pax_global_header00006660000000000000000000000064147574270170014530gustar00rootroot0000000000000052 comment=f289d047f49fb60488301ec62bafab85573668cc KhronosGroup-SPIRV-Tools-f289d04/000077500000000000000000000000001475742701700165315ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/.bazelrc000066400000000000000000000003121475742701700201500ustar00rootroot00000000000000# Enable Bzlmod for every Bazel command common --enable_bzlmod build --enable_platform_specific_config build:linux --cxxopt=-std=c++17 build:macos --cxxopt=-std=c++17 build:windows --cxxopt=/std:c++17 KhronosGroup-SPIRV-Tools-f289d04/.bazelversion000066400000000000000000000000061475742701700212310ustar00rootroot000000000000007.0.2 KhronosGroup-SPIRV-Tools-f289d04/.clang-format000066400000000000000000000001341475742701700211020ustar00rootroot00000000000000--- Language: Cpp BasedOnStyle: Google DerivePointerAlignment: false SortIncludes: true ... KhronosGroup-SPIRV-Tools-f289d04/.github/000077500000000000000000000000001475742701700200715ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/.github/dependabot.yml000066400000000000000000000014221475742701700227200ustar00rootroot00000000000000# Copyright 2023 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. version: 2 updates: - package-ecosystem: github-actions directory: / schedule: interval: daily groups: github-actions: patterns: - "*" open-pull-requests-limit: 3 KhronosGroup-SPIRV-Tools-f289d04/.github/workflows/000077500000000000000000000000001475742701700221265ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/.github/workflows/autoroll.yml000066400000000000000000000033271475742701700245170ustar00rootroot00000000000000name: Update dependencies permissions: contents: read on: schedule: - cron: '0 2 * * *' workflow_dispatch: jobs: update-dependencies: permissions: contents: write pull-requests: write name: Update dependencies runs-on: ubuntu-latest steps: - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2 # Checkout the depot tools they are needed by roll_deps.sh - name: Checkout depot tools run: git clone https://chromium.googlesource.com/chromium/tools/depot_tools.git - name: Update PATH run: echo "$(pwd)/depot_tools" >> $GITHUB_PATH - name: Download dependencies run: python3 utils/git-sync-deps - name: Setup git user information run: | git config user.name "GitHub Actions[bot]" git config user.email "<>" git checkout -b roll_deps - name: Update dependencies run: | utils/roll_deps.sh if [[ `git diff HEAD..origin/main --name-only | wc -l` == 0 ]]; then echo "changed=false" >> $GITHUB_OUTPUT else echo "changed=true" >> $GITHUB_OUTPUT fi id: update_dependencies - name: Push changes and create PR if: steps.update_dependencies.outputs.changed == 'true' run: | git push --force --set-upstream origin roll_deps # Create a PR. If it aready exists, the command fails, so ignore the return code. gh pr create --base main -f || true # Add the 'kokoro:run' label so that the kokoro tests will be run. gh pr edit --add-label 'kokoro:run' gh pr merge --auto --squash env: GITHUB_TOKEN: ${{ github.token }} KhronosGroup-SPIRV-Tools-f289d04/.github/workflows/bazel.yml000066400000000000000000000032601475742701700237470ustar00rootroot00000000000000name: Build and Test with Bazel permissions: contents: read on: push: branches: - 'main' pull_request: jobs: build: timeout-minutes: 120 strategy: matrix: os: [ubuntu-latest, windows-2019] runs-on: ${{matrix.os}} steps: - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2 with: fetch-depth: '0' - name: Download dependencies run: python3 utils/git-sync-deps - name: Mount Bazel cache uses: actions/cache@0c907a75c2c80ebcb7f088228285e798b750cf8f # v4.2.1 with: path: ~/.bazel/cache key: bazel-cache-${{ runner.os }} - name: Build All run: bazel --output_user_root=~/.bazel/cache build //... - name: Test All run: bazel --output_user_root=~/.bazel/cache test //... # iOS is 10x expensive to run on GitHub machines, so only run if we know something else passed # The steps are unfortunately duplicated because github actions requires 2 jobs for a dependency build-macos: needs: build timeout-minutes: 120 runs-on: macos-latest steps: - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2 with: fetch-depth: '0' - name: Download dependencies run: python3 utils/git-sync-deps - name: Mount Bazel cache uses: actions/cache@0c907a75c2c80ebcb7f088228285e798b750cf8f # v4.2.1 with: path: ~/.bazel/cache key: bazel-cache-${{ runner.os }} - name: Build All run: bazel --output_user_root=~/.bazel/cache build //... - name: Test All run: bazel --output_user_root=~/.bazel/cache test //... KhronosGroup-SPIRV-Tools-f289d04/.github/workflows/ios.yml000066400000000000000000000021201475742701700234360ustar00rootroot00000000000000name: iOS permissions: contents: read on: workflow_run: # iOS is 10x expensive to run on GitHub machines, so only run if we know something else passed workflows: ["Wasm Build"] types: - completed jobs: build: runs-on: macos-latest if: ${{ github.event.workflow_run.conclusion == 'success' }} steps: - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2 - uses: lukka/get-cmake@5f6e04f5267c8133f1273bf2103583fc72c46b17 # v3.31.5 - name: Download dependencies run: python3 utils/git-sync-deps # NOTE: The MacOS SDK ships universal binaries. CI should reflect this. - name: Configure Universal Binary for iOS run: | cmake -S . -B build \ -D CMAKE_BUILD_TYPE=Debug \ -D CMAKE_SYSTEM_NAME=iOS \ "-D CMAKE_OSX_ARCHITECTURES=arm64;x86_64" \ -G Ninja env: # Linker warnings as errors LDFLAGS: -Wl,-fatal_warnings - run: cmake --build build - run: cmake --install build --prefix /tmp KhronosGroup-SPIRV-Tools-f289d04/.github/workflows/release.yml000066400000000000000000000013211475742701700242660ustar00rootroot00000000000000name: Create a release branch from release tag permissions: contents: write on: push: tags: - 'v[0-9]+.[0-9]+' - 'vulkan-sdk-[0-9]+.[0-9]+.[0-9]+.[0-9]+' - '!v[0-9]+.[0-9]+.rc*' jobs: prepare-release-job: runs-on: ubuntu-latest steps: - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2 - name: Prepare CHANGELOG for version run: | python utils/generate_changelog.py CHANGES "${{ github.ref_name }}" VERSION_CHANGELOG - name: Create release run: | gh release create -t "Release ${{ github.ref_name }}" -F VERSION_CHANGELOG "${{ github.ref_name }}" env: GITHUB_TOKEN: ${{ github.token }} KhronosGroup-SPIRV-Tools-f289d04/.github/workflows/scorecard.yml000066400000000000000000000040671475742701700246250ustar00rootroot00000000000000name: Scorecard supply-chain security on: # For Branch-Protection check. Only the default branch is supported. See # https://github.com/ossf/scorecard/blob/main/docs/checks.md#branch-protection branch_protection_rule: # To guarantee Maintained check is occasionally updated. See # https://github.com/ossf/scorecard/blob/main/docs/checks.md#maintained schedule: - cron: '36 17 * * 5' push: branches: [ "main" ] # Declare default permissions as read only. permissions: read-all jobs: analysis: name: Scorecard analysis runs-on: ubuntu-latest permissions: security-events: write # to upload the results to code-scanning dashboard id-token: write # to publish results and get a badge steps: - name: "Checkout code" uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2 with: persist-credentials: false - name: "Run analysis" uses: ossf/scorecard-action@f49aabe0b5af0936a0987cfb85d86b75731b0186 # v2.4.1 with: results_file: results.sarif results_format: sarif # To enable Branch-Protection uncomment the `repo_token` line below # To create the Fine-grained PAT, follow the steps in https://github.com/ossf/scorecard-action#authentication-with-fine-grained-pat-optional. # repo_token: ${{ secrets.SCORECARD_TOKEN }} publish_results: true # allows the repo to include the Scorecard badge # Upload the results as artifacts (optional). Commenting out will disable uploads of run results in SARIF # format to the repository Actions tab. - name: "Upload artifact" uses: actions/upload-artifact@4cec3d8aa04e39d1a68397de0c4cd6fb9dce8ec1 # v4.6.1 with: name: SARIF file path: results.sarif retention-days: 5 # Upload the results to GitHub's code scanning dashboard. - name: "Upload to code-scanning" uses: github/codeql-action/upload-sarif@b56ba49b26e50535fa1e7f7db0f4f7b4bf65d80d # v3.28.10 with: sarif_file: results.sarif KhronosGroup-SPIRV-Tools-f289d04/.github/workflows/wasm.yml000066400000000000000000000006451475742701700236250ustar00rootroot00000000000000name: Wasm Build permissions: contents: read on: [push, pull_request] jobs: build: runs-on: ubuntu-latest steps: - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2 with: fetch-depth: '0' - name: Build web run: docker compose -f source/wasm/docker-compose.yml --project-directory . up - name: Run tests run: node test/wasm/test.js KhronosGroup-SPIRV-Tools-f289d04/.gitignore000066400000000000000000000007651475742701700205310ustar00rootroot00000000000000.clang_complete .ycm_extra_conf.py* *.pyc compile_commands.json /build*/ /buildtools/ /external/abseil_cpp/ /external/googletest /external/SPIRV-Headers /external/spirv-headers /external/effcee /external/re2 /external/protobuf /out /TAGS /third_party/llvm-build/ /testing /tools/clang/ /utils/clang-format-diff.py bazel-bin bazel-genfiles bazel-out bazel-spirv-tools bazel-SPIRV-Tools bazel-testlogs MODULE.bazel.lock # Vim [._]*.s[a-w][a-z] *~ # C-Lion /.idea/ /cmake-build-*/ # VSCode /.vscode/* KhronosGroup-SPIRV-Tools-f289d04/.gn000066400000000000000000000013021475742701700171320ustar00rootroot00000000000000# Copyright 2018 Google Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. buildconfig = "//build/config/BUILDCONFIG.gn" default_args = { clang_use_chrome_plugins = false use_custom_libcxx = false } KhronosGroup-SPIRV-Tools-f289d04/Android.mk000066400000000000000000000362671475742701700204600ustar00rootroot00000000000000LOCAL_PATH := $(call my-dir) SPVTOOLS_OUT_PATH=$(if $(call host-path-is-absolute,$(TARGET_OUT)),$(TARGET_OUT),$(abspath $(TARGET_OUT))) ifeq ($(SPVHEADERS_LOCAL_PATH),) SPVHEADERS_LOCAL_PATH := $(LOCAL_PATH)/external/spirv-headers endif SPVTOOLS_SRC_FILES := \ source/assembly_grammar.cpp \ source/binary.cpp \ source/diagnostic.cpp \ source/disassemble.cpp \ source/ext_inst.cpp \ source/enum_string_mapping.cpp \ source/extensions.cpp \ source/libspirv.cpp \ source/name_mapper.cpp \ source/opcode.cpp \ source/operand.cpp \ source/parsed_operand.cpp \ source/print.cpp \ source/software_version.cpp \ source/spirv_endian.cpp \ source/spirv_optimizer_options.cpp \ source/spirv_target_env.cpp \ source/spirv_validator_options.cpp \ source/table.cpp \ source/text.cpp \ source/text_handler.cpp \ source/to_string.cpp \ source/util/bit_vector.cpp \ source/util/parse_number.cpp \ source/util/string_utils.cpp \ source/util/timer.cpp \ source/val/basic_block.cpp \ source/val/construct.cpp \ source/val/function.cpp \ source/val/instruction.cpp \ source/val/validation_state.cpp \ source/val/validate.cpp \ source/val/validate_adjacency.cpp \ source/val/validate_annotation.cpp \ source/val/validate_arithmetics.cpp \ source/val/validate_atomics.cpp \ source/val/validate_barriers.cpp \ source/val/validate_bitwise.cpp \ source/val/validate_builtins.cpp \ source/val/validate_capability.cpp \ source/val/validate_cfg.cpp \ source/val/validate_composites.cpp \ source/val/validate_constants.cpp \ source/val/validate_conversion.cpp \ source/val/validate_debug.cpp \ source/val/validate_decorations.cpp \ source/val/validate_derivatives.cpp \ source/val/validate_extensions.cpp \ source/val/validate_execution_limitations.cpp \ source/val/validate_function.cpp \ source/val/validate_id.cpp \ source/val/validate_image.cpp \ source/val/validate_interfaces.cpp \ source/val/validate_instruction.cpp \ source/val/validate_memory.cpp \ source/val/validate_memory_semantics.cpp \ source/val/validate_mesh_shading.cpp \ source/val/validate_misc.cpp \ source/val/validate_mode_setting.cpp \ source/val/validate_layout.cpp \ source/val/validate_literals.cpp \ source/val/validate_logicals.cpp \ source/val/validate_non_uniform.cpp \ source/val/validate_primitives.cpp \ source/val/validate_ray_query.cpp \ source/val/validate_ray_tracing.cpp \ source/val/validate_ray_tracing_reorder.cpp \ source/val/validate_scopes.cpp \ source/val/validate_small_type_uses.cpp \ source/val/validate_tensor_layout.cpp \ source/val/validate_type.cpp SPVTOOLS_OPT_SRC_FILES := \ source/opt/aggressive_dead_code_elim_pass.cpp \ source/opt/amd_ext_to_khr.cpp \ source/opt/analyze_live_input_pass.cpp \ source/opt/basic_block.cpp \ source/opt/block_merge_pass.cpp \ source/opt/block_merge_util.cpp \ source/opt/build_module.cpp \ source/opt/cfg.cpp \ source/opt/cfg_cleanup_pass.cpp \ source/opt/ccp_pass.cpp \ source/opt/code_sink.cpp \ source/opt/combine_access_chains.cpp \ source/opt/compact_ids_pass.cpp \ source/opt/composite.cpp \ source/opt/const_folding_rules.cpp \ source/opt/constants.cpp \ source/opt/control_dependence.cpp \ source/opt/convert_to_sampled_image_pass.cpp \ source/opt/convert_to_half_pass.cpp \ source/opt/copy_prop_arrays.cpp \ source/opt/dataflow.cpp \ source/opt/dead_branch_elim_pass.cpp \ source/opt/dead_insert_elim_pass.cpp \ source/opt/dead_variable_elimination.cpp \ source/opt/decoration_manager.cpp \ source/opt/debug_info_manager.cpp \ source/opt/def_use_manager.cpp \ source/opt/desc_sroa.cpp \ source/opt/desc_sroa_util.cpp \ source/opt/dominator_analysis.cpp \ source/opt/dominator_tree.cpp \ source/opt/eliminate_dead_constant_pass.cpp \ source/opt/eliminate_dead_functions_pass.cpp \ source/opt/eliminate_dead_functions_util.cpp \ source/opt/eliminate_dead_io_components_pass.cpp \ source/opt/eliminate_dead_members_pass.cpp \ source/opt/eliminate_dead_output_stores_pass.cpp \ source/opt/feature_manager.cpp \ source/opt/fix_func_call_arguments.cpp \ source/opt/fix_storage_class.cpp \ source/opt/flatten_decoration_pass.cpp \ source/opt/fold.cpp \ source/opt/folding_rules.cpp \ source/opt/fold_spec_constant_op_and_composite_pass.cpp \ source/opt/freeze_spec_constant_value_pass.cpp \ source/opt/function.cpp \ source/opt/graphics_robust_access_pass.cpp \ source/opt/if_conversion.cpp \ source/opt/inline_pass.cpp \ source/opt/inline_exhaustive_pass.cpp \ source/opt/inline_opaque_pass.cpp \ source/opt/instruction.cpp \ source/opt/instruction_list.cpp \ source/opt/interface_var_sroa.cpp \ source/opt/interp_fixup_pass.cpp \ source/opt/invocation_interlock_placement_pass.cpp \ source/opt/ir_context.cpp \ source/opt/ir_loader.cpp \ source/opt/licm_pass.cpp \ source/opt/liveness.cpp \ source/opt/local_access_chain_convert_pass.cpp \ source/opt/local_redundancy_elimination.cpp \ source/opt/local_single_block_elim_pass.cpp \ source/opt/local_single_store_elim_pass.cpp \ source/opt/loop_dependence.cpp \ source/opt/loop_dependence_helpers.cpp \ source/opt/loop_descriptor.cpp \ source/opt/loop_fission.cpp \ source/opt/loop_fusion.cpp \ source/opt/loop_fusion_pass.cpp \ source/opt/loop_peeling.cpp \ source/opt/loop_unroller.cpp \ source/opt/loop_unswitch_pass.cpp \ source/opt/loop_utils.cpp \ source/opt/mem_pass.cpp \ source/opt/merge_return_pass.cpp \ source/opt/modify_maximal_reconvergence.cpp \ source/opt/module.cpp \ source/opt/opextinst_forward_ref_fixup_pass.cpp \ source/opt/optimizer.cpp \ source/opt/pass.cpp \ source/opt/pass_manager.cpp \ source/opt/private_to_local_pass.cpp \ source/opt/propagator.cpp \ source/opt/reduce_load_size.cpp \ source/opt/redundancy_elimination.cpp \ source/opt/register_pressure.cpp \ source/opt/relax_float_ops_pass.cpp \ source/opt/remove_dontinline_pass.cpp \ source/opt/remove_duplicates_pass.cpp \ source/opt/remove_unused_interface_variables_pass.cpp \ source/opt/replace_desc_array_access_using_var_index.cpp \ source/opt/replace_invalid_opc.cpp \ source/opt/scalar_analysis.cpp \ source/opt/scalar_analysis_simplification.cpp \ source/opt/scalar_replacement_pass.cpp \ source/opt/set_spec_constant_default_value_pass.cpp \ source/opt/simplification_pass.cpp \ source/opt/spread_volatile_semantics.cpp \ source/opt/ssa_rewrite_pass.cpp \ source/opt/strength_reduction_pass.cpp \ source/opt/strip_debug_info_pass.cpp \ source/opt/strip_nonsemantic_info_pass.cpp \ source/opt/struct_cfg_analysis.cpp \ source/opt/struct_packing_pass.cpp \ source/opt/switch_descriptorset_pass.cpp \ source/opt/trim_capabilities_pass.cpp \ source/opt/type_manager.cpp \ source/opt/types.cpp \ source/opt/unify_const_pass.cpp \ source/opt/upgrade_memory_model.cpp \ source/opt/value_number_table.cpp \ source/opt/vector_dce.cpp \ source/opt/workaround1209.cpp \ source/opt/wrap_opkill.cpp # Locations of grammar files. # SPV_COREUNIFIED1_GRAMMAR=$(SPVHEADERS_LOCAL_PATH)/include/spirv/unified1/spirv.core.grammar.json SPV_GLSL_GRAMMAR=$(SPVHEADERS_LOCAL_PATH)/include/spirv/unified1/extinst.glsl.std.450.grammar.json SPV_OPENCL_GRAMMAR=$(SPVHEADERS_LOCAL_PATH)/include/spirv/unified1/extinst.opencl.std.100.grammar.json SPV_DEBUGINFO_GRAMMAR=$(SPVHEADERS_LOCAL_PATH)/include/spirv/unified1/extinst.debuginfo.grammar.json SPV_CLDEBUGINFO100_GRAMMAR=$(SPVHEADERS_LOCAL_PATH)/include/spirv/unified1/extinst.opencl.debuginfo.100.grammar.json SPV_VKDEBUGINFO100_GRAMMAR=$(SPVHEADERS_LOCAL_PATH)/include/spirv/unified1/extinst.nonsemantic.shader.debuginfo.100.grammar.json define gen_spvtools_grammar_tables $(call generate-file-dir,$(1)/core.insts-unified1.inc) $(1)/core.insts-unified1.inc $(1)/operand.kinds-unified1.inc \ $(1)/glsl.std.450.insts.inc \ $(1)/opencl.std.insts.inc \ : \ $(LOCAL_PATH)/utils/generate_grammar_tables.py \ $(SPV_COREUNIFIED1_GRAMMAR) \ $(SPV_GLSL_GRAMMAR) \ $(SPV_OpenCL_GRAMMAR) \ $(SPV_DEBUGINFO_GRAMMAR) \ $(SPV_CLDEBUGINFO100_GRAMMAR) @$(HOST_PYTHON) $(LOCAL_PATH)/utils/generate_grammar_tables.py \ --spirv-core-grammar=$(SPV_COREUNIFIED1_GRAMMAR) \ --extinst-glsl-grammar=$(SPV_GLSL_GRAMMAR) \ --extinst-opencl-grammar=$(SPV_OPENCL_GRAMMAR) \ --extinst-debuginfo-grammar=$(SPV_DEBUGINFO_GRAMMAR) \ --extinst-cldebuginfo100-grammar=$(SPV_CLDEBUGINFO100_GRAMMAR) \ --core-insts-output=$(1)/core.insts-unified1.inc \ --glsl-insts-output=$(1)/glsl.std.450.insts.inc \ --opencl-insts-output=$(1)/opencl.std.insts.inc \ --operand-kinds-output=$(1)/operand.kinds-unified1.inc \ --output-language=c++ @echo "[$(TARGET_ARCH_ABI)] Grammar (from unified1) : instructions & operands <= grammar JSON files" $(LOCAL_PATH)/source/opcode.cpp: $(1)/core.insts-unified1.inc $(LOCAL_PATH)/source/operand.cpp: $(1)/operand.kinds-unified1.inc $(LOCAL_PATH)/source/ext_inst.cpp: \ $(1)/glsl.std.450.insts.inc \ $(1)/opencl.std.insts.inc \ $(1)/debuginfo.insts.inc \ $(1)/opencl.debuginfo.100.insts.inc \ $(1)/nonsemantic.shader.debuginfo.100.insts.inc \ $(1)/spv-amd-gcn-shader.insts.inc \ $(1)/spv-amd-shader-ballot.insts.inc \ $(1)/spv-amd-shader-explicit-vertex-parameter.insts.inc \ $(1)/spv-amd-shader-trinary-minmax.insts.inc $(LOCAL_PATH)/source/opt/amd_ext_to_khr.cpp: \ $(1)/spv-amd-shader-ballot.insts.inc endef $(eval $(call gen_spvtools_grammar_tables,$(SPVTOOLS_OUT_PATH))) define gen_spvtools_lang_headers # Generate language-specific headers. So far we only generate C headers # $1 is the output directory. # $2 is the base name of the header file, e.g. "DebugInfo". # $3 is the grammar file containing token definitions. $(call generate-file-dir,$(1)/$(2).h) $(1)/$(2).h : \ $(LOCAL_PATH)/utils/generate_language_headers.py \ $(3) @$(HOST_PYTHON) $(LOCAL_PATH)/utils/generate_language_headers.py \ --extinst-grammar=$(3) \ --extinst-output-path=$(1)/$(2).h @echo "[$(TARGET_ARCH_ABI)] Generate language specific header for $(2): headers <= grammar" $(foreach F,$(SPVTOOLS_SRC_FILES) $(SPVTOOLS_OPT_SRC_FILES),$(LOCAL_PATH)/$F ) \ : $(1)/$(2).h endef # We generate language-specific headers for DebugInfo and OpenCL.DebugInfo.100 $(eval $(call gen_spvtools_lang_headers,$(SPVTOOLS_OUT_PATH),DebugInfo,$(SPV_DEBUGINFO_GRAMMAR))) $(eval $(call gen_spvtools_lang_headers,$(SPVTOOLS_OUT_PATH),OpenCLDebugInfo100,$(SPV_CLDEBUGINFO100_GRAMMAR))) $(eval $(call gen_spvtools_lang_headers,$(SPVTOOLS_OUT_PATH),NonSemanticShaderDebugInfo100,$(SPV_VKDEBUGINFO100_GRAMMAR))) define gen_spvtools_vendor_tables $(call generate-file-dir,$(1)/$(2).insts.inc) $(1)/$(2).insts.inc : \ $(LOCAL_PATH)/utils/generate_grammar_tables.py \ $(SPVHEADERS_LOCAL_PATH)/include/spirv/unified1/extinst.$(2).grammar.json @$(HOST_PYTHON) $(LOCAL_PATH)/utils/generate_grammar_tables.py \ --extinst-vendor-grammar=$(SPVHEADERS_LOCAL_PATH)/include/spirv/unified1/extinst.$(2).grammar.json \ --vendor-insts-output=$(1)/$(2).insts.inc \ --vendor-operand-kind-prefix=$(3) @echo "[$(TARGET_ARCH_ABI)] Vendor extended instruction set: $(2) tables <= grammar" $(LOCAL_PATH)/source/ext_inst.cpp: $(1)/$(2).insts.inc endef # Vendor and debug extended instruction sets, with grammars from SPIRV-Tools source tree. $(eval $(call gen_spvtools_vendor_tables,$(SPVTOOLS_OUT_PATH),debuginfo,"")) $(eval $(call gen_spvtools_vendor_tables,$(SPVTOOLS_OUT_PATH),opencl.debuginfo.100,"CLDEBUG100_")) $(eval $(call gen_spvtools_vendor_tables,$(SPVTOOLS_OUT_PATH),nonsemantic.shader.debuginfo.100,"SHDEBUG100_")) $(eval $(call gen_spvtools_vendor_tables,$(SPVTOOLS_OUT_PATH),spv-amd-gcn-shader,"")) $(eval $(call gen_spvtools_vendor_tables,$(SPVTOOLS_OUT_PATH),spv-amd-shader-ballot,"")) $(eval $(call gen_spvtools_vendor_tables,$(SPVTOOLS_OUT_PATH),spv-amd-shader-explicit-vertex-parameter,"")) $(eval $(call gen_spvtools_vendor_tables,$(SPVTOOLS_OUT_PATH),spv-amd-shader-trinary-minmax,"")) $(eval $(call gen_spvtools_vendor_tables,$(SPVTOOLS_OUT_PATH),nonsemantic.clspvreflection,"")) $(eval $(call gen_spvtools_vendor_tables,$(SPVTOOLS_OUT_PATH),nonsemantic.vkspreflection,"")) define gen_spvtools_enum_string_mapping $(call generate-file-dir,$(1)/extension_enum.inc.inc) $(1)/extension_enum.inc $(1)/enum_string_mapping.inc: \ $(LOCAL_PATH)/utils/generate_grammar_tables.py \ $(SPV_COREUNIFIED1_GRAMMAR) @$(HOST_PYTHON) $(LOCAL_PATH)/utils/generate_grammar_tables.py \ --spirv-core-grammar=$(SPV_COREUNIFIED1_GRAMMAR) \ --extinst-debuginfo-grammar=$(SPV_DEBUGINFO_GRAMMAR) \ --extinst-cldebuginfo100-grammar=$(SPV_CLDEBUGINFO100_GRAMMAR) \ --extension-enum-output=$(1)/extension_enum.inc \ --enum-string-mapping-output=$(1)/enum_string_mapping.inc \ --output-language=c++ @echo "[$(TARGET_ARCH_ABI)] Generate enum<->string mapping <= grammar JSON files" # Generated header extension_enum.inc is transitively included by table.h, which is # used pervasively. Capture the pervasive dependency. $(foreach F,$(SPVTOOLS_SRC_FILES) $(SPVTOOLS_OPT_SRC_FILES),$(LOCAL_PATH)/$F ) \ : $(1)/extension_enum.inc $(LOCAL_PATH)/source/enum_string_mapping.cpp: $(1)/enum_string_mapping.inc endef $(eval $(call gen_spvtools_enum_string_mapping,$(SPVTOOLS_OUT_PATH))) define gen_spvtools_build_version_inc $(call generate-file-dir,$(1)/dummy_filename) $(1)/build-version.inc: \ $(LOCAL_PATH)/utils/update_build_version.py \ $(LOCAL_PATH)/CHANGES @$(HOST_PYTHON) $(LOCAL_PATH)/utils/update_build_version.py \ $(LOCAL_PATH)/CHANGES $(1)/build-version.inc @echo "[$(TARGET_ARCH_ABI)] Generate : build-version.inc <= CHANGES" $(LOCAL_PATH)/source/software_version.cpp: $(1)/build-version.inc endef $(eval $(call gen_spvtools_build_version_inc,$(SPVTOOLS_OUT_PATH))) define gen_spvtools_generators_inc $(call generate-file-dir,$(1)/dummy_filename) $(1)/generators.inc: \ $(LOCAL_PATH)/utils/generate_registry_tables.py \ $(SPVHEADERS_LOCAL_PATH)/include/spirv/spir-v.xml @$(HOST_PYTHON) $(LOCAL_PATH)/utils/generate_registry_tables.py \ --xml=$(SPVHEADERS_LOCAL_PATH)/include/spirv/spir-v.xml \ --generator-output=$(1)/generators.inc @echo "[$(TARGET_ARCH_ABI)] Generate : generators.inc <= spir-v.xml" $(LOCAL_PATH)/source/opcode.cpp: $(1)/generators.inc endef $(eval $(call gen_spvtools_generators_inc,$(SPVTOOLS_OUT_PATH))) include $(CLEAR_VARS) LOCAL_MODULE := SPIRV-Tools LOCAL_C_INCLUDES := \ $(LOCAL_PATH)/include \ $(SPVHEADERS_LOCAL_PATH)/include \ $(SPVTOOLS_OUT_PATH) LOCAL_EXPORT_C_INCLUDES := \ $(LOCAL_PATH)/include LOCAL_CXXFLAGS:=-std=c++17 -fno-exceptions -fno-rtti -Werror LOCAL_SRC_FILES:= $(SPVTOOLS_SRC_FILES) include $(BUILD_STATIC_LIBRARY) include $(CLEAR_VARS) LOCAL_MODULE := SPIRV-Tools-opt LOCAL_C_INCLUDES := \ $(LOCAL_PATH)/include \ $(LOCAL_PATH)/source \ $(SPVHEADERS_LOCAL_PATH)/include \ $(SPVTOOLS_OUT_PATH) LOCAL_CXXFLAGS:=-std=c++17 -fno-exceptions -fno-rtti -Werror LOCAL_STATIC_LIBRARIES:=SPIRV-Tools LOCAL_SRC_FILES:= $(SPVTOOLS_OPT_SRC_FILES) include $(BUILD_STATIC_LIBRARY) KhronosGroup-SPIRV-Tools-f289d04/BUILD.bazel000066400000000000000000000414651475742701700204210ustar00rootroot00000000000000load( ":build_defs.bzl", "CLDEBUGINFO100_GRAMMAR_JSON_FILE", "COMMON_COPTS", "DEBUGINFO_GRAMMAR_JSON_FILE", "SHDEBUGINFO100_GRAMMAR_JSON_FILE", "TEST_COPTS", "generate_core_tables", "generate_enum_string_mapping", "generate_extinst_lang_headers", "generate_glsl_tables", "generate_opencl_tables", "generate_vendor_tables", "incompatible_with", ) package( default_visibility = ["//visibility:private"], features = [ "layering_check", ], ) licenses(["notice"]) exports_files([ "CHANGES", "LICENSE", ]) py_binary( name = "generate_grammar_tables", srcs = ["utils/generate_grammar_tables.py"], ) py_binary( name = "generate_language_headers", srcs = ["utils/generate_language_headers.py"], ) generate_core_tables(version = "unified1") generate_enum_string_mapping(version = "unified1") generate_opencl_tables(version = "unified1") generate_glsl_tables(version = "unified1") generate_vendor_tables(extension = "spv-amd-shader-explicit-vertex-parameter") generate_vendor_tables(extension = "spv-amd-shader-trinary-minmax") generate_vendor_tables(extension = "spv-amd-gcn-shader") generate_vendor_tables(extension = "spv-amd-shader-ballot") generate_vendor_tables(extension = "debuginfo") generate_vendor_tables(extension = "nonsemantic.clspvreflection") generate_vendor_tables(extension = "nonsemantic.vkspreflection") generate_vendor_tables( extension = "opencl.debuginfo.100", operand_kind_prefix = "CLDEBUG100_", ) generate_vendor_tables( extension = "nonsemantic.shader.debuginfo.100", operand_kind_prefix = "SHDEBUG100_", ) generate_extinst_lang_headers( name = "DebugInfo", grammar = DEBUGINFO_GRAMMAR_JSON_FILE, ) generate_extinst_lang_headers( name = "OpenCLDebugInfo100", grammar = CLDEBUGINFO100_GRAMMAR_JSON_FILE, ) generate_extinst_lang_headers( name = "NonSemanticShaderDebugInfo100", grammar = SHDEBUGINFO100_GRAMMAR_JSON_FILE, ) py_binary( name = "generate_registry_tables", srcs = ["utils/generate_registry_tables.py"], ) genrule( name = "generators_inc", srcs = ["@spirv_headers//:spirv_xml_registry"], outs = ["generators.inc"], cmd = "$(location :generate_registry_tables) --xml=$(location @spirv_headers//:spirv_xml_registry) --generator-output=$(location generators.inc)", cmd_bat = "$(location :generate_registry_tables) --xml=$(location @spirv_headers//:spirv_xml_registry) --generator-output=$(location generators.inc)", tools = [":generate_registry_tables"], ) py_binary( name = "update_build_version", srcs = ["utils/update_build_version.py"], ) genrule( name = "build_version_inc", srcs = ["CHANGES"], outs = ["build-version.inc"], cmd = "SOURCE_DATE_EPOCH=0 $(location :update_build_version) $(location CHANGES) $(location build-version.inc)", cmd_bat = "set SOURCE_DATE_EPOCH=0 && $(location :update_build_version) $(location CHANGES) $(location build-version.inc)", tools = [":update_build_version"], ) # Libraries cc_library( name = "spirv_tools", hdrs = [ "include/spirv-tools/libspirv.h", "include/spirv-tools/libspirv.hpp", ], copts = COMMON_COPTS, includes = ["include"], linkstatic = 1, visibility = ["//visibility:public"], deps = [ ":spirv_tools_internal", ], ) cc_library( name = "spirv_tools_internal", srcs = glob([ "source/*.cpp", "source/util/*.cpp", "source/val/*.cpp", ]) + [ ":build_version_inc", ":gen_core_tables_unified1", ":gen_enum_string_mapping", ":gen_extinst_lang_headers_DebugInfo", ":gen_extinst_lang_headers_NonSemanticShaderDebugInfo100", ":gen_extinst_lang_headers_OpenCLDebugInfo100", ":gen_glsl_tables_unified1", ":gen_opencl_tables_unified1", ":gen_vendor_tables_debuginfo", ":gen_vendor_tables_nonsemantic_clspvreflection", ":gen_vendor_tables_nonsemantic_vkspreflection", ":gen_vendor_tables_nonsemantic_shader_debuginfo_100", ":gen_vendor_tables_opencl_debuginfo_100", ":gen_vendor_tables_spv_amd_gcn_shader", ":gen_vendor_tables_spv_amd_shader_ballot", ":gen_vendor_tables_spv_amd_shader_explicit_vertex_parameter", ":gen_vendor_tables_spv_amd_shader_trinary_minmax", ":generators_inc", ], hdrs = [ "include/spirv-tools/libspirv.h", "include/spirv-tools/libspirv.hpp", ":gen_extinst_lang_headers_DebugInfo", ":gen_extinst_lang_headers_NonSemanticShaderDebugInfo100", ":gen_extinst_lang_headers_OpenCLDebugInfo100", ] + glob([ "source/*.h", "source/util/*.h", "source/val/*.h", ]), copts = COMMON_COPTS, includes = ["include"], deps = [ "@spirv_headers//:spirv_common_headers", "@spirv_headers//:spirv_cpp11_headers", ], ) cc_library( name = "spirv_tools_opt", hdrs = [ "include/spirv-tools/optimizer.hpp", ], copts = COMMON_COPTS, linkstatic = 1, visibility = ["//visibility:public"], deps = [ ":spirv_tools", ":spirv_tools_opt_internal", ], ) cc_library( name = "spirv_tools_opt_internal", srcs = glob(["source/opt/*.cpp"]) + [ ":gen_vendor_tables_spv_amd_shader_ballot", ], hdrs = glob(["source/opt/*.h"]) + [ "include/spirv-tools/optimizer.hpp", ], copts = COMMON_COPTS, deps = [ ":spirv_tools_internal", "@spirv_headers//:spirv_common_headers", ], ) cc_library( name = "spirv_tools_reduce", srcs = glob(["source/reduce/*.cpp"]), hdrs = glob(["source/reduce/*.h"]), copts = COMMON_COPTS, deps = [ ":spirv_tools_internal", ":spirv_tools_opt_internal", ], ) cc_library( name = "spirv_tools_link", srcs = glob(["source/link/*.cpp"]), hdrs = ["include/spirv-tools/linker.hpp"], copts = COMMON_COPTS, linkstatic = 1, visibility = ["//visibility:public"], deps = [ ":spirv_tools_internal", ":spirv_tools_opt_internal", ], ) cc_library( name = "spirv_tools_lint_internal", srcs = glob([ "source/lint/*.cpp", "source/lint/*.h", ]), hdrs = ["include/spirv-tools/linter.hpp"] + glob([ "source/lint/*.h", ]), copts = COMMON_COPTS, includes = ["include"], deps = [ ":spirv_tools_internal", ":spirv_tools_opt_internal", ], ) cc_library( name = "spirv_tools_lint", hdrs = ["include/spirv-tools/linter.hpp"], copts = COMMON_COPTS, includes = ["include"], linkstatic = 1, visibility = ["//visibility:public"], deps = [ ":spirv_tools", ":spirv_tools_lint_internal", ], ) cc_library( name = "tools_util", srcs = glob(["tools/util/*.cpp"]), hdrs = glob(["tools/util/*.h"]), copts = COMMON_COPTS, deps = [":spirv_tools"], ) cc_library( name = "tools_io", hdrs = ["tools/io.h"], srcs = ["tools/io.cpp"], copts = COMMON_COPTS, ) # Tools cc_binary( name = "spirv-as", srcs = [ "tools/as/as.cpp", ], copts = COMMON_COPTS, visibility = ["//visibility:public"], deps = [ ":spirv_tools_internal", ":tools_io", ":tools_util", ], ) cc_binary( name = "spirv-dis", srcs = [ "tools/dis/dis.cpp", ], copts = COMMON_COPTS, visibility = ["//visibility:public"], deps = [ ":spirv_tools", ":tools_io", ":tools_util", ], ) cc_binary( name = "spirv-objdump", srcs = [ "tools/objdump/extract_source.cpp", "tools/objdump/extract_source.h", "tools/objdump/objdump.cpp", ], copts = COMMON_COPTS, visibility = ["//visibility:public"], deps = [ ":spirv_tools_internal", ":spirv_tools_opt_internal", ":tools_io", ":tools_util", "@spirv_headers//:spirv_cpp_headers", ], ) cc_binary( name = "spirv-val", srcs = [ "tools/val/val.cpp", ], copts = COMMON_COPTS, visibility = ["//visibility:public"], deps = [ ":spirv_tools_internal", ":tools_io", ":tools_util", ], ) cc_binary( name = "spirv-opt", srcs = [ "tools/opt/opt.cpp", ], copts = COMMON_COPTS, visibility = ["//visibility:public"], deps = [ ":spirv_tools_internal", ":spirv_tools_opt_internal", ":tools_io", ":tools_util", ], ) cc_binary( name = "spirv-reduce", srcs = [ "tools/reduce/reduce.cpp", ], copts = COMMON_COPTS, visibility = ["//visibility:public"], deps = [ ":spirv_tools_internal", ":spirv_tools_opt_internal", ":spirv_tools_reduce", ":tools_io", ":tools_util", ], ) cc_binary( name = "spirv-link", srcs = [ "tools/link/linker.cpp", ], copts = COMMON_COPTS, visibility = ["//visibility:public"], deps = [ ":spirv_tools_internal", ":spirv_tools_link", ":tools_io", ":tools_util", ], ) cc_binary( name = "spirv-lint", srcs = [ "tools/lint/lint.cpp", ], copts = COMMON_COPTS, visibility = ["//visibility:public"], deps = [ ":spirv_tools_lint", ":spirv_tools_opt_internal", ":tools_io", ":tools_util", ], ) cc_binary( name = "spirv-cfg", srcs = [ "tools/cfg/bin_to_dot.cpp", "tools/cfg/bin_to_dot.h", "tools/cfg/cfg.cpp", ], copts = COMMON_COPTS, visibility = ["//visibility:public"], deps = [ ":spirv_tools_internal", ":tools_io", ":tools_util", ], ) # Unit tests cc_library( name = "test_lib", testonly = 1, srcs = [ "test/unit_spirv.cpp", ], hdrs = [ "test/test_fixture.h", "test/unit_spirv.h", ], copts = TEST_COPTS, deps = [ ":spirv_tools_internal", "@googletest//:gtest", ], ) # PCH (precompiled header) tests only work when using CMake and MSVC on Windows, # so they will be skipped in the Bazel builds. [cc_test( name = "base_{testcase}_test".format(testcase = f[len("test/"):-len("_test.cpp")]), size = "small", srcs = [f], copts = TEST_COPTS + ["-DTESTING"], linkstatic = 1, target_compatible_with = { "test/timer_test.cpp": incompatible_with(["@bazel_tools//src/conditions:windows"]), }.get(f, []), deps = [ "tools_util", ":spirv_tools_internal", ":test_lib", ":tools_io", "@googletest//:gtest", "@googletest//:gtest_main", ], ) for f in glob( [ "test/*_test.cpp", "test/tools/*_test.cpp", ], exclude = [ "test/cpp_interface_test.cpp", "test/pch_test.cpp", ], )] cc_test( name = "base_cpp_interface_test", size = "small", srcs = ["test/cpp_interface_test.cpp"], linkstatic = 1, deps = [ ":spirv_tools_opt_internal", "@googletest//:gtest", "@googletest//:gtest_main", "@spirv_headers//:spirv_cpp11_headers", ], ) cc_test( name = "base_ilist_test", size = "small", srcs = ["test/util/ilist_test.cpp"], copts = TEST_COPTS, linkstatic = 1, deps = [ ":spirv_tools_internal", "@googletest//:gtest", "@googletest//:gtest_main", ], ) cc_library( name = "link_test_lib", testonly = 1, hdrs = ["test/link/linker_fixture.h"], copts = TEST_COPTS, deps = [ ":spirv_tools_internal", ":spirv_tools_link", ":test_lib", "@effcee//:effcee", "@re2//:re2", ], ) [cc_test( name = "link_{testcase}_test".format(testcase = f[len("test/link/"):-len("_test.cpp")]), size = "small", srcs = [f], copts = TEST_COPTS, linkstatic = 1, deps = [ ":link_test_lib", "@googletest//:gtest", "@googletest//:gtest_main", ], ) for f in glob( ["test/link/*_test.cpp"], )] [cc_test( name = "lint_{testcase}_test".format(testcase = f[len("test/lint/"):-len("_test.cpp")]), size = "small", srcs = [f], copts = TEST_COPTS, linkstatic = 1, deps = [ ":spirv_tools", ":spirv_tools_lint_internal", ":spirv_tools_opt_internal", "@googletest//:gtest", "@googletest//:gtest_main", ], ) for f in glob( ["test/lint/*_test.cpp"], )] cc_library( name = "opt_test_lib", testonly = 1, srcs = [ "test/opt/pass_utils.cpp", ], hdrs = [ "test/opt/assembly_builder.h", "test/opt/function_utils.h", "test/opt/module_utils.h", "test/opt/pass_fixture.h", "test/opt/pass_utils.h", ], copts = TEST_COPTS, deps = [ ":spirv_tools_internal", ":spirv_tools_opt_internal", "@effcee//:effcee", "@googletest//:gtest", ], ) [cc_test( name = "opt_{testcase}_test".format(testcase = f[len("test/opt/"):-len("_test.cpp")]), size = "small", srcs = [f], copts = TEST_COPTS, linkstatic = 1, deps = [ ":opt_test_lib", ":spirv_tools_internal", ":spirv_tools_opt_internal", ":test_lib", "@effcee//:effcee", "@googletest//:gtest", "@googletest//:gtest_main", ], ) for f in glob(["test/opt/*_test.cpp"])] [cc_test( name = "opt_dom_tree_{testcase}_test".format(testcase = f[len("test/opt/dominator_tree/"):-len(".cpp")]), size = "small", srcs = [f], copts = TEST_COPTS, linkstatic = 1, deps = [ ":opt_test_lib", ":spirv_tools_opt_internal", "@googletest//:gtest", "@googletest//:gtest_main", ], ) for f in glob( ["test/opt/dominator_tree/*.cpp"], exclude = ["test/opt/dominator_tree/pch_test_opt_dom.cpp"], )] [cc_test( name = "opt_loop_{testcase}_test".format(testcase = f[len("test/opt/loop_optimizations/"):-len(".cpp")]), size = "small", srcs = [f], copts = TEST_COPTS, linkstatic = 1, deps = [ ":opt_test_lib", ":spirv_tools", ":spirv_tools_opt_internal", "@effcee//:effcee", "@googletest//:gtest", "@googletest//:gtest_main", ], ) for f in glob( ["test/opt/loop_optimizations/*.cpp"], exclude = ["test/opt/loop_optimizations/pch_test_opt_loop.cpp"], )] cc_library( name = "reduce_test_lib", testonly = 1, srcs = [ "test/reduce/reduce_test_util.cpp", ], hdrs = ["test/reduce/reduce_test_util.h"], copts = TEST_COPTS, deps = [ ":spirv_tools", ":spirv_tools_opt_internal", ":spirv_tools_reduce", ":test_lib", ":tools_io", "@googletest//:gtest", ], ) [cc_test( name = "reduce_{testcase}_test".format(testcase = f[len("test/reduce/"):-len("_test.cpp")]), size = "small", srcs = [f], copts = TEST_COPTS, linkstatic = 1, deps = [ ":reduce_test_lib", ":spirv_tools_internal", ":spirv_tools_opt_internal", ":spirv_tools_reduce", "@googletest//:gtest_main", ], ) for f in glob(["test/reduce/*_test.cpp"])] [cc_test( name = "util_{testcase}_test".format(testcase = f[len("test/util/"):-len("_test.cpp")]), size = "small", srcs = [f], copts = TEST_COPTS, linkstatic = 1, deps = [ ":spirv_tools_internal", "@googletest//:gtest", "@googletest//:gtest_main", ], ) for f in glob(["test/util/*_test.cpp"])] cc_library( name = "val_test_lib", testonly = 1, srcs = [ "test/val/val_code_generator.cpp", ], hdrs = [ "test/val/val_code_generator.h", "test/val/val_fixtures.h", ], copts = TEST_COPTS, deps = [ ":spirv_tools_internal", ":test_lib", ], ) [cc_test( name = "val_{testcase}_test".format(testcase = f[len("test/val/val_"):-len("_test.cpp")]), size = "small", srcs = [f], copts = TEST_COPTS, linkstatic = 1, deps = [ ":spirv_tools_internal", ":test_lib", ":val_test_lib", "@googletest//:gtest", "@googletest//:gtest_main", ], ) for f in glob( ["test/val/val_*_test.cpp"], exclude = [ "test/val/val_capability_test.cpp", "test/val/val_limits_test.cpp", ], )] cc_test( name = "val_capability_test", size = "large", timeout = "long", srcs = ["test/val/val_capability_test.cpp"], copts = TEST_COPTS + ["-O3"], linkstatic = 1, deps = [ ":spirv_tools_internal", ":test_lib", ":val_test_lib", "@googletest//:gtest", "@googletest//:gtest_main", ], ) cc_test( name = "val_limits_test", size = "large", timeout = "long", srcs = ["test/val/val_limits_test.cpp"], copts = TEST_COPTS + [ "-O3", ], linkstatic = 1, deps = [ ":test_lib", ":val_test_lib", "@googletest//:gtest", "@googletest//:gtest_main", ], ) KhronosGroup-SPIRV-Tools-f289d04/BUILD.gn000066400000000000000000001741741475742701700177340ustar00rootroot00000000000000# Copyright 2018 Google Inc. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import("//build_overrides/build.gni") import("//build_overrides/spirv_tools.gni") if (build_with_chromium) { import("//testing/test.gni") import("//third_party/protobuf/proto_library.gni") } # SPIRV-Tools may be part of multiple projects in the Chromium tree. # Only enable building executables if this is the main copy. abspath = get_path_info(".", "abspath") spvtools_chromium_third_party = (abspath == "//third_party/vulkan-deps/spirv-tools/src/") spvtools_build_executables = build_with_chromium && spvtools_chromium_third_party # Fuchsia also requires building the executables. # TODO(b/158002593): Avoid the use of dependent-specific variables. if (defined(is_fuchsia_tree) && is_fuchsia_tree) { spvtools_build_executables = true } spirv_headers = spirv_tools_spirv_headers_dir spirv_is_winuwp = is_win && target_os == "winuwp" template("spvtools_core_tables") { assert(defined(invoker.version), "Need version in $target_name generation.") action("spvtools_core_tables_" + target_name) { script = "utils/generate_grammar_tables.py" version = invoker.version core_json_file = "${spirv_headers}/include/spirv/$version/spirv.core.grammar.json" core_insts_file = "${target_gen_dir}/core.insts-$version.inc" operand_kinds_file = "${target_gen_dir}/operand.kinds-$version.inc" debuginfo_insts_file = "${spirv_headers}/include/spirv/unified1/extinst.debuginfo.grammar.json" cldebuginfo100_insts_file = "${spirv_headers}/include/spirv/unified1/extinst.opencl.debuginfo.100.grammar.json" sources = [ cldebuginfo100_insts_file, core_json_file, debuginfo_insts_file, ] outputs = [ core_insts_file, operand_kinds_file, ] args = [ "--spirv-core-grammar", rebase_path(core_json_file, root_build_dir), "--core-insts-output", rebase_path(core_insts_file, root_build_dir), "--extinst-debuginfo-grammar", rebase_path(debuginfo_insts_file, root_build_dir), "--extinst-cldebuginfo100-grammar", rebase_path(cldebuginfo100_insts_file, root_build_dir), "--operand-kinds-output", rebase_path(operand_kinds_file, root_build_dir), "--output-language", "c++" ] } } template("spvtools_core_enums") { assert(defined(invoker.version), "Need version in $target_name generation.") action("spvtools_core_enums_" + target_name) { script = "utils/generate_grammar_tables.py" version = invoker.version core_json_file = "${spirv_headers}/include/spirv/$version/spirv.core.grammar.json" debuginfo_insts_file = "${spirv_headers}/include/spirv/unified1/extinst.debuginfo.grammar.json" cldebuginfo100_insts_file = "${spirv_headers}/include/spirv/unified1/extinst.opencl.debuginfo.100.grammar.json" extension_enum_file = "${target_gen_dir}/extension_enum.inc" extension_map_file = "${target_gen_dir}/enum_string_mapping.inc" args = [ "--spirv-core-grammar", rebase_path(core_json_file, root_build_dir), "--extinst-debuginfo-grammar", rebase_path(debuginfo_insts_file, root_build_dir), "--extinst-cldebuginfo100-grammar", rebase_path(cldebuginfo100_insts_file, root_build_dir), "--extension-enum-output", rebase_path(extension_enum_file, root_build_dir), "--enum-string-mapping-output", rebase_path(extension_map_file, root_build_dir), "--output-language", "c++" ] inputs = [ core_json_file, debuginfo_insts_file, cldebuginfo100_insts_file, ] outputs = [ extension_enum_file, extension_map_file, ] } } template("spvtools_glsl_tables") { assert(defined(invoker.version), "Need version in $target_name generation.") action("spvtools_glsl_tables_" + target_name) { script = "utils/generate_grammar_tables.py" version = invoker.version core_json_file = "${spirv_headers}/include/spirv/$version/spirv.core.grammar.json" glsl_json_file = "${spirv_headers}/include/spirv/${version}/extinst.glsl.std.450.grammar.json" debuginfo_insts_file = "${spirv_headers}/include/spirv/unified1/extinst.debuginfo.grammar.json" cldebuginfo100_insts_file = "${spirv_headers}/include/spirv/unified1/extinst.opencl.debuginfo.100.grammar.json" glsl_insts_file = "${target_gen_dir}/glsl.std.450.insts.inc" args = [ "--spirv-core-grammar", rebase_path(core_json_file, root_build_dir), "--extinst-debuginfo-grammar", rebase_path(debuginfo_insts_file, root_build_dir), "--extinst-cldebuginfo100-grammar", rebase_path(cldebuginfo100_insts_file, root_build_dir), "--extinst-glsl-grammar", rebase_path(glsl_json_file, root_build_dir), "--glsl-insts-output", rebase_path(glsl_insts_file, root_build_dir), "--output-language", "c++" ] inputs = [ core_json_file, glsl_json_file, debuginfo_insts_file, cldebuginfo100_insts_file, ] outputs = [ glsl_insts_file ] } } template("spvtools_opencl_tables") { assert(defined(invoker.version), "Need version in $target_name generation.") action("spvtools_opencl_tables_" + target_name) { script = "utils/generate_grammar_tables.py" version = invoker.version core_json_file = "${spirv_headers}/include/spirv/$version/spirv.core.grammar.json" opencl_json_file = "${spirv_headers}/include/spirv/${version}/extinst.opencl.std.100.grammar.json" debuginfo_insts_file = "${spirv_headers}/include/spirv/unified1/extinst.debuginfo.grammar.json" cldebuginfo100_insts_file = "${spirv_headers}/include/spirv/unified1/extinst.opencl.debuginfo.100.grammar.json" opencl_insts_file = "${target_gen_dir}/opencl.std.insts.inc" args = [ "--spirv-core-grammar", rebase_path(core_json_file, root_build_dir), "--extinst-debuginfo-grammar", rebase_path(debuginfo_insts_file, root_build_dir), "--extinst-cldebuginfo100-grammar", rebase_path(cldebuginfo100_insts_file, root_build_dir), "--extinst-opencl-grammar", rebase_path(opencl_json_file, root_build_dir), "--opencl-insts-output", rebase_path(opencl_insts_file, root_build_dir), ] inputs = [ core_json_file, opencl_json_file, debuginfo_insts_file, cldebuginfo100_insts_file, ] outputs = [ opencl_insts_file ] } } template("spvtools_language_header") { assert(defined(invoker.name), "Need name in $target_name generation.") action("spvtools_language_header_" + target_name) { script = "utils/generate_language_headers.py" name = invoker.name extinst_output_path = "${target_gen_dir}/${name}.h" args = [ "--extinst-grammar", rebase_path(invoker.grammar_file, root_build_dir), "--extinst-output-path", rebase_path(extinst_output_path, root_build_dir), ] inputs = [ invoker.grammar_file ] outputs = [ "${extinst_output_path}" ] } } template("spvtools_vendor_table") { assert(defined(invoker.name), "Need name in $target_name generation.") action("spvtools_vendor_tables_" + target_name) { script = "utils/generate_grammar_tables.py" name = invoker.name extinst_vendor_grammar = "${spirv_headers}/include/spirv/unified1/extinst.${name}.grammar.json" extinst_file = "${target_gen_dir}/${name}.insts.inc" args = [ "--extinst-vendor-grammar", rebase_path(extinst_vendor_grammar, root_build_dir), "--vendor-insts-output", rebase_path(extinst_file, root_build_dir), "--vendor-operand-kind-prefix", invoker.operand_kind_prefix, ] inputs = [ extinst_vendor_grammar ] outputs = [ extinst_file ] } } action("spvtools_generators_inc") { script = "utils/generate_registry_tables.py" # TODO(dsinclair): Make work for chrome xml_file = "${spirv_headers}/include/spirv/spir-v.xml" inc_file = "${target_gen_dir}/generators.inc" sources = [ xml_file ] outputs = [ inc_file ] args = [ "--xml", rebase_path(xml_file, root_build_dir), "--generator", rebase_path(inc_file, root_build_dir), ] } action("spvtools_build_version") { script = "utils/update_build_version.py" changes_file = "CHANGES" inc_file = "${target_gen_dir}/build-version.inc" outputs = [ inc_file ] args = [ rebase_path(changes_file, root_build_dir), rebase_path(inc_file, root_build_dir), ] } spvtools_core_tables("unified1") { version = "unified1" } spvtools_core_enums("unified1") { version = "unified1" } spvtools_glsl_tables("glsl1-0") { version = "1.0" } spvtools_opencl_tables("opencl1-0") { version = "1.0" } spvtools_language_header("debuginfo") { name = "DebugInfo" grammar_file = "${spirv_headers}/include/spirv/unified1/extinst.debuginfo.grammar.json" } spvtools_language_header("cldebuginfo100") { name = "OpenCLDebugInfo100" grammar_file = "${spirv_headers}/include/spirv/unified1/extinst.opencl.debuginfo.100.grammar.json" } spvtools_language_header("vkdebuginfo100") { name = "NonSemanticShaderDebugInfo100" grammar_file = "${spirv_headers}/include/spirv/unified1/extinst.nonsemantic.shader.debuginfo.100.grammar.json" } spvtools_vendor_tables = [ [ "spv-amd-shader-explicit-vertex-parameter", "...nil...", ], [ "spv-amd-shader-trinary-minmax", "...nil...", ], [ "spv-amd-gcn-shader", "...nil...", ], [ "spv-amd-shader-ballot", "...nil...", ], [ "debuginfo", "...nil...", ], [ "opencl.debuginfo.100", "CLDEBUG100_", ], [ "nonsemantic.clspvreflection", "...nil...", ], [ "nonsemantic.vkspreflection", "...nil...", ], [ "nonsemantic.shader.debuginfo.100", "SHDEBUG100_", ], ] foreach(table_def, spvtools_vendor_tables) { spvtools_vendor_table(table_def[0]) { name = table_def[0] operand_kind_prefix = table_def[1] } } config("spvtools_public_config") { include_dirs = [ "include" ] } config("spvtools_include_gen_dirs") { include_dirs = [ "$target_gen_dir" ] } config("spvtools_internal_config") { include_dirs = [ ".", "${spirv_headers}/include", ] configs = [ ":spvtools_public_config", ":spvtools_include_gen_dirs", ] cflags = [] if (is_clang) { cflags += [ "-Wno-implicit-fallthrough", "-Wno-newline-eof", "-Wno-unreachable-code-break", "-Wno-unreachable-code-return", ] } else if (!is_win) { # Work around a false-positive on a Skia GCC 10 builder. cflags += [ "-Wno-format-truncation" ] } else { # Make MSVC report the correct value for __cplusplus cflags += [ "/Zc:__cplusplus" ] } if (!is_win) { cflags += [ "-std=c++17" ] } else { cflags += [ "/std:c++17" ] } } source_set("spvtools_headers") { sources = [ "include/spirv-tools/libspirv.h", "include/spirv-tools/libspirv.hpp", "include/spirv-tools/linker.hpp", "include/spirv-tools/optimizer.hpp", ] public_configs = [ ":spvtools_public_config" ] } group("spvtools_language_headers") { public_deps = [ ":spvtools_language_header_cldebuginfo100", ":spvtools_language_header_debuginfo", ":spvtools_language_header_vkdebuginfo100", ] } static_library("spvtools") { deps = [ ":spvtools_core_tables_unified1", ":spvtools_generators_inc", ":spvtools_glsl_tables_glsl1-0", ":spvtools_language_header_cldebuginfo100", ":spvtools_language_header_debuginfo", ":spvtools_language_header_vkdebuginfo100", ":spvtools_opencl_tables_opencl1-0", ] foreach(table_def, spvtools_vendor_tables) { target_name = table_def[0] deps += [ ":spvtools_vendor_tables_$target_name" ] } sources = [ "source/assembly_grammar.cpp", "source/assembly_grammar.h", "source/binary.cpp", "source/binary.h", "source/cfa.h", "source/common_debug_info.h", "source/diagnostic.cpp", "source/diagnostic.h", "source/disassemble.cpp", "source/disassemble.h", "source/enum_set.h", "source/enum_string_mapping.cpp", "source/enum_string_mapping.h", "source/ext_inst.cpp", "source/ext_inst.h", "source/extensions.cpp", "source/extensions.h", "source/instruction.h", "source/latest_version_glsl_std_450_header.h", "source/latest_version_opencl_std_header.h", "source/latest_version_spirv_header.h", "source/libspirv.cpp", "source/macro.h", "source/name_mapper.cpp", "source/name_mapper.h", "source/opcode.cpp", "source/opcode.h", "source/operand.cpp", "source/operand.h", "source/parsed_operand.cpp", "source/parsed_operand.h", "source/print.cpp", "source/print.h", "source/spirv_constant.h", "source/spirv_definition.h", "source/spirv_endian.cpp", "source/spirv_endian.h", "source/spirv_fuzzer_options.cpp", "source/spirv_fuzzer_options.h", "source/spirv_optimizer_options.cpp", "source/spirv_optimizer_options.h", "source/spirv_reducer_options.cpp", "source/spirv_reducer_options.h", "source/spirv_target_env.cpp", "source/spirv_target_env.h", "source/spirv_validator_options.cpp", "source/spirv_validator_options.h", "source/table.cpp", "source/table.h", "source/text.cpp", "source/text.h", "source/text_handler.cpp", "source/text_handler.h", "source/to_string.cpp", "source/to_string.h", "source/util/bit_vector.cpp", "source/util/bit_vector.h", "source/util/bitutils.h", "source/util/hash_combine.h", "source/util/hex_float.h", "source/util/ilist.h", "source/util/ilist_node.h", "source/util/make_unique.h", "source/util/parse_number.cpp", "source/util/parse_number.h", "source/util/small_vector.h", "source/util/string_utils.cpp", "source/util/string_utils.h", "source/util/timer.cpp", "source/util/timer.h", ] public_deps = [ ":spvtools_core_enums_unified1", ":spvtools_headers", "${spirv_headers}:spv_headers", ] if (build_with_chromium) { configs -= [ "//build/config/compiler:chromium_code" ] configs += [ "//build/config/compiler:no_chromium_code" ] } configs += [ ":spvtools_internal_config" ] } static_library("spvtools_val") { sources = [ "source/val/basic_block.cpp", "source/val/basic_block.h", "source/val/construct.cpp", "source/val/construct.h", "source/val/decoration.h", "source/val/function.cpp", "source/val/function.h", "source/val/instruction.cpp", "source/val/validate.cpp", "source/val/validate.h", "source/val/validate_adjacency.cpp", "source/val/validate_annotation.cpp", "source/val/validate_arithmetics.cpp", "source/val/validate_atomics.cpp", "source/val/validate_barriers.cpp", "source/val/validate_bitwise.cpp", "source/val/validate_builtins.cpp", "source/val/validate_capability.cpp", "source/val/validate_cfg.cpp", "source/val/validate_composites.cpp", "source/val/validate_constants.cpp", "source/val/validate_conversion.cpp", "source/val/validate_debug.cpp", "source/val/validate_decorations.cpp", "source/val/validate_derivatives.cpp", "source/val/validate_execution_limitations.cpp", "source/val/validate_extensions.cpp", "source/val/validate_function.cpp", "source/val/validate_id.cpp", "source/val/validate_image.cpp", "source/val/validate_instruction.cpp", "source/val/validate_interfaces.cpp", "source/val/validate_layout.cpp", "source/val/validate_literals.cpp", "source/val/validate_logicals.cpp", "source/val/validate_memory.cpp", "source/val/validate_memory_semantics.cpp", "source/val/validate_memory_semantics.h", "source/val/validate_mesh_shading.cpp", "source/val/validate_misc.cpp", "source/val/validate_mode_setting.cpp", "source/val/validate_non_uniform.cpp", "source/val/validate_primitives.cpp", "source/val/validate_ray_query.cpp", "source/val/validate_ray_tracing.cpp", "source/val/validate_ray_tracing_reorder.cpp", "source/val/validate_scopes.cpp", "source/val/validate_scopes.h", "source/val/validate_small_type_uses.cpp", "source/val/validate_tensor_layout.cpp", "source/val/validate_type.cpp", "source/val/validation_state.cpp", "source/val/validation_state.h", ] deps = [ ":spvtools", ":spvtools_language_header_cldebuginfo100", ":spvtools_language_header_debuginfo", ":spvtools_language_header_vkdebuginfo100", ] public_deps = [ ":spvtools_headers" ] if (build_with_chromium) { configs -= [ "//build/config/compiler:chromium_code" ] configs += [ "//build/config/compiler:no_chromium_code" ] } configs += [ ":spvtools_internal_config" ] } static_library("spvtools_opt") { sources = [ "source/opt/aggressive_dead_code_elim_pass.cpp", "source/opt/aggressive_dead_code_elim_pass.h", "source/opt/amd_ext_to_khr.cpp", "source/opt/amd_ext_to_khr.h", "source/opt/analyze_live_input_pass.cpp", "source/opt/analyze_live_input_pass.h", "source/opt/basic_block.cpp", "source/opt/basic_block.h", "source/opt/block_merge_pass.cpp", "source/opt/block_merge_pass.h", "source/opt/block_merge_util.cpp", "source/opt/block_merge_util.h", "source/opt/build_module.cpp", "source/opt/build_module.h", "source/opt/ccp_pass.cpp", "source/opt/ccp_pass.h", "source/opt/cfg.cpp", "source/opt/cfg.h", "source/opt/cfg_cleanup_pass.cpp", "source/opt/cfg_cleanup_pass.h", "source/opt/code_sink.cpp", "source/opt/code_sink.h", "source/opt/combine_access_chains.cpp", "source/opt/combine_access_chains.h", "source/opt/compact_ids_pass.cpp", "source/opt/compact_ids_pass.h", "source/opt/composite.cpp", "source/opt/composite.h", "source/opt/const_folding_rules.cpp", "source/opt/const_folding_rules.h", "source/opt/constants.cpp", "source/opt/constants.h", "source/opt/control_dependence.cpp", "source/opt/control_dependence.h", "source/opt/convert_to_half_pass.cpp", "source/opt/convert_to_half_pass.h", "source/opt/convert_to_sampled_image_pass.cpp", "source/opt/convert_to_sampled_image_pass.h", "source/opt/copy_prop_arrays.cpp", "source/opt/copy_prop_arrays.h", "source/opt/dataflow.cpp", "source/opt/dataflow.h", "source/opt/dead_branch_elim_pass.cpp", "source/opt/dead_branch_elim_pass.h", "source/opt/dead_insert_elim_pass.cpp", "source/opt/dead_insert_elim_pass.h", "source/opt/dead_variable_elimination.cpp", "source/opt/dead_variable_elimination.h", "source/opt/debug_info_manager.cpp", "source/opt/debug_info_manager.h", "source/opt/decoration_manager.cpp", "source/opt/decoration_manager.h", "source/opt/def_use_manager.cpp", "source/opt/def_use_manager.h", "source/opt/desc_sroa.cpp", "source/opt/desc_sroa.h", "source/opt/desc_sroa_util.cpp", "source/opt/desc_sroa_util.h", "source/opt/dominator_analysis.cpp", "source/opt/dominator_analysis.h", "source/opt/dominator_tree.cpp", "source/opt/dominator_tree.h", "source/opt/eliminate_dead_constant_pass.cpp", "source/opt/eliminate_dead_constant_pass.h", "source/opt/eliminate_dead_functions_pass.cpp", "source/opt/eliminate_dead_functions_pass.h", "source/opt/eliminate_dead_functions_util.cpp", "source/opt/eliminate_dead_functions_util.h", "source/opt/eliminate_dead_io_components_pass.cpp", "source/opt/eliminate_dead_io_components_pass.h", "source/opt/eliminate_dead_members_pass.cpp", "source/opt/eliminate_dead_members_pass.h", "source/opt/eliminate_dead_output_stores_pass.cpp", "source/opt/eliminate_dead_output_stores_pass.h", "source/opt/empty_pass.h", "source/opt/feature_manager.cpp", "source/opt/feature_manager.h", "source/opt/fix_func_call_arguments.cpp", "source/opt/fix_func_call_arguments.h", "source/opt/fix_storage_class.cpp", "source/opt/fix_storage_class.h", "source/opt/flatten_decoration_pass.cpp", "source/opt/flatten_decoration_pass.h", "source/opt/fold.cpp", "source/opt/fold.h", "source/opt/fold_spec_constant_op_and_composite_pass.cpp", "source/opt/fold_spec_constant_op_and_composite_pass.h", "source/opt/folding_rules.cpp", "source/opt/folding_rules.h", "source/opt/freeze_spec_constant_value_pass.cpp", "source/opt/freeze_spec_constant_value_pass.h", "source/opt/function.cpp", "source/opt/function.h", "source/opt/graphics_robust_access_pass.cpp", "source/opt/graphics_robust_access_pass.h", "source/opt/if_conversion.cpp", "source/opt/if_conversion.h", "source/opt/inline_exhaustive_pass.cpp", "source/opt/inline_exhaustive_pass.h", "source/opt/inline_opaque_pass.cpp", "source/opt/inline_opaque_pass.h", "source/opt/inline_pass.cpp", "source/opt/inline_pass.h", "source/opt/instruction.cpp", "source/opt/instruction.h", "source/opt/instruction_list.cpp", "source/opt/instruction_list.h", "source/opt/interface_var_sroa.cpp", "source/opt/interface_var_sroa.h", "source/opt/interp_fixup_pass.cpp", "source/opt/interp_fixup_pass.h", "source/opt/invocation_interlock_placement_pass.cpp", "source/opt/invocation_interlock_placement_pass.h", "source/opt/ir_builder.h", "source/opt/ir_context.cpp", "source/opt/ir_context.h", "source/opt/ir_loader.cpp", "source/opt/ir_loader.h", "source/opt/iterator.h", "source/opt/licm_pass.cpp", "source/opt/licm_pass.h", "source/opt/liveness.cpp", "source/opt/liveness.h", "source/opt/local_access_chain_convert_pass.cpp", "source/opt/local_access_chain_convert_pass.h", "source/opt/local_redundancy_elimination.cpp", "source/opt/local_redundancy_elimination.h", "source/opt/local_single_block_elim_pass.cpp", "source/opt/local_single_block_elim_pass.h", "source/opt/local_single_store_elim_pass.cpp", "source/opt/local_single_store_elim_pass.h", "source/opt/log.h", "source/opt/loop_dependence.cpp", "source/opt/loop_dependence.h", "source/opt/loop_dependence_helpers.cpp", "source/opt/loop_descriptor.cpp", "source/opt/loop_descriptor.h", "source/opt/loop_fission.cpp", "source/opt/loop_fission.h", "source/opt/loop_fusion.cpp", "source/opt/loop_fusion.h", "source/opt/loop_fusion_pass.cpp", "source/opt/loop_fusion_pass.h", "source/opt/loop_peeling.cpp", "source/opt/loop_peeling.h", "source/opt/loop_unroller.cpp", "source/opt/loop_unroller.h", "source/opt/loop_unswitch_pass.cpp", "source/opt/loop_unswitch_pass.h", "source/opt/loop_utils.cpp", "source/opt/loop_utils.h", "source/opt/mem_pass.cpp", "source/opt/mem_pass.h", "source/opt/merge_return_pass.cpp", "source/opt/merge_return_pass.h", "source/opt/modify_maximal_reconvergence.cpp", "source/opt/modify_maximal_reconvergence.h", "source/opt/module.cpp", "source/opt/module.h", "source/opt/null_pass.h", "source/opt/opextinst_forward_ref_fixup_pass.cpp", "source/opt/opextinst_forward_ref_fixup_pass.h", "source/opt/optimizer.cpp", "source/opt/pass.cpp", "source/opt/pass.h", "source/opt/pass_manager.cpp", "source/opt/pass_manager.h", "source/opt/passes.h", "source/opt/private_to_local_pass.cpp", "source/opt/private_to_local_pass.h", "source/opt/propagator.cpp", "source/opt/propagator.h", "source/opt/reduce_load_size.cpp", "source/opt/reduce_load_size.h", "source/opt/redundancy_elimination.cpp", "source/opt/redundancy_elimination.h", "source/opt/reflect.h", "source/opt/register_pressure.cpp", "source/opt/register_pressure.h", "source/opt/relax_float_ops_pass.cpp", "source/opt/relax_float_ops_pass.h", "source/opt/remove_dontinline_pass.cpp", "source/opt/remove_dontinline_pass.h", "source/opt/remove_duplicates_pass.cpp", "source/opt/remove_duplicates_pass.h", "source/opt/remove_unused_interface_variables_pass.cpp", "source/opt/remove_unused_interface_variables_pass.h", "source/opt/replace_desc_array_access_using_var_index.cpp", "source/opt/replace_desc_array_access_using_var_index.h", "source/opt/replace_invalid_opc.cpp", "source/opt/replace_invalid_opc.h", "source/opt/scalar_analysis.cpp", "source/opt/scalar_analysis.h", "source/opt/scalar_analysis_nodes.h", "source/opt/scalar_analysis_simplification.cpp", "source/opt/scalar_replacement_pass.cpp", "source/opt/scalar_replacement_pass.h", "source/opt/set_spec_constant_default_value_pass.cpp", "source/opt/set_spec_constant_default_value_pass.h", "source/opt/simplification_pass.cpp", "source/opt/simplification_pass.h", "source/opt/spread_volatile_semantics.cpp", "source/opt/spread_volatile_semantics.h", "source/opt/ssa_rewrite_pass.cpp", "source/opt/ssa_rewrite_pass.h", "source/opt/strength_reduction_pass.cpp", "source/opt/strength_reduction_pass.h", "source/opt/strip_debug_info_pass.cpp", "source/opt/strip_debug_info_pass.h", "source/opt/strip_nonsemantic_info_pass.cpp", "source/opt/strip_nonsemantic_info_pass.h", "source/opt/struct_packing_pass.cpp", "source/opt/struct_packing_pass.h", "source/opt/struct_cfg_analysis.cpp", "source/opt/struct_cfg_analysis.h", "source/opt/switch_descriptorset_pass.cpp", "source/opt/switch_descriptorset_pass.h", "source/opt/tree_iterator.h", "source/opt/trim_capabilities_pass.cpp", "source/opt/trim_capabilities_pass.h", "source/opt/type_manager.cpp", "source/opt/type_manager.h", "source/opt/types.cpp", "source/opt/types.h", "source/opt/unify_const_pass.cpp", "source/opt/unify_const_pass.h", "source/opt/upgrade_memory_model.cpp", "source/opt/upgrade_memory_model.h", "source/opt/value_number_table.cpp", "source/opt/value_number_table.h", "source/opt/vector_dce.cpp", "source/opt/vector_dce.h", "source/opt/workaround1209.cpp", "source/opt/workaround1209.h", "source/opt/wrap_opkill.cpp", "source/opt/wrap_opkill.h", ] deps = [ ":spvtools", ":spvtools_language_header_debuginfo", ":spvtools_vendor_tables_spv-amd-shader-ballot", ] public_deps = [ ":spvtools_headers", ":spvtools_language_header_cldebuginfo100", ":spvtools_language_header_vkdebuginfo100", ] if (build_with_chromium) { configs -= [ "//build/config/compiler:chromium_code" ] configs += [ "//build/config/compiler:no_chromium_code" ] } configs += [ ":spvtools_internal_config" ] } static_library("spvtools_link") { sources = [ "source/link/linker.cpp" ] deps = [ ":spvtools", ":spvtools_opt", ":spvtools_val", ] public_deps = [ ":spvtools_headers" ] if (build_with_chromium) { configs -= [ "//build/config/compiler:chromium_code" ] configs += [ "//build/config/compiler:no_chromium_code" ] } configs += [ ":spvtools_internal_config" ] } static_library("spvtools_reduce") { sources = [ "source/reduce/change_operand_reduction_opportunity.cpp", "source/reduce/change_operand_reduction_opportunity.h", "source/reduce/change_operand_to_undef_reduction_opportunity.cpp", "source/reduce/change_operand_to_undef_reduction_opportunity.h", "source/reduce/conditional_branch_to_simple_conditional_branch_opportunity_finder.cpp", "source/reduce/conditional_branch_to_simple_conditional_branch_opportunity_finder.h", "source/reduce/conditional_branch_to_simple_conditional_branch_reduction_opportunity.cpp", "source/reduce/conditional_branch_to_simple_conditional_branch_reduction_opportunity.h", "source/reduce/merge_blocks_reduction_opportunity.cpp", "source/reduce/merge_blocks_reduction_opportunity.h", "source/reduce/merge_blocks_reduction_opportunity_finder.cpp", "source/reduce/merge_blocks_reduction_opportunity_finder.h", "source/reduce/operand_to_const_reduction_opportunity_finder.cpp", "source/reduce/operand_to_const_reduction_opportunity_finder.h", "source/reduce/operand_to_dominating_id_reduction_opportunity_finder.cpp", "source/reduce/operand_to_dominating_id_reduction_opportunity_finder.h", "source/reduce/operand_to_undef_reduction_opportunity_finder.cpp", "source/reduce/operand_to_undef_reduction_opportunity_finder.h", "source/reduce/reducer.cpp", "source/reduce/reducer.h", "source/reduce/reduction_opportunity.cpp", "source/reduce/reduction_opportunity.h", "source/reduce/reduction_opportunity_finder.cpp", "source/reduce/reduction_opportunity_finder.h", "source/reduce/reduction_pass.cpp", "source/reduce/reduction_pass.h", "source/reduce/reduction_util.cpp", "source/reduce/reduction_util.h", "source/reduce/remove_block_reduction_opportunity.cpp", "source/reduce/remove_block_reduction_opportunity.h", "source/reduce/remove_block_reduction_opportunity_finder.cpp", "source/reduce/remove_block_reduction_opportunity_finder.h", "source/reduce/remove_function_reduction_opportunity.cpp", "source/reduce/remove_function_reduction_opportunity.h", "source/reduce/remove_function_reduction_opportunity_finder.cpp", "source/reduce/remove_function_reduction_opportunity_finder.h", "source/reduce/remove_instruction_reduction_opportunity.cpp", "source/reduce/remove_instruction_reduction_opportunity.h", "source/reduce/remove_selection_reduction_opportunity.cpp", "source/reduce/remove_selection_reduction_opportunity.h", "source/reduce/remove_selection_reduction_opportunity_finder.cpp", "source/reduce/remove_selection_reduction_opportunity_finder.h", "source/reduce/remove_struct_member_reduction_opportunity.cpp", "source/reduce/remove_struct_member_reduction_opportunity.h", "source/reduce/remove_unused_instruction_reduction_opportunity_finder.cpp", "source/reduce/remove_unused_instruction_reduction_opportunity_finder.h", "source/reduce/remove_unused_struct_member_reduction_opportunity_finder.cpp", "source/reduce/remove_unused_struct_member_reduction_opportunity_finder.h", "source/reduce/simple_conditional_branch_to_branch_opportunity_finder.cpp", "source/reduce/simple_conditional_branch_to_branch_opportunity_finder.h", "source/reduce/simple_conditional_branch_to_branch_reduction_opportunity.cpp", "source/reduce/simple_conditional_branch_to_branch_reduction_opportunity.h", "source/reduce/structured_construct_to_block_reduction_opportunity.cpp", "source/reduce/structured_construct_to_block_reduction_opportunity.h", "source/reduce/structured_construct_to_block_reduction_opportunity_finder.cpp", "source/reduce/structured_construct_to_block_reduction_opportunity_finder.h", "source/reduce/structured_loop_to_selection_reduction_opportunity.cpp", "source/reduce/structured_loop_to_selection_reduction_opportunity.h", "source/reduce/structured_loop_to_selection_reduction_opportunity_finder.cpp", "source/reduce/structured_loop_to_selection_reduction_opportunity_finder.h", ] deps = [ ":spvtools", ":spvtools_opt", ] public_deps = [ ":spvtools_headers" ] if (build_with_chromium) { configs -= [ "//build/config/compiler:chromium_code" ] configs += [ "//build/config/compiler:no_chromium_code" ] } configs += [ ":spvtools_internal_config" ] } if (build_with_chromium && spvtools_build_executables) { # The spirv-fuzz library is only built when in a Chromium checkout # due to its dependency on protobuf. proto_library("spvtools_fuzz_proto") { sources = [ "source/fuzz/protobufs/spvtoolsfuzz.proto" ] generate_python = false use_protobuf_full = true } static_library("spvtools_fuzz") { sources = [ "source/fuzz/added_function_reducer.cpp", "source/fuzz/added_function_reducer.h", "source/fuzz/available_instructions.cpp", "source/fuzz/available_instructions.h", "source/fuzz/call_graph.cpp", "source/fuzz/call_graph.h", "source/fuzz/comparator_deep_blocks_first.h", "source/fuzz/counter_overflow_id_source.cpp", "source/fuzz/counter_overflow_id_source.h", "source/fuzz/data_descriptor.cpp", "source/fuzz/data_descriptor.h", "source/fuzz/equivalence_relation.h", "source/fuzz/fact_manager/constant_uniform_facts.cpp", "source/fuzz/fact_manager/constant_uniform_facts.h", "source/fuzz/fact_manager/data_synonym_and_id_equation_facts.cpp", "source/fuzz/fact_manager/data_synonym_and_id_equation_facts.h", "source/fuzz/fact_manager/dead_block_facts.cpp", "source/fuzz/fact_manager/dead_block_facts.h", "source/fuzz/fact_manager/fact_manager.cpp", "source/fuzz/fact_manager/fact_manager.h", "source/fuzz/fact_manager/irrelevant_value_facts.cpp", "source/fuzz/fact_manager/irrelevant_value_facts.h", "source/fuzz/fact_manager/livesafe_function_facts.cpp", "source/fuzz/fact_manager/livesafe_function_facts.h", "source/fuzz/force_render_red.cpp", "source/fuzz/force_render_red.h", "source/fuzz/fuzzer.cpp", "source/fuzz/fuzzer.h", "source/fuzz/fuzzer_context.cpp", "source/fuzz/fuzzer_context.h", "source/fuzz/fuzzer_pass.cpp", "source/fuzz/fuzzer_pass.h", "source/fuzz/fuzzer_pass_add_access_chains.cpp", "source/fuzz/fuzzer_pass_add_access_chains.h", "source/fuzz/fuzzer_pass_add_bit_instruction_synonyms.cpp", "source/fuzz/fuzzer_pass_add_bit_instruction_synonyms.h", "source/fuzz/fuzzer_pass_add_composite_extract.cpp", "source/fuzz/fuzzer_pass_add_composite_extract.h", "source/fuzz/fuzzer_pass_add_composite_inserts.cpp", "source/fuzz/fuzzer_pass_add_composite_inserts.h", "source/fuzz/fuzzer_pass_add_composite_types.cpp", "source/fuzz/fuzzer_pass_add_composite_types.h", "source/fuzz/fuzzer_pass_add_copy_memory.cpp", "source/fuzz/fuzzer_pass_add_copy_memory.h", "source/fuzz/fuzzer_pass_add_dead_blocks.cpp", "source/fuzz/fuzzer_pass_add_dead_blocks.h", "source/fuzz/fuzzer_pass_add_dead_breaks.cpp", "source/fuzz/fuzzer_pass_add_dead_breaks.h", "source/fuzz/fuzzer_pass_add_dead_continues.cpp", "source/fuzz/fuzzer_pass_add_dead_continues.h", "source/fuzz/fuzzer_pass_add_equation_instructions.cpp", "source/fuzz/fuzzer_pass_add_equation_instructions.h", "source/fuzz/fuzzer_pass_add_function_calls.cpp", "source/fuzz/fuzzer_pass_add_function_calls.h", "source/fuzz/fuzzer_pass_add_global_variables.cpp", "source/fuzz/fuzzer_pass_add_global_variables.h", "source/fuzz/fuzzer_pass_add_image_sample_unused_components.cpp", "source/fuzz/fuzzer_pass_add_image_sample_unused_components.h", "source/fuzz/fuzzer_pass_add_loads.cpp", "source/fuzz/fuzzer_pass_add_loads.h", "source/fuzz/fuzzer_pass_add_local_variables.cpp", "source/fuzz/fuzzer_pass_add_local_variables.h", "source/fuzz/fuzzer_pass_add_loop_preheaders.cpp", "source/fuzz/fuzzer_pass_add_loop_preheaders.h", "source/fuzz/fuzzer_pass_add_loops_to_create_int_constant_synonyms.cpp", "source/fuzz/fuzzer_pass_add_loops_to_create_int_constant_synonyms.h", "source/fuzz/fuzzer_pass_add_no_contraction_decorations.cpp", "source/fuzz/fuzzer_pass_add_no_contraction_decorations.h", "source/fuzz/fuzzer_pass_add_opphi_synonyms.cpp", "source/fuzz/fuzzer_pass_add_opphi_synonyms.h", "source/fuzz/fuzzer_pass_add_parameters.cpp", "source/fuzz/fuzzer_pass_add_parameters.h", "source/fuzz/fuzzer_pass_add_relaxed_decorations.cpp", "source/fuzz/fuzzer_pass_add_relaxed_decorations.h", "source/fuzz/fuzzer_pass_add_stores.cpp", "source/fuzz/fuzzer_pass_add_stores.h", "source/fuzz/fuzzer_pass_add_synonyms.cpp", "source/fuzz/fuzzer_pass_add_synonyms.h", "source/fuzz/fuzzer_pass_add_vector_shuffle_instructions.cpp", "source/fuzz/fuzzer_pass_add_vector_shuffle_instructions.h", "source/fuzz/fuzzer_pass_adjust_branch_weights.cpp", "source/fuzz/fuzzer_pass_adjust_branch_weights.h", "source/fuzz/fuzzer_pass_adjust_function_controls.cpp", "source/fuzz/fuzzer_pass_adjust_function_controls.h", "source/fuzz/fuzzer_pass_adjust_loop_controls.cpp", "source/fuzz/fuzzer_pass_adjust_loop_controls.h", "source/fuzz/fuzzer_pass_adjust_memory_operands_masks.cpp", "source/fuzz/fuzzer_pass_adjust_memory_operands_masks.h", "source/fuzz/fuzzer_pass_adjust_selection_controls.cpp", "source/fuzz/fuzzer_pass_adjust_selection_controls.h", "source/fuzz/fuzzer_pass_apply_id_synonyms.cpp", "source/fuzz/fuzzer_pass_apply_id_synonyms.h", "source/fuzz/fuzzer_pass_construct_composites.cpp", "source/fuzz/fuzzer_pass_construct_composites.h", "source/fuzz/fuzzer_pass_copy_objects.cpp", "source/fuzz/fuzzer_pass_copy_objects.h", "source/fuzz/fuzzer_pass_donate_modules.cpp", "source/fuzz/fuzzer_pass_donate_modules.h", "source/fuzz/fuzzer_pass_duplicate_regions_with_selections.cpp", "source/fuzz/fuzzer_pass_duplicate_regions_with_selections.h", "source/fuzz/fuzzer_pass_expand_vector_reductions.cpp", "source/fuzz/fuzzer_pass_expand_vector_reductions.h", "source/fuzz/fuzzer_pass_flatten_conditional_branches.cpp", "source/fuzz/fuzzer_pass_flatten_conditional_branches.h", "source/fuzz/fuzzer_pass_inline_functions.cpp", "source/fuzz/fuzzer_pass_inline_functions.h", "source/fuzz/fuzzer_pass_interchange_signedness_of_integer_operands.cpp", "source/fuzz/fuzzer_pass_interchange_signedness_of_integer_operands.h", "source/fuzz/fuzzer_pass_interchange_zero_like_constants.cpp", "source/fuzz/fuzzer_pass_interchange_zero_like_constants.h", "source/fuzz/fuzzer_pass_invert_comparison_operators.cpp", "source/fuzz/fuzzer_pass_invert_comparison_operators.h", "source/fuzz/fuzzer_pass_make_vector_operations_dynamic.cpp", "source/fuzz/fuzzer_pass_make_vector_operations_dynamic.h", "source/fuzz/fuzzer_pass_merge_blocks.cpp", "source/fuzz/fuzzer_pass_merge_blocks.h", "source/fuzz/fuzzer_pass_merge_function_returns.cpp", "source/fuzz/fuzzer_pass_merge_function_returns.h", "source/fuzz/fuzzer_pass_mutate_pointers.cpp", "source/fuzz/fuzzer_pass_mutate_pointers.h", "source/fuzz/fuzzer_pass_obfuscate_constants.cpp", "source/fuzz/fuzzer_pass_obfuscate_constants.h", "source/fuzz/fuzzer_pass_outline_functions.cpp", "source/fuzz/fuzzer_pass_outline_functions.h", "source/fuzz/fuzzer_pass_permute_blocks.cpp", "source/fuzz/fuzzer_pass_permute_blocks.h", "source/fuzz/fuzzer_pass_permute_function_parameters.cpp", "source/fuzz/fuzzer_pass_permute_function_parameters.h", "source/fuzz/fuzzer_pass_permute_function_variables.cpp", "source/fuzz/fuzzer_pass_permute_function_variables.h", "source/fuzz/fuzzer_pass_permute_instructions.cpp", "source/fuzz/fuzzer_pass_permute_instructions.h", "source/fuzz/fuzzer_pass_permute_phi_operands.cpp", "source/fuzz/fuzzer_pass_permute_phi_operands.h", "source/fuzz/fuzzer_pass_propagate_instructions_down.cpp", "source/fuzz/fuzzer_pass_propagate_instructions_down.h", "source/fuzz/fuzzer_pass_propagate_instructions_up.cpp", "source/fuzz/fuzzer_pass_propagate_instructions_up.h", "source/fuzz/fuzzer_pass_push_ids_through_variables.cpp", "source/fuzz/fuzzer_pass_push_ids_through_variables.h", "source/fuzz/fuzzer_pass_replace_adds_subs_muls_with_carrying_extended.cpp", "source/fuzz/fuzzer_pass_replace_adds_subs_muls_with_carrying_extended.h", "source/fuzz/fuzzer_pass_replace_branches_from_dead_blocks_with_exits.cpp", "source/fuzz/fuzzer_pass_replace_branches_from_dead_blocks_with_exits.h", "source/fuzz/fuzzer_pass_replace_copy_memories_with_loads_stores.cpp", "source/fuzz/fuzzer_pass_replace_copy_memories_with_loads_stores.h", "source/fuzz/fuzzer_pass_replace_copy_objects_with_stores_loads.cpp", "source/fuzz/fuzzer_pass_replace_copy_objects_with_stores_loads.h", "source/fuzz/fuzzer_pass_replace_irrelevant_ids.cpp", "source/fuzz/fuzzer_pass_replace_irrelevant_ids.h", "source/fuzz/fuzzer_pass_replace_linear_algebra_instructions.cpp", "source/fuzz/fuzzer_pass_replace_linear_algebra_instructions.h", "source/fuzz/fuzzer_pass_replace_loads_stores_with_copy_memories.cpp", "source/fuzz/fuzzer_pass_replace_loads_stores_with_copy_memories.h", "source/fuzz/fuzzer_pass_replace_opphi_ids_from_dead_predecessors.cpp", "source/fuzz/fuzzer_pass_replace_opphi_ids_from_dead_predecessors.h", "source/fuzz/fuzzer_pass_replace_opselects_with_conditional_branches.cpp", "source/fuzz/fuzzer_pass_replace_opselects_with_conditional_branches.h", "source/fuzz/fuzzer_pass_replace_parameter_with_global.cpp", "source/fuzz/fuzzer_pass_replace_parameter_with_global.h", "source/fuzz/fuzzer_pass_replace_params_with_struct.cpp", "source/fuzz/fuzzer_pass_replace_params_with_struct.h", "source/fuzz/fuzzer_pass_split_blocks.cpp", "source/fuzz/fuzzer_pass_split_blocks.h", "source/fuzz/fuzzer_pass_swap_commutable_operands.cpp", "source/fuzz/fuzzer_pass_swap_commutable_operands.h", "source/fuzz/fuzzer_pass_swap_conditional_branch_operands.cpp", "source/fuzz/fuzzer_pass_swap_conditional_branch_operands.h", "source/fuzz/fuzzer_pass_swap_functions.cpp", "source/fuzz/fuzzer_pass_swap_functions.h", "source/fuzz/fuzzer_pass_toggle_access_chain_instruction.cpp", "source/fuzz/fuzzer_pass_toggle_access_chain_instruction.h", "source/fuzz/fuzzer_pass_wrap_regions_in_selections.cpp", "source/fuzz/fuzzer_pass_wrap_regions_in_selections.h", "source/fuzz/fuzzer_pass_wrap_vector_synonym.cpp", "source/fuzz/fuzzer_pass_wrap_vector_synonym.h", "source/fuzz/fuzzer_util.cpp", "source/fuzz/fuzzer_util.h", "source/fuzz/id_use_descriptor.cpp", "source/fuzz/id_use_descriptor.h", "source/fuzz/instruction_descriptor.cpp", "source/fuzz/instruction_descriptor.h", "source/fuzz/instruction_message.cpp", "source/fuzz/instruction_message.h", "source/fuzz/overflow_id_source.cpp", "source/fuzz/overflow_id_source.h", "source/fuzz/pass_management/repeated_pass_instances.h", "source/fuzz/pass_management/repeated_pass_manager.cpp", "source/fuzz/pass_management/repeated_pass_manager.h", "source/fuzz/pass_management/repeated_pass_manager_looped_with_recommendations.cpp", "source/fuzz/pass_management/repeated_pass_manager_looped_with_recommendations.h", "source/fuzz/pass_management/repeated_pass_manager_random_with_recommendations.cpp", "source/fuzz/pass_management/repeated_pass_manager_random_with_recommendations.h", "source/fuzz/pass_management/repeated_pass_manager_simple.cpp", "source/fuzz/pass_management/repeated_pass_manager_simple.h", "source/fuzz/pass_management/repeated_pass_recommender.cpp", "source/fuzz/pass_management/repeated_pass_recommender.h", "source/fuzz/pass_management/repeated_pass_recommender_standard.cpp", "source/fuzz/pass_management/repeated_pass_recommender_standard.h", "source/fuzz/protobufs/spirvfuzz_protobufs.h", "source/fuzz/pseudo_random_generator.cpp", "source/fuzz/pseudo_random_generator.h", "source/fuzz/random_generator.cpp", "source/fuzz/random_generator.h", "source/fuzz/replayer.cpp", "source/fuzz/replayer.h", "source/fuzz/shrinker.cpp", "source/fuzz/shrinker.h", "source/fuzz/transformation.cpp", "source/fuzz/transformation.h", "source/fuzz/transformation_access_chain.cpp", "source/fuzz/transformation_access_chain.h", "source/fuzz/transformation_add_bit_instruction_synonym.cpp", "source/fuzz/transformation_add_bit_instruction_synonym.h", "source/fuzz/transformation_add_constant_boolean.cpp", "source/fuzz/transformation_add_constant_boolean.h", "source/fuzz/transformation_add_constant_composite.cpp", "source/fuzz/transformation_add_constant_composite.h", "source/fuzz/transformation_add_constant_null.cpp", "source/fuzz/transformation_add_constant_null.h", "source/fuzz/transformation_add_constant_scalar.cpp", "source/fuzz/transformation_add_constant_scalar.h", "source/fuzz/transformation_add_copy_memory.cpp", "source/fuzz/transformation_add_copy_memory.h", "source/fuzz/transformation_add_dead_block.cpp", "source/fuzz/transformation_add_dead_block.h", "source/fuzz/transformation_add_dead_break.cpp", "source/fuzz/transformation_add_dead_break.h", "source/fuzz/transformation_add_dead_continue.cpp", "source/fuzz/transformation_add_dead_continue.h", "source/fuzz/transformation_add_early_terminator_wrapper.cpp", "source/fuzz/transformation_add_early_terminator_wrapper.h", "source/fuzz/transformation_add_function.cpp", "source/fuzz/transformation_add_function.h", "source/fuzz/transformation_add_global_undef.cpp", "source/fuzz/transformation_add_global_undef.h", "source/fuzz/transformation_add_global_variable.cpp", "source/fuzz/transformation_add_global_variable.h", "source/fuzz/transformation_add_image_sample_unused_components.cpp", "source/fuzz/transformation_add_image_sample_unused_components.h", "source/fuzz/transformation_add_local_variable.cpp", "source/fuzz/transformation_add_local_variable.h", "source/fuzz/transformation_add_loop_preheader.cpp", "source/fuzz/transformation_add_loop_preheader.h", "source/fuzz/transformation_add_loop_to_create_int_constant_synonym.cpp", "source/fuzz/transformation_add_loop_to_create_int_constant_synonym.h", "source/fuzz/transformation_add_no_contraction_decoration.cpp", "source/fuzz/transformation_add_no_contraction_decoration.h", "source/fuzz/transformation_add_opphi_synonym.cpp", "source/fuzz/transformation_add_opphi_synonym.h", "source/fuzz/transformation_add_parameter.cpp", "source/fuzz/transformation_add_parameter.h", "source/fuzz/transformation_add_relaxed_decoration.cpp", "source/fuzz/transformation_add_relaxed_decoration.h", "source/fuzz/transformation_add_spec_constant_op.cpp", "source/fuzz/transformation_add_spec_constant_op.h", "source/fuzz/transformation_add_synonym.cpp", "source/fuzz/transformation_add_synonym.h", "source/fuzz/transformation_add_type_array.cpp", "source/fuzz/transformation_add_type_array.h", "source/fuzz/transformation_add_type_boolean.cpp", "source/fuzz/transformation_add_type_boolean.h", "source/fuzz/transformation_add_type_float.cpp", "source/fuzz/transformation_add_type_float.h", "source/fuzz/transformation_add_type_function.cpp", "source/fuzz/transformation_add_type_function.h", "source/fuzz/transformation_add_type_int.cpp", "source/fuzz/transformation_add_type_int.h", "source/fuzz/transformation_add_type_matrix.cpp", "source/fuzz/transformation_add_type_matrix.h", "source/fuzz/transformation_add_type_pointer.cpp", "source/fuzz/transformation_add_type_pointer.h", "source/fuzz/transformation_add_type_struct.cpp", "source/fuzz/transformation_add_type_struct.h", "source/fuzz/transformation_add_type_vector.cpp", "source/fuzz/transformation_add_type_vector.h", "source/fuzz/transformation_adjust_branch_weights.cpp", "source/fuzz/transformation_adjust_branch_weights.h", "source/fuzz/transformation_composite_construct.cpp", "source/fuzz/transformation_composite_construct.h", "source/fuzz/transformation_composite_extract.cpp", "source/fuzz/transformation_composite_extract.h", "source/fuzz/transformation_composite_insert.cpp", "source/fuzz/transformation_composite_insert.h", "source/fuzz/transformation_compute_data_synonym_fact_closure.cpp", "source/fuzz/transformation_compute_data_synonym_fact_closure.h", "source/fuzz/transformation_context.cpp", "source/fuzz/transformation_context.h", "source/fuzz/transformation_duplicate_region_with_selection.cpp", "source/fuzz/transformation_duplicate_region_with_selection.h", "source/fuzz/transformation_equation_instruction.cpp", "source/fuzz/transformation_equation_instruction.h", "source/fuzz/transformation_expand_vector_reduction.cpp", "source/fuzz/transformation_expand_vector_reduction.h", "source/fuzz/transformation_flatten_conditional_branch.cpp", "source/fuzz/transformation_flatten_conditional_branch.h", "source/fuzz/transformation_function_call.cpp", "source/fuzz/transformation_function_call.h", "source/fuzz/transformation_inline_function.cpp", "source/fuzz/transformation_inline_function.h", "source/fuzz/transformation_invert_comparison_operator.cpp", "source/fuzz/transformation_invert_comparison_operator.h", "source/fuzz/transformation_load.cpp", "source/fuzz/transformation_load.h", "source/fuzz/transformation_make_vector_operation_dynamic.cpp", "source/fuzz/transformation_make_vector_operation_dynamic.h", "source/fuzz/transformation_merge_blocks.cpp", "source/fuzz/transformation_merge_blocks.h", "source/fuzz/transformation_merge_function_returns.cpp", "source/fuzz/transformation_merge_function_returns.h", "source/fuzz/transformation_move_block_down.cpp", "source/fuzz/transformation_move_block_down.h", "source/fuzz/transformation_move_instruction_down.cpp", "source/fuzz/transformation_move_instruction_down.h", "source/fuzz/transformation_mutate_pointer.cpp", "source/fuzz/transformation_mutate_pointer.h", "source/fuzz/transformation_outline_function.cpp", "source/fuzz/transformation_outline_function.h", "source/fuzz/transformation_permute_function_parameters.cpp", "source/fuzz/transformation_permute_function_parameters.h", "source/fuzz/transformation_permute_phi_operands.cpp", "source/fuzz/transformation_permute_phi_operands.h", "source/fuzz/transformation_propagate_instruction_down.cpp", "source/fuzz/transformation_propagate_instruction_down.h", "source/fuzz/transformation_propagate_instruction_up.cpp", "source/fuzz/transformation_propagate_instruction_up.h", "source/fuzz/transformation_push_id_through_variable.cpp", "source/fuzz/transformation_push_id_through_variable.h", "source/fuzz/transformation_record_synonymous_constants.cpp", "source/fuzz/transformation_record_synonymous_constants.h", "source/fuzz/transformation_replace_add_sub_mul_with_carrying_extended.cpp", "source/fuzz/transformation_replace_add_sub_mul_with_carrying_extended.h", "source/fuzz/transformation_replace_boolean_constant_with_constant_binary.cpp", "source/fuzz/transformation_replace_boolean_constant_with_constant_binary.h", "source/fuzz/transformation_replace_branch_from_dead_block_with_exit.cpp", "source/fuzz/transformation_replace_branch_from_dead_block_with_exit.h", "source/fuzz/transformation_replace_constant_with_uniform.cpp", "source/fuzz/transformation_replace_constant_with_uniform.h", "source/fuzz/transformation_replace_copy_memory_with_load_store.cpp", "source/fuzz/transformation_replace_copy_memory_with_load_store.h", "source/fuzz/transformation_replace_copy_object_with_store_load.cpp", "source/fuzz/transformation_replace_copy_object_with_store_load.h", "source/fuzz/transformation_replace_id_with_synonym.cpp", "source/fuzz/transformation_replace_id_with_synonym.h", "source/fuzz/transformation_replace_irrelevant_id.cpp", "source/fuzz/transformation_replace_irrelevant_id.h", "source/fuzz/transformation_replace_linear_algebra_instruction.cpp", "source/fuzz/transformation_replace_linear_algebra_instruction.h", "source/fuzz/transformation_replace_load_store_with_copy_memory.cpp", "source/fuzz/transformation_replace_load_store_with_copy_memory.h", "source/fuzz/transformation_replace_opphi_id_from_dead_predecessor.cpp", "source/fuzz/transformation_replace_opphi_id_from_dead_predecessor.h", "source/fuzz/transformation_replace_opselect_with_conditional_branch.cpp", "source/fuzz/transformation_replace_opselect_with_conditional_branch.h", "source/fuzz/transformation_replace_parameter_with_global.cpp", "source/fuzz/transformation_replace_parameter_with_global.h", "source/fuzz/transformation_replace_params_with_struct.cpp", "source/fuzz/transformation_replace_params_with_struct.h", "source/fuzz/transformation_set_function_control.cpp", "source/fuzz/transformation_set_function_control.h", "source/fuzz/transformation_set_loop_control.cpp", "source/fuzz/transformation_set_loop_control.h", "source/fuzz/transformation_set_memory_operands_mask.cpp", "source/fuzz/transformation_set_memory_operands_mask.h", "source/fuzz/transformation_set_selection_control.cpp", "source/fuzz/transformation_set_selection_control.h", "source/fuzz/transformation_split_block.cpp", "source/fuzz/transformation_split_block.h", "source/fuzz/transformation_store.cpp", "source/fuzz/transformation_store.h", "source/fuzz/transformation_swap_commutable_operands.cpp", "source/fuzz/transformation_swap_commutable_operands.h", "source/fuzz/transformation_swap_conditional_branch_operands.cpp", "source/fuzz/transformation_swap_conditional_branch_operands.h", "source/fuzz/transformation_swap_function_variables.cpp", "source/fuzz/transformation_swap_function_variables.h", "source/fuzz/transformation_swap_two_functions.cpp", "source/fuzz/transformation_swap_two_functions.h", "source/fuzz/transformation_toggle_access_chain_instruction.cpp", "source/fuzz/transformation_toggle_access_chain_instruction.h", "source/fuzz/transformation_vector_shuffle.cpp", "source/fuzz/transformation_vector_shuffle.h", "source/fuzz/transformation_wrap_early_terminator_in_function.cpp", "source/fuzz/transformation_wrap_early_terminator_in_function.h", "source/fuzz/transformation_wrap_region_in_selection.cpp", "source/fuzz/transformation_wrap_region_in_selection.h", "source/fuzz/transformation_wrap_vector_synonym.cpp", "source/fuzz/transformation_wrap_vector_synonym.h", "source/fuzz/uniform_buffer_element_descriptor.cpp", "source/fuzz/uniform_buffer_element_descriptor.h", ] deps = [ ":spvtools", ":spvtools_fuzz_proto", ":spvtools_opt", ":spvtools_reduce", "//third_party/protobuf:protobuf_full", ] public_deps = [ ":spvtools_headers" ] configs -= [ "//build/config/compiler:chromium_code" ] configs += [ "//build/config/compiler:no_chromium_code" ] configs += [ ":spvtools_internal_config" ] } } group("SPIRV-Tools") { public_deps = [ ":spvtools", ":spvtools_link", ":spvtools_opt", ":spvtools_reduce", ":spvtools_val", ] } # The tests are scoped to Chromium to avoid needing to write gtest integration. # See Chromium's third_party/googletest/BUILD.gn for a complete integration. if (build_with_chromium && spvtools_build_executables) { test("spvtools_test") { sources = [ "test/assembly_context_test.cpp", "test/assembly_format_test.cpp", "test/binary_destroy_test.cpp", "test/binary_endianness_test.cpp", "test/binary_header_get_test.cpp", "test/binary_parse_test.cpp", "test/binary_strnlen_s_test.cpp", "test/binary_to_text.literal_test.cpp", "test/binary_to_text_test.cpp", "test/comment_test.cpp", "test/enum_set_test.cpp", "test/enum_string_mapping_test.cpp", "test/ext_inst.cldebug100_test.cpp", "test/ext_inst.debuginfo_test.cpp", "test/ext_inst.glsl_test.cpp", "test/ext_inst.opencl_test.cpp", "test/fix_word_test.cpp", "test/generator_magic_number_test.cpp", "test/hex_float_test.cpp", "test/hex_to_text_test.cpp", "test/immediate_int_test.cpp", "test/libspirv_macros_test.cpp", "test/name_mapper_test.cpp", "test/named_id_test.cpp", "test/opcode_make_test.cpp", "test/opcode_require_capabilities_test.cpp", "test/opcode_split_test.cpp", "test/opcode_table_get_test.cpp", "test/operand_capabilities_test.cpp", "test/operand_pattern_test.cpp", "test/operand_test.cpp", "test/target_env_test.cpp", "test/test_fixture.h", "test/text_advance_test.cpp", "test/text_destroy_test.cpp", "test/text_literal_test.cpp", "test/text_start_new_inst_test.cpp", "test/text_to_binary.annotation_test.cpp", "test/text_to_binary.barrier_test.cpp", "test/text_to_binary.constant_test.cpp", "test/text_to_binary.control_flow_test.cpp", "test/text_to_binary.debug_test.cpp", "test/text_to_binary.device_side_enqueue_test.cpp", "test/text_to_binary.extension_test.cpp", "test/text_to_binary.function_test.cpp", "test/text_to_binary.group_test.cpp", "test/text_to_binary.image_test.cpp", "test/text_to_binary.literal_test.cpp", "test/text_to_binary.memory_test.cpp", "test/text_to_binary.misc_test.cpp", "test/text_to_binary.mode_setting_test.cpp", "test/text_to_binary.pipe_storage_test.cpp", "test/text_to_binary.reserved_sampling_test.cpp", "test/text_to_binary.subgroup_dispatch_test.cpp", "test/text_to_binary.type_declaration_test.cpp", "test/text_to_binary_test.cpp", "test/text_word_get_test.cpp", "test/to_string_test.cpp", "test/unit_spirv.cpp", "test/unit_spirv.h", ] deps = [ ":spvtools", ":spvtools_language_header_cldebuginfo100", ":spvtools_language_header_debuginfo", ":spvtools_language_header_vkdebuginfo100", ":spvtools_tools_io", ":spvtools_val", "//testing/gmock", "//testing/gtest", "//testing/gtest:gtest_main", "//third_party/googletest:gmock", "//third_party/googletest:gtest", ] if (is_clang) { cflags_cc = [ "-Wno-self-assign" ] } configs += [ ":spvtools_internal_config" ] } } if (spirv_tools_standalone) { group("fuzzers") { testonly = true deps = [ "test/fuzzers" ] } } source_set("spvtools_software_version") { sources = [ "source/software_version.cpp" ] deps = [ ":spvtools_build_version", ":spvtools_headers", ] configs += [ ":spvtools_internal_config" ] } source_set("spvtools_tools_util") { sources = [ "tools/util/flags.cpp", "tools/util/cli_consumer.cpp", "tools/util/cli_consumer.h", ] deps = [ ":spvtools_headers" ] configs += [ ":spvtools_internal_config" ] } source_set("spvtools_tools_io") { sources = [ "tools/io.cpp", "tools/io.h", ] deps = [ ":spvtools_headers" ] configs += [ ":spvtools_internal_config" ] } if (spvtools_build_executables) { executable("spirv-as") { sources = [ "tools/as/as.cpp" ] deps = [ ":spvtools", ":spvtools_software_version", ":spvtools_tools_util", ":spvtools_tools_io", ] configs += [ ":spvtools_internal_config" ] } executable("spirv-dis") { sources = [ "tools/dis/dis.cpp" ] deps = [ ":spvtools", ":spvtools_software_version", ":spvtools_tools_util", ":spvtools_tools_io", ] configs += [ ":spvtools_internal_config" ] } executable("spirv-val") { sources = [ "tools/val/val.cpp" ] deps = [ ":spvtools", ":spvtools_software_version", ":spvtools_tools_util", ":spvtools_tools_io", ":spvtools_val", ] configs += [ ":spvtools_internal_config" ] } executable("spirv-cfg") { sources = [ "tools/cfg/bin_to_dot.cpp", "tools/cfg/bin_to_dot.h", "tools/cfg/cfg.cpp", ] deps = [ ":spvtools", ":spvtools_software_version", ":spvtools_tools_util", ":spvtools_tools_io", ] configs += [ ":spvtools_internal_config" ] } executable("spirv-opt") { sources = [ "tools/opt/opt.cpp" ] deps = [ ":spvtools", ":spvtools_opt", ":spvtools_software_version", ":spvtools_tools_util", ":spvtools_tools_io", ":spvtools_val", ] configs += [ ":spvtools_internal_config" ] } executable("spirv-link") { sources = [ "tools/link/linker.cpp" ] deps = [ ":spvtools", ":spvtools_link", ":spvtools_opt", ":spvtools_software_version", ":spvtools_tools_util", ":spvtools_tools_io", ":spvtools_val", ] configs += [ ":spvtools_internal_config" ] } } if (!is_ios && !spirv_is_winuwp && build_with_chromium && spvtools_build_executables) { # iOS and UWP do not allow std::system calls which spirv-fuzz # requires. Additionally, spirv-fuzz is only built when in a # Chromium checkout due to its dependency on protobuf. executable("spirv-fuzz") { sources = [ "tools/fuzz/fuzz.cpp" ] deps = [ ":spvtools", ":spvtools_fuzz", ":spvtools_opt", ":spvtools_reduce", ":spvtools_software_version", ":spvtools_tools_util", ":spvtools_tools_io", ":spvtools_val", "//third_party/protobuf:protobuf_full", ] configs += [ ":spvtools_internal_config" ] } } if (!is_ios && !spirv_is_winuwp && spvtools_build_executables) { # iOS and UWP do not allow std::system calls which spirv-reduce # requires. executable("spirv-reduce") { sources = [ "tools/reduce/reduce.cpp" ] deps = [ ":spvtools", ":spvtools_opt", ":spvtools_reduce", ":spvtools_software_version", ":spvtools_tools_util", ":spvtools_tools_io", ":spvtools_val", ] configs += [ ":spvtools_internal_config" ] } } if (spvtools_build_executables){ group("all_spirv_tools") { deps = [ ":spirv-as", ":spirv-cfg", ":spirv-dis", ":spirv-link", ":spirv-opt", ":spirv-val", ] if (!is_ios && !spirv_is_winuwp && build_with_chromium) { deps += [ ":spirv-fuzz" ] } if (!is_ios && !spirv_is_winuwp) { deps += [ ":spirv-reduce" ] } } } KhronosGroup-SPIRV-Tools-f289d04/CHANGES000066400000000000000000002473561475742701700175450ustar00rootroot00000000000000Revision history for SPIRV-Tools v2025.1 2025-02-28 - General - diff: Fix crash in OpString matching (#5988) - Add SPV_AMDX_shader_enqueue version 2 support (#5838) - add support for SPV_INTEL_subgroup_matrix_multiply_accumulate (#5928) - update cmake_minimum_required to 3.22.1 (#5925) - Add OpImageSampleFootprintNV to IsAllowedSampledImageOperand (#5914) - assembler: ensure progress when seeking the version string (#5910) - Optimizer - opt: keep all OpSource instructions (#5901) - [opt] Fix bug opt::InstructionBuilder::AddVariable (#6007) - [OPT] Add SPV_KHR_ray_tracing to allow list (#5941) - opt: keep all OpSource instructions (#5901) - Validator - spirv-val: Add AllowVulkan32BitBitwise option (#6001) - Fix untyped pointer comparison validation (#6004) - spirv-val: Update VUIDs for 308 header (#5990) - spirv-val: fix env parsing for vk1.1spv1.4 (#5985) - Add validation for SPV_NV_linear_swept_spheres. (#5975) - Add validation SPV_NV_cluster_acceleration_structure. (#5974) - Improve the instruction diagnostic for some access chain errors (#5978) - Update physical storage buffer validation to match SPIR-V 1.6.5 (#5977) - Validate SPV_NV_cooperative_vector (#5972) - Fix layout checks with untyped pointers (#5970) - spirv-val: Update mislabeled VUIDs (#5964) - More explicit layout validation (#5958) - spirv-val: Add VK_KHR_maintenance8 support (#5951) - Add EXT_mesh_shader validation support (#5640) - spirv-val: Remove OpenCL ivec3 req (#5940) - spirv-val: Validate zero product workgroup size (#5407) - Relax DebugLine validation (#5916) - Linker - linker: remove LinkOnceODR decorations when linking executables (#5979) - fix: handle LinkOnceODR correctly (#5938) v2024.4 2024-12-04 - General - Add FPEncoding operand type. (#5726) - Support SPV_KHR_untyped_pointers (#5736) - add support for SPV_INTEL_global_variable_host_access (#5786) - Add support for SPV_KHR_compute_shader_derivative (#5817) - Accept hex representation as binary input (#5870) - Vulkan 1.4 support (#5899) - Optimizer - Add knowledge of cooperative matrices (#5720) - Add struct-packing pass and unit test. (#5778) - Validator - Validate presence of Stride operand to OpCooperativeMatrix{Load,Store}KHR (#5777) - Update sampled image validation (#5789) - Disallow stores according to VUID 06924 (#5368) - Add validation for SPV_NV_tensor_addressing and SPV_NV_cooperative_matrix2 (#5865) - Linker - allow linking functions with different pointer arguments (#5534) v2024.3 2024-06-20 - General - Optimizer - Do not fold mul and adds to generate fmas (#5682) - add OpExtInst forward ref fixup pass (#5708) - Validator - Separate Location check for tess patch (#5654) - Validate MemoryAccessMask of OpCooperativeMatrixStoreKHR (#5668) - OpSampledImage extra validation (#5695) - add support for OpExtInstWithForwardRefs (#5698)A - Disassembler - add decorations to comments (#5675) - Add --nested-indent and --reorder-blocks (#5671) v2024.2 2024-04-22 - General - Add SPIRV_TOOLS_EXPORT to public C++ API (#5591) - Use bazel 7 and bzlmod (#5601) - Optimizer - opt: add GroupNonUniformPartitionedNV capability to trim pass (#5648) - Fix rebuilding types with circular references. (#5637) - Add AliasedPointer decoration (#5635) - add support for vulkan-shader-profiler external passes (#5512) - Validator - A fix to support of SPV_QCOM_image_processing2 (#5646) - spirv-val: Add Vulkan check for Rect Dim in OpTypeImage (#5644) - Validate duplicate decorations and execution modes (#5641) - Validator: Support SPV_NV_raw_access_chains (#5568) v2024.1 2024-03-06 - General - Add tooling support for SPV_KHR_maximal_reconvergence (#5542) - Add support for SPV_KHR_float_controls2 (#5543) - SPV_KHR_quad_control (#5547) - Fold 64-bit int operations (#5561) - update image enum tests to remove Kernel capability (#5562) - Support operand kind for SPV_INTEL_maximum_registers (#5580) - SPV_NV_shader_atomic_fp16_vector (#5581) - Support for SPV_QCOM_image_processing2 (#5582) - Fix access chain struct checks (#5592) - Optimizer - opt: add Int16 and Float16 to capability trim pass (#5519) - Add preserver-interface option to spirv-opt (#5524) - spirv-opt: Fix OpCompositeExtract relaxation with struct operands (#5536) - opt: Add VulkanMemoryModelDeviceScope to trim (#5544) - opt: Add TrimCapabilities pass to spirv-opt tool (#5545) - Add modify-maximal-reconvergence to spirv-opt help (#5546) - opt: add SPV_EXT_mesh_shader to opt allowlist (#5551) - opt: Add OpEntryPoint to DescriptorScalarReplacement pass (#5553) - opt: prevent meld to merge block with MaximalReconvergence (#5557) - [OPT] Use new instruction folder for for all opcodes in spec consti folding (#5569) - [OPT] Identify arrays with unknown length in copy prop arrays (#5570) - [OPT] Add removed unused interface var pass to legalization passes (#5579) - Validator - spirv-val: Re-enable OpControlBarrier VU (#5527) - spirv-val: Add Mesh Primitive Built-In validaiton (#5529) - spirv-val: Validate PhysicalStorageBuffer Stage Interface (#5539) - spirv-val: Multiple interface var with same SC (#5528) - spirv-val: Revert Validate PhysicalStorageBuffer Stage Interface (#5575) - spirv-val: Make Constant evaluation consistent (#5587) v2023.6 2023-12-18 - General - update_build_version.py produce deterministic header. (#5426) - Support missing git in update_build_version.py (#5473) - Optimizer - Add ComputeDerivativeGroup*NV capabilities to trim capabilities pass. (#5430) - Do not crash when tryingto fold unsupported spec constant (#5496) - instrument: Fix handling of gl_InvocationID (#5493) - Fix nullptr argument in MarkInsertChain (#5465) - opt: support 64-bit OpAccessChain index in FixStorageClass (#5446) - opt: add StorageImageReadWithoutFormat to cap trim (#5475) - opt: add PhysicalStorageBufferAddresses to trim (#5476) - Fix array size calculation (#5463 - Validator - spirv-val: Loosen restriction on base type of DebugTypePointer and DebugTypeQualifier (#5479) - spirv-val: Add WorkgroupMemoryExplicitLayoutKHR check for Block (#5461) v2023.5 2023-10-15 - General - Support 2 Intel extensions (#5357) - SPV_QCOM_image_processing support (#5223) - Optimizer - opt: fix StorageInputOutput16 trimming. (#5359) - opt: add StoragePushConstant16 to trim pass (#5366) - opt: enable StorageUniform16 (#5371) - opt: add bitmask support for capability trimming (#5372) - opt: Add SwitchDescriptorSetPass (#5375) - opt: add FragmentShader*InterlockEXT to capability trim pass (#5390) - opt: add Int64 capability to trim pass (#5398) - opt: add Float64 capability to trim pass (#5428) - opt: add raytracing/rayquery to trim pass (#5397) - opt: add ImageMSArray capability to trim pass. (#5395) - Add SPV_KHR_physical_storage_buffer to allowlists (#5402) - Add SPV_EXT_fragment_shader_interlock to allow lists (#5393) - Make sure that fragment shader interlock instructions are not removed by DCE (#5400) - instrument: Use Import linkage for instrumentation functions (#5355) - Add a new legalization pass to dedupe invocation interlock instructions (#5409) - instrument: Ensure linking works even of nothing is changed (#5419) - Validator - Move token version/cap/ext checks from parsing to validation (#5370) - val: re-add ImageMSArray validation (#5394) - Linker - linker: Add --use-highest-version option v2023.4 2023-07-17 - General - Set cmake_policy CMP0128 (#5341) - Add python3 requirement for the script (#5326) - Add support for LiteralFloat type (#5323) - SPV_KHR_cooperative_matrix (#5286) - Allow OpTypeBool in UniformConstant (#5237) - Allow physical storage buffer pointer in IO (#5251) - Remove const zero image operands (#5232) - Optimizer - Enable vector constant folding (#4913) (#5272) - Fold negation of integer vectors (#5269) - Add folding rule for OpTranspose (#5241) - Add SPV_NV_bindless_texture to spirv optimizations (#5231) - Fix incorrect half float conversion (#5349) - Add SPV_EXT_shader_atomic_float_add to allow lists (#5348) - Instrument - instrument: Cast gl_VertexIndex and InstanceIndex to uint (#5319) - instrument: Fix buffer address length calculations (#5257) - instrument: Reduce number of inst_bindless_stream_write_6 calls (#5327) - Validator - Validate GroupNonUniform instructions (#5296) - spirv-val: Label SPV_KHR_cooperative_matrix VUID (#5301) - Validate layouts for PhysicalStorageBuffer pointers (#5291) - spirv-val: Remove VUID from 1.3.251 spec (#5244) - Diff - spirv-diff: Update test expectations (#5264) - spirv-diff: Leave undefined ids unpaired. (#5262) - spirv-diff: Properly match SPV_KHR_ray_query types. (#5259) - diff: Don't give up entry point matching too early. (#5224) v2023.3 2023-05-15 - General - Update spirv_headers to include SPV_KHR_ray_tracing_position_fetch (#5205) - spirv-tools: Add support for QNX (#5211) - build: set std=c++17 for BUILD.gn (#5162) - Optimizer - Run ADCE when the printf extension is used. (#5215) - Don't convert struct members to half (#5201) - Apply scalar replacement on vars with Pointer decorations (#5208) - opt: Fix null deref in OpMatrixTimesVector and OpVectorTimesMatrix (#5199) - instrument: Add set and binding to bindless error records (#5204) - instrument: Change descriptor state storage format (#5178) - Fix LICMPass (#5087) - Add Vulkan memory model to allow lists (#5173) - Do not remove control barrier after spv1.3 (#5174) - Validator - spirv-val: Label Interface Location/Component VUIDs (#5221) - Add support for SPV_EXT_shader_tile_image (#5188) - Fix vector OpConstantComposite type validation (#5191) - spirv-val: Label new Vulkan VUID 07951 (#5154) - Fuzz - Do not define GOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL_INLINE if it is already defined. (#5200) v2023.2 2023-03-10 - General - build: move from c++11 to c++17 (#4983) - tools: refactorize tools flags parsing. (#5111) - Add C interface for Optimizer (#5030) - libspirv.cpp: adds c++ api for spvBinaryParse (#5109) - build: change the way we set cxx version for bazel. (#5114) - Optimizer - Fix null pointer in FoldInsertWithConstants. (#5093) - Fix removal of dependent non-semantic instructions (#5122) - Remove duplicate lists of constant and type opcodes (#5106) - opt: fix spirv ABI on Linux again. (#5113) - Validator - Validate decoration of structs with RuntimeArray (#5094) - Validate operand type before operating on it (#5092) - spirv-val: Conditional Branch without an exit is invalid in loop header (#5069) - spirv-val: Initial SPV_EXT_mesh_shader builtins (#5080) v2023.1 2023-01-17 - General - Renamed "master" to "main" (issue#5051) - Validate version 5 of clspv reflection (#5050) - Remove testing support for VS2015 (#5027) - Fix undef behaviour in hex float parsing (#5025) - Require C++11 *or later* (#5020) - Instrument - Instrument: Fix bindless checking for BufferDeviceAddress (#5049) - Optimizer - Optimize allocation of spvtools::opt::Instruction::operands_ (#5024) - spirv-opt: Fix OpCompositeInsert with Null Constant (#5008) - spirv-opt: Handle null CompositeInsert (#4998) - Add option to ADCE to remove output variables from interface. (#4994) - Add support for tesc, tese and geom to EliminateDead*Components (#4990) - Add pass to eliminate dead output components (#4982) - spirv-opt: Add const folding for CompositeInsert (#4943) - Add passes to eliminate dead output stores (#4970) - Prevent eliminating case constructs in block merging (#4976) - Validator - Fix layout validation (#5015) - Fix use of invalid analysis (#5013) - Fix infinite loop in validator (#5006) - Add validation support for SPV_NV_shader_invocation_reorder. (#4979) - Only validate full layout in Vulkan environments (#4972) - spirv-val: Label new Vulkan OpPtrAccessChain VUs (#4975) - spirv-val: Add OpPtrAccessChain Base checks (#4965) v2022.4 2022-10-12 - General - Support Narrow Types in BitCast Folding Rule (#4941) - spirv-diff: Allow no SpecId (#4904) - build: cmake: Add support for GNU/Hurd (#4895) - Implement tool changes for SPV_EXT_mesh_shader. (#4915) - Validator - spirv-val: Add SPV_ARM_core_builtins validation (#4958) - spirv-val: Add an option to use friendly names or not (#4951) - spirv-val: Consistently quote ids in messages (#4950) - spirv-val: Add initial SPV_EXT_mesh_shader validation (#4924) - spirv-val: Make it legal to use arrays of ray queries (#4938) - spirv-val: Better message for using OpTypeBool in input/output (#4901) - spirv-val: Add SPV_KHR_ray_tracing storage class (#4868) - Optimizer - spirv-opt: Fix stacked CompositeExtract constant folds (#4932) - Improve time to build dominators (#4916) - Fix ADCE to mark scope and inlined_at of line instructions as live. (#4910) - Improve algorithm to reorder blocks in a function (#4911) - Add structs to eliminate dead input components (#4894) - spirv-opt: fix copy-propagate-arrays index opti on structs. (#4891) - Fix ADCE to not eliminate top level DebugInfo instructions (#4889) - Fix array copy propagation (#4890) v2022.3 2022-08-08 - General - Add SPV_KHR_fragment_shader_barycentric support (#4805) - Add support for SPV_KHR_subgroup_rotate (#4786) - use exec_tools instead of tools for better RBE compatibility (#4837) - Write binary files to stdout in binary on windows. (#4834) - Allow spirv-opt print-all to show pretty IDs (#4888) - Validator - spirv-val: Add PerVertexKHR (#4807) - spirv-opt : Add FixFuncCallArgumentsPass (#4775) - spirv-val: Add CullMaskKHR support (#4792) - Require ColMajor or RowMajor for matrices (#4878) - spirv-val: Add SPV_KHR_ray_query (#4848) - spirv-val: Add SPV_KHR_ray_tracing instructions (#4871) - Implement SPV_NV_bindless_texture related changes (#4847) - spirv-val: Add OpConvertUToAccelerationStructureKHR (#4838) - spirv-val: Add support for SPV_AMD_shader_early_and_late_fragment_tests (#4812) - Optimizer - Fold multiply and subtraction into FMA with negation (#4808) - Add more folding for composite instructions (#4802) - spirv-opt: add pass for interface variable scalar replacement (#4779) - Don't try to unroll loop with step count 0. (#4769) - spirv-opt: SPV_NV_bindless_texture related changes (#4870) - Linker - linker: Recalculate interface variables (#4784) v2022.2 2022-04-07 - General - Add OpModuleProcessed to debug opcode (#4694) - Optimizer - Complete handling of RayQueryKHR type (#4690) - Have scalar replacement use undef instead of null (#4691) - Optimize Instruction::Instruction (#4705) - Handle propagation of arrays with decorations (#4717) - spirv-opt: Add OpExecutionModeId support (#4719) - Optimize Type::HashValue (#4707) - Optimize DefUseManager allocations (#4709) - Add pass to remove DontInline function control (#4747) - Better handling of 0xFFFFFFFF when folding vector shuffle (#4743) - Reset the id bound on the module in compact ids (#4744) - spirv-opt: (WIP) Eliminate Dead Input Component Pass (#4720) - Support SPV_KHR_uniform_group_instructions (#4734) - Handle shaders without execution model in spread-volatile-semantics (#4766) - Validator - Fix handling of Nontemporal image operand (#4692) - [spirv-val] Allow 0 Component Count for DebugTypeArray for Shader (#4706) - spirv-val: Validate DebugTypeMatrix (#4732) - spirv-val: Label Vulkan VUID 04734 (#4739) - spirv-val: Label VUID 06491 (#4745) - spirv-val: Disallow array of push constants (#4742) - spirv-val: Label Vulkan RuntimeArray VUID (#4749) - spirv-val: Add Vulkan Image VUID 06214 (#4750) - spirv-val: Add Vulkan Dref not allowed 3D dim VUID (#4751) - spirv-val: Label and add test for PSB Aligned (#4756) - spirv-val: Add Vulkan 32-bit bit op Base (#4758) - spirv-val: Add more Vulkan VUID labels (#4764) - Diff - Introduce spirv-diff (#4611) - Stabilize the output of spirv-diff (#4698) - spirv-diff: Handle OpSpecConstant array sizes (#4700) - spirv-diff: Match OpSpecConstantComposite correctly (#4704) - spirv-diff: Use GetSingleWord*Operand (#4768) - spirv-diff: Basic support for OpTypeForwardPointer (#4761) - spirv-diff: Fix OpTypeFunction matching w.r.t operand count (#4771) v2022.1 2022-01-26 - General - Add SPIR-V 1.6 support to wasm build (#4674) - Improvements to disassembly within PassManager (#4677) - Basic support for SPIR-V 1.6 (#4663) - reflect debug (#4662) - Fix endianness of string literals (#4622) - Optimizer - spirv-opt: add pass to Spread Volatile semantics (#4667) - Fix constant propagation and folding of FClamp instructions (#4651) - Manually fold floating point division by zero (#4637) - Allow ADCE to remove dead inputs (#4629) - Linker - Linker improvements (#4679) * test/linker: Code factorisation and small tweaks * linker: Do not fail when going over limits - Validator - val: interface struct with builtins must be Block (#4665) - Fuzzer - Avoid id bound errors during opt fuzzing (#4658) - Avoid uninitialised read when parsing hex float (#4646) v2021.4 2021-11-11 - General - Add a WebAssembly build (#3752) - Make cxx exceptions controllable (#4591) - Validator - Improve decoration validation (#4490) - Optimizer - Add spirv-opt pass to replace descriptor accesses based on variable indices (#4574) - Do not fold snegate feeding sdiv (#4600) - Handle overflowing id in merge return (#4606) - Fuzzer - Add libFuzzer target for spirv-fuzz (#4434) - Linter v2021.3 2021-08-24 - General - Initial support for SPV_KHR_integer_dot_product (#4327) - Add non-semantic vulkan extended instruction set (#4362) - Add common enum for debug info instructions from either opencl or vulkan (#4377) - Validator - Add validation for SPV_EXT_shader_atomic_float16_add (#4325) - Disallow loading a runtime-sized array (#4473) - spirv-val: Validate vulkan debug info similarly to opencl debug info (#4466) - Optimizer - spirv-opt: support SPV_EXT_shader_image_int64 (#4379) - spirv-opt: Add dataflow analysis framework (#4402) - Add control dependence analysis to opt (#4380) - Add spirv-opt convert-to-sampled-image pass (#4340) - spirv-opt: Add handling of vulkan debug info to DebugInfoManager (#4423) - Fuzz - spirv-fuzz: support AtomicLoad (#4330) - spirv-fuzz: Support AtomicStore (#4440) - spirv-fuzz: TransformationWrapVectorSynonym that rewrites scalar operations using vectors (#4376) - spirv-fuzz: Add minimal SPIR-V example to test shaders (#4415) - spirv-fuzz: support building using gn (#4365) - Linter - Add new target for spirv-lint (#4446) - spirv-lint: add basic CLI argument handling (#4478) - Add divergence analysis to linter (#4465) v2021.2 2021-06-18 - General - Support SPV_KHR_subgroup_uniform_control_flow (#4318) - Support Intel extensions for fixed point and hls-float (#4321) - Fix crash when optimizing shaders with DebugPrintf (#4280) - Validator - Support Vulkan Storage Class for Execution Model (#4212) - Optimizer - Handle SPV_KHR_vulkan_memory_model in dead-code elimination (#4320) - Support folding OpBitcast with numeric constants (#4247) - Fuzz - Add tests for MaybeGet* functions in fuzzerutil (#4284) - Fix OutlineFunction in presence of unreachable blocks (#4308) - Fix def-use update in PermutePhiOperands (#4309) - Swap positions of two functions in a module (#4236) v2021.1 2021-04-19 - General - Support SPV_KHR_linkonce_odr, SPV_KHR_expect_assume (#4161) - Fixes for the vscode language server extension (#4150) - Validator - Add validation for SPV_EXT_shader_atomic_float_min_max (#4105) - Add Vulkan Execution Scope checks (#4183) - Vulkan 64-bit OpAtomicStore check (#4163) - Optimizer - Add interpolate legalization pass (#4220) - Fuzz - Various performance optimizations - Do not add too many dead blocks (#4217) - Add WGSL compatibility flag to context (#4193) - Add persistent state to the fuzzer (#4137) v2020.7 2021-02-16 - General - Support pending Intel extensions (#4116) - Remove WebGPU support (#4108) - Validator - Vulkan image gather constant component (#4133) - Add Vulkan PSB64 convert VUID (#4122) - Validate SPV_KHR_workgroup_memory_explicit_layout (#4128) - Validate VK_KHR_zero_initialize_workgroup_memory (#4124) - Add Vulkan image gather offset VUID (#4118) - Label Vulkan atomic semantics VUIDs (#4120) - Label VUID 04662 (#4123) - Label VUID 04683 (#4121) - Add Vulkan EXT builtins (#4115) - Validate Sampled=1 for Vulkan ImageQuerySizeLod, ImageQueryLevels, ImageQueryLod (#4103) - Add Vulkan Memory Scope VUs (#4106) - Add Vulkan Addressing Model check (#4107) - Vulkan atomic storage class (#4079) - Label standalone Vulkan VUID (#4091) - Add Vulkan decroation VUID (#4090) - Add Vulkan FP Mode VUID (#4088) - Fix Vulkan image sampled check (#4085) - Add Vulkan ForwardPointer VUID (#4089) - Add Vulkan ImageTexelPointer format check (#4087) - Add Vulkan Group Operation VUID (#4086) - Add first StandAlone VUID 04633 (#4077) - Add Subgroup VUIDs (#4074) - validate return type of OpImageRead (#4072) - tighter validation of multisampled images (#4059) - validate OpTypeImage Sampled values for environemnts (#4064) - validate StorageImageMultisampled capability (#4062) - Add last TessLevelOuter and TessLevelInner VUID (#4055) - Add last ClipDistance and CullDistance VUID (#4054) - Add last ViewportIndex and Layer VUID (#4053) - Add last Position VUID (#4052) - Allow forward pointer to be used in types generally (#4044) - Optimizer - Mark module as modified if convert-to-half removes decorations (#4127) - Fix binding number calculation in desc sroa (#4095) - Run DCE when SPV_KHR_shader_clock is used (#4049) - Debug Info - Set correct scope and line info for DebugValue (#4125) - Avoid integrity check failures caused by propagating line instructions (#4096) - Linker - Linker usability improvements (#4084) - Instrumentation - Generate differentiated error codes for buffer oob checking (#4097) - Fuzz - Fix OpPhi handling in DuplicateRegionWithSelection (#4065) v2020.6 2020-12-07 - General CMake: Add SPIRV_TOOLS_BUILD_STATIC flag (#3910) - Disassembler Add some context comments to disassembly. (#3847) - Optimizer - Take new (raytracing) termination instructions into account. (#4050) - Do run DCE if SPV_KHR_ray_query is used. (#4047) - Handle 8-bit index in elim dead member (#4043) - Add texel buffer out-of-bounds checking instrumentation (#4038) - Update MeshShadingNV dependencies (and land Ray tracing updates) (#4028) - Fix buffer oob instrumentation for matrix refs (#4025) - Fix SSA re-writing in the presence of variable pointers. (#4010) - Add support to prevent functions from being inlined if they have DontInline flag (#3858) - Add SPV_EXT_shader_image_int64 (#3852) - Support SPV_KHR_fragment_shading_rate (#3943) - Fix use-after-move in val/validate.cpp (#3848) - Debug Info - properly preserve DebugValue indexes operand (#4022) - Add DebugValue for invisible store in single_store_elim (#4002) - Propagate OpLine to all applied instructions in spirv-opt (#3951) - Add DebugValue for DebugDecl invisible to value assignment (#3973) - Add DebugValue for function param regardless of scope (#3923) - Debug info preservation in convert-local-access-chains pass (#3835) - Debug info preservation in redundancy-elimination pass (#3839) - Debug info preservation in if-conversion pass (#3861) - Validator - Add validation support for the ray tracing built-in variables (#4041) - Use less stack space when validating Vulkan builtins (#4019) - Fix SPV_KHR_fragment_shading_rate VUID label (#4014) - Label Layer and ViewportIndex VUIDs (#4013) - Allow the ViewportIndex and Layer built-ins on SPIR-V 1.5 (#3986) - Fix validation of OpPhi instructions (#3919) - Fuzz - Fix facts arising from CompositeConstruct (#4034) - Do not flatten conditionals that create synonyms (#4030) - Add support for reining in rogue fuzzer passes (#3987) - Fix assertion failure in FuzzerPassAddCompositeExtract (#3995) - Fix invalid equation facts (#4009) - Fix bugs in TransformationFlattenConditionalBranch (#4006) - Fix bug related to transformation applicability (#3990) - Add expand vector reduction transformation (#3869) - Add FuzzerPassAddCompositeExtract (#3904) - Fix mismatch with shrinker step limit (#3985) - Fix off-by-one error in replayer (#3982) - Get order right for OpSelect arguments (#3974) - Do not add synonym-creating loops in dead blocks (#3975) - Skip OpTypeSampledImage when propagating up (#3976) - Pass OpUndef in function call if needed (#3978) - Fix off-by-one in TransformationCompositeConstruct (#3979) - Tolerate absent ids in data synonym fact management (#3966) - Fix to id availability (#3971) - Fix operand types (#3962) - Don't flatten conditional if condition is irrelevant (#3944) - Do not produce OpPhis of type OpTypeSampledImage (#3964) - Restrict fuzzer pass to reachable blocks (#3970) - Handle more types when extending OpPhi instructions (#3969) - Skip early terminator wrappers when merging returns (#3968) - Avoid irrelevant constants in synonym-creating loops (#3967) - Skip dead blocks in FuzzerPassAddOpPhiSynonyms (#3965) - Avoid the type manager when looking for struct types (#3963) - Fix to TransformationDuplicateRegionWithSelection (#3941) - Skip OpFunction when replacing irrelevant ids (#3932) - Use component-wise selectors when flattening conditional branches (#3921) - Avoid void struct member when outlining functions (#3936) - Do not allow Block-decorated structs when adding parameters (#3931) - Fix to operand id type (#3937) - Handle dead blocks in TransformationEquationInstruction (#3933) - Do not allow sampled image load when flattening conditionals (#3930) - Take care of OpPhi instructions when inlining (#3939) - Fix to TransformationInlineFunction (#3913) - Wrap early terminators before merging returns (#3925) - Lower probability of adding bit instruction synonyms (#3917) - Fix handling of OpPhi in FlattenConditionalBranch (#3916) - Avoid creating blocks without parents (#3908) - Do not allow creation of constants of block-decorated structs (#3903) - Fixes related to irrelevant ids (#3901) - Fix to transformation that adds a synonym via a loop (#3898) - Fix to duplicate region with selection (#3896) - Do not expose synonym facts for non-existent ids (#3891) - Do not add synonyms involving irrelevant ids (#3890) - Do not replace irrelevant ids that are not in blocks (#3892) - Wrap OpKill and similar in function calls (#3884) - Integrate spirv-reduce with shrinker (#3849) - Report fresh ids in transformations (#3856) - Support OpNot bit instruction case (#3841) - Return IR and transformation context after replay (#3846) v2020.5 2020-09-22 - General - Enable building with BUILD_SHARED_LIBS=1 (#3490) - Avoid using /MP4 for clang on windows. (#3662) - Fix compiler error on macOS with XCode12. (#3836) - Optimizer - Preserve OpenCL.DebugInfo.100 through private-to-local pass (#3571) - Preserve debug info in scalar replacement pass (#3461) - Debug info preservation in loop-unroll pass (#3548) - Preserve debug info in dead-insert-elim pass (#3652) - Improve non-semantic instruction handling in the optimizer (#3693) - Let ADCE pass check DebugScope (#3703) - Add undef for inlined void function (#3720) - Fix SSA-rewrite to remove DebugDeclare for variables without loads (#3719) - Handle DebugScope in compact-ids pass (#3724) - Add buffer oob check to bindless instrumentation (#3800) - Validator - Update OpenCL capabilities validation (#3149) - Validator support for non-semantic clspv reflection (#3618) - OpenCL.DebugInfo.100 DebugTypeArray with variable size (#3549) - Only validation locations for appropriate execution models (#3656) - Validate more OpenCL.DebugInfo.100 instructions (#3684) - Allow DebugTypeTemplate for Type operand (#3702) - spirv-val: Add Vulkan VUID labels to BuiltIn (#3756) - Allow SPV_KHR_8bit_storage extension. (#3780) - Validate SPIRV Version number when parsing binary header (#3834) - Reduce - Support reducing a specific function (#3774) - Fuzz - adds TransformationReplaceCopyObjectWithStoreLoad (#3567) - adds TransformationReplaceCopyMemoryWithLoadStore (#3575) - adds TransformationReplaceLoadStoreWithCopyMemory (#3586) - Implement the OpOuterProduct linear algebra case (#3617) - Pass to replace int operands with ints of opposite signedness (#3612) - TransformationMoveInstructionDown (#3477) - Add TransformationMakeVectorOperationDynamic (#3597) - TransformationReplaceAddSubMulWithCarryingExtended (#3598) - FuzzerPassPropagateInstructionsUp (#3478) - add FuzzerPassAddCompositeInserts (#3606) - Add inline function transformation (#3517) - Transformation to replace the use of an irrelevant id (#3697) - Add SPIRV_FUZZ_PROTOC_COMMAND (#3789) - Add TransformationDuplicateRegionWithSelection (#3773) - Transformation to flatten conditional branch (#3667) - Handle OpPhis in TransformationInlineFunction (#3833) - Create synonym of int constant using a loop (#3790) - Support dead blocks in TransformationAddSynonym (#3832) - Linker v2020.4 2020-07-22 - General - Changed variable names to be more descriptive (#3433) - Add support to GPU-AV instrumentation for Task and Mesh shaders (#3512) - Permit Simple and GLSL450 memory model in WEBGPU_0 (#3463) - Support SPV_KHR_terminate_invocation (#3568) - Optimizer - Preserving debug information in optimizations (#3389,#3420,#3425,#3356,#3459,#3444,#3492,#3451,#3497i,#3498,#3542) - Eliminate branches with condition of OpConstantNull (#3438) - Use structured order to unroll loops. (#3443) - Updated desc_sroa to support flattening structures (#3448) - Support OpCompositeExtract pattern in desc_sroa (#3456) - Fix ADCE pass bug for mulitple entries (#3470) - Sink pointer instructions in merge return (#3569) - Validator - Validate location assignments (#3308) - Fix reachability in the validator (#3541) - Reduce - Fuzz - Add support for OpSpecConstant* (#3373) - Add replace linear algebra instruction transformation (#3402) - Implement vector shuffle fuzzer pass (#3412) - Swap operands in OpBranchConditional (#3423) - Permute OpPhi instruction operands (#3421) - Add FuzzerPassAddCopyMemoryInstructions (#3391) - TransformationInvertComparisonOperator (#3475) - Add variables with workgroup storage class (#3485) - Add image sample unused components transformation (#3439) - TransformationReplaceParameterWithGlobal (#3434) - Support adding dead break from back-edge block (#3519) - Fuzzer pass to interchange zero-like constants (#3524) - Linker v2020.3 2020-05-27 - General - Prevent Effcee from installing things when building spirv-tools with testing enabled (#3256) - Update acorn version (#3294) - If SPIRV-Headers is in our tree, include it as subproject (#3299) - allow cross compiling for Windows Store, UWP, etc. (#3330) - Optimizer - Remove deprecated interfaces from instrument passes (#3361) - Preserve debug info in inline pass (#3349) - Handle more cases in dead member elim (#3289) - Preserve debug info in eliminate-dead-functions (#3251) - Fix Struct CFG analysis for single block loop (#3293) - Add tests for recently added command line option (#3297) - Consider sampled images as read-only storage (#3295) - Allow various validation options to be passed to spirv-opt (#3314) - Add debug information analysis (#3305) - Preserve debug info for wrap-opkill (#3331) - refactor inlining pass (#3328) - Add unrolling to performance passes (#3082) - Validator - Add validation support for ImageGatherBiasLodAMD (#3363) - Validate ShaderCallKHR memory scope (#3332) - Validate Buffer and BufferBlock apply only to struct types (#3259) - Reduce - increase default step limit (#3327) - Remove unused uniforms and similar (#3321) - Fuzz - Add support for StorageBuffer (#3348) - Add validator options (#3254) - Limit adding of new variables to 'basic' types (#3257) - Transformation to add OpConstantNull (#3273) - Handling of more fuzzing opportunities (#3277, #3280, #3281, #3290, #3292) - Respect rules for OpSampledImage (#3287) - Do not outline regions that produce pointer outputs (#3291) - Linker v2020.2 2020-03-26 - General: - Support extended instructions in the vscode language server - Make spvOpcodeString part of the public API (#3174) - Added guide to writing a spirv-fuzz fuzzer pass (#3190) - Add support for KHR_ray_{query,tracing} extensions (#3235) - Optimizer - Debug Printf support (#3215) - Add data structure for DebugScope, DebugDeclare in spirv-opt (#3183) - Fix identification of Vulkan images and buffers (#3253) - Validator - Add support for SPV_AMD_shader_image_load_store_lod (#3186) - Add validation rules for OpenCL.DebugInfo.100 extension (#3133) - Adding WebGPU specific Workgroup scope rule (#3204) - Disallow phis of images, samplers and sampled images (#3246) - Reduce - Fuzz - Fuzzer passes to add local and global variables (#3175) - Add fuzzer passes to add loads/stores (#3176) - Fuzzer pass to add function calls (#3178) - Fuzzer pass that adds access chains (#3182) - Fuzzer pass to add equation instructions (#3202) - Add swap commutable operands transformation (#3205) - Add fuzzer pass to permute function parameters (#3212) - Allow OpPhi operand to be replaced with a composite synonym (#3221) - Linker v2020.1 2020-02-03 - General: - Add support for SPV_KHR_non_semantic_info (#3110) - Support OpenCL.DebugInfo.100 extended instruction set (#3080) - Added support for Vulkan 1.2 - Add API function to better handle getting the necessary environment (#3142) - Clarify mapping of target env to SPIR-V version (#3150) - Implement constant folding for many transcendentals (#3166) - Optimizer - Change default version for CreatInstBindlessCheckPass to 2 (#3096, #3119) - Better handling of OpLine on merge blocks (#3130) - Use placeholder switch instead of placeholder loop in MergeReturn pass. (#3151) - Handle TimeAMD in AmdExtensionToKhrPass. (#3168) - Validator - Fix structured exit validation (#3141) - Reduce - Fuzz - Fuzzer pass to merge blocks (#3097) - Transformation to add a new function to a module (#3114) - Add fuzzer pass to perform module donation (#3117) - Fuzzer passes to create and branch to new dead blocks (#3135) - Fuzzer pass to add composite types (#3171) - Linker: - Remove names and decorations of imported symbols (#3081) v2019.5 2019-12-11 - General: - Export SPIRV-Tools targets on installation - SPIRV-Tools support for SPIR-V 1.5 (#2865) - Add WebGPU SPIR-V Assembler in JavaScript. (#2876) - Add Bazel build configuration. (#2891) - Add support for building with emscripten (#2948) - Update SPIR-V binary header test for SPIR-V 1.5 (#2967) - Add fuzzer for spirv-as call path (#2976) - Improved CMake install step. (#2963) - Add fuzzer for spirv-dis call path (#2977) - Ensure timestamp does not vary with timezone. (#2982) - Add a vscode extension for SPIR-V disassembly files (#2987) - Add iOS as a supported platform (#3001) - utils/vscode: Add SPIR-V language server support - Respect CMAKE_INSTALL_LIBDIR in installed CMake files (#3054) - Permit the debug instructions in WebGPU SPIR-V (#3063) - Add support for Fuchsia. (#3062) - Optimizer - Add descriptor array scalar replacement (#2742) - Add pass to wrap OpKill in a function call (#2790) - Fold FMix during constant folding. (#2818) - Add pass to replace AMD shader ballot extension (#2811) - Add pass to make Float32 operation relax precision (#2808) - Add pass to make relax precision operation Float16 (#2808) - Add pass to replace uses of 3 AMD extensions (#2814) - Fold Min, Max, and Clamp instructions. (#2836) - Better handling of OpKill in continues (#2842,#2922,#2933) - Enable OpTypeCooperativeMatrix specialization (#2927) - Support constant-folding UConvert and SConvert (#2960) - Update Offset to ConstOffset bitmask if operand is constant. (#3024) - Improve RegisterSizePasses (#3059) - Folding: perform add and sub on mismatched integer types (#3084) - Graphics robust access: use signed clamp (#3073) Fixes: - Instrument: Fix version 2 output record write for tess eval shaders. (#2782) - Instrument: Add support for Buffer Device Address extension (#2792) - Fix check for changed binary in API call. (#2798) - For WebGPU<->Vulkan optimization, set correct execution environment (#2834) - Handle OpConstantNull in copy-prop-arrays. (#2870) - Use OpReturn* in wrap-opkill (#2886) - Validator - Add generic builtin validation of target (#2843) - Extra resource interface validation (#2864) - Adding valilidation checks for OpEntryPoint duplicate names and execution mode (#2862) - Relaxed bitcast with pointers (#2878) - Validate physical storage buffer restrictions (#2930) - Add SPV_KHR_shader_clock validation (#2879, #3013) - Validate that selections are structured (#2962) - Disallow use of OpCompositeExtract/OpCompositeInsert with no indices (#2980) - Check that derivatives operate on 32-bit values (#2983) - Validate array stride does not cause overlap (#3028) - Validate nested constructs (#3068) Fixes: - Fix validation of constant matrices (#2794) - Update "remquor" validation - Only allow previously declared forward refs in structs (#2920) - Reduce - Remove relaxed precision decorations (#2797) - Reduce/fuzz: improve command line args (#2932) - Improve remove unref instr pass (#2945) Fixes: - Fuzz - Fix add-dead-break and add-dead-continue passes to respect dominance (#2838) - Add fuzzer pass to copy objects (#2853) - Add fuzzer pass to replace ids with synonyms (#2857) - Allow validation during spirv-fuzz replay (#2873) - Employ the "swarm testing" idea in spirv-fuzz (#2890) - reduce/fuzz: improve command line args (#2932) - option to convert shader into a form that renders red (#2934) - Add fuzzer pass to change selection controls (#2944) - add transformation and pass to construct composites (#2941) - Add fuzzer pass to change loop controls (#2949) - Add fuzzer pass to change function controls (#2951) - Add fuzzer pass to add NoContraction decorations (#2950) - Add missing functionality for matrix composites (#2974) - Fuzzer pass to adjust memory access operands (#2968) - Transformation to extract from a composite object (#2991) - Vector shuffle transformation (#3015) - Improve debugging facilities (#3074) - Function outlining fuzzer pass (#3078) v2019.4 2019-08-08 - General: - Memory model support for SPIR-V 1.4 - Add new spirv-fuzz tool - Add option for base branch in check_code_format.sh - Removed MarkV and Stats code. (#2576) - Instrument: Add version 2 of record formats (#2630) - Linker: Better type comparison for OpTypeArray and OpTypeForwardPointer (#2580) - Optimizer - Bindless Validation: Instrument descriptor-based loads and stores (#2583) - Better folding for OpSpecConstantOp (#2585, #2614) - Add in individual flags for Vulkan <-> WebGPU passes (#2615) - Handle nested breaks from switches. (#2624) - Optimizer: Handle array type with OpSpecConstantOp length (#2652) - Perform merge return with single return in loop. (#2714) - Add --preserve-bindings and --preserve-spec-constants (#2693) - Remove Common Uniform Elimination Pass (#2731) - Allow ray tracing shaders in inst bindle check pass. (#2733) - Add pass to inject code for robust-buffer-access semantics (#2771) - Treat access chain indexes as signed in SROA (#2776) - Handle RelaxedPrecision in SROA (#2788) - Add descriptor array scalar replacement (#2742) Fixes: - Handle decorations better in some optimizations (#2716) - Change the order branches are simplified in dead branch elim (#2728) - Fix bug in merge return (#2734) - SSA rewriter: Don't use trivial phis (#2757) - Record correct dominators in merge return (#2760) - Process OpDecorateId in ADCE (#2761) - Fix check for unreachable blocks in merge-return (#2762) - Handle out-of-bounds scalar replacements. (#2767) - Don't move debug or decorations when folding (#2772) - Protect against out-of-bounds references when folding OpCompositeExtract (#2774) - Validator - Validate loop merge (#2579) - Validate construct exits (#2459) - Validate OpenCL memory and addressing model environment rules (#2589) - Validate OpenCL environment rules for OpTypeImage (#2606) - Allow breaks to switch merge from nested construct (#2604) - Validate OpenCL environment rules for OpImageWrite (#2619) - Allow arrays of out per-primitive builtins for mesh shaders (#2617) - Validate OpenCL rules for ImageRead and OpImageSampleExplicitLod (#2643) - Add validation for SPV_EXT_fragment_shader_interlock (#2650) - Add builtin validation for SPV_NV_shader_sm_builtins (#2656) - Add validation for Subgroup builtins (#2637) - Validate variable initializer type (#2668) - Disallow stores to UBOs (#2651)A - Validate Volatile memory semantics bit (#2672) - Basic validation for Component decorations (#2679) - Validate that in OpenGL env block variables have Binding (#2685) - Validate usage of 8- and 16-bit types with only storage capabilities (#2704) - Add validation for SPV_EXT_demote_to_helper_invocation (#2707) - Extra small storage validation (#2732) - For Vulkan, disallow structures containing opaque types (#2546) - Validate storage class OpenCL environment rules for atomics (#2750) - Update OpControlBarriers rules for WebGPU (#2769) - Update OpMemoryBarriers rules for WebGPU (#2775) - Update WebGPU validation rules of OpAtomic*s (#2777) Fixes: - Disallow merge targeting block with OpLoopMerge (#2610) - Update vloadn and vstoren validation to match the OpenCL Extended Instruction Set Specification (#2599) - Update memory scope rules for WebGPU (#2725) - Allow LOD ops in compute shaders with derivative group execution modes (#2752) - Reduce Fixes: v2019.3 2019-05-14 - General: - Require Python 3 since Python 2 will out of service soon. - Add a continuous test that does memory checks using the address sanitizer. - Fix the build files so the SPIRV_USE_SANITIZER=address build works. - Packaging top of tree build artifacts again. - Added support for SPIR-V 1.4. (#2550) - Optimizer - Remove duplicates from list of interface IDs in OpEntryPoint instruction (#2449) - Bindless Validation: Descriptor Initialization Check (#2419) - Add option to validate after each pass (#2462) - Add legalization pass to fix mismatched pointer (#2430, #2535) - Add error messages when the input contains unknown instructions. (#2487) - Add pass to convert from WebGPU Spir-V to Vulkan Spir-V and back. (#2495) Fixes: - #2412: Dead memeber elimination should not change input and output variables. - #2405: Fix OpDot folding of half float vectors. - #2391: Dead branch elim should not fold away back edges. - #2441: Removing decorations when doing constant propagation. - #2455: Maintain inst to block mapping in merge return. - #2453: Fix merge return in the face of breaks. - #2456: Handle dead infinite loops in DCE. - #2458: Handle variable pointer in some optimizations. - #2452: Fix dead branch elimination to handle unreachable blocks better. - #2528: Fix undefined bit shift in sroa. - #2539: Change implementation of post order CFG traversal. - Validator - Add validation of storage classes for WebGPU (#2446) - Add validation for ExecutionMode in WebGPU (#2443) - Implement WebGPU specific CFG validation (#2386) - Allow NonWritable to target struct members. (#2420) - Allow storage type mismatch for parameter in relaxed addressing mode. - Allow non memory objects as parameter in relaxed addressing mode. - Disallow nested Blocks and buffer blocks (#2410). - Add validation for SPV_NV_cooperative_matrix (#2404) - Add --strip-atomic-counter-memory (#2413) - Check OpSampledImage is only passed into valid instructions (#2467) - Handle function decls in Structured CFG analysis (#2474) - Validate that OpUnreacahble is not statically reachable (#2473) - Add pass to generate needed initializers for WebGPU (#2481) - Allow images without format for OpenCL. (#2470) - Remove unreachable block validation (#2525) - Reduce runtime of array layout checks (#2534) - Add validation specific to OpExecutionModeId (#2536) - Validate sign of int types. (#2549) - VK_KHR_uniform_buffer_standard_layout validation (#2562) Fixes: - #2439: Add missing DepthGreater case to Fragment only check. - #2168: Disallow BufferBlock on StorageBuffer variables for Vulkan. - #2408: Restrict and Aliased decorations cannot be applied to the same id. - #2447: Improve function call parameter check. - Reduce - Add Pass to remove unreferenced blocks. (#2398) - Allows passing options to the validator. (#2401) - Improve reducer algorithm and other changes (#2472) - Add Pass to remove selections (#2485) - Add passes to simplify branches (#2507) Fixes: - #2478: fix loop to selection pass for loops with combined header/continue block v2019.2 2019-02-20 - General: - Support SPV_EXT_physical_storage_buffer - A number of memory leak have been fixed. - Removed use of deprecated Google test macro: - Changed the BUILD.gn to only build tests in Chromium. - Optimizer - Upgrade memory model improvments for modf and frexp. - Add a new pass to move loads closer to their uses: code sinking. - Invalidating the type manager now invalidates the constnat manager. - Expand instrumentation pass for bindless bounds checking to runtime-sized descriptor arrays. - Add a new pass that removes members from structs that are not used: dead member elimination. Fixes: - #2292: Remove undefined behaviour when folding bit shifts. - #2294: Fixes for instrumentation code. - #2293: Fix overflow when folding -INT_MIN. - #2374: Don't merge unreachable blocks when merging blocks. - Validator - Support SPV_KHR_no_integer_wrap and related decorations. - Validate Vulkan rules for OpTypeRuntimeArray. - Validate NonWritable decoration. - Many WebGPU specific validation rules were added. - Validate variable pointer related function call rules. - Better error messages. Fixes: - #2307: Check forwards references in OpTypeArray. - #2315, #2303: Fixed the layout check for relaxed layout. - #1628: Emit an error when an OpSwitch target is not an OpLabel. - Reduce - Added more documentation for spirv-reduce. - Add ability to remove OpPhi instructions. - Add ability to merge two basic blocks. - Add ability to remove unused functions and unused basic blocks. Fixes: v2019.1 2019-01-07 - General: - Created a new tool called spirv-reduce. - Add cmake option to turn off SPIRV_TIMER_ENABLED (#2103) - New optimization pass to update the memory model from GLSL450 to VulkanKHR. - Recognize OpTypeAccelerationStructureNV as a type instruction and ray tracing storage classes. - Fix GCC8 build. - Add --target-env flag to spirv-opt. - Add --webgpu-mode flag to run optimizations for webgpu. - The output disassembled line number stead of byte offset in validation errors. (#2091) - Optimizer - Added the instrumentation passes for bindless validation. - Added passes to help preserve OpLine information (#2027) - Add basic support for EXT_fragment_invocation_density (#2100) - Fix invalid OpPhi generated by merge-return. (#2172) - Constant and type manager have been turned into analysies. (#2251) Fixes: - #2018: Don't inline functions with a return in a structured CFG contstruct. - #2047: Fix bug in folding when volatile stores are present. - #2053: Fix check for when folding floating pointer values is allowed. - #2130: Don't inline recursive functions. - #2202: Handle multiple edges between two basic blocks in SSA-rewriter. - #2205: Don't unswitch a latch condition during loop unswitch. - #2245: Don't fold branch in loop unswitch. Run dead branch elimination to fold them. - #2204: Fix eliminate common uniform to place OpPhi instructions correctly. - #2247: Fix type mismatches caused by scalar replacement. - #2248: Fix missing OpPhi after merge return. - #2211: After merge return, fix invalid continue target. - #2210: Fix loop invariant code motion to not place code between merge instruction and branch. - #2258: Handle CompositeInsert with no indices in VDCE. - #2261: Have replace load size handle extact with no index. - Validator - Changed the naming convention of outputing ids with names in diagnostic messages. - Added validation rules for UniformConstant variables in Vulkan. - #1949: Validate uniform variable type in Vulkan - Ensure for OpVariable that result type and storage class operand agree (#2052) - Validator: Support VK_EXT_scalar_block_layout - Added Vulkan memory model semantics validation - Added validation checkes spefic to WebGPU environment. - Add support for VK_EXT_Transform_feedback capabilities (#2088) - Add validation for OpArrayLength. (#2117) - Ensure that function parameter's type is not void (#2118) - Validate pointer variables (#2111) - Add check for QueueFamilyKHMR memory scope (#2144) - Validate PushConstants annotation and type (#2140) - Allow Float16/Int8 for Vulkan 1.0 (#2153) - Check binding annotations in resource variables (#2151, #2167) - Validate OpForwardPointer (#2156) - Validate operation for OpSpecConstantOp (#2260) Fixes: - #2049: Allow InstanceId for NV ray tracing - Reduce - Initial commit wit a few passes to reduce test cases. - Validation is run after each reduction step. Fixes: v2018.6 2018-11-07 - General: - Added support for the Nvidia Turing and ray tracing extensions. - Make C++11 the CXX standard in CMakeLists.txt. - Enabled a parallel build for MSVC. - Enable pre-compiled headers for MSVC. - Added a code of conduct. - EFFCEE and RE2 are now required when build the tests. - Optimizer - Unrolling loops marked for unrolling in the legalization passes. - Improved the compile time of loop unrolling. - Changee merge-return to create a placeholder loop around the function. - Small improvement to merge-blocks to allow it to merge more often. - Enforce an upper bound for the ids, and add option to set it. - #1966: Report error if there are unreachable block before running merge return Fixes: - #1917: Allow 0 (meaning unlimited) as a parameter to --scalar-replacement - #1915: Improve handling of group decorations. - #1942: Fix incorrect uses of the constant manager. Avoids type mismatches in generated code. - #1997: Fix dead branch elimination when there is a loop in folded selection. - #1991: Fixes legality check in if-conversion. - #1987: Add nullptr check to array copy propagation. - #1984: Better handling of OpUnreachable in ADCE. - #1983: Run merge return on reachable functions only. - #1956: Handled atomic operations in ADCE. - #1963: Fold integer divisions by 0 to 0. - #2019: Handle MemberDecorateStringGOOGLE in ADCE and strip reflect. - Validator - Added validation for OpGroupNonUniformBallotBitCount. - Added validation for the Vulkan memory model. - Added support for VK_KHR_shader_atddomic_int64. - Added validation for execution modes. - Added validation for runtime array layouts. - Added validation for 8-bit storage. - Added validation of OpPhi instructions with pointer result type. - Added checks for the Vulkan memory model. - Validate MakeTexelAvailableKHR and MakeTexelVisibleKHR - Allow atomic function pointer for OpenCL. - FPRounding mode checks were implemented. - Added validation for the id bound with an option to set the max id bound. Fixes: - #1882: Improve the validation of decorations to reduce memory usage. - #1891: Fix an potential infinite loop in dead-branch-elimination. - #1405: Validate the storage class of boolean objects. - #1880: Identify arrays of type void as invalid. - #487: Validate OpImageTexelPointer. - #1922: Validate OpPhi instructions are at the start of a block correctly. - #1923: Validate function scope variable are at the start of the entry block. v2018.5 2018-09-07 - General: - Support SPV_KHR_vulkan_memory_model - Update Dim capabilities, to match SPIR-V 1.3 Rev 4 - Automated build bots no run tests for the VS2013 case - Support Chromium GN build - Use Kokoro bots: - Disable Travis-CI bots - Disable AppVeyor VisualStudio Release builds. Keep VS 2017 Debug build - Don't check export symbols on OSX (Darwin): some installations don't have 'objdump' - Reorganize source files and namespaces - Fixes for ClangTidy, and whitespace (passes 'git cl presumit --all -uf') - Fix unused param compile warnings/errors when Effcee not present - Avoid including time headers when timer functionality is disabled - Avoid too-stringent warnings flags for Clang on Windows - Internal refactoring - Add hooks for automated fuzzing - Add testing of command line executables - #1688: Use binary mode on stdin; fixes "spirv-dis . versioning, with "-dev" indicating work in progress. The intent is to more easly report and summarize functionality when SPIRV-Tools is incorporated in downstream projects. - Summary of functionality (See the README.md for more): - Supports SPIR-V 1.1 Rev 1 - Supports SPIR-V 1.0 Rev 5 - Supports GLSL std450 extended instructions 1.0 Rev 3 - Supports OpenCL extended instructions 1.0 Rev 2 - Assembler, disassembler are complete - Supports floating point widths of 16, 32, 64 bits - Supports integer widths up to 64 bits - Validator is incomplete - Checks capability requirements in most cases - Checks module layout constraints - Checks ID use-definition ordering constraints, ignoring control flow - Checks some control flow graph rules - Optimizer is introduced, with few available transforms. - Supported on Linux, OSX, Android, Windows - Fixes bugs: - #143: OpenCL pow and pown arguments KhronosGroup-SPIRV-Tools-f289d04/CMakeLists.txt000066400000000000000000000362711475742701700213020ustar00rootroot00000000000000# Copyright (c) 2015-2023 The Khronos Group Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. cmake_minimum_required(VERSION 3.22.1) project(spirv-tools) # Avoid a bug in CMake 3.22.1. By default it will set -std=c++11 for # targets in test/*, when those tests need -std=c++17. # https://github.com/KhronosGroup/SPIRV-Tools/issues/5340 # The bug is fixed in CMake 3.22.2 if (${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.22.1") if (${CMAKE_VERSION} VERSION_LESS "3.22.2") cmake_policy(SET CMP0128 NEW) endif() endif() set_property(GLOBAL PROPERTY USE_FOLDERS ON) enable_testing() set(SPIRV_TOOLS "SPIRV-Tools") include(GNUInstallDirs) set(CMAKE_POSITION_INDEPENDENT_CODE ON) # Require at least C++17 if(NOT CMAKE_CXX_STANDARD) set(CMAKE_CXX_STANDARD 17) endif() if(${CMAKE_CXX_STANDARD} LESS 17) message(FATAL_ERROR "SPIRV-Tools requires C++17 or later, but is configured for C++${CMAKE_CXX_STANDARD})") endif() set(CMAKE_CXX_EXTENSIONS OFF) option(ENABLE_RTTI "Enables RTTI" OFF) option(SPIRV_ALLOW_TIMERS "Allow timers via clock_gettime on supported platforms" ON) if("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux") set(SPIRV_TIMER_ENABLED ${SPIRV_ALLOW_TIMERS}) elseif("${CMAKE_SYSTEM_NAME}" MATCHES "Windows") add_definitions(-DSPIRV_WINDOWS) elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "CYGWIN") add_definitions(-DSPIRV_WINDOWS) elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "Android") set(SPIRV_TIMER_ENABLED ${SPIRV_ALLOW_TIMERS}) endif() if (${SPIRV_TIMER_ENABLED}) add_definitions(-DSPIRV_TIMER_ENABLED) endif() if ("${CMAKE_BUILD_TYPE}" STREQUAL "") message(STATUS "No build type selected, default to Debug") set(CMAKE_BUILD_TYPE "Debug") endif() option(SKIP_SPIRV_TOOLS_INSTALL "Skip installation" ${SKIP_SPIRV_TOOLS_INSTALL}) if(NOT ${SKIP_SPIRV_TOOLS_INSTALL}) set(ENABLE_SPIRV_TOOLS_INSTALL ON) endif() option(SPIRV_BUILD_COMPRESSION "Build SPIR-V compressing codec" OFF) if(SPIRV_BUILD_COMPRESSION) message(FATAL_ERROR "SPIR-V compression codec has been removed from SPIR-V tools. " "Please remove SPIRV_BUILD_COMPRESSION from your build options.") endif(SPIRV_BUILD_COMPRESSION) option(SPIRV_BUILD_FUZZER "Build spirv-fuzz" OFF) set(SPIRV_LIB_FUZZING_ENGINE_LINK_OPTIONS "" CACHE STRING "Used by OSS-Fuzz to control, via link options, which fuzzing engine should be used") option(SPIRV_BUILD_LIBFUZZER_TARGETS "Build libFuzzer targets" OFF) option(SPIRV_WERROR "Enable error on warning" ON) if(("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU") OR (("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") AND (NOT CMAKE_CXX_SIMULATE_ID STREQUAL "MSVC"))) set(COMPILER_IS_LIKE_GNU TRUE) endif() if(${COMPILER_IS_LIKE_GNU}) set(SPIRV_WARNINGS -Wall -Wextra -Wnon-virtual-dtor -Wno-missing-field-initializers) if("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") set(SPIRV_WARNINGS ${SPIRV_WARNINGS} -Wno-self-assign) endif() option(SPIRV_WARN_EVERYTHING "Enable -Weverything" ${SPIRV_WARN_EVERYTHING}) if(${SPIRV_WARN_EVERYTHING}) if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") set(SPIRV_WARNINGS ${SPIRV_WARNINGS} -Weverything -Wno-c++98-compat -Wno-c++98-compat-pedantic -Wno-padded) elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") set(SPIRV_WARNINGS ${SPIRV_WARNINGS} -Wpedantic -pedantic-errors) else() message(STATUS "Unknown compiler ${CMAKE_CXX_COMPILER_ID}, " "so SPIRV_WARN_EVERYTHING has no effect") endif() endif() if(${SPIRV_WERROR}) set(SPIRV_WARNINGS ${SPIRV_WARNINGS} -Werror) endif() elseif(MSVC) set(SPIRV_WARNINGS -D_CRT_SECURE_NO_WARNINGS -D_SCL_SECURE_NO_WARNINGS /wd4800 /wd4819) if(${SPIRV_WERROR}) set(SPIRV_WARNINGS ${SPIRV_WARNINGS} /WX) endif() endif() include_directories(${CMAKE_CURRENT_SOURCE_DIR}/) option(SPIRV_COLOR_TERMINAL "Enable color terminal output" ON) if(${SPIRV_COLOR_TERMINAL}) add_definitions(-DSPIRV_COLOR_TERMINAL) endif() option(SPIRV_LOG_DEBUG "Enable excessive debug output" OFF) if(${SPIRV_LOG_DEBUG}) add_definitions(-DSPIRV_LOG_DEBUG) endif() if (DEFINED SPIRV_TOOLS_EXTRA_DEFINITIONS) add_definitions(${SPIRV_TOOLS_EXTRA_DEFINITIONS}) endif() # Library build setting definitions: # # * SPIRV_TOOLS_BUILD_STATIC - ON or OFF - Defaults to ON. # If enabled the following targets will be created: # ${SPIRV_TOOLS}-static - STATIC library. # Has full public symbol visibility. # ${SPIRV_TOOLS}-shared - SHARED library. # Has default-hidden symbol visibility. # ${SPIRV_TOOLS} - will alias to one of above, based on BUILD_SHARED_LIBS. # If disabled the following targets will be created: # ${SPIRV_TOOLS} - either STATIC or SHARED based on SPIRV_TOOLS_LIBRARY_TYPE. # Has full public symbol visibility. # ${SPIRV_TOOLS}-shared - SHARED library. # Has default-hidden symbol visibility. # # * SPIRV_TOOLS_LIBRARY_TYPE - SHARED or STATIC. # Specifies the library type used for building SPIRV-Tools libraries. # Defaults to SHARED when BUILD_SHARED_LIBS=1, otherwise STATIC. # # * SPIRV_TOOLS_FULL_VISIBILITY - "${SPIRV_TOOLS}-static" or "${SPIRV_TOOLS}" # Evaluates to the SPIRV_TOOLS target library name that has no hidden symbols. # This is used by internal targets for accessing symbols that are non-public. # Note this target provides no API stability guarantees. # # Ideally, all of these will go away - see https://github.com/KhronosGroup/SPIRV-Tools/issues/3909. option(ENABLE_EXCEPTIONS_ON_MSVC "Build SPIRV-TOOLS with c++ exceptions enabled in MSVC" ON) option(SPIRV_TOOLS_BUILD_STATIC "Build ${SPIRV_TOOLS}-static target. ${SPIRV_TOOLS} will alias to ${SPIRV_TOOLS}-static or ${SPIRV_TOOLS}-shared based on BUILD_SHARED_LIBS" ON) if(SPIRV_TOOLS_BUILD_STATIC) set(SPIRV_TOOLS_FULL_VISIBILITY ${SPIRV_TOOLS}-static) set(SPIRV_TOOLS_LIBRARY_TYPE "STATIC") else(SPIRV_TOOLS_BUILD_STATIC) set(SPIRV_TOOLS_FULL_VISIBILITY ${SPIRV_TOOLS}) if (NOT DEFINED SPIRV_TOOLS_LIBRARY_TYPE) if(BUILD_SHARED_LIBS) set(SPIRV_TOOLS_LIBRARY_TYPE "SHARED") else() set(SPIRV_TOOLS_LIBRARY_TYPE "STATIC") endif() endif() endif(SPIRV_TOOLS_BUILD_STATIC) function(spvtools_default_compile_options TARGET) target_compile_options(${TARGET} PRIVATE ${SPIRV_WARNINGS}) if (${COMPILER_IS_LIKE_GNU}) target_compile_options(${TARGET} PRIVATE -Wall -Wextra -Wno-long-long -Wshadow -Wundef -Wconversion -Wno-sign-conversion -fno-exceptions) if(NOT ENABLE_RTTI) add_compile_options(-fno-rtti) endif() # For good call stacks in profiles, keep the frame pointers. if(NOT "${SPIRV_PERF}" STREQUAL "") target_compile_options(${TARGET} PRIVATE -fno-omit-frame-pointer) endif() if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "AppleClang") set(SPIRV_USE_SANITIZER "" CACHE STRING "Use the clang sanitizer [address|memory|thread|...]") if(NOT "${SPIRV_USE_SANITIZER}" STREQUAL "") target_compile_options(${TARGET} PRIVATE -fsanitize=${SPIRV_USE_SANITIZER}) set_target_properties(${TARGET} PROPERTIES LINK_FLAGS -fsanitize=${SPIRV_USE_SANITIZER}) endif() target_compile_options(${TARGET} PRIVATE -ftemplate-depth=1024) else() target_compile_options(${TARGET} PRIVATE -Wno-missing-field-initializers) endif() endif() if (MSVC) # Specify /EHs for exception handling. This makes using SPIRV-Tools as # dependencies in other projects easier. if(ENABLE_EXCEPTIONS_ON_MSVC) target_compile_options(${TARGET} PRIVATE /EHs) endif() endif() # For MinGW cross compile, statically link to the C++ runtime. # But it still depends on MSVCRT.dll. if (${CMAKE_SYSTEM_NAME} MATCHES "Windows") if (NOT MSVC) set_target_properties(${TARGET} PROPERTIES LINK_FLAGS -static -static-libgcc -static-libstdc++) endif() endif() endfunction() if(NOT COMMAND find_host_package) macro(find_host_package) find_package(${ARGN}) endmacro() endif() if(NOT COMMAND find_host_program) macro(find_host_program) find_program(${ARGN}) endmacro() endif() # Tests require Python3 find_host_package(Python3 REQUIRED) # Check for symbol exports on Linux. # At the moment, this check will fail on the OSX build machines for the Android NDK. # It appears they don't have objdump. if("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux") macro(spvtools_check_symbol_exports TARGET) if (NOT "${SPIRV_SKIP_TESTS}") add_test(NAME spirv-tools-symbol-exports-${TARGET} COMMAND Python3::Interpreter ${spirv-tools_SOURCE_DIR}/utils/check_symbol_exports.py "$") endif() endmacro() else() macro(spvtools_check_symbol_exports TARGET) if (NOT "${SPIRV_SKIP_TESTS}") message("Skipping symbol exports test for ${TARGET}") endif() endmacro() endif() if(ENABLE_SPIRV_TOOLS_INSTALL) if(WIN32 AND NOT MINGW) macro(spvtools_config_package_dir TARGET PATH) set(${PATH} ${TARGET}/cmake) endmacro() else() macro(spvtools_config_package_dir TARGET PATH) set(${PATH} ${CMAKE_INSTALL_LIBDIR}/cmake/${TARGET}) endmacro() endif() macro(spvtools_generate_config_file TARGET) file(WRITE ${CMAKE_BINARY_DIR}/${TARGET}Config.cmake "include(CMakeFindDependencyMacro)\n" "find_dependency(${SPIRV_TOOLS})\n" "include(\${CMAKE_CURRENT_LIST_DIR}/${TARGET}Targets.cmake)\n" "set(${TARGET}_LIBRARIES ${TARGET})\n" "get_target_property(${TARGET}_INCLUDE_DIRS ${TARGET} INTERFACE_INCLUDE_DIRECTORIES)\n") endmacro() endif() # Currently iOS and Android are very similar. # They both have their own packaging (APP/APK). # Which makes regular executables/testing problematic. # # Currently the only deliverables for these platforms are # libraries (either STATIC or SHARED). # # Furthermore testing is equally problematic. if (IOS OR ANDROID) set(SPIRV_SKIP_EXECUTABLES ON) endif() option(SPIRV_SKIP_EXECUTABLES "Skip building the executable and tests along with the library") if (SPIRV_SKIP_EXECUTABLES) set(SPIRV_SKIP_TESTS ON) endif() option(SPIRV_SKIP_TESTS "Skip building tests along with the library") # Defaults to ON. The checks can be time consuming. # Turn off if they take too long. option(SPIRV_CHECK_CONTEXT "In a debug build, check if the IR context is in a valid state." ON) if (${SPIRV_CHECK_CONTEXT}) add_compile_options($<$:-DSPIRV_CHECK_CONTEXT>) endif() # Precompiled header macro. Parameters are source file list and filename for pch cpp file. macro(spvtools_pch SRCS PCHPREFIX) if(MSVC AND CMAKE_GENERATOR MATCHES "^Visual Studio" AND NOT "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") set(PCH_NAME "$(IntDir)\\${PCHPREFIX}.pch") # make source files use/depend on PCH_NAME set_source_files_properties(${${SRCS}} PROPERTIES COMPILE_FLAGS "/Yu${PCHPREFIX}.h /FI${PCHPREFIX}.h /Fp${PCH_NAME} /Zm300" OBJECT_DEPENDS "${PCH_NAME}") # make PCHPREFIX.cpp file compile and generate PCH_NAME set_source_files_properties("${PCHPREFIX}.cpp" PROPERTIES COMPILE_FLAGS "/Yc${PCHPREFIX}.h /Fp${PCH_NAME} /Zm300" OBJECT_OUTPUTS "${PCH_NAME}") list(APPEND ${SRCS} "${PCHPREFIX}.cpp") endif() endmacro(spvtools_pch) add_subdirectory(external) # Warning about extra semi-colons. # # This is not supported on all compilers/versions. so enabling only # for clang, since that works for all versions that our bots run. # # This is intentionally done after adding the external subdirectory, # so we don't enforce this flag on our dependencies, some of which do # not pass it. # # If the minimum version of CMake supported is updated to 3.0 or # later, then check_cxx_compiler_flag could be used instead. if("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") add_compile_options("-Wextra-semi") endif() add_subdirectory(source) add_subdirectory(tools) add_subdirectory(test) add_subdirectory(examples) if(ENABLE_SPIRV_TOOLS_INSTALL) install( FILES ${CMAKE_CURRENT_SOURCE_DIR}/include/spirv-tools/libspirv.h ${CMAKE_CURRENT_SOURCE_DIR}/include/spirv-tools/libspirv.hpp ${CMAKE_CURRENT_SOURCE_DIR}/include/spirv-tools/optimizer.hpp ${CMAKE_CURRENT_SOURCE_DIR}/include/spirv-tools/linker.hpp DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/spirv-tools/) endif(ENABLE_SPIRV_TOOLS_INSTALL) if (NOT "${SPIRV_SKIP_TESTS}") add_test(NAME spirv-tools-copyrights COMMAND Python3::Interpreter utils/check_copyright.py WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}) endif() set(SPIRV_LIBRARIES "-lSPIRV-Tools-opt -lSPIRV-Tools -lSPIRV-Tools-link") set(SPIRV_SHARED_LIBRARIES "-lSPIRV-Tools-shared") # Build pkg-config file # Use a first-class target so it's regenerated when relevant files are updated. add_custom_command( OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/SPIRV-Tools.pc COMMAND ${CMAKE_COMMAND} -DCHANGES_FILE=${CMAKE_CURRENT_SOURCE_DIR}/CHANGES -DTEMPLATE_FILE=${CMAKE_CURRENT_SOURCE_DIR}/cmake/SPIRV-Tools.pc.in -DOUT_FILE=${CMAKE_CURRENT_BINARY_DIR}/SPIRV-Tools.pc -DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX} -DCMAKE_INSTALL_LIBDIR=${CMAKE_INSTALL_LIBDIR} -DCMAKE_INSTALL_INCLUDEDIR=${CMAKE_INSTALL_INCLUDEDIR} -DSPIRV_LIBRARIES=${SPIRV_LIBRARIES} -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/write_pkg_config.cmake DEPENDS "CHANGES" "${CMAKE_CURRENT_SOURCE_DIR}/cmake/SPIRV-Tools.pc.in" "${CMAKE_CURRENT_SOURCE_DIR}/cmake/write_pkg_config.cmake") add_custom_command( OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/SPIRV-Tools-shared.pc COMMAND ${CMAKE_COMMAND} -DCHANGES_FILE=${CMAKE_CURRENT_SOURCE_DIR}/CHANGES -DTEMPLATE_FILE=${CMAKE_CURRENT_SOURCE_DIR}/cmake/SPIRV-Tools-shared.pc.in -DOUT_FILE=${CMAKE_CURRENT_BINARY_DIR}/SPIRV-Tools-shared.pc -DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX} -DCMAKE_INSTALL_LIBDIR=${CMAKE_INSTALL_LIBDIR} -DCMAKE_INSTALL_INCLUDEDIR=${CMAKE_INSTALL_INCLUDEDIR} -DSPIRV_SHARED_LIBRARIES=${SPIRV_SHARED_LIBRARIES} -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/write_pkg_config.cmake DEPENDS "CHANGES" "${CMAKE_CURRENT_SOURCE_DIR}/cmake/SPIRV-Tools-shared.pc.in" "${CMAKE_CURRENT_SOURCE_DIR}/cmake/write_pkg_config.cmake") add_custom_target(spirv-tools-pkg-config ALL DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/SPIRV-Tools-shared.pc ${CMAKE_CURRENT_BINARY_DIR}/SPIRV-Tools.pc) # Install pkg-config file if (ENABLE_SPIRV_TOOLS_INSTALL) install( FILES ${CMAKE_CURRENT_BINARY_DIR}/SPIRV-Tools.pc ${CMAKE_CURRENT_BINARY_DIR}/SPIRV-Tools-shared.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig) endif() KhronosGroup-SPIRV-Tools-f289d04/CODE_OF_CONDUCT.md000066400000000000000000000004301475742701700213250ustar00rootroot00000000000000A reminder that this issue tracker is managed by the Khronos Group. Interactions here should follow the Khronos Code of Conduct (https://www.khronos.org/developers/code-of-conduct), which prohibits aggressive or derogatory language. Please keep the discussion friendly and civil. KhronosGroup-SPIRV-Tools-f289d04/CONTRIBUTING.md000066400000000000000000000161771475742701700207760ustar00rootroot00000000000000# Contributing to SPIR-V Tools ## For users: Reporting bugs and requesting features We organize known future work in GitHub projects. See [Tracking SPIRV-Tools work with GitHub projects](https://github.com/KhronosGroup/SPIRV-Tools/blob/main/docs/projects.md) for more. To report a new bug or request a new feature, please file a GitHub issue. Please ensure the bug has not already been reported by searching [issues](https://github.com/KhronosGroup/SPIRV-Tools/issues) and [projects](https://github.com/KhronosGroup/SPIRV-Tools/projects). If the bug has not already been reported open a new one [here](https://github.com/KhronosGroup/SPIRV-Tools/issues/new). When opening a new issue for a bug, make sure you provide the following: * A clear and descriptive title. * We want a title that will make it easy for people to remember what the issue is about. Simply using "Segfault in spirv-opt" is not helpful because there could be (but hopefully aren't) multiple bugs with segmentation faults with different causes. * A test case that exposes the bug, with the steps and commands to reproduce it. * The easier it is for a developer to reproduce the problem, the quicker a fix can be found and verified. It will also make it easier for someone to possibly realize the bug is related to another issue. For feature requests, we use [issues](https://github.com/KhronosGroup/SPIRV-Tools/issues) as well. Please create a new issue, as with bugs. In the issue provide * A description of the problem that needs to be solved. * Examples that demonstrate the problem. ## For developers: Contributing a patch Before we can use your code, you must sign the [Khronos Open Source Contributor License Agreement](https://cla-assistant.io/KhronosGroup/SPIRV-Tools) (CLA), which you can do online. The CLA is necessary mainly because you own the copyright to your changes, even after your contribution becomes part of our codebase, so we need your permission to use and distribute your code. We also need to be sure of various other things -- for instance that you'll tell us if you know that your code infringes on other people's patents. You don't have to sign the CLA until after you've submitted your code for review and a member has approved it, but you must do it before we can put your code into our codebase. See [README.md](https://github.com/KhronosGroup/SPIRV-Tools/blob/main/README.md) for instruction on how to get, build, and test the source. Once you have made your changes: * Ensure the code follows the [Google C++ Style Guide](https://google.github.io/styleguide/cppguide.html). Running `clang-format -style=file -i [modified-files]` can help. * Create a pull request (PR) with your patch. * Make sure the PR description clearly identified the problem, explains the solution, and references the issue if applicable. * If your patch completely fixes bug 1234, the commit message should say `Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1234` When you do this, the issue will be closed automatically when the commit goes into main. Also, this helps us update the [CHANGES](CHANGES) file. * Watch the continuous builds to make sure they pass. * Request a code review. The reviewer can either approve your PR or request changes. If changes are requested: * Please add new commits to your branch, instead of amending your commit. Adding new commits makes it easier for the reviewer to see what has changed since the last review. * Once you are ready for another round of reviews, add a comment at the bottom, such as "Ready for review" or "Please take a look" (or "PTAL"). This explicit handoff is useful when responding with multiple small commits. After the PR has been reviewed it is the job of the reviewer to merge the PR. Instructions for this are given below. ## For maintainers: Reviewing a PR The formal code reviews are done on GitHub. Reviewers are to look for all of the usual things: * Coding style follows the [Google C++ Style Guide](https://google.github.io/styleguide/cppguide.html) * Identify potential functional problems. * Identify code duplication. * Ensure the unit tests have enough coverage. * Ensure continuous integration (CI) bots run on the PR. If not run (in the case of PRs by external contributors), add the "kokoro:run" label to the pull request which will trigger running all CI jobs. When looking for functional problems, there are some common problems reviewers should pay particular attention to: * Does the code work for both Shader (Vulkan and OpenGL) and Kernel (OpenCL) scenarios? The respective SPIR-V dialects are slightly different. * Changes are made to a container while iterating through it. You have to be careful that iterators are not invalidated or that elements are not skipped. * For SPIR-V transforms: The module is changed, but the analyses are not updated. For example, a new instruction is added, but the def-use manager is not updated. Later on, it is possible that the def-use manager will be used, and give wrong results. * If a pass gets the id of a type from the type manager, make sure the type is not a struct or array. It there are two structs that look the same, the type manager can return the wrong one. ## For maintainers: Merging a PR We intend to maintain a linear history on the GitHub main branch, and the build and its tests should pass at each commit in that history. A linear always-working history is easier to understand and to bisect in case we want to find which commit introduced a bug. The [Squash and Merge](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/incorporating-changes-from-a-pull-request/about-pull-request-merges#squash-and-merge-your-commits) button on the GitHub web interface. All other ways of merging on the web interface have been disabled. Before merging, we generally require: 1. All tests except for the smoke test pass. See [failing smoke test](#failing-smoke-test). 1. The PR is approved by at least one of the maintainers. If the PR modifies different parts of the code, then multiple reviewers might be necessary. The squash-and-merge button will turn green when these requirements are met. Maintainers have the to power to merge even if the button is not green, but that is discouraged. ### Failing smoke test The purpose of the smoke test is to let us know if [shaderc](https://github.com/google/shaderc) fails to build with the change. If it fails, the maintainer needs to determine if the reason for the failure is a problem in the current PR or if another repository needs to be changed. Most of the time [Glslang](https://github.com/KhronosGroup/glslang) needs to be updated to account for the change in SPIR-V Tools. The PR can still be merged if the problem is not with that PR. ## For maintainers: Running tests For security reasons, not all tests will run automatically. When they do not, a maintainer will have to start the tests. If the Github actions tests do not run on a PR, they can be initiated by closing and reopening the PR. If the kokoro tests are not run, they can be run by adding the label `kokoro:run` to the PR. KhronosGroup-SPIRV-Tools-f289d04/DEPS000066400000000000000000000021561475742701700172130ustar00rootroot00000000000000use_relative_paths = True vars = { 'github': 'https://github.com', 'abseil_revision': 'f004e6c0a9a25e16fd2a1ae671a9cacfa79625b4', 'effcee_revision': '12241cbc30f20730b656db7fd5a3fa36cd420843', 'googletest_revision': 'c00fd25b71a17e645e4567fcb465c3fa532827d2', # Use protobufs before they gained the dependency on abseil 'protobuf_revision': 'v21.12', 're2_revision': '6dcd83d60f7944926bfd308cc13979fc53dd69ca', 'spirv_headers_revision': '09913f088a1197aba4aefd300a876b2ebbaa3391', } deps = { 'external/abseil_cpp': Var('github') + '/abseil/abseil-cpp.git@' + Var('abseil_revision'), 'external/effcee': Var('github') + '/google/effcee.git@' + Var('effcee_revision'), 'external/googletest': Var('github') + '/google/googletest.git@' + Var('googletest_revision'), 'external/protobuf': Var('github') + '/protocolbuffers/protobuf.git@' + Var('protobuf_revision'), 'external/re2': Var('github') + '/google/re2.git@' + Var('re2_revision'), 'external/spirv-headers': Var('github') + '/KhronosGroup/SPIRV-Headers.git@' + Var('spirv_headers_revision'), } KhronosGroup-SPIRV-Tools-f289d04/LICENSE000066400000000000000000000261361475742701700175460ustar00rootroot00000000000000 Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright [yyyy] [name of copyright owner] Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. KhronosGroup-SPIRV-Tools-f289d04/MODULE.bazel000066400000000000000000000015431475742701700205400ustar00rootroot00000000000000bazel_dep(name = "bazel_skylib", version = "1.5.0") bazel_dep(name = "googletest", dev_dependency = True) local_path_override( module_name = "googletest", path = "external/googletest", ) bazel_dep(name = "re2", dev_dependency = True) local_path_override( module_name = "re2", path = "external/re2", ) bazel_dep(name = "effcee", dev_dependency = True) local_path_override( module_name = "effcee", path = "external/effcee", ) bazel_dep(name = "rules_python", version = "0.34.0") # https://rules-python.readthedocs.io/en/stable/toolchains.html#library-modules-with-dev-only-python-usage python = use_extension( "@rules_python//python/extensions:python.bzl", "python", dev_dependency = True ) python.toolchain(python_version = "3.12", is_default = True, ignore_root_user_error = True) KhronosGroup-SPIRV-Tools-f289d04/PRESUBMIT.py000066400000000000000000000024171475742701700204610ustar00rootroot00000000000000# Copyright (c) 2018 The Khronos Group Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Presubmit script for SPIRV-Tools. See http://dev.chromium.org/developers/how-tos/depottools/presubmit-scripts for more details about the presubmit API built into depot_tools. """ USE_PYTHON3 = True LINT_FILTERS = [ "-build/storage_class", "-readability/casting", "-readability/fn_size", "-readability/todo", "-runtime/explicit", "-runtime/int", "-runtime/printf", "-runtime/references", "-runtime/string", ] def CheckChangeOnUpload(input_api, output_api): results = [] results += input_api.canned_checks.CheckPatchFormatted(input_api, output_api) results += input_api.canned_checks.CheckChangeLintsClean( input_api, output_api, None, LINT_FILTERS) return results KhronosGroup-SPIRV-Tools-f289d04/README.md000066400000000000000000000745561475742701700200310ustar00rootroot00000000000000# SPIR-V Tools [![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/KhronosGroup/SPIRV-Tools/badge)](https://securityscorecards.dev/viewer/?uri=github.com/KhronosGroup/SPIRV-Tools) NEWS 2023-01-11: Development occurs on the `main` branch. ## Overview The SPIR-V Tools project provides an API and commands for processing SPIR-V modules. The project includes an assembler, binary module parser, disassembler, validator, and optimizer for SPIR-V. Except for the optimizer, all are based on a common static library. The library contains all of the implementation details, and is used in the standalone tools whilst also enabling integration into other code bases directly. The optimizer implementation resides in its own library, which depends on the core library. The interfaces have stabilized: We don't anticipate making a breaking change for existing features. SPIR-V is defined by the Khronos Group Inc. See the [SPIR-V Registry][spirv-registry] for the SPIR-V specification, headers, and XML registry. ## Downloads The official releases for SPIRV-Tools can be found on LunarG's [SDK download page](https://vulkan.lunarg.com/sdk/home). For convenience, here are also links to the latest builds (HEAD). Those are untested automated builds. Those are not official releases, nor are guaranteed to work. Official releases builds are in the Vulkan SDK. Linux[![Linux Build Status](https://storage.googleapis.com/spirv-tools/badges/build_status_linux_clang_release.svg)](https://storage.googleapis.com/spirv-tools/badges/build_link_linux_clang_release.html) MacOS[![MacOS Build Status](https://storage.googleapis.com/spirv-tools/badges/build_status_macos_clang_release.svg)](https://storage.googleapis.com/spirv-tools/badges/build_link_macos_clang_release.html) Windows[![Windows Build Status](https://storage.googleapis.com/spirv-tools/badges/build_status_windows_vs2022_release.svg)](https://storage.googleapis.com/spirv-tools/badges/build_link_windows_vs2022_release.html) [More downloads](docs/downloads.md) ## Versioning SPIRV-Tools See [`CHANGES`](CHANGES) for a high level summary of recent changes, by version. SPIRV-Tools project version numbers are of the form `v`*year*`.`*index* and with an optional `-dev` suffix to indicate work in progress. For example, the following versions are ordered from oldest to newest: * `v2016.0` * `v2016.1-dev` * `v2016.1` * `v2016.2-dev` * `v2016.2` Use the `--version` option on each command line tool to see the software version. An API call reports the software version as a C-style string. ## Releases The official releases for SPIRV-Tools can be found on LunarG's [SDK download page](https://vulkan.lunarg.com/sdk/home). You can find either the prebuilt, and QA tested binaries, or download the SDK Config, which lists the commits to use to build the release from scratch. GitHub releases are deprecated, and we will not publish new releases until further notice. ## Supported features ### Assembler, binary parser, and disassembler * Support for SPIR-V 1.0, through 1.5 * Based on SPIR-V syntax described by JSON grammar files in the [SPIRV-Headers](https://github.com/KhronosGroup/SPIRV-Headers) repository. * Usually, support for a new version of SPIR-V is ready within days after publication. * Support for extended instruction sets: * GLSL std450 version 1.0 Rev 3 * OpenCL version 1.0 Rev 2 * Assembler only does basic syntax checking. No cross validation of IDs or types is performed, except to check literal arguments to `OpConstant`, `OpSpecConstant`, and `OpSwitch`. * Where tools expect binary input, a hex stream may be provided instead. See `spirv-dis --help`. See [`docs/syntax.md`](docs/syntax.md) for the assembly language syntax. ### Validator The validator checks validation rules described by the SPIR-V specification. Khronos recommends that tools that create or transform SPIR-V modules use the validator to ensure their outputs are valid, and that tools that consume SPIR-V modules optionally use the validator to protect themselves from bad inputs. This is especially encouraged for debug and development scenarios. The validator has one-sided error: it will only return an error when it has implemented a rule check and the module violates that rule. The validator is incomplete. See the [CHANGES](CHANGES) file for reports on completed work, and the [Validator sub-project](https://github.com/KhronosGroup/SPIRV-Tools/projects/1) for planned and in-progress work. *Note*: The validator checks some Universal Limits, from section 2.17 of the SPIR-V spec. The validator will fail on a module that exceeds those minimum upper bound limits. The validator has been parameterized to allow larger values, for use when targeting a more-than-minimally-capable SPIR-V consumer. See [`tools/val/val.cpp`](tools/val/val.cpp) or run `spirv-val --help` for the command-line help. ### Optimizer The optimizer is a collection of code transforms, or "passes". Transforms are written for a diverse set of reasons: * To restructure, simplify, or normalize the code for further processing. * To eliminate undesirable code. * To improve code quality in some metric such as size or performance. **Note**: These transforms are not guaranteed to actually improve any given metric. Users should always measure results for their own situation. As of this writing, there are 67 transforms including examples such as: * Simplification * Strip debug info * Strip reflection info * Specialization Constants * Set spec constant default value * Freeze spec constant to default value * Fold `OpSpecConstantOp` and `OpSpecConstantComposite` * Unify constants * Eliminate dead constant * Code Reduction * Inline all function calls exhaustively * Convert local access chains to inserts/extracts * Eliminate local load/store in single block * Eliminate local load/store with single store * Eliminate local load/store with multiple stores * Eliminate local extract from insert * Eliminate dead instructions (aggressive) * Eliminate dead branches * Merge single successor / single predecessor block pairs * Eliminate common uniform loads * Remove duplicates: Capabilities, extended instruction imports, types, and decorations. * Normalization * Compact IDs * CFG cleanup * Flatten decorations * Merge returns * Convert AMD-specific instructions to KHR instructions * Code improvement * Conditional constant propagation * If-conversion * Loop fission * Loop fusion * Loop-invariant code motion * Loop unroll * Other * Graphics robust access * Upgrade memory model to VulkanKHR Additionally, certain sets of transformations have been packaged into higher-level recipes. These include: * Optimization for size (`spirv-opt -Os`) * Optimization for performance (`spirv-opt -O`) For the latest list with detailed documentation, please refer to [`include/spirv-tools/optimizer.hpp`](include/spirv-tools/optimizer.hpp). For suggestions on using the code reduction options, please refer to this [white paper](https://www.lunarg.com/shader-compiler-technologies/white-paper-spirv-opt/). ### Linker *Note:* The linker is still under development. Current features: * Combine multiple SPIR-V binary modules together. * Combine into a library (exports are retained) or an executable (no symbols are exported). See the [CHANGES](CHANGES) file for reports on completed work, and the [General sub-project](https://github.com/KhronosGroup/SPIRV-Tools/projects/2) for planned and in-progress work. ### Reducer *Note:* The reducer is still under development. The reducer simplifies and shrinks a SPIR-V module with respect to a user-supplied *interestingness function*. For example, given a large SPIR-V module that cause some SPIR-V compiler to fail with a given fatal error message, the reducer could be used to look for a smaller version of the module that causes the compiler to fail with the same fatal error message. To suggest an additional capability for the reducer, [file an issue](https://github.com/KhronosGroup/SPIRV-Tools/issues]) with "Reducer:" as the start of its title. ### Fuzzer *Note:* The fuzzer is still under development. The fuzzer applies semantics-preserving transformations to a SPIR-V binary module, to produce an equivalent module. The original and transformed modules should produce essentially identical results when executed on identical inputs: their results should differ only due to floating-point round-off, if at all. Significant differences in results can pinpoint bugs in tools that process SPIR-V binaries, such as miscompilations. This *metamorphic testing* approach is similar to the method used by the [GraphicsFuzz project](https://github.com/google/graphicsfuzz) for fuzzing of GLSL shaders. To suggest an additional capability for the fuzzer, [file an issue](https://github.com/KhronosGroup/SPIRV-Tools/issues]) with "Fuzzer:" as the start of its title. ### Diff *Note:* The diff tool is still under development. The diff tool takes two SPIR-V files, either in binary or text format and produces a diff-style comparison between the two. The instructions between the src and dst modules are matched as best as the tool can, and output is produced (in src id-space) that shows which instructions are removed in src, added in dst or modified between them. The order of instructions are not retained. Matching instructions between two SPIR-V modules is not trivial, and thus a number of heuristics are applied in this tool. In particular, without debug information, match functions is nontrivial as they can be reordered. As such, this tool is primarily useful to produce the diff of two SPIR-V modules derived from the same source, for example before and after a modification to the shader, before and after a transformation, or SPIR-V produced from different tools. ### Extras * [Utility filters](#utility-filters) * Build target `spirv-tools-vimsyntax` generates file `spvasm.vim`. Copy that file into your `$HOME/.vim/syntax` directory to get SPIR-V assembly syntax highlighting in Vim. This build target is not built by default. ## Contributing The SPIR-V Tools project is maintained by members of the The Khronos Group Inc., and is hosted at https://github.com/KhronosGroup/SPIRV-Tools. Consider joining the `public_spirv_tools_dev@khronos.org` mailing list, via [https://www.khronos.org/spir/spirv-tools-mailing-list/](https://www.khronos.org/spir/spirv-tools-mailing-list/). The mailing list is used to discuss development plans for the SPIRV-Tools as an open source project. Once discussion is resolved, specific work is tracked via issues and sometimes in one of the [projects][spirv-tools-projects]. (To provide feedback on the SPIR-V _specification_, file an issue on the [SPIRV-Headers][spirv-headers] GitHub repository.) See [`docs/projects.md`](docs/projects.md) to see how we use the [GitHub Project feature](https://help.github.com/articles/tracking-the-progress-of-your-work-with-projects/) to organize planned and in-progress work. Contributions via merge request are welcome. Changes should: * Be provided under the [Apache 2.0](#license). * You'll be prompted with a one-time "click-through" [Khronos Open Source Contributor License Agreement][spirv-tools-cla] (CLA) dialog as part of submitting your pull request or other contribution to GitHub. * Include tests to cover updated functionality. * C++ code should follow the [Google C++ Style Guide][cpp-style-guide]. * Code should be formatted with `clang-format`. [kokoro/check-format/build.sh](kokoro/check-format/build.sh) shows how to download it. Note that we currently use `clang-format version 5.0.0` for SPIRV-Tools. Settings are defined by the included [.clang-format](.clang-format) file. We intend to maintain a linear history on the GitHub `main` branch. ### Getting the source Example of getting sources, assuming SPIRV-Tools is configured as a standalone project: git clone https://github.com/KhronosGroup/SPIRV-Tools.git spirv-tools cd spirv-tools # Check out sources for dependencies, at versions known to work together, # as listed in the DEPS file. python3 utils/git-sync-deps For some kinds of development, you may need the latest sources from the third-party projects: git clone https://github.com/KhronosGroup/SPIRV-Headers.git spirv-tools/external/spirv-headers git clone https://github.com/google/googletest.git spirv-tools/external/googletest git clone https://github.com/google/effcee.git spirv-tools/external/effcee git clone https://github.com/google/re2.git spirv-tools/external/re2 git clone https://github.com/abseil/abseil-cpp.git spirv-tools/external/abseil_cpp #### Dependency on Effcee Some tests depend on the [Effcee][effcee] library for stateful matching. Effcee itself depends on [RE2][re2], and RE2 depends on [Abseil][abseil-cpp]. * If SPIRV-Tools is configured as part of a larger project that already uses Effcee, then that project should include Effcee before SPIRV-Tools. * Otherwise, SPIRV-Tools expects Effcee sources to appear in `external/effcee`, RE2 sources to appear in `external/re2`, and Abseil sources to appear in `external/abseil_cpp`. ### Source code organization * `example`: demo code of using SPIRV-Tools APIs * `external/googletest`: Intended location for the [googletest][googletest] sources, not provided * `external/effcee`: Location of [Effcee][effcee] sources, if the `effcee` library is not already configured by an enclosing project. * `external/re2`: Location of [RE2][re2] sources, if the `re2` library is not already configured by an enclosing project. (The Effcee project already requires RE2.) * `external/abseil_cpp`: Location of [Abseil][abseil-cpp] sources, if Abseil is not already configured by an enclosing project. (The RE2 project already requires Abseil.) * `include/`: API clients should add this directory to the include search path * `external/spirv-headers`: Intended location for [SPIR-V headers][spirv-headers], not provided * `include/spirv-tools/libspirv.h`: C API public interface * `source/`: API implementation * `test/`: Tests, using the [googletest][googletest] framework * `tools/`: Command line executables ### Tests The project contains a number of tests, used to drive development and ensure correctness. The tests are written using the [googletest][googletest] framework. The `googletest` source is not provided with this project. There are two ways to enable tests: * If SPIR-V Tools is configured as part of an enclosing project, then the enclosing project should configure `googletest` before configuring SPIR-V Tools. * If SPIR-V Tools is configured as a standalone project, then download the `googletest` source into the `/external/googletest` directory before configuring and building the project. ## Build *Note*: Prebuilt binaries are available from the [downloads](docs/downloads.md) page. First [get the sources](#getting-the-source). Then build using CMake, Bazel, Android ndk-build, or the Emscripten SDK. ### Build using CMake You can build the project using [CMake][cmake]: ```sh cd mkdir build && cd build cmake [-G ] ``` Once the build files have been generated, build using the appropriate build command (e.g. `ninja`, `make`, `msbuild`, etc.; this depends on the platform generator used above), or use your IDE, or use CMake to run the appropriate build command for you: ```sh cmake --build . [--config Debug] # runs `make` or `ninja` or `msbuild` etc. ``` #### Note about the fuzzer The SPIR-V fuzzer, `spirv-fuzz`, can only be built via CMake, and is disabled by default. To build it, clone protobuf and use the `SPIRV_BUILD_FUZZER` CMake option, like so: ```sh # In (the SPIRV-Tools repo root): git clone --depth=1 --branch v3.13.0.1 https://github.com/protocolbuffers/protobuf external/protobuf # In your build directory: cmake [-G ] -DSPIRV_BUILD_FUZZER=ON cmake --build . --config Debug ``` You can also add `-DSPIRV_ENABLE_LONG_FUZZER_TESTS=ON` to build additional fuzzer tests. ### Build using Bazel You can also use [Bazel](https://bazel.build/) to build the project. ```sh bazel build :all ``` ### Build a node.js package using Emscripten The SPIRV-Tools core library can be built to a WebAssembly [node.js](https://nodejs.org) module. The resulting `SpirvTools` WebAssembly module only exports methods to assemble and disassemble SPIR-V modules. First, make sure you have the [Emscripten SDK](https://emscripten.org). Then: ```sh cd ./source/wasm/build.sh ``` The resulting node package, with JavaScript and TypeScript bindings, is written to `/out/web`. Note: This builds the package locally. It does *not* publish it to [npm](https://npmjs.org). To test the result: ```sh node ./test/wasm/test.js ``` ### Tools you'll need For building and testing SPIRV-Tools, the following tools should be installed regardless of your OS: - [CMake](http://www.cmake.org/): if using CMake for generating compilation targets, you need to install CMake Version 2.8.12 or later. - [Python 3](http://www.python.org/): for utility scripts and running the test suite. - [Bazel](https://bazel.build/) (optional): if building the source with Bazel, you need to install Bazel Version 7.0.2 on your machine. Other versions may also work, but are not verified. - [Emscripten SDK](https://emscripten.org) (optional): if building the WebAssembly module. SPIRV-Tools is regularly tested with the following compilers: On Linux - GCC version 9.4 - Clang version 10.0 On MacOS - AppleClang 15.0 On Windows - Visual Studio 2019 - Visual Studio 2022 Note: Other compilers or later versions may work, but they are not tested. ### CMake options The following CMake options are supported: * `SPIRV_BUILD_FUZZER={ON|OFF}`, default `OFF` - Build the spirv-fuzz tool. * `SPIRV_COLOR_TERMINAL={ON|OFF}`, default `ON` - Enables color console output. * `SPIRV_SKIP_TESTS={ON|OFF}`, default `OFF`- Build only the library and the command line tools. This will prevent the tests from being built. * `SPIRV_SKIP_EXECUTABLES={ON|OFF}`, default `OFF`- Build only the library, not the command line tools and tests. * `SPIRV_USE_SANITIZER=`, default is no sanitizing - On UNIX platforms with an appropriate version of `clang` this option enables the use of the sanitizers documented [here][clang-sanitizers]. This should only be used with a debug build. * `SPIRV_WARN_EVERYTHING={ON|OFF}`, default `OFF` - On UNIX platforms enable more strict warnings. The code might not compile with this option enabled. For Clang, enables `-Weverything`. For GCC, enables `-Wpedantic`. See [`CMakeLists.txt`](CMakeLists.txt) for details. * `SPIRV_WERROR={ON|OFF}`, default `ON` - Forces a compilation error on any warnings encountered by enabling the compiler-specific compiler front-end option. No compiler front-end options are enabled when this option is OFF. Additionally, you can pass additional C preprocessor definitions to SPIRV-Tools via setting `SPIRV_TOOLS_EXTRA_DEFINITIONS`. For example, by setting it to `/D_ITERATOR_DEBUG_LEVEL=0` on Windows, you can disable checked iterators and iterator debugging. ### Android ndk-build SPIR-V Tools supports building static libraries `libSPIRV-Tools.a` and `libSPIRV-Tools-opt.a` for Android. Using the Android NDK r25c or later: ``` cd export ANDROID_NDK=/path/to/your/ndk # NDK r25c or later mkdir build && cd build mkdir libs mkdir app $ANDROID_NDK/ndk-build -C ../android_test \ NDK_PROJECT_PATH=. \ NDK_LIBS_OUT=`pwd`/libs \ NDK_APP_OUT=`pwd`/app ``` ### Updating DEPS Occasionally the entries in [DEPS](DEPS) will need to be updated. This is done on demand when there is a request to do this, often due to downstream breakages. To update `DEPS`, run `utils/roll_deps.sh` and confirm that tests pass. The script requires Chromium's [`depot_tools`](https://chromium.googlesource.com/chromium/tools/depot_tools). ## Library ### Usage The internals of the library use C++17 features, and are exposed via both a C and C++ API. In order to use the library from an application, the include path should point to `/include`, which will enable the application to include the header `/include/spirv-tools/libspirv.h{|pp}` then linking against the static library in `/source/libSPIRV-Tools.a` or `/source/SPIRV-Tools.lib`. For optimization, the header file is `/include/spirv-tools/optimizer.hpp`, and the static library is `/source/libSPIRV-Tools-opt.a` or `/source/SPIRV-Tools-opt.lib`. * `SPIRV-Tools` CMake target: Creates the static library: * `/source/libSPIRV-Tools.a` on Linux and OS X. * `/source/libSPIRV-Tools.lib` on Windows. * `SPIRV-Tools-opt` CMake target: Creates the static library: * `/source/libSPIRV-Tools-opt.a` on Linux and OS X. * `/source/libSPIRV-Tools-opt.lib` on Windows. #### Entry points The interfaces are still under development, and are expected to change. There are five main entry points into the library in the C interface: * `spvTextToBinary`: An assembler, translating text to a binary SPIR-V module. * `spvBinaryToText`: A disassembler, translating a binary SPIR-V module to text. * `spvBinaryParse`: The entry point to a binary parser API. It issues callbacks for the header and each parsed instruction. The disassembler is implemented as a client of `spvBinaryParse`. * `spvValidate` implements the validator functionality. *Incomplete* * `spvValidateBinary` implements the validator functionality. *Incomplete* The C++ interface is comprised of three classes, `SpirvTools`, `Optimizer` and `Linker`, all in the `spvtools` namespace. * `SpirvTools` provides `Assemble`, `Disassemble`, and `Validate` methods. * `Optimizer` provides methods for registering and running optimization passes. * `Linker` provides methods for combining together multiple binaries. ## Command line tools Command line tools, which wrap the above library functions, are provided to assemble or disassemble shader files. It's a convention to name SPIR-V assembly and binary files with suffix `.spvasm` and `.spv`, respectively. ### Assembler tool The assembler reads the assembly language text, and emits the binary form. The standalone assembler is the executable called `spirv-as`, and is located in `/tools/spirv-as`. The functionality of the assembler is implemented by the `spvTextToBinary` library function. * `spirv-as` - the standalone assembler * `/tools/as` Use option `-h` to print help. ### Disassembler tool The disassembler reads the binary form, and emits assembly language text. The standalone disassembler is the executable called `spirv-dis`, and is located in `/tools/spirv-dis`. The functionality of the disassembler is implemented by the `spvBinaryToText` library function. * `spirv-dis` - the standalone disassembler * `/tools/dis` Use option `-h` to print help. The output includes syntax colouring when printing to the standard output stream, on Linux, Windows, and OS X. ### Linker tool The linker combines multiple SPIR-V binary modules together, resulting in a single binary module as output. This is a work in progress. The linker does not support OpenCL program linking options related to math flags. (See section 5.6.5.2 in OpenCL 1.2) * `spirv-link` - the standalone linker * `/tools/link` ### Optimizer tool The optimizer processes a SPIR-V binary module, applying transformations in the specified order. This is a work in progress, with initially only few available transformations. * `spirv-opt` - the standalone optimizer * `/tools/opt` ### Validator tool *Warning:* This functionality is under development, and is incomplete. The standalone validator is the executable called `spirv-val`, and is located in `/tools/spirv-val`. The functionality of the validator is implemented by the `spvValidate` library function. The validator operates on the binary form. * `spirv-val` - the standalone validator * `/tools/val` ### Reducer tool The reducer shrinks a SPIR-V binary module, guided by a user-supplied *interestingness test*. This is a work in progress, with initially only shrinks a module in a few ways. * `spirv-reduce` - the standalone reducer * `/tools/reduce` Run `spirv-reduce --help` to see how to specify interestingness. ### Fuzzer tool The fuzzer transforms a SPIR-V binary module into a semantically-equivalent SPIR-V binary module by applying transformations in a randomized fashion. This is a work in progress, with initially only a few semantics-preserving transformations. * `spirv-fuzz` - the standalone fuzzer * `/tools/fuzz` Run `spirv-fuzz --help` for a detailed list of options. ### Control flow dumper tool The control flow dumper prints the control flow graph for a SPIR-V module as a [GraphViz](http://www.graphviz.org/) graph. This is experimental. * `spirv-cfg` - the control flow graph dumper * `/tools/cfg` ### Diff tool *Warning:* This functionality is under development, and is incomplete. The diff tool produces a diff-style comparison between two SPIR-V modules. * `spirv-diff` - the standalone diff tool * ``/tools/diff` ### Utility filters * `spirv-lesspipe.sh` - Automatically disassembles `.spv` binary files for the `less` program, on compatible systems. For example, set the `LESSOPEN` environment variable as follows, assuming both `spirv-lesspipe.sh` and `spirv-dis` are on your executable search path: ``` export LESSOPEN='| spirv-lesspipe.sh "%s"' ``` Then you page through a disassembled module as follows: ``` less foo.spv ``` * The `spirv-lesspipe.sh` script will pass through any extra arguments to `spirv-dis`. So, for example, you can turn off colours and friendly ID naming as follows: ``` export LESSOPEN='| spirv-lesspipe.sh "%s" --no-color --raw-id' ``` * [vim-spirv](https://github.com/kbenzie/vim-spirv) - A vim plugin which supports automatic disassembly of `.spv` files using the `:edit` command and assembly using the `:write` command. The plugin also provides additional features which include; syntax highlighting; highlighting of all ID's matching the ID under the cursor; and highlighting errors where the `Instruction` operand of `OpExtInst` is used without an appropriate `OpExtInstImport`. * `50spirv-tools.el` - Automatically disassembles '.spv' binary files when loaded into the emacs text editor, and re-assembles them when saved, provided any modifications to the file are valid. This functionality must be explicitly requested by defining the symbol SPIRV_TOOLS_INSTALL_EMACS_HELPERS as follows: ``` cmake -DSPIRV_TOOLS_INSTALL_EMACS_HELPERS=true ... ``` In addition, this helper is only installed if the directory /etc/emacs/site-start.d exists, which is typically true if emacs is installed on the system. Note that symbol IDs are not currently preserved through a load/edit/save operation. This may change if the ability is added to spirv-as. ### Tests Tests are only built when googletest is found. #### Running test with CMake Use `ctest -j ` to run all the tests. To run tests using all threads: ```shell ctest -j$(nproc) ``` To run a single test target, use `ctest [-j ] -R `. For example, you can run all `opt` tests with: ```shell ctest -R 'spirv-tools-test_opt' ``` #### Running test with Bazel Use `bazel test :all` to run all tests. This will run tests in parallel by default. To run a single test target, specify `:my_test_target` instead of `:all`. Test target names get printed when you run `bazel test :all`. For example, you can run `opt_def_use_test` with: on linux: ```shell bazel test --cxxopt=-std=c++17 :opt_def_use_test ``` on windows: ```shell bazel test --cxxopt=/std:c++17 :opt_def_use_test ``` ## Future Work _See the [projects pages](https://github.com/KhronosGroup/SPIRV-Tools/projects) for more information._ ### Assembler and disassembler * The disassembler could emit helpful annotations in comments. For example: * Use variable name information from debug instructions to annotate key operations on variables. * Show control flow information by annotating `OpLabel` instructions with that basic block's predecessors. * Error messages could be improved. ### Validator This is a work in progress. ### Linker * The linker could accept math transformations such as allowing MADs, or other math flags passed at linking-time in OpenCL. * Linkage attributes can not be applied through a group. * Check decorations of linked functions attributes. * Remove dead instructions, such as OpName targeting imported symbols. ## Licence Full license terms are in [LICENSE](LICENSE) ``` Copyright (c) 2015-2016 The Khronos Group Inc. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ``` [spirv-tools-cla]: https://cla-assistant.io/KhronosGroup/SPIRV-Tools [spirv-tools-projects]: https://github.com/KhronosGroup/SPIRV-Tools/projects [spirv-tools-mailing-list]: https://www.khronos.org/spir/spirv-tools-mailing-list [spirv-registry]: https://www.khronos.org/registry/spir-v/ [spirv-headers]: https://github.com/KhronosGroup/SPIRV-Headers [googletest]: https://github.com/google/googletest [googletest-pull-612]: https://github.com/google/googletest/pull/612 [googletest-issue-610]: https://github.com/google/googletest/issues/610 [effcee]: https://github.com/google/effcee [re2]: https://github.com/google/re2 [abseil-cpp]: https://github.com/abseil/abseil-cpp [CMake]: https://cmake.org/ [cpp-style-guide]: https://google.github.io/styleguide/cppguide.html [clang-sanitizers]: http://clang.llvm.org/docs/UsersManual.html#controlling-code-generation KhronosGroup-SPIRV-Tools-f289d04/SECURITY.md000066400000000000000000000012711475742701700203230ustar00rootroot00000000000000# Security Policy ## Supported Versions Security updates are applied only to the latest release. ## Reporting a Vulnerability If you have discovered a security vulnerability in this project, please report it privately. **Do not disclose it as a public issue.** This gives us time to work with you to fix the issue before public exposure, reducing the chance that the exploit will be used before a patch is released. Please disclose it at [security advisory](https://github.com/KhronosGroup/SPIRV-Tools/security/advisories/new). This project is maintained by a team of volunteers on a reasonable-effort basis. As such, please give us at least 90 days to work on a fix before public exposure. KhronosGroup-SPIRV-Tools-f289d04/WORKSPACE000066400000000000000000000002451475742701700200130ustar00rootroot00000000000000local_repository( name = "spirv_headers", path = "external/spirv-headers", ) local_repository( name = "abseil-cpp", path = "external/abseil_cpp", ) KhronosGroup-SPIRV-Tools-f289d04/android_test/000077500000000000000000000000001475742701700212105ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/android_test/Android.mk000066400000000000000000000005351475742701700231240ustar00rootroot00000000000000LOCAL_PATH:= $(call my-dir) include $(CLEAR_VARS) LOCAL_CPP_EXTENSION := .cc .cpp .cxx LOCAL_SRC_FILES:=test.cpp LOCAL_MODULE:=spirvtools_test LOCAL_LDLIBS:=-landroid LOCAL_CXXFLAGS:=-std=c++17 -fno-exceptions -fno-rtti -Werror LOCAL_STATIC_LIBRARIES=SPIRV-Tools SPIRV-Tools-opt include $(BUILD_SHARED_LIBRARY) include $(LOCAL_PATH)/../Android.mk KhronosGroup-SPIRV-Tools-f289d04/android_test/jni/000077500000000000000000000000001475742701700217705ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/android_test/jni/Application.mk000066400000000000000000000001741475742701700245660ustar00rootroot00000000000000APP_ABI := all APP_BUILD_SCRIPT := Android.mk APP_STL := c++_static APP_PLATFORM := android-24 NDK_TOOLCHAIN_VERSION := 4.9 KhronosGroup-SPIRV-Tools-f289d04/android_test/test.cpp000066400000000000000000000015171475742701700226770ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "spirv-tools/libspirv.hpp" #include "spirv-tools/optimizer.hpp" void android_main(struct android_app* /*state*/) { spvtools::SpirvTools tools(SPV_ENV_UNIVERSAL_1_2); spvtools::Optimizer optimizer(SPV_ENV_UNIVERSAL_1_2); } KhronosGroup-SPIRV-Tools-f289d04/build_defs.bzl000066400000000000000000000166551475742701700213570ustar00rootroot00000000000000"""Constants and macros for spirv-tools BUILD.""" COMMON_COPTS = [ "-DSPIRV_CHECK_CONTEXT", "-DSPIRV_COLOR_TERMINAL", ] + select({ "@platforms//os:windows": [], "//conditions:default": [ "-DSPIRV_LINUX", "-DSPIRV_TIMER_ENABLED", "-fvisibility=hidden", "-fno-exceptions", "-fno-rtti", "-Wall", "-Wextra", "-Wnon-virtual-dtor", "-Wno-missing-field-initializers", "-Werror", "-Wno-long-long", "-Wshadow", "-Wundef", "-Wconversion", "-Wno-sign-conversion", ], }) TEST_COPTS = COMMON_COPTS + [ ] + select({ "@platforms//os:windows": [ # Disable C4503 "decorated name length exceeded" warning, # triggered by some heavily templated types. # We don't care much about that in test code. # Important to do since we have warnings-as-errors. "/wd4503", ], "//conditions:default": [ "-Wno-undef", "-Wno-self-assign", "-Wno-shadow", "-Wno-unused-parameter", ], }) def incompatible_with(incompatible_constraints): return select(_merge_dicts([{"//conditions:default": []}, { constraint: ["@platforms//:incompatible"] for constraint in incompatible_constraints }])) DEBUGINFO_GRAMMAR_JSON_FILE = "@spirv_headers//:spirv_ext_inst_debuginfo_grammar_unified1" CLDEBUGINFO100_GRAMMAR_JSON_FILE = "@spirv_headers//:spirv_ext_inst_opencl_debuginfo_100_grammar_unified1" SHDEBUGINFO100_GRAMMAR_JSON_FILE = "@spirv_headers//:spirv_ext_inst_nonsemantic_shader_debuginfo_100_grammar_unified1" def _merge_dicts(dicts): merged = {} for d in dicts: merged.update(d) return merged def generate_core_tables(version): if not version: fail("Must specify version", "version") grammars = dict( core_grammar = "@spirv_headers//:spirv_core_grammar_{}".format(version), debuginfo_grammar = DEBUGINFO_GRAMMAR_JSON_FILE, cldebuginfo_grammar = CLDEBUGINFO100_GRAMMAR_JSON_FILE, ) outs = dict( core_insts_output = "core.insts-{}.inc".format(version), operand_kinds_output = "operand.kinds-{}.inc".format(version), ) cmd = ( "$(location :generate_grammar_tables)" + " --spirv-core-grammar=$(location {core_grammar})" + " --extinst-debuginfo-grammar=$(location {debuginfo_grammar})" + " --extinst-cldebuginfo100-grammar=$(location {cldebuginfo_grammar})" + " --core-insts-output=$(location {core_insts_output})" + " --operand-kinds-output=$(location {operand_kinds_output})" + " --output-language=c++" ).format(**_merge_dicts([grammars, outs])) native.genrule( name = "gen_core_tables_" + version, srcs = grammars.values(), outs = outs.values(), cmd = cmd, cmd_bat = cmd, tools = [":generate_grammar_tables"], visibility = ["//visibility:private"], ) def generate_enum_string_mapping(version): if not version: fail("Must specify version", "version") grammars = dict( core_grammar = "@spirv_headers//:spirv_core_grammar_{}".format(version), debuginfo_grammar = DEBUGINFO_GRAMMAR_JSON_FILE, cldebuginfo_grammar = CLDEBUGINFO100_GRAMMAR_JSON_FILE, ) outs = dict( extension_enum_ouput = "extension_enum.inc", enum_string_mapping_output = "enum_string_mapping.inc", ) cmd = ( "$(location :generate_grammar_tables)" + " --spirv-core-grammar=$(location {core_grammar})" + " --extinst-debuginfo-grammar=$(location {debuginfo_grammar})" + " --extinst-cldebuginfo100-grammar=$(location {cldebuginfo_grammar})" + " --extension-enum-output=$(location {extension_enum_ouput})" + " --enum-string-mapping-output=$(location {enum_string_mapping_output})" + " --output-language=c++" ).format(**_merge_dicts([grammars, outs])) native.genrule( name = "gen_enum_string_mapping", srcs = grammars.values(), outs = outs.values(), cmd = cmd, cmd_bat = cmd, tools = [":generate_grammar_tables"], visibility = ["//visibility:private"], ) def generate_opencl_tables(version): if not version: fail("Must specify version", "version") grammars = dict( opencl_grammar = "@spirv_headers//:spirv_opencl_grammar_{}".format(version), ) outs = dict( opencl_insts_output = "opencl.std.insts.inc", ) cmd = ( "$(location :generate_grammar_tables)" + " --extinst-opencl-grammar=$(location {opencl_grammar})" + " --opencl-insts-output=$(location {opencl_insts_output})" ).format(**_merge_dicts([grammars, outs])) native.genrule( name = "gen_opencl_tables_" + version, srcs = grammars.values(), outs = outs.values(), cmd = cmd, cmd_bat = cmd, tools = [":generate_grammar_tables"], visibility = ["//visibility:private"], ) def generate_glsl_tables(version): if not version: fail("Must specify version", "version") grammars = dict( gsls_grammar = "@spirv_headers//:spirv_glsl_grammar_{}".format(version), ) outs = dict( gsls_insts_outs = "glsl.std.450.insts.inc", ) cmd = ( "$(location :generate_grammar_tables)" + " --extinst-glsl-grammar=$(location {gsls_grammar})" + " --glsl-insts-output=$(location {gsls_insts_outs})" + " --output-language=c++" ).format(**_merge_dicts([grammars, outs])) native.genrule( name = "gen_glsl_tables_" + version, srcs = grammars.values(), outs = outs.values(), cmd = cmd, cmd_bat = cmd, tools = [":generate_grammar_tables"], visibility = ["//visibility:private"], ) def generate_vendor_tables(extension, operand_kind_prefix = ""): if not extension: fail("Must specify extension", "extension") extension_rule = extension.replace("-", "_").replace(".", "_") grammars = dict( vendor_grammar = "@spirv_headers//:spirv_ext_inst_{}_grammar_unified1".format(extension_rule), ) outs = dict( vendor_insts_output = "{}.insts.inc".format(extension), ) cmd = ( "$(location :generate_grammar_tables)" + " --extinst-vendor-grammar=$(location {vendor_grammar})" + " --vendor-insts-output=$(location {vendor_insts_output})" + " --vendor-operand-kind-prefix={operand_kind_prefix}" ).format(operand_kind_prefix = operand_kind_prefix, **_merge_dicts([grammars, outs])) native.genrule( name = "gen_vendor_tables_" + extension_rule, srcs = grammars.values(), outs = outs.values(), cmd = cmd, cmd_bat = cmd, tools = [":generate_grammar_tables"], visibility = ["//visibility:private"], ) def generate_extinst_lang_headers(name, grammar = None): if not grammar: fail("Must specify grammar", "grammar") outs = dict( extinst_output_path = name + ".h", ) cmd = ( "$(location :generate_language_headers)" + " --extinst-grammar=$<" + " --extinst-output-path=$(location {extinst_output_path})" ).format(**outs) native.genrule( name = "gen_extinst_lang_headers_{}".format(name), srcs = [grammar], outs = outs.values(), cmd = cmd, cmd_bat = cmd, tools = [":generate_language_headers"], visibility = ["//visibility:private"], ) KhronosGroup-SPIRV-Tools-f289d04/build_overrides/000077500000000000000000000000001475742701700217125ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/build_overrides/build.gni000066400000000000000000000031561475742701700235150ustar00rootroot00000000000000# Copyright 2018 Google Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Variable that can be used to support multiple build scenarios, like having # Chromium specific targets in a client project's GN file etc. build_with_chromium = false declare_args() { # Android 32-bit non-component, non-clang builds cannot have symbol_level=2 # due to 4GiB file size limit, see https://crbug.com/648948. # Set this flag to true to skip the assertion. ignore_elf32_limitations = false # Use the system install of Xcode for tools like ibtool, libtool, etc. # This does not affect the compiler. When this variable is false, targets will # instead use a hermetic install of Xcode. [The hermetic install can be # obtained with gclient sync after setting the environment variable # FORCE_MAC_TOOLCHAIN]. use_system_xcode = "" } if (use_system_xcode == "") { if (target_os == "mac") { _result = exec_script("//build/mac/should_use_hermetic_xcode.py", [ target_os ], "value") use_system_xcode = _result == 0 } if (target_os == "ios") { use_system_xcode = true } } KhronosGroup-SPIRV-Tools-f289d04/build_overrides/gtest.gni000066400000000000000000000017251475742701700235440ustar00rootroot00000000000000# Copyright 2018 Google Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Exclude support for registering main function in multi-process tests. gtest_include_multiprocess = false # Exclude support for platform-specific operations across unit tests. gtest_include_platform_test = false # Exclude support for testing Objective C code on OS X and iOS. gtest_include_objc_support = false # Exclude support for flushing coverage files on iOS. gtest_include_ios_coverage = false KhronosGroup-SPIRV-Tools-f289d04/build_overrides/spirv_tools.gni000066400000000000000000000020441475742701700247740ustar00rootroot00000000000000# Copyright 2018 Google Inc. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # These are variables that are overridable by projects that include # SPIRV-Tools. The values in this file are the defaults for when we are # building from SPIRV-Tools' repository. # Whether we are building from SPIRV-Tools' repository. # MUST be set to false in other projects. spirv_tools_standalone = true # The path to SPIRV-Tools' dependencies spirv_tools_googletest_dir = "//external/googletest" spirv_tools_spirv_headers_dir = "//external/spirv-headers" KhronosGroup-SPIRV-Tools-f289d04/cmake/000077500000000000000000000000001475742701700176115ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/cmake/SPIRV-Tools-shared.pc.in000066400000000000000000000005151475742701700240100ustar00rootroot00000000000000prefix=@CMAKE_INSTALL_PREFIX@ exec_prefix=${prefix} libdir=${prefix}/@CMAKE_INSTALL_LIBDIR@ includedir=${prefix}/@CMAKE_INSTALL_INCLUDEDIR@ Name: SPIRV-Tools Description: Tools for SPIR-V Version: @CURRENT_VERSION@ URL: https://github.com/KhronosGroup/SPIRV-Tools Libs: -L${libdir} @SPIRV_SHARED_LIBRARIES@ Cflags: -I${includedir} KhronosGroup-SPIRV-Tools-f289d04/cmake/SPIRV-Tools.pc.in000066400000000000000000000005061475742701700225440ustar00rootroot00000000000000prefix=@CMAKE_INSTALL_PREFIX@ exec_prefix=${prefix} libdir=${prefix}/@CMAKE_INSTALL_LIBDIR@ includedir=${prefix}/@CMAKE_INSTALL_INCLUDEDIR@ Name: SPIRV-Tools Description: Tools for SPIR-V Version: @CURRENT_VERSION@ URL: https://github.com/KhronosGroup/SPIRV-Tools Libs: -L${libdir} @SPIRV_LIBRARIES@ Cflags: -I${includedir} KhronosGroup-SPIRV-Tools-f289d04/cmake/write_pkg_config.cmake000066400000000000000000000022421475742701700241330ustar00rootroot00000000000000# Copyright (c) 2017 Pierre Moreau # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # First, retrieve the current version from CHANGES file(STRINGS ${CHANGES_FILE} CHANGES_CONTENT) string( REGEX MATCH "v[0-9]+(.[0-9]+)?(-dev)? [0-9]+-[0-9]+-[0-9]+" FIRST_VERSION_LINE ${CHANGES_CONTENT}) string( REGEX REPLACE "^v([^ ]+) .+$" "\\1" CURRENT_VERSION "${FIRST_VERSION_LINE}") # If this is a development version, replace "-dev" by ".0" as pkg-config nor # CMake support "-dev" in the version. # If it's not a "-dev" version then ensure it ends with ".1" string(REGEX REPLACE "-dev.1" ".0" CURRENT_VERSION "${CURRENT_VERSION}.1") configure_file(${TEMPLATE_FILE} ${OUT_FILE} @ONLY) KhronosGroup-SPIRV-Tools-f289d04/codereview.settings000066400000000000000000000001451475742701700224470ustar00rootroot00000000000000# This file is used by git cl to get repository specific information. CODE_REVIEW_SERVER: github.com KhronosGroup-SPIRV-Tools-f289d04/docs/000077500000000000000000000000001475742701700174615ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/docs/downloads.md000066400000000000000000000051071475742701700220000ustar00rootroot00000000000000# Downloads ## Vulkan SDK The official releases for SPIRV-Tools can be found on LunarG's [SDK download page](https://vulkan.lunarg.com/sdk/home). The Vulkan SDK is updated approximately every six weeks. ## Android NDK SPIRV-Tools host executables, and library sources are published as part of the [Android NDK](https://developer.android.com/ndk/downloads). ## Automated builds For convenience, here are also links to the latest builds (HEAD). Those are untested automated builds. Those are not official releases, nor are guaranteed to work. Official releases builds are in the Android NDK or Vulkan SDK. Download the latest builds of the [main](https://github.com/KhronosGroup/SPIRV-Tools/tree/main) branch. | Platform | Processor | Compiler | Release build | Debug build | | --- | --- | --- | --- | --- | | Windows | x86-64 | VisualStudio 2022 (MSVC v143) | Download: status of VS 2022 release build | Download: status of VS 2022 debug build | | Linux | x86-64 | GCC 9.4 | Download: status of Linux GCC build | Download: status of Linux GCC debug build | | macOS | x86-64 | Clang 15 | Download: status of macOS Clang build | Download: status of macOS Clang build | Note: If you suspect something is wrong with the compiler versions mentioned, check the scripts and configurations in the [kokoro](../kokoro) source tree, or the results of the checks on the latest commits on the `main` branch. KhronosGroup-SPIRV-Tools-f289d04/docs/projects.md000066400000000000000000000073651475742701700216470ustar00rootroot00000000000000# Tracking SPIRV-Tools work with GitHub projects We are experimenting with using the [GitHub Project feature](https://help.github.com/articles/tracking-the-progress-of-your-work-with-projects/) to track progress toward large goals. For more on GitHub Projects in general, see: * [Introductory blog post](https://github.com/blog/2256-a-whole-new-github-universe-announcing-new-tools-forums-and-features) * [Introductory video](https://www.youtube.com/watch?v=C6MGKHkNtxU) The current SPIRV-Tools project list can be found at [https://github.com/KhronosGroup/SPIRV-Tools/projects](https://github.com/KhronosGroup/SPIRV-Tools/projects) ## How we use a Project A GitHub Project is a set of work with an overall purpose, and consists of a collection of *Cards*. Each card is either a *Note* or a regular GitHub *Issue.* A Note can be converted to an Issue. In our projects, a card represents work, i.e. a change that can be applied to the repository. The work could be a feature, a bug to be fixed, documentation to be updated, etc. A project and its cards are used as a [Kanban board](https://en.wikipedia.org/wiki/Kanban_board), where cards progress through a workflow starting with ideas through to implementation and completion. In our usage, a *project manager* is someone who organizes the work. They manage the creation and movement of cards through the project workflow: * They create cards to capture ideas, or to decompose large ideas into smaller ones. * They determine if the work for a card has been completed. * Normally they are the person (or persons) who can approve and merge a pull request into the `main` branch. Our projects organize cards into the following columns: * `Ideas`: Work which could be done, captured either as Cards or Notes. * A card in this column could be marked as a [PLACEHOLDER](#placeholders). * `Ready to start`: Issues which represent work we'd like to do, and which are not blocked by other work. * The issue should be narrow enough that it can usually be addressed by a single pull request. * We want these to be Issues (not Notes) so that someone can claim the work by updating the Issue with their intent to do the work. Once an Issue is claimed, the project manager moves the corresponding card from `Ready to start` to `In progress`. * `In progress`: Issues which were in `Ready to start` but which have been claimed by someone. * `Done`: Issues which have been resolved, by completing their work. * The changes have been applied to the repository, typically by being pushed into the `main` branch. * Other kinds of work could update repository settings, for example. * `Rejected ideas`: Work which has been considered, but which we don't want implemented. * We keep rejected ideas so they are not proposed again. This serves as a form of institutional memory. * We should record why an idea is rejected. For this reason, a rejected idea is likely to be an Issue which has been closed. ## Prioritization We are considering prioritizing cards in the `Ideas` and `Ready to start` columns so that things that should be considered first float up to the top. Experience will tell us if we stick to that rule, and if it proves helpful. ## Placeholders A *placeholder* is a Note or Issue that represents a possibly large amount of work that can be broadly defined but which may not have been broken down into small implementable pieces of work. Use a placeholder to capture a big idea, but without doing the upfront work to consider all the details of how it should be implemented. Over time, break off pieces of the placeholder into implementable Issues. Move those Issues into the `Ready to start` column when they become unblocked. We delete the placeholder when all its work has been decomposed into implementable cards. KhronosGroup-SPIRV-Tools-f289d04/docs/spirv-fuzz.md000066400000000000000000000173731475742701700221550ustar00rootroot00000000000000# Guide to writing a spirv-fuzz fuzzer pass Writing a spirv-fuzz fuzzer pass usually requires two main contributions: - A *transformation*, capturing a small semantics-preserving change that can be made to a SPIR-V module. This requires adding a protobuf message representing the transformation, and a corresponding class that implements the `Transformation` interface. - A new *fuzzer pass* class, implementing the `FuzzerPass` interface, that knows how to walk a SPIR-V module and apply the new transformation in a randomized fashion. In some cases, more than one kind of transformation is required for a single fuzzer pass, and in some cases the transformations that a new fuzzer pass requires have already been introduced by existing passes. But the most common case is to introduce a transformation and fuzzer pass together. As an example, let's consider the `TransformationSetSelectionControl` transformation. In SPIR-V, an `OpSelectionMerge` instruction (which intuitively indicates the start of an `if` or `switch` statement in a function) has a *selection control* mask, that can be one of `None`, `Flatten` or `DontFlatten`. The details of these do not matter much for this little tutorial, but in brief, this parameter provides a hint to the shader compiler as to whether it would be profitable to attempt to flatten a piece of conditional code so that all of its statements are executed in a predicated fashion. As the selection control mask is just a hint, changing the value of this mask should have no semantic impact on the module. The `TransformationSelectionControl` transformation specifies a new value for a given selection control mask. ## Adding a new protobuf message Take a look at the `Transformation` message in `spvtoolsfuzz.proto`. This has a `oneof` field that can be any one of the different spirv-fuzz transformations. Observe that one of the options is `TransformationSetSelectionControl`. When adding a transformation you first need to add an option for your transformation to the end of the `oneof` declaration. Now look at the `TransformationSetSelectionControl` message. If adding your own transformation you need to add a new message for your transformation, and it should be placed alphabetically with respect to other transformations. The fields of `TransformationSetSelectionControl` provide just enough information to (a) determine whether a given example of this transformation is actually applicable, and (b) apply the transformation in the case that it is applicable. The details of the transformation message will vary a lot between transformations. In this case, the message has a `block_id` field, specifying a block that must end with `OpSelectionMerge`, and a `selection_control` field, which is the new value for the selection control mask of the `OpSelectionMerge` instruction. ## Adding a new transformation class If your transformation is called `TransformationSomeThing`, you need to add `transformation_some_thing.h` and `transformation_some_thing.cpp` to `source/fuzz` and the corresponding `CMakeLists.txt` file. So for `TransformationSetSelectionControl` we have `transformation_selection_control.h` and `transformation_selection_control.cpp`, and we will use this as an example to illustrate the expected contents of these files. The header file contains the specification of a class, `TransformationSetSelectionControl`, that implements the `Transformation` interface (from `transformation.h`). A transformation class should always have a single field, which should be the associated protobuf message; in our case: ``` private: protobufs::TransformationSetSelectionControl message_; ``` and two public constructors, one that takes a protobuf message; in our case: ``` explicit TransformationSetSelectionControl( const protobufs::TransformationSetSelectionControl& message); ``` and one that takes a parameter for each protobuf message field; in our case: ``` TransformationSetSelectionControl(uint32_t block_id); ``` The first constructor allows an instance of the class to be created from a corresponding protobuf message. The second should provide the ingredients necessary to populate a protobuf message. The class should also override the `IsApplicable`, `Apply` and `ToMessage` methods from `Transformation`. See `transformation_set_selection_control.h` for an example. The `IsApplicable` method should have a comment in the header file describing the conditions for applicability in simple terms. These conditions should be implemented in the body of this method in the `.cpp` file. In the case of `TransformationSetSelectionControl`, `IsApplicable` involves checking that `block_id` is indeed the id of a block that has an `OpSelectionMerge` instruction, and that `selection_control` is a valid selection mask. The `Apply` method should have a comment in the header file summarising the result of applying the transformation. It should be implemented in the `.cpp` file, and you should assume that `IsApplicable` holds whenever `Apply` is invoked. ## Writing tests for the transformation class Whenever you add a transformation class, `TransformationSomeThing`, you should add an associated test file, `transformation_some_thing_test.cpp`, under `test/fuzz`, adding it to the associated `CMakeLists.txt` file. For example `test/fuzz/transformation_set_selection_control_test.cpp` contains tests for `TransformationSetSelectionControl`. Your tests should aim to cover one example from each scenario where the transformation is inapplicable, and check that it is indeed deemed inapplicable, and then check that the transformation does the right thing when applied in a few different ways. For example, the tests for `TransformationSetSelectionControl` check that a transformation of this kind is inapplicable if the `block_id` field of the transformation is not a block, or does not end in `OpSelectionMerge`, or if the `selection_control` mask has an illegal value. It also checks that applying a sequence of valid transformations to a SPIR-V shader leads to a shader with appropriately modified selection controls. ## Adding a new fuzzer pass class A *fuzzer pass* traverses a SPIR-V module looking for places to apply a certain kind of transformation, and randomly decides at which of these points to actually apply the transformation. It might be necessary to apply other transformations in order to apply a given transformation (for example, if a transformation requires a certain type to be present in the module, said type can be added if not already present via another transformation). A fuzzer pass implements the `FuzzerPass` interface, and overrides its `Apply` method. If your fuzzer pass is named `FuzzerPassSomeThing` then it should be represented by `fuzzer_pass_some_thing.h` and `fuzzer_pass_some_thing.cpp`, under `source/fuzz`; these should be added to the associated `CMakeLists.txt` file. Have a look at the source filed for `FuzzerPassAdjustSelectionControls`. This pass considers every block that ends with `OpSelectionMerge`. It decides randomly whether to adjust the selection control of this merge instruction via: ``` if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfAdjustingSelectionControl())) { continue; } ``` The `GetChanceOfAddingSelectionControl()` method has been added to `FuzzerContext` specifically to support this pass, and returns a percentage between 0 and 100. It returns the `chance_of_adjusting_selection_control_` of `FuzzerContext`, which is randomly initialized to lie with the interval defined by `kChanceOfAdjustingSelectionControl` in `fuzzer_context.cpp`. For any pass you write, you will need to add an analogous `GetChanceOf...` method to `FuzzerContext`, backed by an appropriate field, and you will need to decide on lower and upper bounds for this field and specify these via a `kChanceOf...` constant. KhronosGroup-SPIRV-Tools-f289d04/docs/syntax.md000066400000000000000000000254061475742701700213400ustar00rootroot00000000000000# SPIR-V Assembly language syntax ## Overview The assembly attempts to adhere to the binary form from Section 3 of the SPIR-V spec as closely as possible, with one exception aiming at improving the text's readability. The `` generated by an instruction is moved to the beginning of that instruction and followed by an `=` sign. This allows us to distinguish between variable definitions and uses and locate value definitions more easily. Here is an example: ``` OpCapability Shader OpMemoryModel Logical Simple OpEntryPoint GLCompute %3 "main" OpExecutionMode %3 LocalSize 64 64 1 %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpFunction %1 None %2 %4 = OpLabel OpReturn OpFunctionEnd ``` A module is a sequence of instructions, separated by whitespace. An instruction is an opcode name followed by operands, separated by whitespace. Typically each instruction is presented on its own line, but the assembler does not enforce this rule. The opcode names and expected operands are described in Section 3 of the SPIR-V specification. An operand is one of: * a literal integer: A decimal integer, or a hexadecimal integer. A hexadecimal integer is indicated by a leading `0x` or `0X`. A hex integer supplied for a signed integer value will be sign-extended. For example, `0xffff` supplied as the literal for an `OpConstant` on a signed 16-bit integer type will be interpreted as the value `-1`. * a literal floating point number, in decimal or hexadecimal form. See [below](#floats). * a literal string. * A literal string is everything following a double-quote `"` until the following un-escaped double-quote. This includes special characters such as newlines. * A backslash `\` may be used to escape characters in the string. The `\` may be used to escape a double-quote or a `\` but is simply ignored when preceding any other character. * a named enumerated value, specific to that operand position. For example, the `OpMemoryModel` takes a named Addressing Model operand (e.g. `Logical` or `Physical32`), and a named Memory Model operand (e.g. `Simple` or `OpenCL`). Named enumerated values are only meaningful in specific positions, and will otherwise generate an error. * a mask expression, consisting of one or more mask enum names separated by `|`. For example, the expression `NotNaN|NotInf|NSZ` denotes the mask which is the combination of the `NotNaN`, `NotInf`, and `NSZ` flags. * an injected immediate integer: `!`. See [below](#immediate). * an ID, e.g. `%foo`. See [below](#id). * the name of an extended instruction. For example, `sqrt` in an extended instruction such as `%f = OpExtInst %f32 %OpenCLImport sqrt %arg` * the name of an opcode for OpSpecConstantOp, but where the `Op` prefix is removed. For example, the following indicates the use of an integer addition in a specialization constant computation: `%sum = OpSpecConstantOp %i32 IAdd %a %b` ## ID Definitions & Usage An ID _definition_ pertains to the `` of an instruction, and ID _usage_ is a use of an ID as an input to an instruction. An ID in the assembly language begins with `%` and must be followed by a name consisting of one or more letters, numbers or underscore characters. For every ID in the assembly program, the assembler generates a unique number called the ID's internal number. Then each ID reference translates into its internal number in the SPIR-V output. Internal numbers are unique within the compilation unit: no two IDs in the same unit will share internal numbers. The disassembler generates IDs where the name is always a decimal number greater than 0. So the example can be rewritten using more user-friendly names, as follows: ``` OpCapability Shader OpMemoryModel Logical Simple OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 64 64 1 %void = OpTypeVoid %fnMain = OpTypeFunction %void %main = OpFunction %void None %fnMain %lbMain = OpLabel OpReturn OpFunctionEnd ``` ## Floating point literals The assembler and disassembler support floating point literals in both decimal and hexadecimal form. The syntax for a floating point literal is the same as floating point constants in the C programming language, except: * An optional leading minus (`-`) is part of the literal. * An optional type specifier suffix is not allowed. Infinity and NaN values are expressed in hexadecimal float literals by using the maximum representable exponent for the bit width. For example, in 32-bit floating point, 8 bits are used for the exponent, and the exponent bias is 127. So the maximum representable unbiased exponent is 128. Therefore, we represent the infinities and some NaNs as follows: ``` %float32 = OpTypeFloat 32 %inf = OpConstant %float32 0x1p+128 %neginf = OpConstant %float32 -0x1p+128 %aNaN = OpConstant %float32 0x1.8p+128 %moreNaN = OpConstant %float32 -0x1.0002p+128 ``` The assembler preserves all the bits of a NaN value. For example, the encoding of `%aNaN` in the previous example is the same as the word with bits `0x7fc00000`, and `%moreNaN` is encoded as `0xff800100`. The disassembler prints infinite, NaN, and subnormal values in hexadecimal form. Zero and normal values are printed in decimal form with enough digits to preserve all significand bits. ## Arbitrary Integers When writing tests it can be useful to emit an invalid 32 bit word into the binary stream at arbitrary positions within the assembly. To specify an arbitrary word into the stream the prefix `!` is used, this takes the form `!`. Here is an example. ``` OpCapability !0x0000FF00 ``` Any token in a valid assembly program may be replaced by `!` -- even tokens that dictate how the rest of the instruction is parsed. Consider, for example, the following assembly program: ``` %4 = OpConstant %1 123 456 789 OpExecutionMode %2 LocalSize 11 22 33 OpExecutionMode %3 InputLines ``` The tokens `OpConstant`, `LocalSize`, and `InputLines` may be replaced by random `!` values, and the assembler will still assemble an output binary with three instructions. It will not necessarily be valid SPIR-V, but it will faithfully reflect the input text. You may wonder how the assembler recognizes the instruction structure (including instruction boundaries) in the text with certain crucial tokens replaced by arbitrary integers. If, say, `OpConstant` becomes a `!` whose value differs from the binary representation of `OpConstant` (remember that this feature is intended for fine-grain control in SPIR-V testing), the assembler generally has no idea what that value stands for. So how does it know there is exactly one `` and three number literals following in that instruction, before the next one begins? And if `LocalSize` is replaced by an arbitrary `!`, how does it know to take the next three tokens (instead of zero or one, both of which are possible in the absence of certainty that `LocalSize` provided)? The answer is a simple rule governing the parsing of instructions with `!` in them: When a token in the assembly program is a `!`, that integer value is emitted into the binary output, and parsing proceeds differently than before: each subsequent token not recognized as an OpCode or a `` is emitted into the binary output without any checking; when a recognizable OpCode or a `` is eventually encountered, it begins a new instruction and parsing returns to normal. (If a subsequent OpCode is never found, then this alternate parsing mode handles all the remaining tokens in the program.) The assembler processes the tokens encountered in alternate parsing mode as follows: * If the token is a number literal, since context may be lost, the number is interpreted as a 32-bit value and output as a single word. In order to specify multiple-word literals in alternate-parsing mode, further uses of `!` tokens may be required. All formats supported by `strtoul()` are accepted. * If the token is a string literal, it outputs a sequence of words representing the string as defined in the SPIR-V specification for Literal String. * If the token is an ID, it outputs the ID's internal number. * If the token is another `!`, it outputs that integer. * Any other token causes the assembler to quit with an error. Note that this has some interesting consequences, including: * When an OpCode is replaced by `!`, the integer value should encode the instruction's word count, as specified in the physical-layout section of the SPIR-V specification. * Consecutive instructions may have their OpCode replaced by `!` and still produce valid SPIR-V. For example, `!262187 %1 %2 "abc" !327739 %1 %3 6 %2` will successfully assemble into SPIR-V declaring a constant and a PrivateGlobal variable. * Enums (such as `DontInline` or `SubgroupMemory`, for instance) are not handled by the alternate parsing mode. They must be replaced by `!` for successful assembly. * The `` on the left-hand side of an assignment cannot be a `!`. The `` can be still be manually controlled if desired by expressing the entire instruction as `!` tokens for its opcode and operands. * The `=` sign cannot be processed by the alternate parsing mode if the OpCode following it is a `!`. * When replacing a named ID with `!`, it is possible to generate unintentionally valid SPIR-V. If the integer provided happens to equal a number generated for an existing named ID, it will result in a reference to that named ID being output. This may be valid SPIR-V, contrary to the presumed intention of the writer. ## Notes * Some enumerants cannot be used by name, because the target instruction in which they are meaningful take an ID reference instead of a literal value. For example: * Named enumerated value `CmdExecTime` from section 3.30 Kernel Profiling Info is used in constructing a mask value supplied as an ID for `OpCaptureEventProfilingInfo`. But no other instruction has enough context to bring the enumerant names from section 3.30 into scope. * Similarly, the names in section 3.29 Kernel Enqueue Flags are used to construct a value supplied as an ID to the Flags argument of OpEnqueueKernel. * Similarly for the names in section 3.25 Memory Semantics. * Similarly for the names in section 3.27 Scope. * Some enumerants cannot be used by name, because they only name values returned by an instruction: * Enumerants from 3.12 Image Channel Order name possible values returned by the `OpImageQueryOrder` instruction. * Enumerants from 3.13 Image Channel Data Type name possible values returned by the `OpImageQueryFormat` instruction. KhronosGroup-SPIRV-Tools-f289d04/examples/000077500000000000000000000000001475742701700203475ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/examples/CMakeLists.txt000066400000000000000000000023771475742701700231200ustar00rootroot00000000000000# Copyright (c) 2016 Google Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Add a SPIR-V Tools example. Signature: # add_spvtools_example( # TARGET target_name # SRCS src_file1.cpp src_file2.cpp # LIBS lib_target1 lib_target2 # ) function(add_spvtools_example) if (NOT ${SPIRV_SKIP_EXECUTABLES}) set(one_value_args TARGET) set(multi_value_args SRCS LIBS) cmake_parse_arguments( ARG "" "${one_value_args}" "${multi_value_args}" ${ARGN}) add_executable(${ARG_TARGET} ${ARG_SRCS}) spvtools_default_compile_options(${ARG_TARGET}) target_link_libraries(${ARG_TARGET} PRIVATE ${ARG_LIBS}) set_property(TARGET ${ARG_TARGET} PROPERTY FOLDER "SPIRV-Tools examples") endif() endfunction() add_subdirectory(cpp-interface) KhronosGroup-SPIRV-Tools-f289d04/examples/cpp-interface/000077500000000000000000000000001475742701700230675ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/examples/cpp-interface/CMakeLists.txt000066400000000000000000000012441475742701700256300ustar00rootroot00000000000000# Copyright (c) 2016 Google Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. add_spvtools_example( TARGET spirv-tools-cpp-example SRCS main.cpp LIBS SPIRV-Tools-opt ) KhronosGroup-SPIRV-Tools-f289d04/examples/cpp-interface/main.cpp000066400000000000000000000042401475742701700245170ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // This program demonstrates basic SPIR-V module processing using // SPIRV-Tools C++ API: // * Assembling // * Validating // * Optimizing // * Disassembling #include #include #include #include "spirv-tools/libspirv.hpp" #include "spirv-tools/optimizer.hpp" int main() { const std::string source = " OpCapability Linkage " " OpCapability Shader " " OpMemoryModel Logical GLSL450 " " OpSource GLSL 450 " " OpDecorate %spec SpecId 1 " " %int = OpTypeInt 32 1 " " %spec = OpSpecConstant %int 0 " "%const = OpConstant %int 42"; spvtools::SpirvTools core(SPV_ENV_UNIVERSAL_1_3); spvtools::Optimizer opt(SPV_ENV_UNIVERSAL_1_3); auto print_msg_to_stderr = [](spv_message_level_t, const char*, const spv_position_t&, const char* m) { std::cerr << "error: " << m << std::endl; }; core.SetMessageConsumer(print_msg_to_stderr); opt.SetMessageConsumer(print_msg_to_stderr); std::vector spirv; if (!core.Assemble(source, &spirv)) return 1; if (!core.Validate(spirv)) return 1; opt.RegisterPass(spvtools::CreateSetSpecConstantDefaultValuePass({{1, "42"}})) .RegisterPass(spvtools::CreateFreezeSpecConstantValuePass()) .RegisterPass(spvtools::CreateUnifyConstantPass()) .RegisterPass(spvtools::CreateStripDebugInfoPass()); if (!opt.Run(spirv.data(), spirv.size(), &spirv)) return 1; std::string disassembly; if (!core.Disassemble(spirv, &disassembly)) return 1; std::cout << disassembly << "\n"; return 0; } KhronosGroup-SPIRV-Tools-f289d04/external/000077500000000000000000000000001475742701700203535ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/external/CMakeLists.txt000066400000000000000000000146241475742701700231220ustar00rootroot00000000000000# Copyright (c) 2015-2016 The Khronos Group Inc. # # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Utility functions for pushing & popping variables. function(push_variable var val) set("${var}_SAVE_STACK" "${${var}}" "${${var}_SAVE_STACK}" PARENT_SCOPE) set(${var} ${val} PARENT_SCOPE) endfunction() function(pop_variable var) set(save_stack "${${var}_SAVE_STACK}") list(GET save_stack 0 val) list(REMOVE_AT save_stack 0) set("${var}_SAVE_STACK" "${save_stack}" PARENT_SCOPE) set(${var} ${val} PARENT_SCOPE) endfunction() if (DEFINED SPIRV-Headers_SOURCE_DIR) # This allows flexible position of the SPIRV-Headers repo. set(SPIRV_HEADER_DIR ${SPIRV-Headers_SOURCE_DIR}) else() set(SPIRV_HEADER_DIR ${CMAKE_CURRENT_SOURCE_DIR}/spirv-headers) endif() if (IS_DIRECTORY ${SPIRV_HEADER_DIR}) # TODO(dneto): We should not be modifying the parent scope. set(SPIRV_HEADER_INCLUDE_DIR ${SPIRV_HEADER_DIR}/include PARENT_SCOPE) # Add SPIRV-Headers as a sub-project if it isn't already defined. # Do this so enclosing projects can use SPIRV-Headers_SOURCE_DIR to find # headers to include. if (NOT DEFINED SPIRV-Headers_SOURCE_DIR) add_subdirectory(${SPIRV_HEADER_DIR}) endif() else() message(FATAL_ERROR "SPIRV-Headers was not found - please checkout a copy at external/spirv-headers.") endif() if (NOT ${SPIRV_SKIP_TESTS}) # Find gmock if we can. If it's not already configured, then try finding # it in external/googletest. if (TARGET gmock) message(STATUS "Google Mock already configured") else() if (NOT GMOCK_DIR) set(GMOCK_DIR ${CMAKE_CURRENT_SOURCE_DIR}/googletest) endif() if(EXISTS ${GMOCK_DIR}) if(MSVC) # Our tests use ::testing::Combine. Work around a compiler # detection problem in googletest, where that template is # accidentally disabled for VS 2017. # See https://github.com/google/googletest/issues/1352 add_definitions(-DGTEST_HAS_COMBINE=1) endif() if(WIN32) option(gtest_force_shared_crt "Use shared (DLL) run-time lib even when Google Test is built as static lib." ON) endif() # gtest requires special defines for building as a shared # library, simply always build as static. push_variable(BUILD_SHARED_LIBS 0) add_subdirectory(${GMOCK_DIR} ${CMAKE_CURRENT_BINARY_DIR}/googletest EXCLUDE_FROM_ALL) pop_variable(BUILD_SHARED_LIBS) endif() endif() if (TARGET gmock) set(GTEST_TARGETS gtest gtest_main gmock gmock_main ) foreach(target ${GTEST_TARGETS}) set_property(TARGET ${target} PROPERTY FOLDER GoogleTest) endforeach() endif() # Find Effcee and RE2, for testing. # RE2 depends on Abseil. We set absl_SOURCE_DIR if it is not already set, so # that effcee can find abseil. if(NOT TARGET absl::base) if (NOT absl_SOURCE_DIR) if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/abseil_cpp) set(absl_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/abseil_cpp" CACHE STRING "Abseil source dir" ) endif() endif() endif() # First find RE2, since Effcee depends on it. # If already configured, then use that. Otherwise, prefer to find it under 're2' # in this directory. if (NOT TARGET re2) # If we are configuring RE2, then turn off its testing. It takes a long time and # does not add much value for us. If an enclosing project configured RE2, then it # has already chosen whether to enable RE2 testing. set(RE2_BUILD_TESTING OFF CACHE STRING "Run RE2 Tests") if (NOT RE2_SOURCE_DIR) if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/re2) set(RE2_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/re2" CACHE STRING "RE2 source dir" ) endif() endif() endif() if (NOT TARGET effcee) # Expect to find effcee in this directory. if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/effcee) # If we're configuring RE2 (via Effcee), then turn off RE2 testing. if (NOT TARGET re2) set(RE2_BUILD_TESTING OFF) endif() if (MSVC) # SPIRV-Tools uses the shared CRT with MSVC. Tell Effcee to do the same. set(EFFCEE_ENABLE_SHARED_CRT ON) endif() set(EFFCEE_BUILD_SAMPLES OFF CACHE BOOL "Do not build Effcee examples") if (NOT TARGET effcee) set(EFFCEE_BUILD_TESTING OFF CACHE BOOL "Do not build Effcee test suite") endif() push_variable(BUILD_SHARED_LIBS 0) # effcee does not export any symbols for building as a DLL. Always build as static. add_subdirectory(effcee EXCLUDE_FROM_ALL) pop_variable(BUILD_SHARED_LIBS) set_property(TARGET effcee PROPERTY FOLDER Effcee) # Turn off warnings for effcee and re2 set_property(TARGET effcee APPEND PROPERTY COMPILE_OPTIONS -w) set_property(TARGET re2 APPEND PROPERTY COMPILE_OPTIONS -w) endif() endif() endif() if(SPIRV_BUILD_FUZZER) function(backup_compile_options) get_property( SPIRV_TOOLS_BACKUP_EXTERNAL_COMPILE_OPTIONS DIRECTORY PROPERTY COMPILE_OPTIONS ) endfunction() function(restore_compile_options) set_property( DIRECTORY PROPERTY COMPILE_OPTIONS ${SPIRV_TOOLS_BACKUP_EXTERNAL_COMPILE_OPTIONS} ) endfunction() if(NOT TARGET protobuf::libprotobuf OR NOT TARGET protobuf::protoc) set(SPIRV_TOOLS_PROTOBUF_DIR ${CMAKE_CURRENT_SOURCE_DIR}/protobuf) if (NOT IS_DIRECTORY ${SPIRV_TOOLS_PROTOBUF_DIR}) message( FATAL_ERROR "protobuf not found - please checkout a copy under external/.") endif() set(protobuf_BUILD_TESTS OFF CACHE BOOL "Disable protobuf tests") set(protobuf_MSVC_STATIC_RUNTIME OFF CACHE BOOL "Do not build protobuf static runtime") backup_compile_options() if (${CMAKE_CXX_COMPILER_ID} MATCHES Clang) add_compile_options(-Wno-inconsistent-missing-override) endif() add_subdirectory(${SPIRV_TOOLS_PROTOBUF_DIR} EXCLUDE_FROM_ALL) restore_compile_options() endif() endif() KhronosGroup-SPIRV-Tools-f289d04/include/000077500000000000000000000000001475742701700201545ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/include/spirv-tools/000077500000000000000000000000001475742701700224555ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/include/spirv-tools/libspirv.h000066400000000000000000001355771475742701700245020ustar00rootroot00000000000000// Copyright (c) 2015-2020 The Khronos Group Inc. // Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights // reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef INCLUDE_SPIRV_TOOLS_LIBSPIRV_H_ #define INCLUDE_SPIRV_TOOLS_LIBSPIRV_H_ #ifdef __cplusplus extern "C" { #else #include #endif #include #include #if defined(SPIRV_TOOLS_SHAREDLIB) #if defined(_WIN32) #if defined(SPIRV_TOOLS_IMPLEMENTATION) #define SPIRV_TOOLS_EXPORT __declspec(dllexport) #else #define SPIRV_TOOLS_EXPORT __declspec(dllimport) #endif #define SPIRV_TOOLS_LOCAL #else #if defined(SPIRV_TOOLS_IMPLEMENTATION) #define SPIRV_TOOLS_EXPORT __attribute__((visibility("default"))) #define SPIRV_TOOLS_LOCAL __attribute__((visibility("hidden"))) #else #define SPIRV_TOOLS_EXPORT #define SPIRV_TOOLS_LOCAL #endif #endif #else #define SPIRV_TOOLS_EXPORT #define SPIRV_TOOLS_LOCAL #endif // Helpers #define SPV_BIT(shift) (1 << (shift)) #define SPV_FORCE_16_BIT_ENUM(name) SPV_FORCE_16BIT_##name = 0x7fff #define SPV_FORCE_32_BIT_ENUM(name) SPV_FORCE_32BIT_##name = 0x7fffffff // Enumerations typedef enum spv_result_t { SPV_SUCCESS = 0, SPV_UNSUPPORTED = 1, SPV_END_OF_STREAM = 2, SPV_WARNING = 3, SPV_FAILED_MATCH = 4, SPV_REQUESTED_TERMINATION = 5, // Success, but signals early termination. SPV_ERROR_INTERNAL = -1, SPV_ERROR_OUT_OF_MEMORY = -2, SPV_ERROR_INVALID_POINTER = -3, SPV_ERROR_INVALID_BINARY = -4, SPV_ERROR_INVALID_TEXT = -5, SPV_ERROR_INVALID_TABLE = -6, SPV_ERROR_INVALID_VALUE = -7, SPV_ERROR_INVALID_DIAGNOSTIC = -8, SPV_ERROR_INVALID_LOOKUP = -9, SPV_ERROR_INVALID_ID = -10, SPV_ERROR_INVALID_CFG = -11, SPV_ERROR_INVALID_LAYOUT = -12, SPV_ERROR_INVALID_CAPABILITY = -13, SPV_ERROR_INVALID_DATA = -14, // Indicates data rules validation failure. SPV_ERROR_MISSING_EXTENSION = -15, SPV_ERROR_WRONG_VERSION = -16, // Indicates wrong SPIR-V version SPV_FORCE_32_BIT_ENUM(spv_result_t) } spv_result_t; // Severity levels of messages communicated to the consumer. typedef enum spv_message_level_t { SPV_MSG_FATAL, // Unrecoverable error due to environment. // Will exit the program immediately. E.g., // out of memory. SPV_MSG_INTERNAL_ERROR, // Unrecoverable error due to SPIRV-Tools // internals. // Will exit the program immediately. E.g., // unimplemented feature. SPV_MSG_ERROR, // Normal error due to user input. SPV_MSG_WARNING, // Warning information. SPV_MSG_INFO, // General information. SPV_MSG_DEBUG, // Debug information. } spv_message_level_t; typedef enum spv_endianness_t { SPV_ENDIANNESS_LITTLE, SPV_ENDIANNESS_BIG, SPV_FORCE_32_BIT_ENUM(spv_endianness_t) } spv_endianness_t; // The kinds of operands that an instruction may have. // // Some operand types are "concrete". The binary parser uses a concrete // operand type to describe an operand of a parsed instruction. // // The assembler uses all operand types. In addition to determining what // kind of value an operand may be, non-concrete operand types capture the // fact that an operand might be optional (may be absent, or present exactly // once), or might occur zero or more times. // // Sometimes we also need to be able to express the fact that an operand // is a member of an optional tuple of values. In that case the first member // would be optional, and the subsequent members would be required. // // NOTE: Although we don't promise binary compatibility, as a courtesy, please // add new enum values at the end. typedef enum spv_operand_type_t { // A sentinel value. SPV_OPERAND_TYPE_NONE = 0, // Set 1: Operands that are IDs. SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_TYPE_ID, SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID, // SPIR-V Sec 3.25 SPV_OPERAND_TYPE_SCOPE_ID, // SPIR-V Sec 3.27 // Set 2: Operands that are literal numbers. SPV_OPERAND_TYPE_LITERAL_INTEGER, // Always unsigned 32-bits. // The Instruction argument to OpExtInst. It's an unsigned 32-bit literal // number indicating which instruction to use from an extended instruction // set. SPV_OPERAND_TYPE_EXTENSION_INSTRUCTION_NUMBER, // The Opcode argument to OpSpecConstantOp. It determines the operation // to be performed on constant operands to compute a specialization constant // result. SPV_OPERAND_TYPE_SPEC_CONSTANT_OP_NUMBER, // A literal number whose format and size are determined by a previous operand // in the same instruction. It's a signed integer, an unsigned integer, or a // floating point number. It also has a specified bit width. The width // may be larger than 32, which would require such a typed literal value to // occupy multiple SPIR-V words. SPV_OPERAND_TYPE_TYPED_LITERAL_NUMBER, SPV_OPERAND_TYPE_LITERAL_FLOAT, // Always 32-bit float. // Set 3: The literal string operand type. SPV_OPERAND_TYPE_LITERAL_STRING, // Set 4: Operands that are a single word enumerated value. SPV_OPERAND_TYPE_SOURCE_LANGUAGE, // SPIR-V Sec 3.2 SPV_OPERAND_TYPE_EXECUTION_MODEL, // SPIR-V Sec 3.3 SPV_OPERAND_TYPE_ADDRESSING_MODEL, // SPIR-V Sec 3.4 SPV_OPERAND_TYPE_MEMORY_MODEL, // SPIR-V Sec 3.5 SPV_OPERAND_TYPE_EXECUTION_MODE, // SPIR-V Sec 3.6 SPV_OPERAND_TYPE_STORAGE_CLASS, // SPIR-V Sec 3.7 SPV_OPERAND_TYPE_DIMENSIONALITY, // SPIR-V Sec 3.8 SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE, // SPIR-V Sec 3.9 SPV_OPERAND_TYPE_SAMPLER_FILTER_MODE, // SPIR-V Sec 3.10 SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT, // SPIR-V Sec 3.11 SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER, // SPIR-V Sec 3.12 SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE, // SPIR-V Sec 3.13 SPV_OPERAND_TYPE_FP_ROUNDING_MODE, // SPIR-V Sec 3.16 SPV_OPERAND_TYPE_LINKAGE_TYPE, // SPIR-V Sec 3.17 SPV_OPERAND_TYPE_ACCESS_QUALIFIER, // SPIR-V Sec 3.18 SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE, // SPIR-V Sec 3.19 SPV_OPERAND_TYPE_DECORATION, // SPIR-V Sec 3.20 SPV_OPERAND_TYPE_BUILT_IN, // SPIR-V Sec 3.21 SPV_OPERAND_TYPE_GROUP_OPERATION, // SPIR-V Sec 3.28 SPV_OPERAND_TYPE_KERNEL_ENQ_FLAGS, // SPIR-V Sec 3.29 SPV_OPERAND_TYPE_KERNEL_PROFILING_INFO, // SPIR-V Sec 3.30 SPV_OPERAND_TYPE_CAPABILITY, // SPIR-V Sec 3.31 SPV_OPERAND_TYPE_FPENCODING, // SPIR-V Sec 3.51 // NOTE: New concrete enum values should be added at the end. // Set 5: Operands that are a single word bitmask. // Sometimes a set bit indicates the instruction requires still more operands. SPV_OPERAND_TYPE_IMAGE, // SPIR-V Sec 3.14 SPV_OPERAND_TYPE_FP_FAST_MATH_MODE, // SPIR-V Sec 3.15 SPV_OPERAND_TYPE_SELECTION_CONTROL, // SPIR-V Sec 3.22 SPV_OPERAND_TYPE_LOOP_CONTROL, // SPIR-V Sec 3.23 SPV_OPERAND_TYPE_FUNCTION_CONTROL, // SPIR-V Sec 3.24 SPV_OPERAND_TYPE_MEMORY_ACCESS, // SPIR-V Sec 3.26 SPV_OPERAND_TYPE_FRAGMENT_SHADING_RATE, // SPIR-V Sec 3.FSR // NOTE: New concrete enum values should be added at the end. // The "optional" and "variable" operand types are only used internally by // the assembler and the binary parser. // There are two categories: // Optional : expands to 0 or 1 operand, like ? in regular expressions. // Variable : expands to 0, 1 or many operands or pairs of operands. // This is similar to * in regular expressions. // NOTE: These FIRST_* and LAST_* enum values are DEPRECATED. // The concept of "optional" and "variable" operand types are only intended // for use as an implementation detail of parsing SPIR-V, either in text or // binary form. Instead of using enum ranges, use characteristic function // spvOperandIsConcrete. // The use of enum value ranges in a public API makes it difficult to insert // new values into a range without also breaking binary compatibility. // // Macros for defining bounds on optional and variable operand types. // Any variable operand type is also optional. // TODO(dneto): Remove SPV_OPERAND_TYPE_FIRST_* and SPV_OPERAND_TYPE_LAST_* #define FIRST_OPTIONAL(ENUM) ENUM, SPV_OPERAND_TYPE_FIRST_OPTIONAL_TYPE = ENUM #define FIRST_VARIABLE(ENUM) ENUM, SPV_OPERAND_TYPE_FIRST_VARIABLE_TYPE = ENUM #define LAST_VARIABLE(ENUM) \ ENUM, SPV_OPERAND_TYPE_LAST_VARIABLE_TYPE = ENUM, \ SPV_OPERAND_TYPE_LAST_OPTIONAL_TYPE = ENUM // An optional operand represents zero or one logical operands. // In an instruction definition, this may only appear at the end of the // operand types. FIRST_OPTIONAL(SPV_OPERAND_TYPE_OPTIONAL_ID), // An optional image operand type. SPV_OPERAND_TYPE_OPTIONAL_IMAGE, // An optional memory access type. SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS, // An optional literal integer. SPV_OPERAND_TYPE_OPTIONAL_LITERAL_INTEGER, // An optional literal number, which may be either integer or floating point. SPV_OPERAND_TYPE_OPTIONAL_LITERAL_NUMBER, // Like SPV_OPERAND_TYPE_TYPED_LITERAL_NUMBER, but optional, and integral. SPV_OPERAND_TYPE_OPTIONAL_TYPED_LITERAL_INTEGER, // An optional literal string. SPV_OPERAND_TYPE_OPTIONAL_LITERAL_STRING, // An optional access qualifier SPV_OPERAND_TYPE_OPTIONAL_ACCESS_QUALIFIER, // An optional context-independent value, or CIV. CIVs are tokens that we can // assemble regardless of where they occur -- literals, IDs, immediate // integers, etc. SPV_OPERAND_TYPE_OPTIONAL_CIV, // An optional floating point encoding enum SPV_OPERAND_TYPE_OPTIONAL_FPENCODING, // A variable operand represents zero or more logical operands. // In an instruction definition, this may only appear at the end of the // operand types. FIRST_VARIABLE(SPV_OPERAND_TYPE_VARIABLE_ID), SPV_OPERAND_TYPE_VARIABLE_LITERAL_INTEGER, // A sequence of zero or more pairs of (typed literal integer, Id). // Expands to zero or more: // (SPV_OPERAND_TYPE_TYPED_LITERAL_INTEGER, SPV_OPERAND_TYPE_ID) // where the literal number must always be an integer of some sort. SPV_OPERAND_TYPE_VARIABLE_LITERAL_INTEGER_ID, // A sequence of zero or more pairs of (Id, Literal integer) LAST_VARIABLE(SPV_OPERAND_TYPE_VARIABLE_ID_LITERAL_INTEGER), // The following are concrete enum types from the DebugInfo extended // instruction set. SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS, // DebugInfo Sec 3.2. A mask. SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING, // DebugInfo Sec 3.3 SPV_OPERAND_TYPE_DEBUG_COMPOSITE_TYPE, // DebugInfo Sec 3.4 SPV_OPERAND_TYPE_DEBUG_TYPE_QUALIFIER, // DebugInfo Sec 3.5 SPV_OPERAND_TYPE_DEBUG_OPERATION, // DebugInfo Sec 3.6 // The following are concrete enum types from the OpenCL.DebugInfo.100 // extended instruction set. SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS, // Sec 3.2. A Mask SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING, // Sec 3.3 SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_COMPOSITE_TYPE, // Sec 3.4 SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_TYPE_QUALIFIER, // Sec 3.5 SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION, // Sec 3.6 SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_IMPORTED_ENTITY, // Sec 3.7 // The following are concrete enum types from SPV_INTEL_float_controls2 // https://github.com/intel/llvm/blob/39fa9b0cbfbae88327118990a05c5b387b56d2ef/sycl/doc/extensions/SPIRV/SPV_INTEL_float_controls2.asciidoc SPV_OPERAND_TYPE_FPDENORM_MODE, // Sec 3.17 FP Denorm Mode SPV_OPERAND_TYPE_FPOPERATION_MODE, // Sec 3.18 FP Operation Mode // A value enum from https://github.com/KhronosGroup/SPIRV-Headers/pull/177 SPV_OPERAND_TYPE_QUANTIZATION_MODES, // A value enum from https://github.com/KhronosGroup/SPIRV-Headers/pull/177 SPV_OPERAND_TYPE_OVERFLOW_MODES, // Concrete operand types for the provisional Vulkan ray tracing feature. SPV_OPERAND_TYPE_RAY_FLAGS, // SPIR-V Sec 3.RF SPV_OPERAND_TYPE_RAY_QUERY_INTERSECTION, // SPIR-V Sec 3.RQIntersection SPV_OPERAND_TYPE_RAY_QUERY_COMMITTED_INTERSECTION_TYPE, // SPIR-V Sec // 3.RQCommitted SPV_OPERAND_TYPE_RAY_QUERY_CANDIDATE_INTERSECTION_TYPE, // SPIR-V Sec // 3.RQCandidate // Concrete operand types for integer dot product. // Packed vector format SPV_OPERAND_TYPE_PACKED_VECTOR_FORMAT, // SPIR-V Sec 3.x // An optional packed vector format SPV_OPERAND_TYPE_OPTIONAL_PACKED_VECTOR_FORMAT, // Concrete operand types for cooperative matrix. SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS, // An optional cooperative matrix operands SPV_OPERAND_TYPE_OPTIONAL_COOPERATIVE_MATRIX_OPERANDS, SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_LAYOUT, SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_USE, // Enum type from SPV_INTEL_global_variable_fpga_decorations SPV_OPERAND_TYPE_INITIALIZATION_MODE_QUALIFIER, // Enum type from SPV_INTEL_global_variable_host_access SPV_OPERAND_TYPE_HOST_ACCESS_QUALIFIER, // Enum type from SPV_INTEL_cache_controls SPV_OPERAND_TYPE_LOAD_CACHE_CONTROL, // Enum type from SPV_INTEL_cache_controls SPV_OPERAND_TYPE_STORE_CACHE_CONTROL, // Enum type from SPV_INTEL_maximum_registers SPV_OPERAND_TYPE_NAMED_MAXIMUM_NUMBER_OF_REGISTERS, // Enum type from SPV_NV_raw_access_chains SPV_OPERAND_TYPE_RAW_ACCESS_CHAIN_OPERANDS, // Optional enum type from SPV_NV_raw_access_chains SPV_OPERAND_TYPE_OPTIONAL_RAW_ACCESS_CHAIN_OPERANDS, // Enum type from SPV_NV_tensor_addressing SPV_OPERAND_TYPE_TENSOR_CLAMP_MODE, // Enum type from SPV_NV_cooperative_matrix2 SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_REDUCE, // Enum type from SPV_NV_cooperative_matrix2 SPV_OPERAND_TYPE_TENSOR_ADDRESSING_OPERANDS, // Optional types from SPV_INTEL_subgroup_matrix_multiply_accumulate SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS, SPV_OPERAND_TYPE_OPTIONAL_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS, SPV_OPERAND_TYPE_COOPERATIVE_VECTOR_MATRIX_LAYOUT, SPV_OPERAND_TYPE_COMPONENT_TYPE, // This is a sentinel value, and does not represent an operand type. // It should come last. SPV_OPERAND_TYPE_NUM_OPERAND_TYPES, SPV_FORCE_32_BIT_ENUM(spv_operand_type_t) } spv_operand_type_t; // Returns true if the given type is concrete. bool spvOperandIsConcrete(spv_operand_type_t type); // Returns true if the given type is concrete and also a mask. bool spvOperandIsConcreteMask(spv_operand_type_t type); typedef enum spv_ext_inst_type_t { SPV_EXT_INST_TYPE_NONE = 0, SPV_EXT_INST_TYPE_GLSL_STD_450, SPV_EXT_INST_TYPE_OPENCL_STD, SPV_EXT_INST_TYPE_SPV_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER, SPV_EXT_INST_TYPE_SPV_AMD_SHADER_TRINARY_MINMAX, SPV_EXT_INST_TYPE_SPV_AMD_GCN_SHADER, SPV_EXT_INST_TYPE_SPV_AMD_SHADER_BALLOT, SPV_EXT_INST_TYPE_DEBUGINFO, SPV_EXT_INST_TYPE_OPENCL_DEBUGINFO_100, SPV_EXT_INST_TYPE_NONSEMANTIC_CLSPVREFLECTION, SPV_EXT_INST_TYPE_NONSEMANTIC_SHADER_DEBUGINFO_100, SPV_EXT_INST_TYPE_NONSEMANTIC_VKSPREFLECTION, // Multiple distinct extended instruction set types could return this // value, if they are prefixed with NonSemantic. and are otherwise // unrecognised SPV_EXT_INST_TYPE_NONSEMANTIC_UNKNOWN, SPV_FORCE_32_BIT_ENUM(spv_ext_inst_type_t) } spv_ext_inst_type_t; // This determines at a high level the kind of a binary-encoded literal // number, but not the bit width. // In principle, these could probably be folded into new entries in // spv_operand_type_t. But then we'd have some special case differences // between the assembler and disassembler. typedef enum spv_number_kind_t { SPV_NUMBER_NONE = 0, // The default for value initialization. SPV_NUMBER_UNSIGNED_INT, SPV_NUMBER_SIGNED_INT, SPV_NUMBER_FLOATING, } spv_number_kind_t; typedef enum spv_text_to_binary_options_t { SPV_TEXT_TO_BINARY_OPTION_NONE = SPV_BIT(0), // Numeric IDs in the binary will have the same values as in the source. // Non-numeric IDs are allocated by filling in the gaps, starting with 1 // and going up. SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS = SPV_BIT(1), SPV_FORCE_32_BIT_ENUM(spv_text_to_binary_options_t) } spv_text_to_binary_options_t; typedef enum spv_binary_to_text_options_t { SPV_BINARY_TO_TEXT_OPTION_NONE = SPV_BIT(0), SPV_BINARY_TO_TEXT_OPTION_PRINT = SPV_BIT(1), SPV_BINARY_TO_TEXT_OPTION_COLOR = SPV_BIT(2), SPV_BINARY_TO_TEXT_OPTION_INDENT = SPV_BIT(3), SPV_BINARY_TO_TEXT_OPTION_SHOW_BYTE_OFFSET = SPV_BIT(4), // Do not output the module header as leading comments in the assembly. SPV_BINARY_TO_TEXT_OPTION_NO_HEADER = SPV_BIT(5), // Use friendly names where possible. The heuristic may expand over // time, but will use common names for scalar types, and debug names from // OpName instructions. SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES = SPV_BIT(6), // Add some comments to the generated assembly SPV_BINARY_TO_TEXT_OPTION_COMMENT = SPV_BIT(7), // Use nested indentation for more readable SPIR-V SPV_BINARY_TO_TEXT_OPTION_NESTED_INDENT = SPV_BIT(8), // Reorder blocks to match the structured control flow of SPIR-V to increase // readability. SPV_BINARY_TO_TEXT_OPTION_REORDER_BLOCKS = SPV_BIT(9), SPV_FORCE_32_BIT_ENUM(spv_binary_to_text_options_t) } spv_binary_to_text_options_t; // Constants // The default id bound is to the minimum value for the id limit // in the spir-v specification under the section "Universal Limits". const uint32_t kDefaultMaxIdBound = 0x3FFFFF; // Structures // Information about an operand parsed from a binary SPIR-V module. // Note that the values are not included. You still need access to the binary // to extract the values. typedef struct spv_parsed_operand_t { // Location of the operand, in words from the start of the instruction. uint16_t offset; // Number of words occupied by this operand. uint16_t num_words; // The "concrete" operand type. See the definition of spv_operand_type_t // for details. spv_operand_type_t type; // If type is a literal number type, then number_kind says whether it's // a signed integer, an unsigned integer, or a floating point number. spv_number_kind_t number_kind; // The number of bits for a literal number type. uint32_t number_bit_width; } spv_parsed_operand_t; // An instruction parsed from a binary SPIR-V module. typedef struct spv_parsed_instruction_t { // An array of words for this instruction, in native endianness. const uint32_t* words; // The number of words in this instruction. uint16_t num_words; uint16_t opcode; // The extended instruction type, if opcode is OpExtInst. Otherwise // this is the "none" value. spv_ext_inst_type_t ext_inst_type; // The type id, or 0 if this instruction doesn't have one. uint32_t type_id; // The result id, or 0 if this instruction doesn't have one. uint32_t result_id; // The array of parsed operands. const spv_parsed_operand_t* operands; uint16_t num_operands; } spv_parsed_instruction_t; typedef struct spv_parsed_header_t { // The magic number of the SPIR-V module. uint32_t magic; // Version number. uint32_t version; // Generator's magic number. uint32_t generator; // IDs bound for this module (0 < id < bound). uint32_t bound; // reserved. uint32_t reserved; } spv_parsed_header_t; typedef struct spv_const_binary_t { const uint32_t* code; const size_t wordCount; } spv_const_binary_t; typedef struct spv_binary_t { uint32_t* code; size_t wordCount; } spv_binary_t; typedef struct spv_text_t { const char* str; size_t length; } spv_text_t; typedef struct spv_position_t { size_t line; size_t column; size_t index; } spv_position_t; typedef struct spv_diagnostic_t { spv_position_t position; char* error; bool isTextSource; } spv_diagnostic_t; // Opaque struct containing the context used to operate on a SPIR-V module. // Its object is used by various translation API functions. typedef struct spv_context_t spv_context_t; typedef struct spv_validator_options_t spv_validator_options_t; typedef struct spv_optimizer_options_t spv_optimizer_options_t; typedef struct spv_reducer_options_t spv_reducer_options_t; typedef struct spv_fuzzer_options_t spv_fuzzer_options_t; typedef struct spv_optimizer_t spv_optimizer_t; // Type Definitions typedef spv_const_binary_t* spv_const_binary; typedef spv_binary_t* spv_binary; typedef spv_text_t* spv_text; typedef spv_position_t* spv_position; typedef spv_diagnostic_t* spv_diagnostic; typedef const spv_context_t* spv_const_context; typedef spv_context_t* spv_context; typedef spv_validator_options_t* spv_validator_options; typedef const spv_validator_options_t* spv_const_validator_options; typedef spv_optimizer_options_t* spv_optimizer_options; typedef const spv_optimizer_options_t* spv_const_optimizer_options; typedef spv_reducer_options_t* spv_reducer_options; typedef const spv_reducer_options_t* spv_const_reducer_options; typedef spv_fuzzer_options_t* spv_fuzzer_options; typedef const spv_fuzzer_options_t* spv_const_fuzzer_options; // Platform API // Returns the SPIRV-Tools software version as a null-terminated string. // The contents of the underlying storage is valid for the remainder of // the process. SPIRV_TOOLS_EXPORT const char* spvSoftwareVersionString(void); // Returns a null-terminated string containing the name of the project, // the software version string, and commit details. // The contents of the underlying storage is valid for the remainder of // the process. SPIRV_TOOLS_EXPORT const char* spvSoftwareVersionDetailsString(void); // Certain target environments impose additional restrictions on SPIR-V, so it's // often necessary to specify which one applies. SPV_ENV_UNIVERSAL_* implies an // environment-agnostic SPIR-V. // // When an API method needs to derive a SPIR-V version from a target environment // (from the spv_context object), the method will choose the highest version of // SPIR-V supported by the target environment. Examples: // SPV_ENV_VULKAN_1_0 -> SPIR-V 1.0 // SPV_ENV_VULKAN_1_1 -> SPIR-V 1.3 // SPV_ENV_VULKAN_1_1_SPIRV_1_4 -> SPIR-V 1.4 // SPV_ENV_VULKAN_1_2 -> SPIR-V 1.5 // SPV_ENV_VULKAN_1_3 -> SPIR-V 1.6 // SPV_ENV_VULKAN_1_4 -> SPIR-V 1.6 // Consult the description of API entry points for specific rules. typedef enum { SPV_ENV_UNIVERSAL_1_0, // SPIR-V 1.0 latest revision, no other restrictions. SPV_ENV_VULKAN_1_0, // Vulkan 1.0 latest revision. SPV_ENV_UNIVERSAL_1_1, // SPIR-V 1.1 latest revision, no other restrictions. SPV_ENV_OPENCL_2_1, // OpenCL Full Profile 2.1 latest revision. SPV_ENV_OPENCL_2_2, // OpenCL Full Profile 2.2 latest revision. SPV_ENV_OPENGL_4_0, // OpenGL 4.0 plus GL_ARB_gl_spirv, latest revisions. SPV_ENV_OPENGL_4_1, // OpenGL 4.1 plus GL_ARB_gl_spirv, latest revisions. SPV_ENV_OPENGL_4_2, // OpenGL 4.2 plus GL_ARB_gl_spirv, latest revisions. SPV_ENV_OPENGL_4_3, // OpenGL 4.3 plus GL_ARB_gl_spirv, latest revisions. // There is no variant for OpenGL 4.4. SPV_ENV_OPENGL_4_5, // OpenGL 4.5 plus GL_ARB_gl_spirv, latest revisions. SPV_ENV_UNIVERSAL_1_2, // SPIR-V 1.2, latest revision, no other restrictions. SPV_ENV_OPENCL_1_2, // OpenCL Full Profile 1.2 plus cl_khr_il_program, // latest revision. SPV_ENV_OPENCL_EMBEDDED_1_2, // OpenCL Embedded Profile 1.2 plus // cl_khr_il_program, latest revision. SPV_ENV_OPENCL_2_0, // OpenCL Full Profile 2.0 plus cl_khr_il_program, // latest revision. SPV_ENV_OPENCL_EMBEDDED_2_0, // OpenCL Embedded Profile 2.0 plus // cl_khr_il_program, latest revision. SPV_ENV_OPENCL_EMBEDDED_2_1, // OpenCL Embedded Profile 2.1 latest revision. SPV_ENV_OPENCL_EMBEDDED_2_2, // OpenCL Embedded Profile 2.2 latest revision. SPV_ENV_UNIVERSAL_1_3, // SPIR-V 1.3 latest revision, no other restrictions. SPV_ENV_VULKAN_1_1, // Vulkan 1.1 latest revision. SPV_ENV_WEBGPU_0, // DEPRECATED, may be removed in the future. SPV_ENV_UNIVERSAL_1_4, // SPIR-V 1.4 latest revision, no other restrictions. // Vulkan 1.1 with VK_KHR_spirv_1_4, i.e. SPIR-V 1.4 binary. SPV_ENV_VULKAN_1_1_SPIRV_1_4, SPV_ENV_UNIVERSAL_1_5, // SPIR-V 1.5 latest revision, no other restrictions. SPV_ENV_VULKAN_1_2, // Vulkan 1.2 latest revision. SPV_ENV_UNIVERSAL_1_6, // SPIR-V 1.6 latest revision, no other restrictions. SPV_ENV_VULKAN_1_3, // Vulkan 1.3 latest revision. SPV_ENV_VULKAN_1_4, // Vulkan 1.4 latest revision. SPV_ENV_MAX // Keep this as the last enum value. } spv_target_env; // SPIR-V Validator can be parameterized with the following Universal Limits. typedef enum { spv_validator_limit_max_struct_members, spv_validator_limit_max_struct_depth, spv_validator_limit_max_local_variables, spv_validator_limit_max_global_variables, spv_validator_limit_max_switch_branches, spv_validator_limit_max_function_args, spv_validator_limit_max_control_flow_nesting_depth, spv_validator_limit_max_access_chain_indexes, spv_validator_limit_max_id_bound, } spv_validator_limit; // Returns a string describing the given SPIR-V target environment. SPIRV_TOOLS_EXPORT const char* spvTargetEnvDescription(spv_target_env env); // Parses s into *env and returns true if successful. If unparsable, returns // false and sets *env to SPV_ENV_UNIVERSAL_1_0. SPIRV_TOOLS_EXPORT bool spvParseTargetEnv(const char* s, spv_target_env* env); // Determines the target env value with the least features but which enables // the given Vulkan and SPIR-V versions. If such a target is supported, returns // true and writes the value to |env|, otherwise returns false. // // The Vulkan version is given as an unsigned 32-bit number as specified in // Vulkan section "29.2.1 Version Numbers": the major version number appears // in bits 22 to 21, and the minor version is in bits 12 to 21. The SPIR-V // version is given in the SPIR-V version header word: major version in bits // 16 to 23, and minor version in bits 8 to 15. SPIRV_TOOLS_EXPORT bool spvParseVulkanEnv(uint32_t vulkan_ver, uint32_t spirv_ver, spv_target_env* env); // Creates a context object for most of the SPIRV-Tools API. // Returns null if env is invalid. // // See specific API calls for how the target environment is interpreted // (particularly assembly and validation). SPIRV_TOOLS_EXPORT spv_context spvContextCreate(spv_target_env env); // Destroys the given context object. SPIRV_TOOLS_EXPORT void spvContextDestroy(spv_context context); // Creates a Validator options object with default options. Returns a valid // options object. The object remains valid until it is passed into // spvValidatorOptionsDestroy. SPIRV_TOOLS_EXPORT spv_validator_options spvValidatorOptionsCreate(void); // Destroys the given Validator options object. SPIRV_TOOLS_EXPORT void spvValidatorOptionsDestroy( spv_validator_options options); // Records the maximum Universal Limit that is considered valid in the given // Validator options object. argument must be a valid options object. SPIRV_TOOLS_EXPORT void spvValidatorOptionsSetUniversalLimit( spv_validator_options options, spv_validator_limit limit_type, uint32_t limit); // Record whether or not the validator should relax the rules on types for // stores to structs. When relaxed, it will allow a type mismatch as long as // the types are structs with the same layout. Two structs have the same layout // if // // 1) the members of the structs are either the same type or are structs with // same layout, and // // 2) the decorations that affect the memory layout are identical for both // types. Other decorations are not relevant. SPIRV_TOOLS_EXPORT void spvValidatorOptionsSetRelaxStoreStruct( spv_validator_options options, bool val); // Records whether or not the validator should relax the rules on pointer usage // in logical addressing mode. // // When relaxed, it will allow the following usage cases of pointers: // 1) OpVariable allocating an object whose type is a pointer type // 2) OpReturnValue returning a pointer value SPIRV_TOOLS_EXPORT void spvValidatorOptionsSetRelaxLogicalPointer( spv_validator_options options, bool val); // Records whether or not the validator should relax the rules because it is // expected that the optimizations will make the code legal. // // When relaxed, it will allow the following: // 1) It will allow relaxed logical pointers. Setting this option will also // set that option. // 2) Pointers that are pass as parameters to function calls do not have to // match the storage class of the formal parameter. // 3) Pointers that are actual parameters on function calls do not have to point // to the same type pointed as the formal parameter. The types just need to // logically match. // 4) GLSLstd450 Interpolate* instructions can have a load of an interpolant // for a first argument. SPIRV_TOOLS_EXPORT void spvValidatorOptionsSetBeforeHlslLegalization( spv_validator_options options, bool val); // Records whether the validator should use "relaxed" block layout rules. // Relaxed layout rules are described by Vulkan extension // VK_KHR_relaxed_block_layout, and they affect uniform blocks, storage blocks, // and push constants. // // This is enabled by default when targeting Vulkan 1.1 or later. // Relaxed layout is more permissive than the default rules in Vulkan 1.0. SPIRV_TOOLS_EXPORT void spvValidatorOptionsSetRelaxBlockLayout( spv_validator_options options, bool val); // Records whether the validator should use standard block layout rules for // uniform blocks. SPIRV_TOOLS_EXPORT void spvValidatorOptionsSetUniformBufferStandardLayout( spv_validator_options options, bool val); // Records whether the validator should use "scalar" block layout rules. // Scalar layout rules are more permissive than relaxed block layout. // // See Vulkan extension VK_EXT_scalar_block_layout. The scalar alignment is // defined as follows: // - scalar alignment of a scalar is the scalar size // - scalar alignment of a vector is the scalar alignment of its component // - scalar alignment of a matrix is the scalar alignment of its component // - scalar alignment of an array is the scalar alignment of its element // - scalar alignment of a struct is the max scalar alignment among its // members // // For a struct in Uniform, StorageClass, or PushConstant: // - a member Offset must be a multiple of the member's scalar alignment // - ArrayStride or MatrixStride must be a multiple of the array or matrix // scalar alignment SPIRV_TOOLS_EXPORT void spvValidatorOptionsSetScalarBlockLayout( spv_validator_options options, bool val); // Records whether the validator should use "scalar" block layout // rules (as defined above) for Workgroup blocks. See Vulkan // extension VK_KHR_workgroup_memory_explicit_layout. SPIRV_TOOLS_EXPORT void spvValidatorOptionsSetWorkgroupScalarBlockLayout( spv_validator_options options, bool val); // Records whether or not the validator should skip validating standard // uniform/storage block layout. SPIRV_TOOLS_EXPORT void spvValidatorOptionsSetSkipBlockLayout( spv_validator_options options, bool val); // Records whether or not the validator should allow the LocalSizeId // decoration where the environment otherwise would not allow it. SPIRV_TOOLS_EXPORT void spvValidatorOptionsSetAllowLocalSizeId( spv_validator_options options, bool val); // Allow Offset (in addition to ConstOffset) for texture operations. // Was added for VK_KHR_maintenance8 SPIRV_TOOLS_EXPORT void spvValidatorOptionsSetAllowOffsetTextureOperand( spv_validator_options options, bool val); // Allow base operands of some bit operations to be non-32-bit wide. SPIRV_TOOLS_EXPORT void spvValidatorOptionsSetAllowVulkan32BitBitwise( spv_validator_options options, bool val); // Whether friendly names should be used in validation error messages. SPIRV_TOOLS_EXPORT void spvValidatorOptionsSetFriendlyNames( spv_validator_options options, bool val); // Creates an optimizer options object with default options. Returns a valid // options object. The object remains valid until it is passed into // |spvOptimizerOptionsDestroy|. SPIRV_TOOLS_EXPORT spv_optimizer_options spvOptimizerOptionsCreate(void); // Destroys the given optimizer options object. SPIRV_TOOLS_EXPORT void spvOptimizerOptionsDestroy( spv_optimizer_options options); // Records whether or not the optimizer should run the validator before // optimizing. If |val| is true, the validator will be run. SPIRV_TOOLS_EXPORT void spvOptimizerOptionsSetRunValidator( spv_optimizer_options options, bool val); // Records the validator options that should be passed to the validator if it is // run. SPIRV_TOOLS_EXPORT void spvOptimizerOptionsSetValidatorOptions( spv_optimizer_options options, spv_validator_options val); // Records the maximum possible value for the id bound. SPIRV_TOOLS_EXPORT void spvOptimizerOptionsSetMaxIdBound( spv_optimizer_options options, uint32_t val); // Records whether all bindings within the module should be preserved. SPIRV_TOOLS_EXPORT void spvOptimizerOptionsSetPreserveBindings( spv_optimizer_options options, bool val); // Records whether all specialization constants within the module // should be preserved. SPIRV_TOOLS_EXPORT void spvOptimizerOptionsSetPreserveSpecConstants( spv_optimizer_options options, bool val); // Creates a reducer options object with default options. Returns a valid // options object. The object remains valid until it is passed into // |spvReducerOptionsDestroy|. SPIRV_TOOLS_EXPORT spv_reducer_options spvReducerOptionsCreate(void); // Destroys the given reducer options object. SPIRV_TOOLS_EXPORT void spvReducerOptionsDestroy(spv_reducer_options options); // Sets the maximum number of reduction steps that should run before the reducer // gives up. SPIRV_TOOLS_EXPORT void spvReducerOptionsSetStepLimit( spv_reducer_options options, uint32_t step_limit); // Sets the fail-on-validation-error option; if true, the reducer will return // kStateInvalid if a reduction step yields a state that fails SPIR-V // validation. Otherwise, an invalid state is treated as uninteresting and the // reduction backtracks and continues. SPIRV_TOOLS_EXPORT void spvReducerOptionsSetFailOnValidationError( spv_reducer_options options, bool fail_on_validation_error); // Sets the function that the reducer should target. If set to zero the reducer // will target all functions as well as parts of the module that lie outside // functions. Otherwise the reducer will restrict reduction to the function // with result id |target_function|, which is required to exist. SPIRV_TOOLS_EXPORT void spvReducerOptionsSetTargetFunction( spv_reducer_options options, uint32_t target_function); // Creates a fuzzer options object with default options. Returns a valid // options object. The object remains valid until it is passed into // |spvFuzzerOptionsDestroy|. SPIRV_TOOLS_EXPORT spv_fuzzer_options spvFuzzerOptionsCreate(void); // Destroys the given fuzzer options object. SPIRV_TOOLS_EXPORT void spvFuzzerOptionsDestroy(spv_fuzzer_options options); // Enables running the validator after every transformation is applied during // a replay. SPIRV_TOOLS_EXPORT void spvFuzzerOptionsEnableReplayValidation( spv_fuzzer_options options); // Sets the seed with which the random number generator used by the fuzzer // should be initialized. SPIRV_TOOLS_EXPORT void spvFuzzerOptionsSetRandomSeed( spv_fuzzer_options options, uint32_t seed); // Sets the range of transformations that should be applied during replay: 0 // means all transformations, +N means the first N transformations, -N means all // except the final N transformations. SPIRV_TOOLS_EXPORT void spvFuzzerOptionsSetReplayRange( spv_fuzzer_options options, int32_t replay_range); // Sets the maximum number of steps that the shrinker should take before giving // up. SPIRV_TOOLS_EXPORT void spvFuzzerOptionsSetShrinkerStepLimit( spv_fuzzer_options options, uint32_t shrinker_step_limit); // Enables running the validator after every pass is applied during a fuzzing // run. SPIRV_TOOLS_EXPORT void spvFuzzerOptionsEnableFuzzerPassValidation( spv_fuzzer_options options); // Enables all fuzzer passes during a fuzzing run (instead of a random subset // of passes). SPIRV_TOOLS_EXPORT void spvFuzzerOptionsEnableAllPasses( spv_fuzzer_options options); // Encodes the given SPIR-V assembly text to its binary representation. The // length parameter specifies the number of bytes for text. Encoded binary will // be stored into *binary. Any error will be written into *diagnostic if // diagnostic is non-null, otherwise the context's message consumer will be // used. The generated binary is independent of the context and may outlive it. // The SPIR-V binary version is set to the highest version of SPIR-V supported // by the context's target environment. SPIRV_TOOLS_EXPORT spv_result_t spvTextToBinary(const spv_const_context context, const char* text, const size_t length, spv_binary* binary, spv_diagnostic* diagnostic); // Encodes the given SPIR-V assembly text to its binary representation. Same as // spvTextToBinary but with options. The options parameter is a bit field of // spv_text_to_binary_options_t. SPIRV_TOOLS_EXPORT spv_result_t spvTextToBinaryWithOptions( const spv_const_context context, const char* text, const size_t length, const uint32_t options, spv_binary* binary, spv_diagnostic* diagnostic); // Frees an allocated text stream. This is a no-op if the text parameter // is a null pointer. SPIRV_TOOLS_EXPORT void spvTextDestroy(spv_text text); // Decodes the given SPIR-V binary representation to its assembly text. The // word_count parameter specifies the number of words for binary. The options // parameter is a bit field of spv_binary_to_text_options_t. Decoded text will // be stored into *text. Any error will be written into *diagnostic if // diagnostic is non-null, otherwise the context's message consumer will be // used. SPIRV_TOOLS_EXPORT spv_result_t spvBinaryToText(const spv_const_context context, const uint32_t* binary, const size_t word_count, const uint32_t options, spv_text* text, spv_diagnostic* diagnostic); // Frees a binary stream from memory. This is a no-op if binary is a null // pointer. SPIRV_TOOLS_EXPORT void spvBinaryDestroy(spv_binary binary); // Validates a SPIR-V binary for correctness. Any errors will be written into // *diagnostic if diagnostic is non-null, otherwise the context's message // consumer will be used. // // Validate for SPIR-V spec rules for the SPIR-V version named in the // binary's header (at word offset 1). Additionally, if the context target // environment is a client API (such as Vulkan 1.1), then validate for that // client API version, to the extent that it is verifiable from data in the // binary itself. SPIRV_TOOLS_EXPORT spv_result_t spvValidate(const spv_const_context context, const spv_const_binary binary, spv_diagnostic* diagnostic); // Validates a SPIR-V binary for correctness. Uses the provided Validator // options. Any errors will be written into *diagnostic if diagnostic is // non-null, otherwise the context's message consumer will be used. // // Validate for SPIR-V spec rules for the SPIR-V version named in the // binary's header (at word offset 1). Additionally, if the context target // environment is a client API (such as Vulkan 1.1), then validate for that // client API version, to the extent that it is verifiable from data in the // binary itself, or in the validator options. SPIRV_TOOLS_EXPORT spv_result_t spvValidateWithOptions( const spv_const_context context, const spv_const_validator_options options, const spv_const_binary binary, spv_diagnostic* diagnostic); // Validates a raw SPIR-V binary for correctness. Any errors will be written // into *diagnostic if diagnostic is non-null, otherwise the context's message // consumer will be used. SPIRV_TOOLS_EXPORT spv_result_t spvValidateBinary(const spv_const_context context, const uint32_t* words, const size_t num_words, spv_diagnostic* diagnostic); // Creates a diagnostic object. The position parameter specifies the location in // the text/binary stream. The message parameter, copied into the diagnostic // object, contains the error message to display. SPIRV_TOOLS_EXPORT spv_diagnostic spvDiagnosticCreate(const spv_position position, const char* message); // Destroys a diagnostic object. This is a no-op if diagnostic is a null // pointer. SPIRV_TOOLS_EXPORT void spvDiagnosticDestroy(spv_diagnostic diagnostic); // Prints the diagnostic to stderr. SPIRV_TOOLS_EXPORT spv_result_t spvDiagnosticPrint(const spv_diagnostic diagnostic); // Gets the name of an instruction, without the "Op" prefix. SPIRV_TOOLS_EXPORT const char* spvOpcodeString(const uint32_t opcode); // The binary parser interface. // A pointer to a function that accepts a parsed SPIR-V header. // The integer arguments are the 32-bit words from the header, as specified // in SPIR-V 1.0 Section 2.3 Table 1. // The function should return SPV_SUCCESS if parsing should continue. typedef spv_result_t (*spv_parsed_header_fn_t)( void* user_data, spv_endianness_t endian, uint32_t magic, uint32_t version, uint32_t generator, uint32_t id_bound, uint32_t reserved); // A pointer to a function that accepts a parsed SPIR-V instruction. // The parsed_instruction value is transient: it may be overwritten // or released immediately after the function has returned. That also // applies to the words array member of the parsed instruction. The // function should return SPV_SUCCESS if and only if parsing should // continue. typedef spv_result_t (*spv_parsed_instruction_fn_t)( void* user_data, const spv_parsed_instruction_t* parsed_instruction); // Parses a SPIR-V binary, specified as counted sequence of 32-bit words. // Parsing feedback is provided via two callbacks provided as function // pointers. Each callback function pointer can be a null pointer, in // which case it is never called. Otherwise, in a valid parse the // parsed-header callback is called once, and then the parsed-instruction // callback once for each instruction in the stream. The user_data parameter // is supplied as context to the callbacks. Returns SPV_SUCCESS on successful // parse where the callbacks always return SPV_SUCCESS. For an invalid parse, // returns a status code other than SPV_SUCCESS, and if diagnostic is non-null // also emits a diagnostic. If diagnostic is null the context's message consumer // will be used to emit any errors. If a callback returns anything other than // SPV_SUCCESS, then that status code is returned, no further callbacks are // issued, and no additional diagnostics are emitted. SPIRV_TOOLS_EXPORT spv_result_t spvBinaryParse( const spv_const_context context, void* user_data, const uint32_t* words, const size_t num_words, spv_parsed_header_fn_t parse_header, spv_parsed_instruction_fn_t parse_instruction, spv_diagnostic* diagnostic); // The optimizer interface. // A pointer to a function that accepts a log message from an optimizer. typedef void (*spv_message_consumer)( spv_message_level_t, const char*, const spv_position_t*, const char*); // Creates and returns an optimizer object. This object must be passed to // optimizer APIs below and is valid until passed to spvOptimizerDestroy. SPIRV_TOOLS_EXPORT spv_optimizer_t* spvOptimizerCreate(spv_target_env env); // Destroys the given optimizer object. SPIRV_TOOLS_EXPORT void spvOptimizerDestroy(spv_optimizer_t* optimizer); // Sets an spv_message_consumer on an optimizer object. SPIRV_TOOLS_EXPORT void spvOptimizerSetMessageConsumer( spv_optimizer_t* optimizer, spv_message_consumer consumer); // Registers passes that attempt to legalize the generated code. SPIRV_TOOLS_EXPORT void spvOptimizerRegisterLegalizationPasses( spv_optimizer_t* optimizer); // Registers passes that attempt to improve performance of generated code. SPIRV_TOOLS_EXPORT void spvOptimizerRegisterPerformancePasses( spv_optimizer_t* optimizer); // Registers passes that attempt to improve the size of generated code. SPIRV_TOOLS_EXPORT void spvOptimizerRegisterSizePasses( spv_optimizer_t* optimizer); // Registers a pass specified by a flag in an optimizer object. SPIRV_TOOLS_EXPORT bool spvOptimizerRegisterPassFromFlag( spv_optimizer_t* optimizer, const char* flag); // Registers passes specified by length number of flags in an optimizer object. // Passes may remove interface variables that are unused. SPIRV_TOOLS_EXPORT bool spvOptimizerRegisterPassesFromFlags( spv_optimizer_t* optimizer, const char** flags, const size_t flag_count); // Registers passes specified by length number of flags in an optimizer object. // Passes will not remove interface variables. SPIRV_TOOLS_EXPORT bool spvOptimizerRegisterPassesFromFlagsWhilePreservingTheInterface( spv_optimizer_t* optimizer, const char** flags, const size_t flag_count); // Optimizes the SPIR-V code of size |word_count| pointed to by |binary| and // returns an optimized spv_binary in |optimized_binary|. // // Returns SPV_SUCCESS on successful optimization, whether or not the module is // modified. Returns an SPV_ERROR_* if the module fails to validate or if // errors occur when processing using any of the registered passes. In that // case, no further passes are executed and the |optimized_binary| contents may // be invalid. // // By default, the binary is validated before any transforms are performed, // and optionally after each transform. Validation uses SPIR-V spec rules // for the SPIR-V version named in the binary's header (at word offset 1). // Additionally, if the target environment is a client API (such as // Vulkan 1.1), then validate for that client API version, to the extent // that it is verifiable from data in the binary itself, or from the // validator options set on the optimizer options. SPIRV_TOOLS_EXPORT spv_result_t spvOptimizerRun( spv_optimizer_t* optimizer, const uint32_t* binary, const size_t word_count, spv_binary* optimized_binary, const spv_optimizer_options options); #ifdef __cplusplus } #endif #endif // INCLUDE_SPIRV_TOOLS_LIBSPIRV_H_ KhronosGroup-SPIRV-Tools-f289d04/include/spirv-tools/libspirv.hpp000066400000000000000000000400071475742701700250210ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef INCLUDE_SPIRV_TOOLS_LIBSPIRV_HPP_ #define INCLUDE_SPIRV_TOOLS_LIBSPIRV_HPP_ #include #include #include #include #include "libspirv.h" namespace spvtools { // Message consumer. The C strings for source and message are only alive for the // specific invocation. using MessageConsumer = std::function; using HeaderParser = std::function; using InstructionParser = std::function; // C++ RAII wrapper around the C context object spv_context. class SPIRV_TOOLS_EXPORT Context { public: // Constructs a context targeting the given environment |env|. // // See specific API calls for how the target environment is interpreted // (particularly assembly and validation). // // The constructed instance will have an empty message consumer, which just // ignores all messages from the library. Use SetMessageConsumer() to supply // one if messages are of concern. explicit Context(spv_target_env env); // Enables move constructor/assignment operations. Context(Context&& other); Context& operator=(Context&& other); // Disables copy constructor/assignment operations. Context(const Context&) = delete; Context& operator=(const Context&) = delete; // Destructs this instance. ~Context(); // Sets the message consumer to the given |consumer|. The |consumer| will be // invoked once for each message communicated from the library. void SetMessageConsumer(MessageConsumer consumer); // Returns the underlying spv_context. spv_context& CContext(); const spv_context& CContext() const; private: spv_context context_; }; // A RAII wrapper around a validator options object. class SPIRV_TOOLS_EXPORT ValidatorOptions { public: ValidatorOptions() : options_(spvValidatorOptionsCreate()) {} ~ValidatorOptions() { spvValidatorOptionsDestroy(options_); } // Allow implicit conversion to the underlying object. operator spv_validator_options() const { return options_; } // Sets a limit. void SetUniversalLimit(spv_validator_limit limit_type, uint32_t limit) { spvValidatorOptionsSetUniversalLimit(options_, limit_type, limit); } void SetRelaxStructStore(bool val) { spvValidatorOptionsSetRelaxStoreStruct(options_, val); } // Enables VK_KHR_relaxed_block_layout when validating standard // uniform/storage buffer/push-constant layout. If true, disables // scalar block layout rules. void SetRelaxBlockLayout(bool val) { spvValidatorOptionsSetRelaxBlockLayout(options_, val); } // Enables VK_KHR_uniform_buffer_standard_layout when validating standard // uniform layout. If true, disables scalar block layout rules. void SetUniformBufferStandardLayout(bool val) { spvValidatorOptionsSetUniformBufferStandardLayout(options_, val); } // Enables VK_EXT_scalar_block_layout when validating standard // uniform/storage buffer/push-constant layout. If true, disables // relaxed block layout rules. void SetScalarBlockLayout(bool val) { spvValidatorOptionsSetScalarBlockLayout(options_, val); } // Enables scalar layout when validating Workgroup blocks. See // VK_KHR_workgroup_memory_explicit_layout. void SetWorkgroupScalarBlockLayout(bool val) { spvValidatorOptionsSetWorkgroupScalarBlockLayout(options_, val); } // Skips validating standard uniform/storage buffer/push-constant layout. void SetSkipBlockLayout(bool val) { spvValidatorOptionsSetSkipBlockLayout(options_, val); } // Enables LocalSizeId decorations where the environment would not otherwise // allow them. void SetAllowLocalSizeId(bool val) { spvValidatorOptionsSetAllowLocalSizeId(options_, val); } // Allow Offset (in addition to ConstOffset) for texture // operations. Was added for VK_KHR_maintenance8 void SetAllowOffsetTextureOperand(bool val) { spvValidatorOptionsSetAllowOffsetTextureOperand(options_, val); } // Allow base operands of some bit operations to be non-32-bit wide. void SetAllowVulkan32BitBitwise(bool val) { spvValidatorOptionsSetAllowVulkan32BitBitwise(options_, val); } // Records whether or not the validator should relax the rules on pointer // usage in logical addressing mode. // // When relaxed, it will allow the following usage cases of pointers: // 1) OpVariable allocating an object whose type is a pointer type // 2) OpReturnValue returning a pointer value void SetRelaxLogicalPointer(bool val) { spvValidatorOptionsSetRelaxLogicalPointer(options_, val); } // Records whether or not the validator should relax the rules because it is // expected that the optimizations will make the code legal. // // When relaxed, it will allow the following: // 1) It will allow relaxed logical pointers. Setting this option will also // set that option. // 2) Pointers that are pass as parameters to function calls do not have to // match the storage class of the formal parameter. // 3) Pointers that are actual parameters on function calls do not have to // point to the same type pointed as the formal parameter. The types just // need to logically match. // 4) GLSLstd450 Interpolate* instructions can have a load of an interpolant // for a first argument. void SetBeforeHlslLegalization(bool val) { spvValidatorOptionsSetBeforeHlslLegalization(options_, val); } // Whether friendly names should be used in validation error messages. void SetFriendlyNames(bool val) { spvValidatorOptionsSetFriendlyNames(options_, val); } private: spv_validator_options options_; }; // A C++ wrapper around an optimization options object. class SPIRV_TOOLS_EXPORT OptimizerOptions { public: OptimizerOptions() : options_(spvOptimizerOptionsCreate()) {} ~OptimizerOptions() { spvOptimizerOptionsDestroy(options_); } // Allow implicit conversion to the underlying object. operator spv_optimizer_options() const { return options_; } // Records whether or not the optimizer should run the validator before // optimizing. If |run| is true, the validator will be run. void set_run_validator(bool run) { spvOptimizerOptionsSetRunValidator(options_, run); } // Records the validator options that should be passed to the validator if it // is run. void set_validator_options(const ValidatorOptions& val_options) { spvOptimizerOptionsSetValidatorOptions(options_, val_options); } // Records the maximum possible value for the id bound. void set_max_id_bound(uint32_t new_bound) { spvOptimizerOptionsSetMaxIdBound(options_, new_bound); } // Records whether all bindings within the module should be preserved. void set_preserve_bindings(bool preserve_bindings) { spvOptimizerOptionsSetPreserveBindings(options_, preserve_bindings); } // Records whether all specialization constants within the module // should be preserved. void set_preserve_spec_constants(bool preserve_spec_constants) { spvOptimizerOptionsSetPreserveSpecConstants(options_, preserve_spec_constants); } private: spv_optimizer_options options_; }; // A C++ wrapper around a reducer options object. class SPIRV_TOOLS_EXPORT ReducerOptions { public: ReducerOptions() : options_(spvReducerOptionsCreate()) {} ~ReducerOptions() { spvReducerOptionsDestroy(options_); } // Allow implicit conversion to the underlying object. operator spv_reducer_options() const { // NOLINT(google-explicit-constructor) return options_; } // See spvReducerOptionsSetStepLimit. void set_step_limit(uint32_t step_limit) { spvReducerOptionsSetStepLimit(options_, step_limit); } // See spvReducerOptionsSetFailOnValidationError. void set_fail_on_validation_error(bool fail_on_validation_error) { spvReducerOptionsSetFailOnValidationError(options_, fail_on_validation_error); } // See spvReducerOptionsSetTargetFunction. void set_target_function(uint32_t target_function) { spvReducerOptionsSetTargetFunction(options_, target_function); } private: spv_reducer_options options_; }; // A C++ wrapper around a fuzzer options object. class SPIRV_TOOLS_EXPORT FuzzerOptions { public: FuzzerOptions() : options_(spvFuzzerOptionsCreate()) {} ~FuzzerOptions() { spvFuzzerOptionsDestroy(options_); } // Allow implicit conversion to the underlying object. operator spv_fuzzer_options() const { // NOLINT(google-explicit-constructor) return options_; } // See spvFuzzerOptionsEnableReplayValidation. void enable_replay_validation() { spvFuzzerOptionsEnableReplayValidation(options_); } // See spvFuzzerOptionsSetRandomSeed. void set_random_seed(uint32_t seed) { spvFuzzerOptionsSetRandomSeed(options_, seed); } // See spvFuzzerOptionsSetReplayRange. void set_replay_range(int32_t replay_range) { spvFuzzerOptionsSetReplayRange(options_, replay_range); } // See spvFuzzerOptionsSetShrinkerStepLimit. void set_shrinker_step_limit(uint32_t shrinker_step_limit) { spvFuzzerOptionsSetShrinkerStepLimit(options_, shrinker_step_limit); } // See spvFuzzerOptionsEnableFuzzerPassValidation. void enable_fuzzer_pass_validation() { spvFuzzerOptionsEnableFuzzerPassValidation(options_); } // See spvFuzzerOptionsEnableAllPasses. void enable_all_passes() { spvFuzzerOptionsEnableAllPasses(options_); } private: spv_fuzzer_options options_; }; // C++ interface for SPIRV-Tools functionalities. It wraps the context // (including target environment and the corresponding SPIR-V grammar) and // provides methods for assembling, disassembling, and validating. // // Instances of this class provide basic thread-safety guarantee. class SPIRV_TOOLS_EXPORT SpirvTools { public: enum { // Default assembling option used by assemble(): kDefaultAssembleOption = SPV_TEXT_TO_BINARY_OPTION_NONE, // Default disassembling option used by Disassemble(): // * Avoid prefix comments from decoding the SPIR-V module header, and // * Use friendly names for variables. kDefaultDisassembleOption = SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES }; // Constructs an instance targeting the given environment |env|. // // The constructed instance will have an empty message consumer, which just // ignores all messages from the library. Use SetMessageConsumer() to supply // one if messages are of concern. explicit SpirvTools(spv_target_env env); // Disables copy/move constructor/assignment operations. SpirvTools(const SpirvTools&) = delete; SpirvTools(SpirvTools&&) = delete; SpirvTools& operator=(const SpirvTools&) = delete; SpirvTools& operator=(SpirvTools&&) = delete; // Destructs this instance. ~SpirvTools(); // Sets the message consumer to the given |consumer|. The |consumer| will be // invoked once for each message communicated from the library. void SetMessageConsumer(MessageConsumer consumer); // Assembles the given assembly |text| and writes the result to |binary|. // Returns true on successful assembling. |binary| will be kept untouched if // assembling is unsuccessful. // The SPIR-V binary version is set to the highest version of SPIR-V supported // by the target environment with which this SpirvTools object was created. bool Assemble(const std::string& text, std::vector* binary, uint32_t options = kDefaultAssembleOption) const; // |text_size| specifies the number of bytes in |text|. A terminating null // character is not required to present in |text| as long as |text| is valid. // The SPIR-V binary version is set to the highest version of SPIR-V supported // by the target environment with which this SpirvTools object was created. bool Assemble(const char* text, size_t text_size, std::vector* binary, uint32_t options = kDefaultAssembleOption) const; // Disassembles the given SPIR-V |binary| with the given |options| and writes // the assembly to |text|. Returns true on successful disassembling. |text| // will be kept untouched if diassembling is unsuccessful. bool Disassemble(const std::vector& binary, std::string* text, uint32_t options = kDefaultDisassembleOption) const; // |binary_size| specifies the number of words in |binary|. bool Disassemble(const uint32_t* binary, size_t binary_size, std::string* text, uint32_t options = kDefaultDisassembleOption) const; // Parses a SPIR-V binary, specified as counted sequence of 32-bit words. // Parsing feedback is provided via two callbacks provided as std::function. // In a valid parse the parsed-header callback is called once, and // then the parsed-instruction callback is called once for each instruction // in the stream. // Returns true on successful parsing. // If diagnostic is non-null, a diagnostic is emitted on failed parsing. // If diagnostic is null the context's message consumer // will be used to emit any errors. If a callback returns anything other than // SPV_SUCCESS, then that status code is returned, no further callbacks are // issued, and no additional diagnostics are emitted. // This is a wrapper around the C API spvBinaryParse. bool Parse(const std::vector& binary, const HeaderParser& header_parser, const InstructionParser& instruction_parser, spv_diagnostic* diagnostic = nullptr); // Validates the given SPIR-V |binary|. Returns true if no issues are found. // Otherwise, returns false and communicates issues via the message consumer // registered. // Validates for SPIR-V spec rules for the SPIR-V version named in the // binary's header (at word offset 1). Additionally, if the target // environment is a client API (such as Vulkan 1.1), then validate for that // client API version, to the extent that it is verifiable from data in the // binary itself. bool Validate(const std::vector& binary) const; // Like the previous overload, but provides the binary as a pointer and size: // |binary_size| specifies the number of words in |binary|. // Validates for SPIR-V spec rules for the SPIR-V version named in the // binary's header (at word offset 1). Additionally, if the target // environment is a client API (such as Vulkan 1.1), then validate for that // client API version, to the extent that it is verifiable from data in the // binary itself. bool Validate(const uint32_t* binary, size_t binary_size) const; // Like the previous overload, but takes an options object. // Validates for SPIR-V spec rules for the SPIR-V version named in the // binary's header (at word offset 1). Additionally, if the target // environment is a client API (such as Vulkan 1.1), then validate for that // client API version, to the extent that it is verifiable from data in the // binary itself, or in the validator options. bool Validate(const uint32_t* binary, size_t binary_size, spv_validator_options options) const; // Was this object successfully constructed. bool IsValid() const; private: struct SPIRV_TOOLS_LOCAL Impl; // Opaque struct for holding the data fields used by this class. std::unique_ptr impl_; // Unique pointer to implementation data. }; } // namespace spvtools #endif // INCLUDE_SPIRV_TOOLS_LIBSPIRV_HPP_ KhronosGroup-SPIRV-Tools-f289d04/include/spirv-tools/linker.hpp000066400000000000000000000075141475742701700244610ustar00rootroot00000000000000// Copyright (c) 2017 Pierre Moreau // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef INCLUDE_SPIRV_TOOLS_LINKER_HPP_ #define INCLUDE_SPIRV_TOOLS_LINKER_HPP_ #include #include #include #include "libspirv.hpp" namespace spvtools { class SPIRV_TOOLS_EXPORT LinkerOptions { public: // Returns whether a library or an executable should be produced by the // linking phase. // // All exported symbols are kept when creating a library, whereas they will // be removed when creating an executable. // The returned value will be true if creating a library, and false if // creating an executable. bool GetCreateLibrary() const { return create_library_; } // Sets whether a library or an executable should be produced. void SetCreateLibrary(bool create_library) { create_library_ = create_library; } // Returns whether to verify the uniqueness of the unique ids in the merged // context. bool GetVerifyIds() const { return verify_ids_; } // Sets whether to verify the uniqueness of the unique ids in the merged // context. void SetVerifyIds(bool verify_ids) { verify_ids_ = verify_ids; } // Returns whether to allow for imported symbols to have no corresponding // exported symbols bool GetAllowPartialLinkage() const { return allow_partial_linkage_; } // Sets whether to allow for imported symbols to have no corresponding // exported symbols void SetAllowPartialLinkage(bool allow_partial_linkage) { allow_partial_linkage_ = allow_partial_linkage; } bool GetUseHighestVersion() const { return use_highest_version_; } void SetUseHighestVersion(bool use_highest_vers) { use_highest_version_ = use_highest_vers; } bool GetAllowPtrTypeMismatch() const { return allow_ptr_type_mismatch_; } void SetAllowPtrTypeMismatch(bool allow_ptr_type_mismatch) { allow_ptr_type_mismatch_ = allow_ptr_type_mismatch; } private: bool create_library_{false}; bool verify_ids_{false}; bool allow_partial_linkage_{false}; bool use_highest_version_{false}; bool allow_ptr_type_mismatch_{false}; }; // Links one or more SPIR-V modules into a new SPIR-V module. That is, combine // several SPIR-V modules into one, resolving link dependencies between them. // // At least one binary has to be provided in |binaries|. Those binaries do not // have to be valid, but they should be at least parseable. // The functions can fail due to the following: // * The given context was not initialised using `spvContextCreate()`; // * No input modules were given; // * One or more of those modules were not parseable; // * The input modules used different addressing or memory models; // * The ID or global variable number limit were exceeded; // * Some entry points were defined multiple times; // * Some imported symbols did not have an exported counterpart; // * Possibly other reasons. SPIRV_TOOLS_EXPORT spv_result_t Link(const Context& context, const std::vector>& binaries, std::vector* linked_binary, const LinkerOptions& options = LinkerOptions()); SPIRV_TOOLS_EXPORT spv_result_t Link(const Context& context, const uint32_t* const* binaries, const size_t* binary_sizes, size_t num_binaries, std::vector* linked_binary, const LinkerOptions& options = LinkerOptions()); } // namespace spvtools #endif // INCLUDE_SPIRV_TOOLS_LINKER_HPP_ KhronosGroup-SPIRV-Tools-f289d04/include/spirv-tools/linter.hpp000066400000000000000000000030521475742701700244630ustar00rootroot00000000000000// Copyright (c) 2021 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef INCLUDE_SPIRV_TOOLS_LINTER_HPP_ #define INCLUDE_SPIRV_TOOLS_LINTER_HPP_ #include "libspirv.hpp" namespace spvtools { // C++ interface for SPIR-V linting functionalities. It wraps the context // (including target environment and the corresponding SPIR-V grammar) and // provides a method for linting. // // Instances of this class provides basic thread-safety guarantee. class SPIRV_TOOLS_EXPORT Linter { public: explicit Linter(spv_target_env env); ~Linter(); // Sets the message consumer to the given |consumer|. The |consumer| will be // invoked once for each message communicated from the library. void SetMessageConsumer(MessageConsumer consumer); // Returns a reference to the registered message consumer. const MessageConsumer& Consumer() const; bool Run(const uint32_t* binary, size_t binary_size); private: struct SPIRV_TOOLS_LOCAL Impl; std::unique_ptr impl_; }; } // namespace spvtools #endif // INCLUDE_SPIRV_TOOLS_LINTER_HPP_ KhronosGroup-SPIRV-Tools-f289d04/include/spirv-tools/optimizer.hpp000066400000000000000000001372221475742701700252170ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef INCLUDE_SPIRV_TOOLS_OPTIMIZER_HPP_ #define INCLUDE_SPIRV_TOOLS_OPTIMIZER_HPP_ #include #include #include #include #include #include #include #include "libspirv.hpp" namespace spvtools { namespace opt { class Pass; struct DescriptorSetAndBinding; } // namespace opt // C++ interface for SPIR-V optimization functionalities. It wraps the context // (including target environment and the corresponding SPIR-V grammar) and // provides methods for registering optimization passes and optimizing. // // Instances of this class provides basic thread-safety guarantee. class SPIRV_TOOLS_EXPORT Optimizer { public: // The token for an optimization pass. It is returned via one of the // Create*Pass() standalone functions at the end of this header file and // consumed by the RegisterPass() method. Tokens are one-time objects that // only support move; copying is not allowed. struct PassToken { struct SPIRV_TOOLS_LOCAL Impl; // Opaque struct for holding internal data. PassToken(std::unique_ptr); // Tokens for built-in passes should be created using Create*Pass functions // below; for out-of-tree passes, use this constructor instead. // Note that this API isn't guaranteed to be stable and may change without // preserving source or binary compatibility in the future. PassToken(std::unique_ptr&& pass); // Tokens can only be moved. Copying is disabled. PassToken(const PassToken&) = delete; PassToken(PassToken&&); PassToken& operator=(const PassToken&) = delete; PassToken& operator=(PassToken&&); ~PassToken(); std::unique_ptr impl_; // Unique pointer to internal data. }; // Constructs an instance with the given target |env|, which is used to decode // the binaries to be optimized later. // // The instance will have an empty message consumer, which ignores all // messages from the library. Use SetMessageConsumer() to supply a consumer // if messages are of concern. explicit Optimizer(spv_target_env env); // Disables copy/move constructor/assignment operations. Optimizer(const Optimizer&) = delete; Optimizer(Optimizer&&) = delete; Optimizer& operator=(const Optimizer&) = delete; Optimizer& operator=(Optimizer&&) = delete; // Destructs this instance. ~Optimizer(); // Sets the message consumer to the given |consumer|. The |consumer| will be // invoked once for each message communicated from the library. void SetMessageConsumer(MessageConsumer consumer); // Returns a reference to the registered message consumer. const MessageConsumer& consumer() const; // Registers the given |pass| to this optimizer. Passes will be run in the // exact order of registration. The token passed in will be consumed by this // method. Optimizer& RegisterPass(PassToken&& pass); // Registers passes that attempt to improve performance of generated code. // This sequence of passes is subject to constant review and will change // from time to time. // // If |preserve_interface| is true, all non-io variables in the entry point // interface are considered live and are not eliminated. Optimizer& RegisterPerformancePasses(); Optimizer& RegisterPerformancePasses(bool preserve_interface); // Registers passes that attempt to improve the size of generated code. // This sequence of passes is subject to constant review and will change // from time to time. // // If |preserve_interface| is true, all non-io variables in the entry point // interface are considered live and are not eliminated. Optimizer& RegisterSizePasses(); Optimizer& RegisterSizePasses(bool preserve_interface); // Registers passes that attempt to legalize the generated code. // // Note: this recipe is specially designed for legalizing SPIR-V. It should be // used by compilers after translating HLSL source code literally. It should // *not* be used by general workloads for performance or size improvement. // // This sequence of passes is subject to constant review and will change // from time to time. // // If |preserve_interface| is true, all non-io variables in the entry point // interface are considered live and are not eliminated. Optimizer& RegisterLegalizationPasses(); Optimizer& RegisterLegalizationPasses(bool preserve_interface); // Register passes specified in the list of |flags|. Each flag must be a // string of a form accepted by Optimizer::FlagHasValidForm(). // // If the list of flags contains an invalid entry, it returns false and an // error message is emitted to the MessageConsumer object (use // Optimizer::SetMessageConsumer to define a message consumer, if needed). // // If |preserve_interface| is true, all non-io variables in the entry point // interface are considered live and are not eliminated. // // If all the passes are registered successfully, it returns true. bool RegisterPassesFromFlags(const std::vector& flags); bool RegisterPassesFromFlags(const std::vector& flags, bool preserve_interface); // Registers the optimization pass associated with |flag|. This only accepts // |flag| values of the form "--pass_name[=pass_args]". If no such pass // exists, it returns false. Otherwise, the pass is registered and it returns // true. // // The following flags have special meaning: // // -O: Registers all performance optimization passes // (Optimizer::RegisterPerformancePasses) // // -Os: Registers all size optimization passes // (Optimizer::RegisterSizePasses). // // --legalize-hlsl: Registers all passes that legalize SPIR-V generated by an // HLSL front-end. // // If |preserve_interface| is true, all non-io variables in the entry point // interface are considered live and are not eliminated. bool RegisterPassFromFlag(const std::string& flag); bool RegisterPassFromFlag(const std::string& flag, bool preserve_interface); // Validates that |flag| has a valid format. Strings accepted: // // --pass_name[=pass_args] // -O // -Os // // If |flag| takes one of the forms above, it returns true. Otherwise, it // returns false. bool FlagHasValidForm(const std::string& flag) const; // Allows changing, after creation time, the target environment to be // optimized for and validated. Should be called before calling Run(). void SetTargetEnv(const spv_target_env env); // Optimizes the given SPIR-V module |original_binary| and writes the // optimized binary into |optimized_binary|. The optimized binary uses // the same SPIR-V version as the original binary. // // Returns true on successful optimization, whether or not the module is // modified. Returns false if |original_binary| fails to validate or if errors // occur when processing |original_binary| using any of the registered passes. // In that case, no further passes are executed and the contents in // |optimized_binary| may be invalid. // // By default, the binary is validated before any transforms are performed, // and optionally after each transform. Validation uses SPIR-V spec rules // for the SPIR-V version named in the binary's header (at word offset 1). // Additionally, if the target environment is a client API (such as // Vulkan 1.1), then validate for that client API version, to the extent // that it is verifiable from data in the binary itself. // // It's allowed to alias |original_binary| to the start of |optimized_binary|. bool Run(const uint32_t* original_binary, size_t original_binary_size, std::vector* optimized_binary) const; // DEPRECATED: Same as above, except passes |options| to the validator when // trying to validate the binary. If |skip_validation| is true, then the // caller is guaranteeing that |original_binary| is valid, and the validator // will not be run. The |max_id_bound| is the limit on the max id in the // module. bool Run(const uint32_t* original_binary, const size_t original_binary_size, std::vector* optimized_binary, const ValidatorOptions& options, bool skip_validation) const; // Same as above, except it takes an options object. See the documentation // for |OptimizerOptions| to see which options can be set. // // By default, the binary is validated before any transforms are performed, // and optionally after each transform. Validation uses SPIR-V spec rules // for the SPIR-V version named in the binary's header (at word offset 1). // Additionally, if the target environment is a client API (such as // Vulkan 1.1), then validate for that client API version, to the extent // that it is verifiable from data in the binary itself, or from the // validator options set on the optimizer options. bool Run(const uint32_t* original_binary, const size_t original_binary_size, std::vector* optimized_binary, const spv_optimizer_options opt_options) const; // Returns a vector of strings with all the pass names added to this // optimizer's pass manager. These strings are valid until the associated // pass manager is destroyed. std::vector GetPassNames() const; // Sets the option to print the disassembly before each pass and after the // last pass. If |out| is null, then no output is generated. Otherwise, // output is sent to the |out| output stream. Optimizer& SetPrintAll(std::ostream* out); // Sets the option to print the resource utilization of each pass. If |out| // is null, then no output is generated. Otherwise, output is sent to the // |out| output stream. Optimizer& SetTimeReport(std::ostream* out); // Sets the option to validate the module after each pass. Optimizer& SetValidateAfterAll(bool validate); private: struct SPIRV_TOOLS_LOCAL Impl; // Opaque struct for holding internal data. std::unique_ptr impl_; // Unique pointer to internal data. }; // Creates a null pass. // A null pass does nothing to the SPIR-V module to be optimized. Optimizer::PassToken CreateNullPass(); // Creates a strip-debug-info pass. // A strip-debug-info pass removes all debug instructions (as documented in // Section 3.42.2 of the SPIR-V spec) of the SPIR-V module to be optimized. Optimizer::PassToken CreateStripDebugInfoPass(); // [Deprecated] This will create a strip-nonsemantic-info pass. See below. Optimizer::PassToken CreateStripReflectInfoPass(); // Creates a strip-nonsemantic-info pass. // A strip-nonsemantic-info pass removes all reflections and explicitly // non-semantic instructions. Optimizer::PassToken CreateStripNonSemanticInfoPass(); // Creates an eliminate-dead-functions pass. // An eliminate-dead-functions pass will remove all functions that are not in // the call trees rooted at entry points and exported functions. These // functions are not needed because they will never be called. Optimizer::PassToken CreateEliminateDeadFunctionsPass(); // Creates an eliminate-dead-members pass. // An eliminate-dead-members pass will remove all unused members of structures. // This will not affect the data layout of the remaining members. Optimizer::PassToken CreateEliminateDeadMembersPass(); // Creates a set-spec-constant-default-value pass from a mapping from spec-ids // to the default values in the form of string. // A set-spec-constant-default-value pass sets the default values for the // spec constants that have SpecId decorations (i.e., those defined by // OpSpecConstant{|True|False} instructions). Optimizer::PassToken CreateSetSpecConstantDefaultValuePass( const std::unordered_map& id_value_map); // Creates a set-spec-constant-default-value pass from a mapping from spec-ids // to the default values in the form of bit pattern. // A set-spec-constant-default-value pass sets the default values for the // spec constants that have SpecId decorations (i.e., those defined by // OpSpecConstant{|True|False} instructions). Optimizer::PassToken CreateSetSpecConstantDefaultValuePass( const std::unordered_map>& id_value_map); // Creates a flatten-decoration pass. // A flatten-decoration pass replaces grouped decorations with equivalent // ungrouped decorations. That is, it replaces each OpDecorationGroup // instruction and associated OpGroupDecorate and OpGroupMemberDecorate // instructions with equivalent OpDecorate and OpMemberDecorate instructions. // The pass does not attempt to preserve debug information for instructions // it removes. Optimizer::PassToken CreateFlattenDecorationPass(); // Creates a freeze-spec-constant-value pass. // A freeze-spec-constant pass specializes the value of spec constants to // their default values. This pass only processes the spec constants that have // SpecId decorations (defined by OpSpecConstant, OpSpecConstantTrue, or // OpSpecConstantFalse instructions) and replaces them with their normal // counterparts (OpConstant, OpConstantTrue, or OpConstantFalse). The // corresponding SpecId annotation instructions will also be removed. This // pass does not fold the newly added normal constants and does not process // other spec constants defined by OpSpecConstantComposite or // OpSpecConstantOp. Optimizer::PassToken CreateFreezeSpecConstantValuePass(); // Creates a fold-spec-constant-op-and-composite pass. // A fold-spec-constant-op-and-composite pass folds spec constants defined by // OpSpecConstantOp or OpSpecConstantComposite instruction, to normal Constants // defined by OpConstantTrue, OpConstantFalse, OpConstant, OpConstantNull, or // OpConstantComposite instructions. Note that spec constants defined with // OpSpecConstant, OpSpecConstantTrue, or OpSpecConstantFalse instructions are // not handled, as these instructions indicate their value are not determined // and can be changed in future. A spec constant is foldable if all of its // value(s) can be determined from the module. E.g., an integer spec constant // defined with OpSpecConstantOp instruction can be folded if its value won't // change later. This pass will replace the original OpSpecConstantOp // instruction with an OpConstant instruction. When folding composite spec // constants, new instructions may be inserted to define the components of the // composite constant first, then the original spec constants will be replaced // by OpConstantComposite instructions. // // There are some operations not supported yet: // OpSConvert, OpFConvert, OpQuantizeToF16 and // all the operations under Kernel capability. // TODO(qining): Add support for the operations listed above. Optimizer::PassToken CreateFoldSpecConstantOpAndCompositePass(); // Creates a unify-constant pass. // A unify-constant pass de-duplicates the constants. Constants with the exact // same value and identical form will be unified and only one constant will // be kept for each unique pair of type and value. // There are several cases not handled by this pass: // 1) Constants defined by OpConstantNull instructions (null constants) and // constants defined by OpConstantFalse, OpConstant or OpConstantComposite // with value 0 (zero-valued normal constants) are not considered equivalent. // So null constants won't be used to replace zero-valued normal constants, // vice versa. // 2) Whenever there are decorations to the constant's result id id, the // constant won't be handled, which means, it won't be used to replace any // other constants, neither can other constants replace it. // 3) NaN in float point format with different bit patterns are not unified. Optimizer::PassToken CreateUnifyConstantPass(); // Creates a eliminate-dead-constant pass. // A eliminate-dead-constant pass removes dead constants, including normal // constants defined by OpConstant, OpConstantComposite, OpConstantTrue, or // OpConstantFalse and spec constants defined by OpSpecConstant, // OpSpecConstantComposite, OpSpecConstantTrue, OpSpecConstantFalse or // OpSpecConstantOp. Optimizer::PassToken CreateEliminateDeadConstantPass(); // Creates a strength-reduction pass. // A strength-reduction pass will look for opportunities to replace an // instruction with an equivalent and less expensive one. For example, // multiplying by a power of 2 can be replaced by a bit shift. Optimizer::PassToken CreateStrengthReductionPass(); // Creates a block merge pass. // This pass searches for blocks with a single Branch to a block with no // other predecessors and merges the blocks into a single block. Continue // blocks and Merge blocks are not candidates for the second block. // // The pass is most useful after Dead Branch Elimination, which can leave // such sequences of blocks. Merging them makes subsequent passes more // effective, such as single block local store-load elimination. // // While this pass reduces the number of occurrences of this sequence, at // this time it does not guarantee all such sequences are eliminated. // // Presence of phi instructions can inhibit this optimization. Handling // these is left for future improvements. Optimizer::PassToken CreateBlockMergePass(); // Creates an exhaustive inline pass. // An exhaustive inline pass attempts to exhaustively inline all function // calls in all functions in an entry point call tree. The intent is to enable, // albeit through brute force, analysis and optimization across function // calls by subsequent optimization passes. As the inlining is exhaustive, // there is no attempt to optimize for size or runtime performance. Functions // that are not in the call tree of an entry point are not changed. Optimizer::PassToken CreateInlineExhaustivePass(); // Creates an opaque inline pass. // An opaque inline pass inlines all function calls in all functions in all // entry point call trees where the called function contains an opaque type // in either its parameter types or return type. An opaque type is currently // defined as Image, Sampler or SampledImage. The intent is to enable, albeit // through brute force, analysis and optimization across these function calls // by subsequent passes in order to remove the storing of opaque types which is // not legal in Vulkan. Functions that are not in the call tree of an entry // point are not changed. Optimizer::PassToken CreateInlineOpaquePass(); // Creates a single-block local variable load/store elimination pass. // For every entry point function, do single block memory optimization of // function variables referenced only with non-access-chain loads and stores. // For each targeted variable load, if previous store to that variable in the // block, replace the load's result id with the value id of the store. // If previous load within the block, replace the current load's result id // with the previous load's result id. In either case, delete the current // load. Finally, check if any remaining stores are useless, and delete store // and variable if possible. // // The presence of access chain references and function calls can inhibit // the above optimization. // // Only modules with relaxed logical addressing (see opt/instruction.h) are // currently processed. // // This pass is most effective if preceded by Inlining and // LocalAccessChainConvert. This pass will reduce the work needed to be done // by LocalSingleStoreElim and LocalMultiStoreElim. // // Only functions in the call tree of an entry point are processed. Optimizer::PassToken CreateLocalSingleBlockLoadStoreElimPass(); // Create dead branch elimination pass. // For each entry point function, this pass will look for SelectionMerge // BranchConditionals with constant condition and convert to a Branch to // the indicated label. It will delete resulting dead blocks. // // For all phi functions in merge block, replace all uses with the id // corresponding to the living predecessor. // // Note that some branches and blocks may be left to avoid creating invalid // control flow. Improving this is left to future work. // // This pass is most effective when preceded by passes which eliminate // local loads and stores, effectively propagating constant values where // possible. Optimizer::PassToken CreateDeadBranchElimPass(); // Creates an SSA local variable load/store elimination pass. // For every entry point function, eliminate all loads and stores of function // scope variables only referenced with non-access-chain loads and stores. // Eliminate the variables as well. // // The presence of access chain references and function calls can inhibit // the above optimization. // // Only shader modules with relaxed logical addressing (see opt/instruction.h) // are currently processed. Currently modules with any extensions enabled are // not processed. This is left for future work. // // This pass is most effective if preceded by Inlining and // LocalAccessChainConvert. LocalSingleStoreElim and LocalSingleBlockElim // will reduce the work that this pass has to do. Optimizer::PassToken CreateLocalMultiStoreElimPass(); // Creates a local access chain conversion pass. // A local access chain conversion pass identifies all function scope // variables which are accessed only with loads, stores and access chains // with constant indices. It then converts all loads and stores of such // variables into equivalent sequences of loads, stores, extracts and inserts. // // This pass only processes entry point functions. It currently only converts // non-nested, non-ptr access chains. It does not process modules with // non-32-bit integer types present. Optional memory access options on loads // and stores are ignored as we are only processing function scope variables. // // This pass unifies access to these variables to a single mode and simplifies // subsequent analysis and elimination of these variables along with their // loads and stores allowing values to propagate to their points of use where // possible. Optimizer::PassToken CreateLocalAccessChainConvertPass(); // Creates a local single store elimination pass. // For each entry point function, this pass eliminates loads and stores for // function scope variable that are stored to only once, where possible. Only // whole variable loads and stores are eliminated; access-chain references are // not optimized. Replace all loads of such variables with the value that is // stored and eliminate any resulting dead code. // // Currently, the presence of access chains and function calls can inhibit this // pass, however the Inlining and LocalAccessChainConvert passes can make it // more effective. In additional, many non-load/store memory operations are // not supported and will prohibit optimization of a function. Support of // these operations are future work. // // Only shader modules with relaxed logical addressing (see opt/instruction.h) // are currently processed. // // This pass will reduce the work needed to be done by LocalSingleBlockElim // and LocalMultiStoreElim and can improve the effectiveness of other passes // such as DeadBranchElimination which depend on values for their analysis. Optimizer::PassToken CreateLocalSingleStoreElimPass(); // Creates an insert/extract elimination pass. // This pass processes each entry point function in the module, searching for // extracts on a sequence of inserts. It further searches the sequence for an // insert with indices identical to the extract. If such an insert can be // found before hitting a conflicting insert, the extract's result id is // replaced with the id of the values from the insert. // // Besides removing extracts this pass enables subsequent dead code elimination // passes to delete the inserts. This pass performs best after access chains are // converted to inserts and extracts and local loads and stores are eliminated. Optimizer::PassToken CreateInsertExtractElimPass(); // Creates a dead insert elimination pass. // This pass processes each entry point function in the module, searching for // unreferenced inserts into composite types. These are most often unused // stores to vector components. They are unused because they are never // referenced, or because there is another insert to the same component between // the insert and the reference. After removing the inserts, dead code // elimination is attempted on the inserted values. // // This pass performs best after access chains are converted to inserts and // extracts and local loads and stores are eliminated. While executing this // pass can be advantageous on its own, it is also advantageous to execute // this pass after CreateInsertExtractPass() as it will remove any unused // inserts created by that pass. Optimizer::PassToken CreateDeadInsertElimPass(); // Create aggressive dead code elimination pass // This pass eliminates unused code from the module. In addition, // it detects and eliminates code which may have spurious uses but which do // not contribute to the output of the function. The most common cause of // such code sequences is summations in loops whose result is no longer used // due to dead code elimination. This optimization has additional compile // time cost over standard dead code elimination. // // This pass only processes entry point functions. It also only processes // shaders with relaxed logical addressing (see opt/instruction.h). It // currently will not process functions with function calls. Unreachable // functions are deleted. // // This pass will be made more effective by first running passes that remove // dead control flow and inlines function calls. // // This pass can be especially useful after running Local Access Chain // Conversion, which tends to cause cycles of dead code to be left after // Store/Load elimination passes are completed. These cycles cannot be // eliminated with standard dead code elimination. // // If |preserve_interface| is true, all non-io variables in the entry point // interface are considered live and are not eliminated. This mode is needed // by GPU-Assisted validation instrumentation, where a change in the interface // is not allowed. // // If |remove_outputs| is true, allow outputs to be removed from the interface. // This is only safe if the caller knows that there is no corresponding input // variable in the following shader. It is false by default. Optimizer::PassToken CreateAggressiveDCEPass(); Optimizer::PassToken CreateAggressiveDCEPass(bool preserve_interface); Optimizer::PassToken CreateAggressiveDCEPass(bool preserve_interface, bool remove_outputs); // Creates a remove-unused-interface-variables pass. // Removes variables referenced on the |OpEntryPoint| instruction that are not // referenced in the entry point function or any function in its call tree. Note // that this could cause the shader interface to no longer match other shader // stages. Optimizer::PassToken CreateRemoveUnusedInterfaceVariablesPass(); // Creates an empty pass. // This is deprecated and will be removed. // TODO(jaebaek): remove this pass after handling glslang's broken unit tests. // https://github.com/KhronosGroup/glslang/pull/2440 Optimizer::PassToken CreatePropagateLineInfoPass(); // Creates an empty pass. // This is deprecated and will be removed. // TODO(jaebaek): remove this pass after handling glslang's broken unit tests. // https://github.com/KhronosGroup/glslang/pull/2440 Optimizer::PassToken CreateRedundantLineInfoElimPass(); // Creates a compact ids pass. // The pass remaps result ids to a compact and gapless range starting from %1. Optimizer::PassToken CreateCompactIdsPass(); // Creates a remove duplicate pass. // This pass removes various duplicates: // * duplicate capabilities; // * duplicate extended instruction imports; // * duplicate types; // * duplicate decorations. Optimizer::PassToken CreateRemoveDuplicatesPass(); // Creates a CFG cleanup pass. // This pass removes cruft from the control flow graph of functions that are // reachable from entry points and exported functions. It currently includes the // following functionality: // // - Removal of unreachable basic blocks. Optimizer::PassToken CreateCFGCleanupPass(); // Create dead variable elimination pass. // This pass will delete module scope variables, along with their decorations, // that are not referenced. Optimizer::PassToken CreateDeadVariableEliminationPass(); // create merge return pass. // changes functions that have multiple return statements so they have a single // return statement. // // for structured control flow it is assumed that the only unreachable blocks in // the function are trivial merge and continue blocks. // // a trivial merge block contains the label and an opunreachable instructions, // nothing else. a trivial continue block contain a label and an opbranch to // the header, nothing else. // // these conditions are guaranteed to be met after running dead-branch // elimination. Optimizer::PassToken CreateMergeReturnPass(); // Create value numbering pass. // This pass will look for instructions in the same basic block that compute the // same value, and remove the redundant ones. Optimizer::PassToken CreateLocalRedundancyEliminationPass(); // Create LICM pass. // This pass will look for invariant instructions inside loops and hoist them to // the loops preheader. Optimizer::PassToken CreateLoopInvariantCodeMotionPass(); // Creates a loop fission pass. // This pass will split all top level loops whose register pressure exceedes the // given |threshold|. Optimizer::PassToken CreateLoopFissionPass(size_t threshold); // Creates a loop fusion pass. // This pass will look for adjacent loops that are compatible and legal to be // fused. The fuse all such loops as long as the register usage for the fused // loop stays under the threshold defined by |max_registers_per_loop|. Optimizer::PassToken CreateLoopFusionPass(size_t max_registers_per_loop); // Creates a loop peeling pass. // This pass will look for conditions inside a loop that are true or false only // for the N first or last iteration. For loop with such condition, those N // iterations of the loop will be executed outside of the main loop. // To limit code size explosion, the loop peeling can only happen if the code // size growth for each loop is under |code_growth_threshold|. Optimizer::PassToken CreateLoopPeelingPass(); // Creates a loop unswitch pass. // This pass will look for loop independent branch conditions and move the // condition out of the loop and version the loop based on the taken branch. // Works best after LICM and local multi store elimination pass. Optimizer::PassToken CreateLoopUnswitchPass(); // Create global value numbering pass. // This pass will look for instructions where the same value is computed on all // paths leading to the instruction. Those instructions are deleted. Optimizer::PassToken CreateRedundancyEliminationPass(); // Create scalar replacement pass. // This pass replaces composite function scope variables with variables for each // element if those elements are accessed individually. The parameter is a // limit on the number of members in the composite variable that the pass will // consider replacing. Optimizer::PassToken CreateScalarReplacementPass(uint32_t size_limit = 100); // Create a private to local pass. // This pass looks for variables declared in the private storage class that are // used in only one function. Those variables are moved to the function storage // class in the function that they are used. Optimizer::PassToken CreatePrivateToLocalPass(); // Creates a conditional constant propagation (CCP) pass. // This pass implements the SSA-CCP algorithm in // // Constant propagation with conditional branches, // Wegman and Zadeck, ACM TOPLAS 13(2):181-210. // // Constant values in expressions and conditional jumps are folded and // simplified. This may reduce code size by removing never executed jump targets // and computations with constant operands. Optimizer::PassToken CreateCCPPass(); // Creates a workaround driver bugs pass. This pass attempts to work around // a known driver bug (issue #1209) by identifying the bad code sequences and // rewriting them. // // Current workaround: Avoid OpUnreachable instructions in loops. Optimizer::PassToken CreateWorkaround1209Pass(); // Creates a pass that converts if-then-else like assignments into OpSelect. Optimizer::PassToken CreateIfConversionPass(); // Creates a pass that will replace instructions that are not valid for the // current shader stage by constants. Has no effect on non-shader modules. Optimizer::PassToken CreateReplaceInvalidOpcodePass(); // Creates a pass that simplifies instructions using the instruction folder. Optimizer::PassToken CreateSimplificationPass(); // Create loop unroller pass. // Creates a pass to unroll loops which have the "Unroll" loop control // mask set. The loops must meet a specific criteria in order to be unrolled // safely this criteria is checked before doing the unroll by the // LoopUtils::CanPerformUnroll method. Any loop that does not meet the criteria // won't be unrolled. See CanPerformUnroll LoopUtils.h for more information. Optimizer::PassToken CreateLoopUnrollPass(bool fully_unroll, int factor = 0); // Create the SSA rewrite pass. // This pass converts load/store operations on function local variables into // operations on SSA IDs. This allows SSA optimizers to act on these variables. // Only variables that are local to the function and of supported types are // processed (see IsSSATargetVar for details). Optimizer::PassToken CreateSSARewritePass(); // Create pass to convert relaxed precision instructions to half precision. // This pass converts as many relaxed float32 arithmetic operations to half as // possible. It converts any float32 operands to half if needed. It converts // any resulting half precision values back to float32 as needed. No variables // are changed. No image operations are changed. // // Best if run after function scope store/load and composite operation // eliminations are run. Also best if followed by instruction simplification, // redundancy elimination and DCE. Optimizer::PassToken CreateConvertRelaxedToHalfPass(); // Create relax float ops pass. // This pass decorates all float32 result instructions with RelaxedPrecision // if not already so decorated. Optimizer::PassToken CreateRelaxFloatOpsPass(); // Create copy propagate arrays pass. // This pass looks to copy propagate memory references for arrays. It looks // for specific code patterns to recognize array copies. Optimizer::PassToken CreateCopyPropagateArraysPass(); // Create a vector dce pass. // This pass looks for components of vectors that are unused, and removes them // from the vector. Note this would still leave around lots of dead code that // a pass of ADCE will be able to remove. Optimizer::PassToken CreateVectorDCEPass(); // Create a pass to reduce the size of loads. // This pass looks for loads of structures where only a few of its members are // used. It replaces the loads feeding an OpExtract with an OpAccessChain and // a load of the specific elements. The parameter is a threshold to determine // whether we have to replace the load or not. If the ratio of the used // components of the load is less than the threshold, we replace the load. Optimizer::PassToken CreateReduceLoadSizePass( double load_replacement_threshold = 0.9); // Create a pass to combine chained access chains. // This pass looks for access chains fed by other access chains and combines // them into a single instruction where possible. Optimizer::PassToken CreateCombineAccessChainsPass(); // Create a pass to upgrade to the VulkanKHR memory model. // This pass upgrades the Logical GLSL450 memory model to Logical VulkanKHR. // Additionally, it modifies memory, image, atomic and barrier operations to // conform to that model's requirements. Optimizer::PassToken CreateUpgradeMemoryModelPass(); // Create a pass to do code sinking. Code sinking is a transformation // where an instruction is moved into a more deeply nested construct. Optimizer::PassToken CreateCodeSinkingPass(); // Create a pass to fix incorrect storage classes. In order to make code // generation simpler, DXC may generate code where the storage classes do not // match up correctly. This pass will fix the errors that it can. Optimizer::PassToken CreateFixStorageClassPass(); // Creates a graphics robust access pass. // // This pass injects code to clamp indexed accesses to buffers and internal // arrays, providing guarantees satisfying Vulkan's robustBufferAccess rules. // // TODO(dneto): Clamps coordinates and sample index for pointer calculations // into storage images (OpImageTexelPointer). For an cube array image, it // assumes the maximum layer count times 6 is at most 0xffffffff. // // NOTE: This pass will fail with a message if: // - The module is not a Shader module. // - The module declares VariablePointers, VariablePointersStorageBuffer, or // RuntimeDescriptorArrayEXT capabilities. // - The module uses an addressing model other than Logical // - Access chain indices are wider than 64 bits. // - Access chain index for a struct is not an OpConstant integer or is out // of range. (The module is already invalid if that is the case.) // - TODO(dneto): The OpImageTexelPointer coordinate component is not 32-bits // wide. // // NOTE: Access chain indices are always treated as signed integers. So // if an array has a fixed size of more than 2^31 elements, then elements // from 2^31 and above are never accessible with a 32-bit index, // signed or unsigned. For this case, this pass will clamp the index // between 0 and at 2^31-1, inclusive. // Similarly, if an array has more then 2^15 element and is accessed with // a 16-bit index, then elements from 2^15 and above are not accessible. // In this case, the pass will clamp the index between 0 and 2^15-1 // inclusive. Optimizer::PassToken CreateGraphicsRobustAccessPass(); // Create a pass to spread Volatile semantics to variables with SMIDNV, // WarpIDNV, SubgroupSize, SubgroupLocalInvocationId, SubgroupEqMask, // SubgroupGeMask, SubgroupGtMask, SubgroupLeMask, or SubgroupLtMask BuiltIn // decorations or OpLoad for them when the shader model is the ray generation, // closest hit, miss, intersection, or callable. This pass can be used for // VUID-StandaloneSpirv-VulkanMemoryModel-04678 and // VUID-StandaloneSpirv-VulkanMemoryModel-04679 (See "Standalone SPIR-V // Validation" section of Vulkan spec "Appendix A: Vulkan Environment for // SPIR-V"). When the SPIR-V version is 1.6 or above, the pass also spreads // the Volatile semantics to a variable with HelperInvocation BuiltIn decoration // in the fragement shader. Optimizer::PassToken CreateSpreadVolatileSemanticsPass(); // Create a pass to replace a descriptor access using variable index. // This pass replaces every access using a variable index to array variable // |desc| that has a DescriptorSet and Binding decorations with a constant // element of the array. In order to replace the access using a variable index // with the constant element, it uses a switch statement. Optimizer::PassToken CreateReplaceDescArrayAccessUsingVarIndexPass(); // Create descriptor scalar replacement pass. // This pass replaces every array variable |desc| that has a DescriptorSet and // Binding decorations with a new variable for each element of the // array/composite. Suppose |desc| was bound at binding |b|. Then the variable // corresponding to |desc[i]| will have binding |b+i|. The descriptor set will // be the same. It is assumed that no other variable already has a binding that // will used by one of the new variables. If not, the pass will generate // invalid Spir-V. All accesses to |desc| must be OpAccessChain instructions // with a literal index for the first index. This variant flattens both // composites and arrays. Optimizer::PassToken CreateDescriptorScalarReplacementPass(); // This variant flattens only composites. Optimizer::PassToken CreateDescriptorCompositeScalarReplacementPass(); // This variant flattens only arrays. Optimizer::PassToken CreateDescriptorArrayScalarReplacementPass(); // Create a pass to replace each OpKill instruction with a function call to a // function that has a single OpKill. Also replace each OpTerminateInvocation // instruction with a function call to a function that has a single // OpTerminateInvocation. This allows more code to be inlined. Optimizer::PassToken CreateWrapOpKillPass(); // Replaces the extensions VK_AMD_shader_ballot,VK_AMD_gcn_shader, and // VK_AMD_shader_trinary_minmax with equivalent code using core instructions and // capabilities. Optimizer::PassToken CreateAmdExtToKhrPass(); // Replaces the internal version of GLSLstd450 InterpolateAt* extended // instructions with the externally valid version. The internal version allows // an OpLoad of the interpolant for the first argument. This pass removes the // OpLoad and replaces it with its pointer. glslang and possibly other // frontends will create the internal version for HLSL. This pass will be part // of HLSL legalization and should be called after interpolants have been // propagated into their final positions. Optimizer::PassToken CreateInterpolateFixupPass(); // Replace OpExtInst instructions with OpExtInstWithForwardRefsKHR when // the instruction contains a forward reference to another debug instuction. // Replace OpExtInstWithForwardRefsKHR with OpExtInst when there are no forward // reference to another debug instruction. Optimizer::PassToken CreateOpExtInstWithForwardReferenceFixupPass(); // Removes unused components from composite input variables. Current // implementation just removes trailing unused components from input arrays // and structs. The pass performs best after maximizing dead code removal. // A subsequent dead code elimination pass would be beneficial in removing // newly unused component types. // // WARNING: This pass can only be safely applied standalone to vertex shaders // as it can otherwise cause interface incompatibilities with the preceding // shader in the pipeline. If applied to non-vertex shaders, the user should // follow by applying EliminateDeadOutputStores and // EliminateDeadOutputComponents to the preceding shader. Optimizer::PassToken CreateEliminateDeadInputComponentsPass(); // Removes unused components from composite output variables. Current // implementation just removes trailing unused components from output arrays // and structs. The pass performs best after eliminating dead output stores. // A subsequent dead code elimination pass would be beneficial in removing // newly unused component types. Currently only supports vertex and fragment // shaders. // // WARNING: This pass cannot be safely applied standalone as it can cause // interface incompatibility with the following shader in the pipeline. The // user should first apply EliminateDeadInputComponents to the following // shader, then apply EliminateDeadOutputStores to this shader. Optimizer::PassToken CreateEliminateDeadOutputComponentsPass(); // Removes unused components from composite input variables. This safe // version will not cause interface incompatibilities since it only changes // vertex shaders. The current implementation just removes trailing unused // components from input structs and input arrays. The pass performs best // after maximizing dead code removal. A subsequent dead code elimination // pass would be beneficial in removing newly unused component types. Optimizer::PassToken CreateEliminateDeadInputComponentsSafePass(); // Analyzes shader and populates |live_locs| and |live_builtins|. Best results // will be obtained if shader has all dead code eliminated first. |live_locs| // and |live_builtins| are subsequently used when calling // CreateEliminateDeadOutputStoresPass on the preceding shader. Currently only // supports tesc, tese, geom, and frag shaders. Optimizer::PassToken CreateAnalyzeLiveInputPass( std::unordered_set* live_locs, std::unordered_set* live_builtins); // Removes stores to output locations not listed in |live_locs| or // |live_builtins|. Best results are obtained if constant propagation is // performed first. A subsequent call to ADCE will eliminate any dead code // created by the removal of the stores. A subsequent call to // CreateEliminateDeadOutputComponentsPass will eliminate any dead output // components created by the elimination of the stores. Currently only supports // vert, tesc, tese, and geom shaders. Optimizer::PassToken CreateEliminateDeadOutputStoresPass( std::unordered_set* live_locs, std::unordered_set* live_builtins); // Creates a convert-to-sampled-image pass to convert images and/or // samplers with given pairs of descriptor set and binding to sampled image. // If a pair of an image and a sampler have the same pair of descriptor set and // binding that is one of the given pairs, they will be converted to a sampled // image. In addition, if only an image has the descriptor set and binding that // is one of the given pairs, it will be converted to a sampled image as well. Optimizer::PassToken CreateConvertToSampledImagePass( const std::vector& descriptor_set_binding_pairs); // Create an interface-variable-scalar-replacement pass that replaces array or // matrix interface variables with a series of scalar or vector interface // variables. For example, it replaces `float3 foo[2]` with `float3 foo0, foo1`. Optimizer::PassToken CreateInterfaceVariableScalarReplacementPass(); // Creates a remove-dont-inline pass to remove the |DontInline| function control // from every function in the module. This is useful if you want the inliner to // inline these functions some reason. Optimizer::PassToken CreateRemoveDontInlinePass(); // Create a fix-func-call-param pass to fix non memory argument for the function // call, as spirv-validation requires function parameters to be an memory // object, currently the pass would remove accesschain pointer argument passed // to the function Optimizer::PassToken CreateFixFuncCallArgumentsPass(); // Creates a trim-capabilities pass. // This pass removes unused capabilities for a given module, and if possible, // associated extensions. // See `trim_capabilities.h` for the list of supported capabilities. // // If the module contains unsupported capabilities, this pass will ignore them. // This should be fine in most cases, but could yield to incorrect results if // the unknown capability interacts with one of the trimmed capabilities. Optimizer::PassToken CreateTrimCapabilitiesPass(); // Creates a struct-packing pass. // This pass re-assigns all offset layout decorators to tightly pack // the struct with OpName matching `structToPack` according to the given packing // rule. Accepted packing rules are: std140, std140EnhancedLayout, std430, // std430EnhancedLayout, hlslCbuffer, hlslCbufferPackOffset, scalar, // scalarEnhancedLayout. Optimizer::PassToken CreateStructPackingPass(const char* structToPack, const char* packingRule); // Creates a switch-descriptorset pass. // This pass changes any DescriptorSet decorations with the value |ds_from| to // use the new value |ds_to|. Optimizer::PassToken CreateSwitchDescriptorSetPass(uint32_t ds_from, uint32_t ds_to); // Creates an invocation interlock placement pass. // This pass ensures that an entry point will have at most one // OpBeginInterlockInvocationEXT and one OpEndInterlockInvocationEXT, in that // order. Optimizer::PassToken CreateInvocationInterlockPlacementPass(); // Creates a pass to add/remove maximal reconvergence execution mode. // This pass either adds or removes maximal reconvergence from all entry points. Optimizer::PassToken CreateModifyMaximalReconvergencePass(bool add); } // namespace spvtools #endif // INCLUDE_SPIRV_TOOLS_OPTIMIZER_HPP_ KhronosGroup-SPIRV-Tools-f289d04/kokoro/000077500000000000000000000000001475742701700200355ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/kokoro/android/000077500000000000000000000000001475742701700214555ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/kokoro/android/build.sh000077500000000000000000000014321475742701700231130ustar00rootroot00000000000000#!/bin/bash # Copyright (c) 2018 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # Android Build Script. # Fail on any error. set -e # Display commands being run. set -x SCRIPT_DIR=`dirname "$BASH_SOURCE"` source $SCRIPT_DIR/../scripts/linux/build.sh ASAN clang cmake-android-ndk KhronosGroup-SPIRV-Tools-f289d04/kokoro/android/continuous.cfg000066400000000000000000000012331475742701700243430ustar00rootroot00000000000000# Copyright (c) 2018 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Continuous build configuration. # build_file: "SPIRV-Tools/kokoro/android/build.sh" KhronosGroup-SPIRV-Tools-f289d04/kokoro/android/presubmit.cfg000066400000000000000000000012301475742701700241440ustar00rootroot00000000000000# Copyright (c) 2018 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Presubmit build configuration. build_file: "SPIRV-Tools/kokoro/android/build.sh" KhronosGroup-SPIRV-Tools-f289d04/kokoro/check-format/000077500000000000000000000000001475742701700224005ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/kokoro/check-format/build-docker.sh000077500000000000000000000017251475742701700253100ustar00rootroot00000000000000#!/bin/bash # Copyright (c) 2025 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Fail on any error. set -e # This is required to run any git command in the docker since owner will # have changed between the clone environment, and the docker container. # Marking the root of the repo as safe for ownership changes. git config --global --add safe.directory "$PWD" echo $(date): Check formatting... ./utils/check_code_format.sh ${1:-main} echo $(date): check completed. KhronosGroup-SPIRV-Tools-f289d04/kokoro/check-format/build.sh000077500000000000000000000020371475742701700240400ustar00rootroot00000000000000#!/bin/bash # Copyright (c) 2025 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Fail on any error. set -e SCRIPT_DIR="$( cd "$(dirname "${BASH_SOURCE[0]}")" >/dev/null 2>&1 && pwd )" SRC_ROOT="$( cd "${SCRIPT_DIR}/../.." >/dev/null 2>&1 && pwd )" TARGET_BRANCH="${KOKORO_GITHUB_PULL_REQUEST_TARGET_BRANCH-main}" docker run --rm -i \ --volume "${SRC_ROOT}:${SRC_ROOT}" \ --workdir "${SRC_ROOT}" \ "us-east4-docker.pkg.dev/shaderc-build/radial-docker/ubuntu-24.04-amd64/formatter" \ "${SCRIPT_DIR}/build-docker.sh" "${TARGET_BRANCH}" KhronosGroup-SPIRV-Tools-f289d04/kokoro/check-format/presubmit_check_format.cfg000066400000000000000000000012351475742701700276010ustar00rootroot00000000000000# Copyright (c) 2018 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Presubmit build configuration. build_file: "SPIRV-Tools/kokoro/check-format/build.sh" KhronosGroup-SPIRV-Tools-f289d04/kokoro/img/000077500000000000000000000000001475742701700206115ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/kokoro/img/linux.png000066400000000000000000000417311475742701700224640ustar00rootroot00000000000000PNG  IHDR((&p pHYsOOiCCPPhotoshop ICC profilexc``$PPTR~!11 !/?/020|pYɕ4\PTp(%8 CzyIA c HRvA cHvH3c OIjE s~AeQfzFcJ~RBpeqIjng^r~QA~QbIj ^<#U*( >1H.-*%CC"C= o]KW0cc btY9y!K[z,٦}cg͡3#nM4}2?~ 4] Adobe Photoshop CC 2015 (Macintosh) 2017-07-04T18:08:25+01:00 2017-07-26T11:13:36+01:00 2017-07-26T11:13:36+01:00 image/png 1 Dot Gain 20% xmp.did:5e07c219-b13c-49e1-89a1-2f470b0e8652 xmp.iid:c6b4a0d2-b4b7-4548-9677-f39048023763 xmp.did:6e0a7f0a-5b0a-4e50-aa20-2ef167f27825 xmp.did:6e0a7f0a-5b0a-4e50-aa20-2ef167f27825 created xmp.iid:6e0a7f0a-5b0a-4e50-aa20-2ef167f27825 2017-07-04T18:08:25+01:00 Adobe Photoshop CC 2015 (Macintosh) saved xmp.iid:5278a0f8-50ec-4bcc-9e99-fdd09ae1297c 2017-07-26T11:05:16+01:00 Adobe Photoshop CC 2015 (Macintosh) / saved xmp.iid:c6b4a0d2-b4b7-4548-9677-f39048023763 2017-07-26T11:13:36+01:00 Adobe Photoshop CC 2015 (Macintosh) / 1 9838690/10000 9838690/10000 2 65535 40 40 5\ cHRMz%u0`:o_FIDATxڜ_hWe_ HڼXd(D0>Xaij6ex!.4袅"% FNK:Fd,]\9v߯x/8>}89999cSh, r/#'Jg-J<2ݙ&,3!x!] e-f(b7n~8+BZl1Lt{&Zn 60& c=8W+NJBOe/C'8k8sݯk|R3g L^0J {1? *F09nDbMR9.G/[GVÕ,*E+QW=Ahov !VQ DZLF 05.O((="3d\4SrDcf:3~RT"ě2m]hEY=+ !=zc &уXð8I5aɴ"Zq<Ӽt.j7|a+H{vIi|t! 8gsLK3ᔃ![;nr!0O)%v]Qv!dX|VRAc٫t!@=NbOPq1q*V" Adobe Photoshop CC 2015 (Macintosh) 2017-07-04T18:08:25+01:00 2017-07-26T10:59:30+01:00 2017-07-26T10:59:30+01:00 image/png 1 xmp.iid:3d9436ac-531d-42f7-a30f-bdd335e371c2 xmp.did:3d9436ac-531d-42f7-a30f-bdd335e371c2 xmp.did:3d9436ac-531d-42f7-a30f-bdd335e371c2 created xmp.iid:3d9436ac-531d-42f7-a30f-bdd335e371c2 2017-07-04T18:08:25+01:00 Adobe Photoshop CC 2015 (Macintosh) 1 720000/10000 720000/10000 2 65535 40 40 p^[ cHRMz%u0`:o_FIDATxڔ[lU_,@Mצ 1Z((TH@`"!!]+X5V $imDRQh*P6t=>)ɹwF&XOR$&@/s u x\b'PSMFHuj3&N=h4N6x`zQ wdžUox ײٖ{@"nџ'ag_RA ƒ dRzE${L*tgjtIÿ e5lY~vhP%[1Ԥ  OT0FID}OhIIC_>=t31Gq[qI\Т"1r2qW wd fNd2v(s[ȥYjjoѵFb4rrIcL8^qrD$PB$l*C,)ZKR^ ڥ*̥`MantAha+75MLtB3p}4vnF"A#Ck&I*1߼gm02S4Jl9Ǚ t|b/?4cME)6s/[f&b,:#,!;Oa=|O$(QD Adobe Photoshop CC 2015 (Macintosh) 2017-07-04T18:08:25+01:00 2017-07-26T11:12:29+01:00 2017-07-26T11:12:29+01:00 image/png 1 xmp.iid:e81e6346-410e-40a0-82be-cca3dccb8a09 adobe:docid:photoshop:e56f1d8a-b278-117a-846f-8e0976eeb308 xmp.did:6de15b69-3c6e-46d6-a65f-7110ebc9ae57 created xmp.iid:6de15b69-3c6e-46d6-a65f-7110ebc9ae57 2017-07-04T18:08:25+01:00 Adobe Photoshop CC 2015 (Macintosh) saved xmp.iid:6f99ad6c-1395-4c8a-ab40-6aef1302cffc 2017-07-26T11:09:22+01:00 Adobe Photoshop CC 2015 (Macintosh) / saved xmp.iid:e81e6346-410e-40a0-82be-cca3dccb8a09 2017-07-26T11:12:29+01:00 Adobe Photoshop CC 2015 (Macintosh) / 1 720000/10000 720000/10000 2 65535 40 40 v6 cHRMz%u0`:o_FIDATxڔoTU;N;[h[tZ1IDBѸ1aŊƍ%. pe\LL;#BO#H~ǝw9.ig1wΙ>>sQ@ Q%Das9y*Sr(S !v]In(-ݘnۘ!S2IJµ" >Dl+ۼwf1k'J0\wH"1Hy4$pYQlV-Ox8@u/D^ Msr^dl3 ^4v{#ړyץ2< fey,_%C|~(&S2,1'7n6ܬEg)TvNѩk"fV ?A/F女?G^oI 4P[zAsGrJ]h Eaݰ͏[2<#_,)eU?0v'p+*J^VgFdhSFՙ;&30$tdQVvYcjdWX vzdx2S\,׮+ԻKP}?f΂w`ikʔB[#۰kʶRuZ&kxDd$D0ss3+;{VDҽE#vi-پz GXW_ yҔh'9 eɡmuBMr_=zl͙R\De٦{iRgXcsGOpX=7pVһPS{S ')S wcFLWJ)(֧+DNuIENDB`KhronosGroup-SPIRV-Tools-f289d04/kokoro/linux-clang-asan/000077500000000000000000000000001475742701700231765ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/kokoro/linux-clang-asan/build.sh000077500000000000000000000014141475742701700246340ustar00rootroot00000000000000#!/bin/bash # Copyright (c) 2019 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # Linux Build Script. # Fail on any error. set -e # Display commands being run. set -x SCRIPT_DIR=`dirname "$BASH_SOURCE"` source $SCRIPT_DIR/../scripts/linux/build.sh ASAN clang cmake KhronosGroup-SPIRV-Tools-f289d04/kokoro/linux-clang-asan/continuous.cfg000066400000000000000000000012421475742701700260640ustar00rootroot00000000000000# Copyright (c) 2019 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Continuous build configuration. build_file: "SPIRV-Tools/kokoro/linux-clang-asan/build.sh" KhronosGroup-SPIRV-Tools-f289d04/kokoro/linux-clang-asan/presubmit.cfg000066400000000000000000000012411475742701700256670ustar00rootroot00000000000000# Copyright (c) 2019 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Presubmit build configuration. build_file: "SPIRV-Tools/kokoro/linux-clang-asan/build.sh" KhronosGroup-SPIRV-Tools-f289d04/kokoro/linux-clang-debug/000077500000000000000000000000001475742701700233425ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/kokoro/linux-clang-debug/build.sh000077500000000000000000000014151475742701700250010ustar00rootroot00000000000000#!/bin/bash # Copyright (c) 2018 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # Linux Build Script. # Fail on any error. set -e # Display commands being run. set -x SCRIPT_DIR=`dirname "$BASH_SOURCE"` source $SCRIPT_DIR/../scripts/linux/build.sh DEBUG clang cmake KhronosGroup-SPIRV-Tools-f289d04/kokoro/linux-clang-debug/continuous.cfg000066400000000000000000000013411475742701700262300ustar00rootroot00000000000000# Copyright (c) 2018 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Continuous build configuration. build_file: "SPIRV-Tools/kokoro/linux-clang-debug/build.sh" action { define_artifacts { regex: "install.tgz" } } KhronosGroup-SPIRV-Tools-f289d04/kokoro/linux-clang-debug/presubmit.cfg000066400000000000000000000012421475742701700260340ustar00rootroot00000000000000# Copyright (c) 2018 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Presubmit build configuration. build_file: "SPIRV-Tools/kokoro/linux-clang-debug/build.sh" KhronosGroup-SPIRV-Tools-f289d04/kokoro/linux-clang-release-bazel/000077500000000000000000000000001475742701700247675ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/kokoro/linux-clang-release-bazel/build.sh000077500000000000000000000014171475742701700264300ustar00rootroot00000000000000#!/bin/bash # Copyright (c) 2019 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # Linux Build Script. # Fail on any error. set -e # Display commands being run. set -x SCRIPT_DIR=`dirname "$BASH_SOURCE"` source $SCRIPT_DIR/../scripts/linux/build.sh RELEASE clang bazel KhronosGroup-SPIRV-Tools-f289d04/kokoro/linux-clang-release-bazel/continuous.cfg000066400000000000000000000012531475742701700276570ustar00rootroot00000000000000# Copyright (c) 2019 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Continuous build configuration. build_file: "SPIRV-Tools/kokoro/linux-clang-release-bazel/build.sh" KhronosGroup-SPIRV-Tools-f289d04/kokoro/linux-clang-release-bazel/presubmit.cfg000066400000000000000000000012521475742701700274620ustar00rootroot00000000000000# Copyright (c) 2019 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Presubmit build configuration. build_file: "SPIRV-Tools/kokoro/linux-clang-release-bazel/build.sh" KhronosGroup-SPIRV-Tools-f289d04/kokoro/linux-clang-release/000077500000000000000000000000001475742701700236745ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/kokoro/linux-clang-release/build.sh000077500000000000000000000014171475742701700253350ustar00rootroot00000000000000#!/bin/bash # Copyright (c) 2018 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # Linux Build Script. # Fail on any error. set -e # Display commands being run. set -x SCRIPT_DIR=`dirname "$BASH_SOURCE"` source $SCRIPT_DIR/../scripts/linux/build.sh RELEASE clang cmake KhronosGroup-SPIRV-Tools-f289d04/kokoro/linux-clang-release/continuous.cfg000066400000000000000000000013431475742701700265640ustar00rootroot00000000000000# Copyright (c) 2018 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Continuous build configuration. build_file: "SPIRV-Tools/kokoro/linux-clang-release/build.sh" action { define_artifacts { regex: "install.tgz" } } KhronosGroup-SPIRV-Tools-f289d04/kokoro/linux-clang-release/presubmit.cfg000066400000000000000000000012441475742701700263700ustar00rootroot00000000000000# Copyright (c) 2018 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Presubmit build configuration. build_file: "SPIRV-Tools/kokoro/linux-clang-release/build.sh" KhronosGroup-SPIRV-Tools-f289d04/kokoro/linux-clang-ubsan/000077500000000000000000000000001475742701700233645ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/kokoro/linux-clang-ubsan/build.sh000077500000000000000000000014151475742701700250230ustar00rootroot00000000000000#!/bin/bash # Copyright (c) 2021 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # Linux Build Script. # Fail on any error. set -e # Display commands being run. set -x SCRIPT_DIR=`dirname "$BASH_SOURCE"` source $SCRIPT_DIR/../scripts/linux/build.sh UBSAN clang cmake KhronosGroup-SPIRV-Tools-f289d04/kokoro/linux-clang-ubsan/continuous.cfg000066400000000000000000000012431475742701700262530ustar00rootroot00000000000000# Copyright (c) 2021 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Continuous build configuration. build_file: "SPIRV-Tools/kokoro/linux-clang-ubsan/build.sh" KhronosGroup-SPIRV-Tools-f289d04/kokoro/linux-clang-ubsan/presubmit.cfg000066400000000000000000000012421475742701700260560ustar00rootroot00000000000000# Copyright (c) 2021 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Presubmit build configuration. build_file: "SPIRV-Tools/kokoro/linux-clang-ubsan/build.sh" KhronosGroup-SPIRV-Tools-f289d04/kokoro/linux-gcc-debug/000077500000000000000000000000001475742701700230125ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/kokoro/linux-gcc-debug/build.sh000077500000000000000000000014131475742701700244470ustar00rootroot00000000000000#!/bin/bash # Copyright (c) 2018 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # Linux Build Script. # Fail on any error. set -e # Display commands being run. set -x SCRIPT_DIR=`dirname "$BASH_SOURCE"` source $SCRIPT_DIR/../scripts/linux/build.sh DEBUG gcc cmake KhronosGroup-SPIRV-Tools-f289d04/kokoro/linux-gcc-debug/continuous.cfg000066400000000000000000000013371475742701700257050ustar00rootroot00000000000000# Copyright (c) 2018 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Continuous build configuration. build_file: "SPIRV-Tools/kokoro/linux-gcc-debug/build.sh" action { define_artifacts { regex: "install.tgz" } } KhronosGroup-SPIRV-Tools-f289d04/kokoro/linux-gcc-debug/presubmit.cfg000066400000000000000000000012411475742701700255030ustar00rootroot00000000000000# Copyright (c) 2018 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Presubmit build configuration. build_file: "SPIRV-Tools/kokoro/linux-gcc-debug/build.sh" KhronosGroup-SPIRV-Tools-f289d04/kokoro/linux-gcc-release/000077500000000000000000000000001475742701700233445ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/kokoro/linux-gcc-release/build.sh000077500000000000000000000014151475742701700250030ustar00rootroot00000000000000#!/bin/bash # Copyright (c) 2018 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # Linux Build Script. # Fail on any error. set -e # Display commands being run. set -x SCRIPT_DIR=`dirname "$BASH_SOURCE"` source $SCRIPT_DIR/../scripts/linux/build.sh RELEASE gcc cmake KhronosGroup-SPIRV-Tools-f289d04/kokoro/linux-gcc-release/continuous.cfg000066400000000000000000000013411475742701700262320ustar00rootroot00000000000000# Copyright (c) 2018 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Continuous build configuration. build_file: "SPIRV-Tools/kokoro/linux-gcc-release/build.sh" action { define_artifacts { regex: "install.tgz" } } KhronosGroup-SPIRV-Tools-f289d04/kokoro/linux-gcc-release/presubmit.cfg000066400000000000000000000012421475742701700260360ustar00rootroot00000000000000# Copyright (c) 2018 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Presubmit build configuration. build_file: "SPIRV-Tools/kokoro/linux-gcc-release/build.sh" KhronosGroup-SPIRV-Tools-f289d04/kokoro/macos-clang-debug/000077500000000000000000000000001475742701700233055ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/kokoro/macos-clang-debug/build.sh000066400000000000000000000014011475742701700247340ustar00rootroot00000000000000#!/bin/bash # Copyright (c) 2018 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # MacOS Build Script. # Fail on any error. set -e # Display commands being run. set -x SCRIPT_DIR=`dirname "$BASH_SOURCE"` source $SCRIPT_DIR/../scripts/macos/build.sh Debug KhronosGroup-SPIRV-Tools-f289d04/kokoro/macos-clang-debug/continuous.cfg000066400000000000000000000013411475742701700261730ustar00rootroot00000000000000# Copyright (c) 2018 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Continuous build configuration. build_file: "SPIRV-Tools/kokoro/macos-clang-debug/build.sh" action { define_artifacts { regex: "install.tgz" } } KhronosGroup-SPIRV-Tools-f289d04/kokoro/macos-clang-debug/presubmit.cfg000066400000000000000000000012421475742701700257770ustar00rootroot00000000000000# Copyright (c) 2018 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Presubmit build configuration. build_file: "SPIRV-Tools/kokoro/macos-clang-debug/build.sh" KhronosGroup-SPIRV-Tools-f289d04/kokoro/macos-clang-release-bazel/000077500000000000000000000000001475742701700247325ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/kokoro/macos-clang-release-bazel/build.sh000066400000000000000000000026101475742701700263640ustar00rootroot00000000000000#!/bin/bash # Copyright (c) 2019 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # Linux Build Script. # Fail on any error. set -e # Display commands being run. set -x CC=clang CXX=clang++ SRC=$PWD/github/SPIRV-Tools # This is required to run any git command in the docker since owner will # have changed between the clone environment, and the docker container. # Marking the root of the repo as safe for ownership changes. git config --global --add safe.directory $SRC cd $SRC /usr/bin/python3 utils/git-sync-deps --treeless # Get bazel 7.0.2 gsutil cp gs://bazel/7.0.2/release/bazel-7.0.2-darwin-x86_64 . chmod +x bazel-7.0.2-darwin-x86_64 echo $(date): Build everything... ./bazel-7.0.2-darwin-x86_64 build --cxxopt=-std=c++17 :all echo $(date): Build completed. echo $(date): Starting bazel test... ./bazel-7.0.2-darwin-x86_64 test --cxxopt=-std=c++17 :all echo $(date): Bazel test completed. KhronosGroup-SPIRV-Tools-f289d04/kokoro/macos-clang-release-bazel/continuous.cfg000066400000000000000000000012531475742701700276220ustar00rootroot00000000000000# Copyright (c) 2019 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Continuous build configuration. build_file: "SPIRV-Tools/kokoro/macos-clang-release-bazel/build.sh" KhronosGroup-SPIRV-Tools-f289d04/kokoro/macos-clang-release-bazel/presubmit.cfg000066400000000000000000000012521475742701700274250ustar00rootroot00000000000000# Copyright (c) 2019 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Presubmit build configuration. build_file: "SPIRV-Tools/kokoro/macos-clang-release-bazel/build.sh" KhronosGroup-SPIRV-Tools-f289d04/kokoro/macos-clang-release/000077500000000000000000000000001475742701700236375ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/kokoro/macos-clang-release/build.sh000066400000000000000000000014121475742701700252700ustar00rootroot00000000000000#!/bin/bash # Copyright (c) 2018 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # MacOS Build Script. # Fail on any error. set -e # Display commands being run. set -x SCRIPT_DIR=`dirname "$BASH_SOURCE"` source $SCRIPT_DIR/../scripts/macos/build.sh RelWithDebInfo KhronosGroup-SPIRV-Tools-f289d04/kokoro/macos-clang-release/continuous.cfg000066400000000000000000000013431475742701700265270ustar00rootroot00000000000000# Copyright (c) 2018 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Continuous build configuration. build_file: "SPIRV-Tools/kokoro/macos-clang-release/build.sh" action { define_artifacts { regex: "install.tgz" } } KhronosGroup-SPIRV-Tools-f289d04/kokoro/macos-clang-release/presubmit.cfg000066400000000000000000000012441475742701700263330ustar00rootroot00000000000000# Copyright (c) 2018 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Presubmit build configuration. build_file: "SPIRV-Tools/kokoro/macos-clang-release/build.sh" KhronosGroup-SPIRV-Tools-f289d04/kokoro/ndk-build/000077500000000000000000000000001475742701700217065ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/kokoro/ndk-build/build.sh000077500000000000000000000014301475742701700233420ustar00rootroot00000000000000#!/bin/bash # Copyright (c) 2018 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # Linux Build Script. # Fail on any error. set -e # Display commands being run. set -x SCRIPT_DIR=`dirname "$BASH_SOURCE"` source $SCRIPT_DIR/../scripts/linux/build.sh ASAN clang android-ndk-build KhronosGroup-SPIRV-Tools-f289d04/kokoro/ndk-build/continuous.cfg000066400000000000000000000012351475742701700245760ustar00rootroot00000000000000# Copyright (c) 2018 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Continuous build configuration. # build_file: "SPIRV-Tools/kokoro/ndk-build/build.sh" KhronosGroup-SPIRV-Tools-f289d04/kokoro/ndk-build/presubmit.cfg000066400000000000000000000012321475742701700243770ustar00rootroot00000000000000# Copyright (c) 2018 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Presubmit build configuration. build_file: "SPIRV-Tools/kokoro/ndk-build/build.sh" KhronosGroup-SPIRV-Tools-f289d04/kokoro/scripts/000077500000000000000000000000001475742701700215245ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/kokoro/scripts/linux/000077500000000000000000000000001475742701700226635ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/kokoro/scripts/linux/build-docker.sh000077500000000000000000000142531475742701700255730ustar00rootroot00000000000000#!/bin/bash # Copyright (c) 2018 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # Linux Build Script. # Fail on any error. set -e # Display commands being run. set -x # This is required to run any git command in the docker since owner will # have changed between the clone environment, and the docker container. # Marking the root of the repo as safe for ownership changes. git config --global --add safe.directory $ROOT_DIR . /bin/using.sh # Declare the bash `using` function for configuring toolchains. using python-3.12 if [ $COMPILER = "clang" ]; then using clang-13.0.1 elif [ $COMPILER = "gcc" ]; then using gcc-13 fi cd $ROOT_DIR function clean_dir() { dir=$1 if [[ -d "$dir" ]]; then rm -fr "$dir" fi mkdir "$dir" } if [ $TOOL != "cmake-smoketest" ]; then # Get source for dependencies, as specified in the DEPS file /usr/bin/python3 utils/git-sync-deps --treeless fi if [ $TOOL = "cmake" ]; then using cmake-3.31.2 using ninja-1.10.0 # Possible configurations are: # ASAN, UBSAN, COVERAGE, RELEASE, DEBUG, DEBUG_EXCEPTION, RELEASE_MINGW BUILD_TYPE="Debug" if [ $CONFIG = "RELEASE" ] || [ $CONFIG = "RELEASE_MINGW" ]; then BUILD_TYPE="RelWithDebInfo" fi SKIP_TESTS="False" ADDITIONAL_CMAKE_FLAGS="" if [ $CONFIG = "ASAN" ]; then ADDITIONAL_CMAKE_FLAGS="-DSPIRV_USE_SANITIZER=address,bounds,null" [ $COMPILER = "clang" ] || { echo "$CONFIG requires clang"; exit 1; } elif [ $CONFIG = "UBSAN" ]; then # UBSan requires RTTI, and by default UBSan does not exit when errors are # encountered - additional compiler options are required to force this. # The -DSPIRV_USE_SANITIZER=undefined option instructs SPIR-V Tools to be # built with UBSan enabled. ADDITIONAL_CMAKE_FLAGS="-DSPIRV_USE_SANITIZER=undefined -DENABLE_RTTI=ON -DCMAKE_C_FLAGS=-fno-sanitize-recover=all -DCMAKE_CXX_FLAGS=-fno-sanitize-recover=all" [ $COMPILER = "clang" ] || { echo "$CONFIG requires clang"; exit 1; } elif [ $CONFIG = "COVERAGE" ]; then ADDITIONAL_CMAKE_FLAGS="-DENABLE_CODE_COVERAGE=ON" SKIP_TESTS="True" elif [ $CONFIG = "DEBUG_EXCEPTION" ]; then ADDITIONAL_CMAKE_FLAGS="-DDISABLE_EXCEPTIONS=ON -DDISABLE_RTTI=ON" elif [ $CONFIG = "RELEASE_MINGW" ]; then ADDITIONAL_CMAKE_FLAGS="-Dgtest_disable_pthreads=ON -DCMAKE_TOOLCHAIN_FILE=$SRC/cmake/linux-mingw-toolchain.cmake" SKIP_TESTS="True" fi if [ $COMPILER = "clang" ]; then ADDITIONAL_CMAKE_FLAGS="$ADDITIONAL_CMAKE_FLAGS -DSPIRV_BUILD_LIBFUZZER_TARGETS=ON" fi clean_dir "$ROOT_DIR/build" cd "$ROOT_DIR/build" # Invoke the build. BUILD_SHA=${KOKORO_GITHUB_COMMIT:-$KOKORO_GITHUB_PULL_REQUEST_COMMIT} echo $(date): Starting build... cmake -DPYTHON_EXECUTABLE:FILEPATH=/usr/bin/python3 -GNinja -DCMAKE_INSTALL_PREFIX=$KOKORO_ARTIFACTS_DIR/install -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DRE2_BUILD_TESTING=OFF -DSPIRV_BUILD_FUZZER=ON $ADDITIONAL_CMAKE_FLAGS .. echo $(date): Build everything... ninja echo $(date): Build completed. if [ $CONFIG = "COVERAGE" ]; then echo $(date): Check coverage... ninja report-coverage echo $(date): Check coverage completed. fi echo $(date): Starting ctest... if [ $SKIP_TESTS = "False" ]; then ctest -j4 --output-on-failure --timeout 300 fi echo $(date): ctest completed. # Package the build. ninja install cd $KOKORO_ARTIFACTS_DIR tar czf install.tgz install elif [ $TOOL = "cmake-smoketest" ]; then using cmake-3.31.2 using ninja-1.10.0 # Get shaderc. SHADERC_DIR=/tmp/shaderc clean_dir "$SHADERC_DIR" cd $SHADERC_DIR git clone https://github.com/google/shaderc.git . cd $SHADERC_DIR/third_party # Get shaderc dependencies. Link the appropriate SPIRV-Tools. git clone https://github.com/google/googletest.git git clone https://github.com/KhronosGroup/glslang.git ln -s $ROOT_DIR spirv-tools git clone https://github.com/KhronosGroup/SPIRV-Headers.git spirv-headers git clone https://github.com/google/re2 git clone https://github.com/google/effcee git clone https://github.com/abseil/abseil-cpp abseil_cpp cd $SHADERC_DIR mkdir build cd $SHADERC_DIR/build # Invoke the build. echo $(date): Starting build... cmake -GNinja -DRE2_BUILD_TESTING=OFF -DCMAKE_BUILD_TYPE="Release" .. echo $(date): Build glslang... ninja glslang-standalone echo $(date): Build everything... ninja echo $(date): Build completed. echo $(date): Check Shaderc for copyright notices... ninja check-copyright echo $(date): Starting ctest... ctest --output-on-failure -j4 echo $(date): ctest completed. elif [ $TOOL = "cmake-android-ndk" ]; then using cmake-3.31.2 using ndk-r27c using ninja-1.10.0 clean_dir "$ROOT_DIR/build" cd "$ROOT_DIR/build" echo $(date): Starting build... cmake -DCMAKE_BUILD_TYPE=Release \ -DANDROID_NATIVE_API_LEVEL=android-24 \ -DANDROID_ABI="armeabi-v7a with NEON" \ -DSPIRV_SKIP_TESTS=ON \ -DCMAKE_TOOLCHAIN_FILE="$ANDROID_NDK_HOME/build/cmake/android.toolchain.cmake" \ -GNinja \ -DANDROID_NDK=$ANDROID_NDK \ .. echo $(date): Build everything... ninja echo $(date): Build completed. elif [ $TOOL = "android-ndk-build" ]; then using ndk-r27c clean_dir "$ROOT_DIR/build" cd "$ROOT_DIR/build" echo $(date): Starting ndk-build ... $ANDROID_NDK_HOME/ndk-build \ -C $ROOT_DIR/android_test \ NDK_PROJECT_PATH=. \ NDK_LIBS_OUT=./libs \ NDK_APP_OUT=./app \ -j4 echo $(date): ndk-build completed. elif [ $TOOL = "bazel" ]; then using bazel-7.0.2 echo $(date): Build everything... bazel build --cxxopt=-std=c++17 :all echo $(date): Build completed. echo $(date): Starting bazel test... bazel test --cxxopt=-std=c++17 :all echo $(date): Bazel test completed. fi KhronosGroup-SPIRV-Tools-f289d04/kokoro/scripts/linux/build.sh000066400000000000000000000037711475742701700243260ustar00rootroot00000000000000#!/bin/bash # Copyright (c) 2021 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # Linux Build Script. # Fail on any error. set -e SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}")" >/dev/null 2>&1 && pwd )" ROOT_DIR="$( cd "${SCRIPT_DIR}/../../.." >/dev/null 2>&1 && pwd )" CONFIG=$1 COMPILER=$2 TOOL=$3 BUILD_SHA=${KOKORO_GITHUB_COMMIT:-$KOKORO_GITHUB_PULL_REQUEST_COMMIT} # chown the given directory to the current user, if it exists. # Docker creates files with the root user - this can upset the Kokoro artifact copier. function chown_dir() { dir=$1 if [[ -d "$dir" ]]; then sudo chown -R "$(id -u):$(id -g)" "$dir" fi } set +e # Allow build failures # "--privileged" is required to run ptrace in the asan builds. docker run --rm -i \ --privileged \ --volume "${ROOT_DIR}:${ROOT_DIR}" \ --volume "${KOKORO_ARTIFACTS_DIR}:${KOKORO_ARTIFACTS_DIR}" \ --workdir "${ROOT_DIR}" \ --env SCRIPT_DIR=${SCRIPT_DIR} \ --env ROOT_DIR=${ROOT_DIR} \ --env CONFIG=${CONFIG} \ --env COMPILER=${COMPILER} \ --env TOOL=${TOOL} \ --env KOKORO_ARTIFACTS_DIR="${KOKORO_ARTIFACTS_DIR}" \ --env BUILD_SHA="${BUILD_SHA}" \ --entrypoint "${SCRIPT_DIR}/build-docker.sh" \ us-east4-docker.pkg.dev/shaderc-build/radial-docker/ubuntu-24.04-amd64/cpp-builder RESULT=$? # This is important. If the permissions are not fixed, kokoro will fail # to pull build artifacts, and put the build in tool-failure state, which # blocks the logs. chown_dir "${ROOT_DIR}/build" chown_dir "${ROOT_DIR}/external" exit $RESULT KhronosGroup-SPIRV-Tools-f289d04/kokoro/scripts/macos/000077500000000000000000000000001475742701700226265ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/kokoro/scripts/macos/build.sh000066400000000000000000000034511475742701700242640ustar00rootroot00000000000000#!/bin/bash # Copyright (c) 2018 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # MacOS Build Script. # Fail on any error. set -e # Display commands being run. set -x BUILD_ROOT=$PWD SRC=$PWD/github/SPIRV-Tools BUILD_TYPE=$1 # This is required to run any git command in the docker since owner will # have changed between the clone environment, and the docker container. # Marking the root of the repo as safe for ownership changes. git config --global --add safe.directory $SRC # Get NINJA. wget -q https://github.com/ninja-build/ninja/releases/download/v1.8.2/ninja-mac.zip unzip -q ninja-mac.zip chmod +x ninja export PATH="$PWD:$PATH" cd $SRC python3 utils/git-sync-deps --treeless mkdir build && cd $SRC/build # Invoke the build. BUILD_SHA=${KOKORO_GITHUB_COMMIT:-$KOKORO_GITHUB_PULL_REQUEST_COMMIT} echo $(date): Starting build... cmake \ -GNinja \ -DCMAKE_INSTALL_PREFIX=$KOKORO_ARTIFACTS_DIR/install \ -DCMAKE_C_COMPILER=clang \ -DCMAKE_CXX_COMPILER=clang++ \ -DCMAKE_BUILD_TYPE=$BUILD_TYPE \ -DSPIRV_BUILD_FUZZER=ON \ .. echo $(date): Build everything... ninja echo $(date): Build completed. echo $(date): Starting ctest... ctest -j4 --output-on-failure --timeout 300 echo $(date): ctest completed. # Package the build. ninja install cd $KOKORO_ARTIFACTS_DIR tar czf install.tgz install KhronosGroup-SPIRV-Tools-f289d04/kokoro/scripts/windows/000077500000000000000000000000001475742701700232165ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/kokoro/scripts/windows/build.bat000066400000000000000000000055461475742701700250170ustar00rootroot00000000000000:: Copyright (c) 2018 Google LLC. :: :: Licensed under the Apache License, Version 2.0 (the "License"); :: you may not use this file except in compliance with the License. :: You may obtain a copy of the License at :: :: http://www.apache.org/licenses/LICENSE-2.0 :: :: Unless required by applicable law or agreed to in writing, software :: distributed under the License is distributed on an "AS IS" BASIS, :: WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. :: See the License for the specific language governing permissions and :: limitations under the License. :: :: Windows Build Script. @echo on set BUILD_ROOT=%cd% set SRC=%cd%\github\SPIRV-Tools set BUILD_TYPE=%1 set VS_VERSION=%2 :: Force usage of python 3.12, cmake 3.31.2 set PATH=C:\python312;c:\cmake-3.31.2\bin;%PATH% :: ######################################### :: set up msvc build env :: ######################################### if %VS_VERSION% == 2019 ( call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\Build\vcvarsall.bat" x64 echo "Using VS 2019..." ) else if %VS_VERSION% == 2022 ( call "C:\Program Files\Microsoft Visual Studio\2022\Professional\VC\Auxiliary\Build\vcvarsall.bat" x64 echo "Using VS 2022..." ) cd %SRC% python utils/git-sync-deps --treeless mkdir build cd build :: ######################################### :: Start building. :: ######################################### echo "Starting build... %DATE% %TIME%" if "%KOKORO_GITHUB_COMMIT%." == "." ( set BUILD_SHA=%KOKORO_GITHUB_PULL_REQUEST_COMMIT% ) else ( set BUILD_SHA=%KOKORO_GITHUB_COMMIT% ) set CMAKE_FLAGS=-DCMAKE_INSTALL_PREFIX=%KOKORO_ARTIFACTS_DIR%\install -GNinja -DCMAKE_BUILD_TYPE=%BUILD_TYPE% -DRE2_BUILD_TESTING=OFF -DCMAKE_C_COMPILER=cl.exe -DCMAKE_CXX_COMPILER=cl.exe :: Build spirv-fuzz set CMAKE_FLAGS=%CMAKE_FLAGS% -DSPIRV_BUILD_FUZZER=ON if "%BUILD_TESTS%" == "NO" ( set CMAKE_FLAGS=-DSPIRV_SKIP_TESTS=ON %CMAKE_FLAGS% ) cmake --version cmake %CMAKE_FLAGS% .. if %ERRORLEVEL% NEQ 0 exit /b %ERRORLEVEL% echo "Build everything... %DATE% %TIME%" ninja if %ERRORLEVEL% NEQ 0 exit /b %ERRORLEVEL% echo "Build Completed %DATE% %TIME%" :: This lets us use !ERRORLEVEL! inside an IF ... () and get the actual error at that point. setlocal ENABLEDELAYEDEXPANSION :: ################################################ :: Run the tests :: ################################################ if "%BUILD_TESTS%" NEQ "NO" ( echo "Running Tests... %DATE% %TIME%" ctest -C %BUILD_TYPE% --output-on-failure --timeout 300 if !ERRORLEVEL! NEQ 0 exit /b !ERRORLEVEL! echo "Tests Completed %DATE% %TIME%" ) :: ################################################ :: Install and package. :: ################################################ ninja install cd %KOKORO_ARTIFACTS_DIR% zip -r install.zip install :: Clean up some directories. rm -rf %SRC%\build rm -rf %SRC%\external exit /b 0 KhronosGroup-SPIRV-Tools-f289d04/kokoro/shaderc-smoketest/000077500000000000000000000000001475742701700234625ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/kokoro/shaderc-smoketest/build.sh000077500000000000000000000013771475742701700251300ustar00rootroot00000000000000#!/bin/bash # Copyright (c) 2018 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Fail on any error. set -e # Display commands being run. set -x SCRIPT_DIR=`dirname "$BASH_SOURCE"` source $SCRIPT_DIR/../scripts/linux/build.sh RELEASE gcc cmake-smoketest KhronosGroup-SPIRV-Tools-f289d04/kokoro/shaderc-smoketest/continuous.cfg000066400000000000000000000012441475742701700263520ustar00rootroot00000000000000# Copyright (c) 2018 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Continuous build configuration. build_file: "SPIRV-Tools/kokoro/shaderc-smoketest/build.sh" KhronosGroup-SPIRV-Tools-f289d04/kokoro/shaderc-smoketest/presubmit.cfg000066400000000000000000000012431475742701700261550ustar00rootroot00000000000000# Copyright (c) 2018 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Presubmit build configuration. build_file: "SPIRV-Tools/kokoro/shaderc-smoketest/build.sh" KhronosGroup-SPIRV-Tools-f289d04/kokoro/windows-msvc-2019-release/000077500000000000000000000000001475742701700245045ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/kokoro/windows-msvc-2019-release/build.bat000066400000000000000000000014451475742701700262770ustar00rootroot00000000000000:: Copyright (c) 2023 Google LLC :: :: Licensed under the Apache License, Version 2.0 (the "License"); :: you may not use this file except in compliance with the License. :: You may obtain a copy of the License at :: :: http://www.apache.org/licenses/LICENSE-2.0 :: :: Unless required by applicable law or agreed to in writing, software :: distributed under the License is distributed on an "AS IS" BASIS, :: WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. :: See the License for the specific language governing permissions and :: limitations under the License. :: :: Windows Build Script. @echo on :: Find out the directory of the common build script. set SCRIPT_DIR=%~dp0 :: Call with correct parameter call %SCRIPT_DIR%\..\scripts\windows\build.bat RelWithDebInfo 2019 KhronosGroup-SPIRV-Tools-f289d04/kokoro/windows-msvc-2019-release/continuous.cfg000066400000000000000000000013521475742701700273740ustar00rootroot00000000000000# Copyright (c) 2023 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Continuous build configuration. build_file: "SPIRV-Tools/kokoro/windows-msvc-2019-release/build.bat" action { define_artifacts { regex: "install.zip" } } KhronosGroup-SPIRV-Tools-f289d04/kokoro/windows-msvc-2019-release/presubmit.cfg000066400000000000000000000012531475742701700272000ustar00rootroot00000000000000# Copyright (c) 2023 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Presubmit build configuration. build_file: "SPIRV-Tools/kokoro/windows-msvc-2019-release/build.bat" KhronosGroup-SPIRV-Tools-f289d04/kokoro/windows-msvc-2022-debug/000077500000000000000000000000001475742701700241445ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/kokoro/windows-msvc-2022-debug/build.bat000066400000000000000000000014331475742701700257340ustar00rootroot00000000000000:: Copyright (c) 2023 Google LLC :: :: Licensed under the Apache License, Version 2.0 (the "License"); :: you may not use this file except in compliance with the License. :: You may obtain a copy of the License at :: :: http://www.apache.org/licenses/LICENSE-2.0 :: :: Unless required by applicable law or agreed to in writing, software :: distributed under the License is distributed on an "AS IS" BASIS, :: WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. :: See the License for the specific language governing permissions and :: limitations under the License. :: :: Windows Build Script. @echo on :: Find out the directory of the common build script. set SCRIPT_DIR=%~dp0 :: Call with correct parameter call %SCRIPT_DIR%\..\scripts\windows\build.bat Debug 2019 KhronosGroup-SPIRV-Tools-f289d04/kokoro/windows-msvc-2022-debug/continuous.cfg000066400000000000000000000013471475742701700270400ustar00rootroot00000000000000# Copyright (c) 2023 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Continuous build configuration. build_file: "SPIRV-Tools/kokoro/windows-msvc-2022-debug/build.bat" action { define_artifacts { regex: "install.zip" } } KhronosGroup-SPIRV-Tools-f289d04/kokoro/windows-msvc-2022-debug/presubmit.cfg000066400000000000000000000012501475742701700266350ustar00rootroot00000000000000# Copyright (c) 2023 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Presubmit build configuration. build_file: "SPIRV-Tools/kokoro/windows-msvc-2022-debug/build.bat" KhronosGroup-SPIRV-Tools-f289d04/kokoro/windows-msvc-2022-release/000077500000000000000000000000001475742701700244765ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/kokoro/windows-msvc-2022-release/build.bat000066400000000000000000000014451475742701700262710ustar00rootroot00000000000000:: Copyright (c) 2025 Google LLC :: :: Licensed under the Apache License, Version 2.0 (the "License"); :: you may not use this file except in compliance with the License. :: You may obtain a copy of the License at :: :: http://www.apache.org/licenses/LICENSE-2.0 :: :: Unless required by applicable law or agreed to in writing, software :: distributed under the License is distributed on an "AS IS" BASIS, :: WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. :: See the License for the specific language governing permissions and :: limitations under the License. :: :: Windows Build Script. @echo on :: Find out the directory of the common build script. set SCRIPT_DIR=%~dp0 :: Call with correct parameter call %SCRIPT_DIR%\..\scripts\windows\build.bat RelWithDebInfo 2022 KhronosGroup-SPIRV-Tools-f289d04/kokoro/windows-msvc-2022-release/continuous.cfg000066400000000000000000000013521475742701700273660ustar00rootroot00000000000000# Copyright (c) 2025 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Continuous build configuration. build_file: "SPIRV-Tools/kokoro/windows-msvc-2022-release/build.bat" action { define_artifacts { regex: "install.zip" } } KhronosGroup-SPIRV-Tools-f289d04/kokoro/windows-msvc-2022-release/presubmit.cfg000066400000000000000000000012531475742701700271720ustar00rootroot00000000000000# Copyright (c) 2025 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Presubmit build configuration. build_file: "SPIRV-Tools/kokoro/windows-msvc-2022-release/build.bat" KhronosGroup-SPIRV-Tools-f289d04/source/000077500000000000000000000000001475742701700200315ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/CMakeLists.txt000066400000000000000000000542521475742701700226010ustar00rootroot00000000000000# Copyright (c) 2015-2016 The Khronos Group Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. set(GRAMMAR_PROCESSING_SCRIPT "${spirv-tools_SOURCE_DIR}/utils/generate_grammar_tables.py") set(VIMSYNTAX_PROCESSING_SCRIPT "${spirv-tools_SOURCE_DIR}/utils/vim/generate_syntax.py") set(XML_REGISTRY_PROCESSING_SCRIPT "${spirv-tools_SOURCE_DIR}/utils/generate_registry_tables.py") set(LANG_HEADER_PROCESSING_SCRIPT "${spirv-tools_SOURCE_DIR}/utils/generate_language_headers.py") # Pull in grammar files that have migrated to SPIRV-Headers set(DEBUGINFO_GRAMMAR_JSON_FILE "${SPIRV_HEADER_INCLUDE_DIR}/spirv/unified1/extinst.debuginfo.grammar.json") set(CLDEBUGINFO100_GRAMMAR_JSON_FILE "${SPIRV_HEADER_INCLUDE_DIR}/spirv/unified1/extinst.opencl.debuginfo.100.grammar.json") set(VKDEBUGINFO100_GRAMMAR_JSON_FILE "${SPIRV_HEADER_INCLUDE_DIR}/spirv/unified1/extinst.nonsemantic.shader.debuginfo.100.grammar.json") # macro() definitions are used in the following because we need to append .inc # file paths into some global lists (*_CPP_DEPENDS). And those global lists are # later used by set_source_files_properties() calls. # function() definitions are not suitable because they create new scopes. macro(spvtools_core_tables CONFIG_VERSION) set(GRAMMAR_JSON_FILE "${SPIRV_HEADER_INCLUDE_DIR}/spirv/${CONFIG_VERSION}/spirv.core.grammar.json") set(GRAMMAR_INSTS_INC_FILE "${spirv-tools_BINARY_DIR}/core.insts-${CONFIG_VERSION}.inc") set(GRAMMAR_KINDS_INC_FILE "${spirv-tools_BINARY_DIR}/operand.kinds-${CONFIG_VERSION}.inc") add_custom_command(OUTPUT ${GRAMMAR_INSTS_INC_FILE} ${GRAMMAR_KINDS_INC_FILE} COMMAND Python3::Interpreter ${GRAMMAR_PROCESSING_SCRIPT} --spirv-core-grammar=${GRAMMAR_JSON_FILE} --extinst-debuginfo-grammar=${DEBUGINFO_GRAMMAR_JSON_FILE} --extinst-cldebuginfo100-grammar=${CLDEBUGINFO100_GRAMMAR_JSON_FILE} --core-insts-output=${GRAMMAR_INSTS_INC_FILE} --operand-kinds-output=${GRAMMAR_KINDS_INC_FILE} --output-language=c++ DEPENDS ${GRAMMAR_PROCESSING_SCRIPT} ${GRAMMAR_JSON_FILE} ${DEBUGINFO_GRAMMAR_JSON_FILE} ${CLDEBUGINFO100_GRAMMAR_JSON_FILE} COMMENT "Generate info tables for SPIR-V v${CONFIG_VERSION} core instructions and operands.") list(APPEND OPCODE_CPP_DEPENDS ${GRAMMAR_INSTS_INC_FILE}) list(APPEND OPERAND_CPP_DEPENDS ${GRAMMAR_KINDS_INC_FILE}) endmacro(spvtools_core_tables) macro(spvtools_enum_string_mapping CONFIG_VERSION) set(GRAMMAR_JSON_FILE "${SPIRV_HEADER_INCLUDE_DIR}/spirv/${CONFIG_VERSION}/spirv.core.grammar.json") set(GRAMMAR_EXTENSION_ENUM_INC_FILE "${spirv-tools_BINARY_DIR}/extension_enum.inc") set(GRAMMAR_ENUM_STRING_MAPPING_INC_FILE "${spirv-tools_BINARY_DIR}/enum_string_mapping.inc") add_custom_command(OUTPUT ${GRAMMAR_EXTENSION_ENUM_INC_FILE} ${GRAMMAR_ENUM_STRING_MAPPING_INC_FILE} COMMAND Python3::Interpreter ${GRAMMAR_PROCESSING_SCRIPT} --spirv-core-grammar=${GRAMMAR_JSON_FILE} --extinst-debuginfo-grammar=${DEBUGINFO_GRAMMAR_JSON_FILE} --extinst-cldebuginfo100-grammar=${CLDEBUGINFO100_GRAMMAR_JSON_FILE} --extension-enum-output=${GRAMMAR_EXTENSION_ENUM_INC_FILE} --enum-string-mapping-output=${GRAMMAR_ENUM_STRING_MAPPING_INC_FILE} --output-language=c++ DEPENDS ${GRAMMAR_PROCESSING_SCRIPT} ${GRAMMAR_JSON_FILE} ${DEBUGINFO_GRAMMAR_JSON_FILE} ${CLDEBUGINFO100_GRAMMAR_JSON_FILE} COMMENT "Generate enum-string mapping for SPIR-V v${CONFIG_VERSION}.") list(APPEND EXTENSION_H_DEPENDS ${GRAMMAR_EXTENSION_ENUM_INC_FILE}) list(APPEND ENUM_STRING_MAPPING_CPP_DEPENDS ${GRAMMAR_ENUM_STRING_MAPPING_INC_FILE}) endmacro(spvtools_enum_string_mapping) macro(spvtools_vimsyntax CONFIG_VERSION CLVERSION) set(GRAMMAR_JSON_FILE "${SPIRV_HEADER_INCLUDE_DIR}/spirv/${CONFIG_VERSION}/spirv.core.grammar.json") set(GLSL_GRAMMAR_JSON_FILE "${SPIRV_HEADER_INCLUDE_DIR}/spirv/${CONFIG_VERSION}/extinst.glsl.std.450.grammar.json") set(OPENCL_GRAMMAR_JSON_FILE "${SPIRV_HEADER_INCLUDE_DIR}/spirv/${CONFIG_VERSION}/extinst.opencl.std.100.grammar.json") set(VIMSYNTAX_FILE "${spirv-tools_BINARY_DIR}/spvasm.vim") add_custom_command(OUTPUT ${VIMSYNTAX_FILE} COMMAND Python3::Interpreter ${VIMSYNTAX_PROCESSING_SCRIPT} --spirv-core-grammar=${GRAMMAR_JSON_FILE} --extinst-debuginfo-grammar=${DEBUGINFO_GRAMMAR_JSON_FILE} --extinst-glsl-grammar=${GLSL_GRAMMAR_JSON_FILE} --extinst-opencl-grammar=${OPENCL_GRAMMAR_JSON_FILE} >${VIMSYNTAX_FILE} DEPENDS ${VIMSYNTAX_PROCESSING_SCRIPT} ${GRAMMAR_JSON_FILE} ${GLSL_GRAMMAR_JSON_FILE} ${OPENCL_GRAMMAR_JSON_FILE} ${DEBUGINFO_GRAMMAR_JSON_FILE} COMMENT "Generate spvasm.vim: Vim syntax file for SPIR-V assembly.") endmacro(spvtools_vimsyntax) macro(spvtools_glsl_tables CONFIG_VERSION) set(CORE_GRAMMAR_JSON_FILE "${SPIRV_HEADER_INCLUDE_DIR}/spirv/${CONFIG_VERSION}/spirv.core.grammar.json") set(GLSL_GRAMMAR_JSON_FILE "${SPIRV_HEADER_INCLUDE_DIR}/spirv/${CONFIG_VERSION}/extinst.glsl.std.450.grammar.json") set(GRAMMAR_INC_FILE "${spirv-tools_BINARY_DIR}/glsl.std.450.insts.inc") add_custom_command(OUTPUT ${GRAMMAR_INC_FILE} COMMAND Python3::Interpreter ${GRAMMAR_PROCESSING_SCRIPT} --extinst-glsl-grammar=${GLSL_GRAMMAR_JSON_FILE} --glsl-insts-output=${GRAMMAR_INC_FILE} --output-language=c++ DEPENDS ${GRAMMAR_PROCESSING_SCRIPT} ${CORE_GRAMMAR_JSON_FILE} ${GLSL_GRAMMAR_JSON_FILE} COMMENT "Generate info tables for GLSL extended instructions and operands v${CONFIG_VERSION}.") list(APPEND EXTINST_CPP_DEPENDS ${GRAMMAR_INC_FILE}) endmacro(spvtools_glsl_tables) macro(spvtools_opencl_tables CONFIG_VERSION) set(CORE_GRAMMAR_JSON_FILE "${SPIRV_HEADER_INCLUDE_DIR}/spirv/${CONFIG_VERSION}/spirv.core.grammar.json") set(OPENCL_GRAMMAR_JSON_FILE "${SPIRV_HEADER_INCLUDE_DIR}/spirv/${CONFIG_VERSION}/extinst.opencl.std.100.grammar.json") set(GRAMMAR_INC_FILE "${spirv-tools_BINARY_DIR}/opencl.std.insts.inc") add_custom_command(OUTPUT ${GRAMMAR_INC_FILE} COMMAND Python3::Interpreter ${GRAMMAR_PROCESSING_SCRIPT} --extinst-opencl-grammar=${OPENCL_GRAMMAR_JSON_FILE} --opencl-insts-output=${GRAMMAR_INC_FILE} DEPENDS ${GRAMMAR_PROCESSING_SCRIPT} ${CORE_GRAMMAR_JSON_FILE} ${OPENCL_GRAMMAR_JSON_FILE} COMMENT "Generate info tables for OpenCL extended instructions and operands v${CONFIG_VERSION}.") list(APPEND EXTINST_CPP_DEPENDS ${GRAMMAR_INC_FILE}) endmacro(spvtools_opencl_tables) macro(spvtools_vendor_tables VENDOR_TABLE SHORT_NAME OPERAND_KIND_PREFIX) set(INSTS_FILE "${spirv-tools_BINARY_DIR}/${VENDOR_TABLE}.insts.inc") set(GRAMMAR_FILE "${SPIRV_HEADER_INCLUDE_DIR}/spirv/unified1/extinst.${VENDOR_TABLE}.grammar.json") if(NOT EXISTS ${GRAMMAR_FILE}) set(GRAMMAR_FILE "${spirv-tools_SOURCE_DIR}/source/extinst.${VENDOR_TABLE}.grammar.json") endif() add_custom_command(OUTPUT ${INSTS_FILE} COMMAND Python3::Interpreter ${GRAMMAR_PROCESSING_SCRIPT} --extinst-vendor-grammar=${GRAMMAR_FILE} --vendor-insts-output=${INSTS_FILE} --vendor-operand-kind-prefix=${OPERAND_KIND_PREFIX} DEPENDS ${GRAMMAR_PROCESSING_SCRIPT} ${GRAMMAR_FILE} COMMENT "Generate extended instruction tables for ${VENDOR_TABLE}.") add_custom_target(spv-tools-${SHORT_NAME} DEPENDS ${INSTS_FILE}) set_property(TARGET spv-tools-${SHORT_NAME} PROPERTY FOLDER "SPIRV-Tools build") list(APPEND EXTINST_CPP_DEPENDS spv-tools-${SHORT_NAME}) endmacro(spvtools_vendor_tables) macro(spvtools_extinst_lang_headers NAME GRAMMAR_FILE) set(OUT_H ${spirv-tools_BINARY_DIR}/${NAME}.h) add_custom_command(OUTPUT ${OUT_H} COMMAND Python3::Interpreter ${LANG_HEADER_PROCESSING_SCRIPT} --extinst-grammar=${GRAMMAR_FILE} --extinst-output-path=${OUT_H} DEPENDS ${LANG_HEADER_PROCESSING_SCRIPT} ${GRAMMAR_FILE} COMMENT "Generate language specific header for ${NAME}.") add_custom_target(spirv-tools-header-${NAME} DEPENDS ${OUT_H}) set_property(TARGET spirv-tools-header-${NAME} PROPERTY FOLDER "SPIRV-Tools build") list(APPEND EXTINST_CPP_DEPENDS spirv-tools-header-${NAME}) endmacro(spvtools_extinst_lang_headers) spvtools_core_tables("unified1") spvtools_enum_string_mapping("unified1") spvtools_opencl_tables("unified1") spvtools_glsl_tables("unified1") spvtools_vendor_tables("spv-amd-shader-explicit-vertex-parameter" "spv-amd-sevp" "") spvtools_vendor_tables("spv-amd-shader-trinary-minmax" "spv-amd-stm" "") spvtools_vendor_tables("spv-amd-gcn-shader" "spv-amd-gs" "") spvtools_vendor_tables("spv-amd-shader-ballot" "spv-amd-sb" "") spvtools_vendor_tables("debuginfo" "debuginfo" "") spvtools_vendor_tables("opencl.debuginfo.100" "cldi100" "CLDEBUG100_") spvtools_vendor_tables("nonsemantic.shader.debuginfo.100" "shdi100" "SHDEBUG100_") spvtools_vendor_tables("nonsemantic.clspvreflection" "clspvreflection" "") spvtools_vendor_tables("nonsemantic.vkspreflection" "vkspreflection" "") spvtools_extinst_lang_headers("DebugInfo" ${DEBUGINFO_GRAMMAR_JSON_FILE}) spvtools_extinst_lang_headers("OpenCLDebugInfo100" ${CLDEBUGINFO100_GRAMMAR_JSON_FILE}) spvtools_extinst_lang_headers("NonSemanticShaderDebugInfo100" ${VKDEBUGINFO100_GRAMMAR_JSON_FILE}) spvtools_vimsyntax("unified1" "1.0") add_custom_target(spirv-tools-vimsyntax DEPENDS ${VIMSYNTAX_FILE}) set_property(TARGET spirv-tools-vimsyntax PROPERTY FOLDER "SPIRV-Tools utilities") # Extract the list of known generators from the SPIR-V XML registry file. set(GENERATOR_INC_FILE ${spirv-tools_BINARY_DIR}/generators.inc) set(SPIRV_XML_REGISTRY_FILE ${SPIRV_HEADER_INCLUDE_DIR}/spirv/spir-v.xml) add_custom_command(OUTPUT ${GENERATOR_INC_FILE} COMMAND Python3::Interpreter ${XML_REGISTRY_PROCESSING_SCRIPT} --xml=${SPIRV_XML_REGISTRY_FILE} --generator-output=${GENERATOR_INC_FILE} DEPENDS ${XML_REGISTRY_PROCESSING_SCRIPT} ${SPIRV_XML_REGISTRY_FILE} COMMENT "Generate tables based on the SPIR-V XML registry.") list(APPEND OPCODE_CPP_DEPENDS ${GENERATOR_INC_FILE}) # The following .cpp files include the above generated .inc files. # Add those .inc files as their dependencies. # # We need to wrap the .inc files with a custom target to avoid problems when # multiple targets depend on the same custom command. add_custom_target(core_tables DEPENDS ${OPCODE_CPP_DEPENDS} ${OPERAND_CPP_DEPENDS}) add_custom_target(enum_string_mapping DEPENDS ${EXTENSION_H_DEPENDS} ${ENUM_STRING_MAPPING_CPP_DEPENDS}) add_custom_target(extinst_tables DEPENDS ${EXTINST_CPP_DEPENDS}) set_source_files_properties( ${CMAKE_CURRENT_SOURCE_DIR}/extensions.h PROPERTIES HEADER_FILE_ONLY TRUE) set(SPIRV_TOOLS_BUILD_VERSION_INC ${spirv-tools_BINARY_DIR}/build-version.inc) set(SPIRV_TOOLS_BUILD_VERSION_INC_GENERATOR ${spirv-tools_SOURCE_DIR}/utils/update_build_version.py) set(SPIRV_TOOLS_CHANGES_FILE ${spirv-tools_SOURCE_DIR}/CHANGES) add_custom_command(OUTPUT ${SPIRV_TOOLS_BUILD_VERSION_INC} COMMAND Python3::Interpreter ${SPIRV_TOOLS_BUILD_VERSION_INC_GENERATOR} ${SPIRV_TOOLS_CHANGES_FILE} ${SPIRV_TOOLS_BUILD_VERSION_INC} DEPENDS ${SPIRV_TOOLS_BUILD_VERSION_INC_GENERATOR} ${SPIRV_TOOLS_CHANGES_FILE} COMMENT "Update build-version.inc in the SPIRV-Tools build directory (if necessary).") # Convenience target for standalone generation of the build-version.inc file. # This is not required for any dependence chain. add_custom_target(spirv-tools-build-version DEPENDS ${SPIRV_TOOLS_BUILD_VERSION_INC}) set_property(TARGET spirv-tools-build-version PROPERTY FOLDER "SPIRV-Tools build") list(APPEND PCH_DEPENDS ${ENUM_STRING_MAPPING_CPP_DEPENDS} ${OPCODE_CPP_DEPENDS} ${OPERAND_CPP_DEPENDS} ${EXTENSION_H_DEPENDS} ${EXTINST_CPP_DEPENDS} ${SPIRV_TOOLS_BUILD_VERSION_INC}) set_source_files_properties( ${CMAKE_CURRENT_SOURCE_DIR}/pch_source.cpp PROPERTIES OBJECT_DEPENDS "${PCH_DEPENDS}") add_subdirectory(opt) add_subdirectory(reduce) add_subdirectory(fuzz) add_subdirectory(link) add_subdirectory(lint) add_subdirectory(diff) set(SPIRV_SOURCES ${spirv-tools_SOURCE_DIR}/include/spirv-tools/libspirv.h ${CMAKE_CURRENT_SOURCE_DIR}/util/bitutils.h ${CMAKE_CURRENT_SOURCE_DIR}/util/bit_vector.h ${CMAKE_CURRENT_SOURCE_DIR}/util/hash_combine.h ${CMAKE_CURRENT_SOURCE_DIR}/util/hex_float.h ${CMAKE_CURRENT_SOURCE_DIR}/util/make_unique.h ${CMAKE_CURRENT_SOURCE_DIR}/util/parse_number.h ${CMAKE_CURRENT_SOURCE_DIR}/util/small_vector.h ${CMAKE_CURRENT_SOURCE_DIR}/util/string_utils.h ${CMAKE_CURRENT_SOURCE_DIR}/util/timer.h ${CMAKE_CURRENT_SOURCE_DIR}/assembly_grammar.h ${CMAKE_CURRENT_SOURCE_DIR}/binary.h ${CMAKE_CURRENT_SOURCE_DIR}/cfa.h ${CMAKE_CURRENT_SOURCE_DIR}/common_debug_info.h ${CMAKE_CURRENT_SOURCE_DIR}/diagnostic.h ${CMAKE_CURRENT_SOURCE_DIR}/disassemble.h ${CMAKE_CURRENT_SOURCE_DIR}/enum_set.h ${CMAKE_CURRENT_SOURCE_DIR}/enum_string_mapping.h ${CMAKE_CURRENT_SOURCE_DIR}/ext_inst.h ${CMAKE_CURRENT_SOURCE_DIR}/extensions.h ${CMAKE_CURRENT_SOURCE_DIR}/instruction.h ${CMAKE_CURRENT_SOURCE_DIR}/latest_version_glsl_std_450_header.h ${CMAKE_CURRENT_SOURCE_DIR}/latest_version_opencl_std_header.h ${CMAKE_CURRENT_SOURCE_DIR}/latest_version_spirv_header.h ${CMAKE_CURRENT_SOURCE_DIR}/macro.h ${CMAKE_CURRENT_SOURCE_DIR}/name_mapper.h ${CMAKE_CURRENT_SOURCE_DIR}/opcode.h ${CMAKE_CURRENT_SOURCE_DIR}/operand.h ${CMAKE_CURRENT_SOURCE_DIR}/parsed_operand.h ${CMAKE_CURRENT_SOURCE_DIR}/print.h ${CMAKE_CURRENT_SOURCE_DIR}/spirv_constant.h ${CMAKE_CURRENT_SOURCE_DIR}/spirv_definition.h ${CMAKE_CURRENT_SOURCE_DIR}/spirv_endian.h ${CMAKE_CURRENT_SOURCE_DIR}/spirv_fuzzer_options.h ${CMAKE_CURRENT_SOURCE_DIR}/spirv_optimizer_options.h ${CMAKE_CURRENT_SOURCE_DIR}/spirv_reducer_options.h ${CMAKE_CURRENT_SOURCE_DIR}/spirv_target_env.h ${CMAKE_CURRENT_SOURCE_DIR}/spirv_validator_options.h ${CMAKE_CURRENT_SOURCE_DIR}/table.h ${CMAKE_CURRENT_SOURCE_DIR}/text.h ${CMAKE_CURRENT_SOURCE_DIR}/text_handler.h ${CMAKE_CURRENT_SOURCE_DIR}/to_string.h ${CMAKE_CURRENT_SOURCE_DIR}/val/validate.h ${CMAKE_CURRENT_SOURCE_DIR}/util/bit_vector.cpp ${CMAKE_CURRENT_SOURCE_DIR}/util/parse_number.cpp ${CMAKE_CURRENT_SOURCE_DIR}/util/string_utils.cpp ${CMAKE_CURRENT_SOURCE_DIR}/assembly_grammar.cpp ${CMAKE_CURRENT_SOURCE_DIR}/binary.cpp ${CMAKE_CURRENT_SOURCE_DIR}/diagnostic.cpp ${CMAKE_CURRENT_SOURCE_DIR}/disassemble.cpp ${CMAKE_CURRENT_SOURCE_DIR}/enum_string_mapping.cpp ${CMAKE_CURRENT_SOURCE_DIR}/ext_inst.cpp ${CMAKE_CURRENT_SOURCE_DIR}/extensions.cpp ${CMAKE_CURRENT_SOURCE_DIR}/libspirv.cpp ${CMAKE_CURRENT_SOURCE_DIR}/name_mapper.cpp ${CMAKE_CURRENT_SOURCE_DIR}/opcode.cpp ${CMAKE_CURRENT_SOURCE_DIR}/operand.cpp ${CMAKE_CURRENT_SOURCE_DIR}/parsed_operand.cpp ${CMAKE_CURRENT_SOURCE_DIR}/print.cpp ${CMAKE_CURRENT_SOURCE_DIR}/software_version.cpp ${CMAKE_CURRENT_SOURCE_DIR}/spirv_endian.cpp ${CMAKE_CURRENT_SOURCE_DIR}/spirv_fuzzer_options.cpp ${CMAKE_CURRENT_SOURCE_DIR}/spirv_optimizer_options.cpp ${CMAKE_CURRENT_SOURCE_DIR}/spirv_reducer_options.cpp ${CMAKE_CURRENT_SOURCE_DIR}/spirv_target_env.cpp ${CMAKE_CURRENT_SOURCE_DIR}/spirv_validator_options.cpp ${CMAKE_CURRENT_SOURCE_DIR}/table.cpp ${CMAKE_CURRENT_SOURCE_DIR}/text.cpp ${CMAKE_CURRENT_SOURCE_DIR}/text_handler.cpp ${CMAKE_CURRENT_SOURCE_DIR}/to_string.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_adjacency.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_annotation.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_arithmetics.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_atomics.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_barriers.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_bitwise.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_builtins.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_capability.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_cfg.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_composites.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_constants.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_conversion.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_debug.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_decorations.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_derivatives.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_extensions.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_execution_limitations.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_function.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_id.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_image.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_interfaces.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_instruction.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_layout.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_literals.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_logicals.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_memory.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_memory_semantics.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_mesh_shading.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_misc.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_mode_setting.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_non_uniform.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_primitives.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_ray_query.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_ray_tracing.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_ray_tracing_reorder.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_scopes.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_small_type_uses.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_tensor_layout.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validate_type.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/decoration.h ${CMAKE_CURRENT_SOURCE_DIR}/val/basic_block.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/construct.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/function.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/instruction.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val/validation_state.cpp) if (${SPIRV_TIMER_ENABLED}) set(SPIRV_SOURCES ${SPIRV_SOURCES} ${CMAKE_CURRENT_SOURCE_DIR}/util/timer.cpp) endif() # The software_version.cpp file includes build-version.inc. # Rebuild the software_version.cpp object file if it is older than # build-version.inc or whenever build-version.inc itself is out of # date. In the latter case, rebuild build-version.inc first. # CMake is not smart enough to detect this dependency automatically. # Without this, the dependency detection system for #included files # does not kick in on a clean build for the following reason: The # build will fail early because it doesn't know how to build the # missing source file build-version.inc. That occurs before the # preprocessor is run on software_version.cpp to detect the # #include dependency. set_source_files_properties( ${CMAKE_CURRENT_SOURCE_DIR}/software_version.cpp PROPERTIES OBJECT_DEPENDS "${SPIRV_TOOLS_BUILD_VERSION_INC}") spvtools_pch(SPIRV_SOURCES pch_source) # spirv_tools_default_target_options() sets the target options that are common # for all ${SPIRV_TOOLS} targets. function(spirv_tools_default_target_options target) spvtools_default_compile_options(${target}) target_include_directories(${target} PUBLIC $ $ PRIVATE ${spirv-tools_BINARY_DIR} PRIVATE ${SPIRV_HEADER_INCLUDE_DIR} ) set_property(TARGET ${target} PROPERTY FOLDER "SPIRV-Tools libraries") spvtools_check_symbol_exports(${target}) add_dependencies(${target} spirv-tools-build-version core_tables enum_string_mapping extinst_tables) endfunction() # Always build ${SPIRV_TOOLS}-shared. This is expected distro packages, and # unlike the other SPIRV_TOOLS target, defaults to hidden symbol visibility. add_library(${SPIRV_TOOLS}-shared SHARED ${SPIRV_SOURCES}) spirv_tools_default_target_options(${SPIRV_TOOLS}-shared) set_target_properties(${SPIRV_TOOLS}-shared PROPERTIES CXX_VISIBILITY_PRESET hidden) target_compile_definitions(${SPIRV_TOOLS}-shared PRIVATE SPIRV_TOOLS_IMPLEMENTATION PUBLIC SPIRV_TOOLS_SHAREDLIB ) if(SPIRV_TOOLS_BUILD_STATIC) add_library(${SPIRV_TOOLS}-static STATIC ${SPIRV_SOURCES}) spirv_tools_default_target_options(${SPIRV_TOOLS}-static) # The static target does not have the '-static' suffix. set_target_properties(${SPIRV_TOOLS}-static PROPERTIES OUTPUT_NAME "${SPIRV_TOOLS}") # Create the "${SPIRV_TOOLS}" target as an alias to either "${SPIRV_TOOLS}-static" # or "${SPIRV_TOOLS}-shared" depending on the value of BUILD_SHARED_LIBS. if(BUILD_SHARED_LIBS) add_library(${SPIRV_TOOLS} ALIAS ${SPIRV_TOOLS}-shared) else() add_library(${SPIRV_TOOLS} ALIAS ${SPIRV_TOOLS}-static) endif() set(SPIRV_TOOLS_TARGETS ${SPIRV_TOOLS}-static ${SPIRV_TOOLS}-shared) else() add_library(${SPIRV_TOOLS} ${SPIRV_TOOLS_LIBRARY_TYPE} ${SPIRV_SOURCES}) spirv_tools_default_target_options(${SPIRV_TOOLS}) set(SPIRV_TOOLS_TARGETS ${SPIRV_TOOLS} ${SPIRV_TOOLS}-shared) endif() if("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux") find_library(LIBRT rt) if(LIBRT) foreach(target ${SPIRV_TOOLS_TARGETS}) target_link_libraries(${target} rt) endforeach() endif() endif() if(ENABLE_SPIRV_TOOLS_INSTALL) install(TARGETS ${SPIRV_TOOLS_TARGETS} EXPORT ${SPIRV_TOOLS}Targets) export(EXPORT ${SPIRV_TOOLS}Targets FILE ${SPIRV_TOOLS}Target.cmake) spvtools_config_package_dir(${SPIRV_TOOLS} PACKAGE_DIR) install(EXPORT ${SPIRV_TOOLS}Targets FILE ${SPIRV_TOOLS}Target.cmake DESTINATION ${PACKAGE_DIR}) # Special config file for root library compared to other libs. file(WRITE ${CMAKE_BINARY_DIR}/${SPIRV_TOOLS}Config.cmake "include(\${CMAKE_CURRENT_LIST_DIR}/${SPIRV_TOOLS}Target.cmake)\n" "if(TARGET ${SPIRV_TOOLS})\n" " set(${SPIRV_TOOLS}_LIBRARIES ${SPIRV_TOOLS})\n" " get_target_property(${SPIRV_TOOLS}_INCLUDE_DIRS ${SPIRV_TOOLS} INTERFACE_INCLUDE_DIRECTORIES)\n" "endif()\n") install(FILES ${CMAKE_BINARY_DIR}/${SPIRV_TOOLS}Config.cmake DESTINATION ${PACKAGE_DIR}) endif(ENABLE_SPIRV_TOOLS_INSTALL) if(MSVC AND (NOT ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang"))) # Enable parallel builds across four cores for this lib add_definitions(/MP4) endif() KhronosGroup-SPIRV-Tools-f289d04/source/assembly_grammar.cpp000066400000000000000000000220661475742701700240700ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/assembly_grammar.h" #include #include #include #include "source/ext_inst.h" #include "source/opcode.h" #include "source/operand.h" #include "source/spirv_target_env.h" #include "source/table.h" namespace spvtools { namespace { /// @brief Parses a mask expression string for the given operand type. /// /// A mask expression is a sequence of one or more terms separated by '|', /// where each term a named enum value for the given type. No whitespace /// is permitted. /// /// On success, the value is written to pValue. /// /// @param[in] operandTable operand lookup table /// @param[in] type of the operand /// @param[in] textValue word of text to be parsed /// @param[out] pValue where the resulting value is written /// /// @return result code spv_result_t spvTextParseMaskOperand(spv_target_env env, const spv_operand_table operandTable, const spv_operand_type_t type, const char* textValue, uint32_t* pValue) { if (textValue == nullptr) return SPV_ERROR_INVALID_TEXT; size_t text_length = strlen(textValue); if (text_length == 0) return SPV_ERROR_INVALID_TEXT; const char* text_end = textValue + text_length; // We only support mask expressions in ASCII, so the separator value is a // char. const char separator = '|'; // Accumulate the result by interpreting one word at a time, scanning // from left to right. uint32_t value = 0; const char* begin = textValue; // The left end of the current word. const char* end = nullptr; // One character past the end of the current word. do { end = std::find(begin, text_end, separator); spv_operand_desc entry = nullptr; if (auto error = spvOperandTableNameLookup(env, operandTable, type, begin, end - begin, &entry)) { return error; } value |= entry->value; // Advance to the next word by skipping over the separator. begin = end + 1; } while (end != text_end); *pValue = value; return SPV_SUCCESS; } // Associates an opcode with its name. struct SpecConstantOpcodeEntry { spv::Op opcode; const char* name; }; // All the opcodes allowed as the operation for OpSpecConstantOp. // The name does not have the usual "Op" prefix. For example opcode // spv::Op::IAdd is associated with the name "IAdd". // // clang-format off #define CASE(NAME) { spv::Op::Op##NAME, #NAME } const SpecConstantOpcodeEntry kOpSpecConstantOpcodes[] = { // Conversion CASE(SConvert), CASE(FConvert), CASE(ConvertFToS), CASE(ConvertSToF), CASE(ConvertFToU), CASE(ConvertUToF), CASE(UConvert), CASE(ConvertPtrToU), CASE(ConvertUToPtr), CASE(GenericCastToPtr), CASE(PtrCastToGeneric), CASE(Bitcast), CASE(QuantizeToF16), // Arithmetic CASE(SNegate), CASE(Not), CASE(IAdd), CASE(ISub), CASE(IMul), CASE(UDiv), CASE(SDiv), CASE(UMod), CASE(SRem), CASE(SMod), CASE(ShiftRightLogical), CASE(ShiftRightArithmetic), CASE(ShiftLeftLogical), CASE(BitwiseOr), CASE(BitwiseAnd), CASE(BitwiseXor), CASE(FNegate), CASE(FAdd), CASE(FSub), CASE(FMul), CASE(FDiv), CASE(FRem), CASE(FMod), // Composite CASE(VectorShuffle), CASE(CompositeExtract), CASE(CompositeInsert), // Logical CASE(LogicalOr), CASE(LogicalAnd), CASE(LogicalNot), CASE(LogicalEqual), CASE(LogicalNotEqual), CASE(Select), // Comparison CASE(IEqual), CASE(INotEqual), CASE(ULessThan), CASE(SLessThan), CASE(UGreaterThan), CASE(SGreaterThan), CASE(ULessThanEqual), CASE(SLessThanEqual), CASE(UGreaterThanEqual), CASE(SGreaterThanEqual), // Memory CASE(AccessChain), CASE(InBoundsAccessChain), CASE(PtrAccessChain), CASE(InBoundsPtrAccessChain), CASE(CooperativeMatrixLengthNV), CASE(CooperativeMatrixLengthKHR) }; // The 60 is determined by counting the opcodes listed in the spec. static_assert(61 == sizeof(kOpSpecConstantOpcodes)/sizeof(kOpSpecConstantOpcodes[0]), "OpSpecConstantOp opcode table is incomplete"); #undef CASE // clang-format on const size_t kNumOpSpecConstantOpcodes = sizeof(kOpSpecConstantOpcodes) / sizeof(kOpSpecConstantOpcodes[0]); } // namespace bool AssemblyGrammar::isValid() const { return operandTable_ && opcodeTable_ && extInstTable_; } CapabilitySet AssemblyGrammar::filterCapsAgainstTargetEnv( const spv::Capability* cap_array, uint32_t count) const { CapabilitySet cap_set; const auto version = spvVersionForTargetEnv(target_env_); for (uint32_t i = 0; i < count; ++i) { spv_operand_desc entry = {}; if (SPV_SUCCESS == lookupOperand(SPV_OPERAND_TYPE_CAPABILITY, static_cast(cap_array[i]), &entry)) { // This token is visible in this environment if it's in an appropriate // core version, or it is enabled by a capability or an extension. if ((version >= entry->minVersion && version <= entry->lastVersion) || entry->numExtensions > 0u || entry->numCapabilities > 0u) { cap_set.insert(cap_array[i]); } } } return cap_set; } spv_result_t AssemblyGrammar::lookupOpcode(const char* name, spv_opcode_desc* desc) const { return spvOpcodeTableNameLookup(target_env_, opcodeTable_, name, desc); } spv_result_t AssemblyGrammar::lookupOpcode(spv::Op opcode, spv_opcode_desc* desc) const { return spvOpcodeTableValueLookup(target_env_, opcodeTable_, opcode, desc); } spv_result_t AssemblyGrammar::lookupOperand(spv_operand_type_t type, const char* name, size_t name_len, spv_operand_desc* desc) const { return spvOperandTableNameLookup(target_env_, operandTable_, type, name, name_len, desc); } spv_result_t AssemblyGrammar::lookupOperand(spv_operand_type_t type, uint32_t operand, spv_operand_desc* desc) const { return spvOperandTableValueLookup(target_env_, operandTable_, type, operand, desc); } spv_result_t AssemblyGrammar::lookupSpecConstantOpcode(const char* name, spv::Op* opcode) const { const auto* last = kOpSpecConstantOpcodes + kNumOpSpecConstantOpcodes; const auto* found = std::find_if(kOpSpecConstantOpcodes, last, [name](const SpecConstantOpcodeEntry& entry) { return 0 == strcmp(name, entry.name); }); if (found == last) return SPV_ERROR_INVALID_LOOKUP; *opcode = found->opcode; return SPV_SUCCESS; } spv_result_t AssemblyGrammar::lookupSpecConstantOpcode(spv::Op opcode) const { const auto* last = kOpSpecConstantOpcodes + kNumOpSpecConstantOpcodes; const auto* found = std::find_if(kOpSpecConstantOpcodes, last, [opcode](const SpecConstantOpcodeEntry& entry) { return opcode == entry.opcode; }); if (found == last) return SPV_ERROR_INVALID_LOOKUP; return SPV_SUCCESS; } spv_result_t AssemblyGrammar::parseMaskOperand(const spv_operand_type_t type, const char* textValue, uint32_t* pValue) const { return spvTextParseMaskOperand(target_env_, operandTable_, type, textValue, pValue); } spv_result_t AssemblyGrammar::lookupExtInst(spv_ext_inst_type_t type, const char* textValue, spv_ext_inst_desc* extInst) const { return spvExtInstTableNameLookup(extInstTable_, type, textValue, extInst); } spv_result_t AssemblyGrammar::lookupExtInst(spv_ext_inst_type_t type, uint32_t firstWord, spv_ext_inst_desc* extInst) const { return spvExtInstTableValueLookup(extInstTable_, type, firstWord, extInst); } void AssemblyGrammar::pushOperandTypesForMask( const spv_operand_type_t type, const uint32_t mask, spv_operand_pattern_t* pattern) const { spvPushOperandTypesForMask(target_env_, operandTable_, type, mask, pattern); } } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/assembly_grammar.h000066400000000000000000000136441475742701700235370ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_ASSEMBLY_GRAMMAR_H_ #define SOURCE_ASSEMBLY_GRAMMAR_H_ #include "source/enum_set.h" #include "source/latest_version_spirv_header.h" #include "source/operand.h" #include "source/table.h" #include "spirv-tools/libspirv.h" namespace spvtools { // Encapsulates the grammar to use for SPIR-V assembly. // Contains methods to query for valid instructions and operands. class AssemblyGrammar { public: explicit AssemblyGrammar(const spv_const_context context) : target_env_(context->target_env), operandTable_(context->operand_table), opcodeTable_(context->opcode_table), extInstTable_(context->ext_inst_table) {} // Returns true if the internal tables have been initialized with valid data. bool isValid() const; // Returns the SPIR-V target environment. spv_target_env target_env() const { return target_env_; } // Removes capabilities not available in the current target environment and // returns the rest. CapabilitySet filterCapsAgainstTargetEnv(const spv::Capability* cap_array, uint32_t count) const; // Fills in the desc parameter with the information about the opcode // of the given name. Returns SPV_SUCCESS if the opcode was found, and // SPV_ERROR_INVALID_LOOKUP if the opcode does not exist. spv_result_t lookupOpcode(const char* name, spv_opcode_desc* desc) const; // Fills in the desc parameter with the information about the opcode // of the valid. Returns SPV_SUCCESS if the opcode was found, and // SPV_ERROR_INVALID_LOOKUP if the opcode does not exist. spv_result_t lookupOpcode(spv::Op opcode, spv_opcode_desc* desc) const; // Fills in the desc parameter with the information about the given // operand. Returns SPV_SUCCESS if the operand was found, and // SPV_ERROR_INVALID_LOOKUP otherwise. spv_result_t lookupOperand(spv_operand_type_t type, const char* name, size_t name_len, spv_operand_desc* desc) const; // Fills in the desc parameter with the information about the given // operand. Returns SPV_SUCCESS if the operand was found, and // SPV_ERROR_INVALID_LOOKUP otherwise. spv_result_t lookupOperand(spv_operand_type_t type, uint32_t operand, spv_operand_desc* desc) const; // Finds operand entry in the grammar table and returns its name. // Returns "Unknown" if not found. const char* lookupOperandName(spv_operand_type_t type, uint32_t operand) const { spv_operand_desc desc = nullptr; if (lookupOperand(type, operand, &desc) != SPV_SUCCESS || !desc) { return "Unknown"; } return desc->name; } // Finds the opcode for the given OpSpecConstantOp opcode name. The name // should not have the "Op" prefix. For example, "IAdd" corresponds to // the integer add opcode for OpSpecConstantOp. On success, returns // SPV_SUCCESS and sends the discovered operation code through the opcode // parameter. On failure, returns SPV_ERROR_INVALID_LOOKUP. spv_result_t lookupSpecConstantOpcode(const char* name, spv::Op* opcode) const; // Returns SPV_SUCCESS if the given opcode is valid as the opcode operand // to OpSpecConstantOp. spv_result_t lookupSpecConstantOpcode(spv::Op opcode) const; // Parses a mask expression string for the given operand type. // // A mask expression is a sequence of one or more terms separated by '|', // where each term is a named enum value for a given type. No whitespace // is permitted. // // On success, the value is written to pValue, and SPV_SUCCESS is returned. // The operand type is defined by the type parameter, and the text to be // parsed is defined by the textValue parameter. spv_result_t parseMaskOperand(const spv_operand_type_t type, const char* textValue, uint32_t* pValue) const; // Writes the extended operand with the given type and text to the *extInst // parameter. // Returns SPV_SUCCESS if the value could be found. spv_result_t lookupExtInst(spv_ext_inst_type_t type, const char* textValue, spv_ext_inst_desc* extInst) const; // Writes the extended operand with the given type and first encoded word // to the *extInst parameter. // Returns SPV_SUCCESS if the value could be found. spv_result_t lookupExtInst(spv_ext_inst_type_t type, uint32_t firstWord, spv_ext_inst_desc* extInst) const; // Inserts the operands expected after the given typed mask onto the end // of the given pattern. // // Each set bit in the mask represents zero or more operand types that // should be appended onto the pattern. Operands for a less significant // bit must always match before operands for a more significant bit, so // the operands for a less significant bit must appear closer to the end // of the pattern stack. // // If a set bit is unknown, then we assume it has no operands. void pushOperandTypesForMask(const spv_operand_type_t type, const uint32_t mask, spv_operand_pattern_t* pattern) const; private: const spv_target_env target_env_; const spv_operand_table operandTable_; const spv_opcode_table opcodeTable_; const spv_ext_inst_table extInstTable_; }; } // namespace spvtools #endif // SOURCE_ASSEMBLY_GRAMMAR_H_ KhronosGroup-SPIRV-Tools-f289d04/source/binary.cpp000066400000000000000000001125751475742701700220340ustar00rootroot00000000000000// Copyright (c) 2015-2020 The Khronos Group Inc. // Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights // reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/binary.h" #include #include #include #include #include #include #include #include #include "source/assembly_grammar.h" #include "source/diagnostic.h" #include "source/ext_inst.h" #include "source/latest_version_spirv_header.h" #include "source/opcode.h" #include "source/operand.h" #include "source/spirv_constant.h" #include "source/spirv_endian.h" #include "source/util/string_utils.h" spv_result_t spvBinaryHeaderGet(const spv_const_binary binary, const spv_endianness_t endian, spv_header_t* pHeader) { if (!binary->code) return SPV_ERROR_INVALID_BINARY; if (binary->wordCount < SPV_INDEX_INSTRUCTION) return SPV_ERROR_INVALID_BINARY; if (!pHeader) return SPV_ERROR_INVALID_POINTER; // TODO: Validation checking? pHeader->magic = spvFixWord(binary->code[SPV_INDEX_MAGIC_NUMBER], endian); pHeader->version = spvFixWord(binary->code[SPV_INDEX_VERSION_NUMBER], endian); // Per 2.3.1 version's high and low bytes are 0 if ((pHeader->version & 0x000000ff) || pHeader->version & 0xff000000) return SPV_ERROR_INVALID_BINARY; // Minimum version was 1.0 and max version is defined by SPV_VERSION. if (pHeader->version < SPV_SPIRV_VERSION_WORD(1, 0) || pHeader->version > SPV_VERSION) return SPV_ERROR_INVALID_BINARY; pHeader->generator = spvFixWord(binary->code[SPV_INDEX_GENERATOR_NUMBER], endian); pHeader->bound = spvFixWord(binary->code[SPV_INDEX_BOUND], endian); pHeader->schema = spvFixWord(binary->code[SPV_INDEX_SCHEMA], endian); pHeader->instructions = &binary->code[SPV_INDEX_INSTRUCTION]; return SPV_SUCCESS; } std::string spvDecodeLiteralStringOperand(const spv_parsed_instruction_t& inst, const uint16_t operand_index) { assert(operand_index < inst.num_operands); const spv_parsed_operand_t& operand = inst.operands[operand_index]; return spvtools::utils::MakeString(inst.words + operand.offset, operand.num_words); } namespace { // A SPIR-V binary parser. A parser instance communicates detailed parse // results via callbacks. class Parser { public: // The user_data value is provided to the callbacks as context. Parser(const spv_const_context context, void* user_data, spv_parsed_header_fn_t parsed_header_fn, spv_parsed_instruction_fn_t parsed_instruction_fn) : grammar_(context), consumer_(context->consumer), user_data_(user_data), parsed_header_fn_(parsed_header_fn), parsed_instruction_fn_(parsed_instruction_fn) {} // Parses the specified binary SPIR-V module, issuing callbacks on a parsed // header and for each parsed instruction. Returns SPV_SUCCESS on success. // Otherwise returns an error code and issues a diagnostic. spv_result_t parse(const uint32_t* words, size_t num_words, spv_diagnostic* diagnostic); private: // All remaining methods work on the current module parse state. // Like the parse method, but works on the current module parse state. spv_result_t parseModule(); // Parses an instruction at the current position of the binary. Assumes // the header has been parsed, the endian has been set, and the word index is // still in range. Advances the parsing position past the instruction, and // updates other parsing state for the current module. // On success, returns SPV_SUCCESS and issues the parsed-instruction callback. // On failure, returns an error code and issues a diagnostic. spv_result_t parseInstruction(); // Parses an instruction operand with the given type, for an instruction // starting at inst_offset words into the SPIR-V binary. // If the SPIR-V binary is the same endianness as the host, then the // endian_converted_inst_words parameter is ignored. Otherwise, this method // appends the words for this operand, converted to host native endianness, // to the end of endian_converted_inst_words. This method also updates the // expected_operands parameter, and the scalar members of the inst parameter. // On success, returns SPV_SUCCESS, advances past the operand, and pushes a // new entry on to the operands vector. Otherwise returns an error code and // issues a diagnostic. spv_result_t parseOperand(size_t inst_offset, spv_parsed_instruction_t* inst, const spv_operand_type_t type, std::vector* endian_converted_inst_words, std::vector* operands, spv_operand_pattern_t* expected_operands); // Records the numeric type for an operand according to the type information // associated with the given non-zero type Id. This can fail if the type Id // is not a type Id, or if the type Id does not reference a scalar numeric // type. On success, return SPV_SUCCESS and populates the num_words, // number_kind, and number_bit_width fields of parsed_operand. spv_result_t setNumericTypeInfoForType(spv_parsed_operand_t* parsed_operand, uint32_t type_id); // Records the number type for an instruction at the given offset, if that // instruction generates a type. For types that aren't scalar numbers, // record something with number kind SPV_NUMBER_NONE. void recordNumberType(size_t inst_offset, const spv_parsed_instruction_t* inst); // Returns a diagnostic stream object initialized with current position in // the input stream, and for the given error code. Any data written to the // returned object will be propagated to the current parse's diagnostic // object. spvtools::DiagnosticStream diagnostic(spv_result_t error) { return spvtools::DiagnosticStream({0, 0, _.instruction_count}, consumer_, "", error); } // Returns a diagnostic stream object with the default parse error code. spvtools::DiagnosticStream diagnostic() { // The default failure for parsing is invalid binary. return diagnostic(SPV_ERROR_INVALID_BINARY); } // Issues a diagnostic describing an exhaustion of input condition when // trying to decode an instruction operand, and returns // SPV_ERROR_INVALID_BINARY. spv_result_t exhaustedInputDiagnostic(size_t inst_offset, spv::Op opcode, spv_operand_type_t type) { return diagnostic() << "End of input reached while decoding Op" << spvOpcodeString(opcode) << " starting at word " << inst_offset << ((_.word_index < _.num_words) ? ": truncated " : ": missing ") << spvOperandTypeStr(type) << " operand at word offset " << _.word_index - inst_offset << "."; } // Returns the endian-corrected word at the current position. uint32_t peek() const { return peekAt(_.word_index); } // Returns the endian-corrected word at the given position. uint32_t peekAt(size_t index) const { assert(index < _.num_words); return spvFixWord(_.words[index], _.endian); } // Data members const spvtools::AssemblyGrammar grammar_; // SPIR-V syntax utility. const spvtools::MessageConsumer& consumer_; // Message consumer callback. void* const user_data_; // Context for the callbacks const spv_parsed_header_fn_t parsed_header_fn_; // Parsed header callback const spv_parsed_instruction_fn_t parsed_instruction_fn_; // Parsed instruction callback // Describes the format of a typed literal number. struct NumberType { spv_number_kind_t type; uint32_t bit_width; }; // The state used to parse a single SPIR-V binary module. struct State { State(const uint32_t* words_arg, size_t num_words_arg, spv_diagnostic* diagnostic_arg) : words(words_arg), num_words(num_words_arg), diagnostic(diagnostic_arg), word_index(0), instruction_count(0), endian(), requires_endian_conversion(false) { // Temporary storage for parser state within a single instruction. // Most instructions require fewer than 25 words or operands. operands.reserve(25); endian_converted_words.reserve(25); expected_operands.reserve(25); } State() : State(0, 0, nullptr) {} const uint32_t* words; // Words in the binary SPIR-V module. size_t num_words; // Number of words in the module. spv_diagnostic* diagnostic; // Where diagnostics go. size_t word_index; // The current position in words. size_t instruction_count; // The count of processed instructions spv_endianness_t endian; // The endianness of the binary. // Is the SPIR-V binary in a different endianness from the host native // endianness? bool requires_endian_conversion; // Maps a result ID to its type ID. By convention: // - a result ID that is a type definition maps to itself. // - a result ID without a type maps to 0. (E.g. for OpLabel) std::unordered_map id_to_type_id; // Maps a type ID to its number type description. std::unordered_map type_id_to_number_type_info; // Maps an ExtInstImport id to the extended instruction type. std::unordered_map import_id_to_ext_inst_type; // Used by parseOperand std::vector operands; std::vector endian_converted_words; spv_operand_pattern_t expected_operands; } _; }; spv_result_t Parser::parse(const uint32_t* words, size_t num_words, spv_diagnostic* diagnostic_arg) { _ = State(words, num_words, diagnostic_arg); const spv_result_t result = parseModule(); // Clear the module state. The tables might be big. _ = State(); return result; } spv_result_t Parser::parseModule() { if (!_.words) return diagnostic() << "Missing module."; if (_.num_words < SPV_INDEX_INSTRUCTION) return diagnostic() << "Module has incomplete header: only " << _.num_words << " words instead of " << SPV_INDEX_INSTRUCTION; // Check the magic number and detect the module's endianness. spv_const_binary_t binary{_.words, _.num_words}; if (spvBinaryEndianness(&binary, &_.endian)) { return diagnostic() << "Invalid SPIR-V magic number '" << std::hex << _.words[0] << "'."; } _.requires_endian_conversion = !spvIsHostEndian(_.endian); // Process the header. spv_header_t header; if (spvBinaryHeaderGet(&binary, _.endian, &header)) { // It turns out there is no way to trigger this error since the only // failure cases are already handled above, with better messages. return diagnostic(SPV_ERROR_INTERNAL) << "Internal error: unhandled header parse failure"; } if (parsed_header_fn_) { if (auto error = parsed_header_fn_(user_data_, _.endian, header.magic, header.version, header.generator, header.bound, header.schema)) { return error; } } // Process the instructions. _.word_index = SPV_INDEX_INSTRUCTION; while (_.word_index < _.num_words) if (auto error = parseInstruction()) return error; // Running off the end should already have been reported earlier. assert(_.word_index == _.num_words); return SPV_SUCCESS; } spv_result_t Parser::parseInstruction() { _.instruction_count++; // The zero values for all members except for opcode are the // correct initial values. spv_parsed_instruction_t inst = {}; const uint32_t first_word = peek(); // If the module's endianness is different from the host native endianness, // then converted_words contains the endian-translated words in the // instruction. _.endian_converted_words.clear(); _.endian_converted_words.push_back(first_word); // After a successful parse of the instruction, the inst.operands member // will point to this vector's storage. _.operands.clear(); assert(_.word_index < _.num_words); // Decompose and check the first word. uint16_t inst_word_count = 0; spvOpcodeSplit(first_word, &inst_word_count, &inst.opcode); if (inst_word_count < 1) { return diagnostic() << "Invalid instruction word count: " << inst_word_count; } spv_opcode_desc opcode_desc; if (grammar_.lookupOpcode(static_cast(inst.opcode), &opcode_desc)) return diagnostic() << "Invalid opcode: " << inst.opcode; // Advance past the opcode word. But remember the of the start // of the instruction. const size_t inst_offset = _.word_index; _.word_index++; // Maintains the ordered list of expected operand types. // For many instructions we only need the {numTypes, operandTypes} // entries in opcode_desc. However, sometimes we need to modify // the list as we parse the operands. This occurs when an operand // has its own logical operands (such as the LocalSize operand for // ExecutionMode), or for extended instructions that may have their // own operands depending on the selected extended instruction. _.expected_operands.clear(); for (auto i = 0; i < opcode_desc->numTypes; i++) _.expected_operands.push_back( opcode_desc->operandTypes[opcode_desc->numTypes - i - 1]); while (_.word_index < inst_offset + inst_word_count) { const uint16_t inst_word_index = uint16_t(_.word_index - inst_offset); if (_.expected_operands.empty()) { return diagnostic() << "Invalid instruction Op" << opcode_desc->name << " starting at word " << inst_offset << ": expected no more operands after " << inst_word_index << " words, but stated word count is " << inst_word_count << "."; } spv_operand_type_t type = spvTakeFirstMatchableOperand(&_.expected_operands); if (auto error = parseOperand(inst_offset, &inst, type, &_.endian_converted_words, &_.operands, &_.expected_operands)) { return error; } } if (!_.expected_operands.empty() && !spvOperandIsOptional(_.expected_operands.back())) { return diagnostic() << "End of input reached while decoding Op" << opcode_desc->name << " starting at word " << inst_offset << ": expected more operands after " << inst_word_count << " words."; } if ((inst_offset + inst_word_count) != _.word_index) { return diagnostic() << "Invalid word count: Op" << opcode_desc->name << " starting at word " << inst_offset << " says it has " << inst_word_count << " words, but found " << _.word_index - inst_offset << " words instead."; } // Check the computed length of the endian-converted words vector against // the declared number of words in the instruction. If endian conversion // is required, then they should match. If no endian conversion was // performed, then the vector only contains the initial opcode/word-count // word. assert(!_.requires_endian_conversion || (inst_word_count == _.endian_converted_words.size())); assert(_.requires_endian_conversion || (_.endian_converted_words.size() == 1)); recordNumberType(inst_offset, &inst); if (_.requires_endian_conversion) { // We must wait until here to set this pointer, because the vector might // have been be resized while we accumulated its elements. inst.words = _.endian_converted_words.data(); } else { // If no conversion is required, then just point to the underlying binary. // This saves time and space. inst.words = _.words + inst_offset; } inst.num_words = inst_word_count; // We must wait until here to set this pointer, because the vector might // have been be resized while we accumulated its elements. inst.operands = _.operands.data(); inst.num_operands = uint16_t(_.operands.size()); // Issue the callback. The callee should know that all the storage in inst // is transient, and will disappear immediately afterward. if (parsed_instruction_fn_) { if (auto error = parsed_instruction_fn_(user_data_, &inst)) return error; } return SPV_SUCCESS; } spv_result_t Parser::parseOperand(size_t inst_offset, spv_parsed_instruction_t* inst, const spv_operand_type_t type, std::vector* words, std::vector* operands, spv_operand_pattern_t* expected_operands) { const spv::Op opcode = static_cast(inst->opcode); // We'll fill in this result as we go along. spv_parsed_operand_t parsed_operand; parsed_operand.offset = uint16_t(_.word_index - inst_offset); // Most operands occupy one word. This might be be adjusted later. parsed_operand.num_words = 1; // The type argument is the one used by the grammar to parse the instruction. // But it can exposes internal parser details such as whether an operand is // optional or actually represents a variable-length sequence of operands. // The resulting type should be adjusted to avoid those internal details. // In most cases, the resulting operand type is the same as the grammar type. parsed_operand.type = type; // Assume non-numeric values. This will be updated for literal numbers. parsed_operand.number_kind = SPV_NUMBER_NONE; parsed_operand.number_bit_width = 0; if (_.word_index >= _.num_words) return exhaustedInputDiagnostic(inst_offset, opcode, type); const uint32_t word = peek(); // Do the words in this operand have to be converted to native endianness? // True for all but literal strings. bool convert_operand_endianness = true; switch (type) { case SPV_OPERAND_TYPE_TYPE_ID: if (!word) return diagnostic(SPV_ERROR_INVALID_ID) << "Error: Type Id is 0"; inst->type_id = word; break; case SPV_OPERAND_TYPE_RESULT_ID: if (!word) return diagnostic(SPV_ERROR_INVALID_ID) << "Error: Result Id is 0"; inst->result_id = word; // Save the result ID to type ID mapping. // In the grammar, type ID always appears before result ID. if (_.id_to_type_id.find(inst->result_id) != _.id_to_type_id.end()) return diagnostic(SPV_ERROR_INVALID_ID) << "Id " << inst->result_id << " is defined more than once"; // Record it. // A regular value maps to its type. Some instructions (e.g. OpLabel) // have no type Id, and will map to 0. The result Id for a // type-generating instruction (e.g. OpTypeInt) maps to itself. _.id_to_type_id[inst->result_id] = spvOpcodeGeneratesType(opcode) ? inst->result_id : inst->type_id; break; case SPV_OPERAND_TYPE_ID: case SPV_OPERAND_TYPE_OPTIONAL_ID: if (!word) return diagnostic(SPV_ERROR_INVALID_ID) << "Id is 0"; parsed_operand.type = SPV_OPERAND_TYPE_ID; if (spvIsExtendedInstruction(opcode) && parsed_operand.offset == 3) { // The current word is the extended instruction set Id. // Set the extended instruction set type for the current instruction. auto ext_inst_type_iter = _.import_id_to_ext_inst_type.find(word); if (ext_inst_type_iter == _.import_id_to_ext_inst_type.end()) { return diagnostic(SPV_ERROR_INVALID_ID) << "OpExtInst set Id " << word << " does not reference an OpExtInstImport result Id"; } inst->ext_inst_type = ext_inst_type_iter->second; } break; case SPV_OPERAND_TYPE_SCOPE_ID: case SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID: // Check for trivially invalid values. The operand descriptions already // have the word "ID" in them. if (!word) return diagnostic() << spvOperandTypeStr(type) << " is 0"; break; case SPV_OPERAND_TYPE_EXTENSION_INSTRUCTION_NUMBER: { assert(spvIsExtendedInstruction(opcode)); assert(inst->ext_inst_type != SPV_EXT_INST_TYPE_NONE); spv_ext_inst_desc ext_inst; if (grammar_.lookupExtInst(inst->ext_inst_type, word, &ext_inst) == SPV_SUCCESS) { // if we know about this ext inst, push the expected operands spvPushOperandTypes(ext_inst->operandTypes, expected_operands); } else { // if we don't know this extended instruction and the set isn't // non-semantic, we cannot process further if (!spvExtInstIsNonSemantic(inst->ext_inst_type)) { return diagnostic() << "Invalid extended instruction number: " << word; } else { // for non-semantic instruction sets, we know the form of all such // extended instructions contains a series of IDs as parameters expected_operands->push_back(SPV_OPERAND_TYPE_VARIABLE_ID); } } } break; case SPV_OPERAND_TYPE_SPEC_CONSTANT_OP_NUMBER: { assert(spv::Op::OpSpecConstantOp == opcode); if (word > static_cast(spv::Op::Max) || grammar_.lookupSpecConstantOpcode(spv::Op(word))) { return diagnostic() << "Invalid " << spvOperandTypeStr(type) << ": " << word; } spv_opcode_desc opcode_entry = nullptr; if (grammar_.lookupOpcode(spv::Op(word), &opcode_entry)) { return diagnostic(SPV_ERROR_INTERNAL) << "OpSpecConstant opcode table out of sync"; } // OpSpecConstant opcodes must have a type and result. We've already // processed them, so skip them when preparing to parse the other // operants for the opcode. assert(opcode_entry->hasType); assert(opcode_entry->hasResult); assert(opcode_entry->numTypes >= 2); spvPushOperandTypes(opcode_entry->operandTypes + 2, expected_operands); } break; case SPV_OPERAND_TYPE_LITERAL_INTEGER: case SPV_OPERAND_TYPE_OPTIONAL_LITERAL_INTEGER: // These are regular single-word literal integer operands. // Post-parsing validation should check the range of the parsed value. parsed_operand.type = SPV_OPERAND_TYPE_LITERAL_INTEGER; // It turns out they are always unsigned integers! parsed_operand.number_kind = SPV_NUMBER_UNSIGNED_INT; parsed_operand.number_bit_width = 32; break; case SPV_OPERAND_TYPE_LITERAL_FLOAT: // These are regular single-word literal float operands. parsed_operand.type = SPV_OPERAND_TYPE_LITERAL_FLOAT; parsed_operand.number_kind = SPV_NUMBER_FLOATING; parsed_operand.number_bit_width = 32; break; case SPV_OPERAND_TYPE_TYPED_LITERAL_NUMBER: case SPV_OPERAND_TYPE_OPTIONAL_TYPED_LITERAL_INTEGER: parsed_operand.type = SPV_OPERAND_TYPE_TYPED_LITERAL_NUMBER; if (opcode == spv::Op::OpSwitch) { // The literal operands have the same type as the value // referenced by the selector Id. const uint32_t selector_id = peekAt(inst_offset + 1); const auto type_id_iter = _.id_to_type_id.find(selector_id); if (type_id_iter == _.id_to_type_id.end() || type_id_iter->second == 0) { return diagnostic() << "Invalid OpSwitch: selector id " << selector_id << " has no type"; } uint32_t type_id = type_id_iter->second; if (selector_id == type_id) { // Recall that by convention, a result ID that is a type definition // maps to itself. return diagnostic() << "Invalid OpSwitch: selector id " << selector_id << " is a type, not a value"; } if (auto error = setNumericTypeInfoForType(&parsed_operand, type_id)) return error; if (parsed_operand.number_kind != SPV_NUMBER_UNSIGNED_INT && parsed_operand.number_kind != SPV_NUMBER_SIGNED_INT) { return diagnostic() << "Invalid OpSwitch: selector id " << selector_id << " is not a scalar integer"; } } else { assert(opcode == spv::Op::OpConstant || opcode == spv::Op::OpSpecConstant); // The literal number type is determined by the type Id for the // constant. assert(inst->type_id); if (auto error = setNumericTypeInfoForType(&parsed_operand, inst->type_id)) return error; } break; case SPV_OPERAND_TYPE_LITERAL_STRING: case SPV_OPERAND_TYPE_OPTIONAL_LITERAL_STRING: { const size_t max_words = _.num_words - _.word_index; std::string string = spvtools::utils::MakeString(_.words + _.word_index, max_words, false); if (string.length() == max_words * 4) return exhaustedInputDiagnostic(inst_offset, opcode, type); // Make sure we can record the word count without overflow. // // This error can't currently be triggered because of validity // checks elsewhere. const size_t string_num_words = string.length() / 4 + 1; if (string_num_words > std::numeric_limits::max()) { return diagnostic() << "Literal string is longer than " << std::numeric_limits::max() << " words: " << string_num_words << " words long"; } parsed_operand.num_words = uint16_t(string_num_words); parsed_operand.type = SPV_OPERAND_TYPE_LITERAL_STRING; if (spv::Op::OpExtInstImport == opcode) { // Record the extended instruction type for the ID for this import. // There is only one string literal argument to OpExtInstImport, // so it's sufficient to guard this just on the opcode. const spv_ext_inst_type_t ext_inst_type = spvExtInstImportTypeGet(string.c_str()); if (SPV_EXT_INST_TYPE_NONE == ext_inst_type) { return diagnostic() << "Invalid extended instruction import '" << string << "'"; } // We must have parsed a valid result ID. It's a condition // of the grammar, and we only accept non-zero result Ids. assert(inst->result_id); _.import_id_to_ext_inst_type[inst->result_id] = ext_inst_type; } } break; case SPV_OPERAND_TYPE_CAPABILITY: case SPV_OPERAND_TYPE_EXECUTION_MODEL: case SPV_OPERAND_TYPE_ADDRESSING_MODEL: case SPV_OPERAND_TYPE_MEMORY_MODEL: case SPV_OPERAND_TYPE_EXECUTION_MODE: case SPV_OPERAND_TYPE_STORAGE_CLASS: case SPV_OPERAND_TYPE_DIMENSIONALITY: case SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE: case SPV_OPERAND_TYPE_SAMPLER_FILTER_MODE: case SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT: case SPV_OPERAND_TYPE_FP_ROUNDING_MODE: case SPV_OPERAND_TYPE_LINKAGE_TYPE: case SPV_OPERAND_TYPE_ACCESS_QUALIFIER: case SPV_OPERAND_TYPE_OPTIONAL_ACCESS_QUALIFIER: case SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE: case SPV_OPERAND_TYPE_DECORATION: case SPV_OPERAND_TYPE_BUILT_IN: case SPV_OPERAND_TYPE_GROUP_OPERATION: case SPV_OPERAND_TYPE_KERNEL_ENQ_FLAGS: case SPV_OPERAND_TYPE_KERNEL_PROFILING_INFO: case SPV_OPERAND_TYPE_RAY_FLAGS: case SPV_OPERAND_TYPE_RAY_QUERY_INTERSECTION: case SPV_OPERAND_TYPE_RAY_QUERY_COMMITTED_INTERSECTION_TYPE: case SPV_OPERAND_TYPE_RAY_QUERY_CANDIDATE_INTERSECTION_TYPE: case SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING: case SPV_OPERAND_TYPE_DEBUG_COMPOSITE_TYPE: case SPV_OPERAND_TYPE_DEBUG_TYPE_QUALIFIER: case SPV_OPERAND_TYPE_DEBUG_OPERATION: case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING: case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_COMPOSITE_TYPE: case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_TYPE_QUALIFIER: case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION: case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_IMPORTED_ENTITY: case SPV_OPERAND_TYPE_FPDENORM_MODE: case SPV_OPERAND_TYPE_FPOPERATION_MODE: case SPV_OPERAND_TYPE_QUANTIZATION_MODES: case SPV_OPERAND_TYPE_OVERFLOW_MODES: case SPV_OPERAND_TYPE_PACKED_VECTOR_FORMAT: case SPV_OPERAND_TYPE_OPTIONAL_PACKED_VECTOR_FORMAT: case SPV_OPERAND_TYPE_FPENCODING: case SPV_OPERAND_TYPE_OPTIONAL_FPENCODING: case SPV_OPERAND_TYPE_HOST_ACCESS_QUALIFIER: case SPV_OPERAND_TYPE_LOAD_CACHE_CONTROL: case SPV_OPERAND_TYPE_STORE_CACHE_CONTROL: case SPV_OPERAND_TYPE_NAMED_MAXIMUM_NUMBER_OF_REGISTERS: { // A single word that is a plain enum value. // Map an optional operand type to its corresponding concrete type. if (type == SPV_OPERAND_TYPE_OPTIONAL_ACCESS_QUALIFIER) parsed_operand.type = SPV_OPERAND_TYPE_ACCESS_QUALIFIER; if (type == SPV_OPERAND_TYPE_OPTIONAL_PACKED_VECTOR_FORMAT) parsed_operand.type = SPV_OPERAND_TYPE_PACKED_VECTOR_FORMAT; if (type == SPV_OPERAND_TYPE_OPTIONAL_FPENCODING) parsed_operand.type = SPV_OPERAND_TYPE_FPENCODING; spv_operand_desc entry; if (grammar_.lookupOperand(type, word, &entry)) { return diagnostic() << "Invalid " << spvOperandTypeStr(parsed_operand.type) << " operand: " << word; } // Prepare to accept operands to this operand, if needed. spvPushOperandTypes(entry->operandTypes, expected_operands); } break; case SPV_OPERAND_TYPE_SOURCE_LANGUAGE: { spv_operand_desc entry; if (grammar_.lookupOperand(type, word, &entry)) { return diagnostic() << "Invalid " << spvOperandTypeStr(parsed_operand.type) << " operand: " << word << ", if you are creating a new source language please use " "value 0 " "(Unknown) and when ready, add your source language to " "SPIRV-Headers"; } // Prepare to accept operands to this operand, if needed. spvPushOperandTypes(entry->operandTypes, expected_operands); } break; case SPV_OPERAND_TYPE_FP_FAST_MATH_MODE: case SPV_OPERAND_TYPE_FUNCTION_CONTROL: case SPV_OPERAND_TYPE_LOOP_CONTROL: case SPV_OPERAND_TYPE_IMAGE: case SPV_OPERAND_TYPE_OPTIONAL_IMAGE: case SPV_OPERAND_TYPE_MEMORY_ACCESS: case SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS: case SPV_OPERAND_TYPE_OPTIONAL_RAW_ACCESS_CHAIN_OPERANDS: case SPV_OPERAND_TYPE_SELECTION_CONTROL: case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS: case SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS: case SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS: case SPV_OPERAND_TYPE_OPTIONAL_COOPERATIVE_MATRIX_OPERANDS: case SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_REDUCE: case SPV_OPERAND_TYPE_TENSOR_ADDRESSING_OPERANDS: case SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS: case SPV_OPERAND_TYPE_OPTIONAL_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS: { // This operand is a mask. // Map an optional operand type to its corresponding concrete type. if (type == SPV_OPERAND_TYPE_OPTIONAL_IMAGE) parsed_operand.type = SPV_OPERAND_TYPE_IMAGE; if (type == SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS) parsed_operand.type = SPV_OPERAND_TYPE_MEMORY_ACCESS; if (type == SPV_OPERAND_TYPE_OPTIONAL_COOPERATIVE_MATRIX_OPERANDS) parsed_operand.type = SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS; if (type == SPV_OPERAND_TYPE_OPTIONAL_RAW_ACCESS_CHAIN_OPERANDS) parsed_operand.type = SPV_OPERAND_TYPE_RAW_ACCESS_CHAIN_OPERANDS; if (type == SPV_OPERAND_TYPE_OPTIONAL_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS) parsed_operand.type = SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS; // Check validity of set mask bits. Also prepare for operands for those // masks if they have any. To get operand order correct, scan from // MSB to LSB since we can only prepend operands to a pattern. // The only case in the grammar where you have more than one mask bit // having an operand is for image operands. See SPIR-V 3.14 Image // Operands. uint32_t remaining_word = word; for (uint32_t mask = (1u << 31); remaining_word; mask >>= 1) { if (remaining_word & mask) { spv_operand_desc entry; if (grammar_.lookupOperand(type, mask, &entry)) { return diagnostic() << "Invalid " << spvOperandTypeStr(parsed_operand.type) << " operand: " << word << " has invalid mask component " << mask; } remaining_word ^= mask; spvPushOperandTypes(entry->operandTypes, expected_operands); } } if (word == 0) { // An all-zeroes mask *might* also be valid. spv_operand_desc entry; if (SPV_SUCCESS == grammar_.lookupOperand(type, 0, &entry)) { // Prepare for its operands, if any. spvPushOperandTypes(entry->operandTypes, expected_operands); } } } break; default: return diagnostic() << "Internal error: Unhandled operand type: " << type; } assert(spvOperandIsConcrete(parsed_operand.type)); operands->push_back(parsed_operand); const size_t index_after_operand = _.word_index + parsed_operand.num_words; // Avoid buffer overrun for the cases where the operand has more than one // word, and where it isn't a string. (Those other cases have already been // handled earlier.) For example, this error can occur for a multi-word // argument to OpConstant, or a multi-word case literal operand for OpSwitch. if (_.num_words < index_after_operand) return exhaustedInputDiagnostic(inst_offset, opcode, type); if (_.requires_endian_conversion) { // Copy instruction words. Translate to native endianness as needed. if (convert_operand_endianness) { const spv_endianness_t endianness = _.endian; std::transform(_.words + _.word_index, _.words + index_after_operand, std::back_inserter(*words), [endianness](const uint32_t raw_word) { return spvFixWord(raw_word, endianness); }); } else { words->insert(words->end(), _.words + _.word_index, _.words + index_after_operand); } } // Advance past the operand. _.word_index = index_after_operand; return SPV_SUCCESS; } spv_result_t Parser::setNumericTypeInfoForType( spv_parsed_operand_t* parsed_operand, uint32_t type_id) { assert(type_id != 0); auto type_info_iter = _.type_id_to_number_type_info.find(type_id); if (type_info_iter == _.type_id_to_number_type_info.end()) { return diagnostic() << "Type Id " << type_id << " is not a type"; } const NumberType& info = type_info_iter->second; if (info.type == SPV_NUMBER_NONE) { // This is a valid type, but for something other than a scalar number. return diagnostic() << "Type Id " << type_id << " is not a scalar numeric type"; } parsed_operand->number_kind = info.type; parsed_operand->number_bit_width = info.bit_width; // Round up the word count. parsed_operand->num_words = static_cast((info.bit_width + 31) / 32); return SPV_SUCCESS; } void Parser::recordNumberType(size_t inst_offset, const spv_parsed_instruction_t* inst) { const spv::Op opcode = static_cast(inst->opcode); if (spvOpcodeGeneratesType(opcode)) { NumberType info = {SPV_NUMBER_NONE, 0}; if (spv::Op::OpTypeInt == opcode) { const bool is_signed = peekAt(inst_offset + 3) != 0; info.type = is_signed ? SPV_NUMBER_SIGNED_INT : SPV_NUMBER_UNSIGNED_INT; info.bit_width = peekAt(inst_offset + 2); } else if (spv::Op::OpTypeFloat == opcode) { info.type = SPV_NUMBER_FLOATING; info.bit_width = peekAt(inst_offset + 2); } // The *result* Id of a type generating instruction is the type Id. _.type_id_to_number_type_info[inst->result_id] = info; } } } // anonymous namespace spv_result_t spvBinaryParse(const spv_const_context context, void* user_data, const uint32_t* code, const size_t num_words, spv_parsed_header_fn_t parsed_header, spv_parsed_instruction_fn_t parsed_instruction, spv_diagnostic* diagnostic) { spv_context_t hijack_context = *context; if (diagnostic) { *diagnostic = nullptr; spvtools::UseDiagnosticAsMessageConsumer(&hijack_context, diagnostic); } Parser parser(&hijack_context, user_data, parsed_header, parsed_instruction); return parser.parse(code, num_words, diagnostic); } // TODO(dneto): This probably belongs in text.cpp since that's the only place // that a spv_binary_t value is created. void spvBinaryDestroy(spv_binary binary) { if (binary) { if (binary->code) delete[] binary->code; delete binary; } } size_t spv_strnlen_s(const char* str, size_t strsz) { if (!str) return 0; for (size_t i = 0; i < strsz; i++) { if (!str[i]) return i; } return strsz; } KhronosGroup-SPIRV-Tools-f289d04/source/binary.h000066400000000000000000000034051475742701700214700ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_BINARY_H_ #define SOURCE_BINARY_H_ #include #include "source/spirv_definition.h" #include "spirv-tools/libspirv.h" // Functions // Grabs the header from the SPIR-V module given in the binary parameter. The // endian parameter specifies the endianness of the binary module. On success, // returns SPV_SUCCESS and writes the parsed header into *header. spv_result_t spvBinaryHeaderGet(const spv_const_binary binary, const spv_endianness_t endian, spv_header_t* header); // Returns the number of non-null characters in str before the first null // character, or strsz if there is no null character. Examines at most the // first strsz characters in str. Returns 0 if str is nullptr. This is a // replacement for C11's strnlen_s which might not exist in all environments. size_t spv_strnlen_s(const char* str, size_t strsz); // Decode the string literal operand with index operand_index from instruction // inst. std::string spvDecodeLiteralStringOperand(const spv_parsed_instruction_t& inst, const uint16_t operand_index); #endif // SOURCE_BINARY_H_ KhronosGroup-SPIRV-Tools-f289d04/source/cfa.h000066400000000000000000000401771475742701700207440ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_CFA_H_ #define SOURCE_CFA_H_ #include #include #include #include #include #include #include #include #include #include namespace spvtools { // Control Flow Analysis of control flow graphs of basic block nodes |BB|. template class CFA { using bb_ptr = BB*; using cbb_ptr = const BB*; using bb_iter = typename std::vector::const_iterator; using get_blocks_func = std::function*(const BB*)>; struct block_info { cbb_ptr block; ///< pointer to the block bb_iter iter; ///< Iterator to the current child node being processed }; /// Returns true if a block with @p id is found in the @p work_list vector /// /// @param[in] work_list Set of blocks visited in the depth first /// traversal /// of the CFG /// @param[in] id The ID of the block being checked /// /// @return true if the edge work_list.back().block->id() => id is a back-edge static bool FindInWorkList(const std::vector& work_list, uint32_t id); public: /// @brief Depth first traversal starting from the \p entry BasicBlock /// /// This function performs a depth first traversal from the \p entry /// BasicBlock and calls the pre/postorder functions when it needs to process /// the node in pre order, post order. /// /// @param[in] entry The root BasicBlock of a CFG /// @param[in] successor_func A function which will return a pointer to the /// successor nodes /// @param[in] preorder A function that will be called for every block in a /// CFG following preorder traversal semantics /// @param[in] postorder A function that will be called for every block in a /// CFG following postorder traversal semantics /// @param[in] terminal A function that will be called to determine if the /// search should stop at the given node. /// NOTE: The @p successor_func and predecessor_func each return a pointer to /// a collection such that iterators to that collection remain valid for the /// lifetime of the algorithm. static void DepthFirstTraversal(const BB* entry, get_blocks_func successor_func, std::function preorder, std::function postorder, std::function terminal); /// @brief Depth first traversal starting from the \p entry BasicBlock /// /// This function performs a depth first traversal from the \p entry /// BasicBlock and calls the pre/postorder functions when it needs to process /// the node in pre order, post order. It also calls the backedge function /// when a back edge is encountered. The backedge function can be empty. The /// runtime of the algorithm is improved if backedge is empty. /// /// @param[in] entry The root BasicBlock of a CFG /// @param[in] successor_func A function which will return a pointer to the /// successor nodes /// @param[in] preorder A function that will be called for every block in a /// CFG following preorder traversal semantics /// @param[in] postorder A function that will be called for every block in a /// CFG following postorder traversal semantics /// @param[in] backedge A function that will be called when a backedge is /// encountered during a traversal. /// @param[in] terminal A function that will be called to determine if the /// search should stop at the given node. /// NOTE: The @p successor_func and predecessor_func each return a pointer to /// a collection such that iterators to that collection remain valid for the /// lifetime of the algorithm. static void DepthFirstTraversal( const BB* entry, get_blocks_func successor_func, std::function preorder, std::function postorder, std::function backedge, std::function terminal); /// @brief Calculates dominator edges for a set of blocks /// /// Computes dominators using the algorithm of Cooper, Harvey, and Kennedy /// "A Simple, Fast Dominance Algorithm", 2001. /// /// The algorithm assumes there is a unique root node (a node without /// predecessors), and it is therefore at the end of the postorder vector. /// /// This function calculates the dominator edges for a set of blocks in the /// CFG. /// Uses the dominator algorithm by Cooper et al. /// /// @param[in] postorder A vector of blocks in post order traversal /// order /// in a CFG /// @param[in] predecessor_func Function used to get the predecessor nodes of /// a /// block /// /// @return the dominator tree of the graph, as a vector of pairs of nodes. /// The first node in the pair is a node in the graph. The second node in the /// pair is its immediate dominator in the sense of Cooper et.al., where a /// block /// without predecessors (such as the root node) is its own immediate /// dominator. static std::vector> CalculateDominators( const std::vector& postorder, get_blocks_func predecessor_func); // Computes a minimal set of root nodes required to traverse, in the forward // direction, the CFG represented by the given vector of blocks, and successor // and predecessor functions. When considering adding two nodes, each having // predecessors, favour using the one that appears earlier on the input blocks // list. static std::vector TraversalRoots(const std::vector& blocks, get_blocks_func succ_func, get_blocks_func pred_func); static void ComputeAugmentedCFG( std::vector& ordered_blocks, BB* pseudo_entry_block, BB* pseudo_exit_block, std::unordered_map>* augmented_successors_map, std::unordered_map>* augmented_predecessors_map, get_blocks_func succ_func, get_blocks_func pred_func); }; template bool CFA::FindInWorkList(const std::vector& work_list, uint32_t id) { for (const auto& b : work_list) { if (b.block->id() == id) return true; } return false; } template void CFA::DepthFirstTraversal(const BB* entry, get_blocks_func successor_func, std::function preorder, std::function postorder, std::function terminal) { DepthFirstTraversal(entry, successor_func, preorder, postorder, /* backedge = */ {}, terminal); } template void CFA::DepthFirstTraversal( const BB* entry, get_blocks_func successor_func, std::function preorder, std::function postorder, std::function backedge, std::function terminal) { assert(successor_func && "The successor function cannot be empty."); assert(preorder && "The preorder function cannot be empty."); assert(postorder && "The postorder function cannot be empty."); assert(terminal && "The terminal function cannot be empty."); std::unordered_set processed; /// NOTE: work_list is the sequence of nodes from the root node to the node /// being processed in the traversal std::vector work_list; work_list.reserve(10); work_list.push_back({entry, std::begin(*successor_func(entry))}); preorder(entry); processed.insert(entry->id()); while (!work_list.empty()) { block_info& top = work_list.back(); if (terminal(top.block) || top.iter == end(*successor_func(top.block))) { postorder(top.block); work_list.pop_back(); } else { BB* child = *top.iter; top.iter++; if (backedge && FindInWorkList(work_list, child->id())) { backedge(top.block, child); } if (processed.count(child->id()) == 0) { preorder(child); work_list.emplace_back( block_info{child, std::begin(*successor_func(child))}); processed.insert(child->id()); } } } } template std::vector> CFA::CalculateDominators( const std::vector& postorder, get_blocks_func predecessor_func) { struct block_detail { size_t dominator; ///< The index of blocks's dominator in post order array size_t postorder_index; ///< The index of the block in the post order array }; const size_t undefined_dom = postorder.size(); std::unordered_map idoms; for (size_t i = 0; i < postorder.size(); i++) { idoms[postorder[i]] = {undefined_dom, i}; } idoms[postorder.back()].dominator = idoms[postorder.back()].postorder_index; bool changed = true; while (changed) { changed = false; for (auto b = postorder.rbegin() + 1; b != postorder.rend(); ++b) { const std::vector& predecessors = *predecessor_func(*b); // Find the first processed/reachable predecessor that is reachable // in the forward traversal. auto res = std::find_if(std::begin(predecessors), std::end(predecessors), [&idoms, undefined_dom](BB* pred) { return idoms.count(pred) && idoms[pred].dominator != undefined_dom; }); if (res == end(predecessors)) continue; const BB* idom = *res; size_t idom_idx = idoms[idom].postorder_index; // all other predecessors for (const auto* p : predecessors) { if (idom == p) continue; // Only consider nodes reachable in the forward traversal. // Otherwise the intersection doesn't make sense and will never // terminate. if (!idoms.count(p)) continue; if (idoms[p].dominator != undefined_dom) { size_t finger1 = idoms[p].postorder_index; size_t finger2 = idom_idx; while (finger1 != finger2) { while (finger1 < finger2) { finger1 = idoms[postorder[finger1]].dominator; } while (finger2 < finger1) { finger2 = idoms[postorder[finger2]].dominator; } } idom_idx = finger1; } } if (idoms[*b].dominator != idom_idx) { idoms[*b].dominator = idom_idx; changed = true; } } } std::vector> out; for (auto idom : idoms) { // At this point if there is no dominator for the node, just make it // reflexive. auto dominator = std::get<1>(idom).dominator; if (dominator == undefined_dom) { dominator = std::get<1>(idom).postorder_index; } // NOTE: performing a const cast for convenient usage with // UpdateImmediateDominators out.push_back({const_cast(std::get<0>(idom)), const_cast(postorder[dominator])}); } // Sort by postorder index to generate a deterministic ordering of edges. std::sort( out.begin(), out.end(), [&idoms](const std::pair& lhs, const std::pair& rhs) { assert(lhs.first); assert(lhs.second); assert(rhs.first); assert(rhs.second); auto lhs_indices = std::make_pair(idoms[lhs.first].postorder_index, idoms[lhs.second].postorder_index); auto rhs_indices = std::make_pair(idoms[rhs.first].postorder_index, idoms[rhs.second].postorder_index); return lhs_indices < rhs_indices; }); return out; } template std::vector CFA::TraversalRoots(const std::vector& blocks, get_blocks_func succ_func, get_blocks_func pred_func) { // The set of nodes which have been visited from any of the roots so far. std::unordered_set visited; auto mark_visited = [&visited](const BB* b) { visited.insert(b); }; auto ignore_block = [](const BB*) {}; auto no_terminal_blocks = [](const BB*) { return false; }; auto traverse_from_root = [&mark_visited, &succ_func, &ignore_block, &no_terminal_blocks](const BB* entry) { DepthFirstTraversal(entry, succ_func, mark_visited, ignore_block, no_terminal_blocks); }; std::vector result; // First collect nodes without predecessors. for (auto block : blocks) { if (pred_func(block)->empty()) { assert(visited.count(block) == 0 && "Malformed graph!"); result.push_back(block); traverse_from_root(block); } } // Now collect other stranded nodes. These must be in unreachable cycles. for (auto block : blocks) { if (visited.count(block) == 0) { result.push_back(block); traverse_from_root(block); } } return result; } template void CFA::ComputeAugmentedCFG( std::vector& ordered_blocks, BB* pseudo_entry_block, BB* pseudo_exit_block, std::unordered_map>* augmented_successors_map, std::unordered_map>* augmented_predecessors_map, get_blocks_func succ_func, get_blocks_func pred_func) { // Compute the successors of the pseudo-entry block, and // the predecessors of the pseudo exit block. auto sources = TraversalRoots(ordered_blocks, succ_func, pred_func); // For the predecessor traversals, reverse the order of blocks. This // will affect the post-dominance calculation as follows: // - Suppose you have blocks A and B, with A appearing before B in // the list of blocks. // - Also, A branches only to B, and B branches only to A. // - We want to compute A as dominating B, and B as post-dominating B. // By using reversed blocks for predecessor traversal roots discovery, // we'll add an edge from B to the pseudo-exit node, rather than from A. // All this is needed to correctly process the dominance/post-dominance // constraint when A is a loop header that points to itself as its // own continue target, and B is the latch block for the loop. std::vector reversed_blocks(ordered_blocks.rbegin(), ordered_blocks.rend()); auto sinks = TraversalRoots(reversed_blocks, pred_func, succ_func); // Wire up the pseudo entry block. (*augmented_successors_map)[pseudo_entry_block] = sources; for (auto block : sources) { auto& augmented_preds = (*augmented_predecessors_map)[block]; const auto preds = pred_func(block); augmented_preds.reserve(1 + preds->size()); augmented_preds.push_back(pseudo_entry_block); augmented_preds.insert(augmented_preds.end(), preds->begin(), preds->end()); } // Wire up the pseudo exit block. (*augmented_predecessors_map)[pseudo_exit_block] = sinks; for (auto block : sinks) { auto& augmented_succ = (*augmented_successors_map)[block]; const auto succ = succ_func(block); augmented_succ.reserve(1 + succ->size()); augmented_succ.push_back(pseudo_exit_block); augmented_succ.insert(augmented_succ.end(), succ->begin(), succ->end()); } } } // namespace spvtools #endif // SOURCE_CFA_H_ KhronosGroup-SPIRV-Tools-f289d04/source/common_debug_info.h000066400000000000000000000051501475742701700236540ustar00rootroot00000000000000// Copyright (c) 2021 The Khronos Group Inc. // Copyright (c) 2021 Valve Corporation // Copyright (c) 2021 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_COMMON_DEBUG_INFO_HEADER_H_ #define SOURCE_COMMON_DEBUG_INFO_HEADER_H_ // This enum defines the known common set of instructions that are the same // between OpenCL.DebugInfo.100 and NonSemantic.Shader.DebugInfo.100. // Note that NonSemantic.Shader.* instructions can still have slightly // different encoding, as it does not use literals anywhere and only constants. enum CommonDebugInfoInstructions { CommonDebugInfoDebugInfoNone = 0, CommonDebugInfoDebugCompilationUnit = 1, CommonDebugInfoDebugTypeBasic = 2, CommonDebugInfoDebugTypePointer = 3, CommonDebugInfoDebugTypeQualifier = 4, CommonDebugInfoDebugTypeArray = 5, CommonDebugInfoDebugTypeVector = 6, CommonDebugInfoDebugTypedef = 7, CommonDebugInfoDebugTypeFunction = 8, CommonDebugInfoDebugTypeEnum = 9, CommonDebugInfoDebugTypeComposite = 10, CommonDebugInfoDebugTypeMember = 11, CommonDebugInfoDebugTypeInheritance = 12, CommonDebugInfoDebugTypePtrToMember = 13, CommonDebugInfoDebugTypeTemplate = 14, CommonDebugInfoDebugTypeTemplateParameter = 15, CommonDebugInfoDebugTypeTemplateTemplateParameter = 16, CommonDebugInfoDebugTypeTemplateParameterPack = 17, CommonDebugInfoDebugGlobalVariable = 18, CommonDebugInfoDebugFunctionDeclaration = 19, CommonDebugInfoDebugFunction = 20, CommonDebugInfoDebugLexicalBlock = 21, CommonDebugInfoDebugLexicalBlockDiscriminator = 22, CommonDebugInfoDebugScope = 23, CommonDebugInfoDebugNoScope = 24, CommonDebugInfoDebugInlinedAt = 25, CommonDebugInfoDebugLocalVariable = 26, CommonDebugInfoDebugInlinedVariable = 27, CommonDebugInfoDebugDeclare = 28, CommonDebugInfoDebugValue = 29, CommonDebugInfoDebugOperation = 30, CommonDebugInfoDebugExpression = 31, CommonDebugInfoDebugMacroDef = 32, CommonDebugInfoDebugMacroUndef = 33, CommonDebugInfoDebugImportedEntity = 34, CommonDebugInfoDebugSource = 35, CommonDebugInfoInstructionsMax = 0x7ffffff }; #endif // SOURCE_COMMON_DEBUG_INFO_HEADER_H_ KhronosGroup-SPIRV-Tools-f289d04/source/diagnostic.cpp000066400000000000000000000133471475742701700226710ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/diagnostic.h" #include #include #include #include #include #include "source/table.h" // Diagnostic API spv_diagnostic spvDiagnosticCreate(const spv_position position, const char* message) { spv_diagnostic diagnostic = new spv_diagnostic_t; if (!diagnostic) return nullptr; size_t length = strlen(message) + 1; diagnostic->error = new char[length]; if (!diagnostic->error) { delete diagnostic; return nullptr; } diagnostic->position = *position; diagnostic->isTextSource = false; memset(diagnostic->error, 0, length); strcpy(diagnostic->error, message); return diagnostic; } void spvDiagnosticDestroy(spv_diagnostic diagnostic) { if (!diagnostic) return; delete[] diagnostic->error; delete diagnostic; } spv_result_t spvDiagnosticPrint(const spv_diagnostic diagnostic) { if (!diagnostic) return SPV_ERROR_INVALID_DIAGNOSTIC; if (diagnostic->isTextSource) { // NOTE: This is a text position // NOTE: add 1 to the line as editors start at line 1, we are counting new // line characters to start at line 0 std::cerr << "error: " << diagnostic->position.line + 1 << ": " << diagnostic->position.column + 1 << ": " << diagnostic->error << "\n"; return SPV_SUCCESS; } // NOTE: Assume this is a binary position std::cerr << "error: "; if (diagnostic->position.index > 0) std::cerr << diagnostic->position.index << ": "; std::cerr << diagnostic->error << "\n"; return SPV_SUCCESS; } namespace spvtools { DiagnosticStream::DiagnosticStream(DiagnosticStream&& other) : stream_(), position_(other.position_), consumer_(other.consumer_), disassembled_instruction_(std::move(other.disassembled_instruction_)), error_(other.error_) { // Prevent the other object from emitting output during destruction. other.error_ = SPV_FAILED_MATCH; // Some platforms are missing support for std::ostringstream functionality, // including: move constructor, swap method. Either would have been a // better choice than copying the string. stream_ << other.stream_.str(); } DiagnosticStream::~DiagnosticStream() { if (error_ != SPV_FAILED_MATCH && consumer_ != nullptr) { auto level = SPV_MSG_ERROR; switch (error_) { case SPV_SUCCESS: case SPV_REQUESTED_TERMINATION: // Essentially success. level = SPV_MSG_INFO; break; case SPV_WARNING: level = SPV_MSG_WARNING; break; case SPV_UNSUPPORTED: case SPV_ERROR_INTERNAL: case SPV_ERROR_INVALID_TABLE: level = SPV_MSG_INTERNAL_ERROR; break; case SPV_ERROR_OUT_OF_MEMORY: level = SPV_MSG_FATAL; break; default: break; } if (disassembled_instruction_.size() > 0) stream_ << std::endl << " " << disassembled_instruction_ << std::endl; consumer_(level, "input", position_, stream_.str().c_str()); } } void UseDiagnosticAsMessageConsumer(spv_context context, spv_diagnostic* diagnostic) { assert(diagnostic && *diagnostic == nullptr); auto create_diagnostic = [diagnostic](spv_message_level_t, const char*, const spv_position_t& position, const char* message) { auto p = position; spvDiagnosticDestroy(*diagnostic); // Avoid memory leak. *diagnostic = spvDiagnosticCreate(&p, message); }; SetContextMessageConsumer(context, std::move(create_diagnostic)); } std::string spvResultToString(spv_result_t res) { std::string out; switch (res) { case SPV_SUCCESS: out = "SPV_SUCCESS"; break; case SPV_UNSUPPORTED: out = "SPV_UNSUPPORTED"; break; case SPV_END_OF_STREAM: out = "SPV_END_OF_STREAM"; break; case SPV_WARNING: out = "SPV_WARNING"; break; case SPV_FAILED_MATCH: out = "SPV_FAILED_MATCH"; break; case SPV_REQUESTED_TERMINATION: out = "SPV_REQUESTED_TERMINATION"; break; case SPV_ERROR_INTERNAL: out = "SPV_ERROR_INTERNAL"; break; case SPV_ERROR_OUT_OF_MEMORY: out = "SPV_ERROR_OUT_OF_MEMORY"; break; case SPV_ERROR_INVALID_POINTER: out = "SPV_ERROR_INVALID_POINTER"; break; case SPV_ERROR_INVALID_BINARY: out = "SPV_ERROR_INVALID_BINARY"; break; case SPV_ERROR_INVALID_TEXT: out = "SPV_ERROR_INVALID_TEXT"; break; case SPV_ERROR_INVALID_TABLE: out = "SPV_ERROR_INVALID_TABLE"; break; case SPV_ERROR_INVALID_VALUE: out = "SPV_ERROR_INVALID_VALUE"; break; case SPV_ERROR_INVALID_DIAGNOSTIC: out = "SPV_ERROR_INVALID_DIAGNOSTIC"; break; case SPV_ERROR_INVALID_LOOKUP: out = "SPV_ERROR_INVALID_LOOKUP"; break; case SPV_ERROR_INVALID_ID: out = "SPV_ERROR_INVALID_ID"; break; case SPV_ERROR_INVALID_CFG: out = "SPV_ERROR_INVALID_CFG"; break; case SPV_ERROR_INVALID_LAYOUT: out = "SPV_ERROR_INVALID_LAYOUT"; break; default: out = "Unknown Error"; } return out; } } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/diagnostic.h000066400000000000000000000052441475742701700223330ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_DIAGNOSTIC_H_ #define SOURCE_DIAGNOSTIC_H_ #include #include #include "spirv-tools/libspirv.hpp" namespace spvtools { // A DiagnosticStream remembers the current position of the input and an error // code, and captures diagnostic messages via the left-shift operator. // If the error code is not SPV_FAILED_MATCH, then captured messages are // emitted during the destructor. class DiagnosticStream { public: DiagnosticStream(spv_position_t position, const MessageConsumer& consumer, const std::string& disassembled_instruction, spv_result_t error) : position_(position), consumer_(consumer), disassembled_instruction_(disassembled_instruction), error_(error) {} // Creates a DiagnosticStream from an expiring DiagnosticStream. // The new object takes the contents of the other, and prevents the // other from emitting anything during destruction. DiagnosticStream(DiagnosticStream&& other); // Destroys a DiagnosticStream. // If its status code is something other than SPV_FAILED_MATCH // then emit the accumulated message to the consumer. ~DiagnosticStream(); // Adds the given value to the diagnostic message to be written. template DiagnosticStream& operator<<(const T& val) { stream_ << val; return *this; } // Conversion operator to spv_result, returning the error code. operator spv_result_t() { return error_; } private: std::ostringstream stream_; spv_position_t position_; MessageConsumer consumer_; // Message consumer callback. std::string disassembled_instruction_; spv_result_t error_; }; // Changes the MessageConsumer in |context| to one that updates |diagnostic| // with the last message received. // // This function expects that |diagnostic| is not nullptr and its content is a // nullptr. void UseDiagnosticAsMessageConsumer(spv_context context, spv_diagnostic* diagnostic); std::string spvResultToString(spv_result_t res); } // namespace spvtools #endif // SOURCE_DIAGNOSTIC_H_ KhronosGroup-SPIRV-Tools-f289d04/source/diff/000077500000000000000000000000001475742701700207415ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/diff/CMakeLists.txt000066400000000000000000000036131475742701700235040ustar00rootroot00000000000000# Copyright (c) 2022 Google LLC. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. set(SPIRV_TOOLS_DIFF_SOURCES diff.h lcs.h diff.cpp ) add_library(SPIRV-Tools-diff ${SPIRV_TOOLS_LIBRARY_TYPE} ${SPIRV_TOOLS_DIFF_SOURCES}) spvtools_default_compile_options(SPIRV-Tools-diff) target_include_directories(SPIRV-Tools-diff PUBLIC $ $ $ PRIVATE ${spirv-tools_BINARY_DIR} ) # We need the assembling and disassembling functionalities in the main library. target_link_libraries(SPIRV-Tools-diff PUBLIC ${SPIRV_TOOLS_FULL_VISIBILITY}) # We need the internals of spirv-opt. target_link_libraries(SPIRV-Tools-diff PUBLIC SPIRV-Tools-opt) set_property(TARGET SPIRV-Tools-diff PROPERTY FOLDER "SPIRV-Tools libraries") spvtools_check_symbol_exports(SPIRV-Tools-diff) if(ENABLE_SPIRV_TOOLS_INSTALL) install(TARGETS SPIRV-Tools-diff EXPORT SPIRV-Tools-diffTargets) export(EXPORT SPIRV-Tools-diffTargets FILE SPIRV-Tools-diffTargets.cmake) spvtools_config_package_dir(SPIRV-Tools-diff PACKAGE_DIR) install(EXPORT SPIRV-Tools-diffTargets FILE SPIRV-Tools-diffTargets.cmake DESTINATION ${PACKAGE_DIR}) spvtools_generate_config_file(SPIRV-Tools-diff) install(FILES ${CMAKE_BINARY_DIR}/SPIRV-Tools-diffConfig.cmake DESTINATION ${PACKAGE_DIR}) endif(ENABLE_SPIRV_TOOLS_INSTALL) KhronosGroup-SPIRV-Tools-f289d04/source/diff/diff.cpp000066400000000000000000003344571475742701700223750ustar00rootroot00000000000000// Copyright (c) 2022 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/diff/diff.h" #include "source/diff/lcs.h" #include "source/disassemble.h" #include "source/ext_inst.h" #include "source/latest_version_spirv_header.h" #include "source/print.h" #include "spirv-tools/libspirv.hpp" namespace spvtools { namespace diff { namespace { // A map from an id to the instruction that defines it. using IdToInstructionMap = std::vector; // A map from an id to the instructions that decorate it, or name it, etc. using IdToInfoMap = std::vector>; // A map from an instruction to another, used for instructions without id. using InstructionToInstructionMap = std::unordered_map; // A flat list of instructions in a function for easier iteration. using InstructionList = std::vector; // A map from a function to its list of instructions. using FunctionInstMap = std::map; // A list of ids with some similar property, for example functions with the same // name. using IdGroup = std::vector; // A map of names to ids with the same name. This is an ordered map so // different implementations produce identical results. using IdGroupMapByName = std::map; using IdGroupMapByTypeId = std::map; using IdGroupMapByOp = std::map; using IdGroupMapByStorageClass = std::map; // A set of potential id mappings that haven't been resolved yet. Any id in src // may map in any id in dst. Note that ids are added in the same order as they // appear in src and dst to facilitate matching dependent instructions. For // example, this guarantees that when matching OpTypeVector, the basic type of // the vector is already (potentially) matched. struct PotentialIdMap { std::vector src_ids; std::vector dst_ids; }; void CompactIds(std::vector& ids) { size_t write_index = 0; for (size_t i = 0; i < ids.size(); ++i) { if (ids[i] != 0) { ids[write_index++] = ids[i]; } } ids.resize(write_index); } // A mapping between src and dst ids. class IdMap { public: IdMap(size_t id_bound) { id_map_.resize(id_bound, 0); } void MapIds(uint32_t from, uint32_t to) { assert(from != 0); assert(to != 0); assert(from < id_map_.size()); assert(id_map_[from] == 0); id_map_[from] = to; } uint32_t MappedId(uint32_t from) const { assert(from != 0); return from < id_map_.size() ? id_map_[from] : 0; } const opt::Instruction* MappedInst(const opt::Instruction* from_inst) const { assert(from_inst != nullptr); assert(!from_inst->HasResultId()); auto mapped = inst_map_.find(from_inst); if (mapped == inst_map_.end()) { return nullptr; } return mapped->second; } bool IsMapped(uint32_t from) const { assert(from != 0); return from < id_map_.size() && id_map_[from] != 0; } bool IsMapped(const opt::Instruction* from_inst) const { assert(from_inst != nullptr); assert(!from_inst->HasResultId()); return inst_map_.find(from_inst) != inst_map_.end(); } // Some instructions don't have result ids. Those are mapped by pointer. void MapInsts(const opt::Instruction* from_inst, const opt::Instruction* to_inst) { assert(from_inst != nullptr); assert(to_inst != nullptr); assert(inst_map_.find(from_inst) == inst_map_.end()); inst_map_[from_inst] = to_inst; } uint32_t IdBound() const { return static_cast(id_map_.size()); } // Generate a fresh id in this mapping's domain. uint32_t MakeFreshId() { id_map_.push_back(0); return static_cast(id_map_.size()) - 1; } private: // Given an id, returns the corresponding id in the other module, or 0 if not // matched yet. std::vector id_map_; // Same for instructions that don't have an id. InstructionToInstructionMap inst_map_; }; // Two way mapping of ids. class SrcDstIdMap { public: SrcDstIdMap(size_t src_id_bound, size_t dst_id_bound) : src_to_dst_(src_id_bound), dst_to_src_(dst_id_bound) {} void MapIds(uint32_t src, uint32_t dst) { src_to_dst_.MapIds(src, dst); dst_to_src_.MapIds(dst, src); } uint32_t MappedDstId(uint32_t src) { uint32_t dst = src_to_dst_.MappedId(src); assert(dst == 0 || dst_to_src_.MappedId(dst) == src); return dst; } uint32_t MappedSrcId(uint32_t dst) { uint32_t src = dst_to_src_.MappedId(dst); assert(src == 0 || src_to_dst_.MappedId(src) == dst); return src; } bool IsSrcMapped(uint32_t src) { return src_to_dst_.IsMapped(src); } bool IsDstMapped(uint32_t dst) { return dst_to_src_.IsMapped(dst); } bool IsDstMapped(const opt::Instruction* dst_inst) { return dst_to_src_.IsMapped(dst_inst); } // Map any ids in src and dst that have not been mapped to new ids in dst and // src respectively. Use src_insn_defined and dst_insn_defined to ignore ids // that are simply never defined. (Since we assume the inputs are valid // SPIR-V, this implies they are also never used.) void MapUnmatchedIds(std::function src_insn_defined, std::function dst_insn_defined); // Some instructions don't have result ids. Those are mapped by pointer. void MapInsts(const opt::Instruction* src_inst, const opt::Instruction* dst_inst) { assert(src_inst->HasResultId() == dst_inst->HasResultId()); if (src_inst->HasResultId()) { MapIds(src_inst->result_id(), dst_inst->result_id()); } else { src_to_dst_.MapInsts(src_inst, dst_inst); dst_to_src_.MapInsts(dst_inst, src_inst); } } const IdMap& SrcToDstMap() const { return src_to_dst_; } const IdMap& DstToSrcMap() const { return dst_to_src_; } private: IdMap src_to_dst_; IdMap dst_to_src_; }; struct IdInstructions { IdInstructions(const opt::Module* module) : inst_map_(module->IdBound(), nullptr), name_map_(module->IdBound()), decoration_map_(module->IdBound()), forward_pointer_map_(module->IdBound()) { // Map ids from all sections to instructions that define them. MapIdsToInstruction(module->ext_inst_imports()); MapIdsToInstruction(module->debugs1()); MapIdsToInstruction(module->debugs2()); MapIdsToInstruction(module->debugs3()); MapIdsToInstruction(module->ext_inst_debuginfo()); MapIdsToInstruction(module->types_values()); for (const opt::Function& function : *module) { function.ForEachInst( [this](const opt::Instruction* inst) { if (inst->HasResultId()) { MapIdToInstruction(inst->result_id(), inst); } }, true, true); } // Gather decorations applied to ids that could be useful in matching them // between src and dst modules. MapIdsToInfos(module->debugs2()); MapIdsToInfos(module->annotations()); MapIdsToInfos(module->types_values()); } void MapIdToInstruction(uint32_t id, const opt::Instruction* inst); // Return true if id is mapped to any instruction, false otherwise. bool IsDefined(uint32_t id) { return id < inst_map_.size() && inst_map_[id] != nullptr; } void MapIdsToInstruction( opt::IteratorRange section); void MapIdsToInfos( opt::IteratorRange section); IdToInstructionMap inst_map_; IdToInfoMap name_map_; IdToInfoMap decoration_map_; IdToInstructionMap forward_pointer_map_; }; class Differ { public: Differ(opt::IRContext* src, opt::IRContext* dst, std::ostream& out, Options options) : src_context_(src), dst_context_(dst), src_(src->module()), dst_(dst->module()), options_(options), out_(out), src_id_to_(src_), dst_id_to_(dst_), id_map_(src_->IdBound(), dst_->IdBound()) { // Cache function bodies in canonicalization order. GetFunctionBodies(src_context_, &src_funcs_, &src_func_insts_); GetFunctionBodies(dst_context_, &dst_funcs_, &dst_func_insts_); } // Match ids or instructions of different sections. void MatchCapabilities(); void MatchExtensions(); void MatchExtInstImportIds(); void MatchMemoryModel(); void MatchEntryPointIds(); void MatchExecutionModes(); void MatchTypeForwardPointers(); void MatchTypeIds(); void MatchConstants(); void MatchVariableIds(); void MatchFunctions(); // Debug info and annotations are matched only after ids are matched. void MatchDebugs1(); void MatchDebugs2(); void MatchDebugs3(); void MatchExtInstDebugInfo(); void MatchAnnotations(); // Output the diff. spv_result_t Output(); void DumpIdMap() { if (!options_.dump_id_map) { return; } out_ << " Src -> Dst\n"; for (uint32_t src_id = 1; src_id < src_->IdBound(); ++src_id) { uint32_t dst_id = id_map_.MappedDstId(src_id); if (src_id_to_.inst_map_[src_id] != nullptr && dst_id != 0) out_ << std::setw(4) << src_id << " -> " << std::setw(4) << dst_id << " [" << spvOpcodeString(src_id_to_.inst_map_[src_id]->opcode()) << "]\n"; } } private: // Helper functions that match ids between src and dst void PoolPotentialIds( opt::IteratorRange section, std::vector& ids, bool is_src, std::function filter, std::function get_id); void MatchIds( PotentialIdMap& potential, std::function match); // Helper functions that match id-less instructions between src and dst. void MatchPreambleInstructions( opt::IteratorRange src_insts, opt::IteratorRange dst_insts); InstructionList SortPreambleInstructions( const opt::Module* module, opt::IteratorRange insts); int ComparePreambleInstructions(const opt::Instruction* a, const opt::Instruction* b, const opt::Module* src_inst_module, const opt::Module* dst_inst_module); // Helper functions that match debug and annotation instructions of already // matched ids. void MatchDebugAndAnnotationInstructions( opt::IteratorRange src_insts, opt::IteratorRange dst_insts); // Get various properties from an id. These Helper functions are passed to // `GroupIds` and `GroupIdsAndMatch` below (as the `get_group` argument). uint32_t GroupIdsHelperGetTypeId(const IdInstructions& id_to, uint32_t id); spv::StorageClass GroupIdsHelperGetTypePointerStorageClass( const IdInstructions& id_to, uint32_t id); spv::Op GroupIdsHelperGetTypePointerTypeOp(const IdInstructions& id_to, uint32_t id); // Given a list of ids, groups them based on some value. The `get_group` // function extracts a piece of information corresponding to each id, and the // ids are bucketed based on that (and output in `groups`). This is useful to // attempt to match ids between src and dst only when said property is // identical. template void GroupIds(const IdGroup& ids, bool is_src, std::map* groups, T (Differ::*get_group)(const IdInstructions&, uint32_t)); // Calls GroupIds to bucket ids in src and dst based on a property returned by // `get_group`. This function then calls `match_group` for each bucket (i.e. // "group") with identical values for said property. // // For example, say src and dst ids have the following properties // correspondingly: // // - src ids' properties: {id0: A, id1: A, id2: B, id3: C, id4: B} // - dst ids' properties: {id0': B, id1': C, id2': B, id3': D, id4': B} // // Then `match_group` is called 2 times: // // - Once with: ([id2, id4], [id0', id2', id4']) corresponding to B // - Once with: ([id3], [id2']) corresponding to C // // Ids corresponding to A and D cannot match based on this property. template void GroupIdsAndMatch( const IdGroup& src_ids, const IdGroup& dst_ids, T invalid_group_key, T (Differ::*get_group)(const IdInstructions&, uint32_t), std::function match_group); // Bucket `src_ids` and `dst_ids` by the key ids returned by `get_group`, and // then call `match_group` on pairs of buckets whose key ids are matched with // each other. // // For example, suppose we want to pair up groups of instructions with the // same type. Naturally, the source instructions refer to their types by their // ids in the source, and the destination instructions use destination type // ids, so simply comparing source and destination type ids as integers, as // `GroupIdsAndMatch` would do, is meaningless. But if a prior call to // `MatchTypeIds` has established type matches between the two modules, then // we can consult those to pair source and destination buckets whose types are // equivalent. // // Suppose our input groups are as follows: // // - src_ids: { 1 -> 100, 2 -> 300, 3 -> 100, 4 -> 200 } // - dst_ids: { 5 -> 10, 6 -> 20, 7 -> 10, 8 -> 300 } // // Here, `X -> Y` means that the instruction with SPIR-V id `X` is a member of // the group, and `Y` is the id of its type. If we use // `Differ::GroupIdsHelperGetTypeId` for `get_group`, then // `get_group(X) == Y`. // // These instructions are bucketed by type as follows: // // - source: [1, 3] -> 100 // [4] -> 200 // [2] -> 300 // // - destination: [5, 7] -> 10 // [6] -> 20 // [8] -> 300 // // Now suppose that we have previously matched up src type 100 with dst type // 10, and src type 200 with dst type 20, but no other types are matched. // // Then `match_group` is called twice: // - Once with ([1,3], [5, 7]), corresponding to 100/10 // - Once with ([4],[6]), corresponding to 200/20 // // The source type 300 isn't matched with anything, so the fact that there's a // destination type 300 is irrelevant, and thus 2 and 8 are never passed to // `match_group`. // // This function isn't specific to types; it simply buckets by the ids // returned from `get_group`, and consults existing matches to pair up the // resulting buckets. void GroupIdsAndMatchByMappedId( const IdGroup& src_ids, const IdGroup& dst_ids, uint32_t (Differ::*get_group)(const IdInstructions&, uint32_t), std::function match_group); // Helper functions that determine if two instructions match bool DoIdsMatch(uint32_t src_id, uint32_t dst_id); bool DoesOperandMatch(const opt::Operand& src_operand, const opt::Operand& dst_operand); bool DoOperandsMatch(const opt::Instruction* src_inst, const opt::Instruction* dst_inst, uint32_t in_operand_index_start, uint32_t in_operand_count); bool DoInstructionsMatch(const opt::Instruction* src_inst, const opt::Instruction* dst_inst); bool DoIdsMatchFuzzy(uint32_t src_id, uint32_t dst_id); bool DoesOperandMatchFuzzy(const opt::Operand& src_operand, const opt::Operand& dst_operand); bool DoInstructionsMatchFuzzy(const opt::Instruction* src_inst, const opt::Instruction* dst_inst); bool AreIdenticalUintConstants(uint32_t src_id, uint32_t dst_id); bool DoDebugAndAnnotationInstructionsMatch(const opt::Instruction* src_inst, const opt::Instruction* dst_inst); bool AreVariablesMatchable(uint32_t src_id, uint32_t dst_id, uint32_t flexibility); bool MatchOpTypeStruct(const opt::Instruction* src_inst, const opt::Instruction* dst_inst, uint32_t flexibility); bool MatchOpConstant(const opt::Instruction* src_inst, const opt::Instruction* dst_inst, uint32_t flexibility); bool MatchOpSpecConstant(const opt::Instruction* src_inst, const opt::Instruction* dst_inst); bool MatchOpVariable(const opt::Instruction* src_inst, const opt::Instruction* dst_inst, uint32_t flexibility); bool MatchPerVertexType(uint32_t src_type_id, uint32_t dst_type_id); bool MatchPerVertexVariable(const opt::Instruction* src_inst, const opt::Instruction* dst_inst); // Helper functions for matching OpTypeForwardPointer void MatchTypeForwardPointersByName(const IdGroup& src, const IdGroup& dst); void MatchTypeForwardPointersByTypeOp(const IdGroup& src, const IdGroup& dst); // Helper functions for function matching. using FunctionMap = std::map; InstructionList GetFunctionBody(opt::IRContext* context, opt::Function& function); InstructionList GetFunctionHeader(const opt::Function& function); void GetFunctionBodies(opt::IRContext* context, FunctionMap* functions, FunctionInstMap* function_insts); void GetFunctionHeaderInstructions(const opt::Module* module, FunctionInstMap* function_insts); void BestEffortMatchFunctions(const IdGroup& src_func_ids, const IdGroup& dst_func_ids, const FunctionInstMap& src_func_insts, const FunctionInstMap& dst_func_insts); // Calculates the diff of two function bodies. Note that the matched // instructions themselves may not be identical; output of exact matches // should produce the exact instruction while inexact matches should produce a // diff as well. // // Returns the similarity of the two bodies = 2*N_match / (N_src + N_dst) void MatchFunctionParamIds(const opt::Function* src_func, const opt::Function* dst_func); float MatchFunctionBodies(const InstructionList& src_body, const InstructionList& dst_body, DiffMatch* src_match_result, DiffMatch* dst_match_result); void MatchIdsInFunctionBodies(const InstructionList& src_body, const InstructionList& dst_body, const DiffMatch& src_match_result, const DiffMatch& dst_match_result, uint32_t flexibility); void MatchVariablesUsedByMatchedInstructions(const opt::Instruction* src_inst, const opt::Instruction* dst_inst, uint32_t flexibility); // Helper functions to retrieve information pertaining to an id const opt::Instruction* GetInst(const IdInstructions& id_to, uint32_t id); uint32_t GetConstantUint(const IdInstructions& id_to, uint32_t constant_id); spv::ExecutionModel GetExecutionModel(const opt::Module* module, uint32_t entry_point_id); bool HasName(const IdInstructions& id_to, uint32_t id); // Get the OpName associated with an id std::string GetName(const IdInstructions& id_to, uint32_t id, bool* has_name); // Get the OpName associated with an id, with argument types stripped for // functions. Some tools don't encode function argument types in the OpName // string, and this improves diff between SPIR-V from those tools and others. std::string GetSanitizedName(const IdInstructions& id_to, uint32_t id); uint32_t GetVarTypeId(const IdInstructions& id_to, uint32_t var_id, spv::StorageClass* storage_class); bool GetDecorationValue(const IdInstructions& id_to, uint32_t id, spv::Decoration decoration, uint32_t* decoration_value); const opt::Instruction* GetForwardPointerInst(const IdInstructions& id_to, uint32_t id); bool IsIntType(const IdInstructions& id_to, uint32_t type_id); bool IsFloatType(const IdInstructions& id_to, uint32_t type_id); bool IsConstantUint(const IdInstructions& id_to, uint32_t id); bool IsVariable(const IdInstructions& id_to, uint32_t pointer_id); bool IsOp(const IdInstructions& id_to, uint32_t id, spv::Op opcode); bool IsPerVertexType(const IdInstructions& id_to, uint32_t type_id); bool IsPerVertexVariable(const IdInstructions& id_to, uint32_t type_id); spv::StorageClass GetPerVertexStorageClass(const opt::Module* module, uint32_t type_id); spv_ext_inst_type_t GetExtInstType(const IdInstructions& id_to, uint32_t set_id); spv_number_kind_t GetNumberKind(const IdInstructions& id_to, const opt::Instruction& inst, uint32_t operand_index, uint32_t* number_bit_width); spv_number_kind_t GetTypeNumberKind(const IdInstructions& id_to, uint32_t id, uint32_t* number_bit_width); // Helper functions to output a diff line const opt::Instruction* MappedDstInst(const opt::Instruction* src_inst); const opt::Instruction* MappedSrcInst(const opt::Instruction* dst_inst); const opt::Instruction* MappedInstImpl(const opt::Instruction* inst, const IdMap& to_other, const IdInstructions& other_id_to); void OutputLine(std::function are_lines_identical, std::function output_src_line, std::function output_dst_line); template void OutputSection( const InstList& src_insts, const InstList& dst_insts, std::function write_inst); void ToParsedInstruction(const opt::Instruction& inst, const IdInstructions& id_to, const opt::Instruction& original_inst, spv_parsed_instruction_t* parsed_inst, std::vector& parsed_operands, std::vector& inst_binary); opt::Instruction ToMappedSrcIds(const opt::Instruction& dst_inst); void OutputRed() { if (options_.color_output) out_ << spvtools::clr::red{true}; } void OutputGreen() { if (options_.color_output) out_ << spvtools::clr::green{true}; } void OutputResetColor() { if (options_.color_output) out_ << spvtools::clr::reset{true}; } opt::IRContext* src_context_; opt::IRContext* dst_context_; const opt::Module* src_; const opt::Module* dst_; Options options_; std::ostream& out_; // Helpers to look up instructions based on id. IdInstructions src_id_to_; IdInstructions dst_id_to_; // The ids that have been matched between src and dst so far. SrcDstIdMap id_map_; // List of instructions in function bodies after canonicalization. Cached // here to avoid duplicate work. More importantly, some maps use // opt::Instruction pointers so they need to be unique. FunctionInstMap src_func_insts_; FunctionInstMap dst_func_insts_; FunctionMap src_funcs_; FunctionMap dst_funcs_; }; void SrcDstIdMap::MapUnmatchedIds( std::function src_insn_defined, std::function dst_insn_defined) { const uint32_t src_id_bound = static_cast(src_to_dst_.IdBound()); const uint32_t dst_id_bound = static_cast(dst_to_src_.IdBound()); for (uint32_t src_id = 1; src_id < src_id_bound; ++src_id) { if (!src_to_dst_.IsMapped(src_id) && src_insn_defined(src_id)) { uint32_t fresh_dst_id = dst_to_src_.MakeFreshId(); MapIds(src_id, fresh_dst_id); } } for (uint32_t dst_id = 1; dst_id < dst_id_bound; ++dst_id) { if (!dst_to_src_.IsMapped(dst_id) && dst_insn_defined(dst_id)) { uint32_t fresh_src_id = src_to_dst_.MakeFreshId(); MapIds(fresh_src_id, dst_id); } } } void IdInstructions::MapIdToInstruction(uint32_t id, const opt::Instruction* inst) { assert(id != 0); assert(id < inst_map_.size()); assert(inst_map_[id] == nullptr); inst_map_[id] = inst; } void IdInstructions::MapIdsToInstruction( opt::IteratorRange section) { for (const opt::Instruction& inst : section) { uint32_t result_id = inst.result_id(); if (result_id == 0) { continue; } MapIdToInstruction(result_id, &inst); } } void IdInstructions::MapIdsToInfos( opt::IteratorRange section) { for (const opt::Instruction& inst : section) { IdToInfoMap* info_map = nullptr; uint32_t id_operand = 0; switch (inst.opcode()) { case spv::Op::OpName: info_map = &name_map_; break; case spv::Op::OpMemberName: info_map = &name_map_; break; case spv::Op::OpDecorate: info_map = &decoration_map_; break; case spv::Op::OpMemberDecorate: info_map = &decoration_map_; break; case spv::Op::OpTypeForwardPointer: { uint32_t id = inst.GetSingleWordOperand(0); assert(id != 0); assert(id < forward_pointer_map_.size()); forward_pointer_map_[id] = &inst; continue; } default: // Currently unsupported instruction, don't attempt to use it for // matching. break; } if (info_map == nullptr) { continue; } uint32_t id = inst.GetOperand(id_operand).AsId(); assert(id != 0); assert(id < info_map->size()); assert(std::find((*info_map)[id].begin(), (*info_map)[id].end(), &inst) == (*info_map)[id].end()); (*info_map)[id].push_back(&inst); } } void Differ::PoolPotentialIds( opt::IteratorRange section, std::vector& ids, bool is_src, std::function filter, std::function get_id) { for (const opt::Instruction& inst : section) { if (!filter(inst)) { continue; } uint32_t result_id = get_id(inst); assert(result_id != 0); assert(std::find(ids.begin(), ids.end(), result_id) == ids.end()); // Don't include ids that are already matched, for example through // OpTypeForwardPointer. const bool is_matched = is_src ? id_map_.IsSrcMapped(result_id) : id_map_.IsDstMapped(result_id); if (is_matched) { continue; } ids.push_back(result_id); } } void Differ::MatchIds( PotentialIdMap& potential, std::function match) { for (size_t src_index = 0; src_index < potential.src_ids.size(); ++src_index) { for (size_t dst_index = 0; dst_index < potential.dst_ids.size(); ++dst_index) { const uint32_t src_id = potential.src_ids[src_index]; const uint32_t dst_id = potential.dst_ids[dst_index]; if (dst_id == 0) { // Already matched. continue; } const opt::Instruction* src_inst = src_id_to_.inst_map_[src_id]; const opt::Instruction* dst_inst = dst_id_to_.inst_map_[dst_id]; if (match(src_inst, dst_inst)) { id_map_.MapIds(src_id, dst_id); // Remove the ids from the potential list. potential.src_ids[src_index] = 0; potential.dst_ids[dst_index] = 0; // Find a match for the next src id. break; } } } // Remove matched ids to make the next iteration faster. CompactIds(potential.src_ids); CompactIds(potential.dst_ids); } void Differ::MatchPreambleInstructions( opt::IteratorRange src_insts, opt::IteratorRange dst_insts) { // First, pool all instructions from each section and sort them. InstructionList sorted_src_insts = SortPreambleInstructions(src_, src_insts); InstructionList sorted_dst_insts = SortPreambleInstructions(dst_, dst_insts); // Then walk and match them. size_t src_cur = 0; size_t dst_cur = 0; while (src_cur < sorted_src_insts.size() && dst_cur < sorted_dst_insts.size()) { const opt::Instruction* src_inst = sorted_src_insts[src_cur]; const opt::Instruction* dst_inst = sorted_dst_insts[dst_cur]; int compare = ComparePreambleInstructions(src_inst, dst_inst, src_, dst_); if (compare == 0) { id_map_.MapInsts(src_inst, dst_inst); } if (compare <= 0) { ++src_cur; } if (compare >= 0) { ++dst_cur; } } } InstructionList Differ::SortPreambleInstructions( const opt::Module* module, opt::IteratorRange insts) { InstructionList sorted; for (const opt::Instruction& inst : insts) { sorted.push_back(&inst); } std::sort( sorted.begin(), sorted.end(), [this, module](const opt::Instruction* a, const opt::Instruction* b) { return ComparePreambleInstructions(a, b, module, module) < 0; }); return sorted; } int Differ::ComparePreambleInstructions(const opt::Instruction* a, const opt::Instruction* b, const opt::Module* src_inst_module, const opt::Module* dst_inst_module) { assert(a->opcode() == b->opcode()); assert(!a->HasResultId()); assert(!a->HasResultType()); const uint32_t a_operand_count = a->NumOperands(); const uint32_t b_operand_count = b->NumOperands(); if (a_operand_count < b_operand_count) { return -1; } if (a_operand_count > b_operand_count) { return 1; } // Instead of comparing OpExecutionMode entry point ids as ids, compare them // through their corresponding execution model. This simplifies traversing // the sorted list of instructions between src and dst modules. if (a->opcode() == spv::Op::OpExecutionMode) { const spv::ExecutionModel src_model = GetExecutionModel(src_inst_module, a->GetSingleWordOperand(0)); const spv::ExecutionModel dst_model = GetExecutionModel(dst_inst_module, b->GetSingleWordOperand(0)); if (src_model < dst_model) { return -1; } if (src_model > dst_model) { return 1; } } // Match every operand of the instruction. for (uint32_t operand_index = 0; operand_index < a_operand_count; ++operand_index) { const opt::Operand& a_operand = a->GetOperand(operand_index); const opt::Operand& b_operand = b->GetOperand(operand_index); if (a_operand.type < b_operand.type) { return -1; } if (a_operand.type > b_operand.type) { return 1; } switch (a_operand.type) { case SPV_OPERAND_TYPE_ID: // Don't compare ids, there can't be multiple instances of the // OpExecutionMode with different ids of the same execution model. break; case SPV_OPERAND_TYPE_TYPE_ID: case SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID: case SPV_OPERAND_TYPE_SCOPE_ID: assert(false && "Unreachable"); break; case SPV_OPERAND_TYPE_LITERAL_STRING: { int str_compare = strcmp(a_operand.AsString().c_str(), b_operand.AsString().c_str()); if (str_compare != 0) { return str_compare; } break; } default: // Expect literal values to match. assert(a_operand.words.size() == 1); assert(b_operand.words.size() == 1); if (a_operand.words[0] < b_operand.words[0]) { return -1; } if (a_operand.words[0] > b_operand.words[0]) { return 1; } break; } } return 0; } void Differ::MatchDebugAndAnnotationInstructions( opt::IteratorRange src_insts, opt::IteratorRange dst_insts) { for (const opt::Instruction& src_inst : src_insts) { for (const opt::Instruction& dst_inst : dst_insts) { if (MappedSrcInst(&dst_inst) != nullptr) { continue; } // Map instructions as soon as they match. Debug and annotation // instructions are matched such that there can't be multiple matches. if (DoDebugAndAnnotationInstructionsMatch(&src_inst, &dst_inst)) { id_map_.MapInsts(&src_inst, &dst_inst); break; } } } } uint32_t Differ::GroupIdsHelperGetTypeId(const IdInstructions& id_to, uint32_t id) { return GetInst(id_to, id)->type_id(); } spv::StorageClass Differ::GroupIdsHelperGetTypePointerStorageClass( const IdInstructions& id_to, uint32_t id) { const opt::Instruction* inst = GetInst(id_to, id); assert(inst && inst->opcode() == spv::Op::OpTypePointer); return spv::StorageClass(inst->GetSingleWordInOperand(0)); } spv::Op Differ::GroupIdsHelperGetTypePointerTypeOp(const IdInstructions& id_to, uint32_t id) { const opt::Instruction* inst = GetInst(id_to, id); assert(inst && inst->opcode() == spv::Op::OpTypePointer); const uint32_t type_id = inst->GetSingleWordInOperand(1); const opt::Instruction* type_inst = GetInst(id_to, type_id); assert(type_inst); return type_inst->opcode(); } template void Differ::GroupIds(const IdGroup& ids, bool is_src, std::map* groups, T (Differ::*get_group)(const IdInstructions&, uint32_t)) { assert(groups->empty()); const IdInstructions& id_to = is_src ? src_id_to_ : dst_id_to_; for (const uint32_t id : ids) { // Don't include ids that are already matched, for example through // OpEntryPoint. const bool is_matched = is_src ? id_map_.IsSrcMapped(id) : id_map_.IsDstMapped(id); if (is_matched) { continue; } T group = (this->*get_group)(id_to, id); (*groups)[group].push_back(id); } } template void Differ::GroupIdsAndMatch( const IdGroup& src_ids, const IdGroup& dst_ids, T invalid_group_key, T (Differ::*get_group)(const IdInstructions&, uint32_t), std::function match_group) { // Group the ids based on a key (get_group) std::map src_groups; std::map dst_groups; GroupIds(src_ids, true, &src_groups, get_group); GroupIds(dst_ids, false, &dst_groups, get_group); // Iterate over the groups, and match those with identical keys for (const auto& iter : src_groups) { const T& key = iter.first; const IdGroup& src_group = iter.second; if (key == invalid_group_key) { continue; } const IdGroup& dst_group = dst_groups[key]; // Let the caller match the groups as appropriate. match_group(src_group, dst_group); } } void Differ::GroupIdsAndMatchByMappedId( const IdGroup& src_ids, const IdGroup& dst_ids, uint32_t (Differ::*get_group)(const IdInstructions&, uint32_t), std::function match_group) { // Group the ids based on a key (get_group) std::map src_groups; std::map dst_groups; GroupIds(src_ids, true, &src_groups, get_group); GroupIds(dst_ids, false, &dst_groups, get_group); // Iterate over pairs of groups whose keys map to each other. for (const auto& iter : src_groups) { const uint32_t& src_key = iter.first; const IdGroup& src_group = iter.second; if (src_key == 0) { continue; } if (id_map_.IsSrcMapped(src_key)) { const uint32_t& dst_key = id_map_.MappedDstId(src_key); const IdGroup& dst_group = dst_groups[dst_key]; // Let the caller match the groups as appropriate. match_group(src_group, dst_group); } } } bool Differ::DoIdsMatch(uint32_t src_id, uint32_t dst_id) { assert(dst_id != 0); return id_map_.MappedDstId(src_id) == dst_id; } bool Differ::DoesOperandMatch(const opt::Operand& src_operand, const opt::Operand& dst_operand) { assert(src_operand.type == dst_operand.type); switch (src_operand.type) { case SPV_OPERAND_TYPE_ID: case SPV_OPERAND_TYPE_TYPE_ID: case SPV_OPERAND_TYPE_RESULT_ID: case SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID: case SPV_OPERAND_TYPE_SCOPE_ID: // Match ids only if they are already matched in the id map. return DoIdsMatch(src_operand.AsId(), dst_operand.AsId()); case SPV_OPERAND_TYPE_LITERAL_STRING: return src_operand.AsString() == dst_operand.AsString(); default: // Otherwise expect them to match exactly. assert(src_operand.type != SPV_OPERAND_TYPE_LITERAL_STRING); if (src_operand.words.size() != dst_operand.words.size()) { return false; } for (size_t i = 0; i < src_operand.words.size(); ++i) { if (src_operand.words[i] != dst_operand.words[i]) { return false; } } return true; } } bool Differ::DoOperandsMatch(const opt::Instruction* src_inst, const opt::Instruction* dst_inst, uint32_t in_operand_index_start, uint32_t in_operand_count) { // Caller should have returned early for instructions with different opcode. assert(src_inst->opcode() == dst_inst->opcode()); bool match = true; for (uint32_t i = 0; i < in_operand_count; ++i) { const uint32_t in_operand_index = in_operand_index_start + i; const opt::Operand& src_operand = src_inst->GetInOperand(in_operand_index); const opt::Operand& dst_operand = dst_inst->GetInOperand(in_operand_index); match = match && DoesOperandMatch(src_operand, dst_operand); } return match; } bool Differ::DoInstructionsMatch(const opt::Instruction* src_inst, const opt::Instruction* dst_inst) { // Check whether the two instructions are identical, that is the instructions // themselves are matched, every id is matched, and every other value is // identical. if (MappedDstInst(src_inst) != dst_inst) { return false; } assert(src_inst->opcode() == dst_inst->opcode()); if (src_inst->NumOperands() != dst_inst->NumOperands()) { return false; } for (uint32_t operand_index = 0; operand_index < src_inst->NumOperands(); ++operand_index) { const opt::Operand& src_operand = src_inst->GetOperand(operand_index); const opt::Operand& dst_operand = dst_inst->GetOperand(operand_index); if (!DoesOperandMatch(src_operand, dst_operand)) { return false; } } return true; } bool Differ::DoIdsMatchFuzzy(uint32_t src_id, uint32_t dst_id) { assert(dst_id != 0); const uint32_t mapped_dst_id = id_map_.MappedDstId(src_id); // Consider unmatched ids as a match. In function bodies, no result id is // matched yet and thus they are excluded from instruction matching when used // as parameters in subsequent instructions. if (mapped_dst_id == 0 || mapped_dst_id == dst_id) { return true; } // Int and Uint constants are interchangeable, match them in that case. if (AreIdenticalUintConstants(src_id, dst_id)) { return true; } return false; } bool Differ::DoesOperandMatchFuzzy(const opt::Operand& src_operand, const opt::Operand& dst_operand) { if (src_operand.type != dst_operand.type) { return false; } assert(src_operand.type != SPV_OPERAND_TYPE_RESULT_ID); assert(dst_operand.type != SPV_OPERAND_TYPE_RESULT_ID); switch (src_operand.type) { case SPV_OPERAND_TYPE_ID: case SPV_OPERAND_TYPE_TYPE_ID: case SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID: case SPV_OPERAND_TYPE_SCOPE_ID: // Match id operands only if they are already matched in the id map. return DoIdsMatchFuzzy(src_operand.AsId(), dst_operand.AsId()); default: // Otherwise allow everything to match. return true; } } bool Differ::DoInstructionsMatchFuzzy(const opt::Instruction* src_inst, const opt::Instruction* dst_inst) { // Similar to DoOperandsMatch, but only checks that ids that have already been // matched are identical. Ids that are unknown are allowed to match, as well // as any non-id operand. if (src_inst->opcode() != dst_inst->opcode()) { return false; } // For external instructions, make sure the set and opcode of the external // instruction matches too. if (src_inst->opcode() == spv::Op::OpExtInst) { if (!DoOperandsMatch(src_inst, dst_inst, 0, 2)) { return false; } } assert(src_inst->HasResultType() == dst_inst->HasResultType()); if (src_inst->HasResultType() && !DoIdsMatchFuzzy(src_inst->type_id(), dst_inst->type_id())) { return false; } // TODO: allow some instructions to match with different instruction lengths, // for example OpImage* with additional operands. if (src_inst->NumInOperandWords() != dst_inst->NumInOperandWords()) { return false; } bool match = true; for (uint32_t in_operand_index = 0; in_operand_index < src_inst->NumInOperandWords(); ++in_operand_index) { const opt::Operand& src_operand = src_inst->GetInOperand(in_operand_index); const opt::Operand& dst_operand = dst_inst->GetInOperand(in_operand_index); match = match && DoesOperandMatchFuzzy(src_operand, dst_operand); } return match; } bool Differ::AreIdenticalUintConstants(uint32_t src_id, uint32_t dst_id) { return IsConstantUint(src_id_to_, src_id) && IsConstantUint(dst_id_to_, dst_id) && GetConstantUint(src_id_to_, src_id) == GetConstantUint(dst_id_to_, dst_id); } bool Differ::DoDebugAndAnnotationInstructionsMatch( const opt::Instruction* src_inst, const opt::Instruction* dst_inst) { if (src_inst->opcode() != dst_inst->opcode()) { return false; } switch (src_inst->opcode()) { case spv::Op::OpString: case spv::Op::OpSourceExtension: case spv::Op::OpModuleProcessed: return DoesOperandMatch(src_inst->GetOperand(0), dst_inst->GetOperand(0)); case spv::Op::OpSource: return DoOperandsMatch(src_inst, dst_inst, 0, 2); case spv::Op::OpSourceContinued: return true; case spv::Op::OpName: return DoOperandsMatch(src_inst, dst_inst, 0, 1); case spv::Op::OpMemberName: return DoOperandsMatch(src_inst, dst_inst, 0, 2); case spv::Op::OpDecorate: return DoOperandsMatch(src_inst, dst_inst, 0, 2); case spv::Op::OpMemberDecorate: return DoOperandsMatch(src_inst, dst_inst, 0, 3); case spv::Op::OpExtInst: case spv::Op::OpDecorationGroup: case spv::Op::OpGroupDecorate: case spv::Op::OpGroupMemberDecorate: return false; default: return false; } } bool Differ::AreVariablesMatchable(uint32_t src_id, uint32_t dst_id, uint32_t flexibility) { // Variables must match by their built-in decorations. uint32_t src_built_in_decoration = 0, dst_built_in_decoration = 0; const bool src_is_built_in = GetDecorationValue( src_id_to_, src_id, spv::Decoration::BuiltIn, &src_built_in_decoration); const bool dst_is_built_in = GetDecorationValue( dst_id_to_, dst_id, spv::Decoration::BuiltIn, &dst_built_in_decoration); if (src_is_built_in != dst_is_built_in) { return false; } if (src_is_built_in && src_built_in_decoration != dst_built_in_decoration) { return false; } // Check their types and storage classes. spv::StorageClass src_storage_class, dst_storage_class; const uint32_t src_type_id = GetVarTypeId(src_id_to_, src_id, &src_storage_class); const uint32_t dst_type_id = GetVarTypeId(dst_id_to_, dst_id, &dst_storage_class); if (!DoIdsMatch(src_type_id, dst_type_id)) { return false; } switch (flexibility) { case 0: if (src_storage_class != dst_storage_class) { return false; } break; case 1: if (src_storage_class != dst_storage_class) { // Allow one of the two to be Private while the other is Input or // Output, this allows matching in/out variables that have been turned // global as part of linking two stages (as done in ANGLE). const bool src_is_io = src_storage_class == spv::StorageClass::Input || src_storage_class == spv::StorageClass::Output; const bool dst_is_io = dst_storage_class == spv::StorageClass::Input || dst_storage_class == spv::StorageClass::Output; const bool src_is_private = src_storage_class == spv::StorageClass::Private; const bool dst_is_private = dst_storage_class == spv::StorageClass::Private; if (!((src_is_io && dst_is_private) || (src_is_private && dst_is_io))) { return false; } } break; default: assert(false && "Unreachable"); return false; } // TODO: Is there any other way to check compatiblity of the variables? It's // easy to tell when the variables definitely don't match, but there's little // information that can be used for a definite match. return true; } bool Differ::MatchOpTypeStruct(const opt::Instruction* src_inst, const opt::Instruction* dst_inst, uint32_t flexibility) { const uint32_t src_type_id = src_inst->result_id(); const uint32_t dst_type_id = dst_inst->result_id(); bool src_has_name = false, dst_has_name = false; std::string src_name = GetName(src_id_to_, src_type_id, &src_has_name); std::string dst_name = GetName(dst_id_to_, dst_type_id, &dst_has_name); // If debug info is present, always match the structs by name. if (src_has_name && dst_has_name) { if (src_name != dst_name) { return false; } // For gl_PerVertex, find the type pointer of this type (array) and make // sure the storage classes of src and dst match; geometry and tessellation // shaders have two instances of gl_PerVertex. if (src_name == "gl_PerVertex") { return MatchPerVertexType(src_type_id, dst_type_id); } return true; } // If debug info is not present, match the structs by their type. // For gl_PerVertex, find the type pointer of this type (array) and match by // storage class. The gl_PerVertex struct is itself found by the BuiltIn // decorations applied to its members. const bool src_is_per_vertex = IsPerVertexType(src_id_to_, src_type_id); const bool dst_is_per_vertex = IsPerVertexType(dst_id_to_, dst_type_id); if (src_is_per_vertex != dst_is_per_vertex) { return false; } if (src_is_per_vertex) { return MatchPerVertexType(src_type_id, dst_type_id); } switch (flexibility) { case 0: if (src_inst->NumInOperandWords() != dst_inst->NumInOperandWords()) { return false; } return DoOperandsMatch(src_inst, dst_inst, 0, src_inst->NumInOperandWords()); case 1: // TODO: match by taking a diff of the fields, and see if there's a >75% // match. Need to then make sure OpMemberName, OpMemberDecorate, // OpAccessChain etc are aware of the struct field matching. return false; default: assert(false && "Unreachable"); return false; } } bool Differ::MatchOpConstant(const opt::Instruction* src_inst, const opt::Instruction* dst_inst, uint32_t flexibility) { // The constants' type must match. In flexibility == 1, match constants of // int and uint, as they are generally interchangeable. switch (flexibility) { case 0: if (!DoesOperandMatch(src_inst->GetOperand(0), dst_inst->GetOperand(0))) { return false; } break; case 1: if (!IsIntType(src_id_to_, src_inst->type_id()) || !IsIntType(dst_id_to_, dst_inst->type_id())) { return false; } break; default: assert(false && "Unreachable"); return false; } const opt::Operand& src_value_operand = src_inst->GetOperand(2); const opt::Operand& dst_value_operand = dst_inst->GetOperand(2); const uint64_t src_value = src_value_operand.AsLiteralUint64(); const uint64_t dst_value = dst_value_operand.AsLiteralUint64(); // If values are identical, it's a match. if (src_value == dst_value) { return true; } // Otherwise, only allow flexibility for float types. if (IsFloatType(src_id_to_, src_inst->type_id()) && flexibility == 1) { // Tolerance is: // // - For float: allow 4 bits of mantissa as error // - For double: allow 6 bits of mantissa as error // // TODO: the above values are arbitrary and a placeholder; investigate the // amount of error resulting from using `printf("%f", f)` and `printf("%lf", // d)` and having glslang parse them. const uint64_t tolerance = src_value_operand.words.size() == 1 ? 16 : 64; return src_value - dst_value < tolerance || dst_value - src_value < tolerance; } return false; } bool Differ::MatchOpSpecConstant(const opt::Instruction* src_inst, const opt::Instruction* dst_inst) { const uint32_t src_id = src_inst->result_id(); const uint32_t dst_id = dst_inst->result_id(); bool src_has_name = false, dst_has_name = false; std::string src_name = GetName(src_id_to_, src_id, &src_has_name); std::string dst_name = GetName(dst_id_to_, dst_id, &dst_has_name); // If debug info is present, always match the spec consts by name. if (src_has_name && dst_has_name) { return src_name == dst_name; } // Otherwise, match them by SpecId. uint32_t src_spec_id, dst_spec_id; if (GetDecorationValue(src_id_to_, src_id, spv::Decoration::SpecId, &src_spec_id) && GetDecorationValue(dst_id_to_, dst_id, spv::Decoration::SpecId, &dst_spec_id)) { return src_spec_id == dst_spec_id; } // There is no SpecId decoration, while not practical, still valid. // SpecConstantOp don't have SpecId and can be matched by operands if (src_inst->opcode() == spv::Op::OpSpecConstantOp) { if (src_inst->NumInOperandWords() == dst_inst->NumInOperandWords()) { return DoOperandsMatch(src_inst, dst_inst, 0, src_inst->NumInOperandWords()); } } return false; } bool Differ::MatchOpVariable(const opt::Instruction* src_inst, const opt::Instruction* dst_inst, uint32_t flexibility) { const uint32_t src_id = src_inst->result_id(); const uint32_t dst_id = dst_inst->result_id(); const bool src_is_pervertex = IsPerVertexVariable(src_id_to_, src_id); const bool dst_is_pervertex = IsPerVertexVariable(dst_id_to_, dst_id); // For gl_PerVertex, make sure the input and output instances are matched // correctly. if (src_is_pervertex != dst_is_pervertex) { return false; } if (src_is_pervertex) { return MatchPerVertexVariable(src_inst, dst_inst); } bool src_has_name = false, dst_has_name = false; std::string src_name = GetName(src_id_to_, src_id, &src_has_name); std::string dst_name = GetName(dst_id_to_, dst_id, &dst_has_name); // If debug info is present, always match the variables by name. if (src_has_name && dst_has_name) { return src_name == dst_name; } // If debug info is not present, see if the variables can be matched by their // built-in decorations. uint32_t src_built_in_decoration; const bool src_is_built_in = GetDecorationValue( src_id_to_, src_id, spv::Decoration::BuiltIn, &src_built_in_decoration); if (src_is_built_in && AreVariablesMatchable(src_id, dst_id, flexibility)) { return true; } spv::StorageClass src_storage_class, dst_storage_class; GetVarTypeId(src_id_to_, src_id, &src_storage_class); GetVarTypeId(dst_id_to_, dst_id, &dst_storage_class); if (src_storage_class != dst_storage_class) { return false; } // If variables are decorated with set/binding, match by the value of those // decorations. if (!options_.ignore_set_binding) { uint32_t src_set = 0, dst_set = 0; uint32_t src_binding = 0, dst_binding = 0; const bool src_has_set = GetDecorationValue( src_id_to_, src_id, spv::Decoration::DescriptorSet, &src_set); const bool dst_has_set = GetDecorationValue( dst_id_to_, dst_id, spv::Decoration::DescriptorSet, &dst_set); const bool src_has_binding = GetDecorationValue( src_id_to_, src_id, spv::Decoration::Binding, &src_set); const bool dst_has_binding = GetDecorationValue( dst_id_to_, dst_id, spv::Decoration::Binding, &dst_set); if (src_has_set && dst_has_set && src_has_binding && dst_has_binding) { return src_set == dst_set && src_binding == dst_binding; } } // If variables are decorated with location, match by the value of that // decoration. if (!options_.ignore_location) { uint32_t src_location, dst_location; const bool src_has_location = GetDecorationValue( src_id_to_, src_id, spv::Decoration::Location, &src_location); const bool dst_has_location = GetDecorationValue( dst_id_to_, dst_id, spv::Decoration::Location, &dst_location); if (src_has_location && dst_has_location) { return src_location == dst_location; } } // Currently, there's no other way to match variables. return false; } bool Differ::MatchPerVertexType(uint32_t src_type_id, uint32_t dst_type_id) { // For gl_PerVertex, find the type pointer of this type (array) and make sure // the storage classes of src and dst match; geometry and tessellation shaders // have two instances of gl_PerVertex. spv::StorageClass src_storage_class = GetPerVertexStorageClass(src_, src_type_id); spv::StorageClass dst_storage_class = GetPerVertexStorageClass(dst_, dst_type_id); assert(src_storage_class == spv::StorageClass::Input || src_storage_class == spv::StorageClass::Output); assert(dst_storage_class == spv::StorageClass::Input || dst_storage_class == spv::StorageClass::Output); return src_storage_class == dst_storage_class; } bool Differ::MatchPerVertexVariable(const opt::Instruction* src_inst, const opt::Instruction* dst_inst) { spv::StorageClass src_storage_class = spv::StorageClass(src_inst->GetSingleWordInOperand(0)); spv::StorageClass dst_storage_class = spv::StorageClass(dst_inst->GetSingleWordInOperand(0)); return src_storage_class == dst_storage_class; } void Differ::MatchTypeForwardPointersByName(const IdGroup& src, const IdGroup& dst) { // Given two sets of compatible groups of OpTypeForwardPointer instructions, // attempts to match them by name. // Group them by debug info and loop over them. GroupIdsAndMatch( src, dst, "", &Differ::GetSanitizedName, [this](const IdGroup& src_group, const IdGroup& dst_group) { // Match only if there's a unique forward declaration with this debug // name. if (src_group.size() == 1 && dst_group.size() == 1) { id_map_.MapIds(src_group[0], dst_group[0]); } }); } void Differ::MatchTypeForwardPointersByTypeOp(const IdGroup& src, const IdGroup& dst) { // Given two sets of compatible groups of OpTypeForwardPointer instructions, // attempts to match them by type op. Must be called after // MatchTypeForwardPointersByName to match as many as possible by debug info. // Remove ids that are matched with debug info in // MatchTypeForwardPointersByName. IdGroup src_unmatched_ids; IdGroup dst_unmatched_ids; std::copy_if(src.begin(), src.end(), std::back_inserter(src_unmatched_ids), [this](uint32_t id) { return !id_map_.IsSrcMapped(id); }); std::copy_if(dst.begin(), dst.end(), std::back_inserter(dst_unmatched_ids), [this](uint32_t id) { return !id_map_.IsDstMapped(id); }); // Match only if there's a unique forward declaration with this // storage class and type opcode. If both have debug info, they // must not have been matchable. if (src_unmatched_ids.size() == 1 && dst_unmatched_ids.size() == 1) { uint32_t src_id = src_unmatched_ids[0]; uint32_t dst_id = dst_unmatched_ids[0]; if (!HasName(src_id_to_, src_id) || !HasName(dst_id_to_, dst_id)) { id_map_.MapIds(src_id, dst_id); } } } InstructionList Differ::GetFunctionBody(opt::IRContext* context, opt::Function& function) { // Canonicalize the blocks of the function to produce better diff, for example // to not produce any diff if the src and dst have the same switch/case blocks // but with the cases simply reordered. std::list order; context->cfg()->ComputeStructuredOrder(&function, &*function.begin(), &order); // Go over the instructions of the function and add the instructions to a flat // list to simplify future iterations. InstructionList body; for (opt::BasicBlock* block : order) { block->ForEachInst( [&body](const opt::Instruction* inst) { body.push_back(inst); }, true); } body.push_back(function.EndInst()); return body; } InstructionList Differ::GetFunctionHeader(const opt::Function& function) { // Go over the instructions of the function and add the header instructions to // a flat list to simplify diff generation. InstructionList body; function.WhileEachInst( [&body](const opt::Instruction* inst) { if (inst->opcode() == spv::Op::OpLabel) { return false; } body.push_back(inst); return true; }, true, true); return body; } void Differ::GetFunctionBodies(opt::IRContext* context, FunctionMap* functions, FunctionInstMap* function_insts) { for (opt::Function& function : *context->module()) { uint32_t id = function.result_id(); assert(functions->find(id) == functions->end()); assert(function_insts->find(id) == function_insts->end()); (*functions)[id] = &function; InstructionList body = GetFunctionBody(context, function); (*function_insts)[id] = std::move(body); } } void Differ::GetFunctionHeaderInstructions(const opt::Module* module, FunctionInstMap* function_insts) { for (opt::Function& function : *module) { InstructionList body = GetFunctionHeader(function); (*function_insts)[function.result_id()] = std::move(body); } } void Differ::BestEffortMatchFunctions(const IdGroup& src_func_ids, const IdGroup& dst_func_ids, const FunctionInstMap& src_func_insts, const FunctionInstMap& dst_func_insts) { struct MatchResult { uint32_t src_id; uint32_t dst_id; DiffMatch src_match; DiffMatch dst_match; float match_rate; bool operator<(const MatchResult& other) const { return match_rate > other.match_rate; } }; std::vector all_match_results; for (const uint32_t src_func_id : src_func_ids) { if (id_map_.IsSrcMapped(src_func_id)) { continue; } const std::string src_name = GetSanitizedName(src_id_to_, src_func_id); for (const uint32_t dst_func_id : dst_func_ids) { if (id_map_.IsDstMapped(dst_func_id)) { continue; } // Don't match functions that are named, but the names are different. const std::string dst_name = GetSanitizedName(dst_id_to_, dst_func_id); if (src_name != "" && dst_name != "" && src_name != dst_name) { continue; } DiffMatch src_match_result, dst_match_result; float match_rate = MatchFunctionBodies( src_func_insts.at(src_func_id), dst_func_insts.at(dst_func_id), &src_match_result, &dst_match_result); // Only consider the functions a match if there's at least 60% match. // This is an arbitrary limit that should be tuned. constexpr float pass_match_rate = 0.6f; if (match_rate >= pass_match_rate) { all_match_results.emplace_back( MatchResult{src_func_id, dst_func_id, std::move(src_match_result), std::move(dst_match_result), match_rate}); } } } std::sort(all_match_results.begin(), all_match_results.end()); for (const MatchResult& match_result : all_match_results) { if (id_map_.IsSrcMapped(match_result.src_id) || id_map_.IsDstMapped(match_result.dst_id)) { continue; } id_map_.MapIds(match_result.src_id, match_result.dst_id); MatchFunctionParamIds(src_funcs_[match_result.src_id], dst_funcs_[match_result.dst_id]); MatchIdsInFunctionBodies(src_func_insts.at(match_result.src_id), dst_func_insts.at(match_result.dst_id), match_result.src_match, match_result.dst_match, 0); } } void Differ::MatchFunctionParamIds(const opt::Function* src_func, const opt::Function* dst_func) { IdGroup src_params; IdGroup dst_params; src_func->ForEachParam( [&src_params](const opt::Instruction* param) { src_params.push_back(param->result_id()); }, false); dst_func->ForEachParam( [&dst_params](const opt::Instruction* param) { dst_params.push_back(param->result_id()); }, false); GroupIdsAndMatch( src_params, dst_params, "", &Differ::GetSanitizedName, [this](const IdGroup& src_group, const IdGroup& dst_group) { // There shouldn't be two parameters with the same name, so the ids // should match. There is nothing restricting the SPIR-V however to have // two parameters with the same name, so be resilient against that. if (src_group.size() == 1 && dst_group.size() == 1) { id_map_.MapIds(src_group[0], dst_group[0]); } }); // Then match the parameters by their type. If there are multiple of them, // match them by their order. GroupIdsAndMatchByMappedId( src_params, dst_params, &Differ::GroupIdsHelperGetTypeId, [this](const IdGroup& src_group_by_type_id, const IdGroup& dst_group_by_type_id) { const size_t shared_param_count = std::min(src_group_by_type_id.size(), dst_group_by_type_id.size()); for (size_t param_index = 0; param_index < shared_param_count; ++param_index) { id_map_.MapIds(src_group_by_type_id[param_index], dst_group_by_type_id[param_index]); } }); } float Differ::MatchFunctionBodies(const InstructionList& src_body, const InstructionList& dst_body, DiffMatch* src_match_result, DiffMatch* dst_match_result) { LongestCommonSubsequence> lcs(src_body, dst_body); uint32_t best_match_length = lcs.Get( [this](const opt::Instruction* src_inst, const opt::Instruction* dst_inst) { return DoInstructionsMatchFuzzy(src_inst, dst_inst); }, src_match_result, dst_match_result); // TODO: take the gaps in between matches and match those again with a relaxed // instruction-and-type-only comparison. This can produce a better diff for // example if an array index is changed, causing the OpAccessChain id to not // match and subsequently every operation that's derived from that id. // Usually this mismatch cascades until the next OpStore which doesn't produce // an id. return static_cast(best_match_length) * 2.0f / static_cast(src_body.size() + dst_body.size()); } void Differ::MatchIdsInFunctionBodies(const InstructionList& src_body, const InstructionList& dst_body, const DiffMatch& src_match_result, const DiffMatch& dst_match_result, uint32_t flexibility) { size_t src_cur = 0; size_t dst_cur = 0; while (src_cur < src_body.size() && dst_cur < dst_body.size()) { if (src_match_result[src_cur] && dst_match_result[dst_cur]) { // Match instructions the src and dst instructions. // // TODO: count the matchings between variables discovered this way and // choose the "best match" after all functions have been diffed and all // instructions analyzed. const opt::Instruction* src_inst = src_body[src_cur++]; const opt::Instruction* dst_inst = dst_body[dst_cur++]; // Record the matching between the instructions. This is done only once // (hence flexibility == 0). Calls with non-zero flexibility values will // only deal with matching other ids based on the operands. if (flexibility == 0) { id_map_.MapInsts(src_inst, dst_inst); } // Match any unmatched variables referenced by the instructions. MatchVariablesUsedByMatchedInstructions(src_inst, dst_inst, flexibility); continue; } if (!src_match_result[src_cur]) { ++src_cur; } if (!dst_match_result[dst_cur]) { ++dst_cur; } } } void Differ::MatchVariablesUsedByMatchedInstructions( const opt::Instruction* src_inst, const opt::Instruction* dst_inst, uint32_t flexibility) { // For OpAccessChain, OpLoad and OpStore instructions that reference unmatched // variables, match them as a best effort. assert(src_inst->opcode() == dst_inst->opcode()); switch (src_inst->opcode()) { default: // TODO: match functions based on OpFunctionCall? break; case spv::Op::OpAccessChain: case spv::Op::OpInBoundsAccessChain: case spv::Op::OpPtrAccessChain: case spv::Op::OpInBoundsPtrAccessChain: case spv::Op::OpLoad: case spv::Op::OpStore: const uint32_t src_pointer_id = src_inst->GetSingleWordInOperand(0); const uint32_t dst_pointer_id = dst_inst->GetSingleWordInOperand(0); if (IsVariable(src_id_to_, src_pointer_id) && IsVariable(dst_id_to_, dst_pointer_id) && !id_map_.IsSrcMapped(src_pointer_id) && !id_map_.IsDstMapped(dst_pointer_id) && AreVariablesMatchable(src_pointer_id, dst_pointer_id, flexibility)) { id_map_.MapIds(src_pointer_id, dst_pointer_id); } break; } } const opt::Instruction* Differ::GetInst(const IdInstructions& id_to, uint32_t id) { assert(id != 0); assert(id < id_to.inst_map_.size()); const opt::Instruction* inst = id_to.inst_map_[id]; assert(inst != nullptr); return inst; } uint32_t Differ::GetConstantUint(const IdInstructions& id_to, uint32_t constant_id) { const opt::Instruction* constant_inst = GetInst(id_to, constant_id); assert(constant_inst->opcode() == spv::Op::OpConstant); assert(GetInst(id_to, constant_inst->type_id())->opcode() == spv::Op::OpTypeInt); return constant_inst->GetSingleWordInOperand(0); } spv::ExecutionModel Differ::GetExecutionModel(const opt::Module* module, uint32_t entry_point_id) { for (const opt::Instruction& inst : module->entry_points()) { assert(inst.opcode() == spv::Op::OpEntryPoint); if (inst.GetSingleWordOperand(1) == entry_point_id) { return spv::ExecutionModel(inst.GetSingleWordOperand(0)); } } assert(false && "Unreachable"); return spv::ExecutionModel(0xFFF); } bool Differ::HasName(const IdInstructions& id_to, uint32_t id) { assert(id != 0); assert(id < id_to.name_map_.size()); for (const opt::Instruction* inst : id_to.name_map_[id]) { if (inst->opcode() == spv::Op::OpName) { return true; } } return false; } std::string Differ::GetName(const IdInstructions& id_to, uint32_t id, bool* has_name) { assert(id != 0); assert(id < id_to.name_map_.size()); for (const opt::Instruction* inst : id_to.name_map_[id]) { if (inst->opcode() == spv::Op::OpName) { *has_name = true; return inst->GetOperand(1).AsString(); } } *has_name = false; return ""; } std::string Differ::GetSanitizedName(const IdInstructions& id_to, uint32_t id) { bool has_name = false; std::string name = GetName(id_to, id, &has_name); if (!has_name) { return ""; } // Remove args from the name, in case this is a function name return name.substr(0, name.find('(')); } uint32_t Differ::GetVarTypeId(const IdInstructions& id_to, uint32_t var_id, spv::StorageClass* storage_class) { const opt::Instruction* var_inst = GetInst(id_to, var_id); assert(var_inst->opcode() == spv::Op::OpVariable); *storage_class = spv::StorageClass(var_inst->GetSingleWordInOperand(0)); // Get the type pointer from the variable. const uint32_t type_pointer_id = var_inst->type_id(); const opt::Instruction* type_pointer_inst = GetInst(id_to, type_pointer_id); // Get the type from the type pointer. return type_pointer_inst->GetSingleWordInOperand(1); } bool Differ::GetDecorationValue(const IdInstructions& id_to, uint32_t id, spv::Decoration decoration, uint32_t* decoration_value) { assert(id != 0); assert(id < id_to.decoration_map_.size()); for (const opt::Instruction* inst : id_to.decoration_map_[id]) { if (inst->opcode() == spv::Op::OpDecorate && inst->GetSingleWordOperand(0) == id && spv::Decoration(inst->GetSingleWordOperand(1)) == decoration) { *decoration_value = inst->GetSingleWordOperand(2); return true; } } return false; } const opt::Instruction* Differ::GetForwardPointerInst( const IdInstructions& id_to, uint32_t id) { assert(id != 0); assert(id < id_to.forward_pointer_map_.size()); return id_to.forward_pointer_map_[id]; } bool Differ::IsIntType(const IdInstructions& id_to, uint32_t type_id) { return IsOp(id_to, type_id, spv::Op::OpTypeInt); } bool Differ::IsFloatType(const IdInstructions& id_to, uint32_t type_id) { return IsOp(id_to, type_id, spv::Op::OpTypeFloat); } bool Differ::IsConstantUint(const IdInstructions& id_to, uint32_t id) { const opt::Instruction* constant_inst = GetInst(id_to, id); if (constant_inst->opcode() != spv::Op::OpConstant) { return false; } const opt::Instruction* type_inst = GetInst(id_to, constant_inst->type_id()); return type_inst->opcode() == spv::Op::OpTypeInt; } bool Differ::IsVariable(const IdInstructions& id_to, uint32_t pointer_id) { return IsOp(id_to, pointer_id, spv::Op::OpVariable); } bool Differ::IsOp(const IdInstructions& id_to, uint32_t id, spv::Op op) { return GetInst(id_to, id)->opcode() == op; } bool Differ::IsPerVertexType(const IdInstructions& id_to, uint32_t type_id) { assert(type_id != 0); assert(type_id < id_to.decoration_map_.size()); for (const opt::Instruction* inst : id_to.decoration_map_[type_id]) { if (inst->opcode() == spv::Op::OpMemberDecorate && inst->GetSingleWordOperand(0) == type_id && spv::Decoration(inst->GetSingleWordOperand(2)) == spv::Decoration::BuiltIn) { spv::BuiltIn built_in = spv::BuiltIn(inst->GetSingleWordOperand(3)); // Only gl_PerVertex can have, and it can only have, the following // built-in decorations. return built_in == spv::BuiltIn::Position || built_in == spv::BuiltIn::PointSize || built_in == spv::BuiltIn::ClipDistance || built_in == spv::BuiltIn::CullDistance; } } return false; } bool Differ::IsPerVertexVariable(const IdInstructions& id_to, uint32_t var_id) { // Get the type from the type pointer. spv::StorageClass storage_class; uint32_t type_id = GetVarTypeId(id_to, var_id, &storage_class); const opt::Instruction* type_inst = GetInst(id_to, type_id); // If array, get the element type. if (type_inst->opcode() == spv::Op::OpTypeArray) { type_id = type_inst->GetSingleWordInOperand(0); } // Now check if the type is gl_PerVertex. return IsPerVertexType(id_to, type_id); } spv::StorageClass Differ::GetPerVertexStorageClass(const opt::Module* module, uint32_t type_id) { for (const opt::Instruction& inst : module->types_values()) { switch (inst.opcode()) { case spv::Op::OpTypeArray: // The gl_PerVertex instance could be an array, look for a variable of // the array type instead. if (inst.GetSingleWordInOperand(0) == type_id) { type_id = inst.result_id(); } break; case spv::Op::OpTypePointer: // Find the storage class of the pointer to this type. if (inst.GetSingleWordInOperand(1) == type_id) { return spv::StorageClass(inst.GetSingleWordInOperand(0)); } break; default: break; } } // gl_PerVertex is declared, but is unused. Return either of Input or Output // classes just so it matches one in the other module. This should be highly // unlikely, perhaps except for ancient GS-used-to-emulate-CS scenarios. return spv::StorageClass::Output; } spv_ext_inst_type_t Differ::GetExtInstType(const IdInstructions& id_to, uint32_t set_id) { const opt::Instruction* set_inst = GetInst(id_to, set_id); return spvExtInstImportTypeGet(set_inst->GetInOperand(0).AsString().c_str()); } spv_number_kind_t Differ::GetNumberKind(const IdInstructions& id_to, const opt::Instruction& inst, uint32_t operand_index, uint32_t* number_bit_width) { const opt::Operand& operand = inst.GetOperand(operand_index); *number_bit_width = 0; // A very limited version of Parser::parseOperand. switch (operand.type) { case SPV_OPERAND_TYPE_LITERAL_INTEGER: case SPV_OPERAND_TYPE_OPTIONAL_LITERAL_INTEGER: // Always unsigned integers. *number_bit_width = 32; return SPV_NUMBER_UNSIGNED_INT; case SPV_OPERAND_TYPE_LITERAL_FLOAT: // Always float. *number_bit_width = 32; return SPV_NUMBER_FLOATING; case SPV_OPERAND_TYPE_TYPED_LITERAL_NUMBER: case SPV_OPERAND_TYPE_OPTIONAL_TYPED_LITERAL_INTEGER: switch (inst.opcode()) { case spv::Op::OpSwitch: case spv::Op::OpConstant: case spv::Op::OpSpecConstant: // Same kind of number as the selector (OpSwitch) or the type // (Op*Constant). return GetTypeNumberKind(id_to, inst.GetSingleWordOperand(0), number_bit_width); default: assert(false && "Unreachable"); break; } break; default: break; } return SPV_NUMBER_NONE; } spv_number_kind_t Differ::GetTypeNumberKind(const IdInstructions& id_to, uint32_t id, uint32_t* number_bit_width) { const opt::Instruction* type_inst = GetInst(id_to, id); if (!spvOpcodeIsScalarType(type_inst->opcode())) { type_inst = GetInst(id_to, type_inst->type_id()); } switch (type_inst->opcode()) { case spv::Op::OpTypeInt: *number_bit_width = type_inst->GetSingleWordOperand(1); return type_inst->GetSingleWordOperand(2) == 0 ? SPV_NUMBER_UNSIGNED_INT : SPV_NUMBER_SIGNED_INT; break; case spv::Op::OpTypeFloat: *number_bit_width = type_inst->GetSingleWordOperand(1); return SPV_NUMBER_FLOATING; default: assert(false && "Unreachable"); return SPV_NUMBER_NONE; } } void Differ::MatchCapabilities() { MatchPreambleInstructions(src_->capabilities(), dst_->capabilities()); } void Differ::MatchExtensions() { MatchPreambleInstructions(src_->extensions(), dst_->extensions()); } void Differ::MatchExtInstImportIds() { // Bunch all of this section's ids as potential matches. PotentialIdMap potential_id_map; auto get_result_id = [](const opt::Instruction& inst) { return inst.result_id(); }; auto accept_all = [](const opt::Instruction&) { return true; }; PoolPotentialIds(src_->ext_inst_imports(), potential_id_map.src_ids, true, accept_all, get_result_id); PoolPotentialIds(dst_->ext_inst_imports(), potential_id_map.dst_ids, false, accept_all, get_result_id); // Then match the ids. MatchIds(potential_id_map, [](const opt::Instruction* src_inst, const opt::Instruction* dst_inst) { // Match OpExtInstImport by exact name, which is operand 1 const opt::Operand& src_name = src_inst->GetOperand(1); const opt::Operand& dst_name = dst_inst->GetOperand(1); return src_name.AsString() == dst_name.AsString(); }); } void Differ::MatchMemoryModel() { // Always match the memory model instructions, there is always a single one of // it. id_map_.MapInsts(src_->GetMemoryModel(), dst_->GetMemoryModel()); } void Differ::MatchEntryPointIds() { // Match OpEntryPoint ids (at index 1) by ExecutionModel (at index 0) and // possibly name (at index 2). OpEntryPoint doesn't produce a result id, so // this function doesn't use the helpers the other functions use. // Map from execution model to OpEntryPoint instructions of that model. using ExecutionModelMap = std::unordered_map>; ExecutionModelMap src_entry_points_map; ExecutionModelMap dst_entry_points_map; std::set all_execution_models; for (const opt::Instruction& src_inst : src_->entry_points()) { uint32_t execution_model = src_inst.GetSingleWordOperand(0); src_entry_points_map[execution_model].push_back(&src_inst); all_execution_models.insert(execution_model); } for (const opt::Instruction& dst_inst : dst_->entry_points()) { uint32_t execution_model = dst_inst.GetSingleWordOperand(0); dst_entry_points_map[execution_model].push_back(&dst_inst); all_execution_models.insert(execution_model); } // Go through each model and match the ids. for (const uint32_t execution_model : all_execution_models) { auto& src_insts = src_entry_points_map[execution_model]; auto& dst_insts = dst_entry_points_map[execution_model]; // If there is only one entry point in src and dst with that model, match // them unconditionally. if (src_insts.size() == 1 && dst_insts.size() == 1) { uint32_t src_id = src_insts[0]->GetSingleWordOperand(1); uint32_t dst_id = dst_insts[0]->GetSingleWordOperand(1); id_map_.MapIds(src_id, dst_id); id_map_.MapInsts(src_insts[0], dst_insts[0]); continue; } // Otherwise match them by name. for (const opt::Instruction* src_inst : src_insts) { for (const opt::Instruction* dst_inst : dst_insts) { if (id_map_.IsDstMapped(dst_inst)) continue; const opt::Operand& src_name = src_inst->GetOperand(2); const opt::Operand& dst_name = dst_inst->GetOperand(2); if (src_name.AsString() == dst_name.AsString()) { uint32_t src_id = src_inst->GetSingleWordOperand(1); uint32_t dst_id = dst_inst->GetSingleWordOperand(1); id_map_.MapIds(src_id, dst_id); id_map_.MapInsts(src_inst, dst_inst); break; } } } } } void Differ::MatchExecutionModes() { MatchPreambleInstructions(src_->execution_modes(), dst_->execution_modes()); } void Differ::MatchTypeForwardPointers() { // Bunch all of type forward pointers as potential matches. PotentialIdMap potential_id_map; auto get_pointer_type_id = [](const opt::Instruction& inst) { return inst.GetSingleWordOperand(0); }; auto accept_type_forward_pointer_ops = [](const opt::Instruction& inst) { return inst.opcode() == spv::Op::OpTypeForwardPointer; }; PoolPotentialIds(src_->types_values(), potential_id_map.src_ids, true, accept_type_forward_pointer_ops, get_pointer_type_id); PoolPotentialIds(dst_->types_values(), potential_id_map.dst_ids, false, accept_type_forward_pointer_ops, get_pointer_type_id); // Matching types with cyclical references (i.e. in the style of linked lists) // can get very complex. Currently, the diff tool matches types bottom up, so // on every instruction it expects to know if its operands are already matched // or not. With cyclical references, it cannot know that. Type matching may // need significant modifications to be able to support this use case. // // Currently, forwarded types are only matched by storage class and debug // info, with minimal matching of the type being forwarded: // // - Group by class // - Group by OpType being pointed to // - Group by debug info // - If same name and unique, match // - If leftover is unique, match // Group forwarded pointers by storage class first and loop over them. GroupIdsAndMatch( potential_id_map.src_ids, potential_id_map.dst_ids, spv::StorageClass::Max, &Differ::GroupIdsHelperGetTypePointerStorageClass, [this](const IdGroup& src_group_by_storage_class, const IdGroup& dst_group_by_storage_class) { // Group them further by the type they are pointing to and loop over // them. GroupIdsAndMatch( src_group_by_storage_class, dst_group_by_storage_class, spv::Op::Max, &Differ::GroupIdsHelperGetTypePointerTypeOp, [this](const IdGroup& src_group_by_type_op, const IdGroup& dst_group_by_type_op) { // Group them even further by debug info, if possible and match by // debug name. MatchTypeForwardPointersByName(src_group_by_type_op, dst_group_by_type_op); // Match the leftovers only if they lack debug info and there is // only one instance of them. MatchTypeForwardPointersByTypeOp(src_group_by_type_op, dst_group_by_type_op); }); }); // Match the instructions that forward declare the same type themselves for (uint32_t src_id : potential_id_map.src_ids) { uint32_t dst_id = id_map_.MappedDstId(src_id); if (dst_id == 0) continue; const opt::Instruction* src_forward_inst = GetForwardPointerInst(src_id_to_, src_id); const opt::Instruction* dst_forward_inst = GetForwardPointerInst(dst_id_to_, dst_id); assert(src_forward_inst); assert(dst_forward_inst); id_map_.MapInsts(src_forward_inst, dst_forward_inst); } } void Differ::MatchTypeIds() { // Bunch all of type ids as potential matches. PotentialIdMap potential_id_map; auto get_result_id = [](const opt::Instruction& inst) { return inst.result_id(); }; auto accept_type_ops = [](const opt::Instruction& inst) { return spvOpcodeGeneratesType(inst.opcode()); }; PoolPotentialIds(src_->types_values(), potential_id_map.src_ids, true, accept_type_ops, get_result_id); PoolPotentialIds(dst_->types_values(), potential_id_map.dst_ids, false, accept_type_ops, get_result_id); // Then match the ids. Start with exact matches, then match the leftover with // gradually loosening degrees of strictness. For example, in the absence of // debug info, two block types will be matched if they differ only in a few of // the fields. for (uint32_t flexibility = 0; flexibility < 2; ++flexibility) { MatchIds(potential_id_map, [this, flexibility]( const opt::Instruction* src_inst, const opt::Instruction* dst_inst) { const spv::Op src_op = src_inst->opcode(); const spv::Op dst_op = dst_inst->opcode(); // Don't match if the opcode is not the same. if (src_op != dst_op) { return false; } switch (src_op) { case spv::Op::OpTypeVoid: case spv::Op::OpTypeBool: case spv::Op::OpTypeSampler: case spv::Op::OpTypeAccelerationStructureNV: case spv::Op::OpTypeRayQueryKHR: // the above types have no operands and are unique, match them. return true; case spv::Op::OpTypeInt: case spv::Op::OpTypeFloat: case spv::Op::OpTypeVector: case spv::Op::OpTypeMatrix: case spv::Op::OpTypeSampledImage: case spv::Op::OpTypeRuntimeArray: case spv::Op::OpTypePointer: // Match these instructions when all operands match. assert(src_inst->NumInOperandWords() == dst_inst->NumInOperandWords()); return DoOperandsMatch(src_inst, dst_inst, 0, src_inst->NumInOperandWords()); case spv::Op::OpTypeFunction: case spv::Op::OpTypeImage: // Match function types only if they have the same number of operands, // and they all match. // Match image types similarly, expecting the optional final parameter // to match (if provided in both) if (src_inst->NumInOperandWords() != dst_inst->NumInOperandWords()) { return false; } return DoOperandsMatch(src_inst, dst_inst, 0, src_inst->NumInOperandWords()); case spv::Op::OpTypeArray: // Match arrays only if the element type and length match. The length // is an id of a constant, so the actual constant it's defining is // compared instead. if (!DoOperandsMatch(src_inst, dst_inst, 0, 1)) { return false; } if (AreIdenticalUintConstants(src_inst->GetSingleWordInOperand(1), dst_inst->GetSingleWordInOperand(1))) { return true; } // If size is not OpConstant, expect the ids to match exactly (for // example if a spec contant is used). return DoOperandsMatch(src_inst, dst_inst, 1, 1); case spv::Op::OpTypeStruct: return MatchOpTypeStruct(src_inst, dst_inst, flexibility); default: return false; } }); } } void Differ::MatchConstants() { // Bunch all of constant ids as potential matches. PotentialIdMap potential_id_map; auto get_result_id = [](const opt::Instruction& inst) { return inst.result_id(); }; auto accept_type_ops = [](const opt::Instruction& inst) { return spvOpcodeIsConstant(inst.opcode()); }; PoolPotentialIds(src_->types_values(), potential_id_map.src_ids, true, accept_type_ops, get_result_id); PoolPotentialIds(dst_->types_values(), potential_id_map.dst_ids, false, accept_type_ops, get_result_id); // Then match the ids. Constants are matched exactly, except for float types // that are first matched exactly, then leftovers are matched with a small // error. for (uint32_t flexibility = 0; flexibility < 2; ++flexibility) { MatchIds(potential_id_map, [this, flexibility]( const opt::Instruction* src_inst, const opt::Instruction* dst_inst) { const spv::Op src_op = src_inst->opcode(); const spv::Op dst_op = dst_inst->opcode(); // Don't match if the opcode is not the same. if (src_op != dst_op) { return false; } switch (src_op) { case spv::Op::OpConstantTrue: case spv::Op::OpConstantFalse: // true and false are unique, match them. return true; case spv::Op::OpConstant: return MatchOpConstant(src_inst, dst_inst, flexibility); case spv::Op::OpConstantComposite: case spv::Op::OpSpecConstantComposite: // Composite constants must match in type and value. // // TODO: match OpConstantNull with OpConstantComposite with all zeros // at flexibility == 1 // TODO: match constants from structs that have been flexibly-matched. if (src_inst->NumInOperandWords() != dst_inst->NumInOperandWords()) { return false; } return DoesOperandMatch(src_inst->GetOperand(0), dst_inst->GetOperand(0)) && DoOperandsMatch(src_inst, dst_inst, 0, src_inst->NumInOperandWords()); case spv::Op::OpConstantSampler: // Match sampler constants exactly. // TODO: Allow flexibility in parameters to better diff shaders where // the sampler param has changed. assert(src_inst->NumInOperandWords() == dst_inst->NumInOperandWords()); return DoOperandsMatch(src_inst, dst_inst, 0, src_inst->NumInOperandWords()); case spv::Op::OpConstantNull: // Match null constants as long as the type matches. return DoesOperandMatch(src_inst->GetOperand(0), dst_inst->GetOperand(0)); case spv::Op::OpSpecConstantTrue: case spv::Op::OpSpecConstantFalse: case spv::Op::OpSpecConstant: case spv::Op::OpSpecConstantOp: // Match spec constants by name if available, then by the SpecId // decoration. return MatchOpSpecConstant(src_inst, dst_inst); default: return false; } }); } } void Differ::MatchVariableIds() { // Bunch all of variable ids as potential matches. PotentialIdMap potential_id_map; auto get_result_id = [](const opt::Instruction& inst) { return inst.result_id(); }; auto accept_type_ops = [](const opt::Instruction& inst) { return inst.opcode() == spv::Op::OpVariable; }; PoolPotentialIds(src_->types_values(), potential_id_map.src_ids, true, accept_type_ops, get_result_id); PoolPotentialIds(dst_->types_values(), potential_id_map.dst_ids, false, accept_type_ops, get_result_id); // Then match the ids. Start with exact matches, then match the leftover with // gradually loosening degrees of strictness. For example, in the absence of // debug info, two otherwise identical variables will be matched if one of // them has a Private storage class and the other doesn't. for (uint32_t flexibility = 0; flexibility < 2; ++flexibility) { MatchIds(potential_id_map, [this, flexibility](const opt::Instruction* src_inst, const opt::Instruction* dst_inst) { assert(src_inst->opcode() == spv::Op::OpVariable); assert(dst_inst->opcode() == spv::Op::OpVariable); return MatchOpVariable(src_inst, dst_inst, flexibility); }); } } void Differ::MatchFunctions() { IdGroup src_func_ids; IdGroup dst_func_ids; for (const auto& func : src_funcs_) { src_func_ids.push_back(func.first); } for (const auto& func : dst_funcs_) { dst_func_ids.push_back(func.first); } // Base the matching of functions on debug info when available. GroupIdsAndMatch( src_func_ids, dst_func_ids, "", &Differ::GetSanitizedName, [this](const IdGroup& src_group, const IdGroup& dst_group) { // If there is a single function with this name in src and dst, it's a // definite match. if (src_group.size() == 1 && dst_group.size() == 1) { id_map_.MapIds(src_group[0], dst_group[0]); return; } // If there are multiple functions with the same name, group them by // type, and match only if the types match (and are unique). GroupIdsAndMatch(src_group, dst_group, 0, &Differ::GroupIdsHelperGetTypeId, [this](const IdGroup& src_group_by_type_id, const IdGroup& dst_group_by_type_id) { if (src_group_by_type_id.size() == 1 && dst_group_by_type_id.size() == 1) { id_map_.MapIds(src_group_by_type_id[0], dst_group_by_type_id[0]); } }); }); // Any functions that are left are pooled together and matched as if unnamed, // with the only exception that two functions with mismatching names are not // matched. // // Before that however, the diff of the functions that are matched are taken // and processed, so that more of the global variables can be matched before // attempting to match the rest of the functions. They can contribute to the // precision of the diff of those functions. for (const uint32_t src_func_id : src_func_ids) { const uint32_t dst_func_id = id_map_.MappedDstId(src_func_id); if (dst_func_id == 0) { continue; } // Since these functions are definite matches, match their parameters for a // better diff. MatchFunctionParamIds(src_funcs_[src_func_id], dst_funcs_[dst_func_id]); // Take the diff of the two functions. DiffMatch src_match_result, dst_match_result; MatchFunctionBodies(src_func_insts_[src_func_id], dst_func_insts_[dst_func_id], &src_match_result, &dst_match_result); // Match ids between the two function bodies; which can also result in // global variables getting matched. MatchIdsInFunctionBodies(src_func_insts_[src_func_id], dst_func_insts_[dst_func_id], src_match_result, dst_match_result, 0); } // Best effort match functions with matching type. GroupIdsAndMatch( src_func_ids, dst_func_ids, 0, &Differ::GroupIdsHelperGetTypeId, [this](const IdGroup& src_group_by_type_id, const IdGroup& dst_group_by_type_id) { BestEffortMatchFunctions(src_group_by_type_id, dst_group_by_type_id, src_func_insts_, dst_func_insts_); }); // Any function that's left, best effort match them. BestEffortMatchFunctions(src_func_ids, dst_func_ids, src_func_insts_, dst_func_insts_); } void Differ::MatchDebugs1() { // This section in cludes: OpString, OpSourceExtension, OpSource, // OpSourceContinued MatchDebugAndAnnotationInstructions(src_->debugs1(), dst_->debugs1()); } void Differ::MatchDebugs2() { // This section includes: OpName, OpMemberName MatchDebugAndAnnotationInstructions(src_->debugs2(), dst_->debugs2()); } void Differ::MatchDebugs3() { // This section includes: OpModuleProcessed MatchDebugAndAnnotationInstructions(src_->debugs3(), dst_->debugs3()); } void Differ::MatchExtInstDebugInfo() { // This section includes OpExtInst for DebugInfo extension MatchDebugAndAnnotationInstructions(src_->ext_inst_debuginfo(), dst_->ext_inst_debuginfo()); } void Differ::MatchAnnotations() { // This section includes OpDecorate and family. MatchDebugAndAnnotationInstructions(src_->annotations(), dst_->annotations()); } const opt::Instruction* Differ::MappedDstInst( const opt::Instruction* src_inst) { return MappedInstImpl(src_inst, id_map_.SrcToDstMap(), dst_id_to_); } const opt::Instruction* Differ::MappedSrcInst( const opt::Instruction* dst_inst) { return MappedInstImpl(dst_inst, id_map_.DstToSrcMap(), src_id_to_); } const opt::Instruction* Differ::MappedInstImpl( const opt::Instruction* inst, const IdMap& to_other, const IdInstructions& other_id_to) { if (inst->HasResultId()) { if (to_other.IsMapped(inst->result_id())) { const uint32_t other_result_id = to_other.MappedId(inst->result_id()); assert(other_result_id < other_id_to.inst_map_.size()); return other_id_to.inst_map_[other_result_id]; } return nullptr; } return to_other.MappedInst(inst); } void Differ::OutputLine(std::function are_lines_identical, std::function output_src_line, std::function output_dst_line) { if (are_lines_identical()) { out_ << " "; output_src_line(); } else { OutputRed(); out_ << "-"; output_src_line(); OutputGreen(); out_ << "+"; output_dst_line(); OutputResetColor(); } } const opt::Instruction* IterInst(opt::Module::const_inst_iterator& iter) { return &*iter; } const opt::Instruction* IterInst(InstructionList::const_iterator& iter) { return *iter; } template void Differ::OutputSection( const InstList& src_insts, const InstList& dst_insts, std::function write_inst) { auto src_iter = src_insts.begin(); auto dst_iter = dst_insts.begin(); // - While src_inst doesn't have a match, output it with - // - While dst_inst doesn't have a match, output it with + // - Now src_inst and dst_inst both have matches; might not match each other! // * If section is unordered, just process src_inst and its match (dst_inst // or not), // dst_inst will eventually be processed when its match is seen. // * If section is ordered, also just process src_inst and its match. Its // match must // necessarily be dst_inst. while (src_iter != src_insts.end() || dst_iter != dst_insts.end()) { OutputRed(); while (src_iter != src_insts.end() && MappedDstInst(IterInst(src_iter)) == nullptr) { out_ << "-"; write_inst(*IterInst(src_iter), src_id_to_, *IterInst(src_iter)); ++src_iter; } OutputGreen(); while (dst_iter != dst_insts.end() && MappedSrcInst(IterInst(dst_iter)) == nullptr) { out_ << "+"; write_inst(ToMappedSrcIds(*IterInst(dst_iter)), dst_id_to_, *IterInst(dst_iter)); ++dst_iter; } OutputResetColor(); if (src_iter != src_insts.end() && dst_iter != dst_insts.end()) { const opt::Instruction* src_inst = IterInst(src_iter); const opt::Instruction* matched_dst_inst = MappedDstInst(src_inst); assert(matched_dst_inst != nullptr); assert(MappedSrcInst(IterInst(dst_iter)) != nullptr); OutputLine( [this, src_inst, matched_dst_inst]() { return DoInstructionsMatch(src_inst, matched_dst_inst); }, [this, src_inst, &write_inst]() { write_inst(*src_inst, src_id_to_, *src_inst); }, [this, matched_dst_inst, &write_inst]() { write_inst(ToMappedSrcIds(*matched_dst_inst), dst_id_to_, *matched_dst_inst); }); ++src_iter; ++dst_iter; } } } void Differ::ToParsedInstruction( const opt::Instruction& inst, const IdInstructions& id_to, const opt::Instruction& original_inst, spv_parsed_instruction_t* parsed_inst, std::vector& parsed_operands, std::vector& inst_binary) { inst.ToBinaryWithoutAttachedDebugInsts(&inst_binary); parsed_operands.resize(inst.NumOperands()); parsed_inst->words = inst_binary.data(); parsed_inst->num_words = static_cast(inst_binary.size()); parsed_inst->opcode = static_cast(inst.opcode()); parsed_inst->ext_inst_type = inst.opcode() == spv::Op::OpExtInst ? GetExtInstType(id_to, original_inst.GetSingleWordInOperand(0)) : SPV_EXT_INST_TYPE_NONE; parsed_inst->type_id = inst.HasResultType() ? inst.GetSingleWordOperand(0) : 0; parsed_inst->result_id = inst.HasResultId() ? inst.result_id() : 0; parsed_inst->operands = parsed_operands.data(); parsed_inst->num_operands = static_cast(parsed_operands.size()); // Word 0 is always op and num_words, so operands start at offset 1. uint32_t offset = 1; for (uint16_t operand_index = 0; operand_index < parsed_inst->num_operands; ++operand_index) { const opt::Operand& operand = inst.GetOperand(operand_index); spv_parsed_operand_t& parsed_operand = parsed_operands[operand_index]; parsed_operand.offset = static_cast(offset); parsed_operand.num_words = static_cast(operand.words.size()); parsed_operand.type = operand.type; parsed_operand.number_kind = GetNumberKind( id_to, original_inst, operand_index, &parsed_operand.number_bit_width); offset += parsed_operand.num_words; } } opt::Instruction Differ::ToMappedSrcIds(const opt::Instruction& dst_inst) { // Create an identical instruction to dst_inst, except ids are changed to the // mapped one. opt::Instruction mapped_inst = dst_inst; for (uint32_t operand_index = 0; operand_index < mapped_inst.NumOperands(); ++operand_index) { opt::Operand& operand = mapped_inst.GetOperand(operand_index); if (spvIsIdType(operand.type)) { assert(id_map_.IsDstMapped(operand.AsId())); operand.words[0] = id_map_.MappedSrcId(operand.AsId()); } } return mapped_inst; } spv_result_t Differ::Output() { id_map_.MapUnmatchedIds( [this](uint32_t src_id) { return src_id_to_.IsDefined(src_id); }, [this](uint32_t dst_id) { return dst_id_to_.IsDefined(dst_id); }); src_id_to_.inst_map_.resize(id_map_.SrcToDstMap().IdBound(), nullptr); dst_id_to_.inst_map_.resize(id_map_.DstToSrcMap().IdBound(), nullptr); const spv_target_env target_env = SPV_ENV_UNIVERSAL_1_6; spv_opcode_table opcode_table; spv_operand_table operand_table; spv_ext_inst_table ext_inst_table; spv_result_t result; result = spvOpcodeTableGet(&opcode_table, target_env); if (result != SPV_SUCCESS) return result; result = spvOperandTableGet(&operand_table, target_env); if (result != SPV_SUCCESS) return result; result = spvExtInstTableGet(&ext_inst_table, target_env); if (result != SPV_SUCCESS) return result; spv_context_t context{ target_env, opcode_table, operand_table, ext_inst_table, }; const AssemblyGrammar grammar(&context); if (!grammar.isValid()) return SPV_ERROR_INVALID_TABLE; uint32_t disassembly_options = SPV_BINARY_TO_TEXT_OPTION_PRINT; if (options_.indent) { disassembly_options |= SPV_BINARY_TO_TEXT_OPTION_INDENT; } NameMapper name_mapper = GetTrivialNameMapper(); disassemble::InstructionDisassembler dis(grammar, out_, disassembly_options, name_mapper); if (!options_.no_header) { // Output the header // TODO: when using diff with text, the assembler overrides the version and // generator, so these aren't reflected correctly in the output. Could // potentially extract this info from the header comment. OutputLine([]() { return true; }, [&dis]() { dis.EmitHeaderSpirv(); }, []() { assert(false && "Unreachable"); }); OutputLine([this]() { return src_->version() == dst_->version(); }, [this, &dis]() { dis.EmitHeaderVersion(src_->version()); }, [this, &dis]() { dis.EmitHeaderVersion(dst_->version()); }); OutputLine([this]() { return src_->generator() == dst_->generator(); }, [this, &dis]() { dis.EmitHeaderGenerator(src_->generator()); }, [this, &dis]() { dis.EmitHeaderGenerator(dst_->generator()); }); OutputLine( [this]() { return src_->IdBound() == id_map_.SrcToDstMap().IdBound(); }, [this, &dis]() { dis.EmitHeaderIdBound(src_->IdBound()); }, [this, &dis]() { dis.EmitHeaderIdBound(id_map_.SrcToDstMap().IdBound()); }); OutputLine([this]() { return src_->schema() == dst_->schema(); }, [this, &dis]() { dis.EmitHeaderSchema(src_->schema()); }, [this, &dis]() { dis.EmitHeaderSchema(dst_->schema()); }); } // For each section, iterate both modules and output the disassembly. auto write_inst = [this, &dis](const opt::Instruction& inst, const IdInstructions& id_to, const opt::Instruction& original_inst) { spv_parsed_instruction_t parsed_inst; std::vector parsed_operands; std::vector inst_binary; ToParsedInstruction(inst, id_to, original_inst, &parsed_inst, parsed_operands, inst_binary); dis.EmitInstruction(parsed_inst, 0); }; OutputSection(src_->capabilities(), dst_->capabilities(), write_inst); OutputSection(src_->extensions(), dst_->extensions(), write_inst); OutputSection(src_->ext_inst_imports(), dst_->ext_inst_imports(), write_inst); // There is only one memory model. OutputLine( [this]() { return DoInstructionsMatch(src_->GetMemoryModel(), dst_->GetMemoryModel()); }, [this, &write_inst]() { write_inst(*src_->GetMemoryModel(), src_id_to_, *src_->GetMemoryModel()); }, [this, &write_inst]() { write_inst(*dst_->GetMemoryModel(), dst_id_to_, *dst_->GetMemoryModel()); }); OutputSection(src_->entry_points(), dst_->entry_points(), write_inst); OutputSection(src_->execution_modes(), dst_->execution_modes(), write_inst); OutputSection(src_->debugs1(), dst_->debugs1(), write_inst); OutputSection(src_->debugs2(), dst_->debugs2(), write_inst); OutputSection(src_->debugs3(), dst_->debugs3(), write_inst); OutputSection(src_->ext_inst_debuginfo(), dst_->ext_inst_debuginfo(), write_inst); OutputSection(src_->annotations(), dst_->annotations(), write_inst); OutputSection(src_->types_values(), dst_->types_values(), write_inst); // Get the body of all the functions. FunctionInstMap src_func_header_insts; FunctionInstMap dst_func_header_insts; GetFunctionHeaderInstructions(src_, &src_func_header_insts); GetFunctionHeaderInstructions(dst_, &dst_func_header_insts); for (const auto& src_func : src_func_insts_) { const uint32_t src_func_id = src_func.first; const InstructionList& src_insts = src_func.second; const InstructionList& src_header_insts = src_func_header_insts[src_func_id]; const uint32_t dst_func_id = id_map_.MappedDstId(src_func_id); if (dst_func_insts_.find(dst_func_id) == dst_func_insts_.end()) { OutputSection(src_header_insts, InstructionList(), write_inst); OutputSection(src_insts, InstructionList(), write_inst); continue; } const InstructionList& dst_insts = dst_func_insts_[dst_func_id]; const InstructionList& dst_header_insts = dst_func_header_insts[dst_func_id]; OutputSection(src_header_insts, dst_header_insts, write_inst); OutputSection(src_insts, dst_insts, write_inst); } for (const auto& dst_func : dst_func_insts_) { const uint32_t dst_func_id = dst_func.first; const InstructionList& dst_insts = dst_func.second; const InstructionList& dst_header_insts = dst_func_header_insts[dst_func_id]; const uint32_t src_func_id = id_map_.MappedSrcId(dst_func_id); if (src_func_insts_.find(src_func_id) == src_func_insts_.end()) { OutputSection(InstructionList(), dst_header_insts, write_inst); OutputSection(InstructionList(), dst_insts, write_inst); } } out_ << std::flush; return SPV_SUCCESS; } } // anonymous namespace spv_result_t Diff(opt::IRContext* src, opt::IRContext* dst, std::ostream& out, Options options) { // High level algorithm: // // - Some sections of SPIR-V don't deal with ids; instructions in those // sections are matched identically. For example OpCapability instructions. // - Some sections produce ids, and they can be trivially matched by their // parameters. For example OpExtInstImport instructions. // - Some sections annotate ids. These are matched at the end, after the ids // themselves are matched. For example OpName or OpDecorate instructions. // - Some sections produce ids that depend on other ids and they can be // recursively matched. For example OpType* instructions. // - Some sections produce ids that are not trivially matched. For these ids, // the debug info is used when possible, or a best guess (such as through // decorations) is used. For example OpVariable instructions. // - Matching functions is done with multiple attempts: // * Functions with identical debug names are matched if there are no // overloads. // * Otherwise, functions with identical debug names and types are matched. // * The rest of the functions are best-effort matched, first in groups of // identical type, then any with any. // * The best-effort matching takes the diff of every pair of functions in // a group and selects the top matches that also meet a similarity // index. // * Once a pair of functions are matched, the fuzzy diff of the // instructions is used to match the instructions in the function body. // The fuzzy diff makes sure that sufficiently similar instructions are // matched and that yet-to-be-matched result ids don't result in a larger // diff. // // Once the instructions are matched between the src and dst SPIR-V, the src // is traversed and its disassembly is output. In the process, any unmatched // instruction is prefixed with -, and any unmatched instruction in dst in the // same section is output prefixed with +. To avoid confusion, the // instructions in dst are output with matching ids in src so the output // assembly is consistent. Differ differ(src, dst, out, options); // First, match instructions between the different non-annotation sections of // the SPIR-V. differ.MatchCapabilities(); differ.MatchExtensions(); differ.MatchExtInstImportIds(); differ.MatchMemoryModel(); differ.MatchEntryPointIds(); differ.MatchExecutionModes(); differ.MatchTypeForwardPointers(); differ.MatchTypeIds(); differ.MatchConstants(); differ.MatchVariableIds(); differ.MatchFunctions(); // Match instructions that annotate previously-matched ids. differ.MatchDebugs1(); differ.MatchDebugs2(); differ.MatchDebugs3(); differ.MatchExtInstDebugInfo(); differ.MatchAnnotations(); // Show the disassembly with the diff. // // TODO: Based on an option, output either based on src or dst, i.e. the diff // can show the ids and instruction/function order either from src or dst. spv_result_t result = differ.Output(); differ.DumpIdMap(); return result; } } // namespace diff } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/diff/diff.h000066400000000000000000000032751475742701700220310ustar00rootroot00000000000000// Copyright (c) 2022 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_DIFF_DIFF_H_ #define SOURCE_DIFF_DIFF_H_ #include "source/opt/ir_context.h" namespace spvtools { namespace diff { struct Options { bool ignore_set_binding = false; bool ignore_location = false; bool indent = false; bool no_header = false; bool color_output = false; bool dump_id_map = false; }; // Given two SPIR-V modules, this function outputs the textual diff of their // assembly in `out`. The diff is *semantic*, so that the ordering of certain // instructions wouldn't matter. // // The output is a disassembly of src, with diff(1)-style + and - lines that // show how the src is changed into dst. To make this disassembly // self-consistent, the ids that are output are all in the space of the src // module; e.g. any + lines (showing instructions from the dst module) have // their ids mapped to the matched instruction in the src module (or a new id // allocated in the src module if unmatched). spv_result_t Diff(opt::IRContext* src, opt::IRContext* dst, std::ostream& out, Options options); } // namespace diff } // namespace spvtools #endif // SOURCE_DIFF_DIFF_H_ KhronosGroup-SPIRV-Tools-f289d04/source/diff/lcs.h000066400000000000000000000165041475742701700217010ustar00rootroot00000000000000// Copyright (c) 2022 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_DIFF_LCS_H_ #define SOURCE_DIFF_LCS_H_ #include #include #include #include #include #include #include namespace spvtools { namespace diff { // The result of a diff. using DiffMatch = std::vector; // Helper class to find the longest common subsequence between two function // bodies. template class LongestCommonSubsequence { public: LongestCommonSubsequence(const Sequence& src, const Sequence& dst) : src_(src), dst_(dst), table_(src.size(), std::vector(dst.size())) {} // Given two sequences, it creates a matching between them. The elements are // simply marked as matched in src and dst, with any unmatched element in src // implying a removal and any unmatched element in dst implying an addition. // // Returns the length of the longest common subsequence. template uint32_t Get(std::function match, DiffMatch* src_match_result, DiffMatch* dst_match_result); private: struct DiffMatchIndex { uint32_t src_offset; uint32_t dst_offset; }; template void CalculateLCS(std::function match); void RetrieveMatch(DiffMatch* src_match_result, DiffMatch* dst_match_result); bool IsInBound(DiffMatchIndex index) { return index.src_offset < src_.size() && index.dst_offset < dst_.size(); } bool IsCalculated(DiffMatchIndex index) { assert(IsInBound(index)); return table_[index.src_offset][index.dst_offset].valid; } bool IsCalculatedOrOutOfBound(DiffMatchIndex index) { return !IsInBound(index) || IsCalculated(index); } uint32_t GetMemoizedLength(DiffMatchIndex index) { if (!IsInBound(index)) { return 0; } assert(IsCalculated(index)); return table_[index.src_offset][index.dst_offset].best_match_length; } bool IsMatched(DiffMatchIndex index) { assert(IsCalculated(index)); return table_[index.src_offset][index.dst_offset].matched; } void MarkMatched(DiffMatchIndex index, uint32_t best_match_length, bool matched) { assert(IsInBound(index)); DiffMatchEntry& entry = table_[index.src_offset][index.dst_offset]; assert(!entry.valid); entry.best_match_length = best_match_length & 0x3FFFFFFF; assert(entry.best_match_length == best_match_length); entry.matched = matched; entry.valid = true; } const Sequence& src_; const Sequence& dst_; struct DiffMatchEntry { DiffMatchEntry() : best_match_length(0), matched(false), valid(false) {} uint32_t best_match_length : 30; // Whether src[i] and dst[j] matched. This is an optimization to avoid // calling the `match` function again when walking the LCS table. uint32_t matched : 1; // Use for the recursive algorithm to know if the contents of this entry are // valid. uint32_t valid : 1; }; std::vector> table_; }; template template uint32_t LongestCommonSubsequence::Get( std::function match, DiffMatch* src_match_result, DiffMatch* dst_match_result) { CalculateLCS(match); RetrieveMatch(src_match_result, dst_match_result); return GetMemoizedLength({0, 0}); } template template void LongestCommonSubsequence::CalculateLCS( std::function match) { // The LCS algorithm is simple. Given sequences s and d, with a:b depicting a // range in python syntax: // // lcs(s[i:], d[j:]) = // lcs(s[i+1:], d[j+1:]) + 1 if s[i] == d[j] // max(lcs(s[i+1:], d[j:]), lcs(s[i:], d[j+1:])) o.w. // // Once the LCS table is filled according to the above, it can be walked and // the best match retrieved. // // This is a recursive function with memoization, which avoids filling table // entries where unnecessary. This makes the best case O(N) instead of // O(N^2). The implemention uses a std::stack to avoid stack overflow on long // sequences. if (src_.empty() || dst_.empty()) { return; } std::stack to_calculate; to_calculate.push({0, 0}); while (!to_calculate.empty()) { DiffMatchIndex current = to_calculate.top(); to_calculate.pop(); assert(IsInBound(current)); // If already calculated through another path, ignore it. if (IsCalculated(current)) { continue; } if (match(src_[current.src_offset], dst_[current.dst_offset])) { // If the current elements match, advance both indices and calculate the // LCS if not already. Visit `current` again afterwards, so its // corresponding entry will be updated. DiffMatchIndex next = {current.src_offset + 1, current.dst_offset + 1}; if (IsCalculatedOrOutOfBound(next)) { MarkMatched(current, GetMemoizedLength(next) + 1, true); } else { to_calculate.push(current); to_calculate.push(next); } continue; } // We've reached a pair of elements that don't match. Calculate the LCS for // both cases of either being left unmatched and take the max. Visit // `current` again afterwards, so its corresponding entry will be updated. DiffMatchIndex next_src = {current.src_offset + 1, current.dst_offset}; DiffMatchIndex next_dst = {current.src_offset, current.dst_offset + 1}; if (IsCalculatedOrOutOfBound(next_src) && IsCalculatedOrOutOfBound(next_dst)) { uint32_t best_match_length = std::max(GetMemoizedLength(next_src), GetMemoizedLength(next_dst)); MarkMatched(current, best_match_length, false); continue; } to_calculate.push(current); if (!IsCalculatedOrOutOfBound(next_src)) { to_calculate.push(next_src); } if (!IsCalculatedOrOutOfBound(next_dst)) { to_calculate.push(next_dst); } } } template void LongestCommonSubsequence::RetrieveMatch( DiffMatch* src_match_result, DiffMatch* dst_match_result) { src_match_result->clear(); dst_match_result->clear(); src_match_result->resize(src_.size(), false); dst_match_result->resize(dst_.size(), false); DiffMatchIndex current = {0, 0}; while (IsInBound(current)) { if (IsMatched(current)) { (*src_match_result)[current.src_offset++] = true; (*dst_match_result)[current.dst_offset++] = true; continue; } if (GetMemoizedLength({current.src_offset + 1, current.dst_offset}) >= GetMemoizedLength({current.src_offset, current.dst_offset + 1})) { ++current.src_offset; } else { ++current.dst_offset; } } } } // namespace diff } // namespace spvtools #endif // SOURCE_DIFF_LCS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/disassemble.cpp000066400000000000000000001173031475742701700230350ustar00rootroot00000000000000// Copyright (c) 2015-2020 The Khronos Group Inc. // Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights // reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // This file contains a disassembler: It converts a SPIR-V binary // to text. #include "source/disassemble.h" #include #include #include #include #include #include #include #include #include #include #include #include "source/assembly_grammar.h" #include "source/binary.h" #include "source/diagnostic.h" #include "source/ext_inst.h" #include "source/opcode.h" #include "source/parsed_operand.h" #include "source/print.h" #include "source/spirv_constant.h" #include "source/spirv_endian.h" #include "source/util/hex_float.h" #include "source/util/make_unique.h" #include "spirv-tools/libspirv.h" namespace spvtools { namespace { // Indices to ControlFlowGraph's list of blocks from one block to its successors struct BlockSuccessors { // Merge block in OpLoopMerge and OpSelectionMerge uint32_t merge_block_id = 0; // The continue block in OpLoopMerge uint32_t continue_block_id = 0; // The true and false blocks in OpBranchConditional uint32_t true_block_id = 0; uint32_t false_block_id = 0; // The body block of a loop, as specified by OpBranch after a merge // instruction uint32_t body_block_id = 0; // The same-nesting-level block that follows this one, indicated by an // OpBranch with no merge instruction. uint32_t next_block_id = 0; // The cases (including default) of an OpSwitch std::vector case_block_ids; }; class ParsedInstruction { public: ParsedInstruction(const spv_parsed_instruction_t* instruction) { // Make a copy of the parsed instruction, including stable memory for its // operands. instruction_ = *instruction; operands_ = std::make_unique(instruction->num_operands); memcpy(operands_.get(), instruction->operands, instruction->num_operands * sizeof(*instruction->operands)); instruction_.operands = operands_.get(); } const spv_parsed_instruction_t* get() const { return &instruction_; } private: spv_parsed_instruction_t instruction_; std::unique_ptr operands_; }; // One block in the CFG struct SingleBlock { // The byte offset in the SPIR-V where the block starts. Used for printing in // a comment. size_t byte_offset; // Block instructions std::vector instructions; // Successors of this block BlockSuccessors successors; // The nesting level for this block. uint32_t nest_level = 0; bool nest_level_assigned = false; // Whether the block was reachable bool reachable = false; }; // CFG for one function struct ControlFlowGraph { std::vector blocks; }; // A Disassembler instance converts a SPIR-V binary to its assembly // representation. class Disassembler { public: Disassembler(const AssemblyGrammar& grammar, uint32_t options, NameMapper name_mapper) : print_(spvIsInBitfield(SPV_BINARY_TO_TEXT_OPTION_PRINT, options)), nested_indent_( spvIsInBitfield(SPV_BINARY_TO_TEXT_OPTION_NESTED_INDENT, options)), reorder_blocks_( spvIsInBitfield(SPV_BINARY_TO_TEXT_OPTION_REORDER_BLOCKS, options)), text_(), out_(print_ ? out_stream() : out_stream(text_)), instruction_disassembler_(grammar, out_.get(), options, name_mapper), header_(!spvIsInBitfield(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER, options)), byte_offset_(0) {} // Emits the assembly header for the module, and sets up internal state // so subsequent callbacks can handle the cases where the entire module // is either big-endian or little-endian. spv_result_t HandleHeader(spv_endianness_t endian, uint32_t version, uint32_t generator, uint32_t id_bound, uint32_t schema); // Emits the assembly text for the given instruction. spv_result_t HandleInstruction(const spv_parsed_instruction_t& inst); // If not printing, populates text_result with the accumulated text. // Returns SPV_SUCCESS on success. spv_result_t SaveTextResult(spv_text* text_result) const; private: void EmitCFG(); const bool print_; // Should we also print to the standard output stream? const bool nested_indent_; // Should the blocks be indented according to the // control flow structure? const bool reorder_blocks_; // Should the blocks be reordered for readability? spv_endianness_t endian_; // The detected endianness of the binary. std::stringstream text_; // Captures the text, if not printing. out_stream out_; // The Output stream. Either to text_ or standard output. disassemble::InstructionDisassembler instruction_disassembler_; const bool header_; // Should we output header as the leading comment? size_t byte_offset_; // The number of bytes processed so far. bool inserted_decoration_space_ = false; bool inserted_debug_space_ = false; bool inserted_type_space_ = false; // The CFG for the current function ControlFlowGraph current_function_cfg_; }; spv_result_t Disassembler::HandleHeader(spv_endianness_t endian, uint32_t version, uint32_t generator, uint32_t id_bound, uint32_t schema) { endian_ = endian; if (header_) { instruction_disassembler_.EmitHeaderSpirv(); instruction_disassembler_.EmitHeaderVersion(version); instruction_disassembler_.EmitHeaderGenerator(generator); instruction_disassembler_.EmitHeaderIdBound(id_bound); instruction_disassembler_.EmitHeaderSchema(schema); } byte_offset_ = SPV_INDEX_INSTRUCTION * sizeof(uint32_t); return SPV_SUCCESS; } spv_result_t Disassembler::HandleInstruction( const spv_parsed_instruction_t& inst) { instruction_disassembler_.EmitSectionComment(inst, inserted_decoration_space_, inserted_debug_space_, inserted_type_space_); // When nesting needs to be calculated or when the blocks are reordered, we // have to have the full picture of the CFG first. Defer processing of the // instructions until the entire function is visited. This is not done // without those options (even if simpler) to improve debuggability; for // example to be able to see whatever is parsed so far even if there is a // parse error. if (nested_indent_ || reorder_blocks_) { switch (static_cast(inst.opcode)) { case spv::Op::OpLabel: { // Add a new block to the CFG SingleBlock new_block; new_block.byte_offset = byte_offset_; new_block.instructions.emplace_back(&inst); current_function_cfg_.blocks.push_back(std::move(new_block)); break; } case spv::Op::OpFunctionEnd: // Process the CFG and output the instructions EmitCFG(); // Output OpFunctionEnd itself too [[fallthrough]]; default: if (!current_function_cfg_.blocks.empty()) { // If in a function, stash the instruction for later. current_function_cfg_.blocks.back().instructions.emplace_back(&inst); } else { // Otherwise emit the instruction right away. instruction_disassembler_.EmitInstruction(inst, byte_offset_); } break; } } else { instruction_disassembler_.EmitInstruction(inst, byte_offset_); } byte_offset_ += inst.num_words * sizeof(uint32_t); return SPV_SUCCESS; } // Helper to get the operand of an instruction as an id. uint32_t GetOperand(const spv_parsed_instruction_t* instruction, uint32_t operand) { return instruction->words[instruction->operands[operand].offset]; } std::unordered_map BuildControlFlowGraph( ControlFlowGraph& cfg) { std::unordered_map id_to_index; for (size_t index = 0; index < cfg.blocks.size(); ++index) { SingleBlock& block = cfg.blocks[index]; // For future use, build the ID->index map assert(static_cast(block.instructions[0].get()->opcode) == spv::Op::OpLabel); const uint32_t id = block.instructions[0].get()->result_id; id_to_index[id] = static_cast(index); // Look for a merge instruction first. The function of OpBranch depends on // that. if (block.instructions.size() >= 3) { const spv_parsed_instruction_t* maybe_merge = block.instructions[block.instructions.size() - 2].get(); switch (static_cast(maybe_merge->opcode)) { case spv::Op::OpLoopMerge: block.successors.merge_block_id = GetOperand(maybe_merge, 0); block.successors.continue_block_id = GetOperand(maybe_merge, 1); break; case spv::Op::OpSelectionMerge: block.successors.merge_block_id = GetOperand(maybe_merge, 0); break; default: break; } } // Then look at the last instruction; it must be a branch assert(block.instructions.size() >= 2); const spv_parsed_instruction_t* branch = block.instructions.back().get(); switch (static_cast(branch->opcode)) { case spv::Op::OpBranch: if (block.successors.merge_block_id != 0) { block.successors.body_block_id = GetOperand(branch, 0); } else { block.successors.next_block_id = GetOperand(branch, 0); } break; case spv::Op::OpBranchConditional: block.successors.true_block_id = GetOperand(branch, 1); block.successors.false_block_id = GetOperand(branch, 2); break; case spv::Op::OpSwitch: for (uint32_t case_index = 1; case_index < branch->num_operands; case_index += 2) { block.successors.case_block_ids.push_back( GetOperand(branch, case_index)); } break; default: break; } } return id_to_index; } // Helper to deal with nesting and non-existing ids / previously-assigned // levels. It assigns a given nesting level `level` to the block identified by // `id` (unless that block already has a nesting level assigned). void Nest(ControlFlowGraph& cfg, const std::unordered_map& id_to_index, uint32_t id, uint32_t level) { if (id == 0) { return; } const uint32_t block_index = id_to_index.at(id); SingleBlock& block = cfg.blocks[block_index]; if (!block.nest_level_assigned) { block.nest_level = level; block.nest_level_assigned = true; } } // For a given block, assign nesting level to its successors. void NestSuccessors(ControlFlowGraph& cfg, const SingleBlock& block, const std::unordered_map& id_to_index) { assert(block.nest_level_assigned); // Nest loops as such: // // %loop = OpLabel // OpLoopMerge %merge %cont ... // OpBranch %body // %body = OpLabel // Op... // %cont = OpLabel // Op... // %merge = OpLabel // Op... // // Nest conditional branches as such: // // %header = OpLabel // OpSelectionMerge %merge ... // OpBranchConditional ... %true %false // %true = OpLabel // Op... // %false = OpLabel // Op... // %merge = OpLabel // Op... // // Nest switch/case as such: // // %header = OpLabel // OpSelectionMerge %merge ... // OpSwitch ... %default ... %case0 ... %case1 ... // %default = OpLabel // Op... // %case0 = OpLabel // Op... // %case1 = OpLabel // Op... // ... // %merge = OpLabel // Op... // // The following can be observed: // // - In all cases, the merge block has the same nesting as this block // - The continue block of loops is nested 1 level deeper // - The body/branches/cases are nested 2 levels deeper // // Back branches to the header block, branches to the merge block, etc // are correctly handled by processing the header block first (that is // _this_ block, already processed), then following the above rules // (in the same order) for any block that is not already processed. Nest(cfg, id_to_index, block.successors.merge_block_id, block.nest_level); Nest(cfg, id_to_index, block.successors.continue_block_id, block.nest_level + 1); Nest(cfg, id_to_index, block.successors.true_block_id, block.nest_level + 2); Nest(cfg, id_to_index, block.successors.false_block_id, block.nest_level + 2); Nest(cfg, id_to_index, block.successors.body_block_id, block.nest_level + 2); Nest(cfg, id_to_index, block.successors.next_block_id, block.nest_level); for (uint32_t case_block_id : block.successors.case_block_ids) { Nest(cfg, id_to_index, case_block_id, block.nest_level + 2); } } struct StackEntry { // The index of the block (in ControlFlowGraph::blocks) to process. uint32_t block_index; // Whether this is the pre or post visit of the block. Because a post-visit // traversal is needed, the same block is pushed back on the stack on // pre-visit so it can be visited again on post-visit. bool post_visit = false; }; // Helper to deal with DFS traversal and non-existing ids void VisitSuccesor(std::stack* dfs_stack, const std::unordered_map& id_to_index, uint32_t id) { if (id != 0) { dfs_stack->push({id_to_index.at(id), false}); } } // Given the control flow graph, calculates and returns the reverse post-order // ordering of the blocks. The blocks are then disassembled in that order for // readability. std::vector OrderBlocks( ControlFlowGraph& cfg, const std::unordered_map& id_to_index) { std::vector post_order; // Nest level of a function's first block is 0. cfg.blocks[0].nest_level = 0; cfg.blocks[0].nest_level_assigned = true; // Stack of block indices as they are visited. std::stack dfs_stack; dfs_stack.push({0, false}); std::set visited; while (!dfs_stack.empty()) { const uint32_t block_index = dfs_stack.top().block_index; const bool post_visit = dfs_stack.top().post_visit; dfs_stack.pop(); // If this is the second time the block is visited, that's the post-order // visit. if (post_visit) { post_order.push_back(block_index); continue; } // If already visited, another path got to it first (like a case // fallthrough), avoid reprocessing it. if (visited.count(block_index) > 0) { continue; } visited.insert(block_index); // Push it back in the stack for post-order visit dfs_stack.push({block_index, true}); SingleBlock& block = cfg.blocks[block_index]; // Assign nest levels of successors right away. The successors are either // nested under this block, or are back or forward edges to blocks outside // this nesting level (no farther than the merge block), whose nesting // levels are already assigned before this block is visited. NestSuccessors(cfg, block, id_to_index); block.reachable = true; // The post-order visit yields the order in which the blocks are naturally // ordered _backwards_. So blocks to be ordered last should be visited // first. In other words, they should be pushed to the DFS stack last. VisitSuccesor(&dfs_stack, id_to_index, block.successors.true_block_id); VisitSuccesor(&dfs_stack, id_to_index, block.successors.false_block_id); VisitSuccesor(&dfs_stack, id_to_index, block.successors.body_block_id); VisitSuccesor(&dfs_stack, id_to_index, block.successors.next_block_id); for (uint32_t case_block_id : block.successors.case_block_ids) { VisitSuccesor(&dfs_stack, id_to_index, case_block_id); } VisitSuccesor(&dfs_stack, id_to_index, block.successors.continue_block_id); VisitSuccesor(&dfs_stack, id_to_index, block.successors.merge_block_id); } std::vector order(post_order.rbegin(), post_order.rend()); // Finally, dump all unreachable blocks at the end for (size_t index = 0; index < cfg.blocks.size(); ++index) { SingleBlock& block = cfg.blocks[index]; if (!block.reachable) { order.push_back(static_cast(index)); block.nest_level = 0; block.nest_level_assigned = true; } } return order; } void Disassembler::EmitCFG() { // Build the CFG edges. At the same time, build an ID->block index map to // simplify building the CFG edges. const std::unordered_map id_to_index = BuildControlFlowGraph(current_function_cfg_); // Walk the CFG in reverse post-order to find the best ordering of blocks for // presentation std::vector block_order = OrderBlocks(current_function_cfg_, id_to_index); assert(block_order.size() == current_function_cfg_.blocks.size()); // Walk the CFG either in block order or input order based on whether the // reorder_blocks_ option is given. for (uint32_t index = 0; index < current_function_cfg_.blocks.size(); ++index) { const uint32_t block_index = reorder_blocks_ ? block_order[index] : index; const SingleBlock& block = current_function_cfg_.blocks[block_index]; // Emit instructions for this block size_t byte_offset = block.byte_offset; assert(block.nest_level_assigned); for (const ParsedInstruction& inst : block.instructions) { instruction_disassembler_.EmitInstructionInBlock(*inst.get(), byte_offset, block.nest_level); byte_offset += inst.get()->num_words * sizeof(uint32_t); } } current_function_cfg_.blocks.clear(); } spv_result_t Disassembler::SaveTextResult(spv_text* text_result) const { if (!print_) { size_t length = text_.str().size(); char* str = new char[length + 1]; if (!str) return SPV_ERROR_OUT_OF_MEMORY; strncpy(str, text_.str().c_str(), length + 1); spv_text text = new spv_text_t(); if (!text) { delete[] str; return SPV_ERROR_OUT_OF_MEMORY; } text->str = str; text->length = length; *text_result = text; } return SPV_SUCCESS; } spv_result_t DisassembleHeader(void* user_data, spv_endianness_t endian, uint32_t /* magic */, uint32_t version, uint32_t generator, uint32_t id_bound, uint32_t schema) { assert(user_data); auto disassembler = static_cast(user_data); return disassembler->HandleHeader(endian, version, generator, id_bound, schema); } spv_result_t DisassembleInstruction( void* user_data, const spv_parsed_instruction_t* parsed_instruction) { assert(user_data); auto disassembler = static_cast(user_data); return disassembler->HandleInstruction(*parsed_instruction); } // Simple wrapper class to provide extra data necessary for targeted // instruction disassembly. class WrappedDisassembler { public: WrappedDisassembler(Disassembler* dis, const uint32_t* binary, size_t wc) : disassembler_(dis), inst_binary_(binary), word_count_(wc) {} Disassembler* disassembler() { return disassembler_; } const uint32_t* inst_binary() const { return inst_binary_; } size_t word_count() const { return word_count_; } private: Disassembler* disassembler_; const uint32_t* inst_binary_; const size_t word_count_; }; spv_result_t DisassembleTargetHeader(void* user_data, spv_endianness_t endian, uint32_t /* magic */, uint32_t version, uint32_t generator, uint32_t id_bound, uint32_t schema) { assert(user_data); auto wrapped = static_cast(user_data); return wrapped->disassembler()->HandleHeader(endian, version, generator, id_bound, schema); } spv_result_t DisassembleTargetInstruction( void* user_data, const spv_parsed_instruction_t* parsed_instruction) { assert(user_data); auto wrapped = static_cast(user_data); // Check if this is the instruction we want to disassemble. if (wrapped->word_count() == parsed_instruction->num_words && std::equal(wrapped->inst_binary(), wrapped->inst_binary() + wrapped->word_count(), parsed_instruction->words)) { // Found the target instruction. Disassemble it and signal that we should // stop searching so we don't output the same instruction again. if (auto error = wrapped->disassembler()->HandleInstruction(*parsed_instruction)) return error; return SPV_REQUESTED_TERMINATION; } return SPV_SUCCESS; } uint32_t GetLineLengthWithoutColor(const std::string line) { // Currently, every added color is in the form \x1b...m, so instead of doing a // lot of string comparisons with spvtools::clr::* strings, we just ignore // those ranges. uint32_t length = 0; for (size_t i = 0; i < line.size(); ++i) { if (line[i] == '\x1b') { do { ++i; } while (i < line.size() && line[i] != 'm'); continue; } ++length; } return length; } constexpr int kStandardIndent = 15; constexpr int kBlockNestIndent = 2; constexpr int kBlockBodyIndentOffset = 2; constexpr uint32_t kCommentColumn = 50; } // namespace namespace disassemble { InstructionDisassembler::InstructionDisassembler(const AssemblyGrammar& grammar, std::ostream& stream, uint32_t options, NameMapper name_mapper) : grammar_(grammar), stream_(stream), print_(spvIsInBitfield(SPV_BINARY_TO_TEXT_OPTION_PRINT, options)), color_(spvIsInBitfield(SPV_BINARY_TO_TEXT_OPTION_COLOR, options)), indent_(spvIsInBitfield(SPV_BINARY_TO_TEXT_OPTION_INDENT, options) ? kStandardIndent : 0), nested_indent_( spvIsInBitfield(SPV_BINARY_TO_TEXT_OPTION_NESTED_INDENT, options)), comment_(spvIsInBitfield(SPV_BINARY_TO_TEXT_OPTION_COMMENT, options)), show_byte_offset_( spvIsInBitfield(SPV_BINARY_TO_TEXT_OPTION_SHOW_BYTE_OFFSET, options)), name_mapper_(std::move(name_mapper)), last_instruction_comment_alignment_(0) {} void InstructionDisassembler::EmitHeaderSpirv() { stream_ << "; SPIR-V\n"; } void InstructionDisassembler::EmitHeaderVersion(uint32_t version) { stream_ << "; Version: " << SPV_SPIRV_VERSION_MAJOR_PART(version) << "." << SPV_SPIRV_VERSION_MINOR_PART(version) << "\n"; } void InstructionDisassembler::EmitHeaderGenerator(uint32_t generator) { const char* generator_tool = spvGeneratorStr(SPV_GENERATOR_TOOL_PART(generator)); stream_ << "; Generator: " << generator_tool; // For unknown tools, print the numeric tool value. if (0 == strcmp("Unknown", generator_tool)) { stream_ << "(" << SPV_GENERATOR_TOOL_PART(generator) << ")"; } // Print the miscellaneous part of the generator word on the same // line as the tool name. stream_ << "; " << SPV_GENERATOR_MISC_PART(generator) << "\n"; } void InstructionDisassembler::EmitHeaderIdBound(uint32_t id_bound) { stream_ << "; Bound: " << id_bound << "\n"; } void InstructionDisassembler::EmitHeaderSchema(uint32_t schema) { stream_ << "; Schema: " << schema << "\n"; } void InstructionDisassembler::EmitInstruction( const spv_parsed_instruction_t& inst, size_t inst_byte_offset) { EmitInstructionImpl(inst, inst_byte_offset, 0, false); } void InstructionDisassembler::EmitInstructionInBlock( const spv_parsed_instruction_t& inst, size_t inst_byte_offset, uint32_t block_indent) { EmitInstructionImpl(inst, inst_byte_offset, block_indent, true); } void InstructionDisassembler::EmitInstructionImpl( const spv_parsed_instruction_t& inst, size_t inst_byte_offset, uint32_t block_indent, bool is_in_block) { auto opcode = static_cast(inst.opcode); // To better align the comments (if any), write the instruction to a line // first so its length can be readily available. std::ostringstream line; if (nested_indent_ && opcode == spv::Op::OpLabel) { // Separate the blocks by an empty line to make them easier to separate stream_ << std::endl; } if (inst.result_id) { SetBlue(); const std::string id_name = name_mapper_(inst.result_id); if (indent_) line << std::setw(std::max(0, indent_ - 3 - int(id_name.size()))); line << "%" << id_name; ResetColor(); line << " = "; } else { line << std::string(indent_, ' '); } if (nested_indent_ && is_in_block) { // Output OpLabel at the specified nest level, and instructions inside // blocks nested a little more. uint32_t indent = block_indent; bool body_indent = opcode != spv::Op::OpLabel; line << std::string( indent * kBlockNestIndent + (body_indent ? kBlockBodyIndentOffset : 0), ' '); } line << "Op" << spvOpcodeString(opcode); for (uint16_t i = 0; i < inst.num_operands; i++) { const spv_operand_type_t type = inst.operands[i].type; assert(type != SPV_OPERAND_TYPE_NONE); if (type == SPV_OPERAND_TYPE_RESULT_ID) continue; line << " "; EmitOperand(line, inst, i); } // For the sake of comment generation, store information from some // instructions for the future. if (comment_) { GenerateCommentForDecoratedId(inst); } std::ostringstream comments; const char* comment_separator = ""; if (show_byte_offset_) { SetGrey(comments); auto saved_flags = comments.flags(); auto saved_fill = comments.fill(); comments << comment_separator << "0x" << std::setw(8) << std::hex << std::setfill('0') << inst_byte_offset; comments.flags(saved_flags); comments.fill(saved_fill); ResetColor(comments); comment_separator = ", "; } if (comment_ && opcode == spv::Op::OpName) { const spv_parsed_operand_t& operand = inst.operands[0]; const uint32_t word = inst.words[operand.offset]; comments << comment_separator << "id %" << word; comment_separator = ", "; } if (comment_ && inst.result_id && id_comments_.count(inst.result_id) > 0) { comments << comment_separator << id_comments_[inst.result_id].str(); comment_separator = ", "; } stream_ << line.str(); if (!comments.str().empty()) { // Align the comments const uint32_t line_length = GetLineLengthWithoutColor(line.str()); uint32_t align = std::max( {line_length + 2, last_instruction_comment_alignment_, kCommentColumn}); // Round up the alignment to a multiple of 4 for more niceness. align = (align + 3) & ~0x3u; last_instruction_comment_alignment_ = align; stream_ << std::string(align - line_length, ' ') << "; " << comments.str(); } else { last_instruction_comment_alignment_ = 0; } stream_ << "\n"; } void InstructionDisassembler::GenerateCommentForDecoratedId( const spv_parsed_instruction_t& inst) { assert(comment_); auto opcode = static_cast(inst.opcode); std::ostringstream partial; uint32_t id = 0; const char* separator = ""; switch (opcode) { case spv::Op::OpDecorate: // Take everything after `OpDecorate %id` and associate it with id. id = inst.words[inst.operands[0].offset]; for (uint16_t i = 1; i < inst.num_operands; i++) { partial << separator; separator = " "; EmitOperand(partial, inst, i); } break; default: break; } if (id == 0) { return; } // Add the new comment to the comments of this id std::ostringstream& id_comment = id_comments_[id]; if (!id_comment.str().empty()) { id_comment << ", "; } id_comment << partial.str(); } void InstructionDisassembler::EmitSectionComment( const spv_parsed_instruction_t& inst, bool& inserted_decoration_space, bool& inserted_debug_space, bool& inserted_type_space) { auto opcode = static_cast(inst.opcode); if (comment_ && opcode == spv::Op::OpFunction) { stream_ << std::endl; if (nested_indent_) { // Double the empty lines between Function sections since nested_indent_ // also separates blocks by a blank. stream_ << std::endl; } stream_ << std::string(indent_, ' '); stream_ << "; Function " << name_mapper_(inst.result_id) << std::endl; } if (comment_ && !inserted_decoration_space && spvOpcodeIsDecoration(opcode)) { inserted_decoration_space = true; stream_ << std::endl; stream_ << std::string(indent_, ' '); stream_ << "; Annotations" << std::endl; } if (comment_ && !inserted_debug_space && spvOpcodeIsDebug(opcode)) { inserted_debug_space = true; stream_ << std::endl; stream_ << std::string(indent_, ' '); stream_ << "; Debug Information" << std::endl; } if (comment_ && !inserted_type_space && spvOpcodeGeneratesType(opcode)) { inserted_type_space = true; stream_ << std::endl; stream_ << std::string(indent_, ' '); stream_ << "; Types, variables and constants" << std::endl; } } void InstructionDisassembler::EmitOperand(std::ostream& stream, const spv_parsed_instruction_t& inst, const uint16_t operand_index) const { assert(operand_index < inst.num_operands); const spv_parsed_operand_t& operand = inst.operands[operand_index]; const uint32_t word = inst.words[operand.offset]; switch (operand.type) { case SPV_OPERAND_TYPE_RESULT_ID: assert(false && " is not supposed to be handled here"); SetBlue(stream); stream << "%" << name_mapper_(word); break; case SPV_OPERAND_TYPE_ID: case SPV_OPERAND_TYPE_TYPE_ID: case SPV_OPERAND_TYPE_SCOPE_ID: case SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID: SetYellow(stream); stream << "%" << name_mapper_(word); break; case SPV_OPERAND_TYPE_EXTENSION_INSTRUCTION_NUMBER: { spv_ext_inst_desc ext_inst; SetRed(stream); if (grammar_.lookupExtInst(inst.ext_inst_type, word, &ext_inst) == SPV_SUCCESS) { stream << ext_inst->name; } else { if (!spvExtInstIsNonSemantic(inst.ext_inst_type)) { assert(false && "should have caught this earlier"); } else { // for non-semantic instruction sets we can just print the number stream << word; } } } break; case SPV_OPERAND_TYPE_SPEC_CONSTANT_OP_NUMBER: { spv_opcode_desc opcode_desc; if (grammar_.lookupOpcode(spv::Op(word), &opcode_desc)) assert(false && "should have caught this earlier"); SetRed(stream); stream << opcode_desc->name; } break; case SPV_OPERAND_TYPE_LITERAL_INTEGER: case SPV_OPERAND_TYPE_TYPED_LITERAL_NUMBER: case SPV_OPERAND_TYPE_LITERAL_FLOAT: { SetRed(stream); EmitNumericLiteral(&stream, inst, operand); ResetColor(stream); } break; case SPV_OPERAND_TYPE_LITERAL_STRING: { stream << "\""; SetGreen(stream); std::string str = spvDecodeLiteralStringOperand(inst, operand_index); for (char const& c : str) { if (c == '"' || c == '\\') stream << '\\'; stream << c; } ResetColor(stream); stream << '"'; } break; case SPV_OPERAND_TYPE_CAPABILITY: case SPV_OPERAND_TYPE_SOURCE_LANGUAGE: case SPV_OPERAND_TYPE_EXECUTION_MODEL: case SPV_OPERAND_TYPE_ADDRESSING_MODEL: case SPV_OPERAND_TYPE_MEMORY_MODEL: case SPV_OPERAND_TYPE_EXECUTION_MODE: case SPV_OPERAND_TYPE_STORAGE_CLASS: case SPV_OPERAND_TYPE_DIMENSIONALITY: case SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE: case SPV_OPERAND_TYPE_SAMPLER_FILTER_MODE: case SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT: case SPV_OPERAND_TYPE_FP_ROUNDING_MODE: case SPV_OPERAND_TYPE_LINKAGE_TYPE: case SPV_OPERAND_TYPE_ACCESS_QUALIFIER: case SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE: case SPV_OPERAND_TYPE_DECORATION: case SPV_OPERAND_TYPE_BUILT_IN: case SPV_OPERAND_TYPE_GROUP_OPERATION: case SPV_OPERAND_TYPE_KERNEL_ENQ_FLAGS: case SPV_OPERAND_TYPE_KERNEL_PROFILING_INFO: case SPV_OPERAND_TYPE_RAY_FLAGS: case SPV_OPERAND_TYPE_RAY_QUERY_INTERSECTION: case SPV_OPERAND_TYPE_RAY_QUERY_COMMITTED_INTERSECTION_TYPE: case SPV_OPERAND_TYPE_RAY_QUERY_CANDIDATE_INTERSECTION_TYPE: case SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING: case SPV_OPERAND_TYPE_DEBUG_COMPOSITE_TYPE: case SPV_OPERAND_TYPE_DEBUG_TYPE_QUALIFIER: case SPV_OPERAND_TYPE_DEBUG_OPERATION: case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING: case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_COMPOSITE_TYPE: case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_TYPE_QUALIFIER: case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION: case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_IMPORTED_ENTITY: case SPV_OPERAND_TYPE_FPDENORM_MODE: case SPV_OPERAND_TYPE_FPOPERATION_MODE: case SPV_OPERAND_TYPE_QUANTIZATION_MODES: case SPV_OPERAND_TYPE_FPENCODING: case SPV_OPERAND_TYPE_OVERFLOW_MODES: { spv_operand_desc entry; if (grammar_.lookupOperand(operand.type, word, &entry)) assert(false && "should have caught this earlier"); stream << entry->name; } break; case SPV_OPERAND_TYPE_FP_FAST_MATH_MODE: case SPV_OPERAND_TYPE_FUNCTION_CONTROL: case SPV_OPERAND_TYPE_LOOP_CONTROL: case SPV_OPERAND_TYPE_IMAGE: case SPV_OPERAND_TYPE_MEMORY_ACCESS: case SPV_OPERAND_TYPE_SELECTION_CONTROL: case SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS: case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS: case SPV_OPERAND_TYPE_RAW_ACCESS_CHAIN_OPERANDS: EmitMaskOperand(stream, operand.type, word); break; default: if (spvOperandIsConcreteMask(operand.type)) { EmitMaskOperand(stream, operand.type, word); } else if (spvOperandIsConcrete(operand.type)) { spv_operand_desc entry; if (grammar_.lookupOperand(operand.type, word, &entry)) assert(false && "should have caught this earlier"); stream << entry->name; } else { assert(false && "unhandled or invalid case"); } break; } ResetColor(stream); } void InstructionDisassembler::EmitMaskOperand(std::ostream& stream, const spv_operand_type_t type, const uint32_t word) const { // Scan the mask from least significant bit to most significant bit. For each // set bit, emit the name of that bit. Separate multiple names with '|'. uint32_t remaining_word = word; uint32_t mask; int num_emitted = 0; for (mask = 1; remaining_word; mask <<= 1) { if (remaining_word & mask) { remaining_word ^= mask; spv_operand_desc entry; if (grammar_.lookupOperand(type, mask, &entry)) assert(false && "should have caught this earlier"); if (num_emitted) stream << "|"; stream << entry->name; num_emitted++; } } if (!num_emitted) { // An operand value of 0 was provided, so represent it by the name // of the 0 value. In many cases, that's "None". spv_operand_desc entry; if (SPV_SUCCESS == grammar_.lookupOperand(type, 0, &entry)) stream << entry->name; } } void InstructionDisassembler::ResetColor(std::ostream& stream) const { if (color_) stream << spvtools::clr::reset{print_}; } void InstructionDisassembler::SetGrey(std::ostream& stream) const { if (color_) stream << spvtools::clr::grey{print_}; } void InstructionDisassembler::SetBlue(std::ostream& stream) const { if (color_) stream << spvtools::clr::blue{print_}; } void InstructionDisassembler::SetYellow(std::ostream& stream) const { if (color_) stream << spvtools::clr::yellow{print_}; } void InstructionDisassembler::SetRed(std::ostream& stream) const { if (color_) stream << spvtools::clr::red{print_}; } void InstructionDisassembler::SetGreen(std::ostream& stream) const { if (color_) stream << spvtools::clr::green{print_}; } void InstructionDisassembler::ResetColor() { ResetColor(stream_); } void InstructionDisassembler::SetGrey() { SetGrey(stream_); } void InstructionDisassembler::SetBlue() { SetBlue(stream_); } void InstructionDisassembler::SetYellow() { SetYellow(stream_); } void InstructionDisassembler::SetRed() { SetRed(stream_); } void InstructionDisassembler::SetGreen() { SetGreen(stream_); } } // namespace disassemble std::string spvInstructionBinaryToText(const spv_target_env env, const uint32_t* instCode, const size_t instWordCount, const uint32_t* code, const size_t wordCount, const uint32_t options) { spv_context context = spvContextCreate(env); const AssemblyGrammar grammar(context); if (!grammar.isValid()) { spvContextDestroy(context); return ""; } // Generate friendly names for Ids if requested. std::unique_ptr friendly_mapper; NameMapper name_mapper = GetTrivialNameMapper(); if (options & SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES) { friendly_mapper = MakeUnique(context, code, wordCount); name_mapper = friendly_mapper->GetNameMapper(); } // Now disassemble! Disassembler disassembler(grammar, options, name_mapper); WrappedDisassembler wrapped(&disassembler, instCode, instWordCount); spvBinaryParse(context, &wrapped, code, wordCount, DisassembleTargetHeader, DisassembleTargetInstruction, nullptr); spv_text text = nullptr; std::string output; if (disassembler.SaveTextResult(&text) == SPV_SUCCESS) { output.assign(text->str, text->str + text->length); // Drop trailing newline characters. while (!output.empty() && output.back() == '\n') output.pop_back(); } spvTextDestroy(text); spvContextDestroy(context); return output; } } // namespace spvtools spv_result_t spvBinaryToText(const spv_const_context context, const uint32_t* code, const size_t wordCount, const uint32_t options, spv_text* pText, spv_diagnostic* pDiagnostic) { spv_context_t hijack_context = *context; if (pDiagnostic) { *pDiagnostic = nullptr; spvtools::UseDiagnosticAsMessageConsumer(&hijack_context, pDiagnostic); } const spvtools::AssemblyGrammar grammar(&hijack_context); if (!grammar.isValid()) return SPV_ERROR_INVALID_TABLE; // Generate friendly names for Ids if requested. std::unique_ptr friendly_mapper; spvtools::NameMapper name_mapper = spvtools::GetTrivialNameMapper(); if (options & SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES) { friendly_mapper = spvtools::MakeUnique( &hijack_context, code, wordCount); name_mapper = friendly_mapper->GetNameMapper(); } // Now disassemble! spvtools::Disassembler disassembler(grammar, options, name_mapper); if (auto error = spvBinaryParse(&hijack_context, &disassembler, code, wordCount, spvtools::DisassembleHeader, spvtools::DisassembleInstruction, pDiagnostic)) { return error; } return disassembler.SaveTextResult(pText); } KhronosGroup-SPIRV-Tools-f289d04/source/disassemble.h000066400000000000000000000124241475742701700225000ustar00rootroot00000000000000// Copyright (c) 2018 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_DISASSEMBLE_H_ #define SOURCE_DISASSEMBLE_H_ #include #include #include #include "source/name_mapper.h" #include "spirv-tools/libspirv.h" namespace spvtools { // Decodes the given SPIR-V instruction binary representation to its assembly // text. The context is inferred from the provided module binary. The options // parameter is a bit field of spv_binary_to_text_options_t (note: the option // SPV_BINARY_TO_TEXT_OPTION_PRINT will be ignored). Decoded text will be // stored into *text. Any error will be written into *diagnostic if diagnostic // is non-null. std::string spvInstructionBinaryToText(const spv_target_env env, const uint32_t* inst_binary, const size_t inst_word_count, const uint32_t* binary, const size_t word_count, const uint32_t options); class AssemblyGrammar; namespace disassemble { // Shared code with other tools (than the disassembler) that might need to // output disassembly. An InstructionDisassembler instance converts SPIR-V // binary for an instruction to its assembly representation. class InstructionDisassembler { public: InstructionDisassembler(const AssemblyGrammar& grammar, std::ostream& stream, uint32_t options, NameMapper name_mapper); // Emits the assembly header for the module. void EmitHeaderSpirv(); void EmitHeaderVersion(uint32_t version); void EmitHeaderGenerator(uint32_t generator); void EmitHeaderIdBound(uint32_t id_bound); void EmitHeaderSchema(uint32_t schema); // Emits the assembly text for the given instruction. void EmitInstruction(const spv_parsed_instruction_t& inst, size_t inst_byte_offset); // Same as EmitInstruction, but only for block instructions (including // OpLabel) and useful for nested indentation. If nested indentation is not // desired, EmitInstruction can still be used for block instructions. void EmitInstructionInBlock(const spv_parsed_instruction_t& inst, size_t inst_byte_offset, uint32_t block_indent); // Emits a comment between different sections of the module. void EmitSectionComment(const spv_parsed_instruction_t& inst, bool& inserted_decoration_space, bool& inserted_debug_space, bool& inserted_type_space); // Resets the output color, if color is turned on. void ResetColor(); // Set the output color, if color is turned on. void SetGrey(); void SetBlue(); void SetYellow(); void SetRed(); void SetGreen(); private: void ResetColor(std::ostream& stream) const; void SetGrey(std::ostream& stream) const; void SetBlue(std::ostream& stream) const; void SetYellow(std::ostream& stream) const; void SetRed(std::ostream& stream) const; void SetGreen(std::ostream& stream) const; void EmitInstructionImpl(const spv_parsed_instruction_t& inst, size_t inst_byte_offset, uint32_t block_indent, bool is_in_block); // Emits an operand for the given instruction, where the instruction // is at offset words from the start of the binary. void EmitOperand(std::ostream& stream, const spv_parsed_instruction_t& inst, uint16_t operand_index) const; // Emits a mask expression for the given mask word of the specified type. void EmitMaskOperand(std::ostream& stream, spv_operand_type_t type, uint32_t word) const; // Generate part of the instruction as a comment to be added to // |id_comments_|. void GenerateCommentForDecoratedId(const spv_parsed_instruction_t& inst); const spvtools::AssemblyGrammar& grammar_; std::ostream& stream_; const bool print_; // Should we also print to the standard output stream? const bool color_; // Should we print in colour? const int indent_; // How much to indent. 0 means don't indent const bool nested_indent_; // Whether indentation should indicate nesting const int comment_; // Should we comment the source const bool show_byte_offset_; // Should we print byte offset, in hex? spvtools::NameMapper name_mapper_; // Some comments are generated as instructions (such as OpDecorate) are // visited so that when the instruction with that result id is visited, the // comment can be output. std::unordered_map id_comments_; // Align the comments in consecutive lines for more readability. uint32_t last_instruction_comment_alignment_; }; } // namespace disassemble } // namespace spvtools #endif // SOURCE_DISASSEMBLE_H_ KhronosGroup-SPIRV-Tools-f289d04/source/enum_set.h000066400000000000000000000353701475742701700220310ustar00rootroot00000000000000// Copyright (c) 2023 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include #include #include #include #include #include #include #ifndef SOURCE_ENUM_SET_H_ #define SOURCE_ENUM_SET_H_ #include "source/latest_version_spirv_header.h" namespace spvtools { // This container is optimized to store and retrieve unsigned enum values. // The base model for this implementation is an open-addressing hashtable with // linear probing. For small enums (max index < 64), all operations are O(1). // // - Enums are stored in buckets (64 contiguous values max per bucket) // - Buckets ranges don't overlap, but don't have to be contiguous. // - Enums are packed into 64-bits buckets, using 1 bit per enum value. // // Example: // - MyEnum { A = 0, B = 1, C = 64, D = 65 } // - 2 buckets are required: // - bucket 0, storing values in the range [ 0; 64[ // - bucket 1, storing values in the range [64; 128[ // // - Buckets are stored in a sorted vector (sorted by bucket range). // - Retrieval is done by computing the theoretical bucket index using the enum // value, and // doing a linear scan from this position. // - Insertion is done by retrieving the bucket and either: // - inserting a new bucket in the sorted vector when no buckets has a // compatible range. // - setting the corresponding bit in the bucket. // This means insertion in the middle/beginning can cause a memmove when no // bucket is available. In our case, this happens at most 23 times for the // largest enum we have (Opcodes). template class EnumSet { private: using BucketType = uint64_t; using ElementType = std::underlying_type_t; static_assert(std::is_enum_v, "EnumSets only works with enums."); static_assert(std::is_signed_v == false, "EnumSet doesn't supports signed enums."); // Each bucket can hold up to `kBucketSize` distinct, contiguous enum values. // The first value a bucket can hold must be aligned on `kBucketSize`. struct Bucket { // bit mask to store `kBucketSize` enums. BucketType data; // 1st enum this bucket can represent. T start; friend bool operator==(const Bucket& lhs, const Bucket& rhs) { return lhs.start == rhs.start && lhs.data == rhs.data; } }; // How many distinct values can a bucket hold? 1 bit per value. static constexpr size_t kBucketSize = sizeof(BucketType) * 8ULL; public: class Iterator { public: typedef Iterator self_type; typedef T value_type; typedef T& reference; typedef T* pointer; typedef std::forward_iterator_tag iterator_category; typedef size_t difference_type; Iterator(const Iterator& other) : set_(other.set_), bucketIndex_(other.bucketIndex_), bucketOffset_(other.bucketOffset_) {} Iterator& operator++() { do { if (bucketIndex_ >= set_->buckets_.size()) { bucketIndex_ = set_->buckets_.size(); bucketOffset_ = 0; break; } if (bucketOffset_ + 1 == kBucketSize) { bucketOffset_ = 0; ++bucketIndex_; } else { ++bucketOffset_; } } while (bucketIndex_ < set_->buckets_.size() && !set_->HasEnumAt(bucketIndex_, bucketOffset_)); return *this; } Iterator operator++(int) { Iterator old = *this; operator++(); return old; } T operator*() const { assert(set_->HasEnumAt(bucketIndex_, bucketOffset_) && "operator*() called on an invalid iterator."); return GetValueFromBucket(set_->buckets_[bucketIndex_], bucketOffset_); } bool operator!=(const Iterator& other) const { return set_ != other.set_ || bucketOffset_ != other.bucketOffset_ || bucketIndex_ != other.bucketIndex_; } bool operator==(const Iterator& other) const { return !(operator!=(other)); } Iterator& operator=(const Iterator& other) { set_ = other.set_; bucketIndex_ = other.bucketIndex_; bucketOffset_ = other.bucketOffset_; return *this; } private: Iterator(const EnumSet* set, size_t bucketIndex, ElementType bucketOffset) : set_(set), bucketIndex_(bucketIndex), bucketOffset_(bucketOffset) {} private: const EnumSet* set_ = nullptr; // Index of the bucket in the vector. size_t bucketIndex_ = 0; // Offset in bits in the current bucket. ElementType bucketOffset_ = 0; friend class EnumSet; }; // Required to allow the use of std::inserter. using value_type = T; using const_iterator = Iterator; using iterator = Iterator; public: iterator cbegin() const noexcept { auto it = iterator(this, /* bucketIndex= */ 0, /* bucketOffset= */ 0); if (buckets_.size() == 0) { return it; } // The iterator has the logic to find the next valid bit. If the value 0 // is not stored, use it to find the next valid bit. if (!HasEnumAt(it.bucketIndex_, it.bucketOffset_)) { ++it; } return it; } iterator begin() const noexcept { return cbegin(); } iterator cend() const noexcept { return iterator(this, buckets_.size(), /* bucketOffset= */ 0); } iterator end() const noexcept { return cend(); } // Creates an empty set. EnumSet() : buckets_(0), size_(0) {} // Creates a set and store `value` in it. EnumSet(T value) : EnumSet() { insert(value); } // Creates a set and stores each `values` in it. EnumSet(std::initializer_list values) : EnumSet() { for (auto item : values) { insert(item); } } // Creates a set, and insert `count` enum values pointed by `array` in it. EnumSet(ElementType count, const T* array) : EnumSet() { for (ElementType i = 0; i < count; i++) { insert(array[i]); } } // Creates a set initialized with the content of the range [begin; end[. template EnumSet(InputIt begin, InputIt end) : EnumSet() { for (; begin != end; ++begin) { insert(*begin); } } // Copies the EnumSet `other` into a new EnumSet. EnumSet(const EnumSet& other) : buckets_(other.buckets_), size_(other.size_) {} // Moves the EnumSet `other` into a new EnumSet. EnumSet(EnumSet&& other) : buckets_(std::move(other.buckets_)), size_(other.size_) {} // Deep-copies the EnumSet `other` into this EnumSet. EnumSet& operator=(const EnumSet& other) { buckets_ = other.buckets_; size_ = other.size_; return *this; } // Matches std::unordered_set::insert behavior. std::pair insert(const T& value) { const size_t index = FindBucketForValue(value); const ElementType offset = ComputeBucketOffset(value); if (index >= buckets_.size() || buckets_[index].start != ComputeBucketStart(value)) { size_ += 1; InsertBucketFor(index, value); return std::make_pair(Iterator(this, index, offset), true); } auto& bucket = buckets_[index]; const auto mask = ComputeMaskForValue(value); if (bucket.data & mask) { return std::make_pair(Iterator(this, index, offset), false); } size_ += 1; bucket.data |= ComputeMaskForValue(value); return std::make_pair(Iterator(this, index, offset), true); } // Inserts `value` in the set if possible. // Similar to `std::unordered_set::insert`, except the hint is ignored. // Returns an iterator to the inserted element, or the element preventing // insertion. iterator insert(const_iterator, const T& value) { return insert(value).first; } // Inserts `value` in the set if possible. // Similar to `std::unordered_set::insert`, except the hint is ignored. // Returns an iterator to the inserted element, or the element preventing // insertion. iterator insert(const_iterator, T&& value) { return insert(value).first; } // Inserts all the values in the range [`first`; `last[. // Similar to `std::unordered_set::insert`. template void insert(InputIt first, InputIt last) { for (auto it = first; it != last; ++it) { insert(*it); } } // Removes the value `value` into the set. // Similar to `std::unordered_set::erase`. // Returns the number of erased elements. size_t erase(const T& value) { const size_t index = FindBucketForValue(value); if (index >= buckets_.size() || buckets_[index].start != ComputeBucketStart(value)) { return 0; } auto& bucket = buckets_[index]; const auto mask = ComputeMaskForValue(value); if (!(bucket.data & mask)) { return 0; } size_ -= 1; bucket.data &= ~mask; if (bucket.data == 0) { buckets_.erase(buckets_.cbegin() + index); } return 1; } // Returns true if `value` is present in the set. bool contains(T value) const { const size_t index = FindBucketForValue(value); if (index >= buckets_.size() || buckets_[index].start != ComputeBucketStart(value)) { return false; } auto& bucket = buckets_[index]; return bucket.data & ComputeMaskForValue(value); } // Returns the 1 if `value` is present in the set, `0` otherwise. inline size_t count(T value) const { return contains(value) ? 1 : 0; } // Returns true if the set is holds no values. inline bool empty() const { return size_ == 0; } // Returns the number of enums stored in this set. size_t size() const { return size_; } // Returns true if this set contains at least one value contained in `in_set`. // Note: If `in_set` is empty, this function returns true. bool HasAnyOf(const EnumSet& in_set) const { if (in_set.empty()) { return true; } auto lhs = buckets_.cbegin(); auto rhs = in_set.buckets_.cbegin(); while (lhs != buckets_.cend() && rhs != in_set.buckets_.cend()) { if (lhs->start == rhs->start) { if (lhs->data & rhs->data) { // At least 1 bit is shared. Early return. return true; } lhs++; rhs++; continue; } // LHS bucket is smaller than the current RHS bucket. Catching up on RHS. if (lhs->start < rhs->start) { lhs++; continue; } // Otherwise, RHS needs to catch up on LHS. rhs++; } return false; } private: // Returns the index of the last bucket in which `value` could be stored. static constexpr inline size_t ComputeLargestPossibleBucketIndexFor(T value) { return static_cast(value) / kBucketSize; } // Returns the smallest enum value that could be contained in the same bucket // as `value`. static constexpr inline T ComputeBucketStart(T value) { return static_cast(kBucketSize * ComputeLargestPossibleBucketIndexFor(value)); } // Returns the index of the bit that corresponds to `value` in the bucket. static constexpr inline ElementType ComputeBucketOffset(T value) { return static_cast(value) % kBucketSize; } // Returns the bitmask used to represent the enum `value` in its bucket. static constexpr inline BucketType ComputeMaskForValue(T value) { return 1ULL << ComputeBucketOffset(value); } // Returns the `enum` stored in `bucket` at `offset`. // `offset` is the bit-offset in the bucket storage. static constexpr inline T GetValueFromBucket(const Bucket& bucket, BucketType offset) { return static_cast(static_cast(bucket.start) + offset); } // For a given enum `value`, finds the bucket index that could contain this // value. If no such bucket is found, the index at which the new bucket should // be inserted is returned. size_t FindBucketForValue(T value) const { // Set is empty, insert at 0. if (buckets_.size() == 0) { return 0; } const T wanted_start = ComputeBucketStart(value); assert(buckets_.size() > 0 && "Size must not be 0 here. Has the code above changed?"); size_t index = std::min(buckets_.size() - 1, ComputeLargestPossibleBucketIndexFor(value)); // This loops behaves like std::upper_bound with a reverse iterator. // Buckets are sorted. 3 main cases: // - The bucket matches // => returns the bucket index. // - The found bucket is larger // => scans left until it finds the correct bucket, or insertion point. // - The found bucket is smaller // => We are at the end, so we return past-end index for insertion. for (; buckets_[index].start >= wanted_start; index--) { if (index == 0) { return 0; } } return index + 1; } // Creates a new bucket to store `value` and inserts it at `index`. // If the `index` is past the end, the bucket is inserted at the end of the // vector. void InsertBucketFor(size_t index, T value) { const T bucket_start = ComputeBucketStart(value); Bucket bucket = {1ULL << ComputeBucketOffset(value), bucket_start}; auto it = buckets_.emplace(buckets_.begin() + index, std::move(bucket)); #if defined(NDEBUG) (void)it; // Silencing unused variable warning. #else assert(std::next(it) == buckets_.end() || std::next(it)->start > bucket_start); assert(it == buckets_.begin() || std::prev(it)->start < bucket_start); #endif } // Returns true if the bucket at `bucketIndex/ stores the enum at // `bucketOffset`, false otherwise. bool HasEnumAt(size_t bucketIndex, BucketType bucketOffset) const { assert(bucketIndex < buckets_.size()); assert(bucketOffset < kBucketSize); return buckets_[bucketIndex].data & (1ULL << bucketOffset); } // Returns true if `lhs` and `rhs` hold the exact same values. friend bool operator==(const EnumSet& lhs, const EnumSet& rhs) { if (lhs.size_ != rhs.size_) { return false; } if (lhs.buckets_.size() != rhs.buckets_.size()) { return false; } return lhs.buckets_ == rhs.buckets_; } // Returns true if `lhs` and `rhs` hold at least 1 different value. friend bool operator!=(const EnumSet& lhs, const EnumSet& rhs) { return !(lhs == rhs); } // Storage for the buckets. std::vector buckets_; // How many enums is this set storing. size_t size_ = 0; }; // A set of spv::Capability. using CapabilitySet = EnumSet; } // namespace spvtools #endif // SOURCE_ENUM_SET_H_ KhronosGroup-SPIRV-Tools-f289d04/source/enum_string_mapping.cpp000066400000000000000000000015241475742701700246040ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/enum_string_mapping.h" #include #include #include #include #include #include "source/extensions.h" namespace spvtools { #include "enum_string_mapping.inc" } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/enum_string_mapping.h000066400000000000000000000023101475742701700242430ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_ENUM_STRING_MAPPING_H_ #define SOURCE_ENUM_STRING_MAPPING_H_ #include #include "source/extensions.h" #include "source/latest_version_spirv_header.h" namespace spvtools { // Finds Extension enum corresponding to |str|. Returns false if not found. bool GetExtensionFromString(const char* str, Extension* extension); // Returns text string corresponding to |extension|. const char* ExtensionToString(Extension extension); // Returns text string corresponding to |capability|. const char* CapabilityToString(spv::Capability capability); } // namespace spvtools #endif // SOURCE_ENUM_STRING_MAPPING_H_ KhronosGroup-SPIRV-Tools-f289d04/source/ext_inst.cpp000066400000000000000000000177401475742701700224030ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/ext_inst.h" #include // DebugInfo extended instruction set. // See https://www.khronos.org/registry/spir-v/specs/1.0/DebugInfo.html // TODO(dneto): DebugInfo.h should probably move to SPIRV-Headers. #include "DebugInfo.h" #include "source/latest_version_glsl_std_450_header.h" #include "source/latest_version_opencl_std_header.h" #include "source/macro.h" #include "source/spirv_definition.h" #include "debuginfo.insts.inc" #include "glsl.std.450.insts.inc" #include "nonsemantic.clspvreflection.insts.inc" #include "nonsemantic.shader.debuginfo.100.insts.inc" #include "nonsemantic.vkspreflection.insts.inc" #include "opencl.debuginfo.100.insts.inc" #include "opencl.std.insts.inc" #include "spirv-tools/libspirv.h" #include "spv-amd-gcn-shader.insts.inc" #include "spv-amd-shader-ballot.insts.inc" #include "spv-amd-shader-explicit-vertex-parameter.insts.inc" #include "spv-amd-shader-trinary-minmax.insts.inc" static const spv_ext_inst_group_t kGroups_1_0[] = { {SPV_EXT_INST_TYPE_GLSL_STD_450, ARRAY_SIZE(glsl_entries), glsl_entries}, {SPV_EXT_INST_TYPE_OPENCL_STD, ARRAY_SIZE(opencl_entries), opencl_entries}, {SPV_EXT_INST_TYPE_SPV_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER, ARRAY_SIZE(spv_amd_shader_explicit_vertex_parameter_entries), spv_amd_shader_explicit_vertex_parameter_entries}, {SPV_EXT_INST_TYPE_SPV_AMD_SHADER_TRINARY_MINMAX, ARRAY_SIZE(spv_amd_shader_trinary_minmax_entries), spv_amd_shader_trinary_minmax_entries}, {SPV_EXT_INST_TYPE_SPV_AMD_GCN_SHADER, ARRAY_SIZE(spv_amd_gcn_shader_entries), spv_amd_gcn_shader_entries}, {SPV_EXT_INST_TYPE_SPV_AMD_SHADER_BALLOT, ARRAY_SIZE(spv_amd_shader_ballot_entries), spv_amd_shader_ballot_entries}, {SPV_EXT_INST_TYPE_DEBUGINFO, ARRAY_SIZE(debuginfo_entries), debuginfo_entries}, {SPV_EXT_INST_TYPE_OPENCL_DEBUGINFO_100, ARRAY_SIZE(opencl_debuginfo_100_entries), opencl_debuginfo_100_entries}, {SPV_EXT_INST_TYPE_NONSEMANTIC_SHADER_DEBUGINFO_100, ARRAY_SIZE(nonsemantic_shader_debuginfo_100_entries), nonsemantic_shader_debuginfo_100_entries}, {SPV_EXT_INST_TYPE_NONSEMANTIC_CLSPVREFLECTION, ARRAY_SIZE(nonsemantic_clspvreflection_entries), nonsemantic_clspvreflection_entries}, {SPV_EXT_INST_TYPE_NONSEMANTIC_VKSPREFLECTION, ARRAY_SIZE(nonsemantic_vkspreflection_entries), nonsemantic_vkspreflection_entries}, }; static const spv_ext_inst_table_t kTable_1_0 = {ARRAY_SIZE(kGroups_1_0), kGroups_1_0}; spv_result_t spvExtInstTableGet(spv_ext_inst_table* pExtInstTable, spv_target_env env) { if (!pExtInstTable) return SPV_ERROR_INVALID_POINTER; switch (env) { // The extended instruction sets are all version 1.0 so far. case SPV_ENV_UNIVERSAL_1_0: case SPV_ENV_VULKAN_1_0: case SPV_ENV_UNIVERSAL_1_1: case SPV_ENV_UNIVERSAL_1_2: case SPV_ENV_OPENCL_1_2: case SPV_ENV_OPENCL_EMBEDDED_1_2: case SPV_ENV_OPENCL_2_0: case SPV_ENV_OPENCL_EMBEDDED_2_0: case SPV_ENV_OPENCL_2_1: case SPV_ENV_OPENCL_EMBEDDED_2_1: case SPV_ENV_OPENCL_2_2: case SPV_ENV_OPENCL_EMBEDDED_2_2: case SPV_ENV_OPENGL_4_0: case SPV_ENV_OPENGL_4_1: case SPV_ENV_OPENGL_4_2: case SPV_ENV_OPENGL_4_3: case SPV_ENV_OPENGL_4_5: case SPV_ENV_UNIVERSAL_1_3: case SPV_ENV_VULKAN_1_1: case SPV_ENV_VULKAN_1_1_SPIRV_1_4: case SPV_ENV_UNIVERSAL_1_4: case SPV_ENV_UNIVERSAL_1_5: case SPV_ENV_VULKAN_1_2: case SPV_ENV_UNIVERSAL_1_6: case SPV_ENV_VULKAN_1_3: case SPV_ENV_VULKAN_1_4: *pExtInstTable = &kTable_1_0; return SPV_SUCCESS; default: return SPV_ERROR_INVALID_TABLE; } } spv_ext_inst_type_t spvExtInstImportTypeGet(const char* name) { // The names are specified by the respective extension instruction // specifications. if (!strcmp("GLSL.std.450", name)) { return SPV_EXT_INST_TYPE_GLSL_STD_450; } if (!strcmp("OpenCL.std", name)) { return SPV_EXT_INST_TYPE_OPENCL_STD; } if (!strcmp("SPV_AMD_shader_explicit_vertex_parameter", name)) { return SPV_EXT_INST_TYPE_SPV_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER; } if (!strcmp("SPV_AMD_shader_trinary_minmax", name)) { return SPV_EXT_INST_TYPE_SPV_AMD_SHADER_TRINARY_MINMAX; } if (!strcmp("SPV_AMD_gcn_shader", name)) { return SPV_EXT_INST_TYPE_SPV_AMD_GCN_SHADER; } if (!strcmp("SPV_AMD_shader_ballot", name)) { return SPV_EXT_INST_TYPE_SPV_AMD_SHADER_BALLOT; } if (!strcmp("DebugInfo", name)) { return SPV_EXT_INST_TYPE_DEBUGINFO; } if (!strcmp("OpenCL.DebugInfo.100", name)) { return SPV_EXT_INST_TYPE_OPENCL_DEBUGINFO_100; } if (!strcmp("NonSemantic.Shader.DebugInfo.100", name)) { return SPV_EXT_INST_TYPE_NONSEMANTIC_SHADER_DEBUGINFO_100; } if (!strncmp("NonSemantic.ClspvReflection.", name, 28)) { return SPV_EXT_INST_TYPE_NONSEMANTIC_CLSPVREFLECTION; } if (!strncmp("NonSemantic.VkspReflection.", name, 27)) { return SPV_EXT_INST_TYPE_NONSEMANTIC_VKSPREFLECTION; } // ensure to add any known non-semantic extended instruction sets // above this point, and update spvExtInstIsNonSemantic() if (!strncmp("NonSemantic.", name, 12)) { return SPV_EXT_INST_TYPE_NONSEMANTIC_UNKNOWN; } return SPV_EXT_INST_TYPE_NONE; } bool spvExtInstIsNonSemantic(const spv_ext_inst_type_t type) { if (type == SPV_EXT_INST_TYPE_NONSEMANTIC_UNKNOWN || type == SPV_EXT_INST_TYPE_NONSEMANTIC_SHADER_DEBUGINFO_100 || type == SPV_EXT_INST_TYPE_NONSEMANTIC_CLSPVREFLECTION || type == SPV_EXT_INST_TYPE_NONSEMANTIC_VKSPREFLECTION) { return true; } return false; } bool spvExtInstIsDebugInfo(const spv_ext_inst_type_t type) { if (type == SPV_EXT_INST_TYPE_OPENCL_DEBUGINFO_100 || type == SPV_EXT_INST_TYPE_NONSEMANTIC_SHADER_DEBUGINFO_100 || type == SPV_EXT_INST_TYPE_DEBUGINFO) { return true; } return false; } spv_result_t spvExtInstTableNameLookup(const spv_ext_inst_table table, const spv_ext_inst_type_t type, const char* name, spv_ext_inst_desc* pEntry) { if (!table) return SPV_ERROR_INVALID_TABLE; if (!pEntry) return SPV_ERROR_INVALID_POINTER; for (uint32_t groupIndex = 0; groupIndex < table->count; groupIndex++) { const auto& group = table->groups[groupIndex]; if (type != group.type) continue; for (uint32_t index = 0; index < group.count; index++) { const auto& entry = group.entries[index]; if (!strcmp(name, entry.name)) { *pEntry = &entry; return SPV_SUCCESS; } } } return SPV_ERROR_INVALID_LOOKUP; } spv_result_t spvExtInstTableValueLookup(const spv_ext_inst_table table, const spv_ext_inst_type_t type, const uint32_t value, spv_ext_inst_desc* pEntry) { if (!table) return SPV_ERROR_INVALID_TABLE; if (!pEntry) return SPV_ERROR_INVALID_POINTER; for (uint32_t groupIndex = 0; groupIndex < table->count; groupIndex++) { const auto& group = table->groups[groupIndex]; if (type != group.type) continue; for (uint32_t index = 0; index < group.count; index++) { const auto& entry = group.entries[index]; if (value == entry.ext_inst) { *pEntry = &entry; return SPV_SUCCESS; } } } return SPV_ERROR_INVALID_LOOKUP; } KhronosGroup-SPIRV-Tools-f289d04/source/ext_inst.h000066400000000000000000000040351475742701700220410ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_EXT_INST_H_ #define SOURCE_EXT_INST_H_ #include "source/table.h" #include "spirv-tools/libspirv.h" // Gets the type of the extended instruction set with the specified name. spv_ext_inst_type_t spvExtInstImportTypeGet(const char* name); // Returns true if the extended instruction set is non-semantic bool spvExtInstIsNonSemantic(const spv_ext_inst_type_t type); // Returns true if the extended instruction set is debug info bool spvExtInstIsDebugInfo(const spv_ext_inst_type_t type); // Finds the named extended instruction of the given type in the given extended // instruction table. On success, returns SPV_SUCCESS and writes a handle of // the instruction entry into *entry. spv_result_t spvExtInstTableNameLookup(const spv_ext_inst_table table, const spv_ext_inst_type_t type, const char* name, spv_ext_inst_desc* entry); // Finds the extended instruction of the given type in the given extended // instruction table by value. On success, returns SPV_SUCCESS and writes a // handle of the instruction entry into *entry. spv_result_t spvExtInstTableValueLookup(const spv_ext_inst_table table, const spv_ext_inst_type_t type, const uint32_t value, spv_ext_inst_desc* pEntry); #endif // SOURCE_EXT_INST_H_ KhronosGroup-SPIRV-Tools-f289d04/source/extensions.cpp000066400000000000000000000027071475742701700227420ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/extensions.h" #include #include #include #include "source/binary.h" #include "source/enum_string_mapping.h" namespace spvtools { std::string GetExtensionString(const spv_parsed_instruction_t* inst) { if (inst->opcode != static_cast(spv::Op::OpExtension)) { return "ERROR_not_op_extension"; } assert(inst->num_operands == 1); const auto& operand = inst->operands[0]; assert(operand.type == SPV_OPERAND_TYPE_LITERAL_STRING); assert(inst->num_words > operand.offset); (void)operand; /* No unused variables in release builds. */ return spvDecodeLiteralStringOperand(*inst, 0); } std::string ExtensionSetToString(const ExtensionSet& extensions) { std::stringstream ss; for (auto extension : extensions) { ss << ExtensionToString(extension) << " "; } return ss.str(); } } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/extensions.h000066400000000000000000000023271475742701700224050ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_EXTENSIONS_H_ #define SOURCE_EXTENSIONS_H_ #include #include #include "source/enum_set.h" #include "spirv-tools/libspirv.h" namespace spvtools { // The known SPIR-V extensions. enum Extension : uint32_t { #include "extension_enum.inc" }; using ExtensionSet = EnumSet; // Returns literal string operand of OpExtension instruction. std::string GetExtensionString(const spv_parsed_instruction_t* inst); // Returns text string listing |extensions| separated by whitespace. std::string ExtensionSetToString(const ExtensionSet& extensions); } // namespace spvtools #endif // SOURCE_EXTENSIONS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/000077500000000000000000000000001475742701700210275ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/CMakeLists.txt000066400000000000000000000524741475742701700236030ustar00rootroot00000000000000# Copyright (c) 2019 Google LLC # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. if(SPIRV_BUILD_FUZZER) file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/protobufs) set(PROTOBUF_SOURCE ${CMAKE_CURRENT_SOURCE_DIR}/protobufs/spvtoolsfuzz.proto) set( SPIRV_FUZZ_PROTOC_COMMAND "protobuf::protoc" CACHE STRING "The command to invoke the protobuf compiler (protoc). By default it is the protobufs::protoc CMake target. It should be overridden when cross-compiling, such as for Android.") add_custom_command( OUTPUT protobufs/spvtoolsfuzz.pb.cc protobufs/spvtoolsfuzz.pb.h COMMAND "${SPIRV_FUZZ_PROTOC_COMMAND}" -I=${CMAKE_CURRENT_SOURCE_DIR}/protobufs --cpp_out=protobufs ${PROTOBUF_SOURCE} DEPENDS ${PROTOBUF_SOURCE} COMMENT "Generate protobuf sources from proto definition file." ) set(SPIRV_TOOLS_FUZZ_SOURCES added_function_reducer.h available_instructions.h call_graph.h comparator_deep_blocks_first.h counter_overflow_id_source.h data_descriptor.h equivalence_relation.h fact_manager/constant_uniform_facts.h fact_manager/data_synonym_and_id_equation_facts.h fact_manager/dead_block_facts.h fact_manager/fact_manager.h fact_manager/irrelevant_value_facts.h fact_manager/livesafe_function_facts.h force_render_red.h fuzzer.h fuzzer_context.h fuzzer_pass.h fuzzer_pass_add_access_chains.h fuzzer_pass_add_bit_instruction_synonyms.h fuzzer_pass_add_composite_extract.h fuzzer_pass_add_composite_inserts.h fuzzer_pass_add_composite_types.h fuzzer_pass_add_copy_memory.h fuzzer_pass_add_dead_blocks.h fuzzer_pass_add_dead_breaks.h fuzzer_pass_add_dead_continues.h fuzzer_pass_add_equation_instructions.h fuzzer_pass_add_function_calls.h fuzzer_pass_add_global_variables.h fuzzer_pass_add_image_sample_unused_components.h fuzzer_pass_add_loads.h fuzzer_pass_add_local_variables.h fuzzer_pass_add_loop_preheaders.h fuzzer_pass_add_loops_to_create_int_constant_synonyms.h fuzzer_pass_add_no_contraction_decorations.h fuzzer_pass_add_opphi_synonyms.h fuzzer_pass_add_parameters.h fuzzer_pass_add_relaxed_decorations.h fuzzer_pass_add_stores.h fuzzer_pass_add_synonyms.h fuzzer_pass_add_vector_shuffle_instructions.h fuzzer_pass_adjust_branch_weights.h fuzzer_pass_adjust_function_controls.h fuzzer_pass_adjust_loop_controls.h fuzzer_pass_adjust_memory_operands_masks.h fuzzer_pass_adjust_selection_controls.h fuzzer_pass_apply_id_synonyms.h fuzzer_pass_construct_composites.h fuzzer_pass_copy_objects.h fuzzer_pass_donate_modules.h fuzzer_pass_duplicate_regions_with_selections.h fuzzer_pass_expand_vector_reductions.h fuzzer_pass_flatten_conditional_branches.h fuzzer_pass_inline_functions.h fuzzer_pass_invert_comparison_operators.h fuzzer_pass_interchange_signedness_of_integer_operands.h fuzzer_pass_interchange_zero_like_constants.h fuzzer_pass_make_vector_operations_dynamic.h fuzzer_pass_merge_blocks.h fuzzer_pass_merge_function_returns.h fuzzer_pass_mutate_pointers.h fuzzer_pass_obfuscate_constants.h fuzzer_pass_outline_functions.h fuzzer_pass_permute_blocks.h fuzzer_pass_permute_function_parameters.h fuzzer_pass_permute_function_variables.h fuzzer_pass_permute_instructions.h fuzzer_pass_permute_phi_operands.h fuzzer_pass_propagate_instructions_down.h fuzzer_pass_propagate_instructions_up.h fuzzer_pass_push_ids_through_variables.h fuzzer_pass_replace_adds_subs_muls_with_carrying_extended.h fuzzer_pass_replace_branches_from_dead_blocks_with_exits.h fuzzer_pass_replace_copy_memories_with_loads_stores.h fuzzer_pass_replace_copy_objects_with_stores_loads.h fuzzer_pass_replace_irrelevant_ids.h fuzzer_pass_replace_linear_algebra_instructions.h fuzzer_pass_replace_loads_stores_with_copy_memories.h fuzzer_pass_replace_opphi_ids_from_dead_predecessors.h fuzzer_pass_replace_opselects_with_conditional_branches.h fuzzer_pass_replace_parameter_with_global.h fuzzer_pass_replace_params_with_struct.h fuzzer_pass_split_blocks.h fuzzer_pass_swap_commutable_operands.h fuzzer_pass_swap_conditional_branch_operands.h fuzzer_pass_swap_functions.h fuzzer_pass_toggle_access_chain_instruction.h fuzzer_pass_wrap_regions_in_selections.h fuzzer_pass_wrap_vector_synonym.h fuzzer_util.h id_use_descriptor.h instruction_descriptor.h instruction_message.h overflow_id_source.h pass_management/repeated_pass_instances.h pass_management/repeated_pass_manager.h pass_management/repeated_pass_manager_looped_with_recommendations.h pass_management/repeated_pass_manager_random_with_recommendations.h pass_management/repeated_pass_manager_simple.h pass_management/repeated_pass_recommender.h pass_management/repeated_pass_recommender_standard.h protobufs/spirvfuzz_protobufs.h pseudo_random_generator.h random_generator.h replayer.h shrinker.h transformation.h transformation_access_chain.h transformation_add_bit_instruction_synonym.h transformation_add_constant_boolean.h transformation_add_constant_composite.h transformation_add_constant_null.h transformation_add_constant_scalar.h transformation_add_copy_memory.h transformation_add_dead_block.h transformation_add_dead_break.h transformation_add_dead_continue.h transformation_add_early_terminator_wrapper.h transformation_add_function.h transformation_add_global_undef.h transformation_add_global_variable.h transformation_add_image_sample_unused_components.h transformation_add_local_variable.h transformation_add_loop_preheader.h transformation_add_loop_to_create_int_constant_synonym.h transformation_add_no_contraction_decoration.h transformation_add_opphi_synonym.h transformation_add_parameter.h transformation_add_relaxed_decoration.h transformation_add_spec_constant_op.h transformation_add_synonym.h transformation_add_type_array.h transformation_add_type_boolean.h transformation_add_type_float.h transformation_add_type_function.h transformation_add_type_int.h transformation_add_type_matrix.h transformation_add_type_pointer.h transformation_add_type_struct.h transformation_add_type_vector.h transformation_adjust_branch_weights.h transformation_composite_construct.h transformation_composite_extract.h transformation_composite_insert.h transformation_compute_data_synonym_fact_closure.h transformation_context.h transformation_duplicate_region_with_selection.h transformation_equation_instruction.h transformation_expand_vector_reduction.h transformation_flatten_conditional_branch.h transformation_function_call.h transformation_inline_function.h transformation_invert_comparison_operator.h transformation_load.h transformation_make_vector_operation_dynamic.h transformation_merge_blocks.h transformation_merge_function_returns.h transformation_move_block_down.h transformation_move_instruction_down.h transformation_mutate_pointer.h transformation_outline_function.h transformation_permute_function_parameters.h transformation_permute_phi_operands.h transformation_propagate_instruction_down.h transformation_propagate_instruction_up.h transformation_push_id_through_variable.h transformation_record_synonymous_constants.h transformation_replace_add_sub_mul_with_carrying_extended.h transformation_replace_boolean_constant_with_constant_binary.h transformation_replace_branch_from_dead_block_with_exit.h transformation_replace_constant_with_uniform.h transformation_replace_copy_memory_with_load_store.h transformation_replace_copy_object_with_store_load.h transformation_replace_id_with_synonym.h transformation_replace_irrelevant_id.h transformation_replace_linear_algebra_instruction.h transformation_replace_load_store_with_copy_memory.h transformation_replace_opphi_id_from_dead_predecessor.h transformation_replace_opselect_with_conditional_branch.h transformation_replace_parameter_with_global.h transformation_replace_params_with_struct.h transformation_set_function_control.h transformation_set_loop_control.h transformation_set_memory_operands_mask.h transformation_set_selection_control.h transformation_split_block.h transformation_store.h transformation_swap_commutable_operands.h transformation_swap_conditional_branch_operands.h transformation_swap_function_variables.h transformation_swap_two_functions.h transformation_toggle_access_chain_instruction.h transformation_vector_shuffle.h transformation_wrap_early_terminator_in_function.h transformation_wrap_region_in_selection.h transformation_wrap_vector_synonym.h uniform_buffer_element_descriptor.h ${CMAKE_CURRENT_BINARY_DIR}/protobufs/spvtoolsfuzz.pb.h added_function_reducer.cpp available_instructions.cpp call_graph.cpp counter_overflow_id_source.cpp data_descriptor.cpp fact_manager/constant_uniform_facts.cpp fact_manager/data_synonym_and_id_equation_facts.cpp fact_manager/dead_block_facts.cpp fact_manager/fact_manager.cpp fact_manager/irrelevant_value_facts.cpp fact_manager/livesafe_function_facts.cpp force_render_red.cpp fuzzer.cpp fuzzer_context.cpp fuzzer_pass.cpp fuzzer_pass_add_access_chains.cpp fuzzer_pass_add_bit_instruction_synonyms.cpp fuzzer_pass_add_composite_extract.cpp fuzzer_pass_add_composite_inserts.cpp fuzzer_pass_add_composite_types.cpp fuzzer_pass_add_copy_memory.cpp fuzzer_pass_add_dead_blocks.cpp fuzzer_pass_add_dead_breaks.cpp fuzzer_pass_add_dead_continues.cpp fuzzer_pass_add_equation_instructions.cpp fuzzer_pass_add_function_calls.cpp fuzzer_pass_add_global_variables.cpp fuzzer_pass_add_image_sample_unused_components.cpp fuzzer_pass_add_loads.cpp fuzzer_pass_add_local_variables.cpp fuzzer_pass_add_loop_preheaders.cpp fuzzer_pass_add_loops_to_create_int_constant_synonyms.cpp fuzzer_pass_add_no_contraction_decorations.cpp fuzzer_pass_add_opphi_synonyms.cpp fuzzer_pass_add_parameters.cpp fuzzer_pass_add_relaxed_decorations.cpp fuzzer_pass_add_stores.cpp fuzzer_pass_add_synonyms.cpp fuzzer_pass_add_vector_shuffle_instructions.cpp fuzzer_pass_adjust_branch_weights.cpp fuzzer_pass_adjust_function_controls.cpp fuzzer_pass_adjust_loop_controls.cpp fuzzer_pass_adjust_memory_operands_masks.cpp fuzzer_pass_adjust_selection_controls.cpp fuzzer_pass_apply_id_synonyms.cpp fuzzer_pass_construct_composites.cpp fuzzer_pass_copy_objects.cpp fuzzer_pass_donate_modules.cpp fuzzer_pass_duplicate_regions_with_selections.cpp fuzzer_pass_expand_vector_reductions.cpp fuzzer_pass_flatten_conditional_branches.cpp fuzzer_pass_inline_functions.cpp fuzzer_pass_invert_comparison_operators.cpp fuzzer_pass_interchange_signedness_of_integer_operands.cpp fuzzer_pass_interchange_zero_like_constants.cpp fuzzer_pass_make_vector_operations_dynamic.cpp fuzzer_pass_merge_blocks.cpp fuzzer_pass_merge_function_returns.cpp fuzzer_pass_mutate_pointers.cpp fuzzer_pass_obfuscate_constants.cpp fuzzer_pass_outline_functions.cpp fuzzer_pass_permute_blocks.cpp fuzzer_pass_permute_function_parameters.cpp fuzzer_pass_permute_function_variables.cpp fuzzer_pass_permute_instructions.cpp fuzzer_pass_permute_phi_operands.cpp fuzzer_pass_propagate_instructions_down.cpp fuzzer_pass_propagate_instructions_up.cpp fuzzer_pass_push_ids_through_variables.cpp fuzzer_pass_replace_adds_subs_muls_with_carrying_extended.cpp fuzzer_pass_replace_branches_from_dead_blocks_with_exits.cpp fuzzer_pass_replace_copy_memories_with_loads_stores.cpp fuzzer_pass_replace_copy_objects_with_stores_loads.cpp fuzzer_pass_replace_irrelevant_ids.cpp fuzzer_pass_replace_linear_algebra_instructions.cpp fuzzer_pass_replace_loads_stores_with_copy_memories.cpp fuzzer_pass_replace_opphi_ids_from_dead_predecessors.cpp fuzzer_pass_replace_opselects_with_conditional_branches.cpp fuzzer_pass_replace_parameter_with_global.cpp fuzzer_pass_replace_params_with_struct.cpp fuzzer_pass_split_blocks.cpp fuzzer_pass_swap_commutable_operands.cpp fuzzer_pass_swap_conditional_branch_operands.cpp fuzzer_pass_swap_functions.cpp fuzzer_pass_toggle_access_chain_instruction.cpp fuzzer_pass_wrap_regions_in_selections.cpp fuzzer_pass_wrap_vector_synonym.cpp fuzzer_util.cpp id_use_descriptor.cpp instruction_descriptor.cpp instruction_message.cpp overflow_id_source.cpp pass_management/repeated_pass_manager.cpp pass_management/repeated_pass_manager_looped_with_recommendations.cpp pass_management/repeated_pass_manager_random_with_recommendations.cpp pass_management/repeated_pass_manager_simple.cpp pass_management/repeated_pass_recommender.cpp pass_management/repeated_pass_recommender_standard.cpp pseudo_random_generator.cpp random_generator.cpp replayer.cpp shrinker.cpp transformation.cpp transformation_access_chain.cpp transformation_add_bit_instruction_synonym.cpp transformation_add_constant_boolean.cpp transformation_add_constant_composite.cpp transformation_add_constant_null.cpp transformation_add_constant_scalar.cpp transformation_add_copy_memory.cpp transformation_add_dead_block.cpp transformation_add_dead_break.cpp transformation_add_dead_continue.cpp transformation_add_early_terminator_wrapper.cpp transformation_add_function.cpp transformation_add_global_undef.cpp transformation_add_global_variable.cpp transformation_add_image_sample_unused_components.cpp transformation_add_local_variable.cpp transformation_add_loop_preheader.cpp transformation_add_loop_to_create_int_constant_synonym.cpp transformation_add_no_contraction_decoration.cpp transformation_add_opphi_synonym.cpp transformation_add_parameter.cpp transformation_add_relaxed_decoration.cpp transformation_add_spec_constant_op.cpp transformation_add_synonym.cpp transformation_add_type_array.cpp transformation_add_type_boolean.cpp transformation_add_type_float.cpp transformation_add_type_function.cpp transformation_add_type_int.cpp transformation_add_type_matrix.cpp transformation_add_type_pointer.cpp transformation_add_type_struct.cpp transformation_add_type_vector.cpp transformation_adjust_branch_weights.cpp transformation_composite_construct.cpp transformation_composite_extract.cpp transformation_composite_insert.cpp transformation_compute_data_synonym_fact_closure.cpp transformation_context.cpp transformation_duplicate_region_with_selection.cpp transformation_equation_instruction.cpp transformation_expand_vector_reduction.cpp transformation_flatten_conditional_branch.cpp transformation_function_call.cpp transformation_inline_function.cpp transformation_invert_comparison_operator.cpp transformation_load.cpp transformation_make_vector_operation_dynamic.cpp transformation_merge_blocks.cpp transformation_merge_function_returns.cpp transformation_move_block_down.cpp transformation_move_instruction_down.cpp transformation_mutate_pointer.cpp transformation_outline_function.cpp transformation_permute_function_parameters.cpp transformation_permute_phi_operands.cpp transformation_propagate_instruction_down.cpp transformation_propagate_instruction_up.cpp transformation_push_id_through_variable.cpp transformation_record_synonymous_constants.cpp transformation_replace_add_sub_mul_with_carrying_extended.cpp transformation_replace_boolean_constant_with_constant_binary.cpp transformation_replace_branch_from_dead_block_with_exit.cpp transformation_replace_constant_with_uniform.cpp transformation_replace_copy_memory_with_load_store.cpp transformation_replace_copy_object_with_store_load.cpp transformation_replace_id_with_synonym.cpp transformation_replace_irrelevant_id.cpp transformation_replace_linear_algebra_instruction.cpp transformation_replace_load_store_with_copy_memory.cpp transformation_replace_opphi_id_from_dead_predecessor.cpp transformation_replace_opselect_with_conditional_branch.cpp transformation_replace_parameter_with_global.cpp transformation_replace_params_with_struct.cpp transformation_set_function_control.cpp transformation_set_loop_control.cpp transformation_set_memory_operands_mask.cpp transformation_set_selection_control.cpp transformation_split_block.cpp transformation_store.cpp transformation_swap_commutable_operands.cpp transformation_swap_conditional_branch_operands.cpp transformation_swap_function_variables.cpp transformation_swap_two_functions.cpp transformation_toggle_access_chain_instruction.cpp transformation_vector_shuffle.cpp transformation_wrap_early_terminator_in_function.cpp transformation_wrap_region_in_selection.cpp transformation_wrap_vector_synonym.cpp uniform_buffer_element_descriptor.cpp ${CMAKE_CURRENT_BINARY_DIR}/protobufs/spvtoolsfuzz.pb.cc ) if(MSVC AND (NOT ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang"))) # Enable parallel builds across four cores for this lib add_definitions(/MP4) endif() spvtools_pch(SPIRV_TOOLS_FUZZ_SOURCES pch_source_fuzz) add_library(SPIRV-Tools-fuzz ${SPIRV_TOOLS_FUZZ_SOURCES}) spvtools_default_compile_options(SPIRV-Tools-fuzz) # Compilation of the auto-generated protobuf source file will yield warnings, # which we have no control over and thus wish to ignore. if(${COMPILER_IS_LIKE_GNU}) set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/protobufs/spvtoolsfuzz.pb.cc PROPERTIES COMPILE_FLAGS -w) endif() if(MSVC) set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/protobufs/spvtoolsfuzz.pb.cc PROPERTIES COMPILE_FLAGS /w) endif() target_include_directories(SPIRV-Tools-fuzz PUBLIC $ $ $ PRIVATE ${spirv-tools_BINARY_DIR} PRIVATE ${CMAKE_BINARY_DIR}) # The fuzzer reuses a lot of functionality from the SPIRV-Tools library. target_link_libraries(SPIRV-Tools-fuzz PUBLIC ${SPIRV_TOOLS_FULL_VISIBILITY} PUBLIC SPIRV-Tools-opt PUBLIC SPIRV-Tools-reduce PUBLIC protobuf::libprotobuf) set_property(TARGET SPIRV-Tools-fuzz PROPERTY FOLDER "SPIRV-Tools libraries") spvtools_check_symbol_exports(SPIRV-Tools-fuzz) if(ENABLE_SPIRV_TOOLS_INSTALL) install(TARGETS SPIRV-Tools-fuzz EXPORT SPIRV-Tools-fuzzTargets) export(EXPORT SPIRV-Tools-fuzzTargets FILE SPIRV-Tools-fuzzTarget.cmake) spvtools_config_package_dir(SPIRV-Tools-fuzz PACKAGE_DIR) install(EXPORT SPIRV-Tools-fuzzTargets FILE SPIRV-Tools-fuzzTarget.cmake DESTINATION ${PACKAGE_DIR}) spvtools_generate_config_file(SPIRV-Tools-fuzz) install(FILES ${CMAKE_BINARY_DIR}/SPIRV-Tools-fuzzConfig.cmake DESTINATION ${PACKAGE_DIR}) endif(ENABLE_SPIRV_TOOLS_INSTALL) endif(SPIRV_BUILD_FUZZER) KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/added_function_reducer.cpp000066400000000000000000000334331475742701700262200ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/added_function_reducer.h" #include "source/fuzz/instruction_message.h" #include "source/fuzz/replayer.h" #include "source/fuzz/transformation_add_function.h" #include "source/opt/build_module.h" #include "source/opt/ir_context.h" #include "source/reduce/reducer.h" namespace spvtools { namespace fuzz { AddedFunctionReducer::AddedFunctionReducer( spv_target_env target_env, MessageConsumer consumer, const std::vector& binary_in, const protobufs::FactSequence& initial_facts, const protobufs::TransformationSequence& transformation_sequence_in, uint32_t index_of_add_function_transformation, const Shrinker::InterestingnessFunction& shrinker_interestingness_function, bool validate_during_replay, spv_validator_options validator_options, uint32_t shrinker_step_limit, uint32_t num_existing_shrink_attempts) : target_env_(target_env), consumer_(std::move(consumer)), binary_in_(binary_in), initial_facts_(initial_facts), transformation_sequence_in_(transformation_sequence_in), index_of_add_function_transformation_( index_of_add_function_transformation), shrinker_interestingness_function_(shrinker_interestingness_function), validate_during_replay_(validate_during_replay), validator_options_(validator_options), shrinker_step_limit_(shrinker_step_limit), num_existing_shrink_attempts_(num_existing_shrink_attempts), num_reducer_interestingness_function_invocations_(0) {} AddedFunctionReducer::~AddedFunctionReducer() = default; AddedFunctionReducer::AddedFunctionReducerResult AddedFunctionReducer::Run() { // Replay all transformations before the AddFunction transformation, then // add the raw function associated with the AddFunction transformation. std::vector binary_to_reduce; std::unordered_set irrelevant_pointee_global_variables; ReplayPrefixAndAddFunction(&binary_to_reduce, &irrelevant_pointee_global_variables); // Set up spirv-reduce to use our very specific interestingness function. reduce::Reducer reducer(target_env_); reducer.SetMessageConsumer(consumer_); reducer.AddDefaultReductionPasses(); reducer.SetInterestingnessFunction( [this, &irrelevant_pointee_global_variables]( const std::vector& binary_under_reduction, uint32_t /*unused*/) { return InterestingnessFunctionForReducingAddedFunction( binary_under_reduction, irrelevant_pointee_global_variables); }); // Instruct spirv-reduce to only target the function with the id associated // with the AddFunction transformation that we care about. spvtools::ReducerOptions reducer_options; reducer_options.set_target_function(GetAddedFunctionId()); // Bound the number of reduction steps that spirv-reduce can make according // to the overall shrinker step limit and the number of shrink attempts that // have already been tried. assert(shrinker_step_limit_ > num_existing_shrink_attempts_ && "The added function reducer should not have been invoked."); reducer_options.set_step_limit(shrinker_step_limit_ - num_existing_shrink_attempts_); // Run spirv-reduce. std::vector reduced_binary; auto reducer_result = reducer.Run(std::move(binary_to_reduce), &reduced_binary, reducer_options, validator_options_); if (reducer_result != reduce::Reducer::kComplete && reducer_result != reduce::Reducer::kReachedStepLimit) { return {AddedFunctionReducerResultStatus::kReductionFailed, std::vector(), protobufs::TransformationSequence(), 0}; } // Provide the outer shrinker with an adapted sequence of transformations in // which the AddFunction transformation of interest has been simplified to use // the version of the added function that appears in |reduced_binary|. std::vector binary_out; protobufs::TransformationSequence transformation_sequence_out; ReplayAdaptedTransformations(reduced_binary, &binary_out, &transformation_sequence_out); // We subtract 1 from |num_reducer_interestingness_function_invocations_| to // account for the fact that spirv-reduce invokes its interestingness test // once before reduction commences in order to check that the initial module // is interesting. assert(num_reducer_interestingness_function_invocations_ > 0 && "At a minimum spirv-reduce should have invoked its interestingness " "test once."); return {AddedFunctionReducerResultStatus::kComplete, std::move(binary_out), std::move(transformation_sequence_out), num_reducer_interestingness_function_invocations_ - 1}; } bool AddedFunctionReducer::InterestingnessFunctionForReducingAddedFunction( const std::vector& binary_under_reduction, const std::unordered_set& irrelevant_pointee_global_variables) { uint32_t counter_for_shrinker_interestingness_function = num_existing_shrink_attempts_ + num_reducer_interestingness_function_invocations_; num_reducer_interestingness_function_invocations_++; // The reduced version of the added function must be limited to accessing // global variables appearing in |irrelevant_pointee_global_variables|. This // is to guard against the possibility of spirv-reduce changing a reference // to an irrelevant global to a reference to a regular global variable, which // could cause the added function to change the semantics of the original // module. auto ir_context = BuildModule(target_env_, consumer_, binary_under_reduction.data(), binary_under_reduction.size()); assert(ir_context != nullptr && "The binary should be parsable."); for (auto& type_or_value : ir_context->module()->types_values()) { if (type_or_value.opcode() != spv::Op::OpVariable) { continue; } if (irrelevant_pointee_global_variables.count(type_or_value.result_id())) { continue; } if (!ir_context->get_def_use_mgr()->WhileEachUse( &type_or_value, [this, &ir_context](opt::Instruction* user, uint32_t /*unused*/) -> bool { auto block = ir_context->get_instr_block(user); if (block != nullptr && block->GetParent()->result_id() == GetAddedFunctionId()) { return false; } return true; })) { return false; } } // For the binary to be deemed interesting, it must be possible to // successfully apply all the transformations, with the transformation at // index |index_of_add_function_transformation_| simplified to use the version // of the added function from |binary_under_reduction|. // // This might not be the case: spirv-reduce might have removed a chunk of the // added function on which future transformations depend. // // This is an optimization: the assumption is that having already shrunk the // transformation sequence down to minimal form, all transformations have a // role to play, and it's almost certainly a waste of time to invoke the // shrinker's interestingness function if we have eliminated transformations // that the shrinker previously tried to -- but could not -- eliminate. std::vector binary_out; protobufs::TransformationSequence modified_transformations; ReplayAdaptedTransformations(binary_under_reduction, &binary_out, &modified_transformations); if (transformation_sequence_in_.transformation_size() != modified_transformations.transformation_size()) { return false; } // The resulting binary must be deemed interesting according to the shrinker's // interestingness function. return shrinker_interestingness_function_( binary_out, counter_for_shrinker_interestingness_function); } void AddedFunctionReducer::ReplayPrefixAndAddFunction( std::vector* binary_out, std::unordered_set* irrelevant_pointee_global_variables) const { assert(transformation_sequence_in_ .transformation(index_of_add_function_transformation_) .has_add_function() && "A TransformationAddFunction is required at the given index."); auto replay_result = Replayer(target_env_, consumer_, binary_in_, initial_facts_, transformation_sequence_in_, index_of_add_function_transformation_, validate_during_replay_, validator_options_) .Run(); assert(replay_result.status == Replayer::ReplayerResultStatus::kComplete && "Replay should succeed"); assert(static_cast( replay_result.applied_transformations.transformation_size()) == index_of_add_function_transformation_ && "All requested transformations should have applied."); auto* ir_context = replay_result.transformed_module.get(); for (auto& type_or_value : ir_context->module()->types_values()) { if (type_or_value.opcode() != spv::Op::OpVariable) { continue; } if (replay_result.transformation_context->GetFactManager() ->PointeeValueIsIrrelevant(type_or_value.result_id())) { irrelevant_pointee_global_variables->insert(type_or_value.result_id()); } } // Add the function associated with the transformation at // |index_of_add_function_transformation| to the module. By construction this // should succeed. const protobufs::TransformationAddFunction& transformation_add_function_message = transformation_sequence_in_ .transformation(index_of_add_function_transformation_) .add_function(); bool success = TransformationAddFunction(transformation_add_function_message) .TryToAddFunction(ir_context); (void)success; // Keep release mode compilers happy. assert(success && "Addition of the function should have succeeded."); // Get the binary representation of the module with this function added. ir_context->module()->ToBinary(binary_out, false); } void AddedFunctionReducer::ReplayAdaptedTransformations( const std::vector& binary_under_reduction, std::vector* binary_out, protobufs::TransformationSequence* transformation_sequence_out) const { assert(index_of_add_function_transformation_ < static_cast( transformation_sequence_in_.transformation_size()) && "The relevant add function transformation must be present."); std::unique_ptr ir_context_under_reduction = BuildModule(target_env_, consumer_, binary_under_reduction.data(), binary_under_reduction.size()); assert(ir_context_under_reduction && "Error building module."); protobufs::TransformationSequence modified_transformations; for (uint32_t i = 0; i < static_cast(transformation_sequence_in_.transformation_size()); i++) { if (i == index_of_add_function_transformation_) { protobufs::TransformationAddFunction modified_add_function = transformation_sequence_in_ .transformation(index_of_add_function_transformation_) .add_function(); assert(GetAddedFunctionId() == modified_add_function.instruction(0).result_id() && "Unexpected result id for added function."); modified_add_function.clear_instruction(); for (auto& function : *ir_context_under_reduction->module()) { if (function.result_id() != GetAddedFunctionId()) { continue; } function.ForEachInst( [&modified_add_function](const opt::Instruction* instruction) { *modified_add_function.add_instruction() = MakeInstructionMessage(instruction); }); } assert(modified_add_function.instruction_size() > 0 && "Some instructions for the added function should remain."); *modified_transformations.add_transformation()->mutable_add_function() = modified_add_function; } else { *modified_transformations.add_transformation() = transformation_sequence_in_.transformation(i); } } assert( transformation_sequence_in_.transformation_size() == modified_transformations.transformation_size() && "The original and modified transformations should have the same size."); auto replay_result = Replayer(target_env_, consumer_, binary_in_, initial_facts_, modified_transformations, modified_transformations.transformation_size(), validate_during_replay_, validator_options_) .Run(); assert(replay_result.status == Replayer::ReplayerResultStatus::kComplete && "Replay should succeed."); replay_result.transformed_module->module()->ToBinary(binary_out, false); *transformation_sequence_out = std::move(replay_result.applied_transformations); } uint32_t AddedFunctionReducer::GetAddedFunctionId() const { return transformation_sequence_in_ .transformation(index_of_add_function_transformation_) .add_function() .instruction(0) .result_id(); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/added_function_reducer.h000066400000000000000000000212061475742701700256600ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_ADDED_FUNCTION_REDUCER_H_ #define SOURCE_FUZZ_ADDED_FUNCTION_REDUCER_H_ #include #include #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/shrinker.h" #include "spirv-tools/libspirv.hpp" namespace spvtools { namespace fuzz { // An auxiliary class used by Shrinker, this class takes care of using // spirv-reduce to reduce the body of a function encoded in an AddFunction // transformation, in case a smaller, simpler function can be added instead. class AddedFunctionReducer { public: // Possible statuses that can result from running the shrinker. enum class AddedFunctionReducerResultStatus { kComplete, kReductionFailed, }; struct AddedFunctionReducerResult { AddedFunctionReducerResultStatus status; std::vector transformed_binary; protobufs::TransformationSequence applied_transformations; uint32_t num_reduction_attempts; }; AddedFunctionReducer( spv_target_env target_env, MessageConsumer consumer, const std::vector& binary_in, const protobufs::FactSequence& initial_facts, const protobufs::TransformationSequence& transformation_sequence_in, uint32_t index_of_add_function_transformation, const Shrinker::InterestingnessFunction& shrinker_interestingness_function, bool validate_during_replay, spv_validator_options validator_options, uint32_t shrinker_step_limit, uint32_t num_existing_shrink_attempts); // Disables copy/move constructor/assignment operations. AddedFunctionReducer(const AddedFunctionReducer&) = delete; AddedFunctionReducer(AddedFunctionReducer&&) = delete; AddedFunctionReducer& operator=(const AddedFunctionReducer&) = delete; AddedFunctionReducer& operator=(AddedFunctionReducer&&) = delete; ~AddedFunctionReducer(); // Invokes spirv-reduce on the function in the AddFunction transformation // identified by |index_of_add_function_transformation|. Returns a sequence // of transformations identical to |transformation_sequence_in|, except that // the AddFunction transformation at |index_of_add_function_transformation| // might have been simplified. The binary associated with applying the // resulting sequence of transformations to |binary_in| is also returned, as // well as the number of reduction steps that spirv-reduce made. // // On failure, an empty transformation sequence and binary are returned, // with a placeholder value of 0 for the number of reduction attempts. AddedFunctionReducerResult Run(); private: // Yields, via |binary_out|, the binary obtained by applying transformations // [0, |index_of_added_function_| - 1] from |transformations_in_| to // |binary_in_|, and then adding the raw function encoded in // |transformations_in_[index_of_added_function_]| (without adapting that // function to make it livesafe). This function has |added_function_id_| as // its result id. // // The ids associated with all global variables in |binary_out| that had the // "irrelevant pointee value" fact are also returned via // |irrelevant_pointee_global_variables|. // // The point of this function is that spirv-reduce can subsequently be applied // to function |added_function_id_| in |binary_out|. By construction, // |added_function_id_| should originally manipulate globals for which // "irrelevant pointee value" facts hold. The set // |irrelevant_pointee_global_variables| can be used to force spirv-reduce // to preserve this, to avoid the reduced function ending up manipulating // other global variables of the SPIR-V module, potentially changing their // value and thus changing the semantics of the module. void ReplayPrefixAndAddFunction( std::vector* binary_out, std::unordered_set* irrelevant_pointee_global_variables) const; // This is the interestingness function that will be used by spirv-reduce // when shrinking the added function. // // For |binary_under_reduction| to be deemed interesting, the following // conditions must hold: // - The function with id |added_function_id_| in |binary_under_reduction| // must only reference global variables in // |irrelevant_pointee_global_variables|. This avoids the reduced function // changing the semantics of the original SPIR-V module. // - It must be possible to successfully replay the transformations in // |transformation_sequence_in_|, adapted so that the function added by the // transformation at |index_of_add_function_transformation_| is replaced by // the function with id |added_function_id_| in |binary_under_reduction|, // to |binary_in| (starting with initial facts |initial_facts_|). // - All the transformations in this sequence must be successfully applied // during replay. // - The resulting binary must be interesting according to // |shrinker_interestingness_function_|. bool InterestingnessFunctionForReducingAddedFunction( const std::vector& binary_under_reduction, const std::unordered_set& irrelevant_pointee_global_variables); // Starting with |binary_in_| and |initial_facts_|, the transformations in // |transformation_sequence_in_| are replayed. However, the transformation // at index |index_of_add_function_transformation_| of // |transformation_sequence_in_| -- which is guaranteed to be an AddFunction // transformation -- is adapted so that the function to be added is replaced // with the function in |binary_under_reduction| with id |added_function_id_|. // // The binary resulting from this replay is returned via |binary_out|, and the // adapted transformation sequence via |transformation_sequence_out|. void ReplayAdaptedTransformations( const std::vector& binary_under_reduction, std::vector* binary_out, protobufs::TransformationSequence* transformation_sequence_out) const; // Returns the id of the function to be added by the AddFunction // transformation at // |transformation_sequence_in_[index_of_add_function_transformation_]|. uint32_t GetAddedFunctionId() const; // Target environment. const spv_target_env target_env_; // Message consumer. MessageConsumer consumer_; // The initial binary to which transformations are applied -- i.e., the // binary to which spirv-fuzz originally applied transformations. const std::vector& binary_in_; // Initial facts about |binary_in_|. const protobufs::FactSequence& initial_facts_; // A set of transformations that can be successfully applied to |binary_in_|. const protobufs::TransformationSequence& transformation_sequence_in_; // An index into |transformation_sequence_in_| referring to an AddFunction // transformation. This is the transformation to be simplified using // spirv-reduce. const uint32_t index_of_add_function_transformation_; // The interestingness function that has been provided to guide the // overall shrinking process. The AddFunction transformation being simplified // by this class should still -- when applied in conjunction with the other // transformations in |transformation_sequence_in_| -- lead to a binary that // is deemed interesting by this function. const Shrinker::InterestingnessFunction& shrinker_interestingness_function_; // Determines whether to check for validity during the replaying of // transformations. const bool validate_during_replay_; // Options to control validation. spv_validator_options validator_options_; // The step limit associated with the overall shrinking process. const uint32_t shrinker_step_limit_; // The number of shrink attempts that had been applied prior to invoking this // AddedFunctionReducer instance. const uint32_t num_existing_shrink_attempts_; // Tracks the number of attempts that spirv-reduce has invoked its // interestingness function, which it does once at the start of reduction, // and then once more each time it makes a reduction step. uint32_t num_reducer_interestingness_function_invocations_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_ADDED_FUNCTION_REDUCER_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/available_instructions.cpp000066400000000000000000000200421475742701700262750ustar00rootroot00000000000000// Copyright (c) 2021 Alastair F. Donaldson // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/available_instructions.h" #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { AvailableInstructions::AvailableInstructions( opt::IRContext* ir_context, const std::function& predicate) : ir_context_(ir_context) { // Consider all global declarations for (auto& global : ir_context->module()->types_values()) { if (predicate(ir_context, &global)) { available_globals_.push_back(&global); } } // Consider every function for (auto& function : *ir_context->module()) { // Identify those function parameters that satisfy the predicate. std::vector available_params_for_function; function.ForEachParam( [&predicate, ir_context, &available_params_for_function](opt::Instruction* param) { if (predicate(ir_context, param)) { available_params_for_function.push_back(param); } }); // Consider every reachable block in the function. auto dominator_analysis = ir_context->GetDominatorAnalysis(&function); for (auto& block : function) { if (!ir_context->IsReachable(block)) { // The block is not reachable. continue; } if (&block == &*function.begin()) { // The function entry block is special: only the relevant globals and // function parameters are available at its entry point. num_available_at_block_entry_.insert( {&block, static_cast(available_params_for_function.size() + available_globals_.size())}); } else { // |block| is not the entry block and is reachable, so it must have an // immediate dominator. The number of instructions available on entry to // |block| is thus the number of instructions available on entry to the // immediate dominator + the number of instructions generated_by_block // by the immediate dominator. auto immediate_dominator = dominator_analysis->ImmediateDominator(&block); assert(immediate_dominator != nullptr && "The block is reachable so should have an immediate dominator."); assert(generated_by_block_.count(immediate_dominator) != 0 && "Immediate dominator should have already been processed."); assert(num_available_at_block_entry_.count(immediate_dominator) != 0 && "Immediate dominator should have already been processed."); num_available_at_block_entry_.insert( {&block, static_cast( generated_by_block_.at(immediate_dominator).size()) + num_available_at_block_entry_.at(immediate_dominator)}); } // Now consider each instruction in the block. std::vector generated_by_block; for (auto& inst : block) { assert(num_available_at_block_entry_.count(&block) != 0 && "Block should have already been processed."); // The number of available instructions before |inst| is the number // available at the start of the block + the number of relevant // instructions generated by the block so far. num_available_before_instruction_.insert( {&inst, num_available_at_block_entry_.at(&block) + static_cast(generated_by_block.size())}); if (predicate(ir_context, &inst)) { // This instruction satisfies the predicate, so note that it is // generated by |block|. generated_by_block.push_back(&inst); } } generated_by_block_.emplace(&block, std::move(generated_by_block)); } available_params_.emplace(&function, std::move(available_params_for_function)); } } AvailableInstructions::AvailableBeforeInstruction AvailableInstructions::GetAvailableBeforeInstruction( opt::Instruction* inst) const { assert(num_available_before_instruction_.count(inst) != 0 && "Availability can only be queried for reachable instructions."); return {*this, inst}; } AvailableInstructions::AvailableBeforeInstruction::AvailableBeforeInstruction( const AvailableInstructions& available_instructions, opt::Instruction* inst) : available_instructions_(available_instructions), inst_(inst) {} uint32_t AvailableInstructions::AvailableBeforeInstruction::size() const { return available_instructions_.num_available_before_instruction_.at(inst_); } bool AvailableInstructions::AvailableBeforeInstruction::empty() const { return size() == 0; } opt::Instruction* AvailableInstructions::AvailableBeforeInstruction::operator[]( uint32_t index) const { assert(index < size() && "Index out of bounds."); // First, check the cache to see whether we can return the available // instruction in constant time. auto cached_result = index_cache.find(index); if (cached_result != index_cache.end()) { return cached_result->second; } // Next check whether the index falls into the global region. if (index < available_instructions_.available_globals_.size()) { auto result = available_instructions_.available_globals_[index]; index_cache.insert({index, result}); return result; } auto block = available_instructions_.ir_context_->get_instr_block(inst_); auto function = block->GetParent(); // Next check whether the index falls into the available instructions that // correspond to function parameters. if (index < available_instructions_.available_globals_.size() + available_instructions_.available_params_.at(function).size()) { auto result = available_instructions_.available_params_.at( function)[index - available_instructions_.available_globals_.size()]; index_cache.insert({index, result}); return result; } auto dominator_analysis = available_instructions_.ir_context_->GetDominatorAnalysis(function); // Now the expensive part (which is why we have the cache): walk the dominator // tree backwards starting from the block containing |inst_| until we get to // the block in which the instruction corresponding to |index| exists. for (auto* ancestor = block; true; ancestor = dominator_analysis->ImmediateDominator(ancestor)) { uint32_t num_available_at_ancestor_entry = available_instructions_.num_available_at_block_entry_.at(ancestor); if (index_cache.count(num_available_at_ancestor_entry) == 0) { // This is the first time we have traversed this block, so we populate the // cache with the index of each instruction, so that if a future index // query relates to indices associated with this block we can return the // result in constant time. auto& generated_by_ancestor = available_instructions_.generated_by_block_.at(ancestor); for (uint32_t local_index = 0; local_index < generated_by_ancestor.size(); local_index++) { index_cache.insert({num_available_at_ancestor_entry + local_index, generated_by_ancestor[local_index]}); } } if (index >= num_available_at_ancestor_entry) { // This block contains the instruction we want, so by now it will be in // the cache. return index_cache.at(index); } assert(ancestor != &*function->begin() && "By construction we should find a block associated with the index."); } assert(false && "Unreachable."); return nullptr; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/available_instructions.h000066400000000000000000000104231475742701700257440ustar00rootroot00000000000000// Copyright (c) 2021 Alastair F. Donaldson // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_AVAILABLE_INSTRUCTIONS_H_ #define SOURCE_FUZZ_AVAILABLE_INSTRUCTIONS_H_ #include #include #include "source/opt/instruction.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { // A class for allowing efficient querying of the instruction that satisfy a // particular predicate that are available before a given instruction. // Availability information is only computed for instructions in *reachable* // basic blocks. class AvailableInstructions { public: // The outer class captures availability information for a whole module, and // each instance of this inner class captures availability for a particular // instruction. class AvailableBeforeInstruction { public: AvailableBeforeInstruction( const AvailableInstructions& available_instructions, opt::Instruction* inst); // Returns the number of instructions that are available before the // instruction associated with this class. uint32_t size() const; // Returns true if and only if |size()| is 0. bool empty() const; // Requires |index| < |size()|. Returns the ith available instruction. opt::Instruction* operator[](uint32_t index) const; private: // A references to an instance of the outer class. const AvailableInstructions& available_instructions_; // The instruction for which availability information is captured. opt::Instruction* inst_; // A cache to improve the efficiency of the [] operator. The [] operator // requires walking the instruction's dominator tree to find an instruction // at a particular index, which is a linear time operation. By inserting all // instructions that are traversed during this search into a cache, future // lookups will take constant time unless they require traversing the // dominator tree more deeply. mutable std::unordered_map index_cache; }; // Constructs availability instructions for |ir_context|, where instructions // are only available if they satisfy |predicate|. AvailableInstructions( opt::IRContext* ir_context, const std::function& predicate); // Yields instruction availability for |inst|. AvailableBeforeInstruction GetAvailableBeforeInstruction( opt::Instruction* inst) const; private: // The module in which all instructions are contained. opt::IRContext* ir_context_; // The global instructions that satisfy the predicate. std::vector available_globals_; // Per function, the parameters that satisfy the predicate. std::unordered_map> available_params_; // The number of instructions that satisfy the predicate and that are // available at the entry to a block. For the entry block of a function this // is the number of available globals + the number of available function // parameters. For any other block it is the number of available instructions // for the blocks immediate dominator + the number of instructions generated // by the immediate dominator. std::unordered_map num_available_at_block_entry_; // For each block this records those instructions in the block that satisfy // the predicate. std::unordered_map> generated_by_block_; // For each instruction this records how many instructions satisfying the // predicate are available before the instruction. std::unordered_map num_available_before_instruction_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_AVAILABLE_INSTRUCTIONS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/call_graph.cpp000066400000000000000000000151051475742701700236310ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/call_graph.h" #include namespace spvtools { namespace fuzz { CallGraph::CallGraph(opt::IRContext* context) { // Initialize function in-degree, call graph edges and corresponding maximum // loop nesting depth to 0, empty and 0 respectively. for (auto& function : *context->module()) { function_in_degree_[function.result_id()] = 0; call_graph_edges_[function.result_id()] = std::set(); function_max_loop_nesting_depth_[function.result_id()] = 0; } // Record the maximum loop nesting depth for each edge, by keeping a map from // pairs of function ids, where (A, B) represents a function call from A to B, // to the corresponding maximum depth. std::map, uint32_t> call_to_max_depth; // Compute |function_in_degree_|, |call_graph_edges_| and |call_to_max_depth|. BuildGraphAndGetDepthOfFunctionCalls(context, &call_to_max_depth); // Compute |functions_in_topological_order_|. ComputeTopologicalOrderOfFunctions(); // Compute |function_max_loop_nesting_depth_|. ComputeInterproceduralFunctionCallDepths(call_to_max_depth); } void CallGraph::BuildGraphAndGetDepthOfFunctionCalls( opt::IRContext* context, std::map, uint32_t>* call_to_max_depth) { // Consider every function. for (auto& function : *context->module()) { // Avoid considering the same callee of this function multiple times by // recording known callees. std::set known_callees; // Consider every function call instruction in every block. for (auto& block : function) { for (auto& instruction : block) { if (instruction.opcode() != spv::Op::OpFunctionCall) { continue; } // Get the id of the function being called. uint32_t callee = instruction.GetSingleWordInOperand(0); // Get the loop nesting depth of this function call. uint32_t loop_nesting_depth = context->GetStructuredCFGAnalysis()->LoopNestingDepth(block.id()); // If inside a loop header, consider the function call nested inside the // loop headed by the block. if (block.IsLoopHeader()) { loop_nesting_depth++; } // Update the map if we have not seen this pair (caller, callee) // before or if this function call is from a greater depth. if (!known_callees.count(callee) || call_to_max_depth->at({function.result_id(), callee}) < loop_nesting_depth) { call_to_max_depth->insert( {{function.result_id(), callee}, loop_nesting_depth}); } if (known_callees.count(callee)) { // We have already considered a call to this function - ignore it. continue; } // Increase the callee's in-degree and add an edge to the call graph. function_in_degree_[callee]++; call_graph_edges_[function.result_id()].insert(callee); // Mark the callee as 'known'. known_callees.insert(callee); } } } } void CallGraph::ComputeTopologicalOrderOfFunctions() { // This is an implementation of Kahn’s algorithm for topological sorting. // Initialise |functions_in_topological_order_|. functions_in_topological_order_.clear(); // Get a copy of the initial in-degrees of all functions. The algorithm // involves decrementing these values, hence why we work on a copy. std::map function_in_degree = GetFunctionInDegree(); // Populate a queue with all those function ids with in-degree zero. std::queue queue; for (auto& entry : function_in_degree) { if (entry.second == 0) { queue.push(entry.first); } } // Pop ids from the queue, adding them to the sorted order and decreasing the // in-degrees of their successors. A successor who's in-degree becomes zero // gets added to the queue. while (!queue.empty()) { auto next = queue.front(); queue.pop(); functions_in_topological_order_.push_back(next); for (auto successor : GetDirectCallees(next)) { assert(function_in_degree.at(successor) > 0 && "The in-degree cannot be zero if the function is a successor."); function_in_degree[successor] = function_in_degree.at(successor) - 1; if (function_in_degree.at(successor) == 0) { queue.push(successor); } } } assert(functions_in_topological_order_.size() == function_in_degree.size() && "Every function should appear in the sort."); return; } void CallGraph::ComputeInterproceduralFunctionCallDepths( const std::map, uint32_t>& call_to_max_depth) { // Find the maximum loop nesting depth that each function can be // called from, by considering them in topological order. for (uint32_t function_id : functions_in_topological_order_) { const auto& callees = call_graph_edges_[function_id]; // For each callee, update its maximum loop nesting depth, if a call from // |function_id| increases it. for (uint32_t callee : callees) { uint32_t max_depth_from_this_function = function_max_loop_nesting_depth_[function_id] + call_to_max_depth.at({function_id, callee}); if (function_max_loop_nesting_depth_[callee] < max_depth_from_this_function) { function_max_loop_nesting_depth_[callee] = max_depth_from_this_function; } } } } void CallGraph::PushDirectCallees(uint32_t function_id, std::queue* queue) const { for (auto callee : GetDirectCallees(function_id)) { queue->push(callee); } } std::set CallGraph::GetIndirectCallees(uint32_t function_id) const { std::set result; std::queue queue; PushDirectCallees(function_id, &queue); while (!queue.empty()) { auto next = queue.front(); queue.pop(); if (result.count(next)) { continue; } result.insert(next); PushDirectCallees(next, &queue); } return result; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/call_graph.h000066400000000000000000000110041475742701700232700ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_CALL_GRAPH_H_ #define SOURCE_FUZZ_CALL_GRAPH_H_ #include #include #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { // Represents the acyclic call graph of a SPIR-V module. // The module is assumed to be recursion-free, so there are no cycles in the // graph. This class is immutable, so it will need to be recomputed if the // module changes. class CallGraph { public: // Creates a call graph corresponding to the given SPIR-V module. explicit CallGraph(opt::IRContext* context); // Returns a mapping from each function to its number of distinct callers. const std::map& GetFunctionInDegree() const { return function_in_degree_; } // Returns the ids of the functions that |function_id| directly invokes. const std::set& GetDirectCallees(uint32_t function_id) const { return call_graph_edges_.at(function_id); } // Returns the ids of the functions that |function_id| directly or indirectly // invokes. std::set GetIndirectCallees(uint32_t function_id) const; // Returns the ids of all the functions in the graph in a topological order, // in relation to the function calls, which are assumed to be recursion-free. const std::vector& GetFunctionsInTopologicalOrder() const { return functions_in_topological_order_; } // Returns the maximum loop nesting depth from which |function_id| can be // called. This is computed inter-procedurally (i.e. if main calls A from // depth 2 and A calls B from depth 1, the result will be 3 for A). // This is a static analysis, so it's not necessarily true that the depth // returned can actually be reached at runtime. uint32_t GetMaxCallNestingDepth(uint32_t function_id) const { return function_max_loop_nesting_depth_.at(function_id); } private: // Computes |call_graph_edges_| and |function_in_degree_|. For each pair (A, // B) of functions such that there is at least a function call from A to B, // adds, to |call_to_max_depth|, a mapping from (A, B) to the maximum loop // nesting depth (within A) of any such function call. void BuildGraphAndGetDepthOfFunctionCalls( opt::IRContext* context, std::map, uint32_t>* call_to_max_depth); // Computes a topological order of the functions in the graph, writing the // result to |functions_in_topological_order_|. Assumes that the function // calls are recursion-free and that |function_in_degree_| has been computed. void ComputeTopologicalOrderOfFunctions(); // Computes |function_max_loop_nesting_depth_| so that each function is mapped // to the maximum loop nesting depth from which it can be called, as described // by the comment to GetMaxCallNestingDepth. Assumes that |call_graph_edges_| // and |functions_in_topological_order_| have been computed, and that // |call_to_max_depth| contains a mapping for each edge in the graph. void ComputeInterproceduralFunctionCallDepths( const std::map, uint32_t>& call_to_max_depth); // Pushes the direct callees of |function_id| on to |queue|. void PushDirectCallees(uint32_t function_id, std::queue* queue) const; // Maps each function id to the ids of its immediate callees. std::map> call_graph_edges_; // For each function id, stores the number of distinct functions that call // the function. std::map function_in_degree_; // Stores the ids of the functions in a topological order, // in relation to the function calls, which are assumed to be recursion-free. std::vector functions_in_topological_order_; // For each function id, stores the maximum loop nesting depth that the // function can be called from. std::map function_max_loop_nesting_depth_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_CALL_GRAPH_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/comparator_deep_blocks_first.h000066400000000000000000000036271475742701700271200ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_COMPARATOR_BLOCKS_DEEP_FIRST_H_ #define SOURCE_FUZZ_COMPARATOR_BLOCKS_DEEP_FIRST_H_ #include "source/fuzz/fuzzer_util.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { // Comparator for blocks, comparing them based on how deep they are nested // inside selection or loop constructs. Deeper blocks are considered less than // ones that are not as deep. The blocks are required to be in the same // function. class ComparatorDeepBlocksFirst { public: explicit ComparatorDeepBlocksFirst(opt::IRContext* ir_context) : ir_context_(ir_context) {} bool operator()(uint32_t bb1, uint32_t bb2) const { return this->operator()(fuzzerutil::MaybeFindBlock(ir_context_, bb1), fuzzerutil::MaybeFindBlock(ir_context_, bb2)); } bool operator()(const opt::BasicBlock* bb1, opt::BasicBlock* bb2) const { assert(bb1 && bb2 && "The blocks must exist."); assert(bb1->GetParent() == bb2->GetParent() && "The blocks must be in the same functions."); return ir_context_->GetStructuredCFGAnalysis()->NestingDepth(bb1->id()) > ir_context_->GetStructuredCFGAnalysis()->NestingDepth(bb2->id()); } private: opt::IRContext* ir_context_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_COMPARATOR_BLOCKS_DEEP_FIRST_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/counter_overflow_id_source.cpp000066400000000000000000000022501475742701700271700ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/counter_overflow_id_source.h" namespace spvtools { namespace fuzz { CounterOverflowIdSource::CounterOverflowIdSource(uint32_t first_available_id) : next_available_id_(first_available_id), issued_ids_() {} bool CounterOverflowIdSource::HasOverflowIds() const { return true; } uint32_t CounterOverflowIdSource::GetNextOverflowId() { issued_ids_.insert(next_available_id_); return next_available_id_++; } const std::unordered_set& CounterOverflowIdSource::GetIssuedOverflowIds() const { return issued_ids_; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/counter_overflow_id_source.h000066400000000000000000000032061475742701700266370ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_COUNTER_OVERFLOW_ID_SOURCE_H_ #define SOURCE_FUZZ_COUNTER_OVERFLOW_ID_SOURCE_H_ #include "source/fuzz/overflow_id_source.h" namespace spvtools { namespace fuzz { // A source of overflow ids that uses a counter to provide successive ids from // a given starting value. class CounterOverflowIdSource : public OverflowIdSource { public: // |first_available_id| is the starting value for the counter. explicit CounterOverflowIdSource(uint32_t first_available_id); // Always returns true. bool HasOverflowIds() const override; // Returns the current counter value and increments the counter. // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/2541) We should // account for the case where the maximum allowed id is reached. uint32_t GetNextOverflowId() override; const std::unordered_set& GetIssuedOverflowIds() const override; private: uint32_t next_available_id_; std::unordered_set issued_ids_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_OVERFLOW_ID_SOURCE_COUNTER_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/data_descriptor.cpp000066400000000000000000000037501475742701700247070ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/data_descriptor.h" #include namespace spvtools { namespace fuzz { protobufs::DataDescriptor MakeDataDescriptor( uint32_t object, const std::vector& indices) { protobufs::DataDescriptor result; result.set_object(object); for (auto index : indices) { result.add_index(index); } return result; } size_t DataDescriptorHash::operator()( const protobufs::DataDescriptor* data_descriptor) const { std::u32string hash; hash.push_back(data_descriptor->object()); for (auto an_index : data_descriptor->index()) { hash.push_back(an_index); } return std::hash()(hash); } bool DataDescriptorEquals::operator()( const protobufs::DataDescriptor* first, const protobufs::DataDescriptor* second) const { return first->object() == second->object() && first->index().size() == second->index().size() && std::equal(first->index().begin(), first->index().end(), second->index().begin()); } std::ostream& operator<<(std::ostream& out, const protobufs::DataDescriptor& data_descriptor) { out << data_descriptor.object(); out << "["; bool first = true; for (auto index : data_descriptor.index()) { if (first) { first = false; } else { out << ", "; } out << index; } out << "]"; return out; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/data_descriptor.h000066400000000000000000000030401475742701700243440ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_DATA_DESCRIPTOR_H_ #define SOURCE_FUZZ_DATA_DESCRIPTOR_H_ #include #include #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" namespace spvtools { namespace fuzz { // Factory method to create a data descriptor message from an object id and a // list of indices. protobufs::DataDescriptor MakeDataDescriptor( uint32_t object, const std::vector& indices); // Hash function for data descriptors. struct DataDescriptorHash { size_t operator()(const protobufs::DataDescriptor* data_descriptor) const; }; // Equality function for data descriptors. struct DataDescriptorEquals { bool operator()(const protobufs::DataDescriptor* first, const protobufs::DataDescriptor* second) const; }; std::ostream& operator<<(std::ostream& out, const protobufs::DataDescriptor& data_descriptor); } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_DATA_DESCRIPTOR_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/equivalence_relation.h000066400000000000000000000231201475742701700253740ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_EQUIVALENCE_RELATION_H_ #define SOURCE_FUZZ_EQUIVALENCE_RELATION_H_ #include #include #include #include #include #include #include "source/util/make_unique.h" namespace spvtools { namespace fuzz { // A class for representing an equivalence relation on objects of type |T|, // which should be a value type. The type |T| is required to have a copy // constructor, and |PointerHashT| and |PointerEqualsT| must be functors // providing hashing and equality testing functionality for pointers to objects // of type |T|. // // A disjoint-set (a.k.a. union-find or merge-find) data structure is used to // represent the equivalence relation. Path compression is used. Union by // rank/size is not used. // // Each disjoint set is represented as a tree, rooted at the representative // of the set. // // Getting the representative of a value simply requires chasing parent pointers // from the value until you reach the root. // // Checking equivalence of two elements requires checking that the // representatives are equal. // // Traversing the tree rooted at a value's representative visits the value's // equivalence class. // // |PointerHashT| and |PointerEqualsT| are used to define *equality* between // values, and otherwise are *not* used to define the equivalence relation // (except that equal values are equivalent). The equivalence relation is // constructed by repeatedly adding pairs of (typically non-equal) values that // are deemed to be equivalent. // // For example in an equivalence relation on integers, 1 and 5 might be added // as equivalent, so that IsEquivalent(1, 5) holds, because they represent // IDs in a SPIR-V binary that are known to contain the same value at run time, // but clearly 1 != 5. Since 1 and 1 are equal, IsEquivalent(1, 1) will also // hold. // // Each unique (up to equality) value added to the relation is copied into // |owned_values_|, so there is one canonical memory address per unique value. // Uniqueness is ensured by storing (and checking) a set of pointers to these // values in |value_set_|, which uses |PointerHashT| and |PointerEqualsT|. // // |parent_| and |children_| encode the equivalence relation, i.e., the trees. template class EquivalenceRelation { public: // Requires that |value1| and |value2| are already registered in the // equivalence relation. Merges the equivalence classes associated with // |value1| and |value2|. void MakeEquivalent(const T& value1, const T& value2) { assert(Exists(value1) && "Precondition: value1 must already be registered."); assert(Exists(value2) && "Precondition: value2 must already be registered."); // Look up canonical pointers to each of the values in the value pool. const T* value1_ptr = *value_set_.find(&value1); const T* value2_ptr = *value_set_.find(&value2); // If the values turn out to be identical, they are already in the same // equivalence class so there is nothing to do. if (value1_ptr == value2_ptr) { return; } // Find the representative for each value's equivalence class, and if they // are not already in the same class, make one the parent of the other. const T* representative1 = Find(value1_ptr); const T* representative2 = Find(value2_ptr); assert(representative1 && "Representatives should never be null."); assert(representative2 && "Representatives should never be null."); if (representative1 != representative2) { parent_[representative1] = representative2; children_[representative2].push_back(representative1); } } // Requires that |value| is not known to the equivalence relation. Registers // it in its own equivalence class and returns a pointer to the equivalence // class representative. const T* Register(const T& value) { assert(!Exists(value)); // This relies on T having a copy constructor. auto unique_pointer_to_value = MakeUnique(value); auto pointer_to_value = unique_pointer_to_value.get(); owned_values_.push_back(std::move(unique_pointer_to_value)); value_set_.insert(pointer_to_value); // Initially say that the value is its own parent and that it has no // children. assert(pointer_to_value && "Representatives should never be null."); parent_[pointer_to_value] = pointer_to_value; children_[pointer_to_value] = std::vector(); return pointer_to_value; } // Returns exactly one representative per equivalence class. std::vector GetEquivalenceClassRepresentatives() const { std::vector result; for (auto& value : owned_values_) { if (parent_[value.get()] == value.get()) { result.push_back(value.get()); } } return result; } // Returns pointers to all values in the equivalence class of |value|, which // must already be part of the equivalence relation. std::vector GetEquivalenceClass(const T& value) const { assert(Exists(value)); std::vector result; // Traverse the tree of values rooted at the representative of the // equivalence class to which |value| belongs, and collect up all the values // that are encountered. This constitutes the whole equivalence class. std::vector stack; stack.push_back(Find(*value_set_.find(&value))); while (!stack.empty()) { const T* item = stack.back(); result.push_back(item); stack.pop_back(); for (auto child : children_[item]) { stack.push_back(child); } } return result; } // Returns true if and only if |value1| and |value2| are in the same // equivalence class. Both values must already be known to the equivalence // relation. bool IsEquivalent(const T& value1, const T& value2) const { return Find(&value1) == Find(&value2); } // Returns all values known to be part of the equivalence relation. std::vector GetAllKnownValues() const { std::vector result; for (auto& value : owned_values_) { result.push_back(value.get()); } return result; } // Returns true if and only if |value| is known to be part of the equivalence // relation. bool Exists(const T& value) const { return value_set_.find(&value) != value_set_.end(); } // Returns the representative of the equivalence class of |value|, which must // already be known to the equivalence relation. This is the 'Find' operation // in a classic union-find data structure. const T* Find(const T* value) const { assert(Exists(*value)); // Get the canonical pointer to the value from the value pool. const T* known_value = *value_set_.find(value); assert(parent_[known_value] && "Every known value should have a parent."); // Compute the result by chasing parents until we find a value that is its // own parent. const T* result = known_value; while (parent_[result] != result) { result = parent_[result]; } assert(result && "Representatives should never be null."); // At this point, |result| is the representative of the equivalence class. // Now perform the 'path compression' optimization by doing another pass up // the parent chain, setting the parent of each node to be the // representative, and rewriting children correspondingly. const T* current = known_value; while (parent_[current] != result) { const T* next = parent_[current]; parent_[current] = result; children_[result].push_back(current); auto child_iterator = std::find(children_[next].begin(), children_[next].end(), current); assert(child_iterator != children_[next].end() && "'next' is the parent of 'current', so 'current' should be a " "child of 'next'"); children_[next].erase(child_iterator); current = next; } return result; } private: // Maps every value to a parent. The representative of an equivalence class // is its own parent. A value's representative can be found by walking its // chain of ancestors. // // Mutable because the intuitively const method, 'Find', performs path // compression. mutable std::unordered_map parent_; // Stores the children of each value. This allows the equivalence class of // a value to be calculated by traversing all descendents of the class's // representative. // // Mutable because the intuitively const method, 'Find', performs path // compression. mutable std::unordered_map> children_; // The values known to the equivalence relation are allocated in // |owned_values_|, and |value_pool_| provides (via |PointerHashT| and // |PointerEqualsT|) a means for mapping a value of interest to a pointer // into an equivalent value in |owned_values_|. std::unordered_set value_set_; std::vector> owned_values_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_EQUIVALENCE_RELATION_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fact_manager/000077500000000000000000000000001475742701700234365ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fact_manager/constant_uniform_facts.cpp000066400000000000000000000201651475742701700307160ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fact_manager/constant_uniform_facts.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/uniform_buffer_element_descriptor.h" namespace spvtools { namespace fuzz { namespace fact_manager { ConstantUniformFacts::ConstantUniformFacts(opt::IRContext* ir_context) : ir_context_(ir_context) {} uint32_t ConstantUniformFacts::GetConstantId( const protobufs::FactConstantUniform& constant_uniform_fact, uint32_t type_id) const { auto type = ir_context_->get_type_mgr()->GetType(type_id); assert(type != nullptr && "Unknown type id."); const opt::analysis::Constant* known_constant; if (type->AsInteger()) { opt::analysis::IntConstant candidate_constant( type->AsInteger(), GetConstantWords(constant_uniform_fact)); known_constant = ir_context_->get_constant_mgr()->FindConstant(&candidate_constant); } else { assert( type->AsFloat() && "Uniform constant facts are only supported for int and float types."); opt::analysis::FloatConstant candidate_constant( type->AsFloat(), GetConstantWords(constant_uniform_fact)); known_constant = ir_context_->get_constant_mgr()->FindConstant(&candidate_constant); } if (!known_constant) { return 0; } return ir_context_->get_constant_mgr()->FindDeclaredConstant(known_constant, type_id); } std::vector ConstantUniformFacts::GetConstantWords( const protobufs::FactConstantUniform& constant_uniform_fact) { std::vector result; for (auto constant_word : constant_uniform_fact.constant_word()) { result.push_back(constant_word); } return result; } bool ConstantUniformFacts::DataMatches( const opt::Instruction& constant_instruction, const protobufs::FactConstantUniform& constant_uniform_fact) { assert(constant_instruction.opcode() == spv::Op::OpConstant); std::vector data_in_constant; for (uint32_t i = 0; i < constant_instruction.NumInOperands(); i++) { data_in_constant.push_back(constant_instruction.GetSingleWordInOperand(i)); } return data_in_constant == GetConstantWords(constant_uniform_fact); } std::vector ConstantUniformFacts::GetConstantsAvailableFromUniformsForType( uint32_t type_id) const { std::vector result; std::set already_seen; for (auto& fact_and_type_id : facts_and_type_ids_) { if (fact_and_type_id.second != type_id) { continue; } if (auto constant_id = GetConstantId(fact_and_type_id.first, type_id)) { if (already_seen.find(constant_id) == already_seen.end()) { result.push_back(constant_id); already_seen.insert(constant_id); } } } return result; } std::vector ConstantUniformFacts::GetUniformDescriptorsForConstant( uint32_t constant_id) const { std::vector result; auto constant_inst = ir_context_->get_def_use_mgr()->GetDef(constant_id); assert(constant_inst->opcode() == spv::Op::OpConstant && "The given id must be that of a constant"); auto type_id = constant_inst->type_id(); for (auto& fact_and_type_id : facts_and_type_ids_) { if (fact_and_type_id.second != type_id) { continue; } if (DataMatches(*constant_inst, fact_and_type_id.first)) { result.emplace_back( fact_and_type_id.first.uniform_buffer_element_descriptor()); } } return result; } uint32_t ConstantUniformFacts::GetConstantFromUniformDescriptor( const protobufs::UniformBufferElementDescriptor& uniform_descriptor) const { // Consider each fact. for (auto& fact_and_type : facts_and_type_ids_) { // Check whether the uniform descriptor associated with the fact matches // |uniform_descriptor|. if (UniformBufferElementDescriptorEquals()( &uniform_descriptor, &fact_and_type.first.uniform_buffer_element_descriptor())) { return GetConstantId(fact_and_type.first, fact_and_type.second); } } // No fact associated with the given uniform descriptor was found. return 0; } std::vector ConstantUniformFacts::GetTypesForWhichUniformValuesAreKnown() const { std::vector result; for (auto& fact_and_type : facts_and_type_ids_) { if (std::find(result.begin(), result.end(), fact_and_type.second) == result.end()) { result.push_back(fact_and_type.second); } } return result; } bool ConstantUniformFacts::FloatingPointValueIsSuitable( const protobufs::FactConstantUniform& fact, uint32_t width) { const uint32_t kFloatWidth = 32; const uint32_t kDoubleWidth = 64; if (width != kFloatWidth && width != kDoubleWidth) { // Only 32- and 64-bit floating-point types are handled. return false; } std::vector words = GetConstantWords(fact); if (width == 32) { float value; memcpy(&value, words.data(), sizeof(float)); if (!std::isfinite(value)) { return false; } } else { double value; memcpy(&value, words.data(), sizeof(double)); if (!std::isfinite(value)) { return false; } } return true; } bool ConstantUniformFacts::MaybeAddFact( const protobufs::FactConstantUniform& fact) { // Try to find a unique instruction that declares a variable such that the // variable is decorated with the descriptor set and binding associated with // the constant uniform fact. opt::Instruction* uniform_variable = FindUniformVariable( fact.uniform_buffer_element_descriptor(), ir_context_, true); if (!uniform_variable) { return false; } assert(spv::Op::OpVariable == uniform_variable->opcode()); assert(spv::StorageClass::Uniform == spv::StorageClass(uniform_variable->GetSingleWordInOperand(0))); auto should_be_uniform_pointer_type = ir_context_->get_type_mgr()->GetType(uniform_variable->type_id()); if (!should_be_uniform_pointer_type->AsPointer()) { return false; } if (should_be_uniform_pointer_type->AsPointer()->storage_class() != spv::StorageClass::Uniform) { return false; } auto should_be_uniform_pointer_instruction = ir_context_->get_def_use_mgr()->GetDef(uniform_variable->type_id()); auto composite_type = should_be_uniform_pointer_instruction->GetSingleWordInOperand(1); auto final_element_type_id = fuzzerutil::WalkCompositeTypeIndices( ir_context_, composite_type, fact.uniform_buffer_element_descriptor().index()); if (!final_element_type_id) { return false; } auto final_element_type = ir_context_->get_type_mgr()->GetType(final_element_type_id); assert(final_element_type && "There should be a type corresponding to this id."); if (!(final_element_type->AsFloat() || final_element_type->AsInteger())) { return false; } auto width = final_element_type->AsFloat() ? final_element_type->AsFloat()->width() : final_element_type->AsInteger()->width(); if (final_element_type->AsFloat() && !FloatingPointValueIsSuitable(fact, width)) { return false; } auto required_words = (width + 32 - 1) / 32; if (static_cast(fact.constant_word().size()) != required_words) { return false; } facts_and_type_ids_.emplace_back( std::pair( fact, final_element_type_id)); return true; } const std::vector>& ConstantUniformFacts::GetConstantUniformFactsAndTypes() const { return facts_and_type_ids_; } } // namespace fact_manager } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fact_manager/constant_uniform_facts.h000066400000000000000000000064711475742701700303670ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FACT_MANAGER_CONSTANT_UNIFORM_FACTS_H_ #define SOURCE_FUZZ_FACT_MANAGER_CONSTANT_UNIFORM_FACTS_H_ #include #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { namespace fact_manager { // The purpose of this class is to group the fields and data used to represent // facts about uniform constants. class ConstantUniformFacts { public: explicit ConstantUniformFacts(opt::IRContext* ir_context); // See method in FactManager which delegates to this method. bool MaybeAddFact(const protobufs::FactConstantUniform& fact); // See method in FactManager which delegates to this method. std::vector GetConstantsAvailableFromUniformsForType( uint32_t type_id) const; // See method in FactManager which delegates to this method. std::vector GetUniformDescriptorsForConstant(uint32_t constant_id) const; // See method in FactManager which delegates to this method. uint32_t GetConstantFromUniformDescriptor( const protobufs::UniformBufferElementDescriptor& uniform_descriptor) const; // See method in FactManager which delegates to this method. std::vector GetTypesForWhichUniformValuesAreKnown() const; // See method in FactManager which delegates to this method. const std::vector>& GetConstantUniformFactsAndTypes() const; private: // Returns true if and only if the words associated with // |constant_instruction| exactly match the words for the constant associated // with |constant_uniform_fact|. static bool DataMatches( const opt::Instruction& constant_instruction, const protobufs::FactConstantUniform& constant_uniform_fact); // Yields the constant words associated with |constant_uniform_fact|. static std::vector GetConstantWords( const protobufs::FactConstantUniform& constant_uniform_fact); // Yields the id of a constant of type |type_id| whose data matches the // constant data in |constant_uniform_fact|, or 0 if no such constant is // declared. uint32_t GetConstantId( const protobufs::FactConstantUniform& constant_uniform_fact, uint32_t type_id) const; // Checks that the width of a floating-point constant is supported, and that // the constant is finite. static bool FloatingPointValueIsSuitable( const protobufs::FactConstantUniform& fact, uint32_t width); std::vector> facts_and_type_ids_; opt::IRContext* ir_context_; }; } // namespace fact_manager } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FACT_MANAGER_CONSTANT_UNIFORM_FACTS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fact_manager/data_synonym_and_id_equation_facts.cpp000066400000000000000000001125671475742701700332460ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fact_manager/data_synonym_and_id_equation_facts.h" #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { namespace fact_manager { size_t DataSynonymAndIdEquationFacts::OperationHash::operator()( const Operation& operation) const { std::u32string hash; hash.push_back(uint32_t(operation.opcode)); for (auto operand : operation.operands) { hash.push_back(static_cast(DataDescriptorHash()(operand))); } return std::hash()(hash); } bool DataSynonymAndIdEquationFacts::OperationEquals::operator()( const Operation& first, const Operation& second) const { // Equal operations require... // // Equal opcodes. if (first.opcode != second.opcode) { return false; } // Matching operand counts. if (first.operands.size() != second.operands.size()) { return false; } // Equal operands. for (uint32_t i = 0; i < first.operands.size(); i++) { if (!DataDescriptorEquals()(first.operands[i], second.operands[i])) { return false; } } return true; } DataSynonymAndIdEquationFacts::DataSynonymAndIdEquationFacts( opt::IRContext* ir_context) : ir_context_(ir_context) {} bool DataSynonymAndIdEquationFacts::MaybeAddFact( const protobufs::FactDataSynonym& fact, const DeadBlockFacts& dead_block_facts, const IrrelevantValueFacts& irrelevant_value_facts) { if (irrelevant_value_facts.IdIsIrrelevant(fact.data1().object(), dead_block_facts) || irrelevant_value_facts.IdIsIrrelevant(fact.data2().object(), dead_block_facts)) { // Irrelevant ids cannot be synonymous with other ids. return false; } // Add the fact, including all facts relating sub-components of the data // descriptors that are involved. AddDataSynonymFactRecursive(fact.data1(), fact.data2()); return true; } bool DataSynonymAndIdEquationFacts::MaybeAddFact( const protobufs::FactIdEquation& fact, const DeadBlockFacts& dead_block_facts, const IrrelevantValueFacts& irrelevant_value_facts) { if (irrelevant_value_facts.IdIsIrrelevant(fact.lhs_id(), dead_block_facts)) { // Irrelevant ids cannot participate in IdEquation facts. return false; } for (auto id : fact.rhs_id()) { if (irrelevant_value_facts.IdIsIrrelevant(id, dead_block_facts)) { // Irrelevant ids cannot participate in IdEquation facts. return false; } } protobufs::DataDescriptor lhs_dd = MakeDataDescriptor(fact.lhs_id(), {}); // Register the LHS in the equivalence relation if needed. RegisterDataDescriptor(lhs_dd); // Get equivalence class representatives for all ids used on the RHS of the // equation. std::vector rhs_dds; for (auto rhs_id : fact.rhs_id()) { // Register a data descriptor based on this id in the equivalence relation // if needed, and then record the equivalence class representative. rhs_dds.push_back(RegisterDataDescriptor(MakeDataDescriptor(rhs_id, {}))); } // Now add the fact. AddEquationFactRecursive(lhs_dd, static_cast(fact.opcode()), rhs_dds); return true; } DataSynonymAndIdEquationFacts::OperationSet DataSynonymAndIdEquationFacts::GetEquations( const protobufs::DataDescriptor* lhs) const { auto existing = id_equations_.find(lhs); if (existing == id_equations_.end()) { return OperationSet(); } return existing->second; } void DataSynonymAndIdEquationFacts::AddEquationFactRecursive( const protobufs::DataDescriptor& lhs_dd, spv::Op opcode, const std::vector& rhs_dds) { assert(synonymous_.Exists(lhs_dd) && "The LHS must be known to the equivalence relation."); for (auto rhs_dd : rhs_dds) { // Keep release compilers happy. (void)(rhs_dd); assert(synonymous_.Exists(*rhs_dd) && "The RHS operands must be known to the equivalence relation."); } auto lhs_dd_representative = synonymous_.Find(&lhs_dd); if (id_equations_.count(lhs_dd_representative) == 0) { // We have not seen an equation with this LHS before, so associate the LHS // with an initially empty set. id_equations_.insert({lhs_dd_representative, OperationSet()}); } { auto existing_equations = id_equations_.find(lhs_dd_representative); assert(existing_equations != id_equations_.end() && "A set of operations should be present, even if empty."); Operation new_operation = {opcode, rhs_dds}; if (existing_equations->second.count(new_operation)) { // This equation is known, so there is nothing further to be done. return; } // Add the equation to the set of known equations. existing_equations->second.insert(new_operation); } // Now try to work out corollaries implied by the new equation and existing // facts. switch (opcode) { case spv::Op::OpConvertSToF: case spv::Op::OpConvertUToF: ComputeConversionDataSynonymFacts(*rhs_dds[0]); break; case spv::Op::OpBitcast: { assert(DataDescriptorsAreWellFormedAndComparable(lhs_dd, *rhs_dds[0]) && "Operands of OpBitcast equation fact must have compatible types"); if (!synonymous_.IsEquivalent(lhs_dd, *rhs_dds[0])) { AddDataSynonymFactRecursive(lhs_dd, *rhs_dds[0]); } } break; case spv::Op::OpIAdd: { // Equation form: "a = b + c" for (const auto& equation : GetEquations(rhs_dds[0])) { if (equation.opcode == spv::Op::OpISub) { // Equation form: "a = (d - e) + c" if (synonymous_.IsEquivalent(*equation.operands[1], *rhs_dds[1])) { // Equation form: "a = (d - c) + c" // We can thus infer "a = d" AddDataSynonymFactRecursive(lhs_dd, *equation.operands[0]); } } } for (const auto& equation : GetEquations(rhs_dds[1])) { if (equation.opcode == spv::Op::OpISub) { // Equation form: "a = b + (d - e)" if (synonymous_.IsEquivalent(*equation.operands[1], *rhs_dds[0])) { // Equation form: "a = b + (d - b)" // We can thus infer "a = d" AddDataSynonymFactRecursive(lhs_dd, *equation.operands[0]); } } } break; } case spv::Op::OpISub: { // Equation form: "a = b - c" for (const auto& equation : GetEquations(rhs_dds[0])) { if (equation.opcode == spv::Op::OpIAdd) { // Equation form: "a = (d + e) - c" if (synonymous_.IsEquivalent(*equation.operands[0], *rhs_dds[1])) { // Equation form: "a = (c + e) - c" // We can thus infer "a = e" AddDataSynonymFactRecursive(lhs_dd, *equation.operands[1]); } if (synonymous_.IsEquivalent(*equation.operands[1], *rhs_dds[1])) { // Equation form: "a = (d + c) - c" // We can thus infer "a = d" AddDataSynonymFactRecursive(lhs_dd, *equation.operands[0]); } } if (equation.opcode == spv::Op::OpISub) { // Equation form: "a = (d - e) - c" if (synonymous_.IsEquivalent(*equation.operands[0], *rhs_dds[1])) { // Equation form: "a = (c - e) - c" // We can thus infer "a = -e" AddEquationFactRecursive(lhs_dd, spv::Op::OpSNegate, {equation.operands[1]}); } } } for (const auto& equation : GetEquations(rhs_dds[1])) { if (equation.opcode == spv::Op::OpIAdd) { // Equation form: "a = b - (d + e)" if (synonymous_.IsEquivalent(*equation.operands[0], *rhs_dds[0])) { // Equation form: "a = b - (b + e)" // We can thus infer "a = -e" AddEquationFactRecursive(lhs_dd, spv::Op::OpSNegate, {equation.operands[1]}); } if (synonymous_.IsEquivalent(*equation.operands[1], *rhs_dds[0])) { // Equation form: "a = b - (d + b)" // We can thus infer "a = -d" AddEquationFactRecursive(lhs_dd, spv::Op::OpSNegate, {equation.operands[0]}); } } if (equation.opcode == spv::Op::OpISub) { // Equation form: "a = b - (d - e)" if (synonymous_.IsEquivalent(*equation.operands[0], *rhs_dds[0])) { // Equation form: "a = b - (b - e)" // We can thus infer "a = e" AddDataSynonymFactRecursive(lhs_dd, *equation.operands[1]); } } } break; } case spv::Op::OpLogicalNot: case spv::Op::OpSNegate: { // Equation form: "a = !b" or "a = -b" for (const auto& equation : GetEquations(rhs_dds[0])) { if (equation.opcode == opcode) { // Equation form: "a = !!b" or "a = -(-b)" // We can thus infer "a = b" AddDataSynonymFactRecursive(lhs_dd, *equation.operands[0]); } } break; } default: break; } } void DataSynonymAndIdEquationFacts::AddDataSynonymFactRecursive( const protobufs::DataDescriptor& dd1, const protobufs::DataDescriptor& dd2) { assert((!ObjectStillExists(dd1) || !ObjectStillExists(dd2) || DataDescriptorsAreWellFormedAndComparable(dd1, dd2)) && "Mismatched data descriptors."); // Record that the data descriptors provided in the fact are equivalent. MakeEquivalent(dd1, dd2); assert(synonymous_.Find(&dd1) == synonymous_.Find(&dd2) && "|dd1| and |dd2| must have a single representative"); // Compute various corollary facts. // |dd1| and |dd2| belong to the same equivalence class so it doesn't matter // which one we use here. ComputeConversionDataSynonymFacts(dd1); ComputeCompositeDataSynonymFacts(dd1, dd2); } void DataSynonymAndIdEquationFacts::ComputeConversionDataSynonymFacts( const protobufs::DataDescriptor& dd) { assert(synonymous_.Exists(dd) && "|dd| should've been registered in the equivalence relation"); if (!ObjectStillExists(dd)) { // The object is gone from the module, so we cannot proceed. return; } const auto* type = ir_context_->get_type_mgr()->GetType(fuzzerutil::WalkCompositeTypeIndices( ir_context_, fuzzerutil::GetTypeId(ir_context_, dd.object()), dd.index())); assert(type && "Data descriptor has invalid type"); if ((type->AsVector() && type->AsVector()->element_type()->AsInteger()) || type->AsInteger()) { // If there exist equation facts of the form |%a = opcode %representative| // and |%b = opcode %representative| where |opcode| is either OpConvertSToF // or OpConvertUToF, then |a| and |b| are synonymous. std::vector convert_s_to_f_lhs; std::vector convert_u_to_f_lhs; for (const auto& fact : id_equations_) { auto equivalence_class = synonymous_.GetEquivalenceClass(*fact.first); auto dd_it = std::find_if(equivalence_class.begin(), equivalence_class.end(), [this](const protobufs::DataDescriptor* a) { return ObjectStillExists(*a); }); if (dd_it == equivalence_class.end()) { // Skip |equivalence_class| if it has no valid ids. continue; } for (const auto& equation : fact.second) { if (synonymous_.IsEquivalent(*equation.operands[0], dd)) { if (equation.opcode == spv::Op::OpConvertSToF) { convert_s_to_f_lhs.push_back(*dd_it); } else if (equation.opcode == spv::Op::OpConvertUToF) { convert_u_to_f_lhs.push_back(*dd_it); } } } } // We use pointers in the initializer list here since otherwise we would // copy memory from these vectors. for (const auto* synonyms : {&convert_s_to_f_lhs, &convert_u_to_f_lhs}) { for (const auto* synonym_a : *synonyms) { for (const auto* synonym_b : *synonyms) { // DataDescriptorsAreWellFormedAndComparable will be called in the // AddDataSynonymFactRecursive method. if (!synonymous_.IsEquivalent(*synonym_a, *synonym_b)) { // |synonym_a| and |synonym_b| have compatible types - they are // synonymous. AddDataSynonymFactRecursive(*synonym_a, *synonym_b); } } } } } } void DataSynonymAndIdEquationFacts::ComputeCompositeDataSynonymFacts( const protobufs::DataDescriptor& dd1, const protobufs::DataDescriptor& dd2) { // Check whether this is a synonym about composite objects. If it is, // we can recursively add synonym facts about their associated sub-components. // Get the type of the object referred to by the first data descriptor in the // synonym fact. uint32_t type_id = fuzzerutil::WalkCompositeTypeIndices( ir_context_, ir_context_->get_def_use_mgr()->GetDef(dd1.object())->type_id(), dd1.index()); auto type = ir_context_->get_type_mgr()->GetType(type_id); auto type_instruction = ir_context_->get_def_use_mgr()->GetDef(type_id); assert(type != nullptr && "Invalid data synonym fact: one side has an unknown type."); // Check whether the type is composite, recording the number of elements // associated with the composite if so. uint32_t num_composite_elements; if (type->AsArray()) { num_composite_elements = fuzzerutil::GetArraySize(*type_instruction, ir_context_); } else if (type->AsMatrix()) { num_composite_elements = type->AsMatrix()->element_count(); } else if (type->AsStruct()) { num_composite_elements = fuzzerutil::GetNumberOfStructMembers(*type_instruction); } else if (type->AsVector()) { num_composite_elements = type->AsVector()->element_count(); } else { // The type is not a composite, so return. return; } // If the fact has the form: // obj_1[a_1, ..., a_m] == obj_2[b_1, ..., b_n] // then for each composite index i, we add a fact of the form: // obj_1[a_1, ..., a_m, i] == obj_2[b_1, ..., b_n, i] // // However, to avoid adding a large number of synonym facts e.g. in the case // of arrays, we bound the number of composite elements to which this is // applied. Nevertheless, we always add a synonym fact for the final // components, as this may be an interesting edge case. // The bound on the number of indices of the composite pair to note as being // synonymous. const uint32_t kCompositeElementBound = 10; for (uint32_t i = 0; i < num_composite_elements;) { std::vector extended_indices1 = fuzzerutil::RepeatedFieldToVector(dd1.index()); extended_indices1.push_back(i); std::vector extended_indices2 = fuzzerutil::RepeatedFieldToVector(dd2.index()); extended_indices2.push_back(i); AddDataSynonymFactRecursive( MakeDataDescriptor(dd1.object(), extended_indices1), MakeDataDescriptor(dd2.object(), extended_indices2)); if (i < kCompositeElementBound - 1 || i == num_composite_elements - 1) { // We have not reached the bound yet, or have already skipped ahead to the // last element, so increment the loop counter as standard. i++; } else { // We have reached the bound, so skip ahead to the last element. assert(i == kCompositeElementBound - 1); i = num_composite_elements - 1; } } } void DataSynonymAndIdEquationFacts::ComputeClosureOfFacts( uint32_t maximum_equivalence_class_size) { // Suppose that obj_1[a_1, ..., a_m] and obj_2[b_1, ..., b_n] are distinct // data descriptors that describe objects of the same composite type, and that // the composite type is comprised of k components. // // For example, if m is a mat4x4 and v a vec4, we might consider: // m[2]: describes the 2nd column of m, a vec4 // v[]: describes all of v, a vec4 // // Suppose that we know, for every 0 <= i < k, that the fact: // obj_1[a_1, ..., a_m, i] == obj_2[b_1, ..., b_n, i] // holds - i.e. that the children of the two data descriptors are synonymous. // // Then we can conclude that: // obj_1[a_1, ..., a_m] == obj_2[b_1, ..., b_n] // holds. // // For instance, if we have the facts: // m[2, 0] == v[0] // m[2, 1] == v[1] // m[2, 2] == v[2] // m[2, 3] == v[3] // then we can conclude that: // m[2] == v. // // This method repeatedly searches the equivalence relation of data // descriptors, deducing and adding such facts, until a pass over the // relation leads to no further facts being deduced. // The method relies on working with pairs of data descriptors, and in // particular being able to hash and compare such pairs. using DataDescriptorPair = std::pair; struct DataDescriptorPairHash { std::size_t operator()(const DataDescriptorPair& pair) const { return DataDescriptorHash()(&pair.first) ^ DataDescriptorHash()(&pair.second); } }; struct DataDescriptorPairEquals { bool operator()(const DataDescriptorPair& first, const DataDescriptorPair& second) const { return (DataDescriptorEquals()(&first.first, &second.first) && DataDescriptorEquals()(&first.second, &second.second)) || (DataDescriptorEquals()(&first.first, &second.second) && DataDescriptorEquals()(&first.second, &second.first)); } }; // This map records, for a given pair of composite data descriptors of the // same type, all the indices at which the data descriptors are known to be // synonymous. A pair is a key to this map only if we have observed that // the pair are synonymous at *some* index, but not at *all* indices. // Once we find that a pair of data descriptors are equivalent at all indices // we record the fact that they are synonymous and remove them from the map. // // Using the m and v example from above, initially the pair (m[2], v) would // not be a key to the map. If we find that m[2, 2] == v[2] holds, we would // add an entry: // (m[2], v) -> [false, false, true, false] // to record that they are synonymous at index 2. If we then find that // m[2, 0] == v[0] holds, we would update this entry to: // (m[2], v) -> [true, false, true, false] // If we then find that m[2, 3] == v[3] holds, we would update this entry to: // (m[2], v) -> [true, false, true, true] // Finally, if we then find that m[2, 1] == v[1] holds, which would make the // boolean vector true at every index, we would add the fact: // m[2] == v // to the equivalence relation and remove (m[2], v) from the map. std::unordered_map, DataDescriptorPairHash, DataDescriptorPairEquals> candidate_composite_synonyms; // We keep looking for new facts until we perform a complete pass over the // equivalence relation without finding any new facts. while (closure_computation_required_) { // We have not found any new facts yet during this pass; we set this to // 'true' if we do find a new fact. closure_computation_required_ = false; // Consider each class in the equivalence relation. for (auto representative : synonymous_.GetEquivalenceClassRepresentatives()) { auto equivalence_class = synonymous_.GetEquivalenceClass(*representative); if (equivalence_class.size() > maximum_equivalence_class_size) { // This equivalence class is larger than the maximum size we are willing // to consider, so we skip it. This potentially leads to missed fact // deductions, but avoids excessive runtime for closure computation. continue; } // Consider every data descriptor in the equivalence class. for (auto dd1_it = equivalence_class.begin(); dd1_it != equivalence_class.end(); ++dd1_it) { // If this data descriptor has no indices then it does not have the form // obj_1[a_1, ..., a_m, i], so move on. auto dd1 = *dd1_it; if (dd1->index_size() == 0) { continue; } // Consider every other data descriptor later in the equivalence class // (due to symmetry, there is no need to compare with previous data // descriptors). auto dd2_it = dd1_it; for (++dd2_it; dd2_it != equivalence_class.end(); ++dd2_it) { auto dd2 = *dd2_it; // If this data descriptor has no indices then it does not have the // form obj_2[b_1, ..., b_n, i], so move on. if (dd2->index_size() == 0) { continue; } // At this point we know that: // - |dd1| has the form obj_1[a_1, ..., a_m, i] // - |dd2| has the form obj_2[b_1, ..., b_n, j] assert(dd1->index_size() > 0 && dd2->index_size() > 0 && "Control should not reach here if either data descriptor has " "no indices."); // We are only interested if i == j. if (dd1->index(dd1->index_size() - 1) != dd2->index(dd2->index_size() - 1)) { continue; } const uint32_t common_final_index = dd1->index(dd1->index_size() - 1); // Make data descriptors |dd1_prefix| and |dd2_prefix| for // obj_1[a_1, ..., a_m] // and // obj_2[b_1, ..., b_n] // These are the two data descriptors we might be getting closer to // deducing as being synonymous, due to knowing that they are // synonymous when extended by a particular index. protobufs::DataDescriptor dd1_prefix; dd1_prefix.set_object(dd1->object()); for (uint32_t i = 0; i < static_cast(dd1->index_size() - 1); i++) { dd1_prefix.add_index(dd1->index(i)); } protobufs::DataDescriptor dd2_prefix; dd2_prefix.set_object(dd2->object()); for (uint32_t i = 0; i < static_cast(dd2->index_size() - 1); i++) { dd2_prefix.add_index(dd2->index(i)); } assert(!DataDescriptorEquals()(&dd1_prefix, &dd2_prefix) && "By construction these prefixes should be different."); // If we already know that these prefixes are synonymous, move on. if (synonymous_.Exists(dd1_prefix) && synonymous_.Exists(dd2_prefix) && synonymous_.IsEquivalent(dd1_prefix, dd2_prefix)) { continue; } if (!ObjectStillExists(*dd1) || !ObjectStillExists(*dd2)) { // The objects are not both available in the module, so we cannot // investigate the types of the associated data descriptors; we need // to move on. continue; } // Get the type of obj_1 auto dd1_root_type_id = fuzzerutil::GetTypeId(ir_context_, dd1->object()); // Use this type, together with a_1, ..., a_m, to get the type of // obj_1[a_1, ..., a_m]. auto dd1_prefix_type = fuzzerutil::WalkCompositeTypeIndices( ir_context_, dd1_root_type_id, dd1_prefix.index()); // Similarly, get the type of obj_2 and use it to get the type of // obj_2[b_1, ..., b_n]. auto dd2_root_type_id = fuzzerutil::GetTypeId(ir_context_, dd2->object()); auto dd2_prefix_type = fuzzerutil::WalkCompositeTypeIndices( ir_context_, dd2_root_type_id, dd2_prefix.index()); // If the types of dd1_prefix and dd2_prefix are not the same, they // cannot be synonymous. if (dd1_prefix_type != dd2_prefix_type) { continue; } // At this point, we know we have synonymous data descriptors of the // form: // obj_1[a_1, ..., a_m, i] // obj_2[b_1, ..., b_n, i] // with the same last_index i, such that: // obj_1[a_1, ..., a_m] // and // obj_2[b_1, ..., b_n] // have the same type. // Work out how many components there are in the (common) commposite // type associated with obj_1[a_1, ..., a_m] and obj_2[b_1, ..., b_n]. // This depends on whether the composite type is array, matrix, struct // or vector. uint32_t num_components_in_composite; auto composite_type = ir_context_->get_type_mgr()->GetType(dd1_prefix_type); auto composite_type_instruction = ir_context_->get_def_use_mgr()->GetDef(dd1_prefix_type); if (composite_type->AsArray()) { num_components_in_composite = fuzzerutil::GetArraySize( *composite_type_instruction, ir_context_); if (num_components_in_composite == 0) { // This indicates that the array has an unknown size, in which // case we cannot be sure we have matched all of its elements with // synonymous elements of another array. continue; } } else if (composite_type->AsMatrix()) { num_components_in_composite = composite_type->AsMatrix()->element_count(); } else if (composite_type->AsStruct()) { num_components_in_composite = fuzzerutil::GetNumberOfStructMembers( *composite_type_instruction); } else { assert(composite_type->AsVector()); num_components_in_composite = composite_type->AsVector()->element_count(); } // We are one step closer to being able to say that |dd1_prefix| and // |dd2_prefix| are synonymous. DataDescriptorPair candidate_composite_synonym(dd1_prefix, dd2_prefix); // We look up what we already know about this pair. auto existing_entry = candidate_composite_synonyms.find(candidate_composite_synonym); if (existing_entry == candidate_composite_synonyms.end()) { // If this is the first time we have seen the pair, we make a vector // of size |num_components_in_composite| that is 'true' at the // common final index associated with |dd1| and |dd2|, and 'false' // everywhere else, and register this vector as being associated // with the pair. std::vector entry; for (uint32_t i = 0; i < num_components_in_composite; i++) { entry.push_back(i == common_final_index); } candidate_composite_synonyms[candidate_composite_synonym] = entry; existing_entry = candidate_composite_synonyms.find(candidate_composite_synonym); } else { // We have seen this pair of data descriptors before, and we now // know that they are synonymous at one further index, so we // update the entry to record that. existing_entry->second[common_final_index] = true; } assert(existing_entry != candidate_composite_synonyms.end()); // Check whether |dd1_prefix| and |dd2_prefix| are now known to match // at every sub-component. bool all_components_match = true; for (uint32_t i = 0; i < num_components_in_composite; i++) { if (!existing_entry->second[i]) { all_components_match = false; break; } } if (all_components_match) { // The two prefixes match on all sub-components, so we know that // they are synonymous. We add this fact *non-recursively*, as we // have deduced that |dd1_prefix| and |dd2_prefix| are synonymous // by observing that all their sub-components are already // synonymous. assert(DataDescriptorsAreWellFormedAndComparable(dd1_prefix, dd2_prefix)); MakeEquivalent(dd1_prefix, dd2_prefix); // Now that we know this pair of data descriptors are synonymous, // there is no point recording how close they are to being // synonymous. candidate_composite_synonyms.erase(candidate_composite_synonym); } } } } } } void DataSynonymAndIdEquationFacts::MakeEquivalent( const protobufs::DataDescriptor& dd1, const protobufs::DataDescriptor& dd2) { // Register the data descriptors if they are not already known to the // equivalence relation. RegisterDataDescriptor(dd1); RegisterDataDescriptor(dd2); if (synonymous_.IsEquivalent(dd1, dd2)) { // The data descriptors are already known to be equivalent, so there is // nothing to do. return; } // We must make the data descriptors equivalent, and also make sure any // equation facts known about their representatives are merged. // Record the original equivalence class representatives of the data // descriptors. auto dd1_original_representative = synonymous_.Find(&dd1); auto dd2_original_representative = synonymous_.Find(&dd2); // Make the data descriptors equivalent. synonymous_.MakeEquivalent(dd1, dd2); // As we have updated the equivalence relation, we might be able to deduce // more facts by performing a closure computation, so we record that such a // computation is required. closure_computation_required_ = true; // At this point, exactly one of |dd1_original_representative| and // |dd2_original_representative| will be the representative of the combined // equivalence class. We work out which one of them is still the class // representative and which one is no longer the class representative. auto still_representative = synonymous_.Find(dd1_original_representative) == dd1_original_representative ? dd1_original_representative : dd2_original_representative; auto no_longer_representative = still_representative == dd1_original_representative ? dd2_original_representative : dd1_original_representative; assert(no_longer_representative != still_representative && "The current and former representatives cannot be the same."); // We now need to add all equations about |no_longer_representative| to the // set of equations known about |still_representative|. // Get the equations associated with |no_longer_representative|. auto no_longer_representative_id_equations = id_equations_.find(no_longer_representative); if (no_longer_representative_id_equations != id_equations_.end()) { // There are some equations to transfer. There might not yet be any // equations about |still_representative|; create an empty set of equations // if this is the case. if (!id_equations_.count(still_representative)) { id_equations_.insert({still_representative, OperationSet()}); } auto still_representative_id_equations = id_equations_.find(still_representative); assert(still_representative_id_equations != id_equations_.end() && "At this point there must be a set of equations."); // Add all the equations known about |no_longer_representative| to the set // of equations known about |still_representative|. still_representative_id_equations->second.insert( no_longer_representative_id_equations->second.begin(), no_longer_representative_id_equations->second.end()); } // Delete the no longer-relevant equations about |no_longer_representative|. id_equations_.erase(no_longer_representative); } const protobufs::DataDescriptor* DataSynonymAndIdEquationFacts::RegisterDataDescriptor( const protobufs::DataDescriptor& dd) { return synonymous_.Exists(dd) ? synonymous_.Find(&dd) : synonymous_.Register(dd); } bool DataSynonymAndIdEquationFacts::DataDescriptorsAreWellFormedAndComparable( const protobufs::DataDescriptor& dd1, const protobufs::DataDescriptor& dd2) const { if (!ObjectStillExists(dd1) || !ObjectStillExists(dd2)) { // We trivially return true if one or other of the objects associated with // the data descriptors is gone. return true; } auto end_type_id_1 = fuzzerutil::WalkCompositeTypeIndices( ir_context_, fuzzerutil::GetTypeId(ir_context_, dd1.object()), dd1.index()); auto end_type_id_2 = fuzzerutil::WalkCompositeTypeIndices( ir_context_, fuzzerutil::GetTypeId(ir_context_, dd2.object()), dd2.index()); // The end types of the data descriptors must exist. if (end_type_id_1 == 0 || end_type_id_2 == 0) { return false; } // Neither end type is allowed to be void. if (ir_context_->get_def_use_mgr()->GetDef(end_type_id_1)->opcode() == spv::Op::OpTypeVoid || ir_context_->get_def_use_mgr()->GetDef(end_type_id_2)->opcode() == spv::Op::OpTypeVoid) { return false; } // If the end types are the same, the data descriptors are comparable. if (end_type_id_1 == end_type_id_2) { return true; } // Otherwise they are only comparable if they are integer scalars or integer // vectors that differ only in signedness. // Get both types. const auto* type_a = ir_context_->get_type_mgr()->GetType(end_type_id_1); const auto* type_b = ir_context_->get_type_mgr()->GetType(end_type_id_2); assert(type_a && type_b && "Data descriptors have invalid type(s)"); // If both types are numerical or vectors of numerical components, then they // are compatible if they have the same number of components and the same bit // count per component. if (type_a->AsVector() && type_b->AsVector()) { const auto* vector_a = type_a->AsVector(); const auto* vector_b = type_b->AsVector(); if (vector_a->element_count() != vector_b->element_count() || vector_a->element_type()->AsBool() || vector_b->element_type()->AsBool()) { // The case where both vectors have boolean elements and the same number // of components is handled by the direct equality check earlier. // You can't have multiple identical boolean vector types. return false; } type_a = vector_a->element_type(); type_b = vector_b->element_type(); } auto get_bit_count_for_numeric_type = [](const opt::analysis::Type& type) -> uint32_t { if (const auto* integer = type.AsInteger()) { return integer->width(); } else if (const auto* floating = type.AsFloat()) { return floating->width(); } else { assert(false && "|type| must be a numerical type"); return 0; } }; // Checks that both |type_a| and |type_b| are either numerical or vectors of // numerical components and have the same number of bits. return (type_a->AsInteger() || type_a->AsFloat()) && (type_b->AsInteger() || type_b->AsFloat()) && (get_bit_count_for_numeric_type(*type_a) == get_bit_count_for_numeric_type(*type_b)); } std::vector DataSynonymAndIdEquationFacts::GetSynonymsForId(uint32_t id) const { return GetSynonymsForDataDescriptor(MakeDataDescriptor(id, {})); } std::vector DataSynonymAndIdEquationFacts::GetSynonymsForDataDescriptor( const protobufs::DataDescriptor& data_descriptor) const { std::vector result; if (synonymous_.Exists(data_descriptor)) { for (auto dd : synonymous_.GetEquivalenceClass(data_descriptor)) { // There may be data descriptors in the equivalence class whose base // objects have been removed from the module. We do not expose these // data descriptors to clients of the fact manager. if (ObjectStillExists(*dd)) { result.push_back(dd); } } } return result; } std::vector DataSynonymAndIdEquationFacts::GetIdsForWhichSynonymsAreKnown() const { std::vector result; for (auto& data_descriptor : synonymous_.GetAllKnownValues()) { // We skip any data descriptors whose base objects no longer exist in the // module, and we restrict attention to data descriptors for plain ids, // which have no indices. if (ObjectStillExists(*data_descriptor) && data_descriptor->index().empty()) { result.push_back(data_descriptor->object()); } } return result; } std::vector DataSynonymAndIdEquationFacts::GetAllKnownSynonyms() const { std::vector result; for (const auto* dd : synonymous_.GetAllKnownValues()) { if (ObjectStillExists(*dd)) { result.push_back(dd); } } return result; } bool DataSynonymAndIdEquationFacts::IsSynonymous( const protobufs::DataDescriptor& data_descriptor1, const protobufs::DataDescriptor& data_descriptor2) const { return synonymous_.Exists(data_descriptor1) && synonymous_.Exists(data_descriptor2) && synonymous_.IsEquivalent(data_descriptor1, data_descriptor2); } bool DataSynonymAndIdEquationFacts::ObjectStillExists( const protobufs::DataDescriptor& dd) const { return ir_context_->get_def_use_mgr()->GetDef(dd.object()) != nullptr; } } // namespace fact_manager } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fact_manager/data_synonym_and_id_equation_facts.h000066400000000000000000000202141475742701700326760ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FACT_MANAGER_DATA_SYNONYM_AND_ID_EQUATION_FACTS_H_ #define SOURCE_FUZZ_FACT_MANAGER_DATA_SYNONYM_AND_ID_EQUATION_FACTS_H_ #include #include #include "source/fuzz/data_descriptor.h" #include "source/fuzz/equivalence_relation.h" #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { namespace fact_manager { // Forward reference to the DeadBlockFacts class. class DeadBlockFacts; // Forward reference to the IrrelevantValueFacts class. class IrrelevantValueFacts; // The purpose of this class is to group the fields and data used to represent // facts about data synonyms and id equations. class DataSynonymAndIdEquationFacts { public: explicit DataSynonymAndIdEquationFacts(opt::IRContext* ir_context); // See method in FactManager which delegates to this method. Returns true if // neither |fact.data1()| nor |fact.data2()| contain an // irrelevant id. Otherwise, returns false. |dead_block_facts| and // |irrelevant_value_facts| are passed for consistency checks. bool MaybeAddFact(const protobufs::FactDataSynonym& fact, const DeadBlockFacts& dead_block_facts, const IrrelevantValueFacts& irrelevant_value_facts); // See method in FactManager which delegates to this method. Returns true if // neither |fact.lhs_id()| nor any of |fact.rhs_id()| is irrelevant. Returns // false otherwise. |dead_block_facts| and |irrelevant_value_facts| are passed // for consistency checks. bool MaybeAddFact(const protobufs::FactIdEquation& fact, const DeadBlockFacts& dead_block_facts, const IrrelevantValueFacts& irrelevant_value_facts); // See method in FactManager which delegates to this method. std::vector GetSynonymsForId( uint32_t id) const; // See method in FactManager which delegates to this method. std::vector GetSynonymsForDataDescriptor( const protobufs::DataDescriptor& data_descriptor) const; // See method in FactManager which delegates to this method. std::vector GetIdsForWhichSynonymsAreKnown() const; // See method in FactManager which delegates to this method. std::vector GetAllKnownSynonyms() const; // See method in FactManager which delegates to this method. bool IsSynonymous(const protobufs::DataDescriptor& data_descriptor1, const protobufs::DataDescriptor& data_descriptor2) const; // See method in FactManager which delegates to this method. void ComputeClosureOfFacts(uint32_t maximum_equivalence_class_size); private: // This helper struct represents the right hand side of an equation as an // operator applied to a number of data descriptor operands. struct Operation { spv::Op opcode; std::vector operands; }; // Hashing for operations, to allow deterministic unordered sets. struct OperationHash { size_t operator()(const Operation& operation) const; }; // Equality for operations, to allow deterministic unordered sets. struct OperationEquals { bool operator()(const Operation& first, const Operation& second) const; }; using OperationSet = std::unordered_set; // Adds the synonym |dd1| = |dd2| to the set of managed facts, and recurses // into sub-components of the data descriptors, if they are composites, to // record that their components are pairwise-synonymous. void AddDataSynonymFactRecursive(const protobufs::DataDescriptor& dd1, const protobufs::DataDescriptor& dd2); // Computes various corollary facts from the data descriptor |dd| if members // of its equivalence class participate in equation facts with OpConvert* // opcodes. The descriptor should be registered in the equivalence relation. void ComputeConversionDataSynonymFacts(const protobufs::DataDescriptor& dd); // Recurses into sub-components of the data descriptors, if they are // composites, to record that their components are pairwise-synonymous. void ComputeCompositeDataSynonymFacts(const protobufs::DataDescriptor& dd1, const protobufs::DataDescriptor& dd2); // Records the fact that |dd1| and |dd2| are equivalent, and merges the sets // of equations that are known about them. void MakeEquivalent(const protobufs::DataDescriptor& dd1, const protobufs::DataDescriptor& dd2); // Registers a data descriptor in the equivalence relation if it hasn't been // registered yet, and returns its representative. const protobufs::DataDescriptor* RegisterDataDescriptor( const protobufs::DataDescriptor& dd); // Trivially returns true if either |dd1| or |dd2|'s objects are not present // in the module. // // Otherwise, returns true if and only if |dd1| and |dd2| are valid data // descriptors whose associated data have compatible types. Two types are // compatible if: // - they are the same // - they both are numerical or vectors of numerical components with the same // number of components and the same bit count per component bool DataDescriptorsAreWellFormedAndComparable( const protobufs::DataDescriptor& dd1, const protobufs::DataDescriptor& dd2) const; OperationSet GetEquations(const protobufs::DataDescriptor* lhs) const; // Requires that |lhs_dd| and every element of |rhs_dds| is present in the // |synonymous_| equivalence relation, but is not necessarily its own // representative. Records the fact that the equation // "|lhs_dd| |opcode| |rhs_dds_non_canonical|" holds, and adds any // corollaries, in the form of data synonym or equation facts, that follow // from this and other known facts. void AddEquationFactRecursive( const protobufs::DataDescriptor& lhs_dd, spv::Op opcode, const std::vector& rhs_dds); // Returns true if and only if |dd.object()| still exists in the module. bool ObjectStillExists(const protobufs::DataDescriptor& dd) const; // The data descriptors that are known to be synonymous with one another are // captured by this equivalence relation. EquivalenceRelation synonymous_; // When a new synonym fact is added, it may be possible to deduce further // synonym facts by computing a closure of all known facts. However, this is // an expensive operation, so it should be performed sparingly and only there // is some chance of new facts being deduced. This boolean tracks whether a // closure computation is required - i.e., whether a new fact has been added // since the last time such a computation was performed. bool closure_computation_required_ = false; // Represents a set of equations on data descriptors as a map indexed by // left-hand-side, mapping a left-hand-side to a set of operations, each of // which (together with the left-hand-side) defines an equation. // // All data descriptors occurring in equations are required to be present in // the |synonymous_| equivalence relation, and to be their own representatives // in that relation. std::unordered_map id_equations_; // Pointer to the SPIR-V module we store facts about. opt::IRContext* ir_context_; }; } // namespace fact_manager } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FACT_MANAGER_DATA_SYNONYM_AND_ID_EQUATION_FACTS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fact_manager/dead_block_facts.cpp000066400000000000000000000025201475742701700273700ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fact_manager/dead_block_facts.h" #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { namespace fact_manager { DeadBlockFacts::DeadBlockFacts(opt::IRContext* ir_context) : ir_context_(ir_context) {} bool DeadBlockFacts::MaybeAddFact(const protobufs::FactBlockIsDead& fact) { if (!fuzzerutil::MaybeFindBlock(ir_context_, fact.block_id())) { return false; } dead_block_ids_.insert(fact.block_id()); return true; } bool DeadBlockFacts::BlockIsDead(uint32_t block_id) const { return dead_block_ids_.count(block_id) != 0; } const std::unordered_set& DeadBlockFacts::GetDeadBlocks() const { return dead_block_ids_; } } // namespace fact_manager } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fact_manager/dead_block_facts.h000066400000000000000000000033711475742701700270420ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FACT_MANAGER_DEAD_BLOCK_FACTS_H_ #define SOURCE_FUZZ_FACT_MANAGER_DEAD_BLOCK_FACTS_H_ #include #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { namespace fact_manager { // The purpose of this class is to group the fields and data used to represent // facts about data blocks. class DeadBlockFacts { public: explicit DeadBlockFacts(opt::IRContext* ir_context); // Marks |fact.block_id()| as being dead. Returns true if |fact.block_id()| // represents a result id of some OpLabel instruction in |ir_context_|. // Returns false otherwise. bool MaybeAddFact(const protobufs::FactBlockIsDead& fact); // See method in FactManager which delegates to this method. bool BlockIsDead(uint32_t block_id) const; // Returns a set of all the block ids that have been declared dead. const std::unordered_set& GetDeadBlocks() const; private: std::unordered_set dead_block_ids_; opt::IRContext* ir_context_; }; } // namespace fact_manager } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FACT_MANAGER_DEAD_BLOCK_FACTS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fact_manager/fact_manager.cpp000066400000000000000000000231401475742701700265510ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "fact_manager.h" #include #include #include "source/fuzz/uniform_buffer_element_descriptor.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { namespace { std::string ToString(const protobufs::FactConstantUniform& fact) { std::stringstream stream; stream << "(" << fact.uniform_buffer_element_descriptor().descriptor_set() << ", " << fact.uniform_buffer_element_descriptor().binding() << ")["; bool first = true; for (auto index : fact.uniform_buffer_element_descriptor().index()) { if (first) { first = false; } else { stream << ", "; } stream << index; } stream << "] == ["; first = true; for (auto constant_word : fact.constant_word()) { if (first) { first = false; } else { stream << ", "; } stream << constant_word; } stream << "]"; return stream.str(); } std::string ToString(const protobufs::FactDataSynonym& fact) { std::stringstream stream; stream << fact.data1() << " = " << fact.data2(); return stream.str(); } std::string ToString(const protobufs::FactIdEquation& fact) { std::stringstream stream; stream << fact.lhs_id(); stream << " " << fact.opcode(); for (auto rhs_id : fact.rhs_id()) { stream << " " << rhs_id; } return stream.str(); } std::string ToString(const protobufs::Fact& fact) { switch (fact.fact_case()) { case protobufs::Fact::kConstantUniformFact: return ToString(fact.constant_uniform_fact()); case protobufs::Fact::kDataSynonymFact: return ToString(fact.data_synonym_fact()); case protobufs::Fact::kIdEquationFact: return ToString(fact.id_equation_fact()); default: assert(false && "Stringification not supported for this fact."); return ""; } } } // namespace FactManager::FactManager(opt::IRContext* ir_context) : constant_uniform_facts_(ir_context), data_synonym_and_id_equation_facts_(ir_context), dead_block_facts_(ir_context), livesafe_function_facts_(ir_context), irrelevant_value_facts_(ir_context) {} void FactManager::AddInitialFacts(const MessageConsumer& message_consumer, const protobufs::FactSequence& facts) { for (auto& fact : facts.fact()) { if (!MaybeAddFact(fact)) { auto message = "Invalid fact " + ToString(fact) + " ignored."; message_consumer(SPV_MSG_WARNING, nullptr, {}, message.c_str()); } } } bool FactManager::MaybeAddFact(const fuzz::protobufs::Fact& fact) { switch (fact.fact_case()) { case protobufs::Fact::kBlockIsDeadFact: return dead_block_facts_.MaybeAddFact(fact.block_is_dead_fact()); case protobufs::Fact::kConstantUniformFact: return constant_uniform_facts_.MaybeAddFact(fact.constant_uniform_fact()); case protobufs::Fact::kDataSynonymFact: return data_synonym_and_id_equation_facts_.MaybeAddFact( fact.data_synonym_fact(), dead_block_facts_, irrelevant_value_facts_); case protobufs::Fact::kFunctionIsLivesafeFact: return livesafe_function_facts_.MaybeAddFact( fact.function_is_livesafe_fact()); case protobufs::Fact::kIdEquationFact: return data_synonym_and_id_equation_facts_.MaybeAddFact( fact.id_equation_fact(), dead_block_facts_, irrelevant_value_facts_); case protobufs::Fact::kIdIsIrrelevant: return irrelevant_value_facts_.MaybeAddFact( fact.id_is_irrelevant(), data_synonym_and_id_equation_facts_); case protobufs::Fact::kPointeeValueIsIrrelevantFact: return irrelevant_value_facts_.MaybeAddFact( fact.pointee_value_is_irrelevant_fact(), data_synonym_and_id_equation_facts_); case protobufs::Fact::FACT_NOT_SET: assert(false && "The fact must be set"); return false; } assert(false && "Unreachable"); return false; } void FactManager::AddFactDataSynonym(const protobufs::DataDescriptor& data1, const protobufs::DataDescriptor& data2) { protobufs::FactDataSynonym fact; *fact.mutable_data1() = data1; *fact.mutable_data2() = data2; auto success = data_synonym_and_id_equation_facts_.MaybeAddFact( fact, dead_block_facts_, irrelevant_value_facts_); (void)success; // Keep compilers happy in release mode. assert(success && "Unable to create DataSynonym fact"); } std::vector FactManager::GetConstantsAvailableFromUniformsForType( uint32_t type_id) const { return constant_uniform_facts_.GetConstantsAvailableFromUniformsForType( type_id); } std::vector FactManager::GetUniformDescriptorsForConstant(uint32_t constant_id) const { return constant_uniform_facts_.GetUniformDescriptorsForConstant(constant_id); } uint32_t FactManager::GetConstantFromUniformDescriptor( const protobufs::UniformBufferElementDescriptor& uniform_descriptor) const { return constant_uniform_facts_.GetConstantFromUniformDescriptor( uniform_descriptor); } std::vector FactManager::GetTypesForWhichUniformValuesAreKnown() const { return constant_uniform_facts_.GetTypesForWhichUniformValuesAreKnown(); } const std::vector>& FactManager::GetConstantUniformFactsAndTypes() const { return constant_uniform_facts_.GetConstantUniformFactsAndTypes(); } std::vector FactManager::GetIdsForWhichSynonymsAreKnown() const { return data_synonym_and_id_equation_facts_.GetIdsForWhichSynonymsAreKnown(); } std::vector FactManager::GetAllSynonyms() const { return data_synonym_and_id_equation_facts_.GetAllKnownSynonyms(); } std::vector FactManager::GetSynonymsForDataDescriptor( const protobufs::DataDescriptor& data_descriptor) const { return data_synonym_and_id_equation_facts_.GetSynonymsForDataDescriptor( data_descriptor); } std::vector FactManager::GetSynonymsForId( uint32_t id) const { return data_synonym_and_id_equation_facts_.GetSynonymsForId(id); } bool FactManager::IsSynonymous( const protobufs::DataDescriptor& data_descriptor1, const protobufs::DataDescriptor& data_descriptor2) const { return data_synonym_and_id_equation_facts_.IsSynonymous(data_descriptor1, data_descriptor2); } bool FactManager::BlockIsDead(uint32_t block_id) const { return dead_block_facts_.BlockIsDead(block_id); } void FactManager::AddFactBlockIsDead(uint32_t block_id) { protobufs::FactBlockIsDead fact; fact.set_block_id(block_id); auto success = dead_block_facts_.MaybeAddFact(fact); (void)success; // Keep compilers happy in release mode. assert(success && "|block_id| is invalid"); } bool FactManager::FunctionIsLivesafe(uint32_t function_id) const { return livesafe_function_facts_.FunctionIsLivesafe(function_id); } void FactManager::AddFactFunctionIsLivesafe(uint32_t function_id) { protobufs::FactFunctionIsLivesafe fact; fact.set_function_id(function_id); auto success = livesafe_function_facts_.MaybeAddFact(fact); (void)success; // Keep compilers happy in release mode. assert(success && "|function_id| is invalid"); } bool FactManager::PointeeValueIsIrrelevant(uint32_t pointer_id) const { return irrelevant_value_facts_.PointeeValueIsIrrelevant(pointer_id); } bool FactManager::IdIsIrrelevant(uint32_t result_id) const { return irrelevant_value_facts_.IdIsIrrelevant(result_id, dead_block_facts_); } std::unordered_set FactManager::GetIrrelevantIds() const { return irrelevant_value_facts_.GetIrrelevantIds(dead_block_facts_); } void FactManager::AddFactValueOfPointeeIsIrrelevant(uint32_t pointer_id) { protobufs::FactPointeeValueIsIrrelevant fact; fact.set_pointer_id(pointer_id); auto success = irrelevant_value_facts_.MaybeAddFact( fact, data_synonym_and_id_equation_facts_); (void)success; // Keep compilers happy in release mode. assert(success && "|pointer_id| is invalid"); } void FactManager::AddFactIdIsIrrelevant(uint32_t result_id) { protobufs::FactIdIsIrrelevant fact; fact.set_result_id(result_id); auto success = irrelevant_value_facts_.MaybeAddFact( fact, data_synonym_and_id_equation_facts_); (void)success; // Keep compilers happy in release mode. assert(success && "|result_id| is invalid"); } void FactManager::AddFactIdEquation(uint32_t lhs_id, spv::Op opcode, const std::vector& rhs_id) { protobufs::FactIdEquation fact; fact.set_lhs_id(lhs_id); fact.set_opcode(uint32_t(opcode)); for (auto an_rhs_id : rhs_id) { fact.add_rhs_id(an_rhs_id); } auto success = data_synonym_and_id_equation_facts_.MaybeAddFact( fact, dead_block_facts_, irrelevant_value_facts_); (void)success; // Keep compilers happy in release mode. assert(success && "Can't create IdIsIrrelevant fact"); } void FactManager::ComputeClosureOfFacts( uint32_t maximum_equivalence_class_size) { data_synonym_and_id_equation_facts_.ComputeClosureOfFacts( maximum_equivalence_class_size); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fact_manager/fact_manager.h000066400000000000000000000230761475742701700262260ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FACT_MANAGER_FACT_MANAGER_H_ #define SOURCE_FUZZ_FACT_MANAGER_FACT_MANAGER_H_ #include #include #include #include "source/fuzz/data_descriptor.h" #include "source/fuzz/fact_manager/constant_uniform_facts.h" #include "source/fuzz/fact_manager/data_synonym_and_id_equation_facts.h" #include "source/fuzz/fact_manager/dead_block_facts.h" #include "source/fuzz/fact_manager/irrelevant_value_facts.h" #include "source/fuzz/fact_manager/livesafe_function_facts.h" #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/opt/constants.h" namespace spvtools { namespace fuzz { // Keeps track of facts about the module being transformed on which the fuzzing // process can depend. Some initial facts can be provided, for example about // guarantees on the values of inputs to SPIR-V entry points. Transformations // may then rely on these facts, can add further facts that they establish. // Facts are intended to be simple properties that either cannot be deduced from // the module (such as properties that are guaranteed to hold for entry point // inputs), or that are established by transformations, likely to be useful for // future transformations, and not completely trivial to deduce straight from // the module. class FactManager { public: explicit FactManager(opt::IRContext* ir_context); // Adds all the facts from |facts|, checking them for validity with respect to // |ir_context_|. Warnings about invalid facts are communicated via // |message_consumer|; such facts are otherwise ignored. void AddInitialFacts(const MessageConsumer& message_consumer, const protobufs::FactSequence& facts); // Checks the fact for validity with respect to |ir_context_|. Returns false, // with no side effects, if the fact is invalid. Otherwise adds |fact| to the // fact manager. bool MaybeAddFact(const protobufs::Fact& fact); // Record the fact that |data1| and |data2| are synonymous. Neither |data1| // nor |data2| may contain an irrelevant id. void AddFactDataSynonym(const protobufs::DataDescriptor& data1, const protobufs::DataDescriptor& data2); // Records the fact that |block_id| is dead. |block_id| must be a result id // of some OpLabel instruction in the |ir_context_|. void AddFactBlockIsDead(uint32_t block_id); // Records the fact that |function_id| is livesafe. |function_id| must be a // result id of some non-entry-point function in the module. void AddFactFunctionIsLivesafe(uint32_t function_id); // Records the fact that the value of the pointee associated with |pointer_id| // is irrelevant: it does not affect the observable behaviour of the module. // |pointer_id| must exist in the module and actually be a pointer. void AddFactValueOfPointeeIsIrrelevant(uint32_t pointer_id); // Records a fact that the |result_id| is irrelevant (i.e. it doesn't affect // the semantics of the module). // |result_id| must exist in the module and it may not be a pointer. void AddFactIdIsIrrelevant(uint32_t result_id); // Records the fact that |lhs_id| is defined by the equation: // // |lhs_id| = |opcode| |rhs_id[0]| ... |rhs_id[N-1]| // // Neither |lhs_id| nor any of |rhs_id| may be irrelevant. void AddFactIdEquation(uint32_t lhs_id, spv::Op opcode, const std::vector& rhs_id); // Inspects all known facts and adds corollary facts; e.g. if we know that // a.x == b.x and a.y == b.y, where a and b have vec2 type, we can record // that a == b holds. // // This method is expensive, and should only be called (by applying a // transformation) at the start of a fuzzer pass that depends on data // synonym facts, rather than calling it every time a new data synonym fact // is added. // // The parameter |maximum_equivalence_class_size| specifies the size beyond // which equivalence classes should not be mined for new facts, to avoid // excessively-long closure computations. void ComputeClosureOfFacts(uint32_t maximum_equivalence_class_size); // The fact manager is responsible for managing a few distinct categories of // facts. In principle there could be different fact managers for each kind // of fact, but in practice providing one 'go to' place for facts is // convenient. To keep some separation, the public methods of the fact // manager should be grouped according to the kind of fact to which they // relate. //============================== // Querying facts about uniform constants // Provides the distinct type ids for which at least one "constant == // uniform element" fact is known. std::vector GetTypesForWhichUniformValuesAreKnown() const; // Provides distinct constant ids with type |type_id| for which at least one // "constant == uniform element" fact is known. If multiple identically- // valued constants are relevant, only one will appear in the sequence. std::vector GetConstantsAvailableFromUniformsForType( uint32_t type_id) const; // Provides details of all uniform elements that are known to be equal to the // constant associated with |constant_id| in |ir_context_|. std::vector GetUniformDescriptorsForConstant(uint32_t constant_id) const; // Returns the id of a constant whose value is known to match that of // |uniform_descriptor|, and whose type matches the type of the uniform // element. If multiple such constant is exist, the one that is returned // is arbitrary. Returns 0 if no such constant id exists. uint32_t GetConstantFromUniformDescriptor( const protobufs::UniformBufferElementDescriptor& uniform_descriptor) const; // Returns all "constant == uniform element" facts known to the fact // manager, pairing each fact with id of the type that is associated with // both the constant and the uniform element. const std::vector>& GetConstantUniformFactsAndTypes() const; // End of uniform constant facts //============================== //============================== // Querying facts about id synonyms // Returns every id for which a fact of the form "this id is synonymous with // this piece of data" is known. std::vector GetIdsForWhichSynonymsAreKnown() const; // Returns a vector of all data descriptors that participate in DataSynonym // facts. All descriptors are guaranteed to exist in the |ir_context_|. std::vector GetAllSynonyms() const; // Returns the equivalence class of all known synonyms of |id|, or an empty // set if no synonyms are known. std::vector GetSynonymsForId( uint32_t id) const; // Returns the equivalence class of all known synonyms of |data_descriptor|, // or empty if no synonyms are known. std::vector GetSynonymsForDataDescriptor( const protobufs::DataDescriptor& data_descriptor) const; // Returns true if and only if |data_descriptor1| and |data_descriptor2| are // known to be synonymous. bool IsSynonymous(const protobufs::DataDescriptor& data_descriptor1, const protobufs::DataDescriptor& data_descriptor2) const; // End of id synonym facts //============================== //============================== // Querying facts about dead blocks // Returns true if and only if |block_id| is the id of a block known to be // dynamically unreachable. bool BlockIsDead(uint32_t block_id) const; // End of dead block facts //============================== //============================== // Querying facts about livesafe function // Returns true if and only if |function_id| is the id of a function known // to be livesafe. bool FunctionIsLivesafe(uint32_t function_id) const; // End of dead livesafe function facts //============================== //============================== // Querying facts about irrelevant values // Returns true if and only if the value of the pointee associated with // |pointer_id| is irrelevant. bool PointeeValueIsIrrelevant(uint32_t pointer_id) const; // Returns true if there exists a fact that the |result_id| is irrelevant or // if |result_id| is declared in a block that has been declared dead. bool IdIsIrrelevant(uint32_t result_id) const; // Returns a set of all the ids which have been declared irrelevant, or which // have been declared inside a dead block. std::unordered_set GetIrrelevantIds() const; // End of irrelevant value facts //============================== private: // Keep these in alphabetical order. fact_manager::ConstantUniformFacts constant_uniform_facts_; fact_manager::DataSynonymAndIdEquationFacts data_synonym_and_id_equation_facts_; fact_manager::DeadBlockFacts dead_block_facts_; fact_manager::LivesafeFunctionFacts livesafe_function_facts_; fact_manager::IrrelevantValueFacts irrelevant_value_facts_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FACT_MANAGER_FACT_MANAGER_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fact_manager/irrelevant_value_facts.cpp000066400000000000000000000106701475742701700306750ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fact_manager/irrelevant_value_facts.h" #include "source/fuzz/data_descriptor.h" #include "source/fuzz/fact_manager/data_synonym_and_id_equation_facts.h" #include "source/fuzz/fact_manager/dead_block_facts.h" #include "source/fuzz/fuzzer_util.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { namespace fact_manager { IrrelevantValueFacts::IrrelevantValueFacts(opt::IRContext* ir_context) : ir_context_(ir_context) {} bool IrrelevantValueFacts::MaybeAddFact( const protobufs::FactPointeeValueIsIrrelevant& fact, const DataSynonymAndIdEquationFacts& data_synonym_and_id_equation_facts) { const auto* inst = ir_context_->get_def_use_mgr()->GetDef(fact.pointer_id()); if (!inst || !inst->type_id()) { // The id must exist in the module and have type id. return false; } if (!ir_context_->get_type_mgr()->GetType(inst->type_id())->AsPointer()) { // The id must be a pointer. return false; } if (!data_synonym_and_id_equation_facts.GetSynonymsForId(fact.pointer_id()) .empty()) { // Irrelevant id cannot participate in DataSynonym facts. return false; } pointers_to_irrelevant_pointees_ids_.insert(fact.pointer_id()); return true; } bool IrrelevantValueFacts::MaybeAddFact( const protobufs::FactIdIsIrrelevant& fact, const DataSynonymAndIdEquationFacts& data_synonym_and_id_equation_facts) { const auto* inst = ir_context_->get_def_use_mgr()->GetDef(fact.result_id()); if (!inst || !inst->type_id()) { // The id must exist in the module and have type id. return false; } if (ir_context_->get_type_mgr()->GetType(inst->type_id())->AsPointer()) { // The id may not be a pointer. return false; } if (!data_synonym_and_id_equation_facts.GetSynonymsForId(fact.result_id()) .empty()) { // Irrelevant id cannot participate in DataSynonym facts. return false; } irrelevant_ids_.insert(fact.result_id()); return true; } bool IrrelevantValueFacts::PointeeValueIsIrrelevant(uint32_t pointer_id) const { return pointers_to_irrelevant_pointees_ids_.count(pointer_id) != 0; } bool IrrelevantValueFacts::IdIsIrrelevant( uint32_t result_id, const DeadBlockFacts& dead_block_facts) const { // The id is irrelevant if it has been declared irrelevant. if (irrelevant_ids_.count(result_id)) { return true; } // The id must have a non-pointer type to be irrelevant. auto def = ir_context_->get_def_use_mgr()->GetDef(result_id); if (!def) { return false; } auto type = ir_context_->get_type_mgr()->GetType(def->type_id()); if (!type || type->AsPointer()) { return false; } // The id is irrelevant if it is in a dead block. return ir_context_->get_instr_block(result_id) && dead_block_facts.BlockIsDead( ir_context_->get_instr_block(result_id)->id()); } std::unordered_set IrrelevantValueFacts::GetIrrelevantIds( const DeadBlockFacts& dead_block_facts) const { // Get all the ids that have been declared irrelevant. auto irrelevant_ids = irrelevant_ids_; // Get all the non-pointer ids declared in dead blocks that have a type. for (uint32_t block_id : dead_block_facts.GetDeadBlocks()) { auto block = fuzzerutil::MaybeFindBlock(ir_context_, block_id); // It is possible and allowed for the block not to exist, e.g. it could have // been merged with another block. if (!block) { continue; } block->ForEachInst([this, &irrelevant_ids](opt::Instruction* inst) { // The instruction must have a result id and a type, and it must not be a // pointer. if (inst->HasResultId() && inst->type_id() && !ir_context_->get_type_mgr()->GetType(inst->type_id())->AsPointer()) { irrelevant_ids.emplace(inst->result_id()); } }); } return irrelevant_ids; } } // namespace fact_manager } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fact_manager/irrelevant_value_facts.h000066400000000000000000000064371475742701700303500ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FACT_MANAGER_IRRELEVANT_VALUE_FACTS_H_ #define SOURCE_FUZZ_FACT_MANAGER_IRRELEVANT_VALUE_FACTS_H_ #include #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { namespace fact_manager { // Forward reference to the DataSynonymAndIdEquationFacts class. class DataSynonymAndIdEquationFacts; // Forward reference to the DeadBlockFacts class. class DeadBlockFacts; // The purpose of this class is to group the fields and data used to represent // facts about various irrelevant values in the module. class IrrelevantValueFacts { public: explicit IrrelevantValueFacts(opt::IRContext* ir_context); // See method in FactManager which delegates to this method. Returns true if // |fact.pointer_id()| is a result id of pointer type in the |ir_context_| and // |fact.pointer_id()| does not participate in DataSynonym facts. Returns // false otherwise. |data_synonym_and_id_equation_facts| and |context| are // passed for consistency checks. bool MaybeAddFact( const protobufs::FactPointeeValueIsIrrelevant& fact, const DataSynonymAndIdEquationFacts& data_synonym_and_id_equation_facts); // See method in FactManager which delegates to this method. Returns true if // |fact.result_id()| is a result id of non-pointer type in the |ir_context_| // and |fact.result_id()| does not participate in DataSynonym facts. Returns // false otherwise. |data_synonym_and_id_equation_facts| and |context| are // passed for consistency checks. bool MaybeAddFact( const protobufs::FactIdIsIrrelevant& fact, const DataSynonymAndIdEquationFacts& data_synonym_and_id_equation_facts); // See method in FactManager which delegates to this method. bool PointeeValueIsIrrelevant(uint32_t pointer_id) const; // See method in FactManager which delegates to this method. // |dead_block_facts| and |context| are passed to check whether |result_id| is // declared inside a dead block, in which case it is irrelevant. bool IdIsIrrelevant(uint32_t result_id, const DeadBlockFacts& dead_block_facts) const; // See method in FactManager which delegates to this method. // |dead_block_facts| and |context| are passed to also add all the ids // declared in dead blocks to the set of irrelevant ids. std::unordered_set GetIrrelevantIds( const DeadBlockFacts& dead_block_facts) const; private: std::unordered_set pointers_to_irrelevant_pointees_ids_; std::unordered_set irrelevant_ids_; opt::IRContext* ir_context_; }; } // namespace fact_manager } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FACT_MANAGER_IRRELEVANT_VALUE_FACTS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fact_manager/livesafe_function_facts.cpp000066400000000000000000000026271475742701700310340ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fact_manager/livesafe_function_facts.h" #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { namespace fact_manager { LivesafeFunctionFacts::LivesafeFunctionFacts(opt::IRContext* ir_context) : ir_context_(ir_context) {} bool LivesafeFunctionFacts::MaybeAddFact( const protobufs::FactFunctionIsLivesafe& fact) { if (!fuzzerutil::FindFunction(ir_context_, fact.function_id())) { return false; } if (fuzzerutil::FunctionIsEntryPoint(ir_context_, fact.function_id())) { return false; } livesafe_function_ids_.insert(fact.function_id()); return true; } bool LivesafeFunctionFacts::FunctionIsLivesafe(uint32_t function_id) const { return livesafe_function_ids_.count(function_id) != 0; } } // namespace fact_manager } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fact_manager/livesafe_function_facts.h000066400000000000000000000033121475742701700304710ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FACT_MANAGER_LIVESAFE_FUNCTION_FACTS_H_ #define SOURCE_FUZZ_FACT_MANAGER_LIVESAFE_FUNCTION_FACTS_H_ #include #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { namespace fact_manager { // The purpose of this class is to group the fields and data used to represent // facts about livesafe functions. class LivesafeFunctionFacts { public: explicit LivesafeFunctionFacts(opt::IRContext* ir_context); // See method in FactManager which delegates to this method. Returns true if // |fact.function_id()| is a result id of some non-entry-point function in // |ir_context_|. Returns false otherwise. bool MaybeAddFact(const protobufs::FactFunctionIsLivesafe& fact); // See method in FactManager which delegates to this method. bool FunctionIsLivesafe(uint32_t function_id) const; private: std::unordered_set livesafe_function_ids_; opt::IRContext* ir_context_; }; } // namespace fact_manager } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FACT_MANAGER_LIVESAFE_FUNCTION_FACTS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/force_render_red.cpp000066400000000000000000000375451475742701700250400ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/force_render_red.h" #include "source/fuzz/fact_manager/fact_manager.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation_context.h" #include "source/fuzz/transformation_replace_constant_with_uniform.h" #include "source/opt/build_module.h" #include "source/opt/ir_context.h" #include "source/opt/types.h" #include "source/util/make_unique.h" namespace spvtools { namespace fuzz { namespace { // Helper method to find the fragment shader entry point, complaining if there // is no shader or if there is no fragment entry point. opt::Function* FindFragmentShaderEntryPoint(opt::IRContext* ir_context, MessageConsumer message_consumer) { // Check that this is a fragment shader bool found_capability_shader = false; for (auto& capability : ir_context->capabilities()) { assert(capability.opcode() == spv::Op::OpCapability); if (spv::Capability(capability.GetSingleWordInOperand(0)) == spv::Capability::Shader) { found_capability_shader = true; break; } } if (!found_capability_shader) { message_consumer( SPV_MSG_ERROR, nullptr, {}, "Forcing of red rendering requires the Shader capability."); return nullptr; } opt::Instruction* fragment_entry_point = nullptr; for (auto& entry_point : ir_context->module()->entry_points()) { if (spv::ExecutionModel(entry_point.GetSingleWordInOperand(0)) == spv::ExecutionModel::Fragment) { fragment_entry_point = &entry_point; break; } } if (fragment_entry_point == nullptr) { message_consumer(SPV_MSG_ERROR, nullptr, {}, "Forcing of red rendering requires an entry point with " "the Fragment execution model."); return nullptr; } for (auto& function : *ir_context->module()) { if (function.result_id() == fragment_entry_point->GetSingleWordInOperand(1)) { return &function; } } assert( false && "A valid module must have a function associate with each entry point."); return nullptr; } // Helper method to check that there is a single vec4 output variable and get a // pointer to it. opt::Instruction* FindVec4OutputVariable(opt::IRContext* ir_context, MessageConsumer message_consumer) { opt::Instruction* output_variable = nullptr; for (auto& inst : ir_context->types_values()) { if (inst.opcode() == spv::Op::OpVariable && spv::StorageClass(inst.GetSingleWordInOperand(0)) == spv::StorageClass::Output) { if (output_variable != nullptr) { message_consumer(SPV_MSG_ERROR, nullptr, {}, "Only one output variable can be handled at present; " "found multiple."); return nullptr; } output_variable = &inst; // Do not break, as we want to check for multiple output variables. } } if (output_variable == nullptr) { message_consumer(SPV_MSG_ERROR, nullptr, {}, "No output variable to which to write red was found."); return nullptr; } auto output_variable_base_type = ir_context->get_type_mgr() ->GetType(output_variable->type_id()) ->AsPointer() ->pointee_type() ->AsVector(); if (!output_variable_base_type || output_variable_base_type->element_count() != 4 || !output_variable_base_type->element_type()->AsFloat()) { message_consumer(SPV_MSG_ERROR, nullptr, {}, "The output variable must have type vec4."); return nullptr; } return output_variable; } // Helper to get the ids of float constants 0.0 and 1.0, creating them if // necessary. std::pair FindOrCreateFloatZeroAndOne( opt::IRContext* ir_context, opt::analysis::Float* float_type) { float one = 1.0; uint32_t one_as_uint; memcpy(&one_as_uint, &one, sizeof(float)); std::vector zero_bytes = {0}; std::vector one_bytes = {one_as_uint}; auto constant_zero = ir_context->get_constant_mgr()->RegisterConstant( MakeUnique(float_type, zero_bytes)); auto constant_one = ir_context->get_constant_mgr()->RegisterConstant( MakeUnique(float_type, one_bytes)); auto constant_zero_id = ir_context->get_constant_mgr() ->GetDefiningInstruction(constant_zero) ->result_id(); auto constant_one_id = ir_context->get_constant_mgr() ->GetDefiningInstruction(constant_one) ->result_id(); return std::pair(constant_zero_id, constant_one_id); } std::unique_ptr MakeConstantUniformReplacement(opt::IRContext* ir_context, const FactManager& fact_manager, uint32_t constant_id, uint32_t greater_than_instruction, uint32_t in_operand_index) { return MakeUnique( MakeIdUseDescriptor( constant_id, MakeInstructionDescriptor(greater_than_instruction, spv::Op::OpFOrdGreaterThan, 0), in_operand_index), fact_manager.GetUniformDescriptorsForConstant(constant_id)[0], ir_context->TakeNextId(), ir_context->TakeNextId()); } } // namespace bool ForceRenderRed( const spv_target_env& target_env, spv_validator_options validator_options, const std::vector& binary_in, const spvtools::fuzz::protobufs::FactSequence& initial_facts, const MessageConsumer& message_consumer, std::vector* binary_out) { spvtools::SpirvTools tools(target_env); if (!tools.IsValid()) { message_consumer(SPV_MSG_ERROR, nullptr, {}, "Failed to create SPIRV-Tools interface; stopping."); return false; } // Initial binary should be valid. if (!tools.Validate(&binary_in[0], binary_in.size(), validator_options)) { message_consumer(SPV_MSG_ERROR, nullptr, {}, "Initial binary is invalid; stopping."); return false; } // Build the module from the input binary. std::unique_ptr ir_context = BuildModule( target_env, message_consumer, binary_in.data(), binary_in.size()); assert(ir_context); // Set up a fact manager with any given initial facts. TransformationContext transformation_context( MakeUnique(ir_context.get()), validator_options); for (auto& fact : initial_facts.fact()) { transformation_context.GetFactManager()->MaybeAddFact(fact); } auto entry_point_function = FindFragmentShaderEntryPoint(ir_context.get(), message_consumer); auto output_variable = FindVec4OutputVariable(ir_context.get(), message_consumer); if (entry_point_function == nullptr || output_variable == nullptr) { return false; } opt::analysis::Float temp_float_type(32); opt::analysis::Float* float_type = ir_context->get_type_mgr() ->GetRegisteredType(&temp_float_type) ->AsFloat(); std::pair zero_one_float_ids = FindOrCreateFloatZeroAndOne(ir_context.get(), float_type); // Make the new exit block auto new_exit_block_id = ir_context->TakeNextId(); { auto label = MakeUnique( ir_context.get(), spv::Op::OpLabel, 0, new_exit_block_id, opt::Instruction::OperandList()); auto new_exit_block = MakeUnique(std::move(label)); new_exit_block->AddInstruction( MakeUnique(ir_context.get(), spv::Op::OpReturn, 0, 0, opt::Instruction::OperandList())); entry_point_function->AddBasicBlock(std::move(new_exit_block)); } // Make the new entry block { auto label = MakeUnique( ir_context.get(), spv::Op::OpLabel, 0, ir_context->TakeNextId(), opt::Instruction::OperandList()); auto new_entry_block = MakeUnique(std::move(label)); // Make an instruction to construct vec4(1.0, 0.0, 0.0, 1.0), representing // the colour red. opt::Operand zero_float = {SPV_OPERAND_TYPE_ID, {zero_one_float_ids.first}}; opt::Operand one_float = {SPV_OPERAND_TYPE_ID, {zero_one_float_ids.second}}; opt::Instruction::OperandList op_composite_construct_operands = { one_float, zero_float, zero_float, one_float}; auto temp_vec4 = opt::analysis::Vector(float_type, 4); auto vec4_id = ir_context->get_type_mgr()->GetId(&temp_vec4); auto red = MakeUnique( ir_context.get(), spv::Op::OpCompositeConstruct, vec4_id, ir_context->TakeNextId(), op_composite_construct_operands); auto red_id = red->result_id(); new_entry_block->AddInstruction(std::move(red)); // Make an instruction to store red into the output color. opt::Operand variable_to_store_into = {SPV_OPERAND_TYPE_ID, {output_variable->result_id()}}; opt::Operand value_to_be_stored = {SPV_OPERAND_TYPE_ID, {red_id}}; opt::Instruction::OperandList op_store_operands = {variable_to_store_into, value_to_be_stored}; new_entry_block->AddInstruction(MakeUnique( ir_context.get(), spv::Op::OpStore, 0, 0, op_store_operands)); // We are going to attempt to construct 'false' as an expression of the form // 'literal1 > literal2'. If we succeed, we will later replace each literal // with a uniform of the same value - we can only do that replacement once // we have added the entry block to the module. std::unique_ptr first_greater_then_operand_replacement = nullptr; std::unique_ptr second_greater_then_operand_replacement = nullptr; uint32_t id_guaranteed_to_be_false = 0; opt::analysis::Bool temp_bool_type; opt::analysis::Bool* registered_bool_type = ir_context->get_type_mgr() ->GetRegisteredType(&temp_bool_type) ->AsBool(); auto float_type_id = ir_context->get_type_mgr()->GetId(float_type); auto types_for_which_uniforms_are_known = transformation_context.GetFactManager() ->GetTypesForWhichUniformValuesAreKnown(); // Check whether we have any float uniforms. if (std::find(types_for_which_uniforms_are_known.begin(), types_for_which_uniforms_are_known.end(), float_type_id) != types_for_which_uniforms_are_known.end()) { // We have at least one float uniform; let's see whether we have at least // two. auto available_constants = transformation_context.GetFactManager() ->GetConstantsAvailableFromUniformsForType(float_type_id); if (available_constants.size() > 1) { // Grab the float constants associated with the first two known float // uniforms. auto first_constant = ir_context->get_constant_mgr() ->GetConstantFromInst(ir_context->get_def_use_mgr()->GetDef( available_constants[0])) ->AsFloatConstant(); auto second_constant = ir_context->get_constant_mgr() ->GetConstantFromInst(ir_context->get_def_use_mgr()->GetDef( available_constants[1])) ->AsFloatConstant(); // Now work out which of the two constants is larger than the other. uint32_t larger_constant_index = 0; uint32_t smaller_constant_index = 0; if (first_constant->GetFloat() > second_constant->GetFloat()) { larger_constant_index = 0; smaller_constant_index = 1; } else if (first_constant->GetFloat() < second_constant->GetFloat()) { larger_constant_index = 1; smaller_constant_index = 0; } // Only proceed with these constants if they have turned out to be // distinct. if (larger_constant_index != smaller_constant_index) { // We are in a position to create 'false' as 'literal1 > literal2', so // reserve an id for this computation; this id will end up being // guaranteed to be 'false'. id_guaranteed_to_be_false = ir_context->TakeNextId(); auto smaller_constant = available_constants[smaller_constant_index]; auto larger_constant = available_constants[larger_constant_index]; opt::Instruction::OperandList greater_than_operands = { {SPV_OPERAND_TYPE_ID, {smaller_constant}}, {SPV_OPERAND_TYPE_ID, {larger_constant}}}; new_entry_block->AddInstruction(MakeUnique( ir_context.get(), spv::Op::OpFOrdGreaterThan, ir_context->get_type_mgr()->GetId(registered_bool_type), id_guaranteed_to_be_false, greater_than_operands)); first_greater_then_operand_replacement = MakeConstantUniformReplacement( ir_context.get(), *transformation_context.GetFactManager(), smaller_constant, id_guaranteed_to_be_false, 0); second_greater_then_operand_replacement = MakeConstantUniformReplacement( ir_context.get(), *transformation_context.GetFactManager(), larger_constant, id_guaranteed_to_be_false, 1); } } } if (id_guaranteed_to_be_false == 0) { auto constant_false = ir_context->get_constant_mgr()->RegisterConstant( MakeUnique(registered_bool_type, false)); id_guaranteed_to_be_false = ir_context->get_constant_mgr() ->GetDefiningInstruction(constant_false) ->result_id(); } opt::Operand false_condition = {SPV_OPERAND_TYPE_ID, {id_guaranteed_to_be_false}}; opt::Operand then_block = {SPV_OPERAND_TYPE_ID, {entry_point_function->entry()->id()}}; opt::Operand else_block = {SPV_OPERAND_TYPE_ID, {new_exit_block_id}}; opt::Instruction::OperandList op_branch_conditional_operands = { false_condition, then_block, else_block}; new_entry_block->AddInstruction(MakeUnique( ir_context.get(), spv::Op::OpBranchConditional, 0, 0, op_branch_conditional_operands)); entry_point_function->InsertBasicBlockBefore( std::move(new_entry_block), entry_point_function->entry().get()); for (auto& replacement : {first_greater_then_operand_replacement.get(), second_greater_then_operand_replacement.get()}) { if (replacement) { assert(replacement->IsApplicable(ir_context.get(), transformation_context)); replacement->Apply(ir_context.get(), &transformation_context); } } } // Write out the module as a binary. ir_context->module()->ToBinary(binary_out, false); return true; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/force_render_red.h000066400000000000000000000032751475742701700244760ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FORCE_RENDER_RED_H_ #define SOURCE_FORCE_RENDER_RED_H_ #include #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "spirv-tools/libspirv.hpp" namespace spvtools { namespace fuzz { // Requires |binary_in| to be a valid SPIR-V module with Shader capability, // containing an entry point with the Fragment execution model, and a single // output variable of type vec4. // // Turns the body of this entry point into effectively: // // output_variable = vec4(1.0, 0.0, 0.0, 1.0); // if (false) { // original_body // } // // If suitable facts about values of uniforms are available, the 'false' will // instead become: 'u > v', where 'u' and 'v' are pieces of uniform data for // which it is known that 'u < v' holds. bool ForceRenderRed( const spv_target_env& target_env, spv_validator_options validator_options, const std::vector& binary_in, const spvtools::fuzz::protobufs::FactSequence& initial_facts, const MessageConsumer& message_consumer, std::vector* binary_out); } // namespace fuzz } // namespace spvtools #endif // SOURCE_FORCE_RENDER_RED_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer.cpp000066400000000000000000000462331475742701700230700ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer.h" #include #include #include #include "source/fuzz/fuzzer_context.h" #include "source/fuzz/fuzzer_pass_add_access_chains.h" #include "source/fuzz/fuzzer_pass_add_bit_instruction_synonyms.h" #include "source/fuzz/fuzzer_pass_add_composite_extract.h" #include "source/fuzz/fuzzer_pass_add_composite_inserts.h" #include "source/fuzz/fuzzer_pass_add_composite_types.h" #include "source/fuzz/fuzzer_pass_add_copy_memory.h" #include "source/fuzz/fuzzer_pass_add_dead_blocks.h" #include "source/fuzz/fuzzer_pass_add_dead_breaks.h" #include "source/fuzz/fuzzer_pass_add_dead_continues.h" #include "source/fuzz/fuzzer_pass_add_equation_instructions.h" #include "source/fuzz/fuzzer_pass_add_function_calls.h" #include "source/fuzz/fuzzer_pass_add_global_variables.h" #include "source/fuzz/fuzzer_pass_add_image_sample_unused_components.h" #include "source/fuzz/fuzzer_pass_add_loads.h" #include "source/fuzz/fuzzer_pass_add_local_variables.h" #include "source/fuzz/fuzzer_pass_add_loop_preheaders.h" #include "source/fuzz/fuzzer_pass_add_loops_to_create_int_constant_synonyms.h" #include "source/fuzz/fuzzer_pass_add_no_contraction_decorations.h" #include "source/fuzz/fuzzer_pass_add_opphi_synonyms.h" #include "source/fuzz/fuzzer_pass_add_parameters.h" #include "source/fuzz/fuzzer_pass_add_relaxed_decorations.h" #include "source/fuzz/fuzzer_pass_add_stores.h" #include "source/fuzz/fuzzer_pass_add_synonyms.h" #include "source/fuzz/fuzzer_pass_add_vector_shuffle_instructions.h" #include "source/fuzz/fuzzer_pass_adjust_branch_weights.h" #include "source/fuzz/fuzzer_pass_adjust_function_controls.h" #include "source/fuzz/fuzzer_pass_adjust_loop_controls.h" #include "source/fuzz/fuzzer_pass_adjust_memory_operands_masks.h" #include "source/fuzz/fuzzer_pass_adjust_selection_controls.h" #include "source/fuzz/fuzzer_pass_apply_id_synonyms.h" #include "source/fuzz/fuzzer_pass_construct_composites.h" #include "source/fuzz/fuzzer_pass_copy_objects.h" #include "source/fuzz/fuzzer_pass_donate_modules.h" #include "source/fuzz/fuzzer_pass_duplicate_regions_with_selections.h" #include "source/fuzz/fuzzer_pass_expand_vector_reductions.h" #include "source/fuzz/fuzzer_pass_flatten_conditional_branches.h" #include "source/fuzz/fuzzer_pass_inline_functions.h" #include "source/fuzz/fuzzer_pass_interchange_signedness_of_integer_operands.h" #include "source/fuzz/fuzzer_pass_interchange_zero_like_constants.h" #include "source/fuzz/fuzzer_pass_invert_comparison_operators.h" #include "source/fuzz/fuzzer_pass_make_vector_operations_dynamic.h" #include "source/fuzz/fuzzer_pass_merge_blocks.h" #include "source/fuzz/fuzzer_pass_merge_function_returns.h" #include "source/fuzz/fuzzer_pass_mutate_pointers.h" #include "source/fuzz/fuzzer_pass_obfuscate_constants.h" #include "source/fuzz/fuzzer_pass_outline_functions.h" #include "source/fuzz/fuzzer_pass_permute_blocks.h" #include "source/fuzz/fuzzer_pass_permute_function_parameters.h" #include "source/fuzz/fuzzer_pass_permute_function_variables.h" #include "source/fuzz/fuzzer_pass_permute_instructions.h" #include "source/fuzz/fuzzer_pass_permute_phi_operands.h" #include "source/fuzz/fuzzer_pass_propagate_instructions_down.h" #include "source/fuzz/fuzzer_pass_propagate_instructions_up.h" #include "source/fuzz/fuzzer_pass_push_ids_through_variables.h" #include "source/fuzz/fuzzer_pass_replace_adds_subs_muls_with_carrying_extended.h" #include "source/fuzz/fuzzer_pass_replace_branches_from_dead_blocks_with_exits.h" #include "source/fuzz/fuzzer_pass_replace_copy_memories_with_loads_stores.h" #include "source/fuzz/fuzzer_pass_replace_copy_objects_with_stores_loads.h" #include "source/fuzz/fuzzer_pass_replace_irrelevant_ids.h" #include "source/fuzz/fuzzer_pass_replace_linear_algebra_instructions.h" #include "source/fuzz/fuzzer_pass_replace_loads_stores_with_copy_memories.h" #include "source/fuzz/fuzzer_pass_replace_opphi_ids_from_dead_predecessors.h" #include "source/fuzz/fuzzer_pass_replace_opselects_with_conditional_branches.h" #include "source/fuzz/fuzzer_pass_replace_parameter_with_global.h" #include "source/fuzz/fuzzer_pass_replace_params_with_struct.h" #include "source/fuzz/fuzzer_pass_split_blocks.h" #include "source/fuzz/fuzzer_pass_swap_commutable_operands.h" #include "source/fuzz/fuzzer_pass_swap_conditional_branch_operands.h" #include "source/fuzz/fuzzer_pass_swap_functions.h" #include "source/fuzz/fuzzer_pass_toggle_access_chain_instruction.h" #include "source/fuzz/fuzzer_pass_wrap_regions_in_selections.h" #include "source/fuzz/fuzzer_pass_wrap_vector_synonym.h" #include "source/fuzz/pass_management/repeated_pass_manager.h" #include "source/fuzz/pass_management/repeated_pass_recommender_standard.h" #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation_context.h" #include "source/opt/build_module.h" #include "source/spirv_fuzzer_options.h" #include "source/util/make_unique.h" namespace spvtools { namespace fuzz { Fuzzer::Fuzzer(std::unique_ptr ir_context, std::unique_ptr transformation_context, std::unique_ptr fuzzer_context, MessageConsumer consumer, const std::vector& donor_suppliers, bool enable_all_passes, RepeatedPassStrategy repeated_pass_strategy, bool validate_after_each_fuzzer_pass, spv_validator_options validator_options, bool ignore_inapplicable_transformations /* = true */) : consumer_(std::move(consumer)), enable_all_passes_(enable_all_passes), validate_after_each_fuzzer_pass_(validate_after_each_fuzzer_pass), validator_options_(validator_options), num_repeated_passes_applied_(0), is_valid_(true), ir_context_(std::move(ir_context)), transformation_context_(std::move(transformation_context)), fuzzer_context_(std::move(fuzzer_context)), transformation_sequence_out_(), pass_instances_(), repeated_pass_recommender_(nullptr), repeated_pass_manager_(nullptr), final_passes_(), ignore_inapplicable_transformations_( ignore_inapplicable_transformations) { assert(ir_context_ && "IRContext is not initialized"); assert(fuzzer_context_ && "FuzzerContext is not initialized"); assert(transformation_context_ && "TransformationContext is not initialized"); assert(fuzzerutil::IsValidAndWellFormed(ir_context_.get(), validator_options_, consumer_) && "IRContext is invalid"); // The following passes are likely to be very useful: many other passes // introduce synonyms, irrelevant ids and constants that these passes can work // with. We thus enable them with high probability. MaybeAddRepeatedPass(90, &pass_instances_); MaybeAddRepeatedPass(90, &pass_instances_); MaybeAddRepeatedPass(90, &pass_instances_); do { // Each call to MaybeAddRepeatedPass randomly decides whether the given pass // should be enabled, and adds an instance of the pass to |pass_instances| // if it is enabled. MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass( &pass_instances_); MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass( &pass_instances_); MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass( &pass_instances_); MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass(&pass_instances_, donor_suppliers); MaybeAddRepeatedPass( &pass_instances_); MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass( &pass_instances_); MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass( &pass_instances_); MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass( &pass_instances_); MaybeAddRepeatedPass( &pass_instances_); MaybeAddRepeatedPass( &pass_instances_); MaybeAddRepeatedPass( &pass_instances_); MaybeAddRepeatedPass( &pass_instances_); MaybeAddRepeatedPass( &pass_instances_); MaybeAddRepeatedPass( &pass_instances_); MaybeAddRepeatedPass( &pass_instances_); MaybeAddRepeatedPass( &pass_instances_); MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass( &pass_instances_); MaybeAddRepeatedPass(&pass_instances_); MaybeAddRepeatedPass(&pass_instances_); // There is a theoretical possibility that no pass instances were created // until now; loop again if so. } while (pass_instances_.GetPasses().empty()); repeated_pass_recommender_ = MakeUnique( &pass_instances_, fuzzer_context_.get()); repeated_pass_manager_ = RepeatedPassManager::Create( repeated_pass_strategy, fuzzer_context_.get(), &pass_instances_, repeated_pass_recommender_.get()); MaybeAddFinalPass(&final_passes_); MaybeAddFinalPass(&final_passes_); MaybeAddFinalPass(&final_passes_); MaybeAddFinalPass(&final_passes_); MaybeAddFinalPass(&final_passes_); MaybeAddFinalPass(&final_passes_); if (!fuzzer_context_->IsWgslCompatible()) { // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/4214): // this is disabled temporarily due to some issues in the Tint compiler. // Enable it back when the issues are resolved. MaybeAddFinalPass( &final_passes_); } MaybeAddFinalPass(&final_passes_); MaybeAddFinalPass(&final_passes_); MaybeAddFinalPass(&final_passes_); MaybeAddFinalPass(&final_passes_); MaybeAddFinalPass(&final_passes_); MaybeAddFinalPass(&final_passes_); } Fuzzer::~Fuzzer() = default; template void Fuzzer::MaybeAddRepeatedPass(uint32_t percentage_chance_of_adding_pass, RepeatedPassInstances* pass_instances, Args&&... extra_args) { if (enable_all_passes_ || fuzzer_context_->ChoosePercentage(percentage_chance_of_adding_pass)) { pass_instances->SetPass(MakeUnique( ir_context_.get(), transformation_context_.get(), fuzzer_context_.get(), &transformation_sequence_out_, ignore_inapplicable_transformations_, std::forward(extra_args)...)); } } template void Fuzzer::MaybeAddFinalPass(std::vector>* passes, Args&&... extra_args) { if (enable_all_passes_ || fuzzer_context_->ChooseEven()) { passes->push_back(MakeUnique( ir_context_.get(), transformation_context_.get(), fuzzer_context_.get(), &transformation_sequence_out_, ignore_inapplicable_transformations_, std::forward(extra_args)...)); } } bool Fuzzer::ApplyPassAndCheckValidity(FuzzerPass* pass) const { pass->Apply(); return !validate_after_each_fuzzer_pass_ || fuzzerutil::IsValidAndWellFormed(ir_context_.get(), validator_options_, consumer_); } opt::IRContext* Fuzzer::GetIRContext() { return ir_context_.get(); } const protobufs::TransformationSequence& Fuzzer::GetTransformationSequence() const { return transformation_sequence_out_; } Fuzzer::Result Fuzzer::Run(uint32_t num_of_transformations_to_apply) { assert(is_valid_ && "The module was invalidated during the previous fuzzing"); const auto initial_num_of_transformations = static_cast(transformation_sequence_out_.transformation_size()); auto status = Status::kComplete; do { if (!ApplyPassAndCheckValidity( repeated_pass_manager_->ChoosePass(transformation_sequence_out_))) { status = Status::kFuzzerPassLedToInvalidModule; break; } // Check that the module is small enough. if (ir_context_->module()->id_bound() >= fuzzer_context_->GetIdBoundLimit()) { status = Status::kModuleTooBig; break; } auto transformations_applied_so_far = static_cast( transformation_sequence_out_.transformation_size()); assert(transformations_applied_so_far >= initial_num_of_transformations && "Number of transformations cannot decrease"); // Check if we've already applied the maximum number of transformations. if (transformations_applied_so_far >= fuzzer_context_->GetTransformationLimit()) { status = Status::kTransformationLimitReached; break; } // Check that we've not got stuck (this can happen if the only available // fuzzer passes are not able to apply any transformations, or can only // apply very few transformations). if (num_repeated_passes_applied_ >= fuzzer_context_->GetTransformationLimit()) { status = Status::kFuzzerStuck; break; } // Check whether we've exceeded the number of transformations we can apply // in a single call to this method. if (num_of_transformations_to_apply != 0 && transformations_applied_so_far - initial_num_of_transformations >= num_of_transformations_to_apply) { status = Status::kComplete; break; } } while (ShouldContinueRepeatedPasses(num_of_transformations_to_apply == 0)); if (status != Status::kFuzzerPassLedToInvalidModule) { // We apply this transformations despite the fact that we might exceed // |num_of_transformations_to_apply|. This is not a problem for us since // these fuzzer passes are relatively simple yet might trigger some bugs. for (auto& pass : final_passes_) { if (!ApplyPassAndCheckValidity(pass.get())) { status = Status::kFuzzerPassLedToInvalidModule; break; } } } is_valid_ = status != Status::kFuzzerPassLedToInvalidModule; return {status, static_cast( transformation_sequence_out_.transformation_size()) != initial_num_of_transformations}; } bool Fuzzer::ShouldContinueRepeatedPasses( bool continue_fuzzing_probabilistically) { if (continue_fuzzing_probabilistically) { // If we have applied T transformations so far, and the limit on the number // of transformations to apply is L (where T < L), the chance that we will // continue fuzzing is: // // 1 - T/(2*L) // // That is, the chance of continuing decreases as more transformations are // applied. Using 2*L instead of L increases the number of transformations // that are applied on average. auto transformations_applied_so_far = static_cast( transformation_sequence_out_.transformation_size()); auto chance_of_continuing = static_cast( 100.0 * (1.0 - (static_cast(transformations_applied_so_far) / (2.0 * static_cast( fuzzer_context_->GetTransformationLimit()))))); if (!fuzzer_context_->ChoosePercentage(chance_of_continuing)) { // We have probabilistically decided to stop. return false; } } // Continue fuzzing! num_repeated_passes_applied_++; return true; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer.h000066400000000000000000000203651475742701700225330ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_H_ #define SOURCE_FUZZ_FUZZER_H_ #include #include #include #include "source/fuzz/fuzzer_context.h" #include "source/fuzz/fuzzer_pass.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/pass_management/repeated_pass_instances.h" #include "source/fuzz/pass_management/repeated_pass_manager.h" #include "source/fuzz/pass_management/repeated_pass_recommender.h" #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/random_generator.h" #include "source/opt/ir_context.h" #include "spirv-tools/libspirv.hpp" namespace spvtools { namespace fuzz { // Transforms a SPIR-V module into a semantically equivalent SPIR-V module by // running a number of randomized fuzzer passes. class Fuzzer { public: // Possible statuses that can result from running the fuzzer. enum class Status { kComplete, kModuleTooBig, kTransformationLimitReached, kFuzzerStuck, kFuzzerPassLedToInvalidModule, }; struct Result { // Status of the fuzzing session. Status status; // Equals to true if new transformations were applied during the previous // fuzzing session. bool is_changed; }; Fuzzer(std::unique_ptr ir_context, std::unique_ptr transformation_context, std::unique_ptr fuzzer_context, MessageConsumer consumer, const std::vector& donor_suppliers, bool enable_all_passes, RepeatedPassStrategy repeated_pass_strategy, bool validate_after_each_fuzzer_pass, spv_validator_options validator_options, bool ignore_inapplicable_transformations = true); // Disables copy/move constructor/assignment operations. Fuzzer(const Fuzzer&) = delete; Fuzzer(Fuzzer&&) = delete; Fuzzer& operator=(const Fuzzer&) = delete; Fuzzer& operator=(Fuzzer&&) = delete; ~Fuzzer(); // Transforms |ir_context_| by running a number of randomized fuzzer passes. // Initial facts about the input binary and the context in which it will be // executed are provided with |transformation_context_|. // |num_of_transformations| is equal to the maximum number of transformations // applied in a single call to this method. This parameter is ignored if its // value is equal to 0. Because fuzzing cannot stop mid way through a fuzzer // pass, fuzzing will stop after the fuzzer pass that exceeds // |num_of_transformations| has completed, so that the total number of // transformations may be somewhat larger than this number. Result Run(uint32_t num_of_transformations_to_apply); // Returns the current IR context. It may be invalid if the Run method // returned Status::kFuzzerPassLedToInvalidModule previously. opt::IRContext* GetIRContext(); // Returns the sequence of applied transformations. const protobufs::TransformationSequence& GetTransformationSequence() const; private: // A convenience method to add a repeated fuzzer pass to |pass_instances| with // probability |percentage_chance_of_adding_pass|%, or with probability 100% // if |enable_all_passes_| is true. // // All fuzzer passes take members |ir_context_|, |transformation_context_|, // |fuzzer_context_| and |transformation_sequence_out_| as parameters. Extra // arguments can be provided via |extra_args|. template void MaybeAddRepeatedPass(uint32_t percentage_chance_of_adding_pass, RepeatedPassInstances* pass_instances, Args&&... extra_args); // The same as the above, with |percentage_chance_of_adding_pass| == 50%. template void MaybeAddRepeatedPass(RepeatedPassInstances* pass_instances, Args&&... extra_args) { MaybeAddRepeatedPass(50, pass_instances, std::forward(extra_args)...); } // A convenience method to add a final fuzzer pass to |passes| with // probability 50%, or with probability 100% if |enable_all_passes_| is true. // // All fuzzer passes take members |ir_context_|, |transformation_context_|, // |fuzzer_context_| and |transformation_sequence_out_| as parameters. Extra // arguments can be provided via |extra_args|. template void MaybeAddFinalPass(std::vector>* passes, Args&&... extra_args); // Decides whether to apply more repeated passes. The probability decreases as // the number of transformations that have been applied increases. // The described probability is only applied if // |continue_fuzzing_probabilistically| is true. bool ShouldContinueRepeatedPasses(bool continue_fuzzing_probabilistically); // Applies |pass|, which must be a pass constructed with |ir_context|. // If |validate_after_each_fuzzer_pass_| is not set, true is always returned. // Otherwise, true is returned if and only if |ir_context| passes validation, // every block has its enclosing function as its parent, and every // instruction has a distinct unique id. bool ApplyPassAndCheckValidity(FuzzerPass* pass) const; // Message consumer that will be invoked once for each message communicated // from the library. const MessageConsumer consumer_; // Determines whether all passes should be enabled, vs. having passes be // probabilistically enabled. const bool enable_all_passes_; // Determines whether the validator should be invoked after every fuzzer pass. const bool validate_after_each_fuzzer_pass_; // Options to control validation. const spv_validator_options validator_options_; // The number of repeated fuzzer passes that have been applied is kept track // of, in order to enforce a hard limit on the number of times such passes // can be applied. uint32_t num_repeated_passes_applied_; // We use this to determine whether we can continue fuzzing incrementally // since the previous call to the Run method could've returned // kFuzzerPassLedToInvalidModule. bool is_valid_; // Intermediate representation for the module being fuzzed, which gets // mutated as fuzzing proceeds. std::unique_ptr ir_context_; // Contextual information that is required in order to apply // transformations. std::unique_ptr transformation_context_; // Provides probabilities that control the fuzzing process. std::unique_ptr fuzzer_context_; // The sequence of transformations that have been applied during fuzzing. It // is initially empty and grows as fuzzer passes are applied. protobufs::TransformationSequence transformation_sequence_out_; // This object contains instances of all fuzzer passes that will participate // in the fuzzing. RepeatedPassInstances pass_instances_; // This object defines the recommendation logic for fuzzer passes. std::unique_ptr repeated_pass_recommender_; // This object manager a list of fuzzer pass and their available // recommendations. std::unique_ptr repeated_pass_manager_; // Some passes that it does not make sense to apply repeatedly, as they do not // unlock other passes. std::vector> final_passes_; // When set, this flag causes inapplicable transformations that should be // applicable by construction to be ignored. This is useful when the fuzzer // is being deployed at scale to test a SPIR-V processing tool, and where it // is desirable to ignore bugs in the fuzzer itself. const bool ignore_inapplicable_transformations_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_context.cpp000066400000000000000000000552341475742701700246350ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_context.h" #include namespace spvtools { namespace fuzz { namespace { // An offset between the module's id bound and the minimum fresh id. // // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/2541): consider // the case where the maximum id bound is reached. const uint32_t kIdBoundGap = 100; // Limits to help control the overall fuzzing process and rein in individual // fuzzer passes. const uint32_t kIdBoundLimit = 50000; const uint32_t kTransformationLimit = 2000; // Default pairs of probabilities for applying various // transformations. All values are percentages. Keep them in alphabetical order. const std::pair kChanceOfAcceptingRepeatedPassRecommendation = {50, 80}; const std::pair kChanceOfAddingAccessChain = {5, 50}; const std::pair kChanceOfAddingAnotherPassToPassLoop = {50, 90}; const std::pair kChanceOfAddingAnotherStructField = {20, 90}; const std::pair kChanceOfAddingArrayOrStructType = {20, 90}; const std::pair KChanceOfAddingAtomicLoad = {30, 90}; const std::pair KChanceOfAddingAtomicStore = {20, 90}; const std::pair kChanceOfAddingBitInstructionSynonym = {5, 20}; const std::pair kChanceOfAddingBothBranchesWhenReplacingOpSelect = {40, 60}; const std::pair kChanceOfAddingCompositeExtract = {20, 50}; const std::pair kChanceOfAddingCompositeInsert = {20, 50}; const std::pair kChanceOfAddingCopyMemory = {20, 50}; const std::pair kChanceOfAddingDeadBlock = {20, 90}; const std::pair kChanceOfAddingDeadBreak = {5, 80}; const std::pair kChanceOfAddingDeadContinue = {5, 80}; const std::pair kChanceOfAddingEquationInstruction = {5, 90}; const std::pair kChanceOfAddingGlobalVariable = {20, 90}; const std::pair kChanceOfAddingImageSampleUnusedComponents = {20, 90}; const std::pair kChanceOfAddingLoad = {5, 50}; const std::pair kChanceOfAddingLocalVariable = {20, 90}; const std::pair kChanceOfAddingLoopPreheader = {20, 90}; const std::pair kChanceOfAddingMatrixType = {20, 70}; const std::pair kChanceOfAddingNoContractionDecoration = { 5, 70}; const std::pair kChanceOfAddingOpPhiSynonym = {5, 70}; const std::pair kChanceOfAddingParameters = {5, 70}; const std::pair kChanceOfAddingRelaxedDecoration = {20, 90}; const std::pair kChanceOfAddingStore = {5, 50}; const std::pair kChanceOfAddingSynonyms = {20, 50}; const std::pair kChanceOfAddingTrueBranchWhenReplacingOpSelect = {40, 60}; const std::pair kChanceOfAddingVectorType = {20, 70}; const std::pair kChanceOfAddingVectorShuffle = {20, 70}; const std::pair kChanceOfAdjustingBranchWeights = {20, 90}; const std::pair kChanceOfAdjustingFunctionControl = {20, 70}; const std::pair kChanceOfAdjustingLoopControl = {20, 90}; const std::pair kChanceOfAdjustingMemoryOperandsMask = {20, 90}; const std::pair kChanceOfAdjustingSelectionControl = {20, 90}; const std::pair kChanceOfCallingFunction = {1, 10}; const std::pair kChanceOfChoosingStructTypeVsArrayType = { 20, 80}; const std::pair kChanceOfChoosingWorkgroupStorageClass = { 50, 50}; const std::pair kChanceOfConstructingComposite = {20, 50}; const std::pair kChanceOfCopyingObject = {20, 50}; const std::pair kChanceOfCreatingIntSynonymsUsingLoops = { 5, 10}; const std::pair kChanceOfDonatingAdditionalModule = {5, 50}; const std::pair kChanceOfDuplicatingRegionWithSelection = { 20, 50}; const std::pair kChanceOfExpandingVectorReduction = {20, 90}; const std::pair kChanceOfFlatteningConditionalBranch = {45, 95}; const std::pair kChanceOfGoingDeeperToExtractComposite = { 30, 70}; const std::pair kChanceOfGoingDeeperToInsertInComposite = { 30, 70}; const std::pair kChanceOfGoingDeeperWhenMakingAccessChain = {50, 95}; const std::pair kChanceOfHavingTwoBlocksInLoopToCreateIntSynonym = {50, 80}; const std::pair kChanceOfInliningFunction = {10, 90}; const std::pair kChanceOfInterchangingZeroLikeConstants = { 10, 90}; const std::pair kChanceOfInterchangingSignednessOfIntegerOperands = {10, 90}; const std::pair kChanceOfInvertingComparisonOperators = { 20, 50}; const std::pair kChanceOfMakingDonorLivesafe = {40, 60}; const std::pair kChanceOfMakingVectorOperationDynamic = { 20, 90}; const std::pair kChanceOfMergingBlocks = {20, 95}; const std::pair kChanceOfMergingFunctionReturns = {20, 90}; const std::pair kChanceOfMovingBlockDown = {20, 50}; const std::pair kChanceOfMutatingPointer = {20, 90}; const std::pair kChanceOfObfuscatingConstant = {10, 90}; const std::pair kChanceOfOutliningFunction = {10, 90}; const std::pair kChanceOfPermutingFunctionVariables = {30, 90}; const std::pair kChanceOfPermutingInstructions = {20, 70}; const std::pair kChanceOfPermutingParameters = {30, 90}; const std::pair kChanceOfPermutingPhiOperands = {30, 90}; const std::pair kChanceOfPropagatingInstructionsDown = {20, 70}; const std::pair kChanceOfPropagatingInstructionsUp = {20, 70}; const std::pair kChanceOfPushingIdThroughVariable = {5, 50}; const std::pair kChanceOfReplacingAddSubMulWithCarryingExtended = {20, 70}; const std::pair kChanceOfReplacingBranchFromDeadBlockWithExit = {10, 65}; const std::pair kChanceOfReplacingCopyMemoryWithLoadStore = {20, 90}; const std::pair kChanceOfReplacingCopyObjectWithStoreLoad = {20, 90}; const std::pair kChanceOfReplacingIdWithSynonym = {10, 90}; const std::pair kChanceOfReplacingIrrelevantId = {35, 95}; const std::pair kChanceOfReplacingLinearAlgebraInstructions = {10, 90}; const std::pair kChanceOfReplacingLoadStoreWithCopyMemory = {20, 90}; const std::pair kChanceOfReplacingOpPhiIdFromDeadPredecessor = {20, 90}; const std::pair kChanceOfReplacingOpSelectWithConditionalBranch = {20, 90}; const std::pair kChanceOfReplacingParametersWithGlobals = { 30, 70}; const std::pair kChanceOfReplacingParametersWithStruct = { 20, 40}; const std::pair kChanceOfSplittingBlock = {40, 95}; const std::pair kChanceOfSwappingAnotherPairOfFunctionVariables = {30, 90}; const std::pair kChanceOfSwappingConditionalBranchOperands = {10, 70}; const std::pair kChanceOfSwappingFunctions = {10, 90}; const std::pair kChanceOfTogglingAccessChainInstruction = { 20, 90}; const std::pair kChanceOfWrappingRegionInSelection = {70, 90}; const std::pair kChanceOfWrappingVectorSynonym = {10, 90}; // Default limits for various quantities that are chosen during fuzzing. // Keep them in alphabetical order. const uint32_t kDefaultMaxEquivalenceClassSizeForDataSynonymFactClosure = 1000; const uint32_t kDefaultMaxLoopControlPartialCount = 100; const uint32_t kDefaultMaxLoopControlPeelCount = 100; const uint32_t kDefaultMaxLoopLimit = 20; const uint32_t kDefaultMaxNewArraySizeLimit = 100; // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/3424): // think whether there is a better limit on the maximum number of parameters. const uint32_t kDefaultMaxNumberOfFunctionParameters = 128; const uint32_t kDefaultMaxNumberOfNewParameters = 15; const uint32_t kGetDefaultMaxNumberOfParametersReplacedWithStruct = 5; // Default functions for controlling how deep to go during recursive // generation/transformation. Keep them in alphabetical order. const std::function kDefaultGoDeeperInConstantObfuscation = [](uint32_t current_depth, RandomGenerator* random_generator) -> bool { double chance = 1.0 / std::pow(3.0, static_cast(current_depth + 1)); return random_generator->RandomDouble() < chance; }; } // namespace FuzzerContext::FuzzerContext(std::unique_ptr random_generator, uint32_t min_fresh_id, bool is_wgsl_compatible) : random_generator_(std::move(random_generator)), next_fresh_id_(min_fresh_id), is_wgsl_compatible_(is_wgsl_compatible), max_equivalence_class_size_for_data_synonym_fact_closure_( kDefaultMaxEquivalenceClassSizeForDataSynonymFactClosure), max_loop_control_partial_count_(kDefaultMaxLoopControlPartialCount), max_loop_control_peel_count_(kDefaultMaxLoopControlPeelCount), max_loop_limit_(kDefaultMaxLoopLimit), max_new_array_size_limit_(kDefaultMaxNewArraySizeLimit), max_number_of_function_parameters_(kDefaultMaxNumberOfFunctionParameters), max_number_of_new_parameters_(kDefaultMaxNumberOfNewParameters), max_number_of_parameters_replaced_with_struct_( kGetDefaultMaxNumberOfParametersReplacedWithStruct), go_deeper_in_constant_obfuscation_( kDefaultGoDeeperInConstantObfuscation) { chance_of_accepting_repeated_pass_recommendation_ = ChooseBetweenMinAndMax(kChanceOfAcceptingRepeatedPassRecommendation); chance_of_adding_access_chain_ = ChooseBetweenMinAndMax(kChanceOfAddingAccessChain); chance_of_adding_another_pass_to_pass_loop_ = ChooseBetweenMinAndMax(kChanceOfAddingAnotherPassToPassLoop); chance_of_adding_another_struct_field_ = ChooseBetweenMinAndMax(kChanceOfAddingAnotherStructField); chance_of_adding_array_or_struct_type_ = ChooseBetweenMinAndMax(kChanceOfAddingArrayOrStructType); chance_of_adding_atomic_load_ = ChooseBetweenMinAndMax(KChanceOfAddingAtomicLoad); chance_of_adding_atomic_store_ = ChooseBetweenMinAndMax(KChanceOfAddingAtomicStore); chance_of_adding_bit_instruction_synonym_ = ChooseBetweenMinAndMax(kChanceOfAddingBitInstructionSynonym); chance_of_adding_both_branches_when_replacing_opselect_ = ChooseBetweenMinAndMax(kChanceOfAddingBothBranchesWhenReplacingOpSelect); chance_of_adding_composite_extract_ = ChooseBetweenMinAndMax(kChanceOfAddingCompositeExtract); chance_of_adding_composite_insert_ = ChooseBetweenMinAndMax(kChanceOfAddingCompositeInsert); chance_of_adding_copy_memory_ = ChooseBetweenMinAndMax(kChanceOfAddingCopyMemory); chance_of_adding_dead_block_ = ChooseBetweenMinAndMax(kChanceOfAddingDeadBlock); chance_of_adding_dead_break_ = ChooseBetweenMinAndMax(kChanceOfAddingDeadBreak); chance_of_adding_dead_continue_ = ChooseBetweenMinAndMax(kChanceOfAddingDeadContinue); chance_of_adding_equation_instruction_ = ChooseBetweenMinAndMax(kChanceOfAddingEquationInstruction); chance_of_adding_global_variable_ = ChooseBetweenMinAndMax(kChanceOfAddingGlobalVariable); chance_of_adding_load_ = ChooseBetweenMinAndMax(kChanceOfAddingLoad); chance_of_adding_loop_preheader_ = ChooseBetweenMinAndMax(kChanceOfAddingLoopPreheader); chance_of_adding_image_sample_unused_components_ = ChooseBetweenMinAndMax(kChanceOfAddingImageSampleUnusedComponents); chance_of_adding_local_variable_ = ChooseBetweenMinAndMax(kChanceOfAddingLocalVariable); chance_of_adding_matrix_type_ = ChooseBetweenMinAndMax(kChanceOfAddingMatrixType); chance_of_adding_no_contraction_decoration_ = ChooseBetweenMinAndMax(kChanceOfAddingNoContractionDecoration); chance_of_adding_opphi_synonym_ = ChooseBetweenMinAndMax(kChanceOfAddingOpPhiSynonym); chance_of_adding_parameters = ChooseBetweenMinAndMax(kChanceOfAddingParameters); chance_of_adding_relaxed_decoration_ = ChooseBetweenMinAndMax(kChanceOfAddingRelaxedDecoration); chance_of_adding_store_ = ChooseBetweenMinAndMax(kChanceOfAddingStore); chance_of_adding_true_branch_when_replacing_opselect_ = ChooseBetweenMinAndMax(kChanceOfAddingTrueBranchWhenReplacingOpSelect); chance_of_adding_vector_shuffle_ = ChooseBetweenMinAndMax(kChanceOfAddingVectorShuffle); chance_of_adding_vector_type_ = ChooseBetweenMinAndMax(kChanceOfAddingVectorType); chance_of_adjusting_branch_weights_ = ChooseBetweenMinAndMax(kChanceOfAdjustingBranchWeights); chance_of_adjusting_function_control_ = ChooseBetweenMinAndMax(kChanceOfAdjustingFunctionControl); chance_of_adding_synonyms_ = ChooseBetweenMinAndMax(kChanceOfAddingSynonyms); chance_of_adjusting_loop_control_ = ChooseBetweenMinAndMax(kChanceOfAdjustingLoopControl); chance_of_adjusting_memory_operands_mask_ = ChooseBetweenMinAndMax(kChanceOfAdjustingMemoryOperandsMask); chance_of_adjusting_selection_control_ = ChooseBetweenMinAndMax(kChanceOfAdjustingSelectionControl); chance_of_calling_function_ = ChooseBetweenMinAndMax(kChanceOfCallingFunction); chance_of_choosing_struct_type_vs_array_type_ = ChooseBetweenMinAndMax(kChanceOfChoosingStructTypeVsArrayType); chance_of_choosing_workgroup_storage_class_ = ChooseBetweenMinAndMax(kChanceOfChoosingWorkgroupStorageClass); chance_of_constructing_composite_ = ChooseBetweenMinAndMax(kChanceOfConstructingComposite); chance_of_copying_object_ = ChooseBetweenMinAndMax(kChanceOfCopyingObject); chance_of_creating_int_synonyms_using_loops_ = ChooseBetweenMinAndMax(kChanceOfCreatingIntSynonymsUsingLoops); chance_of_donating_additional_module_ = ChooseBetweenMinAndMax(kChanceOfDonatingAdditionalModule); chance_of_duplicating_region_with_selection_ = ChooseBetweenMinAndMax(kChanceOfDuplicatingRegionWithSelection); chance_of_expanding_vector_reduction_ = ChooseBetweenMinAndMax(kChanceOfExpandingVectorReduction); chance_of_flattening_conditional_branch_ = ChooseBetweenMinAndMax(kChanceOfFlatteningConditionalBranch); chance_of_going_deeper_to_extract_composite_ = ChooseBetweenMinAndMax(kChanceOfGoingDeeperToExtractComposite); chance_of_going_deeper_to_insert_in_composite_ = ChooseBetweenMinAndMax(kChanceOfGoingDeeperToInsertInComposite); chance_of_going_deeper_when_making_access_chain_ = ChooseBetweenMinAndMax(kChanceOfGoingDeeperWhenMakingAccessChain); chance_of_having_two_blocks_in_loop_to_create_int_synonym_ = ChooseBetweenMinAndMax(kChanceOfHavingTwoBlocksInLoopToCreateIntSynonym); chance_of_inlining_function_ = ChooseBetweenMinAndMax(kChanceOfInliningFunction); chance_of_interchanging_signedness_of_integer_operands_ = ChooseBetweenMinAndMax(kChanceOfInterchangingSignednessOfIntegerOperands); chance_of_interchanging_zero_like_constants_ = ChooseBetweenMinAndMax(kChanceOfInterchangingZeroLikeConstants); chance_of_inverting_comparison_operators_ = ChooseBetweenMinAndMax(kChanceOfInvertingComparisonOperators); chance_of_making_donor_livesafe_ = ChooseBetweenMinAndMax(kChanceOfMakingDonorLivesafe); chance_of_making_vector_operation_dynamic_ = ChooseBetweenMinAndMax(kChanceOfMakingVectorOperationDynamic); chance_of_merging_blocks_ = ChooseBetweenMinAndMax(kChanceOfMergingBlocks); chance_of_merging_function_returns_ = ChooseBetweenMinAndMax(kChanceOfMergingFunctionReturns); chance_of_moving_block_down_ = ChooseBetweenMinAndMax(kChanceOfMovingBlockDown); chance_of_mutating_pointer_ = ChooseBetweenMinAndMax(kChanceOfMutatingPointer); chance_of_obfuscating_constant_ = ChooseBetweenMinAndMax(kChanceOfObfuscatingConstant); chance_of_outlining_function_ = ChooseBetweenMinAndMax(kChanceOfOutliningFunction); chance_of_permuting_function_variables_ = ChooseBetweenMinAndMax(kChanceOfPermutingFunctionVariables); chance_of_permuting_instructions_ = ChooseBetweenMinAndMax(kChanceOfPermutingInstructions); chance_of_permuting_parameters_ = ChooseBetweenMinAndMax(kChanceOfPermutingParameters); chance_of_permuting_phi_operands_ = ChooseBetweenMinAndMax(kChanceOfPermutingPhiOperands); chance_of_propagating_instructions_down_ = ChooseBetweenMinAndMax(kChanceOfPropagatingInstructionsDown); chance_of_propagating_instructions_up_ = ChooseBetweenMinAndMax(kChanceOfPropagatingInstructionsUp); chance_of_pushing_id_through_variable_ = ChooseBetweenMinAndMax(kChanceOfPushingIdThroughVariable); chance_of_replacing_add_sub_mul_with_carrying_extended_ = ChooseBetweenMinAndMax(kChanceOfReplacingAddSubMulWithCarryingExtended); chance_of_replacing_branch_from_dead_block_with_exit_ = ChooseBetweenMinAndMax(kChanceOfReplacingBranchFromDeadBlockWithExit); chance_of_replacing_copy_memory_with_load_store_ = ChooseBetweenMinAndMax(kChanceOfReplacingCopyMemoryWithLoadStore); chance_of_replacing_copyobject_with_store_load_ = ChooseBetweenMinAndMax(kChanceOfReplacingCopyObjectWithStoreLoad); chance_of_replacing_id_with_synonym_ = ChooseBetweenMinAndMax(kChanceOfReplacingIdWithSynonym); chance_of_replacing_irrelevant_id_ = ChooseBetweenMinAndMax(kChanceOfReplacingIrrelevantId); chance_of_replacing_linear_algebra_instructions_ = ChooseBetweenMinAndMax(kChanceOfReplacingLinearAlgebraInstructions); chance_of_replacing_load_store_with_copy_memory_ = ChooseBetweenMinAndMax(kChanceOfReplacingLoadStoreWithCopyMemory); chance_of_replacing_opphi_id_from_dead_predecessor_ = ChooseBetweenMinAndMax(kChanceOfReplacingOpPhiIdFromDeadPredecessor); chance_of_replacing_opselect_with_conditional_branch_ = ChooseBetweenMinAndMax(kChanceOfReplacingOpSelectWithConditionalBranch); chance_of_replacing_parameters_with_globals_ = ChooseBetweenMinAndMax(kChanceOfReplacingParametersWithGlobals); chance_of_replacing_parameters_with_struct_ = ChooseBetweenMinAndMax(kChanceOfReplacingParametersWithStruct); chance_of_splitting_block_ = ChooseBetweenMinAndMax(kChanceOfSplittingBlock); chance_of_swapping_another_pair_of_function_variables_ = ChooseBetweenMinAndMax(kChanceOfSwappingAnotherPairOfFunctionVariables); chance_of_swapping_conditional_branch_operands_ = ChooseBetweenMinAndMax(kChanceOfSwappingConditionalBranchOperands); chance_of_swapping_functions_ = ChooseBetweenMinAndMax(kChanceOfSwappingFunctions); chance_of_toggling_access_chain_instruction_ = ChooseBetweenMinAndMax(kChanceOfTogglingAccessChainInstruction); chance_of_wrapping_region_in_selection_ = ChooseBetweenMinAndMax(kChanceOfWrappingRegionInSelection); chance_of_wrapping_vector_synonym_ = ChooseBetweenMinAndMax(kChanceOfWrappingVectorSynonym); } FuzzerContext::~FuzzerContext() = default; uint32_t FuzzerContext::GetFreshId() { return next_fresh_id_++; } std::vector FuzzerContext::GetFreshIds(const uint32_t count) { std::vector fresh_ids(count); for (uint32_t& fresh_id : fresh_ids) { fresh_id = next_fresh_id_++; } return fresh_ids; } bool FuzzerContext::ChooseEven() { return random_generator_->RandomBool(); } bool FuzzerContext::ChoosePercentage(uint32_t percentage_chance) { assert(percentage_chance <= 100); return random_generator_->RandomPercentage() < percentage_chance; } uint32_t FuzzerContext::ChooseBetweenMinAndMax( const std::pair& min_max) { assert(min_max.first <= min_max.second); return min_max.first + random_generator_->RandomUint32(min_max.second - min_max.first + 1); } protobufs::TransformationAddSynonym::SynonymType FuzzerContext::GetRandomSynonymType() { // value_count method is guaranteed to return a value greater than 0. auto result_index = ChooseBetweenMinAndMax( {0, static_cast( protobufs::TransformationAddSynonym::SynonymType_descriptor() ->value_count() - 1)}); auto result = protobufs::TransformationAddSynonym::SynonymType_descriptor() ->value(result_index) ->number(); assert(protobufs::TransformationAddSynonym::SynonymType_IsValid(result) && "|result| is not a value of SynonymType"); return static_cast(result); } uint32_t FuzzerContext::GetIdBoundLimit() const { return kIdBoundLimit; } uint32_t FuzzerContext::GetTransformationLimit() const { return kTransformationLimit; } uint32_t FuzzerContext::GetMinFreshId(opt::IRContext* ir_context) { return ir_context->module()->id_bound() + kIdBoundGap; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_context.h000066400000000000000000000572221475742701700243010ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_CONTEXT_H_ #define SOURCE_FUZZ_FUZZER_CONTEXT_H_ #include #include #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/random_generator.h" #include "source/opt/function.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { // Encapsulates all parameters that control the fuzzing process, such as the // source of randomness and the probabilities with which transformations are // applied. class FuzzerContext { public: // Constructs a fuzzer context with a given random generator and the minimum // value that can be used for fresh ids. FuzzerContext(std::unique_ptr random_generator, uint32_t min_fresh_id, bool is_wgsl_compatible); ~FuzzerContext(); // Returns a random boolean. bool ChooseEven(); // Returns true if and only if a randomly-chosen integer in the range [0, 100] // is less than |percentage_chance|. bool ChoosePercentage(uint32_t percentage_chance); // Returns a random index into |sequence|, which is expected to have a 'size' // method, and which must be non-empty. Typically 'HasSizeMethod' will be an // std::vector. template uint32_t RandomIndex(const HasSizeMethod& sequence) const { assert(sequence.size() > 0); return random_generator_->RandomUint32( static_cast(sequence.size())); } // Selects a random index into |sequence|, removes the element at that index // and returns it. template T RemoveAtRandomIndex(std::vector* sequence) const { uint32_t index = RandomIndex(*sequence); T result = sequence->at(index); sequence->erase(sequence->begin() + index); return result; } // Randomly shuffles a |sequence| between |lo| and |hi| indices inclusively. // |lo| and |hi| must be valid indices to the |sequence|. template void Shuffle(std::vector* sequence, size_t lo, size_t hi) const { auto& array = *sequence; if (array.empty()) { return; } assert(lo <= hi && hi < array.size() && "lo and/or hi indices are invalid"); // i > lo to account for potential infinite loop when lo == 0 for (size_t i = hi; i > lo; --i) { auto index = random_generator_->RandomUint32(static_cast(i - lo + 1)); if (lo + index != i) { // Introduce std::swap to the scope but don't use it // directly since there might be a better overload using std::swap; swap(array[lo + index], array[i]); } } } // Randomly shuffles a |sequence|. template void Shuffle(std::vector* sequence) const { if (!sequence->empty()) { Shuffle(sequence, 0, sequence->size() - 1); } } // Yields an id that is guaranteed not to be used in the module being fuzzed, // or to have been issued before. uint32_t GetFreshId(); // Returns a vector of |count| fresh ids. std::vector GetFreshIds(uint32_t count); // A suggested limit on the id bound for the module being fuzzed. This is // useful for deciding when to stop the overall fuzzing process. Furthermore, // fuzzer passes that run the risk of spiralling out of control can // periodically check this limit and terminate early if it has been reached. uint32_t GetIdBoundLimit() const; // A suggested limit on the number of transformations that should be applied. // Also useful to control the overall fuzzing process and rein in individual // fuzzer passes. uint32_t GetTransformationLimit() const; // Returns the minimum fresh id that can be used given the |ir_context|. static uint32_t GetMinFreshId(opt::IRContext* ir_context); // Returns true if all transformations should be compatible with WGSL. bool IsWgslCompatible() const { return is_wgsl_compatible_; } // Probabilities associated with applying various transformations. // Keep them in alphabetical order. uint32_t GetChanceOfAcceptingRepeatedPassRecommendation() const { return chance_of_accepting_repeated_pass_recommendation_; } uint32_t GetChanceOfAddingAccessChain() const { return chance_of_adding_access_chain_; } uint32_t GetChanceOfAddingAnotherPassToPassLoop() const { return chance_of_adding_another_pass_to_pass_loop_; } uint32_t GetChanceOfAddingAnotherStructField() const { return chance_of_adding_another_struct_field_; } uint32_t GetChanceOfAddingArrayOrStructType() const { return chance_of_adding_array_or_struct_type_; } uint32_t GetChanceOfAddingAtomicLoad() const { return chance_of_adding_atomic_load_; } uint32_t GetChanceOfAddingAtomicStore() const { return chance_of_adding_atomic_store_; } uint32_t GetChanceOfAddingBitInstructionSynonym() const { return chance_of_adding_bit_instruction_synonym_; } uint32_t GetChanceOfAddingBothBranchesWhenReplacingOpSelect() const { return chance_of_adding_both_branches_when_replacing_opselect_; } uint32_t GetChanceOfAddingCompositeExtract() const { return chance_of_adding_composite_extract_; } uint32_t GetChanceOfAddingCompositeInsert() const { return chance_of_adding_composite_insert_; } uint32_t GetChanceOfAddingCopyMemory() const { return chance_of_adding_copy_memory_; } uint32_t GetChanceOfAddingDeadBlock() const { return chance_of_adding_dead_block_; } uint32_t GetChanceOfAddingDeadBreak() const { return chance_of_adding_dead_break_; } uint32_t GetChanceOfAddingDeadContinue() const { return chance_of_adding_dead_continue_; } uint32_t GetChanceOfAddingEquationInstruction() const { return chance_of_adding_equation_instruction_; } uint32_t GetChanceOfAddingGlobalVariable() const { return chance_of_adding_global_variable_; } uint32_t GetChanceOfAddingImageSampleUnusedComponents() const { return chance_of_adding_image_sample_unused_components_; } uint32_t GetChanceOfAddingLoad() const { return chance_of_adding_load_; } uint32_t GetChanceOfAddingLocalVariable() const { return chance_of_adding_local_variable_; } uint32_t GetChanceOfAddingLoopPreheader() const { return chance_of_adding_loop_preheader_; } uint32_t GetChanceOfAddingMatrixType() const { return chance_of_adding_matrix_type_; } uint32_t GetChanceOfAddingNoContractionDecoration() const { return chance_of_adding_no_contraction_decoration_; } uint32_t GetChanceOfAddingOpPhiSynonym() const { return chance_of_adding_opphi_synonym_; } uint32_t GetChanceOfAddingParameters() const { return chance_of_adding_parameters; } uint32_t GetChanceOfAddingRelaxedDecoration() const { return chance_of_adding_relaxed_decoration_; } uint32_t GetChanceOfAddingStore() const { return chance_of_adding_store_; } uint32_t GetChanceOfAddingSynonyms() const { return chance_of_adding_synonyms_; } uint32_t GetChanceOfAddingTrueBranchWhenReplacingOpSelect() const { return chance_of_adding_true_branch_when_replacing_opselect_; } uint32_t GetChanceOfAddingVectorShuffle() const { return chance_of_adding_vector_shuffle_; } uint32_t GetChanceOfAddingVectorType() const { return chance_of_adding_vector_type_; } uint32_t GetChanceOfAdjustingBranchWeights() const { return chance_of_adjusting_branch_weights_; } uint32_t GetChanceOfAdjustingFunctionControl() const { return chance_of_adjusting_function_control_; } uint32_t GetChanceOfAdjustingLoopControl() const { return chance_of_adjusting_loop_control_; } uint32_t GetChanceOfAdjustingMemoryOperandsMask() const { return chance_of_adjusting_memory_operands_mask_; } uint32_t GetChanceOfAdjustingSelectionControl() const { return chance_of_adjusting_selection_control_; } uint32_t GetChanceOfCallingFunction() const { return chance_of_calling_function_; } uint32_t GetChanceOfChoosingStructTypeVsArrayType() const { return chance_of_choosing_struct_type_vs_array_type_; } uint32_t GetChanceOfChoosingWorkgroupStorageClass() const { return chance_of_choosing_workgroup_storage_class_; } uint32_t GetChanceOfConstructingComposite() const { return chance_of_constructing_composite_; } uint32_t GetChanceOfCopyingObject() const { return chance_of_copying_object_; } uint32_t GetChanceOfCreatingIntSynonymsUsingLoops() const { return chance_of_creating_int_synonyms_using_loops_; } uint32_t GetChanceOfDonatingAdditionalModule() const { return chance_of_donating_additional_module_; } uint32_t GetChanceOfDuplicatingRegionWithSelection() const { return chance_of_duplicating_region_with_selection_; } uint32_t GetChanceOfExpandingVectorReduction() const { return chance_of_expanding_vector_reduction_; } uint32_t GetChanceOfFlatteningConditionalBranch() const { return chance_of_flattening_conditional_branch_; } uint32_t GetChanceOfGoingDeeperToExtractComposite() const { return chance_of_going_deeper_to_extract_composite_; } uint32_t GetChanceOfGoingDeeperToInsertInComposite() const { return chance_of_going_deeper_to_insert_in_composite_; } uint32_t GetChanceOfGoingDeeperWhenMakingAccessChain() const { return chance_of_going_deeper_when_making_access_chain_; } uint32_t GetChanceOfHavingTwoBlocksInLoopToCreateIntSynonym() const { return chance_of_having_two_blocks_in_loop_to_create_int_synonym_; } uint32_t GetChanceOfInliningFunction() const { return chance_of_inlining_function_; } uint32_t GetChanceOfInterchangingSignednessOfIntegerOperands() const { return chance_of_interchanging_signedness_of_integer_operands_; } uint32_t GetChanceOfInterchangingZeroLikeConstants() const { return chance_of_interchanging_zero_like_constants_; } uint32_t GetChanceOfInvertingComparisonOperators() const { return chance_of_inverting_comparison_operators_; } uint32_t ChanceOfMakingDonorLivesafe() const { return chance_of_making_donor_livesafe_; } uint32_t GetChanceOfMakingVectorOperationDynamic() const { return chance_of_making_vector_operation_dynamic_; } uint32_t GetChanceOfMergingBlocks() const { return chance_of_merging_blocks_; } uint32_t GetChanceOfMergingFunctionReturns() const { return chance_of_merging_function_returns_; } uint32_t GetChanceOfMovingBlockDown() const { return chance_of_moving_block_down_; } uint32_t GetChanceOfMutatingPointer() const { return chance_of_mutating_pointer_; } uint32_t GetChanceOfObfuscatingConstant() const { return chance_of_obfuscating_constant_; } uint32_t GetChanceOfOutliningFunction() const { return chance_of_outlining_function_; } uint32_t GetChanceOfPermutingFunctionVariables() const { return chance_of_permuting_function_variables_; } uint32_t GetChanceOfPermutingInstructions() const { return chance_of_permuting_instructions_; } uint32_t GetChanceOfPermutingParameters() const { return chance_of_permuting_parameters_; } uint32_t GetChanceOfPermutingPhiOperands() const { return chance_of_permuting_phi_operands_; } uint32_t GetChanceOfPropagatingInstructionsDown() const { return chance_of_propagating_instructions_down_; } uint32_t GetChanceOfPropagatingInstructionsUp() const { return chance_of_propagating_instructions_up_; } uint32_t GetChanceOfPushingIdThroughVariable() const { return chance_of_pushing_id_through_variable_; } uint32_t GetChanceOfReplacingAddSubMulWithCarryingExtended() const { return chance_of_replacing_add_sub_mul_with_carrying_extended_; } uint32_t GetChanceOfReplacingBranchFromDeadBlockWithExit() const { return chance_of_replacing_branch_from_dead_block_with_exit_; } uint32_t GetChanceOfReplacingCopyMemoryWithLoadStore() const { return chance_of_replacing_copy_memory_with_load_store_; } uint32_t GetChanceOfReplacingCopyObjectWithStoreLoad() const { return chance_of_replacing_copyobject_with_store_load_; } uint32_t GetChanceOfReplacingIdWithSynonym() const { return chance_of_replacing_id_with_synonym_; } uint32_t GetChanceOfReplacingIrrelevantId() const { return chance_of_replacing_irrelevant_id_; } uint32_t GetChanceOfReplacingLinearAlgebraInstructions() const { return chance_of_replacing_linear_algebra_instructions_; } uint32_t GetChanceOfReplacingLoadStoreWithCopyMemory() const { return chance_of_replacing_load_store_with_copy_memory_; } uint32_t GetChanceOfReplacingOpPhiIdFromDeadPredecessor() const { return chance_of_replacing_opphi_id_from_dead_predecessor_; } uint32_t GetChanceOfReplacingOpselectWithConditionalBranch() const { return chance_of_replacing_opselect_with_conditional_branch_; } uint32_t GetChanceOfReplacingParametersWithGlobals() const { return chance_of_replacing_parameters_with_globals_; } uint32_t GetChanceOfReplacingParametersWithStruct() const { return chance_of_replacing_parameters_with_struct_; } uint32_t GetChanceOfSplittingBlock() const { return chance_of_splitting_block_; } uint32_t GetChanceOfSwappingAnotherPairOfFunctionVariables() const { return chance_of_swapping_another_pair_of_function_variables_; } uint32_t GetChanceOfSwappingConditionalBranchOperands() const { return chance_of_swapping_conditional_branch_operands_; } uint32_t GetChanceOfSwappingFunctions() const { return chance_of_swapping_functions_; } uint32_t GetChanceOfTogglingAccessChainInstruction() const { return chance_of_toggling_access_chain_instruction_; } uint32_t GetChanceOfWrappingRegionInSelection() const { return chance_of_wrapping_region_in_selection_; } uint32_t GetChanceOfWrappingVectorSynonym() const { return chance_of_wrapping_vector_synonym_; } // Other functions to control transformations. Keep them in alphabetical // order. uint32_t GetMaximumEquivalenceClassSizeForDataSynonymFactClosure() const { return max_equivalence_class_size_for_data_synonym_fact_closure_; } uint32_t GetMaximumNumberOfFunctionParameters() const { return max_number_of_function_parameters_; } uint32_t GetMaximumNumberOfParametersReplacedWithStruct() const { return max_number_of_parameters_replaced_with_struct_; } std::pair GetRandomBranchWeights() { std::pair branch_weights = {0, 0}; while (branch_weights.first == 0 && branch_weights.second == 0) { // Using INT32_MAX to do not overflow UINT32_MAX when the branch weights // are added together. branch_weights.first = random_generator_->RandomUint32(INT32_MAX); branch_weights.second = random_generator_->RandomUint32(INT32_MAX); } return branch_weights; } std::vector GetRandomComponentsForVectorShuffle( uint32_t max_component_index) { // Component count must be in range [2, 4]. std::vector components(random_generator_->RandomUint32(2) + 2); for (uint32_t& component : components) { component = random_generator_->RandomUint32(max_component_index); } return components; } uint32_t GetRandomCompositeExtractIndex(uint32_t number_of_members) { assert(number_of_members > 0 && "Composite object must have some members"); return ChooseBetweenMinAndMax({0, number_of_members - 1}); } uint32_t GetRandomIndexForAccessChain(uint32_t composite_size_bound) { return random_generator_->RandomUint32(composite_size_bound); } uint32_t GetRandomIndexForCompositeInsert(uint32_t number_of_components) { return random_generator_->RandomUint32(number_of_components); } uint32_t GetRandomIndexForWrappingVector(uint32_t vector_width) { return random_generator_->RandomUint32(vector_width); } int64_t GetRandomValueForStepConstantInLoop() { return random_generator_->RandomUint64(UINT64_MAX); } uint32_t GetRandomLoopControlPartialCount() { return random_generator_->RandomUint32(max_loop_control_partial_count_); } uint32_t GetRandomLoopControlPeelCount() { return random_generator_->RandomUint32(max_loop_control_peel_count_); } uint32_t GetRandomLoopLimit() { return random_generator_->RandomUint32(max_loop_limit_); } uint32_t GetRandomNumberOfLoopIterations(uint32_t max_num_iterations) { return ChooseBetweenMinAndMax({1, max_num_iterations}); } uint32_t GetRandomNumberOfNewParameters(uint32_t num_of_params) { assert(num_of_params < GetMaximumNumberOfFunctionParameters()); return ChooseBetweenMinAndMax( {1, std::min(max_number_of_new_parameters_, GetMaximumNumberOfFunctionParameters() - num_of_params)}); } uint32_t GetRandomNumberOfParametersReplacedWithStruct(uint32_t num_params) { assert(num_params != 0 && "A function must have parameters to replace"); return ChooseBetweenMinAndMax( {1, std::min(num_params, GetMaximumNumberOfParametersReplacedWithStruct())}); } uint32_t GetRandomSizeForNewArray() { // Ensure that the array size is non-zero. return random_generator_->RandomUint32(max_new_array_size_limit_ - 1) + 1; } protobufs::TransformationAddSynonym::SynonymType GetRandomSynonymType(); uint32_t GetRandomUnusedComponentCountForImageSample( uint32_t max_unused_component_count) { // Ensure that the number of unused components is non-zero. return random_generator_->RandomUint32(max_unused_component_count) + 1; } uint32_t GetWidthOfWrappingVector() { return 2 + random_generator_->RandomUint32(3); } bool GoDeeperInConstantObfuscation(uint32_t depth) { return go_deeper_in_constant_obfuscation_(depth, random_generator_.get()); } private: // The source of randomness. std::unique_ptr random_generator_; // The next fresh id to be issued. uint32_t next_fresh_id_; // True if all transformations should be compatible with WGSL spec. bool is_wgsl_compatible_; // Probabilities associated with applying various transformations. // Keep them in alphabetical order. uint32_t chance_of_accepting_repeated_pass_recommendation_; uint32_t chance_of_adding_access_chain_; uint32_t chance_of_adding_another_pass_to_pass_loop_; uint32_t chance_of_adding_another_struct_field_; uint32_t chance_of_adding_array_or_struct_type_; uint32_t chance_of_adding_atomic_load_; uint32_t chance_of_adding_atomic_store_; uint32_t chance_of_adding_bit_instruction_synonym_; uint32_t chance_of_adding_both_branches_when_replacing_opselect_; uint32_t chance_of_adding_composite_extract_; uint32_t chance_of_adding_composite_insert_; uint32_t chance_of_adding_copy_memory_; uint32_t chance_of_adding_dead_block_; uint32_t chance_of_adding_dead_break_; uint32_t chance_of_adding_dead_continue_; uint32_t chance_of_adding_equation_instruction_; uint32_t chance_of_adding_global_variable_; uint32_t chance_of_adding_image_sample_unused_components_; uint32_t chance_of_adding_load_; uint32_t chance_of_adding_local_variable_; uint32_t chance_of_adding_loop_preheader_; uint32_t chance_of_adding_matrix_type_; uint32_t chance_of_adding_no_contraction_decoration_; uint32_t chance_of_adding_opphi_synonym_; uint32_t chance_of_adding_parameters; uint32_t chance_of_adding_relaxed_decoration_; uint32_t chance_of_adding_store_; uint32_t chance_of_adding_synonyms_; uint32_t chance_of_adding_true_branch_when_replacing_opselect_; uint32_t chance_of_adding_vector_shuffle_; uint32_t chance_of_adding_vector_type_; uint32_t chance_of_adjusting_branch_weights_; uint32_t chance_of_adjusting_function_control_; uint32_t chance_of_adjusting_loop_control_; uint32_t chance_of_adjusting_memory_operands_mask_; uint32_t chance_of_adjusting_selection_control_; uint32_t chance_of_calling_function_; uint32_t chance_of_choosing_struct_type_vs_array_type_; uint32_t chance_of_choosing_workgroup_storage_class_; uint32_t chance_of_constructing_composite_; uint32_t chance_of_copying_object_; uint32_t chance_of_creating_int_synonyms_using_loops_; uint32_t chance_of_donating_additional_module_; uint32_t chance_of_duplicating_region_with_selection_; uint32_t chance_of_expanding_vector_reduction_; uint32_t chance_of_flattening_conditional_branch_; uint32_t chance_of_going_deeper_to_extract_composite_; uint32_t chance_of_going_deeper_to_insert_in_composite_; uint32_t chance_of_going_deeper_when_making_access_chain_; uint32_t chance_of_having_two_blocks_in_loop_to_create_int_synonym_; uint32_t chance_of_inlining_function_; uint32_t chance_of_interchanging_signedness_of_integer_operands_; uint32_t chance_of_interchanging_zero_like_constants_; uint32_t chance_of_inverting_comparison_operators_; uint32_t chance_of_making_donor_livesafe_; uint32_t chance_of_making_vector_operation_dynamic_; uint32_t chance_of_merging_blocks_; uint32_t chance_of_merging_function_returns_; uint32_t chance_of_moving_block_down_; uint32_t chance_of_mutating_pointer_; uint32_t chance_of_obfuscating_constant_; uint32_t chance_of_outlining_function_; uint32_t chance_of_permuting_function_variables_; uint32_t chance_of_permuting_instructions_; uint32_t chance_of_permuting_parameters_; uint32_t chance_of_permuting_phi_operands_; uint32_t chance_of_propagating_instructions_down_; uint32_t chance_of_propagating_instructions_up_; uint32_t chance_of_pushing_id_through_variable_; uint32_t chance_of_replacing_add_sub_mul_with_carrying_extended_; uint32_t chance_of_replacing_branch_from_dead_block_with_exit_; uint32_t chance_of_replacing_copy_memory_with_load_store_; uint32_t chance_of_replacing_copyobject_with_store_load_; uint32_t chance_of_replacing_id_with_synonym_; uint32_t chance_of_replacing_irrelevant_id_; uint32_t chance_of_replacing_linear_algebra_instructions_; uint32_t chance_of_replacing_load_store_with_copy_memory_; uint32_t chance_of_replacing_opphi_id_from_dead_predecessor_; uint32_t chance_of_replacing_opselect_with_conditional_branch_; uint32_t chance_of_replacing_parameters_with_globals_; uint32_t chance_of_replacing_parameters_with_struct_; uint32_t chance_of_splitting_block_; uint32_t chance_of_swapping_another_pair_of_function_variables_; uint32_t chance_of_swapping_conditional_branch_operands_; uint32_t chance_of_swapping_functions_; uint32_t chance_of_toggling_access_chain_instruction_; uint32_t chance_of_wrapping_region_in_selection_; uint32_t chance_of_wrapping_vector_synonym_; // Limits associated with various quantities for which random values are // chosen during fuzzing. // Keep them in alphabetical order. uint32_t max_equivalence_class_size_for_data_synonym_fact_closure_; uint32_t max_loop_control_partial_count_; uint32_t max_loop_control_peel_count_; uint32_t max_loop_limit_; uint32_t max_new_array_size_limit_; uint32_t max_number_of_function_parameters_; uint32_t max_number_of_new_parameters_; uint32_t max_number_of_parameters_replaced_with_struct_; // Functions to determine with what probability to go deeper when generating // or mutating constructs recursively. const std::function& go_deeper_in_constant_obfuscation_; // Requires |min_max.first| <= |min_max.second|, and returns a value in the // range [ |min_max.first|, |min_max.second| ] uint32_t ChooseBetweenMinAndMax(const std::pair& min_max); }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_CONTEXT_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass.cpp000066400000000000000000000766561475742701700241320ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass.h" #include #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/id_use_descriptor.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/transformation_add_constant_boolean.h" #include "source/fuzz/transformation_add_constant_composite.h" #include "source/fuzz/transformation_add_constant_null.h" #include "source/fuzz/transformation_add_constant_scalar.h" #include "source/fuzz/transformation_add_global_undef.h" #include "source/fuzz/transformation_add_global_variable.h" #include "source/fuzz/transformation_add_local_variable.h" #include "source/fuzz/transformation_add_loop_preheader.h" #include "source/fuzz/transformation_add_type_boolean.h" #include "source/fuzz/transformation_add_type_float.h" #include "source/fuzz/transformation_add_type_function.h" #include "source/fuzz/transformation_add_type_int.h" #include "source/fuzz/transformation_add_type_matrix.h" #include "source/fuzz/transformation_add_type_pointer.h" #include "source/fuzz/transformation_add_type_struct.h" #include "source/fuzz/transformation_add_type_vector.h" #include "source/fuzz/transformation_split_block.h" namespace spvtools { namespace fuzz { FuzzerPass::FuzzerPass(opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : ir_context_(ir_context), transformation_context_(transformation_context), fuzzer_context_(fuzzer_context), transformations_(transformations), ignore_inapplicable_transformations_( ignore_inapplicable_transformations) {} FuzzerPass::~FuzzerPass() = default; std::vector FuzzerPass::FindAvailableInstructions( opt::Function* function, opt::BasicBlock* block, const opt::BasicBlock::iterator& inst_it, std::function instruction_is_relevant) const { // TODO(afd) The following is (relatively) simple, but may end up being // prohibitively inefficient, as it walks the whole dominator tree for // every instruction that is considered. std::vector result; // Consider all global declarations for (auto& global : GetIRContext()->module()->types_values()) { if (instruction_is_relevant(GetIRContext(), &global)) { result.push_back(&global); } } // Consider all function parameters function->ForEachParam( [this, &instruction_is_relevant, &result](opt::Instruction* param) { if (instruction_is_relevant(GetIRContext(), param)) { result.push_back(param); } }); // Consider all previous instructions in this block for (auto prev_inst_it = block->begin(); prev_inst_it != inst_it; ++prev_inst_it) { if (instruction_is_relevant(GetIRContext(), &*prev_inst_it)) { result.push_back(&*prev_inst_it); } } // Walk the dominator tree to consider all instructions from dominating // blocks auto dominator_analysis = GetIRContext()->GetDominatorAnalysis(function); for (auto next_dominator = dominator_analysis->ImmediateDominator(block); next_dominator != nullptr; next_dominator = dominator_analysis->ImmediateDominator(next_dominator)) { for (auto& dominating_inst : *next_dominator) { if (instruction_is_relevant(GetIRContext(), &dominating_inst)) { result.push_back(&dominating_inst); } } } return result; } void FuzzerPass::ForEachInstructionWithInstructionDescriptor( opt::Function* function, std::function< void(opt::BasicBlock* block, opt::BasicBlock::iterator inst_it, const protobufs::InstructionDescriptor& instruction_descriptor)> action) { // Consider only reachable blocks. We do this in a separate loop to avoid // recomputing the dominator analysis every time |action| changes the // module. std::vector reachable_blocks; for (auto& block : *function) { if (GetIRContext()->IsReachable(block)) { reachable_blocks.push_back(&block); } } for (auto* block : reachable_blocks) { // We now consider every instruction in the block, randomly deciding // whether to apply a transformation before it. // In order for transformations to insert new instructions, they need to // be able to identify the instruction to insert before. We describe an // instruction via its opcode, 'opc', a base instruction 'base' that has a // result id, and the number of instructions with opcode 'opc' that we // should skip when searching from 'base' for the desired instruction. // (An instruction that has a result id is represented by its own opcode, // itself as 'base', and a skip-count of 0.) std::vector> base_opcode_skip_triples; // The initial base instruction is the block label. uint32_t base = block->id(); // Counts the number of times we have seen each opcode since we reset the // base instruction. std::map skip_count; // Consider every instruction in the block. The label is excluded: it is // only necessary to consider it as a base in case the first instruction // in the block does not have a result id. for (auto inst_it = block->begin(); inst_it != block->end(); ++inst_it) { if (inst_it->HasResultId()) { // In the case that the instruction has a result id, we use the // instruction as its own base, and clear the skip counts we have // collected. base = inst_it->result_id(); skip_count.clear(); } const spv::Op opcode = inst_it->opcode(); // Invoke the provided function, which might apply a transformation. action(block, inst_it, MakeInstructionDescriptor( base, opcode, skip_count.count(opcode) ? skip_count.at(opcode) : 0)); if (!inst_it->HasResultId()) { skip_count[opcode] = skip_count.count(opcode) ? skip_count.at(opcode) + 1 : 1; } } } } void FuzzerPass::ForEachInstructionWithInstructionDescriptor( std::function< void(opt::Function* function, opt::BasicBlock* block, opt::BasicBlock::iterator inst_it, const protobufs::InstructionDescriptor& instruction_descriptor)> action) { // Consider every block in every function. for (auto& function : *GetIRContext()->module()) { ForEachInstructionWithInstructionDescriptor( &function, [&action, &function]( opt::BasicBlock* block, opt::BasicBlock::iterator inst_it, const protobufs::InstructionDescriptor& instruction_descriptor) { action(&function, block, inst_it, instruction_descriptor); }); } } void FuzzerPass::ApplyTransformation(const Transformation& transformation) { if (ignore_inapplicable_transformations_) { // If an applicable-by-construction transformation turns out to be // inapplicable, this is a bug in the fuzzer. However, when deploying the // fuzzer at scale for finding bugs in SPIR-V processing tools it is // desirable to silently ignore such bugs. This code path caters for that // scenario. if (!transformation.IsApplicable(GetIRContext(), *GetTransformationContext())) { return; } } else { // This code path caters for debugging bugs in the fuzzer, where an // applicable-by-construction transformation turns out to be inapplicable. assert(transformation.IsApplicable(GetIRContext(), *GetTransformationContext()) && "Transformation should be applicable by construction."); } transformation.Apply(GetIRContext(), GetTransformationContext()); auto transformation_message = transformation.ToMessage(); assert(transformation_message.transformation_case() != protobufs::Transformation::TRANSFORMATION_NOT_SET && "Bad transformation."); *GetTransformations()->add_transformation() = std::move(transformation_message); } bool FuzzerPass::MaybeApplyTransformation( const Transformation& transformation) { if (transformation.IsApplicable(GetIRContext(), *GetTransformationContext())) { transformation.Apply(GetIRContext(), GetTransformationContext()); auto transformation_message = transformation.ToMessage(); assert(transformation_message.transformation_case() != protobufs::Transformation::TRANSFORMATION_NOT_SET && "Bad transformation."); *GetTransformations()->add_transformation() = std::move(transformation_message); return true; } return false; } uint32_t FuzzerPass::FindOrCreateBoolType() { if (auto existing_id = fuzzerutil::MaybeGetBoolType(GetIRContext())) { return existing_id; } auto result = GetFuzzerContext()->GetFreshId(); ApplyTransformation(TransformationAddTypeBoolean(result)); return result; } uint32_t FuzzerPass::FindOrCreateIntegerType(uint32_t width, bool is_signed) { opt::analysis::Integer int_type(width, is_signed); auto existing_id = GetIRContext()->get_type_mgr()->GetId(&int_type); if (existing_id) { return existing_id; } auto result = GetFuzzerContext()->GetFreshId(); ApplyTransformation(TransformationAddTypeInt(result, width, is_signed)); return result; } uint32_t FuzzerPass::FindOrCreateFloatType(uint32_t width) { opt::analysis::Float float_type(width); auto existing_id = GetIRContext()->get_type_mgr()->GetId(&float_type); if (existing_id) { return existing_id; } auto result = GetFuzzerContext()->GetFreshId(); ApplyTransformation(TransformationAddTypeFloat(result, width)); return result; } uint32_t FuzzerPass::FindOrCreateFunctionType( uint32_t return_type_id, const std::vector& argument_id) { // FindFunctionType has a single argument for OpTypeFunction operands // so we will have to copy them all in this vector std::vector type_ids(argument_id.size() + 1); type_ids[0] = return_type_id; std::copy(argument_id.begin(), argument_id.end(), type_ids.begin() + 1); // Check if type exists auto existing_id = fuzzerutil::FindFunctionType(GetIRContext(), type_ids); if (existing_id) { return existing_id; } auto result = GetFuzzerContext()->GetFreshId(); ApplyTransformation( TransformationAddTypeFunction(result, return_type_id, argument_id)); return result; } uint32_t FuzzerPass::FindOrCreateVectorType(uint32_t component_type_id, uint32_t component_count) { assert(component_count >= 2 && component_count <= 4 && "Precondition: component count must be in range [2, 4]."); opt::analysis::Type* component_type = GetIRContext()->get_type_mgr()->GetType(component_type_id); assert(component_type && "Precondition: the component type must exist."); opt::analysis::Vector vector_type(component_type, component_count); auto existing_id = GetIRContext()->get_type_mgr()->GetId(&vector_type); if (existing_id) { return existing_id; } auto result = GetFuzzerContext()->GetFreshId(); ApplyTransformation( TransformationAddTypeVector(result, component_type_id, component_count)); return result; } uint32_t FuzzerPass::FindOrCreateMatrixType(uint32_t column_count, uint32_t row_count) { assert(column_count >= 2 && column_count <= 4 && "Precondition: column count must be in range [2, 4]."); assert(row_count >= 2 && row_count <= 4 && "Precondition: row count must be in range [2, 4]."); uint32_t column_type_id = FindOrCreateVectorType(FindOrCreateFloatType(32), row_count); opt::analysis::Type* column_type = GetIRContext()->get_type_mgr()->GetType(column_type_id); opt::analysis::Matrix matrix_type(column_type, column_count); auto existing_id = GetIRContext()->get_type_mgr()->GetId(&matrix_type); if (existing_id) { return existing_id; } auto result = GetFuzzerContext()->GetFreshId(); ApplyTransformation( TransformationAddTypeMatrix(result, column_type_id, column_count)); return result; } uint32_t FuzzerPass::FindOrCreateStructType( const std::vector& component_type_ids) { if (auto existing_id = fuzzerutil::MaybeGetStructType(GetIRContext(), component_type_ids)) { return existing_id; } auto new_id = GetFuzzerContext()->GetFreshId(); ApplyTransformation(TransformationAddTypeStruct(new_id, component_type_ids)); return new_id; } uint32_t FuzzerPass::FindOrCreatePointerType(uint32_t base_type_id, spv::StorageClass storage_class) { // We do not use the type manager here, due to problems related to isomorphic // but distinct structs not being regarded as different. auto existing_id = fuzzerutil::MaybeGetPointerType( GetIRContext(), base_type_id, storage_class); if (existing_id) { return existing_id; } auto result = GetFuzzerContext()->GetFreshId(); ApplyTransformation( TransformationAddTypePointer(result, storage_class, base_type_id)); return result; } uint32_t FuzzerPass::FindOrCreatePointerToIntegerType( uint32_t width, bool is_signed, spv::StorageClass storage_class) { return FindOrCreatePointerType(FindOrCreateIntegerType(width, is_signed), storage_class); } uint32_t FuzzerPass::FindOrCreateIntegerConstant( const std::vector& words, uint32_t width, bool is_signed, bool is_irrelevant) { auto int_type_id = FindOrCreateIntegerType(width, is_signed); if (auto constant_id = fuzzerutil::MaybeGetScalarConstant( GetIRContext(), *GetTransformationContext(), words, int_type_id, is_irrelevant)) { return constant_id; } auto result = GetFuzzerContext()->GetFreshId(); ApplyTransformation(TransformationAddConstantScalar(result, int_type_id, words, is_irrelevant)); return result; } uint32_t FuzzerPass::FindOrCreateFloatConstant( const std::vector& words, uint32_t width, bool is_irrelevant) { auto float_type_id = FindOrCreateFloatType(width); if (auto constant_id = fuzzerutil::MaybeGetScalarConstant( GetIRContext(), *GetTransformationContext(), words, float_type_id, is_irrelevant)) { return constant_id; } auto result = GetFuzzerContext()->GetFreshId(); ApplyTransformation(TransformationAddConstantScalar(result, float_type_id, words, is_irrelevant)); return result; } uint32_t FuzzerPass::FindOrCreateBoolConstant(bool value, bool is_irrelevant) { auto bool_type_id = FindOrCreateBoolType(); if (auto constant_id = fuzzerutil::MaybeGetScalarConstant( GetIRContext(), *GetTransformationContext(), {value ? 1u : 0u}, bool_type_id, is_irrelevant)) { return constant_id; } auto result = GetFuzzerContext()->GetFreshId(); ApplyTransformation( TransformationAddConstantBoolean(result, value, is_irrelevant)); return result; } uint32_t FuzzerPass::FindOrCreateConstant(const std::vector& words, uint32_t type_id, bool is_irrelevant) { assert(type_id && "Constant's type id can't be 0."); const auto* type = GetIRContext()->get_type_mgr()->GetType(type_id); assert(type && "Type does not exist."); if (type->AsBool()) { assert(words.size() == 1); return FindOrCreateBoolConstant(words[0], is_irrelevant); } else if (const auto* integer = type->AsInteger()) { return FindOrCreateIntegerConstant(words, integer->width(), integer->IsSigned(), is_irrelevant); } else if (const auto* floating = type->AsFloat()) { return FindOrCreateFloatConstant(words, floating->width(), is_irrelevant); } // This assertion will fail in debug build but not in release build // so we return 0 to make compiler happy. assert(false && "Constant type is not supported"); return 0; } uint32_t FuzzerPass::FindOrCreateCompositeConstant( const std::vector& component_ids, uint32_t type_id, bool is_irrelevant) { if (auto existing_constant = fuzzerutil::MaybeGetCompositeConstant( GetIRContext(), *GetTransformationContext(), component_ids, type_id, is_irrelevant)) { return existing_constant; } uint32_t result = GetFuzzerContext()->GetFreshId(); ApplyTransformation(TransformationAddConstantComposite( result, type_id, component_ids, is_irrelevant)); return result; } uint32_t FuzzerPass::FindOrCreateGlobalUndef(uint32_t type_id) { for (auto& inst : GetIRContext()->types_values()) { if (inst.opcode() == spv::Op::OpUndef && inst.type_id() == type_id) { return inst.result_id(); } } auto result = GetFuzzerContext()->GetFreshId(); ApplyTransformation(TransformationAddGlobalUndef(result, type_id)); return result; } uint32_t FuzzerPass::FindOrCreateNullConstant(uint32_t type_id) { // Find existing declaration opt::analysis::NullConstant null_constant( GetIRContext()->get_type_mgr()->GetType(type_id)); auto existing_constant = GetIRContext()->get_constant_mgr()->FindConstant(&null_constant); // Return if found if (existing_constant) { return GetIRContext() ->get_constant_mgr() ->GetDefiningInstruction(existing_constant) ->result_id(); } // Create new if not found auto result = GetFuzzerContext()->GetFreshId(); ApplyTransformation(TransformationAddConstantNull(result, type_id)); return result; } std::pair, std::map>> FuzzerPass::GetAvailableBasicTypesAndPointers( spv::StorageClass storage_class) const { // Records all of the basic types available in the module. std::set basic_types; // For each basic type, records all the associated pointer types that target // the basic type and that have |storage_class| as their storage class. std::map> basic_type_to_pointers; for (auto& inst : GetIRContext()->types_values()) { // For each basic type that we come across, record type, and the fact that // we cannot yet have seen any pointers that use the basic type as its // pointee type. // // For pointer types with basic pointee types, associate the pointer type // with the basic type. switch (inst.opcode()) { case spv::Op::OpTypeBool: case spv::Op::OpTypeFloat: case spv::Op::OpTypeInt: case spv::Op::OpTypeMatrix: case spv::Op::OpTypeVector: // These are all basic types. basic_types.insert(inst.result_id()); basic_type_to_pointers.insert({inst.result_id(), {}}); break; case spv::Op::OpTypeArray: // An array type is basic if its base type is basic. if (basic_types.count(inst.GetSingleWordInOperand(0))) { basic_types.insert(inst.result_id()); basic_type_to_pointers.insert({inst.result_id(), {}}); } break; case spv::Op::OpTypeStruct: { // A struct type is basic if it does not have the Block/BufferBlock // decoration, and if all of its members are basic. if (!fuzzerutil::HasBlockOrBufferBlockDecoration(GetIRContext(), inst.result_id())) { bool all_members_are_basic_types = true; for (uint32_t i = 0; i < inst.NumInOperands(); i++) { if (!basic_types.count(inst.GetSingleWordInOperand(i))) { all_members_are_basic_types = false; break; } } if (all_members_are_basic_types) { basic_types.insert(inst.result_id()); basic_type_to_pointers.insert({inst.result_id(), {}}); } } break; } case spv::Op::OpTypePointer: { // We are interested in the pointer if its pointee type is basic and it // has the right storage class. auto pointee_type = inst.GetSingleWordInOperand(1); if (spv::StorageClass(inst.GetSingleWordInOperand(0)) == storage_class && basic_types.count(pointee_type)) { // The pointer has the desired storage class, and its pointee type is // a basic type, so we are interested in it. Associate it with its // basic type. basic_type_to_pointers.at(pointee_type).push_back(inst.result_id()); } break; } default: break; } } return {{basic_types.begin(), basic_types.end()}, basic_type_to_pointers}; } uint32_t FuzzerPass::FindOrCreateZeroConstant( uint32_t scalar_or_composite_type_id, bool is_irrelevant) { auto type_instruction = GetIRContext()->get_def_use_mgr()->GetDef(scalar_or_composite_type_id); assert(type_instruction && "The type instruction must exist."); switch (type_instruction->opcode()) { case spv::Op::OpTypeBool: return FindOrCreateBoolConstant(false, is_irrelevant); case spv::Op::OpTypeFloat: { auto width = type_instruction->GetSingleWordInOperand(0); auto num_words = (width + 32 - 1) / 32; return FindOrCreateFloatConstant(std::vector(num_words, 0), width, is_irrelevant); } case spv::Op::OpTypeInt: { auto width = type_instruction->GetSingleWordInOperand(0); auto num_words = (width + 32 - 1) / 32; return FindOrCreateIntegerConstant( std::vector(num_words, 0), width, type_instruction->GetSingleWordInOperand(1), is_irrelevant); } case spv::Op::OpTypeArray: { auto component_type_id = type_instruction->GetSingleWordInOperand(0); auto num_components = fuzzerutil::GetArraySize(*type_instruction, GetIRContext()); return FindOrCreateCompositeConstant( std::vector( num_components, FindOrCreateZeroConstant(component_type_id, is_irrelevant)), scalar_or_composite_type_id, is_irrelevant); } case spv::Op::OpTypeMatrix: case spv::Op::OpTypeVector: { auto component_type_id = type_instruction->GetSingleWordInOperand(0); auto num_components = type_instruction->GetSingleWordInOperand(1); return FindOrCreateCompositeConstant( std::vector( num_components, FindOrCreateZeroConstant(component_type_id, is_irrelevant)), scalar_or_composite_type_id, is_irrelevant); } case spv::Op::OpTypeStruct: { assert(!fuzzerutil::HasBlockOrBufferBlockDecoration( GetIRContext(), scalar_or_composite_type_id) && "We do not construct constants of struct types decorated with " "Block or BufferBlock."); std::vector field_zero_ids; for (uint32_t index = 0; index < type_instruction->NumInOperands(); index++) { field_zero_ids.push_back(FindOrCreateZeroConstant( type_instruction->GetSingleWordInOperand(index), is_irrelevant)); } return FindOrCreateCompositeConstant( field_zero_ids, scalar_or_composite_type_id, is_irrelevant); } default: assert(false && "Unknown type."); return 0; } } void FuzzerPass::MaybeAddUseToReplace( opt::Instruction* use_inst, uint32_t use_index, uint32_t replacement_id, std::vector>* uses_to_replace) { // Only consider this use if it is in a block if (!GetIRContext()->get_instr_block(use_inst)) { return; } // Get the index of the operand restricted to input operands. uint32_t in_operand_index = fuzzerutil::InOperandIndexFromOperandIndex(*use_inst, use_index); auto id_use_descriptor = MakeIdUseDescriptorFromUse(GetIRContext(), use_inst, in_operand_index); uses_to_replace->emplace_back( std::make_pair(id_use_descriptor, replacement_id)); } opt::BasicBlock* FuzzerPass::GetOrCreateSimpleLoopPreheader( uint32_t header_id) { auto header_block = fuzzerutil::MaybeFindBlock(GetIRContext(), header_id); assert(header_block && header_block->IsLoopHeader() && "|header_id| should be the label id of a loop header"); auto predecessors = GetIRContext()->cfg()->preds(header_id); assert(predecessors.size() >= 2 && "The block |header_id| should be reachable."); auto function = header_block->GetParent(); if (predecessors.size() == 2) { // The header has a single out-of-loop predecessor, which could be a // preheader. opt::BasicBlock* maybe_preheader; if (GetIRContext()->GetDominatorAnalysis(function)->Dominates( header_id, predecessors[0])) { // The first predecessor is the back-edge block, because the header // dominates it, so the second one is out of the loop. maybe_preheader = &*function->FindBlock(predecessors[1]); } else { // The first predecessor is out of the loop. maybe_preheader = &*function->FindBlock(predecessors[0]); } // |maybe_preheader| is a preheader if it branches unconditionally to // the header. We also require it not to be a loop header. if (maybe_preheader->terminator()->opcode() == spv::Op::OpBranch && !maybe_preheader->IsLoopHeader()) { return maybe_preheader; } } // We need to add a preheader. // Get a fresh id for the preheader. uint32_t preheader_id = GetFuzzerContext()->GetFreshId(); // Get a fresh id for each OpPhi instruction, if there is more than one // out-of-loop predecessor. std::vector phi_ids; if (predecessors.size() > 2) { header_block->ForEachPhiInst( [this, &phi_ids](opt::Instruction* /* unused */) { phi_ids.push_back(GetFuzzerContext()->GetFreshId()); }); } // Add the preheader. ApplyTransformation( TransformationAddLoopPreheader(header_id, preheader_id, phi_ids)); // Make the newly-created preheader the new entry block. return &*function->FindBlock(preheader_id); } opt::BasicBlock* FuzzerPass::SplitBlockAfterOpPhiOrOpVariable( uint32_t block_id) { auto block = fuzzerutil::MaybeFindBlock(GetIRContext(), block_id); assert(block && "|block_id| must be a block label"); assert(!block->IsLoopHeader() && "|block_id| cannot be a loop header"); // Find the first non-OpPhi and non-OpVariable instruction. auto non_phi_or_var_inst = &*block->begin(); while (non_phi_or_var_inst->opcode() == spv::Op::OpPhi || non_phi_or_var_inst->opcode() == spv::Op::OpVariable) { non_phi_or_var_inst = non_phi_or_var_inst->NextNode(); } // Split the block. uint32_t new_block_id = GetFuzzerContext()->GetFreshId(); ApplyTransformation(TransformationSplitBlock( MakeInstructionDescriptor(GetIRContext(), non_phi_or_var_inst), new_block_id)); // We need to return the newly-created block. return &*block->GetParent()->FindBlock(new_block_id); } uint32_t FuzzerPass::FindOrCreateLocalVariable( uint32_t pointer_type_id, uint32_t function_id, bool pointee_value_is_irrelevant) { auto pointer_type = GetIRContext()->get_type_mgr()->GetType(pointer_type_id); // No unused variables in release mode. (void)pointer_type; assert(pointer_type && pointer_type->AsPointer() && pointer_type->AsPointer()->storage_class() == spv::StorageClass::Function && "The pointer_type_id must refer to a defined pointer type with " "storage class Function"); auto function = fuzzerutil::FindFunction(GetIRContext(), function_id); assert(function && "The function must be defined."); // First we try to find a suitable existing variable. // All of the local variable declarations are located in the first block. for (auto& instruction : *function->begin()) { if (instruction.opcode() != spv::Op::OpVariable) { continue; } // The existing OpVariable must have type |pointer_type_id|. if (instruction.type_id() != pointer_type_id) { continue; } // Check if the found variable is marked with PointeeValueIsIrrelevant // according to |pointee_value_is_irrelevant|. if (GetTransformationContext()->GetFactManager()->PointeeValueIsIrrelevant( instruction.result_id()) != pointee_value_is_irrelevant) { continue; } return instruction.result_id(); } // No such variable was found. Apply a transformation to get one. uint32_t pointee_type_id = fuzzerutil::GetPointeeTypeIdFromPointerType( GetIRContext(), pointer_type_id); uint32_t result_id = GetFuzzerContext()->GetFreshId(); ApplyTransformation(TransformationAddLocalVariable( result_id, pointer_type_id, function_id, FindOrCreateZeroConstant(pointee_type_id, pointee_value_is_irrelevant), pointee_value_is_irrelevant)); return result_id; } uint32_t FuzzerPass::FindOrCreateGlobalVariable( uint32_t pointer_type_id, bool pointee_value_is_irrelevant) { auto pointer_type = GetIRContext()->get_type_mgr()->GetType(pointer_type_id); // No unused variables in release mode. (void)pointer_type; assert( pointer_type && pointer_type->AsPointer() && (pointer_type->AsPointer()->storage_class() == spv::StorageClass::Private || pointer_type->AsPointer()->storage_class() == spv::StorageClass::Workgroup) && "The pointer_type_id must refer to a defined pointer type with storage " "class Private or Workgroup"); // First we try to find a suitable existing variable. for (auto& instruction : GetIRContext()->module()->types_values()) { if (instruction.opcode() != spv::Op::OpVariable) { continue; } // The existing OpVariable must have type |pointer_type_id|. if (instruction.type_id() != pointer_type_id) { continue; } // Check if the found variable is marked with PointeeValueIsIrrelevant // according to |pointee_value_is_irrelevant|. if (GetTransformationContext()->GetFactManager()->PointeeValueIsIrrelevant( instruction.result_id()) != pointee_value_is_irrelevant) { continue; } return instruction.result_id(); } // No such variable was found. Apply a transformation to get one. uint32_t pointee_type_id = fuzzerutil::GetPointeeTypeIdFromPointerType( GetIRContext(), pointer_type_id); auto storage_class = fuzzerutil::GetStorageClassFromPointerType( GetIRContext(), pointer_type_id); uint32_t result_id = GetFuzzerContext()->GetFreshId(); // A variable with storage class Workgroup shouldn't have an initializer. if (storage_class == spv::StorageClass::Workgroup) { ApplyTransformation(TransformationAddGlobalVariable( result_id, pointer_type_id, spv::StorageClass::Workgroup, 0, pointee_value_is_irrelevant)); } else { ApplyTransformation(TransformationAddGlobalVariable( result_id, pointer_type_id, spv::StorageClass::Private, FindOrCreateZeroConstant(pointee_type_id, pointee_value_is_irrelevant), pointee_value_is_irrelevant)); } return result_id; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass.h000066400000000000000000000405411475742701700235570ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_H_ #define SOURCE_FUZZ_FUZZER_PASS_H_ #include #include #include "source/fuzz/fuzzer_context.h" #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { // Interface for applying a pass of transformations to a module. class FuzzerPass { public: FuzzerPass(opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); virtual ~FuzzerPass(); // Applies the pass to the module |ir_context_|, assuming and updating // information from |transformation_context_|, and using |fuzzer_context_| to // guide the process. Appends to |transformations_| all transformations that // were applied during the pass. virtual void Apply() = 0; protected: opt::IRContext* GetIRContext() const { return ir_context_; } TransformationContext* GetTransformationContext() const { return transformation_context_; } FuzzerContext* GetFuzzerContext() const { return fuzzer_context_; } protobufs::TransformationSequence* GetTransformations() const { return transformations_; } // Returns all instructions that are *available* at |inst_it|, which is // required to be inside block |block| of function |function| - that is, all // instructions at global scope and all instructions that strictly dominate // |inst_it|. // // Filters said instructions to return only those that satisfy the // |instruction_is_relevant| predicate. This, for instance, could ignore all // instructions that have a particular decoration. std::vector FindAvailableInstructions( opt::Function* function, opt::BasicBlock* block, const opt::BasicBlock::iterator& inst_it, std::function instruction_is_relevant) const; // A helper method that iterates through each instruction in each reachable // block of |function|, at all times tracking an instruction descriptor that // allows the latest instruction to be located even if it has no result id. // // The code to manipulate the instruction descriptor is a bit fiddly. The // point of this method is to avoiding having to duplicate it in multiple // transformation passes. // // The function |action| is invoked for each instruction |inst_it| in block // |block| of function |function| that is encountered. The // |instruction_descriptor| parameter to the function object allows |inst_it| // to be identified. // // In most intended use cases, the job of |action| is to randomly decide // whether to try to apply some transformation, and then - if selected - to // attempt to apply it. void ForEachInstructionWithInstructionDescriptor( opt::Function* function, std::function< void(opt::BasicBlock* block, opt::BasicBlock::iterator inst_it, const protobufs::InstructionDescriptor& instruction_descriptor)> action); // Applies the above overload of ForEachInstructionWithInstructionDescriptor // to every function in the module, so that |action| is applied to an // |instruction_descriptor| for every instruction, |inst_it|, of every |block| // in every |function|. void ForEachInstructionWithInstructionDescriptor( std::function< void(opt::Function* function, opt::BasicBlock* block, opt::BasicBlock::iterator inst_it, const protobufs::InstructionDescriptor& instruction_descriptor)> action); // A generic helper for applying a transformation that should be applicable // by construction, and adding it to the sequence of applied transformations. void ApplyTransformation(const Transformation& transformation); // A generic helper for applying a transformation only if it is applicable. // If it is applicable, the transformation is applied and then added to the // sequence of applied transformations and the function returns true. // Otherwise, the function returns false. bool MaybeApplyTransformation(const Transformation& transformation); // Returns the id of an OpTypeBool instruction. If such an instruction does // not exist, a transformation is applied to add it. uint32_t FindOrCreateBoolType(); // Returns the id of an OpTypeInt instruction, with width and signedness // specified by |width| and |is_signed|, respectively. If such an instruction // does not exist, a transformation is applied to add it. uint32_t FindOrCreateIntegerType(uint32_t width, bool is_signed); // Returns the id of an OpTypeFloat instruction, with width specified by // |width|. If such an instruction does not exist, a transformation is // applied to add it. uint32_t FindOrCreateFloatType(uint32_t width); // Returns the id of an OpTypeFunction % %<...argument_id> // instruction. If such an instruction doesn't exist, a transformation // is applied to create a new one. uint32_t FindOrCreateFunctionType(uint32_t return_type_id, const std::vector& argument_id); // Returns the id of an OpTypeVector instruction, with |component_type_id| // (which must already exist) as its base type, and |component_count| // elements (which must be in the range [2, 4]). If such an instruction does // not exist, a transformation is applied to add it. uint32_t FindOrCreateVectorType(uint32_t component_type_id, uint32_t component_count); // Returns the id of an OpTypeMatrix instruction, with |column_count| columns // and |row_count| rows (each of which must be in the range [2, 4]). If the // float and vector types required to build this matrix type or the matrix // type itself do not exist, transformations are applied to add them. uint32_t FindOrCreateMatrixType(uint32_t column_count, uint32_t row_count); // Returns the id of an OpTypeStruct instruction with |component_type_ids| as // type ids for struct's components. If no such a struct type exists, // transformations are applied to add it. |component_type_ids| may not contain // a result id of an OpTypeFunction. uint32_t FindOrCreateStructType( const std::vector& component_type_ids); // Returns the id of a pointer type with base type |base_type_id| (which must // already exist) and storage class |storage_class|. A transformation is // applied to add the pointer if it does not already exist. uint32_t FindOrCreatePointerType(uint32_t base_type_id, spv::StorageClass storage_class); // Returns the id of an OpTypePointer instruction, with a integer base // type of width and signedness specified by |width| and |is_signed|, // respectively. If the pointer type or required integer base type do not // exist, transformations are applied to add them. uint32_t FindOrCreatePointerToIntegerType(uint32_t width, bool is_signed, spv::StorageClass storage_class); // Returns the id of an OpConstant instruction, with a integer type of // width and signedness specified by |width| and |is_signed|, respectively, // with |words| as its value. If either the required integer type or the // constant do not exist, transformations are applied to add them. // The returned id either participates in IdIsIrrelevant fact or not, // depending on the |is_irrelevant| parameter. uint32_t FindOrCreateIntegerConstant(const std::vector& words, uint32_t width, bool is_signed, bool is_irrelevant); // Returns the id of an OpConstant instruction, with a floating-point // type of width specified by |width|, with |words| as its value. If either // the required floating-point type or the constant do not exist, // transformations are applied to add them. The returned id either // participates in IdIsIrrelevant fact or not, depending on the // |is_irrelevant| parameter. uint32_t FindOrCreateFloatConstant(const std::vector& words, uint32_t width, bool is_irrelevant); // Returns the id of an OpConstantTrue or OpConstantFalse instruction, // according to |value|. If either the required instruction or the bool // type do not exist, transformations are applied to add them. // The returned id either participates in IdIsIrrelevant fact or not, // depending on the |is_irrelevant| parameter. uint32_t FindOrCreateBoolConstant(bool value, bool is_irrelevant); // Returns the id of an OpConstant instruction of type with |type_id| // that consists of |words|. If that instruction doesn't exist, // transformations are applied to add it. |type_id| must be a valid // result id of either scalar or boolean OpType* instruction that exists // in the module. The returned id either participates in IdIsIrrelevant fact // or not, depending on the |is_irrelevant| parameter. uint32_t FindOrCreateConstant(const std::vector& words, uint32_t type_id, bool is_irrelevant); // Returns the id of an OpConstantComposite instruction of type with |type_id| // that consists of |component_ids|. If that instruction doesn't exist, // transformations are applied to add it. |type_id| must be a valid // result id of an OpType* instruction that represents a composite type // (i.e. a vector, matrix, struct or array). // The returned id either participates in IdIsIrrelevant fact or not, // depending on the |is_irrelevant| parameter. uint32_t FindOrCreateCompositeConstant( const std::vector& component_ids, uint32_t type_id, bool is_irrelevant); // Returns the result id of an instruction of the form: // %id = OpUndef %|type_id| // If no such instruction exists, a transformation is applied to add it. uint32_t FindOrCreateGlobalUndef(uint32_t type_id); // Returns the id of an OpNullConstant instruction of type |type_id|. If // that instruction doesn't exist, it is added through a transformation. // |type_id| must be a valid result id of an OpType* instruction that exists // in the module. uint32_t FindOrCreateNullConstant(uint32_t type_id); // Define a *basic type* to be an integer, boolean or floating-point type, // or a matrix, vector, struct or fixed-size array built from basic types. In // particular, a basic type cannot contain an opaque type (such as an image), // or a runtime-sized array. // // Yields a pair, (basic_type_ids, basic_type_ids_to_pointers), such that: // - basic_type_ids captures every basic type declared in the module. // - basic_type_ids_to_pointers maps every such basic type to the sequence // of all pointer types that have storage class |storage_class| and the // given basic type as their pointee type. The sequence may be empty for // some basic types if no pointers to those types are defined for the given // storage class, and the sequence will have multiple elements if there are // repeated pointer declarations for the same basic type and storage class. std::pair, std::map>> GetAvailableBasicTypesAndPointers(spv::StorageClass storage_class) const; // Given a type id, |scalar_or_composite_type_id|, which must correspond to // some scalar or composite type, returns the result id of an instruction // defining a constant of the given type that is zero or false at everywhere. // If such an instruction does not yet exist, transformations are applied to // add it. The returned id either participates in IdIsIrrelevant fact or not, // depending on the |is_irrelevant| parameter. // // Examples: // --------------+------------------------------- // TYPE | RESULT is id corresponding to // --------------+------------------------------- // bool | false // --------------+------------------------------- // bvec4 | (false, false, false, false) // --------------+------------------------------- // float | 0.0 // --------------+------------------------------- // vec2 | (0.0, 0.0) // --------------+------------------------------- // int[3] | [0, 0, 0] // --------------+------------------------------- // struct S { | // int i; | S(0, false, (0u, 0u)) // bool b; | // uint2 u; | // } | // --------------+------------------------------- uint32_t FindOrCreateZeroConstant(uint32_t scalar_or_composite_type_id, bool is_irrelevant); // Adds a pair (id_use_descriptor, |replacement_id|) to the vector // |uses_to_replace|, where id_use_descriptor is the id use descriptor // representing the usage of an id in the |use_inst| instruction, at operand // index |use_index|, only if the instruction is in a basic block. // If the instruction is not in a basic block, it does nothing. void MaybeAddUseToReplace( opt::Instruction* use_inst, uint32_t use_index, uint32_t replacement_id, std::vector>* uses_to_replace); // Returns the preheader of the loop with header |header_id|, which satisfies // all of the following conditions: // - It is the only out-of-loop predecessor of the header // - It unconditionally branches to the header // - It is not a loop header itself // If such preheader does not exist, a new one is added and returned. // Requires |header_id| to be the label id of a loop header block that is // reachable in the CFG (and thus has at least 2 predecessors). opt::BasicBlock* GetOrCreateSimpleLoopPreheader(uint32_t header_id); // Returns the second block in the pair obtained by splitting |block_id| just // after the last OpPhi or OpVariable instruction in it. Assumes that the // block is not a loop header. opt::BasicBlock* SplitBlockAfterOpPhiOrOpVariable(uint32_t block_id); // Returns the id of an available local variable (storage class Function) with // the fact PointeeValueIsIrrelevant set according to // |pointee_value_is_irrelevant|. If there is no such variable, it creates one // in the |function| adding a zero initializer constant that is irrelevant. // The new variable has the fact PointeeValueIsIrrelevant set according to // |pointee_value_is_irrelevant|. The function returns the id of the created // variable. uint32_t FindOrCreateLocalVariable(uint32_t pointer_type_id, uint32_t function_id, bool pointee_value_is_irrelevant); // Returns the id of an available global variable (storage class Private or // Workgroup) with the fact PointeeValueIsIrrelevant set according to // |pointee_value_is_irrelevant|. If there is no such variable, it creates // one, adding a zero initializer constant that is irrelevant. The new // variable has the fact PointeeValueIsIrrelevant set according to // |pointee_value_is_irrelevant|. The function returns the id of the created // variable. uint32_t FindOrCreateGlobalVariable(uint32_t pointer_type_id, bool pointee_value_is_irrelevant); private: opt::IRContext* ir_context_; TransformationContext* transformation_context_; FuzzerContext* fuzzer_context_; protobufs::TransformationSequence* transformations_; // If set, then transformations that should be applicable by construction are // still tested for applicability, and ignored if they turn out to be // inapplicable. Otherwise, applicability by construction is asserted. const bool ignore_inapplicable_transformations_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_access_chains.cpp000066400000000000000000000201441475742701700275650ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_add_access_chains.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/transformation_access_chain.h" namespace spvtools { namespace fuzz { FuzzerPassAddAccessChains::FuzzerPassAddAccessChains( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassAddAccessChains::Apply() { ForEachInstructionWithInstructionDescriptor( [this](opt::Function* function, opt::BasicBlock* block, opt::BasicBlock::iterator inst_it, const protobufs::InstructionDescriptor& instruction_descriptor) -> void { assert( inst_it->opcode() == spv::Op(instruction_descriptor.target_instruction_opcode()) && "The opcode of the instruction we might insert before must be " "the same as the opcode in the descriptor for the instruction"); // Check whether it is legitimate to insert an access chain // instruction before this instruction. if (!fuzzerutil::CanInsertOpcodeBeforeInstruction( spv::Op::OpAccessChain, inst_it)) { return; } // Randomly decide whether to try inserting a load here. if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfAddingAccessChain())) { return; } // Get all of the pointers that are currently in scope, excluding // explicitly null and undefined pointers. std::vector relevant_pointer_instructions = FindAvailableInstructions( function, block, inst_it, [](opt::IRContext* context, opt::Instruction* instruction) -> bool { if (!instruction->result_id() || !instruction->type_id()) { // A pointer needs both a result and type id. return false; } switch (instruction->opcode()) { case spv::Op::OpConstantNull: case spv::Op::OpUndef: // Do not allow making an access chain from a null or // undefined pointer. (We can eliminate these cases // before actually checking that the instruction is a // pointer.) return false; default: break; } // If the instruction has pointer type, we can legitimately // make an access chain from it. return context->get_def_use_mgr() ->GetDef(instruction->type_id()) ->opcode() == spv::Op::OpTypePointer; }); // At this point, |relevant_instructions| contains all the pointers // we might think of making an access chain from. if (relevant_pointer_instructions.empty()) { return; } auto chosen_pointer = relevant_pointer_instructions[GetFuzzerContext()->RandomIndex( relevant_pointer_instructions)]; std::vector index_ids; // Each index accessing a non-struct composite will be clamped, thus // needing a pair of fresh ids std::vector> fresh_ids_for_clamping; auto pointer_type = GetIRContext()->get_def_use_mgr()->GetDef( chosen_pointer->type_id()); uint32_t subobject_type_id = pointer_type->GetSingleWordInOperand(1); while (true) { auto subobject_type = GetIRContext()->get_def_use_mgr()->GetDef(subobject_type_id); if (!spvOpcodeIsComposite(subobject_type->opcode())) { break; } if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext() ->GetChanceOfGoingDeeperWhenMakingAccessChain())) { break; } uint32_t bound; switch (subobject_type->opcode()) { case spv::Op::OpTypeArray: bound = fuzzerutil::GetArraySize(*subobject_type, GetIRContext()); break; case spv::Op::OpTypeMatrix: case spv::Op::OpTypeVector: bound = subobject_type->GetSingleWordInOperand(1); break; case spv::Op::OpTypeStruct: bound = fuzzerutil::GetNumberOfStructMembers(*subobject_type); break; default: assert(false && "Not a composite type opcode."); // Set the bound to a value in order to keep release compilers // happy. bound = 0; break; } if (bound == 0) { // It is possible for a composite type to legitimately have zero // sub-components, at least in the case of a struct, which // can have no fields. break; } uint32_t index_value = GetFuzzerContext()->GetRandomIndexForAccessChain(bound); switch (subobject_type->opcode()) { case spv::Op::OpTypeArray: case spv::Op::OpTypeMatrix: case spv::Op::OpTypeVector: { // The index will be clamped bool is_signed = GetFuzzerContext()->ChooseEven(); // Make the constant ready for clamping. We need: // - an OpTypeBool to be present in the module // - an OpConstant with the same type as the index and value // the maximum value for an index // - a new pair of fresh ids for the clamping instructions FindOrCreateBoolType(); FindOrCreateIntegerConstant({bound - 1}, 32, is_signed, false); std::pair fresh_pair_of_ids = { GetFuzzerContext()->GetFreshId(), GetFuzzerContext()->GetFreshId()}; fresh_ids_for_clamping.emplace_back(fresh_pair_of_ids); index_ids.push_back(FindOrCreateIntegerConstant( {index_value}, 32, is_signed, false)); subobject_type_id = subobject_type->GetSingleWordInOperand(0); } break; case spv::Op::OpTypeStruct: index_ids.push_back(FindOrCreateIntegerConstant( {index_value}, 32, GetFuzzerContext()->ChooseEven(), false)); subobject_type_id = subobject_type->GetSingleWordInOperand(index_value); break; default: assert(false && "Not a composite type opcode."); } } // The transformation we are about to create will only apply if a // pointer suitable for the access chain's result type exists, so we // create one if it does not. FindOrCreatePointerType(subobject_type_id, static_cast( pointer_type->GetSingleWordInOperand(0))); // Apply the transformation to add an access chain. ApplyTransformation(TransformationAccessChain( GetFuzzerContext()->GetFreshId(), chosen_pointer->result_id(), index_ids, instruction_descriptor, fresh_ids_for_clamping)); }); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_access_chains.h000066400000000000000000000027101475742701700272310ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_ADD_ACCESS_CHAINS_H_ #define SOURCE_FUZZ_FUZZER_PASS_ADD_ACCESS_CHAINS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // Fuzzer pass that randomly adds access chains based on pointers available in // the module. Other passes can use these access chains, e.g. by loading from // them. class FuzzerPassAddAccessChains : public FuzzerPass { public: FuzzerPassAddAccessChains(opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_ADD_ACCESS_CHAINS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_bit_instruction_synonyms.cpp000066400000000000000000000061631475742701700322020ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_add_bit_instruction_synonyms.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/transformation_add_bit_instruction_synonym.h" namespace spvtools { namespace fuzz { FuzzerPassAddBitInstructionSynonyms::FuzzerPassAddBitInstructionSynonyms( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassAddBitInstructionSynonyms::Apply() { for (auto& function : *GetIRContext()->module()) { for (auto& block : function) { for (auto& instruction : block) { // This fuzzer pass can add a *lot* of ids. We bail out early if we hit // the recommended id limit. if (GetIRContext()->module()->id_bound() >= GetFuzzerContext()->GetIdBoundLimit()) { return; } // Randomly decides whether the transformation will be applied. if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfAddingBitInstructionSynonym())) { continue; } // Make sure fuzzer never applies a transformation to a bitwise // instruction with differently signed operands, only integer operands // are supported and bitwise operations are supported only. if (!TransformationAddBitInstructionSynonym::IsInstructionSupported( GetIRContext(), &instruction)) { continue; } // Make sure all bit indexes are defined as 32-bit unsigned integers. uint32_t width = GetIRContext() ->get_type_mgr() ->GetType(instruction.type_id()) ->AsInteger() ->width(); for (uint32_t i = 0; i < width; i++) { FindOrCreateIntegerConstant({i}, 32, false, false); } // Applies the add bit instruction synonym transformation. ApplyTransformation(TransformationAddBitInstructionSynonym( instruction.result_id(), GetFuzzerContext()->GetFreshIds( TransformationAddBitInstructionSynonym::GetRequiredFreshIdCount( GetIRContext(), &instruction)))); } } } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_bit_instruction_synonyms.h000066400000000000000000000026761475742701700316540ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_ADD_BIT_INSTRUCTION_SYNONYMS_H_ #define SOURCE_FUZZ_FUZZER_PASS_ADD_BIT_INSTRUCTION_SYNONYMS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // This fuzzer pass adds synonyms for bit instructions. It iterates over the // module instructions, checks if they are bit instructions and randomly applies // the transformation. class FuzzerPassAddBitInstructionSynonyms : public FuzzerPass { public: FuzzerPassAddBitInstructionSynonyms( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_ADD_BIT_INSTRUCTION_SYNONYMS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_composite_extract.cpp000066400000000000000000000137611475742701700305420ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_add_composite_extract.h" #include "source/fuzz/available_instructions.h" #include "source/fuzz/fuzzer_context.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/transformation_composite_extract.h" namespace spvtools { namespace fuzz { FuzzerPassAddCompositeExtract::FuzzerPassAddCompositeExtract( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassAddCompositeExtract::Apply() { std::vector composite_synonyms; for (const auto* dd : GetTransformationContext()->GetFactManager()->GetAllSynonyms()) { // |dd| must describe a component of a composite. if (!dd->index().empty()) { composite_synonyms.push_back(dd); } } AvailableInstructions available_composites( GetIRContext(), [](opt::IRContext* ir_context, opt::Instruction* inst) { return inst->type_id() && inst->result_id() && fuzzerutil::IsCompositeType( ir_context->get_type_mgr()->GetType(inst->type_id())); }); ForEachInstructionWithInstructionDescriptor( [this, &available_composites, &composite_synonyms]( opt::Function* /*unused*/, opt::BasicBlock* /*unused*/, opt::BasicBlock::iterator inst_it, const protobufs::InstructionDescriptor& instruction_descriptor) { if (!fuzzerutil::CanInsertOpcodeBeforeInstruction( spv::Op::OpCompositeExtract, inst_it)) { return; } if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfAddingCompositeExtract())) { return; } std::vector available_synonyms; for (const auto* dd : composite_synonyms) { if (fuzzerutil::IdIsAvailableBeforeInstruction( GetIRContext(), &*inst_it, dd->object())) { available_synonyms.push_back(dd); } } auto candidate_composites = available_composites.GetAvailableBeforeInstruction(&*inst_it); if (available_synonyms.empty() && candidate_composites.empty()) { return; } uint32_t composite_id = 0; std::vector indices; if (available_synonyms.empty() || (!candidate_composites.empty() && GetFuzzerContext()->ChooseEven())) { const auto* inst = candidate_composites[GetFuzzerContext()->RandomIndex( candidate_composites)]; composite_id = inst->result_id(); auto type_id = inst->type_id(); do { uint32_t number_of_members = 0; const auto* type_inst = GetIRContext()->get_def_use_mgr()->GetDef(type_id); assert(type_inst && "Composite instruction has invalid type id"); switch (type_inst->opcode()) { case spv::Op::OpTypeArray: number_of_members = fuzzerutil::GetArraySize(*type_inst, GetIRContext()); break; case spv::Op::OpTypeVector: case spv::Op::OpTypeMatrix: number_of_members = type_inst->GetSingleWordInOperand(1); break; case spv::Op::OpTypeStruct: number_of_members = type_inst->NumInOperands(); break; default: assert(false && "|type_inst| is not a composite"); return; } if (number_of_members == 0) { return; } indices.push_back( GetFuzzerContext()->GetRandomCompositeExtractIndex( number_of_members)); switch (type_inst->opcode()) { case spv::Op::OpTypeArray: case spv::Op::OpTypeVector: case spv::Op::OpTypeMatrix: type_id = type_inst->GetSingleWordInOperand(0); break; case spv::Op::OpTypeStruct: type_id = type_inst->GetSingleWordInOperand(indices.back()); break; default: assert(false && "|type_inst| is not a composite"); return; } } while (fuzzerutil::IsCompositeType( GetIRContext()->get_type_mgr()->GetType(type_id)) && GetFuzzerContext()->ChoosePercentage( GetFuzzerContext() ->GetChanceOfGoingDeeperToExtractComposite())); } else { const auto* dd = available_synonyms[GetFuzzerContext()->RandomIndex( available_synonyms)]; composite_id = dd->object(); indices.assign(dd->index().begin(), dd->index().end()); } assert(composite_id != 0 && !indices.empty() && "Composite object should have been chosen correctly"); ApplyTransformation(TransformationCompositeExtract( instruction_descriptor, GetFuzzerContext()->GetFreshId(), composite_id, indices)); }); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_composite_extract.h000066400000000000000000000025011475742701700301750ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_ADD_COMPOSITE_EXTRACT_H_ #define SOURCE_FUZZ_FUZZER_PASS_ADD_COMPOSITE_EXTRACT_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // Randomly decides whether to add OpCompositeExtract before some instruction // in the module. class FuzzerPassAddCompositeExtract : public FuzzerPass { public: FuzzerPassAddCompositeExtract( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_ADD_COMPOSITE_EXTRACT_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_composite_inserts.cpp000066400000000000000000000230201475742701700305440ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_add_composite_inserts.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/pseudo_random_generator.h" #include "source/fuzz/transformation_composite_insert.h" namespace spvtools { namespace fuzz { FuzzerPassAddCompositeInserts::FuzzerPassAddCompositeInserts( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassAddCompositeInserts::Apply() { ForEachInstructionWithInstructionDescriptor( [this](opt::Function* function, opt::BasicBlock* block, opt::BasicBlock::iterator instruction_iterator, const protobufs::InstructionDescriptor& instruction_descriptor) -> void { assert( instruction_iterator->opcode() == spv::Op(instruction_descriptor.target_instruction_opcode()) && "The opcode of the instruction we might insert before must be " "the same as the opcode in the descriptor for the instruction"); // Randomly decide whether to try adding an OpCompositeInsert // instruction. if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfAddingCompositeInsert())) { return; } // It must be possible to insert an OpCompositeInsert instruction // before |instruction_iterator|. if (!fuzzerutil::CanInsertOpcodeBeforeInstruction( spv::Op::OpCompositeInsert, instruction_iterator)) { return; } // Look for available values that have composite type. std::vector available_composites = FindAvailableInstructions( function, block, instruction_iterator, [instruction_descriptor]( opt::IRContext* ir_context, opt::Instruction* instruction) -> bool { // |instruction| must be a supported instruction of composite // type. if (!TransformationCompositeInsert:: IsCompositeInstructionSupported(ir_context, instruction)) { return false; } auto instruction_type = ir_context->get_type_mgr()->GetType( instruction->type_id()); // No components of the composite can have type // OpTypeRuntimeArray. if (ContainsRuntimeArray(*instruction_type)) { return false; } // No components of the composite can be pointers. // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/3658): // Structs can have components of pointer type. // FindOrCreateZeroConstant cannot be called on a // pointer. We ignore pointers for now. Consider adding // support for pointer types. if (ContainsPointer(*instruction_type)) { return false; } return true; }); // If there are no available values, then return. if (available_composites.empty()) { return; } // Choose randomly one available composite value. auto available_composite = available_composites[GetFuzzerContext()->RandomIndex( available_composites)]; // Take a random component of the chosen composite value. If the chosen // component is itself a composite, then randomly decide whether to take // its component and repeat. uint32_t current_node_type_id = available_composite->type_id(); std::vector path_to_replaced; while (true) { auto current_node_type_inst = GetIRContext()->get_def_use_mgr()->GetDef(current_node_type_id); uint32_t num_of_components = fuzzerutil::GetBoundForCompositeIndex( *current_node_type_inst, GetIRContext()); // If the composite is empty, then end the iteration. if (num_of_components == 0) { break; } uint32_t one_selected_index = GetFuzzerContext()->GetRandomIndexForCompositeInsert( num_of_components); // Construct a final index by appending the current index. path_to_replaced.push_back(one_selected_index); current_node_type_id = fuzzerutil::WalkOneCompositeTypeIndex( GetIRContext(), current_node_type_id, one_selected_index); // If the component is not a composite then end the iteration. if (!fuzzerutil::IsCompositeType( GetIRContext()->get_type_mgr()->GetType( current_node_type_id))) { break; } // If the component is a composite, but we decide not to go deeper, // then end the iteration. if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext() ->GetChanceOfGoingDeeperToInsertInComposite())) { break; } } // Look for available objects that have the type id // |current_node_type_id| and can be inserted. std::vector available_objects = FindAvailableInstructions( function, block, instruction_iterator, [instruction_descriptor, current_node_type_id]( opt::IRContext* /*unused*/, opt::Instruction* instruction) -> bool { if (instruction->result_id() == 0 || instruction->type_id() == 0) { return false; } if (instruction->type_id() != current_node_type_id) { return false; } return true; }); // If there are no objects of the specific type available, check if // FindOrCreateZeroConstant can be called and create a zero constant of // this type. uint32_t available_object_id; if (available_objects.empty()) { if (!fuzzerutil::CanCreateConstant(GetIRContext(), current_node_type_id)) { return; } available_object_id = FindOrCreateZeroConstant(current_node_type_id, false); } else { available_object_id = available_objects[GetFuzzerContext()->RandomIndex( available_objects)] ->result_id(); } auto new_result_id = GetFuzzerContext()->GetFreshId(); // Insert an OpCompositeInsert instruction which copies // |available_composite| and in the copy inserts the object // of type |available_object_id| at index |index_to_replace|. ApplyTransformation(TransformationCompositeInsert( instruction_descriptor, new_result_id, available_composite->result_id(), available_object_id, path_to_replaced)); }); } bool FuzzerPassAddCompositeInserts::ContainsPointer( const opt::analysis::Type& type) { switch (type.kind()) { case opt::analysis::Type::kPointer: return true; case opt::analysis::Type::kArray: return ContainsPointer(*type.AsArray()->element_type()); case opt::analysis::Type::kMatrix: return ContainsPointer(*type.AsMatrix()->element_type()); case opt::analysis::Type::kVector: return ContainsPointer(*type.AsVector()->element_type()); case opt::analysis::Type::kStruct: return std::any_of(type.AsStruct()->element_types().begin(), type.AsStruct()->element_types().end(), [](const opt::analysis::Type* element_type) { return ContainsPointer(*element_type); }); default: return false; } } bool FuzzerPassAddCompositeInserts::ContainsRuntimeArray( const opt::analysis::Type& type) { switch (type.kind()) { case opt::analysis::Type::kRuntimeArray: return true; case opt::analysis::Type::kStruct: // If any component of a struct is of type OpTypeRuntimeArray, return // true. return std::any_of(type.AsStruct()->element_types().begin(), type.AsStruct()->element_types().end(), [](const opt::analysis::Type* element_type) { return ContainsRuntimeArray(*element_type); }); default: return false; } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_composite_inserts.h000066400000000000000000000031421475742701700302140ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_ADD_COMPOSITE_INSERTS_H_ #define SOURCE_FUZZ_FUZZER_PASS_ADD_COMPOSITE_INSERTS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // Fuzzer pass that randomly adds new OpCompositeInsert instructions to // available values that have the composite type. class FuzzerPassAddCompositeInserts : public FuzzerPass { public: FuzzerPassAddCompositeInserts( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; // Checks if any component of a composite is a pointer. static bool ContainsPointer(const opt::analysis::Type& type); // Checks if any component of a composite has type OpTypeRuntimeArray. static bool ContainsRuntimeArray(const opt::analysis::Type& type); }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_ADD_COMPOSITE_INSERTS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_composite_types.cpp000066400000000000000000000130211475742701700302210ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_add_composite_types.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/transformation_add_type_array.h" #include "source/fuzz/transformation_add_type_struct.h" namespace spvtools { namespace fuzz { FuzzerPassAddCompositeTypes::FuzzerPassAddCompositeTypes( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassAddCompositeTypes::Apply() { MaybeAddMissingVectorTypes(); MaybeAddMissingMatrixTypes(); // Randomly interleave between adding struct and array composite types while (GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfAddingArrayOrStructType())) { if (GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfChoosingStructTypeVsArrayType())) { AddNewStructType(); } else { AddNewArrayType(); } } } void FuzzerPassAddCompositeTypes::MaybeAddMissingVectorTypes() { // Functions to lazily supply scalar base types on demand if we decide to // create vectors with the relevant base types. std::function bool_type_supplier = [this]() -> uint32_t { return FindOrCreateBoolType(); }; std::function float_type_supplier = [this]() -> uint32_t { return FindOrCreateFloatType(32); }; std::function int_type_supplier = [this]() -> uint32_t { return FindOrCreateIntegerType(32, true); }; std::function uint_type_supplier = [this]() -> uint32_t { return FindOrCreateIntegerType(32, false); }; // Consider each of the base types with which we can make vectors. for (auto& base_type_supplier : {bool_type_supplier, float_type_supplier, int_type_supplier, uint_type_supplier}) { // Consider each valid vector size. for (uint32_t size = 2; size <= 4; size++) { // Randomly decide whether to create (if it does not already exist) a // vector with this size and base type. if (GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfAddingVectorType())) { FindOrCreateVectorType(base_type_supplier(), size); } } } } void FuzzerPassAddCompositeTypes::MaybeAddMissingMatrixTypes() { // Consider every valid matrix dimension. for (uint32_t columns = 2; columns <= 4; columns++) { for (uint32_t rows = 2; rows <= 4; rows++) { // Randomly decide whether to create (if it does not already exist) a // matrix with these dimensions. As matrices can only have floating-point // base type, we do not need to consider multiple base types as in the // case for vectors. if (GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfAddingMatrixType())) { FindOrCreateMatrixType(columns, rows); } } } } void FuzzerPassAddCompositeTypes::AddNewArrayType() { ApplyTransformation(TransformationAddTypeArray( GetFuzzerContext()->GetFreshId(), ChooseScalarOrCompositeType(), FindOrCreateIntegerConstant( {GetFuzzerContext()->GetRandomSizeForNewArray()}, 32, false, false))); } void FuzzerPassAddCompositeTypes::AddNewStructType() { std::vector field_type_ids; do { field_type_ids.push_back(ChooseScalarOrCompositeType()); } while (GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfAddingAnotherStructField())); ApplyTransformation(TransformationAddTypeStruct( GetFuzzerContext()->GetFreshId(), field_type_ids)); } uint32_t FuzzerPassAddCompositeTypes::ChooseScalarOrCompositeType() { // Gather up all the possibly-relevant types. std::vector candidates; for (auto& inst : GetIRContext()->types_values()) { switch (inst.opcode()) { case spv::Op::OpTypeArray: case spv::Op::OpTypeBool: case spv::Op::OpTypeFloat: case spv::Op::OpTypeInt: case spv::Op::OpTypeMatrix: case spv::Op::OpTypeVector: candidates.push_back(inst.result_id()); break; case spv::Op::OpTypeStruct: { if (!fuzzerutil::MembersHaveBuiltInDecoration(GetIRContext(), inst.result_id()) && !fuzzerutil::HasBlockOrBufferBlockDecoration(GetIRContext(), inst.result_id())) { candidates.push_back(inst.result_id()); } } break; default: break; } } assert(!candidates.empty() && "This function should only be called if there is at least one scalar " "or composite type available."); // Return one of these types at random. return candidates[GetFuzzerContext()->RandomIndex(candidates)]; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_composite_types.h000066400000000000000000000040141475742701700276700ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_ADD_COMPOSITE_TYPES_H_ #define SOURCE_FUZZ_FUZZER_PASS_ADD_COMPOSITE_TYPES_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // Fuzzer pass that randomly adds missing vector and matrix types, and new // array and struct types, to the module. class FuzzerPassAddCompositeTypes : public FuzzerPass { public: FuzzerPassAddCompositeTypes( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; private: // Creates an array of a random size with a random existing base type and adds // it to the module. void AddNewArrayType(); // Creates a struct with fields of random existing types and adds it to the // module. void AddNewStructType(); // For each vector type not already present in the module, randomly decides // whether to add it to the module. void MaybeAddMissingVectorTypes(); // For each matrix type not already present in the module, randomly decides // whether to add it to the module. void MaybeAddMissingMatrixTypes(); // Returns the id of a scalar or composite type declared in the module, // chosen randomly. uint32_t ChooseScalarOrCompositeType(); }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_ADD_COMPOSITE_TYPES_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_copy_memory.cpp000066400000000000000000000061731475742701700273470ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_add_copy_memory.h" #include "source/fuzz/fuzzer_context.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/transformation_add_copy_memory.h" namespace spvtools { namespace fuzz { FuzzerPassAddCopyMemory::FuzzerPassAddCopyMemory( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassAddCopyMemory::Apply() { ForEachInstructionWithInstructionDescriptor( [this](opt::Function* function, opt::BasicBlock* block, opt::BasicBlock::iterator inst_it, const protobufs::InstructionDescriptor& instruction_descriptor) { // Check that we can insert an OpCopyMemory before this instruction. if (!fuzzerutil::CanInsertOpcodeBeforeInstruction(spv::Op::OpCopyMemory, inst_it)) { return; } if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfAddingCopyMemory())) { return; } // Get all instructions available before |inst_it| according to the // domination rules. auto instructions = FindAvailableInstructions( function, block, inst_it, TransformationAddCopyMemory::IsInstructionSupported); if (instructions.empty()) { return; } const auto* inst = instructions[GetFuzzerContext()->RandomIndex(instructions)]; // Decide whether to create global or local variable. auto storage_class = GetFuzzerContext()->ChooseEven() ? spv::StorageClass::Private : spv::StorageClass::Function; auto pointee_type_id = fuzzerutil::GetPointeeTypeIdFromPointerType( GetIRContext(), inst->type_id()); // Create a pointer type with |storage_class| if needed. FindOrCreatePointerType(pointee_type_id, storage_class); ApplyTransformation(TransformationAddCopyMemory( instruction_descriptor, GetFuzzerContext()->GetFreshId(), inst->result_id(), storage_class, FindOrCreateZeroConstant(pointee_type_id, false))); }); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_copy_memory.h000066400000000000000000000026231475742701700270100ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_ADD_COPY_MEMORY_INSTRUCTIONS_H_ #define SOURCE_FUZZ_FUZZER_PASS_ADD_COPY_MEMORY_INSTRUCTIONS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // Randomly decides whether to add OpCopyMemory before some instruction in the // module. class FuzzerPassAddCopyMemory : public FuzzerPass { public: FuzzerPassAddCopyMemory(opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_ADD_COPY_MEMORY_INSTRUCTIONS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_dead_blocks.cpp000066400000000000000000000065441475742701700272410ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_add_dead_blocks.h" #include #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/transformation_add_dead_block.h" namespace spvtools { namespace fuzz { namespace { const size_t kMaxTransformationsInOnePass = 100U; } // namespace FuzzerPassAddDeadBlocks::FuzzerPassAddDeadBlocks( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassAddDeadBlocks::Apply() { // We iterate over all blocks in the module collecting up those at which we // might add a branch to a new dead block. We then loop over all such // candidates and actually apply transformations. This separation is to // avoid modifying the module as we traverse it. std::vector candidate_transformations; for (auto& function : *GetIRContext()->module()) { for (auto& block : function) { if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfAddingDeadBlock())) { continue; } // Make sure the module contains a boolean constant equal to // |condition_value|. bool condition_value = GetFuzzerContext()->ChooseEven(); FindOrCreateBoolConstant(condition_value, false); // We speculatively create a transformation, and then apply it (below) if // it turns out to be applicable. This avoids duplicating the logic for // applicability checking. // // It means that fresh ids for transformations that turn out not to be // applicable end up being unused. candidate_transformations.emplace_back(TransformationAddDeadBlock( GetFuzzerContext()->GetFreshId(), block.id(), condition_value)); } } // Applying transformations can be expensive as each transformation requires // dominator information and also invalidates dominator information. We thus // limit the number of transformations that one application of this fuzzer // pass can apply. We choose to do this after identifying all the // transformations that we *might* want to apply, rather than breaking the // above loops once the limit is reached, to avoid biasing towards // transformations that target early parts of the module. GetFuzzerContext()->Shuffle(&candidate_transformations); for (size_t i = 0; i < std::min(kMaxTransformationsInOnePass, candidate_transformations.size()); i++) { MaybeApplyTransformation(candidate_transformations[i]); } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_dead_blocks.h000066400000000000000000000026061475742701700267010ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_ADD_DEAD_BLOCKS_H_ #define SOURCE_FUZZ_FUZZER_PASS_ADD_DEAD_BLOCKS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // Fuzzer pass to add dynamically unreachable blocks to the module. Future // passes can then manipulate such blocks. class FuzzerPassAddDeadBlocks : public FuzzerPass { public: FuzzerPassAddDeadBlocks(opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_ADD_DEAD_BLOCKS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_dead_breaks.cpp000066400000000000000000000131301475742701700272200ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_add_dead_breaks.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/transformation_add_dead_break.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { FuzzerPassAddDeadBreaks::FuzzerPassAddDeadBreaks( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassAddDeadBreaks::Apply() { // We first collect up lots of possibly-applicable transformations. std::vector candidate_transformations; // We consider each function separately. for (auto& function : *GetIRContext()->module()) { // For a given function, we find all the merge blocks in that function. std::vector merge_blocks; for (auto& block : function) { auto maybe_merge_id = block.MergeBlockIdIfAny(); if (maybe_merge_id) { auto merge_block = fuzzerutil::MaybeFindBlock(GetIRContext(), maybe_merge_id); assert(merge_block && "Merge block can't be null"); merge_blocks.push_back(merge_block); } } // We rather aggressively consider the possibility of adding a break from // every block in the function to every merge block. Many of these will be // inapplicable as they would be illegal. That's OK - we later discard the // ones that turn out to be no good. for (auto& block : function) { for (auto* merge_block : merge_blocks) { // Populate this vector with ids that are available at the branch point // of this basic block. We will use these ids to update OpPhi // instructions later. std::vector phi_ids; // Determine how we need to adjust OpPhi instructions' operands // for this transformation to be valid. // // If |block| has a branch to |merge_block|, the latter must have all of // its OpPhi instructions set up correctly - we don't need to adjust // anything. if (!block.IsSuccessor(merge_block)) { merge_block->ForEachPhiInst([this, &phi_ids](opt::Instruction* phi) { // Add an additional operand for OpPhi instruction. Use a constant // if possible, and an undef otherwise. if (fuzzerutil::CanCreateConstant(GetIRContext(), phi->type_id())) { // We mark the constant as irrelevant so that we can replace it // with a more interesting value later. phi_ids.push_back(FindOrCreateZeroConstant(phi->type_id(), true)); } else { phi_ids.push_back(FindOrCreateGlobalUndef(phi->type_id())); } }); } // Make sure the module has a required boolean constant to be used in // OpBranchConditional instruction. auto break_condition = GetFuzzerContext()->ChooseEven(); FindOrCreateBoolConstant(break_condition, false); auto candidate_transformation = TransformationAddDeadBreak( block.id(), merge_block->id(), break_condition, std::move(phi_ids)); if (candidate_transformation.IsApplicable( GetIRContext(), *GetTransformationContext())) { // Only consider a transformation as a candidate if it is applicable. candidate_transformations.push_back( std::move(candidate_transformation)); } } } } // Go through the candidate transformations that were accumulated, // probabilistically deciding whether to consider each one further and // applying the still-applicable ones that are considered further. // // We iterate through the candidate transformations in a random order by // repeatedly removing a random candidate transformation from the sequence // until no candidate transformations remain. This is done because // transformations can potentially disable one another, so that iterating // through them in order would lead to a higher probability of // transformations appearing early in the sequence being applied compared // with later transformations. while (!candidate_transformations.empty()) { // Choose a random index into the sequence of remaining candidate // transformations. auto index = GetFuzzerContext()->RandomIndex(candidate_transformations); // Remove the transformation at the chosen index from the sequence. auto transformation = std::move(candidate_transformations[index]); candidate_transformations.erase(candidate_transformations.begin() + index); // Probabilistically decide whether to try to apply it vs. ignore it, in the // case that it is applicable. if (GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfAddingDeadBreak())) { MaybeApplyTransformation(transformation); } } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_dead_breaks.h000066400000000000000000000025131475742701700266700ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_ADD_DEAD_BREAKS_H_ #define SOURCE_FUZZ_FUZZER_PASS_ADD_DEAD_BREAKS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // A fuzzer pass for adding dead break edges to the module. class FuzzerPassAddDeadBreaks : public FuzzerPass { public: FuzzerPassAddDeadBreaks(opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_ADD_DEAD_BREAKS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_dead_continues.cpp000066400000000000000000000075321475742701700277710ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_add_dead_continues.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/transformation_add_dead_continue.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { FuzzerPassAddDeadContinues::FuzzerPassAddDeadContinues( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassAddDeadContinues::Apply() { // Consider every block in every function. for (auto& function : *GetIRContext()->module()) { for (auto& block : function) { // Get the label id of the continue target of the innermost loop. auto continue_block_id = block.IsLoopHeader() ? block.ContinueBlockId() : GetIRContext()->GetStructuredCFGAnalysis()->LoopContinueBlock( block.id()); // This transformation is not applicable if current block is not inside a // loop. if (continue_block_id == 0) { continue; } auto* continue_block = fuzzerutil::MaybeFindBlock(GetIRContext(), continue_block_id); assert(continue_block && "Continue block is null"); // Analyze return type of each OpPhi instruction in the continue target // and provide an id for the transformation if needed. std::vector phi_ids; // Check whether current block has an edge to the continue target. // If this is the case, we don't need to do anything. if (!block.IsSuccessor(continue_block)) { continue_block->ForEachPhiInst([this, &phi_ids](opt::Instruction* phi) { // Add an additional operand for OpPhi instruction. Use a constant // if possible, and an undef otherwise. if (fuzzerutil::CanCreateConstant(GetIRContext(), phi->type_id())) { // We mark the constant as irrelevant so that we can replace it with // a more interesting value later. phi_ids.push_back(FindOrCreateZeroConstant(phi->type_id(), true)); } else { phi_ids.push_back(FindOrCreateGlobalUndef(phi->type_id())); } }); } // Make sure the module contains a boolean constant equal to // |condition_value|. bool condition_value = GetFuzzerContext()->ChooseEven(); FindOrCreateBoolConstant(condition_value, false); // Make a transformation to add a dead continue from this node; if the // node turns out to be inappropriate (e.g. by not being in a loop) the // precondition for the transformation will fail and it will be ignored. auto candidate_transformation = TransformationAddDeadContinue( block.id(), condition_value, std::move(phi_ids)); // Probabilistically decide whether to apply the transformation in the // case that it is applicable. if (GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfAddingDeadContinue())) { MaybeApplyTransformation(candidate_transformation); } } } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_dead_continues.h000066400000000000000000000025511475742701700274320ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_ADD_DEAD_CONTINUES_H_ #define SOURCE_FUZZ_FUZZER_PASS_ADD_DEAD_CONTINUES_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // A fuzzer pass for adding dead continue edges to the module. class FuzzerPassAddDeadContinues : public FuzzerPass { public: FuzzerPassAddDeadContinues(opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_ADD_DEAD_CONTINUES_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_equation_instructions.cpp000066400000000000000000000416171475742701700314600ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_add_equation_instructions.h" #include #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/transformation_equation_instruction.h" namespace spvtools { namespace fuzz { namespace { bool IsBitWidthSupported(opt::IRContext* ir_context, uint32_t bit_width) { switch (bit_width) { case 32: return true; case 64: return ir_context->get_feature_mgr()->HasCapability( spv::Capability::Float64) && ir_context->get_feature_mgr()->HasCapability( spv::Capability::Int64); case 16: return ir_context->get_feature_mgr()->HasCapability( spv::Capability::Float16) && ir_context->get_feature_mgr()->HasCapability( spv::Capability::Int16); default: return false; } } } // namespace FuzzerPassAddEquationInstructions::FuzzerPassAddEquationInstructions( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassAddEquationInstructions::Apply() { ForEachInstructionWithInstructionDescriptor( [this](opt::Function* function, opt::BasicBlock* block, opt::BasicBlock::iterator inst_it, const protobufs::InstructionDescriptor& instruction_descriptor) { if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfAddingEquationInstruction())) { return; } // Check that it is OK to add an equation instruction before the given // instruction in principle - e.g. check that this does not lead to // inserting before an OpVariable or OpPhi instruction. We use OpIAdd // as an example opcode for this check, to be representative of *some* // opcode that defines an equation, even though we may choose a // different opcode below. if (!fuzzerutil::CanInsertOpcodeBeforeInstruction(spv::Op::OpIAdd, inst_it)) { return; } // Get all available instructions with result ids and types that are not // OpUndef. std::vector available_instructions = FindAvailableInstructions( function, block, inst_it, [this](opt::IRContext* /*unused*/, opt::Instruction* instruction) -> bool { return instruction->result_id() && instruction->type_id() && instruction->opcode() != spv::Op::OpUndef && !GetTransformationContext() ->GetFactManager() ->IdIsIrrelevant(instruction->result_id()); }); // Try the opcodes for which we know how to make ids at random until // something works. std::vector candidate_opcodes = { spv::Op::OpIAdd, spv::Op::OpISub, spv::Op::OpLogicalNot, spv::Op::OpSNegate, spv::Op::OpConvertUToF, spv::Op::OpConvertSToF, spv::Op::OpBitcast}; do { auto opcode = GetFuzzerContext()->RemoveAtRandomIndex(&candidate_opcodes); switch (opcode) { case spv::Op::OpConvertSToF: case spv::Op::OpConvertUToF: { std::vector candidate_instructions; for (const auto* inst : GetIntegerInstructions(available_instructions)) { const auto* type = GetIRContext()->get_type_mgr()->GetType(inst->type_id()); assert(type && "|inst| has invalid type"); if (const auto* vector_type = type->AsVector()) { type = vector_type->element_type(); } if (IsBitWidthSupported(GetIRContext(), type->AsInteger()->width())) { candidate_instructions.push_back(inst); } } if (candidate_instructions.empty()) { break; } const auto* operand = candidate_instructions[GetFuzzerContext()->RandomIndex( candidate_instructions)]; const auto* type = GetIRContext()->get_type_mgr()->GetType(operand->type_id()); assert(type && "Operand has invalid type"); // Make sure a result type exists in the module. if (const auto* vector = type->AsVector()) { // We store element count in a separate variable since the // call FindOrCreate* functions below might invalidate // |vector| pointer. const auto element_count = vector->element_count(); FindOrCreateVectorType( FindOrCreateFloatType( vector->element_type()->AsInteger()->width()), element_count); } else { FindOrCreateFloatType(type->AsInteger()->width()); } ApplyTransformation(TransformationEquationInstruction( GetFuzzerContext()->GetFreshId(), opcode, {operand->result_id()}, instruction_descriptor)); return; } case spv::Op::OpBitcast: { const auto candidate_instructions = GetNumericalInstructions(available_instructions); if (!candidate_instructions.empty()) { const auto* operand_inst = candidate_instructions[GetFuzzerContext()->RandomIndex( candidate_instructions)]; const auto* operand_type = GetIRContext()->get_type_mgr()->GetType( operand_inst->type_id()); assert(operand_type && "Operand instruction has invalid type"); // Make sure a result type exists in the module. // // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/3539): // The only constraint on the types of OpBitcast's parameters // is that they must have the same number of bits. Consider // improving the code below to support this in full. if (const auto* vector = operand_type->AsVector()) { // We store element count in a separate variable since the // call FindOrCreate* functions below might invalidate // |vector| pointer. const auto element_count = vector->element_count(); uint32_t element_type_id; if (const auto* int_type = vector->element_type()->AsInteger()) { element_type_id = FindOrCreateFloatType(int_type->width()); } else { assert(vector->element_type()->AsFloat() && "Vector must have numerical elements"); element_type_id = FindOrCreateIntegerType( vector->element_type()->AsFloat()->width(), GetFuzzerContext()->ChooseEven()); } FindOrCreateVectorType(element_type_id, element_count); } else if (const auto* int_type = operand_type->AsInteger()) { FindOrCreateFloatType(int_type->width()); } else { assert(operand_type->AsFloat() && "Operand is not a scalar of numerical type"); FindOrCreateIntegerType(operand_type->AsFloat()->width(), GetFuzzerContext()->ChooseEven()); } ApplyTransformation(TransformationEquationInstruction( GetFuzzerContext()->GetFreshId(), opcode, {operand_inst->result_id()}, instruction_descriptor)); return; } } break; case spv::Op::OpIAdd: case spv::Op::OpISub: { // Instructions of integer (scalar or vector) result type are // suitable for these opcodes. auto integer_instructions = GetIntegerInstructions(available_instructions); if (!integer_instructions.empty()) { // There is at least one such instruction, so pick one at random // for the LHS of an equation. auto lhs = integer_instructions.at( GetFuzzerContext()->RandomIndex(integer_instructions)); // For the RHS, we can use any instruction with an integer // scalar/vector result type of the same number of components // and the same bit-width for the underlying integer type. // Work out the element count and bit-width. auto lhs_type = GetIRContext()->get_type_mgr()->GetType(lhs->type_id()); uint32_t lhs_element_count; uint32_t lhs_bit_width; if (lhs_type->AsVector()) { lhs_element_count = lhs_type->AsVector()->element_count(); lhs_bit_width = lhs_type->AsVector() ->element_type() ->AsInteger() ->width(); } else { lhs_element_count = 1; lhs_bit_width = lhs_type->AsInteger()->width(); } // Get all the instructions that match on element count and // bit-width. auto candidate_rhs_instructions = RestrictToElementBitWidth( RestrictToVectorWidth(integer_instructions, lhs_element_count), lhs_bit_width); // Choose a RHS instruction at random; there is guaranteed to // be at least one choice as the LHS will be available. auto rhs = candidate_rhs_instructions.at( GetFuzzerContext()->RandomIndex( candidate_rhs_instructions)); // Add the equation instruction. ApplyTransformation(TransformationEquationInstruction( GetFuzzerContext()->GetFreshId(), opcode, {lhs->result_id(), rhs->result_id()}, instruction_descriptor)); return; } break; } case spv::Op::OpLogicalNot: { // Choose any available instruction of boolean scalar/vector // result type and equate its negation with a fresh id. auto boolean_instructions = GetBooleanInstructions(available_instructions); if (!boolean_instructions.empty()) { ApplyTransformation(TransformationEquationInstruction( GetFuzzerContext()->GetFreshId(), opcode, {boolean_instructions .at(GetFuzzerContext()->RandomIndex( boolean_instructions)) ->result_id()}, instruction_descriptor)); return; } break; } case spv::Op::OpSNegate: { // Similar to OpLogicalNot, but for signed integer negation. auto integer_instructions = GetIntegerInstructions(available_instructions); if (!integer_instructions.empty()) { ApplyTransformation(TransformationEquationInstruction( GetFuzzerContext()->GetFreshId(), opcode, {integer_instructions .at(GetFuzzerContext()->RandomIndex( integer_instructions)) ->result_id()}, instruction_descriptor)); return; } break; } default: assert(false && "Unexpected opcode."); break; } } while (!candidate_opcodes.empty()); // Reaching here means that we did not manage to apply any // transformation at this point of the module. }); } std::vector FuzzerPassAddEquationInstructions::GetIntegerInstructions( const std::vector& instructions) const { std::vector result; for (auto& inst : instructions) { auto type = GetIRContext()->get_type_mgr()->GetType(inst->type_id()); if (type->AsInteger() || (type->AsVector() && type->AsVector()->element_type()->AsInteger())) { result.push_back(inst); } } return result; } std::vector FuzzerPassAddEquationInstructions::GetFloatInstructions( const std::vector& instructions) const { std::vector result; for (auto& inst : instructions) { auto type = GetIRContext()->get_type_mgr()->GetType(inst->type_id()); if (type->AsFloat() || (type->AsVector() && type->AsVector()->element_type()->AsFloat())) { result.push_back(inst); } } return result; } std::vector FuzzerPassAddEquationInstructions::GetBooleanInstructions( const std::vector& instructions) const { std::vector result; for (auto& inst : instructions) { auto type = GetIRContext()->get_type_mgr()->GetType(inst->type_id()); if (type->AsBool() || (type->AsVector() && type->AsVector()->element_type()->AsBool())) { result.push_back(inst); } } return result; } std::vector FuzzerPassAddEquationInstructions::RestrictToVectorWidth( const std::vector& instructions, uint32_t vector_width) const { std::vector result; for (auto& inst : instructions) { auto type = GetIRContext()->get_type_mgr()->GetType(inst->type_id()); // Get the vector width of |inst|, which is 1 if |inst| is a scalar and is // otherwise derived from its vector type. uint32_t other_vector_width = type->AsVector() ? type->AsVector()->element_count() : 1; // Keep |inst| if the vector widths match. if (vector_width == other_vector_width) { result.push_back(inst); } } return result; } std::vector FuzzerPassAddEquationInstructions::RestrictToElementBitWidth( const std::vector& instructions, uint32_t bit_width) const { std::vector result; for (auto& inst : instructions) { const opt::analysis::Type* type = GetIRContext()->get_type_mgr()->GetType(inst->type_id()); if (type->AsVector()) { type = type->AsVector()->element_type(); } assert((type->AsInteger() || type->AsFloat()) && "Precondition: all input instructions must " "have integer or float scalar or vector type."); if ((type->AsInteger() && type->AsInteger()->width() == bit_width) || (type->AsFloat() && type->AsFloat()->width() == bit_width)) { result.push_back(inst); } } return result; } std::vector FuzzerPassAddEquationInstructions::GetNumericalInstructions( const std::vector& instructions) const { std::vector result; for (auto* inst : instructions) { const auto* type = GetIRContext()->get_type_mgr()->GetType(inst->type_id()); assert(type && "Instruction has invalid type"); if (const auto* vector_type = type->AsVector()) { type = vector_type->element_type(); } if (!type->AsInteger() && !type->AsFloat()) { // Only numerical scalars or vectors of numerical components are // supported. continue; } if (!IsBitWidthSupported(GetIRContext(), type->AsInteger() ? type->AsInteger()->width() : type->AsFloat()->width())) { continue; } result.push_back(inst); } return result; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_equation_instructions.h000066400000000000000000000062751475742701700311260ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_ADD_EQUATION_INSTRUCTIONS_H_ #define SOURCE_FUZZ_FUZZER_PASS_ADD_EQUATION_INSTRUCTIONS_H_ #include #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // Fuzzer pass that sprinkles instructions through the module that define // equations using various arithmetic and logical operators. class FuzzerPassAddEquationInstructions : public FuzzerPass { public: FuzzerPassAddEquationInstructions( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; private: // Yields those instructions in |instructions| that have integer scalar or // vector result type. std::vector GetIntegerInstructions( const std::vector& instructions) const; // Returns only instructions, that have either a scalar floating-point or a // vector type. std::vector GetFloatInstructions( const std::vector& instructions) const; // Yields those instructions in |instructions| that have boolean scalar or // vector result type. std::vector GetBooleanInstructions( const std::vector& instructions) const; // Yields those instructions in |instructions| that have a scalar numerical or // a vector of numerical components type. Only 16, 32 and 64-bit numericals // are supported if both OpTypeInt and OpTypeFloat instructions can be created // with the specified width (e.g. for 16-bit types both Float16 and Int16 // capabilities must be present). std::vector GetNumericalInstructions( const std::vector& instructions) const; // Requires that |instructions| are scalars or vectors of some type. Returns // only those instructions whose width is |width|. If |width| is 1 this means // the scalars. std::vector RestrictToVectorWidth( const std::vector& instructions, uint32_t vector_width) const; // Requires that |instructions| are integer or float scalars or vectors. // Returns only those instructions for which the bit-width of the underlying // integer or floating-point type is |bit_width|. std::vector RestrictToElementBitWidth( const std::vector& instructions, uint32_t bit_width) const; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_ADD_EQUATION_INSTRUCTIONS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_function_calls.cpp000066400000000000000000000206621475742701700300070ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_add_function_calls.h" #include "source/fuzz/call_graph.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/transformation_add_global_variable.h" #include "source/fuzz/transformation_add_local_variable.h" #include "source/fuzz/transformation_function_call.h" namespace spvtools { namespace fuzz { FuzzerPassAddFunctionCalls::FuzzerPassAddFunctionCalls( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassAddFunctionCalls::Apply() { ForEachInstructionWithInstructionDescriptor( [this](opt::Function* function, opt::BasicBlock* block, opt::BasicBlock::iterator inst_it, const protobufs::InstructionDescriptor& instruction_descriptor) -> void { // Check whether it is legitimate to insert a function call before the // instruction. if (!fuzzerutil::CanInsertOpcodeBeforeInstruction( spv::Op::OpFunctionCall, inst_it)) { return; } // Randomly decide whether to try inserting a function call here. if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfCallingFunction())) { return; } // Compute the module's call graph - we don't cache it since it may // change each time we apply a transformation. If this proves to be // a bottleneck the call graph data structure could be made updatable. CallGraph call_graph(GetIRContext()); // Gather all the non-entry point functions different from this // function. It is important to ignore entry points as a function // cannot be an entry point and the target of an OpFunctionCall // instruction. We ignore this function to avoid direct recursion. std::vector candidate_functions; for (auto& other_function : *GetIRContext()->module()) { if (&other_function != function && !fuzzerutil::FunctionIsEntryPoint(GetIRContext(), other_function.result_id())) { candidate_functions.push_back(&other_function); } } // Choose a function to call, at random, by considering candidate // functions until a suitable one is found. opt::Function* chosen_function = nullptr; while (!candidate_functions.empty()) { opt::Function* candidate_function = GetFuzzerContext()->RemoveAtRandomIndex(&candidate_functions); if (!GetTransformationContext()->GetFactManager()->BlockIsDead( block->id()) && !GetTransformationContext()->GetFactManager()->FunctionIsLivesafe( candidate_function->result_id())) { // Unless in a dead block, only livesafe functions can be invoked continue; } if (call_graph.GetIndirectCallees(candidate_function->result_id()) .count(function->result_id())) { // Calling this function could lead to indirect recursion continue; } chosen_function = candidate_function; break; } if (!chosen_function) { // No suitable function was found to call. (This can happen, for // instance, if the current function is the only function in the // module.) return; } ApplyTransformation(TransformationFunctionCall( GetFuzzerContext()->GetFreshId(), chosen_function->result_id(), ChooseFunctionCallArguments(*chosen_function, function, block, inst_it), instruction_descriptor)); }); } std::vector FuzzerPassAddFunctionCalls::ChooseFunctionCallArguments( const opt::Function& callee, opt::Function* caller_function, opt::BasicBlock* caller_block, const opt::BasicBlock::iterator& caller_inst_it) { auto available_pointers = FindAvailableInstructions( caller_function, caller_block, caller_inst_it, [this, caller_block](opt::IRContext* /*unused*/, opt::Instruction* inst) { if (inst->opcode() != spv::Op::OpVariable || inst->opcode() != spv::Op::OpFunctionParameter) { // Function parameters and variables are the only // kinds of pointer that can be used as actual // parameters. return false; } return GetTransformationContext()->GetFactManager()->BlockIsDead( caller_block->id()) || GetTransformationContext() ->GetFactManager() ->PointeeValueIsIrrelevant(inst->result_id()); }); std::unordered_map> type_id_to_result_id; for (const auto* inst : available_pointers) { type_id_to_result_id[inst->type_id()].push_back(inst->result_id()); } std::vector result; for (const auto* param : fuzzerutil::GetParameters(GetIRContext(), callee.result_id())) { const auto* param_type = GetIRContext()->get_type_mgr()->GetType(param->type_id()); assert(param_type && "Parameter has invalid type"); if (!param_type->AsPointer()) { if (fuzzerutil::CanCreateConstant(GetIRContext(), param->type_id())) { // We mark the constant as irrelevant so that we can replace it with a // more interesting value later. result.push_back(FindOrCreateZeroConstant(param->type_id(), true)); } else { result.push_back(FindOrCreateGlobalUndef(param->type_id())); } continue; } if (type_id_to_result_id.count(param->type_id())) { // Use an existing pointer if there are any. const auto& candidates = type_id_to_result_id[param->type_id()]; result.push_back(candidates[GetFuzzerContext()->RandomIndex(candidates)]); continue; } // Make a new variable, at function or global scope depending on the storage // class of the pointer. // Get a fresh id for the new variable. uint32_t fresh_variable_id = GetFuzzerContext()->GetFreshId(); // The id of this variable is what we pass as the parameter to // the call. result.push_back(fresh_variable_id); type_id_to_result_id[param->type_id()].push_back(fresh_variable_id); // Now bring the variable into existence. auto storage_class = param_type->AsPointer()->storage_class(); auto pointee_type_id = fuzzerutil::GetPointeeTypeIdFromPointerType( GetIRContext(), param->type_id()); if (storage_class == spv::StorageClass::Function) { // Add a new zero-initialized local variable to the current // function, noting that its pointee value is irrelevant. ApplyTransformation(TransformationAddLocalVariable( fresh_variable_id, param->type_id(), caller_function->result_id(), FindOrCreateZeroConstant(pointee_type_id, false), true)); } else { assert((storage_class == spv::StorageClass::Private || storage_class == spv::StorageClass::Workgroup) && "Only Function, Private and Workgroup storage classes are " "supported at present."); // Add a new global variable to the module, zero-initializing it if // it has Private storage class, and noting that its pointee value is // irrelevant. ApplyTransformation(TransformationAddGlobalVariable( fresh_variable_id, param->type_id(), storage_class, storage_class == spv::StorageClass::Private ? FindOrCreateZeroConstant(pointee_type_id, false) : 0, true)); } } return result; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_function_calls.h000066400000000000000000000036161475742701700274540ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_ADD_FUNCTION_CALLS_H_ #define SOURCE_FUZZ_FUZZER_PASS_ADD_FUNCTION_CALLS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // Fuzzer pass that adds calls at random to (a) livesafe functions, from // anywhere, and (b) any functions, from dead blocks. class FuzzerPassAddFunctionCalls : public FuzzerPass { public: FuzzerPassAddFunctionCalls(opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; private: // Randomly chooses suitable arguments to invoke |callee| right before // instruction |caller_inst_it| of block |caller_block| in |caller_function|, // based on both existing available instructions and the addition of new // instructions to the module. std::vector ChooseFunctionCallArguments( const opt::Function& callee, opt::Function* caller_function, opt::BasicBlock* caller_block, const opt::BasicBlock::iterator& caller_inst_it); }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_ADD_FUNCTION_CALLS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_global_variables.cpp000066400000000000000000000100661475742701700302710ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_add_global_variables.h" #include "source/fuzz/transformation_add_global_variable.h" #include "source/fuzz/transformation_add_type_pointer.h" namespace spvtools { namespace fuzz { FuzzerPassAddGlobalVariables::FuzzerPassAddGlobalVariables( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassAddGlobalVariables::Apply() { spv::StorageClass variable_storage_class = spv::StorageClass::Private; for (auto& entry_point : GetIRContext()->module()->entry_points()) { // If the execution model of some entry point is GLCompute, // then the variable storage class may be Workgroup. if (spv::ExecutionModel(entry_point.GetSingleWordInOperand(0)) == spv::ExecutionModel::GLCompute) { variable_storage_class = GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfChoosingWorkgroupStorageClass()) ? spv::StorageClass::Workgroup : spv::StorageClass::Private; break; } } auto basic_type_ids_and_pointers = GetAvailableBasicTypesAndPointers(variable_storage_class); // These are the basic types that are available to this fuzzer pass. auto& basic_types = basic_type_ids_and_pointers.first; if (basic_types.empty()) { // There are no basic types, so there is nothing this fuzzer pass can do. return; } // These are the pointers to those basic types that are *initially* available // to the fuzzer pass. The fuzzer pass might add pointer types in cases where // none are available for a given basic type. auto& basic_type_to_pointers = basic_type_ids_and_pointers.second; // Probabilistically keep adding global variables. while (GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfAddingGlobalVariable())) { // Choose a random basic type; the new variable's type will be a pointer to // this basic type. uint32_t basic_type = basic_types[GetFuzzerContext()->RandomIndex(basic_types)]; uint32_t pointer_type_id; std::vector& available_pointers_to_basic_type = basic_type_to_pointers.at(basic_type); // Determine whether there is at least one pointer to this basic type. if (available_pointers_to_basic_type.empty()) { // There is not. Make one, to use here, and add it to the available // pointers for the basic type so that future variables can potentially // use it. pointer_type_id = GetFuzzerContext()->GetFreshId(); available_pointers_to_basic_type.push_back(pointer_type_id); ApplyTransformation(TransformationAddTypePointer( pointer_type_id, variable_storage_class, basic_type)); } else { // There is - grab one. pointer_type_id = available_pointers_to_basic_type[GetFuzzerContext()->RandomIndex( available_pointers_to_basic_type)]; } ApplyTransformation(TransformationAddGlobalVariable( GetFuzzerContext()->GetFreshId(), pointer_type_id, variable_storage_class, variable_storage_class == spv::StorageClass::Private ? FindOrCreateZeroConstant(basic_type, false) : 0, true)); } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_global_variables.h000066400000000000000000000024731475742701700277410ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_ADD_GLOBAL_VARIABLES_H_ #define SOURCE_FUZZ_FUZZER_PASS_ADD_GLOBAL_VARIABLES_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // Fuzzer pass that randomly adds global variables, with Private storage class, // to the module. class FuzzerPassAddGlobalVariables : public FuzzerPass { public: FuzzerPassAddGlobalVariables( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_ADD_GLOBAL_VARIABLES_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_image_sample_unused_components.cpp000066400000000000000000000201321475742701700332470ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_add_image_sample_unused_components.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/transformation_add_image_sample_unused_components.h" #include "source/fuzz/transformation_composite_construct.h" namespace spvtools { namespace fuzz { FuzzerPassAddImageSampleUnusedComponents:: FuzzerPassAddImageSampleUnusedComponents( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassAddImageSampleUnusedComponents::Apply() { // SPIR-V module to help understand the transformation. // // OpCapability Shader // %1 = OpExtInstImport "GLSL.std.450" // OpMemoryModel Logical GLSL450 // OpEntryPoint Fragment %15 "main" %12 %14 // OpExecutionMode %15 OriginUpperLeft // // ; Decorations // OpDecorate %12 Location 0 ; Input color variable location // OpDecorate %13 DescriptorSet 0 ; Image coordinate variable // descriptor set OpDecorate %13 Binding 0 ; Image coordinate // variable binding OpDecorate %14 Location 0 ; Fragment color // variable location // // ; Types // %2 = OpTypeVoid // %3 = OpTypeFunction %2 // %4 = OpTypeFloat 32 // %5 = OpTypeVector %4 2 // %6 = OpTypeVector %4 4 // %7 = OpTypeImage %4 2D 0 0 0 1 Rgba32f // %8 = OpTypeSampledImage %7 // %9 = OpTypePointer Input %5 // %10 = OpTypePointer UniformConstant %8 // %11 = OpTypePointer Output %6 // // ; Variables // %12 = OpVariable %9 Input ; Input image coordinate variable // %13 = OpVariable %10 UniformConstant ; Image variable // %14 = OpVariable %11 Output ; Fragment color variable // // ; main function // %15 = OpFunction %2 None %3 // %16 = OpLabel // %17 = OpLoad %5 %12 // %18 = OpLoad %8 %13 // %19 = OpImageSampleImplicitLod %6 %18 %17 // OpStore %14 %19 // OpReturn // OpFunctionEnd GetIRContext()->module()->ForEachInst([this](opt::Instruction* instruction) { // |instruction| %19 = OpImageSampleImplicitLod %6 %18 %17 if (!spvOpcodeIsImageSample(instruction->opcode())) { return; } if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext() ->GetChanceOfAddingImageSampleUnusedComponents())) { return; } // Gets image sample coordinate information. // |coordinate_instruction| %17 = OpLoad %5 %12 uint32_t coordinate_id = instruction->GetSingleWordInOperand(1); auto coordinate_instruction = GetIRContext()->get_def_use_mgr()->GetDef(coordinate_id); auto coordinate_type = GetIRContext()->get_type_mgr()->GetType( coordinate_instruction->type_id()); // If the coordinate is a 4-dimensional vector, then no unused components // may be added. if (coordinate_type->AsVector() && coordinate_type->AsVector()->element_count() == 4) { return; } // If the coordinate is a scalar, then at most 3 unused components may be // added. If the coordinate is a vector, then the maximum number of unused // components depends on the vector size. // For the sample module, the coordinate type instruction is %5 = // OpTypeVector %4 2, thus |max_unused_component_count| = 4 - 2 = 2. uint32_t max_unused_component_count = coordinate_type->AsInteger() || coordinate_type->AsFloat() ? 3 : 4 - coordinate_type->AsVector()->element_count(); // |unused_component_count| may be 1 or 2. uint32_t unused_component_count = GetFuzzerContext()->GetRandomUnusedComponentCountForImageSample( max_unused_component_count); // Gets a type for the zero-unused components. uint32_t zero_constant_type_id; switch (unused_component_count) { case 1: // If the coordinate is an integer or float, then the unused components // type is the same as the coordinate. If the coordinate is a vector, // then the unused components type is the same as the vector components // type. zero_constant_type_id = coordinate_type->AsInteger() || coordinate_type->AsFloat() ? coordinate_instruction->type_id() : GetIRContext()->get_type_mgr()->GetId( coordinate_type->AsVector()->element_type()); break; case 2: case 3: // If the coordinate is an integer or float, then the unused components // type is the same as the coordinate. If the coordinate is a vector, // then the unused components type is the same as the coordinate // components type. // |zero_constant_type_id| %5 = OpTypeVector %4 2 zero_constant_type_id = coordinate_type->AsInteger() || coordinate_type->AsFloat() ? FindOrCreateVectorType(coordinate_instruction->type_id(), unused_component_count) : FindOrCreateVectorType( GetIRContext()->get_type_mgr()->GetId( coordinate_type->AsVector()->element_type()), unused_component_count); break; default: assert(false && "Should be unreachable."); zero_constant_type_id = 0; break; } // Gets |coordinate_type| again because the module may have changed due to // the use of FindOrCreateVectorType above. coordinate_type = GetIRContext()->get_type_mgr()->GetType( coordinate_instruction->type_id()); // If the new vector type with unused components does not exist, then create // it. |coordinate_with_unused_components_type_id| %6 = OpTypeVector %4 4 uint32_t coordinate_with_unused_components_type_id = coordinate_type->AsInteger() || coordinate_type->AsFloat() ? FindOrCreateVectorType(coordinate_instruction->type_id(), 1 + unused_component_count) : FindOrCreateVectorType( GetIRContext()->get_type_mgr()->GetId( coordinate_type->AsVector()->element_type()), coordinate_type->AsVector()->element_count() + unused_component_count); // Inserts an OpCompositeConstruct instruction which // represents the coordinate with unused components. // |coordinate_with_unused_components_id| // %22 = OpCompositeConstruct %6 %17 %21 uint32_t coordinate_with_unused_components_id = GetFuzzerContext()->GetFreshId(); ApplyTransformation(TransformationCompositeConstruct( coordinate_with_unused_components_type_id, {coordinate_instruction->result_id(), // FindOrCreateZeroConstant // %20 = OpConstant %4 0 // %21 = OpConstantComposite %5 %20 %20 FindOrCreateZeroConstant(zero_constant_type_id, true)}, MakeInstructionDescriptor(GetIRContext(), instruction), coordinate_with_unused_components_id)); // Tries to add unused components to the image sample coordinate. // %19 = OpImageSampleImplicitLod %6 %18 %22 ApplyTransformation(TransformationAddImageSampleUnusedComponents( coordinate_with_unused_components_id, MakeInstructionDescriptor(GetIRContext(), instruction))); }); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_image_sample_unused_components.h000066400000000000000000000027251475742701700327240ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_ADD_IMAGE_SAMPLE_UNUSED_COMPONENTS_H_ #define SOURCE_FUZZ_FUZZER_PASS_ADD_IMAGE_SAMPLE_UNUSED_COMPONENTS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // This fuzzer pass searches for image sample instructions in the module and // randomly applies the transformation to add unused components to the image // sample coordinate. class FuzzerPassAddImageSampleUnusedComponents : public FuzzerPass { public: FuzzerPassAddImageSampleUnusedComponents( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_ADD_IMAGE_SAMPLE_UNUSED_COMPONENTS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_loads.cpp000066400000000000000000000127161475742701700261070ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_add_loads.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/transformation_load.h" namespace spvtools { namespace fuzz { FuzzerPassAddLoads::FuzzerPassAddLoads( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassAddLoads::Apply() { ForEachInstructionWithInstructionDescriptor( [this](opt::Function* function, opt::BasicBlock* block, opt::BasicBlock::iterator inst_it, const protobufs::InstructionDescriptor& instruction_descriptor) -> void { assert( inst_it->opcode() == spv::Op(instruction_descriptor.target_instruction_opcode()) && "The opcode of the instruction we might insert before must be " "the same as the opcode in the descriptor for the instruction"); // Randomly decide whether to try inserting a load here. if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfAddingLoad())) { return; } // Check whether it is legitimate to insert a load or atomic load before // this instruction. if (!fuzzerutil::CanInsertOpcodeBeforeInstruction(spv::Op::OpLoad, inst_it)) { return; } if (!fuzzerutil::CanInsertOpcodeBeforeInstruction(spv::Op::OpAtomicLoad, inst_it)) { return; } std::vector relevant_instructions = FindAvailableInstructions( function, block, inst_it, [](opt::IRContext* context, opt::Instruction* instruction) -> bool { if (!instruction->result_id() || !instruction->type_id()) { return false; } switch (instruction->opcode()) { case spv::Op::OpConstantNull: case spv::Op::OpUndef: // Do not allow loading from a null or undefined pointer; // this might be OK if the block is dead, but for now we // conservatively avoid it. return false; default: break; } return context->get_def_use_mgr() ->GetDef(instruction->type_id()) ->opcode() == spv::Op::OpTypePointer; }); // At this point, |relevant_instructions| contains all the pointers // we might think of loading from. if (relevant_instructions.empty()) { return; } auto chosen_instruction = relevant_instructions[GetFuzzerContext()->RandomIndex( relevant_instructions)]; bool is_atomic_load = false; uint32_t memory_scope_id = 0; uint32_t memory_semantics_id = 0; auto storage_class = static_cast( GetIRContext() ->get_def_use_mgr() ->GetDef(chosen_instruction->type_id()) ->GetSingleWordInOperand(0)); switch (storage_class) { case spv::StorageClass::StorageBuffer: case spv::StorageClass::PhysicalStorageBuffer: case spv::StorageClass::Workgroup: case spv::StorageClass::CrossWorkgroup: case spv::StorageClass::AtomicCounter: case spv::StorageClass::Image: if (GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfAddingAtomicLoad())) { is_atomic_load = true; memory_scope_id = FindOrCreateConstant( {uint32_t(spv::Scope::Invocation)}, FindOrCreateIntegerType(32, GetFuzzerContext()->ChooseEven()), false); memory_semantics_id = FindOrCreateConstant( {static_cast( fuzzerutil::GetMemorySemanticsForStorageClass( storage_class))}, FindOrCreateIntegerType(32, GetFuzzerContext()->ChooseEven()), false); } break; default: break; } // Create and apply the transformation. ApplyTransformation(TransformationLoad( GetFuzzerContext()->GetFreshId(), chosen_instruction->result_id(), is_atomic_load, memory_scope_id, memory_semantics_id, instruction_descriptor)); }); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_loads.h000066400000000000000000000024501475742701700255460ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_ADD_LOADS_H_ #define SOURCE_FUZZ_FUZZER_PASS_ADD_LOADS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // Fuzzer pass that adds stores, at random, from pointers in the module. class FuzzerPassAddLoads : public FuzzerPass { public: FuzzerPassAddLoads(opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_ADD_LOADS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_local_variables.cpp000066400000000000000000000070011475742701700301160ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_add_local_variables.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/transformation_add_local_variable.h" #include "source/fuzz/transformation_add_type_pointer.h" namespace spvtools { namespace fuzz { FuzzerPassAddLocalVariables::FuzzerPassAddLocalVariables( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassAddLocalVariables::Apply() { auto basic_type_ids_and_pointers = GetAvailableBasicTypesAndPointers(spv::StorageClass::Function); // These are the basic types that are available to this fuzzer pass. auto& basic_types = basic_type_ids_and_pointers.first; if (basic_types.empty()) { // The pass cannot do anything if there are no basic types. return; } // These are the pointers to those basic types that are *initially* available // to the fuzzer pass. The fuzzer pass might add pointer types in cases where // none are available for a given basic type. auto& basic_type_to_pointers = basic_type_ids_and_pointers.second; // Consider every function in the module. for (auto& function : *GetIRContext()->module()) { // Probabilistically keep adding random variables to this function. while (GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfAddingLocalVariable())) { // Choose a random basic type; the new variable's type will be a pointer // to this basic type. uint32_t basic_type = basic_types[GetFuzzerContext()->RandomIndex(basic_types)]; uint32_t pointer_type; std::vector& available_pointers_to_basic_type = basic_type_to_pointers.at(basic_type); // Determine whether there is at least one pointer to this basic type. if (available_pointers_to_basic_type.empty()) { // There is not. Make one, to use here, and add it to the available // pointers for the basic type so that future variables can potentially // use it. pointer_type = GetFuzzerContext()->GetFreshId(); ApplyTransformation(TransformationAddTypePointer( pointer_type, spv::StorageClass::Function, basic_type)); available_pointers_to_basic_type.push_back(pointer_type); } else { // There is - grab one. pointer_type = available_pointers_to_basic_type[GetFuzzerContext()->RandomIndex( available_pointers_to_basic_type)]; } ApplyTransformation(TransformationAddLocalVariable( GetFuzzerContext()->GetFreshId(), pointer_type, function.result_id(), FindOrCreateZeroConstant(basic_type, false), true)); } } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_local_variables.h000066400000000000000000000024661475742701700275750ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_ADD_LOCAL_VARIABLES_H_ #define SOURCE_FUZZ_FUZZER_PASS_ADD_LOCAL_VARIABLES_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // Fuzzer pass that randomly adds local variables, with Function storage class, // to the module. class FuzzerPassAddLocalVariables : public FuzzerPass { public: FuzzerPassAddLocalVariables( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_ADD_LOCAL_VARIABLES_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_loop_preheaders.cpp000066400000000000000000000044051475742701700301540ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_add_loop_preheaders.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/transformation_add_loop_preheader.h" namespace spvtools { namespace fuzz { FuzzerPassAddLoopPreheaders::FuzzerPassAddLoopPreheaders( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassAddLoopPreheaders::Apply() { for (auto& function : *GetIRContext()->module()) { // Keep track of all the loop headers we want to add a preheader to. std::vector loop_header_ids_to_consider; for (auto& block : function) { // We only care about loop headers. if (!block.IsLoopHeader()) { continue; } // Randomly decide whether to consider this header. if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfAddingLoopPreheader())) { continue; } // We exclude loop headers with just one predecessor (the back-edge block) // because they are unreachable. if (GetIRContext()->cfg()->preds(block.id()).size() < 2) { continue; } loop_header_ids_to_consider.push_back(block.id()); } for (uint32_t header_id : loop_header_ids_to_consider) { // If not already present, add a preheader which is not also a loop // header. GetOrCreateSimpleLoopPreheader(header_id); } } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_loop_preheaders.h000066400000000000000000000027331475742701700276230ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_ADD_LOOP_PREHEADERS_H #define SOURCE_FUZZ_FUZZER_PASS_ADD_LOOP_PREHEADERS_H #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // A fuzzer pass that randomly adds simple loop preheaders to loops that do not // have one. A simple loop preheader is a block that: // - is the only out-of-loop predecessor of the header // - branches unconditionally to the header // - is not a loop header itself class FuzzerPassAddLoopPreheaders : public FuzzerPass { public: FuzzerPassAddLoopPreheaders( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_ADD_LOOP_PREHEADERS_H fuzzer_pass_add_loops_to_create_int_constant_synonyms.cpp000066400000000000000000000250571475742701700346530ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/fuzz// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_add_loops_to_create_int_constant_synonyms.h" #include "source/fuzz/call_graph.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/transformation_add_loop_to_create_int_constant_synonym.h" namespace spvtools { namespace fuzz { namespace { uint32_t kMaxNestingDepth = 4; } // namespace FuzzerPassAddLoopsToCreateIntConstantSynonyms:: FuzzerPassAddLoopsToCreateIntConstantSynonyms( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassAddLoopsToCreateIntConstantSynonyms::Apply() { std::vector constants; // Choose the constants for which to create synonyms. for (auto constant_def : GetIRContext()->GetConstants()) { // Randomly decide whether to consider this constant. if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfCreatingIntSynonymsUsingLoops())) { continue; } auto constant = GetIRContext()->get_constant_mgr()->FindDeclaredConstant( constant_def->result_id()); // We do not consider irrelevant constants if (GetTransformationContext()->GetFactManager()->IdIsIrrelevant( constant_def->result_id())) { continue; } // We only consider integer constants (scalar or vector). if (!constant->AsIntConstant() && !(constant->AsVectorConstant() && constant->AsVectorConstant()->component_type()->AsInteger())) { continue; } constants.push_back(constant_def->result_id()); } std::vector blocks; // Get a list of all the blocks before which we can add a loop creating a new // synonym. We cannot apply the transformation while iterating over the // module, because we are going to add new blocks. for (auto& function : *GetIRContext()->module()) { // Consider all non-dead blocks reachable from the first block of the // function. GetIRContext()->cfg()->ForEachBlockInPostOrder( &*function.begin(), [this, &blocks](opt::BasicBlock* block) { if (!GetTransformationContext()->GetFactManager()->BlockIsDead( block->id())) { blocks.push_back(block->id()); } }); } // Make sure that the module has an OpTypeBool instruction, and 32-bit signed // integer constants 0 and 1, adding them if necessary. FindOrCreateBoolType(); FindOrCreateIntegerConstant({0}, 32, true, false); FindOrCreateIntegerConstant({1}, 32, true, false); // Compute the call graph. We can use this for any further computation, since // we are not adding or removing functions or function calls. auto call_graph = CallGraph(GetIRContext()); // Consider each constant and each block. for (uint32_t constant_id : constants) { // Choose one of the blocks. uint32_t block_id = blocks[GetFuzzerContext()->RandomIndex(blocks)]; // Adjust the block so that the transformation can be applied. auto block = GetIRContext()->get_instr_block(block_id); // If the block is a loop header, add a simple preheader. We can do this // because we have excluded all the non-reachable headers. if (block->IsLoopHeader()) { block = GetOrCreateSimpleLoopPreheader(block->id()); block_id = block->id(); } assert(!block->IsLoopHeader() && "The block cannot be a loop header at this point."); // If the block is a merge block, a continue block or it does not have // exactly 1 predecessor, split it after any OpPhi or OpVariable // instructions. if (GetIRContext()->GetStructuredCFGAnalysis()->IsMergeBlock(block->id()) || GetIRContext()->GetStructuredCFGAnalysis()->IsContinueBlock( block->id()) || GetIRContext()->cfg()->preds(block->id()).size() != 1) { block = SplitBlockAfterOpPhiOrOpVariable(block->id()); block_id = block->id(); } // Randomly decide the values for the number of iterations and the step // value, and compute the initial value accordingly. // The maximum number of iterations depends on the maximum possible loop // nesting depth of the block, computed interprocedurally, i.e. also // considering the possibility that the enclosing function is called inside // a loop. It is: // - 1 if the nesting depth is >= kMaxNestingDepth // - 2^(kMaxNestingDepth - nesting_depth) otherwise uint32_t max_nesting_depth = call_graph.GetMaxCallNestingDepth(block->GetParent()->result_id()) + GetIRContext()->GetStructuredCFGAnalysis()->LoopNestingDepth( block->id()); uint32_t num_iterations = max_nesting_depth >= kMaxNestingDepth ? 1 : GetFuzzerContext()->GetRandomNumberOfLoopIterations( 1u << (kMaxNestingDepth - max_nesting_depth)); // Find or create the corresponding constant containing the number of // iterations. uint32_t num_iterations_id = FindOrCreateIntegerConstant({num_iterations}, 32, true, false); // Find the other constants. // We use 64-bit values and then use the bits that we need. We find the // step value (S) randomly and then compute the initial value (I) using // the equation I = C + S*N. uint32_t initial_value_id = 0; uint32_t step_value_id = 0; // Get the content of the existing constant. const auto constant = GetIRContext()->get_constant_mgr()->FindDeclaredConstant(constant_id); const auto constant_type_id = GetIRContext()->get_def_use_mgr()->GetDef(constant_id)->type_id(); if (constant->AsIntConstant()) { // The constant is a scalar integer. std::tie(initial_value_id, step_value_id) = FindSuitableStepAndInitialValueConstants( constant->GetZeroExtendedValue(), constant->type()->AsInteger()->width(), constant->type()->AsInteger()->IsSigned(), num_iterations); } else { // The constant is a vector of integers. assert(constant->AsVectorConstant() && constant->AsVectorConstant()->component_type()->AsInteger() && "If the program got here, the constant should be a vector of " "integers."); // Find a constant for each component of the initial value and the step // values. std::vector initial_value_component_ids; std::vector step_value_component_ids; // Get the value, width and signedness of the components. std::vector component_values; for (auto component : constant->AsVectorConstant()->GetComponents()) { component_values.push_back(component->GetZeroExtendedValue()); } uint32_t bit_width = constant->AsVectorConstant()->component_type()->AsInteger()->width(); uint32_t is_signed = constant->AsVectorConstant() ->component_type() ->AsInteger() ->IsSigned(); for (uint64_t component_val : component_values) { uint32_t initial_val_id; uint32_t step_val_id; std::tie(initial_val_id, step_val_id) = FindSuitableStepAndInitialValueConstants(component_val, bit_width, is_signed, num_iterations); initial_value_component_ids.push_back(initial_val_id); step_value_component_ids.push_back(step_val_id); } // Find or create the vector constants. initial_value_id = FindOrCreateCompositeConstant( initial_value_component_ids, constant_type_id, false); step_value_id = FindOrCreateCompositeConstant(step_value_component_ids, constant_type_id, false); } assert(initial_value_id && step_value_id && "|initial_value_id| and |step_value_id| should have been defined."); // Randomly decide whether to have two blocks (or just one) in the new // loop. uint32_t additional_block_id = GetFuzzerContext()->ChoosePercentage( GetFuzzerContext() ->GetChanceOfHavingTwoBlocksInLoopToCreateIntSynonym()) ? GetFuzzerContext()->GetFreshId() : 0; // Add the loop and create the synonym. ApplyTransformation(TransformationAddLoopToCreateIntConstantSynonym( constant_id, initial_value_id, step_value_id, num_iterations_id, block_id, GetFuzzerContext()->GetFreshId(), GetFuzzerContext()->GetFreshId(), GetFuzzerContext()->GetFreshId(), GetFuzzerContext()->GetFreshId(), GetFuzzerContext()->GetFreshId(), GetFuzzerContext()->GetFreshId(), GetFuzzerContext()->GetFreshId(), additional_block_id)); } } std::pair FuzzerPassAddLoopsToCreateIntConstantSynonyms:: FindSuitableStepAndInitialValueConstants(uint64_t constant_val, uint32_t bit_width, bool is_signed, uint32_t num_iterations) { // Choose the step value randomly and compute the initial value accordingly. // The result of |initial_value| could overflow, but this is OK, since // the transformation takes overflows into consideration (the equation still // holds as long as the last |bit_width| bits of C and of (I-S*N) match). uint64_t step_value = GetFuzzerContext()->GetRandomValueForStepConstantInLoop(); uint64_t initial_value = constant_val + step_value * num_iterations; uint32_t initial_val_id = FindOrCreateIntegerConstant( fuzzerutil::IntToWords(initial_value, bit_width, is_signed), bit_width, is_signed, false); uint32_t step_val_id = FindOrCreateIntegerConstant( fuzzerutil::IntToWords(step_value, bit_width, is_signed), bit_width, is_signed, false); return {initial_val_id, step_val_id}; } } // namespace fuzz } // namespace spvtoolsKhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_loops_to_create_int_constant_synonyms.h000066400000000000000000000042421475742701700343700ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_ADD_LOOPS_TO_CREATE_INT_CONSTANT_SYNONYMS_H_ #define SOURCE_FUZZ_FUZZER_PASS_ADD_LOOPS_TO_CREATE_INT_CONSTANT_SYNONYMS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // A fuzzer pass that adds synonyms for integer, scalar or vector, constants, by // adding loops that compute the same value by subtracting a value S from an // initial value I, and for N times, so that C = I - S*N. class FuzzerPassAddLoopsToCreateIntConstantSynonyms : public FuzzerPass { public: FuzzerPassAddLoopsToCreateIntConstantSynonyms( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; private: // Returns a pair (initial_val_id, step_val_id) such that both ids are // integer scalar constants of the same type as the scalar integer constant // identified by the given |constant_val|, |bit_width| and signedness, and // such that, if I is the value of initial_val_id, S is the value of // step_val_id and C is the value of the constant, the equation (C = I - S * // num_iterations) holds, (only considering the last |bit_width| bits of each // constant). std::pair FindSuitableStepAndInitialValueConstants( uint64_t constant_val, uint32_t bit_width, bool is_signed, uint32_t num_iterations); }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_ADD_LOOPS_TO_CREATE_INT_CONSTANT_SYNONYMS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_no_contraction_decorations.cpp000066400000000000000000000042101475742701700324040ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_add_no_contraction_decorations.h" #include "source/fuzz/transformation_add_no_contraction_decoration.h" namespace spvtools { namespace fuzz { FuzzerPassAddNoContractionDecorations::FuzzerPassAddNoContractionDecorations( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassAddNoContractionDecorations::Apply() { // Consider every instruction in every block in every function. for (auto& function : *GetIRContext()->module()) { for (auto& block : function) { for (auto& inst : block) { // Restrict attention to arithmetic instructions (as defined in the // SPIR-V specification). if (TransformationAddNoContractionDecoration::IsArithmetic( inst.opcode())) { // Randomly choose whether to apply the NoContraction decoration to // this arithmetic instruction. if (GetFuzzerContext()->ChoosePercentage( GetFuzzerContext() ->GetChanceOfAddingNoContractionDecoration())) { TransformationAddNoContractionDecoration transformation( inst.result_id()); ApplyTransformation(transformation); } } } } } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_no_contraction_decorations.h000066400000000000000000000025311475742701700320550ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_ADD_NO_CONTRACTION_DECORATIONS_H_ #define SOURCE_FUZZ_FUZZER_PASS_ADD_NO_CONTRACTION_DECORATIONS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // A pass that applies the NoContraction decoration to arithmetic instructions. class FuzzerPassAddNoContractionDecorations : public FuzzerPass { public: FuzzerPassAddNoContractionDecorations( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_ADD_NO_CONTRACTION_DECORATIONS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_opphi_synonyms.cpp000066400000000000000000000263151475742701700301030ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_add_opphi_synonyms.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/transformation_add_opphi_synonym.h" namespace spvtools { namespace fuzz { FuzzerPassAddOpPhiSynonyms::FuzzerPassAddOpPhiSynonyms( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassAddOpPhiSynonyms::Apply() { // Get a list of synonymous ids with the same type that can be used in the // same OpPhi instruction. auto equivalence_classes = GetIdEquivalenceClasses(); // Make a list of references, to avoid copying sets unnecessarily. std::vector*> equivalence_class_pointers; for (auto& set : equivalence_classes) { equivalence_class_pointers.push_back(&set); } // Keep a list of transformations to apply at the end. std::vector transformations_to_apply; for (auto& function : *GetIRContext()->module()) { for (auto& block : function) { // Randomly decide whether to consider this block. if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfAddingOpPhiSynonym())) { continue; } // The block must not be dead. if (GetTransformationContext()->GetFactManager()->BlockIsDead( block.id())) { continue; } // The block must have at least one predecessor. size_t num_preds = GetIRContext()->cfg()->preds(block.id()).size(); if (num_preds == 0) { continue; } std::set* chosen_equivalence_class = nullptr; if (num_preds > 1) { // If the block has more than one predecessor, prioritise sets with at // least 2 ids available at some predecessor. chosen_equivalence_class = MaybeFindSuitableEquivalenceClassRandomly( equivalence_class_pointers, block.id(), 2); } // If a set was not already chosen, choose one with at least one available // id. if (!chosen_equivalence_class) { chosen_equivalence_class = MaybeFindSuitableEquivalenceClassRandomly( equivalence_class_pointers, block.id(), 1); } // If no suitable set was found, we cannot apply the transformation to // this block. if (!chosen_equivalence_class) { continue; } // Initialise the map from predecessor labels to ids. std::map preds_to_ids; // Keep track of the ids used and of the id of a predecessor with at least // two ids to choose from. This is to ensure that, if possible, at least // two distinct ids will be used. std::set ids_chosen; uint32_t pred_with_alternatives = 0; // Choose an id for each predecessor. for (uint32_t pred_id : GetIRContext()->cfg()->preds(block.id())) { auto suitable_ids = GetSuitableIds(*chosen_equivalence_class, pred_id); assert(!suitable_ids.empty() && "We must be able to find at least one suitable id because the " "equivalence class was chosen among suitable ones."); // If this predecessor has more than one id to choose from and it is the // first one of this kind that we found, remember its id. if (suitable_ids.size() > 1 && !pred_with_alternatives) { pred_with_alternatives = pred_id; } uint32_t chosen_id = suitable_ids[GetFuzzerContext()->RandomIndex(suitable_ids)]; // Add this id to the set of ids chosen. ids_chosen.emplace(chosen_id); // Add the pair (predecessor, chosen id) to the map. preds_to_ids[pred_id] = chosen_id; } // If: // - the block has more than one predecessor // - at least one predecessor has more than one alternative // - the same id has been chosen by all the predecessors // then choose another one for the predecessor with more than one // alternative. if (num_preds > 1 && pred_with_alternatives != 0 && ids_chosen.size() == 1) { auto suitable_ids = GetSuitableIds(*chosen_equivalence_class, pred_with_alternatives); uint32_t chosen_id = GetFuzzerContext()->RemoveAtRandomIndex(&suitable_ids); if (chosen_id == preds_to_ids[pred_with_alternatives]) { chosen_id = GetFuzzerContext()->RemoveAtRandomIndex(&suitable_ids); } preds_to_ids[pred_with_alternatives] = chosen_id; } // Add the transformation to the list of transformations to apply. transformations_to_apply.emplace_back(block.id(), preds_to_ids, GetFuzzerContext()->GetFreshId()); } } // Apply the transformations. for (const auto& transformation : transformations_to_apply) { ApplyTransformation(transformation); } } std::vector> FuzzerPassAddOpPhiSynonyms::GetIdEquivalenceClasses() { std::vector> id_equivalence_classes; // Keep track of all the ids that have already be assigned to a class. std::set already_in_a_class; for (const auto& pair : GetIRContext()->get_def_use_mgr()->id_to_defs()) { // Exclude ids that have already been assigned to a class. if (already_in_a_class.count(pair.first)) { continue; } // Exclude irrelevant ids. if (GetTransformationContext()->GetFactManager()->IdIsIrrelevant( pair.first)) { continue; } // Exclude ids having a type that is not allowed by the transformation. if (!TransformationAddOpPhiSynonym::CheckTypeIsAllowed( GetIRContext(), pair.second->type_id())) { continue; } // Exclude OpFunction and OpUndef instructions, because: // - OpFunction does not yield a value; // - OpUndef yields an undefined value at each use, so it should never be a // synonym of another id. if (pair.second->opcode() == spv::Op::OpFunction || pair.second->opcode() == spv::Op::OpUndef) { continue; } // We need a new equivalence class for this id. std::set new_equivalence_class; // Add this id to the class. new_equivalence_class.emplace(pair.first); already_in_a_class.emplace(pair.first); // Add all the synonyms with the same type to this class. for (auto synonym : GetTransformationContext()->GetFactManager()->GetSynonymsForId( pair.first)) { // The synonym must be a plain id - it cannot be an indexed access into a // composite. if (synonym->index_size() > 0) { continue; } // The synonym must not be irrelevant. if (GetTransformationContext()->GetFactManager()->IdIsIrrelevant( synonym->object())) { continue; } auto synonym_def = GetIRContext()->get_def_use_mgr()->GetDef(synonym->object()); // The synonym must exist and have the same type as the id we are // considering. if (!synonym_def || synonym_def->type_id() != pair.second->type_id()) { continue; } // We can add this synonym to the new equivalence class. new_equivalence_class.emplace(synonym->object()); already_in_a_class.emplace(synonym->object()); } // Add the new equivalence class to the list of equivalence classes. id_equivalence_classes.emplace_back(std::move(new_equivalence_class)); } return id_equivalence_classes; } bool FuzzerPassAddOpPhiSynonyms::EquivalenceClassIsSuitableForBlock( const std::set& equivalence_class, uint32_t block_id, uint32_t distinct_ids_required) { bool at_least_one_id_for_each_pred = true; // Keep a set of the suitable ids found. std::set suitable_ids_found; // Loop through all the predecessors of the block. for (auto pred_id : GetIRContext()->cfg()->preds(block_id)) { // Find the last instruction in the predecessor block. auto last_instruction = GetIRContext()->get_instr_block(pred_id)->terminator(); // Initially assume that there is not a suitable id for this predecessor. bool at_least_one_suitable_id_found = false; for (uint32_t id : equivalence_class) { if (fuzzerutil::IdIsAvailableBeforeInstruction(GetIRContext(), last_instruction, id)) { // We have found a suitable id. at_least_one_suitable_id_found = true; suitable_ids_found.emplace(id); // If we have already found enough distinct suitable ids, we don't need // to check the remaining ones for this predecessor. if (suitable_ids_found.size() >= distinct_ids_required) { break; } } } // If no suitable id was found for this predecessor, this equivalence class // is not suitable and we don't need to check the other predecessors. if (!at_least_one_suitable_id_found) { at_least_one_id_for_each_pred = false; break; } } // The equivalence class is suitable if at least one suitable id was found for // each predecessor and we have found at least |distinct_ids_required| // distinct suitable ids in general. return at_least_one_id_for_each_pred && suitable_ids_found.size() >= distinct_ids_required; } std::vector FuzzerPassAddOpPhiSynonyms::GetSuitableIds( const std::set& ids, uint32_t pred_id) { // Initialise an empty vector of suitable ids. std::vector suitable_ids; // Get the predecessor block. auto predecessor = fuzzerutil::MaybeFindBlock(GetIRContext(), pred_id); // Loop through the ids to find the suitable ones. for (uint32_t id : ids) { if (fuzzerutil::IdIsAvailableBeforeInstruction( GetIRContext(), predecessor->terminator(), id)) { suitable_ids.push_back(id); } } return suitable_ids; } std::set* FuzzerPassAddOpPhiSynonyms::MaybeFindSuitableEquivalenceClassRandomly( const std::vector*>& candidates, uint32_t block_id, uint32_t distinct_ids_required) { auto remaining_candidates = candidates; while (!remaining_candidates.empty()) { // Choose one set randomly and return it if it is suitable. auto chosen = GetFuzzerContext()->RemoveAtRandomIndex(&remaining_candidates); if (EquivalenceClassIsSuitableForBlock(*chosen, block_id, distinct_ids_required)) { return chosen; } } // No suitable sets were found. return nullptr; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_opphi_synonyms.h000066400000000000000000000062731475742701700275510ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_ADD_OPPHI_SYNONYMS_H_ #define SOURCE_FUZZ_FUZZER_PASS_ADD_OPPHI_SYNONYMS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // A fuzzer pass to add OpPhi instructions which can take the values of ids that // have been marked as synonymous. This instruction will itself be marked as // synonymous with the others. class FuzzerPassAddOpPhiSynonyms : public FuzzerPass { public: FuzzerPassAddOpPhiSynonyms(opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; // Computes the equivalence classes for the non-pointer and non-irrelevant ids // in the module, where two ids are considered equivalent iff they have been // declared synonymous and they have the same type. std::vector> GetIdEquivalenceClasses(); // Returns true iff |equivalence_class| contains at least // |distinct_ids_required| ids so that all of these ids are available at the // end of at least one predecessor of the block with label |block_id|. // Assumes that the block has at least one predecessor. bool EquivalenceClassIsSuitableForBlock( const std::set& equivalence_class, uint32_t block_id, uint32_t distinct_ids_required); // Returns a vector with the ids that are available to use at the end of the // block with id |pred_id|, selected among the given |ids|. Assumes that // |pred_id| is the label of a block and all ids in |ids| exist in the module. std::vector GetSuitableIds(const std::set& ids, uint32_t pred_id); private: // Randomly chooses one of the equivalence classes in |candidates|, so that it // satisfies all of the following conditions: // - For each of the predecessors of the |block_id| block, there is at least // one id in the chosen equivalence class that is available at the end of // it. // - There are at least |distinct_ids_required| ids available at the end of // some predecessor. // Returns nullptr if no equivalence class in |candidates| satisfies the // requirements. std::set* MaybeFindSuitableEquivalenceClassRandomly( const std::vector*>& candidates, uint32_t block_id, uint32_t distinct_ids_required); }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_ADD_OPPHI_SYNONYMS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_parameters.cpp000066400000000000000000000130001475742701700271330ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_add_parameters.h" #include "source/fuzz/fuzzer_context.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/transformation_add_parameter.h" namespace spvtools { namespace fuzz { FuzzerPassAddParameters::FuzzerPassAddParameters( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassAddParameters::Apply() { // Compute type candidates for the new parameter. std::vector type_candidates; for (const auto& type_inst : GetIRContext()->module()->GetTypes()) { if (TransformationAddParameter::IsParameterTypeSupported( GetIRContext(), type_inst->result_id())) { type_candidates.push_back(type_inst->result_id()); } } if (type_candidates.empty()) { // The module contains no suitable types to use in new parameters. return; } // Iterate over all functions in the module. for (const auto& function : *GetIRContext()->module()) { // Skip all entry-point functions - we don't want to change those. if (fuzzerutil::FunctionIsEntryPoint(GetIRContext(), function.result_id())) { continue; } if (GetNumberOfParameters(function) >= GetFuzzerContext()->GetMaximumNumberOfFunctionParameters()) { continue; } if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfAddingParameters())) { continue; } auto num_new_parameters = GetFuzzerContext()->GetRandomNumberOfNewParameters( GetNumberOfParameters(function)); for (uint32_t i = 0; i < num_new_parameters; ++i) { auto current_type_id = type_candidates[GetFuzzerContext()->RandomIndex(type_candidates)]; auto current_type = GetIRContext()->get_type_mgr()->GetType(current_type_id); std::map call_parameter_ids; // Consider the case when a pointer type was selected. if (current_type->kind() == opt::analysis::Type::kPointer) { auto storage_class = fuzzerutil::GetStorageClassFromPointerType( GetIRContext(), current_type_id); switch (storage_class) { case spv::StorageClass::Function: { // In every caller find or create a local variable that has the // selected type. for (auto* instr : fuzzerutil::GetCallers(GetIRContext(), function.result_id())) { auto block = GetIRContext()->get_instr_block(instr); auto function_id = block->GetParent()->result_id(); uint32_t variable_id = FindOrCreateLocalVariable(current_type_id, function_id, true); call_parameter_ids[instr->result_id()] = variable_id; } } break; case spv::StorageClass::Private: case spv::StorageClass::Workgroup: { // If there exists at least one caller, find or create a global // variable that has the selected type. std::vector callers = fuzzerutil::GetCallers(GetIRContext(), function.result_id()); if (!callers.empty()) { uint32_t variable_id = FindOrCreateGlobalVariable(current_type_id, true); for (auto* instr : callers) { call_parameter_ids[instr->result_id()] = variable_id; } } } break; default: break; } } else { // If there exists at least one caller, find or create a zero constant // that has the selected type. std::vector callers = fuzzerutil::GetCallers(GetIRContext(), function.result_id()); if (!callers.empty()) { uint32_t constant_id = FindOrCreateZeroConstant(current_type_id, true); for (auto* instr : fuzzerutil::GetCallers(GetIRContext(), function.result_id())) { call_parameter_ids[instr->result_id()] = constant_id; } } } ApplyTransformation(TransformationAddParameter( function.result_id(), GetFuzzerContext()->GetFreshId(), current_type_id, std::move(call_parameter_ids), GetFuzzerContext()->GetFreshId())); } } } uint32_t FuzzerPassAddParameters::GetNumberOfParameters( const opt::Function& function) const { const auto* type = GetIRContext()->get_type_mgr()->GetType( function.DefInst().GetSingleWordInOperand(1)); assert(type && type->AsFunction()); return static_cast(type->AsFunction()->param_types().size()); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_parameters.h000066400000000000000000000032121475742701700266040ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_ADD_PARAMETERS_H_ #define SOURCE_FUZZ_FUZZER_PASS_ADD_PARAMETERS_H_ #include #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // Randomly decides for each non-entry-point function in the module whether to // add new parameters to it. If so, randomly determines the number of parameters // to add, their type and creates constants used to initialize them. class FuzzerPassAddParameters : public FuzzerPass { public: FuzzerPassAddParameters(opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; private: // Returns number of parameters of |function|. uint32_t GetNumberOfParameters(const opt::Function& function) const; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_ADD_PARAMETERS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_relaxed_decorations.cpp000066400000000000000000000043551475742701700310230ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_add_relaxed_decorations.h" #include "source/fuzz/transformation_add_relaxed_decoration.h" namespace spvtools { namespace fuzz { FuzzerPassAddRelaxedDecorations::FuzzerPassAddRelaxedDecorations( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassAddRelaxedDecorations::Apply() { // Consider every instruction in every block in every function. for (auto& function : *GetIRContext()->module()) { for (auto& block : function) { for (auto& inst : block) { // Randomly choose whether to apply the RelaxedPrecision decoration // to this instruction. if (GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfAddingRelaxedDecoration())) { TransformationAddRelaxedDecoration transformation(inst.result_id()); // Restrict attention to numeric instructions (returning 32-bit // floats or ints according to SPIR-V documentation) in dead blocks. if (transformation.IsApplicable(GetIRContext(), *GetTransformationContext())) { transformation.Apply(GetIRContext(), GetTransformationContext()); *GetTransformations()->add_transformation() = transformation.ToMessage(); } } } } } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_relaxed_decorations.h000066400000000000000000000024571475742701700304710ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_ADD_RELAXED_DECORATIONS_H_ #define SOURCE_FUZZ_FUZZER_PASS_ADD_RELAXED_DECORATIONS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // A pass that applies the Relaxed decoration to numeric instructions. class FuzzerPassAddRelaxedDecorations : public FuzzerPass { public: FuzzerPassAddRelaxedDecorations( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_ADD_RELAXED_DECORATIONS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_stores.cpp000066400000000000000000000156161475742701700263260ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_add_stores.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/transformation_store.h" namespace spvtools { namespace fuzz { FuzzerPassAddStores::FuzzerPassAddStores( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassAddStores::Apply() { ForEachInstructionWithInstructionDescriptor( [this](opt::Function* function, opt::BasicBlock* block, opt::BasicBlock::iterator inst_it, const protobufs::InstructionDescriptor& instruction_descriptor) -> void { assert( inst_it->opcode() == spv::Op(instruction_descriptor.target_instruction_opcode()) && "The opcode of the instruction we might insert before must be " "the same as the opcode in the descriptor for the instruction"); // Randomly decide whether to try inserting a store here. if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfAddingStore())) { return; } // Check whether it is legitimate to insert a store before this // instruction. if (!fuzzerutil::CanInsertOpcodeBeforeInstruction(spv::Op::OpStore, inst_it)) { return; } if (!fuzzerutil::CanInsertOpcodeBeforeInstruction( spv::Op::OpAtomicStore, inst_it)) { return; } // Look for pointers we might consider storing to. std::vector relevant_pointers = FindAvailableInstructions( function, block, inst_it, [this, block](opt::IRContext* context, opt::Instruction* instruction) -> bool { if (!instruction->result_id() || !instruction->type_id()) { return false; } auto type_inst = context->get_def_use_mgr()->GetDef( instruction->type_id()); if (type_inst->opcode() != spv::Op::OpTypePointer) { // Not a pointer. return false; } if (instruction->IsReadOnlyPointer()) { // Read only: cannot store to it. return false; } switch (instruction->opcode()) { case spv::Op::OpConstantNull: case spv::Op::OpUndef: // Do not allow storing to a null or undefined pointer; // this might be OK if the block is dead, but for now we // conservatively avoid it. return false; default: break; } return GetTransformationContext() ->GetFactManager() ->BlockIsDead(block->id()) || GetTransformationContext() ->GetFactManager() ->PointeeValueIsIrrelevant( instruction->result_id()); }); // At this point, |relevant_pointers| contains all the pointers we might // think of storing to. if (relevant_pointers.empty()) { return; } auto pointer = relevant_pointers[GetFuzzerContext()->RandomIndex( relevant_pointers)]; std::vector relevant_values = FindAvailableInstructions( function, block, inst_it, [pointer](opt::IRContext* context, opt::Instruction* instruction) -> bool { if (!instruction->result_id() || !instruction->type_id()) { return false; } return instruction->type_id() == context->get_def_use_mgr() ->GetDef(pointer->type_id()) ->GetSingleWordInOperand(1); }); if (relevant_values.empty()) { return; } bool is_atomic_store = false; uint32_t memory_scope_id = 0; uint32_t memory_semantics_id = 0; auto storage_class = static_cast(GetIRContext() ->get_def_use_mgr() ->GetDef(pointer->type_id()) ->GetSingleWordInOperand(0)); switch (storage_class) { case spv::StorageClass::StorageBuffer: case spv::StorageClass::PhysicalStorageBuffer: case spv::StorageClass::Workgroup: case spv::StorageClass::CrossWorkgroup: case spv::StorageClass::AtomicCounter: case spv::StorageClass::Image: if (GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfAddingAtomicStore())) { is_atomic_store = true; memory_scope_id = FindOrCreateConstant( {uint32_t(spv::Scope::Invocation)}, FindOrCreateIntegerType(32, GetFuzzerContext()->ChooseEven()), false); memory_semantics_id = FindOrCreateConstant( {static_cast( fuzzerutil::GetMemorySemanticsForStorageClass( storage_class))}, FindOrCreateIntegerType(32, GetFuzzerContext()->ChooseEven()), false); } break; default: break; } // Create and apply the transformation. ApplyTransformation(TransformationStore( pointer->result_id(), is_atomic_store, memory_scope_id, memory_semantics_id, relevant_values[GetFuzzerContext()->RandomIndex(relevant_values)] ->result_id(), instruction_descriptor)); }); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_stores.h000066400000000000000000000026741475742701700257730ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_ADD_STORES_H_ #define SOURCE_FUZZ_FUZZER_PASS_ADD_STORES_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // Fuzzer pass that adds stores, at random, through pointers in the module, // either (a) from dead blocks, or (b) through pointers whose pointee values // are known not to affect the module's overall behaviour. class FuzzerPassAddStores : public FuzzerPass { public: FuzzerPassAddStores(opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_ADD_STORES_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_synonyms.cpp000066400000000000000000000132451475742701700267020ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_add_synonyms.h" #include "source/fuzz/fuzzer_context.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/transformation_add_synonym.h" namespace spvtools { namespace fuzz { FuzzerPassAddSynonyms::FuzzerPassAddSynonyms( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassAddSynonyms::Apply() { ForEachInstructionWithInstructionDescriptor( [this](opt::Function* function, opt::BasicBlock* block, opt::BasicBlock::iterator inst_it, const protobufs::InstructionDescriptor& instruction_descriptor) { if (GetTransformationContext()->GetFactManager()->BlockIsDead( block->id())) { // Don't create synonyms in dead blocks. return; } // Skip |inst_it| if we can't insert anything above it. OpIAdd is just // a representative of some instruction that might be produced by the // transformation. if (!fuzzerutil::CanInsertOpcodeBeforeInstruction(spv::Op::OpIAdd, inst_it)) { return; } if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfAddingSynonyms())) { return; } auto synonym_type = GetFuzzerContext()->GetRandomSynonymType(); // Select all instructions that can be used to create a synonym to. auto available_instructions = FindAvailableInstructions( function, block, inst_it, [synonym_type, this](opt::IRContext* ir_context, opt::Instruction* inst) { // Check that we can create a synonym to |inst| as described by // the |synonym_type| and insert it before |inst_it|. return TransformationAddSynonym::IsInstructionValid( ir_context, *GetTransformationContext(), inst, synonym_type); }); if (available_instructions.empty()) { return; } const auto* existing_synonym = available_instructions[GetFuzzerContext()->RandomIndex( available_instructions)]; // Make sure the module contains all instructions required to apply the // transformation. switch (synonym_type) { case protobufs::TransformationAddSynonym::ADD_ZERO: case protobufs::TransformationAddSynonym::SUB_ZERO: case protobufs::TransformationAddSynonym::LOGICAL_OR: case protobufs::TransformationAddSynonym::BITWISE_OR: case protobufs::TransformationAddSynonym::BITWISE_XOR: // Create a zero constant to be used as an operand of the synonymous // instruction. FindOrCreateZeroConstant(existing_synonym->type_id(), false); break; case protobufs::TransformationAddSynonym::MUL_ONE: case protobufs::TransformationAddSynonym::LOGICAL_AND: { const auto* existing_synonym_type = GetIRContext()->get_type_mgr()->GetType( existing_synonym->type_id()); assert(existing_synonym_type && "Instruction has invalid type"); if (const auto* vector = existing_synonym_type->AsVector()) { auto element_type_id = GetIRContext()->get_type_mgr()->GetId(vector->element_type()); assert(element_type_id && "Vector's element type is invalid"); auto one_word = vector->element_type()->AsFloat() ? fuzzerutil::FloatToWord(1) : 1u; FindOrCreateCompositeConstant( std::vector( vector->element_count(), FindOrCreateConstant({one_word}, element_type_id, false)), existing_synonym->type_id(), false); } else { FindOrCreateConstant( {existing_synonym_type->AsFloat() ? fuzzerutil::FloatToWord(1) : 1u}, existing_synonym->type_id(), false); } } break; default: // This assertion will fail if some SynonymType is missing from the // switch statement. assert( !TransformationAddSynonym::IsAdditionalConstantRequired( synonym_type) && "|synonym_type| requires an additional constant to be present " "in the module"); break; } ApplyTransformation(TransformationAddSynonym( existing_synonym->result_id(), synonym_type, GetFuzzerContext()->GetFreshId(), instruction_descriptor)); }); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_synonyms.h000066400000000000000000000025461475742701700263510ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_ADD_SYNONYMS_H_ #define SOURCE_FUZZ_FUZZER_PASS_ADD_SYNONYMS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // Sprinkles instructions through the module that produce ids, synonymous to // some other instructions. class FuzzerPassAddSynonyms : public FuzzerPass { public: FuzzerPassAddSynonyms(opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_ADD_SYNONYMS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_vector_shuffle_instructions.cpp000066400000000000000000000144621475742701700326470ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_add_vector_shuffle_instructions.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/transformation_vector_shuffle.h" namespace spvtools { namespace fuzz { FuzzerPassAddVectorShuffleInstructions::FuzzerPassAddVectorShuffleInstructions( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassAddVectorShuffleInstructions::Apply() { ForEachInstructionWithInstructionDescriptor( [this](opt::Function* function, opt::BasicBlock* block, opt::BasicBlock::iterator instruction_iterator, const protobufs::InstructionDescriptor& instruction_descriptor) -> void { assert( instruction_iterator->opcode() == spv::Op(instruction_descriptor.target_instruction_opcode()) && "The opcode of the instruction we might insert before must be " "the same as the opcode in the descriptor for the instruction"); // Randomly decide whether to try adding an OpVectorShuffle instruction. if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfAddingVectorShuffle())) { return; } // It must be valid to insert an OpVectorShuffle instruction // before |instruction_iterator|. if (!fuzzerutil::CanInsertOpcodeBeforeInstruction( spv::Op::OpVectorShuffle, instruction_iterator)) { return; } // Looks for vectors that we might consider to use as OpVectorShuffle // operands. std::vector vector_instructions = FindAvailableInstructions( function, block, instruction_iterator, [this, instruction_descriptor]( opt::IRContext* ir_context, opt::Instruction* instruction) -> bool { if (!instruction->result_id() || !instruction->type_id()) { return false; } if (!ir_context->get_type_mgr() ->GetType(instruction->type_id()) ->AsVector()) { return false; } if (!GetTransformationContext() ->GetFactManager() ->IdIsIrrelevant(instruction->result_id()) && !fuzzerutil::CanMakeSynonymOf(ir_context, *GetTransformationContext(), *instruction)) { // If the id is irrelevant, we can use it since it will not // participate in DataSynonym fact. Otherwise, we should be // able to produce a synonym out of the id. return false; } return fuzzerutil::IdIsAvailableBeforeInstruction( ir_context, FindInstruction(instruction_descriptor, ir_context), instruction->result_id()); }); // If there are no vector instructions, then return. if (vector_instructions.empty()) { return; } auto vector_1_instruction = vector_instructions[GetFuzzerContext()->RandomIndex( vector_instructions)]; auto vector_1_type = GetIRContext() ->get_type_mgr() ->GetType(vector_1_instruction->type_id()) ->AsVector(); auto vector_2_instruction = GetFuzzerContext()->RemoveAtRandomIndex(&vector_instructions); auto vector_2_type = GetIRContext() ->get_type_mgr() ->GetType(vector_2_instruction->type_id()) ->AsVector(); // |vector_1| and |vector_2| must have the same element type as each // other. The loop is guaranteed to terminate because each iteration // removes on possible choice for |vector_2|, and there is at least one // choice that will cause the loop to exit - namely |vector_1|. while (vector_1_type->element_type() != vector_2_type->element_type()) { vector_2_instruction = GetFuzzerContext()->RemoveAtRandomIndex(&vector_instructions); vector_2_type = GetIRContext() ->get_type_mgr() ->GetType(vector_2_instruction->type_id()) ->AsVector(); } // Gets components and creates the appropriate result vector type. std::vector components = GetFuzzerContext()->GetRandomComponentsForVectorShuffle( vector_1_type->element_count() + vector_2_type->element_count()); FindOrCreateVectorType(GetIRContext()->get_type_mgr()->GetId( vector_1_type->element_type()), static_cast(components.size())); // Applies the vector shuffle transformation. ApplyTransformation(TransformationVectorShuffle( instruction_descriptor, GetFuzzerContext()->GetFreshId(), vector_1_instruction->result_id(), vector_2_instruction->result_id(), components)); }); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_add_vector_shuffle_instructions.h000066400000000000000000000025141475742701700323070ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_ADD_VECTOR_SHUFFLE_INSTRUCTIONS_H_ #define SOURCE_FUZZ_FUZZER_PASS_ADD_VECTOR_SHUFFLE_INSTRUCTIONS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // Adds OpVectorShuffle instructions to the module. class FuzzerPassAddVectorShuffleInstructions : public FuzzerPass { public: FuzzerPassAddVectorShuffleInstructions( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_ADD_VECTOR_SHUFFLE_INSTRUCTIONS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_adjust_branch_weights.cpp000066400000000000000000000035731475742701700305370ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_adjust_branch_weights.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/transformation_adjust_branch_weights.h" namespace spvtools { namespace fuzz { FuzzerPassAdjustBranchWeights::FuzzerPassAdjustBranchWeights( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassAdjustBranchWeights::Apply() { // For all OpBranchConditional instructions, // randomly applies the transformation. GetIRContext()->module()->ForEachInst([this](opt::Instruction* instruction) { if (instruction->opcode() == spv::Op::OpBranchConditional && GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfAdjustingBranchWeights())) { ApplyTransformation(TransformationAdjustBranchWeights( MakeInstructionDescriptor(GetIRContext(), instruction), GetFuzzerContext()->GetRandomBranchWeights())); } }); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_adjust_branch_weights.h000066400000000000000000000026021475742701700301740ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_ADJUST_BRANCH_WEIGHTS_H_ #define SOURCE_FUZZ_FUZZER_PASS_ADJUST_BRANCH_WEIGHTS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // This fuzzer pass searches for branch conditional instructions // and randomly chooses which of these instructions will have their weights // adjusted. class FuzzerPassAdjustBranchWeights : public FuzzerPass { public: FuzzerPassAdjustBranchWeights( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_ADJUST_BRANCH_WEIGHTS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_adjust_function_controls.cpp000066400000000000000000000057551475742701700313240ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_adjust_function_controls.h" #include "source/fuzz/transformation_set_function_control.h" namespace spvtools { namespace fuzz { FuzzerPassAdjustFunctionControls::FuzzerPassAdjustFunctionControls( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassAdjustFunctionControls::Apply() { // Consider every function in the module. for (auto& function : *GetIRContext()->module()) { // Randomly decide whether to adjust this function's controls. if (GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfAdjustingFunctionControl())) { // Grab the function control mask for the function in its present form. uint32_t existing_function_control_mask = function.DefInst().GetSingleWordInOperand(0); // For the new mask, we first randomly select one of three basic masks: // None, Inline or DontInline. These are always valid (and are mutually // exclusive). std::vector basic_function_control_masks = { spv::FunctionControlMask::MaskNone, spv::FunctionControlMask::Inline, spv::FunctionControlMask::DontInline}; uint32_t new_function_control_mask = uint32_t(basic_function_control_masks[GetFuzzerContext()->RandomIndex( basic_function_control_masks)]); // We now consider the Pure and Const mask bits. If these are already // set on the function then it's OK to keep them, but also interesting // to consider dropping them, so we decide randomly in each case. for (auto mask_bit : {spv::FunctionControlMask::Pure, spv::FunctionControlMask::Const}) { if ((existing_function_control_mask & uint32_t(mask_bit)) && GetFuzzerContext()->ChooseEven()) { new_function_control_mask |= uint32_t(mask_bit); } } // Create and add a transformation. TransformationSetFunctionControl transformation( function.DefInst().result_id(), new_function_control_mask); ApplyTransformation(transformation); } } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_adjust_function_controls.h000066400000000000000000000024661475742701700307650ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_ADJUST_FUNCTION_CONTROLS_H_ #define SOURCE_FUZZ_FUZZER_PASS_ADJUST_FUNCTION_CONTROLS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // A pass that adjusts the function controls on OpFunction instructions. class FuzzerPassAdjustFunctionControls : public FuzzerPass { public: FuzzerPassAdjustFunctionControls( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_ADJUST_FUNCTION_CONTROLS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_adjust_loop_controls.cpp000066400000000000000000000125131475742701700304360ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_adjust_loop_controls.h" #include "source/fuzz/transformation_set_loop_control.h" namespace spvtools { namespace fuzz { FuzzerPassAdjustLoopControls::FuzzerPassAdjustLoopControls( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassAdjustLoopControls::Apply() { // Consider every merge instruction in the module (via looking through all // functions and blocks). for (auto& function : *GetIRContext()->module()) { for (auto& block : function) { if (auto merge_inst = block.GetMergeInst()) { // Ignore the instruction if it is not a loop merge. if (merge_inst->opcode() != spv::Op::OpLoopMerge) { continue; } // Decide randomly whether to adjust this loop merge. if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfAdjustingLoopControl())) { continue; } uint32_t existing_mask = merge_inst->GetSingleWordOperand( TransformationSetLoopControl::kLoopControlMaskInOperandIndex); // First, set the new mask to one of None, Unroll or DontUnroll. std::vector basic_masks = { uint32_t(spv::LoopControlMask::MaskNone), uint32_t(spv::LoopControlMask::Unroll), uint32_t(spv::LoopControlMask::DontUnroll)}; uint32_t new_mask = basic_masks[GetFuzzerContext()->RandomIndex(basic_masks)]; // For the loop controls that depend on guarantees about what the loop // does, check which of these were present in the existing mask and // randomly decide whether to keep them. They are just hints, so // removing them should not change the semantics of the module. for (auto mask_bit : {spv::LoopControlMask::DependencyInfinite, spv::LoopControlMask::DependencyLength, spv::LoopControlMask::MinIterations, spv::LoopControlMask::MaxIterations, spv::LoopControlMask::IterationMultiple}) { if ((existing_mask & uint32_t(mask_bit)) && GetFuzzerContext()->ChooseEven()) { // The mask bits we are considering are not available in all SPIR-V // versions. However, we only include a mask bit if it was present // in the original loop control mask, and we work under the // assumption that we are transforming a valid module, thus we don't // need to actually check whether the SPIR-V version being used // supports these loop control mask bits. new_mask |= uint32_t(mask_bit); } } // We use 0 for peel count and partial count in the case that we choose // not to set these controls. uint32_t peel_count = 0; uint32_t partial_count = 0; // PeelCount and PartialCount are not compatible with DontUnroll, so // we check whether DontUnroll is set. if (!(new_mask & uint32_t(spv::LoopControlMask::DontUnroll))) { // If PeelCount is supported by this SPIR-V version, randomly choose // whether to set it. If it was set in the original mask and is not // selected for setting here, that amounts to dropping it. if (TransformationSetLoopControl::PeelCountIsSupported( GetIRContext()) && GetFuzzerContext()->ChooseEven()) { new_mask |= uint32_t(spv::LoopControlMask::PeelCount); // The peel count is chosen randomly - if PeelCount was already set // this will overwrite whatever peel count was previously used. peel_count = GetFuzzerContext()->GetRandomLoopControlPeelCount(); } // Similar, but for PartialCount. if (TransformationSetLoopControl::PartialCountIsSupported( GetIRContext()) && GetFuzzerContext()->ChooseEven()) { new_mask |= uint32_t(spv::LoopControlMask::PartialCount); partial_count = GetFuzzerContext()->GetRandomLoopControlPartialCount(); } } // Apply the transformation and add it to the output transformation // sequence. TransformationSetLoopControl transformation(block.id(), new_mask, peel_count, partial_count); ApplyTransformation(transformation); } } } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_adjust_loop_controls.h000066400000000000000000000024371475742701700301070ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_ADJUST_LOOP_CONTROLS_H_ #define SOURCE_FUZZ_FUZZER_PASS_ADJUST_LOOP_CONTROLS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // A pass that adjusts the loop controls on OpLoopMerge instructions. class FuzzerPassAdjustLoopControls : public FuzzerPass { public: FuzzerPassAdjustLoopControls( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_ADJUST_LOOP_CONTROLS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_adjust_memory_operands_masks.cpp000066400000000000000000000112031475742701700321360ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_adjust_memory_operands_masks.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/transformation_set_memory_operands_mask.h" namespace spvtools { namespace fuzz { FuzzerPassAdjustMemoryOperandsMasks::FuzzerPassAdjustMemoryOperandsMasks( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassAdjustMemoryOperandsMasks::Apply() { // Consider every block in every function. for (auto& function : *GetIRContext()->module()) { for (auto& block : function) { // Consider every instruction in this block, using an explicit iterator so // that when we find an instruction of interest we can search backwards to // create an id descriptor for it. for (auto inst_it = block.cbegin(); inst_it != block.cend(); ++inst_it) { if (!TransformationSetMemoryOperandsMask::IsMemoryAccess(*inst_it)) { // We are only interested in memory access instructions. continue; } std::vector indices_of_available_masks_to_adjust; // All memory instructions have at least one memory operands mask. indices_of_available_masks_to_adjust.push_back(0); // From SPIR-V 1.4 onwards, OpCopyMemory and OpCopyMemorySized have a // second mask. switch (inst_it->opcode()) { case spv::Op::OpCopyMemory: case spv::Op::OpCopyMemorySized: if (TransformationSetMemoryOperandsMask:: MultipleMemoryOperandMasksAreSupported(GetIRContext())) { indices_of_available_masks_to_adjust.push_back(1); } break; default: break; } // Consider the available masks for (auto mask_index : indices_of_available_masks_to_adjust) { // Randomly decide whether to adjust this mask. if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext() ->GetChanceOfAdjustingMemoryOperandsMask())) { continue; } // Get the existing mask, using None if there was no mask present at // all. auto existing_mask_in_operand_index = TransformationSetMemoryOperandsMask::GetInOperandIndexForMask( *inst_it, mask_index); auto existing_mask = existing_mask_in_operand_index < inst_it->NumInOperands() ? inst_it->GetSingleWordInOperand( existing_mask_in_operand_index) : static_cast(spv::MemoryAccessMask::MaskNone); // There are two things we can do to a mask: // - add Volatile if not already present // - toggle Nontemporal // The following ensures that we do at least one of these bool add_volatile = !(existing_mask & uint32_t(spv::MemoryAccessMask::Volatile)) && GetFuzzerContext()->ChooseEven(); bool toggle_nontemporal = !add_volatile || GetFuzzerContext()->ChooseEven(); // These bitwise operations use '|' to add Volatile if desired, and // '^' to toggle Nontemporal if desired. uint32_t new_mask = (existing_mask | (add_volatile ? uint32_t(spv::MemoryAccessMask::Volatile) : uint32_t(spv::MemoryAccessMask::MaskNone))) ^ (toggle_nontemporal ? uint32_t(spv::MemoryAccessMask::Nontemporal) : uint32_t(spv::MemoryAccessMask::MaskNone)); TransformationSetMemoryOperandsMask transformation( MakeInstructionDescriptor(block, inst_it), new_mask, mask_index); ApplyTransformation(transformation); } } } } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_adjust_memory_operands_masks.h000066400000000000000000000025251475742701700316120ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_ADJUST_MEMORY_OPERANDS_MASKS_H_ #define SOURCE_FUZZ_FUZZER_PASS_ADJUST_MEMORY_OPERANDS_MASKS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // A fuzzer pass to adjust the memory operand masks in memory access // instructions. class FuzzerPassAdjustMemoryOperandsMasks : public FuzzerPass { public: FuzzerPassAdjustMemoryOperandsMasks( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_ADJUST_MEMORY_OPERANDS_MASKS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_adjust_selection_controls.cpp000066400000000000000000000054001475742701700314470ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_adjust_selection_controls.h" #include "source/fuzz/transformation_set_selection_control.h" namespace spvtools { namespace fuzz { FuzzerPassAdjustSelectionControls::FuzzerPassAdjustSelectionControls( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassAdjustSelectionControls::Apply() { // Consider every merge instruction in the module (via looking through all // functions and blocks). for (auto& function : *GetIRContext()->module()) { for (auto& block : function) { if (auto merge_inst = block.GetMergeInst()) { // Ignore the instruction if it is not a selection merge. if (merge_inst->opcode() != spv::Op::OpSelectionMerge) { continue; } // Choose randomly whether to change the selection control for this // instruction. if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfAdjustingSelectionControl())) { continue; } // The choices to change the selection control to are the set of valid // controls, minus the current control. std::vector choices; for (auto control : {spv::SelectionControlMask::MaskNone, spv::SelectionControlMask::Flatten, spv::SelectionControlMask::DontFlatten}) { if (control == spv::SelectionControlMask(merge_inst->GetSingleWordOperand(1))) { continue; } choices.push_back(uint32_t(control)); } // Apply the transformation and add it to the output transformation // sequence. TransformationSetSelectionControl transformation( block.id(), choices[GetFuzzerContext()->RandomIndex(choices)]); ApplyTransformation(transformation); } } } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_adjust_selection_controls.h000066400000000000000000000025021475742701700311140ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_ADJUST_SELECTION_CONTROLS_H_ #define SOURCE_FUZZ_FUZZER_PASS_ADJUST_SELECTION_CONTROLS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // A pass that adjusts the selection controls on OpSelectionMerge instructions. class FuzzerPassAdjustSelectionControls : public FuzzerPass { public: FuzzerPassAdjustSelectionControls( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_ADJUST_SELECTION_CONTROLS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_apply_id_synonyms.cpp000066400000000000000000000221321475742701700277460ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_apply_id_synonyms.h" #include "source/fuzz/data_descriptor.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/id_use_descriptor.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/transformation_composite_extract.h" #include "source/fuzz/transformation_compute_data_synonym_fact_closure.h" #include "source/fuzz/transformation_replace_id_with_synonym.h" namespace spvtools { namespace fuzz { FuzzerPassApplyIdSynonyms::FuzzerPassApplyIdSynonyms( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassApplyIdSynonyms::Apply() { // Compute a closure of data synonym facts, to enrich the pool of synonyms // that are available. ApplyTransformation(TransformationComputeDataSynonymFactClosure( GetFuzzerContext() ->GetMaximumEquivalenceClassSizeForDataSynonymFactClosure())); for (auto id_with_known_synonyms : GetTransformationContext() ->GetFactManager() ->GetIdsForWhichSynonymsAreKnown()) { // Gather up all uses of |id_with_known_synonym| as a regular id, and // subsequently iterate over these uses. We use this separation because, // when considering a given use, we might apply a transformation that will // invalidate the def-use manager. std::vector> uses; GetIRContext()->get_def_use_mgr()->ForEachUse( id_with_known_synonyms, [&uses](opt::Instruction* use_inst, uint32_t use_index) -> void { // We only gather up regular id uses; e.g. we do not include a use of // the id as the scope for an atomic operation. if (use_inst->GetOperand(use_index).type == SPV_OPERAND_TYPE_ID) { uses.emplace_back( std::pair(use_inst, use_index)); } }); for (const auto& use : uses) { auto use_inst = use.first; auto use_index = use.second; auto block_containing_use = GetIRContext()->get_instr_block(use_inst); // The use might not be in a block; e.g. it could be a decoration. if (!block_containing_use) { continue; } if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfReplacingIdWithSynonym())) { continue; } // |use_index| is the absolute index of the operand. We require // the index of the operand restricted to input operands only. uint32_t use_in_operand_index = fuzzerutil::InOperandIndexFromOperandIndex(*use_inst, use_index); if (!fuzzerutil::IdUseCanBeReplaced(GetIRContext(), *GetTransformationContext(), use_inst, use_in_operand_index)) { continue; } std::vector synonyms_to_try; for (const auto* data_descriptor : GetTransformationContext()->GetFactManager()->GetSynonymsForId( id_with_known_synonyms)) { protobufs::DataDescriptor descriptor_for_this_id = MakeDataDescriptor(id_with_known_synonyms, {}); if (DataDescriptorEquals()(data_descriptor, &descriptor_for_this_id)) { // Exclude the fact that the id is synonymous with itself. continue; } if (DataDescriptorsHaveCompatibleTypes( use_inst->opcode(), use_in_operand_index, descriptor_for_this_id, *data_descriptor)) { synonyms_to_try.push_back(data_descriptor); } } while (!synonyms_to_try.empty()) { auto synonym_to_try = GetFuzzerContext()->RemoveAtRandomIndex(&synonyms_to_try); // If the synonym's |index_size| is zero, the synonym represents an id. // Otherwise it represents some element of a composite structure, in // which case we need to be able to add an extract instruction to get // that element out. if (synonym_to_try->index_size() > 0 && !fuzzerutil::CanInsertOpcodeBeforeInstruction( spv::Op::OpCompositeExtract, use_inst) && use_inst->opcode() != spv::Op::OpPhi) { // We cannot insert an extract before this instruction, so this // synonym is no good. continue; } if (!fuzzerutil::IdIsAvailableAtUse(GetIRContext(), use_inst, use_in_operand_index, synonym_to_try->object())) { continue; } // We either replace the use with an id known to be synonymous (when // the synonym's |index_size| is 0), or an id that will hold the result // of extracting a synonym from a composite (when the synonym's // |index_size| is > 0). uint32_t id_with_which_to_replace_use; if (synonym_to_try->index_size() == 0) { id_with_which_to_replace_use = synonym_to_try->object(); } else { id_with_which_to_replace_use = GetFuzzerContext()->GetFreshId(); opt::Instruction* instruction_to_insert_before = nullptr; if (use_inst->opcode() != spv::Op::OpPhi) { instruction_to_insert_before = use_inst; } else { auto parent_block_id = use_inst->GetSingleWordInOperand(use_in_operand_index + 1); auto parent_block_instruction = GetIRContext()->get_def_use_mgr()->GetDef(parent_block_id); auto parent_block = GetIRContext()->get_instr_block(parent_block_instruction); instruction_to_insert_before = parent_block->GetMergeInst() ? parent_block->GetMergeInst() : parent_block->terminator(); } if (GetTransformationContext()->GetFactManager()->BlockIsDead( GetIRContext() ->get_instr_block(instruction_to_insert_before) ->id())) { // We cannot create a synonym via a composite extraction in a dead // block, as the resulting id is irrelevant. continue; } assert(!GetTransformationContext()->GetFactManager()->IdIsIrrelevant( synonym_to_try->object()) && "Irrelevant ids can't participate in DataSynonym facts"); ApplyTransformation(TransformationCompositeExtract( MakeInstructionDescriptor(GetIRContext(), instruction_to_insert_before), id_with_which_to_replace_use, synonym_to_try->object(), fuzzerutil::RepeatedFieldToVector(synonym_to_try->index()))); assert(GetTransformationContext()->GetFactManager()->IsSynonymous( MakeDataDescriptor(id_with_which_to_replace_use, {}), *synonym_to_try) && "The extracted id must be synonymous with the component from " "which it was extracted."); } ApplyTransformation(TransformationReplaceIdWithSynonym( MakeIdUseDescriptorFromUse(GetIRContext(), use_inst, use_in_operand_index), id_with_which_to_replace_use)); break; } } } } bool FuzzerPassApplyIdSynonyms::DataDescriptorsHaveCompatibleTypes( spv::Op opcode, uint32_t use_in_operand_index, const protobufs::DataDescriptor& dd1, const protobufs::DataDescriptor& dd2) { auto base_object_type_id_1 = fuzzerutil::GetTypeId(GetIRContext(), dd1.object()); auto base_object_type_id_2 = fuzzerutil::GetTypeId(GetIRContext(), dd2.object()); assert(base_object_type_id_1 && base_object_type_id_2 && "Data descriptors are invalid"); auto type_id_1 = fuzzerutil::WalkCompositeTypeIndices( GetIRContext(), base_object_type_id_1, dd1.index()); auto type_id_2 = fuzzerutil::WalkCompositeTypeIndices( GetIRContext(), base_object_type_id_2, dd2.index()); assert(type_id_1 && type_id_2 && "Data descriptors have invalid types"); return fuzzerutil::TypesAreCompatible( GetIRContext(), opcode, use_in_operand_index, type_id_1, type_id_2); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_apply_id_synonyms.h000066400000000000000000000040271475742701700274160ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_APPLY_ID_SYNONYMS_H_ #define SOURCE_FUZZ_FUZZER_PASS_APPLY_ID_SYNONYMS_H_ #include "source/fuzz/fuzzer_pass.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { // A pass that replaces ids with other ids, or accesses into structures, that // are known to hold the same values. class FuzzerPassApplyIdSynonyms : public FuzzerPass { public: FuzzerPassApplyIdSynonyms(opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; private: // Returns true if uses of |dd1| can be replaced with |dd2| and vice-versa // with respect to the type. Concretely, returns true if |dd1| and |dd2| have // the same type or both |dd1| and |dd2| are either a numerical or a vector // type of integral components with possibly different signedness. bool DataDescriptorsHaveCompatibleTypes(spv::Op opcode, uint32_t use_in_operand_index, const protobufs::DataDescriptor& dd1, const protobufs::DataDescriptor& dd2); }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_APPLY_ID_SYNONYMS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_construct_composites.cpp000066400000000000000000000356451475742701700304740ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_construct_composites.h" #include #include "source/fuzz/available_instructions.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/transformation_composite_construct.h" namespace spvtools { namespace fuzz { FuzzerPassConstructComposites::FuzzerPassConstructComposites( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassConstructComposites::Apply() { // Gather up the ids of all composite types, but skip block-/buffer // block-decorated struct types. std::vector composite_type_ids; for (auto& inst : GetIRContext()->types_values()) { if (fuzzerutil::IsCompositeType( GetIRContext()->get_type_mgr()->GetType(inst.result_id())) && !fuzzerutil::HasBlockOrBufferBlockDecoration(GetIRContext(), inst.result_id())) { composite_type_ids.push_back(inst.result_id()); } } if (composite_type_ids.empty()) { // There are no composite types, so this fuzzer pass cannot do anything. return; } AvailableInstructions available_composite_constituents( GetIRContext(), [this](opt::IRContext* ir_context, opt::Instruction* inst) -> bool { if (!inst->result_id() || !inst->type_id()) { return false; } // If the id is irrelevant, we can use it since it will not // participate in DataSynonym fact. Otherwise, we should be able // to produce a synonym out of the id. return GetTransformationContext()->GetFactManager()->IdIsIrrelevant( inst->result_id()) || fuzzerutil::CanMakeSynonymOf(ir_context, *GetTransformationContext(), *inst); }); ForEachInstructionWithInstructionDescriptor( [this, &available_composite_constituents, &composite_type_ids]( opt::Function* /*unused*/, opt::BasicBlock* /*unused*/, opt::BasicBlock::iterator inst_it, const protobufs::InstructionDescriptor& instruction_descriptor) -> void { // Randomly decide whether to try inserting a composite construction // here. if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfConstructingComposite())) { return; } // Check whether it is legitimate to insert a composite construction // before the instruction. if (!fuzzerutil::CanInsertOpcodeBeforeInstruction( spv::Op::OpCompositeConstruct, inst_it)) { return; } // For each instruction that is available at this program point (i.e. an // instruction that is global or whose definition strictly dominates the // program point) and suitable for making a synonym of, associate it // with the id of its result type. TypeIdToInstructions type_id_to_available_instructions; auto available_instructions = available_composite_constituents.GetAvailableBeforeInstruction( &*inst_it); for (uint32_t available_instruction_index = 0; available_instruction_index < available_instructions.size(); available_instruction_index++) { opt::Instruction* inst = available_instructions[available_instruction_index]; type_id_to_available_instructions[inst->type_id()].push_back( inst->result_id()); } // At this point, |composite_type_ids| captures all the composite types // we could try to create, while |type_id_to_available_instructions| // captures all the available result ids we might use, organized by // type. // Now we choose a composite type to construct, building it from // available constituent components and using zero constants if suitable // components are not available. std::vector constructor_arguments; uint32_t chosen_composite_type = composite_type_ids[GetFuzzerContext()->RandomIndex( composite_type_ids)]; // Construct a composite of this type, using an appropriate helper // method depending on the kind of composite type. auto composite_type_inst = GetIRContext()->get_def_use_mgr()->GetDef(chosen_composite_type); switch (composite_type_inst->opcode()) { case spv::Op::OpTypeArray: constructor_arguments = FindComponentsToConstructArray( *composite_type_inst, type_id_to_available_instructions); break; case spv::Op::OpTypeMatrix: constructor_arguments = FindComponentsToConstructMatrix( *composite_type_inst, type_id_to_available_instructions); break; case spv::Op::OpTypeStruct: constructor_arguments = FindComponentsToConstructStruct( *composite_type_inst, type_id_to_available_instructions); break; case spv::Op::OpTypeVector: constructor_arguments = FindComponentsToConstructVector( *composite_type_inst, type_id_to_available_instructions); break; default: assert(false && "The space of possible composite types should be covered " "by the above cases."); break; } assert(!constructor_arguments.empty()); // Make and apply a transformation. ApplyTransformation(TransformationCompositeConstruct( chosen_composite_type, constructor_arguments, instruction_descriptor, GetFuzzerContext()->GetFreshId())); }); } std::vector FuzzerPassConstructComposites::FindComponentsToConstructArray( const opt::Instruction& array_type_instruction, const TypeIdToInstructions& type_id_to_available_instructions) { assert(array_type_instruction.opcode() == spv::Op::OpTypeArray && "Precondition: instruction must be an array type."); // Get the element type for the array. auto element_type_id = array_type_instruction.GetSingleWordInOperand(0); // Get all instructions at our disposal that compute something of this element // type. auto available_instructions = type_id_to_available_instructions.find(element_type_id); uint32_t array_length = GetIRContext() ->get_def_use_mgr() ->GetDef(array_type_instruction.GetSingleWordInOperand(1)) ->GetSingleWordInOperand(0); std::vector result; for (uint32_t index = 0; index < array_length; index++) { if (available_instructions == type_id_to_available_instructions.cend()) { // No suitable instructions are available, so use a zero constant result.push_back(FindOrCreateZeroConstant(element_type_id, true)); } else { result.push_back( available_instructions->second[GetFuzzerContext()->RandomIndex( available_instructions->second)]); } } return result; } std::vector FuzzerPassConstructComposites::FindComponentsToConstructMatrix( const opt::Instruction& matrix_type_instruction, const TypeIdToInstructions& type_id_to_available_instructions) { assert(matrix_type_instruction.opcode() == spv::Op::OpTypeMatrix && "Precondition: instruction must be a matrix type."); // Get the element type for the matrix. auto element_type_id = matrix_type_instruction.GetSingleWordInOperand(0); // Get all instructions at our disposal that compute something of this element // type. auto available_instructions = type_id_to_available_instructions.find(element_type_id); std::vector result; for (uint32_t index = 0; index < matrix_type_instruction.GetSingleWordInOperand(1); index++) { if (available_instructions == type_id_to_available_instructions.cend()) { // No suitable components are available, so use a zero constant. result.push_back(FindOrCreateZeroConstant(element_type_id, true)); } else { result.push_back( available_instructions->second[GetFuzzerContext()->RandomIndex( available_instructions->second)]); } } return result; } std::vector FuzzerPassConstructComposites::FindComponentsToConstructStruct( const opt::Instruction& struct_type_instruction, const TypeIdToInstructions& type_id_to_available_instructions) { assert(struct_type_instruction.opcode() == spv::Op::OpTypeStruct && "Precondition: instruction must be a struct type."); std::vector result; // Consider the type of each field of the struct. for (uint32_t in_operand_index = 0; in_operand_index < struct_type_instruction.NumInOperands(); in_operand_index++) { auto element_type_id = struct_type_instruction.GetSingleWordInOperand(in_operand_index); // Find the instructions at our disposal that compute something of the field // type. auto available_instructions = type_id_to_available_instructions.find(element_type_id); if (available_instructions == type_id_to_available_instructions.cend()) { // No suitable component is available for this element type, so use a zero // constant. result.push_back(FindOrCreateZeroConstant(element_type_id, true)); } else { result.push_back( available_instructions->second[GetFuzzerContext()->RandomIndex( available_instructions->second)]); } } return result; } std::vector FuzzerPassConstructComposites::FindComponentsToConstructVector( const opt::Instruction& vector_type_instruction, const TypeIdToInstructions& type_id_to_available_instructions) { assert(vector_type_instruction.opcode() == spv::Op::OpTypeVector && "Precondition: instruction must be a vector type."); // Get details of the type underlying the vector, and the width of the vector, // for convenience. auto element_type_id = vector_type_instruction.GetSingleWordInOperand(0); auto element_type = GetIRContext()->get_type_mgr()->GetType(element_type_id); auto element_count = vector_type_instruction.GetSingleWordInOperand(1); // Collect a mapping, from type id to width, for scalar/vector types that are // smaller in width than |vector_type|, but that have the same underlying // type. For example, if |vector_type| is vec4, the mapping will be: // { float -> 1, vec2 -> 2, vec3 -> 3 } // The mapping will have missing entries if some of these types do not exist. std::map smaller_vector_type_id_to_width; // Add the underlying type. This id must exist, in order for |vector_type| to // exist. smaller_vector_type_id_to_width[element_type_id] = 1; // Now add every vector type with width at least 2, and less than the width of // |vector_type|. for (uint32_t width = 2; width < element_count; width++) { opt::analysis::Vector smaller_vector_type(element_type, width); auto smaller_vector_type_id = GetIRContext()->get_type_mgr()->GetId(&smaller_vector_type); // We might find that there is no declared type of this smaller width. // For example, a module can declare vec4 without having declared vec2 or // vec3. if (smaller_vector_type_id) { smaller_vector_type_id_to_width[smaller_vector_type_id] = width; } } // Now we know the types that are available to us, we set about populating a // vector of the right length. We do this by deciding, with no order in mind, // which instructions we will use to populate the vector, and subsequently // randomly choosing an order. This is to avoid biasing construction of // vectors with smaller vectors to the left and scalars to the right. That is // a concern because, e.g. in the case of populating a vec4, if we populate // the constructor instructions left-to-right, we can always choose a vec3 to // construct the first three elements, but can only choose a vec3 to construct // the last three elements if we chose a float to construct the first element // (otherwise there will not be space left for a vec3). uint32_t vector_slots_used = 0; // The instructions result ids we will use to construct the vector, in no // particular order at this stage. std::vector result; while (vector_slots_used < element_count) { std::vector instructions_to_choose_from; for (auto& entry : smaller_vector_type_id_to_width) { if (entry.second > std::min(element_count - 1, element_count - vector_slots_used)) { continue; } auto available_instructions = type_id_to_available_instructions.find(entry.first); if (available_instructions == type_id_to_available_instructions.cend()) { continue; } instructions_to_choose_from.insert(instructions_to_choose_from.end(), available_instructions->second.begin(), available_instructions->second.end()); } // If there are no instructions to choose from then use a zero constant, // otherwise select one of the instructions at random. uint32_t id_of_instruction_to_use = instructions_to_choose_from.empty() ? FindOrCreateZeroConstant(element_type_id, true) : instructions_to_choose_from[GetFuzzerContext()->RandomIndex( instructions_to_choose_from)]; opt::Instruction* instruction_to_use = GetIRContext()->get_def_use_mgr()->GetDef(id_of_instruction_to_use); result.push_back(instruction_to_use->result_id()); auto chosen_type = GetIRContext()->get_type_mgr()->GetType(instruction_to_use->type_id()); if (chosen_type->AsVector()) { assert(chosen_type->AsVector()->element_type() == element_type); assert(chosen_type->AsVector()->element_count() < element_count); assert(chosen_type->AsVector()->element_count() <= element_count - vector_slots_used); vector_slots_used += chosen_type->AsVector()->element_count(); } else { assert(chosen_type == element_type); vector_slots_used += 1; } } assert(vector_slots_used == element_count); GetFuzzerContext()->Shuffle(&result); return result; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_construct_composites.h000066400000000000000000000053671475742701700301370ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_CONSTRUCT_COMPOSITES_H_ #define SOURCE_FUZZ_FUZZER_PASS_CONSTRUCT_COMPOSITES_H_ #include #include #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // A fuzzer pass for constructing composite objects from smaller objects. class FuzzerPassConstructComposites : public FuzzerPass { public: FuzzerPassConstructComposites( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; private: // Used to map a type id to the ids of relevant instructions of the type. using TypeIdToInstructions = std::unordered_map>; // Requires that |array_type_instruction| has opcode OpTypeArray. // Attempts to find suitable instruction result ids from the values of // |type_id_to_available_instructions| that would allow a composite of type // |array_type_instruction| to be constructed. Returns said ids if they can // be found and an empty vector otherwise. std::vector FindComponentsToConstructArray( const opt::Instruction& array_type_instruction, const TypeIdToInstructions& type_id_to_available_instructions); // Similar to FindComponentsToConstructArray, but for matrices. std::vector FindComponentsToConstructMatrix( const opt::Instruction& matrix_type_instruction, const TypeIdToInstructions& type_id_to_available_instructions); // Similar to FindComponentsToConstructArray, but for structs. std::vector FindComponentsToConstructStruct( const opt::Instruction& struct_type_instruction, const TypeIdToInstructions& type_id_to_available_instructions); // Similar to FindComponentsToConstructArray, but for vectors. std::vector FindComponentsToConstructVector( const opt::Instruction& vector_type_instruction, const TypeIdToInstructions& type_id_to_available_instructions); }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_CONSTRUCT_COMPOSITES_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_copy_objects.cpp000066400000000000000000000070351475742701700266560ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_copy_objects.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation_add_synonym.h" namespace spvtools { namespace fuzz { FuzzerPassCopyObjects::FuzzerPassCopyObjects( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassCopyObjects::Apply() { ForEachInstructionWithInstructionDescriptor( [this](opt::Function* function, opt::BasicBlock* block, opt::BasicBlock::iterator inst_it, const protobufs::InstructionDescriptor& instruction_descriptor) -> void { assert( inst_it->opcode() == spv::Op(instruction_descriptor.target_instruction_opcode()) && "The opcode of the instruction we might insert before must be " "the same as the opcode in the descriptor for the instruction"); if (GetTransformationContext()->GetFactManager()->BlockIsDead( block->id())) { // Don't create synonyms in dead blocks. return; } // Check whether it is legitimate to insert a copy before this // instruction. if (!fuzzerutil::CanInsertOpcodeBeforeInstruction(spv::Op::OpCopyObject, inst_it)) { return; } // Randomly decide whether to try inserting an object copy here. if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfCopyingObject())) { return; } const auto relevant_instructions = FindAvailableInstructions( function, block, inst_it, [this](opt::IRContext* ir_context, opt::Instruction* inst) { return TransformationAddSynonym::IsInstructionValid( ir_context, *GetTransformationContext(), inst, protobufs::TransformationAddSynonym::COPY_OBJECT); }); // At this point, |relevant_instructions| contains all the instructions // we might think of copying. if (relevant_instructions.empty()) { return; } // Choose a copyable instruction at random, and create and apply an // object copying transformation based on it. ApplyTransformation(TransformationAddSynonym( relevant_instructions[GetFuzzerContext()->RandomIndex( relevant_instructions)] ->result_id(), protobufs::TransformationAddSynonym::COPY_OBJECT, GetFuzzerContext()->GetFreshId(), instruction_descriptor)); }); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_copy_objects.h000066400000000000000000000024761475742701700263270ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_COPY_OBJECTS_H_ #define SOURCE_FUZZ_FUZZER_PASS_COPY_OBJECTS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // A fuzzer pass for adding adding copies of objects to the module. class FuzzerPassCopyObjects : public FuzzerPass { public: FuzzerPassCopyObjects(opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_COPY_OBJECTS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_donate_modules.cpp000066400000000000000000001545411475742701700272020ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_donate_modules.h" #include #include #include #include "source/fuzz/call_graph.h" #include "source/fuzz/instruction_message.h" #include "source/fuzz/transformation_add_constant_boolean.h" #include "source/fuzz/transformation_add_constant_composite.h" #include "source/fuzz/transformation_add_constant_null.h" #include "source/fuzz/transformation_add_constant_scalar.h" #include "source/fuzz/transformation_add_function.h" #include "source/fuzz/transformation_add_global_undef.h" #include "source/fuzz/transformation_add_global_variable.h" #include "source/fuzz/transformation_add_spec_constant_op.h" #include "source/fuzz/transformation_add_type_array.h" #include "source/fuzz/transformation_add_type_boolean.h" #include "source/fuzz/transformation_add_type_float.h" #include "source/fuzz/transformation_add_type_function.h" #include "source/fuzz/transformation_add_type_int.h" #include "source/fuzz/transformation_add_type_matrix.h" #include "source/fuzz/transformation_add_type_pointer.h" #include "source/fuzz/transformation_add_type_struct.h" #include "source/fuzz/transformation_add_type_vector.h" namespace spvtools { namespace fuzz { FuzzerPassDonateModules::FuzzerPassDonateModules( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations, std::vector donor_suppliers) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations), donor_suppliers_(std::move(donor_suppliers)) {} void FuzzerPassDonateModules::Apply() { // If there are no donor suppliers, this fuzzer pass is a no-op. if (donor_suppliers_.empty()) { return; } // Donate at least one module, and probabilistically decide when to stop // donating modules. do { // Choose a donor supplier at random, and get the module that it provides. std::unique_ptr donor_ir_context = donor_suppliers_.at( GetFuzzerContext()->RandomIndex(donor_suppliers_))(); assert(donor_ir_context != nullptr && "Supplying of donor failed"); assert( fuzzerutil::IsValid(donor_ir_context.get(), GetTransformationContext()->GetValidatorOptions(), fuzzerutil::kSilentMessageConsumer) && "The donor module must be valid"); // Donate the supplied module. // // Randomly decide whether to make the module livesafe (see // FactFunctionIsLivesafe); doing so allows it to be used for live code // injection but restricts its behaviour to allow this, and means that its // functions cannot be transformed as if they were arbitrary dead code. bool make_livesafe = GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->ChanceOfMakingDonorLivesafe()); DonateSingleModule(donor_ir_context.get(), make_livesafe); } while (GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfDonatingAdditionalModule())); } void FuzzerPassDonateModules::DonateSingleModule( opt::IRContext* donor_ir_context, bool make_livesafe) { // Check that the donated module has capabilities, supported by the recipient // module. for (const auto& capability_inst : donor_ir_context->capabilities()) { auto capability = static_cast(capability_inst.GetSingleWordInOperand(0)); if (!GetIRContext()->get_feature_mgr()->HasCapability(capability)) { return; } } // The ids used by the donor module may very well clash with ids defined in // the recipient module. Furthermore, some instructions defined in the donor // module will be equivalent to instructions defined in the recipient module, // and it is not always legal to re-declare equivalent instructions. For // example, OpTypeVoid cannot be declared twice. // // To handle this, we maintain a mapping from an id used in the donor module // to the corresponding id that will be used by the donated code when it // appears in the recipient module. // // This mapping is populated in two ways: // (1) by mapping a donor instruction's result id to the id of some equivalent // existing instruction in the recipient (e.g. this has to be done for // OpTypeVoid) // (2) by mapping a donor instruction's result id to a freshly chosen id that // is guaranteed to be different from any id already used by the recipient // (or from any id already chosen to handle a previous donor id) std::map original_id_to_donated_id; HandleExternalInstructionImports(donor_ir_context, &original_id_to_donated_id); HandleTypesAndValues(donor_ir_context, &original_id_to_donated_id); HandleFunctions(donor_ir_context, &original_id_to_donated_id, make_livesafe); // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/3115) Handle some // kinds of decoration. } spv::StorageClass FuzzerPassDonateModules::AdaptStorageClass( spv::StorageClass donor_storage_class) { switch (donor_storage_class) { case spv::StorageClass::Function: case spv::StorageClass::Private: case spv::StorageClass::Workgroup: // We leave these alone return donor_storage_class; case spv::StorageClass::Input: case spv::StorageClass::Output: case spv::StorageClass::Uniform: case spv::StorageClass::UniformConstant: case spv::StorageClass::PushConstant: case spv::StorageClass::Image: case spv::StorageClass::StorageBuffer: // We change these to Private return spv::StorageClass::Private; default: // Handle other cases on demand. assert(false && "Currently unsupported storage class."); return spv::StorageClass::Max; } } void FuzzerPassDonateModules::HandleExternalInstructionImports( opt::IRContext* donor_ir_context, std::map* original_id_to_donated_id) { // Consider every external instruction set import in the donor module. for (auto& donor_import : donor_ir_context->module()->ext_inst_imports()) { const auto& donor_import_name_words = donor_import.GetInOperand(0).words; // Look for an identical import in the recipient module. for (auto& existing_import : GetIRContext()->module()->ext_inst_imports()) { const auto& existing_import_name_words = existing_import.GetInOperand(0).words; if (donor_import_name_words == existing_import_name_words) { // A matching import has found. Map the result id for the donor import // to the id of the existing import, so that when donor instructions // rely on the import they will be rewritten to use the existing import. original_id_to_donated_id->insert( {donor_import.result_id(), existing_import.result_id()}); break; } } // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/3116): At present // we do not handle donation of instruction imports, i.e. we do not allow // the donor to import instruction sets that the recipient did not already // import. It might be a good idea to allow this, but it requires some // thought. assert(original_id_to_donated_id->count(donor_import.result_id()) && "Donation of imports is not yet supported."); } } void FuzzerPassDonateModules::HandleTypesAndValues( opt::IRContext* donor_ir_context, std::map* original_id_to_donated_id) { // Consider every type/global/constant/undef in the module. for (auto& type_or_value : donor_ir_context->module()->types_values()) { HandleTypeOrValue(type_or_value, original_id_to_donated_id); } } void FuzzerPassDonateModules::HandleTypeOrValue( const opt::Instruction& type_or_value, std::map* original_id_to_donated_id) { // The type/value instruction generates a result id, and we need to associate // the donor's result id with a new result id. That new result id will either // be the id of some existing instruction, or a fresh id. This variable // captures it. uint32_t new_result_id; // Decide how to handle each kind of instruction on a case-by-case basis. // // Because the donor module is required to be valid, when we encounter a // type comprised of component types (e.g. an aggregate or pointer), we know // that its component types will have been considered previously, and that // |original_id_to_donated_id| will already contain an entry for them. switch (type_or_value.opcode()) { case spv::Op::OpTypeImage: case spv::Op::OpTypeSampledImage: case spv::Op::OpTypeSampler: // We do not donate types and variables that relate to images and // samplers, so we skip these types and subsequently skip anything that // depends on them. return; case spv::Op::OpTypeVoid: { // Void has to exist already in order for us to have an entry point. // Get the existing id of void. opt::analysis::Void void_type; new_result_id = GetIRContext()->get_type_mgr()->GetId(&void_type); assert(new_result_id && "The module being transformed will always have 'void' type " "declared."); } break; case spv::Op::OpTypeBool: { // Bool cannot be declared multiple times, so use its existing id if // present, or add a declaration of Bool with a fresh id if not. opt::analysis::Bool bool_type; auto bool_type_id = GetIRContext()->get_type_mgr()->GetId(&bool_type); if (bool_type_id) { new_result_id = bool_type_id; } else { new_result_id = GetFuzzerContext()->GetFreshId(); ApplyTransformation(TransformationAddTypeBoolean(new_result_id)); } } break; case spv::Op::OpTypeInt: { // Int cannot be declared multiple times with the same width and // signedness, so check whether an existing identical Int type is // present and use its id if so. Otherwise add a declaration of the // Int type used by the donor, with a fresh id. const uint32_t width = type_or_value.GetSingleWordInOperand(0); const bool is_signed = static_cast(type_or_value.GetSingleWordInOperand(1)); opt::analysis::Integer int_type(width, is_signed); auto int_type_id = GetIRContext()->get_type_mgr()->GetId(&int_type); if (int_type_id) { new_result_id = int_type_id; } else { new_result_id = GetFuzzerContext()->GetFreshId(); ApplyTransformation( TransformationAddTypeInt(new_result_id, width, is_signed)); } } break; case spv::Op::OpTypeFloat: { // Similar to spv::Op::OpTypeInt. const uint32_t width = type_or_value.GetSingleWordInOperand(0); opt::analysis::Float float_type(width); auto float_type_id = GetIRContext()->get_type_mgr()->GetId(&float_type); if (float_type_id) { new_result_id = float_type_id; } else { new_result_id = GetFuzzerContext()->GetFreshId(); ApplyTransformation(TransformationAddTypeFloat(new_result_id, width)); } } break; case spv::Op::OpTypeVector: { // It is not legal to have two Vector type declarations with identical // element types and element counts, so check whether an existing // identical Vector type is present and use its id if so. Otherwise add // a declaration of the Vector type used by the donor, with a fresh id. // When considering the vector's component type id, we look up the id // use in the donor to find the id to which this has been remapped. uint32_t component_type_id = original_id_to_donated_id->at( type_or_value.GetSingleWordInOperand(0)); auto component_type = GetIRContext()->get_type_mgr()->GetType(component_type_id); assert(component_type && "The base type should be registered."); auto component_count = type_or_value.GetSingleWordInOperand(1); opt::analysis::Vector vector_type(component_type, component_count); auto vector_type_id = GetIRContext()->get_type_mgr()->GetId(&vector_type); if (vector_type_id) { new_result_id = vector_type_id; } else { new_result_id = GetFuzzerContext()->GetFreshId(); ApplyTransformation(TransformationAddTypeVector( new_result_id, component_type_id, component_count)); } } break; case spv::Op::OpTypeMatrix: { // Similar to spv::Op::OpTypeVector. uint32_t column_type_id = original_id_to_donated_id->at( type_or_value.GetSingleWordInOperand(0)); auto column_type = GetIRContext()->get_type_mgr()->GetType(column_type_id); assert(column_type && column_type->AsVector() && "The column type should be a registered vector type."); auto column_count = type_or_value.GetSingleWordInOperand(1); opt::analysis::Matrix matrix_type(column_type, column_count); auto matrix_type_id = GetIRContext()->get_type_mgr()->GetId(&matrix_type); if (matrix_type_id) { new_result_id = matrix_type_id; } else { new_result_id = GetFuzzerContext()->GetFreshId(); ApplyTransformation(TransformationAddTypeMatrix( new_result_id, column_type_id, column_count)); } } break; case spv::Op::OpTypeArray: { // It is OK to have multiple structurally identical array types, so // we go ahead and add a remapped version of the type declared by the // donor. uint32_t component_type_id = type_or_value.GetSingleWordInOperand(0); if (!original_id_to_donated_id->count(component_type_id)) { // We did not donate the component type of this array type, so we // cannot donate the array type. return; } new_result_id = GetFuzzerContext()->GetFreshId(); ApplyTransformation(TransformationAddTypeArray( new_result_id, original_id_to_donated_id->at(component_type_id), original_id_to_donated_id->at( type_or_value.GetSingleWordInOperand(1)))); } break; case spv::Op::OpTypeRuntimeArray: { // A runtime array is allowed as the final member of an SSBO. During // donation we turn runtime arrays into fixed-size arrays. For dead // code donations this is OK because the array is never indexed into at // runtime, so it does not matter what its size is. For live-safe code, // all accesses are made in-bounds, so this is also OK. // // The special OpArrayLength instruction, which works on runtime arrays, // is rewritten to yield the fixed length that is used for the array. uint32_t component_type_id = type_or_value.GetSingleWordInOperand(0); if (!original_id_to_donated_id->count(component_type_id)) { // We did not donate the component type of this runtime array type, so // we cannot donate it as a fixed-size array. return; } new_result_id = GetFuzzerContext()->GetFreshId(); ApplyTransformation(TransformationAddTypeArray( new_result_id, original_id_to_donated_id->at(component_type_id), FindOrCreateIntegerConstant( {GetFuzzerContext()->GetRandomSizeForNewArray()}, 32, false, false))); } break; case spv::Op::OpTypeStruct: { // Similar to spv::Op::OpTypeArray. std::vector member_type_ids; for (uint32_t i = 0; i < type_or_value.NumInOperands(); i++) { auto component_type_id = type_or_value.GetSingleWordInOperand(i); if (!original_id_to_donated_id->count(component_type_id)) { // We did not donate every member type for this struct type, so we // cannot donate the struct type. return; } member_type_ids.push_back( original_id_to_donated_id->at(component_type_id)); } new_result_id = GetFuzzerContext()->GetFreshId(); ApplyTransformation( TransformationAddTypeStruct(new_result_id, member_type_ids)); } break; case spv::Op::OpTypePointer: { // Similar to spv::Op::OpTypeArray. uint32_t pointee_type_id = type_or_value.GetSingleWordInOperand(1); if (!original_id_to_donated_id->count(pointee_type_id)) { // We did not donate the pointee type for this pointer type, so we // cannot donate the pointer type. return; } new_result_id = GetFuzzerContext()->GetFreshId(); ApplyTransformation(TransformationAddTypePointer( new_result_id, AdaptStorageClass(static_cast( type_or_value.GetSingleWordInOperand(0))), original_id_to_donated_id->at(pointee_type_id))); } break; case spv::Op::OpTypeFunction: { // It is not OK to have multiple function types that use identical ids // for their return and parameter types. We thus go through all // existing function types to look for a match. We do not use the // type manager here because we want to regard two function types that // are structurally identical but that differ with respect to the // actual ids used for pointer types as different. // // Example: // // %1 = OpTypeVoid // %2 = OpTypeInt 32 0 // %3 = OpTypePointer Function %2 // %4 = OpTypePointer Function %2 // %5 = OpTypeFunction %1 %3 // %6 = OpTypeFunction %1 %4 // // We regard %5 and %6 as distinct function types here, even though // they both have the form "uint32* -> void" std::vector return_and_parameter_types; for (uint32_t i = 0; i < type_or_value.NumInOperands(); i++) { uint32_t return_or_parameter_type = type_or_value.GetSingleWordInOperand(i); if (!original_id_to_donated_id->count(return_or_parameter_type)) { // We did not donate every return/parameter type for this function // type, so we cannot donate the function type. return; } return_and_parameter_types.push_back( original_id_to_donated_id->at(return_or_parameter_type)); } uint32_t existing_function_id = fuzzerutil::FindFunctionType( GetIRContext(), return_and_parameter_types); if (existing_function_id) { new_result_id = existing_function_id; } else { // No match was found, so add a remapped version of the function type // to the module, with a fresh id. new_result_id = GetFuzzerContext()->GetFreshId(); std::vector argument_type_ids; for (uint32_t i = 1; i < type_or_value.NumInOperands(); i++) { argument_type_ids.push_back(original_id_to_donated_id->at( type_or_value.GetSingleWordInOperand(i))); } ApplyTransformation(TransformationAddTypeFunction( new_result_id, original_id_to_donated_id->at( type_or_value.GetSingleWordInOperand(0)), argument_type_ids)); } } break; case spv::Op::OpSpecConstantOp: { new_result_id = GetFuzzerContext()->GetFreshId(); auto type_id = original_id_to_donated_id->at(type_or_value.type_id()); auto opcode = static_cast(type_or_value.GetSingleWordInOperand(0)); // Make sure we take into account |original_id_to_donated_id| when // computing operands for OpSpecConstantOp. opt::Instruction::OperandList operands; for (uint32_t i = 1; i < type_or_value.NumInOperands(); ++i) { const auto& operand = type_or_value.GetInOperand(i); auto data = operand.type == SPV_OPERAND_TYPE_ID ? opt::Operand::OperandData{original_id_to_donated_id->at( operand.words[0])} : operand.words; operands.push_back({operand.type, std::move(data)}); } ApplyTransformation(TransformationAddSpecConstantOp( new_result_id, type_id, opcode, std::move(operands))); } break; case spv::Op::OpSpecConstantTrue: case spv::Op::OpSpecConstantFalse: case spv::Op::OpConstantTrue: case spv::Op::OpConstantFalse: { // It is OK to have duplicate definitions of True and False, so add // these to the module, using a remapped Bool type. new_result_id = GetFuzzerContext()->GetFreshId(); auto value = type_or_value.opcode() == spv::Op::OpConstantTrue || type_or_value.opcode() == spv::Op::OpSpecConstantTrue; ApplyTransformation( TransformationAddConstantBoolean(new_result_id, value, false)); } break; case spv::Op::OpSpecConstant: case spv::Op::OpConstant: { // It is OK to have duplicate constant definitions, so add this to the // module using a remapped result type. new_result_id = GetFuzzerContext()->GetFreshId(); std::vector data_words; type_or_value.ForEachInOperand([&data_words](const uint32_t* in_operand) { data_words.push_back(*in_operand); }); ApplyTransformation(TransformationAddConstantScalar( new_result_id, original_id_to_donated_id->at(type_or_value.type_id()), data_words, false)); } break; case spv::Op::OpSpecConstantComposite: case spv::Op::OpConstantComposite: { assert(original_id_to_donated_id->count(type_or_value.type_id()) && "Composite types for which it is possible to create a constant " "should have been donated."); // It is OK to have duplicate constant composite definitions, so add // this to the module using remapped versions of all constituent ids and // the result type. new_result_id = GetFuzzerContext()->GetFreshId(); std::vector constituent_ids; type_or_value.ForEachInId([&constituent_ids, &original_id_to_donated_id]( const uint32_t* constituent_id) { assert(original_id_to_donated_id->count(*constituent_id) && "The constants used to construct this composite should " "have been donated."); constituent_ids.push_back( original_id_to_donated_id->at(*constituent_id)); }); ApplyTransformation(TransformationAddConstantComposite( new_result_id, original_id_to_donated_id->at(type_or_value.type_id()), constituent_ids, false)); } break; case spv::Op::OpConstantNull: { if (!original_id_to_donated_id->count(type_or_value.type_id())) { // We did not donate the type associated with this null constant, so // we cannot donate the null constant. return; } // It is fine to have multiple OpConstantNull instructions of the same // type, so we just add this to the recipient module. new_result_id = GetFuzzerContext()->GetFreshId(); ApplyTransformation(TransformationAddConstantNull( new_result_id, original_id_to_donated_id->at(type_or_value.type_id()))); } break; case spv::Op::OpVariable: { if (!original_id_to_donated_id->count(type_or_value.type_id())) { // We did not donate the pointer type associated with this variable, // so we cannot donate the variable. return; } // This is a global variable that could have one of various storage // classes. However, we change all global variable pointer storage // classes (such as Uniform, Input and Output) to private when donating // pointer types, with the exception of the Workgroup storage class. // // Thus this variable's pointer type is guaranteed to have storage class // Private or Workgroup. // // We add a global variable with either Private or Workgroup storage // class, using remapped versions of the result type and initializer ids // for the global variable in the donor. // // We regard the added variable as having an irrelevant value. This // means that future passes can add stores to the variable in any // way they wish, and pass them as pointer parameters to functions // without worrying about whether their data might get modified. new_result_id = GetFuzzerContext()->GetFreshId(); uint32_t remapped_pointer_type = original_id_to_donated_id->at(type_or_value.type_id()); uint32_t initializer_id; spv::StorageClass storage_class = static_cast(type_or_value.GetSingleWordInOperand( 0)) == spv::StorageClass::Workgroup ? spv::StorageClass::Workgroup : spv::StorageClass::Private; if (type_or_value.NumInOperands() == 1) { // The variable did not have an initializer. Initialize it to zero // if it has Private storage class (to limit problems associated with // uninitialized data), and leave it uninitialized if it has Workgroup // storage class (as Workgroup variables cannot have initializers). // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/3275): we // could initialize Workgroup variables at the start of an entry // point, and should do so if their uninitialized nature proves // problematic. initializer_id = storage_class == spv::StorageClass::Workgroup ? 0 : FindOrCreateZeroConstant( fuzzerutil::GetPointeeTypeIdFromPointerType( GetIRContext(), remapped_pointer_type), false); } else { // The variable already had an initializer; use its remapped id. initializer_id = original_id_to_donated_id->at( type_or_value.GetSingleWordInOperand(1)); } ApplyTransformation( TransformationAddGlobalVariable(new_result_id, remapped_pointer_type, storage_class, initializer_id, true)); } break; case spv::Op::OpUndef: { if (!original_id_to_donated_id->count(type_or_value.type_id())) { // We did not donate the type associated with this undef, so we cannot // donate the undef. return; } // It is fine to have multiple Undef instructions of the same type, so // we just add this to the recipient module. new_result_id = GetFuzzerContext()->GetFreshId(); ApplyTransformation(TransformationAddGlobalUndef( new_result_id, original_id_to_donated_id->at(type_or_value.type_id()))); } break; default: { assert(0 && "Unknown type/value."); new_result_id = 0; } break; } // Update the id mapping to associate the instruction's result id with its // corresponding id in the recipient. original_id_to_donated_id->insert({type_or_value.result_id(), new_result_id}); } void FuzzerPassDonateModules::HandleFunctions( opt::IRContext* donor_ir_context, std::map* original_id_to_donated_id, bool make_livesafe) { // Get the ids of functions in the donor module, topologically sorted // according to the donor's call graph. auto topological_order = CallGraph(donor_ir_context).GetFunctionsInTopologicalOrder(); // Donate the functions in reverse topological order. This ensures that a // function gets donated before any function that depends on it. This allows // donation of the functions to be separated into a number of transformations, // each adding one function, such that every prefix of transformations leaves // the module valid. for (auto function_id = topological_order.rbegin(); function_id != topological_order.rend(); ++function_id) { // Find the function to be donated. opt::Function* function_to_donate = nullptr; for (auto& function : *donor_ir_context->module()) { if (function.result_id() == *function_id) { function_to_donate = &function; break; } } assert(function_to_donate && "Function to be donated was not found."); if (!original_id_to_donated_id->count( function_to_donate->DefInst().GetSingleWordInOperand(1))) { // We were not able to donate this function's type, so we cannot donate // the function. continue; } // We will collect up protobuf messages representing the donor function's // instructions here, and use them to create an AddFunction transformation. std::vector donated_instructions; // This set tracks the ids of those instructions for which donation was // completely skipped: neither the instruction nor a substitute for it was // donated. std::set skipped_instructions; // Consider every instruction of the donor function. function_to_donate->ForEachInst( [this, &donated_instructions, donor_ir_context, &original_id_to_donated_id, &skipped_instructions](const opt::Instruction* instruction) { if (instruction->opcode() == spv::Op::OpArrayLength) { // We treat OpArrayLength specially. HandleOpArrayLength(*instruction, original_id_to_donated_id, &donated_instructions); } else if (!CanDonateInstruction(donor_ir_context, *instruction, *original_id_to_donated_id, skipped_instructions)) { // This is an instruction that we cannot directly donate. HandleDifficultInstruction(*instruction, original_id_to_donated_id, &donated_instructions, &skipped_instructions); } else { PrepareInstructionForDonation(*instruction, donor_ir_context, original_id_to_donated_id, &donated_instructions); } }); // If |make_livesafe| is true, try to add the function in a livesafe manner. // Otherwise (if |make_lifesafe| is false or an attempt to make the function // livesafe has failed), add the function in a non-livesafe manner. if (!make_livesafe || !MaybeAddLivesafeFunction(*function_to_donate, donor_ir_context, *original_id_to_donated_id, donated_instructions)) { ApplyTransformation(TransformationAddFunction(donated_instructions)); } } } bool FuzzerPassDonateModules::CanDonateInstruction( opt::IRContext* donor_ir_context, const opt::Instruction& instruction, const std::map& original_id_to_donated_id, const std::set& skipped_instructions) const { if (instruction.type_id() && !original_id_to_donated_id.count(instruction.type_id())) { // We could not donate the result type of this instruction, so we cannot // donate the instruction. return false; } // Now consider instructions we specifically want to skip because we do not // yet support them. switch (instruction.opcode()) { case spv::Op::OpAtomicLoad: case spv::Op::OpAtomicStore: case spv::Op::OpAtomicExchange: case spv::Op::OpAtomicCompareExchange: case spv::Op::OpAtomicCompareExchangeWeak: case spv::Op::OpAtomicIIncrement: case spv::Op::OpAtomicIDecrement: case spv::Op::OpAtomicIAdd: case spv::Op::OpAtomicISub: case spv::Op::OpAtomicSMin: case spv::Op::OpAtomicUMin: case spv::Op::OpAtomicSMax: case spv::Op::OpAtomicUMax: case spv::Op::OpAtomicAnd: case spv::Op::OpAtomicOr: case spv::Op::OpAtomicXor: // We conservatively ignore all atomic instructions at present. // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/3276): Consider // being less conservative here. case spv::Op::OpImageSampleImplicitLod: case spv::Op::OpImageSampleExplicitLod: case spv::Op::OpImageSampleDrefImplicitLod: case spv::Op::OpImageSampleDrefExplicitLod: case spv::Op::OpImageSampleProjImplicitLod: case spv::Op::OpImageSampleProjExplicitLod: case spv::Op::OpImageSampleProjDrefImplicitLod: case spv::Op::OpImageSampleProjDrefExplicitLod: case spv::Op::OpImageFetch: case spv::Op::OpImageGather: case spv::Op::OpImageDrefGather: case spv::Op::OpImageRead: case spv::Op::OpImageWrite: case spv::Op::OpImageSparseSampleImplicitLod: case spv::Op::OpImageSparseSampleExplicitLod: case spv::Op::OpImageSparseSampleDrefImplicitLod: case spv::Op::OpImageSparseSampleDrefExplicitLod: case spv::Op::OpImageSparseSampleProjImplicitLod: case spv::Op::OpImageSparseSampleProjExplicitLod: case spv::Op::OpImageSparseSampleProjDrefImplicitLod: case spv::Op::OpImageSparseSampleProjDrefExplicitLod: case spv::Op::OpImageSparseFetch: case spv::Op::OpImageSparseGather: case spv::Op::OpImageSparseDrefGather: case spv::Op::OpImageSparseRead: case spv::Op::OpImageSampleFootprintNV: case spv::Op::OpImage: case spv::Op::OpImageQueryFormat: case spv::Op::OpImageQueryLevels: case spv::Op::OpImageQueryLod: case spv::Op::OpImageQueryOrder: case spv::Op::OpImageQuerySamples: case spv::Op::OpImageQuerySize: case spv::Op::OpImageQuerySizeLod: case spv::Op::OpSampledImage: // We ignore all instructions related to accessing images, since we do not // donate images. return false; case spv::Op::OpLoad: switch (donor_ir_context->get_def_use_mgr() ->GetDef(instruction.type_id()) ->opcode()) { case spv::Op::OpTypeImage: case spv::Op::OpTypeSampledImage: case spv::Op::OpTypeSampler: // Again, we ignore instructions that relate to accessing images. return false; default: break; } default: break; } // Examine each id input operand to the instruction. If it turns out that we // have skipped any of these operands then we cannot donate the instruction. bool result = true; instruction.WhileEachInId( [donor_ir_context, &original_id_to_donated_id, &result, &skipped_instructions](const uint32_t* in_id) -> bool { if (!original_id_to_donated_id.count(*in_id)) { // We do not have a mapped result id for this id operand. That either // means that it is a forward reference (which is OK), that we skipped // the instruction that generated it (which is not OK), or that it is // the id of a function or global value that we did not donate (which // is not OK). We check for the latter two cases. if (skipped_instructions.count(*in_id) || // A function or global value does not have an associated basic // block. !donor_ir_context->get_instr_block(*in_id)) { result = false; return false; } } return true; }); return result; } bool FuzzerPassDonateModules::IsBasicType( const opt::Instruction& instruction) const { switch (instruction.opcode()) { case spv::Op::OpTypeArray: case spv::Op::OpTypeBool: case spv::Op::OpTypeFloat: case spv::Op::OpTypeInt: case spv::Op::OpTypeMatrix: case spv::Op::OpTypeStruct: case spv::Op::OpTypeVector: return true; default: return false; } } void FuzzerPassDonateModules::HandleOpArrayLength( const opt::Instruction& instruction, std::map* original_id_to_donated_id, std::vector* donated_instructions) const { assert(instruction.opcode() == spv::Op::OpArrayLength && "Precondition: instruction must be OpArrayLength."); uint32_t donated_variable_id = original_id_to_donated_id->at(instruction.GetSingleWordInOperand(0)); auto donated_variable_instruction = GetIRContext()->get_def_use_mgr()->GetDef(donated_variable_id); auto pointer_to_struct_instruction = GetIRContext()->get_def_use_mgr()->GetDef( donated_variable_instruction->type_id()); assert(pointer_to_struct_instruction->opcode() == spv::Op::OpTypePointer && "Type of variable must be pointer."); auto donated_struct_type_instruction = GetIRContext()->get_def_use_mgr()->GetDef( pointer_to_struct_instruction->GetSingleWordInOperand(1)); assert(donated_struct_type_instruction->opcode() == spv::Op::OpTypeStruct && "Pointee type of pointer used by OpArrayLength must be struct."); assert(donated_struct_type_instruction->NumInOperands() == instruction.GetSingleWordInOperand(1) + 1 && "OpArrayLength must refer to the final member of the given " "struct."); uint32_t fixed_size_array_type_id = donated_struct_type_instruction->GetSingleWordInOperand( donated_struct_type_instruction->NumInOperands() - 1); auto fixed_size_array_type_instruction = GetIRContext()->get_def_use_mgr()->GetDef(fixed_size_array_type_id); assert(fixed_size_array_type_instruction->opcode() == spv::Op::OpTypeArray && "The donated array type must be fixed-size."); auto array_size_id = fixed_size_array_type_instruction->GetSingleWordInOperand(1); if (instruction.result_id() && !original_id_to_donated_id->count(instruction.result_id())) { original_id_to_donated_id->insert( {instruction.result_id(), GetFuzzerContext()->GetFreshId()}); } donated_instructions->push_back(MakeInstructionMessage( spv::Op::OpCopyObject, original_id_to_donated_id->at(instruction.type_id()), original_id_to_donated_id->at(instruction.result_id()), opt::Instruction::OperandList({{SPV_OPERAND_TYPE_ID, {array_size_id}}}))); } void FuzzerPassDonateModules::HandleDifficultInstruction( const opt::Instruction& instruction, std::map* original_id_to_donated_id, std::vector* donated_instructions, std::set* skipped_instructions) { if (!instruction.result_id()) { // It does not generate a result id, so it can be ignored. return; } if (!original_id_to_donated_id->count(instruction.type_id())) { // We cannot handle this instruction's result type, so we need to skip it // all together. skipped_instructions->insert(instruction.result_id()); return; } // We now attempt to replace the instruction with an OpCopyObject. // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/3278): We could do // something more refined here - we could check which operands to the // instruction could not be donated and replace those operands with // references to other ids (such as constants), so that we still get an // instruction with the opcode and easy-to-handle operands of the donor // instruction. auto remapped_type_id = original_id_to_donated_id->at(instruction.type_id()); if (!IsBasicType( *GetIRContext()->get_def_use_mgr()->GetDef(remapped_type_id))) { // The instruction has a non-basic result type, so we cannot replace it with // an object copy of a constant. We thus skip it completely. // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/3279): We could // instead look for an available id of the right type and generate an // OpCopyObject of that id. skipped_instructions->insert(instruction.result_id()); return; } // We are going to add an OpCopyObject instruction. Add a mapping for the // result id of the original instruction if does not already exist (it may // exist in the case that it has been forward-referenced). if (!original_id_to_donated_id->count(instruction.result_id())) { original_id_to_donated_id->insert( {instruction.result_id(), GetFuzzerContext()->GetFreshId()}); } // We find or add a zero constant to the receiving module for the type in // question, and add an OpCopyObject instruction that copies this zero. // // We mark the constant as irrelevant so that we can replace it with a // more interesting value later. auto zero_constant = FindOrCreateZeroConstant(remapped_type_id, true); donated_instructions->push_back(MakeInstructionMessage( spv::Op::OpCopyObject, remapped_type_id, original_id_to_donated_id->at(instruction.result_id()), opt::Instruction::OperandList({{SPV_OPERAND_TYPE_ID, {zero_constant}}}))); } void FuzzerPassDonateModules::PrepareInstructionForDonation( const opt::Instruction& instruction, opt::IRContext* donor_ir_context, std::map* original_id_to_donated_id, std::vector* donated_instructions) { // Get the instruction's input operands into donation-ready form, // remapping any id uses in the process. opt::Instruction::OperandList input_operands; // Consider each input operand in turn. for (uint32_t in_operand_index = 0; in_operand_index < instruction.NumInOperands(); in_operand_index++) { std::vector operand_data; const opt::Operand& in_operand = instruction.GetInOperand(in_operand_index); // Check whether this operand is an id. if (spvIsIdType(in_operand.type)) { // This is an id operand - it consists of a single word of data, // which needs to be remapped so that it is replaced with the // donated form of the id. auto operand_id = in_operand.words[0]; if (!original_id_to_donated_id->count(operand_id)) { // This is a forward reference. We will choose a corresponding // donor id for the referenced id and update the mapping to // reflect it. // Keep release compilers happy because |donor_ir_context| is only used // in this assertion. (void)(donor_ir_context); assert((donor_ir_context->get_def_use_mgr() ->GetDef(operand_id) ->opcode() == spv::Op::OpLabel || instruction.opcode() == spv::Op::OpPhi) && "Unsupported forward reference."); original_id_to_donated_id->insert( {operand_id, GetFuzzerContext()->GetFreshId()}); } operand_data.push_back(original_id_to_donated_id->at(operand_id)); } else { // For non-id operands, we just add each of the data words. for (auto word : in_operand.words) { operand_data.push_back(word); } } input_operands.push_back({in_operand.type, operand_data}); } if (instruction.opcode() == spv::Op::OpVariable && instruction.NumInOperands() == 1) { // This is an uninitialized local variable. Initialize it to zero. input_operands.push_back( {SPV_OPERAND_TYPE_ID, {FindOrCreateZeroConstant( fuzzerutil::GetPointeeTypeIdFromPointerType( GetIRContext(), original_id_to_donated_id->at(instruction.type_id())), false)}}); } if (instruction.result_id() && !original_id_to_donated_id->count(instruction.result_id())) { original_id_to_donated_id->insert( {instruction.result_id(), GetFuzzerContext()->GetFreshId()}); } // Remap the result type and result id (if present) of the // instruction, and turn it into a protobuf message. donated_instructions->push_back(MakeInstructionMessage( instruction.opcode(), instruction.type_id() ? original_id_to_donated_id->at(instruction.type_id()) : 0, instruction.result_id() ? original_id_to_donated_id->at(instruction.result_id()) : 0, input_operands)); } bool FuzzerPassDonateModules::CreateLoopLimiterInfo( opt::IRContext* donor_ir_context, const opt::BasicBlock& loop_header, const std::map& original_id_to_donated_id, protobufs::LoopLimiterInfo* out) { assert(loop_header.IsLoopHeader() && "|loop_header| is not a loop header"); // Grab the loop header's id, mapped to its donated value. out->set_loop_header_id(original_id_to_donated_id.at(loop_header.id())); // Get fresh ids that will be used to load the loop limiter, increment // it, compare it with the loop limit, and an id for a new block that // will contain the loop's original terminator. out->set_load_id(GetFuzzerContext()->GetFreshId()); out->set_increment_id(GetFuzzerContext()->GetFreshId()); out->set_compare_id(GetFuzzerContext()->GetFreshId()); out->set_logical_op_id(GetFuzzerContext()->GetFreshId()); // We are creating a branch from the back-edge block to the merge block. Thus, // if merge block has any OpPhi instructions, we might need to adjust // them. // Note that the loop might have an unreachable back-edge block. This means // that the loop can't iterate, so we don't need to adjust anything. const auto back_edge_block_id = TransformationAddFunction::GetBackEdgeBlockId( donor_ir_context, loop_header.id()); if (!back_edge_block_id) { return true; } auto* back_edge_block = donor_ir_context->cfg()->block(back_edge_block_id); assert(back_edge_block && "|back_edge_block_id| is invalid"); const auto* merge_block = donor_ir_context->cfg()->block(loop_header.MergeBlockId()); assert(merge_block && "Loop header has invalid merge block id"); // We don't need to adjust anything if there is already a branch from // the back-edge block to the merge block. if (back_edge_block->IsSuccessor(merge_block)) { return true; } // Adjust OpPhi instructions in the |merge_block|. for (const auto& inst : *merge_block) { if (inst.opcode() != spv::Op::OpPhi) { break; } // There is no simple way to ensure that a chosen operand for the OpPhi // instruction will never cause any problems (e.g. if we choose an // integer id, it might have a zero value when we branch from the back // edge block. This might cause a division by 0 later in the function.). // Thus, we ignore possible problems and proceed as follows: // - if any of the existing OpPhi operands dominates the back-edge // block - use it // - if OpPhi has a basic type (see IsBasicType method) - create // a zero constant // - otherwise, we can't add a livesafe function. uint32_t suitable_operand_id = 0; for (uint32_t i = 0; i < inst.NumInOperands(); i += 2) { auto dependency_inst_id = inst.GetSingleWordInOperand(i); if (fuzzerutil::IdIsAvailableBeforeInstruction( donor_ir_context, back_edge_block->terminator(), dependency_inst_id)) { suitable_operand_id = original_id_to_donated_id.at(dependency_inst_id); break; } } if (suitable_operand_id == 0 && IsBasicType( *donor_ir_context->get_def_use_mgr()->GetDef(inst.type_id()))) { // We mark this constant as irrelevant so that we can replace it // with more interesting value later. suitable_operand_id = FindOrCreateZeroConstant( original_id_to_donated_id.at(inst.type_id()), true); } if (suitable_operand_id == 0) { return false; } out->add_phi_id(suitable_operand_id); } return true; } bool FuzzerPassDonateModules::MaybeAddLivesafeFunction( const opt::Function& function_to_donate, opt::IRContext* donor_ir_context, const std::map& original_id_to_donated_id, const std::vector& donated_instructions) { // Various types and constants must be in place for a function to be made // live-safe. Add them if not already present. FindOrCreateBoolType(); // Needed for comparisons FindOrCreatePointerToIntegerType( 32, false, spv::StorageClass::Function); // Needed for adding loop limiters FindOrCreateIntegerConstant({0}, 32, false, false); // Needed for initializing loop limiters FindOrCreateIntegerConstant({1}, 32, false, false); // Needed for incrementing loop limiters // Get a fresh id for the variable that will be used as a loop limiter. const uint32_t loop_limiter_variable_id = GetFuzzerContext()->GetFreshId(); // Choose a random loop limit, and add the required constant to the // module if not already there. const uint32_t loop_limit = FindOrCreateIntegerConstant( {GetFuzzerContext()->GetRandomLoopLimit()}, 32, false, false); // Consider every loop header in the function to donate, and create a // structure capturing the ids to be used for manipulating the loop // limiter each time the loop is iterated. std::vector loop_limiters; for (auto& block : function_to_donate) { if (block.IsLoopHeader()) { protobufs::LoopLimiterInfo loop_limiter; if (!CreateLoopLimiterInfo(donor_ir_context, block, original_id_to_donated_id, &loop_limiter)) { return false; } loop_limiters.emplace_back(std::move(loop_limiter)); } } // Consider every access chain in the function to donate, and create a // structure containing the ids necessary to clamp the access chain // indices to be in-bounds. std::vector access_chain_clamping_info; for (auto& block : function_to_donate) { for (auto& inst : block) { switch (inst.opcode()) { case spv::Op::OpAccessChain: case spv::Op::OpInBoundsAccessChain: { protobufs::AccessChainClampingInfo clamping_info; clamping_info.set_access_chain_id( original_id_to_donated_id.at(inst.result_id())); auto base_object = donor_ir_context->get_def_use_mgr()->GetDef( inst.GetSingleWordInOperand(0)); assert(base_object && "The base object must exist."); auto pointer_type = donor_ir_context->get_def_use_mgr()->GetDef( base_object->type_id()); assert(pointer_type && pointer_type->opcode() == spv::Op::OpTypePointer && "The base object must have pointer type."); auto should_be_composite_type = donor_ir_context->get_def_use_mgr()->GetDef( pointer_type->GetSingleWordInOperand(1)); // Walk the access chain, creating fresh ids to facilitate // clamping each index. For simplicity we do this for every // index, even though constant indices will not end up being // clamped. for (uint32_t index = 1; index < inst.NumInOperands(); index++) { auto compare_and_select_ids = clamping_info.add_compare_and_select_ids(); compare_and_select_ids->set_first(GetFuzzerContext()->GetFreshId()); compare_and_select_ids->set_second( GetFuzzerContext()->GetFreshId()); // Get the bound for the component being indexed into. uint32_t bound; if (should_be_composite_type->opcode() == spv::Op::OpTypeRuntimeArray) { // The donor is indexing into a runtime array. We do not // donate runtime arrays. Instead, we donate a corresponding // fixed-size array for every runtime array. We should thus // find that donor composite type's result id maps to a fixed- // size array. auto fixed_size_array_type = GetIRContext()->get_def_use_mgr()->GetDef( original_id_to_donated_id.at( should_be_composite_type->result_id())); assert(fixed_size_array_type->opcode() == spv::Op::OpTypeArray && "A runtime array type in the donor should have been " "replaced by a fixed-sized array in the recipient."); // The size of this fixed-size array is a suitable bound. bound = fuzzerutil::GetBoundForCompositeIndex( *fixed_size_array_type, GetIRContext()); } else { bound = fuzzerutil::GetBoundForCompositeIndex( *should_be_composite_type, donor_ir_context); } const uint32_t index_id = inst.GetSingleWordInOperand(index); auto index_inst = donor_ir_context->get_def_use_mgr()->GetDef(index_id); auto index_type_inst = donor_ir_context->get_def_use_mgr()->GetDef( index_inst->type_id()); assert(index_type_inst->opcode() == spv::Op::OpTypeInt); opt::analysis::Integer* index_int_type = donor_ir_context->get_type_mgr() ->GetType(index_type_inst->result_id()) ->AsInteger(); if (index_inst->opcode() != spv::Op::OpConstant) { // We will have to clamp this index, so we need a constant // whose value is one less than the bound, to compare // against and to use as the clamped value. FindOrCreateIntegerConstant({bound - 1}, 32, index_int_type->IsSigned(), false); } should_be_composite_type = TransformationAddFunction::FollowCompositeIndex( donor_ir_context, *should_be_composite_type, index_id); } access_chain_clamping_info.push_back(clamping_info); break; } default: break; } } } // If |function_to_donate| has non-void return type and contains an // OpKill/OpUnreachable instruction, then a value is needed in order to turn // these into instructions of the form OpReturnValue %value_id. uint32_t kill_unreachable_return_value_id = 0; auto function_return_type_inst = donor_ir_context->get_def_use_mgr()->GetDef(function_to_donate.type_id()); if (function_return_type_inst->opcode() != spv::Op::OpTypeVoid && fuzzerutil::FunctionContainsOpKillOrUnreachable(function_to_donate)) { kill_unreachable_return_value_id = FindOrCreateZeroConstant( original_id_to_donated_id.at(function_return_type_inst->result_id()), false); } // Try to add the function in a livesafe manner. This may fail due to edge // cases, e.g. where adding loop limiters changes dominance such that the // module becomes invalid. It would be ideal to handle all such edge cases, // but as they are rare it is more pragmatic to bail out of making the // function livesafe if the transformation's precondition fails to hold. return MaybeApplyTransformation(TransformationAddFunction( donated_instructions, loop_limiter_variable_id, loop_limit, loop_limiters, kill_unreachable_return_value_id, access_chain_clamping_info)); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_donate_modules.h000066400000000000000000000175361475742701700266510ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_DONATE_MODULES_H_ #define SOURCE_FUZZ_FUZZER_PASS_DONATE_MODULES_H_ #include #include "source/fuzz/fuzzer_pass.h" #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { // A fuzzer pass that randomly adds code from other SPIR-V modules to the module // being transformed. class FuzzerPassDonateModules : public FuzzerPass { public: FuzzerPassDonateModules( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations, std::vector donor_suppliers); void Apply() override; // Donates the global declarations and functions of |donor_ir_context| into // the fuzzer pass's IR context. |make_livesafe| dictates whether the // functions of the donated module will be made livesafe (see // FactFunctionIsLivesafe). void DonateSingleModule(opt::IRContext* donor_ir_context, bool make_livesafe); private: // Adapts a storage class coming from a donor module so that it will work // in a recipient module, e.g. by changing Uniform to Private. static spv::StorageClass AdaptStorageClass( spv::StorageClass donor_storage_class); // Identifies all external instruction set imports in |donor_ir_context| and // populates |original_id_to_donated_id| with a mapping from the donor's id // for such an import to a corresponding import in the recipient. Aborts if // no such corresponding import is available. void HandleExternalInstructionImports( opt::IRContext* donor_ir_context, std::map* original_id_to_donated_id); // Considers all types, globals, constants and undefs in |donor_ir_context|. // For each instruction, uses |original_to_donated_id| to map its result id to // either (1) the id of an existing identical instruction in the recipient, or // (2) to a fresh id, in which case the instruction is also added to the // recipient (with any operand ids that it uses being remapped via // |original_id_to_donated_id|). void HandleTypesAndValues( opt::IRContext* donor_ir_context, std::map* original_id_to_donated_id); // Helper method for HandleTypesAndValues, to handle a single type/value. void HandleTypeOrValue( const opt::Instruction& type_or_value, std::map* original_id_to_donated_id); // Assumes that |donor_ir_context| does not exhibit recursion. Considers the // functions in |donor_ir_context|'s call graph in a reverse-topologically- // sorted order (leaves-to-root), adding each function to the recipient // module, rewritten to use fresh ids and using |original_id_to_donated_id| to // remap ids. The |make_livesafe| argument captures whether the functions in // the module are required to be made livesafe before being added to the // recipient. void HandleFunctions(opt::IRContext* donor_ir_context, std::map* original_id_to_donated_id, bool make_livesafe); // During donation we will have to ignore some instructions, e.g. because they // use opcodes that we cannot support or because they reference the ids of // instructions that have not been donated. This function encapsulates the // logic for deciding which whether instruction |instruction| from // |donor_ir_context| can be donated. bool CanDonateInstruction( opt::IRContext* donor_ir_context, const opt::Instruction& instruction, const std::map& original_id_to_donated_id, const std::set& skipped_instructions) const; // We treat the OpArrayLength instruction specially. In the donor shader this // instruction yields the length of a runtime array that is the final member // of a struct. During donation, we will have converted the runtime array // type, and the associated struct field, into a fixed-size array. // // Instead of donating this instruction, we turn it into an OpCopyObject // instruction that copies the size of the fixed-size array. void HandleOpArrayLength( const opt::Instruction& instruction, std::map* original_id_to_donated_id, std::vector* donated_instructions) const; // The instruction |instruction| is required to be an instruction that cannot // be easily donated, either because it uses an unsupported opcode, has an // unsupported result type, or uses id operands that could not be donated. // // If |instruction| generates a result id, the function attempts to add a // substitute for |instruction| to |donated_instructions| that has the correct // result type. If this cannot be done, the instruction's result id is added // to |skipped_instructions|. The mapping from donor ids to recipient ids is // managed by |original_id_to_donated_id|. void HandleDifficultInstruction( const opt::Instruction& instruction, std::map* original_id_to_donated_id, std::vector* donated_instructions, std::set* skipped_instructions); // Adds an instruction based in |instruction| to |donated_instructions| in a // form ready for donation. The original instruction comes from // |donor_ir_context|, and |original_id_to_donated_id| maps ids from // |donor_ir_context| to corresponding ids in the recipient module. void PrepareInstructionForDonation( const opt::Instruction& instruction, opt::IRContext* donor_ir_context, std::map* original_id_to_donated_id, std::vector* donated_instructions); // Tries to create a protobufs::LoopLimiterInfo given a loop header basic // block. Returns true if successful and outputs loop limiter into the |out| // variable. Otherwise, returns false. |out| contains an undefined value when // this function returns false. bool CreateLoopLimiterInfo( opt::IRContext* donor_ir_context, const opt::BasicBlock& loop_header, const std::map& original_id_to_donated_id, protobufs::LoopLimiterInfo* out); // Requires that |donated_instructions| represents a prepared version of the // instructions of |function_to_donate| (which comes from |donor_ir_context|) // ready for donation, and |original_id_to_donated_id| maps ids from // |donor_ir_context| to their corresponding ids in the recipient module. // // Attempts to add a livesafe version of the function, based on // |donated_instructions|, to the recipient module. Returns true if the // donation was successful, false otherwise. bool MaybeAddLivesafeFunction( const opt::Function& function_to_donate, opt::IRContext* donor_ir_context, const std::map& original_id_to_donated_id, const std::vector& donated_instructions); // Returns true if and only if |instruction| is a scalar, vector, matrix, // array or struct; i.e. it is not an opaque type. bool IsBasicType(const opt::Instruction& instruction) const; // Functions that supply SPIR-V modules std::vector donor_suppliers_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_DONATE_MODULES_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_duplicate_regions_with_selections.cpp000066400000000000000000000134331475742701700331550ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_duplicate_regions_with_selections.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/transformation_duplicate_region_with_selection.h" namespace spvtools { namespace fuzz { FuzzerPassDuplicateRegionsWithSelections:: FuzzerPassDuplicateRegionsWithSelections( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassDuplicateRegionsWithSelections::Apply() { // Iterate over all of the functions in the module. for (auto& function : *GetIRContext()->module()) { // Randomly decide whether to apply the transformation. if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfDuplicatingRegionWithSelection())) { continue; } std::vector candidate_entry_blocks; for (auto& block : function) { // We don't consider the first block to be the entry block, since it // could contain OpVariable instructions that would require additional // operations to be reassigned. // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/3778): // Consider extending this fuzzer pass to allow the first block to be // used in duplication. if (&block == &*function.begin()) { continue; } candidate_entry_blocks.push_back(&block); } if (candidate_entry_blocks.empty()) { continue; } // Randomly choose the entry block. auto entry_block = candidate_entry_blocks[GetFuzzerContext()->RandomIndex( candidate_entry_blocks)]; auto dominator_analysis = GetIRContext()->GetDominatorAnalysis(&function); auto postdominator_analysis = GetIRContext()->GetPostDominatorAnalysis(&function); std::vector candidate_exit_blocks; for (auto postdominates_entry_block = entry_block; postdominates_entry_block != nullptr; postdominates_entry_block = postdominator_analysis->ImmediateDominator( postdominates_entry_block)) { // The candidate exit block must be dominated by the entry block and the // entry block must be post-dominated by the candidate exit block. Ignore // the block if it heads a selection construct or a loop construct. if (dominator_analysis->Dominates(entry_block, postdominates_entry_block) && !postdominates_entry_block->GetMergeInst()) { candidate_exit_blocks.push_back(postdominates_entry_block); } } if (candidate_exit_blocks.empty()) { continue; } // Randomly choose the exit block. auto exit_block = candidate_exit_blocks[GetFuzzerContext()->RandomIndex( candidate_exit_blocks)]; auto region_blocks = TransformationDuplicateRegionWithSelection::GetRegionBlocks( GetIRContext(), entry_block, exit_block); // Construct |original_label_to_duplicate_label| by iterating over all // blocks in the region. Construct |original_id_to_duplicate_id| and // |original_id_to_phi_id| by iterating over all instructions in each block. std::map original_label_to_duplicate_label; std::map original_id_to_duplicate_id; std::map original_id_to_phi_id; for (auto& block : region_blocks) { original_label_to_duplicate_label[block->id()] = GetFuzzerContext()->GetFreshId(); for (auto& instr : *block) { if (instr.result_id()) { original_id_to_duplicate_id[instr.result_id()] = GetFuzzerContext()->GetFreshId(); auto final_instruction = &*exit_block->tail(); // &*exit_block->tail() is the final instruction of the region. // The instruction is available at the end of the region if and only // if it is available before this final instruction or it is the final // instruction. if ((&instr == final_instruction || fuzzerutil::IdIsAvailableBeforeInstruction( GetIRContext(), final_instruction, instr.result_id()))) { original_id_to_phi_id[instr.result_id()] = GetFuzzerContext()->GetFreshId(); } } } } // Randomly decide between value "true" or "false" for a bool constant. // Make sure the transformation has access to a bool constant to be used // while creating conditional construct. auto condition_id = FindOrCreateBoolConstant(GetFuzzerContext()->ChooseEven(), true); TransformationDuplicateRegionWithSelection transformation = TransformationDuplicateRegionWithSelection( GetFuzzerContext()->GetFreshId(), condition_id, GetFuzzerContext()->GetFreshId(), entry_block->id(), exit_block->id(), original_label_to_duplicate_label, original_id_to_duplicate_id, original_id_to_phi_id); MaybeApplyTransformation(transformation); } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_duplicate_regions_with_selections.h000066400000000000000000000030751475742701700326230ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_DUPLICATE_REGIONS_WITH_SELECTIONS_H_ #define SOURCE_FUZZ_FUZZER_PASS_DUPLICATE_REGIONS_WITH_SELECTIONS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // A fuzzer pass that iterates over the whole module. For each function it // finds a single-entry, single-exit region with its constructs and their merge // blocks either completely within or completely outside the region. It // duplicates this region using the corresponding transformation. class FuzzerPassDuplicateRegionsWithSelections : public FuzzerPass { public: FuzzerPassDuplicateRegionsWithSelections( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_DUPLICATE_REGIONS_WITH_SELECTIONS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_expand_vector_reductions.cpp000066400000000000000000000047061475742701700312750ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_expand_vector_reductions.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/transformation_expand_vector_reduction.h" namespace spvtools { namespace fuzz { FuzzerPassExpandVectorReductions::FuzzerPassExpandVectorReductions( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassExpandVectorReductions::Apply() { for (auto& function : *GetIRContext()->module()) { for (auto& block : function) { for (auto& instruction : block) { // Randomly decides whether the transformation will be applied. if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfExpandingVectorReduction())) { continue; } // |instruction| must be OpAny or OpAll. if (instruction.opcode() != spv::Op::OpAny && instruction.opcode() != spv::Op::OpAll) { continue; } // It must be able to make a synonym of |instruction|. if (!fuzzerutil::CanMakeSynonymOf( GetIRContext(), *GetTransformationContext(), instruction)) { continue; } // Applies the expand vector reduction transformation. ApplyTransformation(TransformationExpandVectorReduction( instruction.result_id(), GetFuzzerContext()->GetFreshIds( TransformationExpandVectorReduction::GetRequiredFreshIdCount( GetIRContext(), &instruction)))); } } } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_expand_vector_reductions.h000066400000000000000000000027421475742701700307400ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_EXPAND_VECTOR_REDUCTIONS_H_ #define SOURCE_FUZZ_FUZZER_PASS_EXPAND_VECTOR_REDUCTIONS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // This fuzzer pass adds synonyms for the OpAny and OpAll instructions. It // iterates over the module, checks if there are any OpAny or OpAll applicable // instructions and randomly applies the expand vector reduction transformation. class FuzzerPassExpandVectorReductions : public FuzzerPass { public: FuzzerPassExpandVectorReductions( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_EXPAND_VECTOR_REDUCTIONS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_flatten_conditional_branches.cpp000066400000000000000000000261641475742701700320640ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_flatten_conditional_branches.h" #include "source/fuzz/comparator_deep_blocks_first.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/transformation_flatten_conditional_branch.h" namespace spvtools { namespace fuzz { // A fuzzer pass that randomly selects conditional branches to flatten and // flattens them, if possible. FuzzerPassFlattenConditionalBranches::FuzzerPassFlattenConditionalBranches( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassFlattenConditionalBranches::Apply() { for (auto& function : *GetIRContext()->module()) { // Get all the selection headers that we want to flatten. We need to collect // all of them first, because, since we are changing the structure of the // module, it's not safe to modify them while iterating. std::vector selection_headers; for (auto& block : function) { // Randomly decide whether to consider this block. if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfFlatteningConditionalBranch())) { continue; } // Only consider this block if it is the header of a conditional, with a // non-irrelevant condition. if (block.GetMergeInst() && block.GetMergeInst()->opcode() == spv::Op::OpSelectionMerge && block.terminator()->opcode() == spv::Op::OpBranchConditional && !GetTransformationContext()->GetFactManager()->IdIsIrrelevant( block.terminator()->GetSingleWordInOperand(0))) { selection_headers.emplace_back(&block); } } // Sort the headers so that those that are more deeply nested are considered // first, possibly enabling outer conditionals to be flattened. std::sort(selection_headers.begin(), selection_headers.end(), ComparatorDeepBlocksFirst(GetIRContext())); // Apply the transformation to the headers which can be flattened. for (auto header : selection_headers) { // Make a set to keep track of the instructions that need fresh ids. std::set instructions_that_need_ids; // Do not consider this header if the conditional cannot be flattened. if (!TransformationFlattenConditionalBranch:: GetProblematicInstructionsIfConditionalCanBeFlattened( GetIRContext(), header, *GetTransformationContext(), &instructions_that_need_ids)) { continue; } uint32_t convergence_block_id = TransformationFlattenConditionalBranch::FindConvergenceBlock( GetIRContext(), *header); // If the SPIR-V version is restricted so that OpSelect can only work on // scalar, pointer and vector types then we cannot apply this // transformation to a header whose convergence block features OpPhi // instructions on different types, as we cannot convert such instructions // to OpSelect instructions. if (TransformationFlattenConditionalBranch:: OpSelectArgumentsAreRestricted(GetIRContext())) { if (!GetIRContext() ->cfg() ->block(convergence_block_id) ->WhileEachPhiInst( [this](opt::Instruction* phi_instruction) -> bool { switch (GetIRContext() ->get_def_use_mgr() ->GetDef(phi_instruction->type_id()) ->opcode()) { case spv::Op::OpTypeBool: case spv::Op::OpTypeInt: case spv::Op::OpTypeFloat: case spv::Op::OpTypePointer: case spv::Op::OpTypeVector: return true; default: return false; } })) { // An OpPhi is performed on a type not supported by OpSelect; we // cannot flatten this selection. continue; } } // If the construct's convergence block features OpPhi instructions with // vector result types then we may be *forced*, by the SPIR-V version, to // turn these into component-wise OpSelect instructions, or we might wish // to do so anyway. The following booleans capture whether we will opt // to use a component-wise select even if we don't have to. bool use_component_wise_2d_select_even_if_optional = GetFuzzerContext()->ChooseEven(); bool use_component_wise_3d_select_even_if_optional = GetFuzzerContext()->ChooseEven(); bool use_component_wise_4d_select_even_if_optional = GetFuzzerContext()->ChooseEven(); // If we do need to perform any component-wise selections, we will need a // fresh id for a boolean vector representing the selection's condition // repeated N times, where N is the vector dimension. uint32_t fresh_id_for_bvec2_selector = 0; uint32_t fresh_id_for_bvec3_selector = 0; uint32_t fresh_id_for_bvec4_selector = 0; GetIRContext() ->cfg() ->block(convergence_block_id) ->ForEachPhiInst([this, &fresh_id_for_bvec2_selector, &fresh_id_for_bvec3_selector, &fresh_id_for_bvec4_selector, use_component_wise_2d_select_even_if_optional, use_component_wise_3d_select_even_if_optional, use_component_wise_4d_select_even_if_optional]( opt::Instruction* phi_instruction) { opt::Instruction* type_instruction = GetIRContext()->get_def_use_mgr()->GetDef( phi_instruction->type_id()); switch (type_instruction->opcode()) { case spv::Op::OpTypeVector: { uint32_t dimension = type_instruction->GetSingleWordInOperand(1); switch (dimension) { case 2: PrepareForOpPhiOnVectors( dimension, use_component_wise_2d_select_even_if_optional, &fresh_id_for_bvec2_selector); break; case 3: PrepareForOpPhiOnVectors( dimension, use_component_wise_3d_select_even_if_optional, &fresh_id_for_bvec3_selector); break; case 4: PrepareForOpPhiOnVectors( dimension, use_component_wise_4d_select_even_if_optional, &fresh_id_for_bvec4_selector); break; default: assert(false && "Invalid vector dimension."); } break; } default: break; } }); // Some instructions will require to be enclosed inside conditionals // because they have side effects (for example, loads and stores). Some of // this have no result id, so we require instruction descriptors to // identify them. Each of them is associated with the necessary ids for it // via a SideEffectWrapperInfo message. std::vector wrappers_info; for (auto instruction : instructions_that_need_ids) { protobufs::SideEffectWrapperInfo wrapper_info; *wrapper_info.mutable_instruction() = MakeInstructionDescriptor(GetIRContext(), instruction); wrapper_info.set_merge_block_id(GetFuzzerContext()->GetFreshId()); wrapper_info.set_execute_block_id(GetFuzzerContext()->GetFreshId()); // If the instruction has a non-void result id, we need to define more // fresh ids and provide an id of the suitable type whose value can be // copied in order to create a placeholder id. if (TransformationFlattenConditionalBranch::InstructionNeedsPlaceholder( GetIRContext(), *instruction)) { wrapper_info.set_actual_result_id(GetFuzzerContext()->GetFreshId()); wrapper_info.set_alternative_block_id( GetFuzzerContext()->GetFreshId()); wrapper_info.set_placeholder_result_id( GetFuzzerContext()->GetFreshId()); // The id will be a zero constant if the type allows it, and an // OpUndef otherwise. We want to avoid using OpUndef, if possible, to // avoid undefined behaviour in the module as much as possible. if (fuzzerutil::CanCreateConstant(GetIRContext(), instruction->type_id())) { wrapper_info.set_value_to_copy_id( FindOrCreateZeroConstant(instruction->type_id(), true)); } else { wrapper_info.set_value_to_copy_id( FindOrCreateGlobalUndef(instruction->type_id())); } } wrappers_info.push_back(std::move(wrapper_info)); } // Apply the transformation, evenly choosing whether to lay out the true // branch or the false branch first. ApplyTransformation(TransformationFlattenConditionalBranch( header->id(), GetFuzzerContext()->ChooseEven(), fresh_id_for_bvec2_selector, fresh_id_for_bvec3_selector, fresh_id_for_bvec4_selector, wrappers_info)); } } } void FuzzerPassFlattenConditionalBranches::PrepareForOpPhiOnVectors( uint32_t vector_dimension, bool use_vector_select_if_optional, uint32_t* fresh_id_for_bvec_selector) { if (*fresh_id_for_bvec_selector != 0) { // We already have a fresh id for a component-wise OpSelect of this // dimension return; } if (TransformationFlattenConditionalBranch::OpSelectArgumentsAreRestricted( GetIRContext()) || use_vector_select_if_optional) { // We either have to, or have chosen to, perform a component-wise select, so // we ensure that the right boolean vector type is available, and grab a // fresh id. FindOrCreateVectorType(FindOrCreateBoolType(), vector_dimension); *fresh_id_for_bvec_selector = GetFuzzerContext()->GetFreshId(); } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_flatten_conditional_branches.h000066400000000000000000000034241475742701700315230ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_FLATTEN_CONDITIONAL_BRANCHES_H #define SOURCE_FUZZ_FUZZER_PASS_FLATTEN_CONDITIONAL_BRANCHES_H #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { class FuzzerPassFlattenConditionalBranches : public FuzzerPass { public: FuzzerPassFlattenConditionalBranches( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; private: // If the SPIR-V version requires vector OpSelects to be component-wise, or // if |use_vector_select_if_optional| holds, |fresh_id_for_bvec_selector| is // populated with a fresh id if it is currently zero, and a // |vector_dimension|-dimensional boolean vector type is added to the module // if not already present. void PrepareForOpPhiOnVectors(uint32_t vector_dimension, bool use_vector_select_if_optional, uint32_t* fresh_id_for_bvec_selector); }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_FLATTEN_CONDITIONAL_BRANCHES_H KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_inline_functions.cpp000066400000000000000000000101611475742701700275330ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_inline_functions.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/transformation_inline_function.h" #include "source/fuzz/transformation_split_block.h" namespace spvtools { namespace fuzz { FuzzerPassInlineFunctions::FuzzerPassInlineFunctions( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassInlineFunctions::Apply() { // |function_call_instructions| are the instructions that will be inlined. // First, they will be collected and then do the inlining in another loop. // This avoids changing the module while it is being inspected. std::vector function_call_instructions; for (auto& function : *GetIRContext()->module()) { for (auto& block : function) { for (auto& instruction : block) { if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfInliningFunction())) { continue; } // |instruction| must be suitable for inlining. if (!TransformationInlineFunction::IsSuitableForInlining( GetIRContext(), &instruction)) { continue; } function_call_instructions.push_back(&instruction); } } } // Once the function calls have been collected, it's time to actually create // and apply the inlining transformations. for (auto& function_call_instruction : function_call_instructions) { // If |function_call_instruction| is not the penultimate instruction in its // block or its block termination instruction is not OpBranch, then try to // split |function_call_block| such that the conditions are met. auto* function_call_block = GetIRContext()->get_instr_block(function_call_instruction); if ((function_call_instruction != &*--function_call_block->tail() || function_call_block->terminator()->opcode() != spv::Op::OpBranch) && !MaybeApplyTransformation(TransformationSplitBlock( MakeInstructionDescriptor(GetIRContext(), function_call_instruction->NextNode()), GetFuzzerContext()->GetFreshId()))) { continue; } auto* called_function = fuzzerutil::FindFunction( GetIRContext(), function_call_instruction->GetSingleWordInOperand(0)); // Mapping the called function instructions. std::map result_id_map; for (auto& called_function_block : *called_function) { // The called function entry block label will not be inlined. if (&called_function_block != &*called_function->entry()) { result_id_map[called_function_block.GetLabelInst()->result_id()] = GetFuzzerContext()->GetFreshId(); } for (auto& instruction_to_inline : called_function_block) { // The instructions are mapped to fresh ids. if (instruction_to_inline.HasResultId()) { result_id_map[instruction_to_inline.result_id()] = GetFuzzerContext()->GetFreshId(); } } } // Applies the inline function transformation. ApplyTransformation(TransformationInlineFunction( function_call_instruction->result_id(), result_id_map)); } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_inline_functions.h000066400000000000000000000030121475742701700271750ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_INLINE_FUNCTIONS_H_ #define SOURCE_FUZZ_FUZZER_PASS_INLINE_FUNCTIONS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // Looks for OpFunctionCall instructions and randomly decides which ones to // inline. If the instructions of the called function are going to be inlined, // then a mapping, between their result ids and suitable ids, is done. class FuzzerPassInlineFunctions : public FuzzerPass { public: FuzzerPassInlineFunctions(opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_INLINE_FUNCTIONS_H_ fuzzer_pass_interchange_signedness_of_integer_operands.cpp000066400000000000000000000136651475742701700347270ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/fuzz// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "fuzzer_pass_interchange_signedness_of_integer_operands.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/id_use_descriptor.h" #include "source/fuzz/transformation_record_synonymous_constants.h" #include "source/fuzz/transformation_replace_id_with_synonym.h" namespace spvtools { namespace fuzz { FuzzerPassInterchangeSignednessOfIntegerOperands:: FuzzerPassInterchangeSignednessOfIntegerOperands( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassInterchangeSignednessOfIntegerOperands::Apply() { assert(!GetFuzzerContext()->IsWgslCompatible() && "Cannot interchange signedness in WGSL"); // Make vector keeping track of all the uses we want to replace. // This is a vector of pairs, where the first element is an id use descriptor // identifying the use of a constant id and the second is the id that should // be used to replace it. std::vector> uses_to_replace; for (auto constant : GetIRContext()->GetConstants()) { uint32_t constant_id = constant->result_id(); // We want to record the synonymity of an integer constant with another // constant with opposite signedness, and this can only be done if they are // not irrelevant. if (GetTransformationContext()->GetFactManager()->IdIsIrrelevant( constant_id)) { continue; } uint32_t toggled_id = FindOrCreateToggledIntegerConstant(constant->result_id()); if (!toggled_id) { // Not an integer constant continue; } assert(!GetTransformationContext()->GetFactManager()->IdIsIrrelevant( toggled_id) && "FindOrCreateToggledConstant can't produce an irrelevant id"); // Record synonymous constants ApplyTransformation( TransformationRecordSynonymousConstants(constant_id, toggled_id)); // Find all the uses of the constant and, for each, probabilistically // decide whether to replace it. GetIRContext()->get_def_use_mgr()->ForEachUse( constant_id, [this, toggled_id, &uses_to_replace](opt::Instruction* use_inst, uint32_t use_index) -> void { if (GetFuzzerContext()->ChoosePercentage( GetFuzzerContext() ->GetChanceOfInterchangingSignednessOfIntegerOperands())) { MaybeAddUseToReplace(use_inst, use_index, toggled_id, &uses_to_replace); } }); } // Replace the ids if it is allowed. for (auto use_to_replace : uses_to_replace) { MaybeApplyTransformation(TransformationReplaceIdWithSynonym( use_to_replace.first, use_to_replace.second)); } } uint32_t FuzzerPassInterchangeSignednessOfIntegerOperands:: FindOrCreateToggledIntegerConstant(uint32_t id) { // |id| must not be a specialization constant because we do not know the value // of specialization constants. if (opt::IsSpecConstantInst( GetIRContext()->get_def_use_mgr()->GetDef(id)->opcode())) { return 0; } auto constant = GetIRContext()->get_constant_mgr()->FindDeclaredConstant(id); // This pass only toggles integer constants. if (!constant->AsIntConstant() && (!constant->AsVectorConstant() || !constant->AsVectorConstant()->component_type()->AsInteger())) { return 0; } if (auto integer = constant->AsIntConstant()) { auto type = integer->type()->AsInteger(); // Find or create and return the toggled constant. return FindOrCreateIntegerConstant(std::vector(integer->words()), type->width(), !type->IsSigned(), false); } // The constant is an integer vector. // Find the component type. auto component_type = constant->AsVectorConstant()->component_type()->AsInteger(); // Find or create the toggled component type. uint32_t toggled_component_type = FindOrCreateIntegerType( component_type->width(), !component_type->IsSigned()); // Get the information about the toggled components. We need to extract this // information now because the analyses might be invalidated, which would make // the constant and component_type variables invalid. std::vector> component_words; for (auto component : constant->AsVectorConstant()->GetComponents()) { component_words.push_back(component->AsIntConstant()->words()); } uint32_t width = component_type->width(); bool is_signed = !component_type->IsSigned(); std::vector toggled_components; // Find or create the toggled components. for (auto words : component_words) { toggled_components.push_back( FindOrCreateIntegerConstant(words, width, is_signed, false)); } // Find or create the required toggled vector type. uint32_t toggled_type = FindOrCreateVectorType( toggled_component_type, (uint32_t)toggled_components.size()); // Find or create and return the toggled vector constant. return FindOrCreateCompositeConstant(toggled_components, toggled_type, false); } } // namespace fuzz } // namespace spvtools fuzzer_pass_interchange_signedness_of_integer_operands.h000066400000000000000000000041241475742701700343620ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/fuzz// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_INTERCHANGE_SIGNEDNESS_OF_INTEGER_OPERANDS_H_ #define SOURCE_FUZZ_FUZZER_PASS_INTERCHANGE_SIGNEDNESS_OF_INTEGER_OPERANDS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // A pass that: // - Finds all the integer constant (scalar and vector) definitions in the // module and adds the definitions of the integer with the same data words but // opposite signedness. If the synonym is already in the module, it does not // add a new one. // - For each use of an integer constant where its signedness does not matter, // decides whether to change it to the id of the toggled constant. class FuzzerPassInterchangeSignednessOfIntegerOperands : public FuzzerPass { public: FuzzerPassInterchangeSignednessOfIntegerOperands( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; private: // Given the id of an integer constant (scalar or vector), it finds or creates // the corresponding toggled constant (the integer with the same data words // but opposite signedness). Returns the id of the toggled instruction if the // constant is an integer scalar or vector, 0 otherwise. uint32_t FindOrCreateToggledIntegerConstant(uint32_t id); }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_INTERCHANGE_SIGNEDNESS_OF_INTEGER_OPERANDS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_interchange_zero_like_constants.cpp000066400000000000000000000104121475742701700326120ustar00rootroot00000000000000// Copyright (c) 2020 Stefano Milizia // Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_interchange_zero_like_constants.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/id_use_descriptor.h" #include "source/fuzz/transformation_record_synonymous_constants.h" #include "source/fuzz/transformation_replace_id_with_synonym.h" namespace spvtools { namespace fuzz { FuzzerPassInterchangeZeroLikeConstants::FuzzerPassInterchangeZeroLikeConstants( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} uint32_t FuzzerPassInterchangeZeroLikeConstants::FindOrCreateToggledConstant( opt::Instruction* declaration) { // |declaration| must not be a specialization constant because we do not know // the value of specialization constants. if (opt::IsSpecConstantInst(declaration->opcode())) { return 0; } auto constant = GetIRContext()->get_constant_mgr()->FindDeclaredConstant( declaration->result_id()); // This pass only toggles zero-like constants if (!constant->IsZero()) { return 0; } if (constant->AsScalarConstant()) { return FindOrCreateNullConstant(declaration->type_id()); } else if (constant->AsNullConstant()) { // Add declaration of equivalent scalar constant auto kind = constant->type()->kind(); if (kind == opt::analysis::Type::kBool || kind == opt::analysis::Type::kInteger || kind == opt::analysis::Type::kFloat) { return FindOrCreateZeroConstant(declaration->type_id(), false); } } return 0; } void FuzzerPassInterchangeZeroLikeConstants::Apply() { // Make vector keeping track of all the uses we want to replace. // This is a vector of pairs, where the first element is an id use descriptor // identifying the use of a constant id and the second is the id that should // be used to replace it. std::vector> uses_to_replace; for (auto constant : GetIRContext()->GetConstants()) { uint32_t constant_id = constant->result_id(); if (GetTransformationContext()->GetFactManager()->IdIsIrrelevant( constant_id)) { continue; } uint32_t toggled_id = FindOrCreateToggledConstant(constant); if (!toggled_id) { // Not a zero-like constant continue; } assert(!GetTransformationContext()->GetFactManager()->IdIsIrrelevant( toggled_id) && "FindOrCreateToggledConstant can't produce an irrelevant id"); // Record synonymous constants ApplyTransformation( TransformationRecordSynonymousConstants(constant_id, toggled_id)); // Find all the uses of the constant and, for each, probabilistically // decide whether to replace it. GetIRContext()->get_def_use_mgr()->ForEachUse( constant_id, [this, toggled_id, &uses_to_replace](opt::Instruction* use_inst, uint32_t use_index) -> void { if (GetFuzzerContext()->ChoosePercentage( GetFuzzerContext() ->GetChanceOfInterchangingZeroLikeConstants())) { MaybeAddUseToReplace(use_inst, use_index, toggled_id, &uses_to_replace); } }); } // Replace the ids if it is allowed. for (auto use_to_replace : uses_to_replace) { MaybeApplyTransformation(TransformationReplaceIdWithSynonym( use_to_replace.first, use_to_replace.second)); } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_interchange_zero_like_constants.h000066400000000000000000000040501475742701700322600ustar00rootroot00000000000000// Copyright (c) 2020 Stefano Milizia // Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_INTERCHANGE_ZERO_LIKE_CONSTANTS_H_ #define SOURCE_FUZZ_FUZZER_PASS_INTERCHANGE_ZERO_LIKE_CONSTANTS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // A pass that: // - Finds all the zero-like constant definitions in the module and adds the // definitions of the corresponding synonym, recording the fact that they // are synonymous. If the synonym is already in the module, it does not // add a new one. // - For each use of a zero-like constant, decides whether to change it to the // id of the toggled constant. class FuzzerPassInterchangeZeroLikeConstants : public FuzzerPass { public: FuzzerPassInterchangeZeroLikeConstants( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; private: // Given the declaration of a zero-like constant, it finds or creates the // corresponding toggled constant (a scalar constant of value 0 becomes a // null constant of the same type and vice versa). // Returns the id of the toggled instruction if the constant is zero-like, // 0 otherwise. uint32_t FindOrCreateToggledConstant(opt::Instruction* declaration); }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_INTERCHANGE_ZERO_LIKE_CONSTANTS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_invert_comparison_operators.cpp000066400000000000000000000035051475742701700320300ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_invert_comparison_operators.h" #include "source/fuzz/fuzzer_context.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/transformation_invert_comparison_operator.h" namespace spvtools { namespace fuzz { FuzzerPassInvertComparisonOperators::FuzzerPassInvertComparisonOperators( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassInvertComparisonOperators::Apply() { GetIRContext()->module()->ForEachInst([this](const opt::Instruction* inst) { if (!TransformationInvertComparisonOperator::IsInversionSupported( inst->opcode())) { return; } if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfInvertingComparisonOperators())) { return; } ApplyTransformation(TransformationInvertComparisonOperator( inst->result_id(), GetFuzzerContext()->GetFreshId())); }); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_invert_comparison_operators.h000066400000000000000000000026071475742701700314770ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_INVERT_COMPARISON_OPERATORS_H_ #define SOURCE_FUZZ_FUZZER_PASS_INVERT_COMPARISON_OPERATORS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // Iterates over different comparison operators in the module (>=, <, > etc.) // and randomly decides whether to invert each one or not. class FuzzerPassInvertComparisonOperators : public FuzzerPass { public: FuzzerPassInvertComparisonOperators( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_INVERT_COMPARISON_OPERATORS_H_KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_make_vector_operations_dynamic.cpp000066400000000000000000000054541475742701700324440ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_make_vector_operations_dynamic.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/transformation_make_vector_operation_dynamic.h" namespace spvtools { namespace fuzz { FuzzerPassMakeVectorOperationsDynamic::FuzzerPassMakeVectorOperationsDynamic( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassMakeVectorOperationsDynamic::Apply() { for (auto& function : *GetIRContext()->module()) { for (auto& block : function) { for (auto& instruction : block) { // Randomly decide whether to try applying the transformation. if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext() ->GetChanceOfMakingVectorOperationDynamic())) { continue; } // |instruction| must be a vector operation. if (!TransformationMakeVectorOperationDynamic::IsVectorOperation( GetIRContext(), &instruction)) { continue; } // Make sure |instruction| has only one indexing operand. assert( instruction.NumInOperands() == (instruction.opcode() == spv::Op::OpCompositeExtract ? 2 : 3) && "FuzzerPassMakeVectorOperationsDynamic: the composite " "instruction must have " "only one indexing operand."); // Applies the make vector operation dynamic transformation. ApplyTransformation(TransformationMakeVectorOperationDynamic( instruction.result_id(), FindOrCreateIntegerConstant( {instruction.GetSingleWordInOperand( instruction.opcode() == spv::Op::OpCompositeExtract ? 1 : 2)}, 32, GetFuzzerContext()->ChooseEven(), false))); } } } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_make_vector_operations_dynamic.h000066400000000000000000000026141475742701700321040ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_MAKE_VECTOR_OPERATIONS_DYNAMIC_H_ #define SOURCE_FUZZ_FUZZER_PASS_MAKE_VECTOR_OPERATIONS_DYNAMIC_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // Looks for OpCompositeExtract/Insert instructions on vectors, and replaces // them with OpVectorExtract/InsertDynamic. class FuzzerPassMakeVectorOperationsDynamic : public FuzzerPass { public: FuzzerPassMakeVectorOperationsDynamic( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_MAKE_VECTOR_OPERATIONS_DYNAMIC_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_merge_blocks.cpp000066400000000000000000000044751475742701700266340ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_merge_blocks.h" #include #include "source/fuzz/transformation_merge_blocks.h" namespace spvtools { namespace fuzz { FuzzerPassMergeBlocks::FuzzerPassMergeBlocks( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassMergeBlocks::Apply() { // First we populate a sequence of transformations that we might consider // applying. std::vector potential_transformations; // We do this by considering every block of every function. for (auto& function : *GetIRContext()->module()) { for (auto& block : function) { // We probabilistically decide to ignore some blocks. if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfMergingBlocks())) { continue; } // For other blocks, we add a transformation to merge the block into its // predecessor if that transformation would be applicable. TransformationMergeBlocks transformation(block.id()); if (transformation.IsApplicable(GetIRContext(), *GetTransformationContext())) { potential_transformations.push_back(transformation); } } } while (!potential_transformations.empty()) { auto transformation = GetFuzzerContext()->RemoveAtRandomIndex(&potential_transformations); MaybeApplyTransformation(transformation); } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_merge_blocks.h000066400000000000000000000024551475742701700262750ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_MERGE_BLOCKS_H_ #define SOURCE_FUZZ_FUZZER_PASS_MERGE_BLOCKS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // A fuzzer pass for merging blocks in the module. class FuzzerPassMergeBlocks : public FuzzerPass { public: FuzzerPassMergeBlocks(opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_MERGE_BLOCKS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_merge_function_returns.cpp000066400000000000000000000326141475742701700307620ustar00rootroot00000000000000// Copyright (c) 2020 Stefano Milizia // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_merge_function_returns.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/transformation_add_early_terminator_wrapper.h" #include "source/fuzz/transformation_merge_function_returns.h" #include "source/fuzz/transformation_wrap_early_terminator_in_function.h" namespace spvtools { namespace fuzz { FuzzerPassMergeFunctionReturns::FuzzerPassMergeFunctionReturns( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassMergeFunctionReturns::Apply() { // The pass might add new functions to the module (due to wrapping early // terminator instructions in function calls), so we record the functions that // are currently present and then iterate over them. std::vector functions; for (auto& function : *GetIRContext()->module()) { functions.emplace_back(&function); } for (auto* function : functions) { // Randomly decide whether to consider this function. if (GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfMergingFunctionReturns())) { continue; } // We skip wrappers for early terminators, since this fuzzer pass introduces // such wrappers to eliminate early terminators. if (IsEarlyTerminatorWrapper(*function)) { continue; } // Only consider functions that have early returns. if (!function->HasEarlyReturn()) { continue; } // Wrap early terminators in function calls. ForEachInstructionWithInstructionDescriptor( function, [this, function]( opt::BasicBlock* /*unused*/, opt::BasicBlock::iterator inst_it, const protobufs::InstructionDescriptor& instruction_descriptor) { const spv::Op opcode = inst_it->opcode(); switch (opcode) { case spv::Op::OpKill: case spv::Op::OpUnreachable: case spv::Op::OpTerminateInvocation: { // This is an early termination instruction - we need to wrap it // so that it becomes a return. if (TransformationWrapEarlyTerminatorInFunction:: MaybeGetWrapperFunction(GetIRContext(), opcode) == nullptr) { // We don't have a suitable wrapper function, so create one. ApplyTransformation(TransformationAddEarlyTerminatorWrapper( GetFuzzerContext()->GetFreshId(), GetFuzzerContext()->GetFreshId(), opcode)); } // If the function has non-void return type then we need a // suitable value to use in an OpReturnValue instruction. opt::Instruction* function_return_type = GetIRContext()->get_def_use_mgr()->GetDef( function->type_id()); uint32_t returned_value_id; if (function_return_type->opcode() == spv::Op::OpTypeVoid) { // No value is needed. returned_value_id = 0; } else if (fuzzerutil::CanCreateConstant( GetIRContext(), function_return_type->result_id())) { // We favour returning an irrelevant zero. returned_value_id = FindOrCreateZeroConstant( function_return_type->result_id(), true); } else { // It's not possible to use an irrelevant zero, so we use an // OpUndef instead. returned_value_id = FindOrCreateGlobalUndef(function_return_type->result_id()); } // Wrap the early termination instruction in a function call. ApplyTransformation(TransformationWrapEarlyTerminatorInFunction( GetFuzzerContext()->GetFreshId(), instruction_descriptor, returned_value_id)); break; } default: break; } }); // Get the return blocks. auto return_blocks = fuzzerutil::GetReachableReturnBlocks( GetIRContext(), function->result_id()); // Only go ahead if there is more than one reachable return block. if (return_blocks.size() <= 1) { continue; } // Make sure that OpConstantTrue and OpConstantFalse are in the module. FindOrCreateBoolConstant(true, false); FindOrCreateBoolConstant(false, false); // Collect the ids available after the entry block of the function. auto ids_available_after_entry_block = GetTypesToIdsAvailableAfterEntryBlock(function); // If the entry block does not branch unconditionally to another block, // split it. if (function->entry()->terminator()->opcode() != spv::Op::OpBranch) { SplitBlockAfterOpPhiOrOpVariable(function->entry()->id()); } // Collect the merge blocks of the function whose corresponding loops // contain return blocks. auto merge_blocks = GetMergeBlocksOfLoopsContainingBlocks(return_blocks); // Split the merge blocks, if they contain instructions different from // OpLabel, OpPhi and OpBranch. Collect the new ids of merge blocks. std::vector actual_merge_blocks; for (uint32_t merge_block : merge_blocks) { opt::BasicBlock* block = GetIRContext()->get_instr_block(merge_block); // We don't need to split blocks that are already suitable (they only // contain OpLabel, OpPhi or OpBranch instructions). if (GetIRContext() ->get_instr_block(merge_block) ->WhileEachInst([](opt::Instruction* inst) { return inst->opcode() == spv::Op::OpLabel || inst->opcode() == spv::Op::OpPhi || inst->opcode() == spv::Op::OpBranch; })) { actual_merge_blocks.emplace_back(merge_block); continue; } // If the merge block is also a loop header, we need to add a preheader, // which will be the new merge block. if (block->IsLoopHeader()) { actual_merge_blocks.emplace_back( GetOrCreateSimpleLoopPreheader(merge_block)->id()); continue; } // If the merge block is not a loop header, we must split it after the // last OpPhi instruction. The merge block will be the first of the pair // of blocks obtained after splitting, and it keeps the original id. SplitBlockAfterOpPhiOrOpVariable(merge_block); actual_merge_blocks.emplace_back(merge_block); } // Get the ids needed by the transformation. const uint32_t outer_header_id = GetFuzzerContext()->GetFreshId(); const uint32_t unreachable_continue_id = GetFuzzerContext()->GetFreshId(); const uint32_t outer_return_id = GetFuzzerContext()->GetFreshId(); bool function_is_void = GetIRContext()->get_type_mgr()->GetType(function->type_id())->AsVoid(); // We only need a return value if the function is not void. uint32_t return_val_id = function_is_void ? 0 : GetFuzzerContext()->GetFreshId(); // We only need a placeholder for the return value if the function is not // void and there is at least one relevant merge block. uint32_t returnable_val_id = 0; if (!function_is_void && !actual_merge_blocks.empty()) { // If there is an id of the suitable type, choose one at random. if (ids_available_after_entry_block.count(function->type_id())) { const auto& candidates = ids_available_after_entry_block[function->type_id()]; returnable_val_id = candidates[GetFuzzerContext()->RandomIndex(candidates)]; } else { // If there is no id, add a global OpUndef. uint32_t suitable_id = FindOrCreateGlobalUndef(function->type_id()); // Add the new id to the map of available ids. ids_available_after_entry_block.emplace( function->type_id(), std::vector({suitable_id})); returnable_val_id = suitable_id; } } // Collect all the ids needed for merge blocks. auto merge_blocks_info = GetInfoNeededForMergeBlocks( actual_merge_blocks, &ids_available_after_entry_block); // Apply the transformation if it is applicable (it could be inapplicable if // adding new predecessors to merge blocks breaks dominance rules). MaybeApplyTransformation(TransformationMergeFunctionReturns( function->result_id(), outer_header_id, unreachable_continue_id, outer_return_id, return_val_id, returnable_val_id, merge_blocks_info)); } } std::map> FuzzerPassMergeFunctionReturns::GetTypesToIdsAvailableAfterEntryBlock( opt::Function* function) const { std::map> result; // Consider all global declarations for (auto& global : GetIRContext()->module()->types_values()) { if (global.HasResultId() && global.type_id()) { if (!result.count(global.type_id())) { result.emplace(global.type_id(), std::vector()); } result[global.type_id()].emplace_back(global.result_id()); } } // Consider all function parameters function->ForEachParam([&result](opt::Instruction* param) { if (param->HasResultId() && param->type_id()) { if (!result.count(param->type_id())) { result.emplace(param->type_id(), std::vector()); } result[param->type_id()].emplace_back(param->result_id()); } }); // Consider all the instructions in the entry block. for (auto& inst : *function->entry()) { if (inst.HasResultId() && inst.type_id()) { if (!result.count(inst.type_id())) { result.emplace(inst.type_id(), std::vector()); } result[inst.type_id()].emplace_back(inst.result_id()); } } return result; } std::set FuzzerPassMergeFunctionReturns::GetMergeBlocksOfLoopsContainingBlocks( const std::set& blocks) const { std::set result; for (uint32_t block : blocks) { uint32_t merge_block = GetIRContext()->GetStructuredCFGAnalysis()->LoopMergeBlock(block); while (merge_block != 0 && !result.count(merge_block)) { // Add a new entry. result.emplace(merge_block); // Walk up the loop tree. block = merge_block; merge_block = GetIRContext()->GetStructuredCFGAnalysis()->LoopMergeBlock( merge_block); } } return result; } std::vector FuzzerPassMergeFunctionReturns::GetInfoNeededForMergeBlocks( const std::vector& merge_blocks, std::map>* ids_available_after_entry_block) { std::vector result; for (uint32_t merge_block : merge_blocks) { protobufs::ReturnMergingInfo info; info.set_merge_block_id(merge_block); info.set_is_returning_id(this->GetFuzzerContext()->GetFreshId()); info.set_maybe_return_val_id(this->GetFuzzerContext()->GetFreshId()); // Add all the ids needed for the OpPhi instructions. this->GetIRContext() ->get_instr_block(merge_block) ->ForEachPhiInst([this, &info, &ids_available_after_entry_block]( opt::Instruction* phi_inst) { protobufs::UInt32Pair entry; entry.set_first(phi_inst->result_id()); // If there is an id of the suitable type, choose one at random. if (ids_available_after_entry_block->count(phi_inst->type_id())) { auto& candidates = ids_available_after_entry_block->at(phi_inst->type_id()); entry.set_second( candidates[this->GetFuzzerContext()->RandomIndex(candidates)]); } else { // If there is no id, add a global OpUndef. uint32_t suitable_id = this->FindOrCreateGlobalUndef(phi_inst->type_id()); // Add the new id to the map of available ids. ids_available_after_entry_block->emplace( phi_inst->type_id(), std::vector({suitable_id})); entry.set_second(suitable_id); } // Add the entry to the list. *info.add_opphi_to_suitable_id() = entry; }); result.emplace_back(info); } return result; } bool FuzzerPassMergeFunctionReturns::IsEarlyTerminatorWrapper( const opt::Function& function) const { for (spv::Op opcode : {spv::Op::OpKill, spv::Op::OpUnreachable, spv::Op::OpTerminateInvocation}) { if (TransformationWrapEarlyTerminatorInFunction::MaybeGetWrapperFunction( GetIRContext(), opcode) == &function) { return true; } } return false; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_merge_function_returns.h000066400000000000000000000056231475742701700304270ustar00rootroot00000000000000// Copyright (c) 2020 Stefano Milizia // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_MERGE_FUNCTION_RETURNS_H_ #define SOURCE_FUZZ_FUZZER_PASS_MERGE_FUNCTION_RETURNS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // A fuzzer pass for changing functions in the module so that they don't have an // early return. When handling a function the pass first eliminates early // terminator instructions, such as OpKill, by wrapping them in functions and // replacing them with a function call followed by a return. The return // instructions that arise are then modified so that the function does not have // early returns. class FuzzerPassMergeFunctionReturns : public FuzzerPass { public: FuzzerPassMergeFunctionReturns( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; private: // Returns a map from type ids to a list of ids with that type and which are // available at the end of the entry block of |function|. std::map> GetTypesToIdsAvailableAfterEntryBlock(opt::Function* function) const; // Returns the set of all the loop merge blocks whose corresponding loops // contain at least one of the blocks in |blocks|. std::set GetMergeBlocksOfLoopsContainingBlocks( const std::set& blocks) const; // Returns a list of ReturnMergingInfo messages, containing the information // needed by the transformation for each of the relevant merge blocks. // If a new id is created (because |ids_available_after_entry_block| does not // have an entry for the corresponding type), a new entry is added to // |ids_available_after_entry_block|, mapping its type to a singleton set // containing it. std::vector GetInfoNeededForMergeBlocks( const std::vector& merge_blocks, std::map>* ids_available_after_entry_block); // Returns true if and only if |function| is a wrapper for an early terminator // instruction such as OpKill. bool IsEarlyTerminatorWrapper(const opt::Function& function) const; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_MERGE_FUNCTION_RETURNS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_mutate_pointers.cpp000066400000000000000000000054231475742701700274140ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_mutate_pointers.h" #include "source/fuzz/fuzzer_context.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/transformation_mutate_pointer.h" namespace spvtools { namespace fuzz { FuzzerPassMutatePointers::FuzzerPassMutatePointers( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassMutatePointers::Apply() { ForEachInstructionWithInstructionDescriptor( [this](opt::Function* function, opt::BasicBlock* block, opt::BasicBlock::iterator inst_it, const protobufs::InstructionDescriptor& instruction_descriptor) { if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfMutatingPointer())) { return; } if (!fuzzerutil::CanInsertOpcodeBeforeInstruction(spv::Op::OpLoad, inst_it)) { return; } auto available_pointers = FindAvailableInstructions( function, block, inst_it, [](opt::IRContext* ir_context, opt::Instruction* inst) { return TransformationMutatePointer::IsValidPointerInstruction( ir_context, *inst); }); if (available_pointers.empty()) { return; } const auto* pointer_inst = available_pointers[GetFuzzerContext()->RandomIndex( available_pointers)]; // Make sure there is an irrelevant constant in the module. FindOrCreateZeroConstant(fuzzerutil::GetPointeeTypeIdFromPointerType( GetIRContext(), pointer_inst->type_id()), true); ApplyTransformation(TransformationMutatePointer( pointer_inst->result_id(), GetFuzzerContext()->GetFreshId(), instruction_descriptor)); }); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_mutate_pointers.h000066400000000000000000000025411475742701700270570ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_MUTATE_POINTERS_H_ #define SOURCE_FUZZ_FUZZER_PASS_MUTATE_POINTERS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // Randomly mutates the value of each pointer instruction in the module. class FuzzerPassMutatePointers : public FuzzerPass { public: FuzzerPassMutatePointers(opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_MUTATE_POINTERS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_obfuscate_constants.cpp000066400000000000000000000551671475742701700302530ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_obfuscate_constants.h" #include #include #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/transformation_replace_boolean_constant_with_constant_binary.h" #include "source/fuzz/transformation_replace_constant_with_uniform.h" #include "source/fuzz/uniform_buffer_element_descriptor.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { FuzzerPassObfuscateConstants::FuzzerPassObfuscateConstants( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassObfuscateConstants::ObfuscateBoolConstantViaConstantPair( uint32_t depth, const protobufs::IdUseDescriptor& bool_constant_use, const std::vector& greater_than_opcodes, const std::vector& less_than_opcodes, uint32_t constant_id_1, uint32_t constant_id_2, bool first_constant_is_larger) { auto bool_constant_opcode = GetIRContext() ->get_def_use_mgr() ->GetDef(bool_constant_use.id_of_interest()) ->opcode(); assert((bool_constant_opcode == spv::Op::OpConstantFalse || bool_constant_opcode == spv::Op::OpConstantTrue) && "Precondition: this must be a usage of a boolean constant."); // Pick an opcode at random. First randomly decide whether to generate // a 'greater than' or 'less than' kind of opcode, and then select a // random opcode from the resulting subset. spv::Op comparison_opcode; if (GetFuzzerContext()->ChooseEven()) { comparison_opcode = greater_than_opcodes[GetFuzzerContext()->RandomIndex( greater_than_opcodes)]; } else { comparison_opcode = less_than_opcodes[GetFuzzerContext()->RandomIndex(less_than_opcodes)]; } // We now need to decide how to order constant_id_1 and constant_id_2 such // that 'constant_id_1 comparison_opcode constant_id_2' evaluates to the // boolean constant. const bool is_greater_than_opcode = std::find(greater_than_opcodes.begin(), greater_than_opcodes.end(), comparison_opcode) != greater_than_opcodes.end(); uint32_t lhs_id; uint32_t rhs_id; if ((bool_constant_opcode == spv::Op::OpConstantTrue && first_constant_is_larger == is_greater_than_opcode) || (bool_constant_opcode == spv::Op::OpConstantFalse && first_constant_is_larger != is_greater_than_opcode)) { lhs_id = constant_id_1; rhs_id = constant_id_2; } else { lhs_id = constant_id_2; rhs_id = constant_id_1; } // We can now make a transformation that will replace |bool_constant_use| // with an expression of the form (written using infix notation): // |lhs_id| |comparison_opcode| |rhs_id| auto transformation = TransformationReplaceBooleanConstantWithConstantBinary( bool_constant_use, lhs_id, rhs_id, comparison_opcode, GetFuzzerContext()->GetFreshId()); // The transformation should be applicable by construction. assert( transformation.IsApplicable(GetIRContext(), *GetTransformationContext())); // Applying this transformation yields a pointer to the new instruction that // computes the result of the binary expression. auto binary_operator_instruction = transformation.ApplyWithResult( GetIRContext(), GetTransformationContext()); // Add this transformation to the sequence of transformations that have been // applied. *GetTransformations()->add_transformation() = transformation.ToMessage(); // Having made a binary expression, there may now be opportunities to further // obfuscate the constants used as the LHS and RHS of the expression (e.g. by // replacing them with loads from known uniforms). // // We thus consider operands 0 and 1 (LHS and RHS in turn). for (uint32_t index : {0u, 1u}) { // We randomly decide, based on the current depth of obfuscation, whether // to further obfuscate this operand. if (GetFuzzerContext()->GoDeeperInConstantObfuscation(depth)) { auto in_operand_use = MakeIdUseDescriptor( binary_operator_instruction->GetSingleWordInOperand(index), MakeInstructionDescriptor(binary_operator_instruction->result_id(), binary_operator_instruction->opcode(), 0), index); ObfuscateConstant(depth + 1, in_operand_use); } } } void FuzzerPassObfuscateConstants::ObfuscateBoolConstantViaFloatConstantPair( uint32_t depth, const protobufs::IdUseDescriptor& bool_constant_use, uint32_t float_constant_id_1, uint32_t float_constant_id_2) { auto float_constant_1 = GetIRContext() ->get_constant_mgr() ->FindDeclaredConstant(float_constant_id_1) ->AsFloatConstant(); auto float_constant_2 = GetIRContext() ->get_constant_mgr() ->FindDeclaredConstant(float_constant_id_2) ->AsFloatConstant(); assert(float_constant_1->words() != float_constant_2->words() && "The constants should not be identical."); assert(std::isfinite(float_constant_1->GetValueAsDouble()) && "The constants must be finite numbers."); assert(std::isfinite(float_constant_2->GetValueAsDouble()) && "The constants must be finite numbers."); bool first_constant_is_larger; assert(float_constant_1->type()->AsFloat()->width() == float_constant_2->type()->AsFloat()->width() && "First and second floating-point constants must have the same width."); if (float_constant_1->type()->AsFloat()->width() == 32) { first_constant_is_larger = float_constant_1->GetFloat() > float_constant_2->GetFloat(); } else { assert(float_constant_1->type()->AsFloat()->width() == 64 && "Supported floating-point widths are 32 and 64."); first_constant_is_larger = float_constant_1->GetDouble() > float_constant_2->GetDouble(); } std::vector greater_than_opcodes{ spv::Op::OpFOrdGreaterThan, spv::Op::OpFOrdGreaterThanEqual, spv::Op::OpFUnordGreaterThan, spv::Op::OpFUnordGreaterThanEqual}; std::vector less_than_opcodes{ spv::Op::OpFOrdGreaterThan, spv::Op::OpFOrdGreaterThanEqual, spv::Op::OpFUnordGreaterThan, spv::Op::OpFUnordGreaterThanEqual}; ObfuscateBoolConstantViaConstantPair( depth, bool_constant_use, greater_than_opcodes, less_than_opcodes, float_constant_id_1, float_constant_id_2, first_constant_is_larger); } void FuzzerPassObfuscateConstants:: ObfuscateBoolConstantViaSignedIntConstantPair( uint32_t depth, const protobufs::IdUseDescriptor& bool_constant_use, uint32_t signed_int_constant_id_1, uint32_t signed_int_constant_id_2) { auto signed_int_constant_1 = GetIRContext() ->get_constant_mgr() ->FindDeclaredConstant(signed_int_constant_id_1) ->AsIntConstant(); auto signed_int_constant_2 = GetIRContext() ->get_constant_mgr() ->FindDeclaredConstant(signed_int_constant_id_2) ->AsIntConstant(); assert(signed_int_constant_1->words() != signed_int_constant_2->words() && "The constants should not be identical."); bool first_constant_is_larger; assert(signed_int_constant_1->type()->AsInteger()->width() == signed_int_constant_2->type()->AsInteger()->width() && "First and second floating-point constants must have the same width."); assert(signed_int_constant_1->type()->AsInteger()->IsSigned()); assert(signed_int_constant_2->type()->AsInteger()->IsSigned()); if (signed_int_constant_1->type()->AsFloat()->width() == 32) { first_constant_is_larger = signed_int_constant_1->GetS32() > signed_int_constant_2->GetS32(); } else { assert(signed_int_constant_1->type()->AsFloat()->width() == 64 && "Supported integer widths are 32 and 64."); first_constant_is_larger = signed_int_constant_1->GetS64() > signed_int_constant_2->GetS64(); } std::vector greater_than_opcodes{spv::Op::OpSGreaterThan, spv::Op::OpSGreaterThanEqual}; std::vector less_than_opcodes{spv::Op::OpSLessThan, spv::Op::OpSLessThanEqual}; ObfuscateBoolConstantViaConstantPair( depth, bool_constant_use, greater_than_opcodes, less_than_opcodes, signed_int_constant_id_1, signed_int_constant_id_2, first_constant_is_larger); } void FuzzerPassObfuscateConstants:: ObfuscateBoolConstantViaUnsignedIntConstantPair( uint32_t depth, const protobufs::IdUseDescriptor& bool_constant_use, uint32_t unsigned_int_constant_id_1, uint32_t unsigned_int_constant_id_2) { auto unsigned_int_constant_1 = GetIRContext() ->get_constant_mgr() ->FindDeclaredConstant(unsigned_int_constant_id_1) ->AsIntConstant(); auto unsigned_int_constant_2 = GetIRContext() ->get_constant_mgr() ->FindDeclaredConstant(unsigned_int_constant_id_2) ->AsIntConstant(); assert(unsigned_int_constant_1->words() != unsigned_int_constant_2->words() && "The constants should not be identical."); bool first_constant_is_larger; assert(unsigned_int_constant_1->type()->AsInteger()->width() == unsigned_int_constant_2->type()->AsInteger()->width() && "First and second floating-point constants must have the same width."); assert(!unsigned_int_constant_1->type()->AsInteger()->IsSigned()); assert(!unsigned_int_constant_2->type()->AsInteger()->IsSigned()); if (unsigned_int_constant_1->type()->AsFloat()->width() == 32) { first_constant_is_larger = unsigned_int_constant_1->GetU32() > unsigned_int_constant_2->GetU32(); } else { assert(unsigned_int_constant_1->type()->AsFloat()->width() == 64 && "Supported integer widths are 32 and 64."); first_constant_is_larger = unsigned_int_constant_1->GetU64() > unsigned_int_constant_2->GetU64(); } std::vector greater_than_opcodes{spv::Op::OpUGreaterThan, spv::Op::OpUGreaterThanEqual}; std::vector less_than_opcodes{spv::Op::OpULessThan, spv::Op::OpULessThanEqual}; ObfuscateBoolConstantViaConstantPair( depth, bool_constant_use, greater_than_opcodes, less_than_opcodes, unsigned_int_constant_id_1, unsigned_int_constant_id_2, first_constant_is_larger); } std::vector> FuzzerPassObfuscateConstants::GetConstantWordsFromUniformsForType( uint32_t type_id) { assert(type_id && "Type id can't be 0"); std::vector> result; for (const auto& facts_and_types : GetTransformationContext() ->GetFactManager() ->GetConstantUniformFactsAndTypes()) { if (facts_and_types.second != type_id) { continue; } std::vector words(facts_and_types.first.constant_word().begin(), facts_and_types.first.constant_word().end()); if (std::find(result.begin(), result.end(), words) == result.end()) { result.push_back(std::move(words)); } } return result; } void FuzzerPassObfuscateConstants::ObfuscateBoolConstant( uint32_t depth, const protobufs::IdUseDescriptor& constant_use) { // We want to replace the boolean constant use with a binary expression over // scalar constants, but only if we can then potentially replace the constants // with uniforms of the same value. auto available_types_with_uniforms = GetTransformationContext() ->GetFactManager() ->GetTypesForWhichUniformValuesAreKnown(); if (available_types_with_uniforms.empty()) { // Do not try to obfuscate if we do not have access to any uniform // elements with known values. return; } auto chosen_type_id = available_types_with_uniforms[GetFuzzerContext()->RandomIndex( available_types_with_uniforms)]; auto available_constant_words = GetConstantWordsFromUniformsForType(chosen_type_id); if (available_constant_words.size() == 1) { // TODO(afd): for now we only obfuscate a boolean if there are at least // two constants available from uniforms, so that we can do a // comparison between them. It would be good to be able to do the // obfuscation even if there is only one such constant, if there is // also another regular constant available. return; } assert(!available_constant_words.empty() && "There exists a fact but no constants - impossible"); // We know we have at least two known-to-be-constant uniforms of the chosen // type. Pick one of them at random. auto constant_index_1 = GetFuzzerContext()->RandomIndex(available_constant_words); uint32_t constant_index_2; // Now choose another one distinct from the first one. do { constant_index_2 = GetFuzzerContext()->RandomIndex(available_constant_words); } while (constant_index_1 == constant_index_2); auto constant_id_1 = FindOrCreateConstant( available_constant_words[constant_index_1], chosen_type_id, false); auto constant_id_2 = FindOrCreateConstant( available_constant_words[constant_index_2], chosen_type_id, false); assert(constant_id_1 != 0 && constant_id_2 != 0 && "We should not find an available constant with an id of 0."); // Now perform the obfuscation, according to whether the type of the constants // is float, signed int, or unsigned int. auto chosen_type = GetIRContext()->get_type_mgr()->GetType(chosen_type_id); if (chosen_type->AsFloat()) { ObfuscateBoolConstantViaFloatConstantPair(depth, constant_use, constant_id_1, constant_id_2); } else { assert(chosen_type->AsInteger() && "We should only have uniform facts about ints and floats."); if (chosen_type->AsInteger()->IsSigned()) { ObfuscateBoolConstantViaSignedIntConstantPair( depth, constant_use, constant_id_1, constant_id_2); } else { ObfuscateBoolConstantViaUnsignedIntConstantPair( depth, constant_use, constant_id_1, constant_id_2); } } } void FuzzerPassObfuscateConstants::ObfuscateScalarConstant( uint32_t /*depth*/, const protobufs::IdUseDescriptor& constant_use) { // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/2670): consider // additional ways to obfuscate scalar constants. // Check whether we know that any uniforms are guaranteed to be equal to the // scalar constant associated with |constant_use|. auto uniform_descriptors = GetTransformationContext() ->GetFactManager() ->GetUniformDescriptorsForConstant(constant_use.id_of_interest()); if (uniform_descriptors.empty()) { // No relevant uniforms, so do not obfuscate. return; } // Choose a random available uniform known to be equal to the constant. const auto& uniform_descriptor = uniform_descriptors[GetFuzzerContext()->RandomIndex(uniform_descriptors)]; // Make sure the module has OpConstant instructions for each index used to // access a uniform. for (auto index : uniform_descriptor.index()) { FindOrCreateIntegerConstant({index}, 32, true, false); } // Make sure the module has OpTypePointer that points to the element type of // the uniform. const auto* uniform_variable_instr = FindUniformVariable(uniform_descriptor, GetIRContext(), true); assert(uniform_variable_instr && "Uniform variable does not exist or not unique."); const auto* uniform_variable_type_intr = GetIRContext()->get_def_use_mgr()->GetDef( uniform_variable_instr->type_id()); assert(uniform_variable_type_intr && "Uniform variable has invalid type"); auto element_type_id = fuzzerutil::WalkCompositeTypeIndices( GetIRContext(), uniform_variable_type_intr->GetSingleWordInOperand(1), uniform_descriptor.index()); assert(element_type_id && "Type of uniform variable is invalid"); FindOrCreatePointerType(element_type_id, spv::StorageClass::Uniform); // Create, apply and record a transformation to replace the constant use with // the result of a load from the chosen uniform. ApplyTransformation(TransformationReplaceConstantWithUniform( constant_use, uniform_descriptor, GetFuzzerContext()->GetFreshId(), GetFuzzerContext()->GetFreshId())); } void FuzzerPassObfuscateConstants::ObfuscateConstant( uint32_t depth, const protobufs::IdUseDescriptor& constant_use) { switch (GetIRContext() ->get_def_use_mgr() ->GetDef(constant_use.id_of_interest()) ->opcode()) { case spv::Op::OpConstantTrue: case spv::Op::OpConstantFalse: ObfuscateBoolConstant(depth, constant_use); break; case spv::Op::OpConstant: ObfuscateScalarConstant(depth, constant_use); break; default: assert(false && "The opcode should be one of the above."); break; } } void FuzzerPassObfuscateConstants::MaybeAddConstantIdUse( const opt::Instruction& inst, uint32_t in_operand_index, uint32_t base_instruction_result_id, const std::map& skipped_opcode_count, std::vector* constant_uses) { if (inst.GetInOperand(in_operand_index).type != SPV_OPERAND_TYPE_ID) { // The operand is not an id, so it cannot be a constant id. return; } auto operand_id = inst.GetSingleWordInOperand(in_operand_index); auto operand_definition = GetIRContext()->get_def_use_mgr()->GetDef(operand_id); switch (operand_definition->opcode()) { case spv::Op::OpConstantFalse: case spv::Op::OpConstantTrue: case spv::Op::OpConstant: { // The operand is a constant id, so make an id use descriptor and record // it. protobufs::IdUseDescriptor id_use_descriptor; id_use_descriptor.set_id_of_interest(operand_id); id_use_descriptor.mutable_enclosing_instruction() ->set_target_instruction_opcode(uint32_t(inst.opcode())); id_use_descriptor.mutable_enclosing_instruction() ->set_base_instruction_result_id(base_instruction_result_id); id_use_descriptor.mutable_enclosing_instruction() ->set_num_opcodes_to_ignore( skipped_opcode_count.find(inst.opcode()) == skipped_opcode_count.end() ? 0 : skipped_opcode_count.at(inst.opcode())); id_use_descriptor.set_in_operand_index(in_operand_index); constant_uses->push_back(id_use_descriptor); } break; default: break; } } void FuzzerPassObfuscateConstants::Apply() { // First, gather up all the constant uses available in the module, by going // through each block in each function. std::vector constant_uses; for (auto& function : *GetIRContext()->module()) { for (auto& block : function) { // For each constant use we encounter we are going to make an id use // descriptor. An id use is described with respect to a base instruction; // if there are instructions at the start of the block without result ids, // the base instruction will have to be the block's label. uint32_t base_instruction_result_id = block.id(); // An id use descriptor also records how many instructions of a particular // opcode need to be skipped in order to find the instruction of interest // from the base instruction. We maintain a mapping that records a skip // count for each relevant opcode. std::map skipped_opcode_count; // Go through each instruction in the block. for (auto& inst : block) { if (inst.HasResultId()) { // The instruction has a result id, so can be used as the base // instruction from now on, until another instruction with a result id // is encountered. base_instruction_result_id = inst.result_id(); // Opcode skip counts were with respect to the previous base // instruction and are now irrelevant. skipped_opcode_count.clear(); } // The instruction must not be an OpVariable, the only id that an // OpVariable uses is an initializer id, which has to remain // constant. if (inst.opcode() != spv::Op::OpVariable) { // Consider each operand of the instruction, and add a constant id // use for the operand if relevant. for (uint32_t in_operand_index = 0; in_operand_index < inst.NumInOperands(); in_operand_index++) { MaybeAddConstantIdUse(inst, in_operand_index, base_instruction_result_id, skipped_opcode_count, &constant_uses); } } if (!inst.HasResultId()) { // The instruction has no result id, so in order to identify future id // uses for instructions with this opcode from the existing base // instruction, we need to increase the skip count for this opcode. skipped_opcode_count[inst.opcode()] = skipped_opcode_count.find(inst.opcode()) == skipped_opcode_count.end() ? 1 : skipped_opcode_count[inst.opcode()] + 1; } } } } // Go through the constant uses in a random order by repeatedly pulling out a // constant use at a random index. while (!constant_uses.empty()) { auto index = GetFuzzerContext()->RandomIndex(constant_uses); auto constant_use = std::move(constant_uses[index]); constant_uses.erase(constant_uses.begin() + index); // Decide probabilistically whether to skip or obfuscate this constant use. if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfObfuscatingConstant())) { continue; } ObfuscateConstant(0, constant_use); } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_obfuscate_constants.h000066400000000000000000000120351475742701700277030ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_OBFUSCATE_CONSTANTS_H_ #define SOURCE_FUZZ_FUZZER_PASS_OBFUSCATE_CONSTANTS_H_ #include #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // A fuzzer pass for turning uses of constants into more complex forms. // Examples include replacing 'true' with '42 < 52', and replacing '42' with // 'a.b.c' if 'a.b.c' is known to hold the value '42'. class FuzzerPassObfuscateConstants : public FuzzerPass { public: FuzzerPassObfuscateConstants( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; private: // Applies 0 or more transformations to potentially obfuscate the constant // use represented by |constant_use|. The |depth| parameter controls how // deeply obfuscation can recurse. void ObfuscateConstant(uint32_t depth, const protobufs::IdUseDescriptor& constant_use); // This method will try to turn |constant_use|, required to be a use of a // boolean constant, into a binary expression on scalar constants, which may // themselves be recursively obfuscated. void ObfuscateBoolConstant(uint32_t depth, const protobufs::IdUseDescriptor& constant_use); // This method will try to turn |constant_use|, required to be a use of a // scalar constant, into the value loaded from a uniform known to have the // same value as the constant (if one exists). void ObfuscateScalarConstant(uint32_t depth, const protobufs::IdUseDescriptor& constant_use); // Applies a transformation to replace the boolean constant usage represented // by |bool_constant_use| with a binary expression involving // |float_constant_id_1| and |float_constant_id_2|, which must not be equal // to one another. Possibly further obfuscates the uses of these float // constants. The |depth| parameter controls how deeply obfuscation can // recurse. void ObfuscateBoolConstantViaFloatConstantPair( uint32_t depth, const protobufs::IdUseDescriptor& bool_constant_use, uint32_t float_constant_id_1, uint32_t float_constant_id_2); // Similar to the above, but for signed int constants. void ObfuscateBoolConstantViaSignedIntConstantPair( uint32_t depth, const protobufs::IdUseDescriptor& bool_constant_use, uint32_t signed_int_constant_id_1, uint32_t signed_int_constant_id_2); // Similar to the above, but for unsigned int constants. void ObfuscateBoolConstantViaUnsignedIntConstantPair( uint32_t depth, const protobufs::IdUseDescriptor& bool_constant_use, uint32_t unsigned_int_constant_id_1, uint32_t unsigned_int_constant_id_2); // A helper method to capture the common parts of the above methods. // The method is used to obfuscate the boolean constant usage represented by // |bool_constant_use| by replacing it with '|constant_id_1| OP // |constant_id_2|', where 'OP' is chosen from either |greater_than_opcodes| // or |less_than_opcodes|. // // The two constant ids must not represent the same value, and thus // |greater_than_opcodes| may include 'greater than or equal' opcodes // (similar for |less_than_opcodes|). void ObfuscateBoolConstantViaConstantPair( uint32_t depth, const protobufs::IdUseDescriptor& bool_constant_use, const std::vector& greater_than_opcodes, const std::vector& less_than_opcodes, uint32_t constant_id_1, uint32_t constant_id_2, bool first_constant_is_larger); // A helper method to determine whether input operand |in_operand_index| of // |inst| is the id of a constant, and add an id use descriptor to // |candidate_constant_uses| if so. The other parameters are used for id use // descriptor construction. void MaybeAddConstantIdUse( const opt::Instruction& inst, uint32_t in_operand_index, uint32_t base_instruction_result_id, const std::map& skipped_opcode_count, std::vector* constant_uses); // Returns a vector of unique words that denote constants. Every such constant // is used in |FactConstantUniform| and has type with id equal to |type_id|. std::vector> GetConstantWordsFromUniformsForType( uint32_t type_id); }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_OBFUSCATE_CONSTANTS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_outline_functions.cpp000066400000000000000000000166771475742701700277560ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_outline_functions.h" #include #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/transformation_outline_function.h" #include "source/fuzz/transformation_split_block.h" namespace spvtools { namespace fuzz { FuzzerPassOutlineFunctions::FuzzerPassOutlineFunctions( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassOutlineFunctions::Apply() { std::vector original_functions; for (auto& function : *GetIRContext()->module()) { original_functions.push_back(&function); } for (auto& function : original_functions) { if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfOutliningFunction())) { continue; } std::vector blocks; for (auto& block : *function) { blocks.push_back(&block); } auto entry_block = MaybeGetEntryBlockSuitableForOutlining( blocks[GetFuzzerContext()->RandomIndex(blocks)]); if (!entry_block) { // The chosen block is not suitable to be the entry block of a region that // will be outlined. continue; } auto dominator_analysis = GetIRContext()->GetDominatorAnalysis(function); auto postdominator_analysis = GetIRContext()->GetPostDominatorAnalysis(function); std::vector candidate_exit_blocks; for (auto postdominates_entry_block = entry_block; postdominates_entry_block != nullptr; postdominates_entry_block = postdominator_analysis->ImmediateDominator( postdominates_entry_block)) { // Consider the block if it is dominated by the entry block, ignore it if // it is a continue target. if (dominator_analysis->Dominates(entry_block, postdominates_entry_block) && !GetIRContext()->GetStructuredCFGAnalysis()->IsContinueBlock( postdominates_entry_block->id())) { candidate_exit_blocks.push_back(postdominates_entry_block); } } if (candidate_exit_blocks.empty()) { continue; } auto exit_block = MaybeGetExitBlockSuitableForOutlining( candidate_exit_blocks[GetFuzzerContext()->RandomIndex( candidate_exit_blocks)]); if (!exit_block) { // The block chosen is not suitable continue; } auto region_blocks = TransformationOutlineFunction::GetRegionBlocks( GetIRContext(), entry_block, exit_block); std::map input_id_to_fresh_id; for (auto id : TransformationOutlineFunction::GetRegionInputIds( GetIRContext(), region_blocks, exit_block)) { input_id_to_fresh_id[id] = GetFuzzerContext()->GetFreshId(); } std::map output_id_to_fresh_id; for (auto id : TransformationOutlineFunction::GetRegionOutputIds( GetIRContext(), region_blocks, exit_block)) { output_id_to_fresh_id[id] = GetFuzzerContext()->GetFreshId(); } TransformationOutlineFunction transformation( entry_block->id(), exit_block->id(), /*new_function_struct_return_type_id*/ GetFuzzerContext()->GetFreshId(), /*new_function_type_id*/ GetFuzzerContext()->GetFreshId(), /*new_function_id*/ GetFuzzerContext()->GetFreshId(), /*new_function_region_entry_block*/ GetFuzzerContext()->GetFreshId(), /*new_caller_result_id*/ GetFuzzerContext()->GetFreshId(), /*new_callee_result_id*/ GetFuzzerContext()->GetFreshId(), /*input_id_to_fresh_id*/ input_id_to_fresh_id, /*output_id_to_fresh_id*/ output_id_to_fresh_id); MaybeApplyTransformation(transformation); } } opt::BasicBlock* FuzzerPassOutlineFunctions::MaybeGetEntryBlockSuitableForOutlining( opt::BasicBlock* entry_block) { // If the entry block is a loop header, we need to get or create its // preheader and make it the entry block, if possible. if (entry_block->IsLoopHeader()) { auto predecessors = GetIRContext()->cfg()->preds(entry_block->GetLabel()->result_id()); if (predecessors.size() < 2) { // The header only has one predecessor (the back-edge block) and thus // it is unreachable. The block cannot be adjusted to be suitable for // outlining. return nullptr; } // Get or create a suitable preheader and make it become the entry block. entry_block = GetOrCreateSimpleLoopPreheader(entry_block->GetLabel()->result_id()); } assert(!entry_block->IsLoopHeader() && "The entry block cannot be a loop header at this point."); // If the entry block starts with OpPhi or OpVariable, try to split it. if (entry_block->begin()->opcode() == spv::Op::OpPhi || entry_block->begin()->opcode() == spv::Op::OpVariable) { // Find the first non-OpPhi and non-OpVariable instruction. auto non_phi_or_var_inst = &*entry_block->begin(); while (non_phi_or_var_inst->opcode() == spv::Op::OpPhi || non_phi_or_var_inst->opcode() == spv::Op::OpVariable) { non_phi_or_var_inst = non_phi_or_var_inst->NextNode(); } // Split the block. uint32_t new_block_id = GetFuzzerContext()->GetFreshId(); ApplyTransformation(TransformationSplitBlock( MakeInstructionDescriptor(GetIRContext(), non_phi_or_var_inst), new_block_id)); // The new entry block is the newly-created block. entry_block = &*entry_block->GetParent()->FindBlock(new_block_id); } return entry_block; } opt::BasicBlock* FuzzerPassOutlineFunctions::MaybeGetExitBlockSuitableForOutlining( opt::BasicBlock* exit_block) { // The exit block must not be a continue target. assert(!GetIRContext()->GetStructuredCFGAnalysis()->IsContinueBlock( exit_block->id()) && "A candidate exit block cannot be a continue target."); // If the exit block is a merge block, try to split it and return the second // block in the pair as the exit block. if (GetIRContext()->GetStructuredCFGAnalysis()->IsMergeBlock( exit_block->id())) { uint32_t new_block_id = GetFuzzerContext()->GetFreshId(); // Find the first non-OpPhi instruction, after which to split. auto split_before = &*exit_block->begin(); while (split_before->opcode() == spv::Op::OpPhi) { split_before = split_before->NextNode(); } if (!MaybeApplyTransformation(TransformationSplitBlock( MakeInstructionDescriptor(GetIRContext(), split_before), new_block_id))) { return nullptr; } return &*exit_block->GetParent()->FindBlock(new_block_id); } return exit_block; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_outline_functions.h000066400000000000000000000050701475742701700274040ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_OUTLINE_FUNCTIONS_H_ #define SOURCE_FUZZ_FUZZER_PASS_OUTLINE_FUNCTIONS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // A fuzzer pass for outlining single-entry single-exit regions of a control // flow graph into their own functions. class FuzzerPassOutlineFunctions : public FuzzerPass { public: FuzzerPassOutlineFunctions(opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; // Returns a block suitable to be an entry block for a region that can be // outlined, i.e. a block that is not a loop header and that does not start // with OpPhi or OpVariable. In particular, it returns: // - |entry_block| if it is suitable // - otherwise, a block found by: // - looking for or creating a new preheader, if |entry_block| is a loop // header // - splitting the candidate entry block, if it starts with OpPhi or // OpVariable. // Returns nullptr if a suitable block cannot be found following the // instructions above. opt::BasicBlock* MaybeGetEntryBlockSuitableForOutlining( opt::BasicBlock* entry_block); // Returns: // - |exit_block| if it is not a merge block // - the second block obtained by splitting |exit_block|, if |exit_block| is a // merge block. // Assumes that |exit_block| is not a continue target. // The block returned by this function should be suitable to be the exit block // of a region that can be outlined. // Returns nullptr if |exit_block| is a merge block and it cannot be split. opt::BasicBlock* MaybeGetExitBlockSuitableForOutlining( opt::BasicBlock* exit_block); }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_OUTLINE_FUNCTIONS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_permute_blocks.cpp000066400000000000000000000056051475742701700272120ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_permute_blocks.h" #include "source/fuzz/transformation_move_block_down.h" namespace spvtools { namespace fuzz { FuzzerPassPermuteBlocks::FuzzerPassPermuteBlocks( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassPermuteBlocks::Apply() { // For now we do something very simple: we randomly decide whether to move a // block, and for each block that we do move, we push it down as far as we // legally can. // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/2635): it would be // nice to randomly sample from the set of legal block permutations and then // encode the chosen permutation via a series of move-block-down // transformations. This should be possible but will require some thought. for (auto& function : *GetIRContext()->module()) { std::vector block_ids; // Collect all block ids for the function before messing with block // ordering. for (auto& block : function) { block_ids.push_back(block.id()); } // Now consider each block id. We consider block ids in reverse, because // e.g. in code generated from the following: // // if (...) { // A // B // } else { // C // } // // block A cannot be moved down, but B has freedom to move and that movement // would provide more freedom for A to move. for (auto id = block_ids.rbegin(); id != block_ids.rend(); ++id) { // Randomly decide whether to ignore the block id. if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfMovingBlockDown())) { continue; } // Keep pushing the block down, until pushing down fails. // The loop is guaranteed to terminate because a block cannot be pushed // down indefinitely. while (true) { TransformationMoveBlockDown transformation(*id); if (!MaybeApplyTransformation(transformation)) { break; } } } } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_permute_blocks.h000066400000000000000000000025501475742701700266530ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_PERMUTE_BLOCKS_H_ #define SOURCE_FUZZ_FUZZER_PASS_PERMUTE_BLOCKS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // A fuzzer pass for shuffling the blocks of the module in a validity-preserving // manner. class FuzzerPassPermuteBlocks : public FuzzerPass { public: FuzzerPassPermuteBlocks(opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_PERMUTE_BLOCKS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_permute_function_parameters.cpp000066400000000000000000000047611475742701700320070ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_permute_function_parameters.h" #include #include #include "source/fuzz/fuzzer_context.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/transformation_permute_function_parameters.h" namespace spvtools { namespace fuzz { FuzzerPassPermuteFunctionParameters::FuzzerPassPermuteFunctionParameters( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassPermuteFunctionParameters::Apply() { for (const auto& function : *GetIRContext()->module()) { uint32_t function_id = function.result_id(); // Skip the function if it is an entry point if (fuzzerutil::FunctionIsEntryPoint(GetIRContext(), function_id)) { continue; } if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfPermutingParameters())) { continue; } // Compute permutation for parameters auto* function_type = fuzzerutil::GetFunctionType(GetIRContext(), &function); assert(function_type && "Function type is null"); // Don't take return type into account uint32_t arg_size = function_type->NumInOperands() - 1; // Create a vector, fill it with [0, n-1] values and shuffle it std::vector permutation(arg_size); std::iota(permutation.begin(), permutation.end(), 0); GetFuzzerContext()->Shuffle(&permutation); // Apply our transformation ApplyTransformation(TransformationPermuteFunctionParameters( function_id, GetFuzzerContext()->GetFreshId(), permutation)); } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_permute_function_parameters.h000066400000000000000000000032671475742701700314540ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_PERMUTE_FUNCTION_PARAMETERS_H_ #define SOURCE_FUZZ_FUZZER_PASS_PERMUTE_FUNCTION_PARAMETERS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // Fuzzer pass that, given a non-entry-point function taking n parameters // and a permutation of the set [0, n - 1]: // 1. Introduces a new function type that is the same as the original // function's type but with the order of arguments permuted // (only add this if it doesn't already exist) // 2. Changes the type of the function to this type // 3. Adjusts all calls to the function so that their arguments are permuted class FuzzerPassPermuteFunctionParameters : public FuzzerPass { public: FuzzerPassPermuteFunctionParameters( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_PERMUTE_FUNCTION_PARAMETERS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_permute_function_variables.cpp000066400000000000000000000052231475742701700316060ustar00rootroot00000000000000// Copyright (c) 2021 Mostafa Ashraf // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_permute_function_variables.h" #include #include #include #include "source/fuzz/fuzzer_context.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/transformation_swap_function_variables.h" namespace spvtools { namespace fuzz { FuzzerPassPermuteFunctionVariables::FuzzerPassPermuteFunctionVariables( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) { } // Here we call parent constructor. void FuzzerPassPermuteFunctionVariables::Apply() { // Permuting OpVariable instructions in each function. for (auto& function : *GetIRContext()->module()) { if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfPermutingFunctionVariables())) { continue; } auto first_block = function.entry().get(); std::vector variables; for (auto& instruction : *first_block) { if (instruction.opcode() == spv::Op::OpVariable) { variables.push_back(&instruction); } } if (variables.size() <= 1) { continue; } do { uint32_t instruction_1_index = GetFuzzerContext()->RandomIndex(variables); uint32_t instruction_2_index = GetFuzzerContext()->RandomIndex(variables); if (instruction_1_index != instruction_2_index) { ApplyTransformation(TransformationSwapFunctionVariables( variables[instruction_1_index]->result_id(), variables[instruction_2_index]->result_id())); } } while (GetFuzzerContext()->ChoosePercentage( GetFuzzerContext() ->GetChanceOfSwappingAnotherPairOfFunctionVariables()) && variables.size() > 2); } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_permute_function_variables.h000066400000000000000000000024761475742701700312620ustar00rootroot00000000000000// Copyright (c) 2021 Mostafa Ashraf // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_PERMUTE_FUNCTION_VARIABLES_H_ #define SOURCE_FUZZ_FUZZER_PASS_PERMUTE_FUNCTION_VARIABLES_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // This fuzzer pass permutes variables in functions in the module. class FuzzerPassPermuteFunctionVariables : public FuzzerPass { public: FuzzerPassPermuteFunctionVariables( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_PERMUTE_FUNCTION_VARIABLES_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_permute_instructions.cpp000066400000000000000000000046301475742701700304760ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_permute_instructions.h" #include "source/fuzz/fuzzer_context.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/transformation_move_instruction_down.h" namespace spvtools { namespace fuzz { FuzzerPassPermuteInstructions::FuzzerPassPermuteInstructions( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassPermuteInstructions::Apply() { // We are iterating over all instructions in all basic blocks. for (auto& function : *GetIRContext()->module()) { for (auto& block : function) { // We need to collect all instructions in the block into a separate vector // since application of the transformation below might invalidate // iterators. std::vector instructions; for (auto& instruction : block) { instructions.push_back(&instruction); } // We consider all instructions in reverse to increase the possible number // of applied transformations. for (auto it = instructions.rbegin(); it != instructions.rend(); ++it) { if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfPermutingInstructions())) { continue; } while (MaybeApplyTransformation(TransformationMoveInstructionDown( MakeInstructionDescriptor(GetIRContext(), *it)))) { // Apply the transformation as many times as possible. } } } } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_permute_instructions.h000066400000000000000000000024711475742701700301440ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_PERMUTE_INSTRUCTIONS_H_ #define SOURCE_FUZZ_FUZZER_PASS_PERMUTE_INSTRUCTIONS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // Permutes instructions in every block of all while preserving the module's // semantics. class FuzzerPassPermuteInstructions : public FuzzerPass { public: FuzzerPassPermuteInstructions( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_PERMUTE_INSTRUCTIONS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_permute_phi_operands.cpp000066400000000000000000000045111475742701700304030ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_permute_phi_operands.h" #include #include #include "source/fuzz/fuzzer_context.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/transformation_permute_phi_operands.h" namespace spvtools { namespace fuzz { FuzzerPassPermutePhiOperands::FuzzerPassPermutePhiOperands( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassPermutePhiOperands::Apply() { ForEachInstructionWithInstructionDescriptor( [this](opt::Function* /*unused*/, opt::BasicBlock* /*unused*/, opt::BasicBlock::iterator inst_it, const protobufs::InstructionDescriptor& /*unused*/) { const auto& inst = *inst_it; if (inst.opcode() != spv::Op::OpPhi) { return; } if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfPermutingPhiOperands())) { return; } // Create a vector of indices for each pair of operands in the |inst|. // OpPhi always has an even number of operands. std::vector permutation(inst.NumInOperands() / 2); std::iota(permutation.begin(), permutation.end(), 0); GetFuzzerContext()->Shuffle(&permutation); ApplyTransformation(TransformationPermutePhiOperands( inst.result_id(), std::move(permutation))); }); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_permute_phi_operands.h000066400000000000000000000025401475742701700300500ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_PERMUTE_PHI_OPERANDS_H_ #define SOURCE_FUZZ_FUZZER_PASS_PERMUTE_PHI_OPERANDS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // Iterates over all instructions in the module and randomly decides for each // OpPhi instruction whether to permute its operands. class FuzzerPassPermutePhiOperands : public FuzzerPass { public: FuzzerPassPermutePhiOperands( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_PERMUTE_PHI_OPERANDS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_propagate_instructions_down.cpp000066400000000000000000000046511475742701700320310ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_propagate_instructions_down.h" #include "source/fuzz/fuzzer_context.h" #include "source/fuzz/transformation_propagate_instruction_down.h" namespace spvtools { namespace fuzz { FuzzerPassPropagateInstructionsDown::FuzzerPassPropagateInstructionsDown( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassPropagateInstructionsDown::Apply() { for (const auto& function : *GetIRContext()->module()) { std::vector reachable_blocks; for (const auto& block : function) { if (GetIRContext()->IsReachable(block)) { reachable_blocks.push_back(&block); } } for (const auto* block : reachable_blocks) { if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfPropagatingInstructionsDown())) { continue; } if (TransformationPropagateInstructionDown::IsApplicableToBlock( GetIRContext(), block->id())) { // Record fresh ids for every successor of the |block| that we can // propagate an instruction into. std::map fresh_ids; for (auto id : TransformationPropagateInstructionDown::GetAcceptableSuccessors( GetIRContext(), block->id())) { fresh_ids[id] = GetFuzzerContext()->GetFreshId(); } ApplyTransformation(TransformationPropagateInstructionDown( block->id(), GetFuzzerContext()->GetFreshId(), fresh_ids)); } } } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_propagate_instructions_down.h000066400000000000000000000025201475742701700314670ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_PROPAGATE_INSTRUCTIONS_DOWN_H_ #define SOURCE_FUZZ_FUZZER_PASS_PROPAGATE_INSTRUCTIONS_DOWN_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // Randomly propagates instructions from some block into the block's successors. class FuzzerPassPropagateInstructionsDown : public FuzzerPass { public: FuzzerPassPropagateInstructionsDown( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_PROPAGATE_INSTRUCTIONS_DOWN_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_propagate_instructions_up.cpp000066400000000000000000000044031475742701700315010ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_propagate_instructions_up.h" #include "source/fuzz/fuzzer_context.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/transformation_propagate_instruction_up.h" namespace spvtools { namespace fuzz { FuzzerPassPropagateInstructionsUp::FuzzerPassPropagateInstructionsUp( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassPropagateInstructionsUp::Apply() { for (const auto& function : *GetIRContext()->module()) { for (const auto& block : function) { if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfPropagatingInstructionsUp())) { continue; } if (TransformationPropagateInstructionUp::IsApplicableToBlock( GetIRContext(), block.id())) { std::map fresh_ids; for (auto id : GetIRContext()->cfg()->preds(block.id())) { auto& fresh_id = fresh_ids[id]; if (!fresh_id) { // Create a fresh id if it hasn't been created yet. |fresh_id| will // be default-initialized to 0 in this case. fresh_id = GetFuzzerContext()->GetFreshId(); } } ApplyTransformation( TransformationPropagateInstructionUp(block.id(), fresh_ids)); } } } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_propagate_instructions_up.h000066400000000000000000000025141475742701700311470ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_PROPAGATE_INSTRUCTIONS_UP_H_ #define SOURCE_FUZZ_FUZZER_PASS_PROPAGATE_INSTRUCTIONS_UP_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // Decides whether to propagate instructions from some block into its // predecessors. class FuzzerPassPropagateInstructionsUp : public FuzzerPass { public: FuzzerPassPropagateInstructionsUp( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_PROPAGATE_INSTRUCTIONS_UP_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_push_ids_through_variables.cpp000066400000000000000000000150261475742701700316000ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_push_ids_through_variables.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/transformation_push_id_through_variable.h" namespace spvtools { namespace fuzz { FuzzerPassPushIdsThroughVariables::FuzzerPassPushIdsThroughVariables( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassPushIdsThroughVariables::Apply() { ForEachInstructionWithInstructionDescriptor( [this](opt::Function* function, opt::BasicBlock* block, opt::BasicBlock::iterator instruction_iterator, const protobufs::InstructionDescriptor& instruction_descriptor) -> void { assert( instruction_iterator->opcode() == spv::Op(instruction_descriptor.target_instruction_opcode()) && "The opcode of the instruction we might insert before must be " "the same as the opcode in the descriptor for the instruction"); // Randomly decide whether to try pushing an id through a variable. if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfPushingIdThroughVariable())) { return; } // The block containing the instruction we are going to insert before // must be reachable. if (!GetIRContext()->IsReachable(*block)) { return; } // It must be valid to insert OpStore and OpLoad instructions // before the instruction to insert before. if (!fuzzerutil::CanInsertOpcodeBeforeInstruction( spv::Op::OpStore, instruction_iterator) || !fuzzerutil::CanInsertOpcodeBeforeInstruction( spv::Op::OpLoad, instruction_iterator)) { return; } // Randomly decides whether a global or local variable will be added. auto variable_storage_class = GetFuzzerContext()->ChooseEven() ? spv::StorageClass::Private : spv::StorageClass::Function; // Gets the available basic and pointer types. auto basic_type_ids_and_pointers = GetAvailableBasicTypesAndPointers(variable_storage_class); auto& basic_types = basic_type_ids_and_pointers.first; // There must be at least some basic types. if (basic_types.empty()) { return; } uint32_t basic_type_id = basic_types[GetFuzzerContext()->RandomIndex(basic_types)]; // Looks for ids that we might wish to consider pushing through a // variable. std::vector value_instructions = FindAvailableInstructions( function, block, instruction_iterator, [this, basic_type_id, instruction_descriptor]( opt::IRContext* ir_context, opt::Instruction* instruction) -> bool { if (!instruction->result_id() || !instruction->type_id()) { return false; } if (instruction->type_id() != basic_type_id) { return false; } // If the id is irrelevant, we can use it since it will not // participate in DataSynonym fact. Otherwise, we should be // able to produce a synonym out of the id. if (!GetTransformationContext() ->GetFactManager() ->IdIsIrrelevant(instruction->result_id()) && !fuzzerutil::CanMakeSynonymOf(ir_context, *GetTransformationContext(), *instruction)) { return false; } return fuzzerutil::IdIsAvailableBeforeInstruction( ir_context, FindInstruction(instruction_descriptor, ir_context), instruction->result_id()); }); if (value_instructions.empty()) { return; } // If the pointer type does not exist, then create it. FindOrCreatePointerType(basic_type_id, variable_storage_class); // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/3403): // type support here is limited by the FindOrCreateZeroConstant // function. const auto* type_inst = GetIRContext()->get_def_use_mgr()->GetDef(basic_type_id); assert(type_inst); switch (type_inst->opcode()) { case spv::Op::OpTypeBool: case spv::Op::OpTypeFloat: case spv::Op::OpTypeInt: case spv::Op::OpTypeArray: case spv::Op::OpTypeMatrix: case spv::Op::OpTypeVector: case spv::Op::OpTypeStruct: break; default: return; } // Create a constant to initialize the variable from. This might update // module's id bound so it must be done before any fresh ids are // computed. auto initializer_id = FindOrCreateZeroConstant(basic_type_id, false); // Applies the push id through variable transformation. ApplyTransformation(TransformationPushIdThroughVariable( value_instructions[GetFuzzerContext()->RandomIndex( value_instructions)] ->result_id(), GetFuzzerContext()->GetFreshId(), GetFuzzerContext()->GetFreshId(), uint32_t(variable_storage_class), initializer_id, instruction_descriptor)); }); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_push_ids_through_variables.h000066400000000000000000000027071475742701700312470ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_PUSH_IDS_THROUGH_VARIABLES_H_ #define SOURCE_FUZZ_FUZZER_PASS_PUSH_IDS_THROUGH_VARIABLES_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // Adds instructions to the module that store existing ids into fresh variables // and immediately load from said variables into new ids, thus creating synonyms // between the existing and fresh ids. class FuzzerPassPushIdsThroughVariables : public FuzzerPass { public: FuzzerPassPushIdsThroughVariables( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_PUSH_IDS_THROUGH_VARIABLES_H_ fuzzer_pass_replace_adds_subs_muls_with_carrying_extended.cpp000066400000000000000000000056641475742701700354350ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/fuzz// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_replace_adds_subs_muls_with_carrying_extended.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/transformation_replace_add_sub_mul_with_carrying_extended.h" namespace spvtools { namespace fuzz { namespace { const uint32_t kArithmeticInstructionIndexLeftInOperand = 0; } // namespace FuzzerPassReplaceAddsSubsMulsWithCarryingExtended:: FuzzerPassReplaceAddsSubsMulsWithCarryingExtended( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassReplaceAddsSubsMulsWithCarryingExtended::Apply() { std::vector instructions_for_transformation; for (auto& function : *GetIRContext()->module()) { for (auto& block : function) { for (auto& instruction : block) { // Randomly decide whether to apply the transformation. if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext() ->GetChanceOfReplacingAddSubMulWithCarryingExtended())) { continue; } // Check if the transformation can be applied to this instruction. if (!TransformationReplaceAddSubMulWithCarryingExtended:: IsInstructionSuitable(GetIRContext(), instruction)) { continue; } instructions_for_transformation.push_back(instruction); } } } for (auto& instruction : instructions_for_transformation) { // Get the operand type id. We know that both operands have the same // type. uint32_t operand_type_id = GetIRContext() ->get_def_use_mgr() ->GetDef(instruction.GetSingleWordInOperand( kArithmeticInstructionIndexLeftInOperand)) ->type_id(); // Ensure the required struct type exists. The struct type is based on // the operand type. FindOrCreateStructType({operand_type_id, operand_type_id}); ApplyTransformation(TransformationReplaceAddSubMulWithCarryingExtended( GetFuzzerContext()->GetFreshId(), instruction.result_id())); } } } // namespace fuzz } // namespace spvtools fuzzer_pass_replace_adds_subs_muls_with_carrying_extended.h000066400000000000000000000032031475742701700350650ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/fuzz// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_REPLACE_ADDS_SUBS_MULS_WITH_CARRYING_EXTENDED_H_ #define SOURCE_FUZZ_FUZZER_PASS_REPLACE_ADDS_SUBS_MULS_WITH_CARRYING_EXTENDED_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // A fuzzer pass that replaces instructions OpIAdd, OpISub, OpIMul with pairs of // instructions. The first one (OpIAddCarry, OpISubBorrow, OpUMulExtended, // OpSMulExtended) computes the result into a struct. The second one extracts // the appropriate component from the struct to yield the original result. class FuzzerPassReplaceAddsSubsMulsWithCarryingExtended : public FuzzerPass { public: FuzzerPassReplaceAddsSubsMulsWithCarryingExtended( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_REPLACE_ADDS_SUBS_MULS_WITH_CARRYING_EXTENDED_H_ fuzzer_pass_replace_branches_from_dead_blocks_with_exits.cpp000066400000000000000000000127401475742701700351770ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/fuzz// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_replace_branches_from_dead_blocks_with_exits.h" #include #include #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/transformation_replace_branch_from_dead_block_with_exit.h" namespace spvtools { namespace fuzz { FuzzerPassReplaceBranchesFromDeadBlocksWithExits:: FuzzerPassReplaceBranchesFromDeadBlocksWithExits( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassReplaceBranchesFromDeadBlocksWithExits::Apply() { // OpKill can only be used as a terminator in a function that is guaranteed // to be executed with the Fragment execution model. We conservatively only // allow OpKill if every entry point in the module has the Fragment execution // model. auto fragment_execution_model_guaranteed = std::all_of( GetIRContext()->module()->entry_points().begin(), GetIRContext()->module()->entry_points().end(), [](const opt::Instruction& entry_point) -> bool { return spv::ExecutionModel(entry_point.GetSingleWordInOperand(0)) == spv::ExecutionModel::Fragment; }); // Transformations of this type can disable one another. To avoid ordering // bias, we therefore build a set of candidate transformations to apply, and // subsequently apply them in a random order, skipping any that cease to be // applicable. std::vector candidate_transformations; // Consider every block in every function. for (auto& function : *GetIRContext()->module()) { for (auto& block : function) { // Probabilistically decide whether to skip this block. if (GetFuzzerContext()->ChoosePercentage( GetFuzzerContext() ->GetChanceOfReplacingBranchFromDeadBlockWithExit())) { continue; } // Check whether the block is suitable for having its terminator replaced. if (!TransformationReplaceBranchFromDeadBlockWithExit::BlockIsSuitable( GetIRContext(), *GetTransformationContext(), block)) { continue; } // We can always use OpUnreachable to replace a block's terminator. // Whether we can use OpKill depends on the execution model, and which of // OpReturn and OpReturnValue we can use depends on the return type of the // enclosing function. std::vector opcodes = {spv::Op::OpUnreachable}; if (fragment_execution_model_guaranteed) { opcodes.emplace_back(spv::Op::OpKill); } auto function_return_type = GetIRContext()->get_type_mgr()->GetType(function.type_id()); if (function_return_type->AsVoid()) { opcodes.emplace_back(spv::Op::OpReturn); } else if (fuzzerutil::CanCreateConstant(GetIRContext(), function.type_id())) { // For simplicity we only allow OpReturnValue if the function return // type is a type for which we can create a constant. This allows us a // zero of the given type as a default return value. opcodes.emplace_back(spv::Op::OpReturnValue); } // Choose one of the available terminator opcodes at random and create a // candidate transformation. auto opcode = opcodes[GetFuzzerContext()->RandomIndex(opcodes)]; candidate_transformations.emplace_back( TransformationReplaceBranchFromDeadBlockWithExit( block.id(), opcode, opcode == spv::Op::OpReturnValue ? FindOrCreateZeroConstant(function.type_id(), true) : 0)); } } // Process the candidate transformations in a random order. while (!candidate_transformations.empty()) { // Transformations of this type can disable one another. For example, // suppose we have dead blocks A, B, C, D arranged as follows: // // A | // / \ | // B C | // \ / | // D | // // Here we can replace the terminator of either B or C with an early exit, // because D has two predecessors. But if we replace the terminator of B, // say, we get: // // A | // / \ | // B C | // / | // D | // // and now it is no longer OK to replace the terminator of C as D only has // one predecessor and we do not want to make D unreachable in the control // flow graph. MaybeApplyTransformation( GetFuzzerContext()->RemoveAtRandomIndex(&candidate_transformations)); } } } // namespace fuzz } // namespace spvtools fuzzer_pass_replace_branches_from_dead_blocks_with_exits.h000066400000000000000000000027621475742701700346470ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/fuzz// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_REPLACE_BRANCHES_FROM_DEAD_BLOCKS_WITH_EXITS_H_ #define SOURCE_FUZZ_FUZZER_PASS_REPLACE_BRANCHES_FROM_DEAD_BLOCKS_WITH_EXITS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // Fuzzer pass that, under the right conditions, replaces branch instructions // from dead blocks with non-branching "exit" terminators, such as OpKill and // OpReturn. class FuzzerPassReplaceBranchesFromDeadBlocksWithExits : public FuzzerPass { public: FuzzerPassReplaceBranchesFromDeadBlocksWithExits( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_REPLACE_BRANCHES_FROM_DEAD_BLOCKS_WITH_EXITS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_replace_copy_memories_with_loads_stores.cpp000066400000000000000000000041551475742701700343540ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_replace_copy_memories_with_loads_stores.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/transformation_replace_copy_memory_with_load_store.h" namespace spvtools { namespace fuzz { FuzzerPassReplaceCopyMemoriesWithLoadsStores:: FuzzerPassReplaceCopyMemoriesWithLoadsStores( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassReplaceCopyMemoriesWithLoadsStores::Apply() { GetIRContext()->module()->ForEachInst([this](opt::Instruction* instruction) { // Randomly decide whether to replace the OpCopyMemory. if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext() ->GetChanceOfReplacingCopyMemoryWithLoadStore())) { return; } // The instruction must be OpCopyMemory. if (instruction->opcode() != spv::Op::OpCopyMemory) { return; } // Apply the transformation replacing OpCopyMemory with OpLoad and OpStore. ApplyTransformation(TransformationReplaceCopyMemoryWithLoadStore( GetFuzzerContext()->GetFreshId(), MakeInstructionDescriptor(GetIRContext(), instruction))); }); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_replace_copy_memories_with_loads_stores.h000066400000000000000000000027621475742701700340230ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_REPLACE_COPY_MEMORIES_WITH_LOADS_STORES_H_ #define SOURCE_FUZZ_FUZZER_PASS_REPLACE_COPY_MEMORIES_WITH_LOADS_STORES_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // Replaces instructions OpCopyMemory with loading the source variable to // an intermediate value and storing this value into the target variable of // the original OpCopyMemory instruction. class FuzzerPassReplaceCopyMemoriesWithLoadsStores : public FuzzerPass { public: FuzzerPassReplaceCopyMemoriesWithLoadsStores( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_REPLACE_COPY_MEMORIES_WITH_LOADS_STORES_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_replace_copy_objects_with_stores_loads.cpp000066400000000000000000000071651475742701700341710ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_replace_copy_objects_with_stores_loads.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/transformation_replace_copy_object_with_store_load.h" namespace spvtools { namespace fuzz { FuzzerPassReplaceCopyObjectsWithStoresLoads:: FuzzerPassReplaceCopyObjectsWithStoresLoads( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassReplaceCopyObjectsWithStoresLoads::Apply() { GetIRContext()->module()->ForEachInst([this](opt::Instruction* instruction) { // Randomly decide whether to replace OpCopyObject. if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext() ->GetChanceOfReplacingCopyObjectWithStoreLoad())) { return; } // The instruction must be OpCopyObject. if (instruction->opcode() != spv::Op::OpCopyObject) { return; } // The opcode of the type_id instruction cannot be a OpTypePointer, // because we cannot define a pointer to pointer. if (GetIRContext() ->get_def_use_mgr() ->GetDef(instruction->type_id()) ->opcode() == spv::Op::OpTypePointer) { return; } // It must be valid to insert OpStore and OpLoad instructions // before the instruction OpCopyObject. if (!fuzzerutil::CanInsertOpcodeBeforeInstruction(spv::Op::OpStore, instruction) || !fuzzerutil::CanInsertOpcodeBeforeInstruction(spv::Op::OpLoad, instruction)) { return; } // Randomly decides whether a global or local variable will be added. auto variable_storage_class = GetFuzzerContext()->ChooseEven() ? spv::StorageClass::Private : spv::StorageClass::Function; // Find or create a constant to initialize the variable from. The type of // |instruction| must be such that the function FindOrCreateConstant can be // called. if (!fuzzerutil::CanCreateConstant(GetIRContext(), instruction->type_id())) { return; } auto variable_initializer_id = FindOrCreateZeroConstant(instruction->type_id(), false); // Make sure that pointer type is defined. FindOrCreatePointerType(instruction->type_id(), variable_storage_class); // Apply the transformation replacing OpCopyObject with Store and Load. ApplyTransformation(TransformationReplaceCopyObjectWithStoreLoad( instruction->result_id(), GetFuzzerContext()->GetFreshId(), uint32_t(variable_storage_class), variable_initializer_id)); }); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_replace_copy_objects_with_stores_loads.h000066400000000000000000000027311475742701700336300ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_REPLACE_COPY_OBJECTS_WITH_STORES_LOADS_H_ #define SOURCE_FUZZ_FUZZER_PASS_REPLACE_COPY_OBJECTS_WITH_STORES_LOADS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // Replaces instructions OpCopyObject with storing into a new variable // and immediately loading this variable to |result_id| of the // original OpCopyObject instruction. class FuzzerPassReplaceCopyObjectsWithStoresLoads : public FuzzerPass { public: FuzzerPassReplaceCopyObjectsWithStoresLoads( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_REPLACE_COPY_OBJECTS_WITH_STORES_LOADS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_replace_irrelevant_ids.cpp000066400000000000000000000166651475742701700307110ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_replace_irrelevant_ids.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/id_use_descriptor.h" #include "source/fuzz/transformation_replace_irrelevant_id.h" namespace spvtools { namespace fuzz { // A fuzzer pass that, for every use of an id that has been recorded as // irrelevant, randomly decides whether to replace it with another id of the // same type. FuzzerPassReplaceIrrelevantIds::FuzzerPassReplaceIrrelevantIds( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassReplaceIrrelevantIds::Apply() { // Keep track of the irrelevant ids. This includes all the ids that are // irrelevant according to the fact manager and that are still present in the // module (some of them may have been removed by previously-run // transformations). std::vector irrelevant_ids; // Keep a map from the type ids of irrelevant ids to all the ids with that // type. std::unordered_map> types_to_ids; // Find all the irrelevant ids that still exist in the module and all the // types for which irrelevant ids exist. for (auto id : GetTransformationContext()->GetFactManager()->GetIrrelevantIds()) { // Check that the id still exists in the module. auto declaration = GetIRContext()->get_def_use_mgr()->GetDef(id); if (!declaration) { continue; } irrelevant_ids.push_back(id); // If the type of this id has not been seen before, add a mapping from this // type id to an empty list in |types_to_ids|. The list will be filled later // on. if (types_to_ids.count(declaration->type_id()) == 0) { types_to_ids.insert({declaration->type_id(), {}}); } } // If no irrelevant ids were found, return. if (irrelevant_ids.empty()) { return; } // For every type for which we have at least one irrelevant id, record all ids // in the module which have that type. Skip ids of OpFunction instructions as // we cannot use these as replacements. for (const auto& pair : GetIRContext()->get_def_use_mgr()->id_to_defs()) { uint32_t type_id = pair.second->type_id(); if (pair.second->opcode() != spv::Op::OpFunction && type_id && types_to_ids.count(type_id)) { types_to_ids[type_id].push_back(pair.first); } } // Keep a list of all the transformations to perform. We avoid applying the // transformations while traversing the uses since applying the transformation // invalidates all analyses, and we want to avoid invalidating and recomputing // them every time. std::vector transformations_to_apply; // Loop through all the uses of irrelevant ids, check that the id can be // replaced and randomly decide whether to apply the transformation. for (auto irrelevant_id : irrelevant_ids) { uint32_t type_id = GetIRContext()->get_def_use_mgr()->GetDef(irrelevant_id)->type_id(); GetIRContext()->get_def_use_mgr()->ForEachUse( irrelevant_id, [this, &irrelevant_id, &type_id, &types_to_ids, &transformations_to_apply](opt::Instruction* use_inst, uint32_t use_index) { // Randomly decide whether to consider this use. if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfReplacingIrrelevantId())) { return; } // The id must be used as an input operand. if (use_index < use_inst->NumOperands() - use_inst->NumInOperands()) { // The id is used as an output operand, so we cannot replace this // usage. return; } // Get the input operand index for this use, from the absolute operand // index. uint32_t in_index = fuzzerutil::InOperandIndexFromOperandIndex(*use_inst, use_index); // Only go ahead if this id use can be replaced in principle. if (!fuzzerutil::IdUseCanBeReplaced(GetIRContext(), *GetTransformationContext(), use_inst, in_index)) { return; } // Find out which ids could be used to replace this use. std::vector available_replacement_ids; for (auto replacement_id : types_to_ids[type_id]) { // It would be pointless to replace an id with itself. if (replacement_id == irrelevant_id) { continue; } // We cannot replace a variable initializer with a non-constant. if (TransformationReplaceIrrelevantId:: AttemptsToReplaceVariableInitializerWithNonConstant( *use_inst, *GetIRContext()->get_def_use_mgr()->GetDef( replacement_id))) { continue; } // Only consider this replacement if the use point is within a basic // block and the id is available at the use point. // // There might be opportunities for replacing a non-block use of an // irrelevant id - such as the initializer of a global variable - // with another id, but it would require some care (e.g. to ensure // that the replacement id is defined earlier) and does not seem // worth doing. if (GetIRContext()->get_instr_block(use_inst) && fuzzerutil::IdIsAvailableAtUse(GetIRContext(), use_inst, in_index, replacement_id)) { available_replacement_ids.push_back(replacement_id); } } // Only go ahead if there is at least one id with which this use can // be replaced. if (available_replacement_ids.empty()) { return; } // Choose the replacement id randomly. uint32_t replacement_id = available_replacement_ids[GetFuzzerContext()->RandomIndex( available_replacement_ids)]; // Add this replacement to the list of transformations to apply. transformations_to_apply.emplace_back( TransformationReplaceIrrelevantId( MakeIdUseDescriptorFromUse(GetIRContext(), use_inst, in_index), replacement_id)); }); } // Apply all the transformations. for (const auto& transformation : transformations_to_apply) { ApplyTransformation(transformation); } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_replace_irrelevant_ids.h000066400000000000000000000026171475742701700303460ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_REPLACE_IRRELEVANT_IDS_H_ #define SOURCE_FUZZ_FUZZER_PASS_REPLACE_IRRELEVANT_IDS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // A fuzzer pass that, for every use of an irrelevant id, checks if it is // possible to replace it with other ids of the same type and randomly decides // whether to do it. class FuzzerPassReplaceIrrelevantIds : public FuzzerPass { public: FuzzerPassReplaceIrrelevantIds( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_REPLACE_IRRELEVANT_IDS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_replace_linear_algebra_instructions.cpp000066400000000000000000000044701475742701700334410ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_replace_linear_algebra_instructions.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/transformation_replace_linear_algebra_instruction.h" namespace spvtools { namespace fuzz { FuzzerPassReplaceLinearAlgebraInstructions:: FuzzerPassReplaceLinearAlgebraInstructions( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassReplaceLinearAlgebraInstructions::Apply() { // For each instruction, checks whether it is a linear algebra instruction. In // this case, the transformation is randomly applied. for (auto& function : *GetIRContext()->module()) { for (auto& block : function) { for (auto& instruction : block) { if (!spvOpcodeIsLinearAlgebra(instruction.opcode())) { continue; } if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext() ->GetChanceOfReplacingLinearAlgebraInstructions())) { continue; } ApplyTransformation(TransformationReplaceLinearAlgebraInstruction( GetFuzzerContext()->GetFreshIds( TransformationReplaceLinearAlgebraInstruction:: GetRequiredFreshIdCount(GetIRContext(), &instruction)), MakeInstructionDescriptor(GetIRContext(), &instruction))); } } } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_replace_linear_algebra_instructions.h000066400000000000000000000026121475742701700331020ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_REPLACE_LINEAR_ALGEBRA_INSTRUCTIONS_H_ #define SOURCE_FUZZ_FUZZER_PASS_REPLACE_LINEAR_ALGEBRA_INSTRUCTIONS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // This fuzzer pass replaces linear algebra instructions with its mathematical // definition. class FuzzerPassReplaceLinearAlgebraInstructions : public FuzzerPass { public: FuzzerPassReplaceLinearAlgebraInstructions( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_REPLACE_LINEAR_ALGEBRA_INSTRUCTIONS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_replace_loads_stores_with_copy_memories.cpp000066400000000000000000000106261475742701700343540ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_replace_loads_stores_with_copy_memories.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/transformation_replace_load_store_with_copy_memory.h" #include "source/opt/instruction.h" namespace spvtools { namespace fuzz { FuzzerPassReplaceLoadsStoresWithCopyMemories:: FuzzerPassReplaceLoadsStoresWithCopyMemories( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassReplaceLoadsStoresWithCopyMemories::Apply() { // We look for matching pairs of instructions OpLoad and // OpStore within the same block. Potential instructions OpLoad to be matched // are stored in a hash map. If we encounter instructions that write to memory // or instructions of memory barriers that could operate on variables within // unsafe storage classes we need to erase the hash map to avoid unsafe // operations. // A vector of matching OpLoad and OpStore instructions. std::vector> op_load_store_pairs; for (auto& function : *GetIRContext()->module()) { for (auto& block : function) { // A hash map storing potential OpLoad instructions. std::unordered_map current_op_loads; for (auto& instruction : block) { // Add a potential OpLoad instruction. if (instruction.opcode() == spv::Op::OpLoad) { current_op_loads[instruction.result_id()] = &instruction; } else if (instruction.opcode() == spv::Op::OpStore) { if (current_op_loads.find(instruction.GetSingleWordOperand(1)) != current_op_loads.end()) { // We have found the matching OpLoad instruction to the current // OpStore instruction. op_load_store_pairs.push_back(std::make_pair( current_op_loads[instruction.GetSingleWordOperand(1)], &instruction)); } } if (TransformationReplaceLoadStoreWithCopyMemory::IsMemoryWritingOpCode( instruction.opcode())) { current_op_loads.clear(); } else if (TransformationReplaceLoadStoreWithCopyMemory:: IsMemoryBarrierOpCode(instruction.opcode())) { for (auto it = current_op_loads.begin(); it != current_op_loads.end();) { // Get the storage class. opt::Instruction* source_id = GetIRContext()->get_def_use_mgr()->GetDef( it->second->GetSingleWordOperand(2)); spv::StorageClass storage_class = fuzzerutil::GetStorageClassFromPointerType( GetIRContext(), source_id->type_id()); if (!TransformationReplaceLoadStoreWithCopyMemory:: IsStorageClassSafeAcrossMemoryBarriers(storage_class)) { it = current_op_loads.erase(it); } else { it++; } } } } } } for (auto instr_pair : op_load_store_pairs) { // Randomly decide to apply the transformation for the // potential pairs. if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext() ->GetChanceOfReplacingLoadStoreWithCopyMemory())) { ApplyTransformation(TransformationReplaceLoadStoreWithCopyMemory( MakeInstructionDescriptor(GetIRContext(), instr_pair.first), MakeInstructionDescriptor(GetIRContext(), instr_pair.second))); } } } // namespace fuzz } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_replace_loads_stores_with_copy_memories.h000066400000000000000000000027701475742701700340220ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_REPLACE_LOADS_STORES_WITH_COPY_MEMORIES_H_ #define SOURCE_FUZZ_FUZZER_PASS_REPLACE_LOADS_STORES_WITH_COPY_MEMORIES_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // A fuzzer pass that takes pairs of instruction descriptors to OpLoad and // OpStore that have the same intermediate value and in each pair replaces the // OpStore with an equivalent OpCopyMemory. class FuzzerPassReplaceLoadsStoresWithCopyMemories : public FuzzerPass { public: FuzzerPassReplaceLoadsStoresWithCopyMemories( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_REPLACE_LOADS_STORES_WITH_COPY_MEMORIES_H_ fuzzer_pass_replace_opphi_ids_from_dead_predecessors.cpp000066400000000000000000000116531475742701700343470ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/fuzz// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_replace_opphi_ids_from_dead_predecessors.h" #include "source/fuzz/transformation_replace_opphi_id_from_dead_predecessor.h" namespace spvtools { namespace fuzz { FuzzerPassReplaceOpPhiIdsFromDeadPredecessors:: FuzzerPassReplaceOpPhiIdsFromDeadPredecessors( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassReplaceOpPhiIdsFromDeadPredecessors::Apply() { // Keep a vector of the transformations to apply. std::vector transformations; // Loop through the reachable blocks in the module. for (auto& function : *GetIRContext()->module()) { GetIRContext()->cfg()->ForEachBlockInPostOrder( &*function.begin(), [this, &function, &transformations](opt::BasicBlock* block) { // Only consider dead blocks. if (!GetTransformationContext()->GetFactManager()->BlockIsDead( block->id())) { return; } // Find all the uses of the label id of the block inside OpPhi // instructions. GetIRContext()->get_def_use_mgr()->ForEachUse( block->id(), [this, &function, block, &transformations]( opt::Instruction* instruction, uint32_t) { // Only consider OpPhi instructions. if (instruction->opcode() != spv::Op::OpPhi) { return; } // Randomly decide whether to consider this use. if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext() ->GetChanceOfReplacingOpPhiIdFromDeadPredecessor())) { return; } // Get the current id corresponding to the predecessor. uint32_t current_id = 0; for (uint32_t i = 1; i < instruction->NumInOperands(); i += 2) { if (instruction->GetSingleWordInOperand(i) == block->id()) { // The corresponding id is at the index of the block - 1. current_id = instruction->GetSingleWordInOperand(i - 1); break; } } assert( current_id != 0 && "The predecessor - and corresponding id - should always be " "found."); uint32_t type_id = instruction->type_id(); // Find all the suitable instructions to replace the id. const auto& candidates = FindAvailableInstructions( &function, block, block->end(), [type_id, current_id](opt::IRContext* /* unused */, opt::Instruction* candidate) -> bool { // Only consider instructions with a result id different // from the currently-used one, and with the right type. return candidate->HasResultId() && candidate->type_id() == type_id && candidate->result_id() != current_id; }); // If there is no possible replacement, we cannot apply any // transformation. if (candidates.empty()) { return; } // Choose one of the candidates. uint32_t replacement_id = candidates[GetFuzzerContext()->RandomIndex(candidates)] ->result_id(); // Add a new transformation to the list of transformations to // apply. transformations.emplace_back( TransformationReplaceOpPhiIdFromDeadPredecessor( instruction->result_id(), block->id(), replacement_id)); }); }); } // Apply all the transformations. for (const auto& transformation : transformations) { ApplyTransformation(transformation); } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_replace_opphi_ids_from_dead_predecessors.h000066400000000000000000000027001475742701700340640ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_REPLACE_OPPHI_IDS_FROM_DEAD_PREDECESSORS_H_ #define SOURCE_FUZZ_FUZZER_PASS_REPLACE_OPPHI_IDS_FROM_DEAD_PREDECESSORS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // Replaces id operands in OpPhi instructions with other available ids of the // right type, where the corresponding predecessor is dead. class FuzzerPassReplaceOpPhiIdsFromDeadPredecessors : public FuzzerPass { public: FuzzerPassReplaceOpPhiIdsFromDeadPredecessors( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_REPLACE_OPPHI_IDS_FROM_DEAD_PREDECESSORS_H_ fuzzer_pass_replace_opselects_with_conditional_branches.cpp000066400000000000000000000151621475742701700350730ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/fuzz// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_replace_opselects_with_conditional_branches.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/transformation_replace_opselect_with_conditional_branch.h" #include "source/fuzz/transformation_split_block.h" namespace spvtools { namespace fuzz { FuzzerPassReplaceOpSelectsWithConditionalBranches:: FuzzerPassReplaceOpSelectsWithConditionalBranches( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassReplaceOpSelectsWithConditionalBranches::Apply() { // Keep track of the instructions that we want to replace. We need to collect // them in a vector, since it's not safe to modify the module while iterating // over it. std::vector replaceable_opselect_instruction_ids; // Loop over all the instructions in the module. for (auto& function : *GetIRContext()->module()) { for (auto& block : function) { // We cannot split loop headers, so we don't need to consider instructions // in loop headers that are also merge blocks (since they would need to be // split). if (block.IsLoopHeader() && GetIRContext()->GetStructuredCFGAnalysis()->IsMergeBlock( block.id())) { continue; } for (auto& instruction : block) { // We only care about OpSelect instructions. if (instruction.opcode() != spv::Op::OpSelect) { continue; } // Randomly choose whether to consider this instruction for replacement. if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext() ->GetChanceOfReplacingOpselectWithConditionalBranch())) { continue; } // If the selector does not have scalar boolean type (i.e., it is a // boolean vector) then ignore this OpSelect. if (GetIRContext() ->get_def_use_mgr() ->GetDef(fuzzerutil::GetTypeId( GetIRContext(), instruction.GetSingleWordInOperand(0))) ->opcode() != spv::Op::OpTypeBool) { continue; } // If the block is a loop header and we need to split it, the // transformation cannot be applied because loop headers cannot be // split. We can break out of this loop because the transformation can // only be applied to at most the first instruction in a loop header. if (block.IsLoopHeader() && InstructionNeedsSplitBefore(&instruction)) { break; } // If the instruction separates an OpSampledImage from its use, the // block cannot be split around it and the instruction cannot be // replaced. if (fuzzerutil:: SplittingBeforeInstructionSeparatesOpSampledImageDefinitionFromUse( &block, &instruction)) { continue; } // We can apply the transformation to this instruction. replaceable_opselect_instruction_ids.push_back(instruction.result_id()); } } } // Apply the transformations, splitting the blocks containing the // instructions, if necessary. for (uint32_t instruction_id : replaceable_opselect_instruction_ids) { auto instruction = GetIRContext()->get_def_use_mgr()->GetDef(instruction_id); // If the instruction requires the block containing it to be split before // it, split the block. if (InstructionNeedsSplitBefore(instruction)) { ApplyTransformation(TransformationSplitBlock( MakeInstructionDescriptor(GetIRContext(), instruction), GetFuzzerContext()->GetFreshId())); } // Decide whether to have two branches or just one. bool two_branches = GetFuzzerContext()->ChoosePercentage( GetFuzzerContext() ->GetChanceOfAddingBothBranchesWhenReplacingOpSelect()); // If there will be only one branch, decide whether it will be the true // branch or the false branch. bool true_branch_id_zero = !two_branches && GetFuzzerContext()->ChoosePercentage( GetFuzzerContext() ->GetChanceOfAddingTrueBranchWhenReplacingOpSelect()); bool false_branch_id_zero = !two_branches && !true_branch_id_zero; uint32_t true_branch_id = true_branch_id_zero ? 0 : GetFuzzerContext()->GetFreshId(); uint32_t false_branch_id = false_branch_id_zero ? 0 : GetFuzzerContext()->GetFreshId(); ApplyTransformation(TransformationReplaceOpSelectWithConditionalBranch( instruction_id, true_branch_id, false_branch_id)); } } bool FuzzerPassReplaceOpSelectsWithConditionalBranches:: InstructionNeedsSplitBefore(opt::Instruction* instruction) { assert(instruction && instruction->opcode() == spv::Op::OpSelect && "The instruction must be OpSelect."); auto block = GetIRContext()->get_instr_block(instruction); assert(block && "The instruction must be contained in a block."); // We need to split the block if the instruction is not the first in its // block. if (instruction->unique_id() != block->begin()->unique_id()) { return true; } // We need to split the block if it is a merge block. if (GetIRContext()->GetStructuredCFGAnalysis()->IsMergeBlock(block->id())) { return true; } // We need to split the block if it has more than one predecessor. if (GetIRContext()->cfg()->preds(block->id()).size() != 1) { return true; } // We need to split the block if its predecessor is a header or it does not // branch unconditionally to the block. auto predecessor = GetIRContext()->get_instr_block( GetIRContext()->cfg()->preds(block->id())[0]); return predecessor->MergeBlockIdIfAny() || predecessor->terminator()->opcode() != spv::Op::OpBranch; } } // namespace fuzz } // namespace spvtools fuzzer_pass_replace_opselects_with_conditional_branches.h000066400000000000000000000041131475742701700345320ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/fuzz// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_REPLACE_OPSELECTS_WITH_CONDITIONAL_BRANCHES_H_ #define SOURCE_FUZZ_FUZZER_PASS_REPLACE_OPSELECTS_WITH_CONDITIONAL_BRANCHES_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // A fuzzer pass to replace OpSelect instructions (where the condition is a // scalar boolean) with conditional branches and OpPhi instructions. class FuzzerPassReplaceOpSelectsWithConditionalBranches : public FuzzerPass { public: FuzzerPassReplaceOpSelectsWithConditionalBranches( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; private: // Returns true if any of the following holds: // - the instruction is not the first in its block // - the block containing it is a merge block // - the block does not have a unique predecessor // - the predecessor of the block is the header of a construct // - the predecessor does not branch unconditionally to the block // If this function returns true, the block must be split before the // instruction for TransformationReplaceOpSelectWithConditionalBranch to be // applicable. // Assumes that the instruction is OpSelect. bool InstructionNeedsSplitBefore(opt::Instruction* instruction); }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_REPLACE_OPSELECTS_WITH_CONDITIONAL_BRANCHES_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_replace_parameter_with_global.cpp000066400000000000000000000065031475742701700322200ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_replace_parameter_with_global.h" #include #include #include "source/fuzz/fuzzer_context.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/transformation_replace_parameter_with_global.h" namespace spvtools { namespace fuzz { FuzzerPassReplaceParameterWithGlobal::FuzzerPassReplaceParameterWithGlobal( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassReplaceParameterWithGlobal::Apply() { for (const auto& function : *GetIRContext()->module()) { if (fuzzerutil::FunctionIsEntryPoint(GetIRContext(), function.result_id())) { continue; } if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfReplacingParametersWithGlobals())) { continue; } auto params = fuzzerutil::GetParameters(GetIRContext(), function.result_id()); // Make sure at least one parameter can be replaced. Also checks that the // function has at least one parameter. if (std::none_of(params.begin(), params.end(), [this](const opt::Instruction* param) { return TransformationReplaceParameterWithGlobal:: IsParameterTypeSupported(GetIRContext(), param->type_id()); })) { continue; } // Select id of a parameter to replace. const opt::Instruction* replaced_param; uint32_t param_type_id; do { replaced_param = GetFuzzerContext()->RemoveAtRandomIndex(¶ms); param_type_id = replaced_param->type_id(); assert(param_type_id && "Parameter has invalid type"); } while ( !TransformationReplaceParameterWithGlobal::IsParameterTypeSupported( GetIRContext(), param_type_id)); assert(replaced_param && "Unable to find a parameter to replace"); // Make sure type id for the global variable exists in the module. FindOrCreatePointerType(replaced_param->type_id(), spv::StorageClass::Private); // Make sure initializer for the global variable exists in the module. FindOrCreateZeroConstant(replaced_param->type_id(), false); ApplyTransformation(TransformationReplaceParameterWithGlobal( GetFuzzerContext()->GetFreshId(), replaced_param->result_id(), GetFuzzerContext()->GetFreshId())); } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_replace_parameter_with_global.h000066400000000000000000000026011475742701700316600ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_REPLACE_PARAMETER_WITH_GLOBAL_H_ #define SOURCE_FUZZ_FUZZER_PASS_REPLACE_PARAMETER_WITH_GLOBAL_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // Iterates over all non-entry-point functions in the module and randomly // replaces a parameter with a global variable. class FuzzerPassReplaceParameterWithGlobal : public FuzzerPass { public: FuzzerPassReplaceParameterWithGlobal( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_REPLACE_PARAMETER_WITH_GLOBAL_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_replace_params_with_struct.cpp000066400000000000000000000102521475742701700316030ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_replace_params_with_struct.h" #include #include #include "source/fuzz/fuzzer_context.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/transformation_replace_params_with_struct.h" namespace spvtools { namespace fuzz { FuzzerPassReplaceParamsWithStruct::FuzzerPassReplaceParamsWithStruct( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassReplaceParamsWithStruct::Apply() { for (const auto& function : *GetIRContext()->module()) { auto params = fuzzerutil::GetParameters(GetIRContext(), function.result_id()); if (params.empty() || fuzzerutil::FunctionIsEntryPoint( GetIRContext(), function.result_id())) { continue; } if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfReplacingParametersWithStruct())) { continue; } std::vector parameter_index(params.size()); std::iota(parameter_index.begin(), parameter_index.end(), 0); // Remove the indices of unsupported parameters. auto new_end = std::remove_if(parameter_index.begin(), parameter_index.end(), [this, ¶ms](uint32_t index) { return !TransformationReplaceParamsWithStruct:: IsParameterTypeSupported(GetIRContext(), params[index]->type_id()); }); // std::remove_if changes the vector so that removed elements are placed at // the end (i.e. [new_end, parameter_index.end()) is a range of removed // elements). However, the size of the vector is not changed so we need to // change that explicitly by popping those elements from the vector. parameter_index.erase(new_end, parameter_index.end()); if (parameter_index.empty()) { continue; } // Select |num_replaced_params| parameters at random. We shuffle the vector // of indices for randomization and shrink it to select first // |num_replaced_params| parameters. auto num_replaced_params = std::min( parameter_index.size(), GetFuzzerContext()->GetRandomNumberOfParametersReplacedWithStruct( static_cast(params.size()))); GetFuzzerContext()->Shuffle(¶meter_index); parameter_index.resize(num_replaced_params); // Make sure OpTypeStruct exists in the module. std::vector component_type_ids; for (auto index : parameter_index) { component_type_ids.push_back(params[index]->type_id()); } FindOrCreateStructType(component_type_ids); // Map parameters' indices to parameters' ids. std::vector parameter_id; for (auto index : parameter_index) { parameter_id.push_back(params[index]->result_id()); } std::map caller_id_to_fresh_id; for (const auto* inst : fuzzerutil::GetCallers(GetIRContext(), function.result_id())) { caller_id_to_fresh_id[inst->result_id()] = GetFuzzerContext()->GetFreshId(); } ApplyTransformation(TransformationReplaceParamsWithStruct( parameter_id, GetFuzzerContext()->GetFreshId(), GetFuzzerContext()->GetFreshId(), caller_id_to_fresh_id)); } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_replace_params_with_struct.h000066400000000000000000000026151475742701700312540ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_REPLACE_PARAMS_WITH_STRUCT_H_ #define SOURCE_FUZZ_FUZZER_PASS_REPLACE_PARAMS_WITH_STRUCT_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // Iterates over all functions in the module and randomly decides for each one // whether to replace a subset of its parameters with a struct value. class FuzzerPassReplaceParamsWithStruct : public FuzzerPass { public: FuzzerPassReplaceParamsWithStruct( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_REPLACE_PARAMS_WITH_STRUCT_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_split_blocks.cpp000066400000000000000000000101271475742701700266570ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_split_blocks.h" #include #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/transformation_split_block.h" namespace spvtools { namespace fuzz { FuzzerPassSplitBlocks::FuzzerPassSplitBlocks( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassSplitBlocks::Apply() { // Gather up pointers to all the blocks in the module. We are then able to // iterate over these pointers and split the blocks to which they point; // we cannot safely split blocks while we iterate through the module. std::vector blocks; for (auto& function : *GetIRContext()->module()) { for (auto& block : function) { blocks.push_back(&block); } } // Now go through all the block pointers that were gathered. for (auto& block : blocks) { // Probabilistically decide whether to try to split this block. if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfSplittingBlock())) { // We are not going to try to split this block. continue; } // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/2964): consider // taking a simpler approach to identifying the instruction before which // to split a block. // We are going to try to split this block. We now need to choose where // to split it. We describe the instruction before which we would like to // split a block via an InstructionDescriptor, details of which are // commented in the protobufs definition file. std::vector instruction_descriptors; // The initial base instruction is the block label. uint32_t base = block->id(); // Counts the number of times we have seen each opcode since we reset the // base instruction. std::map skip_count; // Consider every instruction in the block. The label is excluded: it is // only necessary to consider it as a base in case the first instruction // in the block does not have a result id. for (auto& inst : *block) { if (inst.HasResultId()) { // In the case that the instruction has a result id, we use the // instruction as its own base, and clear the skip counts we have // collected. base = inst.result_id(); skip_count.clear(); } const spv::Op opcode = inst.opcode(); instruction_descriptors.emplace_back(MakeInstructionDescriptor( base, opcode, skip_count.count(opcode) ? skip_count.at(opcode) : 0)); if (!inst.HasResultId()) { skip_count[opcode] = skip_count.count(opcode) ? skip_count.at(opcode) + 1 : 1; } } // Having identified all the places we might be able to split the block, // we choose one of them. auto transformation = TransformationSplitBlock( instruction_descriptors[GetFuzzerContext()->RandomIndex( instruction_descriptors)], GetFuzzerContext()->GetFreshId()); // If the position we have chosen turns out to be a valid place to split // the block, we apply the split. Otherwise the block just doesn't get // split. MaybeApplyTransformation(transformation); } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_split_blocks.h000066400000000000000000000026141475742701700263260ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_SPLIT_BLOCKS_H_ #define SOURCE_FUZZ_FUZZER_PASS_SPLIT_BLOCKS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // A fuzzer pass for splitting blocks in the module, to create more blocks; this // can be very useful for giving other passes a chance to apply. class FuzzerPassSplitBlocks : public FuzzerPass { public: FuzzerPassSplitBlocks(opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_SPLIT_BLOCKS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_swap_commutable_operands.cpp000066400000000000000000000040051475742701700312420ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_swap_commutable_operands.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/transformation_swap_commutable_operands.h" namespace spvtools { namespace fuzz { FuzzerPassSwapCommutableOperands::FuzzerPassSwapCommutableOperands( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassSwapCommutableOperands::Apply() { auto context = GetIRContext(); // Iterates over the module's instructions and checks whether it is // commutative. In this case, the transformation is probabilistically applied. context->module()->ForEachInst( [this, context](opt::Instruction* instruction) { if (spvOpcodeIsCommutativeBinaryOperator(instruction->opcode()) && GetFuzzerContext()->ChooseEven()) { auto instructionDescriptor = MakeInstructionDescriptor(context, instruction); auto transformation = TransformationSwapCommutableOperands(instructionDescriptor); ApplyTransformation(transformation); } }); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_swap_commutable_operands.h000066400000000000000000000026471475742701700307210ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_SWAP_COMMUTABLE_OPERANDS_H_ #define SOURCE_FUZZ_FUZZER_PASS_SWAP_COMMUTABLE_OPERANDS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // This fuzzer pass searches for all commutative instructions in the module, // probabilistically choosing which of these instructions will have its input // operands swapped. class FuzzerPassSwapCommutableOperands : public FuzzerPass { public: FuzzerPassSwapCommutableOperands( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_SWAP_COMMUTABLE_OPERANDS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_swap_conditional_branch_operands.cpp000066400000000000000000000042221475742701700327330ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_swap_conditional_branch_operands.h" #include "source/fuzz/fuzzer_context.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/transformation_swap_conditional_branch_operands.h" namespace spvtools { namespace fuzz { FuzzerPassSwapBranchConditionalOperands:: FuzzerPassSwapBranchConditionalOperands( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassSwapBranchConditionalOperands::Apply() { ForEachInstructionWithInstructionDescriptor( [this](opt::Function* /*unused*/, opt::BasicBlock* /*unused*/, opt::BasicBlock::iterator inst_it, const protobufs::InstructionDescriptor& instruction_descriptor) { const auto& inst = *inst_it; if (inst.opcode() != spv::Op::OpBranchConditional) { return; } if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext() ->GetChanceOfSwappingConditionalBranchOperands())) { return; } ApplyTransformation(TransformationSwapConditionalBranchOperands( instruction_descriptor, GetFuzzerContext()->GetFreshId())); }); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_swap_conditional_branch_operands.h000066400000000000000000000026111475742701700324000ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_SWAP_BRANCH_CONDITIONAL_OPERANDS_H_ #define SOURCE_FUZZ_FUZZER_PASS_SWAP_BRANCH_CONDITIONAL_OPERANDS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // Randomly decides for each OpBranchConditional instruction in the module // whether to swap its operands or not. class FuzzerPassSwapBranchConditionalOperands : public FuzzerPass { public: FuzzerPassSwapBranchConditionalOperands( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_SWAP_BRANCH_CONDITIONAL_OPERANDS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_swap_functions.cpp000066400000000000000000000036771475742701700272450ustar00rootroot00000000000000// Copyright (c) 2021 Shiyu Liu // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_swap_functions.h" #include "source/fuzz/fuzzer_context.h" #include "source/fuzz/transformation_swap_two_functions.h" namespace spvtools { namespace fuzz { FuzzerPassSwapFunctions::FuzzerPassSwapFunctions( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassSwapFunctions::Apply() { // Collect all function ids in a module. std::vector function_ids; for (auto& function : *GetIRContext()->module()) { function_ids.emplace_back(function.result_id()); } // Iterate through every combination of id i & j where i!=j. for (size_t i = 0; i < function_ids.size(); ++i) { for (size_t j = i + 1; j < function_ids.size(); ++j) { // Perform function swap randomly. if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfSwappingFunctions())) { continue; } TransformationSwapTwoFunctions transformation(function_ids[i], function_ids[j]); } } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_swap_functions.h000066400000000000000000000024671475742701700267060ustar00rootroot00000000000000// Copyright (c) 2021 Shiyu Liu // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_SWAP_FUNCTIONS_H_ #define SOURCE_FUZZ_FUZZER_PASS_SWAP_FUNCTIONS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // Randomly swap functions within a module. class FuzzerPassSwapFunctions : public FuzzerPass { public: FuzzerPassSwapFunctions(opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_SWAP_FUNCTIONS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_toggle_access_chain_instruction.cpp000066400000000000000000000043341475742701700325770ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_toggle_access_chain_instruction.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/transformation_toggle_access_chain_instruction.h" namespace spvtools { namespace fuzz { FuzzerPassToggleAccessChainInstruction::FuzzerPassToggleAccessChainInstruction( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassToggleAccessChainInstruction::Apply() { auto context = GetIRContext(); // Iterates over the module's instructions and checks whether it is // OpAccessChain or OpInBoundsAccessChain. In this case, the transformation is // probabilistically applied. context->module()->ForEachInst([this, context](opt::Instruction* instruction) { spv::Op opcode = instruction->opcode(); if ((opcode == spv::Op::OpAccessChain || opcode == spv::Op::OpInBoundsAccessChain) && GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfTogglingAccessChainInstruction())) { auto instructionDescriptor = MakeInstructionDescriptor(context, instruction); auto transformation = TransformationToggleAccessChainInstruction(instructionDescriptor); ApplyTransformation(transformation); } }); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_toggle_access_chain_instruction.h000066400000000000000000000026611475742701700322450ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_TOGGLE_ACCESS_CHAIN_INSTRUCTION_H_ #define SOURCE_FUZZ_FUZZER_PASS_TOGGLE_ACCESS_CHAIN_INSTRUCTION_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // This fuzzer pass searches for all access chain instructions in the module, // probabilistically choosing which of these instructions will be toggled. class FuzzerPassToggleAccessChainInstruction : public FuzzerPass { public: FuzzerPassToggleAccessChainInstruction( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_TOGGLE_ACCESS_CHAIN_INSTRUCTION_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_wrap_regions_in_selections.cpp000066400000000000000000000121101475742701700315760ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_wrap_regions_in_selections.h" #include "source/fuzz/fuzzer_context.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/transformation_split_block.h" #include "source/fuzz/transformation_wrap_region_in_selection.h" namespace spvtools { namespace fuzz { FuzzerPassWrapRegionsInSelections::FuzzerPassWrapRegionsInSelections( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassWrapRegionsInSelections::Apply() { for (auto& function : *GetIRContext()->module()) { if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfWrappingRegionInSelection())) { continue; } // It is easier to select an element at random from a vector than from an // instruction list. std::vector header_block_candidates; for (auto& block : function) { header_block_candidates.push_back(&block); } if (header_block_candidates.empty()) { continue; } // Try to get a header block candidate that will increase the chances of the // transformation being applicable. auto* header_block_candidate = MaybeGetHeaderBlockCandidate( header_block_candidates[GetFuzzerContext()->RandomIndex( header_block_candidates)]); if (!header_block_candidate) { continue; } std::vector merge_block_candidates; for (auto& block : function) { if (GetIRContext()->GetDominatorAnalysis(&function)->StrictlyDominates( header_block_candidate, &block) && GetIRContext() ->GetPostDominatorAnalysis(&function) ->StrictlyDominates(&block, header_block_candidate)) { merge_block_candidates.push_back(&block); } } if (merge_block_candidates.empty()) { continue; } // Try to get a merge block candidate that will increase the chances of the // transformation being applicable. auto* merge_block_candidate = MaybeGetMergeBlockCandidate( merge_block_candidates[GetFuzzerContext()->RandomIndex( merge_block_candidates)]); if (!merge_block_candidate) { continue; } if (!TransformationWrapRegionInSelection::IsApplicableToBlockRange( GetIRContext(), header_block_candidate->id(), merge_block_candidate->id())) { continue; } // This boolean constant will be used as a condition for the // OpBranchConditional instruction. We mark it as irrelevant to be able to // replace it with a more interesting value later. auto branch_condition = GetFuzzerContext()->ChooseEven(); FindOrCreateBoolConstant(branch_condition, true); ApplyTransformation(TransformationWrapRegionInSelection( header_block_candidate->id(), merge_block_candidate->id(), branch_condition)); } } opt::BasicBlock* FuzzerPassWrapRegionsInSelections::MaybeGetHeaderBlockCandidate( opt::BasicBlock* header_block_candidate) { // Try to create a preheader if |header_block_candidate| is a loop header. if (header_block_candidate->IsLoopHeader()) { // GetOrCreateSimpleLoopPreheader only supports reachable blocks. return GetIRContext()->cfg()->preds(header_block_candidate->id()).size() == 1 ? nullptr : GetOrCreateSimpleLoopPreheader(header_block_candidate->id()); } // Try to split |header_block_candidate| if it's already a header block. if (header_block_candidate->GetMergeInst()) { SplitBlockAfterOpPhiOrOpVariable(header_block_candidate->id()); } return header_block_candidate; } opt::BasicBlock* FuzzerPassWrapRegionsInSelections::MaybeGetMergeBlockCandidate( opt::BasicBlock* merge_block_candidate) { // If |merge_block_candidate| is a merge block of some construct, try to split // it and return a newly created block. if (GetIRContext()->GetStructuredCFGAnalysis()->IsMergeBlock( merge_block_candidate->id())) { // We can't split a merge block if it's also a loop header. return merge_block_candidate->IsLoopHeader() ? nullptr : SplitBlockAfterOpPhiOrOpVariable(merge_block_candidate->id()); } return merge_block_candidate; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_wrap_regions_in_selections.h000066400000000000000000000040251475742701700312510ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_WRAP_REGIONS_IN_SELECTIONS_H_ #define SOURCE_FUZZ_FUZZER_PASS_WRAP_REGIONS_IN_SELECTIONS_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // Randomly wraps a region of blocks in every function into a selection // construct. class FuzzerPassWrapRegionsInSelections : public FuzzerPass { public: FuzzerPassWrapRegionsInSelections( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; private: // Tries to adjust |header_block_candidate| such that // TransformationWrapRegionInSelection has higher chances of being // applied. In particular, tries to split |header_block_candidate| if it's // already a header block of some other construct. opt::BasicBlock* MaybeGetHeaderBlockCandidate( opt::BasicBlock* header_block_candidate); // Tries to adjust |merge_block_candidate| such that // TransformationWrapRegionInSelection has higher chances of being // applied. In particular, tries to split |merge_block_candidate| if it's // already a merge block of some other construct. opt::BasicBlock* MaybeGetMergeBlockCandidate( opt::BasicBlock* merge_block_candidate); }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_WRAP_REGIONS_IN_SELECTIONS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_wrap_vector_synonym.cpp000066400000000000000000000145021475742701700303170ustar00rootroot00000000000000// Copyright (c) 2021 Shiyu Liu // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_wrap_vector_synonym.h" #include "source/fuzz/fuzzer_context.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/transformation_composite_construct.h" #include "source/fuzz/transformation_wrap_vector_synonym.h" namespace spvtools { namespace fuzz { FuzzerPassWrapVectorSynonym::FuzzerPassWrapVectorSynonym( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, ignore_inapplicable_transformations) {} void FuzzerPassWrapVectorSynonym::Apply() { ForEachInstructionWithInstructionDescriptor( [this](opt::Function* /*unused*/, opt::BasicBlock* /*unused*/, opt::BasicBlock::iterator instruction_iterator, const protobufs::InstructionDescriptor& instruction_descriptor) -> void { // Randomly decide whether to wrap it to a vector operation. if (!GetFuzzerContext()->ChoosePercentage( GetFuzzerContext()->GetChanceOfWrappingVectorSynonym())) { return; } // The transformation is not applicable if the instruction has missing // result id, type id, or is not supported type. if (!TransformationWrapVectorSynonym::IsInstructionSupported( GetIRContext(), *instruction_iterator)) { return; } // It must be valid to insert an OpCompositeConstruct instruction // before |instruction_iterator|. if (!fuzzerutil::CanInsertOpcodeBeforeInstruction( spv::Op::OpCompositeConstruct, instruction_iterator)) { return; } // Get the scalar operands from the original instruction. opt::Instruction* operand1 = GetIRContext()->get_def_use_mgr()->GetDef( instruction_iterator->GetSingleWordInOperand(0)); opt::Instruction* operand2 = GetIRContext()->get_def_use_mgr()->GetDef( instruction_iterator->GetSingleWordInOperand(1)); // We need to be able to make a synonym of the scalar operation's result // id, as well as the operand ids (for example, they cannot be // irrelevant). if (!fuzzerutil::CanMakeSynonymOf(GetIRContext(), *GetTransformationContext(), *instruction_iterator)) { return; } if (!fuzzerutil::CanMakeSynonymOf( GetIRContext(), *GetTransformationContext(), *operand1)) { return; } if (!fuzzerutil::CanMakeSynonymOf( GetIRContext(), *GetTransformationContext(), *operand2)) { return; } // Get a random vector size from 2 to 4. uint32_t vector_size = GetFuzzerContext()->GetWidthOfWrappingVector(); // Randomly choose a position that target ids should be placed at. // The position is in range [0, n - 1], where n is the size of the // vector. uint32_t position = GetFuzzerContext()->GetRandomIndexForWrappingVector(vector_size); // Stores the ids of scalar constants. std::vector vec1_components; std::vector vec2_components; // Populate components based on vector type and size. for (uint32_t i = 0; i < vector_size; ++i) { if (i == position) { vec1_components.emplace_back(operand1->result_id()); vec2_components.emplace_back(operand2->result_id()); } else { vec1_components.emplace_back( FindOrCreateZeroConstant(operand1->type_id(), true)); vec2_components.emplace_back( FindOrCreateZeroConstant(operand2->type_id(), true)); } } // Add two OpCompositeConstruct to the module with result id returned. // The added vectors may have different types, for instance if the // scalar instruction operates on integers with differing sign. // Add the first OpCompositeConstruct that wraps the id of the first // operand. uint32_t result_id1 = GetFuzzerContext()->GetFreshId(); ApplyTransformation(TransformationCompositeConstruct( FindOrCreateVectorType(operand1->type_id(), vector_size), vec1_components, instruction_descriptor, result_id1)); // Add the second OpCompositeConstruct that wraps the id of the second // operand. uint32_t result_id2 = GetFuzzerContext()->GetFreshId(); ApplyTransformation(TransformationCompositeConstruct( FindOrCreateVectorType(operand2->type_id(), vector_size), vec2_components, instruction_descriptor, result_id2)); // The result of the vector instruction that // TransformationWrapVectorSynonym will create should be a vector of the // right size, with the scalar instruction's result type as its element // type. This can be distinct from the types of the operands, if the // scalar instruction adds two signed integers and stores the result in // an unsigned id, for example. A transformation is applied to add the // right type to the module. FindOrCreateVectorType(instruction_iterator->type_id(), vector_size); // Apply transformation to do vector operation and add synonym between // the result vector id and the id of the original instruction. ApplyTransformation(TransformationWrapVectorSynonym( instruction_iterator->result_id(), result_id1, result_id2, GetFuzzerContext()->GetFreshId(), position)); }); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_pass_wrap_vector_synonym.h000066400000000000000000000024201475742701700277600ustar00rootroot00000000000000// Copyright (c) 2021 Shiyu Liu // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_PASS_WRAP_VECTOR_SYNONYM_H_ #define SOURCE_FUZZ_FUZZER_PASS_WRAP_VECTOR_SYNONYM_H_ #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // Randomly wrap a scalar operation into a vector operation. class FuzzerPassWrapVectorSynonym : public FuzzerPass { public: FuzzerPassWrapVectorSynonym( opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations, bool ignore_inapplicable_transformations); void Apply() override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_PASS_WRAP_VECTOR_SYNONYM_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_util.cpp000066400000000000000000002325511475742701700241250ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_util.h" #include #include #include "source/opt/build_module.h" namespace spvtools { namespace fuzz { namespace fuzzerutil { namespace { // A utility class that uses RAII to change and restore the terminator // instruction of the |block|. class ChangeTerminatorRAII { public: explicit ChangeTerminatorRAII(opt::BasicBlock* block, opt::Instruction new_terminator) : block_(block), old_terminator_(std::move(*block->terminator())) { *block_->terminator() = std::move(new_terminator); } ~ChangeTerminatorRAII() { *block_->terminator() = std::move(old_terminator_); } private: opt::BasicBlock* block_; opt::Instruction old_terminator_; }; uint32_t MaybeGetOpConstant(opt::IRContext* ir_context, const TransformationContext& transformation_context, const std::vector& words, uint32_t type_id, bool is_irrelevant) { for (const auto& inst : ir_context->types_values()) { if (inst.opcode() == spv::Op::OpConstant && inst.type_id() == type_id && inst.GetInOperand(0).words == words && transformation_context.GetFactManager()->IdIsIrrelevant( inst.result_id()) == is_irrelevant) { return inst.result_id(); } } return 0; } } // namespace const spvtools::MessageConsumer kSilentMessageConsumer = [](spv_message_level_t, const char*, const spv_position_t&, const char*) -> void {}; bool BuildIRContext(spv_target_env target_env, const spvtools::MessageConsumer& message_consumer, const std::vector& binary_in, spv_validator_options validator_options, std::unique_ptr* ir_context) { SpirvTools tools(target_env); tools.SetMessageConsumer(message_consumer); if (!tools.IsValid()) { message_consumer(SPV_MSG_ERROR, nullptr, {}, "Failed to create SPIRV-Tools interface; stopping."); return false; } // Initial binary should be valid. if (!tools.Validate(binary_in.data(), binary_in.size(), validator_options)) { message_consumer(SPV_MSG_ERROR, nullptr, {}, "Initial binary is invalid; stopping."); return false; } // Build the module from the input binary. auto result = BuildModule(target_env, message_consumer, binary_in.data(), binary_in.size()); assert(result && "IRContext must be valid"); *ir_context = std::move(result); return true; } bool IsFreshId(opt::IRContext* context, uint32_t id) { return !context->get_def_use_mgr()->GetDef(id); } void UpdateModuleIdBound(opt::IRContext* context, uint32_t id) { // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/2541) consider the // case where the maximum id bound is reached. context->module()->SetIdBound( std::max(context->module()->id_bound(), id + 1)); } opt::BasicBlock* MaybeFindBlock(opt::IRContext* context, uint32_t maybe_block_id) { auto inst = context->get_def_use_mgr()->GetDef(maybe_block_id); if (inst == nullptr) { // No instruction defining this id was found. return nullptr; } if (inst->opcode() != spv::Op::OpLabel) { // The instruction defining the id is not a label, so it cannot be a block // id. return nullptr; } return context->cfg()->block(maybe_block_id); } bool PhiIdsOkForNewEdge( opt::IRContext* context, opt::BasicBlock* bb_from, opt::BasicBlock* bb_to, const google::protobuf::RepeatedField& phi_ids) { if (bb_from->IsSuccessor(bb_to)) { // There is already an edge from |from_block| to |to_block|, so there is // no need to extend OpPhi instructions. Do not allow phi ids to be // present. This might turn out to be too strict; perhaps it would be OK // just to ignore the ids in this case. return phi_ids.empty(); } // The edge would add a previously non-existent edge from |from_block| to // |to_block|, so we go through the given phi ids and check that they exactly // match the OpPhi instructions in |to_block|. uint32_t phi_index = 0; // An explicit loop, rather than applying a lambda to each OpPhi in |bb_to|, // makes sense here because we need to increment |phi_index| for each OpPhi // instruction. for (auto& inst : *bb_to) { if (inst.opcode() != spv::Op::OpPhi) { // The OpPhi instructions all occur at the start of the block; if we find // a non-OpPhi then we have seen them all. break; } if (phi_index == static_cast(phi_ids.size())) { // Not enough phi ids have been provided to account for the OpPhi // instructions. return false; } // Look for an instruction defining the next phi id. opt::Instruction* phi_extension = context->get_def_use_mgr()->GetDef(phi_ids[phi_index]); if (!phi_extension) { // The id given to extend this OpPhi does not exist. return false; } if (phi_extension->type_id() != inst.type_id()) { // The instruction given to extend this OpPhi either does not have a type // or its type does not match that of the OpPhi. return false; } if (context->get_instr_block(phi_extension)) { // The instruction defining the phi id has an associated block (i.e., it // is not a global value). Check whether its definition dominates the // exit of |from_block|. auto dominator_analysis = context->GetDominatorAnalysis(bb_from->GetParent()); if (!dominator_analysis->Dominates(phi_extension, bb_from->terminator())) { // The given id is no good as its definition does not dominate the exit // of |from_block| return false; } } phi_index++; } // We allow some of the ids provided for extending OpPhi instructions to be // unused. Their presence does no harm, and requiring a perfect match may // make transformations less likely to cleanly apply. return true; } opt::Instruction CreateUnreachableEdgeInstruction(opt::IRContext* ir_context, uint32_t bb_from_id, uint32_t bb_to_id, uint32_t bool_id) { const auto* bb_from = MaybeFindBlock(ir_context, bb_from_id); assert(bb_from && "|bb_from_id| is invalid"); assert(MaybeFindBlock(ir_context, bb_to_id) && "|bb_to_id| is invalid"); assert(bb_from->terminator()->opcode() == spv::Op::OpBranch && "Precondition on terminator of bb_from is not satisfied"); // Get the id of the boolean constant to be used as the condition. auto condition_inst = ir_context->get_def_use_mgr()->GetDef(bool_id); assert(condition_inst && (condition_inst->opcode() == spv::Op::OpConstantTrue || condition_inst->opcode() == spv::Op::OpConstantFalse) && "|bool_id| is invalid"); auto condition_value = condition_inst->opcode() == spv::Op::OpConstantTrue; auto successor_id = bb_from->terminator()->GetSingleWordInOperand(0); // Add the dead branch, by turning OpBranch into OpBranchConditional, and // ordering the targets depending on whether the given boolean corresponds to // true or false. return opt::Instruction( ir_context, spv::Op::OpBranchConditional, 0, 0, {{SPV_OPERAND_TYPE_ID, {bool_id}}, {SPV_OPERAND_TYPE_ID, {condition_value ? successor_id : bb_to_id}}, {SPV_OPERAND_TYPE_ID, {condition_value ? bb_to_id : successor_id}}}); } void AddUnreachableEdgeAndUpdateOpPhis( opt::IRContext* context, opt::BasicBlock* bb_from, opt::BasicBlock* bb_to, uint32_t bool_id, const google::protobuf::RepeatedField& phi_ids) { assert(PhiIdsOkForNewEdge(context, bb_from, bb_to, phi_ids) && "Precondition on phi_ids is not satisfied"); const bool from_to_edge_already_exists = bb_from->IsSuccessor(bb_to); *bb_from->terminator() = CreateUnreachableEdgeInstruction( context, bb_from->id(), bb_to->id(), bool_id); // Update OpPhi instructions in the target block if this branch adds a // previously non-existent edge from source to target. if (!from_to_edge_already_exists) { uint32_t phi_index = 0; for (auto& inst : *bb_to) { if (inst.opcode() != spv::Op::OpPhi) { break; } assert(phi_index < static_cast(phi_ids.size()) && "There should be at least one phi id per OpPhi instruction."); inst.AddOperand({SPV_OPERAND_TYPE_ID, {phi_ids[phi_index]}}); inst.AddOperand({SPV_OPERAND_TYPE_ID, {bb_from->id()}}); phi_index++; } } } bool BlockIsBackEdge(opt::IRContext* context, uint32_t block_id, uint32_t loop_header_id) { auto block = context->cfg()->block(block_id); auto loop_header = context->cfg()->block(loop_header_id); // |block| and |loop_header| must be defined, |loop_header| must be in fact // loop header and |block| must branch to it. if (!(block && loop_header && loop_header->IsLoopHeader() && block->IsSuccessor(loop_header))) { return false; } // |block| must be reachable and be dominated by |loop_header|. opt::DominatorAnalysis* dominator_analysis = context->GetDominatorAnalysis(loop_header->GetParent()); return context->IsReachable(*block) && dominator_analysis->Dominates(loop_header, block); } bool BlockIsInLoopContinueConstruct(opt::IRContext* context, uint32_t block_id, uint32_t maybe_loop_header_id) { // We deem a block to be part of a loop's continue construct if the loop's // continue target dominates the block. auto containing_construct_block = context->cfg()->block(maybe_loop_header_id); if (containing_construct_block->IsLoopHeader()) { auto continue_target = containing_construct_block->ContinueBlockId(); if (context->GetDominatorAnalysis(containing_construct_block->GetParent()) ->Dominates(continue_target, block_id)) { return true; } } return false; } opt::BasicBlock::iterator GetIteratorForInstruction( opt::BasicBlock* block, const opt::Instruction* inst) { for (auto inst_it = block->begin(); inst_it != block->end(); ++inst_it) { if (inst == &*inst_it) { return inst_it; } } return block->end(); } bool CanInsertOpcodeBeforeInstruction( spv::Op opcode, const opt::BasicBlock::iterator& instruction_in_block) { if (instruction_in_block->PreviousNode() && (instruction_in_block->PreviousNode()->opcode() == spv::Op::OpLoopMerge || instruction_in_block->PreviousNode()->opcode() == spv::Op::OpSelectionMerge)) { // We cannot insert directly after a merge instruction. return false; } if (opcode != spv::Op::OpVariable && instruction_in_block->opcode() == spv::Op::OpVariable) { // We cannot insert a non-OpVariable instruction directly before a // variable; variables in a function must be contiguous in the entry block. return false; } // We cannot insert a non-OpPhi instruction directly before an OpPhi, because // OpPhi instructions need to be contiguous at the start of a block. return opcode == spv::Op::OpPhi || instruction_in_block->opcode() != spv::Op::OpPhi; } bool CanMakeSynonymOf(opt::IRContext* ir_context, const TransformationContext& transformation_context, const opt::Instruction& inst) { if (inst.opcode() == spv::Op::OpSampledImage) { // The SPIR-V data rules say that only very specific instructions may // may consume the result id of an OpSampledImage, and this excludes the // instructions that are used for making synonyms. return false; } if (!inst.HasResultId()) { // We can only make a synonym of an instruction that generates an id. return false; } if (transformation_context.GetFactManager()->IdIsIrrelevant( inst.result_id())) { // An irrelevant id can't be a synonym of anything. return false; } if (!inst.type_id()) { // We can only make a synonym of an instruction that has a type. return false; } auto type_inst = ir_context->get_def_use_mgr()->GetDef(inst.type_id()); if (type_inst->opcode() == spv::Op::OpTypeVoid) { // We only make synonyms of instructions that define objects, and an object // cannot have void type. return false; } if (type_inst->opcode() == spv::Op::OpTypePointer) { switch (inst.opcode()) { case spv::Op::OpConstantNull: case spv::Op::OpUndef: // We disallow making synonyms of null or undefined pointers. This is // to provide the property that if the original shader exhibited no bad // pointer accesses, the transformed shader will not either. return false; default: break; } } // We do not make synonyms of objects that have decorations: if the synonym is // not decorated analogously, using the original object vs. its synonymous // form may not be equivalent. return ir_context->get_decoration_mgr() ->GetDecorationsFor(inst.result_id(), true) .empty(); } bool IsCompositeType(const opt::analysis::Type* type) { return type && (type->AsArray() || type->AsMatrix() || type->AsStruct() || type->AsVector()); } std::vector RepeatedFieldToVector( const google::protobuf::RepeatedField& repeated_field) { std::vector result; for (auto i : repeated_field) { result.push_back(i); } return result; } uint32_t WalkOneCompositeTypeIndex(opt::IRContext* context, uint32_t base_object_type_id, uint32_t index) { auto should_be_composite_type = context->get_def_use_mgr()->GetDef(base_object_type_id); assert(should_be_composite_type && "The type should exist."); switch (should_be_composite_type->opcode()) { case spv::Op::OpTypeArray: { auto array_length = GetArraySize(*should_be_composite_type, context); if (array_length == 0 || index >= array_length) { return 0; } return should_be_composite_type->GetSingleWordInOperand(0); } case spv::Op::OpTypeMatrix: case spv::Op::OpTypeVector: { auto count = should_be_composite_type->GetSingleWordInOperand(1); if (index >= count) { return 0; } return should_be_composite_type->GetSingleWordInOperand(0); } case spv::Op::OpTypeStruct: { if (index >= GetNumberOfStructMembers(*should_be_composite_type)) { return 0; } return should_be_composite_type->GetSingleWordInOperand(index); } default: return 0; } } uint32_t WalkCompositeTypeIndices( opt::IRContext* context, uint32_t base_object_type_id, const google::protobuf::RepeatedField& indices) { uint32_t sub_object_type_id = base_object_type_id; for (auto index : indices) { sub_object_type_id = WalkOneCompositeTypeIndex(context, sub_object_type_id, index); if (!sub_object_type_id) { return 0; } } return sub_object_type_id; } uint32_t GetNumberOfStructMembers( const opt::Instruction& struct_type_instruction) { assert(struct_type_instruction.opcode() == spv::Op::OpTypeStruct && "An OpTypeStruct instruction is required here."); return struct_type_instruction.NumInOperands(); } uint32_t GetArraySize(const opt::Instruction& array_type_instruction, opt::IRContext* context) { auto array_length_constant = context->get_constant_mgr() ->GetConstantFromInst(context->get_def_use_mgr()->GetDef( array_type_instruction.GetSingleWordInOperand(1))) ->AsIntConstant(); if (array_length_constant->words().size() != 1) { return 0; } return array_length_constant->GetU32(); } uint32_t GetBoundForCompositeIndex(const opt::Instruction& composite_type_inst, opt::IRContext* ir_context) { switch (composite_type_inst.opcode()) { case spv::Op::OpTypeArray: return fuzzerutil::GetArraySize(composite_type_inst, ir_context); case spv::Op::OpTypeMatrix: case spv::Op::OpTypeVector: return composite_type_inst.GetSingleWordInOperand(1); case spv::Op::OpTypeStruct: { return fuzzerutil::GetNumberOfStructMembers(composite_type_inst); } case spv::Op::OpTypeRuntimeArray: assert(false && "GetBoundForCompositeIndex should not be invoked with an " "OpTypeRuntimeArray, which does not have a static bound."); return 0; default: assert(false && "Unknown composite type."); return 0; } } spv::MemorySemanticsMask GetMemorySemanticsForStorageClass( spv::StorageClass storage_class) { switch (storage_class) { case spv::StorageClass::Workgroup: return spv::MemorySemanticsMask::WorkgroupMemory; case spv::StorageClass::StorageBuffer: case spv::StorageClass::PhysicalStorageBuffer: return spv::MemorySemanticsMask::UniformMemory; case spv::StorageClass::CrossWorkgroup: return spv::MemorySemanticsMask::CrossWorkgroupMemory; case spv::StorageClass::AtomicCounter: return spv::MemorySemanticsMask::AtomicCounterMemory; case spv::StorageClass::Image: return spv::MemorySemanticsMask::ImageMemory; default: return spv::MemorySemanticsMask::MaskNone; } } bool IsValid(const opt::IRContext* context, spv_validator_options validator_options, MessageConsumer consumer) { std::vector binary; context->module()->ToBinary(&binary, false); SpirvTools tools(context->grammar().target_env()); tools.SetMessageConsumer(std::move(consumer)); return tools.Validate(binary.data(), binary.size(), validator_options); } bool IsValidAndWellFormed(const opt::IRContext* ir_context, spv_validator_options validator_options, MessageConsumer consumer) { if (!IsValid(ir_context, validator_options, consumer)) { // Expression to dump |ir_context| to /data/temp/shader.spv: // DumpShader(ir_context, "/data/temp/shader.spv") consumer(SPV_MSG_INFO, nullptr, {}, "Module is invalid (set a breakpoint to inspect)."); return false; } // Check that all blocks in the module have appropriate parent functions. for (auto& function : *ir_context->module()) { for (auto& block : function) { if (block.GetParent() == nullptr) { std::stringstream ss; ss << "Block " << block.id() << " has no parent; its parent should be " << function.result_id() << " (set a breakpoint to inspect)."; consumer(SPV_MSG_INFO, nullptr, {}, ss.str().c_str()); return false; } if (block.GetParent() != &function) { std::stringstream ss; ss << "Block " << block.id() << " should have parent " << function.result_id() << " but instead has parent " << block.GetParent() << " (set a breakpoint to inspect)."; consumer(SPV_MSG_INFO, nullptr, {}, ss.str().c_str()); return false; } } } // Check that all instructions have distinct unique ids. We map each unique // id to the first instruction it is observed to be associated with so that // if we encounter a duplicate we have access to the previous instruction - // this is a useful aid to debugging. std::unordered_map unique_ids; bool found_duplicate = false; ir_context->module()->ForEachInst([&consumer, &found_duplicate, ir_context, &unique_ids](opt::Instruction* inst) { (void)ir_context; // Only used in an assertion; keep release-mode compilers // happy. assert(inst->context() == ir_context && "Instruction has wrong IR context."); if (unique_ids.count(inst->unique_id()) != 0) { consumer(SPV_MSG_INFO, nullptr, {}, "Two instructions have the same unique id (set a breakpoint to " "inspect)."); found_duplicate = true; } unique_ids.insert({inst->unique_id(), inst}); }); return !found_duplicate; } std::unique_ptr CloneIRContext(opt::IRContext* context) { std::vector binary; context->module()->ToBinary(&binary, false); return BuildModule(context->grammar().target_env(), nullptr, binary.data(), binary.size()); } bool IsNonFunctionTypeId(opt::IRContext* ir_context, uint32_t id) { auto type = ir_context->get_type_mgr()->GetType(id); return type && !type->AsFunction(); } bool IsMergeOrContinue(opt::IRContext* ir_context, uint32_t block_id) { bool result = false; ir_context->get_def_use_mgr()->WhileEachUse( block_id, [&result](const opt::Instruction* use_instruction, uint32_t /*unused*/) -> bool { switch (use_instruction->opcode()) { case spv::Op::OpLoopMerge: case spv::Op::OpSelectionMerge: result = true; return false; default: return true; } }); return result; } uint32_t GetLoopFromMergeBlock(opt::IRContext* ir_context, uint32_t merge_block_id) { uint32_t result = 0; ir_context->get_def_use_mgr()->WhileEachUse( merge_block_id, [ir_context, &result](opt::Instruction* use_instruction, uint32_t use_index) -> bool { switch (use_instruction->opcode()) { case spv::Op::OpLoopMerge: // The merge block operand is the first operand in OpLoopMerge. if (use_index == 0) { result = ir_context->get_instr_block(use_instruction)->id(); return false; } return true; default: return true; } }); return result; } uint32_t FindFunctionType(opt::IRContext* ir_context, const std::vector& type_ids) { // Look through the existing types for a match. for (auto& type_or_value : ir_context->types_values()) { if (type_or_value.opcode() != spv::Op::OpTypeFunction) { // We are only interested in function types. continue; } if (type_or_value.NumInOperands() != type_ids.size()) { // Not a match: different numbers of arguments. continue; } // Check whether the return type and argument types match. bool input_operands_match = true; for (uint32_t i = 0; i < type_or_value.NumInOperands(); i++) { if (type_ids[i] != type_or_value.GetSingleWordInOperand(i)) { input_operands_match = false; break; } } if (input_operands_match) { // Everything matches. return type_or_value.result_id(); } } // No match was found. return 0; } opt::Instruction* GetFunctionType(opt::IRContext* context, const opt::Function* function) { uint32_t type_id = function->DefInst().GetSingleWordInOperand(1); return context->get_def_use_mgr()->GetDef(type_id); } opt::Function* FindFunction(opt::IRContext* ir_context, uint32_t function_id) { for (auto& function : *ir_context->module()) { if (function.result_id() == function_id) { return &function; } } return nullptr; } bool FunctionContainsOpKillOrUnreachable(const opt::Function& function) { for (auto& block : function) { if (block.terminator()->opcode() == spv::Op::OpKill || block.terminator()->opcode() == spv::Op::OpUnreachable) { return true; } } return false; } bool FunctionIsEntryPoint(opt::IRContext* context, uint32_t function_id) { for (auto& entry_point : context->module()->entry_points()) { if (entry_point.GetSingleWordInOperand(1) == function_id) { return true; } } return false; } bool IdIsAvailableAtUse(opt::IRContext* context, opt::Instruction* use_instruction, uint32_t use_input_operand_index, uint32_t id) { assert(context->get_instr_block(use_instruction) && "|use_instruction| must be in a basic block"); auto defining_instruction = context->get_def_use_mgr()->GetDef(id); auto enclosing_function = context->get_instr_block(use_instruction)->GetParent(); // If the id a function parameter, it needs to be associated with the // function containing the use. if (defining_instruction->opcode() == spv::Op::OpFunctionParameter) { return InstructionIsFunctionParameter(defining_instruction, enclosing_function); } if (!context->get_instr_block(id)) { // The id must be at global scope. return true; } if (defining_instruction == use_instruction) { // It is not OK for a definition to use itself. return false; } if (!context->IsReachable(*context->get_instr_block(use_instruction)) || !context->IsReachable(*context->get_instr_block(id))) { // Skip unreachable blocks. return false; } auto dominator_analysis = context->GetDominatorAnalysis(enclosing_function); if (use_instruction->opcode() == spv::Op::OpPhi) { // In the case where the use is an operand to OpPhi, it is actually the // *parent* block associated with the operand that must be dominated by // the synonym. auto parent_block = use_instruction->GetSingleWordInOperand(use_input_operand_index + 1); return dominator_analysis->Dominates( context->get_instr_block(defining_instruction)->id(), parent_block); } return dominator_analysis->Dominates(defining_instruction, use_instruction); } bool IdIsAvailableBeforeInstruction(opt::IRContext* context, opt::Instruction* instruction, uint32_t id) { assert(context->get_instr_block(instruction) && "|instruction| must be in a basic block"); auto id_definition = context->get_def_use_mgr()->GetDef(id); auto function_enclosing_instruction = context->get_instr_block(instruction)->GetParent(); // If the id a function parameter, it needs to be associated with the // function containing the instruction. if (id_definition->opcode() == spv::Op::OpFunctionParameter) { return InstructionIsFunctionParameter(id_definition, function_enclosing_instruction); } if (!context->get_instr_block(id)) { // The id is at global scope. return true; } if (id_definition == instruction) { // The instruction is not available right before its own definition. return false; } const auto* dominator_analysis = context->GetDominatorAnalysis(function_enclosing_instruction); if (context->IsReachable(*context->get_instr_block(instruction)) && context->IsReachable(*context->get_instr_block(id)) && dominator_analysis->Dominates(id_definition, instruction)) { // The id's definition dominates the instruction, and both the definition // and the instruction are in reachable blocks, thus the id is available at // the instruction. return true; } if (id_definition->opcode() == spv::Op::OpVariable && function_enclosing_instruction == context->get_instr_block(id)->GetParent()) { assert(!context->IsReachable(*context->get_instr_block(instruction)) && "If the instruction were in a reachable block we should already " "have returned true."); // The id is a variable and it is in the same function as |instruction|. // This is OK despite |instruction| being unreachable. return true; } return false; } bool InstructionIsFunctionParameter(opt::Instruction* instruction, opt::Function* function) { if (instruction->opcode() != spv::Op::OpFunctionParameter) { return false; } bool found_parameter = false; function->ForEachParam( [instruction, &found_parameter](opt::Instruction* param) { if (param == instruction) { found_parameter = true; } }); return found_parameter; } uint32_t GetTypeId(opt::IRContext* context, uint32_t result_id) { const auto* inst = context->get_def_use_mgr()->GetDef(result_id); assert(inst && "|result_id| is invalid"); return inst->type_id(); } uint32_t GetPointeeTypeIdFromPointerType(opt::Instruction* pointer_type_inst) { assert(pointer_type_inst && pointer_type_inst->opcode() == spv::Op::OpTypePointer && "Precondition: |pointer_type_inst| must be OpTypePointer."); return pointer_type_inst->GetSingleWordInOperand(1); } uint32_t GetPointeeTypeIdFromPointerType(opt::IRContext* context, uint32_t pointer_type_id) { return GetPointeeTypeIdFromPointerType( context->get_def_use_mgr()->GetDef(pointer_type_id)); } spv::StorageClass GetStorageClassFromPointerType( opt::Instruction* pointer_type_inst) { assert(pointer_type_inst && pointer_type_inst->opcode() == spv::Op::OpTypePointer && "Precondition: |pointer_type_inst| must be OpTypePointer."); return static_cast( pointer_type_inst->GetSingleWordInOperand(0)); } spv::StorageClass GetStorageClassFromPointerType(opt::IRContext* context, uint32_t pointer_type_id) { return GetStorageClassFromPointerType( context->get_def_use_mgr()->GetDef(pointer_type_id)); } uint32_t MaybeGetPointerType(opt::IRContext* context, uint32_t pointee_type_id, spv::StorageClass storage_class) { for (auto& inst : context->types_values()) { switch (inst.opcode()) { case spv::Op::OpTypePointer: if (spv::StorageClass(inst.GetSingleWordInOperand(0)) == storage_class && inst.GetSingleWordInOperand(1) == pointee_type_id) { return inst.result_id(); } break; default: break; } } return 0; } uint32_t InOperandIndexFromOperandIndex(const opt::Instruction& inst, uint32_t absolute_index) { // Subtract the number of non-input operands from the index return absolute_index - inst.NumOperands() + inst.NumInOperands(); } bool IsNullConstantSupported(opt::IRContext* ir_context, const opt::Instruction& type_inst) { switch (type_inst.opcode()) { case spv::Op::OpTypeArray: case spv::Op::OpTypeBool: case spv::Op::OpTypeDeviceEvent: case spv::Op::OpTypeEvent: case spv::Op::OpTypeFloat: case spv::Op::OpTypeInt: case spv::Op::OpTypeMatrix: case spv::Op::OpTypeQueue: case spv::Op::OpTypeReserveId: case spv::Op::OpTypeVector: case spv::Op::OpTypeStruct: return true; case spv::Op::OpTypePointer: // Null pointers are allowed if the VariablePointers capability is // enabled, or if the VariablePointersStorageBuffer capability is enabled // and the pointer type has StorageBuffer as its storage class. if (ir_context->get_feature_mgr()->HasCapability( spv::Capability::VariablePointers)) { return true; } if (ir_context->get_feature_mgr()->HasCapability( spv::Capability::VariablePointersStorageBuffer)) { return spv::StorageClass(type_inst.GetSingleWordInOperand(0)) == spv::StorageClass::StorageBuffer; } return false; default: return false; } } bool GlobalVariablesMustBeDeclaredInEntryPointInterfaces( const opt::IRContext* ir_context) { // TODO(afd): We capture the environments for which this requirement holds. // The check should be refined on demand for other target environments. switch (ir_context->grammar().target_env()) { case SPV_ENV_UNIVERSAL_1_0: case SPV_ENV_UNIVERSAL_1_1: case SPV_ENV_UNIVERSAL_1_2: case SPV_ENV_UNIVERSAL_1_3: case SPV_ENV_VULKAN_1_0: case SPV_ENV_VULKAN_1_1: return false; default: return true; } } void AddVariableIdToEntryPointInterfaces(opt::IRContext* context, uint32_t id) { if (GlobalVariablesMustBeDeclaredInEntryPointInterfaces(context)) { // Conservatively add this global to the interface of every entry point in // the module. This means that the global is available for other // transformations to use. // // A downside of this is that the global will be in the interface even if it // ends up never being used. // // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/3111) revisit // this if a more thorough approach to entry point interfaces is taken. for (auto& entry_point : context->module()->entry_points()) { entry_point.AddOperand({SPV_OPERAND_TYPE_ID, {id}}); } } } opt::Instruction* AddGlobalVariable(opt::IRContext* context, uint32_t result_id, uint32_t type_id, spv::StorageClass storage_class, uint32_t initializer_id) { // Check various preconditions. assert(result_id != 0 && "Result id can't be 0"); assert((storage_class == spv::StorageClass::Private || storage_class == spv::StorageClass::Workgroup) && "Variable's storage class must be either Private or Workgroup"); auto* type_inst = context->get_def_use_mgr()->GetDef(type_id); (void)type_inst; // Variable becomes unused in release mode. assert(type_inst && type_inst->opcode() == spv::Op::OpTypePointer && GetStorageClassFromPointerType(type_inst) == storage_class && "Variable's type is invalid"); if (storage_class == spv::StorageClass::Workgroup) { assert(initializer_id == 0); } if (initializer_id != 0) { const auto* constant_inst = context->get_def_use_mgr()->GetDef(initializer_id); (void)constant_inst; // Variable becomes unused in release mode. assert(constant_inst && spvOpcodeIsConstant(constant_inst->opcode()) && GetPointeeTypeIdFromPointerType(type_inst) == constant_inst->type_id() && "Initializer is invalid"); } opt::Instruction::OperandList operands = { {SPV_OPERAND_TYPE_STORAGE_CLASS, {static_cast(storage_class)}}}; if (initializer_id) { operands.push_back({SPV_OPERAND_TYPE_ID, {initializer_id}}); } auto new_instruction = MakeUnique( context, spv::Op::OpVariable, type_id, result_id, std::move(operands)); auto result = new_instruction.get(); context->module()->AddGlobalValue(std::move(new_instruction)); AddVariableIdToEntryPointInterfaces(context, result_id); UpdateModuleIdBound(context, result_id); return result; } opt::Instruction* AddLocalVariable(opt::IRContext* context, uint32_t result_id, uint32_t type_id, uint32_t function_id, uint32_t initializer_id) { // Check various preconditions. assert(result_id != 0 && "Result id can't be 0"); auto* type_inst = context->get_def_use_mgr()->GetDef(type_id); (void)type_inst; // Variable becomes unused in release mode. assert(type_inst && type_inst->opcode() == spv::Op::OpTypePointer && GetStorageClassFromPointerType(type_inst) == spv::StorageClass::Function && "Variable's type is invalid"); const auto* constant_inst = context->get_def_use_mgr()->GetDef(initializer_id); (void)constant_inst; // Variable becomes unused in release mode. assert(constant_inst && spvOpcodeIsConstant(constant_inst->opcode()) && GetPointeeTypeIdFromPointerType(type_inst) == constant_inst->type_id() && "Initializer is invalid"); auto* function = FindFunction(context, function_id); assert(function && "Function id is invalid"); auto new_instruction = MakeUnique( context, spv::Op::OpVariable, type_id, result_id, opt::Instruction::OperandList{{SPV_OPERAND_TYPE_STORAGE_CLASS, {uint32_t(spv::StorageClass::Function)}}, {SPV_OPERAND_TYPE_ID, {initializer_id}}}); auto result = new_instruction.get(); function->begin()->begin()->InsertBefore(std::move(new_instruction)); UpdateModuleIdBound(context, result_id); return result; } bool HasDuplicates(const std::vector& arr) { return std::unordered_set(arr.begin(), arr.end()).size() != arr.size(); } bool IsPermutationOfRange(const std::vector& arr, uint32_t lo, uint32_t hi) { if (arr.empty()) { return lo > hi; } if (HasDuplicates(arr)) { return false; } auto min_max = std::minmax_element(arr.begin(), arr.end()); return arr.size() == hi - lo + 1 && *min_max.first == lo && *min_max.second == hi; } std::vector GetParameters(opt::IRContext* ir_context, uint32_t function_id) { auto* function = FindFunction(ir_context, function_id); assert(function && "|function_id| is invalid"); std::vector result; function->ForEachParam( [&result](opt::Instruction* inst) { result.push_back(inst); }); return result; } void RemoveParameter(opt::IRContext* ir_context, uint32_t parameter_id) { auto* function = GetFunctionFromParameterId(ir_context, parameter_id); assert(function && "|parameter_id| is invalid"); assert(!FunctionIsEntryPoint(ir_context, function->result_id()) && "Can't remove parameter from an entry point function"); function->RemoveParameter(parameter_id); // We've just removed parameters from the function and cleared their memory. // Make sure analyses have no dangling pointers. ir_context->InvalidateAnalysesExceptFor( opt::IRContext::Analysis::kAnalysisNone); } std::vector GetCallers(opt::IRContext* ir_context, uint32_t function_id) { assert(FindFunction(ir_context, function_id) && "|function_id| is not a result id of a function"); std::vector result; ir_context->get_def_use_mgr()->ForEachUser( function_id, [&result, function_id](opt::Instruction* inst) { if (inst->opcode() == spv::Op::OpFunctionCall && inst->GetSingleWordInOperand(0) == function_id) { result.push_back(inst); } }); return result; } opt::Function* GetFunctionFromParameterId(opt::IRContext* ir_context, uint32_t param_id) { auto* param_inst = ir_context->get_def_use_mgr()->GetDef(param_id); assert(param_inst && "Parameter id is invalid"); for (auto& function : *ir_context->module()) { if (InstructionIsFunctionParameter(param_inst, &function)) { return &function; } } return nullptr; } uint32_t UpdateFunctionType(opt::IRContext* ir_context, uint32_t function_id, uint32_t new_function_type_result_id, uint32_t return_type_id, const std::vector& parameter_type_ids) { // Check some initial constraints. assert(ir_context->get_type_mgr()->GetType(return_type_id) && "Return type is invalid"); for (auto id : parameter_type_ids) { const auto* type = ir_context->get_type_mgr()->GetType(id); (void)type; // Make compilers happy in release mode. // Parameters can't be OpTypeVoid. assert(type && !type->AsVoid() && "Parameter has invalid type"); } auto* function = FindFunction(ir_context, function_id); assert(function && "|function_id| is invalid"); auto* old_function_type = GetFunctionType(ir_context, function); assert(old_function_type && "Function has invalid type"); std::vector operand_ids = {return_type_id}; operand_ids.insert(operand_ids.end(), parameter_type_ids.begin(), parameter_type_ids.end()); // A trivial case - we change nothing. if (FindFunctionType(ir_context, operand_ids) == old_function_type->result_id()) { return old_function_type->result_id(); } if (ir_context->get_def_use_mgr()->NumUsers(old_function_type) == 1 && FindFunctionType(ir_context, operand_ids) == 0) { // We can change |old_function_type| only if it's used once in the module // and we are certain we won't create a duplicate as a result of the change. // Update |old_function_type| in-place. opt::Instruction::OperandList operands; for (auto id : operand_ids) { operands.push_back({SPV_OPERAND_TYPE_ID, {id}}); } old_function_type->SetInOperands(std::move(operands)); // |operands| may depend on result ids defined below the |old_function_type| // in the module. old_function_type->RemoveFromList(); ir_context->AddType(std::unique_ptr(old_function_type)); return old_function_type->result_id(); } else { // We can't modify the |old_function_type| so we have to either use an // existing one or create a new one. auto type_id = FindOrCreateFunctionType( ir_context, new_function_type_result_id, operand_ids); assert(type_id != old_function_type->result_id() && "We should've handled this case above"); function->DefInst().SetInOperand(1, {type_id}); // DefUseManager hasn't been updated yet, so if the following condition is // true, then |old_function_type| will have no users when this function // returns. We might as well remove it. if (ir_context->get_def_use_mgr()->NumUsers(old_function_type) == 1) { ir_context->KillInst(old_function_type); } return type_id; } } void AddFunctionType(opt::IRContext* ir_context, uint32_t result_id, const std::vector& type_ids) { assert(result_id != 0 && "Result id can't be 0"); assert(!type_ids.empty() && "OpTypeFunction always has at least one operand - function's return " "type"); assert(IsNonFunctionTypeId(ir_context, type_ids[0]) && "Return type must not be a function"); for (size_t i = 1; i < type_ids.size(); ++i) { const auto* param_type = ir_context->get_type_mgr()->GetType(type_ids[i]); (void)param_type; // Make compiler happy in release mode. assert(param_type && !param_type->AsVoid() && !param_type->AsFunction() && "Function parameter can't have a function or void type"); } opt::Instruction::OperandList operands; operands.reserve(type_ids.size()); for (auto id : type_ids) { operands.push_back({SPV_OPERAND_TYPE_ID, {id}}); } ir_context->AddType(MakeUnique( ir_context, spv::Op::OpTypeFunction, 0, result_id, std::move(operands))); UpdateModuleIdBound(ir_context, result_id); } uint32_t FindOrCreateFunctionType(opt::IRContext* ir_context, uint32_t result_id, const std::vector& type_ids) { if (auto existing_id = FindFunctionType(ir_context, type_ids)) { return existing_id; } AddFunctionType(ir_context, result_id, type_ids); return result_id; } uint32_t MaybeGetIntegerType(opt::IRContext* ir_context, uint32_t width, bool is_signed) { opt::analysis::Integer type(width, is_signed); return ir_context->get_type_mgr()->GetId(&type); } uint32_t MaybeGetFloatType(opt::IRContext* ir_context, uint32_t width) { opt::analysis::Float type(width); return ir_context->get_type_mgr()->GetId(&type); } uint32_t MaybeGetBoolType(opt::IRContext* ir_context) { opt::analysis::Bool type; return ir_context->get_type_mgr()->GetId(&type); } uint32_t MaybeGetVectorType(opt::IRContext* ir_context, uint32_t component_type_id, uint32_t element_count) { const auto* component_type = ir_context->get_type_mgr()->GetType(component_type_id); assert(component_type && (component_type->AsInteger() || component_type->AsFloat() || component_type->AsBool()) && "|component_type_id| is invalid"); assert(element_count >= 2 && element_count <= 4 && "Precondition: component count must be in range [2, 4]."); opt::analysis::Vector type(component_type, element_count); return ir_context->get_type_mgr()->GetId(&type); } uint32_t MaybeGetStructType(opt::IRContext* ir_context, const std::vector& component_type_ids) { for (auto& type_or_value : ir_context->types_values()) { if (type_or_value.opcode() != spv::Op::OpTypeStruct || type_or_value.NumInOperands() != static_cast(component_type_ids.size())) { continue; } bool all_components_match = true; for (uint32_t i = 0; i < component_type_ids.size(); i++) { if (type_or_value.GetSingleWordInOperand(i) != component_type_ids[i]) { all_components_match = false; break; } } if (all_components_match) { return type_or_value.result_id(); } } return 0; } uint32_t MaybeGetVoidType(opt::IRContext* ir_context) { opt::analysis::Void type; return ir_context->get_type_mgr()->GetId(&type); } uint32_t MaybeGetZeroConstant( opt::IRContext* ir_context, const TransformationContext& transformation_context, uint32_t scalar_or_composite_type_id, bool is_irrelevant) { const auto* type_inst = ir_context->get_def_use_mgr()->GetDef(scalar_or_composite_type_id); assert(type_inst && "|scalar_or_composite_type_id| is invalid"); switch (type_inst->opcode()) { case spv::Op::OpTypeBool: return MaybeGetBoolConstant(ir_context, transformation_context, false, is_irrelevant); case spv::Op::OpTypeFloat: case spv::Op::OpTypeInt: { const auto width = type_inst->GetSingleWordInOperand(0); std::vector words = {0}; if (width > 32) { words.push_back(0); } return MaybeGetScalarConstant(ir_context, transformation_context, words, scalar_or_composite_type_id, is_irrelevant); } case spv::Op::OpTypeStruct: { std::vector component_ids; for (uint32_t i = 0; i < type_inst->NumInOperands(); ++i) { const auto component_type_id = type_inst->GetSingleWordInOperand(i); auto component_id = MaybeGetZeroConstant(ir_context, transformation_context, component_type_id, is_irrelevant); if (component_id == 0 && is_irrelevant) { // Irrelevant constants can use either relevant or irrelevant // constituents. component_id = MaybeGetZeroConstant( ir_context, transformation_context, component_type_id, false); } if (component_id == 0) { return 0; } component_ids.push_back(component_id); } return MaybeGetCompositeConstant( ir_context, transformation_context, component_ids, scalar_or_composite_type_id, is_irrelevant); } case spv::Op::OpTypeMatrix: case spv::Op::OpTypeVector: { const auto component_type_id = type_inst->GetSingleWordInOperand(0); auto component_id = MaybeGetZeroConstant( ir_context, transformation_context, component_type_id, is_irrelevant); if (component_id == 0 && is_irrelevant) { // Irrelevant constants can use either relevant or irrelevant // constituents. component_id = MaybeGetZeroConstant(ir_context, transformation_context, component_type_id, false); } if (component_id == 0) { return 0; } const auto component_count = type_inst->GetSingleWordInOperand(1); return MaybeGetCompositeConstant( ir_context, transformation_context, std::vector(component_count, component_id), scalar_or_composite_type_id, is_irrelevant); } case spv::Op::OpTypeArray: { const auto component_type_id = type_inst->GetSingleWordInOperand(0); auto component_id = MaybeGetZeroConstant( ir_context, transformation_context, component_type_id, is_irrelevant); if (component_id == 0 && is_irrelevant) { // Irrelevant constants can use either relevant or irrelevant // constituents. component_id = MaybeGetZeroConstant(ir_context, transformation_context, component_type_id, false); } if (component_id == 0) { return 0; } return MaybeGetCompositeConstant( ir_context, transformation_context, std::vector(GetArraySize(*type_inst, ir_context), component_id), scalar_or_composite_type_id, is_irrelevant); } default: assert(false && "Type is not supported"); return 0; } } bool CanCreateConstant(opt::IRContext* ir_context, uint32_t type_id) { opt::Instruction* type_instr = ir_context->get_def_use_mgr()->GetDef(type_id); assert(type_instr != nullptr && "The type must exist."); assert(spvOpcodeGeneratesType(type_instr->opcode()) && "A type-generating opcode was expected."); switch (type_instr->opcode()) { case spv::Op::OpTypeBool: case spv::Op::OpTypeInt: case spv::Op::OpTypeFloat: case spv::Op::OpTypeMatrix: case spv::Op::OpTypeVector: return true; case spv::Op::OpTypeArray: return CanCreateConstant(ir_context, type_instr->GetSingleWordInOperand(0)); case spv::Op::OpTypeStruct: if (HasBlockOrBufferBlockDecoration(ir_context, type_id)) { return false; } for (uint32_t index = 0; index < type_instr->NumInOperands(); index++) { if (!CanCreateConstant(ir_context, type_instr->GetSingleWordInOperand(index))) { return false; } } return true; default: return false; } } uint32_t MaybeGetScalarConstant( opt::IRContext* ir_context, const TransformationContext& transformation_context, const std::vector& words, uint32_t scalar_type_id, bool is_irrelevant) { const auto* type = ir_context->get_type_mgr()->GetType(scalar_type_id); assert(type && "|scalar_type_id| is invalid"); if (const auto* int_type = type->AsInteger()) { return MaybeGetIntegerConstant(ir_context, transformation_context, words, int_type->width(), int_type->IsSigned(), is_irrelevant); } else if (const auto* float_type = type->AsFloat()) { return MaybeGetFloatConstant(ir_context, transformation_context, words, float_type->width(), is_irrelevant); } else { assert(type->AsBool() && words.size() == 1 && "|scalar_type_id| doesn't represent a scalar type"); return MaybeGetBoolConstant(ir_context, transformation_context, words[0], is_irrelevant); } } uint32_t MaybeGetCompositeConstant( opt::IRContext* ir_context, const TransformationContext& transformation_context, const std::vector& component_ids, uint32_t composite_type_id, bool is_irrelevant) { const auto* type = ir_context->get_type_mgr()->GetType(composite_type_id); (void)type; // Make compilers happy in release mode. assert(IsCompositeType(type) && "|composite_type_id| is invalid"); for (const auto& inst : ir_context->types_values()) { if (inst.opcode() == spv::Op::OpConstantComposite && inst.type_id() == composite_type_id && transformation_context.GetFactManager()->IdIsIrrelevant( inst.result_id()) == is_irrelevant && inst.NumInOperands() == component_ids.size()) { bool is_match = true; for (uint32_t i = 0; i < inst.NumInOperands(); ++i) { if (inst.GetSingleWordInOperand(i) != component_ids[i]) { is_match = false; break; } } if (is_match) { return inst.result_id(); } } } return 0; } uint32_t MaybeGetIntegerConstant( opt::IRContext* ir_context, const TransformationContext& transformation_context, const std::vector& words, uint32_t width, bool is_signed, bool is_irrelevant) { if (auto type_id = MaybeGetIntegerType(ir_context, width, is_signed)) { return MaybeGetOpConstant(ir_context, transformation_context, words, type_id, is_irrelevant); } return 0; } uint32_t MaybeGetIntegerConstantFromValueAndType(opt::IRContext* ir_context, uint32_t value, uint32_t int_type_id) { auto int_type_inst = ir_context->get_def_use_mgr()->GetDef(int_type_id); assert(int_type_inst && "The given type id must exist."); auto int_type = ir_context->get_type_mgr() ->GetType(int_type_inst->result_id()) ->AsInteger(); assert(int_type && int_type->width() == 32 && "The given type id must correspond to an 32-bit integer type."); opt::analysis::IntConstant constant(int_type, {value}); // Check that the constant exists in the module. if (!ir_context->get_constant_mgr()->FindConstant(&constant)) { return 0; } return ir_context->get_constant_mgr() ->GetDefiningInstruction(&constant) ->result_id(); } uint32_t MaybeGetFloatConstant( opt::IRContext* ir_context, const TransformationContext& transformation_context, const std::vector& words, uint32_t width, bool is_irrelevant) { if (auto type_id = MaybeGetFloatType(ir_context, width)) { return MaybeGetOpConstant(ir_context, transformation_context, words, type_id, is_irrelevant); } return 0; } uint32_t MaybeGetBoolConstant( opt::IRContext* ir_context, const TransformationContext& transformation_context, bool value, bool is_irrelevant) { if (auto type_id = MaybeGetBoolType(ir_context)) { for (const auto& inst : ir_context->types_values()) { if (inst.opcode() == (value ? spv::Op::OpConstantTrue : spv::Op::OpConstantFalse) && inst.type_id() == type_id && transformation_context.GetFactManager()->IdIsIrrelevant( inst.result_id()) == is_irrelevant) { return inst.result_id(); } } } return 0; } std::vector IntToWords(uint64_t value, uint32_t width, bool is_signed) { assert(width <= 64 && "The bit width should not be more than 64 bits"); // Sign-extend or zero-extend the last |width| bits of |value|, depending on // |is_signed|. if (is_signed) { // Sign-extend by shifting left and then shifting right, interpreting the // integer as signed. value = static_cast(value << (64 - width)) >> (64 - width); } else { // Zero-extend by shifting left and then shifting right, interpreting the // integer as unsigned. value = (value << (64 - width)) >> (64 - width); } std::vector result; result.push_back(static_cast(value)); if (width > 32) { result.push_back(static_cast(value >> 32)); } return result; } bool TypesAreEqualUpToSign(opt::IRContext* ir_context, uint32_t type1_id, uint32_t type2_id) { if (type1_id == type2_id) { return true; } auto type1 = ir_context->get_type_mgr()->GetType(type1_id); auto type2 = ir_context->get_type_mgr()->GetType(type2_id); // Integer scalar types must have the same width if (type1->AsInteger() && type2->AsInteger()) { return type1->AsInteger()->width() == type2->AsInteger()->width(); } // Integer vector types must have the same number of components and their // component types must be integers with the same width. if (type1->AsVector() && type2->AsVector()) { auto component_type1 = type1->AsVector()->element_type()->AsInteger(); auto component_type2 = type2->AsVector()->element_type()->AsInteger(); // Only check the component count and width if they are integer. if (component_type1 && component_type2) { return type1->AsVector()->element_count() == type2->AsVector()->element_count() && component_type1->width() == component_type2->width(); } } // In all other cases, the types cannot be considered equal. return false; } std::map RepeatedUInt32PairToMap( const google::protobuf::RepeatedPtrField& data) { std::map result; for (const auto& entry : data) { result[entry.first()] = entry.second(); } return result; } google::protobuf::RepeatedPtrField MapToRepeatedUInt32Pair(const std::map& data) { google::protobuf::RepeatedPtrField result; for (const auto& entry : data) { protobufs::UInt32Pair pair; pair.set_first(entry.first); pair.set_second(entry.second); *result.Add() = std::move(pair); } return result; } opt::Instruction* GetLastInsertBeforeInstruction(opt::IRContext* ir_context, uint32_t block_id, spv::Op opcode) { // CFG::block uses std::map::at which throws an exception when |block_id| is // invalid. The error message is unhelpful, though. Thus, we test that // |block_id| is valid here. const auto* label_inst = ir_context->get_def_use_mgr()->GetDef(block_id); (void)label_inst; // Make compilers happy in release mode. assert(label_inst && label_inst->opcode() == spv::Op::OpLabel && "|block_id| is invalid"); auto* block = ir_context->cfg()->block(block_id); auto it = block->rbegin(); assert(it != block->rend() && "Basic block can't be empty"); if (block->GetMergeInst()) { ++it; assert(it != block->rend() && "|block| must have at least two instructions:" "terminator and a merge instruction"); } return CanInsertOpcodeBeforeInstruction(opcode, &*it) ? &*it : nullptr; } bool IdUseCanBeReplaced(opt::IRContext* ir_context, const TransformationContext& transformation_context, opt::Instruction* use_instruction, uint32_t use_in_operand_index) { if (spvOpcodeIsAccessChain(use_instruction->opcode()) && use_in_operand_index > 0) { // A replacement for an irrelevant index in OpAccessChain must be clamped // first. if (transformation_context.GetFactManager()->IdIsIrrelevant( use_instruction->GetSingleWordInOperand(use_in_operand_index))) { return false; } // This is an access chain index. If the (sub-)object being accessed by the // given index has struct type then we cannot replace the use, as it needs // to be an OpConstant. // Get the top-level composite type that is being accessed. auto object_being_accessed = ir_context->get_def_use_mgr()->GetDef( use_instruction->GetSingleWordInOperand(0)); auto pointer_type = ir_context->get_type_mgr()->GetType(object_being_accessed->type_id()); assert(pointer_type->AsPointer()); auto composite_type_being_accessed = pointer_type->AsPointer()->pointee_type(); // Now walk the access chain, tracking the type of each sub-object of the // composite that is traversed, until the index of interest is reached. for (uint32_t index_in_operand = 1; index_in_operand < use_in_operand_index; index_in_operand++) { // For vectors, matrices and arrays, getting the type of the sub-object is // trivial. For the struct case, the sub-object type is field-sensitive, // and depends on the constant index that is used. if (composite_type_being_accessed->AsVector()) { composite_type_being_accessed = composite_type_being_accessed->AsVector()->element_type(); } else if (composite_type_being_accessed->AsMatrix()) { composite_type_being_accessed = composite_type_being_accessed->AsMatrix()->element_type(); } else if (composite_type_being_accessed->AsArray()) { composite_type_being_accessed = composite_type_being_accessed->AsArray()->element_type(); } else if (composite_type_being_accessed->AsRuntimeArray()) { composite_type_being_accessed = composite_type_being_accessed->AsRuntimeArray()->element_type(); } else { assert(composite_type_being_accessed->AsStruct()); auto constant_index_instruction = ir_context->get_def_use_mgr()->GetDef( use_instruction->GetSingleWordInOperand(index_in_operand)); assert(constant_index_instruction->opcode() == spv::Op::OpConstant); uint32_t member_index = constant_index_instruction->GetSingleWordInOperand(0); composite_type_being_accessed = composite_type_being_accessed->AsStruct() ->element_types()[member_index]; } } // We have found the composite type being accessed by the index we are // considering replacing. If it is a struct, then we cannot do the // replacement as struct indices must be constants. if (composite_type_being_accessed->AsStruct()) { return false; } } if (use_instruction->opcode() == spv::Op::OpFunctionCall && use_in_operand_index > 0) { // This is a function call argument. It is not allowed to have pointer // type. // Get the definition of the function being called. auto function = ir_context->get_def_use_mgr()->GetDef( use_instruction->GetSingleWordInOperand(0)); // From the function definition, get the function type. auto function_type = ir_context->get_def_use_mgr()->GetDef( function->GetSingleWordInOperand(1)); // OpTypeFunction's 0-th input operand is the function return type, and the // function argument types follow. Because the arguments to OpFunctionCall // start from input operand 1, we can use |use_in_operand_index| to get the // type associated with this function argument. auto parameter_type = ir_context->get_type_mgr()->GetType( function_type->GetSingleWordInOperand(use_in_operand_index)); if (parameter_type->AsPointer()) { return false; } } if (use_instruction->opcode() == spv::Op::OpImageTexelPointer && use_in_operand_index == 2) { // The OpImageTexelPointer instruction has a Sample parameter that in some // situations must be an id for the value 0. To guard against disrupting // that requirement, we do not replace this argument to that instruction. return false; } if (ir_context->get_feature_mgr()->HasCapability(spv::Capability::Shader)) { // With the Shader capability, memory scope and memory semantics operands // are required to be constants, so they cannot be replaced arbitrarily. switch (use_instruction->opcode()) { case spv::Op::OpAtomicLoad: case spv::Op::OpAtomicStore: case spv::Op::OpAtomicExchange: case spv::Op::OpAtomicIIncrement: case spv::Op::OpAtomicIDecrement: case spv::Op::OpAtomicIAdd: case spv::Op::OpAtomicISub: case spv::Op::OpAtomicSMin: case spv::Op::OpAtomicUMin: case spv::Op::OpAtomicSMax: case spv::Op::OpAtomicUMax: case spv::Op::OpAtomicAnd: case spv::Op::OpAtomicOr: case spv::Op::OpAtomicXor: if (use_in_operand_index == 1 || use_in_operand_index == 2) { return false; } break; case spv::Op::OpAtomicCompareExchange: if (use_in_operand_index == 1 || use_in_operand_index == 2 || use_in_operand_index == 3) { return false; } break; case spv::Op::OpAtomicCompareExchangeWeak: case spv::Op::OpAtomicFlagTestAndSet: case spv::Op::OpAtomicFlagClear: case spv::Op::OpAtomicFAddEXT: assert(false && "Not allowed with the Shader capability."); default: break; } } return true; } bool MembersHaveBuiltInDecoration(opt::IRContext* ir_context, uint32_t struct_type_id) { const auto* type_inst = ir_context->get_def_use_mgr()->GetDef(struct_type_id); assert(type_inst && type_inst->opcode() == spv::Op::OpTypeStruct && "|struct_type_id| is not a result id of an OpTypeStruct"); uint32_t builtin_count = 0; ir_context->get_def_use_mgr()->ForEachUser( type_inst, [struct_type_id, &builtin_count](const opt::Instruction* user) { if (user->opcode() == spv::Op::OpMemberDecorate && user->GetSingleWordInOperand(0) == struct_type_id && static_cast(user->GetSingleWordInOperand(2)) == spv::Decoration::BuiltIn) { ++builtin_count; } }); assert((builtin_count == 0 || builtin_count == type_inst->NumInOperands()) && "The module is invalid: either none or all of the members of " "|struct_type_id| may be builtin"); return builtin_count != 0; } bool HasBlockOrBufferBlockDecoration(opt::IRContext* ir_context, uint32_t id) { for (auto decoration : {spv::Decoration::Block, spv::Decoration::BufferBlock}) { if (!ir_context->get_decoration_mgr()->WhileEachDecoration( id, uint32_t(decoration), [](const opt::Instruction & /*unused*/) -> bool { return false; })) { return true; } } return false; } bool SplittingBeforeInstructionSeparatesOpSampledImageDefinitionFromUse( opt::BasicBlock* block_to_split, opt::Instruction* split_before) { std::set sampled_image_result_ids; bool before_split = true; // Check all the instructions in the block to split. for (auto& instruction : *block_to_split) { if (&instruction == &*split_before) { before_split = false; } if (before_split) { // If the instruction comes before the split and its opcode is // OpSampledImage, record its result id. if (instruction.opcode() == spv::Op::OpSampledImage) { sampled_image_result_ids.insert(instruction.result_id()); } } else { // If the instruction comes after the split, check if ids // corresponding to OpSampledImage instructions defined before the split // are used, and return true if they are. if (!instruction.WhileEachInId( [&sampled_image_result_ids](uint32_t* id) -> bool { return !sampled_image_result_ids.count(*id); })) { return true; } } } // No usage that would be separated from the definition has been found. return false; } bool InstructionHasNoSideEffects(const opt::Instruction& instruction) { switch (instruction.opcode()) { case spv::Op::OpUndef: case spv::Op::OpAccessChain: case spv::Op::OpInBoundsAccessChain: case spv::Op::OpArrayLength: case spv::Op::OpVectorExtractDynamic: case spv::Op::OpVectorInsertDynamic: case spv::Op::OpVectorShuffle: case spv::Op::OpCompositeConstruct: case spv::Op::OpCompositeExtract: case spv::Op::OpCompositeInsert: case spv::Op::OpCopyObject: case spv::Op::OpTranspose: case spv::Op::OpConvertFToU: case spv::Op::OpConvertFToS: case spv::Op::OpConvertSToF: case spv::Op::OpConvertUToF: case spv::Op::OpUConvert: case spv::Op::OpSConvert: case spv::Op::OpFConvert: case spv::Op::OpQuantizeToF16: case spv::Op::OpSatConvertSToU: case spv::Op::OpSatConvertUToS: case spv::Op::OpBitcast: case spv::Op::OpSNegate: case spv::Op::OpFNegate: case spv::Op::OpIAdd: case spv::Op::OpFAdd: case spv::Op::OpISub: case spv::Op::OpFSub: case spv::Op::OpIMul: case spv::Op::OpFMul: case spv::Op::OpUDiv: case spv::Op::OpSDiv: case spv::Op::OpFDiv: case spv::Op::OpUMod: case spv::Op::OpSRem: case spv::Op::OpSMod: case spv::Op::OpFRem: case spv::Op::OpFMod: case spv::Op::OpVectorTimesScalar: case spv::Op::OpMatrixTimesScalar: case spv::Op::OpVectorTimesMatrix: case spv::Op::OpMatrixTimesVector: case spv::Op::OpMatrixTimesMatrix: case spv::Op::OpOuterProduct: case spv::Op::OpDot: case spv::Op::OpIAddCarry: case spv::Op::OpISubBorrow: case spv::Op::OpUMulExtended: case spv::Op::OpSMulExtended: case spv::Op::OpAny: case spv::Op::OpAll: case spv::Op::OpIsNan: case spv::Op::OpIsInf: case spv::Op::OpIsFinite: case spv::Op::OpIsNormal: case spv::Op::OpSignBitSet: case spv::Op::OpLessOrGreater: case spv::Op::OpOrdered: case spv::Op::OpUnordered: case spv::Op::OpLogicalEqual: case spv::Op::OpLogicalNotEqual: case spv::Op::OpLogicalOr: case spv::Op::OpLogicalAnd: case spv::Op::OpLogicalNot: case spv::Op::OpSelect: case spv::Op::OpIEqual: case spv::Op::OpINotEqual: case spv::Op::OpUGreaterThan: case spv::Op::OpSGreaterThan: case spv::Op::OpUGreaterThanEqual: case spv::Op::OpSGreaterThanEqual: case spv::Op::OpULessThan: case spv::Op::OpSLessThan: case spv::Op::OpULessThanEqual: case spv::Op::OpSLessThanEqual: case spv::Op::OpFOrdEqual: case spv::Op::OpFUnordEqual: case spv::Op::OpFOrdNotEqual: case spv::Op::OpFUnordNotEqual: case spv::Op::OpFOrdLessThan: case spv::Op::OpFUnordLessThan: case spv::Op::OpFOrdGreaterThan: case spv::Op::OpFUnordGreaterThan: case spv::Op::OpFOrdLessThanEqual: case spv::Op::OpFUnordLessThanEqual: case spv::Op::OpFOrdGreaterThanEqual: case spv::Op::OpFUnordGreaterThanEqual: case spv::Op::OpShiftRightLogical: case spv::Op::OpShiftRightArithmetic: case spv::Op::OpShiftLeftLogical: case spv::Op::OpBitwiseOr: case spv::Op::OpBitwiseXor: case spv::Op::OpBitwiseAnd: case spv::Op::OpNot: case spv::Op::OpBitFieldInsert: case spv::Op::OpBitFieldSExtract: case spv::Op::OpBitFieldUExtract: case spv::Op::OpBitReverse: case spv::Op::OpBitCount: case spv::Op::OpCopyLogical: case spv::Op::OpPhi: case spv::Op::OpPtrEqual: case spv::Op::OpPtrNotEqual: return true; default: return false; } } std::set GetReachableReturnBlocks(opt::IRContext* ir_context, uint32_t function_id) { auto function = ir_context->GetFunction(function_id); assert(function && "The function |function_id| must exist."); std::set result; ir_context->cfg()->ForEachBlockInPostOrder(function->entry().get(), [&result](opt::BasicBlock* block) { if (block->IsReturn()) { result.emplace(block->id()); } }); return result; } bool NewTerminatorPreservesDominationRules(opt::IRContext* ir_context, uint32_t block_id, opt::Instruction new_terminator) { auto* mutated_block = MaybeFindBlock(ir_context, block_id); assert(mutated_block && "|block_id| is invalid"); ChangeTerminatorRAII change_terminator_raii(mutated_block, std::move(new_terminator)); opt::DominatorAnalysis dominator_analysis; dominator_analysis.InitializeTree(*ir_context->cfg(), mutated_block->GetParent()); // Check that each dominator appears before each dominated block. std::unordered_map positions; for (const auto& block : *mutated_block->GetParent()) { positions[block.id()] = positions.size(); } std::queue q({mutated_block->GetParent()->begin()->id()}); std::unordered_set visited; while (!q.empty()) { auto block = q.front(); q.pop(); visited.insert(block); auto success = ir_context->cfg()->block(block)->WhileEachSuccessorLabel( [&positions, &visited, &dominator_analysis, block, &q](uint32_t id) { if (id == block) { // Handle the case when loop header and continue target are the same // block. return true; } if (dominator_analysis.Dominates(block, id) && positions[block] > positions[id]) { // |block| dominates |id| but appears after |id| - violates // domination rules. return false; } if (!visited.count(id)) { q.push(id); } return true; }); if (!success) { return false; } } // For each instruction in the |block->GetParent()| function check whether // all its dependencies satisfy domination rules (i.e. all id operands // dominate that instruction). for (const auto& block : *mutated_block->GetParent()) { if (!ir_context->IsReachable(block)) { // If some block is not reachable then we don't need to worry about the // preservation of domination rules for its instructions. continue; } for (const auto& inst : block) { for (uint32_t i = 0; i < inst.NumInOperands(); i += inst.opcode() == spv::Op::OpPhi ? 2 : 1) { const auto& operand = inst.GetInOperand(i); if (!spvIsInIdType(operand.type)) { continue; } if (MaybeFindBlock(ir_context, operand.words[0])) { // Ignore operands that refer to OpLabel instructions. continue; } const auto* dependency_block = ir_context->get_instr_block(operand.words[0]); if (!dependency_block) { // A global instruction always dominates all instructions in any // function. continue; } auto domination_target_id = inst.opcode() == spv::Op::OpPhi ? inst.GetSingleWordInOperand(i + 1) : block.id(); if (!dominator_analysis.Dominates(dependency_block->id(), domination_target_id)) { return false; } } } } return true; } opt::Module::iterator GetFunctionIterator(opt::IRContext* ir_context, uint32_t function_id) { return std::find_if(ir_context->module()->begin(), ir_context->module()->end(), [function_id](const opt::Function& f) { return f.result_id() == function_id; }); } // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/3582): Add all // opcodes that are agnostic to signedness of operands to function. // This is not exhaustive yet. bool IsAgnosticToSignednessOfOperand(spv::Op opcode, uint32_t use_in_operand_index) { switch (opcode) { case spv::Op::OpSNegate: case spv::Op::OpNot: case spv::Op::OpIAdd: case spv::Op::OpISub: case spv::Op::OpIMul: case spv::Op::OpSDiv: case spv::Op::OpSRem: case spv::Op::OpSMod: case spv::Op::OpShiftRightLogical: case spv::Op::OpShiftRightArithmetic: case spv::Op::OpShiftLeftLogical: case spv::Op::OpBitwiseOr: case spv::Op::OpBitwiseXor: case spv::Op::OpBitwiseAnd: case spv::Op::OpIEqual: case spv::Op::OpINotEqual: case spv::Op::OpULessThan: case spv::Op::OpSLessThan: case spv::Op::OpUGreaterThan: case spv::Op::OpSGreaterThan: case spv::Op::OpULessThanEqual: case spv::Op::OpSLessThanEqual: case spv::Op::OpUGreaterThanEqual: case spv::Op::OpSGreaterThanEqual: return true; case spv::Op::OpAtomicStore: case spv::Op::OpAtomicExchange: case spv::Op::OpAtomicIAdd: case spv::Op::OpAtomicISub: case spv::Op::OpAtomicSMin: case spv::Op::OpAtomicUMin: case spv::Op::OpAtomicSMax: case spv::Op::OpAtomicUMax: case spv::Op::OpAtomicAnd: case spv::Op::OpAtomicOr: case spv::Op::OpAtomicXor: case spv::Op::OpAtomicFAddEXT: // Capability AtomicFloat32AddEXT, // AtomicFloat64AddEXT. assert(use_in_operand_index != 0 && "Signedness check should not occur on a pointer operand."); return use_in_operand_index == 1 || use_in_operand_index == 2; case spv::Op::OpAtomicCompareExchange: case spv::Op::OpAtomicCompareExchangeWeak: // Capability Kernel. assert(use_in_operand_index != 0 && "Signedness check should not occur on a pointer operand."); return use_in_operand_index >= 1 && use_in_operand_index <= 3; case spv::Op::OpAtomicLoad: case spv::Op::OpAtomicIIncrement: case spv::Op::OpAtomicIDecrement: case spv::Op::OpAtomicFlagTestAndSet: // Capability Kernel. case spv::Op::OpAtomicFlagClear: // Capability Kernel. assert(use_in_operand_index != 0 && "Signedness check should not occur on a pointer operand."); return use_in_operand_index >= 1; case spv::Op::OpAccessChain: // The signedness of indices does not matter. return use_in_operand_index > 0; default: // Conservatively assume that the id cannot be swapped in other // instructions. return false; } } bool TypesAreCompatible(opt::IRContext* ir_context, spv::Op opcode, uint32_t use_in_operand_index, uint32_t type_id_1, uint32_t type_id_2) { assert(ir_context->get_type_mgr()->GetType(type_id_1) && ir_context->get_type_mgr()->GetType(type_id_2) && "Type ids are invalid"); return type_id_1 == type_id_2 || (IsAgnosticToSignednessOfOperand(opcode, use_in_operand_index) && fuzzerutil::TypesAreEqualUpToSign(ir_context, type_id_1, type_id_2)); } } // namespace fuzzerutil } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/fuzzer_util.h000066400000000000000000000753411475742701700235740ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_FUZZER_UTIL_H_ #define SOURCE_FUZZ_FUZZER_UTIL_H_ #include #include #include #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation_context.h" #include "source/opt/basic_block.h" #include "source/opt/instruction.h" #include "source/opt/ir_context.h" #include "source/opt/module.h" #include "spirv-tools/libspirv.hpp" namespace spvtools { namespace fuzz { // Provides types and global utility methods for use by the fuzzer namespace fuzzerutil { // A silent message consumer. extern const spvtools::MessageConsumer kSilentMessageConsumer; // Function type that produces a SPIR-V module. using ModuleSupplier = std::function()>; // Builds a new opt::IRContext object. Returns true if successful and changes // the |ir_context| parameter. Otherwise (if any errors occur), returns false // and |ir_context| remains unchanged. bool BuildIRContext(spv_target_env target_env, const spvtools::MessageConsumer& message_consumer, const std::vector& binary_in, spv_validator_options validator_options, std::unique_ptr* ir_context); // Returns true if and only if the module does not define the given id. bool IsFreshId(opt::IRContext* context, uint32_t id); // Updates the module's id bound if needed so that it is large enough to // account for the given id. void UpdateModuleIdBound(opt::IRContext* context, uint32_t id); // Return the block with id |maybe_block_id| if it exists, and nullptr // otherwise. opt::BasicBlock* MaybeFindBlock(opt::IRContext* context, uint32_t maybe_block_id); // When adding an edge from |bb_from| to |bb_to| (which are assumed to be blocks // in the same function), it is important to supply |bb_to| with ids that can be // used to augment OpPhi instructions in the case that there is not already such // an edge. This function returns true if and only if the ids provided in // |phi_ids| suffice for this purpose, bool PhiIdsOkForNewEdge( opt::IRContext* context, opt::BasicBlock* bb_from, opt::BasicBlock* bb_to, const google::protobuf::RepeatedField& phi_ids); // Returns an OpBranchConditional instruction that will create an unreachable // branch from |bb_from_id| to |bb_to_id|. |bool_id| must be a result id of // either OpConstantTrue or OpConstantFalse. Based on the opcode of |bool_id|, // operands of the returned instruction will be positioned in a way that the // branch from |bb_from_id| to |bb_to_id| is always unreachable. opt::Instruction CreateUnreachableEdgeInstruction(opt::IRContext* ir_context, uint32_t bb_from_id, uint32_t bb_to_id, uint32_t bool_id); // Requires that |bool_id| is a valid result id of either OpConstantTrue or // OpConstantFalse, that PhiIdsOkForNewEdge(context, bb_from, bb_to, phi_ids) // holds, and that bb_from ends with "OpBranch %some_block". Turns OpBranch // into "OpBranchConditional |condition_value| ...", such that control will // branch to %some_block, with |bb_to| being the unreachable alternative. // Updates OpPhi instructions in |bb_to| using |phi_ids| so that the new edge is // valid. |condition_value| above is equal to |true| if |bool_id| is a result id // of an OpConstantTrue instruction. void AddUnreachableEdgeAndUpdateOpPhis( opt::IRContext* context, opt::BasicBlock* bb_from, opt::BasicBlock* bb_to, uint32_t bool_id, const google::protobuf::RepeatedField& phi_ids); // Returns true if and only if |loop_header_id| is a loop header and // |block_id| is a reachable block branching to and dominated by // |loop_header_id|. bool BlockIsBackEdge(opt::IRContext* context, uint32_t block_id, uint32_t loop_header_id); // Returns true if and only if |maybe_loop_header_id| is a loop header and // |block_id| is in the continue construct of the associated loop. bool BlockIsInLoopContinueConstruct(opt::IRContext* context, uint32_t block_id, uint32_t maybe_loop_header_id); // If |block| contains |inst|, an iterator for |inst| is returned. // Otherwise |block|->end() is returned. opt::BasicBlock::iterator GetIteratorForInstruction( opt::BasicBlock* block, const opt::Instruction* inst); // Determines whether it is OK to insert an instruction with opcode |opcode| // before |instruction_in_block|. bool CanInsertOpcodeBeforeInstruction( spv::Op opcode, const opt::BasicBlock::iterator& instruction_in_block); // Determines whether it is OK to make a synonym of |inst|. // |transformation_context| is used to verify that the result id of |inst| // does not participate in IdIsIrrelevant fact. bool CanMakeSynonymOf(opt::IRContext* ir_context, const TransformationContext& transformation_context, const opt::Instruction& inst); // Determines whether the given type is a composite; that is: an array, matrix, // struct or vector. bool IsCompositeType(const opt::analysis::Type* type); // Returns a vector containing the same elements as |repeated_field|. std::vector RepeatedFieldToVector( const google::protobuf::RepeatedField& repeated_field); // Given a type id, |base_object_type_id|, returns 0 if the type is not a // composite type or if |index| is too large to be used as an index into the // composite. Otherwise returns the type id of the type associated with the // composite's index. // // Example: if |base_object_type_id| is 10, and we have: // // %10 = OpTypeStruct %3 %4 %5 // // then 3 will be returned if |index| is 0, 5 if |index| is 2, and 0 if index // is 3 or larger. uint32_t WalkOneCompositeTypeIndex(opt::IRContext* context, uint32_t base_object_type_id, uint32_t index); // Given a type id, |base_object_type_id|, checks that the given sequence of // |indices| is suitable for indexing into this type. Returns the id of the // type of the final sub-object reached via the indices if they are valid, and // 0 otherwise. uint32_t WalkCompositeTypeIndices( opt::IRContext* context, uint32_t base_object_type_id, const google::protobuf::RepeatedField& indices); // Returns the number of members associated with |struct_type_instruction|, // which must be an OpStructType instruction. uint32_t GetNumberOfStructMembers( const opt::Instruction& struct_type_instruction); // Returns the constant size of the array associated with // |array_type_instruction|, which must be an OpArrayType instruction. Returns // 0 if there is not a static size. uint32_t GetArraySize(const opt::Instruction& array_type_instruction, opt::IRContext* context); // Returns the bound for indexing into a composite of type // |composite_type_inst|, i.e. the number of fields of a struct, the size of an // array, the number of components of a vector, or the number of columns of a // matrix. |composite_type_inst| must be the type of a composite. uint32_t GetBoundForCompositeIndex(const opt::Instruction& composite_type_inst, opt::IRContext* ir_context); // Returns memory semantics mask for specific storage class. spv::MemorySemanticsMask GetMemorySemanticsForStorageClass( spv::StorageClass storage_class); // Returns true if and only if |context| is valid, according to the validator // instantiated with |validator_options|. |consumer| is used for error // reporting. bool IsValid(const opt::IRContext* context, spv_validator_options validator_options, MessageConsumer consumer); // Returns true if and only if IsValid(|context|, |validator_options|) holds, // and furthermore every basic block in |context| has its enclosing function as // its parent, and every instruction in |context| has a distinct unique id. // |consumer| is used for error reporting. bool IsValidAndWellFormed(const opt::IRContext* context, spv_validator_options validator_options, MessageConsumer consumer); // Returns a clone of |context|, by writing |context| to a binary and then // parsing it again. std::unique_ptr CloneIRContext(opt::IRContext* context); // Returns true if and only if |id| is the id of a type that is not a function // type. bool IsNonFunctionTypeId(opt::IRContext* ir_context, uint32_t id); // Returns true if and only if |block_id| is a merge block or continue target bool IsMergeOrContinue(opt::IRContext* ir_context, uint32_t block_id); // Returns the id of the header of the loop corresponding to the given loop // merge block. Returns 0 if |merge_block_id| is not a loop merge block. uint32_t GetLoopFromMergeBlock(opt::IRContext* ir_context, uint32_t merge_block_id); // Returns the result id of an instruction of the form: // %id = OpTypeFunction |type_ids| // or 0 if no such instruction exists. uint32_t FindFunctionType(opt::IRContext* ir_context, const std::vector& type_ids); // Returns a type instruction (OpTypeFunction) for |function|. // Returns |nullptr| if type is not found. opt::Instruction* GetFunctionType(opt::IRContext* context, const opt::Function* function); // Returns the function with result id |function_id|, or |nullptr| if no such // function exists. opt::Function* FindFunction(opt::IRContext* ir_context, uint32_t function_id); // Returns true if |function| has a block that the termination instruction is // OpKill or OpUnreachable. bool FunctionContainsOpKillOrUnreachable(const opt::Function& function); // Returns |true| if one of entry points has function id |function_id|. bool FunctionIsEntryPoint(opt::IRContext* context, uint32_t function_id); // Checks whether |id| is available (according to dominance rules) at the use // point defined by input operand |use_input_operand_index| of // |use_instruction|. |use_instruction| must be a in some basic block. bool IdIsAvailableAtUse(opt::IRContext* context, opt::Instruction* use_instruction, uint32_t use_input_operand_index, uint32_t id); // Checks whether |id| is available (according to dominance rules) at the // program point directly before |instruction|. |instruction| must be in some // basic block. bool IdIsAvailableBeforeInstruction(opt::IRContext* context, opt::Instruction* instruction, uint32_t id); // Returns true if and only if |instruction| is an OpFunctionParameter // associated with |function|. bool InstructionIsFunctionParameter(opt::Instruction* instruction, opt::Function* function); // Returns the type id of the instruction defined by |result_id|, or 0 if there // is no such result id. uint32_t GetTypeId(opt::IRContext* context, uint32_t result_id); // Given |pointer_type_inst|, which must be an OpTypePointer instruction, // returns the id of the associated pointee type. uint32_t GetPointeeTypeIdFromPointerType(opt::Instruction* pointer_type_inst); // Given |pointer_type_id|, which must be the id of a pointer type, returns the // id of the associated pointee type. uint32_t GetPointeeTypeIdFromPointerType(opt::IRContext* context, uint32_t pointer_type_id); // Given |pointer_type_inst|, which must be an OpTypePointer instruction, // returns the associated storage class. spv::StorageClass GetStorageClassFromPointerType( opt::Instruction* pointer_type_inst); // Given |pointer_type_id|, which must be the id of a pointer type, returns the // associated storage class. spv::StorageClass GetStorageClassFromPointerType(opt::IRContext* context, uint32_t pointer_type_id); // Returns the id of a pointer with pointee type |pointee_type_id| and storage // class |storage_class|, if it exists, and 0 otherwise. uint32_t MaybeGetPointerType(opt::IRContext* context, uint32_t pointee_type_id, spv::StorageClass storage_class); // Given an instruction |inst| and an operand absolute index |absolute_index|, // returns the index of the operand restricted to the input operands. uint32_t InOperandIndexFromOperandIndex(const opt::Instruction& inst, uint32_t absolute_index); // Returns true if and only if |type| is one of the types for which it is legal // to have an OpConstantNull value. This may depend on the capabilities declared // in |context|. bool IsNullConstantSupported(opt::IRContext* context, const opt::Instruction& type); // Returns true if and only if the SPIR-V version being used requires that // global variables accessed in the static call graph of an entry point need // to be listed in that entry point's interface. bool GlobalVariablesMustBeDeclaredInEntryPointInterfaces( const opt::IRContext* context); // Adds |id| into the interface of every entry point of the shader. // Does nothing if SPIR-V doesn't require global variables, that are accessed // from an entry point function, to be listed in that function's interface. void AddVariableIdToEntryPointInterfaces(opt::IRContext* context, uint32_t id); // Adds a global variable with storage class |storage_class| to the module, with // type |type_id| and either no initializer or |initializer_id| as an // initializer, depending on whether |initializer_id| is 0. The global variable // has result id |result_id|. Updates module's id bound to accommodate for // |result_id|. // // - |type_id| must be the id of a pointer type with the same storage class as // |storage_class|. // - |storage_class| must be Private or Workgroup. // - |initializer_id| must be 0 if |storage_class| is Workgroup, and otherwise // may either be 0 or the id of a constant whose type is the pointee type of // |type_id|. // // Returns a pointer to the new global variable instruction. opt::Instruction* AddGlobalVariable(opt::IRContext* context, uint32_t result_id, uint32_t type_id, spv::StorageClass storage_class, uint32_t initializer_id); // Adds an instruction to the start of |function_id|, of the form: // |result_id| = OpVariable |type_id| Function |initializer_id|. // Updates module's id bound to accommodate for |result_id|. // // - |type_id| must be the id of a pointer type with Function storage class. // - |initializer_id| must be the id of a constant with the same type as the // pointer's pointee type. // - |function_id| must be the id of a function. // // Returns a pointer to the new local variable instruction. opt::Instruction* AddLocalVariable(opt::IRContext* context, uint32_t result_id, uint32_t type_id, uint32_t function_id, uint32_t initializer_id); // Returns true if the vector |arr| has duplicates. bool HasDuplicates(const std::vector& arr); // Checks that the given vector |arr| contains a permutation of a range // [lo, hi]. That being said, all elements in the range are present without // duplicates. If |arr| is empty, returns true iff |lo > hi|. bool IsPermutationOfRange(const std::vector& arr, uint32_t lo, uint32_t hi); // Returns OpFunctionParameter instructions corresponding to the function // with result id |function_id|. std::vector GetParameters(opt::IRContext* ir_context, uint32_t function_id); // Removes an OpFunctionParameter instruction with result id |parameter_id| // from the its function. Parameter's function must not be an entry-point // function. The function must have a parameter with result id |parameter_id|. // // Prefer using this function to opt::Function::RemoveParameter since // this function also guarantees that |ir_context| has no invalid pointers // to the removed parameter. void RemoveParameter(opt::IRContext* ir_context, uint32_t parameter_id); // Returns all OpFunctionCall instructions that call a function with result id // |function_id|. std::vector GetCallers(opt::IRContext* ir_context, uint32_t function_id); // Returns a function that contains OpFunctionParameter instruction with result // id |param_id|. Returns nullptr if the module has no such function. opt::Function* GetFunctionFromParameterId(opt::IRContext* ir_context, uint32_t param_id); // Changes the type of function |function_id| so that its return type is // |return_type_id| and its parameters' types are |parameter_type_ids|. If a // suitable function type already exists in the module, it is used, otherwise // |new_function_type_result_id| is used as the result id of a suitable new // function type instruction. If the old type of the function doesn't have any // more users, it is removed from the module. Returns the result id of the // OpTypeFunction instruction that is used as a type of the function with // |function_id|. // // CAUTION: When the old type of the function is removed from the module, its // memory is deallocated. Be sure not to use any pointers to the old // type when this function returns. uint32_t UpdateFunctionType(opt::IRContext* ir_context, uint32_t function_id, uint32_t new_function_type_result_id, uint32_t return_type_id, const std::vector& parameter_type_ids); // Creates new OpTypeFunction instruction in the module. |type_ids| may not be // empty. It may not contain result ids of OpTypeFunction instructions. // |type_ids[i]| may not be a result id of OpTypeVoid instruction for |i >= 1|. // |result_id| may not equal to 0. Updates module's id bound to accommodate for // |result_id|. void AddFunctionType(opt::IRContext* ir_context, uint32_t result_id, const std::vector& type_ids); // Returns a result id of an OpTypeFunction instruction in the module. Creates a // new instruction if required and returns |result_id|. type_ids| may not be // empty. It may not contain result ids of OpTypeFunction instructions. // |type_ids[i]| may not be a result id of OpTypeVoid instruction for |i >= 1|. // |result_id| must not be equal to 0. Updates module's id bound to accommodate // for |result_id|. uint32_t FindOrCreateFunctionType(opt::IRContext* ir_context, uint32_t result_id, const std::vector& type_ids); // Returns a result id of an OpTypeInt instruction if present. Returns 0 // otherwise. uint32_t MaybeGetIntegerType(opt::IRContext* ir_context, uint32_t width, bool is_signed); // Returns a result id of an OpTypeFloat instruction if present. Returns 0 // otherwise. uint32_t MaybeGetFloatType(opt::IRContext* ir_context, uint32_t width); // Returns a result id of an OpTypeBool instruction if present. Returns 0 // otherwise. uint32_t MaybeGetBoolType(opt::IRContext* ir_context); // Returns a result id of an OpTypeVector instruction if present. Returns 0 // otherwise. |component_type_id| must be a valid result id of an OpTypeInt, // OpTypeFloat or OpTypeBool instruction in the module. |element_count| must be // in the range [2, 4]. uint32_t MaybeGetVectorType(opt::IRContext* ir_context, uint32_t component_type_id, uint32_t element_count); // Returns a result id of an OpTypeStruct instruction whose field types exactly // match |component_type_ids| if such an instruction is present. Returns 0 // otherwise. |component_type_ids| may not contain a result id of an // OpTypeFunction. uint32_t MaybeGetStructType(opt::IRContext* ir_context, const std::vector& component_type_ids); // Returns a result id of an OpTypeVoid instruction if present. Returns 0 // otherwise. uint32_t MaybeGetVoidType(opt::IRContext* ir_context); // Recursive definition is the following: // - if |scalar_or_composite_type_id| is a result id of a scalar type - returns // a result id of the following constants (depending on the type): int -> 0, // float -> 0.0, bool -> false. // - otherwise, returns a result id of an OpConstantComposite instruction. // Every component of the composite constant is looked up by calling this // function with the type id of that component. // Returns 0 if no such instruction is present in the module. // The returned id either participates in IdIsIrrelevant fact or not, depending // on the |is_irrelevant| parameter. uint32_t MaybeGetZeroConstant( opt::IRContext* ir_context, const TransformationContext& transformation_context, uint32_t scalar_or_composite_type_id, bool is_irrelevant); // Returns true if it is possible to create an OpConstant or an // OpConstantComposite instruction of type |type_id|. That is, returns true if // the type associated with |type_id| and all its constituents are either scalar // or composite. bool CanCreateConstant(opt::IRContext* ir_context, uint32_t type_id); // Returns the result id of an OpConstant instruction. |scalar_type_id| must be // a result id of a scalar type (i.e. int, float or bool). Returns 0 if no such // instruction is present in the module. The returned id either participates in // IdIsIrrelevant fact or not, depending on the |is_irrelevant| parameter. uint32_t MaybeGetScalarConstant( opt::IRContext* ir_context, const TransformationContext& transformation_context, const std::vector& words, uint32_t scalar_type_id, bool is_irrelevant); // Returns the result id of an OpConstantComposite instruction. // |composite_type_id| must be a result id of a composite type (i.e. vector, // matrix, struct or array). Returns 0 if no such instruction is present in the // module. The returned id either participates in IdIsIrrelevant fact or not, // depending on the |is_irrelevant| parameter. uint32_t MaybeGetCompositeConstant( opt::IRContext* ir_context, const TransformationContext& transformation_context, const std::vector& component_ids, uint32_t composite_type_id, bool is_irrelevant); // Returns the result id of an OpConstant instruction of integral type. // Returns 0 if no such instruction or type is present in the module. // The returned id either participates in IdIsIrrelevant fact or not, depending // on the |is_irrelevant| parameter. uint32_t MaybeGetIntegerConstant( opt::IRContext* ir_context, const TransformationContext& transformation_context, const std::vector& words, uint32_t width, bool is_signed, bool is_irrelevant); // Returns the id of a 32-bit integer constant in the module with type // |int_type_id| and value |value|, or 0 if no such constant exists in the // module. |int_type_id| must exist in the module and it must correspond to a // 32-bit integer type. uint32_t MaybeGetIntegerConstantFromValueAndType(opt::IRContext* ir_context, uint32_t value, uint32_t int_type_id); // Returns the result id of an OpConstant instruction of floating-point type. // Returns 0 if no such instruction or type is present in the module. // The returned id either participates in IdIsIrrelevant fact or not, depending // on the |is_irrelevant| parameter. uint32_t MaybeGetFloatConstant( opt::IRContext* ir_context, const TransformationContext& transformation_context, const std::vector& words, uint32_t width, bool is_irrelevant); // Returns the id of a boolean constant with value |value| if it exists in the // module, or 0 otherwise. The returned id either participates in IdIsIrrelevant // fact or not, depending on the |is_irrelevant| parameter. uint32_t MaybeGetBoolConstant( opt::IRContext* context, const TransformationContext& transformation_context, bool value, bool is_irrelevant); // Returns a vector of words representing the integer |value|, only considering // the last |width| bits. The last |width| bits are sign-extended if the value // is signed, zero-extended if it is unsigned. // |width| must be <= 64. // If |width| <= 32, returns a vector containing one value. If |width| > 64, // returns a vector containing two values, with the first one representing the // lower-order word of the value and the second one representing the // higher-order word. std::vector IntToWords(uint64_t value, uint32_t width, bool is_signed); // Returns a bit pattern that represents a floating-point |value|. inline uint32_t FloatToWord(float value) { uint32_t result; memcpy(&result, &value, sizeof(uint32_t)); return result; } // Returns true if any of the following is true: // - |type1_id| and |type2_id| are the same id // - |type1_id| and |type2_id| refer to integer scalar or vector types, only // differing by their signedness. bool TypesAreEqualUpToSign(opt::IRContext* ir_context, uint32_t type1_id, uint32_t type2_id); // Converts repeated field of UInt32Pair to a map. If two or more equal values // of |UInt32Pair::first()| are available in |data|, the last value of // |UInt32Pair::second()| is used. std::map RepeatedUInt32PairToMap( const google::protobuf::RepeatedPtrField& data); // Converts a map into a repeated field of UInt32Pair. google::protobuf::RepeatedPtrField MapToRepeatedUInt32Pair(const std::map& data); // Returns the last instruction in |block_id| before which an instruction with // opcode |opcode| can be inserted, or nullptr if there is no such instruction. opt::Instruction* GetLastInsertBeforeInstruction(opt::IRContext* ir_context, uint32_t block_id, spv::Op opcode); // Checks whether various conditions hold related to the acceptability of // replacing the id use at |use_in_operand_index| of |use_instruction| with a // synonym or another id of appropriate type if the original id is irrelevant. // In particular, this checks that: // - If id use is an index of an irrelevant id (|use_in_operand_index > 0|) // in OpAccessChain - it can't be replaced. // - The id use is not an index into a struct field in an OpAccessChain - such // indices must be constants, so it is dangerous to replace them. // - The id use is not a pointer function call argument, on which there are // restrictions that make replacement problematic. // - The id use is not the Sample parameter of an OpImageTexelPointer // instruction, as this must satisfy particular requirements. bool IdUseCanBeReplaced(opt::IRContext* ir_context, const TransformationContext& transformation_context, opt::Instruction* use_instruction, uint32_t use_in_operand_index); // Requires that |struct_type_id| is the id of a struct type, and (as per the // SPIR-V spec) that either all or none of the members of |struct_type_id| have // the BuiltIn decoration. Returns true if and only if all members have the // BuiltIn decoration. bool MembersHaveBuiltInDecoration(opt::IRContext* ir_context, uint32_t struct_type_id); // Returns true if and only if |id| is decorated with either Block or // BufferBlock. Even though these decorations are only allowed on struct types, // for convenience |id| can be any result id so that it is possible to call this // method on something that *might* be a struct type. bool HasBlockOrBufferBlockDecoration(opt::IRContext* ir_context, uint32_t id); // Returns true iff splitting block |block_to_split| just before the instruction // |split_before| would separate an OpSampledImage instruction from its usage. bool SplittingBeforeInstructionSeparatesOpSampledImageDefinitionFromUse( opt::BasicBlock* block_to_split, opt::Instruction* split_before); // Returns true if the instruction given has no side effects. // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/3758): Add any // missing instructions to the list. In particular, GLSL extended instructions // (called using OpExtInst) have not been considered. bool InstructionHasNoSideEffects(const opt::Instruction& instruction); // Returns a set of the ids of all the return blocks that are reachable from // the entry block of |function_id|. // Assumes that the function exists in the module. std::set GetReachableReturnBlocks(opt::IRContext* ir_context, uint32_t function_id); // Returns true if changing terminator instruction to |new_terminator| in the // basic block with id |block_id| preserves domination rules and valid block // order (i.e. dominator must always appear before dominated in the CFG). // Returns false otherwise. bool NewTerminatorPreservesDominationRules(opt::IRContext* ir_context, uint32_t block_id, opt::Instruction new_terminator); // Return the iterator that points to the function with the corresponding // function id. If the function is not found, return the pointer pointing to // module()->end(). opt::Module::iterator GetFunctionIterator(opt::IRContext* ir_context, uint32_t function_id); // Returns true if the instruction with opcode |opcode| does not change its // behaviour depending on the signedness of the operand at // |use_in_operand_index|. // Assumes that the operand must be the id of an integer scalar or vector. bool IsAgnosticToSignednessOfOperand(spv::Op opcode, uint32_t use_in_operand_index); // Returns true if |type_id_1| and |type_id_2| represent compatible types // given the context of the instruction with |opcode| (i.e. we can replace // an operand of |opcode| of the first type with an id of the second type // and vice-versa). bool TypesAreCompatible(opt::IRContext* ir_context, spv::Op opcode, uint32_t use_in_operand_index, uint32_t type_id_1, uint32_t type_id_2); } // namespace fuzzerutil } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_FUZZER_UTIL_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/id_use_descriptor.cpp000066400000000000000000000041041475742701700252400ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/id_use_descriptor.h" #include "source/fuzz/instruction_descriptor.h" namespace spvtools { namespace fuzz { opt::Instruction* FindInstructionContainingUse( const protobufs::IdUseDescriptor& id_use_descriptor, opt::IRContext* context) { auto result = FindInstruction(id_use_descriptor.enclosing_instruction(), context); if (!result) { return nullptr; } if (id_use_descriptor.in_operand_index() >= result->NumInOperands()) { return nullptr; } if (result->GetSingleWordInOperand(id_use_descriptor.in_operand_index()) != id_use_descriptor.id_of_interest()) { return nullptr; } return result; } protobufs::IdUseDescriptor MakeIdUseDescriptor( uint32_t id_of_interest, const protobufs::InstructionDescriptor& enclosing_instruction, uint32_t in_operand_index) { protobufs::IdUseDescriptor result; result.set_id_of_interest(id_of_interest); *result.mutable_enclosing_instruction() = enclosing_instruction; result.set_in_operand_index(in_operand_index); return result; } protobufs::IdUseDescriptor MakeIdUseDescriptorFromUse( opt::IRContext* context, opt::Instruction* inst, uint32_t in_operand_index) { const auto& in_operand = inst->GetInOperand(in_operand_index); assert(spvIsInIdType(in_operand.type)); return MakeIdUseDescriptor(in_operand.words[0], MakeInstructionDescriptor(context, inst), in_operand_index); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/id_use_descriptor.h000066400000000000000000000035031475742701700247070ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_ID_USE_DESCRIPTOR_H_ #define SOURCE_FUZZ_ID_USE_DESCRIPTOR_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { // Looks for an instruction in |context| that contains a use // identified by |id_use_descriptor|. // Returns |nullptr| if no such instruction can be found. opt::Instruction* FindInstructionContainingUse( const protobufs::IdUseDescriptor& id_use_descriptor, opt::IRContext* context); // Creates an IdUseDescriptor protobuf message from the given components. // See the protobuf definition for details of what these components mean. protobufs::IdUseDescriptor MakeIdUseDescriptor( uint32_t id_of_interest, const protobufs::InstructionDescriptor& enclosing_instruction, uint32_t in_operand_index); // Given an id use, represented by the instruction |inst| that uses the id, and // the input operand index |in_operand_index| associated with the usage, returns // an IdUseDescriptor that represents the use. protobufs::IdUseDescriptor MakeIdUseDescriptorFromUse( opt::IRContext* context, opt::Instruction* inst, uint32_t in_operand_index); } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_ID_USE_DESCRIPTOR_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/instruction_descriptor.cpp000066400000000000000000000111141475742701700263500ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/instruction_descriptor.h" namespace spvtools { namespace fuzz { opt::Instruction* FindInstruction( const protobufs::InstructionDescriptor& instruction_descriptor, spvtools::opt::IRContext* context) { auto block = context->get_instr_block( instruction_descriptor.base_instruction_result_id()); if (block == nullptr) { return nullptr; } bool found_base = block->id() == instruction_descriptor.base_instruction_result_id(); uint32_t num_ignored = 0; for (auto& instruction : *block) { if (instruction.HasResultId() && instruction.result_id() == instruction_descriptor.base_instruction_result_id()) { assert(!found_base && "It should not be possible to find the base instruction " "multiple times."); found_base = true; assert(num_ignored == 0 && "The skipped instruction count should only be incremented " "after the instruction base has been found."); } if (found_base && instruction.opcode() == spv::Op(instruction_descriptor.target_instruction_opcode())) { if (num_ignored == instruction_descriptor.num_opcodes_to_ignore()) { return &instruction; } num_ignored++; } } return nullptr; } protobufs::InstructionDescriptor MakeInstructionDescriptor( uint32_t base_instruction_result_id, spv::Op target_instruction_opcode, uint32_t num_opcodes_to_ignore) { protobufs::InstructionDescriptor result; result.set_base_instruction_result_id(base_instruction_result_id); result.set_target_instruction_opcode(uint32_t(target_instruction_opcode)); result.set_num_opcodes_to_ignore(num_opcodes_to_ignore); return result; } protobufs::InstructionDescriptor MakeInstructionDescriptor( const opt::BasicBlock& block, const opt::BasicBlock::const_iterator& inst_it) { const spv::Op opcode = inst_it->opcode(); // The opcode of the instruction being described. uint32_t skip_count = 0; // The number of these opcodes we have skipped when // searching backwards. // Consider instructions in the block in reverse order, starting from // |inst_it|. for (opt::BasicBlock::const_iterator backwards_iterator = inst_it;; --backwards_iterator) { if (backwards_iterator->HasResultId()) { // As soon as we find an instruction with a result id, we can return a // descriptor for |inst_it|. return MakeInstructionDescriptor(backwards_iterator->result_id(), opcode, skip_count); } if (backwards_iterator != inst_it && backwards_iterator->opcode() == opcode) { // We are skipping over an instruction with the same opcode as |inst_it|; // we increase our skip count to reflect this. skip_count++; } if (backwards_iterator == block.begin()) { // We exit the loop when we reach the start of the block, but only after // we have processed the first instruction in the block. break; } } // We did not find an instruction inside the block with a result id, so we use // the block's label's id. return MakeInstructionDescriptor(block.id(), opcode, skip_count); } protobufs::InstructionDescriptor MakeInstructionDescriptor( opt::IRContext* context, opt::Instruction* inst) { auto block = context->get_instr_block(inst); uint32_t base_instruction_result_id = block->id(); uint32_t num_opcodes_to_ignore = 0; for (auto& inst_in_block : *block) { if (inst_in_block.HasResultId()) { base_instruction_result_id = inst_in_block.result_id(); num_opcodes_to_ignore = 0; } if (&inst_in_block == inst) { return MakeInstructionDescriptor(base_instruction_result_id, inst->opcode(), num_opcodes_to_ignore); } if (inst_in_block.opcode() == inst->opcode()) { num_opcodes_to_ignore++; } } assert(false && "No matching instruction was found."); return protobufs::InstructionDescriptor(); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/instruction_descriptor.h000066400000000000000000000041041475742701700260160ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_INSTRUCTION_DESCRIPTOR_H_ #define SOURCE_FUZZ_INSTRUCTION_DESCRIPTOR_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/opt/basic_block.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { // Looks for an instruction in |context| corresponding to |descriptor|. // Returns |nullptr| if no such instruction can be found. opt::Instruction* FindInstruction( const protobufs::InstructionDescriptor& instruction_descriptor, opt::IRContext* context); // Creates an InstructionDescriptor protobuf message from the given // components. See the protobuf definition for details of what these // components mean. protobufs::InstructionDescriptor MakeInstructionDescriptor( uint32_t base_instruction_result_id, spv::Op target_instruction_opcode, uint32_t num_opcodes_to_ignore); // Returns an instruction descriptor that describing the instruction at // |inst_it|, which must be inside |block|. The descriptor will be with // respect to the first instruction at or before |inst_it| that has a result // id. protobufs::InstructionDescriptor MakeInstructionDescriptor( const opt::BasicBlock& block, const opt::BasicBlock::const_iterator& inst_it); // Returns an InstructionDescriptor that describes the given instruction |inst|. protobufs::InstructionDescriptor MakeInstructionDescriptor( opt::IRContext* context, opt::Instruction* inst); } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_INSTRUCTION_DESCRIPTOR_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/instruction_message.cpp000066400000000000000000000057531475742701700256320ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/instruction_message.h" #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { protobufs::Instruction MakeInstructionMessage( spv::Op opcode, uint32_t result_type_id, uint32_t result_id, const opt::Instruction::OperandList& input_operands) { protobufs::Instruction result; result.set_opcode(uint32_t(opcode)); result.set_result_type_id(result_type_id); result.set_result_id(result_id); for (auto& operand : input_operands) { auto operand_message = result.add_input_operand(); operand_message->set_operand_type(static_cast(operand.type)); for (auto operand_word : operand.words) { operand_message->add_operand_data(operand_word); } } return result; } protobufs::Instruction MakeInstructionMessage( const opt::Instruction* instruction) { opt::Instruction::OperandList input_operands; for (uint32_t input_operand_index = 0; input_operand_index < instruction->NumInOperands(); input_operand_index++) { input_operands.push_back(instruction->GetInOperand(input_operand_index)); } return MakeInstructionMessage(instruction->opcode(), instruction->type_id(), instruction->result_id(), input_operands); } std::unique_ptr InstructionFromMessage( opt::IRContext* ir_context, const protobufs::Instruction& instruction_message) { // First, update the module's id bound with respect to the new instruction, // if it has a result id. if (instruction_message.result_id()) { fuzzerutil::UpdateModuleIdBound(ir_context, instruction_message.result_id()); } // Now create a sequence of input operands from the input operand data in the // protobuf message. opt::Instruction::OperandList in_operands; for (auto& operand_message : instruction_message.input_operand()) { opt::Operand::OperandData operand_data; for (auto& word : operand_message.operand_data()) { operand_data.push_back(word); } in_operands.push_back( {static_cast(operand_message.operand_type()), operand_data}); } // Create and return the instruction. return MakeUnique( ir_context, static_cast(instruction_message.opcode()), instruction_message.result_type_id(), instruction_message.result_id(), in_operands); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/instruction_message.h000066400000000000000000000033771475742701700252770ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_INSTRUCTION_MESSAGE_H_ #define SOURCE_FUZZ_INSTRUCTION_MESSAGE_H_ #include #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/opt/instruction.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { // Creates an Instruction protobuf message from its component parts. protobufs::Instruction MakeInstructionMessage( spv::Op opcode, uint32_t result_type_id, uint32_t result_id, const opt::Instruction::OperandList& input_operands); // Creates an Instruction protobuf message from a parsed instruction. protobufs::Instruction MakeInstructionMessage( const opt::Instruction* instruction); // Creates and returns an opt::Instruction from protobuf message // |instruction_message|, relative to |ir_context|. In the process, the module // id bound associated with |ir_context| is updated to be at least as large as // the result id (if any) associated with the new instruction. std::unique_ptr InstructionFromMessage( opt::IRContext* ir_context, const protobufs::Instruction& instruction_message); } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_INSTRUCTION_MESSAGE_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/overflow_id_source.cpp000066400000000000000000000014041475742701700254310ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/overflow_id_source.h" namespace spvtools { namespace fuzz { OverflowIdSource::~OverflowIdSource() = default; } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/overflow_id_source.h000066400000000000000000000064251475742701700251060ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_OVERFLOW_ID_SOURCE_H_ #define SOURCE_FUZZ_OVERFLOW_ID_SOURCE_H_ #include #include namespace spvtools { namespace fuzz { // An implementation of this interface can be used to provide fresh ids on // demand when applying a transformation. // // During fuzzing this should never be required: a fuzzer pass should determine // all the fresh ids it requires to apply a transformation. // // However, during shrinking we can have the situation where, after removing // an early transformation, a later transformation needs more ids. // // As an example, suppose a SPIR-V function originally has this form: // // main() { // stmt1; // stmt2; // stmt3; // stmt4; // } // // Now suppose two *outlining* transformations are applied. The first // transformation, T1, outlines "stmt1; stmt2;" into a function foo, giving us: // // foo() { // stmt1; // stmt2; // } // // main() { // foo(); // stmt3; // stmt4; // } // // The second transformation, T2, outlines "foo(); stmt3;" from main into a // function bar, giving us: // // foo() { // stmt1; // stmt2; // } // // bar() { // foo(); // stmt3; // } // // main() { // bar(); // stmt4; // } // // Suppose that T2 used a set of fresh ids, FRESH, in order to perform its // outlining. // // Now suppose that during shrinking we remove T1, but still want to apply T2. // The fresh ids used by T2 - FRESH - are sufficient to outline "foo(); stmt3;". // However, because we did not apply T1, "foo();" does not exist and instead the // task of T2 is to outline "stmt1; stmt2; stmt3;". The set FRESH contains // *some* of the fresh ids required to do this (those for "stmt3;"), but not all // of them (those for "stmt1; stmt2;" are missing). // // A source of overflow ids can be used to allow the shrinker to proceed // nevertheless. // // It is desirable to use overflow ids only when needed. In our worked example, // T2 should still use the ids from FRESH when handling "stmt3;", because later // transformations might refer to those ids and will become inapplicable if // overflow ids are used instead. class OverflowIdSource { public: virtual ~OverflowIdSource(); // Returns true if and only if this source is capable of providing overflow // ids. virtual bool HasOverflowIds() const = 0; // Precondition: HasOverflowIds() must hold. Returns the next available // overflow id. virtual uint32_t GetNextOverflowId() = 0; // Returns the set of overflow ids from this source that have been previously // issued via calls to GetNextOverflowId(). virtual const std::unordered_set& GetIssuedOverflowIds() const = 0; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_OVERFLOW_ID_SOURCE_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/pass_management/000077500000000000000000000000001475742701700241715ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/pass_management/repeated_pass_instances.h000066400000000000000000000225171475742701700312370ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_REPEATED_PASS_INSTANCES_H_ #define SOURCE_FUZZ_REPEATED_PASS_INSTANCES_H_ #include "source/fuzz/fuzzer_pass_add_access_chains.h" #include "source/fuzz/fuzzer_pass_add_bit_instruction_synonyms.h" #include "source/fuzz/fuzzer_pass_add_composite_extract.h" #include "source/fuzz/fuzzer_pass_add_composite_inserts.h" #include "source/fuzz/fuzzer_pass_add_composite_types.h" #include "source/fuzz/fuzzer_pass_add_copy_memory.h" #include "source/fuzz/fuzzer_pass_add_dead_blocks.h" #include "source/fuzz/fuzzer_pass_add_dead_breaks.h" #include "source/fuzz/fuzzer_pass_add_dead_continues.h" #include "source/fuzz/fuzzer_pass_add_equation_instructions.h" #include "source/fuzz/fuzzer_pass_add_function_calls.h" #include "source/fuzz/fuzzer_pass_add_global_variables.h" #include "source/fuzz/fuzzer_pass_add_image_sample_unused_components.h" #include "source/fuzz/fuzzer_pass_add_loads.h" #include "source/fuzz/fuzzer_pass_add_local_variables.h" #include "source/fuzz/fuzzer_pass_add_loop_preheaders.h" #include "source/fuzz/fuzzer_pass_add_loops_to_create_int_constant_synonyms.h" #include "source/fuzz/fuzzer_pass_add_opphi_synonyms.h" #include "source/fuzz/fuzzer_pass_add_parameters.h" #include "source/fuzz/fuzzer_pass_add_relaxed_decorations.h" #include "source/fuzz/fuzzer_pass_add_stores.h" #include "source/fuzz/fuzzer_pass_add_synonyms.h" #include "source/fuzz/fuzzer_pass_add_vector_shuffle_instructions.h" #include "source/fuzz/fuzzer_pass_apply_id_synonyms.h" #include "source/fuzz/fuzzer_pass_construct_composites.h" #include "source/fuzz/fuzzer_pass_copy_objects.h" #include "source/fuzz/fuzzer_pass_donate_modules.h" #include "source/fuzz/fuzzer_pass_duplicate_regions_with_selections.h" #include "source/fuzz/fuzzer_pass_expand_vector_reductions.h" #include "source/fuzz/fuzzer_pass_flatten_conditional_branches.h" #include "source/fuzz/fuzzer_pass_inline_functions.h" #include "source/fuzz/fuzzer_pass_invert_comparison_operators.h" #include "source/fuzz/fuzzer_pass_make_vector_operations_dynamic.h" #include "source/fuzz/fuzzer_pass_merge_blocks.h" #include "source/fuzz/fuzzer_pass_merge_function_returns.h" #include "source/fuzz/fuzzer_pass_mutate_pointers.h" #include "source/fuzz/fuzzer_pass_obfuscate_constants.h" #include "source/fuzz/fuzzer_pass_outline_functions.h" #include "source/fuzz/fuzzer_pass_permute_blocks.h" #include "source/fuzz/fuzzer_pass_permute_function_parameters.h" #include "source/fuzz/fuzzer_pass_permute_instructions.h" #include "source/fuzz/fuzzer_pass_propagate_instructions_down.h" #include "source/fuzz/fuzzer_pass_propagate_instructions_up.h" #include "source/fuzz/fuzzer_pass_push_ids_through_variables.h" #include "source/fuzz/fuzzer_pass_replace_adds_subs_muls_with_carrying_extended.h" #include "source/fuzz/fuzzer_pass_replace_branches_from_dead_blocks_with_exits.h" #include "source/fuzz/fuzzer_pass_replace_copy_memories_with_loads_stores.h" #include "source/fuzz/fuzzer_pass_replace_copy_objects_with_stores_loads.h" #include "source/fuzz/fuzzer_pass_replace_irrelevant_ids.h" #include "source/fuzz/fuzzer_pass_replace_linear_algebra_instructions.h" #include "source/fuzz/fuzzer_pass_replace_loads_stores_with_copy_memories.h" #include "source/fuzz/fuzzer_pass_replace_opphi_ids_from_dead_predecessors.h" #include "source/fuzz/fuzzer_pass_replace_opselects_with_conditional_branches.h" #include "source/fuzz/fuzzer_pass_replace_parameter_with_global.h" #include "source/fuzz/fuzzer_pass_replace_params_with_struct.h" #include "source/fuzz/fuzzer_pass_split_blocks.h" #include "source/fuzz/fuzzer_pass_swap_conditional_branch_operands.h" #include "source/fuzz/fuzzer_pass_wrap_regions_in_selections.h" #include "source/fuzz/fuzzer_pass_wrap_vector_synonym.h" namespace spvtools { namespace fuzz { // This class has a distinct member for each repeated fuzzer pass (i.e., a // fuzzer pass that it makes sense to run multiple times). If a member is null // then we do not have an instance of that fuzzer pass, i.e. it is disabled. // The class also provides access to the set of passes that are enabled. class RepeatedPassInstances { // This macro should be invoked below for every repeated fuzzer pass. If a // repeated fuzzer pass is called FuzzerPassFoo then the macro invocation: // // REPEATED_PASS_INSTANCE(Foo); // // should be used. This adds a private member of type FuzzerPassFoo*, and // provides the following public methods: // // // Requires that SetPass has not been called previously with FuzzerPassFoo. // // Adds |pass| to the set of known pass instances. // void SetPass(std::unique_ptr pass); // // // Returns a pointer to a pass instance of type FuzzerPassFoo that was // // previously registered via SetPass(), or nullptr if no such instance was // // registered // FuzzerPassFoo* GetFoo(); #define REPEATED_PASS_INSTANCE(NAME) \ public: \ FuzzerPass##NAME* Get##NAME() const { return NAME##_; } \ void SetPass(std::unique_ptr pass) { \ assert(NAME##_ == nullptr && "Attempt to set pass multiple times."); \ NAME##_ = pass.get(); \ passes_.push_back(std::move(pass)); \ } \ \ private: \ FuzzerPass##NAME* NAME##_ = nullptr REPEATED_PASS_INSTANCE(AddAccessChains); REPEATED_PASS_INSTANCE(AddBitInstructionSynonyms); REPEATED_PASS_INSTANCE(AddCompositeExtract); REPEATED_PASS_INSTANCE(AddCompositeInserts); REPEATED_PASS_INSTANCE(AddCompositeTypes); REPEATED_PASS_INSTANCE(AddCopyMemory); REPEATED_PASS_INSTANCE(AddDeadBlocks); REPEATED_PASS_INSTANCE(AddDeadBreaks); REPEATED_PASS_INSTANCE(AddDeadContinues); REPEATED_PASS_INSTANCE(AddEquationInstructions); REPEATED_PASS_INSTANCE(AddFunctionCalls); REPEATED_PASS_INSTANCE(AddGlobalVariables); REPEATED_PASS_INSTANCE(AddImageSampleUnusedComponents); REPEATED_PASS_INSTANCE(AddLoads); REPEATED_PASS_INSTANCE(AddLocalVariables); REPEATED_PASS_INSTANCE(AddLoopPreheaders); REPEATED_PASS_INSTANCE(AddLoopsToCreateIntConstantSynonyms); REPEATED_PASS_INSTANCE(AddOpPhiSynonyms); REPEATED_PASS_INSTANCE(AddParameters); REPEATED_PASS_INSTANCE(AddRelaxedDecorations); REPEATED_PASS_INSTANCE(AddStores); REPEATED_PASS_INSTANCE(AddSynonyms); REPEATED_PASS_INSTANCE(AddVectorShuffleInstructions); REPEATED_PASS_INSTANCE(ApplyIdSynonyms); REPEATED_PASS_INSTANCE(ConstructComposites); REPEATED_PASS_INSTANCE(CopyObjects); REPEATED_PASS_INSTANCE(DonateModules); REPEATED_PASS_INSTANCE(DuplicateRegionsWithSelections); REPEATED_PASS_INSTANCE(ExpandVectorReductions); REPEATED_PASS_INSTANCE(FlattenConditionalBranches); REPEATED_PASS_INSTANCE(InlineFunctions); REPEATED_PASS_INSTANCE(InvertComparisonOperators); REPEATED_PASS_INSTANCE(MakeVectorOperationsDynamic); REPEATED_PASS_INSTANCE(MergeBlocks); REPEATED_PASS_INSTANCE(MergeFunctionReturns); REPEATED_PASS_INSTANCE(MutatePointers); REPEATED_PASS_INSTANCE(ObfuscateConstants); REPEATED_PASS_INSTANCE(OutlineFunctions); REPEATED_PASS_INSTANCE(PermuteBlocks); REPEATED_PASS_INSTANCE(PermuteFunctionParameters); REPEATED_PASS_INSTANCE(PermuteInstructions); REPEATED_PASS_INSTANCE(PropagateInstructionsDown); REPEATED_PASS_INSTANCE(PropagateInstructionsUp); REPEATED_PASS_INSTANCE(PushIdsThroughVariables); REPEATED_PASS_INSTANCE(ReplaceAddsSubsMulsWithCarryingExtended); REPEATED_PASS_INSTANCE(ReplaceBranchesFromDeadBlocksWithExits); REPEATED_PASS_INSTANCE(ReplaceCopyMemoriesWithLoadsStores); REPEATED_PASS_INSTANCE(ReplaceCopyObjectsWithStoresLoads); REPEATED_PASS_INSTANCE(ReplaceLoadsStoresWithCopyMemories); REPEATED_PASS_INSTANCE(ReplaceIrrelevantIds); REPEATED_PASS_INSTANCE(ReplaceOpPhiIdsFromDeadPredecessors); REPEATED_PASS_INSTANCE(ReplaceOpSelectsWithConditionalBranches); REPEATED_PASS_INSTANCE(ReplaceParameterWithGlobal); REPEATED_PASS_INSTANCE(ReplaceLinearAlgebraInstructions); REPEATED_PASS_INSTANCE(ReplaceParamsWithStruct); REPEATED_PASS_INSTANCE(SplitBlocks); REPEATED_PASS_INSTANCE(SwapBranchConditionalOperands); REPEATED_PASS_INSTANCE(WrapRegionsInSelections); REPEATED_PASS_INSTANCE(WrapVectorSynonym); #undef REPEATED_PASS_INSTANCE public: // Yields the sequence of fuzzer pass instances that have been registered. const std::vector>& GetPasses() const { return passes_; } private: // The distinct fuzzer pass instances that have been registered via SetPass(). std::vector> passes_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_REPEATED_PASS_INSTANCES_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/pass_management/repeated_pass_manager.cpp000066400000000000000000000041341475742701700312100ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/pass_management/repeated_pass_manager.h" #include "source/fuzz/pass_management/repeated_pass_manager_looped_with_recommendations.h" #include "source/fuzz/pass_management/repeated_pass_manager_random_with_recommendations.h" #include "source/fuzz/pass_management/repeated_pass_manager_simple.h" namespace spvtools { namespace fuzz { RepeatedPassManager::RepeatedPassManager(FuzzerContext* fuzzer_context, RepeatedPassInstances* pass_instances) : fuzzer_context_(fuzzer_context), pass_instances_(pass_instances) {} RepeatedPassManager::~RepeatedPassManager() = default; std::unique_ptr RepeatedPassManager::Create( RepeatedPassStrategy strategy, FuzzerContext* fuzzer_context, RepeatedPassInstances* pass_instances, RepeatedPassRecommender* pass_recommender) { switch (strategy) { case RepeatedPassStrategy::kSimple: return MakeUnique(fuzzer_context, pass_instances); case RepeatedPassStrategy::kLoopedWithRecommendations: return MakeUnique( fuzzer_context, pass_instances, pass_recommender); case RepeatedPassStrategy::kRandomWithRecommendations: return MakeUnique( fuzzer_context, pass_instances, pass_recommender); } assert(false && "Unreachable"); return nullptr; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/pass_management/repeated_pass_manager.h000066400000000000000000000054171475742701700306620ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_REPEATED_PASS_MANAGER_H_ #define SOURCE_FUZZ_REPEATED_PASS_MANAGER_H_ #include "source/fuzz/fuzzer_context.h" #include "source/fuzz/fuzzer_pass.h" #include "source/fuzz/pass_management/repeated_pass_instances.h" #include "source/fuzz/pass_management/repeated_pass_recommender.h" #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" namespace spvtools { namespace fuzz { // Each field of this enum corresponds to an available repeated pass // strategy, and is used to decide which kind of RepeatedPassManager object // to create. enum class RepeatedPassStrategy { kSimple, kRandomWithRecommendations, kLoopedWithRecommendations }; // An interface to encapsulate the manner in which the sequence of repeated // passes that are applied during fuzzing is chosen. An implementation of this // interface could, for example, keep track of the history of passes that have // been run and bias the selection of future passes according to this history. class RepeatedPassManager { public: RepeatedPassManager(FuzzerContext* fuzzer_context, RepeatedPassInstances* pass_instances); virtual ~RepeatedPassManager(); // Returns the fuzzer pass instance that should be run next. The // transformations that have been applied so far are provided via // |applied_transformations| and can be used to influence the decision. virtual FuzzerPass* ChoosePass( const protobufs::TransformationSequence& applied_transformations) = 0; // Creates a corresponding RepeatedPassManager based on the |strategy|. static std::unique_ptr Create( RepeatedPassStrategy strategy, FuzzerContext* fuzzer_context, RepeatedPassInstances* pass_instances, RepeatedPassRecommender* pass_recommender); protected: FuzzerContext* GetFuzzerContext() { return fuzzer_context_; } RepeatedPassInstances* GetPassInstances() { return pass_instances_; } private: // Provided in order to allow the pass manager to make random decisions. FuzzerContext* fuzzer_context_; // The repeated fuzzer passes that are enabled. RepeatedPassInstances* pass_instances_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_REPEATED_PASS_MANAGER_H_ repeated_pass_manager_looped_with_recommendations.cpp000066400000000000000000000057111475742701700367770ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/pass_management// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/pass_management/repeated_pass_manager_looped_with_recommendations.h" namespace spvtools { namespace fuzz { RepeatedPassManagerLoopedWithRecommendations:: RepeatedPassManagerLoopedWithRecommendations( FuzzerContext* fuzzer_context, RepeatedPassInstances* pass_instances, RepeatedPassRecommender* pass_recommender) : RepeatedPassManager(fuzzer_context, pass_instances), num_transformations_applied_before_last_pass_choice_(0), next_pass_index_(0) { auto& passes = GetPassInstances()->GetPasses(); do { FuzzerPass* current_pass = passes[GetFuzzerContext()->RandomIndex(passes)].get(); pass_loop_.push_back(current_pass); for (auto future_pass : pass_recommender->GetFuturePassRecommendations(*current_pass)) { recommended_pass_indices_.insert( static_cast(pass_loop_.size())); pass_loop_.push_back(future_pass); } } while (fuzzer_context->ChoosePercentage( fuzzer_context->GetChanceOfAddingAnotherPassToPassLoop())); } RepeatedPassManagerLoopedWithRecommendations:: ~RepeatedPassManagerLoopedWithRecommendations() = default; FuzzerPass* RepeatedPassManagerLoopedWithRecommendations::ChoosePass( const protobufs::TransformationSequence& applied_transformations) { assert((next_pass_index_ > 0 || recommended_pass_indices_.count(next_pass_index_) == 0) && "The first pass in the loop should not be a recommendation."); assert(static_cast(applied_transformations.transformation_size()) >= num_transformations_applied_before_last_pass_choice_ && "The number of applied transformations should not decrease."); if (num_transformations_applied_before_last_pass_choice_ == static_cast(applied_transformations.transformation_size())) { // The last pass that was applied did not lead to any new transformations. // We thus do not want to apply recommendations based on it, so we skip on // to the next non-recommended pass. while (recommended_pass_indices_.count(next_pass_index_)) { next_pass_index_ = (next_pass_index_ + 1) % static_cast(pass_loop_.size()); } } auto result = pass_loop_[next_pass_index_]; next_pass_index_ = (next_pass_index_ + 1) % static_cast(pass_loop_.size()); return result; } } // namespace fuzz } // namespace spvtools repeated_pass_manager_looped_with_recommendations.h000066400000000000000000000052641475742701700364470ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/pass_management// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_REPEATED_PASS_MANAGER_LOOPED_WITH_RECOMMENDATIONS_H_ #define SOURCE_FUZZ_REPEATED_PASS_MANAGER_LOOPED_WITH_RECOMMENDATIONS_H_ #include #include "source/fuzz/pass_management/repeated_pass_manager.h" #include "source/fuzz/pass_management/repeated_pass_recommender.h" namespace spvtools { namespace fuzz { // On construction, this pass manager creates a sequence of fuzzer passes which // is not changed thereafter. Passes from this sequence are served up in round // robin fashion each time ChoosePass is invoked - i.e., the sequence is a "pass // loop". // // The pass loop is constructed by repeatedly: // - Randomly adding an enabled pass // - Adding all recommended follow-on passes for this pass // and probabilistically terminating this process. class RepeatedPassManagerLoopedWithRecommendations : public RepeatedPassManager { public: RepeatedPassManagerLoopedWithRecommendations( FuzzerContext* fuzzer_context, RepeatedPassInstances* pass_instances, RepeatedPassRecommender* pass_recommender); ~RepeatedPassManagerLoopedWithRecommendations() override; FuzzerPass* ChoosePass(const protobufs::TransformationSequence& applied_transformations) override; private: // The loop of fuzzer passes to be applied, populated on construction. std::vector pass_loop_; // A set of indices into |pass_loop_| recording which passes are in the loop // because they are recommended based on previous passes in the loop. This // allows these recommended passes to be skipped if the passes they are // meant to amplify had no effect. std::unordered_set recommended_pass_indices_; // Used to detect when chosen passes have had no effect, so that their // associated recommendations are skipped. uint32_t num_transformations_applied_before_last_pass_choice_; // An index into |pass_loop_| specifying which pass should be served up next // time ChoosePass is invoked. uint32_t next_pass_index_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_REPEATED_PASS_MANAGER_LOOPED_WITH_RECOMMENDATIONS_H_ repeated_pass_manager_random_with_recommendations.cpp000066400000000000000000000047511475742701700370000ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/pass_management// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/pass_management/repeated_pass_manager_random_with_recommendations.h" namespace spvtools { namespace fuzz { RepeatedPassManagerRandomWithRecommendations:: RepeatedPassManagerRandomWithRecommendations( FuzzerContext* fuzzer_context, RepeatedPassInstances* pass_instances, RepeatedPassRecommender* pass_recommender) : RepeatedPassManager(fuzzer_context, pass_instances), pass_recommender_(pass_recommender), num_transformations_applied_before_last_pass_choice_(0), last_pass_choice_(nullptr) {} RepeatedPassManagerRandomWithRecommendations:: ~RepeatedPassManagerRandomWithRecommendations() = default; FuzzerPass* RepeatedPassManagerRandomWithRecommendations::ChoosePass( const protobufs::TransformationSequence& applied_transformations) { assert(static_cast(applied_transformations.transformation_size()) >= num_transformations_applied_before_last_pass_choice_ && "The number of applied transformations should not decrease."); if (last_pass_choice_ != nullptr && static_cast(applied_transformations.transformation_size()) > num_transformations_applied_before_last_pass_choice_) { // The last pass had some effect, so we make future recommendations based on // it. for (auto future_pass : pass_recommender_->GetFuturePassRecommendations(*last_pass_choice_)) { recommended_passes_.push_back(future_pass); } } FuzzerPass* result; if (recommended_passes_.empty() || GetFuzzerContext()->ChooseEven()) { auto& passes = GetPassInstances()->GetPasses(); result = passes[GetFuzzerContext()->RandomIndex(passes)].get(); } else { result = recommended_passes_.front(); recommended_passes_.pop_front(); } assert(result != nullptr && "A pass must have been chosen."); last_pass_choice_ = result; return result; } } // namespace fuzz } // namespace spvtools repeated_pass_manager_random_with_recommendations.h000066400000000000000000000051541475742701700364430ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/pass_management// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_REPEATED_PASS_MANAGER_RANDOM_WITH_RECOMMENDATIONS_H_ #define SOURCE_FUZZ_REPEATED_PASS_MANAGER_RANDOM_WITH_RECOMMENDATIONS_H_ #include #include "source/fuzz/pass_management/repeated_pass_manager.h" #include "source/fuzz/pass_management/repeated_pass_recommender.h" namespace spvtools { namespace fuzz { // This repeated pass manager uses a pass recommender to recommend future passes // each time a fuzzer pass is run. It keeps a queue of recommended passes. // // Each time a fuzzer pass is requested, the manager either selects an enabled // fuzzer pass at random, or selects the pass at the front of the recommendation // queue, removing it from the queue. The decision of which of these pass // selection methods to use is made randomly each time ChoosePass is called. // // Either way, recommended follow-on passes for the chosen pass are added to // the recommendation queue. class RepeatedPassManagerRandomWithRecommendations : public RepeatedPassManager { public: RepeatedPassManagerRandomWithRecommendations( FuzzerContext* fuzzer_context, RepeatedPassInstances* pass_instances, RepeatedPassRecommender* pass_recommender); ~RepeatedPassManagerRandomWithRecommendations() override; FuzzerPass* ChoosePass(const protobufs::TransformationSequence& applied_transformations) override; private: // The queue of passes that have been recommended based on previously-chosen // passes. std::deque recommended_passes_; // Used to recommend future passes. RepeatedPassRecommender* pass_recommender_; // Used to detect when chosen passes have had no effect, so that their // associated recommendations are skipped. uint32_t num_transformations_applied_before_last_pass_choice_; // The fuzzer pass returned last time ChoosePass() was called; nullptr if // ChoosePass() has not yet been called. FuzzerPass* last_pass_choice_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_REPEATED_PASS_MANAGER_RANDOM_WITH_RECOMMENDATIONS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/pass_management/repeated_pass_manager_simple.cpp000066400000000000000000000023211475742701700325550ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/pass_management/repeated_pass_manager_simple.h" namespace spvtools { namespace fuzz { RepeatedPassManagerSimple::RepeatedPassManagerSimple( FuzzerContext* fuzzer_context, RepeatedPassInstances* pass_instances) : RepeatedPassManager(fuzzer_context, pass_instances) {} RepeatedPassManagerSimple::~RepeatedPassManagerSimple() = default; FuzzerPass* RepeatedPassManagerSimple::ChoosePass( const protobufs::TransformationSequence& /*unused*/) { auto& passes = GetPassInstances()->GetPasses(); return passes[GetFuzzerContext()->RandomIndex(passes)].get(); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/pass_management/repeated_pass_manager_simple.h000066400000000000000000000025661475742701700322350ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_REPEATED_PASS_MANAGER_SIMPLE_H_ #define SOURCE_FUZZ_REPEATED_PASS_MANAGER_SIMPLE_H_ #include "source/fuzz/pass_management/repeated_pass_manager.h" namespace spvtools { namespace fuzz { // Selects the next pass to run uniformly at random from the enabled repeated // passes. Recommendations are not used. class RepeatedPassManagerSimple : public RepeatedPassManager { public: RepeatedPassManagerSimple(FuzzerContext* fuzzer_context, RepeatedPassInstances* pass_instances); ~RepeatedPassManagerSimple() override; FuzzerPass* ChoosePass(const protobufs::TransformationSequence& applied_transformations) override; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_REPEATED_PASS_MANAGER_SIMPLE_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/pass_management/repeated_pass_recommender.cpp000066400000000000000000000014511475742701700320750ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/pass_management/repeated_pass_recommender.h" namespace spvtools { namespace fuzz { RepeatedPassRecommender::~RepeatedPassRecommender() = default; } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/pass_management/repeated_pass_recommender.h000066400000000000000000000025651475742701700315510ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_REPEATED_PASS_RECOMMENDER_H_ #define SOURCE_FUZZ_REPEATED_PASS_RECOMMENDER_H_ #include #include "source/fuzz/fuzzer_pass.h" namespace spvtools { namespace fuzz { // Interface for influencing interactions between repeated fuzzer passes, by // allowing hints as to which passes are recommended to be run after one // another. class RepeatedPassRecommender { public: virtual ~RepeatedPassRecommender(); // Given a reference to a repeated pass, |pass|, returns a sequence of // repeated pass instances that might be worth running soon after having // run |pass|. virtual std::vector GetFuturePassRecommendations( const FuzzerPass& pass) = 0; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_REPEATED_PASS_RECOMMENDER_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/pass_management/repeated_pass_recommender_standard.cpp000066400000000000000000000415471475742701700337670ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/pass_management/repeated_pass_recommender_standard.h" #include namespace spvtools { namespace fuzz { RepeatedPassRecommenderStandard::RepeatedPassRecommenderStandard( RepeatedPassInstances* pass_instances, FuzzerContext* fuzzer_context) : pass_instances_(pass_instances), fuzzer_context_(fuzzer_context) {} RepeatedPassRecommenderStandard::~RepeatedPassRecommenderStandard() = default; std::vector RepeatedPassRecommenderStandard::GetFuturePassRecommendations( const FuzzerPass& pass) { if (&pass == pass_instances_->GetAddAccessChains()) { // - Adding access chains means there is more scope for loading and storing // - It could be worth making more access chains from the recently-added // access chains return RandomOrderAndNonNull({pass_instances_->GetAddLoads(), pass_instances_->GetAddStores(), pass_instances_->GetAddAccessChains()}); } if (&pass == pass_instances_->GetAddBitInstructionSynonyms()) { // - Adding bit instruction synonyms creates opportunities to apply synonyms return RandomOrderAndNonNull({pass_instances_->GetApplyIdSynonyms()}); } if (&pass == pass_instances_->GetAddCompositeExtract()) { // - This transformation can introduce synonyms to the fact manager. return RandomOrderAndNonNull({pass_instances_->GetApplyIdSynonyms()}); } if (&pass == pass_instances_->GetAddCompositeInserts()) { // - Having added inserts we will have more vectors, so there is scope for // vector shuffling // - Adding inserts creates synonyms, which we should try to use // - Vector inserts can be made dynamic return RandomOrderAndNonNull( {pass_instances_->GetAddVectorShuffleInstructions(), pass_instances_->GetApplyIdSynonyms(), pass_instances_->GetMakeVectorOperationsDynamic()}); } if (&pass == pass_instances_->GetAddCompositeTypes()) { // - More composite types gives more scope for constructing composites return RandomOrderAndNonNull({pass_instances_->GetConstructComposites()}); } if (&pass == pass_instances_->GetAddCopyMemory()) { // - Recently-added copy memories could be replace with load-store pairs return RandomOrderAndNonNull( {pass_instances_->GetReplaceCopyMemoriesWithLoadsStores()}); } if (&pass == pass_instances_->GetAddDeadBlocks()) { // - Dead blocks are great for adding function calls // - Dead blocks are also great for adding loads and stores // - The guard associated with a dead block can be obfuscated // - Branches from dead blocks may be replaced with exits return RandomOrderAndNonNull( {pass_instances_->GetAddFunctionCalls(), pass_instances_->GetAddLoads(), pass_instances_->GetAddStores(), pass_instances_->GetObfuscateConstants(), pass_instances_->GetReplaceBranchesFromDeadBlocksWithExits()}); } if (&pass == pass_instances_->GetAddDeadBreaks()) { // - The guard of the dead break is a good candidate for obfuscation return RandomOrderAndNonNull({pass_instances_->GetObfuscateConstants()}); } if (&pass == pass_instances_->GetAddDeadContinues()) { // - The guard of the dead continue is a good candidate for obfuscation return RandomOrderAndNonNull({pass_instances_->GetObfuscateConstants()}); } if (&pass == pass_instances_->GetAddEquationInstructions()) { // - Equation instructions can create synonyms, which we can apply // - Equation instructions collaborate with one another to make synonyms, so // having added some it is worth adding more return RandomOrderAndNonNull( {pass_instances_->GetApplyIdSynonyms(), pass_instances_->GetAddEquationInstructions()}); } if (&pass == pass_instances_->GetAddFunctionCalls()) { // - Called functions can be inlined // - Irrelevant ids are created, so they can be replaced return RandomOrderAndNonNull({pass_instances_->GetInlineFunctions(), pass_instances_->GetReplaceIrrelevantIds()}); } if (&pass == pass_instances_->GetAddGlobalVariables()) { // - New globals provide new possibilities for making access chains // - We can load from and store to new globals return RandomOrderAndNonNull({pass_instances_->GetAddAccessChains(), pass_instances_->GetAddLoads(), pass_instances_->GetAddStores()}); } if (&pass == pass_instances_->GetAddImageSampleUnusedComponents()) { // - This introduces an unused component whose id is irrelevant and can be // replaced return RandomOrderAndNonNull({pass_instances_->GetReplaceIrrelevantIds()}); } if (&pass == pass_instances_->GetAddLoads()) { // - Loads might end up with corresponding stores, so that pairs can be // replaced with memory copies return RandomOrderAndNonNull( {pass_instances_->GetReplaceLoadsStoresWithCopyMemories()}); } if (&pass == pass_instances_->GetAddLocalVariables()) { // - New locals provide new possibilities for making access chains // - We can load from and store to new locals return RandomOrderAndNonNull({pass_instances_->GetAddAccessChains(), pass_instances_->GetAddLoads(), pass_instances_->GetAddStores()}); } if (&pass == pass_instances_->GetAddLoopPreheaders()) { // - The loop preheader provides more scope for duplicating regions and // outlining functions. return RandomOrderAndNonNull( {pass_instances_->GetDuplicateRegionsWithSelections(), pass_instances_->GetOutlineFunctions(), pass_instances_->GetWrapRegionsInSelections()}); } if (&pass == pass_instances_->GetAddLoopsToCreateIntConstantSynonyms()) { // - New synonyms can be applied return RandomOrderAndNonNull({pass_instances_->GetApplyIdSynonyms()}); } if (&pass == pass_instances_->GetAddOpPhiSynonyms()) { // - New synonyms can be applied // - If OpPhi synonyms are introduced for blocks with dead predecessors, the // values consumed from dead predecessors can be replaced return RandomOrderAndNonNull( {pass_instances_->GetApplyIdSynonyms(), pass_instances_->GetReplaceOpPhiIdsFromDeadPredecessors()}); } if (&pass == pass_instances_->GetAddParameters()) { // - We might be able to create interesting synonyms of new parameters. // - This introduces irrelevant ids, which can be replaced return RandomOrderAndNonNull({pass_instances_->GetAddSynonyms(), pass_instances_->GetReplaceIrrelevantIds()}); } if (&pass == pass_instances_->GetAddRelaxedDecorations()) { // - No obvious follow-on passes return {}; } if (&pass == pass_instances_->GetAddStores()) { // - Stores might end up with corresponding loads, so that pairs can be // replaced with memory copies return RandomOrderAndNonNull( {pass_instances_->GetReplaceLoadsStoresWithCopyMemories()}); } if (&pass == pass_instances_->GetAddSynonyms()) { // - New synonyms can be applied // - Synonym instructions use constants, which can be obfuscated // - Synonym instructions use irrelevant ids, which can be replaced // - Synonym instructions introduce addition/subtraction, which can be // replaced with carrying/extended versions return RandomOrderAndNonNull( {pass_instances_->GetApplyIdSynonyms(), pass_instances_->GetObfuscateConstants(), pass_instances_->GetReplaceAddsSubsMulsWithCarryingExtended(), pass_instances_->GetReplaceIrrelevantIds()}); } if (&pass == pass_instances_->GetAddVectorShuffleInstructions()) { // - Vector shuffles create synonyms that can be applied // - TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/3806) Extract // from composites. return RandomOrderAndNonNull({pass_instances_->GetApplyIdSynonyms()}); } if (&pass == pass_instances_->GetApplyIdSynonyms()) { // - No obvious follow-on passes return {}; } if (&pass == pass_instances_->GetConstructComposites()) { // - TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/3806): Extract // from composites. return RandomOrderAndNonNull({}); } if (&pass == pass_instances_->GetCopyObjects()) { // - Object copies create synonyms that can be applied // - OpCopyObject can be replaced with a store/load pair return RandomOrderAndNonNull( {pass_instances_->GetApplyIdSynonyms(), pass_instances_->GetReplaceCopyObjectsWithStoresLoads()}); } if (&pass == pass_instances_->GetDonateModules()) { // - New functions in the module can be called // - Donated dead functions produce irrelevant ids, which can be replaced // - Donated functions are good candidates for having their returns merged // - Donated dead functions may allow branches to be replaced with exits return RandomOrderAndNonNull( {pass_instances_->GetAddFunctionCalls(), pass_instances_->GetReplaceIrrelevantIds(), pass_instances_->GetMergeFunctionReturns(), pass_instances_->GetReplaceBranchesFromDeadBlocksWithExits()}); } if (&pass == pass_instances_->GetDuplicateRegionsWithSelections()) { // - Parts of duplicated regions can be outlined return RandomOrderAndNonNull({pass_instances_->GetOutlineFunctions()}); } if (&pass == pass_instances_->GetExpandVectorReductions()) { // - Adding OpAny and OpAll synonyms creates opportunities to apply synonyms return RandomOrderAndNonNull({pass_instances_->GetApplyIdSynonyms()}); } if (&pass == pass_instances_->GetFlattenConditionalBranches()) { // - Parts of flattened selections can be outlined // - The flattening transformation introduces constants and irrelevant ids // for enclosing hard-to-flatten operations; these can be obfuscated or // replaced return RandomOrderAndNonNull({pass_instances_->GetObfuscateConstants(), pass_instances_->GetOutlineFunctions(), pass_instances_->GetReplaceIrrelevantIds()}); } if (&pass == pass_instances_->GetInlineFunctions()) { // - Parts of inlined functions can be outlined again return RandomOrderAndNonNull({pass_instances_->GetOutlineFunctions()}); } if (&pass == pass_instances_->GetInvertComparisonOperators()) { // - No obvious follow-on passes return {}; } if (&pass == pass_instances_->GetMakeVectorOperationsDynamic()) { // - No obvious follow-on passes return {}; } if (&pass == pass_instances_->GetMergeBlocks()) { // - Having merged some blocks it may be interesting to split them in a // different way return RandomOrderAndNonNull({pass_instances_->GetSplitBlocks()}); } if (&pass == pass_instances_->GetMergeFunctionReturns()) { // - Functions without early returns are more likely to be able to be // inlined. return RandomOrderAndNonNull({pass_instances_->GetInlineFunctions()}); } if (&pass == pass_instances_->GetMutatePointers()) { // - This creates irrelevant ids, which can be replaced return RandomOrderAndNonNull({pass_instances_->GetReplaceIrrelevantIds()}); } if (&pass == pass_instances_->GetObfuscateConstants()) { // - No obvious follow-on passes return {}; } if (&pass == pass_instances_->GetOutlineFunctions()) { // - This creates more functions, which can be called // - Inlining the function for the region that was outlined might also be // fruitful; it will be inlined in a different form return RandomOrderAndNonNull({pass_instances_->GetAddFunctionCalls(), pass_instances_->GetInlineFunctions()}); } if (&pass == pass_instances_->GetPermuteBlocks()) { // No obvious follow-on passes return {}; } if (&pass == pass_instances_->GetPermuteFunctionParameters()) { // No obvious follow-on passes return {}; } if (&pass == pass_instances_->GetPermuteInstructions()) { // No obvious follow-on passes return {}; } if (&pass == pass_instances_->GetPropagateInstructionsDown()) { // - This fuzzer pass might create new synonyms that can later be applied. // - This fuzzer pass might create irrelevant ids that can later be // replaced. return RandomOrderAndNonNull({pass_instances_->GetApplyIdSynonyms(), pass_instances_->GetReplaceIrrelevantIds()}); } if (&pass == pass_instances_->GetPropagateInstructionsUp()) { // No obvious follow-on passes return {}; } if (&pass == pass_instances_->GetPushIdsThroughVariables()) { // - This pass creates synonyms, so it is worth applying them return RandomOrderAndNonNull({pass_instances_->GetApplyIdSynonyms()}); } if (&pass == pass_instances_->GetReplaceAddsSubsMulsWithCarryingExtended()) { // No obvious follow-on passes return {}; } if (&pass == pass_instances_->GetReplaceBranchesFromDeadBlocksWithExits()) { // - Changing a branch to OpReturnValue introduces an irrelevant id, which // can be replaced return RandomOrderAndNonNull({pass_instances_->GetReplaceIrrelevantIds()}); } if (&pass == pass_instances_->GetReplaceCopyMemoriesWithLoadsStores()) { // No obvious follow-on passes return {}; } if (&pass == pass_instances_->GetReplaceCopyObjectsWithStoresLoads()) { // - We may end up with load/store pairs that could be used to create memory // copies return RandomOrderAndNonNull( {pass_instances_->GetReplaceLoadsStoresWithCopyMemories()}); } if (&pass == pass_instances_->GetReplaceIrrelevantIds()) { // No obvious follow-on passes return {}; } if (&pass == pass_instances_->GetReplaceLinearAlgebraInstructions()) { // No obvious follow-on passes return {}; } if (&pass == pass_instances_->GetReplaceLoadsStoresWithCopyMemories()) { // No obvious follow-on passes return {}; } if (&pass == pass_instances_->GetReplaceOpPhiIdsFromDeadPredecessors()) { // No obvious follow-on passes return {}; } if (&pass == pass_instances_->GetReplaceOpSelectsWithConditionalBranches()) { // No obvious follow-on passes return {}; } if (&pass == pass_instances_->GetReplaceParameterWithGlobal()) { // No obvious follow-on passes return {}; } if (&pass == pass_instances_->GetReplaceParamsWithStruct()) { // No obvious follow-on passes return {}; } if (&pass == pass_instances_->GetSplitBlocks()) { // - More blocks means more chances for adding dead breaks/continues, and // for adding dead blocks return RandomOrderAndNonNull({pass_instances_->GetAddDeadBreaks(), pass_instances_->GetAddDeadContinues(), pass_instances_->GetAddDeadBlocks()}); } if (&pass == pass_instances_->GetSwapBranchConditionalOperands()) { // No obvious follow-on passes return {}; } if (&pass == pass_instances_->GetWrapRegionsInSelections()) { // - This pass uses an irrelevant boolean constant - we can replace it with // something more interesting. // - We can obfuscate that very constant as well. // - We can flatten created selection construct. return RandomOrderAndNonNull( {pass_instances_->GetObfuscateConstants(), pass_instances_->GetReplaceIrrelevantIds(), pass_instances_->GetFlattenConditionalBranches()}); } if (&pass == pass_instances_->GetWrapVectorSynonym()) { // This transformation introduces synonym facts and irrelevant ids. return RandomOrderAndNonNull({pass_instances_->GetApplyIdSynonyms(), pass_instances_->GetReplaceIrrelevantIds()}); } assert(false && "Unreachable: every fuzzer pass should be dealt with."); return {}; } std::vector RepeatedPassRecommenderStandard::RandomOrderAndNonNull( const std::vector& passes) { std::vector indices(passes.size()); std::iota(indices.begin(), indices.end(), 0); std::vector result; while (!indices.empty()) { FuzzerPass* maybe_pass = passes[fuzzer_context_->RemoveAtRandomIndex(&indices)]; if (maybe_pass != nullptr && fuzzer_context_->ChoosePercentage( fuzzer_context_ ->GetChanceOfAcceptingRepeatedPassRecommendation())) { result.push_back(maybe_pass); } } return result; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/pass_management/repeated_pass_recommender_standard.h000066400000000000000000000033521475742701700334240ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_REPEATED_PASS_RECOMMENDER_STANDARD_H_ #define SOURCE_FUZZ_REPEATED_PASS_RECOMMENDER_STANDARD_H_ #include "source/fuzz/fuzzer_context.h" #include "source/fuzz/pass_management/repeated_pass_instances.h" #include "source/fuzz/pass_management/repeated_pass_recommender.h" namespace spvtools { namespace fuzz { // A manually-crafter recommender of repeated passes, designed based on // knowledge of how the various fuzzer passes work and speculation as to how // they might interact in interesting ways. class RepeatedPassRecommenderStandard : public RepeatedPassRecommender { public: RepeatedPassRecommenderStandard(RepeatedPassInstances* pass_instances, FuzzerContext* fuzzer_context); ~RepeatedPassRecommenderStandard(); std::vector GetFuturePassRecommendations( const FuzzerPass& pass) override; private: std::vector RandomOrderAndNonNull( const std::vector& passes); RepeatedPassInstances* pass_instances_; FuzzerContext* fuzzer_context_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_REPEATED_PASS_RECOMMENDER_STANDARD_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/protobufs/000077500000000000000000000000001475742701700230525ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/protobufs/spirvfuzz_protobufs.h000066400000000000000000000045601475742701700274150ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_SPIRVFUZZ_PROTOBUFS_H_ #define SOURCE_FUZZ_SPIRVFUZZ_PROTOBUFS_H_ // This header file serves to act as a barrier between the protobuf header // files and files that include them. It uses compiler pragmas to disable // diagnostics, in order to ignore warnings generated during the processing // of these header files without having to compromise on freedom from warnings // in the rest of the project. #ifndef GOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL_INLINE #define GOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL_INLINE 1 #endif #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wunknown-warning-option" // Must come first #pragma clang diagnostic ignored "-Wreserved-identifier" #pragma clang diagnostic ignored "-Wshadow" #pragma clang diagnostic ignored "-Wsuggest-destructor-override" #pragma clang diagnostic ignored "-Wunused-parameter" #pragma clang diagnostic ignored "-Wc++98-compat-extra-semi" #pragma clang diagnostic ignored "-Wshorten-64-to-32" #elif defined(__GNUC__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wshadow" #pragma GCC diagnostic ignored "-Wunused-parameter" #elif defined(_MSC_VER) #pragma warning(push) #pragma warning(disable : 4244) #endif // The following should be the only place in the project where protobuf files // are directly included. This is so that they can be compiled in a manner // where warnings are ignored. #include "google/protobuf/util/json_util.h" #include "google/protobuf/util/message_differencer.h" #include "source/fuzz/protobufs/spvtoolsfuzz.pb.h" #if defined(__clang__) #pragma clang diagnostic pop #elif defined(__GNUC__) #pragma GCC diagnostic pop #elif defined(_MSC_VER) #pragma warning(pop) #endif #endif // SOURCE_FUZZ_SPIRVFUZZ_PROTOBUFS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/protobufs/spvtoolsfuzz.proto000066400000000000000000002421371475742701700267600ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // This file is specifically named spvtools_fuzz.proto so that the string // 'spvtools_fuzz' appears in the names of global-scope symbols that protoc // generates when targeting C++. This is to reduce the potential for name // clashes with other globally-scoped symbols. syntax = "proto3"; package spvtools.fuzz.protobufs; message UInt32Pair { // A pair of uint32s; useful for defining mappings. uint32 first = 1; uint32 second = 2; } message InstructionDescriptor { // Describes an instruction in some block of a function with respect to a // base instruction. // The id of an instruction after which the instruction being described is // believed to be located. It might be the using instruction itself. uint32 base_instruction_result_id = 1; // The opcode for the instruction being described. uint32 target_instruction_opcode = 2; // The number of matching opcodes to skip over when searching from the base // instruction to the instruction being described. uint32 num_opcodes_to_ignore = 3; } message IdUseDescriptor { // Describes a use of an id as an input operand to an instruction in some // block of a function. // Example: // - id_of_interest = 42 // - enclosing_instruction = ( // base_instruction_result_id = 50, // target_instruction_opcode = OpStore // num_opcodes_to_ignore = 7 // ) // - in_operand_index = 1 // represents a use of id 42 as input operand 1 to an OpStore instruction, // such that the OpStore instruction can be found in the same basic block as // the instruction with result id 50, and in particular is the 8th OpStore // instruction found from instruction 50 onwards (i.e. 7 OpStore // instructions are skipped). // An id that we would like to be able to find a use of. uint32 id_of_interest = 1; // The input operand index at which the use is expected. InstructionDescriptor enclosing_instruction = 2; uint32 in_operand_index = 3; } message DataDescriptor { // Represents a data element that can be accessed from an id, by walking the // type hierarchy via a sequence of 0 or more indices. // // Very similar to a UniformBufferElementDescriptor, except that a // DataDescriptor is rooted at the id of a scalar or composite. // The object being accessed - a scalar or composite uint32 object = 1; // 0 or more indices, used to index into a composite object repeated uint32 index = 2; } message UniformBufferElementDescriptor { // Represents a data element inside a uniform buffer. The element is // specified via (a) the result id of a uniform variable in which the element // is contained, and (b) a series of indices that need to be followed to get // to the element (via fields and array/vector indices). // // Example: suppose there is a uniform variable with descriptor set 7 and // binding 9, and that the uniform variable has the following type (using // GLSL-like syntax): // // struct S { // float f; // vec3 g; // int4 h[10]; // }; // // Then: // - (7, 9, [0]) describes the 'f' field. // - (7, 9, [1,1]) describes the y component of the 'g' field. // - (7, 9, [2,7,3]) describes the w component of element 7 of the 'h' field // The descriptor set and binding associated with a uniform variable. uint32 descriptor_set = 1; uint32 binding = 2; // An ordered sequence of indices through composite structures in the // uniform buffer. repeated uint32 index = 3; } message InstructionOperand { // Represents an operand to a SPIR-V instruction. // The type of the operand. uint32 operand_type = 1; // The data associated with the operand. For most operands (e.g. ids, // storage classes and literals) this will be a single word. repeated uint32 operand_data = 2; } message Instruction { // Represents a SPIR-V instruction. // The instruction's opcode (e.g. OpLabel). uint32 opcode = 1; // The id of the instruction's result type; 0 if there is no result type. uint32 result_type_id = 2; // The id of the instruction's result; 0 if there is no result. uint32 result_id = 3; // Zero or more input operands. repeated InstructionOperand input_operand = 4; } message FactSequence { repeated Fact fact = 1; } message Fact { oneof fact { // Order the fact options by numeric id (rather than alphabetically). FactConstantUniform constant_uniform_fact = 1; FactDataSynonym data_synonym_fact = 2; FactBlockIsDead block_is_dead_fact = 3; FactFunctionIsLivesafe function_is_livesafe_fact = 4; FactPointeeValueIsIrrelevant pointee_value_is_irrelevant_fact = 5; FactIdEquation id_equation_fact = 6; FactIdIsIrrelevant id_is_irrelevant = 7; } } // Keep fact message types in alphabetical order: message FactBlockIsDead { // Records the fact that a block is guaranteed to be dynamically unreachable. // This is useful because it informs the fuzzer that rather arbitrary changes // can be made to this block. uint32 block_id = 1; } message FactConstantUniform { // Records the fact that a uniform buffer element is guaranteed to be equal // to a particular constant value. spirv-fuzz can use such guarantees to // obfuscate code, e.g. to manufacture an expression that will (due to the // guarantee) evaluate to a particular value at runtime but in a manner that // cannot be predicted at compile-time. // An element of a uniform buffer UniformBufferElementDescriptor uniform_buffer_element_descriptor = 1; // The words of the associated constant repeated uint32 constant_word = 2; } message FactDataSynonym { // Records the fact that the data held in two data descriptors are guaranteed // to be equal. spirv-fuzz can use this to replace uses of one piece of data // with a known-to-be-equal piece of data. // Data descriptors guaranteed to hold identical data. DataDescriptor data1 = 1; DataDescriptor data2 = 2; } message FactFunctionIsLivesafe { // Records the fact that a function is guaranteed to be "livesafe", meaning // that it will not make out-of-bounds accesses, does not contain reachable // OpKill or OpUnreachable instructions, does not contain loops that will // execute for large numbers of iterations, and only invokes other livesafe // functions. uint32 function_id = 1; } message FactIdEquation { // Records the fact that the equation: // // lhs_id = opcode rhs_id[0] rhs_id[1] ... rhs_id[N-1] // // holds; e.g. that the equation: // // %12 = OpIAdd %13 %14 // // holds in the case where lhs_id is 12, rhs_id is [13, 14], and the opcode is // OpIAdd. // The left-hand-side of the equation. uint32 lhs_id = 1; // A SPIR-V opcode, from a restricted set of instructions for which equation // facts make sense. uint32 opcode = 2; // The operands to the right-hand-side of the equation. repeated uint32 rhs_id = 3; } message FactIdIsIrrelevant { // Records a fact that |result_id| is irrelevant (i.e. it's usage doesn't // change the semantics of the module). This implies that a use of this id // can later be replaced with some other id of the same type, or the // definition of |result_id| can be changed so that it yields a different value. // An irrelevant id. uint32 result_id = 1; } message FactPointeeValueIsIrrelevant { // Records the fact that value of the data pointed to by a pointer id does // not influence the observable behaviour of the module. This means that // arbitrary stores can be made through the pointer, and that nothing can be // guaranteed about the values that are loaded via the pointer. // A result id of pointer type uint32 pointer_id = 1; } message AccessChainClampingInfo { // When making a function livesafe it is necessary to clamp the indices that // occur as operands to access chain instructions so that they are guaranteed // to be in bounds. This message type allows an access chain instruction to // have an associated sequence of ids that are reserved for comparing an // access chain index with a bound (e.g. an array size), and selecting // between the access chain index (if it is within bounds) and the bound (if // it is not). // // This allows turning an instruction of the form: // // %result = OpAccessChain %type %object ... %index ... // // into: // // %t1 = OpULessThanEqual %bool %index %bound_minus_one // %t2 = OpSelect %int_type %t1 %index %bound_minus_one // %result = OpAccessChain %type %object ... %t2 ... // The result id of an OpAccessChain or OpInBoundsAccessChain instruction. uint32 access_chain_id = 1; // A series of pairs of fresh ids, one per access chain index, for the results // of a compare instruction and a select instruction, serving the roles of %t1 // and %t2 in the above example. repeated UInt32Pair compare_and_select_ids = 2; } message SideEffectWrapperInfo { // When flattening a conditional branch, it is necessary to enclose // instructions that have side effects inside conditionals, so that // they are only executed if the condition holds. Otherwise, there // might be unintended changes in memory, or crashes that would not // originally happen. // For example, the instruction %id = OpLoad %type %ptr, found in // the true branch of the conditional, will be enclosed in a new // conditional (assuming that the block containing it can be split // around it) as follows: // // [previous instructions in the block] // OpSelectionMerge %merge_block_id None // OpBranchConditional %cond %execute_block_id %alternative_block_id // %execute_block_id = OpLabel // %actual_result_id = OpLoad %type %ptr // OpBranch %merge_block_id // %alternative_block_id = OpLabel // %placeholder_result_id = OpCopyObject %type %value_to_copy_id // OpBranch %merge_block_id // %merge_block_id = OpLabel // %id = OpPhi %type %actual_result_id %execute_block_id %placeholder_result_id %alternative_block_id // [following instructions from the original block] // // If the instruction does not have a result id, this is simplified. // For example, OpStore %ptr %value, found in the true branch of a // conditional, is enclosed as follows: // // [previous instructions in the block] // OpSelectionMerge %merge_block None // OpBranchConditional %cond %execute_block_id %merge_block_id // %execute_block_id = OpLabel // OpStore %ptr %value // OpBranch %merge_block_id // %merge_block_id = OpLabel // [following instructions from the original block] // // The same happens if the instruction is found in the false branch // of the conditional being flattened, except that the label ids in // the OpBranchConditional are swapped. // An instruction descriptor for identifying the instruction to be // enclosed inside a conditional. An instruction descriptor is // necessary because the instruction might not have a result id. InstructionDescriptor instruction = 1; // A fresh id for the new merge block. uint32 merge_block_id = 2; // A fresh id for the new block where the actual instruction is // executed. uint32 execute_block_id = 3; // The following fields are only needed if the original instruction has a // result id. They can be set to 0 if not needed. // A fresh id for the result id of the instruction (the original // one is used by the OpPhi instruction). uint32 actual_result_id = 4; // A fresh id for the new block where the placeholder instruction // is placed. uint32 alternative_block_id = 5; // A fresh id for the placeholder instruction. uint32 placeholder_result_id = 6; // An id present in the module, available to use at this point in // the program and with the same type as the original instruction, // that can be used to create a placeholder OpCopyObject // instruction. uint32 value_to_copy_id = 7; } message ReturnMergingInfo { // TransformationMergeFunctionReturns needs to modify each merge block of // loops containing return instructions, by: // - adding instructions to decide whether the function is returning // - adding instructions to pass on the return value of the function, // if it is returning // - changing the branch instruction (which must be an unconditional branch) // to a conditional branch that, if the function is returning, branches to // the merge block of the innermost loop that contains this merge block // (which can be the new merge block introduced by the transformation). // // One such merge block of the form: // %block = OpLabel // %phi1 = OpPhi %type1 %val1_1 %pred1 %val1_2 %pred2 // %phi2 = OpPhi %type2 %val2_1 %pred1 %val2_2 %pred2 // OpBranch %next // // is transformed into: // %block = OpLabel // %is_returning_id = OpPhi %bool %false %pred1 %false %pred2 %true %ret_bb1 %is_bb2_returning %mer_bb2 // %maybe_return_val_id = OpPhi %return_type %any_returnable_val %pred1 %any_returnable_val %pred2 // %ret_val1 %ret_bb1 %ret_val2 %mer_bb2 // %phi1 = OpPhi %type1 %val1_1 %pred1 %val1_2 %pred2 // %any_suitable_id_1 %ret_bb1 %any_suitable_id_1 %mer_bb2 // %phi2 = OpPhi %type2 %val2_1 %pred1 %val2_2 %pred2 // %any_suitable_id_1 %ret_bb1 %any_suitable_id_1 %mer_bb2 // OpBranchConditional %is_returning_id %innermost_loop_merge %next // // where %ret_bb1 is a block that originally contains a return instruction and %mer_bb2 is the merge block of an inner // loop, from where the function might be returning. // // Note that the block is required to only have OpLabel, OpPhi or OpBranch instructions. // The id of the merge block that needs to be modified. uint32 merge_block_id = 1; // A fresh id for a boolean OpPhi whose value will be true iff the function // is returning. This will be used to decide whether to break out of the loop // or to use the original branch of the function. This value will also be // used by the merge block of the enclosing loop (if there is one) if the // function is returning from this block. uint32 is_returning_id = 2; // A fresh id that will get the value being returned, if the function is // returning. If the function return type is void, this is ignored. uint32 maybe_return_val_id = 3; // A mapping from each existing OpPhi id to a suitable id of the same type // available to use before the instruction. repeated UInt32Pair opphi_to_suitable_id = 4; } message LoopLimiterInfo { // Structure capturing the information required to manipulate a loop limiter // at a loop header. // The header for the loop. uint32 loop_header_id = 1; // A fresh id into which the loop limiter's current value can be loaded. uint32 load_id = 2; // A fresh id that can be used to increment the loaded value by 1. uint32 increment_id = 3; // A fresh id that can be used to compare the loaded value with the loop // limit. uint32 compare_id = 4; // A fresh id that can be used to compute the conjunction or disjunction of // an original loop exit condition with |compare_id|, if the loop's back edge // block can conditionally exit the loop. uint32 logical_op_id = 5; // A sequence of ids suitable for extending OpPhi instructions of the loop // merge block if it did not previously have an incoming edge from the loop // back edge block. repeated uint32 phi_id = 6; } message TransformationSequence { repeated Transformation transformation = 1; } message Transformation { oneof transformation { // Order the transformation options by numeric id (rather than // alphabetically). TransformationMoveBlockDown move_block_down = 1; TransformationSplitBlock split_block = 2; TransformationAddConstantBoolean add_constant_boolean = 3; TransformationAddConstantScalar add_constant_scalar = 4; TransformationAddTypeBoolean add_type_boolean = 5; TransformationAddTypeFloat add_type_float = 6; TransformationAddTypeInt add_type_int = 7; TransformationAddDeadBreak add_dead_break = 8; TransformationReplaceBooleanConstantWithConstantBinary replace_boolean_constant_with_constant_binary = 9; TransformationAddTypePointer add_type_pointer = 10; TransformationReplaceConstantWithUniform replace_constant_with_uniform = 11; TransformationAddDeadContinue add_dead_continue = 12; TransformationReplaceIdWithSynonym replace_id_with_synonym = 13; TransformationSetSelectionControl set_selection_control = 14; TransformationCompositeConstruct composite_construct = 15; TransformationSetLoopControl set_loop_control = 16; TransformationSetFunctionControl set_function_control = 17; TransformationAddNoContractionDecoration add_no_contraction_decoration = 18; TransformationSetMemoryOperandsMask set_memory_operands_mask = 19; TransformationCompositeExtract composite_extract = 20; TransformationVectorShuffle vector_shuffle = 21; TransformationOutlineFunction outline_function = 22; TransformationMergeBlocks merge_blocks = 23; TransformationAddTypeVector add_type_vector = 24; TransformationAddTypeArray add_type_array = 25; TransformationAddTypeMatrix add_type_matrix = 26; TransformationAddTypeStruct add_type_struct = 27; TransformationAddTypeFunction add_type_function = 28; TransformationAddConstantComposite add_constant_composite = 29; TransformationAddGlobalVariable add_global_variable = 30; TransformationAddGlobalUndef add_global_undef = 31; TransformationAddFunction add_function = 32; TransformationAddDeadBlock add_dead_block = 33; TransformationAddLocalVariable add_local_variable = 34; TransformationLoad load = 35; TransformationStore store = 36; TransformationFunctionCall function_call = 37; TransformationAccessChain access_chain = 38; TransformationEquationInstruction equation_instruction = 39; TransformationSwapCommutableOperands swap_commutable_operands = 40; TransformationPermuteFunctionParameters permute_function_parameters = 41; TransformationToggleAccessChainInstruction toggle_access_chain_instruction = 42; TransformationAddConstantNull add_constant_null = 43; TransformationComputeDataSynonymFactClosure compute_data_synonym_fact_closure = 44; TransformationAdjustBranchWeights adjust_branch_weights = 45; TransformationPushIdThroughVariable push_id_through_variable = 46; TransformationAddSpecConstantOp add_spec_constant_op = 47; TransformationReplaceLinearAlgebraInstruction replace_linear_algebra_instruction = 48; TransformationSwapConditionalBranchOperands swap_conditional_branch_operands = 49; TransformationPermutePhiOperands permute_phi_operands = 50; TransformationAddParameter add_parameter = 51; TransformationAddCopyMemory add_copy_memory = 52; TransformationInvertComparisonOperator invert_comparison_operator = 53; TransformationAddImageSampleUnusedComponents add_image_sample_unused_components = 54; TransformationReplaceParameterWithGlobal replace_parameter_with_global = 55; TransformationRecordSynonymousConstants record_synonymous_constants = 56; TransformationAddSynonym add_synonym = 57; TransformationAddRelaxedDecoration add_relaxed_decoration = 58; TransformationReplaceParamsWithStruct replace_params_with_struct = 59; TransformationReplaceCopyObjectWithStoreLoad replace_copy_object_with_store_load = 60; TransformationReplaceCopyMemoryWithLoadStore replace_copy_memory_with_load_store = 61; TransformationReplaceLoadStoreWithCopyMemory replace_load_store_with_copy_memory = 62; TransformationAddLoopPreheader add_loop_preheader = 63; TransformationMoveInstructionDown move_instruction_down = 64; TransformationMakeVectorOperationDynamic make_vector_operation_dynamic = 65; TransformationReplaceAddSubMulWithCarryingExtended replace_add_sub_mul_with_carrying_extended = 66; TransformationPropagateInstructionUp propagate_instruction_up = 67; TransformationCompositeInsert composite_insert = 68; TransformationInlineFunction inline_function = 69; TransformationAddOpPhiSynonym add_opphi_synonym = 70; TransformationMutatePointer mutate_pointer = 71; TransformationReplaceIrrelevantId replace_irrelevant_id = 72; TransformationReplaceOpPhiIdFromDeadPredecessor replace_opphi_id_from_dead_predecessor = 73; TransformationReplaceOpSelectWithConditionalBranch replace_opselect_with_conditional_branch = 74; TransformationDuplicateRegionWithSelection duplicate_region_with_selection = 75; TransformationFlattenConditionalBranch flatten_conditional_branch = 76; TransformationAddBitInstructionSynonym add_bit_instruction_synonym = 77; TransformationAddLoopToCreateIntConstantSynonym add_loop_to_create_int_constant_synonym = 78; TransformationWrapRegionInSelection wrap_region_in_selection = 79; TransformationAddEarlyTerminatorWrapper add_early_terminator_wrapper = 80; TransformationPropagateInstructionDown propagate_instruction_down = 81; TransformationReplaceBranchFromDeadBlockWithExit replace_branch_from_dead_block_with_exit = 82; TransformationWrapEarlyTerminatorInFunction wrap_early_terminator_in_function = 83; TransformationMergeFunctionReturns merge_function_returns = 84; TransformationExpandVectorReduction expand_vector_reduction = 85; TransformationSwapFunctionVariables swap_function_variables = 86; TransformationSwapTwoFunctions swap_two_functions = 87; TransformationWrapVectorSynonym wrap_vector_synonym = 88; // Add additional option using the next available number. } } // Keep transformation message types in alphabetical order: message TransformationAccessChain { // Adds an access chain instruction based on a given pointer and indices. // When accessing a struct, the corresponding indices must be 32-bit integer constants. // For any other composite, the indices can be any 32-bit integer, and the transformation // adds two instructions for each such index to clamp it to the bound, as follows: // // %t1 = OpULessThanEqual %bool %index %bound_minus_one // %t2 = OpSelect %int_type %t1 %index %bound_minus_one // Result id for the access chain uint32 fresh_id = 1; // The pointer from which the access chain starts uint32 pointer_id = 2; // Zero or more access chain indices repeated uint32 index_id = 3; // A descriptor for an instruction in a block before which the new // OpAccessChain instruction should be inserted InstructionDescriptor instruction_to_insert_before = 4; // Additional fresh ids, required to clamp index variables. A pair is needed // for each access to a non-struct composite. repeated UInt32Pair fresh_ids_for_clamping = 5; } message TransformationAddBitInstructionSynonym { // A transformation that adds synonyms for bit instructions by evaluating // each bit with the corresponding operation. There is a SPIR-V code example in the // header file of the transformation class that can help understand the transformation. // This transformation is only applicable if the described instruction has one of the following opcodes. // Supported: // OpBitwiseOr // OpBitwiseXor // OpBitwiseAnd // OpNot // To be supported in the future: // OpShiftRightLogical // OpShiftRightArithmetic // OpShiftLeftLogical // OpBitReverse // OpBitCount // The bit instruction result id. uint32 instruction_result_id = 1; // The fresh ids required to apply the transformation. repeated uint32 fresh_ids = 2; } message TransformationAddConstantBoolean { // Supports adding the constants true and false to a module, which may be // necessary in order to enable other transformations if they are not present. // Also, creates an IdIsIrrelevant fact about |fresh_id| if |is_irrelevant| is true. uint32 fresh_id = 1; bool is_true = 2; // If the constant should be marked as irrelevant. bool is_irrelevant = 3; } message TransformationAddConstantComposite { // Adds a constant of the given composite type to the module. // Also, creates an IdIsIrrelevant fact about |fresh_id| if // |is_irrelevant| is true. // Fresh id for the composite uint32 fresh_id = 1; // A composite type id uint32 type_id = 2; // Constituent ids for the composite repeated uint32 constituent_id = 3; // If the constant should be marked as irrelevant. bool is_irrelevant = 4; } message TransformationAddConstantNull { // Adds a null constant. // Id for the constant uint32 fresh_id = 1; // Type of the constant uint32 type_id = 2; } message TransformationAddConstantScalar { // Adds a constant of the given scalar type. // Also, creates an IdIsIrrelevant fact about // |fresh_id| if |is_irrelevant| is true. // Id for the constant uint32 fresh_id = 1; // Id for the scalar type of the constant uint32 type_id = 2; // Value of the constant repeated uint32 word = 3; // If the constant should be marked as irrelevant. bool is_irrelevant = 4; } message TransformationAddCopyMemory { // Adds an OpCopyMemory instruction into the module. // Creates either a global or a local variable (based on // |storage_class| field) to copy the target into. // OpCopyMemory will be inserted before this instruction. InstructionDescriptor instruction_descriptor = 1; // Fresh id to copy memory into. uint32 fresh_id = 2; // Source to copy memory from. uint32 source_id = 3; // Storage class for the target variable. Can be either Function or Private. uint32 storage_class = 4; // Result id for the variable's initializer operand. Its type must be equal to // variable's pointee type. uint32 initializer_id = 5; } message TransformationAddDeadBlock { // Adds a new block to the module that is statically reachable from an // existing block, but dynamically unreachable. // Fresh id for the dead block uint32 fresh_id = 1; // Id of an existing block terminated with OpBranch, such that this OpBranch // can be replaced with an OpBranchConditional to its exiting successor or // the dead block uint32 existing_block = 2; // Determines whether the condition associated with the OpBranchConditional // is true or false bool condition_value = 3; } message TransformationAddDeadBreak { // A transformation that turns a basic block that unconditionally branches to // its successor into a block that potentially breaks out of a structured // control flow construct, but in such a manner that the break cannot actually // be taken. // The block to break from uint32 from_block = 1; // The merge block to break to uint32 to_block = 2; // Determines whether the break condition is true or false bool break_condition_value = 3; // A sequence of ids suitable for extending OpPhi instructions as a result of // the new break edge repeated uint32 phi_id = 4; } message TransformationAddDeadContinue { // A transformation that turns a basic block appearing in a loop and that // unconditionally branches to its successor into a block that potentially // branches to the continue target of the loop, but in such a manner that the // continue branch cannot actually be taken. // The block to continue from uint32 from_block = 1; // Determines whether the continue condition is true or false bool continue_condition_value = 2; // A sequence of ids suitable for extending OpPhi instructions as a result of // the new break edge repeated uint32 phi_id = 3; } message TransformationAddEarlyTerminatorWrapper { // Adds a function to the module containing a single block with a single non- // label instruction that is either OpKill, OpUnreachable, or // OpTerminateInvocation. The purpose of this is to allow such instructions // to be subsequently replaced with wrapper functions, which can then enable // transformations (such as inlining) that are hard in the direct presence // of these instructions. // Fresh id for the function. uint32 function_fresh_id = 1; // Fresh id for the single basic block in the function. uint32 label_fresh_id = 2; // One of OpKill, OpUnreachable, OpTerminateInvocation. If additional early // termination instructions are added to SPIR-V they should also be handled // here. uint32 opcode = 3; } message TransformationAddFunction { // Adds a SPIR-V function to the module. // The series of instructions that comprise the function. repeated Instruction instruction = 1; // True if and only if the given function should be made livesafe (see // FactFunctionIsLivesafe for definition). bool is_livesafe = 2; // Fresh id for a new variable that will serve as a "loop limiter" for the // function; only relevant if |is_livesafe| holds. uint32 loop_limiter_variable_id = 3; // Id of an existing unsigned integer constant providing the maximum value // that the loop limiter can reach before the loop is broken from; only // relevant if |is_livesafe| holds. uint32 loop_limit_constant_id = 4; // Fresh ids for each loop in the function that allow the loop limiter to be // manipulated; only relevant if |is_livesafe| holds. repeated LoopLimiterInfo loop_limiter_info = 5; // Id of an existing global value with the same return type as the function // that can be used to replace OpKill and OpReachable instructions with // ReturnValue instructions. Ignored if the function has void return type. // Only relevant if |is_livesafe| holds. uint32 kill_unreachable_return_value_id = 6; // A mapping (represented as a sequence) from every access chain result id in // the function to the ids required to clamp its indices to ensure they are in // bounds; only relevant if |is_livesafe| holds. repeated AccessChainClampingInfo access_chain_clamping_info = 7; } message TransformationAddGlobalUndef { // Adds an undefined value of a given type to the module at global scope. // Fresh id for the undefined value uint32 fresh_id = 1; // The type of the undefined value uint32 type_id = 2; } message TransformationAddGlobalVariable { // Adds a global variable of the given type to the module, with Private or // Workgroup storage class, and optionally (for the Private case) with an // initializer. // Fresh id for the global variable uint32 fresh_id = 1; // The type of the global variable uint32 type_id = 2; uint32 storage_class = 3; // Initial value of the variable uint32 initializer_id = 4; // True if and only if the behaviour of the module should not depend on the // value of the variable, in which case stores to the variable can be // performed in an arbitrary fashion. bool value_is_irrelevant = 5; } message TransformationAddImageSampleUnusedComponents { // A transformation that adds unused components to an image sample coordinate. // An vector id with the original coordinate and the unused components. uint32 coordinate_with_unused_components_id = 1; // A descriptor for an image sample instruction. InstructionDescriptor instruction_descriptor = 2; } message TransformationAddLocalVariable { // Adds a local variable of the given type (which must be a pointer with // Function storage class) to the given function, initialized to the given // id. // Fresh id for the local variable uint32 fresh_id = 1; // The type of the local variable uint32 type_id = 2; // The id of the function to which the local variable should be added uint32 function_id = 3; // Initial value of the variable uint32 initializer_id = 4; // True if and only if the behaviour of the module should not depend on the // value of the variable, in which case stores to the variable can be // performed in an arbitrary fashion. bool value_is_irrelevant = 5; } message TransformationAddLoopPreheader { // A transformation that adds a loop preheader block before the given loop header. // The id of the loop header block uint32 loop_header_block = 1; // A fresh id for the preheader block uint32 fresh_id = 2; // Fresh ids for splitting the OpPhi instructions in the header. // A new OpPhi instruction in the preheader is needed for each OpPhi instruction in the header, // if the header has more than one predecessor outside of the loop. // This allows turning instructions of the form: // // %loop_header_block = OpLabel // %id1 = OpPhi %type %val1 %pred1_id %val2 %pred2_id %val3 %backedge_block_id // // into: // %fresh_id = OpLabel // %phi_id1 = OpPhi %type %val1 %pred1_id %val2 %pred2_id // OpBranch %header_id // %loop_header_block = OpLabel // %id1 = OpPhi %type %phi_id1 %fresh_id %val3 %backedge_block_id repeated uint32 phi_id = 3; } message TransformationAddLoopToCreateIntConstantSynonym { // A transformation that uses a loop to create a synonym for an integer // constant C (scalar or vector) using an initial value I, a step value S and // a number of iterations N such that C = I - N * S. For each iteration, S is // subtracted from the total. // The loop can be made up of one or two blocks, and it is inserted before a // block with a single predecessor. In the one-block case, it is of the form: // // %loop_id = OpLabel // %ctr_id = OpPhi %int %int_0 %pred %incremented_ctr_id %loop_id // %temp_id = OpPhi %type_of_I %I %pred %eventual_syn_id %loop_id // %eventual_syn_id = OpISub %type_of_I %temp_id %step_val_id // %incremented_ctr_id = OpIAdd %int %ctr_id %int_1 // %cond_id = OpSLessThan %bool %incremented_ctr_id %num_iterations_id // OpLoopMerge %block_after_loop_id %loop_id None // OpBranchConditional %cond_id %loop_id %block_after_loop_id // // A new OpPhi instruction is then added to %block_after_loop_id, as follows: // // %block_after_loop_id = OpLabel // %syn_id = OpPhi %type_of_I %eventual_syn_id %loop_id // // This can be translated, assuming that N > 0, to: // int syn = I; // for (int ctr = 0; ctr < N; ctr++) syn = syn - S; // // All existing OpPhi instructions in %block_after_loop_id are also updated // to reflect the fact that its predecessor is now %loop_id. // The following are existing ids. // The id of the integer constant C that we want a synonym of. uint32 constant_id = 1; // The id of the initial value integer constant I. uint32 initial_val_id = 2; // The id of the step value integer constant S. uint32 step_val_id = 3; // The id of the integer scalar constant, its value being the number of // iterations N. uint32 num_iterations_id = 4; // The label id of the block before which the loop must be inserted. uint32 block_after_loop_id = 5; // The following are fresh ids. // A fresh id for the synonym. uint32 syn_id = 6; // A fresh id for the label of the loop, uint32 loop_id = 7; // A fresh id for the counter. uint32 ctr_id = 8; // A fresh id taking the value I - S * ctr at the ctr-th iteration. uint32 temp_id = 9; // A fresh id taking the value I - S * (ctr + 1) at the ctr-th iteration, and // thus I - S * N at the last iteration. uint32 eventual_syn_id = 10; // A fresh id for the incremented counter. uint32 incremented_ctr_id = 11; // A fresh id for the loop condition. uint32 cond_id = 12; // The instructions in the loop can also be laid out in two basic blocks, as follows: // // %loop_id = OpLabel // %ctr_id = OpPhi %int %int_0 %pred %incremented_ctr_id %loop_id // %temp_id = OpPhi %type_of_I %I %pred %eventual_syn_id %loop_id // OpLoopMerge %block_after_loop_id %additional_block_id None // OpBranch %additional_block_id // // %additional_block_id = OpLabel // %eventual_syn_id = OpISub %type_of_I %temp_id %step_val_id // %incremented_ctr_id = OpIAdd %int %ctr_id %int_1 // %cond_id = OpSLessThan %bool %incremented_ctr_id %num_iterations_id // OpBranchConditional %cond_id %loop_id %block_after_loop_id // A fresh id for the additional block. If this is 0, it means that only one // block is to be created. uint32 additional_block_id = 13; } message TransformationAddNoContractionDecoration { // Applies OpDecorate NoContraction to the given result id // Result id to be decorated uint32 result_id = 1; } message TransformationAddOpPhiSynonym { // Adds an OpPhi instruction at the start of a block with n predecessors (pred_1, pred_2, ..., pred_n) // and n related ids (id_1, id_2, ..., id_n) which are pairwise synonymous. // The instruction will be of the form: // %fresh_id = OpPhi %type %id_1 %pred_1 %id_2 %pred_2 ... %id_n %pred_n // and fresh_id will be recorded as being synonymous with all the other ids. // Label id of the block uint32 block_id = 1; // Pairs (pred_i, id_i) repeated UInt32Pair pred_to_id = 2; // Fresh id for the new instruction uint32 fresh_id = 3; } message TransformationAddParameter { // Adds a new parameter into the function. // Result id of the function to add parameters to. uint32 function_id = 1; // Fresh id for a new parameter. uint32 parameter_fresh_id = 2; // Type id for a new parameter. uint32 parameter_type_id = 3; // A map that maps from the OpFunctionCall id to the id that will be passed as the new // parameter at that call site. It must have the same type as that of the new parameter. repeated UInt32Pair call_parameter_ids = 4; // A fresh id for a new function type. This might not be used // if a required function type already exists or if we can change // the old function type. uint32 function_type_fresh_id = 5; } message TransformationAddRelaxedDecoration { // Applies OpDecorate RelaxedPrecision to the given result id // Result id to be decorated uint32 result_id = 1; } message TransformationAddSpecConstantOp { // Adds OpSpecConstantOp into the module. // Result id for the new instruction. uint32 fresh_id = 1; // Type id for the new instruction. uint32 type_id = 2; // Opcode operand of the OpSpecConstantOp instruction. uint32 opcode = 3; // Operands of the |opcode| instruction. repeated InstructionOperand operand = 4; } message TransformationAddSynonym { // Adds a |synonymous_instruction| before |insert_before| instruction with // and creates a fact that |result_id| and the result id of |synonymous_instruction| // are synonymous. // Result id of the first synonym. uint32 result_id = 1; // Type of the synonym to apply. Some types might produce instructions // with commutative operands. Such types do not specify the order of the // operands since we have a special transformation to swap commutable operands. // // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/3499): // Consider adding more types here. enum SynonymType { // New synonym is derived by adding zero to the |result_id|. ADD_ZERO = 0; // New synonym is derived by subtracting zero from the |result_id|. SUB_ZERO = 1; // New synonym is derived by multiplying |result_id| by one. MUL_ONE = 2; // New synonym is derived by applying OpCopyObject instruction to |result_id|. COPY_OBJECT = 3; // New synonym is derived by applying OpLogicalOr to |result_id| with the second // operand being 'false'. LOGICAL_OR = 4; // New synonym is derived by applying OpLogicalAnd to |result_id| with the second // operand being 'true'. LOGICAL_AND = 5; // New synonym is derived by applying OpBitwiseOr to |result_id| with the second // operand being 0 taken with the same bit length as |result_id| BITWISE_OR = 6; // New synonym is derived by applying OpBitwiseXor to |result_id| with the second // operand being 0 taken with the same bit length as |result_id| BITWISE_XOR = 7; } // Type of the synonym to create. See SynonymType for more details. SynonymType synonym_type = 2; // Fresh result id for a created synonym. uint32 synonym_fresh_id = 3; // An instruction to insert a new synonym before. InstructionDescriptor insert_before = 4; } message TransformationAddTypeArray { // Adds an array type of the given element type and size to the module // Fresh id for the array type uint32 fresh_id = 1; // The array's element type uint32 element_type_id = 2; // The array's size uint32 size_id = 3; } message TransformationAddTypeBoolean { // Adds OpTypeBool to the module // Id to be used for the type uint32 fresh_id = 1; } message TransformationAddTypeFloat { // Adds OpTypeFloat to the module with the given width // Id to be used for the type uint32 fresh_id = 1; // Floating-point width uint32 width = 2; } message TransformationAddTypeFunction { // Adds a function type to the module // Fresh id for the function type uint32 fresh_id = 1; // The function's return type uint32 return_type_id = 2; // The function's argument types repeated uint32 argument_type_id = 3; } message TransformationAddTypeInt { // Adds OpTypeInt to the module with the given width and signedness // Id to be used for the type uint32 fresh_id = 1; // Integer width uint32 width = 2; // True if and only if this is a signed type bool is_signed = 3; } message TransformationAddTypeMatrix { // Adds a matrix type to the module // Fresh id for the matrix type uint32 fresh_id = 1; // The matrix's column type, which must be a floating-point vector (as per // the "data rules" in the SPIR-V specification). uint32 column_type_id = 2; // The matrix's column count uint32 column_count = 3; } message TransformationAddTypePointer { // Adds OpTypePointer to the module, with the given storage class and base // type // Id to be used for the type uint32 fresh_id = 1; // Pointer storage class uint32 storage_class = 2; // Id of the base type for the pointer uint32 base_type_id = 3; } message TransformationAddTypeStruct { // Adds a struct type to the module // Fresh id for the struct type uint32 fresh_id = 1; // The struct's member types repeated uint32 member_type_id = 3; } message TransformationAddTypeVector { // Adds a vector type to the module // Fresh id for the vector type uint32 fresh_id = 1; // The vector's component type uint32 component_type_id = 2; // The vector's component count uint32 component_count = 3; } message TransformationAdjustBranchWeights { // A transformation that adjusts the branch weights // of a branch conditional instruction. // A descriptor for a branch conditional instruction. InstructionDescriptor instruction_descriptor = 1; // Branch weights of a branch conditional instruction. UInt32Pair branch_weights = 2; } message TransformationCompositeConstruct { // A transformation that introduces an OpCompositeConstruct instruction to // make a composite object. // Id of the type of the composite that is to be constructed uint32 composite_type_id = 1; // Ids of the objects that will form the components of the composite repeated uint32 component = 2; // A descriptor for an instruction in a block before which the new // OpCompositeConstruct instruction should be inserted InstructionDescriptor instruction_to_insert_before = 3; // A fresh id for the composite object uint32 fresh_id = 4; } message TransformationCompositeExtract { // A transformation that adds an instruction to extract an element from a // composite. // A descriptor for an instruction in a block before which the new // OpCompositeExtract instruction should be inserted InstructionDescriptor instruction_to_insert_before = 1; // Result id for the extract operation. uint32 fresh_id = 2; // Id of the composite from which data is to be extracted. uint32 composite_id = 3; // Indices that indicate which part of the composite should be extracted. repeated uint32 index = 4; } message TransformationCompositeInsert { // A transformation that adds an instruction OpCompositeInsert which creates // a new composite from an existing composite, with an element inserted. // A descriptor for an instruction before which the new instruction // OpCompositeInsert should be inserted. InstructionDescriptor instruction_to_insert_before = 1; // Result id of the inserted OpCompositeInsert instruction. uint32 fresh_id = 2; // Id of the composite used as the basis for the insertion. uint32 composite_id = 3; // Id of the object to be inserted. uint32 object_id = 4; // Indices that indicate which part of the composite should be inserted into. repeated uint32 index = 5; } message TransformationComputeDataSynonymFactClosure { // A transformation that impacts the fact manager only, forcing a computation // of the closure of data synonym facts, so that e.g. if the components of // vectors v and w are known to be pairwise synonymous, it is deduced that v // and w are themselves synonymous. // When searching equivalence classes for implied facts, equivalence classes // larger than this size will be skipped. uint32 maximum_equivalence_class_size = 1; } message TransformationDuplicateRegionWithSelection { // A transformation that inserts a conditional statement with a boolean expression // of arbitrary value and duplicates a given single-entry, single-exit region, so // that it is present in each conditional branch and will be executed regardless // of which branch will be taken. // Fresh id for a label of the new entry block. uint32 new_entry_fresh_id = 1; // Id for a boolean expression. uint32 condition_id = 2; // Fresh id for a label of the merge block of the conditional. uint32 merge_label_fresh_id = 3; // Block id of the entry block of the original region. uint32 entry_block_id = 4; // Block id of the exit block of the original region. uint32 exit_block_id = 5; // Map that maps from a label in the original region to the corresponding label // in the duplicated region. repeated UInt32Pair original_label_to_duplicate_label = 6; // Map that maps from a result id in the original region to the corresponding // result id in the duplicated region. repeated UInt32Pair original_id_to_duplicate_id = 7; // Map that maps from a result id in the original region to the result id of the // corresponding OpPhi instruction. repeated UInt32Pair original_id_to_phi_id = 8; } message TransformationEquationInstruction { // A transformation that adds an instruction to the module that defines an // equation between its result id and input operand ids, such that the // equation is guaranteed to hold at any program point where all ids involved // are available (i.e. at any program point dominated by the instruction). // The result id of the new instruction uint32 fresh_id = 1; // The instruction's opcode uint32 opcode = 2; // The input operands to the instruction repeated uint32 in_operand_id = 3; // A descriptor for an instruction in a block before which the new // instruction should be inserted InstructionDescriptor instruction_to_insert_before = 4; } message TransformationExpandVectorReduction { // A transformation that adds synonyms for OpAny and OpAll instructions by // evaluating each vector component with the corresponding logical operation. // There is a SPIR-V code example in the header file of the transformation // class that can help understand the transformation. // The OpAny or OpAll instruction result id. uint32 instruction_result_id = 1; // The fresh ids required to apply the transformation. repeated uint32 fresh_ids = 2; } message TransformationFlattenConditionalBranch { // A transformation that takes a selection construct with a header // containing an OpBranchConditional instruction and flattens it. // For example, something of the form: // // %1 = OpLabel // [header instructions] // OpSelectionMerge %4 None // OpBranchConditional %cond %2 %3 // %2 = OpLabel // [true branch instructions] // OpBranch %4 // %3 = OpLabel // [false branch instructions] // OpBranch %4 // %4 = OpLabel // ... // // becomes: // // %1 = OpLabel // [header instructions] // OpBranch %2 // %2 = OpLabel // [true branch instructions] // OpBranch %3 // %3 = OpLabel // [false branch instructions] // OpBranch %4 // %4 = OpLabel // ... // // If all of the instructions in the true or false branches have // no side effects, this is semantics-preserving. // Side-effecting instructions will instead be enclosed by smaller // conditionals. For more details, look at the definition for the // SideEffectWrapperInfo message. // // Nested conditionals or loops are not supported. The false branch // could also be executed before the true branch, depending on the // |true_branch_first| field. // The label id of the header block uint32 header_block_id = 1; // A boolean field deciding the order in which the original branches // will be laid out: the true branch will be laid out first iff this // field is true. bool true_branch_first = 2; // If the convergence block contains an OpPhi with bvec2 result type, it may // be necessary to introduce a bvec2 with the selection construct's condition // in both components in order to turn the OpPhi into an OpSelect. This // this field provides a fresh id for an OpCompositeConstruct instruction for // this purpose. It should be set to 0 if no such instruction is required. uint32 fresh_id_for_bvec2_selector = 3; // The same as |fresh_id_for_bvec2_selector| but for the bvec3 case. uint32 fresh_id_for_bvec3_selector = 4; // The same as |fresh_id_for_bvec2_selector| but for the bvec4 case. uint32 fresh_id_for_bvec4_selector = 5; // A list of instructions with side effects, which must be enclosed // inside smaller conditionals before flattening the main one, and // the corresponding fresh ids and module ids needed. repeated SideEffectWrapperInfo side_effect_wrapper_info = 6; } message TransformationFunctionCall { // A transformation that introduces an OpFunctionCall instruction. The call // must not make the module's call graph cyclic. Beyond that, if the call // is in a dead block it can be to any function with arbitrary suitably-typed // arguments; otherwise it must be to a livesafe function, with injected // variables as pointer arguments and arbitrary non-pointer arguments. // A fresh id for the result of the call uint32 fresh_id = 1; // Id of the function to be called uint32 callee_id = 2; // Ids for arguments to the function repeated uint32 argument_id = 3; // A descriptor for an instruction in a block before which the new // OpFunctionCall instruction should be inserted InstructionDescriptor instruction_to_insert_before = 4; } message TransformationInlineFunction { // This transformation inlines a function by mapping the function instructions to fresh ids. // Result id of the function call instruction. uint32 function_call_id = 1; // For each result id defined by the called function, // this map provides an associated fresh id that can // be used in the inlined version of the function call. repeated UInt32Pair result_id_map = 2; } message TransformationInvertComparisonOperator { // For some instruction with result id |operator_id| that // represents a binary comparison operator (e.g. <, >, <=), this transformation // will replace that instruction's result id with |fresh_id|, // invert the opcode (< will become >=) and insert OpLogicalNot // instruction with result id |operator_id| below. // Result id of the instruction to invert. uint32 operator_id = 1; // Fresh id that will be used by the operator after the inversion. uint32 fresh_id = 2; } message TransformationLoad { // Transformation that adds an OpLoad or OpAtomicLoad instruction from a pointer into an id. // The result of the load instruction. uint32 fresh_id = 1; // The pointer to be loaded from. uint32 pointer_id = 2; // True if and only if the load should be atomic. bool is_atomic = 3; // The memory scope for the atomic load. Ignored unless |is_atomic| is true. uint32 memory_scope_id = 4; // The memory semantics for the atomic load. Ignored unless |is_atomic| is true. uint32 memory_semantics_id = 5; // A descriptor for an instruction in a block before which the new OpLoad // instruction should be inserted. InstructionDescriptor instruction_to_insert_before = 6; } message TransformationMakeVectorOperationDynamic { // A transformation that replaces the OpCompositeExtract and OpCompositeInsert // instructions with the OpVectorExtractDynamic and OpVectorInsertDynamic instructions. // The composite instruction result id. uint32 instruction_result_id = 1; // The OpCompositeExtract/Insert instructions accept integer literals as indices to the composite object. // However, the OpVectorInsert/ExtractDynamic instructions require its single index to be an integer instruction. // This is the result id of the integer instruction. uint32 constant_index_id = 2; } message TransformationMergeBlocks { // A transformation that merges a block with its predecessor. // The id of the block that is to be merged with its predecessor; the merged // block will have the *predecessor's* id. uint32 block_id = 1; } message TransformationMergeFunctionReturns { // A transformation that modifies a function so that it does not return early, // so it only has one return statement (ignoring unreachable blocks). // // The function is enclosed inside an outer loop, that is only executed once, // and whose merge block is the new return block of the function. // // Each return instruction is replaced by: // OpBranch %innermost_loop_merge // where %innermost_loop_merge is the innermost loop containing the return // instruction. // // Each merge block whose associated loop contains return instructions is // changed so that it branches to the merge block of the loop containing it, // as explained in the comments to the ReturnMergingInfo message. // // The new return block (the merge block of the new outer loop) will be of // the following form (if the return type is not void): // %outer_return_id = OpLabel // %return_val_id = OpPhi %return_type %val1 %block_1 %val2 %block_2 ... // OpReturnValue %return_val_id // where %block_k is either a return block that, in the original function, is // outside of any loops, or the merge block of a loop that contains return // instructions and is not, originally, nested inside another loop, and // %block_k is the corresponding return value. // If the function has void type, there will be no OpPhi instruction and the // last instruction will be OpReturn. // The id of the function to which the transformation is being applied. uint32 function_id = 1; // A fresh id for the header of the new outer loop. uint32 outer_header_id = 2; // A fresh id for an unreachable continue construct for the new outer loop. uint32 unreachable_continue_id = 7; // A fresh id for the new return block of the function, // i.e. the merge block of the new outer loop. uint32 outer_return_id = 3; // A fresh id for the value that will be returned. // This is ignored if the function has void return type. uint32 return_val_id = 4; // An existing id of the same type as the return value, which is // available to use at the end of the entry block. // This is ignored if the function has void return type or if no // loops in the function contain a return instruction. // If the function is not void, the transformation will add an // OpPhi instruction to each merge block whose associated loop // contains at least a return instruction. The value associated // with existing predecessors from which the function cannot be // returning will be this id, used as a placeholder. uint32 any_returnable_val_id = 5; // The information needed to modify the merge blocks of // loops containing return instructions. repeated ReturnMergingInfo return_merging_info = 6; } message TransformationMoveBlockDown { // A transformation that moves a basic block to be one position lower in // program order. // The id of the block to move down. uint32 block_id = 1; } message TransformationMoveInstructionDown { // Swaps |instruction| with the next instruction in the block. // The instruction to move down. InstructionDescriptor instruction = 1; } message TransformationMutatePointer { // Backs up value of the pointer, writes into the pointer and // restores the original value. // Result id of the pointer instruction to mutate. uint32 pointer_id = 1; // Fresh id for the OpLoad instruction. uint32 fresh_id = 2; // Instruction to insert backup, mutation and restoration code before. InstructionDescriptor insert_before = 3; } message TransformationOutlineFunction { // A transformation that outlines a single-entry single-exit region of a // control flow graph into a separate function, and replaces the region with // a call to that function. // Id of the entry block of the single-entry single-exit region to be outlined uint32 entry_block = 1; // Id of the exit block of the single-entry single-exit region to be outlined uint32 exit_block = 2; // Id of a struct that will store the return values of the new function uint32 new_function_struct_return_type_id = 3; // A fresh id for the type of the outlined function uint32 new_function_type_id = 4; // A fresh id for the outlined function itself uint32 new_function_id = 5; // A fresh id to represent the block in the outlined function that represents // the first block of the outlined region. uint32 new_function_region_entry_block = 6; // A fresh id for the result of the OpFunctionCall instruction that will call // the outlined function uint32 new_caller_result_id = 7; // A fresh id to capture the return value of the outlined function - the // argument to OpReturn uint32 new_callee_result_id = 8; // Ids defined outside the region and used inside the region will become // parameters to the outlined function. This is a mapping from used ids to // fresh parameter ids. repeated UInt32Pair input_id_to_fresh_id = 9; // Ids defined inside the region and used outside the region will become // fresh ids defined by the outlined function, which get copied into the // function's struct return value and then copied into their destination ids // by the caller. This is a mapping from original ids to corresponding fresh // ids. repeated UInt32Pair output_id_to_fresh_id = 10; } message TransformationPermuteFunctionParameters { // A transformation that, given a non-entry-point function taking n // parameters and a permutation of the set [0, n-1]: // - Introduces a new function type that is the same as the original // function's type but with the order of arguments permuted // (only if it doesn't already exist) // - Changes the type of the function to this type // - Adjusts all calls to the function so that their arguments are permuted // Function, whose parameters will be permuted uint32 function_id = 1; // Fresh id for a new type of the function. This might not be used // if a required function type already exists or if we can change // the old function type. uint32 function_type_fresh_id = 2; // An array of size |n|, where |n| is a number of arguments to a function // with |function_id|. For each i: 0 <= permutation[i] < n. // // i-th element of this array contains a position for an i-th // function's argument (i.e. i-th argument will be permutation[i]-th // after running this transformation) repeated uint32 permutation = 3; } message TransformationPermutePhiOperands { // Permutes operands of some OpPhi instruction. // Result id of the instruction to apply the transformation to. uint32 result_id = 1; // A sequence of numbers in the range [0, n/2 - 1] where |n| is the number // of operands of the OpPhi instruction with |result_id|. repeated uint32 permutation = 2; } message TransformationPropagateInstructionDown { // Propagates an instruction from |block_id| into its successors. // Concretely, the transformation clones the propagated instruction // into some of the successors of |block_id| and removes the original // instruction. Additionally, an OpPhi instruction may be added to make sure // that the transformation can be applied in various scenarios. // // Note that the instruction might not be propagated down into every successor // of |block_id| since it might make the module invalid. // Id of the block to propagate an instruction from. The decision on what // instruction to propagate is made based on whether the instruction interacts // with memory, whether that instruction is used in its block etc (see the // transformation class for more details). uint32 block_id = 1; // A fresh id for an OpPhi instruction. This might not be used by the // transformation since an OpPhi instruction is created only if needed // (e.g. an instruction is propagated into divergent blocks). uint32 phi_fresh_id = 2; // A map from the id of some successor of the |block_id| to the fresh id. // The map contains a fresh id for at least every successor of the |block_id|. // Every fresh id in the map corresponds to the result id of the clone, // propagated into the corresponding successor block. This transformation // might use overflow ids if they are available and this field doesn't account // for every successor of |block_id|. repeated UInt32Pair successor_id_to_fresh_id = 3; } message TransformationPropagateInstructionUp { // Propagates an instruction in the block into the block's predecessors. // Concretely, this transformation clones some particular instruction from // the |block_id| into every block's predecessor and replaces the original // instruction with OpPhi. Take a look at the transformation class to learn // more about how we choose what instruction to propagate. // Id of the block to propagate an instruction from. uint32 block_id = 1; // A map from the id of some predecessor of the |block_id| to the fresh id. // The map contains a fresh id for at least every predecessor of the |block_id|. // The instruction is propagated by creating a number of clones - one clone for // each predecessor. Fresh ids from this field are used as result ids of cloned // instructions. repeated UInt32Pair predecessor_id_to_fresh_id = 2; } message TransformationPushIdThroughVariable { // A transformation that makes |value_synonym_id| and |value_id| to be // synonymous by storing |value_id| into |variable_id| and // loading |variable_id| to |value_synonym_id|. // The value to be stored. uint32 value_id = 1; // A fresh id for the result of the load instruction. uint32 value_synonym_id = 2; // A fresh id for the variable to be stored to. uint32 variable_id = 3; // Constant to initialize the variable from. uint32 initializer_id = 4; // The variable storage class (global or local). uint32 variable_storage_class = 5; // A descriptor for an instruction which the new OpStore // and OpLoad instructions might be inserted before. InstructionDescriptor instruction_descriptor = 6; } message TransformationRecordSynonymousConstants { // A transformation that, given the IDs to two synonymous constants, // records the fact that they are synonymous. The module is not changed. // Two constants are synonymous if: // - they have the same type (ignoring the presence of integer sign) // - they have the same opcode (one of OpConstant, OpConstantTrue, // OpConstantFalse, OpConstantNull) // - they have the same value // If the types are the same, OpConstantNull is equivalent to // OpConstantFalse or OpConstant with value zero. // The id of a constant uint32 constant1_id = 1; // The id of the synonym uint32 constant2_id = 2; } message TransformationReplaceAddSubMulWithCarryingExtended { // Replaces OpIAdd with OpIAddCarry, OpISub with OpISubBorrow, OpIMul // with OpUMulExtended or OpSMulExtended (depending on the signedness // of the operands) and stores the result into a |struct_fresh_id|. // In the original instruction the result type id and the type ids of // the operands must be the same. Then the transformation extracts // the first element of the result into the original |result_id|. // This value is the same as the result of the original instruction. // The fresh id of the intermediate result. uint32 struct_fresh_id = 1; // The result id of the original instruction. uint32 result_id = 2; } message TransformationReplaceBranchFromDeadBlockWithExit { // Given a dead block that ends with OpBranch, replaces OpBranch with an // "exit" instruction; one of OpReturn/OpReturnValue, OpKill (in a fragment // shader) or OpUnreachable. // The dead block whose terminator is to be replaced. uint32 block_id = 1; // The opcode of the new terminator. uint32 opcode = 2; // Ignored unless opcode is OpReturnValue, in which case this field provides // a suitable result id to be returned. uint32 return_value_id = 3; } message TransformationReplaceParameterWithGlobal { // Removes parameter with result id |parameter_id| from its function // and creates a global variable to pass its value to the function instead. // Fresh id for a new function type. This might not be used if a required // function type already exists or if we can change the old function type. uint32 function_type_fresh_id = 2; // Result id of the OpFunctionParameter instruction to remove. uint32 parameter_id = 3; // Fresh id of a global variable used to pass parameter's value to the function. uint32 global_variable_fresh_id = 4; } message TransformationReplaceBooleanConstantWithConstantBinary { // A transformation to capture replacing a use of a boolean constant with // binary operation on two constant values // A descriptor for the boolean constant id we would like to replace IdUseDescriptor id_use_descriptor = 1; // Id for the constant to be used on the LHS of the comparison uint32 lhs_id = 2; // Id for the constant to be used on the RHS of the comparison uint32 rhs_id = 3; // Opcode for binary operator uint32 opcode = 4; // Id that will store the result of the binary operation instruction uint32 fresh_id_for_binary_operation = 5; } message TransformationReplaceConstantWithUniform { // Replaces a use of a constant id with the result of a load from an // element of uniform buffer known to hold the same value as the constant // A descriptor for the id we would like to replace IdUseDescriptor id_use_descriptor = 1; // Uniform descriptor to identify which uniform value to choose UniformBufferElementDescriptor uniform_descriptor = 2; // Id that will store the result of an access chain uint32 fresh_id_for_access_chain = 3; // Id that will store the result of a load uint32 fresh_id_for_load = 4; } message TransformationReplaceCopyMemoryWithLoadStore { // A transformation that replaces instructions OpCopyMemory with loading // the source variable to an intermediate value and storing this value into the // target variable of the original OpCopyMemory instruction. // The intermediate value. uint32 fresh_id = 1; // The instruction descriptor to OpCopyMemory. It is necessary, because // OpCopyMemory doesn't have a result id. InstructionDescriptor copy_memory_instruction_descriptor = 2; } message TransformationReplaceCopyObjectWithStoreLoad { // A transformation that replaces instruction OpCopyObject with // storing into a new variable and immediately loading from this // variable to |result_id| of the original OpCopyObject instruction. // The result id of initial OpCopyObject instruction uint32 copy_object_result_id = 1; // A fresh id for the variable to be stored to. uint32 fresh_variable_id = 2; // The variable storage class (Function or Private). uint32 variable_storage_class = 3; // Constant to initialize the variable with. uint32 variable_initializer_id = 4; } message TransformationReplaceIdWithSynonym { // Replaces a use of an id with an id that is known to be synonymous, e.g. // because it was obtained via applying OpCopyObject // The id use that is to be replaced IdUseDescriptor id_use_descriptor = 1; // The synonymous id uint32 synonymous_id = 2; } message TransformationReplaceIrrelevantId { // Replaces an irrelevant id with another id of the same type. // The id use that is to be replaced IdUseDescriptor id_use_descriptor = 1; // The replacement id uint32 replacement_id = 2; } message TransformationReplaceLinearAlgebraInstruction { // Replaces a linear algebra instruction with its // mathematical definition. // The fresh ids needed to apply the transformation. repeated uint32 fresh_ids = 1; // A descriptor for a linear algebra instruction. InstructionDescriptor instruction_descriptor = 2; } message TransformationReplaceLoadStoreWithCopyMemory { // A transformation that takes a pair of instruction descriptors // to OpLoad and OpStore that have the same intermediate value // and replaces the OpStore with an equivalent OpCopyMemory. // The instruction descriptor to OpLoad InstructionDescriptor load_instruction_descriptor = 1; // The instruction descriptor to OpStore InstructionDescriptor store_instruction_descriptor = 2; } message TransformationReplaceOpPhiIdFromDeadPredecessor { // Replaces one of the ids used by an OpPhi instruction, when // the corresponding predecessor is dead, with any available id // of the correct type. // The result id of the OpPhi instruction. uint32 opphi_id = 1; // The label id of one of the predecessors of the block containing // the OpPhi instruction, corresponding to the id that we want to // replace. uint32 pred_label_id = 2; // The id that, after the transformation, will be associated with // the given predecessor. uint32 replacement_id = 3; } message TransformationReplaceOpSelectWithConditionalBranch { // A transformation that takes an OpSelect instruction with a // scalar boolean condition and replaces it with a conditional // branch and an OpPhi instruction. // The OpSelect instruction must be the first instruction in its // block, which must have a unique predecessor. The block will // become the merge block of a new construct, while its predecessor // will become the header. // Given the original OpSelect instruction: // %id = OpSelect %type %cond %then %else // The branching instruction of the header will be: // OpBranchConditional %cond %true_block_id %false_block_id // and the OpSelect instruction will be turned into: // %id = OpPhi %type %then %true_block_id %else %false_block_id // At most one of |true_block_id| and |false_block_id| can be zero. In // that case, there will be no such block and all references to it // will be replaced by %merge_block (where %merge_block is the // block containing the OpSelect instruction). // The result id of the OpSelect instruction. uint32 select_id = 1; // A fresh id for the new block that the predecessor of the block // containing |select_id| will branch to if the condition holds. uint32 true_block_id = 2; // A fresh id for the new block that the predecessor of the block // containing |select_id| will branch to if the condition does not // hold. uint32 false_block_id = 3; } message TransformationReplaceParamsWithStruct { // Replaces parameters of the function with a struct containing // values of those parameters. // Result ids of parameters to replace. repeated uint32 parameter_id = 1; // Fresh id for a new function type. This might be unused if the required type // already exists in the module or if we can change the old type. uint32 fresh_function_type_id = 2; // Fresh id for a new struct function parameter to be used as a replacement. uint32 fresh_parameter_id = 3; // Fresh ids for struct objects containing values of replaced parameters. // This field contains a fresh id for at least every result id of a relevant // OpFunctionCall instruction. repeated UInt32Pair caller_id_to_fresh_composite_id = 4; } message TransformationSetFunctionControl { // A transformation that sets the function control operand of an OpFunction // instruction. // The result id of an OpFunction instruction uint32 function_id = 1; // The value to which the 'function control' operand should be set. uint32 function_control = 2; } message TransformationSetLoopControl { // A transformation that sets the loop control operand of an OpLoopMerge // instruction. // The id of a basic block that should contain OpLoopMerge uint32 block_id = 1; // The value to which the 'loop control' operand should be set. // This must be a legal loop control mask. uint32 loop_control = 2; // Provides a peel count value for the loop. Used if and only if the // PeelCount bit is set. Must be zero if the PeelCount bit is not set (can // still be zero if this bit is set). uint32 peel_count = 3; // Provides a partial count value for the loop. Used if and only if the // PartialCount bit is set. Must be zero if the PartialCount bit is not set // (can still be zero if this bit is set). uint32 partial_count = 4; } message TransformationSetMemoryOperandsMask { // A transformation that sets the memory operands mask of a memory access // instruction. // A descriptor for a memory access instruction, e.g. an OpLoad InstructionDescriptor memory_access_instruction = 1; // A mask of memory operands to be applied to the instruction. It must be the // same as the original mask, except that Volatile can be added, and // Nontemporal can be added or removed. uint32 memory_operands_mask = 2; // Some memory access instructions allow more than one mask to be specified; // this field indicates which mask should be set uint32 memory_operands_mask_index = 3; } message TransformationSetSelectionControl { // A transformation that sets the selection control operand of an // OpSelectionMerge instruction. // The id of a basic block that should contain OpSelectionMerge uint32 block_id = 1; // The value to which the 'selection control' operand should be set. // Although technically 'selection control' is a literal mask that can be // some combination of 'None', 'Flatten' and 'DontFlatten', the combination // 'Flatten | DontFlatten' does not make sense and is not allowed here. uint32 selection_control = 2; } message TransformationSplitBlock { // A transformation that splits a basic block into two basic blocks // A descriptor for an instruction such that the block containing the // described instruction should be split right before the instruction. InstructionDescriptor instruction_to_split_before = 1; // An id that must not yet be used by the module to which this transformation // is applied. Rather than having the transformation choose a suitable id on // application, we require the id to be given upfront in order to facilitate // reducing fuzzed shaders by removing transformations. The reason is that // future transformations may refer to the fresh id introduced by this // transformation, and if we end up changing what that id is, due to removing // earlier transformations, it may inhibit later transformations from // applying. uint32 fresh_id = 2; } message TransformationStore { // Transformation that adds an OpStore or OpAtomicStore instruction of an id to a pointer. // The pointer to be stored to. uint32 pointer_id = 1; // True if and only if the load should be atomic. bool is_atomic = 2; // The memory scope for the atomic load. Ignored unless |is_atomic| is true. uint32 memory_scope_id = 3; // The memory semantics for the atomic load. Ignored unless |is_atomic| is true. uint32 memory_semantics_id = 4; // The value to be stored. uint32 value_id = 5; // A descriptor for an instruction in a block before which the new OpStore // instruction should be inserted. InstructionDescriptor instruction_to_insert_before = 6; } message TransformationSwapCommutableOperands { // A transformation that swaps the operands of a commutative instruction. // A descriptor for a commutative instruction InstructionDescriptor instruction_descriptor = 1; } message TransformationSwapConditionalBranchOperands { // Swaps label ids in OpBranchConditional instruction. // Additionally, inverts the guard and swaps branch weights // if present. // Descriptor of the instruction to swap operands of. InstructionDescriptor instruction_descriptor = 1; // Fresh result id for the OpLogicalNot instruction, used // to invert the guard. uint32 fresh_id = 2; } message TransformationSwapFunctionVariables { // A transformation that swaps function variables // Result id of the first variable. uint32 result_id1 = 1; // Result id of the second variable. uint32 result_id2 = 2; } message TransformationSwapTwoFunctions { // A transformation that swaps the position of two functions within the same module. // the IDs for the two functions that are swapped. uint32 function_id1 = 1; uint32 function_id2 = 2; } message TransformationToggleAccessChainInstruction { // A transformation that toggles an access chain instruction. // A descriptor for an access chain instruction InstructionDescriptor instruction_descriptor = 1; } message TransformationVectorShuffle { // A transformation that adds a vector shuffle instruction. // A descriptor for an instruction in a block before which the new // OpVectorShuffle instruction should be inserted InstructionDescriptor instruction_to_insert_before = 1; // Result id for the shuffle operation. uint32 fresh_id = 2; // Id of the first vector operand. uint32 vector1 = 3; // Id of the second vector operand. uint32 vector2 = 4; // Indices that indicate which components of the input vectors should be used. repeated uint32 component = 5; } message TransformationWrapEarlyTerminatorInFunction { // Replaces an early terminator - OpKill, OpReachable or OpTerminateInvocation // - with a call to a wrapper function for the terminator. // A fresh id for a new OpFunctionCall instruction. uint32 fresh_id = 1; // A descriptor for an OpKill, OpUnreachable or OpTerminateInvocation // instruction. InstructionDescriptor early_terminator_instruction = 2; // An id with the same type as the enclosing function's return type that is // available at the early terminator. This is used to change the terminator // to OpReturnValue. Ignored if the enclosing function has void return type, // in which case OpReturn can be used as the new terminator. uint32 returned_value_id = 3; } message TransformationWrapRegionInSelection { // Transforms a single-entry-single-exit region R into // if (|branch_condition|) { R } else { R } // The entry block for R becomes a selection header and // the exit block - a selection merge. // // Note that the region R is not duplicated. Thus, the effect of // this transformation can be represented as follows: // entry // entry / \ // | \ / // R --> R // | | // exit exit // This behaviour is different from TransformationDuplicateRegionWithSelection // that copies the blocks in R. // The entry block for the region R. uint32 region_entry_block_id = 1; // The exit block for the region R. uint32 region_exit_block_id = 2; // Boolean value for the condition expression. bool branch_condition = 3; } message TransformationWrapVectorSynonym { // A transformation that wraps an arithmetic operation into a vector operation // and get the result of the original operation from the corresponding index. // For instance, for this transformation, an scalar operation between two scalars: // define op ∈ {+, -, *} // c = a op b // // requires the availability of two vectors: // // va = vector(..., a, ...) // vb = vector(..., b, ...) // // where a and b are in the same position i in each of their corresponding vector // and a is synonymous with va[i] and b is synonymous with vb[i]. // // The transformation then add an instruction vc = va op vb where c is synonymous // with vc[i]. // The result if of the original scalar operation instruction. uint32 instruction_id = 1; // The result id for the first vector that contains the first value of the scalar operation. uint32 vector_operand1 = 2; // The result id for the second vector that contains the second value of the scalar operation. uint32 vector_operand2 = 3; // A fresh id for the resulted vector from the addition of the first and second vector. uint32 fresh_id = 4; // The position in the vector where the value of original instruction is located. Must be in // the corresponding vector range. uint32 scalar_position = 5; } KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/pseudo_random_generator.cpp000066400000000000000000000032361475742701700264440ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/pseudo_random_generator.h" #include namespace spvtools { namespace fuzz { PseudoRandomGenerator::PseudoRandomGenerator(uint32_t seed) : mt_(seed) {} PseudoRandomGenerator::~PseudoRandomGenerator() = default; uint32_t PseudoRandomGenerator::RandomUint32(uint32_t bound) { assert(bound > 0 && "Bound must be positive"); return std::uniform_int_distribution(0, bound - 1)(mt_); } uint64_t PseudoRandomGenerator::RandomUint64(uint64_t bound) { assert(bound > 0 && "Bound must be positive"); return std::uniform_int_distribution(0, bound - 1)(mt_); } bool PseudoRandomGenerator::RandomBool() { return static_cast(std::uniform_int_distribution<>(0, 1)(mt_)); } uint32_t PseudoRandomGenerator::RandomPercentage() { // We use 101 because we want a result in the closed interval [0, 100], and // RandomUint32 is not inclusive of its bound. return RandomUint32(101); } double PseudoRandomGenerator::RandomDouble() { return std::uniform_real_distribution(0.0, 1.0)(mt_); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/pseudo_random_generator.h000066400000000000000000000025001475742701700261020ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_PSEUDO_RANDOM_GENERATOR_H_ #define SOURCE_FUZZ_PSEUDO_RANDOM_GENERATOR_H_ #include #include "source/fuzz/random_generator.h" namespace spvtools { namespace fuzz { // Generates random data from a pseudo-random number generator. class PseudoRandomGenerator : public RandomGenerator { public: explicit PseudoRandomGenerator(uint32_t seed); ~PseudoRandomGenerator() override; uint32_t RandomUint32(uint32_t bound) override; uint64_t RandomUint64(uint64_t bound) override; uint32_t RandomPercentage() override; bool RandomBool() override; double RandomDouble() override; private: std::mt19937 mt_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_PSEUDO_RANDOM_GENERATOR_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/random_generator.cpp000066400000000000000000000014571475742701700250700ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/random_generator.h" namespace spvtools { namespace fuzz { RandomGenerator::RandomGenerator() = default; RandomGenerator::~RandomGenerator() = default; } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/random_generator.h000066400000000000000000000025501475742701700245300ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_RANDOM_GENERATOR_H_ #define SOURCE_FUZZ_RANDOM_GENERATOR_H_ #include namespace spvtools { namespace fuzz { class RandomGenerator { public: RandomGenerator(); virtual ~RandomGenerator(); // Returns a value in the half-open interval [0, bound). virtual uint32_t RandomUint32(uint32_t bound) = 0; // Returns a value in the half-open interval [0, bound). virtual uint64_t RandomUint64(uint64_t bound) = 0; // Returns a value in the closed interval [0, 100]. virtual uint32_t RandomPercentage() = 0; // Returns a boolean. virtual bool RandomBool() = 0; // Returns a double in the closed interval [0, 1] virtual double RandomDouble() = 0; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_RANDOM_GENERATOR_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/replayer.cpp000066400000000000000000000155741475742701700233720ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/replayer.h" #include #include #include #include "source/fuzz/counter_overflow_id_source.h" #include "source/fuzz/fact_manager/fact_manager.h" #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/build_module.h" #include "source/util/make_unique.h" namespace spvtools { namespace fuzz { Replayer::Replayer( spv_target_env target_env, MessageConsumer consumer, const std::vector& binary_in, const protobufs::FactSequence& initial_facts, const protobufs::TransformationSequence& transformation_sequence_in, uint32_t num_transformations_to_apply, bool validate_during_replay, spv_validator_options validator_options) : target_env_(target_env), consumer_(std::move(consumer)), binary_in_(binary_in), initial_facts_(initial_facts), transformation_sequence_in_(transformation_sequence_in), num_transformations_to_apply_(num_transformations_to_apply), validate_during_replay_(validate_during_replay), validator_options_(validator_options) {} Replayer::~Replayer() = default; Replayer::ReplayerResult Replayer::Run() { // Check compatibility between the library version being linked with and the // header files being used. GOOGLE_PROTOBUF_VERIFY_VERSION; if (num_transformations_to_apply_ > static_cast( transformation_sequence_in_.transformation_size())) { consumer_(SPV_MSG_ERROR, nullptr, {}, "The number of transformations to be replayed must not " "exceed the size of the transformation sequence."); return {Replayer::ReplayerResultStatus::kTooManyTransformationsRequested, nullptr, nullptr, protobufs::TransformationSequence()}; } spvtools::SpirvTools tools(target_env_); if (!tools.IsValid()) { consumer_(SPV_MSG_ERROR, nullptr, {}, "Failed to create SPIRV-Tools interface; stopping."); return {Replayer::ReplayerResultStatus::kFailedToCreateSpirvToolsInterface, nullptr, nullptr, protobufs::TransformationSequence()}; } // Initial binary should be valid. if (!tools.Validate(&binary_in_[0], binary_in_.size(), validator_options_)) { consumer_(SPV_MSG_INFO, nullptr, {}, "Initial binary is invalid; stopping."); return {Replayer::ReplayerResultStatus::kInitialBinaryInvalid, nullptr, nullptr, protobufs::TransformationSequence()}; } // Build the module from the input binary. std::unique_ptr ir_context = BuildModule(target_env_, consumer_, binary_in_.data(), binary_in_.size()); assert(ir_context); // For replay validation, we track the last valid SPIR-V binary that was // observed. Initially this is the input binary. std::vector last_valid_binary; if (validate_during_replay_) { last_valid_binary = binary_in_; } // We find the smallest id that is (a) not in use by the original module, and // (b) not used by any transformation in the sequence to be replayed. This // serves as a starting id from which to issue overflow ids if they are // required during replay. uint32_t first_overflow_id = ir_context->module()->id_bound(); for (auto& transformation : transformation_sequence_in_.transformation()) { auto fresh_ids = Transformation::FromMessage(transformation)->GetFreshIds(); if (!fresh_ids.empty()) { first_overflow_id = std::max(first_overflow_id, *std::max_element(fresh_ids.begin(), fresh_ids.end()) + 1); } } std::unique_ptr transformation_context = MakeUnique( MakeUnique(ir_context.get()), validator_options_, MakeUnique(first_overflow_id)); transformation_context->GetFactManager()->AddInitialFacts(consumer_, initial_facts_); // We track the largest id bound observed, to ensure that it only increases // as transformations are applied. uint32_t max_observed_id_bound = ir_context->module()->id_bound(); (void)(max_observed_id_bound); // Keep release-mode compilers happy. protobufs::TransformationSequence transformation_sequence_out; // Consider the transformation proto messages in turn. uint32_t counter = 0; for (auto& message : transformation_sequence_in_.transformation()) { if (counter >= num_transformations_to_apply_) { break; } counter++; auto transformation = Transformation::FromMessage(message); // Check whether the transformation can be applied. if (transformation->IsApplicable(ir_context.get(), *transformation_context)) { // The transformation is applicable, so apply it, and copy it to the // sequence of transformations that were applied. transformation->Apply(ir_context.get(), transformation_context.get()); *transformation_sequence_out.add_transformation() = message; assert(ir_context->module()->id_bound() >= max_observed_id_bound && "The module's id bound should only increase due to applying " "transformations."); max_observed_id_bound = ir_context->module()->id_bound(); if (validate_during_replay_) { std::vector binary_to_validate; ir_context->module()->ToBinary(&binary_to_validate, false); // Check whether the latest transformation led to a valid binary. if (!tools.Validate(&binary_to_validate[0], binary_to_validate.size(), validator_options_)) { consumer_(SPV_MSG_INFO, nullptr, {}, "Binary became invalid during replay (set a " "breakpoint to inspect); stopping."); return {Replayer::ReplayerResultStatus::kReplayValidationFailure, nullptr, nullptr, protobufs::TransformationSequence()}; } // The binary was valid, so it becomes the latest valid binary. last_valid_binary = std::move(binary_to_validate); } } } return {Replayer::ReplayerResultStatus::kComplete, std::move(ir_context), std::move(transformation_context), std::move(transformation_sequence_out)}; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/replayer.h000066400000000000000000000072311475742701700230260ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_REPLAYER_H_ #define SOURCE_FUZZ_REPLAYER_H_ #include #include #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" #include "spirv-tools/libspirv.hpp" namespace spvtools { namespace fuzz { // Transforms a SPIR-V module into a semantically equivalent SPIR-V module by // applying a series of pre-defined transformations. class Replayer { public: // Possible statuses that can result from running the replayer. enum class ReplayerResultStatus { kComplete, kFailedToCreateSpirvToolsInterface, kInitialBinaryInvalid, kReplayValidationFailure, kTooManyTransformationsRequested, }; struct ReplayerResult { ReplayerResultStatus status; std::unique_ptr transformed_module; std::unique_ptr transformation_context; protobufs::TransformationSequence applied_transformations; }; Replayer(spv_target_env target_env, MessageConsumer consumer, const std::vector& binary_in, const protobufs::FactSequence& initial_facts, const protobufs::TransformationSequence& transformation_sequence_in, uint32_t num_transformations_to_apply, bool validate_during_replay, spv_validator_options validator_options); // Disables copy/move constructor/assignment operations. Replayer(const Replayer&) = delete; Replayer(Replayer&&) = delete; Replayer& operator=(const Replayer&) = delete; Replayer& operator=(Replayer&&) = delete; ~Replayer(); // Attempts to apply the first |num_transformations_to_apply_| transformations // from |transformation_sequence_in_| to |binary_in_|. Initial facts about // the input binary and the context in which it will execute are provided via // |initial_facts_|. // // On success, returns a successful result status together with the // transformations that were applied, the IR for the transformed module, and // the transformation context that arises from applying these transformations. // Otherwise, returns an appropriate result status, an empty transformation // sequence, and null pointers for the IR context and transformation context. ReplayerResult Run(); private: // Target environment. const spv_target_env target_env_; // Message consumer. MessageConsumer consumer_; // The binary to which transformations are to be applied. const std::vector& binary_in_; // Initial facts known to hold in advance of applying any transformations. const protobufs::FactSequence& initial_facts_; // The transformations to be replayed. const protobufs::TransformationSequence& transformation_sequence_in_; // The number of transformations that should be replayed. const uint32_t num_transformations_to_apply_; // Controls whether the validator should be run after every replay step. const bool validate_during_replay_; // Options to control validation spv_validator_options validator_options_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_REPLAYER_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/shrinker.cpp000066400000000000000000000330751475742701700233700ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/shrinker.h" #include #include "source/fuzz/added_function_reducer.h" #include "source/fuzz/pseudo_random_generator.h" #include "source/fuzz/replayer.h" #include "source/opt/build_module.h" #include "source/opt/ir_context.h" #include "source/spirv_fuzzer_options.h" #include "source/util/make_unique.h" namespace spvtools { namespace fuzz { namespace { // A helper to get the size of a protobuf transformation sequence in a less // verbose manner. uint32_t NumRemainingTransformations( const protobufs::TransformationSequence& transformation_sequence) { return static_cast(transformation_sequence.transformation_size()); } // A helper to return a transformation sequence identical to |transformations|, // except that a chunk of size |chunk_size| starting from |chunk_index| x // |chunk_size| is removed (or as many transformations as available if the whole // chunk is not). protobufs::TransformationSequence RemoveChunk( const protobufs::TransformationSequence& transformations, uint32_t chunk_index, uint32_t chunk_size) { uint32_t lower = chunk_index * chunk_size; uint32_t upper = std::min((chunk_index + 1) * chunk_size, NumRemainingTransformations(transformations)); assert(lower < upper); assert(upper <= NumRemainingTransformations(transformations)); protobufs::TransformationSequence result; for (uint32_t j = 0; j < NumRemainingTransformations(transformations); j++) { if (j >= lower && j < upper) { continue; } protobufs::Transformation transformation = transformations.transformation()[j]; *result.mutable_transformation()->Add() = transformation; } return result; } } // namespace Shrinker::Shrinker( spv_target_env target_env, MessageConsumer consumer, const std::vector& binary_in, const protobufs::FactSequence& initial_facts, const protobufs::TransformationSequence& transformation_sequence_in, const InterestingnessFunction& interestingness_function, uint32_t step_limit, bool validate_during_replay, spv_validator_options validator_options) : target_env_(target_env), consumer_(std::move(consumer)), binary_in_(binary_in), initial_facts_(initial_facts), transformation_sequence_in_(transformation_sequence_in), interestingness_function_(interestingness_function), step_limit_(step_limit), validate_during_replay_(validate_during_replay), validator_options_(validator_options) {} Shrinker::~Shrinker() = default; Shrinker::ShrinkerResult Shrinker::Run() { // Check compatibility between the library version being linked with and the // header files being used. GOOGLE_PROTOBUF_VERIFY_VERSION; SpirvTools tools(target_env_); if (!tools.IsValid()) { consumer_(SPV_MSG_ERROR, nullptr, {}, "Failed to create SPIRV-Tools interface; stopping."); return {Shrinker::ShrinkerResultStatus::kFailedToCreateSpirvToolsInterface, std::vector(), protobufs::TransformationSequence()}; } // Initial binary should be valid. if (!tools.Validate(&binary_in_[0], binary_in_.size(), validator_options_)) { consumer_(SPV_MSG_INFO, nullptr, {}, "Initial binary is invalid; stopping."); return {Shrinker::ShrinkerResultStatus::kInitialBinaryInvalid, std::vector(), protobufs::TransformationSequence()}; } // Run a replay of the initial transformation sequence to check that it // succeeds. auto initial_replay_result = Replayer(target_env_, consumer_, binary_in_, initial_facts_, transformation_sequence_in_, static_cast( transformation_sequence_in_.transformation_size()), validate_during_replay_, validator_options_) .Run(); if (initial_replay_result.status != Replayer::ReplayerResultStatus::kComplete) { return {ShrinkerResultStatus::kReplayFailed, std::vector(), protobufs::TransformationSequence()}; } // Get the binary that results from running these transformations, and the // subsequence of the initial transformations that actually apply (in // principle this could be a strict subsequence). std::vector current_best_binary; initial_replay_result.transformed_module->module()->ToBinary( ¤t_best_binary, false); protobufs::TransformationSequence current_best_transformations = std::move(initial_replay_result.applied_transformations); // Check that the binary produced by applying the initial transformations is // indeed interesting. if (!interestingness_function_(current_best_binary, 0)) { consumer_(SPV_MSG_INFO, nullptr, {}, "Initial binary is not interesting; stopping."); return {ShrinkerResultStatus::kInitialBinaryNotInteresting, std::vector(), protobufs::TransformationSequence()}; } uint32_t attempt = 0; // Keeps track of the number of shrink attempts that // have been tried, whether successful or not. uint32_t chunk_size = std::max(1u, NumRemainingTransformations(current_best_transformations) / 2); // The number of contiguous transformations that the // shrinker will try to remove in one go; starts // high and decreases during the shrinking process. // Keep shrinking until we: // - reach the step limit, // - run out of transformations to remove, or // - cannot make the chunk size any smaller. while (attempt < step_limit_ && !current_best_transformations.transformation().empty() && chunk_size > 0) { bool progress_this_round = false; // Used to decide whether to make the chunk size with which we // remove transformations smaller. If we managed to remove at // least one chunk of transformations at a particular chunk // size, we set this flag so that we do not yet decrease the // chunk size. assert(chunk_size <= NumRemainingTransformations(current_best_transformations) && "Chunk size should never exceed the number of transformations that " "remain."); // The number of chunks is the ceiling of (#remaining_transformations / // chunk_size). const uint32_t num_chunks = (NumRemainingTransformations(current_best_transformations) + chunk_size - 1) / chunk_size; assert(num_chunks >= 1 && "There should be at least one chunk."); assert(num_chunks * chunk_size >= NumRemainingTransformations(current_best_transformations) && "All transformations should be in some chunk."); // We go through the transformations in reverse, in chunks of size // |chunk_size|, using |chunk_index| to track which chunk to try removing // next. The loop exits early if we reach the shrinking step limit. for (int chunk_index = num_chunks - 1; attempt < step_limit_ && chunk_index >= 0; chunk_index--) { // Remove a chunk of transformations according to the current index and // chunk size. auto transformations_with_chunk_removed = RemoveChunk(current_best_transformations, static_cast(chunk_index), chunk_size); // Replay the smaller sequence of transformations to get a next binary and // transformation sequence. Note that the transformations arising from // replay might be even smaller than the transformations with the chunk // removed, because removing those transformations might make further // transformations inapplicable. auto replay_result = Replayer( target_env_, consumer_, binary_in_, initial_facts_, transformations_with_chunk_removed, static_cast( transformations_with_chunk_removed.transformation_size()), validate_during_replay_, validator_options_) .Run(); if (replay_result.status != Replayer::ReplayerResultStatus::kComplete) { // Replay should not fail; if it does, we need to abort shrinking. return {ShrinkerResultStatus::kReplayFailed, std::vector(), protobufs::TransformationSequence()}; } assert( NumRemainingTransformations(replay_result.applied_transformations) >= chunk_index * chunk_size && "Removing this chunk of transformations should not have an effect " "on earlier chunks."); std::vector transformed_binary; replay_result.transformed_module->module()->ToBinary(&transformed_binary, false); if (interestingness_function_(transformed_binary, attempt)) { // If the binary arising from the smaller transformation sequence is // interesting, this becomes our current best binary and transformation // sequence. current_best_binary = std::move(transformed_binary); current_best_transformations = std::move(replay_result.applied_transformations); progress_this_round = true; } // Either way, this was a shrink attempt, so increment our count of shrink // attempts. attempt++; } if (!progress_this_round) { // If we didn't manage to remove any chunks at this chunk size, try a // smaller chunk size. chunk_size /= 2; } // Decrease the chunk size until it becomes no larger than the number of // remaining transformations. while (chunk_size > NumRemainingTransformations(current_best_transformations)) { chunk_size /= 2; } } // We now use spirv-reduce to minimise the functions associated with any // AddFunction transformations that remain. // // Consider every remaining transformation. for (uint32_t transformation_index = 0; attempt < step_limit_ && transformation_index < static_cast( current_best_transformations.transformation_size()); transformation_index++) { // Skip all transformations apart from TransformationAddFunction. if (!current_best_transformations.transformation(transformation_index) .has_add_function()) { continue; } // Invoke spirv-reduce on the function encoded in this AddFunction // transformation. The details of this are rather involved, and so are // encapsulated in a separate class. auto added_function_reducer_result = AddedFunctionReducer(target_env_, consumer_, binary_in_, initial_facts_, current_best_transformations, transformation_index, interestingness_function_, validate_during_replay_, validator_options_, step_limit_, attempt) .Run(); // Reducing the added function should succeed. If it doesn't, we report // a shrinking error. if (added_function_reducer_result.status != AddedFunctionReducer::AddedFunctionReducerResultStatus::kComplete) { return {ShrinkerResultStatus::kAddedFunctionReductionFailed, std::vector(), protobufs::TransformationSequence()}; } assert(current_best_transformations.transformation_size() == added_function_reducer_result.applied_transformations .transformation_size() && "The number of transformations should not have changed."); current_best_binary = std::move(added_function_reducer_result.transformed_binary); current_best_transformations = std::move(added_function_reducer_result.applied_transformations); // The added function reducer reports how many reduction attempts // spirv-reduce took when reducing the function. We regard each of these // as a shrinker attempt. attempt += added_function_reducer_result.num_reduction_attempts; } // Indicate whether shrinking completed or was truncated due to reaching the // step limit. // // Either way, the output from the shrinker is the best binary we saw, and the // transformations that led to it. assert(attempt <= step_limit_); if (attempt == step_limit_) { std::stringstream strstream; strstream << "Shrinking did not complete; step limit " << step_limit_ << " was reached."; consumer_(SPV_MSG_WARNING, nullptr, {}, strstream.str().c_str()); return {Shrinker::ShrinkerResultStatus::kStepLimitReached, std::move(current_best_binary), std::move(current_best_transformations)}; } return {Shrinker::ShrinkerResultStatus::kComplete, std::move(current_best_binary), std::move(current_best_transformations)}; } uint32_t Shrinker::GetIdBound(const std::vector& binary) const { // Build the module from the input binary. std::unique_ptr ir_context = BuildModule(target_env_, consumer_, binary.data(), binary.size()); assert(ir_context && "Error building module."); return ir_context->module()->id_bound(); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/shrinker.h000066400000000000000000000112661475742701700230330ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_SHRINKER_H_ #define SOURCE_FUZZ_SHRINKER_H_ #include #include #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "spirv-tools/libspirv.hpp" namespace spvtools { namespace fuzz { // Shrinks a sequence of transformations that lead to an interesting SPIR-V // binary to yield a smaller sequence of transformations that still produce an // interesting binary. class Shrinker { public: // Possible statuses that can result from running the shrinker. enum class ShrinkerResultStatus { kComplete, kFailedToCreateSpirvToolsInterface, kInitialBinaryInvalid, kInitialBinaryNotInteresting, kReplayFailed, kStepLimitReached, kAddedFunctionReductionFailed, }; struct ShrinkerResult { ShrinkerResultStatus status; std::vector transformed_binary; protobufs::TransformationSequence applied_transformations; }; // The type for a function that will take a binary, |binary|, and return true // if and only if the binary is deemed interesting. (The function also takes // an integer argument, |counter|, that will be incremented each time the // function is called; this is for debugging purposes). // // The notion of "interesting" depends on what properties of the binary or // tools that process the binary we are trying to maintain during shrinking. using InterestingnessFunction = std::function& binary, uint32_t counter)>; Shrinker(spv_target_env target_env, MessageConsumer consumer, const std::vector& binary_in, const protobufs::FactSequence& initial_facts, const protobufs::TransformationSequence& transformation_sequence_in, const InterestingnessFunction& interestingness_function, uint32_t step_limit, bool validate_during_replay, spv_validator_options validator_options); // Disables copy/move constructor/assignment operations. Shrinker(const Shrinker&) = delete; Shrinker(Shrinker&&) = delete; Shrinker& operator=(const Shrinker&) = delete; Shrinker& operator=(Shrinker&&) = delete; ~Shrinker(); // Requires that when |transformation_sequence_in_| is applied to |binary_in_| // with initial facts |initial_facts_|, the resulting binary is interesting // according to |interestingness_function_|. // // If shrinking succeeded -- possibly terminating early due to reaching the // shrinker's step limit -- an associated result status is returned together // with a subsequence of |transformation_sequence_in_| that, when applied // to |binary_in_| with initial facts |initial_facts_|, produces a binary // that is also interesting according to |interestingness_function_|; this // binary is also returned. // // If shrinking failed for some reason, an appropriate result status is // returned together with an empty binary and empty transformation sequence. ShrinkerResult Run(); private: // Returns the id bound for the given SPIR-V binary, which is assumed to be // valid. uint32_t GetIdBound(const std::vector& binary) const; // Target environment. const spv_target_env target_env_; // Message consumer that will be invoked once for each message communicated // from the library. MessageConsumer consumer_; // The binary to which transformations are to be applied. const std::vector& binary_in_; // Initial facts known to hold in advance of applying any transformations. const protobufs::FactSequence& initial_facts_; // The series of transformations to be shrunk. const protobufs::TransformationSequence& transformation_sequence_in_; // Function that decides whether a given module is interesting. const InterestingnessFunction& interestingness_function_; // Step limit to decide when to terminate shrinking early. const uint32_t step_limit_; // Determines whether to check for validity during the replaying of // transformations. const bool validate_during_replay_; // Options to control validation. spv_validator_options validator_options_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_SHRINKER_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation.cpp000066400000000000000000000556031475742701700246120ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation.h" #include #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/transformation_access_chain.h" #include "source/fuzz/transformation_add_bit_instruction_synonym.h" #include "source/fuzz/transformation_add_constant_boolean.h" #include "source/fuzz/transformation_add_constant_composite.h" #include "source/fuzz/transformation_add_constant_null.h" #include "source/fuzz/transformation_add_constant_scalar.h" #include "source/fuzz/transformation_add_copy_memory.h" #include "source/fuzz/transformation_add_dead_block.h" #include "source/fuzz/transformation_add_dead_break.h" #include "source/fuzz/transformation_add_dead_continue.h" #include "source/fuzz/transformation_add_early_terminator_wrapper.h" #include "source/fuzz/transformation_add_function.h" #include "source/fuzz/transformation_add_global_undef.h" #include "source/fuzz/transformation_add_global_variable.h" #include "source/fuzz/transformation_add_image_sample_unused_components.h" #include "source/fuzz/transformation_add_local_variable.h" #include "source/fuzz/transformation_add_loop_preheader.h" #include "source/fuzz/transformation_add_loop_to_create_int_constant_synonym.h" #include "source/fuzz/transformation_add_no_contraction_decoration.h" #include "source/fuzz/transformation_add_opphi_synonym.h" #include "source/fuzz/transformation_add_parameter.h" #include "source/fuzz/transformation_add_relaxed_decoration.h" #include "source/fuzz/transformation_add_spec_constant_op.h" #include "source/fuzz/transformation_add_synonym.h" #include "source/fuzz/transformation_add_type_array.h" #include "source/fuzz/transformation_add_type_boolean.h" #include "source/fuzz/transformation_add_type_float.h" #include "source/fuzz/transformation_add_type_function.h" #include "source/fuzz/transformation_add_type_int.h" #include "source/fuzz/transformation_add_type_matrix.h" #include "source/fuzz/transformation_add_type_pointer.h" #include "source/fuzz/transformation_add_type_struct.h" #include "source/fuzz/transformation_add_type_vector.h" #include "source/fuzz/transformation_adjust_branch_weights.h" #include "source/fuzz/transformation_composite_construct.h" #include "source/fuzz/transformation_composite_extract.h" #include "source/fuzz/transformation_composite_insert.h" #include "source/fuzz/transformation_compute_data_synonym_fact_closure.h" #include "source/fuzz/transformation_duplicate_region_with_selection.h" #include "source/fuzz/transformation_equation_instruction.h" #include "source/fuzz/transformation_expand_vector_reduction.h" #include "source/fuzz/transformation_flatten_conditional_branch.h" #include "source/fuzz/transformation_function_call.h" #include "source/fuzz/transformation_inline_function.h" #include "source/fuzz/transformation_invert_comparison_operator.h" #include "source/fuzz/transformation_load.h" #include "source/fuzz/transformation_make_vector_operation_dynamic.h" #include "source/fuzz/transformation_merge_blocks.h" #include "source/fuzz/transformation_merge_function_returns.h" #include "source/fuzz/transformation_move_block_down.h" #include "source/fuzz/transformation_move_instruction_down.h" #include "source/fuzz/transformation_mutate_pointer.h" #include "source/fuzz/transformation_outline_function.h" #include "source/fuzz/transformation_permute_function_parameters.h" #include "source/fuzz/transformation_permute_phi_operands.h" #include "source/fuzz/transformation_propagate_instruction_down.h" #include "source/fuzz/transformation_propagate_instruction_up.h" #include "source/fuzz/transformation_push_id_through_variable.h" #include "source/fuzz/transformation_record_synonymous_constants.h" #include "source/fuzz/transformation_replace_add_sub_mul_with_carrying_extended.h" #include "source/fuzz/transformation_replace_boolean_constant_with_constant_binary.h" #include "source/fuzz/transformation_replace_branch_from_dead_block_with_exit.h" #include "source/fuzz/transformation_replace_constant_with_uniform.h" #include "source/fuzz/transformation_replace_copy_memory_with_load_store.h" #include "source/fuzz/transformation_replace_copy_object_with_store_load.h" #include "source/fuzz/transformation_replace_id_with_synonym.h" #include "source/fuzz/transformation_replace_irrelevant_id.h" #include "source/fuzz/transformation_replace_linear_algebra_instruction.h" #include "source/fuzz/transformation_replace_load_store_with_copy_memory.h" #include "source/fuzz/transformation_replace_opphi_id_from_dead_predecessor.h" #include "source/fuzz/transformation_replace_opselect_with_conditional_branch.h" #include "source/fuzz/transformation_replace_parameter_with_global.h" #include "source/fuzz/transformation_replace_params_with_struct.h" #include "source/fuzz/transformation_set_function_control.h" #include "source/fuzz/transformation_set_loop_control.h" #include "source/fuzz/transformation_set_memory_operands_mask.h" #include "source/fuzz/transformation_set_selection_control.h" #include "source/fuzz/transformation_split_block.h" #include "source/fuzz/transformation_store.h" #include "source/fuzz/transformation_swap_commutable_operands.h" #include "source/fuzz/transformation_swap_conditional_branch_operands.h" #include "source/fuzz/transformation_swap_function_variables.h" #include "source/fuzz/transformation_swap_two_functions.h" #include "source/fuzz/transformation_toggle_access_chain_instruction.h" #include "source/fuzz/transformation_vector_shuffle.h" #include "source/fuzz/transformation_wrap_early_terminator_in_function.h" #include "source/fuzz/transformation_wrap_region_in_selection.h" #include "source/fuzz/transformation_wrap_vector_synonym.h" #include "source/util/make_unique.h" namespace spvtools { namespace fuzz { Transformation::~Transformation() = default; std::unique_ptr Transformation::FromMessage( const protobufs::Transformation& message) { switch (message.transformation_case()) { case protobufs::Transformation::TransformationCase::kAccessChain: return MakeUnique(message.access_chain()); case protobufs::Transformation::TransformationCase:: kAddBitInstructionSynonym: return MakeUnique( message.add_bit_instruction_synonym()); case protobufs::Transformation::TransformationCase::kAddConstantBoolean: return MakeUnique( message.add_constant_boolean()); case protobufs::Transformation::TransformationCase::kAddConstantComposite: return MakeUnique( message.add_constant_composite()); case protobufs::Transformation::TransformationCase::kAddConstantNull: return MakeUnique( message.add_constant_null()); case protobufs::Transformation::TransformationCase::kAddConstantScalar: return MakeUnique( message.add_constant_scalar()); case protobufs::Transformation::TransformationCase::kAddCopyMemory: return MakeUnique(message.add_copy_memory()); case protobufs::Transformation::TransformationCase::kAddDeadBlock: return MakeUnique(message.add_dead_block()); case protobufs::Transformation::TransformationCase::kAddDeadBreak: return MakeUnique(message.add_dead_break()); case protobufs::Transformation::TransformationCase::kAddDeadContinue: return MakeUnique( message.add_dead_continue()); case protobufs::Transformation::TransformationCase:: kAddEarlyTerminatorWrapper: return MakeUnique( message.add_early_terminator_wrapper()); case protobufs::Transformation::TransformationCase::kAddFunction: return MakeUnique(message.add_function()); case protobufs::Transformation::TransformationCase::kAddGlobalUndef: return MakeUnique( message.add_global_undef()); case protobufs::Transformation::TransformationCase::kAddGlobalVariable: return MakeUnique( message.add_global_variable()); case protobufs::Transformation::TransformationCase:: kAddImageSampleUnusedComponents: return MakeUnique( message.add_image_sample_unused_components()); case protobufs::Transformation::TransformationCase::kAddLocalVariable: return MakeUnique( message.add_local_variable()); case protobufs::Transformation::TransformationCase::kAddLoopPreheader: return MakeUnique( message.add_loop_preheader()); case protobufs::Transformation::TransformationCase:: kAddLoopToCreateIntConstantSynonym: return MakeUnique( message.add_loop_to_create_int_constant_synonym()); case protobufs::Transformation::TransformationCase:: kAddNoContractionDecoration: return MakeUnique( message.add_no_contraction_decoration()); case protobufs::Transformation::TransformationCase::kAddOpphiSynonym: return MakeUnique( message.add_opphi_synonym()); case protobufs::Transformation::TransformationCase::kAddParameter: return MakeUnique(message.add_parameter()); case protobufs::Transformation::TransformationCase::kAddRelaxedDecoration: return MakeUnique( message.add_relaxed_decoration()); case protobufs::Transformation::TransformationCase::kAddSpecConstantOp: return MakeUnique( message.add_spec_constant_op()); case protobufs::Transformation::TransformationCase::kAddSynonym: return MakeUnique(message.add_synonym()); case protobufs::Transformation::TransformationCase::kAddTypeArray: return MakeUnique(message.add_type_array()); case protobufs::Transformation::TransformationCase::kAddTypeBoolean: return MakeUnique( message.add_type_boolean()); case protobufs::Transformation::TransformationCase::kAddTypeFloat: return MakeUnique(message.add_type_float()); case protobufs::Transformation::TransformationCase::kAddTypeFunction: return MakeUnique( message.add_type_function()); case protobufs::Transformation::TransformationCase::kAddTypeInt: return MakeUnique(message.add_type_int()); case protobufs::Transformation::TransformationCase::kAddTypeMatrix: return MakeUnique(message.add_type_matrix()); case protobufs::Transformation::TransformationCase::kAddTypePointer: return MakeUnique( message.add_type_pointer()); case protobufs::Transformation::TransformationCase::kAddTypeStruct: return MakeUnique(message.add_type_struct()); case protobufs::Transformation::TransformationCase::kAddTypeVector: return MakeUnique(message.add_type_vector()); case protobufs::Transformation::TransformationCase::kAdjustBranchWeights: return MakeUnique( message.adjust_branch_weights()); case protobufs::Transformation::TransformationCase::kCompositeConstruct: return MakeUnique( message.composite_construct()); case protobufs::Transformation::TransformationCase::kCompositeExtract: return MakeUnique( message.composite_extract()); case protobufs::Transformation::TransformationCase::kCompositeInsert: return MakeUnique( message.composite_insert()); case protobufs::Transformation::TransformationCase:: kComputeDataSynonymFactClosure: return MakeUnique( message.compute_data_synonym_fact_closure()); case protobufs::Transformation::TransformationCase:: kDuplicateRegionWithSelection: return MakeUnique( message.duplicate_region_with_selection()); case protobufs::Transformation::TransformationCase::kEquationInstruction: return MakeUnique( message.equation_instruction()); case protobufs::Transformation::TransformationCase::kExpandVectorReduction: return MakeUnique( message.expand_vector_reduction()); case protobufs::Transformation::TransformationCase:: kFlattenConditionalBranch: return MakeUnique( message.flatten_conditional_branch()); case protobufs::Transformation::TransformationCase::kFunctionCall: return MakeUnique(message.function_call()); case protobufs::Transformation::TransformationCase::kInlineFunction: return MakeUnique( message.inline_function()); case protobufs::Transformation::TransformationCase:: kInvertComparisonOperator: return MakeUnique( message.invert_comparison_operator()); case protobufs::Transformation::TransformationCase::kLoad: return MakeUnique(message.load()); case protobufs::Transformation::TransformationCase:: kMakeVectorOperationDynamic: return MakeUnique( message.make_vector_operation_dynamic()); case protobufs::Transformation::TransformationCase::kMergeBlocks: return MakeUnique(message.merge_blocks()); case protobufs::Transformation::TransformationCase::kMergeFunctionReturns: return MakeUnique( message.merge_function_returns()); case protobufs::Transformation::TransformationCase::kMoveBlockDown: return MakeUnique(message.move_block_down()); case protobufs::Transformation::TransformationCase::kMoveInstructionDown: return MakeUnique( message.move_instruction_down()); case protobufs::Transformation::TransformationCase::kMutatePointer: return MakeUnique(message.mutate_pointer()); case protobufs::Transformation::TransformationCase::kOutlineFunction: return MakeUnique( message.outline_function()); case protobufs::Transformation::TransformationCase:: kPermuteFunctionParameters: return MakeUnique( message.permute_function_parameters()); case protobufs::Transformation::TransformationCase::kPermutePhiOperands: return MakeUnique( message.permute_phi_operands()); case protobufs::Transformation::TransformationCase:: kPropagateInstructionDown: return MakeUnique( message.propagate_instruction_down()); case protobufs::Transformation::TransformationCase::kPropagateInstructionUp: return MakeUnique( message.propagate_instruction_up()); case protobufs::Transformation::TransformationCase::kPushIdThroughVariable: return MakeUnique( message.push_id_through_variable()); case protobufs::Transformation::TransformationCase:: kRecordSynonymousConstants: return MakeUnique( message.record_synonymous_constants()); case protobufs::Transformation::TransformationCase:: kReplaceAddSubMulWithCarryingExtended: return MakeUnique( message.replace_add_sub_mul_with_carrying_extended()); case protobufs::Transformation::TransformationCase:: kReplaceBooleanConstantWithConstantBinary: return MakeUnique( message.replace_boolean_constant_with_constant_binary()); case protobufs::Transformation::TransformationCase:: kReplaceBranchFromDeadBlockWithExit: return MakeUnique( message.replace_branch_from_dead_block_with_exit()); case protobufs::Transformation::TransformationCase:: kReplaceConstantWithUniform: return MakeUnique( message.replace_constant_with_uniform()); case protobufs::Transformation::TransformationCase:: kReplaceCopyMemoryWithLoadStore: return MakeUnique( message.replace_copy_memory_with_load_store()); case protobufs::Transformation::TransformationCase:: kReplaceCopyObjectWithStoreLoad: return MakeUnique( message.replace_copy_object_with_store_load()); case protobufs::Transformation::TransformationCase::kReplaceIdWithSynonym: return MakeUnique( message.replace_id_with_synonym()); case protobufs::Transformation::TransformationCase::kReplaceIrrelevantId: return MakeUnique( message.replace_irrelevant_id()); case protobufs::Transformation::TransformationCase:: kReplaceLinearAlgebraInstruction: return MakeUnique( message.replace_linear_algebra_instruction()); case protobufs::Transformation::TransformationCase:: kReplaceLoadStoreWithCopyMemory: return MakeUnique( message.replace_load_store_with_copy_memory()); case protobufs::Transformation::TransformationCase:: kReplaceOpselectWithConditionalBranch: return MakeUnique( message.replace_opselect_with_conditional_branch()); case protobufs::Transformation::TransformationCase:: kReplaceParameterWithGlobal: return MakeUnique( message.replace_parameter_with_global()); case protobufs::Transformation::TransformationCase:: kReplaceParamsWithStruct: return MakeUnique( message.replace_params_with_struct()); case protobufs::Transformation::TransformationCase:: kReplaceOpphiIdFromDeadPredecessor: return MakeUnique( message.replace_opphi_id_from_dead_predecessor()); case protobufs::Transformation::TransformationCase::kSetFunctionControl: return MakeUnique( message.set_function_control()); case protobufs::Transformation::TransformationCase::kSetLoopControl: return MakeUnique( message.set_loop_control()); case protobufs::Transformation::TransformationCase::kSetMemoryOperandsMask: return MakeUnique( message.set_memory_operands_mask()); case protobufs::Transformation::TransformationCase::kSetSelectionControl: return MakeUnique( message.set_selection_control()); case protobufs::Transformation::TransformationCase::kSplitBlock: return MakeUnique(message.split_block()); case protobufs::Transformation::TransformationCase::kStore: return MakeUnique(message.store()); case protobufs::Transformation::TransformationCase::kSwapCommutableOperands: return MakeUnique( message.swap_commutable_operands()); case protobufs::Transformation::TransformationCase:: kSwapConditionalBranchOperands: return MakeUnique( message.swap_conditional_branch_operands()); case protobufs::Transformation::TransformationCase::kSwapFunctionVariables: return MakeUnique( message.swap_function_variables()); case protobufs::Transformation::TransformationCase::kSwapTwoFunctions: return MakeUnique( message.swap_two_functions()); case protobufs::Transformation::TransformationCase:: kToggleAccessChainInstruction: return MakeUnique( message.toggle_access_chain_instruction()); case protobufs::Transformation::TransformationCase::kVectorShuffle: return MakeUnique(message.vector_shuffle()); case protobufs::Transformation::TransformationCase:: kWrapEarlyTerminatorInFunction: return MakeUnique( message.wrap_early_terminator_in_function()); case protobufs::Transformation::TransformationCase::kWrapRegionInSelection: return MakeUnique( message.wrap_region_in_selection()); case protobufs::Transformation::TransformationCase::kWrapVectorSynonym: return MakeUnique( message.wrap_vector_synonym()); case protobufs::Transformation::TRANSFORMATION_NOT_SET: assert(false && "An unset transformation was encountered."); return nullptr; } assert(false && "Should be unreachable as all cases must be handled above."); return nullptr; } bool Transformation::CheckIdIsFreshAndNotUsedByThisTransformation( uint32_t id, opt::IRContext* ir_context, std::set* ids_used_by_this_transformation) { if (!fuzzerutil::IsFreshId(ir_context, id)) { return false; } if (ids_used_by_this_transformation->count(id) != 0) { return false; } ids_used_by_this_transformation->insert(id); return true; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation.h000066400000000000000000000117321475742701700242520ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_H_ #define SOURCE_FUZZ_TRANSFORMATION_H_ #include #include #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { // Rules for transformations // ------------------------- // // - Immutability: a transformation must be immutable. // - Ability to copy and serialize: to ensure that a copy of a transformation, // possibly saved out to disk and read back again, is indistinguishable // from the original transformation, thus a transformation must depend // only on well-defined pieces of state, such as instruction ids. It must // not rely on state such as pointers to instructions and blocks. // - Determinism: the effect of a transformation on a module be a deterministic // function of the module and the transformation. Any randomization should // be applied before creating the transformation, not during its // application. // - Well-defined and precondition: the 'IsApplicable' method should only // return true if the transformation can be cleanly applied to the given // module, to mutate it into a valid and semantically-equivalent module, as // long as the module is initially valid. // - Ability to test precondition on any valid module: 'IsApplicable' should be // designed so that it is safe to ask whether a transformation is // applicable to an arbitrary valid module. For example, if a // transformation involves a block id, 'IsApplicable' should check whether // the module indeed has a block with that id, and return false if not. It // must not assume that there is such a block. // - Documented precondition: while the implementation of 'IsApplicable' should // should codify the precondition, the method should be commented in the // header file for a transformation with a precise English description of // the precondition. // - Documented effect: while the implementation of 'Apply' should codify the // effect of the transformation, the method should be commented in the // header file for a transformation with a precise English description of // the effect. class Transformation { public: virtual ~Transformation(); // Factory method to obtain a transformation object from the protobuf // representation of a transformation given by |message|. static std::unique_ptr FromMessage( const protobufs::Transformation& message); // A precondition that determines whether the transformation can be cleanly // applied in a semantics-preserving manner to the SPIR-V module given by // |ir_context|, in the presence of facts and other contextual information // captured by |transformation_context|. // // Preconditions for individual transformations must be documented in the // associated header file using precise English. The transformation context // provides access to facts about the module that are known to be true, on // which the precondition may depend. virtual bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const = 0; // Requires that IsApplicable(ir_context, *transformation_context) holds. // Applies the transformation, mutating |ir_context| and possibly updating // |transformation_context| with new facts established by the transformation. virtual void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const = 0; // Returns the set of fresh ids that appear in the transformation's protobuf // message. virtual std::unordered_set GetFreshIds() const = 0; // Turns the transformation into a protobuf message for serialization. virtual protobufs::Transformation ToMessage() const = 0; // Helper that returns true if and only if (a) |id| is a fresh id for the // module, and (b) |id| is not in |ids_used_by_this_transformation|, a set of // ids already known to be in use by a transformation. This is useful when // checking id freshness for a transformation that uses many ids, all of which // must be distinct. static bool CheckIdIsFreshAndNotUsedByThisTransformation( uint32_t id, opt::IRContext* ir_context, std::set* ids_used_by_this_transformation); }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_access_chain.cpp000066400000000000000000000420041475742701700272640ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_access_chain.h" #include #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" namespace spvtools { namespace fuzz { TransformationAccessChain::TransformationAccessChain( protobufs::TransformationAccessChain message) : message_(std::move(message)) {} TransformationAccessChain::TransformationAccessChain( uint32_t fresh_id, uint32_t pointer_id, const std::vector& index_id, const protobufs::InstructionDescriptor& instruction_to_insert_before, const std::vector>& fresh_ids_for_clamping) { message_.set_fresh_id(fresh_id); message_.set_pointer_id(pointer_id); for (auto id : index_id) { message_.add_index_id(id); } *message_.mutable_instruction_to_insert_before() = instruction_to_insert_before; for (auto clamping_ids_pair : fresh_ids_for_clamping) { protobufs::UInt32Pair pair; pair.set_first(clamping_ids_pair.first); pair.set_second(clamping_ids_pair.second); *message_.add_fresh_ids_for_clamping() = pair; } } bool TransformationAccessChain::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { // Keep track of the fresh ids used to make sure that they are distinct. std::set fresh_ids_used; // The result id must be fresh. if (!CheckIdIsFreshAndNotUsedByThisTransformation( message_.fresh_id(), ir_context, &fresh_ids_used)) { return false; } // The pointer id must exist and have a type. auto pointer = ir_context->get_def_use_mgr()->GetDef(message_.pointer_id()); if (!pointer || !pointer->type_id()) { return false; } // The type must indeed be a pointer. auto pointer_type = ir_context->get_def_use_mgr()->GetDef(pointer->type_id()); if (pointer_type->opcode() != spv::Op::OpTypePointer) { return false; } // The described instruction to insert before must exist and be a suitable // point where an OpAccessChain instruction could be inserted. auto instruction_to_insert_before = FindInstruction(message_.instruction_to_insert_before(), ir_context); if (!instruction_to_insert_before) { return false; } if (!fuzzerutil::CanInsertOpcodeBeforeInstruction( spv::Op::OpAccessChain, instruction_to_insert_before)) { return false; } // Do not allow making an access chain from a null or undefined pointer, as // we do not want to allow accessing such pointers. This might be acceptable // in dead blocks, but we conservatively avoid it. switch (pointer->opcode()) { case spv::Op::OpConstantNull: case spv::Op::OpUndef: assert( false && "Access chains should not be created from null/undefined pointers"); return false; default: break; } // The pointer on which the access chain is to be based needs to be available // (according to dominance rules) at the insertion point. if (!fuzzerutil::IdIsAvailableBeforeInstruction( ir_context, instruction_to_insert_before, message_.pointer_id())) { return false; } // We now need to use the given indices to walk the type structure of the // base type of the pointer, making sure that (a) the indices correspond to // integers, and (b) these integer values are in-bounds. // Start from the base type of the pointer. uint32_t subobject_type_id = pointer_type->GetSingleWordInOperand(1); int id_pairs_used = 0; // Consider the given index ids in turn. for (auto index_id : message_.index_id()) { // The index value will correspond to the value of the index if the object // is a struct, otherwise the value 0 will be used. uint32_t index_value; // Check whether the object is a struct. if (ir_context->get_def_use_mgr()->GetDef(subobject_type_id)->opcode() == spv::Op::OpTypeStruct) { // It is a struct: we need to retrieve the integer value. bool successful; std::tie(successful, index_value) = GetStructIndexValue(ir_context, index_id, subobject_type_id); if (!successful) { return false; } } else { // It is not a struct: the index will need clamping. if (message_.fresh_ids_for_clamping().size() <= id_pairs_used) { // We don't have enough ids return false; } // Get two new ids to use and update the amount used. protobufs::UInt32Pair fresh_ids = message_.fresh_ids_for_clamping()[id_pairs_used++]; // Valid ids need to have been given if (fresh_ids.first() == 0 || fresh_ids.second() == 0) { return false; } // Check that the ids are actually fresh and not already used by this // transformation. if (!CheckIdIsFreshAndNotUsedByThisTransformation( fresh_ids.first(), ir_context, &fresh_ids_used) || !CheckIdIsFreshAndNotUsedByThisTransformation( fresh_ids.second(), ir_context, &fresh_ids_used)) { return false; } if (!ValidIndexToComposite(ir_context, index_id, subobject_type_id)) { return false; } // Perform the clamping using the fresh ids at our disposal. auto index_instruction = ir_context->get_def_use_mgr()->GetDef(index_id); uint32_t bound = fuzzerutil::GetBoundForCompositeIndex( *ir_context->get_def_use_mgr()->GetDef(subobject_type_id), ir_context); // The module must have an integer constant of value bound-1 of the same // type as the index. if (!fuzzerutil::MaybeGetIntegerConstantFromValueAndType( ir_context, bound - 1, index_instruction->type_id())) { return false; } // The module must have the definition of bool type to make a comparison. if (!fuzzerutil::MaybeGetBoolType(ir_context)) { return false; } // The index is not necessarily a constant, so we may not know its value. // We can use index 0 because the components of a non-struct composite // all have the same type, and index 0 is always in bounds. index_value = 0; } // Try to walk down the type using this index. This will yield 0 if the // type is not a composite or the index is out of bounds, and the id of // the next type otherwise. subobject_type_id = fuzzerutil::WalkOneCompositeTypeIndex( ir_context, subobject_type_id, index_value); if (!subobject_type_id) { // Either the type was not a composite (so that too many indices were // provided), or the index was out of bounds. return false; } } // At this point, |subobject_type_id| is the type of the value targeted by // the new access chain. The result type of the access chain should be a // pointer to this type, with the same storage class as for the original // pointer. Such a pointer type needs to exist in the module. // // We do not use the type manager to look up this type, due to problems // associated with pointers to isomorphic structs being regarded as the same. return fuzzerutil::MaybeGetPointerType( ir_context, subobject_type_id, static_cast( pointer_type->GetSingleWordInOperand(0))) != 0; } void TransformationAccessChain::Apply( opt::IRContext* ir_context, TransformationContext* transformation_context) const { // The operands to the access chain are the pointer followed by the indices. // The result type of the access chain is determined by where the indices // lead. We thus push the pointer to a sequence of operands, and then follow // the indices, pushing each to the operand list and tracking the type // obtained by following it. Ultimately this yields the type of the // component reached by following all the indices, and the result type is // a pointer to this component type. opt::Instruction::OperandList operands; // Add the pointer id itself. operands.push_back({SPV_OPERAND_TYPE_ID, {message_.pointer_id()}}); // Start walking the indices, starting with the pointer's base type. auto pointer_type = ir_context->get_def_use_mgr()->GetDef( ir_context->get_def_use_mgr()->GetDef(message_.pointer_id())->type_id()); uint32_t subobject_type_id = pointer_type->GetSingleWordInOperand(1); uint32_t id_pairs_used = 0; opt::Instruction* instruction_to_insert_before = FindInstruction(message_.instruction_to_insert_before(), ir_context); opt::BasicBlock* enclosing_block = ir_context->get_instr_block(instruction_to_insert_before); // Go through the index ids in turn. for (auto index_id : message_.index_id()) { uint32_t index_value; // Actual id to be used in the instruction: the original id // or the clamped one. uint32_t new_index_id; // Check whether the object is a struct. if (ir_context->get_def_use_mgr()->GetDef(subobject_type_id)->opcode() == spv::Op::OpTypeStruct) { // It is a struct: we need to retrieve the integer value. index_value = GetStructIndexValue(ir_context, index_id, subobject_type_id).second; new_index_id = index_id; } else { // It is not a struct: the index will need clamping. // Get two new ids to use and update the amount used. protobufs::UInt32Pair fresh_ids = message_.fresh_ids_for_clamping()[id_pairs_used++]; // Perform the clamping using the fresh ids at our disposal. // The module will not be changed if |add_clamping_instructions| is not // set. auto index_instruction = ir_context->get_def_use_mgr()->GetDef(index_id); uint32_t bound = fuzzerutil::GetBoundForCompositeIndex( *ir_context->get_def_use_mgr()->GetDef(subobject_type_id), ir_context); auto bound_minus_one_id = fuzzerutil::MaybeGetIntegerConstantFromValueAndType( ir_context, bound - 1, index_instruction->type_id()); assert(bound_minus_one_id && "A constant of value bound - 1 and the same type as the index " "must exist as a precondition."); uint32_t bool_type_id = fuzzerutil::MaybeGetBoolType(ir_context); assert(bool_type_id && "An OpTypeBool instruction must exist as a precondition."); auto int_type_inst = ir_context->get_def_use_mgr()->GetDef(index_instruction->type_id()); // Clamp the integer and add the corresponding instructions in the module // if |add_clamping_instructions| is set. // Compare the index with the bound via an instruction of the form: // %fresh_ids.first = OpULessThanEqual %bool %int_id %bound_minus_one. fuzzerutil::UpdateModuleIdBound(ir_context, fresh_ids.first()); auto comparison_instruction = MakeUnique( ir_context, spv::Op::OpULessThanEqual, bool_type_id, fresh_ids.first(), opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {index_instruction->result_id()}}, {SPV_OPERAND_TYPE_ID, {bound_minus_one_id}}})); auto comparison_instruction_ptr = comparison_instruction.get(); instruction_to_insert_before->InsertBefore( std::move(comparison_instruction)); ir_context->get_def_use_mgr()->AnalyzeInstDefUse( comparison_instruction_ptr); ir_context->set_instr_block(comparison_instruction_ptr, enclosing_block); // Select the index if in-bounds, otherwise one less than the bound: // %fresh_ids.second = OpSelect %int_type %fresh_ids.first %int_id // %bound_minus_one fuzzerutil::UpdateModuleIdBound(ir_context, fresh_ids.second()); auto select_instruction = MakeUnique( ir_context, spv::Op::OpSelect, int_type_inst->result_id(), fresh_ids.second(), opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {fresh_ids.first()}}, {SPV_OPERAND_TYPE_ID, {index_instruction->result_id()}}, {SPV_OPERAND_TYPE_ID, {bound_minus_one_id}}})); auto select_instruction_ptr = select_instruction.get(); instruction_to_insert_before->InsertBefore(std::move(select_instruction)); ir_context->get_def_use_mgr()->AnalyzeInstDefUse(select_instruction_ptr); ir_context->set_instr_block(select_instruction_ptr, enclosing_block); new_index_id = fresh_ids.second(); index_value = 0; } // Add the correct index id to the operands. operands.push_back({SPV_OPERAND_TYPE_ID, {new_index_id}}); // Walk to the next type in the composite object using this index. subobject_type_id = fuzzerutil::WalkOneCompositeTypeIndex( ir_context, subobject_type_id, index_value); } // The access chain's result type is a pointer to the composite component // that was reached after following all indices. The storage class is that // of the original pointer. uint32_t result_type = fuzzerutil::MaybeGetPointerType( ir_context, subobject_type_id, static_cast(pointer_type->GetSingleWordInOperand(0))); // Add the access chain instruction to the module, and update the module's // id bound. fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id()); auto access_chain_instruction = MakeUnique(ir_context, spv::Op::OpAccessChain, result_type, message_.fresh_id(), operands); auto access_chain_instruction_ptr = access_chain_instruction.get(); instruction_to_insert_before->InsertBefore( std::move(access_chain_instruction)); ir_context->get_def_use_mgr()->AnalyzeInstDefUse( access_chain_instruction_ptr); ir_context->set_instr_block(access_chain_instruction_ptr, enclosing_block); // If the base pointer's pointee value was irrelevant, the same is true of // the pointee value of the result of this access chain. if (transformation_context->GetFactManager()->PointeeValueIsIrrelevant( message_.pointer_id())) { transformation_context->GetFactManager()->AddFactValueOfPointeeIsIrrelevant( message_.fresh_id()); } } protobufs::Transformation TransformationAccessChain::ToMessage() const { protobufs::Transformation result; *result.mutable_access_chain() = message_; return result; } std::pair TransformationAccessChain::GetStructIndexValue( opt::IRContext* ir_context, uint32_t index_id, uint32_t object_type_id) const { assert(ir_context->get_def_use_mgr()->GetDef(object_type_id)->opcode() == spv::Op::OpTypeStruct && "Precondition: the type must be a struct type."); if (!ValidIndexToComposite(ir_context, index_id, object_type_id)) { return {false, 0}; } auto index_instruction = ir_context->get_def_use_mgr()->GetDef(index_id); uint32_t bound = fuzzerutil::GetBoundForCompositeIndex( *ir_context->get_def_use_mgr()->GetDef(object_type_id), ir_context); // Ensure that the index given must represent a constant. assert(spvOpcodeIsConstant(index_instruction->opcode()) && "A non-constant index should already have been rejected."); // The index must be in bounds. uint32_t value = index_instruction->GetSingleWordInOperand(0); if (value >= bound) { return {false, 0}; } return {true, value}; } bool TransformationAccessChain::ValidIndexToComposite( opt::IRContext* ir_context, uint32_t index_id, uint32_t object_type_id) { auto object_type_def = ir_context->get_def_use_mgr()->GetDef(object_type_id); // The object being indexed must be a composite. if (!spvOpcodeIsComposite(object_type_def->opcode())) { return false; } // Get the defining instruction of the index. auto index_instruction = ir_context->get_def_use_mgr()->GetDef(index_id); if (!index_instruction) { return false; } // The index type must be 32-bit integer. auto index_type = ir_context->get_def_use_mgr()->GetDef(index_instruction->type_id()); if (index_type->opcode() != spv::Op::OpTypeInt || index_type->GetSingleWordInOperand(0) != 32) { return false; } // If the object being traversed is a struct, the id must correspond to an // in-bound constant. if (object_type_def->opcode() == spv::Op::OpTypeStruct) { if (!spvOpcodeIsConstant(index_instruction->opcode())) { return false; } } return true; } std::unordered_set TransformationAccessChain::GetFreshIds() const { std::unordered_set result = {message_.fresh_id()}; for (auto& fresh_ids_for_clamping : message_.fresh_ids_for_clamping()) { result.insert(fresh_ids_for_clamping.first()); result.insert(fresh_ids_for_clamping.second()); } return result; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_access_chain.h000066400000000000000000000112741475742701700267360ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_ACCESS_CHAIN_H_ #define SOURCE_FUZZ_TRANSFORMATION_ACCESS_CHAIN_H_ #include #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationAccessChain : public Transformation { public: explicit TransformationAccessChain( protobufs::TransformationAccessChain message); TransformationAccessChain( uint32_t fresh_id, uint32_t pointer_id, const std::vector& index_id, const protobufs::InstructionDescriptor& instruction_to_insert_before, const std::vector>& fresh_ids_for_clamping = {}); // - |message_.fresh_id| must be fresh. // - |message_.instruction_to_insert_before| must identify an instruction // before which it is legitimate to insert an OpAccessChain instruction. // - |message_.pointer_id| must be a result id with pointer type that is // available (according to dominance rules) at the insertion point. // - The pointer must not be OpConstantNull or OpUndef. // - |message_.index_id| must be a sequence of ids of 32-bit integers // such that it is possible to walk the pointee type of // |message_.pointer_id| using these indices. // - All indices used to access a struct must be OpConstant. // - The indices used to index non-struct composites will be clamped to be // in bound. Enough fresh ids must be given in // |message_.fresh_id_for_clamping| to perform clamping (2 for // each index accessing a non-struct). This requires the bool type and // a constant of value (bound - 1) to be declared in the module. // - If type t is the final type reached by walking these indices, the module // must include an instruction "OpTypePointer SC %t" where SC is the storage // class associated with |message_.pointer_id|. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Adds an instruction of the form: // |message_.fresh_id| = OpAccessChain %ptr |message_.index_id| // where %ptr is the result if of an instruction declaring a pointer to the // type reached by walking the pointee type of |message_.pointer_id| using // the indices in |message_.index_id|, and with the same storage class as // |message_.pointer_id|. // // For each of the indices traversing non-struct composites, two clamping // instructions are added using ids in |message_.fresh_id_for_clamping|. // // If the fact manager in |transformation_context| reports that // |message_.pointer_id| has an irrelevant pointee value, then the fact that // |message_.fresh_id| (the result of the access chain) also has an irrelevant // pointee value is also recorded. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: // Returns {false, 0} in each of the following cases: // - |index_id| does not correspond to a 32-bit integer constant // - |object_type_id| must be a struct type // - the constant at |index_id| is out of bounds. // Otherwise, returns {true, value}, where value is the value of the constant // at |index_id|. std::pair GetStructIndexValue(opt::IRContext* ir_context, uint32_t index_id, uint32_t object_type_id) const; // Returns true if |index_id| corresponds, in the given context, to a 32-bit // integer which can be used to index an object of the type specified by // |object_type_id|. Returns false otherwise. static bool ValidIndexToComposite(opt::IRContext* ir_context, uint32_t index_id, uint32_t object_type_id); protobufs::TransformationAccessChain message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_ACCESS_CHAIN_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_bit_instruction_synonym.cpp000066400000000000000000000302441475742701700325070ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_bit_instruction_synonym.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" namespace spvtools { namespace fuzz { TransformationAddBitInstructionSynonym::TransformationAddBitInstructionSynonym( protobufs::TransformationAddBitInstructionSynonym message) : message_(std::move(message)) {} TransformationAddBitInstructionSynonym::TransformationAddBitInstructionSynonym( const uint32_t instruction_result_id, const std::vector& fresh_ids) { message_.set_instruction_result_id(instruction_result_id); *message_.mutable_fresh_ids() = google::protobuf::RepeatedField( fresh_ids.begin(), fresh_ids.end()); } bool TransformationAddBitInstructionSynonym::IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const { auto instruction = ir_context->get_def_use_mgr()->GetDef(message_.instruction_result_id()); // Checks on: only integer operands are supported, instructions are bitwise // operations only. Signedness of the operands must be the same. if (!IsInstructionSupported(ir_context, instruction)) { return false; } // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/3791): // This condition could be relaxed if the index exists as another integer // type. // All bit indexes must be defined as 32-bit unsigned integers. uint32_t width = ir_context->get_type_mgr() ->GetType(instruction->type_id()) ->AsInteger() ->width(); for (uint32_t i = 0; i < width; i++) { if (!fuzzerutil::MaybeGetIntegerConstant(ir_context, transformation_context, {i}, 32, false, false)) { return false; } } // |message_.fresh_ids.size| must have the exact number of fresh ids required // to apply the transformation. if (static_cast(message_.fresh_ids().size()) != GetRequiredFreshIdCount(ir_context, instruction)) { return false; } // All ids in |message_.fresh_ids| must be fresh. for (uint32_t fresh_id : message_.fresh_ids()) { if (!fuzzerutil::IsFreshId(ir_context, fresh_id)) { return false; } } return true; } void TransformationAddBitInstructionSynonym::Apply( opt::IRContext* ir_context, TransformationContext* transformation_context) const { auto bit_instruction = ir_context->get_def_use_mgr()->GetDef(message_.instruction_result_id()); // Use an appropriate helper function to add the new instruction and new // synonym fact. The helper function should take care of invalidating // analyses before adding facts. switch (bit_instruction->opcode()) { case spv::Op::OpBitwiseOr: case spv::Op::OpBitwiseXor: case spv::Op::OpBitwiseAnd: case spv::Op::OpNot: AddOpBitwiseOrOpNotSynonym(ir_context, transformation_context, bit_instruction); break; default: assert(false && "Should be unreachable."); break; } } bool TransformationAddBitInstructionSynonym::IsInstructionSupported( opt::IRContext* ir_context, opt::Instruction* instruction) { // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/3557): // Right now we only support certain operations. When this issue is addressed // the following conditional can use the function |spvOpcodeIsBit|. // |instruction| must be defined and must be a supported bit instruction. if (!instruction || (instruction->opcode() != spv::Op::OpBitwiseOr && instruction->opcode() != spv::Op::OpBitwiseXor && instruction->opcode() != spv::Op::OpBitwiseAnd && instruction->opcode() != spv::Op::OpNot)) { return false; } // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/3792): // Right now, only integer operands are supported. if (ir_context->get_type_mgr()->GetType(instruction->type_id())->AsVector()) { return false; } if (instruction->opcode() == spv::Op::OpNot) { auto operand = instruction->GetInOperand(0).words[0]; auto operand_inst = ir_context->get_def_use_mgr()->GetDef(operand); auto operand_type = ir_context->get_type_mgr()->GetType(operand_inst->type_id()); auto operand_sign = operand_type->AsInteger()->IsSigned(); auto type_id_sign = ir_context->get_type_mgr() ->GetType(instruction->type_id()) ->AsInteger() ->IsSigned(); return operand_sign == type_id_sign; } else { // Other BitWise operations that takes two operands. auto first_operand = instruction->GetInOperand(0).words[0]; auto first_operand_inst = ir_context->get_def_use_mgr()->GetDef(first_operand); auto first_operand_type = ir_context->get_type_mgr()->GetType(first_operand_inst->type_id()); auto first_operand_sign = first_operand_type->AsInteger()->IsSigned(); auto second_operand = instruction->GetInOperand(1).words[0]; auto second_operand_inst = ir_context->get_def_use_mgr()->GetDef(second_operand); auto second_operand_type = ir_context->get_type_mgr()->GetType(second_operand_inst->type_id()); auto second_operand_sign = second_operand_type->AsInteger()->IsSigned(); auto type_id_sign = ir_context->get_type_mgr() ->GetType(instruction->type_id()) ->AsInteger() ->IsSigned(); return first_operand_sign == second_operand_sign && first_operand_sign == type_id_sign; } } protobufs::Transformation TransformationAddBitInstructionSynonym::ToMessage() const { protobufs::Transformation result; *result.mutable_add_bit_instruction_synonym() = message_; return result; } uint32_t TransformationAddBitInstructionSynonym::GetRequiredFreshIdCount( opt::IRContext* ir_context, opt::Instruction* bit_instruction) { // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/3557): // Right now, only certain operations are supported. switch (bit_instruction->opcode()) { case spv::Op::OpBitwiseOr: case spv::Op::OpBitwiseXor: case spv::Op::OpBitwiseAnd: case spv::Op::OpNot: return (2 + bit_instruction->NumInOperands()) * ir_context->get_type_mgr() ->GetType(bit_instruction->type_id()) ->AsInteger() ->width() - 1; default: assert(false && "Unsupported bit instruction."); return 0; } } void TransformationAddBitInstructionSynonym::AddOpBitwiseOrOpNotSynonym( opt::IRContext* ir_context, TransformationContext* transformation_context, opt::Instruction* bit_instruction) const { // Fresh id iterator. auto fresh_id = message_.fresh_ids().begin(); // |width| is the bit width of operands (8, 16, 32 or 64). const uint32_t width = ir_context->get_type_mgr() ->GetType(bit_instruction->type_id()) ->AsInteger() ->width(); // |count| is the number of bits to be extracted and inserted at a time. const uint32_t count = fuzzerutil::MaybeGetIntegerConstant( ir_context, *transformation_context, {1}, 32, false, false); // |extracted_bit_instructions| is the collection of OpBiwise* or OpNot // instructions that evaluate the extracted bits. Those ids will be used to // insert the result bits. std::vector extracted_bit_instructions(width); for (uint32_t i = 0; i < width; i++) { // |offset| is the current bit index. uint32_t offset = fuzzerutil::MaybeGetIntegerConstant( ir_context, *transformation_context, {i}, 32, false, false); // |bit_extract_ids| are the two extracted bits from the operands. opt::Instruction::OperandList bit_extract_ids; // Extracts the i-th bit from operands. for (auto operand = bit_instruction->begin() + 2; operand != bit_instruction->end(); operand++) { auto bit_extract = opt::Instruction(ir_context, spv::Op::OpBitFieldUExtract, bit_instruction->type_id(), *fresh_id++, {{SPV_OPERAND_TYPE_ID, operand->words}, {SPV_OPERAND_TYPE_ID, {offset}}, {SPV_OPERAND_TYPE_ID, {count}}}); bit_instruction->InsertBefore(MakeUnique(bit_extract)); fuzzerutil::UpdateModuleIdBound(ir_context, bit_extract.result_id()); bit_extract_ids.push_back( {SPV_OPERAND_TYPE_ID, {bit_extract.result_id()}}); } // Applies |bit_instruction| to the extracted bits. auto extracted_bit_instruction = opt::Instruction( ir_context, bit_instruction->opcode(), bit_instruction->type_id(), *fresh_id++, bit_extract_ids); bit_instruction->InsertBefore( MakeUnique(extracted_bit_instruction)); fuzzerutil::UpdateModuleIdBound(ir_context, extracted_bit_instruction.result_id()); extracted_bit_instructions[i] = extracted_bit_instruction.result_id(); } // The first two ids in |extracted_bit_instructions| are used to insert the // first two bits of the result. uint32_t offset = fuzzerutil::MaybeGetIntegerConstant( ir_context, *transformation_context, {1}, 32, false, false); auto bit_insert = opt::Instruction(ir_context, spv::Op::OpBitFieldInsert, bit_instruction->type_id(), *fresh_id++, {{SPV_OPERAND_TYPE_ID, {extracted_bit_instructions[0]}}, {SPV_OPERAND_TYPE_ID, {extracted_bit_instructions[1]}}, {SPV_OPERAND_TYPE_ID, {offset}}, {SPV_OPERAND_TYPE_ID, {count}}}); bit_instruction->InsertBefore(MakeUnique(bit_insert)); fuzzerutil::UpdateModuleIdBound(ir_context, bit_insert.result_id()); // Inserts the remaining bits. for (uint32_t i = 2; i < width; i++) { offset = fuzzerutil::MaybeGetIntegerConstant( ir_context, *transformation_context, {i}, 32, false, false); bit_insert = opt::Instruction( ir_context, spv::Op::OpBitFieldInsert, bit_instruction->type_id(), *fresh_id++, {{SPV_OPERAND_TYPE_ID, {bit_insert.result_id()}}, {SPV_OPERAND_TYPE_ID, {extracted_bit_instructions[i]}}, {SPV_OPERAND_TYPE_ID, {offset}}, {SPV_OPERAND_TYPE_ID, {count}}}); bit_instruction->InsertBefore(MakeUnique(bit_insert)); fuzzerutil::UpdateModuleIdBound(ir_context, bit_insert.result_id()); } ir_context->InvalidateAnalysesExceptFor(opt::IRContext::kAnalysisNone); // We only add a synonym fact if the bit instruction is not irrelevant, and if // the new result id we would make it synonymous with is not irrelevant. (It // could be irrelevant if we are in a dead block.) if (!transformation_context->GetFactManager()->IdIsIrrelevant( bit_instruction->result_id()) && !transformation_context->GetFactManager()->IdIsIrrelevant( bit_insert.result_id())) { // Adds the fact that the last |bit_insert| instruction is synonymous of // |bit_instruction|. transformation_context->GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(bit_insert.result_id(), {}), MakeDataDescriptor(bit_instruction->result_id(), {})); } } std::unordered_set TransformationAddBitInstructionSynonym::GetFreshIds() const { std::unordered_set result; for (auto id : message_.fresh_ids()) { result.insert(id); } return result; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_bit_instruction_synonym.h000066400000000000000000000260021475742701700321510ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_ADD_BIT_INSTRUCTION_SYNONYM_H_ #define SOURCE_FUZZ_TRANSFORMATION_ADD_BIT_INSTRUCTION_SYNONYM_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { // clang-format off // SPIR-V code to help understand the transformation. // // ---------------------------------------------------------------------------------------------------------------- // | Reference shader | Variant shader | // ---------------------------------------------------------------------------------------------------------------- // | OpCapability Shader | OpCapability Shader | // | OpCapability Int8 | OpCapability Int8 | // | %1 = OpExtInstImport "GLSL.std.450" | %1 = OpExtInstImport "GLSL.std.450" | // | OpMemoryModel Logical GLSL450 | OpMemoryModel Logical GLSL450 | // | OpEntryPoint Vertex %7 "main" | OpEntryPoint Vertex %7 "main" | // | | | // | ; Types | ; Types | // | %2 = OpTypeInt 8 0 | %2 = OpTypeInt 8 0 | // | %3 = OpTypeVoid | %3 = OpTypeVoid | // | %4 = OpTypeFunction %3 | %4 = OpTypeFunction %3 | // | | | // | ; Constants | ; Constants | // | %5 = OpConstant %2 0 | %5 = OpConstant %2 0 | // | %6 = OpConstant %2 1 | %6 = OpConstant %2 1 | // | | %10 = OpConstant %2 2 | // | ; main function | %11 = OpConstant %2 3 | // | %7 = OpFunction %3 None %4 | %12 = OpConstant %2 4 | // | %8 = OpLabel | %13 = OpConstant %2 5 | // | %9 = OpBitwiseOr %2 %5 %6 ; bit instruction | %14 = OpConstant %2 6 | // | OpReturn | %15 = OpConstant %2 7 | // | OpFunctionEnd | | // | | ; main function | // | | %7 = OpFunction %3 None %4 | // | | %8 = OpLabel | // | | | // | | %16 = OpBitFieldUExtract %2 %5 %5 %6 ; extracts bit 0 from %5 | // | | %17 = OpBitFieldUExtract %2 %6 %5 %6 ; extracts bit 0 from %6 | // | | %18 = OpBitwiseOr %2 %16 %17 | // | | | // | | %19 = OpBitFieldUExtract %2 %5 %6 %6 ; extracts bit 1 from %5 | // | | %20 = OpBitFieldUExtract %2 %6 %6 %6 ; extracts bit 1 from %6 | // | | %21 = OpBitwiseOr %2 %19 %20 | // | | | // | | %22 = OpBitFieldUExtract %2 %5 %10 %6 ; extracts bit 2 from %5 | // | | %23 = OpBitFieldUExtract %2 %6 %10 %6 ; extracts bit 2 from %6 | // | | %24 = OpBitwiseOr %2 %22 %23 | // | | | // | | %25 = OpBitFieldUExtract %2 %5 %11 %6 ; extracts bit 3 from %5 | // | | %26 = OpBitFieldUExtract %2 %6 %11 %6 ; extracts bit 3 from %6 | // | | %27 = OpBitwiseOr %2 %25 %26 | // | | | // | | %28 = OpBitFieldUExtract %2 %5 %12 %6 ; extracts bit 4 from %5 | // | | %29 = OpBitFieldUExtract %2 %6 %12 %6 ; extracts bit 4 from %6 | // | | %30 = OpBitwiseOr %2 %28 %29 | // | | | // | | %31 = OpBitFieldUExtract %2 %5 %13 %6 ; extracts bit 5 from %5 | // | | %32 = OpBitFieldUExtract %2 %6 %13 %6 ; extracts bit 5 from %6 | // | | %33 = OpBitwiseOr %2 %31 %32 | // | | | // | | %34 = OpBitFieldUExtract %2 %5 %14 %6 ; extracts bit 6 from %5 | // | | %35 = OpBitFieldUExtract %2 %6 %14 %6 ; extracts bit 6 from %6 | // | | %36 = OpBitwiseOr %2 %34 %35 | // | | | // | | %37 = OpBitFieldUExtract %2 %5 %15 %6 ; extracts bit 7 from %5 | // | | %38 = OpBitFieldUExtract %2 %6 %15 %6 ; extracts bit 7 from %6 | // | | %39 = OpBitwiseOr %2 %37 %38 | // | | | // | | %40 = OpBitFieldInsert %2 %18 %21 %6 %6 ; inserts bit 1 | // | | %41 = OpBitFieldInsert %2 %40 %24 %10 %6 ; inserts bit 2 | // | | %42 = OpBitFieldInsert %2 %41 %27 %11 %6 ; inserts bit 3 | // | | %43 = OpBitFieldInsert %2 %42 %30 %12 %6 ; inserts bit 4 | // | | %44 = OpBitFieldInsert %2 %43 %33 %13 %6 ; inserts bit 5 | // | | %45 = OpBitFieldInsert %2 %44 %36 %14 %6 ; inserts bit 6 | // | | %46 = OpBitFieldInsert %2 %45 %39 %15 %6 ; inserts bit 7 | // | | %9 = OpBitwiseOr %2 %5 %6 ; bit instruction | // | | OpReturn | // | | OpFunctionEnd | // ---------------------------------------------------------------------------------------------------------------- // // After the transformation, %9 and %46 will be synonymous. // clang-format on class TransformationAddBitInstructionSynonym : public Transformation { public: explicit TransformationAddBitInstructionSynonym( protobufs::TransformationAddBitInstructionSynonym message); TransformationAddBitInstructionSynonym( const uint32_t instruction_result_id, const std::vector& fresh_ids); // - |message_.instruction_result_id| must be a bit instruction. // - |message_.fresh_ids| must be fresh ids needed to apply the // transformation. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Adds a bit instruction synonym. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; // Returns the number of fresh ids required to apply the transformation. static uint32_t GetRequiredFreshIdCount(opt::IRContext* ir_context, opt::Instruction* bit_instruction); // Returns true if: // - A |bit_instruction| is one of OpBitwiseOr, OpBitwiseAnd, OpBitwiseXor or // OpNot. // - |bit_instruction|'s operands are scalars. // - The operands have the same signedness. static bool IsInstructionSupported(opt::IRContext* ir_context, opt::Instruction* instruction); private: protobufs::TransformationAddBitInstructionSynonym message_; // Adds OpBitwise* or OpNot synonym. void AddOpBitwiseOrOpNotSynonym(opt::IRContext* ir_context, TransformationContext* transformation_context, opt::Instruction* bitwise_instruction) const; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_ADD_BIT_INSTRUCTION_SYNONYM_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_constant_boolean.cpp000066400000000000000000000055011475742701700310220ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_constant_boolean.h" #include "source/fuzz/fuzzer_util.h" #include "source/opt/types.h" namespace spvtools { namespace fuzz { TransformationAddConstantBoolean::TransformationAddConstantBoolean( protobufs::TransformationAddConstantBoolean message) : message_(std::move(message)) {} TransformationAddConstantBoolean::TransformationAddConstantBoolean( uint32_t fresh_id, bool is_true, bool is_irrelevant) { message_.set_fresh_id(fresh_id); message_.set_is_true(is_true); message_.set_is_irrelevant(is_irrelevant); } bool TransformationAddConstantBoolean::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { return fuzzerutil::MaybeGetBoolType(ir_context) != 0 && fuzzerutil::IsFreshId(ir_context, message_.fresh_id()); } void TransformationAddConstantBoolean::Apply( opt::IRContext* ir_context, TransformationContext* transformation_context) const { // Add the boolean constant to the module, ensuring the module's id bound is // high enough. auto new_instruction = MakeUnique( ir_context, message_.is_true() ? spv::Op::OpConstantTrue : spv::Op::OpConstantFalse, fuzzerutil::MaybeGetBoolType(ir_context), message_.fresh_id(), opt::Instruction::OperandList()); auto new_instruction_ptr = new_instruction.get(); ir_context->module()->AddGlobalValue(std::move(new_instruction)); fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id()); // Inform the def-use manager about the new instruction. Invalidate the // constant manager as we have added a new constant. ir_context->get_def_use_mgr()->AnalyzeInstDef(new_instruction_ptr); ir_context->InvalidateAnalyses(opt::IRContext::kAnalysisConstants); if (message_.is_irrelevant()) { transformation_context->GetFactManager()->AddFactIdIsIrrelevant( message_.fresh_id()); } } protobufs::Transformation TransformationAddConstantBoolean::ToMessage() const { protobufs::Transformation result; *result.mutable_add_constant_boolean() = message_; return result; } std::unordered_set TransformationAddConstantBoolean::GetFreshIds() const { return {message_.fresh_id()}; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_constant_boolean.h000066400000000000000000000041161475742701700304700ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_ADD_BOOLEAN_CONSTANT_H_ #define SOURCE_FUZZ_TRANSFORMATION_ADD_BOOLEAN_CONSTANT_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationAddConstantBoolean : public Transformation { public: explicit TransformationAddConstantBoolean( protobufs::TransformationAddConstantBoolean message); TransformationAddConstantBoolean(uint32_t fresh_id, bool is_true, bool is_irrelevant); // - |message_.fresh_id| must not be used by the module. // - The module must already contain OpTypeBool. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // - Adds OpConstantTrue (OpConstantFalse) to the module with id // |message_.fresh_id| if |message_.is_true| holds (does not hold). // - Also, creates an IdIsIrrelevant fact about |fresh_id| if |is_irrelevant| // is true. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationAddConstantBoolean message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_ADD_BOOLEAN_CONSTANT_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_constant_composite.cpp000066400000000000000000000130501475742701700314030ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_constant_composite.h" #include #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { TransformationAddConstantComposite::TransformationAddConstantComposite( spvtools::fuzz::protobufs::TransformationAddConstantComposite message) : message_(std::move(message)) {} TransformationAddConstantComposite::TransformationAddConstantComposite( uint32_t fresh_id, uint32_t type_id, const std::vector& constituent_ids, bool is_irrelevant) { message_.set_fresh_id(fresh_id); message_.set_type_id(type_id); message_.set_is_irrelevant(is_irrelevant); for (auto constituent_id : constituent_ids) { message_.add_constituent_id(constituent_id); } } bool TransformationAddConstantComposite::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { // Check that the given id is fresh. if (!fuzzerutil::IsFreshId(ir_context, message_.fresh_id())) { return false; } // Check that the composite type id is an instruction id. auto composite_type_instruction = ir_context->get_def_use_mgr()->GetDef(message_.type_id()); if (!composite_type_instruction) { return false; } // Gather up the operands for the composite constant, in the process checking // whether the given type really defines a composite and - in the case of a // struct - whether its decorations are OK. std::vector constituent_type_ids; switch (composite_type_instruction->opcode()) { case spv::Op::OpTypeArray: for (uint32_t index = 0; index < fuzzerutil::GetArraySize(*composite_type_instruction, ir_context); index++) { constituent_type_ids.push_back( composite_type_instruction->GetSingleWordInOperand(0)); } break; case spv::Op::OpTypeMatrix: case spv::Op::OpTypeVector: for (uint32_t index = 0; index < composite_type_instruction->GetSingleWordInOperand(1); index++) { constituent_type_ids.push_back( composite_type_instruction->GetSingleWordInOperand(0)); } break; case spv::Op::OpTypeStruct: // We do not create constants of structs decorated with Block nor // BufferBlock. The SPIR-V spec does not explicitly disallow this, but it // seems like a strange thing to do, so we disallow it to avoid triggering // low priority edge case issues related to it. if (fuzzerutil::HasBlockOrBufferBlockDecoration( ir_context, composite_type_instruction->result_id())) { return false; } composite_type_instruction->ForEachInOperand( [&constituent_type_ids](const uint32_t* member_type_id) { constituent_type_ids.push_back(*member_type_id); }); break; default: // Not a composite type. return false; } // Check that the number of provided operands matches the number of // constituents required by the type. if (constituent_type_ids.size() != static_cast(message_.constituent_id().size())) { return false; } // Check that every provided operand refers to an instruction of the // corresponding constituent type. for (uint32_t index = 0; index < constituent_type_ids.size(); index++) { auto constituent_instruction = ir_context->get_def_use_mgr()->GetDef(message_.constituent_id(index)); if (!constituent_instruction) { return false; } if (constituent_instruction->type_id() != constituent_type_ids.at(index)) { return false; } } return true; } void TransformationAddConstantComposite::Apply( opt::IRContext* ir_context, TransformationContext* transformation_context) const { opt::Instruction::OperandList in_operands; for (auto constituent_id : message_.constituent_id()) { in_operands.push_back({SPV_OPERAND_TYPE_ID, {constituent_id}}); } auto new_instruction = MakeUnique( ir_context, spv::Op::OpConstantComposite, message_.type_id(), message_.fresh_id(), in_operands); auto new_instruction_ptr = new_instruction.get(); ir_context->module()->AddGlobalValue(std::move(new_instruction)); fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id()); // Inform the def-use manager of the new instruction. Invalidate the constant // manager as we have added a new constant. ir_context->get_def_use_mgr()->AnalyzeInstDefUse(new_instruction_ptr); ir_context->InvalidateAnalyses(opt::IRContext::kAnalysisConstants); if (message_.is_irrelevant()) { transformation_context->GetFactManager()->AddFactIdIsIrrelevant( message_.fresh_id()); } } protobufs::Transformation TransformationAddConstantComposite::ToMessage() const { protobufs::Transformation result; *result.mutable_add_constant_composite() = message_; return result; } std::unordered_set TransformationAddConstantComposite::GetFreshIds() const { return {message_.fresh_id()}; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_constant_composite.h000066400000000000000000000046301475742701700310540ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_ADD_CONSTANT_COMPOSITE_H_ #define SOURCE_FUZZ_TRANSFORMATION_ADD_CONSTANT_COMPOSITE_H_ #include #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationAddConstantComposite : public Transformation { public: explicit TransformationAddConstantComposite( protobufs::TransformationAddConstantComposite message); TransformationAddConstantComposite( uint32_t fresh_id, uint32_t type_id, const std::vector& constituent_ids, bool is_irrelevant); // - |message_.fresh_id| must be a fresh id // - |message_.type_id| must be the id of a composite type // - |message_.constituent_id| must refer to ids that match the constituent // types of this composite type // - If |message_.type_id| is a struct type, it must not have the Block or // BufferBlock decoration bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // - Adds an OpConstantComposite instruction defining a constant of type // |message_.type_id|, using |message_.constituent_id| as constituents, with // result id |message_.fresh_id|. // - Creates an IdIsIrrelevant fact about |fresh_id| if |is_irrelevant| is // true. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationAddConstantComposite message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_ADD_CONSTANT_COMPOSITE_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_constant_null.cpp000066400000000000000000000053461475742701700303640ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_constant_null.h" #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { TransformationAddConstantNull::TransformationAddConstantNull( spvtools::fuzz::protobufs::TransformationAddConstantNull message) : message_(std::move(message)) {} TransformationAddConstantNull::TransformationAddConstantNull(uint32_t fresh_id, uint32_t type_id) { message_.set_fresh_id(fresh_id); message_.set_type_id(type_id); } bool TransformationAddConstantNull::IsApplicable( opt::IRContext* context, const TransformationContext& /*unused*/) const { // A fresh id is required. if (!fuzzerutil::IsFreshId(context, message_.fresh_id())) { return false; } auto type = context->get_def_use_mgr()->GetDef(message_.type_id()); // The type must exist. if (!type) { return false; } // The type must be one of the types for which null constants are allowed, // according to the SPIR-V spec. return fuzzerutil::IsNullConstantSupported(context, *type); } void TransformationAddConstantNull::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { auto new_instruction = MakeUnique( ir_context, spv::Op::OpConstantNull, message_.type_id(), message_.fresh_id(), opt::Instruction::OperandList()); auto new_instruction_ptr = new_instruction.get(); ir_context->module()->AddGlobalValue(std::move(new_instruction)); fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id()); // Inform the def-use manager about the new instruction. Invalidate the // constant manager as we have added a new constant. ir_context->get_def_use_mgr()->AnalyzeInstDef(new_instruction_ptr); ir_context->InvalidateAnalyses(opt::IRContext::kAnalysisConstants); } protobufs::Transformation TransformationAddConstantNull::ToMessage() const { protobufs::Transformation result; *result.mutable_add_constant_null() = message_; return result; } std::unordered_set TransformationAddConstantNull::GetFreshIds() const { return {message_.fresh_id()}; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_constant_null.h000066400000000000000000000037271475742701700300320ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_ADD_CONSTANT_NULL_H_ #define SOURCE_FUZZ_TRANSFORMATION_ADD_CONSTANT_NULL_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationAddConstantNull : public Transformation { public: explicit TransformationAddConstantNull( protobufs::TransformationAddConstantNull message); TransformationAddConstantNull(uint32_t fresh_id, uint32_t type_id); // - |message_.fresh_id| must be fresh // - |message_.type_id| must be the id of a type for which it is acceptable // to create a null constant bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Adds an OpConstantNull instruction to the module, with |message_.type_id| // as its type. The instruction has result id |message_.fresh_id|. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationAddConstantNull message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_ADD_CONSTANT_NULL_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_constant_scalar.cpp000066400000000000000000000067431475742701700306610ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_constant_scalar.h" #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { TransformationAddConstantScalar::TransformationAddConstantScalar( spvtools::fuzz::protobufs::TransformationAddConstantScalar message) : message_(std::move(message)) {} TransformationAddConstantScalar::TransformationAddConstantScalar( uint32_t fresh_id, uint32_t type_id, const std::vector& words, bool is_irrelevant) { message_.set_fresh_id(fresh_id); message_.set_type_id(type_id); message_.set_is_irrelevant(is_irrelevant); for (auto word : words) { message_.add_word(word); } } bool TransformationAddConstantScalar::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { // The id needs to be fresh. if (!fuzzerutil::IsFreshId(ir_context, message_.fresh_id())) { return false; } // The type id for the scalar must exist and be a type. auto type = ir_context->get_type_mgr()->GetType(message_.type_id()); if (!type) { return false; } uint32_t width; if (type->AsFloat()) { width = type->AsFloat()->width(); } else if (type->AsInteger()) { width = type->AsInteger()->width(); } else { return false; } // The number of words is the integer floor of the width. auto words = (width + 32 - 1) / 32; // The number of words provided by the transformation needs to match the // width of the type. return static_cast(message_.word().size()) == words; } void TransformationAddConstantScalar::Apply( opt::IRContext* ir_context, TransformationContext* transformation_context) const { auto new_instruction = MakeUnique( ir_context, spv::Op::OpConstant, message_.type_id(), message_.fresh_id(), opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_LITERAL_INTEGER, std::vector(message_.word().begin(), message_.word().end())}})); auto new_instruction_ptr = new_instruction.get(); ir_context->module()->AddGlobalValue(std::move(new_instruction)); fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id()); // Inform the def-use manager about the new instruction. Invalidate the // constant manager as we have added a new constant. ir_context->get_def_use_mgr()->AnalyzeInstDef(new_instruction_ptr); ir_context->InvalidateAnalyses(opt::IRContext::kAnalysisConstants); if (message_.is_irrelevant()) { transformation_context->GetFactManager()->AddFactIdIsIrrelevant( message_.fresh_id()); } } protobufs::Transformation TransformationAddConstantScalar::ToMessage() const { protobufs::Transformation result; *result.mutable_add_constant_scalar() = message_; return result; } std::unordered_set TransformationAddConstantScalar::GetFreshIds() const { return {message_.fresh_id()}; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_constant_scalar.h000066400000000000000000000043001475742701700303110ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_ADD_CONSTANT_SCALAR_H_ #define SOURCE_FUZZ_TRANSFORMATION_ADD_CONSTANT_SCALAR_H_ #include #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationAddConstantScalar : public Transformation { public: explicit TransformationAddConstantScalar( protobufs::TransformationAddConstantScalar message); TransformationAddConstantScalar(uint32_t fresh_id, uint32_t type_id, const std::vector& words, bool is_irrelevant); // - |message_.fresh_id| must not be used by the module // - |message_.type_id| must be the id of a floating-point or integer type // - The size of |message_.word| must be compatible with the width of this // type bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Adds a new OpConstant instruction with the given type and words. // Creates an IdIsIrrelevant fact about |fresh_id| if |is_irrelevant| is true. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationAddConstantScalar message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_ADD_CONSTANT_SCALAR_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_copy_memory.cpp000066400000000000000000000207571475742701700300460ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_copy_memory.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "source/opt/instruction.h" namespace spvtools { namespace fuzz { TransformationAddCopyMemory::TransformationAddCopyMemory( protobufs::TransformationAddCopyMemory message) : message_(std::move(message)) {} TransformationAddCopyMemory::TransformationAddCopyMemory( const protobufs::InstructionDescriptor& instruction_descriptor, uint32_t fresh_id, uint32_t source_id, spv::StorageClass storage_class, uint32_t initializer_id) { *message_.mutable_instruction_descriptor() = instruction_descriptor; message_.set_fresh_id(fresh_id); message_.set_source_id(source_id); message_.set_storage_class(uint32_t(storage_class)); message_.set_initializer_id(initializer_id); } bool TransformationAddCopyMemory::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { // Check that target id is fresh. if (!fuzzerutil::IsFreshId(ir_context, message_.fresh_id())) { return false; } // Check that instruction descriptor is valid. This also checks that // |message_.instruction_descriptor| is not a global instruction. auto* inst = FindInstruction(message_.instruction_descriptor(), ir_context); if (!inst) { return false; } // Check that we can insert OpCopyMemory before |instruction_descriptor|. auto iter = fuzzerutil::GetIteratorForInstruction( ir_context->get_instr_block(inst), inst); if (!fuzzerutil::CanInsertOpcodeBeforeInstruction(spv::Op::OpCopyMemory, iter)) { return false; } // Check that source instruction exists and is valid. auto* source_inst = ir_context->get_def_use_mgr()->GetDef(message_.source_id()); if (!source_inst || !IsInstructionSupported(ir_context, source_inst)) { return false; } // |storage_class| is either Function or Private. if (spv::StorageClass(message_.storage_class()) != spv::StorageClass::Function && spv::StorageClass(message_.storage_class()) != spv::StorageClass::Private) { return false; } auto pointee_type_id = fuzzerutil::GetPointeeTypeIdFromPointerType( ir_context, source_inst->type_id()); // OpTypePointer with |message_.storage_class| exists. if (!fuzzerutil::MaybeGetPointerType( ir_context, pointee_type_id, static_cast(message_.storage_class()))) { return false; } // Check that |initializer_id| exists and has valid type. const auto* initializer_inst = ir_context->get_def_use_mgr()->GetDef(message_.initializer_id()); if (!initializer_inst || initializer_inst->type_id() != pointee_type_id) { return false; } // Check that domination rules are satisfied. return fuzzerutil::IdIsAvailableBeforeInstruction(ir_context, inst, message_.source_id()); } void TransformationAddCopyMemory::Apply( opt::IRContext* ir_context, TransformationContext* transformation_context) const { // Insert OpCopyMemory before |instruction_descriptor|. auto* insert_before_inst = FindInstruction(message_.instruction_descriptor(), ir_context); assert(insert_before_inst); opt::BasicBlock* enclosing_block = ir_context->get_instr_block(insert_before_inst); // Add global or local variable to copy memory into. auto storage_class = static_cast(message_.storage_class()); auto type_id = fuzzerutil::MaybeGetPointerType( ir_context, fuzzerutil::GetPointeeTypeIdFromPointerType( ir_context, fuzzerutil::GetTypeId(ir_context, message_.source_id())), storage_class); if (storage_class == spv::StorageClass::Private) { opt::Instruction* new_global = fuzzerutil::AddGlobalVariable(ir_context, message_.fresh_id(), type_id, storage_class, message_.initializer_id()); ir_context->get_def_use_mgr()->AnalyzeInstDefUse(new_global); } else { assert(storage_class == spv::StorageClass::Function && "Storage class can be either Private or Function"); opt::Function* enclosing_function = enclosing_block->GetParent(); opt::Instruction* new_local = fuzzerutil::AddLocalVariable( ir_context, message_.fresh_id(), type_id, enclosing_function->result_id(), message_.initializer_id()); ir_context->get_def_use_mgr()->AnalyzeInstDefUse(new_local); ir_context->set_instr_block(new_local, &*enclosing_function->entry()); } auto insert_before_iter = fuzzerutil::GetIteratorForInstruction( enclosing_block, insert_before_inst); auto new_instruction = MakeUnique( ir_context, spv::Op::OpCopyMemory, 0, 0, opt::Instruction::OperandList{ {SPV_OPERAND_TYPE_ID, {message_.fresh_id()}}, {SPV_OPERAND_TYPE_ID, {message_.source_id()}}}); auto new_instruction_ptr = new_instruction.get(); insert_before_iter.InsertBefore(std::move(new_instruction)); ir_context->get_def_use_mgr()->AnalyzeInstDefUse(new_instruction_ptr); ir_context->set_instr_block(new_instruction_ptr, enclosing_block); fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id()); // Even though the copy memory instruction will - at least temporarily - lead // to the destination and source pointers referring to identical values, this // fact is not guaranteed to hold throughout execution of the SPIR-V code // since the source pointer could be over-written. We thus assume nothing // about the destination pointer, and record this fact so that the destination // pointer can be used freely by other fuzzer passes. transformation_context->GetFactManager()->AddFactValueOfPointeeIsIrrelevant( message_.fresh_id()); } protobufs::Transformation TransformationAddCopyMemory::ToMessage() const { protobufs::Transformation result; *result.mutable_add_copy_memory() = message_; return result; } bool TransformationAddCopyMemory::IsInstructionSupported( opt::IRContext* ir_context, opt::Instruction* inst) { if (!inst->result_id() || !inst->type_id() || inst->opcode() == spv::Op::OpConstantNull || inst->opcode() == spv::Op::OpUndef) { return false; } const auto* type = ir_context->get_type_mgr()->GetType(inst->type_id()); assert(type && "Instruction must have a valid type"); if (!type->AsPointer()) { return false; } // We do not support copying memory from a pointer to a block-/buffer // block-decorated struct. auto pointee_type_inst = ir_context->get_def_use_mgr() ->GetDef(inst->type_id()) ->GetSingleWordInOperand(1); if (fuzzerutil::HasBlockOrBufferBlockDecoration(ir_context, pointee_type_inst)) { return false; } return CanUsePointeeWithCopyMemory(*type->AsPointer()->pointee_type()); } bool TransformationAddCopyMemory::CanUsePointeeWithCopyMemory( const opt::analysis::Type& type) { switch (type.kind()) { case opt::analysis::Type::kBool: case opt::analysis::Type::kInteger: case opt::analysis::Type::kFloat: case opt::analysis::Type::kArray: return true; case opt::analysis::Type::kVector: return CanUsePointeeWithCopyMemory(*type.AsVector()->element_type()); case opt::analysis::Type::kMatrix: return CanUsePointeeWithCopyMemory(*type.AsMatrix()->element_type()); case opt::analysis::Type::kStruct: return std::all_of(type.AsStruct()->element_types().begin(), type.AsStruct()->element_types().end(), [](const opt::analysis::Type* element) { return CanUsePointeeWithCopyMemory(*element); }); default: return false; } } std::unordered_set TransformationAddCopyMemory::GetFreshIds() const { return {message_.fresh_id()}; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_copy_memory.h000066400000000000000000000061661475742701700275110ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_ADD_COPY_MEMORY_H_ #define SOURCE_FUZZ_TRANSFORMATION_ADD_COPY_MEMORY_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationAddCopyMemory : public Transformation { public: explicit TransformationAddCopyMemory( protobufs::TransformationAddCopyMemory message); TransformationAddCopyMemory( const protobufs::InstructionDescriptor& instruction_descriptor, uint32_t fresh_id, uint32_t source_id, spv::StorageClass storage_class, uint32_t initializer_id); // - |instruction_descriptor| must point to a valid instruction in the module. // - it should be possible to insert OpCopyMemory before // |instruction_descriptor| (i.e. the module remains valid after the // insertion). // - |source_id| must be a result id for some valid instruction in the module. // - |fresh_id| must be a fresh id to copy memory into. // - type of |source_id| must be OpTypePointer where pointee can be used with // OpCopyMemory. // - If the pointee type of |source_id| is a struct type, it must not have the // Block or BufferBlock decoration. // - |storage_class| must be either Private or Function. // - type ids of instructions with result ids |source_id| and |initialize_id| // must be the same. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // A global or local variable with id |target_id| and |storage_class| class is // created. An 'OpCopyMemory %fresh_id %source_id' instruction is inserted // before the |instruction_descriptor|. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; // Returns true if we can copy memory from |instruction| using OpCopyMemory. static bool IsInstructionSupported(opt::IRContext* ir_context, opt::Instruction* inst); private: // Returns whether the type, pointed to by some OpTypePointer, can be used // with OpCopyMemory instruction. static bool CanUsePointeeWithCopyMemory(const opt::analysis::Type& type); protobufs::TransformationAddCopyMemory message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_ADD_COPY_MEMORY_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_dead_block.cpp000066400000000000000000000173601475742701700275470ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_dead_block.h" #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { TransformationAddDeadBlock::TransformationAddDeadBlock( protobufs::TransformationAddDeadBlock message) : message_(std::move(message)) {} TransformationAddDeadBlock::TransformationAddDeadBlock(uint32_t fresh_id, uint32_t existing_block, bool condition_value) { message_.set_fresh_id(fresh_id); message_.set_existing_block(existing_block); message_.set_condition_value(condition_value); } bool TransformationAddDeadBlock::IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const { // The new block's id must be fresh. if (!fuzzerutil::IsFreshId(ir_context, message_.fresh_id())) { return false; } // First, we check that a constant with the same value as // |message_.condition_value| is present. if (!fuzzerutil::MaybeGetBoolConstant(ir_context, transformation_context, message_.condition_value(), false)) { // The required constant is not present, so the transformation cannot be // applied. return false; } // The existing block must indeed exist. auto existing_block = fuzzerutil::MaybeFindBlock(ir_context, message_.existing_block()); if (!existing_block) { return false; } // It must not head a loop. if (existing_block->IsLoopHeader()) { return false; } // It must end with OpBranch. if (existing_block->terminator()->opcode() != spv::Op::OpBranch) { return false; } // Its successor must not be a merge block nor continue target. auto successor_block_id = existing_block->terminator()->GetSingleWordInOperand(0); if (fuzzerutil::IsMergeOrContinue(ir_context, successor_block_id)) { return false; } // The successor must not be a loop header (i.e., |message_.existing_block| // must not be a back-edge block. if (ir_context->cfg()->block(successor_block_id)->IsLoopHeader()) { return false; } // |existing_block| must be reachable. if (!ir_context->IsReachable(*existing_block)) { return false; } assert(existing_block->id() != successor_block_id && "|existing_block| must be different from |successor_block_id|"); // Even though we know |successor_block_id| is not a merge block, it might // still have multiple predecessors because divergent control flow is allowed // to converge early (before the merge block). In this case, when we create // the selection construct, its header |existing_block| will not dominate the // merge block |successor_block_id|, which is invalid. Thus, |existing_block| // must dominate |successor_block_id|. opt::DominatorAnalysis* dominator_analysis = ir_context->GetDominatorAnalysis(existing_block->GetParent()); if (!dominator_analysis->Dominates(existing_block->id(), successor_block_id)) { return false; } return true; } void TransformationAddDeadBlock::Apply( opt::IRContext* ir_context, TransformationContext* transformation_context) const { // Update the module id bound so that it is at least the id of the new block. fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id()); // Get the existing block and its successor. auto existing_block = ir_context->cfg()->block(message_.existing_block()); auto successor_block_id = existing_block->terminator()->GetSingleWordInOperand(0); // Get the id of the boolean value that will be used as the branch condition. auto bool_id = fuzzerutil::MaybeGetBoolConstant( ir_context, *transformation_context, message_.condition_value(), false); // Make a new block that unconditionally branches to the original successor // block. auto enclosing_function = existing_block->GetParent(); std::unique_ptr new_block = MakeUnique(MakeUnique( ir_context, spv::Op::OpLabel, 0, message_.fresh_id(), opt::Instruction::OperandList())); new_block->AddInstruction(MakeUnique( ir_context, spv::Op::OpBranch, 0, 0, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {successor_block_id}}}))); // Turn the original block into a selection merge, with its original successor // as the merge block. existing_block->terminator()->InsertBefore(MakeUnique( ir_context, spv::Op::OpSelectionMerge, 0, 0, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {successor_block_id}}, {SPV_OPERAND_TYPE_SELECTION_CONTROL, {uint32_t(spv::SelectionControlMask::MaskNone)}}}))); // Change the original block's terminator to be a conditional branch on the // given boolean, with the original successor and the new successor as branch // targets, and such that at runtime control will always transfer to the // original successor. existing_block->terminator()->SetOpcode(spv::Op::OpBranchConditional); existing_block->terminator()->SetInOperands( {{SPV_OPERAND_TYPE_ID, {bool_id}}, {SPV_OPERAND_TYPE_ID, {message_.condition_value() ? successor_block_id : message_.fresh_id()}}, {SPV_OPERAND_TYPE_ID, {message_.condition_value() ? message_.fresh_id() : successor_block_id}}}); // Add the new block to the enclosing function. enclosing_function->InsertBasicBlockAfter(std::move(new_block), existing_block); // Fix up OpPhi instructions in the successor block, so that the values they // yield when control has transferred from the new block are the same as if // control had transferred from |message_.existing_block|. This is guaranteed // to be valid since |message_.existing_block| dominates the new block by // construction. Other transformations can change these phi operands to more // interesting values. ir_context->cfg() ->block(successor_block_id) ->ForEachPhiInst([this](opt::Instruction* phi_inst) { // Copy the operand that provides the phi value for the first of any // existing predecessors. opt::Operand copy_of_existing_operand = phi_inst->GetInOperand(0); // Use this as the value associated with the new predecessor. phi_inst->AddOperand(std::move(copy_of_existing_operand)); phi_inst->AddOperand({SPV_OPERAND_TYPE_ID, {message_.fresh_id()}}); }); // Do not rely on any existing analysis results since the control flow graph // of the module has changed. ir_context->InvalidateAnalysesExceptFor(opt::IRContext::kAnalysisNone); // Record the fact that the new block is dead. transformation_context->GetFactManager()->AddFactBlockIsDead( message_.fresh_id()); } protobufs::Transformation TransformationAddDeadBlock::ToMessage() const { protobufs::Transformation result; *result.mutable_add_dead_block() = message_; return result; } std::unordered_set TransformationAddDeadBlock::GetFreshIds() const { return {message_.fresh_id()}; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_dead_block.h000066400000000000000000000052361475742701700272130ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_ADD_DEAD_BLOCK_H_ #define SOURCE_FUZZ_TRANSFORMATION_ADD_DEAD_BLOCK_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationAddDeadBlock : public Transformation { public: explicit TransformationAddDeadBlock( protobufs::TransformationAddDeadBlock message); TransformationAddDeadBlock(uint32_t fresh_id, uint32_t existing_block, bool condition_value); // - |message_.fresh_id| must be a fresh id // - A constant with the same value as |message_.condition_value| must be // available // - |message_.existing_block| must be a block that is not a loop header, // and that ends with OpBranch to a block that is not a merge block nor // continue target - this is because the successor will become the merge // block of a selection construct headed at |message_.existing_block| // - |message_.existing_block| must not be a back-edge block, since in this // case the newly-added block would lead to another back-edge to the // associated loop header bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Changes the OpBranch from |message_.existing_block| to its successor 's' // to an OpBranchConditional to either 's' or a new block, // |message_.fresh_id|, which itself unconditionally branches to 's'. The // conditional branch uses |message.condition_value| as its condition, and is // arranged so that control will pass to 's' at runtime. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationAddDeadBlock message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_ADD_DEAD_BLOCK_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_dead_break.cpp000066400000000000000000000177141475742701700275440ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_dead_break.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/transformation_context.h" #include "source/opt/basic_block.h" #include "source/opt/ir_context.h" #include "source/opt/struct_cfg_analysis.h" namespace spvtools { namespace fuzz { TransformationAddDeadBreak::TransformationAddDeadBreak( protobufs::TransformationAddDeadBreak message) : message_(std::move(message)) {} TransformationAddDeadBreak::TransformationAddDeadBreak( uint32_t from_block, uint32_t to_block, bool break_condition_value, std::vector phi_id) { message_.set_from_block(from_block); message_.set_to_block(to_block); message_.set_break_condition_value(break_condition_value); for (auto id : phi_id) { message_.add_phi_id(id); } } bool TransformationAddDeadBreak::AddingBreakRespectsStructuredControlFlow( opt::IRContext* ir_context, opt::BasicBlock* bb_from) const { // Look at the structured control flow associated with |from_block| and // check whether it is contained in an appropriate construct with merge id // |to_block| such that a break from |from_block| to |to_block| is legal. // There are three legal cases to consider: // (1) |from_block| is a loop header and |to_block| is its merge // (2) |from_block| is a non-header node of a construct, and |to_block| // is the merge for that construct // (3) |from_block| is a non-header node of a selection construct, and // |to_block| is the merge for the innermost loop containing // |from_block| // // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/2653) It may be // possible to be more aggressive in breaking from switch constructs. // // The reason we need to distinguish between cases (1) and (2) is that the // structured CFG analysis does not deem a header to be part of the construct // that it heads. // Consider case (1) if (bb_from->IsLoopHeader()) { // Case (1) holds if |to_block| is the merge block for the loop; // otherwise no case holds return bb_from->MergeBlockId() == message_.to_block(); } // Both cases (2) and (3) require that |from_block| is inside some // structured control flow construct. auto containing_construct = ir_context->GetStructuredCFGAnalysis()->ContainingConstruct( message_.from_block()); if (!containing_construct) { // |from_block| is not in a construct from which we can break. return false; } // Consider case (2) if (message_.to_block() == ir_context->cfg()->block(containing_construct)->MergeBlockId()) { // This looks like an instance of case (2). // However, the structured CFG analysis regards the continue construct of a // loop as part of the loop, but it is not legal to jump from a loop's // continue construct to the loop's merge (except from the back-edge block), // so we need to check for this case. return !fuzzerutil::BlockIsInLoopContinueConstruct( ir_context, message_.from_block(), containing_construct) || fuzzerutil::BlockIsBackEdge(ir_context, message_.from_block(), containing_construct); } // Case (3) holds if and only if |to_block| is the merge block for this // innermost loop that contains |from_block| auto containing_loop_header = ir_context->GetStructuredCFGAnalysis()->ContainingLoop( message_.from_block()); if (containing_loop_header && message_.to_block() == ir_context->cfg()->block(containing_loop_header)->MergeBlockId()) { return !fuzzerutil::BlockIsInLoopContinueConstruct( ir_context, message_.from_block(), containing_loop_header) || fuzzerutil::BlockIsBackEdge(ir_context, message_.from_block(), containing_loop_header); } return false; } bool TransformationAddDeadBreak::IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const { // First, we check that a constant with the same value as // |message_.break_condition_value| is present. const auto bool_id = fuzzerutil::MaybeGetBoolConstant(ir_context, transformation_context, message_.break_condition_value(), false); if (!bool_id) { // The required constant is not present, so the transformation cannot be // applied. return false; } // Check that |message_.from_block| and |message_.to_block| really are block // ids opt::BasicBlock* bb_from = fuzzerutil::MaybeFindBlock(ir_context, message_.from_block()); if (bb_from == nullptr) { return false; } opt::BasicBlock* bb_to = fuzzerutil::MaybeFindBlock(ir_context, message_.to_block()); if (bb_to == nullptr) { return false; } if (!ir_context->IsReachable(*bb_to)) { // If the target of the break is unreachable, we conservatively do not // allow adding a dead break, to avoid the compilations that arise due to // the lack of sensible dominance information for unreachable blocks. return false; } // Check that |message_.from_block| ends with an unconditional branch. if (bb_from->terminator()->opcode() != spv::Op::OpBranch) { // The block associated with the id does not end with an unconditional // branch. return false; } assert(bb_from != nullptr && "We should have found a block if this line of code is reached."); assert( bb_from->id() == message_.from_block() && "The id of the block we found should match the source id for the break."); assert(bb_to != nullptr && "We should have found a block if this line of code is reached."); assert( bb_to->id() == message_.to_block() && "The id of the block we found should match the target id for the break."); // Check whether the data passed to extend OpPhi instructions is appropriate. if (!fuzzerutil::PhiIdsOkForNewEdge(ir_context, bb_from, bb_to, message_.phi_id())) { return false; } // Check that adding the break would respect the rules of structured // control flow. if (!AddingBreakRespectsStructuredControlFlow(ir_context, bb_from)) { return false; } // Adding the dead break is only valid if SPIR-V rules related to dominance // hold. return fuzzerutil::NewTerminatorPreservesDominationRules( ir_context, message_.from_block(), fuzzerutil::CreateUnreachableEdgeInstruction( ir_context, message_.from_block(), message_.to_block(), bool_id)); } void TransformationAddDeadBreak::Apply( opt::IRContext* ir_context, TransformationContext* transformation_context) const { fuzzerutil::AddUnreachableEdgeAndUpdateOpPhis( ir_context, ir_context->cfg()->block(message_.from_block()), ir_context->cfg()->block(message_.to_block()), fuzzerutil::MaybeGetBoolConstant(ir_context, *transformation_context, message_.break_condition_value(), false), message_.phi_id()); // Invalidate all analyses ir_context->InvalidateAnalysesExceptFor( opt::IRContext::Analysis::kAnalysisNone); } protobufs::Transformation TransformationAddDeadBreak::ToMessage() const { protobufs::Transformation result; *result.mutable_add_dead_break() = message_; return result; } std::unordered_set TransformationAddDeadBreak::GetFreshIds() const { return std::unordered_set(); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_dead_break.h000066400000000000000000000064541475742701700272100ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_ADD_DEAD_BREAK_H_ #define SOURCE_FUZZ_TRANSFORMATION_ADD_DEAD_BREAK_H_ #include #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationAddDeadBreak : public Transformation { public: explicit TransformationAddDeadBreak( protobufs::TransformationAddDeadBreak message); TransformationAddDeadBreak(uint32_t from_block, uint32_t to_block, bool break_condition_value, std::vector phi_id); // - |message_.from_block| must be the id of a block a in the given module. // - |message_.to_block| must be the id of a block b in the given module. // - if |message_.break_condition_value| holds (does not hold) then // OpConstantTrue (OpConstantFalse) must be present in the module // - |message_.phi_ids| must be a list of ids that are all available at // |message_.from_block| // - a and b must be in the same function. // - b must be a merge block. // - a must end with an unconditional branch to some block c. // - replacing this branch with a conditional branch to b or c, with // the boolean constant associated with |message_.break_condition_value| as // the condition, and the ids in |message_.phi_ids| used to extend // any OpPhi instructions at b as a result of the edge from a, must // maintain validity of the module. // In particular, the new branch must not lead to violations of the rule // that a use must be dominated by its definition. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Replaces the terminator of a with a conditional branch to b or c. // The boolean constant associated with |message_.break_condition_value| is // used as the condition, and the order of b and c is arranged such that // control is guaranteed to jump to c. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: // Returns true if and only if adding an edge from |bb_from| to // |message_.to_block| respects structured control flow. bool AddingBreakRespectsStructuredControlFlow(opt::IRContext* ir_context, opt::BasicBlock* bb_from) const; protobufs::TransformationAddDeadBreak message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_ADD_DEAD_BREAK_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_dead_continue.cpp000066400000000000000000000132751475742701700303020ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_dead_continue.h" #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { TransformationAddDeadContinue::TransformationAddDeadContinue( protobufs::TransformationAddDeadContinue message) : message_(std::move(message)) {} TransformationAddDeadContinue::TransformationAddDeadContinue( uint32_t from_block, bool continue_condition_value, std::vector phi_id) { message_.set_from_block(from_block); message_.set_continue_condition_value(continue_condition_value); for (auto id : phi_id) { message_.add_phi_id(id); } } bool TransformationAddDeadContinue::IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const { // First, we check that a constant with the same value as // |message_.continue_condition_value| is present. const auto bool_id = fuzzerutil::MaybeGetBoolConstant( ir_context, transformation_context, message_.continue_condition_value(), false); if (!bool_id) { // The required constant is not present, so the transformation cannot be // applied. return false; } // Check that |message_.from_block| really is a block id. opt::BasicBlock* bb_from = fuzzerutil::MaybeFindBlock(ir_context, message_.from_block()); if (bb_from == nullptr) { return false; } // Check that |message_.from_block| ends with an unconditional branch. if (bb_from->terminator()->opcode() != spv::Op::OpBranch) { // The block associated with the id does not end with an unconditional // branch. return false; } assert(bb_from != nullptr && "We should have found a block if this line of code is reached."); assert( bb_from->id() == message_.from_block() && "The id of the block we found should match the source id for the break."); // Get the header for the innermost loop containing |message_.from_block|. // Because the structured CFG analysis does not regard a loop header as part // of the loop it heads, we check first whether bb_from is a loop header // before using the structured CFG analysis. auto loop_header = bb_from->IsLoopHeader() ? message_.from_block() : ir_context->GetStructuredCFGAnalysis()->ContainingLoop( message_.from_block()); if (!loop_header) { return false; } auto continue_block = ir_context->cfg()->block(loop_header)->ContinueBlockId(); if (!ir_context->IsReachable(*ir_context->cfg()->block(continue_block))) { // If the loop's continue block is unreachable, we conservatively do not // allow adding a dead continue, to avoid the compilations that arise due to // the lack of sensible dominance information for unreachable blocks. return false; } if (fuzzerutil::BlockIsInLoopContinueConstruct( ir_context, message_.from_block(), loop_header)) { // We cannot jump to the continue target from the continue construct. return false; } if (ir_context->GetStructuredCFGAnalysis()->IsMergeBlock(continue_block)) { // A branch straight to the continue target that is also a merge block might // break the property that a construct header must dominate its merge block // (if the merge block is reachable). return false; } // Check whether the data passed to extend OpPhi instructions is appropriate. if (!fuzzerutil::PhiIdsOkForNewEdge(ir_context, bb_from, ir_context->cfg()->block(continue_block), message_.phi_id())) { return false; } // Adding the dead break is only valid if SPIR-V rules related to dominance // hold. return fuzzerutil::NewTerminatorPreservesDominationRules( ir_context, message_.from_block(), fuzzerutil::CreateUnreachableEdgeInstruction( ir_context, message_.from_block(), continue_block, bool_id)); } void TransformationAddDeadContinue::Apply( opt::IRContext* ir_context, TransformationContext* transformation_context) const { auto bb_from = ir_context->cfg()->block(message_.from_block()); auto continue_block = bb_from->IsLoopHeader() ? bb_from->ContinueBlockId() : ir_context->GetStructuredCFGAnalysis()->LoopContinueBlock( message_.from_block()); assert(continue_block && "message_.from_block must be in a loop."); fuzzerutil::AddUnreachableEdgeAndUpdateOpPhis( ir_context, bb_from, ir_context->cfg()->block(continue_block), fuzzerutil::MaybeGetBoolConstant(ir_context, *transformation_context, message_.continue_condition_value(), false), message_.phi_id()); // Invalidate all analyses ir_context->InvalidateAnalysesExceptFor( opt::IRContext::Analysis::kAnalysisNone); } protobufs::Transformation TransformationAddDeadContinue::ToMessage() const { protobufs::Transformation result; *result.mutable_add_dead_continue() = message_; return result; } std::unordered_set TransformationAddDeadContinue::GetFreshIds() const { return std::unordered_set(); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_dead_continue.h000066400000000000000000000062731475742701700277470ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_ADD_DEAD_CONTINUE_H_ #define SOURCE_FUZZ_TRANSFORMATION_ADD_DEAD_CONTINUE_H_ #include #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationAddDeadContinue : public Transformation { public: explicit TransformationAddDeadContinue( protobufs::TransformationAddDeadContinue message); TransformationAddDeadContinue(uint32_t from_block, bool continue_condition_value, std::vector phi_id); // - |message_.from_block| must be the id of a block a in the given module. // - a must be contained in a loop with continue target b // - The continue target b must be dominated by the head of the loop in which // it is contained // - b must not be the merge block of a selection construct // - if |message_.continue_condition_value| holds (does not hold) then // OpConstantTrue (OpConstantFalse) must be present in the module // - |message_.phi_ids| must be a list of ids that are all available at // |message_.from_block| // - a must end with an unconditional branch to some block c. // - replacing this branch with a conditional branch to b or c, with // the boolean constant associated with |message_.continue_condition_value| // as the condition, and the ids in |message_.phi_ids| used to extend any // OpPhi instructions at b as a result of the edge from a, must maintain // validity of the module. // In particular, adding an edge from somewhere in the loop to the continue // target must not prevent uses of ids in the continue target from being // dominated by the definitions of those ids. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Replaces the terminator of a with a conditional branch to b or c. // The boolean constant associated with |message_.continue_condition_value| is // used as the condition, and the order of b and c is arranged such that // control is guaranteed to jump to c. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationAddDeadContinue message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_ADD_DEAD_CONTINUE_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_early_terminator_wrapper.cpp000066400000000000000000000104641475742701700326160ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_early_terminator_wrapper.h" #include "source/fuzz/fuzzer_util.h" #include "source/util/make_unique.h" namespace spvtools { namespace fuzz { TransformationAddEarlyTerminatorWrapper:: TransformationAddEarlyTerminatorWrapper( protobufs::TransformationAddEarlyTerminatorWrapper message) : message_(std::move(message)) {} TransformationAddEarlyTerminatorWrapper:: TransformationAddEarlyTerminatorWrapper(uint32_t function_fresh_id, uint32_t label_fresh_id, spv::Op opcode) { message_.set_function_fresh_id(function_fresh_id); message_.set_label_fresh_id(label_fresh_id); message_.set_opcode(uint32_t(opcode)); } bool TransformationAddEarlyTerminatorWrapper::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { assert((spv::Op(message_.opcode()) == spv::Op::OpKill || spv::Op(message_.opcode()) == spv::Op::OpUnreachable || spv::Op(message_.opcode()) == spv::Op::OpTerminateInvocation) && "Invalid opcode."); if (!fuzzerutil::IsFreshId(ir_context, message_.function_fresh_id())) { return false; } if (!fuzzerutil::IsFreshId(ir_context, message_.label_fresh_id())) { return false; } if (message_.function_fresh_id() == message_.label_fresh_id()) { return false; } uint32_t void_type_id = fuzzerutil::MaybeGetVoidType(ir_context); if (!void_type_id) { return false; } return fuzzerutil::FindFunctionType(ir_context, {void_type_id}); } void TransformationAddEarlyTerminatorWrapper::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { fuzzerutil::UpdateModuleIdBound(ir_context, message_.function_fresh_id()); fuzzerutil::UpdateModuleIdBound(ir_context, message_.label_fresh_id()); // Create a basic block of the form: // %label_fresh_id = OpLabel // OpKill|Unreachable|TerminateInvocation auto basic_block = MakeUnique(MakeUnique( ir_context, spv::Op::OpLabel, 0, message_.label_fresh_id(), opt::Instruction::OperandList())); basic_block->AddInstruction(MakeUnique( ir_context, static_cast(message_.opcode()), 0, 0, opt::Instruction::OperandList())); // Create a zero-argument void function. auto void_type_id = fuzzerutil::MaybeGetVoidType(ir_context); auto function = MakeUnique(MakeUnique( ir_context, spv::Op::OpFunction, void_type_id, message_.function_fresh_id(), opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_FUNCTION_CONTROL, {uint32_t(spv::FunctionControlMask::MaskNone)}}, {SPV_OPERAND_TYPE_TYPE_ID, {fuzzerutil::FindFunctionType(ir_context, {void_type_id})}}}))); // Add the basic block to the function as the sole block, and add the function // to the module. function->AddBasicBlock(std::move(basic_block)); function->SetFunctionEnd( MakeUnique(ir_context, spv::Op::OpFunctionEnd, 0, 0, opt::Instruction::OperandList())); ir_context->module()->AddFunction(std::move(function)); ir_context->InvalidateAnalysesExceptFor(opt::IRContext::kAnalysisNone); } std::unordered_set TransformationAddEarlyTerminatorWrapper::GetFreshIds() const { return std::unordered_set( {message_.function_fresh_id(), message_.label_fresh_id()}); } protobufs::Transformation TransformationAddEarlyTerminatorWrapper::ToMessage() const { protobufs::Transformation result; *result.mutable_add_early_terminator_wrapper() = message_; return result; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_early_terminator_wrapper.h000066400000000000000000000045531475742701700322650ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_add_early_terminator_wrapper_H_ #define SOURCE_FUZZ_TRANSFORMATION_add_early_terminator_wrapper_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationAddEarlyTerminatorWrapper : public Transformation { public: explicit TransformationAddEarlyTerminatorWrapper( protobufs::TransformationAddEarlyTerminatorWrapper message); TransformationAddEarlyTerminatorWrapper(uint32_t function_fresh_id, uint32_t label_fresh_id, spv::Op opcode); // - |message_.function_fresh_id| and |message_.label_fresh_id| must be fresh // and distinct. // - OpTypeVoid must be declared in the module. // - The module must contain a type for a zero-argument void function. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Adds a function to the module of the form: // // |message_.function_fresh_id| = OpFunction %void None %zero_args_return_void // |message_.label_fresh_id| = OpLabel // |message_.opcode| // OpFunctionEnd void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationAddEarlyTerminatorWrapper message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_add_early_terminator_wrapper_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_function.cpp000066400000000000000000001143431475742701700273240ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_function.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_message.h" namespace spvtools { namespace fuzz { TransformationAddFunction::TransformationAddFunction( protobufs::TransformationAddFunction message) : message_(std::move(message)) {} TransformationAddFunction::TransformationAddFunction( const std::vector& instructions) { for (auto& instruction : instructions) { *message_.add_instruction() = instruction; } message_.set_is_livesafe(false); } TransformationAddFunction::TransformationAddFunction( const std::vector& instructions, uint32_t loop_limiter_variable_id, uint32_t loop_limit_constant_id, const std::vector& loop_limiters, uint32_t kill_unreachable_return_value_id, const std::vector& access_chain_clampers) { for (auto& instruction : instructions) { *message_.add_instruction() = instruction; } message_.set_is_livesafe(true); message_.set_loop_limiter_variable_id(loop_limiter_variable_id); message_.set_loop_limit_constant_id(loop_limit_constant_id); for (auto& loop_limiter : loop_limiters) { *message_.add_loop_limiter_info() = loop_limiter; } message_.set_kill_unreachable_return_value_id( kill_unreachable_return_value_id); for (auto& access_clamper : access_chain_clampers) { *message_.add_access_chain_clamping_info() = access_clamper; } } bool TransformationAddFunction::IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const { // This transformation may use a lot of ids, all of which need to be fresh // and distinct. This set tracks them. std::set ids_used_by_this_transformation; // Ensure that all result ids in the new function are fresh and distinct. for (auto& instruction : message_.instruction()) { if (instruction.result_id()) { if (!CheckIdIsFreshAndNotUsedByThisTransformation( instruction.result_id(), ir_context, &ids_used_by_this_transformation)) { return false; } } } if (message_.is_livesafe()) { // Ensure that all ids provided for making the function livesafe are fresh // and distinct. if (!CheckIdIsFreshAndNotUsedByThisTransformation( message_.loop_limiter_variable_id(), ir_context, &ids_used_by_this_transformation)) { return false; } for (auto& loop_limiter_info : message_.loop_limiter_info()) { if (!CheckIdIsFreshAndNotUsedByThisTransformation( loop_limiter_info.load_id(), ir_context, &ids_used_by_this_transformation)) { return false; } if (!CheckIdIsFreshAndNotUsedByThisTransformation( loop_limiter_info.increment_id(), ir_context, &ids_used_by_this_transformation)) { return false; } if (!CheckIdIsFreshAndNotUsedByThisTransformation( loop_limiter_info.compare_id(), ir_context, &ids_used_by_this_transformation)) { return false; } if (!CheckIdIsFreshAndNotUsedByThisTransformation( loop_limiter_info.logical_op_id(), ir_context, &ids_used_by_this_transformation)) { return false; } } for (auto& access_chain_clamping_info : message_.access_chain_clamping_info()) { for (auto& pair : access_chain_clamping_info.compare_and_select_ids()) { if (!CheckIdIsFreshAndNotUsedByThisTransformation( pair.first(), ir_context, &ids_used_by_this_transformation)) { return false; } if (!CheckIdIsFreshAndNotUsedByThisTransformation( pair.second(), ir_context, &ids_used_by_this_transformation)) { return false; } } } } // Because checking all the conditions for a function to be valid is a big // job that the SPIR-V validator can already do, a "try it and see" approach // is taken here. // We first clone the current module, so that we can try adding the new // function without risking wrecking |ir_context|. auto cloned_module = fuzzerutil::CloneIRContext(ir_context); // We try to add a function to the cloned module, which may fail if // |message_.instruction| is not sufficiently well-formed. if (!TryToAddFunction(cloned_module.get())) { return false; } // Check whether the cloned module is still valid after adding the function. // If it is not, the transformation is not applicable. if (!fuzzerutil::IsValid(cloned_module.get(), transformation_context.GetValidatorOptions(), fuzzerutil::kSilentMessageConsumer)) { return false; } if (message_.is_livesafe()) { if (!TryToMakeFunctionLivesafe(cloned_module.get(), transformation_context)) { return false; } // After making the function livesafe, we check validity of the module // again. This is because the turning of OpKill, OpUnreachable and OpReturn // instructions into branches changes control flow graph reachability, which // has the potential to make the module invalid when it was otherwise valid. // It is simpler to rely on the validator to guard against this than to // consider all scenarios when making a function livesafe. if (!fuzzerutil::IsValid(cloned_module.get(), transformation_context.GetValidatorOptions(), fuzzerutil::kSilentMessageConsumer)) { return false; } } return true; } void TransformationAddFunction::Apply( opt::IRContext* ir_context, TransformationContext* transformation_context) const { // Add the function to the module. As the transformation is applicable, this // should succeed. bool success = TryToAddFunction(ir_context); assert(success && "The function should be successfully added."); (void)(success); // Keep release builds happy (otherwise they may complain // that |success| is not used). if (message_.is_livesafe()) { // Make the function livesafe, which also should succeed. success = TryToMakeFunctionLivesafe(ir_context, *transformation_context); assert(success && "It should be possible to make the function livesafe."); (void)(success); // Keep release builds happy. } ir_context->InvalidateAnalysesExceptFor(opt::IRContext::kAnalysisNone); assert(spv::Op(message_.instruction(0).opcode()) == spv::Op::OpFunction && "The first instruction of an 'add function' transformation must be " "OpFunction."); if (message_.is_livesafe()) { // Inform the fact manager that the function is livesafe. transformation_context->GetFactManager()->AddFactFunctionIsLivesafe( message_.instruction(0).result_id()); } else { // Inform the fact manager that all blocks in the function are dead. for (auto& inst : message_.instruction()) { if (spv::Op(inst.opcode()) == spv::Op::OpLabel) { transformation_context->GetFactManager()->AddFactBlockIsDead( inst.result_id()); } } } // Record the fact that all pointer parameters and variables declared in the // function should be regarded as having irrelevant values. This allows other // passes to store arbitrarily to such variables, and to pass them freely as // parameters to other functions knowing that it is OK if they get // over-written. for (auto& instruction : message_.instruction()) { switch (spv::Op(instruction.opcode())) { case spv::Op::OpFunctionParameter: if (ir_context->get_def_use_mgr() ->GetDef(instruction.result_type_id()) ->opcode() == spv::Op::OpTypePointer) { transformation_context->GetFactManager() ->AddFactValueOfPointeeIsIrrelevant(instruction.result_id()); } break; case spv::Op::OpVariable: transformation_context->GetFactManager() ->AddFactValueOfPointeeIsIrrelevant(instruction.result_id()); break; default: break; } } } protobufs::Transformation TransformationAddFunction::ToMessage() const { protobufs::Transformation result; *result.mutable_add_function() = message_; return result; } bool TransformationAddFunction::TryToAddFunction( opt::IRContext* ir_context) const { // This function returns false if |message_.instruction| was not well-formed // enough to actually create a function and add it to |ir_context|. // A function must have at least some instructions. if (message_.instruction().empty()) { return false; } // A function must start with OpFunction. auto function_begin = message_.instruction(0); if (spv::Op(function_begin.opcode()) != spv::Op::OpFunction) { return false; } // Make a function, headed by the OpFunction instruction. std::unique_ptr new_function = MakeUnique( InstructionFromMessage(ir_context, function_begin)); // Keeps track of which instruction protobuf message we are currently // considering. uint32_t instruction_index = 1; const auto num_instructions = static_cast(message_.instruction().size()); // Iterate through all function parameter instructions, adding parameters to // the new function. while (instruction_index < num_instructions && spv::Op(message_.instruction(instruction_index).opcode()) == spv::Op::OpFunctionParameter) { new_function->AddParameter(InstructionFromMessage( ir_context, message_.instruction(instruction_index))); instruction_index++; } // After the parameters, there needs to be a label. if (instruction_index == num_instructions || spv::Op(message_.instruction(instruction_index).opcode()) != spv::Op::OpLabel) { return false; } // Iterate through the instructions block by block until the end of the // function is reached. while (instruction_index < num_instructions && spv::Op(message_.instruction(instruction_index).opcode()) != spv::Op::OpFunctionEnd) { // Invariant: we should always be at a label instruction at this point. assert(spv::Op(message_.instruction(instruction_index).opcode()) == spv::Op::OpLabel); // Make a basic block using the label instruction. std::unique_ptr block = MakeUnique(InstructionFromMessage( ir_context, message_.instruction(instruction_index))); // Consider successive instructions until we hit another label or the end // of the function, adding each such instruction to the block. instruction_index++; while (instruction_index < num_instructions && spv::Op(message_.instruction(instruction_index).opcode()) != spv::Op::OpFunctionEnd && spv::Op(message_.instruction(instruction_index).opcode()) != spv::Op::OpLabel) { block->AddInstruction(InstructionFromMessage( ir_context, message_.instruction(instruction_index))); instruction_index++; } // Add the block to the new function. new_function->AddBasicBlock(std::move(block)); } // Having considered all the blocks, we should be at the last instruction and // it needs to be OpFunctionEnd. if (instruction_index != num_instructions - 1 || spv::Op(message_.instruction(instruction_index).opcode()) != spv::Op::OpFunctionEnd) { return false; } // Set the function's final instruction, add the function to the module and // report success. new_function->SetFunctionEnd(InstructionFromMessage( ir_context, message_.instruction(instruction_index))); ir_context->AddFunction(std::move(new_function)); ir_context->InvalidateAnalysesExceptFor(opt::IRContext::kAnalysisNone); return true; } bool TransformationAddFunction::TryToMakeFunctionLivesafe( opt::IRContext* ir_context, const TransformationContext& transformation_context) const { assert(message_.is_livesafe() && "Precondition: is_livesafe must hold."); // Get a pointer to the added function. opt::Function* added_function = nullptr; for (auto& function : *ir_context->module()) { if (function.result_id() == message_.instruction(0).result_id()) { added_function = &function; break; } } assert(added_function && "The added function should have been found."); if (!TryToAddLoopLimiters(ir_context, added_function)) { // Adding loop limiters did not work; bail out. return false; } // Consider all the instructions in the function, and: // - attempt to replace OpKill and OpUnreachable with return instructions // - attempt to clamp access chains to be within bounds // - check that OpFunctionCall instructions are only to livesafe functions for (auto& block : *added_function) { for (auto& inst : block) { switch (inst.opcode()) { case spv::Op::OpKill: case spv::Op::OpUnreachable: if (!TryToTurnKillOrUnreachableIntoReturn(ir_context, added_function, &inst)) { return false; } break; case spv::Op::OpAccessChain: case spv::Op::OpInBoundsAccessChain: if (!TryToClampAccessChainIndices(ir_context, &inst)) { return false; } break; case spv::Op::OpFunctionCall: // A livesafe function my only call other livesafe functions. if (!transformation_context.GetFactManager()->FunctionIsLivesafe( inst.GetSingleWordInOperand(0))) { return false; } default: break; } } } return true; } uint32_t TransformationAddFunction::GetBackEdgeBlockId( opt::IRContext* ir_context, uint32_t loop_header_block_id) { const auto* loop_header_block = ir_context->cfg()->block(loop_header_block_id); assert(loop_header_block && "|loop_header_block_id| is invalid"); for (auto pred : ir_context->cfg()->preds(loop_header_block_id)) { if (ir_context->GetDominatorAnalysis(loop_header_block->GetParent()) ->Dominates(loop_header_block_id, pred)) { return pred; } } return 0; } bool TransformationAddFunction::TryToAddLoopLimiters( opt::IRContext* ir_context, opt::Function* added_function) const { // Collect up all the loop headers so that we can subsequently add loop // limiting logic. std::vector loop_headers; for (auto& block : *added_function) { if (block.IsLoopHeader()) { loop_headers.push_back(&block); } } if (loop_headers.empty()) { // There are no loops, so no need to add any loop limiters. return true; } // Check that the module contains appropriate ingredients for declaring and // manipulating a loop limiter. auto loop_limit_constant_id_instr = ir_context->get_def_use_mgr()->GetDef(message_.loop_limit_constant_id()); if (!loop_limit_constant_id_instr || loop_limit_constant_id_instr->opcode() != spv::Op::OpConstant) { // The loop limit constant id instruction must exist and have an // appropriate opcode. return false; } auto loop_limit_type = ir_context->get_def_use_mgr()->GetDef( loop_limit_constant_id_instr->type_id()); if (loop_limit_type->opcode() != spv::Op::OpTypeInt || loop_limit_type->GetSingleWordInOperand(0) != 32) { // The type of the loop limit constant must be 32-bit integer. It // doesn't actually matter whether the integer is signed or not. return false; } // Find the id of the "unsigned int" type. opt::analysis::Integer unsigned_int_type(32, false); uint32_t unsigned_int_type_id = ir_context->get_type_mgr()->GetId(&unsigned_int_type); if (!unsigned_int_type_id) { // Unsigned int is not available; we need this type in order to add loop // limiters. return false; } auto registered_unsigned_int_type = ir_context->get_type_mgr()->GetRegisteredType(&unsigned_int_type); // Look for 0 of type unsigned int. opt::analysis::IntConstant zero(registered_unsigned_int_type->AsInteger(), {0}); auto registered_zero = ir_context->get_constant_mgr()->FindConstant(&zero); if (!registered_zero) { // We need 0 in order to be able to initialize loop limiters. return false; } uint32_t zero_id = ir_context->get_constant_mgr() ->GetDefiningInstruction(registered_zero) ->result_id(); // Look for 1 of type unsigned int. opt::analysis::IntConstant one(registered_unsigned_int_type->AsInteger(), {1}); auto registered_one = ir_context->get_constant_mgr()->FindConstant(&one); if (!registered_one) { // We need 1 in order to be able to increment loop limiters. return false; } uint32_t one_id = ir_context->get_constant_mgr() ->GetDefiningInstruction(registered_one) ->result_id(); // Look for pointer-to-unsigned int type. opt::analysis::Pointer pointer_to_unsigned_int_type( registered_unsigned_int_type, spv::StorageClass::Function); uint32_t pointer_to_unsigned_int_type_id = ir_context->get_type_mgr()->GetId(&pointer_to_unsigned_int_type); if (!pointer_to_unsigned_int_type_id) { // We need pointer-to-unsigned int in order to declare the loop limiter // variable. return false; } // Look for bool type. opt::analysis::Bool bool_type; uint32_t bool_type_id = ir_context->get_type_mgr()->GetId(&bool_type); if (!bool_type_id) { // We need bool in order to compare the loop limiter's value with the loop // limit constant. return false; } // Declare the loop limiter variable at the start of the function's entry // block, via an instruction of the form: // %loop_limiter_var = spv::Op::OpVariable %ptr_to_uint Function %zero added_function->begin()->begin()->InsertBefore(MakeUnique( ir_context, spv::Op::OpVariable, pointer_to_unsigned_int_type_id, message_.loop_limiter_variable_id(), opt::Instruction::OperandList({{SPV_OPERAND_TYPE_STORAGE_CLASS, {uint32_t(spv::StorageClass::Function)}}, {SPV_OPERAND_TYPE_ID, {zero_id}}}))); // Update the module's id bound since we have added the loop limiter // variable id. fuzzerutil::UpdateModuleIdBound(ir_context, message_.loop_limiter_variable_id()); // Consider each loop in turn. for (auto loop_header : loop_headers) { // Look for the loop's back-edge block. This is a predecessor of the loop // header that is dominated by the loop header. const auto back_edge_block_id = GetBackEdgeBlockId(ir_context, loop_header->id()); if (!back_edge_block_id) { // The loop's back-edge block must be unreachable. This means that the // loop cannot iterate, so there is no need to make it lifesafe; we can // move on from this loop. continue; } // If the loop's merge block is unreachable, then there are no constraints // on where the merge block appears in relation to the blocks of the loop. // This means we need to be careful when adding a branch from the back-edge // block to the merge block: the branch might make the loop merge reachable, // and it might then be dominated by the loop header and possibly by other // blocks in the loop. Since a block needs to appear before those blocks it // strictly dominates, this could make the module invalid. To avoid this // problem we bail out in the case where the loop header does not dominate // the loop merge. if (!ir_context->GetDominatorAnalysis(added_function) ->Dominates(loop_header->id(), loop_header->MergeBlockId())) { return false; } // Go through the sequence of loop limiter infos and find the one // corresponding to this loop. bool found = false; protobufs::LoopLimiterInfo loop_limiter_info; for (auto& info : message_.loop_limiter_info()) { if (info.loop_header_id() == loop_header->id()) { loop_limiter_info = info; found = true; break; } } if (!found) { // We don't have loop limiter info for this loop header. return false; } // The back-edge block either has the form: // // (1) // // %l = OpLabel // ... instructions ... // OpBranch %loop_header // // (2) // // %l = OpLabel // ... instructions ... // OpBranchConditional %c %loop_header %loop_merge // // (3) // // %l = OpLabel // ... instructions ... // OpBranchConditional %c %loop_merge %loop_header // // We turn these into the following: // // (1) // // %l = OpLabel // ... instructions ... // %t1 = OpLoad %uint32 %loop_limiter // %t2 = OpIAdd %uint32 %t1 %one // OpStore %loop_limiter %t2 // %t3 = OpUGreaterThanEqual %bool %t1 %loop_limit // OpBranchConditional %t3 %loop_merge %loop_header // // (2) // // %l = OpLabel // ... instructions ... // %t1 = OpLoad %uint32 %loop_limiter // %t2 = OpIAdd %uint32 %t1 %one // OpStore %loop_limiter %t2 // %t3 = OpULessThan %bool %t1 %loop_limit // %t4 = OpLogicalAnd %bool %c %t3 // OpBranchConditional %t4 %loop_header %loop_merge // // (3) // // %l = OpLabel // ... instructions ... // %t1 = OpLoad %uint32 %loop_limiter // %t2 = OpIAdd %uint32 %t1 %one // OpStore %loop_limiter %t2 // %t3 = OpUGreaterThanEqual %bool %t1 %loop_limit // %t4 = OpLogicalOr %bool %c %t3 // OpBranchConditional %t4 %loop_merge %loop_header auto back_edge_block = ir_context->cfg()->block(back_edge_block_id); auto back_edge_block_terminator = back_edge_block->terminator(); bool compare_using_greater_than_equal; if (back_edge_block_terminator->opcode() == spv::Op::OpBranch) { compare_using_greater_than_equal = true; } else { assert(back_edge_block_terminator->opcode() == spv::Op::OpBranchConditional); assert(((back_edge_block_terminator->GetSingleWordInOperand(1) == loop_header->id() && back_edge_block_terminator->GetSingleWordInOperand(2) == loop_header->MergeBlockId()) || (back_edge_block_terminator->GetSingleWordInOperand(2) == loop_header->id() && back_edge_block_terminator->GetSingleWordInOperand(1) == loop_header->MergeBlockId())) && "A back edge edge block must branch to" " either the loop header or merge"); compare_using_greater_than_equal = back_edge_block_terminator->GetSingleWordInOperand(1) == loop_header->MergeBlockId(); } std::vector> new_instructions; // Add a load from the loop limiter variable, of the form: // %t1 = OpLoad %uint32 %loop_limiter new_instructions.push_back(MakeUnique( ir_context, spv::Op::OpLoad, unsigned_int_type_id, loop_limiter_info.load_id(), opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {message_.loop_limiter_variable_id()}}}))); // Increment the loaded value: // %t2 = OpIAdd %uint32 %t1 %one new_instructions.push_back(MakeUnique( ir_context, spv::Op::OpIAdd, unsigned_int_type_id, loop_limiter_info.increment_id(), opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {loop_limiter_info.load_id()}}, {SPV_OPERAND_TYPE_ID, {one_id}}}))); // Store the incremented value back to the loop limiter variable: // OpStore %loop_limiter %t2 new_instructions.push_back(MakeUnique( ir_context, spv::Op::OpStore, 0, 0, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {message_.loop_limiter_variable_id()}}, {SPV_OPERAND_TYPE_ID, {loop_limiter_info.increment_id()}}}))); // Compare the loaded value with the loop limit; either: // %t3 = OpUGreaterThanEqual %bool %t1 %loop_limit // or // %t3 = OpULessThan %bool %t1 %loop_limit new_instructions.push_back(MakeUnique( ir_context, compare_using_greater_than_equal ? spv::Op::OpUGreaterThanEqual : spv::Op::OpULessThan, bool_type_id, loop_limiter_info.compare_id(), opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {loop_limiter_info.load_id()}}, {SPV_OPERAND_TYPE_ID, {message_.loop_limit_constant_id()}}}))); if (back_edge_block_terminator->opcode() == spv::Op::OpBranchConditional) { new_instructions.push_back(MakeUnique( ir_context, compare_using_greater_than_equal ? spv::Op::OpLogicalOr : spv::Op::OpLogicalAnd, bool_type_id, loop_limiter_info.logical_op_id(), opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {back_edge_block_terminator->GetSingleWordInOperand(0)}}, {SPV_OPERAND_TYPE_ID, {loop_limiter_info.compare_id()}}}))); } // Add the new instructions at the end of the back edge block, before the // terminator and any loop merge instruction (as the back edge block can // be the loop header). if (back_edge_block->GetLoopMergeInst()) { back_edge_block->GetLoopMergeInst()->InsertBefore( std::move(new_instructions)); } else { back_edge_block_terminator->InsertBefore(std::move(new_instructions)); } if (back_edge_block_terminator->opcode() == spv::Op::OpBranchConditional) { back_edge_block_terminator->SetInOperand( 0, {loop_limiter_info.logical_op_id()}); } else { assert(back_edge_block_terminator->opcode() == spv::Op::OpBranch && "Back-edge terminator must be OpBranch or OpBranchConditional"); // Check that, if the merge block starts with OpPhi instructions, suitable // ids have been provided to give these instructions a value corresponding // to the new incoming edge from the back edge block. auto merge_block = ir_context->cfg()->block(loop_header->MergeBlockId()); if (!fuzzerutil::PhiIdsOkForNewEdge(ir_context, back_edge_block, merge_block, loop_limiter_info.phi_id())) { return false; } // Augment OpPhi instructions at the loop merge with the given ids. uint32_t phi_index = 0; for (auto& inst : *merge_block) { if (inst.opcode() != spv::Op::OpPhi) { break; } assert(phi_index < static_cast(loop_limiter_info.phi_id().size()) && "There should be at least one phi id per OpPhi instruction."); inst.AddOperand( {SPV_OPERAND_TYPE_ID, {loop_limiter_info.phi_id(phi_index)}}); inst.AddOperand({SPV_OPERAND_TYPE_ID, {back_edge_block_id}}); phi_index++; } // Add the new edge, by changing OpBranch to OpBranchConditional. back_edge_block_terminator->SetOpcode(spv::Op::OpBranchConditional); back_edge_block_terminator->SetInOperands(opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {loop_limiter_info.compare_id()}}, {SPV_OPERAND_TYPE_ID, {loop_header->MergeBlockId()}}, {SPV_OPERAND_TYPE_ID, {loop_header->id()}}})); } // Update the module's id bound with respect to the various ids that // have been used for loop limiter manipulation. fuzzerutil::UpdateModuleIdBound(ir_context, loop_limiter_info.load_id()); fuzzerutil::UpdateModuleIdBound(ir_context, loop_limiter_info.increment_id()); fuzzerutil::UpdateModuleIdBound(ir_context, loop_limiter_info.compare_id()); fuzzerutil::UpdateModuleIdBound(ir_context, loop_limiter_info.logical_op_id()); } return true; } bool TransformationAddFunction::TryToTurnKillOrUnreachableIntoReturn( opt::IRContext* ir_context, opt::Function* added_function, opt::Instruction* kill_or_unreachable_inst) const { assert((kill_or_unreachable_inst->opcode() == spv::Op::OpKill || kill_or_unreachable_inst->opcode() == spv::Op::OpUnreachable) && "Precondition: instruction must be OpKill or OpUnreachable."); // Get the function's return type. auto function_return_type_inst = ir_context->get_def_use_mgr()->GetDef(added_function->type_id()); if (function_return_type_inst->opcode() == spv::Op::OpTypeVoid) { // The function has void return type, so change this instruction to // OpReturn. kill_or_unreachable_inst->SetOpcode(spv::Op::OpReturn); } else { // The function has non-void return type, so change this instruction // to OpReturnValue, using the value id provided with the // transformation. // We first check that the id, %id, provided with the transformation // specifically to turn OpKill and OpUnreachable instructions into // OpReturnValue %id has the same type as the function's return type. if (ir_context->get_def_use_mgr() ->GetDef(message_.kill_unreachable_return_value_id()) ->type_id() != function_return_type_inst->result_id()) { return false; } kill_or_unreachable_inst->SetOpcode(spv::Op::OpReturnValue); kill_or_unreachable_inst->SetInOperands( {{SPV_OPERAND_TYPE_ID, {message_.kill_unreachable_return_value_id()}}}); } return true; } bool TransformationAddFunction::TryToClampAccessChainIndices( opt::IRContext* ir_context, opt::Instruction* access_chain_inst) const { assert((access_chain_inst->opcode() == spv::Op::OpAccessChain || access_chain_inst->opcode() == spv::Op::OpInBoundsAccessChain) && "Precondition: instruction must be OpAccessChain or " "OpInBoundsAccessChain."); // Find the AccessChainClampingInfo associated with this access chain. const protobufs::AccessChainClampingInfo* access_chain_clamping_info = nullptr; for (auto& clamping_info : message_.access_chain_clamping_info()) { if (clamping_info.access_chain_id() == access_chain_inst->result_id()) { access_chain_clamping_info = &clamping_info; break; } } if (!access_chain_clamping_info) { // No access chain clamping information was found; the function cannot be // made livesafe. return false; } // Check that there is a (compare_id, select_id) pair for every // index associated with the instruction. if (static_cast( access_chain_clamping_info->compare_and_select_ids().size()) != access_chain_inst->NumInOperands() - 1) { return false; } // Walk the access chain, clamping each index to be within bounds if it is // not a constant. auto base_object = ir_context->get_def_use_mgr()->GetDef( access_chain_inst->GetSingleWordInOperand(0)); assert(base_object && "The base object must exist."); auto pointer_type = ir_context->get_def_use_mgr()->GetDef(base_object->type_id()); assert(pointer_type && pointer_type->opcode() == spv::Op::OpTypePointer && "The base object must have pointer type."); auto should_be_composite_type = ir_context->get_def_use_mgr()->GetDef( pointer_type->GetSingleWordInOperand(1)); // Consider each index input operand in turn (operand 0 is the base object). for (uint32_t index = 1; index < access_chain_inst->NumInOperands(); index++) { // We are going to turn: // // %result = OpAccessChain %type %object ... %index ... // // into: // // %t1 = OpULessThanEqual %bool %index %bound_minus_one // %t2 = OpSelect %int_type %t1 %index %bound_minus_one // %result = OpAccessChain %type %object ... %t2 ... // // ... unless %index is already a constant. // Get the bound for the composite being indexed into; e.g. the number of // columns of matrix or the size of an array. uint32_t bound = fuzzerutil::GetBoundForCompositeIndex( *should_be_composite_type, ir_context); // Get the instruction associated with the index and figure out its integer // type. const uint32_t index_id = access_chain_inst->GetSingleWordInOperand(index); auto index_inst = ir_context->get_def_use_mgr()->GetDef(index_id); auto index_type_inst = ir_context->get_def_use_mgr()->GetDef(index_inst->type_id()); assert(index_type_inst->opcode() == spv::Op::OpTypeInt); assert(index_type_inst->GetSingleWordInOperand(0) == 32); opt::analysis::Integer* index_int_type = ir_context->get_type_mgr() ->GetType(index_type_inst->result_id()) ->AsInteger(); if (index_inst->opcode() != spv::Op::OpConstant || index_inst->GetSingleWordInOperand(0) >= bound) { // The index is either non-constant or an out-of-bounds constant, so we // need to clamp it. assert(should_be_composite_type->opcode() != spv::Op::OpTypeStruct && "Access chain indices into structures are required to be " "constants."); opt::analysis::IntConstant bound_minus_one(index_int_type, {bound - 1}); if (!ir_context->get_constant_mgr()->FindConstant(&bound_minus_one)) { // We do not have an integer constant whose value is |bound| -1. return false; } opt::analysis::Bool bool_type; uint32_t bool_type_id = ir_context->get_type_mgr()->GetId(&bool_type); if (!bool_type_id) { // Bool type is not declared; we cannot do a comparison. return false; } uint32_t bound_minus_one_id = ir_context->get_constant_mgr() ->GetDefiningInstruction(&bound_minus_one) ->result_id(); uint32_t compare_id = access_chain_clamping_info->compare_and_select_ids(index - 1).first(); uint32_t select_id = access_chain_clamping_info->compare_and_select_ids(index - 1) .second(); std::vector> new_instructions; // Compare the index with the bound via an instruction of the form: // %t1 = OpULessThanEqual %bool %index %bound_minus_one new_instructions.push_back(MakeUnique( ir_context, spv::Op::OpULessThanEqual, bool_type_id, compare_id, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {index_inst->result_id()}}, {SPV_OPERAND_TYPE_ID, {bound_minus_one_id}}}))); // Select the index if in-bounds, otherwise one less than the bound: // %t2 = OpSelect %int_type %t1 %index %bound_minus_one new_instructions.push_back(MakeUnique( ir_context, spv::Op::OpSelect, index_type_inst->result_id(), select_id, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {compare_id}}, {SPV_OPERAND_TYPE_ID, {index_inst->result_id()}}, {SPV_OPERAND_TYPE_ID, {bound_minus_one_id}}}))); // Add the new instructions before the access chain access_chain_inst->InsertBefore(std::move(new_instructions)); // Replace %index with %t2. access_chain_inst->SetInOperand(index, {select_id}); fuzzerutil::UpdateModuleIdBound(ir_context, compare_id); fuzzerutil::UpdateModuleIdBound(ir_context, select_id); } should_be_composite_type = FollowCompositeIndex(ir_context, *should_be_composite_type, index_id); } return true; } opt::Instruction* TransformationAddFunction::FollowCompositeIndex( opt::IRContext* ir_context, const opt::Instruction& composite_type_inst, uint32_t index_id) { uint32_t sub_object_type_id; switch (composite_type_inst.opcode()) { case spv::Op::OpTypeArray: case spv::Op::OpTypeRuntimeArray: sub_object_type_id = composite_type_inst.GetSingleWordInOperand(0); break; case spv::Op::OpTypeMatrix: case spv::Op::OpTypeVector: sub_object_type_id = composite_type_inst.GetSingleWordInOperand(0); break; case spv::Op::OpTypeStruct: { auto index_inst = ir_context->get_def_use_mgr()->GetDef(index_id); assert(index_inst->opcode() == spv::Op::OpConstant); assert(ir_context->get_def_use_mgr() ->GetDef(index_inst->type_id()) ->opcode() == spv::Op::OpTypeInt); assert(ir_context->get_def_use_mgr() ->GetDef(index_inst->type_id()) ->GetSingleWordInOperand(0) == 32); uint32_t index_value = index_inst->GetSingleWordInOperand(0); sub_object_type_id = composite_type_inst.GetSingleWordInOperand(index_value); break; } default: assert(false && "Unknown composite type."); sub_object_type_id = 0; break; } assert(sub_object_type_id && "No sub-object found."); return ir_context->get_def_use_mgr()->GetDef(sub_object_type_id); } std::unordered_set TransformationAddFunction::GetFreshIds() const { std::unordered_set result; for (auto& instruction : message_.instruction()) { result.insert(instruction.result_id()); } if (message_.is_livesafe()) { result.insert(message_.loop_limiter_variable_id()); for (auto& loop_limiter_info : message_.loop_limiter_info()) { result.insert(loop_limiter_info.load_id()); result.insert(loop_limiter_info.increment_id()); result.insert(loop_limiter_info.compare_id()); result.insert(loop_limiter_info.logical_op_id()); } for (auto& access_chain_clamping_info : message_.access_chain_clamping_info()) { for (auto& pair : access_chain_clamping_info.compare_and_select_ids()) { result.insert(pair.first()); result.insert(pair.second()); } } } return result; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_function.h000066400000000000000000000131541475742701700267670ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_ADD_FUNCTION_H_ #define SOURCE_FUZZ_TRANSFORMATION_ADD_FUNCTION_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationAddFunction : public Transformation { public: explicit TransformationAddFunction( protobufs::TransformationAddFunction message); // Creates a transformation to add a non live-safe function. explicit TransformationAddFunction( const std::vector& instructions); // Creates a transformation to add a live-safe function. TransformationAddFunction( const std::vector& instructions, uint32_t loop_limiter_variable_id, uint32_t loop_limit_constant_id, const std::vector& loop_limiters, uint32_t kill_unreachable_return_value_id, const std::vector& access_chain_clampers); // - |message_.instruction| must correspond to a sufficiently well-formed // sequence of instructions that a function can be created from them // - If |message_.is_livesafe| holds then |message_| must contain suitable // ingredients to make the function livesafe, and the function must only // invoke other livesafe functions // - Adding the created function to the module must lead to a valid module. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Adds the function defined by |message_.instruction| to the module, making // it livesafe if |message_.is_livesafe| holds. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; // Helper method that, given composite type |composite_type_inst|, returns the // type of the sub-object at index |index_id|, which is required to be in- // bounds. static opt::Instruction* FollowCompositeIndex( opt::IRContext* ir_context, const opt::Instruction& composite_type_inst, uint32_t index_id); // Returns id of the back-edge block, given the corresponding // |loop_header_block_id|. |loop_header_block_id| must be the id of a loop // header block. Returns 0 if the loop has no back-edge block. static uint32_t GetBackEdgeBlockId(opt::IRContext* ir_context, uint32_t loop_header_block_id); // Attempts to create a function from the series of instructions in // |message_.instruction| and add it to |ir_context|. // // Returns false if adding the function is not possible due to the messages // not respecting the basic structure of a function, e.g. if there is no // OpFunction instruction or no blocks; in this case |ir_context| is left in // an indeterminate state. // // Otherwise returns true. Whether |ir_context| is valid after addition of // the function depends on the contents of |message_.instruction|. // // Intended usage: // - Perform a dry run of this method on a clone of a module, and use // the validator to check whether the resulting module is valid. Working // on a clone means it does not matter if the function fails to be cleanly // added, or leads to an invalid module. // - If the dry run succeeds, run the method on the real module of interest, // to add the function. bool TryToAddFunction(opt::IRContext* ir_context) const; private: // Should only be called if |message_.is_livesafe| holds. Attempts to make // the function livesafe (see FactFunctionIsLivesafe for a definition). // Returns false if this is not possible, due to |message_| or |ir_context| // not containing sufficient ingredients (such as types and fresh ids) to add // the instrumentation necessary to make the function livesafe. bool TryToMakeFunctionLivesafe( opt::IRContext* ir_context, const TransformationContext& transformation_context) const; // A helper for TryToMakeFunctionLivesafe that tries to add loop-limiting // logic. bool TryToAddLoopLimiters(opt::IRContext* ir_context, opt::Function* added_function) const; // A helper for TryToMakeFunctionLivesafe that tries to replace OpKill and // OpUnreachable instructions into return instructions. bool TryToTurnKillOrUnreachableIntoReturn( opt::IRContext* ir_context, opt::Function* added_function, opt::Instruction* kill_or_unreachable_inst) const; // A helper for TryToMakeFunctionLivesafe that tries to clamp access chain // indices so that they are guaranteed to be in-bounds. bool TryToClampAccessChainIndices(opt::IRContext* ir_context, opt::Instruction* access_chain_inst) const; protobufs::TransformationAddFunction message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_ADD_FUNCTION_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_global_undef.cpp000066400000000000000000000051531475742701700301160ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_global_undef.h" #include "source/fuzz/fuzzer_util.h" #include "source/opt/reflect.h" namespace spvtools { namespace fuzz { TransformationAddGlobalUndef::TransformationAddGlobalUndef( spvtools::fuzz::protobufs::TransformationAddGlobalUndef message) : message_(std::move(message)) {} TransformationAddGlobalUndef::TransformationAddGlobalUndef(uint32_t fresh_id, uint32_t type_id) { message_.set_fresh_id(fresh_id); message_.set_type_id(type_id); } bool TransformationAddGlobalUndef::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { // A fresh id is required. if (!fuzzerutil::IsFreshId(ir_context, message_.fresh_id())) { return false; } auto type = ir_context->get_def_use_mgr()->GetDef(message_.type_id()); // The type must exist, and must not be a function or pointer type. return type != nullptr && opt::IsTypeInst(type->opcode()) && type->opcode() != spv::Op::OpTypeFunction && type->opcode() != spv::Op::OpTypePointer; } void TransformationAddGlobalUndef::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { auto new_instruction = MakeUnique( ir_context, spv::Op::OpUndef, message_.type_id(), message_.fresh_id(), opt::Instruction::OperandList()); auto new_instruction_ptr = new_instruction.get(); ir_context->module()->AddGlobalValue(std::move(new_instruction)); fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id()); // Inform the def-use manager about the new instruction. ir_context->get_def_use_mgr()->AnalyzeInstDef(new_instruction_ptr); } protobufs::Transformation TransformationAddGlobalUndef::ToMessage() const { protobufs::Transformation result; *result.mutable_add_global_undef() = message_; return result; } std::unordered_set TransformationAddGlobalUndef::GetFreshIds() const { return {message_.fresh_id()}; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_global_undef.h000066400000000000000000000036461475742701700275700ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_ADD_GLOBAL_UNDEF_H_ #define SOURCE_FUZZ_TRANSFORMATION_ADD_GLOBAL_UNDEF_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationAddGlobalUndef : public Transformation { public: explicit TransformationAddGlobalUndef( protobufs::TransformationAddGlobalUndef message); TransformationAddGlobalUndef(uint32_t fresh_id, uint32_t type_id); // - |message_.fresh_id| must be fresh // - |message_.type_id| must be the id of a non-function, non-pointer type bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Adds an OpUndef instruction to the module, with |message_.type_id| as its // type. The instruction has result id |message_.fresh_id|. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationAddGlobalUndef message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_ADD_GLOBAL_UNDEF_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_global_variable.cpp000066400000000000000000000103141475742701700305750ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_global_variable.h" #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { TransformationAddGlobalVariable::TransformationAddGlobalVariable( spvtools::fuzz::protobufs::TransformationAddGlobalVariable message) : message_(std::move(message)) {} TransformationAddGlobalVariable::TransformationAddGlobalVariable( uint32_t fresh_id, uint32_t type_id, spv::StorageClass storage_class, uint32_t initializer_id, bool value_is_irrelevant) { message_.set_fresh_id(fresh_id); message_.set_type_id(type_id); message_.set_storage_class(uint32_t(storage_class)); message_.set_initializer_id(initializer_id); message_.set_value_is_irrelevant(value_is_irrelevant); } bool TransformationAddGlobalVariable::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { // The result id must be fresh. if (!fuzzerutil::IsFreshId(ir_context, message_.fresh_id())) { return false; } // The storage class must be Private or Workgroup. auto storage_class = static_cast(message_.storage_class()); switch (storage_class) { case spv::StorageClass::Private: case spv::StorageClass::Workgroup: break; default: assert(false && "Unsupported storage class."); return false; } // The type id must correspond to a type. auto type = ir_context->get_type_mgr()->GetType(message_.type_id()); if (!type) { return false; } // That type must be a pointer type ... auto pointer_type = type->AsPointer(); if (!pointer_type) { return false; } // ... with the right storage class. if (pointer_type->storage_class() != storage_class) { return false; } if (message_.initializer_id()) { // An initializer is not allowed if the storage class is Workgroup. if (storage_class == spv::StorageClass::Workgroup) { assert(false && "By construction this transformation should not have an " "initializer when Workgroup storage class is used."); return false; } // The initializer id must be the id of a constant. Check this with the // constant manager. auto constant_id = ir_context->get_constant_mgr()->GetConstantsFromIds( {message_.initializer_id()}); if (constant_id.empty()) { return false; } assert(constant_id.size() == 1 && "We asked for the constant associated with a single id; we should " "get a single constant."); // The type of the constant must match the pointee type of the pointer. if (pointer_type->pointee_type() != constant_id[0]->type()) { return false; } } return true; } void TransformationAddGlobalVariable::Apply( opt::IRContext* ir_context, TransformationContext* transformation_context) const { opt::Instruction* new_instruction = fuzzerutil::AddGlobalVariable( ir_context, message_.fresh_id(), message_.type_id(), static_cast(message_.storage_class()), message_.initializer_id()); // Inform the def-use manager about the new instruction. ir_context->get_def_use_mgr()->AnalyzeInstDefUse(new_instruction); if (message_.value_is_irrelevant()) { transformation_context->GetFactManager()->AddFactValueOfPointeeIsIrrelevant( message_.fresh_id()); } } protobufs::Transformation TransformationAddGlobalVariable::ToMessage() const { protobufs::Transformation result; *result.mutable_add_global_variable() = message_; return result; } std::unordered_set TransformationAddGlobalVariable::GetFreshIds() const { return {message_.fresh_id()}; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_global_variable.h000066400000000000000000000053441475742701700302510ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_ADD_GLOBAL_VARIABLE_H_ #define SOURCE_FUZZ_TRANSFORMATION_ADD_GLOBAL_VARIABLE_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationAddGlobalVariable : public Transformation { public: explicit TransformationAddGlobalVariable( protobufs::TransformationAddGlobalVariable message); TransformationAddGlobalVariable(uint32_t fresh_id, uint32_t type_id, spv::StorageClass storage_class, uint32_t initializer_id, bool value_is_irrelevant); // - |message_.fresh_id| must be fresh // - |message_.type_id| must be the id of a pointer type with the same storage // class as |message_.storage_class| // - |message_.storage_class| must be Private or Workgroup // - |message_.initializer_id| must be 0 if |message_.storage_class| is // Workgroup, and otherwise may either be 0 or the id of a constant whose // type is the pointee type of |message_.type_id| bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Adds a global variable with storage class |message_.storage_class| to the // module, with type |message_.type_id| and either no initializer or // |message_.initializer_id| as an initializer, depending on whether // |message_.initializer_id| is 0. The global variable has result id // |message_.fresh_id|. // // If |message_.value_is_irrelevant| holds, adds a corresponding fact to the // fact manager in |transformation_context|. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationAddGlobalVariable message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_ADD_GLOBAL_VARIABLE_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_image_sample_unused_components.cpp000066400000000000000000000103451475742701700337470ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_image_sample_unused_components.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" namespace spvtools { namespace fuzz { TransformationAddImageSampleUnusedComponents:: TransformationAddImageSampleUnusedComponents( protobufs::TransformationAddImageSampleUnusedComponents message) : message_(std::move(message)) {} TransformationAddImageSampleUnusedComponents:: TransformationAddImageSampleUnusedComponents( uint32_t coordinate_with_unused_components_id, const protobufs::InstructionDescriptor& instruction_descriptor) { message_.set_coordinate_with_unused_components_id( coordinate_with_unused_components_id); *message_.mutable_instruction_descriptor() = instruction_descriptor; } bool TransformationAddImageSampleUnusedComponents::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { auto image_sample_instruction = FindInstruction(message_.instruction_descriptor(), ir_context); // The image sample instruction must be defined. if (image_sample_instruction == nullptr) { return false; } // The instruction must be an image sample instruction. if (!spvOpcodeIsImageSample(image_sample_instruction->opcode())) { return false; } uint32_t coordinate_id = image_sample_instruction->GetSingleWordInOperand(1); auto coordinate_instruction = ir_context->get_def_use_mgr()->GetDef(coordinate_id); auto coordinate_type = ir_context->get_type_mgr()->GetType(coordinate_instruction->type_id()); // It must be possible to add unused components. if (coordinate_type->AsVector() && coordinate_type->AsVector()->element_count() == 4) { return false; } auto coordinate_with_unused_components_instruction = ir_context->get_def_use_mgr()->GetDef( message_.coordinate_with_unused_components_id()); // The coordinate with unused components instruction must be defined. if (coordinate_with_unused_components_instruction == nullptr) { return false; } // It must be an OpCompositeConstruct instruction such that it can be checked // that the original components are present. if (coordinate_with_unused_components_instruction->opcode() != spv::Op::OpCompositeConstruct) { return false; } // The first constituent must be the original coordinate. if (coordinate_with_unused_components_instruction->GetSingleWordInOperand( 0) != coordinate_id) { return false; } auto coordinate_with_unused_components_type = ir_context->get_type_mgr()->GetType( coordinate_with_unused_components_instruction->type_id()); // |coordinate_with_unused_components_type| must be a vector. if (!coordinate_with_unused_components_type->AsVector()) { return false; } return true; } void TransformationAddImageSampleUnusedComponents::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { // Sets the coordinate operand. auto image_sample_instruction = FindInstruction(message_.instruction_descriptor(), ir_context); image_sample_instruction->SetInOperand( 1, {message_.coordinate_with_unused_components_id()}); ir_context->InvalidateAnalysesExceptFor(opt::IRContext::kAnalysisNone); } protobufs::Transformation TransformationAddImageSampleUnusedComponents::ToMessage() const { protobufs::Transformation result; *result.mutable_add_image_sample_unused_components() = message_; return result; } std::unordered_set TransformationAddImageSampleUnusedComponents::GetFreshIds() const { return std::unordered_set(); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_image_sample_unused_components.h000066400000000000000000000044121475742701700334120ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_ADD_IMAGE_SAMPLE_UNUSED_COMPONENTS_H_ #define SOURCE_FUZZ_TRANSFORMATION_ADD_IMAGE_SAMPLE_UNUSED_COMPONENTS_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationAddImageSampleUnusedComponents : public Transformation { public: explicit TransformationAddImageSampleUnusedComponents( protobufs::TransformationAddImageSampleUnusedComponents message); TransformationAddImageSampleUnusedComponents( uint32_t coordinate_with_unused_components_id, const protobufs::InstructionDescriptor& instruction_descriptor); // - |coordinate_with_unused_components_id| must identify a vector such that // the first components match the components of the image sample coordinate. // - |message_.instruction_descriptor| must identify an image sample // instruction bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Add unused components to an image sample coordinate by replacing the // coordinate with |coordinate_with_unused_components_id|. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationAddImageSampleUnusedComponents message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_ADD_IMAGE_SAMPLE_UNUSED_COMPONENTS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_local_variable.cpp000066400000000000000000000072421475742701700304350ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_local_variable.h" #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { TransformationAddLocalVariable::TransformationAddLocalVariable( spvtools::fuzz::protobufs::TransformationAddLocalVariable message) : message_(std::move(message)) {} TransformationAddLocalVariable::TransformationAddLocalVariable( uint32_t fresh_id, uint32_t type_id, uint32_t function_id, uint32_t initializer_id, bool value_is_irrelevant) { message_.set_fresh_id(fresh_id); message_.set_type_id(type_id); message_.set_function_id(function_id); message_.set_initializer_id(initializer_id); message_.set_value_is_irrelevant(value_is_irrelevant); } bool TransformationAddLocalVariable::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { // The provided id must be fresh. if (!fuzzerutil::IsFreshId(ir_context, message_.fresh_id())) { return false; } // The pointer type id must indeed correspond to a pointer, and it must have // function storage class. auto type_instruction = ir_context->get_def_use_mgr()->GetDef(message_.type_id()); if (!type_instruction || type_instruction->opcode() != spv::Op::OpTypePointer || spv::StorageClass(type_instruction->GetSingleWordInOperand(0)) != spv::StorageClass::Function) { return false; } // The initializer must... auto initializer_instruction = ir_context->get_def_use_mgr()->GetDef(message_.initializer_id()); // ... exist, ... if (!initializer_instruction) { return false; } // ... be a constant, ... if (!spvOpcodeIsConstant(initializer_instruction->opcode())) { return false; } // ... and have the same type as the pointee type. if (initializer_instruction->type_id() != type_instruction->GetSingleWordInOperand(1)) { return false; } // The function to which the local variable is to be added must exist. return fuzzerutil::FindFunction(ir_context, message_.function_id()); } void TransformationAddLocalVariable::Apply( opt::IRContext* ir_context, TransformationContext* transformation_context) const { opt::Instruction* new_instruction = fuzzerutil::AddLocalVariable( ir_context, message_.fresh_id(), message_.type_id(), message_.function_id(), message_.initializer_id()); // Inform the def-use manager about the new instruction. ir_context->get_def_use_mgr()->AnalyzeInstDefUse(new_instruction); ir_context->set_instr_block( new_instruction, fuzzerutil::FindFunction(ir_context, message_.function_id()) ->entry() .get()); if (message_.value_is_irrelevant()) { transformation_context->GetFactManager()->AddFactValueOfPointeeIsIrrelevant( message_.fresh_id()); } } protobufs::Transformation TransformationAddLocalVariable::ToMessage() const { protobufs::Transformation result; *result.mutable_add_local_variable() = message_; return result; } std::unordered_set TransformationAddLocalVariable::GetFreshIds() const { return {message_.fresh_id()}; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_local_variable.h000066400000000000000000000047151475742701700301040ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_ADD_LOCAL_VARIABLE_H_ #define SOURCE_FUZZ_TRANSFORMATION_ADD_LOCAL_VARIABLE_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationAddLocalVariable : public Transformation { public: explicit TransformationAddLocalVariable( protobufs::TransformationAddLocalVariable message); TransformationAddLocalVariable(uint32_t fresh_id, uint32_t type_id, uint32_t function_id, uint32_t initializer_id, bool value_is_irrelevant); // - |message_.fresh_id| must not be used by the module // - |message_.type_id| must be the id of a pointer type with Function // storage class // - |message_.initializer_id| must be the id of a constant with the same // type as the pointer's pointee type // - |message_.function_id| must be the id of a function bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Adds an instruction to the start of |message_.function_id|, of the form: // |message_.fresh_id| = OpVariable |message_.type_id| Function // |message_.initializer_id| // If |message_.value_is_irrelevant| holds, adds a corresponding fact to the // fact manager in |transformation_context|. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationAddLocalVariable message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_ADD_LOCAL_VARIABLE_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_loop_preheader.cpp000066400000000000000000000217771475742701700304770ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "transformation_add_loop_preheader.h" #include "source/fuzz/fuzzer_util.h" #include "source/opt/instruction.h" namespace spvtools { namespace fuzz { TransformationAddLoopPreheader::TransformationAddLoopPreheader( protobufs::TransformationAddLoopPreheader message) : message_(std::move(message)) {} TransformationAddLoopPreheader::TransformationAddLoopPreheader( uint32_t loop_header_block, uint32_t fresh_id, std::vector phi_id) { message_.set_loop_header_block(loop_header_block); message_.set_fresh_id(fresh_id); for (auto id : phi_id) { message_.add_phi_id(id); } } bool TransformationAddLoopPreheader::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /* unused */) const { // |message_.loop_header_block()| must be the id of a loop header block. opt::BasicBlock* loop_header_block = fuzzerutil::MaybeFindBlock(ir_context, message_.loop_header_block()); if (!loop_header_block || !loop_header_block->IsLoopHeader()) { return false; } // The id for the preheader must actually be fresh. std::set used_ids; if (!CheckIdIsFreshAndNotUsedByThisTransformation(message_.fresh_id(), ir_context, &used_ids)) { return false; } size_t num_predecessors = ir_context->cfg()->preds(message_.loop_header_block()).size(); // The block must have at least 2 predecessors (the back-edge block and // another predecessor outside of the loop) if (num_predecessors < 2) { return false; } // If the block only has one predecessor outside of the loop (and thus 2 in // total), then no additional fresh ids are necessary. if (num_predecessors == 2) { return true; } // Count the number of OpPhi instructions. int32_t num_phi_insts = 0; loop_header_block->ForEachPhiInst( [&num_phi_insts](opt::Instruction* /* unused */) { num_phi_insts++; }); // There must be enough fresh ids for the OpPhi instructions. if (num_phi_insts > message_.phi_id_size()) { return false; } // Check that the needed ids are fresh and distinct. for (int32_t i = 0; i < num_phi_insts; i++) { if (!CheckIdIsFreshAndNotUsedByThisTransformation(message_.phi_id(i), ir_context, &used_ids)) { return false; } } return true; } void TransformationAddLoopPreheader::Apply( opt::IRContext* ir_context, TransformationContext* /* transformation_context */) const { // Find the loop header. opt::BasicBlock* loop_header = fuzzerutil::MaybeFindBlock(ir_context, message_.loop_header_block()); auto dominator_analysis = ir_context->GetDominatorAnalysis(loop_header->GetParent()); uint32_t back_edge_block_id = 0; // Update the branching instructions of the out-of-loop predecessors of the // header. Set |back_edge_block_id| to be the id of the back-edge block. ir_context->get_def_use_mgr()->ForEachUse( loop_header->id(), [this, &ir_context, &dominator_analysis, &loop_header, &back_edge_block_id](opt::Instruction* use_inst, uint32_t use_index) { if (dominator_analysis->Dominates(loop_header->GetLabelInst(), use_inst)) { // If |use_inst| is a branch instruction dominated by the header, the // block containing it is the back-edge block. if (use_inst->IsBranch()) { assert(back_edge_block_id == 0 && "There should only be one back-edge block"); back_edge_block_id = ir_context->get_instr_block(use_inst)->id(); } // References to the header inside the loop should not be updated return; } // If |use_inst| is not a branch or merge instruction, it should not be // changed. if (!use_inst->IsBranch() && use_inst->opcode() != spv::Op::OpSelectionMerge && use_inst->opcode() != spv::Op::OpLoopMerge) { return; } // Update the reference. use_inst->SetOperand(use_index, {message_.fresh_id()}); }); assert(back_edge_block_id && "The back-edge block should have been found"); // Make a new block for the preheader. std::unique_ptr preheader = MakeUnique( std::unique_ptr(new opt::Instruction( ir_context, spv::Op::OpLabel, 0, message_.fresh_id(), {}))); uint32_t phi_ids_used = 0; // Update the OpPhi instructions and, if there is more than one out-of-loop // predecessor, add necessary OpPhi instructions so the preheader. loop_header->ForEachPhiInst([this, &ir_context, &preheader, &back_edge_block_id, &phi_ids_used](opt::Instruction* phi_inst) { // The loop header must have at least 2 incoming edges (the back edge, and // at least one from outside the loop). assert(phi_inst->NumInOperands() >= 4); if (phi_inst->NumInOperands() == 4) { // There is just one out-of-loop predecessor, so no additional // instructions in the preheader are necessary. The reference to the // original out-of-loop predecessor needs to be updated so that it refers // to the preheader. uint32_t index_of_out_of_loop_pred_id = phi_inst->GetInOperand(1).words[0] == back_edge_block_id ? 3 : 1; phi_inst->SetInOperand(index_of_out_of_loop_pred_id, {preheader->id()}); } else { // There is more than one out-of-loop predecessor, so an OpPhi instruction // needs to be added to the preheader, and its value will depend on all // the current out-of-loop predecessors of the header. // Get the operand list and the value corresponding to the back-edge // block. std::vector preheader_in_operands; uint32_t back_edge_val = 0; for (uint32_t i = 0; i < phi_inst->NumInOperands(); i += 2) { // Only add operands if they don't refer to the back-edge block. if (phi_inst->GetInOperand(i + 1).words[0] == back_edge_block_id) { back_edge_val = phi_inst->GetInOperand(i).words[0]; } else { preheader_in_operands.push_back(std::move(phi_inst->GetInOperand(i))); preheader_in_operands.push_back( std::move(phi_inst->GetInOperand(i + 1))); } } // Add the new instruction to the preheader. uint32_t fresh_phi_id = message_.phi_id(phi_ids_used++); // Update id bound. fuzzerutil::UpdateModuleIdBound(ir_context, fresh_phi_id); preheader->AddInstruction(std::unique_ptr( new opt::Instruction(ir_context, spv::Op::OpPhi, phi_inst->type_id(), fresh_phi_id, preheader_in_operands))); // Update the OpPhi instruction in the header so that it refers to the // back edge block and the preheader as the predecessors, and it uses the // newly-defined OpPhi in the preheader for the corresponding value. phi_inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {fresh_phi_id}}, {SPV_OPERAND_TYPE_ID, {preheader->id()}}, {SPV_OPERAND_TYPE_ID, {back_edge_val}}, {SPV_OPERAND_TYPE_ID, {back_edge_block_id}}}); } }); // Update id bound. fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id()); // Add an unconditional branch from the preheader to the header. preheader->AddInstruction( std::unique_ptr(new opt::Instruction( ir_context, spv::Op::OpBranch, 0, 0, std::initializer_list{opt::Operand( spv_operand_type_t::SPV_OPERAND_TYPE_ID, {loop_header->id()})}))); // Insert the preheader in the module. loop_header->GetParent()->InsertBasicBlockBefore(std::move(preheader), loop_header); // Invalidate analyses because the structure of the program changed. ir_context->InvalidateAnalysesExceptFor(opt::IRContext::kAnalysisNone); } protobufs::Transformation TransformationAddLoopPreheader::ToMessage() const { protobufs::Transformation result; *result.mutable_add_loop_preheader() = message_; return result; } std::unordered_set TransformationAddLoopPreheader::GetFreshIds() const { std::unordered_set result = {message_.fresh_id()}; for (auto id : message_.phi_id()) { result.insert(id); } return result; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_loop_preheader.h000066400000000000000000000043521475742701700301320ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_ADD_LOOP_PREHEADER_H #define SOURCE_FUZZ_TRANSFORMATION_ADD_LOOP_PREHEADER_H #include "source/fuzz/transformation.h" namespace spvtools { namespace fuzz { class TransformationAddLoopPreheader : public Transformation { public: explicit TransformationAddLoopPreheader( protobufs::TransformationAddLoopPreheader message); TransformationAddLoopPreheader(uint32_t loop_header_block, uint32_t fresh_id, std::vector phi_id); // - |message_.loop_header_block| must be the id of a loop header block in // the given module. // - |message_.fresh_id| must be an available id. // - |message_.phi_ids| must be a list of available ids. // It can be empty if the loop header only has one predecessor outside of // the loop. Otherwise, it must contain at least as many ids as OpPhi // instructions in the loop header block. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Adds a preheader block as the unique out-of-loop predecessor of the given // loop header block. All of the existing out-of-loop predecessors of the // header are changed so that they branch to the preheader instead. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationAddLoopPreheader message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_ADD_LOOP_PREHEADER_H transformation_add_loop_to_create_int_constant_synonym.cpp000066400000000000000000000462121475742701700347740ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/fuzz// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_loop_to_create_int_constant_synonym.h" #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { namespace { uint32_t kMaxNumOfIterations = 32; } TransformationAddLoopToCreateIntConstantSynonym:: TransformationAddLoopToCreateIntConstantSynonym( protobufs::TransformationAddLoopToCreateIntConstantSynonym message) : message_(std::move(message)) {} TransformationAddLoopToCreateIntConstantSynonym:: TransformationAddLoopToCreateIntConstantSynonym( uint32_t constant_id, uint32_t initial_val_id, uint32_t step_val_id, uint32_t num_iterations_id, uint32_t block_after_loop_id, uint32_t syn_id, uint32_t loop_id, uint32_t ctr_id, uint32_t temp_id, uint32_t eventual_syn_id, uint32_t incremented_ctr_id, uint32_t cond_id, uint32_t additional_block_id) { message_.set_constant_id(constant_id); message_.set_initial_val_id(initial_val_id); message_.set_step_val_id(step_val_id); message_.set_num_iterations_id(num_iterations_id); message_.set_block_after_loop_id(block_after_loop_id); message_.set_syn_id(syn_id); message_.set_loop_id(loop_id); message_.set_ctr_id(ctr_id); message_.set_temp_id(temp_id); message_.set_eventual_syn_id(eventual_syn_id); message_.set_incremented_ctr_id(incremented_ctr_id); message_.set_cond_id(cond_id); message_.set_additional_block_id(additional_block_id); } bool TransformationAddLoopToCreateIntConstantSynonym::IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const { // Check that |message_.constant_id|, |message_.initial_val_id| and // |message_.step_val_id| are existing constants, and that their values are // not irrelevant. auto constant = ir_context->get_constant_mgr()->FindDeclaredConstant( message_.constant_id()); auto initial_val = ir_context->get_constant_mgr()->FindDeclaredConstant( message_.initial_val_id()); auto step_val = ir_context->get_constant_mgr()->FindDeclaredConstant( message_.step_val_id()); if (!constant || !initial_val || !step_val) { return false; } if (transformation_context.GetFactManager()->IdIsIrrelevant( message_.constant_id()) || transformation_context.GetFactManager()->IdIsIrrelevant( message_.initial_val_id()) || transformation_context.GetFactManager()->IdIsIrrelevant( message_.step_val_id())) { return false; } // Check that the type of |constant| is integer scalar or vector with integer // components. if (!constant->AsIntConstant() && (!constant->AsVectorConstant() || !constant->type()->AsVector()->element_type()->AsInteger())) { return false; } // Check that the component bit width of |constant| is <= 64. // Consider the width of the constant if it is an integer, of a single // component if it is a vector. uint32_t bit_width = constant->AsIntConstant() ? constant->type()->AsInteger()->width() : constant->type()->AsVector()->element_type()->AsInteger()->width(); if (bit_width > 64) { return false; } auto constant_def = ir_context->get_def_use_mgr()->GetDef(message_.constant_id()); auto initial_val_def = ir_context->get_def_use_mgr()->GetDef(message_.initial_val_id()); auto step_val_def = ir_context->get_def_use_mgr()->GetDef(message_.step_val_id()); // Check that |constant|, |initial_val| and |step_val| have the same type, // with possibly different signedness. if (!fuzzerutil::TypesAreEqualUpToSign(ir_context, constant_def->type_id(), initial_val_def->type_id()) || !fuzzerutil::TypesAreEqualUpToSign(ir_context, constant_def->type_id(), step_val_def->type_id())) { return false; } // |message_.num_iterations_id| must be a non-irrelevant integer constant with // bit width 32. auto num_iterations = ir_context->get_constant_mgr()->FindDeclaredConstant( message_.num_iterations_id()); if (!num_iterations || !num_iterations->AsIntConstant() || num_iterations->type()->AsInteger()->width() != 32 || transformation_context.GetFactManager()->IdIsIrrelevant( message_.num_iterations_id())) { return false; } // Check that the number of iterations is > 0 and <= 32. uint32_t num_iterations_value = num_iterations->AsIntConstant()->GetU32BitValue(); if (num_iterations_value == 0 || num_iterations_value > kMaxNumOfIterations) { return false; } // Check that the module contains 32-bit signed integer scalar constants of // value 0 and 1. if (!fuzzerutil::MaybeGetIntegerConstant(ir_context, transformation_context, {0}, 32, true, false)) { return false; } if (!fuzzerutil::MaybeGetIntegerConstant(ir_context, transformation_context, {1}, 32, true, false)) { return false; } // Check that the module contains the Bool type. if (!fuzzerutil::MaybeGetBoolType(ir_context)) { return false; } // Check that the equation C = I - S * N is satisfied. // Collect the components in vectors (if the constants are scalars, these // vectors will contain the constants themselves). std::vector c_components; std::vector i_components; std::vector s_components; if (constant->AsIntConstant()) { c_components.emplace_back(constant); i_components.emplace_back(initial_val); s_components.emplace_back(step_val); } else { // It is a vector: get all the components. c_components = constant->AsVectorConstant()->GetComponents(); i_components = initial_val->AsVectorConstant()->GetComponents(); s_components = step_val->AsVectorConstant()->GetComponents(); } // Check the value of the components satisfy the equation. for (uint32_t i = 0; i < c_components.size(); i++) { // Use 64-bits integers to be able to handle constants of any width <= 64. uint64_t c_value = c_components[i]->AsIntConstant()->GetZeroExtendedValue(); uint64_t i_value = i_components[i]->AsIntConstant()->GetZeroExtendedValue(); uint64_t s_value = s_components[i]->AsIntConstant()->GetZeroExtendedValue(); uint64_t result = i_value - s_value * num_iterations_value; // Use bit shifts to ignore the first bits in excess (if there are any). By // shifting left, we discard the first |64 - bit_width| bits. By shifting // right, we move the bits back to their correct position. result = (result << (64 - bit_width)) >> (64 - bit_width); if (c_value != result) { return false; } } // Check that |message_.block_after_loop_id| is the label of a block. auto block = fuzzerutil::MaybeFindBlock(ir_context, message_.block_after_loop_id()); // Check that the block exists and has a single predecessor. if (!block || ir_context->cfg()->preds(block->id()).size() != 1) { return false; } // Check that the block is not dead. If it is then the new loop would be // dead and the data it computes would be irrelevant, so we would not be able // to make a synonym. if (transformation_context.GetFactManager()->BlockIsDead(block->id())) { return false; } // Check that the block is not a merge block. if (ir_context->GetStructuredCFGAnalysis()->IsMergeBlock(block->id())) { return false; } // Check that the block is not a continue block. if (ir_context->GetStructuredCFGAnalysis()->IsContinueBlock(block->id())) { return false; } // Check that the block is not a loop header. if (block->IsLoopHeader()) { return false; } // Check all the fresh ids. std::set fresh_ids_used; for (uint32_t id : {message_.syn_id(), message_.loop_id(), message_.ctr_id(), message_.temp_id(), message_.eventual_syn_id(), message_.incremented_ctr_id(), message_.cond_id()}) { if (!id || !CheckIdIsFreshAndNotUsedByThisTransformation(id, ir_context, &fresh_ids_used)) { return false; } } // Check the additional block id if it is non-zero. return !message_.additional_block_id() || CheckIdIsFreshAndNotUsedByThisTransformation( message_.additional_block_id(), ir_context, &fresh_ids_used); } void TransformationAddLoopToCreateIntConstantSynonym::Apply( opt::IRContext* ir_context, TransformationContext* transformation_context) const { // Find 32-bit signed integer constants 0 and 1. uint32_t const_0_id = fuzzerutil::MaybeGetIntegerConstant( ir_context, *transformation_context, {0}, 32, true, false); auto const_0_def = ir_context->get_def_use_mgr()->GetDef(const_0_id); uint32_t const_1_id = fuzzerutil::MaybeGetIntegerConstant( ir_context, *transformation_context, {1}, 32, true, false); // Retrieve the instruction defining the initial value constant. auto initial_val_def = ir_context->get_def_use_mgr()->GetDef(message_.initial_val_id()); // Retrieve the block before which we want to insert the loop. auto block_after_loop = ir_context->get_instr_block(message_.block_after_loop_id()); // Find the predecessor of the block. uint32_t pred_id = ir_context->cfg()->preds(message_.block_after_loop_id())[0]; // Get the id for the last block in the new loop. It will be // |message_.additional_block_id| if this is non_zero, |message_.loop_id| // otherwise. uint32_t last_loop_block_id = message_.additional_block_id() ? message_.additional_block_id() : message_.loop_id(); // Create the loop header block. std::unique_ptr loop_block = MakeUnique(MakeUnique( ir_context, spv::Op::OpLabel, 0, message_.loop_id(), opt::Instruction::OperandList{})); // Add OpPhi instructions to retrieve the current value of the counter and of // the temporary variable that will be decreased at each operation. loop_block->AddInstruction(MakeUnique( ir_context, spv::Op::OpPhi, const_0_def->type_id(), message_.ctr_id(), opt::Instruction::OperandList{ {SPV_OPERAND_TYPE_ID, {const_0_id}}, {SPV_OPERAND_TYPE_ID, {pred_id}}, {SPV_OPERAND_TYPE_ID, {message_.incremented_ctr_id()}}, {SPV_OPERAND_TYPE_ID, {last_loop_block_id}}})); loop_block->AddInstruction(MakeUnique( ir_context, spv::Op::OpPhi, initial_val_def->type_id(), message_.temp_id(), opt::Instruction::OperandList{ {SPV_OPERAND_TYPE_ID, {message_.initial_val_id()}}, {SPV_OPERAND_TYPE_ID, {pred_id}}, {SPV_OPERAND_TYPE_ID, {message_.eventual_syn_id()}}, {SPV_OPERAND_TYPE_ID, {last_loop_block_id}}})); // Collect the other instructions in a list. These will be added to an // additional block if |message_.additional_block_id| is defined, to the loop // header otherwise. std::vector> other_instructions; // Add an instruction to subtract the step value from the temporary value. // The value of this id will converge to the constant in the last iteration. other_instructions.push_back(MakeUnique( ir_context, spv::Op::OpISub, initial_val_def->type_id(), message_.eventual_syn_id(), opt::Instruction::OperandList{ {SPV_OPERAND_TYPE_ID, {message_.temp_id()}}, {SPV_OPERAND_TYPE_ID, {message_.step_val_id()}}})); // Add an instruction to increment the counter. other_instructions.push_back(MakeUnique( ir_context, spv::Op::OpIAdd, const_0_def->type_id(), message_.incremented_ctr_id(), opt::Instruction::OperandList{{SPV_OPERAND_TYPE_ID, {message_.ctr_id()}}, {SPV_OPERAND_TYPE_ID, {const_1_id}}})); // Add an instruction to decide whether the condition holds. other_instructions.push_back(MakeUnique( ir_context, spv::Op::OpSLessThan, fuzzerutil::MaybeGetBoolType(ir_context), message_.cond_id(), opt::Instruction::OperandList{ {SPV_OPERAND_TYPE_ID, {message_.incremented_ctr_id()}}, {SPV_OPERAND_TYPE_ID, {message_.num_iterations_id()}}})); // Define the OpLoopMerge instruction for the loop header. The merge block is // the existing block, the continue block is the last block in the loop // (either the loop itself or the additional block). std::unique_ptr merge_inst = MakeUnique( ir_context, spv::Op::OpLoopMerge, 0, 0, opt::Instruction::OperandList{ {SPV_OPERAND_TYPE_ID, {message_.block_after_loop_id()}}, {SPV_OPERAND_TYPE_ID, {last_loop_block_id}}, {SPV_OPERAND_TYPE_LOOP_CONTROL, {uint32_t(spv::LoopControlMask::MaskNone)}}}); // Define a conditional branch instruction, branching to the loop header if // the condition holds, and to the existing block otherwise. This instruction // will be added to the last block in the loop. std::unique_ptr conditional_branch = MakeUnique( ir_context, spv::Op::OpBranchConditional, 0, 0, opt::Instruction::OperandList{ {SPV_OPERAND_TYPE_ID, {message_.cond_id()}}, {SPV_OPERAND_TYPE_ID, {message_.loop_id()}}, {SPV_OPERAND_TYPE_ID, {message_.block_after_loop_id()}}}); if (message_.additional_block_id()) { // If an id for the additional block is specified, create an additional // block, containing the instructions in the list and a branching // instruction. std::unique_ptr additional_block = MakeUnique(MakeUnique( ir_context, spv::Op::OpLabel, 0, message_.additional_block_id(), opt::Instruction::OperandList{})); for (auto& instruction : other_instructions) { additional_block->AddInstruction(std::move(instruction)); } additional_block->AddInstruction(std::move(conditional_branch)); // Add the merge instruction to the header. loop_block->AddInstruction(std::move(merge_inst)); // Add an unconditional branch from the header to the additional block. loop_block->AddInstruction(MakeUnique( ir_context, spv::Op::OpBranch, 0, 0, opt::Instruction::OperandList{ {SPV_OPERAND_TYPE_ID, {message_.additional_block_id()}}})); // Insert the two loop blocks before the existing block. block_after_loop->GetParent()->InsertBasicBlockBefore(std::move(loop_block), block_after_loop); block_after_loop->GetParent()->InsertBasicBlockBefore( std::move(additional_block), block_after_loop); } else { // If no id for an additional block is specified, the loop will only be made // up of one block, so we need to add all the instructions to it. for (auto& instruction : other_instructions) { loop_block->AddInstruction(std::move(instruction)); } // Add the merge and conditional branch instructions. loop_block->AddInstruction(std::move(merge_inst)); loop_block->AddInstruction(std::move(conditional_branch)); // Insert the header before the existing block. block_after_loop->GetParent()->InsertBasicBlockBefore(std::move(loop_block), block_after_loop); } // Update the branching instructions leading to this block. ir_context->get_def_use_mgr()->ForEachUse( message_.block_after_loop_id(), [this](opt::Instruction* instruction, uint32_t operand_index) { assert(instruction->opcode() != spv::Op::OpLoopMerge && instruction->opcode() != spv::Op::OpSelectionMerge && "The block should not be referenced by OpLoopMerge or " "OpSelectionMerge, by construction."); // Replace all uses of the label inside branch instructions. if (instruction->opcode() == spv::Op::OpBranch || instruction->opcode() == spv::Op::OpBranchConditional || instruction->opcode() == spv::Op::OpSwitch) { instruction->SetOperand(operand_index, {message_.loop_id()}); } }); // Update all the OpPhi instructions in the block after the loop: its // predecessor is now the last block in the loop. block_after_loop->ForEachPhiInst( [last_loop_block_id](opt::Instruction* phi_inst) { // Since the block only had one predecessor, the id of the predecessor // is input operand 1. phi_inst->SetInOperand(1, {last_loop_block_id}); }); // Add a new OpPhi instruction at the beginning of the block after the loop, // defining the synonym of the constant. The type id will be the same as // |message_.initial_value_id|, since this is the value that is decremented in // the loop. block_after_loop->begin()->InsertBefore(MakeUnique( ir_context, spv::Op::OpPhi, initial_val_def->type_id(), message_.syn_id(), opt::Instruction::OperandList{ {SPV_OPERAND_TYPE_ID, {message_.eventual_syn_id()}}, {SPV_OPERAND_TYPE_ID, {last_loop_block_id}}})); // Update the module id bound with all the fresh ids used. for (uint32_t id : {message_.syn_id(), message_.loop_id(), message_.ctr_id(), message_.temp_id(), message_.eventual_syn_id(), message_.incremented_ctr_id(), message_.cond_id(), message_.cond_id(), message_.additional_block_id()}) { fuzzerutil::UpdateModuleIdBound(ir_context, id); } // Since we changed the structure of the module, we need to invalidate all the // analyses. ir_context->InvalidateAnalysesExceptFor(opt::IRContext::kAnalysisNone); // Record that |message_.syn_id| is synonymous with |message_.constant_id|. transformation_context->GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(message_.syn_id(), {}), MakeDataDescriptor(message_.constant_id(), {})); } protobufs::Transformation TransformationAddLoopToCreateIntConstantSynonym::ToMessage() const { protobufs::Transformation result; *result.mutable_add_loop_to_create_int_constant_synonym() = message_; return result; } std::unordered_set TransformationAddLoopToCreateIntConstantSynonym::GetFreshIds() const { return {message_.syn_id(), message_.loop_id(), message_.ctr_id(), message_.temp_id(), message_.eventual_syn_id(), message_.incremented_ctr_id(), message_.cond_id(), message_.additional_block_id()}; } } // namespace fuzz } // namespace spvtools transformation_add_loop_to_create_int_constant_synonym.h000066400000000000000000000060751475742701700344440ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/fuzz// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_ADD_LOOP_TO_CREATE_INT_CONSTANT_SYNONYM_H_ #define SOURCE_FUZZ_TRANSFORMATION_ADD_LOOP_TO_CREATE_INT_CONSTANT_SYNONYM_H_ #include "source/fuzz/transformation.h" namespace spvtools { namespace fuzz { class TransformationAddLoopToCreateIntConstantSynonym : public Transformation { public: explicit TransformationAddLoopToCreateIntConstantSynonym( protobufs::TransformationAddLoopToCreateIntConstantSynonym message); TransformationAddLoopToCreateIntConstantSynonym( uint32_t constant_id, uint32_t initial_val_id, uint32_t step_val_id, uint32_t num_iterations_id, uint32_t block_after_loop_id, uint32_t syn_id, uint32_t loop_id, uint32_t ctr_id, uint32_t temp_id, uint32_t eventual_syn_id, uint32_t incremented_ctr_id, uint32_t cond_id, uint32_t additional_block_id); // - |message_.constant_id|, |message_.initial_value_id|, // |message_.step_val_id| are integer constants (scalar or vectors) with the // same type (with possibly different signedness, but same bit width, which // must be <= 64). Let their value be C, I, S respectively. // - |message_.num_iterations_id| is a 32-bit integer scalar constant, with // value N > 0 and N <= 32. // - The module contains 32-bit signed integer scalar constants of values 0 // and 1. // - The module contains the boolean type. // - C = I - S * N // - |message_.block_after_loop_id| is the label of a block which has a single // predecessor and which is not a merge block, a continue block or a loop // header. // - |message_.block_after_loop_id| must not be a dead block. // - |message_.additional_block_id| is either 0 or a valid fresh id, distinct // from the other fresh ids. // - All of the other parameters are valid fresh ids. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Adds a loop to the module, defining a synonym of an integer (scalar or // vector) constant. This id is marked as synonym with the original constant. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationAddLoopToCreateIntConstantSynonym message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_ADD_LOOP_TO_CREATE_INT_CONSTANT_SYNONYM_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_no_contraction_decoration.cpp000066400000000000000000000073561475742701700327320ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_no_contraction_decoration.h" #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { TransformationAddNoContractionDecoration:: TransformationAddNoContractionDecoration( protobufs::TransformationAddNoContractionDecoration message) : message_(std::move(message)) {} TransformationAddNoContractionDecoration:: TransformationAddNoContractionDecoration(uint32_t result_id) { message_.set_result_id(result_id); } bool TransformationAddNoContractionDecoration::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { // |message_.result_id| must be the id of an instruction. auto instr = ir_context->get_def_use_mgr()->GetDef(message_.result_id()); if (!instr) { return false; } // |instr| must not be decorated with NoContraction. if (ir_context->get_decoration_mgr()->HasDecoration( message_.result_id(), spv::Decoration::NoContraction)) { return false; } // The instruction must be arithmetic. return IsArithmetic(instr->opcode()); } void TransformationAddNoContractionDecoration::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { // Add a NoContraction decoration targeting |message_.result_id|. ir_context->get_decoration_mgr()->AddDecoration( message_.result_id(), uint32_t(spv::Decoration::NoContraction)); } protobufs::Transformation TransformationAddNoContractionDecoration::ToMessage() const { protobufs::Transformation result; *result.mutable_add_no_contraction_decoration() = message_; return result; } bool TransformationAddNoContractionDecoration::IsArithmetic(spv::Op opcode) { switch (opcode) { case spv::Op::OpSNegate: case spv::Op::OpFNegate: case spv::Op::OpIAdd: case spv::Op::OpFAdd: case spv::Op::OpISub: case spv::Op::OpFSub: case spv::Op::OpIMul: case spv::Op::OpFMul: case spv::Op::OpUDiv: case spv::Op::OpSDiv: case spv::Op::OpFDiv: case spv::Op::OpUMod: case spv::Op::OpSRem: case spv::Op::OpSMod: case spv::Op::OpFRem: case spv::Op::OpFMod: case spv::Op::OpVectorTimesScalar: case spv::Op::OpMatrixTimesScalar: case spv::Op::OpVectorTimesMatrix: case spv::Op::OpMatrixTimesVector: case spv::Op::OpMatrixTimesMatrix: case spv::Op::OpOuterProduct: case spv::Op::OpDot: case spv::Op::OpIAddCarry: case spv::Op::OpISubBorrow: case spv::Op::OpUMulExtended: case spv::Op::OpSMulExtended: case spv::Op::OpAny: case spv::Op::OpAll: case spv::Op::OpIsNan: case spv::Op::OpIsInf: case spv::Op::OpIsFinite: case spv::Op::OpIsNormal: case spv::Op::OpSignBitSet: case spv::Op::OpLessOrGreater: case spv::Op::OpOrdered: case spv::Op::OpUnordered: case spv::Op::OpLogicalEqual: case spv::Op::OpLogicalNotEqual: case spv::Op::OpLogicalOr: case spv::Op::OpLogicalAnd: case spv::Op::OpLogicalNot: return true; default: return false; } } std::unordered_set TransformationAddNoContractionDecoration::GetFreshIds() const { return std::unordered_set(); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_no_contraction_decoration.h000066400000000000000000000044161475742701700323710ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_ADD_NO_CONTRACTION_DECORATION_H_ #define SOURCE_FUZZ_TRANSFORMATION_ADD_NO_CONTRACTION_DECORATION_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationAddNoContractionDecoration : public Transformation { public: explicit TransformationAddNoContractionDecoration( protobufs::TransformationAddNoContractionDecoration message); explicit TransformationAddNoContractionDecoration(uint32_t fresh_id); // - |message_.result_id| must be the result id of an arithmetic instruction, // as defined by the SPIR-V specification. // - It does not matter whether this instruction is already annotated with the // NoContraction decoration. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Adds a decoration of the form: // 'OpDecoration |message_.result_id| NoContraction' // to the module. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; // Returns true if and only if |opcode| is the opcode of an arithmetic // instruction, as defined by the SPIR-V specification. static bool IsArithmetic(spv::Op opcode); private: protobufs::TransformationAddNoContractionDecoration message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_ADD_NO_CONTRACTION_DECORATION_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_opphi_synonym.cpp000066400000000000000000000161121475742701700304050ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_opphi_synonym.h" #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { TransformationAddOpPhiSynonym::TransformationAddOpPhiSynonym( protobufs::TransformationAddOpPhiSynonym message) : message_(std::move(message)) {} TransformationAddOpPhiSynonym::TransformationAddOpPhiSynonym( uint32_t block_id, const std::map& preds_to_ids, uint32_t fresh_id) { message_.set_block_id(block_id); *message_.mutable_pred_to_id() = fuzzerutil::MapToRepeatedUInt32Pair(preds_to_ids); message_.set_fresh_id(fresh_id); } bool TransformationAddOpPhiSynonym::IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const { // Check that |message_.block_id| is a block label id, and that it is not // dead. auto block = fuzzerutil::MaybeFindBlock(ir_context, message_.block_id()); if (!block || transformation_context.GetFactManager()->BlockIsDead(block->id())) { return false; } // Check that |message_.fresh_id| is actually fresh. if (!fuzzerutil::IsFreshId(ir_context, message_.fresh_id())) { return false; } // Check that |message_.pred_to_id| contains a mapping for all of the block's // predecessors. std::vector predecessors = ir_context->cfg()->preds(block->id()); // There must be at least one predecessor. if (predecessors.empty()) { return false; } std::map preds_to_ids = fuzzerutil::RepeatedUInt32PairToMap(message_.pred_to_id()); // There must not be repeated key values in |message_.pred_to_id|. if (preds_to_ids.size() != static_cast(message_.pred_to_id_size())) { return false; } // Check that each predecessor has a corresponding mapping and all of the // corresponding ids exist. for (uint32_t pred : predecessors) { if (preds_to_ids.count(pred) == 0) { return false; } // Check that the id exists in the module. if (!ir_context->get_def_use_mgr()->GetDef(preds_to_ids[pred])) { return false; } } // Get the first id and its type (which should be the same as all the other // ones) and check that the transformation supports this type. uint32_t first_id = preds_to_ids[predecessors[0]]; uint32_t type_id = ir_context->get_def_use_mgr()->GetDef(first_id)->type_id(); if (!CheckTypeIsAllowed(ir_context, type_id)) { return false; } // Check that the ids corresponding to predecessors are all synonymous, have // the same type and are available to use at the end of the predecessor. for (uint32_t pred : predecessors) { auto id = preds_to_ids[pred]; // Check that the id has the same type as the other ones. if (ir_context->get_def_use_mgr()->GetDef(id)->type_id() != type_id) { return false; } // Check that the id is synonymous with the others by checking that it is // synonymous with the first one (or it is the same id). if (id != first_id && !transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(id, {}), MakeDataDescriptor(first_id, {}))) { return false; } // Check that the id is available at the end of the corresponding // predecessor block. auto pred_block = ir_context->get_instr_block(pred); // We should always be able to find the predecessor block, since it is in // the predecessors list of |block|. assert(pred_block && "Could not find one of the predecessor blocks."); if (!fuzzerutil::IdIsAvailableBeforeInstruction( ir_context, pred_block->terminator(), id)) { return false; } } return true; } void TransformationAddOpPhiSynonym::Apply( opt::IRContext* ir_context, TransformationContext* transformation_context) const { // Get the type id from one of the ids. uint32_t first_id = message_.pred_to_id(0).second(); uint32_t type_id = ir_context->get_def_use_mgr()->GetDef(first_id)->type_id(); // Define the operand list. opt::Instruction::OperandList operand_list; // For each predecessor, add the corresponding operands. for (auto& pair : message_.pred_to_id()) { operand_list.emplace_back( opt::Operand{SPV_OPERAND_TYPE_ID, {pair.second()}}); operand_list.emplace_back( opt::Operand{SPV_OPERAND_TYPE_ID, {pair.first()}}); } // Add a new OpPhi instructions at the beginning of the block. ir_context->get_instr_block(message_.block_id()) ->begin() .InsertBefore(MakeUnique(ir_context, spv::Op::OpPhi, type_id, message_.fresh_id(), std::move(operand_list))); // Update the module id bound. fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id()); // Invalidate all analyses, since we added an instruction to the module. ir_context->InvalidateAnalysesExceptFor( opt::IRContext::Analysis::kAnalysisNone); // Record the fact that the new id is synonym with the other ones by declaring // that it is a synonym of the first one. transformation_context->GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(message_.fresh_id(), {}), MakeDataDescriptor(first_id, {})); } protobufs::Transformation TransformationAddOpPhiSynonym::ToMessage() const { protobufs::Transformation result; *result.mutable_add_opphi_synonym() = message_; return result; } bool TransformationAddOpPhiSynonym::CheckTypeIsAllowed( opt::IRContext* ir_context, uint32_t type_id) { auto type = ir_context->get_type_mgr()->GetType(type_id); if (!type) { return false; } // We allow the following types: Bool, Integer, Float, Vector, Matrix, Array, // Struct. if (type->AsBool() || type->AsInteger() || type->AsFloat() || type->AsVector() || type->AsMatrix() || type->AsArray() || type->AsStruct()) { return true; } // We allow pointer types if the VariablePointers capability is enabled and // the pointer has the correct storage class (Workgroup or StorageBuffer). if (type->AsPointer()) { auto storage_class = type->AsPointer()->storage_class(); return ir_context->get_feature_mgr()->HasCapability( spv::Capability::VariablePointers) && (storage_class == spv::StorageClass::Workgroup || storage_class == spv::StorageClass::StorageBuffer); } // We do not allow other types. return false; } std::unordered_set TransformationAddOpPhiSynonym::GetFreshIds() const { return {message_.fresh_id()}; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_opphi_synonym.h000066400000000000000000000064401475742701700300550ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_ADD_OPPHI_SYNONYM_H_ #define SOURCE_FUZZ_TRANSFORMATION_ADD_OPPHI_SYNONYM_H_ #include "source/fuzz/transformation.h" namespace spvtools { namespace fuzz { class TransformationAddOpPhiSynonym : public Transformation { public: explicit TransformationAddOpPhiSynonym( protobufs::TransformationAddOpPhiSynonym message); TransformationAddOpPhiSynonym( uint32_t block_id, const std::map& preds_to_ids, uint32_t fresh_id); // - |message_.block_id| is the label of a block with at least one // predecessor. // - |message_.block_id| must not be a dead block. // - |message_.pred_to_id| contains a mapping from each of the predecessors of // the block to an id that is available at the end of the predecessor. // - All the ids corresponding to a predecessor in |message_.pred_to_id|: // - have been recorded as synonymous and all have the same type. // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/3726): if a // predecessor is a dead block, any id of the right type could be used, // even if it is not synonym with the others. // - have one of the following types: Bool, Integer, Float, Vector, Matrix, // Array, Struct. Pointer types are also allowed if the VariablePointers // capability is enabled and the storage class is Workgroup or // StorageBuffer. // - |message_.fresh_id| is a fresh id. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Given a block with n predecessors, with n >= 1, and n corresponding // synonymous ids of the same type, each available to use at the end of the // corresponding predecessor, adds an OpPhi instruction at the beginning of // the block of the form: // %fresh_id = OpPhi %type %id_1 %pred_1 %id_2 %pred_2 ... %id_n %pred_n // This instruction is then marked as synonymous with the ids. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; // Returns true if |type_id| is the id of a type in the module, which is one // of the following: Bool, Integer, Float, Vector, Matrix, Array, Struct. // Pointer types are also allowed if the VariablePointers capability is // enabled and the storage class is Workgroup or StorageBuffer. static bool CheckTypeIsAllowed(opt::IRContext* ir_context, uint32_t type_id); std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationAddOpPhiSynonym message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_ADD_OPPHI_SYNONYM_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_parameter.cpp000066400000000000000000000205111475742701700274500ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_parameter.h" #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { TransformationAddParameter::TransformationAddParameter( protobufs::TransformationAddParameter message) : message_(std::move(message)) {} TransformationAddParameter::TransformationAddParameter( uint32_t function_id, uint32_t parameter_fresh_id, uint32_t parameter_type_id, std::map call_parameter_ids, uint32_t function_type_fresh_id) { message_.set_function_id(function_id); message_.set_parameter_fresh_id(parameter_fresh_id); message_.set_parameter_type_id(parameter_type_id); *message_.mutable_call_parameter_ids() = fuzzerutil::MapToRepeatedUInt32Pair(call_parameter_ids); message_.set_function_type_fresh_id(function_type_fresh_id); } bool TransformationAddParameter::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { // Check that function exists. const auto* function = fuzzerutil::FindFunction(ir_context, message_.function_id()); if (!function || fuzzerutil::FunctionIsEntryPoint(ir_context, function->result_id())) { return false; } // The type must be supported. if (ir_context->get_def_use_mgr()->GetDef(message_.parameter_type_id()) == nullptr) { return false; } if (!IsParameterTypeSupported(ir_context, message_.parameter_type_id())) { return false; } // Iterate over all callers. std::map call_parameter_ids_map = fuzzerutil::RepeatedUInt32PairToMap(message_.call_parameter_ids()); for (auto* instr : fuzzerutil::GetCallers(ir_context, message_.function_id())) { uint32_t caller_id = instr->result_id(); // If there is no entry for this caller, return false. if (call_parameter_ids_map.find(caller_id) == call_parameter_ids_map.end()) { return false; } uint32_t value_id = call_parameter_ids_map[caller_id]; auto value_instr = ir_context->get_def_use_mgr()->GetDef(value_id); if (!value_instr) { return false; } // If the id of the value of the map is not available before the caller, // return false. if (!fuzzerutil::IdIsAvailableBeforeInstruction(ir_context, instr, value_id)) { return false; } // The type of the value must be defined. uint32_t value_type_id = fuzzerutil::GetTypeId(ir_context, value_id); if (!value_type_id) { return false; } // Type of every value of the map must be the same for all callers. if (message_.parameter_type_id() != value_type_id) { return false; } } return fuzzerutil::IsFreshId(ir_context, message_.parameter_fresh_id()) && fuzzerutil::IsFreshId(ir_context, message_.function_type_fresh_id()) && message_.parameter_fresh_id() != message_.function_type_fresh_id(); } void TransformationAddParameter::Apply( opt::IRContext* ir_context, TransformationContext* transformation_context) const { // Find the function that will be transformed. auto* function = fuzzerutil::FindFunction(ir_context, message_.function_id()); assert(function && "Can't find the function"); std::map call_parameter_ids_map = fuzzerutil::RepeatedUInt32PairToMap(message_.call_parameter_ids()); uint32_t new_parameter_type_id = message_.parameter_type_id(); auto new_parameter_type = ir_context->get_type_mgr()->GetType(new_parameter_type_id); assert(new_parameter_type && "New parameter has invalid type."); // Add new parameters to the function. function->AddParameter(MakeUnique( ir_context, spv::Op::OpFunctionParameter, new_parameter_type_id, message_.parameter_fresh_id(), opt::Instruction::OperandList())); fuzzerutil::UpdateModuleIdBound(ir_context, message_.parameter_fresh_id()); // Fix all OpFunctionCall instructions. for (auto* inst : fuzzerutil::GetCallers(ir_context, function->result_id())) { inst->AddOperand( {SPV_OPERAND_TYPE_ID, {call_parameter_ids_map[inst->result_id()]}}); } // Update function's type. { // We use a separate scope here since |old_function_type| might become a // dangling pointer after the call to the fuzzerutil::UpdateFunctionType. const auto* old_function_type = fuzzerutil::GetFunctionType(ir_context, function); assert(old_function_type && "Function must have a valid type"); std::vector parameter_type_ids; for (uint32_t i = 1; i < old_function_type->NumInOperands(); ++i) { parameter_type_ids.push_back( old_function_type->GetSingleWordInOperand(i)); } parameter_type_ids.push_back(new_parameter_type_id); fuzzerutil::UpdateFunctionType( ir_context, function->result_id(), message_.function_type_fresh_id(), old_function_type->GetSingleWordInOperand(0), parameter_type_ids); } auto new_parameter_kind = new_parameter_type->kind(); // Make sure our changes are analyzed. ir_context->InvalidateAnalysesExceptFor( opt::IRContext::Analysis::kAnalysisNone); // If the |new_parameter_type_id| is not a pointer type, mark id as // irrelevant so that we can replace its use with some other id. If the // |new_parameter_type_id| is a pointer type, we cannot mark it with // IdIsIrrelevant, because this pointer might be replaced by a pointer from // original shader. This would change the semantics of the module. In the case // of a pointer type we mark it with PointeeValueIsIrrelevant. if (new_parameter_kind != opt::analysis::Type::kPointer) { transformation_context->GetFactManager()->AddFactIdIsIrrelevant( message_.parameter_fresh_id()); } else { transformation_context->GetFactManager()->AddFactValueOfPointeeIsIrrelevant( message_.parameter_fresh_id()); } } protobufs::Transformation TransformationAddParameter::ToMessage() const { protobufs::Transformation result; *result.mutable_add_parameter() = message_; return result; } bool TransformationAddParameter::IsParameterTypeSupported( opt::IRContext* ir_context, uint32_t type_id) { // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/3403): // Think about other type instructions we can add here. opt::Instruction* type_inst = ir_context->get_def_use_mgr()->GetDef(type_id); switch (type_inst->opcode()) { case spv::Op::OpTypeBool: case spv::Op::OpTypeInt: case spv::Op::OpTypeFloat: case spv::Op::OpTypeMatrix: case spv::Op::OpTypeVector: return true; case spv::Op::OpTypeArray: return IsParameterTypeSupported(ir_context, type_inst->GetSingleWordInOperand(0)); case spv::Op::OpTypeStruct: if (fuzzerutil::HasBlockOrBufferBlockDecoration(ir_context, type_id)) { return false; } for (uint32_t i = 0; i < type_inst->NumInOperands(); i++) { if (!IsParameterTypeSupported(ir_context, type_inst->GetSingleWordInOperand(i))) { return false; } } return true; case spv::Op::OpTypePointer: { spv::StorageClass storage_class = static_cast(type_inst->GetSingleWordInOperand(0)); switch (storage_class) { case spv::StorageClass::Private: case spv::StorageClass::Function: case spv::StorageClass::Workgroup: { return IsParameterTypeSupported(ir_context, type_inst->GetSingleWordInOperand(1)); } default: return false; } } default: return false; } } std::unordered_set TransformationAddParameter::GetFreshIds() const { return {message_.parameter_fresh_id(), message_.function_type_fresh_id()}; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_parameter.h000066400000000000000000000060101475742701700271130ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_ADD_PARAMETER_H_ #define SOURCE_FUZZ_TRANSFORMATION_ADD_PARAMETER_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationAddParameter : public Transformation { public: explicit TransformationAddParameter( protobufs::TransformationAddParameter message); TransformationAddParameter(uint32_t function_id, uint32_t parameter_fresh_id, uint32_t parameter_type_id, std::map call_parameter_ids, uint32_t function_type_fresh_id); // - |function_id| must be a valid result id of some non-entry-point function // in the module. // - |parameter_type_id| is a type id of the new parameter. The type must be // supported by this transformation as specified by IsParameterTypeSupported // function. // - |call_parameter_id| must map from every id of an OpFunctionCall // instruction of this function to the id that will be passed as the new // parameter at that call site. There could be no callers, therefore this // map can be empty. // - |parameter_fresh_id| and |function_type_fresh_id| are fresh ids and are // not equal. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // - Creates a new OpFunctionParameter instruction with result id // |parameter_fresh_id| for the function with |function_id|. // - Adjusts function's type to include a new parameter. // - Adds an argument to every caller of the function to account for the added // parameter. The argument is the value in |call_parameter_id| map. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; // Returns true if the type of the parameter is supported by this // transformation. static bool IsParameterTypeSupported(opt::IRContext* ir_context, uint32_t type_id); private: protobufs::TransformationAddParameter message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_ADD_PARAMETER_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_relaxed_decoration.cpp000066400000000000000000000117051475742701700313300ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_relaxed_decoration.h" #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { TransformationAddRelaxedDecoration::TransformationAddRelaxedDecoration( protobufs::TransformationAddRelaxedDecoration message) : message_(std::move(message)) {} TransformationAddRelaxedDecoration::TransformationAddRelaxedDecoration( uint32_t result_id) { message_.set_result_id(result_id); } bool TransformationAddRelaxedDecoration::IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const { // |message_.result_id| must be the id of an instruction. auto instr = ir_context->get_def_use_mgr()->GetDef(message_.result_id()); if (!instr) { return false; } // |instr| must not be decorated with RelaxedPrecision. if (ir_context->get_decoration_mgr()->HasDecoration( message_.result_id(), spv::Decoration::RelaxedPrecision)) { return false; } opt::BasicBlock* cur_block = ir_context->get_instr_block(instr); // The instruction must have a block. if (cur_block == nullptr) { return false; } // |cur_block| must be a dead block. if (!(transformation_context.GetFactManager()->BlockIsDead( cur_block->id()))) { return false; } // The instruction must be numeric. return IsNumeric(instr->opcode()); } void TransformationAddRelaxedDecoration::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { // Add a RelaxedPrecision decoration targeting |message_.result_id|. ir_context->get_decoration_mgr()->AddDecoration( message_.result_id(), uint32_t(spv::Decoration::RelaxedPrecision)); } protobufs::Transformation TransformationAddRelaxedDecoration::ToMessage() const { protobufs::Transformation result; *result.mutable_add_relaxed_decoration() = message_; return result; } bool TransformationAddRelaxedDecoration::IsNumeric(spv::Op opcode) { switch (opcode) { case spv::Op::OpConvertFToU: case spv::Op::OpConvertFToS: case spv::Op::OpConvertSToF: case spv::Op::OpConvertUToF: case spv::Op::OpUConvert: case spv::Op::OpSConvert: case spv::Op::OpFConvert: case spv::Op::OpConvertPtrToU: case spv::Op::OpSatConvertSToU: case spv::Op::OpSatConvertUToS: case spv::Op::OpVectorExtractDynamic: case spv::Op::OpVectorInsertDynamic: case spv::Op::OpVectorShuffle: case spv::Op::OpTranspose: case spv::Op::OpSNegate: case spv::Op::OpFNegate: case spv::Op::OpIAdd: case spv::Op::OpFAdd: case spv::Op::OpISub: case spv::Op::OpFSub: case spv::Op::OpIMul: case spv::Op::OpFMul: case spv::Op::OpUDiv: case spv::Op::OpSDiv: case spv::Op::OpFDiv: case spv::Op::OpUMod: case spv::Op::OpSRem: case spv::Op::OpSMod: case spv::Op::OpFRem: case spv::Op::OpFMod: case spv::Op::OpVectorTimesScalar: case spv::Op::OpMatrixTimesScalar: case spv::Op::OpVectorTimesMatrix: case spv::Op::OpMatrixTimesVector: case spv::Op::OpMatrixTimesMatrix: case spv::Op::OpOuterProduct: case spv::Op::OpDot: case spv::Op::OpIAddCarry: case spv::Op::OpISubBorrow: case spv::Op::OpUMulExtended: case spv::Op::OpSMulExtended: case spv::Op::OpShiftRightLogical: case spv::Op::OpShiftRightArithmetic: case spv::Op::OpShiftLeftLogical: case spv::Op::OpBitwiseOr: case spv::Op::OpBitwiseXor: case spv::Op::OpBitwiseAnd: case spv::Op::OpNot: case spv::Op::OpBitFieldInsert: case spv::Op::OpBitFieldSExtract: case spv::Op::OpBitFieldUExtract: case spv::Op::OpBitReverse: case spv::Op::OpBitCount: case spv::Op::OpAtomicLoad: case spv::Op::OpAtomicStore: case spv::Op::OpAtomicExchange: case spv::Op::OpAtomicCompareExchange: case spv::Op::OpAtomicCompareExchangeWeak: case spv::Op::OpAtomicIIncrement: case spv::Op::OpAtomicIDecrement: case spv::Op::OpAtomicIAdd: case spv::Op::OpAtomicISub: case spv::Op::OpAtomicSMin: case spv::Op::OpAtomicUMin: case spv::Op::OpAtomicSMax: case spv::Op::OpAtomicUMax: case spv::Op::OpAtomicAnd: case spv::Op::OpAtomicOr: case spv::Op::OpAtomicXor: return true; default: return false; } } std::unordered_set TransformationAddRelaxedDecoration::GetFreshIds() const { return std::unordered_set(); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_relaxed_decoration.h000066400000000000000000000044271475742701700310000ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_ADD_RELAXED_DECORATION_H_ #define SOURCE_FUZZ_TRANSFORMATION_ADD_RELAXED_DECORATION_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationAddRelaxedDecoration : public Transformation { public: explicit TransformationAddRelaxedDecoration( protobufs::TransformationAddRelaxedDecoration message); explicit TransformationAddRelaxedDecoration(uint32_t fresh_id); // - |message_.result_id| must be the result id of an instruction, which is // located in a dead block and Relaxed decoration can be applied. // - It does not matter whether this instruction is already annotated with the // Relaxed decoration. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Adds a decoration of the form: // 'OpDecoration |message_.result_id| RelaxedPrecision' // to the module. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; // Returns true if and only if |opcode| is the opcode of an instruction // that operates on 32-bit integers and 32-bit floats // as defined by the SPIR-V specification. static bool IsNumeric(spv::Op opcode); private: protobufs::TransformationAddRelaxedDecoration message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_ADD_RELAXED_DECORATION_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_spec_constant_op.cpp000066400000000000000000000061721475742701700310400ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_spec_constant_op.h" #include #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { TransformationAddSpecConstantOp::TransformationAddSpecConstantOp( spvtools::fuzz::protobufs::TransformationAddSpecConstantOp message) : message_(std::move(message)) {} TransformationAddSpecConstantOp::TransformationAddSpecConstantOp( uint32_t fresh_id, uint32_t type_id, spv::Op opcode, const opt::Instruction::OperandList& operands) { message_.set_fresh_id(fresh_id); message_.set_type_id(type_id); message_.set_opcode(uint32_t(opcode)); for (const auto& operand : operands) { auto* op = message_.add_operand(); op->set_operand_type(operand.type); for (auto word : operand.words) { op->add_operand_data(word); } } } bool TransformationAddSpecConstantOp::IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const { auto clone = fuzzerutil::CloneIRContext(ir_context); ApplyImpl(clone.get()); return fuzzerutil::IsValid(clone.get(), transformation_context.GetValidatorOptions(), fuzzerutil::kSilentMessageConsumer); } void TransformationAddSpecConstantOp::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { ApplyImpl(ir_context); ir_context->InvalidateAnalysesExceptFor( opt::IRContext::Analysis::kAnalysisNone); } void TransformationAddSpecConstantOp::ApplyImpl( opt::IRContext* ir_context) const { opt::Instruction::OperandList operands = { {SPV_OPERAND_TYPE_SPEC_CONSTANT_OP_NUMBER, {message_.opcode()}}}; for (const auto& operand : message_.operand()) { std::vector words(operand.operand_data().begin(), operand.operand_data().end()); operands.push_back({static_cast(operand.operand_type()), std::move(words)}); } ir_context->AddGlobalValue(MakeUnique( ir_context, spv::Op::OpSpecConstantOp, message_.type_id(), message_.fresh_id(), std::move(operands))); fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id()); } protobufs::Transformation TransformationAddSpecConstantOp::ToMessage() const { protobufs::Transformation result; *result.mutable_add_spec_constant_op() = message_; return result; } std::unordered_set TransformationAddSpecConstantOp::GetFreshIds() const { return {message_.fresh_id()}; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_spec_constant_op.h000066400000000000000000000043311475742701700305000ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_ADD_SPEC_CONSTANT_OP_H_ #define SOURCE_FUZZ_TRANSFORMATION_ADD_SPEC_CONSTANT_OP_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationAddSpecConstantOp : public Transformation { public: explicit TransformationAddSpecConstantOp( protobufs::TransformationAddSpecConstantOp message); TransformationAddSpecConstantOp( uint32_t fresh_id, uint32_t type_id, spv::Op opcode, const opt::Instruction::OperandList& operands); // - |fresh_id| is a fresh result id in the module. // - |type_id| is a valid result id of some OpType* instruction in the // module. It is also a valid type id with respect to |opcode|. // - |opcode| is one of the opcodes supported by OpSpecConstantOp. // - |operands| are valid with respect to |opcode| bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // |%fresh_id = OpSpecConstantOp %type_id opcode operands...| is added to the // module. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: void ApplyImpl(opt::IRContext* ir_context) const; protobufs::TransformationAddSpecConstantOp message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_ADD_SPEC_CONSTANT_OP_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_synonym.cpp000066400000000000000000000312421475742701700272070ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_synonym.h" #include #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" namespace spvtools { namespace fuzz { TransformationAddSynonym::TransformationAddSynonym( protobufs::TransformationAddSynonym message) : message_(std::move(message)) {} TransformationAddSynonym::TransformationAddSynonym( uint32_t result_id, protobufs::TransformationAddSynonym::SynonymType synonym_type, uint32_t synonym_fresh_id, const protobufs::InstructionDescriptor& insert_before) { message_.set_result_id(result_id); message_.set_synonym_type(synonym_type); message_.set_synonym_fresh_id(synonym_fresh_id); *message_.mutable_insert_before() = insert_before; } bool TransformationAddSynonym::IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const { assert(protobufs::TransformationAddSynonym::SynonymType_IsValid( message_.synonym_type()) && "Synonym type is invalid"); // |synonym_fresh_id| must be fresh. if (!fuzzerutil::IsFreshId(ir_context, message_.synonym_fresh_id())) { return false; } // Check that |message_.result_id| is valid. auto* synonym = ir_context->get_def_use_mgr()->GetDef(message_.result_id()); if (!synonym) { return false; } // Check that we can apply |synonym_type| to |result_id|. if (!IsInstructionValid(ir_context, transformation_context, synonym, message_.synonym_type())) { return false; } // Check that |insert_before| is valid. auto* insert_before_inst = FindInstruction(message_.insert_before(), ir_context); if (!insert_before_inst) { return false; } const auto* insert_before_inst_block = ir_context->get_instr_block(insert_before_inst); assert(insert_before_inst_block && "|insert_before_inst| must be in some block"); if (transformation_context.GetFactManager()->BlockIsDead( insert_before_inst_block->id())) { // We don't create synonyms in dead blocks. return false; } // Check that we can insert |message._synonymous_instruction| before // |message_.insert_before| instruction. We use OpIAdd to represent some // instruction that can produce a synonym. if (!fuzzerutil::CanInsertOpcodeBeforeInstruction(spv::Op::OpIAdd, insert_before_inst)) { return false; } // A constant instruction must be present in the module if required. if (IsAdditionalConstantRequired(message_.synonym_type()) && MaybeGetConstantId(ir_context, transformation_context) == 0) { return false; } // Domination rules must be satisfied. return fuzzerutil::IdIsAvailableBeforeInstruction( ir_context, insert_before_inst, message_.result_id()); } void TransformationAddSynonym::Apply( opt::IRContext* ir_context, TransformationContext* transformation_context) const { // Add a synonymous instruction. auto new_instruction = MakeSynonymousInstruction(ir_context, *transformation_context); auto new_instruction_ptr = new_instruction.get(); auto insert_before = FindInstruction(message_.insert_before(), ir_context); insert_before->InsertBefore(std::move(new_instruction)); fuzzerutil::UpdateModuleIdBound(ir_context, message_.synonym_fresh_id()); // Inform the def-use manager about the new instruction and record its basic // block. ir_context->get_def_use_mgr()->AnalyzeInstDefUse(new_instruction_ptr); ir_context->set_instr_block(new_instruction_ptr, ir_context->get_instr_block(insert_before)); // Propagate PointeeValueIsIrrelevant fact. const auto* new_synonym_type = ir_context->get_type_mgr()->GetType( fuzzerutil::GetTypeId(ir_context, message_.synonym_fresh_id())); assert(new_synonym_type && "New synonym should have a valid type"); if (transformation_context->GetFactManager()->PointeeValueIsIrrelevant( message_.result_id()) && new_synonym_type->AsPointer()) { transformation_context->GetFactManager()->AddFactValueOfPointeeIsIrrelevant( message_.synonym_fresh_id()); } // Mark two ids as synonymous. transformation_context->GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(message_.result_id(), {}), MakeDataDescriptor(message_.synonym_fresh_id(), {})); } protobufs::Transformation TransformationAddSynonym::ToMessage() const { protobufs::Transformation result; *result.mutable_add_synonym() = message_; return result; } bool TransformationAddSynonym::IsInstructionValid( opt::IRContext* ir_context, const TransformationContext& transformation_context, opt::Instruction* inst, protobufs::TransformationAddSynonym::SynonymType synonym_type) { // Instruction must have a result id, type id. We skip OpUndef and // OpConstantNull. if (!inst || !inst->result_id() || !inst->type_id() || inst->opcode() == spv::Op::OpUndef || inst->opcode() == spv::Op::OpConstantNull) { return false; } if (!fuzzerutil::CanMakeSynonymOf(ir_context, transformation_context, *inst)) { return false; } switch (synonym_type) { case protobufs::TransformationAddSynonym::ADD_ZERO: case protobufs::TransformationAddSynonym::SUB_ZERO: case protobufs::TransformationAddSynonym::MUL_ONE: { // The instruction must be either scalar or vector of integers or floats. const auto* type = ir_context->get_type_mgr()->GetType(inst->type_id()); assert(type && "Instruction's result id is invalid"); if (const auto* vector = type->AsVector()) { return vector->element_type()->AsInteger() || vector->element_type()->AsFloat(); } return type->AsInteger() || type->AsFloat(); } case protobufs::TransformationAddSynonym::BITWISE_OR: case protobufs::TransformationAddSynonym::BITWISE_XOR: { // The instruction must be either an integer or a vector of integers. const auto* type = ir_context->get_type_mgr()->GetType(inst->type_id()); assert(type && "Instruction's result id is invalid"); if (const auto* vector = type->AsVector()) { return vector->element_type()->AsInteger(); } return type->AsInteger(); } case protobufs::TransformationAddSynonym::COPY_OBJECT: // All checks for OpCopyObject are handled by // fuzzerutil::CanMakeSynonymOf. return true; case protobufs::TransformationAddSynonym::LOGICAL_AND: case protobufs::TransformationAddSynonym::LOGICAL_OR: { // The instruction must be either a scalar or a vector of booleans. const auto* type = ir_context->get_type_mgr()->GetType(inst->type_id()); assert(type && "Instruction's result id is invalid"); return (type->AsVector() && type->AsVector()->element_type()->AsBool()) || type->AsBool(); } default: assert(false && "Synonym type is not supported"); return false; } } std::unique_ptr TransformationAddSynonym::MakeSynonymousInstruction( opt::IRContext* ir_context, const TransformationContext& transformation_context) const { auto synonym_type_id = fuzzerutil::GetTypeId(ir_context, message_.result_id()); assert(synonym_type_id && "Synonym has invalid type id"); auto opcode = spv::Op::OpNop; const auto* synonym_type = ir_context->get_type_mgr()->GetType(synonym_type_id); assert(synonym_type && "Synonym has invalid type"); auto is_integral = (synonym_type->AsVector() && synonym_type->AsVector()->element_type()->AsInteger()) || synonym_type->AsInteger(); switch (message_.synonym_type()) { case protobufs::TransformationAddSynonym::SUB_ZERO: opcode = is_integral ? spv::Op::OpISub : spv::Op::OpFSub; break; case protobufs::TransformationAddSynonym::MUL_ONE: opcode = is_integral ? spv::Op::OpIMul : spv::Op::OpFMul; break; case protobufs::TransformationAddSynonym::ADD_ZERO: opcode = is_integral ? spv::Op::OpIAdd : spv::Op::OpFAdd; break; case protobufs::TransformationAddSynonym::LOGICAL_OR: opcode = spv::Op::OpLogicalOr; break; case protobufs::TransformationAddSynonym::LOGICAL_AND: opcode = spv::Op::OpLogicalAnd; break; case protobufs::TransformationAddSynonym::BITWISE_OR: opcode = spv::Op::OpBitwiseOr; break; case protobufs::TransformationAddSynonym::BITWISE_XOR: opcode = spv::Op::OpBitwiseXor; break; case protobufs::TransformationAddSynonym::COPY_OBJECT: return MakeUnique( ir_context, spv::Op::OpCopyObject, synonym_type_id, message_.synonym_fresh_id(), opt::Instruction::OperandList{ {SPV_OPERAND_TYPE_ID, {message_.result_id()}}}); default: assert(false && "Unhandled synonym type"); return nullptr; } return MakeUnique( ir_context, opcode, synonym_type_id, message_.synonym_fresh_id(), opt::Instruction::OperandList{ {SPV_OPERAND_TYPE_ID, {message_.result_id()}}, {SPV_OPERAND_TYPE_ID, {MaybeGetConstantId(ir_context, transformation_context)}}}); } uint32_t TransformationAddSynonym::MaybeGetConstantId( opt::IRContext* ir_context, const TransformationContext& transformation_context) const { assert(IsAdditionalConstantRequired(message_.synonym_type()) && "Synonym type doesn't require an additional constant"); auto synonym_type_id = fuzzerutil::GetTypeId(ir_context, message_.result_id()); assert(synonym_type_id && "Synonym has invalid type id"); switch (message_.synonym_type()) { case protobufs::TransformationAddSynonym::ADD_ZERO: case protobufs::TransformationAddSynonym::SUB_ZERO: case protobufs::TransformationAddSynonym::LOGICAL_OR: case protobufs::TransformationAddSynonym::BITWISE_OR: case protobufs::TransformationAddSynonym::BITWISE_XOR: return fuzzerutil::MaybeGetZeroConstant( ir_context, transformation_context, synonym_type_id, false); case protobufs::TransformationAddSynonym::MUL_ONE: case protobufs::TransformationAddSynonym::LOGICAL_AND: { auto synonym_type = ir_context->get_type_mgr()->GetType(synonym_type_id); assert(synonym_type && "Synonym has invalid type"); if (const auto* vector = synonym_type->AsVector()) { auto element_type_id = ir_context->get_type_mgr()->GetId(vector->element_type()); assert(element_type_id && "Vector's element type is invalid"); auto one_word = vector->element_type()->AsFloat() ? fuzzerutil::FloatToWord(1) : 1u; if (auto scalar_one_id = fuzzerutil::MaybeGetScalarConstant( ir_context, transformation_context, {one_word}, element_type_id, false)) { return fuzzerutil::MaybeGetCompositeConstant( ir_context, transformation_context, std::vector(vector->element_count(), scalar_one_id), synonym_type_id, false); } return 0; } else { return fuzzerutil::MaybeGetScalarConstant( ir_context, transformation_context, {synonym_type->AsFloat() ? fuzzerutil::FloatToWord(1) : 1u}, synonym_type_id, false); } } default: // The assertion at the beginning of the function will fail in the debug // mode. return 0; } } bool TransformationAddSynonym::IsAdditionalConstantRequired( protobufs::TransformationAddSynonym::SynonymType synonym_type) { switch (synonym_type) { case protobufs::TransformationAddSynonym::ADD_ZERO: case protobufs::TransformationAddSynonym::SUB_ZERO: case protobufs::TransformationAddSynonym::LOGICAL_OR: case protobufs::TransformationAddSynonym::MUL_ONE: case protobufs::TransformationAddSynonym::LOGICAL_AND: case protobufs::TransformationAddSynonym::BITWISE_OR: case protobufs::TransformationAddSynonym::BITWISE_XOR: return true; default: return false; } } std::unordered_set TransformationAddSynonym::GetFreshIds() const { return {message_.synonym_fresh_id()}; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_synonym.h000066400000000000000000000073371475742701700266640ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_ADD_SYNONYM_H_ #define SOURCE_FUZZ_TRANSFORMATION_ADD_SYNONYM_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationAddSynonym : public Transformation { public: explicit TransformationAddSynonym( protobufs::TransformationAddSynonym message); TransformationAddSynonym( uint32_t result_id, protobufs::TransformationAddSynonym::SynonymType synonym_type, uint32_t synonym_fresh_id, const protobufs::InstructionDescriptor& insert_before); // - |result_id| must be a valid result id of some instruction in the module. // - |result_id| may not be an irrelevant id. // - |synonym_type| is a type of the synonymous instruction that will be // created. // - |synonym_fresh_id| is a fresh id. // - |insert_before| must be a valid instruction descriptor and we must be // able to insert a new synonymous instruction before |insert_before|. // - |result_id| must be available before |insert_before|. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Creates a new synonymous instruction according to the |synonym_type| with // result id |synonym_fresh_id|. // Inserts that instruction before |insert_before| and creates a fact // that the |synonym_fresh_id| and the |result_id| are synonymous. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; // Returns true if we can create a synonym of |inst| according to the // |synonym_type|. static bool IsInstructionValid( opt::IRContext* ir_context, const TransformationContext& transformation_context, opt::Instruction* inst, protobufs::TransformationAddSynonym::SynonymType synonym_type); // Returns true if |synonym_type| requires an additional constant instruction // to be present in the module. static bool IsAdditionalConstantRequired( protobufs::TransformationAddSynonym::SynonymType synonym_type); private: // Returns a new instruction which is synonymous to |message_.result_id|. std::unique_ptr MakeSynonymousInstruction( opt::IRContext* ir_context, const TransformationContext& transformation_context) const; // Returns a result id of a constant instruction that is required to be // present in some synonym types (e.g. returns a result id of a zero constant // for ADD_ZERO synonym type). Returns 0 if no such instruction is present in // the module. This method should only be called when // IsAdditionalConstantRequired returns true. uint32_t MaybeGetConstantId( opt::IRContext* ir_context, const TransformationContext& transformation_context) const; protobufs::TransformationAddSynonym message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_ADD_SYNONYM_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_type_array.cpp000066400000000000000000000074011475742701700276520ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_type_array.h" #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { TransformationAddTypeArray::TransformationAddTypeArray( protobufs::TransformationAddTypeArray message) : message_(std::move(message)) {} TransformationAddTypeArray::TransformationAddTypeArray(uint32_t fresh_id, uint32_t element_type_id, uint32_t size_id) { message_.set_fresh_id(fresh_id); message_.set_element_type_id(element_type_id); message_.set_size_id(size_id); } bool TransformationAddTypeArray::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { // A fresh id is required. if (!fuzzerutil::IsFreshId(ir_context, message_.fresh_id())) { return false; } auto element_type = ir_context->get_type_mgr()->GetType(message_.element_type_id()); if (!element_type || element_type->AsFunction() || fuzzerutil::HasBlockOrBufferBlockDecoration(ir_context, message_.element_type_id())) { // The element type id either does not refer to a type, refers to a function // type, or refers to a block-decorated struct. These cases are all illegal. return false; } auto constant = ir_context->get_constant_mgr()->GetConstantsFromIds({message_.size_id()}); if (constant.empty()) { // The size id does not refer to a constant. return false; } assert(constant.size() == 1 && "Only one constant id was provided, so only one constant should have " "been returned"); auto int_constant = constant[0]->AsIntConstant(); if (!int_constant) { // The size constant is not an integer. return false; } // We require that the size constant be a 32-bit value that is positive when // interpreted as being signed. return int_constant->words().size() == 1 && int_constant->GetS32() >= 1; } void TransformationAddTypeArray::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { opt::Instruction::OperandList in_operands; in_operands.push_back({SPV_OPERAND_TYPE_ID, {message_.element_type_id()}}); in_operands.push_back({SPV_OPERAND_TYPE_ID, {message_.size_id()}}); auto type_instruction = MakeUnique( ir_context, spv::Op::OpTypeArray, 0, message_.fresh_id(), in_operands); auto type_instruction_ptr = type_instruction.get(); ir_context->module()->AddType(std::move(type_instruction)); fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id()); // Inform the def use manager that there is a new definition. Invalidate the // type manager since we have added a new type. ir_context->get_def_use_mgr()->AnalyzeInstDef(type_instruction_ptr); ir_context->InvalidateAnalyses(opt::IRContext::kAnalysisTypes); } protobufs::Transformation TransformationAddTypeArray::ToMessage() const { protobufs::Transformation result; *result.mutable_add_type_array() = message_; return result; } std::unordered_set TransformationAddTypeArray::GetFreshIds() const { return {message_.fresh_id()}; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_type_array.h000066400000000000000000000044251475742701700273220ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_ADD_TYPE_ARRAY_H_ #define SOURCE_FUZZ_TRANSFORMATION_ADD_TYPE_ARRAY_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationAddTypeArray : public Transformation { public: explicit TransformationAddTypeArray( protobufs::TransformationAddTypeArray message); TransformationAddTypeArray(uint32_t fresh_id, uint32_t element_type_id, uint32_t size_id); // - |message_.fresh_id| must be fresh // - |message_.element_type_id| must be the id of a non-function type // - |message_.member_type_id| must not be the result id of an OpTypeStruct // instruction that has the Block or BufferBlock decoration // - |message_.size_id| must be the id of a 32-bit integer constant that is // positive when interpreted as signed bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Adds an OpTypeArray instruction to the module, with element type given by // |message_.element_type_id| and size given by |message_.size_id|. The // result id of the instruction is |message_.fresh_id|. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationAddTypeArray message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_ADD_TYPE_ARRAY_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_type_boolean.cpp000066400000000000000000000047171475742701700301620ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_type_boolean.h" #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { TransformationAddTypeBoolean::TransformationAddTypeBoolean( protobufs::TransformationAddTypeBoolean message) : message_(std::move(message)) {} TransformationAddTypeBoolean::TransformationAddTypeBoolean(uint32_t fresh_id) { message_.set_fresh_id(fresh_id); } bool TransformationAddTypeBoolean::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { // The id must be fresh. if (!fuzzerutil::IsFreshId(ir_context, message_.fresh_id())) { return false; } // Applicable if there is no bool type already declared in the module. opt::analysis::Bool bool_type; return ir_context->get_type_mgr()->GetId(&bool_type) == 0; } void TransformationAddTypeBoolean::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { opt::Instruction::OperandList empty_operands; auto type_instruction = MakeUnique( ir_context, spv::Op::OpTypeBool, 0, message_.fresh_id(), empty_operands); auto type_instruction_ptr = type_instruction.get(); ir_context->module()->AddType(std::move(type_instruction)); fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id()); // Inform the def use manager that there is a new definition. Invalidate the // type manager since we have added a new type. ir_context->get_def_use_mgr()->AnalyzeInstDef(type_instruction_ptr); ir_context->InvalidateAnalyses(opt::IRContext::kAnalysisTypes); } protobufs::Transformation TransformationAddTypeBoolean::ToMessage() const { protobufs::Transformation result; *result.mutable_add_type_boolean() = message_; return result; } std::unordered_set TransformationAddTypeBoolean::GetFreshIds() const { return {message_.fresh_id()}; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_type_boolean.h000066400000000000000000000034301475742701700276160ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_ADD_TYPE_BOOLEAN_H_ #define SOURCE_FUZZ_TRANSFORMATION_ADD_TYPE_BOOLEAN_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationAddTypeBoolean : public Transformation { public: explicit TransformationAddTypeBoolean( protobufs::TransformationAddTypeBoolean message); explicit TransformationAddTypeBoolean(uint32_t fresh_id); // - |message_.fresh_id| must not be used by the module. // - The module must not yet declare OpTypeBoolean bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Adds OpTypeBoolean with |message_.fresh_id| as result id. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationAddTypeBoolean message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_ADD_TYPE_BOOLEAN_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_type_float.cpp000066400000000000000000000063061475742701700276440ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_type_float.h" #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { TransformationAddTypeFloat::TransformationAddTypeFloat(uint32_t fresh_id, uint32_t width) { message_.set_fresh_id(fresh_id); message_.set_width(width); } TransformationAddTypeFloat::TransformationAddTypeFloat( protobufs::TransformationAddTypeFloat message) : message_(std::move(message)) {} bool TransformationAddTypeFloat::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { // The id must be fresh. if (!fuzzerutil::IsFreshId(ir_context, message_.fresh_id())) { return false; } // Checks float type width capabilities. switch (message_.width()) { case 16: // The Float16 capability must be present. if (!ir_context->get_feature_mgr()->HasCapability( spv::Capability::Float16)) { return false; } break; case 32: // No capabilities needed. break; case 64: // The Float64 capability must be present. if (!ir_context->get_feature_mgr()->HasCapability( spv::Capability::Float64)) { return false; } break; default: assert(false && "Unexpected float type width"); return false; } // Applicable if there is no float type with this width already declared in // the module. return fuzzerutil::MaybeGetFloatType(ir_context, message_.width()) == 0; } void TransformationAddTypeFloat::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { auto type_instruction = MakeUnique( ir_context, spv::Op::OpTypeFloat, 0, message_.fresh_id(), opt::Instruction::OperandList{ {SPV_OPERAND_TYPE_LITERAL_INTEGER, {message_.width()}}}); auto type_instruction_ptr = type_instruction.get(); ir_context->module()->AddType(std::move(type_instruction)); fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id()); // Inform the def use manager that there is a new definition, and invalidate // the type manager since we have added a new type. ir_context->get_def_use_mgr()->AnalyzeInstDef(type_instruction_ptr); ir_context->InvalidateAnalyses(opt::IRContext::kAnalysisTypes); } protobufs::Transformation TransformationAddTypeFloat::ToMessage() const { protobufs::Transformation result; *result.mutable_add_type_float() = message_; return result; } std::unordered_set TransformationAddTypeFloat::GetFreshIds() const { return {message_.fresh_id()}; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_type_float.h000066400000000000000000000035631475742701700273130ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_ADD_TYPE_FLOAT_H_ #define SOURCE_FUZZ_TRANSFORMATION_ADD_TYPE_FLOAT_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationAddTypeFloat : public Transformation { public: explicit TransformationAddTypeFloat( protobufs::TransformationAddTypeFloat message); TransformationAddTypeFloat(uint32_t fresh_id, uint32_t width); // - |message_.fresh_id| must not be used by the module // - The module must not contain an OpTypeFloat instruction with width // |message_.width| bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Adds an OpTypeFloat instruction to the module with the given width void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationAddTypeFloat message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_ADD_TYPE_FLOAT_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_type_function.cpp000066400000000000000000000064251475742701700303660ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_type_function.h" #include #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { TransformationAddTypeFunction::TransformationAddTypeFunction( protobufs::TransformationAddTypeFunction message) : message_(std::move(message)) {} TransformationAddTypeFunction::TransformationAddTypeFunction( uint32_t fresh_id, uint32_t return_type_id, const std::vector& argument_type_ids) { message_.set_fresh_id(fresh_id); message_.set_return_type_id(return_type_id); for (auto id : argument_type_ids) { message_.add_argument_type_id(id); } } bool TransformationAddTypeFunction::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { // The result id must be fresh. if (!fuzzerutil::IsFreshId(ir_context, message_.fresh_id())) { return false; } // The return and argument types must be type ids but not not be function // type ids. if (!fuzzerutil::IsNonFunctionTypeId(ir_context, message_.return_type_id())) { return false; } for (auto argument_type_id : message_.argument_type_id()) { if (!fuzzerutil::IsNonFunctionTypeId(ir_context, argument_type_id)) { return false; } } // Check whether there is already an OpTypeFunction definition that uses // exactly the same return and argument type ids. (Note that the type manager // does not allow us to check this, as it does not distinguish between // function types with different but isomorphic pointer argument types.) std::vector type_ids = {message_.return_type_id()}; type_ids.insert(type_ids.end(), message_.argument_type_id().begin(), message_.argument_type_id().end()); return fuzzerutil::FindFunctionType(ir_context, type_ids) == 0; } void TransformationAddTypeFunction::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { std::vector type_ids = {message_.return_type_id()}; type_ids.insert(type_ids.end(), message_.argument_type_id().begin(), message_.argument_type_id().end()); fuzzerutil::AddFunctionType(ir_context, message_.fresh_id(), type_ids); // We have added an instruction to the module, so need to be careful about the // validity of existing analyses. ir_context->InvalidateAnalysesExceptFor( opt::IRContext::Analysis::kAnalysisNone); } protobufs::Transformation TransformationAddTypeFunction::ToMessage() const { protobufs::Transformation result; *result.mutable_add_type_function() = message_; return result; } std::unordered_set TransformationAddTypeFunction::GetFreshIds() const { return {message_.fresh_id()}; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_type_function.h000066400000000000000000000045061475742701700300310ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_ADD_TYPE_FUNCTION_H_ #define SOURCE_FUZZ_TRANSFORMATION_ADD_TYPE_FUNCTION_H_ #include #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationAddTypeFunction : public Transformation { public: explicit TransformationAddTypeFunction( protobufs::TransformationAddTypeFunction message); TransformationAddTypeFunction(uint32_t fresh_id, uint32_t return_type_id, const std::vector& argument_type_ids); // - |message_.fresh_id| must not be used by the module // - |message_.return_type_id| and each element of |message_.argument_type_id| // must be the ids of non-function types // - The module must not contain an OpTypeFunction instruction defining a // function type with the signature provided by the given return and // argument types bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Adds an OpTypeFunction instruction to the module, with signature given by // |message_.return_type_id| and |message_.argument_type_id|. The result id // for the instruction is |message_.fresh_id|. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationAddTypeFunction message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_ADD_TYPE_FUNCTION_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_type_int.cpp000066400000000000000000000072321475742701700273300ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_type_int.h" #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { TransformationAddTypeInt::TransformationAddTypeInt( protobufs::TransformationAddTypeInt message) : message_(std::move(message)) {} TransformationAddTypeInt::TransformationAddTypeInt(uint32_t fresh_id, uint32_t width, bool is_signed) { message_.set_fresh_id(fresh_id); message_.set_width(width); message_.set_is_signed(is_signed); } bool TransformationAddTypeInt::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { // The id must be fresh. if (!fuzzerutil::IsFreshId(ir_context, message_.fresh_id())) { return false; } // Checks integer type width capabilities. switch (message_.width()) { case 8: // The Int8 capability must be present. if (!ir_context->get_feature_mgr()->HasCapability( spv::Capability::Int8)) { return false; } break; case 16: // The Int16 capability must be present. if (!ir_context->get_feature_mgr()->HasCapability( spv::Capability::Int16)) { return false; } break; case 32: // No capabilities needed. break; case 64: // The Int64 capability must be present. if (!ir_context->get_feature_mgr()->HasCapability( spv::Capability::Int64)) { return false; } break; default: assert(false && "Unexpected integer type width"); return false; } // Applicable if there is no int type with this width and signedness already // declared in the module. return fuzzerutil::MaybeGetIntegerType(ir_context, message_.width(), message_.is_signed()) == 0; } void TransformationAddTypeInt::Apply(opt::IRContext* ir_context, TransformationContext* /*unused*/) const { auto type_instruction = MakeUnique( ir_context, spv::Op::OpTypeInt, 0, message_.fresh_id(), opt::Instruction::OperandList{ {SPV_OPERAND_TYPE_LITERAL_INTEGER, {message_.width()}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {message_.is_signed() ? 1u : 0u}}}); auto type_instruction_ptr = type_instruction.get(); ir_context->module()->AddType(std::move(type_instruction)); fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id()); // Inform the def use manager that there is a new definition. Invalidate the // type manager since we have added a new type. ir_context->get_def_use_mgr()->AnalyzeInstDef(type_instruction_ptr); ir_context->InvalidateAnalyses(opt::IRContext::kAnalysisTypes); } protobufs::Transformation TransformationAddTypeInt::ToMessage() const { protobufs::Transformation result; *result.mutable_add_type_int() = message_; return result; } std::unordered_set TransformationAddTypeInt::GetFreshIds() const { return {message_.fresh_id()}; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_type_int.h000066400000000000000000000036471475742701700270030ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_ADD_TYPE_INT_H_ #define SOURCE_FUZZ_TRANSFORMATION_ADD_TYPE_INT_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationAddTypeInt : public Transformation { public: explicit TransformationAddTypeInt( protobufs::TransformationAddTypeInt message); TransformationAddTypeInt(uint32_t fresh_id, uint32_t width, bool is_signed); // - |message_.fresh_id| must not be used by the module // - The module must not contain an OpTypeInt instruction with width // |message_.width| and signedness |message.is_signed| bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Adds an OpTypeInt instruction to the module with the given width and // signedness. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationAddTypeInt message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_ADD_TYPE_INT_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_type_matrix.cpp000066400000000000000000000055541475742701700300470ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_type_matrix.h" #include "fuzzer_util.h" namespace spvtools { namespace fuzz { TransformationAddTypeMatrix::TransformationAddTypeMatrix( protobufs::TransformationAddTypeMatrix message) : message_(std::move(message)) {} TransformationAddTypeMatrix::TransformationAddTypeMatrix( uint32_t fresh_id, uint32_t column_type_id, uint32_t column_count) { message_.set_fresh_id(fresh_id); message_.set_column_type_id(column_type_id); message_.set_column_count(column_count); } bool TransformationAddTypeMatrix::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { // The result id must be fresh. if (!fuzzerutil::IsFreshId(ir_context, message_.fresh_id())) { return false; } // The column type must be a floating-point vector. auto column_type = ir_context->get_type_mgr()->GetType(message_.column_type_id()); if (!column_type) { return false; } return column_type->AsVector() && column_type->AsVector()->element_type()->AsFloat(); } void TransformationAddTypeMatrix::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { opt::Instruction::OperandList in_operands; in_operands.push_back({SPV_OPERAND_TYPE_ID, {message_.column_type_id()}}); in_operands.push_back( {SPV_OPERAND_TYPE_LITERAL_INTEGER, {message_.column_count()}}); auto type_instruction = MakeUnique( ir_context, spv::Op::OpTypeMatrix, 0, message_.fresh_id(), in_operands); auto type_instruction_ptr = type_instruction.get(); ir_context->module()->AddType(std::move(type_instruction)); fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id()); // Inform the def use manager that there is a new definition. Invalidate the // type manager since we have added a new type. ir_context->get_def_use_mgr()->AnalyzeInstDef(type_instruction_ptr); ir_context->InvalidateAnalyses(opt::IRContext::kAnalysisTypes); } protobufs::Transformation TransformationAddTypeMatrix::ToMessage() const { protobufs::Transformation result; *result.mutable_add_type_matrix() = message_; return result; } std::unordered_set TransformationAddTypeMatrix::GetFreshIds() const { return {message_.fresh_id()}; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_type_matrix.h000066400000000000000000000040071475742701700275040ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_ADD_TYPE_MATRIX_H_ #define SOURCE_FUZZ_TRANSFORMATION_ADD_TYPE_MATRIX_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationAddTypeMatrix : public Transformation { public: explicit TransformationAddTypeMatrix( protobufs::TransformationAddTypeMatrix message); TransformationAddTypeMatrix(uint32_t fresh_id, uint32_t column_type_id, uint32_t column_count); // - |message_.fresh_id| must be a fresh id // - |message_.column_type_id| must be the id of a floating-point vector type bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Adds an OpTypeMatrix instruction to the module, with column type // |message_.column_type_id| and |message_.column_count| columns, with result // id |message_.fresh_id|. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationAddTypeMatrix message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_ADD_TYPE_MATRIX_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_type_pointer.cpp000066400000000000000000000053331475742701700302160ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_type_pointer.h" #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { TransformationAddTypePointer::TransformationAddTypePointer( protobufs::TransformationAddTypePointer message) : message_(std::move(message)) {} TransformationAddTypePointer::TransformationAddTypePointer( uint32_t fresh_id, spv::StorageClass storage_class, uint32_t base_type_id) { message_.set_fresh_id(fresh_id); message_.set_storage_class(uint32_t(storage_class)); message_.set_base_type_id(base_type_id); } bool TransformationAddTypePointer::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { // The id must be fresh. if (!fuzzerutil::IsFreshId(ir_context, message_.fresh_id())) { return false; } // The base type must be known. return ir_context->get_type_mgr()->GetType(message_.base_type_id()) != nullptr; } void TransformationAddTypePointer::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { // Add the pointer type. opt::Instruction::OperandList in_operands = { {SPV_OPERAND_TYPE_STORAGE_CLASS, {message_.storage_class()}}, {SPV_OPERAND_TYPE_ID, {message_.base_type_id()}}}; auto type_instruction = MakeUnique( ir_context, spv::Op::OpTypePointer, 0, message_.fresh_id(), in_operands); auto type_instruction_ptr = type_instruction.get(); ir_context->module()->AddType(std::move(type_instruction)); fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id()); // Inform the def use manager that there is a new definition. Invalidate the // type manager since we have added a new type. ir_context->get_def_use_mgr()->AnalyzeInstDef(type_instruction_ptr); ir_context->InvalidateAnalyses(opt::IRContext::kAnalysisTypes); } protobufs::Transformation TransformationAddTypePointer::ToMessage() const { protobufs::Transformation result; *result.mutable_add_type_pointer() = message_; return result; } std::unordered_set TransformationAddTypePointer::GetFreshIds() const { return {message_.fresh_id()}; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_type_pointer.h000066400000000000000000000037761475742701700276740ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_ADD_TYPE_POINTER_H_ #define SOURCE_FUZZ_TRANSFORMATION_ADD_TYPE_POINTER_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationAddTypePointer : public Transformation { public: explicit TransformationAddTypePointer( protobufs::TransformationAddTypePointer message); TransformationAddTypePointer(uint32_t fresh_id, spv::StorageClass storage_class, uint32_t base_type_id); // - |message_.fresh_id| must not be used by the module // - |message_.base_type_id| must be the result id of an OpType[...] // instruction bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Adds an OpTypePointer instruction with the given storage class and base // type to the module. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationAddTypePointer message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_ADD_TYPE_POINTER_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_type_struct.cpp000066400000000000000000000076661475742701700300750ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_type_struct.h" #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { TransformationAddTypeStruct::TransformationAddTypeStruct( protobufs::TransformationAddTypeStruct message) : message_(std::move(message)) {} TransformationAddTypeStruct::TransformationAddTypeStruct( uint32_t fresh_id, const std::vector& member_type_ids) { message_.set_fresh_id(fresh_id); for (auto member_type_id : member_type_ids) { message_.add_member_type_id(member_type_id); } } bool TransformationAddTypeStruct::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { // A fresh id is required. if (!fuzzerutil::IsFreshId(ir_context, message_.fresh_id())) { return false; } for (auto member_type : message_.member_type_id()) { auto type = ir_context->get_type_mgr()->GetType(member_type); if (!type || type->AsFunction() || fuzzerutil::HasBlockOrBufferBlockDecoration(ir_context, member_type)) { // The member type id either does not refer to a type, refers to a // function type, or refers to a block-decorated struct. These cases are // all illegal. return false; } // From the spec for the BuiltIn decoration: // - When applied to a structure-type member, that structure type cannot // be contained as a member of another structure type. if (type->AsStruct() && fuzzerutil::MembersHaveBuiltInDecoration(ir_context, member_type)) { return false; } } return true; } void TransformationAddTypeStruct::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { opt::Instruction::OperandList operands; operands.reserve(message_.member_type_id().size()); for (auto type_id : message_.member_type_id()) { const auto* type = ir_context->get_type_mgr()->GetType(type_id); (void)type; // Make compiler happy in release mode. assert(type && !type->AsFunction() && "Component's type id is invalid"); if (type->AsStruct()) { // From the spec for the BuiltIn decoration: // - When applied to a structure-type member, that structure type cannot // be contained as a member of another structure type. assert(!fuzzerutil::MembersHaveBuiltInDecoration(ir_context, type_id) && "A member struct has BuiltIn members"); } operands.push_back({SPV_OPERAND_TYPE_ID, {type_id}}); } auto type_instruction = MakeUnique(ir_context, spv::Op::OpTypeStruct, 0, message_.fresh_id(), std::move(operands)); auto type_instruction_ptr = type_instruction.get(); ir_context->AddType(std::move(type_instruction)); fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id()); // Inform the def use manager that there is a new definition. Invalidate the // type manager since we have added a new type. ir_context->get_def_use_mgr()->AnalyzeInstDef(type_instruction_ptr); ir_context->InvalidateAnalyses(opt::IRContext::kAnalysisTypes); } protobufs::Transformation TransformationAddTypeStruct::ToMessage() const { protobufs::Transformation result; *result.mutable_add_type_struct() = message_; return result; } std::unordered_set TransformationAddTypeStruct::GetFreshIds() const { return {message_.fresh_id()}; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_type_struct.h000066400000000000000000000045251475742701700275310ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_ADD_TYPE_STRUCT_H_ #define SOURCE_FUZZ_TRANSFORMATION_ADD_TYPE_STRUCT_H_ #include #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationAddTypeStruct : public Transformation { public: explicit TransformationAddTypeStruct( protobufs::TransformationAddTypeStruct message); TransformationAddTypeStruct(uint32_t fresh_id, const std::vector& component_type_ids); // - |message_.fresh_id| must be a fresh id // - |message_.member_type_id| must be a sequence of non-function type ids // - |message_.member_type_id| may not contain a result id of an OpTypeStruct // instruction with BuiltIn members (i.e. members of the struct are // decorated via OpMemberDecorate with BuiltIn decoration) // - |message_.member_type_id| may not contain a result id of an OpTypeStruct // instruction that has the Block or BufferBlock decoration bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Adds an OpTypeStruct instruction whose field types are given by // |message_.member_type_id|, with result id |message_.fresh_id|. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationAddTypeStruct message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_ADD_TYPE_STRUCT_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_type_vector.cpp000066400000000000000000000063641475742701700300450ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_type_vector.h" #include "fuzzer_util.h" namespace spvtools { namespace fuzz { TransformationAddTypeVector::TransformationAddTypeVector( protobufs::TransformationAddTypeVector message) : message_(std::move(message)) {} TransformationAddTypeVector::TransformationAddTypeVector( uint32_t fresh_id, uint32_t component_type_id, uint32_t component_count) { message_.set_fresh_id(fresh_id); message_.set_component_type_id(component_type_id); message_.set_component_count(component_count); } bool TransformationAddTypeVector::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { if (!fuzzerutil::IsFreshId(ir_context, message_.fresh_id())) { return false; } auto component_type = ir_context->get_type_mgr()->GetType(message_.component_type_id()); if (!component_type) { return false; } return component_type->AsBool() || component_type->AsFloat() || component_type->AsInteger(); } void TransformationAddTypeVector::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { const auto* component_type = ir_context->get_type_mgr()->GetType(message_.component_type_id()); (void)component_type; // Make compiler happy in release mode. assert(component_type && (component_type->AsInteger() || component_type->AsFloat() || component_type->AsBool()) && "|component_type_id| is invalid"); assert(message_.component_count() >= 2 && message_.component_count() <= 4 && "Precondition: component count must be in range [2, 4]."); auto type_instruction = MakeUnique( ir_context, spv::Op::OpTypeVector, 0, message_.fresh_id(), opt::Instruction::OperandList{ {SPV_OPERAND_TYPE_ID, {message_.component_type_id()}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {message_.component_count()}}}); auto type_instruction_ptr = type_instruction.get(); ir_context->module()->AddType(std::move(type_instruction)); fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id()); // Inform the def use manager that there is a new definition. Invalidate the // type manager since we have added a new type. ir_context->get_def_use_mgr()->AnalyzeInstDef(type_instruction_ptr); ir_context->InvalidateAnalyses(opt::IRContext::kAnalysisTypes); } protobufs::Transformation TransformationAddTypeVector::ToMessage() const { protobufs::Transformation result; *result.mutable_add_type_vector() = message_; return result; } std::unordered_set TransformationAddTypeVector::GetFreshIds() const { return {message_.fresh_id()}; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_add_type_vector.h000066400000000000000000000040151475742701700275010ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_ADD_TYPE_VECTOR_H_ #define SOURCE_FUZZ_TRANSFORMATION_ADD_TYPE_VECTOR_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationAddTypeVector : public Transformation { public: explicit TransformationAddTypeVector( protobufs::TransformationAddTypeVector message); TransformationAddTypeVector(uint32_t fresh_id, uint32_t component_type_id, uint32_t component_count); // - |message_.fresh_id| must be a fresh id // - |message_.component_type_id| must be the id of a scalar type bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Adds an OpTypeVector instruction to the module, with component type // |message_.component_type_id| and |message_.component_count| components, // with result id |message_.fresh_id|. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationAddTypeVector message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_ADD_TYPE_VECTOR_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_adjust_branch_weights.cpp000066400000000000000000000071651475742701700312330ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_adjust_branch_weights.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" namespace spvtools { namespace fuzz { namespace { const uint32_t kBranchWeightForTrueLabelIndex = 3; const uint32_t kBranchWeightForFalseLabelIndex = 4; } // namespace TransformationAdjustBranchWeights::TransformationAdjustBranchWeights( protobufs::TransformationAdjustBranchWeights message) : message_(std::move(message)) {} TransformationAdjustBranchWeights::TransformationAdjustBranchWeights( const protobufs::InstructionDescriptor& instruction_descriptor, const std::pair& branch_weights) { *message_.mutable_instruction_descriptor() = instruction_descriptor; message_.mutable_branch_weights()->set_first(branch_weights.first); message_.mutable_branch_weights()->set_second(branch_weights.second); } bool TransformationAdjustBranchWeights::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { auto instruction = FindInstruction(message_.instruction_descriptor(), ir_context); if (instruction == nullptr) { return false; } spv::Op opcode = static_cast( message_.instruction_descriptor().target_instruction_opcode()); assert(instruction->opcode() == opcode && "The located instruction must have the same opcode as in the " "descriptor."); // Must be an OpBranchConditional instruction. if (opcode != spv::Op::OpBranchConditional) { return false; } assert((message_.branch_weights().first() != 0 || message_.branch_weights().second() != 0) && "At least one weight must be non-zero."); assert(message_.branch_weights().first() <= UINT32_MAX - message_.branch_weights().second() && "The sum of the two weights must not be greater than UINT32_MAX."); return true; } void TransformationAdjustBranchWeights::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { auto instruction = FindInstruction(message_.instruction_descriptor(), ir_context); if (instruction->HasBranchWeights()) { instruction->SetOperand(kBranchWeightForTrueLabelIndex, {message_.branch_weights().first()}); instruction->SetOperand(kBranchWeightForFalseLabelIndex, {message_.branch_weights().second()}); } else { instruction->AddOperand({SPV_OPERAND_TYPE_OPTIONAL_LITERAL_INTEGER, {message_.branch_weights().first()}}); instruction->AddOperand({SPV_OPERAND_TYPE_OPTIONAL_LITERAL_INTEGER, {message_.branch_weights().second()}}); } } protobufs::Transformation TransformationAdjustBranchWeights::ToMessage() const { protobufs::Transformation result; *result.mutable_adjust_branch_weights() = message_; return result; } std::unordered_set TransformationAdjustBranchWeights::GetFreshIds() const { return std::unordered_set(); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_adjust_branch_weights.h000066400000000000000000000041711475742701700306720ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_ADJUST_BRANCH_WEIGHTS_H_ #define SOURCE_FUZZ_TRANSFORMATION_ADJUST_BRANCH_WEIGHTS_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationAdjustBranchWeights : public Transformation { public: explicit TransformationAdjustBranchWeights( protobufs::TransformationAdjustBranchWeights message); TransformationAdjustBranchWeights( const protobufs::InstructionDescriptor& instruction_descriptor, const std::pair& branch_weights); // - |message_.instruction_descriptor| must identify an existing // branch conditional instruction // - At least one of |branch_weights| must be non-zero and // the two weights must not overflow a 32-bit unsigned integer when added // together bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Adjust the branch weights of a branch conditional instruction. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationAdjustBranchWeights message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_ADJUST_BRANCH_WEIGHTS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_composite_construct.cpp000066400000000000000000000326101475742701700307710ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_composite_construct.h" #include "source/fuzz/data_descriptor.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "source/opt/instruction.h" namespace spvtools { namespace fuzz { TransformationCompositeConstruct::TransformationCompositeConstruct( protobufs::TransformationCompositeConstruct message) : message_(std::move(message)) {} TransformationCompositeConstruct::TransformationCompositeConstruct( uint32_t composite_type_id, std::vector component, const protobufs::InstructionDescriptor& instruction_to_insert_before, uint32_t fresh_id) { message_.set_composite_type_id(composite_type_id); for (auto a_component : component) { message_.add_component(a_component); } *message_.mutable_instruction_to_insert_before() = instruction_to_insert_before; message_.set_fresh_id(fresh_id); } bool TransformationCompositeConstruct::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { if (!fuzzerutil::IsFreshId(ir_context, message_.fresh_id())) { // We require the id for the composite constructor to be unused. return false; } auto insert_before = FindInstruction(message_.instruction_to_insert_before(), ir_context); if (!insert_before) { // The instruction before which the composite should be inserted was not // found. return false; } auto composite_type = ir_context->get_type_mgr()->GetType(message_.composite_type_id()); if (!fuzzerutil::IsCompositeType(composite_type)) { // The type must actually be a composite. return false; } // If the type is an array, matrix, struct or vector, the components need to // be suitable for constructing something of that type. if (composite_type->AsArray() && !ComponentsForArrayConstructionAreOK(ir_context, *composite_type->AsArray())) { return false; } if (composite_type->AsMatrix() && !ComponentsForMatrixConstructionAreOK(ir_context, *composite_type->AsMatrix())) { return false; } if (composite_type->AsStruct() && !ComponentsForStructConstructionAreOK(ir_context, *composite_type->AsStruct())) { return false; } if (composite_type->AsVector() && !ComponentsForVectorConstructionAreOK(ir_context, *composite_type->AsVector())) { return false; } // Now check whether every component being used to initialize the composite is // available at the desired program point. for (auto component : message_.component()) { auto* inst = ir_context->get_def_use_mgr()->GetDef(component); if (!inst) { return false; } if (!fuzzerutil::IdIsAvailableBeforeInstruction(ir_context, insert_before, component)) { return false; } } return true; } void TransformationCompositeConstruct::Apply( opt::IRContext* ir_context, TransformationContext* transformation_context) const { // Use the base and offset information from the transformation to determine // where in the module a new instruction should be inserted. auto insert_before_inst = FindInstruction(message_.instruction_to_insert_before(), ir_context); auto destination_block = ir_context->get_instr_block(insert_before_inst); auto insert_before = fuzzerutil::GetIteratorForInstruction( destination_block, insert_before_inst); // Prepare the input operands for an OpCompositeConstruct instruction. opt::Instruction::OperandList in_operands; for (auto& component_id : message_.component()) { in_operands.push_back({SPV_OPERAND_TYPE_ID, {component_id}}); } // Insert an OpCompositeConstruct instruction. auto new_instruction = MakeUnique( ir_context, spv::Op::OpCompositeConstruct, message_.composite_type_id(), message_.fresh_id(), in_operands); auto new_instruction_ptr = new_instruction.get(); insert_before.InsertBefore(std::move(new_instruction)); ir_context->get_def_use_mgr()->AnalyzeInstDefUse(new_instruction_ptr); ir_context->set_instr_block(new_instruction_ptr, destination_block); fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id()); // No analyses need to be invalidated since the transformation is local to a // block and the def-use and instruction-to-block mappings have been updated. AddDataSynonymFacts(ir_context, transformation_context); } bool TransformationCompositeConstruct::ComponentsForArrayConstructionAreOK( opt::IRContext* ir_context, const opt::analysis::Array& array_type) const { if (array_type.length_info().words[0] != opt::analysis::Array::LengthInfo::kConstant) { // We only handle constant-sized arrays. return false; } if (array_type.length_info().words.size() != 2) { // We only handle the case where the array size can be captured in a single // word. return false; } // Get the array size. auto array_size = array_type.length_info().words[1]; if (static_cast(message_.component().size()) != array_size) { // The number of components must match the array size. return false; } // Check that each component is the result id of an instruction whose type is // the array's element type. for (auto component_id : message_.component()) { auto inst = ir_context->get_def_use_mgr()->GetDef(component_id); if (inst == nullptr || !inst->type_id()) { // The component does not correspond to an instruction with a result // type. return false; } auto component_type = ir_context->get_type_mgr()->GetType(inst->type_id()); assert(component_type); if (component_type != array_type.element_type()) { // The component's type does not match the array's element type. return false; } } return true; } bool TransformationCompositeConstruct::ComponentsForMatrixConstructionAreOK( opt::IRContext* ir_context, const opt::analysis::Matrix& matrix_type) const { if (static_cast(message_.component().size()) != matrix_type.element_count()) { // The number of components must match the number of columns of the matrix. return false; } // Check that each component is the result id of an instruction whose type is // the matrix's column type. for (auto component_id : message_.component()) { auto inst = ir_context->get_def_use_mgr()->GetDef(component_id); if (inst == nullptr || !inst->type_id()) { // The component does not correspond to an instruction with a result // type. return false; } auto component_type = ir_context->get_type_mgr()->GetType(inst->type_id()); assert(component_type); if (component_type != matrix_type.element_type()) { // The component's type does not match the matrix's column type. return false; } } return true; } bool TransformationCompositeConstruct::ComponentsForStructConstructionAreOK( opt::IRContext* ir_context, const opt::analysis::Struct& struct_type) const { if (static_cast(message_.component().size()) != struct_type.element_types().size()) { // The number of components must match the number of fields of the struct. return false; } // Check that each component is the result id of an instruction those type // matches the associated field type. for (uint32_t field_index = 0; field_index < struct_type.element_types().size(); field_index++) { auto inst = ir_context->get_def_use_mgr()->GetDef( message_.component()[field_index]); if (inst == nullptr || !inst->type_id()) { // The component does not correspond to an instruction with a result // type. return false; } auto component_type = ir_context->get_type_mgr()->GetType(inst->type_id()); assert(component_type); if (component_type != struct_type.element_types()[field_index]) { // The component's type does not match the corresponding field type. return false; } } return true; } bool TransformationCompositeConstruct::ComponentsForVectorConstructionAreOK( opt::IRContext* ir_context, const opt::analysis::Vector& vector_type) const { uint32_t base_element_count = 0; auto element_type = vector_type.element_type(); for (auto& component_id : message_.component()) { auto inst = ir_context->get_def_use_mgr()->GetDef(component_id); if (inst == nullptr || !inst->type_id()) { // The component does not correspond to an instruction with a result // type. return false; } auto component_type = ir_context->get_type_mgr()->GetType(inst->type_id()); assert(component_type); if (component_type == element_type) { base_element_count++; } else if (component_type->AsVector() && component_type->AsVector()->element_type() == element_type) { base_element_count += component_type->AsVector()->element_count(); } else { // The component was not appropriate; e.g. no type corresponding to the // given id was found, or the type that was found was not compatible // with the vector being constructed. return false; } } // The number of components provided (when vector components are flattened // out) needs to match the length of the vector being constructed. return base_element_count == vector_type.element_count(); } protobufs::Transformation TransformationCompositeConstruct::ToMessage() const { protobufs::Transformation result; *result.mutable_composite_construct() = message_; return result; } std::unordered_set TransformationCompositeConstruct::GetFreshIds() const { return {message_.fresh_id()}; } void TransformationCompositeConstruct::AddDataSynonymFacts( opt::IRContext* ir_context, TransformationContext* transformation_context) const { // If the result id of the composite we are constructing is irrelevant (e.g. // because it is in a dead block) then we do not make any synonyms. if (transformation_context->GetFactManager()->IdIsIrrelevant( message_.fresh_id())) { return; } // Inform the fact manager that we now have new synonyms: every component of // the composite is synonymous with the id used to construct that component // (so long as it is legitimate to create a synonym from that id), except in // the case of a vector where a single vector id can span multiple components. auto composite_type = ir_context->get_type_mgr()->GetType(message_.composite_type_id()); uint32_t index = 0; for (auto component : message_.component()) { auto component_type = ir_context->get_type_mgr()->GetType( ir_context->get_def_use_mgr()->GetDef(component)->type_id()); // Whether the component is a vector being packed into a vector determines // how we should keep track of the indices associated with components. const bool packing_vector_into_vector = composite_type->AsVector() && component_type->AsVector(); if (!fuzzerutil::CanMakeSynonymOf( ir_context, *transformation_context, *ir_context->get_def_use_mgr()->GetDef(component))) { // We can't make a synonym of this component, so we skip on to the next // component. In the case where we're packing a vector into a vector we // have to skip as many components of the resulting vectors as there are // elements of the component vector. index += packing_vector_into_vector ? component_type->AsVector()->element_count() : 1; continue; } if (packing_vector_into_vector) { // The case where the composite being constructed is a vector and the // component provided for construction is also a vector is special. It // requires adding a synonym fact relating each element of the sub-vector // to the corresponding element of the composite being constructed. assert(component_type->AsVector()->element_type() == composite_type->AsVector()->element_type()); assert(component_type->AsVector()->element_count() < composite_type->AsVector()->element_count()); for (uint32_t subvector_index = 0; subvector_index < component_type->AsVector()->element_count(); subvector_index++) { transformation_context->GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(component, {subvector_index}), MakeDataDescriptor(message_.fresh_id(), {index})); index++; } } else { // The other cases are simple: the component is made directly synonymous // with the element of the composite being constructed. transformation_context->GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(component, {}), MakeDataDescriptor(message_.fresh_id(), {index})); index++; } } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_composite_construct.h000066400000000000000000000102231475742701700304320ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_COMPOSITE_CONSTRUCT_H_ #define SOURCE_FUZZ_TRANSFORMATION_COMPOSITE_CONSTRUCT_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationCompositeConstruct : public Transformation { public: explicit TransformationCompositeConstruct( protobufs::TransformationCompositeConstruct message); TransformationCompositeConstruct( uint32_t composite_type_id, std::vector component, const protobufs::InstructionDescriptor& instruction_to_insert_before, uint32_t fresh_id); // - |message_.fresh_id| must not be used by the module. // - |message_.composite_type_id| must be the id of a composite type // - The elements of |message_.component| must be result ids that are // suitable for constructing an element of the given composite type, in // order // - The elements of |message_.component| must not be the target of any // decorations. // - |message_.base_instruction_id| must be the result id of an instruction // 'base' in some block 'blk'. // - 'blk' must contain an instruction 'inst' located |message_.offset| // instructions after 'base' (if |message_.offset| = 0 then 'inst' = // 'base'). // - It must be legal to insert an OpCompositeConstruct instruction directly // before 'inst'. // - Each element of |message_.component| must be available directly before // 'inst'. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Inserts a new OpCompositeConstruct instruction, with id // |message_.fresh_id|, directly before the instruction identified by // |message_.base_instruction_id| and |message_.offset|. The instruction // creates a composite of type |message_.composite_type_id| using the ids of // |message_.component|. // // Synonym facts are added between the elements of the resulting composite // and the components used to construct it, as long as the associated ids // support synonym creation. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: // Helper to decide whether the components of the transformation are suitable // for constructing an array of the given type. bool ComponentsForArrayConstructionAreOK( opt::IRContext* ir_context, const opt::analysis::Array& array_type) const; // Similar, but for matrices. bool ComponentsForMatrixConstructionAreOK( opt::IRContext* ir_context, const opt::analysis::Matrix& matrix_type) const; // Similar, but for structs. bool ComponentsForStructConstructionAreOK( opt::IRContext* ir_context, const opt::analysis::Struct& struct_type) const; // Similar, but for vectors. bool ComponentsForVectorConstructionAreOK( opt::IRContext* ir_context, const opt::analysis::Vector& vector_type) const; // Helper method for adding data synonym facts when applying the // transformation to |ir_context| and |transformation_context|. void AddDataSynonymFacts(opt::IRContext* ir_context, TransformationContext* transformation_context) const; protobufs::TransformationCompositeConstruct message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_COMPOSITE_CONSTRUCT_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_composite_extract.cpp000066400000000000000000000127711475742701700304250ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_composite_extract.h" #include #include "source/fuzz/data_descriptor.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" namespace spvtools { namespace fuzz { TransformationCompositeExtract::TransformationCompositeExtract( protobufs::TransformationCompositeExtract message) : message_(std::move(message)) {} TransformationCompositeExtract::TransformationCompositeExtract( const protobufs::InstructionDescriptor& instruction_to_insert_before, uint32_t fresh_id, uint32_t composite_id, const std::vector& index) { *message_.mutable_instruction_to_insert_before() = instruction_to_insert_before; message_.set_fresh_id(fresh_id); message_.set_composite_id(composite_id); for (auto an_index : index) { message_.add_index(an_index); } } bool TransformationCompositeExtract::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { if (!fuzzerutil::IsFreshId(ir_context, message_.fresh_id())) { return false; } auto instruction_to_insert_before = FindInstruction(message_.instruction_to_insert_before(), ir_context); if (!instruction_to_insert_before) { return false; } auto composite_instruction = ir_context->get_def_use_mgr()->GetDef(message_.composite_id()); if (!composite_instruction) { return false; } if (!fuzzerutil::IdIsAvailableBeforeInstruction( ir_context, instruction_to_insert_before, message_.composite_id())) { return false; } auto composite_type = ir_context->get_type_mgr()->GetType(composite_instruction->type_id()); if (!fuzzerutil::IsCompositeType(composite_type)) { return false; } if (!fuzzerutil::CanInsertOpcodeBeforeInstruction( spv::Op::OpCompositeExtract, instruction_to_insert_before)) { return false; } return fuzzerutil::WalkCompositeTypeIndices(ir_context, composite_instruction->type_id(), message_.index()) != 0; } void TransformationCompositeExtract::Apply( opt::IRContext* ir_context, TransformationContext* transformation_context) const { opt::Instruction::OperandList extract_operands; extract_operands.push_back({SPV_OPERAND_TYPE_ID, {message_.composite_id()}}); for (auto an_index : message_.index()) { extract_operands.push_back({SPV_OPERAND_TYPE_LITERAL_INTEGER, {an_index}}); } auto composite_instruction = ir_context->get_def_use_mgr()->GetDef(message_.composite_id()); auto extracted_type = fuzzerutil::WalkCompositeTypeIndices( ir_context, composite_instruction->type_id(), message_.index()); auto insert_before = FindInstruction(message_.instruction_to_insert_before(), ir_context); opt::Instruction* new_instruction = insert_before->InsertBefore(MakeUnique( ir_context, spv::Op::OpCompositeExtract, extracted_type, message_.fresh_id(), extract_operands)); ir_context->get_def_use_mgr()->AnalyzeInstDefUse(new_instruction); ir_context->set_instr_block(new_instruction, ir_context->get_instr_block(insert_before)); fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id()); // No analyses need to be invalidated since the transformation is local to a // block and the def-use and instruction-to-block mappings have been updated. AddDataSynonymFacts(ir_context, transformation_context); } protobufs::Transformation TransformationCompositeExtract::ToMessage() const { protobufs::Transformation result; *result.mutable_composite_extract() = message_; return result; } std::unordered_set TransformationCompositeExtract::GetFreshIds() const { return {message_.fresh_id()}; } void TransformationCompositeExtract::AddDataSynonymFacts( opt::IRContext* ir_context, TransformationContext* transformation_context) const { // Don't add synonyms if the composite being extracted from is not suitable, // or if the result id into which we are extracting is irrelevant. if (!fuzzerutil::CanMakeSynonymOf( ir_context, *transformation_context, *ir_context->get_def_use_mgr()->GetDef(message_.composite_id())) || transformation_context->GetFactManager()->IdIsIrrelevant( message_.fresh_id())) { return; } // Add the fact that the id storing the extracted element is synonymous with // the index into the structure. std::vector indices(message_.index().begin(), message_.index().end()); auto data_descriptor_for_extracted_element = MakeDataDescriptor(message_.composite_id(), indices); auto data_descriptor_for_result_id = MakeDataDescriptor(message_.fresh_id(), {}); transformation_context->GetFactManager()->AddFactDataSynonym( data_descriptor_for_extracted_element, data_descriptor_for_result_id); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_composite_extract.h000066400000000000000000000060661475742701700300720ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_COMPOSITE_EXTRACT_H_ #define SOURCE_FUZZ_TRANSFORMATION_COMPOSITE_EXTRACT_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationCompositeExtract : public Transformation { public: explicit TransformationCompositeExtract( protobufs::TransformationCompositeExtract message); TransformationCompositeExtract( const protobufs::InstructionDescriptor& instruction_to_insert_before, uint32_t fresh_id, uint32_t composite_id, const std::vector& index); // - |message_.fresh_id| must be available // - |message_.instruction_to_insert_before| must identify an instruction // before which it is valid to place an OpCompositeExtract // - |message_.composite_id| must be the id of an instruction that defines // a composite object, and this id must be available at the instruction // identified by |message_.instruction_to_insert_before| // - |message_.index| must be a suitable set of indices for // |message_.composite_id|, i.e. it must be possible to follow this chain // of indices to reach a sub-object of |message_.composite_id| bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Adds an OpCompositeConstruct instruction before the instruction identified // by |message_.instruction_to_insert_before|, that extracts from // |message_.composite_id| via indices |message_.index| into // |message_.fresh_id|. // // Adds a synonym fact associating |message_.fresh_id| with the relevant // element of |message_.composite_id|, as long as these ids support synonym // creation. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: // Helper method for adding data synonym facts when applying the // transformation to |ir_context| and |transformation_context|. void AddDataSynonymFacts(opt::IRContext* ir_context, TransformationContext* transformation_context) const; protobufs::TransformationCompositeExtract message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_COMPOSITE_EXTRACT_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_composite_insert.cpp000066400000000000000000000224331475742701700302530ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "transformation_composite_insert.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" namespace spvtools { namespace fuzz { TransformationCompositeInsert::TransformationCompositeInsert( protobufs::TransformationCompositeInsert message) : message_(std::move(message)) {} TransformationCompositeInsert::TransformationCompositeInsert( const protobufs::InstructionDescriptor& instruction_to_insert_before, uint32_t fresh_id, uint32_t composite_id, uint32_t object_id, const std::vector& index) { *message_.mutable_instruction_to_insert_before() = instruction_to_insert_before; message_.set_fresh_id(fresh_id); message_.set_composite_id(composite_id); message_.set_object_id(object_id); for (auto an_index : index) { message_.add_index(an_index); } } bool TransformationCompositeInsert::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { // |message_.fresh_id| must be fresh. if (!fuzzerutil::IsFreshId(ir_context, message_.fresh_id())) { return false; } // |message_.composite_id| must refer to an existing composite value. auto composite = ir_context->get_def_use_mgr()->GetDef(message_.composite_id()); if (!IsCompositeInstructionSupported(ir_context, composite)) { return false; } // The indices in |message_.index| must be suitable for indexing into // |composite->type_id()|. auto component_to_be_replaced_type_id = fuzzerutil::WalkCompositeTypeIndices( ir_context, composite->type_id(), message_.index()); if (component_to_be_replaced_type_id == 0) { return false; } // The instruction having the id of |message_.object_id| must be defined. auto object_instruction = ir_context->get_def_use_mgr()->GetDef(message_.object_id()); if (object_instruction == nullptr || object_instruction->type_id() == 0) { return false; } // We ignore pointers for now. auto object_instruction_type = ir_context->get_type_mgr()->GetType(object_instruction->type_id()); if (object_instruction_type->AsPointer() != nullptr) { return false; } // The type id of the object having |message_.object_id| and the type id of // the component of the composite at index |message_.index| must be the same. if (component_to_be_replaced_type_id != object_instruction->type_id()) { return false; } // |message_.instruction_to_insert_before| must be a defined instruction. auto instruction_to_insert_before = FindInstruction(message_.instruction_to_insert_before(), ir_context); if (instruction_to_insert_before == nullptr) { return false; } // |message_.composite_id| and |message_.object_id| must be available before // the |message_.instruction_to_insert_before|. if (!fuzzerutil::IdIsAvailableBeforeInstruction( ir_context, instruction_to_insert_before, message_.composite_id())) { return false; } if (!fuzzerutil::IdIsAvailableBeforeInstruction( ir_context, instruction_to_insert_before, message_.object_id())) { return false; } // It must be possible to insert an OpCompositeInsert before this // instruction. return fuzzerutil::CanInsertOpcodeBeforeInstruction( spv::Op::OpCompositeInsert, instruction_to_insert_before); } void TransformationCompositeInsert::Apply( opt::IRContext* ir_context, TransformationContext* transformation_context) const { // |message_.struct_fresh_id| must be fresh. assert(fuzzerutil::IsFreshId(ir_context, message_.fresh_id()) && "|message_.fresh_id| must be fresh"); std::vector index = fuzzerutil::RepeatedFieldToVector(message_.index()); opt::Instruction::OperandList in_operands; in_operands.push_back({SPV_OPERAND_TYPE_ID, {message_.object_id()}}); in_operands.push_back({SPV_OPERAND_TYPE_ID, {message_.composite_id()}}); for (auto i : index) { in_operands.push_back({SPV_OPERAND_TYPE_LITERAL_INTEGER, {i}}); } auto composite_type_id = fuzzerutil::GetTypeId(ir_context, message_.composite_id()); auto insert_before = FindInstruction(message_.instruction_to_insert_before(), ir_context); auto new_instruction = MakeUnique( ir_context, spv::Op::OpCompositeInsert, composite_type_id, message_.fresh_id(), std::move(in_operands)); auto new_instruction_ptr = new_instruction.get(); insert_before->InsertBefore(std::move(new_instruction)); fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id()); // Inform the def-use manager about the new instruction and record its basic // block. ir_context->get_def_use_mgr()->AnalyzeInstDefUse(new_instruction_ptr); ir_context->set_instr_block(new_instruction_ptr, ir_context->get_instr_block(insert_before)); // Add data synonym facts that arise from the insertion. AddDataSynonymFacts(ir_context, transformation_context); } protobufs::Transformation TransformationCompositeInsert::ToMessage() const { protobufs::Transformation result; *result.mutable_composite_insert() = message_; return result; } bool TransformationCompositeInsert::IsCompositeInstructionSupported( opt::IRContext* ir_context, opt::Instruction* instruction) { if (instruction == nullptr) { return false; } if (instruction->result_id() == 0 || instruction->type_id() == 0) { return false; } auto composite_type = ir_context->get_type_mgr()->GetType(instruction->type_id()); if (!fuzzerutil::IsCompositeType(composite_type)) { return false; } // Empty composites are not supported. auto instruction_type_inst = ir_context->get_def_use_mgr()->GetDef(instruction->type_id()); if (fuzzerutil::GetBoundForCompositeIndex(*instruction_type_inst, ir_context) == 0) { return false; } return true; } std::unordered_set TransformationCompositeInsert::GetFreshIds() const { return {message_.fresh_id()}; } void TransformationCompositeInsert::AddDataSynonymFacts( opt::IRContext* ir_context, TransformationContext* transformation_context) const { // If the result id arising from the insertion is irrelevant then do not add // any data synonym facts. (The result id can be irrelevant if the insertion // occurs in a dead block.) if (transformation_context->GetFactManager()->IdIsIrrelevant( message_.fresh_id())) { return; } // So long as the |message_.composite_id| is suitable for participating in // synonyms, every every element of the insertion result except for at the // index being inserted into is synonymous with the corresponding element of // |message_.composite_id|. In that case, for every index that is a prefix of // |index|, the components different from the one that contains the inserted // object are synonymous with corresponding elements in the original // composite. uint32_t current_node_type_id = fuzzerutil::GetTypeId(ir_context, message_.composite_id()); std::vector current_index; std::vector index = fuzzerutil::RepeatedFieldToVector(message_.index()); for (uint32_t current_level : index) { auto current_node_type_inst = ir_context->get_def_use_mgr()->GetDef(current_node_type_id); uint32_t index_to_skip = current_level; uint32_t num_of_components = fuzzerutil::GetBoundForCompositeIndex( *current_node_type_inst, ir_context); // Update the current_node_type_id. current_node_type_id = fuzzerutil::WalkOneCompositeTypeIndex( ir_context, current_node_type_id, index_to_skip); for (uint32_t i = 0; i < num_of_components; i++) { if (i == index_to_skip) { continue; } current_index.push_back(i); if (fuzzerutil::CanMakeSynonymOf(ir_context, *transformation_context, *ir_context->get_def_use_mgr()->GetDef( message_.composite_id()))) { transformation_context->GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(message_.fresh_id(), current_index), MakeDataDescriptor(message_.composite_id(), current_index)); } current_index.pop_back(); } // Store the prefix of the |index|. current_index.push_back(current_level); } // If the object being inserted supports synonym creation then it is // synonymous with the result of the insert instruction at the given index. if (fuzzerutil::CanMakeSynonymOf( ir_context, *transformation_context, *ir_context->get_def_use_mgr()->GetDef(message_.object_id()))) { transformation_context->GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(message_.object_id(), {}), MakeDataDescriptor(message_.fresh_id(), index)); } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_composite_insert.h000066400000000000000000000063241475742701700277210ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_COMPOSITE_INSERT_H_ #define SOURCE_FUZZ_TRANSFORMATION_COMPOSITE_INSERT_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationCompositeInsert : public Transformation { public: explicit TransformationCompositeInsert( protobufs::TransformationCompositeInsert message); TransformationCompositeInsert( const protobufs::InstructionDescriptor& instruction_to_insert_before, uint32_t fresh_id, uint32_t composite_id, uint32_t object_id, const std::vector& index); // - |message_.fresh_id| must be fresh. // - |message_.composite_id| must refer to an existing composite value. // - |message_.index| must refer to a correct index in the composite. // - The type id of the object and the type id of the component of the // composite at index |message_.index| must be the same. // - |message_.instruction_to_insert_before| must refer to a defined // instruction. // - It must be possible to insert OpCompositeInsert before // |instruction_to_insert_before|. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Adds an instruction OpCompositeInsert before // |instruction_to_insert_before|, which creates a new composite from // |composite_id| by inserting |object_id| at the specified |index|. // Synonyms are created between those components which are identical in the // original and the modified composite and between the inserted object and its // copy in the modified composite. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; // Checks if |instruction| is a instruction of a composite type supported by // this transformation. static bool IsCompositeInstructionSupported(opt::IRContext* ir_context, opt::Instruction* instruction); private: // Helper method for adding data synonym facts when applying the // transformation to |ir_context| and |transformation_context|. void AddDataSynonymFacts(opt::IRContext* ir_context, TransformationContext* transformation_context) const; protobufs::TransformationCompositeInsert message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_COMPOSITE_INSERT_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_compute_data_synonym_fact_closure.cpp000066400000000000000000000036621475742701700336620ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_compute_data_synonym_fact_closure.h" namespace spvtools { namespace fuzz { TransformationComputeDataSynonymFactClosure:: TransformationComputeDataSynonymFactClosure( protobufs::TransformationComputeDataSynonymFactClosure message) : message_(std::move(message)) {} TransformationComputeDataSynonymFactClosure:: TransformationComputeDataSynonymFactClosure( uint32_t maximum_equivalence_class_size) { message_.set_maximum_equivalence_class_size(maximum_equivalence_class_size); } bool TransformationComputeDataSynonymFactClosure::IsApplicable( opt::IRContext* /*unused*/, const TransformationContext& /*unused*/) const { return true; } void TransformationComputeDataSynonymFactClosure::Apply( opt::IRContext* /*unused*/, TransformationContext* transformation_context) const { transformation_context->GetFactManager()->ComputeClosureOfFacts( message_.maximum_equivalence_class_size()); } protobufs::Transformation TransformationComputeDataSynonymFactClosure::ToMessage() const { protobufs::Transformation result; *result.mutable_compute_data_synonym_fact_closure() = message_; return result; } std::unordered_set TransformationComputeDataSynonymFactClosure::GetFreshIds() const { return std::unordered_set(); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_compute_data_synonym_fact_closure.h000066400000000000000000000037511475742701700333260ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_COMPUTE_DATA_SYNONYM_FACT_CLOSURE_H_ #define SOURCE_FUZZ_TRANSFORMATION_COMPUTE_DATA_SYNONYM_FACT_CLOSURE_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationComputeDataSynonymFactClosure : public Transformation { public: explicit TransformationComputeDataSynonymFactClosure( protobufs::TransformationComputeDataSynonymFactClosure message); explicit TransformationComputeDataSynonymFactClosure( uint32_t maximum_equivalence_class_size); // This transformation is trivially applicable. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Forces the fact manager to compute a closure of data synonym facts, so that // facts implied by existing facts are deduced. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationComputeDataSynonymFactClosure message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_COMPUTE_DATA_SYNONYM_FACT_CLOSURE_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_context.cpp000066400000000000000000000042741475742701700263540ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_context.h" #include #include "source/util/make_unique.h" namespace spvtools { namespace fuzz { namespace { // An overflow id source that should never be used: its methods assert false. // This is the right id source for use during fuzzing, when overflow ids should // never be required. class NullOverflowIdSource : public OverflowIdSource { bool HasOverflowIds() const override { assert(false && "Bad attempt to query whether overflow ids are available."); return false; } uint32_t GetNextOverflowId() override { assert(false && "Bad attempt to request an overflow id."); return 0; } const std::unordered_set& GetIssuedOverflowIds() const override { assert(false && "Operation not supported."); return placeholder_; } private: std::unordered_set placeholder_; }; } // namespace TransformationContext::TransformationContext( std::unique_ptr fact_manager, spv_validator_options validator_options) : fact_manager_(std::move(fact_manager)), validator_options_(validator_options), overflow_id_source_(MakeUnique()) {} TransformationContext::TransformationContext( std::unique_ptr fact_manager, spv_validator_options validator_options, std::unique_ptr overflow_id_source) : fact_manager_(std::move(fact_manager)), validator_options_(validator_options), overflow_id_source_(std::move(overflow_id_source)) {} TransformationContext::~TransformationContext() = default; } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_context.h000066400000000000000000000050021475742701700260070ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_CONTEXT_H_ #define SOURCE_FUZZ_TRANSFORMATION_CONTEXT_H_ #include #include "source/fuzz/fact_manager/fact_manager.h" #include "source/fuzz/overflow_id_source.h" #include "spirv-tools/libspirv.hpp" namespace spvtools { namespace fuzz { // Encapsulates all information that is required to inform how to apply a // transformation to a module. class TransformationContext { public: // Constructs a transformation context with a given fact manager and validator // options. Overflow ids are not available from a transformation context // constructed in this way. TransformationContext(std::unique_ptr, spv_validator_options validator_options); // Constructs a transformation context with a given fact manager, validator // options and overflow id source. TransformationContext(std::unique_ptr, spv_validator_options validator_options, std::unique_ptr overflow_id_source); ~TransformationContext(); FactManager* GetFactManager() { return fact_manager_.get(); } const FactManager* GetFactManager() const { return fact_manager_.get(); } OverflowIdSource* GetOverflowIdSource() { return overflow_id_source_.get(); } const OverflowIdSource* GetOverflowIdSource() const { return overflow_id_source_.get(); } spv_validator_options GetValidatorOptions() const { return validator_options_; } private: // Manages facts that inform whether transformations can be applied, and that // are produced by applying transformations. std::unique_ptr fact_manager_; // Options to control validation when deciding whether transformations can be // applied. spv_validator_options validator_options_; std::unique_ptr overflow_id_source_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_CONTEXT_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_duplicate_region_with_selection.cpp000066400000000000000000000725441475742701700333120ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_duplicate_region_with_selection.h" #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { TransformationDuplicateRegionWithSelection:: TransformationDuplicateRegionWithSelection( protobufs::TransformationDuplicateRegionWithSelection message) : message_(std::move(message)) {} TransformationDuplicateRegionWithSelection:: TransformationDuplicateRegionWithSelection( uint32_t new_entry_fresh_id, uint32_t condition_id, uint32_t merge_label_fresh_id, uint32_t entry_block_id, uint32_t exit_block_id, const std::map& original_label_to_duplicate_label, const std::map& original_id_to_duplicate_id, const std::map& original_id_to_phi_id) { message_.set_new_entry_fresh_id(new_entry_fresh_id); message_.set_condition_id(condition_id); message_.set_merge_label_fresh_id(merge_label_fresh_id); message_.set_entry_block_id(entry_block_id); message_.set_exit_block_id(exit_block_id); *message_.mutable_original_label_to_duplicate_label() = fuzzerutil::MapToRepeatedUInt32Pair(original_label_to_duplicate_label); *message_.mutable_original_id_to_duplicate_id() = fuzzerutil::MapToRepeatedUInt32Pair(original_id_to_duplicate_id); *message_.mutable_original_id_to_phi_id() = fuzzerutil::MapToRepeatedUInt32Pair(original_id_to_phi_id); } bool TransformationDuplicateRegionWithSelection::IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const { // Instruction with the id |condition_id| must exist and must be of a bool // type. auto bool_instr = ir_context->get_def_use_mgr()->GetDef(message_.condition_id()); if (bool_instr == nullptr || !bool_instr->type_id()) { return false; } if (!ir_context->get_type_mgr()->GetType(bool_instr->type_id())->AsBool()) { return false; } // The |new_entry_fresh_id| must be fresh and distinct. std::set ids_used_by_this_transformation; if (!CheckIdIsFreshAndNotUsedByThisTransformation( message_.new_entry_fresh_id(), ir_context, &ids_used_by_this_transformation)) { return false; } // The |merge_label_fresh_id| must be fresh and distinct. if (!CheckIdIsFreshAndNotUsedByThisTransformation( message_.merge_label_fresh_id(), ir_context, &ids_used_by_this_transformation)) { return false; } // The entry and exit block ids must refer to blocks. for (auto block_id : {message_.entry_block_id(), message_.exit_block_id()}) { auto block_label = ir_context->get_def_use_mgr()->GetDef(block_id); if (!block_label || block_label->opcode() != spv::Op::OpLabel) { return false; } } auto entry_block = ir_context->cfg()->block(message_.entry_block_id()); auto exit_block = ir_context->cfg()->block(message_.exit_block_id()); // The |entry_block| and the |exit_block| must be in the same function. if (entry_block->GetParent() != exit_block->GetParent()) { return false; } // The |entry_block| must dominate the |exit_block|. auto dominator_analysis = ir_context->GetDominatorAnalysis(entry_block->GetParent()); if (!dominator_analysis->Dominates(entry_block, exit_block)) { return false; } // The |exit_block| must post-dominate the |entry_block|. auto postdominator_analysis = ir_context->GetPostDominatorAnalysis(entry_block->GetParent()); if (!postdominator_analysis->Dominates(exit_block, entry_block)) { return false; } auto enclosing_function = entry_block->GetParent(); // |entry_block| cannot be the first block of the |enclosing_function|. if (&*enclosing_function->begin() == entry_block) { return false; } // To make the process of resolving OpPhi instructions easier, we require that // the entry block has only one predecessor. auto entry_block_preds = ir_context->cfg()->preds(entry_block->id()); std::sort(entry_block_preds.begin(), entry_block_preds.end()); entry_block_preds.erase( std::unique(entry_block_preds.begin(), entry_block_preds.end()), entry_block_preds.end()); if (entry_block_preds.size() > 1) { return false; } // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/3785): // The following code has been copied from TransformationOutlineFunction. // Consider refactoring to avoid duplication. auto region_set = GetRegionBlocks(ir_context, entry_block, exit_block); // Check whether |region_set| really is a single-entry single-exit region, and // also check whether structured control flow constructs and their merge // and continue constructs are either wholly in or wholly out of the region - // e.g. avoid the situation where the region contains the head of a loop but // not the loop's continue construct. // // This is achieved by going through every block in the |enclosing_function| for (auto& block : *enclosing_function) { if (&block == exit_block) { // It is not OK for the exit block to head a loop construct or a // conditional construct. if (block.GetMergeInst()) { return false; } continue; } if (region_set.count(&block) != 0) { // The block is in the region and is not the region's exit block. Let's // see whether all of the block's successors are in the region. If they // are not, the region is not single-entry single-exit. bool all_successors_in_region = true; block.WhileEachSuccessorLabel([&all_successors_in_region, ir_context, ®ion_set](uint32_t successor) -> bool { if (region_set.count(ir_context->cfg()->block(successor)) == 0) { all_successors_in_region = false; return false; } return true; }); if (!all_successors_in_region) { return false; } } if (auto merge = block.GetMergeInst()) { // The block is a loop or selection header. The header and its // associated merge block must be both in the region or both be // outside the region. auto merge_block = ir_context->cfg()->block(merge->GetSingleWordOperand(0)); if (region_set.count(&block) != region_set.count(merge_block)) { return false; } } if (auto loop_merge = block.GetLoopMergeInst()) { // The continue target of a loop must be within the region if and only if // the header of the loop is. auto continue_target = ir_context->cfg()->block(loop_merge->GetSingleWordOperand(1)); // The continue target is a single-entry, single-exit region. Therefore, // if the continue target is the exit block, the region might not contain // the loop header. However, we would like to exclude this situation, // since it would be impossible for the modified exit block to branch to // the new selection merge block. In this scenario the exit block is // required to branch to the loop header. if (region_set.count(&block) != region_set.count(continue_target)) { return false; } } } // Get the maps from the protobuf. std::map original_label_to_duplicate_label = fuzzerutil::RepeatedUInt32PairToMap( message_.original_label_to_duplicate_label()); std::map original_id_to_duplicate_id = fuzzerutil::RepeatedUInt32PairToMap( message_.original_id_to_duplicate_id()); std::map original_id_to_phi_id = fuzzerutil::RepeatedUInt32PairToMap(message_.original_id_to_phi_id()); for (auto block : region_set) { // The label of every block in the region must be present in the map // |original_label_to_duplicate_label|, unless overflow ids are present. if (original_label_to_duplicate_label.count(block->id()) == 0) { if (!transformation_context.GetOverflowIdSource()->HasOverflowIds()) { return false; } } else { auto duplicate_label = original_label_to_duplicate_label.at(block->id()); // Each id assigned to labels in the region must be distinct and fresh. if (!duplicate_label || !CheckIdIsFreshAndNotUsedByThisTransformation( duplicate_label, ir_context, &ids_used_by_this_transformation)) { return false; } } for (auto& instr : *block) { if (!instr.HasResultId()) { continue; } // Every instruction with a result id in the region must be present in the // map |original_id_to_duplicate_id|, unless overflow ids are present. if (original_id_to_duplicate_id.count(instr.result_id()) == 0) { if (!transformation_context.GetOverflowIdSource()->HasOverflowIds()) { return false; } } else { auto duplicate_id = original_id_to_duplicate_id.at(instr.result_id()); // Id assigned to this result id in the region must be distinct and // fresh. if (!duplicate_id || !CheckIdIsFreshAndNotUsedByThisTransformation( duplicate_id, ir_context, &ids_used_by_this_transformation)) { return false; } } // If the instruction is available at the end of the region then we would // like to be able to add an OpPhi instruction at the merge point of the // duplicated region to capture the values computed by both duplicates of // the instruction, so that this is also available after the region. We // do this not just for instructions that are already used after the // region, but for all instructions so that the phi is available to future // transformations. if (AvailableAfterRegion(instr, exit_block, ir_context)) { if (!ValidOpPhiArgument(instr, ir_context)) { // The instruction cannot be used as an OpPhi argument. This is a // blocker if there are uses of the instruction after the region. // Otherwise we can simply avoid generating an OpPhi for this // instruction and its duplicate. if (!ir_context->get_def_use_mgr()->WhileEachUser( &instr, [ir_context, ®ion_set](opt::Instruction* use_instr) -> bool { opt::BasicBlock* use_block = ir_context->get_instr_block(use_instr); return use_block == nullptr || region_set.count(use_block) > 0; })) { return false; } } else { // Every instruction with a result id available at the end of the // region must be present in the map |original_id_to_phi_id|, unless // overflow ids are present. if (original_id_to_phi_id.count(instr.result_id()) == 0) { if (!transformation_context.GetOverflowIdSource() ->HasOverflowIds()) { return false; } } else { auto phi_id = original_id_to_phi_id.at(instr.result_id()); // Id assigned to this result id in the region must be distinct and // fresh. if (!phi_id || !CheckIdIsFreshAndNotUsedByThisTransformation( phi_id, ir_context, &ids_used_by_this_transformation)) { return false; } } } } } } return true; } void TransformationDuplicateRegionWithSelection::Apply( opt::IRContext* ir_context, TransformationContext* transformation_context) const { fuzzerutil::UpdateModuleIdBound(ir_context, message_.new_entry_fresh_id()); fuzzerutil::UpdateModuleIdBound(ir_context, message_.merge_label_fresh_id()); // Create the new entry block containing the main conditional instruction. Set // its parent to the parent of the original entry block, since it is located // in the same function. std::unique_ptr new_entry_block = MakeUnique(MakeUnique( ir_context, spv::Op::OpLabel, 0, message_.new_entry_fresh_id(), opt::Instruction::OperandList())); auto entry_block = ir_context->cfg()->block(message_.entry_block_id()); auto enclosing_function = entry_block->GetParent(); auto exit_block = ir_context->cfg()->block(message_.exit_block_id()); // Get the blocks contained in the region. std::set region_blocks = GetRegionBlocks(ir_context, entry_block, exit_block); // Construct the merge block. std::unique_ptr merge_block = MakeUnique(MakeUnique( ir_context, spv::Op::OpLabel, 0, message_.merge_label_fresh_id(), opt::Instruction::OperandList())); // Get the maps from the protobuf. std::map original_label_to_duplicate_label = fuzzerutil::RepeatedUInt32PairToMap( message_.original_label_to_duplicate_label()); std::map original_id_to_duplicate_id = fuzzerutil::RepeatedUInt32PairToMap( message_.original_id_to_duplicate_id()); std::map original_id_to_phi_id = fuzzerutil::RepeatedUInt32PairToMap(message_.original_id_to_phi_id()); // Use overflow ids to fill in any required ids that are missing from these // maps. for (auto block : region_blocks) { if (original_label_to_duplicate_label.count(block->id()) == 0) { original_label_to_duplicate_label.insert( {block->id(), transformation_context->GetOverflowIdSource()->GetNextOverflowId()}); } for (auto& instr : *block) { if (!instr.HasResultId()) { continue; } if (original_id_to_duplicate_id.count(instr.result_id()) == 0) { original_id_to_duplicate_id.insert( {instr.result_id(), transformation_context->GetOverflowIdSource() ->GetNextOverflowId()}); } if (AvailableAfterRegion(instr, exit_block, ir_context) && ValidOpPhiArgument(instr, ir_context)) { if (original_id_to_phi_id.count(instr.result_id()) == 0) { original_id_to_phi_id.insert( {instr.result_id(), transformation_context->GetOverflowIdSource() ->GetNextOverflowId()}); } } } } // Before adding duplicate blocks, we need to update the OpPhi instructions in // the successors of the |exit_block|. We know that the execution of the // transformed region will end in |merge_block|. Hence, we need to change all // occurrences of the label id of the |exit_block| to the label id of the // |merge_block|. exit_block->ForEachSuccessorLabel([this, ir_context](uint32_t label_id) { auto block = ir_context->cfg()->block(label_id); for (auto& instr : *block) { if (instr.opcode() == spv::Op::OpPhi) { instr.ForEachId([this](uint32_t* id) { if (*id == message_.exit_block_id()) { *id = message_.merge_label_fresh_id(); } }); } } }); // Get vector of predecessors id of |entry_block|. Remove any duplicate // values. auto entry_block_preds = ir_context->cfg()->preds(entry_block->id()); std::sort(entry_block_preds.begin(), entry_block_preds.end()); entry_block_preds.erase( unique(entry_block_preds.begin(), entry_block_preds.end()), entry_block_preds.end()); // We know that |entry_block| has only one predecessor, since the region is // single-entry, single-exit and its constructs and their merge blocks must be // either wholly within or wholly outside of the region. assert(entry_block_preds.size() == 1 && "The entry of the region to be duplicated can have only one " "predecessor."); uint32_t entry_block_pred_id = ir_context->get_instr_block(entry_block_preds[0])->id(); // Update all the OpPhi instructions in the |entry_block|. Change every // occurrence of |entry_block_pred_id| to the id of |new_entry|, because we // will insert |new_entry| before |entry_block|. for (auto& instr : *entry_block) { if (instr.opcode() == spv::Op::OpPhi) { instr.ForEachId([this, entry_block_pred_id](uint32_t* id) { if (*id == entry_block_pred_id) { *id = message_.new_entry_fresh_id(); } }); } } // Duplication of blocks will invalidate iterators. Store all the blocks from // the enclosing function. std::vector blocks; for (auto& block : *enclosing_function) { blocks.push_back(&block); } opt::BasicBlock* previous_block = nullptr; opt::BasicBlock* duplicated_exit_block = nullptr; // Iterate over all blocks of the function to duplicate blocks of the original // region and their instructions. for (auto& block : blocks) { // The block must be contained in the region. if (region_blocks.count(block) == 0) { continue; } fuzzerutil::UpdateModuleIdBound( ir_context, original_label_to_duplicate_label.at(block->id())); std::unique_ptr duplicated_block = MakeUnique(MakeUnique( ir_context, spv::Op::OpLabel, 0, original_label_to_duplicate_label.at(block->id()), opt::Instruction::OperandList())); for (auto& instr : *block) { // Case where an instruction is the terminator of the exit block is // handled separately. if (block == exit_block && instr.IsBlockTerminator()) { switch (instr.opcode()) { case spv::Op::OpBranch: case spv::Op::OpBranchConditional: case spv::Op::OpReturn: case spv::Op::OpReturnValue: case spv::Op::OpUnreachable: case spv::Op::OpKill: continue; default: assert(false && "Unexpected terminator for |exit_block| of the region."); } } // Duplicate the instruction. auto cloned_instr = instr.Clone(ir_context); duplicated_block->AddInstruction( std::unique_ptr(cloned_instr)); if (instr.HasResultId()) { fuzzerutil::UpdateModuleIdBound( ir_context, original_id_to_duplicate_id.at(instr.result_id())); } // If an id from the original region was used in this instruction, // replace it with the value from |original_id_to_duplicate_id|. // If a label from the original region was used in this instruction, // replace it with the value from |original_label_to_duplicate_label|. cloned_instr->ForEachId( [original_id_to_duplicate_id, original_label_to_duplicate_label](uint32_t* op) { if (original_id_to_duplicate_id.count(*op) != 0) { *op = original_id_to_duplicate_id.at(*op); } else if (original_label_to_duplicate_label.count(*op) != 0) { *op = original_label_to_duplicate_label.at(*op); } }); } // If the block is the first duplicated block, insert it after the exit // block of the original region. Otherwise, insert it after the preceding // one. auto duplicated_block_ptr = duplicated_block.get(); if (previous_block) { enclosing_function->InsertBasicBlockAfter(std::move(duplicated_block), previous_block); } else { enclosing_function->InsertBasicBlockAfter(std::move(duplicated_block), exit_block); } previous_block = duplicated_block_ptr; if (block == exit_block) { // After execution of the loop, this variable stores a pointer to the last // duplicated block. duplicated_exit_block = duplicated_block_ptr; } } for (auto& block : region_blocks) { for (auto& instr : *block) { if (instr.result_id() == 0) { continue; } if (AvailableAfterRegion(instr, exit_block, ir_context) && ValidOpPhiArgument(instr, ir_context)) { // Add an OpPhi instruction for every result id that is available at // the end of the region, as long as the result id is valid for use // with OpPhi. merge_block->AddInstruction(MakeUnique( ir_context, spv::Op::OpPhi, instr.type_id(), original_id_to_phi_id.at(instr.result_id()), opt::Instruction::OperandList({ {SPV_OPERAND_TYPE_ID, {instr.result_id()}}, {SPV_OPERAND_TYPE_ID, {exit_block->id()}}, {SPV_OPERAND_TYPE_ID, {original_id_to_duplicate_id.at(instr.result_id())}}, {SPV_OPERAND_TYPE_ID, {duplicated_exit_block->id()}}, }))); fuzzerutil::UpdateModuleIdBound( ir_context, original_id_to_phi_id.at(instr.result_id())); // If the instruction has been remapped by an OpPhi, look // for all its uses outside of the region and outside of the // merge block (to not overwrite just added instructions in // the merge block) and replace the original instruction id // with the id of the corresponding OpPhi instruction. ir_context->get_def_use_mgr()->ForEachUse( &instr, [ir_context, &instr, region_blocks, original_id_to_phi_id, &merge_block](opt::Instruction* user, uint32_t operand_index) { auto user_block = ir_context->get_instr_block(user); if ((region_blocks.find(user_block) != region_blocks.end()) || user_block == merge_block.get()) { return; } user->SetOperand(operand_index, {original_id_to_phi_id.at(instr.result_id())}); }); } } } // Construct a conditional instruction in the |new_entry_block|. // If the condition is true, the execution proceeds in the // |entry_block| of the original region. If the condition is // false, the execution proceeds in the first block of the // duplicated region. new_entry_block->AddInstruction(MakeUnique( ir_context, spv::Op::OpSelectionMerge, 0, 0, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {message_.merge_label_fresh_id()}}, {SPV_OPERAND_TYPE_SELECTION_CONTROL, {uint32_t(spv::SelectionControlMask::MaskNone)}}}))); new_entry_block->AddInstruction(MakeUnique( ir_context, spv::Op::OpBranchConditional, 0, 0, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {message_.condition_id()}}, {SPV_OPERAND_TYPE_ID, {message_.entry_block_id()}}, {SPV_OPERAND_TYPE_ID, {original_label_to_duplicate_label.at( message_.entry_block_id())}}}))); // Move the terminator of |exit_block| to the end of // |merge_block|. auto exit_block_terminator = exit_block->terminator(); auto cloned_instr = exit_block_terminator->Clone(ir_context); merge_block->AddInstruction(std::unique_ptr(cloned_instr)); ir_context->KillInst(exit_block_terminator); // Add OpBranch instruction to the merge block at the end of // |exit_block| and at the end of |duplicated_exit_block|, so that // the execution proceeds in the |merge_block|. opt::Instruction merge_branch_instr = opt::Instruction( ir_context, spv::Op::OpBranch, 0, 0, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {message_.merge_label_fresh_id()}}})); exit_block->AddInstruction(MakeUnique(merge_branch_instr)); duplicated_exit_block->AddInstruction( std::unique_ptr(merge_branch_instr.Clone(ir_context))); // Execution needs to start in the |new_entry_block|. Change all // the uses of |entry_block_label_instr| outside of the original // region to |message_.new_entry_fresh_id|. auto entry_block_label_instr = ir_context->get_def_use_mgr()->GetDef(message_.entry_block_id()); ir_context->get_def_use_mgr()->ForEachUse( entry_block_label_instr, [this, ir_context, region_blocks](opt::Instruction* user, uint32_t operand_index) { auto user_block = ir_context->get_instr_block(user); if ((region_blocks.count(user_block) != 0)) { return; } switch (user->opcode()) { case spv::Op::OpSwitch: case spv::Op::OpBranch: case spv::Op::OpBranchConditional: case spv::Op::OpLoopMerge: case spv::Op::OpSelectionMerge: { user->SetOperand(operand_index, {message_.new_entry_fresh_id()}); } break; case spv::Op::OpName: break; default: assert(false && "The label id cannot be used by instructions " "other than " "OpSwitch, OpBranch, OpBranchConditional, " "OpLoopMerge, " "OpSelectionMerge"); } }); opt::Instruction* merge_block_terminator = merge_block->terminator(); switch (merge_block_terminator->opcode()) { case spv::Op::OpReturnValue: case spv::Op::OpBranchConditional: { uint32_t operand = merge_block_terminator->GetSingleWordInOperand(0); if (original_id_to_phi_id.count(operand)) { merge_block_terminator->SetInOperand( 0, {original_id_to_phi_id.at(operand)}); } break; } default: break; } // Insert the merge block after the |duplicated_exit_block| (the // last duplicated block). enclosing_function->InsertBasicBlockAfter(std::move(merge_block), duplicated_exit_block); // Insert the |new_entry_block| before the entry block of the // original region. enclosing_function->InsertBasicBlockBefore(std::move(new_entry_block), entry_block); // Since we have changed the module, most of the analysis are now // invalid. We can invalidate analyses now after all of the blocks // have been registered. ir_context->InvalidateAnalysesExceptFor(opt::IRContext::kAnalysisNone); } // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/3785): // The following method has been copied from // TransformationOutlineFunction. Consider refactoring to avoid // duplication. std::set TransformationDuplicateRegionWithSelection::GetRegionBlocks( opt::IRContext* ir_context, opt::BasicBlock* entry_block, opt::BasicBlock* exit_block) { auto enclosing_function = entry_block->GetParent(); auto dominator_analysis = ir_context->GetDominatorAnalysis(enclosing_function); auto postdominator_analysis = ir_context->GetPostDominatorAnalysis(enclosing_function); // A block belongs to a region between the entry block and the exit // block if and only if it is dominated by the entry block and // post-dominated by the exit block. std::set result; for (auto& block : *enclosing_function) { if (dominator_analysis->Dominates(entry_block, &block) && postdominator_analysis->Dominates(exit_block, &block)) { result.insert(&block); } } return result; } protobufs::Transformation TransformationDuplicateRegionWithSelection::ToMessage() const { protobufs::Transformation result; *result.mutable_duplicate_region_with_selection() = message_; return result; } std::unordered_set TransformationDuplicateRegionWithSelection::GetFreshIds() const { std::unordered_set result = {message_.new_entry_fresh_id(), message_.merge_label_fresh_id()}; for (auto& pair : message_.original_label_to_duplicate_label()) { result.insert(pair.second()); } for (auto& pair : message_.original_id_to_duplicate_id()) { result.insert(pair.second()); } for (auto& pair : message_.original_id_to_phi_id()) { result.insert(pair.second()); } return result; } bool TransformationDuplicateRegionWithSelection::AvailableAfterRegion( const opt::Instruction& instr, opt::BasicBlock* exit_block, opt::IRContext* ir_context) { opt::Instruction* final_instruction_in_region = &*exit_block->tail(); return &instr == final_instruction_in_region || fuzzerutil::IdIsAvailableBeforeInstruction( ir_context, final_instruction_in_region, instr.result_id()); } bool TransformationDuplicateRegionWithSelection::ValidOpPhiArgument( const opt::Instruction& instr, opt::IRContext* ir_context) { opt::Instruction* instr_type = ir_context->get_def_use_mgr()->GetDef(instr.type_id()); // It is invalid to apply OpPhi to void-typed values. if (instr_type->opcode() == spv::Op::OpTypeVoid) { return false; } // Using pointers with OpPhi requires capability VariablePointers. if (instr_type->opcode() == spv::Op::OpTypePointer && !ir_context->get_feature_mgr()->HasCapability( spv::Capability::VariablePointers)) { return false; } // OpTypeSampledImage cannot be the result type of an OpPhi instruction. if (instr_type->opcode() == spv::Op::OpTypeSampledImage) { return false; } return true; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_duplicate_region_with_selection.h000066400000000000000000000077541475742701700327600ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_DUPLICATE_REGION_WITH_SELECTION_H_ #define SOURCE_FUZZ_TRANSFORMATION_DUPLICATE_REGION_WITH_SELECTION_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationDuplicateRegionWithSelection : public Transformation { public: explicit TransformationDuplicateRegionWithSelection( protobufs::TransformationDuplicateRegionWithSelection message); explicit TransformationDuplicateRegionWithSelection( uint32_t new_entry_fresh_id, uint32_t condition_id, uint32_t merge_label_fresh_id, uint32_t entry_block_id, uint32_t exit_block_id, const std::map& original_label_to_duplicate_label, const std::map& original_id_to_duplicate_id, const std::map& original_id_to_phi_id); // - |new_entry_fresh_id|, |merge_label_fresh_id| must be fresh and distinct. // - |condition_id| must refer to a valid instruction of boolean type. // - |entry_block_id| and |exit_block_id| must refer to valid blocks and they // must form a single-entry, single-exit region. Its constructs and their // merge blocks must be either wholly within or wholly outside of the // region. // - |original_label_to_duplicate_label| must contain at least a key for every // block in the original region. // - |original_id_to_duplicate_id| must contain at least a key for every // result id in the original region. // - |original_id_to_phi_id| must contain at least a key for every result id // available at the end of the original region. // - In each of these three maps, each value must be a distinct, fresh id. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // A transformation that inserts a conditional statement with a boolean // expression of arbitrary value and duplicates a given single-entry, // single-exit region, so that it is present in each conditional branch and // will be executed regardless of which branch will be taken. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; // Returns the set of blocks dominated by |entry_block| and post-dominated // by |exit_block|. static std::set GetRegionBlocks( opt::IRContext* ir_context, opt::BasicBlock* entry_block, opt::BasicBlock* exit_block); // Returns true if and only if |instr| is available at the end of the region // for which |exit_block| is the final block. static bool AvailableAfterRegion(const opt::Instruction& instr, opt::BasicBlock* exit_block, opt::IRContext* ir_context); // Returns true if and only if |instr| is valid as an argument to an OpPhi // instruction. static bool ValidOpPhiArgument(const opt::Instruction& instr, opt::IRContext* ir_context); std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationDuplicateRegionWithSelection message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_DUPLICATE_REGION_WITH_SELECTION_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_equation_instruction.cpp000066400000000000000000000247131475742701700311560ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_equation_instruction.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" namespace spvtools { namespace fuzz { TransformationEquationInstruction::TransformationEquationInstruction( protobufs::TransformationEquationInstruction message) : message_(std::move(message)) {} TransformationEquationInstruction::TransformationEquationInstruction( uint32_t fresh_id, spv::Op opcode, const std::vector& in_operand_id, const protobufs::InstructionDescriptor& instruction_to_insert_before) { message_.set_fresh_id(fresh_id); message_.set_opcode(uint32_t(opcode)); for (auto id : in_operand_id) { message_.add_in_operand_id(id); } *message_.mutable_instruction_to_insert_before() = instruction_to_insert_before; } bool TransformationEquationInstruction::IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const { // The result id must be fresh. if (!fuzzerutil::IsFreshId(ir_context, message_.fresh_id())) { return false; } // The instruction to insert before must exist. auto insert_before = FindInstruction(message_.instruction_to_insert_before(), ir_context); if (!insert_before) { return false; } // The input ids must all exist, not be OpUndef, not be irrelevant, and be // available before this instruction. for (auto id : message_.in_operand_id()) { auto inst = ir_context->get_def_use_mgr()->GetDef(id); if (!inst) { return false; } if (inst->opcode() == spv::Op::OpUndef) { return false; } if (transformation_context.GetFactManager()->IdIsIrrelevant(id)) { return false; } if (!fuzzerutil::IdIsAvailableBeforeInstruction(ir_context, insert_before, id)) { return false; } } return MaybeGetResultTypeId(ir_context) != 0; } void TransformationEquationInstruction::Apply( opt::IRContext* ir_context, TransformationContext* transformation_context) const { fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id()); opt::Instruction::OperandList in_operands; std::vector rhs_id; for (auto id : message_.in_operand_id()) { in_operands.push_back({SPV_OPERAND_TYPE_ID, {id}}); rhs_id.push_back(id); } auto insert_before = FindInstruction(message_.instruction_to_insert_before(), ir_context); opt::Instruction* new_instruction = insert_before->InsertBefore(MakeUnique( ir_context, static_cast(message_.opcode()), MaybeGetResultTypeId(ir_context), message_.fresh_id(), std::move(in_operands))); ir_context->get_def_use_mgr()->AnalyzeInstDefUse(new_instruction); ir_context->set_instr_block(new_instruction, ir_context->get_instr_block(insert_before)); // Add an equation fact as long as the result id is not irrelevant (it could // be if we are inserting into a dead block). if (!transformation_context->GetFactManager()->IdIsIrrelevant( message_.fresh_id())) { transformation_context->GetFactManager()->AddFactIdEquation( message_.fresh_id(), static_cast(message_.opcode()), rhs_id); } } protobufs::Transformation TransformationEquationInstruction::ToMessage() const { protobufs::Transformation result; *result.mutable_equation_instruction() = message_; return result; } uint32_t TransformationEquationInstruction::MaybeGetResultTypeId( opt::IRContext* ir_context) const { auto opcode = static_cast(message_.opcode()); switch (opcode) { case spv::Op::OpConvertUToF: case spv::Op::OpConvertSToF: { if (message_.in_operand_id_size() != 1) { return 0; } const auto* type = ir_context->get_type_mgr()->GetType( fuzzerutil::GetTypeId(ir_context, message_.in_operand_id(0))); if (!type) { return 0; } if (const auto* vector = type->AsVector()) { if (!vector->element_type()->AsInteger()) { return 0; } if (auto element_type_id = fuzzerutil::MaybeGetFloatType( ir_context, vector->element_type()->AsInteger()->width())) { return fuzzerutil::MaybeGetVectorType(ir_context, element_type_id, vector->element_count()); } return 0; } else { if (!type->AsInteger()) { return 0; } return fuzzerutil::MaybeGetFloatType(ir_context, type->AsInteger()->width()); } } case spv::Op::OpBitcast: { if (message_.in_operand_id_size() != 1) { return 0; } const auto* operand_inst = ir_context->get_def_use_mgr()->GetDef(message_.in_operand_id(0)); if (!operand_inst) { return 0; } const auto* operand_type = ir_context->get_type_mgr()->GetType(operand_inst->type_id()); if (!operand_type) { return 0; } // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/3539): // The only constraint on the types of OpBitcast's parameters is that // they must have the same number of bits. Consider improving the code // below to support this in full. if (const auto* vector = operand_type->AsVector()) { uint32_t component_type_id; if (const auto* int_type = vector->element_type()->AsInteger()) { component_type_id = fuzzerutil::MaybeGetFloatType(ir_context, int_type->width()); } else if (const auto* float_type = vector->element_type()->AsFloat()) { component_type_id = fuzzerutil::MaybeGetIntegerType( ir_context, float_type->width(), true); if (component_type_id == 0 || fuzzerutil::MaybeGetVectorType(ir_context, component_type_id, vector->element_count()) == 0) { component_type_id = fuzzerutil::MaybeGetIntegerType( ir_context, float_type->width(), false); } } else { assert(false && "Only vectors of numerical components are supported"); return 0; } if (component_type_id == 0) { return 0; } return fuzzerutil::MaybeGetVectorType(ir_context, component_type_id, vector->element_count()); } else if (const auto* int_type = operand_type->AsInteger()) { return fuzzerutil::MaybeGetFloatType(ir_context, int_type->width()); } else if (const auto* float_type = operand_type->AsFloat()) { if (auto existing_id = fuzzerutil::MaybeGetIntegerType( ir_context, float_type->width(), true)) { return existing_id; } return fuzzerutil::MaybeGetIntegerType(ir_context, float_type->width(), false); } else { assert(false && "Operand is not a scalar or a vector of numerical type"); return 0; } } case spv::Op::OpIAdd: case spv::Op::OpISub: { if (message_.in_operand_id_size() != 2) { return 0; } uint32_t first_operand_width = 0; uint32_t first_operand_type_id = 0; for (uint32_t index = 0; index < 2; index++) { auto operand_inst = ir_context->get_def_use_mgr()->GetDef( message_.in_operand_id(index)); if (!operand_inst || !operand_inst->type_id()) { return 0; } auto operand_type = ir_context->get_type_mgr()->GetType(operand_inst->type_id()); if (!(operand_type->AsInteger() || (operand_type->AsVector() && operand_type->AsVector()->element_type()->AsInteger()))) { return 0; } uint32_t operand_width = operand_type->AsInteger() ? 1 : operand_type->AsVector()->element_count(); if (index == 0) { first_operand_width = operand_width; first_operand_type_id = operand_inst->type_id(); } else { assert(first_operand_width != 0 && "The first operand should have been processed."); if (operand_width != first_operand_width) { return 0; } } } assert(first_operand_type_id != 0 && "A type must have been found for the first operand."); return first_operand_type_id; } case spv::Op::OpLogicalNot: { if (message_.in_operand_id().size() != 1) { return 0; } auto operand_inst = ir_context->get_def_use_mgr()->GetDef(message_.in_operand_id(0)); if (!operand_inst || !operand_inst->type_id()) { return 0; } auto operand_type = ir_context->get_type_mgr()->GetType(operand_inst->type_id()); if (!(operand_type->AsBool() || (operand_type->AsVector() && operand_type->AsVector()->element_type()->AsBool()))) { return 0; } return operand_inst->type_id(); } case spv::Op::OpSNegate: { if (message_.in_operand_id().size() != 1) { return 0; } auto operand_inst = ir_context->get_def_use_mgr()->GetDef(message_.in_operand_id(0)); if (!operand_inst || !operand_inst->type_id()) { return 0; } auto operand_type = ir_context->get_type_mgr()->GetType(operand_inst->type_id()); if (!(operand_type->AsInteger() || (operand_type->AsVector() && operand_type->AsVector()->element_type()->AsInteger()))) { return 0; } return operand_inst->type_id(); } default: assert(false && "Inappropriate opcode for equation instruction."); return 0; } } std::unordered_set TransformationEquationInstruction::GetFreshIds() const { return {message_.fresh_id()}; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_equation_instruction.h000066400000000000000000000057541475742701700306270ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_EQUATION_INSTRUCTION_H_ #define SOURCE_FUZZ_TRANSFORMATION_EQUATION_INSTRUCTION_H_ #include #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationEquationInstruction : public Transformation { public: explicit TransformationEquationInstruction( protobufs::TransformationEquationInstruction message); TransformationEquationInstruction( uint32_t fresh_id, spv::Op opcode, const std::vector& in_operand_id, const protobufs::InstructionDescriptor& instruction_to_insert_before); // - |message_.fresh_id| must be fresh. // - |message_.instruction_to_insert_before| must identify an instruction // before which an equation instruction can legitimately be inserted. // - Each id in |message_.in_operand_id| must exist, not be an OpUndef, and // be available before |message_.instruction_to_insert_before|. // - |message_.opcode| must be an opcode for which we know how to handle // equations, the types of the ids in |message_.in_operand_id| must be // suitable for use with this opcode, and the module must contain an // appropriate result type id. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Adds an instruction to the module, right before // |message_.instruction_to_insert_before|, of the form: // // |message_.fresh_id| = |message_.opcode| %type |message_.in_operand_ids| // // where %type is a type id that already exists in the module and that is // compatible with the opcode and input operands. // // The fact manager is also updated to inform it of this equation fact. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: // Returns type id for the equation instruction. Returns 0 if result type does // not exist. uint32_t MaybeGetResultTypeId(opt::IRContext* ir_context) const; protobufs::TransformationEquationInstruction message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_EQUATION_INSTRUCTION_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_expand_vector_reduction.cpp000066400000000000000000000150671475742701700316070ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_expand_vector_reduction.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" namespace spvtools { namespace fuzz { TransformationExpandVectorReduction::TransformationExpandVectorReduction( protobufs::TransformationExpandVectorReduction message) : message_(std::move(message)) {} TransformationExpandVectorReduction::TransformationExpandVectorReduction( const uint32_t instruction_result_id, const std::vector& fresh_ids) { message_.set_instruction_result_id(instruction_result_id); *message_.mutable_fresh_ids() = google::protobuf::RepeatedField( fresh_ids.begin(), fresh_ids.end()); } bool TransformationExpandVectorReduction::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { auto* instruction = ir_context->get_def_use_mgr()->GetDef(message_.instruction_result_id()); // |instruction| must be defined. if (!instruction) { return false; } // |instruction| must be OpAny or OpAll. if (instruction->opcode() != spv::Op::OpAny && instruction->opcode() != spv::Op::OpAll) { return false; } // |message_.fresh_ids.size| must have the exact number of fresh ids required // to apply the transformation. if (static_cast(message_.fresh_ids().size()) != GetRequiredFreshIdCount(ir_context, instruction)) { return false; } std::set ids_used_by_this_transformation; for (uint32_t fresh_id : message_.fresh_ids()) { // All ids in |message_.fresh_ids| must be fresh. if (!fuzzerutil::IsFreshId(ir_context, fresh_id)) { return false; } // All fresh ids need to be distinct. if (!CheckIdIsFreshAndNotUsedByThisTransformation( fresh_id, ir_context, &ids_used_by_this_transformation)) { return false; } } return true; } void TransformationExpandVectorReduction::Apply( opt::IRContext* ir_context, TransformationContext* transformation_context) const { auto* instruction = ir_context->get_def_use_mgr()->GetDef(message_.instruction_result_id()); auto* vector = ir_context->get_def_use_mgr()->GetDef( instruction->GetSingleWordInOperand(0)); uint32_t vector_component_count = ir_context->get_type_mgr() ->GetType(vector->type_id()) ->AsVector() ->element_count(); // Fresh id iterator. auto fresh_id = message_.fresh_ids().begin(); // |vector_components| are the ids of the extracted components from |vector|. std::vector vector_components; for (uint32_t i = 0; i < vector_component_count; i++) { // Extracts the i-th |vector| component. auto vector_component = opt::Instruction(ir_context, spv::Op::OpCompositeExtract, instruction->type_id(), *fresh_id++, {{SPV_OPERAND_TYPE_ID, {vector->result_id()}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {i}}}); instruction->InsertBefore(MakeUnique(vector_component)); fuzzerutil::UpdateModuleIdBound(ir_context, vector_component.result_id()); vector_components.push_back(vector_component.result_id()); } // The first two |vector| components are used in the first logical operation. auto logical_instruction = opt::Instruction( ir_context, instruction->opcode() == spv::Op::OpAny ? spv::Op::OpLogicalOr : spv::Op::OpLogicalAnd, instruction->type_id(), *fresh_id++, {{SPV_OPERAND_TYPE_ID, {vector_components[0]}}, {SPV_OPERAND_TYPE_ID, {vector_components[1]}}}); instruction->InsertBefore(MakeUnique(logical_instruction)); fuzzerutil::UpdateModuleIdBound(ir_context, logical_instruction.result_id()); // Evaluates the remaining components. for (uint32_t i = 2; i < vector_components.size(); i++) { logical_instruction = opt::Instruction( ir_context, logical_instruction.opcode(), instruction->type_id(), *fresh_id++, {{SPV_OPERAND_TYPE_ID, {vector_components[i]}}, {SPV_OPERAND_TYPE_ID, {logical_instruction.result_id()}}}); instruction->InsertBefore( MakeUnique(logical_instruction)); fuzzerutil::UpdateModuleIdBound(ir_context, logical_instruction.result_id()); } ir_context->InvalidateAnalysesExceptFor(opt::IRContext::kAnalysisNone); // If it's possible to make a synonym of |instruction|, then add the fact that // the last |logical_instruction| is a synonym of |instruction|. if (fuzzerutil::CanMakeSynonymOf(ir_context, *transformation_context, *instruction)) { transformation_context->GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(logical_instruction.result_id(), {}), MakeDataDescriptor(instruction->result_id(), {})); } } protobufs::Transformation TransformationExpandVectorReduction::ToMessage() const { protobufs::Transformation result; *result.mutable_expand_vector_reduction() = message_; return result; } uint32_t TransformationExpandVectorReduction::GetRequiredFreshIdCount( opt::IRContext* ir_context, opt::Instruction* instruction) { // For each vector component, 1 OpCompositeExtract and 1 OpLogical* (except // for the first component) instructions will be inserted. return 2 * ir_context->get_type_mgr() ->GetType(ir_context->get_def_use_mgr() ->GetDef(instruction->GetSingleWordInOperand(0)) ->type_id()) ->AsVector() ->element_count() - 1; } std::unordered_set TransformationExpandVectorReduction::GetFreshIds() const { std::unordered_set result; for (auto id : message_.fresh_ids()) { result.insert(id); } return result; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_expand_vector_reduction.h000066400000000000000000000127151475742701700312510ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_EXPAND_VECTOR_REDUCTION_H_ #define SOURCE_FUZZ_TRANSFORMATION_EXPAND_VECTOR_REDUCTION_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { // clang-format off // SPIR-V code to help understand the transformation. // // ------------------------------------------------------------------------------- // | Reference shader | Variant shader | // ------------------------------------------------------------------------------- // | OpCapability Shader | OpCapability Shader | // | %1 = OpExtInstImport "GLSL.std.450" | %1 = OpExtInstImport "GLSL.std.450" | // | OpMemoryModel Logical GLSL450 | OpMemoryModel Logical GLSL450 | // | OpEntryPoint Vertex %9 "main" | OpEntryPoint Vertex %9 "main" | // | | | // | ; Types | ; Types | // | %2 = OpTypeBool | %2 = OpTypeBool | // | %3 = OpTypeVector %2 2 | %3 = OpTypeVector %2 2 | // | %4 = OpTypeVoid | %4 = OpTypeVoid | // | %5 = OpTypeFunction %4 | %5 = OpTypeFunction %4 | // | | | // | ; Constants | ; Constants | // | %6 = OpConstantTrue %2 | %6 = OpConstantTrue %2 | // | %7 = OpConstantFalse %2 | %7 = OpConstantFalse %2 | // | %8 = OpConstantComposite %3 %6 %7 | %8 = OpConstantComposite %3 %6 %7 | // | | | // | ; main function | ; main function | // | %9 = OpFunction %4 None %5 | %9 = OpFunction %4 None %5 | // | %10 = OpLabel | %10 = OpLabel | // | %11 = OpAny %2 %8 | | // | %12 = OpAll %2 %8 | ; Add OpAny synonym | // | OpReturn | %13 = OpCompositeExtract %2 %8 0 | // | OpFunctionEnd | %14 = OpCompositeExtract %2 %8 1 | // | | %15 = OpLogicalOr %2 %13 %14 | // | | %11 = OpAny %2 %8 | // | | | // | | ; Add OpAll synonym | // | | %16 = OpCompositeExtract %2 %8 0 | // | | %17 = OpCompositeExtract %2 %8 1 | // | | %18 = OpLogicalAnd %2 %16 %17 | // | | %12 = OpAll %2 %8 | // | | OpReturn | // | | OpFunctionEnd | // ------------------------------------------------------------------------------- // // %11 and %15 are synonymous // %12 and %18 are synonymous // clang-format on class TransformationExpandVectorReduction : public Transformation { public: explicit TransformationExpandVectorReduction( protobufs::TransformationExpandVectorReduction message); TransformationExpandVectorReduction(const uint32_t instruction_result_id, const std::vector& fresh_ids); // - |message_.instruction_result_id| must be OpAny or OpAll. // - |message_.fresh_ids| must be fresh ids needed to apply the // transformation. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Adds synonyms for OpAny and OpAll instructions by evaluating each vector // component with the corresponding logical operation. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; // Returns the number of fresh ids required to apply the transformation. static uint32_t GetRequiredFreshIdCount(opt::IRContext* ir_context, opt::Instruction* instruction); private: protobufs::TransformationExpandVectorReduction message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_EXPAND_VECTOR_REDUCTION_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_flatten_conditional_branch.cpp000066400000000000000000001327001475742701700322210ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_flatten_conditional_branch.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" namespace spvtools { namespace fuzz { TransformationFlattenConditionalBranch::TransformationFlattenConditionalBranch( protobufs::TransformationFlattenConditionalBranch message) : message_(std::move(message)) {} TransformationFlattenConditionalBranch::TransformationFlattenConditionalBranch( uint32_t header_block_id, bool true_branch_first, uint32_t fresh_id_for_bvec2_selector, uint32_t fresh_id_for_bvec3_selector, uint32_t fresh_id_for_bvec4_selector, const std::vector& side_effect_wrappers_info) { message_.set_header_block_id(header_block_id); message_.set_true_branch_first(true_branch_first); message_.set_fresh_id_for_bvec2_selector(fresh_id_for_bvec2_selector); message_.set_fresh_id_for_bvec3_selector(fresh_id_for_bvec3_selector); message_.set_fresh_id_for_bvec4_selector(fresh_id_for_bvec4_selector); for (auto const& side_effect_wrapper_info : side_effect_wrappers_info) { *message_.add_side_effect_wrapper_info() = side_effect_wrapper_info; } } bool TransformationFlattenConditionalBranch::IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const { auto header_block = fuzzerutil::MaybeFindBlock(ir_context, message_.header_block_id()); // The block must have been found and it must be a selection header. if (!header_block || !header_block->GetMergeInst() || header_block->GetMergeInst()->opcode() != spv::Op::OpSelectionMerge) { return false; } // The header block must end with an OpBranchConditional instruction. if (header_block->terminator()->opcode() != spv::Op::OpBranchConditional) { return false; } // The branch condition cannot be irrelevant: we will make reference to it // multiple times and we need to be guaranteed that these references will // yield the same result; if they are replaced by other ids that will not // work. if (transformation_context.GetFactManager()->IdIsIrrelevant( header_block->terminator()->GetSingleWordInOperand(0))) { return false; } std::set used_fresh_ids; // If ids have been provided to be used as vector guards for OpSelect // instructions then they must be fresh. for (uint32_t fresh_id_for_bvec_selector : {message_.fresh_id_for_bvec2_selector(), message_.fresh_id_for_bvec3_selector(), message_.fresh_id_for_bvec4_selector()}) { if (fresh_id_for_bvec_selector != 0) { if (!CheckIdIsFreshAndNotUsedByThisTransformation( fresh_id_for_bvec_selector, ir_context, &used_fresh_ids)) { return false; } } } // Use a set to keep track of the instructions that require fresh ids. std::set instructions_that_need_ids; // Check that, if there are enough ids, the conditional can be flattened and, // if so, add all the problematic instructions that need to be enclosed inside // conditionals to |instructions_that_need_ids|. if (!GetProblematicInstructionsIfConditionalCanBeFlattened( ir_context, header_block, transformation_context, &instructions_that_need_ids)) { return false; } // Get the mapping from instructions to the fresh ids needed to enclose them // inside conditionals. auto insts_to_wrapper_info = GetInstructionsToWrapperInfo(ir_context); { // Check the ids in the map. for (const auto& inst_to_info : insts_to_wrapper_info) { // Check the fresh ids needed for all of the instructions that need to be // enclosed inside a conditional. for (uint32_t id : {inst_to_info.second.merge_block_id(), inst_to_info.second.execute_block_id()}) { if (!id || !CheckIdIsFreshAndNotUsedByThisTransformation( id, ir_context, &used_fresh_ids)) { return false; } } // Check the other ids needed, if the instruction needs a placeholder. if (InstructionNeedsPlaceholder(ir_context, *inst_to_info.first)) { // Check the fresh ids. for (uint32_t id : {inst_to_info.second.actual_result_id(), inst_to_info.second.alternative_block_id(), inst_to_info.second.placeholder_result_id()}) { if (!id || !CheckIdIsFreshAndNotUsedByThisTransformation( id, ir_context, &used_fresh_ids)) { return false; } } // Check that the placeholder value id exists, has the right type and is // available to use at this point. auto value_def = ir_context->get_def_use_mgr()->GetDef( inst_to_info.second.value_to_copy_id()); if (!value_def || value_def->type_id() != inst_to_info.first->type_id() || !fuzzerutil::IdIsAvailableBeforeInstruction( ir_context, inst_to_info.first, inst_to_info.second.value_to_copy_id())) { return false; } } } } // If some instructions that require ids are not in the map, the // transformation needs overflow ids to be applicable. for (auto instruction : instructions_that_need_ids) { if (insts_to_wrapper_info.count(instruction) == 0 && !transformation_context.GetOverflowIdSource()->HasOverflowIds()) { return false; } } if (OpSelectArgumentsAreRestricted(ir_context)) { // OpPhi instructions at the convergence block for the selection are handled // by turning them into OpSelect instructions. As the SPIR-V version in use // has restrictions on the arguments that OpSelect can take, we must check // that any OpPhi instructions are compatible with these restrictions. uint32_t convergence_block_id = FindConvergenceBlock(ir_context, *header_block); // Consider every OpPhi instruction at the convergence block. if (!ir_context->cfg() ->block(convergence_block_id) ->WhileEachPhiInst([this, ir_context](opt::Instruction* inst) -> bool { // Decide whether the OpPhi can be handled based on its result // type. opt::Instruction* phi_result_type = ir_context->get_def_use_mgr()->GetDef(inst->type_id()); switch (phi_result_type->opcode()) { case spv::Op::OpTypeBool: case spv::Op::OpTypeInt: case spv::Op::OpTypeFloat: case spv::Op::OpTypePointer: // Fine: OpSelect can work directly on scalar and pointer // types. return true; case spv::Op::OpTypeVector: { // In its restricted form, OpSelect can only select between // vectors if the condition of the select is a boolean // boolean vector. We thus require the appropriate boolean // vector type to be present. uint32_t bool_type_id = fuzzerutil::MaybeGetBoolType(ir_context); if (!bool_type_id) { return false; } uint32_t dimension = phi_result_type->GetSingleWordInOperand(1); if (fuzzerutil::MaybeGetVectorType(ir_context, bool_type_id, dimension) == 0) { // The required boolean vector type is not present. return false; } // The transformation needs to be equipped with a fresh id // in which to store the vectorized version of the selection // construct's condition. switch (dimension) { case 2: return message_.fresh_id_for_bvec2_selector() != 0; case 3: return message_.fresh_id_for_bvec3_selector() != 0; default: assert(dimension == 4 && "Invalid vector dimension."); return message_.fresh_id_for_bvec4_selector() != 0; } } default: return false; } })) { return false; } } // All checks were passed. return true; } void TransformationFlattenConditionalBranch::Apply( opt::IRContext* ir_context, TransformationContext* transformation_context) const { // branch = 1 corresponds to the true branch, branch = 2 corresponds to the // false branch. If the true branch is to be laid out first, we need to visit // the false branch first, because each branch is moved to right after the // header while it is visited. std::vector branches = {2, 1}; if (!message_.true_branch_first()) { // Similarly, we need to visit the true branch first, if we want it to be // laid out after the false branch. branches = {1, 2}; } auto header_block = ir_context->cfg()->block(message_.header_block_id()); // Get the ids of the starting blocks of the first and last branches to be // laid out. The first branch is the true branch iff // |message_.true_branch_first| is true. auto branch_instruction = header_block->terminator(); uint32_t first_block_first_branch_id = branch_instruction->GetSingleWordInOperand(branches[1]); uint32_t first_block_last_branch_id = branch_instruction->GetSingleWordInOperand(branches[0]); uint32_t convergence_block_id = FindConvergenceBlock(ir_context, *header_block); // If the OpBranchConditional instruction in the header branches to the same // block for both values of the condition, this is the convergence block (the // flow does not actually diverge) and the OpPhi instructions in it are still // valid, so we do not need to make any changes. if (first_block_first_branch_id != first_block_last_branch_id) { RewriteOpPhiInstructionsAtConvergenceBlock( *header_block, convergence_block_id, ir_context); } // Get the mapping from instructions to fresh ids. auto insts_to_info = GetInstructionsToWrapperInfo(ir_context); // Get a reference to the last block in the first branch that will be laid out // (this depends on |message_.true_branch_first|). The last block is the block // in the branch just before flow converges (it might not exist). opt::BasicBlock* last_block_first_branch = nullptr; // Keep track of blocks and ids for which we should later add dead block and // irrelevant id facts. We wait until we have finished applying the // transformation before adding these facts, so that the fact manager has // access to the fully up-to-date module. std::vector dead_blocks; std::vector irrelevant_ids; // Adjust the conditional branches by enclosing problematic instructions // within conditionals and get references to the last block in each branch. for (uint32_t branch : branches) { auto current_block = header_block; // Get the id of the first block in this branch. uint32_t next_block_id = branch_instruction->GetSingleWordInOperand(branch); // Consider all blocks in the branch until the convergence block is reached. while (next_block_id != convergence_block_id) { // Move the next block to right after the current one. current_block->GetParent()->MoveBasicBlockToAfter(next_block_id, current_block); // Move forward in the branch. current_block = ir_context->cfg()->block(next_block_id); // Find all the instructions in the current block which need to be // enclosed inside conditionals. std::vector problematic_instructions; current_block->ForEachInst( [&problematic_instructions](opt::Instruction* instruction) { if (instruction->opcode() != spv::Op::OpLabel && instruction->opcode() != spv::Op::OpBranch && !fuzzerutil::InstructionHasNoSideEffects(*instruction)) { problematic_instructions.push_back(instruction); } }); uint32_t condition_id = header_block->terminator()->GetSingleWordInOperand(0); // Enclose all of the problematic instructions in conditionals, with the // same condition as the selection construct being flattened. for (auto instruction : problematic_instructions) { // Get the info needed by this instruction to wrap it inside a // conditional. protobufs::SideEffectWrapperInfo wrapper_info; if (insts_to_info.count(instruction) != 0) { // Get the fresh ids from the map, if present. wrapper_info = insts_to_info[instruction]; } else { // If we could not get it from the map, use overflow ids. We don't // need to set |wrapper_info.instruction|, as it will not be used. wrapper_info.set_merge_block_id( transformation_context->GetOverflowIdSource() ->GetNextOverflowId()); wrapper_info.set_execute_block_id( transformation_context->GetOverflowIdSource() ->GetNextOverflowId()); if (InstructionNeedsPlaceholder(ir_context, *instruction)) { // Ge the fresh ids from the overflow ids. wrapper_info.set_actual_result_id( transformation_context->GetOverflowIdSource() ->GetNextOverflowId()); wrapper_info.set_alternative_block_id( transformation_context->GetOverflowIdSource() ->GetNextOverflowId()); wrapper_info.set_placeholder_result_id( transformation_context->GetOverflowIdSource() ->GetNextOverflowId()); // Try to find a zero constant. It does not matter whether it is // relevant or irrelevant. for (bool is_irrelevant : {true, false}) { wrapper_info.set_value_to_copy_id( fuzzerutil::MaybeGetZeroConstant( ir_context, *transformation_context, instruction->type_id(), is_irrelevant)); if (wrapper_info.value_to_copy_id()) { break; } } } } // Enclose the instruction in a conditional and get the merge block // generated by this operation (this is where all the following // instructions will be). current_block = EncloseInstructionInConditional( ir_context, *transformation_context, current_block, instruction, wrapper_info, condition_id, branch == 1, &dead_blocks, &irrelevant_ids); } next_block_id = current_block->terminator()->GetSingleWordInOperand(0); // If the next block is the convergence block and this the branch that // will be laid out right after the header, record this as the last block // in the first branch. if (next_block_id == convergence_block_id && branch == branches[1]) { last_block_first_branch = current_block; } } } // The current header should unconditionally branch to the starting block in // the first branch to be laid out, if such a branch exists (i.e. the header // does not branch directly to the convergence block), and to the starting // block in the last branch to be laid out otherwise. uint32_t after_header = first_block_first_branch_id != convergence_block_id ? first_block_first_branch_id : first_block_last_branch_id; // Kill the merge instruction and the branch instruction in the current // header. auto merge_inst = header_block->GetMergeInst(); ir_context->KillInst(branch_instruction); ir_context->KillInst(merge_inst); // Add a new, unconditional, branch instruction from the current header to // |after_header|. header_block->AddInstruction(MakeUnique( ir_context, spv::Op::OpBranch, 0, 0, opt::Instruction::OperandList{{SPV_OPERAND_TYPE_ID, {after_header}}})); // If the first branch to be laid out exists, change the branch instruction so // that the last block in such branch unconditionally branches to the first // block in the other branch (or the convergence block if there is no other // branch) and change the OpPhi instructions in the last branch accordingly // (the predecessor changed). if (last_block_first_branch) { last_block_first_branch->terminator()->SetInOperand( 0, {first_block_last_branch_id}); // Change the OpPhi instructions of the last branch (if there is another // branch) so that the predecessor is now the last block of the first // branch. The block must have a single predecessor, so the operand // specifying the predecessor is always in the same position. if (first_block_last_branch_id != convergence_block_id) { ir_context->get_instr_block(first_block_last_branch_id) ->ForEachPhiInst( [&last_block_first_branch](opt::Instruction* phi_inst) { // The operand specifying the predecessor is the second input // operand. phi_inst->SetInOperand(1, {last_block_first_branch->id()}); }); } } // Invalidate all analyses ir_context->InvalidateAnalysesExceptFor(opt::IRContext::kAnalysisNone); // Now that we have finished adding blocks and ids to the module and // invalidated existing analyses, update the fact manager regarding dead // blocks and irrelevant ids. for (auto dead_block : dead_blocks) { transformation_context->GetFactManager()->AddFactBlockIsDead(dead_block); } for (auto irrelevant_id : irrelevant_ids) { transformation_context->GetFactManager()->AddFactIdIsIrrelevant( irrelevant_id); } } protobufs::Transformation TransformationFlattenConditionalBranch::ToMessage() const { protobufs::Transformation result; *result.mutable_flatten_conditional_branch() = message_; return result; } bool TransformationFlattenConditionalBranch:: GetProblematicInstructionsIfConditionalCanBeFlattened( opt::IRContext* ir_context, opt::BasicBlock* header, const TransformationContext& transformation_context, std::set* instructions_that_need_ids) { uint32_t merge_block_id = header->MergeBlockIdIfAny(); assert(merge_block_id && header->GetMergeInst()->opcode() == spv::Op::OpSelectionMerge && header->terminator()->opcode() == spv::Op::OpBranchConditional && "|header| must be the header of a conditional."); // |header| must be reachable. if (!ir_context->IsReachable(*header)) { return false; } auto enclosing_function = header->GetParent(); auto dominator_analysis = ir_context->GetDominatorAnalysis(enclosing_function); auto postdominator_analysis = ir_context->GetPostDominatorAnalysis(enclosing_function); // Check that the header and the merge block describe a single-entry, // single-exit region. if (!dominator_analysis->Dominates(header->id(), merge_block_id) || !postdominator_analysis->Dominates(merge_block_id, header->id())) { return false; } // Traverse the CFG starting from the header and check that, for all the // blocks that can be reached by the header before the flow converges: // - they don't contain merge, barrier or OpSampledImage instructions // - they branch unconditionally to another block // Add any side-effecting instruction, requiring fresh ids, to // |instructions_that_need_ids| std::queue to_check; header->ForEachSuccessorLabel( [&to_check](uint32_t label) { to_check.push(label); }); auto* structured_cfg = ir_context->GetStructuredCFGAnalysis(); while (!to_check.empty()) { uint32_t block_id = to_check.front(); to_check.pop(); if (structured_cfg->ContainingConstruct(block_id) != header->id() && block_id != merge_block_id) { // This block can be reached from the |header| but doesn't belong to its // selection construct. This might be a continue target of some loop - // we can't flatten the |header|. return false; } // If the block post-dominates the header, this is where flow converges, and // we don't need to check this branch any further, because the // transformation will only change the part of the graph where flow is // divergent. if (postdominator_analysis->Dominates(block_id, header->id())) { continue; } if (!transformation_context.GetFactManager()->BlockIsDead(header->id()) && transformation_context.GetFactManager()->BlockIsDead(block_id)) { // The |header| is not dead but the |block_id| is. Since |block_id| // doesn't postdominate the |header|, CFG hasn't converged yet. Thus, we // don't flatten the construct to prevent |block_id| from becoming // executable. return false; } auto block = ir_context->cfg()->block(block_id); // The block must not have a merge instruction, because inner constructs are // not allowed. if (block->GetMergeInst()) { return false; } // The terminator instruction for the block must be OpBranch. if (block->terminator()->opcode() != spv::Op::OpBranch) { return false; } // The base objects for all data descriptors involved in synonym facts. std::unordered_set synonym_base_objects; for (auto* synonym : transformation_context.GetFactManager()->GetAllSynonyms()) { synonym_base_objects.insert(synonym->object()); } // Check all of the instructions in the block. bool all_instructions_compatible = block->WhileEachInst( [ir_context, instructions_that_need_ids, &synonym_base_objects](opt::Instruction* instruction) { // We can ignore OpLabel instructions. if (instruction->opcode() == spv::Op::OpLabel) { return true; } // If the instruction is the base object of some synonym then we // conservatively bail out: if a synonym ends up depending on an // instruction that needs to be enclosed in a side-effect wrapper then // it might no longer hold after we flatten the conditional. if (instruction->result_id() && synonym_base_objects.count(instruction->result_id())) { return false; } // If the instruction is a branch, it must be an unconditional branch. if (instruction->IsBranch()) { return instruction->opcode() == spv::Op::OpBranch; } // We cannot go ahead if we encounter an instruction that cannot be // handled. if (!InstructionCanBeHandled(ir_context, *instruction)) { return false; } // If the instruction has side effects, add it to the // |instructions_that_need_ids| set. if (!fuzzerutil::InstructionHasNoSideEffects(*instruction)) { instructions_that_need_ids->emplace(instruction); } return true; }); if (!all_instructions_compatible) { return false; } // Add the successor of this block to the list of blocks that need to be // checked. to_check.push(block->terminator()->GetSingleWordInOperand(0)); } // All the blocks are compatible with the transformation and this is indeed a // single-entry, single-exit region. return true; } bool TransformationFlattenConditionalBranch::InstructionNeedsPlaceholder( opt::IRContext* ir_context, const opt::Instruction& instruction) { assert(!fuzzerutil::InstructionHasNoSideEffects(instruction) && InstructionCanBeHandled(ir_context, instruction) && "The instruction must have side effects and it must be possible to " "enclose it inside a conditional."); if (instruction.HasResultId()) { // We need a placeholder iff the type is not Void. auto type = ir_context->get_type_mgr()->GetType(instruction.type_id()); return type && !type->AsVoid(); } return false; } std::unordered_map TransformationFlattenConditionalBranch::GetInstructionsToWrapperInfo( opt::IRContext* ir_context) const { std::unordered_map instructions_to_ids; for (const auto& wrapper_info : message_.side_effect_wrapper_info()) { auto instruction = FindInstruction(wrapper_info.instruction(), ir_context); if (instruction) { instructions_to_ids.emplace(instruction, wrapper_info); } } return instructions_to_ids; } opt::BasicBlock* TransformationFlattenConditionalBranch::EncloseInstructionInConditional( opt::IRContext* ir_context, const TransformationContext& transformation_context, opt::BasicBlock* block, opt::Instruction* instruction, const protobufs::SideEffectWrapperInfo& wrapper_info, uint32_t condition_id, bool exec_if_cond_true, std::vector* dead_blocks, std::vector* irrelevant_ids) { // Get the next instruction (it will be useful for splitting). auto next_instruction = instruction->NextNode(); // Update the module id bound. for (uint32_t id : {wrapper_info.merge_block_id(), wrapper_info.execute_block_id()}) { fuzzerutil::UpdateModuleIdBound(ir_context, id); } // Create the block where the instruction is executed by splitting the // original block. auto execute_block = block->SplitBasicBlock( ir_context, wrapper_info.execute_block_id(), fuzzerutil::GetIteratorForInstruction(block, instruction)); // Create the merge block for the conditional that we are about to create by // splitting execute_block (this will leave |instruction| as the only // instruction in |execute_block|). auto merge_block = execute_block->SplitBasicBlock( ir_context, wrapper_info.merge_block_id(), fuzzerutil::GetIteratorForInstruction(execute_block, next_instruction)); // Propagate the fact that the block is dead to the newly-created blocks. if (transformation_context.GetFactManager()->BlockIsDead(block->id())) { dead_blocks->emplace_back(execute_block->id()); dead_blocks->emplace_back(merge_block->id()); } // Initially, consider the merge block as the alternative block to branch to // if the instruction should not be executed. auto alternative_block = merge_block; // Add an unconditional branch from |execute_block| to |merge_block|. execute_block->AddInstruction(MakeUnique( ir_context, spv::Op::OpBranch, 0, 0, opt::Instruction::OperandList{ {SPV_OPERAND_TYPE_ID, {merge_block->id()}}})); // If the instruction requires a placeholder, it means that it has a result id // and its result needs to be able to be used later on, and we need to: // - add an additional block |ids.alternative_block_id| where a placeholder // result id (using fresh id |ids.placeholder_result_id|) is obtained either // by using OpCopyObject and copying |ids.value_to_copy_id| or, if such id // was not given and a suitable constant was not found, by using OpUndef. // - mark |ids.placeholder_result_id| as irrelevant // - change the result id of the instruction to a fresh id // (|ids.actual_result_id|). // - add an OpPhi instruction, which will have the original result id of the // instruction, in the merge block. if (InstructionNeedsPlaceholder(ir_context, *instruction)) { // Update the module id bound with the additional ids. for (uint32_t id : {wrapper_info.actual_result_id(), wrapper_info.alternative_block_id(), wrapper_info.placeholder_result_id()}) { fuzzerutil::UpdateModuleIdBound(ir_context, id); } // Create a new block using |fresh_ids.alternative_block_id| for its label. auto alternative_block_temp = MakeUnique( MakeUnique(ir_context, spv::Op::OpLabel, 0, wrapper_info.alternative_block_id(), opt::Instruction::OperandList{})); // Keep the original result id of the instruction in a variable. uint32_t original_result_id = instruction->result_id(); // Set the result id of the instruction to be |ids.actual_result_id|. instruction->SetResultId(wrapper_info.actual_result_id()); // Add a placeholder instruction, with the same type as the original // instruction and id |ids.placeholder_result_id|, to the new block. if (wrapper_info.value_to_copy_id()) { // If there is an available id to copy from, the placeholder instruction // will be %placeholder_result_id = OpCopyObject %type %value_to_copy_id alternative_block_temp->AddInstruction(MakeUnique( ir_context, spv::Op::OpCopyObject, instruction->type_id(), wrapper_info.placeholder_result_id(), opt::Instruction::OperandList{ {SPV_OPERAND_TYPE_ID, {wrapper_info.value_to_copy_id()}}})); } else { // If there is no such id, use an OpUndef instruction. alternative_block_temp->AddInstruction(MakeUnique( ir_context, spv::Op::OpUndef, instruction->type_id(), wrapper_info.placeholder_result_id(), opt::Instruction::OperandList{})); } // Mark |ids.placeholder_result_id| as irrelevant. irrelevant_ids->emplace_back(wrapper_info.placeholder_result_id()); // Add an unconditional branch from the new block to the merge block. alternative_block_temp->AddInstruction(MakeUnique( ir_context, spv::Op::OpBranch, 0, 0, opt::Instruction::OperandList{ {SPV_OPERAND_TYPE_ID, {merge_block->id()}}})); // Insert the block before the merge block. alternative_block = block->GetParent()->InsertBasicBlockBefore( std::move(alternative_block_temp), merge_block); // Using the original instruction result id, add an OpPhi instruction to the // merge block, which will either take the value of the result of the // instruction or the placeholder value defined in the alternative block. merge_block->begin().InsertBefore(MakeUnique( ir_context, spv::Op::OpPhi, instruction->type_id(), original_result_id, opt::Instruction::OperandList{ {SPV_OPERAND_TYPE_ID, {instruction->result_id()}}, {SPV_OPERAND_TYPE_ID, {execute_block->id()}}, {SPV_OPERAND_TYPE_ID, {wrapper_info.placeholder_result_id()}}, {SPV_OPERAND_TYPE_ID, {alternative_block->id()}}})); // Propagate the fact that the block is dead to the new block. if (transformation_context.GetFactManager()->BlockIsDead(block->id())) { dead_blocks->emplace_back(alternative_block->id()); } } // Depending on whether the instruction should be executed in the if branch or // in the else branch, get the corresponding ids. auto if_block_id = (exec_if_cond_true ? execute_block : alternative_block) ->GetLabel() ->result_id(); auto else_block_id = (exec_if_cond_true ? alternative_block : execute_block) ->GetLabel() ->result_id(); // Add an OpSelectionMerge instruction to the block. block->AddInstruction(MakeUnique( ir_context, spv::Op::OpSelectionMerge, 0, 0, opt::Instruction::OperandList{ {SPV_OPERAND_TYPE_ID, {merge_block->id()}}, {SPV_OPERAND_TYPE_SELECTION_CONTROL, {uint32_t(spv::SelectionControlMask::MaskNone)}}})); // Add an OpBranchConditional, to the block, using |condition_id| as the // condition and branching to |if_block_id| if the condition is true and to // |else_block_id| if the condition is false. block->AddInstruction(MakeUnique( ir_context, spv::Op::OpBranchConditional, 0, 0, opt::Instruction::OperandList{{SPV_OPERAND_TYPE_ID, {condition_id}}, {SPV_OPERAND_TYPE_ID, {if_block_id}}, {SPV_OPERAND_TYPE_ID, {else_block_id}}})); return merge_block; } bool TransformationFlattenConditionalBranch::InstructionCanBeHandled( opt::IRContext* ir_context, const opt::Instruction& instruction) { // We can handle all instructions with no side effects. if (fuzzerutil::InstructionHasNoSideEffects(instruction)) { return true; } // We cannot handle barrier instructions, while we should be able to handle // all other instructions by enclosing them inside a conditional. if (instruction.opcode() == spv::Op::OpControlBarrier || instruction.opcode() == spv::Op::OpMemoryBarrier || instruction.opcode() == spv::Op::OpNamedBarrierInitialize || instruction.opcode() == spv::Op::OpMemoryNamedBarrier || instruction.opcode() == spv::Op::OpTypeNamedBarrier) { return false; } // We cannot handle OpSampledImage instructions, as they need to be in the // same block as their use. if (instruction.opcode() == spv::Op::OpSampledImage) { return false; } // We cannot handle a sampled image load, because we re-work loads using // conditional branches and OpPhi instructions, and the result type of OpPhi // cannot be OpTypeSampledImage. if (instruction.opcode() == spv::Op::OpLoad && ir_context->get_def_use_mgr()->GetDef(instruction.type_id())->opcode() == spv::Op::OpTypeSampledImage) { return false; } // We cannot handle instructions with an id which return a void type, if the // result id is used in the module (e.g. a function call to a function that // returns nothing). if (instruction.HasResultId()) { auto type = ir_context->get_type_mgr()->GetType(instruction.type_id()); assert(type && "The type should be found in the module"); if (type->AsVoid() && !ir_context->get_def_use_mgr()->WhileEachUse( instruction.result_id(), [](opt::Instruction* use_inst, uint32_t use_index) { // Return false if the id is used as an input operand. return use_index < use_inst->NumOperands() - use_inst->NumInOperands(); })) { return false; } } return true; } std::unordered_set TransformationFlattenConditionalBranch::GetFreshIds() const { std::unordered_set result = { message_.fresh_id_for_bvec2_selector(), message_.fresh_id_for_bvec3_selector(), message_.fresh_id_for_bvec4_selector()}; for (auto& side_effect_wrapper_info : message_.side_effect_wrapper_info()) { result.insert(side_effect_wrapper_info.merge_block_id()); result.insert(side_effect_wrapper_info.execute_block_id()); result.insert(side_effect_wrapper_info.actual_result_id()); result.insert(side_effect_wrapper_info.alternative_block_id()); result.insert(side_effect_wrapper_info.placeholder_result_id()); } return result; } uint32_t TransformationFlattenConditionalBranch::FindConvergenceBlock( opt::IRContext* ir_context, const opt::BasicBlock& header_block) { uint32_t result = header_block.terminator()->GetSingleWordInOperand(1); auto postdominator_analysis = ir_context->GetPostDominatorAnalysis(header_block.GetParent()); while (!postdominator_analysis->Dominates(result, header_block.id())) { auto current_block = ir_context->get_instr_block(result); // If the transformation is applicable, the terminator is OpBranch. result = current_block->terminator()->GetSingleWordInOperand(0); } return result; } bool TransformationFlattenConditionalBranch::OpSelectArgumentsAreRestricted( opt::IRContext* ir_context) { switch (ir_context->grammar().target_env()) { case SPV_ENV_UNIVERSAL_1_0: case SPV_ENV_UNIVERSAL_1_1: case SPV_ENV_UNIVERSAL_1_2: case SPV_ENV_UNIVERSAL_1_3: case SPV_ENV_VULKAN_1_0: case SPV_ENV_VULKAN_1_1: { return true; } default: return false; } } void TransformationFlattenConditionalBranch::AddBooleanVectorConstructorToBlock( uint32_t fresh_id, uint32_t dimension, const opt::Operand& branch_condition_operand, opt::IRContext* ir_context, opt::BasicBlock* block) { opt::Instruction::OperandList in_operands; for (uint32_t i = 0; i < dimension; i++) { in_operands.emplace_back(branch_condition_operand); } block->begin()->InsertBefore(MakeUnique( ir_context, spv::Op::OpCompositeConstruct, fuzzerutil::MaybeGetVectorType( ir_context, fuzzerutil::MaybeGetBoolType(ir_context), dimension), fresh_id, in_operands)); fuzzerutil::UpdateModuleIdBound(ir_context, fresh_id); } void TransformationFlattenConditionalBranch:: RewriteOpPhiInstructionsAtConvergenceBlock( const opt::BasicBlock& header_block, uint32_t convergence_block_id, opt::IRContext* ir_context) const { const opt::Instruction& branch_instruction = *header_block.terminator(); const opt::Operand& branch_condition_operand = branch_instruction.GetInOperand(0); // If we encounter OpPhi instructions on vector types then we may need to // introduce vector versions of the selection construct's condition to use // in corresponding OpSelect instructions. These booleans track whether we // need to introduce such boolean vectors. bool require_2d_boolean_vector = false; bool require_3d_boolean_vector = false; bool require_4d_boolean_vector = false; // Consider every OpPhi instruction at the convergence block. opt::BasicBlock* convergence_block = ir_context->get_instr_block(convergence_block_id); convergence_block->ForEachPhiInst( [this, &branch_condition_operand, branch_instruction, convergence_block_id, &header_block, ir_context, &require_2d_boolean_vector, &require_3d_boolean_vector, &require_4d_boolean_vector](opt::Instruction* phi_inst) { assert(phi_inst->NumInOperands() == 4 && "We are going to replace an OpPhi with an OpSelect. This " "only makes sense if the block has two distinct " "predecessors."); // We are going to replace the OpPhi with an OpSelect. By default, // the condition for the OpSelect will be the branch condition's // operand. However, if the OpPhi has vector result type we may need // to use a boolean vector as the condition instead. opt::Operand selector_operand = branch_condition_operand; opt::Instruction* type_inst = ir_context->get_def_use_mgr()->GetDef(phi_inst->type_id()); if (type_inst->opcode() == spv::Op::OpTypeVector) { uint32_t dimension = type_inst->GetSingleWordInOperand(1); switch (dimension) { case 2: // The OpPhi's result type is a 2D vector. If a fresh id for a // bvec2 selector was provided then we should use it as the // OpSelect's condition, and note the fact that we will need to // add an instruction to bring this bvec2 into existence. if (message_.fresh_id_for_bvec2_selector() != 0) { selector_operand = {SPV_OPERAND_TYPE_ID, {message_.fresh_id_for_bvec2_selector()}}; require_2d_boolean_vector = true; } break; case 3: // Similar to the 2D case. if (message_.fresh_id_for_bvec3_selector() != 0) { selector_operand = {SPV_OPERAND_TYPE_ID, {message_.fresh_id_for_bvec3_selector()}}; require_3d_boolean_vector = true; } break; case 4: // Similar to the 2D case. if (message_.fresh_id_for_bvec4_selector() != 0) { selector_operand = {SPV_OPERAND_TYPE_ID, {message_.fresh_id_for_bvec4_selector()}}; require_4d_boolean_vector = true; } break; default: assert(dimension == 4 && "Invalid vector dimension."); break; } } std::vector operands; operands.emplace_back(selector_operand); uint32_t branch_instruction_true_block_id = branch_instruction.GetSingleWordInOperand(1); uint32_t branch_instruction_false_block_id = branch_instruction.GetSingleWordInOperand(2); // The OpPhi takes values from two distinct predecessors. One // predecessor is associated with the "true" path of the conditional // we are flattening, the other with the "false" path, but these // predecessors can appear in either order as operands to the OpPhi // instruction. We determine in which order the OpPhi inputs should // appear as OpSelect arguments by first checking whether the // convergence block is a direct successor of the selection header, and // otherwise checking dominance of the true and false immediate // successors of the header block. if (branch_instruction_true_block_id == convergence_block_id) { // The branch instruction's true block is the convergence block. This // means that the OpPhi's value associated with the branch // instruction's block should the "true" result of the OpSelect. assert(branch_instruction_false_block_id != convergence_block_id && "Control should not reach here if both branches target the " "convergence block."); if (phi_inst->GetSingleWordInOperand(1) == message_.header_block_id()) { operands.emplace_back(phi_inst->GetInOperand(0)); operands.emplace_back(phi_inst->GetInOperand(2)); } else { assert(phi_inst->GetSingleWordInOperand(3) == message_.header_block_id() && "Since the convergence block has the header block as one of " "two predecessors, if it is not handled by the first pair " "of operands of this OpPhi instruction it should be handled " "by the second pair."); operands.emplace_back(phi_inst->GetInOperand(2)); operands.emplace_back(phi_inst->GetInOperand(0)); } } else if (branch_instruction_false_block_id == convergence_block_id) { // The branch instruction's false block is the convergence block. This // means that the OpPhi's value associated with the branch // instruction's block should the "false" result of the OpSelect. if (phi_inst->GetSingleWordInOperand(1) == message_.header_block_id()) { operands.emplace_back(phi_inst->GetInOperand(2)); operands.emplace_back(phi_inst->GetInOperand(0)); } else { assert(phi_inst->GetSingleWordInOperand(3) == message_.header_block_id() && "Since the convergence block has the header block as one of " "two predecessors, if it is not handled by the first pair " "of operands of this OpPhi instruction it should be handled " "by the second pair."); operands.emplace_back(phi_inst->GetInOperand(0)); operands.emplace_back(phi_inst->GetInOperand(2)); } } else if (ir_context->GetDominatorAnalysis(header_block.GetParent()) ->Dominates(branch_instruction_true_block_id, phi_inst->GetSingleWordInOperand(1))) { // The "true" branch of the conditional is handled first in the // OpPhi's operands; we thus provide operands to OpSelect in the same // order that they appear in the OpPhi. operands.emplace_back(phi_inst->GetInOperand(0)); operands.emplace_back(phi_inst->GetInOperand(2)); } else { // The "false" branch of the conditional is handled first in the // OpPhi's operands; we thus provide operands to OpSelect in reverse // of the order that they appear in the OpPhi. operands.emplace_back(phi_inst->GetInOperand(2)); operands.emplace_back(phi_inst->GetInOperand(0)); } phi_inst->SetOpcode(spv::Op::OpSelect); phi_inst->SetInOperands(std::move(operands)); }); // Add boolean vector instructions to the start of the block as required. if (require_2d_boolean_vector) { AddBooleanVectorConstructorToBlock(message_.fresh_id_for_bvec2_selector(), 2, branch_condition_operand, ir_context, convergence_block); } if (require_3d_boolean_vector) { AddBooleanVectorConstructorToBlock(message_.fresh_id_for_bvec3_selector(), 3, branch_condition_operand, ir_context, convergence_block); } if (require_4d_boolean_vector) { AddBooleanVectorConstructorToBlock(message_.fresh_id_for_bvec4_selector(), 4, branch_condition_operand, ir_context, convergence_block); } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_flatten_conditional_branch.h000066400000000000000000000171441475742701700316720ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_FLATTEN_CONDITIONAL_BRANCH_H_ #define SOURCE_FUZZ_TRANSFORMATION_FLATTEN_CONDITIONAL_BRANCH_H_ #include "source/fuzz/transformation.h" namespace spvtools { namespace fuzz { class TransformationFlattenConditionalBranch : public Transformation { public: explicit TransformationFlattenConditionalBranch( protobufs::TransformationFlattenConditionalBranch message); TransformationFlattenConditionalBranch( uint32_t header_block_id, bool true_branch_first, uint32_t fresh_id_for_bvec2_selector, uint32_t fresh_id_for_bvec3_selector, uint32_t fresh_id_for_bvec4_selector, const std::vector& side_effect_wrappers_info); // - |message_.header_block_id| must be the label id of a reachable selection // header, which ends with an OpBranchConditional instruction. // - The condition of the OpBranchConditional instruction must not be an // irrelevant id. // - The header block and the merge block must describe a single-entry, // single-exit region. // - The region must not contain barrier or OpSampledImage instructions. // - The region must not contain selection or loop constructs. // - The region must not define ids that are the base objects for existing // synonym facts. // - For each instruction that requires additional fresh ids, then: // - if the instruction is mapped to the required ids for enclosing it by // |message_.side_effect_wrapper_info|, these must be valid (the // fresh ids must be non-zero, fresh and distinct); // - if there is no such mapping, the transformation context must have // overflow ids available. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Flattens the selection construct with header |message_.header_block_id|, // changing any OpPhi in the block where the flow converges to OpSelect and // enclosing any instruction with side effects in conditionals so that // they are only executed when they should. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; // Returns true if the conditional headed by |header| can be flattened, // according to the conditions of the IsApplicable method, assuming that // enough fresh ids would be provided. In this case, it fills the // |instructions_that_need_ids| set with all the instructions that would // require fresh ids. // Returns false otherwise. // Assumes that |header| is the header of a conditional, so its last two // instructions are OpSelectionMerge and OpBranchConditional. static bool GetProblematicInstructionsIfConditionalCanBeFlattened( opt::IRContext* ir_context, opt::BasicBlock* header, const TransformationContext& transformation_context, std::set* instructions_that_need_ids); // Returns true iff the given instruction needs a placeholder to be enclosed // inside a conditional. So, it returns: // - true if the instruction has a non-void result id, // - false if the instruction does not have a result id or has a void result // id. // Assumes that the instruction has side effects, requiring it to be enclosed // inside a conditional, and that it can be enclosed inside a conditional // keeping the module valid. Assumes that, if the instruction has a void // result type, its result id is not used in the module. static bool InstructionNeedsPlaceholder(opt::IRContext* ir_context, const opt::Instruction& instruction); // Returns true if and only if the SPIR-V version is such that the arguments // to OpSelect are restricted to only scalars, pointers (if the appropriate // capability is enabled) and component-wise vectors. static bool OpSelectArgumentsAreRestricted(opt::IRContext* ir_context); // Find the first block where flow converges (it is not necessarily the merge // block) by walking the true branch until reaching a block that post- // dominates the header. // This is necessary because a potential common set of blocks at the end of // the construct should not be duplicated. static uint32_t FindConvergenceBlock(opt::IRContext* ir_context, const opt::BasicBlock& header_block); private: // Returns an unordered_map mapping instructions to the info required to // enclose them inside a conditional. It maps the instructions to the // corresponding entry in |message_.side_effect_wrapper_info|. std::unordered_map GetInstructionsToWrapperInfo(opt::IRContext* ir_context) const; // Splits the given block, adding a new selection construct so that the given // instruction is only executed if the boolean value of |condition_id| matches // the value of |exec_if_cond_true|. // Assumes that all parameters are consistent. // 2 fresh ids are required if the instruction does not have a result id (the // first two ids in |wrapper_info| must be valid fresh ids), 5 otherwise. // Returns the merge block created. // // |dead_blocks| and |irrelevant_ids| are used to record the ids of blocks // and instructions for which dead block and irrelevant id facts should // ultimately be created. static opt::BasicBlock* EncloseInstructionInConditional( opt::IRContext* ir_context, const TransformationContext& transformation_context, opt::BasicBlock* block, opt::Instruction* instruction, const protobufs::SideEffectWrapperInfo& wrapper_info, uint32_t condition_id, bool exec_if_cond_true, std::vector* dead_blocks, std::vector* irrelevant_ids); // Turns every OpPhi instruction of |convergence_block| -- the convergence // block for |header_block| (both in |ir_context|) into an OpSelect // instruction. void RewriteOpPhiInstructionsAtConvergenceBlock( const opt::BasicBlock& header_block, uint32_t convergence_block_id, opt::IRContext* ir_context) const; // Adds an OpCompositeExtract instruction to the start of |block| in // |ir_context|, with result id given by |fresh_id|. The instruction will // make a |dimension|-dimensional boolean vector with // |branch_condition_operand| at every component. static void AddBooleanVectorConstructorToBlock( uint32_t fresh_id, uint32_t dimension, const opt::Operand& branch_condition_operand, opt::IRContext* ir_context, opt::BasicBlock* block); // Returns true if the given instruction either has no side effects or it can // be handled by being enclosed in a conditional. static bool InstructionCanBeHandled(opt::IRContext* ir_context, const opt::Instruction& instruction); protobufs::TransformationFlattenConditionalBranch message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_FLATTEN_CONDITIONAL_BRANCH_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_function_call.cpp000066400000000000000000000161771475742701700275150ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_function_call.h" #include "source/fuzz/call_graph.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" namespace spvtools { namespace fuzz { TransformationFunctionCall::TransformationFunctionCall( protobufs::TransformationFunctionCall message) : message_(std::move(message)) {} TransformationFunctionCall::TransformationFunctionCall( uint32_t fresh_id, uint32_t callee_id, const std::vector& argument_id, const protobufs::InstructionDescriptor& instruction_to_insert_before) { message_.set_fresh_id(fresh_id); message_.set_callee_id(callee_id); for (auto argument : argument_id) { message_.add_argument_id(argument); } *message_.mutable_instruction_to_insert_before() = instruction_to_insert_before; } bool TransformationFunctionCall::IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const { // The result id must be fresh if (!fuzzerutil::IsFreshId(ir_context, message_.fresh_id())) { return false; } // The function must exist auto callee_inst = ir_context->get_def_use_mgr()->GetDef(message_.callee_id()); if (!callee_inst || callee_inst->opcode() != spv::Op::OpFunction) { return false; } // The function must not be an entry point if (fuzzerutil::FunctionIsEntryPoint(ir_context, message_.callee_id())) { return false; } auto callee_type_inst = ir_context->get_def_use_mgr()->GetDef( callee_inst->GetSingleWordInOperand(1)); assert(callee_type_inst->opcode() == spv::Op::OpTypeFunction && "Bad function type."); // The number of expected function arguments must match the number of given // arguments. The number of expected arguments is one less than the function // type's number of input operands, as one operand is for the return type. if (callee_type_inst->NumInOperands() - 1 != static_cast(message_.argument_id().size())) { return false; } // The instruction descriptor must refer to a position where it is valid to // insert the call auto insert_before = FindInstruction(message_.instruction_to_insert_before(), ir_context); if (!insert_before) { return false; } if (!fuzzerutil::CanInsertOpcodeBeforeInstruction(spv::Op::OpFunctionCall, insert_before)) { return false; } auto block = ir_context->get_instr_block(insert_before); auto enclosing_function = block->GetParent(); // If the block is not dead, the function must be livesafe bool block_is_dead = transformation_context.GetFactManager()->BlockIsDead(block->id()); if (!block_is_dead && !transformation_context.GetFactManager()->FunctionIsLivesafe( message_.callee_id())) { return false; } // The ids must all match and have the right types and satisfy rules on // pointers. If the block is not dead, pointers must be arbitrary. for (uint32_t arg_index = 0; arg_index < static_cast(message_.argument_id().size()); arg_index++) { opt::Instruction* arg_inst = ir_context->get_def_use_mgr()->GetDef(message_.argument_id(arg_index)); if (!arg_inst) { // The given argument does not correspond to an instruction. return false; } if (!arg_inst->type_id()) { // The given argument does not have a type; it is thus not suitable. } if (arg_inst->type_id() != callee_type_inst->GetSingleWordInOperand(arg_index + 1)) { // Argument type mismatch. return false; } opt::Instruction* arg_type_inst = ir_context->get_def_use_mgr()->GetDef(arg_inst->type_id()); if (arg_type_inst->opcode() == spv::Op::OpTypePointer) { switch (arg_inst->opcode()) { case spv::Op::OpFunctionParameter: case spv::Op::OpVariable: // These are OK break; default: // Other pointer ids cannot be passed as parameters return false; } if (!block_is_dead && !transformation_context.GetFactManager()->PointeeValueIsIrrelevant( arg_inst->result_id())) { // This is not a dead block, so pointer parameters passed to the called // function might really have their contents modified. We thus require // such pointers to be to arbitrary-valued variables, which this is not. return false; } } // The argument id needs to be available (according to dominance rules) at // the point where the call will occur. if (!fuzzerutil::IdIsAvailableBeforeInstruction(ir_context, insert_before, arg_inst->result_id())) { return false; } } // Introducing the call must not lead to recursion. if (message_.callee_id() == enclosing_function->result_id()) { // This would be direct recursion. return false; } // Ensure the call would not lead to indirect recursion. return !CallGraph(ir_context) .GetIndirectCallees(message_.callee_id()) .count(block->GetParent()->result_id()); } void TransformationFunctionCall::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { // Update the module's bound to reflect the fresh id for the result of the // function call. fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id()); // Get the return type of the function being called. uint32_t return_type = ir_context->get_def_use_mgr()->GetDef(message_.callee_id())->type_id(); // Populate the operands to the call instruction, with the function id and the // arguments. opt::Instruction::OperandList operands; operands.push_back({SPV_OPERAND_TYPE_ID, {message_.callee_id()}}); for (auto arg : message_.argument_id()) { operands.push_back({SPV_OPERAND_TYPE_ID, {arg}}); } // Insert the function call before the instruction specified in the message. FindInstruction(message_.instruction_to_insert_before(), ir_context) ->InsertBefore(MakeUnique( ir_context, spv::Op::OpFunctionCall, return_type, message_.fresh_id(), operands)); // Invalidate all analyses since we have changed the module. ir_context->InvalidateAnalysesExceptFor(opt::IRContext::kAnalysisNone); } protobufs::Transformation TransformationFunctionCall::ToMessage() const { protobufs::Transformation result; *result.mutable_function_call() = message_; return result; } std::unordered_set TransformationFunctionCall::GetFreshIds() const { return {message_.fresh_id()}; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_function_call.h000066400000000000000000000052661475742701700271570ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_FUNCTION_CALL_H_ #define SOURCE_FUZZ_TRANSFORMATION_FUNCTION_CALL_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationFunctionCall : public Transformation { public: explicit TransformationFunctionCall( protobufs::TransformationFunctionCall message); TransformationFunctionCall( uint32_t fresh_id, uint32_t callee_id, const std::vector& argument_id, const protobufs::InstructionDescriptor& instruction_to_insert_before); // - |message_.fresh_id| must be fresh // - |message_.instruction_to_insert_before| must identify an instruction // before which an OpFunctionCall can be legitimately inserted // - |message_.function_id| must be the id of a function, and calling the // function before the identified instruction must not introduce recursion // - |message_.arg_id| must provide suitable arguments for the function call // (they must have the right types and be available according to dominance // rules) // - If the insertion point is not in a dead block then |message_function_id| // must refer to a livesafe function, and every pointer argument in // |message_.arg_id| must refer to an arbitrary-valued variable bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Adds an instruction of the form: // |fresh_id| = OpFunctionCall %type |callee_id| |arg_id...| // before |instruction_to_insert_before|, where %type is the return type of // |callee_id|. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationFunctionCall message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_FUNCTION_CALL_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_inline_function.cpp000066400000000000000000000346501475742701700300540ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_inline_function.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" namespace spvtools { namespace fuzz { TransformationInlineFunction::TransformationInlineFunction( protobufs::TransformationInlineFunction message) : message_(std::move(message)) {} TransformationInlineFunction::TransformationInlineFunction( uint32_t function_call_id, const std::map& result_id_map) { message_.set_function_call_id(function_call_id); *message_.mutable_result_id_map() = fuzzerutil::MapToRepeatedUInt32Pair(result_id_map); } bool TransformationInlineFunction::IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const { // The values in the |message_.result_id_map| must be all fresh and all // distinct. const auto result_id_map = fuzzerutil::RepeatedUInt32PairToMap(message_.result_id_map()); std::set ids_used_by_this_transformation; for (auto& pair : result_id_map) { if (!CheckIdIsFreshAndNotUsedByThisTransformation( pair.second, ir_context, &ids_used_by_this_transformation)) { return false; } } // |function_call_instruction| must be suitable for inlining. auto* function_call_instruction = ir_context->get_def_use_mgr()->GetDef(message_.function_call_id()); if (!IsSuitableForInlining(ir_context, function_call_instruction)) { return false; } // |function_call_instruction| must be the penultimate instruction in its // block and its block termination instruction must be an OpBranch. This // avoids the case where the penultimate instruction is an OpLoopMerge, which // would make the back-edge block not branch to the loop header. auto* function_call_instruction_block = ir_context->get_instr_block(function_call_instruction); if (function_call_instruction != &*--function_call_instruction_block->tail() || function_call_instruction_block->terminator()->opcode() != spv::Op::OpBranch) { return false; } auto* called_function = fuzzerutil::FindFunction( ir_context, function_call_instruction->GetSingleWordInOperand(0)); for (auto& block : *called_function) { // Since the entry block label will not be inlined, only the remaining // labels must have a corresponding value in the map. if (&block != &*called_function->entry() && !result_id_map.count(block.id()) && !transformation_context.GetOverflowIdSource()->HasOverflowIds()) { return false; } // |result_id_map| must have an entry for every result id in the called // function. for (auto& instruction : block) { // If |instruction| has result id, then it must have a mapped id in // |result_id_map|. if (instruction.HasResultId() && !result_id_map.count(instruction.result_id()) && !transformation_context.GetOverflowIdSource()->HasOverflowIds()) { return false; } } } // |result_id_map| must not contain an entry for any parameter of the function // that is being inlined. bool found_entry_for_parameter = false; called_function->ForEachParam( [&result_id_map, &found_entry_for_parameter](opt::Instruction* param) { if (result_id_map.count(param->result_id())) { found_entry_for_parameter = true; } }); return !found_entry_for_parameter; } void TransformationInlineFunction::Apply( opt::IRContext* ir_context, TransformationContext* transformation_context) const { auto* function_call_instruction = ir_context->get_def_use_mgr()->GetDef(message_.function_call_id()); auto* caller_function = ir_context->get_instr_block(function_call_instruction)->GetParent(); auto* called_function = fuzzerutil::FindFunction( ir_context, function_call_instruction->GetSingleWordInOperand(0)); std::map result_id_map = fuzzerutil::RepeatedUInt32PairToMap(message_.result_id_map()); // If there are gaps in the result id map, fill them using overflow ids. for (auto& block : *called_function) { if (&block != &*called_function->entry() && !result_id_map.count(block.id())) { result_id_map.insert( {block.id(), transformation_context->GetOverflowIdSource()->GetNextOverflowId()}); } for (auto& instruction : block) { // If |instruction| has result id, then it must have a mapped id in // |result_id_map|. if (instruction.HasResultId() && !result_id_map.count(instruction.result_id())) { result_id_map.insert({instruction.result_id(), transformation_context->GetOverflowIdSource() ->GetNextOverflowId()}); } } } auto* successor_block = ir_context->cfg()->block( ir_context->get_instr_block(function_call_instruction) ->terminator() ->GetSingleWordInOperand(0)); // Inline the |called_function| entry block. for (auto& entry_block_instruction : *called_function->entry()) { opt::Instruction* inlined_instruction; if (entry_block_instruction.opcode() == spv::Op::OpVariable) { // All OpVariable instructions in a function must be in the first block // in the function. inlined_instruction = caller_function->begin()->begin()->InsertBefore( std::unique_ptr( entry_block_instruction.Clone(ir_context))); } else { inlined_instruction = function_call_instruction->InsertBefore( std::unique_ptr( entry_block_instruction.Clone(ir_context))); } AdaptInlinedInstruction(result_id_map, ir_context, inlined_instruction); } // If the function call's successor block contains OpPhi instructions that // refer to the block containing the call then these will need to be rewritten // to instead refer to the block associated with "returning" from the inlined // function, as this block will be the predecessor of what used to be the // function call's successor block. We look out for this block. uint32_t new_return_block_id = 0; // Inline the |called_function| non-entry blocks. for (auto& block : *called_function) { if (&block == &*called_function->entry()) { continue; } // Check whether this is the function's return block. Take note if it is, // so that OpPhi instructions in the successor of the original function call // block can be re-written. if (block.terminator()->IsReturn()) { assert(new_return_block_id == 0 && "There should be only one return block."); new_return_block_id = result_id_map.at(block.id()); } auto* cloned_block = block.Clone(ir_context); cloned_block = caller_function->InsertBasicBlockBefore( std::unique_ptr(cloned_block), successor_block); cloned_block->GetLabel()->SetResultId(result_id_map.at(cloned_block->id())); fuzzerutil::UpdateModuleIdBound(ir_context, cloned_block->id()); for (auto& inlined_instruction : *cloned_block) { AdaptInlinedInstruction(result_id_map, ir_context, &inlined_instruction); } } opt::BasicBlock* block_containing_function_call = ir_context->get_instr_block(function_call_instruction); assert(((new_return_block_id == 0) == called_function->entry()->terminator()->IsReturn()) && "We should have found a return block unless the function being " "inlined returns in its first block."); if (new_return_block_id != 0) { // Rewrite any OpPhi instructions in the successor block so that they refer // to the new return block instead of the block that originally contained // the function call. ir_context->get_def_use_mgr()->ForEachUse( block_containing_function_call->id(), [ir_context, new_return_block_id, successor_block]( opt::Instruction* use_instruction, uint32_t operand_index) { if (use_instruction->opcode() == spv::Op::OpPhi && ir_context->get_instr_block(use_instruction) == successor_block) { use_instruction->SetOperand(operand_index, {new_return_block_id}); } }); } // Removes the function call instruction and its block termination instruction // from |caller_function|. ir_context->KillInst(block_containing_function_call->terminator()); ir_context->KillInst(function_call_instruction); // Since the SPIR-V module has changed, no analyses must be validated. ir_context->InvalidateAnalysesExceptFor( opt::IRContext::Analysis::kAnalysisNone); } protobufs::Transformation TransformationInlineFunction::ToMessage() const { protobufs::Transformation result; *result.mutable_inline_function() = message_; return result; } bool TransformationInlineFunction::IsSuitableForInlining( opt::IRContext* ir_context, opt::Instruction* function_call_instruction) { // |function_call_instruction| must be defined and must be an OpFunctionCall // instruction. if (!function_call_instruction || function_call_instruction->opcode() != spv::Op::OpFunctionCall) { return false; } // If |function_call_instruction| return type is void, then // |function_call_instruction| must not have uses. if (ir_context->get_type_mgr() ->GetType(function_call_instruction->type_id()) ->AsVoid() && ir_context->get_def_use_mgr()->NumUses(function_call_instruction) != 0) { return false; } // |called_function| must not have an early return. auto called_function = fuzzerutil::FindFunction( ir_context, function_call_instruction->GetSingleWordInOperand(0)); if (called_function->HasEarlyReturn()) { return false; } // |called_function| must not use OpKill or OpUnreachable. if (fuzzerutil::FunctionContainsOpKillOrUnreachable(*called_function)) { return false; } return true; } void TransformationInlineFunction::AdaptInlinedInstruction( const std::map& result_id_map, opt::IRContext* ir_context, opt::Instruction* instruction_to_be_inlined) const { auto* function_call_instruction = ir_context->get_def_use_mgr()->GetDef(message_.function_call_id()); auto* called_function = fuzzerutil::FindFunction( ir_context, function_call_instruction->GetSingleWordInOperand(0)); const auto* function_call_block = ir_context->get_instr_block(function_call_instruction); assert(function_call_block && "OpFunctionCall must belong to some block"); // Replaces the operand ids with their mapped result ids. instruction_to_be_inlined->ForEachInId( [called_function, function_call_instruction, &result_id_map, function_call_block](uint32_t* id) { // We are not inlining the entry block of the |called_function|. // // We must check this condition first since we can't use the fresh id // from |result_id_map| even if it has one. This is because that fresh // id will never be added to the module since entry blocks are not // inlined. if (*id == called_function->entry()->id()) { *id = function_call_block->id(); return; } // If |id| is mapped, then set it to its mapped value. if (result_id_map.count(*id)) { *id = result_id_map.at(*id); return; } uint32_t parameter_index = 0; called_function->ForEachParam( [id, function_call_instruction, ¶meter_index](opt::Instruction* parameter_instruction) { // If the id is a function parameter, then set it to the // parameter value passed in the function call instruction. if (*id == parameter_instruction->result_id()) { // We do + 1 because the first in-operand for OpFunctionCall is // the function id that is being called. *id = function_call_instruction->GetSingleWordInOperand( parameter_index + 1); } parameter_index++; }); }); // If |instruction_to_be_inlined| has result id, then set it to its mapped // value. if (instruction_to_be_inlined->HasResultId()) { assert(result_id_map.count(instruction_to_be_inlined->result_id()) && "Result id must be mapped to a fresh id."); instruction_to_be_inlined->SetResultId( result_id_map.at(instruction_to_be_inlined->result_id())); fuzzerutil::UpdateModuleIdBound(ir_context, instruction_to_be_inlined->result_id()); } // The return instruction will be changed into an OpBranch to the basic // block that follows the block containing the function call. if (spvOpcodeIsReturn(instruction_to_be_inlined->opcode())) { uint32_t successor_block_id = ir_context->get_instr_block(function_call_instruction) ->terminator() ->GetSingleWordInOperand(0); switch (instruction_to_be_inlined->opcode()) { case spv::Op::OpReturn: instruction_to_be_inlined->AddOperand( {SPV_OPERAND_TYPE_ID, {successor_block_id}}); break; case spv::Op::OpReturnValue: { instruction_to_be_inlined->InsertBefore(MakeUnique( ir_context, spv::Op::OpCopyObject, function_call_instruction->type_id(), function_call_instruction->result_id(), opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {instruction_to_be_inlined->GetSingleWordOperand(0)}}}))); instruction_to_be_inlined->SetInOperand(0, {successor_block_id}); break; } default: break; } instruction_to_be_inlined->SetOpcode(spv::Op::OpBranch); } } std::unordered_set TransformationInlineFunction::GetFreshIds() const { std::unordered_set result; for (auto& pair : message_.result_id_map()) { result.insert(pair.second()); } return result; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_inline_function.h000066400000000000000000000061731475742701700275200ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_INLINE_FUNCTION_H_ #define SOURCE_FUZZ_TRANSFORMATION_INLINE_FUNCTION_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationInlineFunction : public Transformation { public: explicit TransformationInlineFunction( protobufs::TransformationInlineFunction message); TransformationInlineFunction( uint32_t function_call_id, const std::map& result_id_map); // - |message_.result_id_map| must map the instructions of the called function // to fresh ids, unless overflow ids are available. // - |message_.function_call_id| must be an OpFunctionCall instruction. // It must not have an early return and must not use OpUnreachable or // OpKill. This is to guard against making the module invalid when the // caller is inside a continue construct. // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/3735): // Allow functions that use OpKill or OpUnreachable to be inlined if the // function call is not part of a continue construct. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Replaces the OpFunctionCall instruction, identified by // |message_.function_call_id|, with a copy of the function's body. // |message_.result_id_map| is used to provide fresh ids for duplicate // instructions. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; // Returns true if |function_call_instruction| is defined, is an // OpFunctionCall instruction, has no uses if its return type is void, has no // early returns and has no uses of OpKill or OpUnreachable. static bool IsSuitableForInlining( opt::IRContext* ir_context, opt::Instruction* function_call_instruction); private: protobufs::TransformationInlineFunction message_; // Inline |instruction_to_be_inlined| by setting its ids to the corresponding // ids in |result_id_map|. void AdaptInlinedInstruction( const std::map& result_id_map, opt::IRContext* ir_context, opt::Instruction* instruction) const; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_INLINE_FUNCTION_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_invert_comparison_operator.cpp000066400000000000000000000145051475742701700323420ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_invert_comparison_operator.h" #include #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { TransformationInvertComparisonOperator::TransformationInvertComparisonOperator( protobufs::TransformationInvertComparisonOperator message) : message_(std::move(message)) {} TransformationInvertComparisonOperator::TransformationInvertComparisonOperator( uint32_t operator_id, uint32_t fresh_id) { message_.set_operator_id(operator_id); message_.set_fresh_id(fresh_id); } bool TransformationInvertComparisonOperator::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { // |message_.operator_id| must be valid and inversion must be supported for // it. auto* inst = ir_context->get_def_use_mgr()->GetDef(message_.operator_id()); if (!inst || !IsInversionSupported(inst->opcode())) { return false; } // Check that we can insert negation instruction. auto* block = ir_context->get_instr_block(inst); assert(block && "Instruction must have a basic block"); auto iter = fuzzerutil::GetIteratorForInstruction(block, inst); ++iter; assert(iter != block->end() && "Instruction can't be the last in the block"); assert(fuzzerutil::CanInsertOpcodeBeforeInstruction(spv::Op::OpLogicalNot, iter) && "Can't insert negation after comparison operator"); // |message_.fresh_id| must be fresh. return fuzzerutil::IsFreshId(ir_context, message_.fresh_id()); } void TransformationInvertComparisonOperator::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { auto* inst = ir_context->get_def_use_mgr()->GetDef(message_.operator_id()); assert(inst && "Result id of an operator is invalid"); // Insert negation after |inst|. auto iter = fuzzerutil::GetIteratorForInstruction( ir_context->get_instr_block(inst), inst); ++iter; iter.InsertBefore(MakeUnique( ir_context, spv::Op::OpLogicalNot, inst->type_id(), inst->result_id(), opt::Instruction::OperandList{ {SPV_OPERAND_TYPE_ID, {message_.fresh_id()}}})); // Change the result id of the original operator to |fresh_id|. inst->SetResultId(message_.fresh_id()); // Invert the operator. inst->SetOpcode(InvertOpcode(inst->opcode())); fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id()); ir_context->InvalidateAnalysesExceptFor( opt::IRContext::Analysis::kAnalysisNone); } bool TransformationInvertComparisonOperator::IsInversionSupported( spv::Op opcode) { switch (opcode) { case spv::Op::OpSGreaterThan: case spv::Op::OpSGreaterThanEqual: case spv::Op::OpSLessThan: case spv::Op::OpSLessThanEqual: case spv::Op::OpUGreaterThan: case spv::Op::OpUGreaterThanEqual: case spv::Op::OpULessThan: case spv::Op::OpULessThanEqual: case spv::Op::OpIEqual: case spv::Op::OpINotEqual: case spv::Op::OpFOrdEqual: case spv::Op::OpFUnordEqual: case spv::Op::OpFOrdNotEqual: case spv::Op::OpFUnordNotEqual: case spv::Op::OpFOrdLessThan: case spv::Op::OpFUnordLessThan: case spv::Op::OpFOrdLessThanEqual: case spv::Op::OpFUnordLessThanEqual: case spv::Op::OpFOrdGreaterThan: case spv::Op::OpFUnordGreaterThan: case spv::Op::OpFOrdGreaterThanEqual: case spv::Op::OpFUnordGreaterThanEqual: return true; default: return false; } } spv::Op TransformationInvertComparisonOperator::InvertOpcode(spv::Op opcode) { assert(IsInversionSupported(opcode) && "Inversion must be supported"); switch (opcode) { case spv::Op::OpSGreaterThan: return spv::Op::OpSLessThanEqual; case spv::Op::OpSGreaterThanEqual: return spv::Op::OpSLessThan; case spv::Op::OpSLessThan: return spv::Op::OpSGreaterThanEqual; case spv::Op::OpSLessThanEqual: return spv::Op::OpSGreaterThan; case spv::Op::OpUGreaterThan: return spv::Op::OpULessThanEqual; case spv::Op::OpUGreaterThanEqual: return spv::Op::OpULessThan; case spv::Op::OpULessThan: return spv::Op::OpUGreaterThanEqual; case spv::Op::OpULessThanEqual: return spv::Op::OpUGreaterThan; case spv::Op::OpIEqual: return spv::Op::OpINotEqual; case spv::Op::OpINotEqual: return spv::Op::OpIEqual; case spv::Op::OpFOrdEqual: return spv::Op::OpFUnordNotEqual; case spv::Op::OpFUnordEqual: return spv::Op::OpFOrdNotEqual; case spv::Op::OpFOrdNotEqual: return spv::Op::OpFUnordEqual; case spv::Op::OpFUnordNotEqual: return spv::Op::OpFOrdEqual; case spv::Op::OpFOrdLessThan: return spv::Op::OpFUnordGreaterThanEqual; case spv::Op::OpFUnordLessThan: return spv::Op::OpFOrdGreaterThanEqual; case spv::Op::OpFOrdLessThanEqual: return spv::Op::OpFUnordGreaterThan; case spv::Op::OpFUnordLessThanEqual: return spv::Op::OpFOrdGreaterThan; case spv::Op::OpFOrdGreaterThan: return spv::Op::OpFUnordLessThanEqual; case spv::Op::OpFUnordGreaterThan: return spv::Op::OpFOrdLessThanEqual; case spv::Op::OpFOrdGreaterThanEqual: return spv::Op::OpFUnordLessThan; case spv::Op::OpFUnordGreaterThanEqual: return spv::Op::OpFOrdLessThan; default: // The program will fail in the debug mode because of the assertion // at the beginning of the function. return spv::Op::OpNop; } } protobufs::Transformation TransformationInvertComparisonOperator::ToMessage() const { protobufs::Transformation result; *result.mutable_invert_comparison_operator() = message_; return result; } std::unordered_set TransformationInvertComparisonOperator::GetFreshIds() const { return {message_.fresh_id()}; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_invert_comparison_operator.h000066400000000000000000000047101475742701700320040ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_INVERT_COMPARISON_OPERATOR_H_ #define SOURCE_FUZZ_TRANSFORMATION_INVERT_COMPARISON_OPERATOR_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationInvertComparisonOperator : public Transformation { public: explicit TransformationInvertComparisonOperator( protobufs::TransformationInvertComparisonOperator message); TransformationInvertComparisonOperator(uint32_t operator_id, uint32_t fresh_id); // - |operator_id| should be a result id of some instruction for which // IsInversionSupported returns true. // - |fresh_id| must be a fresh id. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Inverts the opcode of the instruction with result id |operator_id| (e.g >= // becomes <) and inserts OpLogicalNot instruction after |operator_id|. Also, // changes the result id of OpLogicalNot to |operator_id| and the result id of // the inverted operator to |fresh_id|. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; // Returns true if |opcode| is supported by this transformation. static bool IsInversionSupported(spv::Op opcode); private: // Returns an inverted |opcode| (e.g. < becomes >=, == becomes != etc.) static spv::Op InvertOpcode(spv::Op opcode); protobufs::TransformationInvertComparisonOperator message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_INVERT_COMPARISON_OPERATOR_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_load.cpp000066400000000000000000000213731475742701700256060ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_load.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" namespace spvtools { namespace fuzz { TransformationLoad::TransformationLoad(protobufs::TransformationLoad message) : message_(std::move(message)) {} TransformationLoad::TransformationLoad( uint32_t fresh_id, uint32_t pointer_id, bool is_atomic, uint32_t memory_scope, uint32_t memory_semantics, const protobufs::InstructionDescriptor& instruction_to_insert_before) { message_.set_fresh_id(fresh_id); message_.set_pointer_id(pointer_id); message_.set_is_atomic(is_atomic); message_.set_memory_scope_id(memory_scope); message_.set_memory_semantics_id(memory_semantics); *message_.mutable_instruction_to_insert_before() = instruction_to_insert_before; } bool TransformationLoad::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { // The result id must be fresh. if (!fuzzerutil::IsFreshId(ir_context, message_.fresh_id())) { return false; } // The pointer must exist and have a type. auto pointer = ir_context->get_def_use_mgr()->GetDef(message_.pointer_id()); if (!pointer || !pointer->type_id()) { return false; } // The type must indeed be a pointer type. auto pointer_type = ir_context->get_def_use_mgr()->GetDef(pointer->type_id()); assert(pointer_type && "Type id must be defined."); if (pointer_type->opcode() != spv::Op::OpTypePointer) { return false; } // We do not want to allow loading from null or undefined pointers, as it is // not clear how punishing the consequences of doing so are from a semantics // point of view. switch (pointer->opcode()) { case spv::Op::OpConstantNull: case spv::Op::OpUndef: return false; default: break; } // Determine which instruction we should be inserting before. auto insert_before = FindInstruction(message_.instruction_to_insert_before(), ir_context); // It must exist, ... if (!insert_before) { return false; } // ... and it must be legitimate to insert a load before it. if (!message_.is_atomic() && !fuzzerutil::CanInsertOpcodeBeforeInstruction( spv::Op::OpLoad, insert_before)) { return false; } if (message_.is_atomic() && !fuzzerutil::CanInsertOpcodeBeforeInstruction( spv::Op::OpAtomicLoad, insert_before)) { return false; } if (message_.is_atomic()) { // Check the exists of memory scope and memory semantics ids. auto memory_scope_instruction = ir_context->get_def_use_mgr()->GetDef(message_.memory_scope_id()); auto memory_semantics_instruction = ir_context->get_def_use_mgr()->GetDef(message_.memory_semantics_id()); if (!memory_scope_instruction) { return false; } if (!memory_semantics_instruction) { return false; } // The memory scope and memory semantics instructions must have the // 'OpConstant' opcode. if (memory_scope_instruction->opcode() != spv::Op::OpConstant) { return false; } if (memory_semantics_instruction->opcode() != spv::Op::OpConstant) { return false; } // The memory scope and memory semantics need to be available before // |insert_before|. if (!fuzzerutil::IdIsAvailableBeforeInstruction( ir_context, insert_before, message_.memory_scope_id())) { return false; } if (!fuzzerutil::IdIsAvailableBeforeInstruction( ir_context, insert_before, message_.memory_semantics_id())) { return false; } // The memory scope and memory semantics instructions must have an Integer // operand type with signedness does not matters. if (ir_context->get_def_use_mgr() ->GetDef(memory_scope_instruction->type_id()) ->opcode() != spv::Op::OpTypeInt) { return false; } if (ir_context->get_def_use_mgr() ->GetDef(memory_semantics_instruction->type_id()) ->opcode() != spv::Op::OpTypeInt) { return false; } // The size of the integer for memory scope and memory semantics // instructions must be equal to 32 bits. auto memory_scope_int_width = ir_context->get_def_use_mgr() ->GetDef(memory_scope_instruction->type_id()) ->GetSingleWordInOperand(0); auto memory_semantics_int_width = ir_context->get_def_use_mgr() ->GetDef(memory_semantics_instruction->type_id()) ->GetSingleWordInOperand(0); if (memory_scope_int_width != 32) { return false; } if (memory_semantics_int_width != 32) { return false; } // The memory scope constant value must be that of spv::Scope::Invocation. auto memory_scope_const_value = spv::Scope(memory_scope_instruction->GetSingleWordInOperand(0)); if (memory_scope_const_value != spv::Scope::Invocation) { return false; } // The memory semantics constant value must match the storage class of the // pointer being loaded from. auto memory_semantics_const_value = static_cast( memory_semantics_instruction->GetSingleWordInOperand(0)); if (memory_semantics_const_value != fuzzerutil::GetMemorySemanticsForStorageClass( static_cast( pointer_type->GetSingleWordInOperand(0)))) { return false; } } // The pointer needs to be available at the insertion point. return fuzzerutil::IdIsAvailableBeforeInstruction(ir_context, insert_before, message_.pointer_id()); } void TransformationLoad::Apply(opt::IRContext* ir_context, TransformationContext* /*unused*/) const { if (message_.is_atomic()) { // OpAtomicLoad instruction. uint32_t result_type = fuzzerutil::GetPointeeTypeIdFromPointerType( ir_context, fuzzerutil::GetTypeId(ir_context, message_.pointer_id())); fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id()); auto insert_before = FindInstruction(message_.instruction_to_insert_before(), ir_context); auto new_instruction = MakeUnique( ir_context, spv::Op::OpAtomicLoad, result_type, message_.fresh_id(), opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {message_.pointer_id()}}, {SPV_OPERAND_TYPE_SCOPE_ID, {message_.memory_scope_id()}}, {SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID, {message_.memory_semantics_id()}}})); auto new_instruction_ptr = new_instruction.get(); insert_before->InsertBefore(std::move(new_instruction)); // Inform the def-use manager about the new instruction and record its basic // block. ir_context->get_def_use_mgr()->AnalyzeInstDefUse(new_instruction_ptr); ir_context->set_instr_block(new_instruction_ptr, ir_context->get_instr_block(insert_before)); } else { // OpLoad instruction. uint32_t result_type = fuzzerutil::GetPointeeTypeIdFromPointerType( ir_context, fuzzerutil::GetTypeId(ir_context, message_.pointer_id())); fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id()); auto insert_before = FindInstruction(message_.instruction_to_insert_before(), ir_context); auto new_instruction = MakeUnique( ir_context, spv::Op::OpLoad, result_type, message_.fresh_id(), opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {message_.pointer_id()}}})); auto new_instruction_ptr = new_instruction.get(); insert_before->InsertBefore(std::move(new_instruction)); // Inform the def-use manager about the new instruction and record its basic // block. ir_context->get_def_use_mgr()->AnalyzeInstDefUse(new_instruction_ptr); ir_context->set_instr_block(new_instruction_ptr, ir_context->get_instr_block(insert_before)); } } protobufs::Transformation TransformationLoad::ToMessage() const { protobufs::Transformation result; *result.mutable_load() = message_; return result; } std::unordered_set TransformationLoad::GetFreshIds() const { return {message_.fresh_id()}; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_load.h000066400000000000000000000054501475742701700252510ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_LOAD_H_ #define SOURCE_FUZZ_TRANSFORMATION_LOAD_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationLoad : public Transformation { public: explicit TransformationLoad(protobufs::TransformationLoad message); TransformationLoad( uint32_t fresh_id, uint32_t pointer_id, bool is_atomic, uint32_t memory_scope, uint32_t memory_semantics, const protobufs::InstructionDescriptor& instruction_to_insert_before); // - |message_.fresh_id| must be fresh // - |message_.pointer_id| must be the id of a pointer // - |message_.is_atomic| must be true if want to work with OpAtomicLoad // - If |is_atomic| is true then |message_memory_scope_id| must be the id of // an OpConstant 32 bit integer instruction with the value // spv::Scope::Invocation. // - If |is_atomic| is true then |message_.memory_semantics_id| must be the id // of an OpConstant 32 bit integer instruction with the values // SpvMemorySemanticsWorkgroupMemoryMask or // SpvMemorySemanticsUniformMemoryMask. // - The pointer must not be OpConstantNull or OpUndef // - |message_.instruction_to_insert_before| must identify an instruction // before which it is valid to insert an OpLoad, and where // |message_.pointer_id| is available (according to dominance rules) bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Adds an instruction of the form: // |message_.fresh_id| = OpLoad %type |message_.pointer_id| // before the instruction identified by // |message_.instruction_to_insert_before|, where %type is the pointer's // pointee type. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationLoad message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_LOAD_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_make_vector_operation_dynamic.cpp000066400000000000000000000103171475742701700327460ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_make_vector_operation_dynamic.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" namespace spvtools { namespace fuzz { TransformationMakeVectorOperationDynamic:: TransformationMakeVectorOperationDynamic( protobufs::TransformationMakeVectorOperationDynamic message) : message_(std::move(message)) {} TransformationMakeVectorOperationDynamic:: TransformationMakeVectorOperationDynamic(uint32_t instruction_result_id, uint32_t constant_index_id) { message_.set_instruction_result_id(instruction_result_id); message_.set_constant_index_id(constant_index_id); } bool TransformationMakeVectorOperationDynamic::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { // |instruction| must be a vector operation. auto instruction = ir_context->get_def_use_mgr()->GetDef(message_.instruction_result_id()); if (!IsVectorOperation(ir_context, instruction)) { return false; } // |constant_index_instruction| must be defined as an integer instruction. auto constant_index_instruction = ir_context->get_def_use_mgr()->GetDef(message_.constant_index_id()); if (!constant_index_instruction || !constant_index_instruction->type_id() || !ir_context->get_type_mgr() ->GetType(constant_index_instruction->type_id()) ->AsInteger()) { return false; } return true; } void TransformationMakeVectorOperationDynamic::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { auto instruction = ir_context->get_def_use_mgr()->GetDef(message_.instruction_result_id()); // The OpVectorInsertDynamic instruction has the vector and component operands // in reverse order in relation to the OpCompositeInsert corresponding // operands. if (instruction->opcode() == spv::Op::OpCompositeInsert) { std::swap(instruction->GetInOperand(0), instruction->GetInOperand(1)); } // Sets the literal operand to the equivalent constant. instruction->SetInOperand( instruction->opcode() == spv::Op::OpCompositeExtract ? 1 : 2, {message_.constant_index_id()}); // Sets the |instruction| opcode to the corresponding vector dynamic opcode. instruction->SetOpcode(instruction->opcode() == spv::Op::OpCompositeExtract ? spv::Op::OpVectorExtractDynamic : spv::Op::OpVectorInsertDynamic); } protobufs::Transformation TransformationMakeVectorOperationDynamic::ToMessage() const { protobufs::Transformation result; *result.mutable_make_vector_operation_dynamic() = message_; return result; } bool TransformationMakeVectorOperationDynamic::IsVectorOperation( opt::IRContext* ir_context, opt::Instruction* instruction) { // |instruction| must be defined and must be an OpCompositeExtract/Insert // instruction. if (!instruction || (instruction->opcode() != spv::Op::OpCompositeExtract && instruction->opcode() != spv::Op::OpCompositeInsert)) { return false; } // The composite must be a vector. auto composite_instruction = ir_context->get_def_use_mgr()->GetDef(instruction->GetSingleWordInOperand( instruction->opcode() == spv::Op::OpCompositeExtract ? 0 : 1)); if (!ir_context->get_type_mgr() ->GetType(composite_instruction->type_id()) ->AsVector()) { return false; } return true; } std::unordered_set TransformationMakeVectorOperationDynamic::GetFreshIds() const { return std::unordered_set(); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_make_vector_operation_dynamic.h000066400000000000000000000050761475742701700324210ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_MAKE_VECTOR_OPERATION_DYNAMIC_H_ #define SOURCE_FUZZ_TRANSFORMATION_MAKE_VECTOR_OPERATION_DYNAMIC_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationMakeVectorOperationDynamic : public Transformation { public: explicit TransformationMakeVectorOperationDynamic( protobufs::TransformationMakeVectorOperationDynamic message); TransformationMakeVectorOperationDynamic(uint32_t instruction_result_id, uint32_t constant_index_id); // - |message_.instruction_result_id| must be the result id of an // OpCompositeExtract/Insert instruction such that the composite operand is a // vector. // - |message_.constant_index_id| must be the result id of an integer // instruction such that its value equals the indexing literal of the // OpCompositeExtract/Insert instruction. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Replaces the OpCompositeExtract and OpCompositeInsert instructions with the // OpVectorExtractDynamic and OpVectorInsertDynamic instructions. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; // Checks |instruction| is defined, is an OpCompositeExtract/Insert // instruction and the composite operand is a vector. static bool IsVectorOperation(opt::IRContext* ir_context, opt::Instruction* instruction); private: protobufs::TransformationMakeVectorOperationDynamic message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_MAKE_VECTOR_OPERATION_DYNAMIC_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_merge_blocks.cpp000066400000000000000000000062261475742701700273230ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_merge_blocks.h" #include "source/fuzz/fuzzer_util.h" #include "source/opt/block_merge_util.h" namespace spvtools { namespace fuzz { TransformationMergeBlocks::TransformationMergeBlocks( protobufs::TransformationMergeBlocks message) : message_(std::move(message)) {} TransformationMergeBlocks::TransformationMergeBlocks(uint32_t block_id) { message_.set_block_id(block_id); } bool TransformationMergeBlocks::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { auto second_block = fuzzerutil::MaybeFindBlock(ir_context, message_.block_id()); // The given block must exist. if (!second_block) { return false; } // The block must have just one predecessor. auto predecessors = ir_context->cfg()->preds(second_block->id()); if (predecessors.size() != 1) { return false; } auto first_block = ir_context->cfg()->block(predecessors.at(0)); if (!ir_context->IsReachable(*first_block)) { return false; } return opt::blockmergeutil::CanMergeWithSuccessor(ir_context, first_block); } void TransformationMergeBlocks::Apply(opt::IRContext* ir_context, TransformationContext* /*unused*/) const { auto second_block = fuzzerutil::MaybeFindBlock(ir_context, message_.block_id()); auto first_block = ir_context->cfg()->block( ir_context->cfg()->preds(second_block->id()).at(0)); auto function = first_block->GetParent(); // We need an iterator pointing to the predecessor, hence the loop. for (auto bi = function->begin(); bi != function->end(); ++bi) { if (bi->id() == first_block->id()) { assert(opt::blockmergeutil::CanMergeWithSuccessor(ir_context, &*bi) && "Because 'Apply' should only be invoked if 'IsApplicable' holds, " "it must be possible to merge |bi| with its successor."); opt::blockmergeutil::MergeWithSuccessor(ir_context, function, bi); // Invalidate all analyses, since we have changed the module // significantly. ir_context->InvalidateAnalysesExceptFor(opt::IRContext::kAnalysisNone); return; } } assert(false && "Control should not reach here - we should always find the desired " "block"); } protobufs::Transformation TransformationMergeBlocks::ToMessage() const { protobufs::Transformation result; *result.mutable_merge_blocks() = message_; return result; } std::unordered_set TransformationMergeBlocks::GetFreshIds() const { return std::unordered_set(); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_merge_blocks.h000066400000000000000000000040771475742701700267720ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_MERGE_BLOCKS_H_ #define SOURCE_FUZZ_TRANSFORMATION_MERGE_BLOCKS_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationMergeBlocks : public Transformation { public: explicit TransformationMergeBlocks( protobufs::TransformationMergeBlocks message); TransformationMergeBlocks(uint32_t block_id); // - |message_.block_id| must be the id of a block, b // - b must be statically reachable in the control flow graph of its function // - b must have a single predecessor, a // - b must be the sole successor of a // - Replacing a with the merge of a and b (and removing b) must lead to a // valid module bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // The contents of b are merged into a, and a's terminator is replaced with // the terminator of b. Block b is removed from the module. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationMergeBlocks message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_MERGE_BLOCKS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_merge_function_returns.cpp000066400000000000000000001044761475742701700314630ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_merge_function_returns.h" #include "source/fuzz/comparator_deep_blocks_first.h" #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { TransformationMergeFunctionReturns::TransformationMergeFunctionReturns( protobufs::TransformationMergeFunctionReturns message) : message_(std::move(message)) {} TransformationMergeFunctionReturns::TransformationMergeFunctionReturns( uint32_t function_id, uint32_t outer_header_id, uint32_t unreachable_continue_id, uint32_t outer_return_id, uint32_t return_val_id, uint32_t any_returnable_val_id, const std::vector& returns_merging_info) { message_.set_function_id(function_id); message_.set_outer_header_id(outer_header_id); message_.set_unreachable_continue_id(unreachable_continue_id); message_.set_outer_return_id(outer_return_id); message_.set_return_val_id(return_val_id); message_.set_any_returnable_val_id(any_returnable_val_id); for (const auto& return_merging_info : returns_merging_info) { *message_.add_return_merging_info() = return_merging_info; } } bool TransformationMergeFunctionReturns::IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const { auto function = ir_context->GetFunction(message_.function_id()); // The function must exist. if (!function) { return false; } // The entry block must end in an unconditional branch. if (function->entry()->terminator()->opcode() != spv::Op::OpBranch) { return false; } // The module must contain an OpConstantTrue instruction. if (!fuzzerutil::MaybeGetBoolConstant(ir_context, transformation_context, true, false)) { return false; } // The module must contain an OpConstantFalse instruction. if (!fuzzerutil::MaybeGetBoolConstant(ir_context, transformation_context, false, false)) { return false; } // Check that the fresh ids provided are fresh and distinct. std::set used_fresh_ids; for (uint32_t id : {message_.outer_header_id(), message_.unreachable_continue_id(), message_.outer_return_id()}) { if (!id || !CheckIdIsFreshAndNotUsedByThisTransformation(id, ir_context, &used_fresh_ids)) { return false; } } // Check the additional fresh id required if the function is not void. auto function_type = ir_context->get_type_mgr()->GetType(function->type_id()); assert(function_type && "The function type should always exist."); if (!function_type->AsVoid() && (!message_.return_val_id() || !CheckIdIsFreshAndNotUsedByThisTransformation( message_.return_val_id(), ir_context, &used_fresh_ids))) { return false; } // Get a map from the types for which ids are available at the end of the // entry block to one of the ids with that type. We compute this here to avoid // potentially doing it multiple times later on. auto types_to_available_ids = GetTypesToIdAvailableAfterEntryBlock(ir_context); // Get the reachable return blocks. auto return_blocks = fuzzerutil::GetReachableReturnBlocks(ir_context, message_.function_id()); // Map each merge block of loops containing reachable return blocks to the // corresponding returning predecessors (all the blocks that, at the end of // the transformation, will branch to the merge block because the function is // returning). std::map> merge_blocks_to_returning_preds; for (uint32_t block : return_blocks) { uint32_t merge_block = ir_context->GetStructuredCFGAnalysis()->LoopMergeBlock(block); while (merge_block != 0) { // If we have seen this merge block before, update the corresponding set // and break out of the loop. if (merge_blocks_to_returning_preds.count(merge_block)) { merge_blocks_to_returning_preds[merge_block].emplace(block); break; } // If we have not seen this merge block before, add a new entry and walk // up the loop tree. merge_blocks_to_returning_preds.emplace(merge_block, std::set({block})); // Walk up the loop tree. block = merge_block; merge_block = ir_context->GetStructuredCFGAnalysis()->LoopMergeBlock(merge_block); } } // Instructions in the relevant merge blocks must be restricted to OpLabel, // OpPhi and OpBranch. for (const auto& merge_block_entry : merge_blocks_to_returning_preds) { uint32_t merge_block = merge_block_entry.first; bool all_instructions_allowed = ir_context->get_instr_block(merge_block) ->WhileEachInst([](opt::Instruction* inst) { return inst->opcode() == spv::Op::OpLabel || inst->opcode() == spv::Op::OpPhi || inst->opcode() == spv::Op::OpBranch; }); if (!all_instructions_allowed) { return false; } } auto merge_blocks_to_info = GetMappingOfMergeBlocksToInfo(); // For each relevant merge block, check that the correct ids are available. for (const auto& merge_block_entry : merge_blocks_to_returning_preds) { if (!CheckThatTheCorrectIdsAreGivenForMergeBlock( merge_block_entry.first, merge_blocks_to_info, types_to_available_ids, function_type->AsVoid(), ir_context, transformation_context, &used_fresh_ids)) { return false; } } // If the function has a non-void return type, and there are merge loops which // contain return instructions, we need to check that either: // - |message_.any_returnable_val_id| exists. In this case, it must have the // same type as the return type of the function and be available at the end // of the entry block. // - a suitable id, available at the end of the entry block can be found in // the module. if (!function_type->AsVoid() && !merge_blocks_to_returning_preds.empty()) { auto returnable_val_def = ir_context->get_def_use_mgr()->GetDef(message_.any_returnable_val_id()); if (!returnable_val_def) { // Check if a suitable id can be found in the module. if (types_to_available_ids.count(function->type_id()) == 0) { return false; } } else if (returnable_val_def->type_id() != function->type_id()) { return false; } else if (!fuzzerutil::IdIsAvailableBeforeInstruction( ir_context, function->entry()->terminator(), message_.any_returnable_val_id())) { // The id must be available at the end of the entry block. return false; } } // Check that adding new predecessors to the relevant merge blocks does not // render any instructions invalid (each id definition must still dominate // each of its uses). if (!CheckDefinitionsStillDominateUsesAfterAddingNewPredecessors( ir_context, function, merge_blocks_to_returning_preds)) { return false; } return true; } void TransformationMergeFunctionReturns::Apply( opt::IRContext* ir_context, TransformationContext* transformation_context) const { auto function = ir_context->GetFunction(message_.function_id()); auto function_type = ir_context->get_type_mgr()->GetType(function->type_id()); // Get a map from the types for which ids are available at the end of the // entry block to one of the ids with that type. We compute this here to avoid // potentially doing it multiple times later on. auto types_to_available_ids = GetTypesToIdAvailableAfterEntryBlock(ir_context); uint32_t bool_type = fuzzerutil::MaybeGetBoolType(ir_context); uint32_t constant_true = fuzzerutil::MaybeGetBoolConstant( ir_context, *transformation_context, true, false); uint32_t constant_false = fuzzerutil::MaybeGetBoolConstant( ir_context, *transformation_context, false, false); // Get the reachable return blocks. auto return_blocks = fuzzerutil::GetReachableReturnBlocks(ir_context, message_.function_id()); // Keep a map from the relevant merge blocks to a mapping from each of the // returning predecessors to the corresponding pair (return value, // boolean specifying whether the function is returning). Returning // predecessors are blocks in the loop (not further nested inside loops), // which either return or are merge blocks of nested loops containing return // instructions. std::map>> merge_blocks_to_returning_predecessors; // Initialise the map, mapping each relevant merge block to an empty map. for (uint32_t ret_block_id : return_blocks) { uint32_t merge_block_id = ir_context->GetStructuredCFGAnalysis()->LoopMergeBlock(ret_block_id); while (merge_block_id != 0 && !merge_blocks_to_returning_predecessors.count(merge_block_id)) { merge_blocks_to_returning_predecessors.emplace( merge_block_id, std::map>()); merge_block_id = ir_context->GetStructuredCFGAnalysis()->LoopMergeBlock( merge_block_id); } } // Get a reference to an instruction with the same type id as the function's // return type, if the type of the function is not void and ther are loops // containing return instructions. uint32_t returnable_val_id = 0; if (!function_type->AsVoid() && !merge_blocks_to_returning_predecessors.empty()) { // If |message.any_returnable_val_id| can be found in the module, use it. // Otherwise, use another suitable id found in the module. auto returnable_val_def = ir_context->get_def_use_mgr()->GetDef(message_.any_returnable_val_id()); returnable_val_id = returnable_val_def ? returnable_val_def->result_id() : types_to_available_ids[function->type_id()]; } // Keep a map from all the new predecessors of the merge block of the new // outer loop, to the related return value ids. std::map outer_merge_predecessors; // Adjust the return blocks and add the related information to the map or // |outer_merge_predecessors| set. for (uint32_t ret_block_id : return_blocks) { auto ret_block = ir_context->get_instr_block(ret_block_id); // Get the return value id (if the function is not void). uint32_t ret_val_id = function_type->AsVoid() ? 0 : ret_block->terminator()->GetSingleWordInOperand(0); uint32_t merge_block_id = ir_context->GetStructuredCFGAnalysis()->LoopMergeBlock(ret_block_id); // Add a new entry to the map corresponding to the merge block of the // innermost enclosing loop (or that of the new outer loop if there is no // enclosing loop). if (merge_block_id != 0) { merge_blocks_to_returning_predecessors[merge_block_id].emplace( ret_block_id, std::pair(ret_val_id, constant_true)); } else { // If there is no enclosing loop, the block will branch to the merge block // of the new outer loop. merge_block_id = message_.outer_return_id(); outer_merge_predecessors.emplace(ret_block_id, ret_val_id); } // Replace the return instruction with an unconditional branch. ret_block->terminator()->SetOpcode(spv::Op::OpBranch); ret_block->terminator()->SetInOperands( {{SPV_OPERAND_TYPE_ID, {merge_block_id}}}); } // Get a list of all the relevant merge blocks. std::vector merge_blocks; merge_blocks.reserve(merge_blocks_to_returning_predecessors.size()); for (const auto& entry : merge_blocks_to_returning_predecessors) { merge_blocks.emplace_back(entry.first); } // Sort the list so that deeper merge blocks come first. // We need to consider deeper merge blocks first so that, when a merge block // is considered, all the merge blocks enclosed by the corresponding loop have // already been considered and, thus, the mapping from this merge block to the // returning predecessors is complete. std::sort(merge_blocks.begin(), merge_blocks.end(), ComparatorDeepBlocksFirst(ir_context)); auto merge_blocks_to_info = GetMappingOfMergeBlocksToInfo(); // Adjust the merge blocks and add the related information to the map or // |outer_merge_predecessors| set. for (uint32_t merge_block_id : merge_blocks) { // Get the info corresponding to |merge_block| from the map, if a // corresponding entry exists. Otherwise use overflow ids and find suitable // ids in the module. protobufs::ReturnMergingInfo* info = merge_blocks_to_info.count(merge_block_id) ? &merge_blocks_to_info[merge_block_id] : nullptr; uint32_t is_returning_id = info ? info->is_returning_id() : transformation_context->GetOverflowIdSource() ->GetNextOverflowId(); uint32_t maybe_return_val_id = 0; if (!function_type->AsVoid()) { maybe_return_val_id = info ? info->maybe_return_val_id() : transformation_context->GetOverflowIdSource() ->GetNextOverflowId(); } // Map from existing OpPhi to overflow ids. If there is no mapping, get an // empty map. auto phi_to_id = info ? fuzzerutil::RepeatedUInt32PairToMap( *merge_blocks_to_info[merge_block_id] .mutable_opphi_to_suitable_id()) : std::map(); // Get a reference to the info related to the returning predecessors. const auto& returning_preds = merge_blocks_to_returning_predecessors[merge_block_id]; // Get a set of the original predecessors. auto preds_list = ir_context->cfg()->preds(merge_block_id); auto preds = std::set(preds_list.begin(), preds_list.end()); auto merge_block = ir_context->get_instr_block(merge_block_id); // Adjust the existing OpPhi instructions. merge_block->ForEachPhiInst( [&preds, &returning_preds, &phi_to_id, &types_to_available_ids](opt::Instruction* inst) { // We need a placeholder value id. If |phi_to_id| contains a mapping // for this instruction, we use the given id, otherwise a suitable id // for the instruction's type from |types_to_available_ids|. uint32_t placeholder_val_id = phi_to_id.count(inst->result_id()) ? phi_to_id[inst->result_id()] : types_to_available_ids[inst->type_id()]; assert(placeholder_val_id && "We should always be able to find a suitable if the " "transformation is applicable."); // Add a pair of operands (placeholder id, new predecessor) for each // new predecessor of the merge block. for (const auto& entry : returning_preds) { // A returning predecessor may already be a predecessor of the // block. In that case, we should not add new operands. // Each entry is in the form (predecessor, {return val, is // returning}). if (!preds.count(entry.first)) { inst->AddOperand({SPV_OPERAND_TYPE_ID, {placeholder_val_id}}); inst->AddOperand({SPV_OPERAND_TYPE_ID, {entry.first}}); } } }); // If the function is not void, add a new OpPhi instructions to collect the // return value from the returning predecessors. if (!function_type->AsVoid()) { opt::Instruction::OperandList operand_list; // Add two operands (return value, predecessor) for each returning // predecessor. for (auto entry : returning_preds) { // Each entry is in the form (predecessor, {return value, // is returning}). operand_list.emplace_back( opt::Operand{SPV_OPERAND_TYPE_ID, {entry.second.first}}); operand_list.emplace_back( opt::Operand{SPV_OPERAND_TYPE_ID, {entry.first}}); } // Add two operands for each original predecessor from which the function // does not return. for (uint32_t original_pred : preds) { // Only add operands if the function cannot be returning from this // block. if (returning_preds.count(original_pred)) { continue; } operand_list.emplace_back( opt::Operand{SPV_OPERAND_TYPE_ID, {returnable_val_id}}); operand_list.emplace_back( opt::Operand{SPV_OPERAND_TYPE_ID, {original_pred}}); } // Insert the instruction. merge_block->begin()->InsertBefore(MakeUnique( ir_context, spv::Op::OpPhi, function->type_id(), maybe_return_val_id, std::move(operand_list))); fuzzerutil::UpdateModuleIdBound(ir_context, maybe_return_val_id); } // Add an OpPhi instruction deciding whether the function is returning. { opt::Instruction::OperandList operand_list; // Add two operands (return value, is returning) for each returning // predecessor. for (auto entry : returning_preds) { // Each entry is in the form (predecessor, {return value, // is returning}). operand_list.emplace_back( opt::Operand{SPV_OPERAND_TYPE_ID, {entry.second.second}}); operand_list.emplace_back( opt::Operand{SPV_OPERAND_TYPE_ID, {entry.first}}); } // Add two operands for each original predecessor from which the function // does not return. for (uint32_t original_pred : preds) { // Only add operands if the function cannot be returning from this // block. if (returning_preds.count(original_pred)) { continue; } operand_list.emplace_back( opt::Operand{SPV_OPERAND_TYPE_ID, {constant_false}}); operand_list.emplace_back( opt::Operand{SPV_OPERAND_TYPE_ID, {original_pred}}); } // Insert the instruction. merge_block->begin()->InsertBefore(MakeUnique( ir_context, spv::Op::OpPhi, bool_type, is_returning_id, std::move(operand_list))); fuzzerutil::UpdateModuleIdBound(ir_context, is_returning_id); } // Change the branching instruction of the block. assert(merge_block->terminator()->opcode() == spv::Op::OpBranch && "Each block should branch unconditionally to the next."); // Add a new entry to the map corresponding to the merge block of the // innermost enclosing loop (or that of the new outer loop if there is no // enclosing loop). uint32_t enclosing_merge = ir_context->GetStructuredCFGAnalysis()->LoopMergeBlock(merge_block_id); if (enclosing_merge == 0) { enclosing_merge = message_.outer_return_id(); outer_merge_predecessors.emplace(merge_block_id, maybe_return_val_id); } else { merge_blocks_to_returning_predecessors[enclosing_merge].emplace( merge_block_id, std::pair(maybe_return_val_id, is_returning_id)); } // Get the current successor. uint32_t original_succ = merge_block->terminator()->GetSingleWordInOperand(0); // Leave the instruction as it is if the block already branches to the merge // block of the enclosing loop. if (original_succ == enclosing_merge) { continue; } // The block should branch to |enclosing_merge| if |is_returning_id| is // true, to |original_succ| otherwise. merge_block->terminator()->SetOpcode(spv::Op::OpBranchConditional); merge_block->terminator()->SetInOperands( {{SPV_OPERAND_TYPE_ID, {is_returning_id}}, {SPV_OPERAND_TYPE_ID, {enclosing_merge}}, {SPV_OPERAND_TYPE_ID, {original_succ}}}); } assert(function->entry()->terminator()->opcode() == spv::Op::OpBranch && "The entry block should branch unconditionally to another block."); uint32_t block_after_entry = function->entry()->terminator()->GetSingleWordInOperand(0); // Create the header for the new outer loop. auto outer_loop_header = MakeUnique(MakeUnique( ir_context, spv::Op::OpLabel, 0, message_.outer_header_id(), opt::Instruction::OperandList())); fuzzerutil::UpdateModuleIdBound(ir_context, message_.outer_header_id()); // Add the instruction: // OpLoopMerge %outer_return_id %unreachable_continue_id None outer_loop_header->AddInstruction(MakeUnique( ir_context, spv::Op::OpLoopMerge, 0, 0, opt::Instruction::OperandList{ {SPV_OPERAND_TYPE_ID, {message_.outer_return_id()}}, {SPV_OPERAND_TYPE_ID, {message_.unreachable_continue_id()}}, {SPV_OPERAND_TYPE_LOOP_CONTROL, {uint32_t(spv::LoopControlMask::MaskNone)}}})); // Add unconditional branch to %block_after_entry. outer_loop_header->AddInstruction(MakeUnique( ir_context, spv::Op::OpBranch, 0, 0, opt::Instruction::OperandList{ {SPV_OPERAND_TYPE_ID, {block_after_entry}}})); // Insert the header right after the entry block. function->InsertBasicBlockAfter(std::move(outer_loop_header), function->entry().get()); // Update the branching instruction of the entry block. function->entry()->terminator()->SetInOperands( {{SPV_OPERAND_TYPE_ID, {message_.outer_header_id()}}}); // If the entry block is referenced in an OpPhi instruction, the header for // the new loop should be referenced instead. ir_context->get_def_use_mgr()->ForEachUse( function->entry()->id(), [this](opt::Instruction* use_instruction, uint32_t use_operand_index) { if (use_instruction->opcode() == spv::Op::OpPhi) { use_instruction->SetOperand(use_operand_index, {message_.outer_header_id()}); } }); // Create the merge block for the loop (and return block for the function). auto outer_return_block = MakeUnique(MakeUnique( ir_context, spv::Op::OpLabel, 0, message_.outer_return_id(), opt::Instruction::OperandList())); fuzzerutil::UpdateModuleIdBound(ir_context, message_.outer_return_id()); // If the function is not void, insert an instruction to collect the return // value from the predecessors and an OpReturnValue instruction. if (!function_type->AsVoid()) { opt::Instruction::OperandList operand_list; // Add two operands (return value, predecessor) for each predecessor. for (auto entry : outer_merge_predecessors) { // Each entry is in the form (predecessor, return value). operand_list.emplace_back( opt::Operand{SPV_OPERAND_TYPE_ID, {entry.second}}); operand_list.emplace_back( opt::Operand{SPV_OPERAND_TYPE_ID, {entry.first}}); } // Insert the OpPhi instruction. outer_return_block->AddInstruction(MakeUnique( ir_context, spv::Op::OpPhi, function->type_id(), message_.return_val_id(), std::move(operand_list))); fuzzerutil::UpdateModuleIdBound(ir_context, message_.return_val_id()); // Insert the OpReturnValue instruction. outer_return_block->AddInstruction(MakeUnique( ir_context, spv::Op::OpReturnValue, 0, 0, opt::Instruction::OperandList{ {SPV_OPERAND_TYPE_ID, {message_.return_val_id()}}})); } else { // Insert an OpReturn instruction (the function is void). outer_return_block->AddInstruction(MakeUnique( ir_context, spv::Op::OpReturn, 0, 0, opt::Instruction::OperandList{})); } // Insert the new return block at the end of the function. function->AddBasicBlock(std::move(outer_return_block)); // Create the unreachable continue block associated with the enclosing loop. auto unreachable_continue_block = MakeUnique(MakeUnique( ir_context, spv::Op::OpLabel, 0, message_.unreachable_continue_id(), opt::Instruction::OperandList())); fuzzerutil::UpdateModuleIdBound(ir_context, message_.unreachable_continue_id()); // Insert an branch back to the loop header, to create a back edge. unreachable_continue_block->AddInstruction(MakeUnique( ir_context, spv::Op::OpBranch, 0, 0, opt::Instruction::OperandList{ {SPV_OPERAND_TYPE_ID, {message_.outer_header_id()}}})); // Insert the unreachable continue block at the end of the function. function->AddBasicBlock(std::move(unreachable_continue_block)); // All analyses must be invalidated because the structure of the module was // changed. ir_context->InvalidateAnalysesExceptFor(opt::IRContext::kAnalysisNone); } std::unordered_set TransformationMergeFunctionReturns::GetFreshIds() const { std::unordered_set result; result.emplace(message_.outer_header_id()); result.emplace(message_.unreachable_continue_id()); result.emplace(message_.outer_return_id()); // |message_.return_val_info| can be 0 if the function is void. if (message_.return_val_id()) { result.emplace(message_.return_val_id()); } for (const auto& merging_info : message_.return_merging_info()) { result.emplace(merging_info.is_returning_id()); // |maybe_return_val_id| can be 0 if the function is void. if (merging_info.maybe_return_val_id()) { result.emplace(merging_info.maybe_return_val_id()); } } return result; } protobufs::Transformation TransformationMergeFunctionReturns::ToMessage() const { protobufs::Transformation result; *result.mutable_merge_function_returns() = message_; return result; } std::map TransformationMergeFunctionReturns::GetMappingOfMergeBlocksToInfo() const { std::map result; for (const auto& info : message_.return_merging_info()) { result.emplace(info.merge_block_id(), info); } return result; } std::map TransformationMergeFunctionReturns::GetTypesToIdAvailableAfterEntryBlock( opt::IRContext* ir_context) const { std::map result; // Consider all global declarations for (auto& global : ir_context->module()->types_values()) { if (global.HasResultId() && global.type_id()) { result.emplace(global.type_id(), global.result_id()); } } auto function = ir_context->GetFunction(message_.function_id()); assert(function && "The function must exist."); // Consider all function parameters function->ForEachParam([&result](opt::Instruction* param) { if (param->HasResultId() && param->type_id()) { result.emplace(param->type_id(), param->result_id()); } }); // Consider all the instructions in the entry block. for (auto& inst : *function->entry()) { if (inst.HasResultId() && inst.type_id()) { result.emplace(inst.type_id(), inst.result_id()); } } return result; } bool TransformationMergeFunctionReturns:: CheckDefinitionsStillDominateUsesAfterAddingNewPredecessors( opt::IRContext* ir_context, const opt::Function* function, const std::map>& merge_blocks_to_new_predecessors) { for (const auto& merge_block_entry : merge_blocks_to_new_predecessors) { uint32_t merge_block = merge_block_entry.first; const auto& returning_preds = merge_block_entry.second; // Find a list of blocks in which there might be problematic definitions. // These are all the blocks that dominate the merge block but do not // dominate all of the new predecessors. std::vector problematic_blocks; auto dominator_analysis = ir_context->GetDominatorAnalysis(function); // Start from the immediate dominator of the merge block. auto current_block = dominator_analysis->ImmediateDominator(merge_block); assert(current_block && "Each merge block should have at least one dominator."); for (uint32_t pred : returning_preds) { while (!dominator_analysis->Dominates(current_block->id(), pred)) { // The current block does not dominate all of the new predecessor // blocks, so it might be problematic. problematic_blocks.emplace_back(current_block); // Walk up the dominator tree. current_block = dominator_analysis->ImmediateDominator(current_block); assert(current_block && "We should be able to find a dominator for all the blocks, " "since they must all be dominated at least by the header."); } } // Identify the loop header corresponding to the merge block. uint32_t loop_header = fuzzerutil::GetLoopFromMergeBlock(ir_context, merge_block); // For all the ids defined in blocks inside |problematic_blocks|, check that // all their uses are either: // - inside the loop (or in the loop header). If this is the case, the path // from the definition to the use does not go through the merge block, so // adding new predecessor to it is not a problem. // - inside an OpPhi instruction in the merge block. If this is the case, // the definition does not need to dominate the merge block. for (auto block : problematic_blocks) { assert((block->id() == loop_header || ir_context->GetStructuredCFGAnalysis()->ContainingLoop( block->id()) == loop_header) && "The problematic blocks should all be inside the loop (also " "considering the header)."); bool dominance_rules_maintained = block->WhileEachInst([ir_context, loop_header, merge_block](opt::Instruction* instruction) { // Instruction without a result id do not cause any problems. if (!instruction->HasResultId()) { return true; } // Check that all the uses of the id are inside the loop. return ir_context->get_def_use_mgr()->WhileEachUse( instruction->result_id(), [ir_context, loop_header, merge_block]( opt::Instruction* inst_use, uint32_t /* unused */) { uint32_t block_use = ir_context->get_instr_block(inst_use)->id(); // The usage is OK if it is inside the loop (including the // header). if (block_use == loop_header || ir_context->GetStructuredCFGAnalysis()->ContainingLoop( block_use)) { return true; } // The usage is OK if it is inside an OpPhi instruction in the // merge block. return block_use == merge_block && inst_use->opcode() == spv::Op::OpPhi; }); }); // If not all instructions in the block satisfy the requirement, the // transformation is not applicable. if (!dominance_rules_maintained) { return false; } } } return true; } bool TransformationMergeFunctionReturns:: CheckThatTheCorrectIdsAreGivenForMergeBlock( uint32_t merge_block, const std::map& merge_blocks_to_info, const std::map& types_to_available_id, bool function_is_void, opt::IRContext* ir_context, const TransformationContext& transformation_context, std::set* used_fresh_ids) { // A map from OpPhi ids to ids of the same type available at the beginning // of the merge block. std::map phi_to_id; if (merge_blocks_to_info.count(merge_block) > 0) { // If the map contains an entry for the merge block, check that the fresh // ids are fresh and distinct. auto info = merge_blocks_to_info.at(merge_block); if (!info.is_returning_id() || !CheckIdIsFreshAndNotUsedByThisTransformation( info.is_returning_id(), ir_context, used_fresh_ids)) { return false; } if (!function_is_void && (!info.maybe_return_val_id() || !CheckIdIsFreshAndNotUsedByThisTransformation( info.maybe_return_val_id(), ir_context, used_fresh_ids))) { return false; } // Get the mapping from OpPhis to suitable ids. phi_to_id = fuzzerutil::RepeatedUInt32PairToMap( *info.mutable_opphi_to_suitable_id()); } else { // If the map does not contain an entry for the merge block, check that // overflow ids are available. if (!transformation_context.GetOverflowIdSource()->HasOverflowIds()) { return false; } } // For each OpPhi instruction, check that a suitable placeholder id is // available. bool suitable_info_for_phi = ir_context->get_instr_block(merge_block) ->WhileEachPhiInst([ir_context, &phi_to_id, &types_to_available_id](opt::Instruction* inst) { if (phi_to_id.count(inst->result_id()) > 0) { // If there exists a mapping for this instruction and the // placeholder id exists in the module, check that it has the // correct type and it is available before the instruction. auto placeholder_def = ir_context->get_def_use_mgr()->GetDef( phi_to_id[inst->result_id()]); if (placeholder_def) { if (inst->type_id() != placeholder_def->type_id()) { return false; } if (!fuzzerutil::IdIsAvailableBeforeInstruction( ir_context, inst, placeholder_def->result_id())) { return false; } return true; } } // If there is no mapping, check if there is a suitable id // available at the end of the entry block. return types_to_available_id.count(inst->type_id()) > 0; }); if (!suitable_info_for_phi) { return false; } return true; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_merge_function_returns.h000066400000000000000000000131231475742701700311140ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_MERGE_FUNCTION_RETURNS_ #define SOURCE_FUZZ_TRANSFORMATION_MERGE_FUNCTION_RETURNS_ #include "source/fuzz/transformation.h" namespace spvtools { namespace fuzz { class TransformationMergeFunctionReturns : public Transformation { public: explicit TransformationMergeFunctionReturns( protobufs::TransformationMergeFunctionReturns message); TransformationMergeFunctionReturns( uint32_t function_id, uint32_t outer_header_id, uint32_t unreachable_continue_id, uint32_t outer_return_id, uint32_t return_val_id, uint32_t any_returnable_val_id, const std::vector& returns_merging_info); // - |message_.function_id| is the id of a function. // - The entry block of |message_.function_id| branches unconditionally to // another block. // - |message_.any_returnable_val_id| is an id whose type is the same as the // return type of the function and which is available at the end of the // entry block. If this id is not found in the module, the transformation // will try to find a suitable one. // If the function is void, or no loops in the function contain return // statements, this id will be ignored. // - Merge blocks of reachable loops that contain return statements only // consist of OpLabel, OpPhi or OpBranch instructions. // - The module contains OpConstantTrue and OpConstantFalse instructions. // - For all merge blocks of reachable loops that contain return statements, // either: // - a mapping is provided in |message_.return_merging_info|, all of the // corresponding fresh ids are valid and, for each OpPhi instruction in // the block, there is a mapping to an available id of the same type in // |opphi_to_suitable_id| or a suitable id, available at the end of the // entry block, can be found in the module. // - there is no mapping, but overflow ids are available and, for every // OpPhi instruction in the merge blocks that need to be modified, a // suitable id, available at the end of the entry block, can be found. // - The addition of new predecessors to the relevant merge blocks does not // cause any id use to be invalid (i.e. every id must dominate all its uses // even after the transformation has added new branches). // - All of the fresh ids that are provided and needed by the transformation // are valid. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Changes the function so that there is only one reachable return // instruction. The function is enclosed by an outer loop, whose merge block // is the new return block. All existing return statements are replaced by // branch instructions to the merge block of the loop enclosing them, and // OpPhi instructions are used to keep track of the return value and of // whether the function is returning. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: // Returns a map from merge block ids to the corresponding info in // |message_.return_merging_info|. std::map GetMappingOfMergeBlocksToInfo() const; // Returns a map from type ids to an id with that type and which is available // at the end of the entry block of |message_.function_id|. // Assumes that the function exists. std::map GetTypesToIdAvailableAfterEntryBlock( opt::IRContext* ir_context) const; // Returns true if adding new predecessors to the given loop merge blocks // does not render any instructions invalid (each id definition must still // dominate all of its uses). The loop merge blocks and corresponding new // predecessors to consider are given in |merge_blocks_to_new_predecessors|. // All of the new predecessors are assumed to be inside the loop associated // with the corresponding loop merge block. static bool CheckDefinitionsStillDominateUsesAfterAddingNewPredecessors( opt::IRContext* ir_context, const opt::Function* function, const std::map>& merge_blocks_to_new_predecessors); // Returns true if the required ids for |merge_block| are provided in the // |merge_blocks_to_info| map, or if ids of the suitable type can be found. static bool CheckThatTheCorrectIdsAreGivenForMergeBlock( uint32_t merge_block, const std::map& merge_blocks_to_info, const std::map& types_to_available_id, bool function_is_void, opt::IRContext* ir_context, const TransformationContext& transformation_context, std::set* used_fresh_ids); protobufs::TransformationMergeFunctionReturns message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_MERGE_FUNCTION_RETURNS_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_move_block_down.cpp000066400000000000000000000105371475742701700300360ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_move_block_down.h" #include "source/opt/basic_block.h" namespace spvtools { namespace fuzz { TransformationMoveBlockDown::TransformationMoveBlockDown( protobufs::TransformationMoveBlockDown message) : message_(std::move(message)) {} TransformationMoveBlockDown::TransformationMoveBlockDown(uint32_t id) { message_.set_block_id(id); } bool TransformationMoveBlockDown::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { // Go through every block in every function, looking for a block whose id // matches that of the block we want to consider moving down. for (auto& function : *ir_context->module()) { for (auto block_it = function.begin(); block_it != function.end(); ++block_it) { if (block_it->id() == message_.block_id()) { // We have found a match. if (block_it == function.begin()) { // The block is the first one appearing in the function. We are not // allowed to move this block down. return false; } // Record the block we would like to consider moving down. opt::BasicBlock* block_matching_id = &*block_it; if (!ir_context->GetDominatorAnalysis(&function)->IsReachable( block_matching_id)) { // The block is not reachable. We are not allowed to move it down. return false; } // Now see whether there is some block following that block in program // order. ++block_it; if (block_it == function.end()) { // There is no such block; i.e., the block we are considering moving // is the last one in the function. The transformation thus does not // apply. return false; } opt::BasicBlock* next_block_in_program_order = &*block_it; // We can move the block of interest down if and only if it does not // dominate the block that comes next. return !ir_context->GetDominatorAnalysis(&function)->Dominates( block_matching_id, next_block_in_program_order); } } } // We did not find a matching block, so the transformation is not applicable: // there is no relevant block to move. return false; } void TransformationMoveBlockDown::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { // Go through every block in every function, looking for a block whose id // matches that of the block we want to move down. for (auto& function : *ir_context->module()) { for (auto block_it = function.begin(); block_it != function.end(); ++block_it) { if (block_it->id() == message_.block_id()) { ++block_it; assert(block_it != function.end() && "To be able to move a block down, it needs to have a " "program-order successor."); function.MoveBasicBlockToAfter(message_.block_id(), &*block_it); // For performance, it is vital to keep the dominator analysis valid // (which due to https://github.com/KhronosGroup/SPIRV-Tools/issues/2889 // requires keeping the CFG analysis valid). ir_context->InvalidateAnalysesExceptFor( opt::IRContext::Analysis::kAnalysisDefUse | opt::IRContext::Analysis::kAnalysisCFG | opt::IRContext::Analysis::kAnalysisDominatorAnalysis); return; } } } assert(false && "No block was found to move down."); } protobufs::Transformation TransformationMoveBlockDown::ToMessage() const { protobufs::Transformation result; *result.mutable_move_block_down() = message_; return result; } std::unordered_set TransformationMoveBlockDown::GetFreshIds() const { return std::unordered_set(); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_move_block_down.h000066400000000000000000000040461475742701700275010ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_MOVE_BLOCK_DOWN_H_ #define SOURCE_FUZZ_TRANSFORMATION_MOVE_BLOCK_DOWN_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationMoveBlockDown : public Transformation { public: explicit TransformationMoveBlockDown( protobufs::TransformationMoveBlockDown message); explicit TransformationMoveBlockDown(uint32_t id); // - |message_.block_id| must be the id of a block b in the given module. // - b must not be the first nor last block appearing, in program order, // in a function. // - b must not dominate the block that follows it in program order. // - b must be reachable. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // The block with id |message_.block_id| is moved down; i.e. the program order // between it and the block that follows it is swapped. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationMoveBlockDown message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_MOVE_BLOCK_DOWN_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_move_instruction_down.cpp000066400000000000000000000624351475742701700313310ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_move_instruction_down.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "spirv/unified1/GLSL.std.450.h" namespace spvtools { namespace fuzz { namespace { const char* const kExtensionSetName = "GLSL.std.450"; std::string GetExtensionSet(opt::IRContext* ir_context, const opt::Instruction& op_ext_inst) { assert(op_ext_inst.opcode() == spv::Op::OpExtInst && "Wrong opcode"); const auto* ext_inst_import = ir_context->get_def_use_mgr()->GetDef( op_ext_inst.GetSingleWordInOperand(0)); assert(ext_inst_import && "Extension set is not imported"); return ext_inst_import->GetInOperand(0).AsString(); } } // namespace TransformationMoveInstructionDown::TransformationMoveInstructionDown( protobufs::TransformationMoveInstructionDown message) : message_(std::move(message)) {} TransformationMoveInstructionDown::TransformationMoveInstructionDown( const protobufs::InstructionDescriptor& instruction) { *message_.mutable_instruction() = instruction; } bool TransformationMoveInstructionDown::IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const { // |instruction| must be valid. auto* inst = FindInstruction(message_.instruction(), ir_context); if (!inst) { return false; } // Instruction's opcode must be supported by this transformation. if (!IsInstructionSupported(ir_context, *inst)) { return false; } auto* inst_block = ir_context->get_instr_block(inst); assert(inst_block && "Global instructions and function parameters are not supported"); auto inst_it = fuzzerutil::GetIteratorForInstruction(inst_block, inst); assert(inst_it != inst_block->end() && "Can't get an iterator for the instruction"); // |instruction| can't be the last instruction in the block. auto successor_it = ++inst_it; if (successor_it == inst_block->end()) { return false; } // We don't risk swapping a memory instruction with an unsupported one. if (!IsSimpleInstruction(ir_context, *inst) && !IsInstructionSupported(ir_context, *successor_it)) { return false; } // It must be safe to swap the instructions without changing the semantics of // the module. if (IsInstructionSupported(ir_context, *successor_it) && !CanSafelySwapInstructions(ir_context, *inst, *successor_it, *transformation_context.GetFactManager())) { return false; } // Check that we can insert |instruction| after |inst_it|. auto successors_successor_it = ++inst_it; if (successors_successor_it == inst_block->end() || !fuzzerutil::CanInsertOpcodeBeforeInstruction(inst->opcode(), successors_successor_it)) { return false; } // Check that |instruction|'s successor doesn't depend on the |instruction|. if (inst->result_id()) { for (uint32_t i = 0; i < successor_it->NumInOperands(); ++i) { const auto& operand = successor_it->GetInOperand(i); if (spvIsInIdType(operand.type) && operand.words[0] == inst->result_id()) { return false; } } } return true; } void TransformationMoveInstructionDown::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { auto* inst = FindInstruction(message_.instruction(), ir_context); assert(inst && "The instruction should've been validated in the IsApplicable"); auto inst_it = fuzzerutil::GetIteratorForInstruction( ir_context->get_instr_block(inst), inst); // Move the instruction down in the block. inst->InsertAfter(&*++inst_it); ir_context->InvalidateAnalyses(opt::IRContext::kAnalysisNone); } protobufs::Transformation TransformationMoveInstructionDown::ToMessage() const { protobufs::Transformation result; *result.mutable_move_instruction_down() = message_; return result; } bool TransformationMoveInstructionDown::IsInstructionSupported( opt::IRContext* ir_context, const opt::Instruction& inst) { // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/3605): // Add support for more instructions here. return IsSimpleInstruction(ir_context, inst) || IsMemoryInstruction(ir_context, inst) || IsBarrierInstruction(inst); } bool TransformationMoveInstructionDown::IsSimpleInstruction( opt::IRContext* ir_context, const opt::Instruction& inst) { switch (inst.opcode()) { case spv::Op::OpNop: case spv::Op::OpUndef: case spv::Op::OpAccessChain: case spv::Op::OpInBoundsAccessChain: // OpAccessChain and OpInBoundsAccessChain are considered simple // instructions since they result in a pointer to the object in memory, // not the object itself. case spv::Op::OpVectorExtractDynamic: case spv::Op::OpVectorInsertDynamic: case spv::Op::OpVectorShuffle: case spv::Op::OpCompositeConstruct: case spv::Op::OpCompositeExtract: case spv::Op::OpCompositeInsert: case spv::Op::OpCopyObject: case spv::Op::OpTranspose: case spv::Op::OpConvertFToU: case spv::Op::OpConvertFToS: case spv::Op::OpConvertSToF: case spv::Op::OpConvertUToF: case spv::Op::OpUConvert: case spv::Op::OpSConvert: case spv::Op::OpFConvert: case spv::Op::OpQuantizeToF16: case spv::Op::OpSatConvertSToU: case spv::Op::OpSatConvertUToS: case spv::Op::OpBitcast: case spv::Op::OpSNegate: case spv::Op::OpFNegate: case spv::Op::OpIAdd: case spv::Op::OpFAdd: case spv::Op::OpISub: case spv::Op::OpFSub: case spv::Op::OpIMul: case spv::Op::OpFMul: case spv::Op::OpUDiv: case spv::Op::OpSDiv: case spv::Op::OpFDiv: case spv::Op::OpUMod: case spv::Op::OpSRem: case spv::Op::OpSMod: case spv::Op::OpFRem: case spv::Op::OpFMod: case spv::Op::OpVectorTimesScalar: case spv::Op::OpMatrixTimesScalar: case spv::Op::OpVectorTimesMatrix: case spv::Op::OpMatrixTimesVector: case spv::Op::OpMatrixTimesMatrix: case spv::Op::OpOuterProduct: case spv::Op::OpDot: case spv::Op::OpIAddCarry: case spv::Op::OpISubBorrow: case spv::Op::OpUMulExtended: case spv::Op::OpSMulExtended: case spv::Op::OpAny: case spv::Op::OpAll: case spv::Op::OpIsNan: case spv::Op::OpIsInf: case spv::Op::OpIsFinite: case spv::Op::OpIsNormal: case spv::Op::OpSignBitSet: case spv::Op::OpLessOrGreater: case spv::Op::OpOrdered: case spv::Op::OpUnordered: case spv::Op::OpLogicalEqual: case spv::Op::OpLogicalNotEqual: case spv::Op::OpLogicalOr: case spv::Op::OpLogicalAnd: case spv::Op::OpLogicalNot: case spv::Op::OpSelect: case spv::Op::OpIEqual: case spv::Op::OpINotEqual: case spv::Op::OpUGreaterThan: case spv::Op::OpSGreaterThan: case spv::Op::OpUGreaterThanEqual: case spv::Op::OpSGreaterThanEqual: case spv::Op::OpULessThan: case spv::Op::OpSLessThan: case spv::Op::OpULessThanEqual: case spv::Op::OpSLessThanEqual: case spv::Op::OpFOrdEqual: case spv::Op::OpFUnordEqual: case spv::Op::OpFOrdNotEqual: case spv::Op::OpFUnordNotEqual: case spv::Op::OpFOrdLessThan: case spv::Op::OpFUnordLessThan: case spv::Op::OpFOrdGreaterThan: case spv::Op::OpFUnordGreaterThan: case spv::Op::OpFOrdLessThanEqual: case spv::Op::OpFUnordLessThanEqual: case spv::Op::OpFOrdGreaterThanEqual: case spv::Op::OpFUnordGreaterThanEqual: case spv::Op::OpShiftRightLogical: case spv::Op::OpShiftRightArithmetic: case spv::Op::OpShiftLeftLogical: case spv::Op::OpBitwiseOr: case spv::Op::OpBitwiseXor: case spv::Op::OpBitwiseAnd: case spv::Op::OpNot: case spv::Op::OpBitFieldInsert: case spv::Op::OpBitFieldSExtract: case spv::Op::OpBitFieldUExtract: case spv::Op::OpBitReverse: case spv::Op::OpBitCount: case spv::Op::OpCopyLogical: return true; case spv::Op::OpExtInst: { const auto* ext_inst_import = ir_context->get_def_use_mgr()->GetDef(inst.GetSingleWordInOperand(0)); if (ext_inst_import->GetInOperand(0).AsString() != kExtensionSetName) { return false; } switch (static_cast(inst.GetSingleWordInOperand(1))) { case GLSLstd450Round: case GLSLstd450RoundEven: case GLSLstd450Trunc: case GLSLstd450FAbs: case GLSLstd450SAbs: case GLSLstd450FSign: case GLSLstd450SSign: case GLSLstd450Floor: case GLSLstd450Ceil: case GLSLstd450Fract: case GLSLstd450Radians: case GLSLstd450Degrees: case GLSLstd450Sin: case GLSLstd450Cos: case GLSLstd450Tan: case GLSLstd450Asin: case GLSLstd450Acos: case GLSLstd450Atan: case GLSLstd450Sinh: case GLSLstd450Cosh: case GLSLstd450Tanh: case GLSLstd450Asinh: case GLSLstd450Acosh: case GLSLstd450Atanh: case GLSLstd450Atan2: case GLSLstd450Pow: case GLSLstd450Exp: case GLSLstd450Log: case GLSLstd450Exp2: case GLSLstd450Log2: case GLSLstd450Sqrt: case GLSLstd450InverseSqrt: case GLSLstd450Determinant: case GLSLstd450MatrixInverse: case GLSLstd450ModfStruct: case GLSLstd450FMin: case GLSLstd450UMin: case GLSLstd450SMin: case GLSLstd450FMax: case GLSLstd450UMax: case GLSLstd450SMax: case GLSLstd450FClamp: case GLSLstd450UClamp: case GLSLstd450SClamp: case GLSLstd450FMix: case GLSLstd450IMix: case GLSLstd450Step: case GLSLstd450SmoothStep: case GLSLstd450Fma: case GLSLstd450FrexpStruct: case GLSLstd450Ldexp: case GLSLstd450PackSnorm4x8: case GLSLstd450PackUnorm4x8: case GLSLstd450PackSnorm2x16: case GLSLstd450PackUnorm2x16: case GLSLstd450PackHalf2x16: case GLSLstd450PackDouble2x32: case GLSLstd450UnpackSnorm2x16: case GLSLstd450UnpackUnorm2x16: case GLSLstd450UnpackHalf2x16: case GLSLstd450UnpackSnorm4x8: case GLSLstd450UnpackUnorm4x8: case GLSLstd450UnpackDouble2x32: case GLSLstd450Length: case GLSLstd450Distance: case GLSLstd450Cross: case GLSLstd450Normalize: case GLSLstd450FaceForward: case GLSLstd450Reflect: case GLSLstd450Refract: case GLSLstd450FindILsb: case GLSLstd450FindSMsb: case GLSLstd450FindUMsb: case GLSLstd450NMin: case GLSLstd450NMax: case GLSLstd450NClamp: return true; default: return false; } } default: return false; } } bool TransformationMoveInstructionDown::IsMemoryReadInstruction( opt::IRContext* ir_context, const opt::Instruction& inst) { switch (inst.opcode()) { // Some simple instructions. case spv::Op::OpLoad: case spv::Op::OpCopyMemory: // Image instructions. case spv::Op::OpImageSampleImplicitLod: case spv::Op::OpImageSampleExplicitLod: case spv::Op::OpImageSampleDrefImplicitLod: case spv::Op::OpImageSampleDrefExplicitLod: case spv::Op::OpImageSampleProjImplicitLod: case spv::Op::OpImageSampleProjExplicitLod: case spv::Op::OpImageSampleProjDrefImplicitLod: case spv::Op::OpImageSampleProjDrefExplicitLod: case spv::Op::OpImageFetch: case spv::Op::OpImageGather: case spv::Op::OpImageDrefGather: case spv::Op::OpImageRead: case spv::Op::OpImageSparseSampleImplicitLod: case spv::Op::OpImageSparseSampleExplicitLod: case spv::Op::OpImageSparseSampleDrefImplicitLod: case spv::Op::OpImageSparseSampleDrefExplicitLod: case spv::Op::OpImageSparseSampleProjImplicitLod: case spv::Op::OpImageSparseSampleProjExplicitLod: case spv::Op::OpImageSparseSampleProjDrefImplicitLod: case spv::Op::OpImageSparseSampleProjDrefExplicitLod: case spv::Op::OpImageSparseFetch: case spv::Op::OpImageSparseGather: case spv::Op::OpImageSparseDrefGather: case spv::Op::OpImageSparseRead: // Atomic instructions. case spv::Op::OpAtomicLoad: case spv::Op::OpAtomicExchange: case spv::Op::OpAtomicCompareExchange: case spv::Op::OpAtomicCompareExchangeWeak: case spv::Op::OpAtomicIIncrement: case spv::Op::OpAtomicIDecrement: case spv::Op::OpAtomicIAdd: case spv::Op::OpAtomicISub: case spv::Op::OpAtomicSMin: case spv::Op::OpAtomicUMin: case spv::Op::OpAtomicSMax: case spv::Op::OpAtomicUMax: case spv::Op::OpAtomicAnd: case spv::Op::OpAtomicOr: case spv::Op::OpAtomicXor: case spv::Op::OpAtomicFlagTestAndSet: return true; // Extensions. case spv::Op::OpExtInst: { if (GetExtensionSet(ir_context, inst) != kExtensionSetName) { return false; } switch (static_cast(inst.GetSingleWordInOperand(1))) { case GLSLstd450InterpolateAtCentroid: case GLSLstd450InterpolateAtOffset: case GLSLstd450InterpolateAtSample: return true; default: return false; } } default: return false; } } uint32_t TransformationMoveInstructionDown::GetMemoryReadTarget( opt::IRContext* ir_context, const opt::Instruction& inst) { (void)ir_context; // |ir_context| is only used in assertions. assert(IsMemoryReadInstruction(ir_context, inst) && "|inst| is not a memory read instruction"); switch (inst.opcode()) { // Simple instructions. case spv::Op::OpLoad: // Image instructions. case spv::Op::OpImageSampleImplicitLod: case spv::Op::OpImageSampleExplicitLod: case spv::Op::OpImageSampleDrefImplicitLod: case spv::Op::OpImageSampleDrefExplicitLod: case spv::Op::OpImageSampleProjImplicitLod: case spv::Op::OpImageSampleProjExplicitLod: case spv::Op::OpImageSampleProjDrefImplicitLod: case spv::Op::OpImageSampleProjDrefExplicitLod: case spv::Op::OpImageFetch: case spv::Op::OpImageGather: case spv::Op::OpImageDrefGather: case spv::Op::OpImageRead: case spv::Op::OpImageSparseSampleImplicitLod: case spv::Op::OpImageSparseSampleExplicitLod: case spv::Op::OpImageSparseSampleDrefImplicitLod: case spv::Op::OpImageSparseSampleDrefExplicitLod: case spv::Op::OpImageSparseSampleProjImplicitLod: case spv::Op::OpImageSparseSampleProjExplicitLod: case spv::Op::OpImageSparseSampleProjDrefImplicitLod: case spv::Op::OpImageSparseSampleProjDrefExplicitLod: case spv::Op::OpImageSparseFetch: case spv::Op::OpImageSparseGather: case spv::Op::OpImageSparseDrefGather: case spv::Op::OpImageSparseRead: // Atomic instructions. case spv::Op::OpAtomicLoad: case spv::Op::OpAtomicExchange: case spv::Op::OpAtomicCompareExchange: case spv::Op::OpAtomicCompareExchangeWeak: case spv::Op::OpAtomicIIncrement: case spv::Op::OpAtomicIDecrement: case spv::Op::OpAtomicIAdd: case spv::Op::OpAtomicISub: case spv::Op::OpAtomicSMin: case spv::Op::OpAtomicUMin: case spv::Op::OpAtomicSMax: case spv::Op::OpAtomicUMax: case spv::Op::OpAtomicAnd: case spv::Op::OpAtomicOr: case spv::Op::OpAtomicXor: case spv::Op::OpAtomicFlagTestAndSet: return inst.GetSingleWordInOperand(0); case spv::Op::OpCopyMemory: return inst.GetSingleWordInOperand(1); case spv::Op::OpExtInst: { assert(GetExtensionSet(ir_context, inst) == kExtensionSetName && "Extension set is not supported"); switch (static_cast(inst.GetSingleWordInOperand(1))) { case GLSLstd450InterpolateAtCentroid: case GLSLstd450InterpolateAtOffset: case GLSLstd450InterpolateAtSample: return inst.GetSingleWordInOperand(2); default: // This assertion will fail if not all memory read extension // instructions are handled in the switch. assert(false && "Not all memory opcodes are handled"); return 0; } } default: // This assertion will fail if not all memory read opcodes are handled in // the switch. assert(false && "Not all memory opcodes are handled"); return 0; } } bool TransformationMoveInstructionDown::IsMemoryWriteInstruction( opt::IRContext* ir_context, const opt::Instruction& inst) { switch (inst.opcode()) { // Simple Instructions. case spv::Op::OpStore: case spv::Op::OpCopyMemory: // Image instructions. case spv::Op::OpImageWrite: // Atomic instructions. case spv::Op::OpAtomicStore: case spv::Op::OpAtomicExchange: case spv::Op::OpAtomicCompareExchange: case spv::Op::OpAtomicCompareExchangeWeak: case spv::Op::OpAtomicIIncrement: case spv::Op::OpAtomicIDecrement: case spv::Op::OpAtomicIAdd: case spv::Op::OpAtomicISub: case spv::Op::OpAtomicSMin: case spv::Op::OpAtomicUMin: case spv::Op::OpAtomicSMax: case spv::Op::OpAtomicUMax: case spv::Op::OpAtomicAnd: case spv::Op::OpAtomicOr: case spv::Op::OpAtomicXor: case spv::Op::OpAtomicFlagTestAndSet: case spv::Op::OpAtomicFlagClear: return true; // Extensions. case spv::Op::OpExtInst: { if (GetExtensionSet(ir_context, inst) != kExtensionSetName) { return false; } auto extension = static_cast(inst.GetSingleWordInOperand(1)); return extension == GLSLstd450Modf || extension == GLSLstd450Frexp; } default: return false; } } uint32_t TransformationMoveInstructionDown::GetMemoryWriteTarget( opt::IRContext* ir_context, const opt::Instruction& inst) { (void)ir_context; // |ir_context| is only used in assertions. assert(IsMemoryWriteInstruction(ir_context, inst) && "|inst| is not a memory write instruction"); switch (inst.opcode()) { case spv::Op::OpStore: case spv::Op::OpCopyMemory: case spv::Op::OpImageWrite: case spv::Op::OpAtomicStore: case spv::Op::OpAtomicExchange: case spv::Op::OpAtomicCompareExchange: case spv::Op::OpAtomicCompareExchangeWeak: case spv::Op::OpAtomicIIncrement: case spv::Op::OpAtomicIDecrement: case spv::Op::OpAtomicIAdd: case spv::Op::OpAtomicISub: case spv::Op::OpAtomicSMin: case spv::Op::OpAtomicUMin: case spv::Op::OpAtomicSMax: case spv::Op::OpAtomicUMax: case spv::Op::OpAtomicAnd: case spv::Op::OpAtomicOr: case spv::Op::OpAtomicXor: case spv::Op::OpAtomicFlagTestAndSet: case spv::Op::OpAtomicFlagClear: return inst.GetSingleWordInOperand(0); case spv::Op::OpExtInst: { assert(GetExtensionSet(ir_context, inst) == kExtensionSetName && "Extension set is not supported"); switch (static_cast(inst.GetSingleWordInOperand(1))) { case GLSLstd450Modf: case GLSLstd450Frexp: return inst.GetSingleWordInOperand(3); default: // This assertion will fail if not all memory write extension // instructions are handled in the switch. assert(false && "Not all opcodes are handled"); return 0; } } default: // This assertion will fail if not all memory write opcodes are handled in // the switch. assert(false && "Not all opcodes are handled"); return 0; } } bool TransformationMoveInstructionDown::IsMemoryInstruction( opt::IRContext* ir_context, const opt::Instruction& inst) { return IsMemoryReadInstruction(ir_context, inst) || IsMemoryWriteInstruction(ir_context, inst); } bool TransformationMoveInstructionDown::IsBarrierInstruction( const opt::Instruction& inst) { switch (inst.opcode()) { case spv::Op::OpMemoryBarrier: case spv::Op::OpControlBarrier: case spv::Op::OpMemoryNamedBarrier: return true; default: return false; } } bool TransformationMoveInstructionDown::CanSafelySwapInstructions( opt::IRContext* ir_context, const opt::Instruction& a, const opt::Instruction& b, const FactManager& fact_manager) { assert(IsInstructionSupported(ir_context, a) && IsInstructionSupported(ir_context, b) && "Both opcodes must be supported"); // One of opcodes is simple - we can swap them without any side-effects. if (IsSimpleInstruction(ir_context, a) || IsSimpleInstruction(ir_context, b)) { return true; } // Both parameters are either memory instruction or barriers. // One of the opcodes is a barrier - can't swap them. if (IsBarrierInstruction(a) || IsBarrierInstruction(b)) { return false; } // Both parameters are memory instructions. // Both parameters only read from memory - it's OK to swap them. if (!IsMemoryWriteInstruction(ir_context, a) && !IsMemoryWriteInstruction(ir_context, b)) { return true; } // At least one of parameters is a memory read instruction. // In theory, we can swap two memory instructions, one of which reads // from the memory, if the read target (the pointer the memory is read from) // and the write target (the memory is written into): // - point to different memory regions // - point to the same region with irrelevant value // - point to the same region and the region is not used anymore. // // However, we can't currently determine if two pointers point to two // different memory regions. That being said, if two pointers are not // synonymous, they still might point to the same memory region. For example: // %1 = OpVariable ... // %2 = OpAccessChain %1 0 // %3 = OpAccessChain %1 0 // In this pseudo-code, %2 and %3 are not synonymous but point to the same // memory location. This implies that we can't determine if some memory // location is not used in the block. // // With this in mind, consider two cases (we will build a table for each one): // - one instruction only reads from memory, the other one only writes to it. // S - both point to the same memory region. // D - both point to different memory regions. // 0, 1, 2 - neither, one of or both of the memory regions are irrelevant. // |-| - can't swap; |+| - can swap. // | 0 | 1 | 2 | // S : - + + // D : + + + // - both instructions write to memory. Notation is the same. // | 0 | 1 | 2 | // S : * + + // D : + + + // * - we can swap two instructions that write into the same non-irrelevant // memory region if the written value is the same. // // Note that we can't always distinguish between S and D. Also note that // in case of S, if one of the instructions is marked with // PointeeValueIsIrrelevant, then the pointee of the other one is irrelevant // as well even if the instruction is not marked with that fact. // // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/3723): // This procedure can be improved when we can determine if two pointers point // to different memory regions. // From now on we will denote an instruction that: // - only reads from memory - R // - only writes into memory - W // - reads and writes - RW // // Both |a| and |b| can be either W or RW at this point. Additionally, at most // one of them can be R. The procedure below checks all possible combinations // of R, W and RW according to the tables above. We conservatively assume that // both |a| and |b| point to the same memory region. auto memory_is_irrelevant = [ir_context, &fact_manager](uint32_t id) { const auto* inst = ir_context->get_def_use_mgr()->GetDef(id); if (!inst->type_id()) { return false; } const auto* type = ir_context->get_type_mgr()->GetType(inst->type_id()); assert(type && "|id| has invalid type"); if (!type->AsPointer()) { return false; } return fact_manager.PointeeValueIsIrrelevant(id); }; if (IsMemoryWriteInstruction(ir_context, a) && IsMemoryWriteInstruction(ir_context, b) && (memory_is_irrelevant(GetMemoryWriteTarget(ir_context, a)) || memory_is_irrelevant(GetMemoryWriteTarget(ir_context, b)))) { // We ignore the case when the written value is the same. This is because // the written value might not be equal to any of the instruction's // operands. return true; } if (IsMemoryReadInstruction(ir_context, a) && IsMemoryWriteInstruction(ir_context, b) && !memory_is_irrelevant(GetMemoryReadTarget(ir_context, a)) && !memory_is_irrelevant(GetMemoryWriteTarget(ir_context, b))) { return false; } if (IsMemoryWriteInstruction(ir_context, a) && IsMemoryReadInstruction(ir_context, b) && !memory_is_irrelevant(GetMemoryWriteTarget(ir_context, a)) && !memory_is_irrelevant(GetMemoryReadTarget(ir_context, b))) { return false; } return IsMemoryReadInstruction(ir_context, a) || IsMemoryReadInstruction(ir_context, b); } std::unordered_set TransformationMoveInstructionDown::GetFreshIds() const { return std::unordered_set(); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_move_instruction_down.h000066400000000000000000000112571475742701700307720ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_MOVE_INSTRUCTION_DOWN_H_ #define SOURCE_FUZZ_TRANSFORMATION_MOVE_INSTRUCTION_DOWN_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationMoveInstructionDown : public Transformation { public: explicit TransformationMoveInstructionDown( protobufs::TransformationMoveInstructionDown message); explicit TransformationMoveInstructionDown( const protobufs::InstructionDescriptor& instruction); // - |instruction| should be a descriptor of a valid instruction in the module // - |instruction|'s opcode should be supported by this transformation // - neither |instruction| nor its successor may be the last instruction in // the block // - |instruction|'s successor may not be dependent on the |instruction| // - it should be possible to insert |instruction|'s opcode after its // successor bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Swaps |instruction| with its successor. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: // Returns true if the |inst| is supported by this transformation. static bool IsInstructionSupported(opt::IRContext* ir_context, const opt::Instruction& inst); // Returns true if |inst| represents a "simple" instruction. That is, it // neither reads from nor writes to the memory and is not a barrier. static bool IsSimpleInstruction(opt::IRContext* ir_context, const opt::Instruction& inst); // Returns true if |inst| reads from memory. static bool IsMemoryReadInstruction(opt::IRContext* ir_context, const opt::Instruction& inst); // Returns id being used by |inst| to read from. |inst| must be a memory read // instruction (see IsMemoryReadInstruction). Returned id is not guaranteed to // have pointer type. static uint32_t GetMemoryReadTarget(opt::IRContext* ir_context, const opt::Instruction& inst); // Returns true if |inst| that writes to the memory. static bool IsMemoryWriteInstruction(opt::IRContext* ir_context, const opt::Instruction& inst); // Returns id being used by |inst| to write into. |inst| must be a memory // write instruction (see IsMemoryWriteInstruction). Returned id is not // guaranteed to have pointer type. static uint32_t GetMemoryWriteTarget(opt::IRContext* ir_context, const opt::Instruction& inst); // Returns true if |inst| either reads from or writes to the memory // (see IsMemoryReadInstruction and IsMemoryWriteInstruction accordingly). static bool IsMemoryInstruction(opt::IRContext* ir_context, const opt::Instruction& inst); // Returns true if |inst| is a barrier instruction. static bool IsBarrierInstruction(const opt::Instruction& inst); // Returns true if it is possible to swap |a| and |b| without changing the // module's semantics. |a| and |b| are required to be supported instructions // (see IsInstructionSupported). In particular, if either |a| or |b| are // memory or barrier instructions, some checks are used to only say that they // can be swapped if the swap is definitely semantics-preserving. static bool CanSafelySwapInstructions(opt::IRContext* ir_context, const opt::Instruction& a, const opt::Instruction& b, const FactManager& fact_manager); protobufs::TransformationMoveInstructionDown message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_MOVE_INSTRUCTION_DOWN_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_mutate_pointer.cpp000066400000000000000000000157111475742701700277250ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_mutate_pointer.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" namespace spvtools { namespace fuzz { TransformationMutatePointer::TransformationMutatePointer( protobufs::TransformationMutatePointer message) : message_(std::move(message)) {} TransformationMutatePointer::TransformationMutatePointer( uint32_t pointer_id, uint32_t fresh_id, const protobufs::InstructionDescriptor& insert_before) { message_.set_pointer_id(pointer_id); message_.set_fresh_id(fresh_id); *message_.mutable_insert_before() = insert_before; } bool TransformationMutatePointer::IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const { // Check that |fresh_id| is fresh. if (!fuzzerutil::IsFreshId(ir_context, message_.fresh_id())) { return false; } auto* insert_before_inst = FindInstruction(message_.insert_before(), ir_context); // Check that |insert_before| is a valid instruction descriptor. if (!insert_before_inst) { return false; } // Check that it is possible to insert OpLoad and OpStore before // |insert_before_inst|. We are only using OpLoad here since the result does // not depend on the opcode. if (!fuzzerutil::CanInsertOpcodeBeforeInstruction(spv::Op::OpLoad, insert_before_inst)) { return false; } const auto* pointer_inst = ir_context->get_def_use_mgr()->GetDef(message_.pointer_id()); // Check that |pointer_id| is a result id of a valid pointer instruction. if (!pointer_inst || !IsValidPointerInstruction(ir_context, *pointer_inst)) { return false; } // Check that the module contains an irrelevant constant that will be used to // mutate |pointer_inst|. The constant is irrelevant so that the latter // transformation can change its value to something more interesting. auto constant_id = fuzzerutil::MaybeGetZeroConstant( ir_context, transformation_context, fuzzerutil::GetPointeeTypeIdFromPointerType(ir_context, pointer_inst->type_id()), true); if (!constant_id) { return false; } assert(fuzzerutil::IdIsAvailableBeforeInstruction( ir_context, insert_before_inst, constant_id) && "Global constant instruction is not available before " "|insert_before_inst|"); // Check that |pointer_inst| is available before |insert_before_inst|. return fuzzerutil::IdIsAvailableBeforeInstruction( ir_context, insert_before_inst, pointer_inst->result_id()); } void TransformationMutatePointer::Apply( opt::IRContext* ir_context, TransformationContext* transformation_context) const { auto* insert_before_inst = FindInstruction(message_.insert_before(), ir_context); assert(insert_before_inst && "|insert_before| descriptor is invalid"); opt::BasicBlock* enclosing_block = ir_context->get_instr_block(insert_before_inst); auto pointee_type_id = fuzzerutil::GetPointeeTypeIdFromPointerType( ir_context, fuzzerutil::GetTypeId(ir_context, message_.pointer_id())); // Back up the original value. auto backup_instruction = MakeUnique( ir_context, spv::Op::OpLoad, pointee_type_id, message_.fresh_id(), opt::Instruction::OperandList{ {SPV_OPERAND_TYPE_ID, {message_.pointer_id()}}}); auto backup_instruction_ptr = backup_instruction.get(); insert_before_inst->InsertBefore(std::move(backup_instruction)); ir_context->get_def_use_mgr()->AnalyzeInstDefUse(backup_instruction_ptr); ir_context->set_instr_block(backup_instruction_ptr, enclosing_block); // Insert a new value. auto new_value_instruction = MakeUnique( ir_context, spv::Op::OpStore, 0, 0, opt::Instruction::OperandList{ {SPV_OPERAND_TYPE_ID, {message_.pointer_id()}}, {SPV_OPERAND_TYPE_ID, {fuzzerutil::MaybeGetZeroConstant( ir_context, *transformation_context, pointee_type_id, true)}}}); auto new_value_instruction_ptr = new_value_instruction.get(); insert_before_inst->InsertBefore(std::move(new_value_instruction)); ir_context->get_def_use_mgr()->AnalyzeInstDefUse(new_value_instruction_ptr); ir_context->set_instr_block(new_value_instruction_ptr, enclosing_block); // Restore the original value. auto restore_instruction = MakeUnique( ir_context, spv::Op::OpStore, 0, 0, opt::Instruction::OperandList{ {SPV_OPERAND_TYPE_ID, {message_.pointer_id()}}, {SPV_OPERAND_TYPE_ID, {message_.fresh_id()}}}); auto restore_instruction_ptr = restore_instruction.get(); insert_before_inst->InsertBefore(std::move(restore_instruction)); ir_context->get_def_use_mgr()->AnalyzeInstDefUse(restore_instruction_ptr); ir_context->set_instr_block(restore_instruction_ptr, enclosing_block); fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id()); } protobufs::Transformation TransformationMutatePointer::ToMessage() const { protobufs::Transformation result; *result.mutable_mutate_pointer() = message_; return result; } bool TransformationMutatePointer::IsValidPointerInstruction( opt::IRContext* ir_context, const opt::Instruction& inst) { // |inst| must have both result id and type id and it may not cause undefined // behaviour. if (!inst.result_id() || !inst.type_id() || inst.opcode() == spv::Op::OpUndef || inst.opcode() == spv::Op::OpConstantNull) { return false; } opt::Instruction* type_inst = ir_context->get_def_use_mgr()->GetDef(inst.type_id()); assert(type_inst != nullptr && "|inst| has invalid type id"); // |inst| must be a pointer. if (type_inst->opcode() != spv::Op::OpTypePointer) { return false; } // |inst| must have a supported storage class. switch ( static_cast(type_inst->GetSingleWordInOperand(0))) { case spv::StorageClass::Function: case spv::StorageClass::Private: case spv::StorageClass::Workgroup: break; default: return false; } // |inst|'s pointee must consist of scalars and/or composites. return fuzzerutil::CanCreateConstant(ir_context, type_inst->GetSingleWordInOperand(1)); } std::unordered_set TransformationMutatePointer::GetFreshIds() const { return {message_.fresh_id()}; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_mutate_pointer.h000066400000000000000000000061211475742701700273650ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_MUTATE_POINTER_H_ #define SOURCE_FUZZ_TRANSFORMATION_MUTATE_POINTER_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationMutatePointer : public Transformation { public: explicit TransformationMutatePointer( protobufs::TransformationMutatePointer message); explicit TransformationMutatePointer( uint32_t pointer_id, uint32_t fresh_id, const protobufs::InstructionDescriptor& insert_before); // - |fresh_id| must be fresh. // - |insert_before| must be a valid instruction descriptor of some // instruction in the module. // - It should be possible to insert OpLoad and OpStore before // |insert_before|. // - |pointer_id| must be a result id of some instruction in the module. // - Instruction with result id |pointer_id| must be valid (see // IsValidPointerInstruction method). // - There must exist an irrelevant constant in the module. Type of the // constant must be equal to the type of the |pointer_id|'s pointee. // - |pointer_id| must be available (according to the dominance rules) before // |insert_before|. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Inserts the following instructions before |insert_before|: // %fresh_id = OpLoad %pointee_type_id %pointer_id // OpStore %pointer_id %constant_id // OpStore %pointer_id %fresh_id void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; // Returns true if |inst| valid pointer according to the following: // - |inst| has result id and type id. // - |inst| is neither OpUndef nor OpConstantNull. // - |inst| has a pointer type. // - |inst|'s storage class is either Private, Function or Workgroup. // - |inst|'s pointee type and all its constituents are either scalar or // composite. static bool IsValidPointerInstruction(opt::IRContext* ir_context, const opt::Instruction& inst); private: protobufs::TransformationMutatePointer message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_MUTATE_POINTER_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_outline_function.cpp000066400000000000000000001251611475742701700302530ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_outline_function.h" #include #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { TransformationOutlineFunction::TransformationOutlineFunction( protobufs::TransformationOutlineFunction message) : message_(std::move(message)) {} TransformationOutlineFunction::TransformationOutlineFunction( uint32_t entry_block, uint32_t exit_block, uint32_t new_function_struct_return_type_id, uint32_t new_function_type_id, uint32_t new_function_id, uint32_t new_function_region_entry_block, uint32_t new_caller_result_id, uint32_t new_callee_result_id, const std::map& input_id_to_fresh_id, const std::map& output_id_to_fresh_id) { message_.set_entry_block(entry_block); message_.set_exit_block(exit_block); message_.set_new_function_struct_return_type_id( new_function_struct_return_type_id); message_.set_new_function_type_id(new_function_type_id); message_.set_new_function_id(new_function_id); message_.set_new_function_region_entry_block(new_function_region_entry_block); message_.set_new_caller_result_id(new_caller_result_id); message_.set_new_callee_result_id(new_callee_result_id); *message_.mutable_input_id_to_fresh_id() = fuzzerutil::MapToRepeatedUInt32Pair(input_id_to_fresh_id); *message_.mutable_output_id_to_fresh_id() = fuzzerutil::MapToRepeatedUInt32Pair(output_id_to_fresh_id); } bool TransformationOutlineFunction::IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const { std::set ids_used_by_this_transformation; // The various new ids used by the transformation must be fresh and distinct. if (!CheckIdIsFreshAndNotUsedByThisTransformation( message_.new_function_struct_return_type_id(), ir_context, &ids_used_by_this_transformation)) { return false; } if (!CheckIdIsFreshAndNotUsedByThisTransformation( message_.new_function_type_id(), ir_context, &ids_used_by_this_transformation)) { return false; } if (!CheckIdIsFreshAndNotUsedByThisTransformation( message_.new_function_id(), ir_context, &ids_used_by_this_transformation)) { return false; } if (!CheckIdIsFreshAndNotUsedByThisTransformation( message_.new_function_region_entry_block(), ir_context, &ids_used_by_this_transformation)) { return false; } if (!CheckIdIsFreshAndNotUsedByThisTransformation( message_.new_caller_result_id(), ir_context, &ids_used_by_this_transformation)) { return false; } if (!CheckIdIsFreshAndNotUsedByThisTransformation( message_.new_callee_result_id(), ir_context, &ids_used_by_this_transformation)) { return false; } for (auto& pair : message_.input_id_to_fresh_id()) { if (!CheckIdIsFreshAndNotUsedByThisTransformation( pair.second(), ir_context, &ids_used_by_this_transformation)) { return false; } } for (auto& pair : message_.output_id_to_fresh_id()) { if (!CheckIdIsFreshAndNotUsedByThisTransformation( pair.second(), ir_context, &ids_used_by_this_transformation)) { return false; } } // The entry and exit block ids must indeed refer to blocks. for (auto block_id : {message_.entry_block(), message_.exit_block()}) { auto block_label = ir_context->get_def_use_mgr()->GetDef(block_id); if (!block_label || block_label->opcode() != spv::Op::OpLabel) { return false; } } auto entry_block = ir_context->cfg()->block(message_.entry_block()); auto exit_block = ir_context->cfg()->block(message_.exit_block()); // The entry block cannot start with OpVariable - this would mean that // outlining would remove a variable from the function containing the region // being outlined. if (entry_block->begin()->opcode() == spv::Op::OpVariable) { return false; } // For simplicity, we do not allow the entry block to be a loop header. if (entry_block->GetLoopMergeInst()) { return false; } // For simplicity, we do not allow the exit block to be a merge block or // continue target. if (fuzzerutil::IsMergeOrContinue(ir_context, exit_block->id())) { return false; } // The entry block cannot start with OpPhi. This is to keep the // transformation logic simple. (Another transformation to split the OpPhis // from a block could be applied to avoid this scenario.) if (entry_block->begin()->opcode() == spv::Op::OpPhi) { return false; } // The block must be in the same function. if (entry_block->GetParent() != exit_block->GetParent()) { return false; } // The entry block must dominate the exit block. auto dominator_analysis = ir_context->GetDominatorAnalysis(entry_block->GetParent()); if (!dominator_analysis->Dominates(entry_block, exit_block)) { return false; } // The exit block must post-dominate the entry block. auto postdominator_analysis = ir_context->GetPostDominatorAnalysis(entry_block->GetParent()); if (!postdominator_analysis->Dominates(exit_block, entry_block)) { return false; } // Find all the blocks dominated by |message_.entry_block| and post-dominated // by |message_.exit_block|. auto region_set = GetRegionBlocks( ir_context, entry_block = ir_context->cfg()->block(message_.entry_block()), exit_block = ir_context->cfg()->block(message_.exit_block())); // Check whether |region_set| really is a single-entry single-exit region, and // also check whether structured control flow constructs and their merge // and continue constructs are either wholly in or wholly out of the region - // e.g. avoid the situation where the region contains the head of a loop but // not the loop's continue construct. // // This is achieved by going through every block in the function that contains // the region. for (auto& block : *entry_block->GetParent()) { if (region_set.count(&block) != 0) { // The block is in the region. Check that it does not have any unreachable // predecessors. If it does, then we do not regard the region as single- // entry-single-exit and hence do not outline it. for (auto pred : ir_context->cfg()->preds(block.id())) { if (!ir_context->IsReachable(*ir_context->cfg()->block(pred))) { // The predecessor is unreachable. return false; } } } if (&block == exit_block) { // It is OK (and typically expected) for the exit block of the region to // have successors outside the region. // // It is also OK for the exit block to head a selection construct: the // block containing the call to the outlined function will end up heading // this construct if outlining takes place. However, it is not OK for // the exit block to head a loop construct. if (block.GetLoopMergeInst()) { return false; } continue; } if (region_set.count(&block) != 0) { // The block is in the region and is not the region's exit block. Let's // see whether all of the block's successors are in the region. If they // are not, the region is not single-entry single-exit. bool all_successors_in_region = true; block.WhileEachSuccessorLabel([&all_successors_in_region, ir_context, ®ion_set](uint32_t successor) -> bool { if (region_set.count(ir_context->cfg()->block(successor)) == 0) { all_successors_in_region = false; return false; } return true; }); if (!all_successors_in_region) { return false; } } if (auto merge = block.GetMergeInst()) { // The block is a loop or selection header -- the header and its // associated merge block had better both be in the region or both be // outside the region. auto merge_block = ir_context->cfg()->block(merge->GetSingleWordOperand(0)); if (region_set.count(&block) != region_set.count(merge_block)) { return false; } } if (auto loop_merge = block.GetLoopMergeInst()) { // Similar to the above, but for the continue target of a loop. auto continue_target = ir_context->cfg()->block(loop_merge->GetSingleWordOperand(1)); if (continue_target != exit_block && region_set.count(&block) != region_set.count(continue_target)) { return false; } } } // For each region input id, i.e. every id defined outside the region but // used inside the region, ... auto input_id_to_fresh_id_map = fuzzerutil::RepeatedUInt32PairToMap(message_.input_id_to_fresh_id()); for (auto id : GetRegionInputIds(ir_context, region_set, exit_block)) { // There needs to be a corresponding fresh id to be used as a function // parameter, or overflow ids need to be available. if (input_id_to_fresh_id_map.count(id) == 0 && !transformation_context.GetOverflowIdSource()->HasOverflowIds()) { return false; } // Furthermore, if the input id has pointer type it must be an OpVariable // or OpFunctionParameter. auto input_id_inst = ir_context->get_def_use_mgr()->GetDef(id); if (ir_context->get_def_use_mgr() ->GetDef(input_id_inst->type_id()) ->opcode() == spv::Op::OpTypePointer) { switch (input_id_inst->opcode()) { case spv::Op::OpFunctionParameter: case spv::Op::OpVariable: // These are OK. break; default: // Anything else is not OK. return false; } } } // For each region output id -- i.e. every id defined inside the region but // used outside the region, ... auto output_id_to_fresh_id_map = fuzzerutil::RepeatedUInt32PairToMap(message_.output_id_to_fresh_id()); for (auto id : GetRegionOutputIds(ir_context, region_set, exit_block)) { if ( // ... there needs to be a corresponding fresh id that can hold the // value for this id computed in the outlined function (or overflow ids // must be available), and ... (output_id_to_fresh_id_map.count(id) == 0 && !transformation_context.GetOverflowIdSource()->HasOverflowIds()) // ... the output id must not have pointer type (to avoid creating a // struct with pointer members to pass data out of the outlined // function) || ir_context->get_def_use_mgr() ->GetDef(fuzzerutil::GetTypeId(ir_context, id)) ->opcode() == spv::Op::OpTypePointer) { return false; } } return true; } void TransformationOutlineFunction::Apply( opt::IRContext* ir_context, TransformationContext* transformation_context) const { // The entry block for the region before outlining. auto original_region_entry_block = ir_context->cfg()->block(message_.entry_block()); // The exit block for the region before outlining. auto original_region_exit_block = ir_context->cfg()->block(message_.exit_block()); // The single-entry single-exit region defined by |message_.entry_block| and // |message_.exit_block|. std::set region_blocks = GetRegionBlocks( ir_context, original_region_entry_block, original_region_exit_block); // Input and output ids for the region being outlined. std::vector region_input_ids = GetRegionInputIds(ir_context, region_blocks, original_region_exit_block); std::vector region_output_ids = GetRegionOutputIds(ir_context, region_blocks, original_region_exit_block); // Maps from input and output ids to fresh ids. auto input_id_to_fresh_id_map = fuzzerutil::RepeatedUInt32PairToMap(message_.input_id_to_fresh_id()); auto output_id_to_fresh_id_map = fuzzerutil::RepeatedUInt32PairToMap(message_.output_id_to_fresh_id()); // Use overflow ids to augment these maps at any locations where fresh ids are // required but not provided. for (uint32_t id : region_input_ids) { if (input_id_to_fresh_id_map.count(id) == 0) { input_id_to_fresh_id_map.insert( {id, transformation_context->GetOverflowIdSource()->GetNextOverflowId()}); } } for (uint32_t id : region_output_ids) { if (output_id_to_fresh_id_map.count(id) == 0) { output_id_to_fresh_id_map.insert( {id, transformation_context->GetOverflowIdSource()->GetNextOverflowId()}); } } UpdateModuleIdBoundForFreshIds(ir_context, input_id_to_fresh_id_map, output_id_to_fresh_id_map); // Construct a map that associates each output id with its type id. std::map output_id_to_type_id; for (uint32_t output_id : region_output_ids) { output_id_to_type_id[output_id] = ir_context->get_def_use_mgr()->GetDef(output_id)->type_id(); } // The region will be collapsed to a single block that calls a function // containing the outlined region. This block needs to end with whatever // the exit block of the region ended with before outlining. We thus clone // the terminator of the region's exit block, and the merge instruction for // the block if there is one, so that we can append them to the end of the // collapsed block later. std::unique_ptr cloned_exit_block_terminator = std::unique_ptr( original_region_exit_block->terminator()->Clone(ir_context)); std::unique_ptr cloned_exit_block_merge = original_region_exit_block->GetMergeInst() ? std::unique_ptr( original_region_exit_block->GetMergeInst()->Clone(ir_context)) : nullptr; // Make a function prototype for the outlined function, which involves // figuring out its required type. std::unique_ptr outlined_function = PrepareFunctionPrototype( region_input_ids, region_output_ids, input_id_to_fresh_id_map, ir_context, transformation_context); // Adapt the region to be outlined so that its input ids are replaced with the // ids of the outlined function's input parameters, and so that output ids // are similarly remapped. RemapInputAndOutputIdsInRegion( ir_context, *original_region_exit_block, region_blocks, region_input_ids, region_output_ids, input_id_to_fresh_id_map, output_id_to_fresh_id_map); // Fill out the body of the outlined function according to the region that is // being outlined. PopulateOutlinedFunction( *original_region_entry_block, *original_region_exit_block, region_blocks, region_output_ids, output_id_to_type_id, output_id_to_fresh_id_map, ir_context, outlined_function.get()); // Collapse the region that has been outlined into a function down to a single // block that calls said function. ShrinkOriginalRegion( ir_context, region_blocks, region_input_ids, region_output_ids, output_id_to_type_id, outlined_function->type_id(), std::move(cloned_exit_block_merge), std::move(cloned_exit_block_terminator), original_region_entry_block); // Add the outlined function to the module. const auto* outlined_function_ptr = outlined_function.get(); ir_context->module()->AddFunction(std::move(outlined_function)); // Major surgery has been conducted on the module, so invalidate all analyses. ir_context->InvalidateAnalysesExceptFor( opt::IRContext::Analysis::kAnalysisNone); // If the original function was livesafe, the new function should also be // livesafe. if (transformation_context->GetFactManager()->FunctionIsLivesafe( original_region_entry_block->GetParent()->result_id())) { transformation_context->GetFactManager()->AddFactFunctionIsLivesafe( message_.new_function_id()); } // Record the fact that all blocks in the outlined region are dead if the // first block is dead. if (transformation_context->GetFactManager()->BlockIsDead( original_region_entry_block->id())) { transformation_context->GetFactManager()->AddFactBlockIsDead( outlined_function_ptr->entry()->id()); } } protobufs::Transformation TransformationOutlineFunction::ToMessage() const { protobufs::Transformation result; *result.mutable_outline_function() = message_; return result; } std::vector TransformationOutlineFunction::GetRegionInputIds( opt::IRContext* ir_context, const std::set& region_set, opt::BasicBlock* region_exit_block) { std::vector result; auto enclosing_function = region_exit_block->GetParent(); // Consider each parameter of the function containing the region. enclosing_function->ForEachParam( [ir_context, ®ion_set, &result](opt::Instruction* function_parameter) { // Consider every use of the parameter. ir_context->get_def_use_mgr()->WhileEachUse( function_parameter, [ir_context, function_parameter, ®ion_set, &result]( opt::Instruction* use, uint32_t /*unused*/) { // Get the block, if any, in which the parameter is used. auto use_block = ir_context->get_instr_block(use); // If the use is in a block that lies within the region, the // parameter is an input id for the region. if (use_block && region_set.count(use_block) != 0) { result.push_back(function_parameter->result_id()); return false; } return true; }); }); // Consider all definitions in the function that might turn out to be input // ids. for (auto& block : *enclosing_function) { std::vector candidate_input_ids_for_block; if (region_set.count(&block) == 0) { // All instructions in blocks outside the region are candidate's for // generating input ids. for (auto& inst : block) { candidate_input_ids_for_block.push_back(&inst); } } else { // Blocks in the region cannot generate input ids. continue; } // Consider each candidate input id to check whether it is used in the // region. for (auto& inst : candidate_input_ids_for_block) { ir_context->get_def_use_mgr()->WhileEachUse( inst, [ir_context, &inst, region_exit_block, ®ion_set, &result]( opt::Instruction* use, uint32_t /*unused*/) -> bool { // Find the block in which this id use occurs, recording the id as // an input id if the block is outside the region, with some // exceptions detailed below. auto use_block = ir_context->get_instr_block(use); if (!use_block) { // There might be no containing block, e.g. if the use is in a // decoration. return true; } if (region_set.count(use_block) == 0) { // The use is not in the region: this does not make it an input // id. return true; } if (use_block == region_exit_block && use->IsBlockTerminator()) { // We do not regard uses in the exit block terminator as input // ids, as this terminator does not get outlined. return true; } result.push_back(inst->result_id()); return false; }); } } return result; } std::vector TransformationOutlineFunction::GetRegionOutputIds( opt::IRContext* ir_context, const std::set& region_set, opt::BasicBlock* region_exit_block) { std::vector result; // Consider each block in the function containing the region. for (auto& block : *region_exit_block->GetParent()) { if (region_set.count(&block) == 0) { // Skip blocks that are not in the region. continue; } // Consider each use of each instruction defined in the block. for (auto& inst : block) { ir_context->get_def_use_mgr()->WhileEachUse( &inst, [®ion_set, ir_context, &inst, region_exit_block, &result]( opt::Instruction* use, uint32_t /*unused*/) -> bool { // Find the block in which this id use occurs, recording the id as // an output id if the block is outside the region, with some // exceptions detailed below. auto use_block = ir_context->get_instr_block(use); if (!use_block) { // There might be no containing block, e.g. if the use is in a // decoration. return true; } if (region_set.count(use_block) != 0) { // The use is in the region. if (use_block != region_exit_block || !use->IsBlockTerminator()) { // Furthermore, the use is not in the terminator of the region's // exit block. return true; } } result.push_back(inst.result_id()); return false; }); } } return result; } std::set TransformationOutlineFunction::GetRegionBlocks( opt::IRContext* ir_context, opt::BasicBlock* entry_block, opt::BasicBlock* exit_block) { auto enclosing_function = entry_block->GetParent(); auto dominator_analysis = ir_context->GetDominatorAnalysis(enclosing_function); auto postdominator_analysis = ir_context->GetPostDominatorAnalysis(enclosing_function); std::set result; for (auto& block : *enclosing_function) { if (dominator_analysis->Dominates(entry_block, &block) && postdominator_analysis->Dominates(exit_block, &block)) { result.insert(&block); } } return result; } std::unique_ptr TransformationOutlineFunction::PrepareFunctionPrototype( const std::vector& region_input_ids, const std::vector& region_output_ids, const std::map& input_id_to_fresh_id_map, opt::IRContext* ir_context, TransformationContext* transformation_context) const { uint32_t return_type_id = 0; uint32_t function_type_id = 0; // First, try to find an existing function type that is suitable. This is // only possible if the region generates no output ids; if it generates output // ids we are going to make a new struct for those, and since that struct does // not exist there cannot already be a function type with this struct as its // return type. if (region_output_ids.empty()) { std::vector return_and_parameter_types; opt::analysis::Void void_type; return_type_id = ir_context->get_type_mgr()->GetId(&void_type); return_and_parameter_types.push_back(return_type_id); for (auto id : region_input_ids) { return_and_parameter_types.push_back( ir_context->get_def_use_mgr()->GetDef(id)->type_id()); } function_type_id = fuzzerutil::FindFunctionType(ir_context, return_and_parameter_types); } // If no existing function type was found, we need to create one. if (function_type_id == 0) { assert( ((return_type_id == 0) == !region_output_ids.empty()) && "We should only have set the return type if there are no output ids."); // If the region generates output ids, we need to make a struct with one // field per output id. if (!region_output_ids.empty()) { opt::Instruction::OperandList struct_member_types; for (uint32_t output_id : region_output_ids) { auto output_id_type = ir_context->get_def_use_mgr()->GetDef(output_id)->type_id(); if (ir_context->get_def_use_mgr()->GetDef(output_id_type)->opcode() == spv::Op::OpTypeVoid) { // We cannot add a void field to a struct. We instead use OpUndef to // handle void output ids. continue; } struct_member_types.push_back({SPV_OPERAND_TYPE_ID, {output_id_type}}); } // Add a new struct type to the module. ir_context->module()->AddType(MakeUnique( ir_context, spv::Op::OpTypeStruct, 0, message_.new_function_struct_return_type_id(), std::move(struct_member_types))); // The return type for the function is the newly-created struct. return_type_id = message_.new_function_struct_return_type_id(); } assert( return_type_id != 0 && "We should either have a void return type, or have created a struct."); // The region's input ids dictate the parameter types to the function. opt::Instruction::OperandList function_type_operands; function_type_operands.push_back({SPV_OPERAND_TYPE_ID, {return_type_id}}); for (auto id : region_input_ids) { function_type_operands.push_back( {SPV_OPERAND_TYPE_ID, {ir_context->get_def_use_mgr()->GetDef(id)->type_id()}}); } // Add a new function type to the module, and record that this is the type // id for the new function. ir_context->module()->AddType(MakeUnique( ir_context, spv::Op::OpTypeFunction, 0, message_.new_function_type_id(), function_type_operands)); function_type_id = message_.new_function_type_id(); } // Create a new function with |message_.new_function_id| as the function id, // and the return type and function type prepared above. std::unique_ptr outlined_function = MakeUnique(MakeUnique( ir_context, spv::Op::OpFunction, return_type_id, message_.new_function_id(), opt::Instruction::OperandList( {{spv_operand_type_t ::SPV_OPERAND_TYPE_LITERAL_INTEGER, {uint32_t(spv::FunctionControlMask::MaskNone)}}, {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {function_type_id}}}))); // Add one parameter to the function for each input id, using the fresh ids // provided in |input_id_to_fresh_id_map|, or overflow ids if needed. for (auto id : region_input_ids) { uint32_t fresh_id = input_id_to_fresh_id_map.at(id); outlined_function->AddParameter(MakeUnique( ir_context, spv::Op::OpFunctionParameter, ir_context->get_def_use_mgr()->GetDef(id)->type_id(), fresh_id, opt::Instruction::OperandList())); // Analyse the use of the new parameter instruction. outlined_function->ForEachParam( [fresh_id, ir_context](opt::Instruction* inst) { if (inst->result_id() == fresh_id) { ir_context->AnalyzeDefUse(inst); } }); // If the input id is an irrelevant-valued variable, the same should be true // of the corresponding parameter. if (transformation_context->GetFactManager()->PointeeValueIsIrrelevant( id)) { transformation_context->GetFactManager() ->AddFactValueOfPointeeIsIrrelevant(input_id_to_fresh_id_map.at(id)); } } return outlined_function; } void TransformationOutlineFunction::UpdateModuleIdBoundForFreshIds( opt::IRContext* ir_context, const std::map& input_id_to_fresh_id_map, const std::map& output_id_to_fresh_id_map) const { // Enlarge the module's id bound as needed to accommodate the various fresh // ids associated with the transformation. fuzzerutil::UpdateModuleIdBound( ir_context, message_.new_function_struct_return_type_id()); fuzzerutil::UpdateModuleIdBound(ir_context, message_.new_function_type_id()); fuzzerutil::UpdateModuleIdBound(ir_context, message_.new_function_id()); fuzzerutil::UpdateModuleIdBound(ir_context, message_.new_function_region_entry_block()); fuzzerutil::UpdateModuleIdBound(ir_context, message_.new_caller_result_id()); fuzzerutil::UpdateModuleIdBound(ir_context, message_.new_callee_result_id()); for (auto& entry : input_id_to_fresh_id_map) { fuzzerutil::UpdateModuleIdBound(ir_context, entry.second); } for (auto& entry : output_id_to_fresh_id_map) { fuzzerutil::UpdateModuleIdBound(ir_context, entry.second); } } void TransformationOutlineFunction::RemapInputAndOutputIdsInRegion( opt::IRContext* ir_context, const opt::BasicBlock& original_region_exit_block, const std::set& region_blocks, const std::vector& region_input_ids, const std::vector& region_output_ids, const std::map& input_id_to_fresh_id_map, const std::map& output_id_to_fresh_id_map) const { // Change all uses of input ids inside the region to the corresponding fresh // ids that will ultimately be parameters of the outlined function. // This is done by considering each region input id in turn. for (uint32_t id : region_input_ids) { // We then consider each use of the input id. ir_context->get_def_use_mgr()->ForEachUse( id, [ir_context, id, &input_id_to_fresh_id_map, region_blocks]( opt::Instruction* use, uint32_t operand_index) { // Find the block in which this use of the input id occurs. opt::BasicBlock* use_block = ir_context->get_instr_block(use); // We want to rewrite the use id if its block occurs in the outlined // region. if (region_blocks.count(use_block) != 0) { // Rewrite this use of the input id. use->SetOperand(operand_index, {input_id_to_fresh_id_map.at(id)}); } }); } // Change each definition of a region output id to define the corresponding // fresh ids that will store intermediate value for the output ids. Also // change all uses of the output id located in the outlined region. // This is done by considering each region output id in turn. for (uint32_t id : region_output_ids) { // First consider each use of the output id and update the relevant uses. ir_context->get_def_use_mgr()->ForEachUse( id, [ir_context, &original_region_exit_block, id, &output_id_to_fresh_id_map, region_blocks](opt::Instruction* use, uint32_t operand_index) { // Find the block in which this use of the output id occurs. auto use_block = ir_context->get_instr_block(use); // We want to rewrite the use id if its block occurs in the outlined // region, with one exception: the terminator of the exit block of // the region is going to remain in the original function, so if the // use appears in such a terminator instruction we leave it alone. if ( // The block is in the region ... region_blocks.count(use_block) != 0 && // ... and the use is not in the terminator instruction of the // region's exit block. !(use_block == &original_region_exit_block && use->IsBlockTerminator())) { // Rewrite this use of the output id. use->SetOperand(operand_index, {output_id_to_fresh_id_map.at(id)}); } }); // Now change the instruction that defines the output id so that it instead // defines the corresponding fresh id. We do this after changing all the // uses so that the definition of the original id is still registered when // we analyse its uses. ir_context->get_def_use_mgr()->GetDef(id)->SetResultId( output_id_to_fresh_id_map.at(id)); } } void TransformationOutlineFunction::PopulateOutlinedFunction( const opt::BasicBlock& original_region_entry_block, const opt::BasicBlock& original_region_exit_block, const std::set& region_blocks, const std::vector& region_output_ids, const std::map& output_id_to_type_id, const std::map& output_id_to_fresh_id_map, opt::IRContext* ir_context, opt::Function* outlined_function) const { // When we create the exit block for the outlined region, we use this pointer // to track of it so that we can manipulate it later. opt::BasicBlock* outlined_region_exit_block = nullptr; // The region entry block in the new function is identical to the entry block // of the region being outlined, except that it has // |message_.new_function_region_entry_block| as its id. std::unique_ptr outlined_region_entry_block = MakeUnique(MakeUnique( ir_context, spv::Op::OpLabel, 0, message_.new_function_region_entry_block(), opt::Instruction::OperandList())); if (&original_region_entry_block == &original_region_exit_block) { outlined_region_exit_block = outlined_region_entry_block.get(); } for (auto& inst : original_region_entry_block) { outlined_region_entry_block->AddInstruction( std::unique_ptr(inst.Clone(ir_context))); } outlined_function->AddBasicBlock(std::move(outlined_region_entry_block)); // We now go through the single-entry single-exit region defined by the entry // and exit blocks, adding clones of all blocks to the new function. // Consider every block in the enclosing function. auto enclosing_function = original_region_entry_block.GetParent(); for (auto block_it = enclosing_function->begin(); block_it != enclosing_function->end();) { // Skip the region's entry block - we already dealt with it above. if (region_blocks.count(&*block_it) == 0 || &*block_it == &original_region_entry_block) { ++block_it; continue; } // Clone the block so that it can be added to the new function. auto cloned_block = std::unique_ptr(block_it->Clone(ir_context)); // If this is the region's exit block, then the cloned block is the outlined // region's exit block. if (&*block_it == &original_region_exit_block) { assert(outlined_region_exit_block == nullptr && "We should not yet have encountered the exit block."); outlined_region_exit_block = cloned_block.get(); } // Redirect any OpPhi operands whose predecessors are the original region // entry block to become the new function entry block. cloned_block->ForEachPhiInst([this](opt::Instruction* phi_inst) { for (uint32_t predecessor_index = 1; predecessor_index < phi_inst->NumInOperands(); predecessor_index += 2) { if (phi_inst->GetSingleWordInOperand(predecessor_index) == message_.entry_block()) { phi_inst->SetInOperand(predecessor_index, {message_.new_function_region_entry_block()}); } } }); outlined_function->AddBasicBlock(std::move(cloned_block)); block_it = block_it.Erase(); } assert(outlined_region_exit_block != nullptr && "We should have encountered the region's exit block when iterating " "through the function"); // We now need to adapt the exit block for the region - in the new function - // so that it ends with a return. // We first eliminate the merge instruction (if any) and the terminator for // the cloned exit block. for (auto inst_it = outlined_region_exit_block->begin(); inst_it != outlined_region_exit_block->end();) { if (inst_it->opcode() == spv::Op::OpLoopMerge || inst_it->opcode() == spv::Op::OpSelectionMerge) { inst_it = inst_it.Erase(); } else if (inst_it->IsBlockTerminator()) { inst_it = inst_it.Erase(); } else { ++inst_it; } } // We now add either OpReturn or OpReturnValue as the cloned exit block's // terminator. if (region_output_ids.empty()) { // The case where there are no region output ids is simple: we just add // OpReturn. outlined_region_exit_block->AddInstruction(MakeUnique( ir_context, spv::Op::OpReturn, 0, 0, opt::Instruction::OperandList())); } else { // In the case where there are output ids, we add an OpCompositeConstruct // instruction to pack all the non-void output values into a struct, and // then an OpReturnValue instruction to return this struct. opt::Instruction::OperandList struct_member_operands; for (uint32_t id : region_output_ids) { if (ir_context->get_def_use_mgr() ->GetDef(output_id_to_type_id.at(id)) ->opcode() != spv::Op::OpTypeVoid) { struct_member_operands.push_back( {SPV_OPERAND_TYPE_ID, {output_id_to_fresh_id_map.at(id)}}); } } outlined_region_exit_block->AddInstruction(MakeUnique( ir_context, spv::Op::OpCompositeConstruct, message_.new_function_struct_return_type_id(), message_.new_callee_result_id(), struct_member_operands)); outlined_region_exit_block->AddInstruction(MakeUnique( ir_context, spv::Op::OpReturnValue, 0, 0, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {message_.new_callee_result_id()}}}))); } outlined_function->SetFunctionEnd( MakeUnique(ir_context, spv::Op::OpFunctionEnd, 0, 0, opt::Instruction::OperandList())); } void TransformationOutlineFunction::ShrinkOriginalRegion( opt::IRContext* ir_context, const std::set& region_blocks, const std::vector& region_input_ids, const std::vector& region_output_ids, const std::map& output_id_to_type_id, uint32_t return_type_id, std::unique_ptr cloned_exit_block_merge, std::unique_ptr cloned_exit_block_terminator, opt::BasicBlock* original_region_entry_block) const { // Erase all blocks from the original function that are in the outlined // region, except for the region's entry block. // // In the process, identify all references to the exit block of the region, // as merge blocks, continue targets, or OpPhi predecessors, and rewrite them // to refer to the region entry block (the single block to which we are // shrinking the region). auto enclosing_function = original_region_entry_block->GetParent(); for (auto block_it = enclosing_function->begin(); block_it != enclosing_function->end();) { if (&*block_it == original_region_entry_block) { ++block_it; } else if (region_blocks.count(&*block_it) == 0) { // The block is not in the region. Check whether it has the last block // of the region as an OpPhi predecessor, and if so change the // predecessor to be the first block of the region (i.e. the block // containing the call to what was outlined). assert(block_it->MergeBlockIdIfAny() != message_.exit_block() && "Outlined region must not end with a merge block"); assert(block_it->ContinueBlockIdIfAny() != message_.exit_block() && "Outlined region must not end with a continue target"); block_it->ForEachPhiInst([this](opt::Instruction* phi_inst) { for (uint32_t predecessor_index = 1; predecessor_index < phi_inst->NumInOperands(); predecessor_index += 2) { if (phi_inst->GetSingleWordInOperand(predecessor_index) == message_.exit_block()) { phi_inst->SetInOperand(predecessor_index, {message_.entry_block()}); } } }); ++block_it; } else { // The block is in the region and is not the region's entry block: kill // it. block_it = block_it.Erase(); } } // Now erase all instructions from the region's entry block, as they have // been outlined. for (auto inst_it = original_region_entry_block->begin(); inst_it != original_region_entry_block->end();) { inst_it = inst_it.Erase(); } // Now we add a call to the outlined function to the region's entry block. opt::Instruction::OperandList function_call_operands; function_call_operands.push_back( {SPV_OPERAND_TYPE_ID, {message_.new_function_id()}}); // The function parameters are the region input ids. for (auto input_id : region_input_ids) { function_call_operands.push_back({SPV_OPERAND_TYPE_ID, {input_id}}); } original_region_entry_block->AddInstruction(MakeUnique( ir_context, spv::Op::OpFunctionCall, return_type_id, message_.new_caller_result_id(), function_call_operands)); // If there are output ids, the function call will return a struct. For each // output id, we add an extract operation to pull the appropriate struct // member out into an output id. The exception is for output ids with void // type. There are no struct entries for these, so we use an OpUndef of void // type instead. uint32_t struct_member_index = 0; for (uint32_t output_id : region_output_ids) { uint32_t output_type_id = output_id_to_type_id.at(output_id); if (ir_context->get_def_use_mgr()->GetDef(output_type_id)->opcode() == spv::Op::OpTypeVoid) { original_region_entry_block->AddInstruction(MakeUnique( ir_context, spv::Op::OpUndef, output_type_id, output_id, opt::Instruction::OperandList())); // struct_member_index is not incremented since there was no struct member // associated with this void-typed output id. } else { original_region_entry_block->AddInstruction(MakeUnique( ir_context, spv::Op::OpCompositeExtract, output_type_id, output_id, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {message_.new_caller_result_id()}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {struct_member_index}}}))); struct_member_index++; } } // Finally, we terminate the block with the merge instruction (if any) that // used to belong to the region's exit block, and the terminator that used // to belong to the region's exit block. if (cloned_exit_block_merge != nullptr) { original_region_entry_block->AddInstruction( std::move(cloned_exit_block_merge)); } original_region_entry_block->AddInstruction( std::move(cloned_exit_block_terminator)); } std::unordered_set TransformationOutlineFunction::GetFreshIds() const { std::unordered_set result = { message_.new_function_struct_return_type_id(), message_.new_function_type_id(), message_.new_function_id(), message_.new_function_region_entry_block(), message_.new_caller_result_id(), message_.new_callee_result_id()}; for (auto& pair : message_.input_id_to_fresh_id()) { result.insert(pair.second()); } for (auto& pair : message_.output_id_to_fresh_id()) { result.insert(pair.second()); } return result; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_outline_function.h000066400000000000000000000265161475742701700277240ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_OUTLINE_FUNCTION_H_ #define SOURCE_FUZZ_TRANSFORMATION_OUTLINE_FUNCTION_H_ #include #include #include #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationOutlineFunction : public Transformation { public: explicit TransformationOutlineFunction( protobufs::TransformationOutlineFunction message); TransformationOutlineFunction( uint32_t entry_block, uint32_t exit_block, uint32_t new_function_struct_return_type_id, uint32_t new_function_type_id, uint32_t new_function_id, uint32_t new_function_region_entry_block, uint32_t new_caller_result_id, uint32_t new_callee_result_id, const std::map& input_id_to_fresh_id, const std::map& output_id_to_fresh_id); // - All the fresh ids occurring in the transformation must be distinct and // fresh // - |message_.entry_block| and |message_.exit_block| must form a single-entry // single-exit control flow graph region // - |message_.entry_block| must not start with OpVariable // - |message_.entry_block| must not be a loop header // - |message_.exit_block| must not be a merge block or the continue target // of a loop // - A structured control flow construct must lie either completely within the // region or completely outside it // - |message.entry_block| must not start with OpPhi; this is to keep the // transformation simple - another transformation should be used to split // a desired entry block that starts with OpPhi if needed // - |message_.input_id_to_fresh_id| must contain an entry for every id // defined outside the region but used in the region // - |message_.output_id_to_fresh_id| must contain an entry for every id // defined in the region but used outside the region bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // - A new function with id |message_.new_function_id| is added to the module. // - If the region generates output ids, the return type of this function is // a new struct type with one field per output id, and with type id // |message_.new_function_struct_return_type|, otherwise the function return // types is void and |message_.new_function_struct_return_type| is not used. // - If the region generates input ids, the new function has one parameter per // input id. Fresh ids for these parameters are provided by // |message_.input_id_to_fresh_id|. // - Unless the type required for the new function is already known, // |message_.new_function_type_id| is used as the type id for a new function // type, and the new function uses this type. // - The new function starts with a placeholder block with id // |message_.new_function_first_block|, which jumps straight to a successor // block, to avoid violating rules on what the first block in a function may // look like. // - The outlined region is replaced with a single block, with the same id // as |message_.entry_block|, and which calls the new function, passing the // region's input ids as parameters. The result is stored in // |message_.new_caller_result_id|, which has type // |message_.new_function_struct_return_type| (unless there are // no output ids, in which case the return type is void). The components // of this returned struct are then copied out into the region's output ids. // The block ends with the merge instruction (if any) and terminator of // |message_.exit_block|. // - The body of the new function is identical to the outlined region, except // that (a) the region's entry block has id // |message_.new_function_region_entry_block|, (b) input id uses are // replaced with parameter accesses, (c) and definitions of output ids are // replaced with definitions of corresponding fresh ids provided by // |message_.output_id_to_fresh_id|, and (d) the block of the function // ends by returning a composite of type // |message_.new_function_struct_return_type| comprised of all the fresh // output ids (unless the return type is void, in which case no value is // returned. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; // Returns the set of blocks dominated by |entry_block| and post-dominated // by |exit_block|. static std::set GetRegionBlocks( opt::IRContext* ir_context, opt::BasicBlock* entry_block, opt::BasicBlock* exit_block); // Yields ids that are used in |region_set| and that are either parameters // to the function containing |region_set|, or are defined by blocks of this // function that are outside |region_set|. // // Special cases: OpPhi instructions in |region_entry_block| and the // terminator of |region_exit_block| do not get outlined, therefore // - id uses in OpPhi instructions in |region_entry_block| are ignored // - id uses in the terminator instruction of |region_exit_block| are ignored static std::vector GetRegionInputIds( opt::IRContext* ir_context, const std::set& region_set, opt::BasicBlock* region_exit_block); // Yields all ids that are defined in |region_set| and used outside // |region_set|. // // Special cases: for similar reasons as for |GetRegionInputIds|, // - ids defined in the region and used in the terminator of // |region_exit_block| count as output ids static std::vector GetRegionOutputIds( opt::IRContext* ir_context, const std::set& region_set, opt::BasicBlock* region_exit_block); private: // Ensures that the module's id bound is at least the maximum of any fresh id // associated with the transformation. void UpdateModuleIdBoundForFreshIds( opt::IRContext* ir_context, const std::map& input_id_to_fresh_id_map, const std::map& output_id_to_fresh_id_map) const; // Uses |input_id_to_fresh_id_map| and |output_id_to_fresh_id_map| to convert, // in the region to be outlined, all the input ids in |region_input_ids| and // the output ids in |region_output_ids| to their fresh counterparts. // Parameters |region_blocks| provides access to the blocks that must be // modified, and |original_region_exit_block| allows for some special cases // where ids should not be remapped. void RemapInputAndOutputIdsInRegion( opt::IRContext* ir_context, const opt::BasicBlock& original_region_exit_block, const std::set& region_blocks, const std::vector& region_input_ids, const std::vector& region_output_ids, const std::map& input_id_to_fresh_id_map, const std::map& output_id_to_fresh_id_map) const; // Produce a Function object that has the right function type and parameter // declarations. The function argument types and parameter ids are dictated // by |region_input_ids| and |input_id_to_fresh_id_map|. The function return // type is dictated by |region_output_ids|. // // A new struct type to represent the function return type, and a new function // type for the function, will be added to the module (unless suitable types // are already present). // // Facts about the function containing the outlined region that are relevant // to the new function are propagated via the vact manager in // |transformation_context|. std::unique_ptr PrepareFunctionPrototype( const std::vector& region_input_ids, const std::vector& region_output_ids, const std::map& input_id_to_fresh_id_map, opt::IRContext* ir_context, TransformationContext* transformation_context) const; // Creates the body of the outlined function by cloning blocks from the // original region, given by |region_blocks|, adapting the cloned version // of |original_region_exit_block| so that it returns something appropriate, // and patching up branches to |original_region_entry_block| to refer to its // clone. Parameters |region_output_ids| and |output_id_to_fresh_id_map| are // used to determine what the function should return. Parameter // |output_id_to_type_id| provides the type of each output id. // // The |transformation_context| argument allow facts about blocks being // outlined, e.g. whether they are dead blocks, to be asserted about blocks // that get created during outlining. void PopulateOutlinedFunction( const opt::BasicBlock& original_region_entry_block, const opt::BasicBlock& original_region_exit_block, const std::set& region_blocks, const std::vector& region_output_ids, const std::map& output_id_to_type_id, const std::map& output_id_to_fresh_id_map, opt::IRContext* ir_context, opt::Function* outlined_function) const; // Shrinks the outlined region, given by |region_blocks|, down to the single // block |original_region_entry_block|. This block is itself shrunk to just // contain: // - any OpPhi instructions that were originally present // - a call to the outlined function, with parameters provided by // |region_input_ids| // - instructions to route components of the call's return value into // |region_output_ids| // - The merge instruction (if any) and terminator of the original region's // exit block, given by |cloned_exit_block_merge| and // |cloned_exit_block_terminator| // Parameters |output_id_to_type_id| and |return_type_id| provide the // provide types for the region's output ids, and the return type of the // outlined function: as the module is in an inconsistent state when this // function is called, this information cannot be gotten from the def-use // manager. void ShrinkOriginalRegion( opt::IRContext* ir_context, const std::set& region_blocks, const std::vector& region_input_ids, const std::vector& region_output_ids, const std::map& output_id_to_type_id, uint32_t return_type_id, std::unique_ptr cloned_exit_block_merge, std::unique_ptr cloned_exit_block_terminator, opt::BasicBlock* original_region_entry_block) const; protobufs::TransformationOutlineFunction message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_OUTLINE_FUNCTION_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_permute_function_parameters.cpp000066400000000000000000000136401475742701700324760ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_permute_function_parameters.h" #include #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { TransformationPermuteFunctionParameters:: TransformationPermuteFunctionParameters( protobufs::TransformationPermuteFunctionParameters message) : message_(std::move(message)) {} TransformationPermuteFunctionParameters:: TransformationPermuteFunctionParameters( uint32_t function_id, uint32_t function_type_fresh_id, const std::vector& permutation) { message_.set_function_id(function_id); message_.set_function_type_fresh_id(function_type_fresh_id); for (auto index : permutation) { message_.add_permutation(index); } } bool TransformationPermuteFunctionParameters::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { // Check that function exists const auto* function = fuzzerutil::FindFunction(ir_context, message_.function_id()); if (!function || function->DefInst().opcode() != spv::Op::OpFunction || fuzzerutil::FunctionIsEntryPoint(ir_context, function->result_id())) { return false; } // Check that permutation has valid indices const auto* function_type = fuzzerutil::GetFunctionType(ir_context, function); assert(function_type && "Function type is null"); std::vector permutation(message_.permutation().begin(), message_.permutation().end()); // Don't take return type into account auto arg_size = function_type->NumInOperands() - 1; // |permutation| vector should be equal to the number of arguments if (static_cast(permutation.size()) != arg_size) { return false; } // Check that permutation doesn't have duplicated values. assert(!fuzzerutil::HasDuplicates(permutation) && "Permutation has duplicates"); // Check that elements in permutation are in range [0, arg_size - 1]. // // We must check whether the permutation is empty first because in that case // |arg_size - 1| will produce |std::numeric_limits::max()| since // it's an unsigned integer. if (!permutation.empty() && !fuzzerutil::IsPermutationOfRange(permutation, 0, arg_size - 1)) { return false; } return fuzzerutil::IsFreshId(ir_context, message_.function_type_fresh_id()); } void TransformationPermuteFunctionParameters::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { // Find the function that will be transformed auto* function = fuzzerutil::FindFunction(ir_context, message_.function_id()); assert(function && "Can't find the function"); // Adjust OpFunctionParameter instructions // Collect ids and types from OpFunctionParameter instructions std::vector param_id, param_type; function->ForEachParam( [¶m_id, ¶m_type](const opt::Instruction* param) { param_id.push_back(param->result_id()); param_type.push_back(param->type_id()); }); // Permute parameters' ids and types std::vector permuted_param_id, permuted_param_type; for (auto index : message_.permutation()) { permuted_param_id.push_back(param_id[index]); permuted_param_type.push_back(param_type[index]); } // Set OpFunctionParameter instructions to point to new parameters size_t i = 0; function->ForEachParam( [&i, &permuted_param_id, &permuted_param_type](opt::Instruction* param) { param->SetResultType(permuted_param_type[i]); param->SetResultId(permuted_param_id[i]); ++i; }); // Fix all OpFunctionCall instructions for (auto* call : fuzzerutil::GetCallers(ir_context, function->result_id())) { opt::Instruction::OperandList call_operands = { call->GetInOperand(0) // Function id }; for (auto index : message_.permutation()) { // Take function id into account call_operands.push_back(call->GetInOperand(index + 1)); } call->SetInOperands(std::move(call_operands)); } // Update function type. { // We use a separate scope here since |old_function_type_inst| might become // a dangling pointer after the call to the fuzzerutil::UpdateFunctionType. auto* old_function_type_inst = fuzzerutil::GetFunctionType(ir_context, function); assert(old_function_type_inst && "Function must have a valid type"); std::vector parameter_type_ids; for (auto index : message_.permutation()) { // +1 since the first operand to OpTypeFunction is a return type. parameter_type_ids.push_back( old_function_type_inst->GetSingleWordInOperand(index + 1)); } // Change function's type. fuzzerutil::UpdateFunctionType( ir_context, function->result_id(), message_.function_type_fresh_id(), old_function_type_inst->GetSingleWordInOperand(0), parameter_type_ids); } // Make sure our changes are analyzed ir_context->InvalidateAnalysesExceptFor( opt::IRContext::Analysis::kAnalysisNone); } protobufs::Transformation TransformationPermuteFunctionParameters::ToMessage() const { protobufs::Transformation result; *result.mutable_permute_function_parameters() = message_; return result; } std::unordered_set TransformationPermuteFunctionParameters::GetFreshIds() const { return {message_.function_type_fresh_id()}; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_permute_function_parameters.h000066400000000000000000000050301475742701700321350ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_PERMUTE_FUNCTION_PARAMETERS_H_ #define SOURCE_FUZZ_TRANSFORMATION_PERMUTE_FUNCTION_PARAMETERS_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationPermuteFunctionParameters : public Transformation { public: explicit TransformationPermuteFunctionParameters( protobufs::TransformationPermuteFunctionParameters message); TransformationPermuteFunctionParameters( uint32_t function_id, uint32_t function_type_fresh_id, const std::vector& permutation); // - |function_id| is a valid non-entry-point OpFunction instruction // - |function_type_fresh_id| is a fresh id. // New type is valid if: // - it has the same number of operands as the old one // - function's result type is the same as the old one // - function's arguments are permuted according to |permutation| vector // - |permutation| is a set of [0..(n - 1)], where n is a number of arguments // to the function bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // - OpFunction instruction with |result_id == function_id| is changed. // Its arguments are permuted according to the |permutation| vector // - Adjusts function's type to accommodate for permuted parameters. // - Calls to the function are adjusted accordingly void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationPermuteFunctionParameters message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_PERMUTE_FUNCTION_PARAMETERS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_permute_phi_operands.cpp000066400000000000000000000066161475742701700311060ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_permute_phi_operands.h" #include #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { TransformationPermutePhiOperands::TransformationPermutePhiOperands( protobufs::TransformationPermutePhiOperands message) : message_(std::move(message)) {} TransformationPermutePhiOperands::TransformationPermutePhiOperands( uint32_t result_id, const std::vector& permutation) { message_.set_result_id(result_id); for (auto index : permutation) { message_.add_permutation(index); } } bool TransformationPermutePhiOperands::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { // Check that |message_.result_id| is valid. const auto* inst = ir_context->get_def_use_mgr()->GetDef(message_.result_id()); if (!inst || inst->opcode() != spv::Op::OpPhi) { return false; } // Check that |message_.permutation| has expected size. auto expected_permutation_size = inst->NumInOperands() / 2; if (static_cast(message_.permutation().size()) != expected_permutation_size) { return false; } // Check that |message_.permutation| has elements in range // [0, expected_permutation_size - 1]. std::vector permutation(message_.permutation().begin(), message_.permutation().end()); assert(!fuzzerutil::HasDuplicates(permutation) && "Permutation has duplicates"); // We must check whether the permutation is empty first because in that case // |expected_permutation_size - 1| will produce // |std::numeric_limits::max()| since it's an unsigned integer. return permutation.empty() || fuzzerutil::IsPermutationOfRange(permutation, 0, expected_permutation_size - 1); } void TransformationPermutePhiOperands::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { auto* inst = ir_context->get_def_use_mgr()->GetDef(message_.result_id()); assert(inst); opt::Instruction::OperandList permuted_operands; permuted_operands.reserve(inst->NumInOperands()); for (auto index : message_.permutation()) { permuted_operands.push_back(std::move(inst->GetInOperand(2 * index))); permuted_operands.push_back(std::move(inst->GetInOperand(2 * index + 1))); } inst->SetInOperands(std::move(permuted_operands)); // Update the def-use manager. ir_context->UpdateDefUse(inst); } protobufs::Transformation TransformationPermutePhiOperands::ToMessage() const { protobufs::Transformation result; *result.mutable_permute_phi_operands() = message_; return result; } std::unordered_set TransformationPermutePhiOperands::GetFreshIds() const { return std::unordered_set(); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_permute_phi_operands.h000066400000000000000000000042361475742701700305470ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_PERMUTE_PHI_OPERANDS_H_ #define SOURCE_FUZZ_TRANSFORMATION_PERMUTE_PHI_OPERANDS_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationPermutePhiOperands : public Transformation { public: explicit TransformationPermutePhiOperands( protobufs::TransformationPermutePhiOperands message); TransformationPermutePhiOperands(uint32_t result_id, const std::vector& permutation); // - |result_id| must be a valid id of some OpPhi instruction in the module. // - |permutation| must contain elements in the range [0, n/2 - 1] where |n| // is a number of operands to the instruction with |result_id|. All elements // must be unique (i.e. |permutation.size() == n / 2|). bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Permutes operands of the OpPhi instruction with |result_id| according to // the elements in |permutation|. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationPermutePhiOperands message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_PERMUTE_PHI_OPERANDS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_propagate_instruction_down.cpp000066400000000000000000000517451475742701700323470ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_propagate_instruction_down.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" namespace spvtools { namespace fuzz { TransformationPropagateInstructionDown::TransformationPropagateInstructionDown( protobufs::TransformationPropagateInstructionDown message) : message_(std::move(message)) {} TransformationPropagateInstructionDown::TransformationPropagateInstructionDown( uint32_t block_id, uint32_t phi_fresh_id, const std::map& successor_id_to_fresh_id) { message_.set_block_id(block_id); message_.set_phi_fresh_id(phi_fresh_id); *message_.mutable_successor_id_to_fresh_id() = fuzzerutil::MapToRepeatedUInt32Pair(successor_id_to_fresh_id); } bool TransformationPropagateInstructionDown::IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const { // Check that we can apply this transformation to the |block_id|. if (!IsApplicableToBlock(ir_context, message_.block_id())) { return false; } const auto successor_id_to_fresh_id = fuzzerutil::RepeatedUInt32PairToMap(message_.successor_id_to_fresh_id()); for (auto id : GetAcceptableSuccessors(ir_context, message_.block_id())) { // Each successor must have a fresh id in the |successor_id_to_fresh_id| // map, unless overflow ids are available. if (!successor_id_to_fresh_id.count(id) && !transformation_context.GetOverflowIdSource()->HasOverflowIds()) { return false; } } std::vector maybe_fresh_ids = {message_.phi_fresh_id()}; maybe_fresh_ids.reserve(successor_id_to_fresh_id.size()); for (const auto& entry : successor_id_to_fresh_id) { maybe_fresh_ids.push_back(entry.second); } // All ids must be unique and fresh. return !fuzzerutil::HasDuplicates(maybe_fresh_ids) && std::all_of(maybe_fresh_ids.begin(), maybe_fresh_ids.end(), [ir_context](uint32_t id) { return fuzzerutil::IsFreshId(ir_context, id); }); } void TransformationPropagateInstructionDown::Apply( opt::IRContext* ir_context, TransformationContext* transformation_context) const { // Get instruction to propagate down. There must be one. auto* inst_to_propagate = GetInstructionToPropagate(ir_context, message_.block_id()); assert(inst_to_propagate && "There must be an instruction to propagate"); auto successor_id_to_fresh_id = fuzzerutil::RepeatedUInt32PairToMap(message_.successor_id_to_fresh_id()); std::vector created_inst_ids; auto successor_ids = GetAcceptableSuccessors(ir_context, message_.block_id()); // Clone |inst_to_propagate| into every successor. for (auto successor_id : successor_ids) { std::unique_ptr clone( inst_to_propagate->Clone(ir_context)); uint32_t new_result_id; if (successor_id_to_fresh_id.count(successor_id)) { new_result_id = successor_id_to_fresh_id.at(successor_id); } else { assert(transformation_context->GetOverflowIdSource()->HasOverflowIds() && "Overflow ids must be available"); new_result_id = transformation_context->GetOverflowIdSource()->GetNextOverflowId(); successor_id_to_fresh_id[successor_id] = new_result_id; } clone->SetResultId(new_result_id); fuzzerutil::UpdateModuleIdBound(ir_context, new_result_id); auto* insert_before_inst = GetFirstInsertBeforeInstruction( ir_context, successor_id, clone->opcode()); assert(insert_before_inst && "Can't insert into one of the successors"); insert_before_inst->InsertBefore(std::move(clone)); created_inst_ids.push_back(new_result_id); } // Add an OpPhi instruction into the module if possible. if (auto merge_block_id = GetOpPhiBlockId( ir_context, message_.block_id(), *inst_to_propagate, successor_ids)) { opt::Instruction::OperandList in_operands; std::unordered_set visited_predecessors; for (auto predecessor_id : ir_context->cfg()->preds(merge_block_id)) { if (visited_predecessors.count(predecessor_id)) { // Merge block might have multiple identical predecessors. continue; } visited_predecessors.insert(predecessor_id); const auto* dominator_analysis = ir_context->GetDominatorAnalysis( ir_context->cfg()->block(message_.block_id())->GetParent()); // Find the successor of |source_block| that dominates the predecessor of // the merge block |predecessor_id|. auto it = std::find_if( successor_ids.begin(), successor_ids.end(), [predecessor_id, dominator_analysis](uint32_t successor_id) { return dominator_analysis->Dominates(successor_id, predecessor_id); }); // OpPhi requires a single operand pair for every predecessor of the // OpPhi's block. assert(it != successor_ids.end() && "Unable to insert OpPhi"); in_operands.push_back( {SPV_OPERAND_TYPE_ID, {successor_id_to_fresh_id.at(*it)}}); in_operands.push_back({SPV_OPERAND_TYPE_ID, {predecessor_id}}); } ir_context->cfg() ->block(merge_block_id) ->begin() ->InsertBefore(MakeUnique( ir_context, spv::Op::OpPhi, inst_to_propagate->type_id(), message_.phi_fresh_id(), std::move(in_operands))); fuzzerutil::UpdateModuleIdBound(ir_context, message_.phi_fresh_id()); created_inst_ids.push_back(message_.phi_fresh_id()); } // Make sure analyses are updated when we adjust users of |inst_to_propagate|. ir_context->InvalidateAnalysesExceptFor(opt::IRContext::kAnalysisNone); // Copy decorations from the original instructions to its propagated copies. for (auto id : created_inst_ids) { ir_context->get_decoration_mgr()->CloneDecorations( inst_to_propagate->result_id(), id); } // Remove all decorations from the original instruction. ir_context->get_decoration_mgr()->RemoveDecorationsFrom( inst_to_propagate->result_id()); // Update every use of the |inst_to_propagate| with a result id of some of the // newly created instructions. ir_context->get_def_use_mgr()->ForEachUse( inst_to_propagate, [ir_context, &created_inst_ids]( opt::Instruction* user, uint32_t operand_index) { assert(ir_context->get_instr_block(user) && "All decorations should have already been adjusted"); auto in_operand_index = fuzzerutil::InOperandIndexFromOperandIndex(*user, operand_index); for (auto id : created_inst_ids) { if (fuzzerutil::IdIsAvailableAtUse(ir_context, user, in_operand_index, id)) { user->SetInOperand(in_operand_index, {id}); return; } } // Every user of |inst_to_propagate| must be updated since we will // remove that instruction from the module. assert(false && "Every user of |inst_to_propagate| must be updated"); }); // Add synonyms about newly created instructions. assert(inst_to_propagate->HasResultId() && "Result id is required to add facts"); if (transformation_context->GetFactManager()->IdIsIrrelevant( inst_to_propagate->result_id())) { for (auto id : created_inst_ids) { transformation_context->GetFactManager()->AddFactIdIsIrrelevant(id); } } else { std::vector non_irrelevant_ids; for (auto id : created_inst_ids) { // |id| can be irrelevant implicitly (e.g. if we propagate it into a dead // block). if (!transformation_context->GetFactManager()->IdIsIrrelevant(id)) { non_irrelevant_ids.push_back(id); } } if (transformation_context->GetFactManager()->PointeeValueIsIrrelevant( inst_to_propagate->result_id())) { for (auto id : non_irrelevant_ids) { transformation_context->GetFactManager() ->AddFactValueOfPointeeIsIrrelevant(id); } } for (auto id : non_irrelevant_ids) { transformation_context->GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(id, {}), MakeDataDescriptor(non_irrelevant_ids[0], {})); } } // Remove the propagated instruction from the module. ir_context->KillInst(inst_to_propagate); // We've adjusted all users - make sure these changes are analyzed. ir_context->InvalidateAnalysesExceptFor(opt::IRContext::kAnalysisNone); } protobufs::Transformation TransformationPropagateInstructionDown::ToMessage() const { protobufs::Transformation result; *result.mutable_propagate_instruction_down() = message_; return result; } bool TransformationPropagateInstructionDown::IsOpcodeSupported(spv::Op opcode) { // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/3605): // We only support "simple" instructions that don't work with memory. // We should extend this so that we support the ones that modify the memory // too. switch (opcode) { case spv::Op::OpUndef: case spv::Op::OpAccessChain: case spv::Op::OpInBoundsAccessChain: case spv::Op::OpArrayLength: case spv::Op::OpVectorExtractDynamic: case spv::Op::OpVectorInsertDynamic: case spv::Op::OpVectorShuffle: case spv::Op::OpCompositeConstruct: case spv::Op::OpCompositeExtract: case spv::Op::OpCompositeInsert: case spv::Op::OpCopyObject: case spv::Op::OpTranspose: case spv::Op::OpConvertFToU: case spv::Op::OpConvertFToS: case spv::Op::OpConvertSToF: case spv::Op::OpConvertUToF: case spv::Op::OpUConvert: case spv::Op::OpSConvert: case spv::Op::OpFConvert: case spv::Op::OpQuantizeToF16: case spv::Op::OpSatConvertSToU: case spv::Op::OpSatConvertUToS: case spv::Op::OpBitcast: case spv::Op::OpSNegate: case spv::Op::OpFNegate: case spv::Op::OpIAdd: case spv::Op::OpFAdd: case spv::Op::OpISub: case spv::Op::OpFSub: case spv::Op::OpIMul: case spv::Op::OpFMul: case spv::Op::OpUDiv: case spv::Op::OpSDiv: case spv::Op::OpFDiv: case spv::Op::OpUMod: case spv::Op::OpSRem: case spv::Op::OpSMod: case spv::Op::OpFRem: case spv::Op::OpFMod: case spv::Op::OpVectorTimesScalar: case spv::Op::OpMatrixTimesScalar: case spv::Op::OpVectorTimesMatrix: case spv::Op::OpMatrixTimesVector: case spv::Op::OpMatrixTimesMatrix: case spv::Op::OpOuterProduct: case spv::Op::OpDot: case spv::Op::OpIAddCarry: case spv::Op::OpISubBorrow: case spv::Op::OpUMulExtended: case spv::Op::OpSMulExtended: case spv::Op::OpAny: case spv::Op::OpAll: case spv::Op::OpIsNan: case spv::Op::OpIsInf: case spv::Op::OpIsFinite: case spv::Op::OpIsNormal: case spv::Op::OpSignBitSet: case spv::Op::OpLessOrGreater: case spv::Op::OpOrdered: case spv::Op::OpUnordered: case spv::Op::OpLogicalEqual: case spv::Op::OpLogicalNotEqual: case spv::Op::OpLogicalOr: case spv::Op::OpLogicalAnd: case spv::Op::OpLogicalNot: case spv::Op::OpSelect: case spv::Op::OpIEqual: case spv::Op::OpINotEqual: case spv::Op::OpUGreaterThan: case spv::Op::OpSGreaterThan: case spv::Op::OpUGreaterThanEqual: case spv::Op::OpSGreaterThanEqual: case spv::Op::OpULessThan: case spv::Op::OpSLessThan: case spv::Op::OpULessThanEqual: case spv::Op::OpSLessThanEqual: case spv::Op::OpFOrdEqual: case spv::Op::OpFUnordEqual: case spv::Op::OpFOrdNotEqual: case spv::Op::OpFUnordNotEqual: case spv::Op::OpFOrdLessThan: case spv::Op::OpFUnordLessThan: case spv::Op::OpFOrdGreaterThan: case spv::Op::OpFUnordGreaterThan: case spv::Op::OpFOrdLessThanEqual: case spv::Op::OpFUnordLessThanEqual: case spv::Op::OpFOrdGreaterThanEqual: case spv::Op::OpFUnordGreaterThanEqual: case spv::Op::OpShiftRightLogical: case spv::Op::OpShiftRightArithmetic: case spv::Op::OpShiftLeftLogical: case spv::Op::OpBitwiseOr: case spv::Op::OpBitwiseXor: case spv::Op::OpBitwiseAnd: case spv::Op::OpNot: case spv::Op::OpBitFieldInsert: case spv::Op::OpBitFieldSExtract: case spv::Op::OpBitFieldUExtract: case spv::Op::OpBitReverse: case spv::Op::OpBitCount: case spv::Op::OpCopyLogical: case spv::Op::OpPtrEqual: case spv::Op::OpPtrNotEqual: return true; default: return false; } } opt::Instruction* TransformationPropagateInstructionDown::GetInstructionToPropagate( opt::IRContext* ir_context, uint32_t block_id) { auto* block = ir_context->cfg()->block(block_id); assert(block && "|block_id| is invalid"); for (auto it = block->rbegin(); it != block->rend(); ++it) { if (!it->result_id() || !it->type_id() || !IsOpcodeSupported(it->opcode())) { continue; } auto all_users_from_different_blocks = ir_context->get_def_use_mgr()->WhileEachUser( &*it, [ir_context, block](opt::Instruction* user) { return ir_context->get_instr_block(user) != block; }); if (!all_users_from_different_blocks) { // We can't propagate an instruction if it's used in the same block. continue; } return &*it; } return nullptr; } bool TransformationPropagateInstructionDown::IsApplicableToBlock( opt::IRContext* ir_context, uint32_t block_id) { // Check that |block_id| is valid. const auto* block = fuzzerutil::MaybeFindBlock(ir_context, block_id); if (!block) { return false; } // |block| must be reachable. if (!ir_context->IsReachable(*block)) { return false; } // The block must have an instruction to propagate. const auto* inst_to_propagate = GetInstructionToPropagate(ir_context, block_id); if (!inst_to_propagate) { return false; } // Check that |block| has successors. auto successor_ids = GetAcceptableSuccessors(ir_context, block_id); if (successor_ids.empty()) { return false; } // Check that |successor_block| doesn't have any OpPhi instructions that // use |inst|. for (auto successor_id : successor_ids) { for (const auto& maybe_phi_inst : *ir_context->cfg()->block(successor_id)) { if (maybe_phi_inst.opcode() != spv::Op::OpPhi) { // OpPhis can be intermixed with OpLine and OpNoLine. continue; } for (uint32_t i = 0; i < maybe_phi_inst.NumInOperands(); i += 2) { if (maybe_phi_inst.GetSingleWordInOperand(i) == inst_to_propagate->result_id()) { return false; } } } } // Get the result id of the block we will insert OpPhi instruction into. // This is either 0 or a result id of some merge block in the function. auto phi_block_id = GetOpPhiBlockId(ir_context, block_id, *inst_to_propagate, successor_ids); const auto* dominator_analysis = ir_context->GetDominatorAnalysis(block->GetParent()); // Make sure we can adjust all users of the propagated instruction. return ir_context->get_def_use_mgr()->WhileEachUse( inst_to_propagate, [ir_context, &successor_ids, dominator_analysis, phi_block_id]( opt::Instruction* user, uint32_t index) { const auto* user_block = ir_context->get_instr_block(user); if (!user_block) { // |user| might be a global instruction (e.g. OpDecorate). return true; } // Check that at least one of the ids in |successor_ids| or a // |phi_block_id| dominates |user|'s block (or its predecessor if the // user is an OpPhi). We can't use fuzzerutil::IdIsAvailableAtUse since // the id in question hasn't yet been created in the module. auto block_id_to_dominate = user->opcode() == spv::Op::OpPhi ? user->GetSingleWordOperand(index + 1) : user_block->id(); if (phi_block_id != 0 && dominator_analysis->Dominates(phi_block_id, block_id_to_dominate)) { return true; } return std::any_of( successor_ids.begin(), successor_ids.end(), [dominator_analysis, block_id_to_dominate](uint32_t id) { return dominator_analysis->Dominates(id, block_id_to_dominate); }); }); } opt::Instruction* TransformationPropagateInstructionDown::GetFirstInsertBeforeInstruction( opt::IRContext* ir_context, uint32_t block_id, spv::Op opcode) { auto* block = ir_context->cfg()->block(block_id); auto it = block->begin(); while (it != block->end() && !fuzzerutil::CanInsertOpcodeBeforeInstruction(opcode, it)) { ++it; } return it == block->end() ? nullptr : &*it; } std::unordered_set TransformationPropagateInstructionDown::GetAcceptableSuccessors( opt::IRContext* ir_context, uint32_t block_id) { const auto* block = ir_context->cfg()->block(block_id); assert(block && "|block_id| is invalid"); const auto* inst = GetInstructionToPropagate(ir_context, block_id); assert(inst && "The block must have an instruction to propagate"); std::unordered_set result; block->ForEachSuccessorLabel([ir_context, &result, inst](uint32_t successor_id) { if (result.count(successor_id)) { return; } auto* successor_block = ir_context->cfg()->block(successor_id); // We can't propagate |inst| into |successor_block| if the latter is not // dominated by the |inst|'s dependencies. if (!inst->WhileEachInId([ir_context, successor_block](const uint32_t* id) { return fuzzerutil::IdIsAvailableBeforeInstruction( ir_context, &*successor_block->begin(), *id); })) { return; } // We don't propagate any "special" instructions (e.g. OpSelectionMerge // etc), thus, insertion point must always exist if the module is valid. assert(GetFirstInsertBeforeInstruction(ir_context, successor_id, inst->opcode()) && "There must exist an insertion point."); result.insert(successor_id); }); return result; } uint32_t TransformationPropagateInstructionDown::GetOpPhiBlockId( opt::IRContext* ir_context, uint32_t block_id, const opt::Instruction& inst_to_propagate, const std::unordered_set& successor_ids) { const auto* block = ir_context->cfg()->block(block_id); // |block_id| must belong to some construct. auto merge_block_id = block->GetMergeInst() ? block->GetMergeInst()->GetSingleWordInOperand(0) : ir_context->GetStructuredCFGAnalysis()->MergeBlock(block_id); if (!merge_block_id) { return 0; } const auto* dominator_analysis = ir_context->GetDominatorAnalysis(block->GetParent()); // Check that |merge_block_id| is reachable in the CFG and |block_id| // dominates |merge_block_id|. if (!ir_context->IsReachable(*ir_context->cfg()->block(merge_block_id)) || !dominator_analysis->Dominates(block_id, merge_block_id)) { return 0; } // We can't insert an OpPhi into |merge_block_id| if it's an acceptable // successor of |block_id|. if (successor_ids.count(merge_block_id)) { return 0; } // All predecessors of the merge block must be dominated by at least one // successor of the |block_id|. assert(!ir_context->cfg()->preds(merge_block_id).empty() && "Merge block must be reachable"); for (auto predecessor_id : ir_context->cfg()->preds(merge_block_id)) { if (std::none_of( successor_ids.begin(), successor_ids.end(), [dominator_analysis, predecessor_id](uint32_t successor_id) { return dominator_analysis->Dominates(successor_id, predecessor_id); })) { return 0; } } const auto* propagate_type = ir_context->get_type_mgr()->GetType(inst_to_propagate.type_id()); assert(propagate_type && "|inst_to_propagate| must have a valid type"); // VariablePointers capability implicitly declares // VariablePointersStorageBuffer. We need those capabilities since otherwise // OpPhi instructions cannot have operands of pointer types. if (propagate_type->AsPointer() && !ir_context->get_feature_mgr()->HasCapability( spv::Capability::VariablePointersStorageBuffer)) { return 0; } return merge_block_id; } std::unordered_set TransformationPropagateInstructionDown::GetFreshIds() const { std::unordered_set result = {message_.phi_fresh_id()}; for (const auto& pair : message_.successor_id_to_fresh_id()) { result.insert(pair.second()); } return result; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_propagate_instruction_down.h000066400000000000000000000175671475742701700320200ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_PROPAGATE_INSTRUCTION_DOWN_H_ #define SOURCE_FUZZ_TRANSFORMATION_PROPAGATE_INSTRUCTION_DOWN_H_ #include #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationPropagateInstructionDown : public Transformation { public: explicit TransformationPropagateInstructionDown( protobufs::TransformationPropagateInstructionDown message); TransformationPropagateInstructionDown( uint32_t block_id, uint32_t phi_fresh_id, const std::map& successor_id_to_fresh_id); // - It should be possible to apply this transformation to |block_id| (see // IsApplicableToBlock method). // - Every acceptable successor of |block_id| (see GetAcceptableSuccessors // method) must have an entry in the |successor_id_to_fresh_id| map unless // overflow ids are available. // - All values in |successor_id_to_fresh_id| and |phi_fresh_id| must be // unique and fresh. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // - Adds a clone of the propagated instruction into every acceptable // successor of |block_id|. // - Removes the original instruction. // - Creates an OpPhi instruction if possible, that tries to group created // clones. // - If the original instruction's id was irrelevant - marks created // instructions as irrelevant. Otherwise, marks the created instructions as // synonymous to each other if possible (i.e. skips instructions, copied // into dead blocks). void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; protobufs::Transformation ToMessage() const override; // Returns true if this transformation can be applied to the block with id // |block_id|. Concretely, returns true iff: // - |block_id| is a result id of some reachable basic block in the module. // - the block has an instruction to propagate (see // GetInstructionToPropagate method). // - the block has at least one acceptable successor (see // GetAcceptableSuccessors method). // - none of the acceptable successors have OpPhi instructions that use the // original instruction. // - it is possible to replace every use of the original instruction with some // of the propagated instructions (or an OpPhi if we can create it - see // GetOpPhiBlockId method). static bool IsApplicableToBlock(opt::IRContext* ir_context, uint32_t block_id); // Returns ids of successors of |block_id|, that can be used to propagate an // instruction into. Concretely, a successor block is acceptable if all // dependencies of the propagated instruction dominate it. Note that this // implies that an acceptable successor must be reachable in the CFG. // For example: // %1 = OpLabel // OpSelectionMerge %2 None // OpBranchConditional %cond %2 %3 // %3 = OpLabel // %4 = OpUndef %int // %5 = OpCopyObject %int %4 // OpBranch %2 // %2 = OpLabel // ... // In this example, %2 is not an acceptable successor of %3 since one of the // dependencies (%4) of the propagated instruction (%5) does not dominate it. static std::unordered_set GetAcceptableSuccessors( opt::IRContext* ir_context, uint32_t block_id); std::unordered_set GetFreshIds() const override; private: // Returns the last possible instruction in the |block_id| that satisfies the // following properties: // - has result id // - has type id // - has supported opcode (see IsOpcodeSupported method) // - has no users in its basic block. // Returns nullptr if no such an instruction exists. For example: // %1 = OpLabel // %2 = OpUndef %int // %3 = OpUndef %int // OpStore %var %3 // OpBranch %some_block // In this example: // - We cannot propagate OpBranch nor OpStore since they both have unsupported // opcodes and have neither result ids nor type ids. // - We cannot propagate %3 either since it is used by OpStore. // - We can propagate %2 since it satisfies all our conditions. // The basic idea behind this method it to make sure that the returned // instruction will not break domination rules in its original block when // propagated. static opt::Instruction* GetInstructionToPropagate(opt::IRContext* ir_context, uint32_t block_id); // Returns true if |opcode| is supported by this transformation. static bool IsOpcodeSupported(spv::Op opcode); // Returns the first instruction in the |block| that allows us to insert // |opcode| above itself. Returns nullptr is no such instruction exists. static opt::Instruction* GetFirstInsertBeforeInstruction( opt::IRContext* ir_context, uint32_t block_id, spv::Op opcode); // Returns a result id of a basic block, where an OpPhi instruction can be // inserted. Returns nullptr if it's not possible to create an OpPhi. The // created OpPhi instruction groups all the propagated clones of the original // instruction. |block_id| is a result id of the block we propagate the // instruction from. |successor_ids| contains result ids of the successors we // propagate the instruction into. Concretely, returns a non-null value if: // - |block_id| is in some construct. // - The merge block of that construct is reachable. // - |block_id| dominates that merge block. // - That merge block may not be an acceptable successor of |block_id|. // - There must be at least one |block_id|'s acceptable successor for every // predecessor of the merge block, dominating that predecessor. // - We can't create an OpPhi if the module has neither VariablePointers nor // VariablePointersStorageBuffer capabilities. // A simple example of when we can insert an OpPhi instruction is: // - This snippet of code: // %1 = OpLabel // %2 = OpUndef %int // OpSelectionMerge %5 None // OpBranchConditional %cond %3 %4 // %3 = OpLabel // OpBranch %5 // %4 = OpLabel // OpBranch %5 // %5 = OpLabel // ... // will be transformed into the following one (if %2 is propagated): // %1 = OpLabel // OpSelectionMerge %5 None // OpBranchConditional %cond %3 %4 // %3 = OpLabel // %6 = OpUndef %int // OpBranch %5 // %4 = OpLabel // %7 = OpUndef %int // OpBranch %5 // %5 = OpLabel // %8 = OpPhi %int %6 %3 %7 %4 // ... // The fact that we introduce an OpPhi allows us to increase the applicability // of the transformation. Concretely, we wouldn't be able to apply it in the // example above if %2 were used in %5. Some more complicated examples can be // found in unit tests. static uint32_t GetOpPhiBlockId( opt::IRContext* ir_context, uint32_t block_id, const opt::Instruction& inst_to_propagate, const std::unordered_set& successor_ids); protobufs::TransformationPropagateInstructionDown message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_PROPAGATE_INSTRUCTION_DOWN_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_propagate_instruction_up.cpp000066400000000000000000000347411475742701700320210ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_propagate_instruction_up.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" namespace spvtools { namespace fuzz { namespace { uint32_t GetResultIdFromLabelId(const opt::Instruction& phi_inst, uint32_t label_id) { assert(phi_inst.opcode() == spv::Op::OpPhi && "|phi_inst| is not an OpPhi"); for (uint32_t i = 1; i < phi_inst.NumInOperands(); i += 2) { if (phi_inst.GetSingleWordInOperand(i) == label_id) { return phi_inst.GetSingleWordInOperand(i - 1); } } return 0; } bool ContainsPointers(const opt::analysis::Type& type) { switch (type.kind()) { case opt::analysis::Type::kPointer: return true; case opt::analysis::Type::kStruct: return std::any_of(type.AsStruct()->element_types().begin(), type.AsStruct()->element_types().end(), [](const opt::analysis::Type* element_type) { return ContainsPointers(*element_type); }); default: return false; } } bool HasValidDependencies(opt::IRContext* ir_context, opt::Instruction* inst) { const auto* inst_block = ir_context->get_instr_block(inst); assert(inst_block && "This function shouldn't be applied to global instructions or function" "parameters"); for (uint32_t i = 0; i < inst->NumInOperands(); ++i) { const auto& operand = inst->GetInOperand(i); if (operand.type != SPV_OPERAND_TYPE_ID) { // Consider only operands. continue; } auto* dependency = ir_context->get_def_use_mgr()->GetDef(operand.words[0]); assert(dependency && "Operand has invalid id"); if (ir_context->get_instr_block(dependency) == inst_block && dependency->opcode() != spv::Op::OpPhi) { // |dependency| is "valid" if it's an OpPhi from the same basic block or // an instruction from a different basic block. return false; } } return true; } } // namespace TransformationPropagateInstructionUp::TransformationPropagateInstructionUp( protobufs::TransformationPropagateInstructionUp message) : message_(std::move(message)) {} TransformationPropagateInstructionUp::TransformationPropagateInstructionUp( uint32_t block_id, const std::map& predecessor_id_to_fresh_id) { message_.set_block_id(block_id); *message_.mutable_predecessor_id_to_fresh_id() = fuzzerutil::MapToRepeatedUInt32Pair(predecessor_id_to_fresh_id); } bool TransformationPropagateInstructionUp::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { // Check that we can apply this transformation to the |block_id|. if (!IsApplicableToBlock(ir_context, message_.block_id())) { return false; } const auto predecessor_id_to_fresh_id = fuzzerutil::RepeatedUInt32PairToMap( message_.predecessor_id_to_fresh_id()); for (auto id : ir_context->cfg()->preds(message_.block_id())) { // Each predecessor must have a fresh id in the |predecessor_id_to_fresh_id| // map. if (!predecessor_id_to_fresh_id.count(id)) { return false; } } std::vector maybe_fresh_ids; maybe_fresh_ids.reserve(predecessor_id_to_fresh_id.size()); for (const auto& entry : predecessor_id_to_fresh_id) { maybe_fresh_ids.push_back(entry.second); } // All ids must be unique and fresh. return !fuzzerutil::HasDuplicates(maybe_fresh_ids) && std::all_of(maybe_fresh_ids.begin(), maybe_fresh_ids.end(), [ir_context](uint32_t id) { return fuzzerutil::IsFreshId(ir_context, id); }); } void TransformationPropagateInstructionUp::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { auto* inst = GetInstructionToPropagate(ir_context, message_.block_id()); assert(inst && "The block must have at least one supported instruction to propagate"); assert(inst->result_id() && inst->type_id() && "|inst| must have a result id and a type id"); opt::Instruction::OperandList op_phi_operands; const auto predecessor_id_to_fresh_id = fuzzerutil::RepeatedUInt32PairToMap( message_.predecessor_id_to_fresh_id()); std::unordered_set visited_predecessors; for (auto predecessor_id : ir_context->cfg()->preds(message_.block_id())) { // A block can have multiple identical predecessors. if (visited_predecessors.count(predecessor_id)) { continue; } visited_predecessors.insert(predecessor_id); auto new_result_id = predecessor_id_to_fresh_id.at(predecessor_id); // Compute InOperands for the OpPhi instruction to be inserted later. op_phi_operands.push_back({SPV_OPERAND_TYPE_ID, {new_result_id}}); op_phi_operands.push_back({SPV_OPERAND_TYPE_ID, {predecessor_id}}); // Create a clone of the |inst| to be inserted into the |predecessor_id|. std::unique_ptr clone(inst->Clone(ir_context)); clone->SetResultId(new_result_id); fuzzerutil::UpdateModuleIdBound(ir_context, new_result_id); // Adjust |clone|'s operands to account for possible dependencies on OpPhi // instructions from the same basic block. for (uint32_t i = 0; i < clone->NumInOperands(); ++i) { auto& operand = clone->GetInOperand(i); if (operand.type != SPV_OPERAND_TYPE_ID) { // Consider only ids. continue; } const auto* dependency_inst = ir_context->get_def_use_mgr()->GetDef(operand.words[0]); assert(dependency_inst && "|clone| depends on an invalid id"); if (ir_context->get_instr_block(dependency_inst->result_id()) != ir_context->cfg()->block(message_.block_id())) { // We don't need to adjust anything if |dependency_inst| is from a // different block, a global instruction or a function parameter. continue; } assert(dependency_inst->opcode() == spv::Op::OpPhi && "Propagated instruction can depend only on OpPhis from the same " "basic block or instructions from different basic blocks"); auto new_id = GetResultIdFromLabelId(*dependency_inst, predecessor_id); assert(new_id && "OpPhi instruction is missing a predecessor"); operand.words[0] = new_id; } auto* insert_before_inst = fuzzerutil::GetLastInsertBeforeInstruction( ir_context, predecessor_id, clone->opcode()); assert(insert_before_inst && "Can't insert |clone| into |predecessor_id"); insert_before_inst->InsertBefore(std::move(clone)); } // Insert an OpPhi instruction into the basic block of |inst|. ir_context->get_instr_block(inst)->begin()->InsertBefore( MakeUnique(ir_context, spv::Op::OpPhi, inst->type_id(), inst->result_id(), std::move(op_phi_operands))); // Remove |inst| from the basic block. ir_context->KillInst(inst); // We have changed the module so most analyzes are now invalid. ir_context->InvalidateAnalysesExceptFor( opt::IRContext::Analysis::kAnalysisNone); } protobufs::Transformation TransformationPropagateInstructionUp::ToMessage() const { protobufs::Transformation result; *result.mutable_propagate_instruction_up() = message_; return result; } bool TransformationPropagateInstructionUp::IsOpcodeSupported(spv::Op opcode) { // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/3605): // We only support "simple" instructions that don't work with memory. // We should extend this so that we support the ones that modify the memory // too. switch (opcode) { case spv::Op::OpUndef: case spv::Op::OpAccessChain: case spv::Op::OpInBoundsAccessChain: case spv::Op::OpArrayLength: case spv::Op::OpVectorExtractDynamic: case spv::Op::OpVectorInsertDynamic: case spv::Op::OpVectorShuffle: case spv::Op::OpCompositeConstruct: case spv::Op::OpCompositeExtract: case spv::Op::OpCompositeInsert: case spv::Op::OpCopyObject: case spv::Op::OpTranspose: case spv::Op::OpConvertFToU: case spv::Op::OpConvertFToS: case spv::Op::OpConvertSToF: case spv::Op::OpConvertUToF: case spv::Op::OpUConvert: case spv::Op::OpSConvert: case spv::Op::OpFConvert: case spv::Op::OpQuantizeToF16: case spv::Op::OpSatConvertSToU: case spv::Op::OpSatConvertUToS: case spv::Op::OpBitcast: case spv::Op::OpSNegate: case spv::Op::OpFNegate: case spv::Op::OpIAdd: case spv::Op::OpFAdd: case spv::Op::OpISub: case spv::Op::OpFSub: case spv::Op::OpIMul: case spv::Op::OpFMul: case spv::Op::OpUDiv: case spv::Op::OpSDiv: case spv::Op::OpFDiv: case spv::Op::OpUMod: case spv::Op::OpSRem: case spv::Op::OpSMod: case spv::Op::OpFRem: case spv::Op::OpFMod: case spv::Op::OpVectorTimesScalar: case spv::Op::OpMatrixTimesScalar: case spv::Op::OpVectorTimesMatrix: case spv::Op::OpMatrixTimesVector: case spv::Op::OpMatrixTimesMatrix: case spv::Op::OpOuterProduct: case spv::Op::OpDot: case spv::Op::OpIAddCarry: case spv::Op::OpISubBorrow: case spv::Op::OpUMulExtended: case spv::Op::OpSMulExtended: case spv::Op::OpAny: case spv::Op::OpAll: case spv::Op::OpIsNan: case spv::Op::OpIsInf: case spv::Op::OpIsFinite: case spv::Op::OpIsNormal: case spv::Op::OpSignBitSet: case spv::Op::OpLessOrGreater: case spv::Op::OpOrdered: case spv::Op::OpUnordered: case spv::Op::OpLogicalEqual: case spv::Op::OpLogicalNotEqual: case spv::Op::OpLogicalOr: case spv::Op::OpLogicalAnd: case spv::Op::OpLogicalNot: case spv::Op::OpSelect: case spv::Op::OpIEqual: case spv::Op::OpINotEqual: case spv::Op::OpUGreaterThan: case spv::Op::OpSGreaterThan: case spv::Op::OpUGreaterThanEqual: case spv::Op::OpSGreaterThanEqual: case spv::Op::OpULessThan: case spv::Op::OpSLessThan: case spv::Op::OpULessThanEqual: case spv::Op::OpSLessThanEqual: case spv::Op::OpFOrdEqual: case spv::Op::OpFUnordEqual: case spv::Op::OpFOrdNotEqual: case spv::Op::OpFUnordNotEqual: case spv::Op::OpFOrdLessThan: case spv::Op::OpFUnordLessThan: case spv::Op::OpFOrdGreaterThan: case spv::Op::OpFUnordGreaterThan: case spv::Op::OpFOrdLessThanEqual: case spv::Op::OpFUnordLessThanEqual: case spv::Op::OpFOrdGreaterThanEqual: case spv::Op::OpFUnordGreaterThanEqual: case spv::Op::OpShiftRightLogical: case spv::Op::OpShiftRightArithmetic: case spv::Op::OpShiftLeftLogical: case spv::Op::OpBitwiseOr: case spv::Op::OpBitwiseXor: case spv::Op::OpBitwiseAnd: case spv::Op::OpNot: case spv::Op::OpBitFieldInsert: case spv::Op::OpBitFieldSExtract: case spv::Op::OpBitFieldUExtract: case spv::Op::OpBitReverse: case spv::Op::OpBitCount: case spv::Op::OpCopyLogical: case spv::Op::OpPtrEqual: case spv::Op::OpPtrNotEqual: return true; default: return false; } } opt::Instruction* TransformationPropagateInstructionUp::GetInstructionToPropagate( opt::IRContext* ir_context, uint32_t block_id) { auto* block = ir_context->cfg()->block(block_id); assert(block && "|block_id| is invalid"); for (auto& inst : *block) { // We look for the first instruction in the block that satisfies the // following rules: // - it's not an OpPhi // - it must be supported by this transformation // - it may depend only on instructions from different basic blocks or on // OpPhi instructions from the same basic block. if (inst.opcode() == spv::Op::OpPhi || !IsOpcodeSupported(inst.opcode()) || !inst.type_id() || !inst.result_id()) { continue; } const auto* inst_type = ir_context->get_type_mgr()->GetType(inst.type_id()); assert(inst_type && "|inst| has invalid type"); if (inst_type->AsSampledImage()) { // OpTypeSampledImage cannot be used as an argument to OpPhi instructions, // thus we cannot support this type. continue; } if (!ir_context->get_feature_mgr()->HasCapability( spv::Capability::VariablePointersStorageBuffer) && ContainsPointers(*inst_type)) { // OpPhi supports pointer operands only with VariablePointers or // VariablePointersStorageBuffer capabilities. // // Note that VariablePointers capability implicitly declares // VariablePointersStorageBuffer capability. continue; } if (!HasValidDependencies(ir_context, &inst)) { continue; } return &inst; } return nullptr; } bool TransformationPropagateInstructionUp::IsApplicableToBlock( opt::IRContext* ir_context, uint32_t block_id) { // Check that |block_id| is valid. const auto* label_inst = ir_context->get_def_use_mgr()->GetDef(block_id); if (!label_inst || label_inst->opcode() != spv::Op::OpLabel) { return false; } // Check that |block| has predecessors. const auto& predecessors = ir_context->cfg()->preds(block_id); if (predecessors.empty()) { return false; } // The block must contain an instruction to propagate. const auto* inst_to_propagate = GetInstructionToPropagate(ir_context, block_id); if (!inst_to_propagate) { return false; } // We should be able to insert |inst_to_propagate| into every predecessor of // |block|. return std::all_of(predecessors.begin(), predecessors.end(), [ir_context, inst_to_propagate](uint32_t predecessor_id) { return fuzzerutil::GetLastInsertBeforeInstruction( ir_context, predecessor_id, inst_to_propagate->opcode()) != nullptr; }); } std::unordered_set TransformationPropagateInstructionUp::GetFreshIds() const { std::unordered_set result; for (auto& pair : message_.predecessor_id_to_fresh_id()) { result.insert(pair.second()); } return result; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_propagate_instruction_up.h000066400000000000000000000073111475742701700314570ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_PROPAGATE_INSTRUCTION_UP_H_ #define SOURCE_FUZZ_TRANSFORMATION_PROPAGATE_INSTRUCTION_UP_H_ #include #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationPropagateInstructionUp : public Transformation { public: explicit TransformationPropagateInstructionUp( protobufs::TransformationPropagateInstructionUp message); TransformationPropagateInstructionUp( uint32_t block_id, const std::map& predecessor_id_to_fresh_id); // - |block_id| must be a valid result id of some OpLabel instruction. // - |block_id| must have at least one predecessor // - |block_id| must contain an instruction that can be propagated using this // transformation // - the instruction can be propagated if: // - it's not an OpPhi // - it is supported by this transformation // - it depends only on instructions from different basic blocks or on // OpPhi instructions from the same basic block // - it should be possible to insert the propagated instruction at the end of // each |block_id|'s predecessor // - |predecessor_id_to_fresh_id| must have an entry for at least every // predecessor of |block_id| // - each value in the |predecessor_id_to_fresh_id| map must be a fresh id // - all fresh ids in the |predecessor_id_to_fresh_id| must be unique bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Inserts a copy of the propagated instruction into each |block_id|'s // predecessor. Replaces the original instruction with an OpPhi referring // inserted copies. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; // Returns true if this transformation can be applied to the block with id // |block_id|. Concretely, returns true iff: // - |block_id| is a valid id of some block in the module // - |block_id| has predecessors // - |block_id| contains an instruction that can be propagated // - it is possible to insert the propagated instruction into every // |block_id|'s predecessor static bool IsApplicableToBlock(opt::IRContext* ir_context, uint32_t block_id); private: // Returns the instruction that will be propagated into the predecessors of // the |block_id|. Returns nullptr if no such an instruction exists. static opt::Instruction* GetInstructionToPropagate(opt::IRContext* ir_context, uint32_t block_id); // Returns true if |opcode| is supported by this transformation. static bool IsOpcodeSupported(spv::Op opcode); protobufs::TransformationPropagateInstructionUp message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_PROPAGATE_INSTRUCTION_UP_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_push_id_through_variable.cpp000066400000000000000000000174051475742701700317300ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_push_id_through_variable.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" namespace spvtools { namespace fuzz { TransformationPushIdThroughVariable::TransformationPushIdThroughVariable( protobufs::TransformationPushIdThroughVariable message) : message_(std::move(message)) {} TransformationPushIdThroughVariable::TransformationPushIdThroughVariable( uint32_t value_id, uint32_t value_synonym_id, uint32_t variable_id, uint32_t variable_storage_class, uint32_t initializer_id, const protobufs::InstructionDescriptor& instruction_descriptor) { message_.set_value_id(value_id); message_.set_value_synonym_id(value_synonym_id); message_.set_variable_id(variable_id); message_.set_variable_storage_class(variable_storage_class); message_.set_initializer_id(initializer_id); *message_.mutable_instruction_descriptor() = instruction_descriptor; } bool TransformationPushIdThroughVariable::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { // |message_.value_synonym_id| and |message_.variable_id| must be fresh. if (!fuzzerutil::IsFreshId(ir_context, message_.value_synonym_id()) || !fuzzerutil::IsFreshId(ir_context, message_.variable_id())) { return false; } // The instruction to insert before must be defined. auto instruction_to_insert_before = FindInstruction(message_.instruction_descriptor(), ir_context); if (!instruction_to_insert_before) { return false; } // It must be valid to insert the OpStore and OpLoad instruction before it. if (!fuzzerutil::CanInsertOpcodeBeforeInstruction( spv::Op::OpStore, instruction_to_insert_before) || !fuzzerutil::CanInsertOpcodeBeforeInstruction( spv::Op::OpLoad, instruction_to_insert_before)) { return false; } // The instruction to insert before must belong to a reachable block. auto basic_block = ir_context->get_instr_block(instruction_to_insert_before); if (!ir_context->IsReachable(*basic_block)) { return false; } // The value instruction must be defined and have a type. auto value_instruction = ir_context->get_def_use_mgr()->GetDef(message_.value_id()); if (!value_instruction || !value_instruction->type_id()) { return false; } // A pointer type instruction pointing to the value type must be defined. auto pointer_type_id = fuzzerutil::MaybeGetPointerType( ir_context, value_instruction->type_id(), static_cast(message_.variable_storage_class())); if (!pointer_type_id) { return false; } // |message_.variable_storage_class| must be private or function. assert((message_.variable_storage_class() == (uint32_t)spv::StorageClass::Private || message_.variable_storage_class() == (uint32_t)spv::StorageClass::Function) && "The variable storage class must be private or function."); // Check that initializer is valid. const auto* constant_inst = ir_context->get_def_use_mgr()->GetDef(message_.initializer_id()); if (!constant_inst || !spvOpcodeIsConstant(constant_inst->opcode()) || value_instruction->type_id() != constant_inst->type_id()) { return false; } // |message_.value_id| must be available at the insertion point. return fuzzerutil::IdIsAvailableBeforeInstruction( ir_context, instruction_to_insert_before, message_.value_id()); } void TransformationPushIdThroughVariable::Apply( opt::IRContext* ir_context, TransformationContext* transformation_context) const { auto value_instruction = ir_context->get_def_use_mgr()->GetDef(message_.value_id()); opt::Instruction* insert_before = FindInstruction(message_.instruction_descriptor(), ir_context); opt::BasicBlock* enclosing_block = ir_context->get_instr_block(insert_before); // A pointer type instruction pointing to the value type must be defined. auto pointer_type_id = fuzzerutil::MaybeGetPointerType( ir_context, value_instruction->type_id(), static_cast(message_.variable_storage_class())); assert(pointer_type_id && "The required pointer type must be available."); // Adds whether a global or local variable. if (spv::StorageClass(message_.variable_storage_class()) == spv::StorageClass::Private) { opt::Instruction* global_variable = fuzzerutil::AddGlobalVariable( ir_context, message_.variable_id(), pointer_type_id, spv::StorageClass::Private, message_.initializer_id()); ir_context->get_def_use_mgr()->AnalyzeInstDefUse(global_variable); } else { opt::Function* function = ir_context ->get_instr_block( FindInstruction(message_.instruction_descriptor(), ir_context)) ->GetParent(); opt::Instruction* local_variable = fuzzerutil::AddLocalVariable( ir_context, message_.variable_id(), pointer_type_id, function->result_id(), message_.initializer_id()); ir_context->get_def_use_mgr()->AnalyzeInstDefUse(local_variable); ir_context->set_instr_block(local_variable, &*function->entry()); } // First, insert the OpLoad instruction before |instruction_descriptor| and // then insert the OpStore instruction before the OpLoad instruction. fuzzerutil::UpdateModuleIdBound(ir_context, message_.value_synonym_id()); opt::Instruction* load_instruction = insert_before->InsertBefore(MakeUnique( ir_context, spv::Op::OpLoad, value_instruction->type_id(), message_.value_synonym_id(), opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {message_.variable_id()}}}))); opt::Instruction* store_instruction = load_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpStore, 0, 0, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {message_.variable_id()}}, {SPV_OPERAND_TYPE_ID, {message_.value_id()}}}))); ir_context->get_def_use_mgr()->AnalyzeInstDefUse(store_instruction); ir_context->set_instr_block(store_instruction, enclosing_block); ir_context->get_def_use_mgr()->AnalyzeInstDefUse(load_instruction); ir_context->set_instr_block(load_instruction, enclosing_block); // We should be able to create a synonym of |value_id| if it's not irrelevant. if (fuzzerutil::CanMakeSynonymOf(ir_context, *transformation_context, *value_instruction) && !transformation_context->GetFactManager()->IdIsIrrelevant( message_.value_synonym_id())) { // Adds the fact that |message_.value_synonym_id| // and |message_.value_id| are synonymous. transformation_context->GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(message_.value_synonym_id(), {}), MakeDataDescriptor(message_.value_id(), {})); } } protobufs::Transformation TransformationPushIdThroughVariable::ToMessage() const { protobufs::Transformation result; *result.mutable_push_id_through_variable() = message_; return result; } std::unordered_set TransformationPushIdThroughVariable::GetFreshIds() const { return {message_.value_synonym_id(), message_.variable_id()}; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_push_id_through_variable.h000066400000000000000000000055131475742701700313720ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_PUSH_ID_THROUGH_VARIABLE_H_ #define SOURCE_FUZZ_TRANSFORMATION_PUSH_ID_THROUGH_VARIABLE_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationPushIdThroughVariable : public Transformation { public: explicit TransformationPushIdThroughVariable( protobufs::TransformationPushIdThroughVariable message); TransformationPushIdThroughVariable( uint32_t value_id, uint32_t value_synonym_fresh_id, uint32_t variable_fresh_id, uint32_t variable_storage_class, uint32_t initializer_id, const protobufs::InstructionDescriptor& instruction_descriptor); // - |message_.value_id| must be an instruction result id that has the same // type as the pointee type of |message_.pointer_id| // - |message_.value_synonym_id| must be fresh // - |message_.variable_id| must be fresh // - |message_.variable_storage_class| must be either StorageClassPrivate or // StorageClassFunction // - |message_.initializer_id| must be a result id of some constant in the // module. Its type must be equal to the pointee type of the variable that // will be created. // - |message_.instruction_descriptor| must identify an instruction // which it is valid to insert the OpStore and OpLoad instructions before it // and must be belongs to a reachable block. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Stores |value_id| to |variable_id|, loads |variable_id| to // |value_synonym_id|. Adds the fact that |value_synonym_id| and |value_id| // are synonymous if |value_id| and |value_synonym_id| are not irrelevant. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationPushIdThroughVariable message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_PUSH_ID_THROUGH_VARIABLE_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_record_synonymous_constants.cpp000066400000000000000000000114571475742701700325660ustar00rootroot00000000000000// Copyright (c) 2020 Stefano Milizia // Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "transformation_record_synonymous_constants.h" #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { TransformationRecordSynonymousConstants:: TransformationRecordSynonymousConstants( protobufs::TransformationRecordSynonymousConstants message) : message_(std::move(message)) {} TransformationRecordSynonymousConstants:: TransformationRecordSynonymousConstants(uint32_t constant1_id, uint32_t constant2_id) { message_.set_constant1_id(constant1_id); message_.set_constant2_id(constant2_id); } bool TransformationRecordSynonymousConstants::IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const { // The ids must be different if (message_.constant1_id() == message_.constant2_id()) { return false; } if (transformation_context.GetFactManager()->IdIsIrrelevant( message_.constant1_id()) || transformation_context.GetFactManager()->IdIsIrrelevant( message_.constant2_id())) { return false; } return AreEquivalentConstants(ir_context, message_.constant1_id(), message_.constant2_id()); } void TransformationRecordSynonymousConstants::Apply( opt::IRContext* /*unused*/, TransformationContext* transformation_context) const { // Add the fact to the fact manager transformation_context->GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(message_.constant1_id(), {}), MakeDataDescriptor(message_.constant2_id(), {})); } protobufs::Transformation TransformationRecordSynonymousConstants::ToMessage() const { protobufs::Transformation result; *result.mutable_record_synonymous_constants() = message_; return result; } bool TransformationRecordSynonymousConstants::AreEquivalentConstants( opt::IRContext* ir_context, uint32_t constant_id1, uint32_t constant_id2) { const auto* def_1 = ir_context->get_def_use_mgr()->GetDef(constant_id1); const auto* def_2 = ir_context->get_def_use_mgr()->GetDef(constant_id2); // Check that the definitions exist if (!def_1 || !def_2) { // We don't use an assertion since otherwise the shrinker fails. return false; } auto constant1 = ir_context->get_constant_mgr()->GetConstantFromInst(def_1); auto constant2 = ir_context->get_constant_mgr()->GetConstantFromInst(def_2); // The ids must refer to constants. if (!constant1 || !constant2) { return false; } // The types must be compatible. if (!fuzzerutil::TypesAreEqualUpToSign(ir_context, def_1->type_id(), def_2->type_id())) { return false; } // If either constant is null, the other is equivalent iff it is zero-like if (constant1->AsNullConstant()) { return constant2->IsZero(); } if (constant2->AsNullConstant()) { return constant1->IsZero(); } // If the constants are scalar, they are equal iff their words are the same if (auto scalar1 = constant1->AsScalarConstant()) { // Either both or neither constant is scalar since we've already checked // that their types are compatible. assert(constant2->AsScalarConstant() && "Both constants must be scalar"); return scalar1->words() == constant2->AsScalarConstant()->words(); } // The only remaining possibility is that the constants are composite assert(constant1->AsCompositeConstant() && constant2->AsCompositeConstant() && "Equivalence of constants can only be checked with scalar, composite " "or null constants."); // Since the types match, we already know that the number of components is // the same. We check that the input operands of the definitions are all // constants and that they are pairwise equivalent. for (uint32_t i = 0; i < def_1->NumInOperands(); i++) { if (!AreEquivalentConstants(ir_context, def_1->GetSingleWordInOperand(i), def_2->GetSingleWordInOperand(i))) { return false; } } // If we get here, all the components are equivalent return true; } std::unordered_set TransformationRecordSynonymousConstants::GetFreshIds() const { return std::unordered_set(); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_record_synonymous_constants.h000066400000000000000000000057451475742701700322360ustar00rootroot00000000000000// Copyright (c) 2020 Stefano Milizia // Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_RECORD_SYNONYMOUS_CONSTANTS_H #define SOURCE_FUZZ_TRANSFORMATION_RECORD_SYNONYMOUS_CONSTANTS_H #include "source/fuzz/transformation.h" namespace spvtools { namespace fuzz { class TransformationRecordSynonymousConstants : public Transformation { public: explicit TransformationRecordSynonymousConstants( protobufs::TransformationRecordSynonymousConstants message); TransformationRecordSynonymousConstants(uint32_t constant1_id, uint32_t constant2_id); // - |message_.constant_id| and |message_.synonym_id| are distinct ids // of constants // - |message_.constant_id| and |message_.synonym_id| refer to constants // that are equivalent. // Constants are equivalent if at least one of the following holds: // - they are equal (i.e. they have the same type ids and equal values) // - both of them represent zero-like values of compatible types // - they are composite constants with compatible types and their // components are pairwise equivalent // Two types are compatible if at least one of the following holds: // - they have the same id // - they are integer scalar types with the same width // - they are integer vectors and their components have the same width // (this is always the case if the components are equivalent) bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Adds the fact that |message_.constant_id| and |message_.synonym_id| // are synonyms to the fact manager. The module is not changed. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationRecordSynonymousConstants message_; // Returns true if the two given constants are equivalent // (the description of IsApplicable specifies the conditions they must satisfy // to be considered equivalent) static bool AreEquivalentConstants(opt::IRContext* ir_context, uint32_t constant_id1, uint32_t constant_id2); }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_RECORD_SYNONYMOUS_CONSTANTS transformation_replace_add_sub_mul_with_carrying_extended.cpp000066400000000000000000000210041475742701700353610ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/fuzz// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_replace_add_sub_mul_with_carrying_extended.h" #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { namespace { const uint32_t kOpCompositeExtractIndexLowOrderBits = 0; const uint32_t kArithmeticInstructionIndexLeftInOperand = 0; const uint32_t kArithmeticInstructionIndexRightInOperand = 1; } // namespace TransformationReplaceAddSubMulWithCarryingExtended:: TransformationReplaceAddSubMulWithCarryingExtended( protobufs::TransformationReplaceAddSubMulWithCarryingExtended message) : message_(std::move(message)) {} TransformationReplaceAddSubMulWithCarryingExtended:: TransformationReplaceAddSubMulWithCarryingExtended(uint32_t struct_fresh_id, uint32_t result_id) { message_.set_struct_fresh_id(struct_fresh_id); message_.set_result_id(result_id); } bool TransformationReplaceAddSubMulWithCarryingExtended::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { // |message_.struct_fresh_id| must be fresh. if (!fuzzerutil::IsFreshId(ir_context, message_.struct_fresh_id())) { return false; } // |message_.result_id| must refer to a suitable OpIAdd, OpISub or OpIMul // instruction. The instruction must be defined. auto instruction = ir_context->get_def_use_mgr()->GetDef(message_.result_id()); if (instruction == nullptr) { return false; } if (!TransformationReplaceAddSubMulWithCarryingExtended:: IsInstructionSuitable(ir_context, *instruction)) { return false; } // The struct type for holding the intermediate result must exist in the // module. The struct type is based on the operand type. uint32_t operand_type_id = ir_context->get_def_use_mgr() ->GetDef(instruction->GetSingleWordInOperand( kArithmeticInstructionIndexLeftInOperand)) ->type_id(); uint32_t struct_type_id = fuzzerutil::MaybeGetStructType( ir_context, {operand_type_id, operand_type_id}); if (struct_type_id == 0) { return false; } return true; } void TransformationReplaceAddSubMulWithCarryingExtended::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { // |message_.struct_fresh_id| must be fresh. assert(fuzzerutil::IsFreshId(ir_context, message_.struct_fresh_id()) && "|message_.struct_fresh_id| must be fresh"); // Get the signedness of an operand if it is an int or the signedness of a // component if it is a vector. auto type_id = ir_context->get_def_use_mgr()->GetDef(message_.result_id())->type_id(); auto type = ir_context->get_type_mgr()->GetType(type_id); bool operand_is_signed; if (type->kind() == opt::analysis::Type::kVector) { auto operand_type = type->AsVector()->element_type(); operand_is_signed = operand_type->AsInteger()->IsSigned(); } else { operand_is_signed = type->AsInteger()->IsSigned(); } auto original_instruction = ir_context->get_def_use_mgr()->GetDef(message_.result_id()); fuzzerutil::UpdateModuleIdBound(ir_context, message_.struct_fresh_id()); // Determine the opcode of the new instruction that computes the result into a // struct. spv::Op new_instruction_opcode; switch (original_instruction->opcode()) { case spv::Op::OpIAdd: new_instruction_opcode = spv::Op::OpIAddCarry; break; case spv::Op::OpISub: new_instruction_opcode = spv::Op::OpISubBorrow; break; case spv::Op::OpIMul: if (!operand_is_signed) { new_instruction_opcode = spv::Op::OpUMulExtended; } else { new_instruction_opcode = spv::Op::OpSMulExtended; } break; default: assert(false && "The instruction has an unsupported opcode."); return; } // Get the type of struct type id holding the intermediate result based on the // operand type. uint32_t operand_type_id = ir_context->get_def_use_mgr() ->GetDef(original_instruction->GetSingleWordInOperand( kArithmeticInstructionIndexLeftInOperand)) ->type_id(); uint32_t struct_type_id = fuzzerutil::MaybeGetStructType( ir_context, {operand_type_id, operand_type_id}); // Avoid unused variables in release mode. (void)struct_type_id; assert(struct_type_id && "The struct type must exist in the module."); // Insert the new instruction that computes the result into a struct before // the |original_instruction|. original_instruction->InsertBefore(MakeUnique( ir_context, new_instruction_opcode, struct_type_id, message_.struct_fresh_id(), opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {original_instruction->GetSingleWordInOperand( kArithmeticInstructionIndexLeftInOperand)}}, {SPV_OPERAND_TYPE_ID, {original_instruction->GetSingleWordInOperand( kArithmeticInstructionIndexRightInOperand)}}}))); // Insert the OpCompositeExtract after the added instruction. This instruction // takes the first component of the struct which represents low-order bits of // the operation. This is the original result. original_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpCompositeExtract, original_instruction->type_id(), message_.result_id(), opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {message_.struct_fresh_id()}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {kOpCompositeExtractIndexLowOrderBits}}}))); // Remove the original instruction. ir_context->KillInst(original_instruction); // We have modified the module so most analyzes are now invalid. ir_context->InvalidateAnalysesExceptFor(opt::IRContext::kAnalysisNone); } bool TransformationReplaceAddSubMulWithCarryingExtended::IsInstructionSuitable( opt::IRContext* ir_context, const opt::Instruction& instruction) { auto instruction_opcode = instruction.opcode(); // Only instructions OpIAdd, OpISub, OpIMul are supported. switch (instruction_opcode) { case spv::Op::OpIAdd: case spv::Op::OpISub: case spv::Op::OpIMul: break; default: return false; } uint32_t operand_1_type_id = ir_context->get_def_use_mgr() ->GetDef(instruction.GetSingleWordInOperand( kArithmeticInstructionIndexLeftInOperand)) ->type_id(); uint32_t operand_2_type_id = ir_context->get_def_use_mgr() ->GetDef(instruction.GetSingleWordInOperand( kArithmeticInstructionIndexRightInOperand)) ->type_id(); uint32_t result_type_id = instruction.type_id(); // Both type ids of the operands and the result type ids must be equal. if (operand_1_type_id != operand_2_type_id) { return false; } if (operand_2_type_id != result_type_id) { return false; } // In case of OpIAdd and OpISub, the type must be unsigned. auto type = ir_context->get_type_mgr()->GetType(instruction.type_id()); switch (instruction_opcode) { case spv::Op::OpIAdd: case spv::Op::OpISub: { // In case of OpIAdd and OpISub if the operand is a vector, the component // type must be unsigned. Otherwise (if the operand is an int), the // operand must be unsigned. bool operand_is_signed = type->AsVector() ? type->AsVector()->element_type()->AsInteger()->IsSigned() : type->AsInteger()->IsSigned(); if (operand_is_signed) { return false; } } break; default: break; } return true; } protobufs::Transformation TransformationReplaceAddSubMulWithCarryingExtended::ToMessage() const { protobufs::Transformation result; *result.mutable_replace_add_sub_mul_with_carrying_extended() = message_; return result; } std::unordered_set TransformationReplaceAddSubMulWithCarryingExtended::GetFreshIds() const { return {message_.struct_fresh_id()}; } } // namespace fuzz } // namespace spvtools transformation_replace_add_sub_mul_with_carrying_extended.h000066400000000000000000000054561475742701700350430ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/fuzz// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_REPLACE_ADD_SUB_MUL_WITH_CARRYING_EXTENDED_H_ #define SOURCE_FUZZ_TRANSFORMATION_REPLACE_ADD_SUB_MUL_WITH_CARRYING_EXTENDED_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationReplaceAddSubMulWithCarryingExtended : public Transformation { public: explicit TransformationReplaceAddSubMulWithCarryingExtended( protobufs::TransformationReplaceAddSubMulWithCarryingExtended message); explicit TransformationReplaceAddSubMulWithCarryingExtended( uint32_t struct_fresh_id, uint32_t result_id); // - |message_.struct_fresh_id| must be fresh. // - |message_.result_id| must refer to an OpIAdd or OpISub or OpIMul // instruction. In this instruction the result type id and the type ids of // the operands must be the same. // - The type of struct holding the intermediate result must exists in the // module. // - For OpIAdd, OpISub both operands must be unsigned. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // A transformation that replaces instructions OpIAdd, OpISub, OpIMul with // pairs of instructions. The first one (OpIAddCarry, OpISubBorrow, // OpUMulExtended, OpSMulExtended) computes the result into a struct. The // second one extracts the appropriate component from the struct to yield the // original result. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; // Checks if an OpIAdd, OpISub or OpIMul instruction can be used by the // transformation. bool static IsInstructionSuitable(opt::IRContext* ir_context, const opt::Instruction& instruction); private: protobufs::TransformationReplaceAddSubMulWithCarryingExtended message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_REPLACE_ADD_SUB_MUL_WITH_CARRYING_EXTENDED_H_ transformation_replace_boolean_constant_with_constant_binary.cpp000066400000000000000000000276501475742701700361470ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/fuzz// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_replace_boolean_constant_with_constant_binary.h" #include #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/id_use_descriptor.h" namespace spvtools { namespace fuzz { namespace { // Given floating-point values |lhs| and |rhs|, and a floating-point binary // operator |binop|, returns true if it is certain that 'lhs binop rhs' // evaluates to |required_value|. template bool float_binop_evaluates_to(T lhs, T rhs, spv::Op binop, bool required_value) { // Infinity and NaN values are conservatively treated as out of scope. if (!std::isfinite(lhs) || !std::isfinite(rhs)) { return false; } bool binop_result; // The following captures the binary operators that spirv-fuzz can actually // generate when turning a boolean constant into a binary expression. switch (binop) { case spv::Op::OpFOrdGreaterThanEqual: case spv::Op::OpFUnordGreaterThanEqual: binop_result = (lhs >= rhs); break; case spv::Op::OpFOrdGreaterThan: case spv::Op::OpFUnordGreaterThan: binop_result = (lhs > rhs); break; case spv::Op::OpFOrdLessThanEqual: case spv::Op::OpFUnordLessThanEqual: binop_result = (lhs <= rhs); break; case spv::Op::OpFOrdLessThan: case spv::Op::OpFUnordLessThan: binop_result = (lhs < rhs); break; default: return false; } return binop_result == required_value; } // Analogous to 'float_binop_evaluates_to', but for signed int values. template bool signed_int_binop_evaluates_to(T lhs, T rhs, spv::Op binop, bool required_value) { bool binop_result; switch (binop) { case spv::Op::OpSGreaterThanEqual: binop_result = (lhs >= rhs); break; case spv::Op::OpSGreaterThan: binop_result = (lhs > rhs); break; case spv::Op::OpSLessThanEqual: binop_result = (lhs <= rhs); break; case spv::Op::OpSLessThan: binop_result = (lhs < rhs); break; default: return false; } return binop_result == required_value; } // Analogous to 'float_binop_evaluates_to', but for unsigned int values. template bool unsigned_int_binop_evaluates_to(T lhs, T rhs, spv::Op binop, bool required_value) { bool binop_result; switch (binop) { case spv::Op::OpUGreaterThanEqual: binop_result = (lhs >= rhs); break; case spv::Op::OpUGreaterThan: binop_result = (lhs > rhs); break; case spv::Op::OpULessThanEqual: binop_result = (lhs <= rhs); break; case spv::Op::OpULessThan: binop_result = (lhs < rhs); break; default: return false; } return binop_result == required_value; } } // namespace TransformationReplaceBooleanConstantWithConstantBinary:: TransformationReplaceBooleanConstantWithConstantBinary( protobufs::TransformationReplaceBooleanConstantWithConstantBinary message) : message_(std::move(message)) {} TransformationReplaceBooleanConstantWithConstantBinary:: TransformationReplaceBooleanConstantWithConstantBinary( const protobufs::IdUseDescriptor& id_use_descriptor, uint32_t lhs_id, uint32_t rhs_id, spv::Op comparison_opcode, uint32_t fresh_id_for_binary_operation) { *message_.mutable_id_use_descriptor() = id_use_descriptor; message_.set_lhs_id(lhs_id); message_.set_rhs_id(rhs_id); message_.set_opcode(uint32_t(comparison_opcode)); message_.set_fresh_id_for_binary_operation(fresh_id_for_binary_operation); } bool TransformationReplaceBooleanConstantWithConstantBinary::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { // The id for the binary result must be fresh if (!fuzzerutil::IsFreshId(ir_context, message_.fresh_id_for_binary_operation())) { return false; } // The used id must be for a boolean constant auto boolean_constant = ir_context->get_def_use_mgr()->GetDef( message_.id_use_descriptor().id_of_interest()); if (!boolean_constant) { return false; } if (!(boolean_constant->opcode() == spv::Op::OpConstantFalse || boolean_constant->opcode() == spv::Op::OpConstantTrue)) { return false; } // The left-hand-side id must correspond to a constant instruction. auto lhs_constant_inst = ir_context->get_def_use_mgr()->GetDef(message_.lhs_id()); if (!lhs_constant_inst) { return false; } if (lhs_constant_inst->opcode() != spv::Op::OpConstant) { return false; } // The right-hand-side id must correspond to a constant instruction. auto rhs_constant_inst = ir_context->get_def_use_mgr()->GetDef(message_.rhs_id()); if (!rhs_constant_inst) { return false; } if (rhs_constant_inst->opcode() != spv::Op::OpConstant) { return false; } // The left- and right-hand side instructions must have the same type. if (lhs_constant_inst->type_id() != rhs_constant_inst->type_id()) { return false; } // The expression 'LHS opcode RHS' must evaluate to the boolean constant. auto lhs_constant = ir_context->get_constant_mgr()->FindDeclaredConstant(message_.lhs_id()); auto rhs_constant = ir_context->get_constant_mgr()->FindDeclaredConstant(message_.rhs_id()); bool expected_result = (boolean_constant->opcode() == spv::Op::OpConstantTrue); const auto binary_opcode = static_cast(message_.opcode()); // We consider the floating point, signed and unsigned integer cases // separately. In each case the logic is very similar. if (lhs_constant->AsFloatConstant()) { assert(rhs_constant->AsFloatConstant() && "Both constants should be of the same type."); if (lhs_constant->type()->AsFloat()->width() == 32) { if (!float_binop_evaluates_to(lhs_constant->GetFloat(), rhs_constant->GetFloat(), binary_opcode, expected_result)) { return false; } } else { assert(lhs_constant->type()->AsFloat()->width() == 64); if (!float_binop_evaluates_to(lhs_constant->GetDouble(), rhs_constant->GetDouble(), binary_opcode, expected_result)) { return false; } } } else { assert(lhs_constant->AsIntConstant() && "Constants should be in or float."); assert(rhs_constant->AsIntConstant() && "Both constants should be of the same type."); if (lhs_constant->type()->AsInteger()->IsSigned()) { if (lhs_constant->type()->AsInteger()->width() == 32) { if (!signed_int_binop_evaluates_to(lhs_constant->GetS32(), rhs_constant->GetS32(), binary_opcode, expected_result)) { return false; } } else { assert(lhs_constant->type()->AsInteger()->width() == 64); if (!signed_int_binop_evaluates_to(lhs_constant->GetS64(), rhs_constant->GetS64(), binary_opcode, expected_result)) { return false; } } } else { if (lhs_constant->type()->AsInteger()->width() == 32) { if (!unsigned_int_binop_evaluates_to(lhs_constant->GetU32(), rhs_constant->GetU32(), binary_opcode, expected_result)) { return false; } } else { assert(lhs_constant->type()->AsInteger()->width() == 64); if (!unsigned_int_binop_evaluates_to(lhs_constant->GetU64(), rhs_constant->GetU64(), binary_opcode, expected_result)) { return false; } } } } // The id use descriptor must identify some instruction auto instruction = FindInstructionContainingUse(message_.id_use_descriptor(), ir_context); if (instruction == nullptr) { return false; } // The instruction must not be an OpVariable, because (a) we cannot insert // a binary operator before an OpVariable, but in any case (b) the // constant we would be replacing is the initializer constant of the // OpVariable, and this cannot be the result of a binary operation. if (instruction->opcode() == spv::Op::OpVariable) { return false; } return true; } void TransformationReplaceBooleanConstantWithConstantBinary::Apply( opt::IRContext* ir_context, TransformationContext* transformation_context) const { ApplyWithResult(ir_context, transformation_context); } opt::Instruction* TransformationReplaceBooleanConstantWithConstantBinary::ApplyWithResult( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { opt::analysis::Bool bool_type; opt::Instruction::OperandList operands = { {SPV_OPERAND_TYPE_ID, {message_.lhs_id()}}, {SPV_OPERAND_TYPE_ID, {message_.rhs_id()}}}; auto binary_instruction = MakeUnique( ir_context, static_cast(message_.opcode()), ir_context->get_type_mgr()->GetId(&bool_type), message_.fresh_id_for_binary_operation(), operands); opt::Instruction* result = binary_instruction.get(); auto instruction_containing_constant_use = FindInstructionContainingUse(message_.id_use_descriptor(), ir_context); auto instruction_before_which_to_insert = instruction_containing_constant_use; // If |instruction_before_which_to_insert| is an OpPhi instruction, // then |binary_instruction| will be inserted into the parent block associated // with the OpPhi variable operand. if (instruction_containing_constant_use->opcode() == spv::Op::OpPhi) { instruction_before_which_to_insert = ir_context->cfg() ->block(instruction_containing_constant_use->GetSingleWordInOperand( message_.id_use_descriptor().in_operand_index() + 1)) ->terminator(); } // We want to insert the new instruction before the instruction that contains // the use of the boolean, but we need to go backwards one more instruction if // the using instruction is preceded by a merge instruction. { opt::Instruction* previous_node = instruction_before_which_to_insert->PreviousNode(); if (previous_node && (previous_node->opcode() == spv::Op::OpLoopMerge || previous_node->opcode() == spv::Op::OpSelectionMerge)) { instruction_before_which_to_insert = previous_node; } } instruction_before_which_to_insert->InsertBefore( std::move(binary_instruction)); instruction_containing_constant_use->SetInOperand( message_.id_use_descriptor().in_operand_index(), {message_.fresh_id_for_binary_operation()}); fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id_for_binary_operation()); ir_context->InvalidateAnalysesExceptFor( opt::IRContext::Analysis::kAnalysisNone); return result; } protobufs::Transformation TransformationReplaceBooleanConstantWithConstantBinary::ToMessage() const { protobufs::Transformation result; *result.mutable_replace_boolean_constant_with_constant_binary() = message_; return result; } std::unordered_set TransformationReplaceBooleanConstantWithConstantBinary::GetFreshIds() const { return {message_.fresh_id_for_binary_operation()}; } } // namespace fuzz } // namespace spvtools transformation_replace_boolean_constant_with_constant_binary.h000066400000000000000000000065601475742701700356110ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/fuzz// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_REPLACE_BOOLEAN_CONSTANT_WITH_CONSTANT_BINARY_H_ #define SOURCE_FUZZ_TRANSFORMATION_REPLACE_BOOLEAN_CONSTANT_WITH_CONSTANT_BINARY_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationReplaceBooleanConstantWithConstantBinary : public Transformation { public: explicit TransformationReplaceBooleanConstantWithConstantBinary( protobufs::TransformationReplaceBooleanConstantWithConstantBinary message); TransformationReplaceBooleanConstantWithConstantBinary( const protobufs::IdUseDescriptor& id_use_descriptor, uint32_t lhs_id, uint32_t rhs_id, spv::Op comparison_opcode, uint32_t fresh_id_for_binary_operation); // - |message_.fresh_id_for_binary_operation| must not already be used by the // module. // - |message_.id_use_descriptor| must identify a use of a boolean constant c. // - |message_.lhs_id| and |message.rhs_id| must be the ids of constant // instructions with the same type // - |message_.opcode| must be suitable for applying to |message.lhs_id| and // |message_.rhs_id|, and the result must evaluate to the boolean constant // c. // - The boolean constant usage must not be an argument to OpPhi, because in // this case it is not legal to insert a binary operator instruction right // before the OpPhi. // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/2902): consider // replacing a boolean in an OpPhi by adding a binary operator instruction // to the parent block for the OpPhi. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // A new instruction is added before the boolean constant usage that computes // the result of applying |message_.opcode| to |message_.lhs_id| and // |message_.rhs_id| is added, with result id // |message_.fresh_id_for_binary_operation|. The boolean constant usage is // replaced with this result id. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; // The same as Apply, except that the newly-added binary instruction is // returned. opt::Instruction* ApplyWithResult( opt::IRContext* ir_context, TransformationContext* transformation_context) const; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationReplaceBooleanConstantWithConstantBinary message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_REPLACE_BOOLEAN_CONSTANT_WITH_CONSTANT_BINARY_H_ transformation_replace_branch_from_dead_block_with_exit.cpp000066400000000000000000000154061475742701700347760ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/fuzz// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_replace_branch_from_dead_block_with_exit.h" #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { TransformationReplaceBranchFromDeadBlockWithExit:: TransformationReplaceBranchFromDeadBlockWithExit( protobufs::TransformationReplaceBranchFromDeadBlockWithExit message) : message_(std::move(message)) {} TransformationReplaceBranchFromDeadBlockWithExit:: TransformationReplaceBranchFromDeadBlockWithExit(uint32_t block_id, spv::Op opcode, uint32_t return_value_id) { message_.set_block_id(block_id); message_.set_opcode(uint32_t(opcode)); message_.set_return_value_id(return_value_id); } bool TransformationReplaceBranchFromDeadBlockWithExit::IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const { // The block whose terminator is to be changed must exist. auto block = ir_context->get_instr_block(message_.block_id()); if (!block) { return false; } if (!BlockIsSuitable(ir_context, transformation_context, *block)) { return false; } auto function_return_type_id = block->GetParent()->type_id(); switch (spv::Op(message_.opcode())) { case spv::Op::OpKill: for (auto& entry_point : ir_context->module()->entry_points()) { if (spv::ExecutionModel(entry_point.GetSingleWordInOperand(0)) != spv::ExecutionModel::Fragment) { // OpKill is only allowed in a fragment shader. This is a // conservative check: if the module contains a non-fragment entry // point then adding an OpKill might lead to OpKill being used in a // non-fragment shader. return false; } } break; case spv::Op::OpReturn: if (ir_context->get_def_use_mgr() ->GetDef(function_return_type_id) ->opcode() != spv::Op::OpTypeVoid) { // OpReturn is only allowed in a function with void return type. return false; } break; case spv::Op::OpReturnValue: { // If the terminator is to be changed to OpReturnValue, with // |message_.return_value_id| being the value that will be returned, then // |message_.return_value_id| must have a compatible type and be available // at the block terminator. auto return_value = ir_context->get_def_use_mgr()->GetDef(message_.return_value_id()); if (!return_value || return_value->type_id() != function_return_type_id) { return false; } if (!fuzzerutil::IdIsAvailableBeforeInstruction( ir_context, block->terminator(), message_.return_value_id())) { return false; } break; } default: assert(spv::Op(message_.opcode()) == spv::Op::OpUnreachable && "Invalid early exit opcode."); break; } return true; } void TransformationReplaceBranchFromDeadBlockWithExit::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { // If the successor block has OpPhi instructions then arguments related to // |message_.block_id| need to be removed from these instruction. auto block = ir_context->get_instr_block(message_.block_id()); assert(block->terminator()->opcode() == spv::Op::OpBranch && "Precondition: the block must end with OpBranch."); auto successor = ir_context->get_instr_block( block->terminator()->GetSingleWordInOperand(0)); successor->ForEachPhiInst([block](opt::Instruction* phi_inst) { opt::Instruction::OperandList new_phi_in_operands; for (uint32_t i = 0; i < phi_inst->NumInOperands(); i += 2) { if (phi_inst->GetSingleWordInOperand(i + 1) == block->id()) { continue; } new_phi_in_operands.emplace_back(phi_inst->GetInOperand(i)); new_phi_in_operands.emplace_back(phi_inst->GetInOperand(i + 1)); } assert(new_phi_in_operands.size() == phi_inst->NumInOperands() - 2); phi_inst->SetInOperands(std::move(new_phi_in_operands)); }); // Rewrite the terminator of |message_.block_id|. opt::Instruction::OperandList new_terminator_in_operands; if (spv::Op(message_.opcode()) == spv::Op::OpReturnValue) { new_terminator_in_operands.push_back( {SPV_OPERAND_TYPE_ID, {message_.return_value_id()}}); } auto terminator = block->terminator(); terminator->SetOpcode(static_cast(message_.opcode())); terminator->SetInOperands(std::move(new_terminator_in_operands)); ir_context->InvalidateAnalysesExceptFor(opt::IRContext::kAnalysisNone); } std::unordered_set TransformationReplaceBranchFromDeadBlockWithExit::GetFreshIds() const { return std::unordered_set(); } protobufs::Transformation TransformationReplaceBranchFromDeadBlockWithExit::ToMessage() const { protobufs::Transformation result; *result.mutable_replace_branch_from_dead_block_with_exit() = message_; return result; } bool TransformationReplaceBranchFromDeadBlockWithExit::BlockIsSuitable( opt::IRContext* ir_context, const TransformationContext& transformation_context, const opt::BasicBlock& block) { // The block must be dead. if (!transformation_context.GetFactManager()->BlockIsDead(block.id())) { return false; } // The block's terminator must be OpBranch. if (block.terminator()->opcode() != spv::Op::OpBranch) { return false; } if (ir_context->GetStructuredCFGAnalysis()->IsInContinueConstruct( block.id())) { // Early exits from continue constructs are not allowed as they would break // the SPIR-V structured control flow rules. return false; } // We only allow changing OpBranch to an early terminator if the target of the // OpBranch has at least one other predecessor. auto successor = ir_context->get_instr_block( block.terminator()->GetSingleWordInOperand(0)); if (ir_context->cfg()->preds(successor->id()).size() < 2) { return false; } // Make sure that domination rules are satisfied when we remove the branch // from the |block| to its |successor|. return fuzzerutil::NewTerminatorPreservesDominationRules( ir_context, block.id(), {ir_context, spv::Op::OpUnreachable}); } } // namespace fuzz } // namespace spvtools transformation_replace_branch_from_dead_block_with_exit.h000066400000000000000000000073211475742701700344400ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/fuzz// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_REPLACE_BRANCH_FROM_DEAD_BLOCK_WITH_EXIT_H_ #define SOURCE_FUZZ_TRANSFORMATION_REPLACE_BRANCH_FROM_DEAD_BLOCK_WITH_EXIT_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/basic_block.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationReplaceBranchFromDeadBlockWithExit : public Transformation { public: explicit TransformationReplaceBranchFromDeadBlockWithExit( protobufs::TransformationReplaceBranchFromDeadBlockWithExit message); TransformationReplaceBranchFromDeadBlockWithExit(uint32_t block_id, spv::Op opcode, uint32_t return_value_id); // - |message_.block_id| must be the id of a dead block that is not part of // a continue construct // - |message_.block_id| must end with OpBranch // - The successor of |message_.block_id| must have at least one other // predecessor // - |message_.opcode()| must be one of OpKill, OpReturn, OpReturnValue and // OpUnreachable // - |message_.opcode()| can only be OpKill if the module's entry points all // have Fragment execution mode // - |message_.opcode()| can only be OpReturn if the return type of the // function containing the block is void // - If |message_.opcode()| is OpReturnValue then |message_.return_value_id| // must be an id that is available at the block terminator and that matches // the return type of the enclosing function // - Domination rules should be preserved when we apply this transformation. // In particular, if some block appears after the |block_id|'s successor in // the CFG, then that block cannot dominate |block_id|'s successor when this // transformation is applied. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Changes the terminator of |message_.block_id| to have opcode // |message_.opcode|, additionally with input operand // |message_.return_value_id| in the case that |message_.opcode| is // OpReturnValue. // // If |message_.block_id|'s successor starts with OpPhi instructions these are // updated so that they no longer refer to |message_.block_id|. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; // Returns true if and only if |block| meets the criteria for having its // terminator replaced with an early exit (see IsApplicable for details of the // criteria.) static bool BlockIsSuitable( opt::IRContext* ir_context, const TransformationContext& transformation_context, const opt::BasicBlock& block); private: protobufs::TransformationReplaceBranchFromDeadBlockWithExit message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_REPLACE_BRANCH_FROM_DEAD_BLOCK_WITH_EXIT_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_replace_constant_with_uniform.cpp000066400000000000000000000315651475742701700330110ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_replace_constant_with_uniform.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/uniform_buffer_element_descriptor.h" namespace spvtools { namespace fuzz { TransformationReplaceConstantWithUniform:: TransformationReplaceConstantWithUniform( protobufs::TransformationReplaceConstantWithUniform message) : message_(std::move(message)) {} TransformationReplaceConstantWithUniform:: TransformationReplaceConstantWithUniform( protobufs::IdUseDescriptor id_use, protobufs::UniformBufferElementDescriptor uniform_descriptor, uint32_t fresh_id_for_access_chain, uint32_t fresh_id_for_load) { *message_.mutable_id_use_descriptor() = std::move(id_use); *message_.mutable_uniform_descriptor() = std::move(uniform_descriptor); message_.set_fresh_id_for_access_chain(fresh_id_for_access_chain); message_.set_fresh_id_for_load(fresh_id_for_load); } std::unique_ptr TransformationReplaceConstantWithUniform::MakeAccessChainInstruction( spvtools::opt::IRContext* ir_context, uint32_t constant_type_id) const { // The input operands for the access chain. opt::Instruction::OperandList operands_for_access_chain; opt::Instruction* uniform_variable = FindUniformVariable(message_.uniform_descriptor(), ir_context, false); // The first input operand is the id of the uniform variable. operands_for_access_chain.push_back( {SPV_OPERAND_TYPE_ID, {uniform_variable->result_id()}}); // The other input operands are the ids of the constants used to index into // the uniform. The uniform buffer descriptor specifies a series of literals; // for each we find the id of the instruction that defines it, and add these // instruction ids as operands. opt::analysis::Integer int_type(32, true); auto registered_int_type = ir_context->get_type_mgr()->GetRegisteredType(&int_type)->AsInteger(); auto int_type_id = ir_context->get_type_mgr()->GetId(&int_type); for (auto index : message_.uniform_descriptor().index()) { opt::analysis::IntConstant int_constant(registered_int_type, {index}); auto constant_id = ir_context->get_constant_mgr()->FindDeclaredConstant( &int_constant, int_type_id); operands_for_access_chain.push_back({SPV_OPERAND_TYPE_ID, {constant_id}}); } // The type id for the access chain is a uniform pointer with base type // matching the given constant id type. auto type_and_pointer_type = ir_context->get_type_mgr()->GetTypeAndPointerType( constant_type_id, spv::StorageClass::Uniform); assert(type_and_pointer_type.first != nullptr); assert(type_and_pointer_type.second != nullptr); auto pointer_to_uniform_constant_type_id = ir_context->get_type_mgr()->GetId(type_and_pointer_type.second.get()); return MakeUnique( ir_context, spv::Op::OpAccessChain, pointer_to_uniform_constant_type_id, message_.fresh_id_for_access_chain(), operands_for_access_chain); } std::unique_ptr TransformationReplaceConstantWithUniform::MakeLoadInstruction( spvtools::opt::IRContext* ir_context, uint32_t constant_type_id) const { opt::Instruction::OperandList operands_for_load = { {SPV_OPERAND_TYPE_ID, {message_.fresh_id_for_access_chain()}}}; return MakeUnique( ir_context, spv::Op::OpLoad, constant_type_id, message_.fresh_id_for_load(), operands_for_load); } opt::Instruction* TransformationReplaceConstantWithUniform::GetInsertBeforeInstruction( opt::IRContext* ir_context) const { auto* result = FindInstructionContainingUse(message_.id_use_descriptor(), ir_context); if (!result) { return nullptr; } // The use might be in an OpPhi instruction. if (result->opcode() == spv::Op::OpPhi) { // OpPhi instructions must be the first instructions in a block. Thus, we // can't insert above the OpPhi instruction. Given the predecessor block // that corresponds to the id use, get the last instruction in that block // above which we can insert OpAccessChain and OpLoad. return fuzzerutil::GetLastInsertBeforeInstruction( ir_context, result->GetSingleWordInOperand( message_.id_use_descriptor().in_operand_index() + 1), spv::Op::OpLoad); } // The only operand that we could've replaced in the OpBranchConditional is // the condition id. But that operand has a boolean type and uniform variables // can't store booleans (see the spec on OpTypeBool). Thus, |result| can't be // an OpBranchConditional. assert(result->opcode() != spv::Op::OpBranchConditional && "OpBranchConditional has no operands to replace"); assert( fuzzerutil::CanInsertOpcodeBeforeInstruction(spv::Op::OpLoad, result) && "We should be able to insert OpLoad and OpAccessChain at this point"); return result; } bool TransformationReplaceConstantWithUniform::IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const { // The following is really an invariant of the transformation rather than // merely a requirement of the precondition. We check it here since we cannot // check it in the message_ constructor. assert(message_.fresh_id_for_access_chain() != message_.fresh_id_for_load() && "Fresh ids for access chain and load result cannot be the same."); // The ids for the access chain and load instructions must both be fresh. if (!fuzzerutil::IsFreshId(ir_context, message_.fresh_id_for_access_chain())) { return false; } if (!fuzzerutil::IsFreshId(ir_context, message_.fresh_id_for_load())) { return false; } // The id specified in the id use descriptor must be that of a declared scalar // constant. auto declared_constant = ir_context->get_constant_mgr()->FindDeclaredConstant( message_.id_use_descriptor().id_of_interest()); if (!declared_constant) { return false; } if (!declared_constant->AsScalarConstant()) { return false; } // The fact manager needs to believe that the uniform data element described // by the uniform buffer element descriptor will hold a scalar value. auto constant_id_associated_with_uniform = transformation_context.GetFactManager()->GetConstantFromUniformDescriptor( message_.uniform_descriptor()); if (!constant_id_associated_with_uniform) { return false; } auto constant_associated_with_uniform = ir_context->get_constant_mgr()->FindDeclaredConstant( constant_id_associated_with_uniform); assert(constant_associated_with_uniform && "The constant should be present in the module."); if (!constant_associated_with_uniform->AsScalarConstant()) { return false; } // The types and values of the scalar value held in the id specified by the id // use descriptor and in the uniform data element specified by the uniform // buffer element descriptor need to match on both type and value. if (!declared_constant->type()->IsSame( constant_associated_with_uniform->type())) { return false; } if (declared_constant->AsScalarConstant()->words() != constant_associated_with_uniform->AsScalarConstant()->words()) { return false; } // The id use descriptor must identify some instruction with respect to the // module. auto instruction_using_constant = FindInstructionContainingUse(message_.id_use_descriptor(), ir_context); if (!instruction_using_constant) { return false; } // The use must not be a variable initializer; these are required to be // constants, so it would be illegal to replace one with a uniform access. if (instruction_using_constant->opcode() == spv::Op::OpVariable) { return false; } // The module needs to have a uniform pointer type suitable for indexing into // the uniform variable, i.e. matching the type of the constant we wish to // replace with a uniform. opt::analysis::Pointer pointer_to_type_of_constant( declared_constant->type(), spv::StorageClass::Uniform); if (!ir_context->get_type_mgr()->GetId(&pointer_to_type_of_constant)) { return false; } // In order to index into the uniform, the module has got to contain the int32 // type, plus an OpConstant for each of the indices of interest. opt::analysis::Integer int_type(32, true); if (!ir_context->get_type_mgr()->GetId(&int_type)) { return false; } auto registered_int_type = ir_context->get_type_mgr()->GetRegisteredType(&int_type)->AsInteger(); auto int_type_id = ir_context->get_type_mgr()->GetId(&int_type); for (auto index : message_.uniform_descriptor().index()) { opt::analysis::IntConstant int_constant(registered_int_type, {index}); if (!ir_context->get_constant_mgr()->FindDeclaredConstant(&int_constant, int_type_id)) { return false; } } // Once all checks are completed, we should be able to safely insert // OpAccessChain and OpLoad into the module. assert(GetInsertBeforeInstruction(ir_context) && "There must exist an instruction that we can use to insert " "OpAccessChain and OpLoad above"); return true; } void TransformationReplaceConstantWithUniform::Apply( spvtools::opt::IRContext* ir_context, TransformationContext* /*unused*/) const { // Get the instruction that contains the id use we wish to replace. auto* instruction_containing_constant_use = FindInstructionContainingUse(message_.id_use_descriptor(), ir_context); assert(instruction_containing_constant_use && "Precondition requires that the id use can be found."); assert(instruction_containing_constant_use->GetSingleWordInOperand( message_.id_use_descriptor().in_operand_index()) == message_.id_use_descriptor().id_of_interest() && "Does not appear to be a usage of the desired id."); // The id of the type for the constant whose use we wish to replace. auto constant_type_id = ir_context->get_def_use_mgr() ->GetDef(message_.id_use_descriptor().id_of_interest()) ->type_id(); // Get an instruction that will be used to insert OpAccessChain and OpLoad. auto* insert_before_inst = GetInsertBeforeInstruction(ir_context); assert(insert_before_inst && "There must exist an insertion point for OpAccessChain and OpLoad"); opt::BasicBlock* enclosing_block = ir_context->get_instr_block(insert_before_inst); // Add an access chain instruction to target the uniform element. auto access_chain_instruction = MakeAccessChainInstruction(ir_context, constant_type_id); auto access_chain_instruction_ptr = access_chain_instruction.get(); insert_before_inst->InsertBefore(std::move(access_chain_instruction)); ir_context->get_def_use_mgr()->AnalyzeInstDefUse( access_chain_instruction_ptr); ir_context->set_instr_block(access_chain_instruction_ptr, enclosing_block); // Add a load from this access chain. auto load_instruction = MakeLoadInstruction(ir_context, constant_type_id); auto load_instruction_ptr = load_instruction.get(); insert_before_inst->InsertBefore(std::move(load_instruction)); ir_context->get_def_use_mgr()->AnalyzeInstDefUse(load_instruction_ptr); ir_context->set_instr_block(load_instruction_ptr, enclosing_block); // Adjust the instruction containing the usage of the constant so that this // usage refers instead to the result of the load. instruction_containing_constant_use->SetInOperand( message_.id_use_descriptor().in_operand_index(), {message_.fresh_id_for_load()}); ir_context->get_def_use_mgr()->EraseUseRecordsOfOperandIds( instruction_containing_constant_use); ir_context->get_def_use_mgr()->AnalyzeInstUse( instruction_containing_constant_use); // Update the module id bound to reflect the new instructions. fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id_for_load()); fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id_for_access_chain()); } protobufs::Transformation TransformationReplaceConstantWithUniform::ToMessage() const { protobufs::Transformation result; *result.mutable_replace_constant_with_uniform() = message_; return result; } std::unordered_set TransformationReplaceConstantWithUniform::GetFreshIds() const { return {message_.fresh_id_for_access_chain(), message_.fresh_id_for_load()}; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_replace_constant_with_uniform.h000066400000000000000000000104121475742701700324420ustar00rootroot00000000000000#include // Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_REPLACE_CONSTANT_WITH_UNIFORM_H_ #define SOURCE_FUZZ_TRANSFORMATION_REPLACE_CONSTANT_WITH_UNIFORM_H_ #include "source/fuzz/id_use_descriptor.h" #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationReplaceConstantWithUniform : public Transformation { public: explicit TransformationReplaceConstantWithUniform( protobufs::TransformationReplaceConstantWithUniform message); TransformationReplaceConstantWithUniform( protobufs::IdUseDescriptor id_use, protobufs::UniformBufferElementDescriptor uniform_descriptor, uint32_t fresh_id_for_access_chain, uint32_t fresh_id_for_load); // - |message_.fresh_id_for_access_chain| and |message_.fresh_id_for_load| // must be distinct fresh ids. // - |message_.uniform_descriptor| specifies a result id and a list of integer // literal indices. // As an example, suppose |message_.uniform_descriptor| is (18, [0, 1, 0]) // It is required that: // - the result id (18 in our example) is the id of some uniform variable // - the module contains an integer constant instruction corresponding to // each of the literal indices; in our example there must thus be // OpConstant instructions %A and %B say for each of 0 and 1 // - it is legitimate to index into the uniform variable using the // sequence of indices; in our example this means indexing into %18 // using the sequence %A %B %A // - the module contains a uniform pointer type corresponding to the type // of the uniform data element obtained by following these indices // - |message_.id_use_descriptor| identifies the use of some id %C. It is // required that: // - this use does indeed exist in the module // - %C is an OpConstant // - According to the fact manager, the uniform data element specified by // |message_.uniform_descriptor| holds a value with the same type and // value as %C bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // - Introduces two new instructions: // - An access chain targeting the uniform data element specified by // |message_.uniform_descriptor|, with result id // |message_.fresh_id_for_access_chain| // - A load from this access chain, with id |message_.fresh_id_for_load| // - Replaces the id use specified by |message_.id_use_descriptor| with // |message_.fresh_id_for_load| void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: // Helper method to create an access chain for the uniform element associated // with the transformation. std::unique_ptr MakeAccessChainInstruction( spvtools::opt::IRContext* ir_context, uint32_t constant_type_id) const; // Helper to create a load instruction. std::unique_ptr MakeLoadInstruction( spvtools::opt::IRContext* ir_context, uint32_t constant_type_id) const; // OpAccessChain and OpLoad will be inserted above the instruction returned // by this function. Returns nullptr if no such instruction is present. opt::Instruction* GetInsertBeforeInstruction( opt::IRContext* ir_context) const; protobufs::TransformationReplaceConstantWithUniform message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_REPLACE_CONSTANT_WITH_UNIFORM_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_replace_copy_memory_with_load_store.cpp000066400000000000000000000122301475742701700341620ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_replace_copy_memory_with_load_store.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" namespace spvtools { namespace fuzz { TransformationReplaceCopyMemoryWithLoadStore:: TransformationReplaceCopyMemoryWithLoadStore( protobufs::TransformationReplaceCopyMemoryWithLoadStore message) : message_(std::move(message)) {} TransformationReplaceCopyMemoryWithLoadStore:: TransformationReplaceCopyMemoryWithLoadStore( uint32_t fresh_id, const protobufs::InstructionDescriptor& copy_memory_instruction_descriptor) { message_.set_fresh_id(fresh_id); *message_.mutable_copy_memory_instruction_descriptor() = copy_memory_instruction_descriptor; } bool TransformationReplaceCopyMemoryWithLoadStore::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { // |message_.fresh_id| must be fresh. if (!fuzzerutil::IsFreshId(ir_context, message_.fresh_id())) { return false; } // The instruction to be replaced must be defined and have opcode // OpCopyMemory. auto copy_memory_instruction = FindInstruction( message_.copy_memory_instruction_descriptor(), ir_context); if (!copy_memory_instruction || copy_memory_instruction->opcode() != spv::Op::OpCopyMemory) { return false; } return true; } void TransformationReplaceCopyMemoryWithLoadStore::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { auto copy_memory_instruction = FindInstruction( message_.copy_memory_instruction_descriptor(), ir_context); // |copy_memory_instruction| must be defined. assert(copy_memory_instruction && copy_memory_instruction->opcode() == spv::Op::OpCopyMemory && "The required OpCopyMemory instruction must be defined."); // Integrity check: Both operands must be pointers. // Get types of ids used as a source and target of |copy_memory_instruction|. auto target = ir_context->get_def_use_mgr()->GetDef( copy_memory_instruction->GetSingleWordInOperand(0)); auto source = ir_context->get_def_use_mgr()->GetDef( copy_memory_instruction->GetSingleWordInOperand(1)); auto target_type_opcode = ir_context->get_def_use_mgr()->GetDef(target->type_id())->opcode(); auto source_type_opcode = ir_context->get_def_use_mgr()->GetDef(source->type_id())->opcode(); // Keep release-mode compilers happy. (No unused variables.) (void)target; (void)source; (void)target_type_opcode; (void)source_type_opcode; assert(target_type_opcode == spv::Op::OpTypePointer && source_type_opcode == spv::Op::OpTypePointer && "Operands must be of type OpTypePointer"); // Integrity check: |source| and |target| must point to the same type. uint32_t target_pointee_type = fuzzerutil::GetPointeeTypeIdFromPointerType( ir_context, target->type_id()); uint32_t source_pointee_type = fuzzerutil::GetPointeeTypeIdFromPointerType( ir_context, source->type_id()); // Keep release-mode compilers happy. (No unused variables.) (void)target_pointee_type; (void)source_pointee_type; assert(target_pointee_type == source_pointee_type && "Operands must have the same type to which they point to."); // First, insert the OpStore instruction before the OpCopyMemory instruction // and then insert the OpLoad instruction before the OpStore instruction. fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id()); FindInstruction(message_.copy_memory_instruction_descriptor(), ir_context) ->InsertBefore(MakeUnique( ir_context, spv::Op::OpStore, 0, 0, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {target->result_id()}}, {SPV_OPERAND_TYPE_ID, {message_.fresh_id()}}}))) ->InsertBefore(MakeUnique( ir_context, spv::Op::OpLoad, target_pointee_type, message_.fresh_id(), opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {source->result_id()}}}))); // Remove the OpCopyMemory instruction. ir_context->KillInst(copy_memory_instruction); ir_context->InvalidateAnalysesExceptFor(opt::IRContext::kAnalysisNone); } protobufs::Transformation TransformationReplaceCopyMemoryWithLoadStore::ToMessage() const { protobufs::Transformation result; *result.mutable_replace_copy_memory_with_load_store() = message_; return result; } std::unordered_set TransformationReplaceCopyMemoryWithLoadStore::GetFreshIds() const { return {message_.fresh_id()}; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_replace_copy_memory_with_load_store.h000066400000000000000000000043371475742701700336400ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_REPLACE_COPY_MEMORY_WITH_LOAD_STORE_H_ #define SOURCE_FUZZ_TRANSFORMATION_REPLACE_COPY_MEMORY_WITH_LOAD_STORE_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationReplaceCopyMemoryWithLoadStore : public Transformation { public: explicit TransformationReplaceCopyMemoryWithLoadStore( protobufs::TransformationReplaceCopyMemoryWithLoadStore message); TransformationReplaceCopyMemoryWithLoadStore( uint32_t fresh_id, const protobufs::InstructionDescriptor& copy_memory_instruction_descriptor); // - |message_.fresh_id| must be fresh. // - |message_.copy_memory_instruction_descriptor| must refer to an // OpCopyMemory instruction. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Replaces instruction OpCopyMemory with loading the source variable to an // intermediate value and storing this value into the target variable of the // original OpCopyMemory instruction. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationReplaceCopyMemoryWithLoadStore message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_REPLACE_COPY_MEMORY_WITH_LOAD_STORE_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_replace_copy_object_with_store_load.cpp000066400000000000000000000165061475742701700341320ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_replace_copy_object_with_store_load.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" namespace spvtools { namespace fuzz { TransformationReplaceCopyObjectWithStoreLoad:: TransformationReplaceCopyObjectWithStoreLoad( protobufs::TransformationReplaceCopyObjectWithStoreLoad message) : message_(std::move(message)) {} TransformationReplaceCopyObjectWithStoreLoad:: TransformationReplaceCopyObjectWithStoreLoad( uint32_t copy_object_result_id, uint32_t fresh_variable_id, uint32_t variable_storage_class, uint32_t variable_initializer_id) { message_.set_copy_object_result_id(copy_object_result_id); message_.set_fresh_variable_id(fresh_variable_id); message_.set_variable_storage_class(variable_storage_class); message_.set_variable_initializer_id(variable_initializer_id); } bool TransformationReplaceCopyObjectWithStoreLoad::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { // |message_.fresh_variable_id| must be fresh. if (!fuzzerutil::IsFreshId(ir_context, message_.fresh_variable_id())) { return false; } auto copy_object_instruction = ir_context->get_def_use_mgr()->GetDef(message_.copy_object_result_id()); // This must be a defined OpCopyObject instruction. if (!copy_object_instruction || copy_object_instruction->opcode() != spv::Op::OpCopyObject) { return false; } // The opcode of the type_id instruction cannot be a OpTypePointer, // because we cannot define a pointer to pointer. if (ir_context->get_def_use_mgr() ->GetDef(copy_object_instruction->type_id()) ->opcode() == spv::Op::OpTypePointer) { return false; } // A pointer type instruction pointing to the value type must be defined. auto pointer_type_id = fuzzerutil::MaybeGetPointerType( ir_context, copy_object_instruction->type_id(), static_cast(message_.variable_storage_class())); if (!pointer_type_id) { return false; } // Check that initializer is valid. const auto* constant_inst = ir_context->get_def_use_mgr()->GetDef(message_.variable_initializer_id()); if (!constant_inst || !spvOpcodeIsConstant(constant_inst->opcode()) || copy_object_instruction->type_id() != constant_inst->type_id()) { return false; } // |message_.variable_storage_class| must be Private or Function. return spv::StorageClass(message_.variable_storage_class()) == spv::StorageClass::Private || spv::StorageClass(message_.variable_storage_class()) == spv::StorageClass::Function; } void TransformationReplaceCopyObjectWithStoreLoad::Apply( opt::IRContext* ir_context, TransformationContext* transformation_context) const { auto copy_object_instruction = ir_context->get_def_use_mgr()->GetDef(message_.copy_object_result_id()); // |copy_object_instruction| must be defined. assert(copy_object_instruction && copy_object_instruction->opcode() == spv::Op::OpCopyObject && "The required OpCopyObject instruction must be defined."); opt::BasicBlock* enclosing_block = ir_context->get_instr_block(copy_object_instruction); // Get id used as a source by the OpCopyObject instruction. uint32_t src_operand = copy_object_instruction->GetSingleWordInOperand(0); // A pointer type instruction pointing to the value type must be defined. auto pointer_type_id = fuzzerutil::MaybeGetPointerType( ir_context, copy_object_instruction->type_id(), static_cast(message_.variable_storage_class())); assert(pointer_type_id && "The required pointer type must be available."); // Adds a global or local variable (according to the storage class). if (spv::StorageClass(message_.variable_storage_class()) == spv::StorageClass::Private) { opt::Instruction* new_global = fuzzerutil::AddGlobalVariable( ir_context, message_.fresh_variable_id(), pointer_type_id, spv::StorageClass::Private, message_.variable_initializer_id()); ir_context->get_def_use_mgr()->AnalyzeInstDefUse(new_global); } else { opt::Function* function = ir_context->get_instr_block(copy_object_instruction)->GetParent(); opt::Instruction* new_local = fuzzerutil::AddLocalVariable( ir_context, message_.fresh_variable_id(), pointer_type_id, function->result_id(), message_.variable_initializer_id()); ir_context->get_def_use_mgr()->AnalyzeInstDefUse(new_local); ir_context->set_instr_block(new_local, &*function->begin()); } // First, insert the OpLoad instruction before the OpCopyObject instruction // and then insert the OpStore instruction before the OpLoad instruction. fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_variable_id()); opt::Instruction* load_instruction = copy_object_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpLoad, copy_object_instruction->type_id(), message_.copy_object_result_id(), opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {message_.fresh_variable_id()}}}))); opt::Instruction* store_instruction = load_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpStore, 0, 0, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {message_.fresh_variable_id()}}, {SPV_OPERAND_TYPE_ID, {src_operand}}}))); // Register the new instructions with the def-use manager, and record their // enclosing block. ir_context->get_def_use_mgr()->AnalyzeInstDefUse(store_instruction); ir_context->get_def_use_mgr()->AnalyzeInstDefUse(load_instruction); ir_context->set_instr_block(store_instruction, enclosing_block); ir_context->set_instr_block(load_instruction, enclosing_block); // Remove the CopyObject instruction. ir_context->KillInst(copy_object_instruction); if (!transformation_context->GetFactManager()->IdIsIrrelevant( message_.copy_object_result_id()) && !transformation_context->GetFactManager()->IdIsIrrelevant(src_operand)) { // Adds the fact that |message_.copy_object_result_id| // and src_operand (id used by OpCopyObject) are synonymous. transformation_context->GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(message_.copy_object_result_id(), {}), MakeDataDescriptor(src_operand, {})); } } protobufs::Transformation TransformationReplaceCopyObjectWithStoreLoad::ToMessage() const { protobufs::Transformation result; *result.mutable_replace_copy_object_with_store_load() = message_; return result; } std::unordered_set TransformationReplaceCopyObjectWithStoreLoad::GetFreshIds() const { return {message_.fresh_variable_id()}; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_replace_copy_object_with_store_load.h000066400000000000000000000050541475742701700335730ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_REPLACE_COPY_OBJECT_WITH_STORE_LOAD_H_ #define SOURCE_FUZZ_TRANSFORMATION_REPLACE_COPY_OBJECT_WITH_STORE_LOAD_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationReplaceCopyObjectWithStoreLoad : public Transformation { public: explicit TransformationReplaceCopyObjectWithStoreLoad( protobufs::TransformationReplaceCopyObjectWithStoreLoad message); TransformationReplaceCopyObjectWithStoreLoad( uint32_t copy_object_result_id, uint32_t fresh_variable_id, uint32_t variable_storage_class, uint32_t variable_initializer_id); // - |message_.copy_object_result_id| must be a result id of an OpCopyObject // instruction. // - |message_.fresh_variable_id| must be a fresh id given to variable used by // OpStore. // - |message_.variable_storage_class| must be either StorageClassPrivate or // StorageClassFunction. // - |message_.initializer_id| must be a result id of some constant in the // module. Its type must be equal to the pointee type of the variable that // will be created. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Replaces instruction OpCopyObject with storing into a new variable and // immediately loading from this variable to |result_id| of the original // OpCopyObject instruction. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationReplaceCopyObjectWithStoreLoad message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_REPLACE_COPY_OBJECT_WITH_STORE_LOAD_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_replace_id_with_synonym.cpp000066400000000000000000000104731475742701700316040ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_replace_id_with_synonym.h" #include #include "source/fuzz/data_descriptor.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/id_use_descriptor.h" #include "source/opt/types.h" #include "source/util/make_unique.h" namespace spvtools { namespace fuzz { TransformationReplaceIdWithSynonym::TransformationReplaceIdWithSynonym( protobufs::TransformationReplaceIdWithSynonym message) : message_(std::move(message)) {} TransformationReplaceIdWithSynonym::TransformationReplaceIdWithSynonym( protobufs::IdUseDescriptor id_use_descriptor, uint32_t synonymous_id) { *message_.mutable_id_use_descriptor() = std::move(id_use_descriptor); message_.set_synonymous_id(synonymous_id); } bool TransformationReplaceIdWithSynonym::IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const { auto id_of_interest = message_.id_use_descriptor().id_of_interest(); // Does the fact manager know about the synonym? auto data_descriptor_for_synonymous_id = MakeDataDescriptor(message_.synonymous_id(), {}); if (!transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(id_of_interest, {}), data_descriptor_for_synonymous_id)) { return false; } // Does the id use descriptor in the transformation identify an instruction? auto use_instruction = FindInstructionContainingUse(message_.id_use_descriptor(), ir_context); if (!use_instruction) { return false; } uint32_t type_id_of_interest = ir_context->get_def_use_mgr()->GetDef(id_of_interest)->type_id(); uint32_t type_id_synonym = ir_context->get_def_use_mgr() ->GetDef(message_.synonymous_id()) ->type_id(); // If the id of interest and the synonym are scalar or vector integer // constants with different signedness, their use can only be swapped if the // instruction is agnostic to the signedness of the operand. if (!fuzzerutil::TypesAreCompatible( ir_context, use_instruction->opcode(), message_.id_use_descriptor().in_operand_index(), type_id_of_interest, type_id_synonym)) { return false; } // Is the use suitable for being replaced in principle? if (!fuzzerutil::IdUseCanBeReplaced( ir_context, transformation_context, use_instruction, message_.id_use_descriptor().in_operand_index())) { return false; } // The transformation is applicable if the synonymous id is available at the // use point. return fuzzerutil::IdIsAvailableAtUse( ir_context, use_instruction, message_.id_use_descriptor().in_operand_index(), message_.synonymous_id()); } void TransformationReplaceIdWithSynonym::Apply( spvtools::opt::IRContext* ir_context, TransformationContext* /*unused*/) const { auto instruction_to_change = FindInstructionContainingUse(message_.id_use_descriptor(), ir_context); instruction_to_change->SetInOperand( message_.id_use_descriptor().in_operand_index(), {message_.synonymous_id()}); ir_context->get_def_use_mgr()->EraseUseRecordsOfOperandIds( instruction_to_change); ir_context->get_def_use_mgr()->AnalyzeInstUse(instruction_to_change); // No analyses need to be invalidated, since the transformation is local to a // block, and the def-use analysis has been updated. } protobufs::Transformation TransformationReplaceIdWithSynonym::ToMessage() const { protobufs::Transformation result; *result.mutable_replace_id_with_synonym() = message_; return result; } std::unordered_set TransformationReplaceIdWithSynonym::GetFreshIds() const { return std::unordered_set(); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_replace_id_with_synonym.h000066400000000000000000000045241475742701700312510ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_REPLACE_ID_WITH_SYNONYM_H_ #define SOURCE_FUZZ_TRANSFORMATION_REPLACE_ID_WITH_SYNONYM_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationReplaceIdWithSynonym : public Transformation { public: explicit TransformationReplaceIdWithSynonym( protobufs::TransformationReplaceIdWithSynonym message); TransformationReplaceIdWithSynonym( protobufs::IdUseDescriptor id_use_descriptor, uint32_t synonymous_id); // - The fact manager must know that the id identified by // |message_.id_use_descriptor| is synonymous with |message_.synonymous_id|. // - Replacing the id in |message_.id_use_descriptor| by // |message_.synonymous_id| must respect SPIR-V's rules about uses being // dominated by their definitions. // - The id use must be replaceable in principle. See // fuzzerutil::IdUseCanBeReplaced for details. // - |fresh_id_for_temporary| must be 0. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Replaces the use identified by |message_.id_use_descriptor| with the // synonymous id identified by |message_.synonymous_id|. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationReplaceIdWithSynonym message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_REPLACE_ID_WITH_SYNONYM_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_replace_irrelevant_id.cpp000066400000000000000000000113571475742701700312120ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_replace_irrelevant_id.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/id_use_descriptor.h" namespace spvtools { namespace fuzz { TransformationReplaceIrrelevantId::TransformationReplaceIrrelevantId( protobufs::TransformationReplaceIrrelevantId message) : message_(std::move(message)) {} TransformationReplaceIrrelevantId::TransformationReplaceIrrelevantId( const protobufs::IdUseDescriptor& id_use_descriptor, uint32_t replacement_id) { *message_.mutable_id_use_descriptor() = id_use_descriptor; message_.set_replacement_id(replacement_id); } bool TransformationReplaceIrrelevantId::IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const { auto id_of_interest = message_.id_use_descriptor().id_of_interest(); // The id must be irrelevant. if (!transformation_context.GetFactManager()->IdIsIrrelevant( id_of_interest)) { return false; } // Find the instruction containing the id use, which must exist. auto use_instruction = FindInstructionContainingUse(message_.id_use_descriptor(), ir_context); if (!use_instruction) { return false; } // Check that the replacement id exists and retrieve its definition. auto replacement_id_def = ir_context->get_def_use_mgr()->GetDef(message_.replacement_id()); if (!replacement_id_def) { return false; } // The type of the id of interest and of the replacement id must be the same. uint32_t type_id_of_interest = ir_context->get_def_use_mgr()->GetDef(id_of_interest)->type_id(); uint32_t type_replacement_id = replacement_id_def->type_id(); if (type_id_of_interest != type_replacement_id) { return false; } // The replacement id must not be the result of an OpFunction instruction. if (replacement_id_def->opcode() == spv::Op::OpFunction) { return false; } // Consistency check: an irrelevant id cannot be a pointer. assert( !ir_context->get_type_mgr()->GetType(type_id_of_interest)->AsPointer() && "An irrelevant id cannot be a pointer"); uint32_t use_in_operand_index = message_.id_use_descriptor().in_operand_index(); // The id use must be replaceable with any other id of the same type. if (!fuzzerutil::IdUseCanBeReplaced(ir_context, transformation_context, use_instruction, use_in_operand_index)) { return false; } if (AttemptsToReplaceVariableInitializerWithNonConstant( *use_instruction, *replacement_id_def)) { return false; } // The id must be available to use at the use point. return fuzzerutil::IdIsAvailableAtUse( ir_context, use_instruction, message_.id_use_descriptor().in_operand_index(), message_.replacement_id()); } void TransformationReplaceIrrelevantId::Apply( opt::IRContext* ir_context, TransformationContext* /* transformation_context */) const { // Find the instruction. auto instruction_to_change = FindInstructionContainingUse(message_.id_use_descriptor(), ir_context); // Replace the instruction. instruction_to_change->SetInOperand( message_.id_use_descriptor().in_operand_index(), {message_.replacement_id()}); ir_context->get_def_use_mgr()->EraseUseRecordsOfOperandIds( instruction_to_change); ir_context->get_def_use_mgr()->AnalyzeInstUse(instruction_to_change); // No analyses need to be invalidated, since the transformation is local to a // block, and the def-use analysis has been updated. } protobufs::Transformation TransformationReplaceIrrelevantId::ToMessage() const { protobufs::Transformation result; *result.mutable_replace_irrelevant_id() = message_; return result; } std::unordered_set TransformationReplaceIrrelevantId::GetFreshIds() const { return std::unordered_set(); } bool TransformationReplaceIrrelevantId:: AttemptsToReplaceVariableInitializerWithNonConstant( const opt::Instruction& use_instruction, const opt::Instruction& replacement_for_use) { return use_instruction.opcode() == spv::Op::OpVariable && !spvOpcodeIsConstant(replacement_for_use.opcode()); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_replace_irrelevant_id.h000066400000000000000000000053101475742701700306470ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_REPLACE_IRRELEVANT_ID_H_ #define SOURCE_FUZZ_TRANSFORMATION_REPLACE_IRRELEVANT_ID_H_ #include "source/fuzz/transformation.h" namespace spvtools { namespace fuzz { class TransformationReplaceIrrelevantId : public Transformation { public: explicit TransformationReplaceIrrelevantId( protobufs::TransformationReplaceIrrelevantId message); TransformationReplaceIrrelevantId( const protobufs::IdUseDescriptor& id_use_descriptor, uint32_t replacement_id); // - The id of interest in |message_.id_use_descriptor| is irrelevant // according to the fact manager. // - The types of the original id and of the replacement ids are the same. // - The replacement must not be the result id of an OpFunction instruction. // - |message_.replacement_id| is available to use at the enclosing // instruction of |message_.id_use_descriptor|. // - The original id is in principle replaceable with any other id of the same // type. See fuzzerutil::IdUseCanBeReplaced for details. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Replaces the use of an irrelevant id identified by // |message_.id_use_descriptor| with the id |message_.replacement_id|, which // has the same type as the id of interest. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; // Returns true if and only if |use_instruction| is OpVariable and // |replacement_for_use| is not a constant instruction - i.e., if it would be // illegal to replace the variable's initializer with the given instruction. static bool AttemptsToReplaceVariableInitializerWithNonConstant( const opt::Instruction& use_instruction, const opt::Instruction& replacement_for_use); private: protobufs::TransformationReplaceIrrelevantId message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_REPLACE_IRRELEVANT_ID_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_replace_linear_algebra_instruction.cpp000066400000000000000000001373421475742701700337560ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_replace_linear_algebra_instruction.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" namespace spvtools { namespace fuzz { TransformationReplaceLinearAlgebraInstruction:: TransformationReplaceLinearAlgebraInstruction( protobufs::TransformationReplaceLinearAlgebraInstruction message) : message_(std::move(message)) {} TransformationReplaceLinearAlgebraInstruction:: TransformationReplaceLinearAlgebraInstruction( const std::vector& fresh_ids, const protobufs::InstructionDescriptor& instruction_descriptor) { for (auto fresh_id : fresh_ids) { message_.add_fresh_ids(fresh_id); } *message_.mutable_instruction_descriptor() = instruction_descriptor; } bool TransformationReplaceLinearAlgebraInstruction::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { auto instruction = FindInstruction(message_.instruction_descriptor(), ir_context); // It must be a linear algebra instruction. if (!spvOpcodeIsLinearAlgebra(instruction->opcode())) { return false; } // |message_.fresh_ids.size| must be the exact number of fresh ids needed to // apply the transformation. if (static_cast(message_.fresh_ids().size()) != GetRequiredFreshIdCount(ir_context, instruction)) { return false; } // All ids in |message_.fresh_ids| must be fresh. for (uint32_t fresh_id : message_.fresh_ids()) { if (!fuzzerutil::IsFreshId(ir_context, fresh_id)) { return false; } } return true; } void TransformationReplaceLinearAlgebraInstruction::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { auto linear_algebra_instruction = FindInstruction(message_.instruction_descriptor(), ir_context); switch (linear_algebra_instruction->opcode()) { case spv::Op::OpTranspose: ReplaceOpTranspose(ir_context, linear_algebra_instruction); break; case spv::Op::OpVectorTimesScalar: ReplaceOpVectorTimesScalar(ir_context, linear_algebra_instruction); break; case spv::Op::OpMatrixTimesScalar: ReplaceOpMatrixTimesScalar(ir_context, linear_algebra_instruction); break; case spv::Op::OpVectorTimesMatrix: ReplaceOpVectorTimesMatrix(ir_context, linear_algebra_instruction); break; case spv::Op::OpMatrixTimesVector: ReplaceOpMatrixTimesVector(ir_context, linear_algebra_instruction); break; case spv::Op::OpMatrixTimesMatrix: ReplaceOpMatrixTimesMatrix(ir_context, linear_algebra_instruction); break; case spv::Op::OpOuterProduct: ReplaceOpOuterProduct(ir_context, linear_algebra_instruction); break; case spv::Op::OpDot: ReplaceOpDot(ir_context, linear_algebra_instruction); break; default: assert(false && "Should be unreachable."); break; } ir_context->InvalidateAnalysesExceptFor(opt::IRContext::kAnalysisNone); } protobufs::Transformation TransformationReplaceLinearAlgebraInstruction::ToMessage() const { protobufs::Transformation result; *result.mutable_replace_linear_algebra_instruction() = message_; return result; } uint32_t TransformationReplaceLinearAlgebraInstruction::GetRequiredFreshIdCount( opt::IRContext* ir_context, opt::Instruction* instruction) { // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/3354): // Right now we only support certain operations. switch (instruction->opcode()) { case spv::Op::OpTranspose: { // For each matrix row, |2 * matrix_column_count| OpCompositeExtract and 1 // OpCompositeConstruct will be inserted. auto matrix_instruction = ir_context->get_def_use_mgr()->GetDef( instruction->GetSingleWordInOperand(0)); uint32_t matrix_column_count = ir_context->get_type_mgr() ->GetType(matrix_instruction->type_id()) ->AsMatrix() ->element_count(); uint32_t matrix_row_count = ir_context->get_type_mgr() ->GetType(matrix_instruction->type_id()) ->AsMatrix() ->element_type() ->AsVector() ->element_count(); return matrix_row_count * (2 * matrix_column_count + 1); } case spv::Op::OpVectorTimesScalar: // For each vector component, 1 OpCompositeExtract and 1 OpFMul will be // inserted. return 2 * ir_context->get_type_mgr() ->GetType(ir_context->get_def_use_mgr() ->GetDef(instruction->GetSingleWordInOperand(0)) ->type_id()) ->AsVector() ->element_count(); case spv::Op::OpMatrixTimesScalar: { // For each matrix column, |1 + column.size| OpCompositeExtract, // |column.size| OpFMul and 1 OpCompositeConstruct instructions will be // inserted. auto matrix_instruction = ir_context->get_def_use_mgr()->GetDef( instruction->GetSingleWordInOperand(0)); auto matrix_type = ir_context->get_type_mgr()->GetType(matrix_instruction->type_id()); return 2 * matrix_type->AsMatrix()->element_count() * (1 + matrix_type->AsMatrix() ->element_type() ->AsVector() ->element_count()); } case spv::Op::OpVectorTimesMatrix: { // For each vector component, 1 OpCompositeExtract instruction will be // inserted. For each matrix column, |1 + vector_component_count| // OpCompositeExtract, |vector_component_count| OpFMul and // |vector_component_count - 1| OpFAdd instructions will be inserted. auto vector_instruction = ir_context->get_def_use_mgr()->GetDef( instruction->GetSingleWordInOperand(0)); auto matrix_instruction = ir_context->get_def_use_mgr()->GetDef( instruction->GetSingleWordInOperand(1)); uint32_t vector_component_count = ir_context->get_type_mgr() ->GetType(vector_instruction->type_id()) ->AsVector() ->element_count(); uint32_t matrix_column_count = ir_context->get_type_mgr() ->GetType(matrix_instruction->type_id()) ->AsMatrix() ->element_count(); return vector_component_count * (3 * matrix_column_count + 1); } case spv::Op::OpMatrixTimesVector: { // For each matrix column, |1 + matrix_row_count| OpCompositeExtract // will be inserted. For each matrix row, |matrix_column_count| OpFMul and // |matrix_column_count - 1| OpFAdd instructions will be inserted. For // each vector component, 1 OpCompositeExtract instruction will be // inserted. auto matrix_instruction = ir_context->get_def_use_mgr()->GetDef( instruction->GetSingleWordInOperand(0)); uint32_t matrix_column_count = ir_context->get_type_mgr() ->GetType(matrix_instruction->type_id()) ->AsMatrix() ->element_count(); uint32_t matrix_row_count = ir_context->get_type_mgr() ->GetType(matrix_instruction->type_id()) ->AsMatrix() ->element_type() ->AsVector() ->element_count(); return 3 * matrix_column_count * matrix_row_count + 2 * matrix_column_count - matrix_row_count; } case spv::Op::OpMatrixTimesMatrix: { // For each matrix 2 column, 1 OpCompositeExtract, 1 OpCompositeConstruct, // |3 * matrix_1_row_count * matrix_1_column_count| OpCompositeExtract, // |matrix_1_row_count * matrix_1_column_count| OpFMul, // |matrix_1_row_count * (matrix_1_column_count - 1)| OpFAdd instructions // will be inserted. auto matrix_1_instruction = ir_context->get_def_use_mgr()->GetDef( instruction->GetSingleWordInOperand(0)); uint32_t matrix_1_column_count = ir_context->get_type_mgr() ->GetType(matrix_1_instruction->type_id()) ->AsMatrix() ->element_count(); uint32_t matrix_1_row_count = ir_context->get_type_mgr() ->GetType(matrix_1_instruction->type_id()) ->AsMatrix() ->element_type() ->AsVector() ->element_count(); auto matrix_2_instruction = ir_context->get_def_use_mgr()->GetDef( instruction->GetSingleWordInOperand(1)); uint32_t matrix_2_column_count = ir_context->get_type_mgr() ->GetType(matrix_2_instruction->type_id()) ->AsMatrix() ->element_count(); return matrix_2_column_count * (2 + matrix_1_row_count * (5 * matrix_1_column_count - 1)); } case spv::Op::OpOuterProduct: { // For each |vector_2| component, |vector_1_component_count + 1| // OpCompositeExtract, |vector_1_component_count| OpFMul and 1 // OpCompositeConstruct instructions will be inserted. auto vector_1_instruction = ir_context->get_def_use_mgr()->GetDef( instruction->GetSingleWordInOperand(0)); auto vector_2_instruction = ir_context->get_def_use_mgr()->GetDef( instruction->GetSingleWordInOperand(1)); uint32_t vector_1_component_count = ir_context->get_type_mgr() ->GetType(vector_1_instruction->type_id()) ->AsVector() ->element_count(); uint32_t vector_2_component_count = ir_context->get_type_mgr() ->GetType(vector_2_instruction->type_id()) ->AsVector() ->element_count(); return 2 * vector_2_component_count * (vector_1_component_count + 1); } case spv::Op::OpDot: // For each pair of vector components, 2 OpCompositeExtract and 1 OpFMul // will be inserted. The first two OpFMul instructions will result the // first OpFAdd instruction to be inserted. For each remaining OpFMul, 1 // OpFAdd will be inserted. The last OpFAdd instruction is got by changing // the OpDot instruction. return 4 * ir_context->get_type_mgr() ->GetType( ir_context->get_def_use_mgr() ->GetDef(instruction->GetSingleWordInOperand(0)) ->type_id()) ->AsVector() ->element_count() - 2; default: assert(false && "Unsupported linear algebra instruction."); return 0; } } void TransformationReplaceLinearAlgebraInstruction::ReplaceOpTranspose( opt::IRContext* ir_context, opt::Instruction* linear_algebra_instruction) const { // Gets OpTranspose instruction information. auto matrix_instruction = ir_context->get_def_use_mgr()->GetDef( linear_algebra_instruction->GetSingleWordInOperand(0)); uint32_t matrix_column_count = ir_context->get_type_mgr() ->GetType(matrix_instruction->type_id()) ->AsMatrix() ->element_count(); auto matrix_column_type = ir_context->get_type_mgr() ->GetType(matrix_instruction->type_id()) ->AsMatrix() ->element_type(); auto matrix_column_component_type = matrix_column_type->AsVector()->element_type(); uint32_t matrix_row_count = matrix_column_type->AsVector()->element_count(); auto resulting_matrix_column_type = ir_context->get_type_mgr() ->GetType(linear_algebra_instruction->type_id()) ->AsMatrix() ->element_type(); uint32_t fresh_id_index = 0; std::vector result_column_ids(matrix_row_count); for (uint32_t i = 0; i < matrix_row_count; i++) { std::vector column_component_ids(matrix_column_count); for (uint32_t j = 0; j < matrix_column_count; j++) { // Extracts the matrix column. uint32_t matrix_column_id = message_.fresh_ids(fresh_id_index++); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpCompositeExtract, ir_context->get_type_mgr()->GetId(matrix_column_type), matrix_column_id, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {matrix_instruction->result_id()}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {j}}}))); // Extracts the matrix column component. column_component_ids[j] = message_.fresh_ids(fresh_id_index++); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpCompositeExtract, ir_context->get_type_mgr()->GetId(matrix_column_component_type), column_component_ids[j], opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {matrix_column_id}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {i}}}))); } // Inserts the resulting matrix column. opt::Instruction::OperandList in_operands; for (auto& column_component_id : column_component_ids) { in_operands.push_back({SPV_OPERAND_TYPE_ID, {column_component_id}}); } result_column_ids[i] = message_.fresh_ids(fresh_id_index++); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpCompositeConstruct, ir_context->get_type_mgr()->GetId(resulting_matrix_column_type), result_column_ids[i], opt::Instruction::OperandList(in_operands))); } // The OpTranspose instruction is changed to an OpCompositeConstruct // instruction. linear_algebra_instruction->SetOpcode(spv::Op::OpCompositeConstruct); linear_algebra_instruction->SetInOperand(0, {result_column_ids[0]}); for (uint32_t i = 1; i < result_column_ids.size(); i++) { linear_algebra_instruction->AddOperand( {SPV_OPERAND_TYPE_ID, {result_column_ids[i]}}); } fuzzerutil::UpdateModuleIdBound( ir_context, message_.fresh_ids(message_.fresh_ids().size() - 1)); } void TransformationReplaceLinearAlgebraInstruction::ReplaceOpVectorTimesScalar( opt::IRContext* ir_context, opt::Instruction* linear_algebra_instruction) const { // Gets OpVectorTimesScalar in operands. auto vector = ir_context->get_def_use_mgr()->GetDef( linear_algebra_instruction->GetSingleWordInOperand(0)); auto scalar = ir_context->get_def_use_mgr()->GetDef( linear_algebra_instruction->GetSingleWordInOperand(1)); uint32_t vector_component_count = ir_context->get_type_mgr() ->GetType(vector->type_id()) ->AsVector() ->element_count(); std::vector float_multiplication_ids(vector_component_count); uint32_t fresh_id_index = 0; for (uint32_t i = 0; i < vector_component_count; i++) { // Extracts |vector| component. uint32_t vector_extract_id = message_.fresh_ids(fresh_id_index++); fuzzerutil::UpdateModuleIdBound(ir_context, vector_extract_id); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpCompositeExtract, scalar->type_id(), vector_extract_id, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {vector->result_id()}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {i}}}))); // Multiplies the |vector| component with the |scalar|. uint32_t float_multiplication_id = message_.fresh_ids(fresh_id_index++); float_multiplication_ids[i] = float_multiplication_id; fuzzerutil::UpdateModuleIdBound(ir_context, float_multiplication_id); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpFMul, scalar->type_id(), float_multiplication_id, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {vector_extract_id}}, {SPV_OPERAND_TYPE_ID, {scalar->result_id()}}}))); } // The OpVectorTimesScalar instruction is changed to an OpCompositeConstruct // instruction. linear_algebra_instruction->SetOpcode(spv::Op::OpCompositeConstruct); linear_algebra_instruction->SetInOperand(0, {float_multiplication_ids[0]}); linear_algebra_instruction->SetInOperand(1, {float_multiplication_ids[1]}); for (uint32_t i = 2; i < float_multiplication_ids.size(); i++) { linear_algebra_instruction->AddOperand( {SPV_OPERAND_TYPE_ID, {float_multiplication_ids[i]}}); } } void TransformationReplaceLinearAlgebraInstruction::ReplaceOpMatrixTimesScalar( opt::IRContext* ir_context, opt::Instruction* linear_algebra_instruction) const { // Gets OpMatrixTimesScalar in operands. auto matrix_instruction = ir_context->get_def_use_mgr()->GetDef( linear_algebra_instruction->GetSingleWordInOperand(0)); auto scalar_instruction = ir_context->get_def_use_mgr()->GetDef( linear_algebra_instruction->GetSingleWordInOperand(1)); // Gets matrix information. uint32_t matrix_column_count = ir_context->get_type_mgr() ->GetType(matrix_instruction->type_id()) ->AsMatrix() ->element_count(); auto matrix_column_type = ir_context->get_type_mgr() ->GetType(matrix_instruction->type_id()) ->AsMatrix() ->element_type(); uint32_t matrix_column_size = matrix_column_type->AsVector()->element_count(); std::vector composite_construct_ids(matrix_column_count); uint32_t fresh_id_index = 0; for (uint32_t i = 0; i < matrix_column_count; i++) { // Extracts |matrix| column. uint32_t matrix_extract_id = message_.fresh_ids(fresh_id_index++); fuzzerutil::UpdateModuleIdBound(ir_context, matrix_extract_id); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpCompositeExtract, ir_context->get_type_mgr()->GetId(matrix_column_type), matrix_extract_id, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {matrix_instruction->result_id()}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {i}}}))); std::vector float_multiplication_ids(matrix_column_size); for (uint32_t j = 0; j < matrix_column_size; j++) { // Extracts |column| component. uint32_t column_extract_id = message_.fresh_ids(fresh_id_index++); fuzzerutil::UpdateModuleIdBound(ir_context, column_extract_id); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpCompositeExtract, scalar_instruction->type_id(), column_extract_id, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {matrix_extract_id}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {j}}}))); // Multiplies the |column| component with the |scalar|. float_multiplication_ids[j] = message_.fresh_ids(fresh_id_index++); fuzzerutil::UpdateModuleIdBound(ir_context, float_multiplication_ids[j]); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpFMul, scalar_instruction->type_id(), float_multiplication_ids[j], opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {column_extract_id}}, {SPV_OPERAND_TYPE_ID, {scalar_instruction->result_id()}}}))); } // Constructs a new column multiplied by |scalar|. opt::Instruction::OperandList composite_construct_in_operands; for (uint32_t& float_multiplication_id : float_multiplication_ids) { composite_construct_in_operands.push_back( {SPV_OPERAND_TYPE_ID, {float_multiplication_id}}); } composite_construct_ids[i] = message_.fresh_ids(fresh_id_index++); fuzzerutil::UpdateModuleIdBound(ir_context, composite_construct_ids[i]); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpCompositeConstruct, ir_context->get_type_mgr()->GetId(matrix_column_type), composite_construct_ids[i], composite_construct_in_operands)); } // The OpMatrixTimesScalar instruction is changed to an OpCompositeConstruct // instruction. linear_algebra_instruction->SetOpcode(spv::Op::OpCompositeConstruct); linear_algebra_instruction->SetInOperand(0, {composite_construct_ids[0]}); linear_algebra_instruction->SetInOperand(1, {composite_construct_ids[1]}); for (uint32_t i = 2; i < composite_construct_ids.size(); i++) { linear_algebra_instruction->AddOperand( {SPV_OPERAND_TYPE_ID, {composite_construct_ids[i]}}); } } void TransformationReplaceLinearAlgebraInstruction::ReplaceOpVectorTimesMatrix( opt::IRContext* ir_context, opt::Instruction* linear_algebra_instruction) const { // Gets vector information. auto vector_instruction = ir_context->get_def_use_mgr()->GetDef( linear_algebra_instruction->GetSingleWordInOperand(0)); uint32_t vector_component_count = ir_context->get_type_mgr() ->GetType(vector_instruction->type_id()) ->AsVector() ->element_count(); auto vector_component_type = ir_context->get_type_mgr() ->GetType(vector_instruction->type_id()) ->AsVector() ->element_type(); // Extracts vector components. uint32_t fresh_id_index = 0; std::vector vector_component_ids(vector_component_count); for (uint32_t i = 0; i < vector_component_count; i++) { vector_component_ids[i] = message_.fresh_ids(fresh_id_index++); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpCompositeExtract, ir_context->get_type_mgr()->GetId(vector_component_type), vector_component_ids[i], opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {vector_instruction->result_id()}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {i}}}))); } // Gets matrix information. auto matrix_instruction = ir_context->get_def_use_mgr()->GetDef( linear_algebra_instruction->GetSingleWordInOperand(1)); uint32_t matrix_column_count = ir_context->get_type_mgr() ->GetType(matrix_instruction->type_id()) ->AsMatrix() ->element_count(); auto matrix_column_type = ir_context->get_type_mgr() ->GetType(matrix_instruction->type_id()) ->AsMatrix() ->element_type(); std::vector result_component_ids(matrix_column_count); for (uint32_t i = 0; i < matrix_column_count; i++) { // Extracts matrix column. uint32_t matrix_extract_id = message_.fresh_ids(fresh_id_index++); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpCompositeExtract, ir_context->get_type_mgr()->GetId(matrix_column_type), matrix_extract_id, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {matrix_instruction->result_id()}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {i}}}))); std::vector float_multiplication_ids(vector_component_count); for (uint32_t j = 0; j < vector_component_count; j++) { // Extracts column component. uint32_t column_extract_id = message_.fresh_ids(fresh_id_index++); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpCompositeExtract, ir_context->get_type_mgr()->GetId(vector_component_type), column_extract_id, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {matrix_extract_id}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {j}}}))); // Multiplies corresponding vector and column components. float_multiplication_ids[j] = message_.fresh_ids(fresh_id_index++); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpFMul, ir_context->get_type_mgr()->GetId(vector_component_type), float_multiplication_ids[j], opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {vector_component_ids[j]}}, {SPV_OPERAND_TYPE_ID, {column_extract_id}}}))); } // Adds the multiplication results. std::vector float_add_ids; uint32_t float_add_id = message_.fresh_ids(fresh_id_index++); float_add_ids.push_back(float_add_id); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpFAdd, ir_context->get_type_mgr()->GetId(vector_component_type), float_add_id, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {float_multiplication_ids[0]}}, {SPV_OPERAND_TYPE_ID, {float_multiplication_ids[1]}}}))); for (uint32_t j = 2; j < float_multiplication_ids.size(); j++) { float_add_id = message_.fresh_ids(fresh_id_index++); float_add_ids.push_back(float_add_id); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpFAdd, ir_context->get_type_mgr()->GetId(vector_component_type), float_add_id, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {float_multiplication_ids[j]}}, {SPV_OPERAND_TYPE_ID, {float_add_ids[j - 2]}}}))); } result_component_ids[i] = float_add_ids.back(); } // The OpVectorTimesMatrix instruction is changed to an OpCompositeConstruct // instruction. linear_algebra_instruction->SetOpcode(spv::Op::OpCompositeConstruct); linear_algebra_instruction->SetInOperand(0, {result_component_ids[0]}); linear_algebra_instruction->SetInOperand(1, {result_component_ids[1]}); for (uint32_t i = 2; i < result_component_ids.size(); i++) { linear_algebra_instruction->AddOperand( {SPV_OPERAND_TYPE_ID, {result_component_ids[i]}}); } fuzzerutil::UpdateModuleIdBound( ir_context, message_.fresh_ids(message_.fresh_ids().size() - 1)); } void TransformationReplaceLinearAlgebraInstruction::ReplaceOpMatrixTimesVector( opt::IRContext* ir_context, opt::Instruction* linear_algebra_instruction) const { // Gets matrix information. auto matrix_instruction = ir_context->get_def_use_mgr()->GetDef( linear_algebra_instruction->GetSingleWordInOperand(0)); uint32_t matrix_column_count = ir_context->get_type_mgr() ->GetType(matrix_instruction->type_id()) ->AsMatrix() ->element_count(); auto matrix_column_type = ir_context->get_type_mgr() ->GetType(matrix_instruction->type_id()) ->AsMatrix() ->element_type(); uint32_t matrix_row_count = matrix_column_type->AsVector()->element_count(); // Extracts matrix columns. uint32_t fresh_id_index = 0; std::vector matrix_column_ids(matrix_column_count); for (uint32_t i = 0; i < matrix_column_count; i++) { matrix_column_ids[i] = message_.fresh_ids(fresh_id_index++); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpCompositeExtract, ir_context->get_type_mgr()->GetId(matrix_column_type), matrix_column_ids[i], opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {matrix_instruction->result_id()}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {i}}}))); } // Gets vector information. auto vector_instruction = ir_context->get_def_use_mgr()->GetDef( linear_algebra_instruction->GetSingleWordInOperand(1)); auto vector_component_type = ir_context->get_type_mgr() ->GetType(vector_instruction->type_id()) ->AsVector() ->element_type(); // Extracts vector components. std::vector vector_component_ids(matrix_column_count); for (uint32_t i = 0; i < matrix_column_count; i++) { vector_component_ids[i] = message_.fresh_ids(fresh_id_index++); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpCompositeExtract, ir_context->get_type_mgr()->GetId(vector_component_type), vector_component_ids[i], opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {vector_instruction->result_id()}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {i}}}))); } std::vector result_component_ids(matrix_row_count); for (uint32_t i = 0; i < matrix_row_count; i++) { std::vector float_multiplication_ids(matrix_column_count); for (uint32_t j = 0; j < matrix_column_count; j++) { // Extracts column component. uint32_t column_extract_id = message_.fresh_ids(fresh_id_index++); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpCompositeExtract, ir_context->get_type_mgr()->GetId(vector_component_type), column_extract_id, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {matrix_column_ids[j]}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {i}}}))); // Multiplies corresponding vector and column components. float_multiplication_ids[j] = message_.fresh_ids(fresh_id_index++); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpFMul, ir_context->get_type_mgr()->GetId(vector_component_type), float_multiplication_ids[j], opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {column_extract_id}}, {SPV_OPERAND_TYPE_ID, {vector_component_ids[j]}}}))); } // Adds the multiplication results. std::vector float_add_ids; uint32_t float_add_id = message_.fresh_ids(fresh_id_index++); float_add_ids.push_back(float_add_id); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpFAdd, ir_context->get_type_mgr()->GetId(vector_component_type), float_add_id, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {float_multiplication_ids[0]}}, {SPV_OPERAND_TYPE_ID, {float_multiplication_ids[1]}}}))); for (uint32_t j = 2; j < float_multiplication_ids.size(); j++) { float_add_id = message_.fresh_ids(fresh_id_index++); float_add_ids.push_back(float_add_id); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpFAdd, ir_context->get_type_mgr()->GetId(vector_component_type), float_add_id, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {float_multiplication_ids[j]}}, {SPV_OPERAND_TYPE_ID, {float_add_ids[j - 2]}}}))); } result_component_ids[i] = float_add_ids.back(); } // The OpMatrixTimesVector instruction is changed to an OpCompositeConstruct // instruction. linear_algebra_instruction->SetOpcode(spv::Op::OpCompositeConstruct); linear_algebra_instruction->SetInOperand(0, {result_component_ids[0]}); linear_algebra_instruction->SetInOperand(1, {result_component_ids[1]}); for (uint32_t i = 2; i < result_component_ids.size(); i++) { linear_algebra_instruction->AddOperand( {SPV_OPERAND_TYPE_ID, {result_component_ids[i]}}); } fuzzerutil::UpdateModuleIdBound( ir_context, message_.fresh_ids(message_.fresh_ids().size() - 1)); } void TransformationReplaceLinearAlgebraInstruction::ReplaceOpMatrixTimesMatrix( opt::IRContext* ir_context, opt::Instruction* linear_algebra_instruction) const { // Gets matrix 1 information. auto matrix_1_instruction = ir_context->get_def_use_mgr()->GetDef( linear_algebra_instruction->GetSingleWordInOperand(0)); uint32_t matrix_1_column_count = ir_context->get_type_mgr() ->GetType(matrix_1_instruction->type_id()) ->AsMatrix() ->element_count(); auto matrix_1_column_type = ir_context->get_type_mgr() ->GetType(matrix_1_instruction->type_id()) ->AsMatrix() ->element_type(); auto matrix_1_column_component_type = matrix_1_column_type->AsVector()->element_type(); uint32_t matrix_1_row_count = matrix_1_column_type->AsVector()->element_count(); // Gets matrix 2 information. auto matrix_2_instruction = ir_context->get_def_use_mgr()->GetDef( linear_algebra_instruction->GetSingleWordInOperand(1)); uint32_t matrix_2_column_count = ir_context->get_type_mgr() ->GetType(matrix_2_instruction->type_id()) ->AsMatrix() ->element_count(); auto matrix_2_column_type = ir_context->get_type_mgr() ->GetType(matrix_2_instruction->type_id()) ->AsMatrix() ->element_type(); uint32_t fresh_id_index = 0; std::vector result_column_ids(matrix_2_column_count); for (uint32_t i = 0; i < matrix_2_column_count; i++) { // Extracts matrix 2 column. uint32_t matrix_2_column_id = message_.fresh_ids(fresh_id_index++); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpCompositeExtract, ir_context->get_type_mgr()->GetId(matrix_2_column_type), matrix_2_column_id, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {matrix_2_instruction->result_id()}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {i}}}))); std::vector column_component_ids(matrix_1_row_count); for (uint32_t j = 0; j < matrix_1_row_count; j++) { std::vector float_multiplication_ids(matrix_1_column_count); for (uint32_t k = 0; k < matrix_1_column_count; k++) { // Extracts matrix 1 column. uint32_t matrix_1_column_id = message_.fresh_ids(fresh_id_index++); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpCompositeExtract, ir_context->get_type_mgr()->GetId(matrix_1_column_type), matrix_1_column_id, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {matrix_1_instruction->result_id()}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {k}}}))); // Extracts matrix 1 column component. uint32_t matrix_1_column_component_id = message_.fresh_ids(fresh_id_index++); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpCompositeExtract, ir_context->get_type_mgr()->GetId(matrix_1_column_component_type), matrix_1_column_component_id, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {matrix_1_column_id}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {j}}}))); // Extracts matrix 2 column component. uint32_t matrix_2_column_component_id = message_.fresh_ids(fresh_id_index++); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpCompositeExtract, ir_context->get_type_mgr()->GetId(matrix_1_column_component_type), matrix_2_column_component_id, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {matrix_2_column_id}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {k}}}))); // Multiplies corresponding matrix 1 and matrix 2 column components. float_multiplication_ids[k] = message_.fresh_ids(fresh_id_index++); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpFMul, ir_context->get_type_mgr()->GetId(matrix_1_column_component_type), float_multiplication_ids[k], opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {matrix_1_column_component_id}}, {SPV_OPERAND_TYPE_ID, {matrix_2_column_component_id}}}))); } // Adds the multiplication results. std::vector float_add_ids; uint32_t float_add_id = message_.fresh_ids(fresh_id_index++); float_add_ids.push_back(float_add_id); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpFAdd, ir_context->get_type_mgr()->GetId(matrix_1_column_component_type), float_add_id, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {float_multiplication_ids[0]}}, {SPV_OPERAND_TYPE_ID, {float_multiplication_ids[1]}}}))); for (uint32_t k = 2; k < float_multiplication_ids.size(); k++) { float_add_id = message_.fresh_ids(fresh_id_index++); float_add_ids.push_back(float_add_id); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpFAdd, ir_context->get_type_mgr()->GetId(matrix_1_column_component_type), float_add_id, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {float_multiplication_ids[k]}}, {SPV_OPERAND_TYPE_ID, {float_add_ids[k - 2]}}}))); } column_component_ids[j] = float_add_ids.back(); } // Inserts the resulting matrix column. opt::Instruction::OperandList in_operands; for (auto& column_component_id : column_component_ids) { in_operands.push_back({SPV_OPERAND_TYPE_ID, {column_component_id}}); } result_column_ids[i] = message_.fresh_ids(fresh_id_index++); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpCompositeConstruct, ir_context->get_type_mgr()->GetId(matrix_1_column_type), result_column_ids[i], opt::Instruction::OperandList(in_operands))); } // The OpMatrixTimesMatrix instruction is changed to an OpCompositeConstruct // instruction. linear_algebra_instruction->SetOpcode(spv::Op::OpCompositeConstruct); linear_algebra_instruction->SetInOperand(0, {result_column_ids[0]}); linear_algebra_instruction->SetInOperand(1, {result_column_ids[1]}); for (uint32_t i = 2; i < result_column_ids.size(); i++) { linear_algebra_instruction->AddOperand( {SPV_OPERAND_TYPE_ID, {result_column_ids[i]}}); } fuzzerutil::UpdateModuleIdBound( ir_context, message_.fresh_ids(message_.fresh_ids().size() - 1)); } void TransformationReplaceLinearAlgebraInstruction::ReplaceOpOuterProduct( opt::IRContext* ir_context, opt::Instruction* linear_algebra_instruction) const { // Gets vector 1 information. auto vector_1_instruction = ir_context->get_def_use_mgr()->GetDef( linear_algebra_instruction->GetSingleWordInOperand(0)); uint32_t vector_1_component_count = ir_context->get_type_mgr() ->GetType(vector_1_instruction->type_id()) ->AsVector() ->element_count(); auto vector_1_component_type = ir_context->get_type_mgr() ->GetType(vector_1_instruction->type_id()) ->AsVector() ->element_type(); // Gets vector 2 information. auto vector_2_instruction = ir_context->get_def_use_mgr()->GetDef( linear_algebra_instruction->GetSingleWordInOperand(1)); uint32_t vector_2_component_count = ir_context->get_type_mgr() ->GetType(vector_2_instruction->type_id()) ->AsVector() ->element_count(); uint32_t fresh_id_index = 0; std::vector result_column_ids(vector_2_component_count); for (uint32_t i = 0; i < vector_2_component_count; i++) { // Extracts |vector_2| component. uint32_t vector_2_component_id = message_.fresh_ids(fresh_id_index++); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpCompositeExtract, ir_context->get_type_mgr()->GetId(vector_1_component_type), vector_2_component_id, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {vector_2_instruction->result_id()}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {i}}}))); std::vector column_component_ids(vector_1_component_count); for (uint32_t j = 0; j < vector_1_component_count; j++) { // Extracts |vector_1| component. uint32_t vector_1_component_id = message_.fresh_ids(fresh_id_index++); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpCompositeExtract, ir_context->get_type_mgr()->GetId(vector_1_component_type), vector_1_component_id, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {vector_1_instruction->result_id()}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {j}}}))); // Multiplies |vector_1| and |vector_2| components. column_component_ids[j] = message_.fresh_ids(fresh_id_index++); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpFMul, ir_context->get_type_mgr()->GetId(vector_1_component_type), column_component_ids[j], opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {vector_2_component_id}}, {SPV_OPERAND_TYPE_ID, {vector_1_component_id}}}))); } // Inserts the resulting matrix column. opt::Instruction::OperandList in_operands; for (auto& column_component_id : column_component_ids) { in_operands.push_back({SPV_OPERAND_TYPE_ID, {column_component_id}}); } result_column_ids[i] = message_.fresh_ids(fresh_id_index++); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpCompositeConstruct, vector_1_instruction->type_id(), result_column_ids[i], in_operands)); } // The OpOuterProduct instruction is changed to an OpCompositeConstruct // instruction. linear_algebra_instruction->SetOpcode(spv::Op::OpCompositeConstruct); linear_algebra_instruction->SetInOperand(0, {result_column_ids[0]}); linear_algebra_instruction->SetInOperand(1, {result_column_ids[1]}); for (uint32_t i = 2; i < result_column_ids.size(); i++) { linear_algebra_instruction->AddOperand( {SPV_OPERAND_TYPE_ID, {result_column_ids[i]}}); } fuzzerutil::UpdateModuleIdBound( ir_context, message_.fresh_ids(message_.fresh_ids().size() - 1)); } void TransformationReplaceLinearAlgebraInstruction::ReplaceOpDot( opt::IRContext* ir_context, opt::Instruction* linear_algebra_instruction) const { // Gets OpDot in operands. auto vector_1 = ir_context->get_def_use_mgr()->GetDef( linear_algebra_instruction->GetSingleWordInOperand(0)); auto vector_2 = ir_context->get_def_use_mgr()->GetDef( linear_algebra_instruction->GetSingleWordInOperand(1)); uint32_t vectors_component_count = ir_context->get_type_mgr() ->GetType(vector_1->type_id()) ->AsVector() ->element_count(); std::vector float_multiplication_ids(vectors_component_count); uint32_t fresh_id_index = 0; for (uint32_t i = 0; i < vectors_component_count; i++) { // Extracts |vector_1| component. uint32_t vector_1_extract_id = message_.fresh_ids(fresh_id_index++); fuzzerutil::UpdateModuleIdBound(ir_context, vector_1_extract_id); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpCompositeExtract, linear_algebra_instruction->type_id(), vector_1_extract_id, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {vector_1->result_id()}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {i}}}))); // Extracts |vector_2| component. uint32_t vector_2_extract_id = message_.fresh_ids(fresh_id_index++); fuzzerutil::UpdateModuleIdBound(ir_context, vector_2_extract_id); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpCompositeExtract, linear_algebra_instruction->type_id(), vector_2_extract_id, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {vector_2->result_id()}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {i}}}))); // Multiplies the pair of components. float_multiplication_ids[i] = message_.fresh_ids(fresh_id_index++); fuzzerutil::UpdateModuleIdBound(ir_context, float_multiplication_ids[i]); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpFMul, linear_algebra_instruction->type_id(), float_multiplication_ids[i], opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {vector_1_extract_id}}, {SPV_OPERAND_TYPE_ID, {vector_2_extract_id}}}))); } // If the vector has 2 components, then there will be 2 float multiplication // instructions. if (vectors_component_count == 2) { linear_algebra_instruction->SetOpcode(spv::Op::OpFAdd); linear_algebra_instruction->SetInOperand(0, {float_multiplication_ids[0]}); linear_algebra_instruction->SetInOperand(1, {float_multiplication_ids[1]}); } else { // The first OpFAdd instruction has as operands the first two OpFMul // instructions. std::vector float_add_ids; uint32_t float_add_id = message_.fresh_ids(fresh_id_index++); float_add_ids.push_back(float_add_id); fuzzerutil::UpdateModuleIdBound(ir_context, float_add_id); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpFAdd, linear_algebra_instruction->type_id(), float_add_id, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {float_multiplication_ids[0]}}, {SPV_OPERAND_TYPE_ID, {float_multiplication_ids[1]}}}))); // The remaining OpFAdd instructions has as operands an OpFMul and an OpFAdd // instruction. for (uint32_t i = 2; i < float_multiplication_ids.size() - 1; i++) { float_add_id = message_.fresh_ids(fresh_id_index++); fuzzerutil::UpdateModuleIdBound(ir_context, float_add_id); float_add_ids.push_back(float_add_id); linear_algebra_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpFAdd, linear_algebra_instruction->type_id(), float_add_id, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {float_multiplication_ids[i]}}, {SPV_OPERAND_TYPE_ID, {float_add_ids[i - 2]}}}))); } // The last OpFAdd instruction is got by changing some of the OpDot // instruction attributes. linear_algebra_instruction->SetOpcode(spv::Op::OpFAdd); linear_algebra_instruction->SetInOperand( 0, {float_multiplication_ids[float_multiplication_ids.size() - 1]}); linear_algebra_instruction->SetInOperand( 1, {float_add_ids[float_add_ids.size() - 1]}); } } std::unordered_set TransformationReplaceLinearAlgebraInstruction::GetFreshIds() const { std::unordered_set result; for (auto id : message_.fresh_ids()) { result.insert(id); } return result; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_replace_linear_algebra_instruction.h000066400000000000000000000072431475742701700334170ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_REPLACE_LINEAR_ALGEBRA_INSTRUCTION_H_ #define SOURCE_FUZZ_TRANSFORMATION_REPLACE_LINEAR_ALGEBRA_INSTRUCTION_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationReplaceLinearAlgebraInstruction : public Transformation { public: explicit TransformationReplaceLinearAlgebraInstruction( protobufs::TransformationReplaceLinearAlgebraInstruction message); TransformationReplaceLinearAlgebraInstruction( const std::vector& fresh_ids, const protobufs::InstructionDescriptor& instruction_descriptor); // - |message_.fresh_ids| must be fresh ids needed to apply the // transformation. // - |message_.instruction_descriptor| must be a linear algebra instruction bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Replaces a linear algebra instruction. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; // Returns the number of ids needed to apply the transformation. static uint32_t GetRequiredFreshIdCount(opt::IRContext* ir_context, opt::Instruction* instruction); private: protobufs::TransformationReplaceLinearAlgebraInstruction message_; // Replaces an OpTranspose instruction. void ReplaceOpTranspose(opt::IRContext* ir_context, opt::Instruction* instruction) const; // Replaces an OpVectorTimesScalar instruction. void ReplaceOpVectorTimesScalar(opt::IRContext* ir_context, opt::Instruction* instruction) const; // Replaces an OpMatrixTimesScalar instruction. void ReplaceOpMatrixTimesScalar(opt::IRContext* ir_context, opt::Instruction* instruction) const; // Replaces an OpVectorTimesMatrix instruction. void ReplaceOpVectorTimesMatrix(opt::IRContext* ir_context, opt::Instruction* instruction) const; // Replaces an OpMatrixTimesVector instruction. void ReplaceOpMatrixTimesVector(opt::IRContext* ir_context, opt::Instruction* instruction) const; // Replaces an OpMatrixTimesMatrix instruction. void ReplaceOpMatrixTimesMatrix(opt::IRContext* ir_context, opt::Instruction* instruction) const; // Replaces an OpOuterProduct instruction. void ReplaceOpOuterProduct(opt::IRContext* ir_context, opt::Instruction* instruction) const; // Replaces an OpDot instruction. void ReplaceOpDot(opt::IRContext* ir_context, opt::Instruction* instruction) const; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_REPLACE_LINEAR_ALGEBRA_INSTRUCTION_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_replace_load_store_with_copy_memory.cpp000066400000000000000000000153221475742701700341670ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "transformation_replace_load_store_with_copy_memory.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "source/opcode.h" namespace spvtools { namespace fuzz { namespace { const uint32_t kOpStoreOperandIndexTargetVariable = 0; const uint32_t kOpStoreOperandIndexIntermediateIdToWrite = 1; const uint32_t kOpLoadOperandIndexSourceVariable = 2; } // namespace TransformationReplaceLoadStoreWithCopyMemory:: TransformationReplaceLoadStoreWithCopyMemory( protobufs::TransformationReplaceLoadStoreWithCopyMemory message) : message_(std::move(message)) {} TransformationReplaceLoadStoreWithCopyMemory:: TransformationReplaceLoadStoreWithCopyMemory( const protobufs::InstructionDescriptor& load_instruction_descriptor, const protobufs::InstructionDescriptor& store_instruction_descriptor) { *message_.mutable_load_instruction_descriptor() = load_instruction_descriptor; *message_.mutable_store_instruction_descriptor() = store_instruction_descriptor; } bool TransformationReplaceLoadStoreWithCopyMemory::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { // This transformation is only applicable to the pair of OpLoad and OpStore // instructions. // The OpLoad instruction must be defined. auto load_instruction = FindInstruction(message_.load_instruction_descriptor(), ir_context); if (!load_instruction || load_instruction->opcode() != spv::Op::OpLoad) { return false; } // The OpStore instruction must be defined. auto store_instruction = FindInstruction(message_.store_instruction_descriptor(), ir_context); if (!store_instruction || store_instruction->opcode() != spv::Op::OpStore) { return false; } // Intermediate values of the OpLoad and the OpStore must match. if (load_instruction->result_id() != store_instruction->GetSingleWordOperand( kOpStoreOperandIndexIntermediateIdToWrite)) { return false; } // Get storage class of the variable pointed by the source operand in OpLoad. opt::Instruction* source_id = ir_context->get_def_use_mgr()->GetDef( load_instruction->GetSingleWordOperand(2)); spv::StorageClass storage_class = fuzzerutil::GetStorageClassFromPointerType( ir_context, source_id->type_id()); // Iterate over all instructions between |load_instruction| and // |store_instruction|. for (auto it = load_instruction; it != store_instruction; it = it->NextNode()) { //|load_instruction| and |store_instruction| are not in the same block. if (it == nullptr) { return false; } // We need to make sure that the value pointed to by the source of the // OpLoad hasn't changed by the time we see the matching OpStore // instruction. if (IsMemoryWritingOpCode(it->opcode())) { return false; } else if (IsMemoryBarrierOpCode(it->opcode()) && !IsStorageClassSafeAcrossMemoryBarriers(storage_class)) { return false; } } return true; } void TransformationReplaceLoadStoreWithCopyMemory::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { // OpLoad and OpStore instructions must be defined. auto load_instruction = FindInstruction(message_.load_instruction_descriptor(), ir_context); assert(load_instruction && load_instruction->opcode() == spv::Op::OpLoad && "The required OpLoad instruction must be defined."); auto store_instruction = FindInstruction(message_.store_instruction_descriptor(), ir_context); assert(store_instruction && store_instruction->opcode() == spv::Op::OpStore && "The required OpStore instruction must be defined."); // Intermediate values of the OpLoad and the OpStore must match. assert(load_instruction->result_id() == store_instruction->GetSingleWordOperand( kOpStoreOperandIndexIntermediateIdToWrite) && "OpLoad and OpStore must refer to the same value."); // Get the ids of the source operand of the OpLoad and the target operand of // the OpStore. uint32_t source_variable_id = load_instruction->GetSingleWordOperand(kOpLoadOperandIndexSourceVariable); uint32_t target_variable_id = store_instruction->GetSingleWordOperand( kOpStoreOperandIndexTargetVariable); // Insert the OpCopyMemory instruction before the OpStore instruction. store_instruction->InsertBefore(MakeUnique( ir_context, spv::Op::OpCopyMemory, 0, 0, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {target_variable_id}}, {SPV_OPERAND_TYPE_ID, {source_variable_id}}}))); // Remove the OpStore instruction. ir_context->KillInst(store_instruction); ir_context->InvalidateAnalysesExceptFor(opt::IRContext::kAnalysisNone); } bool TransformationReplaceLoadStoreWithCopyMemory::IsMemoryWritingOpCode( spv::Op op_code) { if (spvOpcodeIsAtomicOp(op_code)) { return op_code != spv::Op::OpAtomicLoad; } switch (op_code) { case spv::Op::OpStore: case spv::Op::OpCopyMemory: case spv::Op::OpCopyMemorySized: return true; default: return false; } } bool TransformationReplaceLoadStoreWithCopyMemory::IsMemoryBarrierOpCode( spv::Op op_code) { switch (op_code) { case spv::Op::OpMemoryBarrier: case spv::Op::OpMemoryNamedBarrier: return true; default: return false; } } bool TransformationReplaceLoadStoreWithCopyMemory:: IsStorageClassSafeAcrossMemoryBarriers(spv::StorageClass storage_class) { switch (storage_class) { case spv::StorageClass::UniformConstant: case spv::StorageClass::Input: case spv::StorageClass::Uniform: case spv::StorageClass::Private: case spv::StorageClass::Function: return true; default: return false; } } protobufs::Transformation TransformationReplaceLoadStoreWithCopyMemory::ToMessage() const { protobufs::Transformation result; *result.mutable_replace_load_store_with_copy_memory() = message_; return result; } std::unordered_set TransformationReplaceLoadStoreWithCopyMemory::GetFreshIds() const { return std::unordered_set(); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_replace_load_store_with_copy_memory.h000066400000000000000000000062401475742701700336330ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_REPLACE_LOAD_STORE_WITH_COPY_MEMORY_H_ #define SOURCE_FUZZ_TRANSFORMATION_REPLACE_LOAD_STORE_WITH_COPY_MEMORY_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationReplaceLoadStoreWithCopyMemory : public Transformation { public: explicit TransformationReplaceLoadStoreWithCopyMemory( protobufs::TransformationReplaceLoadStoreWithCopyMemory message); TransformationReplaceLoadStoreWithCopyMemory( const protobufs::InstructionDescriptor& load_instruction_descriptor, const protobufs::InstructionDescriptor& store_instruction_descriptor); // - |message_.load_instruction_descriptor| must identify an OpLoad // instruction. // - |message_.store_instruction_descriptor| must identify an OpStore // instruction. // - The OpStore must write the intermediate value loaded by the OpLoad. // - The OpLoad and the OpStore must not have certain instruction in between // (checked by IsMemoryWritingOpCode(), IsMemoryBarrierOpCode(), // IsStorageClassSafeAcrossMemoryBarriers()). bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Takes a pair of instruction descriptors to OpLoad and OpStore that have the // same intermediate value and replaces the OpStore with an equivalent // OpCopyMemory. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; // Checks if the instruction that has an |op_code| might write to // the source operand of the OpLoad instruction. static bool IsMemoryWritingOpCode(spv::Op op_code); // Checks if the instruction that has an |op_code| is a memory barrier that // could interfere with the source operand of the OpLoad instruction static bool IsMemoryBarrierOpCode(spv::Op op_code); // Checks if the |storage_class| of the source operand of the OpLoad // instruction implies that this variable cannot change (due to other threads) // across memory barriers. static bool IsStorageClassSafeAcrossMemoryBarriers( spv::StorageClass storage_class); std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationReplaceLoadStoreWithCopyMemory message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_REPLACE_LOAD_STORE_WITH_COPY_MEMORY_H_ transformation_replace_opphi_id_from_dead_predecessor.cpp000066400000000000000000000102131475742701700344630ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/fuzz// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_replace_opphi_id_from_dead_predecessor.h" #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { TransformationReplaceOpPhiIdFromDeadPredecessor:: TransformationReplaceOpPhiIdFromDeadPredecessor( protobufs::TransformationReplaceOpPhiIdFromDeadPredecessor message) : message_(std::move(message)) {} TransformationReplaceOpPhiIdFromDeadPredecessor:: TransformationReplaceOpPhiIdFromDeadPredecessor(uint32_t opphi_id, uint32_t pred_label_id, uint32_t replacement_id) { message_.set_opphi_id(opphi_id); message_.set_pred_label_id(pred_label_id); message_.set_replacement_id(replacement_id); } bool TransformationReplaceOpPhiIdFromDeadPredecessor::IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const { // |opphi_id| must be the id of an OpPhi instruction. auto opphi_def = ir_context->get_def_use_mgr()->GetDef(message_.opphi_id()); if (!opphi_def || opphi_def->opcode() != spv::Op::OpPhi) { return false; } // |pred_label_id| must be the label id of a dead block. auto pred_block = ir_context->get_instr_block(message_.pred_label_id()); if (!pred_block || pred_block->id() != message_.pred_label_id() || !transformation_context.GetFactManager()->BlockIsDead(pred_block->id())) { return false; } // |pred_label_id| must be one of the predecessors of the block containing the // OpPhi instruction. bool found = false; for (auto pred : ir_context->cfg()->preds(ir_context->get_instr_block(opphi_def)->id())) { if (pred == message_.pred_label_id()) { found = true; break; } } if (!found) { return false; } // |replacement_id| must have the same type id as the OpPhi instruction. auto replacement_def = ir_context->get_def_use_mgr()->GetDef(message_.replacement_id()); if (!replacement_def || replacement_def->type_id() != opphi_def->type_id()) { return false; } // The replacement id must be available at the end of the predecessor. return fuzzerutil::IdIsAvailableBeforeInstruction( ir_context, pred_block->terminator(), replacement_def->result_id()); } void TransformationReplaceOpPhiIdFromDeadPredecessor::Apply( opt::IRContext* ir_context, TransformationContext* /* transformation_context */) const { // Get the OpPhi instruction. auto opphi_def = ir_context->get_def_use_mgr()->GetDef(message_.opphi_id()); // Find the index corresponding to the operand being replaced and replace it, // by looping through the odd-indexed input operands and finding // |pred_label_id|. The index that we are interested in is the one before // that. for (uint32_t i = 1; i < opphi_def->NumInOperands(); i += 2) { if (opphi_def->GetSingleWordInOperand(i) == message_.pred_label_id()) { // The operand to be replaced is at index i-1. opphi_def->SetInOperand(i - 1, {message_.replacement_id()}); } } // Invalidate the analyses because we have altered the usages of ids. ir_context->InvalidateAnalysesExceptFor(opt::IRContext::kAnalysisNone); } protobufs::Transformation TransformationReplaceOpPhiIdFromDeadPredecessor::ToMessage() const { protobufs::Transformation result; *result.mutable_replace_opphi_id_from_dead_predecessor() = message_; return result; } std::unordered_set TransformationReplaceOpPhiIdFromDeadPredecessor::GetFreshIds() const { return std::unordered_set(); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_replace_opphi_id_from_dead_predecessor.h000066400000000000000000000045451475742701700342220ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_REPLACE_OPPHI_ID_FROM_DEAD_PREDECESSOR_H_ #define SOURCE_FUZZ_TRANSFORMATION_REPLACE_OPPHI_ID_FROM_DEAD_PREDECESSOR_H_ #include "source/fuzz/transformation.h" namespace spvtools { namespace fuzz { class TransformationReplaceOpPhiIdFromDeadPredecessor : public Transformation { public: explicit TransformationReplaceOpPhiIdFromDeadPredecessor( protobufs::TransformationReplaceOpPhiIdFromDeadPredecessor message); TransformationReplaceOpPhiIdFromDeadPredecessor(uint32_t opphi_id, uint32_t pred_label_id, uint32_t replacement_id); // - |message_.opphi_id| is the id of an OpPhi instruction. // - |message_.pred_label_id| is the label id of one of the predecessors of // the block containing the OpPhi instruction. // - The predecessor has been recorded as dead. // - |message_.replacement_id| is the id of an instruction with the same type // as the OpPhi instruction, available at the end of the predecessor. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Replaces the id corresponding to predecessor |message_.pred_label_id|, in // the OpPhi instruction |message_.opphi_id|, with |message_.replacement_id|. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationReplaceOpPhiIdFromDeadPredecessor message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_REPLACE_OPPHI_ID_FROM_DEAD_PREDECESSOR_H_ transformation_replace_opselect_with_conditional_branch.cpp000066400000000000000000000175721475742701700350620ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/fuzz// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_replace_opselect_with_conditional_branch.h" #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { TransformationReplaceOpSelectWithConditionalBranch:: TransformationReplaceOpSelectWithConditionalBranch( protobufs::TransformationReplaceOpSelectWithConditionalBranch message) : message_(std::move(message)) {} TransformationReplaceOpSelectWithConditionalBranch:: TransformationReplaceOpSelectWithConditionalBranch( uint32_t select_id, uint32_t true_block_id, uint32_t false_block_id) { message_.set_select_id(select_id); message_.set_true_block_id(true_block_id); message_.set_false_block_id(false_block_id); } bool TransformationReplaceOpSelectWithConditionalBranch::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /* unused */) const { assert((message_.true_block_id() || message_.false_block_id()) && "At least one of the ids must be non-zero."); // Check that the non-zero ids are fresh. std::set used_ids; for (uint32_t id : {message_.true_block_id(), message_.false_block_id()}) { if (id && !CheckIdIsFreshAndNotUsedByThisTransformation(id, ir_context, &used_ids)) { return false; } } auto instruction = ir_context->get_def_use_mgr()->GetDef(message_.select_id()); // The instruction must exist and it must be an OpSelect instruction. if (!instruction || instruction->opcode() != spv::Op::OpSelect) { return false; } // Check that the condition is a scalar boolean. auto condition = ir_context->get_def_use_mgr()->GetDef( instruction->GetSingleWordInOperand(0)); assert(condition && "The condition should always exist in a valid module."); auto condition_type = ir_context->get_type_mgr()->GetType(condition->type_id()); if (!condition_type->AsBool()) { return false; } auto block = ir_context->get_instr_block(instruction); assert(block && "The block containing the instruction must be found"); // The instruction must be the first in its block. if (instruction->unique_id() != block->begin()->unique_id()) { return false; } // The block must not be a merge block. if (ir_context->GetStructuredCFGAnalysis()->IsMergeBlock(block->id())) { return false; } // The block must have exactly one predecessor. auto predecessors = ir_context->cfg()->preds(block->id()); if (predecessors.size() != 1) { return false; } uint32_t pred_id = predecessors[0]; auto predecessor = ir_context->get_instr_block(pred_id); // The predecessor must not be the header of a construct and it must end with // OpBranch. if (predecessor->GetMergeInst() != nullptr || predecessor->terminator()->opcode() != spv::Op::OpBranch) { return false; } return true; } void TransformationReplaceOpSelectWithConditionalBranch::Apply( opt::IRContext* ir_context, TransformationContext* /* unused */) const { auto instruction = ir_context->get_def_use_mgr()->GetDef(message_.select_id()); auto block = ir_context->get_instr_block(instruction); auto predecessor = ir_context->get_instr_block(ir_context->cfg()->preds(block->id())[0]); // Create a new block for each non-zero id in {|message_.true_branch_id|, // |message_.false_branch_id|}. Make each newly-created block branch // unconditionally to the instruction block. for (uint32_t id : {message_.true_block_id(), message_.false_block_id()}) { if (id) { fuzzerutil::UpdateModuleIdBound(ir_context, id); // Create the new block. auto new_block = MakeUnique( MakeUnique(ir_context, spv::Op::OpLabel, 0, id, opt::Instruction::OperandList{})); // Add an unconditional branch from the new block to the instruction // block. new_block->AddInstruction(MakeUnique( ir_context, spv::Op::OpBranch, 0, 0, opt::Instruction::OperandList{{SPV_OPERAND_TYPE_ID, {block->id()}}})); // Insert the new block right after the predecessor of the instruction // block. block->GetParent()->InsertBasicBlockBefore(std::move(new_block), block); } } // Delete the OpBranch instruction from the predecessor. ir_context->KillInst(predecessor->terminator()); // Add an OpSelectionMerge instruction to the predecessor block, where the // merge block is the instruction block. predecessor->AddInstruction(MakeUnique( ir_context, spv::Op::OpSelectionMerge, 0, 0, opt::Instruction::OperandList{ {SPV_OPERAND_TYPE_ID, {block->id()}}, {SPV_OPERAND_TYPE_SELECTION_CONTROL, {uint32_t(spv::SelectionControlMask::MaskNone)}}})); // |if_block| will be the true block, if it has been created, the instruction // block otherwise. uint32_t if_block = message_.true_block_id() ? message_.true_block_id() : block->id(); // |else_block| will be the false block, if it has been created, the // instruction block otherwise. uint32_t else_block = message_.false_block_id() ? message_.false_block_id() : block->id(); assert(if_block != else_block && "|if_block| and |else_block| should always be different, if the " "transformation is applicable."); // Add a conditional branching instruction to the predecessor, branching to // |if_block| if the condition is true and to |if_false| otherwise. predecessor->AddInstruction(MakeUnique( ir_context, spv::Op::OpBranchConditional, 0, 0, opt::Instruction::OperandList{ {SPV_OPERAND_TYPE_ID, {instruction->GetSingleWordInOperand(0)}}, {SPV_OPERAND_TYPE_ID, {if_block}}, {SPV_OPERAND_TYPE_ID, {else_block}}})); // |if_pred| will be the true block, if it has been created, the existing // predecessor otherwise. uint32_t if_pred = message_.true_block_id() ? message_.true_block_id() : predecessor->id(); // |else_pred| will be the false block, if it has been created, the existing // predecessor otherwise. uint32_t else_pred = message_.false_block_id() ? message_.false_block_id() : predecessor->id(); // Replace the OpSelect instruction in the merge block with an OpPhi. // This: OpSelect %type %cond %if %else // will become: OpPhi %type %if %if_pred %else %else_pred instruction->SetOpcode(spv::Op::OpPhi); std::vector operands; operands.emplace_back(instruction->GetInOperand(1)); operands.emplace_back(opt::Operand{SPV_OPERAND_TYPE_ID, {if_pred}}); operands.emplace_back(instruction->GetInOperand(2)); operands.emplace_back(opt::Operand{SPV_OPERAND_TYPE_ID, {else_pred}}); instruction->SetInOperands(std::move(operands)); // Invalidate all analyses, since the structure of the module was changed. ir_context->InvalidateAnalysesExceptFor(opt::IRContext::kAnalysisNone); } protobufs::Transformation TransformationReplaceOpSelectWithConditionalBranch::ToMessage() const { protobufs::Transformation result; *result.mutable_replace_opselect_with_conditional_branch() = message_; return result; } std::unordered_set TransformationReplaceOpSelectWithConditionalBranch::GetFreshIds() const { return {message_.true_block_id(), message_.false_block_id()}; } } // namespace fuzz } // namespace spvtools transformation_replace_opselect_with_conditional_branch.h000066400000000000000000000047761475742701700345310ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/fuzz// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_REPLACE_OPSELECT_WITH_CONDITIONAL_BRANCH_H #define SOURCE_FUZZ_TRANSFORMATION_REPLACE_OPSELECT_WITH_CONDITIONAL_BRANCH_H #include "source/fuzz/transformation.h" namespace spvtools { namespace fuzz { class TransformationReplaceOpSelectWithConditionalBranch : public Transformation { public: explicit TransformationReplaceOpSelectWithConditionalBranch( protobufs::TransformationReplaceOpSelectWithConditionalBranch message); TransformationReplaceOpSelectWithConditionalBranch(uint32_t select_id, uint32_t true_block_id, uint32_t false_block_id); // - |message_.select_id| is the result id of an OpSelect instruction. // - The condition of the OpSelect must be a scalar boolean. // - The OpSelect instruction is the first instruction in its block. // - The block containing the instruction is not a merge block, and it has a // single predecessor, which is not a header and whose last instruction is // OpBranch. // - Each of |message_.true_block_id| and |message_.false_block_id| is either // 0 or a valid fresh id, and at most one of them is 0. They must be // distinct. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Replaces the OpSelect instruction with id |message_.select_id| with a // conditional branch and an OpPhi instruction. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationReplaceOpSelectWithConditionalBranch message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_REPLACE_OPSELECT_WITH_CONDITIONAL_BRANCH_H KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_replace_parameter_with_global.cpp000066400000000000000000000201451475742701700327110ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_replace_parameter_with_global.h" #include #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { TransformationReplaceParameterWithGlobal:: TransformationReplaceParameterWithGlobal( protobufs::TransformationReplaceParameterWithGlobal message) : message_(std::move(message)) {} TransformationReplaceParameterWithGlobal:: TransformationReplaceParameterWithGlobal( uint32_t function_type_fresh_id, uint32_t parameter_id, uint32_t global_variable_fresh_id) { message_.set_function_type_fresh_id(function_type_fresh_id); message_.set_parameter_id(parameter_id); message_.set_global_variable_fresh_id(global_variable_fresh_id); } bool TransformationReplaceParameterWithGlobal::IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const { // Check that |parameter_id| is valid. const auto* param_inst = ir_context->get_def_use_mgr()->GetDef(message_.parameter_id()); if (!param_inst || param_inst->opcode() != spv::Op::OpFunctionParameter) { return false; } // Check that function exists and is not an entry point. const auto* function = fuzzerutil::GetFunctionFromParameterId( ir_context, message_.parameter_id()); if (!function || fuzzerutil::FunctionIsEntryPoint(ir_context, function->result_id())) { return false; } // We already know that the function has at least one parameter - // |parameter_id|. // Check that replaced parameter has valid type. if (!IsParameterTypeSupported(ir_context, param_inst->type_id())) { return false; } // Check that initializer for the global variable exists in the module. if (fuzzerutil::MaybeGetZeroConstant(ir_context, transformation_context, param_inst->type_id(), false) == 0) { return false; } // Check that pointer type for the global variable exists in the module. if (!fuzzerutil::MaybeGetPointerType(ir_context, param_inst->type_id(), spv::StorageClass::Private)) { return false; } return fuzzerutil::IsFreshId(ir_context, message_.function_type_fresh_id()) && fuzzerutil::IsFreshId(ir_context, message_.global_variable_fresh_id()) && message_.function_type_fresh_id() != message_.global_variable_fresh_id(); } void TransformationReplaceParameterWithGlobal::Apply( opt::IRContext* ir_context, TransformationContext* transformation_context) const { const auto* param_inst = ir_context->get_def_use_mgr()->GetDef(message_.parameter_id()); assert(param_inst && "Parameter must exist"); // Create global variable to store parameter's value. fuzzerutil::AddGlobalVariable( ir_context, message_.global_variable_fresh_id(), fuzzerutil::MaybeGetPointerType(ir_context, param_inst->type_id(), spv::StorageClass::Private), spv::StorageClass::Private, fuzzerutil::MaybeGetZeroConstant(ir_context, *transformation_context, param_inst->type_id(), false)); auto* function = fuzzerutil::GetFunctionFromParameterId( ir_context, message_.parameter_id()); assert(function && "Function must exist"); // Insert an OpLoad instruction right after OpVariable instructions. auto it = function->begin()->begin(); while (it != function->begin()->end() && !fuzzerutil::CanInsertOpcodeBeforeInstruction(spv::Op::OpLoad, it)) { ++it; } assert(fuzzerutil::CanInsertOpcodeBeforeInstruction(spv::Op::OpLoad, it) && "Can't insert OpLoad or OpCopyMemory into the first basic block of " "the function"); it.InsertBefore(MakeUnique( ir_context, spv::Op::OpLoad, param_inst->type_id(), param_inst->result_id(), opt::Instruction::OperandList{ {SPV_OPERAND_TYPE_ID, {message_.global_variable_fresh_id()}}})); // Calculate the index of the replaced parameter (we need to know this to // remove operands from the OpFunctionCall). auto params = fuzzerutil::GetParameters(ir_context, function->result_id()); auto parameter_index = static_cast(params.size()); for (uint32_t i = 0, n = static_cast(params.size()); i < n; ++i) { if (params[i]->result_id() == message_.parameter_id()) { parameter_index = i; break; } } assert(parameter_index != params.size() && "Parameter must exist in the function"); // Update all relevant OpFunctionCall instructions. for (auto* inst : fuzzerutil::GetCallers(ir_context, function->result_id())) { assert( fuzzerutil::CanInsertOpcodeBeforeInstruction(spv::Op::OpStore, inst) && "Can't insert OpStore right before the function call"); // Insert an OpStore before the OpFunctionCall. +1 since the first // operand of OpFunctionCall is an id of the function. inst->InsertBefore(MakeUnique( ir_context, spv::Op::OpStore, 0, 0, opt::Instruction::OperandList{ {SPV_OPERAND_TYPE_ID, {message_.global_variable_fresh_id()}}, {SPV_OPERAND_TYPE_ID, {inst->GetSingleWordInOperand(parameter_index + 1)}}})); // +1 since the first operand of OpFunctionCall is an id of the // function. inst->RemoveInOperand(parameter_index + 1); } // Remove the parameter from the function. fuzzerutil::RemoveParameter(ir_context, message_.parameter_id()); // Update function's type. { // We use a separate scope here since |old_function_type| might become a // dangling pointer after the call to the fuzzerutil::UpdateFunctionType. auto* old_function_type = fuzzerutil::GetFunctionType(ir_context, function); assert(old_function_type && "Function has invalid type"); // +1 and -1 since the first operand is the return type id. std::vector parameter_type_ids; for (uint32_t i = 1; i < old_function_type->NumInOperands(); ++i) { if (i - 1 != parameter_index) { parameter_type_ids.push_back( old_function_type->GetSingleWordInOperand(i)); } } fuzzerutil::UpdateFunctionType( ir_context, function->result_id(), message_.function_type_fresh_id(), old_function_type->GetSingleWordInOperand(0), parameter_type_ids); } // Make sure our changes are analyzed ir_context->InvalidateAnalysesExceptFor( opt::IRContext::Analysis::kAnalysisNone); // Mark the pointee of the global variable storing the parameter's value as // irrelevant if replaced parameter is irrelevant. if (transformation_context->GetFactManager()->IdIsIrrelevant( message_.parameter_id())) { transformation_context->GetFactManager()->AddFactValueOfPointeeIsIrrelevant( message_.global_variable_fresh_id()); } } protobufs::Transformation TransformationReplaceParameterWithGlobal::ToMessage() const { protobufs::Transformation result; *result.mutable_replace_parameter_with_global() = message_; return result; } bool TransformationReplaceParameterWithGlobal::IsParameterTypeSupported( opt::IRContext* ir_context, uint32_t param_type_id) { // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/3403): // Think about other type instructions we can add here. return fuzzerutil::CanCreateConstant(ir_context, param_type_id); } std::unordered_set TransformationReplaceParameterWithGlobal::GetFreshIds() const { return {message_.function_type_fresh_id(), message_.global_variable_fresh_id()}; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_replace_parameter_with_global.h000066400000000000000000000054641475742701700323650ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_REPLACE_PARAMETER_WITH_GLOBAL_H_ #define SOURCE_FUZZ_TRANSFORMATION_REPLACE_PARAMETER_WITH_GLOBAL_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationReplaceParameterWithGlobal : public Transformation { public: explicit TransformationReplaceParameterWithGlobal( protobufs::TransformationReplaceParameterWithGlobal message); TransformationReplaceParameterWithGlobal(uint32_t function_type_fresh_id, uint32_t parameter_id, uint32_t global_variable_fresh_id); // - |function_type_fresh_id| is a fresh id. // - |parameter_id| is the result id of the parameter to replace. // - |global_variable_fresh_id| is a fresh id. // - |function_type_fresh_id| is not equal to |global_variable_fresh_id|. // - the function that contains |parameter_id| may not be an entry-point // function. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // - Removes parameter with result id |parameter_id| from its function // - Adds a global variable to store the value for the parameter // - Add an OpStore instruction before each function call to // store parameter's value into the variable // - Adds OpLoad at the beginning of the function to load the // value from the variable into the old parameter's id void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; // Returns true if the type of the parameter is supported by this // transformation. static bool IsParameterTypeSupported(opt::IRContext* ir_context, uint32_t param_type_id); private: protobufs::TransformationReplaceParameterWithGlobal message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_REPLACE_PARAMETER_WITH_GLOBAL_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_replace_params_with_struct.cpp000066400000000000000000000277011475742701700323050ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_replace_params_with_struct.h" #include #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { TransformationReplaceParamsWithStruct::TransformationReplaceParamsWithStruct( protobufs::TransformationReplaceParamsWithStruct message) : message_(std::move(message)) {} TransformationReplaceParamsWithStruct::TransformationReplaceParamsWithStruct( const std::vector& parameter_id, uint32_t fresh_function_type_id, uint32_t fresh_parameter_id, const std::map& caller_id_to_fresh_composite_id) { message_.set_fresh_function_type_id(fresh_function_type_id); message_.set_fresh_parameter_id(fresh_parameter_id); for (auto id : parameter_id) { message_.add_parameter_id(id); } *message_.mutable_caller_id_to_fresh_composite_id() = fuzzerutil::MapToRepeatedUInt32Pair(caller_id_to_fresh_composite_id); } bool TransformationReplaceParamsWithStruct::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { std::vector parameter_id(message_.parameter_id().begin(), message_.parameter_id().end()); // Check that |parameter_id| is neither empty nor it has duplicates. if (parameter_id.empty() || fuzzerutil::HasDuplicates(parameter_id)) { return false; } // All ids must correspond to valid parameters of the same function. // The function can't be an entry-point function. // fuzzerutil::GetFunctionFromParameterId requires a valid id. if (!ir_context->get_def_use_mgr()->GetDef(parameter_id[0])) { return false; } const auto* function = fuzzerutil::GetFunctionFromParameterId(ir_context, parameter_id[0]); if (!function || fuzzerutil::FunctionIsEntryPoint(ir_context, function->result_id())) { return false; } // Compute all ids of the function's parameters. std::unordered_set all_parameter_ids; for (const auto* param : fuzzerutil::GetParameters(ir_context, function->result_id())) { all_parameter_ids.insert(param->result_id()); } // Check that all elements in |parameter_id| are valid. for (auto id : parameter_id) { // fuzzerutil::GetFunctionFromParameterId requires a valid id. if (!ir_context->get_def_use_mgr()->GetDef(id)) { return false; } // Check that |id| is a result id of one of the |function|'s parameters. if (!all_parameter_ids.count(id)) { return false; } // Check that the parameter with result id |id| has supported type. if (!IsParameterTypeSupported(ir_context, fuzzerutil::GetTypeId(ir_context, id))) { return false; } } // We already know that the function has at least |parameter_id.size()| // parameters. // Check that a relevant OpTypeStruct exists in the module. if (!MaybeGetRequiredStructType(ir_context)) { return false; } const auto caller_id_to_fresh_composite_id = fuzzerutil::RepeatedUInt32PairToMap( message_.caller_id_to_fresh_composite_id()); // Check that |callee_id_to_fresh_composite_id| is valid. for (const auto* inst : fuzzerutil::GetCallers(ir_context, function->result_id())) { // Check that the callee is present in the map. It's ok if the map contains // more ids that there are callees (those ids will not be used). if (!caller_id_to_fresh_composite_id.count(inst->result_id())) { return false; } } // Check that all fresh ids are unique and fresh. std::vector fresh_ids = {message_.fresh_function_type_id(), message_.fresh_parameter_id()}; for (const auto& entry : caller_id_to_fresh_composite_id) { fresh_ids.push_back(entry.second); } return !fuzzerutil::HasDuplicates(fresh_ids) && std::all_of(fresh_ids.begin(), fresh_ids.end(), [ir_context](uint32_t id) { return fuzzerutil::IsFreshId(ir_context, id); }); } void TransformationReplaceParamsWithStruct::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { auto* function = fuzzerutil::GetFunctionFromParameterId( ir_context, message_.parameter_id(0)); assert(function && "All parameters' ids should've been checked in the IsApplicable"); // Get a type id of the OpTypeStruct used as a type id of the new parameter. auto struct_type_id = MaybeGetRequiredStructType(ir_context); assert(struct_type_id && "IsApplicable should've guaranteed that this value isn't equal to 0"); // Add new parameter to the function. function->AddParameter(MakeUnique( ir_context, spv::Op::OpFunctionParameter, struct_type_id, message_.fresh_parameter_id(), opt::Instruction::OperandList())); fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_parameter_id()); // Compute indices of replaced parameters. This will be used to adjust // OpFunctionCall instructions and create OpCompositeConstruct instructions at // every call site. const auto indices_of_replaced_params = ComputeIndicesOfReplacedParameters(ir_context); const auto caller_id_to_fresh_composite_id = fuzzerutil::RepeatedUInt32PairToMap( message_.caller_id_to_fresh_composite_id()); // Update all function calls. for (auto* inst : fuzzerutil::GetCallers(ir_context, function->result_id())) { // Create a list of operands for the OpCompositeConstruct instruction. opt::Instruction::OperandList composite_components; for (auto index : indices_of_replaced_params) { // +1 since the first in operand to OpFunctionCall is the result id of // the function. composite_components.emplace_back( std::move(inst->GetInOperand(index + 1))); } // Remove arguments from the function call. We do it in a separate loop // and in decreasing order to make sure we have removed correct operands. for (auto index : std::set>( indices_of_replaced_params.begin(), indices_of_replaced_params.end())) { // +1 since the first in operand to OpFunctionCall is the result id of // the function. inst->RemoveInOperand(index + 1); } // Insert OpCompositeConstruct before the function call. auto fresh_composite_id = caller_id_to_fresh_composite_id.at(inst->result_id()); inst->InsertBefore(MakeUnique( ir_context, spv::Op::OpCompositeConstruct, struct_type_id, fresh_composite_id, std::move(composite_components))); // Add a new operand to the OpFunctionCall instruction. inst->AddOperand({SPV_OPERAND_TYPE_ID, {fresh_composite_id}}); fuzzerutil::UpdateModuleIdBound(ir_context, fresh_composite_id); } // Insert OpCompositeExtract instructions into the entry point block of the // function and remove replaced parameters. for (int i = 0; i < message_.parameter_id_size(); ++i) { const auto* param_inst = ir_context->get_def_use_mgr()->GetDef(message_.parameter_id(i)); assert(param_inst && "Parameter id is invalid"); // Skip all OpVariable instructions. auto iter = function->begin()->begin(); while (iter != function->begin()->end() && !fuzzerutil::CanInsertOpcodeBeforeInstruction( spv::Op::OpCompositeExtract, iter)) { ++iter; } assert(fuzzerutil::CanInsertOpcodeBeforeInstruction( spv::Op::OpCompositeExtract, iter) && "Can't extract parameter's value from the structure"); // Insert OpCompositeExtract instructions to unpack parameters' values from // the struct type. iter.InsertBefore(MakeUnique( ir_context, spv::Op::OpCompositeExtract, param_inst->type_id(), param_inst->result_id(), opt::Instruction::OperandList{ {SPV_OPERAND_TYPE_ID, {message_.fresh_parameter_id()}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {static_cast(i)}}})); fuzzerutil::RemoveParameter(ir_context, param_inst->result_id()); } // Update function's type. { // We use a separate scope here since |old_function_type| might become a // dangling pointer after the call to the fuzzerutil::UpdateFunctionType. auto* old_function_type = fuzzerutil::GetFunctionType(ir_context, function); assert(old_function_type && "Function has invalid type"); // +1 since the first in operand to OpTypeFunction is the result type id // of the function. std::vector parameter_type_ids; for (uint32_t i = 1; i < old_function_type->NumInOperands(); ++i) { if (std::find(indices_of_replaced_params.begin(), indices_of_replaced_params.end(), i - 1) == indices_of_replaced_params.end()) { parameter_type_ids.push_back( old_function_type->GetSingleWordInOperand(i)); } } parameter_type_ids.push_back(struct_type_id); fuzzerutil::UpdateFunctionType( ir_context, function->result_id(), message_.fresh_function_type_id(), old_function_type->GetSingleWordInOperand(0), parameter_type_ids); } // Make sure our changes are analyzed ir_context->InvalidateAnalysesExceptFor( opt::IRContext::Analysis::kAnalysisNone); } protobufs::Transformation TransformationReplaceParamsWithStruct::ToMessage() const { protobufs::Transformation result; *result.mutable_replace_params_with_struct() = message_; return result; } bool TransformationReplaceParamsWithStruct::IsParameterTypeSupported( opt::IRContext* ir_context, uint32_t param_type_id) { // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/3403): // Consider adding support for more types of parameters. return fuzzerutil::CanCreateConstant(ir_context, param_type_id); } uint32_t TransformationReplaceParamsWithStruct::MaybeGetRequiredStructType( opt::IRContext* ir_context) const { std::vector component_type_ids; for (auto id : message_.parameter_id()) { component_type_ids.push_back(fuzzerutil::GetTypeId(ir_context, id)); } return fuzzerutil::MaybeGetStructType(ir_context, component_type_ids); } std::vector TransformationReplaceParamsWithStruct::ComputeIndicesOfReplacedParameters( opt::IRContext* ir_context) const { assert(!message_.parameter_id().empty() && "There must be at least one parameter to replace"); const auto* function = fuzzerutil::GetFunctionFromParameterId( ir_context, message_.parameter_id(0)); assert(function && "|parameter_id|s are invalid"); std::vector result; auto params = fuzzerutil::GetParameters(ir_context, function->result_id()); for (auto id : message_.parameter_id()) { auto it = std::find_if(params.begin(), params.end(), [id](const opt::Instruction* param) { return param->result_id() == id; }); assert(it != params.end() && "Parameter's id is invalid"); result.push_back(static_cast(it - params.begin())); } return result; } std::unordered_set TransformationReplaceParamsWithStruct::GetFreshIds() const { std::unordered_set result = {message_.fresh_function_type_id(), message_.fresh_parameter_id()}; for (auto& pair : message_.caller_id_to_fresh_composite_id()) { result.insert(pair.second()); } return result; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_replace_params_with_struct.h000066400000000000000000000076751475742701700317620ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_REPLACE_PARAMS_WITH_STRUCT_H_ #define SOURCE_FUZZ_TRANSFORMATION_REPLACE_PARAMS_WITH_STRUCT_H_ #include #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationReplaceParamsWithStruct : public Transformation { public: explicit TransformationReplaceParamsWithStruct( protobufs::TransformationReplaceParamsWithStruct message); TransformationReplaceParamsWithStruct( const std::vector& parameter_id, uint32_t fresh_function_type_id, uint32_t fresh_parameter_id, const std::map& caller_id_to_fresh_composite_id); // - Each element of |parameter_id| is a valid result id of some // OpFunctionParameter instruction. All parameter ids must correspond to // parameters of the same function. That function may not be an entry-point // function. // - Types of all parameters must be supported by this transformation (see // IsParameterTypeSupported method). // - |parameter_id| may not be empty or contain duplicates. // - There must exist an OpTypeStruct instruction containing types of all // replaced parameters. Type of the i'th component of the struct is equal // to the type of the instruction with result id |parameter_id[i]|. // - |caller_id_to_fresh_composite_id| should contain a key for at least every // result id of an OpFunctionCall instruction that calls the function. // - |fresh_function_type_id|, |fresh_parameter_id|, // |caller_id_to_fresh_composite_id| are all fresh and unique ids. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // - Creates a new function parameter with result id |fresh_parameter_id|. // Parameter's type is OpTypeStruct with each components type equal to the // type of the replaced parameter. // - OpCompositeConstruct with result id from |fresh_composite_id| is inserted // before each OpFunctionCall instruction. // - OpCompositeExtract with result id equal to the result id of the replaced // parameter is created in the function. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; // Returns true if parameter's type is supported by this transformation. static bool IsParameterTypeSupported(opt::IRContext* ir_context, uint32_t param_type_id); private: // Returns a result id of the OpTypeStruct instruction required by this // transformation (see docs on the IsApplicable method to learn more). uint32_t MaybeGetRequiredStructType(opt::IRContext* ir_context) const; // Returns a vector of indices of parameters to replace. Concretely, i'th // element is the index of the parameter with result id |parameter_id[i]| in // its function. std::vector ComputeIndicesOfReplacedParameters( opt::IRContext* ir_context) const; protobufs::TransformationReplaceParamsWithStruct message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_REPLACE_PARAMS_WITH_STRUCT_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_set_function_control.cpp000066400000000000000000000100331475742701700311160ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_set_function_control.h" namespace spvtools { namespace fuzz { TransformationSetFunctionControl::TransformationSetFunctionControl( protobufs::TransformationSetFunctionControl message) : message_(std::move(message)) {} TransformationSetFunctionControl::TransformationSetFunctionControl( uint32_t function_id, uint32_t function_control) { message_.set_function_id(function_id); message_.set_function_control(function_control); } bool TransformationSetFunctionControl::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { opt::Instruction* function_def_instruction = FindFunctionDefInstruction(ir_context); if (!function_def_instruction) { // The given function id does not correspond to any function. return false; } uint32_t existing_function_control_mask = function_def_instruction->GetSingleWordInOperand(0); // Check (via an assertion) that function control mask doesn't have any bad // bits set. uint32_t acceptable_function_control_bits = uint32_t( spv::FunctionControlMask::Inline | spv::FunctionControlMask::DontInline | spv::FunctionControlMask::Pure | spv::FunctionControlMask::Const); // The following is to keep release-mode compilers happy as this variable is // only used in an assertion. (void)(acceptable_function_control_bits); assert(!(message_.function_control() & ~acceptable_function_control_bits) && "Nonsensical loop control bits were found."); // Check (via an assertion) that function control mask does not have both // Inline and DontInline bits set. assert(!((message_.function_control() & (uint32_t)spv::FunctionControlMask::Inline) && (message_.function_control() & (uint32_t)spv::FunctionControlMask::DontInline)) && "It is not OK to set both the 'Inline' and 'DontInline' bits of a " "function control mask"); // Check that Const and Pure are only present if they were present on the // original function for (auto mask_bit : {spv::FunctionControlMask::Pure, spv::FunctionControlMask::Const}) { if ((message_.function_control() & uint32_t(mask_bit)) && !(existing_function_control_mask & uint32_t(mask_bit))) { return false; } } return true; } void TransformationSetFunctionControl::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { opt::Instruction* function_def_instruction = FindFunctionDefInstruction(ir_context); function_def_instruction->SetInOperand(0, {message_.function_control()}); } protobufs::Transformation TransformationSetFunctionControl::ToMessage() const { protobufs::Transformation result; *result.mutable_set_function_control() = message_; return result; } opt::Instruction* TransformationSetFunctionControl ::FindFunctionDefInstruction( opt::IRContext* ir_context) const { // Look through all functions for a function whose defining instruction's // result id matches |message_.function_id|, returning the defining // instruction if found. for (auto& function : *ir_context->module()) { if (function.DefInst().result_id() == message_.function_id()) { return &function.DefInst(); } } // A nullptr result indicates that no match was found. return nullptr; } std::unordered_set TransformationSetFunctionControl::GetFreshIds() const { return std::unordered_set(); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_set_function_control.h000066400000000000000000000044671475742701700306010ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_SET_FUNCTION_CONTROL_H_ #define SOURCE_FUZZ_TRANSFORMATION_SET_FUNCTION_CONTROL_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationSetFunctionControl : public Transformation { public: explicit TransformationSetFunctionControl( protobufs::TransformationSetFunctionControl message); TransformationSetFunctionControl(uint32_t function_id, uint32_t function_control); // - |message_.function_id| must be the result id of an OpFunction // instruction. // - |message_.function_control| must be a function control mask that sets // at most one of 'Inline' or 'DontInline', and that may not contain 'Pure' // (respectively 'Const') unless the existing function control mask contains // 'Pure' (respectively 'Const'). bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // The function control operand of instruction |message_.function_id| is // over-written with |message_.function_control|. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: opt::Instruction* FindFunctionDefInstruction( opt::IRContext* ir_context) const; protobufs::TransformationSetFunctionControl message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_SET_FUNCTION_CONTROL_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_set_loop_control.cpp000066400000000000000000000221371475742701700302520ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_set_loop_control.h" namespace spvtools { namespace fuzz { TransformationSetLoopControl::TransformationSetLoopControl( protobufs::TransformationSetLoopControl message) : message_(std::move(message)) {} TransformationSetLoopControl::TransformationSetLoopControl( uint32_t block_id, uint32_t loop_control, uint32_t peel_count, uint32_t partial_count) { message_.set_block_id(block_id); message_.set_loop_control(loop_control); message_.set_peel_count(peel_count); message_.set_partial_count(partial_count); } bool TransformationSetLoopControl::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { // |message_.block_id| must identify a block that ends with OpLoopMerge. auto block = ir_context->get_instr_block(message_.block_id()); if (!block) { return false; } auto merge_inst = block->GetMergeInst(); if (!merge_inst || merge_inst->opcode() != spv::Op::OpLoopMerge) { return false; } // We assert that the transformation does not try to set any meaningless bits // of the loop control mask. uint32_t all_loop_control_mask_bits_set = uint32_t( spv::LoopControlMask::Unroll | spv::LoopControlMask::DontUnroll | spv::LoopControlMask::DependencyInfinite | spv::LoopControlMask::DependencyLength | spv::LoopControlMask::MinIterations | spv::LoopControlMask::MaxIterations | spv::LoopControlMask::IterationMultiple | spv::LoopControlMask::PeelCount | spv::LoopControlMask::PartialCount); // The variable is only used in an assertion; the following keeps release-mode // compilers happy. (void)(all_loop_control_mask_bits_set); // No additional bits should be set. assert(!(message_.loop_control() & ~all_loop_control_mask_bits_set)); // Grab the loop control mask currently associated with the OpLoopMerge // instruction. auto existing_loop_control_mask = merge_inst->GetSingleWordInOperand(kLoopControlMaskInOperandIndex); // Check that there is no attempt to set one of the loop controls that // requires guarantees to hold. for (spv::LoopControlMask mask : {spv::LoopControlMask::DependencyInfinite, spv::LoopControlMask::DependencyLength, spv::LoopControlMask::MinIterations, spv::LoopControlMask::MaxIterations, spv::LoopControlMask::IterationMultiple}) { // We have a problem if this loop control bit was not set in the original // loop control mask but is set by the transformation. if (LoopControlBitIsAddedByTransformation(mask, existing_loop_control_mask)) { return false; } } // Check that PeelCount and PartialCount are supported if used. if ((message_.loop_control() & uint32_t(spv::LoopControlMask::PeelCount)) && !PeelCountIsSupported(ir_context)) { return false; } if ((message_.loop_control() & uint32_t(spv::LoopControlMask::PartialCount)) && !PartialCountIsSupported(ir_context)) { return false; } if (message_.peel_count() > 0 && !(message_.loop_control() & uint32_t(spv::LoopControlMask::PeelCount))) { // Peel count provided, but peel count mask bit not set. return false; } if (message_.partial_count() > 0 && !(message_.loop_control() & uint32_t(spv::LoopControlMask::PartialCount))) { // Partial count provided, but partial count mask bit not set. return false; } // We must not set both 'don't unroll' and one of 'peel count' or 'partial // count'. return !( (message_.loop_control() & uint32_t(spv::LoopControlMask::DontUnroll)) && (message_.loop_control() & uint32_t(spv::LoopControlMask::PeelCount | spv::LoopControlMask::PartialCount))); } void TransformationSetLoopControl::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { // Grab the loop merge instruction and its associated loop control mask. auto merge_inst = ir_context->get_instr_block(message_.block_id())->GetMergeInst(); auto existing_loop_control_mask = merge_inst->GetSingleWordInOperand(kLoopControlMaskInOperandIndex); // We are going to replace the OpLoopMerge's operands with this list. opt::Instruction::OperandList new_operands; // We add the existing merge block and continue target ids. new_operands.push_back(merge_inst->GetInOperand(0)); new_operands.push_back(merge_inst->GetInOperand(1)); // We use the loop control mask from the transformation. new_operands.push_back( {SPV_OPERAND_TYPE_LOOP_CONTROL, {message_.loop_control()}}); // It remains to determine what literals to provide, in association with // the new loop control mask. // // For the loop controls that require guarantees to hold about the number // of loop iterations, we need to keep, from the original OpLoopMerge, any // literals associated with loop control bits that are still set. uint32_t literal_index = 0; // Indexes into the literals from the original // instruction. for (spv::LoopControlMask mask : {spv::LoopControlMask::DependencyLength, spv::LoopControlMask::MinIterations, spv::LoopControlMask::MaxIterations, spv::LoopControlMask::IterationMultiple}) { // Check whether the bit was set in the original loop control mask. if (existing_loop_control_mask & uint32_t(mask)) { // Check whether the bit is set in the new loop control mask. if (message_.loop_control() & uint32_t(mask)) { // Add the associated literal to our sequence of replacement operands. new_operands.push_back( {SPV_OPERAND_TYPE_LITERAL_INTEGER, {merge_inst->GetSingleWordInOperand( kLoopControlFirstLiteralInOperandIndex + literal_index)}}); } // Increment our index into the original loop control mask's literals, // whether or not the bit was set in the new mask. literal_index++; } } // If PeelCount is set in the new mask, |message_.peel_count| provides the // associated peel count. if (message_.loop_control() & uint32_t(spv::LoopControlMask::PeelCount)) { new_operands.push_back( {SPV_OPERAND_TYPE_LITERAL_INTEGER, {message_.peel_count()}}); } // Similar, but for PartialCount. if (message_.loop_control() & uint32_t(spv::LoopControlMask::PartialCount)) { new_operands.push_back( {SPV_OPERAND_TYPE_LITERAL_INTEGER, {message_.partial_count()}}); } // Replace the input operands of the OpLoopMerge with the new operands we have // accumulated. merge_inst->SetInOperands(std::move(new_operands)); } protobufs::Transformation TransformationSetLoopControl::ToMessage() const { protobufs::Transformation result; *result.mutable_set_loop_control() = message_; return result; } bool TransformationSetLoopControl::LoopControlBitIsAddedByTransformation( spv::LoopControlMask loop_control_single_bit_mask, uint32_t existing_loop_control_mask) const { return !(uint32_t(loop_control_single_bit_mask) & existing_loop_control_mask) && (uint32_t(loop_control_single_bit_mask) & message_.loop_control()); } bool TransformationSetLoopControl::PartialCountIsSupported( opt::IRContext* ir_context) { // TODO(afd): We capture the environments for which this loop control is // definitely not supported. The check should be refined on demand for other // target environments. switch (ir_context->grammar().target_env()) { case SPV_ENV_UNIVERSAL_1_0: case SPV_ENV_UNIVERSAL_1_1: case SPV_ENV_UNIVERSAL_1_2: case SPV_ENV_UNIVERSAL_1_3: case SPV_ENV_VULKAN_1_0: case SPV_ENV_VULKAN_1_1: return false; default: return true; } } bool TransformationSetLoopControl::PeelCountIsSupported( opt::IRContext* ir_context) { // TODO(afd): We capture the environments for which this loop control is // definitely not supported. The check should be refined on demand for other // target environments. switch (ir_context->grammar().target_env()) { case SPV_ENV_UNIVERSAL_1_0: case SPV_ENV_UNIVERSAL_1_1: case SPV_ENV_UNIVERSAL_1_2: case SPV_ENV_UNIVERSAL_1_3: case SPV_ENV_VULKAN_1_0: case SPV_ENV_VULKAN_1_1: return false; default: return true; } } std::unordered_set TransformationSetLoopControl::GetFreshIds() const { return std::unordered_set(); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_set_loop_control.h000066400000000000000000000065601475742701700277210ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_SET_LOOP_CONTROL_H_ #define SOURCE_FUZZ_TRANSFORMATION_SET_LOOP_CONTROL_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationSetLoopControl : public Transformation { public: const static uint32_t kLoopControlMaskInOperandIndex = 2; const static uint32_t kLoopControlFirstLiteralInOperandIndex = 3; explicit TransformationSetLoopControl( protobufs::TransformationSetLoopControl message); TransformationSetLoopControl(uint32_t block_id, uint32_t loop_control, uint32_t peel_count, uint32_t partial_count); // - |message_.block_id| must be a block containing an OpLoopMerge // instruction. // - |message_.loop_control| must be a legal loop control mask that // only uses controls available in the SPIR-V version associated with // |ir_context|, and must not add loop controls that are only valid in the // presence of guarantees about what the loop does (e.g. MinIterations). // - |message_.peel_count| (respectively |message_.partial_count|) must be // zero PeelCount (respectively PartialCount) is set in // |message_.loop_control|. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // - The loop control operand of the OpLoopMergeInstruction in // |message_.block_id| is overwritten with |message_.loop_control|. // - The literals associated with the loop control are updated to reflect any // controls with associated literals that have been removed (e.g. // MinIterations), and any that have been added (PeelCount and/or // PartialCount). void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; // Does the version of SPIR-V being used support the PartialCount loop // control? static bool PartialCountIsSupported(opt::IRContext* ir_context); // Does the version of SPIR-V being used support the PeelCount loop control? static bool PeelCountIsSupported(opt::IRContext* ir_context); private: // Returns true if and only if |loop_single_bit_mask| is *not* set in // |existing_loop_control| but *is* set in |message_.loop_control|. bool LoopControlBitIsAddedByTransformation( spv::LoopControlMask loop_control_single_bit_mask, uint32_t existing_loop_control_mask) const; protobufs::TransformationSetLoopControl message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_SET_LOOP_CONTROL_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_set_memory_operands_mask.cpp000066400000000000000000000225111475742701700317530ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_set_memory_operands_mask.h" #include "source/fuzz/instruction_descriptor.h" namespace spvtools { namespace fuzz { namespace { const uint32_t kOpLoadMemoryOperandsMaskIndex = 1; const uint32_t kOpStoreMemoryOperandsMaskIndex = 2; const uint32_t kOpCopyMemoryFirstMemoryOperandsMaskIndex = 2; const uint32_t kOpCopyMemorySizedFirstMemoryOperandsMaskIndex = 3; } // namespace TransformationSetMemoryOperandsMask::TransformationSetMemoryOperandsMask( protobufs::TransformationSetMemoryOperandsMask message) : message_(std::move(message)) {} TransformationSetMemoryOperandsMask::TransformationSetMemoryOperandsMask( const protobufs::InstructionDescriptor& memory_access_instruction, uint32_t memory_operands_mask, uint32_t memory_operands_mask_index) { *message_.mutable_memory_access_instruction() = memory_access_instruction; message_.set_memory_operands_mask(memory_operands_mask); message_.set_memory_operands_mask_index(memory_operands_mask_index); } bool TransformationSetMemoryOperandsMask::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { if (message_.memory_operands_mask_index() != 0) { // The following conditions should never be violated, even if // transformations end up being replayed in a different way to the manner in // which they were applied during fuzzing, hence why these are assertions // rather than applicability checks. assert(message_.memory_operands_mask_index() == 1); assert( spv::Op( message_.memory_access_instruction().target_instruction_opcode()) == spv::Op::OpCopyMemory || spv::Op( message_.memory_access_instruction().target_instruction_opcode()) == spv::Op::OpCopyMemorySized); assert(MultipleMemoryOperandMasksAreSupported(ir_context) && "Multiple memory operand masks are not supported for this SPIR-V " "version."); } auto instruction = FindInstruction(message_.memory_access_instruction(), ir_context); if (!instruction) { return false; } if (!IsMemoryAccess(*instruction)) { return false; } auto original_mask_in_operand_index = GetInOperandIndexForMask( *instruction, message_.memory_operands_mask_index()); assert(original_mask_in_operand_index != 0 && "The given mask index is not valid."); uint32_t original_mask = original_mask_in_operand_index < instruction->NumInOperands() ? instruction->GetSingleWordInOperand(original_mask_in_operand_index) : static_cast(spv::MemoryAccessMask::MaskNone); uint32_t new_mask = message_.memory_operands_mask(); // Volatile must not be removed if ((original_mask & uint32_t(spv::MemoryAccessMask::Volatile)) && !(new_mask & uint32_t(spv::MemoryAccessMask::Volatile))) { return false; } // Nontemporal can be added or removed, and no other flag is allowed to // change. We do this by checking that the masks are equal once we set // their Volatile and Nontemporal flags to the same value (this works // because valid manipulation of Volatile is checked above, and the manner // in which Nontemporal is manipulated does not matter). return (original_mask | uint32_t(spv::MemoryAccessMask::Volatile) | uint32_t(spv::MemoryAccessMask::Nontemporal)) == (new_mask | uint32_t(spv::MemoryAccessMask::Volatile) | uint32_t(spv::MemoryAccessMask::Nontemporal)); } void TransformationSetMemoryOperandsMask::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { auto instruction = FindInstruction(message_.memory_access_instruction(), ir_context); auto original_mask_in_operand_index = GetInOperandIndexForMask( *instruction, message_.memory_operands_mask_index()); // Either add a new operand, if no mask operand was already present, or // replace an existing mask operand. if (original_mask_in_operand_index >= instruction->NumInOperands()) { // Add first memory operand if it's missing. if (message_.memory_operands_mask_index() == 1 && GetInOperandIndexForMask(*instruction, 0) >= instruction->NumInOperands()) { instruction->AddOperand({SPV_OPERAND_TYPE_MEMORY_ACCESS, {uint32_t(spv::MemoryAccessMask::MaskNone)}}); } instruction->AddOperand( {SPV_OPERAND_TYPE_MEMORY_ACCESS, {message_.memory_operands_mask()}}); } else { instruction->SetInOperand(original_mask_in_operand_index, {message_.memory_operands_mask()}); } } protobufs::Transformation TransformationSetMemoryOperandsMask::ToMessage() const { protobufs::Transformation result; *result.mutable_set_memory_operands_mask() = message_; return result; } bool TransformationSetMemoryOperandsMask::IsMemoryAccess( const opt::Instruction& instruction) { switch (instruction.opcode()) { case spv::Op::OpLoad: case spv::Op::OpStore: case spv::Op::OpCopyMemory: case spv::Op::OpCopyMemorySized: return true; default: return false; } } uint32_t TransformationSetMemoryOperandsMask::GetInOperandIndexForMask( const opt::Instruction& instruction, uint32_t mask_index) { // Get the input operand index associated with the first memory operands mask // for the instruction. uint32_t first_mask_in_operand_index = 0; switch (instruction.opcode()) { case spv::Op::OpLoad: first_mask_in_operand_index = kOpLoadMemoryOperandsMaskIndex; break; case spv::Op::OpStore: first_mask_in_operand_index = kOpStoreMemoryOperandsMaskIndex; break; case spv::Op::OpCopyMemory: first_mask_in_operand_index = kOpCopyMemoryFirstMemoryOperandsMaskIndex; break; case spv::Op::OpCopyMemorySized: first_mask_in_operand_index = kOpCopyMemorySizedFirstMemoryOperandsMaskIndex; break; default: assert(false && "Unknown memory instruction."); break; } // If we are looking for the input operand index of the first mask, return it. // This will also return a correct value if the operand is missing. if (mask_index == 0) { return first_mask_in_operand_index; } assert(mask_index == 1 && "Memory operands mask index must be 0 or 1."); // Memory mask operands are optional. Thus, if the second operand exists, // its index will be >= |first_mask_in_operand_index + 1|. We can reason as // follows to separate the cases where the index of the second operand is // equal to |first_mask_in_operand_index + 1|: // - If the first memory operand doesn't exist, its value is equal to None. // This means that it doesn't have additional operands following it and the // condition in the if statement below will be satisfied. // - If the first memory operand exists and has no additional memory operands // following it, the condition in the if statement below will be satisfied // and we will return the correct value from the function. if (first_mask_in_operand_index + 1 >= instruction.NumInOperands()) { return first_mask_in_operand_index + 1; } // We are looking for the input operand index of the second mask. This is a // little complicated because, depending on the contents of the first mask, // there may be some input operands separating the two masks. uint32_t first_mask = instruction.GetSingleWordInOperand(first_mask_in_operand_index); // Consider each bit that might have an associated extra input operand, and // count how many there are expected to be. uint32_t first_mask_extra_operand_count = 0; for (auto mask_bit : {spv::MemoryAccessMask::Aligned, spv::MemoryAccessMask::MakePointerAvailable, spv::MemoryAccessMask::MakePointerAvailableKHR, spv::MemoryAccessMask::MakePointerVisible, spv::MemoryAccessMask::MakePointerVisibleKHR}) { if (first_mask & uint32_t(mask_bit)) { first_mask_extra_operand_count++; } } return first_mask_in_operand_index + first_mask_extra_operand_count + 1; } bool TransformationSetMemoryOperandsMask:: MultipleMemoryOperandMasksAreSupported(opt::IRContext* ir_context) { // TODO(afd): We capture the environments for which this loop control is // definitely not supported. The check should be refined on demand for other // target environments. switch (ir_context->grammar().target_env()) { case SPV_ENV_UNIVERSAL_1_0: case SPV_ENV_UNIVERSAL_1_1: case SPV_ENV_UNIVERSAL_1_2: case SPV_ENV_UNIVERSAL_1_3: case SPV_ENV_VULKAN_1_0: case SPV_ENV_VULKAN_1_1: return false; default: return true; } } std::unordered_set TransformationSetMemoryOperandsMask::GetFreshIds() const { return std::unordered_set(); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_set_memory_operands_mask.h000066400000000000000000000066461475742701700314330ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_SET_MEMORY_OPERANDS_MASK_H_ #define SOURCE_FUZZ_TRANSFORMATION_SET_MEMORY_OPERANDS_MASK_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationSetMemoryOperandsMask : public Transformation { public: explicit TransformationSetMemoryOperandsMask( protobufs::TransformationSetMemoryOperandsMask message); TransformationSetMemoryOperandsMask( const protobufs::InstructionDescriptor& memory_access_instruction, uint32_t memory_operands_mask, uint32_t memory_operands_mask_index); // - |message_.memory_access_instruction| must describe a memory access // instruction. // - |message_.memory_operands_mask_index| must be suitable for this memory // access instruction, e.g. it must be 0 in the case of OpLoad, and may be // 1 in the case of OpCopyMemory if the SPIR-V version is 1.4 or higher. // - |message_.memory_operands_mask| must be identical to the original memory // operands mask, except that Volatile may be added, and Nontemporal may be // toggled. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Replaces the operands mask identified by // |message_.memory_operands_mask_index| in the instruction described by // |message_.memory_access_instruction| with |message_.memory_operands_mask|, // creating an input operand for the mask if no such operand was present. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; // Helper function that determines whether |instruction| is a memory // instruction (e.g. OpLoad). static bool IsMemoryAccess(const opt::Instruction& instruction); // Does the version of SPIR-V being used support multiple memory operand // masks on relevant memory access instructions? static bool MultipleMemoryOperandMasksAreSupported( opt::IRContext* ir_context); // Helper function to get the input operand index associated with mask number // |mask_index|. This is a bit tricky if there are multiple masks, because the // index associated with the second mask depends on whether the first mask // includes any flags such as Aligned that have corresponding operands. static uint32_t GetInOperandIndexForMask(const opt::Instruction& instruction, uint32_t mask_index); private: protobufs::TransformationSetMemoryOperandsMask message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_SET_MEMORY_OPERANDS_MASK_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_set_selection_control.cpp000066400000000000000000000050711475742701700312640ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_set_selection_control.h" namespace spvtools { namespace fuzz { TransformationSetSelectionControl::TransformationSetSelectionControl( protobufs::TransformationSetSelectionControl message) : message_(std::move(message)) {} TransformationSetSelectionControl::TransformationSetSelectionControl( uint32_t block_id, uint32_t selection_control) { message_.set_block_id(block_id); message_.set_selection_control(selection_control); } bool TransformationSetSelectionControl::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { assert((spv::SelectionControlMask(message_.selection_control()) == spv::SelectionControlMask::MaskNone || spv::SelectionControlMask(message_.selection_control()) == spv::SelectionControlMask::Flatten || spv::SelectionControlMask(message_.selection_control()) == spv::SelectionControlMask::DontFlatten) && "Selection control should never be set to something other than " "'None', 'Flatten' or 'DontFlatten'"); if (auto block = ir_context->get_instr_block(message_.block_id())) { if (auto merge_inst = block->GetMergeInst()) { return merge_inst->opcode() == spv::Op::OpSelectionMerge; } } // Either the block did not exit, or did not end with OpSelectionMerge. return false; } void TransformationSetSelectionControl::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { ir_context->get_instr_block(message_.block_id()) ->GetMergeInst() ->SetInOperand(1, {message_.selection_control()}); } protobufs::Transformation TransformationSetSelectionControl::ToMessage() const { protobufs::Transformation result; *result.mutable_set_selection_control() = message_; return result; } std::unordered_set TransformationSetSelectionControl::GetFreshIds() const { return std::unordered_set(); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_set_selection_control.h000066400000000000000000000041061475742701700307270ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_SET_SELECTION_CONTROL_H_ #define SOURCE_FUZZ_TRANSFORMATION_SET_SELECTION_CONTROL_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationSetSelectionControl : public Transformation { public: explicit TransformationSetSelectionControl( protobufs::TransformationSetSelectionControl message); TransformationSetSelectionControl(uint32_t block_id, uint32_t selection_control); // - |message_.block_id| must be a block containing an OpSelectionMerge // instruction. // - |message_.selection_control| must be one of None, Flatten or // DontFlatten. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // - The selection control operand of the OpSelectionMergeInstruction in // |message_.block_id| is overwritten with |message_.selection_control|. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationSetSelectionControl message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_SET_SELECTION_CONTROL_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_split_block.cpp000066400000000000000000000146021475742701700271710ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_split_block.h" #include #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "source/util/make_unique.h" namespace spvtools { namespace fuzz { TransformationSplitBlock::TransformationSplitBlock( protobufs::TransformationSplitBlock message) : message_(std::move(message)) {} TransformationSplitBlock::TransformationSplitBlock( const protobufs::InstructionDescriptor& instruction_to_split_before, uint32_t fresh_id) { *message_.mutable_instruction_to_split_before() = instruction_to_split_before; message_.set_fresh_id(fresh_id); } bool TransformationSplitBlock::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { if (!fuzzerutil::IsFreshId(ir_context, message_.fresh_id())) { // We require the id for the new block to be unused. return false; } auto instruction_to_split_before = FindInstruction(message_.instruction_to_split_before(), ir_context); if (!instruction_to_split_before) { // The instruction describing the block we should split does not exist. return false; } auto block_to_split = ir_context->get_instr_block(instruction_to_split_before); assert(block_to_split && "We should not have managed to find the " "instruction if it was not contained in a block."); if (block_to_split->IsLoopHeader()) { // We cannot split a loop header block: back-edges would become invalid. return false; } auto split_before = fuzzerutil::GetIteratorForInstruction( block_to_split, instruction_to_split_before); assert(split_before != block_to_split->end() && "At this point we know the" " block split point exists."); if (split_before->PreviousNode() && split_before->PreviousNode()->opcode() == spv::Op::OpSelectionMerge) { // We cannot split directly after a selection merge: this would separate // the merge from its associated branch or switch operation. return false; } if (split_before->opcode() == spv::Op::OpVariable) { // We cannot split directly after a variable; variables in a function // must be contiguous in the entry block. return false; } // We cannot split before an OpPhi unless the OpPhi has exactly one // associated incoming edge. if (split_before->opcode() == spv::Op::OpPhi && split_before->NumInOperands() != 2) { return false; } // Splitting the block must not separate the definition of an OpSampledImage // from its use: the SPIR-V data rules require them to be in the same block. return !fuzzerutil:: SplittingBeforeInstructionSeparatesOpSampledImageDefinitionFromUse( block_to_split, instruction_to_split_before); } void TransformationSplitBlock::Apply( opt::IRContext* ir_context, TransformationContext* transformation_context) const { opt::Instruction* instruction_to_split_before = FindInstruction(message_.instruction_to_split_before(), ir_context); opt::BasicBlock* block_to_split = ir_context->get_instr_block(instruction_to_split_before); auto split_before = fuzzerutil::GetIteratorForInstruction( block_to_split, instruction_to_split_before); assert(split_before != block_to_split->end() && "If the transformation is applicable, we should have an " "instruction to split on."); // We need to make sure the module's id bound is large enough to add the // fresh id. fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id()); // Split the block. auto new_bb = block_to_split->SplitBasicBlock(ir_context, message_.fresh_id(), split_before); // The split does not automatically add a branch between the two parts of // the original block, so we add one. auto branch_instruction = MakeUnique( ir_context, spv::Op::OpBranch, 0, 0, std::initializer_list{opt::Operand( spv_operand_type_t::SPV_OPERAND_TYPE_ID, {message_.fresh_id()})}); auto branch_instruction_ptr = branch_instruction.get(); block_to_split->AddInstruction(std::move(branch_instruction)); // Inform the def-use manager about the branch instruction, and record its // block. ir_context->get_def_use_mgr()->AnalyzeInstDefUse(branch_instruction_ptr); ir_context->set_instr_block(branch_instruction_ptr, block_to_split); // If we split before OpPhi instructions, we need to update their // predecessor operand so that the block they used to be inside is now the // predecessor. new_bb->ForEachPhiInst([block_to_split, ir_context](opt::Instruction* phi_inst) { assert( phi_inst->NumInOperands() == 2 && "Precondition: a block can only be split before an OpPhi if the block" "has exactly one predecessor."); phi_inst->SetInOperand(1, {block_to_split->id()}); ir_context->UpdateDefUse(phi_inst); }); // We have updated the def-use manager and the instruction to block mapping, // but other analyses (especially control flow-related ones) need to be // recomputed. ir_context->InvalidateAnalysesExceptFor( opt::IRContext::Analysis::kAnalysisDefUse | opt::IRContext::Analysis::kAnalysisInstrToBlockMapping); // If the block being split was dead, the new block arising from the split is // also dead. if (transformation_context->GetFactManager()->BlockIsDead( block_to_split->id())) { transformation_context->GetFactManager()->AddFactBlockIsDead( message_.fresh_id()); } } protobufs::Transformation TransformationSplitBlock::ToMessage() const { protobufs::Transformation result; *result.mutable_split_block() = message_; return result; } std::unordered_set TransformationSplitBlock::GetFreshIds() const { return {message_.fresh_id()}; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_split_block.h000066400000000000000000000047361475742701700266450ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_SPLIT_BLOCK_H_ #define SOURCE_FUZZ_TRANSFORMATION_SPLIT_BLOCK_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationSplitBlock : public Transformation { public: explicit TransformationSplitBlock( protobufs::TransformationSplitBlock message); TransformationSplitBlock( const protobufs::InstructionDescriptor& instruction_to_split_before, uint32_t fresh_id); // - |message_.base_instruction_id| must be the result id of an instruction // 'base' in some block 'blk'. // - 'blk' must contain an instruction 'inst' located |message_.offset| // instructions after 'base' (if |message_.offset| = 0 then 'inst' = // 'base'). // - Splitting 'blk' at 'inst', so that all instructions from 'inst' onwards // appear in a new block that 'blk' directly jumps to must be valid. // - |message_.fresh_id| must not be used by the module. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // - A new block with label |message_.fresh_id| is inserted right after 'blk' // in program order. // - All instructions of 'blk' from 'inst' onwards are moved into the new // block. // - 'blk' is made to jump unconditionally to the new block. // - If 'blk' was dead, the new block is also dead. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationSplitBlock message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_SPLIT_BLOCK_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_store.cpp000066400000000000000000000225171475742701700260240ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_store.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" namespace spvtools { namespace fuzz { TransformationStore::TransformationStore(protobufs::TransformationStore message) : message_(std::move(message)) {} TransformationStore::TransformationStore( uint32_t pointer_id, bool is_atomic, uint32_t memory_scope, uint32_t memory_semantics, uint32_t value_id, const protobufs::InstructionDescriptor& instruction_to_insert_before) { message_.set_pointer_id(pointer_id); message_.set_is_atomic(is_atomic); message_.set_memory_scope_id(memory_scope); message_.set_memory_semantics_id(memory_semantics); message_.set_value_id(value_id); *message_.mutable_instruction_to_insert_before() = instruction_to_insert_before; } bool TransformationStore::IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const { // The pointer must exist and have a type. auto pointer = ir_context->get_def_use_mgr()->GetDef(message_.pointer_id()); if (!pointer || !pointer->type_id()) { return false; } // The pointer type must indeed be a pointer. auto pointer_type = ir_context->get_def_use_mgr()->GetDef(pointer->type_id()); assert(pointer_type && "Type id must be defined."); if (pointer_type->opcode() != spv::Op::OpTypePointer) { return false; } // The pointer must not be read only. if (pointer->IsReadOnlyPointer()) { return false; } // We do not want to allow storing to null or undefined pointers. switch (pointer->opcode()) { case spv::Op::OpConstantNull: case spv::Op::OpUndef: return false; default: break; } // Determine which instruction we should be inserting before. auto insert_before = FindInstruction(message_.instruction_to_insert_before(), ir_context); // It must exist, ... if (!insert_before) { return false; } // ... and it must be legitimate to insert a store before it. if (!message_.is_atomic() && !fuzzerutil::CanInsertOpcodeBeforeInstruction( spv::Op::OpStore, insert_before)) { return false; } if (message_.is_atomic() && !fuzzerutil::CanInsertOpcodeBeforeInstruction( spv::Op::OpAtomicStore, insert_before)) { return false; } // The block we are inserting into needs to be dead, or else the pointee type // of the pointer we are storing to needs to be irrelevant (otherwise the // store could impact on the observable behaviour of the module). if (!transformation_context.GetFactManager()->BlockIsDead( ir_context->get_instr_block(insert_before)->id()) && !transformation_context.GetFactManager()->PointeeValueIsIrrelevant( message_.pointer_id())) { return false; } // The value being stored needs to exist and have a type. auto value = ir_context->get_def_use_mgr()->GetDef(message_.value_id()); if (!value || !value->type_id()) { return false; } // The type of the value must match the pointee type. if (pointer_type->GetSingleWordInOperand(1) != value->type_id()) { return false; } // The pointer needs to be available at the insertion point. if (!fuzzerutil::IdIsAvailableBeforeInstruction(ir_context, insert_before, message_.pointer_id())) { return false; } if (message_.is_atomic()) { // Check the exists of memory scope and memory semantics ids. auto memory_scope_instruction = ir_context->get_def_use_mgr()->GetDef(message_.memory_scope_id()); auto memory_semantics_instruction = ir_context->get_def_use_mgr()->GetDef(message_.memory_semantics_id()); if (!memory_scope_instruction) { return false; } if (!memory_semantics_instruction) { return false; } // The memory scope and memory semantics instructions must have the // 'OpConstant' opcode. if (memory_scope_instruction->opcode() != spv::Op::OpConstant) { return false; } if (memory_semantics_instruction->opcode() != spv::Op::OpConstant) { return false; } // The memory scope and memory semantics need to be available before // |insert_before|. if (!fuzzerutil::IdIsAvailableBeforeInstruction( ir_context, insert_before, message_.memory_scope_id())) { return false; } if (!fuzzerutil::IdIsAvailableBeforeInstruction( ir_context, insert_before, message_.memory_semantics_id())) { return false; } // The memory scope and memory semantics instructions must have an Integer // operand type with signedness does not matters. if (ir_context->get_def_use_mgr() ->GetDef(memory_scope_instruction->type_id()) ->opcode() != spv::Op::OpTypeInt) { return false; } if (ir_context->get_def_use_mgr() ->GetDef(memory_semantics_instruction->type_id()) ->opcode() != spv::Op::OpTypeInt) { return false; } // The size of the integer for memory scope and memory semantics // instructions must be equal to 32 bits. auto memory_scope_int_width = ir_context->get_def_use_mgr() ->GetDef(memory_scope_instruction->type_id()) ->GetSingleWordInOperand(0); auto memory_semantics_int_width = ir_context->get_def_use_mgr() ->GetDef(memory_semantics_instruction->type_id()) ->GetSingleWordInOperand(0); if (memory_scope_int_width != 32) { return false; } if (memory_semantics_int_width != 32) { return false; } // The memory scope constant value must be that of spv::Scope::Invocation. auto memory_scope_const_value = memory_scope_instruction->GetSingleWordInOperand(0); if (spv::Scope(memory_scope_const_value) != spv::Scope::Invocation) { return false; } // The memory semantics constant value must match the storage class of the // pointer being loaded from. auto memory_semantics_const_value = static_cast( memory_semantics_instruction->GetSingleWordInOperand(0)); if (memory_semantics_const_value != fuzzerutil::GetMemorySemanticsForStorageClass( static_cast( pointer_type->GetSingleWordInOperand(0)))) { return false; } } // The value needs to be available at the insertion point. return fuzzerutil::IdIsAvailableBeforeInstruction(ir_context, insert_before, message_.value_id()); } void TransformationStore::Apply(opt::IRContext* ir_context, TransformationContext* /*unused*/) const { if (message_.is_atomic()) { // OpAtomicStore instruction. auto insert_before = FindInstruction(message_.instruction_to_insert_before(), ir_context); auto new_instruction = MakeUnique( ir_context, spv::Op::OpAtomicStore, 0, 0, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {message_.pointer_id()}}, {SPV_OPERAND_TYPE_SCOPE_ID, {message_.memory_scope_id()}}, {SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID, {message_.memory_semantics_id()}}, {SPV_OPERAND_TYPE_ID, {message_.value_id()}}})); auto new_instruction_ptr = new_instruction.get(); insert_before->InsertBefore(std::move(new_instruction)); // Inform the def-use manager about the new instruction and record its basic // block. ir_context->get_def_use_mgr()->AnalyzeInstDefUse(new_instruction_ptr); ir_context->set_instr_block(new_instruction_ptr, ir_context->get_instr_block(insert_before)); } else { // OpStore instruction. auto insert_before = FindInstruction(message_.instruction_to_insert_before(), ir_context); auto new_instruction = MakeUnique( ir_context, spv::Op::OpStore, 0, 0, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {message_.pointer_id()}}, {SPV_OPERAND_TYPE_ID, {message_.value_id()}}})); auto new_instruction_ptr = new_instruction.get(); insert_before->InsertBefore(std::move(new_instruction)); // Inform the def-use manager about the new instruction and record its basic // block. ir_context->get_def_use_mgr()->AnalyzeInstDefUse(new_instruction_ptr); ir_context->set_instr_block(new_instruction_ptr, ir_context->get_instr_block(insert_before)); } } protobufs::Transformation TransformationStore::ToMessage() const { protobufs::Transformation result; *result.mutable_store() = message_; return result; } std::unordered_set TransformationStore::GetFreshIds() const { return std::unordered_set(); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_store.h000066400000000000000000000060771475742701700254740ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_STORE_H_ #define SOURCE_FUZZ_TRANSFORMATION_STORE_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationStore : public Transformation { public: explicit TransformationStore(protobufs::TransformationStore message); TransformationStore( uint32_t pointer_id, bool is_atomic, uint32_t memory_scope, uint32_t memory_semantics, uint32_t value_id, const protobufs::InstructionDescriptor& instruction_to_insert_before); // - |message_.pointer_id| must be the id of a pointer // - The pointer type must not have read-only storage class // - The pointer must not be OpConstantNull or OpUndef // - |message_.is_atomic| must be true if want to work with OpAtomicStore. // - If |is_atomic| is true then |message_memory_scope_id| must be the id of // an OpConstant 32 bit integer instruction with the value // spv::Scope::Invocation. // - If |is_atomic| is true then |message_.memory_semantics_id| must be the id // of an OpConstant 32 bit integer instruction with the values // SpvMemorySemanticsWorkgroupMemoryMask or // SpvMemorySemanticsUniformMemoryMask. // - |message_.value_id| must be an instruction result id that has the same // type as the pointee type of |message_.pointer_id| // - |message_.instruction_to_insert_before| must identify an instruction // before which it is valid to insert an OpStore, and where both // |message_.pointer_id| and |message_.value_id| are available (according // to dominance rules) // - Either the insertion point must be in a dead block, or it must be known // that the pointee value of |message_.pointer_id| is irrelevant bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Adds an instruction of the form: // OpStore |pointer_id| |value_id| // before the instruction identified by // |message_.instruction_to_insert_before|. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationStore message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_STORE_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_swap_commutable_operands.cpp000066400000000000000000000047751475742701700317530ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_swap_commutable_operands.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" namespace spvtools { namespace fuzz { TransformationSwapCommutableOperands::TransformationSwapCommutableOperands( protobufs::TransformationSwapCommutableOperands message) : message_(std::move(message)) {} TransformationSwapCommutableOperands::TransformationSwapCommutableOperands( const protobufs::InstructionDescriptor& instruction_descriptor) { *message_.mutable_instruction_descriptor() = instruction_descriptor; } bool TransformationSwapCommutableOperands::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { auto instruction = FindInstruction(message_.instruction_descriptor(), ir_context); if (instruction == nullptr) return false; spv::Op opcode = static_cast( message_.instruction_descriptor().target_instruction_opcode()); assert(spv::Op(instruction->opcode()) == opcode && "The located instruction must have the same opcode as in the " "descriptor."); return spvOpcodeIsCommutativeBinaryOperator(opcode); } void TransformationSwapCommutableOperands::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { auto instruction = FindInstruction(message_.instruction_descriptor(), ir_context); // By design, the instructions defined to be commutative have exactly two // input parameters. std::swap(instruction->GetInOperand(0), instruction->GetInOperand(1)); } protobufs::Transformation TransformationSwapCommutableOperands::ToMessage() const { protobufs::Transformation result; *result.mutable_swap_commutable_operands() = message_; return result; } std::unordered_set TransformationSwapCommutableOperands::GetFreshIds() const { return std::unordered_set(); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_swap_commutable_operands.h000066400000000000000000000036221475742701700314060ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_SWAP_COMMUTABLE_OPERANDS_H_ #define SOURCE_FUZZ_TRANSFORMATION_SWAP_COMMUTABLE_OPERANDS_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationSwapCommutableOperands : public Transformation { public: explicit TransformationSwapCommutableOperands( protobufs::TransformationSwapCommutableOperands message); TransformationSwapCommutableOperands( const protobufs::InstructionDescriptor& instruction_descriptor); // - |message_.instruction_descriptor| must identify an existing // commutative instruction bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Swaps the commutable operands. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationSwapCommutableOperands message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_SWAP_COMMUTABLE_OPERANDS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_swap_conditional_branch_operands.cpp000066400000000000000000000110501475742701700334230ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_swap_conditional_branch_operands.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" namespace spvtools { namespace fuzz { TransformationSwapConditionalBranchOperands:: TransformationSwapConditionalBranchOperands( protobufs::TransformationSwapConditionalBranchOperands message) : message_(std::move(message)) {} TransformationSwapConditionalBranchOperands:: TransformationSwapConditionalBranchOperands( const protobufs::InstructionDescriptor& instruction_descriptor, uint32_t fresh_id) { *message_.mutable_instruction_descriptor() = instruction_descriptor; message_.set_fresh_id(fresh_id); } bool TransformationSwapConditionalBranchOperands::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { const auto* inst = FindInstruction(message_.instruction_descriptor(), ir_context); return fuzzerutil::IsFreshId(ir_context, message_.fresh_id()) && inst && inst->opcode() == spv::Op::OpBranchConditional; } void TransformationSwapConditionalBranchOperands::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { auto* branch_inst = FindInstruction(message_.instruction_descriptor(), ir_context); assert(branch_inst); auto* block = ir_context->get_instr_block(branch_inst); assert(block); // Compute the last instruction in the |block| that allows us to insert // OpLogicalNot above it. auto iter = fuzzerutil::GetIteratorForInstruction(block, branch_inst); if (!fuzzerutil::CanInsertOpcodeBeforeInstruction(spv::Op::OpLogicalNot, iter)) { // There might be a merge instruction before OpBranchConditional. --iter; } assert(fuzzerutil::CanInsertOpcodeBeforeInstruction(spv::Op::OpLogicalNot, iter) && "We should now be able to insert spv::Op::OpLogicalNot before |iter|"); // Get the instruction whose result is used as a condition for // OpBranchConditional. const auto* condition_inst = ir_context->get_def_use_mgr()->GetDef( branch_inst->GetSingleWordInOperand(0)); assert(condition_inst); // We are swapping the labels in OpBranchConditional. This means that we must // invert the guard as well. We are using OpLogicalNot for that purpose here. auto new_instruction = MakeUnique( ir_context, spv::Op::OpLogicalNot, condition_inst->type_id(), message_.fresh_id(), opt::Instruction::OperandList{ {SPV_OPERAND_TYPE_ID, {condition_inst->result_id()}}}); auto new_instruction_ptr = new_instruction.get(); iter.InsertBefore(std::move(new_instruction)); fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id()); // Update OpBranchConditional condition operand. branch_inst->GetInOperand(0).words[0] = message_.fresh_id(); // Swap label operands. std::swap(branch_inst->GetInOperand(1), branch_inst->GetInOperand(2)); // Additionally, swap branch weights if present. if (branch_inst->NumInOperands() > 3) { std::swap(branch_inst->GetInOperand(3), branch_inst->GetInOperand(4)); } ir_context->get_def_use_mgr()->AnalyzeInstDefUse(new_instruction_ptr); ir_context->set_instr_block(new_instruction_ptr, block); ir_context->get_def_use_mgr()->EraseUseRecordsOfOperandIds(branch_inst); ir_context->get_def_use_mgr()->AnalyzeInstUse(branch_inst); // No analyses need to be invalidated since the transformation is local to a // block and the def-use and instruction-to-block mappings have been updated. } protobufs::Transformation TransformationSwapConditionalBranchOperands::ToMessage() const { protobufs::Transformation result; *result.mutable_swap_conditional_branch_operands() = message_; return result; } std::unordered_set TransformationSwapConditionalBranchOperands::GetFreshIds() const { return {message_.fresh_id()}; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_swap_conditional_branch_operands.h000066400000000000000000000043701475742701700330770ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_SWAP_CONDITIONAL_BRANCH_OPERANDS_H_ #define SOURCE_FUZZ_TRANSFORMATION_SWAP_CONDITIONAL_BRANCH_OPERANDS_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationSwapConditionalBranchOperands : public Transformation { public: explicit TransformationSwapConditionalBranchOperands( protobufs::TransformationSwapConditionalBranchOperands message); TransformationSwapConditionalBranchOperands( const protobufs::InstructionDescriptor& instruction_descriptor, uint32_t fresh_id); // - |message_.instruction_descriptor| must be a valid descriptor of some // OpBranchConditional instruction in the module. // - |message_.fresh_id| must be a fresh id. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Inserts |%fresh_id = OpLogicalNot %bool_type_id %cond_id| before // |OpBranchConditional %cond_id %branch_a %branch_b [%weight_a %weight_b]|. // Replaces %cond_id with %fresh_id and swaps %branch_* and %weight_* // operands. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationSwapConditionalBranchOperands message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_SWAP_CONDITIONAL_BRANCH_OPERANDS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_swap_function_variables.cpp000066400000000000000000000064151475742701700315760ustar00rootroot00000000000000// Copyright (c) 2021 Mostafa Ashraf // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_swap_function_variables.h" #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { TransformationSwapFunctionVariables::TransformationSwapFunctionVariables( protobufs::TransformationSwapFunctionVariables message) : message_(std::move(message)) {} TransformationSwapFunctionVariables::TransformationSwapFunctionVariables( uint32_t result_id1, uint32_t result_id2) { message_.set_result_id1(result_id1); message_.set_result_id2(result_id2); } bool TransformationSwapFunctionVariables::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { uint32_t result_id1 = message_.result_id1(); uint32_t result_id2 = message_.result_id2(); assert((result_id1 != result_id2) && "Two results ids are equal"); // The result ids used in the message must refer to instructions. auto instruction1 = ir_context->get_def_use_mgr()->GetDef(result_id1); auto instruction2 = ir_context->get_def_use_mgr()->GetDef(result_id2); if (instruction1 == nullptr || instruction2 == nullptr) { return false; } // Both instructions must be variables. if (instruction1->opcode() != spv::Op::OpVariable || instruction2->opcode() != spv::Op::OpVariable) { return false; } // Both variable instructions must be in some basic block (as they are // function-local variables), and they must be in the same block (as they need // to be variables of the same function). auto* block_1 = ir_context->get_instr_block(result_id1); auto* block_2 = ir_context->get_instr_block(result_id2); if (block_1 == nullptr || block_2 == nullptr) { return false; } return block_1 == block_2; } void TransformationSwapFunctionVariables::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { // The result ids used in the message must refer to instructions. auto instruction1 = ir_context->get_def_use_mgr()->GetDef(message_.result_id1()); auto instruction2 = ir_context->get_def_use_mgr()->GetDef(message_.result_id2()); std::unique_ptr temp_instruction = MakeUnique(); temp_instruction->InsertBefore(instruction1); instruction1->InsertAfter(instruction2); instruction2->InsertAfter(temp_instruction.get()); temp_instruction->RemoveFromList(); } protobufs::Transformation TransformationSwapFunctionVariables::ToMessage() const { protobufs::Transformation result; *result.mutable_swap_function_variables() = message_; return result; } std::unordered_set TransformationSwapFunctionVariables::GetFreshIds() const { return std::unordered_set(); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_swap_function_variables.h000066400000000000000000000041141475742701700312350ustar00rootroot00000000000000// Copyright (c) 2021 Mostafa Ashraf // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_SWAP_FUNCTION_VARIABLES_H_ #define SOURCE_FUZZ_TRANSFORMATION_SWAP_FUNCTION_VARIABLES_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { // A transformation that swaps two variable declaration instructions that appear // in the same function. class TransformationSwapFunctionVariables : public Transformation { public: explicit TransformationSwapFunctionVariables( protobufs::TransformationSwapFunctionVariables message); TransformationSwapFunctionVariables(uint32_t result_id1, uint32_t result_id2); // - |message_.result_id1| and |message_.result_id2| must be the ids of // distinct OpVariable instructions appearing in the same function. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Swaps two OpVariable instructions with result ids |message_.result_id1| // and |message_.result_id2|. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; protobufs::Transformation ToMessage() const override; std::unordered_set GetFreshIds() const override; private: protobufs::TransformationSwapFunctionVariables message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_SWAP_FUNCTION_VARIABLES_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_swap_two_functions.cpp000066400000000000000000000050531475742701700306170ustar00rootroot00000000000000// Copyright (c) 2021 Shiyu Liu // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_swap_two_functions.h" #include "source/opt/function.h" #include "source/opt/module.h" #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { TransformationSwapTwoFunctions::TransformationSwapTwoFunctions( protobufs::TransformationSwapTwoFunctions message) : message_(std::move(message)) {} TransformationSwapTwoFunctions::TransformationSwapTwoFunctions(uint32_t id1, uint32_t id2) { assert(id1 != id2 && "The two function ids cannot be the same."); message_.set_function_id1(id1); message_.set_function_id2(id2); } bool TransformationSwapTwoFunctions::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { auto func1_ptr = ir_context->GetFunction(message_.function_id1()); auto func2_ptr = ir_context->GetFunction(message_.function_id2()); return func1_ptr != nullptr && func2_ptr != nullptr; } void TransformationSwapTwoFunctions::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { opt::Module::iterator func1_it = fuzzerutil::GetFunctionIterator(ir_context, message_.function_id1()); opt::Module::iterator func2_it = fuzzerutil::GetFunctionIterator(ir_context, message_.function_id2()); assert(func1_it != ir_context->module()->end() && "Could not find function 1."); assert(func2_it != ir_context->module()->end() && "Could not find function 2."); // Two function pointers are all set, swap the two functions within the // module. std::iter_swap(func1_it.Get(), func2_it.Get()); } protobufs::Transformation TransformationSwapTwoFunctions::ToMessage() const { protobufs::Transformation result; *result.mutable_swap_two_functions() = message_; return result; } std::unordered_set TransformationSwapTwoFunctions::GetFreshIds() const { return std::unordered_set(); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_swap_two_functions.h000066400000000000000000000040051475742701700302600ustar00rootroot00000000000000// Copyright (c) 2021 Shiyu Liu // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_SWAP_TWO_FUNCTIONS_H_ #define SOURCE_FUZZ_TRANSFORMATION_SWAP_TWO_FUNCTIONS_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationSwapTwoFunctions : public Transformation { public: explicit TransformationSwapTwoFunctions( protobufs::TransformationSwapTwoFunctions message); TransformationSwapTwoFunctions(uint32_t function_id1, uint32_t function_id2); // |function_id1| and |function_id1| should all be existing ids. // Swap function operation is only permitted if: // - both ids must be ids of functions. // - both ids can be found in the module. // - function_id1 and function_id2 are not the same. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // OpFunction with |function_id1| and |function_id1| are swapped. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationSwapTwoFunctions message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_SWAP_TWO_FUNCTIONS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_toggle_access_chain_instruction.cpp000066400000000000000000000055331475742701700332740ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_toggle_access_chain_instruction.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" namespace spvtools { namespace fuzz { TransformationToggleAccessChainInstruction:: TransformationToggleAccessChainInstruction( protobufs::TransformationToggleAccessChainInstruction message) : message_(std::move(message)) {} TransformationToggleAccessChainInstruction:: TransformationToggleAccessChainInstruction( const protobufs::InstructionDescriptor& instruction_descriptor) { *message_.mutable_instruction_descriptor() = instruction_descriptor; } bool TransformationToggleAccessChainInstruction::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { auto instruction = FindInstruction(message_.instruction_descriptor(), ir_context); if (instruction == nullptr) { return false; } spv::Op opcode = static_cast( message_.instruction_descriptor().target_instruction_opcode()); assert(instruction->opcode() == opcode && "The located instruction must have the same opcode as in the " "descriptor."); if (opcode == spv::Op::OpAccessChain || opcode == spv::Op::OpInBoundsAccessChain) { return true; } return false; } void TransformationToggleAccessChainInstruction::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { auto instruction = FindInstruction(message_.instruction_descriptor(), ir_context); spv::Op opcode = instruction->opcode(); if (opcode == spv::Op::OpAccessChain) { instruction->SetOpcode(spv::Op::OpInBoundsAccessChain); } else { assert(opcode == spv::Op::OpInBoundsAccessChain && "The located instruction must be an OpInBoundsAccessChain " "instruction."); instruction->SetOpcode(spv::Op::OpAccessChain); } } protobufs::Transformation TransformationToggleAccessChainInstruction::ToMessage() const { protobufs::Transformation result; *result.mutable_toggle_access_chain_instruction() = message_; return result; } std::unordered_set TransformationToggleAccessChainInstruction::GetFreshIds() const { return std::unordered_set(); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_toggle_access_chain_instruction.h000066400000000000000000000037171475742701700327430ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_TOGGLE_ACCESS_CHAIN_INSTRUCTION_H_ #define SOURCE_FUZZ_TRANSFORMATION_TOGGLE_ACCESS_CHAIN_INSTRUCTION_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationToggleAccessChainInstruction : public Transformation { public: explicit TransformationToggleAccessChainInstruction( protobufs::TransformationToggleAccessChainInstruction message); TransformationToggleAccessChainInstruction( const protobufs::InstructionDescriptor& instruction_descriptor); // - |message_.instruction_descriptor| must identify an existing // access chain instruction bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Toggles the access chain instruction. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: protobufs::TransformationToggleAccessChainInstruction message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_TOGGLE_ACCESS_CHAIN_INSTRUCTION_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_vector_shuffle.cpp000066400000000000000000000224431475742701700277040ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_vector_shuffle.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" namespace spvtools { namespace fuzz { TransformationVectorShuffle::TransformationVectorShuffle( protobufs::TransformationVectorShuffle message) : message_(std::move(message)) {} TransformationVectorShuffle::TransformationVectorShuffle( const protobufs::InstructionDescriptor& instruction_to_insert_before, uint32_t fresh_id, uint32_t vector1, uint32_t vector2, const std::vector& component) { *message_.mutable_instruction_to_insert_before() = instruction_to_insert_before; message_.set_fresh_id(fresh_id); message_.set_vector1(vector1); message_.set_vector2(vector2); for (auto a_component : component) { message_.add_component(a_component); } } bool TransformationVectorShuffle::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { // The fresh id must not already be in use. if (!fuzzerutil::IsFreshId(ir_context, message_.fresh_id())) { return false; } // The instruction before which the shuffle will be inserted must exist. auto instruction_to_insert_before = FindInstruction(message_.instruction_to_insert_before(), ir_context); if (!instruction_to_insert_before) { return false; } // The first vector must be an instruction with a type id auto vector1_instruction = ir_context->get_def_use_mgr()->GetDef(message_.vector1()); if (!vector1_instruction || !vector1_instruction->type_id()) { return false; } // The second vector must be an instruction with a type id auto vector2_instruction = ir_context->get_def_use_mgr()->GetDef(message_.vector2()); if (!vector2_instruction || !vector2_instruction->type_id()) { return false; } auto vector1_type = ir_context->get_type_mgr()->GetType(vector1_instruction->type_id()); // The first vector instruction's type must actually be a vector type. if (!vector1_type->AsVector()) { return false; } auto vector2_type = ir_context->get_type_mgr()->GetType(vector2_instruction->type_id()); // The second vector instruction's type must actually be a vector type. if (!vector2_type->AsVector()) { return false; } // The element types of the vectors must be the same. if (vector1_type->AsVector()->element_type() != vector2_type->AsVector()->element_type()) { return false; } uint32_t combined_size = vector1_type->AsVector()->element_count() + vector2_type->AsVector()->element_count(); for (auto a_compoment : message_.component()) { // 0xFFFFFFFF is used to represent an undefined component. Unless // undefined, a component must be less than the combined size of the // vectors. if (a_compoment != 0xFFFFFFFF && a_compoment >= combined_size) { return false; } } // The module must already declare an appropriate type in which to store the // result of the shuffle. if (!GetResultTypeId(ir_context, *vector1_type->AsVector()->element_type())) { return false; } // Each of the vectors used in the shuffle must be available at the insertion // point. for (auto used_instruction : {vector1_instruction, vector2_instruction}) { if (auto block = ir_context->get_instr_block(used_instruction)) { if (!ir_context->GetDominatorAnalysis(block->GetParent()) ->Dominates(used_instruction, instruction_to_insert_before)) { return false; } } } // It must be legitimate to insert an OpVectorShuffle before the identified // instruction. return fuzzerutil::CanInsertOpcodeBeforeInstruction( spv::Op::OpVectorShuffle, instruction_to_insert_before); } void TransformationVectorShuffle::Apply( opt::IRContext* ir_context, TransformationContext* transformation_context) const { // Make input operands for a shuffle instruction - these comprise the two // vectors being shuffled, followed by the integer literal components. opt::Instruction::OperandList shuffle_operands = { {SPV_OPERAND_TYPE_ID, {message_.vector1()}}, {SPV_OPERAND_TYPE_ID, {message_.vector2()}}}; for (auto a_component : message_.component()) { shuffle_operands.push_back( {SPV_OPERAND_TYPE_LITERAL_INTEGER, {a_component}}); } uint32_t result_type_id = GetResultTypeId( ir_context, *GetVectorType(ir_context, message_.vector1())->element_type()); // Add a shuffle instruction right before the instruction identified by // |message_.instruction_to_insert_before|. auto insert_before = FindInstruction(message_.instruction_to_insert_before(), ir_context); opt::Instruction* new_instruction = insert_before->InsertBefore(MakeUnique( ir_context, spv::Op::OpVectorShuffle, result_type_id, message_.fresh_id(), shuffle_operands)); fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id()); // Inform the def-use manager about the new instruction and record its basic // block. ir_context->get_def_use_mgr()->AnalyzeInstDefUse(new_instruction); ir_context->set_instr_block(new_instruction, ir_context->get_instr_block(insert_before)); AddDataSynonymFacts(ir_context, transformation_context); } protobufs::Transformation TransformationVectorShuffle::ToMessage() const { protobufs::Transformation result; *result.mutable_vector_shuffle() = message_; return result; } uint32_t TransformationVectorShuffle::GetResultTypeId( opt::IRContext* ir_context, const opt::analysis::Type& element_type) const { opt::analysis::Vector result_type( &element_type, static_cast(message_.component_size())); return ir_context->get_type_mgr()->GetId(&result_type); } opt::analysis::Vector* TransformationVectorShuffle::GetVectorType( opt::IRContext* ir_context, uint32_t id_of_vector) { return ir_context->get_type_mgr() ->GetType(ir_context->get_def_use_mgr()->GetDef(id_of_vector)->type_id()) ->AsVector(); } std::unordered_set TransformationVectorShuffle::GetFreshIds() const { return {message_.fresh_id()}; } void TransformationVectorShuffle::AddDataSynonymFacts( opt::IRContext* ir_context, TransformationContext* transformation_context) const { // If the new instruction is irrelevant (because it is in a dead block), it // cannot participate in any DataSynonym fact. if (transformation_context->GetFactManager()->IdIsIrrelevant( message_.fresh_id())) { return; } // Add synonym facts relating the defined elements of the shuffle result to // the vector components that they come from. for (uint32_t component_index = 0; component_index < static_cast(message_.component_size()); component_index++) { uint32_t component = message_.component(component_index); if (component == 0xFFFFFFFF) { // This component is undefined, we do not introduce a synonym. continue; } // This describes the element of the result vector associated with // |component_index|. protobufs::DataDescriptor descriptor_for_result_component = MakeDataDescriptor(message_.fresh_id(), {component_index}); protobufs::DataDescriptor descriptor_for_source_component; // Get a data descriptor for the component of the input vector to which // |component| refers. if (component < GetVectorType(ir_context, message_.vector1())->element_count()) { // Check that the first vector can participate in data synonym facts. if (!fuzzerutil::CanMakeSynonymOf( ir_context, *transformation_context, *ir_context->get_def_use_mgr()->GetDef(message_.vector1()))) { continue; } descriptor_for_source_component = MakeDataDescriptor(message_.vector1(), {component}); } else { // Check that the second vector can participate in data synonym facts. if (!fuzzerutil::CanMakeSynonymOf( ir_context, *transformation_context, *ir_context->get_def_use_mgr()->GetDef(message_.vector2()))) { continue; } auto index_into_vector_2 = component - GetVectorType(ir_context, message_.vector1())->element_count(); assert( index_into_vector_2 < GetVectorType(ir_context, message_.vector2())->element_count() && "Vector shuffle index is out of bounds."); descriptor_for_source_component = MakeDataDescriptor(message_.vector2(), {index_into_vector_2}); } // Add a fact relating this input vector component with the associated // result component. transformation_context->GetFactManager()->AddFactDataSynonym( descriptor_for_result_component, descriptor_for_source_component); } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_vector_shuffle.h000066400000000000000000000101621475742701700273440ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_VECTOR_SHUFFLE_H_ #define SOURCE_FUZZ_TRANSFORMATION_VECTOR_SHUFFLE_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" #include "source/opt/types.h" namespace spvtools { namespace fuzz { class TransformationVectorShuffle : public Transformation { public: explicit TransformationVectorShuffle( protobufs::TransformationVectorShuffle message); TransformationVectorShuffle( const protobufs::InstructionDescriptor& instruction_to_insert_before, uint32_t fresh_id, uint32_t vector1, uint32_t vector2, const std::vector& component); // - |message_.fresh_id| must not be in use // - |message_.instruction_to_insert_before| must identify an instruction // before which it is legitimate to insert an OpVectorShuffle // - |message_.vector1| and |message_.vector2| must be instructions of vector // type, and the element types of these vectors must be the same // - Each element of |message_.component| must either be 0xFFFFFFFF // (representing an undefined component), or must be less than the combined // sizes of the input vectors // - The module must already contain a vector type with the same element type // as |message_.vector1| and |message_.vector2|, and with the size of // |message_component| as its element count bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Inserts an OpVectorShuffle instruction before // |message_.instruction_to_insert_before|, shuffles vectors // |message_.vector1| and |message_.vector2| using the indices provided by // |message_.component|, into |message_.fresh_id|. // // If |message_.fresh_id| is irrelevant (e.g. due to being in a dead block) // of if one of |message_.vector1| or |message_.vector2| is irrelevant and the // shuffle reads components from the irrelevant vector then no synonym facts // are added. // // Otherwise, a fact is added recording that element of |message_.fresh_id| is // synonymous with the element of |message_.vector1| or |message_.vector2| // from which it came (with undefined components being ignored). void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; private: // Returns a type id that already exists in |ir_context| suitable for // representing the result of the shuffle, where |element_type| is known to // be the common element type of the vectors to which the shuffle is being // applied. Returns 0 if no such id exists. uint32_t GetResultTypeId(opt::IRContext* ir_context, const opt::analysis::Type& element_type) const; // Returns the type associated with |id_of_vector| in |ir_context|. static opt::analysis::Vector* GetVectorType(opt::IRContext* ir_context, uint32_t id_of_vector); // Helper method for adding data synonym facts when applying the // transformation to |ir_context| and |transformation_context|. void AddDataSynonymFacts(opt::IRContext* ir_context, TransformationContext* transformation_context) const; protobufs::TransformationVectorShuffle message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_VECTOR_SHUFFLE_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_wrap_early_terminator_in_function.cpp000066400000000000000000000151771475742701700337000ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_wrap_early_terminator_in_function.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "source/util/make_unique.h" namespace spvtools { namespace fuzz { TransformationWrapEarlyTerminatorInFunction:: TransformationWrapEarlyTerminatorInFunction( protobufs::TransformationWrapEarlyTerminatorInFunction message) : message_(std::move(message)) {} TransformationWrapEarlyTerminatorInFunction:: TransformationWrapEarlyTerminatorInFunction( uint32_t fresh_id, const protobufs::InstructionDescriptor& early_terminator_instruction, uint32_t returned_value_id) { message_.set_fresh_id(fresh_id); *message_.mutable_early_terminator_instruction() = early_terminator_instruction; message_.set_returned_value_id(returned_value_id); } bool TransformationWrapEarlyTerminatorInFunction::IsApplicable( opt::IRContext* ir_context, const TransformationContext& /*unused*/) const { // The given id must be fresh. if (!fuzzerutil::IsFreshId(ir_context, message_.fresh_id())) { return false; } // |message_.early_terminator_instruction| must identify an instruction, and // the instruction must indeed be an early terminator. auto early_terminator = FindInstruction(message_.early_terminator_instruction(), ir_context); if (!early_terminator) { return false; } switch (early_terminator->opcode()) { case spv::Op::OpKill: case spv::Op::OpUnreachable: case spv::Op::OpTerminateInvocation: break; default: return false; } // A wrapper function for the early terminator must exist. auto wrapper_function = MaybeGetWrapperFunction(ir_context, early_terminator->opcode()); if (wrapper_function == nullptr) { return false; } auto enclosing_function = ir_context->get_instr_block(early_terminator)->GetParent(); // The wrapper function cannot be the function containing the instruction we // would like to wrap. if (wrapper_function->result_id() == enclosing_function->result_id()) { return false; } if (!ir_context->get_type_mgr() ->GetType(enclosing_function->type_id()) ->AsVoid()) { // The enclosing function has non-void return type. We thus need to make // sure that |message_.returned_value_instruction| provides a suitable // result id to use in an OpReturnValue instruction. auto returned_value_instruction = ir_context->get_def_use_mgr()->GetDef(message_.returned_value_id()); if (!returned_value_instruction || !returned_value_instruction->type_id() || returned_value_instruction->type_id() != enclosing_function->type_id()) { return false; } if (!fuzzerutil::IdIsAvailableBeforeInstruction( ir_context, early_terminator, message_.returned_value_id())) { return false; } } return true; } void TransformationWrapEarlyTerminatorInFunction::Apply( opt::IRContext* ir_context, TransformationContext* /*unused*/) const { fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id()); auto early_terminator = FindInstruction(message_.early_terminator_instruction(), ir_context); auto enclosing_block = ir_context->get_instr_block(early_terminator); auto enclosing_function = enclosing_block->GetParent(); // We would like to add an OpFunctionCall before the block's terminator // instruction, and then change the block's terminator to OpReturn or // OpReturnValue. // We get an iterator to the instruction we would like to insert the function // call before. It will be an iterator to the final instruction in the block // unless the block is a merge block in which case it will be to the // penultimate instruction (because we cannot insert an OpFunctionCall after // a merge instruction). auto iterator = enclosing_block->tail(); if (enclosing_block->MergeBlockIdIfAny()) { --iterator; } auto wrapper_function = MaybeGetWrapperFunction(ir_context, early_terminator->opcode()); iterator->InsertBefore(MakeUnique( ir_context, spv::Op::OpFunctionCall, wrapper_function->type_id(), message_.fresh_id(), opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {wrapper_function->result_id()}}}))); opt::Instruction::OperandList new_in_operands; if (!ir_context->get_type_mgr() ->GetType(enclosing_function->type_id()) ->AsVoid()) { new_in_operands.push_back( {SPV_OPERAND_TYPE_ID, {message_.returned_value_id()}}); early_terminator->SetOpcode(spv::Op::OpReturnValue); } else { early_terminator->SetOpcode(spv::Op::OpReturn); } early_terminator->SetInOperands(std::move(new_in_operands)); ir_context->InvalidateAnalysesExceptFor(opt::IRContext::kAnalysisNone); } std::unordered_set TransformationWrapEarlyTerminatorInFunction::GetFreshIds() const { return std::unordered_set({message_.fresh_id()}); } protobufs::Transformation TransformationWrapEarlyTerminatorInFunction::ToMessage() const { protobufs::Transformation result; *result.mutable_wrap_early_terminator_in_function() = message_; return result; } opt::Function* TransformationWrapEarlyTerminatorInFunction::MaybeGetWrapperFunction( opt::IRContext* ir_context, spv::Op early_terminator_opcode) { assert((early_terminator_opcode == spv::Op::OpKill || early_terminator_opcode == spv::Op::OpUnreachable || early_terminator_opcode == spv::Op::OpTerminateInvocation) && "Invalid opcode."); auto void_type_id = fuzzerutil::MaybeGetVoidType(ir_context); if (!void_type_id) { return nullptr; } auto void_function_type_id = fuzzerutil::FindFunctionType(ir_context, {void_type_id}); if (!void_function_type_id) { return nullptr; } for (auto& function : *ir_context->module()) { if (function.DefInst().GetSingleWordInOperand(1) != void_function_type_id) { continue; } if (function.begin()->begin()->opcode() == early_terminator_opcode) { return &function; } } return nullptr; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_wrap_early_terminator_in_function.h000066400000000000000000000057421475742701700333420ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_WRAP_EARLY_TERMINATOR_IN_FUNCTION_H_ #define SOURCE_FUZZ_TRANSFORMATION_WRAP_EARLY_TERMINATOR_IN_FUNCTION_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationWrapEarlyTerminatorInFunction : public Transformation { public: explicit TransformationWrapEarlyTerminatorInFunction( protobufs::TransformationWrapEarlyTerminatorInFunction message); TransformationWrapEarlyTerminatorInFunction( uint32_t fresh_id, const protobufs::InstructionDescriptor& early_terminator_instruction, uint32_t returned_value_id); // - |message_.fresh_id| must be fresh. // - |message_.early_terminator_instruction| must identify an early terminator // instruction, i.e. an instruction with opcode OpKill, OpUnreachable or // OpTerminateInvocation. // - A suitable wrapper function for the early terminator must exist, and it // must be distinct from the function containing // |message_.early_terminator_instruction|. // - If the enclosing function has non-void return type then // |message_.returned_value_instruction| must be the id of an instruction of // the return type that is available at the point of the early terminator // instruction. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // An OpFunctionCall instruction to an appropriate wrapper function is // inserted before |message_.early_terminator_instruction|, and // |message_.early_terminator_instruction| is replaced with either OpReturn // or OpReturnValue |message_.returned_value_instruction| depending on whether // the enclosing function's return type is void. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; static opt::Function* MaybeGetWrapperFunction( opt::IRContext* ir_context, spv::Op early_terminator_opcode); private: protobufs::TransformationWrapEarlyTerminatorInFunction message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_WRAP_EARLY_TERMINATOR_IN_FUNCTION_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_wrap_region_in_selection.cpp000066400000000000000000000146111475742701700317330ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_wrap_region_in_selection.h" #include "source/fuzz/fuzzer_util.h" namespace spvtools { namespace fuzz { TransformationWrapRegionInSelection::TransformationWrapRegionInSelection( protobufs::TransformationWrapRegionInSelection message) : message_(std::move(message)) {} TransformationWrapRegionInSelection::TransformationWrapRegionInSelection( uint32_t region_entry_block_id, uint32_t region_exit_block_id, bool branch_condition) { message_.set_region_entry_block_id(region_entry_block_id); message_.set_region_exit_block_id(region_exit_block_id); message_.set_branch_condition(branch_condition); } bool TransformationWrapRegionInSelection::IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const { // Check that it is possible to outline a region of blocks without breaking // domination and structured control flow rules. if (!IsApplicableToBlockRange(ir_context, message_.region_entry_block_id(), message_.region_exit_block_id())) { return false; } // There must exist an irrelevant boolean constant to be used as a condition // in the OpBranchConditional instruction. return fuzzerutil::MaybeGetBoolConstant(ir_context, transformation_context, message_.branch_condition(), true) != 0; } void TransformationWrapRegionInSelection::Apply( opt::IRContext* ir_context, TransformationContext* transformation_context) const { auto* new_header_block = ir_context->cfg()->block(message_.region_entry_block_id()); assert(new_header_block->terminator()->opcode() == spv::Op::OpBranch && "This condition should have been checked in the IsApplicable"); const auto successor_id = new_header_block->terminator()->GetSingleWordInOperand(0); // Change |entry_block|'s terminator to |OpBranchConditional|. new_header_block->terminator()->SetOpcode(spv::Op::OpBranchConditional); new_header_block->terminator()->SetInOperands( {{SPV_OPERAND_TYPE_ID, {fuzzerutil::MaybeGetBoolConstant(ir_context, *transformation_context, message_.branch_condition(), true)}}, {SPV_OPERAND_TYPE_ID, {successor_id}}, {SPV_OPERAND_TYPE_ID, {successor_id}}}); // Insert OpSelectionMerge before the terminator. new_header_block->terminator()->InsertBefore(MakeUnique( ir_context, spv::Op::OpSelectionMerge, 0, 0, opt::Instruction::OperandList{ {SPV_OPERAND_TYPE_ID, {message_.region_exit_block_id()}}, {SPV_OPERAND_TYPE_SELECTION_CONTROL, {uint32_t(spv::SelectionControlMask::MaskNone)}}})); // We've change the module so we must invalidate analyses. ir_context->InvalidateAnalysesExceptFor(opt::IRContext::kAnalysisNone); } protobufs::Transformation TransformationWrapRegionInSelection::ToMessage() const { protobufs::Transformation result; *result.mutable_wrap_region_in_selection() = message_; return result; } bool TransformationWrapRegionInSelection::IsApplicableToBlockRange( opt::IRContext* ir_context, uint32_t header_block_candidate_id, uint32_t merge_block_candidate_id) { // Check that |header_block_candidate_id| and |merge_block_candidate_id| are // valid. const auto* header_block_candidate = fuzzerutil::MaybeFindBlock(ir_context, header_block_candidate_id); if (!header_block_candidate) { return false; } const auto* merge_block_candidate = fuzzerutil::MaybeFindBlock(ir_context, merge_block_candidate_id); if (!merge_block_candidate) { return false; } // |header_block_candidate| and |merge_block_candidate| must be from the same // function. if (header_block_candidate->GetParent() != merge_block_candidate->GetParent()) { return false; } const auto* dominator_analysis = ir_context->GetDominatorAnalysis(header_block_candidate->GetParent()); const auto* postdominator_analysis = ir_context->GetPostDominatorAnalysis(header_block_candidate->GetParent()); if (!dominator_analysis->StrictlyDominates(header_block_candidate, merge_block_candidate) || !postdominator_analysis->StrictlyDominates(merge_block_candidate, header_block_candidate)) { return false; } // |header_block_candidate| can't be a header since we are about to make it // one. if (header_block_candidate->GetMergeInst()) { return false; } // |header_block_candidate| must have an OpBranch terminator. if (header_block_candidate->terminator()->opcode() != spv::Op::OpBranch) { return false; } // Every header block must have a unique merge block. Thus, // |merge_block_candidate| can't be a merge block of some other header. auto* structured_cfg = ir_context->GetStructuredCFGAnalysis(); if (structured_cfg->IsMergeBlock(merge_block_candidate_id)) { return false; } // |header_block_candidate|'s containing construct must also contain // |merge_block_candidate|. // // ContainingConstruct will return the id of a loop header for a block in the // loop's continue construct. Thus, we must also check the case when one of // the candidates is in continue construct and the other one is not. if (structured_cfg->ContainingConstruct(header_block_candidate_id) != structured_cfg->ContainingConstruct(merge_block_candidate_id) || structured_cfg->IsInContinueConstruct(header_block_candidate_id) != structured_cfg->IsInContinueConstruct(merge_block_candidate_id)) { return false; } return true; } std::unordered_set TransformationWrapRegionInSelection::GetFreshIds() const { return std::unordered_set(); } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_wrap_region_in_selection.h000066400000000000000000000075031475742701700314020ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_WRAP_REGION_IN_SELECTION_H_ #define SOURCE_FUZZ_TRANSFORMATION_WRAP_REGION_IN_SELECTION_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationWrapRegionInSelection : public Transformation { public: explicit TransformationWrapRegionInSelection( protobufs::TransformationWrapRegionInSelection message); TransformationWrapRegionInSelection(uint32_t region_entry_block_id, uint32_t region_exit_block_id, bool branch_condition); // - It should be possible to apply this transformation to a // single-exit-single-entry region of blocks dominated by // |region_entry_block_id| and postdominated by |region_exit_block_id| // (see IsApplicableToBlockRange method for further details). // // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/3828): // Consider applying this transformation to non-single-entry-single-exit // regions of blocks. // - There must exist an irrelevant boolean constant with value // |branch_condition|. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // - Transforms |region_entry_block_id| into a selection header with both // branches pointing to the block's successor. // - |branch_condition| is used as a condition in the header's // OpBranchConditional instruction. // - Transforms |region_exit_block_id| into a merge block of the selection's // header. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; protobufs::Transformation ToMessage() const override; // Returns true if it's possible to apply this transformation to the // single-exit-single-entry region of blocks starting with // |header_block_candidate_id| and ending with |merge_block_candidate_id|. // Concretely: // - Both |header_block_candidate_id| and |merge_block_candidate_id| must be // result ids of some blocks in the module. // - Both blocks must belong to the same function. // - |header_block_candidate_id| must strictly dominate // |merge_block_candidate_id| and |merge_block_candidate_id| must strictly // postdominate |header_block_candidate_id|. // - |header_block_candidate_id| can't be a header block of any construct. // - |header_block_candidate_id|'s terminator must be an OpBranch. // - |merge_block_candidate_id| can't be a merge block of any other construct. // - Both |header_block_candidate_id| and |merge_block_candidate_id| must be // inside the same construct if any. static bool IsApplicableToBlockRange(opt::IRContext* ir_context, uint32_t header_block_candidate_id, uint32_t merge_block_candidate_id); std::unordered_set GetFreshIds() const override; private: protobufs::TransformationWrapRegionInSelection message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_WRAP_REGION_IN_SELECTION_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_wrap_vector_synonym.cpp000066400000000000000000000162531475742701700310170ustar00rootroot00000000000000// Copyright (c) 2021 Shiyu Liu // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_wrap_vector_synonym.h" #include "source/fuzz/data_descriptor.h" #include "source/fuzz/fuzzer_util.h" #include "source/opt/instruction.h" namespace spvtools { namespace fuzz { TransformationWrapVectorSynonym::TransformationWrapVectorSynonym( protobufs::TransformationWrapVectorSynonym message) : message_(std::move(message)) {} TransformationWrapVectorSynonym::TransformationWrapVectorSynonym( uint32_t instruction_id, uint32_t vector_operand1, uint32_t vector_operand2, uint32_t fresh_id, uint32_t pos) { message_.set_instruction_id(instruction_id); message_.set_vector_operand1(vector_operand1); message_.set_vector_operand2(vector_operand2); message_.set_fresh_id(fresh_id); message_.set_scalar_position(pos); } bool TransformationWrapVectorSynonym::IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const { // |fresh_id| must be fresh. if (!fuzzerutil::IsFreshId(ir_context, message_.fresh_id())) { return false; } const opt::Instruction* instruction = ir_context->get_def_use_mgr()->GetDef(message_.instruction_id()); // |instruction_id| must refer to an existing instruction. if (instruction == nullptr) { return false; } if (!IsInstructionSupported(ir_context, *instruction)) { return false; } // It must be possible to make a synonym of the result id of the scalar // operation if (!fuzzerutil::CanMakeSynonymOf(ir_context, transformation_context, *instruction)) { return false; } // |vector_operand1| and |vector_operand2| must exist. auto vec1 = ir_context->get_def_use_mgr()->GetDef(message_.vector_operand1()); auto vec2 = ir_context->get_def_use_mgr()->GetDef(message_.vector_operand2()); if (vec1 == nullptr || vec2 == nullptr) { return false; } // The 2 vectors must have compatible vector types. auto vec1_type_id = vec1->type_id(); auto vec2_type_id = vec2->type_id(); for (auto operand_index : {0, 1}) { if (!fuzzerutil::TypesAreCompatible(ir_context, instruction->opcode(), operand_index, vec1_type_id, vec2_type_id)) { return false; } } auto vec1_type = ir_context->get_def_use_mgr()->GetDef(vec1_type_id); if (vec1_type->opcode() != spv::Op::OpTypeVector) { return false; } // A suitable vector for the result type of the new vector instruction must // exist in the module. This is a vector of the right length, whose element // type matches the result type of the scalar instruction. uint32_t vector_size = vec1_type->GetSingleWordInOperand(1); if (!fuzzerutil::MaybeGetVectorType(ir_context, instruction->type_id(), vector_size)) { return false; } // |scalar_position| needs to be a non-negative integer less than the vector // length. // OpTypeVector instruction has the component count at index 2. if (message_.scalar_position() >= ir_context->get_def_use_mgr() ->GetDef(vec1_type_id) ->GetSingleWordInOperand(1)) { return false; } if (!transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(message_.vector_operand1(), {message_.scalar_position()}), MakeDataDescriptor(instruction->GetSingleWordInOperand(0), {}))) { return false; } if (!transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(message_.vector_operand2(), {message_.scalar_position()}), MakeDataDescriptor(instruction->GetSingleWordInOperand(1), {}))) { return false; } return true; } void TransformationWrapVectorSynonym::Apply( opt::IRContext* ir_context, TransformationContext* transformation_context) const { // Create an instruction descriptor for the original instruction. auto instruction = ir_context->get_def_use_mgr()->GetDef(message_.instruction_id()); auto destination_block = ir_context->get_instr_block(instruction); // Populate input operand list with two vectors for vector operation. opt::Instruction::OperandList in_operands; in_operands.push_back({SPV_OPERAND_TYPE_ID, {message_.vector_operand1()}}); in_operands.push_back({SPV_OPERAND_TYPE_ID, {message_.vector_operand2()}}); // Make a new arithmetic instruction: %fresh_id = OpXX %type_id %result_id1 // %result_id2. auto vector_operand_type = ir_context->get_def_use_mgr()->GetDef( fuzzerutil::GetTypeId(ir_context, message_.vector_operand1())); uint32_t vector_size = vector_operand_type->GetSingleWordInOperand(1); auto vec_type_id = fuzzerutil::MaybeGetVectorType( ir_context, instruction->type_id(), vector_size); auto new_instruction = MakeUnique( ir_context, instruction->opcode(), vec_type_id, message_.fresh_id(), std::move(in_operands)); auto new_instruction_ptr = new_instruction.get(); instruction->InsertBefore(std::move(new_instruction)); ir_context->get_def_use_mgr()->AnalyzeInstDefUse(new_instruction_ptr); ir_context->set_instr_block(new_instruction_ptr, destination_block); // Add |fresh_id| to id bound. fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id()); // Add synonyms between |fresh_id| and |instruction_id|. transformation_context->GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(message_.fresh_id(), {message_.scalar_position()}), MakeDataDescriptor(message_.instruction_id(), {})); } protobufs::Transformation TransformationWrapVectorSynonym::ToMessage() const { protobufs::Transformation result; *result.mutable_wrap_vector_synonym() = message_; return result; } std::unordered_set TransformationWrapVectorSynonym::GetFreshIds() const { return std::unordered_set{message_.fresh_id()}; } bool TransformationWrapVectorSynonym::IsInstructionSupported( opt::IRContext* ir_context, const opt::Instruction& instruction) { if (!instruction.result_id() || !instruction.type_id()) { return false; } auto type_instruction = ir_context->get_def_use_mgr()->GetDef(instruction.type_id()); if ((type_instruction->opcode() != spv::Op::OpTypeInt && type_instruction->opcode() != spv::Op::OpTypeFloat)) { return false; } switch (instruction.opcode()) { case spv::Op::OpIAdd: case spv::Op::OpISub: case spv::Op::OpIMul: case spv::Op::OpFAdd: case spv::Op::OpFSub: case spv::Op::OpFMul: return true; default: return false; } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/transformation_wrap_vector_synonym.h000066400000000000000000000066231475742701700304640ustar00rootroot00000000000000// Copyright (c) 2021 Shiyu Liu // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_TRANSFORMATION_WRAP_VECTOR_SYNONYM_H_ #define SOURCE_FUZZ_TRANSFORMATION_WRAP_VECTOR_SYNONYM_H_ #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { class TransformationWrapVectorSynonym : public Transformation { public: explicit TransformationWrapVectorSynonym( protobufs::TransformationWrapVectorSynonym message); TransformationWrapVectorSynonym(uint32_t instruction_id, uint32_t vector_operand1, uint32_t vector_operand2, uint32_t fresh_id, uint32_t pos); // - |instruction_id| must be the id of a supported arithmetic operation // and must be relevant. // - |vector_operand1| and |vector_operand2| represents the result ids of the // two vector operands. // - |fresh_id| is an unused id that will be used as a result id of the // created instruction. // - |vector_operand1| and |vector_operand2| must have compatible vector types // that are supported by this transformation. // - |pos| is an index of the operands of |instruction_id| in the // |vector_operand1| and |vector_operand2|. It must be less than the size // of those vector operands. // - A vector type with the same width as the types of the vector operands, // and element type matching the type of |instruction_id|, must exist in the // module. bool IsApplicable( opt::IRContext* ir_context, const TransformationContext& transformation_context) const override; // Adds a new instruction before the |instruction_id| with |fresh_id| // result id and |instruction_id|'s opcode. The added instruction has // two operands: |vector_operand1| and |vector_operand2| and its type // id is equal to the type ids of those operands. A new fact is added // to the fact manager specifying that |fresh_id[pos]| is synonymous // to |instruction_id|. void Apply(opt::IRContext* ir_context, TransformationContext* transformation_context) const override; std::unordered_set GetFreshIds() const override; protobufs::Transformation ToMessage() const override; // Checks whether the instruction given is supported by the transformation. // A valid instruction must: // - has both result id and type id. // - is a supported scalar operation instruction. // - has a supported type that is either int or float. static bool IsInstructionSupported(opt::IRContext* ir_context, const opt::Instruction& instruction); private: protobufs::TransformationWrapVectorSynonym message_; }; } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_TRANSFORMATION_WRAP_VECTOR_SYNONYM_H_ KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/uniform_buffer_element_descriptor.cpp000066400000000000000000000102311475742701700305070ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/uniform_buffer_element_descriptor.h" #include namespace spvtools { namespace fuzz { protobufs::UniformBufferElementDescriptor MakeUniformBufferElementDescriptor( uint32_t descriptor_set, uint32_t binding, std::vector&& indices) { protobufs::UniformBufferElementDescriptor result; result.set_descriptor_set(descriptor_set); result.set_binding(binding); for (auto index : indices) { result.add_index(index); } return result; } bool UniformBufferElementDescriptorEquals::operator()( const protobufs::UniformBufferElementDescriptor* first, const protobufs::UniformBufferElementDescriptor* second) const { return first->descriptor_set() == second->descriptor_set() && first->binding() == second->binding() && first->index().size() == second->index().size() && std::equal(first->index().begin(), first->index().end(), second->index().begin()); } opt::Instruction* FindUniformVariable( const protobufs::UniformBufferElementDescriptor& uniform_buffer_element_descriptor, opt::IRContext* context, bool check_unique) { opt::Instruction* result = nullptr; for (auto& inst : context->types_values()) { // Consider all global variables with uniform storage class. if (inst.opcode() != spv::Op::OpVariable) { continue; } if (spv::StorageClass(inst.GetSingleWordInOperand(0)) != spv::StorageClass::Uniform) { continue; } // Determine whether the variable is decorated with a descriptor set // matching that in |uniform_buffer_element|. bool descriptor_set_matches = false; context->get_decoration_mgr()->ForEachDecoration( inst.result_id(), uint32_t(spv::Decoration::DescriptorSet), [&descriptor_set_matches, &uniform_buffer_element_descriptor]( const opt::Instruction& decoration_inst) { const uint32_t kDescriptorSetOperandIndex = 2; if (decoration_inst.GetSingleWordInOperand( kDescriptorSetOperandIndex) == uniform_buffer_element_descriptor.descriptor_set()) { descriptor_set_matches = true; } }); if (!descriptor_set_matches) { // Descriptor set does not match. continue; } // Determine whether the variable is decorated with a binding matching that // in |uniform_buffer_element|. bool binding_matches = false; context->get_decoration_mgr()->ForEachDecoration( inst.result_id(), uint32_t(spv::Decoration::Binding), [&binding_matches, &uniform_buffer_element_descriptor]( const opt::Instruction& decoration_inst) { const uint32_t kBindingOperandIndex = 2; if (decoration_inst.GetSingleWordInOperand(kBindingOperandIndex) == uniform_buffer_element_descriptor.binding()) { binding_matches = true; } }); if (!binding_matches) { // Binding does not match. continue; } // This instruction is a uniform variable with the right descriptor set and // binding. if (!check_unique) { // If we aren't checking uniqueness, return it. return &inst; } if (result) { // More than one uniform variable is decorated with the given descriptor // set and binding. This means the fact is ambiguous. return nullptr; } result = &inst; } // We get here either if no match was found, or if |check_unique| holds and // exactly one match was found. assert(result == nullptr || check_unique); return result; } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/fuzz/uniform_buffer_element_descriptor.h000066400000000000000000000041231475742701700301570ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_FUZZ_UNIFORM_BUFFER_ELEMENT_DESCRIPTOR_H_ #define SOURCE_FUZZ_UNIFORM_BUFFER_ELEMENT_DESCRIPTOR_H_ #include #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/opt/instruction.h" #include "source/opt/ir_context.h" namespace spvtools { namespace fuzz { // Factory method to create a uniform buffer element descriptor message from // descriptor set and binding ids and a list of indices. protobufs::UniformBufferElementDescriptor MakeUniformBufferElementDescriptor( uint32_t descriptor_set, uint32_t binding, std::vector&& indices); // Equality function for uniform buffer element descriptors. struct UniformBufferElementDescriptorEquals { bool operator()( const protobufs::UniformBufferElementDescriptor* first, const protobufs::UniformBufferElementDescriptor* second) const; }; // Returns a pointer to an OpVariable in |context| that is decorated with the // descriptor set and binding associated with |uniform_buffer_element|. Returns // nullptr if no such variable exists. If multiple such variables exist, a // pointer to an arbitrary one of the associated instructions is returned if // |check_unique| is false, and nullptr is returned if |check_unique| is true. opt::Instruction* FindUniformVariable( const protobufs::UniformBufferElementDescriptor& uniform_buffer_element_descriptor, opt::IRContext* context, bool check_unique); } // namespace fuzz } // namespace spvtools #endif // SOURCE_FUZZ_UNIFORM_BUFFER_ELEMENT_DESCRIPTOR_H_ KhronosGroup-SPIRV-Tools-f289d04/source/instruction.h000066400000000000000000000034421475742701700225660ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_INSTRUCTION_H_ #define SOURCE_INSTRUCTION_H_ #include #include #include "source/latest_version_spirv_header.h" #include "spirv-tools/libspirv.h" // Describes an instruction. struct spv_instruction_t { // Normally, both opcode and extInstType contain valid data. // However, when the assembler parses ! as the first word in // an instruction and opcode and extInstType are invalid. spv::Op opcode; spv_ext_inst_type_t extInstType; // The Id of the result type, if this instruction has one. Zero otherwise. uint32_t resultTypeId; // The instruction, as a sequence of 32-bit words. // For a regular instruction the opcode and word count are combined // in words[0], as described in the SPIR-V spec. // Otherwise, the first token was !, and that number appears // in words[0]. Subsequent elements are the result of parsing // tokens in the alternate parsing mode as described in syntax.md. std::vector words; }; // Appends a word to an instruction, without checking for overflow. inline void spvInstructionAddWord(spv_instruction_t* inst, uint32_t value) { inst->words.push_back(value); } #endif // SOURCE_INSTRUCTION_H_ KhronosGroup-SPIRV-Tools-f289d04/source/latest_version_glsl_std_450_header.h000066400000000000000000000014361475742701700270420ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_LATEST_VERSION_GLSL_STD_450_HEADER_H_ #define SOURCE_LATEST_VERSION_GLSL_STD_450_HEADER_H_ #include "spirv/unified1/GLSL.std.450.h" #endif // SOURCE_LATEST_VERSION_GLSL_STD_450_HEADER_H_ KhronosGroup-SPIRV-Tools-f289d04/source/latest_version_opencl_std_header.h000066400000000000000000000014261475742701700267700ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_LATEST_VERSION_OPENCL_STD_HEADER_H_ #define SOURCE_LATEST_VERSION_OPENCL_STD_HEADER_H_ #include "spirv/unified1/OpenCL.std.h" #endif // SOURCE_LATEST_VERSION_OPENCL_STD_HEADER_H_ KhronosGroup-SPIRV-Tools-f289d04/source/latest_version_spirv_header.h000066400000000000000000000014061475742701700257770ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_LATEST_VERSION_SPIRV_HEADER_H_ #define SOURCE_LATEST_VERSION_SPIRV_HEADER_H_ #include "spirv/unified1/spirv.hpp11" #endif // SOURCE_LATEST_VERSION_SPIRV_HEADER_H_ KhronosGroup-SPIRV-Tools-f289d04/source/libspirv.cpp000066400000000000000000000136221475742701700223730ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "spirv-tools/libspirv.hpp" #include #include #include #include #include #include "source/table.h" namespace spvtools { Context::Context(spv_target_env env) : context_(spvContextCreate(env)) {} Context::Context(Context&& other) : context_(other.context_) { other.context_ = nullptr; } Context& Context::operator=(Context&& other) { spvContextDestroy(context_); context_ = other.context_; other.context_ = nullptr; return *this; } Context::~Context() { spvContextDestroy(context_); } void Context::SetMessageConsumer(MessageConsumer consumer) { SetContextMessageConsumer(context_, std::move(consumer)); } spv_context& Context::CContext() { return context_; } const spv_context& Context::CContext() const { return context_; } // Structs for holding the data members for SpvTools. struct SpirvTools::Impl { explicit Impl(spv_target_env env) : context(spvContextCreate(env)) { // The default consumer in spv_context_t is a null consumer, which provides // equivalent functionality (from the user's perspective) as a real consumer // does nothing. } ~Impl() { spvContextDestroy(context); } spv_context context; // C interface context object. }; SpirvTools::SpirvTools(spv_target_env env) : impl_(new Impl(env)) { assert(env != SPV_ENV_WEBGPU_0); } SpirvTools::~SpirvTools() {} void SpirvTools::SetMessageConsumer(MessageConsumer consumer) { SetContextMessageConsumer(impl_->context, std::move(consumer)); } bool SpirvTools::Assemble(const std::string& text, std::vector* binary, uint32_t options) const { return Assemble(text.data(), text.size(), binary, options); } bool SpirvTools::Assemble(const char* text, const size_t text_size, std::vector* binary, uint32_t options) const { spv_binary spvbinary = nullptr; spv_result_t status = spvTextToBinaryWithOptions( impl_->context, text, text_size, options, &spvbinary, nullptr); if (status == SPV_SUCCESS) { binary->assign(spvbinary->code, spvbinary->code + spvbinary->wordCount); } spvBinaryDestroy(spvbinary); return status == SPV_SUCCESS; } bool SpirvTools::Disassemble(const std::vector& binary, std::string* text, uint32_t options) const { return Disassemble(binary.data(), binary.size(), text, options); } bool SpirvTools::Disassemble(const uint32_t* binary, const size_t binary_size, std::string* text, uint32_t options) const { spv_text spvtext = nullptr; spv_result_t status = spvBinaryToText(impl_->context, binary, binary_size, options, &spvtext, nullptr); if (status == SPV_SUCCESS && (options & SPV_BINARY_TO_TEXT_OPTION_PRINT) == 0) { assert(spvtext); text->assign(spvtext->str, spvtext->str + spvtext->length); } spvTextDestroy(spvtext); return status == SPV_SUCCESS; } struct CxxParserContext { const HeaderParser& header_parser; const InstructionParser& instruction_parser; }; bool SpirvTools::Parse(const std::vector& binary, const HeaderParser& header_parser, const InstructionParser& instruction_parser, spv_diagnostic* diagnostic) { CxxParserContext parser_context = {header_parser, instruction_parser}; spv_parsed_header_fn_t header_fn_wrapper = [](void* user_data, spv_endianness_t endianness, uint32_t magic, uint32_t version, uint32_t generator, uint32_t id_bound, uint32_t reserved) { CxxParserContext* ctx = reinterpret_cast(user_data); spv_parsed_header_t header = {magic, version, generator, id_bound, reserved}; return ctx->header_parser(endianness, header); }; spv_parsed_instruction_fn_t instruction_fn_wrapper = [](void* user_data, const spv_parsed_instruction_t* instruction) { CxxParserContext* ctx = reinterpret_cast(user_data); return ctx->instruction_parser(*instruction); }; spv_result_t status = spvBinaryParse( impl_->context, &parser_context, binary.data(), binary.size(), header_fn_wrapper, instruction_fn_wrapper, diagnostic); return status == SPV_SUCCESS; } bool SpirvTools::Validate(const std::vector& binary) const { return Validate(binary.data(), binary.size()); } bool SpirvTools::Validate(const uint32_t* binary, const size_t binary_size) const { return spvValidateBinary(impl_->context, binary, binary_size, nullptr) == SPV_SUCCESS; } bool SpirvTools::Validate(const uint32_t* binary, const size_t binary_size, spv_validator_options options) const { spv_const_binary_t the_binary{binary, binary_size}; spv_diagnostic diagnostic = nullptr; bool valid = spvValidateWithOptions(impl_->context, options, &the_binary, &diagnostic) == SPV_SUCCESS; if (!valid && impl_->context->consumer) { impl_->context->consumer.operator()( SPV_MSG_ERROR, nullptr, diagnostic->position, diagnostic->error); } spvDiagnosticDestroy(diagnostic); return valid; } bool SpirvTools::IsValid() const { return impl_->context != nullptr; } } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/link/000077500000000000000000000000001475742701700207665ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/link/CMakeLists.txt000066400000000000000000000032631475742701700235320ustar00rootroot00000000000000# Copyright (c) 2017 Pierre Moreau # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. add_library(SPIRV-Tools-link ${SPIRV_TOOLS_LIBRARY_TYPE} linker.cpp ) spvtools_default_compile_options(SPIRV-Tools-link) target_include_directories(SPIRV-Tools-link PUBLIC $ $ $ PRIVATE ${spirv-tools_BINARY_DIR} ) # We need the IR functionalities from the optimizer target_link_libraries(SPIRV-Tools-link PUBLIC SPIRV-Tools-opt) set_property(TARGET SPIRV-Tools-link PROPERTY FOLDER "SPIRV-Tools libraries") spvtools_check_symbol_exports(SPIRV-Tools-link) if(ENABLE_SPIRV_TOOLS_INSTALL) install(TARGETS SPIRV-Tools-link EXPORT SPIRV-Tools-linkTargets) export(EXPORT SPIRV-Tools-linkTargets FILE SPIRV-Tools-linkTargets.cmake) spvtools_config_package_dir(SPIRV-Tools-link PACKAGE_DIR) install(EXPORT SPIRV-Tools-linkTargets FILE SPIRV-Tools-linkTargets.cmake DESTINATION ${PACKAGE_DIR}) spvtools_generate_config_file(SPIRV-Tools-link) install(FILES ${CMAKE_BINARY_DIR}/SPIRV-Tools-linkConfig.cmake DESTINATION ${PACKAGE_DIR}) endif(ENABLE_SPIRV_TOOLS_INSTALL) KhronosGroup-SPIRV-Tools-f289d04/source/link/linker.cpp000066400000000000000000001157361475742701700227730ustar00rootroot00000000000000// Copyright (c) 2017 Pierre Moreau // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "spirv-tools/linker.hpp" #include #include #include #include #include #include #include #include #include #include #include #include "source/assembly_grammar.h" #include "source/diagnostic.h" #include "source/opt/build_module.h" #include "source/opt/compact_ids_pass.h" #include "source/opt/decoration_manager.h" #include "source/opt/ir_builder.h" #include "source/opt/ir_loader.h" #include "source/opt/pass_manager.h" #include "source/opt/remove_duplicates_pass.h" #include "source/opt/remove_unused_interface_variables_pass.h" #include "source/opt/type_manager.h" #include "source/spirv_constant.h" #include "source/spirv_target_env.h" #include "source/util/make_unique.h" #include "source/util/string_utils.h" #include "spirv-tools/libspirv.hpp" namespace spvtools { namespace { using opt::Instruction; using opt::InstructionBuilder; using opt::IRContext; using opt::Module; using opt::PassManager; using opt::RemoveDuplicatesPass; using opt::analysis::DecorationManager; using opt::analysis::DefUseManager; using opt::analysis::Function; using opt::analysis::Type; using opt::analysis::TypeManager; // Stores various information about an imported or exported symbol. struct LinkageSymbolInfo { spv::Id id; // ID of the symbol spv::Id type_id; // ID of the type of the symbol std::string name; // unique name defining the symbol and used for matching // imports and exports together std::vector parameter_ids; // ID of the parameters of the symbol, if // it is a function }; struct LinkageEntry { LinkageSymbolInfo imported_symbol; LinkageSymbolInfo exported_symbol; LinkageEntry(const LinkageSymbolInfo& import_info, const LinkageSymbolInfo& export_info) : imported_symbol(import_info), exported_symbol(export_info) {} }; using LinkageTable = std::vector; // Shifts the IDs used in each binary of |modules| so that they occupy a // disjoint range from the other binaries, and compute the new ID bound which // is returned in |max_id_bound|. // // Both |modules| and |max_id_bound| should not be null, and |modules| should // not be empty either. Furthermore |modules| should not contain any null // pointers. spv_result_t ShiftIdsInModules(const MessageConsumer& consumer, std::vector* modules, uint32_t* max_id_bound); // Generates the header for the linked module and returns it in |header|. // // |header| should not be null, |modules| should not be empty and pointers // should be non-null. |max_id_bound| should be strictly greater than 0. spv_result_t GenerateHeader(const MessageConsumer& consumer, const std::vector& modules, uint32_t max_id_bound, opt::ModuleHeader* header, const LinkerOptions& options); // Merge all the modules from |in_modules| into a single module owned by // |linked_context|. // // |linked_context| should not be null. spv_result_t MergeModules(const MessageConsumer& consumer, const std::vector& in_modules, const AssemblyGrammar& grammar, IRContext* linked_context); // Compute all pairs of import and export and return it in |linkings_to_do|. // // |linkings_to_do should not be null. Built-in symbols will be ignored. // // TODO(pierremoreau): Linkage attributes applied by a group decoration are // currently not handled. (You could have a group being // applied to a single ID.) // TODO(pierremoreau): What should be the proper behaviour with built-in // symbols? spv_result_t GetImportExportPairs(const MessageConsumer& consumer, const opt::IRContext& linked_context, const DefUseManager& def_use_manager, const DecorationManager& decoration_manager, bool allow_partial_linkage, LinkageTable* linkings_to_do); // Checks that for each pair of import and export, the import and export have // the same type as well as the same decorations. // // TODO(pierremoreau): Decorations on functions parameters are currently not // checked. spv_result_t CheckImportExportCompatibility(const MessageConsumer& consumer, const LinkageTable& linkings_to_do, bool allow_ptr_type_mismatch, opt::IRContext* context); // Remove linkage specific instructions, such as prototypes of imported // functions, declarations of imported variables, import (and export if // necessary) linkage attributes. // // |linked_context| and |decoration_manager| should not be null, and the // 'RemoveDuplicatePass' should be run first. // // TODO(pierremoreau): Linkage attributes applied by a group decoration are // currently not handled. (You could have a group being // applied to a single ID.) spv_result_t RemoveLinkageSpecificInstructions( const MessageConsumer& consumer, const LinkerOptions& options, const LinkageTable& linkings_to_do, DecorationManager* decoration_manager, opt::IRContext* linked_context); // Verify that the unique ids of each instruction in |linked_context| (i.e. the // merged module) are truly unique. Does not check the validity of other ids spv_result_t VerifyIds(const MessageConsumer& consumer, opt::IRContext* linked_context); // Verify that the universal limits are not crossed, and warn the user // otherwise. // // TODO(pierremoreau): // - Verify against the limits of the environment (e.g. Vulkan limits if // consuming vulkan1.x) spv_result_t VerifyLimits(const MessageConsumer& consumer, const opt::IRContext& linked_context); spv_result_t ShiftIdsInModules(const MessageConsumer& consumer, std::vector* modules, uint32_t* max_id_bound) { spv_position_t position = {}; if (modules == nullptr) return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_DATA) << "|modules| of ShiftIdsInModules should not be null."; if (modules->empty()) return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_DATA) << "|modules| of ShiftIdsInModules should not be empty."; if (max_id_bound == nullptr) return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_DATA) << "|max_id_bound| of ShiftIdsInModules should not be null."; const size_t id_bound = std::accumulate(modules->begin(), modules->end(), static_cast(1), [](const size_t& accumulation, opt::Module* module) { return accumulation + module->IdBound() - 1u; }); if (id_bound > std::numeric_limits::max()) return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_DATA) << "Too many IDs (" << id_bound << "): combining all modules would overflow the 32-bit word of the " "SPIR-V header."; *max_id_bound = static_cast(id_bound); uint32_t id_offset = modules->front()->IdBound() - 1u; for (auto module_iter = modules->begin() + 1; module_iter != modules->end(); ++module_iter) { Module* module = *module_iter; module->ForEachInst([&id_offset](Instruction* insn) { insn->ForEachId([&id_offset](uint32_t* id) { *id += id_offset; }); }); id_offset += module->IdBound() - 1u; // Invalidate the DefUseManager module->context()->InvalidateAnalyses(opt::IRContext::kAnalysisDefUse); } return SPV_SUCCESS; } spv_result_t GenerateHeader(const MessageConsumer& consumer, const std::vector& modules, uint32_t max_id_bound, opt::ModuleHeader* header, const LinkerOptions& options) { spv_position_t position = {}; if (modules.empty()) return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_DATA) << "|modules| of GenerateHeader should not be empty."; if (max_id_bound == 0u) return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_DATA) << "|max_id_bound| of GenerateHeader should not be null."; uint32_t linked_version = modules.front()->version(); for (std::size_t i = 1; i < modules.size(); ++i) { const uint32_t module_version = modules[i]->version(); if (options.GetUseHighestVersion()) { linked_version = std::max(linked_version, module_version); } else if (module_version != linked_version) { return DiagnosticStream({0, 0, 1}, consumer, "", SPV_ERROR_INTERNAL) << "Conflicting SPIR-V versions: " << SPV_SPIRV_VERSION_MAJOR_PART(linked_version) << "." << SPV_SPIRV_VERSION_MINOR_PART(linked_version) << " (input modules 1 through " << i << ") vs " << SPV_SPIRV_VERSION_MAJOR_PART(module_version) << "." << SPV_SPIRV_VERSION_MINOR_PART(module_version) << " (input module " << (i + 1) << ")."; } } header->magic_number = spv::MagicNumber; header->version = linked_version; header->generator = SPV_GENERATOR_WORD(SPV_GENERATOR_KHRONOS_LINKER, 0); header->bound = max_id_bound; header->schema = 0u; return SPV_SUCCESS; } spv_result_t MergeModules(const MessageConsumer& consumer, const std::vector& input_modules, const AssemblyGrammar& grammar, IRContext* linked_context) { spv_position_t position = {}; if (linked_context == nullptr) return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_DATA) << "|linked_module| of MergeModules should not be null."; Module* linked_module = linked_context->module(); if (input_modules.empty()) return SPV_SUCCESS; for (const auto& module : input_modules) for (const auto& inst : module->capabilities()) linked_module->AddCapability( std::unique_ptr(inst.Clone(linked_context))); for (const auto& module : input_modules) for (const auto& inst : module->extensions()) linked_module->AddExtension( std::unique_ptr(inst.Clone(linked_context))); for (const auto& module : input_modules) for (const auto& inst : module->ext_inst_imports()) linked_module->AddExtInstImport( std::unique_ptr(inst.Clone(linked_context))); const Instruction* linked_memory_model_inst = input_modules.front()->GetMemoryModel(); if (linked_memory_model_inst == nullptr) { return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_BINARY) << "Input module 1 is lacking an OpMemoryModel instruction."; } const uint32_t linked_addressing_model = linked_memory_model_inst->GetSingleWordOperand(0u); const uint32_t linked_memory_model = linked_memory_model_inst->GetSingleWordOperand(1u); for (std::size_t i = 1; i < input_modules.size(); ++i) { const Module* module = input_modules[i]; const Instruction* memory_model_inst = module->GetMemoryModel(); if (memory_model_inst == nullptr) return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_BINARY) << "Input module " << (i + 1) << " is lacking an OpMemoryModel instruction."; const uint32_t module_addressing_model = memory_model_inst->GetSingleWordOperand(0u); if (module_addressing_model != linked_addressing_model) { spv_operand_desc linked_desc = nullptr, module_desc = nullptr; grammar.lookupOperand(SPV_OPERAND_TYPE_ADDRESSING_MODEL, linked_addressing_model, &linked_desc); grammar.lookupOperand(SPV_OPERAND_TYPE_ADDRESSING_MODEL, module_addressing_model, &module_desc); return DiagnosticStream(position, consumer, "", SPV_ERROR_INTERNAL) << "Conflicting addressing models: " << linked_desc->name << " (input modules 1 through " << i << ") vs " << module_desc->name << " (input module " << (i + 1) << ")."; } const uint32_t module_memory_model = memory_model_inst->GetSingleWordOperand(1u); if (module_memory_model != linked_memory_model) { spv_operand_desc linked_desc = nullptr, module_desc = nullptr; grammar.lookupOperand(SPV_OPERAND_TYPE_MEMORY_MODEL, linked_memory_model, &linked_desc); grammar.lookupOperand(SPV_OPERAND_TYPE_MEMORY_MODEL, module_memory_model, &module_desc); return DiagnosticStream(position, consumer, "", SPV_ERROR_INTERNAL) << "Conflicting memory models: " << linked_desc->name << " (input modules 1 through " << i << ") vs " << module_desc->name << " (input module " << (i + 1) << ")."; } } linked_module->SetMemoryModel(std::unique_ptr( linked_memory_model_inst->Clone(linked_context))); std::vector> entry_points; for (const auto& module : input_modules) for (const auto& inst : module->entry_points()) { const uint32_t model = inst.GetSingleWordInOperand(0); const std::string name = inst.GetInOperand(2).AsString(); const auto i = std::find_if( entry_points.begin(), entry_points.end(), [model, name](const std::pair& v) { return v.first == model && v.second == name; }); if (i != entry_points.end()) { spv_operand_desc desc = nullptr; grammar.lookupOperand(SPV_OPERAND_TYPE_EXECUTION_MODEL, model, &desc); return DiagnosticStream(position, consumer, "", SPV_ERROR_INTERNAL) << "The entry point \"" << name << "\", with execution model " << desc->name << ", was already defined."; } linked_module->AddEntryPoint( std::unique_ptr(inst.Clone(linked_context))); entry_points.emplace_back(model, name); } for (const auto& module : input_modules) for (const auto& inst : module->execution_modes()) linked_module->AddExecutionMode( std::unique_ptr(inst.Clone(linked_context))); for (const auto& module : input_modules) for (const auto& inst : module->debugs1()) linked_module->AddDebug1Inst( std::unique_ptr(inst.Clone(linked_context))); for (const auto& module : input_modules) for (const auto& inst : module->debugs2()) linked_module->AddDebug2Inst( std::unique_ptr(inst.Clone(linked_context))); for (const auto& module : input_modules) for (const auto& inst : module->debugs3()) linked_module->AddDebug3Inst( std::unique_ptr(inst.Clone(linked_context))); for (const auto& module : input_modules) for (const auto& inst : module->ext_inst_debuginfo()) linked_module->AddExtInstDebugInfo( std::unique_ptr(inst.Clone(linked_context))); // If the generated module uses SPIR-V 1.1 or higher, add an // OpModuleProcessed instruction about the linking step. if (linked_module->version() >= SPV_SPIRV_VERSION_WORD(1, 1)) { const std::string processed_string("Linked by SPIR-V Tools Linker"); std::vector processed_words = spvtools::utils::MakeVector(processed_string); linked_module->AddDebug3Inst(std::unique_ptr( new Instruction(linked_context, spv::Op::OpModuleProcessed, 0u, 0u, {{SPV_OPERAND_TYPE_LITERAL_STRING, processed_words}}))); } for (const auto& module : input_modules) for (const auto& inst : module->annotations()) linked_module->AddAnnotationInst( std::unique_ptr(inst.Clone(linked_context))); // TODO(pierremoreau): Since the modules have not been validate, should we // expect spv::StorageClass::Function variables outside // functions? for (const auto& module : input_modules) { for (const auto& inst : module->types_values()) { linked_module->AddType( std::unique_ptr(inst.Clone(linked_context))); } } // Process functions and their basic blocks for (const auto& module : input_modules) { for (const auto& func : *module) { std::unique_ptr cloned_func(func.Clone(linked_context)); linked_module->AddFunction(std::move(cloned_func)); } } return SPV_SUCCESS; } spv_result_t GetImportExportPairs(const MessageConsumer& consumer, const opt::IRContext& linked_context, const DefUseManager& def_use_manager, const DecorationManager& decoration_manager, bool allow_partial_linkage, LinkageTable* linkings_to_do) { spv_position_t position = {}; if (linkings_to_do == nullptr) return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_DATA) << "|linkings_to_do| of GetImportExportPairs should not be empty."; std::vector imports; std::unordered_map> exports; std::unordered_map linkonce; // Figure out the imports and exports for (const auto& decoration : linked_context.annotations()) { if (decoration.opcode() != spv::Op::OpDecorate || spv::Decoration(decoration.GetSingleWordInOperand(1u)) != spv::Decoration::LinkageAttributes) continue; const spv::Id id = decoration.GetSingleWordInOperand(0u); // Ignore if the targeted symbol is a built-in bool is_built_in = false; for (const auto& id_decoration : decoration_manager.GetDecorationsFor(id, false)) { if (spv::Decoration(id_decoration->GetSingleWordInOperand(1u)) == spv::Decoration::BuiltIn) { is_built_in = true; break; } } if (is_built_in) { continue; } const uint32_t type = decoration.GetSingleWordInOperand(3u); LinkageSymbolInfo symbol_info; symbol_info.name = decoration.GetInOperand(2u).AsString(); symbol_info.id = id; symbol_info.type_id = 0u; // Retrieve the type of the current symbol. This information will be used // when checking that the imported and exported symbols have the same // types. const Instruction* def_inst = def_use_manager.GetDef(id); if (def_inst == nullptr) return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_BINARY) << "ID " << id << " is never defined:\n"; if (def_inst->opcode() == spv::Op::OpVariable) { symbol_info.type_id = def_inst->type_id(); } else if (def_inst->opcode() == spv::Op::OpFunction) { symbol_info.type_id = def_inst->GetSingleWordInOperand(1u); // range-based for loop calls begin()/end(), but never cbegin()/cend(), // which will not work here. for (auto func_iter = linked_context.module()->cbegin(); func_iter != linked_context.module()->cend(); ++func_iter) { if (func_iter->result_id() != id) continue; func_iter->ForEachParam([&symbol_info](const Instruction* inst) { symbol_info.parameter_ids.push_back(inst->result_id()); }); } } else { return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_BINARY) << "Only global variables and functions can be decorated using" << " LinkageAttributes; " << id << " is neither of them.\n"; } if (spv::LinkageType(type) == spv::LinkageType::Import) { imports.push_back(symbol_info); } else if (spv::LinkageType(type) == spv::LinkageType::Export) { exports[symbol_info.name].push_back(symbol_info); } else if (spv::LinkageType(type) == spv::LinkageType::LinkOnceODR) { if (linkonce.find(symbol_info.name) == linkonce.end()) linkonce[symbol_info.name] = symbol_info; } } for (const auto& possible_export : linkonce) { if (exports.find(possible_export.first) == exports.end()) exports[possible_export.first].push_back(possible_export.second); else return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_BINARY) << "Combination of Export and LinkOnceODR is not allowed, found " "for \"" << possible_export.second.name << "\"."; } // Find the import/export pairs for (const auto& import : imports) { std::vector possible_exports; const auto& exp = exports.find(import.name); if (exp != exports.end()) possible_exports = exp->second; if (possible_exports.empty() && !allow_partial_linkage) return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_BINARY) << "Unresolved external reference to \"" << import.name << "\"."; else if (possible_exports.size() > 1u) return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_BINARY) << "Too many external references, " << possible_exports.size() << ", were found for \"" << import.name << "\"."; if (!possible_exports.empty()) linkings_to_do->emplace_back(import, possible_exports.front()); } return SPV_SUCCESS; } spv_result_t CheckImportExportCompatibility(const MessageConsumer& consumer, const LinkageTable& linkings_to_do, bool allow_ptr_type_mismatch, opt::IRContext* context) { spv_position_t position = {}; // Ensure the import and export types are the same. const DecorationManager& decoration_manager = *context->get_decoration_mgr(); const TypeManager& type_manager = *context->get_type_mgr(); for (const auto& linking_entry : linkings_to_do) { Type* imported_symbol_type = type_manager.GetType(linking_entry.imported_symbol.type_id); Type* exported_symbol_type = type_manager.GetType(linking_entry.exported_symbol.type_id); if (!(*imported_symbol_type == *exported_symbol_type)) { Function* imported_symbol_type_func = imported_symbol_type->AsFunction(); Function* exported_symbol_type_func = exported_symbol_type->AsFunction(); if (imported_symbol_type_func && exported_symbol_type_func) { const auto& imported_params = imported_symbol_type_func->param_types(); const auto& exported_params = exported_symbol_type_func->param_types(); // allow_ptr_type_mismatch allows linking functions where the pointer // type of arguments doesn't match. Everything else still needs to be // equal. This is to workaround LLVM-17+ not having typed pointers and // generated SPIR-Vs not knowing the actual pointer types in some cases. if (allow_ptr_type_mismatch && imported_params.size() == exported_params.size()) { bool correct = true; for (size_t i = 0; i < imported_params.size(); i++) { const auto& imported_param = imported_params[i]; const auto& exported_param = exported_params[i]; if (!imported_param->IsSame(exported_param) && (imported_param->kind() != Type::kPointer || exported_param->kind() != Type::kPointer)) { correct = false; break; } } if (correct) continue; } } return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_BINARY) << "Type mismatch on symbol \"" << linking_entry.imported_symbol.name << "\" between imported variable/function %" << linking_entry.imported_symbol.id << " and exported variable/function %" << linking_entry.exported_symbol.id << "."; } } // Ensure the import and export decorations are similar for (const auto& linking_entry : linkings_to_do) { if (!decoration_manager.HaveTheSameDecorations( linking_entry.imported_symbol.id, linking_entry.exported_symbol.id)) return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_BINARY) << "Decorations mismatch on symbol \"" << linking_entry.imported_symbol.name << "\" between imported variable/function %" << linking_entry.imported_symbol.id << " and exported variable/function %" << linking_entry.exported_symbol.id << "."; // TODO(pierremoreau): Decorations on function parameters should probably // match, except for FuncParamAttr if I understand the // spec correctly. // TODO(pierremoreau): Decorations on the function return type should // match, except for FuncParamAttr. } return SPV_SUCCESS; } spv_result_t RemoveLinkageSpecificInstructions( const MessageConsumer& consumer, const LinkerOptions& options, const LinkageTable& linkings_to_do, DecorationManager* decoration_manager, opt::IRContext* linked_context) { spv_position_t position = {}; if (decoration_manager == nullptr) return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_DATA) << "|decoration_manager| of RemoveLinkageSpecificInstructions " "should not be empty."; if (linked_context == nullptr) return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_DATA) << "|linked_module| of RemoveLinkageSpecificInstructions should not " "be empty."; // TODO(pierremoreau): Remove FuncParamAttr decorations of imported // functions' return type. // Remove prototypes of imported functions for (const auto& linking_entry : linkings_to_do) { for (auto func_iter = linked_context->module()->begin(); func_iter != linked_context->module()->end();) { if (func_iter->result_id() == linking_entry.imported_symbol.id) func_iter = func_iter.Erase(); else ++func_iter; } } // Remove declarations of imported variables for (const auto& linking_entry : linkings_to_do) { auto next = linked_context->types_values_begin(); for (auto inst = next; inst != linked_context->types_values_end(); inst = next) { ++next; if (inst->result_id() == linking_entry.imported_symbol.id) { linked_context->KillInst(&*inst); } } } // If partial linkage is allowed, we need an efficient way to check whether // an imported ID had a corresponding export symbol. As uses of the imported // symbol have already been replaced by the exported symbol, use the exported // symbol ID. // TODO(pierremoreau): This will not work if the decoration is applied // through a group, but the linker does not support that // either. std::unordered_set imports; if (options.GetAllowPartialLinkage()) { imports.reserve(linkings_to_do.size()); for (const auto& linking_entry : linkings_to_do) imports.emplace(linking_entry.exported_symbol.id); } // Remove import linkage attributes auto next = linked_context->annotation_begin(); for (auto inst = next; inst != linked_context->annotation_end(); inst = next) { ++next; // If this is an import annotation: // * if we do not allow partial linkage, remove all import annotations; // * otherwise, remove the annotation only if there was a corresponding // export. if (inst->opcode() == spv::Op::OpDecorate && spv::Decoration(inst->GetSingleWordOperand(1u)) == spv::Decoration::LinkageAttributes && spv::LinkageType(inst->GetSingleWordOperand(3u)) == spv::LinkageType::Import && (!options.GetAllowPartialLinkage() || imports.find(inst->GetSingleWordOperand(0u)) != imports.end())) { linked_context->KillInst(&*inst); } } // Remove export linkage attributes if making an executable if (!options.GetCreateLibrary()) { next = linked_context->annotation_begin(); for (auto inst = next; inst != linked_context->annotation_end(); inst = next) { ++next; if (inst->opcode() == spv::Op::OpDecorate && spv::Decoration(inst->GetSingleWordOperand(1u)) == spv::Decoration::LinkageAttributes && (spv::LinkageType(inst->GetSingleWordOperand(3u)) == spv::LinkageType::Export || spv::LinkageType(inst->GetSingleWordOperand(3u)) == spv::LinkageType::LinkOnceODR)) { linked_context->KillInst(&*inst); } } } // Remove Linkage capability if making an executable and partial linkage is // not allowed if (!options.GetCreateLibrary() && !options.GetAllowPartialLinkage()) { for (auto& inst : linked_context->capabilities()) if (spv::Capability(inst.GetSingleWordInOperand(0u)) == spv::Capability::Linkage) { linked_context->KillInst(&inst); // The RemoveDuplicatesPass did remove duplicated capabilities, so we // now there aren’t more spv::Capability::Linkage further down. break; } } return SPV_SUCCESS; } spv_result_t VerifyIds(const MessageConsumer& consumer, opt::IRContext* linked_context) { std::unordered_set ids; bool ok = true; linked_context->module()->ForEachInst( [&ids, &ok](const opt::Instruction* inst) { ok &= ids.insert(inst->unique_id()).second; }); if (!ok) { consumer(SPV_MSG_INTERNAL_ERROR, "", {}, "Non-unique id in merged module"); return SPV_ERROR_INVALID_ID; } return SPV_SUCCESS; } spv_result_t VerifyLimits(const MessageConsumer& consumer, const opt::IRContext& linked_context) { spv_position_t position = {}; const uint32_t max_id_bound = linked_context.module()->id_bound(); if (max_id_bound >= SPV_LIMIT_RESULT_ID_BOUND) DiagnosticStream({0u, 0u, 4u}, consumer, "", SPV_WARNING) << "The minimum limit of IDs, " << (SPV_LIMIT_RESULT_ID_BOUND - 1) << ", was exceeded:" << " " << max_id_bound << " is the current ID bound.\n" << "The resulting module might not be supported by all " "implementations."; size_t num_global_values = 0u; for (const auto& inst : linked_context.module()->types_values()) { num_global_values += inst.opcode() == spv::Op::OpVariable; } if (num_global_values >= SPV_LIMIT_GLOBAL_VARIABLES_MAX) DiagnosticStream(position, consumer, "", SPV_WARNING) << "The minimum limit of global values, " << (SPV_LIMIT_GLOBAL_VARIABLES_MAX - 1) << ", was exceeded;" << " " << num_global_values << " global values were found.\n" << "The resulting module might not be supported by all " "implementations."; return SPV_SUCCESS; } spv_result_t FixFunctionCallTypes(opt::IRContext& context, const LinkageTable& linkings) { auto mod = context.module(); const auto type_manager = context.get_type_mgr(); const auto def_use_mgr = context.get_def_use_mgr(); for (auto& func : *mod) { func.ForEachInst([&](Instruction* inst) { if (inst->opcode() != spv::Op::OpFunctionCall) return; opt::Operand& target = inst->GetInOperand(0); // only fix calls to imported functions auto linking = std::find_if( linkings.begin(), linkings.end(), [&](const auto& entry) { return entry.exported_symbol.id == target.AsId(); }); if (linking == linkings.end()) return; auto builder = InstructionBuilder(&context, inst); for (uint32_t i = 1; i < inst->NumInOperands(); ++i) { auto exported_func_param = def_use_mgr->GetDef(linking->exported_symbol.parameter_ids[i - 1]); const Type* target_type = type_manager->GetType(exported_func_param->type_id()); if (target_type->kind() != Type::kPointer) continue; opt::Operand& arg = inst->GetInOperand(i); const Type* param_type = type_manager->GetType(def_use_mgr->GetDef(arg.AsId())->type_id()); // No need to cast if it already matches if (*param_type == *target_type) continue; auto new_id = context.TakeNextId(); // cast to the expected pointer type builder.AddInstruction(MakeUnique( &context, spv::Op::OpBitcast, exported_func_param->type_id(), new_id, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_ID, {arg.AsId()}}}))); inst->SetInOperand(i, {new_id}); } }); } context.InvalidateAnalyses(opt::IRContext::kAnalysisDefUse | opt::IRContext::kAnalysisInstrToBlockMapping); return SPV_SUCCESS; } } // namespace spv_result_t Link(const Context& context, const std::vector>& binaries, std::vector* linked_binary, const LinkerOptions& options) { std::vector binary_ptrs; binary_ptrs.reserve(binaries.size()); std::vector binary_sizes; binary_sizes.reserve(binaries.size()); for (const auto& binary : binaries) { binary_ptrs.push_back(binary.data()); binary_sizes.push_back(binary.size()); } return Link(context, binary_ptrs.data(), binary_sizes.data(), binaries.size(), linked_binary, options); } spv_result_t Link(const Context& context, const uint32_t* const* binaries, const size_t* binary_sizes, size_t num_binaries, std::vector* linked_binary, const LinkerOptions& options) { spv_position_t position = {}; const spv_context& c_context = context.CContext(); const MessageConsumer& consumer = c_context->consumer; linked_binary->clear(); if (num_binaries == 0u) return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_BINARY) << "No modules were given."; std::vector> ir_contexts; std::vector modules; modules.reserve(num_binaries); for (size_t i = 0u; i < num_binaries; ++i) { const uint32_t schema = binaries[i][4u]; if (schema != 0u) { position.index = 4u; return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_BINARY) << "Schema is non-zero for module " << i + 1 << "."; } std::unique_ptr ir_context = BuildModule( c_context->target_env, consumer, binaries[i], binary_sizes[i]); if (ir_context == nullptr) return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_BINARY) << "Failed to build module " << i + 1 << " out of " << num_binaries << "."; modules.push_back(ir_context->module()); ir_contexts.push_back(std::move(ir_context)); } // Phase 1: Shift the IDs used in each binary so that they occupy a disjoint // range from the other binaries, and compute the new ID bound. uint32_t max_id_bound = 0u; spv_result_t res = ShiftIdsInModules(consumer, &modules, &max_id_bound); if (res != SPV_SUCCESS) return res; // Phase 2: Generate the header opt::ModuleHeader header; res = GenerateHeader(consumer, modules, max_id_bound, &header, options); if (res != SPV_SUCCESS) return res; IRContext linked_context(c_context->target_env, consumer); linked_context.module()->SetHeader(header); // Phase 3: Merge all the binaries into a single one. AssemblyGrammar grammar(c_context); res = MergeModules(consumer, modules, grammar, &linked_context); if (res != SPV_SUCCESS) return res; if (options.GetVerifyIds()) { res = VerifyIds(consumer, &linked_context); if (res != SPV_SUCCESS) return res; } // Phase 4: Remove duplicates PassManager manager; manager.SetMessageConsumer(consumer); manager.AddPass(); opt::Pass::Status pass_res = manager.Run(&linked_context); if (pass_res == opt::Pass::Status::Failure) return SPV_ERROR_INVALID_DATA; // Phase 5: Find the import/export pairs LinkageTable linkings_to_do; res = GetImportExportPairs(consumer, linked_context, *linked_context.get_def_use_mgr(), *linked_context.get_decoration_mgr(), options.GetAllowPartialLinkage(), &linkings_to_do); if (res != SPV_SUCCESS) return res; // Phase 6: Ensure the import and export have the same types and decorations. res = CheckImportExportCompatibility(consumer, linkings_to_do, options.GetAllowPtrTypeMismatch(), &linked_context); if (res != SPV_SUCCESS) return res; // Phase 7: Remove all names and decorations of import variables/functions for (const auto& linking_entry : linkings_to_do) { linked_context.KillNamesAndDecorates(linking_entry.imported_symbol.id); for (const auto parameter_id : linking_entry.imported_symbol.parameter_ids) { linked_context.KillNamesAndDecorates(parameter_id); } } // Phase 8: Rematch import variables/functions to export variables/functions for (const auto& linking_entry : linkings_to_do) { linked_context.ReplaceAllUsesWith(linking_entry.imported_symbol.id, linking_entry.exported_symbol.id); } // Phase 9: Remove linkage specific instructions, such as import/export // attributes, linkage capability, etc. if applicable res = RemoveLinkageSpecificInstructions(consumer, options, linkings_to_do, linked_context.get_decoration_mgr(), &linked_context); if (res != SPV_SUCCESS) return res; // Phase 10: Optionally fix function call types if (options.GetAllowPtrTypeMismatch()) { res = FixFunctionCallTypes(linked_context, linkings_to_do); if (res != SPV_SUCCESS) return res; } // Phase 11: Compact the IDs used in the module manager.AddPass(); pass_res = manager.Run(&linked_context); if (pass_res == opt::Pass::Status::Failure) return SPV_ERROR_INVALID_DATA; // Phase 12: Recompute EntryPoint variables manager.AddPass(); pass_res = manager.Run(&linked_context); if (pass_res == opt::Pass::Status::Failure) return SPV_ERROR_INVALID_DATA; // Phase 13: Warn if SPIR-V limits were exceeded res = VerifyLimits(consumer, linked_context); if (res != SPV_SUCCESS) return res; // Phase 14: Output the module linked_context.module()->ToBinary(linked_binary, true); return SPV_SUCCESS; } } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/lint/000077500000000000000000000000001475742701700207775ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/lint/CMakeLists.txt000066400000000000000000000041651475742701700235450ustar00rootroot00000000000000# Copyright (c) 2021 Google LLC. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. set(SPIRV_TOOLS_LINT_SOURCES divergence_analysis.h lints.h linter.cpp divergence_analysis.cpp lint_divergent_derivatives.cpp ) if(MSVC AND (NOT ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang"))) # Enable parallel builds across four cores for this lib. add_definitions(/MP4) endif() add_library(SPIRV-Tools-lint ${SPIRV_TOOLS_LIBRARY_TYPE} ${SPIRV_TOOLS_LINT_SOURCES}) spvtools_default_compile_options(SPIRV-Tools-lint) target_include_directories(SPIRV-Tools-lint PUBLIC $ $ $ PRIVATE ${spirv-tools_BINARY_DIR} ) # We need the assembling and disassembling functionalities in the main library. target_link_libraries(SPIRV-Tools-lint PUBLIC ${SPIRV_TOOLS_FULL_VISIBILITY}) # We need the internals of spirv-opt. target_link_libraries(SPIRV-Tools-lint PUBLIC SPIRV-Tools-opt) set_property(TARGET SPIRV-Tools-lint PROPERTY FOLDER "SPIRV-Tools libraries") spvtools_check_symbol_exports(SPIRV-Tools-lint) if(ENABLE_SPIRV_TOOLS_INSTALL) install(TARGETS SPIRV-Tools-lint EXPORT SPIRV-Tools-lintTargets) export(EXPORT SPIRV-Tools-lintTargets FILE SPIRV-Tools-lintTargets.cmake) spvtools_config_package_dir(SPIRV-Tools-lint PACKAGE_DIR) install(EXPORT SPIRV-Tools-lintTargets FILE SPIRV-Tools-lintTargets.cmake DESTINATION ${PACKAGE_DIR}) spvtools_generate_config_file(SPIRV-Tools-lint) install(FILES ${CMAKE_BINARY_DIR}/SPIRV-Tools-lintConfig.cmake DESTINATION ${PACKAGE_DIR}) endif(ENABLE_SPIRV_TOOLS_INSTALL) KhronosGroup-SPIRV-Tools-f289d04/source/lint/divergence_analysis.cpp000066400000000000000000000222371475742701700255270ustar00rootroot00000000000000// Copyright (c) 2021 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/lint/divergence_analysis.h" #include "source/opt/basic_block.h" #include "source/opt/control_dependence.h" #include "source/opt/dataflow.h" #include "source/opt/function.h" #include "source/opt/instruction.h" namespace spvtools { namespace lint { void DivergenceAnalysis::EnqueueSuccessors(opt::Instruction* inst) { // Enqueue control dependents of block, if applicable. // There are two ways for a dependence source to be updated: // 1. control -> control: source block is marked divergent. // 2. data -> control: branch condition is marked divergent. uint32_t block_id; if (inst->IsBlockTerminator()) { block_id = context().get_instr_block(inst)->id(); } else if (inst->opcode() == spv::Op::OpLabel) { block_id = inst->result_id(); opt::BasicBlock* bb = context().cfg()->block(block_id); // Only enqueue phi instructions, as other uses don't affect divergence. bb->ForEachPhiInst([this](opt::Instruction* phi) { Enqueue(phi); }); } else { opt::ForwardDataFlowAnalysis::EnqueueUsers(inst); return; } if (!cd_.HasBlock(block_id)) { return; } for (const spvtools::opt::ControlDependence& dep : cd_.GetDependenceTargets(block_id)) { opt::Instruction* target_inst = context().cfg()->block(dep.target_bb_id())->GetLabelInst(); Enqueue(target_inst); } } opt::DataFlowAnalysis::VisitResult DivergenceAnalysis::Visit( opt::Instruction* inst) { if (inst->opcode() == spv::Op::OpLabel) { return VisitBlock(inst->result_id()); } else { return VisitInstruction(inst); } } opt::DataFlowAnalysis::VisitResult DivergenceAnalysis::VisitBlock(uint32_t id) { if (!cd_.HasBlock(id)) { return opt::DataFlowAnalysis::VisitResult::kResultFixed; } DivergenceLevel& cur_level = divergence_[id]; if (cur_level == DivergenceLevel::kDivergent) { return opt::DataFlowAnalysis::VisitResult::kResultFixed; } DivergenceLevel orig = cur_level; for (const spvtools::opt::ControlDependence& dep : cd_.GetDependenceSources(id)) { if (divergence_[dep.source_bb_id()] > cur_level) { cur_level = divergence_[dep.source_bb_id()]; divergence_source_[id] = dep.source_bb_id(); } else if (dep.source_bb_id() != 0) { uint32_t condition_id = dep.GetConditionID(*context().cfg()); DivergenceLevel dep_level = divergence_[condition_id]; // Check if we are along the chain of unconditional branches starting from // the branch target. if (follow_unconditional_branches_[dep.branch_target_bb_id()] != follow_unconditional_branches_[dep.target_bb_id()]) { // We must have reconverged in order to reach this block. // Promote partially uniform to divergent. if (dep_level == DivergenceLevel::kPartiallyUniform) { dep_level = DivergenceLevel::kDivergent; } } if (dep_level > cur_level) { cur_level = dep_level; divergence_source_[id] = condition_id; divergence_dependence_source_[id] = dep.source_bb_id(); } } } return cur_level > orig ? VisitResult::kResultChanged : VisitResult::kResultFixed; } opt::DataFlowAnalysis::VisitResult DivergenceAnalysis::VisitInstruction( opt::Instruction* inst) { if (inst->IsBlockTerminator()) { // This is called only when the condition has changed, so return changed. return VisitResult::kResultChanged; } if (!inst->HasResultId()) { return VisitResult::kResultFixed; } uint32_t id = inst->result_id(); DivergenceLevel& cur_level = divergence_[id]; if (cur_level == DivergenceLevel::kDivergent) { return opt::DataFlowAnalysis::VisitResult::kResultFixed; } DivergenceLevel orig = cur_level; cur_level = ComputeInstructionDivergence(inst); return cur_level > orig ? VisitResult::kResultChanged : VisitResult::kResultFixed; } DivergenceAnalysis::DivergenceLevel DivergenceAnalysis::ComputeInstructionDivergence(opt::Instruction* inst) { // TODO(kuhar): Check to see if inst is decorated with Uniform or UniformId // and use that to short circuit other checks. Uniform is for subgroups which // would satisfy derivative groups too. UniformId takes a scope, so if it is // subgroup or greater it could satisfy derivative group and // Device/QueueFamily could satisfy fully uniform. uint32_t id = inst->result_id(); // Handle divergence roots. if (inst->opcode() == spv::Op::OpFunctionParameter) { divergence_source_[id] = 0; return divergence_[id] = DivergenceLevel::kDivergent; } else if (inst->IsLoad()) { spvtools::opt::Instruction* var = inst->GetBaseAddress(); if (var->opcode() != spv::Op::OpVariable) { // Assume divergent. divergence_source_[id] = 0; return DivergenceLevel::kDivergent; } DivergenceLevel ret = ComputeVariableDivergence(var); if (ret > DivergenceLevel::kUniform) { divergence_source_[inst->result_id()] = 0; } return divergence_[id] = ret; } // Get the maximum divergence of the operands. DivergenceLevel ret = DivergenceLevel::kUniform; inst->ForEachInId([this, inst, &ret](const uint32_t* op) { if (!op) return; if (divergence_[*op] > ret) { divergence_source_[inst->result_id()] = *op; ret = divergence_[*op]; } }); divergence_[inst->result_id()] = ret; return ret; } DivergenceAnalysis::DivergenceLevel DivergenceAnalysis::ComputeVariableDivergence(opt::Instruction* var) { uint32_t type_id = var->type_id(); spvtools::opt::analysis::Pointer* type = context().get_type_mgr()->GetType(type_id)->AsPointer(); assert(type != nullptr); uint32_t def_id = var->result_id(); DivergenceLevel ret; switch (type->storage_class()) { case spv::StorageClass::Function: case spv::StorageClass::Generic: case spv::StorageClass::AtomicCounter: case spv::StorageClass::StorageBuffer: case spv::StorageClass::PhysicalStorageBuffer: case spv::StorageClass::Output: case spv::StorageClass::Workgroup: case spv::StorageClass::Image: // Image atomics probably aren't uniform. case spv::StorageClass::Private: ret = DivergenceLevel::kDivergent; break; case spv::StorageClass::Input: ret = DivergenceLevel::kDivergent; // If this variable has a Flat decoration, it is partially uniform. // TODO(kuhar): Track access chain indices and also consider Flat members // of a structure. context().get_decoration_mgr()->WhileEachDecoration( def_id, static_cast(spv::Decoration::Flat), [&ret](const opt::Instruction&) { ret = DivergenceLevel::kPartiallyUniform; return false; }); break; case spv::StorageClass::UniformConstant: // May be a storage image which is also written to; mark those as // divergent. if (!var->IsVulkanStorageImage() || var->IsReadOnlyPointer()) { ret = DivergenceLevel::kUniform; } else { ret = DivergenceLevel::kDivergent; } break; case spv::StorageClass::Uniform: case spv::StorageClass::PushConstant: case spv::StorageClass::CrossWorkgroup: // Not for shaders; default // uniform. default: ret = DivergenceLevel::kUniform; break; } return ret; } void DivergenceAnalysis::Setup(opt::Function* function) { // TODO(kuhar): Run functions called by |function| so we can detect // reconvergence caused by multiple returns. cd_.ComputeControlDependenceGraph( *context().cfg(), *context().GetPostDominatorAnalysis(function)); context().cfg()->ForEachBlockInPostOrder( function->entry().get(), [this](const opt::BasicBlock* bb) { uint32_t id = bb->id(); if (bb->terminator() == nullptr || bb->terminator()->opcode() != spv::Op::OpBranch) { follow_unconditional_branches_[id] = id; } else { uint32_t target_id = bb->terminator()->GetSingleWordInOperand(0); // Target is guaranteed to have been visited before us in postorder. follow_unconditional_branches_[id] = follow_unconditional_branches_[target_id]; } }); } std::ostream& operator<<(std::ostream& os, DivergenceAnalysis::DivergenceLevel level) { switch (level) { case DivergenceAnalysis::DivergenceLevel::kUniform: return os << "uniform"; case DivergenceAnalysis::DivergenceLevel::kPartiallyUniform: return os << "partially uniform"; case DivergenceAnalysis::DivergenceLevel::kDivergent: return os << "divergent"; default: return os << ""; } } } // namespace lint } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/lint/divergence_analysis.h000066400000000000000000000144221475742701700251710ustar00rootroot00000000000000// Copyright (c) 2021 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_LINT_DIVERGENCE_ANALYSIS_H_ #define SOURCE_LINT_DIVERGENCE_ANALYSIS_H_ #include #include #include #include "source/opt/basic_block.h" #include "source/opt/control_dependence.h" #include "source/opt/dataflow.h" #include "source/opt/function.h" #include "source/opt/instruction.h" namespace spvtools { namespace lint { // Computes the static divergence level for blocks (control flow) and values. // // A value is uniform if all threads that execute it are guaranteed to have the // same value. Similarly, a value is partially uniform if this is true only // within each derivative group. If neither apply, it is divergent. // // Control flow through a block is uniform if for any possible execution and // point in time, all threads are executing it, or no threads are executing it. // In particular, it is never possible for some threads to be inside the block // and some threads not executing. // TODO(kuhar): Clarify the difference between uniform, divergent, and // partially-uniform execution in this analysis. // // Caveat: // As we use control dependence to determine how divergence is propagated, this // analysis can be overly permissive when the merge block for a conditional // branch or switch is later than (strictly postdominates) the expected merge // block, which is the immediate postdominator. However, this is not expected to // be a problem in practice, given that SPIR-V is generally output by compilers // and other automated tools, which would assign the earliest possible merge // block, rather than written by hand. // TODO(kuhar): Handle late merges. class DivergenceAnalysis : public opt::ForwardDataFlowAnalysis { public: // The tightest (most uniform) level of divergence that can be determined // statically for a value or control flow for a block. // // The values are ordered such that A > B means that A is potentially more // divergent than B. // TODO(kuhar): Rename |PartiallyUniform' to something less confusing. For // example, the enum could be based on scopes. enum class DivergenceLevel { // The value or control flow is uniform across the entire invocation group. kUniform = 0, // The value or control flow is uniform across the derivative group, but not // the invocation group. kPartiallyUniform = 1, // The value or control flow is not statically uniform. kDivergent = 2, }; DivergenceAnalysis(opt::IRContext& context) : ForwardDataFlowAnalysis(context, LabelPosition::kLabelsAtEnd) {} // Returns the divergence level for the given value (non-label instructions), // or control flow for the given block. DivergenceLevel GetDivergenceLevel(uint32_t id) { auto it = divergence_.find(id); if (it == divergence_.end()) { return DivergenceLevel::kUniform; } return it->second; } // Returns the divergence source for the given id. The following types of // divergence flows from A to B are possible: // // data -> data: A is used as an operand in the definition of B. // data -> control: B is control-dependent on a branch with condition A. // control -> data: B is a OpPhi instruction in which A is a block operand. // control -> control: B is control-dependent on A. uint32_t GetDivergenceSource(uint32_t id) { auto it = divergence_source_.find(id); if (it == divergence_source_.end()) { return 0; } return it->second; } // Returns the dependence source for the control dependence for the given id. // This only exists for data -> control edges. // // In other words, if block 2 is dependent on block 1 due to value 3 (e.g. // block 1 terminates with OpBranchConditional %3 %2 %4): // * GetDivergenceSource(2) = 3 // * GetDivergenceDependenceSource(2) = 1 // // Returns 0 if not applicable. uint32_t GetDivergenceDependenceSource(uint32_t id) { auto it = divergence_dependence_source_.find(id); if (it == divergence_dependence_source_.end()) { return 0; } return it->second; } void InitializeWorklist(opt::Function* function, bool is_first_iteration) override { // Since |EnqueueSuccessors| is complete, we only need one pass. if (is_first_iteration) { Setup(function); opt::ForwardDataFlowAnalysis::InitializeWorklist(function, true); } } void EnqueueSuccessors(opt::Instruction* inst) override; VisitResult Visit(opt::Instruction* inst) override; private: VisitResult VisitBlock(uint32_t id); VisitResult VisitInstruction(opt::Instruction* inst); // Computes the divergence level for the result of the given instruction // based on the current state of the analysis. This is always an // underapproximation, which will be improved as the analysis proceeds. DivergenceLevel ComputeInstructionDivergence(opt::Instruction* inst); // Computes the divergence level for a variable, which is used for loads. DivergenceLevel ComputeVariableDivergence(opt::Instruction* var); // Initializes data structures for performing dataflow on the given function. void Setup(opt::Function* function); std::unordered_map divergence_; std::unordered_map divergence_source_; std::unordered_map divergence_dependence_source_; // Stores the result of following unconditional branches starting from the // given block. This is used to detect when reconvergence needs to be // accounted for. std::unordered_map follow_unconditional_branches_; opt::ControlDependenceAnalysis cd_; }; std::ostream& operator<<(std::ostream& os, DivergenceAnalysis::DivergenceLevel level); } // namespace lint } // namespace spvtools #endif // SOURCE_LINT_DIVERGENCE_ANALYSIS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/lint/lint_divergent_derivatives.cpp000066400000000000000000000135461475742701700271360ustar00rootroot00000000000000// Copyright (c) 2021 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include "source/diagnostic.h" #include "source/lint/divergence_analysis.h" #include "source/lint/lints.h" #include "source/opt/basic_block.h" #include "source/opt/cfg.h" #include "source/opt/control_dependence.h" #include "source/opt/def_use_manager.h" #include "source/opt/dominator_analysis.h" #include "source/opt/instruction.h" #include "source/opt/ir_context.h" #include "spirv-tools/libspirv.h" namespace spvtools { namespace lint { namespace lints { namespace { // Returns the %name[id], where `name` is the first name associated with the // given id, or just %id if one is not found. std::string GetFriendlyName(opt::IRContext* context, uint32_t id) { auto names = context->GetNames(id); std::stringstream ss; ss << "%"; if (names.empty()) { ss << id; } else { opt::Instruction* inst_name = names.begin()->second; if (inst_name->opcode() == spv::Op::OpName) { ss << names.begin()->second->GetInOperand(0).AsString(); ss << "[" << id << "]"; } else { ss << id; } } return ss.str(); } bool InstructionHasDerivative(const opt::Instruction& inst) { static const spv::Op derivative_opcodes[] = { // Implicit derivatives. spv::Op::OpImageSampleImplicitLod, spv::Op::OpImageSampleDrefImplicitLod, spv::Op::OpImageSampleProjImplicitLod, spv::Op::OpImageSampleProjDrefImplicitLod, spv::Op::OpImageSparseSampleImplicitLod, spv::Op::OpImageSparseSampleDrefImplicitLod, spv::Op::OpImageSparseSampleProjImplicitLod, spv::Op::OpImageSparseSampleProjDrefImplicitLod, // Explicit derivatives. spv::Op::OpDPdx, spv::Op::OpDPdy, spv::Op::OpFwidth, spv::Op::OpDPdxFine, spv::Op::OpDPdyFine, spv::Op::OpFwidthFine, spv::Op::OpDPdxCoarse, spv::Op::OpDPdyCoarse, spv::Op::OpFwidthCoarse, }; return std::find(std::begin(derivative_opcodes), std::end(derivative_opcodes), inst.opcode()) != std::end(derivative_opcodes); } spvtools::DiagnosticStream Warn(opt::IRContext* context, opt::Instruction* inst) { if (inst == nullptr) { return DiagnosticStream({0, 0, 0}, context->consumer(), "", SPV_WARNING); } else { // TODO(kuhar): Use line numbers based on debug info. return DiagnosticStream( {0, 0, 0}, context->consumer(), inst->PrettyPrint(SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES), SPV_WARNING); } } void PrintDivergenceFlow(opt::IRContext* context, DivergenceAnalysis div, uint32_t id) { opt::analysis::DefUseManager* def_use = context->get_def_use_mgr(); opt::CFG* cfg = context->cfg(); while (id != 0) { bool is_block = def_use->GetDef(id)->opcode() == spv::Op::OpLabel; if (is_block) { Warn(context, nullptr) << "block " << GetFriendlyName(context, id) << " is divergent"; uint32_t source = div.GetDivergenceSource(id); // Skip intermediate blocks. while (source != 0 && def_use->GetDef(source)->opcode() == spv::Op::OpLabel) { id = source; source = div.GetDivergenceSource(id); } if (source == 0) break; spvtools::opt::Instruction* branch = cfg->block(div.GetDivergenceDependenceSource(id))->terminator(); Warn(context, branch) << "because it depends on a conditional branch on divergent value " << GetFriendlyName(context, source) << ""; id = source; } else { Warn(context, nullptr) << "value " << GetFriendlyName(context, id) << " is divergent"; uint32_t source = div.GetDivergenceSource(id); opt::Instruction* def = def_use->GetDef(id); opt::Instruction* source_def = source == 0 ? nullptr : def_use->GetDef(source); // First print data -> data dependencies. while (source != 0 && source_def->opcode() != spv::Op::OpLabel) { Warn(context, def_use->GetDef(id)) << "because " << GetFriendlyName(context, id) << " uses value " << GetFriendlyName(context, source) << "in its definition, which is divergent"; id = source; def = source_def; source = div.GetDivergenceSource(id); source_def = def_use->GetDef(source); } if (source == 0) { Warn(context, def) << "because it has a divergent definition"; break; } Warn(context, def) << "because it is conditionally set in block " << GetFriendlyName(context, source); id = source; } } } } // namespace bool CheckDivergentDerivatives(opt::IRContext* context) { DivergenceAnalysis div(*context); for (opt::Function& func : *context->module()) { div.Run(&func); for (const opt::BasicBlock& bb : func) { for (const opt::Instruction& inst : bb) { if (InstructionHasDerivative(inst) && div.GetDivergenceLevel(bb.id()) > DivergenceAnalysis::DivergenceLevel::kPartiallyUniform) { Warn(context, nullptr) << "derivative with divergent control flow" << " located in block " << GetFriendlyName(context, bb.id()); PrintDivergenceFlow(context, div, bb.id()); } } } } return true; } } // namespace lints } // namespace lint } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/lint/linter.cpp000066400000000000000000000035111475742701700230000ustar00rootroot00000000000000// Copyright (c) 2021 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "spirv-tools/linter.hpp" #include "source/lint/lints.h" #include "source/opt/build_module.h" #include "source/opt/ir_context.h" #include "spirv-tools/libspirv.h" #include "spirv-tools/libspirv.hpp" namespace spvtools { struct Linter::Impl { explicit Impl(spv_target_env env) : target_env(env) { message_consumer = [](spv_message_level_t /*level*/, const char* /*source*/, const spv_position_t& /*position*/, const char* /*message*/) {}; } spv_target_env target_env; // Target environment. MessageConsumer message_consumer; // Message consumer. }; Linter::Linter(spv_target_env env) : impl_(new Impl(env)) {} Linter::~Linter() {} void Linter::SetMessageConsumer(MessageConsumer consumer) { impl_->message_consumer = std::move(consumer); } const MessageConsumer& Linter::Consumer() const { return impl_->message_consumer; } bool Linter::Run(const uint32_t* binary, size_t binary_size) { std::unique_ptr context = BuildModule(SPV_ENV_VULKAN_1_2, Consumer(), binary, binary_size); if (context == nullptr) return false; bool result = true; result &= lint::lints::CheckDivergentDerivatives(context.get()); return result; } } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/lint/lints.h000066400000000000000000000020651475742701700223040ustar00rootroot00000000000000// Copyright (c) 2021 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_LINT_LINTS_H_ #define SOURCE_LINT_LINTS_H_ #include "source/opt/ir_context.h" namespace spvtools { namespace lint { // All of the functions in this namespace output to the error consumer in the // |context| argument and return |true| if no errors are found. They do not // modify the IR. namespace lints { bool CheckDivergentDerivatives(opt::IRContext* context); } // namespace lints } // namespace lint } // namespace spvtools #endif // SOURCE_LINT_LINTS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/macro.h000066400000000000000000000017151475742701700213070ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_MACRO_H_ #define SOURCE_MACRO_H_ // Evaluates to the number of elements of array A. // // If we could use constexpr, then we could make this a template function. // If the source arrays were std::array, then we could have used // std::array::size. #define ARRAY_SIZE(A) (static_cast(sizeof(A) / sizeof(A[0]))) #endif // SOURCE_MACRO_H_ KhronosGroup-SPIRV-Tools-f289d04/source/name_mapper.cpp000066400000000000000000000256141475742701700230310ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // Modifications Copyright (C) 2024 Advanced Micro Devices, Inc. All rights // reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/name_mapper.h" #include #include #include #include #include #include #include #include "source/binary.h" #include "source/latest_version_spirv_header.h" #include "source/parsed_operand.h" #include "source/to_string.h" #include "spirv-tools/libspirv.h" namespace spvtools { NameMapper GetTrivialNameMapper() { return [](uint32_t i) { return spvtools::to_string(i); }; } FriendlyNameMapper::FriendlyNameMapper(const spv_const_context context, const uint32_t* code, const size_t wordCount) : grammar_(AssemblyGrammar(context)) { spv_diagnostic diag = nullptr; // We don't care if the parse fails. spvBinaryParse(context, this, code, wordCount, nullptr, ParseInstructionForwarder, &diag); spvDiagnosticDestroy(diag); } std::string FriendlyNameMapper::NameForId(uint32_t id) { auto iter = name_for_id_.find(id); if (iter == name_for_id_.end()) { // It must have been an invalid module, so just return a trivial mapping. // We don't care about uniqueness. return to_string(id); } else { return iter->second; } } std::string FriendlyNameMapper::Sanitize(const std::string& suggested_name) { if (suggested_name.empty()) return "_"; // Otherwise, replace invalid characters by '_'. std::string result; std::string valid = "abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ" "_0123456789"; std::transform(suggested_name.begin(), suggested_name.end(), std::back_inserter(result), [&valid](const char c) { return (std::string::npos == valid.find(c)) ? '_' : c; }); return result; } void FriendlyNameMapper::SaveName(uint32_t id, const std::string& suggested_name) { if (name_for_id_.find(id) != name_for_id_.end()) return; const std::string sanitized_suggested_name = Sanitize(suggested_name); std::string name = sanitized_suggested_name; auto inserted = used_names_.insert(name); if (!inserted.second) { const std::string base_name = sanitized_suggested_name + "_"; for (uint32_t index = 0; !inserted.second; ++index) { name = base_name + to_string(index); inserted = used_names_.insert(name); } } name_for_id_[id] = name; } void FriendlyNameMapper::SaveBuiltInName(uint32_t target_id, uint32_t built_in) { #define GLCASE(name) \ case spv::BuiltIn::name: \ SaveName(target_id, "gl_" #name); \ return; #define GLCASE2(name, suggested) \ case spv::BuiltIn::name: \ SaveName(target_id, "gl_" #suggested); \ return; #define CASE(name) \ case spv::BuiltIn::name: \ SaveName(target_id, #name); \ return; switch (spv::BuiltIn(built_in)) { GLCASE(Position) GLCASE(PointSize) GLCASE(ClipDistance) GLCASE(CullDistance) GLCASE2(VertexId, VertexID) GLCASE2(InstanceId, InstanceID) GLCASE2(PrimitiveId, PrimitiveID) GLCASE2(InvocationId, InvocationID) GLCASE(Layer) GLCASE(ViewportIndex) GLCASE(TessLevelOuter) GLCASE(TessLevelInner) GLCASE(TessCoord) GLCASE(PatchVertices) GLCASE(FragCoord) GLCASE(PointCoord) GLCASE(FrontFacing) GLCASE2(SampleId, SampleID) GLCASE(SamplePosition) GLCASE(SampleMask) GLCASE(FragDepth) GLCASE(HelperInvocation) GLCASE2(NumWorkgroups, NumWorkGroups) GLCASE2(WorkgroupSize, WorkGroupSize) GLCASE2(WorkgroupId, WorkGroupID) GLCASE2(LocalInvocationId, LocalInvocationID) GLCASE2(GlobalInvocationId, GlobalInvocationID) GLCASE(LocalInvocationIndex) CASE(WorkDim) CASE(GlobalSize) CASE(EnqueuedWorkgroupSize) CASE(GlobalOffset) CASE(GlobalLinearId) CASE(SubgroupSize) CASE(SubgroupMaxSize) CASE(NumSubgroups) CASE(NumEnqueuedSubgroups) CASE(SubgroupId) CASE(SubgroupLocalInvocationId) GLCASE(VertexIndex) GLCASE(InstanceIndex) GLCASE(BaseInstance) CASE(SubgroupEqMaskKHR) CASE(SubgroupGeMaskKHR) CASE(SubgroupGtMaskKHR) CASE(SubgroupLeMaskKHR) CASE(SubgroupLtMaskKHR) default: break; } #undef GLCASE #undef GLCASE2 #undef CASE } spv_result_t FriendlyNameMapper::ParseInstruction( const spv_parsed_instruction_t& inst) { const auto result_id = inst.result_id; switch (spv::Op(inst.opcode)) { case spv::Op::OpName: SaveName(inst.words[1], spvDecodeLiteralStringOperand(inst, 1)); break; case spv::Op::OpDecorate: // Decorations come after OpName. So OpName will take precedence over // decorations. // // In theory, we should also handle OpGroupDecorate. But that's unlikely // to occur. if (spv::Decoration(inst.words[2]) == spv::Decoration::BuiltIn) { assert(inst.num_words > 3); SaveBuiltInName(inst.words[1], inst.words[3]); } break; case spv::Op::OpTypeVoid: SaveName(result_id, "void"); break; case spv::Op::OpTypeBool: SaveName(result_id, "bool"); break; case spv::Op::OpTypeInt: { std::string signedness; std::string root; const auto bit_width = inst.words[2]; switch (bit_width) { case 8: root = "char"; break; case 16: root = "short"; break; case 32: root = "int"; break; case 64: root = "long"; break; default: root = to_string(bit_width); signedness = "i"; break; } if (0 == inst.words[3]) signedness = "u"; SaveName(result_id, signedness + root); } break; case spv::Op::OpTypeFloat: { const auto bit_width = inst.words[2]; // TODO: Handle optional fpencoding enum once actually used. switch (bit_width) { case 16: SaveName(result_id, "half"); break; case 32: SaveName(result_id, "float"); break; case 64: SaveName(result_id, "double"); break; default: SaveName(result_id, std::string("fp") + to_string(bit_width)); break; } } break; case spv::Op::OpTypeVector: SaveName(result_id, std::string("v") + to_string(inst.words[3]) + NameForId(inst.words[2])); break; case spv::Op::OpTypeMatrix: SaveName(result_id, std::string("mat") + to_string(inst.words[3]) + NameForId(inst.words[2])); break; case spv::Op::OpTypeArray: SaveName(result_id, std::string("_arr_") + NameForId(inst.words[2]) + "_" + NameForId(inst.words[3])); break; case spv::Op::OpTypeRuntimeArray: SaveName(result_id, std::string("_runtimearr_") + NameForId(inst.words[2])); break; case spv::Op::OpTypeNodePayloadArrayAMDX: SaveName(result_id, std::string("_payloadarr_") + NameForId(inst.words[2])); break; case spv::Op::OpTypePointer: SaveName(result_id, std::string("_ptr_") + NameForEnumOperand(SPV_OPERAND_TYPE_STORAGE_CLASS, inst.words[2]) + "_" + NameForId(inst.words[3])); break; case spv::Op::OpTypeUntypedPointerKHR: SaveName(result_id, std::string("_ptr_") + NameForEnumOperand(SPV_OPERAND_TYPE_STORAGE_CLASS, inst.words[2])); break; case spv::Op::OpTypePipe: SaveName(result_id, std::string("Pipe") + NameForEnumOperand(SPV_OPERAND_TYPE_ACCESS_QUALIFIER, inst.words[2])); break; case spv::Op::OpTypeEvent: SaveName(result_id, "Event"); break; case spv::Op::OpTypeDeviceEvent: SaveName(result_id, "DeviceEvent"); break; case spv::Op::OpTypeReserveId: SaveName(result_id, "ReserveId"); break; case spv::Op::OpTypeQueue: SaveName(result_id, "Queue"); break; case spv::Op::OpTypeOpaque: SaveName(result_id, std::string("Opaque_") + Sanitize(spvDecodeLiteralStringOperand(inst, 1))); break; case spv::Op::OpTypePipeStorage: SaveName(result_id, "PipeStorage"); break; case spv::Op::OpTypeNamedBarrier: SaveName(result_id, "NamedBarrier"); break; case spv::Op::OpTypeStruct: // Structs are mapped rather simplisitically. Just indicate that they // are a struct and then give the raw Id number. SaveName(result_id, std::string("_struct_") + to_string(result_id)); break; case spv::Op::OpConstantTrue: SaveName(result_id, "true"); break; case spv::Op::OpConstantFalse: SaveName(result_id, "false"); break; case spv::Op::OpConstant: { std::ostringstream value; EmitNumericLiteral(&value, inst, inst.operands[2]); auto value_str = value.str(); // Use 'n' to signify negative. Other invalid characters will be mapped // to underscore. for (auto& c : value_str) if (c == '-') c = 'n'; SaveName(result_id, NameForId(inst.type_id) + "_" + value_str); } break; default: // If this instruction otherwise defines an Id, then save a mapping for // it. This is needed to ensure uniqueness in there is an OpName with // string something like "1" that might collide with this result_id. // We should only do this if a name hasn't already been registered by some // previous forward reference. if (result_id && name_for_id_.find(result_id) == name_for_id_.end()) SaveName(result_id, to_string(result_id)); break; } return SPV_SUCCESS; } std::string FriendlyNameMapper::NameForEnumOperand(spv_operand_type_t type, uint32_t word) { spv_operand_desc desc = nullptr; if (SPV_SUCCESS == grammar_.lookupOperand(type, word, &desc)) { return desc->name; } else { // Invalid input. Just give something. return std::string("StorageClass") + to_string(word); } } } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/name_mapper.h000066400000000000000000000122661475742701700224750ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_NAME_MAPPER_H_ #define SOURCE_NAME_MAPPER_H_ #include #include #include #include #include "source/assembly_grammar.h" #include "spirv-tools/libspirv.h" namespace spvtools { // A NameMapper maps SPIR-V Id values to names. Each name is valid to use in // SPIR-V assembly. The mapping is one-to-one, i.e. no two Ids map to the same // name. using NameMapper = std::function; // Returns a NameMapper which always maps an Id to its decimal representation. NameMapper GetTrivialNameMapper(); // A FriendlyNameMapper parses a module upon construction. If the parse is // successful, then the NameForId method maps an Id to a friendly name // while also satisfying the constraints on a NameMapper. // // The mapping is friendly in the following sense: // - If an Id has a debug name (via OpName), then that will be used when // possible. // - Well known scalar types map to friendly names. For example, // OpTypeVoid should be %void. Scalar types map to their names in OpenCL // when // there is a correspondence, and otherwise as follows: // - unsigned integer type of n bits map to "u" followed by n // - signed integer type of n bits map to "i" followed by n // - floating point type of n bits map to "fp" followed by n // - Vector type names map to "v" followed by the number of components, // followed by the friendly name for the base type. // - Matrix type names map to "mat" followed by the number of columns, // followed by the friendly name for the base vector type. // - Pointer types map to "_ptr_", then the name of the storage class, then the // name for the pointee type. // - Exotic types like event, pipe, opaque, queue, reserve-id map to their own // human readable names. // - A struct type maps to "_struct_" followed by the raw Id number. That's // pretty simplistic, but workable. // - A built-in variable maps to its GLSL variable name. // - Numeric literals in OpConstant map to a human-friendly name. class FriendlyNameMapper { public: // Construct a friendly name mapper, and determine friendly names for each // defined Id in the specified module. The module is specified by the code // wordCount, and should be parseable in the specified context. FriendlyNameMapper(const spv_const_context context, const uint32_t* code, const size_t wordCount); // Returns a NameMapper which maps ids to the friendly names parsed from the // module provided to the constructor. NameMapper GetNameMapper() { return [this](uint32_t id) { return this->NameForId(id); }; } // Returns the friendly name for the given id. If the module parsed during // construction is valid, then the mapping satisfies the rules for a // NameMapper. std::string NameForId(uint32_t id); private: // Transforms the given string so that it is acceptable as an Id name in // assembly language. Two distinct inputs can map to the same output. std::string Sanitize(const std::string& suggested_name); // Records a name for the given id. If this id already has a name, then // this is a no-op. If the id doesn't have a name, use the given // suggested_name if it hasn't already been taken, and otherwise generate // a new (unused) name based on the suggested name. void SaveName(uint32_t id, const std::string& suggested_name); // Records a built-in variable name for target_id. If target_id already // has a name then this is a no-op. void SaveBuiltInName(uint32_t target_id, uint32_t built_in); // Collects information from the given parsed instruction to populate // name_for_id_. Returns SPV_SUCCESS; spv_result_t ParseInstruction(const spv_parsed_instruction_t& inst); // Forwards a parsed-instruction callback from the binary parser into the // FriendlyNameMapper hidden inside the user_data parameter. static spv_result_t ParseInstructionForwarder( void* user_data, const spv_parsed_instruction_t* parsed_instruction) { return reinterpret_cast(user_data)->ParseInstruction( *parsed_instruction); } // Returns the friendly name for an enumerant. std::string NameForEnumOperand(spv_operand_type_t type, uint32_t word); // Maps an id to its friendly name. This will have an entry for each Id // defined in the module. std::unordered_map name_for_id_; // The set of names that have a mapping in name_for_id_; std::unordered_set used_names_; // The assembly grammar for the current context. const AssemblyGrammar grammar_; }; } // namespace spvtools #endif // SOURCE_NAME_MAPPER_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opcode.cpp000066400000000000000000000646321475742701700220210ustar00rootroot00000000000000// Copyright (c) 2015-2022 The Khronos Group Inc. // Modifications Copyright (C) 2020-2024 Advanced Micro Devices, Inc. All // rights reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opcode.h" #include #include #include #include #include "source/instruction.h" #include "source/macro.h" #include "source/spirv_constant.h" #include "source/spirv_endian.h" #include "source/spirv_target_env.h" #include "spirv-tools/libspirv.h" namespace { struct OpcodeDescPtrLen { const spv_opcode_desc_t* ptr; uint32_t len; }; #include "core.insts-unified1.inc" static const spv_opcode_table_t kOpcodeTable = {ARRAY_SIZE(kOpcodeTableEntries), kOpcodeTableEntries}; // Represents a vendor tool entry in the SPIR-V XML Registry. struct VendorTool { uint32_t value; const char* vendor; const char* tool; // Might be empty string. const char* vendor_tool; // Combination of vendor and tool. }; const VendorTool vendor_tools[] = { #include "generators.inc" }; } // anonymous namespace // TODO(dneto): Move this to another file. It doesn't belong with opcode // processing. const char* spvGeneratorStr(uint32_t generator) { auto where = std::find_if( std::begin(vendor_tools), std::end(vendor_tools), [generator](const VendorTool& vt) { return generator == vt.value; }); if (where != std::end(vendor_tools)) return where->vendor_tool; return "Unknown"; } uint32_t spvOpcodeMake(uint16_t wordCount, spv::Op opcode) { return ((uint32_t)opcode) | (((uint32_t)wordCount) << 16); } void spvOpcodeSplit(const uint32_t word, uint16_t* pWordCount, uint16_t* pOpcode) { if (pWordCount) { *pWordCount = (uint16_t)((0xffff0000 & word) >> 16); } if (pOpcode) { *pOpcode = 0x0000ffff & word; } } spv_result_t spvOpcodeTableGet(spv_opcode_table* pInstTable, spv_target_env) { if (!pInstTable) return SPV_ERROR_INVALID_POINTER; // Descriptions of each opcode. Each entry describes the format of the // instruction that follows a particular opcode. *pInstTable = &kOpcodeTable; return SPV_SUCCESS; } spv_result_t spvOpcodeTableNameLookup(spv_target_env env, const spv_opcode_table table, const char* name, spv_opcode_desc* pEntry) { if (!name || !pEntry) return SPV_ERROR_INVALID_POINTER; if (!table) return SPV_ERROR_INVALID_TABLE; // TODO: This lookup of the Opcode table is suboptimal! Binary sort would be // preferable but the table requires sorting on the Opcode name, but it's // static const initialized and matches the order of the spec. const size_t nameLength = strlen(name); const auto version = spvVersionForTargetEnv(env); for (uint64_t opcodeIndex = 0; opcodeIndex < table->count; ++opcodeIndex) { const spv_opcode_desc_t& entry = table->entries[opcodeIndex]; // We consider the current opcode as available as long as // 1. The target environment satisfies the minimal requirement of the // opcode; or // 2. There is at least one extension enabling this opcode. // // Note that the second rule assumes the extension enabling this instruction // is indeed requested in the SPIR-V code; checking that should be // validator's work. if ((version >= entry.minVersion && version <= entry.lastVersion) || entry.numExtensions > 0u || entry.numCapabilities > 0u) { // Exact match case. if (nameLength == strlen(entry.name) && !strncmp(name, entry.name, nameLength)) { *pEntry = &entry; return SPV_SUCCESS; } // Lack of binary search really hurts here. There isn't an easy filter to // apply before checking aliases since we need to handle promotion from // vendor to KHR/EXT and KHR/EXT to core. It would require a sure-fire way // of dropping suffices. Fortunately, most lookup are based on token // value. // // If this was a binary search we could iterate between the lower and // upper bounds. if (entry.numAliases > 0) { for (uint32_t aliasIndex = 0; aliasIndex < entry.numAliases; aliasIndex++) { // Skip Op prefix. Should this be encoded in the table instead? const auto alias = entry.aliases[aliasIndex] + 2; const size_t aliasLength = strlen(alias); if (nameLength == aliasLength && !strncmp(name, alias, nameLength)) { *pEntry = &entry; return SPV_SUCCESS; } } } } } return SPV_ERROR_INVALID_LOOKUP; } spv_result_t spvOpcodeTableValueLookup(spv_target_env env, const spv_opcode_table table, const spv::Op opcode, spv_opcode_desc* pEntry) { if (!table) return SPV_ERROR_INVALID_TABLE; if (!pEntry) return SPV_ERROR_INVALID_POINTER; const auto beg = table->entries; const auto end = table->entries + table->count; spv_opcode_desc_t needle = {"", opcode, 0, nullptr, 0, {}, 0, {}, false, false, 0, nullptr, ~0u, ~0u}; auto comp = [](const spv_opcode_desc_t& lhs, const spv_opcode_desc_t& rhs) { return lhs.opcode < rhs.opcode; }; // We need to loop here because there can exist multiple symbols for the same // opcode value, and they can be introduced in different target environments, // which means they can have different minimal version requirements. // Assumes the underlying table is already sorted ascendingly according to // opcode value. const auto version = spvVersionForTargetEnv(env); for (auto it = std::lower_bound(beg, end, needle, comp); it != end && it->opcode == opcode; ++it) { // We considers the current opcode as available as long as // 1. The target environment satisfies the minimal requirement of the // opcode; or // 2. There is at least one extension enabling this opcode. // // Note that the second rule assumes the extension enabling this instruction // is indeed requested in the SPIR-V code; checking that should be // validator's work. if ((version >= it->minVersion && version <= it->lastVersion) || it->numExtensions > 0u || it->numCapabilities > 0u) { *pEntry = it; return SPV_SUCCESS; } } return SPV_ERROR_INVALID_LOOKUP; } void spvInstructionCopy(const uint32_t* words, const spv::Op opcode, const uint16_t wordCount, const spv_endianness_t endian, spv_instruction_t* pInst) { pInst->opcode = opcode; pInst->words.resize(wordCount); for (uint16_t wordIndex = 0; wordIndex < wordCount; ++wordIndex) { pInst->words[wordIndex] = spvFixWord(words[wordIndex], endian); if (!wordIndex) { uint16_t thisWordCount; uint16_t thisOpcode; spvOpcodeSplit(pInst->words[wordIndex], &thisWordCount, &thisOpcode); assert(opcode == static_cast(thisOpcode) && wordCount == thisWordCount && "Endianness failed!"); } } } const char* spvOpcodeString(const uint32_t opcode) { const auto beg = kOpcodeTableEntries; const auto end = kOpcodeTableEntries + ARRAY_SIZE(kOpcodeTableEntries); spv_opcode_desc_t needle = {"", static_cast(opcode), 0, nullptr, 0, {}, 0, {}, false, false, 0, nullptr, ~0u, ~0u}; auto comp = [](const spv_opcode_desc_t& lhs, const spv_opcode_desc_t& rhs) { return lhs.opcode < rhs.opcode; }; auto it = std::lower_bound(beg, end, needle, comp); if (it != end && it->opcode == spv::Op(opcode)) { return it->name; } assert(0 && "Unreachable!"); return "unknown"; } const char* spvOpcodeString(const spv::Op opcode) { return spvOpcodeString(static_cast(opcode)); } int32_t spvOpcodeIsScalarType(const spv::Op opcode) { switch (opcode) { case spv::Op::OpTypeInt: case spv::Op::OpTypeFloat: case spv::Op::OpTypeBool: return true; default: return false; } } int32_t spvOpcodeIsSpecConstant(const spv::Op opcode) { switch (opcode) { case spv::Op::OpSpecConstantTrue: case spv::Op::OpSpecConstantFalse: case spv::Op::OpSpecConstant: case spv::Op::OpSpecConstantComposite: case spv::Op::OpSpecConstantCompositeReplicateEXT: case spv::Op::OpSpecConstantOp: return true; default: return false; } } int32_t spvOpcodeIsConstant(const spv::Op opcode) { switch (opcode) { case spv::Op::OpConstantTrue: case spv::Op::OpConstantFalse: case spv::Op::OpConstant: case spv::Op::OpConstantComposite: case spv::Op::OpConstantCompositeReplicateEXT: case spv::Op::OpConstantSampler: case spv::Op::OpConstantNull: case spv::Op::OpConstantFunctionPointerINTEL: case spv::Op::OpConstantStringAMDX: case spv::Op::OpSpecConstantTrue: case spv::Op::OpSpecConstantFalse: case spv::Op::OpSpecConstant: case spv::Op::OpSpecConstantComposite: case spv::Op::OpSpecConstantCompositeReplicateEXT: case spv::Op::OpSpecConstantOp: case spv::Op::OpSpecConstantStringAMDX: return true; default: return false; } } bool spvOpcodeIsConstantOrUndef(const spv::Op opcode) { return opcode == spv::Op::OpUndef || spvOpcodeIsConstant(opcode); } bool spvOpcodeIsScalarSpecConstant(const spv::Op opcode) { switch (opcode) { case spv::Op::OpSpecConstantTrue: case spv::Op::OpSpecConstantFalse: case spv::Op::OpSpecConstant: return true; default: return false; } } int32_t spvOpcodeIsComposite(const spv::Op opcode) { switch (opcode) { case spv::Op::OpTypeVector: case spv::Op::OpTypeMatrix: case spv::Op::OpTypeArray: case spv::Op::OpTypeStruct: case spv::Op::OpTypeRuntimeArray: case spv::Op::OpTypeCooperativeMatrixNV: case spv::Op::OpTypeCooperativeMatrixKHR: case spv::Op::OpTypeCooperativeVectorNV: return true; default: return false; } } bool spvOpcodeReturnsLogicalVariablePointer(const spv::Op opcode) { switch (opcode) { case spv::Op::OpVariable: case spv::Op::OpUntypedVariableKHR: case spv::Op::OpAccessChain: case spv::Op::OpInBoundsAccessChain: case spv::Op::OpUntypedAccessChainKHR: case spv::Op::OpUntypedInBoundsAccessChainKHR: case spv::Op::OpFunctionParameter: case spv::Op::OpImageTexelPointer: case spv::Op::OpCopyObject: case spv::Op::OpAllocateNodePayloadsAMDX: case spv::Op::OpSelect: case spv::Op::OpPhi: case spv::Op::OpFunctionCall: case spv::Op::OpPtrAccessChain: case spv::Op::OpUntypedPtrAccessChainKHR: case spv::Op::OpLoad: case spv::Op::OpConstantNull: case spv::Op::OpRawAccessChainNV: return true; default: return false; } } int32_t spvOpcodeReturnsLogicalPointer(const spv::Op opcode) { switch (opcode) { case spv::Op::OpVariable: case spv::Op::OpUntypedVariableKHR: case spv::Op::OpAccessChain: case spv::Op::OpInBoundsAccessChain: case spv::Op::OpUntypedAccessChainKHR: case spv::Op::OpUntypedInBoundsAccessChainKHR: case spv::Op::OpFunctionParameter: case spv::Op::OpImageTexelPointer: case spv::Op::OpCopyObject: case spv::Op::OpRawAccessChainNV: case spv::Op::OpAllocateNodePayloadsAMDX: return true; default: return false; } } int32_t spvOpcodeGeneratesType(spv::Op op) { switch (op) { case spv::Op::OpTypeVoid: case spv::Op::OpTypeBool: case spv::Op::OpTypeInt: case spv::Op::OpTypeFloat: case spv::Op::OpTypeVector: case spv::Op::OpTypeMatrix: case spv::Op::OpTypeImage: case spv::Op::OpTypeSampler: case spv::Op::OpTypeSampledImage: case spv::Op::OpTypeArray: case spv::Op::OpTypeRuntimeArray: case spv::Op::OpTypeStruct: case spv::Op::OpTypeOpaque: case spv::Op::OpTypePointer: case spv::Op::OpTypeFunction: case spv::Op::OpTypeEvent: case spv::Op::OpTypeDeviceEvent: case spv::Op::OpTypeReserveId: case spv::Op::OpTypeQueue: case spv::Op::OpTypePipe: case spv::Op::OpTypePipeStorage: case spv::Op::OpTypeNamedBarrier: case spv::Op::OpTypeAccelerationStructureNV: case spv::Op::OpTypeCooperativeMatrixNV: case spv::Op::OpTypeCooperativeMatrixKHR: case spv::Op::OpTypeCooperativeVectorNV: // case spv::Op::OpTypeAccelerationStructureKHR: covered by // spv::Op::OpTypeAccelerationStructureNV case spv::Op::OpTypeRayQueryKHR: case spv::Op::OpTypeHitObjectNV: case spv::Op::OpTypeUntypedPointerKHR: case spv::Op::OpTypeNodePayloadArrayAMDX: case spv::Op::OpTypeTensorLayoutNV: case spv::Op::OpTypeTensorViewNV: return true; default: // In particular, OpTypeForwardPointer does not generate a type, // but declares a storage class for a pointer type generated // by a different instruction. break; } return 0; } bool spvOpcodeIsDecoration(const spv::Op opcode) { switch (opcode) { case spv::Op::OpDecorate: case spv::Op::OpDecorateId: case spv::Op::OpMemberDecorate: case spv::Op::OpGroupDecorate: case spv::Op::OpGroupMemberDecorate: case spv::Op::OpDecorateStringGOOGLE: case spv::Op::OpMemberDecorateStringGOOGLE: return true; default: break; } return false; } bool spvOpcodeIsLoad(const spv::Op opcode) { switch (opcode) { case spv::Op::OpLoad: case spv::Op::OpImageSampleExplicitLod: case spv::Op::OpImageSampleImplicitLod: case spv::Op::OpImageSampleDrefImplicitLod: case spv::Op::OpImageSampleDrefExplicitLod: case spv::Op::OpImageSampleProjImplicitLod: case spv::Op::OpImageSampleProjExplicitLod: case spv::Op::OpImageSampleProjDrefImplicitLod: case spv::Op::OpImageSampleProjDrefExplicitLod: case spv::Op::OpImageSampleFootprintNV: case spv::Op::OpImageFetch: case spv::Op::OpImageGather: case spv::Op::OpImageDrefGather: case spv::Op::OpImageRead: case spv::Op::OpImageSparseSampleImplicitLod: case spv::Op::OpImageSparseSampleExplicitLod: case spv::Op::OpImageSparseSampleDrefExplicitLod: case spv::Op::OpImageSparseSampleDrefImplicitLod: case spv::Op::OpImageSparseFetch: case spv::Op::OpImageSparseGather: case spv::Op::OpImageSparseDrefGather: case spv::Op::OpImageSparseRead: return true; default: return false; } } bool spvOpcodeIsBranch(spv::Op opcode) { switch (opcode) { case spv::Op::OpBranch: case spv::Op::OpBranchConditional: case spv::Op::OpSwitch: return true; default: return false; } } bool spvOpcodeIsAtomicWithLoad(const spv::Op opcode) { switch (opcode) { case spv::Op::OpAtomicLoad: case spv::Op::OpAtomicExchange: case spv::Op::OpAtomicCompareExchange: case spv::Op::OpAtomicCompareExchangeWeak: case spv::Op::OpAtomicIIncrement: case spv::Op::OpAtomicIDecrement: case spv::Op::OpAtomicIAdd: case spv::Op::OpAtomicFAddEXT: case spv::Op::OpAtomicISub: case spv::Op::OpAtomicSMin: case spv::Op::OpAtomicUMin: case spv::Op::OpAtomicFMinEXT: case spv::Op::OpAtomicSMax: case spv::Op::OpAtomicUMax: case spv::Op::OpAtomicFMaxEXT: case spv::Op::OpAtomicAnd: case spv::Op::OpAtomicOr: case spv::Op::OpAtomicXor: case spv::Op::OpAtomicFlagTestAndSet: return true; default: return false; } } bool spvOpcodeIsAtomicOp(const spv::Op opcode) { return (spvOpcodeIsAtomicWithLoad(opcode) || opcode == spv::Op::OpAtomicStore || opcode == spv::Op::OpAtomicFlagClear); } bool spvOpcodeIsReturn(spv::Op opcode) { switch (opcode) { case spv::Op::OpReturn: case spv::Op::OpReturnValue: return true; default: return false; } } bool spvOpcodeIsAbort(spv::Op opcode) { switch (opcode) { case spv::Op::OpKill: case spv::Op::OpUnreachable: case spv::Op::OpTerminateInvocation: case spv::Op::OpTerminateRayKHR: case spv::Op::OpIgnoreIntersectionKHR: case spv::Op::OpEmitMeshTasksEXT: return true; default: return false; } } bool spvOpcodeIsReturnOrAbort(spv::Op opcode) { return spvOpcodeIsReturn(opcode) || spvOpcodeIsAbort(opcode); } bool spvOpcodeIsBlockTerminator(spv::Op opcode) { return spvOpcodeIsBranch(opcode) || spvOpcodeIsReturnOrAbort(opcode); } bool spvOpcodeIsBaseOpaqueType(spv::Op opcode) { switch (opcode) { case spv::Op::OpTypeImage: case spv::Op::OpTypeSampler: case spv::Op::OpTypeSampledImage: case spv::Op::OpTypeOpaque: case spv::Op::OpTypeEvent: case spv::Op::OpTypeDeviceEvent: case spv::Op::OpTypeReserveId: case spv::Op::OpTypeQueue: case spv::Op::OpTypePipe: case spv::Op::OpTypeForwardPointer: case spv::Op::OpTypePipeStorage: case spv::Op::OpTypeNamedBarrier: return true; default: return false; } } bool spvOpcodeIsNonUniformGroupOperation(spv::Op opcode) { switch (opcode) { case spv::Op::OpGroupNonUniformElect: case spv::Op::OpGroupNonUniformAll: case spv::Op::OpGroupNonUniformAny: case spv::Op::OpGroupNonUniformAllEqual: case spv::Op::OpGroupNonUniformBroadcast: case spv::Op::OpGroupNonUniformBroadcastFirst: case spv::Op::OpGroupNonUniformBallot: case spv::Op::OpGroupNonUniformInverseBallot: case spv::Op::OpGroupNonUniformBallotBitExtract: case spv::Op::OpGroupNonUniformBallotBitCount: case spv::Op::OpGroupNonUniformBallotFindLSB: case spv::Op::OpGroupNonUniformBallotFindMSB: case spv::Op::OpGroupNonUniformShuffle: case spv::Op::OpGroupNonUniformShuffleXor: case spv::Op::OpGroupNonUniformShuffleUp: case spv::Op::OpGroupNonUniformShuffleDown: case spv::Op::OpGroupNonUniformIAdd: case spv::Op::OpGroupNonUniformFAdd: case spv::Op::OpGroupNonUniformIMul: case spv::Op::OpGroupNonUniformFMul: case spv::Op::OpGroupNonUniformSMin: case spv::Op::OpGroupNonUniformUMin: case spv::Op::OpGroupNonUniformFMin: case spv::Op::OpGroupNonUniformSMax: case spv::Op::OpGroupNonUniformUMax: case spv::Op::OpGroupNonUniformFMax: case spv::Op::OpGroupNonUniformBitwiseAnd: case spv::Op::OpGroupNonUniformBitwiseOr: case spv::Op::OpGroupNonUniformBitwiseXor: case spv::Op::OpGroupNonUniformLogicalAnd: case spv::Op::OpGroupNonUniformLogicalOr: case spv::Op::OpGroupNonUniformLogicalXor: case spv::Op::OpGroupNonUniformQuadBroadcast: case spv::Op::OpGroupNonUniformQuadSwap: case spv::Op::OpGroupNonUniformRotateKHR: case spv::Op::OpGroupNonUniformQuadAllKHR: case spv::Op::OpGroupNonUniformQuadAnyKHR: return true; default: return false; } } bool spvOpcodeIsScalarizable(spv::Op opcode) { switch (opcode) { case spv::Op::OpPhi: case spv::Op::OpCopyObject: case spv::Op::OpConvertFToU: case spv::Op::OpConvertFToS: case spv::Op::OpConvertSToF: case spv::Op::OpConvertUToF: case spv::Op::OpUConvert: case spv::Op::OpSConvert: case spv::Op::OpFConvert: case spv::Op::OpQuantizeToF16: case spv::Op::OpVectorInsertDynamic: case spv::Op::OpSNegate: case spv::Op::OpFNegate: case spv::Op::OpIAdd: case spv::Op::OpFAdd: case spv::Op::OpISub: case spv::Op::OpFSub: case spv::Op::OpIMul: case spv::Op::OpFMul: case spv::Op::OpUDiv: case spv::Op::OpSDiv: case spv::Op::OpFDiv: case spv::Op::OpUMod: case spv::Op::OpSRem: case spv::Op::OpSMod: case spv::Op::OpFRem: case spv::Op::OpFMod: case spv::Op::OpVectorTimesScalar: case spv::Op::OpIAddCarry: case spv::Op::OpISubBorrow: case spv::Op::OpUMulExtended: case spv::Op::OpSMulExtended: case spv::Op::OpShiftRightLogical: case spv::Op::OpShiftRightArithmetic: case spv::Op::OpShiftLeftLogical: case spv::Op::OpBitwiseOr: case spv::Op::OpBitwiseAnd: case spv::Op::OpNot: case spv::Op::OpBitFieldInsert: case spv::Op::OpBitFieldSExtract: case spv::Op::OpBitFieldUExtract: case spv::Op::OpBitReverse: case spv::Op::OpBitCount: case spv::Op::OpIsNan: case spv::Op::OpIsInf: case spv::Op::OpIsFinite: case spv::Op::OpIsNormal: case spv::Op::OpSignBitSet: case spv::Op::OpLessOrGreater: case spv::Op::OpOrdered: case spv::Op::OpUnordered: case spv::Op::OpLogicalEqual: case spv::Op::OpLogicalNotEqual: case spv::Op::OpLogicalOr: case spv::Op::OpLogicalAnd: case spv::Op::OpLogicalNot: case spv::Op::OpSelect: case spv::Op::OpIEqual: case spv::Op::OpINotEqual: case spv::Op::OpUGreaterThan: case spv::Op::OpSGreaterThan: case spv::Op::OpUGreaterThanEqual: case spv::Op::OpSGreaterThanEqual: case spv::Op::OpULessThan: case spv::Op::OpSLessThan: case spv::Op::OpULessThanEqual: case spv::Op::OpSLessThanEqual: case spv::Op::OpFOrdEqual: case spv::Op::OpFUnordEqual: case spv::Op::OpFOrdNotEqual: case spv::Op::OpFUnordNotEqual: case spv::Op::OpFOrdLessThan: case spv::Op::OpFUnordLessThan: case spv::Op::OpFOrdGreaterThan: case spv::Op::OpFUnordGreaterThan: case spv::Op::OpFOrdLessThanEqual: case spv::Op::OpFUnordLessThanEqual: case spv::Op::OpFOrdGreaterThanEqual: case spv::Op::OpFUnordGreaterThanEqual: return true; default: return false; } } bool spvOpcodeIsDebug(spv::Op opcode) { switch (opcode) { case spv::Op::OpName: case spv::Op::OpMemberName: case spv::Op::OpSource: case spv::Op::OpSourceContinued: case spv::Op::OpSourceExtension: case spv::Op::OpString: case spv::Op::OpLine: case spv::Op::OpNoLine: case spv::Op::OpModuleProcessed: return true; default: return false; } } bool spvOpcodeIsCommutativeBinaryOperator(spv::Op opcode) { switch (opcode) { case spv::Op::OpPtrEqual: case spv::Op::OpPtrNotEqual: case spv::Op::OpIAdd: case spv::Op::OpFAdd: case spv::Op::OpIMul: case spv::Op::OpFMul: case spv::Op::OpDot: case spv::Op::OpIAddCarry: case spv::Op::OpUMulExtended: case spv::Op::OpSMulExtended: case spv::Op::OpBitwiseOr: case spv::Op::OpBitwiseXor: case spv::Op::OpBitwiseAnd: case spv::Op::OpOrdered: case spv::Op::OpUnordered: case spv::Op::OpLogicalEqual: case spv::Op::OpLogicalNotEqual: case spv::Op::OpLogicalOr: case spv::Op::OpLogicalAnd: case spv::Op::OpIEqual: case spv::Op::OpINotEqual: case spv::Op::OpFOrdEqual: case spv::Op::OpFUnordEqual: case spv::Op::OpFOrdNotEqual: case spv::Op::OpFUnordNotEqual: return true; default: return false; } } bool spvOpcodeIsLinearAlgebra(spv::Op opcode) { switch (opcode) { case spv::Op::OpTranspose: case spv::Op::OpVectorTimesScalar: case spv::Op::OpMatrixTimesScalar: case spv::Op::OpVectorTimesMatrix: case spv::Op::OpMatrixTimesVector: case spv::Op::OpMatrixTimesMatrix: case spv::Op::OpOuterProduct: case spv::Op::OpDot: return true; default: return false; } } bool spvOpcodeIsImageSample(const spv::Op opcode) { switch (opcode) { case spv::Op::OpImageSampleImplicitLod: case spv::Op::OpImageSampleExplicitLod: case spv::Op::OpImageSampleDrefImplicitLod: case spv::Op::OpImageSampleDrefExplicitLod: case spv::Op::OpImageSampleProjImplicitLod: case spv::Op::OpImageSampleProjExplicitLod: case spv::Op::OpImageSampleProjDrefImplicitLod: case spv::Op::OpImageSampleProjDrefExplicitLod: case spv::Op::OpImageSparseSampleImplicitLod: case spv::Op::OpImageSparseSampleExplicitLod: case spv::Op::OpImageSparseSampleDrefImplicitLod: case spv::Op::OpImageSparseSampleDrefExplicitLod: case spv::Op::OpImageSampleFootprintNV: return true; default: return false; } } bool spvIsExtendedInstruction(const spv::Op opcode) { switch (opcode) { case spv::Op::OpExtInst: case spv::Op::OpExtInstWithForwardRefsKHR: return true; default: return false; } } std::vector spvOpcodeMemorySemanticsOperandIndices(spv::Op opcode) { switch (opcode) { case spv::Op::OpMemoryBarrier: return {1}; case spv::Op::OpAtomicStore: case spv::Op::OpControlBarrier: case spv::Op::OpAtomicFlagClear: case spv::Op::OpMemoryNamedBarrier: return {2}; case spv::Op::OpAtomicLoad: case spv::Op::OpAtomicExchange: case spv::Op::OpAtomicIIncrement: case spv::Op::OpAtomicIDecrement: case spv::Op::OpAtomicIAdd: case spv::Op::OpAtomicFAddEXT: case spv::Op::OpAtomicISub: case spv::Op::OpAtomicSMin: case spv::Op::OpAtomicUMin: case spv::Op::OpAtomicSMax: case spv::Op::OpAtomicUMax: case spv::Op::OpAtomicAnd: case spv::Op::OpAtomicOr: case spv::Op::OpAtomicXor: case spv::Op::OpAtomicFlagTestAndSet: return {4}; case spv::Op::OpAtomicCompareExchange: case spv::Op::OpAtomicCompareExchangeWeak: return {4, 5}; default: return {}; } } bool spvOpcodeIsAccessChain(spv::Op opcode) { switch (opcode) { case spv::Op::OpAccessChain: case spv::Op::OpInBoundsAccessChain: case spv::Op::OpPtrAccessChain: case spv::Op::OpInBoundsPtrAccessChain: case spv::Op::OpRawAccessChainNV: return true; default: return false; } } bool spvOpcodeIsBit(spv::Op opcode) { switch (opcode) { case spv::Op::OpShiftRightLogical: case spv::Op::OpShiftRightArithmetic: case spv::Op::OpShiftLeftLogical: case spv::Op::OpBitwiseOr: case spv::Op::OpBitwiseXor: case spv::Op::OpBitwiseAnd: case spv::Op::OpNot: case spv::Op::OpBitReverse: case spv::Op::OpBitCount: return true; default: return false; } } bool spvOpcodeGeneratesUntypedPointer(spv::Op opcode) { switch (opcode) { case spv::Op::OpUntypedVariableKHR: case spv::Op::OpUntypedAccessChainKHR: case spv::Op::OpUntypedInBoundsAccessChainKHR: case spv::Op::OpUntypedPtrAccessChainKHR: case spv::Op::OpUntypedInBoundsPtrAccessChainKHR: return true; default: return false; } } KhronosGroup-SPIRV-Tools-f289d04/source/opcode.h000066400000000000000000000160061475742701700214560ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPCODE_H_ #define SOURCE_OPCODE_H_ #include "source/instruction.h" #include "source/latest_version_spirv_header.h" #include "source/table.h" #include "spirv-tools/libspirv.h" // Returns the name of a registered SPIR-V generator as a null-terminated // string. If the generator is not known, then returns the string "Unknown". // The generator parameter should be most significant 16-bits of the generator // word in the SPIR-V module header. // // See the registry at https://www.khronos.org/registry/spir-v/api/spir-v.xml. const char* spvGeneratorStr(uint32_t generator); // Combines word_count and opcode enumerant in single word. uint32_t spvOpcodeMake(uint16_t word_count, spv::Op opcode); // Splits word into into two constituent parts: word_count and opcode. void spvOpcodeSplit(const uint32_t word, uint16_t* word_count, uint16_t* opcode); // Finds the named opcode in the given opcode table. On success, returns // SPV_SUCCESS and writes a handle of the table entry into *entry. spv_result_t spvOpcodeTableNameLookup(spv_target_env, const spv_opcode_table table, const char* name, spv_opcode_desc* entry); // Finds the opcode by enumerant in the given opcode table. On success, returns // SPV_SUCCESS and writes a handle of the table entry into *entry. spv_result_t spvOpcodeTableValueLookup(spv_target_env, const spv_opcode_table table, const spv::Op opcode, spv_opcode_desc* entry); // Copies an instruction's word and fixes the endianness to host native. The // source instruction's stream/opcode/endianness is in the words/opcode/endian // parameter. The word_count parameter specifies the number of words to copy. // Writes copied instruction into *inst. void spvInstructionCopy(const uint32_t* words, const spv::Op opcode, const uint16_t word_count, const spv_endianness_t endian, spv_instruction_t* inst); // Determine if the given opcode is a scalar type. Returns zero if false, // non-zero otherwise. int32_t spvOpcodeIsScalarType(const spv::Op opcode); // Determines if the given opcode is a specialization constant. Returns zero if // false, non-zero otherwise. int32_t spvOpcodeIsSpecConstant(const spv::Op opcode); // Determines if the given opcode is a constant. Returns zero if false, non-zero // otherwise. int32_t spvOpcodeIsConstant(const spv::Op opcode); // Returns true if the given opcode is a constant or undef. bool spvOpcodeIsConstantOrUndef(const spv::Op opcode); // Returns true if the given opcode is a scalar specialization constant. bool spvOpcodeIsScalarSpecConstant(const spv::Op opcode); // Determines if the given opcode is a composite type. Returns zero if false, // non-zero otherwise. int32_t spvOpcodeIsComposite(const spv::Op opcode); // Determines if the given opcode results in a pointer when using the logical // addressing model. Returns zero if false, non-zero otherwise. int32_t spvOpcodeReturnsLogicalPointer(const spv::Op opcode); // Returns whether the given opcode could result in a pointer or a variable // pointer when using the logical addressing model. bool spvOpcodeReturnsLogicalVariablePointer(const spv::Op opcode); // Determines if the given opcode generates a type. Returns zero if false, // non-zero otherwise. int32_t spvOpcodeGeneratesType(spv::Op opcode); // Returns true if the opcode adds a decoration to an id. bool spvOpcodeIsDecoration(const spv::Op opcode); // Returns true if the opcode is a load from memory into a result id. This // function only considers core instructions. bool spvOpcodeIsLoad(const spv::Op opcode); // Returns true if the opcode is an atomic operation that uses the original // value. bool spvOpcodeIsAtomicWithLoad(const spv::Op opcode); // Returns true if the opcode is an atomic operation. bool spvOpcodeIsAtomicOp(const spv::Op opcode); // Returns true if the given opcode is a branch instruction. bool spvOpcodeIsBranch(spv::Op opcode); // Returns true if the given opcode is a return instruction. bool spvOpcodeIsReturn(spv::Op opcode); // Returns true if the given opcode aborts execution. To abort means that after // executing that instruction, no other instructions will be executed regardless // of the context in which the instruction appears. Note that `OpUnreachable` // is considered an abort even if its behaviour is undefined. bool spvOpcodeIsAbort(spv::Op opcode); // Returns true if the given opcode is a return instruction or it aborts // execution. bool spvOpcodeIsReturnOrAbort(spv::Op opcode); // Returns true if the given opcode is a basic block terminator. bool spvOpcodeIsBlockTerminator(spv::Op opcode); // Returns true if the given opcode always defines an opaque type. bool spvOpcodeIsBaseOpaqueType(spv::Op opcode); // Returns true if the given opcode is a non-uniform group operation. bool spvOpcodeIsNonUniformGroupOperation(spv::Op opcode); // Returns true if the opcode with vector inputs could be divided into a series // of independent scalar operations that would give the same result. bool spvOpcodeIsScalarizable(spv::Op opcode); // Returns true if the given opcode is a debug instruction. bool spvOpcodeIsDebug(spv::Op opcode); // Returns true for opcodes that are binary operators, // where the order of the operands is irrelevant. bool spvOpcodeIsCommutativeBinaryOperator(spv::Op opcode); // Returns true for opcodes that represent linear algebra instructions. bool spvOpcodeIsLinearAlgebra(spv::Op opcode); // Returns true for opcodes that represent image sample instructions. bool spvOpcodeIsImageSample(spv::Op opcode); // Returns true if the opcode is either OpExtInst or OpExtInstWithForwardRefsKHR bool spvIsExtendedInstruction(spv::Op opcode); // Returns a vector containing the indices of the memory semantics // operands for |opcode|. std::vector spvOpcodeMemorySemanticsOperandIndices(spv::Op opcode); // Returns true for opcodes that represent access chain instructions. bool spvOpcodeIsAccessChain(spv::Op opcode); // Returns true for opcodes that represent bit instructions. bool spvOpcodeIsBit(spv::Op opcode); // Gets the name of an instruction, without the "Op" prefix. const char* spvOpcodeString(const spv::Op opcode); // Returns true for opcodes that generate an untyped pointer result. bool spvOpcodeGeneratesUntypedPointer(spv::Op opcode); #endif // SOURCE_OPCODE_H_ KhronosGroup-SPIRV-Tools-f289d04/source/operand.cpp000066400000000000000000000615121475742701700221720ustar00rootroot00000000000000// Copyright (c) 2015-2020 The Khronos Group Inc. // Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights // reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/operand.h" #include #include #include #include "DebugInfo.h" #include "OpenCLDebugInfo100.h" #include "source/macro.h" #include "source/opcode.h" #include "source/spirv_constant.h" // For now, assume unified1 contains up to SPIR-V 1.3 and no later // SPIR-V version. // TODO(dneto): Make one set of tables, but with version tags on a // per-item basis. https://github.com/KhronosGroup/SPIRV-Tools/issues/1195 #include "operand.kinds-unified1.inc" #include "spirv-tools/libspirv.h" static const spv_operand_table_t kOperandTable = { ARRAY_SIZE(pygen_variable_OperandInfoTable), pygen_variable_OperandInfoTable}; spv_result_t spvOperandTableGet(spv_operand_table* pOperandTable, spv_target_env) { if (!pOperandTable) return SPV_ERROR_INVALID_POINTER; *pOperandTable = &kOperandTable; return SPV_SUCCESS; } spv_result_t spvOperandTableNameLookup(spv_target_env, const spv_operand_table table, const spv_operand_type_t type, const char* name, const size_t nameLength, spv_operand_desc* pEntry) { if (!table) return SPV_ERROR_INVALID_TABLE; if (!name || !pEntry) return SPV_ERROR_INVALID_POINTER; for (uint64_t typeIndex = 0; typeIndex < table->count; ++typeIndex) { const auto& group = table->types[typeIndex]; if (type != group.type) continue; for (uint64_t index = 0; index < group.count; ++index) { const auto& entry = group.entries[index]; // We consider the current operand as available as long as // it is in the grammar. It might not be *valid* to use, // but that should be checked by the validator, not by parsing. // // Exact match case if (nameLength == strlen(entry.name) && !strncmp(entry.name, name, nameLength)) { *pEntry = &entry; return SPV_SUCCESS; } // Check the aliases. Ideally we would have a version of the table sorted // by name and then we could iterate between the lower and upper bounds to // restrict the amount comparisons. Fortunately, name-based lookups are // mostly restricted to the assembler. if (entry.numAliases > 0) { for (uint32_t aliasIndex = 0; aliasIndex < entry.numAliases; aliasIndex++) { const auto alias = entry.aliases[aliasIndex]; const size_t aliasLength = strlen(alias); if (nameLength == aliasLength && !strncmp(name, alias, nameLength)) { *pEntry = &entry; return SPV_SUCCESS; } } } } } return SPV_ERROR_INVALID_LOOKUP; } spv_result_t spvOperandTableValueLookup(spv_target_env, const spv_operand_table table, const spv_operand_type_t type, const uint32_t value, spv_operand_desc* pEntry) { if (!table) return SPV_ERROR_INVALID_TABLE; if (!pEntry) return SPV_ERROR_INVALID_POINTER; spv_operand_desc_t needle = {"", value, 0, nullptr, 0, nullptr, 0, nullptr, {}, ~0u, ~0u}; auto comp = [](const spv_operand_desc_t& lhs, const spv_operand_desc_t& rhs) { return lhs.value < rhs.value; }; for (uint64_t typeIndex = 0; typeIndex < table->count; ++typeIndex) { const auto& group = table->types[typeIndex]; if (type != group.type) continue; const auto beg = group.entries; const auto end = group.entries + group.count; // Assumes the underlying table is already sorted ascendingly according to // opcode value. auto it = std::lower_bound(beg, end, needle, comp); if (it != end && it->value == value) { // The current operand is considered available as long as // it is in the grammar. It might not be *valid* to use, // but that should be checked by the validator, not by parsing. *pEntry = it; return SPV_SUCCESS; } } return SPV_ERROR_INVALID_LOOKUP; } const char* spvOperandTypeStr(spv_operand_type_t type) { switch (type) { case SPV_OPERAND_TYPE_ID: case SPV_OPERAND_TYPE_OPTIONAL_ID: return "ID"; case SPV_OPERAND_TYPE_TYPE_ID: return "type ID"; case SPV_OPERAND_TYPE_RESULT_ID: return "result ID"; case SPV_OPERAND_TYPE_LITERAL_INTEGER: case SPV_OPERAND_TYPE_OPTIONAL_LITERAL_INTEGER: case SPV_OPERAND_TYPE_OPTIONAL_LITERAL_NUMBER: case SPV_OPERAND_TYPE_LITERAL_FLOAT: return "literal number"; case SPV_OPERAND_TYPE_OPTIONAL_TYPED_LITERAL_INTEGER: return "possibly multi-word literal integer"; case SPV_OPERAND_TYPE_TYPED_LITERAL_NUMBER: return "possibly multi-word literal number"; case SPV_OPERAND_TYPE_EXTENSION_INSTRUCTION_NUMBER: return "extension instruction number"; case SPV_OPERAND_TYPE_SPEC_CONSTANT_OP_NUMBER: return "OpSpecConstantOp opcode"; case SPV_OPERAND_TYPE_LITERAL_STRING: case SPV_OPERAND_TYPE_OPTIONAL_LITERAL_STRING: return "literal string"; case SPV_OPERAND_TYPE_SOURCE_LANGUAGE: return "source language"; case SPV_OPERAND_TYPE_EXECUTION_MODEL: return "execution model"; case SPV_OPERAND_TYPE_ADDRESSING_MODEL: return "addressing model"; case SPV_OPERAND_TYPE_MEMORY_MODEL: return "memory model"; case SPV_OPERAND_TYPE_EXECUTION_MODE: return "execution mode"; case SPV_OPERAND_TYPE_STORAGE_CLASS: return "storage class"; case SPV_OPERAND_TYPE_DIMENSIONALITY: return "dimensionality"; case SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE: return "sampler addressing mode"; case SPV_OPERAND_TYPE_SAMPLER_FILTER_MODE: return "sampler filter mode"; case SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT: return "image format"; case SPV_OPERAND_TYPE_FP_FAST_MATH_MODE: return "floating-point fast math mode"; case SPV_OPERAND_TYPE_FP_ROUNDING_MODE: return "floating-point rounding mode"; case SPV_OPERAND_TYPE_LINKAGE_TYPE: return "linkage type"; case SPV_OPERAND_TYPE_ACCESS_QUALIFIER: case SPV_OPERAND_TYPE_OPTIONAL_ACCESS_QUALIFIER: return "access qualifier"; case SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE: return "function parameter attribute"; case SPV_OPERAND_TYPE_DECORATION: return "decoration"; case SPV_OPERAND_TYPE_BUILT_IN: return "built-in"; case SPV_OPERAND_TYPE_SELECTION_CONTROL: return "selection control"; case SPV_OPERAND_TYPE_LOOP_CONTROL: return "loop control"; case SPV_OPERAND_TYPE_FUNCTION_CONTROL: return "function control"; case SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID: return "memory semantics ID"; case SPV_OPERAND_TYPE_MEMORY_ACCESS: case SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS: return "memory access"; case SPV_OPERAND_TYPE_FRAGMENT_SHADING_RATE: return "shading rate"; case SPV_OPERAND_TYPE_SCOPE_ID: return "scope ID"; case SPV_OPERAND_TYPE_GROUP_OPERATION: return "group operation"; case SPV_OPERAND_TYPE_KERNEL_ENQ_FLAGS: return "kernel enqeue flags"; case SPV_OPERAND_TYPE_KERNEL_PROFILING_INFO: return "kernel profiling info"; case SPV_OPERAND_TYPE_CAPABILITY: return "capability"; case SPV_OPERAND_TYPE_RAY_FLAGS: return "ray flags"; case SPV_OPERAND_TYPE_RAY_QUERY_INTERSECTION: return "ray query intersection"; case SPV_OPERAND_TYPE_RAY_QUERY_COMMITTED_INTERSECTION_TYPE: return "ray query committed intersection type"; case SPV_OPERAND_TYPE_RAY_QUERY_CANDIDATE_INTERSECTION_TYPE: return "ray query candidate intersection type"; case SPV_OPERAND_TYPE_PACKED_VECTOR_FORMAT: case SPV_OPERAND_TYPE_OPTIONAL_PACKED_VECTOR_FORMAT: return "packed vector format"; case SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS: case SPV_OPERAND_TYPE_OPTIONAL_COOPERATIVE_MATRIX_OPERANDS: return "cooperative matrix operands"; case SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_LAYOUT: return "cooperative matrix layout"; case SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_USE: return "cooperative matrix use"; case SPV_OPERAND_TYPE_TENSOR_CLAMP_MODE: return "tensor clamp mode"; case SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_REDUCE: return "cooperative matrix reduce"; case SPV_OPERAND_TYPE_TENSOR_ADDRESSING_OPERANDS: return "tensor addressing operands"; case SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS: case SPV_OPERAND_TYPE_OPTIONAL_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS: return "matrix multiply accumulate operands"; case SPV_OPERAND_TYPE_INITIALIZATION_MODE_QUALIFIER: return "initialization mode qualifier"; case SPV_OPERAND_TYPE_HOST_ACCESS_QUALIFIER: return "host access qualifier"; case SPV_OPERAND_TYPE_LOAD_CACHE_CONTROL: return "load cache control"; case SPV_OPERAND_TYPE_STORE_CACHE_CONTROL: return "store cache control"; case SPV_OPERAND_TYPE_NAMED_MAXIMUM_NUMBER_OF_REGISTERS: return "named maximum number of registers"; case SPV_OPERAND_TYPE_RAW_ACCESS_CHAIN_OPERANDS: case SPV_OPERAND_TYPE_OPTIONAL_RAW_ACCESS_CHAIN_OPERANDS: return "raw access chain operands"; case SPV_OPERAND_TYPE_IMAGE: case SPV_OPERAND_TYPE_OPTIONAL_IMAGE: return "image"; case SPV_OPERAND_TYPE_OPTIONAL_CIV: return "context-insensitive value"; case SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS: return "debug info flags"; case SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING: return "debug base type encoding"; case SPV_OPERAND_TYPE_DEBUG_COMPOSITE_TYPE: return "debug composite type"; case SPV_OPERAND_TYPE_DEBUG_TYPE_QUALIFIER: return "debug type qualifier"; case SPV_OPERAND_TYPE_DEBUG_OPERATION: return "debug operation"; case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS: return "OpenCL.DebugInfo.100 debug info flags"; case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING: return "OpenCL.DebugInfo.100 debug base type encoding"; case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_COMPOSITE_TYPE: return "OpenCL.DebugInfo.100 debug composite type"; case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_TYPE_QUALIFIER: return "OpenCL.DebugInfo.100 debug type qualifier"; case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION: return "OpenCL.DebugInfo.100 debug operation"; case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_IMPORTED_ENTITY: return "OpenCL.DebugInfo.100 debug imported entity"; case SPV_OPERAND_TYPE_FPENCODING: case SPV_OPERAND_TYPE_OPTIONAL_FPENCODING: return "FP encoding"; // The next values are for values returned from an instruction, not actually // an operand. So the specific strings don't matter. But let's add them // for completeness and ease of testing. case SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER: return "image channel order"; case SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE: return "image channel data type"; case SPV_OPERAND_TYPE_FPDENORM_MODE: return "FP denorm mode"; case SPV_OPERAND_TYPE_FPOPERATION_MODE: return "FP operation mode"; case SPV_OPERAND_TYPE_QUANTIZATION_MODES: return "quantization mode"; case SPV_OPERAND_TYPE_OVERFLOW_MODES: return "overflow mode"; case SPV_OPERAND_TYPE_COOPERATIVE_VECTOR_MATRIX_LAYOUT: return "cooperative vector matrix layout"; case SPV_OPERAND_TYPE_COMPONENT_TYPE: return "component type"; case SPV_OPERAND_TYPE_NONE: return "NONE"; default: break; } return "unknown"; } void spvPushOperandTypes(const spv_operand_type_t* types, spv_operand_pattern_t* pattern) { const spv_operand_type_t* endTypes; for (endTypes = types; *endTypes != SPV_OPERAND_TYPE_NONE; ++endTypes) { } while (endTypes-- != types) { pattern->push_back(*endTypes); } } void spvPushOperandTypesForMask(spv_target_env env, const spv_operand_table operandTable, const spv_operand_type_t type, const uint32_t mask, spv_operand_pattern_t* pattern) { // Scan from highest bits to lowest bits because we will append in LIFO // fashion, and we need the operands for lower order bits to be consumed first for (uint32_t candidate_bit = (1u << 31u); candidate_bit; candidate_bit >>= 1) { if (candidate_bit & mask) { spv_operand_desc entry = nullptr; if (SPV_SUCCESS == spvOperandTableValueLookup(env, operandTable, type, candidate_bit, &entry)) { spvPushOperandTypes(entry->operandTypes, pattern); } } } } bool spvOperandIsConcrete(spv_operand_type_t type) { if (spvIsIdType(type) || spvOperandIsConcreteMask(type)) { return true; } switch (type) { case SPV_OPERAND_TYPE_LITERAL_INTEGER: case SPV_OPERAND_TYPE_LITERAL_FLOAT: case SPV_OPERAND_TYPE_EXTENSION_INSTRUCTION_NUMBER: case SPV_OPERAND_TYPE_SPEC_CONSTANT_OP_NUMBER: case SPV_OPERAND_TYPE_TYPED_LITERAL_NUMBER: case SPV_OPERAND_TYPE_LITERAL_STRING: case SPV_OPERAND_TYPE_SOURCE_LANGUAGE: case SPV_OPERAND_TYPE_EXECUTION_MODEL: case SPV_OPERAND_TYPE_ADDRESSING_MODEL: case SPV_OPERAND_TYPE_MEMORY_MODEL: case SPV_OPERAND_TYPE_EXECUTION_MODE: case SPV_OPERAND_TYPE_STORAGE_CLASS: case SPV_OPERAND_TYPE_DIMENSIONALITY: case SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE: case SPV_OPERAND_TYPE_SAMPLER_FILTER_MODE: case SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT: case SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER: case SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE: case SPV_OPERAND_TYPE_FP_ROUNDING_MODE: case SPV_OPERAND_TYPE_LINKAGE_TYPE: case SPV_OPERAND_TYPE_ACCESS_QUALIFIER: case SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE: case SPV_OPERAND_TYPE_DECORATION: case SPV_OPERAND_TYPE_BUILT_IN: case SPV_OPERAND_TYPE_GROUP_OPERATION: case SPV_OPERAND_TYPE_KERNEL_ENQ_FLAGS: case SPV_OPERAND_TYPE_KERNEL_PROFILING_INFO: case SPV_OPERAND_TYPE_CAPABILITY: case SPV_OPERAND_TYPE_RAY_FLAGS: case SPV_OPERAND_TYPE_RAY_QUERY_INTERSECTION: case SPV_OPERAND_TYPE_RAY_QUERY_COMMITTED_INTERSECTION_TYPE: case SPV_OPERAND_TYPE_RAY_QUERY_CANDIDATE_INTERSECTION_TYPE: case SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING: case SPV_OPERAND_TYPE_DEBUG_COMPOSITE_TYPE: case SPV_OPERAND_TYPE_DEBUG_TYPE_QUALIFIER: case SPV_OPERAND_TYPE_DEBUG_OPERATION: case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING: case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_COMPOSITE_TYPE: case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_TYPE_QUALIFIER: case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION: case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_IMPORTED_ENTITY: case SPV_OPERAND_TYPE_FPDENORM_MODE: case SPV_OPERAND_TYPE_FPOPERATION_MODE: case SPV_OPERAND_TYPE_QUANTIZATION_MODES: case SPV_OPERAND_TYPE_OVERFLOW_MODES: case SPV_OPERAND_TYPE_PACKED_VECTOR_FORMAT: case SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_LAYOUT: case SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_USE: case SPV_OPERAND_TYPE_INITIALIZATION_MODE_QUALIFIER: case SPV_OPERAND_TYPE_HOST_ACCESS_QUALIFIER: case SPV_OPERAND_TYPE_LOAD_CACHE_CONTROL: case SPV_OPERAND_TYPE_STORE_CACHE_CONTROL: case SPV_OPERAND_TYPE_NAMED_MAXIMUM_NUMBER_OF_REGISTERS: case SPV_OPERAND_TYPE_FPENCODING: case SPV_OPERAND_TYPE_TENSOR_CLAMP_MODE: case SPV_OPERAND_TYPE_COOPERATIVE_VECTOR_MATRIX_LAYOUT: case SPV_OPERAND_TYPE_COMPONENT_TYPE: return true; default: break; } return false; } bool spvOperandIsConcreteMask(spv_operand_type_t type) { switch (type) { case SPV_OPERAND_TYPE_IMAGE: case SPV_OPERAND_TYPE_FP_FAST_MATH_MODE: case SPV_OPERAND_TYPE_SELECTION_CONTROL: case SPV_OPERAND_TYPE_LOOP_CONTROL: case SPV_OPERAND_TYPE_FUNCTION_CONTROL: case SPV_OPERAND_TYPE_MEMORY_ACCESS: case SPV_OPERAND_TYPE_FRAGMENT_SHADING_RATE: case SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS: case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS: case SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS: case SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS: case SPV_OPERAND_TYPE_RAW_ACCESS_CHAIN_OPERANDS: case SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_REDUCE: case SPV_OPERAND_TYPE_TENSOR_ADDRESSING_OPERANDS: return true; default: break; } return false; } bool spvOperandIsOptional(spv_operand_type_t type) { switch (type) { case SPV_OPERAND_TYPE_OPTIONAL_ID: case SPV_OPERAND_TYPE_OPTIONAL_IMAGE: case SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS: case SPV_OPERAND_TYPE_OPTIONAL_LITERAL_INTEGER: case SPV_OPERAND_TYPE_OPTIONAL_LITERAL_NUMBER: case SPV_OPERAND_TYPE_OPTIONAL_TYPED_LITERAL_INTEGER: case SPV_OPERAND_TYPE_OPTIONAL_LITERAL_STRING: case SPV_OPERAND_TYPE_OPTIONAL_ACCESS_QUALIFIER: case SPV_OPERAND_TYPE_OPTIONAL_PACKED_VECTOR_FORMAT: case SPV_OPERAND_TYPE_OPTIONAL_COOPERATIVE_MATRIX_OPERANDS: case SPV_OPERAND_TYPE_OPTIONAL_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS: case SPV_OPERAND_TYPE_OPTIONAL_CIV: case SPV_OPERAND_TYPE_OPTIONAL_RAW_ACCESS_CHAIN_OPERANDS: case SPV_OPERAND_TYPE_OPTIONAL_FPENCODING: return true; default: break; } // Any variable operand is also optional. return spvOperandIsVariable(type); } bool spvOperandIsVariable(spv_operand_type_t type) { switch (type) { case SPV_OPERAND_TYPE_VARIABLE_ID: case SPV_OPERAND_TYPE_VARIABLE_LITERAL_INTEGER: case SPV_OPERAND_TYPE_VARIABLE_LITERAL_INTEGER_ID: case SPV_OPERAND_TYPE_VARIABLE_ID_LITERAL_INTEGER: return true; default: break; } return false; } bool spvExpandOperandSequenceOnce(spv_operand_type_t type, spv_operand_pattern_t* pattern) { switch (type) { case SPV_OPERAND_TYPE_VARIABLE_ID: pattern->push_back(type); pattern->push_back(SPV_OPERAND_TYPE_OPTIONAL_ID); return true; case SPV_OPERAND_TYPE_VARIABLE_LITERAL_INTEGER: pattern->push_back(type); pattern->push_back(SPV_OPERAND_TYPE_OPTIONAL_LITERAL_INTEGER); return true; case SPV_OPERAND_TYPE_VARIABLE_LITERAL_INTEGER_ID: // Represents Zero or more (Literal number, Id) pairs, // where the literal number must be a scalar integer. pattern->push_back(type); pattern->push_back(SPV_OPERAND_TYPE_ID); pattern->push_back(SPV_OPERAND_TYPE_OPTIONAL_TYPED_LITERAL_INTEGER); return true; case SPV_OPERAND_TYPE_VARIABLE_ID_LITERAL_INTEGER: // Represents Zero or more (Id, Literal number) pairs. pattern->push_back(type); pattern->push_back(SPV_OPERAND_TYPE_LITERAL_INTEGER); pattern->push_back(SPV_OPERAND_TYPE_OPTIONAL_ID); return true; default: break; } return false; } spv_operand_type_t spvTakeFirstMatchableOperand( spv_operand_pattern_t* pattern) { assert(!pattern->empty()); spv_operand_type_t result; do { result = pattern->back(); pattern->pop_back(); } while (spvExpandOperandSequenceOnce(result, pattern)); return result; } spv_operand_pattern_t spvAlternatePatternFollowingImmediate( const spv_operand_pattern_t& pattern) { auto it = std::find(pattern.crbegin(), pattern.crend(), SPV_OPERAND_TYPE_RESULT_ID); if (it != pattern.crend()) { spv_operand_pattern_t alternatePattern(it - pattern.crbegin() + 2, SPV_OPERAND_TYPE_OPTIONAL_CIV); alternatePattern[1] = SPV_OPERAND_TYPE_RESULT_ID; return alternatePattern; } // No result-id found, so just expect CIVs. return {SPV_OPERAND_TYPE_OPTIONAL_CIV}; } bool spvIsIdType(spv_operand_type_t type) { switch (type) { case SPV_OPERAND_TYPE_ID: case SPV_OPERAND_TYPE_TYPE_ID: case SPV_OPERAND_TYPE_RESULT_ID: case SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID: case SPV_OPERAND_TYPE_SCOPE_ID: return true; default: return false; } } bool spvIsInIdType(spv_operand_type_t type) { if (!spvIsIdType(type)) { // If it is not an ID it cannot be an input ID. return false; } switch (type) { // Deny non-input IDs. case SPV_OPERAND_TYPE_TYPE_ID: case SPV_OPERAND_TYPE_RESULT_ID: return false; default: return true; } } std::function spvOperandCanBeForwardDeclaredFunction( spv::Op opcode) { std::function out; if (spvOpcodeGeneratesType(opcode)) { // All types can use forward pointers. out = [](unsigned) { return true; }; return out; } switch (opcode) { case spv::Op::OpExecutionMode: case spv::Op::OpExecutionModeId: case spv::Op::OpEntryPoint: case spv::Op::OpName: case spv::Op::OpMemberName: case spv::Op::OpSelectionMerge: case spv::Op::OpDecorate: case spv::Op::OpMemberDecorate: case spv::Op::OpDecorateId: case spv::Op::OpDecorateStringGOOGLE: case spv::Op::OpMemberDecorateStringGOOGLE: case spv::Op::OpBranch: case spv::Op::OpLoopMerge: out = [](unsigned) { return true; }; break; case spv::Op::OpGroupDecorate: case spv::Op::OpGroupMemberDecorate: case spv::Op::OpBranchConditional: case spv::Op::OpSwitch: out = [](unsigned index) { return index != 0; }; break; case spv::Op::OpFunctionCall: // The Function parameter. out = [](unsigned index) { return index == 2; }; break; case spv::Op::OpPhi: out = [](unsigned index) { return index > 1; }; break; case spv::Op::OpEnqueueKernel: // The Invoke parameter. out = [](unsigned index) { return index == 8; }; break; case spv::Op::OpGetKernelNDrangeSubGroupCount: case spv::Op::OpGetKernelNDrangeMaxSubGroupSize: // The Invoke parameter. out = [](unsigned index) { return index == 3; }; break; case spv::Op::OpGetKernelWorkGroupSize: case spv::Op::OpGetKernelPreferredWorkGroupSizeMultiple: // The Invoke parameter. out = [](unsigned index) { return index == 2; }; break; case spv::Op::OpTypeForwardPointer: out = [](unsigned index) { return index == 0; }; break; case spv::Op::OpTypeArray: out = [](unsigned index) { return index == 1; }; break; case spv::Op::OpCooperativeMatrixPerElementOpNV: out = [](unsigned index) { return index == 3; }; break; case spv::Op::OpCooperativeMatrixReduceNV: out = [](unsigned index) { return index == 4; }; break; case spv::Op::OpCooperativeMatrixLoadTensorNV: // approximate, due to variable operands out = [](unsigned index) { return index > 6; }; break; default: out = [](unsigned) { return false; }; break; } return out; } std::function spvDbgInfoExtOperandCanBeForwardDeclaredFunction( spv::Op opcode, spv_ext_inst_type_t ext_type, uint32_t key) { // The Vulkan debug info extended instruction set is non-semantic so allows no // forward references except if used through OpExtInstWithForwardRefsKHR. if (ext_type == SPV_EXT_INST_TYPE_NONSEMANTIC_SHADER_DEBUGINFO_100) { return [opcode](unsigned) { return opcode == spv::Op::OpExtInstWithForwardRefsKHR; }; } // TODO(https://gitlab.khronos.org/spirv/SPIR-V/issues/532): Forward // references for debug info instructions are still in discussion. We must // update the following lines of code when we conclude the spec. std::function out; if (ext_type == SPV_EXT_INST_TYPE_OPENCL_DEBUGINFO_100) { switch (OpenCLDebugInfo100Instructions(key)) { case OpenCLDebugInfo100DebugFunction: out = [](unsigned index) { return index == 13; }; break; case OpenCLDebugInfo100DebugTypeComposite: out = [](unsigned index) { return index >= 13; }; break; default: out = [](unsigned) { return false; }; break; } } else { switch (DebugInfoInstructions(key)) { case DebugInfoDebugFunction: out = [](unsigned index) { return index == 13; }; break; case DebugInfoDebugTypeComposite: out = [](unsigned index) { return index >= 12; }; break; default: out = [](unsigned) { return false; }; break; } } return out; } KhronosGroup-SPIRV-Tools-f289d04/source/operand.h000066400000000000000000000143701475742701700216370ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPERAND_H_ #define SOURCE_OPERAND_H_ #include #include #include "source/table.h" #include "spirv-tools/libspirv.h" // A sequence of operand types. // // A SPIR-V parser uses an operand pattern to describe what is expected // next on the input. // // As we parse an instruction in text or binary form from left to right, // we pop and push at the end of the pattern vector. Symbols later in the // pattern vector are matched against the input before symbols earlier in the // pattern vector are matched. // Using a vector in this way reduces memory traffic, which is good for // performance. using spv_operand_pattern_t = std::vector; // Finds the named operand in the table. The type parameter specifies the // operand's group. A handle of the operand table entry for this operand will // be written into *entry. spv_result_t spvOperandTableNameLookup(spv_target_env, const spv_operand_table table, const spv_operand_type_t type, const char* name, const size_t name_length, spv_operand_desc* entry); // Finds the operand with value in the table. The type parameter specifies the // operand's group. A handle of the operand table entry for this operand will // be written into *entry. spv_result_t spvOperandTableValueLookup(spv_target_env, const spv_operand_table table, const spv_operand_type_t type, const uint32_t value, spv_operand_desc* entry); // Gets the name string of the non-variable operand type. const char* spvOperandTypeStr(spv_operand_type_t type); // Returns true if an operand of the given type is optional. bool spvOperandIsOptional(spv_operand_type_t type); // Returns true if an operand type represents zero or more logical operands. // // Note that a single logical operand may still be a variable number of words. // For example, a literal string may be many words, but is just one logical // operand. bool spvOperandIsVariable(spv_operand_type_t type); // Append a list of operand types to the end of the pattern vector. // The types parameter specifies the source array of types, ending with // SPV_OPERAND_TYPE_NONE. void spvPushOperandTypes(const spv_operand_type_t* types, spv_operand_pattern_t* pattern); // Appends the operands expected after the given typed mask onto the // end of the given pattern. // // Each set bit in the mask represents zero or more operand types that should // be appended onto the pattern. Operands for a less significant bit always // appear after operands for a more significant bit. // // If a set bit is unknown, then we assume it has no operands. void spvPushOperandTypesForMask(spv_target_env, const spv_operand_table operand_table, const spv_operand_type_t mask_type, const uint32_t mask, spv_operand_pattern_t* pattern); // Expands an operand type representing zero or more logical operands, // exactly once. // // If the given type represents potentially several logical operands, // then prepend the given pattern with the first expansion of the logical // operands, followed by original type. Otherwise, don't modify the pattern. // // For example, the SPV_OPERAND_TYPE_VARIABLE_ID represents zero or more // IDs. In that case we would prepend the pattern with SPV_OPERAND_TYPE_ID // followed by SPV_OPERAND_TYPE_VARIABLE_ID again. // // This also applies to zero or more tuples of logical operands. In that case // we prepend pattern with for the members of the tuple, followed by the // original type argument. The pattern must encode the fact that if any part // of the tuple is present, then all tuple members should be. So the first // member of the tuple must be optional, and the remaining members // non-optional. // // Returns true if we modified the pattern. bool spvExpandOperandSequenceOnce(spv_operand_type_t type, spv_operand_pattern_t* pattern); // Expands the first element in the pattern until it is a matchable operand // type, then pops it off the front and returns it. The pattern must not be // empty. // // A matchable operand type is anything other than a zero-or-more-items // operand type. spv_operand_type_t spvTakeFirstMatchableOperand(spv_operand_pattern_t* pattern); // Calculates the corresponding post-immediate alternate pattern, which allows // a limited set of operand types. spv_operand_pattern_t spvAlternatePatternFollowingImmediate( const spv_operand_pattern_t& pattern); // Is the operand an ID? bool spvIsIdType(spv_operand_type_t type); // Is the operand an input ID? bool spvIsInIdType(spv_operand_type_t type); // Takes the opcode of an instruction and returns // a function object that will return true if the index // of the operand can be forward declared. This function will // used in the SSA validation stage of the pipeline std::function spvOperandCanBeForwardDeclaredFunction( spv::Op opcode); // Takes the instruction key of a debug info extension instruction // and returns a function object that will return true if the index // of the operand can be forward declared. This function will // used in the SSA validation stage of the pipeline std::function spvDbgInfoExtOperandCanBeForwardDeclaredFunction( spv::Op opcode, spv_ext_inst_type_t ext_type, uint32_t key); #endif // SOURCE_OPERAND_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/000077500000000000000000000000001475742701700206335ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/opt/CMakeLists.txt000066400000000000000000000167241475742701700234050ustar00rootroot00000000000000# Copyright (c) 2016 Google Inc. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. set(SPIRV_TOOLS_OPT_SOURCES fix_func_call_arguments.h aggressive_dead_code_elim_pass.h amd_ext_to_khr.h analyze_live_input_pass.h basic_block.h block_merge_pass.h block_merge_util.h build_module.h ccp_pass.h cfg_cleanup_pass.h cfg.h code_sink.h combine_access_chains.h compact_ids_pass.h composite.h const_folding_rules.h constants.h control_dependence.h convert_to_sampled_image_pass.h convert_to_half_pass.h copy_prop_arrays.h dataflow.h dead_branch_elim_pass.h dead_insert_elim_pass.h dead_variable_elimination.h decoration_manager.h debug_info_manager.h def_use_manager.h desc_sroa.h desc_sroa_util.h dominator_analysis.h dominator_tree.h eliminate_dead_constant_pass.h eliminate_dead_functions_pass.h eliminate_dead_functions_util.h eliminate_dead_io_components_pass.h eliminate_dead_members_pass.h eliminate_dead_output_stores_pass.h empty_pass.h feature_manager.h fix_storage_class.h flatten_decoration_pass.h fold.h folding_rules.h fold_spec_constant_op_and_composite_pass.h freeze_spec_constant_value_pass.h function.h graphics_robust_access_pass.h if_conversion.h inline_exhaustive_pass.h inline_opaque_pass.h inline_pass.h instruction.h instruction_list.h interface_var_sroa.h invocation_interlock_placement_pass.h interp_fixup_pass.h opextinst_forward_ref_fixup_pass.h ir_builder.h ir_context.h ir_loader.h licm_pass.h liveness.h local_access_chain_convert_pass.h local_redundancy_elimination.h local_single_block_elim_pass.h local_single_store_elim_pass.h log.h loop_dependence.h loop_descriptor.h loop_fission.h loop_fusion.h loop_fusion_pass.h loop_peeling.h loop_unroller.h loop_utils.h loop_unswitch_pass.h mem_pass.h merge_return_pass.h modify_maximal_reconvergence.h module.h null_pass.h passes.h pass.h pass_manager.h private_to_local_pass.h propagator.h reduce_load_size.h redundancy_elimination.h reflect.h register_pressure.h relax_float_ops_pass.h remove_dontinline_pass.h remove_duplicates_pass.h remove_unused_interface_variables_pass.h replace_desc_array_access_using_var_index.h replace_invalid_opc.h scalar_analysis.h scalar_analysis_nodes.h scalar_replacement_pass.h set_spec_constant_default_value_pass.h simplification_pass.h spread_volatile_semantics.h ssa_rewrite_pass.h strength_reduction_pass.h strip_debug_info_pass.h strip_nonsemantic_info_pass.h struct_cfg_analysis.h switch_descriptorset_pass.h tree_iterator.h trim_capabilities_pass.h type_manager.h types.h unify_const_pass.h upgrade_memory_model.h value_number_table.h vector_dce.h workaround1209.h wrap_opkill.h fix_func_call_arguments.cpp aggressive_dead_code_elim_pass.cpp amd_ext_to_khr.cpp analyze_live_input_pass.cpp basic_block.cpp block_merge_pass.cpp block_merge_util.cpp build_module.cpp ccp_pass.cpp cfg_cleanup_pass.cpp cfg.cpp code_sink.cpp combine_access_chains.cpp compact_ids_pass.cpp composite.cpp const_folding_rules.cpp constants.cpp control_dependence.cpp convert_to_sampled_image_pass.cpp convert_to_half_pass.cpp copy_prop_arrays.cpp dataflow.cpp dead_branch_elim_pass.cpp dead_insert_elim_pass.cpp dead_variable_elimination.cpp decoration_manager.cpp debug_info_manager.cpp def_use_manager.cpp desc_sroa.cpp desc_sroa_util.cpp dominator_analysis.cpp dominator_tree.cpp eliminate_dead_constant_pass.cpp eliminate_dead_functions_pass.cpp eliminate_dead_functions_util.cpp eliminate_dead_io_components_pass.cpp eliminate_dead_members_pass.cpp eliminate_dead_output_stores_pass.cpp feature_manager.cpp fix_storage_class.cpp flatten_decoration_pass.cpp fold.cpp folding_rules.cpp fold_spec_constant_op_and_composite_pass.cpp freeze_spec_constant_value_pass.cpp function.cpp graphics_robust_access_pass.cpp if_conversion.cpp inline_exhaustive_pass.cpp inline_opaque_pass.cpp inline_pass.cpp instruction.cpp instruction_list.cpp interface_var_sroa.cpp invocation_interlock_placement_pass.cpp interp_fixup_pass.cpp opextinst_forward_ref_fixup_pass.cpp ir_context.cpp ir_loader.cpp licm_pass.cpp liveness.cpp local_access_chain_convert_pass.cpp local_redundancy_elimination.cpp local_single_block_elim_pass.cpp local_single_store_elim_pass.cpp loop_dependence.cpp loop_dependence_helpers.cpp loop_descriptor.cpp loop_fission.cpp loop_fusion.cpp loop_fusion_pass.cpp loop_peeling.cpp loop_utils.cpp loop_unroller.cpp loop_unswitch_pass.cpp mem_pass.cpp merge_return_pass.cpp modify_maximal_reconvergence.cpp module.cpp optimizer.cpp pass.cpp pass_manager.cpp private_to_local_pass.cpp propagator.cpp reduce_load_size.cpp redundancy_elimination.cpp register_pressure.cpp relax_float_ops_pass.cpp remove_dontinline_pass.cpp remove_duplicates_pass.cpp remove_unused_interface_variables_pass.cpp replace_desc_array_access_using_var_index.cpp replace_invalid_opc.cpp scalar_analysis.cpp scalar_analysis_simplification.cpp scalar_replacement_pass.cpp set_spec_constant_default_value_pass.cpp simplification_pass.cpp spread_volatile_semantics.cpp ssa_rewrite_pass.cpp strength_reduction_pass.cpp strip_debug_info_pass.cpp strip_nonsemantic_info_pass.cpp struct_cfg_analysis.cpp struct_packing_pass.cpp switch_descriptorset_pass.cpp trim_capabilities_pass.cpp type_manager.cpp types.cpp unify_const_pass.cpp upgrade_memory_model.cpp value_number_table.cpp vector_dce.cpp workaround1209.cpp wrap_opkill.cpp ) if(MSVC AND (NOT ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang"))) # Enable parallel builds across four cores for this lib add_definitions(/MP4) endif() spvtools_pch(SPIRV_TOOLS_OPT_SOURCES pch_source_opt) add_library(SPIRV-Tools-opt ${SPIRV_TOOLS_LIBRARY_TYPE} ${SPIRV_TOOLS_OPT_SOURCES}) spvtools_default_compile_options(SPIRV-Tools-opt) target_include_directories(SPIRV-Tools-opt PUBLIC $ $ $ PRIVATE ${spirv-tools_BINARY_DIR} ) # We need the assembling and disassembling functionalities in the main library. target_link_libraries(SPIRV-Tools-opt PUBLIC ${SPIRV_TOOLS_FULL_VISIBILITY}) set_property(TARGET SPIRV-Tools-opt PROPERTY FOLDER "SPIRV-Tools libraries") spvtools_check_symbol_exports(SPIRV-Tools-opt) if(ENABLE_SPIRV_TOOLS_INSTALL) install(TARGETS SPIRV-Tools-opt EXPORT SPIRV-Tools-optTargets) export(EXPORT SPIRV-Tools-optTargets FILE SPIRV-Tools-optTargets.cmake) spvtools_config_package_dir(SPIRV-Tools-opt PACKAGE_DIR) install(EXPORT SPIRV-Tools-optTargets FILE SPIRV-Tools-optTargets.cmake DESTINATION ${PACKAGE_DIR}) spvtools_generate_config_file(SPIRV-Tools-opt) install(FILES ${CMAKE_BINARY_DIR}/SPIRV-Tools-optConfig.cmake DESTINATION ${PACKAGE_DIR}) endif(ENABLE_SPIRV_TOOLS_INSTALL) KhronosGroup-SPIRV-Tools-f289d04/source/opt/aggressive_dead_code_elim_pass.cpp000066400000000000000000001224521475742701700275070ustar00rootroot00000000000000// Copyright (c) 2017 The Khronos Group Inc. // Copyright (c) 2017 Valve Corporation // Copyright (c) 2017 LunarG Inc. // Copyright (c) 2018-2021 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/aggressive_dead_code_elim_pass.h" #include #include #include "source/cfa.h" #include "source/opt/eliminate_dead_functions_util.h" #include "source/opt/ir_builder.h" #include "source/opt/reflect.h" #include "source/spirv_constant.h" #include "source/util/string_utils.h" namespace spvtools { namespace opt { namespace { constexpr uint32_t kTypePointerStorageClassInIdx = 0; constexpr uint32_t kEntryPointFunctionIdInIdx = 1; constexpr uint32_t kSelectionMergeMergeBlockIdInIdx = 0; constexpr uint32_t kLoopMergeContinueBlockIdInIdx = 1; constexpr uint32_t kCopyMemoryTargetAddrInIdx = 0; constexpr uint32_t kCopyMemorySourceAddrInIdx = 1; constexpr uint32_t kLoadSourceAddrInIdx = 0; constexpr uint32_t kDebugDeclareOperandVariableIndex = 5; constexpr uint32_t kGlobalVariableVariableIndex = 12; constexpr uint32_t kExtInstSetInIdx = 0; constexpr uint32_t kExtInstOpInIdx = 1; constexpr uint32_t kInterpolantInIdx = 2; constexpr uint32_t kCooperativeMatrixLoadSourceAddrInIdx = 0; // Sorting functor to present annotation instructions in an easy-to-process // order. The functor orders by opcode first and falls back on unique id // ordering if both instructions have the same opcode. // // Desired priority: // spv::Op::OpGroupDecorate // spv::Op::OpGroupMemberDecorate // spv::Op::OpDecorate // spv::Op::OpMemberDecorate // spv::Op::OpDecorateId // spv::Op::OpDecorateStringGOOGLE // spv::Op::OpDecorationGroup struct DecorationLess { bool operator()(const Instruction* lhs, const Instruction* rhs) const { assert(lhs && rhs); spv::Op lhsOp = lhs->opcode(); spv::Op rhsOp = rhs->opcode(); if (lhsOp != rhsOp) { #define PRIORITY_CASE(opcode) \ if (lhsOp == opcode && rhsOp != opcode) return true; \ if (rhsOp == opcode && lhsOp != opcode) return false; // OpGroupDecorate and OpGroupMember decorate are highest priority to // eliminate dead targets early and simplify subsequent checks. PRIORITY_CASE(spv::Op::OpGroupDecorate) PRIORITY_CASE(spv::Op::OpGroupMemberDecorate) PRIORITY_CASE(spv::Op::OpDecorate) PRIORITY_CASE(spv::Op::OpMemberDecorate) PRIORITY_CASE(spv::Op::OpDecorateId) PRIORITY_CASE(spv::Op::OpDecorateStringGOOGLE) // OpDecorationGroup is lowest priority to ensure use/def chains remain // usable for instructions that target this group. PRIORITY_CASE(spv::Op::OpDecorationGroup) #undef PRIORITY_CASE } // Fall back to maintain total ordering (compare unique ids). return *lhs < *rhs; } }; } // namespace bool AggressiveDCEPass::IsVarOfStorage(uint32_t varId, spv::StorageClass storageClass) { if (varId == 0) return false; const Instruction* varInst = get_def_use_mgr()->GetDef(varId); const spv::Op op = varInst->opcode(); if (op != spv::Op::OpVariable) return false; const uint32_t varTypeId = varInst->type_id(); const Instruction* varTypeInst = get_def_use_mgr()->GetDef(varTypeId); if (varTypeInst->opcode() != spv::Op::OpTypePointer) return false; return spv::StorageClass(varTypeInst->GetSingleWordInOperand( kTypePointerStorageClassInIdx)) == storageClass; } bool AggressiveDCEPass::IsLocalVar(uint32_t varId, Function* func) { if (IsVarOfStorage(varId, spv::StorageClass::Function)) { return true; } if (!IsVarOfStorage(varId, spv::StorageClass::Private) && !IsVarOfStorage(varId, spv::StorageClass::Workgroup)) { return false; } // For a variable in the Private or WorkGroup storage class, the variable will // get a new instance for every call to an entry point. If the entry point // does not have a call, then no other function can read or write to that // instance of the variable. return IsEntryPointWithNoCalls(func); } void AggressiveDCEPass::AddStores(Function* func, uint32_t ptrId) { get_def_use_mgr()->ForEachUser(ptrId, [this, ptrId, func](Instruction* user) { // If the user is not a part of |func|, skip it. BasicBlock* blk = context()->get_instr_block(user); if (blk && blk->GetParent() != func) return; switch (user->opcode()) { case spv::Op::OpAccessChain: case spv::Op::OpInBoundsAccessChain: case spv::Op::OpCopyObject: this->AddStores(func, user->result_id()); break; case spv::Op::OpLoad: break; case spv::Op::OpCopyMemory: case spv::Op::OpCopyMemorySized: if (user->GetSingleWordInOperand(kCopyMemoryTargetAddrInIdx) == ptrId) { AddToWorklist(user); } break; // If default, assume it stores e.g. frexp, modf, function call case spv::Op::OpStore: { const uint32_t kStoreTargetAddrInIdx = 0; if (user->GetSingleWordInOperand(kStoreTargetAddrInIdx) == ptrId) AddToWorklist(user); break; } default: AddToWorklist(user); break; } }); } bool AggressiveDCEPass::AllExtensionsSupported() const { // If any extension not in allowlist, return false for (auto& ei : get_module()->extensions()) { const std::string extName = ei.GetInOperand(0).AsString(); if (extensions_allowlist_.find(extName) == extensions_allowlist_.end()) return false; } // Only allow NonSemantic.Shader.DebugInfo.100, we cannot safely optimise // around unknown extended instruction sets even if they are non-semantic for (auto& inst : context()->module()->ext_inst_imports()) { assert(inst.opcode() == spv::Op::OpExtInstImport && "Expecting an import of an extension's instruction set."); const std::string extension_name = inst.GetInOperand(0).AsString(); if (spvtools::utils::starts_with(extension_name, "NonSemantic.") && (extension_name != "NonSemantic.Shader.DebugInfo.100") && (extension_name != "NonSemantic.DebugPrintf")) { return false; } } return true; } bool AggressiveDCEPass::IsTargetDead(Instruction* inst) { const uint32_t tId = inst->GetSingleWordInOperand(0); Instruction* tInst = get_def_use_mgr()->GetDef(tId); if (IsAnnotationInst(tInst->opcode())) { // This must be a decoration group. We go through annotations in a specific // order. So if this is not used by any group or group member decorates, it // is dead. assert(tInst->opcode() == spv::Op::OpDecorationGroup); bool dead = true; get_def_use_mgr()->ForEachUser(tInst, [&dead](Instruction* user) { if (user->opcode() == spv::Op::OpGroupDecorate || user->opcode() == spv::Op::OpGroupMemberDecorate) dead = false; }); return dead; } return !IsLive(tInst); } void AggressiveDCEPass::ProcessLoad(Function* func, uint32_t varId) { // Only process locals if (!IsLocalVar(varId, func)) return; // Return if already processed if (live_local_vars_.find(varId) != live_local_vars_.end()) return; // Mark all stores to varId as live AddStores(func, varId); // Cache varId as processed live_local_vars_.insert(varId); } void AggressiveDCEPass::AddBranch(uint32_t labelId, BasicBlock* bp) { std::unique_ptr newBranch( new Instruction(context(), spv::Op::OpBranch, 0, 0, {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {labelId}}})); context()->AnalyzeDefUse(&*newBranch); context()->set_instr_block(&*newBranch, bp); bp->AddInstruction(std::move(newBranch)); } void AggressiveDCEPass::AddBreaksAndContinuesToWorklist( Instruction* mergeInst) { assert(mergeInst->opcode() == spv::Op::OpSelectionMerge || mergeInst->opcode() == spv::Op::OpLoopMerge); BasicBlock* header = context()->get_instr_block(mergeInst); const uint32_t mergeId = mergeInst->GetSingleWordInOperand(0); get_def_use_mgr()->ForEachUser(mergeId, [header, this](Instruction* user) { if (!user->IsBranch()) return; BasicBlock* block = context()->get_instr_block(user); if (BlockIsInConstruct(header, block)) { // This is a break from the loop. AddToWorklist(user); // Add branch's merge if there is one. Instruction* userMerge = GetMergeInstruction(user); if (userMerge != nullptr) AddToWorklist(userMerge); } }); if (mergeInst->opcode() != spv::Op::OpLoopMerge) { return; } // For loops we need to find the continues as well. const uint32_t contId = mergeInst->GetSingleWordInOperand(kLoopMergeContinueBlockIdInIdx); get_def_use_mgr()->ForEachUser(contId, [&contId, this](Instruction* user) { spv::Op op = user->opcode(); if (op == spv::Op::OpBranchConditional || op == spv::Op::OpSwitch) { // A conditional branch or switch can only be a continue if it does not // have a merge instruction or its merge block is not the continue block. Instruction* hdrMerge = GetMergeInstruction(user); if (hdrMerge != nullptr && hdrMerge->opcode() == spv::Op::OpSelectionMerge) { uint32_t hdrMergeId = hdrMerge->GetSingleWordInOperand(kSelectionMergeMergeBlockIdInIdx); if (hdrMergeId == contId) return; // Need to mark merge instruction too AddToWorklist(hdrMerge); } } else if (op == spv::Op::OpBranch) { // An unconditional branch can only be a continue if it is not // branching to its own merge block. BasicBlock* blk = context()->get_instr_block(user); Instruction* hdrBranch = GetHeaderBranch(blk); if (hdrBranch == nullptr) return; Instruction* hdrMerge = GetMergeInstruction(hdrBranch); if (hdrMerge->opcode() == spv::Op::OpLoopMerge) return; uint32_t hdrMergeId = hdrMerge->GetSingleWordInOperand(kSelectionMergeMergeBlockIdInIdx); if (contId == hdrMergeId) return; } else { return; } AddToWorklist(user); }); } bool AggressiveDCEPass::AggressiveDCE(Function* func) { if (func->IsDeclaration()) return false; std::list structured_order; cfg()->ComputeStructuredOrder(func, &*func->begin(), &structured_order); live_local_vars_.clear(); InitializeWorkList(func, structured_order); ProcessWorkList(func); return KillDeadInstructions(func, structured_order); } bool AggressiveDCEPass::KillDeadInstructions( const Function* func, std::list& structured_order) { bool modified = false; for (auto bi = structured_order.begin(); bi != structured_order.end();) { uint32_t merge_block_id = 0; (*bi)->ForEachInst([this, &modified, &merge_block_id](Instruction* inst) { if (IsLive(inst)) return; if (inst->opcode() == spv::Op::OpLabel) return; // If dead instruction is selection merge, remember merge block // for new branch at end of block if (inst->opcode() == spv::Op::OpSelectionMerge || inst->opcode() == spv::Op::OpLoopMerge) merge_block_id = inst->GetSingleWordInOperand(0); to_kill_.push_back(inst); modified = true; }); // If a structured if or loop was deleted, add a branch to its merge // block, and traverse to the merge block and continue processing there. // We know the block still exists because the label is not deleted. if (merge_block_id != 0) { AddBranch(merge_block_id, *bi); for (++bi; (*bi)->id() != merge_block_id; ++bi) { } auto merge_terminator = (*bi)->terminator(); if (merge_terminator->opcode() == spv::Op::OpUnreachable) { // The merge was unreachable. This is undefined behaviour so just // return (or return an undef). Then mark the new return as live. auto func_ret_type_inst = get_def_use_mgr()->GetDef(func->type_id()); if (func_ret_type_inst->opcode() == spv::Op::OpTypeVoid) { merge_terminator->SetOpcode(spv::Op::OpReturn); } else { // Find an undef for the return value and make sure it gets kept by // the pass. auto undef_id = Type2Undef(func->type_id()); auto undef = get_def_use_mgr()->GetDef(undef_id); live_insts_.Set(undef->unique_id()); merge_terminator->SetOpcode(spv::Op::OpReturnValue); merge_terminator->SetInOperands({{SPV_OPERAND_TYPE_ID, {undef_id}}}); get_def_use_mgr()->AnalyzeInstUse(merge_terminator); } live_insts_.Set(merge_terminator->unique_id()); } } else { Instruction* inst = (*bi)->terminator(); if (!IsLive(inst)) { // If the terminator is not live, this block has no live instructions, // and it will be unreachable. AddUnreachable(*bi); } ++bi; } } return modified; } void AggressiveDCEPass::ProcessWorkList(Function* func) { while (!worklist_.empty()) { Instruction* live_inst = worklist_.front(); worklist_.pop(); AddOperandsToWorkList(live_inst); MarkBlockAsLive(live_inst); MarkLoadedVariablesAsLive(func, live_inst); AddDecorationsToWorkList(live_inst); AddDebugInstructionsToWorkList(live_inst); } } void AggressiveDCEPass::AddDebugScopeToWorkList(const Instruction* inst) { auto scope = inst->GetDebugScope(); auto lex_scope_id = scope.GetLexicalScope(); if (lex_scope_id != kNoDebugScope) AddToWorklist(get_def_use_mgr()->GetDef(lex_scope_id)); auto inlined_at_id = scope.GetInlinedAt(); if (inlined_at_id != kNoInlinedAt) AddToWorklist(get_def_use_mgr()->GetDef(inlined_at_id)); } void AggressiveDCEPass::AddDebugInstructionsToWorkList( const Instruction* inst) { for (auto& line_inst : inst->dbg_line_insts()) { if (line_inst.IsDebugLineInst()) { AddOperandsToWorkList(&line_inst); } AddDebugScopeToWorkList(&line_inst); } AddDebugScopeToWorkList(inst); } void AggressiveDCEPass::AddDecorationsToWorkList(const Instruction* inst) { // Add OpDecorateId instructions that apply to this instruction to the work // list. We use the decoration manager to look through the group // decorations to get to the OpDecorate* instructions themselves. auto decorations = get_decoration_mgr()->GetDecorationsFor(inst->result_id(), false); for (Instruction* dec : decorations) { // We only care about OpDecorateId instructions because the are the only // decorations that will reference an id that will have to be kept live // because of that use. if (dec->opcode() != spv::Op::OpDecorateId) { continue; } if (spv::Decoration(dec->GetSingleWordInOperand(1)) == spv::Decoration::HlslCounterBufferGOOGLE) { // These decorations should not force the use id to be live. It will be // removed if either the target or the in operand are dead. continue; } AddToWorklist(dec); } } void AggressiveDCEPass::MarkLoadedVariablesAsLive(Function* func, Instruction* inst) { std::vector live_variables = GetLoadedVariables(inst); for (uint32_t var_id : live_variables) { ProcessLoad(func, var_id); } } std::vector AggressiveDCEPass::GetLoadedVariables(Instruction* inst) { if (inst->opcode() == spv::Op::OpFunctionCall) { return GetLoadedVariablesFromFunctionCall(inst); } uint32_t var_id = GetLoadedVariableFromNonFunctionCalls(inst); if (var_id == 0) { return {}; } return {var_id}; } uint32_t AggressiveDCEPass::GetLoadedVariableFromNonFunctionCalls( Instruction* inst) { std::vector live_variables; if (inst->IsAtomicWithLoad()) { return GetVariableId(inst->GetSingleWordInOperand(kLoadSourceAddrInIdx)); } switch (inst->opcode()) { case spv::Op::OpLoad: case spv::Op::OpImageTexelPointer: return GetVariableId(inst->GetSingleWordInOperand(kLoadSourceAddrInIdx)); case spv::Op::OpCopyMemory: case spv::Op::OpCopyMemorySized: return GetVariableId( inst->GetSingleWordInOperand(kCopyMemorySourceAddrInIdx)); case spv::Op::OpExtInst: { if (inst->GetSingleWordInOperand(kExtInstSetInIdx) == context()->get_feature_mgr()->GetExtInstImportId_GLSLstd450()) { auto ext_inst = inst->GetSingleWordInOperand(kExtInstOpInIdx); switch (ext_inst) { case GLSLstd450InterpolateAtCentroid: case GLSLstd450InterpolateAtOffset: case GLSLstd450InterpolateAtSample: return inst->GetSingleWordInOperand(kInterpolantInIdx); } } break; } case spv::Op::OpCooperativeMatrixLoadNV: case spv::Op::OpCooperativeMatrixLoadKHR: case spv::Op::OpCooperativeMatrixLoadTensorNV: return GetVariableId( inst->GetSingleWordInOperand(kCooperativeMatrixLoadSourceAddrInIdx)); default: break; } switch (inst->GetCommonDebugOpcode()) { case CommonDebugInfoDebugDeclare: return inst->GetSingleWordOperand(kDebugDeclareOperandVariableIndex); case CommonDebugInfoDebugValue: { analysis::DebugInfoManager* debug_info_mgr = context()->get_debug_info_mgr(); return debug_info_mgr->GetVariableIdOfDebugValueUsedForDeclare(inst); } default: break; } return 0; } std::vector AggressiveDCEPass::GetLoadedVariablesFromFunctionCall( const Instruction* inst) { assert(inst->opcode() == spv::Op::OpFunctionCall); std::vector live_variables; // NOTE: we should only be checking function call parameters here, not the // function itself, however, `IsPtr` will trivially return false for // OpFunction inst->ForEachInId([this, &live_variables](const uint32_t* operand_id) { if (!IsPtr(*operand_id)) return; uint32_t var_id = GetVariableId(*operand_id); live_variables.push_back(var_id); }); return live_variables; } uint32_t AggressiveDCEPass::GetVariableId(uint32_t ptr_id) { assert(IsPtr(ptr_id) && "Cannot get the variable when input is not a pointer."); uint32_t varId = 0; (void)GetPtr(ptr_id, &varId); return varId; } void AggressiveDCEPass::MarkBlockAsLive(Instruction* inst) { BasicBlock* basic_block = context()->get_instr_block(inst); if (basic_block == nullptr) { return; } // If we intend to keep this instruction, we need the block label and // block terminator to have a valid block for the instruction. AddToWorklist(basic_block->GetLabelInst()); // We need to mark the successors blocks that follow as live. If this is // header of the merge construct, the construct may be folded, but we will // definitely need the merge label. If it is not a construct, the terminator // must be live, and the successor blocks will be marked as live when // processing the terminator. uint32_t merge_id = basic_block->MergeBlockIdIfAny(); if (merge_id == 0) { AddToWorklist(basic_block->terminator()); } else { AddToWorklist(context()->get_def_use_mgr()->GetDef(merge_id)); } // Mark the structured control flow constructs that contains this block as // live. If |inst| is an instruction in the loop header, then it is part of // the loop, so the loop construct must be live. We exclude the label because // it does not matter how many times it is executed. This could be extended // to more instructions, but we will need it for now. if (inst->opcode() != spv::Op::OpLabel) MarkLoopConstructAsLiveIfLoopHeader(basic_block); Instruction* next_branch_inst = GetBranchForNextHeader(basic_block); if (next_branch_inst != nullptr) { AddToWorklist(next_branch_inst); Instruction* mergeInst = GetMergeInstruction(next_branch_inst); AddToWorklist(mergeInst); } if (inst->opcode() == spv::Op::OpLoopMerge || inst->opcode() == spv::Op::OpSelectionMerge) { AddBreaksAndContinuesToWorklist(inst); } } void AggressiveDCEPass::MarkLoopConstructAsLiveIfLoopHeader( BasicBlock* basic_block) { // If this is the header for a loop, then loop structure needs to keep as well // because the loop header is also part of the loop. Instruction* merge_inst = basic_block->GetLoopMergeInst(); if (merge_inst != nullptr) { AddToWorklist(basic_block->terminator()); AddToWorklist(merge_inst); } } void AggressiveDCEPass::AddOperandsToWorkList(const Instruction* inst) { inst->ForEachInId([this](const uint32_t* iid) { Instruction* inInst = get_def_use_mgr()->GetDef(*iid); AddToWorklist(inInst); }); if (inst->type_id() != 0) { AddToWorklist(get_def_use_mgr()->GetDef(inst->type_id())); } } void AggressiveDCEPass::InitializeWorkList( Function* func, std::list& structured_order) { AddToWorklist(&func->DefInst()); MarkFunctionParameterAsLive(func); MarkFirstBlockAsLive(func); // Add instructions with external side effects to the worklist. Also add // branches that are not attached to a structured construct. // TODO(s-perron): The handling of branch seems to be adhoc. This needs to be // cleaned up. for (auto& bi : structured_order) { for (auto ii = bi->begin(); ii != bi->end(); ++ii) { spv::Op op = ii->opcode(); if (ii->IsBranch()) { continue; } switch (op) { case spv::Op::OpStore: { uint32_t var_id = 0; (void)GetPtr(&*ii, &var_id); if (!IsLocalVar(var_id, func)) AddToWorklist(&*ii); } break; case spv::Op::OpCopyMemory: case spv::Op::OpCopyMemorySized: { uint32_t var_id = 0; uint32_t target_addr_id = ii->GetSingleWordInOperand(kCopyMemoryTargetAddrInIdx); (void)GetPtr(target_addr_id, &var_id); if (!IsLocalVar(var_id, func)) AddToWorklist(&*ii); } break; case spv::Op::OpLoopMerge: case spv::Op::OpSelectionMerge: case spv::Op::OpUnreachable: break; default: { // Function calls, atomics, function params, function returns, etc. if (!ii->IsOpcodeSafeToDelete()) { AddToWorklist(&*ii); } } break; } } } } void AggressiveDCEPass::InitializeModuleScopeLiveInstructions() { // Keep all execution modes. for (auto& exec : get_module()->execution_modes()) { AddToWorklist(&exec); } // Keep all entry points. for (auto& entry : get_module()->entry_points()) { if (!preserve_interface_) { live_insts_.Set(entry.unique_id()); // The actual function is live always. AddToWorklist( get_def_use_mgr()->GetDef(entry.GetSingleWordInOperand(1u))); for (uint32_t i = 3; i < entry.NumInOperands(); ++i) { auto* var = get_def_use_mgr()->GetDef(entry.GetSingleWordInOperand(i)); auto storage_class = var->GetSingleWordInOperand(0u); // Vulkan support outputs without an associated input, but not inputs // without an associated output. Don't remove outputs unless explicitly // allowed. if (!remove_outputs_ && spv::StorageClass(storage_class) == spv::StorageClass::Output) { AddToWorklist(var); } } } else { AddToWorklist(&entry); } } for (auto& anno : get_module()->annotations()) { if (anno.opcode() == spv::Op::OpDecorate) { // Keep workgroup size. if (spv::Decoration(anno.GetSingleWordInOperand(1u)) == spv::Decoration::BuiltIn && spv::BuiltIn(anno.GetSingleWordInOperand(2u)) == spv::BuiltIn::WorkgroupSize) { AddToWorklist(&anno); } if (context()->preserve_bindings()) { // Keep all bindings. if ((spv::Decoration(anno.GetSingleWordInOperand(1u)) == spv::Decoration::DescriptorSet) || (spv::Decoration(anno.GetSingleWordInOperand(1u)) == spv::Decoration::Binding)) { AddToWorklist(&anno); } } if (context()->preserve_spec_constants()) { // Keep all specialization constant instructions if (spv::Decoration(anno.GetSingleWordInOperand(1u)) == spv::Decoration::SpecId) { AddToWorklist(&anno); } } } } // For each DebugInfo GlobalVariable keep all operands except the Variable. // Later, if the variable is killed with KillInst(), we will set the operand // to DebugInfoNone. Create and save DebugInfoNone now for this possible // later use. This is slightly unoptimal, but it avoids generating it during // instruction killing when the module is not consistent. bool debug_global_seen = false; for (auto& dbg : get_module()->ext_inst_debuginfo()) { if (dbg.GetCommonDebugOpcode() != CommonDebugInfoDebugGlobalVariable) continue; debug_global_seen = true; dbg.ForEachInId([this](const uint32_t* iid) { Instruction* in_inst = get_def_use_mgr()->GetDef(*iid); if (in_inst->opcode() == spv::Op::OpVariable) return; AddToWorklist(in_inst); }); } if (debug_global_seen) { auto dbg_none = context()->get_debug_info_mgr()->GetDebugInfoNone(); AddToWorklist(dbg_none); } // Add top level DebugInfo to worklist for (auto& dbg : get_module()->ext_inst_debuginfo()) { auto op = dbg.GetShader100DebugOpcode(); if (op == NonSemanticShaderDebugInfo100DebugCompilationUnit || op == NonSemanticShaderDebugInfo100DebugEntryPoint || op == NonSemanticShaderDebugInfo100DebugSource || op == NonSemanticShaderDebugInfo100DebugSourceContinued) { AddToWorklist(&dbg); } } } Pass::Status AggressiveDCEPass::ProcessImpl() { // Current functionality assumes shader capability // TODO(greg-lunarg): Handle additional capabilities if (!context()->get_feature_mgr()->HasCapability(spv::Capability::Shader)) return Status::SuccessWithoutChange; // Current functionality assumes relaxed logical addressing (see // instruction.h) // TODO(greg-lunarg): Handle non-logical addressing if (context()->get_feature_mgr()->HasCapability(spv::Capability::Addresses)) return Status::SuccessWithoutChange; // The variable pointer extension is no longer needed to use the capability, // so we have to look for the capability. if (context()->get_feature_mgr()->HasCapability( spv::Capability::VariablePointersStorageBuffer)) return Status::SuccessWithoutChange; // If any extensions in the module are not explicitly supported, // return unmodified. if (!AllExtensionsSupported()) return Status::SuccessWithoutChange; // Eliminate Dead functions. bool modified = EliminateDeadFunctions(); InitializeModuleScopeLiveInstructions(); // Run |AggressiveDCE| on the remaining functions. The order does not matter, // since |AggressiveDCE| is intra-procedural. This can mean that function // will become dead if all function call to them are removed. These dead // function will still be in the module after this pass. We expect this to be // rare. for (Function& fp : *context()->module()) { modified |= AggressiveDCE(&fp); } // If the decoration manager is kept live then the context will try to keep it // up to date. ADCE deals with group decorations by changing the operands in // |OpGroupDecorate| instruction directly without informing the decoration // manager. This can put it in an invalid state which will cause an error // when the context tries to update it. To avoid this problem invalidate // the decoration manager upfront. // // We kill it at now because it is used when processing the entry point // functions. context()->InvalidateAnalyses(IRContext::Analysis::kAnalysisDecorations); // Process module-level instructions. Now that all live instructions have // been marked, it is safe to remove dead global values. modified |= ProcessGlobalValues(); assert((to_kill_.empty() || modified) && "A dead instruction was identified, but no change recorded."); // Kill all dead instructions. for (auto inst : to_kill_) { context()->KillInst(inst); } // Cleanup all CFG including all unreachable blocks. for (Function& fp : *context()->module()) { modified |= CFGCleanup(&fp); } return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } bool AggressiveDCEPass::EliminateDeadFunctions() { // Identify live functions first. Those that are not live // are dead. std::unordered_set live_function_set; ProcessFunction mark_live = [&live_function_set](Function* fp) { live_function_set.insert(fp); return false; }; context()->ProcessReachableCallTree(mark_live); bool modified = false; for (auto funcIter = get_module()->begin(); funcIter != get_module()->end();) { if (live_function_set.count(&*funcIter) == 0) { modified = true; funcIter = eliminatedeadfunctionsutil::EliminateFunction(context(), &funcIter); } else { ++funcIter; } } return modified; } bool AggressiveDCEPass::ProcessGlobalValues() { // Remove debug and annotation statements referencing dead instructions. // This must be done before killing the instructions, otherwise there are // dead objects in the def/use database. bool modified = false; Instruction* instruction = &*get_module()->debug2_begin(); while (instruction) { if (instruction->opcode() != spv::Op::OpName) { instruction = instruction->NextNode(); continue; } if (IsTargetDead(instruction)) { instruction = context()->KillInst(instruction); modified = true; } else { instruction = instruction->NextNode(); } } // This code removes all unnecessary decorations safely (see #1174). It also // does so in a more efficient manner than deleting them only as the targets // are deleted. std::vector annotations; for (auto& inst : get_module()->annotations()) annotations.push_back(&inst); std::sort(annotations.begin(), annotations.end(), DecorationLess()); for (auto annotation : annotations) { switch (annotation->opcode()) { case spv::Op::OpDecorate: case spv::Op::OpMemberDecorate: case spv::Op::OpDecorateStringGOOGLE: case spv::Op::OpMemberDecorateStringGOOGLE: if (IsTargetDead(annotation)) { context()->KillInst(annotation); modified = true; } break; case spv::Op::OpDecorateId: if (IsTargetDead(annotation)) { context()->KillInst(annotation); modified = true; } else { if (spv::Decoration(annotation->GetSingleWordInOperand(1)) == spv::Decoration::HlslCounterBufferGOOGLE) { // HlslCounterBuffer will reference an id other than the target. // If that id is dead, then the decoration can be removed as well. uint32_t counter_buffer_id = annotation->GetSingleWordInOperand(2); Instruction* counter_buffer_inst = get_def_use_mgr()->GetDef(counter_buffer_id); if (!IsLive(counter_buffer_inst)) { context()->KillInst(annotation); modified = true; } } } break; case spv::Op::OpGroupDecorate: { // Go through the targets of this group decorate. Remove each dead // target. If all targets are dead, remove this decoration. bool dead = true; bool removed_operand = false; for (uint32_t i = 1; i < annotation->NumOperands();) { Instruction* opInst = get_def_use_mgr()->GetDef(annotation->GetSingleWordOperand(i)); if (!IsLive(opInst)) { // Don't increment |i|. annotation->RemoveOperand(i); modified = true; removed_operand = true; } else { i++; dead = false; } } if (dead) { context()->KillInst(annotation); modified = true; } else if (removed_operand) { context()->UpdateDefUse(annotation); } break; } case spv::Op::OpGroupMemberDecorate: { // Go through the targets of this group member decorate. Remove each // dead target (and member index). If all targets are dead, remove this // decoration. bool dead = true; bool removed_operand = false; for (uint32_t i = 1; i < annotation->NumOperands();) { Instruction* opInst = get_def_use_mgr()->GetDef(annotation->GetSingleWordOperand(i)); if (!IsLive(opInst)) { // Don't increment |i|. annotation->RemoveOperand(i + 1); annotation->RemoveOperand(i); modified = true; removed_operand = true; } else { i += 2; dead = false; } } if (dead) { context()->KillInst(annotation); modified = true; } else if (removed_operand) { context()->UpdateDefUse(annotation); } break; } case spv::Op::OpDecorationGroup: // By the time we hit decoration groups we've checked everything that // can target them. So if they have no uses they must be dead. if (get_def_use_mgr()->NumUsers(annotation) == 0) { context()->KillInst(annotation); modified = true; } break; default: assert(false); break; } } for (auto& dbg : get_module()->ext_inst_debuginfo()) { if (IsLive(&dbg)) continue; // Save GlobalVariable if its variable is live, otherwise null out variable // index if (dbg.GetCommonDebugOpcode() == CommonDebugInfoDebugGlobalVariable) { auto var_id = dbg.GetSingleWordOperand(kGlobalVariableVariableIndex); Instruction* var_inst = get_def_use_mgr()->GetDef(var_id); if (IsLive(var_inst)) continue; context()->ForgetUses(&dbg); dbg.SetOperand( kGlobalVariableVariableIndex, {context()->get_debug_info_mgr()->GetDebugInfoNone()->result_id()}); context()->AnalyzeUses(&dbg); continue; } to_kill_.push_back(&dbg); modified = true; } // Since ADCE is disabled for non-shaders, we don't check for export linkage // attributes here. for (auto& val : get_module()->types_values()) { if (!IsLive(&val)) { // Save forwarded pointer if pointer is live since closure does not mark // this live as it does not have a result id. This is a little too // conservative since it is not known if the structure type that needed // it is still live. TODO(greg-lunarg): Only save if needed. if (val.opcode() == spv::Op::OpTypeForwardPointer) { uint32_t ptr_ty_id = val.GetSingleWordInOperand(0); Instruction* ptr_ty_inst = get_def_use_mgr()->GetDef(ptr_ty_id); if (IsLive(ptr_ty_inst)) continue; } to_kill_.push_back(&val); modified = true; } } if (!preserve_interface_) { // Remove the dead interface variables from the entry point interface list. for (auto& entry : get_module()->entry_points()) { std::vector new_operands; for (uint32_t i = 0; i < entry.NumInOperands(); ++i) { if (i < 3) { // Execution model, function id and name are always valid. new_operands.push_back(entry.GetInOperand(i)); } else { auto* var = get_def_use_mgr()->GetDef(entry.GetSingleWordInOperand(i)); if (IsLive(var)) { new_operands.push_back(entry.GetInOperand(i)); } } } if (new_operands.size() != entry.NumInOperands()) { entry.SetInOperands(std::move(new_operands)); get_def_use_mgr()->UpdateDefUse(&entry); } } } return modified; } Pass::Status AggressiveDCEPass::Process() { // Initialize extensions allowlist InitExtensions(); return ProcessImpl(); } void AggressiveDCEPass::InitExtensions() { extensions_allowlist_.clear(); // clang-format off extensions_allowlist_.insert({ "SPV_AMD_shader_explicit_vertex_parameter", "SPV_AMD_shader_trinary_minmax", "SPV_AMD_gcn_shader", "SPV_KHR_shader_ballot", "SPV_AMD_shader_ballot", "SPV_AMD_gpu_shader_half_float", "SPV_KHR_shader_draw_parameters", "SPV_KHR_subgroup_vote", "SPV_KHR_8bit_storage", "SPV_KHR_16bit_storage", "SPV_KHR_device_group", "SPV_KHR_multiview", "SPV_NVX_multiview_per_view_attributes", "SPV_NV_viewport_array2", "SPV_NV_stereo_view_rendering", "SPV_NV_sample_mask_override_coverage", "SPV_NV_geometry_shader_passthrough", "SPV_AMD_texture_gather_bias_lod", "SPV_KHR_storage_buffer_storage_class", // SPV_KHR_variable_pointers // Currently do not support extended pointer expressions "SPV_AMD_gpu_shader_int16", "SPV_KHR_post_depth_coverage", "SPV_KHR_shader_atomic_counter_ops", "SPV_EXT_shader_stencil_export", "SPV_EXT_shader_viewport_index_layer", "SPV_AMD_shader_image_load_store_lod", "SPV_AMD_shader_fragment_mask", "SPV_EXT_fragment_fully_covered", "SPV_AMD_gpu_shader_half_float_fetch", "SPV_GOOGLE_decorate_string", "SPV_GOOGLE_hlsl_functionality1", "SPV_GOOGLE_user_type", "SPV_NV_shader_subgroup_partitioned", "SPV_EXT_demote_to_helper_invocation", "SPV_EXT_descriptor_indexing", "SPV_NV_fragment_shader_barycentric", "SPV_NV_compute_shader_derivatives", "SPV_NV_shader_image_footprint", "SPV_NV_shading_rate", "SPV_NV_mesh_shader", "SPV_EXT_mesh_shader", "SPV_NV_ray_tracing", "SPV_KHR_ray_tracing", "SPV_KHR_ray_query", "SPV_EXT_fragment_invocation_density", "SPV_EXT_physical_storage_buffer", "SPV_KHR_physical_storage_buffer", "SPV_KHR_terminate_invocation", "SPV_KHR_shader_clock", "SPV_KHR_vulkan_memory_model", "SPV_KHR_subgroup_uniform_control_flow", "SPV_KHR_integer_dot_product", "SPV_EXT_shader_image_int64", "SPV_KHR_non_semantic_info", "SPV_KHR_uniform_group_instructions", "SPV_KHR_fragment_shader_barycentric", "SPV_NV_bindless_texture", "SPV_EXT_shader_atomic_float_add", "SPV_EXT_fragment_shader_interlock", "SPV_KHR_compute_shader_derivatives", "SPV_NV_cooperative_matrix", "SPV_KHR_cooperative_matrix", "SPV_KHR_ray_tracing_position_fetch", "SPV_KHR_fragment_shading_rate" }); // clang-format on } Instruction* AggressiveDCEPass::GetHeaderBranch(BasicBlock* blk) { if (blk == nullptr) { return nullptr; } BasicBlock* header_block = GetHeaderBlock(blk); if (header_block == nullptr) { return nullptr; } return header_block->terminator(); } BasicBlock* AggressiveDCEPass::GetHeaderBlock(BasicBlock* blk) const { if (blk == nullptr) { return nullptr; } BasicBlock* header_block = nullptr; if (blk->IsLoopHeader()) { header_block = blk; } else { uint32_t header = context()->GetStructuredCFGAnalysis()->ContainingConstruct(blk->id()); header_block = context()->get_instr_block(header); } return header_block; } Instruction* AggressiveDCEPass::GetMergeInstruction(Instruction* inst) { BasicBlock* bb = context()->get_instr_block(inst); if (bb == nullptr) { return nullptr; } return bb->GetMergeInst(); } Instruction* AggressiveDCEPass::GetBranchForNextHeader(BasicBlock* blk) { if (blk == nullptr) { return nullptr; } if (blk->IsLoopHeader()) { uint32_t header = context()->GetStructuredCFGAnalysis()->ContainingConstruct(blk->id()); blk = context()->get_instr_block(header); } return GetHeaderBranch(blk); } void AggressiveDCEPass::MarkFunctionParameterAsLive(const Function* func) { func->ForEachParam( [this](const Instruction* param) { AddToWorklist(const_cast(param)); }, false); } bool AggressiveDCEPass::BlockIsInConstruct(BasicBlock* header_block, BasicBlock* bb) { if (bb == nullptr || header_block == nullptr) { return false; } uint32_t current_header = bb->id(); while (current_header != 0) { if (current_header == header_block->id()) return true; current_header = context()->GetStructuredCFGAnalysis()->ContainingConstruct( current_header); } return false; } bool AggressiveDCEPass::IsEntryPointWithNoCalls(Function* func) { auto cached_result = entry_point_with_no_calls_cache_.find(func->result_id()); if (cached_result != entry_point_with_no_calls_cache_.end()) { return cached_result->second; } bool result = IsEntryPoint(func) && !HasCall(func); entry_point_with_no_calls_cache_[func->result_id()] = result; return result; } bool AggressiveDCEPass::IsEntryPoint(Function* func) { for (const Instruction& entry_point : get_module()->entry_points()) { uint32_t entry_point_id = entry_point.GetSingleWordInOperand(kEntryPointFunctionIdInIdx); if (entry_point_id == func->result_id()) { return true; } } return false; } bool AggressiveDCEPass::HasCall(Function* func) { return !func->WhileEachInst([](Instruction* inst) { return inst->opcode() != spv::Op::OpFunctionCall; }); } void AggressiveDCEPass::MarkFirstBlockAsLive(Function* func) { BasicBlock* first_block = &*func->begin(); MarkBlockAsLive(first_block->GetLabelInst()); } void AggressiveDCEPass::AddUnreachable(BasicBlock*& block) { InstructionBuilder builder( context(), block, IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisDefUse); builder.AddUnreachable(); } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/aggressive_dead_code_elim_pass.h000066400000000000000000000245351475742701700271570ustar00rootroot00000000000000// Copyright (c) 2017 The Khronos Group Inc. // Copyright (c) 2017 Valve Corporation // Copyright (c) 2017 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_AGGRESSIVE_DEAD_CODE_ELIM_PASS_H_ #define SOURCE_OPT_AGGRESSIVE_DEAD_CODE_ELIM_PASS_H_ #include #include #include #include #include #include #include #include #include #include "source/opt/basic_block.h" #include "source/opt/def_use_manager.h" #include "source/opt/mem_pass.h" #include "source/opt/module.h" #include "source/util/bit_vector.h" namespace spvtools { namespace opt { // See optimizer.hpp for documentation. class AggressiveDCEPass : public MemPass { using cbb_ptr = const BasicBlock*; public: using GetBlocksFunction = std::function*(const BasicBlock*)>; AggressiveDCEPass(bool preserve_interface = false, bool remove_outputs = false) : preserve_interface_(preserve_interface), remove_outputs_(remove_outputs) {} const char* name() const override { return "eliminate-dead-code-aggressive"; } Status Process() override; IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisConstants | IRContext::kAnalysisTypes; } private: // Preserve entry point interface if true. All variables in interface // will be marked live and will not be eliminated. This mode is needed by // GPU-Assisted Validation instrumentation where a change in the interface // is not allowed. bool preserve_interface_; // Output variables can be removed from the interface if this is true. // This is safe if the caller knows that the corresponding input variable // in the following shader has been removed. It is false by default. bool remove_outputs_; // Return true if |varId| is a variable of |storageClass|. |varId| must either // be 0 or the result of an instruction. bool IsVarOfStorage(uint32_t varId, spv::StorageClass storageClass); // Return true if the instance of the variable |varId| can only be access in // |func|. For example, a function scope variable, or a private variable // where |func| is an entry point with no function calls. bool IsLocalVar(uint32_t varId, Function* func); // Return true if |inst| is marked live. bool IsLive(const Instruction* inst) const { return live_insts_.Get(inst->unique_id()); } // Adds entry points, execution modes and workgroup size decorations to the // worklist for processing with the first function. void InitializeModuleScopeLiveInstructions(); // Add |inst| to worklist_ and live_insts_. void AddToWorklist(Instruction* inst) { if (!live_insts_.Set(inst->unique_id())) { worklist_.push(inst); } } // Add all store instruction which use |ptrId|, directly or indirectly, // to the live instruction worklist. void AddStores(Function* func, uint32_t ptrId); // Initialize extensions allowlist void InitExtensions(); // Return true if all extensions in this module are supported by this pass. bool AllExtensionsSupported() const; // Returns true if the target of |inst| is dead. An instruction is dead if // its result id is used in decoration or debug instructions only. |inst| is // assumed to be OpName, OpMemberName or an annotation instruction. bool IsTargetDead(Instruction* inst); // If |varId| is local, mark all stores of varId as live. void ProcessLoad(Function* func, uint32_t varId); // Add branch to |labelId| to end of block |bp|. void AddBranch(uint32_t labelId, BasicBlock* bp); // Add all break and continue branches in the construct associated with // |mergeInst| to worklist if not already live void AddBreaksAndContinuesToWorklist(Instruction* mergeInst); // Eliminates dead debug2 and annotation instructions. Marks dead globals for // removal (e.g. types, constants and variables). bool ProcessGlobalValues(); // Erases functions that are unreachable from the entry points of the module. bool EliminateDeadFunctions(); // For function |func|, mark all Stores to non-function-scope variables // and block terminating instructions as live. Recursively mark the values // they use. When complete, mark any non-live instructions to be deleted. // Returns true if the function has been modified. // // Note: This function does not delete useless control structures. All // existing control structures will remain. This can leave not-insignificant // sequences of ultimately useless code. // TODO(): Remove useless control constructs. bool AggressiveDCE(Function* func); Pass::Status ProcessImpl(); // Adds instructions which must be kept because of they have side-effects // that ADCE cannot model to the work list. void InitializeWorkList(Function* func, std::list& structured_order); // Process each instruction in the work list by marking any instruction that // that it depends on as live, and adding it to the work list. The work list // will be empty at the end. void ProcessWorkList(Function* func); // Kills any instructions in |func| that have not been marked as live. bool KillDeadInstructions(const Function* func, std::list& structured_order); // Adds the instructions that define the operands of |inst| to the work list. void AddOperandsToWorkList(const Instruction* inst); // Marks all of the labels and branch that inst requires as live. void MarkBlockAsLive(Instruction* inst); // Marks any variables from which |inst| may require data as live. void MarkLoadedVariablesAsLive(Function* func, Instruction* inst); // Returns the id of the variable that |ptr_id| point to. |ptr_id| must be a // value whose type is a pointer. uint32_t GetVariableId(uint32_t ptr_id); // Returns all of the ids for the variables from which |inst| will load data. std::vector GetLoadedVariables(Instruction* inst); // Returns all of the ids for the variables from which |inst| will load data. // The opcode of |inst| must be OpFunctionCall. std::vector GetLoadedVariablesFromFunctionCall( const Instruction* inst); // Returns the id of the variable from which |inst| will load data. |inst| // must not be an OpFunctionCall. Returns 0 if no data is read or the // variable cannot be determined. Note that in logical addressing mode the // latter is not possible for function and private storage class because there // cannot be variable pointers pointing to those storage classes. uint32_t GetLoadedVariableFromNonFunctionCalls(Instruction* inst); // Adds all decorations of |inst| to the work list. void AddDecorationsToWorkList(const Instruction* inst); // Adds DebugScope instruction associated with |inst| to the work list. void AddDebugScopeToWorkList(const Instruction* inst); // Adds all debug instruction associated with |inst| to the work list. void AddDebugInstructionsToWorkList(const Instruction* inst); // Marks all of the OpFunctionParameter instructions in |func| as live. void MarkFunctionParameterAsLive(const Function* func); // Returns the terminator instruction in the header for the innermost // construct that contains |blk|. Returns nullptr if no such header exists. Instruction* GetHeaderBranch(BasicBlock* blk); // Returns the header for the innermost construct that contains |blk|. A loop // header will be its own header. Returns nullptr if no such header exists. BasicBlock* GetHeaderBlock(BasicBlock* blk) const; // Returns the same as |GetHeaderBlock| except if |blk| is a loop header it // will return the header of the next enclosing construct. Returns nullptr if // no such header exists. Instruction* GetBranchForNextHeader(BasicBlock* blk); // Returns the merge instruction in the same basic block as |inst|. Returns // nullptr if one does not exist. Instruction* GetMergeInstruction(Instruction* inst); // Returns true if |bb| is in the construct with header |header_block|. bool BlockIsInConstruct(BasicBlock* header_block, BasicBlock* bb); // Returns true if |func| is an entry point that does not have any function // calls. bool IsEntryPointWithNoCalls(Function* func); // Returns true if |func| is an entry point. bool IsEntryPoint(Function* func); // Returns true if |func| contains a function call. bool HasCall(Function* func); // Marks the first block, which is the entry block, in |func| as live. void MarkFirstBlockAsLive(Function* func); // Adds an OpUnreachable instruction at the end of |block|. void AddUnreachable(BasicBlock*& block); // Marks the OpLoopMerge and the terminator in |basic_block| as live if // |basic_block| is a loop header. void MarkLoopConstructAsLiveIfLoopHeader(BasicBlock* basic_block); // The cached results for |IsEntryPointWithNoCalls|. It maps the function's // result id to the return value. std::unordered_map entry_point_with_no_calls_cache_; // Live Instruction Worklist. An instruction is added to this list // if it might have a side effect, either directly or indirectly. // If we don't know, then add it to this list. Instructions are // removed from this list as the algorithm traces side effects, // building up the live instructions set |live_insts_|. std::queue worklist_; // Live Instructions utils::BitVector live_insts_; // Live Local Variables std::unordered_set live_local_vars_; // List of instructions to delete. Deletion is delayed until debug and // annotation instructions are processed. std::vector to_kill_; // Extensions supported by this pass. std::unordered_set extensions_allowlist_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_AGGRESSIVE_DEAD_CODE_ELIM_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/amd_ext_to_khr.cpp000066400000000000000000001176261475742701700243430ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/amd_ext_to_khr.h" #include #include #include "ir_builder.h" #include "source/opt/ir_context.h" #include "spv-amd-shader-ballot.insts.inc" #include "type_manager.h" namespace spvtools { namespace opt { namespace { enum AmdShaderBallotExtOpcodes { AmdShaderBallotSwizzleInvocationsAMD = 1, AmdShaderBallotSwizzleInvocationsMaskedAMD = 2, AmdShaderBallotWriteInvocationAMD = 3, AmdShaderBallotMbcntAMD = 4 }; enum AmdShaderTrinaryMinMaxExtOpCodes { FMin3AMD = 1, UMin3AMD = 2, SMin3AMD = 3, FMax3AMD = 4, UMax3AMD = 5, SMax3AMD = 6, FMid3AMD = 7, UMid3AMD = 8, SMid3AMD = 9 }; enum AmdGcnShader { CubeFaceCoordAMD = 2, CubeFaceIndexAMD = 1, TimeAMD = 3 }; analysis::Type* GetUIntType(IRContext* ctx) { analysis::Integer int_type(32, false); return ctx->get_type_mgr()->GetRegisteredType(&int_type); } // Returns a folding rule that replaces |op(a,b,c)| by |op(op(a,b),c)|, where // |op| is either min or max. |opcode| is the binary opcode in the GLSLstd450 // extended instruction set that corresponds to the trinary instruction being // replaced. template bool ReplaceTrinaryMinMax(IRContext* ctx, Instruction* inst, const std::vector&) { uint32_t glsl405_ext_inst_id = ctx->get_feature_mgr()->GetExtInstImportId_GLSLstd450(); if (glsl405_ext_inst_id == 0) { ctx->AddExtInstImport("GLSL.std.450"); glsl405_ext_inst_id = ctx->get_feature_mgr()->GetExtInstImportId_GLSLstd450(); } InstructionBuilder ir_builder( ctx, inst, IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); uint32_t op1 = inst->GetSingleWordInOperand(2); uint32_t op2 = inst->GetSingleWordInOperand(3); uint32_t op3 = inst->GetSingleWordInOperand(4); Instruction* temp = ir_builder.AddNaryExtendedInstruction( inst->type_id(), glsl405_ext_inst_id, opcode, {op1, op2}); Instruction::OperandList new_operands; new_operands.push_back({SPV_OPERAND_TYPE_ID, {glsl405_ext_inst_id}}); new_operands.push_back({SPV_OPERAND_TYPE_EXTENSION_INSTRUCTION_NUMBER, {static_cast(opcode)}}); new_operands.push_back({SPV_OPERAND_TYPE_ID, {temp->result_id()}}); new_operands.push_back({SPV_OPERAND_TYPE_ID, {op3}}); inst->SetInOperands(std::move(new_operands)); ctx->UpdateDefUse(inst); return true; } // Returns a folding rule that replaces |mid(a,b,c)| by |clamp(a, min(b,c), // max(b,c)|. The three parameters are the opcode that correspond to the min, // max, and clamp operations for the type of the instruction being replaced. template bool ReplaceTrinaryMid(IRContext* ctx, Instruction* inst, const std::vector&) { uint32_t glsl405_ext_inst_id = ctx->get_feature_mgr()->GetExtInstImportId_GLSLstd450(); if (glsl405_ext_inst_id == 0) { ctx->AddExtInstImport("GLSL.std.450"); glsl405_ext_inst_id = ctx->get_feature_mgr()->GetExtInstImportId_GLSLstd450(); } InstructionBuilder ir_builder( ctx, inst, IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); uint32_t op1 = inst->GetSingleWordInOperand(2); uint32_t op2 = inst->GetSingleWordInOperand(3); uint32_t op3 = inst->GetSingleWordInOperand(4); Instruction* min = ir_builder.AddNaryExtendedInstruction( inst->type_id(), glsl405_ext_inst_id, static_cast(min_opcode), {op2, op3}); Instruction* max = ir_builder.AddNaryExtendedInstruction( inst->type_id(), glsl405_ext_inst_id, static_cast(max_opcode), {op2, op3}); Instruction::OperandList new_operands; new_operands.push_back({SPV_OPERAND_TYPE_ID, {glsl405_ext_inst_id}}); new_operands.push_back({SPV_OPERAND_TYPE_EXTENSION_INSTRUCTION_NUMBER, {static_cast(clamp_opcode)}}); new_operands.push_back({SPV_OPERAND_TYPE_ID, {op1}}); new_operands.push_back({SPV_OPERAND_TYPE_ID, {min->result_id()}}); new_operands.push_back({SPV_OPERAND_TYPE_ID, {max->result_id()}}); inst->SetInOperands(std::move(new_operands)); ctx->UpdateDefUse(inst); return true; } // Returns a folding rule that will replace the opcode with |opcode| and add // the capabilities required. The folding rule assumes it is folding an // OpGroup*NonUniformAMD instruction from the SPV_AMD_shader_ballot extension. template bool ReplaceGroupNonuniformOperationOpCode( IRContext* ctx, Instruction* inst, const std::vector&) { switch (new_opcode) { case spv::Op::OpGroupNonUniformIAdd: case spv::Op::OpGroupNonUniformFAdd: case spv::Op::OpGroupNonUniformUMin: case spv::Op::OpGroupNonUniformSMin: case spv::Op::OpGroupNonUniformFMin: case spv::Op::OpGroupNonUniformUMax: case spv::Op::OpGroupNonUniformSMax: case spv::Op::OpGroupNonUniformFMax: break; default: assert( false && "Should be replacing with a group non uniform arithmetic operation."); } switch (inst->opcode()) { case spv::Op::OpGroupIAddNonUniformAMD: case spv::Op::OpGroupFAddNonUniformAMD: case spv::Op::OpGroupUMinNonUniformAMD: case spv::Op::OpGroupSMinNonUniformAMD: case spv::Op::OpGroupFMinNonUniformAMD: case spv::Op::OpGroupUMaxNonUniformAMD: case spv::Op::OpGroupSMaxNonUniformAMD: case spv::Op::OpGroupFMaxNonUniformAMD: break; default: assert(false && "Should be replacing a group non uniform arithmetic operation."); } ctx->AddCapability(spv::Capability::GroupNonUniformArithmetic); inst->SetOpcode(new_opcode); return true; } // Returns a folding rule that will replace the SwizzleInvocationsAMD extended // instruction in the SPV_AMD_shader_ballot extension. // // The instruction // // %offset = OpConstantComposite %v3uint %x %y %z %w // %result = OpExtInst %type %1 SwizzleInvocationsAMD %data %offset // // is replaced with // // potentially new constants and types // // clang-format off // %uint_max = OpConstant %uint 0xFFFFFFFF // %v4uint = OpTypeVector %uint 4 // %ballot_value = OpConstantComposite %v4uint %uint_max %uint_max %uint_max %uint_max // %null = OpConstantNull %type // clang-format on // // and the following code in the function body // // clang-format off // %id = OpLoad %uint %SubgroupLocalInvocationId // %quad_idx = OpBitwiseAnd %uint %id %uint_3 // %quad_ldr = OpBitwiseXor %uint %id %quad_idx // %my_offset = OpVectorExtractDynamic %uint %offset %quad_idx // %target_inv = OpIAdd %uint %quad_ldr %my_offset // %is_active = OpGroupNonUniformBallotBitExtract %bool %uint_3 %ballot_value %target_inv // %shuffle = OpGroupNonUniformShuffle %type %uint_3 %data %target_inv // %result = OpSelect %type %is_active %shuffle %null // clang-format on // // Also adding the capabilities and builtins that are needed. bool ReplaceSwizzleInvocations(IRContext* ctx, Instruction* inst, const std::vector&) { analysis::TypeManager* type_mgr = ctx->get_type_mgr(); analysis::ConstantManager* const_mgr = ctx->get_constant_mgr(); ctx->AddExtension("SPV_KHR_shader_ballot"); ctx->AddCapability(spv::Capability::GroupNonUniformBallot); ctx->AddCapability(spv::Capability::GroupNonUniformShuffle); InstructionBuilder ir_builder( ctx, inst, IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); uint32_t data_id = inst->GetSingleWordInOperand(2); uint32_t offset_id = inst->GetSingleWordInOperand(3); // Get the subgroup invocation id. uint32_t var_id = ctx->GetBuiltinInputVarId( uint32_t(spv::BuiltIn::SubgroupLocalInvocationId)); assert(var_id != 0 && "Could not get SubgroupLocalInvocationId variable."); Instruction* var_inst = ctx->get_def_use_mgr()->GetDef(var_id); Instruction* var_ptr_type = ctx->get_def_use_mgr()->GetDef(var_inst->type_id()); uint32_t uint_type_id = var_ptr_type->GetSingleWordInOperand(1); Instruction* id = ir_builder.AddLoad(uint_type_id, var_id); uint32_t quad_mask = ir_builder.GetUintConstantId(3); // This gives the offset in the group of 4 of this invocation. Instruction* quad_idx = ir_builder.AddBinaryOp( uint_type_id, spv::Op::OpBitwiseAnd, id->result_id(), quad_mask); // Get the invocation id of the first invocation in the group of 4. Instruction* quad_ldr = ir_builder.AddBinaryOp(uint_type_id, spv::Op::OpBitwiseXor, id->result_id(), quad_idx->result_id()); // Get the offset of the target invocation from the offset vector. Instruction* my_offset = ir_builder.AddBinaryOp(uint_type_id, spv::Op::OpVectorExtractDynamic, offset_id, quad_idx->result_id()); // Determine the index of the invocation to read from. Instruction* target_inv = ir_builder.AddBinaryOp(uint_type_id, spv::Op::OpIAdd, quad_ldr->result_id(), my_offset->result_id()); // Do the group operations uint32_t uint_max_id = ir_builder.GetUintConstantId(0xFFFFFFFF); uint32_t subgroup_scope = ir_builder.GetUintConstantId(uint32_t(spv::Scope::Subgroup)); const auto* ballot_value_const = const_mgr->GetConstant( type_mgr->GetUIntVectorType(4), {uint_max_id, uint_max_id, uint_max_id, uint_max_id}); Instruction* ballot_value = const_mgr->GetDefiningInstruction(ballot_value_const); Instruction* is_active = ir_builder.AddNaryOp( type_mgr->GetBoolTypeId(), spv::Op::OpGroupNonUniformBallotBitExtract, {subgroup_scope, ballot_value->result_id(), target_inv->result_id()}); Instruction* shuffle = ir_builder.AddNaryOp(inst->type_id(), spv::Op::OpGroupNonUniformShuffle, {subgroup_scope, data_id, target_inv->result_id()}); // Create the null constant to use in the select. const auto* null = const_mgr->GetConstant(type_mgr->GetType(inst->type_id()), std::vector()); Instruction* null_inst = const_mgr->GetDefiningInstruction(null); // Build the select. inst->SetOpcode(spv::Op::OpSelect); Instruction::OperandList new_operands; new_operands.push_back({SPV_OPERAND_TYPE_ID, {is_active->result_id()}}); new_operands.push_back({SPV_OPERAND_TYPE_ID, {shuffle->result_id()}}); new_operands.push_back({SPV_OPERAND_TYPE_ID, {null_inst->result_id()}}); inst->SetInOperands(std::move(new_operands)); ctx->UpdateDefUse(inst); return true; } // Returns a folding rule that will replace the SwizzleInvocationsMaskedAMD // extended instruction in the SPV_AMD_shader_ballot extension. // // The instruction // // %mask = OpConstantComposite %v3uint %uint_x %uint_y %uint_z // %result = OpExtInst %uint %1 SwizzleInvocationsMaskedAMD %data %mask // // is replaced with // // potentially new constants and types // // clang-format off // %uint_mask_extend = OpConstant %uint 0xFFFFFFE0 // %uint_max = OpConstant %uint 0xFFFFFFFF // %v4uint = OpTypeVector %uint 4 // %ballot_value = OpConstantComposite %v4uint %uint_max %uint_max %uint_max %uint_max // clang-format on // // and the following code in the function body // // clang-format off // %id = OpLoad %uint %SubgroupLocalInvocationId // %and_mask = OpBitwiseOr %uint %uint_x %uint_mask_extend // %and = OpBitwiseAnd %uint %id %and_mask // %or = OpBitwiseOr %uint %and %uint_y // %target_inv = OpBitwiseXor %uint %or %uint_z // %is_active = OpGroupNonUniformBallotBitExtract %bool %uint_3 %ballot_value %target_inv // %shuffle = OpGroupNonUniformShuffle %type %uint_3 %data %target_inv // %result = OpSelect %type %is_active %shuffle %uint_0 // clang-format on // // Also adding the capabilities and builtins that are needed. bool ReplaceSwizzleInvocationsMasked( IRContext* ctx, Instruction* inst, const std::vector&) { analysis::TypeManager* type_mgr = ctx->get_type_mgr(); analysis::DefUseManager* def_use_mgr = ctx->get_def_use_mgr(); analysis::ConstantManager* const_mgr = ctx->get_constant_mgr(); ctx->AddCapability(spv::Capability::GroupNonUniformBallot); ctx->AddCapability(spv::Capability::GroupNonUniformShuffle); InstructionBuilder ir_builder( ctx, inst, IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); // Get the operands to inst, and the components of the mask uint32_t data_id = inst->GetSingleWordInOperand(2); Instruction* mask_inst = def_use_mgr->GetDef(inst->GetSingleWordInOperand(3)); assert(mask_inst->opcode() == spv::Op::OpConstantComposite && "The mask is suppose to be a vector constant."); assert(mask_inst->NumInOperands() == 3 && "The mask is suppose to have 3 components."); uint32_t uint_x = mask_inst->GetSingleWordInOperand(0); uint32_t uint_y = mask_inst->GetSingleWordInOperand(1); uint32_t uint_z = mask_inst->GetSingleWordInOperand(2); // Get the subgroup invocation id. uint32_t var_id = ctx->GetBuiltinInputVarId( uint32_t(spv::BuiltIn::SubgroupLocalInvocationId)); ctx->AddExtension("SPV_KHR_shader_ballot"); assert(var_id != 0 && "Could not get SubgroupLocalInvocationId variable."); Instruction* var_inst = ctx->get_def_use_mgr()->GetDef(var_id); Instruction* var_ptr_type = ctx->get_def_use_mgr()->GetDef(var_inst->type_id()); uint32_t uint_type_id = var_ptr_type->GetSingleWordInOperand(1); Instruction* id = ir_builder.AddLoad(uint_type_id, var_id); // Do the bitwise operations. uint32_t mask_extended = ir_builder.GetUintConstantId(0xFFFFFFE0); Instruction* and_mask = ir_builder.AddBinaryOp( uint_type_id, spv::Op::OpBitwiseOr, uint_x, mask_extended); Instruction* and_result = ir_builder.AddBinaryOp(uint_type_id, spv::Op::OpBitwiseAnd, id->result_id(), and_mask->result_id()); Instruction* or_result = ir_builder.AddBinaryOp( uint_type_id, spv::Op::OpBitwiseOr, and_result->result_id(), uint_y); Instruction* target_inv = ir_builder.AddBinaryOp( uint_type_id, spv::Op::OpBitwiseXor, or_result->result_id(), uint_z); // Do the group operations uint32_t uint_max_id = ir_builder.GetUintConstantId(0xFFFFFFFF); uint32_t subgroup_scope = ir_builder.GetUintConstantId(uint32_t(spv::Scope::Subgroup)); const auto* ballot_value_const = const_mgr->GetConstant( type_mgr->GetUIntVectorType(4), {uint_max_id, uint_max_id, uint_max_id, uint_max_id}); Instruction* ballot_value = const_mgr->GetDefiningInstruction(ballot_value_const); Instruction* is_active = ir_builder.AddNaryOp( type_mgr->GetBoolTypeId(), spv::Op::OpGroupNonUniformBallotBitExtract, {subgroup_scope, ballot_value->result_id(), target_inv->result_id()}); Instruction* shuffle = ir_builder.AddNaryOp(inst->type_id(), spv::Op::OpGroupNonUniformShuffle, {subgroup_scope, data_id, target_inv->result_id()}); // Create the null constant to use in the select. const auto* null = const_mgr->GetConstant(type_mgr->GetType(inst->type_id()), std::vector()); Instruction* null_inst = const_mgr->GetDefiningInstruction(null); // Build the select. inst->SetOpcode(spv::Op::OpSelect); Instruction::OperandList new_operands; new_operands.push_back({SPV_OPERAND_TYPE_ID, {is_active->result_id()}}); new_operands.push_back({SPV_OPERAND_TYPE_ID, {shuffle->result_id()}}); new_operands.push_back({SPV_OPERAND_TYPE_ID, {null_inst->result_id()}}); inst->SetInOperands(std::move(new_operands)); ctx->UpdateDefUse(inst); return true; } // Returns a folding rule that will replace the WriteInvocationAMD extended // instruction in the SPV_AMD_shader_ballot extension. // // The instruction // // clang-format off // %result = OpExtInst %type %1 WriteInvocationAMD %input_value %write_value %invocation_index // clang-format on // // with // // %id = OpLoad %uint %SubgroupLocalInvocationId // %cmp = OpIEqual %bool %id %invocation_index // %result = OpSelect %type %cmp %write_value %input_value // // Also adding the capabilities and builtins that are needed. bool ReplaceWriteInvocation(IRContext* ctx, Instruction* inst, const std::vector&) { uint32_t var_id = ctx->GetBuiltinInputVarId( uint32_t(spv::BuiltIn::SubgroupLocalInvocationId)); ctx->AddCapability(spv::Capability::SubgroupBallotKHR); ctx->AddExtension("SPV_KHR_shader_ballot"); assert(var_id != 0 && "Could not get SubgroupLocalInvocationId variable."); Instruction* var_inst = ctx->get_def_use_mgr()->GetDef(var_id); Instruction* var_ptr_type = ctx->get_def_use_mgr()->GetDef(var_inst->type_id()); InstructionBuilder ir_builder( ctx, inst, IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); Instruction* t = ir_builder.AddLoad(var_ptr_type->GetSingleWordInOperand(1), var_id); analysis::Bool bool_type; uint32_t bool_type_id = ctx->get_type_mgr()->GetTypeInstruction(&bool_type); Instruction* cmp = ir_builder.AddBinaryOp(bool_type_id, spv::Op::OpIEqual, t->result_id(), inst->GetSingleWordInOperand(4)); // Build a select. inst->SetOpcode(spv::Op::OpSelect); Instruction::OperandList new_operands; new_operands.push_back({SPV_OPERAND_TYPE_ID, {cmp->result_id()}}); new_operands.push_back(inst->GetInOperand(3)); new_operands.push_back(inst->GetInOperand(2)); inst->SetInOperands(std::move(new_operands)); ctx->UpdateDefUse(inst); return true; } // Returns a folding rule that will replace the MbcntAMD extended instruction in // the SPV_AMD_shader_ballot extension. // // The instruction // // %result = OpExtInst %uint %1 MbcntAMD %mask // // with // // Get SubgroupLtMask and convert the first 64-bits into a uint64_t because // AMD's shader compiler expects a 64-bit integer mask. // // %var = OpLoad %v4uint %SubgroupLtMaskKHR // %shuffle = OpVectorShuffle %v2uint %var %var 0 1 // %cast = OpBitcast %ulong %shuffle // // Perform the mask and count the bits. // // %and = OpBitwiseAnd %ulong %cast %mask // %result = OpBitCount %uint %and // // Also adding the capabilities and builtins that are needed. bool ReplaceMbcnt(IRContext* context, Instruction* inst, const std::vector&) { analysis::TypeManager* type_mgr = context->get_type_mgr(); analysis::DefUseManager* def_use_mgr = context->get_def_use_mgr(); uint32_t var_id = context->GetBuiltinInputVarId(uint32_t(spv::BuiltIn::SubgroupLtMask)); assert(var_id != 0 && "Could not get SubgroupLtMask variable."); context->AddCapability(spv::Capability::GroupNonUniformBallot); Instruction* var_inst = def_use_mgr->GetDef(var_id); Instruction* var_ptr_type = def_use_mgr->GetDef(var_inst->type_id()); Instruction* var_type = def_use_mgr->GetDef(var_ptr_type->GetSingleWordInOperand(1)); assert(var_type->opcode() == spv::Op::OpTypeVector && "Variable is suppose to be a vector of 4 ints"); // Get the type for the shuffle. analysis::Vector temp_type(GetUIntType(context), 2); const analysis::Type* shuffle_type = context->get_type_mgr()->GetRegisteredType(&temp_type); uint32_t shuffle_type_id = type_mgr->GetTypeInstruction(shuffle_type); uint32_t mask_id = inst->GetSingleWordInOperand(2); Instruction* mask_inst = def_use_mgr->GetDef(mask_id); // Testing with amd's shader compiler shows that a 64-bit mask is expected. assert(type_mgr->GetType(mask_inst->type_id())->AsInteger() != nullptr); assert(type_mgr->GetType(mask_inst->type_id())->AsInteger()->width() == 64); InstructionBuilder ir_builder( context, inst, IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); Instruction* load = ir_builder.AddLoad(var_type->result_id(), var_id); Instruction* shuffle = ir_builder.AddVectorShuffle( shuffle_type_id, load->result_id(), load->result_id(), {0, 1}); Instruction* bitcast = ir_builder.AddUnaryOp( mask_inst->type_id(), spv::Op::OpBitcast, shuffle->result_id()); Instruction* t = ir_builder.AddBinaryOp(mask_inst->type_id(), spv::Op::OpBitwiseAnd, bitcast->result_id(), mask_id); inst->SetOpcode(spv::Op::OpBitCount); inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {t->result_id()}}}); context->UpdateDefUse(inst); return true; } // A folding rule that will replace the CubeFaceCoordAMD extended // instruction in the SPV_AMD_gcn_shader_ballot. Returns true if the folding is // successful. // // The instruction // // %result = OpExtInst %v2float %1 CubeFaceCoordAMD %input // // with // // %x = OpCompositeExtract %float %input 0 // %y = OpCompositeExtract %float %input 1 // %z = OpCompositeExtract %float %input 2 // %nx = OpFNegate %float %x // %ny = OpFNegate %float %y // %nz = OpFNegate %float %z // %ax = OpExtInst %float %n_1 FAbs %x // %ay = OpExtInst %float %n_1 FAbs %y // %az = OpExtInst %float %n_1 FAbs %z // %amax_x_y = OpExtInst %float %n_1 FMax %ay %ax // %amax = OpExtInst %float %n_1 FMax %az %amax_x_y // %cubema = OpFMul %float %float_2 %amax // %is_z_max = OpFOrdGreaterThanEqual %bool %az %amax_x_y // %not_is_z_max = OpLogicalNot %bool %is_z_max // %y_gt_x = OpFOrdGreaterThanEqual %bool %ay %ax // %is_y_max = OpLogicalAnd %bool %not_is_z_max %y_gt_x // %is_z_neg = OpFOrdLessThan %bool %z %float_0 // %cubesc_case_1 = OpSelect %float %is_z_neg %nx %x // %is_x_neg = OpFOrdLessThan %bool %x %float_0 // %cubesc_case_2 = OpSelect %float %is_x_neg %z %nz // %sel = OpSelect %float %is_y_max %x %cubesc_case_2 // %cubesc = OpSelect %float %is_z_max %cubesc_case_1 %sel // %is_y_neg = OpFOrdLessThan %bool %y %float_0 // %cubetc_case_1 = OpSelect %float %is_y_neg %nz %z // %cubetc = OpSelect %float %is_y_max %cubetc_case_1 %ny // %cube = OpCompositeConstruct %v2float %cubesc %cubetc // %denom = OpCompositeConstruct %v2float %cubema %cubema // %div = OpFDiv %v2float %cube %denom // %result = OpFAdd %v2float %div %const // // Also adding the capabilities and builtins that are needed. bool ReplaceCubeFaceCoord(IRContext* ctx, Instruction* inst, const std::vector&) { analysis::TypeManager* type_mgr = ctx->get_type_mgr(); analysis::ConstantManager* const_mgr = ctx->get_constant_mgr(); uint32_t float_type_id = type_mgr->GetFloatTypeId(); const analysis::Type* v2_float_type = type_mgr->GetFloatVectorType(2); uint32_t v2_float_type_id = type_mgr->GetId(v2_float_type); uint32_t bool_id = type_mgr->GetBoolTypeId(); InstructionBuilder ir_builder( ctx, inst, IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); uint32_t input_id = inst->GetSingleWordInOperand(2); uint32_t glsl405_ext_inst_id = ctx->get_feature_mgr()->GetExtInstImportId_GLSLstd450(); if (glsl405_ext_inst_id == 0) { ctx->AddExtInstImport("GLSL.std.450"); glsl405_ext_inst_id = ctx->get_feature_mgr()->GetExtInstImportId_GLSLstd450(); } // Get the constants that will be used. uint32_t f0_const_id = const_mgr->GetFloatConstId(0.0); uint32_t f2_const_id = const_mgr->GetFloatConstId(2.0); uint32_t f0_5_const_id = const_mgr->GetFloatConstId(0.5); const analysis::Constant* vec_const = const_mgr->GetConstant(v2_float_type, {f0_5_const_id, f0_5_const_id}); uint32_t vec_const_id = const_mgr->GetDefiningInstruction(vec_const)->result_id(); // Extract the input values. Instruction* x = ir_builder.AddCompositeExtract(float_type_id, input_id, {0}); Instruction* y = ir_builder.AddCompositeExtract(float_type_id, input_id, {1}); Instruction* z = ir_builder.AddCompositeExtract(float_type_id, input_id, {2}); // Negate the input values. Instruction* nx = ir_builder.AddUnaryOp(float_type_id, spv::Op::OpFNegate, x->result_id()); Instruction* ny = ir_builder.AddUnaryOp(float_type_id, spv::Op::OpFNegate, y->result_id()); Instruction* nz = ir_builder.AddUnaryOp(float_type_id, spv::Op::OpFNegate, z->result_id()); // Get the abolsute values of the inputs. Instruction* ax = ir_builder.AddNaryExtendedInstruction( float_type_id, glsl405_ext_inst_id, GLSLstd450FAbs, {x->result_id()}); Instruction* ay = ir_builder.AddNaryExtendedInstruction( float_type_id, glsl405_ext_inst_id, GLSLstd450FAbs, {y->result_id()}); Instruction* az = ir_builder.AddNaryExtendedInstruction( float_type_id, glsl405_ext_inst_id, GLSLstd450FAbs, {z->result_id()}); // Find which values are negative. Used in later computations. Instruction* is_z_neg = ir_builder.AddBinaryOp( bool_id, spv::Op::OpFOrdLessThan, z->result_id(), f0_const_id); Instruction* is_y_neg = ir_builder.AddBinaryOp( bool_id, spv::Op::OpFOrdLessThan, y->result_id(), f0_const_id); Instruction* is_x_neg = ir_builder.AddBinaryOp( bool_id, spv::Op::OpFOrdLessThan, x->result_id(), f0_const_id); // Compute cubema Instruction* amax_x_y = ir_builder.AddNaryExtendedInstruction( float_type_id, glsl405_ext_inst_id, GLSLstd450FMax, {ax->result_id(), ay->result_id()}); Instruction* amax = ir_builder.AddNaryExtendedInstruction( float_type_id, glsl405_ext_inst_id, GLSLstd450FMax, {az->result_id(), amax_x_y->result_id()}); Instruction* cubema = ir_builder.AddBinaryOp(float_type_id, spv::Op::OpFMul, f2_const_id, amax->result_id()); // Do the comparisons needed for computing cubesc and cubetc. Instruction* is_z_max = ir_builder.AddBinaryOp(bool_id, spv::Op::OpFOrdGreaterThanEqual, az->result_id(), amax_x_y->result_id()); Instruction* not_is_z_max = ir_builder.AddUnaryOp( bool_id, spv::Op::OpLogicalNot, is_z_max->result_id()); Instruction* y_gr_x = ir_builder.AddBinaryOp(bool_id, spv::Op::OpFOrdGreaterThanEqual, ay->result_id(), ax->result_id()); Instruction* is_y_max = ir_builder.AddBinaryOp(bool_id, spv::Op::OpLogicalAnd, not_is_z_max->result_id(), y_gr_x->result_id()); // Select the correct value for cubesc. Instruction* cubesc_case_1 = ir_builder.AddSelect( float_type_id, is_z_neg->result_id(), nx->result_id(), x->result_id()); Instruction* cubesc_case_2 = ir_builder.AddSelect( float_type_id, is_x_neg->result_id(), z->result_id(), nz->result_id()); Instruction* sel = ir_builder.AddSelect(float_type_id, is_y_max->result_id(), x->result_id(), cubesc_case_2->result_id()); Instruction* cubesc = ir_builder.AddSelect(float_type_id, is_z_max->result_id(), cubesc_case_1->result_id(), sel->result_id()); // Select the correct value for cubetc. Instruction* cubetc_case_1 = ir_builder.AddSelect( float_type_id, is_y_neg->result_id(), nz->result_id(), z->result_id()); Instruction* cubetc = ir_builder.AddSelect(float_type_id, is_y_max->result_id(), cubetc_case_1->result_id(), ny->result_id()); // Do the division Instruction* cube = ir_builder.AddCompositeConstruct( v2_float_type_id, {cubesc->result_id(), cubetc->result_id()}); Instruction* denom = ir_builder.AddCompositeConstruct( v2_float_type_id, {cubema->result_id(), cubema->result_id()}); Instruction* div = ir_builder.AddBinaryOp( v2_float_type_id, spv::Op::OpFDiv, cube->result_id(), denom->result_id()); // Get the final result by adding 0.5 to |div|. inst->SetOpcode(spv::Op::OpFAdd); Instruction::OperandList new_operands; new_operands.push_back({SPV_OPERAND_TYPE_ID, {div->result_id()}}); new_operands.push_back({SPV_OPERAND_TYPE_ID, {vec_const_id}}); inst->SetInOperands(std::move(new_operands)); ctx->UpdateDefUse(inst); return true; } // A folding rule that will replace the CubeFaceIndexAMD extended // instruction in the SPV_AMD_gcn_shader_ballot. Returns true if the folding // is successful. // // The instruction // // %result = OpExtInst %float %1 CubeFaceIndexAMD %input // // with // // %x = OpCompositeExtract %float %input 0 // %y = OpCompositeExtract %float %input 1 // %z = OpCompositeExtract %float %input 2 // %ax = OpExtInst %float %n_1 FAbs %x // %ay = OpExtInst %float %n_1 FAbs %y // %az = OpExtInst %float %n_1 FAbs %z // %is_z_neg = OpFOrdLessThan %bool %z %float_0 // %is_y_neg = OpFOrdLessThan %bool %y %float_0 // %is_x_neg = OpFOrdLessThan %bool %x %float_0 // %amax_x_y = OpExtInst %float %n_1 FMax %ax %ay // %is_z_max = OpFOrdGreaterThanEqual %bool %az %amax_x_y // %y_gt_x = OpFOrdGreaterThanEqual %bool %ay %ax // %case_z = OpSelect %float %is_z_neg %float_5 %float4 // %case_y = OpSelect %float %is_y_neg %float_3 %float2 // %case_x = OpSelect %float %is_x_neg %float_1 %float0 // %sel = OpSelect %float %y_gt_x %case_y %case_x // %result = OpSelect %float %is_z_max %case_z %sel // // Also adding the capabilities and builtins that are needed. bool ReplaceCubeFaceIndex(IRContext* ctx, Instruction* inst, const std::vector&) { analysis::TypeManager* type_mgr = ctx->get_type_mgr(); analysis::ConstantManager* const_mgr = ctx->get_constant_mgr(); uint32_t float_type_id = type_mgr->GetFloatTypeId(); uint32_t bool_id = type_mgr->GetBoolTypeId(); InstructionBuilder ir_builder( ctx, inst, IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); uint32_t input_id = inst->GetSingleWordInOperand(2); uint32_t glsl405_ext_inst_id = ctx->get_feature_mgr()->GetExtInstImportId_GLSLstd450(); if (glsl405_ext_inst_id == 0) { ctx->AddExtInstImport("GLSL.std.450"); glsl405_ext_inst_id = ctx->get_feature_mgr()->GetExtInstImportId_GLSLstd450(); } // Get the constants that will be used. uint32_t f0_const_id = const_mgr->GetFloatConstId(0.0); uint32_t f1_const_id = const_mgr->GetFloatConstId(1.0); uint32_t f2_const_id = const_mgr->GetFloatConstId(2.0); uint32_t f3_const_id = const_mgr->GetFloatConstId(3.0); uint32_t f4_const_id = const_mgr->GetFloatConstId(4.0); uint32_t f5_const_id = const_mgr->GetFloatConstId(5.0); // Extract the input values. Instruction* x = ir_builder.AddCompositeExtract(float_type_id, input_id, {0}); Instruction* y = ir_builder.AddCompositeExtract(float_type_id, input_id, {1}); Instruction* z = ir_builder.AddCompositeExtract(float_type_id, input_id, {2}); // Get the absolute values of the inputs. Instruction* ax = ir_builder.AddNaryExtendedInstruction( float_type_id, glsl405_ext_inst_id, GLSLstd450FAbs, {x->result_id()}); Instruction* ay = ir_builder.AddNaryExtendedInstruction( float_type_id, glsl405_ext_inst_id, GLSLstd450FAbs, {y->result_id()}); Instruction* az = ir_builder.AddNaryExtendedInstruction( float_type_id, glsl405_ext_inst_id, GLSLstd450FAbs, {z->result_id()}); // Find which values are negative. Used in later computations. Instruction* is_z_neg = ir_builder.AddBinaryOp( bool_id, spv::Op::OpFOrdLessThan, z->result_id(), f0_const_id); Instruction* is_y_neg = ir_builder.AddBinaryOp( bool_id, spv::Op::OpFOrdLessThan, y->result_id(), f0_const_id); Instruction* is_x_neg = ir_builder.AddBinaryOp( bool_id, spv::Op::OpFOrdLessThan, x->result_id(), f0_const_id); // Find the max value. Instruction* amax_x_y = ir_builder.AddNaryExtendedInstruction( float_type_id, glsl405_ext_inst_id, GLSLstd450FMax, {ax->result_id(), ay->result_id()}); Instruction* is_z_max = ir_builder.AddBinaryOp(bool_id, spv::Op::OpFOrdGreaterThanEqual, az->result_id(), amax_x_y->result_id()); Instruction* y_gr_x = ir_builder.AddBinaryOp(bool_id, spv::Op::OpFOrdGreaterThanEqual, ay->result_id(), ax->result_id()); // Get the value for each case. Instruction* case_z = ir_builder.AddSelect( float_type_id, is_z_neg->result_id(), f5_const_id, f4_const_id); Instruction* case_y = ir_builder.AddSelect( float_type_id, is_y_neg->result_id(), f3_const_id, f2_const_id); Instruction* case_x = ir_builder.AddSelect( float_type_id, is_x_neg->result_id(), f1_const_id, f0_const_id); // Select the correct case. Instruction* sel = ir_builder.AddSelect(float_type_id, y_gr_x->result_id(), case_y->result_id(), case_x->result_id()); // Get the final result by adding 0.5 to |div|. inst->SetOpcode(spv::Op::OpSelect); Instruction::OperandList new_operands; new_operands.push_back({SPV_OPERAND_TYPE_ID, {is_z_max->result_id()}}); new_operands.push_back({SPV_OPERAND_TYPE_ID, {case_z->result_id()}}); new_operands.push_back({SPV_OPERAND_TYPE_ID, {sel->result_id()}}); inst->SetInOperands(std::move(new_operands)); ctx->UpdateDefUse(inst); return true; } // A folding rule that will replace the TimeAMD extended instruction in the // SPV_AMD_gcn_shader_ballot. It returns true if the folding is successful. // It returns False, otherwise. // // The instruction // // %result = OpExtInst %uint64 %1 TimeAMD // // with // // %result = OpReadClockKHR %uint64 %uint_3 // // NOTE: TimeAMD uses subgroup scope (it is not a real time clock). bool ReplaceTimeAMD(IRContext* ctx, Instruction* inst, const std::vector&) { InstructionBuilder ir_builder( ctx, inst, IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); ctx->AddExtension("SPV_KHR_shader_clock"); ctx->AddCapability(spv::Capability::ShaderClockKHR); inst->SetOpcode(spv::Op::OpReadClockKHR); Instruction::OperandList args; uint32_t subgroup_scope_id = ir_builder.GetUintConstantId(uint32_t(spv::Scope::Subgroup)); args.push_back({SPV_OPERAND_TYPE_ID, {subgroup_scope_id}}); inst->SetInOperands(std::move(args)); ctx->UpdateDefUse(inst); return true; } class AmdExtFoldingRules : public FoldingRules { public: explicit AmdExtFoldingRules(IRContext* ctx) : FoldingRules(ctx) {} protected: virtual void AddFoldingRules() override { rules_[spv::Op::OpGroupIAddNonUniformAMD].push_back( ReplaceGroupNonuniformOperationOpCode); rules_[spv::Op::OpGroupFAddNonUniformAMD].push_back( ReplaceGroupNonuniformOperationOpCode); rules_[spv::Op::OpGroupUMinNonUniformAMD].push_back( ReplaceGroupNonuniformOperationOpCode); rules_[spv::Op::OpGroupSMinNonUniformAMD].push_back( ReplaceGroupNonuniformOperationOpCode); rules_[spv::Op::OpGroupFMinNonUniformAMD].push_back( ReplaceGroupNonuniformOperationOpCode); rules_[spv::Op::OpGroupUMaxNonUniformAMD].push_back( ReplaceGroupNonuniformOperationOpCode); rules_[spv::Op::OpGroupSMaxNonUniformAMD].push_back( ReplaceGroupNonuniformOperationOpCode); rules_[spv::Op::OpGroupFMaxNonUniformAMD].push_back( ReplaceGroupNonuniformOperationOpCode); uint32_t extension_id = context()->module()->GetExtInstImportId("SPV_AMD_shader_ballot"); if (extension_id != 0) { ext_rules_[{extension_id, AmdShaderBallotSwizzleInvocationsAMD}] .push_back(ReplaceSwizzleInvocations); ext_rules_[{extension_id, AmdShaderBallotSwizzleInvocationsMaskedAMD}] .push_back(ReplaceSwizzleInvocationsMasked); ext_rules_[{extension_id, AmdShaderBallotWriteInvocationAMD}].push_back( ReplaceWriteInvocation); ext_rules_[{extension_id, AmdShaderBallotMbcntAMD}].push_back( ReplaceMbcnt); } extension_id = context()->module()->GetExtInstImportId( "SPV_AMD_shader_trinary_minmax"); if (extension_id != 0) { ext_rules_[{extension_id, FMin3AMD}].push_back( ReplaceTrinaryMinMax); ext_rules_[{extension_id, UMin3AMD}].push_back( ReplaceTrinaryMinMax); ext_rules_[{extension_id, SMin3AMD}].push_back( ReplaceTrinaryMinMax); ext_rules_[{extension_id, FMax3AMD}].push_back( ReplaceTrinaryMinMax); ext_rules_[{extension_id, UMax3AMD}].push_back( ReplaceTrinaryMinMax); ext_rules_[{extension_id, SMax3AMD}].push_back( ReplaceTrinaryMinMax); ext_rules_[{extension_id, FMid3AMD}].push_back( ReplaceTrinaryMid); ext_rules_[{extension_id, UMid3AMD}].push_back( ReplaceTrinaryMid); ext_rules_[{extension_id, SMid3AMD}].push_back( ReplaceTrinaryMid); } extension_id = context()->module()->GetExtInstImportId("SPV_AMD_gcn_shader"); if (extension_id != 0) { ext_rules_[{extension_id, CubeFaceCoordAMD}].push_back( ReplaceCubeFaceCoord); ext_rules_[{extension_id, CubeFaceIndexAMD}].push_back( ReplaceCubeFaceIndex); ext_rules_[{extension_id, TimeAMD}].push_back(ReplaceTimeAMD); } } }; class AmdExtConstFoldingRules : public ConstantFoldingRules { public: AmdExtConstFoldingRules(IRContext* ctx) : ConstantFoldingRules(ctx) {} protected: virtual void AddFoldingRules() override {} }; } // namespace Pass::Status AmdExtensionToKhrPass::Process() { bool changed = false; // Traverse the body of the functions to replace instructions that require // the extensions. InstructionFolder folder( context(), std::unique_ptr(new AmdExtFoldingRules(context())), MakeUnique(context())); for (Function& func : *get_module()) { func.ForEachInst([&changed, &folder](Instruction* inst) { if (folder.FoldInstruction(inst)) { changed = true; } }); } // Now that instruction that require the extensions have been removed, we can // remove the extension instructions. std::set ext_to_remove = {"SPV_AMD_shader_ballot", "SPV_AMD_shader_trinary_minmax", "SPV_AMD_gcn_shader"}; std::vector to_be_killed; for (Instruction& inst : context()->module()->extensions()) { if (inst.opcode() == spv::Op::OpExtension) { if (ext_to_remove.count(inst.GetInOperand(0).AsString()) != 0) { to_be_killed.push_back(&inst); } } } for (Instruction& inst : context()->ext_inst_imports()) { if (inst.opcode() == spv::Op::OpExtInstImport) { if (ext_to_remove.count(inst.GetInOperand(0).AsString()) != 0) { to_be_killed.push_back(&inst); } } } for (Instruction* inst : to_be_killed) { context()->KillInst(inst); changed = true; } // The replacements that take place use instructions that are missing before // SPIR-V 1.3. If we changed something, we will have to make sure the version // is at least SPIR-V 1.3 to make sure those instruction can be used. if (changed) { uint32_t version = get_module()->version(); if (version < 0x00010300 /*1.3*/) { get_module()->set_version(0x00010300); } } return changed ? Status::SuccessWithChange : Status::SuccessWithoutChange; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/amd_ext_to_khr.h000066400000000000000000000036311475742701700237760ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_AMD_EXT_TO_KHR_H_ #define SOURCE_OPT_AMD_EXT_TO_KHR_H_ #include "source/opt/ir_context.h" #include "source/opt/module.h" #include "source/opt/pass.h" namespace spvtools { namespace opt { // Replaces the extensions VK_AMD_shader_ballot, VK_AMD_gcn_shader, and // VK_AMD_shader_trinary_minmax with equivalent code using core instructions and // capabilities. class AmdExtensionToKhrPass : public Pass { public: const char* name() const override { return "amd-ext-to-khr"; } Status Process() override; IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisDecorations | IRContext::kAnalysisCombinators | IRContext::kAnalysisCFG | IRContext::kAnalysisDominatorAnalysis | IRContext::kAnalysisLoopAnalysis | IRContext::kAnalysisNameMap | IRContext::kAnalysisScalarEvolution | IRContext::kAnalysisRegisterPressure | IRContext::kAnalysisValueNumberTable | IRContext::kAnalysisStructuredCFG | IRContext::kAnalysisBuiltinVarId | IRContext::kAnalysisIdToFuncMapping | IRContext::kAnalysisTypes | IRContext::kAnalysisDefUse | IRContext::kAnalysisConstants; } }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_AMD_EXT_TO_KHR_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/analyze_live_input_pass.cpp000066400000000000000000000031771475742701700262760ustar00rootroot00000000000000// Copyright (c) 2022 The Khronos Group Inc. // Copyright (c) 2022 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/analyze_live_input_pass.h" #include "source/opt/ir_context.h" namespace spvtools { namespace opt { Pass::Status AnalyzeLiveInputPass::Process() { // Current functionality assumes shader capability if (!context()->get_feature_mgr()->HasCapability(spv::Capability::Shader)) return Status::SuccessWithoutChange; Pass::Status status = DoLiveInputAnalysis(); return status; } Pass::Status AnalyzeLiveInputPass::DoLiveInputAnalysis() { // Current functionality only supports frag, tesc, tese or geom shaders. // Report failure for any other stage. auto stage = context()->GetStage(); if (stage != spv::ExecutionModel::Fragment && stage != spv::ExecutionModel::TessellationControl && stage != spv::ExecutionModel::TessellationEvaluation && stage != spv::ExecutionModel::Geometry) return Status::Failure; context()->get_liveness_mgr()->GetLiveness(live_locs_, live_builtins_); return Status::SuccessWithoutChange; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/analyze_live_input_pass.h000066400000000000000000000036301475742701700257350ustar00rootroot00000000000000// Copyright (c) 2022 The Khronos Group Inc. // Copyright (c) 2022 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_ANALYZE_LIVE_INPUT_H_ #define SOURCE_OPT_ANALYZE_LIVE_INPUT_H_ #include #include "source/opt/pass.h" namespace spvtools { namespace opt { // See optimizer.hpp for documentation. class AnalyzeLiveInputPass : public Pass { public: explicit AnalyzeLiveInputPass(std::unordered_set* live_locs, std::unordered_set* live_builtins) : live_locs_(live_locs), live_builtins_(live_builtins) {} const char* name() const override { return "analyze-live-input"; } Status Process() override; // Return the mask of preserved Analyses. IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisCombinators | IRContext::kAnalysisCFG | IRContext::kAnalysisDominatorAnalysis | IRContext::kAnalysisLoopAnalysis | IRContext::kAnalysisNameMap | IRContext::kAnalysisConstants | IRContext::kAnalysisTypes; } private: // Do live input analysis Status DoLiveInputAnalysis(); std::unordered_set* live_locs_; std::unordered_set* live_builtins_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_ANALYZE_LIVE_INPUT_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/basic_block.cpp000066400000000000000000000202351475742701700235740ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/basic_block.h" #include #include "source/opt/ir_context.h" #include "source/opt/reflect.h" #include "source/util/make_unique.h" namespace spvtools { namespace opt { namespace { constexpr uint32_t kLoopMergeContinueBlockIdInIdx = 1; constexpr uint32_t kLoopMergeMergeBlockIdInIdx = 0; constexpr uint32_t kSelectionMergeMergeBlockIdInIdx = 0; } // namespace BasicBlock* BasicBlock::Clone(IRContext* context) const { BasicBlock* clone = new BasicBlock( std::unique_ptr(GetLabelInst()->Clone(context))); for (const auto& inst : insts_) { // Use the incoming context clone->AddInstruction(std::unique_ptr(inst.Clone(context))); } if (context->AreAnalysesValid( IRContext::Analysis::kAnalysisInstrToBlockMapping)) { for (auto& inst : *clone) { context->set_instr_block(&inst, clone); } } return clone; } const Instruction* BasicBlock::GetMergeInst() const { const Instruction* result = nullptr; // If it exists, the merge instruction immediately precedes the // terminator. auto iter = ctail(); if (iter != cbegin()) { --iter; const auto opcode = iter->opcode(); if (opcode == spv::Op::OpLoopMerge || opcode == spv::Op::OpSelectionMerge) { result = &*iter; } } return result; } Instruction* BasicBlock::GetMergeInst() { Instruction* result = nullptr; // If it exists, the merge instruction immediately precedes the // terminator. auto iter = tail(); if (iter != begin()) { --iter; const auto opcode = iter->opcode(); if (opcode == spv::Op::OpLoopMerge || opcode == spv::Op::OpSelectionMerge) { result = &*iter; } } return result; } const Instruction* BasicBlock::GetLoopMergeInst() const { if (auto* merge = GetMergeInst()) { if (merge->opcode() == spv::Op::OpLoopMerge) { return merge; } } return nullptr; } Instruction* BasicBlock::GetLoopMergeInst() { if (auto* merge = GetMergeInst()) { if (merge->opcode() == spv::Op::OpLoopMerge) { return merge; } } return nullptr; } void BasicBlock::KillAllInsts(bool killLabel) { ForEachInst([killLabel](Instruction* ip) { if (killLabel || ip->opcode() != spv::Op::OpLabel) { ip->context()->KillInst(ip); } }); } void BasicBlock::ForEachSuccessorLabel( const std::function& f) const { WhileEachSuccessorLabel([f](const uint32_t l) { f(l); return true; }); } bool BasicBlock::WhileEachSuccessorLabel( const std::function& f) const { const auto br = &insts_.back(); switch (br->opcode()) { case spv::Op::OpBranch: return f(br->GetOperand(0).words[0]); case spv::Op::OpBranchConditional: case spv::Op::OpSwitch: { bool is_first = true; return br->WhileEachInId([&is_first, &f](const uint32_t* idp) { if (!is_first) return f(*idp); is_first = false; return true; }); } default: return true; } } void BasicBlock::ForEachSuccessorLabel( const std::function& f) { auto br = &insts_.back(); switch (br->opcode()) { case spv::Op::OpBranch: { uint32_t tmp_id = br->GetOperand(0).words[0]; f(&tmp_id); if (tmp_id != br->GetOperand(0).words[0]) br->SetOperand(0, {tmp_id}); } break; case spv::Op::OpBranchConditional: case spv::Op::OpSwitch: { bool is_first = true; br->ForEachInId([&is_first, &f](uint32_t* idp) { if (!is_first) f(idp); is_first = false; }); } break; default: break; } } bool BasicBlock::IsSuccessor(const BasicBlock* block) const { uint32_t succId = block->id(); bool isSuccessor = false; ForEachSuccessorLabel([&isSuccessor, succId](const uint32_t label) { if (label == succId) isSuccessor = true; }); return isSuccessor; } void BasicBlock::ForMergeAndContinueLabel( const std::function& f) { auto ii = insts_.end(); --ii; if (ii == insts_.begin()) return; --ii; if (ii->opcode() == spv::Op::OpSelectionMerge || ii->opcode() == spv::Op::OpLoopMerge) { ii->ForEachInId([&f](const uint32_t* idp) { f(*idp); }); } } uint32_t BasicBlock::MergeBlockIdIfAny() const { auto merge_ii = cend(); --merge_ii; uint32_t mbid = 0; if (merge_ii != cbegin()) { --merge_ii; if (merge_ii->opcode() == spv::Op::OpLoopMerge) { mbid = merge_ii->GetSingleWordInOperand(kLoopMergeMergeBlockIdInIdx); } else if (merge_ii->opcode() == spv::Op::OpSelectionMerge) { mbid = merge_ii->GetSingleWordInOperand(kSelectionMergeMergeBlockIdInIdx); } } return mbid; } uint32_t BasicBlock::MergeBlockId() const { uint32_t mbid = MergeBlockIdIfAny(); assert(mbid && "Expected block to have a corresponding merge block"); return mbid; } uint32_t BasicBlock::ContinueBlockIdIfAny() const { auto merge_ii = cend(); --merge_ii; uint32_t cbid = 0; if (merge_ii != cbegin()) { --merge_ii; if (merge_ii->opcode() == spv::Op::OpLoopMerge) { cbid = merge_ii->GetSingleWordInOperand(kLoopMergeContinueBlockIdInIdx); } } return cbid; } uint32_t BasicBlock::ContinueBlockId() const { uint32_t cbid = ContinueBlockIdIfAny(); assert(cbid && "Expected block to have a corresponding continue target"); return cbid; } std::ostream& operator<<(std::ostream& str, const BasicBlock& block) { str << block.PrettyPrint(); return str; } void BasicBlock::Dump() const { std::cerr << "Basic block #" << id() << "\n" << *this << "\n "; } std::string BasicBlock::PrettyPrint(uint32_t options) const { std::ostringstream str; ForEachInst([&str, options](const Instruction* inst) { str << inst->PrettyPrint(options); if (!spvOpcodeIsBlockTerminator(inst->opcode())) { str << std::endl; } }); return str.str(); } BasicBlock* BasicBlock::SplitBasicBlock(IRContext* context, uint32_t label_id, iterator iter) { assert(!insts_.empty()); std::unique_ptr new_block_temp = MakeUnique( MakeUnique(context, spv::Op::OpLabel, 0, label_id, std::initializer_list{})); BasicBlock* new_block = new_block_temp.get(); function_->InsertBasicBlockAfter(std::move(new_block_temp), this); new_block->insts_.Splice(new_block->end(), &insts_, iter, end()); assert(new_block->GetParent() == GetParent() && "The parent should already be set appropriately."); context->AnalyzeDefUse(new_block->GetLabelInst()); // Update the phi nodes in the successor blocks to reference the new block id. const_cast(new_block)->ForEachSuccessorLabel( [new_block, this, context](const uint32_t label) { BasicBlock* target_bb = context->get_instr_block(label); target_bb->ForEachPhiInst( [this, new_block, context](Instruction* phi_inst) { bool changed = false; for (uint32_t i = 1; i < phi_inst->NumInOperands(); i += 2) { if (phi_inst->GetSingleWordInOperand(i) == this->id()) { changed = true; phi_inst->SetInOperand(i, {new_block->id()}); } } if (changed) { context->UpdateDefUse(phi_inst); } }); }); if (context->AreAnalysesValid(IRContext::kAnalysisInstrToBlockMapping)) { context->set_instr_block(new_block->GetLabelInst(), new_block); new_block->ForEachInst([new_block, context](Instruction* inst) { context->set_instr_block(inst, new_block); }); } return new_block; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/basic_block.h000066400000000000000000000302211475742701700232350ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // This file defines the language constructs for representing a SPIR-V // module in memory. #ifndef SOURCE_OPT_BASIC_BLOCK_H_ #define SOURCE_OPT_BASIC_BLOCK_H_ #include #include #include #include #include #include #include #include "source/opt/instruction.h" #include "source/opt/instruction_list.h" #include "source/opt/iterator.h" namespace spvtools { namespace opt { class Function; class IRContext; // A SPIR-V basic block. class BasicBlock { public: using iterator = InstructionList::iterator; using const_iterator = InstructionList::const_iterator; using reverse_iterator = std::reverse_iterator; using const_reverse_iterator = std::reverse_iterator; // Creates a basic block with the given starting |label|. inline explicit BasicBlock(std::unique_ptr label); explicit BasicBlock(const BasicBlock& bb) = delete; // Creates a clone of the basic block in the given |context| // // The parent function will default to null and needs to be explicitly set by // the user. // // If the inst-to-block map in |context| is valid, then the new instructions // will be inserted into the map. BasicBlock* Clone(IRContext*) const; // Sets the enclosing function for this basic block. void SetParent(Function* function) { function_ = function; } // Return the enclosing function inline Function* GetParent() const { return function_; } // Appends an instruction to this basic block. inline void AddInstruction(std::unique_ptr i); // Appends all of block's instructions (except label) to this block inline void AddInstructions(BasicBlock* bp); // The pointer to the label starting this basic block. std::unique_ptr& GetLabel() { return label_; } // The label starting this basic block. Instruction* GetLabelInst() { return label_.get(); } const Instruction* GetLabelInst() const { return label_.get(); } // Returns the merge instruction in this basic block, if it exists. // Otherwise return null. May be used whenever tail() can be used. const Instruction* GetMergeInst() const; Instruction* GetMergeInst(); // Returns the OpLoopMerge instruction in this basic block, if it exists. // Otherwise return null. May be used whenever tail() can be used. const Instruction* GetLoopMergeInst() const; Instruction* GetLoopMergeInst(); // Returns the id of the label at the top of this block inline uint32_t id() const { return label_->result_id(); } iterator begin() { return insts_.begin(); } iterator end() { return insts_.end(); } const_iterator begin() const { return insts_.cbegin(); } const_iterator end() const { return insts_.cend(); } const_iterator cbegin() const { return insts_.cbegin(); } const_iterator cend() const { return insts_.cend(); } reverse_iterator rbegin() { return reverse_iterator(end()); } reverse_iterator rend() { return reverse_iterator(begin()); } const_reverse_iterator rbegin() const { return const_reverse_iterator(cend()); } const_reverse_iterator rend() const { return const_reverse_iterator(cbegin()); } const_reverse_iterator crbegin() const { return const_reverse_iterator(cend()); } const_reverse_iterator crend() const { return const_reverse_iterator(cbegin()); } // Returns an iterator pointing to the last instruction. This may only // be used if this block has an instruction other than the OpLabel // that defines it. iterator tail() { assert(!insts_.empty()); return --end(); } // Returns a const iterator, but othewrise similar to tail(). const_iterator ctail() const { assert(!insts_.empty()); return --insts_.cend(); } // Returns true if the basic block has at least one successor. inline bool hasSuccessor() const { return ctail()->IsBranch(); } // Runs the given function |f| on each instruction in this basic block, and // optionally on the debug line instructions that might precede them. inline void ForEachInst(const std::function& f, bool run_on_debug_line_insts = false); inline void ForEachInst(const std::function& f, bool run_on_debug_line_insts = false) const; // Runs the given function |f| on each instruction in this basic block, and // optionally on the debug line instructions that might precede them. If |f| // returns false, iteration is terminated and this function returns false. inline bool WhileEachInst(const std::function& f, bool run_on_debug_line_insts = false); inline bool WhileEachInst(const std::function& f, bool run_on_debug_line_insts = false) const; // Runs the given function |f| on each Phi instruction in this basic block, // and optionally on the debug line instructions that might precede them. inline void ForEachPhiInst(const std::function& f, bool run_on_debug_line_insts = false); // Runs the given function |f| on each Phi instruction in this basic block, // and optionally on the debug line instructions that might precede them. If // |f| returns false, iteration is terminated and this function return false. inline bool WhileEachPhiInst(const std::function& f, bool run_on_debug_line_insts = false); // Runs the given function |f| on each label id of each successor block void ForEachSuccessorLabel( const std::function& f) const; // Runs the given function |f| on each label id of each successor block. If // |f| returns false, iteration is terminated and this function returns false. bool WhileEachSuccessorLabel( const std::function& f) const; // Runs the given function |f| on each label id of each successor block. // Modifying the pointed value will change the branch taken by the basic // block. It is the caller responsibility to update or invalidate the CFG. void ForEachSuccessorLabel(const std::function& f); // Returns true if |block| is a direct successor of |this|. bool IsSuccessor(const BasicBlock* block) const; // Runs the given function |f| on the merge and continue label, if any void ForMergeAndContinueLabel(const std::function& f); // Returns true if this basic block has any Phi instructions. bool HasPhiInstructions() { return !WhileEachPhiInst([](Instruction*) { return false; }); } // Return true if this block is a loop header block. bool IsLoopHeader() const { return GetLoopMergeInst() != nullptr; } // Returns the ID of the merge block declared by a merge instruction in this // block, if any. If none, returns zero. uint32_t MergeBlockIdIfAny() const; // Returns MergeBlockIdIfAny() and asserts that it is non-zero. uint32_t MergeBlockId() const; // Returns the ID of the continue block declared by a merge instruction in // this block, if any. If none, returns zero. uint32_t ContinueBlockIdIfAny() const; // Returns ContinueBlockIdIfAny() and asserts that it is non-zero. uint32_t ContinueBlockId() const; // Returns the terminator instruction. Assumes the terminator exists. Instruction* terminator() { return &*tail(); } const Instruction* terminator() const { return &*ctail(); } // Returns true if this basic block exits this function and returns to its // caller. bool IsReturn() const { return ctail()->IsReturn(); } // Returns true if this basic block exits this function or aborts execution. bool IsReturnOrAbort() const { return ctail()->IsReturnOrAbort(); } // Kill all instructions in this block. Whether or not to kill the label is // indicated by |killLabel|. void KillAllInsts(bool killLabel); // Splits this basic block into two. Returns a new basic block with label // |label_id| containing the instructions from |iter| onwards. Instructions // prior to |iter| remain in this basic block. The new block will be added // to the function immediately after the original block. BasicBlock* SplitBasicBlock(IRContext* context, uint32_t label_id, iterator iter); // Pretty-prints this basic block into a std::string by printing every // instruction in it. // // |options| are the disassembly options. SPV_BINARY_TO_TEXT_OPTION_NO_HEADER // is always added to |options|. std::string PrettyPrint(uint32_t options = 0u) const; // Dump this basic block on stderr. Useful when running interactive // debuggers. void Dump() const; private: // The enclosing function. Function* function_; // The label starting this basic block. std::unique_ptr label_; // Instructions inside this basic block, but not the OpLabel. InstructionList insts_; }; // Pretty-prints |block| to |str|. Returns |str|. std::ostream& operator<<(std::ostream& str, const BasicBlock& block); inline BasicBlock::BasicBlock(std::unique_ptr label) : function_(nullptr), label_(std::move(label)) {} inline void BasicBlock::AddInstruction(std::unique_ptr i) { insts_.push_back(std::move(i)); } inline void BasicBlock::AddInstructions(BasicBlock* bp) { auto bEnd = end(); (void)bEnd.MoveBefore(&bp->insts_); } inline bool BasicBlock::WhileEachInst( const std::function& f, bool run_on_debug_line_insts) { if (label_) { if (!label_->WhileEachInst(f, run_on_debug_line_insts)) return false; } if (insts_.empty()) { return true; } Instruction* inst = &insts_.front(); while (inst != nullptr) { Instruction* next_instruction = inst->NextNode(); if (!inst->WhileEachInst(f, run_on_debug_line_insts)) return false; inst = next_instruction; } return true; } inline bool BasicBlock::WhileEachInst( const std::function& f, bool run_on_debug_line_insts) const { if (label_) { if (!static_cast(label_.get()) ->WhileEachInst(f, run_on_debug_line_insts)) return false; } for (const auto& inst : insts_) { if (!static_cast(&inst)->WhileEachInst( f, run_on_debug_line_insts)) return false; } return true; } inline void BasicBlock::ForEachInst(const std::function& f, bool run_on_debug_line_insts) { WhileEachInst( [&f](Instruction* inst) { f(inst); return true; }, run_on_debug_line_insts); } inline void BasicBlock::ForEachInst( const std::function& f, bool run_on_debug_line_insts) const { WhileEachInst( [&f](const Instruction* inst) { f(inst); return true; }, run_on_debug_line_insts); } inline bool BasicBlock::WhileEachPhiInst( const std::function& f, bool run_on_debug_line_insts) { if (insts_.empty()) { return true; } Instruction* inst = &insts_.front(); while (inst != nullptr) { Instruction* next_instruction = inst->NextNode(); if (inst->opcode() != spv::Op::OpPhi) break; if (!inst->WhileEachInst(f, run_on_debug_line_insts)) return false; inst = next_instruction; } return true; } inline void BasicBlock::ForEachPhiInst( const std::function& f, bool run_on_debug_line_insts) { WhileEachPhiInst( [&f](Instruction* inst) { f(inst); return true; }, run_on_debug_line_insts); } } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_BASIC_BLOCK_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/block_merge_pass.cpp000066400000000000000000000032211475742701700246340ustar00rootroot00000000000000// Copyright (c) 2017 The Khronos Group Inc. // Copyright (c) 2017 Valve Corporation // Copyright (c) 2017 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/block_merge_pass.h" #include "source/opt/block_merge_util.h" #include "source/opt/ir_context.h" namespace spvtools { namespace opt { bool BlockMergePass::MergeBlocks(Function* func) { bool modified = false; for (auto bi = func->begin(); bi != func->end();) { // Don't bother trying to merge unreachable blocks. if (context()->IsReachable(*bi) && blockmergeutil::CanMergeWithSuccessor(context(), &*bi)) { blockmergeutil::MergeWithSuccessor(context(), func, bi); // Reprocess block. modified = true; } else { ++bi; } } return modified; } Pass::Status BlockMergePass::Process() { // Process all entry point functions. ProcessFunction pfn = [this](Function* fp) { return MergeBlocks(fp); }; bool modified = context()->ProcessReachableCallTree(pfn); return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } BlockMergePass::BlockMergePass() = default; } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/block_merge_pass.h000066400000000000000000000035721475742701700243120ustar00rootroot00000000000000// Copyright (c) 2017 The Khronos Group Inc. // Copyright (c) 2017 Valve Corporation // Copyright (c) 2017 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_BLOCK_MERGE_PASS_H_ #define SOURCE_OPT_BLOCK_MERGE_PASS_H_ #include #include #include #include #include #include #include "source/opt/basic_block.h" #include "source/opt/def_use_manager.h" #include "source/opt/ir_context.h" #include "source/opt/module.h" #include "source/opt/pass.h" namespace spvtools { namespace opt { // See optimizer.hpp for documentation. class BlockMergePass : public Pass { public: BlockMergePass(); const char* name() const override { return "merge-blocks"; } Status Process() override; IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisDecorations | IRContext::kAnalysisCombinators | IRContext::kAnalysisNameMap | IRContext::kAnalysisConstants | IRContext::kAnalysisTypes; } private: // Search |func| for blocks which have a single Branch to a block // with no other predecessors. Merge these blocks into a single block. bool MergeBlocks(Function* func); }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_BLOCK_MERGE_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/block_merge_util.cpp000066400000000000000000000205701475742701700246510ustar00rootroot00000000000000// Copyright (c) 2017 The Khronos Group Inc. // Copyright (c) 2017 Valve Corporation // Copyright (c) 2017 LunarG Inc. // Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "block_merge_util.h" namespace spvtools { namespace opt { namespace blockmergeutil { namespace { // Returns true if |block| contains a merge instruction. bool IsHeader(BasicBlock* block) { return block->GetMergeInst() != nullptr; } // Returns true if |id| contains a merge instruction. bool IsHeader(IRContext* context, uint32_t id) { return IsHeader( context->get_instr_block(context->get_def_use_mgr()->GetDef(id))); } // Returns true if |id| is the merge target of a merge instruction. bool IsMerge(IRContext* context, uint32_t id) { return !context->get_def_use_mgr()->WhileEachUse( id, [](Instruction* user, uint32_t index) { spv::Op op = user->opcode(); if ((op == spv::Op::OpLoopMerge || op == spv::Op::OpSelectionMerge) && index == 0u) { return false; } return true; }); } // Returns true if |block| is the merge target of a merge instruction. bool IsMerge(IRContext* context, BasicBlock* block) { return IsMerge(context, block->id()); } // Returns true if |id| is the continue target of a merge instruction. bool IsContinue(IRContext* context, uint32_t id) { return !context->get_def_use_mgr()->WhileEachUse( id, [](Instruction* user, uint32_t index) { spv::Op op = user->opcode(); if (op == spv::Op::OpLoopMerge && index == 1u) { return false; } return true; }); } // Removes any OpPhi instructions in |block|, which should have exactly one // predecessor, replacing uses of OpPhi ids with the ids associated with the // predecessor. void EliminateOpPhiInstructions(IRContext* context, BasicBlock* block) { block->ForEachPhiInst([context](Instruction* phi) { assert(2 == phi->NumInOperands() && "A block can only have one predecessor for block merging to make " "sense."); context->ReplaceAllUsesWith(phi->result_id(), phi->GetSingleWordInOperand(0)); context->KillInst(phi); }); } } // Anonymous namespace bool CanMergeWithSuccessor(IRContext* context, BasicBlock* block) { // Find block with single successor which has no other predecessors. auto ii = block->end(); --ii; Instruction* br = &*ii; if (br->opcode() != spv::Op::OpBranch) { return false; } const uint32_t lab_id = br->GetSingleWordInOperand(0); if (context->cfg()->preds(lab_id).size() != 1) { return false; } bool pred_is_merge = IsMerge(context, block); bool succ_is_merge = IsMerge(context, lab_id); if (pred_is_merge && succ_is_merge) { // Cannot merge two merges together. return false; } // Note: This means that the instructions in a break block will execute as if // they were still diverged according to the loop iteration. This restricts // potential transformations an implementation may perform on the IR to match // shader author expectations. Similarly, instructions in the loop construct // cannot be moved into the continue construct unless it can be proven that // invocations are always converged. if (succ_is_merge && context->get_feature_mgr()->HasExtension( kSPV_KHR_maximal_reconvergence)) { return false; } if (pred_is_merge && IsContinue(context, lab_id)) { // Cannot merge a continue target with a merge block. return false; } Instruction* merge_inst = block->GetMergeInst(); const bool pred_is_header = IsHeader(block); if (pred_is_header && lab_id != merge_inst->GetSingleWordInOperand(0u)) { bool succ_is_header = IsHeader(context, lab_id); if (pred_is_header && succ_is_header) { // Cannot merge two headers together when the successor is not the merge // block of the predecessor. return false; } // If this is a header block and the successor is not its merge, we must // be careful about which blocks we are willing to merge together. // OpLoopMerge must be followed by a conditional or unconditional branch. // The merge must be a loop merge because a selection merge cannot be // followed by an unconditional branch. BasicBlock* succ_block = context->get_instr_block(lab_id); spv::Op succ_term_op = succ_block->terminator()->opcode(); assert(merge_inst->opcode() == spv::Op::OpLoopMerge); if (succ_term_op != spv::Op::OpBranch && succ_term_op != spv::Op::OpBranchConditional) { return false; } } if (succ_is_merge || IsContinue(context, lab_id)) { auto* struct_cfg = context->GetStructuredCFGAnalysis(); auto switch_block_id = struct_cfg->ContainingSwitch(block->id()); if (switch_block_id) { auto switch_merge_id = struct_cfg->SwitchMergeBlock(switch_block_id); const auto* switch_inst = &*block->GetParent()->FindBlock(switch_block_id)->tail(); for (uint32_t i = 1; i < switch_inst->NumInOperands(); i += 2) { auto target_id = switch_inst->GetSingleWordInOperand(i); if (target_id == block->id() && target_id != switch_merge_id) { // Case constructs must be structurally dominated by the OpSwitch. // Since the successor is the merge/continue for another construct, // merging the blocks would break that requirement. return false; } } } } return true; } void MergeWithSuccessor(IRContext* context, Function* func, Function::iterator bi) { assert(CanMergeWithSuccessor(context, &*bi) && "Precondition failure for MergeWithSuccessor: it must be legal to " "merge the block and its successor."); auto ii = bi->end(); --ii; Instruction* br = &*ii; const uint32_t lab_id = br->GetSingleWordInOperand(0); Instruction* merge_inst = bi->GetMergeInst(); bool pred_is_header = IsHeader(&*bi); // Merge blocks. context->KillInst(br); auto sbi = bi; for (; sbi != func->end(); ++sbi) if (sbi->id() == lab_id) break; // If bi is sbi's only predecessor, it dominates sbi and thus // sbi must follow bi in func's ordering. assert(sbi != func->end()); if (sbi->tail()->opcode() == spv::Op::OpSwitch && sbi->MergeBlockIdIfAny() != 0) { context->InvalidateAnalyses(IRContext::Analysis::kAnalysisStructuredCFG); } // Update the inst-to-block mapping for the instructions in sbi. for (auto& inst : *sbi) { context->set_instr_block(&inst, &*bi); } EliminateOpPhiInstructions(context, &*sbi); // Now actually move the instructions. bi->AddInstructions(&*sbi); if (merge_inst) { if (pred_is_header && lab_id == merge_inst->GetSingleWordInOperand(0u)) { // Merging the header and merge blocks, so remove the structured control // flow declaration. context->KillInst(merge_inst); } else { // Move OpLine/OpNoLine information to merge_inst. This solves // the validation error that OpLine is placed between OpLoopMerge // and OpBranchConditional. auto terminator = bi->terminator(); auto& vec = terminator->dbg_line_insts(); if (vec.size() > 0) { merge_inst->ClearDbgLineInsts(); auto& new_vec = merge_inst->dbg_line_insts(); new_vec.insert(new_vec.end(), vec.begin(), vec.end()); terminator->ClearDbgLineInsts(); for (auto& l_inst : new_vec) context->get_def_use_mgr()->AnalyzeInstDefUse(&l_inst); } // Clear debug scope of terminator to avoid DebugScope // emitted between terminator and merge. terminator->SetDebugScope(DebugScope(kNoDebugScope, kNoInlinedAt)); // Move the merge instruction to just before the terminator. merge_inst->InsertBefore(terminator); } } context->ReplaceAllUsesWith(lab_id, bi->id()); context->KillInst(sbi->GetLabelInst()); (void)sbi.Erase(); } } // namespace blockmergeutil } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/block_merge_util.h000066400000000000000000000031161475742701700243130ustar00rootroot00000000000000// Copyright (c) 2017 The Khronos Group Inc. // Copyright (c) 2017 Valve Corporation // Copyright (c) 2017 LunarG Inc. // Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_BLOCK_MERGE_UTIL_H_ #define SOURCE_OPT_BLOCK_MERGE_UTIL_H_ #include "source/opt/ir_context.h" namespace spvtools { namespace opt { // Provides functions for determining when it is safe to merge blocks, and for // actually merging blocks, for use by various analyses and passes. namespace blockmergeutil { // Returns true if and only if |block| has exactly one successor and merging // this successor into |block| has no impact on the semantics or validity of the // SPIR-V module. bool CanMergeWithSuccessor(IRContext* context, BasicBlock* block); // Requires that |bi| has a successor that can be safely merged into |bi|, and // performs the merge. void MergeWithSuccessor(IRContext* context, Function* func, Function::iterator bi); } // namespace blockmergeutil } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_BLOCK_MERGE_UTIL_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/build_module.cpp000066400000000000000000000064061475742701700240110ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/build_module.h" #include #include #include "source/opt/ir_context.h" #include "source/opt/ir_loader.h" #include "source/table.h" #include "source/util/make_unique.h" namespace spvtools { namespace { // Sets the module header for IrLoader. Meets the interface requirement of // spvBinaryParse(). spv_result_t SetSpvHeader(void* builder, spv_endianness_t, uint32_t magic, uint32_t version, uint32_t generator, uint32_t id_bound, uint32_t reserved) { reinterpret_cast(builder)->SetModuleHeader( magic, version, generator, id_bound, reserved); return SPV_SUCCESS; } // Processes a parsed instruction for IrLoader. Meets the interface requirement // of spvBinaryParse(). spv_result_t SetSpvInst(void* builder, const spv_parsed_instruction_t* inst) { if (reinterpret_cast(builder)->AddInstruction(inst)) { return SPV_SUCCESS; } return SPV_ERROR_INVALID_BINARY; } } // namespace std::unique_ptr BuildModule(spv_target_env env, MessageConsumer consumer, const uint32_t* binary, const size_t size) { return BuildModule(env, consumer, binary, size, true); } std::unique_ptr BuildModule(spv_target_env env, MessageConsumer consumer, const uint32_t* binary, const size_t size, bool extra_line_tracking) { auto context = spvContextCreate(env); SetContextMessageConsumer(context, consumer); auto irContext = MakeUnique(env, consumer); opt::IrLoader loader(consumer, irContext->module()); loader.SetExtraLineTracking(extra_line_tracking); spv_result_t status = spvBinaryParse(context, &loader, binary, size, SetSpvHeader, SetSpvInst, nullptr); loader.EndModule(); spvContextDestroy(context); return status == SPV_SUCCESS ? std::move(irContext) : nullptr; } std::unique_ptr BuildModule(spv_target_env env, MessageConsumer consumer, const std::string& text, uint32_t assemble_options) { SpirvTools t(env); t.SetMessageConsumer(consumer); std::vector binary; if (!t.Assemble(text, &binary, assemble_options)) return nullptr; return BuildModule(env, consumer, binary.data(), binary.size()); } } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/build_module.h000066400000000000000000000044441475742701700234560ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_BUILD_MODULE_H_ #define SOURCE_OPT_BUILD_MODULE_H_ #include #include #include "source/opt/ir_context.h" #include "source/opt/module.h" #include "spirv-tools/libspirv.hpp" namespace spvtools { // Builds a Module and returns the owning IRContext from the given SPIR-V // |binary|. |size| specifies number of words in |binary|. The |binary| will be // decoded according to the given target |env|. Returns nullptr if errors occur // and sends the errors to |consumer|. When |extra_line_tracking| is true, // extra OpLine instructions are injected to better presere line numbers while // later transforms mutate the module. std::unique_ptr BuildModule(spv_target_env env, MessageConsumer consumer, const uint32_t* binary, size_t size, bool extra_line_tracking); // Like above, with extra line tracking turned on. std::unique_ptr BuildModule(spv_target_env env, MessageConsumer consumer, const uint32_t* binary, size_t size); // Builds a Module and returns the owning IRContext from the given // SPIR-V assembly |text|. The |text| will be encoded according to the given // target |env|. Returns nullptr if errors occur and sends the errors to // |consumer|. std::unique_ptr BuildModule( spv_target_env env, MessageConsumer consumer, const std::string& text, uint32_t assemble_options = SpirvTools::kDefaultAssembleOption); } // namespace spvtools #endif // SOURCE_OPT_BUILD_MODULE_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/ccp_pass.cpp000066400000000000000000000335161475742701700231420ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // This file implements conditional constant propagation as described in // // Constant propagation with conditional branches, // Wegman and Zadeck, ACM TOPLAS 13(2):181-210. #include "source/opt/ccp_pass.h" #include #include #include "source/opt/fold.h" #include "source/opt/function.h" #include "source/opt/propagator.h" namespace spvtools { namespace opt { namespace { // This SSA id is never defined nor referenced in the IR. It is a special ID // which represents varying values. When an ID is found to have a varying // value, its entry in the |values_| table maps to kVaryingSSAId. constexpr uint32_t kVaryingSSAId = std::numeric_limits::max(); } // namespace bool CCPPass::IsVaryingValue(uint32_t id) const { return id == kVaryingSSAId; } SSAPropagator::PropStatus CCPPass::MarkInstructionVarying(Instruction* instr) { assert(instr->result_id() != 0 && "Instructions with no result cannot be marked varying."); values_[instr->result_id()] = kVaryingSSAId; return SSAPropagator::kVarying; } SSAPropagator::PropStatus CCPPass::VisitPhi(Instruction* phi) { uint32_t meet_val_id = 0; // Implement the lattice meet operation. The result of this Phi instruction is // interesting only if the meet operation over arguments coming through // executable edges yields the same constant value. for (uint32_t i = 2; i < phi->NumOperands(); i += 2) { if (!propagator_->IsPhiArgExecutable(phi, i)) { // Ignore arguments coming through non-executable edges. continue; } uint32_t phi_arg_id = phi->GetSingleWordOperand(i); auto it = values_.find(phi_arg_id); if (it != values_.end()) { // We found an argument with a constant value. Apply the meet operation // with the previous arguments. if (it->second == kVaryingSSAId) { // The "constant" value is actually a placeholder for varying. Return // varying for this phi. return MarkInstructionVarying(phi); } else if (meet_val_id == 0) { // This is the first argument we find. Initialize the result to its // constant value id. meet_val_id = it->second; } else if (it->second == meet_val_id) { // The argument is the same constant value already computed. Continue // looking. continue; } else { // We either found a varying value, or another constant value different // from the previous computed meet value. This Phi will never be // constant. return MarkInstructionVarying(phi); } } else { // The incoming value has no recorded value and is therefore not // interesting. A not interesting value joined with any other value is the // other value. continue; } } // If there are no incoming executable edges, the meet ID will still be 0. In // that case, return not interesting to evaluate the Phi node again. if (meet_val_id == 0) { return SSAPropagator::kNotInteresting; } // All the operands have the same constant value represented by |meet_val_id|. // Set the Phi's result to that value and declare it interesting. values_[phi->result_id()] = meet_val_id; return SSAPropagator::kInteresting; } uint32_t CCPPass::ComputeLatticeMeet(Instruction* instr, uint32_t val2) { // Given two values val1 and val2, the meet operation in the constant // lattice uses the following rules: // // meet(val1, UNDEFINED) = val1 // meet(val1, VARYING) = VARYING // meet(val1, val2) = val1 if val1 == val2 // meet(val1, val2) = VARYING if val1 != val2 // // When two different values meet, the result is always varying because CCP // does not allow lateral transitions in the lattice. This prevents // infinite cycles during propagation. auto val1_it = values_.find(instr->result_id()); if (val1_it == values_.end()) { return val2; } uint32_t val1 = val1_it->second; if (IsVaryingValue(val1)) { return val1; } else if (IsVaryingValue(val2)) { return val2; } else if (val1 != val2) { return kVaryingSSAId; } return val2; } SSAPropagator::PropStatus CCPPass::VisitAssignment(Instruction* instr) { assert(instr->result_id() != 0 && "Expecting an instruction that produces a result"); // If this is a copy operation, and the RHS is a known constant, assign its // value to the LHS. if (instr->opcode() == spv::Op::OpCopyObject) { uint32_t rhs_id = instr->GetSingleWordInOperand(0); auto it = values_.find(rhs_id); if (it != values_.end()) { if (IsVaryingValue(it->second)) { return MarkInstructionVarying(instr); } else { uint32_t new_val = ComputeLatticeMeet(instr, it->second); values_[instr->result_id()] = new_val; return IsVaryingValue(new_val) ? SSAPropagator::kVarying : SSAPropagator::kInteresting; } } return SSAPropagator::kNotInteresting; } // Instructions with a RHS that cannot produce a constant are always varying. if (!instr->IsFoldable()) { return MarkInstructionVarying(instr); } // See if the RHS of the assignment folds into a constant value. auto map_func = [this](uint32_t id) { auto it = values_.find(id); if (it == values_.end() || IsVaryingValue(it->second)) { return id; } return it->second; }; Instruction* folded_inst = context()->get_instruction_folder().FoldInstructionToConstant(instr, map_func); if (folded_inst != nullptr) { // We do not want to change the body of the function by adding new // instructions. When folding we can only generate new constants. assert((folded_inst->IsConstant() || IsSpecConstantInst(folded_inst->opcode())) && "CCP is only interested in constant values."); uint32_t new_val = ComputeLatticeMeet(instr, folded_inst->result_id()); values_[instr->result_id()] = new_val; return IsVaryingValue(new_val) ? SSAPropagator::kVarying : SSAPropagator::kInteresting; } // Conservatively mark this instruction as varying if any input id is varying. if (!instr->WhileEachInId([this](uint32_t* op_id) { auto iter = values_.find(*op_id); if (iter != values_.end() && IsVaryingValue(iter->second)) return false; return true; })) { return MarkInstructionVarying(instr); } // If not, see if there is a least one unknown operand to the instruction. If // so, we might be able to fold it later. if (!instr->WhileEachInId([this](uint32_t* op_id) { auto it = values_.find(*op_id); if (it == values_.end()) return false; return true; })) { return SSAPropagator::kNotInteresting; } // Otherwise, we will never be able to fold this instruction, so mark it // varying. return MarkInstructionVarying(instr); } SSAPropagator::PropStatus CCPPass::VisitBranch(Instruction* instr, BasicBlock** dest_bb) const { assert(instr->IsBranch() && "Expected a branch instruction."); *dest_bb = nullptr; uint32_t dest_label = 0; if (instr->opcode() == spv::Op::OpBranch) { // An unconditional jump always goes to its unique destination. dest_label = instr->GetSingleWordInOperand(0); } else if (instr->opcode() == spv::Op::OpBranchConditional) { // For a conditional branch, determine whether the predicate selector has a // known value in |values_|. If it does, set the destination block // according to the selector's boolean value. uint32_t pred_id = instr->GetSingleWordOperand(0); auto it = values_.find(pred_id); if (it == values_.end() || IsVaryingValue(it->second)) { // The predicate has an unknown value, either branch could be taken. return SSAPropagator::kVarying; } // Get the constant value for the predicate selector from the value table. // Use it to decide which branch will be taken. uint32_t pred_val_id = it->second; const analysis::Constant* c = const_mgr_->FindDeclaredConstant(pred_val_id); assert(c && "Expected to find a constant declaration for a known value."); // Undef values should have returned as varying above. assert(c->AsBoolConstant() || c->AsNullConstant()); if (c->AsNullConstant()) { dest_label = instr->GetSingleWordOperand(2u); } else { const analysis::BoolConstant* val = c->AsBoolConstant(); dest_label = val->value() ? instr->GetSingleWordOperand(1) : instr->GetSingleWordOperand(2); } } else { // For an OpSwitch, extract the value taken by the switch selector and check // which of the target literals it matches. The branch associated with that // literal is the taken branch. assert(instr->opcode() == spv::Op::OpSwitch); if (instr->GetOperand(0).words.size() != 1) { // If the selector is wider than 32-bits, return varying. TODO(dnovillo): // Add support for wider constants. return SSAPropagator::kVarying; } uint32_t select_id = instr->GetSingleWordOperand(0); auto it = values_.find(select_id); if (it == values_.end() || IsVaryingValue(it->second)) { // The selector has an unknown value, any of the branches could be taken. return SSAPropagator::kVarying; } // Get the constant value for the selector from the value table. Use it to // decide which branch will be taken. uint32_t select_val_id = it->second; const analysis::Constant* c = const_mgr_->FindDeclaredConstant(select_val_id); assert(c && "Expected to find a constant declaration for a known value."); // TODO: support 64-bit integer switches. uint32_t constant_cond = 0; if (const analysis::IntConstant* val = c->AsIntConstant()) { constant_cond = val->words()[0]; } else { // Undef values should have returned varying above. assert(c->AsNullConstant()); constant_cond = 0; } // Start assuming that the selector will take the default value; dest_label = instr->GetSingleWordOperand(1); for (uint32_t i = 2; i < instr->NumOperands(); i += 2) { if (constant_cond == instr->GetSingleWordOperand(i)) { dest_label = instr->GetSingleWordOperand(i + 1); break; } } } assert(dest_label && "Destination label should be set at this point."); *dest_bb = context()->cfg()->block(dest_label); return SSAPropagator::kInteresting; } SSAPropagator::PropStatus CCPPass::VisitInstruction(Instruction* instr, BasicBlock** dest_bb) { *dest_bb = nullptr; if (instr->opcode() == spv::Op::OpPhi) { return VisitPhi(instr); } else if (instr->IsBranch()) { return VisitBranch(instr, dest_bb); } else if (instr->result_id()) { return VisitAssignment(instr); } return SSAPropagator::kVarying; } bool CCPPass::ReplaceValues() { // Even if we make no changes to the function's IR, propagation may have // created new constants. Even if those constants cannot be replaced in // the IR, the constant definition itself is a change. To reflect this, // we check whether the next ID to be given by the module is different than // the original bound ID. If that happens, new instructions were added to the // module during propagation. // // See https://github.com/KhronosGroup/SPIRV-Tools/issues/3636 and // https://github.com/KhronosGroup/SPIRV-Tools/issues/3991 for details. bool changed_ir = (context()->module()->IdBound() > original_id_bound_); for (const auto& it : values_) { uint32_t id = it.first; uint32_t cst_id = it.second; if (!IsVaryingValue(cst_id) && id != cst_id) { context()->KillNamesAndDecorates(id); changed_ir |= context()->ReplaceAllUsesWith(id, cst_id); } } return changed_ir; } bool CCPPass::PropagateConstants(Function* fp) { if (fp->IsDeclaration()) { return false; } // Mark function parameters as varying. fp->ForEachParam([this](const Instruction* inst) { values_[inst->result_id()] = kVaryingSSAId; }); const auto visit_fn = [this](Instruction* instr, BasicBlock** dest_bb) { return VisitInstruction(instr, dest_bb); }; propagator_ = std::unique_ptr(new SSAPropagator(context(), visit_fn)); if (propagator_->Run(fp)) { return ReplaceValues(); } return false; } void CCPPass::Initialize() { const_mgr_ = context()->get_constant_mgr(); // Populate the constant table with values from constant declarations in the // module. The values of each OpConstant declaration is the identity // assignment (i.e., each constant is its own value). for (const auto& inst : get_module()->types_values()) { // Record compile time constant ids. Treat all other global values as // varying. if (inst.IsConstant()) { values_[inst.result_id()] = inst.result_id(); } else { values_[inst.result_id()] = kVaryingSSAId; } } original_id_bound_ = context()->module()->IdBound(); } Pass::Status CCPPass::Process() { Initialize(); // Process all entry point functions. ProcessFunction pfn = [this](Function* fp) { return PropagateConstants(fp); }; bool modified = context()->ProcessReachableCallTree(pfn); return modified ? Pass::Status::SuccessWithChange : Pass::Status::SuccessWithoutChange; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/ccp_pass.h000066400000000000000000000123051475742701700226000ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_CCP_PASS_H_ #define SOURCE_OPT_CCP_PASS_H_ #include #include #include "source/opt/constants.h" #include "source/opt/function.h" #include "source/opt/ir_context.h" #include "source/opt/mem_pass.h" #include "source/opt/module.h" #include "source/opt/propagator.h" namespace spvtools { namespace opt { class CCPPass : public MemPass { public: CCPPass() = default; const char* name() const override { return "ccp"; } Status Process() override; IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisDecorations | IRContext::kAnalysisCombinators | IRContext::kAnalysisCFG | IRContext::kAnalysisDominatorAnalysis | IRContext::kAnalysisNameMap | IRContext::kAnalysisConstants | IRContext::kAnalysisTypes; } private: // Initializes the pass. void Initialize(); // Runs constant propagation on the given function |fp|. Returns true if any // constants were propagated and the IR modified. bool PropagateConstants(Function* fp); // Visits a single instruction |instr|. If the instruction is a conditional // branch that always jumps to the same basic block, it sets the destination // block in |dest_bb|. SSAPropagator::PropStatus VisitInstruction(Instruction* instr, BasicBlock** dest_bb); // Visits an OpPhi instruction |phi|. This applies the meet operator for the // CCP lattice. Essentially, if all the operands in |phi| have the same // constant value C, the result for |phi| gets assigned the value C. SSAPropagator::PropStatus VisitPhi(Instruction* phi); // Visits an SSA assignment instruction |instr|. If the RHS of |instr| folds // into a constant value C, then the LHS of |instr| is assigned the value C in // |values_|. SSAPropagator::PropStatus VisitAssignment(Instruction* instr); // Visits a branch instruction |instr|. If the branch is conditional // (OpBranchConditional or OpSwitch), and the value of its selector is known, // |dest_bb| will be set to the corresponding destination block. Unconditional // branches always set |dest_bb| to the single destination block. SSAPropagator::PropStatus VisitBranch(Instruction* instr, BasicBlock** dest_bb) const; // Replaces all operands used in |fp| with the corresponding constant values // in |values_|. Returns true if any operands were replaced, and false // otherwise. bool ReplaceValues(); // Marks |instr| as varying by registering a varying value for its result // into the |values_| table. Returns SSAPropagator::kVarying. SSAPropagator::PropStatus MarkInstructionVarying(Instruction* instr); // Returns true if |id| is the special SSA id that corresponds to a varying // value. bool IsVaryingValue(uint32_t id) const; // Constant manager for the parent IR context. Used to record new constants // generated during propagation. analysis::ConstantManager* const_mgr_; // Returns a new value for |instr| by computing the meet operation between // its existing value and |val2|. // // Given two values val1 and val2, the meet operation in the constant // lattice uses the following rules: // // meet(val1, UNDEFINED) = val1 // meet(val1, VARYING) = VARYING // meet(val1, val2) = val1 if val1 == val2 // meet(val1, val2) = VARYING if val1 != val2 // // When two different values meet, the result is always varying because CCP // does not allow lateral transitions in the lattice. This prevents // infinite cycles during propagation. uint32_t ComputeLatticeMeet(Instruction* instr, uint32_t val2); // Constant value table. Each entry in this map // represents the compile-time constant value for |id| as declared by // |const_decl_id|. Each |const_decl_id| in this table is an OpConstant // declaration for the current module. // // Additionally, this table keeps track of SSA IDs with varying values. If an // SSA ID is found to have a varying value, it will have an entry in this // table that maps to the special SSA id kVaryingSSAId. These values are // never replaced in the IR, they are used by CCP during propagation. std::unordered_map values_; // Propagator engine used. std::unique_ptr propagator_; // Value for the module's ID bound before running CCP. Used to detect whether // propagation created new instructions. uint32_t original_id_bound_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_CCP_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/cfg.cpp000066400000000000000000000274021475742701700221030ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/cfg.h" #include #include #include "source/cfa.h" #include "source/opt/ir_builder.h" #include "source/opt/ir_context.h" #include "source/opt/module.h" namespace spvtools { namespace opt { namespace { using cbb_ptr = const opt::BasicBlock*; // Universal Limit of ResultID + 1 constexpr int kMaxResultId = 0x400000; } // namespace CFG::CFG(Module* module) : module_(module), pseudo_entry_block_(std::unique_ptr( new Instruction(module->context(), spv::Op::OpLabel, 0, 0, {}))), pseudo_exit_block_(std::unique_ptr(new Instruction( module->context(), spv::Op::OpLabel, 0, kMaxResultId, {}))) { for (auto& fn : *module) { for (auto& blk : fn) { RegisterBlock(&blk); } } } void CFG::AddEdges(BasicBlock* blk) { uint32_t blk_id = blk->id(); // Force the creation of an entry, not all basic block have predecessors // (such as the entry blocks and some unreachables). label2preds_[blk_id]; const auto* const_blk = blk; const_blk->ForEachSuccessorLabel( [blk_id, this](const uint32_t succ_id) { AddEdge(blk_id, succ_id); }); } void CFG::RemoveNonExistingEdges(uint32_t blk_id) { std::vector updated_pred_list; for (uint32_t id : preds(blk_id)) { const BasicBlock* pred_blk = block(id); bool has_branch = false; pred_blk->ForEachSuccessorLabel([&has_branch, blk_id](uint32_t succ) { if (succ == blk_id) { has_branch = true; } }); if (has_branch) updated_pred_list.push_back(id); } label2preds_.at(blk_id) = std::move(updated_pred_list); } void CFG::ComputeStructuredOrder(Function* func, BasicBlock* root, std::list* order) { ComputeStructuredOrder(func, root, nullptr, order); } void CFG::ComputeStructuredOrder(Function* func, BasicBlock* root, BasicBlock* end, std::list* order) { assert(module_->context()->get_feature_mgr()->HasCapability( spv::Capability::Shader) && "This only works on structured control flow"); // Compute structured successors and do DFS. ComputeStructuredSuccessors(func); auto ignore_block = [](cbb_ptr) {}; auto terminal = [end](cbb_ptr bb) { return bb == end; }; auto get_structured_successors = [this](const BasicBlock* b) { return &(block2structured_succs_[b]); }; // TODO(greg-lunarg): Get rid of const_cast by making moving const // out of the cfa.h prototypes and into the invoking code. auto post_order = [&](cbb_ptr b) { order->push_front(const_cast(b)); }; CFA::DepthFirstTraversal(root, get_structured_successors, ignore_block, post_order, terminal); } void CFG::ForEachBlockInPostOrder(BasicBlock* bb, const std::function& f) { std::vector po; std::unordered_set seen; ComputePostOrderTraversal(bb, &po, &seen); for (BasicBlock* current_bb : po) { if (!IsPseudoExitBlock(current_bb) && !IsPseudoEntryBlock(current_bb)) { f(current_bb); } } } void CFG::ForEachBlockInReversePostOrder( BasicBlock* bb, const std::function& f) { WhileEachBlockInReversePostOrder(bb, [f](BasicBlock* b) { f(b); return true; }); } bool CFG::WhileEachBlockInReversePostOrder( BasicBlock* bb, const std::function& f) { std::vector po; std::unordered_set seen; ComputePostOrderTraversal(bb, &po, &seen); for (auto current_bb = po.rbegin(); current_bb != po.rend(); ++current_bb) { if (!IsPseudoExitBlock(*current_bb) && !IsPseudoEntryBlock(*current_bb)) { if (!f(*current_bb)) { return false; } } } return true; } void CFG::ComputeStructuredSuccessors(Function* func) { block2structured_succs_.clear(); for (auto& blk : *func) { // If no predecessors in function, make successor to pseudo entry. if (label2preds_[blk.id()].size() == 0) block2structured_succs_[&pseudo_entry_block_].push_back(&blk); // If header, make merge block first successor and continue block second // successor if there is one. uint32_t mbid = blk.MergeBlockIdIfAny(); if (mbid != 0) { block2structured_succs_[&blk].push_back(block(mbid)); uint32_t cbid = blk.ContinueBlockIdIfAny(); if (cbid != 0) { block2structured_succs_[&blk].push_back(block(cbid)); } } // Add true successors. const auto& const_blk = blk; const_blk.ForEachSuccessorLabel([&blk, this](const uint32_t sbid) { block2structured_succs_[&blk].push_back(block(sbid)); }); } } void CFG::ComputePostOrderTraversal(BasicBlock* bb, std::vector* order, std::unordered_set* seen) { std::vector stack; stack.push_back(bb); while (!stack.empty()) { bb = stack.back(); seen->insert(bb); static_cast(bb)->WhileEachSuccessorLabel( [&seen, &stack, this](const uint32_t sbid) { BasicBlock* succ_bb = id2block_[sbid]; if (!seen->count(succ_bb)) { stack.push_back(succ_bb); return false; } return true; }); if (stack.back() == bb) { order->push_back(bb); stack.pop_back(); } } } BasicBlock* CFG::SplitLoopHeader(BasicBlock* bb) { assert(bb->GetLoopMergeInst() && "Expecting bb to be the header of a loop."); Function* fn = bb->GetParent(); IRContext* context = module_->context(); // Get the new header id up front. If we are out of ids, then we cannot split // the loop. uint32_t new_header_id = context->TakeNextId(); if (new_header_id == 0) { return nullptr; } // Find the insertion point for the new bb. Function::iterator header_it = std::find_if( fn->begin(), fn->end(), [bb](BasicBlock& block_in_func) { return &block_in_func == bb; }); assert(header_it != fn->end()); const std::vector& pred = preds(bb->id()); // Find the back edge BasicBlock* latch_block = nullptr; Function::iterator latch_block_iter = header_it; for (; latch_block_iter != fn->end(); ++latch_block_iter) { // If blocks are in the proper order, then the only branch that appears // after the header is the latch. if (std::find(pred.begin(), pred.end(), latch_block_iter->id()) != pred.end()) { break; } } assert(latch_block_iter != fn->end() && "Could not find the latch."); latch_block = &*latch_block_iter; RemoveSuccessorEdges(bb); // Create the new header bb basic bb. // Leave the phi instructions behind. auto iter = bb->begin(); while (iter->opcode() == spv::Op::OpPhi) { ++iter; } BasicBlock* new_header = bb->SplitBasicBlock(context, new_header_id, iter); context->AnalyzeDefUse(new_header->GetLabelInst()); // Update cfg RegisterBlock(new_header); // Update bb mappings. context->set_instr_block(new_header->GetLabelInst(), new_header); new_header->ForEachInst([new_header, context](Instruction* inst) { context->set_instr_block(inst, new_header); }); // If |bb| was the latch block, the branch back to the header is not in // |new_header|. if (latch_block == bb) { if (new_header->ContinueBlockId() == bb->id()) { new_header->GetLoopMergeInst()->SetInOperand(1, {new_header_id}); } latch_block = new_header; } // Adjust the OpPhi instructions as needed. bb->ForEachPhiInst([latch_block, bb, new_header, context](Instruction* phi) { std::vector preheader_phi_ops; std::vector header_phi_ops; // Identify where the original inputs to original OpPhi belong: header or // preheader. for (uint32_t i = 0; i < phi->NumInOperands(); i += 2) { uint32_t def_id = phi->GetSingleWordInOperand(i); uint32_t branch_id = phi->GetSingleWordInOperand(i + 1); if (branch_id == latch_block->id()) { header_phi_ops.push_back({SPV_OPERAND_TYPE_ID, {def_id}}); header_phi_ops.push_back({SPV_OPERAND_TYPE_ID, {branch_id}}); } else { preheader_phi_ops.push_back(def_id); preheader_phi_ops.push_back(branch_id); } } // Create a phi instruction if and only if the preheader_phi_ops has more // than one pair. if (preheader_phi_ops.size() > 2) { InstructionBuilder builder( context, &*bb->begin(), IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); Instruction* new_phi = builder.AddPhi(phi->type_id(), preheader_phi_ops); // Add the OpPhi to the header bb. header_phi_ops.push_back({SPV_OPERAND_TYPE_ID, {new_phi->result_id()}}); header_phi_ops.push_back({SPV_OPERAND_TYPE_ID, {bb->id()}}); } else { // An OpPhi with a single entry is just a copy. In this case use the same // instruction in the new header. header_phi_ops.push_back({SPV_OPERAND_TYPE_ID, {preheader_phi_ops[0]}}); header_phi_ops.push_back({SPV_OPERAND_TYPE_ID, {bb->id()}}); } phi->RemoveFromList(); std::unique_ptr phi_owner(phi); phi->SetInOperands(std::move(header_phi_ops)); new_header->begin()->InsertBefore(std::move(phi_owner)); context->set_instr_block(phi, new_header); context->AnalyzeUses(phi); }); // Add a branch to the new header. InstructionBuilder branch_builder( context, bb, IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); bb->AddInstruction( MakeUnique(context, spv::Op::OpBranch, 0, 0, std::initializer_list{ {SPV_OPERAND_TYPE_ID, {new_header->id()}}})); context->AnalyzeUses(bb->terminator()); context->set_instr_block(bb->terminator(), bb); label2preds_[new_header->id()].push_back(bb->id()); // Update the latch to branch to the new header. latch_block->ForEachSuccessorLabel([bb, new_header_id](uint32_t* id) { if (*id == bb->id()) { *id = new_header_id; } }); Instruction* latch_branch = latch_block->terminator(); context->AnalyzeUses(latch_branch); label2preds_[new_header->id()].push_back(latch_block->id()); auto& block_preds = label2preds_[bb->id()]; auto latch_pos = std::find(block_preds.begin(), block_preds.end(), latch_block->id()); assert(latch_pos != block_preds.end() && "The cfg was invalid."); block_preds.erase(latch_pos); // Update the loop descriptors if (context->AreAnalysesValid(IRContext::kAnalysisLoopAnalysis)) { LoopDescriptor* loop_desc = context->GetLoopDescriptor(bb->GetParent()); Loop* loop = (*loop_desc)[bb->id()]; loop->AddBasicBlock(new_header_id); loop->SetHeaderBlock(new_header); loop_desc->SetBasicBlockToLoop(new_header_id, loop); loop->RemoveBasicBlock(bb->id()); loop->SetPreHeaderBlock(bb); Loop* parent_loop = loop->GetParent(); if (parent_loop != nullptr) { parent_loop->AddBasicBlock(bb->id()); loop_desc->SetBasicBlockToLoop(bb->id(), parent_loop); } else { loop_desc->SetBasicBlockToLoop(bb->id(), nullptr); } } return new_header; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/cfg.h000066400000000000000000000164771475742701700215620ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_CFG_H_ #define SOURCE_OPT_CFG_H_ #include #include #include #include #include #include "source/opt/basic_block.h" namespace spvtools { namespace opt { class CFG { public: explicit CFG(Module* module); // Return the list of predecessors for basic block with label |blkid|. // TODO(dnovillo): Move this to BasicBlock. const std::vector& preds(uint32_t blk_id) const { assert(label2preds_.count(blk_id)); return label2preds_.at(blk_id); } // Return a pointer to the basic block instance corresponding to the label // |blk_id|. BasicBlock* block(uint32_t blk_id) const { return id2block_.at(blk_id); } // Return the pseudo entry and exit blocks. const BasicBlock* pseudo_entry_block() const { return &pseudo_entry_block_; } BasicBlock* pseudo_entry_block() { return &pseudo_entry_block_; } const BasicBlock* pseudo_exit_block() const { return &pseudo_exit_block_; } BasicBlock* pseudo_exit_block() { return &pseudo_exit_block_; } // Return true if |block_ptr| is the pseudo-entry block. bool IsPseudoEntryBlock(BasicBlock* block_ptr) const { return block_ptr == &pseudo_entry_block_; } // Return true if |block_ptr| is the pseudo-exit block. bool IsPseudoExitBlock(BasicBlock* block_ptr) const { return block_ptr == &pseudo_exit_block_; } // Compute structured block order into |order| for |func| starting at |root|. // This order has the property that dominators come before all blocks they // dominate, merge blocks come after all blocks that are in the control // constructs of their header, and continue blocks come after all of the // blocks in the body of their loop. void ComputeStructuredOrder(Function* func, BasicBlock* root, std::list* order); // Compute structured block order into |order| for |func| starting at |root| // and ending at |end|. This order has the property that dominators come // before all blocks they dominate, merge blocks come after all blocks that // are in the control constructs of their header, and continue blocks come // after all the blocks in the body of their loop. void ComputeStructuredOrder(Function* func, BasicBlock* root, BasicBlock* end, std::list* order); // Applies |f| to all blocks that can be reach from |bb| in post order. void ForEachBlockInPostOrder(BasicBlock* bb, const std::function& f); // Applies |f| to all blocks that can be reach from |bb| in reverse post // order. void ForEachBlockInReversePostOrder( BasicBlock* bb, const std::function& f); // Applies |f| to all blocks that can be reach from |bb| in reverse post // order. Return false if |f| return false on any basic block, and stops // processing. bool WhileEachBlockInReversePostOrder( BasicBlock* bb, const std::function& f); // Registers |blk| as a basic block in the cfg, this also updates the // predecessor lists of each successor of |blk|. |blk| must have a terminator // instruction at the end of the block. void RegisterBlock(BasicBlock* blk) { assert(blk->begin() != blk->end() && "Basic blocks must have a terminator before registering."); assert(blk->tail()->IsBlockTerminator() && "Basic blocks must have a terminator before registering."); uint32_t blk_id = blk->id(); id2block_[blk_id] = blk; AddEdges(blk); } // Removes from the CFG any mapping for the basic block id |blk_id|. void ForgetBlock(const BasicBlock* blk) { id2block_.erase(blk->id()); label2preds_.erase(blk->id()); RemoveSuccessorEdges(blk); } void RemoveEdge(uint32_t pred_blk_id, uint32_t succ_blk_id) { auto pred_it = label2preds_.find(succ_blk_id); if (pred_it == label2preds_.end()) return; auto& preds_list = pred_it->second; auto it = std::find(preds_list.begin(), preds_list.end(), pred_blk_id); if (it != preds_list.end()) preds_list.erase(it); } // Registers |blk| to all of its successors. void AddEdges(BasicBlock* blk); // Registers the basic block id |pred_blk_id| as being a predecessor of the // basic block id |succ_blk_id|. void AddEdge(uint32_t pred_blk_id, uint32_t succ_blk_id) { label2preds_[succ_blk_id].push_back(pred_blk_id); } // Removes any edges that no longer exist from the predecessor mapping for // the basic block id |blk_id|. void RemoveNonExistingEdges(uint32_t blk_id); // Remove all edges that leave |bb|. void RemoveSuccessorEdges(const BasicBlock* bb) { bb->ForEachSuccessorLabel( [bb, this](uint32_t succ_id) { RemoveEdge(bb->id(), succ_id); }); } // Divides |block| into two basic blocks. The first block will have the same // id as |block| and will become a preheader for the loop. The other block // is a new block that will be the new loop header. // // Returns a pointer to the new loop header. Returns |nullptr| if the new // loop pointer could not be created. BasicBlock* SplitLoopHeader(BasicBlock* bb); private: // Compute structured successors for function |func|. A block's structured // successors are the blocks it branches to together with its declared merge // block and continue block if it has them. When order matters, the merge // block and continue block always appear first. This assures correct depth // first search in the presence of early returns and kills. If the successor // vector contain duplicates of the merge or continue blocks, they are safely // ignored by DFS. void ComputeStructuredSuccessors(Function* func); // Computes the post-order traversal of the cfg starting at |bb| skipping // nodes in |seen|. The order of the traversal is appended to |order|, and // all nodes in the traversal are added to |seen|. void ComputePostOrderTraversal(BasicBlock* bb, std::vector* order, std::unordered_set* seen); // Module for this CFG. Module* module_; // Map from block to its structured successor blocks. See // ComputeStructuredSuccessors() for definition. std::unordered_map> block2structured_succs_; // Extra block whose successors are all blocks with no predecessors // in function. BasicBlock pseudo_entry_block_; // Augmented CFG Exit Block. BasicBlock pseudo_exit_block_; // Map from block's label id to its predecessor blocks ids std::unordered_map> label2preds_; // Map from block's label id to block. std::unordered_map id2block_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_CFG_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/cfg_cleanup_pass.cpp000066400000000000000000000023241475742701700246340ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // This file implements a pass to cleanup the CFG to remove superfluous // constructs (e.g., unreachable basic blocks, empty control flow structures, // etc) #include "source/opt/cfg_cleanup_pass.h" #include "source/opt/function.h" namespace spvtools { namespace opt { Pass::Status CFGCleanupPass::Process() { // Process all entry point functions. ProcessFunction pfn = [this](Function* fp) { return CFGCleanup(fp); }; bool modified = context()->ProcessReachableCallTree(pfn); return modified ? Pass::Status::SuccessWithChange : Pass::Status::SuccessWithoutChange; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/cfg_cleanup_pass.h000066400000000000000000000023321475742701700243000ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_CFG_CLEANUP_PASS_H_ #define SOURCE_OPT_CFG_CLEANUP_PASS_H_ #include "source/opt/function.h" #include "source/opt/mem_pass.h" #include "source/opt/module.h" namespace spvtools { namespace opt { class CFGCleanupPass : public MemPass { public: CFGCleanupPass() = default; const char* name() const override { return "cfg-cleanup"; } Status Process() override; IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisDefUse | IRContext::kAnalysisConstants | IRContext::kAnalysisTypes; } }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_CFG_CLEANUP_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/code_sink.cpp000066400000000000000000000241231475742701700232770ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "code_sink.h" #include #include "source/opt/instruction.h" #include "source/opt/ir_context.h" #include "source/util/bit_vector.h" namespace spvtools { namespace opt { Pass::Status CodeSinkingPass::Process() { bool modified = false; for (Function& function : *get_module()) { cfg()->ForEachBlockInPostOrder(function.entry().get(), [&modified, this](BasicBlock* bb) { if (SinkInstructionsInBB(bb)) { modified = true; } }); } return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } bool CodeSinkingPass::SinkInstructionsInBB(BasicBlock* bb) { bool modified = false; for (auto inst = bb->rbegin(); inst != bb->rend(); ++inst) { if (SinkInstruction(&*inst)) { inst = bb->rbegin(); modified = true; } } return modified; } bool CodeSinkingPass::SinkInstruction(Instruction* inst) { if (inst->opcode() != spv::Op::OpLoad && inst->opcode() != spv::Op::OpAccessChain) { return false; } if (ReferencesMutableMemory(inst)) { return false; } if (BasicBlock* target_bb = FindNewBasicBlockFor(inst)) { Instruction* pos = &*target_bb->begin(); while (pos->opcode() == spv::Op::OpPhi) { pos = pos->NextNode(); } inst->InsertBefore(pos); context()->set_instr_block(inst, target_bb); return true; } return false; } BasicBlock* CodeSinkingPass::FindNewBasicBlockFor(Instruction* inst) { assert(inst->result_id() != 0 && "Instruction should have a result."); BasicBlock* original_bb = context()->get_instr_block(inst); BasicBlock* bb = original_bb; std::unordered_set bbs_with_uses; get_def_use_mgr()->ForEachUse( inst, [&bbs_with_uses, this](Instruction* use, uint32_t idx) { if (use->opcode() != spv::Op::OpPhi) { BasicBlock* use_bb = context()->get_instr_block(use); if (use_bb) { bbs_with_uses.insert(use_bb->id()); } } else { bbs_with_uses.insert(use->GetSingleWordOperand(idx + 1)); } }); while (true) { // If |inst| is used in |bb|, then |inst| cannot be moved any further. if (bbs_with_uses.count(bb->id())) { break; } // If |bb| has one successor (succ_bb), and |bb| is the only predecessor // of succ_bb, then |inst| can be moved to succ_bb. If succ_bb, has move // then one predecessor, then moving |inst| into succ_bb could cause it to // be executed more often, so the search has to stop. if (bb->terminator()->opcode() == spv::Op::OpBranch) { uint32_t succ_bb_id = bb->terminator()->GetSingleWordInOperand(0); if (cfg()->preds(succ_bb_id).size() == 1) { bb = context()->get_instr_block(succ_bb_id); continue; } else { break; } } // The remaining checks need to know the merge node. If there is no merge // instruction or an OpLoopMerge, then it is a break or continue. We could // figure it out, but not worth doing it now. Instruction* merge_inst = bb->GetMergeInst(); if (merge_inst == nullptr || merge_inst->opcode() != spv::Op::OpSelectionMerge) { break; } // Check all of the successors of |bb| it see which lead to a use of |inst| // before reaching the merge node. bool used_in_multiple_blocks = false; uint32_t bb_used_in = 0; bb->ForEachSuccessorLabel([this, bb, &bb_used_in, &used_in_multiple_blocks, &bbs_with_uses](uint32_t* succ_bb_id) { if (IntersectsPath(*succ_bb_id, bb->MergeBlockIdIfAny(), bbs_with_uses)) { if (bb_used_in == 0) { bb_used_in = *succ_bb_id; } else { used_in_multiple_blocks = true; } } }); // If more than one successor, which is not the merge block, uses |inst| // then we have to leave |inst| in bb because there is none of the // successors dominate all uses of |inst|. if (used_in_multiple_blocks) { break; } if (bb_used_in == 0) { // If |inst| is not used before reaching the merge node, then we can move // |inst| to the merge node. bb = context()->get_instr_block(bb->MergeBlockIdIfAny()); } else { // If the only successor that leads to a used of |inst| has more than 1 // predecessor, then moving |inst| could cause it to be executed more // often, so we cannot move it. if (cfg()->preds(bb_used_in).size() != 1) { break; } // If |inst| is used after the merge block, then |bb_used_in| does not // dominate all of the uses. So we cannot move |inst| any further. if (IntersectsPath(bb->MergeBlockIdIfAny(), original_bb->id(), bbs_with_uses)) { break; } // Otherwise, |bb_used_in| dominates all uses, so move |inst| into that // block. bb = context()->get_instr_block(bb_used_in); } continue; } return (bb != original_bb ? bb : nullptr); } bool CodeSinkingPass::ReferencesMutableMemory(Instruction* inst) { if (!inst->IsLoad()) { return false; } Instruction* base_ptr = inst->GetBaseAddress(); if (base_ptr->opcode() != spv::Op::OpVariable) { return true; } if (base_ptr->IsReadOnlyPointer()) { return false; } if (HasUniformMemorySync()) { return true; } if (spv::StorageClass(base_ptr->GetSingleWordInOperand(0)) != spv::StorageClass::Uniform) { return true; } return HasPossibleStore(base_ptr); } bool CodeSinkingPass::HasUniformMemorySync() { if (checked_for_uniform_sync_) { return has_uniform_sync_; } bool has_sync = false; get_module()->ForEachInst([this, &has_sync](Instruction* inst) { switch (inst->opcode()) { case spv::Op::OpMemoryBarrier: { uint32_t mem_semantics_id = inst->GetSingleWordInOperand(1); if (IsSyncOnUniform(mem_semantics_id)) { has_sync = true; } break; } case spv::Op::OpControlBarrier: case spv::Op::OpAtomicLoad: case spv::Op::OpAtomicStore: case spv::Op::OpAtomicExchange: case spv::Op::OpAtomicIIncrement: case spv::Op::OpAtomicIDecrement: case spv::Op::OpAtomicIAdd: case spv::Op::OpAtomicFAddEXT: case spv::Op::OpAtomicISub: case spv::Op::OpAtomicSMin: case spv::Op::OpAtomicUMin: case spv::Op::OpAtomicFMinEXT: case spv::Op::OpAtomicSMax: case spv::Op::OpAtomicUMax: case spv::Op::OpAtomicFMaxEXT: case spv::Op::OpAtomicAnd: case spv::Op::OpAtomicOr: case spv::Op::OpAtomicXor: case spv::Op::OpAtomicFlagTestAndSet: case spv::Op::OpAtomicFlagClear: { uint32_t mem_semantics_id = inst->GetSingleWordInOperand(2); if (IsSyncOnUniform(mem_semantics_id)) { has_sync = true; } break; } case spv::Op::OpAtomicCompareExchange: case spv::Op::OpAtomicCompareExchangeWeak: if (IsSyncOnUniform(inst->GetSingleWordInOperand(2)) || IsSyncOnUniform(inst->GetSingleWordInOperand(3))) { has_sync = true; } break; default: break; } }); has_uniform_sync_ = has_sync; return has_sync; } bool CodeSinkingPass::IsSyncOnUniform(uint32_t mem_semantics_id) const { const analysis::Constant* mem_semantics_const = context()->get_constant_mgr()->FindDeclaredConstant(mem_semantics_id); assert(mem_semantics_const != nullptr && "Expecting memory semantics id to be a constant."); assert(mem_semantics_const->AsIntConstant() && "Memory semantics should be an integer."); uint32_t mem_semantics_int = mem_semantics_const->GetU32(); // If it does not affect uniform memory, then it is does not apply to uniform // memory. if ((mem_semantics_int & uint32_t(spv::MemorySemanticsMask::UniformMemory)) == 0) { return false; } // Check if there is an acquire or release. If so not, this it does not add // any memory constraints. return (mem_semantics_int & uint32_t(spv::MemorySemanticsMask::Acquire | spv::MemorySemanticsMask::AcquireRelease | spv::MemorySemanticsMask::Release)) != 0; } bool CodeSinkingPass::HasPossibleStore(Instruction* var_inst) { assert(var_inst->opcode() == spv::Op::OpVariable || var_inst->opcode() == spv::Op::OpAccessChain || var_inst->opcode() == spv::Op::OpPtrAccessChain); return get_def_use_mgr()->WhileEachUser(var_inst, [this](Instruction* use) { switch (use->opcode()) { case spv::Op::OpStore: return true; case spv::Op::OpAccessChain: case spv::Op::OpPtrAccessChain: return HasPossibleStore(use); default: return false; } }); } bool CodeSinkingPass::IntersectsPath(uint32_t start, uint32_t end, const std::unordered_set& set) { std::vector worklist; worklist.push_back(start); std::unordered_set already_done; already_done.insert(start); while (!worklist.empty()) { BasicBlock* bb = context()->get_instr_block(worklist.back()); worklist.pop_back(); if (bb->id() == end) { continue; } if (set.count(bb->id())) { return true; } bb->ForEachSuccessorLabel([&already_done, &worklist](uint32_t* succ_bb_id) { if (already_done.insert(*succ_bb_id).second) { worklist.push_back(*succ_bb_id); } }); } return false; } // namespace opt } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/code_sink.h000066400000000000000000000104741475742701700227500ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_CODE_SINK_H_ #define SOURCE_OPT_CODE_SINK_H_ #include #include "source/opt/ir_context.h" #include "source/opt/module.h" #include "source/opt/pass.h" namespace spvtools { namespace opt { // This pass does code sinking for OpAccessChain and OpLoad on variables in // uniform storage or in read only memory. Code sinking is a transformation // where an instruction is moved into a more deeply nested construct. // // The goal is to move these instructions as close as possible to their uses // without having to execute them more often or to replicate the instruction. // Moving the instruction in this way can lead to shorter live ranges, which can // lead to less register pressure. It can also cause instructions to be // executed less often because they could be moved into one path of a selection // construct. // // This optimization can cause register pressure to rise if the operands of the // instructions go dead after the instructions being moved. That is why we only // move certain OpLoad and OpAccessChain instructions. They generally have // constants, loop induction variables, and global pointers as operands. The // operands are live for a longer time in most cases. class CodeSinkingPass : public Pass { public: const char* name() const override { return "code-sink"; } Status Process() override; // Return the mask of preserved Analyses. IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisCombinators | IRContext::kAnalysisCFG | IRContext::kAnalysisDominatorAnalysis | IRContext::kAnalysisLoopAnalysis | IRContext::kAnalysisNameMap | IRContext::kAnalysisConstants | IRContext::kAnalysisTypes; } private: // Sinks the instructions in |bb| as much as possible. Returns true if // something changes. bool SinkInstructionsInBB(BasicBlock* bb); // Tries the sink |inst| as much as possible. Returns true if the instruction // is moved. bool SinkInstruction(Instruction* inst); // Returns the basic block in which to move |inst| to move is as close as // possible to the uses of |inst| without increasing the number of times // |inst| will be executed. Return |nullptr| if there is no need to move // |inst|. BasicBlock* FindNewBasicBlockFor(Instruction* inst); // Return true if |inst| reference memory and it is possible that the data in // the memory changes at some point. bool ReferencesMutableMemory(Instruction* inst); // Returns true if the module contains an instruction that has a memory // semantics id as an operand, and the memory semantics enforces a // synchronization of uniform memory. See section 3.25 of the SPIR-V // specification. bool HasUniformMemorySync(); // Returns true if there may be a store to the variable |var_inst|. bool HasPossibleStore(Instruction* var_inst); // Returns true if one of the basic blocks in |set| exists on a path from the // basic block |start| to |end|. bool IntersectsPath(uint32_t start, uint32_t end, const std::unordered_set& set); // Returns true if |mem_semantics_id| is the id of a constant that, when // interpreted as a memory semantics mask enforces synchronization of uniform // memory. See section 3.25 of the SPIR-V specification. bool IsSyncOnUniform(uint32_t mem_semantics_id) const; // True if a check has for uniform storage has taken place. bool checked_for_uniform_sync_; // Cache of whether or not the module has a memory sync on uniform storage. // only valid if |check_for_uniform_sync_| is true. bool has_uniform_sync_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_CODE_SINK_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/combine_access_chains.cpp000066400000000000000000000257411475742701700256320ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/combine_access_chains.h" #include #include "source/opt/constants.h" #include "source/opt/ir_builder.h" #include "source/opt/ir_context.h" namespace spvtools { namespace opt { Pass::Status CombineAccessChains::Process() { bool modified = false; for (auto& function : *get_module()) { modified |= ProcessFunction(function); } return (modified ? Status::SuccessWithChange : Status::SuccessWithoutChange); } bool CombineAccessChains::ProcessFunction(Function& function) { if (function.IsDeclaration()) { return false; } bool modified = false; cfg()->ForEachBlockInReversePostOrder( function.entry().get(), [&modified, this](BasicBlock* block) { block->ForEachInst([&modified, this](Instruction* inst) { switch (inst->opcode()) { case spv::Op::OpAccessChain: case spv::Op::OpInBoundsAccessChain: case spv::Op::OpPtrAccessChain: case spv::Op::OpInBoundsPtrAccessChain: modified |= CombineAccessChain(inst); break; default: break; } }); }); return modified; } uint32_t CombineAccessChains::GetConstantValue( const analysis::Constant* constant_inst) { if (constant_inst->type()->AsInteger()->width() <= 32) { if (constant_inst->type()->AsInteger()->IsSigned()) { return static_cast(constant_inst->GetS32()); } else { return constant_inst->GetU32(); } } else { assert(false); return 0u; } } uint32_t CombineAccessChains::GetArrayStride(const Instruction* inst) { uint32_t array_stride = 0; context()->get_decoration_mgr()->WhileEachDecoration( inst->type_id(), uint32_t(spv::Decoration::ArrayStride), [&array_stride](const Instruction& decoration) { assert(decoration.opcode() != spv::Op::OpDecorateId); if (decoration.opcode() == spv::Op::OpDecorate) { array_stride = decoration.GetSingleWordInOperand(1); } else { array_stride = decoration.GetSingleWordInOperand(2); } return false; }); return array_stride; } const analysis::Type* CombineAccessChains::GetIndexedType(Instruction* inst) { analysis::DefUseManager* def_use_mgr = context()->get_def_use_mgr(); analysis::TypeManager* type_mgr = context()->get_type_mgr(); Instruction* base_ptr = def_use_mgr->GetDef(inst->GetSingleWordInOperand(0)); const analysis::Type* type = type_mgr->GetType(base_ptr->type_id()); assert(type->AsPointer()); type = type->AsPointer()->pointee_type(); std::vector element_indices; uint32_t starting_index = 1; if (IsPtrAccessChain(inst->opcode())) { // Skip the first index of OpPtrAccessChain as it does not affect type // resolution. starting_index = 2; } for (uint32_t i = starting_index; i < inst->NumInOperands(); ++i) { Instruction* index_inst = def_use_mgr->GetDef(inst->GetSingleWordInOperand(i)); const analysis::Constant* index_constant = context()->get_constant_mgr()->GetConstantFromInst(index_inst); if (index_constant) { uint32_t index_value = GetConstantValue(index_constant); element_indices.push_back(index_value); } else { // This index must not matter to resolve the type in valid SPIR-V. element_indices.push_back(0); } } type = type_mgr->GetMemberType(type, element_indices); return type; } bool CombineAccessChains::CombineIndices(Instruction* ptr_input, Instruction* inst, std::vector* new_operands) { analysis::DefUseManager* def_use_mgr = context()->get_def_use_mgr(); analysis::ConstantManager* constant_mgr = context()->get_constant_mgr(); Instruction* last_index_inst = def_use_mgr->GetDef( ptr_input->GetSingleWordInOperand(ptr_input->NumInOperands() - 1)); const analysis::Constant* last_index_constant = constant_mgr->GetConstantFromInst(last_index_inst); Instruction* element_inst = def_use_mgr->GetDef(inst->GetSingleWordInOperand(1)); const analysis::Constant* element_constant = constant_mgr->GetConstantFromInst(element_inst); // Combine the last index of the AccessChain (|ptr_inst|) with the element // operand of the PtrAccessChain (|inst|). const bool combining_element_operands = IsPtrAccessChain(inst->opcode()) && IsPtrAccessChain(ptr_input->opcode()) && ptr_input->NumInOperands() == 2; uint32_t new_value_id = 0; const analysis::Type* type = GetIndexedType(ptr_input); if (last_index_constant && element_constant) { // Combine the constants. uint32_t new_value = GetConstantValue(last_index_constant) + GetConstantValue(element_constant); const analysis::Constant* new_value_constant = constant_mgr->GetConstant(last_index_constant->type(), {new_value}); Instruction* new_value_inst = constant_mgr->GetDefiningInstruction(new_value_constant); new_value_id = new_value_inst->result_id(); } else if (!type->AsStruct() || combining_element_operands) { // Generate an addition of the two indices. InstructionBuilder builder( context(), inst, IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); Instruction* addition = builder.AddIAdd(last_index_inst->type_id(), last_index_inst->result_id(), element_inst->result_id()); new_value_id = addition->result_id(); } else { // Indexing into structs must be constant, so bail out here. return false; } new_operands->push_back({SPV_OPERAND_TYPE_ID, {new_value_id}}); return true; } bool CombineAccessChains::CreateNewInputOperands( Instruction* ptr_input, Instruction* inst, std::vector* new_operands) { // Start by copying all the input operands of the feeder access chain. for (uint32_t i = 0; i != ptr_input->NumInOperands() - 1; ++i) { new_operands->push_back(ptr_input->GetInOperand(i)); } // Deal with the last index of the feeder access chain. if (IsPtrAccessChain(inst->opcode())) { // The last index of the feeder should be combined with the element operand // of |inst|. if (!CombineIndices(ptr_input, inst, new_operands)) return false; } else { // The indices aren't being combined so now add the last index operand of // |ptr_input|. new_operands->push_back( ptr_input->GetInOperand(ptr_input->NumInOperands() - 1)); } // Copy the remaining index operands. uint32_t starting_index = IsPtrAccessChain(inst->opcode()) ? 2 : 1; for (uint32_t i = starting_index; i < inst->NumInOperands(); ++i) { new_operands->push_back(inst->GetInOperand(i)); } return true; } bool CombineAccessChains::CombineAccessChain(Instruction* inst) { assert((inst->opcode() == spv::Op::OpPtrAccessChain || inst->opcode() == spv::Op::OpAccessChain || inst->opcode() == spv::Op::OpInBoundsAccessChain || inst->opcode() == spv::Op::OpInBoundsPtrAccessChain) && "Wrong opcode. Expected an access chain."); Instruction* ptr_input = context()->get_def_use_mgr()->GetDef(inst->GetSingleWordInOperand(0)); if (ptr_input->opcode() != spv::Op::OpAccessChain && ptr_input->opcode() != spv::Op::OpInBoundsAccessChain && ptr_input->opcode() != spv::Op::OpPtrAccessChain && ptr_input->opcode() != spv::Op::OpInBoundsPtrAccessChain) { return false; } if (Has64BitIndices(inst) || Has64BitIndices(ptr_input)) return false; // Handles the following cases: // 1. |ptr_input| is an index-less access chain. Replace the pointer // in |inst| with |ptr_input|'s pointer. // 2. |inst| is a index-less access chain. Change |inst| to an // OpCopyObject. // 3. |inst| is not a pointer access chain. // |inst|'s indices are appended to |ptr_input|'s indices. // 4. |ptr_input| is not pointer access chain. // |inst| is a pointer access chain. // |inst|'s element operand is combined with the last index in // |ptr_input| to form a new operand. // 5. |ptr_input| is a pointer access chain. // Like the above scenario, |inst|'s element operand is combined // with |ptr_input|'s last index. This results is either a // combined element operand or combined regular index. // TODO(alan-baker): Support this properly. Requires analyzing the // size/alignment of the type and converting the stride into an element // index. uint32_t array_stride = GetArrayStride(ptr_input); if (array_stride != 0) return false; if (ptr_input->NumInOperands() == 1) { // The input is effectively a no-op. inst->SetInOperand(0, {ptr_input->GetSingleWordInOperand(0)}); context()->AnalyzeUses(inst); } else if (inst->NumInOperands() == 1) { // |inst| is a no-op, change it to a copy. Instruction simplification will // clean it up. inst->SetOpcode(spv::Op::OpCopyObject); } else { std::vector new_operands; if (!CreateNewInputOperands(ptr_input, inst, &new_operands)) return false; // Update the instruction. inst->SetOpcode(UpdateOpcode(inst->opcode(), ptr_input->opcode())); inst->SetInOperands(std::move(new_operands)); context()->AnalyzeUses(inst); } return true; } spv::Op CombineAccessChains::UpdateOpcode(spv::Op base_opcode, spv::Op input_opcode) { auto IsInBounds = [](spv::Op opcode) { return opcode == spv::Op::OpInBoundsPtrAccessChain || opcode == spv::Op::OpInBoundsAccessChain; }; if (input_opcode == spv::Op::OpInBoundsPtrAccessChain) { if (!IsInBounds(base_opcode)) return spv::Op::OpPtrAccessChain; } else if (input_opcode == spv::Op::OpInBoundsAccessChain) { if (!IsInBounds(base_opcode)) return spv::Op::OpAccessChain; } return input_opcode; } bool CombineAccessChains::IsPtrAccessChain(spv::Op opcode) { return opcode == spv::Op::OpPtrAccessChain || opcode == spv::Op::OpInBoundsPtrAccessChain; } bool CombineAccessChains::Has64BitIndices(Instruction* inst) { for (uint32_t i = 1; i < inst->NumInOperands(); ++i) { Instruction* index_inst = context()->get_def_use_mgr()->GetDef(inst->GetSingleWordInOperand(i)); const analysis::Type* index_type = context()->get_type_mgr()->GetType(index_inst->type_id()); if (!index_type->AsInteger() || index_type->AsInteger()->width() != 32) return true; } return false; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/combine_access_chains.h000066400000000000000000000061251475742701700252720ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_COMBINE_ACCESS_CHAINS_H_ #define SOURCE_OPT_COMBINE_ACCESS_CHAINS_H_ #include #include "source/opt/pass.h" namespace spvtools { namespace opt { // See optimizer.hpp for documentation. class CombineAccessChains : public Pass { public: const char* name() const override { return "combine-access-chains"; } Status Process() override; IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisDecorations | IRContext::kAnalysisCombinators | IRContext::kAnalysisCFG | IRContext::kAnalysisDominatorAnalysis | IRContext::kAnalysisNameMap | IRContext::kAnalysisConstants | IRContext::kAnalysisTypes; } private: // Combine access chains in |function|. Blocks are processed in reverse // post-order. Returns true if the function is modified. bool ProcessFunction(Function& function); // Combines an access chain (normal, in bounds or pointer) |inst| if its base // pointer is another access chain. Returns true if the access chain was // modified. bool CombineAccessChain(Instruction* inst); // Returns the value of |constant_inst| as a uint32_t. uint32_t GetConstantValue(const analysis::Constant* constant_inst); // Returns the array stride of |inst|'s type. uint32_t GetArrayStride(const Instruction* inst); // Returns the type by resolving the index operands |inst|. |inst| must be an // access chain instruction. const analysis::Type* GetIndexedType(Instruction* inst); // Populates |new_operands| with the operands for the combined access chain. // Returns false if the access chains cannot be combined. bool CreateNewInputOperands(Instruction* ptr_input, Instruction* inst, std::vector* new_operands); // Combines the last index of |ptr_input| with the element operand of |inst|. // Adds the combined operand to |new_operands|. bool CombineIndices(Instruction* ptr_input, Instruction* inst, std::vector* new_operands); // Returns the opcode to use for the combined access chain. spv::Op UpdateOpcode(spv::Op base_opcode, spv::Op input_opcode); // Returns true if |opcode| is a pointer access chain. bool IsPtrAccessChain(spv::Op opcode); // Returns true if |inst| (an access chain) has 64-bit indices. bool Has64BitIndices(Instruction* inst); }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_COMBINE_ACCESS_CHAINS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/compact_ids_pass.cpp000066400000000000000000000072131475742701700246550ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/compact_ids_pass.h" #include #include #include "source/opt/ir_context.h" namespace spvtools { namespace opt { namespace { // Returns the remapped id of |id| from |result_id_mapping|. If the remapped // id does not exist, adds a new one to |result_id_mapping| and returns it. uint32_t GetRemappedId( std::unordered_map* result_id_mapping, uint32_t id) { auto it = result_id_mapping->find(id); if (it == result_id_mapping->end()) { const uint32_t new_id = static_cast(result_id_mapping->size()) + 1; const auto insertion_result = result_id_mapping->emplace(id, new_id); it = insertion_result.first; assert(insertion_result.second); } return it->second; } } // namespace Pass::Status CompactIdsPass::Process() { bool modified = false; std::unordered_map result_id_mapping; // Disable automatic DebugInfo analysis for the life of the CompactIds pass. // The DebugInfo manager requires the SPIR-V to be valid to run, but this is // not true at all times in CompactIds as it remaps all ids. context()->InvalidateAnalyses(IRContext::kAnalysisDebugInfo); context()->module()->ForEachInst( [&result_id_mapping, &modified](Instruction* inst) { auto operand = inst->begin(); while (operand != inst->end()) { const auto type = operand->type; if (spvIsIdType(type)) { assert(operand->words.size() == 1); uint32_t& id = operand->words[0]; uint32_t new_id = GetRemappedId(&result_id_mapping, id); if (id != new_id) { modified = true; id = new_id; // Update data cached in the instruction object. if (type == SPV_OPERAND_TYPE_RESULT_ID) { inst->SetResultId(id); } else if (type == SPV_OPERAND_TYPE_TYPE_ID) { inst->SetResultType(id); } } } ++operand; } uint32_t scope_id = inst->GetDebugScope().GetLexicalScope(); if (scope_id != kNoDebugScope) { uint32_t new_id = GetRemappedId(&result_id_mapping, scope_id); if (scope_id != new_id) { inst->UpdateLexicalScope(new_id); modified = true; } } uint32_t inlinedat_id = inst->GetDebugInlinedAt(); if (inlinedat_id != kNoInlinedAt) { uint32_t new_id = GetRemappedId(&result_id_mapping, inlinedat_id); if (inlinedat_id != new_id) { inst->UpdateDebugInlinedAt(new_id); modified = true; } } }, true); if (context()->module()->id_bound() != result_id_mapping.size() + 1) { modified = true; context()->module()->SetIdBound( static_cast(result_id_mapping.size() + 1)); // There are ids in the feature manager that could now be invalid context()->ResetFeatureManager(); } return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/compact_ids_pass.h000066400000000000000000000024611475742701700243220ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_COMPACT_IDS_PASS_H_ #define SOURCE_OPT_COMPACT_IDS_PASS_H_ #include "source/opt/ir_context.h" #include "source/opt/module.h" #include "source/opt/pass.h" namespace spvtools { namespace opt { // See optimizer.hpp for documentation. class CompactIdsPass : public Pass { public: const char* name() const override { return "compact-ids"; } Status Process() override; // Return the mask of preserved Analyses. IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisDominatorAnalysis | IRContext::kAnalysisLoopAnalysis; } }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_COMPACT_IDS_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/composite.cpp000066400000000000000000000036211475742701700233430ustar00rootroot00000000000000// Copyright (c) 2018 The Khronos Group Inc. // Copyright (c) 2018 Valve Corporation // Copyright (c) 2018 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/composite.h" #include #include "source/opt/ir_context.h" #include "source/opt/iterator.h" #include "spirv/1.2/GLSL.std.450.h" namespace spvtools { namespace opt { bool ExtInsMatch(const std::vector& extIndices, const Instruction* insInst, const uint32_t extOffset) { uint32_t numIndices = static_cast(extIndices.size()) - extOffset; if (numIndices != insInst->NumInOperands() - 2) return false; for (uint32_t i = 0; i < numIndices; ++i) if (extIndices[i + extOffset] != insInst->GetSingleWordInOperand(i + 2)) return false; return true; } bool ExtInsConflict(const std::vector& extIndices, const Instruction* insInst, const uint32_t extOffset) { if (extIndices.size() - extOffset == insInst->NumInOperands() - 2) return false; uint32_t extNumIndices = static_cast(extIndices.size()) - extOffset; uint32_t insNumIndices = insInst->NumInOperands() - 2; uint32_t numIndices = std::min(extNumIndices, insNumIndices); for (uint32_t i = 0; i < numIndices; ++i) if (extIndices[i + extOffset] != insInst->GetSingleWordInOperand(i + 2)) return false; return true; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/composite.h000066400000000000000000000034701475742701700230120ustar00rootroot00000000000000// Copyright (c) 2018 The Khronos Group Inc. // Copyright (c) 2018 Valve Corporation // Copyright (c) 2018 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_COMPOSITE_H_ #define SOURCE_OPT_COMPOSITE_H_ #include #include #include #include #include #include #include "source/opt/basic_block.h" #include "source/opt/def_use_manager.h" #include "source/opt/ir_context.h" #include "source/opt/module.h" namespace spvtools { namespace opt { // Return true if the extract indices in |extIndices| starting at |extOffset| // match indices of insert |insInst|. bool ExtInsMatch(const std::vector& extIndices, const Instruction* insInst, const uint32_t extOffset); // Return true if indices in |extIndices| starting at |extOffset| and // indices of insert |insInst| conflict, specifically, if the insert // changes bits specified by the extract, but changes either more bits // or less bits than the extract specifies, meaning the exact value being // inserted cannot be used to replace the extract. bool ExtInsConflict(const std::vector& extIndices, const Instruction* insInst, const uint32_t extOffset); } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_COMPOSITE_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/const_folding_rules.cpp000066400000000000000000002320161475742701700254050ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/const_folding_rules.h" #include "source/opt/ir_context.h" namespace spvtools { namespace opt { namespace { constexpr uint32_t kExtractCompositeIdInIdx = 0; // Returns a constants with the value NaN of the given type. Only works for // 32-bit and 64-bit float point types. Returns |nullptr| if an error occurs. const analysis::Constant* GetNan(const analysis::Type* type, analysis::ConstantManager* const_mgr) { const analysis::Float* float_type = type->AsFloat(); if (float_type == nullptr) { return nullptr; } switch (float_type->width()) { case 32: return const_mgr->GetFloatConst(std::numeric_limits::quiet_NaN()); case 64: return const_mgr->GetDoubleConst( std::numeric_limits::quiet_NaN()); default: return nullptr; } } // Returns a constants with the value INF of the given type. Only works for // 32-bit and 64-bit float point types. Returns |nullptr| if an error occurs. const analysis::Constant* GetInf(const analysis::Type* type, analysis::ConstantManager* const_mgr) { const analysis::Float* float_type = type->AsFloat(); if (float_type == nullptr) { return nullptr; } switch (float_type->width()) { case 32: return const_mgr->GetFloatConst(std::numeric_limits::infinity()); case 64: return const_mgr->GetDoubleConst(std::numeric_limits::infinity()); default: return nullptr; } } // Returns true if |type| is Float or a vector of Float. bool HasFloatingPoint(const analysis::Type* type) { if (type->AsFloat()) { return true; } else if (const analysis::Vector* vec_type = type->AsVector()) { return vec_type->element_type()->AsFloat() != nullptr; } return false; } // Returns a constants with the value |-val| of the given type. Only works for // 32-bit and 64-bit float point types. Returns |nullptr| if an error occurs. const analysis::Constant* NegateFPConst(const analysis::Type* result_type, const analysis::Constant* val, analysis::ConstantManager* const_mgr) { const analysis::Float* float_type = result_type->AsFloat(); assert(float_type != nullptr); if (float_type->width() == 32) { float fa = val->GetFloat(); return const_mgr->GetFloatConst(-fa); } else if (float_type->width() == 64) { double da = val->GetDouble(); return const_mgr->GetDoubleConst(-da); } return nullptr; } // Returns a constants with the value |-val| of the given type. const analysis::Constant* NegateIntConst(const analysis::Type* result_type, const analysis::Constant* val, analysis::ConstantManager* const_mgr) { const analysis::Integer* int_type = result_type->AsInteger(); assert(int_type != nullptr); if (val->AsNullConstant()) { return val; } uint64_t new_value = static_cast(-val->GetSignExtendedValue()); return const_mgr->GetIntConst(new_value, int_type->width(), int_type->IsSigned()); } // Folds an OpcompositeExtract where input is a composite constant. ConstantFoldingRule FoldExtractWithConstants() { return [](IRContext* context, Instruction* inst, const std::vector& constants) -> const analysis::Constant* { const analysis::Constant* c = constants[kExtractCompositeIdInIdx]; if (c == nullptr) { return nullptr; } for (uint32_t i = 1; i < inst->NumInOperands(); ++i) { uint32_t element_index = inst->GetSingleWordInOperand(i); if (c->AsNullConstant()) { // Return Null for the return type. analysis::ConstantManager* const_mgr = context->get_constant_mgr(); analysis::TypeManager* type_mgr = context->get_type_mgr(); return const_mgr->GetConstant(type_mgr->GetType(inst->type_id()), {}); } auto cc = c->AsCompositeConstant(); assert(cc != nullptr); auto components = cc->GetComponents(); // Protect against invalid IR. Refuse to fold if the index is out // of bounds. if (element_index >= components.size()) return nullptr; c = components[element_index]; } return c; }; } // Folds an OpcompositeInsert where input is a composite constant. ConstantFoldingRule FoldInsertWithConstants() { return [](IRContext* context, Instruction* inst, const std::vector& constants) -> const analysis::Constant* { analysis::ConstantManager* const_mgr = context->get_constant_mgr(); const analysis::Constant* object = constants[0]; const analysis::Constant* composite = constants[1]; if (object == nullptr || composite == nullptr) { return nullptr; } // If there is more than 1 index, then each additional constant used by the // index will need to be recreated to use the inserted object. std::vector chain; std::vector components; const analysis::Type* type = nullptr; const uint32_t final_index = (inst->NumInOperands() - 1); // Work down hierarchy of all indexes for (uint32_t i = 2; i < inst->NumInOperands(); ++i) { type = composite->type(); if (composite->AsNullConstant()) { // Make new composite so it can be inserted in the index with the // non-null value if (const auto new_composite = const_mgr->GetNullCompositeConstant(type)) { // Keep track of any indexes along the way to last index if (i != final_index) { chain.push_back(new_composite); } components = new_composite->AsCompositeConstant()->GetComponents(); } else { // Unsupported input type (such as structs) return nullptr; } } else { // Keep track of any indexes along the way to last index if (i != final_index) { chain.push_back(composite); } components = composite->AsCompositeConstant()->GetComponents(); } const uint32_t index = inst->GetSingleWordInOperand(i); composite = components[index]; } // Final index in hierarchy is inserted with new object. const uint32_t final_operand = inst->GetSingleWordInOperand(final_index); std::vector ids; for (size_t i = 0; i < components.size(); i++) { const analysis::Constant* constant = (i == final_operand) ? object : components[i]; Instruction* member_inst = const_mgr->GetDefiningInstruction(constant); ids.push_back(member_inst->result_id()); } const analysis::Constant* new_constant = const_mgr->GetConstant(type, ids); // Work backwards up the chain and replace each index with new constant. for (size_t i = chain.size(); i > 0; i--) { // Need to insert any previous instruction into the module first. // Can't just insert in types_values_begin() because it will move above // where the types are declared. // Can't compare with location of inst because not all new added // instructions are added to types_values_ auto iter = context->types_values_end(); Module::inst_iterator* pos = &iter; const_mgr->BuildInstructionAndAddToModule(new_constant, pos); composite = chain[i - 1]; components = composite->AsCompositeConstant()->GetComponents(); type = composite->type(); ids.clear(); for (size_t k = 0; k < components.size(); k++) { const uint32_t index = inst->GetSingleWordInOperand(1 + static_cast(i)); const analysis::Constant* constant = (k == index) ? new_constant : components[k]; const uint32_t constant_id = const_mgr->FindDeclaredConstant(constant, 0); ids.push_back(constant_id); } new_constant = const_mgr->GetConstant(type, ids); } // If multiple constants were created, only need to return the top index. return new_constant; }; } ConstantFoldingRule FoldVectorShuffleWithConstants() { return [](IRContext* context, Instruction* inst, const std::vector& constants) -> const analysis::Constant* { assert(inst->opcode() == spv::Op::OpVectorShuffle); const analysis::Constant* c1 = constants[0]; const analysis::Constant* c2 = constants[1]; if (c1 == nullptr || c2 == nullptr) { return nullptr; } analysis::ConstantManager* const_mgr = context->get_constant_mgr(); const analysis::Type* element_type = c1->type()->AsVector()->element_type(); std::vector c1_components; if (const analysis::VectorConstant* vec_const = c1->AsVectorConstant()) { c1_components = vec_const->GetComponents(); } else { assert(c1->AsNullConstant()); const analysis::Constant* element = const_mgr->GetConstant(element_type, {}); c1_components.resize(c1->type()->AsVector()->element_count(), element); } std::vector c2_components; if (const analysis::VectorConstant* vec_const = c2->AsVectorConstant()) { c2_components = vec_const->GetComponents(); } else { assert(c2->AsNullConstant()); const analysis::Constant* element = const_mgr->GetConstant(element_type, {}); c2_components.resize(c2->type()->AsVector()->element_count(), element); } std::vector ids; const uint32_t undef_literal_value = 0xffffffff; for (uint32_t i = 2; i < inst->NumInOperands(); ++i) { uint32_t index = inst->GetSingleWordInOperand(i); if (index == undef_literal_value) { // Don't fold shuffle with undef literal value. return nullptr; } else if (index < c1_components.size()) { Instruction* member_inst = const_mgr->GetDefiningInstruction(c1_components[index]); ids.push_back(member_inst->result_id()); } else { Instruction* member_inst = const_mgr->GetDefiningInstruction( c2_components[index - c1_components.size()]); ids.push_back(member_inst->result_id()); } } analysis::TypeManager* type_mgr = context->get_type_mgr(); return const_mgr->GetConstant(type_mgr->GetType(inst->type_id()), ids); }; } ConstantFoldingRule FoldVectorTimesScalar() { return [](IRContext* context, Instruction* inst, const std::vector& constants) -> const analysis::Constant* { assert(inst->opcode() == spv::Op::OpVectorTimesScalar); analysis::ConstantManager* const_mgr = context->get_constant_mgr(); analysis::TypeManager* type_mgr = context->get_type_mgr(); if (!inst->IsFloatingPointFoldingAllowed()) { if (HasFloatingPoint(type_mgr->GetType(inst->type_id()))) { return nullptr; } } const analysis::Constant* c1 = constants[0]; const analysis::Constant* c2 = constants[1]; if (c1 && c1->IsZero()) { return c1; } if (c2 && c2->IsZero()) { // Get or create the NullConstant for this type. std::vector ids; return const_mgr->GetConstant(type_mgr->GetType(inst->type_id()), ids); } if (c1 == nullptr || c2 == nullptr) { return nullptr; } // Check result type. const analysis::Type* result_type = type_mgr->GetType(inst->type_id()); const analysis::Vector* vector_type = result_type->AsVector(); assert(vector_type != nullptr); const analysis::Type* element_type = vector_type->element_type(); assert(element_type != nullptr); const analysis::Float* float_type = element_type->AsFloat(); assert(float_type != nullptr); // Check types of c1 and c2. assert(c1->type()->AsVector() == vector_type); assert(c1->type()->AsVector()->element_type() == element_type && c2->type() == element_type); // Get a float vector that is the result of vector-times-scalar. std::vector c1_components = c1->GetVectorComponents(const_mgr); std::vector ids; if (float_type->width() == 32) { float scalar = c2->GetFloat(); for (uint32_t i = 0; i < c1_components.size(); ++i) { utils::FloatProxy result(c1_components[i]->GetFloat() * scalar); std::vector words = result.GetWords(); const analysis::Constant* new_elem = const_mgr->GetConstant(float_type, words); ids.push_back(const_mgr->GetDefiningInstruction(new_elem)->result_id()); } return const_mgr->GetConstant(vector_type, ids); } else if (float_type->width() == 64) { double scalar = c2->GetDouble(); for (uint32_t i = 0; i < c1_components.size(); ++i) { utils::FloatProxy result(c1_components[i]->GetDouble() * scalar); std::vector words = result.GetWords(); const analysis::Constant* new_elem = const_mgr->GetConstant(float_type, words); ids.push_back(const_mgr->GetDefiningInstruction(new_elem)->result_id()); } return const_mgr->GetConstant(vector_type, ids); } return nullptr; }; } // Returns to the constant that results from tranposing |matrix|. The result // will have type |result_type|, and |matrix| must exist in |context|. The // result constant will also exist in |context|. const analysis::Constant* TransposeMatrix(const analysis::Constant* matrix, analysis::Matrix* result_type, IRContext* context) { analysis::ConstantManager* const_mgr = context->get_constant_mgr(); if (matrix->AsNullConstant() != nullptr) { return const_mgr->GetNullCompositeConstant(result_type); } const auto& columns = matrix->AsMatrixConstant()->GetComponents(); uint32_t number_of_rows = columns[0]->type()->AsVector()->element_count(); // Collect the ids of the elements in their new positions. std::vector> result_elements(number_of_rows); for (const analysis::Constant* column : columns) { if (column->AsNullConstant()) { column = const_mgr->GetNullCompositeConstant(column->type()); } const auto& column_components = column->AsVectorConstant()->GetComponents(); for (uint32_t row = 0; row < number_of_rows; ++row) { result_elements[row].push_back( const_mgr->GetDefiningInstruction(column_components[row]) ->result_id()); } } // Create the constant for each row in the result, and collect the ids. std::vector result_columns(number_of_rows); for (uint32_t col = 0; col < number_of_rows; ++col) { auto* element = const_mgr->GetConstant(result_type->element_type(), result_elements[col]); result_columns[col] = const_mgr->GetDefiningInstruction(element)->result_id(); } // Create the matrix constant from the row ids, and return it. return const_mgr->GetConstant(result_type, result_columns); } const analysis::Constant* FoldTranspose( IRContext* context, Instruction* inst, const std::vector& constants) { assert(inst->opcode() == spv::Op::OpTranspose); analysis::TypeManager* type_mgr = context->get_type_mgr(); if (!inst->IsFloatingPointFoldingAllowed()) { if (HasFloatingPoint(type_mgr->GetType(inst->type_id()))) { return nullptr; } } const analysis::Constant* matrix = constants[0]; if (matrix == nullptr) { return nullptr; } auto* result_type = type_mgr->GetType(inst->type_id()); return TransposeMatrix(matrix, result_type->AsMatrix(), context); } ConstantFoldingRule FoldVectorTimesMatrix() { return [](IRContext* context, Instruction* inst, const std::vector& constants) -> const analysis::Constant* { assert(inst->opcode() == spv::Op::OpVectorTimesMatrix); analysis::ConstantManager* const_mgr = context->get_constant_mgr(); analysis::TypeManager* type_mgr = context->get_type_mgr(); if (!inst->IsFloatingPointFoldingAllowed()) { if (HasFloatingPoint(type_mgr->GetType(inst->type_id()))) { return nullptr; } } const analysis::Constant* c1 = constants[0]; const analysis::Constant* c2 = constants[1]; if (c1 == nullptr || c2 == nullptr) { return nullptr; } // Check result type. const analysis::Type* result_type = type_mgr->GetType(inst->type_id()); const analysis::Vector* vector_type = result_type->AsVector(); assert(vector_type != nullptr); const analysis::Type* element_type = vector_type->element_type(); assert(element_type != nullptr); const analysis::Float* float_type = element_type->AsFloat(); assert(float_type != nullptr); // Check types of c1 and c2. assert(c1->type()->AsVector() == vector_type); assert(c1->type()->AsVector()->element_type() == element_type && c2->type()->AsMatrix()->element_type() == vector_type); uint32_t resultVectorSize = result_type->AsVector()->element_count(); std::vector ids; if ((c1 && c1->IsZero()) || (c2 && c2->IsZero())) { std::vector words(float_type->width() / 32, 0); for (uint32_t i = 0; i < resultVectorSize; ++i) { const analysis::Constant* new_elem = const_mgr->GetConstant(float_type, words); ids.push_back(const_mgr->GetDefiningInstruction(new_elem)->result_id()); } return const_mgr->GetConstant(vector_type, ids); } // Get a float vector that is the result of vector-times-matrix. std::vector c1_components = c1->GetVectorComponents(const_mgr); std::vector c2_components = c2->AsMatrixConstant()->GetComponents(); if (float_type->width() == 32) { for (uint32_t i = 0; i < resultVectorSize; ++i) { float result_scalar = 0.0f; if (!c2_components[i]->AsNullConstant()) { const analysis::VectorConstant* c2_vec = c2_components[i]->AsVectorConstant(); for (uint32_t j = 0; j < c2_vec->GetComponents().size(); ++j) { float c1_scalar = c1_components[j]->GetFloat(); float c2_scalar = c2_vec->GetComponents()[j]->GetFloat(); result_scalar += c1_scalar * c2_scalar; } } utils::FloatProxy result(result_scalar); std::vector words = result.GetWords(); const analysis::Constant* new_elem = const_mgr->GetConstant(float_type, words); ids.push_back(const_mgr->GetDefiningInstruction(new_elem)->result_id()); } return const_mgr->GetConstant(vector_type, ids); } else if (float_type->width() == 64) { for (uint32_t i = 0; i < c2_components.size(); ++i) { double result_scalar = 0.0; if (!c2_components[i]->AsNullConstant()) { const analysis::VectorConstant* c2_vec = c2_components[i]->AsVectorConstant(); for (uint32_t j = 0; j < c2_vec->GetComponents().size(); ++j) { double c1_scalar = c1_components[j]->GetDouble(); double c2_scalar = c2_vec->GetComponents()[j]->GetDouble(); result_scalar += c1_scalar * c2_scalar; } } utils::FloatProxy result(result_scalar); std::vector words = result.GetWords(); const analysis::Constant* new_elem = const_mgr->GetConstant(float_type, words); ids.push_back(const_mgr->GetDefiningInstruction(new_elem)->result_id()); } return const_mgr->GetConstant(vector_type, ids); } return nullptr; }; } ConstantFoldingRule FoldMatrixTimesVector() { return [](IRContext* context, Instruction* inst, const std::vector& constants) -> const analysis::Constant* { assert(inst->opcode() == spv::Op::OpMatrixTimesVector); analysis::ConstantManager* const_mgr = context->get_constant_mgr(); analysis::TypeManager* type_mgr = context->get_type_mgr(); if (!inst->IsFloatingPointFoldingAllowed()) { if (HasFloatingPoint(type_mgr->GetType(inst->type_id()))) { return nullptr; } } const analysis::Constant* c1 = constants[0]; const analysis::Constant* c2 = constants[1]; if (c1 == nullptr || c2 == nullptr) { return nullptr; } // Check result type. const analysis::Type* result_type = type_mgr->GetType(inst->type_id()); const analysis::Vector* vector_type = result_type->AsVector(); assert(vector_type != nullptr); const analysis::Type* element_type = vector_type->element_type(); assert(element_type != nullptr); const analysis::Float* float_type = element_type->AsFloat(); assert(float_type != nullptr); // Check types of c1 and c2. assert(c1->type()->AsMatrix()->element_type() == vector_type); assert(c2->type()->AsVector()->element_type() == element_type); uint32_t resultVectorSize = result_type->AsVector()->element_count(); std::vector ids; if ((c1 && c1->IsZero()) || (c2 && c2->IsZero())) { std::vector words(float_type->width() / 32, 0); for (uint32_t i = 0; i < resultVectorSize; ++i) { const analysis::Constant* new_elem = const_mgr->GetConstant(float_type, words); ids.push_back(const_mgr->GetDefiningInstruction(new_elem)->result_id()); } return const_mgr->GetConstant(vector_type, ids); } // Get a float vector that is the result of matrix-times-vector. std::vector c1_components = c1->AsMatrixConstant()->GetComponents(); std::vector c2_components = c2->GetVectorComponents(const_mgr); if (float_type->width() == 32) { for (uint32_t i = 0; i < resultVectorSize; ++i) { float result_scalar = 0.0f; for (uint32_t j = 0; j < c1_components.size(); ++j) { if (!c1_components[j]->AsNullConstant()) { float c1_scalar = c1_components[j] ->AsVectorConstant() ->GetComponents()[i] ->GetFloat(); float c2_scalar = c2_components[j]->GetFloat(); result_scalar += c1_scalar * c2_scalar; } } utils::FloatProxy result(result_scalar); std::vector words = result.GetWords(); const analysis::Constant* new_elem = const_mgr->GetConstant(float_type, words); ids.push_back(const_mgr->GetDefiningInstruction(new_elem)->result_id()); } return const_mgr->GetConstant(vector_type, ids); } else if (float_type->width() == 64) { for (uint32_t i = 0; i < resultVectorSize; ++i) { double result_scalar = 0.0; for (uint32_t j = 0; j < c1_components.size(); ++j) { if (!c1_components[j]->AsNullConstant()) { double c1_scalar = c1_components[j] ->AsVectorConstant() ->GetComponents()[i] ->GetDouble(); double c2_scalar = c2_components[j]->GetDouble(); result_scalar += c1_scalar * c2_scalar; } } utils::FloatProxy result(result_scalar); std::vector words = result.GetWords(); const analysis::Constant* new_elem = const_mgr->GetConstant(float_type, words); ids.push_back(const_mgr->GetDefiningInstruction(new_elem)->result_id()); } return const_mgr->GetConstant(vector_type, ids); } return nullptr; }; } ConstantFoldingRule FoldCompositeWithConstants() { // Folds an OpCompositeConstruct where all of the inputs are constants to a // constant. A new constant is created if necessary. return [](IRContext* context, Instruction* inst, const std::vector& constants) -> const analysis::Constant* { analysis::ConstantManager* const_mgr = context->get_constant_mgr(); analysis::TypeManager* type_mgr = context->get_type_mgr(); const analysis::Type* new_type = type_mgr->GetType(inst->type_id()); Instruction* type_inst = context->get_def_use_mgr()->GetDef(inst->type_id()); std::vector ids; for (uint32_t i = 0; i < constants.size(); ++i) { const analysis::Constant* element_const = constants[i]; if (element_const == nullptr) { return nullptr; } uint32_t component_type_id = 0; if (type_inst->opcode() == spv::Op::OpTypeStruct) { component_type_id = type_inst->GetSingleWordInOperand(i); } else if (type_inst->opcode() == spv::Op::OpTypeArray) { component_type_id = type_inst->GetSingleWordInOperand(0); } uint32_t element_id = const_mgr->FindDeclaredConstant(element_const, component_type_id); if (element_id == 0) { return nullptr; } ids.push_back(element_id); } return const_mgr->GetConstant(new_type, ids); }; } // The interface for a function that returns the result of applying a scalar // floating-point binary operation on |a| and |b|. The type of the return value // will be |type|. The input constants must also be of type |type|. using UnaryScalarFoldingRule = std::function; // The interface for a function that returns the result of applying a scalar // floating-point binary operation on |a| and |b|. The type of the return value // will be |type|. The input constants must also be of type |type|. using BinaryScalarFoldingRule = std::function; // Returns a |ConstantFoldingRule| that folds unary scalar ops // using |scalar_rule| and unary vectors ops by applying // |scalar_rule| to the elements of the vector. The |ConstantFoldingRule| // that is returned assumes that |constants| contains 1 entry. If they are // not |nullptr|, then their type is either |Float| or |Integer| or a |Vector| // whose element type is |Float| or |Integer|. ConstantFoldingRule FoldUnaryOp(UnaryScalarFoldingRule scalar_rule) { return [scalar_rule](IRContext* context, Instruction* inst, const std::vector& constants) -> const analysis::Constant* { analysis::ConstantManager* const_mgr = context->get_constant_mgr(); analysis::TypeManager* type_mgr = context->get_type_mgr(); const analysis::Type* result_type = type_mgr->GetType(inst->type_id()); const analysis::Vector* vector_type = result_type->AsVector(); const analysis::Constant* arg = (inst->opcode() == spv::Op::OpExtInst) ? constants[1] : constants[0]; if (arg == nullptr) { return nullptr; } if (vector_type != nullptr) { std::vector a_components; std::vector results_components; a_components = arg->GetVectorComponents(const_mgr); // Fold each component of the vector. for (uint32_t i = 0; i < a_components.size(); ++i) { results_components.push_back(scalar_rule(vector_type->element_type(), a_components[i], const_mgr)); if (results_components[i] == nullptr) { return nullptr; } } // Build the constant object and return it. std::vector ids; for (const analysis::Constant* member : results_components) { ids.push_back(const_mgr->GetDefiningInstruction(member)->result_id()); } return const_mgr->GetConstant(vector_type, ids); } else { return scalar_rule(result_type, arg, const_mgr); } }; } // Returns a |ConstantFoldingRule| that folds binary scalar ops // using |scalar_rule| and binary vectors ops by applying // |scalar_rule| to the elements of the vector. The folding rule assumes that op // has two inputs. For regular instruction, those are in operands 0 and 1. For // extended instruction, they are in operands 1 and 2. If an element in // |constants| is not nullprt, then the constant's type is |Float|, |Integer|, // or |Vector| whose element type is |Float| or |Integer|. ConstantFoldingRule FoldBinaryOp(BinaryScalarFoldingRule scalar_rule) { return [scalar_rule](IRContext* context, Instruction* inst, const std::vector& constants) -> const analysis::Constant* { assert(constants.size() == inst->NumInOperands()); assert(constants.size() == (inst->opcode() == spv::Op::OpExtInst ? 3 : 2)); analysis::ConstantManager* const_mgr = context->get_constant_mgr(); analysis::TypeManager* type_mgr = context->get_type_mgr(); const analysis::Type* result_type = type_mgr->GetType(inst->type_id()); const analysis::Vector* vector_type = result_type->AsVector(); const analysis::Constant* arg1 = (inst->opcode() == spv::Op::OpExtInst) ? constants[1] : constants[0]; const analysis::Constant* arg2 = (inst->opcode() == spv::Op::OpExtInst) ? constants[2] : constants[1]; if (arg1 == nullptr || arg2 == nullptr) { return nullptr; } if (vector_type == nullptr) { return scalar_rule(result_type, arg1, arg2, const_mgr); } std::vector a_components; std::vector b_components; std::vector results_components; a_components = arg1->GetVectorComponents(const_mgr); b_components = arg2->GetVectorComponents(const_mgr); assert(a_components.size() == b_components.size()); // Fold each component of the vector. for (uint32_t i = 0; i < a_components.size(); ++i) { results_components.push_back(scalar_rule(vector_type->element_type(), a_components[i], b_components[i], const_mgr)); if (results_components[i] == nullptr) { return nullptr; } } // Build the constant object and return it. std::vector ids; for (const analysis::Constant* member : results_components) { ids.push_back(const_mgr->GetDefiningInstruction(member)->result_id()); } return const_mgr->GetConstant(vector_type, ids); }; } // Returns a |ConstantFoldingRule| that folds unary floating point scalar ops // using |scalar_rule| and unary float point vectors ops by applying // |scalar_rule| to the elements of the vector. The |ConstantFoldingRule| // that is returned assumes that |constants| contains 1 entry. If they are // not |nullptr|, then their type is either |Float| or |Integer| or a |Vector| // whose element type is |Float| or |Integer|. ConstantFoldingRule FoldFPUnaryOp(UnaryScalarFoldingRule scalar_rule) { auto folding_rule = FoldUnaryOp(scalar_rule); return [folding_rule](IRContext* context, Instruction* inst, const std::vector& constants) -> const analysis::Constant* { if (!inst->IsFloatingPointFoldingAllowed()) { return nullptr; } return folding_rule(context, inst, constants); }; } // Returns the result of folding the constants in |constants| according the // |scalar_rule|. If |result_type| is a vector, then |scalar_rule| is applied // per component. const analysis::Constant* FoldFPBinaryOp( BinaryScalarFoldingRule scalar_rule, uint32_t result_type_id, const std::vector& constants, IRContext* context) { analysis::ConstantManager* const_mgr = context->get_constant_mgr(); analysis::TypeManager* type_mgr = context->get_type_mgr(); const analysis::Type* result_type = type_mgr->GetType(result_type_id); const analysis::Vector* vector_type = result_type->AsVector(); if (constants[0] == nullptr || constants[1] == nullptr) { return nullptr; } if (vector_type != nullptr) { std::vector a_components; std::vector b_components; std::vector results_components; a_components = constants[0]->GetVectorComponents(const_mgr); b_components = constants[1]->GetVectorComponents(const_mgr); // Fold each component of the vector. for (uint32_t i = 0; i < a_components.size(); ++i) { results_components.push_back(scalar_rule(vector_type->element_type(), a_components[i], b_components[i], const_mgr)); if (results_components[i] == nullptr) { return nullptr; } } // Build the constant object and return it. std::vector ids; for (const analysis::Constant* member : results_components) { ids.push_back(const_mgr->GetDefiningInstruction(member)->result_id()); } return const_mgr->GetConstant(vector_type, ids); } else { return scalar_rule(result_type, constants[0], constants[1], const_mgr); } } // Returns a |ConstantFoldingRule| that folds floating point scalars using // |scalar_rule| and vectors of floating point by applying |scalar_rule| to the // elements of the vector. The |ConstantFoldingRule| that is returned assumes // that |constants| contains 2 entries. If they are not |nullptr|, then their // type is either |Float| or a |Vector| whose element type is |Float|. ConstantFoldingRule FoldFPBinaryOp(BinaryScalarFoldingRule scalar_rule) { return [scalar_rule](IRContext* context, Instruction* inst, const std::vector& constants) -> const analysis::Constant* { if (!inst->IsFloatingPointFoldingAllowed()) { return nullptr; } if (inst->opcode() == spv::Op::OpExtInst) { return FoldFPBinaryOp(scalar_rule, inst->type_id(), {constants[1], constants[2]}, context); } return FoldFPBinaryOp(scalar_rule, inst->type_id(), constants, context); }; } // This macro defines a |UnaryScalarFoldingRule| that performs float to // integer conversion. // TODO(greg-lunarg): Support for 64-bit integer types. UnaryScalarFoldingRule FoldFToIOp() { return [](const analysis::Type* result_type, const analysis::Constant* a, analysis::ConstantManager* const_mgr) -> const analysis::Constant* { assert(result_type != nullptr && a != nullptr); const analysis::Integer* integer_type = result_type->AsInteger(); const analysis::Float* float_type = a->type()->AsFloat(); assert(float_type != nullptr); assert(integer_type != nullptr); if (integer_type->width() != 32) return nullptr; if (float_type->width() == 32) { float fa = a->GetFloat(); uint32_t result = integer_type->IsSigned() ? static_cast(static_cast(fa)) : static_cast(fa); std::vector words = {result}; return const_mgr->GetConstant(result_type, words); } else if (float_type->width() == 64) { double fa = a->GetDouble(); uint32_t result = integer_type->IsSigned() ? static_cast(static_cast(fa)) : static_cast(fa); std::vector words = {result}; return const_mgr->GetConstant(result_type, words); } return nullptr; }; } // This function defines a |UnaryScalarFoldingRule| that performs integer to // float conversion. // TODO(greg-lunarg): Support for 64-bit integer types. UnaryScalarFoldingRule FoldIToFOp() { return [](const analysis::Type* result_type, const analysis::Constant* a, analysis::ConstantManager* const_mgr) -> const analysis::Constant* { assert(result_type != nullptr && a != nullptr); const analysis::Integer* integer_type = a->type()->AsInteger(); const analysis::Float* float_type = result_type->AsFloat(); assert(float_type != nullptr); assert(integer_type != nullptr); if (integer_type->width() != 32) return nullptr; uint32_t ua = a->GetU32(); if (float_type->width() == 32) { float result_val = integer_type->IsSigned() ? static_cast(static_cast(ua)) : static_cast(ua); utils::FloatProxy result(result_val); std::vector words = {result.data()}; return const_mgr->GetConstant(result_type, words); } else if (float_type->width() == 64) { double result_val = integer_type->IsSigned() ? static_cast(static_cast(ua)) : static_cast(ua); utils::FloatProxy result(result_val); std::vector words = result.GetWords(); return const_mgr->GetConstant(result_type, words); } return nullptr; }; } // This defines a |UnaryScalarFoldingRule| that performs |OpQuantizeToF16|. UnaryScalarFoldingRule FoldQuantizeToF16Scalar() { return [](const analysis::Type* result_type, const analysis::Constant* a, analysis::ConstantManager* const_mgr) -> const analysis::Constant* { assert(result_type != nullptr && a != nullptr); const analysis::Float* float_type = a->type()->AsFloat(); assert(float_type != nullptr); if (float_type->width() != 32) { return nullptr; } float fa = a->GetFloat(); utils::HexFloat> orignal(fa); utils::HexFloat> quantized(0); utils::HexFloat> result(0.0f); orignal.castTo(quantized, utils::round_direction::kToZero); quantized.castTo(result, utils::round_direction::kToZero); std::vector words = {result.getBits()}; return const_mgr->GetConstant(result_type, words); }; } // This macro defines a |BinaryScalarFoldingRule| that applies |op|. The // operator |op| must work for both float and double, and use syntax "f1 op f2". #define FOLD_FPARITH_OP(op) \ [](const analysis::Type* result_type_in_macro, const analysis::Constant* a, \ const analysis::Constant* b, \ analysis::ConstantManager* const_mgr_in_macro) \ -> const analysis::Constant* { \ assert(result_type_in_macro != nullptr && a != nullptr && b != nullptr); \ assert(result_type_in_macro == a->type() && \ result_type_in_macro == b->type()); \ const analysis::Float* float_type_in_macro = \ result_type_in_macro->AsFloat(); \ assert(float_type_in_macro != nullptr); \ if (float_type_in_macro->width() == 32) { \ float fa = a->GetFloat(); \ float fb = b->GetFloat(); \ utils::FloatProxy result_in_macro(fa op fb); \ std::vector words_in_macro = result_in_macro.GetWords(); \ return const_mgr_in_macro->GetConstant(result_type_in_macro, \ words_in_macro); \ } else if (float_type_in_macro->width() == 64) { \ double fa = a->GetDouble(); \ double fb = b->GetDouble(); \ utils::FloatProxy result_in_macro(fa op fb); \ std::vector words_in_macro = result_in_macro.GetWords(); \ return const_mgr_in_macro->GetConstant(result_type_in_macro, \ words_in_macro); \ } \ return nullptr; \ } // Define the folding rule for conversion between floating point and integer ConstantFoldingRule FoldFToI() { return FoldFPUnaryOp(FoldFToIOp()); } ConstantFoldingRule FoldIToF() { return FoldFPUnaryOp(FoldIToFOp()); } ConstantFoldingRule FoldQuantizeToF16() { return FoldFPUnaryOp(FoldQuantizeToF16Scalar()); } // Define the folding rules for subtraction, addition, multiplication, and // division for floating point values. ConstantFoldingRule FoldFSub() { return FoldFPBinaryOp(FOLD_FPARITH_OP(-)); } ConstantFoldingRule FoldFAdd() { return FoldFPBinaryOp(FOLD_FPARITH_OP(+)); } ConstantFoldingRule FoldFMul() { return FoldFPBinaryOp(FOLD_FPARITH_OP(*)); } // Returns the constant that results from evaluating |numerator| / 0.0. Returns // |nullptr| if the result could not be evaluated. const analysis::Constant* FoldFPScalarDivideByZero( const analysis::Type* result_type, const analysis::Constant* numerator, analysis::ConstantManager* const_mgr) { if (numerator == nullptr) { return nullptr; } if (numerator->IsZero()) { return GetNan(result_type, const_mgr); } const analysis::Constant* result = GetInf(result_type, const_mgr); if (result == nullptr) { return nullptr; } if (numerator->AsFloatConstant()->GetValueAsDouble() < 0.0) { result = NegateFPConst(result_type, result, const_mgr); } return result; } // Returns the result of folding |numerator| / |denominator|. Returns |nullptr| // if it cannot be folded. const analysis::Constant* FoldScalarFPDivide( const analysis::Type* result_type, const analysis::Constant* numerator, const analysis::Constant* denominator, analysis::ConstantManager* const_mgr) { if (denominator == nullptr) { return nullptr; } if (denominator->IsZero()) { return FoldFPScalarDivideByZero(result_type, numerator, const_mgr); } uint32_t width = denominator->type()->AsFloat()->width(); if (width != 32 && width != 64) { return nullptr; } const analysis::FloatConstant* denominator_float = denominator->AsFloatConstant(); if (denominator_float && denominator->GetValueAsDouble() == -0.0) { const analysis::Constant* result = FoldFPScalarDivideByZero(result_type, numerator, const_mgr); if (result != nullptr) result = NegateFPConst(result_type, result, const_mgr); return result; } else { return FOLD_FPARITH_OP(/)(result_type, numerator, denominator, const_mgr); } } // Returns the constant folding rule to fold |OpFDiv| with two constants. ConstantFoldingRule FoldFDiv() { return FoldFPBinaryOp(FoldScalarFPDivide); } bool CompareFloatingPoint(bool op_result, bool op_unordered, bool need_ordered) { if (need_ordered) { // operands are ordered and Operand 1 is |op| Operand 2 return !op_unordered && op_result; } else { // operands are unordered or Operand 1 is |op| Operand 2 return op_unordered || op_result; } } // This macro defines a |BinaryScalarFoldingRule| that applies |op|. The // operator |op| must work for both float and double, and use syntax "f1 op f2". #define FOLD_FPCMP_OP(op, ord) \ [](const analysis::Type* result_type, const analysis::Constant* a, \ const analysis::Constant* b, \ analysis::ConstantManager* const_mgr) -> const analysis::Constant* { \ assert(result_type != nullptr && a != nullptr && b != nullptr); \ assert(result_type->AsBool()); \ assert(a->type() == b->type()); \ const analysis::Float* float_type = a->type()->AsFloat(); \ assert(float_type != nullptr); \ if (float_type->width() == 32) { \ float fa = a->GetFloat(); \ float fb = b->GetFloat(); \ bool result = CompareFloatingPoint( \ fa op fb, std::isnan(fa) || std::isnan(fb), ord); \ std::vector words = {uint32_t(result)}; \ return const_mgr->GetConstant(result_type, words); \ } else if (float_type->width() == 64) { \ double fa = a->GetDouble(); \ double fb = b->GetDouble(); \ bool result = CompareFloatingPoint( \ fa op fb, std::isnan(fa) || std::isnan(fb), ord); \ std::vector words = {uint32_t(result)}; \ return const_mgr->GetConstant(result_type, words); \ } \ return nullptr; \ } // Define the folding rules for ordered and unordered comparison for floating // point values. ConstantFoldingRule FoldFOrdEqual() { return FoldFPBinaryOp(FOLD_FPCMP_OP(==, true)); } ConstantFoldingRule FoldFUnordEqual() { return FoldFPBinaryOp(FOLD_FPCMP_OP(==, false)); } ConstantFoldingRule FoldFOrdNotEqual() { return FoldFPBinaryOp(FOLD_FPCMP_OP(!=, true)); } ConstantFoldingRule FoldFUnordNotEqual() { return FoldFPBinaryOp(FOLD_FPCMP_OP(!=, false)); } ConstantFoldingRule FoldFOrdLessThan() { return FoldFPBinaryOp(FOLD_FPCMP_OP(<, true)); } ConstantFoldingRule FoldFUnordLessThan() { return FoldFPBinaryOp(FOLD_FPCMP_OP(<, false)); } ConstantFoldingRule FoldFOrdGreaterThan() { return FoldFPBinaryOp(FOLD_FPCMP_OP(>, true)); } ConstantFoldingRule FoldFUnordGreaterThan() { return FoldFPBinaryOp(FOLD_FPCMP_OP(>, false)); } ConstantFoldingRule FoldFOrdLessThanEqual() { return FoldFPBinaryOp(FOLD_FPCMP_OP(<=, true)); } ConstantFoldingRule FoldFUnordLessThanEqual() { return FoldFPBinaryOp(FOLD_FPCMP_OP(<=, false)); } ConstantFoldingRule FoldFOrdGreaterThanEqual() { return FoldFPBinaryOp(FOLD_FPCMP_OP(>=, true)); } ConstantFoldingRule FoldFUnordGreaterThanEqual() { return FoldFPBinaryOp(FOLD_FPCMP_OP(>=, false)); } // Folds an OpDot where all of the inputs are constants to a // constant. A new constant is created if necessary. ConstantFoldingRule FoldOpDotWithConstants() { return [](IRContext* context, Instruction* inst, const std::vector& constants) -> const analysis::Constant* { analysis::ConstantManager* const_mgr = context->get_constant_mgr(); analysis::TypeManager* type_mgr = context->get_type_mgr(); const analysis::Type* new_type = type_mgr->GetType(inst->type_id()); assert(new_type->AsFloat() && "OpDot should have a float return type."); const analysis::Float* float_type = new_type->AsFloat(); if (!inst->IsFloatingPointFoldingAllowed()) { return nullptr; } // If one of the operands is 0, then the result is 0. bool has_zero_operand = false; for (int i = 0; i < 2; ++i) { if (constants[i]) { if (constants[i]->AsNullConstant() || constants[i]->AsVectorConstant()->IsZero()) { has_zero_operand = true; break; } } } if (has_zero_operand) { if (float_type->width() == 32) { utils::FloatProxy result(0.0f); std::vector words = result.GetWords(); return const_mgr->GetConstant(float_type, words); } if (float_type->width() == 64) { utils::FloatProxy result(0.0); std::vector words = result.GetWords(); return const_mgr->GetConstant(float_type, words); } return nullptr; } if (constants[0] == nullptr || constants[1] == nullptr) { return nullptr; } std::vector a_components; std::vector b_components; a_components = constants[0]->GetVectorComponents(const_mgr); b_components = constants[1]->GetVectorComponents(const_mgr); utils::FloatProxy result(0.0); std::vector words = result.GetWords(); const analysis::Constant* result_const = const_mgr->GetConstant(float_type, words); for (uint32_t i = 0; i < a_components.size() && result_const != nullptr; ++i) { if (a_components[i] == nullptr || b_components[i] == nullptr) { return nullptr; } const analysis::Constant* component = FOLD_FPARITH_OP(*)( new_type, a_components[i], b_components[i], const_mgr); if (component == nullptr) { return nullptr; } result_const = FOLD_FPARITH_OP(+)(new_type, result_const, component, const_mgr); } return result_const; }; } ConstantFoldingRule FoldFNegate() { return FoldFPUnaryOp(NegateFPConst); } ConstantFoldingRule FoldSNegate() { return FoldUnaryOp(NegateIntConst); } ConstantFoldingRule FoldFClampFeedingCompare(spv::Op cmp_opcode) { return [cmp_opcode](IRContext* context, Instruction* inst, const std::vector& constants) -> const analysis::Constant* { analysis::ConstantManager* const_mgr = context->get_constant_mgr(); analysis::DefUseManager* def_use_mgr = context->get_def_use_mgr(); if (!inst->IsFloatingPointFoldingAllowed()) { return nullptr; } uint32_t non_const_idx = (constants[0] ? 1 : 0); uint32_t operand_id = inst->GetSingleWordInOperand(non_const_idx); Instruction* operand_inst = def_use_mgr->GetDef(operand_id); analysis::TypeManager* type_mgr = context->get_type_mgr(); const analysis::Type* operand_type = type_mgr->GetType(operand_inst->type_id()); if (!operand_type->AsFloat()) { return nullptr; } if (operand_type->AsFloat()->width() != 32 && operand_type->AsFloat()->width() != 64) { return nullptr; } if (operand_inst->opcode() != spv::Op::OpExtInst) { return nullptr; } if (operand_inst->GetSingleWordInOperand(1) != GLSLstd450FClamp) { return nullptr; } if (constants[1] == nullptr && constants[0] == nullptr) { return nullptr; } uint32_t max_id = operand_inst->GetSingleWordInOperand(4); const analysis::Constant* max_const = const_mgr->FindDeclaredConstant(max_id); uint32_t min_id = operand_inst->GetSingleWordInOperand(3); const analysis::Constant* min_const = const_mgr->FindDeclaredConstant(min_id); bool found_result = false; bool result = false; switch (cmp_opcode) { case spv::Op::OpFOrdLessThan: case spv::Op::OpFUnordLessThan: case spv::Op::OpFOrdGreaterThanEqual: case spv::Op::OpFUnordGreaterThanEqual: if (constants[0]) { if (min_const) { if (constants[0]->GetValueAsDouble() < min_const->GetValueAsDouble()) { found_result = true; result = (cmp_opcode == spv::Op::OpFOrdLessThan || cmp_opcode == spv::Op::OpFUnordLessThan); } } if (max_const) { if (constants[0]->GetValueAsDouble() >= max_const->GetValueAsDouble()) { found_result = true; result = !(cmp_opcode == spv::Op::OpFOrdLessThan || cmp_opcode == spv::Op::OpFUnordLessThan); } } } if (constants[1]) { if (max_const) { if (max_const->GetValueAsDouble() < constants[1]->GetValueAsDouble()) { found_result = true; result = (cmp_opcode == spv::Op::OpFOrdLessThan || cmp_opcode == spv::Op::OpFUnordLessThan); } } if (min_const) { if (min_const->GetValueAsDouble() >= constants[1]->GetValueAsDouble()) { found_result = true; result = !(cmp_opcode == spv::Op::OpFOrdLessThan || cmp_opcode == spv::Op::OpFUnordLessThan); } } } break; case spv::Op::OpFOrdGreaterThan: case spv::Op::OpFUnordGreaterThan: case spv::Op::OpFOrdLessThanEqual: case spv::Op::OpFUnordLessThanEqual: if (constants[0]) { if (min_const) { if (constants[0]->GetValueAsDouble() <= min_const->GetValueAsDouble()) { found_result = true; result = (cmp_opcode == spv::Op::OpFOrdLessThanEqual || cmp_opcode == spv::Op::OpFUnordLessThanEqual); } } if (max_const) { if (constants[0]->GetValueAsDouble() > max_const->GetValueAsDouble()) { found_result = true; result = !(cmp_opcode == spv::Op::OpFOrdLessThanEqual || cmp_opcode == spv::Op::OpFUnordLessThanEqual); } } } if (constants[1]) { if (max_const) { if (max_const->GetValueAsDouble() <= constants[1]->GetValueAsDouble()) { found_result = true; result = (cmp_opcode == spv::Op::OpFOrdLessThanEqual || cmp_opcode == spv::Op::OpFUnordLessThanEqual); } } if (min_const) { if (min_const->GetValueAsDouble() > constants[1]->GetValueAsDouble()) { found_result = true; result = !(cmp_opcode == spv::Op::OpFOrdLessThanEqual || cmp_opcode == spv::Op::OpFUnordLessThanEqual); } } } break; default: return nullptr; } if (!found_result) { return nullptr; } const analysis::Type* bool_type = context->get_type_mgr()->GetType(inst->type_id()); const analysis::Constant* result_const = const_mgr->GetConstant(bool_type, {static_cast(result)}); assert(result_const); return result_const; }; } ConstantFoldingRule FoldFMix() { return [](IRContext* context, Instruction* inst, const std::vector& constants) -> const analysis::Constant* { analysis::ConstantManager* const_mgr = context->get_constant_mgr(); assert(inst->opcode() == spv::Op::OpExtInst && "Expecting an extended instruction."); assert(inst->GetSingleWordInOperand(0) == context->get_feature_mgr()->GetExtInstImportId_GLSLstd450() && "Expecting a GLSLstd450 extended instruction."); assert(inst->GetSingleWordInOperand(1) == GLSLstd450FMix && "Expecting and FMix instruction."); if (!inst->IsFloatingPointFoldingAllowed()) { return nullptr; } // Make sure all FMix operands are constants. for (uint32_t i = 1; i < 4; i++) { if (constants[i] == nullptr) { return nullptr; } } const analysis::Constant* one; bool is_vector = false; const analysis::Type* result_type = constants[1]->type(); const analysis::Type* base_type = result_type; if (base_type->AsVector()) { is_vector = true; base_type = base_type->AsVector()->element_type(); } assert(base_type->AsFloat() != nullptr && "FMix is suppose to act on floats or vectors of floats."); if (base_type->AsFloat()->width() == 32) { one = const_mgr->GetConstant(base_type, utils::FloatProxy(1.0f).GetWords()); } else { one = const_mgr->GetConstant(base_type, utils::FloatProxy(1.0).GetWords()); } if (is_vector) { uint32_t one_id = const_mgr->GetDefiningInstruction(one)->result_id(); one = const_mgr->GetConstant(result_type, std::vector(4, one_id)); } const analysis::Constant* temp1 = FoldFPBinaryOp( FOLD_FPARITH_OP(-), inst->type_id(), {one, constants[3]}, context); if (temp1 == nullptr) { return nullptr; } const analysis::Constant* temp2 = FoldFPBinaryOp( FOLD_FPARITH_OP(*), inst->type_id(), {constants[1], temp1}, context); if (temp2 == nullptr) { return nullptr; } const analysis::Constant* temp3 = FoldFPBinaryOp(FOLD_FPARITH_OP(*), inst->type_id(), {constants[2], constants[3]}, context); if (temp3 == nullptr) { return nullptr; } return FoldFPBinaryOp(FOLD_FPARITH_OP(+), inst->type_id(), {temp2, temp3}, context); }; } const analysis::Constant* FoldMin(const analysis::Type* result_type, const analysis::Constant* a, const analysis::Constant* b, analysis::ConstantManager*) { if (const analysis::Integer* int_type = result_type->AsInteger()) { if (int_type->width() == 32) { if (int_type->IsSigned()) { int32_t va = a->GetS32(); int32_t vb = b->GetS32(); return (va < vb ? a : b); } else { uint32_t va = a->GetU32(); uint32_t vb = b->GetU32(); return (va < vb ? a : b); } } else if (int_type->width() == 64) { if (int_type->IsSigned()) { int64_t va = a->GetS64(); int64_t vb = b->GetS64(); return (va < vb ? a : b); } else { uint64_t va = a->GetU64(); uint64_t vb = b->GetU64(); return (va < vb ? a : b); } } } else if (const analysis::Float* float_type = result_type->AsFloat()) { if (float_type->width() == 32) { float va = a->GetFloat(); float vb = b->GetFloat(); return (va < vb ? a : b); } else if (float_type->width() == 64) { double va = a->GetDouble(); double vb = b->GetDouble(); return (va < vb ? a : b); } } return nullptr; } const analysis::Constant* FoldMax(const analysis::Type* result_type, const analysis::Constant* a, const analysis::Constant* b, analysis::ConstantManager*) { if (const analysis::Integer* int_type = result_type->AsInteger()) { if (int_type->width() == 32) { if (int_type->IsSigned()) { int32_t va = a->GetS32(); int32_t vb = b->GetS32(); return (va > vb ? a : b); } else { uint32_t va = a->GetU32(); uint32_t vb = b->GetU32(); return (va > vb ? a : b); } } else if (int_type->width() == 64) { if (int_type->IsSigned()) { int64_t va = a->GetS64(); int64_t vb = b->GetS64(); return (va > vb ? a : b); } else { uint64_t va = a->GetU64(); uint64_t vb = b->GetU64(); return (va > vb ? a : b); } } } else if (const analysis::Float* float_type = result_type->AsFloat()) { if (float_type->width() == 32) { float va = a->GetFloat(); float vb = b->GetFloat(); return (va > vb ? a : b); } else if (float_type->width() == 64) { double va = a->GetDouble(); double vb = b->GetDouble(); return (va > vb ? a : b); } } return nullptr; } // Fold an clamp instruction when all three operands are constant. const analysis::Constant* FoldClamp1( IRContext* context, Instruction* inst, const std::vector& constants) { assert(inst->opcode() == spv::Op::OpExtInst && "Expecting an extended instruction."); assert(inst->GetSingleWordInOperand(0) == context->get_feature_mgr()->GetExtInstImportId_GLSLstd450() && "Expecting a GLSLstd450 extended instruction."); // Make sure all Clamp operands are constants. for (uint32_t i = 1; i < 4; i++) { if (constants[i] == nullptr) { return nullptr; } } const analysis::Constant* temp = FoldFPBinaryOp( FoldMax, inst->type_id(), {constants[1], constants[2]}, context); if (temp == nullptr) { return nullptr; } return FoldFPBinaryOp(FoldMin, inst->type_id(), {temp, constants[3]}, context); } // Fold a clamp instruction when |x <= min_val|. const analysis::Constant* FoldClamp2( IRContext* context, Instruction* inst, const std::vector& constants) { assert(inst->opcode() == spv::Op::OpExtInst && "Expecting an extended instruction."); assert(inst->GetSingleWordInOperand(0) == context->get_feature_mgr()->GetExtInstImportId_GLSLstd450() && "Expecting a GLSLstd450 extended instruction."); const analysis::Constant* x = constants[1]; const analysis::Constant* min_val = constants[2]; if (x == nullptr || min_val == nullptr) { return nullptr; } const analysis::Constant* temp = FoldFPBinaryOp(FoldMax, inst->type_id(), {x, min_val}, context); if (temp == min_val) { // We can assume that |min_val| is less than |max_val|. Therefore, if the // result of the max operation is |min_val|, we know the result of the min // operation, even if |max_val| is not a constant. return min_val; } return nullptr; } // Fold a clamp instruction when |x >= max_val|. const analysis::Constant* FoldClamp3( IRContext* context, Instruction* inst, const std::vector& constants) { assert(inst->opcode() == spv::Op::OpExtInst && "Expecting an extended instruction."); assert(inst->GetSingleWordInOperand(0) == context->get_feature_mgr()->GetExtInstImportId_GLSLstd450() && "Expecting a GLSLstd450 extended instruction."); const analysis::Constant* x = constants[1]; const analysis::Constant* max_val = constants[3]; if (x == nullptr || max_val == nullptr) { return nullptr; } const analysis::Constant* temp = FoldFPBinaryOp(FoldMin, inst->type_id(), {x, max_val}, context); if (temp == max_val) { // We can assume that |min_val| is less than |max_val|. Therefore, if the // result of the max operation is |min_val|, we know the result of the min // operation, even if |max_val| is not a constant. return max_val; } return nullptr; } UnaryScalarFoldingRule FoldFTranscendentalUnary(double (*fp)(double)) { return [fp](const analysis::Type* result_type, const analysis::Constant* a, analysis::ConstantManager* const_mgr) -> const analysis::Constant* { assert(result_type != nullptr && a != nullptr); const analysis::Float* float_type = a->type()->AsFloat(); assert(float_type != nullptr); assert(float_type == result_type->AsFloat()); if (float_type->width() == 32) { float fa = a->GetFloat(); float res = static_cast(fp(fa)); utils::FloatProxy result(res); std::vector words = result.GetWords(); return const_mgr->GetConstant(result_type, words); } else if (float_type->width() == 64) { double fa = a->GetDouble(); double res = fp(fa); utils::FloatProxy result(res); std::vector words = result.GetWords(); return const_mgr->GetConstant(result_type, words); } return nullptr; }; } BinaryScalarFoldingRule FoldFTranscendentalBinary(double (*fp)(double, double)) { return [fp](const analysis::Type* result_type, const analysis::Constant* a, const analysis::Constant* b, analysis::ConstantManager* const_mgr) -> const analysis::Constant* { assert(result_type != nullptr && a != nullptr); const analysis::Float* float_type = a->type()->AsFloat(); assert(float_type != nullptr); assert(float_type == result_type->AsFloat()); assert(float_type == b->type()->AsFloat()); if (float_type->width() == 32) { float fa = a->GetFloat(); float fb = b->GetFloat(); float res = static_cast(fp(fa, fb)); utils::FloatProxy result(res); std::vector words = result.GetWords(); return const_mgr->GetConstant(result_type, words); } else if (float_type->width() == 64) { double fa = a->GetDouble(); double fb = b->GetDouble(); double res = fp(fa, fb); utils::FloatProxy result(res); std::vector words = result.GetWords(); return const_mgr->GetConstant(result_type, words); } return nullptr; }; } enum Sign { Signed, Unsigned }; // Returns a BinaryScalarFoldingRule that applies `op` to the scalars. // The `signedness` is used to determine if the operands should be interpreted // as signed or unsigned. If the operands are signed, the value will be sign // extended before the value is passed to `op`. Otherwise the values will be // zero extended. template BinaryScalarFoldingRule FoldBinaryIntegerOperation(uint64_t (*op)(uint64_t, uint64_t)) { return [op](const analysis::Type* result_type, const analysis::Constant* a, const analysis::Constant* b, analysis::ConstantManager* const_mgr) -> const analysis::Constant* { assert(result_type != nullptr && a != nullptr && b != nullptr); const analysis::Integer* integer_type = result_type->AsInteger(); assert(integer_type != nullptr); assert(a->type()->kind() == analysis::Type::kInteger); assert(b->type()->kind() == analysis::Type::kInteger); assert(integer_type->width() == a->type()->AsInteger()->width()); assert(integer_type->width() == b->type()->AsInteger()->width()); // In SPIR-V, all operations support unsigned types, but the way they // are interpreted depends on the opcode. This is why we use the // template argument to determine how to interpret the operands. uint64_t ia = (signedness == Signed ? a->GetSignExtendedValue() : a->GetZeroExtendedValue()); uint64_t ib = (signedness == Signed ? b->GetSignExtendedValue() : b->GetZeroExtendedValue()); uint64_t result = op(ia, ib); const analysis::Constant* result_constant = const_mgr->GenerateIntegerConstant(integer_type, result); return result_constant; }; } // A scalar folding rule that folds OpSConvert. const analysis::Constant* FoldScalarSConvert( const analysis::Type* result_type, const analysis::Constant* a, analysis::ConstantManager* const_mgr) { assert(result_type != nullptr); assert(a != nullptr); assert(const_mgr != nullptr); const analysis::Integer* integer_type = result_type->AsInteger(); assert(integer_type && "The result type of an SConvert"); int64_t value = a->GetSignExtendedValue(); return const_mgr->GenerateIntegerConstant(integer_type, value); } // A scalar folding rule that folds OpUConvert. const analysis::Constant* FoldScalarUConvert( const analysis::Type* result_type, const analysis::Constant* a, analysis::ConstantManager* const_mgr) { assert(result_type != nullptr); assert(a != nullptr); assert(const_mgr != nullptr); const analysis::Integer* integer_type = result_type->AsInteger(); assert(integer_type && "The result type of an UConvert"); uint64_t value = a->GetZeroExtendedValue(); // If the operand was an unsigned value with less than 32-bit, it would have // been sign extended earlier, and we need to clear those bits. auto* operand_type = a->type()->AsInteger(); value = utils::ClearHighBits(value, 64 - operand_type->width()); return const_mgr->GenerateIntegerConstant(integer_type, value); } } // namespace void ConstantFoldingRules::AddFoldingRules() { // Add all folding rules to the list for the opcodes to which they apply. // Note that the order in which rules are added to the list matters. If a rule // applies to the instruction, the rest of the rules will not be attempted. // Take that into consideration. rules_[spv::Op::OpCompositeConstruct].push_back(FoldCompositeWithConstants()); rules_[spv::Op::OpCompositeExtract].push_back(FoldExtractWithConstants()); rules_[spv::Op::OpCompositeInsert].push_back(FoldInsertWithConstants()); rules_[spv::Op::OpConvertFToS].push_back(FoldFToI()); rules_[spv::Op::OpConvertFToU].push_back(FoldFToI()); rules_[spv::Op::OpConvertSToF].push_back(FoldIToF()); rules_[spv::Op::OpConvertUToF].push_back(FoldIToF()); rules_[spv::Op::OpSConvert].push_back(FoldUnaryOp(FoldScalarSConvert)); rules_[spv::Op::OpUConvert].push_back(FoldUnaryOp(FoldScalarUConvert)); rules_[spv::Op::OpDot].push_back(FoldOpDotWithConstants()); rules_[spv::Op::OpFAdd].push_back(FoldFAdd()); rules_[spv::Op::OpFDiv].push_back(FoldFDiv()); rules_[spv::Op::OpFMul].push_back(FoldFMul()); rules_[spv::Op::OpFSub].push_back(FoldFSub()); rules_[spv::Op::OpFOrdEqual].push_back(FoldFOrdEqual()); rules_[spv::Op::OpFUnordEqual].push_back(FoldFUnordEqual()); rules_[spv::Op::OpFOrdNotEqual].push_back(FoldFOrdNotEqual()); rules_[spv::Op::OpFUnordNotEqual].push_back(FoldFUnordNotEqual()); rules_[spv::Op::OpFOrdLessThan].push_back(FoldFOrdLessThan()); rules_[spv::Op::OpFOrdLessThan].push_back( FoldFClampFeedingCompare(spv::Op::OpFOrdLessThan)); rules_[spv::Op::OpFUnordLessThan].push_back(FoldFUnordLessThan()); rules_[spv::Op::OpFUnordLessThan].push_back( FoldFClampFeedingCompare(spv::Op::OpFUnordLessThan)); rules_[spv::Op::OpFOrdGreaterThan].push_back(FoldFOrdGreaterThan()); rules_[spv::Op::OpFOrdGreaterThan].push_back( FoldFClampFeedingCompare(spv::Op::OpFOrdGreaterThan)); rules_[spv::Op::OpFUnordGreaterThan].push_back(FoldFUnordGreaterThan()); rules_[spv::Op::OpFUnordGreaterThan].push_back( FoldFClampFeedingCompare(spv::Op::OpFUnordGreaterThan)); rules_[spv::Op::OpFOrdLessThanEqual].push_back(FoldFOrdLessThanEqual()); rules_[spv::Op::OpFOrdLessThanEqual].push_back( FoldFClampFeedingCompare(spv::Op::OpFOrdLessThanEqual)); rules_[spv::Op::OpFUnordLessThanEqual].push_back(FoldFUnordLessThanEqual()); rules_[spv::Op::OpFUnordLessThanEqual].push_back( FoldFClampFeedingCompare(spv::Op::OpFUnordLessThanEqual)); rules_[spv::Op::OpFOrdGreaterThanEqual].push_back(FoldFOrdGreaterThanEqual()); rules_[spv::Op::OpFOrdGreaterThanEqual].push_back( FoldFClampFeedingCompare(spv::Op::OpFOrdGreaterThanEqual)); rules_[spv::Op::OpFUnordGreaterThanEqual].push_back( FoldFUnordGreaterThanEqual()); rules_[spv::Op::OpFUnordGreaterThanEqual].push_back( FoldFClampFeedingCompare(spv::Op::OpFUnordGreaterThanEqual)); rules_[spv::Op::OpVectorShuffle].push_back(FoldVectorShuffleWithConstants()); rules_[spv::Op::OpVectorTimesScalar].push_back(FoldVectorTimesScalar()); rules_[spv::Op::OpVectorTimesMatrix].push_back(FoldVectorTimesMatrix()); rules_[spv::Op::OpMatrixTimesVector].push_back(FoldMatrixTimesVector()); rules_[spv::Op::OpTranspose].push_back(FoldTranspose); rules_[spv::Op::OpFNegate].push_back(FoldFNegate()); rules_[spv::Op::OpSNegate].push_back(FoldSNegate()); rules_[spv::Op::OpQuantizeToF16].push_back(FoldQuantizeToF16()); rules_[spv::Op::OpIAdd].push_back( FoldBinaryOp(FoldBinaryIntegerOperation( [](uint64_t a, uint64_t b) { return a + b; }))); rules_[spv::Op::OpISub].push_back( FoldBinaryOp(FoldBinaryIntegerOperation( [](uint64_t a, uint64_t b) { return a - b; }))); rules_[spv::Op::OpIMul].push_back( FoldBinaryOp(FoldBinaryIntegerOperation( [](uint64_t a, uint64_t b) { return a * b; }))); rules_[spv::Op::OpUDiv].push_back( FoldBinaryOp(FoldBinaryIntegerOperation( [](uint64_t a, uint64_t b) { return (b != 0 ? a / b : 0); }))); rules_[spv::Op::OpSDiv].push_back(FoldBinaryOp( FoldBinaryIntegerOperation([](uint64_t a, uint64_t b) { return (b != 0 ? static_cast(static_cast(a) / static_cast(b)) : 0); }))); rules_[spv::Op::OpUMod].push_back( FoldBinaryOp(FoldBinaryIntegerOperation( [](uint64_t a, uint64_t b) { return (b != 0 ? a % b : 0); }))); rules_[spv::Op::OpSRem].push_back(FoldBinaryOp( FoldBinaryIntegerOperation([](uint64_t a, uint64_t b) { return (b != 0 ? static_cast(static_cast(a) % static_cast(b)) : 0); }))); rules_[spv::Op::OpSMod].push_back(FoldBinaryOp( FoldBinaryIntegerOperation([](uint64_t a, uint64_t b) { if (b == 0) return static_cast(0ull); int64_t signed_a = static_cast(a); int64_t signed_b = static_cast(b); int64_t result = signed_a % signed_b; if ((signed_b < 0) != (result < 0)) result += signed_b; return static_cast(result); }))); // Add rules for GLSLstd450 FeatureManager* feature_manager = context_->get_feature_mgr(); uint32_t ext_inst_glslstd450_id = feature_manager->GetExtInstImportId_GLSLstd450(); if (ext_inst_glslstd450_id != 0) { ext_rules_[{ext_inst_glslstd450_id, GLSLstd450FMix}].push_back(FoldFMix()); ext_rules_[{ext_inst_glslstd450_id, GLSLstd450SMin}].push_back( FoldFPBinaryOp(FoldMin)); ext_rules_[{ext_inst_glslstd450_id, GLSLstd450UMin}].push_back( FoldFPBinaryOp(FoldMin)); ext_rules_[{ext_inst_glslstd450_id, GLSLstd450FMin}].push_back( FoldFPBinaryOp(FoldMin)); ext_rules_[{ext_inst_glslstd450_id, GLSLstd450SMax}].push_back( FoldFPBinaryOp(FoldMax)); ext_rules_[{ext_inst_glslstd450_id, GLSLstd450UMax}].push_back( FoldFPBinaryOp(FoldMax)); ext_rules_[{ext_inst_glslstd450_id, GLSLstd450FMax}].push_back( FoldFPBinaryOp(FoldMax)); ext_rules_[{ext_inst_glslstd450_id, GLSLstd450UClamp}].push_back( FoldClamp1); ext_rules_[{ext_inst_glslstd450_id, GLSLstd450UClamp}].push_back( FoldClamp2); ext_rules_[{ext_inst_glslstd450_id, GLSLstd450UClamp}].push_back( FoldClamp3); ext_rules_[{ext_inst_glslstd450_id, GLSLstd450SClamp}].push_back( FoldClamp1); ext_rules_[{ext_inst_glslstd450_id, GLSLstd450SClamp}].push_back( FoldClamp2); ext_rules_[{ext_inst_glslstd450_id, GLSLstd450SClamp}].push_back( FoldClamp3); ext_rules_[{ext_inst_glslstd450_id, GLSLstd450FClamp}].push_back( FoldClamp1); ext_rules_[{ext_inst_glslstd450_id, GLSLstd450FClamp}].push_back( FoldClamp2); ext_rules_[{ext_inst_glslstd450_id, GLSLstd450FClamp}].push_back( FoldClamp3); ext_rules_[{ext_inst_glslstd450_id, GLSLstd450Sin}].push_back( FoldFPUnaryOp(FoldFTranscendentalUnary(std::sin))); ext_rules_[{ext_inst_glslstd450_id, GLSLstd450Cos}].push_back( FoldFPUnaryOp(FoldFTranscendentalUnary(std::cos))); ext_rules_[{ext_inst_glslstd450_id, GLSLstd450Tan}].push_back( FoldFPUnaryOp(FoldFTranscendentalUnary(std::tan))); ext_rules_[{ext_inst_glslstd450_id, GLSLstd450Asin}].push_back( FoldFPUnaryOp(FoldFTranscendentalUnary(std::asin))); ext_rules_[{ext_inst_glslstd450_id, GLSLstd450Acos}].push_back( FoldFPUnaryOp(FoldFTranscendentalUnary(std::acos))); ext_rules_[{ext_inst_glslstd450_id, GLSLstd450Atan}].push_back( FoldFPUnaryOp(FoldFTranscendentalUnary(std::atan))); ext_rules_[{ext_inst_glslstd450_id, GLSLstd450Exp}].push_back( FoldFPUnaryOp(FoldFTranscendentalUnary(std::exp))); ext_rules_[{ext_inst_glslstd450_id, GLSLstd450Log}].push_back( FoldFPUnaryOp(FoldFTranscendentalUnary(std::log))); #ifdef __ANDROID__ // Android NDK r15c targeting ABI 15 doesn't have full support for C++11 // (no std::exp2/log2). ::exp2 is available from C99 but ::log2 isn't // available up until ABI 18 so we use a shim auto log2_shim = [](double v) -> double { return log(v) / log(2.0); }; ext_rules_[{ext_inst_glslstd450_id, GLSLstd450Exp2}].push_back( FoldFPUnaryOp(FoldFTranscendentalUnary(::exp2))); ext_rules_[{ext_inst_glslstd450_id, GLSLstd450Log2}].push_back( FoldFPUnaryOp(FoldFTranscendentalUnary(log2_shim))); #else ext_rules_[{ext_inst_glslstd450_id, GLSLstd450Exp2}].push_back( FoldFPUnaryOp(FoldFTranscendentalUnary(std::exp2))); ext_rules_[{ext_inst_glslstd450_id, GLSLstd450Log2}].push_back( FoldFPUnaryOp(FoldFTranscendentalUnary(std::log2))); #endif ext_rules_[{ext_inst_glslstd450_id, GLSLstd450Sqrt}].push_back( FoldFPUnaryOp(FoldFTranscendentalUnary(std::sqrt))); ext_rules_[{ext_inst_glslstd450_id, GLSLstd450Atan2}].push_back( FoldFPBinaryOp(FoldFTranscendentalBinary(std::atan2))); ext_rules_[{ext_inst_glslstd450_id, GLSLstd450Pow}].push_back( FoldFPBinaryOp(FoldFTranscendentalBinary(std::pow))); } } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/const_folding_rules.h000066400000000000000000000107071475742701700250530ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_CONST_FOLDING_RULES_H_ #define SOURCE_OPT_CONST_FOLDING_RULES_H_ #include #include #include "source/opt/constants.h" namespace spvtools { namespace opt { // Constant Folding Rules: // // The folding mechanism is built around the concept of a |ConstantFoldingRule|. // A constant folding rule is a function that implements a method of simplifying // an instruction to a constant. // // The inputs to a folding rule are: // |inst| - the instruction to be simplified. // |constants| - if an in-operands is an id of a constant, then the // corresponding value in |constants| contains that // constant value. Otherwise, the corresponding entry in // |constants| is |nullptr|. // // A constant folding rule returns a pointer to an Constant if |inst| can be // simplified using this rule. Otherwise, it returns |nullptr|. // // See const_folding_rules.cpp for examples on how to write a constant folding // rule. // // Be sure to add new constant folding rules to the table of constant folding // rules in the constructor for ConstantFoldingRules. The new rule should be // added to the list for every opcode that it applies to. Note that earlier // rules in the list are given priority. That is, if an earlier rule is able to // fold an instruction, the later rules will not be attempted. using ConstantFoldingRule = std::function& constants)>; class ConstantFoldingRules { protected: // The |Key| and |Value| structs are used to by-pass a "decorated name length // exceeded, name was truncated" warning on VS2013 and VS2015. struct Key { uint32_t instruction_set; uint32_t opcode; }; friend bool operator<(const Key& a, const Key& b) { if (a.instruction_set < b.instruction_set) { return true; } if (a.instruction_set > b.instruction_set) { return false; } return a.opcode < b.opcode; } struct Value { std::vector value; void push_back(ConstantFoldingRule rule) { value.push_back(rule); } }; public: ConstantFoldingRules(IRContext* ctx) : context_(ctx) {} virtual ~ConstantFoldingRules() = default; // Returns true if there is at least 1 folding rule for |opcode|. bool HasFoldingRule(const Instruction* inst) const { return !GetRulesForInstruction(inst).empty(); } // Returns true if there is at least 1 folding rule for |inst|. const std::vector& GetRulesForInstruction( const Instruction* inst) const { if (inst->opcode() != spv::Op::OpExtInst) { auto it = rules_.find(inst->opcode()); if (it != rules_.end()) { return it->second.value; } } else { uint32_t ext_inst_id = inst->GetSingleWordInOperand(0); uint32_t ext_opcode = inst->GetSingleWordInOperand(1); auto it = ext_rules_.find({ext_inst_id, ext_opcode}); if (it != ext_rules_.end()) { return it->second.value; } } return empty_vector_; } // Add the folding rules. virtual void AddFoldingRules(); protected: struct hasher { size_t operator()(const spv::Op& op) const noexcept { return std::hash()(uint32_t(op)); } }; // |rules[opcode]| is the set of rules that can be applied to instructions // with |opcode| as the opcode. std::unordered_map rules_; // The folding rules for extended instructions. std::map ext_rules_; private: // The context that the instruction to be folded will be a part of. IRContext* context_; // The empty set of rules to be used as the default return value in // |GetRulesForInstruction|. std::vector empty_vector_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_CONST_FOLDING_RULES_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/constants.cpp000066400000000000000000000475111475742701700233630ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/constants.h" #include #include "source/opt/ir_context.h" namespace spvtools { namespace opt { namespace analysis { float Constant::GetFloat() const { assert(type()->AsFloat() != nullptr && type()->AsFloat()->width() == 32); if (const FloatConstant* fc = AsFloatConstant()) { return fc->GetFloatValue(); } else { assert(AsNullConstant() && "Must be a floating point constant."); return 0.0f; } } double Constant::GetDouble() const { assert(type()->AsFloat() != nullptr && type()->AsFloat()->width() == 64); if (const FloatConstant* fc = AsFloatConstant()) { return fc->GetDoubleValue(); } else { assert(AsNullConstant() && "Must be a floating point constant."); return 0.0; } } double Constant::GetValueAsDouble() const { assert(type()->AsFloat() != nullptr); if (type()->AsFloat()->width() == 32) { return GetFloat(); } else { assert(type()->AsFloat()->width() == 64); return GetDouble(); } } uint32_t Constant::GetU32() const { assert(type()->AsInteger() != nullptr); assert(type()->AsInteger()->width() == 32); if (const IntConstant* ic = AsIntConstant()) { return ic->GetU32BitValue(); } else { assert(AsNullConstant() && "Must be an integer constant."); return 0u; } } uint64_t Constant::GetU64() const { assert(type()->AsInteger() != nullptr); assert(type()->AsInteger()->width() == 64); if (const IntConstant* ic = AsIntConstant()) { return ic->GetU64BitValue(); } else { assert(AsNullConstant() && "Must be an integer constant."); return 0u; } } int32_t Constant::GetS32() const { assert(type()->AsInteger() != nullptr); assert(type()->AsInteger()->width() == 32); if (const IntConstant* ic = AsIntConstant()) { return ic->GetS32BitValue(); } else { assert(AsNullConstant() && "Must be an integer constant."); return 0; } } int64_t Constant::GetS64() const { assert(type()->AsInteger() != nullptr); assert(type()->AsInteger()->width() == 64); if (const IntConstant* ic = AsIntConstant()) { return ic->GetS64BitValue(); } else { assert(AsNullConstant() && "Must be an integer constant."); return 0; } } uint64_t Constant::GetZeroExtendedValue() const { const auto* int_type = type()->AsInteger(); assert(int_type != nullptr); const auto width = int_type->width(); assert(width <= 64); uint64_t value = 0; if (const IntConstant* ic = AsIntConstant()) { if (width <= 32) { value = ic->GetU32BitValue(); } else { value = ic->GetU64BitValue(); } } else { assert(AsNullConstant() && "Must be an integer constant."); } return value; } int64_t Constant::GetSignExtendedValue() const { const auto* int_type = type()->AsInteger(); assert(int_type != nullptr); const auto width = int_type->width(); assert(width <= 64); int64_t value = 0; if (const IntConstant* ic = AsIntConstant()) { if (width <= 32) { // Let the C++ compiler do the sign extension. value = int64_t(ic->GetS32BitValue()); } else { value = ic->GetS64BitValue(); } } else { assert(AsNullConstant() && "Must be an integer constant."); } return value; } ConstantManager::ConstantManager(IRContext* ctx) : ctx_(ctx) { // Populate the constant table with values from constant declarations in the // module. The values of each OpConstant declaration is the identity // assignment (i.e., each constant is its own value). for (const auto& inst : ctx_->module()->GetConstants()) { MapInst(inst); } } Type* ConstantManager::GetType(const Instruction* inst) const { return context()->get_type_mgr()->GetType(inst->type_id()); } std::vector ConstantManager::GetOperandConstants( const Instruction* inst) const { std::vector constants; constants.reserve(inst->NumInOperands()); for (uint32_t i = 0; i < inst->NumInOperands(); i++) { const Operand* operand = &inst->GetInOperand(i); if (operand->type != SPV_OPERAND_TYPE_ID) { constants.push_back(nullptr); } else { uint32_t id = operand->words[0]; const analysis::Constant* constant = FindDeclaredConstant(id); constants.push_back(constant); } } return constants; } uint32_t ConstantManager::FindDeclaredConstant(const Constant* c, uint32_t type_id) const { c = FindConstant(c); if (c == nullptr) { return 0; } for (auto range = const_val_to_id_.equal_range(c); range.first != range.second; ++range.first) { Instruction* const_def = context()->get_def_use_mgr()->GetDef(range.first->second); if (type_id == 0 || const_def->type_id() == type_id) { return range.first->second; } } return 0; } std::vector ConstantManager::GetConstantsFromIds( const std::vector& ids) const { std::vector constants; for (uint32_t id : ids) { if (const Constant* c = FindDeclaredConstant(id)) { constants.push_back(c); } else { return {}; } } return constants; } Instruction* ConstantManager::BuildInstructionAndAddToModule( const Constant* new_const, Module::inst_iterator* pos, uint32_t type_id) { // TODO(1841): Handle id overflow. uint32_t new_id = context()->TakeNextId(); if (new_id == 0) { return nullptr; } auto new_inst = CreateInstruction(new_id, new_const, type_id); if (!new_inst) { return nullptr; } auto* new_inst_ptr = new_inst.get(); *pos = pos->InsertBefore(std::move(new_inst)); ++(*pos); if (context()->AreAnalysesValid(IRContext::Analysis::kAnalysisDefUse)) context()->get_def_use_mgr()->AnalyzeInstDefUse(new_inst_ptr); MapConstantToInst(new_const, new_inst_ptr); return new_inst_ptr; } Instruction* ConstantManager::GetDefiningInstruction( const Constant* c, uint32_t type_id, Module::inst_iterator* pos) { uint32_t decl_id = FindDeclaredConstant(c, type_id); if (decl_id == 0) { auto iter = context()->types_values_end(); if (pos == nullptr) pos = &iter; return BuildInstructionAndAddToModule(c, pos, type_id); } else { auto def = context()->get_def_use_mgr()->GetDef(decl_id); assert(def != nullptr); assert((type_id == 0 || def->type_id() == type_id) && "This constant already has an instruction with a different type."); return def; } } std::unique_ptr ConstantManager::CreateConstant( const Type* type, const std::vector& literal_words_or_ids) const { if (literal_words_or_ids.size() == 0) { // Constant declared with OpConstantNull return MakeUnique(type); } else if (auto* bt = type->AsBool()) { assert(literal_words_or_ids.size() == 1 && "Bool constant should be declared with one operand"); return MakeUnique(bt, literal_words_or_ids.front()); } else if (auto* it = type->AsInteger()) { return MakeUnique(it, literal_words_or_ids); } else if (auto* ft = type->AsFloat()) { return MakeUnique(ft, literal_words_or_ids); } else if (auto* vt = type->AsVector()) { auto components = GetConstantsFromIds(literal_words_or_ids); if (components.empty()) return nullptr; // All components of VectorConstant must be of type Bool, Integer or Float. if (!std::all_of(components.begin(), components.end(), [](const Constant* c) { if (c->type()->AsBool() || c->type()->AsInteger() || c->type()->AsFloat()) { return true; } else { return false; } })) return nullptr; // All components of VectorConstant must be in the same type. const auto* component_type = components.front()->type(); if (!std::all_of(components.begin(), components.end(), [&component_type](const Constant* c) { if (c->type() == component_type) return true; return false; })) return nullptr; return MakeUnique(vt, components); } else if (auto* mt = type->AsMatrix()) { auto components = GetConstantsFromIds(literal_words_or_ids); if (components.empty()) return nullptr; return MakeUnique(mt, components); } else if (auto* st = type->AsStruct()) { auto components = GetConstantsFromIds(literal_words_or_ids); if (components.empty()) return nullptr; return MakeUnique(st, components); } else if (auto* at = type->AsArray()) { auto components = GetConstantsFromIds(literal_words_or_ids); if (components.empty()) return nullptr; return MakeUnique(at, components); } else { return nullptr; } } const Constant* ConstantManager::GetConstantFromInst(const Instruction* inst) { std::vector literal_words_or_ids; // Collect the constant defining literals or component ids. for (uint32_t i = 0; i < inst->NumInOperands(); i++) { literal_words_or_ids.insert(literal_words_or_ids.end(), inst->GetInOperand(i).words.begin(), inst->GetInOperand(i).words.end()); } switch (inst->opcode()) { // OpConstant{True|False} have the value embedded in the opcode. So they // are not handled by the for-loop above. Here we add the value explicitly. case spv::Op::OpConstantTrue: literal_words_or_ids.push_back(true); break; case spv::Op::OpConstantFalse: literal_words_or_ids.push_back(false); break; case spv::Op::OpConstantNull: case spv::Op::OpConstant: case spv::Op::OpConstantComposite: case spv::Op::OpSpecConstantComposite: break; default: return nullptr; } return GetConstant(GetType(inst), literal_words_or_ids); } std::unique_ptr ConstantManager::CreateInstruction( uint32_t id, const Constant* c, uint32_t type_id) const { uint32_t type = (type_id == 0) ? context()->get_type_mgr()->GetId(c->type()) : type_id; if (c->AsNullConstant()) { return MakeUnique(context(), spv::Op::OpConstantNull, type, id, std::initializer_list{}); } else if (const BoolConstant* bc = c->AsBoolConstant()) { return MakeUnique( context(), bc->value() ? spv::Op::OpConstantTrue : spv::Op::OpConstantFalse, type, id, std::initializer_list{}); } else if (const IntConstant* ic = c->AsIntConstant()) { return MakeUnique( context(), spv::Op::OpConstant, type, id, std::initializer_list{ Operand(spv_operand_type_t::SPV_OPERAND_TYPE_TYPED_LITERAL_NUMBER, ic->words())}); } else if (const FloatConstant* fc = c->AsFloatConstant()) { return MakeUnique( context(), spv::Op::OpConstant, type, id, std::initializer_list{ Operand(spv_operand_type_t::SPV_OPERAND_TYPE_TYPED_LITERAL_NUMBER, fc->words())}); } else if (const CompositeConstant* cc = c->AsCompositeConstant()) { return CreateCompositeInstruction(id, cc, type_id); } else { return nullptr; } } std::unique_ptr ConstantManager::CreateCompositeInstruction( uint32_t result_id, const CompositeConstant* cc, uint32_t type_id) const { std::vector operands; Instruction* type_inst = context()->get_def_use_mgr()->GetDef(type_id); uint32_t component_index = 0; for (const Constant* component_const : cc->GetComponents()) { uint32_t component_type_id = 0; if (type_inst && type_inst->opcode() == spv::Op::OpTypeStruct) { component_type_id = type_inst->GetSingleWordInOperand(component_index); } else if (type_inst && type_inst->opcode() == spv::Op::OpTypeArray) { component_type_id = type_inst->GetSingleWordInOperand(0); } uint32_t id = FindDeclaredConstant(component_const, component_type_id); if (id == 0) { // Cannot get the id of the component constant, while all components // should have been added to the module prior to the composite constant. // Cannot create OpConstantComposite instruction in this case. return nullptr; } operands.emplace_back(spv_operand_type_t::SPV_OPERAND_TYPE_ID, std::initializer_list{id}); component_index++; } uint32_t type = (type_id == 0) ? context()->get_type_mgr()->GetId(cc->type()) : type_id; return MakeUnique(context(), spv::Op::OpConstantComposite, type, result_id, std::move(operands)); } const Constant* ConstantManager::GetConstant( const Type* type, const std::vector& literal_words_or_ids) { auto cst = CreateConstant(type, literal_words_or_ids); return cst ? RegisterConstant(std::move(cst)) : nullptr; } const Constant* ConstantManager::GetNullCompositeConstant(const Type* type) { std::vector literal_words_or_id; if (type->AsVector()) { const Type* element_type = type->AsVector()->element_type(); const uint32_t null_id = GetNullConstId(element_type); const uint32_t element_count = type->AsVector()->element_count(); for (uint32_t i = 0; i < element_count; i++) { literal_words_or_id.push_back(null_id); } } else if (type->AsMatrix()) { const Type* element_type = type->AsMatrix()->element_type(); const uint32_t null_id = GetNullConstId(element_type); const uint32_t element_count = type->AsMatrix()->element_count(); for (uint32_t i = 0; i < element_count; i++) { literal_words_or_id.push_back(null_id); } } else if (type->AsStruct()) { // TODO (sfricke-lunarg) add proper struct support return nullptr; } else if (type->AsArray()) { const Type* element_type = type->AsArray()->element_type(); const uint32_t null_id = GetNullConstId(element_type); assert(type->AsArray()->length_info().words[0] == analysis::Array::LengthInfo::kConstant && "unexpected array length"); const uint32_t element_count = type->AsArray()->length_info().words[0]; for (uint32_t i = 0; i < element_count; i++) { literal_words_or_id.push_back(null_id); } } else { return nullptr; } return GetConstant(type, literal_words_or_id); } const Constant* ConstantManager::GetNumericVectorConstantWithWords( const Vector* type, const std::vector& literal_words) { const auto* element_type = type->element_type(); uint32_t words_per_element = 0; if (const auto* float_type = element_type->AsFloat()) words_per_element = float_type->width() / 32; else if (const auto* int_type = element_type->AsInteger()) words_per_element = int_type->width() / 32; else if (element_type->AsBool() != nullptr) words_per_element = 1; if (words_per_element != 1 && words_per_element != 2) return nullptr; if (words_per_element * type->element_count() != static_cast(literal_words.size())) { return nullptr; } std::vector element_ids; for (uint32_t i = 0; i < type->element_count(); ++i) { auto first_word = literal_words.begin() + (words_per_element * i); std::vector const_data(first_word, first_word + words_per_element); const analysis::Constant* element_constant = GetConstant(element_type, const_data); auto element_id = GetDefiningInstruction(element_constant)->result_id(); element_ids.push_back(element_id); } return GetConstant(type, element_ids); } uint32_t ConstantManager::GetFloatConstId(float val) { const Constant* c = GetFloatConst(val); return GetDefiningInstruction(c)->result_id(); } const Constant* ConstantManager::GetFloatConst(float val) { Type* float_type = context()->get_type_mgr()->GetFloatType(); utils::FloatProxy v(val); const Constant* c = GetConstant(float_type, v.GetWords()); return c; } uint32_t ConstantManager::GetDoubleConstId(double val) { const Constant* c = GetDoubleConst(val); return GetDefiningInstruction(c)->result_id(); } const Constant* ConstantManager::GetDoubleConst(double val) { Type* float_type = context()->get_type_mgr()->GetDoubleType(); utils::FloatProxy v(val); const Constant* c = GetConstant(float_type, v.GetWords()); return c; } uint32_t ConstantManager::GetSIntConstId(int32_t val) { Type* sint_type = context()->get_type_mgr()->GetSIntType(); const Constant* c = GetConstant(sint_type, {static_cast(val)}); return GetDefiningInstruction(c)->result_id(); } const Constant* ConstantManager::GetIntConst(uint64_t val, int32_t bitWidth, bool isSigned) { Type* int_type = context()->get_type_mgr()->GetIntType(bitWidth, isSigned); if (isSigned) { // Sign extend the value. int32_t num_of_bit_to_ignore = 64 - bitWidth; val = static_cast(val << num_of_bit_to_ignore) >> num_of_bit_to_ignore; } else if (bitWidth < 64) { // Clear the upper bit that are not used. uint64_t mask = ((1ull << bitWidth) - 1); val &= mask; } if (bitWidth <= 32) { return GetConstant(int_type, {static_cast(val)}); } // If the value is more than 32-bit, we need to split the operands into two // 32-bit integers. return GetConstant( int_type, {static_cast(val), static_cast(val >> 32)}); } uint32_t ConstantManager::GetUIntConstId(uint32_t val) { Type* uint_type = context()->get_type_mgr()->GetUIntType(); const Constant* c = GetConstant(uint_type, {val}); return GetDefiningInstruction(c)->result_id(); } uint32_t ConstantManager::GetNullConstId(const Type* type) { const Constant* c = GetConstant(type, {}); return GetDefiningInstruction(c)->result_id(); } const Constant* ConstantManager::GenerateIntegerConstant( const analysis::Integer* integer_type, uint64_t result) { assert(integer_type != nullptr); std::vector words; if (integer_type->width() == 64) { // In the 64-bit case, two words are needed to represent the value. words = {static_cast(result), static_cast(result >> 32)}; } else { // In all other cases, only a single word is needed. assert(integer_type->width() <= 32); if (integer_type->IsSigned()) { result = utils::SignExtendValue(result, integer_type->width()); } else { result = utils::ZeroExtendValue(result, integer_type->width()); } words = {static_cast(result)}; } return GetConstant(integer_type, words); } std::vector Constant::GetVectorComponents( analysis::ConstantManager* const_mgr) const { std::vector components; const analysis::VectorConstant* a = this->AsVectorConstant(); const analysis::Vector* vector_type = this->type()->AsVector(); assert(vector_type != nullptr); if (a != nullptr) { for (uint32_t i = 0; i < vector_type->element_count(); ++i) { components.push_back(a->GetComponents()[i]); } } else { const analysis::Type* element_type = vector_type->element_type(); const analysis::Constant* element_null_const = const_mgr->GetConstant(element_type, {}); for (uint32_t i = 0; i < vector_type->element_count(); ++i) { components.push_back(element_null_const); } } return components; } } // namespace analysis } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/constants.h000066400000000000000000000712261475742701700230300ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_CONSTANTS_H_ #define SOURCE_OPT_CONSTANTS_H_ #include #include #include #include #include #include #include #include "source/opt/module.h" #include "source/opt/type_manager.h" #include "source/opt/types.h" #include "source/util/hex_float.h" #include "source/util/make_unique.h" namespace spvtools { namespace opt { class IRContext; namespace analysis { // Class hierarchy to represent the normal constants defined through // OpConstantTrue, OpConstantFalse, OpConstant, OpConstantNull and // OpConstantComposite instructions. // TODO(qining): Add class for constants defined with OpConstantSampler. class Constant; class ScalarConstant; class IntConstant; class FloatConstant; class BoolConstant; class CompositeConstant; class StructConstant; class VectorConstant; class MatrixConstant; class ArrayConstant; class NullConstant; class ConstantManager; // Abstract class for a SPIR-V constant. It has a bunch of As methods, // which is used as a way to probe the actual class Constant { public: Constant() = delete; virtual ~Constant() = default; // Make a deep copy of this constant. virtual std::unique_ptr Copy() const = 0; // reflections virtual ScalarConstant* AsScalarConstant() { return nullptr; } virtual IntConstant* AsIntConstant() { return nullptr; } virtual FloatConstant* AsFloatConstant() { return nullptr; } virtual BoolConstant* AsBoolConstant() { return nullptr; } virtual CompositeConstant* AsCompositeConstant() { return nullptr; } virtual StructConstant* AsStructConstant() { return nullptr; } virtual VectorConstant* AsVectorConstant() { return nullptr; } virtual MatrixConstant* AsMatrixConstant() { return nullptr; } virtual ArrayConstant* AsArrayConstant() { return nullptr; } virtual NullConstant* AsNullConstant() { return nullptr; } virtual const ScalarConstant* AsScalarConstant() const { return nullptr; } virtual const IntConstant* AsIntConstant() const { return nullptr; } virtual const FloatConstant* AsFloatConstant() const { return nullptr; } virtual const BoolConstant* AsBoolConstant() const { return nullptr; } virtual const CompositeConstant* AsCompositeConstant() const { return nullptr; } virtual const StructConstant* AsStructConstant() const { return nullptr; } virtual const VectorConstant* AsVectorConstant() const { return nullptr; } virtual const MatrixConstant* AsMatrixConstant() const { return nullptr; } virtual const ArrayConstant* AsArrayConstant() const { return nullptr; } virtual const NullConstant* AsNullConstant() const { return nullptr; } // Returns the float representation of the constant. Must be a 32 bit // Float type. float GetFloat() const; // Returns the double representation of the constant. Must be a 64 bit // Float type. double GetDouble() const; // Returns the double representation of the constant. Must be a 32-bit or // 64-bit Float type. double GetValueAsDouble() const; // Returns uint32_t representation of the constant. Must be a 32 bit // Integer type. uint32_t GetU32() const; // Returns uint64_t representation of the constant. Must be a 64 bit // Integer type. uint64_t GetU64() const; // Returns int32_t representation of the constant. Must be a 32 bit // Integer type. int32_t GetS32() const; // Returns int64_t representation of the constant. Must be a 64 bit // Integer type. int64_t GetS64() const; // Returns the zero-extended representation of an integer constant. Must // be an integral constant of at most 64 bits. uint64_t GetZeroExtendedValue() const; // Returns the sign-extended representation of an integer constant. Must // be an integral constant of at most 64 bits. int64_t GetSignExtendedValue() const; // Returns true if the constant is a zero or a composite containing 0s. virtual bool IsZero() const { return false; } const Type* type() const { return type_; } // Returns an std::vector containing the elements of |constant|. The type of // |constant| must be |Vector|. std::vector GetVectorComponents( ConstantManager* const_mgr) const; protected: Constant(const Type* ty) : type_(ty) {} // The type of this constant. const Type* type_; }; // Abstract class for scalar type constants. class ScalarConstant : public Constant { public: ScalarConstant() = delete; ScalarConstant* AsScalarConstant() override { return this; } const ScalarConstant* AsScalarConstant() const override { return this; } // Returns a const reference of the value of this constant in 32-bit words. virtual const std::vector& words() const { return words_; } // Returns true if the value is zero. bool IsZero() const override { bool is_zero = true; for (uint32_t v : words()) { if (v != 0) { is_zero = false; break; } } return is_zero; } uint32_t GetU32BitValue() const { // Relies on unsigned values smaller than 32-bit being zero extended. See // section 2.2.1 of the SPIR-V spec. assert(words().size() == 1); return words()[0]; } uint64_t GetU64BitValue() const { // Relies on unsigned values smaller than 64-bit being zero extended. See // section 2.2.1 of the SPIR-V spec. assert(words().size() == 2); return static_cast(words()[1]) << 32 | static_cast(words()[0]); } protected: ScalarConstant(const Type* ty, const std::vector& w) : Constant(ty), words_(w) {} ScalarConstant(const Type* ty, std::vector&& w) : Constant(ty), words_(std::move(w)) {} std::vector words_; }; // Integer type constant. class IntConstant : public ScalarConstant { public: IntConstant(const Integer* ty, const std::vector& w) : ScalarConstant(ty, w) {} IntConstant(const Integer* ty, std::vector&& w) : ScalarConstant(ty, std::move(w)) {} IntConstant* AsIntConstant() override { return this; } const IntConstant* AsIntConstant() const override { return this; } int32_t GetS32BitValue() const { // Relies on signed values smaller than 32-bit being sign extended. See // section 2.2.1 of the SPIR-V spec. assert(words().size() == 1); return words()[0]; } int64_t GetS64BitValue() const { // Relies on unsigned values smaller than 64-bit being sign extended. See // section 2.2.1 of the SPIR-V spec. assert(words().size() == 2); return static_cast(words()[1]) << 32 | static_cast(words()[0]); } // Make a copy of this IntConstant instance. std::unique_ptr CopyIntConstant() const { return MakeUnique(type_->AsInteger(), words_); } std::unique_ptr Copy() const override { return std::unique_ptr(CopyIntConstant().release()); } }; // Float type constant. class FloatConstant : public ScalarConstant { public: FloatConstant(const Float* ty, const std::vector& w) : ScalarConstant(ty, w) {} FloatConstant(const Float* ty, std::vector&& w) : ScalarConstant(ty, std::move(w)) {} FloatConstant* AsFloatConstant() override { return this; } const FloatConstant* AsFloatConstant() const override { return this; } // Make a copy of this FloatConstant instance. std::unique_ptr CopyFloatConstant() const { return MakeUnique(type_->AsFloat(), words_); } std::unique_ptr Copy() const override { return std::unique_ptr(CopyFloatConstant().release()); } // Returns the float value of |this|. The type of |this| must be |Float| with // width of 32. float GetFloatValue() const { assert(type()->AsFloat()->width() == 32 && "Not a 32-bit floating point value."); utils::FloatProxy a(words()[0]); return a.getAsFloat(); } // Returns the double value of |this|. The type of |this| must be |Float| // with width of 64. double GetDoubleValue() const { assert(type()->AsFloat()->width() == 64 && "Not a 32-bit floating point value."); uint64_t combined_words = words()[1]; combined_words = combined_words << 32; combined_words |= words()[0]; utils::FloatProxy a(combined_words); return a.getAsFloat(); } }; // Bool type constant. class BoolConstant : public ScalarConstant { public: BoolConstant(const Bool* ty, bool v) : ScalarConstant(ty, {static_cast(v)}), value_(v) {} BoolConstant* AsBoolConstant() override { return this; } const BoolConstant* AsBoolConstant() const override { return this; } // Make a copy of this BoolConstant instance. std::unique_ptr CopyBoolConstant() const { return MakeUnique(type_->AsBool(), value_); } std::unique_ptr Copy() const override { return std::unique_ptr(CopyBoolConstant().release()); } bool value() const { return value_; } private: bool value_; }; // Abstract class for composite constants. class CompositeConstant : public Constant { public: CompositeConstant() = delete; CompositeConstant* AsCompositeConstant() override { return this; } const CompositeConstant* AsCompositeConstant() const override { return this; } // Returns a const reference of the components held in this composite // constant. virtual const std::vector& GetComponents() const { return components_; } bool IsZero() const override { for (const Constant* c : GetComponents()) { if (!c->IsZero()) { return false; } } return true; } protected: CompositeConstant(const Type* ty) : Constant(ty), components_() {} CompositeConstant(const Type* ty, const std::vector& components) : Constant(ty), components_(components) {} CompositeConstant(const Type* ty, std::vector&& components) : Constant(ty), components_(std::move(components)) {} std::vector components_; }; // Struct type constant. class StructConstant : public CompositeConstant { public: StructConstant(const Struct* ty) : CompositeConstant(ty) {} StructConstant(const Struct* ty, const std::vector& components) : CompositeConstant(ty, components) {} StructConstant(const Struct* ty, std::vector&& components) : CompositeConstant(ty, std::move(components)) {} StructConstant* AsStructConstant() override { return this; } const StructConstant* AsStructConstant() const override { return this; } // Make a copy of this StructConstant instance. std::unique_ptr CopyStructConstant() const { return MakeUnique(type_->AsStruct(), components_); } std::unique_ptr Copy() const override { return std::unique_ptr(CopyStructConstant().release()); } }; // Vector type constant. class VectorConstant : public CompositeConstant { public: VectorConstant(const Vector* ty) : CompositeConstant(ty), component_type_(ty->element_type()) {} VectorConstant(const Vector* ty, const std::vector& components) : CompositeConstant(ty, components), component_type_(ty->element_type()) {} VectorConstant(const Vector* ty, std::vector&& components) : CompositeConstant(ty, std::move(components)), component_type_(ty->element_type()) {} VectorConstant* AsVectorConstant() override { return this; } const VectorConstant* AsVectorConstant() const override { return this; } // Make a copy of this VectorConstant instance. std::unique_ptr CopyVectorConstant() const { auto another = MakeUnique(type_->AsVector()); another->components_.insert(another->components_.end(), components_.begin(), components_.end()); return another; } std::unique_ptr Copy() const override { return std::unique_ptr(CopyVectorConstant().release()); } const Type* component_type() const { return component_type_; } private: const Type* component_type_; }; // Matrix type constant. class MatrixConstant : public CompositeConstant { public: MatrixConstant(const Matrix* ty) : CompositeConstant(ty), component_type_(ty->element_type()) {} MatrixConstant(const Matrix* ty, const std::vector& components) : CompositeConstant(ty, components), component_type_(ty->element_type()) {} MatrixConstant(const Vector* ty, std::vector&& components) : CompositeConstant(ty, std::move(components)), component_type_(ty->element_type()) {} MatrixConstant* AsMatrixConstant() override { return this; } const MatrixConstant* AsMatrixConstant() const override { return this; } // Make a copy of this MatrixConstant instance. std::unique_ptr CopyMatrixConstant() const { auto another = MakeUnique(type_->AsMatrix()); another->components_.insert(another->components_.end(), components_.begin(), components_.end()); return another; } std::unique_ptr Copy() const override { return std::unique_ptr(CopyMatrixConstant().release()); } const Type* component_type() { return component_type_; } private: const Type* component_type_; }; // Array type constant. class ArrayConstant : public CompositeConstant { public: ArrayConstant(const Array* ty) : CompositeConstant(ty) {} ArrayConstant(const Array* ty, const std::vector& components) : CompositeConstant(ty, components) {} ArrayConstant(const Array* ty, std::vector&& components) : CompositeConstant(ty, std::move(components)) {} ArrayConstant* AsArrayConstant() override { return this; } const ArrayConstant* AsArrayConstant() const override { return this; } // Make a copy of this ArrayConstant instance. std::unique_ptr CopyArrayConstant() const { return MakeUnique(type_->AsArray(), components_); } std::unique_ptr Copy() const override { return std::unique_ptr(CopyArrayConstant().release()); } }; // Null type constant. class NullConstant : public Constant { public: NullConstant(const Type* ty) : Constant(ty) {} NullConstant* AsNullConstant() override { return this; } const NullConstant* AsNullConstant() const override { return this; } // Make a copy of this NullConstant instance. std::unique_ptr CopyNullConstant() const { return MakeUnique(type_); } std::unique_ptr Copy() const override { return std::unique_ptr(CopyNullConstant().release()); } bool IsZero() const override { return true; } }; // Hash function for Constant instances. Use the structure of the constant as // the key. struct ConstantHash { void add_pointer(std::u32string* h, const void* p) const { uint64_t ptr_val = reinterpret_cast(p); h->push_back(static_cast(ptr_val >> 32)); h->push_back(static_cast(ptr_val)); } size_t operator()(const Constant* const_val) const { std::u32string h; add_pointer(&h, const_val->type()); if (const auto scalar = const_val->AsScalarConstant()) { for (const auto& w : scalar->words()) { h.push_back(w); } } else if (const auto composite = const_val->AsCompositeConstant()) { for (const auto& c : composite->GetComponents()) { add_pointer(&h, c); } } else if (const_val->AsNullConstant()) { h.push_back(0); } else { assert( false && "Tried to compute the hash value of an invalid Constant instance."); } return std::hash()(h); } }; // Equality comparison structure for two constants. struct ConstantEqual { bool operator()(const Constant* c1, const Constant* c2) const { if (c1->type() != c2->type()) { return false; } if (const auto& s1 = c1->AsScalarConstant()) { const auto& s2 = c2->AsScalarConstant(); return s2 && s1->words() == s2->words(); } else if (const auto& composite1 = c1->AsCompositeConstant()) { const auto& composite2 = c2->AsCompositeConstant(); return composite2 && composite1->GetComponents() == composite2->GetComponents(); } else if (c1->AsNullConstant()) { return c2->AsNullConstant() != nullptr; } else { assert(false && "Tried to compare two invalid Constant instances."); } return false; } }; // This class represents a pool of constants. class ConstantManager { public: ConstantManager(IRContext* ctx); IRContext* context() const { return ctx_; } // Gets or creates a unique Constant instance of type |type| and a vector of // constant defining words or ids for elements of Vector type // |literal_words_or_ids|. If a Constant instance existed already in the // constant pool, it returns a pointer to it. Otherwise, it creates one using // CreateConstant. If a new Constant instance cannot be created, it returns // nullptr. const Constant* GetConstant( const Type* type, const std::vector& literal_words_or_ids); template const Constant* GetConstant(const Type* type, const C& literal_words_or_ids) { return GetConstant(type, std::vector(literal_words_or_ids.begin(), literal_words_or_ids.end())); } // Takes a type and creates a OpConstantComposite // This allows a // OpConstantNull %composite_type // to become a // OpConstantComposite %composite_type %null %null ... etc // Assumes type is a Composite already, otherwise returns null const Constant* GetNullCompositeConstant(const Type* type); // Gets or creates a unique Constant instance of Vector type |type| with // numeric elements and a vector of constant defining words |literal_words|. // If a Constant instance existed already in the constant pool, it returns a // pointer to it. Otherwise, it creates one using CreateConstant. If a new // Constant instance cannot be created, it returns nullptr. const Constant* GetNumericVectorConstantWithWords( const Vector* type, const std::vector& literal_words); // Gets or creates a Constant instance to hold the constant value of the given // instruction. It returns a pointer to a Constant instance or nullptr if it // could not create the constant. const Constant* GetConstantFromInst(const Instruction* inst); // Gets or creates a constant defining instruction for the given Constant |c|. // If |c| had already been defined, it returns a pointer to the existing // declaration. Otherwise, it calls BuildInstructionAndAddToModule. If the // optional |pos| is given, it will insert any newly created instructions at // the given instruction iterator position. Otherwise, it inserts the new // instruction at the end of the current module's types section. // // |type_id| is an optional argument for disambiguating equivalent types. If // |type_id| is specified, the constant returned will have that type id. Instruction* GetDefiningInstruction(const Constant* c, uint32_t type_id = 0, Module::inst_iterator* pos = nullptr); // Creates a constant defining instruction for the given Constant instance // and inserts the instruction at the position specified by the given // instruction iterator. Returns a pointer to the created instruction if // succeeded, otherwise returns a null pointer. The instruction iterator // points to the same instruction before and after the insertion. This is the // only method that actually manages id creation/assignment and instruction // creation/insertion for a new Constant instance. // // |type_id| is an optional argument for disambiguating equivalent types. If // |type_id| is specified, it is used as the type of the constant. Otherwise // the type of the constant is derived by getting an id from the type manager // for |c|. Instruction* BuildInstructionAndAddToModule(const Constant* c, Module::inst_iterator* pos, uint32_t type_id = 0); // A helper function to get the result type of the given instruction. Returns // nullptr if the instruction does not have a type id (type id is 0). Type* GetType(const Instruction* inst) const; // A helper function to get the collected normal constant with the given id. // Returns the pointer to the Constant instance in case it is found. // Otherwise, it returns a null pointer. const Constant* FindDeclaredConstant(uint32_t id) const { auto iter = id_to_const_val_.find(id); return (iter != id_to_const_val_.end()) ? iter->second : nullptr; } // A helper function to get the id of a collected constant with the pointer // to the Constant instance. Returns 0 in case the constant is not found. uint32_t FindDeclaredConstant(const Constant* c, uint32_t type_id) const; // Returns the canonical constant that has the same structure and value as the // given Constant |cst|. If none is found, it returns nullptr. // // TODO: Should be able to give a type id to disambiguate types with the same // structure. const Constant* FindConstant(const Constant* c) const { auto it = const_pool_.find(c); return (it != const_pool_.end()) ? *it : nullptr; } // Registers a new constant |cst| in the constant pool. If the constant // existed already, it returns a pointer to the previously existing Constant // in the pool. Otherwise, it returns |cst|. const Constant* RegisterConstant(std::unique_ptr cst) { auto ret = const_pool_.insert(cst.get()); if (ret.second) { owned_constants_.emplace_back(std::move(cst)); } return *ret.first; } // A helper function to get a vector of Constant instances with the specified // ids. If it can not find the Constant instance for any one of the ids, // it returns an empty vector. std::vector GetConstantsFromIds( const std::vector& ids) const; // Returns a vector of constants representing each in operand. If an operand // is not constant its entry is nullptr. std::vector GetOperandConstants( const Instruction* inst) const; // Records a mapping between |inst| and the constant value generated by it. // It returns true if a new Constant was successfully mapped, false if |inst| // generates no constant values. bool MapInst(Instruction* inst) { if (auto cst = GetConstantFromInst(inst)) { MapConstantToInst(cst, inst); return true; } return false; } void RemoveId(uint32_t id) { auto it = id_to_const_val_.find(id); if (it != id_to_const_val_.end()) { const_val_to_id_.erase(it->second); id_to_const_val_.erase(it); } } // Records a new mapping between |inst| and |const_value|. This updates the // two mappings |id_to_const_val_| and |const_val_to_id_|. void MapConstantToInst(const Constant* const_value, Instruction* inst) { if (id_to_const_val_.insert({inst->result_id(), const_value}).second) { const_val_to_id_.insert({const_value, inst->result_id()}); } } // Returns the id of a 32-bit floating point constant with value |val|. uint32_t GetFloatConstId(float val); // Returns a 32-bit float constant with the given value. const Constant* GetFloatConst(float val); // Returns the id of a 64-bit floating point constant with value |val|. uint32_t GetDoubleConstId(double val); // Returns a 64-bit float constant with the given value. const Constant* GetDoubleConst(double val); // Returns the id of a 32-bit signed integer constant with value |val|. uint32_t GetSIntConstId(int32_t val); // Returns an integer constant with `bitWidth` and value |val|. If `isSigned` // is true, the constant will be a signed integer. Otherwise it will be // unsigned. Only the `bitWidth` lower order bits of |val| will be used. The // rest will be ignored. const Constant* GetIntConst(uint64_t val, int32_t bitWidth, bool isSigned); // Returns the id of a 32-bit unsigned integer constant with value |val|. uint32_t GetUIntConstId(uint32_t val); // Returns the id of a OpConstantNull with type of |type|. uint32_t GetNullConstId(const Type* type); // Returns a constant whose value is `value` and type is `type`. This constant // will be generated by `const_mgr`. The type must be a scalar integer type. const Constant* GenerateIntegerConstant(const analysis::Integer* integer_type, uint64_t result); private: // Creates a Constant instance with the given type and a vector of constant // defining words. Returns a unique pointer to the created Constant instance // if the Constant instance can be created successfully. To create scalar // type constants, the vector should contain the constant value in 32 bit // words and the given type must be of type Bool, Integer or Float. To create // composite type constants, the vector should contain the component ids, and // those component ids should have been recorded before as Normal Constants. // And the given type must be of type Struct, Vector or Array. When creating // VectorType Constant instance, the components must be scalars of the same // type, either Bool, Integer or Float. If any of the rules above failed, the // creation will fail and nullptr will be returned. If the vector is empty, // a NullConstant instance will be created with the given type. std::unique_ptr CreateConstant( const Type* type, const std::vector& literal_words_or_ids) const; // Creates an instruction with the given result id to declare a constant // represented by the given Constant instance. Returns an unique pointer to // the created instruction if the instruction can be created successfully. // Otherwise, returns a null pointer. // // |type_id| is an optional argument for disambiguating equivalent types. If // |type_id| is specified, it is used as the type of the constant. Otherwise // the type of the constant is derived by getting an id from the type manager // for |c|. std::unique_ptr CreateInstruction(uint32_t result_id, const Constant* c, uint32_t type_id = 0) const; // Creates an OpConstantComposite instruction with the given result id and // the CompositeConst instance which represents a composite constant. Returns // an unique pointer to the created instruction if succeeded. Otherwise // returns a null pointer. // // |type_id| is an optional argument for disambiguating equivalent types. If // |type_id| is specified, it is used as the type of the constant. Otherwise // the type of the constant is derived by getting an id from the type manager // for |c|. std::unique_ptr CreateCompositeInstruction( uint32_t result_id, const CompositeConstant* cc, uint32_t type_id = 0) const; // IR context that owns this constant manager. IRContext* ctx_; // A mapping from the result ids of Normal Constants to their // Constant instances. All Normal Constants in the module, either // existing ones before optimization or the newly generated ones, should have // their Constant instance stored and their result id registered in this map. std::unordered_map id_to_const_val_; // A mapping from the Constant instance of Normal Constants to their // result id in the module. This is a mirror map of |id_to_const_val_|. All // Normal Constants that defining instructions in the module should have // their Constant and their result id registered here. std::multimap const_val_to_id_; // The constant pool. All created constants are registered here. std::unordered_set const_pool_; // The constant that are owned by the constant manager. Every constant in // |const_pool_| should be in |owned_constants_| as well. std::vector> owned_constants_; }; } // namespace analysis } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_CONSTANTS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/control_dependence.cpp000066400000000000000000000142121475742701700251710ustar00rootroot00000000000000// Copyright (c) 2021 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/control_dependence.h" #include #include #include "source/opt/basic_block.h" #include "source/opt/cfg.h" #include "source/opt/dominator_analysis.h" #include "source/opt/function.h" #include "source/opt/instruction.h" // Computes the control dependence graph (CDG) using the algorithm in Cytron // 1991, "Efficiently Computing Static Single Assignment Form and the Control // Dependence Graph." It relies on the fact that the control dependence sources // (blocks on which a block is control dependent) are exactly the post-dominance // frontier for that block. The explanation and proofs are given in Section 6 of // that paper. // Link: https://www.cs.utexas.edu/~pingali/CS380C/2010/papers/ssaCytron.pdf // // The algorithm in Section 4.2 of the same paper is used to construct the // dominance frontier. It uses the post-dominance tree, which is available in // the IR context. namespace spvtools { namespace opt { constexpr uint32_t ControlDependenceAnalysis::kPseudoEntryBlock; uint32_t ControlDependence::GetConditionID(const CFG& cfg) const { if (source_bb_id() == 0) { // Entry dependence; return 0. return 0; } const BasicBlock* source_bb = cfg.block(source_bb_id()); const Instruction* branch = source_bb->terminator(); assert((branch->opcode() == spv::Op::OpBranchConditional || branch->opcode() == spv::Op::OpSwitch) && "invalid control dependence; last instruction must be conditional " "branch or switch"); return branch->GetSingleWordInOperand(0); } bool ControlDependence::operator<(const ControlDependence& other) const { return std::tie(source_bb_id_, target_bb_id_, branch_target_bb_id_) < std::tie(other.source_bb_id_, other.target_bb_id_, other.branch_target_bb_id_); } bool ControlDependence::operator==(const ControlDependence& other) const { return std::tie(source_bb_id_, target_bb_id_, branch_target_bb_id_) == std::tie(other.source_bb_id_, other.target_bb_id_, other.branch_target_bb_id_); } std::ostream& operator<<(std::ostream& os, const ControlDependence& dep) { os << dep.source_bb_id() << "->" << dep.target_bb_id(); if (dep.branch_target_bb_id() != dep.target_bb_id()) { os << " through " << dep.branch_target_bb_id(); } return os; } void ControlDependenceAnalysis::ComputePostDominanceFrontiers( const CFG& cfg, const PostDominatorAnalysis& pdom) { // Compute post-dominance frontiers (reverse graph). // The dominance frontier for a block X is equal to (Equation 4) // DF_local(X) U { B in DF_up(Z) | X = ipdom(Z) } // (ipdom(Z) is the immediate post-dominator of Z.) // where // DF_local(X) = { Y | X -> Y in CFG, X does not strictly post-dominate Y } // represents the contribution of X's predecessors to the DF, and // DF_up(Z) = { Y | Y in DF(Z), ipdom(Z) does not strictly post-dominate Y } // (note: ipdom(Z) = X.) // represents the contribution of a block to its immediate post- // dominator's DF. // This is computed in one pass through a post-order traversal of the // post-dominator tree. // Assert that there is a block other than the pseudo exit in the pdom tree, // as we need one to get the function entry point (as the pseudo exit is not // actually part of the function.) assert(!cfg.IsPseudoExitBlock(pdom.GetDomTree().post_begin()->bb_)); Function* function = pdom.GetDomTree().post_begin()->bb_->GetParent(); uint32_t function_entry = function->entry()->id(); // Explicitly initialize pseudo-entry block, as it doesn't depend on anything, // so it won't be initialized in the following loop. reverse_nodes_[kPseudoEntryBlock] = {}; for (auto it = pdom.GetDomTree().post_cbegin(); it != pdom.GetDomTree().post_cend(); ++it) { ComputePostDominanceFrontierForNode(cfg, pdom, function_entry, *it); } } void ControlDependenceAnalysis::ComputePostDominanceFrontierForNode( const CFG& cfg, const PostDominatorAnalysis& pdom, uint32_t function_entry, const DominatorTreeNode& pdom_node) { const uint32_t label = pdom_node.id(); ControlDependenceList& edges = reverse_nodes_[label]; for (uint32_t pred : cfg.preds(label)) { if (!pdom.StrictlyDominates(label, pred)) { edges.push_back(ControlDependence(pred, label)); } } if (label == function_entry) { // Add edge from pseudo-entry to entry. // In CDG construction, an edge is added from entry to exit, so only the // exit node can post-dominate entry. edges.push_back(ControlDependence(kPseudoEntryBlock, label)); } for (DominatorTreeNode* child : pdom_node) { // Note: iterate dependences by value, as we need a copy. for (const ControlDependence& dep : reverse_nodes_[child->id()]) { // Special-case pseudo-entry, as above. if (dep.source_bb_id() == kPseudoEntryBlock || !pdom.StrictlyDominates(label, dep.source_bb_id())) { edges.push_back(ControlDependence(dep.source_bb_id(), label, dep.branch_target_bb_id())); } } } } void ControlDependenceAnalysis::ComputeControlDependenceGraph( const CFG& cfg, const PostDominatorAnalysis& pdom) { ComputePostDominanceFrontiers(cfg, pdom); ComputeForwardGraphFromReverse(); } void ControlDependenceAnalysis::ComputeForwardGraphFromReverse() { for (const auto& entry : reverse_nodes_) { // Ensure an entry is created for each node. forward_nodes_[entry.first]; for (const ControlDependence& dep : entry.second) { forward_nodes_[dep.source_bb_id()].push_back(dep); } } } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/control_dependence.h000066400000000000000000000176421475742701700246500ustar00rootroot00000000000000// Copyright (c) 2021 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_CONTROL_DEPENDENCE_H_ #define SOURCE_OPT_CONTROL_DEPENDENCE_H_ #include #include #include #include #include #include #include "source/opt/cfg.h" #include "source/opt/dominator_analysis.h" namespace spvtools { namespace opt { class ControlDependence { public: // The label of the source of this dependence, i.e. the block on which the // target is dependent on. // A |source_bb_id| of 0 represents an "entry" dependence, meaning that the // execution of |target_bb_id| is only dependent on entry to the function. uint32_t source_bb_id() const { return source_bb_id_; } // The label of the target of this dependence, i.e. the block which is // dependent on the source. uint32_t target_bb_id() const { return target_bb_id_; } // The label of the target of the *branch* for this dependence. // Equal to the ID of the entry block for entry dependences. // // For example, for the partial CFG pictured below: // 1 ---> 2 ---> 4 ---> 6 // \ \ ^ // \-> 3 \-> 5 -----/ // Block 6 is control dependent on block 1, but this dependence comes from the // branch 1 -> 2, so in this case the branch target ID would be 2. uint32_t branch_target_bb_id() const { return branch_target_bb_id_; } // Create a direct control dependence from BB ID |source| to |target|. ControlDependence(uint32_t source, uint32_t target) : source_bb_id_(source), target_bb_id_(target), branch_target_bb_id_(target) {} // Create a control dependence from BB ID |source| to |target| through the // branch from |source| to |branch_target|. ControlDependence(uint32_t source, uint32_t target, uint32_t branch_target) : source_bb_id_(source), target_bb_id_(target), branch_target_bb_id_(branch_target) {} // Gets the ID of the conditional value for the branch corresponding to this // control dependence. This is the first input operand for both // OpConditionalBranch and OpSwitch. // Returns 0 for entry dependences. uint32_t GetConditionID(const CFG& cfg) const; bool operator==(const ControlDependence& other) const; bool operator!=(const ControlDependence& other) const { return !(*this == other); } // Comparison operators, ordered lexicographically. Total ordering. bool operator<(const ControlDependence& other) const; bool operator>(const ControlDependence& other) const { return other < *this; } bool operator<=(const ControlDependence& other) const { return !(*this > other); } bool operator>=(const ControlDependence& other) const { return !(*this < other); } private: uint32_t source_bb_id_; uint32_t target_bb_id_; uint32_t branch_target_bb_id_; }; // Prints |dep| to |os| in a human-readable way. For example, // 1->2 (target_bb_id = branch_target_bb_id = 2) // 3->4 through 5 (target_bb_id = 4, branch_target_bb_id = 5) std::ostream& operator<<(std::ostream& os, const ControlDependence& dep); // Represents the control dependence graph. A basic block is control dependent // on another if the result of that block (e.g. the condition of a conditional // branch) influences whether it is executed or not. More formally, a block A is // control dependent on B iff: // 1. there exists a path from A to the exit node that does *not* go through B // (i.e., A does not postdominate B), and // 2. there exists a path B -> b_1 -> ... -> b_n -> A such that A post-dominates // all nodes b_i. class ControlDependenceAnalysis { public: // Map basic block labels to control dependencies/dependents. // Not guaranteed to be in any particular order. using ControlDependenceList = std::vector; using ControlDependenceListMap = std::unordered_map; // 0, the label number for the pseudo entry block. // All control dependences on the pseudo entry block are of type kEntry, and // vice versa. static constexpr uint32_t kPseudoEntryBlock = 0; // Build the control dependence graph for the given control flow graph |cfg| // and corresponding post-dominator analysis |pdom|. void ComputeControlDependenceGraph(const CFG& cfg, const PostDominatorAnalysis& pdom); // Get the list of the nodes that depend on a block. // Return value is not guaranteed to be in any particular order. const ControlDependenceList& GetDependenceTargets(uint32_t block) const { return forward_nodes_.at(block); } // Get the list of the nodes on which a block depends on. // Return value is not guaranteed to be in any particular order. const ControlDependenceList& GetDependenceSources(uint32_t block) const { return reverse_nodes_.at(block); } // Runs the function |f| on each block label in the CDG. If any iteration // returns false, immediately stops iteration and returns false. Otherwise // returns true. Nodes are iterated in some undefined order, including the // pseudo-entry block. bool WhileEachBlockLabel(std::function f) const { for (const auto& entry : forward_nodes_) { if (!f(entry.first)) { return false; } } return true; } // Runs the function |f| on each block label in the CDG. Nodes are iterated in // some undefined order, including the pseudo-entry block. void ForEachBlockLabel(std::function f) const { WhileEachBlockLabel([&f](uint32_t label) { f(label); return true; }); } // Returns true if the block |id| exists in the control dependence graph. // This can be false even if the block exists in the function when it is part // of an infinite loop, since it is not part of the post-dominator tree. bool HasBlock(uint32_t id) const { return forward_nodes_.count(id) > 0; } // Returns true if block |a| is dependent on block |b|. bool IsDependent(uint32_t a, uint32_t b) const { if (!HasBlock(a)) return false; // BBs tend to have more dependents (targets) than they are dependent on // (sources), so search sources. const ControlDependenceList& a_sources = GetDependenceSources(a); return std::find_if(a_sources.begin(), a_sources.end(), [b](const ControlDependence& dep) { return dep.source_bb_id() == b; }) != a_sources.end(); } private: // Computes the post-dominance frontiers (i.e. the reverse CDG) for each node // in the post-dominator tree. Only modifies reverse_nodes_; forward_nodes_ is // not modified. void ComputePostDominanceFrontiers(const CFG& cfg, const PostDominatorAnalysis& pdom); // Computes the post-dominance frontier for a specific node |pdom_node| in the // post-dominator tree. Result is placed in reverse_nodes_[pdom_node.id()]. void ComputePostDominanceFrontierForNode(const CFG& cfg, const PostDominatorAnalysis& pdom, uint32_t function_entry, const DominatorTreeNode& pdom_node); // Computes the forward graph (forward_nodes_) from the reverse graph // (reverse_nodes_). void ComputeForwardGraphFromReverse(); ControlDependenceListMap forward_nodes_; ControlDependenceListMap reverse_nodes_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_CONTROL_DEPENDENCE_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/convert_to_half_pass.cpp000066400000000000000000000473151475742701700255530ustar00rootroot00000000000000// Copyright (c) 2019 The Khronos Group Inc. // Copyright (c) 2019 Valve Corporation // Copyright (c) 2019 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "convert_to_half_pass.h" #include "source/opt/ir_builder.h" namespace spvtools { namespace opt { namespace { // Indices of operands in SPIR-V instructions constexpr int kImageSampleDrefIdInIdx = 2; } // namespace bool ConvertToHalfPass::IsArithmetic(Instruction* inst) { return target_ops_core_.count(inst->opcode()) != 0 || (inst->opcode() == spv::Op::OpExtInst && inst->GetSingleWordInOperand(0) == context()->get_feature_mgr()->GetExtInstImportId_GLSLstd450() && target_ops_450_.count(inst->GetSingleWordInOperand(1)) != 0); } bool ConvertToHalfPass::IsFloat(Instruction* inst, uint32_t width) { uint32_t ty_id = inst->type_id(); if (ty_id == 0) return false; return Pass::IsFloat(ty_id, width); } bool ConvertToHalfPass::IsStruct(Instruction* inst) { uint32_t ty_id = inst->type_id(); if (ty_id == 0) return false; Instruction* ty_inst = Pass::GetBaseType(ty_id); return (ty_inst->opcode() == spv::Op::OpTypeStruct); } bool ConvertToHalfPass::IsDecoratedRelaxed(Instruction* inst) { uint32_t r_id = inst->result_id(); for (auto r_inst : get_decoration_mgr()->GetDecorationsFor(r_id, false)) if (r_inst->opcode() == spv::Op::OpDecorate && spv::Decoration(r_inst->GetSingleWordInOperand(1)) == spv::Decoration::RelaxedPrecision) { return true; } return false; } bool ConvertToHalfPass::IsRelaxed(uint32_t id) { return relaxed_ids_set_.count(id) > 0; } void ConvertToHalfPass::AddRelaxed(uint32_t id) { relaxed_ids_set_.insert(id); } bool ConvertToHalfPass::CanRelaxOpOperands(Instruction* inst) { return image_ops_.count(inst->opcode()) == 0; } analysis::Type* ConvertToHalfPass::FloatScalarType(uint32_t width) { analysis::Float float_ty(width); return context()->get_type_mgr()->GetRegisteredType(&float_ty); } analysis::Type* ConvertToHalfPass::FloatVectorType(uint32_t v_len, uint32_t width) { analysis::Type* reg_float_ty = FloatScalarType(width); analysis::Vector vec_ty(reg_float_ty, v_len); return context()->get_type_mgr()->GetRegisteredType(&vec_ty); } analysis::Type* ConvertToHalfPass::FloatMatrixType(uint32_t v_cnt, uint32_t vty_id, uint32_t width) { Instruction* vty_inst = get_def_use_mgr()->GetDef(vty_id); uint32_t v_len = vty_inst->GetSingleWordInOperand(1); analysis::Type* reg_vec_ty = FloatVectorType(v_len, width); analysis::Matrix mat_ty(reg_vec_ty, v_cnt); return context()->get_type_mgr()->GetRegisteredType(&mat_ty); } uint32_t ConvertToHalfPass::EquivFloatTypeId(uint32_t ty_id, uint32_t width) { analysis::Type* reg_equiv_ty; Instruction* ty_inst = get_def_use_mgr()->GetDef(ty_id); if (ty_inst->opcode() == spv::Op::OpTypeMatrix) reg_equiv_ty = FloatMatrixType(ty_inst->GetSingleWordInOperand(1), ty_inst->GetSingleWordInOperand(0), width); else if (ty_inst->opcode() == spv::Op::OpTypeVector) reg_equiv_ty = FloatVectorType(ty_inst->GetSingleWordInOperand(1), width); else // spv::Op::OpTypeFloat reg_equiv_ty = FloatScalarType(width); return context()->get_type_mgr()->GetTypeInstruction(reg_equiv_ty); } void ConvertToHalfPass::GenConvert(uint32_t* val_idp, uint32_t width, Instruction* inst) { Instruction* val_inst = get_def_use_mgr()->GetDef(*val_idp); uint32_t ty_id = val_inst->type_id(); uint32_t nty_id = EquivFloatTypeId(ty_id, width); if (nty_id == ty_id) return; Instruction* cvt_inst; InstructionBuilder builder( context(), inst, IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); if (val_inst->opcode() == spv::Op::OpUndef) cvt_inst = builder.AddNullaryOp(nty_id, spv::Op::OpUndef); else cvt_inst = builder.AddUnaryOp(nty_id, spv::Op::OpFConvert, *val_idp); *val_idp = cvt_inst->result_id(); } bool ConvertToHalfPass::MatConvertCleanup(Instruction* inst) { if (inst->opcode() != spv::Op::OpFConvert) return false; uint32_t mty_id = inst->type_id(); Instruction* mty_inst = get_def_use_mgr()->GetDef(mty_id); if (mty_inst->opcode() != spv::Op::OpTypeMatrix) return false; uint32_t vty_id = mty_inst->GetSingleWordInOperand(0); uint32_t v_cnt = mty_inst->GetSingleWordInOperand(1); Instruction* vty_inst = get_def_use_mgr()->GetDef(vty_id); uint32_t cty_id = vty_inst->GetSingleWordInOperand(0); Instruction* cty_inst = get_def_use_mgr()->GetDef(cty_id); InstructionBuilder builder( context(), inst, IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); // Convert each component vector, combine them with OpCompositeConstruct // and replace original instruction. uint32_t orig_width = (cty_inst->GetSingleWordInOperand(0) == 16) ? 32 : 16; uint32_t orig_mat_id = inst->GetSingleWordInOperand(0); uint32_t orig_vty_id = EquivFloatTypeId(vty_id, orig_width); std::vector opnds = {}; for (uint32_t vidx = 0; vidx < v_cnt; ++vidx) { Instruction* ext_inst = builder.AddIdLiteralOp( orig_vty_id, spv::Op::OpCompositeExtract, orig_mat_id, vidx); Instruction* cvt_inst = builder.AddUnaryOp(vty_id, spv::Op::OpFConvert, ext_inst->result_id()); opnds.push_back({SPV_OPERAND_TYPE_ID, {cvt_inst->result_id()}}); } uint32_t mat_id = TakeNextId(); std::unique_ptr mat_inst(new Instruction( context(), spv::Op::OpCompositeConstruct, mty_id, mat_id, opnds)); (void)builder.AddInstruction(std::move(mat_inst)); context()->ReplaceAllUsesWith(inst->result_id(), mat_id); // Turn original instruction into copy so it is valid. inst->SetOpcode(spv::Op::OpCopyObject); inst->SetResultType(EquivFloatTypeId(mty_id, orig_width)); get_def_use_mgr()->AnalyzeInstUse(inst); return true; } bool ConvertToHalfPass::RemoveRelaxedDecoration(uint32_t id) { return context()->get_decoration_mgr()->RemoveDecorationsFrom( id, [](const Instruction& dec) { if (dec.opcode() == spv::Op::OpDecorate && spv::Decoration(dec.GetSingleWordInOperand(1u)) == spv::Decoration::RelaxedPrecision) { return true; } else return false; }); } bool ConvertToHalfPass::GenHalfArith(Instruction* inst) { bool modified = false; // If this is a OpCompositeExtract instruction and has a struct operand, we // should not relax this instruction. Doing so could cause a mismatch between // the result type and the struct member type. bool hasStructOperand = false; if (inst->opcode() == spv::Op::OpCompositeExtract) { inst->ForEachInId([&hasStructOperand, this](uint32_t* idp) { Instruction* op_inst = get_def_use_mgr()->GetDef(*idp); if (IsStruct(op_inst)) hasStructOperand = true; }); if (hasStructOperand) { return false; } } // Convert all float32 based operands to float16 equivalent and change // instruction type to float16 equivalent. inst->ForEachInId([&inst, &modified, this](uint32_t* idp) { Instruction* op_inst = get_def_use_mgr()->GetDef(*idp); if (!IsFloat(op_inst, 32)) return; GenConvert(idp, 16, inst); modified = true; }); if (IsFloat(inst, 32)) { inst->SetResultType(EquivFloatTypeId(inst->type_id(), 16)); converted_ids_.insert(inst->result_id()); modified = true; } if (modified) get_def_use_mgr()->AnalyzeInstUse(inst); return modified; } bool ConvertToHalfPass::ProcessPhi(Instruction* inst, uint32_t from_width, uint32_t to_width) { // Add converts of any float operands to to_width if they are of from_width. // If converting to 16, change type of phi to float16 equivalent and remember // result id. Converts need to be added to preceding blocks. uint32_t ocnt = 0; uint32_t* prev_idp; bool modified = false; inst->ForEachInId([&ocnt, &prev_idp, &from_width, &to_width, &modified, this](uint32_t* idp) { if (ocnt % 2 == 0) { prev_idp = idp; } else { Instruction* val_inst = get_def_use_mgr()->GetDef(*prev_idp); if (IsFloat(val_inst, from_width)) { BasicBlock* bp = context()->get_instr_block(*idp); auto insert_before = bp->tail(); if (insert_before != bp->begin()) { --insert_before; if (insert_before->opcode() != spv::Op::OpSelectionMerge && insert_before->opcode() != spv::Op::OpLoopMerge) ++insert_before; } GenConvert(prev_idp, to_width, &*insert_before); modified = true; } } ++ocnt; }); if (to_width == 16u) { inst->SetResultType(EquivFloatTypeId(inst->type_id(), 16u)); converted_ids_.insert(inst->result_id()); modified = true; } if (modified) get_def_use_mgr()->AnalyzeInstUse(inst); return modified; } bool ConvertToHalfPass::ProcessConvert(Instruction* inst) { // If float32 and relaxed, change to float16 convert if (IsFloat(inst, 32) && IsRelaxed(inst->result_id())) { inst->SetResultType(EquivFloatTypeId(inst->type_id(), 16)); get_def_use_mgr()->AnalyzeInstUse(inst); converted_ids_.insert(inst->result_id()); } // If operand and result types are the same, change FConvert to CopyObject to // keep validator happy; simplification and DCE will clean it up // One way this can happen is if an FConvert generated during this pass // (likely by ProcessPhi) is later encountered here and its operand has been // changed to half. uint32_t val_id = inst->GetSingleWordInOperand(0); Instruction* val_inst = get_def_use_mgr()->GetDef(val_id); if (inst->type_id() == val_inst->type_id()) inst->SetOpcode(spv::Op::OpCopyObject); return true; // modified } bool ConvertToHalfPass::ProcessImageRef(Instruction* inst) { bool modified = false; // If image reference, only need to convert dref args back to float32 if (dref_image_ops_.count(inst->opcode()) != 0) { uint32_t dref_id = inst->GetSingleWordInOperand(kImageSampleDrefIdInIdx); if (converted_ids_.count(dref_id) > 0) { GenConvert(&dref_id, 32, inst); inst->SetInOperand(kImageSampleDrefIdInIdx, {dref_id}); get_def_use_mgr()->AnalyzeInstUse(inst); modified = true; } } return modified; } bool ConvertToHalfPass::ProcessDefault(Instruction* inst) { // If non-relaxed instruction has changed operands, need to convert // them back to float32 if (inst->opcode() == spv::Op::OpPhi) return ProcessPhi(inst, 16u, 32u); bool modified = false; inst->ForEachInId([&inst, &modified, this](uint32_t* idp) { if (converted_ids_.count(*idp) == 0) return; uint32_t old_id = *idp; GenConvert(idp, 32, inst); if (*idp != old_id) modified = true; }); if (modified) get_def_use_mgr()->AnalyzeInstUse(inst); return modified; } bool ConvertToHalfPass::GenHalfInst(Instruction* inst) { bool modified = false; // Remember id for later deletion of RelaxedPrecision decoration bool inst_relaxed = IsRelaxed(inst->result_id()); if (IsArithmetic(inst) && inst_relaxed) modified = GenHalfArith(inst); else if (inst->opcode() == spv::Op::OpPhi && inst_relaxed) modified = ProcessPhi(inst, 32u, 16u); else if (inst->opcode() == spv::Op::OpFConvert) modified = ProcessConvert(inst); else if (image_ops_.count(inst->opcode()) != 0) modified = ProcessImageRef(inst); else modified = ProcessDefault(inst); return modified; } bool ConvertToHalfPass::CloseRelaxInst(Instruction* inst) { if (inst->result_id() == 0) return false; if (IsRelaxed(inst->result_id())) return false; if (!IsFloat(inst, 32)) return false; if (IsDecoratedRelaxed(inst)) { AddRelaxed(inst->result_id()); return true; } if (closure_ops_.count(inst->opcode()) == 0) return false; // Can relax if all float operands are relaxed bool relax = true; bool hasStructOperand = false; inst->ForEachInId([&relax, &hasStructOperand, this](uint32_t* idp) { Instruction* op_inst = get_def_use_mgr()->GetDef(*idp); if (IsStruct(op_inst)) hasStructOperand = true; if (!IsFloat(op_inst, 32)) return; if (!IsRelaxed(*idp)) relax = false; }); // If the instruction has a struct operand, we should not relax it, even if // all its uses are relaxed. Doing so could cause a mismatch between the // result type and the struct member type. if (hasStructOperand) { return false; } if (relax) { AddRelaxed(inst->result_id()); return true; } // Can relax if all uses are relaxed relax = true; get_def_use_mgr()->ForEachUser(inst, [&relax, this](Instruction* uinst) { if (uinst->result_id() == 0 || !IsFloat(uinst, 32) || (!IsDecoratedRelaxed(uinst) && !IsRelaxed(uinst->result_id())) || !CanRelaxOpOperands(uinst)) { relax = false; return; } }); if (relax) { AddRelaxed(inst->result_id()); return true; } return false; } bool ConvertToHalfPass::ProcessFunction(Function* func) { // Do a closure of Relaxed on composite and phi instructions bool changed = true; while (changed) { changed = false; cfg()->ForEachBlockInReversePostOrder( func->entry().get(), [&changed, this](BasicBlock* bb) { for (auto ii = bb->begin(); ii != bb->end(); ++ii) changed |= CloseRelaxInst(&*ii); }); } // Do convert of relaxed instructions to half precision bool modified = false; cfg()->ForEachBlockInReversePostOrder( func->entry().get(), [&modified, this](BasicBlock* bb) { for (auto ii = bb->begin(); ii != bb->end(); ++ii) modified |= GenHalfInst(&*ii); }); // Replace invalid converts of matrix into equivalent vector extracts, // converts and finally a composite construct cfg()->ForEachBlockInReversePostOrder( func->entry().get(), [&modified, this](BasicBlock* bb) { for (auto ii = bb->begin(); ii != bb->end(); ++ii) modified |= MatConvertCleanup(&*ii); }); return modified; } Pass::Status ConvertToHalfPass::ProcessImpl() { Pass::ProcessFunction pfn = [this](Function* fp) { return ProcessFunction(fp); }; bool modified = context()->ProcessReachableCallTree(pfn); // If modified, make sure module has Float16 capability if (modified) context()->AddCapability(spv::Capability::Float16); // Remove all RelaxedPrecision decorations from instructions and globals for (auto c_id : relaxed_ids_set_) { modified |= RemoveRelaxedDecoration(c_id); } for (auto& val : get_module()->types_values()) { uint32_t v_id = val.result_id(); if (v_id != 0) { modified |= RemoveRelaxedDecoration(v_id); } } return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } Pass::Status ConvertToHalfPass::Process() { Initialize(); return ProcessImpl(); } void ConvertToHalfPass::Initialize() { target_ops_core_ = { spv::Op::OpVectorExtractDynamic, spv::Op::OpVectorInsertDynamic, spv::Op::OpVectorShuffle, spv::Op::OpCompositeConstruct, spv::Op::OpCompositeInsert, spv::Op::OpCompositeExtract, spv::Op::OpCopyObject, spv::Op::OpTranspose, spv::Op::OpConvertSToF, spv::Op::OpConvertUToF, // spv::Op::OpFConvert, // spv::Op::OpQuantizeToF16, spv::Op::OpFNegate, spv::Op::OpFAdd, spv::Op::OpFSub, spv::Op::OpFMul, spv::Op::OpFDiv, spv::Op::OpFMod, spv::Op::OpVectorTimesScalar, spv::Op::OpMatrixTimesScalar, spv::Op::OpVectorTimesMatrix, spv::Op::OpMatrixTimesVector, spv::Op::OpMatrixTimesMatrix, spv::Op::OpOuterProduct, spv::Op::OpDot, spv::Op::OpSelect, spv::Op::OpFOrdEqual, spv::Op::OpFUnordEqual, spv::Op::OpFOrdNotEqual, spv::Op::OpFUnordNotEqual, spv::Op::OpFOrdLessThan, spv::Op::OpFUnordLessThan, spv::Op::OpFOrdGreaterThan, spv::Op::OpFUnordGreaterThan, spv::Op::OpFOrdLessThanEqual, spv::Op::OpFUnordLessThanEqual, spv::Op::OpFOrdGreaterThanEqual, spv::Op::OpFUnordGreaterThanEqual, }; target_ops_450_ = { GLSLstd450Round, GLSLstd450RoundEven, GLSLstd450Trunc, GLSLstd450FAbs, GLSLstd450FSign, GLSLstd450Floor, GLSLstd450Ceil, GLSLstd450Fract, GLSLstd450Radians, GLSLstd450Degrees, GLSLstd450Sin, GLSLstd450Cos, GLSLstd450Tan, GLSLstd450Asin, GLSLstd450Acos, GLSLstd450Atan, GLSLstd450Sinh, GLSLstd450Cosh, GLSLstd450Tanh, GLSLstd450Asinh, GLSLstd450Acosh, GLSLstd450Atanh, GLSLstd450Atan2, GLSLstd450Pow, GLSLstd450Exp, GLSLstd450Log, GLSLstd450Exp2, GLSLstd450Log2, GLSLstd450Sqrt, GLSLstd450InverseSqrt, GLSLstd450Determinant, GLSLstd450MatrixInverse, // TODO(greg-lunarg): GLSLstd450ModfStruct, GLSLstd450FMin, GLSLstd450FMax, GLSLstd450FClamp, GLSLstd450FMix, GLSLstd450Step, GLSLstd450SmoothStep, GLSLstd450Fma, // TODO(greg-lunarg): GLSLstd450FrexpStruct, GLSLstd450Ldexp, GLSLstd450Length, GLSLstd450Distance, GLSLstd450Cross, GLSLstd450Normalize, GLSLstd450FaceForward, GLSLstd450Reflect, GLSLstd450Refract, GLSLstd450NMin, GLSLstd450NMax, GLSLstd450NClamp}; image_ops_ = {spv::Op::OpImageSampleImplicitLod, spv::Op::OpImageSampleExplicitLod, spv::Op::OpImageSampleDrefImplicitLod, spv::Op::OpImageSampleDrefExplicitLod, spv::Op::OpImageSampleProjImplicitLod, spv::Op::OpImageSampleProjExplicitLod, spv::Op::OpImageSampleProjDrefImplicitLod, spv::Op::OpImageSampleProjDrefExplicitLod, spv::Op::OpImageFetch, spv::Op::OpImageGather, spv::Op::OpImageDrefGather, spv::Op::OpImageRead, spv::Op::OpImageSparseSampleImplicitLod, spv::Op::OpImageSparseSampleExplicitLod, spv::Op::OpImageSparseSampleDrefImplicitLod, spv::Op::OpImageSparseSampleDrefExplicitLod, spv::Op::OpImageSparseSampleProjImplicitLod, spv::Op::OpImageSparseSampleProjExplicitLod, spv::Op::OpImageSparseSampleProjDrefImplicitLod, spv::Op::OpImageSparseSampleProjDrefExplicitLod, spv::Op::OpImageSparseFetch, spv::Op::OpImageSparseGather, spv::Op::OpImageSparseDrefGather, spv::Op::OpImageSparseTexelsResident, spv::Op::OpImageSparseRead}; dref_image_ops_ = { spv::Op::OpImageSampleDrefImplicitLod, spv::Op::OpImageSampleDrefExplicitLod, spv::Op::OpImageSampleProjDrefImplicitLod, spv::Op::OpImageSampleProjDrefExplicitLod, spv::Op::OpImageDrefGather, spv::Op::OpImageSparseSampleDrefImplicitLod, spv::Op::OpImageSparseSampleDrefExplicitLod, spv::Op::OpImageSparseSampleProjDrefImplicitLod, spv::Op::OpImageSparseSampleProjDrefExplicitLod, spv::Op::OpImageSparseDrefGather, }; closure_ops_ = { spv::Op::OpVectorExtractDynamic, spv::Op::OpVectorInsertDynamic, spv::Op::OpVectorShuffle, spv::Op::OpCompositeConstruct, spv::Op::OpCompositeInsert, spv::Op::OpCompositeExtract, spv::Op::OpCopyObject, spv::Op::OpTranspose, spv::Op::OpPhi, }; relaxed_ids_set_.clear(); converted_ids_.clear(); } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/convert_to_half_pass.h000066400000000000000000000127511475742701700252140ustar00rootroot00000000000000// Copyright (c) 2019 Valve Corporation // Copyright (c) 2019 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef LIBSPIRV_OPT_CONVERT_TO_HALF_PASS_H_ #define LIBSPIRV_OPT_CONVERT_TO_HALF_PASS_H_ #include "source/opt/ir_builder.h" #include "source/opt/pass.h" namespace spvtools { namespace opt { class ConvertToHalfPass : public Pass { public: ConvertToHalfPass() : Pass() {} ~ConvertToHalfPass() override = default; IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping; } // See optimizer.hpp for pass user documentation. Status Process() override; const char* name() const override { return "convert-to-half-pass"; } private: // Return true if |inst| is an arithmetic, composite or phi op that can be // of type float16 bool IsArithmetic(Instruction* inst); // Return true if |inst| returns scalar, vector or matrix type with base // float and |width| bool IsFloat(Instruction* inst, uint32_t width); bool IsStruct(Instruction* inst); // Return true if |inst| is decorated with RelaxedPrecision bool IsDecoratedRelaxed(Instruction* inst); // Return true if |id| has been added to the relaxed id set bool IsRelaxed(uint32_t id); // Add |id| to the relaxed id set void AddRelaxed(uint32_t id); // Return true if the instruction's operands can be relaxed bool CanRelaxOpOperands(Instruction* inst); // Return type id for float with |width| analysis::Type* FloatScalarType(uint32_t width); // Return type id for vector of length |vlen| of float of |width| analysis::Type* FloatVectorType(uint32_t v_len, uint32_t width); // Return type id for matrix of |v_cnt| vectors of length identical to // |vty_id| of float of |width| analysis::Type* FloatMatrixType(uint32_t v_cnt, uint32_t vty_id, uint32_t width); // Return equivalent to float type |ty_id| with |width| uint32_t EquivFloatTypeId(uint32_t ty_id, uint32_t width); // Append instructions to builder to convert value |*val_idp| to type // |ty_id| but with |width|. Set |*val_idp| to the new id. void GenConvert(uint32_t* val_idp, uint32_t width, Instruction* inst); // Remove RelaxedPrecision decoration of |id|. bool RemoveRelaxedDecoration(uint32_t id); // Add |inst| to relaxed instruction set if warranted. Specifically, if // it is float32 and either decorated relaxed or a composite or phi // instruction where all operands are relaxed or all uses are relaxed. bool CloseRelaxInst(Instruction* inst); // If |inst| is an arithmetic, phi, extract or convert instruction of float32 // base type and decorated with RelaxedPrecision, change it to the equivalent // float16 based type instruction. Specifically, insert instructions to // convert all operands to float16 (if needed) and change its type to the // equivalent float16 type. Otherwise, insert instructions to convert its // operands back to their original types, if needed. bool GenHalfInst(Instruction* inst); // Gen code for relaxed arithmetic |inst| bool GenHalfArith(Instruction* inst); // Gen code for relaxed phi |inst| bool ProcessPhi(Instruction* inst, uint32_t from_width, uint32_t to_width); // Gen code for relaxed convert |inst| bool ProcessConvert(Instruction* inst); // Gen code for image reference |inst| bool ProcessImageRef(Instruction* inst); // Process default non-relaxed |inst| bool ProcessDefault(Instruction* inst); // If |inst| is an FConvert of a matrix type, decompose it to a series // of vector extracts, converts and inserts into an Undef. These are // generated by GenHalfInst because they are easier to manipulate, but are // invalid so we need to clean them up. bool MatConvertCleanup(Instruction* inst); // Call GenHalfInst on every instruction in |func|. // If code is generated for an instruction, replace the instruction // with the new instructions that are generated. bool ProcessFunction(Function* func); Pass::Status ProcessImpl(); // Initialize state for converting to half void Initialize(); struct hasher { size_t operator()(const spv::Op& op) const noexcept { return std::hash()(uint32_t(op)); } }; // Set of core operations to be processed std::unordered_set target_ops_core_; // Set of 450 extension operations to be processed std::unordered_set target_ops_450_; // Set of all sample operations, including dref and non-dref operations std::unordered_set image_ops_; // Set of only dref sample operations std::unordered_set dref_image_ops_; // Set of operations that can be marked as relaxed std::unordered_set closure_ops_; // Set of ids of all relaxed instructions std::unordered_set relaxed_ids_set_; // Ids of all converted instructions std::unordered_set converted_ids_; }; } // namespace opt } // namespace spvtools #endif // LIBSPIRV_OPT_CONVERT_TO_HALF_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/convert_to_sampled_image_pass.cpp000066400000000000000000000377641475742701700274370ustar00rootroot00000000000000// Copyright (c) 2021 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/convert_to_sampled_image_pass.h" #include #include #include "source/opt/ir_builder.h" #include "source/util/make_unique.h" #include "source/util/parse_number.h" namespace spvtools { namespace opt { using VectorOfDescriptorSetAndBindingPairs = std::vector; using DescriptorSetBindingToInstruction = ConvertToSampledImagePass::DescriptorSetBindingToInstruction; namespace { using utils::ParseNumber; // Returns true if the given char is ':', '\0' or considered as blank space // (i.e.: '\n', '\r', '\v', '\t', '\f' and ' '). bool IsSeparator(char ch) { return std::strchr(":\0", ch) || std::isspace(ch) != 0; } // Reads characters starting from |str| until it meets a separator. Parses a // number from the characters and stores it into |number|. Returns the pointer // to the separator if it succeeds. Otherwise, returns nullptr. const char* ParseNumberUntilSeparator(const char* str, uint32_t* number) { const char* number_begin = str; while (!IsSeparator(*str)) str++; const char* number_end = str; std::string number_in_str(number_begin, number_end - number_begin); if (!utils::ParseNumber(number_in_str.c_str(), number)) { // The descriptor set is not a valid uint32 number. return nullptr; } return str; } // Returns id of the image type used for the sampled image type of // |sampled_image|. uint32_t GetImageTypeOfSampledImage(analysis::TypeManager* type_mgr, Instruction* sampled_image) { auto* sampled_image_type = type_mgr->GetType(sampled_image->type_id())->AsSampledImage(); return type_mgr->GetTypeInstruction(sampled_image_type->image_type()); } // Finds the instruction whose id is |inst_id|. Follows the operand of // OpCopyObject recursively if the opcode of the instruction is OpCopyObject // and returns the first instruction that does not have OpCopyObject as opcode. Instruction* GetNonCopyObjectDef(analysis::DefUseManager* def_use_mgr, uint32_t inst_id) { Instruction* inst = def_use_mgr->GetDef(inst_id); while (inst->opcode() == spv::Op::OpCopyObject) { inst_id = inst->GetSingleWordInOperand(0u); inst = def_use_mgr->GetDef(inst_id); } return inst; } } // namespace bool ConvertToSampledImagePass::GetDescriptorSetBinding( const Instruction& inst, DescriptorSetAndBinding* descriptor_set_binding) const { auto* decoration_manager = context()->get_decoration_mgr(); bool found_descriptor_set_to_convert = false; bool found_binding_to_convert = false; for (auto decorate : decoration_manager->GetDecorationsFor(inst.result_id(), false)) { spv::Decoration decoration = spv::Decoration(decorate->GetSingleWordInOperand(1u)); if (decoration == spv::Decoration::DescriptorSet) { if (found_descriptor_set_to_convert) { assert(false && "A resource has two OpDecorate for the descriptor set"); return false; } descriptor_set_binding->descriptor_set = decorate->GetSingleWordInOperand(2u); found_descriptor_set_to_convert = true; } else if (decoration == spv::Decoration::Binding) { if (found_binding_to_convert) { assert(false && "A resource has two OpDecorate for the binding"); return false; } descriptor_set_binding->binding = decorate->GetSingleWordInOperand(2u); found_binding_to_convert = true; } } return found_descriptor_set_to_convert && found_binding_to_convert; } bool ConvertToSampledImagePass::ShouldResourceBeConverted( const DescriptorSetAndBinding& descriptor_set_binding) const { return descriptor_set_binding_pairs_.find(descriptor_set_binding) != descriptor_set_binding_pairs_.end(); } const analysis::Type* ConvertToSampledImagePass::GetVariableType( const Instruction& variable) const { if (variable.opcode() != spv::Op::OpVariable) return nullptr; auto* type = context()->get_type_mgr()->GetType(variable.type_id()); auto* pointer_type = type->AsPointer(); if (!pointer_type) return nullptr; return pointer_type->pointee_type(); } spv::StorageClass ConvertToSampledImagePass::GetStorageClass( const Instruction& variable) const { assert(variable.opcode() == spv::Op::OpVariable); auto* type = context()->get_type_mgr()->GetType(variable.type_id()); auto* pointer_type = type->AsPointer(); if (!pointer_type) return spv::StorageClass::Max; return pointer_type->storage_class(); } bool ConvertToSampledImagePass::CollectResourcesToConvert( DescriptorSetBindingToInstruction* descriptor_set_binding_pair_to_sampler, DescriptorSetBindingToInstruction* descriptor_set_binding_pair_to_image) const { for (auto& inst : context()->types_values()) { const auto* variable_type = GetVariableType(inst); if (variable_type == nullptr) continue; DescriptorSetAndBinding descriptor_set_binding; if (!GetDescriptorSetBinding(inst, &descriptor_set_binding)) continue; if (!ShouldResourceBeConverted(descriptor_set_binding)) { continue; } if (variable_type->AsImage()) { if (!descriptor_set_binding_pair_to_image ->insert({descriptor_set_binding, &inst}) .second) { return false; } } else if (variable_type->AsSampler()) { if (!descriptor_set_binding_pair_to_sampler ->insert({descriptor_set_binding, &inst}) .second) { return false; } } } return true; } Pass::Status ConvertToSampledImagePass::Process() { Status status = Status::SuccessWithoutChange; DescriptorSetBindingToInstruction descriptor_set_binding_pair_to_sampler, descriptor_set_binding_pair_to_image; if (!CollectResourcesToConvert(&descriptor_set_binding_pair_to_sampler, &descriptor_set_binding_pair_to_image)) { return Status::Failure; } for (auto& image : descriptor_set_binding_pair_to_image) { status = CombineStatus( status, UpdateImageVariableToSampledImage(image.second, image.first)); if (status == Status::Failure) { return status; } } for (const auto& sampler : descriptor_set_binding_pair_to_sampler) { // Converting only a Sampler to Sampled Image is not allowed. It must have a // corresponding image to combine the sampler with. auto image_itr = descriptor_set_binding_pair_to_image.find(sampler.first); if (image_itr == descriptor_set_binding_pair_to_image.end() || image_itr->second == nullptr) { return Status::Failure; } status = CombineStatus( status, CheckUsesOfSamplerVariable(sampler.second, image_itr->second)); if (status == Status::Failure) { return status; } } return status; } void ConvertToSampledImagePass::FindUses(const Instruction* inst, std::vector* uses, spv::Op user_opcode) const { auto* def_use_mgr = context()->get_def_use_mgr(); def_use_mgr->ForEachUser(inst, [uses, user_opcode, this](Instruction* user) { if (user->opcode() == user_opcode) { uses->push_back(user); } else if (user->opcode() == spv::Op::OpCopyObject) { FindUses(user, uses, user_opcode); } }); } void ConvertToSampledImagePass::FindUsesOfImage( const Instruction* image, std::vector* uses) const { auto* def_use_mgr = context()->get_def_use_mgr(); def_use_mgr->ForEachUser(image, [uses, this](Instruction* user) { switch (user->opcode()) { case spv::Op::OpImageFetch: case spv::Op::OpImageRead: case spv::Op::OpImageWrite: case spv::Op::OpImageQueryFormat: case spv::Op::OpImageQueryOrder: case spv::Op::OpImageQuerySizeLod: case spv::Op::OpImageQuerySize: case spv::Op::OpImageQueryLevels: case spv::Op::OpImageQuerySamples: case spv::Op::OpImageSparseFetch: uses->push_back(user); default: break; } if (user->opcode() == spv::Op::OpCopyObject) { FindUsesOfImage(user, uses); } }); } Instruction* ConvertToSampledImagePass::CreateImageExtraction( Instruction* sampled_image) { InstructionBuilder builder( context(), sampled_image->NextNode(), IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); return builder.AddUnaryOp( GetImageTypeOfSampledImage(context()->get_type_mgr(), sampled_image), spv::Op::OpImage, sampled_image->result_id()); } uint32_t ConvertToSampledImagePass::GetSampledImageTypeForImage( Instruction* image_variable) { const auto* variable_type = GetVariableType(*image_variable); if (variable_type == nullptr) return 0; const auto* image_type = variable_type->AsImage(); if (image_type == nullptr) return 0; analysis::Image image_type_for_sampled_image(*image_type); analysis::SampledImage sampled_image_type(&image_type_for_sampled_image); return context()->get_type_mgr()->GetTypeInstruction(&sampled_image_type); } Instruction* ConvertToSampledImagePass::UpdateImageUses( Instruction* sampled_image_load) { std::vector uses_of_load; FindUsesOfImage(sampled_image_load, &uses_of_load); if (uses_of_load.empty()) return nullptr; auto* extracted_image = CreateImageExtraction(sampled_image_load); for (auto* user : uses_of_load) { user->SetInOperand(0, {extracted_image->result_id()}); context()->get_def_use_mgr()->AnalyzeInstUse(user); } return extracted_image; } bool ConvertToSampledImagePass:: IsSamplerOfSampledImageDecoratedByDescriptorSetBinding( Instruction* sampled_image_inst, const DescriptorSetAndBinding& descriptor_set_binding) { auto* def_use_mgr = context()->get_def_use_mgr(); uint32_t sampler_id = sampled_image_inst->GetSingleWordInOperand(1u); auto* sampler_load = def_use_mgr->GetDef(sampler_id); if (sampler_load->opcode() != spv::Op::OpLoad) return false; auto* sampler = def_use_mgr->GetDef(sampler_load->GetSingleWordInOperand(0u)); DescriptorSetAndBinding sampler_descriptor_set_binding; return GetDescriptorSetBinding(*sampler, &sampler_descriptor_set_binding) && sampler_descriptor_set_binding == descriptor_set_binding; } void ConvertToSampledImagePass::UpdateSampledImageUses( Instruction* image_load, Instruction* image_extraction, const DescriptorSetAndBinding& image_descriptor_set_binding) { std::vector sampled_image_users; FindUses(image_load, &sampled_image_users, spv::Op::OpSampledImage); auto* def_use_mgr = context()->get_def_use_mgr(); for (auto* sampled_image_inst : sampled_image_users) { if (IsSamplerOfSampledImageDecoratedByDescriptorSetBinding( sampled_image_inst, image_descriptor_set_binding)) { context()->ReplaceAllUsesWith(sampled_image_inst->result_id(), image_load->result_id()); def_use_mgr->AnalyzeInstUse(image_load); context()->KillInst(sampled_image_inst); } else { if (!image_extraction) image_extraction = CreateImageExtraction(image_load); sampled_image_inst->SetInOperand(0, {image_extraction->result_id()}); def_use_mgr->AnalyzeInstUse(sampled_image_inst); } } } void ConvertToSampledImagePass::MoveInstructionNextToType(Instruction* inst, uint32_t type_id) { auto* type_inst = context()->get_def_use_mgr()->GetDef(type_id); inst->SetResultType(type_id); inst->RemoveFromList(); inst->InsertAfter(type_inst); } bool ConvertToSampledImagePass::ConvertImageVariableToSampledImage( Instruction* image_variable, uint32_t sampled_image_type_id) { auto* sampled_image_type = context()->get_type_mgr()->GetType(sampled_image_type_id); if (sampled_image_type == nullptr) return false; auto storage_class = GetStorageClass(*image_variable); if (storage_class == spv::StorageClass::Max) return false; // Make sure |image_variable| is behind its type i.e., avoid the forward // reference. uint32_t type_id = context()->get_type_mgr()->FindPointerToType( sampled_image_type_id, storage_class); MoveInstructionNextToType(image_variable, type_id); return true; } Pass::Status ConvertToSampledImagePass::UpdateImageVariableToSampledImage( Instruction* image_variable, const DescriptorSetAndBinding& descriptor_set_binding) { std::vector image_variable_loads; FindUses(image_variable, &image_variable_loads, spv::Op::OpLoad); if (image_variable_loads.empty()) return Status::SuccessWithoutChange; const uint32_t sampled_image_type_id = GetSampledImageTypeForImage(image_variable); if (!sampled_image_type_id) return Status::Failure; for (auto* load : image_variable_loads) { load->SetResultType(sampled_image_type_id); auto* image_extraction = UpdateImageUses(load); UpdateSampledImageUses(load, image_extraction, descriptor_set_binding); } return ConvertImageVariableToSampledImage(image_variable, sampled_image_type_id) ? Status::SuccessWithChange : Status::Failure; } bool ConvertToSampledImagePass::DoesSampledImageReferenceImage( Instruction* sampled_image_inst, Instruction* image_variable) { if (sampled_image_inst->opcode() != spv::Op::OpSampledImage) return false; auto* def_use_mgr = context()->get_def_use_mgr(); auto* image_load = GetNonCopyObjectDef( def_use_mgr, sampled_image_inst->GetSingleWordInOperand(0u)); if (image_load->opcode() != spv::Op::OpLoad) return false; auto* image = GetNonCopyObjectDef(def_use_mgr, image_load->GetSingleWordInOperand(0u)); return image->opcode() == spv::Op::OpVariable && image->result_id() == image_variable->result_id(); } Pass::Status ConvertToSampledImagePass::CheckUsesOfSamplerVariable( const Instruction* sampler_variable, Instruction* image_to_be_combined_with) { if (image_to_be_combined_with == nullptr) return Status::Failure; std::vector sampler_variable_loads; FindUses(sampler_variable, &sampler_variable_loads, spv::Op::OpLoad); for (auto* load : sampler_variable_loads) { std::vector sampled_image_users; FindUses(load, &sampled_image_users, spv::Op::OpSampledImage); for (auto* sampled_image_inst : sampled_image_users) { if (!DoesSampledImageReferenceImage(sampled_image_inst, image_to_be_combined_with)) { return Status::Failure; } } } return Status::SuccessWithoutChange; } std::unique_ptr ConvertToSampledImagePass::ParseDescriptorSetBindingPairsString( const char* str) { if (!str) return nullptr; auto descriptor_set_binding_pairs = MakeUnique(); while (std::isspace(*str)) str++; // skip leading spaces. // The parsing loop, break when points to the end. while (*str) { // Parse the descriptor set. uint32_t descriptor_set = 0; str = ParseNumberUntilSeparator(str, &descriptor_set); if (str == nullptr) return nullptr; // Find the ':', spaces between the descriptor set and the ':' are not // allowed. if (*str++ != ':') { // ':' not found return nullptr; } // Parse the binding. uint32_t binding = 0; str = ParseNumberUntilSeparator(str, &binding); if (str == nullptr) return nullptr; descriptor_set_binding_pairs->push_back({descriptor_set, binding}); // Skip trailing spaces. while (std::isspace(*str)) str++; } return descriptor_set_binding_pairs; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/convert_to_sampled_image_pass.h000066400000000000000000000223151475742701700270660ustar00rootroot00000000000000// Copyright (c) 2021 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_CONVERT_TO_SAMPLED_IMAGE_PASS_H_ #define SOURCE_OPT_CONVERT_TO_SAMPLED_IMAGE_PASS_H_ #include #include #include #include "source/opt/pass.h" #include "source/opt/types.h" namespace spvtools { namespace opt { // A struct for a pair of descriptor set and binding. struct DescriptorSetAndBinding { uint32_t descriptor_set; uint32_t binding; bool operator==(const DescriptorSetAndBinding& descriptor_set_binding) const { return descriptor_set_binding.descriptor_set == descriptor_set && descriptor_set_binding.binding == binding; } }; // See optimizer.hpp for documentation. class ConvertToSampledImagePass : public Pass { public: // Hashing functor for the pair of descriptor set and binding. struct DescriptorSetAndBindingHash { size_t operator()( const DescriptorSetAndBinding& descriptor_set_binding) const { return std::hash()(descriptor_set_binding.descriptor_set) ^ std::hash()(descriptor_set_binding.binding); } }; using SetOfDescriptorSetAndBindingPairs = std::unordered_set; using DescriptorSetBindingToInstruction = std::unordered_map; explicit ConvertToSampledImagePass( const std::vector& descriptor_set_binding_pairs) : descriptor_set_binding_pairs_(descriptor_set_binding_pairs.begin(), descriptor_set_binding_pairs.end()) {} const char* name() const override { return "convert-to-sampled-image"; } Status Process() override; // Parses the given null-terminated C string to get a vector of descriptor set // and binding pairs. Returns a unique pointer to the vector of descriptor set // and binding pairs built from the given |str| on success. Returns a nullptr // if the given string is not valid for building the vector of pairs. // A valid string for building the vector of pairs should follow the rule // below: // // ": : ..." // Example: // "3:5 2:1 0:4" // // Entries are separated with blank spaces (i.e.:' ', '\n', '\r', '\t', // '\f', '\v'). Each entry corresponds to a descriptor set and binding pair. // Multiple spaces between, before or after entries are allowed. However, // spaces are not allowed within a descriptor set or binding. // // In each entry, the descriptor set and binding are separated by ':'. // Missing ':' in any entry is invalid. And it is invalid to have blank // spaces in between the descriptor set and ':' or ':' and the binding. // // : the descriptor set. // The text must represent a valid uint32_t number. // // : the binding. // The text must represent a valid uint32_t number. static std::unique_ptr> ParseDescriptorSetBindingPairsString(const char* str); private: // Collects resources to convert to sampled image and saves them in // |descriptor_set_binding_pair_to_sampler| if the resource is a sampler and // saves them in |descriptor_set_binding_pair_to_image| if the resource is an // image. Returns false if two samplers or two images have the same descriptor // set and binding. Otherwise, returns true. bool CollectResourcesToConvert( DescriptorSetBindingToInstruction* descriptor_set_binding_pair_to_sampler, DescriptorSetBindingToInstruction* descriptor_set_binding_pair_to_image) const; // Finds an OpDecorate with DescriptorSet decorating |inst| and another // OpDecorate with Binding decorating |inst|. Stores the descriptor set and // binding in |descriptor_set_binding|. Returns whether it successfully finds // the descriptor set and binding or not. bool GetDescriptorSetBinding( const Instruction& inst, DescriptorSetAndBinding* descriptor_set_binding) const; // Returns whether |descriptor_set_binding| is a pair of a descriptor set // and a binding that we have to convert resources with it to a sampled image // or not. bool ShouldResourceBeConverted( const DescriptorSetAndBinding& descriptor_set_binding) const; // Returns the pointee type of the type of variable |variable|. If |variable| // is not an OpVariable instruction, just returns nullptr. const analysis::Type* GetVariableType(const Instruction& variable) const; // Returns the storage class of |variable|. spv::StorageClass GetStorageClass(const Instruction& variable) const; // Finds |inst|'s users whose opcode is |user_opcode| or users of OpCopyObject // instructions of |inst| whose opcode is |user_opcode| and puts them in // |uses|. void FindUses(const Instruction* inst, std::vector* uses, spv::Op user_opcode) const; // Finds OpImage* instructions using |image| or OpCopyObject instructions that // copy |image| and puts them in |uses|. void FindUsesOfImage(const Instruction* image, std::vector* uses) const; // Creates an OpImage instruction that extracts the image from the sampled // image |sampled_image|. Instruction* CreateImageExtraction(Instruction* sampled_image); // Converts |image_variable| whose type is an image pointer to sampled image // type. Updates users of |image_variable| accordingly. If some instructions // e.g., OpImageRead use |image_variable| as an Image operand, creates an // image extracted from the sampled image using OpImage and replace the Image // operands of the users with the extracted image. If some OpSampledImage // instructions use |image_variable| and sampler whose descriptor set and // binding are the same with |image_variable|, just combines |image_variable| // and the sampler to a sampled image. Pass::Status UpdateImageVariableToSampledImage( Instruction* image_variable, const DescriptorSetAndBinding& descriptor_set_binding); // Returns the id of type sampled image type whose image type is the one of // |image_variable|. uint32_t GetSampledImageTypeForImage(Instruction* image_variable); // Moves |inst| next to the OpType* instruction with |type_id|. void MoveInstructionNextToType(Instruction* inst, uint32_t type_id); // Converts |image_variable| whose type is an image pointer to sampled image // with the type id |sampled_image_type_id|. Returns whether it successfully // converts the type of |image_variable| or not. bool ConvertImageVariableToSampledImage(Instruction* image_variable, uint32_t sampled_image_type_id); // Replaces |sampled_image_load| instruction used by OpImage* with the image // extracted from |sampled_image_load|. Returns the extracted image or nullptr // if it does not have uses. Instruction* UpdateImageUses(Instruction* sampled_image_load); // Returns true if the sampler of |sampled_image_inst| is decorated by a // descriptor set and a binding |descriptor_set_binding|. bool IsSamplerOfSampledImageDecoratedByDescriptorSetBinding( Instruction* sampled_image_inst, const DescriptorSetAndBinding& descriptor_set_binding); // Replaces OpSampledImage instructions using |image_load| with |image_load| // if the sampler of the OpSampledImage instruction has descriptor set and // binding |image_descriptor_set_binding|. Otherwise, replaces |image_load| // with |image_extraction|. void UpdateSampledImageUses( Instruction* image_load, Instruction* image_extraction, const DescriptorSetAndBinding& image_descriptor_set_binding); // Checks the uses of |sampler_variable|. When a sampler is used by // OpSampledImage instruction, the corresponding image must be // |image_to_be_combined_with| that should be already converted to a sampled // image by UpdateImageVariableToSampledImage() method. Pass::Status CheckUsesOfSamplerVariable( const Instruction* sampler_variable, Instruction* image_to_be_combined_with); // Returns true if Image operand of |sampled_image_inst| is the image of // |image_variable|. bool DoesSampledImageReferenceImage(Instruction* sampled_image_inst, Instruction* image_variable); // A set of pairs of descriptor set and binding. If an image and/or a sampler // have a pair of descriptor set and binding that is an element of // |descriptor_set_binding_pairs_|, they/it will be converted to a sampled // image by this pass. const SetOfDescriptorSetAndBindingPairs descriptor_set_binding_pairs_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_CONVERT_TO_SAMPLED_IMAGE_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/copy_prop_arrays.cpp000066400000000000000000001022061475742701700247330ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/copy_prop_arrays.h" #include #include "source/opt/ir_builder.h" namespace spvtools { namespace opt { namespace { constexpr uint32_t kLoadPointerInOperand = 0; constexpr uint32_t kStorePointerInOperand = 0; constexpr uint32_t kStoreObjectInOperand = 1; constexpr uint32_t kCompositeExtractObjectInOperand = 0; constexpr uint32_t kTypePointerStorageClassInIdx = 0; constexpr uint32_t kTypePointerPointeeInIdx = 1; constexpr uint32_t kExtInstSetInIdx = 0; constexpr uint32_t kExtInstOpInIdx = 1; constexpr uint32_t kInterpolantInIdx = 2; bool IsDebugDeclareOrValue(Instruction* di) { auto dbg_opcode = di->GetCommonDebugOpcode(); return dbg_opcode == CommonDebugInfoDebugDeclare || dbg_opcode == CommonDebugInfoDebugValue; } // Returns the number of members in |type|. If |type| is not a composite type // or the number of components is not known at compile time, the return value // will be 0. uint32_t GetNumberOfMembers(const analysis::Type* type, IRContext* context) { if (const analysis::Struct* struct_type = type->AsStruct()) { return static_cast(struct_type->element_types().size()); } else if (const analysis::Array* array_type = type->AsArray()) { const analysis::Constant* length_const = context->get_constant_mgr()->FindDeclaredConstant( array_type->LengthId()); if (length_const == nullptr) { // This can happen if the length is an OpSpecConstant. return 0; } assert(length_const->type()->AsInteger()); return length_const->GetU32(); } else if (const analysis::Vector* vector_type = type->AsVector()) { return vector_type->element_count(); } else if (const analysis::Matrix* matrix_type = type->AsMatrix()) { return matrix_type->element_count(); } else { return 0; } } } // namespace Pass::Status CopyPropagateArrays::Process() { bool modified = false; for (Function& function : *get_module()) { if (function.IsDeclaration()) { continue; } BasicBlock* entry_bb = &*function.begin(); for (auto var_inst = entry_bb->begin(); var_inst->opcode() == spv::Op::OpVariable; ++var_inst) { worklist_.push(&*var_inst); } } while (!worklist_.empty()) { Instruction* var_inst = worklist_.front(); worklist_.pop(); // Find the only store to the entire memory location, if it exists. Instruction* store_inst = FindStoreInstruction(&*var_inst); if (!store_inst) { continue; } std::unique_ptr source_object = FindSourceObjectIfPossible(&*var_inst, store_inst); if (source_object != nullptr) { if (!IsPointerToArrayType(var_inst->type_id()) && source_object->GetStorageClass() != spv::StorageClass::Input) { continue; } if (CanUpdateUses(&*var_inst, source_object->GetPointerTypeId(this))) { modified = true; PropagateObject(&*var_inst, source_object.get(), store_inst); } } } return (modified ? Status::SuccessWithChange : Status::SuccessWithoutChange); } std::unique_ptr CopyPropagateArrays::FindSourceObjectIfPossible(Instruction* var_inst, Instruction* store_inst) { assert(var_inst->opcode() == spv::Op::OpVariable && "Expecting a variable."); // Check that the variable is a composite object where |store_inst| // dominates all of its loads. if (!store_inst) { return nullptr; } // Look at the loads to ensure they are dominated by the store. if (!HasValidReferencesOnly(var_inst, store_inst)) { return nullptr; } // If so, look at the store to see if it is the copy of an object. std::unique_ptr source = GetSourceObjectIfAny( store_inst->GetSingleWordInOperand(kStoreObjectInOperand)); if (!source) { return nullptr; } // Ensure that |source| does not change between the point at which it is // loaded, and the position in which |var_inst| is loaded. // // For now we will go with the easy to implement approach, and check that the // entire variable (not just the specific component) is never written to. if (!HasNoStores(source->GetVariable())) { return nullptr; } return source; } Instruction* CopyPropagateArrays::FindStoreInstruction( const Instruction* var_inst) const { Instruction* store_inst = nullptr; get_def_use_mgr()->WhileEachUser( var_inst, [&store_inst, var_inst](Instruction* use) { if (use->opcode() == spv::Op::OpStore && use->GetSingleWordInOperand(kStorePointerInOperand) == var_inst->result_id()) { if (store_inst == nullptr) { store_inst = use; } else { store_inst = nullptr; return false; } } return true; }); return store_inst; } void CopyPropagateArrays::PropagateObject(Instruction* var_inst, MemoryObject* source, Instruction* insertion_point) { assert(var_inst->opcode() == spv::Op::OpVariable && "This function propagates variables."); Instruction* new_access_chain = BuildNewAccessChain(insertion_point, source); context()->KillNamesAndDecorates(var_inst); UpdateUses(var_inst, new_access_chain); } Instruction* CopyPropagateArrays::BuildNewAccessChain( Instruction* insertion_point, CopyPropagateArrays::MemoryObject* source) const { InstructionBuilder builder( context(), insertion_point, IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); if (source->AccessChain().size() == 0) { return source->GetVariable(); } source->BuildConstants(); std::vector access_ids(source->AccessChain().size()); std::transform( source->AccessChain().cbegin(), source->AccessChain().cend(), access_ids.begin(), [](const AccessChainEntry& entry) { assert(entry.is_result_id && "Constants needs to be built first."); return entry.result_id; }); return builder.AddAccessChain(source->GetPointerTypeId(this), source->GetVariable()->result_id(), access_ids); } bool CopyPropagateArrays::HasNoStores(Instruction* ptr_inst) { return get_def_use_mgr()->WhileEachUser(ptr_inst, [this](Instruction* use) { if (use->opcode() == spv::Op::OpLoad) { return true; } else if (use->opcode() == spv::Op::OpAccessChain) { return HasNoStores(use); } else if (use->IsDecoration() || use->opcode() == spv::Op::OpName) { return true; } else if (use->opcode() == spv::Op::OpStore) { return false; } else if (use->opcode() == spv::Op::OpImageTexelPointer) { return true; } else if (use->opcode() == spv::Op::OpEntryPoint) { return true; } else if (IsInterpolationInstruction(use)) { return true; } // Some other instruction. Be conservative. return false; }); } bool CopyPropagateArrays::HasValidReferencesOnly(Instruction* ptr_inst, Instruction* store_inst) { BasicBlock* store_block = context()->get_instr_block(store_inst); DominatorAnalysis* dominator_analysis = context()->GetDominatorAnalysis(store_block->GetParent()); return get_def_use_mgr()->WhileEachUser( ptr_inst, [this, store_inst, dominator_analysis, ptr_inst](Instruction* use) { if (use->opcode() == spv::Op::OpLoad || use->opcode() == spv::Op::OpImageTexelPointer) { // TODO: If there are many load in the same BB as |store_inst| the // time to do the multiple traverses can add up. Consider collecting // those loads and doing a single traversal. return dominator_analysis->Dominates(store_inst, use); } else if (IsInterpolationInstruction(use)) { // GLSL InterpolateAt* instructions work similarly to loads uint32_t interpolant = use->GetSingleWordInOperand(kInterpolantInIdx); if (interpolant != store_inst->GetSingleWordInOperand(kStorePointerInOperand)) return false; return dominator_analysis->Dominates(store_inst, use); } else if (use->opcode() == spv::Op::OpAccessChain) { return HasValidReferencesOnly(use, store_inst); } else if (use->IsDecoration() || use->opcode() == spv::Op::OpName) { return true; } else if (use->opcode() == spv::Op::OpStore) { // If we are storing to part of the object it is not an candidate. return ptr_inst->opcode() == spv::Op::OpVariable && store_inst->GetSingleWordInOperand(kStorePointerInOperand) == ptr_inst->result_id(); } else if (IsDebugDeclareOrValue(use)) { return true; } // Some other instruction. Be conservative. return false; }); } std::unique_ptr CopyPropagateArrays::GetSourceObjectIfAny(uint32_t result) { Instruction* result_inst = context()->get_def_use_mgr()->GetDef(result); switch (result_inst->opcode()) { case spv::Op::OpLoad: return BuildMemoryObjectFromLoad(result_inst); case spv::Op::OpCompositeExtract: return BuildMemoryObjectFromExtract(result_inst); case spv::Op::OpCompositeConstruct: return BuildMemoryObjectFromCompositeConstruct(result_inst); case spv::Op::OpCopyObject: return GetSourceObjectIfAny(result_inst->GetSingleWordInOperand(0)); case spv::Op::OpCompositeInsert: return BuildMemoryObjectFromInsert(result_inst); default: return nullptr; } } std::unique_ptr CopyPropagateArrays::BuildMemoryObjectFromLoad(Instruction* load_inst) { std::vector components_in_reverse; analysis::DefUseManager* def_use_mgr = context()->get_def_use_mgr(); Instruction* current_inst = def_use_mgr->GetDef( load_inst->GetSingleWordInOperand(kLoadPointerInOperand)); // Build the access chain for the memory object by collecting the indices used // in the OpAccessChain instructions. If we find a variable index, then // return |nullptr| because we cannot know for sure which memory location is // used. // // It is built in reverse order because the different |OpAccessChain| // instructions are visited in reverse order from which they are applied. while (current_inst->opcode() == spv::Op::OpAccessChain) { for (uint32_t i = current_inst->NumInOperands() - 1; i >= 1; --i) { uint32_t element_index_id = current_inst->GetSingleWordInOperand(i); components_in_reverse.push_back(element_index_id); } current_inst = def_use_mgr->GetDef(current_inst->GetSingleWordInOperand(0)); } // If the address in the load is not constructed from an |OpVariable| // instruction followed by a series of |OpAccessChain| instructions, then // return |nullptr| because we cannot identify the owner or access chain // exactly. if (current_inst->opcode() != spv::Op::OpVariable) { return nullptr; } // Build the memory object. Use |rbegin| and |rend| to put the access chain // back in the correct order. return std::unique_ptr( new MemoryObject(current_inst, components_in_reverse.rbegin(), components_in_reverse.rend())); } std::unique_ptr CopyPropagateArrays::BuildMemoryObjectFromExtract(Instruction* extract_inst) { assert(extract_inst->opcode() == spv::Op::OpCompositeExtract && "Expecting an OpCompositeExtract instruction."); std::unique_ptr result = GetSourceObjectIfAny( extract_inst->GetSingleWordInOperand(kCompositeExtractObjectInOperand)); if (!result) { return nullptr; } // Copy the indices of the extract instruction to |OpAccessChain| indices. std::vector components; for (uint32_t i = 1; i < extract_inst->NumInOperands(); ++i) { components.push_back({false, {extract_inst->GetSingleWordInOperand(i)}}); } result->PushIndirection(components); return result; } std::unique_ptr CopyPropagateArrays::BuildMemoryObjectFromCompositeConstruct( Instruction* conststruct_inst) { assert(conststruct_inst->opcode() == spv::Op::OpCompositeConstruct && "Expecting an OpCompositeConstruct instruction."); // If every operand in the instruction are part of the same memory object, and // are being combined in the same order, then the result is the same as the // parent. std::unique_ptr memory_object = GetSourceObjectIfAny(conststruct_inst->GetSingleWordInOperand(0)); if (!memory_object) { return nullptr; } if (!memory_object->IsMember()) { return nullptr; } AccessChainEntry last_access = memory_object->AccessChain().back(); if (!IsAccessChainIndexValidAndEqualTo(last_access, 0)) { return nullptr; } memory_object->PopIndirection(); if (memory_object->GetNumberOfMembers() != conststruct_inst->NumInOperands()) { return nullptr; } for (uint32_t i = 1; i < conststruct_inst->NumInOperands(); ++i) { std::unique_ptr member_object = GetSourceObjectIfAny(conststruct_inst->GetSingleWordInOperand(i)); if (!member_object) { return nullptr; } if (!member_object->IsMember()) { return nullptr; } if (!memory_object->Contains(member_object.get())) { return nullptr; } last_access = member_object->AccessChain().back(); if (!IsAccessChainIndexValidAndEqualTo(last_access, i)) { return nullptr; } } return memory_object; } std::unique_ptr CopyPropagateArrays::BuildMemoryObjectFromInsert(Instruction* insert_inst) { assert(insert_inst->opcode() == spv::Op::OpCompositeInsert && "Expecting an OpCompositeInsert instruction."); analysis::DefUseManager* def_use_mgr = context()->get_def_use_mgr(); analysis::TypeManager* type_mgr = context()->get_type_mgr(); const analysis::Type* result_type = type_mgr->GetType(insert_inst->type_id()); uint32_t number_of_elements = GetNumberOfMembers(result_type, context()); if (number_of_elements == 0) { return nullptr; } if (insert_inst->NumInOperands() != 3) { return nullptr; } if (insert_inst->GetSingleWordInOperand(2) != number_of_elements - 1) { return nullptr; } std::unique_ptr memory_object = GetSourceObjectIfAny(insert_inst->GetSingleWordInOperand(0)); if (!memory_object) { return nullptr; } if (!memory_object->IsMember()) { return nullptr; } AccessChainEntry last_access = memory_object->AccessChain().back(); if (!IsAccessChainIndexValidAndEqualTo(last_access, number_of_elements - 1)) { return nullptr; } memory_object->PopIndirection(); Instruction* current_insert = def_use_mgr->GetDef(insert_inst->GetSingleWordInOperand(1)); for (uint32_t i = number_of_elements - 1; i > 0; --i) { if (current_insert->opcode() != spv::Op::OpCompositeInsert) { return nullptr; } if (current_insert->NumInOperands() != 3) { return nullptr; } if (current_insert->GetSingleWordInOperand(2) != i - 1) { return nullptr; } std::unique_ptr current_memory_object = GetSourceObjectIfAny(current_insert->GetSingleWordInOperand(0)); if (!current_memory_object) { return nullptr; } if (!current_memory_object->IsMember()) { return nullptr; } if (memory_object->AccessChain().size() + 1 != current_memory_object->AccessChain().size()) { return nullptr; } if (!memory_object->Contains(current_memory_object.get())) { return nullptr; } AccessChainEntry current_last_access = current_memory_object->AccessChain().back(); if (!IsAccessChainIndexValidAndEqualTo(current_last_access, i - 1)) { return nullptr; } current_insert = def_use_mgr->GetDef(current_insert->GetSingleWordInOperand(1)); } return memory_object; } bool CopyPropagateArrays::IsAccessChainIndexValidAndEqualTo( const AccessChainEntry& entry, uint32_t value) const { if (!entry.is_result_id) { return entry.immediate == value; } analysis::ConstantManager* const_mgr = context()->get_constant_mgr(); const analysis::Constant* constant = const_mgr->FindDeclaredConstant(entry.result_id); if (!constant || !constant->type()->AsInteger()) { return false; } return constant->GetU32() == value; } bool CopyPropagateArrays::IsPointerToArrayType(uint32_t type_id) { analysis::TypeManager* type_mgr = context()->get_type_mgr(); analysis::Pointer* pointer_type = type_mgr->GetType(type_id)->AsPointer(); if (pointer_type) { return pointer_type->pointee_type()->kind() == analysis::Type::kArray || pointer_type->pointee_type()->kind() == analysis::Type::kImage; } return false; } bool CopyPropagateArrays::IsInterpolationInstruction(Instruction* inst) { if (inst->opcode() == spv::Op::OpExtInst && inst->GetSingleWordInOperand(kExtInstSetInIdx) == context()->get_feature_mgr()->GetExtInstImportId_GLSLstd450()) { uint32_t ext_inst = inst->GetSingleWordInOperand(kExtInstOpInIdx); switch (ext_inst) { case GLSLstd450InterpolateAtCentroid: case GLSLstd450InterpolateAtOffset: case GLSLstd450InterpolateAtSample: return true; } } return false; } bool CopyPropagateArrays::CanUpdateUses(Instruction* original_ptr_inst, uint32_t type_id) { analysis::TypeManager* type_mgr = context()->get_type_mgr(); analysis::ConstantManager* const_mgr = context()->get_constant_mgr(); analysis::DefUseManager* def_use_mgr = context()->get_def_use_mgr(); analysis::Type* type = type_mgr->GetType(type_id); if (type->AsRuntimeArray()) { return false; } if (!type->AsStruct() && !type->AsArray() && !type->AsPointer()) { // If the type is not an aggregate, then the desired type must be the // same as the current type. No work to do, and we can do that. return true; } return def_use_mgr->WhileEachUse(original_ptr_inst, [this, type_mgr, const_mgr, type](Instruction* use, uint32_t) { if (IsDebugDeclareOrValue(use)) return true; switch (use->opcode()) { case spv::Op::OpLoad: { analysis::Pointer* pointer_type = type->AsPointer(); uint32_t new_type_id = type_mgr->GetId(pointer_type->pointee_type()); if (new_type_id != use->type_id()) { return CanUpdateUses(use, new_type_id); } return true; } case spv::Op::OpExtInst: if (IsInterpolationInstruction(use)) { return true; } return false; case spv::Op::OpAccessChain: { analysis::Pointer* pointer_type = type->AsPointer(); const analysis::Type* pointee_type = pointer_type->pointee_type(); std::vector access_chain; for (uint32_t i = 1; i < use->NumInOperands(); ++i) { const analysis::Constant* index_const = const_mgr->FindDeclaredConstant(use->GetSingleWordInOperand(i)); if (index_const) { access_chain.push_back(index_const->GetU32()); } else { // Variable index means the type is a type where every element // is the same type. Use element 0 to get the type. access_chain.push_back(0); // We are trying to access a struct with variable indices. // This cannot happen. if (pointee_type->kind() == analysis::Type::kStruct) { return false; } } } const analysis::Type* new_pointee_type = type_mgr->GetMemberType(pointee_type, access_chain); analysis::Pointer pointerTy(new_pointee_type, pointer_type->storage_class()); uint32_t new_pointer_type_id = context()->get_type_mgr()->GetTypeInstruction(&pointerTy); if (new_pointer_type_id == 0) { return false; } if (new_pointer_type_id != use->type_id()) { return CanUpdateUses(use, new_pointer_type_id); } return true; } case spv::Op::OpCompositeExtract: { std::vector access_chain; for (uint32_t i = 1; i < use->NumInOperands(); ++i) { access_chain.push_back(use->GetSingleWordInOperand(i)); } const analysis::Type* new_type = type_mgr->GetMemberType(type, access_chain); uint32_t new_type_id = type_mgr->GetTypeInstruction(new_type); if (new_type_id == 0) { return false; } if (new_type_id != use->type_id()) { return CanUpdateUses(use, new_type_id); } return true; } case spv::Op::OpStore: // If needed, we can create an element-by-element copy to change the // type of the value being stored. This way we can always handled // stores. return true; case spv::Op::OpImageTexelPointer: case spv::Op::OpName: return true; default: return use->IsDecoration(); } }); } void CopyPropagateArrays::UpdateUses(Instruction* original_ptr_inst, Instruction* new_ptr_inst) { analysis::TypeManager* type_mgr = context()->get_type_mgr(); analysis::ConstantManager* const_mgr = context()->get_constant_mgr(); analysis::DefUseManager* def_use_mgr = context()->get_def_use_mgr(); std::vector > uses; def_use_mgr->ForEachUse(original_ptr_inst, [&uses](Instruction* use, uint32_t index) { uses.push_back({use, index}); }); for (auto pair : uses) { Instruction* use = pair.first; uint32_t index = pair.second; if (use->IsCommonDebugInstr()) { switch (use->GetCommonDebugOpcode()) { case CommonDebugInfoDebugDeclare: { if (new_ptr_inst->opcode() == spv::Op::OpVariable || new_ptr_inst->opcode() == spv::Op::OpFunctionParameter) { context()->ForgetUses(use); use->SetOperand(index, {new_ptr_inst->result_id()}); context()->AnalyzeUses(use); } else { // Based on the spec, we cannot use a pointer other than OpVariable // or OpFunctionParameter for DebugDeclare. We have to use // DebugValue with Deref. context()->ForgetUses(use); // Change DebugDeclare to DebugValue. use->SetOperand(index - 2, {static_cast(CommonDebugInfoDebugValue)}); use->SetOperand(index, {new_ptr_inst->result_id()}); // Add Deref operation. Instruction* dbg_expr = def_use_mgr->GetDef(use->GetSingleWordOperand(index + 1)); auto* deref_expr_instr = context()->get_debug_info_mgr()->DerefDebugExpression(dbg_expr); use->SetOperand(index + 1, {deref_expr_instr->result_id()}); context()->AnalyzeUses(deref_expr_instr); context()->AnalyzeUses(use); } break; } case CommonDebugInfoDebugValue: context()->ForgetUses(use); use->SetOperand(index, {new_ptr_inst->result_id()}); context()->AnalyzeUses(use); break; default: assert(false && "Don't know how to rewrite instruction"); break; } continue; } switch (use->opcode()) { case spv::Op::OpLoad: { // Replace the actual use. context()->ForgetUses(use); use->SetOperand(index, {new_ptr_inst->result_id()}); // Update the type. Instruction* pointer_type_inst = def_use_mgr->GetDef(new_ptr_inst->type_id()); uint32_t new_type_id = pointer_type_inst->GetSingleWordInOperand(kTypePointerPointeeInIdx); if (new_type_id != use->type_id()) { use->SetResultType(new_type_id); context()->AnalyzeUses(use); UpdateUses(use, use); } else { context()->AnalyzeUses(use); } AddUsesToWorklist(use); } break; case spv::Op::OpExtInst: { if (IsInterpolationInstruction(use)) { // Replace the actual use. context()->ForgetUses(use); use->SetOperand(index, {new_ptr_inst->result_id()}); context()->AnalyzeUses(use); } else { assert(false && "Don't know how to rewrite instruction"); } } break; case spv::Op::OpAccessChain: { // Update the actual use. context()->ForgetUses(use); use->SetOperand(index, {new_ptr_inst->result_id()}); // Convert the ids on the OpAccessChain to indices that can be used to // get the specific member. std::vector access_chain; for (uint32_t i = 1; i < use->NumInOperands(); ++i) { const analysis::Constant* index_const = const_mgr->FindDeclaredConstant(use->GetSingleWordInOperand(i)); if (index_const) { access_chain.push_back(index_const->GetU32()); } else { // Variable index means the type is an type where every element // is the same type. Use element 0 to get the type. access_chain.push_back(0); } } Instruction* pointer_type_inst = get_def_use_mgr()->GetDef(new_ptr_inst->type_id()); uint32_t new_pointee_type_id = GetMemberTypeId( pointer_type_inst->GetSingleWordInOperand(kTypePointerPointeeInIdx), access_chain); spv::StorageClass storage_class = static_cast( pointer_type_inst->GetSingleWordInOperand( kTypePointerStorageClassInIdx)); uint32_t new_pointer_type_id = type_mgr->FindPointerToType(new_pointee_type_id, storage_class); if (new_pointer_type_id != use->type_id()) { use->SetResultType(new_pointer_type_id); context()->AnalyzeUses(use); UpdateUses(use, use); } else { context()->AnalyzeUses(use); } } break; case spv::Op::OpCompositeExtract: { // Update the actual use. context()->ForgetUses(use); use->SetOperand(index, {new_ptr_inst->result_id()}); uint32_t new_type_id = new_ptr_inst->type_id(); std::vector access_chain; for (uint32_t i = 1; i < use->NumInOperands(); ++i) { access_chain.push_back(use->GetSingleWordInOperand(i)); } new_type_id = GetMemberTypeId(new_type_id, access_chain); if (new_type_id != use->type_id()) { use->SetResultType(new_type_id); context()->AnalyzeUses(use); UpdateUses(use, use); } else { context()->AnalyzeUses(use); } } break; case spv::Op::OpStore: // If the use is the pointer, then it is the single store to that // variable. We do not want to replace it. Instead, it will become // dead after all of the loads are removed, and ADCE will get rid of it. // // If the use is the object being stored, we will create a copy of the // object turning it into the correct type. The copy is done by // decomposing the object into the base type, which must be the same, // and then rebuilding them. if (index == 1) { Instruction* target_pointer = def_use_mgr->GetDef( use->GetSingleWordInOperand(kStorePointerInOperand)); Instruction* pointer_type = def_use_mgr->GetDef(target_pointer->type_id()); uint32_t pointee_type_id = pointer_type->GetSingleWordInOperand(kTypePointerPointeeInIdx); uint32_t copy = GenerateCopy(original_ptr_inst, pointee_type_id, use); assert(copy != 0 && "Should not be updating uses unless we know it can be done."); context()->ForgetUses(use); use->SetInOperand(index, {copy}); context()->AnalyzeUses(use); } break; case spv::Op::OpDecorate: // We treat an OpImageTexelPointer as a load. The result type should // always have the Image storage class, and should not need to be // updated. case spv::Op::OpImageTexelPointer: // Replace the actual use. context()->ForgetUses(use); use->SetOperand(index, {new_ptr_inst->result_id()}); context()->AnalyzeUses(use); break; default: assert(false && "Don't know how to rewrite instruction"); break; } } } uint32_t CopyPropagateArrays::GetMemberTypeId( uint32_t id, const std::vector& access_chain) const { for (uint32_t element_index : access_chain) { Instruction* type_inst = get_def_use_mgr()->GetDef(id); switch (type_inst->opcode()) { case spv::Op::OpTypeArray: case spv::Op::OpTypeRuntimeArray: case spv::Op::OpTypeMatrix: case spv::Op::OpTypeVector: id = type_inst->GetSingleWordInOperand(0); break; case spv::Op::OpTypeStruct: id = type_inst->GetSingleWordInOperand(element_index); break; default: break; } assert(id != 0 && "Tried to extract from an object where it cannot be done."); } return id; } void CopyPropagateArrays::AddUsesToWorklist(Instruction* inst) { analysis::DefUseManager* def_use_mgr = context()->get_def_use_mgr(); def_use_mgr->ForEachUse(inst, [this](Instruction* use, uint32_t) { if (use->opcode() == spv::Op::OpStore) { uint32_t var_id; Instruction* target_pointer = GetPtr(use, &var_id); if (target_pointer->opcode() != spv::Op::OpVariable) { return; } worklist_.push(target_pointer); } }); } void CopyPropagateArrays::MemoryObject::PushIndirection( const std::vector& access_chain) { access_chain_.insert(access_chain_.end(), access_chain.begin(), access_chain.end()); } uint32_t CopyPropagateArrays::MemoryObject::GetNumberOfMembers() { IRContext* context = variable_inst_->context(); analysis::TypeManager* type_mgr = context->get_type_mgr(); const analysis::Type* type = type_mgr->GetType(variable_inst_->type_id()); type = type->AsPointer()->pointee_type(); std::vector access_indices = GetAccessIds(); type = type_mgr->GetMemberType(type, access_indices); return opt::GetNumberOfMembers(type, context); } template CopyPropagateArrays::MemoryObject::MemoryObject(Instruction* var_inst, iterator begin, iterator end) : variable_inst_(var_inst) { std::transform(begin, end, std::back_inserter(access_chain_), [](uint32_t id) { return AccessChainEntry{true, {id}}; }); } std::vector CopyPropagateArrays::MemoryObject::GetAccessIds() const { analysis::ConstantManager* const_mgr = variable_inst_->context()->get_constant_mgr(); std::vector indices(AccessChain().size()); std::transform(AccessChain().cbegin(), AccessChain().cend(), indices.begin(), [&const_mgr](const AccessChainEntry& entry) { if (entry.is_result_id) { const analysis::Constant* constant = const_mgr->FindDeclaredConstant(entry.result_id); return constant == nullptr ? 0 : constant->GetU32(); } return entry.immediate; }); return indices; } bool CopyPropagateArrays::MemoryObject::Contains( CopyPropagateArrays::MemoryObject* other) { if (this->GetVariable() != other->GetVariable()) { return false; } if (AccessChain().size() > other->AccessChain().size()) { return false; } for (uint32_t i = 0; i < AccessChain().size(); i++) { if (AccessChain()[i] != other->AccessChain()[i]) { return false; } } return true; } void CopyPropagateArrays::MemoryObject::BuildConstants() { for (auto& entry : access_chain_) { if (entry.is_result_id) { continue; } auto context = variable_inst_->context(); analysis::Integer int_type(32, false); const analysis::Type* uint32_type = context->get_type_mgr()->GetRegisteredType(&int_type); analysis::ConstantManager* const_mgr = context->get_constant_mgr(); const analysis::Constant* index_const = const_mgr->GetConstant(uint32_type, {entry.immediate}); entry.result_id = const_mgr->GetDefiningInstruction(index_const)->result_id(); entry.is_result_id = true; } } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/copy_prop_arrays.h000066400000000000000000000273601475742701700244070ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_COPY_PROP_ARRAYS_H_ #define SOURCE_OPT_COPY_PROP_ARRAYS_H_ #include #include #include "source/opt/mem_pass.h" namespace spvtools { namespace opt { // This pass implements a simple array copy propagation. It does not do a full // array data flow. It looks for simple cases that meet the following // conditions: // // 1) The source must never be stored to. // 2) The target must be stored to exactly once. // 3) The store to the target must be a store to the entire array, and be a // copy of the entire source. // 4) All loads of the target must be dominated by the store. // // The hard part is keeping all of the types correct. We do not want to // have to do too large a search to update everything, which may not be // possible, so we give up if we see any instruction that might be hard to // update. class CopyPropagateArrays : public MemPass { public: const char* name() const override { return "copy-propagate-arrays"; } Status Process() override; IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisDefUse | IRContext::kAnalysisCFG | IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisLoopAnalysis | IRContext::kAnalysisDecorations | IRContext::kAnalysisDominatorAnalysis | IRContext::kAnalysisNameMap | IRContext::kAnalysisConstants | IRContext::kAnalysisTypes; } private: // Represents one index in the OpAccessChain instruction. It can be either // an instruction's result_id (OpConstant by ex), or a immediate value. // Immediate values are used to prepare the final access chain without // creating OpConstant instructions until done. struct AccessChainEntry { bool is_result_id; union { uint32_t result_id; uint32_t immediate; }; bool operator!=(const AccessChainEntry& other) const { return other.is_result_id != is_result_id || other.result_id != result_id; } }; // The class used to identify a particular memory object. This memory object // will be owned by a particular variable, meaning that the memory is part of // that variable. It could be the entire variable or a member of the // variable. class MemoryObject { public: // Construction a memory object that is owned by |var_inst|. The iterator // |begin| and |end| traverse a container of integers that identify which // member of |var_inst| this memory object will represent. These integers // are interpreted the same way they would be in an |OpAccessChain| // instruction. template MemoryObject(Instruction* var_inst, iterator begin, iterator end); // Change |this| to now point to the member identified by |access_chain| // (starting from the current member). The elements in |access_chain| are // interpreted the same as the indices in the |OpAccessChain| // instruction. void PushIndirection(const std::vector& access_chain); // Change |this| to now represent the first enclosing object to which it // belongs. (Remove the last element off the access_chain). It is invalid // to call this function if |this| does not represent a member of its owner. void PopIndirection() { assert(IsMember()); access_chain_.pop_back(); } // Returns true if |this| represents a member of its owner, and not the // entire variable. bool IsMember() const { return !access_chain_.empty(); } // Returns the number of members in the object represented by |this|. If // |this| does not represent a composite type or the number of components is // not known at compile time, the return value will be 0. uint32_t GetNumberOfMembers(); // Returns the owning variable that the memory object is contained in. Instruction* GetVariable() const { return variable_inst_; } // Returns a vector of integers that can be used to access the specific // member that |this| represents starting from the owning variable. These // values are to be interpreted the same way the indices are in an // |OpAccessChain| instruction. const std::vector& AccessChain() const { return access_chain_; } // Converts all immediate values in the AccessChain their OpConstant // equivalent. void BuildConstants(); // Returns the type id of the pointer type that can be used to point to this // memory object. uint32_t GetPointerTypeId(const CopyPropagateArrays* pass) const { analysis::DefUseManager* def_use_mgr = GetVariable()->context()->get_def_use_mgr(); analysis::TypeManager* type_mgr = GetVariable()->context()->get_type_mgr(); Instruction* var_pointer_inst = def_use_mgr->GetDef(GetVariable()->type_id()); uint32_t member_type_id = pass->GetMemberTypeId( var_pointer_inst->GetSingleWordInOperand(1), GetAccessIds()); uint32_t member_pointer_type_id = type_mgr->FindPointerToType( member_type_id, static_cast( var_pointer_inst->GetSingleWordInOperand(0))); return member_pointer_type_id; } // Returns the storage class of the memory object. spv::StorageClass GetStorageClass() const { analysis::TypeManager* type_mgr = GetVariable()->context()->get_type_mgr(); const analysis::Pointer* pointer_type = type_mgr->GetType(GetVariable()->type_id())->AsPointer(); return pointer_type->storage_class(); } // Returns true if |other| represents memory that is contains inside of the // memory represented by |this|. bool Contains(MemoryObject* other); private: // The variable that owns this memory object. Instruction* variable_inst_; // The access chain to reach the particular member the memory object // represents. It should be interpreted the same way the indices in an // |OpAccessChain| are interpreted. std::vector access_chain_; std::vector GetAccessIds() const; }; // Returns the memory object being stored to |var_inst| in the store // instruction |store_inst|, if one exists, that can be used in place of // |var_inst| in all of the loads of |var_inst|. This code is conservative // and only identifies very simple cases. If no such memory object can be // found, the return value is |nullptr|. std::unique_ptr FindSourceObjectIfPossible( Instruction* var_inst, Instruction* store_inst); // Replaces all loads of |var_inst| with a load from |source| instead. // |insertion_pos| is a position where it is possible to construct the // address of |source| and also dominates all of the loads of |var_inst|. void PropagateObject(Instruction* var_inst, MemoryObject* source, Instruction* insertion_pos); // Returns true if all of the references to |ptr_inst| can be rewritten and // are dominated by |store_inst|. bool HasValidReferencesOnly(Instruction* ptr_inst, Instruction* store_inst); // Returns a memory object that at one time was equivalent to the value in // |result|. If no such memory object exists, the return value is |nullptr|. std::unique_ptr GetSourceObjectIfAny(uint32_t result); // Returns the memory object that is loaded by |load_inst|. If a memory // object cannot be identified, the return value is |nullptr|. The opcode of // |load_inst| must be |OpLoad|. std::unique_ptr BuildMemoryObjectFromLoad( Instruction* load_inst); // Returns the memory object that at some point was equivalent to the result // of |extract_inst|. If a memory object cannot be identified, the return // value is |nullptr|. The opcode of |extract_inst| must be // |OpCompositeExtract|. std::unique_ptr BuildMemoryObjectFromExtract( Instruction* extract_inst); // Returns the memory object that at some point was equivalent to the result // of |construct_inst|. If a memory object cannot be identified, the return // value is |nullptr|. The opcode of |constuct_inst| must be // |OpCompositeConstruct|. std::unique_ptr BuildMemoryObjectFromCompositeConstruct( Instruction* conststruct_inst); // Returns the memory object that at some point was equivalent to the result // of |insert_inst|. If a memory object cannot be identified, the return // value is |nullptr|. The opcode of |insert_inst| must be // |OpCompositeInsert|. This function looks for a series of // |OpCompositeInsert| instructions that insert the elements one at a time in // order from beginning to end. std::unique_ptr BuildMemoryObjectFromInsert( Instruction* insert_inst); // Return true if the given entry can represent the given value. bool IsAccessChainIndexValidAndEqualTo(const AccessChainEntry& entry, uint32_t value) const; // Return true if |type_id| is a pointer type whose pointee type is an array. bool IsPointerToArrayType(uint32_t type_id); // Return true if |inst| is one of the InterpolateAt* GLSL.std.450 extended // instructions. bool IsInterpolationInstruction(Instruction* inst); // Returns true if there are not stores using |ptr_inst| or something derived // from it. bool HasNoStores(Instruction* ptr_inst); // Creates an |OpAccessChain| instruction whose result is a pointer the memory // represented by |source|. The new instruction will be placed before // |insertion_point|. |insertion_point| must be part of a function. Returns // the new instruction. Instruction* BuildNewAccessChain(Instruction* insertion_point, MemoryObject* source) const; // Rewrites all uses of |original_ptr| to use |new_pointer_inst| updating // types of other instructions as needed. This function should not be called // if |CanUpdateUses(original_ptr_inst, new_pointer_inst->type_id())| returns // false. void UpdateUses(Instruction* original_ptr_inst, Instruction* new_pointer_inst); // Return true if |UpdateUses| is able to change all of the uses of // |original_ptr_inst| to |type_id| and still have valid code. bool CanUpdateUses(Instruction* original_ptr_inst, uint32_t type_id); // Returns a store to |var_inst| that writes to the entire variable, and is // the only store that does so. Note it does not look through OpAccessChain // instruction, so partial stores are not considered. Instruction* FindStoreInstruction(const Instruction* var_inst) const; // Return the type id of the member of the type |id| access using // |access_chain|. The elements of |access_chain| are to be interpreted the // same way the indexes are used in an |OpCompositeExtract| instruction. uint32_t GetMemberTypeId(uint32_t id, const std::vector& access_chain) const; // If the result of inst is stored to a variable, add that variable to the // worklist. void AddUsesToWorklist(Instruction* inst); // OpVariable worklist. An instruction is added to this list if we would like // to run copy propagation on it. std::queue worklist_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_COPY_PROP_ARRAYS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/dataflow.cpp000066400000000000000000000054011475742701700231400ustar00rootroot00000000000000// Copyright (c) 2021 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/dataflow.h" #include namespace spvtools { namespace opt { bool DataFlowAnalysis::Enqueue(Instruction* inst) { bool& is_enqueued = on_worklist_[inst]; if (is_enqueued) return false; is_enqueued = true; worklist_.push(inst); return true; } DataFlowAnalysis::VisitResult DataFlowAnalysis::RunOnce( Function* function, bool is_first_iteration) { InitializeWorklist(function, is_first_iteration); VisitResult ret = VisitResult::kResultFixed; while (!worklist_.empty()) { Instruction* top = worklist_.front(); worklist_.pop(); on_worklist_[top] = false; VisitResult result = Visit(top); if (result == VisitResult::kResultChanged) { EnqueueSuccessors(top); ret = VisitResult::kResultChanged; } } return ret; } void DataFlowAnalysis::Run(Function* function) { VisitResult result = RunOnce(function, true); while (result == VisitResult::kResultChanged) { result = RunOnce(function, false); } } void ForwardDataFlowAnalysis::InitializeWorklist(Function* function, bool /*is_first_iteration*/) { context().cfg()->ForEachBlockInReversePostOrder( function->entry().get(), [this](BasicBlock* bb) { if (label_position_ == LabelPosition::kLabelsOnly) { Enqueue(bb->GetLabelInst()); return; } if (label_position_ == LabelPosition::kLabelsAtBeginning) { Enqueue(bb->GetLabelInst()); } for (Instruction& inst : *bb) { Enqueue(&inst); } if (label_position_ == LabelPosition::kLabelsAtEnd) { Enqueue(bb->GetLabelInst()); } }); } void ForwardDataFlowAnalysis::EnqueueUsers(Instruction* inst) { context().get_def_use_mgr()->ForEachUser( inst, [this](Instruction* user) { Enqueue(user); }); } void ForwardDataFlowAnalysis::EnqueueBlockSuccessors(Instruction* inst) { if (inst->opcode() != spv::Op::OpLabel) return; context() .cfg() ->block(inst->result_id()) ->ForEachSuccessorLabel([this](uint32_t* label) { Enqueue(context().cfg()->block(*label)->GetLabelInst()); }); } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/dataflow.h000066400000000000000000000132241475742701700226070ustar00rootroot00000000000000// Copyright (c) 2021 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_DATAFLOW_H_ #define SOURCE_OPT_DATAFLOW_H_ #include #include #include #include "source/opt/instruction.h" #include "source/opt/ir_context.h" namespace spvtools { namespace opt { // Generic data-flow analysis. // Maintains a worklist of instructions to process and processes them in a // specified order. See also ForwardDataFlowAnalysis, which is specialized for // forward data-flow analysis. class DataFlowAnalysis { public: // The result of a |Visit| operation on an instruction. // This is used to determine when analysis has reached a fixpoint. enum class VisitResult { // The analysis result for this instruction has changed. // This means that any instructions that depend on it (its successors) must // be recomputed. kResultChanged, // The analysis result for this instruction has not changed. // When all visit operations return |kResultFixed|, the analysis has reached // a fixpoint (converged). kResultFixed, }; virtual ~DataFlowAnalysis() {} // Run this analysis on a given function. // For analyses which work interprocedurally, |function| may be ignored. void Run(Function* function); protected: DataFlowAnalysis(IRContext& context) : context_(context) {} // Initialize the worklist for a given function. // |is_first_iteration| is true on the first call to |Run| and false // afterwards. All subsequent runs are only necessary to check if the analysis // has converged; if |EnqueueSuccessors| is complete, |InitializeWorklist| // should do nothing after the first iteration. virtual void InitializeWorklist(Function* function, bool is_first_iteration) = 0; // Enqueues the successors (instructions which use the analysis result) of // |inst|. This is not required to be complete, but convergence is faster when // it is. This is called whenever |Visit| returns |kResultChanged|. virtual void EnqueueSuccessors(Instruction* inst) = 0; // Visits the given instruction, recomputing the analysis result. This is // called once per instruction queued in |InitializeWorklist| and afterward // when a predecessor is changed, through |EnqueueSuccessors|. virtual VisitResult Visit(Instruction* inst) = 0; // Enqueues the given instruction to be visited. Ignored if already in the // worklist. bool Enqueue(Instruction* inst); IRContext& context() { return context_; } private: // Runs one pass, calling |InitializeWorklist| and then iterating through the // worklist until all fixed. VisitResult RunOnce(Function* function, bool is_first_iteration); IRContext& context_; std::unordered_map on_worklist_; // The worklist, which contains the list of instructions to be visited. // // The choice of data structure was influenced by the data in "Iterative // Data-flow Analysis, Revisited" (Cooper et al, 2002). // https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.125.1549&rep=rep1&type=pdf // The paper shows that the overall performance benefit of a priority queue // over a regular queue or stack is relatively small (or negative). // // A queue has the advantage that nodes are visited in the same order they are // enqueued, which relieves the analysis from inserting nodes "backwards", for // example in worklist initialization. Also, as the paper claims that sorting // successors does not improve runtime, we can use a single queue which is // modified during iteration. std::queue worklist_; }; // A generic data flow analysis, specialized for forward analysis. class ForwardDataFlowAnalysis : public DataFlowAnalysis { public: // Indicates where labels should be in the worklist RPO ordering. enum class LabelPosition { // Labels should be placed at the beginning of their blocks. kLabelsAtBeginning, // Labels should be placed at the end of their blocks. kLabelsAtEnd, // Labels should not be in the worklist. kNoLabels, // Only labels should be placed in the worklist. kLabelsOnly, }; ForwardDataFlowAnalysis(IRContext& context, LabelPosition label_position) : DataFlowAnalysis(context), label_position_(label_position) {} protected: // Initializes the worklist in reverse postorder, regardless of // |is_first_iteration|. Labels are placed according to the label position // specified in the constructor. void InitializeWorklist(Function* function, bool is_first_iteration) override; // Enqueues the users and block successors of the given instruction. // See |EnqueueUsers| and |EnqueueBlockSuccessors|. void EnqueueSuccessors(Instruction* inst) override { EnqueueUsers(inst); EnqueueBlockSuccessors(inst); } // Enqueues the users of the given instruction. void EnqueueUsers(Instruction* inst); // Enqueues the labels of the successors of the block corresponding to the // given label instruction. Does nothing for other instructions. void EnqueueBlockSuccessors(Instruction* inst); private: LabelPosition label_position_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_DATAFLOW_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/dead_branch_elim_pass.cpp000066400000000000000000000611001475742701700256030ustar00rootroot00000000000000// Copyright (c) 2017 The Khronos Group Inc. // Copyright (c) 2017 Valve Corporation // Copyright (c) 2017 LunarG Inc. // Copyright (c) 2018 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/dead_branch_elim_pass.h" #include #include #include #include "source/cfa.h" #include "source/opt/ir_context.h" #include "source/opt/struct_cfg_analysis.h" #include "source/util/make_unique.h" namespace spvtools { namespace opt { namespace { constexpr uint32_t kBranchCondTrueLabIdInIdx = 1; constexpr uint32_t kBranchCondFalseLabIdInIdx = 2; } // namespace bool DeadBranchElimPass::GetConstCondition(uint32_t condId, bool* condVal) { bool condIsConst; Instruction* cInst = get_def_use_mgr()->GetDef(condId); switch (cInst->opcode()) { case spv::Op::OpConstantNull: case spv::Op::OpConstantFalse: { *condVal = false; condIsConst = true; } break; case spv::Op::OpConstantTrue: { *condVal = true; condIsConst = true; } break; case spv::Op::OpLogicalNot: { bool negVal; condIsConst = GetConstCondition(cInst->GetSingleWordInOperand(0), &negVal); if (condIsConst) *condVal = !negVal; } break; default: { condIsConst = false; } break; } return condIsConst; } bool DeadBranchElimPass::GetConstInteger(uint32_t selId, uint32_t* selVal) { Instruction* sInst = get_def_use_mgr()->GetDef(selId); uint32_t typeId = sInst->type_id(); Instruction* typeInst = get_def_use_mgr()->GetDef(typeId); if (!typeInst || (typeInst->opcode() != spv::Op::OpTypeInt)) return false; // TODO(greg-lunarg): Support non-32 bit ints if (typeInst->GetSingleWordInOperand(0) != 32) return false; if (sInst->opcode() == spv::Op::OpConstant) { *selVal = sInst->GetSingleWordInOperand(0); return true; } else if (sInst->opcode() == spv::Op::OpConstantNull) { *selVal = 0; return true; } return false; } void DeadBranchElimPass::AddBranch(uint32_t labelId, BasicBlock* bp) { assert(get_def_use_mgr()->GetDef(labelId) != nullptr); std::unique_ptr newBranch( new Instruction(context(), spv::Op::OpBranch, 0, 0, {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {labelId}}})); context()->AnalyzeDefUse(&*newBranch); context()->set_instr_block(&*newBranch, bp); bp->AddInstruction(std::move(newBranch)); } BasicBlock* DeadBranchElimPass::GetParentBlock(uint32_t id) { return context()->get_instr_block(get_def_use_mgr()->GetDef(id)); } bool DeadBranchElimPass::MarkLiveBlocks( Function* func, std::unordered_set* live_blocks) { std::vector> conditions_to_simplify; std::unordered_set blocks_with_backedge; std::vector stack; stack.push_back(&*func->begin()); bool modified = false; while (!stack.empty()) { BasicBlock* block = stack.back(); stack.pop_back(); // Live blocks doubles as visited set. if (!live_blocks->insert(block).second) continue; uint32_t cont_id = block->ContinueBlockIdIfAny(); if (cont_id != 0) { AddBlocksWithBackEdge(cont_id, block->id(), block->MergeBlockIdIfAny(), &blocks_with_backedge); } Instruction* terminator = block->terminator(); uint32_t live_lab_id = 0; // Check if the terminator has a single valid successor. if (terminator->opcode() == spv::Op::OpBranchConditional) { bool condVal; if (GetConstCondition(terminator->GetSingleWordInOperand(0u), &condVal)) { live_lab_id = terminator->GetSingleWordInOperand( condVal ? kBranchCondTrueLabIdInIdx : kBranchCondFalseLabIdInIdx); } } else if (terminator->opcode() == spv::Op::OpSwitch) { uint32_t sel_val; if (GetConstInteger(terminator->GetSingleWordInOperand(0u), &sel_val)) { // Search switch operands for selector value, set live_lab_id to // corresponding label, use default if not found. uint32_t icnt = 0; uint32_t case_val; terminator->WhileEachInOperand( [&icnt, &case_val, &sel_val, &live_lab_id](const uint32_t* idp) { if (icnt == 1) { // Start with default label. live_lab_id = *idp; } else if (icnt > 1) { if (icnt % 2 == 0) { case_val = *idp; } else { if (case_val == sel_val) { live_lab_id = *idp; return false; } } } ++icnt; return true; }); } } // Don't simplify back edges unless it becomes a branch to the header. Every // loop must have exactly one back edge to the loop header, so we cannot // remove it. bool simplify = false; if (live_lab_id != 0) { if (!blocks_with_backedge.count(block)) { // This is not a back edge. simplify = true; } else { const auto& struct_cfg_analysis = context()->GetStructuredCFGAnalysis(); uint32_t header_id = struct_cfg_analysis->ContainingLoop(block->id()); if (live_lab_id == header_id) { // The new branch will be a branch to the header. simplify = true; } } } if (simplify) { conditions_to_simplify.push_back({block, live_lab_id}); stack.push_back(GetParentBlock(live_lab_id)); } else { // All successors are live. const auto* const_block = block; const_block->ForEachSuccessorLabel([&stack, this](const uint32_t label) { stack.push_back(GetParentBlock(label)); }); } } // Traverse |conditions_to_simplify| in reverse order. This is done so that // we simplify nested constructs before simplifying the constructs that // contain them. for (auto b = conditions_to_simplify.rbegin(); b != conditions_to_simplify.rend(); ++b) { modified |= SimplifyBranch(b->first, b->second); } return modified; } bool DeadBranchElimPass::SimplifyBranch(BasicBlock* block, uint32_t live_lab_id) { Instruction* merge_inst = block->GetMergeInst(); Instruction* terminator = block->terminator(); if (merge_inst && merge_inst->opcode() == spv::Op::OpSelectionMerge) { if (merge_inst->NextNode()->opcode() == spv::Op::OpSwitch && SwitchHasNestedBreak(block->id())) { if (terminator->NumInOperands() == 2) { // We cannot remove the branch, and it already has a single case, so no // work to do. return false; } // We have to keep the switch because it has a nest break, so we // remove all cases except for the live one. Instruction::OperandList new_operands; new_operands.push_back(terminator->GetInOperand(0)); new_operands.push_back({SPV_OPERAND_TYPE_ID, {live_lab_id}}); terminator->SetInOperands(std::move(new_operands)); context()->UpdateDefUse(terminator); } else { // Check if the merge instruction is still needed because of a // non-nested break from the construct. Move the merge instruction if // it is still needed. StructuredCFGAnalysis* cfg_analysis = context()->GetStructuredCFGAnalysis(); Instruction* first_break = FindFirstExitFromSelectionMerge( live_lab_id, merge_inst->GetSingleWordInOperand(0), cfg_analysis->LoopMergeBlock(live_lab_id), cfg_analysis->LoopContinueBlock(live_lab_id), cfg_analysis->SwitchMergeBlock(live_lab_id)); AddBranch(live_lab_id, block); context()->KillInst(terminator); if (first_break == nullptr) { context()->KillInst(merge_inst); } else { merge_inst->RemoveFromList(); first_break->InsertBefore(std::unique_ptr(merge_inst)); context()->set_instr_block(merge_inst, context()->get_instr_block(first_break)); } } } else { AddBranch(live_lab_id, block); context()->KillInst(terminator); } return true; } void DeadBranchElimPass::MarkUnreachableStructuredTargets( const std::unordered_set& live_blocks, std::unordered_set* unreachable_merges, std::unordered_map* unreachable_continues) { for (auto block : live_blocks) { if (auto merge_id = block->MergeBlockIdIfAny()) { BasicBlock* merge_block = GetParentBlock(merge_id); if (!live_blocks.count(merge_block)) { unreachable_merges->insert(merge_block); } if (auto cont_id = block->ContinueBlockIdIfAny()) { BasicBlock* cont_block = GetParentBlock(cont_id); if (!live_blocks.count(cont_block)) { (*unreachable_continues)[cont_block] = block; } } } } } bool DeadBranchElimPass::FixPhiNodesInLiveBlocks( Function* func, const std::unordered_set& live_blocks, const std::unordered_map& unreachable_continues) { bool modified = false; for (auto& block : *func) { if (live_blocks.count(&block)) { for (auto iter = block.begin(); iter != block.end();) { if (iter->opcode() != spv::Op::OpPhi) { break; } bool changed = false; bool backedge_added = false; Instruction* inst = &*iter; std::vector operands; // Build a complete set of operands (not just input operands). Start // with type and result id operands. operands.push_back(inst->GetOperand(0u)); operands.push_back(inst->GetOperand(1u)); // Iterate through the incoming labels and determine which to keep // and/or modify. If there in an unreachable continue block, there will // be an edge from that block to the header. We need to keep it to // maintain the structured control flow. If the header has more that 2 // incoming edges, then the OpPhi must have an entry for that edge. // However, if there is only one other incoming edge, the OpPhi can be // eliminated. for (uint32_t i = 1; i < inst->NumInOperands(); i += 2) { BasicBlock* inc = GetParentBlock(inst->GetSingleWordInOperand(i)); auto cont_iter = unreachable_continues.find(inc); if (cont_iter != unreachable_continues.end() && cont_iter->second == &block && inst->NumInOperands() > 4) { if (get_def_use_mgr() ->GetDef(inst->GetSingleWordInOperand(i - 1)) ->opcode() == spv::Op::OpUndef) { // Already undef incoming value, no change necessary. operands.push_back(inst->GetInOperand(i - 1)); operands.push_back(inst->GetInOperand(i)); backedge_added = true; } else { // Replace incoming value with undef if this phi exists in the // loop header. Otherwise, this edge is not live since the // unreachable continue block will be replaced with an // unconditional branch to the header only. operands.emplace_back( SPV_OPERAND_TYPE_ID, std::initializer_list{Type2Undef(inst->type_id())}); operands.push_back(inst->GetInOperand(i)); changed = true; backedge_added = true; } } else if (live_blocks.count(inc) && inc->IsSuccessor(&block)) { // Keep live incoming edge. operands.push_back(inst->GetInOperand(i - 1)); operands.push_back(inst->GetInOperand(i)); } else { // Remove incoming edge. changed = true; } } if (changed) { modified = true; uint32_t continue_id = block.ContinueBlockIdIfAny(); if (!backedge_added && continue_id != 0 && unreachable_continues.count(GetParentBlock(continue_id)) && operands.size() > 4) { // Changed the backedge to branch from the continue block instead // of a successor of the continue block. Add an entry to the phi to // provide an undef for the continue block. Since the successor of // the continue must also be unreachable (dominated by the continue // block), any entry for the original backedge has been removed // from the phi operands. operands.emplace_back( SPV_OPERAND_TYPE_ID, std::initializer_list{Type2Undef(inst->type_id())}); operands.emplace_back(SPV_OPERAND_TYPE_ID, std::initializer_list{continue_id}); } // Either replace the phi with a single value or rebuild the phi out // of |operands|. // // We always have type and result id operands. So this phi has a // single source if there are two more operands beyond those. if (operands.size() == 4) { // First input data operands is at index 2. uint32_t replId = operands[2u].words[0]; context()->KillNamesAndDecorates(inst->result_id()); context()->ReplaceAllUsesWith(inst->result_id(), replId); iter = context()->KillInst(&*inst); } else { // We've rewritten the operands, so first instruct the def/use // manager to forget uses in the phi before we replace them. After // replacing operands update the def/use manager by re-analyzing // the used ids in this phi. get_def_use_mgr()->EraseUseRecordsOfOperandIds(inst); inst->ReplaceOperands(operands); get_def_use_mgr()->AnalyzeInstUse(inst); ++iter; } } else { ++iter; } } } } return modified; } bool DeadBranchElimPass::EraseDeadBlocks( Function* func, const std::unordered_set& live_blocks, const std::unordered_set& unreachable_merges, const std::unordered_map& unreachable_continues) { bool modified = false; for (auto ebi = func->begin(); ebi != func->end();) { if (unreachable_continues.count(&*ebi)) { uint32_t cont_id = unreachable_continues.find(&*ebi)->second->id(); if (ebi->begin() != ebi->tail() || ebi->terminator()->opcode() != spv::Op::OpBranch || ebi->terminator()->GetSingleWordInOperand(0u) != cont_id) { // Make unreachable, but leave the label. KillAllInsts(&*ebi, false); // Add unconditional branch to header. assert(unreachable_continues.count(&*ebi)); ebi->AddInstruction(MakeUnique( context(), spv::Op::OpBranch, 0, 0, std::initializer_list{{SPV_OPERAND_TYPE_ID, {cont_id}}})); get_def_use_mgr()->AnalyzeInstUse(&*ebi->tail()); context()->set_instr_block(&*ebi->tail(), &*ebi); modified = true; } ++ebi; } else if (unreachable_merges.count(&*ebi)) { if (ebi->begin() != ebi->tail() || ebi->terminator()->opcode() != spv::Op::OpUnreachable) { // Make unreachable, but leave the label. KillAllInsts(&*ebi, false); // Add unreachable terminator. ebi->AddInstruction( MakeUnique(context(), spv::Op::OpUnreachable, 0, 0, std::initializer_list{})); context()->AnalyzeUses(ebi->terminator()); context()->set_instr_block(ebi->terminator(), &*ebi); modified = true; } ++ebi; } else if (!live_blocks.count(&*ebi)) { // Kill this block. KillAllInsts(&*ebi); ebi = ebi.Erase(); modified = true; } else { ++ebi; } } return modified; } bool DeadBranchElimPass::EliminateDeadBranches(Function* func) { if (func->IsDeclaration()) { return false; } bool modified = false; std::unordered_set live_blocks; modified |= MarkLiveBlocks(func, &live_blocks); std::unordered_set unreachable_merges; std::unordered_map unreachable_continues; MarkUnreachableStructuredTargets(live_blocks, &unreachable_merges, &unreachable_continues); modified |= FixPhiNodesInLiveBlocks(func, live_blocks, unreachable_continues); modified |= EraseDeadBlocks(func, live_blocks, unreachable_merges, unreachable_continues); return modified; } void DeadBranchElimPass::FixBlockOrder() { context()->BuildInvalidAnalyses(IRContext::kAnalysisCFG | IRContext::kAnalysisDominatorAnalysis); // Reorders blocks according to DFS of dominator tree. ProcessFunction reorder_dominators = [this](Function* function) { DominatorAnalysis* dominators = context()->GetDominatorAnalysis(function); std::vector blocks; for (auto iter = dominators->GetDomTree().begin(); iter != dominators->GetDomTree().end(); ++iter) { if (iter->id() != 0) { blocks.push_back(iter->bb_); } } for (uint32_t i = 1; i < blocks.size(); ++i) { function->MoveBasicBlockToAfter(blocks[i]->id(), blocks[i - 1]); } return true; }; // Reorders blocks according to structured order. ProcessFunction reorder_structured = [](Function* function) { function->ReorderBasicBlocksInStructuredOrder(); return true; }; // Structured order is more intuitive so use it where possible. if (context()->get_feature_mgr()->HasCapability(spv::Capability::Shader)) { context()->ProcessReachableCallTree(reorder_structured); } else { context()->ProcessReachableCallTree(reorder_dominators); } } Pass::Status DeadBranchElimPass::Process() { // Do not process if module contains OpGroupDecorate. Additional // support required in KillNamesAndDecorates(). // TODO(greg-lunarg): Add support for OpGroupDecorate for (auto& ai : get_module()->annotations()) if (ai.opcode() == spv::Op::OpGroupDecorate) return Status::SuccessWithoutChange; // Process all entry point functions ProcessFunction pfn = [this](Function* fp) { return EliminateDeadBranches(fp); }; bool modified = context()->ProcessReachableCallTree(pfn); if (modified) FixBlockOrder(); return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } Instruction* DeadBranchElimPass::FindFirstExitFromSelectionMerge( uint32_t start_block_id, uint32_t merge_block_id, uint32_t loop_merge_id, uint32_t loop_continue_id, uint32_t switch_merge_id) { // To find the "first" exit, we follow branches looking for a conditional // branch that is not in a nested construct and is not the header of a new // construct. We follow the control flow from |start_block_id| to find the // first one. while (start_block_id != merge_block_id && start_block_id != loop_merge_id && start_block_id != loop_continue_id) { BasicBlock* start_block = context()->get_instr_block(start_block_id); Instruction* branch = start_block->terminator(); uint32_t next_block_id = 0; switch (branch->opcode()) { case spv::Op::OpBranchConditional: next_block_id = start_block->MergeBlockIdIfAny(); if (next_block_id == 0) { // If a possible target is the |loop_merge_id| or |loop_continue_id|, // which are not the current merge node, then we continue the search // with the other target. for (uint32_t i = 1; i < 3; i++) { if (branch->GetSingleWordInOperand(i) == loop_merge_id && loop_merge_id != merge_block_id) { next_block_id = branch->GetSingleWordInOperand(3 - i); break; } if (branch->GetSingleWordInOperand(i) == loop_continue_id && loop_continue_id != merge_block_id) { next_block_id = branch->GetSingleWordInOperand(3 - i); break; } if (branch->GetSingleWordInOperand(i) == switch_merge_id && switch_merge_id != merge_block_id) { next_block_id = branch->GetSingleWordInOperand(3 - i); break; } } if (next_block_id == 0) { return branch; } } break; case spv::Op::OpSwitch: next_block_id = start_block->MergeBlockIdIfAny(); if (next_block_id == 0) { // A switch with no merge instructions can have at most 5 targets: // a. |merge_block_id| // b. |loop_merge_id| // c. |loop_continue_id| // d. |switch_merge_id| // e. 1 block inside the current region. // // Note that because this is a switch, |merge_block_id| must equal // |switch_merge_id|. // // This leads to a number of cases of what to do. // // 1. Does not jump to a block inside of the current construct. In // this case, there is not conditional break, so we should return // |nullptr|. // // 2. Jumps to |merge_block_id| and a block inside the current // construct. In this case, this branch conditionally break to the // end of the current construct, so return the current branch. // // 3. Otherwise, this branch may break, but not to the current merge // block. So we continue with the block that is inside the loop. bool found_break = false; for (uint32_t i = 1; i < branch->NumInOperands(); i += 2) { uint32_t target = branch->GetSingleWordInOperand(i); if (target == merge_block_id) { found_break = true; } else if (target != loop_merge_id && target != loop_continue_id) { next_block_id = branch->GetSingleWordInOperand(i); } } if (next_block_id == 0) { // Case 1. return nullptr; } if (found_break) { // Case 2. return branch; } // The fall through is case 3. } break; case spv::Op::OpBranch: // Need to check if this is the header of a loop nested in the // selection construct. next_block_id = start_block->MergeBlockIdIfAny(); if (next_block_id == 0) { next_block_id = branch->GetSingleWordInOperand(0); } break; default: return nullptr; } start_block_id = next_block_id; } return nullptr; } void DeadBranchElimPass::AddBlocksWithBackEdge( uint32_t cont_id, uint32_t header_id, uint32_t merge_id, std::unordered_set* blocks_with_back_edges) { std::unordered_set visited; visited.insert(cont_id); visited.insert(header_id); visited.insert(merge_id); std::vector work_list; work_list.push_back(cont_id); while (!work_list.empty()) { uint32_t bb_id = work_list.back(); work_list.pop_back(); BasicBlock* bb = context()->get_instr_block(bb_id); bool has_back_edge = false; bb->ForEachSuccessorLabel([header_id, &visited, &work_list, &has_back_edge](uint32_t* succ_label_id) { if (visited.insert(*succ_label_id).second) { work_list.push_back(*succ_label_id); } if (*succ_label_id == header_id) { has_back_edge = true; } }); if (has_back_edge) { blocks_with_back_edges->insert(bb); } } } bool DeadBranchElimPass::SwitchHasNestedBreak(uint32_t switch_header_id) { std::vector block_in_construct; BasicBlock* start_block = context()->get_instr_block(switch_header_id); uint32_t merge_block_id = start_block->MergeBlockIdIfAny(); StructuredCFGAnalysis* cfg_analysis = context()->GetStructuredCFGAnalysis(); return !get_def_use_mgr()->WhileEachUser( merge_block_id, [this, cfg_analysis, switch_header_id](Instruction* inst) { if (!inst->IsBranch()) { return true; } BasicBlock* bb = context()->get_instr_block(inst); if (bb->id() == switch_header_id) { return true; } return (cfg_analysis->ContainingConstruct(inst) == switch_header_id && bb->GetMergeInst() == nullptr); }); } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/dead_branch_elim_pass.h000066400000000000000000000175151475742701700252630ustar00rootroot00000000000000// Copyright (c) 2017 The Khronos Group Inc. // Copyright (c) 2017 Valve Corporation // Copyright (c) 2017 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_DEAD_BRANCH_ELIM_PASS_H_ #define SOURCE_OPT_DEAD_BRANCH_ELIM_PASS_H_ #include #include #include #include #include #include #include #include "source/opt/basic_block.h" #include "source/opt/def_use_manager.h" #include "source/opt/mem_pass.h" #include "source/opt/module.h" namespace spvtools { namespace opt { // See optimizer.hpp for documentation. class DeadBranchElimPass : public MemPass { using cbb_ptr = const BasicBlock*; public: DeadBranchElimPass() = default; const char* name() const override { return "eliminate-dead-branches"; } Status Process() override; IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisConstants | IRContext::kAnalysisTypes; } private: // If |condId| is boolean constant, return conditional value in |condVal| and // return true, otherwise return false. bool GetConstCondition(uint32_t condId, bool* condVal); // If |valId| is a 32-bit integer constant, return value via |value| and // return true, otherwise return false. bool GetConstInteger(uint32_t valId, uint32_t* value); // Add branch to |labelId| to end of block |bp|. void AddBranch(uint32_t labelId, BasicBlock* bp); // For function |func|, look for BranchConditionals with constant condition // and convert to a Branch to the indicated label. Delete resulting dead // blocks. Note some such branches and blocks may be left to avoid creating // invalid control flow. // TODO(greg-lunarg): Remove remaining constant conditional branches and dead // blocks. bool EliminateDeadBranches(Function* func); // Returns the basic block containing |id|. // Note: this pass only requires correct instruction block mappings for the // input. This pass does not preserve the block mapping, so it is not kept // up-to-date during processing. BasicBlock* GetParentBlock(uint32_t id); // Marks live blocks reachable from the entry of |func|. Simplifies constant // branches and switches as it proceeds, to limit the number of live blocks. // It is careful not to eliminate backedges even if they are dead, but the // header is live. Likewise, unreachable merge blocks named in live merge // instruction must be retained (though they may be clobbered). bool MarkLiveBlocks(Function* func, std::unordered_set* live_blocks); // Checks for unreachable merge and continue blocks with live headers; those // blocks must be retained. Continues are tracked separately so that a live // phi can be updated to take an undef value from any of its predecessors // that are unreachable continues. // // |unreachable_continues| maps the id of an unreachable continue target to // the header block that declares it. void MarkUnreachableStructuredTargets( const std::unordered_set& live_blocks, std::unordered_set* unreachable_merges, std::unordered_map* unreachable_continues); // Fix phis in reachable blocks so that only live (or unremovable) incoming // edges are present. If the block now only has a single live incoming edge, // remove the phi and replace its uses with its data input. If the single // remaining incoming edge is from the phi itself, the phi is in an // unreachable single block loop. Either the block is dead and will be // removed, or it's reachable from an unreachable continue target. In the // latter case that continue target block will be collapsed into a block that // only branches back to its header and we'll eliminate the block with the // phi. // // |unreachable_continues| maps continue targets that cannot be reached to // merge instruction that declares them. bool FixPhiNodesInLiveBlocks( Function* func, const std::unordered_set& live_blocks, const std::unordered_map& unreachable_continues); // Erases dead blocks. Any block captured in |unreachable_merges| or // |unreachable_continues| is a dead block that is required to remain due to // a live merge instruction in the corresponding header. These blocks will // have their instructions clobbered and will become a label and terminator. // Unreachable merge blocks are terminated by OpUnreachable, while // unreachable continue blocks are terminated by an unconditional branch to // the header. Otherwise, blocks are dead if not explicitly captured in // |live_blocks| and are totally removed. // // |unreachable_continues| maps continue targets that cannot be reached to // corresponding header block that declares them. bool EraseDeadBlocks( Function* func, const std::unordered_set& live_blocks, const std::unordered_set& unreachable_merges, const std::unordered_map& unreachable_continues); // Reorders blocks in reachable functions so that they satisfy dominator // block ordering rules. void FixBlockOrder(); // Return the first branch instruction that is a conditional branch to // |merge_block_id|. Returns |nullptr| if no such branch exists. If there are // multiple such branches, the first one is the one that would be executed // first when running the code. That is, the one that dominates all of the // others. // // |start_block_id| must be a block whose innermost containing merge construct // has |merge_block_id| as the merge block. // // |loop_merge_id| and |loop_continue_id| are the merge and continue block ids // of the innermost loop containing |start_block_id|. Instruction* FindFirstExitFromSelectionMerge(uint32_t start_block_id, uint32_t merge_block_id, uint32_t loop_merge_id, uint32_t loop_continue_id, uint32_t switch_merge_id); // Adds to |blocks_with_back_edges| all of the blocks on the path from the // basic block |cont_id| to |header_id| and |merge_id|. The intention is that // |cond_id| is a the continue target of a loop, |header_id| is the header of // the loop, and |merge_id| is the merge block of the loop. void AddBlocksWithBackEdge( uint32_t cont_id, uint32_t header_id, uint32_t merge_id, std::unordered_set* blocks_with_back_edges); // Returns true if there is a branch to the merge node of the selection // construct |switch_header_id| that is inside a nested selection construct or // in the header of the nested selection construct. bool SwitchHasNestedBreak(uint32_t switch_header_id); // Return true of the terminator of |block| is successfully replaced with a // branch to |live_lab_id|. The merge instruction is deleted or moved as // needed to maintain structured control flow. Assumes that the // StructuredCFGAnalysis is valid for the constructs containing |block|. bool SimplifyBranch(BasicBlock* block, uint32_t live_lab_id); }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_DEAD_BRANCH_ELIM_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/dead_insert_elim_pass.cpp000066400000000000000000000247271475742701700256700ustar00rootroot00000000000000// Copyright (c) 2018 The Khronos Group Inc. // Copyright (c) 2018 Valve Corporation // Copyright (c) 2018 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/dead_insert_elim_pass.h" #include "source/opt/composite.h" #include "source/opt/ir_context.h" #include "source/opt/iterator.h" #include "spirv/1.2/GLSL.std.450.h" namespace spvtools { namespace opt { namespace { constexpr uint32_t kTypeVectorCountInIdx = 1; constexpr uint32_t kTypeMatrixCountInIdx = 1; constexpr uint32_t kTypeArrayLengthIdInIdx = 1; constexpr uint32_t kTypeIntWidthInIdx = 0; constexpr uint32_t kConstantValueInIdx = 0; constexpr uint32_t kInsertObjectIdInIdx = 0; constexpr uint32_t kInsertCompositeIdInIdx = 1; } // namespace uint32_t DeadInsertElimPass::NumComponents(Instruction* typeInst) { switch (typeInst->opcode()) { case spv::Op::OpTypeVector: { return typeInst->GetSingleWordInOperand(kTypeVectorCountInIdx); } break; case spv::Op::OpTypeMatrix: { return typeInst->GetSingleWordInOperand(kTypeMatrixCountInIdx); } break; case spv::Op::OpTypeArray: { uint32_t lenId = typeInst->GetSingleWordInOperand(kTypeArrayLengthIdInIdx); Instruction* lenInst = get_def_use_mgr()->GetDef(lenId); if (lenInst->opcode() != spv::Op::OpConstant) return 0; uint32_t lenTypeId = lenInst->type_id(); Instruction* lenTypeInst = get_def_use_mgr()->GetDef(lenTypeId); // TODO(greg-lunarg): Support non-32-bit array length if (lenTypeInst->GetSingleWordInOperand(kTypeIntWidthInIdx) != 32) return 0; return lenInst->GetSingleWordInOperand(kConstantValueInIdx); } break; case spv::Op::OpTypeStruct: { return typeInst->NumInOperands(); } break; default: { return 0; } break; } } void DeadInsertElimPass::MarkInsertChain( Instruction* insertChain, std::vector* pExtIndices, uint32_t extOffset, std::unordered_set* visited_phis) { // Not currently optimizing array inserts. Instruction* typeInst = get_def_use_mgr()->GetDef(insertChain->type_id()); if (typeInst->opcode() == spv::Op::OpTypeArray) return; // Insert chains are only composed of inserts and phis if (insertChain->opcode() != spv::Op::OpCompositeInsert && insertChain->opcode() != spv::Op::OpPhi) return; // If extract indices are empty, mark all subcomponents if type // is constant length. if (pExtIndices == nullptr) { uint32_t cnum = NumComponents(typeInst); if (cnum > 0) { std::vector extIndices; for (uint32_t i = 0; i < cnum; i++) { extIndices.clear(); extIndices.push_back(i); std::unordered_set sub_visited_phis; MarkInsertChain(insertChain, &extIndices, 0, &sub_visited_phis); } return; } } Instruction* insInst = insertChain; while (insInst->opcode() == spv::Op::OpCompositeInsert) { // If no extract indices, mark insert and inserted object (which might // also be an insert chain) and continue up the chain though the input // composite. // // Note: We mark inserted objects in this function (rather than in // EliminateDeadInsertsOnePass) because in some cases, we can do it // more accurately here. if (pExtIndices == nullptr) { liveInserts_.insert(insInst->result_id()); uint32_t objId = insInst->GetSingleWordInOperand(kInsertObjectIdInIdx); std::unordered_set obj_visited_phis; MarkInsertChain(get_def_use_mgr()->GetDef(objId), nullptr, 0, &obj_visited_phis); // If extract indices match insert, we are done. Mark insert and // inserted object. } else if (ExtInsMatch(*pExtIndices, insInst, extOffset)) { liveInserts_.insert(insInst->result_id()); uint32_t objId = insInst->GetSingleWordInOperand(kInsertObjectIdInIdx); std::unordered_set obj_visited_phis; MarkInsertChain(get_def_use_mgr()->GetDef(objId), nullptr, 0, &obj_visited_phis); break; // If non-matching intersection, mark insert } else if (ExtInsConflict(*pExtIndices, insInst, extOffset)) { liveInserts_.insert(insInst->result_id()); // If more extract indices than insert, we are done. Use remaining // extract indices to mark inserted object. uint32_t numInsertIndices = insInst->NumInOperands() - 2; if (pExtIndices->size() - extOffset > numInsertIndices) { uint32_t objId = insInst->GetSingleWordInOperand(kInsertObjectIdInIdx); std::unordered_set obj_visited_phis; MarkInsertChain(get_def_use_mgr()->GetDef(objId), pExtIndices, extOffset + numInsertIndices, &obj_visited_phis); break; // If fewer extract indices than insert, also mark inserted object and // continue up chain. } else { uint32_t objId = insInst->GetSingleWordInOperand(kInsertObjectIdInIdx); std::unordered_set obj_visited_phis; MarkInsertChain(get_def_use_mgr()->GetDef(objId), nullptr, 0, &obj_visited_phis); } } // Get next insert in chain const uint32_t compId = insInst->GetSingleWordInOperand(kInsertCompositeIdInIdx); insInst = get_def_use_mgr()->GetDef(compId); } // If insert chain ended with phi, do recursive call on each operand if (insInst->opcode() != spv::Op::OpPhi) return; // Mark phi visited to prevent potential infinite loop. If phi is already // visited, return to avoid infinite loop. if (visited_phis->count(insInst->result_id()) != 0) return; visited_phis->insert(insInst->result_id()); // Phis may have duplicate inputs values for different edges, prune incoming // ids lists before recursing. std::vector ids; for (uint32_t i = 0; i < insInst->NumInOperands(); i += 2) { ids.push_back(insInst->GetSingleWordInOperand(i)); } std::sort(ids.begin(), ids.end()); auto new_end = std::unique(ids.begin(), ids.end()); for (auto id_iter = ids.begin(); id_iter != new_end; ++id_iter) { Instruction* pi = get_def_use_mgr()->GetDef(*id_iter); MarkInsertChain(pi, pExtIndices, extOffset, visited_phis); } } bool DeadInsertElimPass::EliminateDeadInserts(Function* func) { bool modified = false; bool lastmodified = true; // Each pass can delete dead instructions, thus potentially revealing // new dead insertions ie insertions with no uses. while (lastmodified) { lastmodified = EliminateDeadInsertsOnePass(func); modified |= lastmodified; } return modified; } bool DeadInsertElimPass::EliminateDeadInsertsOnePass(Function* func) { bool modified = false; liveInserts_.clear(); visitedPhis_.clear(); // Mark all live inserts for (auto bi = func->begin(); bi != func->end(); ++bi) { for (auto ii = bi->begin(); ii != bi->end(); ++ii) { // Only process Inserts and composite Phis spv::Op op = ii->opcode(); Instruction* typeInst = get_def_use_mgr()->GetDef(ii->type_id()); if (op != spv::Op::OpCompositeInsert && (op != spv::Op::OpPhi || !spvOpcodeIsComposite(typeInst->opcode()))) continue; // The marking algorithm can be expensive for large arrays and the // efficacy of eliminating dead inserts into arrays is questionable. // Skip optimizing array inserts for now. Just mark them live. // TODO(greg-lunarg): Eliminate dead array inserts if (op == spv::Op::OpCompositeInsert) { if (typeInst->opcode() == spv::Op::OpTypeArray) { liveInserts_.insert(ii->result_id()); continue; } } const uint32_t id = ii->result_id(); get_def_use_mgr()->ForEachUser(id, [&ii, this](Instruction* user) { if (user->IsCommonDebugInstr()) return; switch (user->opcode()) { case spv::Op::OpCompositeInsert: case spv::Op::OpPhi: // Use by insert or phi does not initiate marking break; case spv::Op::OpCompositeExtract: { // Capture extract indices std::vector extIndices; uint32_t icnt = 0; user->ForEachInOperand([&icnt, &extIndices](const uint32_t* idp) { if (icnt > 0) extIndices.push_back(*idp); ++icnt; }); // Mark all inserts in chain that intersect with extract std::unordered_set visited_phis; MarkInsertChain(&*ii, &extIndices, 0, &visited_phis); } break; default: { // Mark inserts in chain for all components std::unordered_set visited_phis; MarkInsertChain(&*ii, nullptr, 0, &visited_phis); } break; } }); } } // Find and disconnect dead inserts std::vector dead_instructions; for (auto bi = func->begin(); bi != func->end(); ++bi) { for (auto ii = bi->begin(); ii != bi->end(); ++ii) { if (ii->opcode() != spv::Op::OpCompositeInsert) continue; const uint32_t id = ii->result_id(); if (liveInserts_.find(id) != liveInserts_.end()) continue; const uint32_t replId = ii->GetSingleWordInOperand(kInsertCompositeIdInIdx); (void)context()->ReplaceAllUsesWith(id, replId); dead_instructions.push_back(&*ii); modified = true; } } // DCE dead inserts while (!dead_instructions.empty()) { Instruction* inst = dead_instructions.back(); dead_instructions.pop_back(); DCEInst(inst, [&dead_instructions](Instruction* other_inst) { auto i = std::find(dead_instructions.begin(), dead_instructions.end(), other_inst); if (i != dead_instructions.end()) { dead_instructions.erase(i); } }); } return modified; } Pass::Status DeadInsertElimPass::Process() { // Process all entry point functions. ProcessFunction pfn = [this](Function* fp) { return EliminateDeadInserts(fp); }; bool modified = context()->ProcessReachableCallTree(pfn); return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/dead_insert_elim_pass.h000066400000000000000000000065351475742701700253320ustar00rootroot00000000000000// Copyright (c) 2018 The Khronos Group Inc. // Copyright (c) 2018 Valve Corporation // Copyright (c) 2018 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_DEAD_INSERT_ELIM_PASS_H_ #define SOURCE_OPT_DEAD_INSERT_ELIM_PASS_H_ #include #include #include #include #include #include #include "source/opt/basic_block.h" #include "source/opt/def_use_manager.h" #include "source/opt/ir_context.h" #include "source/opt/mem_pass.h" #include "source/opt/module.h" namespace spvtools { namespace opt { // See optimizer.hpp for documentation. class DeadInsertElimPass : public MemPass { public: DeadInsertElimPass() = default; const char* name() const override { return "eliminate-dead-inserts"; } Status Process() override; IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisDecorations | IRContext::kAnalysisCombinators | IRContext::kAnalysisCFG | IRContext::kAnalysisDominatorAnalysis | IRContext::kAnalysisNameMap | IRContext::kAnalysisConstants | IRContext::kAnalysisTypes; } private: // Return the number of subcomponents in the composite type |typeId|. // Return 0 if not a composite type or number of components is not a // 32-bit constant. uint32_t NumComponents(Instruction* typeInst); // Mark all inserts in instruction chain ending at |insertChain| with // indices that intersect with extract indices |extIndices| starting with // index at |extOffset|. Chains are composed solely of Inserts and Phis. // Mark all inserts in chain if |extIndices| is nullptr. void MarkInsertChain(Instruction* insertChain, std::vector* extIndices, uint32_t extOffset, std::unordered_set* visited_phis); // Perform EliminateDeadInsertsOnePass(|func|) until no modification is // made. Return true if modified. bool EliminateDeadInserts(Function* func); // DCE all dead struct, matrix and vector inserts in |func|. An insert is // dead if the value it inserts is never used. Replace any reference to the // insert with its original composite. Return true if modified. Dead inserts // in dependence cycles are not currently eliminated. Dead inserts into // arrays are not currently eliminated. bool EliminateDeadInsertsOnePass(Function* func); // Return true if all extensions in this module are allowed by this pass. bool AllExtensionsSupported() const; // Live inserts std::unordered_set liveInserts_; // Visited phis as insert chain is traversed; used to avoid infinite loop std::unordered_map visitedPhis_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_DEAD_INSERT_ELIM_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/dead_variable_elimination.cpp000066400000000000000000000077141475742701700265020ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/dead_variable_elimination.h" #include #include "source/opt/ir_context.h" #include "source/opt/reflect.h" namespace spvtools { namespace opt { // This optimization removes global variables that are not needed because they // are definitely not accessed. Pass::Status DeadVariableElimination::Process() { // The algorithm will compute the reference count for every global variable. // Anything with a reference count of 0 will then be deleted. For variables // that might have references that are not explicit in this context, we use // the value kMustKeep as the reference count. std::vector ids_to_remove; // Get the reference count for all of the global OpVariable instructions. for (auto& inst : context()->types_values()) { if (inst.opcode() != spv::Op::OpVariable) { continue; } size_t count = 0; uint32_t result_id = inst.result_id(); // Check the linkage. If it is exported, it could be reference somewhere // else, so we must keep the variable around. get_decoration_mgr()->ForEachDecoration( result_id, uint32_t(spv::Decoration::LinkageAttributes), [&count](const Instruction& linkage_instruction) { uint32_t last_operand = linkage_instruction.NumOperands() - 1; if (spv::LinkageType(linkage_instruction.GetSingleWordOperand( last_operand)) == spv::LinkageType::Export) { count = kMustKeep; } }); if (count != kMustKeep) { // If we don't have to keep the instruction for other reasons, then look // at the uses and count the number of real references. count = 0; get_def_use_mgr()->ForEachUser(result_id, [&count](Instruction* user) { if (!IsAnnotationInst(user->opcode()) && user->opcode() != spv::Op::OpName) { ++count; } }); } reference_count_[result_id] = count; if (count == 0) { ids_to_remove.push_back(result_id); } } // Remove all of the variables that have a reference count of 0. bool modified = false; if (!ids_to_remove.empty()) { modified = true; for (auto result_id : ids_to_remove) { DeleteVariable(result_id); } } return (modified ? Status::SuccessWithChange : Status::SuccessWithoutChange); } void DeadVariableElimination::DeleteVariable(uint32_t result_id) { Instruction* inst = get_def_use_mgr()->GetDef(result_id); assert(inst->opcode() == spv::Op::OpVariable && "Should not be trying to delete anything other than an OpVariable."); // Look for an initializer that references another variable. We need to know // if that variable can be deleted after the reference is removed. if (inst->NumOperands() == 4) { Instruction* initializer = get_def_use_mgr()->GetDef(inst->GetSingleWordOperand(3)); // TODO: Handle OpSpecConstantOP which might be defined in terms of other // variables. Will probably require a unified dead code pass that does all // instruction types. (Issue 906) if (initializer->opcode() == spv::Op::OpVariable) { uint32_t initializer_id = initializer->result_id(); size_t& count = reference_count_[initializer_id]; if (count != kMustKeep) { --count; } if (count == 0) { DeleteVariable(initializer_id); } } } context()->KillDef(result_id); } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/dead_variable_elimination.h000066400000000000000000000035271475742701700261450ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_DEAD_VARIABLE_ELIMINATION_H_ #define SOURCE_OPT_DEAD_VARIABLE_ELIMINATION_H_ #include #include #include "source/opt/decoration_manager.h" #include "source/opt/mem_pass.h" namespace spvtools { namespace opt { class DeadVariableElimination : public MemPass { public: const char* name() const override { return "eliminate-dead-variables"; } Status Process() override; IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisDefUse | IRContext::kAnalysisConstants | IRContext::kAnalysisTypes; } private: // Deletes the OpVariable instruction who result id is |result_id|. void DeleteVariable(uint32_t result_id); // Keeps track of the number of references of an id. Once that value is 0, it // is safe to remove the corresponding instruction. // // Note that the special value kMustKeep is used to indicate that the // instruction cannot be deleted for reasons other that is being explicitly // referenced. std::unordered_map reference_count_; // Special value used to indicate that an id cannot be safely deleted. enum { kMustKeep = INT_MAX }; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_DEAD_VARIABLE_ELIMINATION_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/debug_info_manager.cpp000066400000000000000000001127101475742701700251340ustar00rootroot00000000000000// Copyright (c) 2020-2022 Google LLC // Copyright (c) 2022 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/debug_info_manager.h" #include #include "source/opt/ir_context.h" // Constants for OpenCL.DebugInfo.100 & NonSemantic.Shader.DebugInfo.100 // extension instructions. namespace spvtools { namespace opt { namespace analysis { namespace { constexpr uint32_t kOpLineOperandLineIndex = 1; constexpr uint32_t kLineOperandIndexDebugFunction = 7; constexpr uint32_t kLineOperandIndexDebugLexicalBlock = 5; constexpr uint32_t kLineOperandIndexDebugLine = 5; constexpr uint32_t kDebugFunctionOperandFunctionIndex = 13; constexpr uint32_t kDebugFunctionDefinitionOperandDebugFunctionIndex = 4; constexpr uint32_t kDebugFunctionDefinitionOperandOpFunctionIndex = 5; constexpr uint32_t kDebugFunctionOperandParentIndex = 9; constexpr uint32_t kDebugTypeCompositeOperandParentIndex = 9; constexpr uint32_t kDebugLexicalBlockOperandParentIndex = 7; constexpr uint32_t kDebugInlinedAtOperandInlinedIndex = 6; constexpr uint32_t kDebugExpressOperandOperationIndex = 4; constexpr uint32_t kDebugDeclareOperandLocalVariableIndex = 4; constexpr uint32_t kDebugDeclareOperandVariableIndex = 5; constexpr uint32_t kDebugValueOperandExpressionIndex = 6; constexpr uint32_t kDebugOperationOperandOperationIndex = 4; constexpr uint32_t kOpVariableOperandStorageClassIndex = 2; constexpr uint32_t kDebugLocalVariableOperandParentIndex = 9; constexpr uint32_t kExtInstInstructionInIdx = 1; constexpr uint32_t kDebugGlobalVariableOperandFlagsIndex = 12; constexpr uint32_t kDebugLocalVariableOperandFlagsIndex = 10; void SetInlinedOperand(Instruction* dbg_inlined_at, uint32_t inlined_operand) { assert(dbg_inlined_at); assert(dbg_inlined_at->GetCommonDebugOpcode() == CommonDebugInfoDebugInlinedAt); if (dbg_inlined_at->NumOperands() <= kDebugInlinedAtOperandInlinedIndex) { dbg_inlined_at->AddOperand( {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {inlined_operand}}); } else { dbg_inlined_at->SetOperand(kDebugInlinedAtOperandInlinedIndex, {inlined_operand}); } } uint32_t GetInlinedOperand(Instruction* dbg_inlined_at) { assert(dbg_inlined_at); assert(dbg_inlined_at->GetCommonDebugOpcode() == CommonDebugInfoDebugInlinedAt); if (dbg_inlined_at->NumOperands() <= kDebugInlinedAtOperandInlinedIndex) return kNoInlinedAt; return dbg_inlined_at->GetSingleWordOperand( kDebugInlinedAtOperandInlinedIndex); } bool IsEmptyDebugExpression(Instruction* instr) { return (instr->GetCommonDebugOpcode() == CommonDebugInfoDebugExpression) && instr->NumOperands() == kDebugExpressOperandOperationIndex; } } // namespace DebugInfoManager::DebugInfoManager(IRContext* c) : context_(c) { AnalyzeDebugInsts(*c->module()); } uint32_t DebugInfoManager::GetDbgSetImportId() { uint32_t setId = context()->get_feature_mgr()->GetExtInstImportId_OpenCL100DebugInfo(); if (setId == 0) { setId = context()->get_feature_mgr()->GetExtInstImportId_Shader100DebugInfo(); } return setId; } Instruction* DebugInfoManager::GetDbgInst(uint32_t id) { auto dbg_inst_it = id_to_dbg_inst_.find(id); return dbg_inst_it == id_to_dbg_inst_.end() ? nullptr : dbg_inst_it->second; } void DebugInfoManager::RegisterDbgInst(Instruction* inst) { assert(inst->NumInOperands() != 0 && (GetDbgSetImportId() == inst->GetInOperand(0).words[0]) && "Given instruction is not a debug instruction"); id_to_dbg_inst_[inst->result_id()] = inst; } void DebugInfoManager::RegisterDbgFunction(Instruction* inst) { if (inst->GetOpenCL100DebugOpcode() == OpenCLDebugInfo100DebugFunction) { auto fn_id = inst->GetSingleWordOperand(kDebugFunctionOperandFunctionIndex); // Do not register function that has been optimized away. auto fn_inst = GetDbgInst(fn_id); if (fn_inst != nullptr) { assert(GetDbgInst(fn_id)->GetOpenCL100DebugOpcode() == OpenCLDebugInfo100DebugInfoNone); return; } assert( fn_id_to_dbg_fn_.find(fn_id) == fn_id_to_dbg_fn_.end() && "Register DebugFunction for a function that already has DebugFunction"); fn_id_to_dbg_fn_[fn_id] = inst; } else if (inst->GetShader100DebugOpcode() == NonSemanticShaderDebugInfo100DebugFunctionDefinition) { auto fn_id = inst->GetSingleWordOperand( kDebugFunctionDefinitionOperandOpFunctionIndex); auto fn_inst = GetDbgInst(inst->GetSingleWordOperand( kDebugFunctionDefinitionOperandDebugFunctionIndex)); assert(fn_inst && fn_inst->GetShader100DebugOpcode() == NonSemanticShaderDebugInfo100DebugFunction); assert(fn_id_to_dbg_fn_.find(fn_id) == fn_id_to_dbg_fn_.end() && "Register DebugFunctionDefinition for a function that already has " "DebugFunctionDefinition"); fn_id_to_dbg_fn_[fn_id] = fn_inst; } else { assert(false && "inst is not a DebugFunction"); } } void DebugInfoManager::RegisterDbgDeclare(uint32_t var_id, Instruction* dbg_declare) { assert(dbg_declare->GetCommonDebugOpcode() == CommonDebugInfoDebugDeclare || dbg_declare->GetCommonDebugOpcode() == CommonDebugInfoDebugValue); auto dbg_decl_itr = var_id_to_dbg_decl_.find(var_id); if (dbg_decl_itr == var_id_to_dbg_decl_.end()) { var_id_to_dbg_decl_[var_id] = {dbg_declare}; } else { dbg_decl_itr->second.insert(dbg_declare); } } // Create new constant directly into global value area, bypassing the // Constant manager. This is used when the DefUse or Constant managers // are invalid and cannot be regenerated due to the module being in an // inconsistent state e.g. in the middle of significant modification // such as inlining. Invalidate Constant and DefUse managers if used. uint32_t AddNewConstInGlobals(IRContext* context, uint32_t const_value) { uint32_t id = context->TakeNextId(); std::unique_ptr new_const(new Instruction( context, spv::Op::OpConstant, context->get_type_mgr()->GetUIntTypeId(), id, { {spv_operand_type_t::SPV_OPERAND_TYPE_TYPED_LITERAL_NUMBER, {const_value}}, })); context->module()->AddGlobalValue(std::move(new_const)); context->InvalidateAnalyses(IRContext::kAnalysisConstants); context->InvalidateAnalyses(IRContext::kAnalysisDefUse); return id; } uint32_t DebugInfoManager::CreateDebugInlinedAt(const Instruction* line, const DebugScope& scope) { uint32_t setId = GetDbgSetImportId(); if (setId == 0) return kNoInlinedAt; spv_operand_type_t line_number_type = spv_operand_type_t::SPV_OPERAND_TYPE_LITERAL_INTEGER; // In NonSemantic.Shader.DebugInfo.100, all constants are IDs of OpConstant, // not literals. if (setId == context()->get_feature_mgr()->GetExtInstImportId_Shader100DebugInfo()) line_number_type = spv_operand_type_t::SPV_OPERAND_TYPE_ID; uint32_t line_number = 0; if (line == nullptr) { auto* lexical_scope_inst = GetDbgInst(scope.GetLexicalScope()); if (lexical_scope_inst == nullptr) return kNoInlinedAt; CommonDebugInfoInstructions debug_opcode = lexical_scope_inst->GetCommonDebugOpcode(); switch (debug_opcode) { case CommonDebugInfoDebugFunction: line_number = lexical_scope_inst->GetSingleWordOperand( kLineOperandIndexDebugFunction); break; case CommonDebugInfoDebugLexicalBlock: line_number = lexical_scope_inst->GetSingleWordOperand( kLineOperandIndexDebugLexicalBlock); break; case CommonDebugInfoDebugTypeComposite: case CommonDebugInfoDebugCompilationUnit: assert(false && "DebugTypeComposite and DebugCompilationUnit are lexical " "scopes, but we inline functions into a function or a block " "of a function, not into a struct/class or a global scope."); break; default: assert(false && "Unreachable. a debug extension instruction for a " "lexical scope must be DebugFunction, DebugTypeComposite, " "DebugLexicalBlock, or DebugCompilationUnit."); break; } } else { if (line->opcode() == spv::Op::OpLine) { line_number = line->GetSingleWordOperand(kOpLineOperandLineIndex); } else if (line->GetShader100DebugOpcode() == NonSemanticShaderDebugInfo100DebugLine) { line_number = line->GetSingleWordOperand(kLineOperandIndexDebugLine); } else { assert(false && "Unreachable. A line instruction must be OpLine or DebugLine"); } // If we need the line number as an ID, generate that constant now. // If Constant or DefUse managers are invalid, generate constant // directly into the global value section of the module; do not // use Constant manager which may attempt to invoke building of the // DefUse manager which cannot be done during inlining. The extra // constants that may be generated here is likely not significant // and will likely be cleaned up in later passes. if (line_number_type == spv_operand_type_t::SPV_OPERAND_TYPE_ID && line->opcode() == spv::Op::OpLine) { if (!context()->AreAnalysesValid(IRContext::Analysis::kAnalysisDefUse) || !context()->AreAnalysesValid(IRContext::Analysis::kAnalysisConstants)) line_number = AddNewConstInGlobals(context(), line_number); else line_number = context()->get_constant_mgr()->GetUIntConstId(line_number); } } uint32_t result_id = context()->TakeNextId(); std::unique_ptr inlined_at(new Instruction( context(), spv::Op::OpExtInst, context()->get_type_mgr()->GetVoidTypeId(), result_id, { {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {setId}}, {spv_operand_type_t::SPV_OPERAND_TYPE_EXTENSION_INSTRUCTION_NUMBER, {static_cast(CommonDebugInfoDebugInlinedAt)}}, {line_number_type, {line_number}}, {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {scope.GetLexicalScope()}}, })); // |scope| already has DebugInlinedAt. We put the existing DebugInlinedAt // into the Inlined operand of this new DebugInlinedAt. if (scope.GetInlinedAt() != kNoInlinedAt) { inlined_at->AddOperand( {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {scope.GetInlinedAt()}}); } RegisterDbgInst(inlined_at.get()); if (context()->AreAnalysesValid(IRContext::Analysis::kAnalysisDefUse)) context()->get_def_use_mgr()->AnalyzeInstDefUse(inlined_at.get()); context()->module()->AddExtInstDebugInfo(std::move(inlined_at)); return result_id; } DebugScope DebugInfoManager::BuildDebugScope( const DebugScope& callee_instr_scope, DebugInlinedAtContext* inlined_at_ctx) { return DebugScope(callee_instr_scope.GetLexicalScope(), BuildDebugInlinedAtChain(callee_instr_scope.GetInlinedAt(), inlined_at_ctx)); } uint32_t DebugInfoManager::BuildDebugInlinedAtChain( uint32_t callee_inlined_at, DebugInlinedAtContext* inlined_at_ctx) { if (inlined_at_ctx->GetScopeOfCallInstruction().GetLexicalScope() == kNoDebugScope) return kNoInlinedAt; // Reuse the already generated DebugInlinedAt chain if exists. uint32_t already_generated_chain_head_id = inlined_at_ctx->GetDebugInlinedAtChain(callee_inlined_at); if (already_generated_chain_head_id != kNoInlinedAt) { return already_generated_chain_head_id; } const uint32_t new_dbg_inlined_at_id = CreateDebugInlinedAt(inlined_at_ctx->GetLineOfCallInstruction(), inlined_at_ctx->GetScopeOfCallInstruction()); if (new_dbg_inlined_at_id == kNoInlinedAt) return kNoInlinedAt; if (callee_inlined_at == kNoInlinedAt) { inlined_at_ctx->SetDebugInlinedAtChain(kNoInlinedAt, new_dbg_inlined_at_id); return new_dbg_inlined_at_id; } uint32_t chain_head_id = kNoInlinedAt; uint32_t chain_iter_id = callee_inlined_at; Instruction* last_inlined_at_in_chain = nullptr; do { Instruction* new_inlined_at_in_chain = CloneDebugInlinedAt( chain_iter_id, /* insert_before */ last_inlined_at_in_chain); assert(new_inlined_at_in_chain != nullptr); // Set DebugInlinedAt of the new scope as the head of the chain. if (chain_head_id == kNoInlinedAt) chain_head_id = new_inlined_at_in_chain->result_id(); // Previous DebugInlinedAt of the chain must point to the new // DebugInlinedAt as its Inlined operand to build a recursive // chain. if (last_inlined_at_in_chain != nullptr) { SetInlinedOperand(last_inlined_at_in_chain, new_inlined_at_in_chain->result_id()); } last_inlined_at_in_chain = new_inlined_at_in_chain; chain_iter_id = GetInlinedOperand(new_inlined_at_in_chain); } while (chain_iter_id != kNoInlinedAt); // Put |new_dbg_inlined_at_id| into the end of the chain. SetInlinedOperand(last_inlined_at_in_chain, new_dbg_inlined_at_id); // Keep the new chain information that will be reused it. inlined_at_ctx->SetDebugInlinedAtChain(callee_inlined_at, chain_head_id); return chain_head_id; } Instruction* DebugInfoManager::GetDebugOperationWithDeref() { if (deref_operation_ != nullptr) return deref_operation_; uint32_t result_id = context()->TakeNextId(); std::unique_ptr deref_operation; if (context()->get_feature_mgr()->GetExtInstImportId_OpenCL100DebugInfo()) { deref_operation = std::unique_ptr(new Instruction( context(), spv::Op::OpExtInst, context()->get_type_mgr()->GetVoidTypeId(), result_id, { {SPV_OPERAND_TYPE_ID, {GetDbgSetImportId()}}, {SPV_OPERAND_TYPE_EXTENSION_INSTRUCTION_NUMBER, {static_cast(OpenCLDebugInfo100DebugOperation)}}, {SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION, {static_cast(OpenCLDebugInfo100Deref)}}, })); } else { uint32_t deref_id = context()->get_constant_mgr()->GetUIntConstId( NonSemanticShaderDebugInfo100Deref); deref_operation = std::unique_ptr( new Instruction(context(), spv::Op::OpExtInst, context()->get_type_mgr()->GetVoidTypeId(), result_id, { {SPV_OPERAND_TYPE_ID, {GetDbgSetImportId()}}, {SPV_OPERAND_TYPE_EXTENSION_INSTRUCTION_NUMBER, {static_cast( NonSemanticShaderDebugInfo100DebugOperation)}}, {SPV_OPERAND_TYPE_ID, {deref_id}}, })); } // Add to the front of |ext_inst_debuginfo_|. deref_operation_ = context()->module()->ext_inst_debuginfo_begin()->InsertBefore( std::move(deref_operation)); RegisterDbgInst(deref_operation_); if (context()->AreAnalysesValid(IRContext::Analysis::kAnalysisDefUse)) context()->get_def_use_mgr()->AnalyzeInstDefUse(deref_operation_); return deref_operation_; } Instruction* DebugInfoManager::DerefDebugExpression(Instruction* dbg_expr) { assert(dbg_expr->GetCommonDebugOpcode() == CommonDebugInfoDebugExpression); std::unique_ptr deref_expr(dbg_expr->Clone(context())); deref_expr->SetResultId(context()->TakeNextId()); deref_expr->InsertOperand( kDebugExpressOperandOperationIndex, {SPV_OPERAND_TYPE_ID, {GetDebugOperationWithDeref()->result_id()}}); auto* deref_expr_instr = context()->ext_inst_debuginfo_end()->InsertBefore(std::move(deref_expr)); AnalyzeDebugInst(deref_expr_instr); if (context()->AreAnalysesValid(IRContext::Analysis::kAnalysisDefUse)) context()->get_def_use_mgr()->AnalyzeInstDefUse(deref_expr_instr); return deref_expr_instr; } Instruction* DebugInfoManager::GetDebugInfoNone() { if (debug_info_none_inst_ != nullptr) return debug_info_none_inst_; uint32_t result_id = context()->TakeNextId(); std::unique_ptr dbg_info_none_inst(new Instruction( context(), spv::Op::OpExtInst, context()->get_type_mgr()->GetVoidTypeId(), result_id, { {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {GetDbgSetImportId()}}, {spv_operand_type_t::SPV_OPERAND_TYPE_EXTENSION_INSTRUCTION_NUMBER, {static_cast(CommonDebugInfoDebugInfoNone)}}, })); // Add to the front of |ext_inst_debuginfo_|. debug_info_none_inst_ = context()->module()->ext_inst_debuginfo_begin()->InsertBefore( std::move(dbg_info_none_inst)); RegisterDbgInst(debug_info_none_inst_); if (context()->AreAnalysesValid(IRContext::Analysis::kAnalysisDefUse)) context()->get_def_use_mgr()->AnalyzeInstDefUse(debug_info_none_inst_); return debug_info_none_inst_; } Instruction* DebugInfoManager::GetEmptyDebugExpression() { if (empty_debug_expr_inst_ != nullptr) return empty_debug_expr_inst_; uint32_t result_id = context()->TakeNextId(); std::unique_ptr empty_debug_expr(new Instruction( context(), spv::Op::OpExtInst, context()->get_type_mgr()->GetVoidTypeId(), result_id, { {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {GetDbgSetImportId()}}, {spv_operand_type_t::SPV_OPERAND_TYPE_EXTENSION_INSTRUCTION_NUMBER, {static_cast(CommonDebugInfoDebugExpression)}}, })); // Add to the front of |ext_inst_debuginfo_|. empty_debug_expr_inst_ = context()->module()->ext_inst_debuginfo_begin()->InsertBefore( std::move(empty_debug_expr)); RegisterDbgInst(empty_debug_expr_inst_); if (context()->AreAnalysesValid(IRContext::Analysis::kAnalysisDefUse)) context()->get_def_use_mgr()->AnalyzeInstDefUse(empty_debug_expr_inst_); return empty_debug_expr_inst_; } Instruction* DebugInfoManager::GetDebugInlinedAt(uint32_t dbg_inlined_at_id) { auto* inlined_at = GetDbgInst(dbg_inlined_at_id); if (inlined_at == nullptr) return nullptr; if (inlined_at->GetCommonDebugOpcode() != CommonDebugInfoDebugInlinedAt) { return nullptr; } return inlined_at; } Instruction* DebugInfoManager::CloneDebugInlinedAt(uint32_t clone_inlined_at_id, Instruction* insert_before) { auto* inlined_at = GetDebugInlinedAt(clone_inlined_at_id); if (inlined_at == nullptr) return nullptr; std::unique_ptr new_inlined_at(inlined_at->Clone(context())); new_inlined_at->SetResultId(context()->TakeNextId()); RegisterDbgInst(new_inlined_at.get()); if (context()->AreAnalysesValid(IRContext::Analysis::kAnalysisDefUse)) context()->get_def_use_mgr()->AnalyzeInstDefUse(new_inlined_at.get()); if (insert_before != nullptr) return insert_before->InsertBefore(std::move(new_inlined_at)); return context()->module()->ext_inst_debuginfo_end()->InsertBefore( std::move(new_inlined_at)); } bool DebugInfoManager::IsVariableDebugDeclared(uint32_t variable_id) { auto dbg_decl_itr = var_id_to_dbg_decl_.find(variable_id); return dbg_decl_itr != var_id_to_dbg_decl_.end(); } bool DebugInfoManager::KillDebugDeclares(uint32_t variable_id) { bool modified = false; auto dbg_decl_itr = var_id_to_dbg_decl_.find(variable_id); if (dbg_decl_itr != var_id_to_dbg_decl_.end()) { // We intentionally copy the list of DebugDeclare instructions because // context()->KillInst(dbg_decl) will update |var_id_to_dbg_decl_|. If we // directly use |dbg_decl_itr->second|, it accesses a dangling pointer. auto copy_dbg_decls = dbg_decl_itr->second; for (auto* dbg_decl : copy_dbg_decls) { context()->KillInst(dbg_decl); modified = true; } var_id_to_dbg_decl_.erase(dbg_decl_itr); } return modified; } uint32_t DebugInfoManager::GetParentScope(uint32_t child_scope) { auto dbg_scope_itr = id_to_dbg_inst_.find(child_scope); assert(dbg_scope_itr != id_to_dbg_inst_.end()); CommonDebugInfoInstructions debug_opcode = dbg_scope_itr->second->GetCommonDebugOpcode(); uint32_t parent_scope = kNoDebugScope; switch (debug_opcode) { case CommonDebugInfoDebugFunction: parent_scope = dbg_scope_itr->second->GetSingleWordOperand( kDebugFunctionOperandParentIndex); break; case CommonDebugInfoDebugLexicalBlock: parent_scope = dbg_scope_itr->second->GetSingleWordOperand( kDebugLexicalBlockOperandParentIndex); break; case CommonDebugInfoDebugTypeComposite: parent_scope = dbg_scope_itr->second->GetSingleWordOperand( kDebugTypeCompositeOperandParentIndex); break; case CommonDebugInfoDebugCompilationUnit: // DebugCompilationUnit does not have a parent scope. break; default: assert(false && "Unreachable. A debug scope instruction must be " "DebugFunction, DebugTypeComposite, DebugLexicalBlock, " "or DebugCompilationUnit."); break; } return parent_scope; } bool DebugInfoManager::IsAncestorOfScope(uint32_t scope, uint32_t ancestor) { uint32_t ancestor_scope_itr = scope; while (ancestor_scope_itr != kNoDebugScope) { if (ancestor == ancestor_scope_itr) return true; ancestor_scope_itr = GetParentScope(ancestor_scope_itr); } return false; } bool DebugInfoManager::IsDeclareVisibleToInstr(Instruction* dbg_declare, Instruction* scope) { assert(dbg_declare != nullptr); assert(scope != nullptr); std::vector scope_ids; if (scope->opcode() == spv::Op::OpPhi) { scope_ids.push_back(scope->GetDebugScope().GetLexicalScope()); for (uint32_t i = 0; i < scope->NumInOperands(); i += 2) { auto* value = context()->get_def_use_mgr()->GetDef( scope->GetSingleWordInOperand(i)); if (value != nullptr) scope_ids.push_back(value->GetDebugScope().GetLexicalScope()); } } else { scope_ids.push_back(scope->GetDebugScope().GetLexicalScope()); } uint32_t dbg_local_var_id = dbg_declare->GetSingleWordOperand(kDebugDeclareOperandLocalVariableIndex); auto dbg_local_var_itr = id_to_dbg_inst_.find(dbg_local_var_id); assert(dbg_local_var_itr != id_to_dbg_inst_.end()); uint32_t decl_scope_id = dbg_local_var_itr->second->GetSingleWordOperand( kDebugLocalVariableOperandParentIndex); // If the scope of DebugDeclare is an ancestor scope of the instruction's // scope, the local variable is visible to the instruction. for (uint32_t scope_id : scope_ids) { if (scope_id != kNoDebugScope && IsAncestorOfScope(scope_id, decl_scope_id)) { return true; } } return false; } bool DebugInfoManager::AddDebugValueForVariable(Instruction* scope_and_line, uint32_t variable_id, uint32_t value_id, Instruction* insert_pos) { assert(scope_and_line != nullptr); auto dbg_decl_itr = var_id_to_dbg_decl_.find(variable_id); if (dbg_decl_itr == var_id_to_dbg_decl_.end()) return false; bool modified = false; for (auto* dbg_decl_or_val : dbg_decl_itr->second) { // Avoid inserting the new DebugValue between OpPhi or OpVariable // instructions. Instruction* insert_before = insert_pos->NextNode(); while (insert_before->opcode() == spv::Op::OpPhi || insert_before->opcode() == spv::Op::OpVariable) { insert_before = insert_before->NextNode(); } modified |= AddDebugValueForDecl(dbg_decl_or_val, value_id, insert_before, scope_and_line) != nullptr; } return modified; } Instruction* DebugInfoManager::AddDebugValueForDecl( Instruction* dbg_decl, uint32_t value_id, Instruction* insert_before, Instruction* scope_and_line) { if (dbg_decl == nullptr || !IsDebugDeclare(dbg_decl)) return nullptr; std::unique_ptr dbg_val(dbg_decl->Clone(context())); dbg_val->SetResultId(context()->TakeNextId()); dbg_val->SetInOperand(kExtInstInstructionInIdx, {CommonDebugInfoDebugValue}); dbg_val->SetOperand(kDebugDeclareOperandVariableIndex, {value_id}); dbg_val->SetOperand(kDebugValueOperandExpressionIndex, {GetEmptyDebugExpression()->result_id()}); dbg_val->UpdateDebugInfoFrom(scope_and_line); auto* added_dbg_val = insert_before->InsertBefore(std::move(dbg_val)); AnalyzeDebugInst(added_dbg_val); if (context()->AreAnalysesValid(IRContext::Analysis::kAnalysisDefUse)) context()->get_def_use_mgr()->AnalyzeInstDefUse(added_dbg_val); if (context()->AreAnalysesValid( IRContext::Analysis::kAnalysisInstrToBlockMapping)) { auto insert_blk = context()->get_instr_block(insert_before); context()->set_instr_block(added_dbg_val, insert_blk); } return added_dbg_val; } uint32_t DebugInfoManager::GetVulkanDebugOperation(Instruction* inst) { assert(inst->GetShader100DebugOpcode() == NonSemanticShaderDebugInfo100DebugOperation && "inst must be Vulkan DebugOperation"); return context() ->get_constant_mgr() ->GetConstantFromInst(context()->get_def_use_mgr()->GetDef( inst->GetSingleWordOperand(kDebugOperationOperandOperationIndex))) ->GetU32(); } uint32_t DebugInfoManager::GetVariableIdOfDebugValueUsedForDeclare( Instruction* inst) { if (inst->GetCommonDebugOpcode() != CommonDebugInfoDebugValue) return 0; auto* expr = GetDbgInst(inst->GetSingleWordOperand(kDebugValueOperandExpressionIndex)); if (expr == nullptr) return 0; if (expr->NumOperands() != kDebugExpressOperandOperationIndex + 1) return 0; auto* operation = GetDbgInst( expr->GetSingleWordOperand(kDebugExpressOperandOperationIndex)); if (operation == nullptr) return 0; // OpenCL.DebugInfo.100 contains a literal for the operation, Vulkan uses an // OpConstant. if (inst->IsOpenCL100DebugInstr()) { if (operation->GetSingleWordOperand(kDebugOperationOperandOperationIndex) != OpenCLDebugInfo100Deref) { return 0; } } else { uint32_t operation_const = GetVulkanDebugOperation(operation); if (operation_const != NonSemanticShaderDebugInfo100Deref) { return 0; } } uint32_t var_id = inst->GetSingleWordOperand(kDebugDeclareOperandVariableIndex); if (!context()->AreAnalysesValid(IRContext::Analysis::kAnalysisDefUse)) { assert(false && "Checking a DebugValue can be used for declare needs DefUseManager"); return 0; } auto* var = context()->get_def_use_mgr()->GetDef(var_id); if (var->opcode() == spv::Op::OpVariable && spv::StorageClass( var->GetSingleWordOperand(kOpVariableOperandStorageClassIndex)) == spv::StorageClass::Function) { return var_id; } return 0; } bool DebugInfoManager::IsDebugDeclare(Instruction* instr) { if (!instr->IsCommonDebugInstr()) return false; return instr->GetCommonDebugOpcode() == CommonDebugInfoDebugDeclare || GetVariableIdOfDebugValueUsedForDeclare(instr) != 0; } void DebugInfoManager::ReplaceAllUsesInDebugScopeWithPredicate( uint32_t before, uint32_t after, const std::function& predicate) { auto scope_id_to_users_itr = scope_id_to_users_.find(before); if (scope_id_to_users_itr != scope_id_to_users_.end()) { for (Instruction* inst : scope_id_to_users_itr->second) { if (predicate(inst)) inst->UpdateLexicalScope(after); } scope_id_to_users_[after] = scope_id_to_users_itr->second; scope_id_to_users_.erase(scope_id_to_users_itr); } auto inlinedat_id_to_users_itr = inlinedat_id_to_users_.find(before); if (inlinedat_id_to_users_itr != inlinedat_id_to_users_.end()) { for (Instruction* inst : inlinedat_id_to_users_itr->second) { if (predicate(inst)) inst->UpdateDebugInlinedAt(after); } inlinedat_id_to_users_[after] = inlinedat_id_to_users_itr->second; inlinedat_id_to_users_.erase(inlinedat_id_to_users_itr); } } void DebugInfoManager::ClearDebugScopeAndInlinedAtUses(Instruction* inst) { auto scope_id_to_users_itr = scope_id_to_users_.find(inst->result_id()); if (scope_id_to_users_itr != scope_id_to_users_.end()) { scope_id_to_users_.erase(scope_id_to_users_itr); } auto inlinedat_id_to_users_itr = inlinedat_id_to_users_.find(inst->result_id()); if (inlinedat_id_to_users_itr != inlinedat_id_to_users_.end()) { inlinedat_id_to_users_.erase(inlinedat_id_to_users_itr); } } void DebugInfoManager::AnalyzeDebugInst(Instruction* inst) { if (inst->GetDebugScope().GetLexicalScope() != kNoDebugScope) { auto& users = scope_id_to_users_[inst->GetDebugScope().GetLexicalScope()]; users.insert(inst); } if (inst->GetDebugInlinedAt() != kNoInlinedAt) { auto& users = inlinedat_id_to_users_[inst->GetDebugInlinedAt()]; users.insert(inst); } if (!inst->IsCommonDebugInstr()) return; RegisterDbgInst(inst); if (inst->GetOpenCL100DebugOpcode() == OpenCLDebugInfo100DebugFunction || inst->GetShader100DebugOpcode() == NonSemanticShaderDebugInfo100DebugFunctionDefinition) { RegisterDbgFunction(inst); } if (deref_operation_ == nullptr && inst->GetOpenCL100DebugOpcode() == OpenCLDebugInfo100DebugOperation && inst->GetSingleWordOperand(kDebugOperationOperandOperationIndex) == OpenCLDebugInfo100Deref) { deref_operation_ = inst; } if (deref_operation_ == nullptr && inst->GetShader100DebugOpcode() == NonSemanticShaderDebugInfo100DebugOperation) { uint32_t operation_const = GetVulkanDebugOperation(inst); if (operation_const == NonSemanticShaderDebugInfo100Deref) { deref_operation_ = inst; } } if (debug_info_none_inst_ == nullptr && inst->GetCommonDebugOpcode() == CommonDebugInfoDebugInfoNone) { debug_info_none_inst_ = inst; } if (empty_debug_expr_inst_ == nullptr && IsEmptyDebugExpression(inst)) { empty_debug_expr_inst_ = inst; } if (inst->GetCommonDebugOpcode() == CommonDebugInfoDebugDeclare) { uint32_t var_id = inst->GetSingleWordOperand(kDebugDeclareOperandVariableIndex); RegisterDbgDeclare(var_id, inst); } if (uint32_t var_id = GetVariableIdOfDebugValueUsedForDeclare(inst)) { RegisterDbgDeclare(var_id, inst); } } void DebugInfoManager::ConvertDebugGlobalToLocalVariable( Instruction* dbg_global_var, Instruction* local_var) { if (dbg_global_var->GetCommonDebugOpcode() != CommonDebugInfoDebugGlobalVariable) { return; } assert(local_var->opcode() == spv::Op::OpVariable || local_var->opcode() == spv::Op::OpFunctionParameter); // Convert |dbg_global_var| to DebugLocalVariable // All of the operands up to the scope operand are the same for the type // instructions. The flag operand needs to move from operand // kDebugGlobalVariableOperandFlagsIndex to // kDebugLocalVariableOperandFlagsIndex. No other operands are needed to // define the DebugLocalVariable. // Modify the opcode. dbg_global_var->SetInOperand(kExtInstInstructionInIdx, {CommonDebugInfoDebugLocalVariable}); // Move the flags operand. auto flags = dbg_global_var->GetSingleWordOperand( kDebugGlobalVariableOperandFlagsIndex); dbg_global_var->SetOperand(kDebugLocalVariableOperandFlagsIndex, {flags}); // Remove the extra operands. Starting at the end to avoid copying too much // data. for (uint32_t i = dbg_global_var->NumOperands() - 1; i > kDebugLocalVariableOperandFlagsIndex; --i) { dbg_global_var->RemoveOperand(i); } // Update the def-use manager. context()->ForgetUses(dbg_global_var); context()->AnalyzeUses(dbg_global_var); // Create a DebugDeclare std::unique_ptr new_dbg_decl(new Instruction( context(), spv::Op::OpExtInst, context()->get_type_mgr()->GetVoidTypeId(), context()->TakeNextId(), { {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {GetDbgSetImportId()}}, {spv_operand_type_t::SPV_OPERAND_TYPE_EXTENSION_INSTRUCTION_NUMBER, {static_cast(CommonDebugInfoDebugDeclare)}}, {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {dbg_global_var->result_id()}}, {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {local_var->result_id()}}, {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {GetEmptyDebugExpression()->result_id()}}, })); // Must insert after all OpVariables in block Instruction* insert_before = local_var; while (insert_before->opcode() == spv::Op::OpVariable) insert_before = insert_before->NextNode(); auto* added_dbg_decl = insert_before->InsertBefore(std::move(new_dbg_decl)); if (context()->AreAnalysesValid(IRContext::Analysis::kAnalysisDefUse)) context()->get_def_use_mgr()->AnalyzeInstDefUse(added_dbg_decl); if (context()->AreAnalysesValid( IRContext::Analysis::kAnalysisInstrToBlockMapping)) { auto insert_blk = context()->get_instr_block(local_var); context()->set_instr_block(added_dbg_decl, insert_blk); } } void DebugInfoManager::AnalyzeDebugInsts(Module& module) { deref_operation_ = nullptr; debug_info_none_inst_ = nullptr; empty_debug_expr_inst_ = nullptr; module.ForEachInst([this](Instruction* cpi) { AnalyzeDebugInst(cpi); }); // Move |empty_debug_expr_inst_| to the beginning of the debug instruction // list. if (empty_debug_expr_inst_ != nullptr && empty_debug_expr_inst_->PreviousNode() != nullptr && empty_debug_expr_inst_->PreviousNode()->IsCommonDebugInstr()) { empty_debug_expr_inst_->InsertBefore( &*context()->module()->ext_inst_debuginfo_begin()); } // Move |debug_info_none_inst_| to the beginning of the debug instruction // list. if (debug_info_none_inst_ != nullptr && debug_info_none_inst_->PreviousNode() != nullptr && debug_info_none_inst_->PreviousNode()->IsCommonDebugInstr()) { debug_info_none_inst_->InsertBefore( &*context()->module()->ext_inst_debuginfo_begin()); } } void DebugInfoManager::ClearDebugInfo(Instruction* instr) { auto scope_id_to_users_itr = scope_id_to_users_.find(instr->GetDebugScope().GetLexicalScope()); if (scope_id_to_users_itr != scope_id_to_users_.end()) { scope_id_to_users_itr->second.erase(instr); } auto inlinedat_id_to_users_itr = inlinedat_id_to_users_.find(instr->GetDebugInlinedAt()); if (inlinedat_id_to_users_itr != inlinedat_id_to_users_.end()) { inlinedat_id_to_users_itr->second.erase(instr); } if (instr == nullptr || !instr->IsCommonDebugInstr()) { return; } id_to_dbg_inst_.erase(instr->result_id()); if (instr->GetOpenCL100DebugOpcode() == OpenCLDebugInfo100DebugFunction) { auto fn_id = instr->GetSingleWordOperand(kDebugFunctionOperandFunctionIndex); fn_id_to_dbg_fn_.erase(fn_id); } if (instr->GetShader100DebugOpcode() == NonSemanticShaderDebugInfo100DebugFunctionDefinition) { auto fn_id = instr->GetSingleWordOperand( kDebugFunctionDefinitionOperandOpFunctionIndex); fn_id_to_dbg_fn_.erase(fn_id); } if (instr->GetCommonDebugOpcode() == CommonDebugInfoDebugDeclare || instr->GetCommonDebugOpcode() == CommonDebugInfoDebugValue) { auto var_or_value_id = instr->GetSingleWordOperand(kDebugDeclareOperandVariableIndex); auto dbg_decl_itr = var_id_to_dbg_decl_.find(var_or_value_id); if (dbg_decl_itr != var_id_to_dbg_decl_.end()) { dbg_decl_itr->second.erase(instr); } } if (deref_operation_ == instr) { deref_operation_ = nullptr; for (auto dbg_instr_itr = context()->module()->ext_inst_debuginfo_begin(); dbg_instr_itr != context()->module()->ext_inst_debuginfo_end(); ++dbg_instr_itr) { // OpenCL.DebugInfo.100 contains the operation as a literal operand, in // Vulkan it's referenced as an OpConstant. if (instr != &*dbg_instr_itr && dbg_instr_itr->GetOpenCL100DebugOpcode() == OpenCLDebugInfo100DebugOperation && dbg_instr_itr->GetSingleWordOperand( kDebugOperationOperandOperationIndex) == OpenCLDebugInfo100Deref) { deref_operation_ = &*dbg_instr_itr; break; } else if (instr != &*dbg_instr_itr && dbg_instr_itr->GetShader100DebugOpcode() == NonSemanticShaderDebugInfo100DebugOperation) { uint32_t operation_const = GetVulkanDebugOperation(&*dbg_instr_itr); if (operation_const == NonSemanticShaderDebugInfo100Deref) { deref_operation_ = &*dbg_instr_itr; break; } } } } if (debug_info_none_inst_ == instr) { debug_info_none_inst_ = nullptr; for (auto dbg_instr_itr = context()->module()->ext_inst_debuginfo_begin(); dbg_instr_itr != context()->module()->ext_inst_debuginfo_end(); ++dbg_instr_itr) { if (instr != &*dbg_instr_itr && dbg_instr_itr->GetCommonDebugOpcode() == CommonDebugInfoDebugInfoNone) { debug_info_none_inst_ = &*dbg_instr_itr; break; } } } if (empty_debug_expr_inst_ == instr) { empty_debug_expr_inst_ = nullptr; for (auto dbg_instr_itr = context()->module()->ext_inst_debuginfo_begin(); dbg_instr_itr != context()->module()->ext_inst_debuginfo_end(); ++dbg_instr_itr) { if (instr != &*dbg_instr_itr && IsEmptyDebugExpression(&*dbg_instr_itr)) { empty_debug_expr_inst_ = &*dbg_instr_itr; break; } } } } } // namespace analysis } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/debug_info_manager.h000066400000000000000000000300321475742701700245750ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_DEBUG_INFO_MANAGER_H_ #define SOURCE_OPT_DEBUG_INFO_MANAGER_H_ #include #include #include #include "source/opt/instruction.h" #include "source/opt/module.h" namespace spvtools { namespace opt { namespace analysis { // When an instruction of a callee function is inlined to its caller function, // we need the line and the scope information of the function call instruction // to generate DebugInlinedAt. This class keeps the data. For multiple inlining // of a single instruction, we have to create multiple DebugInlinedAt // instructions as a chain. This class keeps the information of the generated // DebugInlinedAt chains to reduce the number of chains. class DebugInlinedAtContext { public: explicit DebugInlinedAtContext(Instruction* call_inst) : call_inst_line_(call_inst->dbg_line_inst()), call_inst_scope_(call_inst->GetDebugScope()) {} const Instruction* GetLineOfCallInstruction() { return call_inst_line_; } const DebugScope& GetScopeOfCallInstruction() { return call_inst_scope_; } // Puts the DebugInlinedAt chain that is generated for the callee instruction // whose DebugInlinedAt of DebugScope is |callee_instr_inlined_at| into // |callee_inlined_at2chain_|. void SetDebugInlinedAtChain(uint32_t callee_instr_inlined_at, uint32_t chain_head_id) { callee_inlined_at2chain_[callee_instr_inlined_at] = chain_head_id; } // Gets the DebugInlinedAt chain from |callee_inlined_at2chain_|. uint32_t GetDebugInlinedAtChain(uint32_t callee_instr_inlined_at) { auto chain_itr = callee_inlined_at2chain_.find(callee_instr_inlined_at); if (chain_itr != callee_inlined_at2chain_.end()) return chain_itr->second; return kNoInlinedAt; } private: // The line information of the function call instruction that will be // replaced by the callee function. const Instruction* call_inst_line_; // The scope information of the function call instruction that will be // replaced by the callee function. const DebugScope call_inst_scope_; // Map from DebugInlinedAt ids of callee to head ids of new generated // DebugInlinedAt chain. std::unordered_map callee_inlined_at2chain_; }; // A class for analyzing, managing, and creating OpenCL.DebugInfo.100 and // NonSemantic.Shader.DebugInfo.100 extension instructions. class DebugInfoManager { public: // Constructs a debug information manager from the given |context|. DebugInfoManager(IRContext* context); DebugInfoManager(const DebugInfoManager&) = delete; DebugInfoManager(DebugInfoManager&&) = delete; DebugInfoManager& operator=(const DebugInfoManager&) = delete; DebugInfoManager& operator=(DebugInfoManager&&) = delete; friend bool operator==(const DebugInfoManager&, const DebugInfoManager&); friend bool operator!=(const DebugInfoManager& lhs, const DebugInfoManager& rhs) { return !(lhs == rhs); } // Analyzes DebugInfo instruction |dbg_inst|. void AnalyzeDebugInst(Instruction* dbg_inst); // Creates new DebugInlinedAt and returns its id. Its line operand is the // line number of |line| if |line| is not nullptr. Otherwise, its line operand // is the line number of lexical scope of |scope|. Its Scope and Inlined // operands are Scope and Inlined of |scope|. uint32_t CreateDebugInlinedAt(const Instruction* line, const DebugScope& scope); // Clones DebugExpress instruction |dbg_expr| and add Deref Operation // in the front of the Operation list of |dbg_expr|. Instruction* DerefDebugExpression(Instruction* dbg_expr); // Returns a DebugInfoNone instruction. Instruction* GetDebugInfoNone(); // Returns DebugInlinedAt whose id is |dbg_inlined_at_id|. If it does not // exist or it is not a DebugInlinedAt instruction, return nullptr. Instruction* GetDebugInlinedAt(uint32_t dbg_inlined_at_id); // Returns DebugFunction whose Function operand is |fn_id|. If it does not // exist, return nullptr. Instruction* GetDebugFunction(uint32_t fn_id) { auto dbg_fn_it = fn_id_to_dbg_fn_.find(fn_id); return dbg_fn_it == fn_id_to_dbg_fn_.end() ? nullptr : dbg_fn_it->second; } // Clones DebugInlinedAt whose id is |clone_inlined_at_id|. If // |clone_inlined_at_id| is not an id of DebugInlinedAt, returns nullptr. // If |insert_before| is given, inserts the new DebugInlinedAt before it. // Otherwise, inserts the new DebugInlinedAt into the debug instruction // section of the module. Instruction* CloneDebugInlinedAt(uint32_t clone_inlined_at_id, Instruction* insert_before = nullptr); // Returns the debug scope corresponding to an inlining instruction in the // scope |callee_instr_scope| into |inlined_at_ctx|. Generates all new // debug instructions needed to represent the scope. DebugScope BuildDebugScope(const DebugScope& callee_instr_scope, DebugInlinedAtContext* inlined_at_ctx); // Returns DebugInlinedAt corresponding to inlining an instruction, which // was inlined at |callee_inlined_at|, into |inlined_at_ctx|. Generates all // new debug instructions needed to represent the DebugInlinedAt. uint32_t BuildDebugInlinedAtChain(uint32_t callee_inlined_at, DebugInlinedAtContext* inlined_at_ctx); // Returns true if there is a debug declaration instruction whose // 'Local Variable' operand is |variable_id|. bool IsVariableDebugDeclared(uint32_t variable_id); // Kills all debug declaration instructions with Deref whose 'Local Variable' // operand is |variable_id|. Returns whether it kills an instruction or not. bool KillDebugDeclares(uint32_t variable_id); // Generates a DebugValue instruction with value |value_id| for every local // variable that is in the scope of |scope_and_line| and whose memory is // |variable_id| and inserts it after the instruction |insert_pos|. // Returns whether a DebugValue is added or not. bool AddDebugValueForVariable(Instruction* scope_and_line, uint32_t variable_id, uint32_t value_id, Instruction* insert_pos); // Creates a DebugValue for DebugDeclare |dbg_decl| and inserts it before // |insert_before|. The new DebugValue has the same line and scope as // |scope_and_line|, or no scope and line information if |scope_and_line| // is nullptr. The new DebugValue has the same operands as DebugDeclare // but it uses |value_id| for the value. Returns the created DebugValue, // or nullptr if fails to create one. Instruction* AddDebugValueForDecl(Instruction* dbg_decl, uint32_t value_id, Instruction* insert_before, Instruction* scope_and_line); // Erases |instr| from data structures of this class. void ClearDebugInfo(Instruction* instr); // Return the opcode for the Vulkan DebugOperation inst uint32_t GetVulkanDebugOperation(Instruction* inst); // Returns the id of Value operand if |inst| is DebugValue who has Deref // operation and its Value operand is a result id of OpVariable with // Function storage class. Otherwise, returns 0. uint32_t GetVariableIdOfDebugValueUsedForDeclare(Instruction* inst); // Converts DebugGlobalVariable |dbg_global_var| to a DebugLocalVariable and // creates a DebugDeclare mapping the new DebugLocalVariable to |local_var|. void ConvertDebugGlobalToLocalVariable(Instruction* dbg_global_var, Instruction* local_var); // Returns true if |instr| is a debug declaration instruction. bool IsDebugDeclare(Instruction* instr); // Replace all uses of |before| id that is an operand of a DebugScope with // |after| id if those uses (instruction) return true for |predicate|. void ReplaceAllUsesInDebugScopeWithPredicate( uint32_t before, uint32_t after, const std::function& predicate); // Removes uses of DebugScope |inst| from |scope_id_to_users_| or uses of // DebugInlinedAt |inst| from |inlinedat_id_to_users_|. void ClearDebugScopeAndInlinedAtUses(Instruction* inst); private: IRContext* context() { return context_; } // Analyzes DebugInfo instructions in the given |module| and // populates data structures in this class. void AnalyzeDebugInsts(Module& module); // Get the DebugInfo ExtInstImport Id, or 0 if no DebugInfo is available. uint32_t GetDbgSetImportId(); // Returns the debug instruction whose id is |id|. Returns |nullptr| if one // does not exists. Instruction* GetDbgInst(uint32_t id); // Returns a DebugOperation instruction with OpCode Deref. Instruction* GetDebugOperationWithDeref(); // Registers the debug instruction |inst| into |id_to_dbg_inst_| using id of // |inst| as a key. void RegisterDbgInst(Instruction* inst); // Register the DebugFunction instruction |inst|. The function referenced // in |inst| must not already be registered. void RegisterDbgFunction(Instruction* inst); // Register the DebugDeclare or DebugValue with Deref operation // |dbg_declare| into |var_id_to_dbg_decl_| using OpVariable id // |var_id| as a key. void RegisterDbgDeclare(uint32_t var_id, Instruction* dbg_declare); // Returns a DebugExpression instruction without Operation operands. Instruction* GetEmptyDebugExpression(); // Returns true if a scope |ancestor| is |scope| or an ancestor scope // of |scope|. bool IsAncestorOfScope(uint32_t scope, uint32_t ancestor); // Returns true if the declaration of a local variable |dbg_declare| // is visible in the scope of an instruction |instr_scope_id|. bool IsDeclareVisibleToInstr(Instruction* dbg_declare, Instruction* scope); // Returns the parent scope of the scope |child_scope|. uint32_t GetParentScope(uint32_t child_scope); IRContext* context_; // Mapping from ids of DebugInfo extension instructions. // to their Instruction instances. std::unordered_map id_to_dbg_inst_; // Mapping from function's ids to DebugFunction instructions whose // operand is the function. std::unordered_map fn_id_to_dbg_fn_; // Orders Instruction* for use in associative containers (i.e. less than // ordering). Unique Id is used. typedef Instruction* InstPtr; struct InstPtrLess { bool operator()(const InstPtr& lhs, const InstPtr& rhs) const { return lhs->unique_id() < rhs->unique_id(); } }; // Mapping from variable or value ids to DebugDeclare or DebugValue // instructions whose operand is the variable or value. std::unordered_map> var_id_to_dbg_decl_; // Mapping from DebugScope ids to users. std::unordered_map> scope_id_to_users_; // Mapping from DebugInlinedAt ids to users. std::unordered_map> inlinedat_id_to_users_; // DebugOperation whose OpCode is OpenCLDebugInfo100Deref. Instruction* deref_operation_; // DebugInfoNone instruction. We need only a single DebugInfoNone. // To reuse the existing one, we keep it using this member variable. Instruction* debug_info_none_inst_; // DebugExpression instruction without Operation operands. We need only // a single DebugExpression without Operation operands. To reuse the // existing one, we keep it using this member variable. Instruction* empty_debug_expr_inst_; }; } // namespace analysis } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_DEBUG_INFO_MANAGER_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/decoration_manager.cpp000066400000000000000000000603541475742701700251700ustar00rootroot00000000000000// Copyright (c) 2017 Pierre Moreau // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/decoration_manager.h" #include #include #include #include #include #include "source/opt/ir_context.h" namespace spvtools { namespace opt { namespace analysis { namespace { using InstructionVector = std::vector; using DecorationSet = std::set; // Returns true if |a| is a subet of |b|. bool IsSubset(const DecorationSet& a, const DecorationSet& b) { auto it1 = a.begin(); auto it2 = b.begin(); while (it1 != a.end()) { if (it2 == b.end() || *it1 < *it2) { // |*it1| is in |a|, but not in |b|. return false; } if (*it1 == *it2) { // Found the element move to the next one. it1++; it2++; } else /* *it1 > *it2 */ { // Did not find |*it1| yet, check the next element in |b|. it2++; } } return true; } } // namespace bool DecorationManager::RemoveDecorationsFrom( uint32_t id, std::function pred) { bool was_modified = false; const auto ids_iter = id_to_decoration_insts_.find(id); if (ids_iter == id_to_decoration_insts_.end()) { return was_modified; } TargetData& decorations_info = ids_iter->second; auto context = module_->context(); std::vector insts_to_kill; const bool is_group = !decorations_info.decorate_insts.empty(); // Schedule all direct decorations for removal if instructed as such by // |pred|. for (Instruction* inst : decorations_info.direct_decorations) if (pred(*inst)) insts_to_kill.push_back(inst); // For all groups being directly applied to |id|, remove |id| (and the // literal if |inst| is an OpGroupMemberDecorate) from the instruction // applying the group. std::unordered_set indirect_decorations_to_remove; for (Instruction* inst : decorations_info.indirect_decorations) { assert(inst->opcode() == spv::Op::OpGroupDecorate || inst->opcode() == spv::Op::OpGroupMemberDecorate); std::vector group_decorations_to_keep; const uint32_t group_id = inst->GetSingleWordInOperand(0u); const auto group_iter = id_to_decoration_insts_.find(group_id); assert(group_iter != id_to_decoration_insts_.end() && "Unknown decoration group"); const auto& group_decorations = group_iter->second.direct_decorations; for (Instruction* decoration : group_decorations) { if (!pred(*decoration)) group_decorations_to_keep.push_back(decoration); } // If all decorations should be kept, then we can keep |id| part of the // group. However, if the group itself has no decorations, we should remove // the id from the group. This is needed to make |KillNameAndDecorate| work // correctly when a decoration group has no decorations. if (group_decorations_to_keep.size() == group_decorations.size() && group_decorations.size() != 0) { continue; } // Otherwise, remove |id| from the targets of |group_id| const uint32_t stride = inst->opcode() == spv::Op::OpGroupDecorate ? 1u : 2u; for (uint32_t i = 1u; i < inst->NumInOperands();) { if (inst->GetSingleWordInOperand(i) != id) { i += stride; continue; } const uint32_t last_operand_index = inst->NumInOperands() - stride; if (i < last_operand_index) inst->GetInOperand(i) = inst->GetInOperand(last_operand_index); // Remove the associated literal, if it exists. if (stride == 2u) { if (i < last_operand_index) inst->GetInOperand(i + 1u) = inst->GetInOperand(last_operand_index + 1u); inst->RemoveInOperand(last_operand_index + 1u); } inst->RemoveInOperand(last_operand_index); was_modified = true; } // If the instruction has no targets left, remove the instruction // altogether. if (inst->NumInOperands() == 1u) { indirect_decorations_to_remove.emplace(inst); insts_to_kill.push_back(inst); } else if (was_modified) { context->ForgetUses(inst); indirect_decorations_to_remove.emplace(inst); context->AnalyzeUses(inst); } // If only some of the decorations should be kept, clone them and apply // them directly to |id|. if (!group_decorations_to_keep.empty()) { for (Instruction* decoration : group_decorations_to_keep) { // simply clone decoration and change |group_id| to |id| std::unique_ptr new_inst( decoration->Clone(module_->context())); new_inst->SetInOperand(0, {id}); module_->AddAnnotationInst(std::move(new_inst)); auto decoration_iter = --module_->annotation_end(); context->AnalyzeUses(&*decoration_iter); } } } auto& indirect_decorations = decorations_info.indirect_decorations; indirect_decorations.erase( std::remove_if( indirect_decorations.begin(), indirect_decorations.end(), [&indirect_decorations_to_remove](const Instruction* inst) { return indirect_decorations_to_remove.count(inst); }), indirect_decorations.end()); was_modified |= !insts_to_kill.empty(); for (Instruction* inst : insts_to_kill) context->KillInst(inst); insts_to_kill.clear(); // Schedule all instructions applying the group for removal if this group no // longer applies decorations, either directly or indirectly. if (is_group && decorations_info.direct_decorations.empty() && decorations_info.indirect_decorations.empty()) { for (Instruction* inst : decorations_info.decorate_insts) insts_to_kill.push_back(inst); } was_modified |= !insts_to_kill.empty(); for (Instruction* inst : insts_to_kill) context->KillInst(inst); if (decorations_info.direct_decorations.empty() && decorations_info.indirect_decorations.empty() && decorations_info.decorate_insts.empty()) { id_to_decoration_insts_.erase(ids_iter); } return was_modified; } std::vector DecorationManager::GetDecorationsFor( uint32_t id, bool include_linkage) { return InternalGetDecorationsFor(id, include_linkage); } std::vector DecorationManager::GetDecorationsFor( uint32_t id, bool include_linkage) const { return const_cast(this) ->InternalGetDecorationsFor(id, include_linkage); } bool DecorationManager::HaveTheSameDecorations(uint32_t id1, uint32_t id2) const { const InstructionVector decorations_for1 = GetDecorationsFor(id1, false); const InstructionVector decorations_for2 = GetDecorationsFor(id2, false); // This function splits the decoration instructions into different sets, // based on their opcode; only OpDecorate, OpDecorateId, // OpDecorateStringGOOGLE, and OpMemberDecorate are considered, the other // opcodes are ignored. const auto fillDecorationSets = [](const InstructionVector& decoration_list, DecorationSet* decorate_set, DecorationSet* decorate_id_set, DecorationSet* decorate_string_set, DecorationSet* member_decorate_set) { for (const Instruction* inst : decoration_list) { std::u32string decoration_payload; // Ignore the opcode and the target as we do not want them to be // compared. for (uint32_t i = 1u; i < inst->NumInOperands(); ++i) { for (uint32_t word : inst->GetInOperand(i).words) { decoration_payload.push_back(word); } } switch (inst->opcode()) { case spv::Op::OpDecorate: decorate_set->emplace(std::move(decoration_payload)); break; case spv::Op::OpMemberDecorate: member_decorate_set->emplace(std::move(decoration_payload)); break; case spv::Op::OpDecorateId: decorate_id_set->emplace(std::move(decoration_payload)); break; case spv::Op::OpDecorateStringGOOGLE: decorate_string_set->emplace(std::move(decoration_payload)); break; default: break; } } }; DecorationSet decorate_set_for1; DecorationSet decorate_id_set_for1; DecorationSet decorate_string_set_for1; DecorationSet member_decorate_set_for1; fillDecorationSets(decorations_for1, &decorate_set_for1, &decorate_id_set_for1, &decorate_string_set_for1, &member_decorate_set_for1); DecorationSet decorate_set_for2; DecorationSet decorate_id_set_for2; DecorationSet decorate_string_set_for2; DecorationSet member_decorate_set_for2; fillDecorationSets(decorations_for2, &decorate_set_for2, &decorate_id_set_for2, &decorate_string_set_for2, &member_decorate_set_for2); const bool result = decorate_set_for1 == decorate_set_for2 && decorate_id_set_for1 == decorate_id_set_for2 && member_decorate_set_for1 == member_decorate_set_for2 && // Compare string sets last in case the strings are long. decorate_string_set_for1 == decorate_string_set_for2; return result; } bool DecorationManager::HaveSubsetOfDecorations(uint32_t id1, uint32_t id2) const { const InstructionVector decorations_for1 = GetDecorationsFor(id1, false); const InstructionVector decorations_for2 = GetDecorationsFor(id2, false); // This function splits the decoration instructions into different sets, // based on their opcode; only OpDecorate, OpDecorateId, // OpDecorateStringGOOGLE, and OpMemberDecorate are considered, the other // opcodes are ignored. const auto fillDecorationSets = [](const InstructionVector& decoration_list, DecorationSet* decorate_set, DecorationSet* decorate_id_set, DecorationSet* decorate_string_set, DecorationSet* member_decorate_set) { for (const Instruction* inst : decoration_list) { std::u32string decoration_payload; // Ignore the opcode and the target as we do not want them to be // compared. for (uint32_t i = 1u; i < inst->NumInOperands(); ++i) { for (uint32_t word : inst->GetInOperand(i).words) { decoration_payload.push_back(word); } } switch (inst->opcode()) { case spv::Op::OpDecorate: decorate_set->emplace(std::move(decoration_payload)); break; case spv::Op::OpMemberDecorate: member_decorate_set->emplace(std::move(decoration_payload)); break; case spv::Op::OpDecorateId: decorate_id_set->emplace(std::move(decoration_payload)); break; case spv::Op::OpDecorateStringGOOGLE: decorate_string_set->emplace(std::move(decoration_payload)); break; default: break; } } }; DecorationSet decorate_set_for1; DecorationSet decorate_id_set_for1; DecorationSet decorate_string_set_for1; DecorationSet member_decorate_set_for1; fillDecorationSets(decorations_for1, &decorate_set_for1, &decorate_id_set_for1, &decorate_string_set_for1, &member_decorate_set_for1); DecorationSet decorate_set_for2; DecorationSet decorate_id_set_for2; DecorationSet decorate_string_set_for2; DecorationSet member_decorate_set_for2; fillDecorationSets(decorations_for2, &decorate_set_for2, &decorate_id_set_for2, &decorate_string_set_for2, &member_decorate_set_for2); const bool result = IsSubset(decorate_set_for1, decorate_set_for2) && IsSubset(decorate_id_set_for1, decorate_id_set_for2) && IsSubset(member_decorate_set_for1, member_decorate_set_for2) && // Compare string sets last in case the strings are long. IsSubset(decorate_string_set_for1, decorate_string_set_for2); return result; } // TODO(pierremoreau): If OpDecorateId is referencing an OpConstant, one could // check that the constants are the same rather than just // looking at the constant ID. bool DecorationManager::AreDecorationsTheSame(const Instruction* inst1, const Instruction* inst2, bool ignore_target) const { switch (inst1->opcode()) { case spv::Op::OpDecorate: case spv::Op::OpMemberDecorate: case spv::Op::OpDecorateId: case spv::Op::OpDecorateStringGOOGLE: break; default: return false; } if (inst1->opcode() != inst2->opcode() || inst1->NumInOperands() != inst2->NumInOperands()) return false; for (uint32_t i = ignore_target ? 1u : 0u; i < inst1->NumInOperands(); ++i) if (inst1->GetInOperand(i) != inst2->GetInOperand(i)) return false; return true; } void DecorationManager::AnalyzeDecorations() { if (!module_) return; // For each group and instruction, collect all their decoration instructions. for (Instruction& inst : module_->annotations()) { AddDecoration(&inst); } } void DecorationManager::AddDecoration(Instruction* inst) { switch (inst->opcode()) { case spv::Op::OpDecorate: case spv::Op::OpDecorateId: case spv::Op::OpDecorateStringGOOGLE: case spv::Op::OpMemberDecorate: { const auto target_id = inst->GetSingleWordInOperand(0u); id_to_decoration_insts_[target_id].direct_decorations.push_back(inst); break; } case spv::Op::OpGroupDecorate: case spv::Op::OpGroupMemberDecorate: { const uint32_t start = inst->opcode() == spv::Op::OpGroupDecorate ? 1u : 2u; const uint32_t stride = start; for (uint32_t i = start; i < inst->NumInOperands(); i += stride) { const auto target_id = inst->GetSingleWordInOperand(i); TargetData& target_data = id_to_decoration_insts_[target_id]; target_data.indirect_decorations.push_back(inst); } const auto target_id = inst->GetSingleWordInOperand(0u); id_to_decoration_insts_[target_id].decorate_insts.push_back(inst); break; } default: break; } } void DecorationManager::AddDecoration(spv::Op opcode, std::vector opnds) { IRContext* ctx = module_->context(); std::unique_ptr newDecoOp( new Instruction(ctx, opcode, 0, 0, opnds)); ctx->AddAnnotationInst(std::move(newDecoOp)); } void DecorationManager::AddDecoration(uint32_t inst_id, uint32_t decoration) { AddDecoration( spv::Op::OpDecorate, {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {inst_id}}, {spv_operand_type_t::SPV_OPERAND_TYPE_LITERAL_INTEGER, {decoration}}}); } void DecorationManager::AddDecorationVal(uint32_t inst_id, uint32_t decoration, uint32_t decoration_value) { AddDecoration( spv::Op::OpDecorate, {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {inst_id}}, {spv_operand_type_t::SPV_OPERAND_TYPE_LITERAL_INTEGER, {decoration}}, {spv_operand_type_t::SPV_OPERAND_TYPE_LITERAL_INTEGER, {decoration_value}}}); } void DecorationManager::AddMemberDecoration(uint32_t inst_id, uint32_t member, uint32_t decoration, uint32_t decoration_value) { AddDecoration( spv::Op::OpMemberDecorate, {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {inst_id}}, {spv_operand_type_t::SPV_OPERAND_TYPE_LITERAL_INTEGER, {member}}, {spv_operand_type_t::SPV_OPERAND_TYPE_LITERAL_INTEGER, {decoration}}, {spv_operand_type_t::SPV_OPERAND_TYPE_LITERAL_INTEGER, {decoration_value}}}); } template std::vector DecorationManager::InternalGetDecorationsFor( uint32_t id, bool include_linkage) { std::vector decorations; const auto ids_iter = id_to_decoration_insts_.find(id); // |id| has no decorations if (ids_iter == id_to_decoration_insts_.end()) return decorations; const TargetData& target_data = ids_iter->second; const auto process_direct_decorations = [include_linkage, &decorations](const std::vector& direct_decorations) { for (Instruction* inst : direct_decorations) { const bool is_linkage = inst->opcode() == spv::Op::OpDecorate && spv::Decoration(inst->GetSingleWordInOperand(1u)) == spv::Decoration::LinkageAttributes; if (include_linkage || !is_linkage) decorations.push_back(inst); } }; // Process |id|'s decorations. process_direct_decorations(ids_iter->second.direct_decorations); // Process the decorations of all groups applied to |id|. for (const Instruction* inst : target_data.indirect_decorations) { const uint32_t group_id = inst->GetSingleWordInOperand(0u); const auto group_iter = id_to_decoration_insts_.find(group_id); assert(group_iter != id_to_decoration_insts_.end() && "Unknown group ID"); process_direct_decorations(group_iter->second.direct_decorations); } return decorations; } bool DecorationManager::WhileEachDecoration( uint32_t id, uint32_t decoration, std::function f) const { for (const Instruction* inst : GetDecorationsFor(id, true)) { switch (inst->opcode()) { case spv::Op::OpMemberDecorate: if (inst->GetSingleWordInOperand(2) == decoration) { if (!f(*inst)) return false; } break; case spv::Op::OpDecorate: case spv::Op::OpDecorateId: case spv::Op::OpDecorateStringGOOGLE: if (inst->GetSingleWordInOperand(1) == decoration) { if (!f(*inst)) return false; } break; default: assert(false && "Unexpected decoration instruction"); } } return true; } void DecorationManager::ForEachDecoration( uint32_t id, uint32_t decoration, std::function f) const { WhileEachDecoration(id, decoration, [&f](const Instruction& inst) { f(inst); return true; }); } bool DecorationManager::HasDecoration(uint32_t id, spv::Decoration decoration) const { return HasDecoration(id, static_cast(decoration)); } bool DecorationManager::HasDecoration(uint32_t id, uint32_t decoration) const { bool has_decoration = false; ForEachDecoration(id, decoration, [&has_decoration](const Instruction&) { has_decoration = true; }); return has_decoration; } bool DecorationManager::FindDecoration( uint32_t id, uint32_t decoration, std::function f) { return !WhileEachDecoration( id, decoration, [&f](const Instruction& inst) { return !f(inst); }); } void DecorationManager::CloneDecorations(uint32_t from, uint32_t to) { const auto decoration_list = id_to_decoration_insts_.find(from); if (decoration_list == id_to_decoration_insts_.end()) return; auto context = module_->context(); for (Instruction* inst : decoration_list->second.direct_decorations) { // simply clone decoration and change |target-id| to |to| std::unique_ptr new_inst(inst->Clone(module_->context())); new_inst->SetInOperand(0, {to}); module_->AddAnnotationInst(std::move(new_inst)); auto decoration_iter = --module_->annotation_end(); context->AnalyzeUses(&*decoration_iter); } // We need to copy the list of instructions as ForgetUses and AnalyzeUses are // going to modify it. std::vector indirect_decorations = decoration_list->second.indirect_decorations; for (Instruction* inst : indirect_decorations) { switch (inst->opcode()) { case spv::Op::OpGroupDecorate: context->ForgetUses(inst); // add |to| to list of decorated id's inst->AddOperand( Operand(spv_operand_type_t::SPV_OPERAND_TYPE_ID, {to})); context->AnalyzeUses(inst); break; case spv::Op::OpGroupMemberDecorate: { context->ForgetUses(inst); // for each (id == from), add (to, literal) as operands const uint32_t num_operands = inst->NumOperands(); for (uint32_t i = 1; i < num_operands; i += 2) { Operand op = inst->GetOperand(i); if (op.words[0] == from) { // add new pair of operands: (to, literal) inst->AddOperand( Operand(spv_operand_type_t::SPV_OPERAND_TYPE_ID, {to})); op = inst->GetOperand(i + 1); inst->AddOperand(std::move(op)); } } context->AnalyzeUses(inst); break; } default: assert(false && "Unexpected decoration instruction"); } } } void DecorationManager::CloneDecorations( uint32_t from, uint32_t to, const std::vector& decorations_to_copy) { const auto decoration_list = id_to_decoration_insts_.find(from); if (decoration_list == id_to_decoration_insts_.end()) return; auto context = module_->context(); for (Instruction* inst : decoration_list->second.direct_decorations) { if (std::find(decorations_to_copy.begin(), decorations_to_copy.end(), spv::Decoration(inst->GetSingleWordInOperand(1))) == decorations_to_copy.end()) { continue; } // Clone decoration and change |target-id| to |to|. std::unique_ptr new_inst(inst->Clone(module_->context())); new_inst->SetInOperand(0, {to}); module_->AddAnnotationInst(std::move(new_inst)); auto decoration_iter = --module_->annotation_end(); context->AnalyzeUses(&*decoration_iter); } // We need to copy the list of instructions as ForgetUses and AnalyzeUses are // going to modify it. std::vector indirect_decorations = decoration_list->second.indirect_decorations; for (Instruction* inst : indirect_decorations) { switch (inst->opcode()) { case spv::Op::OpGroupDecorate: CloneDecorations(inst->GetSingleWordInOperand(0), to, decorations_to_copy); break; case spv::Op::OpGroupMemberDecorate: { assert(false && "The source id is not suppose to be a type."); break; } default: assert(false && "Unexpected decoration instruction"); } } } void DecorationManager::RemoveDecoration(Instruction* inst) { const auto remove_from_container = [inst](std::vector& v) { v.erase(std::remove(v.begin(), v.end(), inst), v.end()); }; switch (inst->opcode()) { case spv::Op::OpDecorate: case spv::Op::OpDecorateId: case spv::Op::OpDecorateStringGOOGLE: case spv::Op::OpMemberDecorate: { const auto target_id = inst->GetSingleWordInOperand(0u); auto const iter = id_to_decoration_insts_.find(target_id); if (iter == id_to_decoration_insts_.end()) return; remove_from_container(iter->second.direct_decorations); } break; case spv::Op::OpGroupDecorate: case spv::Op::OpGroupMemberDecorate: { const uint32_t stride = inst->opcode() == spv::Op::OpGroupDecorate ? 1u : 2u; for (uint32_t i = 1u; i < inst->NumInOperands(); i += stride) { const auto target_id = inst->GetSingleWordInOperand(i); auto const iter = id_to_decoration_insts_.find(target_id); if (iter == id_to_decoration_insts_.end()) continue; remove_from_container(iter->second.indirect_decorations); } const auto group_id = inst->GetSingleWordInOperand(0u); auto const iter = id_to_decoration_insts_.find(group_id); if (iter == id_to_decoration_insts_.end()) return; remove_from_container(iter->second.decorate_insts); } break; default: break; } } bool operator==(const DecorationManager& lhs, const DecorationManager& rhs) { return lhs.id_to_decoration_insts_ == rhs.id_to_decoration_insts_; } } // namespace analysis } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/decoration_manager.h000066400000000000000000000225441475742701700246340ustar00rootroot00000000000000// Copyright (c) 2017 Pierre Moreau // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_DECORATION_MANAGER_H_ #define SOURCE_OPT_DECORATION_MANAGER_H_ #include #include #include #include #include "source/opt/instruction.h" #include "source/opt/module.h" namespace spvtools { namespace opt { namespace analysis { // A class for analyzing and managing decorations in an Module. class DecorationManager { public: // Constructs a decoration manager from the given |module| explicit DecorationManager(Module* module) : module_(module) { AnalyzeDecorations(); } DecorationManager() = delete; // Removes all decorations (direct and through groups) where |pred| is // true and that apply to |id| so that they no longer apply to |id|. Returns // true if something changed. // // If |id| is part of a group, it will be removed from the group if it // does not use all of the group's decorations, or, if there are no // decorations that apply to the group. // // If decoration groups become empty, the |OpGroupDecorate| and // |OpGroupMemberDecorate| instructions will be killed. // // Decoration instructions that apply directly to |id| will be killed. // // If |id| is a decoration group and all of the group's decorations are // removed, then the |OpGroupDecorate| and // |OpGroupMemberDecorate| for the group will be killed, but not the defining // |OpDecorationGroup| instruction. bool RemoveDecorationsFrom( uint32_t id, std::function pred = [](const Instruction&) { return true; }); // Removes all decorations from the result id of |inst|. // // NOTE: This is only meant to be called from ir_context, as only metadata // will be removed, and no actual instruction. void RemoveDecoration(Instruction* inst); // Returns a vector of all decorations affecting |id|. If a group is applied // to |id|, the decorations of that group are returned rather than the group // decoration instruction. If |include_linkage| is not set, linkage // decorations won't be returned. std::vector GetDecorationsFor(uint32_t id, bool include_linkage); std::vector GetDecorationsFor(uint32_t id, bool include_linkage) const; // Returns whether two IDs have the same decorations. Two // spv::Op::OpGroupDecorate instructions that apply the same decorations but // to different IDs, still count as being the same. bool HaveTheSameDecorations(uint32_t id1, uint32_t id2) const; // Returns whether two IDs have the same decorations. Two // spv::Op::OpGroupDecorate instructions that apply the same decorations but // to different IDs, still count as being the same. bool HaveSubsetOfDecorations(uint32_t id1, uint32_t id2) const; // Returns whether the two decorations instructions are the same and are // applying the same decorations; unless |ignore_target| is false, the targets // to which they are applied to does not matter, except for the member part. // // This is only valid for OpDecorate, OpMemberDecorate and OpDecorateId; it // will return false for other opcodes. bool AreDecorationsTheSame(const Instruction* inst1, const Instruction* inst2, bool ignore_target) const; // Returns whether a decoration instruction for |id| with decoration // |decoration| exists or not. bool HasDecoration(uint32_t id, uint32_t decoration) const; bool HasDecoration(uint32_t id, spv::Decoration decoration) const; // |f| is run on each decoration instruction for |id| with decoration // |decoration|. Processed are all decorations which target |id| either // directly or indirectly by Decoration Groups. void ForEachDecoration(uint32_t id, uint32_t decoration, std::function f) const; // |f| is run on each decoration instruction for |id| with decoration // |decoration|. Processes all decoration which target |id| either directly or // indirectly through decoration groups. If |f| returns false, iteration is // terminated and this function returns false. bool WhileEachDecoration(uint32_t id, uint32_t decoration, std::function f) const; // |f| is run on each decoration instruction for |id| with decoration // |decoration|. Processes all decoration which target |id| either directly or // indirectly through decoration groups. If |f| returns true, iteration is // terminated and this function returns true. Otherwise returns false. bool FindDecoration(uint32_t id, uint32_t decoration, std::function f); // Clone all decorations from one id |from|. // The cloned decorations are assigned to the given id |to| and are // added to the module. The purpose is to decorate cloned instructions. // This function does not check if the id |to| is already decorated. void CloneDecorations(uint32_t from, uint32_t to); // Same as above, but only clone the decoration if the decoration operand is // in |decorations_to_copy|. This function has the extra restriction that // |from| and |to| must not be an object, not a type. void CloneDecorations( uint32_t from, uint32_t to, const std::vector& decorations_to_copy); // Informs the decoration manager of a new decoration that it needs to track. void AddDecoration(Instruction* inst); // Add decoration with |opcode| and operands |opnds|. void AddDecoration(spv::Op opcode, const std::vector opnds); // Add |decoration| of |inst_id| to module. void AddDecoration(uint32_t inst_id, uint32_t decoration); // Add |decoration, decoration_value| of |inst_id| to module. void AddDecorationVal(uint32_t inst_id, uint32_t decoration, uint32_t decoration_value); // Add |decoration, decoration_value| of |inst_id, member| to module. void AddMemberDecoration(uint32_t inst_id, uint32_t member, uint32_t decoration, uint32_t decoration_value); friend bool operator==(const DecorationManager&, const DecorationManager&); friend bool operator!=(const DecorationManager& lhs, const DecorationManager& rhs) { return !(lhs == rhs); } private: // Analyzes the defs and uses in the given |module| and populates data // structures in this class. Does nothing if |module| is nullptr. void AnalyzeDecorations(); template std::vector InternalGetDecorationsFor(uint32_t id, bool include_linkage); // Tracks decoration information of an ID. struct TargetData { std::vector direct_decorations; // All decorate // instructions applied // to the tracked ID. std::vector indirect_decorations; // All instructions // applying a group to // the tracked ID. std::vector decorate_insts; // All decorate instructions // applying the decorations // of the tracked ID to // targets. // It is empty if the // tracked ID is not a // group. }; friend bool operator==(const TargetData& lhs, const TargetData& rhs) { if (!std::is_permutation(lhs.direct_decorations.begin(), lhs.direct_decorations.end(), rhs.direct_decorations.begin())) { return false; } if (!std::is_permutation(lhs.indirect_decorations.begin(), lhs.indirect_decorations.end(), rhs.indirect_decorations.begin())) { return false; } if (!std::is_permutation(lhs.decorate_insts.begin(), lhs.decorate_insts.end(), rhs.decorate_insts.begin())) { return false; } return true; } // Mapping from ids to the instructions applying a decoration to those ids. // In other words, for each id you get all decoration instructions // referencing that id, be it directly (spv::Op::OpDecorate, // spv::Op::OpMemberDecorate and spv::Op::OpDecorateId), or indirectly // (spv::Op::OpGroupDecorate, spv::Op::OpMemberGroupDecorate). std::unordered_map id_to_decoration_insts_; // The enclosing module. Module* module_; }; } // namespace analysis } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_DECORATION_MANAGER_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/def_use_manager.cpp000066400000000000000000000227631475742701700244550ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/def_use_manager.h" namespace spvtools { namespace opt { namespace analysis { void DefUseManager::AnalyzeInstDef(Instruction* inst) { const uint32_t def_id = inst->result_id(); if (def_id != 0) { auto iter = id_to_def_.find(def_id); if (iter != id_to_def_.end()) { // Clear the original instruction that defining the same result id of the // new instruction. ClearInst(iter->second); } id_to_def_[def_id] = inst; } else { ClearInst(inst); } } void DefUseManager::AnalyzeInstUse(Instruction* inst) { // Create entry for the given instruction. Note that the instruction may // not have any in-operands. In such cases, we still need a entry for those // instructions so this manager knows it has seen the instruction later. auto* used_ids = &inst_to_used_ids_[inst]; if (used_ids->size()) { EraseUseRecordsOfOperandIds(inst); used_ids = &inst_to_used_ids_[inst]; } used_ids->clear(); // It might have existed before. for (uint32_t i = 0; i < inst->NumOperands(); ++i) { switch (inst->GetOperand(i).type) { // For any id type but result id type case SPV_OPERAND_TYPE_ID: case SPV_OPERAND_TYPE_TYPE_ID: case SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID: case SPV_OPERAND_TYPE_SCOPE_ID: { uint32_t use_id = inst->GetSingleWordOperand(i); Instruction* def = GetDef(use_id); assert(def && "Definition is not registered."); id_to_users_.insert(UserEntry{def, inst}); used_ids->push_back(use_id); } break; default: break; } } } void DefUseManager::AnalyzeInstDefUse(Instruction* inst) { AnalyzeInstDef(inst); AnalyzeInstUse(inst); // Analyze lines last otherwise they will be cleared when inst is // cleared by preceding two calls for (auto& l_inst : inst->dbg_line_insts()) AnalyzeInstDefUse(&l_inst); } void DefUseManager::UpdateDefUse(Instruction* inst) { const uint32_t def_id = inst->result_id(); if (def_id != 0) { auto iter = id_to_def_.find(def_id); if (iter == id_to_def_.end()) { AnalyzeInstDef(inst); } } AnalyzeInstUse(inst); } Instruction* DefUseManager::GetDef(uint32_t id) { auto iter = id_to_def_.find(id); if (iter == id_to_def_.end()) return nullptr; return iter->second; } const Instruction* DefUseManager::GetDef(uint32_t id) const { const auto iter = id_to_def_.find(id); if (iter == id_to_def_.end()) return nullptr; return iter->second; } DefUseManager::IdToUsersMap::const_iterator DefUseManager::UsersBegin( const Instruction* def) const { return id_to_users_.lower_bound( UserEntry{const_cast(def), nullptr}); } bool DefUseManager::UsersNotEnd(const IdToUsersMap::const_iterator& iter, const IdToUsersMap::const_iterator& cached_end, const Instruction* inst) const { return (iter != cached_end && iter->def == inst); } bool DefUseManager::UsersNotEnd(const IdToUsersMap::const_iterator& iter, const Instruction* inst) const { return UsersNotEnd(iter, id_to_users_.end(), inst); } bool DefUseManager::WhileEachUser( const Instruction* def, const std::function& f) const { // Ensure that |def| has been registered. assert(def && (!def->HasResultId() || def == GetDef(def->result_id())) && "Definition is not registered."); if (!def->HasResultId()) return true; auto end = id_to_users_.end(); for (auto iter = UsersBegin(def); UsersNotEnd(iter, end, def); ++iter) { if (!f(iter->user)) return false; } return true; } bool DefUseManager::WhileEachUser( uint32_t id, const std::function& f) const { return WhileEachUser(GetDef(id), f); } void DefUseManager::ForEachUser( const Instruction* def, const std::function& f) const { WhileEachUser(def, [&f](Instruction* user) { f(user); return true; }); } void DefUseManager::ForEachUser( uint32_t id, const std::function& f) const { ForEachUser(GetDef(id), f); } bool DefUseManager::WhileEachUse( const Instruction* def, const std::function& f) const { // Ensure that |def| has been registered. assert(def && (!def->HasResultId() || def == GetDef(def->result_id())) && "Definition is not registered."); if (!def->HasResultId()) return true; auto end = id_to_users_.end(); for (auto iter = UsersBegin(def); UsersNotEnd(iter, end, def); ++iter) { Instruction* user = iter->user; for (uint32_t idx = 0; idx != user->NumOperands(); ++idx) { const Operand& op = user->GetOperand(idx); if (op.type != SPV_OPERAND_TYPE_RESULT_ID && spvIsIdType(op.type)) { if (def->result_id() == op.words[0]) { if (!f(user, idx)) return false; } } } } return true; } bool DefUseManager::WhileEachUse( uint32_t id, const std::function& f) const { return WhileEachUse(GetDef(id), f); } void DefUseManager::ForEachUse( const Instruction* def, const std::function& f) const { WhileEachUse(def, [&f](Instruction* user, uint32_t index) { f(user, index); return true; }); } void DefUseManager::ForEachUse( uint32_t id, const std::function& f) const { ForEachUse(GetDef(id), f); } uint32_t DefUseManager::NumUsers(const Instruction* def) const { uint32_t count = 0; ForEachUser(def, [&count](Instruction*) { ++count; }); return count; } uint32_t DefUseManager::NumUsers(uint32_t id) const { return NumUsers(GetDef(id)); } uint32_t DefUseManager::NumUses(const Instruction* def) const { uint32_t count = 0; ForEachUse(def, [&count](Instruction*, uint32_t) { ++count; }); return count; } uint32_t DefUseManager::NumUses(uint32_t id) const { return NumUses(GetDef(id)); } std::vector DefUseManager::GetAnnotations(uint32_t id) const { std::vector annos; const Instruction* def = GetDef(id); if (!def) return annos; ForEachUser(def, [&annos](Instruction* user) { if (IsAnnotationInst(user->opcode())) { annos.push_back(user); } }); return annos; } void DefUseManager::AnalyzeDefUse(Module* module) { if (!module) return; // Analyze all the defs before any uses to catch forward references. module->ForEachInst( std::bind(&DefUseManager::AnalyzeInstDef, this, std::placeholders::_1), true); module->ForEachInst( std::bind(&DefUseManager::AnalyzeInstUse, this, std::placeholders::_1), true); } void DefUseManager::ClearInst(Instruction* inst) { auto iter = inst_to_used_ids_.find(inst); if (iter != inst_to_used_ids_.end()) { EraseUseRecordsOfOperandIds(inst); if (inst->result_id() != 0) { // Remove all uses of this inst. auto users_begin = UsersBegin(inst); auto end = id_to_users_.end(); auto new_end = users_begin; for (; UsersNotEnd(new_end, end, inst); ++new_end) { } id_to_users_.erase(users_begin, new_end); id_to_def_.erase(inst->result_id()); } } } void DefUseManager::EraseUseRecordsOfOperandIds(const Instruction* inst) { // Go through all ids used by this instruction, remove this instruction's // uses of them. auto iter = inst_to_used_ids_.find(inst); if (iter != inst_to_used_ids_.end()) { for (auto use_id : iter->second) { id_to_users_.erase( UserEntry{GetDef(use_id), const_cast(inst)}); } inst_to_used_ids_.erase(iter); } } bool CompareAndPrintDifferences(const DefUseManager& lhs, const DefUseManager& rhs) { bool same = true; if (lhs.id_to_def_ != rhs.id_to_def_) { for (auto p : lhs.id_to_def_) { if (rhs.id_to_def_.find(p.first) == rhs.id_to_def_.end()) { printf("Diff in id_to_def: missing value in rhs\n"); } } for (auto p : rhs.id_to_def_) { if (lhs.id_to_def_.find(p.first) == lhs.id_to_def_.end()) { printf("Diff in id_to_def: missing value in lhs\n"); } } same = false; } if (lhs.id_to_users_ != rhs.id_to_users_) { for (auto p : lhs.id_to_users_) { if (rhs.id_to_users_.count(p) == 0) { printf("Diff in id_to_users: missing value in rhs\n"); } } for (auto p : rhs.id_to_users_) { if (lhs.id_to_users_.count(p) == 0) { printf("Diff in id_to_users: missing value in lhs\n"); } } same = false; } if (lhs.inst_to_used_ids_ != rhs.inst_to_used_ids_) { for (auto p : lhs.inst_to_used_ids_) { if (rhs.inst_to_used_ids_.count(p.first) == 0) { printf("Diff in inst_to_used_ids: missing value in rhs\n"); } } for (auto p : rhs.inst_to_used_ids_) { if (lhs.inst_to_used_ids_.count(p.first) == 0) { printf("Diff in inst_to_used_ids: missing value in lhs\n"); } } same = false; } return same; } } // namespace analysis } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/def_use_manager.h000066400000000000000000000216231475742701700241140ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_DEF_USE_MANAGER_H_ #define SOURCE_OPT_DEF_USE_MANAGER_H_ #include #include #include #include "source/opt/instruction.h" #include "source/opt/module.h" #include "spirv-tools/libspirv.hpp" namespace spvtools { namespace opt { namespace analysis { // Definition should never be null. User can be null, however, such an entry // should be used only for searching (e.g. all users of a particular definition) // and never stored in a container. struct UserEntry { Instruction* def; Instruction* user; }; inline bool operator==(const UserEntry& lhs, const UserEntry& rhs) { return lhs.def == rhs.def && lhs.user == rhs.user; } // Orders UserEntry for use in associative containers (i.e. less than ordering). // // The definition of an UserEntry is treated as the major key and the users as // the minor key so that all the users of a particular definition are // consecutive in a container. // // A null user always compares less than a real user. This is done to provide // easy values to search for the beginning of the users of a particular // definition (i.e. using {def, nullptr}). struct UserEntryLess { bool operator()(const UserEntry& lhs, const UserEntry& rhs) const { // If lhs.def and rhs.def are both null, fall through to checking the // second entries. if (!lhs.def && rhs.def) return true; if (lhs.def && !rhs.def) return false; // If neither definition is null, then compare unique ids. if (lhs.def && rhs.def) { if (lhs.def->unique_id() < rhs.def->unique_id()) return true; if (rhs.def->unique_id() < lhs.def->unique_id()) return false; } // Return false on equality. if (!lhs.user && !rhs.user) return false; if (!lhs.user) return true; if (!rhs.user) return false; // If neither user is null then compare unique ids. return lhs.user->unique_id() < rhs.user->unique_id(); } }; // A class for analyzing and managing defs and uses in an Module. class DefUseManager { public: using IdToDefMap = std::unordered_map; // Constructs a def-use manager from the given |module|. All internal messages // will be communicated to the outside via the given message |consumer|. This // instance only keeps a reference to the |consumer|, so the |consumer| should // outlive this instance. DefUseManager(Module* module) { AnalyzeDefUse(module); } DefUseManager(const DefUseManager&) = delete; DefUseManager(DefUseManager&&) = delete; DefUseManager& operator=(const DefUseManager&) = delete; DefUseManager& operator=(DefUseManager&&) = delete; // Analyzes the defs in the given |inst|. void AnalyzeInstDef(Instruction* inst); // Analyzes the uses in the given |inst|. // // All operands of |inst| must be analyzed as defs. void AnalyzeInstUse(Instruction* inst); // Analyzes the defs and uses in the given |inst|. void AnalyzeInstDefUse(Instruction* inst); // Returns the def instruction for the given |id|. If there is no instruction // defining |id|, returns nullptr. Instruction* GetDef(uint32_t id); const Instruction* GetDef(uint32_t id) const; // Runs the given function |f| on each unique user instruction of |def| (or // |id|). // // If one instruction uses |def| in multiple operands, that instruction will // only be visited once. // // |def| (or |id|) must be registered as a definition. void ForEachUser(const Instruction* def, const std::function& f) const; void ForEachUser(uint32_t id, const std::function& f) const; // Runs the given function |f| on each unique user instruction of |def| (or // |id|). If |f| returns false, iteration is terminated and this function // returns false. // // If one instruction uses |def| in multiple operands, that instruction will // be only be visited once. // // |def| (or |id|) must be registered as a definition. bool WhileEachUser(const Instruction* def, const std::function& f) const; bool WhileEachUser(uint32_t id, const std::function& f) const; // Runs the given function |f| on each unique use of |def| (or // |id|). // // If one instruction uses |def| in multiple operands, each operand will be // visited separately. // // |def| (or |id|) must be registered as a definition. void ForEachUse( const Instruction* def, const std::function& f) const; void ForEachUse( uint32_t id, const std::function& f) const; // Runs the given function |f| on each unique use of |def| (or // |id|). If |f| returns false, iteration is terminated and this function // returns false. // // If one instruction uses |def| in multiple operands, each operand will be // visited separately. // // |def| (or |id|) must be registered as a definition. bool WhileEachUse( const Instruction* def, const std::function& f) const; bool WhileEachUse( uint32_t id, const std::function& f) const; // Returns the number of users of |def| (or |id|). uint32_t NumUsers(const Instruction* def) const; uint32_t NumUsers(uint32_t id) const; // Returns the number of uses of |def| (or |id|). uint32_t NumUses(const Instruction* def) const; uint32_t NumUses(uint32_t id) const; // Returns the annotation instrunctions which are a direct use of the given // |id|. This means when the decorations are applied through decoration // group(s), this function will just return the OpGroupDecorate // instruction(s) which refer to the given id as an operand. The OpDecorate // instructions which decorate the decoration group will not be returned. std::vector GetAnnotations(uint32_t id) const; // Returns the map from ids to their def instructions. const IdToDefMap& id_to_defs() const { return id_to_def_; } // Clear the internal def-use record of the given instruction |inst|. This // method will update the use information of the operand ids of |inst|. The // record: |inst| uses an |id|, will be removed from the use records of |id|. // If |inst| defines an result id, the use record of this result id will also // be removed. Does nothing if |inst| was not analyzed before. void ClearInst(Instruction* inst); // Erases the records that a given instruction uses its operand ids. void EraseUseRecordsOfOperandIds(const Instruction* inst); friend bool CompareAndPrintDifferences(const DefUseManager&, const DefUseManager&); // If |inst| has not already been analysed, then analyses its definition and // uses. void UpdateDefUse(Instruction* inst); private: using IdToUsersMap = std::set; using InstToUsedIdsMap = std::unordered_map>; // Returns the first location that {|def|, nullptr} could be inserted into the // users map without violating ordering. IdToUsersMap::const_iterator UsersBegin(const Instruction* def) const; // Returns true if |iter| has not reached the end of |def|'s users. // // In the first version |iter| is compared against the end of the map for // validity before other checks. In the second version, |iter| is compared // against |cached_end| for validity before other checks. This allows caching // the map's end which is a performance improvement on some platforms. bool UsersNotEnd(const IdToUsersMap::const_iterator& iter, const Instruction* def) const; bool UsersNotEnd(const IdToUsersMap::const_iterator& iter, const IdToUsersMap::const_iterator& cached_end, const Instruction* def) const; // Analyzes the defs and uses in the given |module| and populates data // structures in this class. Does nothing if |module| is nullptr. void AnalyzeDefUse(Module* module); IdToDefMap id_to_def_; // Mapping from ids to their definitions IdToUsersMap id_to_users_; // Mapping from ids to their users // Mapping from instructions to the ids used in the instruction. InstToUsedIdsMap inst_to_used_ids_; }; } // namespace analysis } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_DEF_USE_MANAGER_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/desc_sroa.cpp000066400000000000000000000414431475742701700233070ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/desc_sroa.h" #include "source/opt/desc_sroa_util.h" #include "source/util/string_utils.h" namespace spvtools { namespace opt { namespace { bool IsDecorationBinding(Instruction* inst) { if (inst->opcode() != spv::Op::OpDecorate) return false; return spv::Decoration(inst->GetSingleWordInOperand(1u)) == spv::Decoration::Binding; } } // namespace Pass::Status DescriptorScalarReplacement::Process() { bool modified = false; std::vector vars_to_kill; for (Instruction& var : context()->types_values()) { bool is_candidate = flatten_arrays_ && descsroautil::IsDescriptorArray(context(), &var); is_candidate |= flatten_composites_ && descsroautil::IsDescriptorStruct(context(), &var); if (is_candidate) { modified = true; if (!ReplaceCandidate(&var)) { return Status::Failure; } vars_to_kill.push_back(&var); } } for (Instruction* var : vars_to_kill) { context()->KillInst(var); } return (modified ? Status::SuccessWithChange : Status::SuccessWithoutChange); } bool DescriptorScalarReplacement::ReplaceCandidate(Instruction* var) { std::vector access_chain_work_list; std::vector load_work_list; std::vector entry_point_work_list; bool failed = !get_def_use_mgr()->WhileEachUser( var->result_id(), [this, &access_chain_work_list, &load_work_list, &entry_point_work_list](Instruction* use) { if (use->opcode() == spv::Op::OpName) { return true; } if (use->IsDecoration()) { return true; } switch (use->opcode()) { case spv::Op::OpAccessChain: case spv::Op::OpInBoundsAccessChain: access_chain_work_list.push_back(use); return true; case spv::Op::OpLoad: load_work_list.push_back(use); return true; case spv::Op::OpEntryPoint: entry_point_work_list.push_back(use); return true; default: context()->EmitErrorMessage( "Variable cannot be replaced: invalid instruction", use); return false; } return true; }); if (failed) { return false; } for (Instruction* use : access_chain_work_list) { if (!ReplaceAccessChain(var, use)) { return false; } } for (Instruction* use : load_work_list) { if (!ReplaceLoadedValue(var, use)) { return false; } } for (Instruction* use : entry_point_work_list) { if (!ReplaceEntryPoint(var, use)) { return false; } } return true; } bool DescriptorScalarReplacement::ReplaceAccessChain(Instruction* var, Instruction* use) { if (use->NumInOperands() <= 1) { context()->EmitErrorMessage( "Variable cannot be replaced: invalid instruction", use); return false; } const analysis::Constant* const_index = descsroautil::GetAccessChainIndexAsConst(context(), use); if (const_index == nullptr) { context()->EmitErrorMessage("Variable cannot be replaced: invalid index", use); return false; } uint32_t idx = const_index->GetU32(); uint32_t replacement_var = GetReplacementVariable(var, idx); if (use->NumInOperands() == 2) { // We are not indexing into the replacement variable. We can replaces the // access chain with the replacement variable itself. context()->ReplaceAllUsesWith(use->result_id(), replacement_var); context()->KillInst(use); return true; } // We need to build a new access chain with the replacement variable as the // base address. Instruction::OperandList new_operands; // Same result id and result type. new_operands.emplace_back(use->GetOperand(0)); new_operands.emplace_back(use->GetOperand(1)); // Use the replacement variable as the base address. new_operands.push_back({SPV_OPERAND_TYPE_ID, {replacement_var}}); // Drop the first index because it is consumed by the replacement, and copy // the rest. for (uint32_t i = 4; i < use->NumOperands(); i++) { new_operands.emplace_back(use->GetOperand(i)); } use->ReplaceOperands(new_operands); context()->UpdateDefUse(use); return true; } bool DescriptorScalarReplacement::ReplaceEntryPoint(Instruction* var, Instruction* use) { // Build a new |OperandList| for |use| that removes |var| and adds its // replacement variables. Instruction::OperandList new_operands; // Copy all operands except |var|. bool found = false; for (uint32_t idx = 0; idx < use->NumOperands(); idx++) { Operand& op = use->GetOperand(idx); if (op.type == SPV_OPERAND_TYPE_ID && op.words[0] == var->result_id()) { found = true; } else { new_operands.emplace_back(op); } } if (!found) { context()->EmitErrorMessage( "Variable cannot be replaced: invalid instruction", use); return false; } // Add all new replacement variables. uint32_t num_replacement_vars = descsroautil::GetNumberOfElementsForArrayOrStruct(context(), var); for (uint32_t i = 0; i < num_replacement_vars; i++) { new_operands.push_back( {SPV_OPERAND_TYPE_ID, {GetReplacementVariable(var, i)}}); } use->ReplaceOperands(new_operands); context()->UpdateDefUse(use); return true; } uint32_t DescriptorScalarReplacement::GetReplacementVariable(Instruction* var, uint32_t idx) { auto replacement_vars = replacement_variables_.find(var); if (replacement_vars == replacement_variables_.end()) { uint32_t number_of_elements = descsroautil::GetNumberOfElementsForArrayOrStruct(context(), var); replacement_vars = replacement_variables_ .insert({var, std::vector(number_of_elements, 0)}) .first; } if (replacement_vars->second[idx] == 0) { replacement_vars->second[idx] = CreateReplacementVariable(var, idx); } return replacement_vars->second[idx]; } void DescriptorScalarReplacement::CopyDecorationsForNewVariable( Instruction* old_var, uint32_t index, uint32_t new_var_id, uint32_t new_var_ptr_type_id, const bool is_old_var_array, const bool is_old_var_struct, Instruction* old_var_type) { // Handle OpDecorate and OpDecorateString instructions. for (auto old_decoration : get_decoration_mgr()->GetDecorationsFor(old_var->result_id(), true)) { uint32_t new_binding = 0; if (IsDecorationBinding(old_decoration)) { new_binding = GetNewBindingForElement( old_decoration->GetSingleWordInOperand(2), index, new_var_ptr_type_id, is_old_var_array, is_old_var_struct, old_var_type); } CreateNewDecorationForNewVariable(old_decoration, new_var_id, new_binding); } // Handle OpMemberDecorate instructions. for (auto old_decoration : get_decoration_mgr()->GetDecorationsFor( old_var_type->result_id(), true)) { assert(old_decoration->opcode() == spv::Op::OpMemberDecorate); if (old_decoration->GetSingleWordInOperand(1u) != index) continue; CreateNewDecorationForMemberDecorate(old_decoration, new_var_id); } } uint32_t DescriptorScalarReplacement::GetNewBindingForElement( uint32_t old_binding, uint32_t index, uint32_t new_var_ptr_type_id, const bool is_old_var_array, const bool is_old_var_struct, Instruction* old_var_type) { if (is_old_var_array) { return old_binding + index * GetNumBindingsUsedByType(new_var_ptr_type_id); } if (is_old_var_struct) { // The binding offset that should be added is the sum of binding // numbers used by previous members of the current struct. uint32_t new_binding = old_binding; for (uint32_t i = 0; i < index; ++i) { new_binding += GetNumBindingsUsedByType(old_var_type->GetSingleWordInOperand(i)); } return new_binding; } return old_binding; } void DescriptorScalarReplacement::CreateNewDecorationForNewVariable( Instruction* old_decoration, uint32_t new_var_id, uint32_t new_binding) { assert(old_decoration->opcode() == spv::Op::OpDecorate || old_decoration->opcode() == spv::Op::OpDecorateString); std::unique_ptr new_decoration(old_decoration->Clone(context())); new_decoration->SetInOperand(0, {new_var_id}); if (IsDecorationBinding(new_decoration.get())) { new_decoration->SetInOperand(2, {new_binding}); } context()->AddAnnotationInst(std::move(new_decoration)); } void DescriptorScalarReplacement::CreateNewDecorationForMemberDecorate( Instruction* old_member_decoration, uint32_t new_var_id) { std::vector operands( {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {new_var_id}}}); auto new_decorate_operand_begin = old_member_decoration->begin() + 2u; auto new_decorate_operand_end = old_member_decoration->end(); operands.insert(operands.end(), new_decorate_operand_begin, new_decorate_operand_end); get_decoration_mgr()->AddDecoration(spv::Op::OpDecorate, std::move(operands)); } uint32_t DescriptorScalarReplacement::CreateReplacementVariable( Instruction* var, uint32_t idx) { // The storage class for the new variable is the same as the original. spv::StorageClass storage_class = static_cast(var->GetSingleWordInOperand(0)); // The type for the new variable will be a pointer to type of the elements of // the array. uint32_t ptr_type_id = var->type_id(); Instruction* ptr_type_inst = get_def_use_mgr()->GetDef(ptr_type_id); assert(ptr_type_inst->opcode() == spv::Op::OpTypePointer && "Variable should be a pointer to an array or structure."); uint32_t pointee_type_id = ptr_type_inst->GetSingleWordInOperand(1); Instruction* pointee_type_inst = get_def_use_mgr()->GetDef(pointee_type_id); const bool is_array = pointee_type_inst->opcode() == spv::Op::OpTypeArray; const bool is_struct = pointee_type_inst->opcode() == spv::Op::OpTypeStruct; assert((is_array || is_struct) && "Variable should be a pointer to an array or structure."); uint32_t element_type_id = is_array ? pointee_type_inst->GetSingleWordInOperand(0) : pointee_type_inst->GetSingleWordInOperand(idx); uint32_t ptr_element_type_id = context()->get_type_mgr()->FindPointerToType( element_type_id, storage_class); // Create the variable. uint32_t id = TakeNextId(); std::unique_ptr variable( new Instruction(context(), spv::Op::OpVariable, ptr_element_type_id, id, std::initializer_list{ {SPV_OPERAND_TYPE_STORAGE_CLASS, {static_cast(storage_class)}}})); context()->AddGlobalValue(std::move(variable)); CopyDecorationsForNewVariable(var, idx, id, ptr_element_type_id, is_array, is_struct, pointee_type_inst); // Create a new OpName for the replacement variable. std::vector> names_to_add; for (auto p : context()->GetNames(var->result_id())) { Instruction* name_inst = p.second; std::string name_str = utils::MakeString(name_inst->GetOperand(1).words); if (is_array) { name_str += "[" + utils::ToString(idx) + "]"; } if (is_struct) { Instruction* member_name_inst = context()->GetMemberName(pointee_type_inst->result_id(), idx); name_str += "."; if (member_name_inst) name_str += utils::MakeString(member_name_inst->GetOperand(2).words); else // In case the member does not have a name assigned to it, use the // member index. name_str += utils::ToString(idx); } std::unique_ptr new_name(new Instruction( context(), spv::Op::OpName, 0, 0, std::initializer_list{ {SPV_OPERAND_TYPE_ID, {id}}, {SPV_OPERAND_TYPE_LITERAL_STRING, utils::MakeVector(name_str)}})); Instruction* new_name_inst = new_name.get(); get_def_use_mgr()->AnalyzeInstDefUse(new_name_inst); names_to_add.push_back(std::move(new_name)); } // We shouldn't add the new names when we are iterating over name ranges // above. We can add all the new names now. for (auto& new_name : names_to_add) context()->AddDebug2Inst(std::move(new_name)); return id; } uint32_t DescriptorScalarReplacement::GetNumBindingsUsedByType( uint32_t type_id) { Instruction* type_inst = get_def_use_mgr()->GetDef(type_id); // If it's a pointer, look at the underlying type. if (type_inst->opcode() == spv::Op::OpTypePointer) { type_id = type_inst->GetSingleWordInOperand(1); type_inst = get_def_use_mgr()->GetDef(type_id); } // Arrays consume N*M binding numbers where N is the array length, and M is // the number of bindings used by each array element. if (type_inst->opcode() == spv::Op::OpTypeArray) { uint32_t element_type_id = type_inst->GetSingleWordInOperand(0); uint32_t length_id = type_inst->GetSingleWordInOperand(1); const analysis::Constant* length_const = context()->get_constant_mgr()->FindDeclaredConstant(length_id); // OpTypeArray's length must always be a constant assert(length_const != nullptr); uint32_t num_elems = length_const->GetU32(); return num_elems * GetNumBindingsUsedByType(element_type_id); } // The number of bindings consumed by a structure is the sum of the bindings // used by its members. if (type_inst->opcode() == spv::Op::OpTypeStruct && !descsroautil::IsTypeOfStructuredBuffer(context(), type_inst)) { uint32_t sum = 0; for (uint32_t i = 0; i < type_inst->NumInOperands(); i++) sum += GetNumBindingsUsedByType(type_inst->GetSingleWordInOperand(i)); return sum; } // All other types are considered to take up 1 binding number. return 1; } bool DescriptorScalarReplacement::ReplaceLoadedValue(Instruction* var, Instruction* value) { // |var| is the global variable that has to be eliminated (OpVariable). // |value| is the OpLoad instruction that has loaded |var|. // The function expects all users of |value| to be OpCompositeExtract // instructions. Otherwise the function returns false with an error message. assert(value->opcode() == spv::Op::OpLoad); assert(value->GetSingleWordInOperand(0) == var->result_id()); std::vector work_list; bool failed = !get_def_use_mgr()->WhileEachUser( value->result_id(), [this, &work_list](Instruction* use) { if (use->opcode() != spv::Op::OpCompositeExtract) { context()->EmitErrorMessage( "Variable cannot be replaced: invalid instruction", use); return false; } work_list.push_back(use); return true; }); if (failed) { return false; } for (Instruction* use : work_list) { if (!ReplaceCompositeExtract(var, use)) { return false; } } // All usages of the loaded value have been killed. We can kill the OpLoad. context()->KillInst(value); return true; } bool DescriptorScalarReplacement::ReplaceCompositeExtract( Instruction* var, Instruction* extract) { assert(extract->opcode() == spv::Op::OpCompositeExtract); // We're currently only supporting extractions of one index at a time. If we // need to, we can handle cases with multiple indexes in the future. if (extract->NumInOperands() != 2) { context()->EmitErrorMessage( "Variable cannot be replaced: invalid instruction", extract); return false; } uint32_t replacement_var = GetReplacementVariable(var, extract->GetSingleWordInOperand(1)); // The result type of the OpLoad is the same as the result type of the // OpCompositeExtract. uint32_t load_id = TakeNextId(); std::unique_ptr load( new Instruction(context(), spv::Op::OpLoad, extract->type_id(), load_id, std::initializer_list{ {SPV_OPERAND_TYPE_ID, {replacement_var}}})); Instruction* load_instr = load.get(); get_def_use_mgr()->AnalyzeInstDefUse(load_instr); context()->set_instr_block(load_instr, context()->get_instr_block(extract)); extract->InsertBefore(std::move(load)); context()->ReplaceAllUsesWith(extract->result_id(), load_id); context()->KillInst(extract); return true; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/desc_sroa.h000066400000000000000000000163571475742701700227620ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_DESC_SROA_H_ #define SOURCE_OPT_DESC_SROA_H_ #include #include #include #include #include #include #include "source/opt/function.h" #include "source/opt/pass.h" #include "source/opt/type_manager.h" namespace spvtools { namespace opt { // Documented in optimizer.hpp class DescriptorScalarReplacement : public Pass { public: DescriptorScalarReplacement(bool flatten_composites, bool flatten_arrays) : flatten_composites_(flatten_composites), flatten_arrays_(flatten_arrays) {} const char* name() const override { if (flatten_composites_ && flatten_arrays_) return "descriptor-scalar-replacement"; if (flatten_composites_) return "descriptor-compososite-scalar-replacement"; return "descriptor-array-scalar-replacement"; } Status Process() override; IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisCombinators | IRContext::kAnalysisCFG | IRContext::kAnalysisConstants | IRContext::kAnalysisTypes; } private: // Replaces all references to |var| by new variables, one for each element of // the array |var|. The binding for the new variables corresponding to // element i will be the binding of |var| plus i. Returns true if successful. bool ReplaceCandidate(Instruction* var); // Replaces the base address |var| in the OpAccessChain or // OpInBoundsAccessChain instruction |use| by the variable that the access // chain accesses. The first index in |use| must be an |OpConstant|. Returns // |true| if successful. bool ReplaceAccessChain(Instruction* var, Instruction* use); // Replaces the given compososite variable |var| loaded by OpLoad |value| with // replacement variables, one for each component that's accessed in the // shader. Assumes that |value| is only used by OpCompositeExtract // instructions, one index at a time. Returns true on success, and false // otherwise. bool ReplaceLoadedValue(Instruction* var, Instruction* value); // Replaces the given composite variable |var| in the OpEntryPoint with the // new replacement variables, one for each element of the array |var|. Returns // |true| if successful, and |false| otherwise. bool ReplaceEntryPoint(Instruction* var, Instruction* use); // Replaces the given OpCompositeExtract |extract| and all of its references // with an OpLoad of a replacement variable. |var| is the variable with // composite type whose value is being used by |extract|. Assumes that // |extract| is extracting one index only. Returns true on success, and false // otherwise. bool ReplaceCompositeExtract(Instruction* var, Instruction* extract); // Returns the id of the variable that will be used to replace the |idx|th // element of |var|. The variable is created if it has not already been // created. uint32_t GetReplacementVariable(Instruction* var, uint32_t idx); // Returns the id of a new variable that can be used to replace the |idx|th // element of |var|. uint32_t CreateReplacementVariable(Instruction* var, uint32_t idx); // Returns the number of bindings used by the given |type_id|. // All types are considered to use 1 binding slot, except: // 1- A pointer type consumes as many binding numbers as its pointee. // 2- An array of size N consumes N*M binding numbers, where M is the number // of bindings used by each array element. // 3- The number of bindings consumed by a structure is the sum of the // bindings used by its members. uint32_t GetNumBindingsUsedByType(uint32_t type_id); // Copy all of the decorations of variable |old_var| and make them as // decorations for the new variable whose id is |new_var_id|. The new variable // is supposed to replace |index|th element of |old_var|. // |new_var_ptr_type_id| is the id of the pointer to the type of the new // variable. |is_old_var_array| is true if |old_var| has an array type. // |is_old_var_struct| is true if |old_var| has a structure type. // |old_var_type| is the pointee type of |old_var|. void CopyDecorationsForNewVariable(Instruction* old_var, uint32_t index, uint32_t new_var_id, uint32_t new_var_ptr_type_id, const bool is_old_var_array, const bool is_old_var_struct, Instruction* old_var_type); // Get the new binding number for a new variable that will be replaced with an // |index|th element of an old variable. The old variable has |old_binding| // as its binding number. |ptr_elem_type_id| the id of the pointer to the // element type. |is_old_var_array| is true if the old variable has an array // type. |is_old_var_struct| is true if the old variable has a structure type. // |old_var_type| is the pointee type of the old variable. uint32_t GetNewBindingForElement(uint32_t old_binding, uint32_t index, uint32_t ptr_elem_type_id, const bool is_old_var_array, const bool is_old_var_struct, Instruction* old_var_type); // Create a new OpDecorate(String) instruction by cloning |old_decoration|. // The new OpDecorate(String) instruction will be used for a variable whose id // is |new_var_ptr_type_id|. If |old_decoration| is a decoration for a // binding, the new OpDecorate(String) instruction will have |new_binding| as // its binding. void CreateNewDecorationForNewVariable(Instruction* old_decoration, uint32_t new_var_id, uint32_t new_binding); // Create a new OpDecorate instruction whose operand is the same as an // OpMemberDecorate instruction |old_member_decoration| except Target operand. // The Target operand of the new OpDecorate instruction will be |new_var_id|. void CreateNewDecorationForMemberDecorate(Instruction* old_decoration, uint32_t new_var_id); // A map from an OpVariable instruction to the set of variables that will be // used to replace it. The entry |replacement_variables_[var][i]| is the id of // a variable that will be used in the place of the ith element of the // array |var|. If the entry is |0|, then the variable has not been // created yet. std::map> replacement_variables_; bool flatten_composites_; bool flatten_arrays_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_DESC_SROA_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/desc_sroa_util.cpp000066400000000000000000000116061475742701700243420ustar00rootroot00000000000000// Copyright (c) 2021 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/desc_sroa_util.h" namespace spvtools { namespace opt { namespace { constexpr uint32_t kOpAccessChainInOperandIndexes = 1; // Returns the length of array type |type|. uint32_t GetLengthOfArrayType(IRContext* context, Instruction* type) { assert(type->opcode() == spv::Op::OpTypeArray && "type must be array"); uint32_t length_id = type->GetSingleWordInOperand(1); const analysis::Constant* length_const = context->get_constant_mgr()->FindDeclaredConstant(length_id); assert(length_const != nullptr); return length_const->GetU32(); } bool HasDescriptorDecorations(IRContext* context, Instruction* var) { const auto& decoration_mgr = context->get_decoration_mgr(); return decoration_mgr->HasDecoration( var->result_id(), uint32_t(spv::Decoration::DescriptorSet)) && decoration_mgr->HasDecoration(var->result_id(), uint32_t(spv::Decoration::Binding)); } Instruction* GetVariableType(IRContext* context, Instruction* var) { if (var->opcode() != spv::Op::OpVariable) { return nullptr; } uint32_t ptr_type_id = var->type_id(); Instruction* ptr_type_inst = context->get_def_use_mgr()->GetDef(ptr_type_id); if (ptr_type_inst->opcode() != spv::Op::OpTypePointer) { return nullptr; } uint32_t var_type_id = ptr_type_inst->GetSingleWordInOperand(1); return context->get_def_use_mgr()->GetDef(var_type_id); } } // namespace namespace descsroautil { bool IsDescriptorArray(IRContext* context, Instruction* var) { Instruction* var_type_inst = GetVariableType(context, var); if (var_type_inst == nullptr) return false; return var_type_inst->opcode() == spv::Op::OpTypeArray && HasDescriptorDecorations(context, var); } bool IsDescriptorStruct(IRContext* context, Instruction* var) { Instruction* var_type_inst = GetVariableType(context, var); if (var_type_inst == nullptr) return false; while (var_type_inst->opcode() == spv::Op::OpTypeArray) { var_type_inst = context->get_def_use_mgr()->GetDef( var_type_inst->GetInOperand(0).AsId()); } if (var_type_inst->opcode() != spv::Op::OpTypeStruct) return false; // All structures with descriptor assignments must be replaced by variables, // one for each of their members - with the exceptions of buffers. if (IsTypeOfStructuredBuffer(context, var_type_inst)) { return false; } return HasDescriptorDecorations(context, var); } bool IsTypeOfStructuredBuffer(IRContext* context, const Instruction* type) { if (type->opcode() != spv::Op::OpTypeStruct) { return false; } // All buffers have offset decorations for members of their structure types. // This is how we distinguish it from a structure of descriptors. return context->get_decoration_mgr()->HasDecoration( type->result_id(), uint32_t(spv::Decoration::Offset)); } const analysis::Constant* GetAccessChainIndexAsConst( IRContext* context, Instruction* access_chain) { if (access_chain->NumInOperands() <= 1) { return nullptr; } uint32_t idx_id = GetFirstIndexOfAccessChain(access_chain); const analysis::Constant* idx_const = context->get_constant_mgr()->FindDeclaredConstant(idx_id); return idx_const; } uint32_t GetFirstIndexOfAccessChain(Instruction* access_chain) { assert(access_chain->NumInOperands() > 1 && "OpAccessChain does not have Indexes operand"); return access_chain->GetSingleWordInOperand(kOpAccessChainInOperandIndexes); } uint32_t GetNumberOfElementsForArrayOrStruct(IRContext* context, Instruction* var) { uint32_t ptr_type_id = var->type_id(); Instruction* ptr_type_inst = context->get_def_use_mgr()->GetDef(ptr_type_id); assert(ptr_type_inst->opcode() == spv::Op::OpTypePointer && "Variable should be a pointer to an array or structure."); uint32_t pointee_type_id = ptr_type_inst->GetSingleWordInOperand(1); Instruction* pointee_type_inst = context->get_def_use_mgr()->GetDef(pointee_type_id); if (pointee_type_inst->opcode() == spv::Op::OpTypeArray) { return GetLengthOfArrayType(context, pointee_type_inst); } assert(pointee_type_inst->opcode() == spv::Op::OpTypeStruct && "Variable should be a pointer to an array or structure."); return pointee_type_inst->NumInOperands(); } } // namespace descsroautil } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/desc_sroa_util.h000066400000000000000000000043471475742701700240130ustar00rootroot00000000000000// Copyright (c) 2021 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_DESC_SROA_UTIL_H_ #define SOURCE_OPT_DESC_SROA_UTIL_H_ #include "source/opt/ir_context.h" namespace spvtools { namespace opt { // Provides functions for the descriptor array SROA. namespace descsroautil { // Returns true if |var| is an OpVariable instruction that represents a // descriptor array. bool IsDescriptorArray(IRContext* context, Instruction* var); // Returns true if |var| is an OpVariable instruction that represents a // struct containing descriptors. bool IsDescriptorStruct(IRContext* context, Instruction* var); // Returns true if |type| is a type that could be used for a structured buffer // as opposed to a type that would be used for a structure of resource // descriptors. bool IsTypeOfStructuredBuffer(IRContext* context, const Instruction* type); // Returns the first index of the OpAccessChain instruction |access_chain| as // a constant. Returns nullptr if it is not a constant. const analysis::Constant* GetAccessChainIndexAsConst(IRContext* context, Instruction* access_chain); // Returns the number of elements of an OpVariable instruction |var| whose type // must be a pointer to an array or a struct. uint32_t GetNumberOfElementsForArrayOrStruct(IRContext* context, Instruction* var); // Returns the first Indexes operand id of the OpAccessChain or // OpInBoundsAccessChain instruction |access_chain|. The access chain must have // at least 1 index. uint32_t GetFirstIndexOfAccessChain(Instruction* access_chain); } // namespace descsroautil } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_DESC_SROA_UTIL_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/dominator_analysis.cpp000066400000000000000000000037141475742701700252430ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/dominator_analysis.h" #include #include "source/opt/ir_context.h" namespace spvtools { namespace opt { BasicBlock* DominatorAnalysisBase::CommonDominator(BasicBlock* b1, BasicBlock* b2) const { if (!b1 || !b2) return nullptr; std::unordered_set seen; BasicBlock* block = b1; while (block && seen.insert(block).second) { block = ImmediateDominator(block); } block = b2; while (block && !seen.count(block)) { block = ImmediateDominator(block); } return block; } bool DominatorAnalysisBase::Dominates(Instruction* a, Instruction* b) const { if (!a || !b) { return false; } if (a == b) { return true; } BasicBlock* bb_a = a->context()->get_instr_block(a); BasicBlock* bb_b = b->context()->get_instr_block(b); if (bb_a != bb_b) { return tree_.Dominates(bb_a, bb_b); } const Instruction* current = a; const Instruction* other = b; if (tree_.IsPostDominator()) { std::swap(current, other); } // We handle OpLabel instructions explicitly since they are not stored in the // instruction list. if (current->opcode() == spv::Op::OpLabel) { return true; } while ((current = current->NextNode())) { if (current == other) { return true; } } return false; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/dominator_analysis.h000066400000000000000000000112621475742701700247050ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_DOMINATOR_ANALYSIS_H_ #define SOURCE_OPT_DOMINATOR_ANALYSIS_H_ #include #include #include "source/opt/dominator_tree.h" namespace spvtools { namespace opt { // Interface to perform dominator or postdominator analysis on a given function. class DominatorAnalysisBase { public: explicit DominatorAnalysisBase(bool is_post_dom) : tree_(is_post_dom) {} // Calculates the dominator (or postdominator) tree for given function |f|. inline void InitializeTree(const CFG& cfg, const Function* f) { tree_.InitializeTree(cfg, f); } // Returns true if BasicBlock |a| dominates BasicBlock |b|. inline bool Dominates(const BasicBlock* a, const BasicBlock* b) const { if (!a || !b) return false; return Dominates(a->id(), b->id()); } // Returns true if BasicBlock |a| dominates BasicBlock |b|. Same as above only // using the BasicBlock IDs. inline bool Dominates(uint32_t a, uint32_t b) const { return tree_.Dominates(a, b); } // Returns true if instruction |a| dominates instruction |b|. bool Dominates(Instruction* a, Instruction* b) const; // Returns true if BasicBlock |a| strictly dominates BasicBlock |b|. inline bool StrictlyDominates(const BasicBlock* a, const BasicBlock* b) const { if (!a || !b) return false; return StrictlyDominates(a->id(), b->id()); } // Returns true if BasicBlock |a| strictly dominates BasicBlock |b|. Same as // above only using the BasicBlock IDs. inline bool StrictlyDominates(uint32_t a, uint32_t b) const { return tree_.StrictlyDominates(a, b); } // Returns the immediate dominator of |node| or returns nullptr if it is has // no dominator. inline BasicBlock* ImmediateDominator(const BasicBlock* node) const { if (!node) return nullptr; return tree_.ImmediateDominator(node); } // Returns the immediate dominator of |node_id| or returns nullptr if it is // has no dominator. Same as above but operates on IDs. inline BasicBlock* ImmediateDominator(uint32_t node_id) const { return tree_.ImmediateDominator(node_id); } // Returns true if |node| is reachable from the entry. inline bool IsReachable(const BasicBlock* node) const { if (!node) return false; return tree_.ReachableFromRoots(node->id()); } // Returns true if |node_id| is reachable from the entry. inline bool IsReachable(uint32_t node_id) const { return tree_.ReachableFromRoots(node_id); } // Dump the tree structure into the given |out| stream in the dot format. inline void DumpAsDot(std::ostream& out) const { tree_.DumpTreeAsDot(out); } // Returns true if this is a postdomiator tree. inline bool IsPostDominator() const { return tree_.IsPostDominator(); } // Returns the tree itself for manual operations, such as traversing the // roots. // For normal dominance relationships the methods above should be used. inline DominatorTree& GetDomTree() { return tree_; } inline const DominatorTree& GetDomTree() const { return tree_; } // Force the dominator tree to be removed inline void ClearTree() { tree_.ClearTree(); } // Applies the std::function |func| to dominator tree nodes in dominator // order. void Visit(std::function func) { tree_.Visit(func); } // Applies the std::function |func| to dominator tree nodes in dominator // order. void Visit(std::function func) const { tree_.Visit(func); } // Returns the most immediate basic block that dominates both |b1| and |b2|. // If there is no such basic block, nullptr is returned. BasicBlock* CommonDominator(BasicBlock* b1, BasicBlock* b2) const; protected: DominatorTree tree_; }; // Derived class for normal dominator analysis. class DominatorAnalysis : public DominatorAnalysisBase { public: DominatorAnalysis() : DominatorAnalysisBase(false) {} }; // Derived class for postdominator analysis. class PostDominatorAnalysis : public DominatorAnalysisBase { public: PostDominatorAnalysis() : DominatorAnalysisBase(true) {} }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_DOMINATOR_ANALYSIS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/dominator_tree.cpp000066400000000000000000000344351475742701700243630ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include "source/cfa.h" #include "source/opt/dominator_tree.h" #include "source/opt/ir_context.h" // Calculates the dominator or postdominator tree for a given function. // 1 - Compute the successors and predecessors for each BasicBlock. We add a // placeholder node for the start node or for postdominators the exit. This node // will point to all entry or all exit nodes. // 2 - Using the CFA::DepthFirstTraversal get a depth first postordered list of // all BasicBlocks. Using the successors (or for postdominator, predecessors) // calculated in step 1 to traverse the tree. // 3 - Pass the list calculated in step 2 to the CFA::CalculateDominators using // the predecessors list (or for postdominator, successors). This will give us a // vector of BB pairs. Each BB and its immediate dominator. // 4 - Using the list from 3 use those edges to build a tree of // DominatorTreeNodes. Each node containing a link to the parent dominator and // children which are dominated. // 5 - Using the tree from 4, perform a depth first traversal to calculate the // preorder and postorder index of each node. We use these indexes to compare // nodes against each other for domination checks. namespace spvtools { namespace opt { namespace { // Wrapper around CFA::DepthFirstTraversal to provide an interface to perform // depth first search on generic BasicBlock types. Will call post and pre order // user defined functions during traversal // // BBType - BasicBlock type. Will either be BasicBlock or DominatorTreeNode // SuccessorLambda - Lamdba matching the signature of 'const // std::vector*(const BBType *A)'. Will return a vector of the nodes // succeeding BasicBlock A. // PostLambda - Lamdba matching the signature of 'void (const BBType*)' will be // called on each node traversed AFTER their children. // PreLambda - Lamdba matching the signature of 'void (const BBType*)' will be // called on each node traversed BEFORE their children. template void DepthFirstSearch(const BBType* bb, SuccessorLambda successors, PreLambda pre, PostLambda post) { auto no_terminal_blocks = [](const BBType*) { return false; }; CFA::DepthFirstTraversal(bb, successors, pre, post, no_terminal_blocks); } // Wrapper around CFA::DepthFirstTraversal to provide an interface to perform // depth first search on generic BasicBlock types. This overload is for only // performing user defined post order. // // BBType - BasicBlock type. Will either be BasicBlock or DominatorTreeNode // SuccessorLambda - Lamdba matching the signature of 'const // std::vector*(const BBType *A)'. Will return a vector of the nodes // succeeding BasicBlock A. // PostLambda - Lamdba matching the signature of 'void (const BBType*)' will be // called on each node traversed after their children. template void DepthFirstSearchPostOrder(const BBType* bb, SuccessorLambda successors, PostLambda post) { // Ignore preorder operation. auto nop_preorder = [](const BBType*) {}; DepthFirstSearch(bb, successors, nop_preorder, post); } // Small type trait to get the function class type. template struct GetFunctionClass { using FunctionType = Function; }; // Helper class to compute predecessors and successors for each Basic Block in a // function. Through GetPredFunctor and GetSuccessorFunctor it provides an // interface to get the successor and predecessor lists for each basic // block. This is required by the DepthFirstTraversal and ComputeDominator // functions which take as parameter an std::function returning the successors // and predecessors respectively. // // When computing the post-dominator tree, all edges are inverted. So successors // returned by this class will be predecessors in the original CFG. template class BasicBlockSuccessorHelper { // This should eventually become const BasicBlock. using BasicBlock = BBType; using Function = typename GetFunctionClass::FunctionType; using BasicBlockListTy = std::vector; using BasicBlockMapTy = std::unordered_map; public: // For compliance with the dominance tree computation, entry nodes are // connected to a single placeholder node. BasicBlockSuccessorHelper(Function& func, const BasicBlock* placeholder_start_node, bool post); // CFA::CalculateDominators requires std::vector. using GetBlocksFunction = std::function*(const BasicBlock*)>; // Returns the list of predecessor functions. GetBlocksFunction GetPredFunctor() { return [this](const BasicBlock* bb) { BasicBlockListTy* v = &this->predecessors_[bb]; return v; }; } // Returns a vector of the list of successor nodes from a given node. GetBlocksFunction GetSuccessorFunctor() { return [this](const BasicBlock* bb) { BasicBlockListTy* v = &this->successors_[bb]; return v; }; } private: bool invert_graph_; BasicBlockMapTy successors_; BasicBlockMapTy predecessors_; // Build the successors and predecessors map for each basic blocks |f|. // If |invert_graph_| is true, all edges are reversed (successors becomes // predecessors and vice versa). // For convenience, the start of the graph is |placeholder_start_node|. // The dominator tree construction requires a unique entry node, which cannot // be guaranteed for the postdominator graph. The |placeholder_start_node| BB // is here to gather all entry nodes. void CreateSuccessorMap(Function& f, const BasicBlock* placeholder_start_node); }; template BasicBlockSuccessorHelper::BasicBlockSuccessorHelper( Function& func, const BasicBlock* placeholder_start_node, bool invert) : invert_graph_(invert) { CreateSuccessorMap(func, placeholder_start_node); } template void BasicBlockSuccessorHelper::CreateSuccessorMap( Function& f, const BasicBlock* placeholder_start_node) { IRContext* context = f.DefInst().context(); if (invert_graph_) { // For the post dominator tree, we see the inverted graph. // successors_ in the inverted graph are the predecessors in the CFG. // The tree construction requires 1 entry point, so we add a placeholder // node that is connected to all function exiting basic blocks. An exiting // basic block is a block with an OpKill, OpUnreachable, OpReturn, // OpReturnValue, or OpTerminateInvocation as terminator instruction. for (BasicBlock& bb : f) { if (bb.hasSuccessor()) { BasicBlockListTy& pred_list = predecessors_[&bb]; const auto& const_bb = bb; const_bb.ForEachSuccessorLabel( [this, &pred_list, &bb, context](const uint32_t successor_id) { BasicBlock* succ = context->get_instr_block(successor_id); // Inverted graph: our successors in the CFG // are our predecessors in the inverted graph. this->successors_[succ].push_back(&bb); pred_list.push_back(succ); }); } else { successors_[placeholder_start_node].push_back(&bb); predecessors_[&bb].push_back( const_cast(placeholder_start_node)); } } } else { successors_[placeholder_start_node].push_back(f.entry().get()); predecessors_[f.entry().get()].push_back( const_cast(placeholder_start_node)); for (BasicBlock& bb : f) { BasicBlockListTy& succ_list = successors_[&bb]; const auto& const_bb = bb; const_bb.ForEachSuccessorLabel([&](const uint32_t successor_id) { BasicBlock* succ = context->get_instr_block(successor_id); succ_list.push_back(succ); predecessors_[succ].push_back(&bb); }); } } } } // namespace bool DominatorTree::StrictlyDominates(uint32_t a, uint32_t b) const { if (a == b) return false; return Dominates(a, b); } bool DominatorTree::StrictlyDominates(const BasicBlock* a, const BasicBlock* b) const { return DominatorTree::StrictlyDominates(a->id(), b->id()); } bool DominatorTree::StrictlyDominates(const DominatorTreeNode* a, const DominatorTreeNode* b) const { if (a == b) return false; return Dominates(a, b); } bool DominatorTree::Dominates(uint32_t a, uint32_t b) const { // Check that both of the inputs are actual nodes. const DominatorTreeNode* a_node = GetTreeNode(a); const DominatorTreeNode* b_node = GetTreeNode(b); if (!a_node || !b_node) return false; return Dominates(a_node, b_node); } bool DominatorTree::Dominates(const DominatorTreeNode* a, const DominatorTreeNode* b) const { if (!a || !b) return false; // Node A dominates node B if they are the same. if (a == b) return true; return a->dfs_num_pre_ < b->dfs_num_pre_ && a->dfs_num_post_ > b->dfs_num_post_; } bool DominatorTree::Dominates(const BasicBlock* A, const BasicBlock* B) const { return Dominates(A->id(), B->id()); } BasicBlock* DominatorTree::ImmediateDominator(const BasicBlock* A) const { return ImmediateDominator(A->id()); } BasicBlock* DominatorTree::ImmediateDominator(uint32_t a) const { // Check that A is a valid node in the tree. auto a_itr = nodes_.find(a); if (a_itr == nodes_.end()) return nullptr; const DominatorTreeNode* node = &a_itr->second; if (node->parent_ == nullptr) { return nullptr; } return node->parent_->bb_; } DominatorTreeNode* DominatorTree::GetOrInsertNode(BasicBlock* bb) { DominatorTreeNode* dtn = nullptr; std::map::iterator node_iter = nodes_.find(bb->id()); if (node_iter == nodes_.end()) { dtn = &nodes_.emplace(std::make_pair(bb->id(), DominatorTreeNode{bb})) .first->second; } else { dtn = &node_iter->second; } return dtn; } void DominatorTree::GetDominatorEdges( const Function* f, const BasicBlock* placeholder_start_node, std::vector>* edges) { // Each time the depth first traversal calls the postorder callback // std::function we push that node into the postorder vector to create our // postorder list. std::vector postorder; auto postorder_function = [&](const BasicBlock* b) { postorder.push_back(b); }; // CFA::CalculateDominators requires std::vector // BB are derived from F, so we need to const cast it at some point // no modification is made on F. BasicBlockSuccessorHelper helper{ *const_cast(f), placeholder_start_node, postdominator_}; // The successor function tells DepthFirstTraversal how to move to successive // nodes by providing an interface to get a list of successor nodes from any // given node. auto successor_functor = helper.GetSuccessorFunctor(); // The predecessor functor does the same as the successor functor // but for all nodes preceding a given node. auto predecessor_functor = helper.GetPredFunctor(); // If we're building a post dominator tree we traverse the tree in reverse // using the predecessor function in place of the successor function and vice // versa. DepthFirstSearchPostOrder(placeholder_start_node, successor_functor, postorder_function); *edges = CFA::CalculateDominators(postorder, predecessor_functor); } void DominatorTree::InitializeTree(const CFG& cfg, const Function* f) { ClearTree(); // Skip over empty functions. if (f->cbegin() == f->cend()) { return; } const BasicBlock* placeholder_start_node = postdominator_ ? cfg.pseudo_exit_block() : cfg.pseudo_entry_block(); // Get the immediate dominator for each node. std::vector> edges; GetDominatorEdges(f, placeholder_start_node, &edges); // Transform the vector into the tree structure which we can use to // efficiently query dominance. for (auto edge : edges) { DominatorTreeNode* first = GetOrInsertNode(edge.first); if (edge.first == edge.second) { if (std::find(roots_.begin(), roots_.end(), first) == roots_.end()) roots_.push_back(first); continue; } DominatorTreeNode* second = GetOrInsertNode(edge.second); first->parent_ = second; second->children_.push_back(first); } ResetDFNumbering(); } void DominatorTree::ResetDFNumbering() { int index = 0; auto preFunc = [&index](const DominatorTreeNode* node) { const_cast(node)->dfs_num_pre_ = ++index; }; auto postFunc = [&index](const DominatorTreeNode* node) { const_cast(node)->dfs_num_post_ = ++index; }; auto getSucc = [](const DominatorTreeNode* node) { return &node->children_; }; for (auto root : roots_) DepthFirstSearch(root, getSucc, preFunc, postFunc); } void DominatorTree::DumpTreeAsDot(std::ostream& out_stream) const { out_stream << "digraph {\n"; Visit([&out_stream](const DominatorTreeNode* node) { // Print the node. if (node->bb_) { out_stream << node->bb_->id() << "[label=\"" << node->bb_->id() << "\"];\n"; } // Print the arrow from the parent to this node. Entry nodes will not have // parents so draw them as children from the placeholder node. if (node->parent_) { out_stream << node->parent_->bb_->id() << " -> " << node->bb_->id() << ";\n"; } // Return true to continue the traversal. return true; }); out_stream << "}\n"; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/dominator_tree.h000066400000000000000000000271031475742701700240220ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_DOMINATOR_TREE_H_ #define SOURCE_OPT_DOMINATOR_TREE_H_ #include #include #include #include #include #include "source/opt/cfg.h" #include "source/opt/tree_iterator.h" namespace spvtools { namespace opt { // This helper struct forms the nodes in the tree, with each node containing its // children. It also contains two values, for the pre and post indexes in the // tree which are used to compare two nodes. struct DominatorTreeNode { explicit DominatorTreeNode(BasicBlock* bb) : bb_(bb), parent_(nullptr), children_({}), dfs_num_pre_(-1), dfs_num_post_(-1) {} using iterator = std::vector::iterator; using const_iterator = std::vector::const_iterator; // depth first preorder iterator. using df_iterator = TreeDFIterator; using const_df_iterator = TreeDFIterator; // depth first postorder iterator. using post_iterator = PostOrderTreeDFIterator; using const_post_iterator = PostOrderTreeDFIterator; iterator begin() { return children_.begin(); } iterator end() { return children_.end(); } const_iterator begin() const { return cbegin(); } const_iterator end() const { return cend(); } const_iterator cbegin() const { return children_.begin(); } const_iterator cend() const { return children_.end(); } // Depth first preorder iterator using this node as root. df_iterator df_begin() { return df_iterator(this); } df_iterator df_end() { return df_iterator(); } const_df_iterator df_begin() const { return df_cbegin(); } const_df_iterator df_end() const { return df_cend(); } const_df_iterator df_cbegin() const { return const_df_iterator(this); } const_df_iterator df_cend() const { return const_df_iterator(); } // Depth first postorder iterator using this node as root. post_iterator post_begin() { return post_iterator::begin(this); } post_iterator post_end() { return post_iterator::end(nullptr); } const_post_iterator post_begin() const { return post_cbegin(); } const_post_iterator post_end() const { return post_cend(); } const_post_iterator post_cbegin() const { return const_post_iterator::begin(this); } const_post_iterator post_cend() const { return const_post_iterator::end(nullptr); } inline uint32_t id() const { return bb_->id(); } BasicBlock* bb_; DominatorTreeNode* parent_; std::vector children_; // These indexes are used to compare two given nodes. A node is a child or // grandchild of another node if its preorder index is greater than the // first nodes preorder index AND if its postorder index is less than the // first nodes postorder index. int dfs_num_pre_; int dfs_num_post_; }; // A class representing a tree of BasicBlocks in a given function, where each // node is dominated by its parent. class DominatorTree { public: // Map OpLabel ids to dominator tree nodes using DominatorTreeNodeMap = std::map; using iterator = TreeDFIterator; using const_iterator = TreeDFIterator; using post_iterator = PostOrderTreeDFIterator; using const_post_iterator = PostOrderTreeDFIterator; // List of DominatorTreeNode to define the list of roots using DominatorTreeNodeList = std::vector; using roots_iterator = DominatorTreeNodeList::iterator; using roots_const_iterator = DominatorTreeNodeList::const_iterator; DominatorTree() : postdominator_(false) {} explicit DominatorTree(bool post) : postdominator_(post) {} // Depth first iterators. // Traverse the dominator tree in a depth first pre-order. // The pseudo-block is ignored. iterator begin() { return ++iterator(GetRoot()); } iterator end() { return iterator(); } const_iterator begin() const { return cbegin(); } const_iterator end() const { return cend(); } const_iterator cbegin() const { return ++const_iterator(GetRoot()); } const_iterator cend() const { return const_iterator(); } // Traverse the dominator tree in a depth first post-order. // The pseudo-block is ignored. post_iterator post_begin() { return post_iterator::begin(GetRoot()); } post_iterator post_end() { return post_iterator::end(GetRoot()); } const_post_iterator post_begin() const { return post_cbegin(); } const_post_iterator post_end() const { return post_cend(); } const_post_iterator post_cbegin() const { return const_post_iterator::begin(GetRoot()); } const_post_iterator post_cend() const { return const_post_iterator::end(GetRoot()); } roots_iterator roots_begin() { return roots_.begin(); } roots_iterator roots_end() { return roots_.end(); } roots_const_iterator roots_begin() const { return roots_cbegin(); } roots_const_iterator roots_end() const { return roots_cend(); } roots_const_iterator roots_cbegin() const { return roots_.begin(); } roots_const_iterator roots_cend() const { return roots_.end(); } // Get the unique root of the tree. // It is guaranteed to work on a dominator tree. // post-dominator might have a list. DominatorTreeNode* GetRoot() { assert(roots_.size() == 1); return *roots_.begin(); } const DominatorTreeNode* GetRoot() const { assert(roots_.size() == 1); return *roots_.begin(); } const DominatorTreeNodeList& Roots() const { return roots_; } // Dumps the tree in the graphvis dot format into the |out_stream|. void DumpTreeAsDot(std::ostream& out_stream) const; // Build the (post-)dominator tree for the given control flow graph // |cfg| and the function |f|. |f| must exist in the |cfg|. Any // existing data in the dominator tree will be overwritten void InitializeTree(const CFG& cfg, const Function* f); // Check if the basic block |a| dominates the basic block |b|. bool Dominates(const BasicBlock* a, const BasicBlock* b) const; // Check if the basic block id |a| dominates the basic block id |b|. bool Dominates(uint32_t a, uint32_t b) const; // Check if the dominator tree node |a| dominates the dominator tree node |b|. bool Dominates(const DominatorTreeNode* a, const DominatorTreeNode* b) const; // Check if the basic block |a| strictly dominates the basic block |b|. bool StrictlyDominates(const BasicBlock* a, const BasicBlock* b) const; // Check if the basic block id |a| strictly dominates the basic block id |b|. bool StrictlyDominates(uint32_t a, uint32_t b) const; // Check if the dominator tree node |a| strictly dominates the dominator tree // node |b|. bool StrictlyDominates(const DominatorTreeNode* a, const DominatorTreeNode* b) const; // Returns the immediate dominator of basic block |a|. BasicBlock* ImmediateDominator(const BasicBlock* A) const; // Returns the immediate dominator of basic block id |a|. BasicBlock* ImmediateDominator(uint32_t a) const; // Returns true if the basic block |a| is reachable by this tree. A node would // be unreachable if it cannot be reached by traversal from the start node or // for a postdominator tree, cannot be reached from the exit nodes. inline bool ReachableFromRoots(const BasicBlock* a) const { if (!a) return false; return ReachableFromRoots(a->id()); } // Returns true if the basic block id |a| is reachable by this tree. bool ReachableFromRoots(uint32_t a) const { return GetTreeNode(a) != nullptr; } // Returns true if this tree is a post dominator tree. bool IsPostDominator() const { return postdominator_; } // Clean up the tree. void ClearTree() { nodes_.clear(); roots_.clear(); } // Applies the std::function |func| to all nodes in the dominator tree. // Tree nodes are visited in a depth first pre-order. bool Visit(std::function func) { for (auto n : *this) { if (!func(&n)) return false; } return true; } // Applies the std::function |func| to all nodes in the dominator tree. // Tree nodes are visited in a depth first pre-order. bool Visit(std::function func) const { for (auto n : *this) { if (!func(&n)) return false; } return true; } // Applies the std::function |func| to all nodes in the dominator tree from // |node| downwards. The boolean return from |func| is used to determine // whether or not the children should also be traversed. Tree nodes are // visited in a depth first pre-order. void VisitChildrenIf(std::function func, iterator node) { if (func(&*node)) { for (auto n : *node) { VisitChildrenIf(func, n->df_begin()); } } } // Returns the DominatorTreeNode associated with the basic block |bb|. // If the |bb| is unknown to the dominator tree, it returns null. inline DominatorTreeNode* GetTreeNode(BasicBlock* bb) { return GetTreeNode(bb->id()); } // Returns the DominatorTreeNode associated with the basic block |bb|. // If the |bb| is unknown to the dominator tree, it returns null. inline const DominatorTreeNode* GetTreeNode(BasicBlock* bb) const { return GetTreeNode(bb->id()); } // Returns the DominatorTreeNode associated with the basic block id |id|. // If the id |id| is unknown to the dominator tree, it returns null. inline DominatorTreeNode* GetTreeNode(uint32_t id) { DominatorTreeNodeMap::iterator node_iter = nodes_.find(id); if (node_iter == nodes_.end()) { return nullptr; } return &node_iter->second; } // Returns the DominatorTreeNode associated with the basic block id |id|. // If the id |id| is unknown to the dominator tree, it returns null. inline const DominatorTreeNode* GetTreeNode(uint32_t id) const { DominatorTreeNodeMap::const_iterator node_iter = nodes_.find(id); if (node_iter == nodes_.end()) { return nullptr; } return &node_iter->second; } // Adds the basic block |bb| to the tree structure if it doesn't already // exist. DominatorTreeNode* GetOrInsertNode(BasicBlock* bb); // Recomputes the DF numbering of the tree. void ResetDFNumbering(); private: // Wrapper function which gets the list of pairs of each BasicBlocks to its // immediately dominating BasicBlock and stores the result in the edges // parameter. // // The |edges| vector will contain the dominator tree as pairs of nodes. // The first node in the pair is a node in the graph. The second node in the // pair is its immediate dominator. // The root of the tree has themself as immediate dominator. void GetDominatorEdges( const Function* f, const BasicBlock* dummy_start_node, std::vector>* edges); // The roots of the tree. std::vector roots_; // Pairs each basic block id to the tree node containing that basic block. DominatorTreeNodeMap nodes_; // True if this is a post dominator tree. bool postdominator_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_DOMINATOR_TREE_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/eliminate_dead_constant_pass.cpp000066400000000000000000000071661475742701700272340ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/eliminate_dead_constant_pass.h" #include #include #include #include #include "source/opt/def_use_manager.h" #include "source/opt/log.h" #include "source/opt/reflect.h" namespace spvtools { namespace opt { Pass::Status EliminateDeadConstantPass::Process() { std::unordered_set working_list; // Traverse all the instructions to get the initial set of dead constants as // working list and count number of real uses for constants. Uses in // annotation instructions do not count. std::unordered_map use_counts; std::vector constants = context()->GetConstants(); for (auto* c : constants) { uint32_t const_id = c->result_id(); size_t count = 0; context()->get_def_use_mgr()->ForEachUse( const_id, [&count](Instruction* user, uint32_t index) { (void)index; spv::Op op = user->opcode(); if (!(IsAnnotationInst(op) || IsDebug1Inst(op) || IsDebug2Inst(op) || IsDebug3Inst(op))) { ++count; } }); use_counts[c] = count; if (!count) { working_list.insert(c); } } // Start from the constants with 0 uses, back trace through the def-use chain // to find all dead constants. std::unordered_set dead_consts; while (!working_list.empty()) { Instruction* inst = *working_list.begin(); // Back propagate if the instruction contains IDs in its operands. switch (inst->opcode()) { case spv::Op::OpConstantComposite: case spv::Op::OpSpecConstantComposite: case spv::Op::OpSpecConstantOp: for (uint32_t i = 0; i < inst->NumInOperands(); i++) { // SpecConstantOp instruction contains 'opcode' as its operand. Need // to exclude such operands when decreasing uses. if (inst->GetInOperand(i).type != SPV_OPERAND_TYPE_ID) { continue; } uint32_t operand_id = inst->GetSingleWordInOperand(i); Instruction* def_inst = context()->get_def_use_mgr()->GetDef(operand_id); // If the use_count does not have any count for the def_inst, // def_inst must not be a constant, and should be ignored here. if (!use_counts.count(def_inst)) { continue; } // The number of uses should never be less then 0, so it can not be // less than 1 before it decreases. SPIRV_ASSERT(consumer(), use_counts[def_inst] > 0); --use_counts[def_inst]; if (!use_counts[def_inst]) { working_list.insert(def_inst); } } break; default: break; } dead_consts.insert(inst); working_list.erase(inst); } // Turn all dead instructions and uses of them to nop for (auto* dc : dead_consts) { context()->KillDef(dc->result_id()); } return dead_consts.empty() ? Status::SuccessWithoutChange : Status::SuccessWithChange; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/eliminate_dead_constant_pass.h000066400000000000000000000021531475742701700266700ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_ELIMINATE_DEAD_CONSTANT_PASS_H_ #define SOURCE_OPT_ELIMINATE_DEAD_CONSTANT_PASS_H_ #include "source/opt/ir_context.h" #include "source/opt/module.h" #include "source/opt/pass.h" namespace spvtools { namespace opt { // See optimizer.hpp for documentation. class EliminateDeadConstantPass : public Pass { public: const char* name() const override { return "eliminate-dead-const"; } Status Process() override; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_ELIMINATE_DEAD_CONSTANT_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/eliminate_dead_functions_pass.cpp000066400000000000000000000031561475742701700274060ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/eliminate_dead_functions_pass.h" #include "source/opt/eliminate_dead_functions_util.h" #include #include "source/opt/ir_context.h" namespace spvtools { namespace opt { Pass::Status EliminateDeadFunctionsPass::Process() { // Identify live functions first. Those that are not live // are dead. std::unordered_set live_function_set; ProcessFunction mark_live = [&live_function_set](Function* fp) { live_function_set.insert(fp); return false; }; context()->ProcessReachableCallTree(mark_live); bool modified = false; for (auto funcIter = get_module()->begin(); funcIter != get_module()->end();) { if (live_function_set.count(&*funcIter) == 0) { modified = true; funcIter = eliminatedeadfunctionsutil::EliminateFunction(context(), &funcIter); } else { ++funcIter; } } return modified ? Pass::Status::SuccessWithChange : Pass::Status::SuccessWithoutChange; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/eliminate_dead_functions_pass.h000066400000000000000000000026001475742701700270440ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_ELIMINATE_DEAD_FUNCTIONS_PASS_H_ #define SOURCE_OPT_ELIMINATE_DEAD_FUNCTIONS_PASS_H_ #include "source/opt/def_use_manager.h" #include "source/opt/function.h" #include "source/opt/mem_pass.h" #include "source/opt/module.h" namespace spvtools { namespace opt { // See optimizer.hpp for documentation. class EliminateDeadFunctionsPass : public MemPass { public: const char* name() const override { return "eliminate-dead-functions"; } Status Process() override; IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisDefUse | IRContext::kAnalysisConstants | IRContext::kAnalysisTypes; } private: void EliminateFunction(Function* func); }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_ELIMINATE_DEAD_FUNCTIONS_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/eliminate_dead_functions_util.cpp000066400000000000000000000047761475742701700274260ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "eliminate_dead_functions_util.h" namespace spvtools { namespace opt { namespace eliminatedeadfunctionsutil { Module::iterator EliminateFunction(IRContext* context, Module::iterator* func_iter) { bool first_func = *func_iter == context->module()->begin(); bool seen_func_end = false; std::unordered_set to_kill; (*func_iter) ->ForEachInst( [context, first_func, func_iter, &seen_func_end, &to_kill](Instruction* inst) { if (inst->opcode() == spv::Op::OpFunctionEnd) { seen_func_end = true; } // Move non-semantic instructions to the previous function or // global values if this is the first function. if (seen_func_end && inst->opcode() == spv::Op::OpExtInst) { assert(inst->IsNonSemanticInstruction()); if (to_kill.find(inst) != to_kill.end()) return; std::unique_ptr clone(inst->Clone(context)); // Clear uses of "inst" to in case this moves a dependent chain of // instructions. context->get_def_use_mgr()->ClearInst(inst); context->AnalyzeDefUse(clone.get()); if (first_func) { context->AddGlobalValue(std::move(clone)); } else { auto prev_func_iter = *func_iter; --prev_func_iter; prev_func_iter->AddNonSemanticInstruction(std::move(clone)); } inst->ToNop(); } else if (to_kill.find(inst) == to_kill.end()) { context->CollectNonSemanticTree(inst, &to_kill); context->KillInst(inst); } }, true, true); for (auto* dead : to_kill) { context->KillInst(dead); } return func_iter->Erase(); } } // namespace eliminatedeadfunctionsutil } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/eliminate_dead_functions_util.h000066400000000000000000000024401475742701700270550ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_ELIMINATE_DEAD_FUNCTIONS_UTIL_H_ #define SOURCE_OPT_ELIMINATE_DEAD_FUNCTIONS_UTIL_H_ #include "source/opt/ir_context.h" namespace spvtools { namespace opt { // Provides functionality for eliminating functions that are not needed, for use // by various analyses and passes. namespace eliminatedeadfunctionsutil { // Removes all of the function's instructions, removes the function from the // module, and returns the next iterator. Module::iterator EliminateFunction(IRContext* context, Module::iterator* func_iter); } // namespace eliminatedeadfunctionsutil } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_ELIMINATE_DEAD_FUNCTIONS_UTIL_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/eliminate_dead_io_components_pass.cpp000066400000000000000000000255571475742701700302630ustar00rootroot00000000000000// Copyright (c) 2022 The Khronos Group Inc. // Copyright (c) 2022 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/eliminate_dead_io_components_pass.h" #include #include "source/opt/instruction.h" #include "source/opt/ir_context.h" #include "source/util/bit_vector.h" namespace spvtools { namespace opt { namespace { constexpr uint32_t kAccessChainBaseInIdx = 0; constexpr uint32_t kAccessChainIndex0InIdx = 1; constexpr uint32_t kAccessChainIndex1InIdx = 2; constexpr uint32_t kConstantValueInIdx = 0; } // namespace Pass::Status EliminateDeadIOComponentsPass::Process() { // Only process input and output variables if (elim_sclass_ != spv::StorageClass::Input && elim_sclass_ != spv::StorageClass::Output) { if (consumer()) { std::string message = "EliminateDeadIOComponentsPass only valid for input and output " "variables."; consumer()(SPV_MSG_ERROR, 0, {0, 0, 0}, message.c_str()); } return Status::Failure; } // If safe mode, only process Input variables in vertex shader const auto stage = context()->GetStage(); if (safe_mode_ && !(stage == spv::ExecutionModel::Vertex && elim_sclass_ == spv::StorageClass::Input)) return Status::SuccessWithoutChange; // Current functionality assumes shader capability. if (!context()->get_feature_mgr()->HasCapability(spv::Capability::Shader)) return Status::SuccessWithoutChange; // Current functionality assumes vert, frag, tesc, tese or geom shader. // TODO(issue #4988): Add GLCompute. if (stage != spv::ExecutionModel::Vertex && stage != spv::ExecutionModel::Fragment && stage != spv::ExecutionModel::TessellationControl && stage != spv::ExecutionModel::TessellationEvaluation && stage != spv::ExecutionModel::Geometry) return Status::SuccessWithoutChange; analysis::DefUseManager* def_use_mgr = context()->get_def_use_mgr(); analysis::TypeManager* type_mgr = context()->get_type_mgr(); bool modified = false; std::vector vars_to_move; for (auto& var : context()->types_values()) { if (var.opcode() != spv::Op::OpVariable) { continue; } analysis::Type* var_type = type_mgr->GetType(var.type_id()); analysis::Pointer* ptr_type = var_type->AsPointer(); if (ptr_type == nullptr) { continue; } const auto sclass = ptr_type->storage_class(); if (sclass != elim_sclass_) { continue; } // For tesc, or input variables in tese or geom shaders, // there is a outer per-vertex-array that must be ignored // for the purposes of this analysis/optimization. Do the // analysis on the inner type in these cases. bool skip_first_index = false; auto core_type = ptr_type->pointee_type(); if (stage == spv::ExecutionModel::TessellationControl || (sclass == spv::StorageClass::Input && (stage == spv::ExecutionModel::TessellationEvaluation || stage == spv::ExecutionModel::Geometry))) { auto arr_type = core_type->AsArray(); if (!arr_type) continue; core_type = arr_type->element_type(); skip_first_index = true; } const analysis::Array* arr_type = core_type->AsArray(); if (arr_type != nullptr) { // Only process array if input of vertex shader, or output of // fragment shader. Otherwise, if one shader has a runtime index and the // other does not, interface incompatibility can occur. if (!((sclass == spv::StorageClass::Input && stage == spv::ExecutionModel::Vertex) || (sclass == spv::StorageClass::Output && stage == spv::ExecutionModel::Fragment))) continue; unsigned arr_len_id = arr_type->LengthId(); Instruction* arr_len_inst = def_use_mgr->GetDef(arr_len_id); if (arr_len_inst->opcode() != spv::Op::OpConstant) { continue; } // SPIR-V requires array size is >= 1, so this works for signed or // unsigned size. unsigned original_max = arr_len_inst->GetSingleWordInOperand(kConstantValueInIdx) - 1; unsigned max_idx = FindMaxIndex(var, original_max); if (max_idx != original_max) { ChangeArrayLength(var, max_idx + 1); vars_to_move.push_back(&var); modified = true; } continue; } const analysis::Struct* struct_type = core_type->AsStruct(); if (struct_type == nullptr) continue; const auto elt_types = struct_type->element_types(); unsigned original_max = static_cast(elt_types.size()) - 1; unsigned max_idx = FindMaxIndex(var, original_max, skip_first_index); if (max_idx != original_max) { ChangeIOVarStructLength(var, max_idx + 1); vars_to_move.push_back(&var); modified = true; } } // Move changed vars after their new type instruction to preserve backward // referencing. for (auto var : vars_to_move) { auto type_id = var->type_id(); auto type_inst = def_use_mgr->GetDef(type_id); var->RemoveFromList(); var->InsertAfter(type_inst); } return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } unsigned EliminateDeadIOComponentsPass::FindMaxIndex( const Instruction& var, const unsigned original_max, const bool skip_first_index) { unsigned max = 0; bool seen_non_const_ac = false; assert(var.opcode() == spv::Op::OpVariable && "must be variable"); context()->get_def_use_mgr()->WhileEachUser( var.result_id(), [&max, &seen_non_const_ac, var, skip_first_index, this](Instruction* use) { auto use_opcode = use->opcode(); if (use_opcode == spv::Op::OpLoad || use_opcode == spv::Op::OpStore || use_opcode == spv::Op::OpCopyMemory || use_opcode == spv::Op::OpCopyMemorySized || use_opcode == spv::Op::OpCopyObject) { seen_non_const_ac = true; return false; } if (use->opcode() != spv::Op::OpAccessChain && use->opcode() != spv::Op::OpInBoundsAccessChain) { return true; } // OpAccessChain with no indices currently not optimized if (use->NumInOperands() == 1 || (skip_first_index && use->NumInOperands() == 2)) { seen_non_const_ac = true; return false; } const unsigned base_id = use->GetSingleWordInOperand(kAccessChainBaseInIdx); USE_ASSERT(base_id == var.result_id() && "unexpected base"); const unsigned in_idx = skip_first_index ? kAccessChainIndex1InIdx : kAccessChainIndex0InIdx; const unsigned idx_id = use->GetSingleWordInOperand(in_idx); Instruction* idx_inst = context()->get_def_use_mgr()->GetDef(idx_id); if (idx_inst->opcode() != spv::Op::OpConstant) { seen_non_const_ac = true; return false; } unsigned value = idx_inst->GetSingleWordInOperand(kConstantValueInIdx); if (value > max) max = value; return true; }); return seen_non_const_ac ? original_max : max; } void EliminateDeadIOComponentsPass::ChangeArrayLength(Instruction& arr_var, unsigned length) { analysis::TypeManager* type_mgr = context()->get_type_mgr(); analysis::ConstantManager* const_mgr = context()->get_constant_mgr(); analysis::DefUseManager* def_use_mgr = context()->get_def_use_mgr(); analysis::Pointer* ptr_type = type_mgr->GetType(arr_var.type_id())->AsPointer(); const analysis::Array* arr_ty = ptr_type->pointee_type()->AsArray(); assert(arr_ty && "expecting array type"); uint32_t length_id = const_mgr->GetUIntConstId(length); analysis::Array new_arr_ty(arr_ty->element_type(), arr_ty->GetConstantLengthInfo(length_id, length)); analysis::Type* reg_new_arr_ty = type_mgr->GetRegisteredType(&new_arr_ty); analysis::Pointer new_ptr_ty(reg_new_arr_ty, ptr_type->storage_class()); analysis::Type* reg_new_ptr_ty = type_mgr->GetRegisteredType(&new_ptr_ty); uint32_t new_ptr_ty_id = type_mgr->GetTypeInstruction(reg_new_ptr_ty); arr_var.SetResultType(new_ptr_ty_id); def_use_mgr->AnalyzeInstUse(&arr_var); } void EliminateDeadIOComponentsPass::ChangeIOVarStructLength(Instruction& io_var, unsigned length) { analysis::TypeManager* type_mgr = context()->get_type_mgr(); analysis::Pointer* ptr_type = type_mgr->GetType(io_var.type_id())->AsPointer(); auto core_type = ptr_type->pointee_type(); // Check for per-vertex-array of struct from tesc, tese and geom and grab // embedded struct type. const auto arr_type = core_type->AsArray(); if (arr_type) core_type = arr_type->element_type(); const analysis::Struct* struct_ty = core_type->AsStruct(); assert(struct_ty && "expecting struct type"); const auto orig_elt_types = struct_ty->element_types(); std::vector new_elt_types; for (unsigned u = 0; u < length; ++u) new_elt_types.push_back(orig_elt_types[u]); analysis::Struct new_struct_ty(new_elt_types); uint32_t old_struct_ty_id = type_mgr->GetTypeInstruction(struct_ty); std::vector decorations = context()->get_decoration_mgr()->GetDecorationsFor(old_struct_ty_id, true); for (auto dec : decorations) { if (dec->opcode() == spv::Op::OpMemberDecorate) { uint32_t midx = dec->GetSingleWordInOperand(1); if (midx >= length) continue; } type_mgr->AttachDecoration(*dec, &new_struct_ty); } // Clone name instructions for new struct type analysis::Type* reg_new_str_ty = type_mgr->GetRegisteredType(&new_struct_ty); uint32_t new_struct_ty_id = type_mgr->GetTypeInstruction(reg_new_str_ty); context()->CloneNames(old_struct_ty_id, new_struct_ty_id, length); // Attach new type to var analysis::Type* reg_new_var_ty = reg_new_str_ty; if (arr_type) { analysis::Array new_arr_ty(reg_new_var_ty, arr_type->length_info()); reg_new_var_ty = type_mgr->GetRegisteredType(&new_arr_ty); } analysis::Pointer new_ptr_ty(reg_new_var_ty, elim_sclass_); analysis::Type* reg_new_ptr_ty = type_mgr->GetRegisteredType(&new_ptr_ty); uint32_t new_ptr_ty_id = type_mgr->GetTypeInstruction(reg_new_ptr_ty); io_var.SetResultType(new_ptr_ty_id); analysis::DefUseManager* def_use_mgr = context()->get_def_use_mgr(); def_use_mgr->AnalyzeInstUse(&io_var); } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/eliminate_dead_io_components_pass.h000066400000000000000000000054451475742701700277220ustar00rootroot00000000000000// Copyright (c) 2022 The Khronos Group Inc. // Copyright (c) 2022 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_ELIMINATE_DEAD_INPUT_COMPONENTS_H_ #define SOURCE_OPT_ELIMINATE_DEAD_INPUT_COMPONENTS_H_ #include #include "source/opt/ir_context.h" #include "source/opt/module.h" #include "source/opt/pass.h" namespace spvtools { namespace opt { // See optimizer.hpp for documentation. class EliminateDeadIOComponentsPass : public Pass { public: explicit EliminateDeadIOComponentsPass(spv::StorageClass elim_sclass, bool safe_mode = true) : elim_sclass_(elim_sclass), safe_mode_(safe_mode) {} const char* name() const override { return "eliminate-dead-input-components"; } Status Process() override; // Return the mask of preserved Analyses. IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisCombinators | IRContext::kAnalysisCFG | IRContext::kAnalysisDominatorAnalysis | IRContext::kAnalysisLoopAnalysis | IRContext::kAnalysisNameMap | IRContext::kAnalysisConstants | IRContext::kAnalysisTypes; } private: // Find the max constant used to index the variable declared by |var| // through OpAccessChain or OpInBoundsAccessChain. If any non-constant // indices or non-Op*AccessChain use of |var|, return |original_max|. unsigned FindMaxIndex(const Instruction& var, const unsigned original_max, const bool skip_first_index = false); // Change the length of the array |inst| to |length| void ChangeArrayLength(Instruction& inst, unsigned length); // Change the length of the struct in |io_var| to |length|. |io_var| // is either the struct or a per-vertex-array of the struct. void ChangeIOVarStructLength(Instruction& io_var, unsigned length); // Storage class to be optimized. Must be Input or Output. spv::StorageClass elim_sclass_; // Only make changes that will not cause interface incompatibility if done // standalone. Currently this is only Input variables in vertex shaders. bool safe_mode_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_ELIMINATE_DEAD_INPUT_COMPONENTS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/eliminate_dead_members_pass.cpp000066400000000000000000000611671475742701700270360ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/eliminate_dead_members_pass.h" #include "ir_builder.h" #include "source/opt/ir_context.h" namespace spvtools { namespace opt { namespace { constexpr uint32_t kRemovedMember = 0xFFFFFFFF; constexpr uint32_t kSpecConstOpOpcodeIdx = 0; constexpr uint32_t kArrayElementTypeIdx = 0; } // namespace Pass::Status EliminateDeadMembersPass::Process() { if (!context()->get_feature_mgr()->HasCapability(spv::Capability::Shader)) return Status::SuccessWithoutChange; FindLiveMembers(); if (RemoveDeadMembers()) { return Status::SuccessWithChange; } return Status::SuccessWithoutChange; } void EliminateDeadMembersPass::FindLiveMembers() { // Until we have implemented the rewriting of OpSpecConsantOp instructions, // we have to mark them as fully used just to be safe. for (auto& inst : get_module()->types_values()) { if (inst.opcode() == spv::Op::OpSpecConstantOp) { switch (spv::Op(inst.GetSingleWordInOperand(kSpecConstOpOpcodeIdx))) { case spv::Op::OpCompositeExtract: MarkMembersAsLiveForExtract(&inst); break; case spv::Op::OpCompositeInsert: // Nothing specific to do. break; case spv::Op::OpAccessChain: case spv::Op::OpInBoundsAccessChain: case spv::Op::OpPtrAccessChain: case spv::Op::OpInBoundsPtrAccessChain: assert(false && "Not implemented yet."); break; default: break; } } else if (inst.opcode() == spv::Op::OpVariable) { switch (spv::StorageClass(inst.GetSingleWordInOperand(0))) { case spv::StorageClass::Input: case spv::StorageClass::Output: MarkPointeeTypeAsFullUsed(inst.type_id()); break; default: // Ignore structured buffers as layout(offset) qualifiers cannot be // applied to structure fields if (inst.IsVulkanStorageBufferVariable()) MarkPointeeTypeAsFullUsed(inst.type_id()); break; } } else if (inst.opcode() == spv::Op::OpTypePointer) { uint32_t storage_class = inst.GetSingleWordInOperand(0); if (storage_class == uint32_t(spv::StorageClass::PhysicalStorageBuffer)) { MarkTypeAsFullyUsed(inst.GetSingleWordInOperand(1)); } } } for (const Function& func : *get_module()) { FindLiveMembers(func); } } void EliminateDeadMembersPass::FindLiveMembers(const Function& function) { function.ForEachInst( [this](const Instruction* inst) { FindLiveMembers(inst); }); } void EliminateDeadMembersPass::FindLiveMembers(const Instruction* inst) { switch (inst->opcode()) { case spv::Op::OpStore: MarkMembersAsLiveForStore(inst); break; case spv::Op::OpCopyMemory: case spv::Op::OpCopyMemorySized: MarkMembersAsLiveForCopyMemory(inst); break; case spv::Op::OpCompositeExtract: MarkMembersAsLiveForExtract(inst); break; case spv::Op::OpAccessChain: case spv::Op::OpInBoundsAccessChain: case spv::Op::OpPtrAccessChain: case spv::Op::OpInBoundsPtrAccessChain: MarkMembersAsLiveForAccessChain(inst); break; case spv::Op::OpReturnValue: // This should be an issue only if we are returning from the entry point. // However, for now I will keep it more conservative because functions are // often inlined leaving only the entry points. MarkOperandTypeAsFullyUsed(inst, 0); break; case spv::Op::OpArrayLength: MarkMembersAsLiveForArrayLength(inst); break; case spv::Op::OpLoad: case spv::Op::OpCompositeInsert: case spv::Op::OpCompositeConstruct: break; default: // This path is here for safety. All instructions that can reference // structs in a function body should be handled above. However, this will // keep the pass valid, but not optimal, as new instructions get added // or if something was missed. MarkStructOperandsAsFullyUsed(inst); break; } } void EliminateDeadMembersPass::MarkMembersAsLiveForStore( const Instruction* inst) { // We should only have to mark the members as live if the store is to // memory that is read outside of the shader. Other passes can remove all // store to memory that is not visible outside of the shader, so we do not // complicate the code for now. assert(inst->opcode() == spv::Op::OpStore); uint32_t object_id = inst->GetSingleWordInOperand(1); Instruction* object_inst = context()->get_def_use_mgr()->GetDef(object_id); uint32_t object_type_id = object_inst->type_id(); MarkTypeAsFullyUsed(object_type_id); } void EliminateDeadMembersPass::MarkTypeAsFullyUsed(uint32_t type_id) { Instruction* type_inst = get_def_use_mgr()->GetDef(type_id); assert(type_inst != nullptr); switch (type_inst->opcode()) { case spv::Op::OpTypeStruct: // Mark every member and its type as fully used. for (uint32_t i = 0; i < type_inst->NumInOperands(); ++i) { used_members_[type_id].insert(i); MarkTypeAsFullyUsed(type_inst->GetSingleWordInOperand(i)); } break; case spv::Op::OpTypeArray: case spv::Op::OpTypeRuntimeArray: MarkTypeAsFullyUsed( type_inst->GetSingleWordInOperand(kArrayElementTypeIdx)); break; default: break; } } void EliminateDeadMembersPass::MarkPointeeTypeAsFullUsed(uint32_t ptr_type_id) { Instruction* ptr_type_inst = get_def_use_mgr()->GetDef(ptr_type_id); assert(ptr_type_inst->opcode() == spv::Op::OpTypePointer); MarkTypeAsFullyUsed(ptr_type_inst->GetSingleWordInOperand(1)); } void EliminateDeadMembersPass::MarkMembersAsLiveForCopyMemory( const Instruction* inst) { uint32_t target_id = inst->GetSingleWordInOperand(0); Instruction* target_inst = get_def_use_mgr()->GetDef(target_id); uint32_t pointer_type_id = target_inst->type_id(); Instruction* pointer_type_inst = get_def_use_mgr()->GetDef(pointer_type_id); uint32_t type_id = pointer_type_inst->GetSingleWordInOperand(1); MarkTypeAsFullyUsed(type_id); } void EliminateDeadMembersPass::MarkMembersAsLiveForExtract( const Instruction* inst) { assert(inst->opcode() == spv::Op::OpCompositeExtract || (inst->opcode() == spv::Op::OpSpecConstantOp && spv::Op(inst->GetSingleWordInOperand(kSpecConstOpOpcodeIdx)) == spv::Op::OpCompositeExtract)); uint32_t first_operand = (inst->opcode() == spv::Op::OpSpecConstantOp ? 1 : 0); uint32_t composite_id = inst->GetSingleWordInOperand(first_operand); Instruction* composite_inst = get_def_use_mgr()->GetDef(composite_id); uint32_t type_id = composite_inst->type_id(); for (uint32_t i = first_operand + 1; i < inst->NumInOperands(); ++i) { Instruction* type_inst = get_def_use_mgr()->GetDef(type_id); uint32_t member_idx = inst->GetSingleWordInOperand(i); switch (type_inst->opcode()) { case spv::Op::OpTypeStruct: used_members_[type_id].insert(member_idx); type_id = type_inst->GetSingleWordInOperand(member_idx); break; case spv::Op::OpTypeArray: case spv::Op::OpTypeRuntimeArray: case spv::Op::OpTypeVector: case spv::Op::OpTypeMatrix: case spv::Op::OpTypeCooperativeMatrixNV: case spv::Op::OpTypeCooperativeMatrixKHR: case spv::Op::OpTypeCooperativeVectorNV: type_id = type_inst->GetSingleWordInOperand(0); break; default: assert(false); } } } void EliminateDeadMembersPass::MarkMembersAsLiveForAccessChain( const Instruction* inst) { assert(inst->opcode() == spv::Op::OpAccessChain || inst->opcode() == spv::Op::OpInBoundsAccessChain || inst->opcode() == spv::Op::OpPtrAccessChain || inst->opcode() == spv::Op::OpInBoundsPtrAccessChain); uint32_t pointer_id = inst->GetSingleWordInOperand(0); Instruction* pointer_inst = get_def_use_mgr()->GetDef(pointer_id); uint32_t pointer_type_id = pointer_inst->type_id(); Instruction* pointer_type_inst = get_def_use_mgr()->GetDef(pointer_type_id); uint32_t type_id = pointer_type_inst->GetSingleWordInOperand(1); analysis::ConstantManager* const_mgr = context()->get_constant_mgr(); // For a pointer access chain, we need to skip the |element| index. It is not // a reference to the member of a struct, and it does not change the type. uint32_t i = (inst->opcode() == spv::Op::OpAccessChain || inst->opcode() == spv::Op::OpInBoundsAccessChain ? 1 : 2); for (; i < inst->NumInOperands(); ++i) { Instruction* type_inst = get_def_use_mgr()->GetDef(type_id); switch (type_inst->opcode()) { case spv::Op::OpTypeStruct: { const analysis::IntConstant* member_idx = const_mgr->FindDeclaredConstant(inst->GetSingleWordInOperand(i)) ->AsIntConstant(); assert(member_idx); uint32_t index = static_cast(member_idx->GetZeroExtendedValue()); used_members_[type_id].insert(index); type_id = type_inst->GetSingleWordInOperand(index); } break; case spv::Op::OpTypeArray: case spv::Op::OpTypeRuntimeArray: case spv::Op::OpTypeVector: case spv::Op::OpTypeMatrix: case spv::Op::OpTypeCooperativeMatrixNV: case spv::Op::OpTypeCooperativeMatrixKHR: case spv::Op::OpTypeCooperativeVectorNV: type_id = type_inst->GetSingleWordInOperand(0); break; default: assert(false); } } } void EliminateDeadMembersPass::MarkOperandTypeAsFullyUsed( const Instruction* inst, uint32_t in_idx) { uint32_t op_id = inst->GetSingleWordInOperand(in_idx); Instruction* op_inst = get_def_use_mgr()->GetDef(op_id); MarkTypeAsFullyUsed(op_inst->type_id()); } void EliminateDeadMembersPass::MarkMembersAsLiveForArrayLength( const Instruction* inst) { assert(inst->opcode() == spv::Op::OpArrayLength); uint32_t object_id = inst->GetSingleWordInOperand(0); Instruction* object_inst = get_def_use_mgr()->GetDef(object_id); uint32_t pointer_type_id = object_inst->type_id(); Instruction* pointer_type_inst = get_def_use_mgr()->GetDef(pointer_type_id); uint32_t type_id = pointer_type_inst->GetSingleWordInOperand(1); used_members_[type_id].insert(inst->GetSingleWordInOperand(1)); } bool EliminateDeadMembersPass::RemoveDeadMembers() { bool modified = false; // First update all of the OpTypeStruct instructions. get_module()->ForEachInst([&modified, this](Instruction* inst) { switch (inst->opcode()) { case spv::Op::OpTypeStruct: modified |= UpdateOpTypeStruct(inst); break; default: break; } }); // Now update all of the instructions that reference the OpTypeStructs. get_module()->ForEachInst([&modified, this](Instruction* inst) { switch (inst->opcode()) { case spv::Op::OpMemberName: modified |= UpdateOpMemberNameOrDecorate(inst); break; case spv::Op::OpMemberDecorate: modified |= UpdateOpMemberNameOrDecorate(inst); break; case spv::Op::OpGroupMemberDecorate: modified |= UpdateOpGroupMemberDecorate(inst); break; case spv::Op::OpSpecConstantComposite: case spv::Op::OpConstantComposite: case spv::Op::OpCompositeConstruct: modified |= UpdateConstantComposite(inst); break; case spv::Op::OpAccessChain: case spv::Op::OpInBoundsAccessChain: case spv::Op::OpPtrAccessChain: case spv::Op::OpInBoundsPtrAccessChain: modified |= UpdateAccessChain(inst); break; case spv::Op::OpCompositeExtract: modified |= UpdateCompsiteExtract(inst); break; case spv::Op::OpCompositeInsert: modified |= UpdateCompositeInsert(inst); break; case spv::Op::OpArrayLength: modified |= UpdateOpArrayLength(inst); break; case spv::Op::OpSpecConstantOp: switch (spv::Op(inst->GetSingleWordInOperand(kSpecConstOpOpcodeIdx))) { case spv::Op::OpCompositeExtract: modified |= UpdateCompsiteExtract(inst); break; case spv::Op::OpCompositeInsert: modified |= UpdateCompositeInsert(inst); break; case spv::Op::OpAccessChain: case spv::Op::OpInBoundsAccessChain: case spv::Op::OpPtrAccessChain: case spv::Op::OpInBoundsPtrAccessChain: assert(false && "Not implemented yet."); break; default: break; } break; default: break; } }); return modified; } bool EliminateDeadMembersPass::UpdateOpTypeStruct(Instruction* inst) { assert(inst->opcode() == spv::Op::OpTypeStruct); const auto& live_members = used_members_[inst->result_id()]; if (live_members.size() == inst->NumInOperands()) { return false; } Instruction::OperandList new_operands; for (uint32_t idx : live_members) { new_operands.emplace_back(inst->GetInOperand(idx)); } inst->SetInOperands(std::move(new_operands)); context()->UpdateDefUse(inst); return true; } bool EliminateDeadMembersPass::UpdateOpMemberNameOrDecorate(Instruction* inst) { assert(inst->opcode() == spv::Op::OpMemberName || inst->opcode() == spv::Op::OpMemberDecorate); uint32_t type_id = inst->GetSingleWordInOperand(0); auto live_members = used_members_.find(type_id); if (live_members == used_members_.end()) { return false; } uint32_t orig_member_idx = inst->GetSingleWordInOperand(1); uint32_t new_member_idx = GetNewMemberIndex(type_id, orig_member_idx); if (new_member_idx == kRemovedMember) { context()->KillInst(inst); return true; } if (new_member_idx == orig_member_idx) { return false; } inst->SetInOperand(1, {new_member_idx}); return true; } bool EliminateDeadMembersPass::UpdateOpGroupMemberDecorate(Instruction* inst) { assert(inst->opcode() == spv::Op::OpGroupMemberDecorate); bool modified = false; Instruction::OperandList new_operands; new_operands.emplace_back(inst->GetInOperand(0)); for (uint32_t i = 1; i < inst->NumInOperands(); i += 2) { uint32_t type_id = inst->GetSingleWordInOperand(i); uint32_t member_idx = inst->GetSingleWordInOperand(i + 1); uint32_t new_member_idx = GetNewMemberIndex(type_id, member_idx); if (new_member_idx == kRemovedMember) { modified = true; continue; } new_operands.emplace_back(inst->GetOperand(i)); if (new_member_idx != member_idx) { new_operands.emplace_back( Operand({SPV_OPERAND_TYPE_LITERAL_INTEGER, {new_member_idx}})); modified = true; } else { new_operands.emplace_back(inst->GetOperand(i + 1)); } } if (!modified) { return false; } if (new_operands.size() == 1) { context()->KillInst(inst); return true; } inst->SetInOperands(std::move(new_operands)); context()->UpdateDefUse(inst); return true; } bool EliminateDeadMembersPass::UpdateConstantComposite(Instruction* inst) { assert(inst->opcode() == spv::Op::OpSpecConstantComposite || inst->opcode() == spv::Op::OpConstantComposite || inst->opcode() == spv::Op::OpCompositeConstruct); uint32_t type_id = inst->type_id(); bool modified = false; Instruction::OperandList new_operands; for (uint32_t i = 0; i < inst->NumInOperands(); ++i) { uint32_t new_idx = GetNewMemberIndex(type_id, i); if (new_idx == kRemovedMember) { modified = true; } else { new_operands.emplace_back(inst->GetInOperand(i)); } } inst->SetInOperands(std::move(new_operands)); context()->UpdateDefUse(inst); return modified; } bool EliminateDeadMembersPass::UpdateAccessChain(Instruction* inst) { assert(inst->opcode() == spv::Op::OpAccessChain || inst->opcode() == spv::Op::OpInBoundsAccessChain || inst->opcode() == spv::Op::OpPtrAccessChain || inst->opcode() == spv::Op::OpInBoundsPtrAccessChain); uint32_t pointer_id = inst->GetSingleWordInOperand(0); Instruction* pointer_inst = get_def_use_mgr()->GetDef(pointer_id); uint32_t pointer_type_id = pointer_inst->type_id(); Instruction* pointer_type_inst = get_def_use_mgr()->GetDef(pointer_type_id); uint32_t type_id = pointer_type_inst->GetSingleWordInOperand(1); analysis::ConstantManager* const_mgr = context()->get_constant_mgr(); Instruction::OperandList new_operands; bool modified = false; new_operands.emplace_back(inst->GetInOperand(0)); // For pointer access chains we want to copy the element operand. if (inst->opcode() == spv::Op::OpPtrAccessChain || inst->opcode() == spv::Op::OpInBoundsPtrAccessChain) { new_operands.emplace_back(inst->GetInOperand(1)); } for (uint32_t i = static_cast(new_operands.size()); i < inst->NumInOperands(); ++i) { Instruction* type_inst = get_def_use_mgr()->GetDef(type_id); switch (type_inst->opcode()) { case spv::Op::OpTypeStruct: { const analysis::IntConstant* member_idx = const_mgr->FindDeclaredConstant(inst->GetSingleWordInOperand(i)) ->AsIntConstant(); assert(member_idx); uint32_t orig_member_idx = static_cast(member_idx->GetZeroExtendedValue()); uint32_t new_member_idx = GetNewMemberIndex(type_id, orig_member_idx); assert(new_member_idx != kRemovedMember); if (orig_member_idx != new_member_idx) { InstructionBuilder ir_builder( context(), inst, IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); uint32_t const_id = ir_builder.GetUintConstant(new_member_idx)->result_id(); new_operands.emplace_back(Operand({SPV_OPERAND_TYPE_ID, {const_id}})); modified = true; } else { new_operands.emplace_back(inst->GetInOperand(i)); } // The type will have already been rewritten, so use the new member // index. type_id = type_inst->GetSingleWordInOperand(new_member_idx); } break; case spv::Op::OpTypeArray: case spv::Op::OpTypeRuntimeArray: case spv::Op::OpTypeVector: case spv::Op::OpTypeMatrix: case spv::Op::OpTypeCooperativeMatrixNV: case spv::Op::OpTypeCooperativeMatrixKHR: case spv::Op::OpTypeCooperativeVectorNV: new_operands.emplace_back(inst->GetInOperand(i)); type_id = type_inst->GetSingleWordInOperand(0); break; default: assert(false); break; } } if (!modified) { return false; } inst->SetInOperands(std::move(new_operands)); context()->UpdateDefUse(inst); return true; } uint32_t EliminateDeadMembersPass::GetNewMemberIndex(uint32_t type_id, uint32_t member_idx) { auto live_members = used_members_.find(type_id); if (live_members == used_members_.end()) { return member_idx; } auto current_member = live_members->second.find(member_idx); if (current_member == live_members->second.end()) { return kRemovedMember; } return static_cast( std::distance(live_members->second.begin(), current_member)); } bool EliminateDeadMembersPass::UpdateCompsiteExtract(Instruction* inst) { assert(inst->opcode() == spv::Op::OpCompositeExtract || (inst->opcode() == spv::Op::OpSpecConstantOp && spv::Op(inst->GetSingleWordInOperand(kSpecConstOpOpcodeIdx)) == spv::Op::OpCompositeExtract)); uint32_t first_operand = 0; if (inst->opcode() == spv::Op::OpSpecConstantOp) { first_operand = 1; } uint32_t object_id = inst->GetSingleWordInOperand(first_operand); Instruction* object_inst = get_def_use_mgr()->GetDef(object_id); uint32_t type_id = object_inst->type_id(); Instruction::OperandList new_operands; bool modified = false; for (uint32_t i = 0; i < first_operand + 1; i++) { new_operands.emplace_back(inst->GetInOperand(i)); } for (uint32_t i = first_operand + 1; i < inst->NumInOperands(); ++i) { uint32_t member_idx = inst->GetSingleWordInOperand(i); uint32_t new_member_idx = GetNewMemberIndex(type_id, member_idx); assert(new_member_idx != kRemovedMember); if (member_idx != new_member_idx) { modified = true; } new_operands.emplace_back( Operand({SPV_OPERAND_TYPE_LITERAL_INTEGER, {new_member_idx}})); Instruction* type_inst = get_def_use_mgr()->GetDef(type_id); switch (type_inst->opcode()) { case spv::Op::OpTypeStruct: // The type will have already been rewritten, so use the new member // index. type_id = type_inst->GetSingleWordInOperand(new_member_idx); break; case spv::Op::OpTypeArray: case spv::Op::OpTypeRuntimeArray: case spv::Op::OpTypeVector: case spv::Op::OpTypeMatrix: case spv::Op::OpTypeCooperativeMatrixNV: case spv::Op::OpTypeCooperativeMatrixKHR: case spv::Op::OpTypeCooperativeVectorNV: type_id = type_inst->GetSingleWordInOperand(0); break; default: assert(false); } } if (!modified) { return false; } inst->SetInOperands(std::move(new_operands)); context()->UpdateDefUse(inst); return true; } bool EliminateDeadMembersPass::UpdateCompositeInsert(Instruction* inst) { assert(inst->opcode() == spv::Op::OpCompositeInsert || (inst->opcode() == spv::Op::OpSpecConstantOp && spv::Op(inst->GetSingleWordInOperand(kSpecConstOpOpcodeIdx)) == spv::Op::OpCompositeInsert)); uint32_t first_operand = 0; if (inst->opcode() == spv::Op::OpSpecConstantOp) { first_operand = 1; } uint32_t composite_id = inst->GetSingleWordInOperand(first_operand + 1); Instruction* composite_inst = get_def_use_mgr()->GetDef(composite_id); uint32_t type_id = composite_inst->type_id(); Instruction::OperandList new_operands; bool modified = false; for (uint32_t i = 0; i < first_operand + 2; ++i) { new_operands.emplace_back(inst->GetInOperand(i)); } for (uint32_t i = first_operand + 2; i < inst->NumInOperands(); ++i) { uint32_t member_idx = inst->GetSingleWordInOperand(i); uint32_t new_member_idx = GetNewMemberIndex(type_id, member_idx); if (new_member_idx == kRemovedMember) { context()->KillInst(inst); return true; } if (member_idx != new_member_idx) { modified = true; } new_operands.emplace_back( Operand({SPV_OPERAND_TYPE_LITERAL_INTEGER, {new_member_idx}})); Instruction* type_inst = get_def_use_mgr()->GetDef(type_id); switch (type_inst->opcode()) { case spv::Op::OpTypeStruct: // The type will have already been rewritten, so use the new member // index. type_id = type_inst->GetSingleWordInOperand(new_member_idx); break; case spv::Op::OpTypeArray: case spv::Op::OpTypeRuntimeArray: case spv::Op::OpTypeVector: case spv::Op::OpTypeMatrix: case spv::Op::OpTypeCooperativeMatrixNV: case spv::Op::OpTypeCooperativeMatrixKHR: case spv::Op::OpTypeCooperativeVectorNV: type_id = type_inst->GetSingleWordInOperand(0); break; default: assert(false); } } if (!modified) { return false; } inst->SetInOperands(std::move(new_operands)); context()->UpdateDefUse(inst); return true; } bool EliminateDeadMembersPass::UpdateOpArrayLength(Instruction* inst) { uint32_t struct_id = inst->GetSingleWordInOperand(0); Instruction* struct_inst = get_def_use_mgr()->GetDef(struct_id); uint32_t pointer_type_id = struct_inst->type_id(); Instruction* pointer_type_inst = get_def_use_mgr()->GetDef(pointer_type_id); uint32_t type_id = pointer_type_inst->GetSingleWordInOperand(1); uint32_t member_idx = inst->GetSingleWordInOperand(1); uint32_t new_member_idx = GetNewMemberIndex(type_id, member_idx); assert(new_member_idx != kRemovedMember); if (member_idx == new_member_idx) { return false; } inst->SetInOperand(1, {new_member_idx}); context()->UpdateDefUse(inst); return true; } void EliminateDeadMembersPass::MarkStructOperandsAsFullyUsed( const Instruction* inst) { if (inst->type_id() != 0) { MarkTypeAsFullyUsed(inst->type_id()); } inst->ForEachInId([this](const uint32_t* id) { Instruction* instruction = get_def_use_mgr()->GetDef(*id); if (instruction->type_id() != 0) { MarkTypeAsFullyUsed(instruction->type_id()); } }); } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/eliminate_dead_members_pass.h000066400000000000000000000142251475742701700264740ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_ELIMINATE_DEAD_MEMBERS_PASS_H_ #define SOURCE_OPT_ELIMINATE_DEAD_MEMBERS_PASS_H_ #include "source/opt/def_use_manager.h" #include "source/opt/function.h" #include "source/opt/mem_pass.h" #include "source/opt/module.h" namespace spvtools { namespace opt { // Remove unused members from structures. The remaining members will remain at // the same offset. class EliminateDeadMembersPass : public MemPass { public: const char* name() const override { return "eliminate-dead-members"; } Status Process() override; IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisCombinators | IRContext::kAnalysisCFG | IRContext::kAnalysisDominatorAnalysis | IRContext::kAnalysisLoopAnalysis | IRContext::kAnalysisScalarEvolution | IRContext::kAnalysisRegisterPressure | IRContext::kAnalysisValueNumberTable | IRContext::kAnalysisStructuredCFG | IRContext::kAnalysisBuiltinVarId | IRContext::kAnalysisIdToFuncMapping; } private: // Populate |used_members_| with the member of structures that are live in the // current context. void FindLiveMembers(); // Add to |used_members_| the member of structures that are live in // |function|. void FindLiveMembers(const Function& function); // Add to |used_members_| the member of structures that are live in |inst|. void FindLiveMembers(const Instruction* inst); // Add to |used_members_| the members that are live in the |OpStore| // instruction |inst|. void MarkMembersAsLiveForStore(const Instruction* inst); // Add to |used_members_| the members that are live in the |OpCopyMemory*| // instruction |inst|. void MarkMembersAsLiveForCopyMemory(const Instruction* inst); // Add to |used_members_| the members that are live in the // |OpCompositeExtract| instruction |inst|. void MarkMembersAsLiveForExtract(const Instruction* inst); // Add to |used_members_| the members that are live in the |Op*AccessChain| // instruction |inst|. void MarkMembersAsLiveForAccessChain(const Instruction* inst); // Add the member referenced by the OpArrayLength instruction |inst| to // |uses_members_|. void MarkMembersAsLiveForArrayLength(const Instruction* inst); // Remove dead members from structs and updates any instructions that need to // be updated as a consequence. Return true if something changed. bool RemoveDeadMembers(); // Update |inst|, which must be an |OpMemberName| or |OpMemberDecorate| // instruction, so it references the correct member after the struct is // updated. Return true if something changed. bool UpdateOpMemberNameOrDecorate(Instruction* inst); // Update |inst|, which must be an |OpGroupMemberDecorate| instruction, so it // references the correct member after the struct is updated. Return true if // something changed. bool UpdateOpGroupMemberDecorate(Instruction* inst); // Update the |OpTypeStruct| instruction |inst| my removing the members that // are not live. Return true if something changed. bool UpdateOpTypeStruct(Instruction* inst); // Update the |OpConstantComposite| instruction |inst| to match the change // made to the type that was being generated. Return true if something // changed. bool UpdateConstantComposite(Instruction* inst); // Update the |Op*AccessChain| instruction |inst| to reference the correct // members. All members referenced in the access chain must be live. This // function must be called after the |OpTypeStruct| instruction for the type // has been updated. Return true if something changed. bool UpdateAccessChain(Instruction* inst); // Update the |OpCompositeExtract| instruction |inst| to reference the correct // members. All members referenced in the instruction must be live. This // function must be called after the |OpTypeStruct| instruction for the type // has been updated. Return true if something changed. bool UpdateCompsiteExtract(Instruction* inst); // Update the |OpCompositeInsert| instruction |inst| to reference the correct // members. If the member being inserted is not live, then |inst| is killed. // This function must be called after the |OpTypeStruct| instruction for the // type has been updated. Return true if something changed. bool UpdateCompositeInsert(Instruction* inst); // Update the |OpArrayLength| instruction |inst| to reference the correct // member. The member referenced in the instruction must be live. Return true // if something changed. bool UpdateOpArrayLength(Instruction* inst); // Add all of the members of type |type_id| and members of any subtypes to // |used_members_|. void MarkTypeAsFullyUsed(uint32_t type_id); // Add all of the members of the type of the operand |in_idx| in |inst| and // members of any subtypes to |uses_members_|. void MarkOperandTypeAsFullyUsed(const Instruction* inst, uint32_t in_idx); // Return the index of the member that use to be the |member_idx|th member of // |type_id|. If the member has been removed, |kRemovedMember| is returned. uint32_t GetNewMemberIndex(uint32_t type_id, uint32_t member_idx); // A map from a type id to a set of indices representing the members of the // type that are used, and must be kept. std::unordered_map> used_members_; void MarkStructOperandsAsFullyUsed(const Instruction* inst); void MarkPointeeTypeAsFullUsed(uint32_t ptr_type_id); }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_ELIMINATE_DEAD_MEMBERS_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/eliminate_dead_output_stores_pass.cpp000066400000000000000000000230351475742701700303330ustar00rootroot00000000000000// Copyright (c) 2022 The Khronos Group Inc. // Copyright (c) 2022 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/eliminate_dead_output_stores_pass.h" #include "source/opt/instruction.h" #include "source/opt/ir_context.h" namespace spvtools { namespace opt { namespace { constexpr uint32_t kDecorationLocationInIdx = 2; constexpr uint32_t kOpDecorateMemberMemberInIdx = 1; constexpr uint32_t kOpDecorateBuiltInLiteralInIdx = 2; constexpr uint32_t kOpDecorateMemberBuiltInLiteralInIdx = 3; constexpr uint32_t kOpAccessChainIdx0InIdx = 1; constexpr uint32_t kOpConstantValueInIdx = 0; } // namespace Pass::Status EliminateDeadOutputStoresPass::Process() { // Current functionality assumes shader capability if (!context()->get_feature_mgr()->HasCapability(spv::Capability::Shader)) return Status::SuccessWithoutChange; Pass::Status status = DoDeadOutputStoreElimination(); return status; } void EliminateDeadOutputStoresPass::InitializeElimination() { kill_list_.clear(); } bool EliminateDeadOutputStoresPass::IsLiveBuiltin(uint32_t bi) { return live_builtins_->find(bi) != live_builtins_->end(); } bool EliminateDeadOutputStoresPass::AnyLocsAreLive(uint32_t start, uint32_t count) { auto finish = start + count; for (uint32_t u = start; u < finish; ++u) { if (live_locs_->find(u) != live_locs_->end()) return true; } return false; } void EliminateDeadOutputStoresPass::KillAllStoresOfRef(Instruction* ref) { analysis::DefUseManager* def_use_mgr = context()->get_def_use_mgr(); if (ref->opcode() == spv::Op::OpStore) { kill_list_.push_back(ref); return; } assert((ref->opcode() == spv::Op::OpAccessChain || ref->opcode() == spv::Op::OpInBoundsAccessChain) && "unexpected use of output variable"); def_use_mgr->ForEachUser(ref, [this](Instruction* user) { if (user->opcode() == spv::Op::OpStore) kill_list_.push_back(user); }); } void EliminateDeadOutputStoresPass::KillAllDeadStoresOfLocRef( Instruction* ref, Instruction* var) { analysis::TypeManager* type_mgr = context()->get_type_mgr(); analysis::DecorationManager* deco_mgr = context()->get_decoration_mgr(); analysis::LivenessManager* live_mgr = context()->get_liveness_mgr(); // Find variable location if present. uint32_t start_loc = 0; auto var_id = var->result_id(); bool no_loc = deco_mgr->WhileEachDecoration( var_id, uint32_t(spv::Decoration::Location), [&start_loc](const Instruction& deco) { assert(deco.opcode() == spv::Op::OpDecorate && "unexpected decoration"); start_loc = deco.GetSingleWordInOperand(kDecorationLocationInIdx); return false; }); // Find patch decoration if present bool is_patch = !deco_mgr->WhileEachDecoration( var_id, uint32_t(spv::Decoration::Patch), [](const Instruction& deco) { if (deco.opcode() != spv::Op::OpDecorate) assert(false && "unexpected decoration"); return false; }); // Compute offset and final type of reference. If no location found // or any stored locations are live, return without removing stores. Instruction* ptr_type = get_def_use_mgr()->GetDef(var->type_id()); assert(ptr_type && "unexpected var type"); const uint32_t kPointerTypePointeeIdx = 1; uint32_t var_type_id = ptr_type->GetSingleWordInOperand(kPointerTypePointeeIdx); uint32_t ref_loc = start_loc; if (ref->opcode() == spv::Op::OpAccessChain || ref->opcode() == spv::Op::OpInBoundsAccessChain) { var_type_id = live_mgr->AnalyzeAccessChainLoc( ref, var_type_id, &ref_loc, &no_loc, is_patch, /* input */ false); } const analysis::Type* curr_type = type_mgr->GetType(var_type_id); if (no_loc || AnyLocsAreLive(ref_loc, live_mgr->GetLocSize(curr_type))) return; // Kill all stores based on this reference KillAllStoresOfRef(ref); } void EliminateDeadOutputStoresPass::KillAllDeadStoresOfBuiltinRef( Instruction* ref, Instruction* var) { auto deco_mgr = context()->get_decoration_mgr(); auto def_use_mgr = context()->get_def_use_mgr(); auto type_mgr = context()->get_type_mgr(); auto live_mgr = context()->get_liveness_mgr(); // Search for builtin decoration of base variable uint32_t builtin = uint32_t(spv::BuiltIn::Max); auto var_id = var->result_id(); (void)deco_mgr->WhileEachDecoration( var_id, uint32_t(spv::Decoration::BuiltIn), [&builtin](const Instruction& deco) { assert(deco.opcode() == spv::Op::OpDecorate && "unexpected decoration"); builtin = deco.GetSingleWordInOperand(kOpDecorateBuiltInLiteralInIdx); return false; }); // If analyzed builtin and not live, kill stores. if (builtin != uint32_t(spv::BuiltIn::Max)) { if (live_mgr->IsAnalyzedBuiltin(builtin) && !IsLiveBuiltin(builtin)) KillAllStoresOfRef(ref); return; } // Search for builtin decoration on indexed member auto ref_op = ref->opcode(); if (ref_op != spv::Op::OpAccessChain && ref_op != spv::Op::OpInBoundsAccessChain) { return; } uint32_t in_idx = kOpAccessChainIdx0InIdx; analysis::Type* var_type = type_mgr->GetType(var->type_id()); analysis::Pointer* ptr_type = var_type->AsPointer(); auto curr_type = ptr_type->pointee_type(); auto arr_type = curr_type->AsArray(); if (arr_type) { curr_type = arr_type->element_type(); ++in_idx; } auto str_type = curr_type->AsStruct(); auto str_type_id = type_mgr->GetId(str_type); auto member_idx_id = ref->GetSingleWordInOperand(in_idx); auto member_idx_inst = def_use_mgr->GetDef(member_idx_id); assert(member_idx_inst->opcode() == spv::Op::OpConstant && "unexpected non-constant index"); auto ac_idx = member_idx_inst->GetSingleWordInOperand(kOpConstantValueInIdx); (void)deco_mgr->WhileEachDecoration( str_type_id, uint32_t(spv::Decoration::BuiltIn), [ac_idx, &builtin](const Instruction& deco) { assert(deco.opcode() == spv::Op::OpMemberDecorate && "unexpected decoration"); auto deco_idx = deco.GetSingleWordInOperand(kOpDecorateMemberMemberInIdx); if (deco_idx == ac_idx) { builtin = deco.GetSingleWordInOperand(kOpDecorateMemberBuiltInLiteralInIdx); return false; } return true; }); assert(builtin != uint32_t(spv::BuiltIn::Max) && "builtin not found"); // If analyzed builtin and not live, kill stores. if (live_mgr->IsAnalyzedBuiltin(builtin) && !IsLiveBuiltin(builtin)) KillAllStoresOfRef(ref); } Pass::Status EliminateDeadOutputStoresPass::DoDeadOutputStoreElimination() { // Current implementation only supports vert, tesc, tese, geom shaders auto stage = context()->GetStage(); if (stage != spv::ExecutionModel::Vertex && stage != spv::ExecutionModel::TessellationControl && stage != spv::ExecutionModel::TessellationEvaluation && stage != spv::ExecutionModel::Geometry) return Status::Failure; InitializeElimination(); analysis::DefUseManager* def_use_mgr = context()->get_def_use_mgr(); analysis::TypeManager* type_mgr = context()->get_type_mgr(); analysis::DecorationManager* deco_mgr = context()->get_decoration_mgr(); // Process all output variables for (auto& var : context()->types_values()) { if (var.opcode() != spv::Op::OpVariable) { continue; } analysis::Type* var_type = type_mgr->GetType(var.type_id()); analysis::Pointer* ptr_type = var_type->AsPointer(); if (ptr_type->storage_class() != spv::StorageClass::Output) { continue; } // If builtin decoration on variable, process as builtin. auto var_id = var.result_id(); bool is_builtin = false; if (deco_mgr->HasDecoration(var_id, uint32_t(spv::Decoration::BuiltIn))) { is_builtin = true; } else { // If interface block with builtin members, process as builtin. // Strip off outer array type if present. auto curr_type = ptr_type->pointee_type(); auto arr_type = curr_type->AsArray(); if (arr_type) curr_type = arr_type->element_type(); auto str_type = curr_type->AsStruct(); if (str_type) { auto str_type_id = type_mgr->GetId(str_type); if (deco_mgr->HasDecoration(str_type_id, uint32_t(spv::Decoration::BuiltIn))) is_builtin = true; } } // For each store or access chain using var, if dead builtin or all its // locations are dead, kill store or all access chain's stores def_use_mgr->ForEachUser( var_id, [this, &var, is_builtin](Instruction* user) { auto op = user->opcode(); if (op == spv::Op::OpEntryPoint || op == spv::Op::OpName || op == spv::Op::OpDecorate || user->IsNonSemanticInstruction()) return; if (is_builtin) KillAllDeadStoresOfBuiltinRef(user, &var); else KillAllDeadStoresOfLocRef(user, &var); }); } for (auto& kinst : kill_list_) context()->KillInst(kinst); return kill_list_.empty() ? Status::SuccessWithoutChange : Status::SuccessWithChange; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/eliminate_dead_output_stores_pass.h000066400000000000000000000053111475742701700277750ustar00rootroot00000000000000// Copyright (c) 2022 The Khronos Group Inc. // Copyright (c) 2022 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_ELIMINATE_DEAD_OUTPUT_STORES_H_ #define SOURCE_OPT_ELIMINATE_DEAD_OUTPUT_STORES_H_ #include #include "source/opt/ir_context.h" #include "source/opt/module.h" #include "source/opt/pass.h" namespace spvtools { namespace opt { // See optimizer.hpp for documentation. class EliminateDeadOutputStoresPass : public Pass { public: explicit EliminateDeadOutputStoresPass( std::unordered_set* live_locs, std::unordered_set* live_builtins) : live_locs_(live_locs), live_builtins_(live_builtins) {} const char* name() const override { return "eliminate-dead-output-stores"; } Status Process() override; // Return the mask of preserved Analyses. IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisCombinators | IRContext::kAnalysisCFG | IRContext::kAnalysisDominatorAnalysis | IRContext::kAnalysisLoopAnalysis | IRContext::kAnalysisNameMap | IRContext::kAnalysisConstants | IRContext::kAnalysisTypes; } private: // Initialize elimination void InitializeElimination(); // Do dead output store analysis Status DoDeadOutputStoreElimination(); // Kill all stores resulting from |ref|. void KillAllStoresOfRef(Instruction* ref); // Kill all dead stores resulting from |user| of loc-based |var|. void KillAllDeadStoresOfLocRef(Instruction* user, Instruction* var); // Kill all dead stores resulting from |user| of builtin |var|. void KillAllDeadStoresOfBuiltinRef(Instruction* user, Instruction* var); // Return true if any of |count| locations starting at location |start| are // live. bool AnyLocsAreLive(uint32_t start, uint32_t count); // Return true if builtin |bi| is live. bool IsLiveBuiltin(uint32_t bi); std::unordered_set* live_locs_; std::unordered_set* live_builtins_; std::vector kill_list_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_ELIMINATE_DEAD_OUTPUT_STORES_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/empty_pass.h000066400000000000000000000020121475742701700231630ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_EMPTY_PASS_H_ #define SOURCE_OPT_EMPTY_PASS_H_ #include "source/opt/pass.h" namespace spvtools { namespace opt { // Documented in optimizer.hpp class EmptyPass : public Pass { public: EmptyPass() {} const char* name() const override { return "empty-pass"; } Status Process() override { return Status::SuccessWithoutChange; } }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_EMPTY_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/feature_manager.cpp000066400000000000000000000065151475742701700244730ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/feature_manager.h" #include #include "source/enum_string_mapping.h" namespace spvtools { namespace opt { void FeatureManager::Analyze(Module* module) { AddExtensions(module); AddCapabilities(module); AddExtInstImportIds(module); } void FeatureManager::AddExtensions(Module* module) { for (auto ext : module->extensions()) { AddExtension(&ext); } } void FeatureManager::AddExtension(Instruction* ext) { assert(ext->opcode() == spv::Op::OpExtension && "Expecting an extension instruction."); const std::string name = ext->GetInOperand(0u).AsString(); Extension extension; if (GetExtensionFromString(name.c_str(), &extension)) { extensions_.insert(extension); } } void FeatureManager::RemoveExtension(Extension ext) { if (!extensions_.contains(ext)) return; extensions_.erase(ext); } void FeatureManager::AddCapability(spv::Capability cap) { if (capabilities_.contains(cap)) return; capabilities_.insert(cap); spv_operand_desc desc = {}; if (SPV_SUCCESS == grammar_.lookupOperand(SPV_OPERAND_TYPE_CAPABILITY, uint32_t(cap), &desc)) { for (auto capability : CapabilitySet(desc->numCapabilities, desc->capabilities)) { AddCapability(capability); } } } void FeatureManager::RemoveCapability(spv::Capability cap) { if (!capabilities_.contains(cap)) return; capabilities_.erase(cap); } void FeatureManager::AddCapabilities(Module* module) { for (Instruction& inst : module->capabilities()) { AddCapability(static_cast(inst.GetSingleWordInOperand(0))); } } void FeatureManager::AddExtInstImportIds(Module* module) { extinst_importid_GLSLstd450_ = module->GetExtInstImportId("GLSL.std.450"); extinst_importid_OpenCL100DebugInfo_ = module->GetExtInstImportId("OpenCL.DebugInfo.100"); extinst_importid_Shader100DebugInfo_ = module->GetExtInstImportId("NonSemantic.Shader.DebugInfo.100"); } bool operator==(const FeatureManager& a, const FeatureManager& b) { // We check that the addresses of the grammars are the same because they // are large objects, and this is faster. It can be changed if needed as a // later time. if (&a.grammar_ != &b.grammar_) { return false; } if (a.capabilities_ != b.capabilities_) { return false; } if (a.extensions_ != b.extensions_) { return false; } if (a.extinst_importid_GLSLstd450_ != b.extinst_importid_GLSLstd450_) { return false; } if (a.extinst_importid_OpenCL100DebugInfo_ != b.extinst_importid_OpenCL100DebugInfo_) { return false; } if (a.extinst_importid_Shader100DebugInfo_ != b.extinst_importid_Shader100DebugInfo_) { return false; } return true; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/feature_manager.h000066400000000000000000000072101475742701700241310ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_FEATURE_MANAGER_H_ #define SOURCE_OPT_FEATURE_MANAGER_H_ #include "source/assembly_grammar.h" #include "source/extensions.h" #include "source/opt/module.h" namespace spvtools { namespace opt { // Tracks features enabled by a module. The IRContext has a FeatureManager. class FeatureManager { public: // Returns true if |ext| is an enabled extension in the module. bool HasExtension(Extension ext) const { return extensions_.contains(ext); } // Returns true if |cap| is an enabled capability in the module. bool HasCapability(spv::Capability cap) const { return capabilities_.contains(cap); } // Returns the capabilities the module declares. inline const CapabilitySet& GetCapabilities() const { return capabilities_; } // Returns the extensions the module imports. inline const ExtensionSet& GetExtensions() const { return extensions_; } uint32_t GetExtInstImportId_GLSLstd450() const { return extinst_importid_GLSLstd450_; } uint32_t GetExtInstImportId_OpenCL100DebugInfo() const { return extinst_importid_OpenCL100DebugInfo_; } uint32_t GetExtInstImportId_Shader100DebugInfo() const { return extinst_importid_Shader100DebugInfo_; } friend bool operator==(const FeatureManager& a, const FeatureManager& b); friend bool operator!=(const FeatureManager& a, const FeatureManager& b) { return !(a == b); } private: explicit FeatureManager(const AssemblyGrammar& grammar) : grammar_(grammar) {} // Analyzes |module| and records enabled extensions and capabilities. void Analyze(Module* module); // Add the extension |ext| to the feature manager. void AddExtension(Instruction* ext); // Analyzes |module| and records enabled extensions. void AddExtensions(Module* module); // Removes the given |extension| from the current FeatureManager. void RemoveExtension(Extension extension); // Adds the given |capability| and all implied capabilities into the current // FeatureManager. void AddCapability(spv::Capability capability); // Analyzes |module| and records enabled capabilities. void AddCapabilities(Module* module); // Removes the given |capability| from the current FeatureManager. void RemoveCapability(spv::Capability capability); // Analyzes |module| and records imported external instruction sets. void AddExtInstImportIds(Module* module); // Auxiliary object for querying SPIR-V grammar facts. const AssemblyGrammar& grammar_; // The enabled extensions. ExtensionSet extensions_; // The enabled capabilities. CapabilitySet capabilities_; // Common external instruction import ids, cached for performance. uint32_t extinst_importid_GLSLstd450_ = 0; // Common OpenCL100DebugInfo external instruction import ids, cached // for performance. uint32_t extinst_importid_OpenCL100DebugInfo_ = 0; // Common NonSemanticShader100DebugInfo external instruction import ids, // cached for performance. uint32_t extinst_importid_Shader100DebugInfo_ = 0; friend class IRContext; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_FEATURE_MANAGER_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/fix_func_call_arguments.cpp000066400000000000000000000067221475742701700262270ustar00rootroot00000000000000// Copyright (c) 2022 Advanced Micro Devices, Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "fix_func_call_arguments.h" #include "ir_builder.h" using namespace spvtools; using namespace opt; bool FixFuncCallArgumentsPass::ModuleHasASingleFunction() { auto funcsNum = get_module()->end() - get_module()->begin(); return funcsNum == 1; } Pass::Status FixFuncCallArgumentsPass::Process() { bool modified = false; if (ModuleHasASingleFunction()) return Status::SuccessWithoutChange; for (auto& func : *get_module()) { func.ForEachInst([this, &modified](Instruction* inst) { if (inst->opcode() == spv::Op::OpFunctionCall) { modified |= FixFuncCallArguments(inst); } }); } return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } bool FixFuncCallArgumentsPass::FixFuncCallArguments( Instruction* func_call_inst) { bool modified = false; for (uint32_t i = 0; i < func_call_inst->NumInOperands(); ++i) { Operand& op = func_call_inst->GetInOperand(i); if (op.type != SPV_OPERAND_TYPE_ID) continue; Instruction* operand_inst = get_def_use_mgr()->GetDef(op.AsId()); if (operand_inst->opcode() == spv::Op::OpAccessChain) { uint32_t var_id = ReplaceAccessChainFuncCallArguments(func_call_inst, operand_inst); func_call_inst->SetInOperand(i, {var_id}); modified = true; } } if (modified) { context()->UpdateDefUse(func_call_inst); } return modified; } uint32_t FixFuncCallArgumentsPass::ReplaceAccessChainFuncCallArguments( Instruction* func_call_inst, Instruction* operand_inst) { InstructionBuilder builder( context(), func_call_inst, IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); Instruction* next_insert_point = func_call_inst->NextNode(); // Get Variable insertion point Function* func = context()->get_instr_block(func_call_inst)->GetParent(); Instruction* variable_insertion_point = &*(func->begin()->begin()); Instruction* op_ptr_type = get_def_use_mgr()->GetDef(operand_inst->type_id()); Instruction* op_type = get_def_use_mgr()->GetDef(op_ptr_type->GetSingleWordInOperand(1)); uint32_t varType = context()->get_type_mgr()->FindPointerToType( op_type->result_id(), spv::StorageClass::Function); // Create new variable builder.SetInsertPoint(variable_insertion_point); Instruction* var = builder.AddVariable(varType, uint32_t(spv::StorageClass::Function)); // Load access chain to the new variable before function call builder.SetInsertPoint(func_call_inst); uint32_t operand_id = operand_inst->result_id(); Instruction* load = builder.AddLoad(op_type->result_id(), operand_id); builder.AddStore(var->result_id(), load->result_id()); // Load return value to the acesschain after function call builder.SetInsertPoint(next_insert_point); load = builder.AddLoad(op_type->result_id(), var->result_id()); builder.AddStore(operand_id, load->result_id()); return var->result_id(); } KhronosGroup-SPIRV-Tools-f289d04/source/opt/fix_func_call_arguments.h000066400000000000000000000033471475742701700256740ustar00rootroot00000000000000// Copyright (c) 2022 Advanced Micro Devices, Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef _VAR_FUNC_CALL_PASS_H #define _VAR_FUNC_CALL_PASS_H #include "source/opt/pass.h" namespace spvtools { namespace opt { class FixFuncCallArgumentsPass : public Pass { public: FixFuncCallArgumentsPass() {} const char* name() const override { return "fix-for-funcall-param"; } Status Process() override; // Returns true if the module has one one function. bool ModuleHasASingleFunction(); // Copies from the memory pointed to by |operand_inst| to a new function scope // variable created before |func_call_inst|, and // copies the value of the new variable back to the memory pointed to by // |operand_inst| after |funct_call_inst| Returns the id of // the new variable. uint32_t ReplaceAccessChainFuncCallArguments(Instruction* func_call_inst, Instruction* operand_inst); // Fix function call |func_call_inst| non memory object arguments bool FixFuncCallArguments(Instruction* func_call_inst); IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisTypes; } }; } // namespace opt } // namespace spvtools #endif // _VAR_FUNC_CALL_PASS_HKhronosGroup-SPIRV-Tools-f289d04/source/opt/fix_storage_class.cpp000066400000000000000000000321551475742701700250440ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // Modifications Copyright (C) 2024 Advanced Micro Devices, Inc. All rights // reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "fix_storage_class.h" #include #include "source/opt/instruction.h" #include "source/opt/ir_context.h" namespace spvtools { namespace opt { Pass::Status FixStorageClass::Process() { bool modified = false; get_module()->ForEachInst([this, &modified](Instruction* inst) { if (inst->opcode() == spv::Op::OpVariable) { std::set seen; std::vector> uses; get_def_use_mgr()->ForEachUse(inst, [&uses](Instruction* use, uint32_t op_idx) { uses.push_back({use, op_idx}); }); for (auto& use : uses) { modified |= PropagateStorageClass( use.first, static_cast(inst->GetSingleWordInOperand(0)), &seen); assert(seen.empty() && "Seen was not properly reset."); modified |= PropagateType(use.first, inst->type_id(), use.second, &seen); assert(seen.empty() && "Seen was not properly reset."); } } }); return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } bool FixStorageClass::PropagateStorageClass(Instruction* inst, spv::StorageClass storage_class, std::set* seen) { if (!IsPointerResultType(inst)) { return false; } if (IsPointerToStorageClass(inst, storage_class)) { if (inst->opcode() == spv::Op::OpPhi) { if (!seen->insert(inst->result_id()).second) { return false; } } bool modified = false; std::vector uses; get_def_use_mgr()->ForEachUser( inst, [&uses](Instruction* use) { uses.push_back(use); }); for (Instruction* use : uses) { modified |= PropagateStorageClass(use, storage_class, seen); } if (inst->opcode() == spv::Op::OpPhi) { seen->erase(inst->result_id()); } return modified; } switch (inst->opcode()) { case spv::Op::OpAccessChain: case spv::Op::OpPtrAccessChain: case spv::Op::OpInBoundsAccessChain: case spv::Op::OpCopyObject: case spv::Op::OpPhi: case spv::Op::OpSelect: FixInstructionStorageClass(inst, storage_class, seen); return true; case spv::Op::OpFunctionCall: // We cannot be sure of the actual connection between the storage class // of the parameter and the storage class of the result, so we should not // do anything. If the result type needs to be fixed, the function call // should be inlined. return false; case spv::Op::OpImageTexelPointer: case spv::Op::OpLoad: case spv::Op::OpStore: case spv::Op::OpCopyMemory: case spv::Op::OpCopyMemorySized: case spv::Op::OpVariable: case spv::Op::OpBitcast: case spv::Op::OpAllocateNodePayloadsAMDX: // Nothing to change for these opcode. The result type is the same // regardless of the storage class of the operand. return false; default: assert(false && "Not expecting instruction to have a pointer result type."); return false; } } void FixStorageClass::FixInstructionStorageClass( Instruction* inst, spv::StorageClass storage_class, std::set* seen) { assert(IsPointerResultType(inst) && "The result type of the instruction must be a pointer."); ChangeResultStorageClass(inst, storage_class); std::vector uses; get_def_use_mgr()->ForEachUser( inst, [&uses](Instruction* use) { uses.push_back(use); }); for (Instruction* use : uses) { PropagateStorageClass(use, storage_class, seen); } } void FixStorageClass::ChangeResultStorageClass( Instruction* inst, spv::StorageClass storage_class) const { analysis::TypeManager* type_mgr = context()->get_type_mgr(); Instruction* result_type_inst = get_def_use_mgr()->GetDef(inst->type_id()); assert(result_type_inst->opcode() == spv::Op::OpTypePointer); uint32_t pointee_type_id = result_type_inst->GetSingleWordInOperand(1); uint32_t new_result_type_id = type_mgr->FindPointerToType(pointee_type_id, storage_class); inst->SetResultType(new_result_type_id); context()->UpdateDefUse(inst); } bool FixStorageClass::IsPointerResultType(Instruction* inst) { if (inst->type_id() == 0) { return false; } Instruction* type_def = get_def_use_mgr()->GetDef(inst->type_id()); return type_def->opcode() == spv::Op::OpTypePointer; } bool FixStorageClass::IsPointerToStorageClass(Instruction* inst, spv::StorageClass storage_class) { if (inst->type_id() == 0) { return false; } Instruction* type_def = get_def_use_mgr()->GetDef(inst->type_id()); if (type_def->opcode() != spv::Op::OpTypePointer) { return false; } const uint32_t kPointerTypeStorageClassIndex = 0; spv::StorageClass pointer_storage_class = static_cast( type_def->GetSingleWordInOperand(kPointerTypeStorageClassIndex)); return pointer_storage_class == storage_class; } bool FixStorageClass::ChangeResultType(Instruction* inst, uint32_t new_type_id) { if (inst->type_id() == new_type_id) { return false; } context()->ForgetUses(inst); inst->SetResultType(new_type_id); context()->AnalyzeUses(inst); return true; } bool FixStorageClass::PropagateType(Instruction* inst, uint32_t type_id, uint32_t op_idx, std::set* seen) { assert(type_id != 0 && "Not given a valid type in PropagateType"); bool modified = false; // If the type of operand |op_idx| forces the result type of |inst| to a // particular type, then we want find that type. uint32_t new_type_id = 0; switch (inst->opcode()) { case spv::Op::OpAccessChain: case spv::Op::OpPtrAccessChain: case spv::Op::OpInBoundsAccessChain: case spv::Op::OpInBoundsPtrAccessChain: if (op_idx == 2) { new_type_id = WalkAccessChainType(inst, type_id); } break; case spv::Op::OpCopyObject: new_type_id = type_id; break; case spv::Op::OpPhi: if (seen->insert(inst->result_id()).second) { new_type_id = type_id; } break; case spv::Op::OpSelect: if (op_idx > 2) { new_type_id = type_id; } break; case spv::Op::OpFunctionCall: // We cannot be sure of the actual connection between the type // of the parameter and the type of the result, so we should not // do anything. If the result type needs to be fixed, the function call // should be inlined. return false; case spv::Op::OpLoad: { Instruction* type_inst = get_def_use_mgr()->GetDef(type_id); new_type_id = type_inst->GetSingleWordInOperand(1); break; } case spv::Op::OpStore: { uint32_t obj_id = inst->GetSingleWordInOperand(1); Instruction* obj_inst = get_def_use_mgr()->GetDef(obj_id); uint32_t obj_type_id = obj_inst->type_id(); uint32_t ptr_id = inst->GetSingleWordInOperand(0); Instruction* ptr_inst = get_def_use_mgr()->GetDef(ptr_id); uint32_t pointee_type_id = GetPointeeTypeId(ptr_inst); if (obj_type_id != pointee_type_id) { if (context()->get_type_mgr()->GetType(obj_type_id)->AsImage() && context()->get_type_mgr()->GetType(pointee_type_id)->AsImage()) { // When storing an image, allow the type mismatch // and let the later legalization passes eliminate the OpStore. // This is to support assigning an image to a variable, // where the assigned image does not have a pre-defined // image format. return false; } uint32_t copy_id = GenerateCopy(obj_inst, pointee_type_id, inst); if (copy_id == 0) { return false; } inst->SetInOperand(1, {copy_id}); context()->UpdateDefUse(inst); } } break; case spv::Op::OpCopyMemory: case spv::Op::OpCopyMemorySized: // TODO: May need to expand the copy as we do with the stores. break; case spv::Op::OpCompositeConstruct: case spv::Op::OpCompositeExtract: case spv::Op::OpCompositeInsert: // TODO: DXC does not seem to generate code that will require changes to // these opcode. The can be implemented when they come up. break; case spv::Op::OpImageTexelPointer: case spv::Op::OpBitcast: // Nothing to change for these opcode. The result type is the same // regardless of the type of the operand. return false; default: // I expect the remaining instructions to act on types that are guaranteed // to be unique, so no change will be necessary. break; } // If the operand forces the result type, then make sure the result type // matches, and update the uses of |inst|. We do not have to check the uses // of |inst| in the result type is not forced because we are only looking for // issue that come from mismatches between function formal and actual // parameters after the function has been inlined. These parameters are // pointers. Once the type no longer depends on the type of the parameter, // then the types should have be correct. if (new_type_id != 0) { modified = ChangeResultType(inst, new_type_id); std::vector> uses; get_def_use_mgr()->ForEachUse(inst, [&uses](Instruction* use, uint32_t idx) { uses.push_back({use, idx}); }); for (auto& use : uses) { PropagateType(use.first, new_type_id, use.second, seen); } if (inst->opcode() == spv::Op::OpPhi) { seen->erase(inst->result_id()); } } return modified; } uint32_t FixStorageClass::WalkAccessChainType(Instruction* inst, uint32_t id) { uint32_t start_idx = 0; switch (inst->opcode()) { case spv::Op::OpAccessChain: case spv::Op::OpInBoundsAccessChain: start_idx = 1; break; case spv::Op::OpPtrAccessChain: case spv::Op::OpInBoundsPtrAccessChain: start_idx = 2; break; default: assert(false); break; } Instruction* id_type_inst = get_def_use_mgr()->GetDef(id); assert(id_type_inst->opcode() == spv::Op::OpTypePointer); id = id_type_inst->GetSingleWordInOperand(1); spv::StorageClass input_storage_class = static_cast(id_type_inst->GetSingleWordInOperand(0)); for (uint32_t i = start_idx; i < inst->NumInOperands(); ++i) { Instruction* type_inst = get_def_use_mgr()->GetDef(id); switch (type_inst->opcode()) { case spv::Op::OpTypeArray: case spv::Op::OpTypeRuntimeArray: case spv::Op::OpTypeNodePayloadArrayAMDX: case spv::Op::OpTypeMatrix: case spv::Op::OpTypeVector: case spv::Op::OpTypeCooperativeMatrixKHR: id = type_inst->GetSingleWordInOperand(0); break; case spv::Op::OpTypeStruct: { const analysis::Constant* index_const = context()->get_constant_mgr()->FindDeclaredConstant( inst->GetSingleWordInOperand(i)); // It is highly unlikely that any type would have more fields than could // be indexed by a 32-bit integer, and GetSingleWordInOperand only takes // a 32-bit value, so we would not be able to handle it anyway. But the // specification does allow any scalar integer type, treated as signed, // so we simply downcast the index to 32-bits. uint32_t index = static_cast(index_const->GetSignExtendedValue()); id = type_inst->GetSingleWordInOperand(index); break; } default: break; } assert(id != 0 && "Tried to extract from an object where it cannot be done."); } Instruction* orig_type_inst = get_def_use_mgr()->GetDef(inst->type_id()); spv::StorageClass orig_storage_class = static_cast(orig_type_inst->GetSingleWordInOperand(0)); assert(orig_type_inst->opcode() == spv::Op::OpTypePointer); if (orig_type_inst->GetSingleWordInOperand(1) == id && input_storage_class == orig_storage_class) { // The existing type is correct. Avoid the search for the type. Note that if // there is a duplicate type, the search below could return a different type // forcing more changes to the code than necessary. return inst->type_id(); } return context()->get_type_mgr()->FindPointerToType(id, input_storage_class); } // namespace opt } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/fix_storage_class.h000066400000000000000000000075271475742701700245160ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_FIX_STORAGE_CLASS_H_ #define SOURCE_OPT_FIX_STORAGE_CLASS_H_ #include #include "source/opt/ir_context.h" #include "source/opt/module.h" #include "source/opt/pass.h" namespace spvtools { namespace opt { // This pass tries to fix validation error due to a mismatch of storage classes // in instructions. There is no guarantee that all such error will be fixed, // and it is possible that in fixing these errors, it could lead to other // errors. class FixStorageClass : public Pass { public: const char* name() const override { return "fix-storage-class"; } Status Process() override; // Return the mask of preserved Analyses. IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisCombinators | IRContext::kAnalysisCFG | IRContext::kAnalysisDominatorAnalysis | IRContext::kAnalysisLoopAnalysis | IRContext::kAnalysisNameMap | IRContext::kAnalysisConstants | IRContext::kAnalysisTypes; } private: // Changes the storage class of the result of |inst| to |storage_class| in // appropriate, and propagates the change to the users of |inst| as well. // Returns true of any changes were made. // |seen| is used to track OpPhi instructions that should not be processed. bool PropagateStorageClass(Instruction* inst, spv::StorageClass storage_class, std::set* seen); // Changes the storage class of the result of |inst| to |storage_class|. // Is it assumed that the result type of |inst| is a pointer type. // Propagates the change to the users of |inst| as well. // Returns true of any changes were made. // |seen| is used to track OpPhi instructions that should not be processed by // |PropagateStorageClass| void FixInstructionStorageClass(Instruction* inst, spv::StorageClass storage_class, std::set* seen); // Changes the storage class of the result of |inst| to |storage_class|. The // result type of |inst| must be a pointer. void ChangeResultStorageClass(Instruction* inst, spv::StorageClass storage_class) const; // Returns true if the result type of |inst| is a pointer. bool IsPointerResultType(Instruction* inst); // Returns true if the result of |inst| is a pointer to storage class // |storage_class|. bool IsPointerToStorageClass(Instruction* inst, spv::StorageClass storage_class); // Change |inst| to match that operand |op_idx| now has type |type_id|, and // adjust any uses of |inst| accordingly. Returns true if the code changed. bool PropagateType(Instruction* inst, uint32_t type_id, uint32_t op_idx, std::set* seen); // Changes the result type of |inst| to |new_type_id|. bool ChangeResultType(Instruction* inst, uint32_t new_type_id); // Returns the type id of the member of the type |id| that would be returned // by following the indices of the access chain instruction |inst|. uint32_t WalkAccessChainType(Instruction* inst, uint32_t id); }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_FIX_STORAGE_CLASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/flatten_decoration_pass.cpp000066400000000000000000000141251475742701700262340ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/flatten_decoration_pass.h" #include #include #include #include #include #include #include "source/opt/ir_context.h" namespace spvtools { namespace opt { using Words = std::vector; using OrderedUsesMap = std::unordered_map; Pass::Status FlattenDecorationPass::Process() { bool modified = false; // The target Id of OpDecorationGroup instructions. // We have to track this separately from its uses, in case it // has no uses. std::unordered_set group_ids; // Maps a decoration group Id to its GroupDecorate targets, in order // of appearance. OrderedUsesMap normal_uses; // Maps a decoration group Id to its GroupMemberDecorate targets and // their indices, in of appearance. OrderedUsesMap member_uses; auto annotations = context()->annotations(); // On the first pass, record each OpDecorationGroup with its ordered uses. // Rely on unordered_map::operator[] to create its entries on first access. for (const auto& inst : annotations) { switch (inst.opcode()) { case spv::Op::OpDecorationGroup: group_ids.insert(inst.result_id()); break; case spv::Op::OpGroupDecorate: { Words& words = normal_uses[inst.GetSingleWordInOperand(0)]; for (uint32_t i = 1; i < inst.NumInOperandWords(); i++) { words.push_back(inst.GetSingleWordInOperand(i)); } } break; case spv::Op::OpGroupMemberDecorate: { Words& words = member_uses[inst.GetSingleWordInOperand(0)]; for (uint32_t i = 1; i < inst.NumInOperandWords(); i++) { words.push_back(inst.GetSingleWordInOperand(i)); } } break; default: break; } } // On the second pass, replace OpDecorationGroup and its uses with // equivalent normal and struct member uses. auto inst_iter = annotations.begin(); // We have to re-evaluate the end pointer while (inst_iter != context()->annotations().end()) { // Should we replace this instruction? bool replace = false; switch (inst_iter->opcode()) { case spv::Op::OpDecorationGroup: case spv::Op::OpGroupDecorate: case spv::Op::OpGroupMemberDecorate: replace = true; break; case spv::Op::OpDecorate: { // If this decoration targets a group, then replace it // by sets of normal and member decorations. const uint32_t group = inst_iter->GetSingleWordOperand(0); const auto normal_uses_iter = normal_uses.find(group); if (normal_uses_iter != normal_uses.end()) { for (auto target : normal_uses[group]) { std::unique_ptr new_inst(inst_iter->Clone(context())); new_inst->SetInOperand(0, Words{target}); inst_iter = inst_iter.InsertBefore(std::move(new_inst)); ++inst_iter; replace = true; } } const auto member_uses_iter = member_uses.find(group); if (member_uses_iter != member_uses.end()) { const Words& member_id_pairs = (*member_uses_iter).second; // The collection is a sequence of pairs. assert((member_id_pairs.size() % 2) == 0); for (size_t i = 0; i < member_id_pairs.size(); i += 2) { // Make an OpMemberDecorate instruction for each (target, member) // pair. const uint32_t target = member_id_pairs[i]; const uint32_t member = member_id_pairs[i + 1]; std::vector operands; operands.push_back(Operand(SPV_OPERAND_TYPE_ID, {target})); operands.push_back( Operand(SPV_OPERAND_TYPE_LITERAL_INTEGER, {member})); auto decoration_operands_iter = inst_iter->begin(); decoration_operands_iter++; // Skip the group target. operands.insert(operands.end(), decoration_operands_iter, inst_iter->end()); std::unique_ptr new_inst(new Instruction( context(), spv::Op::OpMemberDecorate, 0, 0, operands)); inst_iter = inst_iter.InsertBefore(std::move(new_inst)); ++inst_iter; replace = true; } } // If this is an OpDecorate targeting the OpDecorationGroup itself, // remove it even if that decoration group itself is not the target of // any OpGroupDecorate or OpGroupMemberDecorate. if (!replace && group_ids.count(group)) { replace = true; } } break; default: break; } if (replace) { inst_iter = inst_iter.Erase(); modified = true; } else { // Handle the case of decorations unrelated to decoration groups. ++inst_iter; } } // Remove OpName instructions which reference the removed group decorations. // An OpDecorationGroup instruction might not have been used by an // OpGroupDecorate or OpGroupMemberDecorate instruction. if (!group_ids.empty()) { for (auto debug_inst_iter = context()->debug2_begin(); debug_inst_iter != context()->debug2_end();) { if (debug_inst_iter->opcode() == spv::Op::OpName) { const uint32_t target = debug_inst_iter->GetSingleWordOperand(0); if (group_ids.count(target)) { debug_inst_iter = debug_inst_iter.Erase(); modified = true; } else { ++debug_inst_iter; } } } } return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/flatten_decoration_pass.h000066400000000000000000000021271475742701700257000ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_FLATTEN_DECORATION_PASS_H_ #define SOURCE_OPT_FLATTEN_DECORATION_PASS_H_ #include "source/opt/ir_context.h" #include "source/opt/module.h" #include "source/opt/pass.h" namespace spvtools { namespace opt { // See optimizer.hpp for documentation. class FlattenDecorationPass : public Pass { public: const char* name() const override { return "flatten-decorations"; } Status Process() override; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_FLATTEN_DECORATION_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/fold.cpp000066400000000000000000000537701475742701700222770ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/fold.h" #include #include #include #include "source/opt/const_folding_rules.h" #include "source/opt/def_use_manager.h" #include "source/opt/folding_rules.h" #include "source/opt/ir_context.h" namespace spvtools { namespace opt { namespace { #ifndef INT32_MIN #define INT32_MIN (-2147483648) #endif #ifndef INT32_MAX #define INT32_MAX 2147483647 #endif #ifndef UINT32_MAX #define UINT32_MAX 0xffffffff /* 4294967295U */ #endif } // namespace uint32_t InstructionFolder::UnaryOperate(spv::Op opcode, uint32_t operand) const { switch (opcode) { // Arthimetics case spv::Op::OpSNegate: { int32_t s_operand = static_cast(operand); if (s_operand == std::numeric_limits::min()) { return s_operand; } return -s_operand; } case spv::Op::OpNot: return ~operand; case spv::Op::OpLogicalNot: return !static_cast(operand); case spv::Op::OpUConvert: return operand; case spv::Op::OpSConvert: return operand; default: assert(false && "Unsupported unary operation for OpSpecConstantOp instruction"); return 0u; } } uint32_t InstructionFolder::BinaryOperate(spv::Op opcode, uint32_t a, uint32_t b) const { switch (opcode) { // Shifting case spv::Op::OpShiftRightLogical: if (b >= 32) { // This is undefined behaviour when |b| > 32. Choose 0 for consistency. // When |b| == 32, doing the shift in C++ in undefined, but the result // will be 0, so just return that value. return 0; } return a >> b; case spv::Op::OpShiftRightArithmetic: if (b > 32) { // This is undefined behaviour. Choose 0 for consistency. return 0; } if (b == 32) { // Doing the shift in C++ is undefined, but the result is defined in the // spir-v spec. Find that value another way. if (static_cast(a) >= 0) { return 0; } else { return static_cast(-1); } } return (static_cast(a)) >> b; case spv::Op::OpShiftLeftLogical: if (b >= 32) { // This is undefined behaviour when |b| > 32. Choose 0 for consistency. // When |b| == 32, doing the shift in C++ in undefined, but the result // will be 0, so just return that value. return 0; } return a << b; // Bitwise operations case spv::Op::OpBitwiseOr: return a | b; case spv::Op::OpBitwiseAnd: return a & b; case spv::Op::OpBitwiseXor: return a ^ b; // Logical case spv::Op::OpLogicalEqual: return (static_cast(a)) == (static_cast(b)); case spv::Op::OpLogicalNotEqual: return (static_cast(a)) != (static_cast(b)); case spv::Op::OpLogicalOr: return (static_cast(a)) || (static_cast(b)); case spv::Op::OpLogicalAnd: return (static_cast(a)) && (static_cast(b)); // Comparison case spv::Op::OpIEqual: return a == b; case spv::Op::OpINotEqual: return a != b; case spv::Op::OpULessThan: return a < b; case spv::Op::OpSLessThan: return (static_cast(a)) < (static_cast(b)); case spv::Op::OpUGreaterThan: return a > b; case spv::Op::OpSGreaterThan: return (static_cast(a)) > (static_cast(b)); case spv::Op::OpULessThanEqual: return a <= b; case spv::Op::OpSLessThanEqual: return (static_cast(a)) <= (static_cast(b)); case spv::Op::OpUGreaterThanEqual: return a >= b; case spv::Op::OpSGreaterThanEqual: return (static_cast(a)) >= (static_cast(b)); default: assert(false && "Unsupported binary operation for OpSpecConstantOp instruction"); return 0u; } } uint32_t InstructionFolder::TernaryOperate(spv::Op opcode, uint32_t a, uint32_t b, uint32_t c) const { switch (opcode) { case spv::Op::OpSelect: return (static_cast(a)) ? b : c; default: assert(false && "Unsupported ternary operation for OpSpecConstantOp instruction"); return 0u; } } uint32_t InstructionFolder::OperateWords( spv::Op opcode, const std::vector& operand_words) const { switch (operand_words.size()) { case 1: return UnaryOperate(opcode, operand_words.front()); case 2: return BinaryOperate(opcode, operand_words.front(), operand_words.back()); case 3: return TernaryOperate(opcode, operand_words[0], operand_words[1], operand_words[2]); default: assert(false && "Invalid number of operands"); return 0; } } bool InstructionFolder::FoldInstructionInternal(Instruction* inst) const { auto identity_map = [](uint32_t id) { return id; }; Instruction* folded_inst = FoldInstructionToConstant(inst, identity_map); if (folded_inst != nullptr) { inst->SetOpcode(spv::Op::OpCopyObject); inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {folded_inst->result_id()}}}); return true; } analysis::ConstantManager* const_manager = context_->get_constant_mgr(); std::vector constants = const_manager->GetOperandConstants(inst); for (const FoldingRule& rule : GetFoldingRules().GetRulesForInstruction(inst)) { if (rule(context_, inst, constants)) { return true; } } return false; } // Returns the result of performing an operation on scalar constant operands. // This function extracts the operand values as 32 bit words and returns the // result in 32 bit word. Scalar constants with longer than 32-bit width are // not accepted in this function. uint32_t InstructionFolder::FoldScalars( spv::Op opcode, const std::vector& operands) const { assert(IsFoldableOpcode(opcode) && "Unhandled instruction opcode in FoldScalars"); std::vector operand_values_in_raw_words; for (const auto& operand : operands) { if (const analysis::ScalarConstant* scalar = operand->AsScalarConstant()) { const auto& scalar_words = scalar->words(); assert(scalar_words.size() == 1 && "Scalar constants with longer than 32-bit width are not allowed " "in FoldScalars()"); operand_values_in_raw_words.push_back(scalar_words.front()); } else if (operand->AsNullConstant()) { operand_values_in_raw_words.push_back(0u); } else { assert(false && "FoldScalars() only accepts ScalarConst or NullConst type of " "constant"); } } return OperateWords(opcode, operand_values_in_raw_words); } bool InstructionFolder::FoldBinaryIntegerOpToConstant( Instruction* inst, const std::function& id_map, uint32_t* result) const { spv::Op opcode = inst->opcode(); analysis::ConstantManager* const_manger = context_->get_constant_mgr(); uint32_t ids[2]; const analysis::IntConstant* constants[2]; for (uint32_t i = 0; i < 2; i++) { const Operand* operand = &inst->GetInOperand(i); if (operand->type != SPV_OPERAND_TYPE_ID) { return false; } ids[i] = id_map(operand->words[0]); const analysis::Constant* constant = const_manger->FindDeclaredConstant(ids[i]); constants[i] = (constant != nullptr ? constant->AsIntConstant() : nullptr); } switch (opcode) { // Arthimetics case spv::Op::OpIMul: for (uint32_t i = 0; i < 2; i++) { if (constants[i] != nullptr && constants[i]->IsZero()) { *result = 0; return true; } } break; case spv::Op::OpUDiv: case spv::Op::OpSDiv: case spv::Op::OpSRem: case spv::Op::OpSMod: case spv::Op::OpUMod: // This changes undefined behaviour (ie divide by 0) into a 0. for (uint32_t i = 0; i < 2; i++) { if (constants[i] != nullptr && constants[i]->IsZero()) { *result = 0; return true; } } break; // Shifting case spv::Op::OpShiftRightLogical: case spv::Op::OpShiftLeftLogical: if (constants[1] != nullptr) { // When shifting by a value larger than the size of the result, the // result is undefined. We are setting the undefined behaviour to a // result of 0. If the shift amount is the same as the size of the // result, then the result is defined, and it 0. uint32_t shift_amount = constants[1]->GetU32BitValue(); if (shift_amount >= 32) { *result = 0; return true; } } break; // Bitwise operations case spv::Op::OpBitwiseOr: for (uint32_t i = 0; i < 2; i++) { if (constants[i] != nullptr) { // TODO: Change the mask against a value based on the bit width of the // instruction result type. This way we can handle say 16-bit values // as well. uint32_t mask = constants[i]->GetU32BitValue(); if (mask == 0xFFFFFFFF) { *result = 0xFFFFFFFF; return true; } } } break; case spv::Op::OpBitwiseAnd: for (uint32_t i = 0; i < 2; i++) { if (constants[i] != nullptr) { if (constants[i]->IsZero()) { *result = 0; return true; } } } break; // Comparison case spv::Op::OpULessThan: if (constants[0] != nullptr && constants[0]->GetU32BitValue() == UINT32_MAX) { *result = false; return true; } if (constants[1] != nullptr && constants[1]->GetU32BitValue() == 0) { *result = false; return true; } break; case spv::Op::OpSLessThan: if (constants[0] != nullptr && constants[0]->GetS32BitValue() == INT32_MAX) { *result = false; return true; } if (constants[1] != nullptr && constants[1]->GetS32BitValue() == INT32_MIN) { *result = false; return true; } break; case spv::Op::OpUGreaterThan: if (constants[0] != nullptr && constants[0]->IsZero()) { *result = false; return true; } if (constants[1] != nullptr && constants[1]->GetU32BitValue() == UINT32_MAX) { *result = false; return true; } break; case spv::Op::OpSGreaterThan: if (constants[0] != nullptr && constants[0]->GetS32BitValue() == INT32_MIN) { *result = false; return true; } if (constants[1] != nullptr && constants[1]->GetS32BitValue() == INT32_MAX) { *result = false; return true; } break; case spv::Op::OpULessThanEqual: if (constants[0] != nullptr && constants[0]->IsZero()) { *result = true; return true; } if (constants[1] != nullptr && constants[1]->GetU32BitValue() == UINT32_MAX) { *result = true; return true; } break; case spv::Op::OpSLessThanEqual: if (constants[0] != nullptr && constants[0]->GetS32BitValue() == INT32_MIN) { *result = true; return true; } if (constants[1] != nullptr && constants[1]->GetS32BitValue() == INT32_MAX) { *result = true; return true; } break; case spv::Op::OpUGreaterThanEqual: if (constants[0] != nullptr && constants[0]->GetU32BitValue() == UINT32_MAX) { *result = true; return true; } if (constants[1] != nullptr && constants[1]->GetU32BitValue() == 0) { *result = true; return true; } break; case spv::Op::OpSGreaterThanEqual: if (constants[0] != nullptr && constants[0]->GetS32BitValue() == INT32_MAX) { *result = true; return true; } if (constants[1] != nullptr && constants[1]->GetS32BitValue() == INT32_MIN) { *result = true; return true; } break; default: break; } return false; } bool InstructionFolder::FoldBinaryBooleanOpToConstant( Instruction* inst, const std::function& id_map, uint32_t* result) const { spv::Op opcode = inst->opcode(); analysis::ConstantManager* const_manger = context_->get_constant_mgr(); uint32_t ids[2]; const analysis::BoolConstant* constants[2]; for (uint32_t i = 0; i < 2; i++) { const Operand* operand = &inst->GetInOperand(i); if (operand->type != SPV_OPERAND_TYPE_ID) { return false; } ids[i] = id_map(operand->words[0]); const analysis::Constant* constant = const_manger->FindDeclaredConstant(ids[i]); constants[i] = (constant != nullptr ? constant->AsBoolConstant() : nullptr); } switch (opcode) { // Logical case spv::Op::OpLogicalOr: for (uint32_t i = 0; i < 2; i++) { if (constants[i] != nullptr) { if (constants[i]->value()) { *result = true; return true; } } } break; case spv::Op::OpLogicalAnd: for (uint32_t i = 0; i < 2; i++) { if (constants[i] != nullptr) { if (!constants[i]->value()) { *result = false; return true; } } } break; default: break; } return false; } bool InstructionFolder::FoldIntegerOpToConstant( Instruction* inst, const std::function& id_map, uint32_t* result) const { assert(IsFoldableOpcode(inst->opcode()) && "Unhandled instruction opcode in FoldScalars"); switch (inst->NumInOperands()) { case 2: return FoldBinaryIntegerOpToConstant(inst, id_map, result) || FoldBinaryBooleanOpToConstant(inst, id_map, result); default: return false; } } std::vector InstructionFolder::FoldVectors( spv::Op opcode, uint32_t num_dims, const std::vector& operands) const { assert(IsFoldableOpcode(opcode) && "Unhandled instruction opcode in FoldVectors"); std::vector result; for (uint32_t d = 0; d < num_dims; d++) { std::vector operand_values_for_one_dimension; for (const auto& operand : operands) { if (const analysis::VectorConstant* vector_operand = operand->AsVectorConstant()) { // Extract the raw value of the scalar component constants // in 32-bit words here. The reason of not using FoldScalars() here // is that we do not create temporary null constants as components // when the vector operand is a NullConstant because Constant creation // may need extra checks for the validity and that is not managed in // here. if (const analysis::ScalarConstant* scalar_component = vector_operand->GetComponents().at(d)->AsScalarConstant()) { const auto& scalar_words = scalar_component->words(); assert( scalar_words.size() == 1 && "Vector components with longer than 32-bit width are not allowed " "in FoldVectors()"); operand_values_for_one_dimension.push_back(scalar_words.front()); } else if (operand->AsNullConstant()) { operand_values_for_one_dimension.push_back(0u); } else { assert(false && "VectorConst should only has ScalarConst or NullConst as " "components"); } } else if (operand->AsNullConstant()) { operand_values_for_one_dimension.push_back(0u); } else { assert(false && "FoldVectors() only accepts VectorConst or NullConst type of " "constant"); } } result.push_back(OperateWords(opcode, operand_values_for_one_dimension)); } return result; } bool InstructionFolder::IsFoldableOpcode(spv::Op opcode) const { // NOTE: Extend to more opcodes as new cases are handled in the folder // functions. switch (opcode) { case spv::Op::OpBitwiseAnd: case spv::Op::OpBitwiseOr: case spv::Op::OpBitwiseXor: case spv::Op::OpIAdd: case spv::Op::OpIEqual: case spv::Op::OpIMul: case spv::Op::OpINotEqual: case spv::Op::OpISub: case spv::Op::OpLogicalAnd: case spv::Op::OpLogicalEqual: case spv::Op::OpLogicalNot: case spv::Op::OpLogicalNotEqual: case spv::Op::OpLogicalOr: case spv::Op::OpNot: case spv::Op::OpSDiv: case spv::Op::OpSelect: case spv::Op::OpSGreaterThan: case spv::Op::OpSGreaterThanEqual: case spv::Op::OpShiftLeftLogical: case spv::Op::OpShiftRightArithmetic: case spv::Op::OpShiftRightLogical: case spv::Op::OpSLessThan: case spv::Op::OpSLessThanEqual: case spv::Op::OpSMod: case spv::Op::OpSNegate: case spv::Op::OpSRem: case spv::Op::OpSConvert: case spv::Op::OpUConvert: case spv::Op::OpUDiv: case spv::Op::OpUGreaterThan: case spv::Op::OpUGreaterThanEqual: case spv::Op::OpULessThan: case spv::Op::OpULessThanEqual: case spv::Op::OpUMod: return true; default: return false; } } bool InstructionFolder::IsFoldableConstant( const analysis::Constant* cst) const { // Currently supported constants are 32-bit values or null constants. if (const analysis::ScalarConstant* scalar = cst->AsScalarConstant()) return scalar->words().size() == 1; else return cst->AsNullConstant() != nullptr; } Instruction* InstructionFolder::FoldInstructionToConstant( Instruction* inst, std::function id_map) const { analysis::ConstantManager* const_mgr = context_->get_constant_mgr(); if (!inst->IsFoldableByFoldScalar() && !inst->IsFoldableByFoldVector() && !GetConstantFoldingRules().HasFoldingRule(inst)) { return nullptr; } // Collect the values of the constant parameters. std::vector constants; bool missing_constants = false; inst->ForEachInId([&constants, &missing_constants, const_mgr, &id_map](uint32_t* op_id) { uint32_t id = id_map(*op_id); const analysis::Constant* const_op = const_mgr->FindDeclaredConstant(id); if (!const_op) { constants.push_back(nullptr); missing_constants = true; } else { constants.push_back(const_op); } }); const analysis::Constant* folded_const = nullptr; for (auto rule : GetConstantFoldingRules().GetRulesForInstruction(inst)) { folded_const = rule(context_, inst, constants); if (folded_const != nullptr) { Instruction* const_inst = const_mgr->GetDefiningInstruction(folded_const, inst->type_id()); if (const_inst == nullptr) { return nullptr; } assert(const_inst->type_id() == inst->type_id()); // May be a new instruction that needs to be analysed. context_->UpdateDefUse(const_inst); return const_inst; } } bool successful = false; // If all parameters are constant, fold the instruction to a constant. if (inst->IsFoldableByFoldScalar()) { uint32_t result_val = 0; if (!missing_constants) { result_val = FoldScalars(inst->opcode(), constants); successful = true; } if (!successful) { successful = FoldIntegerOpToConstant(inst, id_map, &result_val); } if (successful) { const analysis::Constant* result_const = const_mgr->GetConstant(const_mgr->GetType(inst), {result_val}); Instruction* folded_inst = const_mgr->GetDefiningInstruction(result_const, inst->type_id()); return folded_inst; } } else if (inst->IsFoldableByFoldVector()) { std::vector result_val; if (!missing_constants) { if (Instruction* inst_type = context_->get_def_use_mgr()->GetDef(inst->type_id())) { result_val = FoldVectors( inst->opcode(), inst_type->GetSingleWordInOperand(1), constants); successful = true; } } if (successful) { const analysis::Constant* result_const = const_mgr->GetNumericVectorConstantWithWords( const_mgr->GetType(inst)->AsVector(), result_val); Instruction* folded_inst = const_mgr->GetDefiningInstruction(result_const, inst->type_id()); return folded_inst; } } return nullptr; } bool InstructionFolder::IsFoldableType(Instruction* type_inst) const { return IsFoldableScalarType(type_inst) || IsFoldableVectorType(type_inst); } bool InstructionFolder::IsFoldableScalarType(Instruction* type_inst) const { // Support 32-bit integers. if (type_inst->opcode() == spv::Op::OpTypeInt) { return type_inst->GetSingleWordInOperand(0) == 32; } // Support booleans. if (type_inst->opcode() == spv::Op::OpTypeBool) { return true; } // Nothing else yet. return false; } bool InstructionFolder::IsFoldableVectorType(Instruction* type_inst) const { // Support vectors with foldable components if (type_inst->opcode() == spv::Op::OpTypeVector) { uint32_t component_type_id = type_inst->GetSingleWordInOperand(0); Instruction* def_component_type = context_->get_def_use_mgr()->GetDef(component_type_id); return def_component_type != nullptr && IsFoldableScalarType(def_component_type); } // Nothing else yet. return false; } bool InstructionFolder::FoldInstruction(Instruction* inst) const { bool modified = false; Instruction* folded_inst(inst); while (folded_inst->opcode() != spv::Op::OpCopyObject && FoldInstructionInternal(&*folded_inst)) { modified = true; } return modified; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/fold.h000066400000000000000000000206761475742701700217430ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_FOLD_H_ #define SOURCE_OPT_FOLD_H_ #include #include #include "source/opt/const_folding_rules.h" #include "source/opt/constants.h" #include "source/opt/def_use_manager.h" #include "source/opt/folding_rules.h" namespace spvtools { namespace opt { class InstructionFolder { public: explicit InstructionFolder(IRContext* context) : context_(context), const_folding_rules_(new ConstantFoldingRules(context)), folding_rules_(new FoldingRules(context)) { folding_rules_->AddFoldingRules(); const_folding_rules_->AddFoldingRules(); } explicit InstructionFolder( IRContext* context, std::unique_ptr&& folding_rules, std::unique_ptr&& constant_folding_rules) : context_(context), const_folding_rules_(std::move(constant_folding_rules)), folding_rules_(std::move(folding_rules)) { folding_rules_->AddFoldingRules(); const_folding_rules_->AddFoldingRules(); } // Returns the result of folding a scalar instruction with the given |opcode| // and |operands|. Each entry in |operands| is a pointer to an // analysis::Constant instance, which should've been created with the constant // manager (See IRContext::get_constant_mgr). // // It is an error to call this function with an opcode that does not pass the // IsFoldableOpcode test. If any error occurs during folding, the folder will // fail with a call to assert. uint32_t FoldScalars( spv::Op opcode, const std::vector& operands) const; // Returns the result of performing an operation with the given |opcode| over // constant vectors with |num_dims| dimensions. Each entry in |operands| is a // pointer to an analysis::Constant instance, which should've been created // with the constant manager (See IRContext::get_constant_mgr). // // This function iterates through the given vector type constant operands and // calculates the result for each element of the result vector to return. // Vectors with longer than 32-bit scalar components are not accepted in this // function. // // It is an error to call this function with an opcode that does not pass the // IsFoldableOpcode test. If any error occurs during folding, the folder will // fail with a call to assert. std::vector FoldVectors( spv::Op opcode, uint32_t num_dims, const std::vector& operands) const; // Returns true if |opcode| represents an operation handled by FoldScalars or // FoldVectors. bool IsFoldableOpcode(spv::Op opcode) const; // Returns true if |cst| is supported by FoldScalars and FoldVectors. bool IsFoldableConstant(const analysis::Constant* cst) const; // Returns true if |FoldInstructionToConstant| could fold an instruction whose // result type is |type_inst|. bool IsFoldableType(Instruction* type_inst) const; // Returns true if |FoldInstructionToConstant| could fold an instruction whose // result type is |type_inst|. bool IsFoldableScalarType(Instruction* type_inst) const; // Returns true if |FoldInstructionToConstant| could fold an instruction whose // result type is |type_inst|. bool IsFoldableVectorType(Instruction* type_inst) const; // Tries to fold |inst| to a single constant, when the input ids to |inst| // have been substituted using |id_map|. Returns a pointer to the OpConstant* // instruction if successful. If necessary, a new constant instruction is // created and placed in the global values section. // // |id_map| is a function that takes one result id and returns another. It // can be used for things like CCP where it is known that some ids contain a // constant, but the instruction itself has not been updated yet. This can // map those ids to the appropriate constants. Instruction* FoldInstructionToConstant( Instruction* inst, std::function id_map) const; // Returns true if |inst| can be folded into a simpler instruction. // If |inst| can be simplified, |inst| is overwritten with the simplified // instruction reusing the same result id. // // If |inst| is simplified, it is possible that the resulting code in invalid // because the instruction is in a bad location. Callers of this function // have to handle the following cases: // // 1) An OpPhi becomes and OpCopyObject - If there are OpPhi instruction after // |inst| in a basic block then this is invalid. The caller must fix this // up. bool FoldInstruction(Instruction* inst) const; // Return true if this opcode has a const folding rule associtated with it. bool HasConstFoldingRule(const Instruction* inst) const { return GetConstantFoldingRules().HasFoldingRule(inst); } private: // Returns a reference to the ConstnatFoldingRules instance. const ConstantFoldingRules& GetConstantFoldingRules() const { return *const_folding_rules_; } // Returns a reference to the FoldingRules instance. const FoldingRules& GetFoldingRules() const { return *folding_rules_; } // Returns the single-word result from performing the given unary operation on // the operand value which is passed in as a 32-bit word. uint32_t UnaryOperate(spv::Op opcode, uint32_t operand) const; // Returns the single-word result from performing the given binary operation // on the operand values which are passed in as two 32-bit word. uint32_t BinaryOperate(spv::Op opcode, uint32_t a, uint32_t b) const; // Returns the single-word result from performing the given ternary operation // on the operand values which are passed in as three 32-bit word. uint32_t TernaryOperate(spv::Op opcode, uint32_t a, uint32_t b, uint32_t c) const; // Returns the single-word result from performing the given operation on the // operand words. This only works with 32-bit operations and uses boolean // convention that 0u is false, and anything else is boolean true. // TODO(qining): Support operands other than 32-bit wide. uint32_t OperateWords(spv::Op opcode, const std::vector& operand_words) const; bool FoldInstructionInternal(Instruction* inst) const; // Returns true if |inst| is a binary operation that takes two integers as // parameters and folds to a constant that can be represented as an unsigned // 32-bit value when the ids have been replaced by |id_map|. If |inst| can be // folded, the resulting value is returned in |*result|. Valid result types // for the instruction are any integer (signed or unsigned) with 32-bits or // less, or a boolean value. bool FoldBinaryIntegerOpToConstant( Instruction* inst, const std::function& id_map, uint32_t* result) const; // Returns true if |inst| is a binary operation on two boolean values, and // folds // to a constant boolean value when the ids have been replaced using |id_map|. // If |inst| can be folded, the result value is returned in |*result|. bool FoldBinaryBooleanOpToConstant( Instruction* inst, const std::function& id_map, uint32_t* result) const; // Returns true if |inst| can be folded to an constant when the ids have been // substituted using id_map. If it can, the value is returned in |result|. If // not, |result| is unchanged. It is assumed that not all operands are // constant. Those cases are handled by |FoldScalar|. bool FoldIntegerOpToConstant(Instruction* inst, const std::function& id_map, uint32_t* result) const; IRContext* context_; // Folding rules used by |FoldInstructionToConstant| and |FoldInstruction|. std::unique_ptr const_folding_rules_; // Folding rules used by |FoldInstruction|. std::unique_ptr folding_rules_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_FOLD_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/fold_spec_constant_op_and_composite_pass.cpp000066400000000000000000000330171475742701700316420ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/fold_spec_constant_op_and_composite_pass.h" #include #include #include "source/opt/constants.h" #include "source/util/make_unique.h" namespace spvtools { namespace opt { Pass::Status FoldSpecConstantOpAndCompositePass::Process() { bool modified = false; analysis::ConstantManager* const_mgr = context()->get_constant_mgr(); // Traverse through all the constant defining instructions. For Normal // Constants whose values are determined and do not depend on OpUndef // instructions, records their values in two internal maps: id_to_const_val_ // and const_val_to_id_ so that we can use them to infer the value of Spec // Constants later. // For Spec Constants defined with OpSpecConstantComposite instructions, if // all of their components are Normal Constants, they will be turned into // Normal Constants too. For Spec Constants defined with OpSpecConstantOp // instructions, we check if they only depends on Normal Constants and fold // them when possible. The two maps for Normal Constants: id_to_const_val_ // and const_val_to_id_ will be updated along the traversal so that the new // Normal Constants generated from folding can be used to fold following Spec // Constants. // This algorithm depends on the SSA property of SPIR-V when // defining constants. The dependent constants must be defined before the // dependee constants. So a dependent Spec Constant must be defined and // will be processed before its dependee Spec Constant. When we encounter // the dependee Spec Constants, all its dependent constants must have been // processed and all its dependent Spec Constants should have been folded if // possible. Module::inst_iterator next_inst = context()->types_values_begin(); for (Module::inst_iterator inst_iter = next_inst; // Need to re-evaluate the end iterator since we may modify the list of // instructions in this section of the module as the process goes. inst_iter != context()->types_values_end(); inst_iter = next_inst) { ++next_inst; Instruction* inst = &*inst_iter; // Collect constant values of normal constants and process the // OpSpecConstantOp and OpSpecConstantComposite instructions if possible. // The constant values will be stored in analysis::Constant instances. // OpConstantSampler instruction is not collected here because it cannot be // used in OpSpecConstant{Composite|Op} instructions. // TODO(qining): If the constant or its type has decoration, we may need // to skip it. if (const_mgr->GetType(inst) && !const_mgr->GetType(inst)->decoration_empty()) continue; switch (spv::Op opcode = inst->opcode()) { // Records the values of Normal Constants. case spv::Op::OpConstantTrue: case spv::Op::OpConstantFalse: case spv::Op::OpConstant: case spv::Op::OpConstantNull: case spv::Op::OpConstantComposite: case spv::Op::OpSpecConstantComposite: { // A Constant instance will be created if the given instruction is a // Normal Constant whose value(s) are fixed. Note that for a composite // Spec Constant defined with OpSpecConstantComposite instruction, if // all of its components are Normal Constants already, the Spec // Constant will be turned in to a Normal Constant. In that case, a // Constant instance should also be created successfully and recorded // in the id_to_const_val_ and const_val_to_id_ mapps. if (auto const_value = const_mgr->GetConstantFromInst(inst)) { // Need to replace the OpSpecConstantComposite instruction with a // corresponding OpConstantComposite instruction. if (opcode == spv::Op::OpSpecConstantComposite) { inst->SetOpcode(spv::Op::OpConstantComposite); modified = true; } const_mgr->MapConstantToInst(const_value, inst); } break; } // For a Spec Constants defined with OpSpecConstantOp instruction, check // if it only depends on Normal Constants. If so, the Spec Constant will // be folded. The original Spec Constant defining instruction will be // replaced by Normal Constant defining instructions, and the new Normal // Constants will be added to id_to_const_val_ and const_val_to_id_ so // that we can use the new Normal Constants when folding following Spec // Constants. case spv::Op::OpSpecConstantOp: modified |= ProcessOpSpecConstantOp(&inst_iter); break; default: break; } } return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } bool FoldSpecConstantOpAndCompositePass::ProcessOpSpecConstantOp( Module::inst_iterator* pos) { Instruction* inst = &**pos; Instruction* folded_inst = nullptr; assert(inst->GetInOperand(0).type == SPV_OPERAND_TYPE_SPEC_CONSTANT_OP_NUMBER && "The first in-operand of OpSpecConstantOp instruction must be of " "SPV_OPERAND_TYPE_SPEC_CONSTANT_OP_NUMBER type"); folded_inst = FoldWithInstructionFolder(pos); if (!folded_inst) { folded_inst = DoComponentWiseOperation(pos); } if (!folded_inst) return false; // Replace the original constant with the new folded constant, kill the // original constant. uint32_t new_id = folded_inst->result_id(); uint32_t old_id = inst->result_id(); context()->ReplaceAllUsesWith(old_id, new_id); context()->KillDef(old_id); return true; } Instruction* FoldSpecConstantOpAndCompositePass::FoldWithInstructionFolder( Module::inst_iterator* inst_iter_ptr) { analysis::ConstantManager* const_mgr = context()->get_constant_mgr(); // If one of operands to the instruction is not a // constant, then we cannot fold this spec constant. for (uint32_t i = 1; i < (*inst_iter_ptr)->NumInOperands(); i++) { const Operand& operand = (*inst_iter_ptr)->GetInOperand(i); if (operand.type != SPV_OPERAND_TYPE_ID && operand.type != SPV_OPERAND_TYPE_OPTIONAL_ID) { continue; } uint32_t id = operand.words[0]; if (const_mgr->FindDeclaredConstant(id) == nullptr) { return nullptr; } } // All of the operands are constant. Construct a regular version of the // instruction and pass it to the instruction folder. std::unique_ptr inst((*inst_iter_ptr)->Clone(context())); inst->SetOpcode( static_cast((*inst_iter_ptr)->GetSingleWordInOperand(0))); inst->RemoveOperand(2); // We want the current instruction to be replaced by an |OpConstant*| // instruction in the same position. We need to keep track of which constants // the instruction folder creates, so we can move them into the correct place. auto last_type_value_iter = (context()->types_values_end()); --last_type_value_iter; Instruction* last_type_value = &*last_type_value_iter; auto identity_map = [](uint32_t id) { return id; }; Instruction* new_const_inst = context()->get_instruction_folder().FoldInstructionToConstant( inst.get(), identity_map); // new_const_inst == null indicates we cannot fold this spec constant if (!new_const_inst) return nullptr; // Get the instruction before |pos| to insert after. |pos| cannot be the // first instruction in the list because its type has to come first. Instruction* insert_pos = (*inst_iter_ptr)->PreviousNode(); assert(insert_pos != nullptr && "pos is the first instruction in the types and values."); bool need_to_clone = true; for (Instruction* i = last_type_value->NextNode(); i != nullptr; i = last_type_value->NextNode()) { if (i == new_const_inst) { need_to_clone = false; } i->InsertAfter(insert_pos); insert_pos = insert_pos->NextNode(); } if (need_to_clone) { new_const_inst = new_const_inst->Clone(context()); new_const_inst->SetResultId(TakeNextId()); new_const_inst->InsertAfter(insert_pos); get_def_use_mgr()->AnalyzeInstDefUse(new_const_inst); } const_mgr->MapInst(new_const_inst); return new_const_inst; } namespace { // A helper function to check the type for component wise operations. Returns // true if the type: // 1) is bool type; // 2) is 32-bit int type; // 3) is vector of bool type; // 4) is vector of 32-bit integer type. // Otherwise returns false. bool IsValidTypeForComponentWiseOperation(const analysis::Type* type) { if (type->AsBool()) { return true; } else if (auto* it = type->AsInteger()) { if (it->width() == 32) return true; } else if (auto* vt = type->AsVector()) { if (vt->element_type()->AsBool()) { return true; } else if (auto* vit = vt->element_type()->AsInteger()) { if (vit->width() == 32) return true; } } return false; } // Encodes the integer |value| of in a word vector format appropriate for // representing this value as a operands for a constant definition. Performs // zero-extension/sign-extension/truncation when needed, based on the signess of // the given target type. // // Note: type |type| argument must be either Integer or Bool. utils::SmallVector EncodeIntegerAsWords(const analysis::Type& type, uint32_t value) { const uint32_t all_ones = ~0; uint32_t bit_width = 0; uint32_t pad_value = 0; bool result_type_signed = false; if (auto* int_ty = type.AsInteger()) { bit_width = int_ty->width(); result_type_signed = int_ty->IsSigned(); if (result_type_signed && static_cast(value) < 0) { pad_value = all_ones; } } else if (type.AsBool()) { bit_width = 1; } else { assert(false && "type must be Integer or Bool"); } assert(bit_width > 0); uint32_t first_word = value; const uint32_t bits_per_word = 32; // Truncate first_word if the |type| has width less than uint32. if (bit_width < bits_per_word) { first_word = utils::SignExtendValue(first_word, bit_width); } utils::SmallVector words = {first_word}; for (uint32_t current_bit = bits_per_word; current_bit < bit_width; current_bit += bits_per_word) { words.push_back(pad_value); } return words; } } // namespace Instruction* FoldSpecConstantOpAndCompositePass::DoComponentWiseOperation( Module::inst_iterator* pos) { const Instruction* inst = &**pos; analysis::ConstantManager* const_mgr = context()->get_constant_mgr(); const analysis::Type* result_type = const_mgr->GetType(inst); spv::Op spec_opcode = static_cast(inst->GetSingleWordInOperand(0)); // Check and collect operands. std::vector operands; if (!std::all_of( inst->cbegin(), inst->cend(), [&operands, this](const Operand& o) { // skip the operands that is not an id. if (o.type != spv_operand_type_t::SPV_OPERAND_TYPE_ID) return true; uint32_t id = o.words.front(); if (auto c = context()->get_constant_mgr()->FindDeclaredConstant(id)) { if (IsValidTypeForComponentWiseOperation(c->type())) { operands.push_back(c); return true; } } return false; })) return nullptr; if (result_type->AsInteger() || result_type->AsBool()) { // Scalar operation const uint32_t result_val = context()->get_instruction_folder().FoldScalars(spec_opcode, operands); auto result_const = const_mgr->GetConstant( result_type, EncodeIntegerAsWords(*result_type, result_val)); return const_mgr->BuildInstructionAndAddToModule(result_const, pos); } else if (result_type->AsVector()) { // Vector operation const analysis::Type* element_type = result_type->AsVector()->element_type(); uint32_t num_dims = result_type->AsVector()->element_count(); std::vector result_vec = context()->get_instruction_folder().FoldVectors(spec_opcode, num_dims, operands); std::vector result_vector_components; for (const uint32_t r : result_vec) { if (auto rc = const_mgr->GetConstant( element_type, EncodeIntegerAsWords(*element_type, r))) { result_vector_components.push_back(rc); if (!const_mgr->BuildInstructionAndAddToModule(rc, pos)) { assert(false && "Failed to build and insert constant declaring instruction " "for the given vector component constant"); } } else { assert(false && "Failed to create constants with 32-bit word"); } } auto new_vec_const = MakeUnique( result_type->AsVector(), result_vector_components); auto reg_vec_const = const_mgr->RegisterConstant(std::move(new_vec_const)); return const_mgr->BuildInstructionAndAddToModule(reg_vec_const, pos); } else { // Cannot process invalid component wise operation. The result of component // wise operation must be of integer or bool scalar or vector of // integer/bool type. return nullptr; } } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/fold_spec_constant_op_and_composite_pass.h000066400000000000000000000056171475742701700313140ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_FOLD_SPEC_CONSTANT_OP_AND_COMPOSITE_PASS_H_ #define SOURCE_OPT_FOLD_SPEC_CONSTANT_OP_AND_COMPOSITE_PASS_H_ #include #include #include #include "source/opt/constants.h" #include "source/opt/def_use_manager.h" #include "source/opt/ir_context.h" #include "source/opt/module.h" #include "source/opt/pass.h" #include "source/opt/type_manager.h" namespace spvtools { namespace opt { // See optimizer.hpp for documentation. class FoldSpecConstantOpAndCompositePass : public Pass { public: FoldSpecConstantOpAndCompositePass() = default; const char* name() const override { return "fold-spec-const-op-composite"; } // Iterates through the types-constants-globals section of the given module, // finds the Spec Constants defined with OpSpecConstantOp and // OpSpecConstantComposite instructions. If the result value of those spec // constants can be folded, fold them to their corresponding normal constants. Status Process() override; private: // Processes the OpSpecConstantOp instruction pointed by the given // instruction iterator, folds it to normal constants if possible. Returns // true if the spec constant is folded to normal constants. New instructions // will be inserted before the OpSpecConstantOp instruction pointed by the // instruction iterator. The instruction iterator, which is passed by // pointer, will still point to the original OpSpecConstantOp instruction. If // folding is done successfully, the original OpSpecConstantOp instruction // will be changed to Nop and new folded instruction will be inserted before // it. bool ProcessOpSpecConstantOp(Module::inst_iterator* pos); // Returns the result of folding the OpSpecConstantOp instruction // |inst_iter_ptr| using the instruction folder. Instruction* FoldWithInstructionFolder(Module::inst_iterator* inst_iter_ptr); // Try to fold the OpSpecConstantOp instruction // pointed by the given instruction iterator to a normal constant defining // instruction. Returns the pointer to the new constant defining instruction // if succeeded, otherwise return nullptr. Instruction* DoComponentWiseOperation(Module::inst_iterator* inst_iter_ptr); }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_FOLD_SPEC_CONSTANT_OP_AND_COMPOSITE_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/folding_rules.cpp000066400000000000000000003351161475742701700242040ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/folding_rules.h" #include #include #include #include "ir_builder.h" #include "source/latest_version_glsl_std_450_header.h" #include "source/opt/ir_context.h" namespace spvtools { namespace opt { namespace { constexpr uint32_t kExtractCompositeIdInIdx = 0; constexpr uint32_t kInsertObjectIdInIdx = 0; constexpr uint32_t kInsertCompositeIdInIdx = 1; constexpr uint32_t kExtInstSetIdInIdx = 0; constexpr uint32_t kExtInstInstructionInIdx = 1; constexpr uint32_t kFMixXIdInIdx = 2; constexpr uint32_t kFMixYIdInIdx = 3; constexpr uint32_t kFMixAIdInIdx = 4; constexpr uint32_t kStoreObjectInIdx = 1; // Some image instructions may contain an "image operands" argument. // Returns the operand index for the "image operands". // Returns -1 if the instruction does not have image operands. int32_t ImageOperandsMaskInOperandIndex(Instruction* inst) { const auto opcode = inst->opcode(); switch (opcode) { case spv::Op::OpImageSampleImplicitLod: case spv::Op::OpImageSampleExplicitLod: case spv::Op::OpImageSampleProjImplicitLod: case spv::Op::OpImageSampleProjExplicitLod: case spv::Op::OpImageFetch: case spv::Op::OpImageRead: case spv::Op::OpImageSparseSampleImplicitLod: case spv::Op::OpImageSparseSampleExplicitLod: case spv::Op::OpImageSparseSampleProjImplicitLod: case spv::Op::OpImageSparseSampleProjExplicitLod: case spv::Op::OpImageSparseFetch: case spv::Op::OpImageSparseRead: return inst->NumOperands() > 4 ? 2 : -1; case spv::Op::OpImageSampleDrefImplicitLod: case spv::Op::OpImageSampleDrefExplicitLod: case spv::Op::OpImageSampleProjDrefImplicitLod: case spv::Op::OpImageSampleProjDrefExplicitLod: case spv::Op::OpImageGather: case spv::Op::OpImageDrefGather: case spv::Op::OpImageSparseSampleDrefImplicitLod: case spv::Op::OpImageSparseSampleDrefExplicitLod: case spv::Op::OpImageSparseSampleProjDrefImplicitLod: case spv::Op::OpImageSparseSampleProjDrefExplicitLod: case spv::Op::OpImageSparseGather: case spv::Op::OpImageSparseDrefGather: return inst->NumOperands() > 5 ? 3 : -1; case spv::Op::OpImageWrite: return inst->NumOperands() > 3 ? 3 : -1; default: return -1; } } // Returns the element width of |type|. uint32_t ElementWidth(const analysis::Type* type) { if (const analysis::CooperativeVectorNV* coopvec_type = type->AsCooperativeVectorNV()) { return ElementWidth(coopvec_type->component_type()); } else if (const analysis::Vector* vec_type = type->AsVector()) { return ElementWidth(vec_type->element_type()); } else if (const analysis::Float* float_type = type->AsFloat()) { return float_type->width(); } else { assert(type->AsInteger()); return type->AsInteger()->width(); } } // Returns true if |type| is Float or a vector of Float. bool HasFloatingPoint(const analysis::Type* type) { if (type->AsFloat()) { return true; } else if (const analysis::Vector* vec_type = type->AsVector()) { return vec_type->element_type()->AsFloat() != nullptr; } return false; } // Returns false if |val| is NaN, infinite or subnormal. template bool IsValidResult(T val) { int classified = std::fpclassify(val); switch (classified) { case FP_NAN: case FP_INFINITE: case FP_SUBNORMAL: return false; default: return true; } } // Returns true if `type` is a cooperative matrix. bool IsCooperativeMatrix(const analysis::Type* type) { return type->kind() == analysis::Type::kCooperativeMatrixKHR || type->kind() == analysis::Type::kCooperativeMatrixNV; } const analysis::Constant* ConstInput( const std::vector& constants) { return constants[0] ? constants[0] : constants[1]; } Instruction* NonConstInput(IRContext* context, const analysis::Constant* c, Instruction* inst) { uint32_t in_op = c ? 1u : 0u; return context->get_def_use_mgr()->GetDef( inst->GetSingleWordInOperand(in_op)); } std::vector ExtractInts(uint64_t val) { std::vector words; words.push_back(static_cast(val)); words.push_back(static_cast(val >> 32)); return words; } std::vector GetWordsFromScalarIntConstant( const analysis::IntConstant* c) { assert(c != nullptr); uint32_t width = c->type()->AsInteger()->width(); assert(width == 8 || width == 16 || width == 32 || width == 64); if (width == 64) { uint64_t uval = static_cast(c->GetU64()); return ExtractInts(uval); } // Section 2.2.1 of the SPIR-V spec guarantees that all integer types // smaller than 32-bits are automatically zero or sign extended to 32-bits. return {c->GetU32BitValue()}; } std::vector GetWordsFromScalarFloatConstant( const analysis::FloatConstant* c) { assert(c != nullptr); uint32_t width = c->type()->AsFloat()->width(); assert(width == 16 || width == 32 || width == 64); if (width == 64) { utils::FloatProxy result(c->GetDouble()); return result.GetWords(); } // Section 2.2.1 of the SPIR-V spec guarantees that all floating-point types // smaller than 32-bits are automatically zero extended to 32-bits. return {c->GetU32BitValue()}; } std::vector GetWordsFromNumericScalarOrVectorConstant( analysis::ConstantManager* const_mgr, const analysis::Constant* c) { if (const auto* float_constant = c->AsFloatConstant()) { return GetWordsFromScalarFloatConstant(float_constant); } else if (const auto* int_constant = c->AsIntConstant()) { return GetWordsFromScalarIntConstant(int_constant); } else if (const auto* vec_constant = c->AsVectorConstant()) { std::vector words; for (const auto* comp : vec_constant->GetComponents()) { auto comp_in_words = GetWordsFromNumericScalarOrVectorConstant(const_mgr, comp); words.insert(words.end(), comp_in_words.begin(), comp_in_words.end()); } return words; } return {}; } const analysis::Constant* ConvertWordsToNumericScalarOrVectorConstant( analysis::ConstantManager* const_mgr, const std::vector& words, const analysis::Type* type) { const spvtools::opt::analysis::Integer* int_type = type->AsInteger(); if (int_type && int_type->width() <= 32) { assert(words.size() == 1); return const_mgr->GenerateIntegerConstant(int_type, words[0]); } if (int_type || type->AsFloat()) return const_mgr->GetConstant(type, words); if (const auto* vec_type = type->AsVector()) return const_mgr->GetNumericVectorConstantWithWords(vec_type, words); return nullptr; } // Returns the negation of |c|. |c| must be a 32 or 64 bit floating point // constant. uint32_t NegateFloatingPointConstant(analysis::ConstantManager* const_mgr, const analysis::Constant* c) { assert(c); assert(c->type()->AsFloat()); uint32_t width = c->type()->AsFloat()->width(); assert(width == 32 || width == 64); std::vector words; if (width == 64) { utils::FloatProxy result(c->GetDouble() * -1.0); words = result.GetWords(); } else { utils::FloatProxy result(c->GetFloat() * -1.0f); words = result.GetWords(); } const analysis::Constant* negated_const = const_mgr->GetConstant(c->type(), std::move(words)); return const_mgr->GetDefiningInstruction(negated_const)->result_id(); } // Negates the integer constant |c|. Returns the id of the defining instruction. uint32_t NegateIntegerConstant(analysis::ConstantManager* const_mgr, const analysis::Constant* c) { assert(c); assert(c->type()->AsInteger()); uint32_t width = c->type()->AsInteger()->width(); assert(width == 32 || width == 64); std::vector words; if (width == 64) { uint64_t uval = static_cast(0 - c->GetU64()); words = ExtractInts(uval); } else { words.push_back(static_cast(0 - c->GetU32())); } const analysis::Constant* negated_const = const_mgr->GetConstant(c->type(), std::move(words)); return const_mgr->GetDefiningInstruction(negated_const)->result_id(); } // Negates the vector constant |c|. Returns the id of the defining instruction. uint32_t NegateVectorConstant(analysis::ConstantManager* const_mgr, const analysis::Constant* c) { assert(const_mgr && c); assert(c->type()->AsVector()); if (c->AsNullConstant()) { // 0.0 vs -0.0 shouldn't matter. return const_mgr->GetDefiningInstruction(c)->result_id(); } else { const analysis::Type* component_type = c->AsVectorConstant()->component_type(); std::vector words; for (auto& comp : c->AsVectorConstant()->GetComponents()) { if (component_type->AsFloat()) { words.push_back(NegateFloatingPointConstant(const_mgr, comp)); } else { assert(component_type->AsInteger()); words.push_back(NegateIntegerConstant(const_mgr, comp)); } } const analysis::Constant* negated_const = const_mgr->GetConstant(c->type(), std::move(words)); return const_mgr->GetDefiningInstruction(negated_const)->result_id(); } } // Negates |c|. Returns the id of the defining instruction. uint32_t NegateConstant(analysis::ConstantManager* const_mgr, const analysis::Constant* c) { if (c->type()->AsVector()) { return NegateVectorConstant(const_mgr, c); } else if (c->type()->AsFloat()) { return NegateFloatingPointConstant(const_mgr, c); } else { assert(c->type()->AsInteger()); return NegateIntegerConstant(const_mgr, c); } } // Takes the reciprocal of |c|. |c|'s type must be Float or a vector of Float. // Returns 0 if the reciprocal is NaN, infinite or subnormal. uint32_t Reciprocal(analysis::ConstantManager* const_mgr, const analysis::Constant* c) { assert(const_mgr && c); assert(c->type()->AsFloat()); uint32_t width = c->type()->AsFloat()->width(); assert(width == 32 || width == 64); std::vector words; if (c->IsZero()) { return 0; } if (width == 64) { spvtools::utils::FloatProxy result(1.0 / c->GetDouble()); if (!IsValidResult(result.getAsFloat())) return 0; words = result.GetWords(); } else { spvtools::utils::FloatProxy result(1.0f / c->GetFloat()); if (!IsValidResult(result.getAsFloat())) return 0; words = result.GetWords(); } const analysis::Constant* negated_const = const_mgr->GetConstant(c->type(), std::move(words)); return const_mgr->GetDefiningInstruction(negated_const)->result_id(); } // Replaces fdiv where second operand is constant with fmul. FoldingRule ReciprocalFDiv() { return [](IRContext* context, Instruction* inst, const std::vector& constants) { assert(inst->opcode() == spv::Op::OpFDiv); analysis::ConstantManager* const_mgr = context->get_constant_mgr(); const analysis::Type* type = context->get_type_mgr()->GetType(inst->type_id()); if (IsCooperativeMatrix(type)) { return false; } if (!inst->IsFloatingPointFoldingAllowed()) return false; uint32_t width = ElementWidth(type); if (width != 32 && width != 64) return false; if (constants[1] != nullptr) { uint32_t id = 0; if (const analysis::VectorConstant* vector_const = constants[1]->AsVectorConstant()) { std::vector neg_ids; for (auto& comp : vector_const->GetComponents()) { id = Reciprocal(const_mgr, comp); if (id == 0) return false; neg_ids.push_back(id); } const analysis::Constant* negated_const = const_mgr->GetConstant(constants[1]->type(), std::move(neg_ids)); id = const_mgr->GetDefiningInstruction(negated_const)->result_id(); } else if (constants[1]->AsFloatConstant()) { id = Reciprocal(const_mgr, constants[1]); if (id == 0) return false; } else { // Don't fold a null constant. return false; } inst->SetOpcode(spv::Op::OpFMul); inst->SetInOperands( {{SPV_OPERAND_TYPE_ID, {inst->GetSingleWordInOperand(0u)}}, {SPV_OPERAND_TYPE_ID, {id}}}); return true; } return false; }; } // Elides consecutive negate instructions. FoldingRule MergeNegateArithmetic() { return [](IRContext* context, Instruction* inst, const std::vector& constants) { assert(inst->opcode() == spv::Op::OpFNegate || inst->opcode() == spv::Op::OpSNegate); (void)constants; const analysis::Type* type = context->get_type_mgr()->GetType(inst->type_id()); if (HasFloatingPoint(type) && !inst->IsFloatingPointFoldingAllowed()) return false; Instruction* op_inst = context->get_def_use_mgr()->GetDef(inst->GetSingleWordInOperand(0u)); if (HasFloatingPoint(type) && !op_inst->IsFloatingPointFoldingAllowed()) return false; if (op_inst->opcode() == inst->opcode()) { // Elide negates. inst->SetOpcode(spv::Op::OpCopyObject); inst->SetInOperands( {{SPV_OPERAND_TYPE_ID, {op_inst->GetSingleWordInOperand(0u)}}}); return true; } return false; }; } // Merges negate into a mul or div operation if that operation contains a // constant operand. // Cases: // -(x * 2) = x * -2 // -(2 * x) = x * -2 // -(x / 2) = x / -2 // -(2 / x) = -2 / x FoldingRule MergeNegateMulDivArithmetic() { return [](IRContext* context, Instruction* inst, const std::vector& constants) { assert(inst->opcode() == spv::Op::OpFNegate || inst->opcode() == spv::Op::OpSNegate); (void)constants; analysis::ConstantManager* const_mgr = context->get_constant_mgr(); const analysis::Type* type = context->get_type_mgr()->GetType(inst->type_id()); if (IsCooperativeMatrix(type)) { return false; } if (HasFloatingPoint(type) && !inst->IsFloatingPointFoldingAllowed()) return false; Instruction* op_inst = context->get_def_use_mgr()->GetDef(inst->GetSingleWordInOperand(0u)); if (HasFloatingPoint(type) && !op_inst->IsFloatingPointFoldingAllowed()) return false; uint32_t width = ElementWidth(type); if (width != 32 && width != 64) return false; spv::Op opcode = op_inst->opcode(); if (opcode != spv::Op::OpFMul && opcode != spv::Op::OpFDiv && opcode != spv::Op::OpIMul && opcode != spv::Op::OpSDiv) { return false; } std::vector op_constants = const_mgr->GetOperandConstants(op_inst); // Merge negate into mul or div if one operand is constant. if (op_constants[0] == nullptr && op_constants[1] == nullptr) { return false; } bool zero_is_variable = op_constants[0] == nullptr; const analysis::Constant* c = ConstInput(op_constants); uint32_t neg_id = NegateConstant(const_mgr, c); uint32_t non_const_id = zero_is_variable ? op_inst->GetSingleWordInOperand(0u) : op_inst->GetSingleWordInOperand(1u); // Change this instruction to a mul/div. inst->SetOpcode(op_inst->opcode()); if (opcode == spv::Op::OpFDiv || opcode == spv::Op::OpUDiv || opcode == spv::Op::OpSDiv) { uint32_t op0 = zero_is_variable ? non_const_id : neg_id; uint32_t op1 = zero_is_variable ? neg_id : non_const_id; inst->SetInOperands( {{SPV_OPERAND_TYPE_ID, {op0}}, {SPV_OPERAND_TYPE_ID, {op1}}}); } else { inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {non_const_id}}, {SPV_OPERAND_TYPE_ID, {neg_id}}}); } return true; }; } // Merges negate into a add or sub operation if that operation contains a // constant operand. // Cases: // -(x + 2) = -2 - x // -(2 + x) = -2 - x // -(x - 2) = 2 - x // -(2 - x) = x - 2 FoldingRule MergeNegateAddSubArithmetic() { return [](IRContext* context, Instruction* inst, const std::vector& constants) { assert(inst->opcode() == spv::Op::OpFNegate || inst->opcode() == spv::Op::OpSNegate); (void)constants; analysis::ConstantManager* const_mgr = context->get_constant_mgr(); const analysis::Type* type = context->get_type_mgr()->GetType(inst->type_id()); if (IsCooperativeMatrix(type)) { return false; } if (HasFloatingPoint(type) && !inst->IsFloatingPointFoldingAllowed()) return false; Instruction* op_inst = context->get_def_use_mgr()->GetDef(inst->GetSingleWordInOperand(0u)); if (HasFloatingPoint(type) && !op_inst->IsFloatingPointFoldingAllowed()) return false; uint32_t width = ElementWidth(type); if (width != 32 && width != 64) return false; if (op_inst->opcode() == spv::Op::OpFAdd || op_inst->opcode() == spv::Op::OpFSub || op_inst->opcode() == spv::Op::OpIAdd || op_inst->opcode() == spv::Op::OpISub) { std::vector op_constants = const_mgr->GetOperandConstants(op_inst); if (op_constants[0] || op_constants[1]) { bool zero_is_variable = op_constants[0] == nullptr; bool is_add = (op_inst->opcode() == spv::Op::OpFAdd) || (op_inst->opcode() == spv::Op::OpIAdd); bool swap_operands = !is_add || zero_is_variable; bool negate_const = is_add; const analysis::Constant* c = ConstInput(op_constants); uint32_t const_id = 0; if (negate_const) { const_id = NegateConstant(const_mgr, c); } else { const_id = zero_is_variable ? op_inst->GetSingleWordInOperand(1u) : op_inst->GetSingleWordInOperand(0u); } // Swap operands if necessary and make the instruction a subtraction. uint32_t op0 = zero_is_variable ? op_inst->GetSingleWordInOperand(0u) : const_id; uint32_t op1 = zero_is_variable ? const_id : op_inst->GetSingleWordInOperand(1u); if (swap_operands) std::swap(op0, op1); inst->SetOpcode(HasFloatingPoint(type) ? spv::Op::OpFSub : spv::Op::OpISub); inst->SetInOperands( {{SPV_OPERAND_TYPE_ID, {op0}}, {SPV_OPERAND_TYPE_ID, {op1}}}); return true; } } return false; }; } // Returns true if |c| has a zero element. bool HasZero(const analysis::Constant* c) { if (c->AsNullConstant()) { return true; } if (const analysis::VectorConstant* vec_const = c->AsVectorConstant()) { for (auto& comp : vec_const->GetComponents()) if (HasZero(comp)) return true; } else { assert(c->AsScalarConstant()); return c->AsScalarConstant()->IsZero(); } return false; } // Performs |input1| |opcode| |input2| and returns the merged constant result // id. Returns 0 if the result is not a valid value. The input types must be // Float. uint32_t PerformFloatingPointOperation(analysis::ConstantManager* const_mgr, spv::Op opcode, const analysis::Constant* input1, const analysis::Constant* input2) { const analysis::Type* type = input1->type(); assert(type->AsFloat()); uint32_t width = type->AsFloat()->width(); assert(width == 32 || width == 64); std::vector words; #define FOLD_OP(op) \ if (width == 64) { \ utils::FloatProxy val = \ input1->GetDouble() op input2->GetDouble(); \ double dval = val.getAsFloat(); \ if (!IsValidResult(dval)) return 0; \ words = val.GetWords(); \ } else { \ utils::FloatProxy val = input1->GetFloat() op input2->GetFloat(); \ float fval = val.getAsFloat(); \ if (!IsValidResult(fval)) return 0; \ words = val.GetWords(); \ } \ static_assert(true, "require extra semicolon") switch (opcode) { case spv::Op::OpFMul: FOLD_OP(*); break; case spv::Op::OpFDiv: if (HasZero(input2)) return 0; FOLD_OP(/); break; case spv::Op::OpFAdd: FOLD_OP(+); break; case spv::Op::OpFSub: FOLD_OP(-); break; default: assert(false && "Unexpected operation"); break; } #undef FOLD_OP const analysis::Constant* merged_const = const_mgr->GetConstant(type, words); return const_mgr->GetDefiningInstruction(merged_const)->result_id(); } // Performs |input1| |opcode| |input2| and returns the merged constant result // id. Returns 0 if the result is not a valid value. The input types must be // Integers. uint32_t PerformIntegerOperation(analysis::ConstantManager* const_mgr, spv::Op opcode, const analysis::Constant* input1, const analysis::Constant* input2) { assert(input1->type()->AsInteger()); const analysis::Integer* type = input1->type()->AsInteger(); uint32_t width = type->AsInteger()->width(); assert(width == 32 || width == 64); std::vector words; // Regardless of the sign of the constant, folding is performed on an unsigned // interpretation of the constant data. This avoids signed integer overflow // while folding, and works because sign is irrelevant for the IAdd, ISub and // IMul instructions. #define FOLD_OP(op) \ if (width == 64) { \ uint64_t val = input1->GetU64() op input2->GetU64(); \ words = ExtractInts(val); \ } else { \ uint32_t val = input1->GetU32() op input2->GetU32(); \ words.push_back(val); \ } \ static_assert(true, "require extra semicolon") switch (opcode) { case spv::Op::OpIMul: FOLD_OP(*); break; case spv::Op::OpSDiv: case spv::Op::OpUDiv: assert(false && "Should not merge integer division"); break; case spv::Op::OpIAdd: FOLD_OP(+); break; case spv::Op::OpISub: FOLD_OP(-); break; default: assert(false && "Unexpected operation"); break; } #undef FOLD_OP const analysis::Constant* merged_const = const_mgr->GetConstant(type, words); return const_mgr->GetDefiningInstruction(merged_const)->result_id(); } // Performs |input1| |opcode| |input2| and returns the merged constant result // id. Returns 0 if the result is not a valid value. The input types must be // Integers, Floats or Vectors of such. uint32_t PerformOperation(analysis::ConstantManager* const_mgr, spv::Op opcode, const analysis::Constant* input1, const analysis::Constant* input2) { assert(input1 && input2); const analysis::Type* type = input1->type(); std::vector words; if (const analysis::Vector* vector_type = type->AsVector()) { const analysis::Type* ele_type = vector_type->element_type(); for (uint32_t i = 0; i != vector_type->element_count(); ++i) { uint32_t id = 0; const analysis::Constant* input1_comp = nullptr; if (const analysis::VectorConstant* input1_vector = input1->AsVectorConstant()) { input1_comp = input1_vector->GetComponents()[i]; } else { assert(input1->AsNullConstant()); input1_comp = const_mgr->GetConstant(ele_type, {}); } const analysis::Constant* input2_comp = nullptr; if (const analysis::VectorConstant* input2_vector = input2->AsVectorConstant()) { input2_comp = input2_vector->GetComponents()[i]; } else { assert(input2->AsNullConstant()); input2_comp = const_mgr->GetConstant(ele_type, {}); } if (ele_type->AsFloat()) { id = PerformFloatingPointOperation(const_mgr, opcode, input1_comp, input2_comp); } else { assert(ele_type->AsInteger()); id = PerformIntegerOperation(const_mgr, opcode, input1_comp, input2_comp); } if (id == 0) return 0; words.push_back(id); } const analysis::Constant* merged_const = const_mgr->GetConstant(type, words); return const_mgr->GetDefiningInstruction(merged_const)->result_id(); } else if (type->AsFloat()) { return PerformFloatingPointOperation(const_mgr, opcode, input1, input2); } else { assert(type->AsInteger()); return PerformIntegerOperation(const_mgr, opcode, input1, input2); } } // Merges consecutive multiplies where each contains one constant operand. // Cases: // 2 * (x * 2) = x * 4 // 2 * (2 * x) = x * 4 // (x * 2) * 2 = x * 4 // (2 * x) * 2 = x * 4 FoldingRule MergeMulMulArithmetic() { return [](IRContext* context, Instruction* inst, const std::vector& constants) { assert(inst->opcode() == spv::Op::OpFMul || inst->opcode() == spv::Op::OpIMul); analysis::ConstantManager* const_mgr = context->get_constant_mgr(); const analysis::Type* type = context->get_type_mgr()->GetType(inst->type_id()); if (IsCooperativeMatrix(type)) { return false; } if (HasFloatingPoint(type) && !inst->IsFloatingPointFoldingAllowed()) return false; uint32_t width = ElementWidth(type); if (width != 32 && width != 64) return false; // Determine the constant input and the variable input in |inst|. const analysis::Constant* const_input1 = ConstInput(constants); if (!const_input1) return false; Instruction* other_inst = NonConstInput(context, constants[0], inst); if (HasFloatingPoint(type) && !other_inst->IsFloatingPointFoldingAllowed()) return false; if (other_inst->opcode() == inst->opcode()) { std::vector other_constants = const_mgr->GetOperandConstants(other_inst); const analysis::Constant* const_input2 = ConstInput(other_constants); if (!const_input2) return false; bool other_first_is_variable = other_constants[0] == nullptr; uint32_t merged_id = PerformOperation(const_mgr, inst->opcode(), const_input1, const_input2); if (merged_id == 0) return false; uint32_t non_const_id = other_first_is_variable ? other_inst->GetSingleWordInOperand(0u) : other_inst->GetSingleWordInOperand(1u); inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {non_const_id}}, {SPV_OPERAND_TYPE_ID, {merged_id}}}); return true; } return false; }; } // Merges divides into subsequent multiplies if each instruction contains one // constant operand. Does not support integer operations. // Cases: // 2 * (x / 2) = x * 1 // 2 * (2 / x) = 4 / x // (x / 2) * 2 = x * 1 // (2 / x) * 2 = 4 / x // (y / x) * x = y // x * (y / x) = y FoldingRule MergeMulDivArithmetic() { return [](IRContext* context, Instruction* inst, const std::vector& constants) { assert(inst->opcode() == spv::Op::OpFMul); analysis::ConstantManager* const_mgr = context->get_constant_mgr(); analysis::DefUseManager* def_use_mgr = context->get_def_use_mgr(); const analysis::Type* type = context->get_type_mgr()->GetType(inst->type_id()); if (IsCooperativeMatrix(type)) { return false; } if (!inst->IsFloatingPointFoldingAllowed()) return false; uint32_t width = ElementWidth(type); if (width != 32 && width != 64) return false; for (uint32_t i = 0; i < 2; i++) { uint32_t op_id = inst->GetSingleWordInOperand(i); Instruction* op_inst = def_use_mgr->GetDef(op_id); if (op_inst->opcode() == spv::Op::OpFDiv) { if (op_inst->GetSingleWordInOperand(1) == inst->GetSingleWordInOperand(1 - i)) { inst->SetOpcode(spv::Op::OpCopyObject); inst->SetInOperands( {{SPV_OPERAND_TYPE_ID, {op_inst->GetSingleWordInOperand(0)}}}); return true; } } } const analysis::Constant* const_input1 = ConstInput(constants); if (!const_input1) return false; Instruction* other_inst = NonConstInput(context, constants[0], inst); if (!other_inst->IsFloatingPointFoldingAllowed()) return false; if (other_inst->opcode() == spv::Op::OpFDiv) { std::vector other_constants = const_mgr->GetOperandConstants(other_inst); const analysis::Constant* const_input2 = ConstInput(other_constants); if (!const_input2 || HasZero(const_input2)) return false; bool other_first_is_variable = other_constants[0] == nullptr; // If the variable value is the second operand of the divide, multiply // the constants together. Otherwise divide the constants. uint32_t merged_id = PerformOperation( const_mgr, other_first_is_variable ? other_inst->opcode() : inst->opcode(), const_input1, const_input2); if (merged_id == 0) return false; uint32_t non_const_id = other_first_is_variable ? other_inst->GetSingleWordInOperand(0u) : other_inst->GetSingleWordInOperand(1u); // If the variable value is on the second operand of the div, then this // operation is a div. Otherwise it should be a multiply. inst->SetOpcode(other_first_is_variable ? inst->opcode() : other_inst->opcode()); if (other_first_is_variable) { inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {non_const_id}}, {SPV_OPERAND_TYPE_ID, {merged_id}}}); } else { inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {merged_id}}, {SPV_OPERAND_TYPE_ID, {non_const_id}}}); } return true; } return false; }; } // Merges multiply of constant and negation. // Cases: // (-x) * 2 = x * -2 // 2 * (-x) = x * -2 FoldingRule MergeMulNegateArithmetic() { return [](IRContext* context, Instruction* inst, const std::vector& constants) { assert(inst->opcode() == spv::Op::OpFMul || inst->opcode() == spv::Op::OpIMul); analysis::ConstantManager* const_mgr = context->get_constant_mgr(); const analysis::Type* type = context->get_type_mgr()->GetType(inst->type_id()); if (IsCooperativeMatrix(type)) { return false; } bool uses_float = HasFloatingPoint(type); if (uses_float && !inst->IsFloatingPointFoldingAllowed()) return false; uint32_t width = ElementWidth(type); if (width != 32 && width != 64) return false; const analysis::Constant* const_input1 = ConstInput(constants); if (!const_input1) return false; Instruction* other_inst = NonConstInput(context, constants[0], inst); if (uses_float && !other_inst->IsFloatingPointFoldingAllowed()) return false; if (other_inst->opcode() == spv::Op::OpFNegate || other_inst->opcode() == spv::Op::OpSNegate) { uint32_t neg_id = NegateConstant(const_mgr, const_input1); inst->SetInOperands( {{SPV_OPERAND_TYPE_ID, {other_inst->GetSingleWordInOperand(0u)}}, {SPV_OPERAND_TYPE_ID, {neg_id}}}); return true; } return false; }; } // Merges consecutive divides if each instruction contains one constant operand. // Does not support integer division. // Cases: // 2 / (x / 2) = 4 / x // 4 / (2 / x) = 2 * x // (4 / x) / 2 = 2 / x // (x / 2) / 2 = x / 4 FoldingRule MergeDivDivArithmetic() { return [](IRContext* context, Instruction* inst, const std::vector& constants) { assert(inst->opcode() == spv::Op::OpFDiv); analysis::ConstantManager* const_mgr = context->get_constant_mgr(); const analysis::Type* type = context->get_type_mgr()->GetType(inst->type_id()); if (IsCooperativeMatrix(type)) { return false; } if (!inst->IsFloatingPointFoldingAllowed()) return false; uint32_t width = ElementWidth(type); if (width != 32 && width != 64) return false; const analysis::Constant* const_input1 = ConstInput(constants); if (!const_input1 || HasZero(const_input1)) return false; Instruction* other_inst = NonConstInput(context, constants[0], inst); if (!other_inst->IsFloatingPointFoldingAllowed()) return false; bool first_is_variable = constants[0] == nullptr; if (other_inst->opcode() == inst->opcode()) { std::vector other_constants = const_mgr->GetOperandConstants(other_inst); const analysis::Constant* const_input2 = ConstInput(other_constants); if (!const_input2 || HasZero(const_input2)) return false; bool other_first_is_variable = other_constants[0] == nullptr; spv::Op merge_op = inst->opcode(); if (other_first_is_variable) { // Constants magnify. merge_op = spv::Op::OpFMul; } // This is an x / (*) case. Swap the inputs. Doesn't harm multiply // because it is commutative. if (first_is_variable) std::swap(const_input1, const_input2); uint32_t merged_id = PerformOperation(const_mgr, merge_op, const_input1, const_input2); if (merged_id == 0) return false; uint32_t non_const_id = other_first_is_variable ? other_inst->GetSingleWordInOperand(0u) : other_inst->GetSingleWordInOperand(1u); spv::Op op = inst->opcode(); if (!first_is_variable && !other_first_is_variable) { // Effectively div of 1/x, so change to multiply. op = spv::Op::OpFMul; } uint32_t op1 = merged_id; uint32_t op2 = non_const_id; if (first_is_variable && other_first_is_variable) std::swap(op1, op2); inst->SetOpcode(op); inst->SetInOperands( {{SPV_OPERAND_TYPE_ID, {op1}}, {SPV_OPERAND_TYPE_ID, {op2}}}); return true; } return false; }; } // Fold multiplies succeeded by divides where each instruction contains a // constant operand. Does not support integer divide. // Cases: // 4 / (x * 2) = 2 / x // 4 / (2 * x) = 2 / x // (x * 4) / 2 = x * 2 // (4 * x) / 2 = x * 2 // (x * y) / x = y // (y * x) / x = y FoldingRule MergeDivMulArithmetic() { return [](IRContext* context, Instruction* inst, const std::vector& constants) { assert(inst->opcode() == spv::Op::OpFDiv); analysis::DefUseManager* def_use_mgr = context->get_def_use_mgr(); analysis::ConstantManager* const_mgr = context->get_constant_mgr(); const analysis::Type* type = context->get_type_mgr()->GetType(inst->type_id()); if (IsCooperativeMatrix(type)) { return false; } if (!inst->IsFloatingPointFoldingAllowed()) return false; uint32_t width = ElementWidth(type); if (width != 32 && width != 64) return false; uint32_t op_id = inst->GetSingleWordInOperand(0); Instruction* op_inst = def_use_mgr->GetDef(op_id); if (op_inst->opcode() == spv::Op::OpFMul) { for (uint32_t i = 0; i < 2; i++) { if (op_inst->GetSingleWordInOperand(i) == inst->GetSingleWordInOperand(1)) { inst->SetOpcode(spv::Op::OpCopyObject); inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {op_inst->GetSingleWordInOperand(1 - i)}}}); return true; } } } const analysis::Constant* const_input1 = ConstInput(constants); if (!const_input1 || HasZero(const_input1)) return false; Instruction* other_inst = NonConstInput(context, constants[0], inst); if (!other_inst->IsFloatingPointFoldingAllowed()) return false; bool first_is_variable = constants[0] == nullptr; if (other_inst->opcode() == spv::Op::OpFMul) { std::vector other_constants = const_mgr->GetOperandConstants(other_inst); const analysis::Constant* const_input2 = ConstInput(other_constants); if (!const_input2) return false; bool other_first_is_variable = other_constants[0] == nullptr; // This is an x / (*) case. Swap the inputs. if (first_is_variable) std::swap(const_input1, const_input2); uint32_t merged_id = PerformOperation(const_mgr, inst->opcode(), const_input1, const_input2); if (merged_id == 0) return false; uint32_t non_const_id = other_first_is_variable ? other_inst->GetSingleWordInOperand(0u) : other_inst->GetSingleWordInOperand(1u); uint32_t op1 = merged_id; uint32_t op2 = non_const_id; if (first_is_variable) std::swap(op1, op2); // Convert to multiply if (first_is_variable) inst->SetOpcode(other_inst->opcode()); inst->SetInOperands( {{SPV_OPERAND_TYPE_ID, {op1}}, {SPV_OPERAND_TYPE_ID, {op2}}}); return true; } return false; }; } // Fold divides of a constant and a negation. // Cases: // (-x) / 2 = x / -2 // 2 / (-x) = -2 / x FoldingRule MergeDivNegateArithmetic() { return [](IRContext* context, Instruction* inst, const std::vector& constants) { assert(inst->opcode() == spv::Op::OpFDiv); analysis::ConstantManager* const_mgr = context->get_constant_mgr(); if (!inst->IsFloatingPointFoldingAllowed()) return false; const analysis::Constant* const_input1 = ConstInput(constants); if (!const_input1) return false; Instruction* other_inst = NonConstInput(context, constants[0], inst); if (!other_inst->IsFloatingPointFoldingAllowed()) return false; bool first_is_variable = constants[0] == nullptr; if (other_inst->opcode() == spv::Op::OpFNegate) { uint32_t neg_id = NegateConstant(const_mgr, const_input1); if (first_is_variable) { inst->SetInOperands( {{SPV_OPERAND_TYPE_ID, {other_inst->GetSingleWordInOperand(0u)}}, {SPV_OPERAND_TYPE_ID, {neg_id}}}); } else { inst->SetInOperands( {{SPV_OPERAND_TYPE_ID, {neg_id}}, {SPV_OPERAND_TYPE_ID, {other_inst->GetSingleWordInOperand(0u)}}}); } return true; } return false; }; } // Folds addition of a constant and a negation. // Cases: // (-x) + 2 = 2 - x // 2 + (-x) = 2 - x FoldingRule MergeAddNegateArithmetic() { return [](IRContext* context, Instruction* inst, const std::vector& constants) { assert(inst->opcode() == spv::Op::OpFAdd || inst->opcode() == spv::Op::OpIAdd); const analysis::Type* type = context->get_type_mgr()->GetType(inst->type_id()); bool uses_float = HasFloatingPoint(type); if (uses_float && !inst->IsFloatingPointFoldingAllowed()) return false; const analysis::Constant* const_input1 = ConstInput(constants); if (!const_input1) return false; Instruction* other_inst = NonConstInput(context, constants[0], inst); if (uses_float && !other_inst->IsFloatingPointFoldingAllowed()) return false; if (other_inst->opcode() == spv::Op::OpSNegate || other_inst->opcode() == spv::Op::OpFNegate) { inst->SetOpcode(HasFloatingPoint(type) ? spv::Op::OpFSub : spv::Op::OpISub); uint32_t const_id = constants[0] ? inst->GetSingleWordInOperand(0u) : inst->GetSingleWordInOperand(1u); inst->SetInOperands( {{SPV_OPERAND_TYPE_ID, {const_id}}, {SPV_OPERAND_TYPE_ID, {other_inst->GetSingleWordInOperand(0u)}}}); return true; } return false; }; } // Folds subtraction of a constant and a negation. // Cases: // (-x) - 2 = -2 - x // 2 - (-x) = x + 2 FoldingRule MergeSubNegateArithmetic() { return [](IRContext* context, Instruction* inst, const std::vector& constants) { assert(inst->opcode() == spv::Op::OpFSub || inst->opcode() == spv::Op::OpISub); analysis::ConstantManager* const_mgr = context->get_constant_mgr(); const analysis::Type* type = context->get_type_mgr()->GetType(inst->type_id()); if (IsCooperativeMatrix(type)) { return false; } bool uses_float = HasFloatingPoint(type); if (uses_float && !inst->IsFloatingPointFoldingAllowed()) return false; uint32_t width = ElementWidth(type); if (width != 32 && width != 64) return false; const analysis::Constant* const_input1 = ConstInput(constants); if (!const_input1) return false; Instruction* other_inst = NonConstInput(context, constants[0], inst); if (uses_float && !other_inst->IsFloatingPointFoldingAllowed()) return false; if (other_inst->opcode() == spv::Op::OpSNegate || other_inst->opcode() == spv::Op::OpFNegate) { uint32_t op1 = 0; uint32_t op2 = 0; spv::Op opcode = inst->opcode(); if (constants[0] != nullptr) { op1 = other_inst->GetSingleWordInOperand(0u); op2 = inst->GetSingleWordInOperand(0u); opcode = HasFloatingPoint(type) ? spv::Op::OpFAdd : spv::Op::OpIAdd; } else { op1 = NegateConstant(const_mgr, const_input1); op2 = other_inst->GetSingleWordInOperand(0u); } inst->SetOpcode(opcode); inst->SetInOperands( {{SPV_OPERAND_TYPE_ID, {op1}}, {SPV_OPERAND_TYPE_ID, {op2}}}); return true; } return false; }; } // Folds addition of an addition where each operation has a constant operand. // Cases: // (x + 2) + 2 = x + 4 // (2 + x) + 2 = x + 4 // 2 + (x + 2) = x + 4 // 2 + (2 + x) = x + 4 FoldingRule MergeAddAddArithmetic() { return [](IRContext* context, Instruction* inst, const std::vector& constants) { assert(inst->opcode() == spv::Op::OpFAdd || inst->opcode() == spv::Op::OpIAdd); const analysis::Type* type = context->get_type_mgr()->GetType(inst->type_id()); if (IsCooperativeMatrix(type)) { return false; } analysis::ConstantManager* const_mgr = context->get_constant_mgr(); bool uses_float = HasFloatingPoint(type); if (uses_float && !inst->IsFloatingPointFoldingAllowed()) return false; uint32_t width = ElementWidth(type); if (width != 32 && width != 64) return false; const analysis::Constant* const_input1 = ConstInput(constants); if (!const_input1) return false; Instruction* other_inst = NonConstInput(context, constants[0], inst); if (uses_float && !other_inst->IsFloatingPointFoldingAllowed()) return false; if (other_inst->opcode() == spv::Op::OpFAdd || other_inst->opcode() == spv::Op::OpIAdd) { std::vector other_constants = const_mgr->GetOperandConstants(other_inst); const analysis::Constant* const_input2 = ConstInput(other_constants); if (!const_input2) return false; Instruction* non_const_input = NonConstInput(context, other_constants[0], other_inst); uint32_t merged_id = PerformOperation(const_mgr, inst->opcode(), const_input1, const_input2); if (merged_id == 0) return false; inst->SetInOperands( {{SPV_OPERAND_TYPE_ID, {non_const_input->result_id()}}, {SPV_OPERAND_TYPE_ID, {merged_id}}}); return true; } return false; }; } // Folds addition of a subtraction where each operation has a constant operand. // Cases: // (x - 2) + 2 = x + 0 // (2 - x) + 2 = 4 - x // 2 + (x - 2) = x + 0 // 2 + (2 - x) = 4 - x FoldingRule MergeAddSubArithmetic() { return [](IRContext* context, Instruction* inst, const std::vector& constants) { assert(inst->opcode() == spv::Op::OpFAdd || inst->opcode() == spv::Op::OpIAdd); const analysis::Type* type = context->get_type_mgr()->GetType(inst->type_id()); if (IsCooperativeMatrix(type)) { return false; } analysis::ConstantManager* const_mgr = context->get_constant_mgr(); bool uses_float = HasFloatingPoint(type); if (uses_float && !inst->IsFloatingPointFoldingAllowed()) return false; uint32_t width = ElementWidth(type); if (width != 32 && width != 64) return false; const analysis::Constant* const_input1 = ConstInput(constants); if (!const_input1) return false; Instruction* other_inst = NonConstInput(context, constants[0], inst); if (uses_float && !other_inst->IsFloatingPointFoldingAllowed()) return false; if (other_inst->opcode() == spv::Op::OpFSub || other_inst->opcode() == spv::Op::OpISub) { std::vector other_constants = const_mgr->GetOperandConstants(other_inst); const analysis::Constant* const_input2 = ConstInput(other_constants); if (!const_input2) return false; bool first_is_variable = other_constants[0] == nullptr; spv::Op op = inst->opcode(); uint32_t op1 = 0; uint32_t op2 = 0; if (first_is_variable) { // Subtract constants. Non-constant operand is first. op1 = other_inst->GetSingleWordInOperand(0u); op2 = PerformOperation(const_mgr, other_inst->opcode(), const_input1, const_input2); } else { // Add constants. Constant operand is first. Change the opcode. op1 = PerformOperation(const_mgr, inst->opcode(), const_input1, const_input2); op2 = other_inst->GetSingleWordInOperand(1u); op = other_inst->opcode(); } if (op1 == 0 || op2 == 0) return false; inst->SetOpcode(op); inst->SetInOperands( {{SPV_OPERAND_TYPE_ID, {op1}}, {SPV_OPERAND_TYPE_ID, {op2}}}); return true; } return false; }; } // Folds subtraction of an addition where each operand has a constant operand. // Cases: // (x + 2) - 2 = x + 0 // (2 + x) - 2 = x + 0 // 2 - (x + 2) = 0 - x // 2 - (2 + x) = 0 - x FoldingRule MergeSubAddArithmetic() { return [](IRContext* context, Instruction* inst, const std::vector& constants) { assert(inst->opcode() == spv::Op::OpFSub || inst->opcode() == spv::Op::OpISub); const analysis::Type* type = context->get_type_mgr()->GetType(inst->type_id()); if (IsCooperativeMatrix(type)) { return false; } analysis::ConstantManager* const_mgr = context->get_constant_mgr(); bool uses_float = HasFloatingPoint(type); if (uses_float && !inst->IsFloatingPointFoldingAllowed()) return false; uint32_t width = ElementWidth(type); if (width != 32 && width != 64) return false; const analysis::Constant* const_input1 = ConstInput(constants); if (!const_input1) return false; Instruction* other_inst = NonConstInput(context, constants[0], inst); if (uses_float && !other_inst->IsFloatingPointFoldingAllowed()) return false; if (other_inst->opcode() == spv::Op::OpFAdd || other_inst->opcode() == spv::Op::OpIAdd) { std::vector other_constants = const_mgr->GetOperandConstants(other_inst); const analysis::Constant* const_input2 = ConstInput(other_constants); if (!const_input2) return false; Instruction* non_const_input = NonConstInput(context, other_constants[0], other_inst); // If the first operand of the sub is not a constant, swap the constants // so the subtraction has the correct operands. if (constants[0] == nullptr) std::swap(const_input1, const_input2); // Subtract the constants. uint32_t merged_id = PerformOperation(const_mgr, inst->opcode(), const_input1, const_input2); spv::Op op = inst->opcode(); uint32_t op1 = 0; uint32_t op2 = 0; if (constants[0] == nullptr) { // Non-constant operand is first. Change the opcode. op1 = non_const_input->result_id(); op2 = merged_id; op = other_inst->opcode(); } else { // Constant operand is first. op1 = merged_id; op2 = non_const_input->result_id(); } if (op1 == 0 || op2 == 0) return false; inst->SetOpcode(op); inst->SetInOperands( {{SPV_OPERAND_TYPE_ID, {op1}}, {SPV_OPERAND_TYPE_ID, {op2}}}); return true; } return false; }; } // Folds subtraction of a subtraction where each operand has a constant operand. // Cases: // (x - 2) - 2 = x - 4 // (2 - x) - 2 = 0 - x // 2 - (x - 2) = 4 - x // 2 - (2 - x) = x + 0 FoldingRule MergeSubSubArithmetic() { return [](IRContext* context, Instruction* inst, const std::vector& constants) { assert(inst->opcode() == spv::Op::OpFSub || inst->opcode() == spv::Op::OpISub); const analysis::Type* type = context->get_type_mgr()->GetType(inst->type_id()); if (IsCooperativeMatrix(type)) { return false; } analysis::ConstantManager* const_mgr = context->get_constant_mgr(); bool uses_float = HasFloatingPoint(type); if (uses_float && !inst->IsFloatingPointFoldingAllowed()) return false; uint32_t width = ElementWidth(type); if (width != 32 && width != 64) return false; const analysis::Constant* const_input1 = ConstInput(constants); if (!const_input1) return false; Instruction* other_inst = NonConstInput(context, constants[0], inst); if (uses_float && !other_inst->IsFloatingPointFoldingAllowed()) return false; if (other_inst->opcode() == spv::Op::OpFSub || other_inst->opcode() == spv::Op::OpISub) { std::vector other_constants = const_mgr->GetOperandConstants(other_inst); const analysis::Constant* const_input2 = ConstInput(other_constants); if (!const_input2) return false; Instruction* non_const_input = NonConstInput(context, other_constants[0], other_inst); // Merge the constants. uint32_t merged_id = 0; spv::Op merge_op = inst->opcode(); if (other_constants[0] == nullptr) { merge_op = uses_float ? spv::Op::OpFAdd : spv::Op::OpIAdd; } else if (constants[0] == nullptr) { std::swap(const_input1, const_input2); } merged_id = PerformOperation(const_mgr, merge_op, const_input1, const_input2); if (merged_id == 0) return false; spv::Op op = inst->opcode(); if (constants[0] != nullptr && other_constants[0] != nullptr) { // Change the operation. op = uses_float ? spv::Op::OpFAdd : spv::Op::OpIAdd; } uint32_t op1 = 0; uint32_t op2 = 0; if ((constants[0] == nullptr) ^ (other_constants[0] == nullptr)) { op1 = merged_id; op2 = non_const_input->result_id(); } else { op1 = non_const_input->result_id(); op2 = merged_id; } inst->SetOpcode(op); inst->SetInOperands( {{SPV_OPERAND_TYPE_ID, {op1}}, {SPV_OPERAND_TYPE_ID, {op2}}}); return true; } return false; }; } // Helper function for MergeGenericAddSubArithmetic. If |addend| and // subtrahend of |sub| is the same, merge to copy of minuend of |sub|. bool MergeGenericAddendSub(uint32_t addend, uint32_t sub, Instruction* inst) { IRContext* context = inst->context(); analysis::DefUseManager* def_use_mgr = context->get_def_use_mgr(); Instruction* sub_inst = def_use_mgr->GetDef(sub); if (sub_inst->opcode() != spv::Op::OpFSub && sub_inst->opcode() != spv::Op::OpISub) return false; if (sub_inst->opcode() == spv::Op::OpFSub && !sub_inst->IsFloatingPointFoldingAllowed()) return false; if (addend != sub_inst->GetSingleWordInOperand(1)) return false; inst->SetOpcode(spv::Op::OpCopyObject); inst->SetInOperands( {{SPV_OPERAND_TYPE_ID, {sub_inst->GetSingleWordInOperand(0)}}}); context->UpdateDefUse(inst); return true; } // Folds addition of a subtraction where the subtrahend is equal to the // other addend. Return a copy of the minuend. Accepts generic (const and // non-const) operands. // Cases: // (a - b) + b = a // b + (a - b) = a FoldingRule MergeGenericAddSubArithmetic() { return [](IRContext* context, Instruction* inst, const std::vector&) { assert(inst->opcode() == spv::Op::OpFAdd || inst->opcode() == spv::Op::OpIAdd); const analysis::Type* type = context->get_type_mgr()->GetType(inst->type_id()); if (IsCooperativeMatrix(type)) { return false; } bool uses_float = HasFloatingPoint(type); if (uses_float && !inst->IsFloatingPointFoldingAllowed()) return false; uint32_t width = ElementWidth(type); if (width != 32 && width != 64) return false; uint32_t add_op0 = inst->GetSingleWordInOperand(0); uint32_t add_op1 = inst->GetSingleWordInOperand(1); if (MergeGenericAddendSub(add_op0, add_op1, inst)) return true; return MergeGenericAddendSub(add_op1, add_op0, inst); }; } // Helper function for FactorAddMuls. If |factor0_0| is the same as |factor1_0|, // generate |factor0_0| * (|factor0_1| + |factor1_1|). bool FactorAddMulsOpnds(uint32_t factor0_0, uint32_t factor0_1, uint32_t factor1_0, uint32_t factor1_1, Instruction* inst) { IRContext* context = inst->context(); if (factor0_0 != factor1_0) return false; InstructionBuilder ir_builder( context, inst, IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); Instruction* new_add_inst = ir_builder.AddBinaryOp( inst->type_id(), inst->opcode(), factor0_1, factor1_1); inst->SetOpcode(inst->opcode() == spv::Op::OpFAdd ? spv::Op::OpFMul : spv::Op::OpIMul); inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {factor0_0}}, {SPV_OPERAND_TYPE_ID, {new_add_inst->result_id()}}}); context->UpdateDefUse(inst); return true; } // Perform the following factoring identity, handling all operand order // combinations: (a * b) + (a * c) = a * (b + c) FoldingRule FactorAddMuls() { return [](IRContext* context, Instruction* inst, const std::vector&) { assert(inst->opcode() == spv::Op::OpFAdd || inst->opcode() == spv::Op::OpIAdd); const analysis::Type* type = context->get_type_mgr()->GetType(inst->type_id()); bool uses_float = HasFloatingPoint(type); if (uses_float && !inst->IsFloatingPointFoldingAllowed()) return false; analysis::DefUseManager* def_use_mgr = context->get_def_use_mgr(); uint32_t add_op0 = inst->GetSingleWordInOperand(0); Instruction* add_op0_inst = def_use_mgr->GetDef(add_op0); if (add_op0_inst->opcode() != spv::Op::OpFMul && add_op0_inst->opcode() != spv::Op::OpIMul) return false; uint32_t add_op1 = inst->GetSingleWordInOperand(1); Instruction* add_op1_inst = def_use_mgr->GetDef(add_op1); if (add_op1_inst->opcode() != spv::Op::OpFMul && add_op1_inst->opcode() != spv::Op::OpIMul) return false; // Only perform this optimization if both of the muls only have one use. // Otherwise this is a deoptimization in size and performance. if (def_use_mgr->NumUses(add_op0_inst) > 1) return false; if (def_use_mgr->NumUses(add_op1_inst) > 1) return false; if (add_op0_inst->opcode() == spv::Op::OpFMul && (!add_op0_inst->IsFloatingPointFoldingAllowed() || !add_op1_inst->IsFloatingPointFoldingAllowed())) return false; for (int i = 0; i < 2; i++) { for (int j = 0; j < 2; j++) { // Check if operand i in add_op0_inst matches operand j in add_op1_inst. if (FactorAddMulsOpnds(add_op0_inst->GetSingleWordInOperand(i), add_op0_inst->GetSingleWordInOperand(1 - i), add_op1_inst->GetSingleWordInOperand(j), add_op1_inst->GetSingleWordInOperand(1 - j), inst)) return true; } } return false; }; } FoldingRule IntMultipleBy1() { return [](IRContext*, Instruction* inst, const std::vector& constants) { assert(inst->opcode() == spv::Op::OpIMul && "Wrong opcode. Should be OpIMul."); for (uint32_t i = 0; i < 2; i++) { if (constants[i] == nullptr) { continue; } const analysis::IntConstant* int_constant = constants[i]->AsIntConstant(); if (int_constant) { uint32_t width = ElementWidth(int_constant->type()); if (width != 32 && width != 64) return false; bool is_one = (width == 32) ? int_constant->GetU32BitValue() == 1u : int_constant->GetU64BitValue() == 1ull; if (is_one) { inst->SetOpcode(spv::Op::OpCopyObject); inst->SetInOperands( {{SPV_OPERAND_TYPE_ID, {inst->GetSingleWordInOperand(1 - i)}}}); return true; } } } return false; }; } // Returns the number of elements that the |index|th in operand in |inst| // contributes to the result of |inst|. |inst| must be an // OpCompositeConstructInstruction. uint32_t GetNumOfElementsContributedByOperand(IRContext* context, const Instruction* inst, uint32_t index) { assert(inst->opcode() == spv::Op::OpCompositeConstruct); analysis::DefUseManager* def_use_mgr = context->get_def_use_mgr(); analysis::TypeManager* type_mgr = context->get_type_mgr(); analysis::Vector* result_type = type_mgr->GetType(inst->type_id())->AsVector(); if (result_type == nullptr) { // If the result of the OpCompositeConstruct is not a vector then every // operands corresponds to a single element in the result. return 1; } // If the result type is a vector then the operands are either scalars or // vectors. If it is a scalar, then it corresponds to a single element. If it // is a vector, then each element in the vector will be an element in the // result. uint32_t id = inst->GetSingleWordInOperand(index); Instruction* def = def_use_mgr->GetDef(id); analysis::Vector* type = type_mgr->GetType(def->type_id())->AsVector(); if (type == nullptr) { return 1; } return type->element_count(); } // Returns the in-operands for an OpCompositeExtract instruction that are needed // to extract the |result_index|th element in the result of |inst| without using // the result of |inst|. Returns the empty vector if |result_index| is // out-of-bounds. |inst| must be an |OpCompositeConstruct| instruction. std::vector GetExtractOperandsForElementOfCompositeConstruct( IRContext* context, const Instruction* inst, uint32_t result_index) { assert(inst->opcode() == spv::Op::OpCompositeConstruct); analysis::DefUseManager* def_use_mgr = context->get_def_use_mgr(); analysis::TypeManager* type_mgr = context->get_type_mgr(); analysis::Type* result_type = type_mgr->GetType(inst->type_id()); if (result_type->AsVector() == nullptr) { if (result_index < inst->NumInOperands()) { uint32_t id = inst->GetSingleWordInOperand(result_index); return {Operand(SPV_OPERAND_TYPE_ID, {id})}; } return {}; } // If the result type is a vector, then vector operands are concatenated. uint32_t total_element_count = 0; for (uint32_t idx = 0; idx < inst->NumInOperands(); ++idx) { uint32_t element_count = GetNumOfElementsContributedByOperand(context, inst, idx); total_element_count += element_count; if (result_index < total_element_count) { std::vector operands; uint32_t id = inst->GetSingleWordInOperand(idx); Instruction* operand_def = def_use_mgr->GetDef(id); analysis::Type* operand_type = type_mgr->GetType(operand_def->type_id()); operands.push_back({SPV_OPERAND_TYPE_ID, {id}}); if (operand_type->AsVector()) { uint32_t start_index_of_id = total_element_count - element_count; uint32_t index_into_id = result_index - start_index_of_id; operands.push_back({SPV_OPERAND_TYPE_LITERAL_INTEGER, {index_into_id}}); } return operands; } } return {}; } bool CompositeConstructFeedingExtract( IRContext* context, Instruction* inst, const std::vector&) { // If the input to an OpCompositeExtract is an OpCompositeConstruct, // then we can simply use the appropriate element in the construction. assert(inst->opcode() == spv::Op::OpCompositeExtract && "Wrong opcode. Should be OpCompositeExtract."); analysis::DefUseManager* def_use_mgr = context->get_def_use_mgr(); // If there are no index operands, then this rule cannot do anything. if (inst->NumInOperands() <= 1) { return false; } uint32_t cid = inst->GetSingleWordInOperand(kExtractCompositeIdInIdx); Instruction* cinst = def_use_mgr->GetDef(cid); if (cinst->opcode() != spv::Op::OpCompositeConstruct) { return false; } uint32_t index_into_result = inst->GetSingleWordInOperand(1); std::vector operands = GetExtractOperandsForElementOfCompositeConstruct(context, cinst, index_into_result); if (operands.empty()) { return false; } // Add the remaining indices for extraction. for (uint32_t i = 2; i < inst->NumInOperands(); ++i) { operands.push_back( {SPV_OPERAND_TYPE_LITERAL_INTEGER, {inst->GetSingleWordInOperand(i)}}); } if (operands.size() == 1) { // If there were no extra indices, then we have the final object. No need // to extract any more. inst->SetOpcode(spv::Op::OpCopyObject); } inst->SetInOperands(std::move(operands)); return true; } // Walks the indexes chain from |start| to |end| of an OpCompositeInsert or // OpCompositeExtract instruction, and returns the type id of the final element // being accessed. Returns 0 if a valid type could not be found. uint32_t GetElementType(uint32_t type_id, Instruction::iterator start, Instruction::iterator end, const analysis::DefUseManager* def_use_manager) { for (auto index : make_range(std::move(start), std::move(end))) { const Instruction* type_inst = def_use_manager->GetDef(type_id); assert(index.type == SPV_OPERAND_TYPE_LITERAL_INTEGER && index.words.size() == 1); if (type_inst->opcode() == spv::Op::OpTypeArray) { type_id = type_inst->GetSingleWordInOperand(0); } else if (type_inst->opcode() == spv::Op::OpTypeMatrix) { type_id = type_inst->GetSingleWordInOperand(0); } else if (type_inst->opcode() == spv::Op::OpTypeStruct) { type_id = type_inst->GetSingleWordInOperand(index.words[0]); } else { return 0; } } return type_id; } // Returns true of |inst_1| and |inst_2| have the same indexes that will be used // to index into a composite object, excluding the last index. The two // instructions must have the same opcode, and be either OpCompositeExtract or // OpCompositeInsert instructions. bool HaveSameIndexesExceptForLast(Instruction* inst_1, Instruction* inst_2) { assert(inst_1->opcode() == inst_2->opcode() && "Expecting the opcodes to be the same."); assert((inst_1->opcode() == spv::Op::OpCompositeInsert || inst_1->opcode() == spv::Op::OpCompositeExtract) && "Instructions must be OpCompositeInsert or OpCompositeExtract."); if (inst_1->NumInOperands() != inst_2->NumInOperands()) { return false; } uint32_t first_index_position = (inst_1->opcode() == spv::Op::OpCompositeInsert ? 2 : 1); for (uint32_t i = first_index_position; i < inst_1->NumInOperands() - 1; i++) { if (inst_1->GetSingleWordInOperand(i) != inst_2->GetSingleWordInOperand(i)) { return false; } } return true; } // If the OpCompositeConstruct is simply putting back together elements that // where extracted from the same source, we can simply reuse the source. // // This is a common code pattern because of the way that scalar replacement // works. bool CompositeExtractFeedingConstruct( IRContext* context, Instruction* inst, const std::vector&) { assert(inst->opcode() == spv::Op::OpCompositeConstruct && "Wrong opcode. Should be OpCompositeConstruct."); analysis::DefUseManager* def_use_mgr = context->get_def_use_mgr(); uint32_t original_id = 0; if (inst->NumInOperands() == 0) { // The struct being constructed has no members. return false; } // Check each element to make sure they are: // - extractions // - extracting the same position they are inserting // - all extract from the same id. Instruction* first_element_inst = nullptr; for (uint32_t i = 0; i < inst->NumInOperands(); ++i) { const uint32_t element_id = inst->GetSingleWordInOperand(i); Instruction* element_inst = def_use_mgr->GetDef(element_id); if (first_element_inst == nullptr) { first_element_inst = element_inst; } if (element_inst->opcode() != spv::Op::OpCompositeExtract) { return false; } if (!HaveSameIndexesExceptForLast(element_inst, first_element_inst)) { return false; } if (element_inst->GetSingleWordInOperand(element_inst->NumInOperands() - 1) != i) { return false; } if (i == 0) { original_id = element_inst->GetSingleWordInOperand(kExtractCompositeIdInIdx); } else if (original_id != element_inst->GetSingleWordInOperand(kExtractCompositeIdInIdx)) { return false; } } assert(first_element_inst != nullptr); // The last check it to see that the object being extracted from is the // correct type. Instruction* original_inst = def_use_mgr->GetDef(original_id); uint32_t original_type_id = GetElementType(original_inst->type_id(), first_element_inst->begin() + 3, first_element_inst->end() - 1, def_use_mgr); if (inst->type_id() != original_type_id) { return false; } if (first_element_inst->NumInOperands() == 2) { // Simplify by using the original object. inst->SetOpcode(spv::Op::OpCopyObject); inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {original_id}}}); return true; } // Copies the original id and all indexes except for the last to the new // extract instruction. inst->SetOpcode(spv::Op::OpCompositeExtract); inst->SetInOperands(std::vector(first_element_inst->begin() + 2, first_element_inst->end() - 1)); return true; } FoldingRule InsertFeedingExtract() { return [](IRContext* context, Instruction* inst, const std::vector&) { assert(inst->opcode() == spv::Op::OpCompositeExtract && "Wrong opcode. Should be OpCompositeExtract."); analysis::DefUseManager* def_use_mgr = context->get_def_use_mgr(); uint32_t cid = inst->GetSingleWordInOperand(kExtractCompositeIdInIdx); Instruction* cinst = def_use_mgr->GetDef(cid); if (cinst->opcode() != spv::Op::OpCompositeInsert) { return false; } // Find the first position where the list of insert and extract indicies // differ, if at all. uint32_t i; for (i = 1; i < inst->NumInOperands(); ++i) { if (i + 1 >= cinst->NumInOperands()) { break; } if (inst->GetSingleWordInOperand(i) != cinst->GetSingleWordInOperand(i + 1)) { break; } } // We are extracting the element that was inserted. if (i == inst->NumInOperands() && i + 1 == cinst->NumInOperands()) { inst->SetOpcode(spv::Op::OpCopyObject); inst->SetInOperands( {{SPV_OPERAND_TYPE_ID, {cinst->GetSingleWordInOperand(kInsertObjectIdInIdx)}}}); return true; } // Extracting the value that was inserted along with values for the base // composite. Cannot do anything. if (i == inst->NumInOperands()) { return false; } // Extracting an element of the value that was inserted. Extract from // that value directly. if (i + 1 == cinst->NumInOperands()) { std::vector operands; operands.push_back( {SPV_OPERAND_TYPE_ID, {cinst->GetSingleWordInOperand(kInsertObjectIdInIdx)}}); for (; i < inst->NumInOperands(); ++i) { operands.push_back({SPV_OPERAND_TYPE_LITERAL_INTEGER, {inst->GetSingleWordInOperand(i)}}); } inst->SetInOperands(std::move(operands)); return true; } // Extracting a value that is disjoint from the element being inserted. // Rewrite the extract to use the composite input to the insert. std::vector operands; operands.push_back( {SPV_OPERAND_TYPE_ID, {cinst->GetSingleWordInOperand(kInsertCompositeIdInIdx)}}); for (i = 1; i < inst->NumInOperands(); ++i) { operands.push_back({SPV_OPERAND_TYPE_LITERAL_INTEGER, {inst->GetSingleWordInOperand(i)}}); } inst->SetInOperands(std::move(operands)); return true; }; } // When a VectorShuffle is feeding an Extract, we can extract from one of the // operands of the VectorShuffle. We just need to adjust the index in the // extract instruction. FoldingRule VectorShuffleFeedingExtract() { return [](IRContext* context, Instruction* inst, const std::vector&) { assert(inst->opcode() == spv::Op::OpCompositeExtract && "Wrong opcode. Should be OpCompositeExtract."); analysis::DefUseManager* def_use_mgr = context->get_def_use_mgr(); analysis::TypeManager* type_mgr = context->get_type_mgr(); uint32_t cid = inst->GetSingleWordInOperand(kExtractCompositeIdInIdx); Instruction* cinst = def_use_mgr->GetDef(cid); if (cinst->opcode() != spv::Op::OpVectorShuffle) { return false; } // Find the size of the first vector operand of the VectorShuffle Instruction* first_input = def_use_mgr->GetDef(cinst->GetSingleWordInOperand(0)); analysis::Type* first_input_type = type_mgr->GetType(first_input->type_id()); assert(first_input_type->AsVector() && "Input to vector shuffle should be vectors."); uint32_t first_input_size = first_input_type->AsVector()->element_count(); // Get index of the element the vector shuffle is placing in the position // being extracted. uint32_t new_index = cinst->GetSingleWordInOperand(2 + inst->GetSingleWordInOperand(1)); // Extracting an undefined value so fold this extract into an undef. const uint32_t undef_literal_value = 0xffffffff; if (new_index == undef_literal_value) { inst->SetOpcode(spv::Op::OpUndef); inst->SetInOperands({}); return true; } // Get the id of the of the vector the elemtent comes from, and update the // index if needed. uint32_t new_vector = 0; if (new_index < first_input_size) { new_vector = cinst->GetSingleWordInOperand(0); } else { new_vector = cinst->GetSingleWordInOperand(1); new_index -= first_input_size; } // Update the extract instruction. inst->SetInOperand(kExtractCompositeIdInIdx, {new_vector}); inst->SetInOperand(1, {new_index}); return true; }; } // When an FMix with is feeding an Extract that extracts an element whose // corresponding |a| in the FMix is 0 or 1, we can extract from one of the // operands of the FMix. FoldingRule FMixFeedingExtract() { return [](IRContext* context, Instruction* inst, const std::vector&) { assert(inst->opcode() == spv::Op::OpCompositeExtract && "Wrong opcode. Should be OpCompositeExtract."); analysis::DefUseManager* def_use_mgr = context->get_def_use_mgr(); analysis::ConstantManager* const_mgr = context->get_constant_mgr(); uint32_t composite_id = inst->GetSingleWordInOperand(kExtractCompositeIdInIdx); Instruction* composite_inst = def_use_mgr->GetDef(composite_id); if (composite_inst->opcode() != spv::Op::OpExtInst) { return false; } uint32_t inst_set_id = context->get_feature_mgr()->GetExtInstImportId_GLSLstd450(); if (composite_inst->GetSingleWordInOperand(kExtInstSetIdInIdx) != inst_set_id || composite_inst->GetSingleWordInOperand(kExtInstInstructionInIdx) != GLSLstd450FMix) { return false; } // Get the |a| for the FMix instruction. uint32_t a_id = composite_inst->GetSingleWordInOperand(kFMixAIdInIdx); std::unique_ptr a(inst->Clone(context)); a->SetInOperand(kExtractCompositeIdInIdx, {a_id}); context->get_instruction_folder().FoldInstruction(a.get()); if (a->opcode() != spv::Op::OpCopyObject) { return false; } const analysis::Constant* a_const = const_mgr->FindDeclaredConstant(a->GetSingleWordInOperand(0)); if (!a_const) { return false; } bool use_x = false; assert(a_const->type()->AsFloat()); double element_value = a_const->GetValueAsDouble(); if (element_value == 0.0) { use_x = true; } else if (element_value == 1.0) { use_x = false; } else { return false; } // Get the id of the of the vector the element comes from. uint32_t new_vector = 0; if (use_x) { new_vector = composite_inst->GetSingleWordInOperand(kFMixXIdInIdx); } else { new_vector = composite_inst->GetSingleWordInOperand(kFMixYIdInIdx); } // Update the extract instruction. inst->SetInOperand(kExtractCompositeIdInIdx, {new_vector}); return true; }; } // Returns the number of elements in the composite type |type|. Returns 0 if // |type| is a scalar value. Return UINT32_MAX when the size is unknown at // compile time. uint32_t GetNumberOfElements(const analysis::Type* type) { if (auto* vector_type = type->AsVector()) { return vector_type->element_count(); } if (auto* matrix_type = type->AsMatrix()) { return matrix_type->element_count(); } if (auto* struct_type = type->AsStruct()) { return static_cast(struct_type->element_types().size()); } if (auto* array_type = type->AsArray()) { if (array_type->length_info().words[0] == analysis::Array::LengthInfo::kConstant && array_type->length_info().words.size() == 2) { return array_type->length_info().words[1]; } return UINT32_MAX; } return 0; } // Returns a map with the set of values that were inserted into an object by // the chain of OpCompositeInsertInstruction starting with |inst|. // The map will map the index to the value inserted at that index. An empty map // will be returned if the map could not be properly generated. std::map GetInsertedValues(Instruction* inst) { analysis::DefUseManager* def_use_mgr = inst->context()->get_def_use_mgr(); std::map values_inserted; Instruction* current_inst = inst; while (current_inst->opcode() == spv::Op::OpCompositeInsert) { if (current_inst->NumInOperands() > inst->NumInOperands()) { // This is to catch the case // %2 = OpCompositeInsert %m2x2int %v2int_1_0 %m2x2int_undef 0 // %3 = OpCompositeInsert %m2x2int %int_4 %2 0 0 // %4 = OpCompositeInsert %m2x2int %v2int_2_3 %3 1 // In this case we cannot do a single construct to get the matrix. uint32_t partially_inserted_element_index = current_inst->GetSingleWordInOperand(inst->NumInOperands() - 1); if (values_inserted.count(partially_inserted_element_index) == 0) return {}; } if (HaveSameIndexesExceptForLast(inst, current_inst)) { values_inserted.insert( {current_inst->GetSingleWordInOperand(current_inst->NumInOperands() - 1), current_inst->GetSingleWordInOperand(kInsertObjectIdInIdx)}); } current_inst = def_use_mgr->GetDef( current_inst->GetSingleWordInOperand(kInsertCompositeIdInIdx)); } return values_inserted; } // Returns true of there is an entry in |values_inserted| for every element of // |Type|. bool DoInsertedValuesCoverEntireObject( const analysis::Type* type, std::map& values_inserted) { uint32_t container_size = GetNumberOfElements(type); if (container_size != values_inserted.size()) { return false; } if (values_inserted.rbegin()->first >= container_size) { return false; } return true; } // Returns id of the type of the element that immediately contains the element // being inserted by the OpCompositeInsert instruction |inst|. Returns 0 if it // could not be found. uint32_t GetContainerTypeId(Instruction* inst) { assert(inst->opcode() == spv::Op::OpCompositeInsert); analysis::DefUseManager* def_use_manager = inst->context()->get_def_use_mgr(); uint32_t container_type_id = GetElementType( inst->type_id(), inst->begin() + 4, inst->end() - 1, def_use_manager); return container_type_id; } // Returns an OpCompositeConstruct instruction that build an object with // |type_id| out of the values in |values_inserted|. Each value will be // placed at the index corresponding to the value. The new instruction will // be placed before |insert_before|. Instruction* BuildCompositeConstruct( uint32_t type_id, const std::map& values_inserted, Instruction* insert_before) { InstructionBuilder ir_builder( insert_before->context(), insert_before, IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); std::vector ids_in_order; for (auto it : values_inserted) { ids_in_order.push_back(it.second); } Instruction* construct = ir_builder.AddCompositeConstruct(type_id, ids_in_order); return construct; } // Replaces the OpCompositeInsert |inst| that inserts |construct| into the same // object as |inst| with final index removed. If the resulting // OpCompositeInsert instruction would have no remaining indexes, the // instruction is replaced with an OpCopyObject instead. void InsertConstructedObject(Instruction* inst, const Instruction* construct) { if (inst->NumInOperands() == 3) { inst->SetOpcode(spv::Op::OpCopyObject); inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {construct->result_id()}}}); } else { inst->SetInOperand(kInsertObjectIdInIdx, {construct->result_id()}); inst->RemoveOperand(inst->NumOperands() - 1); } } // Replaces a series of |OpCompositeInsert| instruction that cover the entire // object with an |OpCompositeConstruct|. bool CompositeInsertToCompositeConstruct( IRContext* context, Instruction* inst, const std::vector&) { assert(inst->opcode() == spv::Op::OpCompositeInsert && "Wrong opcode. Should be OpCompositeInsert."); if (inst->NumInOperands() < 3) return false; std::map values_inserted = GetInsertedValues(inst); uint32_t container_type_id = GetContainerTypeId(inst); if (container_type_id == 0) { return false; } analysis::TypeManager* type_mgr = context->get_type_mgr(); const analysis::Type* container_type = type_mgr->GetType(container_type_id); assert(container_type && "GetContainerTypeId returned a bad id."); if (!DoInsertedValuesCoverEntireObject(container_type, values_inserted)) { return false; } Instruction* construct = BuildCompositeConstruct(container_type_id, values_inserted, inst); InsertConstructedObject(inst, construct); return true; } FoldingRule RedundantPhi() { // An OpPhi instruction where all values are the same or the result of the phi // itself, can be replaced by the value itself. return [](IRContext*, Instruction* inst, const std::vector&) { assert(inst->opcode() == spv::Op::OpPhi && "Wrong opcode. Should be OpPhi."); uint32_t incoming_value = 0; for (uint32_t i = 0; i < inst->NumInOperands(); i += 2) { uint32_t op_id = inst->GetSingleWordInOperand(i); if (op_id == inst->result_id()) { continue; } if (incoming_value == 0) { incoming_value = op_id; } else if (op_id != incoming_value) { // Found two possible value. Can't simplify. return false; } } if (incoming_value == 0) { // Code looks invalid. Don't do anything. return false; } // We have a single incoming value. Simplify using that value. inst->SetOpcode(spv::Op::OpCopyObject); inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {incoming_value}}}); return true; }; } FoldingRule BitCastScalarOrVector() { return [](IRContext* context, Instruction* inst, const std::vector& constants) { assert(inst->opcode() == spv::Op::OpBitcast && constants.size() == 1); if (constants[0] == nullptr) return false; const analysis::Type* type = context->get_type_mgr()->GetType(inst->type_id()); if (HasFloatingPoint(type) && !inst->IsFloatingPointFoldingAllowed()) return false; analysis::ConstantManager* const_mgr = context->get_constant_mgr(); std::vector words = GetWordsFromNumericScalarOrVectorConstant(const_mgr, constants[0]); if (words.size() == 0) return false; const analysis::Constant* bitcasted_constant = ConvertWordsToNumericScalarOrVectorConstant(const_mgr, words, type); if (!bitcasted_constant) return false; auto new_feeder_id = const_mgr->GetDefiningInstruction(bitcasted_constant, inst->type_id()) ->result_id(); inst->SetOpcode(spv::Op::OpCopyObject); inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {new_feeder_id}}}); return true; }; } FoldingRule RedundantSelect() { // An OpSelect instruction where both values are the same or the condition is // constant can be replaced by one of the values return [](IRContext*, Instruction* inst, const std::vector& constants) { assert(inst->opcode() == spv::Op::OpSelect && "Wrong opcode. Should be OpSelect."); assert(inst->NumInOperands() == 3); assert(constants.size() == 3); uint32_t true_id = inst->GetSingleWordInOperand(1); uint32_t false_id = inst->GetSingleWordInOperand(2); if (true_id == false_id) { // Both results are the same, condition doesn't matter inst->SetOpcode(spv::Op::OpCopyObject); inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {true_id}}}); return true; } else if (constants[0]) { const analysis::Type* type = constants[0]->type(); if (type->AsBool()) { // Scalar constant value, select the corresponding value. inst->SetOpcode(spv::Op::OpCopyObject); if (constants[0]->AsNullConstant() || !constants[0]->AsBoolConstant()->value()) { inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {false_id}}}); } else { inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {true_id}}}); } return true; } else { assert(type->AsVector()); if (constants[0]->AsNullConstant()) { // All values come from false id. inst->SetOpcode(spv::Op::OpCopyObject); inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {false_id}}}); return true; } else { // Convert to a vector shuffle. std::vector ops; ops.push_back({SPV_OPERAND_TYPE_ID, {true_id}}); ops.push_back({SPV_OPERAND_TYPE_ID, {false_id}}); const analysis::VectorConstant* vector_const = constants[0]->AsVectorConstant(); uint32_t size = static_cast(vector_const->GetComponents().size()); for (uint32_t i = 0; i != size; ++i) { const analysis::Constant* component = vector_const->GetComponents()[i]; if (component->AsNullConstant() || !component->AsBoolConstant()->value()) { // Selecting from the false vector which is the second input // vector to the shuffle. Offset the index by |size|. ops.push_back({SPV_OPERAND_TYPE_LITERAL_INTEGER, {i + size}}); } else { // Selecting from true vector which is the first input vector to // the shuffle. ops.push_back({SPV_OPERAND_TYPE_LITERAL_INTEGER, {i}}); } } inst->SetOpcode(spv::Op::OpVectorShuffle); inst->SetInOperands(std::move(ops)); return true; } } } return false; }; } enum class FloatConstantKind { Unknown, Zero, One }; FloatConstantKind getFloatConstantKind(const analysis::Constant* constant) { if (constant == nullptr) { return FloatConstantKind::Unknown; } assert(HasFloatingPoint(constant->type()) && "Unexpected constant type"); if (constant->AsNullConstant()) { return FloatConstantKind::Zero; } else if (const analysis::VectorConstant* vc = constant->AsVectorConstant()) { const std::vector& components = vc->GetComponents(); assert(!components.empty()); FloatConstantKind kind = getFloatConstantKind(components[0]); for (size_t i = 1; i < components.size(); ++i) { if (getFloatConstantKind(components[i]) != kind) { return FloatConstantKind::Unknown; } } return kind; } else if (const analysis::FloatConstant* fc = constant->AsFloatConstant()) { if (fc->IsZero()) return FloatConstantKind::Zero; uint32_t width = fc->type()->AsFloat()->width(); if (width != 32 && width != 64) return FloatConstantKind::Unknown; double value = (width == 64) ? fc->GetDoubleValue() : fc->GetFloatValue(); if (value == 0.0) { return FloatConstantKind::Zero; } else if (value == 1.0) { return FloatConstantKind::One; } else { return FloatConstantKind::Unknown; } } else { return FloatConstantKind::Unknown; } } FoldingRule RedundantFAdd() { return [](IRContext*, Instruction* inst, const std::vector& constants) { assert(inst->opcode() == spv::Op::OpFAdd && "Wrong opcode. Should be OpFAdd."); assert(constants.size() == 2); if (!inst->IsFloatingPointFoldingAllowed()) { return false; } FloatConstantKind kind0 = getFloatConstantKind(constants[0]); FloatConstantKind kind1 = getFloatConstantKind(constants[1]); if (kind0 == FloatConstantKind::Zero || kind1 == FloatConstantKind::Zero) { inst->SetOpcode(spv::Op::OpCopyObject); inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {inst->GetSingleWordInOperand( kind0 == FloatConstantKind::Zero ? 1 : 0)}}}); return true; } return false; }; } FoldingRule RedundantFSub() { return [](IRContext*, Instruction* inst, const std::vector& constants) { assert(inst->opcode() == spv::Op::OpFSub && "Wrong opcode. Should be OpFSub."); assert(constants.size() == 2); if (!inst->IsFloatingPointFoldingAllowed()) { return false; } FloatConstantKind kind0 = getFloatConstantKind(constants[0]); FloatConstantKind kind1 = getFloatConstantKind(constants[1]); if (kind0 == FloatConstantKind::Zero) { inst->SetOpcode(spv::Op::OpFNegate); inst->SetInOperands( {{SPV_OPERAND_TYPE_ID, {inst->GetSingleWordInOperand(1)}}}); return true; } if (kind1 == FloatConstantKind::Zero) { inst->SetOpcode(spv::Op::OpCopyObject); inst->SetInOperands( {{SPV_OPERAND_TYPE_ID, {inst->GetSingleWordInOperand(0)}}}); return true; } return false; }; } FoldingRule RedundantFMul() { return [](IRContext*, Instruction* inst, const std::vector& constants) { assert(inst->opcode() == spv::Op::OpFMul && "Wrong opcode. Should be OpFMul."); assert(constants.size() == 2); if (!inst->IsFloatingPointFoldingAllowed()) { return false; } FloatConstantKind kind0 = getFloatConstantKind(constants[0]); FloatConstantKind kind1 = getFloatConstantKind(constants[1]); if (kind0 == FloatConstantKind::Zero || kind1 == FloatConstantKind::Zero) { inst->SetOpcode(spv::Op::OpCopyObject); inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {inst->GetSingleWordInOperand( kind0 == FloatConstantKind::Zero ? 0 : 1)}}}); return true; } if (kind0 == FloatConstantKind::One || kind1 == FloatConstantKind::One) { inst->SetOpcode(spv::Op::OpCopyObject); inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {inst->GetSingleWordInOperand( kind0 == FloatConstantKind::One ? 1 : 0)}}}); return true; } return false; }; } FoldingRule RedundantFDiv() { return [](IRContext*, Instruction* inst, const std::vector& constants) { assert(inst->opcode() == spv::Op::OpFDiv && "Wrong opcode. Should be OpFDiv."); assert(constants.size() == 2); if (!inst->IsFloatingPointFoldingAllowed()) { return false; } FloatConstantKind kind0 = getFloatConstantKind(constants[0]); FloatConstantKind kind1 = getFloatConstantKind(constants[1]); if (kind0 == FloatConstantKind::Zero) { inst->SetOpcode(spv::Op::OpCopyObject); inst->SetInOperands( {{SPV_OPERAND_TYPE_ID, {inst->GetSingleWordInOperand(0)}}}); return true; } if (kind1 == FloatConstantKind::One) { inst->SetOpcode(spv::Op::OpCopyObject); inst->SetInOperands( {{SPV_OPERAND_TYPE_ID, {inst->GetSingleWordInOperand(0)}}}); return true; } return false; }; } FoldingRule RedundantFMix() { return [](IRContext* context, Instruction* inst, const std::vector& constants) { assert(inst->opcode() == spv::Op::OpExtInst && "Wrong opcode. Should be OpExtInst."); if (!inst->IsFloatingPointFoldingAllowed()) { return false; } uint32_t instSetId = context->get_feature_mgr()->GetExtInstImportId_GLSLstd450(); if (inst->GetSingleWordInOperand(kExtInstSetIdInIdx) == instSetId && inst->GetSingleWordInOperand(kExtInstInstructionInIdx) == GLSLstd450FMix) { assert(constants.size() == 5); FloatConstantKind kind4 = getFloatConstantKind(constants[4]); if (kind4 == FloatConstantKind::Zero || kind4 == FloatConstantKind::One) { inst->SetOpcode(spv::Op::OpCopyObject); inst->SetInOperands( {{SPV_OPERAND_TYPE_ID, {inst->GetSingleWordInOperand(kind4 == FloatConstantKind::Zero ? kFMixXIdInIdx : kFMixYIdInIdx)}}}); return true; } } return false; }; } // This rule handles addition of zero for integers. FoldingRule RedundantIAdd() { return [](IRContext* context, Instruction* inst, const std::vector& constants) { assert(inst->opcode() == spv::Op::OpIAdd && "Wrong opcode. Should be OpIAdd."); uint32_t operand = std::numeric_limits::max(); const analysis::Type* operand_type = nullptr; if (constants[0] && constants[0]->IsZero()) { operand = inst->GetSingleWordInOperand(1); operand_type = constants[0]->type(); } else if (constants[1] && constants[1]->IsZero()) { operand = inst->GetSingleWordInOperand(0); operand_type = constants[1]->type(); } if (operand != std::numeric_limits::max()) { const analysis::Type* inst_type = context->get_type_mgr()->GetType(inst->type_id()); if (inst_type->IsSame(operand_type)) { inst->SetOpcode(spv::Op::OpCopyObject); } else { inst->SetOpcode(spv::Op::OpBitcast); } inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {operand}}}); return true; } return false; }; } // This rule look for a dot with a constant vector containing a single 1 and // the rest 0s. This is the same as doing an extract. FoldingRule DotProductDoingExtract() { return [](IRContext* context, Instruction* inst, const std::vector& constants) { assert(inst->opcode() == spv::Op::OpDot && "Wrong opcode. Should be OpDot."); analysis::ConstantManager* const_mgr = context->get_constant_mgr(); if (!inst->IsFloatingPointFoldingAllowed()) { return false; } for (int i = 0; i < 2; ++i) { if (!constants[i]) { continue; } const analysis::Vector* vector_type = constants[i]->type()->AsVector(); assert(vector_type && "Inputs to OpDot must be vectors."); const analysis::Float* element_type = vector_type->element_type()->AsFloat(); assert(element_type && "Inputs to OpDot must be vectors of floats."); uint32_t element_width = element_type->width(); if (element_width != 32 && element_width != 64) { return false; } std::vector components; components = constants[i]->GetVectorComponents(const_mgr); constexpr uint32_t kNotFound = std::numeric_limits::max(); uint32_t component_with_one = kNotFound; bool all_others_zero = true; for (uint32_t j = 0; j < components.size(); ++j) { const analysis::Constant* element = components[j]; double value = (element_width == 32 ? element->GetFloat() : element->GetDouble()); if (value == 0.0) { continue; } else if (value == 1.0) { if (component_with_one == kNotFound) { component_with_one = j; } else { component_with_one = kNotFound; break; } } else { all_others_zero = false; break; } } if (!all_others_zero || component_with_one == kNotFound) { continue; } std::vector operands; operands.push_back( {SPV_OPERAND_TYPE_ID, {inst->GetSingleWordInOperand(1u - i)}}); operands.push_back( {SPV_OPERAND_TYPE_LITERAL_INTEGER, {component_with_one}}); inst->SetOpcode(spv::Op::OpCompositeExtract); inst->SetInOperands(std::move(operands)); return true; } return false; }; } // If we are storing an undef, then we can remove the store. // // TODO: We can do something similar for OpImageWrite, but checking for volatile // is complicated. Waiting to see if it is needed. FoldingRule StoringUndef() { return [](IRContext* context, Instruction* inst, const std::vector&) { assert(inst->opcode() == spv::Op::OpStore && "Wrong opcode. Should be OpStore."); analysis::DefUseManager* def_use_mgr = context->get_def_use_mgr(); // If this is a volatile store, the store cannot be removed. if (inst->NumInOperands() == 3) { if (inst->GetSingleWordInOperand(2) & uint32_t(spv::MemoryAccessMask::Volatile)) { return false; } } uint32_t object_id = inst->GetSingleWordInOperand(kStoreObjectInIdx); Instruction* object_inst = def_use_mgr->GetDef(object_id); if (object_inst->opcode() == spv::Op::OpUndef) { inst->ToNop(); return true; } return false; }; } FoldingRule VectorShuffleFeedingShuffle() { return [](IRContext* context, Instruction* inst, const std::vector&) { assert(inst->opcode() == spv::Op::OpVectorShuffle && "Wrong opcode. Should be OpVectorShuffle."); analysis::DefUseManager* def_use_mgr = context->get_def_use_mgr(); analysis::TypeManager* type_mgr = context->get_type_mgr(); Instruction* feeding_shuffle_inst = def_use_mgr->GetDef(inst->GetSingleWordInOperand(0)); analysis::Vector* op0_type = type_mgr->GetType(feeding_shuffle_inst->type_id())->AsVector(); uint32_t op0_length = op0_type->element_count(); bool feeder_is_op0 = true; if (feeding_shuffle_inst->opcode() != spv::Op::OpVectorShuffle) { feeding_shuffle_inst = def_use_mgr->GetDef(inst->GetSingleWordInOperand(1)); feeder_is_op0 = false; } if (feeding_shuffle_inst->opcode() != spv::Op::OpVectorShuffle) { return false; } Instruction* feeder2 = def_use_mgr->GetDef(feeding_shuffle_inst->GetSingleWordInOperand(0)); analysis::Vector* feeder_op0_type = type_mgr->GetType(feeder2->type_id())->AsVector(); uint32_t feeder_op0_length = feeder_op0_type->element_count(); uint32_t new_feeder_id = 0; std::vector new_operands; new_operands.resize( 2, {SPV_OPERAND_TYPE_ID, {0}}); // Place holders for vector operands. const uint32_t undef_literal = 0xffffffff; for (uint32_t op = 2; op < inst->NumInOperands(); ++op) { uint32_t component_index = inst->GetSingleWordInOperand(op); // Do not interpret the undefined value literal as coming from operand 1. if (component_index != undef_literal && feeder_is_op0 == (component_index < op0_length)) { // This component comes from the feeding_shuffle_inst. Update // |component_index| to be the index into the operand of the feeder. // Adjust component_index to get the index into the operands of the // feeding_shuffle_inst. if (component_index >= op0_length) { component_index -= op0_length; } component_index = feeding_shuffle_inst->GetSingleWordInOperand(component_index + 2); // Check if we are using a component from the first or second operand of // the feeding instruction. if (component_index < feeder_op0_length) { if (new_feeder_id == 0) { // First time through, save the id of the operand the element comes // from. new_feeder_id = feeding_shuffle_inst->GetSingleWordInOperand(0); } else if (new_feeder_id != feeding_shuffle_inst->GetSingleWordInOperand(0)) { // We need both elements of the feeding_shuffle_inst, so we cannot // fold. return false; } } else if (component_index != undef_literal) { if (new_feeder_id == 0) { // First time through, save the id of the operand the element comes // from. new_feeder_id = feeding_shuffle_inst->GetSingleWordInOperand(1); } else if (new_feeder_id != feeding_shuffle_inst->GetSingleWordInOperand(1)) { // We need both elements of the feeding_shuffle_inst, so we cannot // fold. return false; } component_index -= feeder_op0_length; } if (!feeder_is_op0 && component_index != undef_literal) { component_index += op0_length; } } new_operands.push_back( {SPV_OPERAND_TYPE_LITERAL_INTEGER, {component_index}}); } if (new_feeder_id == 0) { analysis::ConstantManager* const_mgr = context->get_constant_mgr(); const analysis::Type* type = type_mgr->GetType(feeding_shuffle_inst->type_id()); const analysis::Constant* null_const = const_mgr->GetConstant(type, {}); new_feeder_id = const_mgr->GetDefiningInstruction(null_const, 0)->result_id(); } if (feeder_is_op0) { // If the size of the first vector operand changed then the indices // referring to the second operand need to be adjusted. Instruction* new_feeder_inst = def_use_mgr->GetDef(new_feeder_id); analysis::Type* new_feeder_type = type_mgr->GetType(new_feeder_inst->type_id()); uint32_t new_op0_size = new_feeder_type->AsVector()->element_count(); int32_t adjustment = op0_length - new_op0_size; if (adjustment != 0) { for (uint32_t i = 2; i < new_operands.size(); i++) { uint32_t operand = inst->GetSingleWordInOperand(i); if (operand >= op0_length && operand != undef_literal) { new_operands[i].words[0] -= adjustment; } } } new_operands[0].words[0] = new_feeder_id; new_operands[1] = inst->GetInOperand(1); } else { new_operands[1].words[0] = new_feeder_id; new_operands[0] = inst->GetInOperand(0); } inst->SetInOperands(std::move(new_operands)); return true; }; } // Removes duplicate ids from the interface list of an OpEntryPoint // instruction. FoldingRule RemoveRedundantOperands() { return [](IRContext*, Instruction* inst, const std::vector&) { assert(inst->opcode() == spv::Op::OpEntryPoint && "Wrong opcode. Should be OpEntryPoint."); bool has_redundant_operand = false; std::unordered_set seen_operands; std::vector new_operands; new_operands.emplace_back(inst->GetOperand(0)); new_operands.emplace_back(inst->GetOperand(1)); new_operands.emplace_back(inst->GetOperand(2)); for (uint32_t i = 3; i < inst->NumOperands(); ++i) { if (seen_operands.insert(inst->GetSingleWordOperand(i)).second) { new_operands.emplace_back(inst->GetOperand(i)); } else { has_redundant_operand = true; } } if (!has_redundant_operand) { return false; } inst->SetInOperands(std::move(new_operands)); return true; }; } // If an image instruction's operand is a constant, updates the image operand // flag from Offset to ConstOffset. FoldingRule UpdateImageOperands() { return [](IRContext*, Instruction* inst, const std::vector& constants) { const auto opcode = inst->opcode(); (void)opcode; assert((opcode == spv::Op::OpImageSampleImplicitLod || opcode == spv::Op::OpImageSampleExplicitLod || opcode == spv::Op::OpImageSampleDrefImplicitLod || opcode == spv::Op::OpImageSampleDrefExplicitLod || opcode == spv::Op::OpImageSampleProjImplicitLod || opcode == spv::Op::OpImageSampleProjExplicitLod || opcode == spv::Op::OpImageSampleProjDrefImplicitLod || opcode == spv::Op::OpImageSampleProjDrefExplicitLod || opcode == spv::Op::OpImageFetch || opcode == spv::Op::OpImageGather || opcode == spv::Op::OpImageDrefGather || opcode == spv::Op::OpImageRead || opcode == spv::Op::OpImageWrite || opcode == spv::Op::OpImageSparseSampleImplicitLod || opcode == spv::Op::OpImageSparseSampleExplicitLod || opcode == spv::Op::OpImageSparseSampleDrefImplicitLod || opcode == spv::Op::OpImageSparseSampleDrefExplicitLod || opcode == spv::Op::OpImageSparseSampleProjImplicitLod || opcode == spv::Op::OpImageSparseSampleProjExplicitLod || opcode == spv::Op::OpImageSparseSampleProjDrefImplicitLod || opcode == spv::Op::OpImageSparseSampleProjDrefExplicitLod || opcode == spv::Op::OpImageSparseFetch || opcode == spv::Op::OpImageSparseGather || opcode == spv::Op::OpImageSparseDrefGather || opcode == spv::Op::OpImageSparseRead) && "Wrong opcode. Should be an image instruction."); int32_t operand_index = ImageOperandsMaskInOperandIndex(inst); if (operand_index >= 0) { auto image_operands = inst->GetSingleWordInOperand(operand_index); if (image_operands & uint32_t(spv::ImageOperandsMask::Offset)) { uint32_t offset_operand_index = operand_index + 1; if (image_operands & uint32_t(spv::ImageOperandsMask::Bias)) offset_operand_index++; if (image_operands & uint32_t(spv::ImageOperandsMask::Lod)) offset_operand_index++; if (image_operands & uint32_t(spv::ImageOperandsMask::Grad)) offset_operand_index += 2; assert(((image_operands & uint32_t(spv::ImageOperandsMask::ConstOffset)) == 0) && "Offset and ConstOffset may not be used together"); if (offset_operand_index < inst->NumOperands()) { if (constants[offset_operand_index]) { if (constants[offset_operand_index]->IsZero()) { inst->RemoveInOperand(offset_operand_index); } else { image_operands = image_operands | uint32_t(spv::ImageOperandsMask::ConstOffset); } image_operands = image_operands & ~uint32_t(spv::ImageOperandsMask::Offset); inst->SetInOperand(operand_index, {image_operands}); return true; } } } } return false; }; } } // namespace void FoldingRules::AddFoldingRules() { // Add all folding rules to the list for the opcodes to which they apply. // Note that the order in which rules are added to the list matters. If a rule // applies to the instruction, the rest of the rules will not be attempted. // Take that into consideration. rules_[spv::Op::OpBitcast].push_back(BitCastScalarOrVector()); rules_[spv::Op::OpCompositeConstruct].push_back( CompositeExtractFeedingConstruct); rules_[spv::Op::OpCompositeExtract].push_back(InsertFeedingExtract()); rules_[spv::Op::OpCompositeExtract].push_back( CompositeConstructFeedingExtract); rules_[spv::Op::OpCompositeExtract].push_back(VectorShuffleFeedingExtract()); rules_[spv::Op::OpCompositeExtract].push_back(FMixFeedingExtract()); rules_[spv::Op::OpCompositeInsert].push_back( CompositeInsertToCompositeConstruct); rules_[spv::Op::OpDot].push_back(DotProductDoingExtract()); rules_[spv::Op::OpEntryPoint].push_back(RemoveRedundantOperands()); rules_[spv::Op::OpFAdd].push_back(RedundantFAdd()); rules_[spv::Op::OpFAdd].push_back(MergeAddNegateArithmetic()); rules_[spv::Op::OpFAdd].push_back(MergeAddAddArithmetic()); rules_[spv::Op::OpFAdd].push_back(MergeAddSubArithmetic()); rules_[spv::Op::OpFAdd].push_back(MergeGenericAddSubArithmetic()); rules_[spv::Op::OpFAdd].push_back(FactorAddMuls()); rules_[spv::Op::OpFDiv].push_back(RedundantFDiv()); rules_[spv::Op::OpFDiv].push_back(ReciprocalFDiv()); rules_[spv::Op::OpFDiv].push_back(MergeDivDivArithmetic()); rules_[spv::Op::OpFDiv].push_back(MergeDivMulArithmetic()); rules_[spv::Op::OpFDiv].push_back(MergeDivNegateArithmetic()); rules_[spv::Op::OpFMul].push_back(RedundantFMul()); rules_[spv::Op::OpFMul].push_back(MergeMulMulArithmetic()); rules_[spv::Op::OpFMul].push_back(MergeMulDivArithmetic()); rules_[spv::Op::OpFMul].push_back(MergeMulNegateArithmetic()); rules_[spv::Op::OpFNegate].push_back(MergeNegateArithmetic()); rules_[spv::Op::OpFNegate].push_back(MergeNegateAddSubArithmetic()); rules_[spv::Op::OpFNegate].push_back(MergeNegateMulDivArithmetic()); rules_[spv::Op::OpFSub].push_back(RedundantFSub()); rules_[spv::Op::OpFSub].push_back(MergeSubNegateArithmetic()); rules_[spv::Op::OpFSub].push_back(MergeSubAddArithmetic()); rules_[spv::Op::OpFSub].push_back(MergeSubSubArithmetic()); rules_[spv::Op::OpIAdd].push_back(RedundantIAdd()); rules_[spv::Op::OpIAdd].push_back(MergeAddNegateArithmetic()); rules_[spv::Op::OpIAdd].push_back(MergeAddAddArithmetic()); rules_[spv::Op::OpIAdd].push_back(MergeAddSubArithmetic()); rules_[spv::Op::OpIAdd].push_back(MergeGenericAddSubArithmetic()); rules_[spv::Op::OpIAdd].push_back(FactorAddMuls()); rules_[spv::Op::OpIMul].push_back(IntMultipleBy1()); rules_[spv::Op::OpIMul].push_back(MergeMulMulArithmetic()); rules_[spv::Op::OpIMul].push_back(MergeMulNegateArithmetic()); rules_[spv::Op::OpISub].push_back(MergeSubNegateArithmetic()); rules_[spv::Op::OpISub].push_back(MergeSubAddArithmetic()); rules_[spv::Op::OpISub].push_back(MergeSubSubArithmetic()); rules_[spv::Op::OpPhi].push_back(RedundantPhi()); rules_[spv::Op::OpSNegate].push_back(MergeNegateArithmetic()); rules_[spv::Op::OpSNegate].push_back(MergeNegateMulDivArithmetic()); rules_[spv::Op::OpSNegate].push_back(MergeNegateAddSubArithmetic()); rules_[spv::Op::OpSelect].push_back(RedundantSelect()); rules_[spv::Op::OpStore].push_back(StoringUndef()); rules_[spv::Op::OpVectorShuffle].push_back(VectorShuffleFeedingShuffle()); rules_[spv::Op::OpImageSampleImplicitLod].push_back(UpdateImageOperands()); rules_[spv::Op::OpImageSampleExplicitLod].push_back(UpdateImageOperands()); rules_[spv::Op::OpImageSampleDrefImplicitLod].push_back( UpdateImageOperands()); rules_[spv::Op::OpImageSampleDrefExplicitLod].push_back( UpdateImageOperands()); rules_[spv::Op::OpImageSampleProjImplicitLod].push_back( UpdateImageOperands()); rules_[spv::Op::OpImageSampleProjExplicitLod].push_back( UpdateImageOperands()); rules_[spv::Op::OpImageSampleProjDrefImplicitLod].push_back( UpdateImageOperands()); rules_[spv::Op::OpImageSampleProjDrefExplicitLod].push_back( UpdateImageOperands()); rules_[spv::Op::OpImageFetch].push_back(UpdateImageOperands()); rules_[spv::Op::OpImageGather].push_back(UpdateImageOperands()); rules_[spv::Op::OpImageDrefGather].push_back(UpdateImageOperands()); rules_[spv::Op::OpImageRead].push_back(UpdateImageOperands()); rules_[spv::Op::OpImageWrite].push_back(UpdateImageOperands()); rules_[spv::Op::OpImageSparseSampleImplicitLod].push_back( UpdateImageOperands()); rules_[spv::Op::OpImageSparseSampleExplicitLod].push_back( UpdateImageOperands()); rules_[spv::Op::OpImageSparseSampleDrefImplicitLod].push_back( UpdateImageOperands()); rules_[spv::Op::OpImageSparseSampleDrefExplicitLod].push_back( UpdateImageOperands()); rules_[spv::Op::OpImageSparseSampleProjImplicitLod].push_back( UpdateImageOperands()); rules_[spv::Op::OpImageSparseSampleProjExplicitLod].push_back( UpdateImageOperands()); rules_[spv::Op::OpImageSparseSampleProjDrefImplicitLod].push_back( UpdateImageOperands()); rules_[spv::Op::OpImageSparseSampleProjDrefExplicitLod].push_back( UpdateImageOperands()); rules_[spv::Op::OpImageSparseFetch].push_back(UpdateImageOperands()); rules_[spv::Op::OpImageSparseGather].push_back(UpdateImageOperands()); rules_[spv::Op::OpImageSparseDrefGather].push_back(UpdateImageOperands()); rules_[spv::Op::OpImageSparseRead].push_back(UpdateImageOperands()); FeatureManager* feature_manager = context_->get_feature_mgr(); // Add rules for GLSLstd450 uint32_t ext_inst_glslstd450_id = feature_manager->GetExtInstImportId_GLSLstd450(); if (ext_inst_glslstd450_id != 0) { ext_rules_[{ext_inst_glslstd450_id, GLSLstd450FMix}].push_back( RedundantFMix()); } } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/folding_rules.h000066400000000000000000000076041475742701700236470ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_FOLDING_RULES_H_ #define SOURCE_OPT_FOLDING_RULES_H_ #include #include #include #include "source/opt/constants.h" namespace spvtools { namespace opt { // Folding Rules: // // The folding mechanism is built around the concept of a |FoldingRule|. A // folding rule is a function that implements a method of simplifying an // instruction. // // The inputs to a folding rule are: // |inst| - the instruction to be simplified. // |constants| - if an in-operands is an id of a constant, then the // corresponding value in |constants| contains that // constant value. Otherwise, the corresponding entry in // |constants| is |nullptr|. // // A folding rule returns true if |inst| can be simplified using this rule. If // the instruction can be simplified, then |inst| is changed to the simplified // instruction. Otherwise, |inst| remains the same. // // See folding_rules.cpp for examples on how to write a folding rule. It is // important to note that if |inst| can be folded to the result of an // instruction that feed it, then |inst| should be changed to an OpCopyObject // that copies that id. // // Be sure to add new folding rules to the table of folding rules in the // constructor for FoldingRules. The new rule should be added to the list for // every opcode that it applies to. Note that earlier rules in the list are // given priority. That is, if an earlier rule is able to fold an instruction, // the later rules will not be attempted. using FoldingRule = std::function& constants)>; class FoldingRules { public: using FoldingRuleSet = std::vector; explicit FoldingRules(IRContext* ctx) : context_(ctx) {} virtual ~FoldingRules() = default; const FoldingRuleSet& GetRulesForInstruction(Instruction* inst) const { if (inst->opcode() != spv::Op::OpExtInst) { auto it = rules_.find(inst->opcode()); if (it != rules_.end()) { return it->second; } } else { uint32_t ext_inst_id = inst->GetSingleWordInOperand(0); uint32_t ext_opcode = inst->GetSingleWordInOperand(1); auto it = ext_rules_.find({ext_inst_id, ext_opcode}); if (it != ext_rules_.end()) { return it->second; } } return empty_vector_; } IRContext* context() { return context_; } // Adds the folding rules for the object. virtual void AddFoldingRules(); protected: struct hasher { size_t operator()(const spv::Op& op) const noexcept { return std::hash()(uint32_t(op)); } }; // The folding rules for core instructions. std::unordered_map rules_; // The folding rules for extended instructions. struct Key { uint32_t instruction_set; uint32_t opcode; }; friend bool operator<(const Key& a, const Key& b) { if (a.instruction_set < b.instruction_set) { return true; } if (a.instruction_set > b.instruction_set) { return false; } return a.opcode < b.opcode; } std::map ext_rules_; private: IRContext* context_; FoldingRuleSet empty_vector_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_FOLDING_RULES_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/freeze_spec_constant_value_pass.cpp000066400000000000000000000032351475742701700277670ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/freeze_spec_constant_value_pass.h" #include "source/opt/ir_context.h" namespace spvtools { namespace opt { Pass::Status FreezeSpecConstantValuePass::Process() { bool modified = false; auto ctx = context(); ctx->module()->ForEachInst([&modified, ctx](Instruction* inst) { switch (inst->opcode()) { case spv::Op::OpSpecConstant: inst->SetOpcode(spv::Op::OpConstant); modified = true; break; case spv::Op::OpSpecConstantTrue: inst->SetOpcode(spv::Op::OpConstantTrue); modified = true; break; case spv::Op::OpSpecConstantFalse: inst->SetOpcode(spv::Op::OpConstantFalse); modified = true; break; case spv::Op::OpDecorate: if (spv::Decoration(inst->GetSingleWordInOperand(1)) == spv::Decoration::SpecId) { ctx->KillInst(inst); modified = true; } break; default: break; } }); return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/freeze_spec_constant_value_pass.h000066400000000000000000000021631475742701700274330ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_FREEZE_SPEC_CONSTANT_VALUE_PASS_H_ #define SOURCE_OPT_FREEZE_SPEC_CONSTANT_VALUE_PASS_H_ #include "source/opt/ir_context.h" #include "source/opt/module.h" #include "source/opt/pass.h" namespace spvtools { namespace opt { // See optimizer.hpp for documentation. class FreezeSpecConstantValuePass : public Pass { public: const char* name() const override { return "freeze-spec-const"; } Status Process() override; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_FREEZE_SPEC_CONSTANT_VALUE_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/function.cpp000066400000000000000000000201461475742701700231670ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/function.h" #include #include "ir_context.h" #include "source/util/bit_vector.h" namespace spvtools { namespace opt { Function* Function::Clone(IRContext* ctx) const { Function* clone = new Function(std::unique_ptr(DefInst().Clone(ctx))); clone->params_.reserve(params_.size()); ForEachParam( [clone, ctx](const Instruction* inst) { clone->AddParameter(std::unique_ptr(inst->Clone(ctx))); }, true); for (const auto& i : debug_insts_in_header_) { clone->AddDebugInstructionInHeader( std::unique_ptr(i.Clone(ctx))); } clone->blocks_.reserve(blocks_.size()); for (const auto& b : blocks_) { std::unique_ptr bb(b->Clone(ctx)); clone->AddBasicBlock(std::move(bb)); } clone->SetFunctionEnd(std::unique_ptr(EndInst()->Clone(ctx))); clone->non_semantic_.reserve(non_semantic_.size()); for (auto& non_semantic : non_semantic_) { clone->AddNonSemanticInstruction( std::unique_ptr(non_semantic->Clone(ctx))); } return clone; } void Function::ForEachInst(const std::function& f, bool run_on_debug_line_insts, bool run_on_non_semantic_insts) { WhileEachInst( [&f](Instruction* inst) { f(inst); return true; }, run_on_debug_line_insts, run_on_non_semantic_insts); } void Function::ForEachInst(const std::function& f, bool run_on_debug_line_insts, bool run_on_non_semantic_insts) const { WhileEachInst( [&f](const Instruction* inst) { f(inst); return true; }, run_on_debug_line_insts, run_on_non_semantic_insts); } bool Function::WhileEachInst(const std::function& f, bool run_on_debug_line_insts, bool run_on_non_semantic_insts) { if (def_inst_) { if (!def_inst_->WhileEachInst(f, run_on_debug_line_insts)) { return false; } } for (auto& param : params_) { if (!param->WhileEachInst(f, run_on_debug_line_insts)) { return false; } } if (!debug_insts_in_header_.empty()) { Instruction* di = &debug_insts_in_header_.front(); while (di != nullptr) { Instruction* next_instruction = di->NextNode(); if (!di->WhileEachInst(f, run_on_debug_line_insts)) return false; di = next_instruction; } } for (auto& bb : blocks_) { if (!bb->WhileEachInst(f, run_on_debug_line_insts)) { return false; } } if (end_inst_) { if (!end_inst_->WhileEachInst(f, run_on_debug_line_insts)) { return false; } } if (run_on_non_semantic_insts) { for (auto& non_semantic : non_semantic_) { if (!non_semantic->WhileEachInst(f, run_on_debug_line_insts)) { return false; } } } return true; } bool Function::WhileEachInst(const std::function& f, bool run_on_debug_line_insts, bool run_on_non_semantic_insts) const { if (def_inst_) { if (!static_cast(def_inst_.get()) ->WhileEachInst(f, run_on_debug_line_insts)) { return false; } } for (const auto& param : params_) { if (!static_cast(param.get()) ->WhileEachInst(f, run_on_debug_line_insts)) { return false; } } for (const auto& di : debug_insts_in_header_) { if (!static_cast(&di)->WhileEachInst( f, run_on_debug_line_insts)) return false; } for (const auto& bb : blocks_) { if (!static_cast(bb.get())->WhileEachInst( f, run_on_debug_line_insts)) { return false; } } if (end_inst_) { if (!static_cast(end_inst_.get()) ->WhileEachInst(f, run_on_debug_line_insts)) { return false; } } if (run_on_non_semantic_insts) { for (auto& non_semantic : non_semantic_) { if (!static_cast(non_semantic.get()) ->WhileEachInst(f, run_on_debug_line_insts)) { return false; } } } return true; } void Function::ForEachParam(const std::function& f, bool run_on_debug_line_insts) { for (auto& param : params_) static_cast(param.get()) ->ForEachInst(f, run_on_debug_line_insts); } void Function::ForEachParam(const std::function& f, bool run_on_debug_line_insts) const { for (const auto& param : params_) static_cast(param.get()) ->ForEachInst(f, run_on_debug_line_insts); } void Function::ForEachDebugInstructionsInHeader( const std::function& f) { if (debug_insts_in_header_.empty()) return; Instruction* di = &debug_insts_in_header_.front(); while (di != nullptr) { Instruction* next_instruction = di->NextNode(); di->ForEachInst(f); di = next_instruction; } } BasicBlock* Function::InsertBasicBlockAfter( std::unique_ptr&& new_block, BasicBlock* position) { for (auto bb_iter = begin(); bb_iter != end(); ++bb_iter) { if (&*bb_iter == position) { new_block->SetParent(this); ++bb_iter; bb_iter = bb_iter.InsertBefore(std::move(new_block)); return &*bb_iter; } } assert(false && "Could not find insertion point."); return nullptr; } BasicBlock* Function::InsertBasicBlockBefore( std::unique_ptr&& new_block, BasicBlock* position) { for (auto bb_iter = begin(); bb_iter != end(); ++bb_iter) { if (&*bb_iter == position) { new_block->SetParent(this); bb_iter = bb_iter.InsertBefore(std::move(new_block)); return &*bb_iter; } } assert(false && "Could not find insertion point."); return nullptr; } bool Function::HasEarlyReturn() const { auto post_dominator_analysis = blocks_.front()->GetLabel()->context()->GetPostDominatorAnalysis(this); for (auto& block : blocks_) { if (spvOpcodeIsReturn(block->tail()->opcode()) && !post_dominator_analysis->Dominates(block.get(), entry().get())) { return true; } } return false; } bool Function::IsRecursive() const { IRContext* ctx = blocks_.front()->GetLabel()->context(); IRContext::ProcessFunction mark_visited = [this](Function* fp) { return fp == this; }; // Process the call tree from all of the function called by |this|. If it get // back to |this|, then we have a recursive function. std::queue roots; ctx->AddCalls(this, &roots); return ctx->ProcessCallTreeFromRoots(mark_visited, &roots); } std::ostream& operator<<(std::ostream& str, const Function& func) { str << func.PrettyPrint(); return str; } void Function::Dump() const { std::cerr << "Function #" << result_id() << "\n" << *this << "\n"; } std::string Function::PrettyPrint(uint32_t options) const { std::ostringstream str; ForEachInst([&str, options](const Instruction* inst) { str << inst->PrettyPrint(options); if (inst->opcode() != spv::Op::OpFunctionEnd) { str << std::endl; } }); return str.str(); } void Function::ReorderBasicBlocksInStructuredOrder() { std::list order; IRContext* context = this->def_inst_->context(); context->cfg()->ComputeStructuredOrder(this, blocks_[0].get(), &order); ReorderBasicBlocks(order.begin(), order.end()); } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/function.h000066400000000000000000000271611475742701700226400ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_FUNCTION_H_ #define SOURCE_OPT_FUNCTION_H_ #include #include #include #include #include #include #include #include "source/opt/basic_block.h" #include "source/opt/instruction.h" #include "source/opt/iterator.h" namespace spvtools { namespace opt { class CFG; class IRContext; class Module; // A SPIR-V function. class Function { public: using iterator = UptrVectorIterator; using const_iterator = UptrVectorIterator; // Creates a function instance declared by the given OpFunction instruction // |def_inst|. inline explicit Function(std::unique_ptr def_inst); explicit Function(const Function& f) = delete; // Creates a clone of the instruction in the given |context| // // The parent module will default to null and needs to be explicitly set by // the user. Function* Clone(IRContext*) const; // The OpFunction instruction that begins the definition of this function. Instruction& DefInst() { return *def_inst_; } const Instruction& DefInst() const { return *def_inst_; } // Appends a parameter to this function. inline void AddParameter(std::unique_ptr p); // Appends a debug instruction in function header to this function. inline void AddDebugInstructionInHeader(std::unique_ptr p); // Appends a basic block to this function. inline void AddBasicBlock(std::unique_ptr b); // Appends a basic block to this function at the position |ip|. inline void AddBasicBlock(std::unique_ptr b, iterator ip); template inline void AddBasicBlocks(T begin, T end, iterator ip); // Move basic block with |id| to the position after |ip|. Both have to be // contained in this function. inline void MoveBasicBlockToAfter(uint32_t id, BasicBlock* ip); // Delete all basic blocks that contain no instructions. inline void RemoveEmptyBlocks(); // Removes a parameter from the function with result id equal to |id|. // Does nothing if the function doesn't have such a parameter. inline void RemoveParameter(uint32_t id); // Saves the given function end instruction. inline void SetFunctionEnd(std::unique_ptr end_inst); // Add a non-semantic instruction that succeeds this function in the module. // These instructions are maintained in the order they are added. inline void AddNonSemanticInstruction( std::unique_ptr non_semantic); // Returns the given function end instruction. inline Instruction* EndInst() { return end_inst_.get(); } inline const Instruction* EndInst() const { return end_inst_.get(); } // Returns function's id inline uint32_t result_id() const { return def_inst_->result_id(); } // Returns function's return type id inline uint32_t type_id() const { return def_inst_->type_id(); } // Returns the function's control mask inline uint32_t control_mask() const { return def_inst_->GetSingleWordInOperand(0); } // Returns the entry basic block for this function. const std::unique_ptr& entry() const { return blocks_.front(); } // Returns the last basic block in this function. BasicBlock* tail() { return blocks_.back().get(); } const BasicBlock* tail() const { return blocks_.back().get(); } iterator begin() { return iterator(&blocks_, blocks_.begin()); } iterator end() { return iterator(&blocks_, blocks_.end()); } const_iterator begin() const { return cbegin(); } const_iterator end() const { return cend(); } const_iterator cbegin() const { return const_iterator(&blocks_, blocks_.cbegin()); } const_iterator cend() const { return const_iterator(&blocks_, blocks_.cend()); } // Returns an iterator to the basic block |id|. iterator FindBlock(uint32_t bb_id) { return std::find_if(begin(), end(), [bb_id](const BasicBlock& it_bb) { return bb_id == it_bb.id(); }); } // Runs the given function |f| on instructions in this function, in order, // and optionally on debug line instructions that might precede them and // non-semantic instructions that succceed the function. void ForEachInst(const std::function& f, bool run_on_debug_line_insts = false, bool run_on_non_semantic_insts = false); void ForEachInst(const std::function& f, bool run_on_debug_line_insts = false, bool run_on_non_semantic_insts = false) const; // Runs the given function |f| on instructions in this function, in order, // and optionally on debug line instructions that might precede them and // non-semantic instructions that succeed the function. If |f| returns // false, iteration is terminated and this function returns false. bool WhileEachInst(const std::function& f, bool run_on_debug_line_insts = false, bool run_on_non_semantic_insts = false); bool WhileEachInst(const std::function& f, bool run_on_debug_line_insts = false, bool run_on_non_semantic_insts = false) const; // Runs the given function |f| on each parameter instruction in this function, // in order, and optionally on debug line instructions that might precede // them. void ForEachParam(const std::function& f, bool run_on_debug_line_insts = false) const; void ForEachParam(const std::function& f, bool run_on_debug_line_insts = false); // Runs the given function |f| on each debug instruction in this function's // header in order. void ForEachDebugInstructionsInHeader( const std::function& f); BasicBlock* InsertBasicBlockAfter(std::unique_ptr&& new_block, BasicBlock* position); BasicBlock* InsertBasicBlockBefore(std::unique_ptr&& new_block, BasicBlock* position); // Returns true if the function has a return block other than the exit block. bool HasEarlyReturn() const; // Returns true if the function calls itself either directly or indirectly. bool IsRecursive() const; // Pretty-prints all the basic blocks in this function into a std::string. // // |options| are the disassembly options. SPV_BINARY_TO_TEXT_OPTION_NO_HEADER // is always added to |options|. std::string PrettyPrint(uint32_t options = 0u) const; // Dump this function on stderr. Useful when running interactive // debuggers. void Dump() const; // Returns true is a function declaration and not a function definition. bool IsDeclaration() { return begin() == end(); } // Reorders the basic blocks in the function to match the structured order. void ReorderBasicBlocksInStructuredOrder(); private: // Reorders the basic blocks in the function to match the order given by the // range |{begin,end}|. The range must contain every basic block in the // function, and no extras. template void ReorderBasicBlocks(It begin, It end); template bool ContainsAllBlocksInTheFunction(It begin, It end); // The OpFunction instruction that begins the definition of this function. std::unique_ptr def_inst_; // All parameters to this function. std::vector> params_; // All debug instructions in this function's header. InstructionList debug_insts_in_header_; // All basic blocks inside this function in specification order std::vector> blocks_; // The OpFunctionEnd instruction. std::unique_ptr end_inst_; // Non-semantic instructions succeeded by this function. std::vector> non_semantic_; }; // Pretty-prints |func| to |str|. Returns |str|. std::ostream& operator<<(std::ostream& str, const Function& func); inline Function::Function(std::unique_ptr def_inst) : def_inst_(std::move(def_inst)), end_inst_() {} inline void Function::AddParameter(std::unique_ptr p) { params_.emplace_back(std::move(p)); } inline void Function::AddDebugInstructionInHeader( std::unique_ptr p) { debug_insts_in_header_.push_back(std::move(p)); } inline void Function::AddBasicBlock(std::unique_ptr b) { AddBasicBlock(std::move(b), end()); } inline void Function::AddBasicBlock(std::unique_ptr b, iterator ip) { b->SetParent(this); ip.InsertBefore(std::move(b)); } template inline void Function::AddBasicBlocks(T src_begin, T src_end, iterator ip) { blocks_.insert(ip.Get(), std::make_move_iterator(src_begin), std::make_move_iterator(src_end)); } inline void Function::MoveBasicBlockToAfter(uint32_t id, BasicBlock* ip) { std::unique_ptr block_to_move = std::move(*FindBlock(id).Get()); blocks_.erase(std::find(std::begin(blocks_), std::end(blocks_), nullptr)); assert(block_to_move->GetParent() == ip->GetParent() && "Both blocks have to be in the same function."); InsertBasicBlockAfter(std::move(block_to_move), ip); } inline void Function::RemoveEmptyBlocks() { auto first_empty = std::remove_if(std::begin(blocks_), std::end(blocks_), [](const std::unique_ptr& bb) -> bool { return bb->GetLabelInst()->opcode() == spv::Op::OpNop; }); blocks_.erase(first_empty, std::end(blocks_)); } inline void Function::RemoveParameter(uint32_t id) { params_.erase(std::remove_if(params_.begin(), params_.end(), [id](const std::unique_ptr& param) { return param->result_id() == id; }), params_.end()); } inline void Function::SetFunctionEnd(std::unique_ptr end_inst) { end_inst_ = std::move(end_inst); } inline void Function::AddNonSemanticInstruction( std::unique_ptr non_semantic) { non_semantic_.emplace_back(std::move(non_semantic)); } template void Function::ReorderBasicBlocks(It begin, It end) { // Asserts to make sure every node in the function is in new_order. assert(ContainsAllBlocksInTheFunction(begin, end)); // We have a pointer to all the elements in order, so we can release all // pointers in |block_|, and then create the new unique pointers from |{begin, // end}|. std::for_each(blocks_.begin(), blocks_.end(), [](std::unique_ptr& bb) { bb.release(); }); std::transform(begin, end, blocks_.begin(), [](BasicBlock* bb) { return std::unique_ptr(bb); }); } template bool Function::ContainsAllBlocksInTheFunction(It begin, It end) { std::unordered_multiset range(begin, end); if (range.size() != blocks_.size()) { return false; } for (auto& bb : blocks_) { if (range.count(bb.get()) == 0) return false; } return true; } } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_FUNCTION_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/graphics_robust_access_pass.cpp000066400000000000000000001315371475742701700271160ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // This pass injects code in a graphics shader to implement guarantees // satisfying Vulkan's robustBufferAccess rules. Robust access rules permit // an out-of-bounds access to be redirected to an access of the same type // (load, store, etc.) but within the same root object. // // We assume baseline functionality in Vulkan, i.e. the module uses // logical addressing mode, without VK_KHR_variable_pointers. // // - Logical addressing mode implies: // - Each root pointer (a pointer that exists other than by the // execution of a shader instruction) is the result of an OpVariable. // // - Instructions that result in pointers are: // OpVariable // OpAccessChain // OpInBoundsAccessChain // OpFunctionParameter // OpImageTexelPointer // OpCopyObject // // - Instructions that use a pointer are: // OpLoad // OpStore // OpAccessChain // OpInBoundsAccessChain // OpFunctionCall // OpImageTexelPointer // OpCopyMemory // OpCopyObject // all OpAtomic* instructions // // We classify pointer-users into: // - Accesses: // - OpLoad // - OpStore // - OpAtomic* // - OpCopyMemory // // - Address calculations: // - OpAccessChain // - OpInBoundsAccessChain // // - Pass-through: // - OpFunctionCall // - OpFunctionParameter // - OpCopyObject // // The strategy is: // // - Handle only logical addressing mode. In particular, don't handle a module // if it uses one of the variable-pointers capabilities. // // - Don't handle modules using capability RuntimeDescriptorArrayEXT. So the // only runtime arrays are those that are the last member in a // Block-decorated struct. This allows us to feasibly/easily compute the // length of the runtime array. See below. // // - The memory locations accessed by OpLoad, OpStore, OpCopyMemory, and // OpAtomic* are determined by their pointer parameter or parameters. // Pointers are always (correctly) typed and so the address and number of // consecutive locations are fully determined by the pointer. // // - A pointer value originates as one of few cases: // // - OpVariable for an interface object or an array of them: image, // buffer (UBO or SSBO), sampler, sampled-image, push-constant, input // variable, output variable. The execution environment is responsible for // allocating the correct amount of storage for these, and for ensuring // each resource bound to such a variable is big enough to contain the // SPIR-V pointee type of the variable. // // - OpVariable for a non-interface object. These are variables in // Workgroup, Private, and Function storage classes. The compiler ensures // the underlying allocation is big enough to store the entire SPIR-V // pointee type of the variable. // // - An OpFunctionParameter. This always maps to a pointer parameter to an // OpFunctionCall. // // - In logical addressing mode, these are severely limited: // "Any pointer operand to an OpFunctionCall must be: // - a memory object declaration, or // - a pointer to an element in an array that is a memory object // declaration, where the element type is OpTypeSampler or OpTypeImage" // // - This has an important simplifying consequence: // // - When looking for a pointer to the structure containing a runtime // array, you begin with a pointer to the runtime array and trace // backward in the function. You never have to trace back beyond // your function call boundary. So you can't take a partial access // chain into an SSBO, then pass that pointer into a function. So // we don't resort to using fat pointers to compute array length. // We can trace back to a pointer to the containing structure, // and use that in an OpArrayLength instruction. (The structure type // gives us the member index of the runtime array.) // // - Otherwise, the pointer type fully encodes the range of valid // addresses. In particular, the type of a pointer to an aggregate // value fully encodes the range of indices when indexing into // that aggregate. // // - The pointer is the result of an access chain instruction. We clamp // indices contributing to address calculations. As noted above, the // valid ranges are either bound by the length of a runtime array, or // by the type of the base pointer. The length of a runtime array is // the result of an OpArrayLength instruction acting on the pointer of // the containing structure as noted above. // // - Access chain indices are always treated as signed, so: // - Clamp the upper bound at the signed integer maximum. // - Use SClamp for all clamping. // // - TODO(dneto): OpImageTexelPointer: // - Clamp coordinate to the image size returned by OpImageQuerySize // - If multi-sampled, clamp the sample index to the count returned by // OpImageQuerySamples. // - If not multi-sampled, set the sample index to 0. // // - Rely on the external validator to check that pointers are only // used by the instructions as above. // // - Handles OpTypeRuntimeArray // Track pointer back to original resource (pointer to struct), so we can // query the runtime array size. // #include "graphics_robust_access_pass.h" #include #include #include #include "function.h" #include "ir_context.h" #include "pass.h" #include "source/diagnostic.h" #include "source/util/make_unique.h" #include "spirv-tools/libspirv.h" #include "spirv/unified1/GLSL.std.450.h" #include "type_manager.h" #include "types.h" namespace spvtools { namespace opt { using opt::Instruction; using opt::Operand; using spvtools::MakeUnique; GraphicsRobustAccessPass::GraphicsRobustAccessPass() : module_status_() {} Pass::Status GraphicsRobustAccessPass::Process() { module_status_ = PerModuleState(); ProcessCurrentModule(); auto result = module_status_.failed ? Status::Failure : (module_status_.modified ? Status::SuccessWithChange : Status::SuccessWithoutChange); return result; } spvtools::DiagnosticStream GraphicsRobustAccessPass::Fail() { module_status_.failed = true; // We don't really have a position, and we'll ignore the result. return std::move( spvtools::DiagnosticStream({}, consumer(), "", SPV_ERROR_INVALID_BINARY) << name() << ": "); } spv_result_t GraphicsRobustAccessPass::IsCompatibleModule() { auto* feature_mgr = context()->get_feature_mgr(); if (!feature_mgr->HasCapability(spv::Capability::Shader)) return Fail() << "Can only process Shader modules"; if (feature_mgr->HasCapability(spv::Capability::VariablePointers)) return Fail() << "Can't process modules with VariablePointers capability"; if (feature_mgr->HasCapability( spv::Capability::VariablePointersStorageBuffer)) return Fail() << "Can't process modules with VariablePointersStorageBuffer " "capability"; if (feature_mgr->HasCapability(spv::Capability::RuntimeDescriptorArrayEXT)) { // These have a RuntimeArray outside of Block-decorated struct. There // is no way to compute the array length from within SPIR-V. return Fail() << "Can't process modules with RuntimeDescriptorArrayEXT " "capability"; } { auto* inst = context()->module()->GetMemoryModel(); const auto addressing_model = spv::AddressingModel(inst->GetSingleWordOperand(0)); if (addressing_model != spv::AddressingModel::Logical) return Fail() << "Addressing model must be Logical. Found " << inst->PrettyPrint(); } return SPV_SUCCESS; } spv_result_t GraphicsRobustAccessPass::ProcessCurrentModule() { auto err = IsCompatibleModule(); if (err != SPV_SUCCESS) return err; ProcessFunction fn = [this](opt::Function* f) { return ProcessAFunction(f); }; module_status_.modified |= context()->ProcessReachableCallTree(fn); // Need something here. It's the price we pay for easier failure paths. return SPV_SUCCESS; } bool GraphicsRobustAccessPass::ProcessAFunction(opt::Function* function) { // Ensure that all pointers computed inside a function are within bounds. // Find the access chains in this block before trying to modify them. std::vector access_chains; std::vector image_texel_pointers; for (auto& block : *function) { for (auto& inst : block) { switch (inst.opcode()) { case spv::Op::OpAccessChain: case spv::Op::OpInBoundsAccessChain: access_chains.push_back(&inst); break; case spv::Op::OpImageTexelPointer: image_texel_pointers.push_back(&inst); break; default: break; } } } for (auto* inst : access_chains) { ClampIndicesForAccessChain(inst); if (module_status_.failed) return module_status_.modified; } for (auto* inst : image_texel_pointers) { if (SPV_SUCCESS != ClampCoordinateForImageTexelPointer(inst)) break; } return module_status_.modified; } void GraphicsRobustAccessPass::ClampIndicesForAccessChain( Instruction* access_chain) { Instruction& inst = *access_chain; auto* constant_mgr = context()->get_constant_mgr(); auto* def_use_mgr = context()->get_def_use_mgr(); auto* type_mgr = context()->get_type_mgr(); const bool have_int64_cap = context()->get_feature_mgr()->HasCapability(spv::Capability::Int64); // Replaces one of the OpAccessChain index operands with a new value. // Updates def-use analysis. auto replace_index = [this, &inst, def_use_mgr](uint32_t operand_index, Instruction* new_value) { inst.SetOperand(operand_index, {new_value->result_id()}); def_use_mgr->AnalyzeInstUse(&inst); module_status_.modified = true; return SPV_SUCCESS; }; // Replaces one of the OpAccesssChain index operands with a clamped value. // Replace the operand at |operand_index| with the value computed from // signed_clamp(%old_value, %min_value, %max_value). It also analyzes // the new instruction and records that them module is modified. // Assumes %min_value is signed-less-or-equal than %max_value. (All callees // use 0 for %min_value). auto clamp_index = [&inst, type_mgr, this, &replace_index]( uint32_t operand_index, Instruction* old_value, Instruction* min_value, Instruction* max_value) { auto* clamp_inst = MakeSClampInst(*type_mgr, old_value, min_value, max_value, &inst); return replace_index(operand_index, clamp_inst); }; // Ensures the specified index of access chain |inst| has a value that is // at most |count| - 1. If the index is already a constant value less than // |count| then no change is made. auto clamp_to_literal_count = [&inst, this, &constant_mgr, &type_mgr, have_int64_cap, &replace_index, &clamp_index](uint32_t operand_index, uint64_t count) -> spv_result_t { Instruction* index_inst = this->GetDef(inst.GetSingleWordOperand(operand_index)); const auto* index_type = type_mgr->GetType(index_inst->type_id())->AsInteger(); assert(index_type); const auto index_width = index_type->width(); if (count <= 1) { // Replace the index with 0. return replace_index(operand_index, GetValueForType(0, index_type)); } uint64_t maxval = count - 1; // Compute the bit width of a viable type to hold |maxval|. // Look for a bit width, up to 64 bits wide, to fit maxval. uint32_t maxval_width = index_width; while ((maxval_width < 64) && (0 != (maxval >> maxval_width))) { maxval_width *= 2; } // Determine the type for |maxval|. uint32_t next_id = context()->module()->IdBound(); analysis::Integer signed_type_for_query(maxval_width, true); auto* maxval_type = type_mgr->GetRegisteredType(&signed_type_for_query)->AsInteger(); if (next_id != context()->module()->IdBound()) { module_status_.modified = true; } // Access chain indices are treated as signed, so limit the maximum value // of the index so it will always be positive for a signed clamp operation. maxval = std::min(maxval, ((uint64_t(1) << (maxval_width - 1)) - 1)); if (index_width > 64) { return this->Fail() << "Can't handle indices wider than 64 bits, found " "constant index with " << index_width << " bits as index number " << operand_index << " of access chain " << inst.PrettyPrint(); } // Split into two cases: the current index is a constant, or not. // If the index is a constant then |index_constant| will not be a null // pointer. (If index is an |OpConstantNull| then it |index_constant| will // not be a null pointer.) Since access chain indices must be scalar // integers, this can't be a spec constant. if (auto* index_constant = constant_mgr->GetConstantFromInst(index_inst)) { auto* int_index_constant = index_constant->AsIntConstant(); int64_t value = 0; // OpAccessChain indices are treated as signed. So get the signed // constant value here. if (index_width <= 32) { value = int64_t(int_index_constant->GetS32BitValue()); } else if (index_width <= 64) { value = int_index_constant->GetS64BitValue(); } if (value < 0) { return replace_index(operand_index, GetValueForType(0, index_type)); } else if (uint64_t(value) <= maxval) { // Nothing to do. return SPV_SUCCESS; } else { // Replace with maxval. assert(count > 0); // Already took care of this case above. return replace_index(operand_index, GetValueForType(maxval, maxval_type)); } } else { // Generate a clamp instruction. assert(maxval >= 1); assert(index_width <= 64); // Otherwise, already returned above. if (index_width >= 64 && !have_int64_cap) { // An inconsistent module. return Fail() << "Access chain index is wider than 64 bits, but Int64 " "is not declared: " << index_inst->PrettyPrint(); } // Widen the index value if necessary if (maxval_width > index_width) { // Find the wider type. We only need this case if a constant array // bound is too big. // From how we calculated maxval_width, widening won't require adding // the Int64 capability. assert(have_int64_cap || maxval_width <= 32); if (!have_int64_cap && maxval_width >= 64) { // Be defensive, but this shouldn't happen. return this->Fail() << "Clamping index would require adding Int64 capability. " << "Can't clamp 32-bit index " << operand_index << " of access chain " << inst.PrettyPrint(); } index_inst = WidenInteger(index_type->IsSigned(), maxval_width, index_inst, &inst); } // Finally, clamp the index. return clamp_index(operand_index, index_inst, GetValueForType(0, maxval_type), GetValueForType(maxval, maxval_type)); } return SPV_SUCCESS; }; // Ensures the specified index of access chain |inst| has a value that is at // most the value of |count_inst| minus 1, where |count_inst| is treated as an // unsigned integer. This can log a failure. auto clamp_to_count = [&inst, this, &constant_mgr, &clamp_to_literal_count, &clamp_index, &type_mgr](uint32_t operand_index, Instruction* count_inst) -> spv_result_t { Instruction* index_inst = this->GetDef(inst.GetSingleWordOperand(operand_index)); const auto* index_type = type_mgr->GetType(index_inst->type_id())->AsInteger(); const auto* count_type = type_mgr->GetType(count_inst->type_id())->AsInteger(); assert(index_type); if (const auto* count_constant = constant_mgr->GetConstantFromInst(count_inst)) { uint64_t value = 0; const auto width = count_constant->type()->AsInteger()->width(); if (width <= 32) { value = count_constant->AsIntConstant()->GetU32BitValue(); } else if (width <= 64) { value = count_constant->AsIntConstant()->GetU64BitValue(); } else { return this->Fail() << "Can't handle indices wider than 64 bits, found " "constant index with " << index_type->width() << "bits"; } return clamp_to_literal_count(operand_index, value); } else { // Widen them to the same width. const auto index_width = index_type->width(); const auto count_width = count_type->width(); const auto target_width = std::max(index_width, count_width); // UConvert requires the result type to have 0 signedness. So enforce // that here. auto* wider_type = index_width < count_width ? count_type : index_type; if (index_type->width() < target_width) { // Access chain indices are treated as signed integers. index_inst = WidenInteger(true, target_width, index_inst, &inst); } else if (count_type->width() < target_width) { // Assume type sizes are treated as unsigned. count_inst = WidenInteger(false, target_width, count_inst, &inst); } // Compute count - 1. // It doesn't matter if 1 is signed or unsigned. auto* one = GetValueForType(1, wider_type); auto* count_minus_1 = InsertInst( &inst, spv::Op::OpISub, type_mgr->GetId(wider_type), TakeNextId(), {{SPV_OPERAND_TYPE_ID, {count_inst->result_id()}}, {SPV_OPERAND_TYPE_ID, {one->result_id()}}}); auto* zero = GetValueForType(0, wider_type); // Make sure we clamp to an upper bound that is at most the signed max // for the target type. const uint64_t max_signed_value = ((uint64_t(1) << (target_width - 1)) - 1); // Use unsigned-min to ensure that the result is always non-negative. // That ensures we satisfy the invariant for SClamp, where the "min" // argument we give it (zero), is no larger than the third argument. auto* upper_bound = MakeUMinInst(*type_mgr, count_minus_1, GetValueForType(max_signed_value, wider_type), &inst); // Now clamp the index to this upper bound. return clamp_index(operand_index, index_inst, zero, upper_bound); } return SPV_SUCCESS; }; const Instruction* base_inst = GetDef(inst.GetSingleWordInOperand(0)); const Instruction* base_type = GetDef(base_inst->type_id()); Instruction* pointee_type = GetDef(base_type->GetSingleWordInOperand(1)); // Walk the indices from earliest to latest, replacing indices with a // clamped value, and updating the pointee_type. The order matters for // the case when we have to compute the length of a runtime array. In // that the algorithm relies on the fact that that the earlier indices // have already been clamped. const uint32_t num_operands = inst.NumOperands(); for (uint32_t idx = 3; !module_status_.failed && idx < num_operands; ++idx) { const uint32_t index_id = inst.GetSingleWordOperand(idx); Instruction* index_inst = GetDef(index_id); switch (pointee_type->opcode()) { case spv::Op::OpTypeMatrix: // Use column count case spv::Op::OpTypeVector: // Use component count { const uint32_t count = pointee_type->GetSingleWordOperand(2); clamp_to_literal_count(idx, count); pointee_type = GetDef(pointee_type->GetSingleWordOperand(1)); } break; case spv::Op::OpTypeArray: { // The array length can be a spec constant, so go through the general // case. Instruction* array_len = GetDef(pointee_type->GetSingleWordOperand(2)); clamp_to_count(idx, array_len); pointee_type = GetDef(pointee_type->GetSingleWordOperand(1)); } break; case spv::Op::OpTypeStruct: { // SPIR-V requires the index to be an OpConstant. // We need to know the index literal value so we can compute the next // pointee type. if (index_inst->opcode() != spv::Op::OpConstant || !constant_mgr->GetConstantFromInst(index_inst) ->type() ->AsInteger()) { Fail() << "Member index into struct is not a constant integer: " << index_inst->PrettyPrint( SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES) << "\nin access chain: " << inst.PrettyPrint(SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); return; } const auto num_members = pointee_type->NumInOperands(); const auto* index_constant = constant_mgr->GetConstantFromInst(index_inst); // Get the sign-extended value, since access index is always treated as // signed. const auto index_value = index_constant->GetSignExtendedValue(); if (index_value < 0 || index_value >= num_members) { Fail() << "Member index " << index_value << " is out of bounds for struct type: " << pointee_type->PrettyPrint( SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES) << "\nin access chain: " << inst.PrettyPrint(SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); return; } pointee_type = GetDef(pointee_type->GetSingleWordInOperand( static_cast(index_value))); // No need to clamp this index. We just checked that it's valid. } break; case spv::Op::OpTypeRuntimeArray: { auto* array_len = MakeRuntimeArrayLengthInst(&inst, idx); if (!array_len) { // We've already signaled an error. return; } clamp_to_count(idx, array_len); if (module_status_.failed) return; pointee_type = GetDef(pointee_type->GetSingleWordOperand(1)); } break; default: Fail() << " Unhandled pointee type for access chain " << pointee_type->PrettyPrint( SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); } } } uint32_t GraphicsRobustAccessPass::GetGlslInsts() { if (module_status_.glsl_insts_id == 0) { // This string serves double-duty as raw data for a string and for a vector // of 32-bit words const char glsl[] = "GLSL.std.450"; // Use an existing import if we can. for (auto& inst : context()->module()->ext_inst_imports()) { if (inst.GetInOperand(0).AsString() == glsl) { module_status_.glsl_insts_id = inst.result_id(); } } if (module_status_.glsl_insts_id == 0) { // Make a new import instruction. module_status_.glsl_insts_id = TakeNextId(); std::vector words = spvtools::utils::MakeVector(glsl); auto import_inst = MakeUnique( context(), spv::Op::OpExtInstImport, 0, module_status_.glsl_insts_id, std::initializer_list{ Operand{SPV_OPERAND_TYPE_LITERAL_STRING, std::move(words)}}); Instruction* inst = import_inst.get(); context()->module()->AddExtInstImport(std::move(import_inst)); module_status_.modified = true; context()->AnalyzeDefUse(inst); // Invalidates the feature manager, since we added an extended instruction // set import. context()->ResetFeatureManager(); } } return module_status_.glsl_insts_id; } opt::Instruction* opt::GraphicsRobustAccessPass::GetValueForType( uint64_t value, const analysis::Integer* type) { auto* mgr = context()->get_constant_mgr(); assert(type->width() <= 64); std::vector words; words.push_back(uint32_t(value)); if (type->width() > 32) { words.push_back(uint32_t(value >> 32u)); } const auto* constant = mgr->GetConstant(type, words); return mgr->GetDefiningInstruction( constant, context()->get_type_mgr()->GetTypeInstruction(type)); } opt::Instruction* opt::GraphicsRobustAccessPass::WidenInteger( bool sign_extend, uint32_t bit_width, Instruction* value, Instruction* before_inst) { analysis::Integer unsigned_type_for_query(bit_width, false); auto* type_mgr = context()->get_type_mgr(); auto* unsigned_type = type_mgr->GetRegisteredType(&unsigned_type_for_query); auto type_id = context()->get_type_mgr()->GetId(unsigned_type); auto conversion_id = TakeNextId(); auto* conversion = InsertInst( before_inst, (sign_extend ? spv::Op::OpSConvert : spv::Op::OpUConvert), type_id, conversion_id, {{SPV_OPERAND_TYPE_ID, {value->result_id()}}}); return conversion; } Instruction* GraphicsRobustAccessPass::MakeUMinInst( const analysis::TypeManager& tm, Instruction* x, Instruction* y, Instruction* where) { // Get IDs of instructions we'll be referencing. Evaluate them before calling // the function so we force a deterministic ordering in case both of them need // to take a new ID. const uint32_t glsl_insts_id = GetGlslInsts(); uint32_t smin_id = TakeNextId(); const auto xwidth = tm.GetType(x->type_id())->AsInteger()->width(); const auto ywidth = tm.GetType(y->type_id())->AsInteger()->width(); assert(xwidth == ywidth); (void)xwidth; (void)ywidth; auto* smin_inst = InsertInst( where, spv::Op::OpExtInst, x->type_id(), smin_id, { {SPV_OPERAND_TYPE_ID, {glsl_insts_id}}, {SPV_OPERAND_TYPE_EXTENSION_INSTRUCTION_NUMBER, {GLSLstd450UMin}}, {SPV_OPERAND_TYPE_ID, {x->result_id()}}, {SPV_OPERAND_TYPE_ID, {y->result_id()}}, }); return smin_inst; } Instruction* GraphicsRobustAccessPass::MakeSClampInst( const analysis::TypeManager& tm, Instruction* x, Instruction* min, Instruction* max, Instruction* where) { // Get IDs of instructions we'll be referencing. Evaluate them before calling // the function so we force a deterministic ordering in case both of them need // to take a new ID. const uint32_t glsl_insts_id = GetGlslInsts(); uint32_t clamp_id = TakeNextId(); const auto xwidth = tm.GetType(x->type_id())->AsInteger()->width(); const auto minwidth = tm.GetType(min->type_id())->AsInteger()->width(); const auto maxwidth = tm.GetType(max->type_id())->AsInteger()->width(); assert(xwidth == minwidth); assert(xwidth == maxwidth); (void)xwidth; (void)minwidth; (void)maxwidth; auto* clamp_inst = InsertInst( where, spv::Op::OpExtInst, x->type_id(), clamp_id, { {SPV_OPERAND_TYPE_ID, {glsl_insts_id}}, {SPV_OPERAND_TYPE_EXTENSION_INSTRUCTION_NUMBER, {GLSLstd450SClamp}}, {SPV_OPERAND_TYPE_ID, {x->result_id()}}, {SPV_OPERAND_TYPE_ID, {min->result_id()}}, {SPV_OPERAND_TYPE_ID, {max->result_id()}}, }); return clamp_inst; } Instruction* GraphicsRobustAccessPass::MakeRuntimeArrayLengthInst( Instruction* access_chain, uint32_t operand_index) { // The Index parameter to the access chain at |operand_index| is indexing // *into* the runtime-array. To get the number of elements in the runtime // array we need a pointer to the Block-decorated struct that contains the // runtime array. So conceptually we have to go 2 steps backward in the // access chain. The two steps backward might forces us to traverse backward // across multiple dominating instructions. auto* type_mgr = context()->get_type_mgr(); // How many access chain indices do we have to unwind to find the pointer // to the struct containing the runtime array? uint32_t steps_remaining = 2; // Find or create an instruction computing the pointer to the structure // containing the runtime array. // Walk backward through pointer address calculations until we either get // to exactly the right base pointer, or to an access chain instruction // that we can replicate but truncate to compute the address of the right // struct. Instruction* current_access_chain = access_chain; Instruction* pointer_to_containing_struct = nullptr; while (steps_remaining > 0) { switch (current_access_chain->opcode()) { case spv::Op::OpCopyObject: // Whoops. Walk right through this one. current_access_chain = GetDef(current_access_chain->GetSingleWordInOperand(0)); break; case spv::Op::OpAccessChain: case spv::Op::OpInBoundsAccessChain: { const int first_index_operand = 3; // How many indices in this access chain contribute to getting us // to an element in the runtime array? const auto num_contributing_indices = current_access_chain == access_chain ? operand_index - (first_index_operand - 1) : current_access_chain->NumInOperands() - 1 /* skip the base */; Instruction* base = GetDef(current_access_chain->GetSingleWordInOperand(0)); if (num_contributing_indices == steps_remaining) { // The base pointer points to the structure. pointer_to_containing_struct = base; steps_remaining = 0; break; } else if (num_contributing_indices < steps_remaining) { // Peel off the index and keep going backward. steps_remaining -= num_contributing_indices; current_access_chain = base; } else { // This access chain has more indices than needed. Generate a new // access chain instruction, but truncating the list of indices. const int base_operand = 2; // We'll use the base pointer and the indices up to but not including // the one indexing into the runtime array. Instruction::OperandList ops; // Use the base pointer ops.push_back(current_access_chain->GetOperand(base_operand)); const uint32_t num_indices_to_keep = num_contributing_indices - steps_remaining - 1; for (uint32_t i = 0; i <= num_indices_to_keep; i++) { ops.push_back( current_access_chain->GetOperand(first_index_operand + i)); } // Compute the type of the result of the new access chain. Start at // the base and walk the indices in a forward direction. auto* constant_mgr = context()->get_constant_mgr(); std::vector indices_for_type; for (uint32_t i = 0; i < ops.size() - 1; i++) { uint32_t index_for_type_calculation = 0; Instruction* index = GetDef(current_access_chain->GetSingleWordOperand( first_index_operand + i)); if (auto* index_constant = constant_mgr->GetConstantFromInst(index)) { // We only need 32 bits. For the type calculation, it's sufficient // to take the zero-extended value. It only matters for the struct // case, and struct member indices are unsigned. index_for_type_calculation = uint32_t(index_constant->GetZeroExtendedValue()); } else { // Indexing into a variably-sized thing like an array. Use 0. index_for_type_calculation = 0; } indices_for_type.push_back(index_for_type_calculation); } auto* base_ptr_type = type_mgr->GetType(base->type_id())->AsPointer(); auto* base_pointee_type = base_ptr_type->pointee_type(); auto* new_access_chain_result_pointee_type = type_mgr->GetMemberType(base_pointee_type, indices_for_type); const uint32_t new_access_chain_type_id = type_mgr->FindPointerToType( type_mgr->GetId(new_access_chain_result_pointee_type), base_ptr_type->storage_class()); // Create the instruction and insert it. const auto new_access_chain_id = TakeNextId(); auto* new_access_chain = InsertInst(current_access_chain, current_access_chain->opcode(), new_access_chain_type_id, new_access_chain_id, ops); pointer_to_containing_struct = new_access_chain; steps_remaining = 0; break; } } break; default: Fail() << "Unhandled access chain in logical addressing mode passes " "through " << current_access_chain->PrettyPrint( SPV_BINARY_TO_TEXT_OPTION_SHOW_BYTE_OFFSET | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); return nullptr; } } assert(pointer_to_containing_struct); auto* pointee_type = type_mgr->GetType(pointer_to_containing_struct->type_id()) ->AsPointer() ->pointee_type(); auto* struct_type = pointee_type->AsStruct(); const uint32_t member_index_of_runtime_array = uint32_t(struct_type->element_types().size() - 1); // Create the length-of-array instruction before the original access chain, // but after the generation of the pointer to the struct. const auto array_len_id = TakeNextId(); analysis::Integer uint_type_for_query(32, false); auto* uint_type = type_mgr->GetRegisteredType(&uint_type_for_query); auto* array_len = InsertInst( access_chain, spv::Op::OpArrayLength, type_mgr->GetId(uint_type), array_len_id, {{SPV_OPERAND_TYPE_ID, {pointer_to_containing_struct->result_id()}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {member_index_of_runtime_array}}}); return array_len; } spv_result_t GraphicsRobustAccessPass::ClampCoordinateForImageTexelPointer( opt::Instruction* image_texel_pointer) { // TODO(dneto): Write tests for this code. // TODO(dneto): Use signed-clamp (void)(image_texel_pointer); return SPV_SUCCESS; // Do not compile this code until it is ready to be used. #if 0 // Example: // %texel_ptr = OpImageTexelPointer %texel_ptr_type %image_ptr %coord // %sample // // We want to clamp %coord components between vector-0 and the result // of OpImageQuerySize acting on the underlying image. So insert: // %image = OpLoad %image_type %image_ptr // %query_size = OpImageQuerySize %query_size_type %image // // For a multi-sampled image, %sample is the sample index, and we need // to clamp it between zero and the number of samples in the image. // %sample_count = OpImageQuerySamples %uint %image // %max_sample_index = OpISub %uint %sample_count %uint_1 // For non-multi-sampled images, the sample index must be constant zero. auto* def_use_mgr = context()->get_def_use_mgr(); auto* type_mgr = context()->get_type_mgr(); auto* constant_mgr = context()->get_constant_mgr(); auto* image_ptr = GetDef(image_texel_pointer->GetSingleWordInOperand(0)); auto* image_ptr_type = GetDef(image_ptr->type_id()); auto image_type_id = image_ptr_type->GetSingleWordInOperand(1); auto* image_type = GetDef(image_type_id); auto* coord = GetDef(image_texel_pointer->GetSingleWordInOperand(1)); auto* samples = GetDef(image_texel_pointer->GetSingleWordInOperand(2)); // We will modify the module, at least by adding image query instructions. module_status_.modified = true; // Declare the ImageQuery capability if the module doesn't already have it. auto* feature_mgr = context()->get_feature_mgr(); if (!feature_mgr->HasCapability(spv::Capability::ImageQuery)) { auto cap = MakeUnique( context(), spv::Op::OpCapability, 0, 0, std::initializer_list{ {SPV_OPERAND_TYPE_CAPABILITY, {spv::Capability::ImageQuery}}}); def_use_mgr->AnalyzeInstDefUse(cap.get()); context()->AddCapability(std::move(cap)); feature_mgr->Analyze(context()->module()); } // OpImageTexelPointer is used to translate a coordinate and sample index // into an address for use with an atomic operation. That is, it may only // used with what Vulkan calls a "storage image" // (OpTypeImage parameter Sampled=2). // Note: A storage image never has a level-of-detail associated with it. // Constraints on the sample id: // - Only 2D images can be multi-sampled: OpTypeImage parameter MS=1 // only if Dim=2D. // - Non-multi-sampled images (OpTypeImage parameter MS=0) must use // sample ID to a constant 0. // The coordinate is treated as unsigned, and should be clamped against the // image "size", returned by OpImageQuerySize. (Note: OpImageQuerySizeLod // is only usable with a sampled image, i.e. its image type has Sampled=1). // Determine the result type for the OpImageQuerySize. // For non-arrayed images: // non-Cube: // - Always the same as the coordinate type // Cube: // - Use all but the last component of the coordinate (which is the face // index from 0 to 5). // For arrayed images (in Vulkan the Dim is 1D, 2D, or Cube): // non-Cube: // - A vector with the components in the coordinate, and one more for // the layer index. // Cube: // - The same as the coordinate type: 3-element integer vector. // - The third component from the size query is the layer count. // - The third component in the texel pointer calculation is // 6 * layer + face, where 0 <= face < 6. // Cube: Use all but the last component of the coordinate (which is the face // index from 0 to 5). const auto dim = SpvDim(image_type->GetSingleWordInOperand(1)); const bool arrayed = image_type->GetSingleWordInOperand(3) == 1; const bool multisampled = image_type->GetSingleWordInOperand(4) != 0; const auto query_num_components = [dim, arrayed, this]() -> int { const int arrayness_bonus = arrayed ? 1 : 0; int num_coords = 0; switch (dim) { case spv::Dim::Buffer: case SpvDim1D: num_coords = 1; break; case spv::Dim::Cube: // For cube, we need bounds for x, y, but not face. case spv::Dim::Rect: case SpvDim2D: num_coords = 2; break; case SpvDim3D: num_coords = 3; break; case spv::Dim::SubpassData: case spv::Dim::Max: return Fail() << "Invalid image dimension for OpImageTexelPointer: " << int(dim); break; } return num_coords + arrayness_bonus; }(); const auto* coord_component_type = [type_mgr, coord]() { const analysis::Type* coord_type = type_mgr->GetType(coord->type_id()); if (auto* vector_type = coord_type->AsVector()) { return vector_type->element_type()->AsInteger(); } return coord_type->AsInteger(); }(); // For now, only handle 32-bit case for coordinates. if (!coord_component_type) { return Fail() << " Coordinates for OpImageTexelPointer are not integral: " << image_texel_pointer->PrettyPrint( SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); } if (coord_component_type->width() != 32) { return Fail() << " Expected OpImageTexelPointer coordinate components to " "be 32-bits wide. They are " << coord_component_type->width() << " bits. " << image_texel_pointer->PrettyPrint( SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); } const auto* query_size_type = [type_mgr, coord_component_type, query_num_components]() -> const analysis::Type* { if (query_num_components == 1) return coord_component_type; analysis::Vector proposed(coord_component_type, query_num_components); return type_mgr->GetRegisteredType(&proposed); }(); const uint32_t image_id = TakeNextId(); auto* image = InsertInst(image_texel_pointer, spv::Op::OpLoad, image_type_id, image_id, {{SPV_OPERAND_TYPE_ID, {image_ptr->result_id()}}}); const uint32_t query_size_id = TakeNextId(); auto* query_size = InsertInst(image_texel_pointer, spv::Op::OpImageQuerySize, type_mgr->GetTypeInstruction(query_size_type), query_size_id, {{SPV_OPERAND_TYPE_ID, {image->result_id()}}}); auto* component_1 = constant_mgr->GetConstant(coord_component_type, {1}); const uint32_t component_1_id = constant_mgr->GetDefiningInstruction(component_1)->result_id(); auto* component_0 = constant_mgr->GetConstant(coord_component_type, {0}); const uint32_t component_0_id = constant_mgr->GetDefiningInstruction(component_0)->result_id(); // If the image is a cube array, then the last component of the queried // size is the layer count. In the query, we have to accommodate folding // in the face index ranging from 0 through 5. The inclusive upper bound // on the third coordinate therefore is multiplied by 6. auto* query_size_including_faces = query_size; if (arrayed && (dim == spv::Dim::Cube)) { // Multiply the last coordinate by 6. auto* component_6 = constant_mgr->GetConstant(coord_component_type, {6}); const uint32_t component_6_id = constant_mgr->GetDefiningInstruction(component_6)->result_id(); assert(query_num_components == 3); auto* multiplicand = constant_mgr->GetConstant( query_size_type, {component_1_id, component_1_id, component_6_id}); auto* multiplicand_inst = constant_mgr->GetDefiningInstruction(multiplicand); const auto query_size_including_faces_id = TakeNextId(); query_size_including_faces = InsertInst( image_texel_pointer, spv::Op::OpIMul, type_mgr->GetTypeInstruction(query_size_type), query_size_including_faces_id, {{SPV_OPERAND_TYPE_ID, {query_size_including_faces->result_id()}}, {SPV_OPERAND_TYPE_ID, {multiplicand_inst->result_id()}}}); } // Make a coordinate-type with all 1 components. auto* coordinate_1 = query_num_components == 1 ? component_1 : constant_mgr->GetConstant( query_size_type, std::vector(query_num_components, component_1_id)); // Make a coordinate-type with all 1 components. auto* coordinate_0 = query_num_components == 0 ? component_0 : constant_mgr->GetConstant( query_size_type, std::vector(query_num_components, component_0_id)); const uint32_t query_max_including_faces_id = TakeNextId(); auto* query_max_including_faces = InsertInst( image_texel_pointer, spv::Op::OpISub, type_mgr->GetTypeInstruction(query_size_type), query_max_including_faces_id, {{SPV_OPERAND_TYPE_ID, {query_size_including_faces->result_id()}}, {SPV_OPERAND_TYPE_ID, {constant_mgr->GetDefiningInstruction(coordinate_1)->result_id()}}}); // Clamp the coordinate auto* clamp_coord = MakeSClampInst( *type_mgr, coord, constant_mgr->GetDefiningInstruction(coordinate_0), query_max_including_faces, image_texel_pointer); image_texel_pointer->SetInOperand(1, {clamp_coord->result_id()}); // Clamp the sample index if (multisampled) { // Get the sample count via OpImageQuerySamples const auto query_samples_id = TakeNextId(); auto* query_samples = InsertInst( image_texel_pointer, spv::Op::OpImageQuerySamples, constant_mgr->GetDefiningInstruction(component_0)->type_id(), query_samples_id, {{SPV_OPERAND_TYPE_ID, {image->result_id()}}}); const auto max_samples_id = TakeNextId(); auto* max_samples = InsertInst(image_texel_pointer, spv::Op::OpImageQuerySamples, query_samples->type_id(), max_samples_id, {{SPV_OPERAND_TYPE_ID, {query_samples_id}}, {SPV_OPERAND_TYPE_ID, {component_1_id}}}); auto* clamp_samples = MakeSClampInst( *type_mgr, samples, constant_mgr->GetDefiningInstruction(coordinate_0), max_samples, image_texel_pointer); image_texel_pointer->SetInOperand(2, {clamp_samples->result_id()}); } else { // Just replace it with 0. Don't even check what was there before. image_texel_pointer->SetInOperand(2, {component_0_id}); } def_use_mgr->AnalyzeInstUse(image_texel_pointer); return SPV_SUCCESS; #endif } opt::Instruction* GraphicsRobustAccessPass::InsertInst( opt::Instruction* where_inst, spv::Op opcode, uint32_t type_id, uint32_t result_id, const Instruction::OperandList& operands) { module_status_.modified = true; auto* result = where_inst->InsertBefore( MakeUnique(context(), opcode, type_id, result_id, operands)); context()->get_def_use_mgr()->AnalyzeInstDefUse(result); auto* basic_block = context()->get_instr_block(where_inst); context()->set_instr_block(result, basic_block); return result; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/graphics_robust_access_pass.h000066400000000000000000000152621475742701700265570ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_GRAPHICS_ROBUST_ACCESS_PASS_H_ #define SOURCE_OPT_GRAPHICS_ROBUST_ACCESS_PASS_H_ #include #include #include "constants.h" #include "def_use_manager.h" #include "instruction.h" #include "module.h" #include "pass.h" #include "source/diagnostic.h" #include "type_manager.h" namespace spvtools { namespace opt { // See optimizer.hpp for documentation. class GraphicsRobustAccessPass : public Pass { public: GraphicsRobustAccessPass(); const char* name() const override { return "graphics-robust-access"; } Status Process() override; IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisConstants | IRContext::kAnalysisTypes | IRContext::kAnalysisIdToFuncMapping; } private: // Records failure for the current module, and returns a stream // that can be used to provide user error information to the message // consumer. spvtools::DiagnosticStream Fail(); // Returns SPV_SUCCESS if this pass can correctly process the module, // as far as we can tell from capabilities and the memory model. // Otherwise logs a message and returns a failure code. spv_result_t IsCompatibleModule(); // Transform the current module, if possible. Failure and modification // status is recorded in the |_| member. On failure, error information is // posted to the message consumer. The return value has no significance. spv_result_t ProcessCurrentModule(); // Process the given function. Updates the state value |_|. Returns true // if the module was modified. This can log a failure. bool ProcessAFunction(opt::Function*); // Clamps indices in the OpAccessChain or OpInBoundsAccessChain instruction // |access_chain|. Inserts instructions before the given instruction. Updates // analyses and records that the module is modified. This can log a failure. void ClampIndicesForAccessChain(Instruction* access_chain); // Returns the id of the instruction importing the "GLSL.std.450" extended // instruction set. If it does not yet exist, the import instruction is // created and inserted into the module, and updates |_.modified| and // |_.glsl_insts_id|. uint32_t GetGlslInsts(); // Returns an instruction which is constant with the given value of the given // type. Ignores any value bits beyond the width of the type. Instruction* GetValueForType(uint64_t value, const analysis::Integer* type); // Converts an integer value to an unsigned wider integer type, using either // sign extension or zero extension. The new instruction is inserted // immediately before |before_inst|, and is analyzed for definitions and uses. // Returns the newly inserted instruction. Assumes the |value| is an integer // scalar of a narrower type than |bit_width| bits. Instruction* WidenInteger(bool sign_extend, uint32_t bit_width, Instruction* value, Instruction* before_inst); // Returns a new instruction that invokes the UMin GLSL.std.450 extended // instruction with the two given operands. That is, the result of the // instruction is: // - |x| if |x| is unsigned-less than |y| // - |y| otherwise // We assume that |x| and |y| are scalar integer types with the same // width. The instruction is inserted before |where|. opt::Instruction* MakeUMinInst(const analysis::TypeManager& tm, Instruction* x, Instruction* y, Instruction* where); // Returns a new instruction that invokes the SClamp GLSL.std.450 extended // instruction with the three given operands. That is, the result of the // instruction is: // - |min| if |x| is signed-less than |min| // - |max| if |x| is signed-more than |max| // - |x| otherwise. // We assume that |min| is signed-less-or-equal to |max|, and that the // operands all have the same scalar integer type. The instruction is // inserted before |where|. opt::Instruction* MakeSClampInst(const analysis::TypeManager& tm, Instruction* x, Instruction* min, Instruction* max, Instruction* where); // Returns a new instruction which evaluates to the length the runtime array // referenced by the access chain at the specified index. The instruction is // inserted before the access chain instruction. Returns a null pointer in // some cases if assumptions are violated (rather than asserting out). opt::Instruction* MakeRuntimeArrayLengthInst(Instruction* access_chain, uint32_t operand_index); // Clamps the coordinate for an OpImageTexelPointer so it stays within // the bounds of the size of the image. Updates analyses and records that // the module is modified. Returns a status code to indicate success // or failure. If assumptions are not met, returns an error status code // and emits a diagnostic. spv_result_t ClampCoordinateForImageTexelPointer( opt::Instruction* image_texel_pointer); // Gets the instruction that defines the given id. opt::Instruction* GetDef(uint32_t id) { return context()->get_def_use_mgr()->GetDef(id); } // Returns a new instruction inserted before |where_inst|, and created from // the remaining arguments. Registers the definitions and uses of the new // instruction and also records its block. opt::Instruction* InsertInst(opt::Instruction* where_inst, spv::Op opcode, uint32_t type_id, uint32_t result_id, const Instruction::OperandList& operands); // State required for the current module. struct PerModuleState { // This pass modified the module. bool modified = false; // True if there is an error processing the current module, e.g. if // preconditions are not met. bool failed = false; // The id of the GLSL.std.450 extended instruction set. Zero if it does // not exist. uint32_t glsl_insts_id = 0; } module_status_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_GRAPHICS_ROBUST_ACCESS_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/if_conversion.cpp000066400000000000000000000266321475742701700242130ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/if_conversion.h" #include #include #include "source/opt/value_number_table.h" namespace spvtools { namespace opt { Pass::Status IfConversion::Process() { if (!context()->get_feature_mgr()->HasCapability(spv::Capability::Shader)) { return Status::SuccessWithoutChange; } const ValueNumberTable& vn_table = *context()->GetValueNumberTable(); bool modified = false; std::vector to_kill; for (auto& func : *get_module()) { DominatorAnalysis* dominators = context()->GetDominatorAnalysis(&func); for (auto& block : func) { // Check if it is possible for |block| to have phis that can be // transformed. BasicBlock* common = nullptr; if (!CheckBlock(&block, dominators, &common)) continue; // Get an insertion point. auto iter = block.begin(); while (iter != block.end() && iter->opcode() == spv::Op::OpPhi) { ++iter; } InstructionBuilder builder( context(), &*iter, IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); block.ForEachPhiInst([this, &builder, &modified, &common, &to_kill, dominators, &block, &vn_table](Instruction* phi) { // This phi is not compatible, but subsequent phis might be. if (!CheckType(phi->type_id())) return; // We cannot transform cases where the phi is used by another phi in the // same block due to instruction ordering restrictions. // TODO(alan-baker): If all inappropriate uses could also be // transformed, we could still remove this phi. if (!CheckPhiUsers(phi, &block)) return; // Identify the incoming values associated with the true and false // branches. If |then_block| dominates |inc0| or if the true edge // branches straight to this block and |common| is |inc0|, then |inc0| // is on the true branch. Otherwise the |inc1| is on the true branch. BasicBlock* inc0 = GetIncomingBlock(phi, 0u); Instruction* branch = common->terminator(); uint32_t condition = branch->GetSingleWordInOperand(0u); BasicBlock* then_block = GetBlock(branch->GetSingleWordInOperand(1u)); Instruction* true_value = nullptr; Instruction* false_value = nullptr; if ((then_block == &block && inc0 == common) || dominators->Dominates(then_block, inc0)) { true_value = GetIncomingValue(phi, 0u); false_value = GetIncomingValue(phi, 1u); } else { true_value = GetIncomingValue(phi, 1u); false_value = GetIncomingValue(phi, 0u); } BasicBlock* true_def_block = context()->get_instr_block(true_value); BasicBlock* false_def_block = context()->get_instr_block(false_value); uint32_t true_vn = vn_table.GetValueNumber(true_value); uint32_t false_vn = vn_table.GetValueNumber(false_value); if (true_vn != 0 && true_vn == false_vn) { Instruction* inst_to_use = nullptr; // Try to pick an instruction that is not in a side node. If we can't // pick either the true for false branch as long as they can be // legally moved. if (!true_def_block || dominators->Dominates(true_def_block, &block)) { inst_to_use = true_value; } else if (!false_def_block || dominators->Dominates(false_def_block, &block)) { inst_to_use = false_value; } else if (CanHoistInstruction(true_value, common, dominators)) { inst_to_use = true_value; } else if (CanHoistInstruction(false_value, common, dominators)) { inst_to_use = false_value; } if (inst_to_use != nullptr) { modified = true; HoistInstruction(inst_to_use, common, dominators); context()->KillNamesAndDecorates(phi); context()->ReplaceAllUsesWith(phi->result_id(), inst_to_use->result_id()); } return; } // If either incoming value is defined in a block that does not dominate // this phi, then we cannot eliminate the phi with a select. // TODO(alan-baker): Perform code motion where it makes sense to enable // the transform in this case. if (true_def_block && !dominators->Dominates(true_def_block, &block)) return; if (false_def_block && !dominators->Dominates(false_def_block, &block)) return; analysis::Type* data_ty = context()->get_type_mgr()->GetType(true_value->type_id()); if (analysis::Vector* vec_data_ty = data_ty->AsVector()) { condition = SplatCondition(vec_data_ty, condition, &builder); } Instruction* select = builder.AddSelect(phi->type_id(), condition, true_value->result_id(), false_value->result_id()); context()->get_def_use_mgr()->AnalyzeInstDefUse(select); select->UpdateDebugInfoFrom(phi); context()->ReplaceAllUsesWith(phi->result_id(), select->result_id()); to_kill.push_back(phi); modified = true; return; }); } } for (auto inst : to_kill) { context()->KillInst(inst); } return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } bool IfConversion::CheckBlock(BasicBlock* block, DominatorAnalysis* dominators, BasicBlock** common) { const std::vector& preds = cfg()->preds(block->id()); // TODO(alan-baker): Extend to more than two predecessors if (preds.size() != 2) return false; BasicBlock* inc0 = context()->get_instr_block(preds[0]); if (dominators->Dominates(block, inc0)) return false; BasicBlock* inc1 = context()->get_instr_block(preds[1]); if (dominators->Dominates(block, inc1)) return false; if (inc0 == inc1) { // If the predecessor blocks are the same, then there is only 1 value for // the OpPhi. Other transformation should be able to simplify that. return false; } // All phis will have the same common dominator, so cache the result // for this block. If there is no common dominator, then we cannot transform // any phi in this basic block. *common = dominators->CommonDominator(inc0, inc1); if (!*common || cfg()->IsPseudoEntryBlock(*common)) return false; Instruction* branch = (*common)->terminator(); if (branch->opcode() != spv::Op::OpBranchConditional) return false; auto merge = (*common)->GetMergeInst(); if (!merge || merge->opcode() != spv::Op::OpSelectionMerge) return false; if (spv::SelectionControlMask(merge->GetSingleWordInOperand(1)) == spv::SelectionControlMask::DontFlatten) { return false; } if ((*common)->MergeBlockIdIfAny() != block->id()) return false; return true; } bool IfConversion::CheckPhiUsers(Instruction* phi, BasicBlock* block) { return get_def_use_mgr()->WhileEachUser( phi, [block, this](Instruction* user) { if (user->opcode() == spv::Op::OpPhi && context()->get_instr_block(user) == block) return false; return true; }); } uint32_t IfConversion::SplatCondition(analysis::Vector* vec_data_ty, uint32_t cond, InstructionBuilder* builder) { // If the data inputs to OpSelect are vectors, the condition for // OpSelect must be a boolean vector with the same number of // components. So splat the condition for the branch into a vector // type. analysis::Bool bool_ty; analysis::Vector bool_vec_ty(&bool_ty, vec_data_ty->element_count()); uint32_t bool_vec_id = context()->get_type_mgr()->GetTypeInstruction(&bool_vec_ty); std::vector ids(vec_data_ty->element_count(), cond); return builder->AddCompositeConstruct(bool_vec_id, ids)->result_id(); } bool IfConversion::CheckType(uint32_t id) { Instruction* type = get_def_use_mgr()->GetDef(id); spv::Op op = type->opcode(); if (spvOpcodeIsScalarType(op) || op == spv::Op::OpTypePointer || op == spv::Op::OpTypeVector) return true; return false; } BasicBlock* IfConversion::GetBlock(uint32_t id) { return context()->get_instr_block(get_def_use_mgr()->GetDef(id)); } BasicBlock* IfConversion::GetIncomingBlock(Instruction* phi, uint32_t predecessor) { uint32_t in_index = 2 * predecessor + 1; return GetBlock(phi->GetSingleWordInOperand(in_index)); } Instruction* IfConversion::GetIncomingValue(Instruction* phi, uint32_t predecessor) { uint32_t in_index = 2 * predecessor; return get_def_use_mgr()->GetDef(phi->GetSingleWordInOperand(in_index)); } void IfConversion::HoistInstruction(Instruction* inst, BasicBlock* target_block, DominatorAnalysis* dominators) { BasicBlock* inst_block = context()->get_instr_block(inst); if (!inst_block) { // This is in the header, and dominates everything. return; } if (dominators->Dominates(inst_block, target_block)) { // Already in position. No work to do. return; } assert(inst->IsOpcodeCodeMotionSafe() && "Trying to move an instruction that is not safe to move."); // First hoist all instructions it depends on. analysis::DefUseManager* def_use_mgr = context()->get_def_use_mgr(); inst->ForEachInId( [this, target_block, def_use_mgr, dominators](uint32_t* id) { Instruction* operand_inst = def_use_mgr->GetDef(*id); HoistInstruction(operand_inst, target_block, dominators); }); Instruction* insertion_pos = target_block->terminator(); if ((insertion_pos)->PreviousNode()->opcode() == spv::Op::OpSelectionMerge) { insertion_pos = insertion_pos->PreviousNode(); } inst->RemoveFromList(); insertion_pos->InsertBefore(std::unique_ptr(inst)); context()->set_instr_block(inst, target_block); } bool IfConversion::CanHoistInstruction(Instruction* inst, BasicBlock* target_block, DominatorAnalysis* dominators) { BasicBlock* inst_block = context()->get_instr_block(inst); if (!inst_block) { // This is in the header, and dominates everything. return true; } if (dominators->Dominates(inst_block, target_block)) { // Already in position. No work to do. return true; } if (!inst->IsOpcodeCodeMotionSafe()) { return false; } // Check all instruction |inst| depends on. analysis::DefUseManager* def_use_mgr = context()->get_def_use_mgr(); return inst->WhileEachInId( [this, target_block, def_use_mgr, dominators](uint32_t* id) { Instruction* operand_inst = def_use_mgr->GetDef(*id); return CanHoistInstruction(operand_inst, target_block, dominators); }); } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/if_conversion.h000066400000000000000000000072411475742701700236530ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_IF_CONVERSION_H_ #define SOURCE_OPT_IF_CONVERSION_H_ #include "source/opt/basic_block.h" #include "source/opt/ir_builder.h" #include "source/opt/pass.h" #include "source/opt/types.h" namespace spvtools { namespace opt { // See optimizer.hpp for documentation. class IfConversion : public Pass { public: const char* name() const override { return "if-conversion"; } Status Process() override; IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisDefUse | IRContext::kAnalysisDominatorAnalysis | IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisCFG | IRContext::kAnalysisNameMap | IRContext::kAnalysisConstants | IRContext::kAnalysisTypes; } private: // Returns true if |id| is a valid type for use with OpSelect. OpSelect only // allows scalars, vectors and pointers as valid inputs. bool CheckType(uint32_t id); // Returns the basic block containing |id|. BasicBlock* GetBlock(uint32_t id); // Returns the basic block for the |predecessor|'th index predecessor of // |phi|. BasicBlock* GetIncomingBlock(Instruction* phi, uint32_t predecessor); // Returns the instruction defining the |predecessor|'th index of |phi|. Instruction* GetIncomingValue(Instruction* phi, uint32_t predecessor); // Returns the id of a OpCompositeConstruct boolean vector. The composite has // the same number of elements as |vec_data_ty| and each member is |cond|. // |where| indicates the location in |block| to insert the composite // construct. If necessary, this function will also construct the necessary // type instructions for the boolean vector. uint32_t SplatCondition(analysis::Vector* vec_data_ty, uint32_t cond, InstructionBuilder* builder); // Returns true if none of |phi|'s users are in |block|. bool CheckPhiUsers(Instruction* phi, BasicBlock* block); // Returns |false| if |block| is not appropriate to transform. Only // transforms blocks with two predecessors. Neither incoming block can be // dominated by |block|. Both predecessors must share a common dominator that // is terminated by a conditional branch. bool CheckBlock(BasicBlock* block, DominatorAnalysis* dominators, BasicBlock** common); // Moves |inst| to |target_block| if it does not already dominate the block. // Any instructions that |inst| depends on are move if necessary. It is // assumed that |inst| can be hoisted to |target_block| as defined by // |CanHoistInstruction|. |dominators| is the dominator analysis for the // function that contains |target_block|. void HoistInstruction(Instruction* inst, BasicBlock* target_block, DominatorAnalysis* dominators); // Returns true if it is legal to move |inst| and the instructions it depends // on to |target_block| if they do not already dominate |target_block|. bool CanHoistInstruction(Instruction* inst, BasicBlock* target_block, DominatorAnalysis* dominators); }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_IF_CONVERSION_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/inline_exhaustive_pass.cpp000066400000000000000000000052661475742701700261210ustar00rootroot00000000000000// Copyright (c) 2017 The Khronos Group Inc. // Copyright (c) 2017 Valve Corporation // Copyright (c) 2017 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/inline_exhaustive_pass.h" #include namespace spvtools { namespace opt { Pass::Status InlineExhaustivePass::InlineExhaustive(Function* func) { bool modified = false; // Using block iterators here because of block erasures and insertions. for (auto bi = func->begin(); bi != func->end(); ++bi) { for (auto ii = bi->begin(); ii != bi->end();) { if (IsInlinableFunctionCall(&*ii)) { // Inline call. std::vector> newBlocks; std::vector> newVars; if (!GenInlineCode(&newBlocks, &newVars, ii, bi)) { return Status::Failure; } // If call block is replaced with more than one block, point // succeeding phis at new last block. if (newBlocks.size() > 1) UpdateSucceedingPhis(newBlocks); // Replace old calling block with new block(s). bi = bi.Erase(); for (auto& bb : newBlocks) { bb->SetParent(func); } bi = bi.InsertBefore(&newBlocks); // Insert new function variables. if (newVars.size() > 0) func->begin()->begin().InsertBefore(std::move(newVars)); // Restart inlining at beginning of calling block. ii = bi->begin(); modified = true; } else { ++ii; } } } if (modified) { FixDebugDeclares(func); } return (modified ? Status::SuccessWithChange : Status::SuccessWithoutChange); } Pass::Status InlineExhaustivePass::ProcessImpl() { Status status = Status::SuccessWithoutChange; // Attempt exhaustive inlining on each entry point function in module ProcessFunction pfn = [&status, this](Function* fp) { status = CombineStatus(status, InlineExhaustive(fp)); return false; }; context()->ProcessReachableCallTree(pfn); return status; } InlineExhaustivePass::InlineExhaustivePass() = default; Pass::Status InlineExhaustivePass::Process() { InitializeInline(); return ProcessImpl(); } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/inline_exhaustive_pass.h000066400000000000000000000030541475742701700255570ustar00rootroot00000000000000// Copyright (c) 2017 The Khronos Group Inc. // Copyright (c) 2017 Valve Corporation // Copyright (c) 2017 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_INLINE_EXHAUSTIVE_PASS_H_ #define SOURCE_OPT_INLINE_EXHAUSTIVE_PASS_H_ #include #include #include #include #include #include "source/opt/def_use_manager.h" #include "source/opt/inline_pass.h" #include "source/opt/module.h" namespace spvtools { namespace opt { // See optimizer.hpp for documentation. class InlineExhaustivePass : public InlinePass { public: InlineExhaustivePass(); Status Process() override; const char* name() const override { return "inline-entry-points-exhaustive"; } private: // Exhaustively inline all function calls in func as well as in // all code that is inlined into func. Returns the status. Status InlineExhaustive(Function* func); void Initialize(); Pass::Status ProcessImpl(); }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_INLINE_EXHAUSTIVE_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/inline_opaque_pass.cpp000066400000000000000000000075131475742701700252230ustar00rootroot00000000000000// Copyright (c) 2017 The Khronos Group Inc. // Copyright (c) 2017 Valve Corporation // Copyright (c) 2017 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/inline_opaque_pass.h" #include namespace spvtools { namespace opt { namespace { constexpr uint32_t kTypePointerTypeIdInIdx = 1; } // namespace bool InlineOpaquePass::IsOpaqueType(uint32_t typeId) { const Instruction* typeInst = get_def_use_mgr()->GetDef(typeId); switch (typeInst->opcode()) { case spv::Op::OpTypeSampler: case spv::Op::OpTypeImage: case spv::Op::OpTypeSampledImage: return true; case spv::Op::OpTypePointer: return IsOpaqueType( typeInst->GetSingleWordInOperand(kTypePointerTypeIdInIdx)); default: break; } // TODO(greg-lunarg): Handle arrays containing opaque type if (typeInst->opcode() != spv::Op::OpTypeStruct) return false; // Return true if any member is opaque return !typeInst->WhileEachInId([this](const uint32_t* tid) { if (IsOpaqueType(*tid)) return false; return true; }); } bool InlineOpaquePass::HasOpaqueArgsOrReturn(const Instruction* callInst) { // Check return type if (IsOpaqueType(callInst->type_id())) return true; // Check args int icnt = 0; return !callInst->WhileEachInId([&icnt, this](const uint32_t* iid) { if (icnt > 0) { const Instruction* argInst = get_def_use_mgr()->GetDef(*iid); if (IsOpaqueType(argInst->type_id())) return false; } ++icnt; return true; }); } Pass::Status InlineOpaquePass::InlineOpaque(Function* func) { bool modified = false; // Using block iterators here because of block erasures and insertions. for (auto bi = func->begin(); bi != func->end(); ++bi) { for (auto ii = bi->begin(); ii != bi->end();) { if (IsInlinableFunctionCall(&*ii) && HasOpaqueArgsOrReturn(&*ii)) { // Inline call. std::vector> newBlocks; std::vector> newVars; if (!GenInlineCode(&newBlocks, &newVars, ii, bi)) { return Status::Failure; } // If call block is replaced with more than one block, point // succeeding phis at new last block. if (newBlocks.size() > 1) UpdateSucceedingPhis(newBlocks); // Replace old calling block with new block(s). bi = bi.Erase(); bi = bi.InsertBefore(&newBlocks); // Insert new function variables. if (newVars.size() > 0) func->begin()->begin().InsertBefore(std::move(newVars)); // Restart inlining at beginning of calling block. ii = bi->begin(); modified = true; } else { ++ii; } } } return (modified ? Status::SuccessWithChange : Status::SuccessWithoutChange); } void InlineOpaquePass::Initialize() { InitializeInline(); } Pass::Status InlineOpaquePass::ProcessImpl() { Status status = Status::SuccessWithoutChange; // Do opaque inlining on each function in entry point call tree ProcessFunction pfn = [&status, this](Function* fp) { status = CombineStatus(status, InlineOpaque(fp)); return false; }; context()->ProcessReachableCallTree(pfn); return status; } InlineOpaquePass::InlineOpaquePass() = default; Pass::Status InlineOpaquePass::Process() { Initialize(); return ProcessImpl(); } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/inline_opaque_pass.h000066400000000000000000000034551475742701700246710ustar00rootroot00000000000000// Copyright (c) 2017 The Khronos Group Inc. // Copyright (c) 2017 Valve Corporation // Copyright (c) 2017 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_INLINE_OPAQUE_PASS_H_ #define SOURCE_OPT_INLINE_OPAQUE_PASS_H_ #include #include #include #include #include #include "source/opt/def_use_manager.h" #include "source/opt/inline_pass.h" #include "source/opt/module.h" namespace spvtools { namespace opt { // See optimizer.hpp for documentation. class InlineOpaquePass : public InlinePass { public: InlineOpaquePass(); Status Process() override; const char* name() const override { return "inline-entry-points-opaque"; } private: // Return true if |typeId| is or contains opaque type bool IsOpaqueType(uint32_t typeId); // Return true if function call |callInst| has opaque argument or return type bool HasOpaqueArgsOrReturn(const Instruction* callInst); // Inline all function calls in |func| that have opaque params or return // type. Inline similarly all code that is inlined into func. Return true // if func is modified. Status InlineOpaque(Function* func); void Initialize(); Pass::Status ProcessImpl(); }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_INLINE_OPAQUE_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/inline_pass.cpp000066400000000000000000001050671475742701700236540ustar00rootroot00000000000000// Copyright (c) 2017 The Khronos Group Inc. // Copyright (c) 2017 Valve Corporation // Copyright (c) 2017 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/inline_pass.h" #include #include #include "source/cfa.h" #include "source/opt/reflect.h" #include "source/util/make_unique.h" namespace spvtools { namespace opt { namespace { // Indices of operands in SPIR-V instructions constexpr int kSpvFunctionCallFunctionId = 2; constexpr int kSpvFunctionCallArgumentId = 3; constexpr int kSpvReturnValueId = 0; constexpr int kSpvDebugDeclareVarInIdx = 3; constexpr int kSpvAccessChainBaseInIdx = 0; } // namespace uint32_t InlinePass::AddPointerToType(uint32_t type_id, spv::StorageClass storage_class) { uint32_t resultId = context()->TakeNextId(); if (resultId == 0) { return resultId; } std::unique_ptr type_inst( new Instruction(context(), spv::Op::OpTypePointer, 0, resultId, {{spv_operand_type_t::SPV_OPERAND_TYPE_STORAGE_CLASS, {uint32_t(storage_class)}}, {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {type_id}}})); context()->AddType(std::move(type_inst)); analysis::Type* pointeeTy; std::unique_ptr pointerTy; std::tie(pointeeTy, pointerTy) = context()->get_type_mgr()->GetTypeAndPointerType( type_id, spv::StorageClass::Function); context()->get_type_mgr()->RegisterType(resultId, *pointerTy); return resultId; } void InlinePass::AddBranch(uint32_t label_id, std::unique_ptr* block_ptr) { std::unique_ptr newBranch( new Instruction(context(), spv::Op::OpBranch, 0, 0, {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {label_id}}})); (*block_ptr)->AddInstruction(std::move(newBranch)); } void InlinePass::AddBranchCond(uint32_t cond_id, uint32_t true_id, uint32_t false_id, std::unique_ptr* block_ptr) { std::unique_ptr newBranch( new Instruction(context(), spv::Op::OpBranchConditional, 0, 0, {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {cond_id}}, {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {true_id}}, {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {false_id}}})); (*block_ptr)->AddInstruction(std::move(newBranch)); } void InlinePass::AddLoopMerge(uint32_t merge_id, uint32_t continue_id, std::unique_ptr* block_ptr) { std::unique_ptr newLoopMerge(new Instruction( context(), spv::Op::OpLoopMerge, 0, 0, {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {merge_id}}, {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {continue_id}}, {spv_operand_type_t::SPV_OPERAND_TYPE_LOOP_CONTROL, {0}}})); (*block_ptr)->AddInstruction(std::move(newLoopMerge)); } void InlinePass::AddStore(uint32_t ptr_id, uint32_t val_id, std::unique_ptr* block_ptr, const Instruction* line_inst, const DebugScope& dbg_scope) { std::unique_ptr newStore( new Instruction(context(), spv::Op::OpStore, 0, 0, {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {ptr_id}}, {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {val_id}}})); if (line_inst != nullptr) { newStore->AddDebugLine(line_inst); } newStore->SetDebugScope(dbg_scope); (*block_ptr)->AddInstruction(std::move(newStore)); } void InlinePass::AddLoad(uint32_t type_id, uint32_t resultId, uint32_t ptr_id, std::unique_ptr* block_ptr, const Instruction* line_inst, const DebugScope& dbg_scope) { std::unique_ptr newLoad( new Instruction(context(), spv::Op::OpLoad, type_id, resultId, {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {ptr_id}}})); if (line_inst != nullptr) { newLoad->AddDebugLine(line_inst); } newLoad->SetDebugScope(dbg_scope); (*block_ptr)->AddInstruction(std::move(newLoad)); } std::unique_ptr InlinePass::NewLabel(uint32_t label_id) { std::unique_ptr newLabel( new Instruction(context(), spv::Op::OpLabel, 0, label_id, {})); return newLabel; } uint32_t InlinePass::GetFalseId() { if (false_id_ != 0) return false_id_; false_id_ = get_module()->GetGlobalValue(spv::Op::OpConstantFalse); if (false_id_ != 0) return false_id_; uint32_t boolId = get_module()->GetGlobalValue(spv::Op::OpTypeBool); if (boolId == 0) { boolId = context()->TakeNextId(); if (boolId == 0) { return 0; } get_module()->AddGlobalValue(spv::Op::OpTypeBool, boolId, 0); } false_id_ = context()->TakeNextId(); if (false_id_ == 0) { return 0; } get_module()->AddGlobalValue(spv::Op::OpConstantFalse, false_id_, boolId); return false_id_; } void InlinePass::MapParams( Function* calleeFn, BasicBlock::iterator call_inst_itr, std::unordered_map* callee2caller) { int param_idx = 0; calleeFn->ForEachParam( [&call_inst_itr, ¶m_idx, &callee2caller](const Instruction* cpi) { const uint32_t pid = cpi->result_id(); (*callee2caller)[pid] = call_inst_itr->GetSingleWordOperand( kSpvFunctionCallArgumentId + param_idx); ++param_idx; }); } bool InlinePass::CloneAndMapLocals( Function* calleeFn, std::vector>* new_vars, std::unordered_map* callee2caller, analysis::DebugInlinedAtContext* inlined_at_ctx) { auto callee_block_itr = calleeFn->begin(); auto callee_var_itr = callee_block_itr->begin(); while (callee_var_itr->opcode() == spv::Op::OpVariable || callee_var_itr->GetCommonDebugOpcode() == CommonDebugInfoDebugDeclare) { if (callee_var_itr->opcode() != spv::Op::OpVariable) { ++callee_var_itr; continue; } std::unique_ptr var_inst(callee_var_itr->Clone(context())); uint32_t newId = context()->TakeNextId(); if (newId == 0) { return false; } get_decoration_mgr()->CloneDecorations(callee_var_itr->result_id(), newId); var_inst->SetResultId(newId); var_inst->UpdateDebugInlinedAt( context()->get_debug_info_mgr()->BuildDebugInlinedAtChain( callee_var_itr->GetDebugInlinedAt(), inlined_at_ctx)); (*callee2caller)[callee_var_itr->result_id()] = newId; new_vars->push_back(std::move(var_inst)); ++callee_var_itr; } return true; } uint32_t InlinePass::CreateReturnVar( Function* calleeFn, std::vector>* new_vars) { uint32_t returnVarId = 0; const uint32_t calleeTypeId = calleeFn->type_id(); analysis::TypeManager* type_mgr = context()->get_type_mgr(); assert(type_mgr->GetType(calleeTypeId)->AsVoid() == nullptr && "Cannot create a return variable of type void."); // Find or create ptr to callee return type. uint32_t returnVarTypeId = type_mgr->FindPointerToType(calleeTypeId, spv::StorageClass::Function); if (returnVarTypeId == 0) { returnVarTypeId = AddPointerToType(calleeTypeId, spv::StorageClass::Function); if (returnVarTypeId == 0) { return 0; } } // Add return var to new function scope variables. returnVarId = context()->TakeNextId(); if (returnVarId == 0) { return 0; } std::unique_ptr var_inst(new Instruction( context(), spv::Op::OpVariable, returnVarTypeId, returnVarId, {{spv_operand_type_t::SPV_OPERAND_TYPE_STORAGE_CLASS, {(uint32_t)spv::StorageClass::Function}}})); new_vars->push_back(std::move(var_inst)); get_decoration_mgr()->CloneDecorations(calleeFn->result_id(), returnVarId); // Decorate the return var with AliasedPointer if the storage class of the // pointee type is PhysicalStorageBuffer. auto const pointee_type = type_mgr->GetType(returnVarTypeId)->AsPointer()->pointee_type(); if (pointee_type->AsPointer() != nullptr) { if (pointee_type->AsPointer()->storage_class() == spv::StorageClass::PhysicalStorageBuffer) { get_decoration_mgr()->AddDecoration( returnVarId, uint32_t(spv::Decoration::AliasedPointer)); } } return returnVarId; } bool InlinePass::IsSameBlockOp(const Instruction* inst) const { return inst->opcode() == spv::Op::OpSampledImage || inst->opcode() == spv::Op::OpImage; } bool InlinePass::CloneSameBlockOps( std::unique_ptr* inst, std::unordered_map* postCallSB, std::unordered_map* preCallSB, std::unique_ptr* block_ptr) { return (*inst)->WhileEachInId([&postCallSB, &preCallSB, &block_ptr, this](uint32_t* iid) { const auto mapItr = (*postCallSB).find(*iid); if (mapItr == (*postCallSB).end()) { const auto mapItr2 = (*preCallSB).find(*iid); if (mapItr2 != (*preCallSB).end()) { // Clone pre-call same-block ops, map result id. const Instruction* inInst = mapItr2->second; std::unique_ptr sb_inst(inInst->Clone(context())); if (!CloneSameBlockOps(&sb_inst, postCallSB, preCallSB, block_ptr)) { return false; } const uint32_t rid = sb_inst->result_id(); const uint32_t nid = context()->TakeNextId(); if (nid == 0) { return false; } get_decoration_mgr()->CloneDecorations(rid, nid); sb_inst->SetResultId(nid); (*postCallSB)[rid] = nid; *iid = nid; (*block_ptr)->AddInstruction(std::move(sb_inst)); } } else { // Reset same-block op operand. *iid = mapItr->second; } return true; }); } void InlinePass::MoveInstsBeforeEntryBlock( std::unordered_map* preCallSB, BasicBlock* new_blk_ptr, BasicBlock::iterator call_inst_itr, UptrVectorIterator call_block_itr) { for (auto cii = call_block_itr->begin(); cii != call_inst_itr; cii = call_block_itr->begin()) { Instruction* inst = &*cii; inst->RemoveFromList(); std::unique_ptr cp_inst(inst); // Remember same-block ops for possible regeneration. if (IsSameBlockOp(&*cp_inst)) { auto* sb_inst_ptr = cp_inst.get(); (*preCallSB)[cp_inst->result_id()] = sb_inst_ptr; } new_blk_ptr->AddInstruction(std::move(cp_inst)); } } std::unique_ptr InlinePass::AddGuardBlock( std::vector>* new_blocks, std::unordered_map* callee2caller, std::unique_ptr new_blk_ptr, uint32_t entry_blk_label_id) { const auto guard_block_id = context()->TakeNextId(); if (guard_block_id == 0) { return nullptr; } AddBranch(guard_block_id, &new_blk_ptr); new_blocks->push_back(std::move(new_blk_ptr)); // Start the next block. new_blk_ptr = MakeUnique(NewLabel(guard_block_id)); // Reset the mapping of the callee's entry block to point to // the guard block. Do this so we can fix up phis later on to // satisfy dominance. (*callee2caller)[entry_blk_label_id] = guard_block_id; return new_blk_ptr; } InstructionList::iterator InlinePass::AddStoresForVariableInitializers( const std::unordered_map& callee2caller, analysis::DebugInlinedAtContext* inlined_at_ctx, std::unique_ptr* new_blk_ptr, UptrVectorIterator callee_first_block_itr) { auto callee_itr = callee_first_block_itr->begin(); while (callee_itr->opcode() == spv::Op::OpVariable || callee_itr->GetCommonDebugOpcode() == CommonDebugInfoDebugDeclare) { if (callee_itr->opcode() == spv::Op::OpVariable && callee_itr->NumInOperands() == 2) { assert(callee2caller.count(callee_itr->result_id()) && "Expected the variable to have already been mapped."); uint32_t new_var_id = callee2caller.at(callee_itr->result_id()); // The initializer must be a constant or global value. No mapped // should be used. uint32_t val_id = callee_itr->GetSingleWordInOperand(1); AddStore(new_var_id, val_id, new_blk_ptr, callee_itr->dbg_line_inst(), context()->get_debug_info_mgr()->BuildDebugScope( callee_itr->GetDebugScope(), inlined_at_ctx)); } if (callee_itr->GetCommonDebugOpcode() == CommonDebugInfoDebugDeclare) { InlineSingleInstruction( callee2caller, new_blk_ptr->get(), &*callee_itr, context()->get_debug_info_mgr()->BuildDebugInlinedAtChain( callee_itr->GetDebugScope().GetInlinedAt(), inlined_at_ctx)); } ++callee_itr; } return callee_itr; } bool InlinePass::InlineSingleInstruction( const std::unordered_map& callee2caller, BasicBlock* new_blk_ptr, const Instruction* inst, uint32_t dbg_inlined_at) { // If we have return, it must be at the end of the callee. We will handle // it at the end. if (inst->opcode() == spv::Op::OpReturnValue || inst->opcode() == spv::Op::OpReturn) return true; // Copy callee instruction and remap all input Ids. std::unique_ptr cp_inst(inst->Clone(context())); cp_inst->ForEachInId([&callee2caller](uint32_t* iid) { const auto mapItr = callee2caller.find(*iid); if (mapItr != callee2caller.end()) { *iid = mapItr->second; } }); // If result id is non-zero, remap it. const uint32_t rid = cp_inst->result_id(); if (rid != 0) { const auto mapItr = callee2caller.find(rid); if (mapItr == callee2caller.end()) { return false; } uint32_t nid = mapItr->second; cp_inst->SetResultId(nid); get_decoration_mgr()->CloneDecorations(rid, nid); } cp_inst->UpdateDebugInlinedAt(dbg_inlined_at); new_blk_ptr->AddInstruction(std::move(cp_inst)); return true; } std::unique_ptr InlinePass::InlineReturn( const std::unordered_map& callee2caller, std::vector>* new_blocks, std::unique_ptr new_blk_ptr, analysis::DebugInlinedAtContext* inlined_at_ctx, Function* calleeFn, const Instruction* inst, uint32_t returnVarId) { // Store return value to return variable. if (inst->opcode() == spv::Op::OpReturnValue) { assert(returnVarId != 0); uint32_t valId = inst->GetInOperand(kSpvReturnValueId).words[0]; const auto mapItr = callee2caller.find(valId); if (mapItr != callee2caller.end()) { valId = mapItr->second; } AddStore(returnVarId, valId, &new_blk_ptr, inst->dbg_line_inst(), context()->get_debug_info_mgr()->BuildDebugScope( inst->GetDebugScope(), inlined_at_ctx)); } uint32_t returnLabelId = 0; for (auto callee_block_itr = calleeFn->begin(); callee_block_itr != calleeFn->end(); ++callee_block_itr) { if (spvOpcodeIsAbort(callee_block_itr->tail()->opcode())) { returnLabelId = context()->TakeNextId(); break; } } if (returnLabelId == 0) return new_blk_ptr; if (inst->opcode() == spv::Op::OpReturn || inst->opcode() == spv::Op::OpReturnValue) AddBranch(returnLabelId, &new_blk_ptr); new_blocks->push_back(std::move(new_blk_ptr)); return MakeUnique(NewLabel(returnLabelId)); } bool InlinePass::InlineEntryBlock( const std::unordered_map& callee2caller, std::unique_ptr* new_blk_ptr, UptrVectorIterator callee_first_block, analysis::DebugInlinedAtContext* inlined_at_ctx) { auto callee_inst_itr = AddStoresForVariableInitializers( callee2caller, inlined_at_ctx, new_blk_ptr, callee_first_block); while (callee_inst_itr != callee_first_block->end()) { // Don't inline function definition links, the calling function is not a // definition. if (callee_inst_itr->GetShader100DebugOpcode() == NonSemanticShaderDebugInfo100DebugFunctionDefinition) { ++callee_inst_itr; continue; } if (!InlineSingleInstruction( callee2caller, new_blk_ptr->get(), &*callee_inst_itr, context()->get_debug_info_mgr()->BuildDebugInlinedAtChain( callee_inst_itr->GetDebugScope().GetInlinedAt(), inlined_at_ctx))) { return false; } ++callee_inst_itr; } return true; } std::unique_ptr InlinePass::InlineBasicBlocks( std::vector>* new_blocks, const std::unordered_map& callee2caller, std::unique_ptr new_blk_ptr, analysis::DebugInlinedAtContext* inlined_at_ctx, Function* calleeFn) { auto callee_block_itr = calleeFn->begin(); ++callee_block_itr; while (callee_block_itr != calleeFn->end()) { new_blocks->push_back(std::move(new_blk_ptr)); const auto mapItr = callee2caller.find(callee_block_itr->GetLabelInst()->result_id()); if (mapItr == callee2caller.end()) return nullptr; new_blk_ptr = MakeUnique(NewLabel(mapItr->second)); auto tail_inst_itr = callee_block_itr->end(); for (auto inst_itr = callee_block_itr->begin(); inst_itr != tail_inst_itr; ++inst_itr) { // Don't inline function definition links, the calling function is not a // definition if (inst_itr->GetShader100DebugOpcode() == NonSemanticShaderDebugInfo100DebugFunctionDefinition) continue; if (!InlineSingleInstruction( callee2caller, new_blk_ptr.get(), &*inst_itr, context()->get_debug_info_mgr()->BuildDebugInlinedAtChain( inst_itr->GetDebugScope().GetInlinedAt(), inlined_at_ctx))) { return nullptr; } } ++callee_block_itr; } return new_blk_ptr; } bool InlinePass::MoveCallerInstsAfterFunctionCall( std::unordered_map* preCallSB, std::unordered_map* postCallSB, std::unique_ptr* new_blk_ptr, BasicBlock::iterator call_inst_itr, bool multiBlocks) { // Copy remaining instructions from caller block. for (Instruction* inst = call_inst_itr->NextNode(); inst; inst = call_inst_itr->NextNode()) { inst->RemoveFromList(); std::unique_ptr cp_inst(inst); // If multiple blocks generated, regenerate any same-block // instruction that has not been seen in this last block. if (multiBlocks) { if (!CloneSameBlockOps(&cp_inst, postCallSB, preCallSB, new_blk_ptr)) { return false; } // Remember same-block ops in this block. if (IsSameBlockOp(&*cp_inst)) { const uint32_t rid = cp_inst->result_id(); (*postCallSB)[rid] = rid; } } new_blk_ptr->get()->AddInstruction(std::move(cp_inst)); } return true; } void InlinePass::MoveLoopMergeInstToFirstBlock( std::vector>* new_blocks) { // Move the OpLoopMerge from the last block back to the first, where // it belongs. auto& first = new_blocks->front(); auto& last = new_blocks->back(); assert(first != last); // Insert a modified copy of the loop merge into the first block. auto loop_merge_itr = last->tail(); --loop_merge_itr; assert(loop_merge_itr->opcode() == spv::Op::OpLoopMerge); std::unique_ptr cp_inst(loop_merge_itr->Clone(context())); first->tail().InsertBefore(std::move(cp_inst)); // Remove the loop merge from the last block. loop_merge_itr->RemoveFromList(); delete &*loop_merge_itr; } void InlinePass::UpdateSingleBlockLoopContinueTarget( uint32_t new_id, std::vector>* new_blocks) { auto& header = new_blocks->front(); auto* merge_inst = header->GetLoopMergeInst(); // The back-edge block is split at the branch to create a new back-edge // block. The old block is modified to branch to the new block. The loop // merge instruction is updated to declare the new block as the continue // target. This has the effect of changing the loop from being a large // continue construct and an empty loop construct to being a loop with a loop // construct and a trivial continue construct. This change is made to satisfy // structural dominance. // Add the new basic block. std::unique_ptr new_block = MakeUnique(NewLabel(new_id)); auto& old_backedge = new_blocks->back(); auto old_branch = old_backedge->tail(); // Move the old back edge into the new block. std::unique_ptr br(&*old_branch); new_block->AddInstruction(std::move(br)); // Add a branch to the new block from the old back-edge block. AddBranch(new_id, &old_backedge); new_blocks->push_back(std::move(new_block)); // Update the loop's continue target to the new block. merge_inst->SetInOperand(1u, {new_id}); } bool InlinePass::GenInlineCode( std::vector>* new_blocks, std::vector>* new_vars, BasicBlock::iterator call_inst_itr, UptrVectorIterator call_block_itr) { // Map from all ids in the callee to their equivalent id in the caller // as callee instructions are copied into caller. std::unordered_map callee2caller; // Pre-call same-block insts std::unordered_map preCallSB; // Post-call same-block op ids std::unordered_map postCallSB; analysis::DebugInlinedAtContext inlined_at_ctx(&*call_inst_itr); // Invalidate the def-use chains. They are not kept up to date while // inlining. However, certain calls try to keep them up-to-date if they are // valid. These operations can fail. context()->InvalidateAnalyses(IRContext::kAnalysisDefUse); // If the caller is a loop header and the callee has multiple blocks, then the // normal inlining logic will place the OpLoopMerge in the last of several // blocks in the loop. Instead, it should be placed at the end of the first // block. We'll wait to move the OpLoopMerge until the end of the regular // inlining logic, and only if necessary. bool caller_is_loop_header = call_block_itr->GetLoopMergeInst() != nullptr; // Single-trip loop continue block std::unique_ptr single_trip_loop_cont_blk; Function* calleeFn = id2function_[call_inst_itr->GetSingleWordOperand( kSpvFunctionCallFunctionId)]; // Map parameters to actual arguments. MapParams(calleeFn, call_inst_itr, &callee2caller); // Define caller local variables for all callee variables and create map to // them. if (!CloneAndMapLocals(calleeFn, new_vars, &callee2caller, &inlined_at_ctx)) { return false; } // First block needs to use label of original block // but map callee label in case of phi reference. uint32_t entry_blk_label_id = calleeFn->begin()->GetLabelInst()->result_id(); callee2caller[entry_blk_label_id] = call_block_itr->id(); std::unique_ptr new_blk_ptr = MakeUnique(NewLabel(call_block_itr->id())); // Move instructions of original caller block up to call instruction. MoveInstsBeforeEntryBlock(&preCallSB, new_blk_ptr.get(), call_inst_itr, call_block_itr); if (caller_is_loop_header && (*(calleeFn->begin())).GetMergeInst() != nullptr) { // We can't place both the caller's merge instruction and // another merge instruction in the same block. So split the // calling block. Insert an unconditional branch to a new guard // block. Later, once we know the ID of the last block, we // will move the caller's OpLoopMerge from the last generated // block into the first block. We also wait to avoid // invalidating various iterators. new_blk_ptr = AddGuardBlock(new_blocks, &callee2caller, std::move(new_blk_ptr), entry_blk_label_id); if (new_blk_ptr == nullptr) return false; } // Create return var if needed. const uint32_t calleeTypeId = calleeFn->type_id(); uint32_t returnVarId = 0; analysis::Type* calleeType = context()->get_type_mgr()->GetType(calleeTypeId); if (calleeType->AsVoid() == nullptr) { returnVarId = CreateReturnVar(calleeFn, new_vars); if (returnVarId == 0) { return false; } } calleeFn->WhileEachInst([&callee2caller, this](const Instruction* cpi) { // Create set of callee result ids. Used to detect forward references const uint32_t rid = cpi->result_id(); if (rid != 0 && callee2caller.find(rid) == callee2caller.end()) { const uint32_t nid = context()->TakeNextId(); if (nid == 0) return false; callee2caller[rid] = nid; } return true; }); // Inline DebugClare instructions in the callee's header. calleeFn->ForEachDebugInstructionsInHeader( [&new_blk_ptr, &callee2caller, &inlined_at_ctx, this](Instruction* inst) { InlineSingleInstruction( callee2caller, new_blk_ptr.get(), inst, context()->get_debug_info_mgr()->BuildDebugInlinedAtChain( inst->GetDebugScope().GetInlinedAt(), &inlined_at_ctx)); }); // Inline the entry block of the callee function. if (!InlineEntryBlock(callee2caller, &new_blk_ptr, calleeFn->begin(), &inlined_at_ctx)) { return false; } // Inline blocks of the callee function other than the entry block. new_blk_ptr = InlineBasicBlocks(new_blocks, callee2caller, std::move(new_blk_ptr), &inlined_at_ctx, calleeFn); if (new_blk_ptr == nullptr) return false; new_blk_ptr = InlineReturn(callee2caller, new_blocks, std::move(new_blk_ptr), &inlined_at_ctx, calleeFn, &*(calleeFn->tail()->tail()), returnVarId); // Load return value into result id of call, if it exists. if (returnVarId != 0) { const uint32_t resId = call_inst_itr->result_id(); assert(resId != 0); AddLoad(calleeTypeId, resId, returnVarId, &new_blk_ptr, call_inst_itr->dbg_line_inst(), call_inst_itr->GetDebugScope()); } // Move instructions of original caller block after call instruction. if (!MoveCallerInstsAfterFunctionCall(&preCallSB, &postCallSB, &new_blk_ptr, call_inst_itr, calleeFn->begin() != calleeFn->end())) return false; // Finalize inline code. new_blocks->push_back(std::move(new_blk_ptr)); if (caller_is_loop_header && (new_blocks->size() > 1)) { MoveLoopMergeInstToFirstBlock(new_blocks); // If the loop was a single basic block previously, update it's structure. auto& header = new_blocks->front(); auto* merge_inst = header->GetLoopMergeInst(); if (merge_inst->GetSingleWordInOperand(1u) == header->id()) { auto new_id = context()->TakeNextId(); if (new_id == 0) return false; UpdateSingleBlockLoopContinueTarget(new_id, new_blocks); } } // Update block map given replacement blocks. for (auto& blk : *new_blocks) { id2block_[blk->id()] = &*blk; } // We need to kill the name and decorations for the call, which will be // deleted. context()->KillNamesAndDecorates(&*call_inst_itr); return true; } bool InlinePass::IsInlinableFunctionCall(const Instruction* inst) { if (inst->opcode() != spv::Op::OpFunctionCall) return false; const uint32_t calleeFnId = inst->GetSingleWordOperand(kSpvFunctionCallFunctionId); const auto ci = inlinable_.find(calleeFnId); if (ci == inlinable_.cend()) return false; if (early_return_funcs_.find(calleeFnId) != early_return_funcs_.end()) { // We rely on the merge-return pass to handle the early return case // in advance. std::string message = "The function '" + id2function_[calleeFnId]->DefInst().PrettyPrint() + "' could not be inlined because the return instruction " "is not at the end of the function. This could be fixed by " "running merge-return before inlining."; consumer()(SPV_MSG_WARNING, "", {0, 0, 0}, message.c_str()); return false; } return true; } void InlinePass::UpdateSucceedingPhis( std::vector>& new_blocks) { const auto firstBlk = new_blocks.begin(); const auto lastBlk = new_blocks.end() - 1; const uint32_t firstId = (*firstBlk)->id(); const uint32_t lastId = (*lastBlk)->id(); const BasicBlock& const_last_block = *lastBlk->get(); const_last_block.ForEachSuccessorLabel( [&firstId, &lastId, this](const uint32_t succ) { BasicBlock* sbp = this->id2block_[succ]; sbp->ForEachPhiInst([&firstId, &lastId](Instruction* phi) { phi->ForEachInId([&firstId, &lastId](uint32_t* id) { if (*id == firstId) *id = lastId; }); }); }); } bool InlinePass::HasNoReturnInLoop(Function* func) { // If control not structured, do not do loop/return analysis // TODO: Analyze returns in non-structured control flow if (!context()->get_feature_mgr()->HasCapability(spv::Capability::Shader)) return false; const auto structured_analysis = context()->GetStructuredCFGAnalysis(); // Search for returns in structured construct. bool return_in_loop = false; for (auto& blk : *func) { auto terminal_ii = blk.cend(); --terminal_ii; if (spvOpcodeIsReturn(terminal_ii->opcode()) && structured_analysis->ContainingLoop(blk.id()) != 0) { return_in_loop = true; break; } } return !return_in_loop; } void InlinePass::AnalyzeReturns(Function* func) { // Analyze functions without a return in loop. if (HasNoReturnInLoop(func)) { no_return_in_loop_.insert(func->result_id()); } // Analyze functions with a return before its tail basic block. for (auto& blk : *func) { auto terminal_ii = blk.cend(); --terminal_ii; if (spvOpcodeIsReturn(terminal_ii->opcode()) && &blk != func->tail()) { early_return_funcs_.insert(func->result_id()); break; } } } bool InlinePass::IsInlinableFunction(Function* func) { // We can only inline a function if it has blocks. if (func->cbegin() == func->cend()) return false; // Do not inline functions with DontInline flag. if (func->control_mask() & uint32_t(spv::FunctionControlMask::DontInline)) { return false; } // Do not inline functions with returns in loops. Currently early return // functions are inlined by wrapping them in a one trip loop and implementing // the returns as a branch to the loop's merge block. However, this can only // done validly if the return was not in a loop in the original function. // Also remember functions with multiple (early) returns. AnalyzeReturns(func); if (no_return_in_loop_.find(func->result_id()) == no_return_in_loop_.cend()) { return false; } if (func->IsRecursive()) { return false; } // Do not inline functions with an abort instruction if they are called from a // continue construct. If it is inlined into a continue construct the backedge // will no longer post-dominate the continue target, which is invalid. An // `OpUnreachable` is acceptable because it will not change post-dominance if // it is statically unreachable. bool func_is_called_from_continue = funcs_called_from_continue_.count(func->result_id()) != 0; if (func_is_called_from_continue && ContainsAbortOtherThanUnreachable(func)) { return false; } return true; } bool InlinePass::ContainsAbortOtherThanUnreachable(Function* func) const { return !func->WhileEachInst([](Instruction* inst) { return inst->opcode() == spv::Op::OpUnreachable || !spvOpcodeIsAbort(inst->opcode()); }); } void InlinePass::InitializeInline() { false_id_ = 0; // clear collections id2function_.clear(); id2block_.clear(); inlinable_.clear(); no_return_in_loop_.clear(); early_return_funcs_.clear(); funcs_called_from_continue_ = context()->GetStructuredCFGAnalysis()->FindFuncsCalledFromContinue(); for (auto& fn : *get_module()) { // Initialize function and block maps. id2function_[fn.result_id()] = &fn; for (auto& blk : fn) { id2block_[blk.id()] = &blk; } // Compute inlinability if (IsInlinableFunction(&fn)) inlinable_.insert(fn.result_id()); } } InlinePass::InlinePass() {} void InlinePass::FixDebugDeclares(Function* func) { std::map access_chains; std::vector debug_declare_insts; func->ForEachInst([&access_chains, &debug_declare_insts](Instruction* inst) { if (inst->opcode() == spv::Op::OpAccessChain) { access_chains[inst->result_id()] = inst; } if (inst->GetCommonDebugOpcode() == CommonDebugInfoDebugDeclare) { debug_declare_insts.push_back(inst); } }); for (auto& inst : debug_declare_insts) { FixDebugDeclare(inst, access_chains); } } void InlinePass::FixDebugDeclare( Instruction* dbg_declare_inst, const std::map& access_chains) { do { uint32_t var_id = dbg_declare_inst->GetSingleWordInOperand(kSpvDebugDeclareVarInIdx); // The def-use chains are not kept up to date while inlining, so we need to // get the variable by traversing the functions. auto it = access_chains.find(var_id); if (it == access_chains.end()) { return; } Instruction* access_chain = it->second; // If the variable id in the debug declare is an access chain, it is // invalid. it needs to be fixed up. The debug declare will be updated so // that its Var operand becomes the base of the access chain. The indexes of // the access chain are prepended before the indexes of the debug declare. std::vector operands; for (int i = 0; i < kSpvDebugDeclareVarInIdx; i++) { operands.push_back(dbg_declare_inst->GetInOperand(i)); } uint32_t access_chain_base = access_chain->GetSingleWordInOperand(kSpvAccessChainBaseInIdx); operands.push_back(Operand(SPV_OPERAND_TYPE_ID, {access_chain_base})); operands.push_back( dbg_declare_inst->GetInOperand(kSpvDebugDeclareVarInIdx + 1)); for (uint32_t i = kSpvAccessChainBaseInIdx + 1; i < access_chain->NumInOperands(); ++i) { operands.push_back(access_chain->GetInOperand(i)); } for (uint32_t i = kSpvDebugDeclareVarInIdx + 2; i < dbg_declare_inst->NumInOperands(); ++i) { operands.push_back(dbg_declare_inst->GetInOperand(i)); } dbg_declare_inst->SetInOperands(std::move(operands)); } while (true); } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/inline_pass.h000066400000000000000000000255741475742701700233250ustar00rootroot00000000000000// Copyright (c) 2017 The Khronos Group Inc. // Copyright (c) 2017 Valve Corporation // Copyright (c) 2017 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_INLINE_PASS_H_ #define SOURCE_OPT_INLINE_PASS_H_ #include #include #include #include #include #include #include "source/opt/debug_info_manager.h" #include "source/opt/decoration_manager.h" #include "source/opt/module.h" #include "source/opt/pass.h" namespace spvtools { namespace opt { // See optimizer.hpp for documentation. class InlinePass : public Pass { using cbb_ptr = const BasicBlock*; public: virtual ~InlinePass() override = default; protected: InlinePass(); // Add pointer to type to module and return resultId. Returns 0 if the type // could not be created. uint32_t AddPointerToType(uint32_t type_id, spv::StorageClass storage_class); // Add unconditional branch to labelId to end of block block_ptr. void AddBranch(uint32_t labelId, std::unique_ptr* block_ptr); // Add conditional branch to end of block |block_ptr|. void AddBranchCond(uint32_t cond_id, uint32_t true_id, uint32_t false_id, std::unique_ptr* block_ptr); // Add unconditional branch to labelId to end of block block_ptr. void AddLoopMerge(uint32_t merge_id, uint32_t continue_id, std::unique_ptr* block_ptr); // Add store of valId to ptrId to end of block block_ptr. void AddStore(uint32_t ptrId, uint32_t valId, std::unique_ptr* block_ptr, const Instruction* line_inst, const DebugScope& dbg_scope); // Add load of ptrId into resultId to end of block block_ptr. void AddLoad(uint32_t typeId, uint32_t resultId, uint32_t ptrId, std::unique_ptr* block_ptr, const Instruction* line_inst, const DebugScope& dbg_scope); // Return new label. std::unique_ptr NewLabel(uint32_t label_id); // Returns the id for the boolean false value. Looks in the module first // and creates it if not found. Remembers it for future calls. Returns 0 if // the value could not be created. uint32_t GetFalseId(); // Map callee params to caller args void MapParams(Function* calleeFn, BasicBlock::iterator call_inst_itr, std::unordered_map* callee2caller); // Clone and map callee locals. Return true if successful. bool CloneAndMapLocals(Function* calleeFn, std::vector>* new_vars, std::unordered_map* callee2caller, analysis::DebugInlinedAtContext* inlined_at_ctx); // Create return variable for callee clone code. The return type of // |calleeFn| must not be void. Returns the id of the return variable if // created. Returns 0 if the return variable could not be created. uint32_t CreateReturnVar(Function* calleeFn, std::vector>* new_vars); // Return true if instruction must be in the same block that its result // is used. bool IsSameBlockOp(const Instruction* inst) const; // Clone operands which must be in same block as consumer instructions. // Look in preCallSB for instructions that need cloning. Look in // postCallSB for instructions already cloned. Add cloned instruction // to postCallSB. bool CloneSameBlockOps(std::unique_ptr* inst, std::unordered_map* postCallSB, std::unordered_map* preCallSB, std::unique_ptr* block_ptr); // Return in new_blocks the result of inlining the call at call_inst_itr // within its block at call_block_itr. The block at call_block_itr can // just be replaced with the blocks in new_blocks. Any additional branches // are avoided. Debug instructions are cloned along with their callee // instructions. Early returns are replaced by a store to a local return // variable and a branch to a (created) exit block where the local variable // is returned. Formal parameters are trivially mapped to their actual // parameters. Note that the first block in new_blocks retains the label // of the original calling block. Also note that if an exit block is // created, it is the last block of new_blocks. // // Also return in new_vars additional OpVariable instructions required by // and to be inserted into the caller function after the block at // call_block_itr is replaced with new_blocks. // // Returns true if successful. bool GenInlineCode(std::vector>* new_blocks, std::vector>* new_vars, BasicBlock::iterator call_inst_itr, UptrVectorIterator call_block_itr); // Return true if |inst| is a function call that can be inlined. bool IsInlinableFunctionCall(const Instruction* inst); // Return true if |func| has no return in a loop. The current analysis // requires structured control flow, so return false if control flow not // structured ie. module is not a shader. bool HasNoReturnInLoop(Function* func); // Find all functions with multiple returns and no returns in loops void AnalyzeReturns(Function* func); // Return true if |func| is a function that can be inlined. bool IsInlinableFunction(Function* func); // Returns true if |func| contains an abort instruction that is not an // `OpUnreachable` instruction. bool ContainsAbortOtherThanUnreachable(Function* func) const; // Update phis in succeeding blocks to point to new last block void UpdateSucceedingPhis( std::vector>& new_blocks); // Initialize state for optimization of |module| void InitializeInline(); // Fixes invalid debug declare functions in `func` that were caused by // inlining. This function cannot be called while in the middle of inlining // because it needs to be able to find the instructions that define an // id. void FixDebugDeclares(Function* func); // Map from function's result id to function. std::unordered_map id2function_; // Map from block's label id to block. TODO(dnovillo): This is superfluous wrt // CFG. It has functionality not present in CFG. Consolidate. std::unordered_map id2block_; // Set of ids of functions with early return. std::set early_return_funcs_; // Set of ids of functions with no returns in loop std::set no_return_in_loop_; // Set of ids of inlinable functions std::set inlinable_; // result id for OpConstantFalse uint32_t false_id_; // Set of functions that are originally called directly or indirectly from a // continue construct. std::unordered_set funcs_called_from_continue_; private: // Moves instructions of the caller function up to the call instruction // to |new_blk_ptr|. void MoveInstsBeforeEntryBlock( std::unordered_map* preCallSB, BasicBlock* new_blk_ptr, BasicBlock::iterator call_inst_itr, UptrVectorIterator call_block_itr); // Returns a new guard block after adding a branch to the end of // |new_blocks|. std::unique_ptr AddGuardBlock( std::vector>* new_blocks, std::unordered_map* callee2caller, std::unique_ptr new_blk_ptr, uint32_t entry_blk_label_id); // Add store instructions for initializers of variables. InstructionList::iterator AddStoresForVariableInitializers( const std::unordered_map& callee2caller, analysis::DebugInlinedAtContext* inlined_at_ctx, std::unique_ptr* new_blk_ptr, UptrVectorIterator callee_block_itr); // Inlines a single instruction of the callee function. bool InlineSingleInstruction( const std::unordered_map& callee2caller, BasicBlock* new_blk_ptr, const Instruction* inst, uint32_t dbg_inlined_at); // Inlines the return instruction of the callee function. std::unique_ptr InlineReturn( const std::unordered_map& callee2caller, std::vector>* new_blocks, std::unique_ptr new_blk_ptr, analysis::DebugInlinedAtContext* inlined_at_ctx, Function* calleeFn, const Instruction* inst, uint32_t returnVarId); // Inlines the entry block of the callee function. bool InlineEntryBlock( const std::unordered_map& callee2caller, std::unique_ptr* new_blk_ptr, UptrVectorIterator callee_first_block, analysis::DebugInlinedAtContext* inlined_at_ctx); // Inlines basic blocks of the callee function other than the entry basic // block. std::unique_ptr InlineBasicBlocks( std::vector>* new_blocks, const std::unordered_map& callee2caller, std::unique_ptr new_blk_ptr, analysis::DebugInlinedAtContext* inlined_at_ctx, Function* calleeFn); // Moves instructions of the caller function after the call instruction // to |new_blk_ptr|. bool MoveCallerInstsAfterFunctionCall( std::unordered_map* preCallSB, std::unordered_map* postCallSB, std::unique_ptr* new_blk_ptr, BasicBlock::iterator call_inst_itr, bool multiBlocks); // Move the OpLoopMerge from the last block back to the first. void MoveLoopMergeInstToFirstBlock( std::vector>* new_blocks); // Update the structure of single block loops so that the inlined code ends // up in the loop construct and a new continue target is added to satisfy // structural dominance. void UpdateSingleBlockLoopContinueTarget( uint32_t new_id, std::vector>* new_blocks); // Replaces the `var` operand of `dbg_declare_inst` and updates the indexes // accordingly, if it is the id of an access chain in `access_chains`. void FixDebugDeclare(Instruction* dbg_declare_inst, const std::map& access_chains); }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_INLINE_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/instruction.cpp000066400000000000000000001052551475742701700237300ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/instruction.h" #include #include "OpenCLDebugInfo100.h" #include "source/disassemble.h" #include "source/opt/fold.h" #include "source/opt/ir_context.h" #include "source/opt/reflect.h" namespace spvtools { namespace opt { namespace { // Indices used to get particular operands out of instructions using InOperand. constexpr uint32_t kTypeImageDimIndex = 1; constexpr uint32_t kLoadBaseIndex = 0; constexpr uint32_t kPointerTypeStorageClassIndex = 0; constexpr uint32_t kVariableStorageClassIndex = 0; constexpr uint32_t kTypeImageSampledIndex = 5; // Constants for OpenCL.DebugInfo.100 / NonSemantic.Shader.DebugInfo.100 // extension instructions. constexpr uint32_t kExtInstSetIdInIdx = 0; constexpr uint32_t kExtInstInstructionInIdx = 1; constexpr uint32_t kDebugScopeNumWords = 7; constexpr uint32_t kDebugScopeNumWordsWithoutInlinedAt = 6; constexpr uint32_t kDebugNoScopeNumWords = 5; // Number of operands of an OpBranchConditional instruction // with weights. constexpr uint32_t kOpBranchConditionalWithWeightsNumOperands = 5; } // namespace Instruction::Instruction(IRContext* c) : utils::IntrusiveNodeBase(), context_(c), opcode_(spv::Op::OpNop), has_type_id_(false), has_result_id_(false), unique_id_(c->TakeNextUniqueId()), dbg_scope_(kNoDebugScope, kNoInlinedAt) {} Instruction::Instruction(IRContext* c, spv::Op op) : utils::IntrusiveNodeBase(), context_(c), opcode_(op), has_type_id_(false), has_result_id_(false), unique_id_(c->TakeNextUniqueId()), dbg_scope_(kNoDebugScope, kNoInlinedAt) {} Instruction::Instruction(IRContext* c, const spv_parsed_instruction_t& inst, std::vector&& dbg_line) : utils::IntrusiveNodeBase(), context_(c), opcode_(static_cast(inst.opcode)), has_type_id_(inst.type_id != 0), has_result_id_(inst.result_id != 0), unique_id_(c->TakeNextUniqueId()), dbg_line_insts_(std::move(dbg_line)), dbg_scope_(kNoDebugScope, kNoInlinedAt) { operands_.reserve(inst.num_operands); for (uint32_t i = 0; i < inst.num_operands; ++i) { const auto& current_payload = inst.operands[i]; operands_.emplace_back( current_payload.type, inst.words + current_payload.offset, inst.words + current_payload.offset + current_payload.num_words); } assert((!IsLineInst() || dbg_line.empty()) && "Op(No)Line attaching to Op(No)Line found"); } Instruction::Instruction(IRContext* c, const spv_parsed_instruction_t& inst, const DebugScope& dbg_scope) : utils::IntrusiveNodeBase(), context_(c), opcode_(static_cast(inst.opcode)), has_type_id_(inst.type_id != 0), has_result_id_(inst.result_id != 0), unique_id_(c->TakeNextUniqueId()), dbg_scope_(dbg_scope) { operands_.reserve(inst.num_operands); for (uint32_t i = 0; i < inst.num_operands; ++i) { const auto& current_payload = inst.operands[i]; operands_.emplace_back( current_payload.type, inst.words + current_payload.offset, inst.words + current_payload.offset + current_payload.num_words); } } Instruction::Instruction(IRContext* c, spv::Op op, uint32_t ty_id, uint32_t res_id, const OperandList& in_operands) : utils::IntrusiveNodeBase(), context_(c), opcode_(op), has_type_id_(ty_id != 0), has_result_id_(res_id != 0), unique_id_(c->TakeNextUniqueId()), operands_(), dbg_scope_(kNoDebugScope, kNoInlinedAt) { size_t operands_size = in_operands.size(); if (has_type_id_) { operands_size++; } if (has_result_id_) { operands_size++; } operands_.reserve(operands_size); if (has_type_id_) { operands_.emplace_back(spv_operand_type_t::SPV_OPERAND_TYPE_TYPE_ID, std::initializer_list{ty_id}); } if (has_result_id_) { operands_.emplace_back(spv_operand_type_t::SPV_OPERAND_TYPE_RESULT_ID, std::initializer_list{res_id}); } operands_.insert(operands_.end(), in_operands.begin(), in_operands.end()); } Instruction::Instruction(Instruction&& that) : utils::IntrusiveNodeBase(), context_(that.context_), opcode_(that.opcode_), has_type_id_(that.has_type_id_), has_result_id_(that.has_result_id_), unique_id_(that.unique_id_), operands_(std::move(that.operands_)), dbg_line_insts_(std::move(that.dbg_line_insts_)), dbg_scope_(that.dbg_scope_) { for (auto& i : dbg_line_insts_) { i.dbg_scope_ = that.dbg_scope_; } } Instruction& Instruction::operator=(Instruction&& that) { context_ = that.context_; opcode_ = that.opcode_; has_type_id_ = that.has_type_id_; has_result_id_ = that.has_result_id_; unique_id_ = that.unique_id_; operands_ = std::move(that.operands_); dbg_line_insts_ = std::move(that.dbg_line_insts_); dbg_scope_ = that.dbg_scope_; return *this; } Instruction* Instruction::Clone(IRContext* c) const { Instruction* clone = new Instruction(c); clone->opcode_ = opcode_; clone->has_type_id_ = has_type_id_; clone->has_result_id_ = has_result_id_; clone->unique_id_ = c->TakeNextUniqueId(); clone->operands_ = operands_; clone->dbg_line_insts_ = dbg_line_insts_; for (auto& i : clone->dbg_line_insts_) { i.unique_id_ = c->TakeNextUniqueId(); if (i.IsDebugLineInst()) i.SetResultId(c->TakeNextId()); } clone->dbg_scope_ = dbg_scope_; return clone; } uint32_t Instruction::GetSingleWordOperand(uint32_t index) const { const auto& words = GetOperand(index).words; assert(words.size() == 1 && "expected the operand only taking one word"); return words.front(); } uint32_t Instruction::NumInOperandWords() const { uint32_t size = 0; for (uint32_t i = TypeResultIdCount(); i < operands_.size(); ++i) size += static_cast(operands_[i].words.size()); return size; } bool Instruction::HasBranchWeights() const { if (opcode_ == spv::Op::OpBranchConditional && NumOperands() == kOpBranchConditionalWithWeightsNumOperands) { return true; } return false; } void Instruction::ToBinaryWithoutAttachedDebugInsts( std::vector* binary) const { const uint32_t num_words = 1 + NumOperandWords(); binary->push_back((num_words << 16) | static_cast(opcode_)); for (const auto& operand : operands_) { binary->insert(binary->end(), operand.words.begin(), operand.words.end()); } } void Instruction::ReplaceOperands(const OperandList& new_operands) { operands_.clear(); operands_.insert(operands_.begin(), new_operands.begin(), new_operands.end()); } bool Instruction::IsReadOnlyLoad() const { if (IsLoad()) { Instruction* address_def = GetBaseAddress(); if (!address_def) { return false; } if (address_def->opcode() == spv::Op::OpVariable) { if (address_def->IsReadOnlyPointer()) { return true; } } if (address_def->opcode() == spv::Op::OpLoad) { const analysis::Type* address_type = context()->get_type_mgr()->GetType(address_def->type_id()); if (address_type->AsSampledImage() != nullptr) { const auto* image_type = address_type->AsSampledImage()->image_type()->AsImage(); if (image_type->sampled() == 1) { return true; } } } } return false; } Instruction* Instruction::GetBaseAddress() const { uint32_t base = GetSingleWordInOperand(kLoadBaseIndex); Instruction* base_inst = context()->get_def_use_mgr()->GetDef(base); bool done = false; while (!done) { switch (base_inst->opcode()) { case spv::Op::OpAccessChain: case spv::Op::OpInBoundsAccessChain: case spv::Op::OpPtrAccessChain: case spv::Op::OpInBoundsPtrAccessChain: case spv::Op::OpImageTexelPointer: case spv::Op::OpCopyObject: // All of these instructions have the base pointer use a base pointer // in in-operand 0. base = base_inst->GetSingleWordInOperand(0); base_inst = context()->get_def_use_mgr()->GetDef(base); break; default: done = true; break; } } return base_inst; } bool Instruction::IsReadOnlyPointer() const { if (context()->get_feature_mgr()->HasCapability(spv::Capability::Shader)) return IsReadOnlyPointerShaders(); else return IsReadOnlyPointerKernel(); } bool Instruction::IsVulkanStorageImage() const { if (opcode() != spv::Op::OpTypePointer) { return false; } spv::StorageClass storage_class = spv::StorageClass(GetSingleWordInOperand(kPointerTypeStorageClassIndex)); if (storage_class != spv::StorageClass::UniformConstant) { return false; } Instruction* base_type = context()->get_def_use_mgr()->GetDef(GetSingleWordInOperand(1)); // Unpack the optional layer of arraying. if (base_type->opcode() == spv::Op::OpTypeArray || base_type->opcode() == spv::Op::OpTypeRuntimeArray) { base_type = context()->get_def_use_mgr()->GetDef( base_type->GetSingleWordInOperand(0)); } if (base_type->opcode() != spv::Op::OpTypeImage) { return false; } if (spv::Dim(base_type->GetSingleWordInOperand(kTypeImageDimIndex)) == spv::Dim::Buffer) { return false; } // Check if the image is sampled. If we do not know for sure that it is, // then assume it is a storage image. return base_type->GetSingleWordInOperand(kTypeImageSampledIndex) != 1; } bool Instruction::IsVulkanSampledImage() const { if (opcode() != spv::Op::OpTypePointer) { return false; } spv::StorageClass storage_class = spv::StorageClass(GetSingleWordInOperand(kPointerTypeStorageClassIndex)); if (storage_class != spv::StorageClass::UniformConstant) { return false; } Instruction* base_type = context()->get_def_use_mgr()->GetDef(GetSingleWordInOperand(1)); // Unpack the optional layer of arraying. if (base_type->opcode() == spv::Op::OpTypeArray || base_type->opcode() == spv::Op::OpTypeRuntimeArray) { base_type = context()->get_def_use_mgr()->GetDef( base_type->GetSingleWordInOperand(0)); } if (base_type->opcode() != spv::Op::OpTypeImage) { return false; } if (spv::Dim(base_type->GetSingleWordInOperand(kTypeImageDimIndex)) == spv::Dim::Buffer) { return false; } // Check if the image is sampled. If we know for sure that it is, // then return true. return base_type->GetSingleWordInOperand(kTypeImageSampledIndex) == 1; } bool Instruction::IsVulkanStorageTexelBuffer() const { if (opcode() != spv::Op::OpTypePointer) { return false; } spv::StorageClass storage_class = spv::StorageClass(GetSingleWordInOperand(kPointerTypeStorageClassIndex)); if (storage_class != spv::StorageClass::UniformConstant) { return false; } Instruction* base_type = context()->get_def_use_mgr()->GetDef(GetSingleWordInOperand(1)); // Unpack the optional layer of arraying. if (base_type->opcode() == spv::Op::OpTypeArray || base_type->opcode() == spv::Op::OpTypeRuntimeArray) { base_type = context()->get_def_use_mgr()->GetDef( base_type->GetSingleWordInOperand(0)); } if (base_type->opcode() != spv::Op::OpTypeImage) { return false; } if (spv::Dim(base_type->GetSingleWordInOperand(kTypeImageDimIndex)) != spv::Dim::Buffer) { return false; } // Check if the image is sampled. If we do not know for sure that it is, // then assume it is a storage texel buffer. return base_type->GetSingleWordInOperand(kTypeImageSampledIndex) != 1; } bool Instruction::IsVulkanStorageBuffer() const { // Is there a difference between a "Storage buffer" and a "dynamic storage // buffer" in SPIR-V and do we care about the difference? if (opcode() != spv::Op::OpTypePointer) { return false; } Instruction* base_type = context()->get_def_use_mgr()->GetDef(GetSingleWordInOperand(1)); // Unpack the optional layer of arraying. if (base_type->opcode() == spv::Op::OpTypeArray || base_type->opcode() == spv::Op::OpTypeRuntimeArray) { base_type = context()->get_def_use_mgr()->GetDef( base_type->GetSingleWordInOperand(0)); } if (base_type->opcode() != spv::Op::OpTypeStruct) { return false; } spv::StorageClass storage_class = spv::StorageClass(GetSingleWordInOperand(kPointerTypeStorageClassIndex)); if (storage_class == spv::StorageClass::Uniform) { bool is_buffer_block = false; context()->get_decoration_mgr()->ForEachDecoration( base_type->result_id(), uint32_t(spv::Decoration::BufferBlock), [&is_buffer_block](const Instruction&) { is_buffer_block = true; }); return is_buffer_block; } else if (storage_class == spv::StorageClass::StorageBuffer) { bool is_block = false; context()->get_decoration_mgr()->ForEachDecoration( base_type->result_id(), uint32_t(spv::Decoration::Block), [&is_block](const Instruction&) { is_block = true; }); return is_block; } return false; } bool Instruction::IsVulkanStorageBufferVariable() const { if (opcode() != spv::Op::OpVariable) { return false; } spv::StorageClass storage_class = spv::StorageClass(GetSingleWordInOperand(kVariableStorageClassIndex)); if (storage_class == spv::StorageClass::StorageBuffer || storage_class == spv::StorageClass::Uniform) { Instruction* var_type = context()->get_def_use_mgr()->GetDef(type_id()); return var_type != nullptr && var_type->IsVulkanStorageBuffer(); } return false; } bool Instruction::IsVulkanUniformBuffer() const { if (opcode() != spv::Op::OpTypePointer) { return false; } spv::StorageClass storage_class = spv::StorageClass(GetSingleWordInOperand(kPointerTypeStorageClassIndex)); if (storage_class != spv::StorageClass::Uniform) { return false; } Instruction* base_type = context()->get_def_use_mgr()->GetDef(GetSingleWordInOperand(1)); // Unpack the optional layer of arraying. if (base_type->opcode() == spv::Op::OpTypeArray || base_type->opcode() == spv::Op::OpTypeRuntimeArray) { base_type = context()->get_def_use_mgr()->GetDef( base_type->GetSingleWordInOperand(0)); } if (base_type->opcode() != spv::Op::OpTypeStruct) { return false; } bool is_block = false; context()->get_decoration_mgr()->ForEachDecoration( base_type->result_id(), uint32_t(spv::Decoration::Block), [&is_block](const Instruction&) { is_block = true; }); return is_block; } bool Instruction::IsReadOnlyPointerShaders() const { if (type_id() == 0) { return false; } Instruction* type_def = context()->get_def_use_mgr()->GetDef(type_id()); if (type_def->opcode() != spv::Op::OpTypePointer) { return false; } spv::StorageClass storage_class = spv::StorageClass( type_def->GetSingleWordInOperand(kPointerTypeStorageClassIndex)); switch (storage_class) { case spv::StorageClass::UniformConstant: if (!type_def->IsVulkanStorageImage() && !type_def->IsVulkanStorageTexelBuffer()) { return true; } break; case spv::StorageClass::Uniform: if (!type_def->IsVulkanStorageBuffer()) { return true; } break; case spv::StorageClass::PushConstant: case spv::StorageClass::Input: return true; default: break; } bool is_nonwritable = false; context()->get_decoration_mgr()->ForEachDecoration( result_id(), uint32_t(spv::Decoration::NonWritable), [&is_nonwritable](const Instruction&) { is_nonwritable = true; }); return is_nonwritable; } bool Instruction::IsReadOnlyPointerKernel() const { if (type_id() == 0) { return false; } Instruction* type_def = context()->get_def_use_mgr()->GetDef(type_id()); if (type_def->opcode() != spv::Op::OpTypePointer) { return false; } spv::StorageClass storage_class = spv::StorageClass( type_def->GetSingleWordInOperand(kPointerTypeStorageClassIndex)); return storage_class == spv::StorageClass::UniformConstant; } void Instruction::UpdateLexicalScope(uint32_t scope) { dbg_scope_.SetLexicalScope(scope); for (auto& i : dbg_line_insts_) { i.dbg_scope_.SetLexicalScope(scope); } if (!IsLineInst() && context()->AreAnalysesValid(IRContext::kAnalysisDebugInfo)) { context()->get_debug_info_mgr()->AnalyzeDebugInst(this); } } void Instruction::UpdateDebugInlinedAt(uint32_t new_inlined_at) { dbg_scope_.SetInlinedAt(new_inlined_at); for (auto& i : dbg_line_insts_) { i.dbg_scope_.SetInlinedAt(new_inlined_at); } if (!IsLineInst() && context()->AreAnalysesValid(IRContext::kAnalysisDebugInfo)) { context()->get_debug_info_mgr()->AnalyzeDebugInst(this); } } void Instruction::ClearDbgLineInsts() { if (context()->AreAnalysesValid(IRContext::kAnalysisDefUse)) { auto def_use_mgr = context()->get_def_use_mgr(); for (auto& l_inst : dbg_line_insts_) def_use_mgr->ClearInst(&l_inst); } clear_dbg_line_insts(); } void Instruction::UpdateDebugInfoFrom(const Instruction* from) { if (from == nullptr) return; ClearDbgLineInsts(); if (!from->dbg_line_insts().empty()) AddDebugLine(&from->dbg_line_insts().back()); SetDebugScope(from->GetDebugScope()); if (!IsLineInst() && context()->AreAnalysesValid(IRContext::kAnalysisDebugInfo)) { context()->get_debug_info_mgr()->AnalyzeDebugInst(this); } } void Instruction::AddDebugLine(const Instruction* inst) { dbg_line_insts_.push_back(*inst); dbg_line_insts_.back().unique_id_ = context()->TakeNextUniqueId(); if (inst->IsDebugLineInst()) dbg_line_insts_.back().SetResultId(context_->TakeNextId()); if (context()->AreAnalysesValid(IRContext::kAnalysisDefUse)) context()->get_def_use_mgr()->AnalyzeInstDefUse(&dbg_line_insts_.back()); } bool Instruction::IsDebugLineInst() const { NonSemanticShaderDebugInfo100Instructions ext_opt = GetShader100DebugOpcode(); return ((ext_opt == NonSemanticShaderDebugInfo100DebugLine) || (ext_opt == NonSemanticShaderDebugInfo100DebugNoLine)); } bool Instruction::IsLineInst() const { return IsLine() || IsNoLine(); } bool Instruction::IsLine() const { if (opcode() == spv::Op::OpLine) return true; NonSemanticShaderDebugInfo100Instructions ext_opt = GetShader100DebugOpcode(); return ext_opt == NonSemanticShaderDebugInfo100DebugLine; } bool Instruction::IsNoLine() const { if (opcode() == spv::Op::OpNoLine) return true; NonSemanticShaderDebugInfo100Instructions ext_opt = GetShader100DebugOpcode(); return ext_opt == NonSemanticShaderDebugInfo100DebugNoLine; } Instruction* Instruction::InsertBefore(std::unique_ptr&& inst) { inst.get()->InsertBefore(this); return inst.release(); } Instruction* Instruction::InsertBefore( std::vector>&& list) { Instruction* first_node = list.front().get(); for (auto& inst : list) { inst.release()->InsertBefore(this); } list.clear(); return first_node; } bool Instruction::IsValidBasePointer() const { uint32_t tid = type_id(); if (tid == 0) { return false; } Instruction* type = context()->get_def_use_mgr()->GetDef(tid); if (type->opcode() != spv::Op::OpTypePointer) { return false; } auto feature_mgr = context()->get_feature_mgr(); if (feature_mgr->HasCapability(spv::Capability::Addresses)) { // TODO: The rules here could be more restrictive. return true; } if (opcode() == spv::Op::OpVariable || opcode() == spv::Op::OpFunctionParameter) { return true; } // With variable pointers, there are more valid base pointer objects. // Variable pointers implicitly declares Variable pointers storage buffer. spv::StorageClass storage_class = static_cast(type->GetSingleWordInOperand(0)); if ((feature_mgr->HasCapability( spv::Capability::VariablePointersStorageBuffer) && storage_class == spv::StorageClass::StorageBuffer) || (feature_mgr->HasCapability(spv::Capability::VariablePointers) && storage_class == spv::StorageClass::Workgroup)) { switch (opcode()) { case spv::Op::OpPhi: case spv::Op::OpSelect: case spv::Op::OpFunctionCall: case spv::Op::OpConstantNull: return true; default: break; } } uint32_t pointee_type_id = type->GetSingleWordInOperand(1); Instruction* pointee_type_inst = context()->get_def_use_mgr()->GetDef(pointee_type_id); if (pointee_type_inst->IsOpaqueType()) { return true; } return false; } OpenCLDebugInfo100Instructions Instruction::GetOpenCL100DebugOpcode() const { if (opcode() != spv::Op::OpExtInst) { return OpenCLDebugInfo100InstructionsMax; } if (!context()->get_feature_mgr()->GetExtInstImportId_OpenCL100DebugInfo()) { return OpenCLDebugInfo100InstructionsMax; } if (GetSingleWordInOperand(kExtInstSetIdInIdx) != context()->get_feature_mgr()->GetExtInstImportId_OpenCL100DebugInfo()) { return OpenCLDebugInfo100InstructionsMax; } return OpenCLDebugInfo100Instructions( GetSingleWordInOperand(kExtInstInstructionInIdx)); } NonSemanticShaderDebugInfo100Instructions Instruction::GetShader100DebugOpcode() const { if (opcode() != spv::Op::OpExtInst) { return NonSemanticShaderDebugInfo100InstructionsMax; } if (!context()->get_feature_mgr()->GetExtInstImportId_Shader100DebugInfo()) { return NonSemanticShaderDebugInfo100InstructionsMax; } if (GetSingleWordInOperand(kExtInstSetIdInIdx) != context()->get_feature_mgr()->GetExtInstImportId_Shader100DebugInfo()) { return NonSemanticShaderDebugInfo100InstructionsMax; } uint32_t opcode = GetSingleWordInOperand(kExtInstInstructionInIdx); if (opcode >= NonSemanticShaderDebugInfo100InstructionsMax) { return NonSemanticShaderDebugInfo100InstructionsMax; } return NonSemanticShaderDebugInfo100Instructions(opcode); } CommonDebugInfoInstructions Instruction::GetCommonDebugOpcode() const { if (opcode() != spv::Op::OpExtInst) { return CommonDebugInfoInstructionsMax; } const uint32_t opencl_set_id = context()->get_feature_mgr()->GetExtInstImportId_OpenCL100DebugInfo(); const uint32_t shader_set_id = context()->get_feature_mgr()->GetExtInstImportId_Shader100DebugInfo(); if (!opencl_set_id && !shader_set_id) { return CommonDebugInfoInstructionsMax; } const uint32_t used_set_id = GetSingleWordInOperand(kExtInstSetIdInIdx); if (used_set_id != opencl_set_id && used_set_id != shader_set_id) { return CommonDebugInfoInstructionsMax; } return CommonDebugInfoInstructions( GetSingleWordInOperand(kExtInstInstructionInIdx)); } bool Instruction::IsValidBaseImage() const { uint32_t tid = type_id(); if (tid == 0) { return false; } Instruction* type = context()->get_def_use_mgr()->GetDef(tid); return (type->opcode() == spv::Op::OpTypeImage || type->opcode() == spv::Op::OpTypeSampledImage); } bool Instruction::IsOpaqueType() const { if (opcode() == spv::Op::OpTypeStruct) { bool is_opaque = false; ForEachInOperand([&is_opaque, this](const uint32_t* op_id) { Instruction* type_inst = context()->get_def_use_mgr()->GetDef(*op_id); is_opaque |= type_inst->IsOpaqueType(); }); return is_opaque; } else if (opcode() == spv::Op::OpTypeArray) { uint32_t sub_type_id = GetSingleWordInOperand(0); Instruction* sub_type_inst = context()->get_def_use_mgr()->GetDef(sub_type_id); return sub_type_inst->IsOpaqueType(); } else { return opcode() == spv::Op::OpTypeRuntimeArray || spvOpcodeIsBaseOpaqueType(opcode()); } } bool Instruction::IsFoldable() const { return IsFoldableByFoldScalar() || IsFoldableByFoldVector() || context()->get_instruction_folder().HasConstFoldingRule(this); } bool Instruction::IsFoldableByFoldScalar() const { const InstructionFolder& folder = context()->get_instruction_folder(); if (!folder.IsFoldableOpcode(opcode())) { return false; } Instruction* type = context()->get_def_use_mgr()->GetDef(type_id()); if (!folder.IsFoldableScalarType(type)) { return false; } // Even if the type of the instruction is foldable, its operands may not be // foldable (e.g., comparisons of 64bit types). Check that all operand types // are foldable before accepting the instruction. return WhileEachInOperand([&folder, this](const uint32_t* op_id) { Instruction* def_inst = context()->get_def_use_mgr()->GetDef(*op_id); Instruction* def_inst_type = context()->get_def_use_mgr()->GetDef(def_inst->type_id()); return folder.IsFoldableScalarType(def_inst_type); }); } bool Instruction::IsFoldableByFoldVector() const { const InstructionFolder& folder = context()->get_instruction_folder(); if (!folder.IsFoldableOpcode(opcode())) { return false; } Instruction* type = context()->get_def_use_mgr()->GetDef(type_id()); if (!folder.IsFoldableVectorType(type)) { return false; } // Even if the type of the instruction is foldable, its operands may not be // foldable (e.g., comparisons of 64bit types). Check that all operand types // are foldable before accepting the instruction. return WhileEachInOperand([&folder, this](const uint32_t* op_id) { Instruction* def_inst = context()->get_def_use_mgr()->GetDef(*op_id); Instruction* def_inst_type = context()->get_def_use_mgr()->GetDef(def_inst->type_id()); return folder.IsFoldableVectorType(def_inst_type); }); } bool Instruction::IsFloatingPointFoldingAllowed() const { // TODO: Add the rules for kernels. For now it will be pessimistic. // For now, do not support capabilities introduced by SPV_KHR_float_controls. if (!context_->get_feature_mgr()->HasCapability(spv::Capability::Shader) || context_->get_feature_mgr()->HasCapability( spv::Capability::DenormPreserve) || context_->get_feature_mgr()->HasCapability( spv::Capability::DenormFlushToZero) || context_->get_feature_mgr()->HasCapability( spv::Capability::SignedZeroInfNanPreserve) || context_->get_feature_mgr()->HasCapability( spv::Capability::RoundingModeRTZ) || context_->get_feature_mgr()->HasCapability( spv::Capability::RoundingModeRTE)) { return false; } bool is_nocontract = false; context_->get_decoration_mgr()->WhileEachDecoration( result_id(), uint32_t(spv::Decoration::NoContraction), [&is_nocontract](const Instruction&) { is_nocontract = true; return false; }); return !is_nocontract; } std::string Instruction::PrettyPrint(uint32_t options) const { // Convert the module to binary. std::vector module_binary; context()->module()->ToBinary(&module_binary, /* skip_nop = */ false); // Convert the instruction to binary. This is used to identify the correct // stream of words to output from the module. std::vector inst_binary; ToBinaryWithoutAttachedDebugInsts(&inst_binary); // Do not generate a header. return spvInstructionBinaryToText( context()->grammar().target_env(), inst_binary.data(), inst_binary.size(), module_binary.data(), module_binary.size(), options | SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); } std::ostream& operator<<(std::ostream& str, const Instruction& inst) { str << inst.PrettyPrint(); return str; } void Instruction::Dump() const { std::cerr << "Instruction #" << unique_id() << "\n" << *this << "\n"; } bool Instruction::IsOpcodeCodeMotionSafe() const { switch (opcode_) { case spv::Op::OpNop: case spv::Op::OpUndef: case spv::Op::OpLoad: case spv::Op::OpAccessChain: case spv::Op::OpInBoundsAccessChain: case spv::Op::OpArrayLength: case spv::Op::OpVectorExtractDynamic: case spv::Op::OpVectorInsertDynamic: case spv::Op::OpVectorShuffle: case spv::Op::OpCompositeConstruct: case spv::Op::OpCompositeExtract: case spv::Op::OpCompositeInsert: case spv::Op::OpCopyObject: case spv::Op::OpTranspose: case spv::Op::OpConvertFToU: case spv::Op::OpConvertFToS: case spv::Op::OpConvertSToF: case spv::Op::OpConvertUToF: case spv::Op::OpUConvert: case spv::Op::OpSConvert: case spv::Op::OpFConvert: case spv::Op::OpQuantizeToF16: case spv::Op::OpBitcast: case spv::Op::OpSNegate: case spv::Op::OpFNegate: case spv::Op::OpIAdd: case spv::Op::OpFAdd: case spv::Op::OpISub: case spv::Op::OpFSub: case spv::Op::OpIMul: case spv::Op::OpFMul: case spv::Op::OpUDiv: case spv::Op::OpSDiv: case spv::Op::OpFDiv: case spv::Op::OpUMod: case spv::Op::OpSRem: case spv::Op::OpSMod: case spv::Op::OpFRem: case spv::Op::OpFMod: case spv::Op::OpVectorTimesScalar: case spv::Op::OpMatrixTimesScalar: case spv::Op::OpVectorTimesMatrix: case spv::Op::OpMatrixTimesVector: case spv::Op::OpMatrixTimesMatrix: case spv::Op::OpOuterProduct: case spv::Op::OpDot: case spv::Op::OpIAddCarry: case spv::Op::OpISubBorrow: case spv::Op::OpUMulExtended: case spv::Op::OpSMulExtended: case spv::Op::OpAny: case spv::Op::OpAll: case spv::Op::OpIsNan: case spv::Op::OpIsInf: case spv::Op::OpLogicalEqual: case spv::Op::OpLogicalNotEqual: case spv::Op::OpLogicalOr: case spv::Op::OpLogicalAnd: case spv::Op::OpLogicalNot: case spv::Op::OpSelect: case spv::Op::OpIEqual: case spv::Op::OpINotEqual: case spv::Op::OpUGreaterThan: case spv::Op::OpSGreaterThan: case spv::Op::OpUGreaterThanEqual: case spv::Op::OpSGreaterThanEqual: case spv::Op::OpULessThan: case spv::Op::OpSLessThan: case spv::Op::OpULessThanEqual: case spv::Op::OpSLessThanEqual: case spv::Op::OpFOrdEqual: case spv::Op::OpFUnordEqual: case spv::Op::OpFOrdNotEqual: case spv::Op::OpFUnordNotEqual: case spv::Op::OpFOrdLessThan: case spv::Op::OpFUnordLessThan: case spv::Op::OpFOrdGreaterThan: case spv::Op::OpFUnordGreaterThan: case spv::Op::OpFOrdLessThanEqual: case spv::Op::OpFUnordLessThanEqual: case spv::Op::OpFOrdGreaterThanEqual: case spv::Op::OpFUnordGreaterThanEqual: case spv::Op::OpShiftRightLogical: case spv::Op::OpShiftRightArithmetic: case spv::Op::OpShiftLeftLogical: case spv::Op::OpBitwiseOr: case spv::Op::OpBitwiseXor: case spv::Op::OpBitwiseAnd: case spv::Op::OpNot: case spv::Op::OpBitFieldInsert: case spv::Op::OpBitFieldSExtract: case spv::Op::OpBitFieldUExtract: case spv::Op::OpBitReverse: case spv::Op::OpBitCount: case spv::Op::OpSizeOf: return true; default: return false; } } bool Instruction::IsScalarizable() const { if (spvOpcodeIsScalarizable(opcode())) { return true; } if (opcode() == spv::Op::OpExtInst) { uint32_t instSetId = context()->get_feature_mgr()->GetExtInstImportId_GLSLstd450(); if (GetSingleWordInOperand(kExtInstSetIdInIdx) == instSetId) { switch (GetSingleWordInOperand(kExtInstInstructionInIdx)) { case GLSLstd450Round: case GLSLstd450RoundEven: case GLSLstd450Trunc: case GLSLstd450FAbs: case GLSLstd450SAbs: case GLSLstd450FSign: case GLSLstd450SSign: case GLSLstd450Floor: case GLSLstd450Ceil: case GLSLstd450Fract: case GLSLstd450Radians: case GLSLstd450Degrees: case GLSLstd450Sin: case GLSLstd450Cos: case GLSLstd450Tan: case GLSLstd450Asin: case GLSLstd450Acos: case GLSLstd450Atan: case GLSLstd450Sinh: case GLSLstd450Cosh: case GLSLstd450Tanh: case GLSLstd450Asinh: case GLSLstd450Acosh: case GLSLstd450Atanh: case GLSLstd450Atan2: case GLSLstd450Pow: case GLSLstd450Exp: case GLSLstd450Log: case GLSLstd450Exp2: case GLSLstd450Log2: case GLSLstd450Sqrt: case GLSLstd450InverseSqrt: case GLSLstd450Modf: case GLSLstd450FMin: case GLSLstd450UMin: case GLSLstd450SMin: case GLSLstd450FMax: case GLSLstd450UMax: case GLSLstd450SMax: case GLSLstd450FClamp: case GLSLstd450UClamp: case GLSLstd450SClamp: case GLSLstd450FMix: case GLSLstd450Step: case GLSLstd450SmoothStep: case GLSLstd450Fma: case GLSLstd450Frexp: case GLSLstd450Ldexp: case GLSLstd450FindILsb: case GLSLstd450FindSMsb: case GLSLstd450FindUMsb: case GLSLstd450NMin: case GLSLstd450NMax: case GLSLstd450NClamp: return true; default: return false; } } } return false; } bool Instruction::IsOpcodeSafeToDelete() const { if (context()->IsCombinatorInstruction(this)) { return true; } switch (opcode()) { case spv::Op::OpDPdx: case spv::Op::OpDPdy: case spv::Op::OpFwidth: case spv::Op::OpDPdxFine: case spv::Op::OpDPdyFine: case spv::Op::OpFwidthFine: case spv::Op::OpDPdxCoarse: case spv::Op::OpDPdyCoarse: case spv::Op::OpFwidthCoarse: case spv::Op::OpImageQueryLod: return true; default: return false; } } bool Instruction::IsNonSemanticInstruction() const { if (!HasResultId()) return false; if (opcode() != spv::Op::OpExtInst) return false; auto import_inst = context()->get_def_use_mgr()->GetDef(GetSingleWordInOperand(0)); std::string import_name = import_inst->GetInOperand(0).AsString(); return import_name.find("NonSemantic.") == 0; } void DebugScope::ToBinary(uint32_t type_id, uint32_t result_id, uint32_t ext_set, std::vector* binary) const { uint32_t num_words = kDebugScopeNumWords; CommonDebugInfoInstructions dbg_opcode = CommonDebugInfoDebugScope; if (GetLexicalScope() == kNoDebugScope) { num_words = kDebugNoScopeNumWords; dbg_opcode = CommonDebugInfoDebugNoScope; } else if (GetInlinedAt() == kNoInlinedAt) { num_words = kDebugScopeNumWordsWithoutInlinedAt; } std::vector operands = { (num_words << 16) | static_cast(spv::Op::OpExtInst), type_id, result_id, ext_set, static_cast(dbg_opcode), }; binary->insert(binary->end(), operands.begin(), operands.end()); if (GetLexicalScope() != kNoDebugScope) { binary->push_back(GetLexicalScope()); if (GetInlinedAt() != kNoInlinedAt) binary->push_back(GetInlinedAt()); } } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/instruction.h000066400000000000000000001042231475742701700233670ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_INSTRUCTION_H_ #define SOURCE_OPT_INSTRUCTION_H_ #include #include #include #include #include #include #include "NonSemanticShaderDebugInfo100.h" #include "OpenCLDebugInfo100.h" #include "source/binary.h" #include "source/common_debug_info.h" #include "source/latest_version_glsl_std_450_header.h" #include "source/latest_version_spirv_header.h" #include "source/opcode.h" #include "source/operand.h" #include "source/opt/reflect.h" #include "source/util/ilist_node.h" #include "source/util/small_vector.h" #include "source/util/string_utils.h" #include "spirv-tools/libspirv.h" constexpr uint32_t kNoDebugScope = 0; constexpr uint32_t kNoInlinedAt = 0; namespace spvtools { namespace opt { class Function; class IRContext; class Module; class InstructionList; // Relaxed logical addressing: // // In the logical addressing model, pointers cannot be stored or loaded. This // is a useful assumption because it simplifies the aliasing significantly. // However, for the purpose of legalizing code generated from HLSL, we will have // to allow storing and loading of pointers to opaque objects and runtime // arrays. This relaxation of the rule still implies that function and private // scope variables do not have any aliasing, so we can treat them as before. // This will be call the relaxed logical addressing model. // // This relaxation of the rule will be allowed by |GetBaseAddress|, but it will // enforce that no other pointers are stored or loaded. // About operand: // // In the SPIR-V specification, the term "operand" is used to mean any single // SPIR-V word following the leading wordcount-opcode word. Here, the term // "operand" is used to mean a *logical* operand. A logical operand may consist // of multiple SPIR-V words, which together make up the same component. For // example, a logical operand of a 64-bit integer needs two words to express. // // Further, we categorize logical operands into *in* and *out* operands. // In operands are operands actually serve as input to operations, while out // operands are operands that represent ids generated from operations (result // type id or result id). For example, for "OpIAdd %rtype %rid %inop1 %inop2", // "%inop1" and "%inop2" are in operands, while "%rtype" and "%rid" are out // operands. // A *logical* operand to a SPIR-V instruction. It can be the type id, result // id, or other additional operands carried in an instruction. struct Operand { using OperandData = utils::SmallVector; Operand(spv_operand_type_t t, OperandData&& w) : type(t), words(std::move(w)) {} Operand(spv_operand_type_t t, const OperandData& w) : type(t), words(w) {} template Operand(spv_operand_type_t t, InputIt firstOperandData, InputIt lastOperandData) : type(t), words(firstOperandData, lastOperandData) {} spv_operand_type_t type; // Type of this logical operand. OperandData words; // Binary segments of this logical operand. uint32_t AsId() const { assert(spvIsIdType(type)); assert(words.size() == 1); return words[0]; } // Returns a string operand as a std::string. std::string AsString() const { assert(type == SPV_OPERAND_TYPE_LITERAL_STRING); return spvtools::utils::MakeString(words); } // Returns a literal integer operand as a uint64_t uint64_t AsLiteralUint64() const { assert(type == SPV_OPERAND_TYPE_LITERAL_INTEGER || type == SPV_OPERAND_TYPE_TYPED_LITERAL_NUMBER || type == SPV_OPERAND_TYPE_OPTIONAL_LITERAL_INTEGER || type == SPV_OPERAND_TYPE_OPTIONAL_TYPED_LITERAL_INTEGER); assert(1 <= words.size()); assert(words.size() <= 2); uint64_t result = 0; if (words.size() > 0) { // Needed to avoid maybe-uninitialized GCC warning uint32_t low = words[0]; result = uint64_t(low); } if (words.size() > 1) { uint32_t high = words[1]; result = result | (uint64_t(high) << 32); } return result; } friend bool operator==(const Operand& o1, const Operand& o2) { return o1.type == o2.type && o1.words == o2.words; } // TODO(antiagainst): create fields for literal number kind, width, etc. }; inline bool operator!=(const Operand& o1, const Operand& o2) { return !(o1 == o2); } // This structure is used to represent a DebugScope instruction from // the OpenCL.100.DebugInfo extended instruction set. Note that we can // ignore the result id of DebugScope instruction because it is not // used for anything. We do not keep it to reduce the size of // structure. // TODO: Let validator check that the result id is not used anywhere. class DebugScope { public: DebugScope(uint32_t lexical_scope, uint32_t inlined_at) : lexical_scope_(lexical_scope), inlined_at_(inlined_at) {} inline bool operator!=(const DebugScope& d) const { return lexical_scope_ != d.lexical_scope_ || inlined_at_ != d.inlined_at_; } // Accessor functions for |lexical_scope_|. uint32_t GetLexicalScope() const { return lexical_scope_; } void SetLexicalScope(uint32_t scope) { lexical_scope_ = scope; } // Accessor functions for |inlined_at_|. uint32_t GetInlinedAt() const { return inlined_at_; } void SetInlinedAt(uint32_t at) { inlined_at_ = at; } // Pushes the binary segments for this DebugScope instruction into // the back of *|binary|. void ToBinary(uint32_t type_id, uint32_t result_id, uint32_t ext_set, std::vector* binary) const; private: // The result id of the lexical scope in which this debug scope is // contained. The value is kNoDebugScope if there is no scope. uint32_t lexical_scope_; // The result id of DebugInlinedAt if instruction in this debug scope // is inlined. The value is kNoInlinedAt if it is not inlined. uint32_t inlined_at_; }; // A SPIR-V instruction. It contains the opcode and any additional logical // operand, including the result id (if any) and result type id (if any). It // may also contain line-related debug instruction (OpLine, OpNoLine) directly // appearing before this instruction. Note that the result id of an instruction // should never change after the instruction being built. If the result id // needs to change, the user should create a new instruction instead. class Instruction : public utils::IntrusiveNodeBase { public: using OperandList = std::vector; using iterator = OperandList::iterator; using const_iterator = OperandList::const_iterator; // Creates a default OpNop instruction. // This exists solely for containers that can't do without. Should be removed. Instruction() : utils::IntrusiveNodeBase(), context_(nullptr), opcode_(spv::Op::OpNop), has_type_id_(false), has_result_id_(false), unique_id_(0), dbg_scope_(kNoDebugScope, kNoInlinedAt) {} // Creates a default OpNop instruction. Instruction(IRContext*); // Creates an instruction with the given opcode |op| and no additional logical // operands. Instruction(IRContext*, spv::Op); // Creates an instruction using the given spv_parsed_instruction_t |inst|. All // the data inside |inst| will be copied and owned in this instance. And keep // record of line-related debug instructions |dbg_line| ahead of this // instruction, if any. Instruction(IRContext* c, const spv_parsed_instruction_t& inst, std::vector&& dbg_line = {}); Instruction(IRContext* c, const spv_parsed_instruction_t& inst, const DebugScope& dbg_scope); // Creates an instruction with the given opcode |op|, type id: |ty_id|, // result id: |res_id| and input operands: |in_operands|. Instruction(IRContext* c, spv::Op op, uint32_t ty_id, uint32_t res_id, const OperandList& in_operands); // TODO: I will want to remove these, but will first have to remove the use of // std::vector. Instruction(const Instruction&) = default; Instruction& operator=(const Instruction&) = default; Instruction(Instruction&&); Instruction& operator=(Instruction&&); ~Instruction() override = default; // Returns a newly allocated instruction that has the same operands, result, // and type as |this|. The new instruction is not linked into any list. // It is the responsibility of the caller to make sure that the storage is // removed. It is the caller's responsibility to make sure that there is only // one instruction for each result id. Instruction* Clone(IRContext* c) const; IRContext* context() const { return context_; } spv::Op opcode() const { return opcode_; } // Sets the opcode of this instruction to a specific opcode. Note this may // invalidate the instruction. // TODO(qining): Remove this function when instruction building and insertion // is well implemented. void SetOpcode(spv::Op op) { opcode_ = op; } uint32_t type_id() const { return has_type_id_ ? GetSingleWordOperand(0) : 0; } uint32_t result_id() const { return has_result_id_ ? GetSingleWordOperand(has_type_id_ ? 1 : 0) : 0; } uint32_t unique_id() const { assert(unique_id_ != 0); return unique_id_; } // Returns the vector of line-related debug instructions attached to this // instruction and the caller can directly modify them. std::vector& dbg_line_insts() { return dbg_line_insts_; } const std::vector& dbg_line_insts() const { return dbg_line_insts_; } const Instruction* dbg_line_inst() const { return dbg_line_insts_.empty() ? nullptr : &dbg_line_insts_[0]; } // Clear line-related debug instructions attached to this instruction. void clear_dbg_line_insts() { dbg_line_insts_.clear(); } // Same semantics as in the base class except the list the InstructionList // containing |pos| will now assume ownership of |this|. // inline void MoveBefore(Instruction* pos); // inline void InsertAfter(Instruction* pos); // Begin and end iterators for operands. iterator begin() { return operands_.begin(); } iterator end() { return operands_.end(); } const_iterator begin() const { return operands_.cbegin(); } const_iterator end() const { return operands_.cend(); } // Const begin and end iterators for operands. const_iterator cbegin() const { return operands_.cbegin(); } const_iterator cend() const { return operands_.cend(); } // Gets the number of logical operands. uint32_t NumOperands() const { return static_cast(operands_.size()); } // Gets the number of SPIR-V words occupied by all logical operands. uint32_t NumOperandWords() const { return NumInOperandWords() + TypeResultIdCount(); } // Gets the |index|-th logical operand. inline Operand& GetOperand(uint32_t index); inline const Operand& GetOperand(uint32_t index) const; // Adds |operand| to the list of operands of this instruction. // It is the responsibility of the caller to make sure // that the instruction remains valid. inline void AddOperand(Operand&& operand); // Adds a copy of |operand| to the list of operands of this instruction. inline void AddOperand(const Operand& operand); // Gets the |index|-th logical operand as a single SPIR-V word. This method is // not expected to be used with logical operands consisting of multiple SPIR-V // words. uint32_t GetSingleWordOperand(uint32_t index) const; // Sets the |index|-th in-operand's data to the given |data|. inline void SetInOperand(uint32_t index, Operand::OperandData&& data); // Sets the |index|-th operand's data to the given |data|. // This is for in-operands modification only, but with |index| expressed in // terms of operand index rather than in-operand index. inline void SetOperand(uint32_t index, Operand::OperandData&& data); // Replace all of the in operands with those in |new_operands|. inline void SetInOperands(OperandList&& new_operands); // Sets the result type id. inline void SetResultType(uint32_t ty_id); inline bool HasResultType() const { return has_type_id_; } // Sets the result id inline void SetResultId(uint32_t res_id); inline bool HasResultId() const { return has_result_id_; } // Sets DebugScope. inline void SetDebugScope(const DebugScope& scope); inline const DebugScope& GetDebugScope() const { return dbg_scope_; } // Add debug line inst. Renew result id if Debug[No]Line void AddDebugLine(const Instruction* inst); // Updates DebugInlinedAt of DebugScope and OpLine. void UpdateDebugInlinedAt(uint32_t new_inlined_at); // Clear line-related debug instructions attached to this instruction // along with def-use entries. void ClearDbgLineInsts(); // Return true if Shader100:Debug[No]Line bool IsDebugLineInst() const; // Return true if Op[No]Line or Shader100:Debug[No]Line bool IsLineInst() const; // Return true if OpLine or Shader100:DebugLine bool IsLine() const; // Return true if OpNoLine or Shader100:DebugNoLine bool IsNoLine() const; inline uint32_t GetDebugInlinedAt() const { return dbg_scope_.GetInlinedAt(); } // Updates lexical scope of DebugScope and OpLine. void UpdateLexicalScope(uint32_t scope); // Updates OpLine and DebugScope based on the information of |from|. void UpdateDebugInfoFrom(const Instruction* from); // Remove the |index|-th operand void RemoveOperand(uint32_t index) { operands_.erase(operands_.begin() + index); } // Insert an operand before the |index|-th operand void InsertOperand(uint32_t index, Operand&& operand) { operands_.insert(operands_.begin() + index, operand); } // The following methods are similar to the above, but are for in operands. uint32_t NumInOperands() const { return static_cast(operands_.size() - TypeResultIdCount()); } uint32_t NumInOperandWords() const; Operand& GetInOperand(uint32_t index) { return GetOperand(index + TypeResultIdCount()); } const Operand& GetInOperand(uint32_t index) const { return GetOperand(index + TypeResultIdCount()); } uint32_t GetSingleWordInOperand(uint32_t index) const { return GetSingleWordOperand(index + TypeResultIdCount()); } void RemoveInOperand(uint32_t index) { operands_.erase(operands_.begin() + index + TypeResultIdCount()); } // Returns true if this instruction is OpNop. inline bool IsNop() const; // Turns this instruction to OpNop. This does not clear out all preceding // line-related debug instructions. inline void ToNop(); // Runs the given function |f| on this instruction and optionally on the // preceding debug line instructions. The function will always be run // if this is itself a debug line instruction. inline void ForEachInst(const std::function& f, bool run_on_debug_line_insts = false); inline void ForEachInst(const std::function& f, bool run_on_debug_line_insts = false) const; // Runs the given function |f| on this instruction and optionally on the // preceding debug line instructions. The function will always be run // if this is itself a debug line instruction. If |f| returns false, // iteration is terminated and this function returns false. inline bool WhileEachInst(const std::function& f, bool run_on_debug_line_insts = false); inline bool WhileEachInst(const std::function& f, bool run_on_debug_line_insts = false) const; // Runs the given function |f| on all operand ids. // // |f| should not transform an ID into 0, as 0 is an invalid ID. inline void ForEachId(const std::function& f); inline void ForEachId(const std::function& f) const; // Runs the given function |f| on all "in" operand ids. inline void ForEachInId(const std::function& f); inline void ForEachInId(const std::function& f) const; // Runs the given function |f| on all "in" operand ids. If |f| returns false, // iteration is terminated and this function returns false. inline bool WhileEachInId(const std::function& f); inline bool WhileEachInId( const std::function& f) const; // Runs the given function |f| on all "in" operands. inline void ForEachInOperand(const std::function& f); inline void ForEachInOperand( const std::function& f) const; // Runs the given function |f| on all "in" operands. If |f| returns false, // iteration is terminated and this function return false. inline bool WhileEachInOperand(const std::function& f); inline bool WhileEachInOperand( const std::function& f) const; // Returns true if it's an OpBranchConditional instruction // with branch weights. bool HasBranchWeights() const; // Returns true if any operands can be labels inline bool HasLabels() const; // Pushes the binary segments for this instruction into the back of *|binary|. void ToBinaryWithoutAttachedDebugInsts(std::vector* binary) const; // Replaces the operands to the instruction with |new_operands|. The caller // is responsible for building a complete and valid list of operands for // this instruction. void ReplaceOperands(const OperandList& new_operands); // Returns true if the instruction annotates an id with a decoration. inline bool IsDecoration() const; // Returns true if the instruction is known to be a load from read-only // memory. bool IsReadOnlyLoad() const; // Returns the instruction that gives the base address of an address // calculation. The instruction must be a load, as defined by |IsLoad|, // store, copy, or access chain instruction. In logical addressing mode, will // return an OpVariable or OpFunctionParameter instruction. For relaxed // logical addressing, it would also return a load of a pointer to an opaque // object. For physical addressing mode, could return other types of // instructions. Instruction* GetBaseAddress() const; // Returns true if the instruction loads from memory or samples an image, and // stores the result into an id. It considers only core instructions. // Memory-to-memory instructions are not considered loads. inline bool IsLoad() const; // Returns true if the instruction generates a pointer that is definitely // read-only. This is determined by analysing the pointer type's storage // class and decorations that target the pointer's id. It does not analyse // other instructions that the pointer may be derived from. Thus if 'true' is // returned, the pointer is definitely read-only, while if 'false' is returned // it is possible that the pointer may actually be read-only if it is derived // from another pointer that is decorated as read-only. bool IsReadOnlyPointer() const; // The following functions check for the various descriptor types defined in // the Vulkan specification section 13.1. // Returns true if the instruction defines a pointer type that points to a // storage image. bool IsVulkanStorageImage() const; // Returns true if the instruction defines a pointer type that points to a // sampled image. bool IsVulkanSampledImage() const; // Returns true if the instruction defines a pointer type that points to a // storage texel buffer. bool IsVulkanStorageTexelBuffer() const; // Returns true if the instruction defines a pointer type that points to a // storage buffer. bool IsVulkanStorageBuffer() const; // Returns true if the instruction defines a variable in StorageBuffer or // Uniform storage class with a pointer type that points to a storage buffer. bool IsVulkanStorageBufferVariable() const; // Returns true if the instruction defines a pointer type that points to a // uniform buffer. bool IsVulkanUniformBuffer() const; // Returns true if the instruction is an atom operation that uses original // value. inline bool IsAtomicWithLoad() const; // Returns true if the instruction is an atom operation. inline bool IsAtomicOp() const; // Returns true if this instruction is a branch or switch instruction (either // conditional or not). bool IsBranch() const { return spvOpcodeIsBranch(opcode()); } // Returns true if this instruction causes the function to finish execution // and return to its caller bool IsReturn() const { return spvOpcodeIsReturn(opcode()); } // Returns true if this instruction exits this function or aborts execution. bool IsReturnOrAbort() const { return spvOpcodeIsReturnOrAbort(opcode()); } // Returns true if this instruction is a basic block terminator. bool IsBlockTerminator() const { return spvOpcodeIsBlockTerminator(opcode()); } // Returns true if |this| is an instruction that define an opaque type. Since // runtime array have similar characteristics they are included as opaque // types. bool IsOpaqueType() const; // Returns true if |this| is an instruction which could be folded into a // constant value. bool IsFoldable() const; // Returns true if |this| is an instruction which could be folded into a // constant value by |FoldScalar|. bool IsFoldableByFoldScalar() const; // Returns true if |this| is an instruction which could be folded into a // constant value by |FoldVector|. bool IsFoldableByFoldVector() const; // Returns true if we are allowed to fold or otherwise manipulate the // instruction that defines |id| in the given context. This includes not // handling NaN values. bool IsFloatingPointFoldingAllowed() const; inline bool operator==(const Instruction&) const; inline bool operator!=(const Instruction&) const; inline bool operator<(const Instruction&) const; // Takes ownership of the instruction owned by |i| and inserts it immediately // before |this|. Returns the inserted instruction. Instruction* InsertBefore(std::unique_ptr&& i); // Takes ownership of the instructions in |list| and inserts them in order // immediately before |this|. Returns the first inserted instruction. // Assumes the list is non-empty. Instruction* InsertBefore(std::vector>&& list); using utils::IntrusiveNodeBase::InsertBefore; // Returns true if |this| is an instruction defining a constant, but not a // Spec constant. inline bool IsConstant() const; // Returns true if |this| is an instruction with an opcode safe to move bool IsOpcodeCodeMotionSafe() const; // Pretty-prints |inst|. // // Provides the disassembly of a specific instruction. Utilizes |inst|'s // context to provide the correct interpretation of types, constants, etc. // // |options| are the disassembly options. SPV_BINARY_TO_TEXT_OPTION_NO_HEADER // is always added to |options|. std::string PrettyPrint(uint32_t options = 0u) const; // Returns true if the result can be a vector and the result of each component // depends on the corresponding component of any vector inputs. bool IsScalarizable() const; // Return true if the only effect of this instructions is the result. bool IsOpcodeSafeToDelete() const; // Returns true if it is valid to use the result of |inst| as the base // pointer for a load or store. In this case, valid is defined by the relaxed // logical addressing rules when using logical addressing. Normal validation // rules for physical addressing. bool IsValidBasePointer() const; // Returns debug opcode of an OpenCL.100.DebugInfo instruction. If // it is not an OpenCL.100.DebugInfo instruction, just returns // OpenCLDebugInfo100InstructionsMax. OpenCLDebugInfo100Instructions GetOpenCL100DebugOpcode() const; // Returns debug opcode of an NonSemantic.Shader.DebugInfo.100 instruction. If // it is not an NonSemantic.Shader.DebugInfo.100 instruction, just return // NonSemanticShaderDebugInfo100InstructionsMax. NonSemanticShaderDebugInfo100Instructions GetShader100DebugOpcode() const; // Returns debug opcode of an OpenCL.100.DebugInfo or // NonSemantic.Shader.DebugInfo.100 instruction. Since these overlap, we // return the OpenCLDebugInfo code CommonDebugInfoInstructions GetCommonDebugOpcode() const; // Returns true if it is an OpenCL.DebugInfo.100 instruction. bool IsOpenCL100DebugInstr() const { return GetOpenCL100DebugOpcode() != OpenCLDebugInfo100InstructionsMax; } // Returns true if it is an NonSemantic.Shader.DebugInfo.100 instruction. bool IsShader100DebugInstr() const { return GetShader100DebugOpcode() != NonSemanticShaderDebugInfo100InstructionsMax; } bool IsCommonDebugInstr() const { return GetCommonDebugOpcode() != CommonDebugInfoInstructionsMax; } // Returns true if this instructions a non-semantic instruction. bool IsNonSemanticInstruction() const; // Dump this instruction on stderr. Useful when running interactive // debuggers. void Dump() const; private: // Returns the total count of result type id and result id. uint32_t TypeResultIdCount() const { if (has_type_id_ && has_result_id_) return 2; if (has_type_id_ || has_result_id_) return 1; return 0; } // Returns true if the instruction generates a read-only pointer, with the // same caveats documented in the comment for IsReadOnlyPointer. The first // version assumes the module is a shader module. The second assumes a // kernel. bool IsReadOnlyPointerShaders() const; bool IsReadOnlyPointerKernel() const; // Returns true if the result of |inst| can be used as the base image for an // instruction that samples a image, reads an image, or writes to an image. bool IsValidBaseImage() const; IRContext* context_; // IR Context spv::Op opcode_; // Opcode bool has_type_id_; // True if the instruction has a type id bool has_result_id_; // True if the instruction has a result id uint32_t unique_id_; // Unique instruction id // All logical operands, including result type id and result id. OperandList operands_; // Op[No]Line or Debug[No]Line instructions preceding this instruction. Note // that for Instructions representing Op[No]Line or Debug[No]Line themselves, // this field should be empty. std::vector dbg_line_insts_; // DebugScope that wraps this instruction. DebugScope dbg_scope_; friend InstructionList; }; // Pretty-prints |inst| to |str| and returns |str|. // // Provides the disassembly of a specific instruction. Utilizes |inst|'s context // to provide the correct interpretation of types, constants, etc. // // Disassembly uses raw ids (not pretty printed names). std::ostream& operator<<(std::ostream& str, const Instruction& inst); inline bool Instruction::operator==(const Instruction& other) const { return unique_id() == other.unique_id(); } inline bool Instruction::operator!=(const Instruction& other) const { return !(*this == other); } inline bool Instruction::operator<(const Instruction& other) const { return unique_id() < other.unique_id(); } inline Operand& Instruction::GetOperand(uint32_t index) { assert(index < operands_.size() && "operand index out of bound"); return operands_[index]; } inline const Operand& Instruction::GetOperand(uint32_t index) const { assert(index < operands_.size() && "operand index out of bound"); return operands_[index]; } inline void Instruction::AddOperand(Operand&& operand) { operands_.push_back(std::move(operand)); } inline void Instruction::AddOperand(const Operand& operand) { operands_.push_back(operand); } inline void Instruction::SetInOperand(uint32_t index, Operand::OperandData&& data) { SetOperand(index + TypeResultIdCount(), std::move(data)); } inline void Instruction::SetOperand(uint32_t index, Operand::OperandData&& data) { assert(index < operands_.size() && "operand index out of bound"); assert(index >= TypeResultIdCount() && "operand is not a in-operand"); operands_[index].words = std::move(data); } inline void Instruction::SetInOperands(OperandList&& new_operands) { // Remove the old in operands. operands_.erase(operands_.begin() + TypeResultIdCount(), operands_.end()); // Add the new in operands. operands_.insert(operands_.end(), new_operands.begin(), new_operands.end()); } inline void Instruction::SetResultId(uint32_t res_id) { // TODO(dsinclair): Allow setting a result id if there wasn't one // previously. Need to make room in the operands_ array to place the result, // and update the has_result_id_ flag. assert(has_result_id_); // TODO(dsinclair): Allow removing the result id. This needs to make sure, // if there was a result id previously to remove it from the operands_ array // and reset the has_result_id_ flag. assert(res_id != 0); auto ridx = has_type_id_ ? 1 : 0; operands_[ridx].words = {res_id}; } inline void Instruction::SetDebugScope(const DebugScope& scope) { dbg_scope_ = scope; for (auto& i : dbg_line_insts_) { i.dbg_scope_ = scope; } } inline void Instruction::SetResultType(uint32_t ty_id) { // TODO(dsinclair): Allow setting a type id if there wasn't one // previously. Need to make room in the operands_ array to place the result, // and update the has_type_id_ flag. assert(has_type_id_); // TODO(dsinclair): Allow removing the type id. This needs to make sure, // if there was a type id previously to remove it from the operands_ array // and reset the has_type_id_ flag. assert(ty_id != 0); operands_.front().words = {ty_id}; } inline bool Instruction::IsNop() const { return opcode_ == spv::Op::OpNop && !has_type_id_ && !has_result_id_ && operands_.empty(); } inline void Instruction::ToNop() { opcode_ = spv::Op::OpNop; has_type_id_ = false; has_result_id_ = false; operands_.clear(); } inline bool Instruction::WhileEachInst( const std::function& f, bool run_on_debug_line_insts) { if (run_on_debug_line_insts) { for (auto& dbg_line : dbg_line_insts_) { if (!f(&dbg_line)) return false; } } return f(this); } inline bool Instruction::WhileEachInst( const std::function& f, bool run_on_debug_line_insts) const { if (run_on_debug_line_insts) { for (auto& dbg_line : dbg_line_insts_) { if (!f(&dbg_line)) return false; } } return f(this); } inline void Instruction::ForEachInst(const std::function& f, bool run_on_debug_line_insts) { WhileEachInst( [&f](Instruction* inst) { f(inst); return true; }, run_on_debug_line_insts); } inline void Instruction::ForEachInst( const std::function& f, bool run_on_debug_line_insts) const { WhileEachInst( [&f](const Instruction* inst) { f(inst); return true; }, run_on_debug_line_insts); } inline void Instruction::ForEachId(const std::function& f) { for (auto& operand : operands_) if (spvIsIdType(operand.type)) f(&operand.words[0]); } inline void Instruction::ForEachId( const std::function& f) const { for (const auto& operand : operands_) if (spvIsIdType(operand.type)) f(&operand.words[0]); } inline bool Instruction::WhileEachInId( const std::function& f) { for (auto& operand : operands_) { if (spvIsInIdType(operand.type) && !f(&operand.words[0])) { return false; } } return true; } inline bool Instruction::WhileEachInId( const std::function& f) const { for (const auto& operand : operands_) { if (spvIsInIdType(operand.type) && !f(&operand.words[0])) { return false; } } return true; } inline void Instruction::ForEachInId(const std::function& f) { WhileEachInId([&f](uint32_t* id) { f(id); return true; }); } inline void Instruction::ForEachInId( const std::function& f) const { WhileEachInId([&f](const uint32_t* id) { f(id); return true; }); } inline bool Instruction::WhileEachInOperand( const std::function& f) { for (auto& operand : operands_) { switch (operand.type) { case SPV_OPERAND_TYPE_RESULT_ID: case SPV_OPERAND_TYPE_TYPE_ID: break; default: if (!f(&operand.words[0])) return false; break; } } return true; } inline bool Instruction::WhileEachInOperand( const std::function& f) const { for (const auto& operand : operands_) { switch (operand.type) { case SPV_OPERAND_TYPE_RESULT_ID: case SPV_OPERAND_TYPE_TYPE_ID: break; default: if (!f(&operand.words[0])) return false; break; } } return true; } inline void Instruction::ForEachInOperand( const std::function& f) { WhileEachInOperand([&f](uint32_t* operand) { f(operand); return true; }); } inline void Instruction::ForEachInOperand( const std::function& f) const { WhileEachInOperand([&f](const uint32_t* operand) { f(operand); return true; }); } inline bool Instruction::HasLabels() const { switch (opcode_) { case spv::Op::OpSelectionMerge: case spv::Op::OpBranch: case spv::Op::OpLoopMerge: case spv::Op::OpBranchConditional: case spv::Op::OpSwitch: case spv::Op::OpPhi: return true; break; default: break; } return false; } bool Instruction::IsDecoration() const { return spvOpcodeIsDecoration(opcode()); } bool Instruction::IsLoad() const { return spvOpcodeIsLoad(opcode()); } bool Instruction::IsAtomicWithLoad() const { return spvOpcodeIsAtomicWithLoad(opcode()); } bool Instruction::IsAtomicOp() const { return spvOpcodeIsAtomicOp(opcode()); } bool Instruction::IsConstant() const { return IsConstantInst(opcode()) && !IsSpecConstantInst(opcode()); } } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_INSTRUCTION_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/instruction_list.cpp000066400000000000000000000022331475742701700247530ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/instruction_list.h" namespace spvtools { namespace opt { InstructionList::iterator InstructionList::iterator::InsertBefore( std::vector>&& list) { Instruction* first_node = list.front().get(); for (auto& i : list) { i.release()->InsertBefore(node_); } list.clear(); return iterator(first_node); } InstructionList::iterator InstructionList::iterator::InsertBefore( std::unique_ptr&& i) { i.get()->InsertBefore(node_); return iterator(i.release()); } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/instruction_list.h000066400000000000000000000115431475742701700244240ustar00rootroot00000000000000 // Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_INSTRUCTION_LIST_H_ #define SOURCE_OPT_INSTRUCTION_LIST_H_ #include #include #include #include #include #include "source/latest_version_spirv_header.h" #include "source/operand.h" #include "source/opt/instruction.h" #include "source/util/ilist.h" #include "spirv-tools/libspirv.h" namespace spvtools { namespace opt { // This class is intended to be the container for Instructions. This container // owns the instructions that are in it. When removing an Instruction from the // list, the caller is assuming responsibility for deleting the storage. // // TODO: Because there are a number of other data structures that will want // pointers to instruction, ownership should probably be moved to the module. // Because of that I have not made the ownership passing in this class fully // explicit. For example, RemoveFromList takes ownership from the list, but // does not return an std::unique_ptr to signal that. When we fully decide on // ownership, this will have to be fixed up one way or the other. class InstructionList : public utils::IntrusiveList { public: InstructionList() = default; InstructionList(InstructionList&& that) : utils::IntrusiveList(std::move(that)) {} InstructionList& operator=(InstructionList&& that) { auto p = static_cast*>(this); *p = std::move(that); return *this; } // Destroy this list and any instructions in the list. inline ~InstructionList() override; class iterator : public utils::IntrusiveList::iterator { public: iterator(const utils::IntrusiveList::iterator& i) : utils::IntrusiveList::iterator(i) {} iterator(Instruction* i) : utils::IntrusiveList::iterator(i) {} iterator& operator++() { utils::IntrusiveList::iterator::operator++(); return *this; } iterator& operator--() { utils::IntrusiveList::iterator::operator--(); return *this; } // DEPRECATED: Please use MoveBefore with an InstructionList instead. // // Moves the nodes in |list| to the list that |this| points to. The // positions of the nodes will be immediately before the element pointed to // by the iterator. The return value will be an iterator pointing to the // first of the newly inserted elements. Ownership of the elements in // |list| is now passed on to |*this|. iterator InsertBefore(std::vector>&& list); // The node |i| will be inserted immediately before |this|. The return value // will be an iterator pointing to the newly inserted node. The owner of // |*i| becomes |*this| iterator InsertBefore(std::unique_ptr&& i); // Removes the node from the list, and deletes the storage. Returns a valid // iterator to the next node. iterator Erase() { iterator_template next_node = *this; ++next_node; node_->RemoveFromList(); delete node_; return next_node; } }; iterator begin() { return utils::IntrusiveList::begin(); } iterator end() { return utils::IntrusiveList::end(); } const_iterator begin() const { return utils::IntrusiveList::begin(); } const_iterator end() const { return utils::IntrusiveList::end(); } void push_back(std::unique_ptr&& inst) { utils::IntrusiveList::push_back(inst.release()); } // Same as in the base class, except it will delete the data as well. inline void clear(); // Runs the given function |f| on the instructions in the list and optionally // on the preceding debug line instructions. inline void ForEachInst(const std::function& f, bool run_on_debug_line_insts) { auto next = begin(); for (auto i = next; i != end(); i = next) { ++next; i->ForEachInst(f, run_on_debug_line_insts); } } }; InstructionList::~InstructionList() { clear(); } void InstructionList::clear() { while (!empty()) { Instruction* inst = &front(); inst->RemoveFromList(); delete inst; } } } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_INSTRUCTION_LIST_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/interface_var_sroa.cpp000066400000000000000000001164461475742701700252070ustar00rootroot00000000000000// Copyright (c) 2022 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/interface_var_sroa.h" #include #include "source/opt/decoration_manager.h" #include "source/opt/def_use_manager.h" #include "source/opt/function.h" #include "source/opt/log.h" #include "source/opt/type_manager.h" #include "source/util/make_unique.h" namespace spvtools { namespace opt { namespace { constexpr uint32_t kOpDecorateDecorationInOperandIndex = 1; constexpr uint32_t kOpDecorateLiteralInOperandIndex = 2; constexpr uint32_t kOpEntryPointInOperandInterface = 3; constexpr uint32_t kOpVariableStorageClassInOperandIndex = 0; constexpr uint32_t kOpTypeArrayElemTypeInOperandIndex = 0; constexpr uint32_t kOpTypeArrayLengthInOperandIndex = 1; constexpr uint32_t kOpTypeMatrixColCountInOperandIndex = 1; constexpr uint32_t kOpTypeMatrixColTypeInOperandIndex = 0; constexpr uint32_t kOpTypePtrTypeInOperandIndex = 1; constexpr uint32_t kOpConstantValueInOperandIndex = 0; // Get the length of the OpTypeArray |array_type|. uint32_t GetArrayLength(analysis::DefUseManager* def_use_mgr, Instruction* array_type) { assert(array_type->opcode() == spv::Op::OpTypeArray); uint32_t const_int_id = array_type->GetSingleWordInOperand(kOpTypeArrayLengthInOperandIndex); Instruction* array_length_inst = def_use_mgr->GetDef(const_int_id); assert(array_length_inst->opcode() == spv::Op::OpConstant); return array_length_inst->GetSingleWordInOperand( kOpConstantValueInOperandIndex); } // Get the element type instruction of the OpTypeArray |array_type|. Instruction* GetArrayElementType(analysis::DefUseManager* def_use_mgr, Instruction* array_type) { assert(array_type->opcode() == spv::Op::OpTypeArray); uint32_t elem_type_id = array_type->GetSingleWordInOperand(kOpTypeArrayElemTypeInOperandIndex); return def_use_mgr->GetDef(elem_type_id); } // Get the column type instruction of the OpTypeMatrix |matrix_type|. Instruction* GetMatrixColumnType(analysis::DefUseManager* def_use_mgr, Instruction* matrix_type) { assert(matrix_type->opcode() == spv::Op::OpTypeMatrix); uint32_t column_type_id = matrix_type->GetSingleWordInOperand(kOpTypeMatrixColTypeInOperandIndex); return def_use_mgr->GetDef(column_type_id); } // Traverses the component type of OpTypeArray or OpTypeMatrix. Repeats it // |depth_to_component| times recursively and returns the component type. // |type_id| is the result id of the OpTypeArray or OpTypeMatrix instruction. uint32_t GetComponentTypeOfArrayMatrix(analysis::DefUseManager* def_use_mgr, uint32_t type_id, uint32_t depth_to_component) { if (depth_to_component == 0) return type_id; Instruction* type_inst = def_use_mgr->GetDef(type_id); if (type_inst->opcode() == spv::Op::OpTypeArray) { uint32_t elem_type_id = type_inst->GetSingleWordInOperand(kOpTypeArrayElemTypeInOperandIndex); return GetComponentTypeOfArrayMatrix(def_use_mgr, elem_type_id, depth_to_component - 1); } assert(type_inst->opcode() == spv::Op::OpTypeMatrix); uint32_t column_type_id = type_inst->GetSingleWordInOperand(kOpTypeMatrixColTypeInOperandIndex); return GetComponentTypeOfArrayMatrix(def_use_mgr, column_type_id, depth_to_component - 1); } // Creates an OpDecorate instruction whose Target is |var_id| and Decoration is // |decoration|. Adds |literal| as an extra operand of the instruction. void CreateDecoration(analysis::DecorationManager* decoration_mgr, uint32_t var_id, spv::Decoration decoration, uint32_t literal) { std::vector operands({ {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {var_id}}, {spv_operand_type_t::SPV_OPERAND_TYPE_DECORATION, {static_cast(decoration)}}, {spv_operand_type_t::SPV_OPERAND_TYPE_LITERAL_INTEGER, {literal}}, }); decoration_mgr->AddDecoration(spv::Op::OpDecorate, std::move(operands)); } // Replaces load instructions with composite construct instructions in all the // users of the loads. |loads_to_composites| is the mapping from each load to // its corresponding OpCompositeConstruct. void ReplaceLoadWithCompositeConstruct( IRContext* context, const std::unordered_map& loads_to_composites) { for (const auto& load_and_composite : loads_to_composites) { Instruction* load = load_and_composite.first; Instruction* composite_construct = load_and_composite.second; std::vector users; context->get_def_use_mgr()->ForEachUse( load, [&users, composite_construct](Instruction* user, uint32_t index) { user->GetOperand(index).words[0] = composite_construct->result_id(); users.push_back(user); }); for (Instruction* user : users) context->get_def_use_mgr()->AnalyzeInstUse(user); } } // Returns the storage class of the instruction |var|. spv::StorageClass GetStorageClass(Instruction* var) { return static_cast( var->GetSingleWordInOperand(kOpVariableStorageClassInOperandIndex)); } } // namespace bool InterfaceVariableScalarReplacement::HasExtraArrayness( Instruction& entry_point, Instruction* var) { spv::ExecutionModel execution_model = static_cast(entry_point.GetSingleWordInOperand(0)); if (execution_model != spv::ExecutionModel::TessellationEvaluation && execution_model != spv::ExecutionModel::TessellationControl) { return false; } if (!context()->get_decoration_mgr()->HasDecoration( var->result_id(), uint32_t(spv::Decoration::Patch))) { if (execution_model == spv::ExecutionModel::TessellationControl) return true; return GetStorageClass(var) != spv::StorageClass::Output; } return false; } bool InterfaceVariableScalarReplacement:: CheckExtraArraynessConflictBetweenEntries(Instruction* interface_var, bool has_extra_arrayness) { if (has_extra_arrayness) { return !ReportErrorIfHasNoExtraArraynessForOtherEntry(interface_var); } return !ReportErrorIfHasExtraArraynessForOtherEntry(interface_var); } bool InterfaceVariableScalarReplacement::GetVariableLocation( Instruction* var, uint32_t* location) { return !context()->get_decoration_mgr()->WhileEachDecoration( var->result_id(), uint32_t(spv::Decoration::Location), [location](const Instruction& inst) { *location = inst.GetSingleWordInOperand(kOpDecorateLiteralInOperandIndex); return false; }); } bool InterfaceVariableScalarReplacement::GetVariableComponent( Instruction* var, uint32_t* component) { return !context()->get_decoration_mgr()->WhileEachDecoration( var->result_id(), uint32_t(spv::Decoration::Component), [component](const Instruction& inst) { *component = inst.GetSingleWordInOperand(kOpDecorateLiteralInOperandIndex); return false; }); } std::vector InterfaceVariableScalarReplacement::CollectInterfaceVariables( Instruction& entry_point) { std::vector interface_vars; for (uint32_t i = kOpEntryPointInOperandInterface; i < entry_point.NumInOperands(); ++i) { Instruction* interface_var = context()->get_def_use_mgr()->GetDef( entry_point.GetSingleWordInOperand(i)); assert(interface_var->opcode() == spv::Op::OpVariable); spv::StorageClass storage_class = GetStorageClass(interface_var); if (storage_class != spv::StorageClass::Input && storage_class != spv::StorageClass::Output) { continue; } interface_vars.push_back(interface_var); } return interface_vars; } void InterfaceVariableScalarReplacement::KillInstructionAndUsers( Instruction* inst) { if (inst->opcode() == spv::Op::OpEntryPoint) { return; } if (inst->opcode() != spv::Op::OpAccessChain) { context()->KillInst(inst); return; } std::vector users; context()->get_def_use_mgr()->ForEachUser( inst, [&users](Instruction* user) { users.push_back(user); }); for (auto user : users) { context()->KillInst(user); } context()->KillInst(inst); } void InterfaceVariableScalarReplacement::KillInstructionsAndUsers( const std::vector& insts) { for (Instruction* inst : insts) { KillInstructionAndUsers(inst); } } void InterfaceVariableScalarReplacement::KillLocationAndComponentDecorations( uint32_t var_id) { context()->get_decoration_mgr()->RemoveDecorationsFrom( var_id, [](const Instruction& inst) { spv::Decoration decoration = spv::Decoration( inst.GetSingleWordInOperand(kOpDecorateDecorationInOperandIndex)); return decoration == spv::Decoration::Location || decoration == spv::Decoration::Component; }); } bool InterfaceVariableScalarReplacement::ReplaceInterfaceVariableWithScalars( Instruction* interface_var, Instruction* interface_var_type, uint32_t location, uint32_t component, uint32_t extra_array_length) { NestedCompositeComponents scalar_interface_vars = CreateScalarInterfaceVarsForReplacement(interface_var_type, GetStorageClass(interface_var), extra_array_length); AddLocationAndComponentDecorations(scalar_interface_vars, &location, component); KillLocationAndComponentDecorations(interface_var->result_id()); if (!ReplaceInterfaceVarWith(interface_var, extra_array_length, scalar_interface_vars)) { return false; } context()->KillInst(interface_var); return true; } bool InterfaceVariableScalarReplacement::ReplaceInterfaceVarWith( Instruction* interface_var, uint32_t extra_array_length, const NestedCompositeComponents& scalar_interface_vars) { std::vector users; context()->get_def_use_mgr()->ForEachUser( interface_var, [&users](Instruction* user) { users.push_back(user); }); std::vector interface_var_component_indices; std::unordered_map loads_to_composites; std::unordered_map loads_for_access_chain_to_composites; if (extra_array_length != 0) { // Note that the extra arrayness is the first dimension of the array // interface variable. for (uint32_t index = 0; index < extra_array_length; ++index) { std::unordered_map loads_to_component_values; if (!ReplaceComponentsOfInterfaceVarWith( interface_var, users, scalar_interface_vars, interface_var_component_indices, &index, &loads_to_component_values, &loads_for_access_chain_to_composites)) { return false; } AddComponentsToCompositesForLoads(loads_to_component_values, &loads_to_composites, 0); } } else if (!ReplaceComponentsOfInterfaceVarWith( interface_var, users, scalar_interface_vars, interface_var_component_indices, nullptr, &loads_to_composites, &loads_for_access_chain_to_composites)) { return false; } ReplaceLoadWithCompositeConstruct(context(), loads_to_composites); ReplaceLoadWithCompositeConstruct(context(), loads_for_access_chain_to_composites); KillInstructionsAndUsers(users); return true; } void InterfaceVariableScalarReplacement::AddLocationAndComponentDecorations( const NestedCompositeComponents& vars, uint32_t* location, uint32_t component) { if (!vars.HasMultipleComponents()) { uint32_t var_id = vars.GetComponentVariable()->result_id(); CreateDecoration(context()->get_decoration_mgr(), var_id, spv::Decoration::Location, *location); CreateDecoration(context()->get_decoration_mgr(), var_id, spv::Decoration::Component, component); ++(*location); return; } for (const auto& var : vars.GetComponents()) { AddLocationAndComponentDecorations(var, location, component); } } bool InterfaceVariableScalarReplacement::ReplaceComponentsOfInterfaceVarWith( Instruction* interface_var, const std::vector& interface_var_users, const NestedCompositeComponents& scalar_interface_vars, std::vector& interface_var_component_indices, const uint32_t* extra_array_index, std::unordered_map* loads_to_composites, std::unordered_map* loads_for_access_chain_to_composites) { if (!scalar_interface_vars.HasMultipleComponents()) { for (Instruction* interface_var_user : interface_var_users) { if (!ReplaceComponentOfInterfaceVarWith( interface_var, interface_var_user, scalar_interface_vars.GetComponentVariable(), interface_var_component_indices, extra_array_index, loads_to_composites, loads_for_access_chain_to_composites)) { return false; } } return true; } return ReplaceMultipleComponentsOfInterfaceVarWith( interface_var, interface_var_users, scalar_interface_vars.GetComponents(), interface_var_component_indices, extra_array_index, loads_to_composites, loads_for_access_chain_to_composites); } bool InterfaceVariableScalarReplacement:: ReplaceMultipleComponentsOfInterfaceVarWith( Instruction* interface_var, const std::vector& interface_var_users, const std::vector& components, std::vector& interface_var_component_indices, const uint32_t* extra_array_index, std::unordered_map* loads_to_composites, std::unordered_map* loads_for_access_chain_to_composites) { for (uint32_t i = 0; i < components.size(); ++i) { interface_var_component_indices.push_back(i); std::unordered_map loads_to_component_values; std::unordered_map loads_for_access_chain_to_component_values; if (!ReplaceComponentsOfInterfaceVarWith( interface_var, interface_var_users, components[i], interface_var_component_indices, extra_array_index, &loads_to_component_values, &loads_for_access_chain_to_component_values)) { return false; } interface_var_component_indices.pop_back(); uint32_t depth_to_component = static_cast(interface_var_component_indices.size()); AddComponentsToCompositesForLoads( loads_for_access_chain_to_component_values, loads_for_access_chain_to_composites, depth_to_component); if (extra_array_index) ++depth_to_component; AddComponentsToCompositesForLoads(loads_to_component_values, loads_to_composites, depth_to_component); } return true; } bool InterfaceVariableScalarReplacement::ReplaceComponentOfInterfaceVarWith( Instruction* interface_var, Instruction* interface_var_user, Instruction* scalar_var, const std::vector& interface_var_component_indices, const uint32_t* extra_array_index, std::unordered_map* loads_to_component_values, std::unordered_map* loads_for_access_chain_to_component_values) { spv::Op opcode = interface_var_user->opcode(); if (opcode == spv::Op::OpStore) { uint32_t value_id = interface_var_user->GetSingleWordInOperand(1); StoreComponentOfValueToScalarVar(value_id, interface_var_component_indices, scalar_var, extra_array_index, interface_var_user); return true; } if (opcode == spv::Op::OpLoad) { Instruction* scalar_load = LoadScalarVar(scalar_var, extra_array_index, interface_var_user); loads_to_component_values->insert({interface_var_user, scalar_load}); return true; } // Copy OpName and annotation instructions only once. Therefore, we create // them only for the first element of the extra array. if (extra_array_index && *extra_array_index != 0) return true; if (opcode == spv::Op::OpDecorateId || opcode == spv::Op::OpDecorateString || opcode == spv::Op::OpDecorate) { CloneAnnotationForVariable(interface_var_user, scalar_var->result_id()); return true; } if (opcode == spv::Op::OpName) { std::unique_ptr new_inst(interface_var_user->Clone(context())); new_inst->SetInOperand(0, {scalar_var->result_id()}); context()->AddDebug2Inst(std::move(new_inst)); return true; } if (opcode == spv::Op::OpEntryPoint) { return ReplaceInterfaceVarInEntryPoint(interface_var, interface_var_user, scalar_var->result_id()); } if (opcode == spv::Op::OpAccessChain) { ReplaceAccessChainWith(interface_var_user, interface_var_component_indices, scalar_var, loads_for_access_chain_to_component_values); return true; } std::string message("Unhandled instruction"); message += "\n " + interface_var_user->PrettyPrint( SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); message += "\nfor interface variable scalar replacement\n " + interface_var->PrettyPrint(SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); context()->consumer()(SPV_MSG_ERROR, "", {0, 0, 0}, message.c_str()); return false; } void InterfaceVariableScalarReplacement::UseBaseAccessChainForAccessChain( Instruction* access_chain, Instruction* base_access_chain) { assert(base_access_chain->opcode() == spv::Op::OpAccessChain && access_chain->opcode() == spv::Op::OpAccessChain && access_chain->GetSingleWordInOperand(0) == base_access_chain->result_id()); Instruction::OperandList new_operands; for (uint32_t i = 0; i < base_access_chain->NumInOperands(); ++i) { new_operands.emplace_back(base_access_chain->GetInOperand(i)); } for (uint32_t i = 1; i < access_chain->NumInOperands(); ++i) { new_operands.emplace_back(access_chain->GetInOperand(i)); } access_chain->SetInOperands(std::move(new_operands)); } Instruction* InterfaceVariableScalarReplacement::CreateAccessChainToVar( uint32_t var_type_id, Instruction* var, const std::vector& index_ids, Instruction* insert_before, uint32_t* component_type_id) { analysis::DefUseManager* def_use_mgr = context()->get_def_use_mgr(); *component_type_id = GetComponentTypeOfArrayMatrix( def_use_mgr, var_type_id, static_cast(index_ids.size())); uint32_t ptr_type_id = GetPointerType(*component_type_id, GetStorageClass(var)); std::unique_ptr new_access_chain(new Instruction( context(), spv::Op::OpAccessChain, ptr_type_id, TakeNextId(), std::initializer_list{ {SPV_OPERAND_TYPE_ID, {var->result_id()}}})); for (uint32_t index_id : index_ids) { new_access_chain->AddOperand({SPV_OPERAND_TYPE_ID, {index_id}}); } Instruction* inst = new_access_chain.get(); def_use_mgr->AnalyzeInstDefUse(inst); insert_before->InsertBefore(std::move(new_access_chain)); return inst; } Instruction* InterfaceVariableScalarReplacement::CreateAccessChainWithIndex( uint32_t component_type_id, Instruction* var, uint32_t index, Instruction* insert_before) { uint32_t ptr_type_id = GetPointerType(component_type_id, GetStorageClass(var)); uint32_t index_id = context()->get_constant_mgr()->GetUIntConstId(index); std::unique_ptr new_access_chain(new Instruction( context(), spv::Op::OpAccessChain, ptr_type_id, TakeNextId(), std::initializer_list{ {SPV_OPERAND_TYPE_ID, {var->result_id()}}, {SPV_OPERAND_TYPE_ID, {index_id}}, })); Instruction* inst = new_access_chain.get(); context()->get_def_use_mgr()->AnalyzeInstDefUse(inst); insert_before->InsertBefore(std::move(new_access_chain)); return inst; } void InterfaceVariableScalarReplacement::ReplaceAccessChainWith( Instruction* access_chain, const std::vector& interface_var_component_indices, Instruction* scalar_var, std::unordered_map* loads_to_component_values) { std::vector indexes; for (uint32_t i = 1; i < access_chain->NumInOperands(); ++i) { indexes.push_back(access_chain->GetSingleWordInOperand(i)); } // Note that we have a strong assumption that |access_chain| has only a single // index that is for the extra arrayness. context()->get_def_use_mgr()->ForEachUser( access_chain, [this, access_chain, &indexes, &interface_var_component_indices, scalar_var, loads_to_component_values](Instruction* user) { switch (user->opcode()) { case spv::Op::OpAccessChain: { UseBaseAccessChainForAccessChain(user, access_chain); ReplaceAccessChainWith(user, interface_var_component_indices, scalar_var, loads_to_component_values); return; } case spv::Op::OpStore: { uint32_t value_id = user->GetSingleWordInOperand(1); StoreComponentOfValueToAccessChainToScalarVar( value_id, interface_var_component_indices, scalar_var, indexes, user); return; } case spv::Op::OpLoad: { Instruction* value = LoadAccessChainToVar(scalar_var, indexes, user); loads_to_component_values->insert({user, value}); return; } default: break; } }); } void InterfaceVariableScalarReplacement::CloneAnnotationForVariable( Instruction* annotation_inst, uint32_t var_id) { assert(annotation_inst->opcode() == spv::Op::OpDecorate || annotation_inst->opcode() == spv::Op::OpDecorateId || annotation_inst->opcode() == spv::Op::OpDecorateString); std::unique_ptr new_inst(annotation_inst->Clone(context())); new_inst->SetInOperand(0, {var_id}); context()->AddAnnotationInst(std::move(new_inst)); } bool InterfaceVariableScalarReplacement::ReplaceInterfaceVarInEntryPoint( Instruction* interface_var, Instruction* entry_point, uint32_t scalar_var_id) { analysis::DefUseManager* def_use_mgr = context()->get_def_use_mgr(); uint32_t interface_var_id = interface_var->result_id(); if (interface_vars_removed_from_entry_point_operands_.find( interface_var_id) != interface_vars_removed_from_entry_point_operands_.end()) { entry_point->AddOperand({SPV_OPERAND_TYPE_ID, {scalar_var_id}}); def_use_mgr->AnalyzeInstUse(entry_point); return true; } bool success = !entry_point->WhileEachInId( [&interface_var_id, &scalar_var_id](uint32_t* id) { if (*id == interface_var_id) { *id = scalar_var_id; return false; } return true; }); if (!success) { std::string message( "interface variable is not an operand of the entry point"); message += "\n " + interface_var->PrettyPrint( SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); message += "\n " + entry_point->PrettyPrint( SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); context()->consumer()(SPV_MSG_ERROR, "", {0, 0, 0}, message.c_str()); return false; } def_use_mgr->AnalyzeInstUse(entry_point); interface_vars_removed_from_entry_point_operands_.insert(interface_var_id); return true; } uint32_t InterfaceVariableScalarReplacement::GetPointeeTypeIdOfVar( Instruction* var) { assert(var->opcode() == spv::Op::OpVariable); uint32_t ptr_type_id = var->type_id(); analysis::DefUseManager* def_use_mgr = context()->get_def_use_mgr(); Instruction* ptr_type_inst = def_use_mgr->GetDef(ptr_type_id); assert(ptr_type_inst->opcode() == spv::Op::OpTypePointer && "Variable must have a pointer type."); return ptr_type_inst->GetSingleWordInOperand(kOpTypePtrTypeInOperandIndex); } void InterfaceVariableScalarReplacement::StoreComponentOfValueToScalarVar( uint32_t value_id, const std::vector& component_indices, Instruction* scalar_var, const uint32_t* extra_array_index, Instruction* insert_before) { uint32_t component_type_id = GetPointeeTypeIdOfVar(scalar_var); Instruction* ptr = scalar_var; if (extra_array_index) { auto* ty_mgr = context()->get_type_mgr(); analysis::Array* array_type = ty_mgr->GetType(component_type_id)->AsArray(); assert(array_type != nullptr); component_type_id = ty_mgr->GetTypeInstruction(array_type->element_type()); ptr = CreateAccessChainWithIndex(component_type_id, scalar_var, *extra_array_index, insert_before); } StoreComponentOfValueTo(component_type_id, value_id, component_indices, ptr, extra_array_index, insert_before); } Instruction* InterfaceVariableScalarReplacement::LoadScalarVar( Instruction* scalar_var, const uint32_t* extra_array_index, Instruction* insert_before) { uint32_t component_type_id = GetPointeeTypeIdOfVar(scalar_var); Instruction* ptr = scalar_var; if (extra_array_index) { auto* ty_mgr = context()->get_type_mgr(); analysis::Array* array_type = ty_mgr->GetType(component_type_id)->AsArray(); assert(array_type != nullptr); component_type_id = ty_mgr->GetTypeInstruction(array_type->element_type()); ptr = CreateAccessChainWithIndex(component_type_id, scalar_var, *extra_array_index, insert_before); } return CreateLoad(component_type_id, ptr, insert_before); } Instruction* InterfaceVariableScalarReplacement::CreateLoad( uint32_t type_id, Instruction* ptr, Instruction* insert_before) { std::unique_ptr load( new Instruction(context(), spv::Op::OpLoad, type_id, TakeNextId(), std::initializer_list{ {SPV_OPERAND_TYPE_ID, {ptr->result_id()}}})); Instruction* load_inst = load.get(); context()->get_def_use_mgr()->AnalyzeInstDefUse(load_inst); insert_before->InsertBefore(std::move(load)); return load_inst; } void InterfaceVariableScalarReplacement::StoreComponentOfValueTo( uint32_t component_type_id, uint32_t value_id, const std::vector& component_indices, Instruction* ptr, const uint32_t* extra_array_index, Instruction* insert_before) { std::unique_ptr composite_extract(CreateCompositeExtract( component_type_id, value_id, component_indices, extra_array_index)); std::unique_ptr new_store( new Instruction(context(), spv::Op::OpStore)); new_store->AddOperand({SPV_OPERAND_TYPE_ID, {ptr->result_id()}}); new_store->AddOperand( {SPV_OPERAND_TYPE_ID, {composite_extract->result_id()}}); analysis::DefUseManager* def_use_mgr = context()->get_def_use_mgr(); def_use_mgr->AnalyzeInstDefUse(composite_extract.get()); def_use_mgr->AnalyzeInstDefUse(new_store.get()); insert_before->InsertBefore(std::move(composite_extract)); insert_before->InsertBefore(std::move(new_store)); } Instruction* InterfaceVariableScalarReplacement::CreateCompositeExtract( uint32_t type_id, uint32_t composite_id, const std::vector& indexes, const uint32_t* extra_first_index) { uint32_t component_id = TakeNextId(); Instruction* composite_extract = new Instruction( context(), spv::Op::OpCompositeExtract, type_id, component_id, std::initializer_list{{SPV_OPERAND_TYPE_ID, {composite_id}}}); if (extra_first_index) { composite_extract->AddOperand( {SPV_OPERAND_TYPE_LITERAL_INTEGER, {*extra_first_index}}); } for (uint32_t index : indexes) { composite_extract->AddOperand({SPV_OPERAND_TYPE_LITERAL_INTEGER, {index}}); } return composite_extract; } void InterfaceVariableScalarReplacement:: StoreComponentOfValueToAccessChainToScalarVar( uint32_t value_id, const std::vector& component_indices, Instruction* scalar_var, const std::vector& access_chain_indices, Instruction* insert_before) { uint32_t component_type_id = GetPointeeTypeIdOfVar(scalar_var); Instruction* ptr = scalar_var; if (!access_chain_indices.empty()) { ptr = CreateAccessChainToVar(component_type_id, scalar_var, access_chain_indices, insert_before, &component_type_id); } StoreComponentOfValueTo(component_type_id, value_id, component_indices, ptr, nullptr, insert_before); } Instruction* InterfaceVariableScalarReplacement::LoadAccessChainToVar( Instruction* var, const std::vector& indexes, Instruction* insert_before) { uint32_t component_type_id = GetPointeeTypeIdOfVar(var); Instruction* ptr = var; if (!indexes.empty()) { ptr = CreateAccessChainToVar(component_type_id, var, indexes, insert_before, &component_type_id); } return CreateLoad(component_type_id, ptr, insert_before); } Instruction* InterfaceVariableScalarReplacement::CreateCompositeConstructForComponentOfLoad( Instruction* load, uint32_t depth_to_component) { analysis::DefUseManager* def_use_mgr = context()->get_def_use_mgr(); uint32_t type_id = load->type_id(); if (depth_to_component != 0) { type_id = GetComponentTypeOfArrayMatrix(def_use_mgr, load->type_id(), depth_to_component); } uint32_t new_id = context()->TakeNextId(); std::unique_ptr new_composite_construct(new Instruction( context(), spv::Op::OpCompositeConstruct, type_id, new_id, {})); Instruction* composite_construct = new_composite_construct.get(); def_use_mgr->AnalyzeInstDefUse(composite_construct); // Insert |new_composite_construct| after |load|. When there are multiple // recursive composite construct instructions for a load, we have to place the // composite construct with a lower depth later because it constructs the // composite that contains other composites with lower depths. auto* insert_before = load->NextNode(); while (true) { auto itr = composite_ids_to_component_depths.find(insert_before->result_id()); if (itr == composite_ids_to_component_depths.end()) break; if (itr->second <= depth_to_component) break; insert_before = insert_before->NextNode(); } insert_before->InsertBefore(std::move(new_composite_construct)); composite_ids_to_component_depths.insert({new_id, depth_to_component}); return composite_construct; } void InterfaceVariableScalarReplacement::AddComponentsToCompositesForLoads( const std::unordered_map& loads_to_component_values, std::unordered_map* loads_to_composites, uint32_t depth_to_component) { analysis::DefUseManager* def_use_mgr = context()->get_def_use_mgr(); for (auto& load_and_component_vale : loads_to_component_values) { Instruction* load = load_and_component_vale.first; Instruction* component_value = load_and_component_vale.second; Instruction* composite_construct = nullptr; auto itr = loads_to_composites->find(load); if (itr == loads_to_composites->end()) { composite_construct = CreateCompositeConstructForComponentOfLoad(load, depth_to_component); loads_to_composites->insert({load, composite_construct}); } else { composite_construct = itr->second; } composite_construct->AddOperand( {SPV_OPERAND_TYPE_ID, {component_value->result_id()}}); def_use_mgr->AnalyzeInstDefUse(composite_construct); } } uint32_t InterfaceVariableScalarReplacement::GetArrayType( uint32_t elem_type_id, uint32_t array_length) { analysis::Type* elem_type = context()->get_type_mgr()->GetType(elem_type_id); uint32_t array_length_id = context()->get_constant_mgr()->GetUIntConstId(array_length); analysis::Array array_type( elem_type, analysis::Array::LengthInfo{array_length_id, {0, array_length}}); return context()->get_type_mgr()->GetTypeInstruction(&array_type); } uint32_t InterfaceVariableScalarReplacement::GetPointerType( uint32_t type_id, spv::StorageClass storage_class) { analysis::Type* type = context()->get_type_mgr()->GetType(type_id); analysis::Pointer ptr_type(type, storage_class); return context()->get_type_mgr()->GetTypeInstruction(&ptr_type); } InterfaceVariableScalarReplacement::NestedCompositeComponents InterfaceVariableScalarReplacement::CreateScalarInterfaceVarsForArray( Instruction* interface_var_type, spv::StorageClass storage_class, uint32_t extra_array_length) { assert(interface_var_type->opcode() == spv::Op::OpTypeArray); analysis::DefUseManager* def_use_mgr = context()->get_def_use_mgr(); uint32_t array_length = GetArrayLength(def_use_mgr, interface_var_type); Instruction* elem_type = GetArrayElementType(def_use_mgr, interface_var_type); NestedCompositeComponents scalar_vars; while (array_length > 0) { NestedCompositeComponents scalar_vars_for_element = CreateScalarInterfaceVarsForReplacement(elem_type, storage_class, extra_array_length); scalar_vars.AddComponent(scalar_vars_for_element); --array_length; } return scalar_vars; } InterfaceVariableScalarReplacement::NestedCompositeComponents InterfaceVariableScalarReplacement::CreateScalarInterfaceVarsForMatrix( Instruction* interface_var_type, spv::StorageClass storage_class, uint32_t extra_array_length) { assert(interface_var_type->opcode() == spv::Op::OpTypeMatrix); analysis::DefUseManager* def_use_mgr = context()->get_def_use_mgr(); uint32_t column_count = interface_var_type->GetSingleWordInOperand( kOpTypeMatrixColCountInOperandIndex); Instruction* column_type = GetMatrixColumnType(def_use_mgr, interface_var_type); NestedCompositeComponents scalar_vars; while (column_count > 0) { NestedCompositeComponents scalar_vars_for_column = CreateScalarInterfaceVarsForReplacement(column_type, storage_class, extra_array_length); scalar_vars.AddComponent(scalar_vars_for_column); --column_count; } return scalar_vars; } InterfaceVariableScalarReplacement::NestedCompositeComponents InterfaceVariableScalarReplacement::CreateScalarInterfaceVarsForReplacement( Instruction* interface_var_type, spv::StorageClass storage_class, uint32_t extra_array_length) { // Handle array case. if (interface_var_type->opcode() == spv::Op::OpTypeArray) { return CreateScalarInterfaceVarsForArray(interface_var_type, storage_class, extra_array_length); } // Handle matrix case. if (interface_var_type->opcode() == spv::Op::OpTypeMatrix) { return CreateScalarInterfaceVarsForMatrix(interface_var_type, storage_class, extra_array_length); } // Handle scalar or vector case. NestedCompositeComponents scalar_var; uint32_t type_id = interface_var_type->result_id(); if (extra_array_length != 0) { type_id = GetArrayType(type_id, extra_array_length); } uint32_t ptr_type_id = context()->get_type_mgr()->FindPointerToType(type_id, storage_class); uint32_t id = TakeNextId(); std::unique_ptr variable( new Instruction(context(), spv::Op::OpVariable, ptr_type_id, id, std::initializer_list{ {SPV_OPERAND_TYPE_STORAGE_CLASS, {static_cast(storage_class)}}})); scalar_var.SetSingleComponentVariable(variable.get()); context()->AddGlobalValue(std::move(variable)); return scalar_var; } Instruction* InterfaceVariableScalarReplacement::GetTypeOfVariable( Instruction* var) { uint32_t pointee_type_id = GetPointeeTypeIdOfVar(var); analysis::DefUseManager* def_use_mgr = context()->get_def_use_mgr(); return def_use_mgr->GetDef(pointee_type_id); } Pass::Status InterfaceVariableScalarReplacement::Process() { Pass::Status status = Status::SuccessWithoutChange; for (Instruction& entry_point : get_module()->entry_points()) { status = CombineStatus(status, ReplaceInterfaceVarsWithScalars(entry_point)); } return status; } bool InterfaceVariableScalarReplacement:: ReportErrorIfHasExtraArraynessForOtherEntry(Instruction* var) { if (vars_with_extra_arrayness.find(var) == vars_with_extra_arrayness.end()) return false; std::string message( "A variable is arrayed for an entry point but it is not " "arrayed for another entry point"); message += "\n " + var->PrettyPrint(SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); context()->consumer()(SPV_MSG_ERROR, "", {0, 0, 0}, message.c_str()); return true; } bool InterfaceVariableScalarReplacement:: ReportErrorIfHasNoExtraArraynessForOtherEntry(Instruction* var) { if (vars_without_extra_arrayness.find(var) == vars_without_extra_arrayness.end()) return false; std::string message( "A variable is not arrayed for an entry point but it is " "arrayed for another entry point"); message += "\n " + var->PrettyPrint(SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); context()->consumer()(SPV_MSG_ERROR, "", {0, 0, 0}, message.c_str()); return true; } Pass::Status InterfaceVariableScalarReplacement::ReplaceInterfaceVarsWithScalars( Instruction& entry_point) { std::vector interface_vars = CollectInterfaceVariables(entry_point); Pass::Status status = Status::SuccessWithoutChange; for (Instruction* interface_var : interface_vars) { uint32_t location, component; if (!GetVariableLocation(interface_var, &location)) continue; if (!GetVariableComponent(interface_var, &component)) component = 0; Instruction* interface_var_type = GetTypeOfVariable(interface_var); uint32_t extra_array_length = 0; if (HasExtraArrayness(entry_point, interface_var)) { extra_array_length = GetArrayLength(context()->get_def_use_mgr(), interface_var_type); interface_var_type = GetArrayElementType(context()->get_def_use_mgr(), interface_var_type); vars_with_extra_arrayness.insert(interface_var); } else { vars_without_extra_arrayness.insert(interface_var); } if (!CheckExtraArraynessConflictBetweenEntries(interface_var, extra_array_length != 0)) { return Pass::Status::Failure; } if (interface_var_type->opcode() != spv::Op::OpTypeArray && interface_var_type->opcode() != spv::Op::OpTypeMatrix) { continue; } if (!ReplaceInterfaceVariableWithScalars(interface_var, interface_var_type, location, component, extra_array_length)) { return Pass::Status::Failure; } status = Pass::Status::SuccessWithChange; } return status; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/interface_var_sroa.h000066400000000000000000000471001475742701700246420ustar00rootroot00000000000000// Copyright (c) 2022 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_INTERFACE_VAR_SROA_H_ #define SOURCE_OPT_INTERFACE_VAR_SROA_H_ #include #include "source/opt/pass.h" namespace spvtools { namespace opt { // See optimizer.hpp for documentation. // // Note that the current implementation of this pass covers only store, load, // access chain instructions for the interface variables. Supporting other types // of instructions is a future work. class InterfaceVariableScalarReplacement : public Pass { public: InterfaceVariableScalarReplacement() {} const char* name() const override { return "interface-variable-scalar-replacement"; } Status Process() override; IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisDecorations | IRContext::kAnalysisDefUse | IRContext::kAnalysisConstants | IRContext::kAnalysisTypes; } private: // A struct containing components of a composite variable. If the composite // consists of multiple or recursive components, |component_variable| is // nullptr and |nested_composite_components| keeps the components. If it has a // single component, |nested_composite_components| is empty and // |component_variable| is the component. Note that each element of // |nested_composite_components| has the NestedCompositeComponents struct as // its type that can recursively keep the components. struct NestedCompositeComponents { NestedCompositeComponents() : component_variable(nullptr) {} bool HasMultipleComponents() const { return !nested_composite_components.empty(); } const std::vector& GetComponents() const { return nested_composite_components; } void AddComponent(const NestedCompositeComponents& component) { nested_composite_components.push_back(component); } Instruction* GetComponentVariable() const { return component_variable; } void SetSingleComponentVariable(Instruction* var) { component_variable = var; } private: std::vector nested_composite_components; Instruction* component_variable; }; // Collects all interface variables used by the |entry_point|. std::vector CollectInterfaceVariables(Instruction& entry_point); // Returns whether |var| has the extra arrayness for the entry point // |entry_point| or not. bool HasExtraArrayness(Instruction& entry_point, Instruction* var); // Finds a Location BuiltIn decoration of |var| and returns it via // |location|. Returns true whether the location exists or not. bool GetVariableLocation(Instruction* var, uint32_t* location); // Finds a Component BuiltIn decoration of |var| and returns it via // |component|. Returns true whether the component exists or not. bool GetVariableComponent(Instruction* var, uint32_t* component); // Returns the type of |var| as an instruction. Instruction* GetTypeOfVariable(Instruction* var); // Replaces an interface variable |interface_var| whose type is // |interface_var_type| with scalars and returns whether it succeeds or not. // |location| is the value of Location Decoration for |interface_var|. // |component| is the value of Component Decoration for |interface_var|. // If |extra_array_length| is 0, it means |interface_var| has a Patch // decoration. Otherwise, |extra_array_length| denotes the length of the extra // array of |interface_var|. bool ReplaceInterfaceVariableWithScalars(Instruction* interface_var, Instruction* interface_var_type, uint32_t location, uint32_t component, uint32_t extra_array_length); // Creates scalar variables with the storage classe |storage_class| to replace // an interface variable whose type is |interface_var_type|. If // |extra_array_length| is not zero, adds the extra arrayness to the created // scalar variables. NestedCompositeComponents CreateScalarInterfaceVarsForReplacement( Instruction* interface_var_type, spv::StorageClass storage_class, uint32_t extra_array_length); // Creates scalar variables with the storage classe |storage_class| to replace // the interface variable whose type is OpTypeArray |interface_var_type| with. // If |extra_array_length| is not zero, adds the extra arrayness to all the // scalar variables. NestedCompositeComponents CreateScalarInterfaceVarsForArray( Instruction* interface_var_type, spv::StorageClass storage_class, uint32_t extra_array_length); // Creates scalar variables with the storage classe |storage_class| to replace // the interface variable whose type is OpTypeMatrix |interface_var_type| // with. If |extra_array_length| is not zero, adds the extra arrayness to all // the scalar variables. NestedCompositeComponents CreateScalarInterfaceVarsForMatrix( Instruction* interface_var_type, spv::StorageClass storage_class, uint32_t extra_array_length); // Recursively adds Location and Component decorations to variables in // |vars| with |location| and |component|. Increases |location| by one after // it actually adds Location and Component decorations for a variable. void AddLocationAndComponentDecorations(const NestedCompositeComponents& vars, uint32_t* location, uint32_t component); // Replaces the interface variable |interface_var| with // |scalar_interface_vars| and returns whether it succeeds or not. // |extra_arrayness| is the extra arrayness of the interface variable. // |scalar_interface_vars| contains the nested variables to replace the // interface variable with. bool ReplaceInterfaceVarWith( Instruction* interface_var, uint32_t extra_arrayness, const NestedCompositeComponents& scalar_interface_vars); // Replaces |interface_var| in the operands of instructions // |interface_var_users| with |scalar_interface_vars|. This is a recursive // method and |interface_var_component_indices| is used to specify which // recursive component of |interface_var| is replaced. Returns composite // construct instructions to be replaced with load instructions of // |interface_var_users| via |loads_to_composites|. Returns composite // construct instructions to be replaced with load instructions of access // chain instructions in |interface_var_users| via // |loads_for_access_chain_to_composites|. bool ReplaceComponentsOfInterfaceVarWith( Instruction* interface_var, const std::vector& interface_var_users, const NestedCompositeComponents& scalar_interface_vars, std::vector& interface_var_component_indices, const uint32_t* extra_array_index, std::unordered_map* loads_to_composites, std::unordered_map* loads_for_access_chain_to_composites); // Replaces |interface_var| in the operands of instructions // |interface_var_users| with |components| that is a vector of components for // the interface variable |interface_var|. This is a recursive method and // |interface_var_component_indices| is used to specify which recursive // component of |interface_var| is replaced. Returns composite construct // instructions to be replaced with load instructions of |interface_var_users| // via |loads_to_composites|. Returns composite construct instructions to be // replaced with load instructions of access chain instructions in // |interface_var_users| via |loads_for_access_chain_to_composites|. bool ReplaceMultipleComponentsOfInterfaceVarWith( Instruction* interface_var, const std::vector& interface_var_users, const std::vector& components, std::vector& interface_var_component_indices, const uint32_t* extra_array_index, std::unordered_map* loads_to_composites, std::unordered_map* loads_for_access_chain_to_composites); // Replaces a component of |interface_var| that is used as an operand of // instruction |interface_var_user| with |scalar_var|. // |interface_var_component_indices| is a vector of recursive indices for // which recursive component of |interface_var| is replaced. If // |interface_var_user| is a load, returns the component value via // |loads_to_component_values|. If |interface_var_user| is an access chain, // returns the component value for loads of |interface_var_user| via // |loads_for_access_chain_to_component_values|. bool ReplaceComponentOfInterfaceVarWith( Instruction* interface_var, Instruction* interface_var_user, Instruction* scalar_var, const std::vector& interface_var_component_indices, const uint32_t* extra_array_index, std::unordered_map* loads_to_component_values, std::unordered_map* loads_for_access_chain_to_component_values); // Creates instructions to load |scalar_var| and inserts them before // |insert_before|. If |extra_array_index| is not null, they load // |extra_array_index| th component of |scalar_var| instead of |scalar_var| // itself. Instruction* LoadScalarVar(Instruction* scalar_var, const uint32_t* extra_array_index, Instruction* insert_before); // Creates instructions to load an access chain to |var| and inserts them // before |insert_before|. |Indexes| will be Indexes operand of the access // chain. Instruction* LoadAccessChainToVar(Instruction* var, const std::vector& indexes, Instruction* insert_before); // Creates instructions to store a component of an aggregate whose id is // |value_id| to an access chain to |scalar_var| and inserts the created // instructions before |insert_before|. To get the component, recursively // traverses the aggregate with |component_indices| as indexes. // Numbers in |access_chain_indices| are the Indexes operand of the access // chain to |scalar_var| void StoreComponentOfValueToAccessChainToScalarVar( uint32_t value_id, const std::vector& component_indices, Instruction* scalar_var, const std::vector& access_chain_indices, Instruction* insert_before); // Creates instructions to store a component of an aggregate whose id is // |value_id| to |scalar_var| and inserts the created instructions before // |insert_before|. To get the component, recursively traverses the aggregate // using |extra_array_index| and |component_indices| as indexes. void StoreComponentOfValueToScalarVar( uint32_t value_id, const std::vector& component_indices, Instruction* scalar_var, const uint32_t* extra_array_index, Instruction* insert_before); // Creates instructions to store a component of an aggregate whose id is // |value_id| to |ptr| and inserts the created instructions before // |insert_before|. To get the component, recursively traverses the aggregate // using |extra_array_index| and |component_indices| as indexes. // |component_type_id| is the id of the type instruction of the component. void StoreComponentOfValueTo(uint32_t component_type_id, uint32_t value_id, const std::vector& component_indices, Instruction* ptr, const uint32_t* extra_array_index, Instruction* insert_before); // Creates new OpCompositeExtract with |type_id| for Result Type, // |composite_id| for Composite operand, and |indexes| for Indexes operands. // If |extra_first_index| is not nullptr, uses it as the first Indexes // operand. Instruction* CreateCompositeExtract(uint32_t type_id, uint32_t composite_id, const std::vector& indexes, const uint32_t* extra_first_index); // Creates a new OpLoad whose Result Type is |type_id| and Pointer operand is // |ptr|. Inserts the new instruction before |insert_before|. Instruction* CreateLoad(uint32_t type_id, Instruction* ptr, Instruction* insert_before); // Clones an annotation instruction |annotation_inst| and sets the target // operand of the new annotation instruction as |var_id|. void CloneAnnotationForVariable(Instruction* annotation_inst, uint32_t var_id); // Replaces the interface variable |interface_var| in the operands of the // entry point |entry_point| with |scalar_var_id|. If it cannot find // |interface_var| from the operands of the entry point |entry_point|, adds // |scalar_var_id| as an operand of the entry point |entry_point|. bool ReplaceInterfaceVarInEntryPoint(Instruction* interface_var, Instruction* entry_point, uint32_t scalar_var_id); // Creates an access chain instruction whose Base operand is |var| and Indexes // operand is |index|. |component_type_id| is the id of the type instruction // that is the type of component. Inserts the new access chain before // |insert_before|. Instruction* CreateAccessChainWithIndex(uint32_t component_type_id, Instruction* var, uint32_t index, Instruction* insert_before); // Returns the pointee type of the type of variable |var|. uint32_t GetPointeeTypeIdOfVar(Instruction* var); // Replaces the access chain |access_chain| and its users with a new access // chain that points |scalar_var| as the Base operand having // |interface_var_component_indices| as Indexes operands and users of the new // access chain. When some of the users are load instructions, returns the // original load instruction to the new instruction that loads a component of // the original load value via |loads_to_component_values|. void ReplaceAccessChainWith( Instruction* access_chain, const std::vector& interface_var_component_indices, Instruction* scalar_var, std::unordered_map* loads_to_component_values); // Assuming that |access_chain| is an access chain instruction whose Base // operand is |base_access_chain|, replaces the operands of |access_chain| // with operands of |base_access_chain| and Indexes operands of // |access_chain|. void UseBaseAccessChainForAccessChain(Instruction* access_chain, Instruction* base_access_chain); // Creates composite construct instructions for load instructions that are the // keys of |loads_to_component_values| if no such composite construct // instructions exist. Adds a component of the composite as an operand of the // created composite construct instruction. Each value of // |loads_to_component_values| is the component. Returns the created composite // construct instructions using |loads_to_composites|. |depth_to_component| is // the number of recursive access steps to get the component from the // composite. void AddComponentsToCompositesForLoads( const std::unordered_map& loads_to_component_values, std::unordered_map* loads_to_composites, uint32_t depth_to_component); // Creates a composite construct instruction for a component of the value of // instruction |load| in |depth_to_component| th recursive depth and inserts // it after |load|. Instruction* CreateCompositeConstructForComponentOfLoad( Instruction* load, uint32_t depth_to_component); // Creates a new access chain instruction that points to variable |var| whose // type is the instruction with |var_type_id| and inserts it before // |insert_before|. The new access chain will have |index_ids| for Indexes // operands. Returns the type id of the component that is pointed by the new // access chain via |component_type_id|. Instruction* CreateAccessChainToVar(uint32_t var_type_id, Instruction* var, const std::vector& index_ids, Instruction* insert_before, uint32_t* component_type_id); // Returns the result id of OpTypeArray instrunction whose Element Type // operand is |elem_type_id| and Length operand is |array_length|. uint32_t GetArrayType(uint32_t elem_type_id, uint32_t array_length); // Returns the result id of OpTypePointer instrunction whose Type // operand is |type_id| and Storage Class operand is |storage_class|. uint32_t GetPointerType(uint32_t type_id, spv::StorageClass storage_class); // Kills an instrunction |inst| and its users. void KillInstructionAndUsers(Instruction* inst); // Kills a vector of instrunctions |insts| and their users. void KillInstructionsAndUsers(const std::vector& insts); // Kills all OpDecorate instructions for Location and Component of the // variable whose id is |var_id|. void KillLocationAndComponentDecorations(uint32_t var_id); // If |var| has the extra arrayness for an entry point, reports an error and // returns true. Otherwise, returns false. bool ReportErrorIfHasExtraArraynessForOtherEntry(Instruction* var); // If |var| does not have the extra arrayness for an entry point, reports an // error and returns true. Otherwise, returns false. bool ReportErrorIfHasNoExtraArraynessForOtherEntry(Instruction* var); // If |interface_var| has the extra arrayness for an entry point but it does // not have one for another entry point, reports an error and returns false. // Otherwise, returns true. |has_extra_arrayness| denotes whether it has an // extra arrayness for an entry point or not. bool CheckExtraArraynessConflictBetweenEntries(Instruction* interface_var, bool has_extra_arrayness); // Conducts the scalar replacement for the interface variables used by the // |entry_point|. Pass::Status ReplaceInterfaceVarsWithScalars(Instruction& entry_point); // A set of interface variable ids that were already removed from operands of // the entry point. std::unordered_set interface_vars_removed_from_entry_point_operands_; // A mapping from ids of new composite construct instructions that load // instructions are replaced with to the recursive depth of the component of // load that the new component construct instruction is used for. std::unordered_map composite_ids_to_component_depths; // A set of interface variables with the extra arrayness for any of the entry // points. std::unordered_set vars_with_extra_arrayness; // A set of interface variables without the extra arrayness for any of the // entry points. std::unordered_set vars_without_extra_arrayness; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_INTERFACE_VAR_SROA_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/interp_fixup_pass.cpp000066400000000000000000000101341475742701700251000ustar00rootroot00000000000000// Copyright (c) 2021 The Khronos Group Inc. // Copyright (c) 2021 Valve Corporation // Copyright (c) 2021 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/interp_fixup_pass.h" #include #include #include "source/opt/ir_context.h" #include "type_manager.h" namespace spvtools { namespace opt { namespace { // Input Operand Indices constexpr int kSpvVariableStorageClassInIdx = 0; // Folding rule function which attempts to replace |op(OpLoad(a),...)| // by |op(a,...)|, where |op| is one of the GLSLstd450 InterpolateAt* // instructions. Returns true if replaced, false otherwise. bool ReplaceInternalInterpolate(IRContext* ctx, Instruction* inst, const std::vector&) { uint32_t glsl450_ext_inst_id = ctx->get_feature_mgr()->GetExtInstImportId_GLSLstd450(); assert(glsl450_ext_inst_id != 0); uint32_t ext_opcode = inst->GetSingleWordInOperand(1); uint32_t op1_id = inst->GetSingleWordInOperand(2); Instruction* load_inst = ctx->get_def_use_mgr()->GetDef(op1_id); if (load_inst->opcode() != spv::Op::OpLoad) return false; Instruction* base_inst = load_inst->GetBaseAddress(); USE_ASSERT(base_inst->opcode() == spv::Op::OpVariable && spv::StorageClass(base_inst->GetSingleWordInOperand( kSpvVariableStorageClassInIdx)) == spv::StorageClass::Input && "unexpected interpolant in InterpolateAt*"); uint32_t ptr_id = load_inst->GetSingleWordInOperand(0); uint32_t op2_id = (ext_opcode != GLSLstd450InterpolateAtCentroid) ? inst->GetSingleWordInOperand(3) : 0; Instruction::OperandList new_operands; new_operands.push_back({SPV_OPERAND_TYPE_ID, {glsl450_ext_inst_id}}); new_operands.push_back( {SPV_OPERAND_TYPE_EXTENSION_INSTRUCTION_NUMBER, {ext_opcode}}); new_operands.push_back({SPV_OPERAND_TYPE_ID, {ptr_id}}); if (op2_id != 0) new_operands.push_back({SPV_OPERAND_TYPE_ID, {op2_id}}); inst->SetInOperands(std::move(new_operands)); ctx->UpdateDefUse(inst); return true; } class InterpFoldingRules : public FoldingRules { public: explicit InterpFoldingRules(IRContext* ctx) : FoldingRules(ctx) {} protected: virtual void AddFoldingRules() override { uint32_t extension_id = context()->get_feature_mgr()->GetExtInstImportId_GLSLstd450(); if (extension_id != 0) { ext_rules_[{extension_id, GLSLstd450InterpolateAtCentroid}].push_back( ReplaceInternalInterpolate); ext_rules_[{extension_id, GLSLstd450InterpolateAtSample}].push_back( ReplaceInternalInterpolate); ext_rules_[{extension_id, GLSLstd450InterpolateAtOffset}].push_back( ReplaceInternalInterpolate); } } }; class InterpConstFoldingRules : public ConstantFoldingRules { public: InterpConstFoldingRules(IRContext* ctx) : ConstantFoldingRules(ctx) {} protected: virtual void AddFoldingRules() override {} }; } // namespace Pass::Status InterpFixupPass::Process() { bool changed = false; // Traverse the body of the functions to replace instructions that require // the extensions. InstructionFolder folder( context(), std::unique_ptr(new InterpFoldingRules(context())), MakeUnique(context())); for (Function& func : *get_module()) { func.ForEachInst([&changed, &folder](Instruction* inst) { if (folder.FoldInstruction(inst)) { changed = true; } }); } return changed ? Status::SuccessWithChange : Status::SuccessWithoutChange; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/interp_fixup_pass.h000066400000000000000000000041421475742701700245470ustar00rootroot00000000000000// Copyright (c) 2021 The Khronos Group Inc. // Copyright (c) 2021 Valve Corporation // Copyright (c) 2021 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_INTERP_FIXUP_H #define SOURCE_OPT_INTERP_FIXUP_H #include "source/opt/ir_context.h" #include "source/opt/module.h" #include "source/opt/pass.h" namespace spvtools { namespace opt { // Replaces overloaded internal form for GLSLstd450Interpolate* instructions // with external form. Specifically, removes OpLoad from the first argument // and replaces it with the pointer for the OpLoad. glslang generates the // internal form. This pass is called as part of glslang HLSL legalization. class InterpFixupPass : public Pass { public: const char* name() const override { return "interp-fixup"; } Status Process() override; IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisDecorations | IRContext::kAnalysisCombinators | IRContext::kAnalysisCFG | IRContext::kAnalysisDominatorAnalysis | IRContext::kAnalysisLoopAnalysis | IRContext::kAnalysisNameMap | IRContext::kAnalysisScalarEvolution | IRContext::kAnalysisRegisterPressure | IRContext::kAnalysisValueNumberTable | IRContext::kAnalysisStructuredCFG | IRContext::kAnalysisBuiltinVarId | IRContext::kAnalysisIdToFuncMapping | IRContext::kAnalysisTypes | IRContext::kAnalysisDefUse | IRContext::kAnalysisConstants; } }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_INTERP_FIXUP_H KhronosGroup-SPIRV-Tools-f289d04/source/opt/invocation_interlock_placement_pass.cpp000066400000000000000000000404721475742701700306470ustar00rootroot00000000000000// Copyright (c) 2023 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/invocation_interlock_placement_pass.h" #include #include #include #include #include #include #include #include #include #include #include "source/enum_set.h" #include "source/enum_string_mapping.h" #include "source/opt/ir_context.h" #include "source/opt/reflect.h" #include "source/spirv_target_env.h" #include "source/util/string_utils.h" namespace spvtools { namespace opt { namespace { constexpr uint32_t kEntryPointExecutionModelInIdx = 0; constexpr uint32_t kEntryPointFunctionIdInIdx = 1; constexpr uint32_t kFunctionCallFunctionIdInIdx = 0; } // namespace bool InvocationInterlockPlacementPass::hasSingleNextBlock(uint32_t block_id, bool reverse_cfg) { if (reverse_cfg) { // We are traversing forward, so check whether there is a single successor. BasicBlock* block = cfg()->block(block_id); switch (block->tail()->opcode()) { case spv::Op::OpBranchConditional: return false; case spv::Op::OpSwitch: return block->tail()->NumInOperandWords() == 1; default: return !block->tail()->IsReturnOrAbort(); } } else { // We are traversing backward, so check whether there is a single // predecessor. return cfg()->preds(block_id).size() == 1; } } void InvocationInterlockPlacementPass::forEachNext( uint32_t block_id, bool reverse_cfg, std::function f) { if (reverse_cfg) { BasicBlock* block = cfg()->block(block_id); block->ForEachSuccessorLabel([f](uint32_t succ_id) { f(succ_id); }); } else { for (uint32_t pred_id : cfg()->preds(block_id)) { f(pred_id); } } } void InvocationInterlockPlacementPass::addInstructionAtBlockBoundary( BasicBlock* block, spv::Op opcode, bool at_end) { if (at_end) { assert(block->begin()->opcode() != spv::Op::OpPhi && "addInstructionAtBlockBoundary expects to be called with at_end == " "true only if there is a single successor to block"); // Insert a begin instruction at the end of the block. Instruction* begin_inst = new Instruction(context(), opcode); begin_inst->InsertAfter(&*--block->tail()); } else { assert(block->begin()->opcode() != spv::Op::OpPhi && "addInstructionAtBlockBoundary expects to be called with at_end == " "false only if there is a single predecessor to block"); // Insert an end instruction at the beginning of the block. Instruction* end_inst = new Instruction(context(), opcode); end_inst->InsertBefore(&*block->begin()); } } bool InvocationInterlockPlacementPass::killDuplicateBegin(BasicBlock* block) { bool found = false; return context()->KillInstructionIf( block->begin(), block->end(), [&found](Instruction* inst) { if (inst->opcode() == spv::Op::OpBeginInvocationInterlockEXT) { if (found) { return true; } found = true; } return false; }); } bool InvocationInterlockPlacementPass::killDuplicateEnd(BasicBlock* block) { std::vector to_kill; block->ForEachInst([&to_kill](Instruction* inst) { if (inst->opcode() == spv::Op::OpEndInvocationInterlockEXT) { to_kill.push_back(inst); } }); if (to_kill.size() <= 1) { return false; } to_kill.pop_back(); for (Instruction* inst : to_kill) { context()->KillInst(inst); } return true; } void InvocationInterlockPlacementPass::recordBeginOrEndInFunction( Function* func) { if (extracted_functions_.count(func)) { return; } bool had_begin = false; bool had_end = false; func->ForEachInst([this, &had_begin, &had_end](Instruction* inst) { switch (inst->opcode()) { case spv::Op::OpBeginInvocationInterlockEXT: had_begin = true; break; case spv::Op::OpEndInvocationInterlockEXT: had_end = true; break; case spv::Op::OpFunctionCall: { uint32_t function_id = inst->GetSingleWordInOperand(kFunctionCallFunctionIdInIdx); Function* inner_func = context()->GetFunction(function_id); recordBeginOrEndInFunction(inner_func); ExtractionResult result = extracted_functions_[inner_func]; had_begin = had_begin || result.had_begin; had_end = had_end || result.had_end; break; } default: break; } }); ExtractionResult result = {had_begin, had_end}; extracted_functions_[func] = result; } bool InvocationInterlockPlacementPass:: removeBeginAndEndInstructionsFromFunction(Function* func) { bool modified = false; func->ForEachInst([this, &modified](Instruction* inst) { switch (inst->opcode()) { case spv::Op::OpBeginInvocationInterlockEXT: context()->KillInst(inst); modified = true; break; case spv::Op::OpEndInvocationInterlockEXT: context()->KillInst(inst); modified = true; break; default: break; } }); return modified; } bool InvocationInterlockPlacementPass::extractInstructionsFromCalls( std::vector blocks) { bool modified = false; for (BasicBlock* block : blocks) { block->ForEachInst([this, &modified](Instruction* inst) { if (inst->opcode() == spv::Op::OpFunctionCall) { uint32_t function_id = inst->GetSingleWordInOperand(kFunctionCallFunctionIdInIdx); Function* func = context()->GetFunction(function_id); ExtractionResult result = extracted_functions_[func]; if (result.had_begin) { Instruction* new_inst = new Instruction( context(), spv::Op::OpBeginInvocationInterlockEXT); new_inst->InsertBefore(inst); modified = true; } if (result.had_end) { Instruction* new_inst = new Instruction(context(), spv::Op::OpEndInvocationInterlockEXT); new_inst->InsertAfter(inst); modified = true; } } }); } return modified; } void InvocationInterlockPlacementPass::recordExistingBeginAndEndBlock( std::vector blocks) { for (BasicBlock* block : blocks) { block->ForEachInst([this, block](Instruction* inst) { switch (inst->opcode()) { case spv::Op::OpBeginInvocationInterlockEXT: begin_.insert(block->id()); break; case spv::Op::OpEndInvocationInterlockEXT: end_.insert(block->id()); break; default: break; } }); } } InvocationInterlockPlacementPass::BlockSet InvocationInterlockPlacementPass::computeReachableBlocks( BlockSet& previous_inside, const BlockSet& starting_nodes, bool reverse_cfg) { BlockSet inside = starting_nodes; std::deque worklist; worklist.insert(worklist.begin(), starting_nodes.begin(), starting_nodes.end()); while (!worklist.empty()) { uint32_t block_id = worklist.front(); worklist.pop_front(); forEachNext(block_id, reverse_cfg, [&inside, &previous_inside, &worklist](uint32_t next_id) { previous_inside.insert(next_id); if (inside.insert(next_id).second) { worklist.push_back(next_id); } }); } return inside; } bool InvocationInterlockPlacementPass::removeUnneededInstructions( BasicBlock* block) { bool modified = false; if (!predecessors_after_begin_.count(block->id()) && after_begin_.count(block->id())) { // None of the previous blocks are in the critical section, but this block // is. This can only happen if this block already has at least one begin // instruction. Leave the first begin instruction, and remove any others. modified |= killDuplicateBegin(block); } else if (predecessors_after_begin_.count(block->id())) { // At least one previous block is in the critical section; remove all // begin instructions in this block. modified |= context()->KillInstructionIf( block->begin(), block->end(), [](Instruction* inst) { return inst->opcode() == spv::Op::OpBeginInvocationInterlockEXT; }); } if (!successors_before_end_.count(block->id()) && before_end_.count(block->id())) { // Same as above modified |= killDuplicateEnd(block); } else if (successors_before_end_.count(block->id())) { modified |= context()->KillInstructionIf( block->begin(), block->end(), [](Instruction* inst) { return inst->opcode() == spv::Op::OpEndInvocationInterlockEXT; }); } return modified; } BasicBlock* InvocationInterlockPlacementPass::splitEdge(BasicBlock* block, uint32_t succ_id) { // Create a new block to replace the critical edge. auto new_succ_temp = MakeUnique( MakeUnique(context(), spv::Op::OpLabel, 0, TakeNextId(), std::initializer_list{})); auto* new_succ = new_succ_temp.get(); // Insert the new block into the function. block->GetParent()->InsertBasicBlockAfter(std::move(new_succ_temp), block); new_succ->AddInstruction(MakeUnique( context(), spv::Op::OpBranch, 0, 0, std::initializer_list{ Operand(spv_operand_type_t::SPV_OPERAND_TYPE_ID, {succ_id})})); assert(block->tail()->opcode() == spv::Op::OpBranchConditional || block->tail()->opcode() == spv::Op::OpSwitch); // Update the first branch to successor to instead branch to // the new successor. If there are multiple edges, we arbitrarily choose the // first time it appears in the list. The other edges to `succ_id` will have // to be split by another call to `splitEdge`. block->tail()->WhileEachInId([new_succ, succ_id](uint32_t* branch_id) { if (*branch_id == succ_id) { *branch_id = new_succ->id(); return false; } return true; }); return new_succ; } bool InvocationInterlockPlacementPass::placeInstructionsForEdge( BasicBlock* block, uint32_t next_id, BlockSet& inside, BlockSet& previous_inside, spv::Op opcode, bool reverse_cfg) { bool modified = false; if (previous_inside.count(next_id) && !inside.count(block->id())) { // This block is not in the critical section but the next has at least one // other previous block that is, so this block should be enter it as well. // We need to add begin or end instructions to the edge. modified = true; if (hasSingleNextBlock(block->id(), reverse_cfg)) { // This is the only next block. // Additionally, because `next_id` is in `previous_inside`, we know that // `next_id` has at least one previous block in `inside`. And because // 'block` is not in `inside`, that means the `next_id` has to have at // least one other previous block in `inside`. // This is solely for a debug assertion. It is essentially recomputing the // value of `previous_inside` to verify that it was computed correctly // such that the above statement is true. bool next_has_previous_inside = false; // By passing !reverse_cfg to forEachNext, we are actually iterating over // the previous blocks. forEachNext(next_id, !reverse_cfg, [&next_has_previous_inside, inside](uint32_t previous_id) { if (inside.count(previous_id)) { next_has_previous_inside = true; } }); assert(next_has_previous_inside && "`previous_inside` must be the set of blocks with at least one " "previous block in `inside`"); addInstructionAtBlockBoundary(block, opcode, reverse_cfg); } else { // This block has multiple next blocks. Split the edge and insert the // instruction in the new next block. BasicBlock* new_branch; if (reverse_cfg) { new_branch = splitEdge(block, next_id); } else { new_branch = splitEdge(cfg()->block(next_id), block->id()); } auto inst = new Instruction(context(), opcode); inst->InsertBefore(&*new_branch->tail()); } } return modified; } bool InvocationInterlockPlacementPass::placeInstructions(BasicBlock* block) { bool modified = false; block->ForEachSuccessorLabel([this, block, &modified](uint32_t succ_id) { modified |= placeInstructionsForEdge( block, succ_id, after_begin_, predecessors_after_begin_, spv::Op::OpBeginInvocationInterlockEXT, /* reverse_cfg= */ true); modified |= placeInstructionsForEdge(cfg()->block(succ_id), block->id(), before_end_, successors_before_end_, spv::Op::OpEndInvocationInterlockEXT, /* reverse_cfg= */ false); }); return modified; } bool InvocationInterlockPlacementPass::processFragmentShaderEntry( Function* entry_func) { bool modified = false; // Save the original order of blocks in the function, so we don't iterate over // newly-added blocks. std::vector original_blocks; for (auto bi = entry_func->begin(); bi != entry_func->end(); ++bi) { original_blocks.push_back(&*bi); } modified |= extractInstructionsFromCalls(original_blocks); recordExistingBeginAndEndBlock(original_blocks); after_begin_ = computeReachableBlocks(predecessors_after_begin_, begin_, /* reverse_cfg= */ true); before_end_ = computeReachableBlocks(successors_before_end_, end_, /* reverse_cfg= */ false); for (BasicBlock* block : original_blocks) { modified |= removeUnneededInstructions(block); modified |= placeInstructions(block); } return modified; } bool InvocationInterlockPlacementPass::isFragmentShaderInterlockEnabled() { if (!context()->get_feature_mgr()->HasExtension( kSPV_EXT_fragment_shader_interlock)) { return false; } if (context()->get_feature_mgr()->HasCapability( spv::Capability::FragmentShaderSampleInterlockEXT)) { return true; } if (context()->get_feature_mgr()->HasCapability( spv::Capability::FragmentShaderPixelInterlockEXT)) { return true; } if (context()->get_feature_mgr()->HasCapability( spv::Capability::FragmentShaderShadingRateInterlockEXT)) { return true; } return false; } Pass::Status InvocationInterlockPlacementPass::Process() { // Skip this pass if the necessary extension or capability is missing if (!isFragmentShaderInterlockEnabled()) { return Status::SuccessWithoutChange; } bool modified = false; std::unordered_set entry_points; for (Instruction& entry_inst : context()->module()->entry_points()) { uint32_t entry_id = entry_inst.GetSingleWordInOperand(kEntryPointFunctionIdInIdx); entry_points.insert(context()->GetFunction(entry_id)); } for (auto fi = context()->module()->begin(); fi != context()->module()->end(); ++fi) { Function* func = &*fi; recordBeginOrEndInFunction(func); if (!entry_points.count(func) && extracted_functions_.count(func)) { modified |= removeBeginAndEndInstructionsFromFunction(func); } } for (Instruction& entry_inst : context()->module()->entry_points()) { uint32_t entry_id = entry_inst.GetSingleWordInOperand(kEntryPointFunctionIdInIdx); Function* entry_func = context()->GetFunction(entry_id); auto execution_model = spv::ExecutionModel( entry_inst.GetSingleWordInOperand(kEntryPointExecutionModelInIdx)); if (execution_model != spv::ExecutionModel::Fragment) { continue; } modified |= processFragmentShaderEntry(entry_func); } return modified ? Pass::Status::SuccessWithChange : Pass::Status::SuccessWithoutChange; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/invocation_interlock_placement_pass.h000066400000000000000000000154401475742701700303110ustar00rootroot00000000000000// Copyright (c) 2023 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_DEDUPE_INTERLOCK_INVOCATION_PASS_H_ #define SOURCE_OPT_DEDUPE_INTERLOCK_INVOCATION_PASS_H_ #include #include #include #include #include #include #include "source/enum_set.h" #include "source/extensions.h" #include "source/opt/ir_context.h" #include "source/opt/module.h" #include "source/opt/pass.h" #include "source/spirv_target_env.h" namespace spvtools { namespace opt { // This pass will ensure that an entry point will only have at most one // OpBeginInterlockInvocationEXT and one OpEndInterlockInvocationEXT, in that // order class InvocationInterlockPlacementPass : public Pass { public: InvocationInterlockPlacementPass() {} InvocationInterlockPlacementPass(const InvocationInterlockPlacementPass&) = delete; InvocationInterlockPlacementPass(InvocationInterlockPlacementPass&&) = delete; const char* name() const override { return "dedupe-interlock-invocation"; } Status Process() override; private: using BlockSet = std::unordered_set; // Specifies whether a function originally had a begin or end instruction. struct ExtractionResult { bool had_begin : 1; bool had_end : 2; }; // Check if a block has only a single next block, depending on the directing // that we are traversing the CFG. If reverse_cfg is true, we are walking // forward through the CFG, and will return if the block has only one // successor. Otherwise, we are walking backward through the CFG, and will // return if the block has only one predecessor. bool hasSingleNextBlock(uint32_t block_id, bool reverse_cfg); // Iterate over each of a block's predecessors or successors, depending on // direction. If reverse_cfg is true, we are walking forward through the CFG, // and need to iterate over the successors. Otherwise, we are walking backward // through the CFG, and need to iterate over the predecessors. void forEachNext(uint32_t block_id, bool reverse_cfg, std::function f); // Add either a begin or end instruction to the edge of the basic block. If // at_end is true, add the instruction to the end of the block; otherwise add // the instruction to the beginning of the basic block. void addInstructionAtBlockBoundary(BasicBlock* block, spv::Op opcode, bool at_end); // Remove every OpBeginInvocationInterlockEXT instruction in block after the // first. Returns whether any instructions were removed. bool killDuplicateBegin(BasicBlock* block); // Remove every OpBeginInvocationInterlockEXT instruction in block before the // last. Returns whether any instructions were removed. bool killDuplicateEnd(BasicBlock* block); // Records whether a function will potentially execute a begin or end // instruction. void recordBeginOrEndInFunction(Function* func); // Recursively removes any begin or end instructions from func and any // function func calls. Returns whether any instructions were removed. bool removeBeginAndEndInstructionsFromFunction(Function* func); // For every function call in any of the passed blocks, move any begin or end // instructions outside of the function call. Returns whether any extractions // occurred. bool extractInstructionsFromCalls(std::vector blocks); // Finds the sets of blocks that contain OpBeginInvocationInterlockEXT and // OpEndInvocationInterlockEXT, storing them in the member variables begin_ // and end_ respectively. void recordExistingBeginAndEndBlock(std::vector blocks); // Compute the set of blocks including or after the barrier instruction, and // the set of blocks with any previous blocks inside the barrier instruction. // If reverse_cfg is true, move forward through the CFG, computing // after_begin_ and predecessors_after_begin_computing after_begin_ and // predecessors_after_begin_, otherwise, move backward through the CFG, // computing before_end_ and successors_before_end_. BlockSet computeReachableBlocks(BlockSet& in_set, const BlockSet& starting_nodes, bool reverse_cfg); // Remove unneeded begin and end instructions in block. bool removeUnneededInstructions(BasicBlock* block); // Given a block which branches to multiple successors, and a specific // successor, creates a new empty block, and update the branch instruction to // branch to the new block instead. BasicBlock* splitEdge(BasicBlock* block, uint32_t succ_id); // For the edge from block to next_id, places a begin or end instruction on // the edge, based on the direction we are walking the CFG, specified in // reverse_cfg. bool placeInstructionsForEdge(BasicBlock* block, uint32_t next_id, BlockSet& inside, BlockSet& previous_inside, spv::Op opcode, bool reverse_cfg); // Calls placeInstructionsForEdge for each edge in block. bool placeInstructions(BasicBlock* block); // Processes a single fragment shader entry function. bool processFragmentShaderEntry(Function* entry_func); // Returns whether the module has the SPV_EXT_fragment_shader_interlock // extension and one of the FragmentShader*InterlockEXT capabilities. bool isFragmentShaderInterlockEnabled(); // Maps a function to whether that function originally held a begin or end // instruction. std::unordered_map extracted_functions_; // The set of blocks which have an OpBeginInvocationInterlockEXT instruction. BlockSet begin_; // The set of blocks which have an OpEndInvocationInterlockEXT instruction. BlockSet end_; // The set of blocks which either have a begin instruction, or have a // predecessor which has a begin instruction. BlockSet after_begin_; // The set of blocks which either have an end instruction, or have a successor // which have an end instruction. BlockSet before_end_; // The set of blocks which have a predecessor in after_begin_. BlockSet predecessors_after_begin_; // The set of blocks which have a successor in before_end_. BlockSet successors_before_end_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_DEDUPE_INTERLOCK_INVOCATION_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/ir_builder.h000066400000000000000000000653451475742701700231410ustar00rootroot00000000000000// Copyright (c) 2018 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_IR_BUILDER_H_ #define SOURCE_OPT_IR_BUILDER_H_ #include #include #include #include #include "source/opt/basic_block.h" #include "source/opt/constants.h" #include "source/opt/instruction.h" #include "source/opt/ir_context.h" namespace spvtools { namespace opt { // In SPIR-V, ids are encoded as uint16_t, this id is guaranteed to be always // invalid. constexpr uint32_t kInvalidId = std::numeric_limits::max(); // Helper class to abstract instruction construction and insertion. // The instruction builder can preserve the following analyses (specified via // the constructors): // - Def-use analysis // - Instruction to block analysis class InstructionBuilder { public: using InsertionPointTy = BasicBlock::iterator; // Creates an InstructionBuilder, all new instructions will be inserted before // the instruction |insert_before|. InstructionBuilder( IRContext* context, Instruction* insert_before, IRContext::Analysis preserved_analyses = IRContext::kAnalysisNone) : InstructionBuilder(context, context->get_instr_block(insert_before), InsertionPointTy(insert_before), preserved_analyses) {} // Creates an InstructionBuilder, all new instructions will be inserted at the // end of the basic block |parent_block|. InstructionBuilder( IRContext* context, BasicBlock* parent_block, IRContext::Analysis preserved_analyses = IRContext::kAnalysisNone) : InstructionBuilder(context, parent_block, parent_block->end(), preserved_analyses) {} Instruction* AddNullaryOp(uint32_t type_id, spv::Op opcode) { uint32_t result_id = 0; if (type_id != 0) { result_id = GetContext()->TakeNextId(); if (result_id == 0) { return nullptr; } } std::unique_ptr new_inst( new Instruction(GetContext(), opcode, type_id, result_id, {})); return AddInstruction(std::move(new_inst)); } Instruction* AddUnaryOp(uint32_t type_id, spv::Op opcode, uint32_t operand1) { uint32_t result_id = 0; if (type_id != 0) { result_id = GetContext()->TakeNextId(); if (result_id == 0) { return nullptr; } } std::unique_ptr newUnOp(new Instruction( GetContext(), opcode, type_id, result_id, {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {operand1}}})); return AddInstruction(std::move(newUnOp)); } Instruction* AddBinaryOp(uint32_t type_id, spv::Op opcode, uint32_t operand1, uint32_t operand2) { uint32_t result_id = 0; if (type_id != 0) { result_id = GetContext()->TakeNextId(); if (result_id == 0) { return nullptr; } } std::unique_ptr newBinOp(new Instruction( GetContext(), opcode, type_id, opcode == spv::Op::OpStore ? 0 : result_id, {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {operand1}}, {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {operand2}}})); return AddInstruction(std::move(newBinOp)); } Instruction* AddTernaryOp(uint32_t type_id, spv::Op opcode, uint32_t operand1, uint32_t operand2, uint32_t operand3) { uint32_t result_id = 0; if (type_id != 0) { result_id = GetContext()->TakeNextId(); if (result_id == 0) { return nullptr; } } std::unique_ptr newTernOp(new Instruction( GetContext(), opcode, type_id, result_id, {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {operand1}}, {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {operand2}}, {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {operand3}}})); return AddInstruction(std::move(newTernOp)); } Instruction* AddQuadOp(uint32_t type_id, spv::Op opcode, uint32_t operand1, uint32_t operand2, uint32_t operand3, uint32_t operand4) { uint32_t result_id = 0; if (type_id != 0) { result_id = GetContext()->TakeNextId(); if (result_id == 0) { return nullptr; } } std::unique_ptr newQuadOp(new Instruction( GetContext(), opcode, type_id, result_id, {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {operand1}}, {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {operand2}}, {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {operand3}}, {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {operand4}}})); return AddInstruction(std::move(newQuadOp)); } Instruction* AddIdLiteralOp(uint32_t type_id, spv::Op opcode, uint32_t id, uint32_t uliteral) { uint32_t result_id = 0; if (type_id != 0) { result_id = GetContext()->TakeNextId(); if (result_id == 0) { return nullptr; } } std::unique_ptr newBinOp(new Instruction( GetContext(), opcode, type_id, result_id, {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {id}}, {spv_operand_type_t::SPV_OPERAND_TYPE_LITERAL_INTEGER, {uliteral}}})); return AddInstruction(std::move(newBinOp)); } // Creates an N-ary instruction of |opcode|. // |typid| must be the id of the instruction's type. // |operands| must be a sequence of operand ids. // Use |result| for the result id if non-zero. Instruction* AddNaryOp(uint32_t type_id, spv::Op opcode, const std::vector& operands, uint32_t result = 0) { std::vector ops; for (size_t i = 0; i < operands.size(); i++) { ops.push_back({SPV_OPERAND_TYPE_ID, {operands[i]}}); } // TODO(1841): Handle id overflow. std::unique_ptr new_inst(new Instruction( GetContext(), opcode, type_id, result != 0 ? result : GetContext()->TakeNextId(), ops)); return AddInstruction(std::move(new_inst)); } // Creates a new selection merge instruction. // The id |merge_id| is the merge basic block id. Instruction* AddSelectionMerge( uint32_t merge_id, uint32_t selection_control = static_cast( spv::SelectionControlMask::MaskNone)) { std::unique_ptr new_branch_merge(new Instruction( GetContext(), spv::Op::OpSelectionMerge, 0, 0, {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {merge_id}}, {spv_operand_type_t::SPV_OPERAND_TYPE_SELECTION_CONTROL, {selection_control}}})); return AddInstruction(std::move(new_branch_merge)); } // Creates a new loop merge instruction. // The id |merge_id| is the basic block id of the merge block. // |continue_id| is the id of the continue block. // |loop_control| are the loop control flags to be added to the instruction. Instruction* AddLoopMerge(uint32_t merge_id, uint32_t continue_id, uint32_t loop_control = static_cast( spv::LoopControlMask::MaskNone)) { std::unique_ptr new_branch_merge(new Instruction( GetContext(), spv::Op::OpLoopMerge, 0, 0, {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {merge_id}}, {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {continue_id}}, {spv_operand_type_t::SPV_OPERAND_TYPE_LOOP_CONTROL, {loop_control}}})); return AddInstruction(std::move(new_branch_merge)); } // Creates a new branch instruction to |label_id|. // Note that the user must make sure the final basic block is // well formed. Instruction* AddBranch(uint32_t label_id) { std::unique_ptr new_branch(new Instruction( GetContext(), spv::Op::OpBranch, 0, 0, {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {label_id}}})); return AddInstruction(std::move(new_branch)); } // Creates a new conditional instruction and the associated selection merge // instruction if requested. // The id |cond_id| is the id of the condition instruction, must be of // type bool. // The id |true_id| is the id of the basic block to branch to if the condition // is true. // The id |false_id| is the id of the basic block to branch to if the // condition is false. // The id |merge_id| is the id of the merge basic block for the selection // merge instruction. If |merge_id| equals kInvalidId then no selection merge // instruction will be created. // The value |selection_control| is the selection control flag for the // selection merge instruction. // Note that the user must make sure the final basic block is // well formed. Instruction* AddConditionalBranch( uint32_t cond_id, uint32_t true_id, uint32_t false_id, uint32_t merge_id = kInvalidId, uint32_t selection_control = static_cast(spv::SelectionControlMask::MaskNone)) { if (merge_id != kInvalidId) { AddSelectionMerge(merge_id, selection_control); } std::unique_ptr new_branch(new Instruction( GetContext(), spv::Op::OpBranchConditional, 0, 0, {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {cond_id}}, {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {true_id}}, {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {false_id}}})); return AddInstruction(std::move(new_branch)); } // Creates a new switch instruction and the associated selection merge // instruction if requested. // The id |selector_id| is the id of the selector instruction, must be of // type int. // The id |default_id| is the id of the default basic block to branch to. // The vector |targets| is the pair of literal/branch id. // The id |merge_id| is the id of the merge basic block for the selection // merge instruction. If |merge_id| equals kInvalidId then no selection merge // instruction will be created. // The value |selection_control| is the selection control flag for the // selection merge instruction. // Note that the user must make sure the final basic block is // well formed. Instruction* AddSwitch( uint32_t selector_id, uint32_t default_id, const std::vector>& targets, uint32_t merge_id = kInvalidId, uint32_t selection_control = static_cast(spv::SelectionControlMask::MaskNone)) { if (merge_id != kInvalidId) { AddSelectionMerge(merge_id, selection_control); } std::vector operands; operands.emplace_back( Operand{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {selector_id}}); operands.emplace_back( Operand{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {default_id}}); for (auto& target : targets) { operands.emplace_back( Operand{spv_operand_type_t::SPV_OPERAND_TYPE_TYPED_LITERAL_NUMBER, target.first}); operands.emplace_back( Operand{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {target.second}}); } std::unique_ptr new_switch( new Instruction(GetContext(), spv::Op::OpSwitch, 0, 0, operands)); return AddInstruction(std::move(new_switch)); } // Creates a phi instruction. // The id |type| must be the id of the phi instruction's type. // The vector |incomings| must be a sequence of pairs of . Instruction* AddPhi(uint32_t type, const std::vector& incomings, uint32_t result = 0) { assert(incomings.size() % 2 == 0 && "A sequence of pairs is expected"); return AddNaryOp(type, spv::Op::OpPhi, incomings, result); } // Creates an addition instruction. // The id |type| must be the id of the instruction's type, must be the same as // |op1| and |op2| types. // The id |op1| is the left hand side of the operation. // The id |op2| is the right hand side of the operation. Instruction* AddIAdd(uint32_t type, uint32_t op1, uint32_t op2) { // TODO(1841): Handle id overflow. std::unique_ptr inst(new Instruction( GetContext(), spv::Op::OpIAdd, type, GetContext()->TakeNextId(), {{SPV_OPERAND_TYPE_ID, {op1}}, {SPV_OPERAND_TYPE_ID, {op2}}})); return AddInstruction(std::move(inst)); } // Creates a less than instruction for unsigned integer. // The id |op1| is the left hand side of the operation. // The id |op2| is the right hand side of the operation. // It is assumed that |op1| and |op2| have the same underlying type. Instruction* AddULessThan(uint32_t op1, uint32_t op2) { analysis::Bool bool_type; uint32_t type = GetContext()->get_type_mgr()->GetId(&bool_type); // TODO(1841): Handle id overflow. std::unique_ptr inst(new Instruction( GetContext(), spv::Op::OpULessThan, type, GetContext()->TakeNextId(), {{SPV_OPERAND_TYPE_ID, {op1}}, {SPV_OPERAND_TYPE_ID, {op2}}})); return AddInstruction(std::move(inst)); } // Creates a less than instruction for signed integer. // The id |op1| is the left hand side of the operation. // The id |op2| is the right hand side of the operation. // It is assumed that |op1| and |op2| have the same underlying type. Instruction* AddSLessThan(uint32_t op1, uint32_t op2) { analysis::Bool bool_type; uint32_t type = GetContext()->get_type_mgr()->GetId(&bool_type); // TODO(1841): Handle id overflow. std::unique_ptr inst(new Instruction( GetContext(), spv::Op::OpSLessThan, type, GetContext()->TakeNextId(), {{SPV_OPERAND_TYPE_ID, {op1}}, {SPV_OPERAND_TYPE_ID, {op2}}})); return AddInstruction(std::move(inst)); } // Creates an OpILessThan or OpULessThen instruction depending on the sign of // |op1|. The id |op1| is the left hand side of the operation. The id |op2| is // the right hand side of the operation. It is assumed that |op1| and |op2| // have the same underlying type. Instruction* AddLessThan(uint32_t op1, uint32_t op2) { Instruction* op1_insn = context_->get_def_use_mgr()->GetDef(op1); analysis::Type* type = GetContext()->get_type_mgr()->GetType(op1_insn->type_id()); analysis::Integer* int_type = type->AsInteger(); assert(int_type && "Operand is not of int type"); if (int_type->IsSigned()) return AddSLessThan(op1, op2); else return AddULessThan(op1, op2); } // Creates a select instruction. // |type| must match the types of |true_value| and |false_value|. It is up to // the caller to ensure that |cond| is a correct type (bool or vector of // bool) for |type|. Instruction* AddSelect(uint32_t type, uint32_t cond, uint32_t true_value, uint32_t false_value) { // TODO(1841): Handle id overflow. std::unique_ptr select(new Instruction( GetContext(), spv::Op::OpSelect, type, GetContext()->TakeNextId(), std::initializer_list{{SPV_OPERAND_TYPE_ID, {cond}}, {SPV_OPERAND_TYPE_ID, {true_value}}, {SPV_OPERAND_TYPE_ID, {false_value}}})); return AddInstruction(std::move(select)); } // Returns a pointer to the definition of a signed 32-bit integer constant // with the given value. Returns |nullptr| if the constant does not exist and // cannot be created. Instruction* GetSintConstant(int32_t value) { return GetIntConstant(value, true); } // Create a composite construct. // |type| should be a composite type and the number of elements it has should // match the size od |ids|. Instruction* AddCompositeConstruct(uint32_t type, const std::vector& ids) { std::vector ops; for (auto id : ids) { ops.emplace_back(SPV_OPERAND_TYPE_ID, std::initializer_list{id}); } // TODO(1841): Handle id overflow. std::unique_ptr construct( new Instruction(GetContext(), spv::Op::OpCompositeConstruct, type, GetContext()->TakeNextId(), ops)); return AddInstruction(std::move(construct)); } // Returns a pointer to the definition of an unsigned 32-bit integer constant // with the given value. Returns |nullptr| if the constant does not exist and // cannot be created. Instruction* GetUintConstant(uint32_t value) { return GetIntConstant(value, false); } uint32_t GetUintConstantId(uint32_t value) { Instruction* uint_inst = GetUintConstant(value); return (uint_inst != nullptr ? uint_inst->result_id() : 0); } // Adds either a signed or unsigned 32 bit integer constant to the binary // depending on the |sign|. If |sign| is true then the value is added as a // signed constant otherwise as an unsigned constant. If |sign| is false the // value must not be a negative number. Returns false if the constant does // not exists and could be be created. template Instruction* GetIntConstant(T value, bool sign) { // Assert that we are not trying to store a negative number in an unsigned // type. if (!sign) assert(value >= 0 && "Trying to add a signed integer with an unsigned type!"); analysis::Integer int_type{32, sign}; // Get or create the integer type. This rebuilds the type and manages the // memory for the rebuilt type. uint32_t type_id = GetContext()->get_type_mgr()->GetTypeInstruction(&int_type); if (type_id == 0) { return nullptr; } // Get the memory managed type so that it is safe to be stored by // GetConstant. analysis::Type* rebuilt_type = GetContext()->get_type_mgr()->GetType(type_id); // Even if the value is negative we need to pass the bit pattern as a // uint32_t to GetConstant. uint32_t word = value; // Create the constant value. const analysis::Constant* constant = GetContext()->get_constant_mgr()->GetConstant(rebuilt_type, {word}); // Create the OpConstant instruction using the type and the value. return GetContext()->get_constant_mgr()->GetDefiningInstruction(constant); } Instruction* GetBoolConstant(bool value) { analysis::Bool type; uint32_t type_id = GetContext()->get_type_mgr()->GetTypeInstruction(&type); analysis::Type* rebuilt_type = GetContext()->get_type_mgr()->GetType(type_id); uint32_t word = value; const analysis::Constant* constant = GetContext()->get_constant_mgr()->GetConstant(rebuilt_type, {word}); return GetContext()->get_constant_mgr()->GetDefiningInstruction(constant); } uint32_t GetBoolConstantId(bool value) { Instruction* inst = GetBoolConstant(value); return (inst != nullptr ? inst->result_id() : 0); } Instruction* AddCompositeExtract(uint32_t type, uint32_t id_of_composite, const std::vector& index_list) { std::vector operands; operands.push_back({SPV_OPERAND_TYPE_ID, {id_of_composite}}); for (uint32_t index : index_list) { operands.push_back({SPV_OPERAND_TYPE_LITERAL_INTEGER, {index}}); } // TODO(1841): Handle id overflow. std::unique_ptr new_inst( new Instruction(GetContext(), spv::Op::OpCompositeExtract, type, GetContext()->TakeNextId(), operands)); return AddInstruction(std::move(new_inst)); } // Creates an unreachable instruction. Instruction* AddUnreachable() { std::unique_ptr select( new Instruction(GetContext(), spv::Op::OpUnreachable, 0, 0, std::initializer_list{})); return AddInstruction(std::move(select)); } Instruction* AddAccessChain(uint32_t type_id, uint32_t base_ptr_id, std::vector ids) { std::vector operands; operands.push_back({SPV_OPERAND_TYPE_ID, {base_ptr_id}}); for (uint32_t index_id : ids) { operands.push_back({SPV_OPERAND_TYPE_ID, {index_id}}); } // TODO(1841): Handle id overflow. std::unique_ptr new_inst( new Instruction(GetContext(), spv::Op::OpAccessChain, type_id, GetContext()->TakeNextId(), operands)); return AddInstruction(std::move(new_inst)); } Instruction* AddLoad(uint32_t type_id, uint32_t base_ptr_id, uint32_t alignment = 0) { std::vector operands; operands.push_back({SPV_OPERAND_TYPE_ID, {base_ptr_id}}); if (alignment != 0) { operands.push_back( {SPV_OPERAND_TYPE_MEMORY_ACCESS, {static_cast(spv::MemoryAccessMask::Aligned)}}); operands.push_back({SPV_OPERAND_TYPE_TYPED_LITERAL_NUMBER, {alignment}}); } // TODO(1841): Handle id overflow. std::unique_ptr new_inst( new Instruction(GetContext(), spv::Op::OpLoad, type_id, GetContext()->TakeNextId(), operands)); return AddInstruction(std::move(new_inst)); } Instruction* AddVariable(uint32_t type_id, uint32_t storage_class) { std::vector operands; operands.push_back({SPV_OPERAND_TYPE_STORAGE_CLASS, {storage_class}}); std::unique_ptr new_inst( new Instruction(GetContext(), spv::Op::OpVariable, type_id, GetContext()->TakeNextId(), operands)); return AddInstruction(std::move(new_inst)); } Instruction* AddStore(uint32_t ptr_id, uint32_t obj_id) { std::vector operands; operands.push_back({SPV_OPERAND_TYPE_ID, {ptr_id}}); operands.push_back({SPV_OPERAND_TYPE_ID, {obj_id}}); std::unique_ptr new_inst( new Instruction(GetContext(), spv::Op::OpStore, 0, 0, operands)); return AddInstruction(std::move(new_inst)); } Instruction* AddFunctionCall(uint32_t result_type, uint32_t function, const std::vector& parameters) { std::vector operands; operands.push_back({SPV_OPERAND_TYPE_ID, {function}}); for (uint32_t id : parameters) { operands.push_back({SPV_OPERAND_TYPE_ID, {id}}); } uint32_t result_id = GetContext()->TakeNextId(); if (result_id == 0) { return nullptr; } std::unique_ptr new_inst( new Instruction(GetContext(), spv::Op::OpFunctionCall, result_type, result_id, operands)); return AddInstruction(std::move(new_inst)); } Instruction* AddVectorShuffle(uint32_t result_type, uint32_t vec1, uint32_t vec2, const std::vector& components) { std::vector operands; operands.push_back({SPV_OPERAND_TYPE_ID, {vec1}}); operands.push_back({SPV_OPERAND_TYPE_ID, {vec2}}); for (uint32_t id : components) { operands.push_back({SPV_OPERAND_TYPE_LITERAL_INTEGER, {id}}); } uint32_t result_id = GetContext()->TakeNextId(); if (result_id == 0) { return nullptr; } std::unique_ptr new_inst( new Instruction(GetContext(), spv::Op::OpVectorShuffle, result_type, result_id, operands)); return AddInstruction(std::move(new_inst)); } Instruction* AddNaryExtendedInstruction( uint32_t result_type, uint32_t set, uint32_t instruction, const std::vector& ext_operands) { std::vector operands; operands.push_back({SPV_OPERAND_TYPE_ID, {set}}); operands.push_back( {SPV_OPERAND_TYPE_EXTENSION_INSTRUCTION_NUMBER, {instruction}}); for (uint32_t id : ext_operands) { operands.push_back({SPV_OPERAND_TYPE_ID, {id}}); } uint32_t result_id = GetContext()->TakeNextId(); if (result_id == 0) { return nullptr; } std::unique_ptr new_inst(new Instruction( GetContext(), spv::Op::OpExtInst, result_type, result_id, operands)); return AddInstruction(std::move(new_inst)); } // Inserts the new instruction before the insertion point. Instruction* AddInstruction(std::unique_ptr&& insn) { Instruction* insn_ptr = &*insert_before_.InsertBefore(std::move(insn)); UpdateInstrToBlockMapping(insn_ptr); UpdateDefUseMgr(insn_ptr); return insn_ptr; } // Returns the insertion point iterator. InsertionPointTy GetInsertPoint() { return insert_before_; } // Change the insertion point to insert before the instruction // |insert_before|. void SetInsertPoint(Instruction* insert_before) { parent_ = context_->get_instr_block(insert_before); insert_before_ = InsertionPointTy(insert_before); } // Change the insertion point to insert at the end of the basic block // |parent_block|. void SetInsertPoint(BasicBlock* parent_block) { parent_ = parent_block; insert_before_ = parent_block->end(); } // Returns the context which instructions are constructed for. IRContext* GetContext() const { return context_; } // Returns the set of preserved analyses. inline IRContext::Analysis GetPreservedAnalysis() const { return preserved_analyses_; } private: InstructionBuilder(IRContext* context, BasicBlock* parent, InsertionPointTy insert_before, IRContext::Analysis preserved_analyses) : context_(context), parent_(parent), insert_before_(insert_before), preserved_analyses_(preserved_analyses) { assert(!(preserved_analyses_ & ~(IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping))); } // Returns true if the users requested to update |analysis|. inline bool IsAnalysisUpdateRequested(IRContext::Analysis analysis) const { if (!GetContext()->AreAnalysesValid(analysis)) { // Do not try to update something that is not built. return false; } return preserved_analyses_ & analysis; } // Updates the def/use manager if the user requested it. If an update was not // requested, this function does nothing. inline void UpdateDefUseMgr(Instruction* insn) { if (IsAnalysisUpdateRequested(IRContext::kAnalysisDefUse)) GetContext()->get_def_use_mgr()->AnalyzeInstDefUse(insn); } // Updates the instruction to block analysis if the user requested it. If // an update was not requested, this function does nothing. inline void UpdateInstrToBlockMapping(Instruction* insn) { if (IsAnalysisUpdateRequested(IRContext::kAnalysisInstrToBlockMapping) && parent_) GetContext()->set_instr_block(insn, parent_); } IRContext* context_; BasicBlock* parent_; InsertionPointTy insert_before_; const IRContext::Analysis preserved_analyses_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_IR_BUILDER_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/ir_context.cpp000066400000000000000000001161561475742701700235270ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // Modifications Copyright (C) 2024 Advanced Micro Devices, Inc. All rights // reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/ir_context.h" #include #include "OpenCLDebugInfo100.h" #include "source/latest_version_glsl_std_450_header.h" #include "source/opt/log.h" #include "source/opt/reflect.h" namespace spvtools { namespace opt { namespace { constexpr int kSpvDecorateTargetIdInIdx = 0; constexpr int kSpvDecorateDecorationInIdx = 1; constexpr int kSpvDecorateBuiltinInIdx = 2; constexpr int kEntryPointInterfaceInIdx = 3; constexpr int kEntryPointFunctionIdInIdx = 1; constexpr int kEntryPointExecutionModelInIdx = 0; // Constants for OpenCL.DebugInfo.100 / NonSemantic.Shader.DebugInfo.100 // extension instructions. constexpr uint32_t kDebugFunctionOperandFunctionIndex = 13; constexpr uint32_t kDebugGlobalVariableOperandVariableIndex = 11; } // namespace void IRContext::BuildInvalidAnalyses(IRContext::Analysis set) { set = Analysis(set & ~valid_analyses_); if (set & kAnalysisDefUse) { BuildDefUseManager(); } if (set & kAnalysisInstrToBlockMapping) { BuildInstrToBlockMapping(); } if (set & kAnalysisDecorations) { BuildDecorationManager(); } if (set & kAnalysisCFG) { BuildCFG(); } if (set & kAnalysisDominatorAnalysis) { ResetDominatorAnalysis(); } if (set & kAnalysisLoopAnalysis) { ResetLoopAnalysis(); } if (set & kAnalysisBuiltinVarId) { ResetBuiltinAnalysis(); } if (set & kAnalysisNameMap) { BuildIdToNameMap(); } if (set & kAnalysisScalarEvolution) { BuildScalarEvolutionAnalysis(); } if (set & kAnalysisRegisterPressure) { BuildRegPressureAnalysis(); } if (set & kAnalysisValueNumberTable) { BuildValueNumberTable(); } if (set & kAnalysisStructuredCFG) { BuildStructuredCFGAnalysis(); } if (set & kAnalysisIdToFuncMapping) { BuildIdToFuncMapping(); } if (set & kAnalysisConstants) { BuildConstantManager(); } if (set & kAnalysisTypes) { BuildTypeManager(); } if (set & kAnalysisDebugInfo) { BuildDebugInfoManager(); } if (set & kAnalysisLiveness) { BuildLivenessManager(); } } void IRContext::InvalidateAnalysesExceptFor( IRContext::Analysis preserved_analyses) { uint32_t analyses_to_invalidate = valid_analyses_ & (~preserved_analyses); InvalidateAnalyses(static_cast(analyses_to_invalidate)); } void IRContext::InvalidateAnalyses(IRContext::Analysis analyses_to_invalidate) { // The ConstantManager and DebugInfoManager contain Type pointers. If the // TypeManager goes away, the ConstantManager and DebugInfoManager have to // go away. if (analyses_to_invalidate & kAnalysisTypes) { analyses_to_invalidate |= kAnalysisConstants; analyses_to_invalidate |= kAnalysisDebugInfo; } // The dominator analysis hold the pseudo entry and exit nodes from the CFG. // Also if the CFG change the dominators many changed as well, so the // dominator analysis should be invalidated as well. if (analyses_to_invalidate & kAnalysisCFG) { analyses_to_invalidate |= kAnalysisDominatorAnalysis; } if (analyses_to_invalidate & kAnalysisDefUse) { def_use_mgr_.reset(nullptr); } if (analyses_to_invalidate & kAnalysisInstrToBlockMapping) { instr_to_block_.clear(); } if (analyses_to_invalidate & kAnalysisDecorations) { decoration_mgr_.reset(nullptr); } if (analyses_to_invalidate & kAnalysisCombinators) { combinator_ops_.clear(); } if (analyses_to_invalidate & kAnalysisBuiltinVarId) { builtin_var_id_map_.clear(); } if (analyses_to_invalidate & kAnalysisCFG) { cfg_.reset(nullptr); } if (analyses_to_invalidate & kAnalysisDominatorAnalysis) { dominator_trees_.clear(); post_dominator_trees_.clear(); } if (analyses_to_invalidate & kAnalysisNameMap) { id_to_name_.reset(nullptr); } if (analyses_to_invalidate & kAnalysisValueNumberTable) { vn_table_.reset(nullptr); } if (analyses_to_invalidate & kAnalysisStructuredCFG) { struct_cfg_analysis_.reset(nullptr); } if (analyses_to_invalidate & kAnalysisIdToFuncMapping) { id_to_func_.clear(); } if (analyses_to_invalidate & kAnalysisConstants) { constant_mgr_.reset(nullptr); } if (analyses_to_invalidate & kAnalysisLiveness) { liveness_mgr_.reset(nullptr); } if (analyses_to_invalidate & kAnalysisTypes) { type_mgr_.reset(nullptr); } if (analyses_to_invalidate & kAnalysisDebugInfo) { debug_info_mgr_.reset(nullptr); } valid_analyses_ = Analysis(valid_analyses_ & ~analyses_to_invalidate); } Instruction* IRContext::KillInst(Instruction* inst) { if (!inst) { return nullptr; } KillNamesAndDecorates(inst); KillOperandFromDebugInstructions(inst); if (AreAnalysesValid(kAnalysisDefUse)) { analysis::DefUseManager* def_use_mgr = get_def_use_mgr(); def_use_mgr->ClearInst(inst); for (auto& l_inst : inst->dbg_line_insts()) def_use_mgr->ClearInst(&l_inst); } if (AreAnalysesValid(kAnalysisInstrToBlockMapping)) { instr_to_block_.erase(inst); } if (AreAnalysesValid(kAnalysisDecorations)) { if (inst->IsDecoration()) { decoration_mgr_->RemoveDecoration(inst); } } if (AreAnalysesValid(kAnalysisDebugInfo)) { get_debug_info_mgr()->ClearDebugScopeAndInlinedAtUses(inst); get_debug_info_mgr()->ClearDebugInfo(inst); } if (type_mgr_ && IsTypeInst(inst->opcode())) { type_mgr_->RemoveId(inst->result_id()); } if (constant_mgr_ && IsConstantInst(inst->opcode())) { constant_mgr_->RemoveId(inst->result_id()); } if (inst->opcode() == spv::Op::OpCapability || inst->opcode() == spv::Op::OpExtension) { // We reset the feature manager, instead of updating it, because it is just // as much work. We would have to remove all capabilities implied by this // capability that are not also implied by the remaining OpCapability // instructions. We could update extensions, but we will see if it is // needed. ResetFeatureManager(); } RemoveFromIdToName(inst); Instruction* next_instruction = nullptr; if (inst->IsInAList()) { next_instruction = inst->NextNode(); inst->RemoveFromList(); delete inst; } else { // Needed for instructions that are not part of a list like OpLabels, // OpFunction, OpFunctionEnd, etc.. inst->ToNop(); } return next_instruction; } bool IRContext::KillInstructionIf(Module::inst_iterator begin, Module::inst_iterator end, std::function condition) { bool removed = false; for (auto it = begin; it != end;) { if (!condition(&*it)) { ++it; continue; } removed = true; // `it` is an iterator on an intrusive list. Next is invalidated on the // current node when an instruction is killed. The iterator must be moved // forward before deleting the node. auto instruction = &*it; ++it; KillInst(instruction); } return removed; } void IRContext::CollectNonSemanticTree( Instruction* inst, std::unordered_set* to_kill) { if (!inst->HasResultId()) return; // Debug[No]Line result id is not used, so we are done if (inst->IsDebugLineInst()) return; std::vector work_list; std::unordered_set seen; work_list.push_back(inst); while (!work_list.empty()) { auto* i = work_list.back(); work_list.pop_back(); get_def_use_mgr()->ForEachUser( i, [&work_list, to_kill, &seen](Instruction* user) { if (user->IsNonSemanticInstruction() && seen.insert(user).second) { work_list.push_back(user); to_kill->insert(user); } }); } } bool IRContext::KillDef(uint32_t id) { Instruction* def = get_def_use_mgr()->GetDef(id); if (def != nullptr) { KillInst(def); return true; } return false; } bool IRContext::RemoveCapability(spv::Capability capability) { const bool removed = KillInstructionIf( module()->capability_begin(), module()->capability_end(), [capability](Instruction* inst) { return static_cast(inst->GetSingleWordOperand(0)) == capability; }); if (removed && feature_mgr_ != nullptr) { feature_mgr_->RemoveCapability(capability); } return removed; } bool IRContext::RemoveExtension(Extension extension) { const std::string_view extensionName = ExtensionToString(extension); const bool removed = KillInstructionIf( module()->extension_begin(), module()->extension_end(), [&extensionName](Instruction* inst) { return inst->GetOperand(0).AsString() == extensionName; }); if (removed && feature_mgr_ != nullptr) { feature_mgr_->RemoveExtension(extension); } return removed; } bool IRContext::ReplaceAllUsesWith(uint32_t before, uint32_t after) { return ReplaceAllUsesWithPredicate(before, after, [](Instruction*) { return true; }); } bool IRContext::ReplaceAllUsesWithPredicate( uint32_t before, uint32_t after, const std::function& predicate) { if (before == after) return false; if (AreAnalysesValid(kAnalysisDebugInfo)) { get_debug_info_mgr()->ReplaceAllUsesInDebugScopeWithPredicate(before, after, predicate); } // Ensure that |after| has been registered as def. assert(get_def_use_mgr()->GetDef(after) && "'after' is not a registered def."); std::vector> uses_to_update; get_def_use_mgr()->ForEachUse( before, [&predicate, &uses_to_update](Instruction* user, uint32_t index) { if (predicate(user)) { uses_to_update.emplace_back(user, index); } }); Instruction* prev = nullptr; for (auto p : uses_to_update) { Instruction* user = p.first; uint32_t index = p.second; if (prev == nullptr || prev != user) { ForgetUses(user); prev = user; } const uint32_t type_result_id_count = (user->result_id() != 0) + (user->type_id() != 0); if (index < type_result_id_count) { // Update the type_id. Note that result id is immutable so it should // never be updated. if (user->type_id() != 0 && index == 0) { user->SetResultType(after); } else if (user->type_id() == 0) { SPIRV_ASSERT(consumer_, false, "Result type id considered as use while the instruction " "doesn't have a result type id."); (void)consumer_; // Makes the compiler happy for release build. } else { SPIRV_ASSERT(consumer_, false, "Trying setting the immutable result id."); } } else { // Update an in-operand. uint32_t in_operand_pos = index - type_result_id_count; // Make the modification in the instruction. user->SetInOperand(in_operand_pos, {after}); } AnalyzeUses(user); } return true; } bool IRContext::IsConsistent() { #ifndef SPIRV_CHECK_CONTEXT return true; #else if (AreAnalysesValid(kAnalysisDefUse)) { analysis::DefUseManager new_def_use(module()); if (!CompareAndPrintDifferences(*get_def_use_mgr(), new_def_use)) { return false; } } if (AreAnalysesValid(kAnalysisIdToFuncMapping)) { for (auto& fn : *module_) { if (id_to_func_[fn.result_id()] != &fn) { return false; } } } if (AreAnalysesValid(kAnalysisInstrToBlockMapping)) { for (auto& func : *module()) { for (auto& block : func) { if (!block.WhileEachInst([this, &block](Instruction* inst) { if (get_instr_block(inst) != &block) { return false; } return true; })) return false; } } } if (!CheckCFG()) { return false; } if (AreAnalysesValid(kAnalysisDecorations)) { analysis::DecorationManager* dec_mgr = get_decoration_mgr(); analysis::DecorationManager current(module()); if (*dec_mgr != current) { return false; } } if (feature_mgr_ != nullptr) { FeatureManager current(grammar_); current.Analyze(module()); if (current != *feature_mgr_) { return false; } } return true; #endif } void IRContext::ForgetUses(Instruction* inst) { if (AreAnalysesValid(kAnalysisDefUse)) { get_def_use_mgr()->EraseUseRecordsOfOperandIds(inst); } if (AreAnalysesValid(kAnalysisDecorations)) { if (inst->IsDecoration()) { get_decoration_mgr()->RemoveDecoration(inst); } } if (AreAnalysesValid(kAnalysisDebugInfo)) { get_debug_info_mgr()->ClearDebugInfo(inst); } RemoveFromIdToName(inst); } void IRContext::AnalyzeUses(Instruction* inst) { if (AreAnalysesValid(kAnalysisDefUse)) { get_def_use_mgr()->AnalyzeInstUse(inst); } if (AreAnalysesValid(kAnalysisDecorations)) { if (inst->IsDecoration()) { get_decoration_mgr()->AddDecoration(inst); } } if (AreAnalysesValid(kAnalysisDebugInfo)) { get_debug_info_mgr()->AnalyzeDebugInst(inst); } if (id_to_name_ && (inst->opcode() == spv::Op::OpName || inst->opcode() == spv::Op::OpMemberName)) { id_to_name_->insert({inst->GetSingleWordInOperand(0), inst}); } } void IRContext::KillNamesAndDecorates(uint32_t id) { analysis::DecorationManager* dec_mgr = get_decoration_mgr(); dec_mgr->RemoveDecorationsFrom(id); std::vector name_to_kill; for (auto name : GetNames(id)) { name_to_kill.push_back(name.second); } for (Instruction* name_inst : name_to_kill) { KillInst(name_inst); } } void IRContext::KillNamesAndDecorates(Instruction* inst) { const uint32_t rId = inst->result_id(); if (rId == 0) return; KillNamesAndDecorates(rId); } void IRContext::KillOperandFromDebugInstructions(Instruction* inst) { const auto opcode = inst->opcode(); const uint32_t id = inst->result_id(); // Kill id of OpFunction from DebugFunction. if (opcode == spv::Op::OpFunction) { for (auto it = module()->ext_inst_debuginfo_begin(); it != module()->ext_inst_debuginfo_end(); ++it) { if (it->GetOpenCL100DebugOpcode() != OpenCLDebugInfo100DebugFunction) continue; auto& operand = it->GetOperand(kDebugFunctionOperandFunctionIndex); if (operand.words[0] == id) { operand.words[0] = get_debug_info_mgr()->GetDebugInfoNone()->result_id(); get_def_use_mgr()->AnalyzeInstUse(&*it); } } } // Kill id of OpVariable for global variable from DebugGlobalVariable. if (opcode == spv::Op::OpVariable || IsConstantInst(opcode)) { for (auto it = module()->ext_inst_debuginfo_begin(); it != module()->ext_inst_debuginfo_end(); ++it) { if (it->GetCommonDebugOpcode() != CommonDebugInfoDebugGlobalVariable) continue; auto& operand = it->GetOperand(kDebugGlobalVariableOperandVariableIndex); if (operand.words[0] == id) { operand.words[0] = get_debug_info_mgr()->GetDebugInfoNone()->result_id(); get_def_use_mgr()->AnalyzeInstUse(&*it); } } } } void IRContext::AddCombinatorsForCapability(uint32_t capability) { spv::Capability cap = spv::Capability(capability); if (cap == spv::Capability::Shader) { combinator_ops_[0].insert( {(uint32_t)spv::Op::OpNop, (uint32_t)spv::Op::OpUndef, (uint32_t)spv::Op::OpConstant, (uint32_t)spv::Op::OpConstantTrue, (uint32_t)spv::Op::OpConstantFalse, (uint32_t)spv::Op::OpConstantComposite, (uint32_t)spv::Op::OpConstantSampler, (uint32_t)spv::Op::OpConstantNull, (uint32_t)spv::Op::OpTypeVoid, (uint32_t)spv::Op::OpTypeBool, (uint32_t)spv::Op::OpTypeInt, (uint32_t)spv::Op::OpTypeFloat, (uint32_t)spv::Op::OpTypeVector, (uint32_t)spv::Op::OpTypeMatrix, (uint32_t)spv::Op::OpTypeImage, (uint32_t)spv::Op::OpTypeSampler, (uint32_t)spv::Op::OpTypeSampledImage, (uint32_t)spv::Op::OpTypeAccelerationStructureNV, (uint32_t)spv::Op::OpTypeAccelerationStructureKHR, (uint32_t)spv::Op::OpTypeRayQueryKHR, (uint32_t)spv::Op::OpTypeHitObjectNV, (uint32_t)spv::Op::OpTypeArray, (uint32_t)spv::Op::OpTypeRuntimeArray, (uint32_t)spv::Op::OpTypeNodePayloadArrayAMDX, (uint32_t)spv::Op::OpTypeStruct, (uint32_t)spv::Op::OpTypeOpaque, (uint32_t)spv::Op::OpTypePointer, (uint32_t)spv::Op::OpTypeFunction, (uint32_t)spv::Op::OpTypeEvent, (uint32_t)spv::Op::OpTypeDeviceEvent, (uint32_t)spv::Op::OpTypeReserveId, (uint32_t)spv::Op::OpTypeQueue, (uint32_t)spv::Op::OpTypePipe, (uint32_t)spv::Op::OpTypeForwardPointer, (uint32_t)spv::Op::OpVariable, (uint32_t)spv::Op::OpImageTexelPointer, (uint32_t)spv::Op::OpLoad, (uint32_t)spv::Op::OpAccessChain, (uint32_t)spv::Op::OpInBoundsAccessChain, (uint32_t)spv::Op::OpArrayLength, (uint32_t)spv::Op::OpVectorExtractDynamic, (uint32_t)spv::Op::OpVectorInsertDynamic, (uint32_t)spv::Op::OpVectorShuffle, (uint32_t)spv::Op::OpCompositeConstruct, (uint32_t)spv::Op::OpCompositeExtract, (uint32_t)spv::Op::OpCompositeInsert, (uint32_t)spv::Op::OpCopyObject, (uint32_t)spv::Op::OpTranspose, (uint32_t)spv::Op::OpSampledImage, (uint32_t)spv::Op::OpImageSampleImplicitLod, (uint32_t)spv::Op::OpImageSampleExplicitLod, (uint32_t)spv::Op::OpImageSampleDrefImplicitLod, (uint32_t)spv::Op::OpImageSampleDrefExplicitLod, (uint32_t)spv::Op::OpImageSampleProjImplicitLod, (uint32_t)spv::Op::OpImageSampleProjExplicitLod, (uint32_t)spv::Op::OpImageSampleProjDrefImplicitLod, (uint32_t)spv::Op::OpImageSampleProjDrefExplicitLod, (uint32_t)spv::Op::OpImageFetch, (uint32_t)spv::Op::OpImageGather, (uint32_t)spv::Op::OpImageDrefGather, (uint32_t)spv::Op::OpImageRead, (uint32_t)spv::Op::OpImage, (uint32_t)spv::Op::OpImageQueryFormat, (uint32_t)spv::Op::OpImageQueryOrder, (uint32_t)spv::Op::OpImageQuerySizeLod, (uint32_t)spv::Op::OpImageQuerySize, (uint32_t)spv::Op::OpImageQueryLevels, (uint32_t)spv::Op::OpImageQuerySamples, (uint32_t)spv::Op::OpConvertFToU, (uint32_t)spv::Op::OpConvertFToS, (uint32_t)spv::Op::OpConvertSToF, (uint32_t)spv::Op::OpConvertUToF, (uint32_t)spv::Op::OpUConvert, (uint32_t)spv::Op::OpSConvert, (uint32_t)spv::Op::OpFConvert, (uint32_t)spv::Op::OpQuantizeToF16, (uint32_t)spv::Op::OpBitcast, (uint32_t)spv::Op::OpSNegate, (uint32_t)spv::Op::OpFNegate, (uint32_t)spv::Op::OpIAdd, (uint32_t)spv::Op::OpFAdd, (uint32_t)spv::Op::OpISub, (uint32_t)spv::Op::OpFSub, (uint32_t)spv::Op::OpIMul, (uint32_t)spv::Op::OpFMul, (uint32_t)spv::Op::OpUDiv, (uint32_t)spv::Op::OpSDiv, (uint32_t)spv::Op::OpFDiv, (uint32_t)spv::Op::OpUMod, (uint32_t)spv::Op::OpSRem, (uint32_t)spv::Op::OpSMod, (uint32_t)spv::Op::OpFRem, (uint32_t)spv::Op::OpFMod, (uint32_t)spv::Op::OpVectorTimesScalar, (uint32_t)spv::Op::OpMatrixTimesScalar, (uint32_t)spv::Op::OpVectorTimesMatrix, (uint32_t)spv::Op::OpMatrixTimesVector, (uint32_t)spv::Op::OpMatrixTimesMatrix, (uint32_t)spv::Op::OpOuterProduct, (uint32_t)spv::Op::OpDot, (uint32_t)spv::Op::OpIAddCarry, (uint32_t)spv::Op::OpISubBorrow, (uint32_t)spv::Op::OpUMulExtended, (uint32_t)spv::Op::OpSMulExtended, (uint32_t)spv::Op::OpAny, (uint32_t)spv::Op::OpAll, (uint32_t)spv::Op::OpIsNan, (uint32_t)spv::Op::OpIsInf, (uint32_t)spv::Op::OpLogicalEqual, (uint32_t)spv::Op::OpLogicalNotEqual, (uint32_t)spv::Op::OpLogicalOr, (uint32_t)spv::Op::OpLogicalAnd, (uint32_t)spv::Op::OpLogicalNot, (uint32_t)spv::Op::OpSelect, (uint32_t)spv::Op::OpIEqual, (uint32_t)spv::Op::OpINotEqual, (uint32_t)spv::Op::OpUGreaterThan, (uint32_t)spv::Op::OpSGreaterThan, (uint32_t)spv::Op::OpUGreaterThanEqual, (uint32_t)spv::Op::OpSGreaterThanEqual, (uint32_t)spv::Op::OpULessThan, (uint32_t)spv::Op::OpSLessThan, (uint32_t)spv::Op::OpULessThanEqual, (uint32_t)spv::Op::OpSLessThanEqual, (uint32_t)spv::Op::OpFOrdEqual, (uint32_t)spv::Op::OpFUnordEqual, (uint32_t)spv::Op::OpFOrdNotEqual, (uint32_t)spv::Op::OpFUnordNotEqual, (uint32_t)spv::Op::OpFOrdLessThan, (uint32_t)spv::Op::OpFUnordLessThan, (uint32_t)spv::Op::OpFOrdGreaterThan, (uint32_t)spv::Op::OpFUnordGreaterThan, (uint32_t)spv::Op::OpFOrdLessThanEqual, (uint32_t)spv::Op::OpFUnordLessThanEqual, (uint32_t)spv::Op::OpFOrdGreaterThanEqual, (uint32_t)spv::Op::OpFUnordGreaterThanEqual, (uint32_t)spv::Op::OpShiftRightLogical, (uint32_t)spv::Op::OpShiftRightArithmetic, (uint32_t)spv::Op::OpShiftLeftLogical, (uint32_t)spv::Op::OpBitwiseOr, (uint32_t)spv::Op::OpBitwiseXor, (uint32_t)spv::Op::OpBitwiseAnd, (uint32_t)spv::Op::OpNot, (uint32_t)spv::Op::OpBitFieldInsert, (uint32_t)spv::Op::OpBitFieldSExtract, (uint32_t)spv::Op::OpBitFieldUExtract, (uint32_t)spv::Op::OpBitReverse, (uint32_t)spv::Op::OpBitCount, (uint32_t)spv::Op::OpPhi, (uint32_t)spv::Op::OpImageSparseSampleImplicitLod, (uint32_t)spv::Op::OpImageSparseSampleExplicitLod, (uint32_t)spv::Op::OpImageSparseSampleDrefImplicitLod, (uint32_t)spv::Op::OpImageSparseSampleDrefExplicitLod, (uint32_t)spv::Op::OpImageSparseSampleProjImplicitLod, (uint32_t)spv::Op::OpImageSparseSampleProjExplicitLod, (uint32_t)spv::Op::OpImageSparseSampleProjDrefImplicitLod, (uint32_t)spv::Op::OpImageSparseSampleProjDrefExplicitLod, (uint32_t)spv::Op::OpImageSparseFetch, (uint32_t)spv::Op::OpImageSparseGather, (uint32_t)spv::Op::OpImageSparseDrefGather, (uint32_t)spv::Op::OpImageSparseTexelsResident, (uint32_t)spv::Op::OpImageSparseRead, (uint32_t)spv::Op::OpSizeOf}); } } void IRContext::AddCombinatorsForExtension(Instruction* extension) { assert(extension->opcode() == spv::Op::OpExtInstImport && "Expecting an import of an extension's instruction set."); const std::string extension_name = extension->GetInOperand(0).AsString(); if (extension_name == "GLSL.std.450") { combinator_ops_[extension->result_id()] = { (uint32_t)GLSLstd450Round, (uint32_t)GLSLstd450RoundEven, (uint32_t)GLSLstd450Trunc, (uint32_t)GLSLstd450FAbs, (uint32_t)GLSLstd450SAbs, (uint32_t)GLSLstd450FSign, (uint32_t)GLSLstd450SSign, (uint32_t)GLSLstd450Floor, (uint32_t)GLSLstd450Ceil, (uint32_t)GLSLstd450Fract, (uint32_t)GLSLstd450Radians, (uint32_t)GLSLstd450Degrees, (uint32_t)GLSLstd450Sin, (uint32_t)GLSLstd450Cos, (uint32_t)GLSLstd450Tan, (uint32_t)GLSLstd450Asin, (uint32_t)GLSLstd450Acos, (uint32_t)GLSLstd450Atan, (uint32_t)GLSLstd450Sinh, (uint32_t)GLSLstd450Cosh, (uint32_t)GLSLstd450Tanh, (uint32_t)GLSLstd450Asinh, (uint32_t)GLSLstd450Acosh, (uint32_t)GLSLstd450Atanh, (uint32_t)GLSLstd450Atan2, (uint32_t)GLSLstd450Pow, (uint32_t)GLSLstd450Exp, (uint32_t)GLSLstd450Log, (uint32_t)GLSLstd450Exp2, (uint32_t)GLSLstd450Log2, (uint32_t)GLSLstd450Sqrt, (uint32_t)GLSLstd450InverseSqrt, (uint32_t)GLSLstd450Determinant, (uint32_t)GLSLstd450MatrixInverse, (uint32_t)GLSLstd450ModfStruct, (uint32_t)GLSLstd450FMin, (uint32_t)GLSLstd450UMin, (uint32_t)GLSLstd450SMin, (uint32_t)GLSLstd450FMax, (uint32_t)GLSLstd450UMax, (uint32_t)GLSLstd450SMax, (uint32_t)GLSLstd450FClamp, (uint32_t)GLSLstd450UClamp, (uint32_t)GLSLstd450SClamp, (uint32_t)GLSLstd450FMix, (uint32_t)GLSLstd450IMix, (uint32_t)GLSLstd450Step, (uint32_t)GLSLstd450SmoothStep, (uint32_t)GLSLstd450Fma, (uint32_t)GLSLstd450FrexpStruct, (uint32_t)GLSLstd450Ldexp, (uint32_t)GLSLstd450PackSnorm4x8, (uint32_t)GLSLstd450PackUnorm4x8, (uint32_t)GLSLstd450PackSnorm2x16, (uint32_t)GLSLstd450PackUnorm2x16, (uint32_t)GLSLstd450PackHalf2x16, (uint32_t)GLSLstd450PackDouble2x32, (uint32_t)GLSLstd450UnpackSnorm2x16, (uint32_t)GLSLstd450UnpackUnorm2x16, (uint32_t)GLSLstd450UnpackHalf2x16, (uint32_t)GLSLstd450UnpackSnorm4x8, (uint32_t)GLSLstd450UnpackUnorm4x8, (uint32_t)GLSLstd450UnpackDouble2x32, (uint32_t)GLSLstd450Length, (uint32_t)GLSLstd450Distance, (uint32_t)GLSLstd450Cross, (uint32_t)GLSLstd450Normalize, (uint32_t)GLSLstd450FaceForward, (uint32_t)GLSLstd450Reflect, (uint32_t)GLSLstd450Refract, (uint32_t)GLSLstd450FindILsb, (uint32_t)GLSLstd450FindSMsb, (uint32_t)GLSLstd450FindUMsb, (uint32_t)GLSLstd450InterpolateAtCentroid, (uint32_t)GLSLstd450InterpolateAtSample, (uint32_t)GLSLstd450InterpolateAtOffset, (uint32_t)GLSLstd450NMin, (uint32_t)GLSLstd450NMax, (uint32_t)GLSLstd450NClamp}; } else { // Map the result id to the empty set. combinator_ops_[extension->result_id()]; } } void IRContext::InitializeCombinators() { for (auto capability : get_feature_mgr()->GetCapabilities()) { AddCombinatorsForCapability(uint32_t(capability)); } for (auto& extension : module()->ext_inst_imports()) { AddCombinatorsForExtension(&extension); } valid_analyses_ |= kAnalysisCombinators; } void IRContext::RemoveFromIdToName(const Instruction* inst) { if (id_to_name_ && (inst->opcode() == spv::Op::OpName || inst->opcode() == spv::Op::OpMemberName)) { auto range = id_to_name_->equal_range(inst->GetSingleWordInOperand(0)); for (auto it = range.first; it != range.second; ++it) { if (it->second == inst) { id_to_name_->erase(it); break; } } } } LoopDescriptor* IRContext::GetLoopDescriptor(const Function* f) { if (!AreAnalysesValid(kAnalysisLoopAnalysis)) { ResetLoopAnalysis(); } std::unordered_map::iterator it = loop_descriptors_.find(f); if (it == loop_descriptors_.end()) { return &loop_descriptors_ .emplace(std::make_pair(f, LoopDescriptor(this, f))) .first->second; } return &it->second; } uint32_t IRContext::FindBuiltinInputVar(uint32_t builtin) { for (auto& a : module_->annotations()) { if (spv::Op(a.opcode()) != spv::Op::OpDecorate) continue; if (spv::Decoration(a.GetSingleWordInOperand( kSpvDecorateDecorationInIdx)) != spv::Decoration::BuiltIn) continue; if (a.GetSingleWordInOperand(kSpvDecorateBuiltinInIdx) != builtin) continue; uint32_t target_id = a.GetSingleWordInOperand(kSpvDecorateTargetIdInIdx); Instruction* b_var = get_def_use_mgr()->GetDef(target_id); if (b_var->opcode() != spv::Op::OpVariable) continue; if (spv::StorageClass(b_var->GetSingleWordInOperand(0)) != spv::StorageClass::Input) continue; return target_id; } return 0; } void IRContext::AddVarToEntryPoints(uint32_t var_id) { uint32_t ocnt = 0; for (auto& e : module()->entry_points()) { bool found = false; e.ForEachInOperand([&ocnt, &found, &var_id](const uint32_t* idp) { if (ocnt >= kEntryPointInterfaceInIdx) { if (*idp == var_id) found = true; } ++ocnt; }); if (!found) { e.AddOperand({SPV_OPERAND_TYPE_ID, {var_id}}); get_def_use_mgr()->AnalyzeInstDefUse(&e); } } } uint32_t IRContext::GetBuiltinInputVarId(uint32_t builtin) { if (!AreAnalysesValid(kAnalysisBuiltinVarId)) ResetBuiltinAnalysis(); // If cached, return it. std::unordered_map::iterator it = builtin_var_id_map_.find(builtin); if (it != builtin_var_id_map_.end()) return it->second; // Look for one in shader uint32_t var_id = FindBuiltinInputVar(builtin); if (var_id == 0) { // If not found, create it // TODO(greg-lunarg): Add support for all builtins analysis::TypeManager* type_mgr = get_type_mgr(); analysis::Type* reg_type; switch (spv::BuiltIn(builtin)) { case spv::BuiltIn::FragCoord: { analysis::Float float_ty(32); analysis::Type* reg_float_ty = type_mgr->GetRegisteredType(&float_ty); analysis::Vector v4float_ty(reg_float_ty, 4); reg_type = type_mgr->GetRegisteredType(&v4float_ty); break; } case spv::BuiltIn::VertexIndex: case spv::BuiltIn::InstanceIndex: case spv::BuiltIn::PrimitiveId: case spv::BuiltIn::InvocationId: case spv::BuiltIn::SubgroupLocalInvocationId: { analysis::Integer uint_ty(32, false); reg_type = type_mgr->GetRegisteredType(&uint_ty); break; } case spv::BuiltIn::GlobalInvocationId: case spv::BuiltIn::LaunchIdNV: { analysis::Integer uint_ty(32, false); analysis::Type* reg_uint_ty = type_mgr->GetRegisteredType(&uint_ty); analysis::Vector v3uint_ty(reg_uint_ty, 3); reg_type = type_mgr->GetRegisteredType(&v3uint_ty); break; } case spv::BuiltIn::TessCoord: { analysis::Float float_ty(32); analysis::Type* reg_float_ty = type_mgr->GetRegisteredType(&float_ty); analysis::Vector v3float_ty(reg_float_ty, 3); reg_type = type_mgr->GetRegisteredType(&v3float_ty); break; } case spv::BuiltIn::SubgroupLtMask: { analysis::Integer uint_ty(32, false); analysis::Type* reg_uint_ty = type_mgr->GetRegisteredType(&uint_ty); analysis::Vector v4uint_ty(reg_uint_ty, 4); reg_type = type_mgr->GetRegisteredType(&v4uint_ty); break; } default: { assert(false && "unhandled builtin"); return 0; } } uint32_t type_id = type_mgr->GetTypeInstruction(reg_type); uint32_t varTyPtrId = type_mgr->FindPointerToType(type_id, spv::StorageClass::Input); // TODO(1841): Handle id overflow. var_id = TakeNextId(); std::unique_ptr newVarOp( new Instruction(this, spv::Op::OpVariable, varTyPtrId, var_id, {{spv_operand_type_t::SPV_OPERAND_TYPE_LITERAL_INTEGER, {uint32_t(spv::StorageClass::Input)}}})); get_def_use_mgr()->AnalyzeInstDefUse(&*newVarOp); module()->AddGlobalValue(std::move(newVarOp)); get_decoration_mgr()->AddDecorationVal( var_id, uint32_t(spv::Decoration::BuiltIn), builtin); AddVarToEntryPoints(var_id); } builtin_var_id_map_[builtin] = var_id; return var_id; } void IRContext::AddCalls(const Function* func, std::queue* todo) { for (auto bi = func->begin(); bi != func->end(); ++bi) for (auto ii = bi->begin(); ii != bi->end(); ++ii) { if (ii->opcode() == spv::Op::OpFunctionCall) todo->push(ii->GetSingleWordInOperand(0)); if (ii->opcode() == spv::Op::OpCooperativeMatrixPerElementOpNV) todo->push(ii->GetSingleWordInOperand(1)); if (ii->opcode() == spv::Op::OpCooperativeMatrixReduceNV) todo->push(ii->GetSingleWordInOperand(2)); if (ii->opcode() == spv::Op::OpCooperativeMatrixLoadTensorNV) { const auto memory_operands_index = 3; auto mask = ii->GetSingleWordInOperand(memory_operands_index); uint32_t count = 1; if (mask & uint32_t(spv::MemoryAccessMask::Aligned)) ++count; if (mask & uint32_t(spv::MemoryAccessMask::MakePointerAvailableKHR)) ++count; if (mask & uint32_t(spv::MemoryAccessMask::MakePointerVisibleKHR)) ++count; const auto tensor_operands_index = memory_operands_index + count; mask = ii->GetSingleWordInOperand(tensor_operands_index); count = 1; if (mask & uint32_t(spv::TensorAddressingOperandsMask::TensorView)) ++count; if (mask & uint32_t(spv::TensorAddressingOperandsMask::DecodeFunc)) { todo->push(ii->GetSingleWordInOperand(tensor_operands_index + count)); } } } } bool IRContext::ProcessEntryPointCallTree(ProcessFunction& pfn) { // Collect all of the entry points as the roots. std::queue roots; for (auto& e : module()->entry_points()) { roots.push(e.GetSingleWordInOperand(kEntryPointFunctionIdInIdx)); } return ProcessCallTreeFromRoots(pfn, &roots); } bool IRContext::ProcessReachableCallTree(ProcessFunction& pfn) { std::queue roots; // Add all entry points since they can be reached from outside the module. for (auto& e : module()->entry_points()) roots.push(e.GetSingleWordInOperand(kEntryPointFunctionIdInIdx)); // Add all exported functions since they can be reached from outside the // module. for (auto& a : annotations()) { // TODO: Handle group decorations as well. Currently not generate by any // front-end, but could be coming. if (a.opcode() == spv::Op::OpDecorate) { if (spv::Decoration(a.GetSingleWordOperand(1)) == spv::Decoration::LinkageAttributes) { uint32_t lastOperand = a.NumOperands() - 1; if (spv::LinkageType(a.GetSingleWordOperand(lastOperand)) == spv::LinkageType::Export) { uint32_t id = a.GetSingleWordOperand(0); if (GetFunction(id)) { roots.push(id); } } } } } return ProcessCallTreeFromRoots(pfn, &roots); } bool IRContext::ProcessCallTreeFromRoots(ProcessFunction& pfn, std::queue* roots) { // Process call tree bool modified = false; std::unordered_set done; while (!roots->empty()) { const uint32_t fi = roots->front(); roots->pop(); if (done.insert(fi).second) { Function* fn = GetFunction(fi); assert(fn && "Trying to process a function that does not exist."); modified = pfn(fn) || modified; AddCalls(fn, roots); } } return modified; } void IRContext::CollectCallTreeFromRoots(unsigned entryId, std::unordered_set* funcs) { std::queue roots; roots.push(entryId); while (!roots.empty()) { const uint32_t fi = roots.front(); roots.pop(); funcs->insert(fi); Function* fn = GetFunction(fi); AddCalls(fn, &roots); } } void IRContext::EmitErrorMessage(std::string message, Instruction* inst) { if (!consumer()) { return; } Instruction* line_inst = inst; while (line_inst != nullptr) { // Stop at the beginning of the basic block. if (!line_inst->dbg_line_insts().empty()) { line_inst = &line_inst->dbg_line_insts().back(); if (line_inst->IsNoLine()) { line_inst = nullptr; } break; } line_inst = line_inst->PreviousNode(); } uint32_t line_number = 0; uint32_t col_number = 0; std::string source; if (line_inst != nullptr) { Instruction* file_name = get_def_use_mgr()->GetDef(line_inst->GetSingleWordInOperand(0)); source = file_name->GetInOperand(0).AsString(); // Get the line number and column number. line_number = line_inst->GetSingleWordInOperand(1); col_number = line_inst->GetSingleWordInOperand(2); } message += "\n " + inst->PrettyPrint(SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); consumer()(SPV_MSG_ERROR, source.c_str(), {line_number, col_number, 0}, message.c_str()); } // Gets the dominator analysis for function |f|. DominatorAnalysis* IRContext::GetDominatorAnalysis(const Function* f) { if (!AreAnalysesValid(kAnalysisDominatorAnalysis)) { ResetDominatorAnalysis(); } if (dominator_trees_.find(f) == dominator_trees_.end()) { dominator_trees_[f].InitializeTree(*cfg(), f); } return &dominator_trees_[f]; } // Gets the postdominator analysis for function |f|. PostDominatorAnalysis* IRContext::GetPostDominatorAnalysis(const Function* f) { if (!AreAnalysesValid(kAnalysisDominatorAnalysis)) { ResetDominatorAnalysis(); } if (post_dominator_trees_.find(f) == post_dominator_trees_.end()) { post_dominator_trees_[f].InitializeTree(*cfg(), f); } return &post_dominator_trees_[f]; } bool IRContext::CheckCFG() { std::unordered_map> real_preds; if (!AreAnalysesValid(kAnalysisCFG)) { return true; } for (Function& function : *module()) { for (const auto& bb : function) { bb.ForEachSuccessorLabel([&bb, &real_preds](const uint32_t lab_id) { real_preds[lab_id].push_back(bb.id()); }); } for (auto& bb : function) { std::vector preds = cfg()->preds(bb.id()); std::vector real = real_preds[bb.id()]; std::sort(preds.begin(), preds.end()); std::sort(real.begin(), real.end()); bool same = true; if (preds.size() != real.size()) { same = false; } for (size_t i = 0; i < real.size() && same; i++) { if (preds[i] != real[i]) { same = false; } } if (!same) { std::cerr << "Predecessors for " << bb.id() << " are different:\n"; std::cerr << "Real:"; for (uint32_t i : real) { std::cerr << ' ' << i; } std::cerr << std::endl; std::cerr << "Recorded:"; for (uint32_t i : preds) { std::cerr << ' ' << i; } std::cerr << std::endl; } if (!same) return false; } } return true; } bool IRContext::IsReachable(const opt::BasicBlock& bb) { auto enclosing_function = bb.GetParent(); return GetDominatorAnalysis(enclosing_function) ->Dominates(enclosing_function->entry().get(), &bb); } spv::ExecutionModel IRContext::GetStage() { const auto& entry_points = module()->entry_points(); if (entry_points.empty()) { return spv::ExecutionModel::Max; } uint32_t stage = entry_points.begin()->GetSingleWordInOperand( kEntryPointExecutionModelInIdx); auto it = std::find_if( entry_points.begin(), entry_points.end(), [stage](const Instruction& x) { return x.GetSingleWordInOperand(kEntryPointExecutionModelInIdx) != stage; }); if (it != entry_points.end()) { EmitErrorMessage("Mixed stage shader module not supported", &(*it)); } return static_cast(stage); } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/ir_context.h000066400000000000000000001355471475742701700232010ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_IR_CONTEXT_H_ #define SOURCE_OPT_IR_CONTEXT_H_ #include #include #include #include #include #include #include #include #include #include #include "source/assembly_grammar.h" #include "source/enum_string_mapping.h" #include "source/opt/cfg.h" #include "source/opt/constants.h" #include "source/opt/debug_info_manager.h" #include "source/opt/decoration_manager.h" #include "source/opt/def_use_manager.h" #include "source/opt/dominator_analysis.h" #include "source/opt/feature_manager.h" #include "source/opt/fold.h" #include "source/opt/liveness.h" #include "source/opt/loop_descriptor.h" #include "source/opt/module.h" #include "source/opt/register_pressure.h" #include "source/opt/scalar_analysis.h" #include "source/opt/struct_cfg_analysis.h" #include "source/opt/type_manager.h" #include "source/opt/value_number_table.h" #include "source/util/make_unique.h" #include "source/util/string_utils.h" namespace spvtools { namespace opt { class IRContext { public: // Available analyses. // // When adding a new analysis: // // 1. Enum values should be powers of 2. These are cast into uint32_t // bitmasks, so we can have at most 31 analyses represented. // // 2. Make sure it gets invalidated or preserved by IRContext methods that add // or remove IR elements (e.g., KillDef, KillInst, ReplaceAllUsesWith). // // 3. Add handling code in BuildInvalidAnalyses and InvalidateAnalyses enum Analysis { kAnalysisNone = 0 << 0, kAnalysisBegin = 1 << 0, kAnalysisDefUse = kAnalysisBegin, kAnalysisInstrToBlockMapping = 1 << 1, kAnalysisDecorations = 1 << 2, kAnalysisCombinators = 1 << 3, kAnalysisCFG = 1 << 4, kAnalysisDominatorAnalysis = 1 << 5, kAnalysisLoopAnalysis = 1 << 6, kAnalysisNameMap = 1 << 7, kAnalysisScalarEvolution = 1 << 8, kAnalysisRegisterPressure = 1 << 9, kAnalysisValueNumberTable = 1 << 10, kAnalysisStructuredCFG = 1 << 11, kAnalysisBuiltinVarId = 1 << 12, kAnalysisIdToFuncMapping = 1 << 13, kAnalysisConstants = 1 << 14, kAnalysisTypes = 1 << 15, kAnalysisDebugInfo = 1 << 16, kAnalysisLiveness = 1 << 17, kAnalysisEnd = 1 << 18 }; using ProcessFunction = std::function; friend inline Analysis operator|(Analysis lhs, Analysis rhs); friend inline Analysis& operator|=(Analysis& lhs, Analysis rhs); friend inline Analysis operator<<(Analysis a, int shift); friend inline Analysis& operator<<=(Analysis& a, int shift); // Creates an |IRContext| that contains an owned |Module| IRContext(spv_target_env env, MessageConsumer c) : syntax_context_(spvContextCreate(env)), grammar_(syntax_context_), unique_id_(0), module_(new Module()), consumer_(std::move(c)), def_use_mgr_(nullptr), feature_mgr_(nullptr), valid_analyses_(kAnalysisNone), constant_mgr_(nullptr), type_mgr_(nullptr), id_to_name_(nullptr), max_id_bound_(kDefaultMaxIdBound), preserve_bindings_(false), preserve_spec_constants_(false) { SetContextMessageConsumer(syntax_context_, consumer_); module_->SetContext(this); } IRContext(spv_target_env env, std::unique_ptr&& m, MessageConsumer c) : syntax_context_(spvContextCreate(env)), grammar_(syntax_context_), unique_id_(0), module_(std::move(m)), consumer_(std::move(c)), def_use_mgr_(nullptr), feature_mgr_(nullptr), valid_analyses_(kAnalysisNone), type_mgr_(nullptr), id_to_name_(nullptr), max_id_bound_(kDefaultMaxIdBound), preserve_bindings_(false), preserve_spec_constants_(false) { SetContextMessageConsumer(syntax_context_, consumer_); module_->SetContext(this); InitializeCombinators(); } ~IRContext() { spvContextDestroy(syntax_context_); } Module* module() const { return module_.get(); } // Returns a vector of pointers to constant-creation instructions in this // context. inline std::vector GetConstants(); inline std::vector GetConstants() const; // Iterators for annotation instructions contained in this context. inline Module::inst_iterator annotation_begin(); inline Module::inst_iterator annotation_end(); inline IteratorRange annotations(); inline IteratorRange annotations() const; // Iterators for capabilities instructions contained in this module. inline Module::inst_iterator capability_begin(); inline Module::inst_iterator capability_end(); inline IteratorRange capabilities(); inline IteratorRange capabilities() const; // Iterators for extensions instructions contained in this module. inline Module::inst_iterator extension_begin(); inline Module::inst_iterator extension_end(); inline IteratorRange extensions(); inline IteratorRange extensions() const; // Iterators for types, constants and global variables instructions. inline Module::inst_iterator types_values_begin(); inline Module::inst_iterator types_values_end(); inline IteratorRange types_values(); inline IteratorRange types_values() const; // Iterators for ext_inst import instructions contained in this module. inline Module::inst_iterator ext_inst_import_begin(); inline Module::inst_iterator ext_inst_import_end(); inline IteratorRange ext_inst_imports(); inline IteratorRange ext_inst_imports() const; // There are several kinds of debug instructions, according to where they can // appear in the logical layout of a module: // - Section 7a: OpString, OpSourceExtension, OpSource, OpSourceContinued // - Section 7b: OpName, OpMemberName // - Section 7c: OpModuleProcessed // - Mostly anywhere: OpLine and OpNoLine // // Iterators for debug 1 instructions (excluding OpLine & OpNoLine) contained // in this module. These are for layout section 7a. inline Module::inst_iterator debug1_begin(); inline Module::inst_iterator debug1_end(); inline IteratorRange debugs1(); inline IteratorRange debugs1() const; // Iterators for debug 2 instructions (excluding OpLine & OpNoLine) contained // in this module. These are for layout section 7b. inline Module::inst_iterator debug2_begin(); inline Module::inst_iterator debug2_end(); inline IteratorRange debugs2(); inline IteratorRange debugs2() const; // Iterators for debug 3 instructions (excluding OpLine & OpNoLine) contained // in this module. These are for layout section 7c. inline Module::inst_iterator debug3_begin(); inline Module::inst_iterator debug3_end(); inline IteratorRange debugs3(); inline IteratorRange debugs3() const; // Iterators for debug info instructions (excluding OpLine & OpNoLine) // contained in this module. These are OpExtInst & // OpExtInstWithForwardRefsKHR for DebugInfo extension placed between section // 9 and 10. inline Module::inst_iterator ext_inst_debuginfo_begin(); inline Module::inst_iterator ext_inst_debuginfo_end(); inline IteratorRange ext_inst_debuginfo(); inline IteratorRange ext_inst_debuginfo() const; // Add |capability| to the module, if it is not already enabled. inline void AddCapability(spv::Capability capability); // Appends a capability instruction to this module. inline void AddCapability(std::unique_ptr&& c); // Removes instruction declaring `capability` from this module. // Returns true if the capability was removed, false otherwise. bool RemoveCapability(spv::Capability capability); // Appends an extension instruction to this module. inline void AddExtension(const std::string& ext_name); inline void AddExtension(std::unique_ptr&& e); // Removes instruction declaring `extension` from this module. // Returns true if the extension was removed, false otherwise. bool RemoveExtension(Extension extension); // Appends an extended instruction set instruction to this module. inline void AddExtInstImport(const std::string& name); inline void AddExtInstImport(std::unique_ptr&& e); // Set the memory model for this module. inline void SetMemoryModel(std::unique_ptr&& m); // Get the memory model for this module. inline const Instruction* GetMemoryModel() const; // Appends an entry point instruction to this module. inline void AddEntryPoint(std::unique_ptr&& e); // Appends an execution mode instruction to this module. inline void AddExecutionMode(std::unique_ptr&& e); // Appends a debug 1 instruction (excluding OpLine & OpNoLine) to this module. // "debug 1" instructions are the ones in layout section 7.a), see section // 2.4 Logical Layout of a Module from the SPIR-V specification. inline void AddDebug1Inst(std::unique_ptr&& d); // Appends a debug 2 instruction (excluding OpLine & OpNoLine) to this module. // "debug 2" instructions are the ones in layout section 7.b), see section // 2.4 Logical Layout of a Module from the SPIR-V specification. inline void AddDebug2Inst(std::unique_ptr&& d); // Appends a debug 3 instruction (OpModuleProcessed) to this module. // This is due to decision by the SPIR Working Group, pending publication. inline void AddDebug3Inst(std::unique_ptr&& d); // Appends a OpExtInst for DebugInfo to this module. inline void AddExtInstDebugInfo(std::unique_ptr&& d); // Appends an annotation instruction to this module. inline void AddAnnotationInst(std::unique_ptr&& a); // Appends a type-declaration instruction to this module. inline void AddType(std::unique_ptr&& t); // Appends a constant, global variable, or OpUndef instruction to this module. inline void AddGlobalValue(std::unique_ptr&& v); // Prepends a function declaration to this module. inline void AddFunctionDeclaration(std::unique_ptr&& f); // Appends a function to this module. inline void AddFunction(std::unique_ptr&& f); // Returns a pointer to a def-use manager. If the def-use manager is // invalid, it is rebuilt first. analysis::DefUseManager* get_def_use_mgr() { if (!AreAnalysesValid(kAnalysisDefUse)) { BuildDefUseManager(); } return def_use_mgr_.get(); } // Returns a pointer to a liveness manager. If the liveness manager is // invalid, it is rebuilt first. analysis::LivenessManager* get_liveness_mgr() { if (!AreAnalysesValid(kAnalysisLiveness)) { BuildLivenessManager(); } return liveness_mgr_.get(); } // Returns a pointer to a value number table. If the liveness analysis is // invalid, it is rebuilt first. ValueNumberTable* GetValueNumberTable() { if (!AreAnalysesValid(kAnalysisValueNumberTable)) { BuildValueNumberTable(); } return vn_table_.get(); } // Returns a pointer to a StructuredCFGAnalysis. If the analysis is invalid, // it is rebuilt first. StructuredCFGAnalysis* GetStructuredCFGAnalysis() { if (!AreAnalysesValid(kAnalysisStructuredCFG)) { BuildStructuredCFGAnalysis(); } return struct_cfg_analysis_.get(); } // Returns a pointer to a liveness analysis. If the liveness analysis is // invalid, it is rebuilt first. LivenessAnalysis* GetLivenessAnalysis() { if (!AreAnalysesValid(kAnalysisRegisterPressure)) { BuildRegPressureAnalysis(); } return reg_pressure_.get(); } // Returns the basic block for instruction |instr|. Re-builds the instruction // block map, if needed. BasicBlock* get_instr_block(Instruction* instr) { if (!AreAnalysesValid(kAnalysisInstrToBlockMapping)) { BuildInstrToBlockMapping(); } auto entry = instr_to_block_.find(instr); return (entry != instr_to_block_.end()) ? entry->second : nullptr; } // Returns the basic block for |id|. Re-builds the instruction block map, if // needed. // // |id| must be a registered definition. BasicBlock* get_instr_block(uint32_t id) { Instruction* def = get_def_use_mgr()->GetDef(id); return get_instr_block(def); } // Sets the basic block for |inst|. Re-builds the mapping if it has become // invalid. void set_instr_block(Instruction* inst, BasicBlock* block) { if (AreAnalysesValid(kAnalysisInstrToBlockMapping)) { instr_to_block_[inst] = block; } } // Returns a pointer the decoration manager. If the decoration manager is // invalid, it is rebuilt first. analysis::DecorationManager* get_decoration_mgr() { if (!AreAnalysesValid(kAnalysisDecorations)) { BuildDecorationManager(); } return decoration_mgr_.get(); } // Returns a pointer to the constant manager. If no constant manager has been // created yet, it creates one. NOTE: Once created, the constant manager // remains active and it is never re-built. analysis::ConstantManager* get_constant_mgr() { if (!AreAnalysesValid(kAnalysisConstants)) { BuildConstantManager(); } return constant_mgr_.get(); } // Returns a pointer to the type manager. If no type manager has been created // yet, it creates one. NOTE: Once created, the type manager remains active it // is never re-built. analysis::TypeManager* get_type_mgr() { if (!AreAnalysesValid(kAnalysisTypes)) { BuildTypeManager(); } return type_mgr_.get(); } // Returns a pointer to the debug information manager. If no debug // information manager has been created yet, it creates one. // NOTE: Once created, the debug information manager remains active // it is never re-built. analysis::DebugInfoManager* get_debug_info_mgr() { if (!AreAnalysesValid(kAnalysisDebugInfo)) { BuildDebugInfoManager(); } return debug_info_mgr_.get(); } // Returns a pointer to the scalar evolution analysis. If it is invalid it // will be rebuilt first. ScalarEvolutionAnalysis* GetScalarEvolutionAnalysis() { if (!AreAnalysesValid(kAnalysisScalarEvolution)) { BuildScalarEvolutionAnalysis(); } return scalar_evolution_analysis_.get(); } // Build the map from the ids to the OpName and OpMemberName instruction // associated with it. inline void BuildIdToNameMap(); // Returns a range of instrucions that contain all of the OpName and // OpMemberNames associated with the given id. inline IteratorRange::iterator> GetNames(uint32_t id); // Returns an OpMemberName instruction that targets |struct_type_id| at // index |index|. Returns nullptr if no such instruction exists. // While the SPIR-V spec does not prohibit having multiple OpMemberName // instructions for the same structure member, it is hard to imagine a member // having more than one name. This method returns the first one it finds. inline Instruction* GetMemberName(uint32_t struct_type_id, uint32_t index); // Copy names from |old_id| to |new_id|. Only copy member name if index is // less than |max_member_index|. inline void CloneNames(const uint32_t old_id, const uint32_t new_id, const uint32_t max_member_index = UINT32_MAX); // Sets the message consumer to the given |consumer|. |consumer| which will be // invoked every time there is a message to be communicated to the outside. void SetMessageConsumer(MessageConsumer c) { consumer_ = std::move(c); } // Returns the reference to the message consumer for this pass. const MessageConsumer& consumer() const { return consumer_; } // Rebuilds the analyses in |set| that are invalid. void BuildInvalidAnalyses(Analysis set); // Invalidates all of the analyses except for those in |preserved_analyses|. void InvalidateAnalysesExceptFor(Analysis preserved_analyses); // Invalidates the analyses marked in |analyses_to_invalidate|. void InvalidateAnalyses(Analysis analyses_to_invalidate); // Deletes the instruction defining the given |id|. Returns true on // success, false if the given |id| is not defined at all. This method also // erases the name, decorations, and definition of |id|. // // Pointers and iterators pointing to the deleted instructions become invalid. // However other pointers and iterators are still valid. bool KillDef(uint32_t id); // Deletes the given instruction |inst|. This method erases the // information of the given instruction's uses of its operands. If |inst| // defines a result id, its name and decorations will also be deleted. // // Pointer and iterator pointing to the deleted instructions become invalid. // However other pointers and iterators are still valid. // // Note that if an instruction is not in an instruction list, the memory may // not be safe to delete, so the instruction is turned into a OpNop instead. // This can happen with OpLabel. // // Returns a pointer to the instruction after |inst| or |nullptr| if no such // instruction exists. Instruction* KillInst(Instruction* inst); // Deletes all the instruction in the range [`begin`; `end`[, for which the // unary predicate `condition` returned true. // Returns true if at least one instruction was removed, false otherwise. // // Pointer and iterator pointing to the deleted instructions become invalid. // However other pointers and iterators are still valid. bool KillInstructionIf(Module::inst_iterator begin, Module::inst_iterator end, std::function condition); // Collects the non-semantic instruction tree that uses |inst|'s result id // to be killed later. void CollectNonSemanticTree(Instruction* inst, std::unordered_set* to_kill); // Collect function reachable from |entryId|, returns |funcs| void CollectCallTreeFromRoots(unsigned entryId, std::unordered_set* funcs); // Returns true if all of the given analyses are valid. bool AreAnalysesValid(Analysis set) { return (set & valid_analyses_) == set; } // Replaces all uses of |before| id with |after| id. Returns true if any // replacement happens. This method does not kill the definition of the // |before| id. If |after| is the same as |before|, does nothing and returns // false. // // |before| and |after| must be registered definitions in the DefUseManager. bool ReplaceAllUsesWith(uint32_t before, uint32_t after); // Replace all uses of |before| id with |after| id if those uses // (instruction) return true for |predicate|. Returns true if // any replacement happens. This method does not kill the definition of the // |before| id. If |after| is the same as |before|, does nothing and return // false. bool ReplaceAllUsesWithPredicate( uint32_t before, uint32_t after, const std::function& predicate); // Returns true if all of the analyses that are suppose to be valid are // actually valid. bool IsConsistent(); // The IRContext will look at the def and uses of |inst| and update any valid // analyses will be updated accordingly. inline void AnalyzeDefUse(Instruction* inst); // Informs the IRContext that the uses of |inst| are going to change, and that // is should forget everything it know about the current uses. Any valid // analyses will be updated accordingly. void ForgetUses(Instruction* inst); // The IRContext will look at the uses of |inst| and update any valid analyses // will be updated accordingly. void AnalyzeUses(Instruction* inst); // Kill all name and decorate ops targeting |id|. void KillNamesAndDecorates(uint32_t id); // Kill all name and decorate ops targeting the result id of |inst|. void KillNamesAndDecorates(Instruction* inst); // Change operands of debug instruction to DebugInfoNone. void KillOperandFromDebugInstructions(Instruction* inst); // Returns the next unique id for use by an instruction. inline uint32_t TakeNextUniqueId() { assert(unique_id_ != std::numeric_limits::max()); // Skip zero. return ++unique_id_; } // Returns true if |inst| is a combinator in the current context. // |combinator_ops_| is built if it has not been already. inline bool IsCombinatorInstruction(const Instruction* inst) { if (!AreAnalysesValid(kAnalysisCombinators)) { InitializeCombinators(); } constexpr uint32_t kExtInstSetIdInIndx = 0; constexpr uint32_t kExtInstInstructionInIndx = 1; if (inst->opcode() != spv::Op::OpExtInst) { return combinator_ops_[0].count(uint32_t(inst->opcode())) != 0; } else { uint32_t set = inst->GetSingleWordInOperand(kExtInstSetIdInIndx); auto op = inst->GetSingleWordInOperand(kExtInstInstructionInIndx); return combinator_ops_[set].count(op) != 0; } } // Returns a pointer to the CFG for all the functions in |module_|. CFG* cfg() { if (!AreAnalysesValid(kAnalysisCFG)) { BuildCFG(); } return cfg_.get(); } // Gets the loop descriptor for function |f|. LoopDescriptor* GetLoopDescriptor(const Function* f); // Gets the dominator analysis for function |f|. DominatorAnalysis* GetDominatorAnalysis(const Function* f); // Gets the postdominator analysis for function |f|. PostDominatorAnalysis* GetPostDominatorAnalysis(const Function* f); // Remove the dominator tree of |f| from the cache. inline void RemoveDominatorAnalysis(const Function* f) { dominator_trees_.erase(f); } // Remove the postdominator tree of |f| from the cache. inline void RemovePostDominatorAnalysis(const Function* f) { post_dominator_trees_.erase(f); } // Return the next available SSA id and increment it. Returns 0 if the // maximum SSA id has been reached. inline uint32_t TakeNextId() { uint32_t next_id = module()->TakeNextIdBound(); if (next_id == 0) { if (consumer()) { std::string message = "ID overflow. Try running compact-ids."; consumer()(SPV_MSG_ERROR, "", {0, 0, 0}, message.c_str()); } #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION // If TakeNextId returns 0, it is very likely that execution will // subsequently fail. Such failures are false alarms from a fuzzing point // of view: they are due to the fact that too many ids were used, rather // than being due to an actual bug. Thus, during a fuzzing build, it is // preferable to bail out when ID overflow occurs. // // A zero exit code is returned here because a non-zero code would cause // ClusterFuzz/OSS-Fuzz to regard the termination as a crash, and spurious // crash reports is what this guard aims to avoid. exit(0); #endif } return next_id; } FeatureManager* get_feature_mgr() { if (!feature_mgr_.get()) { AnalyzeFeatures(); } return feature_mgr_.get(); } void ResetFeatureManager() { feature_mgr_.reset(nullptr); } // Returns the grammar for this context. const AssemblyGrammar& grammar() const { return grammar_; } // If |inst| has not yet been analysed by the def-use manager, then analyse // its definitions and uses. inline void UpdateDefUse(Instruction* inst); const InstructionFolder& get_instruction_folder() { if (!inst_folder_) { inst_folder_ = MakeUnique(this); } return *inst_folder_; } uint32_t max_id_bound() const { return max_id_bound_; } void set_max_id_bound(uint32_t new_bound) { max_id_bound_ = new_bound; } bool preserve_bindings() const { return preserve_bindings_; } void set_preserve_bindings(bool should_preserve_bindings) { preserve_bindings_ = should_preserve_bindings; } bool preserve_spec_constants() const { return preserve_spec_constants_; } void set_preserve_spec_constants(bool should_preserve_spec_constants) { preserve_spec_constants_ = should_preserve_spec_constants; } // Return id of input variable only decorated with |builtin|, if in module. // Create variable and return its id otherwise. If builtin not currently // supported, return 0. uint32_t GetBuiltinInputVarId(uint32_t builtin); // Returns the function whose id is |id|, if one exists. Returns |nullptr| // otherwise. Function* GetFunction(uint32_t id) { if (!AreAnalysesValid(kAnalysisIdToFuncMapping)) { BuildIdToFuncMapping(); } auto entry = id_to_func_.find(id); return (entry != id_to_func_.end()) ? entry->second : nullptr; } Function* GetFunction(Instruction* inst) { if (inst->opcode() != spv::Op::OpFunction) { return nullptr; } return GetFunction(inst->result_id()); } // Add to |todo| all ids of functions called directly from |func|. void AddCalls(const Function* func, std::queue* todo); // Applies |pfn| to every function in the call trees that are rooted at the // entry points. Returns true if any call |pfn| returns true. By convention // |pfn| should return true if it modified the module. bool ProcessEntryPointCallTree(ProcessFunction& pfn); // Applies |pfn| to every function in the call trees rooted at the entry // points and exported functions. Returns true if any call |pfn| returns // true. By convention |pfn| should return true if it modified the module. bool ProcessReachableCallTree(ProcessFunction& pfn); // Applies |pfn| to every function in the call trees rooted at the elements of // |roots|. Returns true if any call to |pfn| returns true. By convention // |pfn| should return true if it modified the module. After returning // |roots| will be empty. bool ProcessCallTreeFromRoots(ProcessFunction& pfn, std::queue* roots); // Emits a error message to the message consumer indicating the error // described by |message| occurred in |inst|. void EmitErrorMessage(std::string message, Instruction* inst); // Returns true if and only if there is a path to |bb| from the entry block of // the function that contains |bb|. bool IsReachable(const opt::BasicBlock& bb); // Return the stage of the module. Will generate error if entry points don't // all have the same stage. spv::ExecutionModel GetStage(); // Returns true of the current target environment is at least that of the // given environment. bool IsTargetEnvAtLeast(spv_target_env env) { // A bit of a hack. We assume that the target environments are appended to // the enum, so that there is an appropriate order. return syntax_context_->target_env >= env; } // Return the target environment for the current context. spv_target_env GetTargetEnv() const { return syntax_context_->target_env; } private: // Builds the def-use manager from scratch, even if it was already valid. void BuildDefUseManager() { def_use_mgr_ = MakeUnique(module()); valid_analyses_ = valid_analyses_ | kAnalysisDefUse; } // Builds the liveness manager from scratch, even if it was already valid. void BuildLivenessManager() { liveness_mgr_ = MakeUnique(this); valid_analyses_ = valid_analyses_ | kAnalysisLiveness; } // Builds the instruction-block map for the whole module. void BuildInstrToBlockMapping() { instr_to_block_.clear(); for (auto& fn : *module_) { for (auto& block : fn) { block.ForEachInst([this, &block](Instruction* inst) { instr_to_block_[inst] = █ }); } } valid_analyses_ = valid_analyses_ | kAnalysisInstrToBlockMapping; } // Builds the instruction-function map for the whole module. void BuildIdToFuncMapping() { id_to_func_.clear(); for (auto& fn : *module_) { id_to_func_[fn.result_id()] = &fn; } valid_analyses_ = valid_analyses_ | kAnalysisIdToFuncMapping; } void BuildDecorationManager() { decoration_mgr_ = MakeUnique(module()); valid_analyses_ = valid_analyses_ | kAnalysisDecorations; } void BuildCFG() { cfg_ = MakeUnique(module()); valid_analyses_ = valid_analyses_ | kAnalysisCFG; } void BuildScalarEvolutionAnalysis() { scalar_evolution_analysis_ = MakeUnique(this); valid_analyses_ = valid_analyses_ | kAnalysisScalarEvolution; } // Builds the liveness analysis from scratch, even if it was already valid. void BuildRegPressureAnalysis() { reg_pressure_ = MakeUnique(this); valid_analyses_ = valid_analyses_ | kAnalysisRegisterPressure; } // Builds the value number table analysis from scratch, even if it was already // valid. void BuildValueNumberTable() { vn_table_ = MakeUnique(this); valid_analyses_ = valid_analyses_ | kAnalysisValueNumberTable; } // Builds the structured CFG analysis from scratch, even if it was already // valid. void BuildStructuredCFGAnalysis() { struct_cfg_analysis_ = MakeUnique(this); valid_analyses_ = valid_analyses_ | kAnalysisStructuredCFG; } // Builds the constant manager from scratch, even if it was already // valid. void BuildConstantManager() { constant_mgr_ = MakeUnique(this); valid_analyses_ = valid_analyses_ | kAnalysisConstants; } // Builds the type manager from scratch, even if it was already // valid. void BuildTypeManager() { type_mgr_ = MakeUnique(consumer(), this); valid_analyses_ = valid_analyses_ | kAnalysisTypes; } // Builds the debug information manager from scratch, even if it was // already valid. void BuildDebugInfoManager() { debug_info_mgr_ = MakeUnique(this); valid_analyses_ = valid_analyses_ | kAnalysisDebugInfo; } // Removes all computed dominator and post-dominator trees. This will force // the context to rebuild the trees on demand. void ResetDominatorAnalysis() { // Clear the cache. dominator_trees_.clear(); post_dominator_trees_.clear(); valid_analyses_ = valid_analyses_ | kAnalysisDominatorAnalysis; } // Removes all computed loop descriptors. void ResetLoopAnalysis() { // Clear the cache. loop_descriptors_.clear(); valid_analyses_ = valid_analyses_ | kAnalysisLoopAnalysis; } // Removes all computed loop descriptors. void ResetBuiltinAnalysis() { // Clear the cache. builtin_var_id_map_.clear(); valid_analyses_ = valid_analyses_ | kAnalysisBuiltinVarId; } // Analyzes the features in the owned module. Builds the manager if required. void AnalyzeFeatures() { feature_mgr_ = std::unique_ptr(new FeatureManager(grammar_)); feature_mgr_->Analyze(module()); } // Scans a module looking for it capabilities, and initializes combinator_ops_ // accordingly. void InitializeCombinators(); // Add the combinator opcode for the given capability to combinator_ops_. void AddCombinatorsForCapability(uint32_t capability); // Add the combinator opcode for the given extension to combinator_ops_. void AddCombinatorsForExtension(Instruction* extension); // Remove |inst| from |id_to_name_| if it is in map. void RemoveFromIdToName(const Instruction* inst); // Returns true if it is suppose to be valid but it is incorrect. Returns // true if the cfg is invalidated. bool CheckCFG(); // Return id of input variable only decorated with |builtin|, if in module. // Return 0 otherwise. uint32_t FindBuiltinInputVar(uint32_t builtin); // Add |var_id| to all entry points in module. void AddVarToEntryPoints(uint32_t var_id); // The SPIR-V syntax context containing grammar tables for opcodes and // operands. spv_context syntax_context_; // Auxiliary object for querying SPIR-V grammar facts. AssemblyGrammar grammar_; // An unique identifier for instructions in |module_|. Can be used to order // instructions in a container. // // This member is initialized to 0, but always issues this value plus one. // Therefore, 0 is not a valid unique id for an instruction. uint32_t unique_id_; // The module being processed within this IR context. std::unique_ptr module_; // A message consumer for diagnostics. MessageConsumer consumer_; // The def-use manager for |module_|. std::unique_ptr def_use_mgr_; // The instruction decoration manager for |module_|. std::unique_ptr decoration_mgr_; // The feature manager for |module_|. std::unique_ptr feature_mgr_; // A map from instructions to the basic block they belong to. This mapping is // built on-demand when get_instr_block() is called. // // NOTE: Do not traverse this map. Ever. Use the function and basic block // iterators to traverse instructions. std::unordered_map instr_to_block_; // A map from ids to the function they define. This mapping is // built on-demand when GetFunction() is called. // // NOTE: Do not traverse this map. Ever. Use the function and basic block // iterators to traverse instructions. std::unordered_map id_to_func_; // A bitset indicating which analyzes are currently valid. Analysis valid_analyses_; // Opcodes of shader capability core executable instructions // without side-effect. std::unordered_map> combinator_ops_; // Opcodes of shader capability core executable instructions // without side-effect. std::unordered_map builtin_var_id_map_; // The CFG for all the functions in |module_|. std::unique_ptr cfg_; // Each function in the module will create its own dominator tree. We cache // the result so it doesn't need to be rebuilt each time. std::map dominator_trees_; std::map post_dominator_trees_; // Cache of loop descriptors for each function. std::unordered_map loop_descriptors_; // Constant manager for |module_|. std::unique_ptr constant_mgr_; // Type manager for |module_|. std::unique_ptr type_mgr_; // Debug information manager for |module_|. std::unique_ptr debug_info_mgr_; // A map from an id to its corresponding OpName and OpMemberName instructions. std::unique_ptr> id_to_name_; // The cache scalar evolution analysis node. std::unique_ptr scalar_evolution_analysis_; // The liveness analysis |module_|. std::unique_ptr reg_pressure_; std::unique_ptr vn_table_; std::unique_ptr inst_folder_; std::unique_ptr struct_cfg_analysis_; // The liveness manager for |module_|. std::unique_ptr liveness_mgr_; // The maximum legal value for the id bound. uint32_t max_id_bound_; // Whether all bindings within |module_| should be preserved. bool preserve_bindings_; // Whether all specialization constants within |module_| // should be preserved. bool preserve_spec_constants_; }; inline IRContext::Analysis operator|(IRContext::Analysis lhs, IRContext::Analysis rhs) { return static_cast(static_cast(lhs) | static_cast(rhs)); } inline IRContext::Analysis& operator|=(IRContext::Analysis& lhs, IRContext::Analysis rhs) { lhs = lhs | rhs; return lhs; } inline IRContext::Analysis operator<<(IRContext::Analysis a, int shift) { return static_cast(static_cast(a) << shift); } inline IRContext::Analysis& operator<<=(IRContext::Analysis& a, int shift) { a = static_cast(static_cast(a) << shift); return a; } std::vector IRContext::GetConstants() { return module()->GetConstants(); } std::vector IRContext::GetConstants() const { return ((const Module*)module())->GetConstants(); } Module::inst_iterator IRContext::annotation_begin() { return module()->annotation_begin(); } Module::inst_iterator IRContext::annotation_end() { return module()->annotation_end(); } IteratorRange IRContext::annotations() { return module_->annotations(); } IteratorRange IRContext::annotations() const { return ((const Module*)module_.get())->annotations(); } Module::inst_iterator IRContext::capability_begin() { return module()->capability_begin(); } Module::inst_iterator IRContext::capability_end() { return module()->capability_end(); } IteratorRange IRContext::capabilities() { return module()->capabilities(); } IteratorRange IRContext::capabilities() const { return ((const Module*)module())->capabilities(); } Module::inst_iterator IRContext::extension_begin() { return module()->extension_begin(); } Module::inst_iterator IRContext::extension_end() { return module()->extension_end(); } IteratorRange IRContext::extensions() { return module()->extensions(); } IteratorRange IRContext::extensions() const { return ((const Module*)module())->extensions(); } Module::inst_iterator IRContext::types_values_begin() { return module()->types_values_begin(); } Module::inst_iterator IRContext::types_values_end() { return module()->types_values_end(); } IteratorRange IRContext::types_values() { return module()->types_values(); } IteratorRange IRContext::types_values() const { return ((const Module*)module_.get())->types_values(); } Module::inst_iterator IRContext::ext_inst_import_begin() { return module()->ext_inst_import_begin(); } Module::inst_iterator IRContext::ext_inst_import_end() { return module()->ext_inst_import_end(); } IteratorRange IRContext::ext_inst_imports() { return module()->ext_inst_imports(); } IteratorRange IRContext::ext_inst_imports() const { return ((const Module*)module_.get())->ext_inst_imports(); } Module::inst_iterator IRContext::debug1_begin() { return module()->debug1_begin(); } Module::inst_iterator IRContext::debug1_end() { return module()->debug1_end(); } IteratorRange IRContext::debugs1() { return module()->debugs1(); } IteratorRange IRContext::debugs1() const { return ((const Module*)module_.get())->debugs1(); } Module::inst_iterator IRContext::debug2_begin() { return module()->debug2_begin(); } Module::inst_iterator IRContext::debug2_end() { return module()->debug2_end(); } IteratorRange IRContext::debugs2() { return module()->debugs2(); } IteratorRange IRContext::debugs2() const { return ((const Module*)module_.get())->debugs2(); } Module::inst_iterator IRContext::debug3_begin() { return module()->debug3_begin(); } Module::inst_iterator IRContext::debug3_end() { return module()->debug3_end(); } IteratorRange IRContext::debugs3() { return module()->debugs3(); } IteratorRange IRContext::debugs3() const { return ((const Module*)module_.get())->debugs3(); } Module::inst_iterator IRContext::ext_inst_debuginfo_begin() { return module()->ext_inst_debuginfo_begin(); } Module::inst_iterator IRContext::ext_inst_debuginfo_end() { return module()->ext_inst_debuginfo_end(); } IteratorRange IRContext::ext_inst_debuginfo() { return module()->ext_inst_debuginfo(); } IteratorRange IRContext::ext_inst_debuginfo() const { return ((const Module*)module_.get())->ext_inst_debuginfo(); } void IRContext::AddCapability(spv::Capability capability) { if (!get_feature_mgr()->HasCapability(capability)) { std::unique_ptr capability_inst(new Instruction( this, spv::Op::OpCapability, 0, 0, {{SPV_OPERAND_TYPE_CAPABILITY, {static_cast(capability)}}})); AddCapability(std::move(capability_inst)); } } void IRContext::AddCapability(std::unique_ptr&& c) { AddCombinatorsForCapability(c->GetSingleWordInOperand(0)); if (feature_mgr_ != nullptr) { feature_mgr_->AddCapability( static_cast(c->GetSingleWordInOperand(0))); } if (AreAnalysesValid(kAnalysisDefUse)) { get_def_use_mgr()->AnalyzeInstDefUse(c.get()); } module()->AddCapability(std::move(c)); } void IRContext::AddExtension(const std::string& ext_name) { std::vector ext_words = spvtools::utils::MakeVector(ext_name); AddExtension(std::unique_ptr( new Instruction(this, spv::Op::OpExtension, 0u, 0u, {{SPV_OPERAND_TYPE_LITERAL_STRING, ext_words}}))); } void IRContext::AddExtension(std::unique_ptr&& e) { if (AreAnalysesValid(kAnalysisDefUse)) { get_def_use_mgr()->AnalyzeInstDefUse(e.get()); } if (feature_mgr_ != nullptr) { feature_mgr_->AddExtension(&*e); } module()->AddExtension(std::move(e)); } void IRContext::AddExtInstImport(const std::string& name) { std::vector ext_words = spvtools::utils::MakeVector(name); AddExtInstImport(std::unique_ptr( new Instruction(this, spv::Op::OpExtInstImport, 0u, TakeNextId(), {{SPV_OPERAND_TYPE_LITERAL_STRING, ext_words}}))); } void IRContext::AddExtInstImport(std::unique_ptr&& e) { AddCombinatorsForExtension(e.get()); if (AreAnalysesValid(kAnalysisDefUse)) { get_def_use_mgr()->AnalyzeInstDefUse(e.get()); } module()->AddExtInstImport(std::move(e)); if (feature_mgr_ != nullptr) { feature_mgr_->AddExtInstImportIds(module()); } } void IRContext::SetMemoryModel(std::unique_ptr&& m) { module()->SetMemoryModel(std::move(m)); } const Instruction* IRContext::GetMemoryModel() const { return module()->GetMemoryModel(); } void IRContext::AddEntryPoint(std::unique_ptr&& e) { module()->AddEntryPoint(std::move(e)); } void IRContext::AddExecutionMode(std::unique_ptr&& e) { module()->AddExecutionMode(std::move(e)); } void IRContext::AddDebug1Inst(std::unique_ptr&& d) { module()->AddDebug1Inst(std::move(d)); } void IRContext::AddDebug2Inst(std::unique_ptr&& d) { if (AreAnalysesValid(kAnalysisNameMap)) { if (d->opcode() == spv::Op::OpName || d->opcode() == spv::Op::OpMemberName) { // OpName and OpMemberName do not have result-ids. The target of the // instruction is at InOperand index 0. id_to_name_->insert({d->GetSingleWordInOperand(0), d.get()}); } } if (AreAnalysesValid(kAnalysisDefUse)) { get_def_use_mgr()->AnalyzeInstDefUse(d.get()); } module()->AddDebug2Inst(std::move(d)); } void IRContext::AddDebug3Inst(std::unique_ptr&& d) { module()->AddDebug3Inst(std::move(d)); } void IRContext::AddExtInstDebugInfo(std::unique_ptr&& d) { module()->AddExtInstDebugInfo(std::move(d)); } void IRContext::AddAnnotationInst(std::unique_ptr&& a) { if (AreAnalysesValid(kAnalysisDecorations)) { get_decoration_mgr()->AddDecoration(a.get()); } if (AreAnalysesValid(kAnalysisDefUse)) { get_def_use_mgr()->AnalyzeInstDefUse(a.get()); } module()->AddAnnotationInst(std::move(a)); } void IRContext::AddType(std::unique_ptr&& t) { module()->AddType(std::move(t)); if (AreAnalysesValid(kAnalysisDefUse)) { get_def_use_mgr()->AnalyzeInstDefUse(&*(--types_values_end())); } } void IRContext::AddGlobalValue(std::unique_ptr&& v) { if (AreAnalysesValid(kAnalysisDefUse)) { get_def_use_mgr()->AnalyzeInstDefUse(&*v); } module()->AddGlobalValue(std::move(v)); } void IRContext::AddFunctionDeclaration(std::unique_ptr&& f) { module()->AddFunctionDeclaration(std::move(f)); } void IRContext::AddFunction(std::unique_ptr&& f) { module()->AddFunction(std::move(f)); } void IRContext::AnalyzeDefUse(Instruction* inst) { if (AreAnalysesValid(kAnalysisDefUse)) { get_def_use_mgr()->AnalyzeInstDefUse(inst); } } void IRContext::UpdateDefUse(Instruction* inst) { if (AreAnalysesValid(kAnalysisDefUse)) { get_def_use_mgr()->UpdateDefUse(inst); } } void IRContext::BuildIdToNameMap() { id_to_name_ = MakeUnique>(); for (Instruction& debug_inst : debugs2()) { if (debug_inst.opcode() == spv::Op::OpMemberName || debug_inst.opcode() == spv::Op::OpName) { id_to_name_->insert({debug_inst.GetSingleWordInOperand(0), &debug_inst}); } } valid_analyses_ = valid_analyses_ | kAnalysisNameMap; } IteratorRange::iterator> IRContext::GetNames(uint32_t id) { if (!AreAnalysesValid(kAnalysisNameMap)) { BuildIdToNameMap(); } auto result = id_to_name_->equal_range(id); return make_range(std::move(result.first), std::move(result.second)); } Instruction* IRContext::GetMemberName(uint32_t struct_type_id, uint32_t index) { if (!AreAnalysesValid(kAnalysisNameMap)) { BuildIdToNameMap(); } auto result = id_to_name_->equal_range(struct_type_id); for (auto i = result.first; i != result.second; ++i) { auto* name_instr = i->second; if (name_instr->opcode() == spv::Op::OpMemberName && name_instr->GetSingleWordInOperand(1) == index) { return name_instr; } } return nullptr; } void IRContext::CloneNames(const uint32_t old_id, const uint32_t new_id, const uint32_t max_member_index) { std::vector> names_to_add; auto names = GetNames(old_id); for (auto n : names) { Instruction* old_name_inst = n.second; if (old_name_inst->opcode() == spv::Op::OpMemberName) { auto midx = old_name_inst->GetSingleWordInOperand(1); if (midx >= max_member_index) continue; } std::unique_ptr new_name_inst(old_name_inst->Clone(this)); new_name_inst->SetInOperand(0, {new_id}); names_to_add.push_back(std::move(new_name_inst)); } // We can't add the new names when we are iterating over name range above. // We can add all the new names now. for (auto& new_name : names_to_add) AddDebug2Inst(std::move(new_name)); } } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_IR_CONTEXT_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/ir_loader.cpp000066400000000000000000000353471475742701700233130ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/ir_loader.h" #include #include "DebugInfo.h" #include "OpenCLDebugInfo100.h" #include "source/ext_inst.h" #include "source/opt/ir_context.h" #include "source/opt/log.h" #include "source/opt/reflect.h" #include "source/util/make_unique.h" namespace spvtools { namespace opt { namespace { constexpr uint32_t kExtInstSetIndex = 4; constexpr uint32_t kLexicalScopeIndex = 5; constexpr uint32_t kInlinedAtIndex = 6; } // namespace IrLoader::IrLoader(const MessageConsumer& consumer, Module* m) : consumer_(consumer), module_(m), source_(""), inst_index_(0), last_dbg_scope_(kNoDebugScope, kNoInlinedAt) {} bool IsLineInst(const spv_parsed_instruction_t* inst) { const auto opcode = static_cast(inst->opcode); if (IsOpLineInst(opcode)) return true; if (!spvIsExtendedInstruction(opcode)) return false; if (inst->ext_inst_type != SPV_EXT_INST_TYPE_NONSEMANTIC_SHADER_DEBUGINFO_100) return false; const uint32_t ext_inst_index = inst->words[kExtInstSetIndex]; const NonSemanticShaderDebugInfo100Instructions ext_inst_key = NonSemanticShaderDebugInfo100Instructions(ext_inst_index); return ext_inst_key == NonSemanticShaderDebugInfo100DebugLine || ext_inst_key == NonSemanticShaderDebugInfo100DebugNoLine; } bool IrLoader::AddInstruction(const spv_parsed_instruction_t* inst) { ++inst_index_; if (IsLineInst(inst)) { module()->SetContainsDebugInfo(); last_line_inst_.reset(); dbg_line_info_.emplace_back(module()->context(), *inst, last_dbg_scope_); return true; } // If it is a DebugScope or DebugNoScope of debug extension, we do not // create a new instruction, but simply keep the information in // struct DebugScope. const auto opcode = static_cast(inst->opcode); if (spvIsExtendedInstruction(opcode) && spvExtInstIsDebugInfo(inst->ext_inst_type)) { const uint32_t ext_inst_index = inst->words[kExtInstSetIndex]; if (inst->ext_inst_type == SPV_EXT_INST_TYPE_OPENCL_DEBUGINFO_100 || inst->ext_inst_type == SPV_EXT_INST_TYPE_NONSEMANTIC_SHADER_DEBUGINFO_100) { const CommonDebugInfoInstructions ext_inst_key = CommonDebugInfoInstructions(ext_inst_index); if (ext_inst_key == CommonDebugInfoDebugScope) { uint32_t inlined_at = 0; if (inst->num_words > kInlinedAtIndex) inlined_at = inst->words[kInlinedAtIndex]; last_dbg_scope_ = DebugScope(inst->words[kLexicalScopeIndex], inlined_at); module()->SetContainsDebugInfo(); return true; } if (ext_inst_key == CommonDebugInfoDebugNoScope) { last_dbg_scope_ = DebugScope(kNoDebugScope, kNoInlinedAt); module()->SetContainsDebugInfo(); return true; } } else { const DebugInfoInstructions ext_inst_key = DebugInfoInstructions(ext_inst_index); if (ext_inst_key == DebugInfoDebugScope) { uint32_t inlined_at = 0; if (inst->num_words > kInlinedAtIndex) inlined_at = inst->words[kInlinedAtIndex]; last_dbg_scope_ = DebugScope(inst->words[kLexicalScopeIndex], inlined_at); module()->SetContainsDebugInfo(); return true; } if (ext_inst_key == DebugInfoDebugNoScope) { last_dbg_scope_ = DebugScope(kNoDebugScope, kNoInlinedAt); module()->SetContainsDebugInfo(); return true; } } } std::unique_ptr spv_inst( new Instruction(module()->context(), *inst, std::move(dbg_line_info_))); if (!spv_inst->dbg_line_insts().empty()) { if (extra_line_tracking_ && (!spv_inst->dbg_line_insts().back().IsNoLine())) { last_line_inst_ = std::unique_ptr( spv_inst->dbg_line_insts().back().Clone(module()->context())); if (last_line_inst_->IsDebugLineInst()) last_line_inst_->SetResultId(module()->context()->TakeNextId()); } dbg_line_info_.clear(); } else if (last_line_inst_ != nullptr) { last_line_inst_->SetDebugScope(last_dbg_scope_); spv_inst->dbg_line_insts().push_back(*last_line_inst_); last_line_inst_ = std::unique_ptr( spv_inst->dbg_line_insts().back().Clone(module()->context())); if (last_line_inst_->IsDebugLineInst()) last_line_inst_->SetResultId(module()->context()->TakeNextId()); } const char* src = source_.c_str(); spv_position_t loc = {inst_index_, 0, 0}; // Handle function and basic block boundaries first, then normal // instructions. if (opcode == spv::Op::OpFunction) { if (function_ != nullptr) { Error(consumer_, src, loc, "function inside function"); return false; } function_ = MakeUnique(std::move(spv_inst)); } else if (opcode == spv::Op::OpFunctionEnd) { if (function_ == nullptr) { Error(consumer_, src, loc, "OpFunctionEnd without corresponding OpFunction"); return false; } if (block_ != nullptr) { Error(consumer_, src, loc, "OpFunctionEnd inside basic block"); return false; } function_->SetFunctionEnd(std::move(spv_inst)); module_->AddFunction(std::move(function_)); function_ = nullptr; } else if (opcode == spv::Op::OpLabel) { if (function_ == nullptr) { Error(consumer_, src, loc, "OpLabel outside function"); return false; } if (block_ != nullptr) { Error(consumer_, src, loc, "OpLabel inside basic block"); return false; } block_ = MakeUnique(std::move(spv_inst)); } else if (spvOpcodeIsBlockTerminator(opcode)) { if (function_ == nullptr) { Error(consumer_, src, loc, "terminator instruction outside function"); return false; } if (block_ == nullptr) { Error(consumer_, src, loc, "terminator instruction outside basic block"); return false; } if (last_dbg_scope_.GetLexicalScope() != kNoDebugScope) spv_inst->SetDebugScope(last_dbg_scope_); block_->AddInstruction(std::move(spv_inst)); function_->AddBasicBlock(std::move(block_)); block_ = nullptr; last_dbg_scope_ = DebugScope(kNoDebugScope, kNoInlinedAt); last_line_inst_.reset(); dbg_line_info_.clear(); } else { if (function_ == nullptr) { // Outside function definition SPIRV_ASSERT(consumer_, block_ == nullptr); if (opcode == spv::Op::OpCapability) { module_->AddCapability(std::move(spv_inst)); } else if (opcode == spv::Op::OpExtension) { module_->AddExtension(std::move(spv_inst)); } else if (opcode == spv::Op::OpExtInstImport) { module_->AddExtInstImport(std::move(spv_inst)); } else if (opcode == spv::Op::OpMemoryModel) { module_->SetMemoryModel(std::move(spv_inst)); } else if (opcode == spv::Op::OpSamplerImageAddressingModeNV) { module_->SetSampledImageAddressMode(std::move(spv_inst)); } else if (opcode == spv::Op::OpEntryPoint) { module_->AddEntryPoint(std::move(spv_inst)); } else if (opcode == spv::Op::OpExecutionMode || opcode == spv::Op::OpExecutionModeId) { module_->AddExecutionMode(std::move(spv_inst)); } else if (IsDebug1Inst(opcode)) { module_->AddDebug1Inst(std::move(spv_inst)); } else if (IsDebug2Inst(opcode)) { module_->AddDebug2Inst(std::move(spv_inst)); } else if (IsDebug3Inst(opcode)) { module_->AddDebug3Inst(std::move(spv_inst)); } else if (IsAnnotationInst(opcode)) { module_->AddAnnotationInst(std::move(spv_inst)); } else if (IsTypeInst(opcode)) { module_->AddType(std::move(spv_inst)); } else if (IsConstantInst(opcode) || opcode == spv::Op::OpVariable || opcode == spv::Op::OpUndef) { module_->AddGlobalValue(std::move(spv_inst)); } else if (spvIsExtendedInstruction(opcode) && spvExtInstIsDebugInfo(inst->ext_inst_type)) { module_->AddExtInstDebugInfo(std::move(spv_inst)); } else if (spvIsExtendedInstruction(opcode) && spvExtInstIsNonSemantic(inst->ext_inst_type)) { // If there are no functions, add the non-semantic instructions to the // global values. Otherwise append it to the list of the last function. auto func_begin = module_->begin(); auto func_end = module_->end(); if (func_begin == func_end) { module_->AddGlobalValue(std::move(spv_inst)); } else { (--func_end)->AddNonSemanticInstruction(std::move(spv_inst)); } } else { Errorf(consumer_, src, loc, "Unhandled inst type (opcode: %d) found outside function " "definition.", opcode); return false; } } else { if (opcode == spv::Op::OpLoopMerge || opcode == spv::Op::OpSelectionMerge) last_dbg_scope_ = DebugScope(kNoDebugScope, kNoInlinedAt); if (last_dbg_scope_.GetLexicalScope() != kNoDebugScope) spv_inst->SetDebugScope(last_dbg_scope_); if (spvIsExtendedInstruction(opcode) && spvExtInstIsDebugInfo(inst->ext_inst_type)) { const uint32_t ext_inst_index = inst->words[kExtInstSetIndex]; if (inst->ext_inst_type == SPV_EXT_INST_TYPE_OPENCL_DEBUGINFO_100) { const OpenCLDebugInfo100Instructions ext_inst_key = OpenCLDebugInfo100Instructions(ext_inst_index); switch (ext_inst_key) { case OpenCLDebugInfo100DebugDeclare: { if (block_ == nullptr) // Inside function but outside blocks function_->AddDebugInstructionInHeader(std::move(spv_inst)); else block_->AddInstruction(std::move(spv_inst)); break; } case OpenCLDebugInfo100DebugValue: { if (block_ == nullptr) // Inside function but outside blocks function_->AddDebugInstructionInHeader(std::move(spv_inst)); else block_->AddInstruction(std::move(spv_inst)); break; } default: { Errorf(consumer_, src, loc, "Debug info extension instruction other than DebugScope, " "DebugNoScope, DebugFunctionDefinition, DebugDeclare, and " "DebugValue found inside function", opcode); return false; } } } else if (inst->ext_inst_type == SPV_EXT_INST_TYPE_NONSEMANTIC_SHADER_DEBUGINFO_100) { const NonSemanticShaderDebugInfo100Instructions ext_inst_key = NonSemanticShaderDebugInfo100Instructions(ext_inst_index); switch (ext_inst_key) { case NonSemanticShaderDebugInfo100DebugDeclare: case NonSemanticShaderDebugInfo100DebugValue: case NonSemanticShaderDebugInfo100DebugScope: case NonSemanticShaderDebugInfo100DebugNoScope: case NonSemanticShaderDebugInfo100DebugFunctionDefinition: { if (block_ == nullptr) { // Inside function but outside blocks Errorf(consumer_, src, loc, "Debug info extension instruction found inside function " "but outside block", opcode); } else { block_->AddInstruction(std::move(spv_inst)); } break; } default: { Errorf(consumer_, src, loc, "Debug info extension instruction other than DebugScope, " "DebugNoScope, DebugDeclare, and DebugValue found inside " "function", opcode); return false; } } } else { const DebugInfoInstructions ext_inst_key = DebugInfoInstructions(ext_inst_index); switch (ext_inst_key) { case DebugInfoDebugDeclare: { if (block_ == nullptr) // Inside function but outside blocks function_->AddDebugInstructionInHeader(std::move(spv_inst)); else block_->AddInstruction(std::move(spv_inst)); break; } case DebugInfoDebugValue: { if (block_ == nullptr) // Inside function but outside blocks function_->AddDebugInstructionInHeader(std::move(spv_inst)); else block_->AddInstruction(std::move(spv_inst)); break; } default: { Errorf(consumer_, src, loc, "Debug info extension instruction other than DebugScope, " "DebugNoScope, DebugDeclare, and DebugValue found inside " "function", opcode); return false; } } } } else { if (block_ == nullptr) { // Inside function but outside blocks if (opcode != spv::Op::OpFunctionParameter) { Errorf(consumer_, src, loc, "Non-OpFunctionParameter (opcode: %d) found inside " "function but outside basic block", opcode); return false; } function_->AddParameter(std::move(spv_inst)); } else { block_->AddInstruction(std::move(spv_inst)); } } } } return true; } // Resolves internal references among the module, functions, basic blocks, etc. // This function should be called after adding all instructions. void IrLoader::EndModule() { if (block_ && function_) { // We're in the middle of a basic block, but the terminator is missing. // Register the block anyway. This lets us write tests with less // boilerplate. function_->AddBasicBlock(std::move(block_)); block_ = nullptr; } if (function_) { // We're in the middle of a function, but the OpFunctionEnd is missing. // Register the function anyway. This lets us write tests with less // boilerplate. module_->AddFunction(std::move(function_)); function_ = nullptr; } for (auto& function : *module_) { for (auto& bb : function) bb.SetParent(&function); } // Copy any trailing Op*Line instruction into the module module_->SetTrailingDbgLineInfo(std::move(dbg_line_info_)); } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/ir_loader.h000066400000000000000000000100311475742701700227370ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_IR_LOADER_H_ #define SOURCE_OPT_IR_LOADER_H_ #include #include #include #include "source/opt/basic_block.h" #include "source/opt/instruction.h" #include "source/opt/module.h" #include "spirv-tools/libspirv.hpp" namespace spvtools { namespace opt { // Loader class for constructing SPIR-V in-memory IR representation. Methods in // this class are designed to work with the interface for spvBinaryParse() in // libspirv.h so that we can leverage the syntax checks implemented behind it. // // The user is expected to call SetModuleHeader() to fill in the module's // header, and then AddInstruction() for each decoded instruction, and finally // EndModule() to finalize the module. The instructions processed in sequence // by AddInstruction() should comprise a valid SPIR-V module. class IrLoader { public: // Instantiates a builder to construct the given |module| gradually. // All internal messages will be communicated to the outside via the given // message |consumer|. This instance only keeps a reference to the |consumer|, // so the |consumer| should outlive this instance. IrLoader(const MessageConsumer& consumer, Module* m); // Sets the source name of the module. void SetSource(const std::string& src) { source_ = src; } Module* module() const { return module_; } // Sets the fields in the module's header to the given parameters. void SetModuleHeader(uint32_t magic, uint32_t version, uint32_t generator, uint32_t bound, uint32_t reserved) { module_->SetHeader({magic, version, generator, bound, reserved}); } // Adds an instruction to the module. Returns true if no error occurs. This // method will properly capture and store the data provided in |inst| so that // |inst| is no longer needed after returning. bool AddInstruction(const spv_parsed_instruction_t* inst); // Finalizes the module construction. This must be called after the module // header has been set and all instructions have been added. This is // forgiving in the case of a missing terminator instruction on a basic block, // or a missing OpFunctionEnd. Resolves internal bookkeeping. void EndModule(); // Sets whether extra OpLine instructions should be injected to better // track line information. void SetExtraLineTracking(bool flag) { extra_line_tracking_ = flag; } private: // Consumer for communicating messages to outside. const MessageConsumer& consumer_; // The module to be built. Module* module_; // The source name of the module. std::string source_; // The last used instruction index. uint32_t inst_index_; // The current Function under construction. std::unique_ptr function_; // The current BasicBlock under construction. std::unique_ptr block_; // Line related debug instructions accumulated thus far. std::vector dbg_line_info_; // If doing extra line tracking, this is the line instruction that should be // applied to the next instruction. Otherwise it always contains null. std::unique_ptr last_line_inst_; // The last DebugScope information that IrLoader::AddInstruction() handled. DebugScope last_dbg_scope_; // When true, do extra line information tracking: Additional OpLine // instructions will be injected to help track line info more robustly during // transformations. bool extra_line_tracking_ = true; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_IR_LOADER_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/iterator.h000066400000000000000000000306201475742701700226360ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_ITERATOR_H_ #define SOURCE_OPT_ITERATOR_H_ #include // for ptrdiff_t #include #include #include #include #include namespace spvtools { namespace opt { // An ad hoc iterator class for std::vector>. The // purpose of this iterator class is to provide transparent access to those // std::unique_ptr managed elements in the vector, behaving like we are using // std::vector<|ValueType|>. template class UptrVectorIterator { public: using iterator_category = std::random_access_iterator_tag; using value_type = ValueType; using pointer = value_type*; using reference = value_type&; using difference_type = std::ptrdiff_t; // Type aliases. We need to apply constness properly if |IsConst| is true. using Uptr = std::unique_ptr; using UptrVector = typename std::conditional, std::vector>::type; using UnderlyingIterator = typename std::conditional::type; // Creates a new iterator from the given |container| and its raw iterator // |it|. UptrVectorIterator(UptrVector* container, const UnderlyingIterator& it) : container_(container), iterator_(it) {} UptrVectorIterator(const UptrVectorIterator&) = default; UptrVectorIterator& operator=(const UptrVectorIterator&) = default; inline UptrVectorIterator& operator++(); inline UptrVectorIterator operator++(int); inline UptrVectorIterator& operator--(); inline UptrVectorIterator operator--(int); reference operator*() const { return **iterator_; } pointer operator->() { return (*iterator_).get(); } reference operator[](ptrdiff_t index) { return **(iterator_ + index); } inline bool operator==(const UptrVectorIterator& that) const; inline bool operator!=(const UptrVectorIterator& that) const; inline ptrdiff_t operator-(const UptrVectorIterator& that) const; inline bool operator<(const UptrVectorIterator& that) const; // Inserts the given |value| to the position pointed to by this iterator // and returns an iterator to the newly iserted |value|. // If the underlying vector changes capacity, all previous iterators will be // invalidated. Otherwise, those previous iterators pointing to after the // insertion point will be invalidated. template inline typename std::enable_if::type InsertBefore(Uptr value); // Inserts the given |valueVector| to the position pointed to by this iterator // and returns an iterator to the first newly inserted value. // If the underlying vector changes capacity, all previous iterators will be // invalidated. Otherwise, those previous iterators pointing to after the // insertion point will be invalidated. template inline typename std::enable_if::type InsertBefore(UptrVector* valueVector); // Erases the value at the position pointed to by this iterator // and returns an iterator to the following value. // If the underlying vector changes capacity, all previous iterators will be // invalidated. Otherwise, those previous iterators pointing to after the // erasure point will be invalidated. template inline typename std::enable_if::type Erase(); // Returns the underlying iterator. UnderlyingIterator Get() const { return iterator_; } // Returns a valid end iterator for the underlying container. UptrVectorIterator End() const { return UptrVectorIterator(container_, container_->end()); } private: UptrVector* container_; // The container we are manipulating. UnderlyingIterator iterator_; // The raw iterator from the container. }; // Handy class for a (begin, end) iterator pair. template class IteratorRange { public: IteratorRange(const IteratorType& b, const IteratorType& e) : begin_(b), end_(e) {} IteratorRange(IteratorType&& b, IteratorType&& e) : begin_(std::move(b)), end_(std::move(e)) {} IteratorType begin() const { return begin_; } IteratorType end() const { return end_; } bool empty() const { return begin_ == end_; } size_t size() const { return end_ - begin_; } private: IteratorType begin_; IteratorType end_; }; // Returns a (begin, end) iterator pair for the given iterators. // The iterators must belong to the same container. template inline IteratorRange make_range(const IteratorType& begin, const IteratorType& end) { return {begin, end}; } // Returns a (begin, end) iterator pair for the given iterators. // The iterators must belong to the same container. template inline IteratorRange make_range(IteratorType&& begin, IteratorType&& end) { return {std::forward(begin), std::forward(end)}; } // Returns a (begin, end) iterator pair for the given container. template > inline IteratorRange make_range( std::vector>& container) { return {IteratorType(&container, container.begin()), IteratorType(&container, container.end())}; } // Returns a const (begin, end) iterator pair for the given container. template > inline IteratorRange make_const_range( const std::vector>& container) { return {IteratorType(&container, container.cbegin()), IteratorType(&container, container.cend())}; } // Wrapping iterator class that only consider elements that satisfy the given // predicate |Predicate|. When moving to the next element of the iterator, the // FilterIterator will iterate over the range until it finds an element that // satisfies |Predicate| or reaches the end of the iterator. // // Currently this iterator is always an input iterator. template class FilterIterator { public: // Iterator interface. using iterator_category = typename SubIterator::iterator_category; using value_type = typename SubIterator::value_type; using pointer = typename SubIterator::pointer; using reference = typename SubIterator::reference; using difference_type = typename SubIterator::difference_type; using Range = IteratorRange; FilterIterator(const IteratorRange& iteration_range, Predicate predicate) : cur_(iteration_range.begin()), end_(iteration_range.end()), predicate_(predicate) { if (!IsPredicateSatisfied()) { MoveToNextPosition(); } } FilterIterator(const SubIterator& end, Predicate predicate) : FilterIterator({end, end}, predicate) {} inline FilterIterator& operator++() { MoveToNextPosition(); return *this; } inline FilterIterator operator++(int) { FilterIterator old = *this; MoveToNextPosition(); return old; } reference operator*() const { return *cur_; } pointer operator->() { return &*cur_; } inline bool operator==(const FilterIterator& rhs) const { return cur_ == rhs.cur_ && end_ == rhs.end_; } inline bool operator!=(const FilterIterator& rhs) const { return !(*this == rhs); } // Returns the underlying iterator. SubIterator Get() const { return cur_; } // Returns the sentinel iterator. FilterIterator GetEnd() const { return FilterIterator(end_, predicate_); } private: // Returns true if the predicate is satisfied or the current iterator reached // the end. bool IsPredicateSatisfied() { return cur_ == end_ || predicate_(*cur_); } void MoveToNextPosition() { if (cur_ == end_) return; do { ++cur_; } while (!IsPredicateSatisfied()); } SubIterator cur_; SubIterator end_; Predicate predicate_; }; template FilterIterator MakeFilterIterator( const IteratorRange& sub_iterator_range, Predicate predicate) { return FilterIterator(sub_iterator_range, predicate); } template FilterIterator MakeFilterIterator( const SubIterator& begin, const SubIterator& end, Predicate predicate) { return MakeFilterIterator(make_range(begin, end), predicate); } template typename FilterIterator::Range MakeFilterIteratorRange( const SubIterator& begin, const SubIterator& end, Predicate predicate) { return typename FilterIterator::Range( MakeFilterIterator(begin, end, predicate), MakeFilterIterator(end, end, predicate)); } template inline UptrVectorIterator& UptrVectorIterator::operator++() { ++iterator_; return *this; } template inline UptrVectorIterator UptrVectorIterator::operator++(int) { auto it = *this; ++(*this); return it; } template inline UptrVectorIterator& UptrVectorIterator::operator--() { --iterator_; return *this; } template inline UptrVectorIterator UptrVectorIterator::operator--(int) { auto it = *this; --(*this); return it; } template inline bool UptrVectorIterator::operator==( const UptrVectorIterator& that) const { return container_ == that.container_ && iterator_ == that.iterator_; } template inline bool UptrVectorIterator::operator!=( const UptrVectorIterator& that) const { return !(*this == that); } template inline ptrdiff_t UptrVectorIterator::operator-( const UptrVectorIterator& that) const { assert(container_ == that.container_); return iterator_ - that.iterator_; } template inline bool UptrVectorIterator::operator<( const UptrVectorIterator& that) const { assert(container_ == that.container_); return iterator_ < that.iterator_; } template template inline typename std::enable_if>::type UptrVectorIterator::InsertBefore(Uptr value) { auto index = iterator_ - container_->begin(); container_->insert(iterator_, std::move(value)); return UptrVectorIterator(container_, container_->begin() + index); } template template inline typename std::enable_if>::type UptrVectorIterator::InsertBefore(UptrVector* values) { const auto pos = iterator_ - container_->begin(); const auto origsz = container_->size(); container_->resize(origsz + values->size()); std::move_backward(container_->begin() + pos, container_->begin() + origsz, container_->end()); std::move(values->begin(), values->end(), container_->begin() + pos); return UptrVectorIterator(container_, container_->begin() + pos); } template template inline typename std::enable_if>::type UptrVectorIterator::Erase() { auto index = iterator_ - container_->begin(); (void)container_->erase(iterator_); return UptrVectorIterator(container_, container_->begin() + index); } } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_ITERATOR_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/licm_pass.cpp000066400000000000000000000105371475742701700233170ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/licm_pass.h" #include #include "source/opt/module.h" #include "source/opt/pass.h" namespace spvtools { namespace opt { Pass::Status LICMPass::Process() { return ProcessIRContext(); } Pass::Status LICMPass::ProcessIRContext() { Status status = Status::SuccessWithoutChange; Module* module = get_module(); // Process each function in the module for (auto func = module->begin(); func != module->end() && status != Status::Failure; ++func) { status = CombineStatus(status, ProcessFunction(&*func)); } return status; } Pass::Status LICMPass::ProcessFunction(Function* f) { Status status = Status::SuccessWithoutChange; LoopDescriptor* loop_descriptor = context()->GetLoopDescriptor(f); // Process each loop in the function for (auto it = loop_descriptor->begin(); it != loop_descriptor->end() && status != Status::Failure; ++it) { Loop& loop = *it; // Ignore nested loops, as we will process them in order in ProcessLoop if (loop.IsNested()) { continue; } status = CombineStatus(status, ProcessLoop(&loop, f)); } return status; } Pass::Status LICMPass::ProcessLoop(Loop* loop, Function* f) { Status status = Status::SuccessWithoutChange; // Process all nested loops first for (auto nl = loop->begin(); nl != loop->end() && status != Status::Failure; ++nl) { Loop* nested_loop = *nl; status = CombineStatus(status, ProcessLoop(nested_loop, f)); } std::vector loop_bbs{}; status = CombineStatus( status, AnalyseAndHoistFromBB(loop, f, loop->GetHeaderBlock(), &loop_bbs)); for (size_t i = 0; i < loop_bbs.size() && status != Status::Failure; ++i) { BasicBlock* bb = loop_bbs[i]; // do not delete the element status = CombineStatus(status, AnalyseAndHoistFromBB(loop, f, bb, &loop_bbs)); } return status; } Pass::Status LICMPass::AnalyseAndHoistFromBB( Loop* loop, Function* f, BasicBlock* bb, std::vector* loop_bbs) { bool modified = false; std::function hoist_inst = [this, &loop, &modified](Instruction* inst) { if (loop->ShouldHoistInstruction(*inst)) { if (!HoistInstruction(loop, inst)) { return false; } modified = true; } return true; }; if (IsImmediatelyContainedInLoop(loop, f, bb)) { if (!bb->WhileEachInst(hoist_inst, false)) { return Status::Failure; } } DominatorAnalysis* dom_analysis = context()->GetDominatorAnalysis(f); DominatorTree& dom_tree = dom_analysis->GetDomTree(); for (DominatorTreeNode* child_dom_tree_node : *dom_tree.GetTreeNode(bb)) { if (loop->IsInsideLoop(child_dom_tree_node->bb_)) { loop_bbs->push_back(child_dom_tree_node->bb_); } } return (modified ? Status::SuccessWithChange : Status::SuccessWithoutChange); } bool LICMPass::IsImmediatelyContainedInLoop(Loop* loop, Function* f, BasicBlock* bb) { LoopDescriptor* loop_descriptor = context()->GetLoopDescriptor(f); return loop == (*loop_descriptor)[bb->id()]; } bool LICMPass::HoistInstruction(Loop* loop, Instruction* inst) { // TODO(1841): Handle failure to create pre-header. BasicBlock* pre_header_bb = loop->GetOrCreatePreHeaderBlock(); if (!pre_header_bb) { return false; } Instruction* insertion_point = &*pre_header_bb->tail(); Instruction* previous_node = insertion_point->PreviousNode(); if (previous_node && (previous_node->opcode() == spv::Op::OpLoopMerge || previous_node->opcode() == spv::Op::OpSelectionMerge)) { insertion_point = previous_node; } inst->InsertBefore(insertion_point); context()->set_instr_block(inst, pre_header_bb); return true; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/licm_pass.h000066400000000000000000000050641475742701700227630ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_LICM_PASS_H_ #define SOURCE_OPT_LICM_PASS_H_ #include #include #include "source/opt/basic_block.h" #include "source/opt/instruction.h" #include "source/opt/loop_descriptor.h" #include "source/opt/pass.h" namespace spvtools { namespace opt { class LICMPass : public Pass { public: LICMPass() {} const char* name() const override { return "loop-invariant-code-motion"; } Status Process() override; private: // Searches the IRContext for functions and processes each, moving invariants // outside loops within the function where possible. // Returns the status depending on whether or not there was a failure or // change. Pass::Status ProcessIRContext(); // Checks the function for loops, calling ProcessLoop on each one found. // Returns the status depending on whether or not there was a failure or // change. Pass::Status ProcessFunction(Function* f); // Checks for invariants in the loop and attempts to move them to the loops // preheader. Works from inner loop to outer when nested loops are found. // Returns the status depending on whether or not there was a failure or // change. Pass::Status ProcessLoop(Loop* loop, Function* f); // Analyses each instruction in |bb|, hoisting invariants to |pre_header_bb|. // Each child of |bb| wrt to |dom_tree| is pushed to |loop_bbs| // Returns the status depending on whether or not there was a failure or // change. Pass::Status AnalyseAndHoistFromBB(Loop* loop, Function* f, BasicBlock* bb, std::vector* loop_bbs); // Returns true if |bb| is immediately contained in |loop| bool IsImmediatelyContainedInLoop(Loop* loop, Function* f, BasicBlock* bb); // Move the instruction to the preheader of |loop|. // This method will update the instruction to block mapping for the context bool HoistInstruction(Loop* loop, Instruction* inst); }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_LICM_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/liveness.cpp000066400000000000000000000335351475742701700232000ustar00rootroot00000000000000// Copyright (c) 2022 The Khronos Group Inc. // Copyright (c) 2022 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/liveness.h" #include "source/opt/ir_context.h" namespace spvtools { namespace opt { namespace analysis { namespace { constexpr uint32_t kDecorationLocationInIdx = 2; constexpr uint32_t kOpDecorateMemberMemberInIdx = 1; constexpr uint32_t kOpDecorateMemberLocationInIdx = 3; constexpr uint32_t kOpDecorateBuiltInLiteralInIdx = 2; constexpr uint32_t kOpDecorateMemberBuiltInLiteralInIdx = 3; } // namespace LivenessManager::LivenessManager(IRContext* ctx) : ctx_(ctx), computed_(false) { // Liveness sets computed when queried } void LivenessManager::InitializeAnalysis() { live_locs_.clear(); live_builtins_.clear(); // Mark all builtins live for frag shader. if (context()->GetStage() == spv::ExecutionModel::Fragment) { live_builtins_.insert(uint32_t(spv::BuiltIn::PointSize)); live_builtins_.insert(uint32_t(spv::BuiltIn::ClipDistance)); live_builtins_.insert(uint32_t(spv::BuiltIn::CullDistance)); } } bool LivenessManager::IsAnalyzedBuiltin(uint32_t bi) { // There are only three builtins that can be analyzed and removed between // two stages: PointSize, ClipDistance and CullDistance. All others are // always consumed implicitly by the downstream stage. const auto builtin = spv::BuiltIn(bi); return builtin == spv::BuiltIn::PointSize || builtin == spv::BuiltIn::ClipDistance || builtin == spv::BuiltIn::CullDistance; } bool LivenessManager::AnalyzeBuiltIn(uint32_t id) { auto deco_mgr = context()->get_decoration_mgr(); bool saw_builtin = false; // Analyze all builtin decorations of |id|. (void)deco_mgr->ForEachDecoration( id, uint32_t(spv::Decoration::BuiltIn), [this, &saw_builtin](const Instruction& deco_inst) { saw_builtin = true; // No need to process builtins in frag shader. All assumed used. if (context()->GetStage() == spv::ExecutionModel::Fragment) return; uint32_t builtin = uint32_t(spv::BuiltIn::Max); if (deco_inst.opcode() == spv::Op::OpDecorate) builtin = deco_inst.GetSingleWordInOperand(kOpDecorateBuiltInLiteralInIdx); else if (deco_inst.opcode() == spv::Op::OpMemberDecorate) builtin = deco_inst.GetSingleWordInOperand( kOpDecorateMemberBuiltInLiteralInIdx); else assert(false && "unexpected decoration"); if (IsAnalyzedBuiltin(builtin)) live_builtins_.insert(builtin); }); return saw_builtin; } void LivenessManager::MarkLocsLive(uint32_t start, uint32_t count) { auto finish = start + count; for (uint32_t u = start; u < finish; ++u) { live_locs_.insert(u); } } uint32_t LivenessManager::GetLocSize(const analysis::Type* type) const { auto arr_type = type->AsArray(); if (arr_type) { auto comp_type = arr_type->element_type(); auto len_info = arr_type->length_info(); assert(len_info.words[0] == analysis::Array::LengthInfo::kConstant && "unexpected array length"); auto comp_len = len_info.words[1]; return comp_len * GetLocSize(comp_type); } auto struct_type = type->AsStruct(); if (struct_type) { uint32_t size = 0u; for (auto& el_type : struct_type->element_types()) size += GetLocSize(el_type); return size; } auto mat_type = type->AsMatrix(); if (mat_type) { auto cnt = mat_type->element_count(); auto comp_type = mat_type->element_type(); return cnt * GetLocSize(comp_type); } auto vec_type = type->AsVector(); if (vec_type) { auto comp_type = vec_type->element_type(); if (comp_type->AsInteger()) return 1; auto float_type = comp_type->AsFloat(); assert(float_type && "unexpected vector component type"); auto width = float_type->width(); if (width == 32 || width == 16) return 1; assert(width == 64 && "unexpected float type width"); auto comp_cnt = vec_type->element_count(); return (comp_cnt > 2) ? 2 : 1; } assert((type->AsInteger() || type->AsFloat()) && "unexpected input type"); return 1; } uint32_t LivenessManager::GetComponentType(uint32_t index, uint32_t agg_type_id) const { analysis::DefUseManager* def_use_mgr = context()->get_def_use_mgr(); Instruction* agg_type_inst = def_use_mgr->GetDef(agg_type_id); const uint32_t kArrayElementInIdx = 0; switch (agg_type_inst->opcode()) { case spv::Op::OpTypeArray: case spv::Op::OpTypeMatrix: case spv::Op::OpTypeVector: return agg_type_inst->GetSingleWordInOperand(kArrayElementInIdx); case spv::Op::OpTypeStruct: return agg_type_inst->GetSingleWordInOperand(index); default: assert(false && "unexpected aggregate type"); return 0; } } uint32_t LivenessManager::GetLocOffset(uint32_t index, uint32_t agg_type_id) const { analysis::TypeManager* type_mgr = context()->get_type_mgr(); const analysis::Type* agg_type = type_mgr->GetType(agg_type_id); auto arr_type = agg_type->AsArray(); if (arr_type) return index * GetLocSize(arr_type->element_type()); auto struct_type = agg_type->AsStruct(); if (struct_type) { uint32_t offset = 0u; uint32_t cnt = 0u; for (auto& el_type : struct_type->element_types()) { if (cnt == index) break; offset += GetLocSize(el_type); ++cnt; } return offset; } auto mat_type = agg_type->AsMatrix(); if (mat_type) return index * GetLocSize(mat_type->element_type()); auto vec_type = agg_type->AsVector(); assert(vec_type && "unexpected non-aggregate type"); auto comp_type = vec_type->element_type(); auto flt_type = comp_type->AsFloat(); if (flt_type && flt_type->width() == 64u && index >= 2u) return 1; return 0; } uint32_t LivenessManager::AnalyzeAccessChainLoc(const Instruction* ac, uint32_t curr_type_id, uint32_t* offset, bool* no_loc, bool is_patch, bool input) { analysis::DefUseManager* def_use_mgr = context()->get_def_use_mgr(); analysis::DecorationManager* deco_mgr = context()->get_decoration_mgr(); // For tesc, tese and geom input variables, and tesc output variables, // first array index does not contribute to offset. auto stage = context()->GetStage(); bool skip_first_index = false; if ((input && (stage == spv::ExecutionModel::TessellationControl || stage == spv::ExecutionModel::TessellationEvaluation || stage == spv::ExecutionModel::Geometry)) || (!input && stage == spv::ExecutionModel::TessellationControl)) skip_first_index = !is_patch; uint32_t ocnt = 0; ac->WhileEachInOperand([this, &ocnt, def_use_mgr, deco_mgr, &curr_type_id, offset, no_loc, skip_first_index](const uint32_t* opnd) { if (ocnt >= 1) { // Skip first index's contribution to offset if indicated Instruction* curr_type_inst = def_use_mgr->GetDef(curr_type_id); if (ocnt == 1 && skip_first_index) { assert(curr_type_inst->opcode() == spv::Op::OpTypeArray && "unexpected wrapper type"); const uint32_t kArrayElementTypeInIdx = 0; curr_type_id = curr_type_inst->GetSingleWordInOperand(kArrayElementTypeInIdx); ocnt++; return true; } // If any non-constant index, mark the entire current object and return. auto idx_inst = def_use_mgr->GetDef(*opnd); if (idx_inst->opcode() != spv::Op::OpConstant) return false; // If current type is struct, look for location decoration on member and // reset offset if found. auto index = idx_inst->GetSingleWordInOperand(0); if (curr_type_inst->opcode() == spv::Op::OpTypeStruct) { uint32_t loc = 0; bool no_mem_loc = deco_mgr->WhileEachDecoration( curr_type_id, uint32_t(spv::Decoration::Location), [&loc, index, no_loc](const Instruction& deco) { assert(deco.opcode() == spv::Op::OpMemberDecorate && "unexpected decoration"); if (deco.GetSingleWordInOperand(kOpDecorateMemberMemberInIdx) == index) { loc = deco.GetSingleWordInOperand(kOpDecorateMemberLocationInIdx); *no_loc = false; return false; } return true; }); if (!no_mem_loc) { *offset = loc; curr_type_id = curr_type_inst->GetSingleWordInOperand(index); ocnt++; return true; } } // Update offset and current type based on constant index. *offset += GetLocOffset(index, curr_type_id); curr_type_id = GetComponentType(index, curr_type_id); } ocnt++; return true; }); return curr_type_id; } void LivenessManager::MarkRefLive(const Instruction* ref, Instruction* var) { analysis::TypeManager* type_mgr = context()->get_type_mgr(); analysis::DecorationManager* deco_mgr = context()->get_decoration_mgr(); // Find variable location if present. uint32_t loc = 0; auto var_id = var->result_id(); bool no_loc = deco_mgr->WhileEachDecoration( var_id, uint32_t(spv::Decoration::Location), [&loc](const Instruction& deco) { assert(deco.opcode() == spv::Op::OpDecorate && "unexpected decoration"); loc = deco.GetSingleWordInOperand(kDecorationLocationInIdx); return false; }); // Find patch decoration if present bool is_patch = !deco_mgr->WhileEachDecoration( var_id, uint32_t(spv::Decoration::Patch), [](const Instruction& deco) { if (deco.opcode() != spv::Op::OpDecorate) assert(false && "unexpected decoration"); return false; }); // If use is a load, mark all locations of var auto ptr_type = type_mgr->GetType(var->type_id())->AsPointer(); assert(ptr_type && "unexpected var type"); auto var_type = ptr_type->pointee_type(); if (ref->opcode() == spv::Op::OpLoad) { assert(!no_loc && "missing input variable location"); MarkLocsLive(loc, GetLocSize(var_type)); return; } // Mark just those locations indicated by access chain assert((ref->opcode() == spv::Op::OpAccessChain || ref->opcode() == spv::Op::OpInBoundsAccessChain) && "unexpected use of input variable"); // Traverse access chain, compute location offset and type of reference // through constant indices and mark those locs live. Assert if no location // found. uint32_t offset = loc; Instruction* ptr_type_inst = context()->get_def_use_mgr()->GetDef(var->type_id()); assert(ptr_type && "unexpected var type"); const uint32_t kPointerTypePointeeIdx = 1; uint32_t var_type_id = ptr_type_inst->GetSingleWordInOperand(kPointerTypePointeeIdx); uint32_t curr_type_id = AnalyzeAccessChainLoc(ref, var_type_id, &offset, &no_loc, is_patch); auto curr_type = type_mgr->GetType(curr_type_id); assert(!no_loc && "missing input variable location"); MarkLocsLive(offset, GetLocSize(curr_type)); } void LivenessManager::ComputeLiveness() { InitializeAnalysis(); analysis::DefUseManager* def_use_mgr = context()->get_def_use_mgr(); // Process all input variables for (auto& var : context()->types_values()) { if (var.opcode() != spv::Op::OpVariable) { continue; } Instruction* var_type_inst = def_use_mgr->GetDef(var.type_id()); assert(var_type_inst->opcode() == spv::Op::OpTypePointer && "Expected a pointer type"); const uint32_t kPointerTypeStorageClassInIdx = 0; spv::StorageClass sc = static_cast( var_type_inst->GetSingleWordInOperand(kPointerTypeStorageClassInIdx)); if (sc != spv::StorageClass::Input) { continue; } // If var is builtin, mark live if analyzed and continue to next variable auto var_id = var.result_id(); if (AnalyzeBuiltIn(var_id)) continue; // If interface block with builtin members, mark live if analyzed and // continue to next variable. Input interface blocks will only appear // in tesc, tese and geom shaders. Will need to strip off one level of // arrayness to get to block type. const uint32_t kPointerTypePointeeTypeInIdx = 1; uint32_t pte_type_id = var_type_inst->GetSingleWordInOperand(kPointerTypePointeeTypeInIdx); Instruction* pte_type_inst = def_use_mgr->GetDef(pte_type_id); if (pte_type_inst->opcode() == spv::Op::OpTypeArray) { uint32_t array_elt_type_id = pte_type_inst->GetSingleWordInOperand(0); Instruction* arr_elt_type = def_use_mgr->GetDef(array_elt_type_id); if (arr_elt_type->opcode() == spv::Op::OpTypeStruct) { if (AnalyzeBuiltIn(array_elt_type_id)) continue; } } // Mark all used locations of var live def_use_mgr->ForEachUser(var_id, [this, &var](Instruction* user) { auto op = user->opcode(); if (op == spv::Op::OpEntryPoint || op == spv::Op::OpName || op == spv::Op::OpDecorate || user->IsNonSemanticInstruction()) { return; } MarkRefLive(user, &var); }); } } void LivenessManager::GetLiveness(std::unordered_set* live_locs, std::unordered_set* live_builtins) { if (!computed_) { ComputeLiveness(); computed_ = true; } *live_locs = live_locs_; *live_builtins = live_builtins_; } } // namespace analysis } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/liveness.h000066400000000000000000000061331475742701700226370ustar00rootroot00000000000000// Copyright (c) 2022 The Khronos Group Inc. // Copyright (c) 2022 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_LIVENESS_H_ #define SOURCE_OPT_LIVENESS_H_ #include #include namespace spvtools { namespace opt { class IRContext; class Instruction; namespace analysis { class Type; // This class represents the liveness of the input variables of a module class LivenessManager { public: LivenessManager(IRContext* ctx); // Copy liveness info into |live_locs| and |builtin_locs|. void GetLiveness(std::unordered_set* live_locs, std::unordered_set* live_builtins); // Return true if builtin |bi| is being analyzed. bool IsAnalyzedBuiltin(uint32_t bi); // Return the result type of |ac| when applied to |cur_type_id|. Set // |no_loc| to true if no loc found. Set |is_patch| indicates if the variable // is a patch variable. Set |input| if the variable is an input variable. // Otherwise it is assumed that the variable is an output variable. uint32_t AnalyzeAccessChainLoc(const Instruction* ac, uint32_t curr_type_id, uint32_t* offset, bool* no_loc, bool is_patch, bool input = true); // Return size of |type_id| in units of locations uint32_t GetLocSize(const analysis::Type* type) const; private: IRContext* context() const { return ctx_; } // Initialize analysis void InitializeAnalysis(); // Analyze |id| for builtin var and struct members. Return true if builtins // found. bool AnalyzeBuiltIn(uint32_t id); // Mark all live locations resulting from |user| of |var| at |loc|. void MarkRefLive(const Instruction* user, Instruction* var); // Mark |count| locations starting at location |start|. void MarkLocsLive(uint32_t start, uint32_t count); // Return type of the member |index| in the aggregate type |agg_type_id|. uint32_t GetComponentType(uint32_t index, uint32_t agg_type_id) const; // Return offset of member |index| in the aggregate type |agg_type_id| in // units of input locations. uint32_t GetLocOffset(uint32_t index, uint32_t agg_type_id) const; // Populate live_locs_ and live_builtins_ void ComputeLiveness(); // IR context that owns this liveness manager. IRContext* ctx_; // True if live_locs_ and live_builtins_ are computed bool computed_; // Live locations std::unordered_set live_locs_; // Live builtins std::unordered_set live_builtins_; }; } // namespace analysis } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_LIVENESS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/local_access_chain_convert_pass.cpp000066400000000000000000000444761475742701700277210ustar00rootroot00000000000000// Copyright (c) 2017 The Khronos Group Inc. // Copyright (c) 2017 Valve Corporation // Copyright (c) 2017 LunarG Inc. // Modifications Copyright (C) 2024 Advanced Micro Devices, Inc. All rights // reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/local_access_chain_convert_pass.h" #include "ir_context.h" #include "iterator.h" #include "source/util/string_utils.h" namespace spvtools { namespace opt { namespace { constexpr uint32_t kStoreValIdInIdx = 1; constexpr uint32_t kAccessChainPtrIdInIdx = 0; } // namespace void LocalAccessChainConvertPass::BuildAndAppendInst( spv::Op opcode, uint32_t typeId, uint32_t resultId, const std::vector& in_opnds, std::vector>* newInsts) { std::unique_ptr newInst( new Instruction(context(), opcode, typeId, resultId, in_opnds)); get_def_use_mgr()->AnalyzeInstDefUse(&*newInst); newInsts->emplace_back(std::move(newInst)); } uint32_t LocalAccessChainConvertPass::BuildAndAppendVarLoad( const Instruction* ptrInst, uint32_t* varId, uint32_t* varPteTypeId, std::vector>* newInsts) { const uint32_t ldResultId = TakeNextId(); if (ldResultId == 0) { return 0; } *varId = ptrInst->GetSingleWordInOperand(kAccessChainPtrIdInIdx); const Instruction* varInst = get_def_use_mgr()->GetDef(*varId); assert(varInst->opcode() == spv::Op::OpVariable); *varPteTypeId = GetPointeeTypeId(varInst); BuildAndAppendInst(spv::Op::OpLoad, *varPteTypeId, ldResultId, {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {*varId}}}, newInsts); return ldResultId; } void LocalAccessChainConvertPass::AppendConstantOperands( const Instruction* ptrInst, std::vector* in_opnds) { uint32_t iidIdx = 0; ptrInst->ForEachInId([&iidIdx, &in_opnds, this](const uint32_t* iid) { if (iidIdx > 0) { const Instruction* cInst = get_def_use_mgr()->GetDef(*iid); const auto* constant_value = context()->get_constant_mgr()->GetConstantFromInst(cInst); assert(constant_value != nullptr && "Expecting the index to be a constant."); // We take the sign extended value because OpAccessChain interprets the // index as signed. int64_t long_value = constant_value->GetSignExtendedValue(); assert(long_value <= UINT32_MAX && long_value >= 0 && "The index value is too large for a composite insert or extract " "instruction."); uint32_t val = static_cast(long_value); in_opnds->push_back( {spv_operand_type_t::SPV_OPERAND_TYPE_LITERAL_INTEGER, {val}}); } ++iidIdx; }); } bool LocalAccessChainConvertPass::ReplaceAccessChainLoad( const Instruction* address_inst, Instruction* original_load) { // Build and append load of variable in ptrInst if (address_inst->NumInOperands() == 1) { // An access chain with no indices is essentially a copy. All that is // needed is to propagate the address. context()->ReplaceAllUsesWith( address_inst->result_id(), address_inst->GetSingleWordInOperand(kAccessChainPtrIdInIdx)); return true; } std::vector> new_inst; uint32_t varId; uint32_t varPteTypeId; const uint32_t ldResultId = BuildAndAppendVarLoad(address_inst, &varId, &varPteTypeId, &new_inst); if (ldResultId == 0) { return false; } new_inst[0]->UpdateDebugInfoFrom(original_load); context()->get_decoration_mgr()->CloneDecorations( original_load->result_id(), ldResultId, {spv::Decoration::RelaxedPrecision}); original_load->InsertBefore(std::move(new_inst)); context()->get_debug_info_mgr()->AnalyzeDebugInst( original_load->PreviousNode()); // Rewrite |original_load| into an extract. Instruction::OperandList new_operands; // copy the result id and the type id to the new operand list. new_operands.emplace_back(original_load->GetOperand(0)); new_operands.emplace_back(original_load->GetOperand(1)); new_operands.emplace_back( Operand({spv_operand_type_t::SPV_OPERAND_TYPE_ID, {ldResultId}})); AppendConstantOperands(address_inst, &new_operands); original_load->SetOpcode(spv::Op::OpCompositeExtract); original_load->ReplaceOperands(new_operands); context()->UpdateDefUse(original_load); return true; } bool LocalAccessChainConvertPass::GenAccessChainStoreReplacement( const Instruction* ptrInst, uint32_t valId, std::vector>* newInsts) { if (ptrInst->NumInOperands() == 1) { // An access chain with no indices is essentially a copy. However, we still // have to create a new store because the old ones will be deleted. BuildAndAppendInst( spv::Op::OpStore, 0, 0, {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {ptrInst->GetSingleWordInOperand(kAccessChainPtrIdInIdx)}}, {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {valId}}}, newInsts); return true; } // Build and append load of variable in ptrInst uint32_t varId; uint32_t varPteTypeId; const uint32_t ldResultId = BuildAndAppendVarLoad(ptrInst, &varId, &varPteTypeId, newInsts); if (ldResultId == 0) { return false; } context()->get_decoration_mgr()->CloneDecorations( varId, ldResultId, {spv::Decoration::RelaxedPrecision}); // Build and append Insert const uint32_t insResultId = TakeNextId(); if (insResultId == 0) { return false; } std::vector ins_in_opnds = { {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {valId}}, {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {ldResultId}}}; AppendConstantOperands(ptrInst, &ins_in_opnds); BuildAndAppendInst(spv::Op::OpCompositeInsert, varPteTypeId, insResultId, ins_in_opnds, newInsts); context()->get_decoration_mgr()->CloneDecorations( varId, insResultId, {spv::Decoration::RelaxedPrecision}); // Build and append Store BuildAndAppendInst(spv::Op::OpStore, 0, 0, {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {varId}}, {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {insResultId}}}, newInsts); return true; } bool LocalAccessChainConvertPass::Is32BitConstantIndexAccessChain( const Instruction* acp) const { uint32_t inIdx = 0; return acp->WhileEachInId([&inIdx, this](const uint32_t* tid) { if (inIdx > 0) { Instruction* opInst = get_def_use_mgr()->GetDef(*tid); if (opInst->opcode() != spv::Op::OpConstant) return false; const auto* index = context()->get_constant_mgr()->GetConstantFromInst(opInst); int64_t index_value = index->GetSignExtendedValue(); if (index_value > UINT32_MAX) return false; if (index_value < 0) return false; } ++inIdx; return true; }); } bool LocalAccessChainConvertPass::HasOnlySupportedRefs(uint32_t ptrId) { if (supported_ref_ptrs_.find(ptrId) != supported_ref_ptrs_.end()) return true; if (get_def_use_mgr()->WhileEachUser(ptrId, [this](Instruction* user) { if (user->GetCommonDebugOpcode() == CommonDebugInfoDebugValue || user->GetCommonDebugOpcode() == CommonDebugInfoDebugDeclare) { return true; } spv::Op op = user->opcode(); if (IsNonPtrAccessChain(op) || op == spv::Op::OpCopyObject) { if (!HasOnlySupportedRefs(user->result_id())) { return false; } } else if (op != spv::Op::OpStore && op != spv::Op::OpLoad && op != spv::Op::OpName && !IsNonTypeDecorate(op)) { return false; } return true; })) { supported_ref_ptrs_.insert(ptrId); return true; } return false; } void LocalAccessChainConvertPass::FindTargetVars(Function* func) { for (auto bi = func->begin(); bi != func->end(); ++bi) { for (auto ii = bi->begin(); ii != bi->end(); ++ii) { switch (ii->opcode()) { case spv::Op::OpStore: case spv::Op::OpLoad: { uint32_t varId; Instruction* ptrInst = GetPtr(&*ii, &varId); if (!IsTargetVar(varId)) break; const spv::Op op = ptrInst->opcode(); // Rule out variables with non-supported refs eg function calls if (!HasOnlySupportedRefs(varId)) { seen_non_target_vars_.insert(varId); seen_target_vars_.erase(varId); break; } // Rule out variables with nested access chains // TODO(): Convert nested access chains bool is_non_ptr_access_chain = IsNonPtrAccessChain(op); if (is_non_ptr_access_chain && ptrInst->GetSingleWordInOperand( kAccessChainPtrIdInIdx) != varId) { seen_non_target_vars_.insert(varId); seen_target_vars_.erase(varId); break; } // Rule out variables accessed with non-constant indices if (!Is32BitConstantIndexAccessChain(ptrInst)) { seen_non_target_vars_.insert(varId); seen_target_vars_.erase(varId); break; } if (is_non_ptr_access_chain && AnyIndexIsOutOfBounds(ptrInst)) { seen_non_target_vars_.insert(varId); seen_target_vars_.erase(varId); break; } } break; default: break; } } } } Pass::Status LocalAccessChainConvertPass::ConvertLocalAccessChains( Function* func) { FindTargetVars(func); // Replace access chains of all targeted variables with equivalent // extract and insert sequences bool modified = false; for (auto bi = func->begin(); bi != func->end(); ++bi) { std::vector dead_instructions; for (auto ii = bi->begin(); ii != bi->end(); ++ii) { switch (ii->opcode()) { case spv::Op::OpLoad: { uint32_t varId; Instruction* ptrInst = GetPtr(&*ii, &varId); if (!IsNonPtrAccessChain(ptrInst->opcode())) break; if (!IsTargetVar(varId)) break; if (!ReplaceAccessChainLoad(ptrInst, &*ii)) { return Status::Failure; } modified = true; } break; case spv::Op::OpStore: { uint32_t varId; Instruction* store = &*ii; Instruction* ptrInst = GetPtr(store, &varId); if (!IsNonPtrAccessChain(ptrInst->opcode())) break; if (!IsTargetVar(varId)) break; std::vector> newInsts; uint32_t valId = store->GetSingleWordInOperand(kStoreValIdInIdx); if (!GenAccessChainStoreReplacement(ptrInst, valId, &newInsts)) { return Status::Failure; } size_t num_of_instructions_to_skip = newInsts.size() - 1; dead_instructions.push_back(store); ++ii; ii = ii.InsertBefore(std::move(newInsts)); for (size_t i = 0; i < num_of_instructions_to_skip; ++i) { ii->UpdateDebugInfoFrom(store); context()->get_debug_info_mgr()->AnalyzeDebugInst(&*ii); ++ii; } ii->UpdateDebugInfoFrom(store); context()->get_debug_info_mgr()->AnalyzeDebugInst(&*ii); modified = true; } break; default: break; } } while (!dead_instructions.empty()) { Instruction* inst = dead_instructions.back(); dead_instructions.pop_back(); DCEInst(inst, [&dead_instructions](Instruction* other_inst) { auto i = std::find(dead_instructions.begin(), dead_instructions.end(), other_inst); if (i != dead_instructions.end()) { dead_instructions.erase(i); } }); } } return (modified ? Status::SuccessWithChange : Status::SuccessWithoutChange); } void LocalAccessChainConvertPass::Initialize() { // Initialize Target Variable Caches seen_target_vars_.clear(); seen_non_target_vars_.clear(); // Initialize collections supported_ref_ptrs_.clear(); // Initialize extension allowlist InitExtensions(); } bool LocalAccessChainConvertPass::AllExtensionsSupported() const { // This capability can now exist without the extension, so we have to check // for the capability. This pass is only looking at function scope symbols, // so we do not care if there are variable pointers on storage buffers. if (context()->get_feature_mgr()->HasCapability( spv::Capability::VariablePointers)) return false; // If any extension not in allowlist, return false for (auto& ei : get_module()->extensions()) { const std::string extName = ei.GetInOperand(0).AsString(); if (extensions_allowlist_.find(extName) == extensions_allowlist_.end()) return false; } // only allow NonSemantic.Shader.DebugInfo.100, we cannot safely optimise // around unknown extended // instruction sets even if they are non-semantic for (auto& inst : context()->module()->ext_inst_imports()) { assert(inst.opcode() == spv::Op::OpExtInstImport && "Expecting an import of an extension's instruction set."); const std::string extension_name = inst.GetInOperand(0).AsString(); if (spvtools::utils::starts_with(extension_name, "NonSemantic.") && extension_name != "NonSemantic.Shader.DebugInfo.100") { return false; } } return true; } Pass::Status LocalAccessChainConvertPass::ProcessImpl() { // Do not process if module contains OpGroupDecorate. Additional // support required in KillNamesAndDecorates(). // TODO(greg-lunarg): Add support for OpGroupDecorate for (auto& ai : get_module()->annotations()) if (ai.opcode() == spv::Op::OpGroupDecorate) return Status::SuccessWithoutChange; // Do not process if any disallowed extensions are enabled if (!AllExtensionsSupported()) return Status::SuccessWithoutChange; // Process all functions in the module. Status status = Status::SuccessWithoutChange; for (Function& func : *get_module()) { status = CombineStatus(status, ConvertLocalAccessChains(&func)); if (status == Status::Failure) { break; } } return status; } LocalAccessChainConvertPass::LocalAccessChainConvertPass() {} Pass::Status LocalAccessChainConvertPass::Process() { Initialize(); return ProcessImpl(); } void LocalAccessChainConvertPass::InitExtensions() { extensions_allowlist_.clear(); extensions_allowlist_.insert( {"SPV_AMD_shader_explicit_vertex_parameter", "SPV_AMD_shader_trinary_minmax", "SPV_AMD_gcn_shader", "SPV_KHR_shader_ballot", "SPV_AMD_shader_ballot", "SPV_AMD_gpu_shader_half_float", "SPV_KHR_shader_draw_parameters", "SPV_KHR_subgroup_vote", "SPV_KHR_8bit_storage", "SPV_KHR_16bit_storage", "SPV_KHR_device_group", "SPV_KHR_multiview", "SPV_NVX_multiview_per_view_attributes", "SPV_NV_viewport_array2", "SPV_NV_stereo_view_rendering", "SPV_NV_sample_mask_override_coverage", "SPV_NV_geometry_shader_passthrough", "SPV_AMD_texture_gather_bias_lod", "SPV_KHR_storage_buffer_storage_class", // SPV_KHR_variable_pointers // Currently do not support extended pointer expressions "SPV_AMD_gpu_shader_int16", "SPV_KHR_post_depth_coverage", "SPV_KHR_shader_atomic_counter_ops", "SPV_EXT_shader_stencil_export", "SPV_EXT_shader_viewport_index_layer", "SPV_AMD_shader_image_load_store_lod", "SPV_AMD_shader_fragment_mask", "SPV_EXT_fragment_fully_covered", "SPV_AMD_gpu_shader_half_float_fetch", "SPV_GOOGLE_decorate_string", "SPV_GOOGLE_hlsl_functionality1", "SPV_GOOGLE_user_type", "SPV_NV_shader_subgroup_partitioned", "SPV_EXT_demote_to_helper_invocation", "SPV_EXT_descriptor_indexing", "SPV_NV_fragment_shader_barycentric", "SPV_NV_compute_shader_derivatives", "SPV_NV_shader_image_footprint", "SPV_NV_shading_rate", "SPV_NV_mesh_shader", "SPV_EXT_mesh_shader", "SPV_NV_ray_tracing", "SPV_KHR_ray_tracing", "SPV_KHR_ray_query", "SPV_EXT_fragment_invocation_density", "SPV_KHR_terminate_invocation", "SPV_KHR_subgroup_uniform_control_flow", "SPV_KHR_integer_dot_product", "SPV_EXT_shader_image_int64", "SPV_KHR_non_semantic_info", "SPV_KHR_uniform_group_instructions", "SPV_KHR_fragment_shader_barycentric", "SPV_KHR_vulkan_memory_model", "SPV_NV_bindless_texture", "SPV_EXT_shader_atomic_float_add", "SPV_EXT_fragment_shader_interlock", "SPV_KHR_compute_shader_derivatives", "SPV_NV_cooperative_matrix", "SPV_KHR_cooperative_matrix", "SPV_KHR_ray_tracing_position_fetch", "SPV_AMDX_shader_enqueue", "SPV_KHR_fragment_shading_rate"}); } bool LocalAccessChainConvertPass::AnyIndexIsOutOfBounds( const Instruction* access_chain_inst) { assert(IsNonPtrAccessChain(access_chain_inst->opcode())); analysis::TypeManager* type_mgr = context()->get_type_mgr(); analysis::ConstantManager* const_mgr = context()->get_constant_mgr(); auto constants = const_mgr->GetOperandConstants(access_chain_inst); uint32_t base_pointer_id = access_chain_inst->GetSingleWordInOperand(0); Instruction* base_pointer = get_def_use_mgr()->GetDef(base_pointer_id); const analysis::Pointer* base_pointer_type = type_mgr->GetType(base_pointer->type_id())->AsPointer(); assert(base_pointer_type != nullptr && "The base of the access chain is not a pointer."); const analysis::Type* current_type = base_pointer_type->pointee_type(); for (uint32_t i = 1; i < access_chain_inst->NumInOperands(); ++i) { if (IsIndexOutOfBounds(constants[i], current_type)) { return true; } uint32_t index = (constants[i] ? static_cast(constants[i]->GetZeroExtendedValue()) : 0); current_type = type_mgr->GetMemberType(current_type, {index}); } return false; } bool LocalAccessChainConvertPass::IsIndexOutOfBounds( const analysis::Constant* index, const analysis::Type* type) const { if (index == nullptr) { return false; } return index->GetZeroExtendedValue() >= type->NumberOfComponents(); } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/local_access_chain_convert_pass.h000066400000000000000000000133561475742701700273570ustar00rootroot00000000000000// Copyright (c) 2017 The Khronos Group Inc. // Copyright (c) 2017 Valve Corporation // Copyright (c) 2017 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_LOCAL_ACCESS_CHAIN_CONVERT_PASS_H_ #define SOURCE_OPT_LOCAL_ACCESS_CHAIN_CONVERT_PASS_H_ #include #include #include #include #include #include #include #include #include #include "source/opt/basic_block.h" #include "source/opt/def_use_manager.h" #include "source/opt/mem_pass.h" #include "source/opt/module.h" namespace spvtools { namespace opt { // See optimizer.hpp for documentation. class LocalAccessChainConvertPass : public MemPass { public: LocalAccessChainConvertPass(); const char* name() const override { return "convert-local-access-chains"; } Status Process() override; IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisDefUse | IRContext::kAnalysisConstants | IRContext::kAnalysisTypes; } using ProcessFunction = std::function; private: // Return true if all refs through |ptrId| are only loads or stores and // cache ptrId in supported_ref_ptrs_. TODO(dnovillo): This function is // replicated in other passes and it's slightly different in every pass. Is it // possible to make one common implementation? bool HasOnlySupportedRefs(uint32_t ptrId); // Search |func| and cache function scope variables of target type that are // not accessed with non-constant-index access chains. Also cache non-target // variables. void FindTargetVars(Function* func); // Build instruction from |opcode|, |typeId|, |resultId|, and |in_opnds|. // Append to |newInsts|. void BuildAndAppendInst(spv::Op opcode, uint32_t typeId, uint32_t resultId, const std::vector& in_opnds, std::vector>* newInsts); // Build load of variable in |ptrInst| and append to |newInsts|. // Return var in |varId| and its pointee type in |varPteTypeId|. uint32_t BuildAndAppendVarLoad( const Instruction* ptrInst, uint32_t* varId, uint32_t* varPteTypeId, std::vector>* newInsts); // Append literal integer operands to |in_opnds| corresponding to constant // integer operands from access chain |ptrInst|. Assumes all indices in // access chains are OpConstant. void AppendConstantOperands(const Instruction* ptrInst, std::vector* in_opnds); // Create a load/insert/store equivalent to a store of // |valId| through (constant index) access chain |ptrInst|. // Append to |newInsts|. Returns true if successful. bool GenAccessChainStoreReplacement( const Instruction* ptrInst, uint32_t valId, std::vector>* newInsts); // For the (constant index) access chain |address_inst|, create an // equivalent load and extract that replaces |original_load|. The result id // of the extract will be the same as the original result id of // |original_load|. Returns true if successful. bool ReplaceAccessChainLoad(const Instruction* address_inst, Instruction* original_load); // Return true if all indices of the access chain |acp| are OpConstant // integers whose signed values can be represented as unsigned 32-bit values. bool Is32BitConstantIndexAccessChain(const Instruction* acp) const; // Identify all function scope variables of target type which are // accessed only with loads, stores and access chains with constant // indices. Convert all loads and stores of such variables into equivalent // loads, stores, extracts and inserts. This unifies access to these // variables to a single mode and simplifies analysis and optimization. // See IsTargetType() for targeted types. // // Nested access chains and pointer access chains are not currently // converted. // // Returns a status to indicate success or failure, and change or no change. Status ConvertLocalAccessChains(Function* func); // Returns true one of the indexes in the |access_chain_inst| is definitly out // of bounds. If the size of the type or the value of the index is unknown, // then it will be considered in-bounds. bool AnyIndexIsOutOfBounds(const Instruction* access_chain_inst); // Returns true if getting element |index| from |type| would be out-of-bounds. // If |index| is nullptr or the size of the type are unknown, then it will be // considered in-bounds. bool IsIndexOutOfBounds(const analysis::Constant* index, const analysis::Type* type) const; // Initialize extensions allowlist void InitExtensions(); // Return true if all extensions in this module are allowed by this pass. bool AllExtensionsSupported() const; void Initialize(); Pass::Status ProcessImpl(); // Variables with only supported references, ie. loads and stores using // variable directly or through non-ptr access chains. std::unordered_set supported_ref_ptrs_; // Extensions supported by this pass. std::unordered_set extensions_allowlist_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_LOCAL_ACCESS_CHAIN_CONVERT_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/local_redundancy_elimination.cpp000066400000000000000000000041411475742701700272350ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/local_redundancy_elimination.h" #include "source/opt/value_number_table.h" namespace spvtools { namespace opt { Pass::Status LocalRedundancyEliminationPass::Process() { bool modified = false; ValueNumberTable vnTable(context()); for (auto& func : *get_module()) { for (auto& bb : func) { // Keeps track of all ids that contain a given value number. We keep // track of multiple values because they could have the same value, but // different decorations. std::map value_to_ids; if (EliminateRedundanciesInBB(&bb, vnTable, &value_to_ids)) modified = true; } } return (modified ? Status::SuccessWithChange : Status::SuccessWithoutChange); } bool LocalRedundancyEliminationPass::EliminateRedundanciesInBB( BasicBlock* block, const ValueNumberTable& vnTable, std::map* value_to_ids) { bool modified = false; auto func = [this, &vnTable, &modified, value_to_ids](Instruction* inst) { if (inst->result_id() == 0) { return; } uint32_t value = vnTable.GetValueNumber(inst); if (value == 0) { return; } auto candidate = value_to_ids->insert({value, inst->result_id()}); if (!candidate.second) { context()->KillNamesAndDecorates(inst); context()->ReplaceAllUsesWith(inst->result_id(), candidate.first->second); context()->KillInst(inst); modified = true; } }; block->ForEachInst(func); return modified; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/local_redundancy_elimination.h000066400000000000000000000052071475742701700267060ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_LOCAL_REDUNDANCY_ELIMINATION_H_ #define SOURCE_OPT_LOCAL_REDUNDANCY_ELIMINATION_H_ #include #include "source/opt/ir_context.h" #include "source/opt/pass.h" #include "source/opt/value_number_table.h" namespace spvtools { namespace opt { // This pass implements local redundancy elimination. Its goal is to reduce the // number of times the same value is computed. It works on each basic block // independently, ie local. For each instruction in a basic block, it gets the // value number for the result id, |id|, of the instruction. If that value // number has already been computed in the basic block, it tries to replace the // uses of |id| by the id that already contains the same value. Then the // current instruction is deleted. class LocalRedundancyEliminationPass : public Pass { public: const char* name() const override { return "local-redundancy-elimination"; } Status Process() override; IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisDecorations | IRContext::kAnalysisCombinators | IRContext::kAnalysisCFG | IRContext::kAnalysisDominatorAnalysis | IRContext::kAnalysisNameMap | IRContext::kAnalysisConstants | IRContext::kAnalysisTypes; } protected: // Deletes instructions in |block| whose value is in |value_to_ids| or is // computed earlier in |block|. // // |vnTable| must have computed a value number for every result id defined // in |bb|. // // |value_to_ids| is a map from value number to ids. If {vn, id} is in // |value_to_ids| then vn is the value number of id, and the definition of id // dominates |bb|. // // Returns true if the module is changed. bool EliminateRedundanciesInBB(BasicBlock* block, const ValueNumberTable& vnTable, std::map* value_to_ids); }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_LOCAL_REDUNDANCY_ELIMINATION_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/local_single_block_elim_pass.cpp000066400000000000000000000312171475742701700272040ustar00rootroot00000000000000// Copyright (c) 2017 The Khronos Group Inc. // Copyright (c) 2017 Valve Corporation // Copyright (c) 2017 LunarG Inc. // Modifications Copyright (C) 2024 Advanced Micro Devices, Inc. All rights // reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/local_single_block_elim_pass.h" #include #include "source/util/string_utils.h" namespace spvtools { namespace opt { namespace { constexpr uint32_t kStoreValIdInIdx = 1; } // namespace bool LocalSingleBlockLoadStoreElimPass::HasOnlySupportedRefs(uint32_t ptrId) { if (supported_ref_ptrs_.find(ptrId) != supported_ref_ptrs_.end()) return true; if (get_def_use_mgr()->WhileEachUser(ptrId, [this](Instruction* user) { auto dbg_op = user->GetCommonDebugOpcode(); if (dbg_op == CommonDebugInfoDebugDeclare || dbg_op == CommonDebugInfoDebugValue) { return true; } spv::Op op = user->opcode(); if (IsNonPtrAccessChain(op) || op == spv::Op::OpCopyObject) { if (!HasOnlySupportedRefs(user->result_id())) { return false; } } else if (op != spv::Op::OpStore && op != spv::Op::OpLoad && op != spv::Op::OpName && !IsNonTypeDecorate(op)) { return false; } return true; })) { supported_ref_ptrs_.insert(ptrId); return true; } return false; } bool LocalSingleBlockLoadStoreElimPass::LocalSingleBlockLoadStoreElim( Function* func) { // Perform local store/load, load/load and store/store elimination // on each block bool modified = false; std::vector instructions_to_kill; std::unordered_set instructions_to_save; for (auto bi = func->begin(); bi != func->end(); ++bi) { var2store_.clear(); var2load_.clear(); auto next = bi->begin(); for (auto ii = next; ii != bi->end(); ii = next) { ++next; switch (ii->opcode()) { case spv::Op::OpStore: { // Verify store variable is target type uint32_t varId; Instruction* ptrInst = GetPtr(&*ii, &varId); if (!IsTargetVar(varId)) continue; if (!HasOnlySupportedRefs(varId)) continue; // If a store to the whole variable, remember it for succeeding // loads and stores. Otherwise forget any previous store to that // variable. if (ptrInst->opcode() == spv::Op::OpVariable) { // If a previous store to same variable, mark the store // for deletion if not still used. Don't delete store // if debugging; let ssa-rewrite and DCE handle it auto prev_store = var2store_.find(varId); if (prev_store != var2store_.end() && instructions_to_save.count(prev_store->second) == 0 && !context()->get_debug_info_mgr()->IsVariableDebugDeclared( varId)) { instructions_to_kill.push_back(prev_store->second); modified = true; } bool kill_store = false; auto li = var2load_.find(varId); if (li != var2load_.end()) { if (ii->GetSingleWordInOperand(kStoreValIdInIdx) == li->second->result_id()) { // We are storing the same value that already exists in the // memory location. The store does nothing. kill_store = true; } } if (!kill_store) { var2store_[varId] = &*ii; var2load_.erase(varId); } else { instructions_to_kill.push_back(&*ii); modified = true; } } else { assert(IsNonPtrAccessChain(ptrInst->opcode())); var2store_.erase(varId); var2load_.erase(varId); } } break; case spv::Op::OpLoad: { // Verify store variable is target type uint32_t varId; Instruction* ptrInst = GetPtr(&*ii, &varId); if (!IsTargetVar(varId)) continue; if (!HasOnlySupportedRefs(varId)) continue; uint32_t replId = 0; if (ptrInst->opcode() == spv::Op::OpVariable) { // If a load from a variable, look for a previous store or // load from that variable and use its value. auto si = var2store_.find(varId); if (si != var2store_.end()) { replId = si->second->GetSingleWordInOperand(kStoreValIdInIdx); } else { auto li = var2load_.find(varId); if (li != var2load_.end()) { replId = li->second->result_id(); } } } else { // If a partial load of a previously seen store, remember // not to delete the store. auto si = var2store_.find(varId); if (si != var2store_.end()) instructions_to_save.insert(si->second); } if (replId != 0) { // replace load's result id and delete load context()->KillNamesAndDecorates(&*ii); context()->ReplaceAllUsesWith(ii->result_id(), replId); instructions_to_kill.push_back(&*ii); modified = true; } else { if (ptrInst->opcode() == spv::Op::OpVariable) var2load_[varId] = &*ii; // register load } } break; case spv::Op::OpFunctionCall: { // Conservatively assume all locals are redefined for now. // TODO(): Handle more optimally var2store_.clear(); var2load_.clear(); } break; default: break; } } } for (Instruction* inst : instructions_to_kill) { context()->KillInst(inst); } return modified; } void LocalSingleBlockLoadStoreElimPass::Initialize() { // Initialize Target Type Caches seen_target_vars_.clear(); seen_non_target_vars_.clear(); // Clear collections supported_ref_ptrs_.clear(); // Initialize extensions allowlist InitExtensions(); } bool LocalSingleBlockLoadStoreElimPass::AllExtensionsSupported() const { // If any extension not in allowlist, return false for (auto& ei : get_module()->extensions()) { const std::string extName = ei.GetInOperand(0).AsString(); if (extensions_allowlist_.find(extName) == extensions_allowlist_.end()) return false; } // only allow NonSemantic.Shader.DebugInfo.100, we cannot safely optimise // around unknown extended // instruction sets even if they are non-semantic for (auto& inst : context()->module()->ext_inst_imports()) { assert(inst.opcode() == spv::Op::OpExtInstImport && "Expecting an import of an extension's instruction set."); const std::string extension_name = inst.GetInOperand(0).AsString(); if (spvtools::utils::starts_with(extension_name, "NonSemantic.") && extension_name != "NonSemantic.Shader.DebugInfo.100") { return false; } } return true; } Pass::Status LocalSingleBlockLoadStoreElimPass::ProcessImpl() { // Assumes relaxed logical addressing only (see instruction.h). if (context()->get_feature_mgr()->HasCapability(spv::Capability::Addresses)) return Status::SuccessWithoutChange; // Do not process if module contains OpGroupDecorate. Additional // support required in KillNamesAndDecorates(). // TODO(greg-lunarg): Add support for OpGroupDecorate for (auto& ai : get_module()->annotations()) if (ai.opcode() == spv::Op::OpGroupDecorate) return Status::SuccessWithoutChange; // If any extensions in the module are not explicitly supported, // return unmodified. if (!AllExtensionsSupported()) return Status::SuccessWithoutChange; // Process all entry point functions ProcessFunction pfn = [this](Function* fp) { return LocalSingleBlockLoadStoreElim(fp); }; bool modified = context()->ProcessReachableCallTree(pfn); return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } LocalSingleBlockLoadStoreElimPass::LocalSingleBlockLoadStoreElimPass() = default; Pass::Status LocalSingleBlockLoadStoreElimPass::Process() { Initialize(); return ProcessImpl(); } void LocalSingleBlockLoadStoreElimPass::InitExtensions() { extensions_allowlist_.clear(); extensions_allowlist_.insert({"SPV_AMD_shader_explicit_vertex_parameter", "SPV_AMD_shader_trinary_minmax", "SPV_AMD_gcn_shader", "SPV_KHR_shader_ballot", "SPV_AMD_shader_ballot", "SPV_AMDX_shader_enqueue", "SPV_AMD_gpu_shader_half_float", "SPV_KHR_shader_draw_parameters", "SPV_KHR_subgroup_vote", "SPV_KHR_8bit_storage", "SPV_KHR_16bit_storage", "SPV_KHR_device_group", "SPV_KHR_multiview", "SPV_NVX_multiview_per_view_attributes", "SPV_NV_viewport_array2", "SPV_NV_stereo_view_rendering", "SPV_NV_sample_mask_override_coverage", "SPV_NV_geometry_shader_passthrough", "SPV_AMD_texture_gather_bias_lod", "SPV_KHR_storage_buffer_storage_class", "SPV_KHR_variable_pointers", "SPV_AMD_gpu_shader_int16", "SPV_KHR_post_depth_coverage", "SPV_KHR_shader_atomic_counter_ops", "SPV_EXT_shader_stencil_export", "SPV_EXT_shader_viewport_index_layer", "SPV_AMD_shader_image_load_store_lod", "SPV_AMD_shader_fragment_mask", "SPV_EXT_fragment_fully_covered", "SPV_AMD_gpu_shader_half_float_fetch", "SPV_GOOGLE_decorate_string", "SPV_GOOGLE_hlsl_functionality1", "SPV_GOOGLE_user_type", "SPV_NV_shader_subgroup_partitioned", "SPV_EXT_demote_to_helper_invocation", "SPV_EXT_descriptor_indexing", "SPV_NV_fragment_shader_barycentric", "SPV_NV_compute_shader_derivatives", "SPV_NV_shader_image_footprint", "SPV_NV_shading_rate", "SPV_NV_mesh_shader", "SPV_EXT_mesh_shader", "SPV_NV_ray_tracing", "SPV_KHR_ray_tracing", "SPV_KHR_ray_query", "SPV_EXT_fragment_invocation_density", "SPV_EXT_physical_storage_buffer", "SPV_KHR_physical_storage_buffer", "SPV_KHR_terminate_invocation", "SPV_KHR_subgroup_uniform_control_flow", "SPV_KHR_integer_dot_product", "SPV_EXT_shader_image_int64", "SPV_KHR_non_semantic_info", "SPV_KHR_uniform_group_instructions", "SPV_KHR_fragment_shader_barycentric", "SPV_KHR_vulkan_memory_model", "SPV_NV_bindless_texture", "SPV_EXT_shader_atomic_float_add", "SPV_EXT_fragment_shader_interlock", "SPV_KHR_compute_shader_derivatives", "SPV_NV_cooperative_matrix", "SPV_KHR_cooperative_matrix", "SPV_KHR_ray_tracing_position_fetch", "SPV_KHR_fragment_shading_rate"}); } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/local_single_block_elim_pass.h000066400000000000000000000101611475742701700266440ustar00rootroot00000000000000// Copyright (c) 2017 The Khronos Group Inc. // Copyright (c) 2017 Valve Corporation // Copyright (c) 2017 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_LOCAL_SINGLE_BLOCK_ELIM_PASS_H_ #define SOURCE_OPT_LOCAL_SINGLE_BLOCK_ELIM_PASS_H_ #include #include #include #include #include #include #include #include "source/opt/basic_block.h" #include "source/opt/def_use_manager.h" #include "source/opt/mem_pass.h" #include "source/opt/module.h" namespace spvtools { namespace opt { // See optimizer.hpp for documentation. class LocalSingleBlockLoadStoreElimPass : public MemPass { public: LocalSingleBlockLoadStoreElimPass(); const char* name() const override { return "eliminate-local-single-block"; } Status Process() override; IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisConstants | IRContext::kAnalysisTypes; } private: // Return true if all uses of |varId| are only through supported reference // operations ie. loads and store. Also cache in supported_ref_ptrs_. // TODO(dnovillo): This function is replicated in other passes and it's // slightly different in every pass. Is it possible to make one common // implementation? bool HasOnlySupportedRefs(uint32_t varId); // On all entry point functions, within each basic block, eliminate // loads and stores to function variables where possible. For // loads, if previous load or store to same variable, replace // load id with previous id and delete load. Finally, check if // remaining stores are useless, and delete store and variable // where possible. Assumes logical addressing. bool LocalSingleBlockLoadStoreElim(Function* func); // Initialize extensions allowlist void InitExtensions(); // Return true if all extensions in this module are supported by this pass. bool AllExtensionsSupported() const; void Initialize(); Pass::Status ProcessImpl(); // Map from function scope variable to a store of that variable in the // current block whose value is currently valid. This map is cleared // at the start of each block and incrementally updated as the block // is scanned. The stores are candidates for elimination. The map is // conservatively cleared when a function call is encountered. std::unordered_map var2store_; // Map from function scope variable to a load of that variable in the // current block whose value is currently valid. This map is cleared // at the start of each block and incrementally updated as the block // is scanned. The stores are candidates for elimination. The map is // conservatively cleared when a function call is encountered. std::unordered_map var2load_; // Set of variables whose most recent store in the current block cannot be // deleted, for example, if there is a load of the variable which is // dependent on the store and is not replaced and deleted by this pass, // for example, a load through an access chain. A variable is removed // from this set each time a new store of that variable is encountered. std::unordered_set pinned_vars_; // Extensions supported by this pass. std::unordered_set extensions_allowlist_; // Variables that are only referenced by supported operations for this // pass ie. loads and stores. std::unordered_set supported_ref_ptrs_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_LOCAL_SINGLE_BLOCK_ELIM_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/local_single_store_elim_pass.cpp000066400000000000000000000306641475742701700272530ustar00rootroot00000000000000// Copyright (c) 2017 The Khronos Group Inc. // Copyright (c) 2017 Valve Corporation // Copyright (c) 2017 LunarG Inc. // Modifications Copyright (C) 2024 Advanced Micro Devices, Inc. All rights // reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/local_single_store_elim_pass.h" #include "source/cfa.h" #include "source/util/string_utils.h" namespace spvtools { namespace opt { namespace { constexpr uint32_t kStoreValIdInIdx = 1; constexpr uint32_t kVariableInitIdInIdx = 1; } // namespace bool LocalSingleStoreElimPass::LocalSingleStoreElim(Function* func) { bool modified = false; // Check all function scope variables in |func|. BasicBlock* entry_block = &*func->begin(); for (Instruction& inst : *entry_block) { if (inst.opcode() != spv::Op::OpVariable) { break; } modified |= ProcessVariable(&inst); } return modified; } bool LocalSingleStoreElimPass::AllExtensionsSupported() const { // If any extension not in allowlist, return false for (auto& ei : get_module()->extensions()) { const std::string extName = ei.GetInOperand(0).AsString(); if (extensions_allowlist_.find(extName) == extensions_allowlist_.end()) return false; } // only allow NonSemantic.Shader.DebugInfo.100, we cannot safely optimise // around unknown extended // instruction sets even if they are non-semantic for (auto& inst : context()->module()->ext_inst_imports()) { assert(inst.opcode() == spv::Op::OpExtInstImport && "Expecting an import of an extension's instruction set."); const std::string extension_name = inst.GetInOperand(0).AsString(); if (spvtools::utils::starts_with(extension_name, "NonSemantic.") && extension_name != "NonSemantic.Shader.DebugInfo.100") { return false; } } return true; } Pass::Status LocalSingleStoreElimPass::ProcessImpl() { // Assumes relaxed logical addressing only (see instruction.h) if (context()->get_feature_mgr()->HasCapability(spv::Capability::Addresses)) return Status::SuccessWithoutChange; // Do not process if any disallowed extensions are enabled if (!AllExtensionsSupported()) return Status::SuccessWithoutChange; // Process all entry point functions ProcessFunction pfn = [this](Function* fp) { return LocalSingleStoreElim(fp); }; bool modified = context()->ProcessReachableCallTree(pfn); return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } LocalSingleStoreElimPass::LocalSingleStoreElimPass() = default; Pass::Status LocalSingleStoreElimPass::Process() { InitExtensionAllowList(); return ProcessImpl(); } void LocalSingleStoreElimPass::InitExtensionAllowList() { extensions_allowlist_.insert({"SPV_AMD_shader_explicit_vertex_parameter", "SPV_AMD_shader_trinary_minmax", "SPV_AMD_gcn_shader", "SPV_KHR_shader_ballot", "SPV_AMD_shader_ballot", "SPV_AMD_gpu_shader_half_float", "SPV_KHR_shader_draw_parameters", "SPV_KHR_subgroup_vote", "SPV_KHR_8bit_storage", "SPV_KHR_16bit_storage", "SPV_KHR_device_group", "SPV_KHR_multiview", "SPV_NVX_multiview_per_view_attributes", "SPV_NV_viewport_array2", "SPV_NV_stereo_view_rendering", "SPV_NV_sample_mask_override_coverage", "SPV_NV_geometry_shader_passthrough", "SPV_AMD_texture_gather_bias_lod", "SPV_KHR_storage_buffer_storage_class", "SPV_KHR_variable_pointers", "SPV_AMD_gpu_shader_int16", "SPV_KHR_post_depth_coverage", "SPV_KHR_shader_atomic_counter_ops", "SPV_EXT_shader_stencil_export", "SPV_EXT_shader_viewport_index_layer", "SPV_AMD_shader_image_load_store_lod", "SPV_AMD_shader_fragment_mask", "SPV_EXT_fragment_fully_covered", "SPV_AMD_gpu_shader_half_float_fetch", "SPV_GOOGLE_decorate_string", "SPV_GOOGLE_hlsl_functionality1", "SPV_NV_shader_subgroup_partitioned", "SPV_EXT_descriptor_indexing", "SPV_NV_fragment_shader_barycentric", "SPV_NV_compute_shader_derivatives", "SPV_NV_shader_image_footprint", "SPV_NV_shading_rate", "SPV_NV_mesh_shader", "SPV_EXT_mesh_shader", "SPV_NV_ray_tracing", "SPV_KHR_ray_query", "SPV_EXT_fragment_invocation_density", "SPV_EXT_physical_storage_buffer", "SPV_KHR_physical_storage_buffer", "SPV_KHR_terminate_invocation", "SPV_KHR_subgroup_uniform_control_flow", "SPV_KHR_integer_dot_product", "SPV_EXT_shader_image_int64", "SPV_KHR_non_semantic_info", "SPV_KHR_uniform_group_instructions", "SPV_KHR_fragment_shader_barycentric", "SPV_KHR_vulkan_memory_model", "SPV_NV_bindless_texture", "SPV_EXT_shader_atomic_float_add", "SPV_EXT_fragment_shader_interlock", "SPV_KHR_compute_shader_derivatives", "SPV_NV_cooperative_matrix", "SPV_KHR_cooperative_matrix", "SPV_KHR_ray_tracing_position_fetch", "SPV_AMDX_shader_enqueue", "SPV_KHR_fragment_shading_rate", "SPV_KHR_ray_tracing"}); } bool LocalSingleStoreElimPass::ProcessVariable(Instruction* var_inst) { std::vector users; FindUses(var_inst, &users); Instruction* store_inst = FindSingleStoreAndCheckUses(var_inst, users); if (store_inst == nullptr) { return false; } bool all_rewritten; bool modified = RewriteLoads(store_inst, users, &all_rewritten); // If all uses are rewritten and the variable has a DebugDeclare and the // variable is not an aggregate, add a DebugValue after the store and remove // the DebugDeclare. uint32_t var_id = var_inst->result_id(); if (all_rewritten && context()->get_debug_info_mgr()->IsVariableDebugDeclared(var_id)) { const analysis::Type* var_type = context()->get_type_mgr()->GetType(var_inst->type_id()); const analysis::Type* store_type = var_type->AsPointer()->pointee_type(); if (!(store_type->AsStruct() || store_type->AsArray())) { modified |= RewriteDebugDeclares(store_inst, var_id); } } return modified; } bool LocalSingleStoreElimPass::RewriteDebugDeclares(Instruction* store_inst, uint32_t var_id) { uint32_t value_id = store_inst->GetSingleWordInOperand(1); bool modified = context()->get_debug_info_mgr()->AddDebugValueForVariable( store_inst, var_id, value_id, store_inst); modified |= context()->get_debug_info_mgr()->KillDebugDeclares(var_id); return modified; } Instruction* LocalSingleStoreElimPass::FindSingleStoreAndCheckUses( Instruction* var_inst, const std::vector& users) const { // Make sure there is exactly 1 store. Instruction* store_inst = nullptr; // If |var_inst| has an initializer, then that will count as a store. if (var_inst->NumInOperands() > 1) { store_inst = var_inst; } for (Instruction* user : users) { switch (user->opcode()) { case spv::Op::OpStore: // Since we are in the relaxed addressing mode, the use has to be the // base address of the store, and not the value being store. Otherwise, // we would have a pointer to a pointer to function scope memory, which // is not allowed. if (store_inst == nullptr) { store_inst = user; } else { // More than 1 store. return nullptr; } break; case spv::Op::OpAccessChain: case spv::Op::OpInBoundsAccessChain: if (FeedsAStore(user)) { // Has a partial store. Cannot propagate that. return nullptr; } break; case spv::Op::OpLoad: case spv::Op::OpImageTexelPointer: case spv::Op::OpName: case spv::Op::OpCopyObject: break; case spv::Op::OpExtInst: { auto dbg_op = user->GetCommonDebugOpcode(); if (dbg_op == CommonDebugInfoDebugDeclare || dbg_op == CommonDebugInfoDebugValue) { break; } return nullptr; } default: if (!user->IsDecoration()) { // Don't know if this instruction modifies the variable. // Conservatively assume it is a store. return nullptr; } break; } } return store_inst; } void LocalSingleStoreElimPass::FindUses( const Instruction* var_inst, std::vector* users) const { analysis::DefUseManager* def_use_mgr = context()->get_def_use_mgr(); def_use_mgr->ForEachUser(var_inst, [users, this](Instruction* user) { users->push_back(user); if (user->opcode() == spv::Op::OpCopyObject) { FindUses(user, users); } }); } bool LocalSingleStoreElimPass::FeedsAStore(Instruction* inst) const { analysis::DefUseManager* def_use_mgr = context()->get_def_use_mgr(); return !def_use_mgr->WhileEachUser(inst, [this](Instruction* user) { switch (user->opcode()) { case spv::Op::OpStore: return false; case spv::Op::OpAccessChain: case spv::Op::OpInBoundsAccessChain: case spv::Op::OpCopyObject: return !FeedsAStore(user); case spv::Op::OpLoad: case spv::Op::OpImageTexelPointer: case spv::Op::OpName: return true; default: // Don't know if this instruction modifies the variable. // Conservatively assume it is a store. return user->IsDecoration(); } }); } bool LocalSingleStoreElimPass::RewriteLoads( Instruction* store_inst, const std::vector& uses, bool* all_rewritten) { BasicBlock* store_block = context()->get_instr_block(store_inst); DominatorAnalysis* dominator_analysis = context()->GetDominatorAnalysis(store_block->GetParent()); uint32_t stored_id; if (store_inst->opcode() == spv::Op::OpStore) stored_id = store_inst->GetSingleWordInOperand(kStoreValIdInIdx); else stored_id = store_inst->GetSingleWordInOperand(kVariableInitIdInIdx); *all_rewritten = true; bool modified = false; for (Instruction* use : uses) { if (use->opcode() == spv::Op::OpStore) continue; auto dbg_op = use->GetCommonDebugOpcode(); if (dbg_op == CommonDebugInfoDebugDeclare || dbg_op == CommonDebugInfoDebugValue) continue; if (use->opcode() == spv::Op::OpLoad && dominator_analysis->Dominates(store_inst, use)) { modified = true; context()->KillNamesAndDecorates(use->result_id()); context()->ReplaceAllUsesWith(use->result_id(), stored_id); context()->KillInst(use); } else { *all_rewritten = false; } } return modified; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/local_single_store_elim_pass.h000066400000000000000000000075141475742701700267160ustar00rootroot00000000000000// Copyright (c) 2017 The Khronos Group Inc. // Copyright (c) 2017 Valve Corporation // Copyright (c) 2017 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_LOCAL_SINGLE_STORE_ELIM_PASS_H_ #define SOURCE_OPT_LOCAL_SINGLE_STORE_ELIM_PASS_H_ #include #include #include #include #include #include #include #include #include "source/opt/basic_block.h" #include "source/opt/def_use_manager.h" #include "source/opt/mem_pass.h" #include "source/opt/module.h" namespace spvtools { namespace opt { // See optimizer.hpp for documentation. class LocalSingleStoreElimPass : public Pass { using cbb_ptr = const BasicBlock*; public: LocalSingleStoreElimPass(); const char* name() const override { return "eliminate-local-single-store"; } Status Process() override; IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisConstants | IRContext::kAnalysisTypes; } private: // Do "single-store" optimization of function variables defined only // with a single non-access-chain store in |func|. Replace all their // non-access-chain loads with the value that is stored and eliminate // any resulting dead code. bool LocalSingleStoreElim(Function* func); // Initialize extensions allowlist void InitExtensionAllowList(); // Return true if all extensions in this module are allowed by this pass. bool AllExtensionsSupported() const; Pass::Status ProcessImpl(); // If there is a single store to |var_inst|, and it covers the entire // variable, then replace all of the loads of the entire variable that are // dominated by the store by the value that was stored. Returns true if the // module was changed. bool ProcessVariable(Instruction* var_inst); // Collects all of the uses of |var_inst| into |uses|. This looks through // OpObjectCopy's that copy the address of the variable, and collects those // uses as well. void FindUses(const Instruction* var_inst, std::vector* uses) const; // Returns a store to |var_inst| if // - it is a store to the entire variable, // - and there are no other instructions that may modify |var_inst|. Instruction* FindSingleStoreAndCheckUses( Instruction* var_inst, const std::vector& users) const; // Returns true if the address that results from |inst| may be used as a base // address in a store instruction or may be used to compute the base address // of a store instruction. bool FeedsAStore(Instruction* inst) const; // Replaces all of the loads in |uses| by the value stored in |store_inst|. // The load instructions are then killed. |all_rewritten| is true iff all // uses have been rewritten. bool RewriteLoads(Instruction* store_inst, const std::vector& uses, bool* all_rewritten); // Replaces DebugDeclares of |var_id| with DebugValues using the value // assignment of |store_inst|. bool RewriteDebugDeclares(Instruction* store_inst, uint32_t var_id); // Extensions supported by this pass. std::unordered_set extensions_allowlist_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_LOCAL_SINGLE_STORE_ELIM_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/log.h000066400000000000000000000220341475742701700215660ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_LOG_H_ #define SOURCE_OPT_LOG_H_ #include #include #include #include #include "spirv-tools/libspirv.hpp" // Asserts the given condition is true. Otherwise, sends a message to the // consumer and exits the program with failure code. Accepts the following // formats: // // SPIRV_ASSERT(, ); // SPIRV_ASSERT(, , ); // SPIRV_ASSERT(, , // , ); // // In the third format, the number of cannot exceed (5 - // 2). If more arguments are wanted, grow PP_ARG_N and PP_NARGS in the below. #if !defined(NDEBUG) #define SPIRV_ASSERT(consumer, ...) SPIRV_ASSERT_IMPL(consumer, __VA_ARGS__) #else // Adding a use to avoid errors in the release build related to unused // consumers. #define SPIRV_ASSERT(consumer, ...) (void)(consumer) #endif // Logs a debug message to the consumer. Accepts the following formats: // // SPIRV_DEBUG(, ); // SPIRV_DEBUG(, , ); // // In the second format, the number of cannot exceed (5 - // 1). If more arguments are wanted, grow PP_ARG_N and PP_NARGS in the below. #if !defined(NDEBUG) && defined(SPIRV_LOG_DEBUG) #define SPIRV_DEBUG(consumer, ...) SPIRV_DEBUG_IMPL(consumer, __VA_ARGS__) #else // Adding a use to avoid errors in the release build related to unused // consumers. #define SPIRV_DEBUG(consumer, ...) (void)(consumer) #endif // Helper macros for concatenating arguments. #define SPIRV_CONCATENATE(a, b) SPIRV_CONCATENATE_(a, b) #define SPIRV_CONCATENATE_(a, b) a##b // Helper macro to force expanding __VA_ARGS__ to satisfy MSVC compiler. #define PP_EXPAND(x) x namespace spvtools { // Calls the given |consumer| by supplying the |message|. The |message| is from // the given |source| and |location| and of the given severity |level|. inline void Log(const MessageConsumer& consumer, spv_message_level_t level, const char* source, const spv_position_t& position, const char* message) { if (consumer != nullptr) consumer(level, source, position, message); } // Calls the given |consumer| by supplying the message composed according to the // given |format|. The |message| is from the given |source| and |location| and // of the given severity |level|. template void Logf(const MessageConsumer& consumer, spv_message_level_t level, const char* source, const spv_position_t& position, const char* format, Args&&... args) { #if defined(_MSC_VER) && _MSC_VER < 1900 // Sadly, snprintf() is not supported until Visual Studio 2015! #define snprintf _snprintf #endif enum { kInitBufferSize = 256 }; char message[kInitBufferSize]; const int size = snprintf(message, kInitBufferSize, format, std::forward(args)...); if (size >= 0 && size < kInitBufferSize) { Log(consumer, level, source, position, message); return; } if (size >= 0) { // The initial buffer is insufficient. Allocate a buffer of a larger size, // and write to it instead. Force the size to be unsigned to avoid a // warning in GCC 7.1. std::vector longer_message(size + 1u); snprintf(longer_message.data(), longer_message.size(), format, std::forward(args)...); Log(consumer, level, source, position, longer_message.data()); return; } Log(consumer, level, source, position, "cannot compose log message"); #if defined(_MSC_VER) && _MSC_VER < 1900 #undef snprintf #endif } // Calls the given |consumer| by supplying the given error |message|. The // |message| is from the given |source| and |location|. inline void Error(const MessageConsumer& consumer, const char* source, const spv_position_t& position, const char* message) { Log(consumer, SPV_MSG_ERROR, source, position, message); } // Calls the given |consumer| by supplying the error message composed according // to the given |format|. The |message| is from the given |source| and // |location|. template inline void Errorf(const MessageConsumer& consumer, const char* source, const spv_position_t& position, const char* format, Args&&... args) { Logf(consumer, SPV_MSG_ERROR, source, position, format, std::forward(args)...); } } // namespace spvtools #define SPIRV_ASSERT_IMPL(consumer, ...) \ PP_EXPAND(SPIRV_CONCATENATE(SPIRV_ASSERT_, PP_NARGS(__VA_ARGS__))( \ consumer, __VA_ARGS__)) #define SPIRV_DEBUG_IMPL(consumer, ...) \ PP_EXPAND(SPIRV_CONCATENATE(SPIRV_DEBUG_, PP_NARGS(__VA_ARGS__))( \ consumer, __VA_ARGS__)) #define SPIRV_ASSERT_1(consumer, condition) \ do { \ if (!(condition)) { \ spvtools::Log(consumer, SPV_MSG_INTERNAL_ERROR, __FILE__, \ {static_cast(__LINE__), 0, 0}, \ "assertion failed: " #condition); \ std::exit(EXIT_FAILURE); \ } \ } while (0) #define SPIRV_ASSERT_2(consumer, condition, message) \ do { \ if (!(condition)) { \ spvtools::Log(consumer, SPV_MSG_INTERNAL_ERROR, __FILE__, \ {static_cast(__LINE__), 0, 0}, \ "assertion failed: " message); \ std::exit(EXIT_FAILURE); \ } \ } while (0) #define SPIRV_ASSERT_more(consumer, condition, format, ...) \ do { \ if (!(condition)) { \ spvtools::Logf(consumer, SPV_MSG_INTERNAL_ERROR, __FILE__, \ {static_cast(__LINE__), 0, 0}, \ "assertion failed: " format, __VA_ARGS__); \ std::exit(EXIT_FAILURE); \ } \ } while (0) #define SPIRV_ASSERT_3(consumer, condition, format, ...) \ SPIRV_ASSERT_more(consumer, condition, format, __VA_ARGS__) #define SPIRV_ASSERT_4(consumer, condition, format, ...) \ SPIRV_ASSERT_more(consumer, condition, format, __VA_ARGS__) #define SPIRV_ASSERT_5(consumer, condition, format, ...) \ SPIRV_ASSERT_more(consumer, condition, format, __VA_ARGS__) #define SPIRV_DEBUG_1(consumer, message) \ do { \ spvtools::Log(consumer, SPV_MSG_DEBUG, __FILE__, \ {static_cast(__LINE__), 0, 0}, message); \ } while (0) #define SPIRV_DEBUG_more(consumer, format, ...) \ do { \ spvtools::Logf(consumer, SPV_MSG_DEBUG, __FILE__, \ {static_cast(__LINE__), 0, 0}, format, \ __VA_ARGS__); \ } while (0) #define SPIRV_DEBUG_2(consumer, format, ...) \ SPIRV_DEBUG_more(consumer, format, __VA_ARGS__) #define SPIRV_DEBUG_3(consumer, format, ...) \ SPIRV_DEBUG_more(consumer, format, __VA_ARGS__) #define SPIRV_DEBUG_4(consumer, format, ...) \ SPIRV_DEBUG_more(consumer, format, __VA_ARGS__) #define SPIRV_DEBUG_5(consumer, format, ...) \ SPIRV_DEBUG_more(consumer, format, __VA_ARGS__) // Macros for counting the number of arguments passed in. #define PP_NARGS(...) PP_EXPAND(PP_ARG_N(__VA_ARGS__, 5, 4, 3, 2, 1, 0)) #define PP_ARG_N(_1, _2, _3, _4, _5, N, ...) N // Tests for making sure that PP_NARGS() behaves as expected. static_assert(PP_NARGS(0) == 1, "PP_NARGS macro error"); static_assert(PP_NARGS(0, 0) == 2, "PP_NARGS macro error"); static_assert(PP_NARGS(0, 0, 0) == 3, "PP_NARGS macro error"); static_assert(PP_NARGS(0, 0, 0, 0) == 4, "PP_NARGS macro error"); static_assert(PP_NARGS(0, 0, 0, 0, 0) == 5, "PP_NARGS macro error"); static_assert(PP_NARGS(1 + 1, 2, 3 / 3) == 3, "PP_NARGS macro error"); static_assert(PP_NARGS((1, 1), 2, (3, 3)) == 3, "PP_NARGS macro error"); #endif // SOURCE_OPT_LOG_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/loop_dependence.cpp000066400000000000000000001777271475742701700245070ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/loop_dependence.h" #include #include #include #include #include #include "source/opt/instruction.h" #include "source/opt/scalar_analysis_nodes.h" namespace spvtools { namespace opt { using SubscriptPair = std::pair; namespace { // Calculate the greatest common divisor of a & b using Stein's algorithm. // https://en.wikipedia.org/wiki/Binary_GCD_algorithm int64_t GreatestCommonDivisor(int64_t a, int64_t b) { // Simple cases if (a == b) { return a; } else if (a == 0) { return b; } else if (b == 0) { return a; } // Both even if (a % 2 == 0 && b % 2 == 0) { return 2 * GreatestCommonDivisor(a / 2, b / 2); } // Even a, odd b if (a % 2 == 0 && b % 2 == 1) { return GreatestCommonDivisor(a / 2, b); } // Odd a, even b if (a % 2 == 1 && b % 2 == 0) { return GreatestCommonDivisor(a, b / 2); } // Both odd, reduce the larger argument if (a > b) { return GreatestCommonDivisor((a - b) / 2, b); } else { return GreatestCommonDivisor((b - a) / 2, a); } } // Check if node is affine, ie in the form: a0*i0 + a1*i1 + ... an*in + c // and contains only the following types of nodes: SERecurrentNode, SEAddNode // and SEConstantNode bool IsInCorrectFormForGCDTest(SENode* node) { bool children_ok = true; if (auto add_node = node->AsSEAddNode()) { for (auto child : add_node->GetChildren()) { children_ok &= IsInCorrectFormForGCDTest(child); } } bool this_ok = node->AsSERecurrentNode() || node->AsSEAddNode() || node->AsSEConstantNode(); return children_ok && this_ok; } // If |node| is an SERecurrentNode then returns |node| or if |node| is an // SEAddNode returns a vector of SERecurrentNode that are its children. std::vector GetAllTopLevelRecurrences(SENode* node) { auto nodes = std::vector{}; if (auto recurrent_node = node->AsSERecurrentNode()) { nodes.push_back(recurrent_node); } if (auto add_node = node->AsSEAddNode()) { for (auto child : add_node->GetChildren()) { auto child_nodes = GetAllTopLevelRecurrences(child); nodes.insert(nodes.end(), child_nodes.begin(), child_nodes.end()); } } return nodes; } // If |node| is an SEConstantNode then returns |node| or if |node| is an // SEAddNode returns a vector of SEConstantNode that are its children. std::vector GetAllTopLevelConstants(SENode* node) { auto nodes = std::vector{}; if (auto recurrent_node = node->AsSEConstantNode()) { nodes.push_back(recurrent_node); } if (auto add_node = node->AsSEAddNode()) { for (auto child : add_node->GetChildren()) { auto child_nodes = GetAllTopLevelConstants(child); nodes.insert(nodes.end(), child_nodes.begin(), child_nodes.end()); } } return nodes; } bool AreOffsetsAndCoefficientsConstant( const std::vector& nodes) { for (auto node : nodes) { if (!node->GetOffset()->AsSEConstantNode() || !node->GetOffset()->AsSEConstantNode()) { return false; } } return true; } // Fold all SEConstantNode that appear in |recurrences| and |constants| into a // single integer value. int64_t CalculateConstantTerm(const std::vector& recurrences, const std::vector& constants) { int64_t constant_term = 0; for (auto recurrence : recurrences) { constant_term += recurrence->GetOffset()->AsSEConstantNode()->FoldToSingleValue(); } for (auto constant : constants) { constant_term += constant->FoldToSingleValue(); } return constant_term; } int64_t CalculateGCDFromCoefficients( const std::vector& recurrences, int64_t running_gcd) { for (SERecurrentNode* recurrence : recurrences) { auto coefficient = recurrence->GetCoefficient()->AsSEConstantNode(); running_gcd = GreatestCommonDivisor( running_gcd, std::abs(coefficient->FoldToSingleValue())); } return running_gcd; } // Compare 2 fractions while first normalizing them, e.g. 2/4 and 4/8 will both // be simplified to 1/2 and then determined to be equal. bool NormalizeAndCompareFractions(int64_t numerator_0, int64_t denominator_0, int64_t numerator_1, int64_t denominator_1) { auto gcd_0 = GreatestCommonDivisor(std::abs(numerator_0), std::abs(denominator_0)); auto gcd_1 = GreatestCommonDivisor(std::abs(numerator_1), std::abs(denominator_1)); auto normalized_numerator_0 = numerator_0 / gcd_0; auto normalized_denominator_0 = denominator_0 / gcd_0; auto normalized_numerator_1 = numerator_1 / gcd_1; auto normalized_denominator_1 = denominator_1 / gcd_1; return normalized_numerator_0 == normalized_numerator_1 && normalized_denominator_0 == normalized_denominator_1; } } // namespace bool LoopDependenceAnalysis::GetDependence(const Instruction* source, const Instruction* destination, DistanceVector* distance_vector) { // Start off by finding and marking all the loops in |loops_| that are // irrelevant to the dependence analysis. MarkUnsusedDistanceEntriesAsIrrelevant(source, destination, distance_vector); Instruction* source_access_chain = GetOperandDefinition(source, 0); Instruction* destination_access_chain = GetOperandDefinition(destination, 0); auto num_access_chains = (source_access_chain->opcode() == spv::Op::OpAccessChain) + (destination_access_chain->opcode() == spv::Op::OpAccessChain); // If neither is an access chain, then they are load/store to a variable. if (num_access_chains == 0) { if (source_access_chain != destination_access_chain) { // Not the same location, report independence return true; } else { // Accessing the same variable for (auto& entry : distance_vector->GetEntries()) { entry = DistanceEntry(); } return false; } } // If only one is an access chain, it could be accessing a part of a struct if (num_access_chains == 1) { auto source_is_chain = source_access_chain->opcode() == spv::Op::OpAccessChain; auto access_chain = source_is_chain ? source_access_chain : destination_access_chain; auto variable = source_is_chain ? destination_access_chain : source_access_chain; auto location_in_chain = GetOperandDefinition(access_chain, 0); if (variable != location_in_chain) { // Not the same location, report independence return true; } else { // Accessing the same variable for (auto& entry : distance_vector->GetEntries()) { entry = DistanceEntry(); } return false; } } // If the access chains aren't collecting from the same structure there is no // dependence. Instruction* source_array = GetOperandDefinition(source_access_chain, 0); Instruction* destination_array = GetOperandDefinition(destination_access_chain, 0); // Nested access chains are not supported yet, bail out. if (source_array->opcode() == spv::Op::OpAccessChain || destination_array->opcode() == spv::Op::OpAccessChain) { for (auto& entry : distance_vector->GetEntries()) { entry = DistanceEntry(); } return false; } if (source_array != destination_array) { PrintDebug("Proved independence through different arrays."); return true; } // To handle multiple subscripts we must get every operand in the access // chains past the first. std::vector source_subscripts = GetSubscripts(source); std::vector destination_subscripts = GetSubscripts(destination); auto sets_of_subscripts = PartitionSubscripts(source_subscripts, destination_subscripts); auto first_coupled = std::partition( std::begin(sets_of_subscripts), std::end(sets_of_subscripts), [](const std::set>& set) { return set.size() == 1; }); // Go through each subscript testing for independence. // If any subscript results in independence, we prove independence between the // load and store. // If we can't prove independence we store what information we can gather in // a DistanceVector. for (auto it = std::begin(sets_of_subscripts); it < first_coupled; ++it) { auto source_subscript = std::get<0>(*(*it).begin()); auto destination_subscript = std::get<1>(*(*it).begin()); SENode* source_node = scalar_evolution_.SimplifyExpression( scalar_evolution_.AnalyzeInstruction(source_subscript)); SENode* destination_node = scalar_evolution_.SimplifyExpression( scalar_evolution_.AnalyzeInstruction(destination_subscript)); // Check the loops are in a form we support. auto subscript_pair = std::make_pair(source_node, destination_node); const Loop* loop = GetLoopForSubscriptPair(subscript_pair); if (loop) { if (!IsSupportedLoop(loop)) { PrintDebug( "GetDependence found an unsupported loop form. Assuming <=> for " "loop."); DistanceEntry* distance_entry = GetDistanceEntryForSubscriptPair(subscript_pair, distance_vector); if (distance_entry) { distance_entry->direction = DistanceEntry::Directions::ALL; } continue; } } // If either node is simplified to a CanNotCompute we can't perform any // analysis so must assume <=> dependence and return. if (source_node->GetType() == SENode::CanNotCompute || destination_node->GetType() == SENode::CanNotCompute) { // Record the <=> dependence if we can get a DistanceEntry PrintDebug( "GetDependence found source_node || destination_node as " "CanNotCompute. Abandoning evaluation for this subscript."); DistanceEntry* distance_entry = GetDistanceEntryForSubscriptPair(subscript_pair, distance_vector); if (distance_entry) { distance_entry->direction = DistanceEntry::Directions::ALL; } continue; } // We have no induction variables so can apply a ZIV test. if (IsZIV(subscript_pair)) { PrintDebug("Found a ZIV subscript pair"); if (ZIVTest(subscript_pair)) { PrintDebug("Proved independence with ZIVTest."); return true; } } // We have only one induction variable so should attempt an SIV test. if (IsSIV(subscript_pair)) { PrintDebug("Found a SIV subscript pair."); if (SIVTest(subscript_pair, distance_vector)) { PrintDebug("Proved independence with SIVTest."); return true; } } // We have multiple induction variables so should attempt an MIV test. if (IsMIV(subscript_pair)) { PrintDebug("Found a MIV subscript pair."); if (GCDMIVTest(subscript_pair)) { PrintDebug("Proved independence with the GCD test."); auto current_loops = CollectLoops(source_node, destination_node); for (auto current_loop : current_loops) { auto distance_entry = GetDistanceEntryForLoop(current_loop, distance_vector); distance_entry->direction = DistanceEntry::Directions::NONE; } return true; } } } for (auto it = first_coupled; it < std::end(sets_of_subscripts); ++it) { auto coupled_instructions = *it; std::vector coupled_subscripts{}; for (const auto& elem : coupled_instructions) { auto source_subscript = std::get<0>(elem); auto destination_subscript = std::get<1>(elem); SENode* source_node = scalar_evolution_.SimplifyExpression( scalar_evolution_.AnalyzeInstruction(source_subscript)); SENode* destination_node = scalar_evolution_.SimplifyExpression( scalar_evolution_.AnalyzeInstruction(destination_subscript)); coupled_subscripts.push_back({source_node, destination_node}); } auto supported = true; for (const auto& subscript : coupled_subscripts) { auto loops = CollectLoops(std::get<0>(subscript), std::get<1>(subscript)); auto is_subscript_supported = std::all_of(std::begin(loops), std::end(loops), [this](const Loop* l) { return IsSupportedLoop(l); }); supported = supported && is_subscript_supported; } if (DeltaTest(coupled_subscripts, distance_vector)) { return true; } } // We were unable to prove independence so must gather all of the direction // information we found. PrintDebug( "Couldn't prove independence.\n" "All possible direction information has been collected in the input " "DistanceVector."); return false; } bool LoopDependenceAnalysis::ZIVTest( const std::pair& subscript_pair) { auto source = std::get<0>(subscript_pair); auto destination = std::get<1>(subscript_pair); PrintDebug("Performing ZIVTest"); // If source == destination, dependence with direction = and distance 0. if (source == destination) { PrintDebug("ZIVTest found EQ dependence."); return false; } else { PrintDebug("ZIVTest found independence."); // Otherwise we prove independence. return true; } } bool LoopDependenceAnalysis::SIVTest( const std::pair& subscript_pair, DistanceVector* distance_vector) { DistanceEntry* distance_entry = GetDistanceEntryForSubscriptPair(subscript_pair, distance_vector); if (!distance_entry) { PrintDebug( "SIVTest could not find a DistanceEntry for subscript_pair. Exiting"); } SENode* source_node = std::get<0>(subscript_pair); SENode* destination_node = std::get<1>(subscript_pair); int64_t source_induction_count = CountInductionVariables(source_node); int64_t destination_induction_count = CountInductionVariables(destination_node); // If the source node has no induction variables we can apply a // WeakZeroSrcTest. if (source_induction_count == 0) { PrintDebug("Found source has no induction variable."); if (WeakZeroSourceSIVTest( source_node, destination_node->AsSERecurrentNode(), destination_node->AsSERecurrentNode()->GetCoefficient(), distance_entry)) { PrintDebug("Proved independence with WeakZeroSourceSIVTest."); distance_entry->dependence_information = DistanceEntry::DependenceInformation::DIRECTION; distance_entry->direction = DistanceEntry::Directions::NONE; return true; } } // If the destination has no induction variables we can apply a // WeakZeroDestTest. if (destination_induction_count == 0) { PrintDebug("Found destination has no induction variable."); if (WeakZeroDestinationSIVTest( source_node->AsSERecurrentNode(), destination_node, source_node->AsSERecurrentNode()->GetCoefficient(), distance_entry)) { PrintDebug("Proved independence with WeakZeroDestinationSIVTest."); distance_entry->dependence_information = DistanceEntry::DependenceInformation::DIRECTION; distance_entry->direction = DistanceEntry::Directions::NONE; return true; } } // We now need to collect the SERecurrentExpr nodes from source and // destination. We do not handle cases where source or destination have // multiple SERecurrentExpr nodes. std::vector source_recurrent_nodes = source_node->CollectRecurrentNodes(); std::vector destination_recurrent_nodes = destination_node->CollectRecurrentNodes(); if (source_recurrent_nodes.size() == 1 && destination_recurrent_nodes.size() == 1) { PrintDebug("Found source and destination have 1 induction variable."); SERecurrentNode* source_recurrent_expr = *source_recurrent_nodes.begin(); SERecurrentNode* destination_recurrent_expr = *destination_recurrent_nodes.begin(); // If the coefficients are identical we can apply a StrongSIVTest. if (source_recurrent_expr->GetCoefficient() == destination_recurrent_expr->GetCoefficient()) { PrintDebug("Found source and destination share coefficient."); if (StrongSIVTest(source_node, destination_node, source_recurrent_expr->GetCoefficient(), distance_entry)) { PrintDebug("Proved independence with StrongSIVTest"); distance_entry->dependence_information = DistanceEntry::DependenceInformation::DIRECTION; distance_entry->direction = DistanceEntry::Directions::NONE; return true; } } // If the coefficients are of equal magnitude and opposite sign we can // apply a WeakCrossingSIVTest. if (source_recurrent_expr->GetCoefficient() == scalar_evolution_.CreateNegation( destination_recurrent_expr->GetCoefficient())) { PrintDebug("Found source coefficient = -destination coefficient."); if (WeakCrossingSIVTest(source_node, destination_node, source_recurrent_expr->GetCoefficient(), distance_entry)) { PrintDebug("Proved independence with WeakCrossingSIVTest"); distance_entry->dependence_information = DistanceEntry::DependenceInformation::DIRECTION; distance_entry->direction = DistanceEntry::Directions::NONE; return true; } } } return false; } bool LoopDependenceAnalysis::StrongSIVTest(SENode* source, SENode* destination, SENode* coefficient, DistanceEntry* distance_entry) { PrintDebug("Performing StrongSIVTest."); // If both source and destination are SERecurrentNodes we can perform tests // based on distance. // If either source or destination contain value unknown nodes or if one or // both are not SERecurrentNodes we must attempt a symbolic test. std::vector source_value_unknown_nodes = source->CollectValueUnknownNodes(); std::vector destination_value_unknown_nodes = destination->CollectValueUnknownNodes(); if (source_value_unknown_nodes.size() > 0 || destination_value_unknown_nodes.size() > 0) { PrintDebug( "StrongSIVTest found symbolics. Will attempt SymbolicStrongSIVTest."); return SymbolicStrongSIVTest(source, destination, coefficient, distance_entry); } if (!source->AsSERecurrentNode() || !destination->AsSERecurrentNode()) { PrintDebug( "StrongSIVTest could not simplify source and destination to " "SERecurrentNodes so will exit."); distance_entry->direction = DistanceEntry::Directions::ALL; return false; } // Build an SENode for distance. std::pair subscript_pair = std::make_pair(source, destination); const Loop* subscript_loop = GetLoopForSubscriptPair(subscript_pair); SENode* source_constant_term = GetConstantTerm(subscript_loop, source->AsSERecurrentNode()); SENode* destination_constant_term = GetConstantTerm(subscript_loop, destination->AsSERecurrentNode()); if (!source_constant_term || !destination_constant_term) { PrintDebug( "StrongSIVTest could not collect the constant terms of either source " "or destination so will exit."); return false; } SENode* constant_term_delta = scalar_evolution_.SimplifyExpression(scalar_evolution_.CreateSubtraction( destination_constant_term, source_constant_term)); // Scalar evolution doesn't perform division, so we must fold to constants and // do it manually. // We must check the offset delta and coefficient are constants. int64_t distance = 0; SEConstantNode* delta_constant = constant_term_delta->AsSEConstantNode(); SEConstantNode* coefficient_constant = coefficient->AsSEConstantNode(); if (delta_constant && coefficient_constant) { int64_t delta_value = delta_constant->FoldToSingleValue(); int64_t coefficient_value = coefficient_constant->FoldToSingleValue(); PrintDebug( "StrongSIVTest found delta value and coefficient value as constants " "with values:\n" "\tdelta value: " + ToString(delta_value) + "\n\tcoefficient value: " + ToString(coefficient_value) + "\n"); // Check if the distance is not integral to try to prove independence. if (delta_value % coefficient_value != 0) { PrintDebug( "StrongSIVTest proved independence through distance not being an " "integer."); distance_entry->dependence_information = DistanceEntry::DependenceInformation::DIRECTION; distance_entry->direction = DistanceEntry::Directions::NONE; return true; } else { distance = delta_value / coefficient_value; PrintDebug("StrongSIV test found distance as " + ToString(distance)); } } else { // If we can't fold delta and coefficient to single values we can't produce // distance. // As a result we can't perform the rest of the pass and must assume // dependence in all directions. PrintDebug("StrongSIVTest could not produce a distance. Must exit."); distance_entry->distance = DistanceEntry::Directions::ALL; return false; } // Next we gather the upper and lower bounds as constants if possible. If // distance > upper_bound - lower_bound we prove independence. SENode* lower_bound = GetLowerBound(subscript_loop); SENode* upper_bound = GetUpperBound(subscript_loop); if (lower_bound && upper_bound) { PrintDebug("StrongSIVTest found bounds."); SENode* bounds = scalar_evolution_.SimplifyExpression( scalar_evolution_.CreateSubtraction(upper_bound, lower_bound)); if (bounds->GetType() == SENode::SENodeType::Constant) { int64_t bounds_value = bounds->AsSEConstantNode()->FoldToSingleValue(); PrintDebug( "StrongSIVTest found upper_bound - lower_bound as a constant with " "value " + ToString(bounds_value)); // If the absolute value of the distance is > upper bound - lower bound // then we prove independence. if (llabs(distance) > llabs(bounds_value)) { PrintDebug( "StrongSIVTest proved independence through distance escaping the " "loop bounds."); distance_entry->dependence_information = DistanceEntry::DependenceInformation::DISTANCE; distance_entry->direction = DistanceEntry::Directions::NONE; distance_entry->distance = distance; return true; } } } else { PrintDebug("StrongSIVTest was unable to gather lower and upper bounds."); } // Otherwise we can get a direction as follows // { < if distance > 0 // direction = { = if distance == 0 // { > if distance < 0 PrintDebug( "StrongSIVTest could not prove independence. Gathering direction " "information."); if (distance > 0) { distance_entry->dependence_information = DistanceEntry::DependenceInformation::DISTANCE; distance_entry->direction = DistanceEntry::Directions::LT; distance_entry->distance = distance; return false; } if (distance == 0) { distance_entry->dependence_information = DistanceEntry::DependenceInformation::DISTANCE; distance_entry->direction = DistanceEntry::Directions::EQ; distance_entry->distance = 0; return false; } if (distance < 0) { distance_entry->dependence_information = DistanceEntry::DependenceInformation::DISTANCE; distance_entry->direction = DistanceEntry::Directions::GT; distance_entry->distance = distance; return false; } // We were unable to prove independence or discern any additional information // Must assume <=> direction. PrintDebug( "StrongSIVTest was unable to determine any dependence information."); distance_entry->direction = DistanceEntry::Directions::ALL; return false; } bool LoopDependenceAnalysis::SymbolicStrongSIVTest( SENode* source, SENode* destination, SENode* coefficient, DistanceEntry* distance_entry) { PrintDebug("Performing SymbolicStrongSIVTest."); SENode* source_destination_delta = scalar_evolution_.SimplifyExpression( scalar_evolution_.CreateSubtraction(source, destination)); // By cancelling out the induction variables by subtracting the source and // destination we can produce an expression of symbolics and constants. This // expression can be compared to the loop bounds to find if the offset is // outwith the bounds. std::pair subscript_pair = std::make_pair(source, destination); const Loop* subscript_loop = GetLoopForSubscriptPair(subscript_pair); if (IsProvablyOutsideOfLoopBounds(subscript_loop, source_destination_delta, coefficient)) { PrintDebug( "SymbolicStrongSIVTest proved independence through loop bounds."); distance_entry->dependence_information = DistanceEntry::DependenceInformation::DIRECTION; distance_entry->direction = DistanceEntry::Directions::NONE; return true; } // We were unable to prove independence or discern any additional information. // Must assume <=> direction. PrintDebug( "SymbolicStrongSIVTest was unable to determine any dependence " "information."); distance_entry->direction = DistanceEntry::Directions::ALL; return false; } bool LoopDependenceAnalysis::WeakZeroSourceSIVTest( SENode* source, SERecurrentNode* destination, SENode* coefficient, DistanceEntry* distance_entry) { PrintDebug("Performing WeakZeroSourceSIVTest."); std::pair subscript_pair = std::make_pair(source, destination); const Loop* subscript_loop = GetLoopForSubscriptPair(subscript_pair); // Build an SENode for distance. SENode* destination_constant_term = GetConstantTerm(subscript_loop, destination); SENode* delta = scalar_evolution_.SimplifyExpression( scalar_evolution_.CreateSubtraction(source, destination_constant_term)); // Scalar evolution doesn't perform division, so we must fold to constants and // do it manually. int64_t distance = 0; SEConstantNode* delta_constant = delta->AsSEConstantNode(); SEConstantNode* coefficient_constant = coefficient->AsSEConstantNode(); if (delta_constant && coefficient_constant) { PrintDebug( "WeakZeroSourceSIVTest folding delta and coefficient to constants."); int64_t delta_value = delta_constant->FoldToSingleValue(); int64_t coefficient_value = coefficient_constant->FoldToSingleValue(); // Check if the distance is not integral. if (delta_value % coefficient_value != 0) { PrintDebug( "WeakZeroSourceSIVTest proved independence through distance not " "being an integer."); distance_entry->dependence_information = DistanceEntry::DependenceInformation::DIRECTION; distance_entry->direction = DistanceEntry::Directions::NONE; return true; } else { distance = delta_value / coefficient_value; PrintDebug( "WeakZeroSourceSIVTest calculated distance with the following " "values\n" "\tdelta value: " + ToString(delta_value) + "\n\tcoefficient value: " + ToString(coefficient_value) + "\n\tdistance: " + ToString(distance) + "\n"); } } else { PrintDebug( "WeakZeroSourceSIVTest was unable to fold delta and coefficient to " "constants."); } // If we can prove the distance is outside the bounds we prove independence. SEConstantNode* lower_bound = GetLowerBound(subscript_loop)->AsSEConstantNode(); SEConstantNode* upper_bound = GetUpperBound(subscript_loop)->AsSEConstantNode(); if (lower_bound && upper_bound) { PrintDebug("WeakZeroSourceSIVTest found bounds as SEConstantNodes."); int64_t lower_bound_value = lower_bound->FoldToSingleValue(); int64_t upper_bound_value = upper_bound->FoldToSingleValue(); if (!IsWithinBounds(llabs(distance), lower_bound_value, upper_bound_value)) { PrintDebug( "WeakZeroSourceSIVTest proved independence through distance escaping " "the loop bounds."); PrintDebug( "Bound values were as follow\n" "\tlower bound value: " + ToString(lower_bound_value) + "\n\tupper bound value: " + ToString(upper_bound_value) + "\n\tdistance value: " + ToString(distance) + "\n"); distance_entry->dependence_information = DistanceEntry::DependenceInformation::DISTANCE; distance_entry->direction = DistanceEntry::Directions::NONE; distance_entry->distance = distance; return true; } } else { PrintDebug( "WeakZeroSourceSIVTest was unable to find lower and upper bound as " "SEConstantNodes."); } // Now we want to see if we can detect to peel the first or last iterations. // We get the FirstTripValue as GetFirstTripInductionNode() + // GetConstantTerm(destination) SENode* first_trip_SENode = scalar_evolution_.SimplifyExpression(scalar_evolution_.CreateAddNode( GetFirstTripInductionNode(subscript_loop), GetConstantTerm(subscript_loop, destination))); // If source == FirstTripValue, peel_first. if (first_trip_SENode) { PrintDebug("WeakZeroSourceSIVTest built first_trip_SENode."); if (first_trip_SENode->AsSEConstantNode()) { PrintDebug( "WeakZeroSourceSIVTest has found first_trip_SENode as an " "SEConstantNode with value: " + ToString(first_trip_SENode->AsSEConstantNode()->FoldToSingleValue()) + "\n"); } if (source == first_trip_SENode) { // We have found that peeling the first iteration will break dependency. PrintDebug( "WeakZeroSourceSIVTest has found peeling first iteration will break " "dependency"); distance_entry->dependence_information = DistanceEntry::DependenceInformation::PEEL; distance_entry->peel_first = true; return false; } } else { PrintDebug("WeakZeroSourceSIVTest was unable to build first_trip_SENode"); } // We get the LastTripValue as GetFinalTripInductionNode(coefficient) + // GetConstantTerm(destination) SENode* final_trip_SENode = scalar_evolution_.SimplifyExpression(scalar_evolution_.CreateAddNode( GetFinalTripInductionNode(subscript_loop, coefficient), GetConstantTerm(subscript_loop, destination))); // If source == LastTripValue, peel_last. if (final_trip_SENode) { PrintDebug("WeakZeroSourceSIVTest built final_trip_SENode."); if (first_trip_SENode->AsSEConstantNode()) { PrintDebug( "WeakZeroSourceSIVTest has found final_trip_SENode as an " "SEConstantNode with value: " + ToString(final_trip_SENode->AsSEConstantNode()->FoldToSingleValue()) + "\n"); } if (source == final_trip_SENode) { // We have found that peeling the last iteration will break dependency. PrintDebug( "WeakZeroSourceSIVTest has found peeling final iteration will break " "dependency"); distance_entry->dependence_information = DistanceEntry::DependenceInformation::PEEL; distance_entry->peel_last = true; return false; } } else { PrintDebug("WeakZeroSourceSIVTest was unable to build final_trip_SENode"); } // We were unable to prove independence or discern any additional information. // Must assume <=> direction. PrintDebug( "WeakZeroSourceSIVTest was unable to determine any dependence " "information."); distance_entry->direction = DistanceEntry::Directions::ALL; return false; } bool LoopDependenceAnalysis::WeakZeroDestinationSIVTest( SERecurrentNode* source, SENode* destination, SENode* coefficient, DistanceEntry* distance_entry) { PrintDebug("Performing WeakZeroDestinationSIVTest."); // Build an SENode for distance. std::pair subscript_pair = std::make_pair(source, destination); const Loop* subscript_loop = GetLoopForSubscriptPair(subscript_pair); SENode* source_constant_term = GetConstantTerm(subscript_loop, source); SENode* delta = scalar_evolution_.SimplifyExpression( scalar_evolution_.CreateSubtraction(destination, source_constant_term)); // Scalar evolution doesn't perform division, so we must fold to constants and // do it manually. int64_t distance = 0; SEConstantNode* delta_constant = delta->AsSEConstantNode(); SEConstantNode* coefficient_constant = coefficient->AsSEConstantNode(); if (delta_constant && coefficient_constant) { PrintDebug( "WeakZeroDestinationSIVTest folding delta and coefficient to " "constants."); int64_t delta_value = delta_constant->FoldToSingleValue(); int64_t coefficient_value = coefficient_constant->FoldToSingleValue(); // Check if the distance is not integral. if (delta_value % coefficient_value != 0) { PrintDebug( "WeakZeroDestinationSIVTest proved independence through distance not " "being an integer."); distance_entry->dependence_information = DistanceEntry::DependenceInformation::DIRECTION; distance_entry->direction = DistanceEntry::Directions::NONE; return true; } else { distance = delta_value / coefficient_value; PrintDebug( "WeakZeroDestinationSIVTest calculated distance with the following " "values\n" "\tdelta value: " + ToString(delta_value) + "\n\tcoefficient value: " + ToString(coefficient_value) + "\n\tdistance: " + ToString(distance) + "\n"); } } else { PrintDebug( "WeakZeroDestinationSIVTest was unable to fold delta and coefficient " "to constants."); } // If we can prove the distance is outside the bounds we prove independence. SEConstantNode* lower_bound = GetLowerBound(subscript_loop)->AsSEConstantNode(); SEConstantNode* upper_bound = GetUpperBound(subscript_loop)->AsSEConstantNode(); if (lower_bound && upper_bound) { PrintDebug("WeakZeroDestinationSIVTest found bounds as SEConstantNodes."); int64_t lower_bound_value = lower_bound->FoldToSingleValue(); int64_t upper_bound_value = upper_bound->FoldToSingleValue(); if (!IsWithinBounds(llabs(distance), lower_bound_value, upper_bound_value)) { PrintDebug( "WeakZeroDestinationSIVTest proved independence through distance " "escaping the loop bounds."); PrintDebug( "Bound values were as follows\n" "\tlower bound value: " + ToString(lower_bound_value) + "\n\tupper bound value: " + ToString(upper_bound_value) + "\n\tdistance value: " + ToString(distance)); distance_entry->dependence_information = DistanceEntry::DependenceInformation::DISTANCE; distance_entry->direction = DistanceEntry::Directions::NONE; distance_entry->distance = distance; return true; } } else { PrintDebug( "WeakZeroDestinationSIVTest was unable to find lower and upper bound " "as SEConstantNodes."); } // Now we want to see if we can detect to peel the first or last iterations. // We get the FirstTripValue as GetFirstTripInductionNode() + // GetConstantTerm(source) SENode* first_trip_SENode = scalar_evolution_.SimplifyExpression( scalar_evolution_.CreateAddNode(GetFirstTripInductionNode(subscript_loop), GetConstantTerm(subscript_loop, source))); // If destination == FirstTripValue, peel_first. if (first_trip_SENode) { PrintDebug("WeakZeroDestinationSIVTest built first_trip_SENode."); if (first_trip_SENode->AsSEConstantNode()) { PrintDebug( "WeakZeroDestinationSIVTest has found first_trip_SENode as an " "SEConstantNode with value: " + ToString(first_trip_SENode->AsSEConstantNode()->FoldToSingleValue()) + "\n"); } if (destination == first_trip_SENode) { // We have found that peeling the first iteration will break dependency. PrintDebug( "WeakZeroDestinationSIVTest has found peeling first iteration will " "break dependency"); distance_entry->dependence_information = DistanceEntry::DependenceInformation::PEEL; distance_entry->peel_first = true; return false; } } else { PrintDebug( "WeakZeroDestinationSIVTest was unable to build first_trip_SENode"); } // We get the LastTripValue as GetFinalTripInductionNode(coefficient) + // GetConstantTerm(source) SENode* final_trip_SENode = scalar_evolution_.SimplifyExpression(scalar_evolution_.CreateAddNode( GetFinalTripInductionNode(subscript_loop, coefficient), GetConstantTerm(subscript_loop, source))); // If destination == LastTripValue, peel_last. if (final_trip_SENode) { PrintDebug("WeakZeroDestinationSIVTest built final_trip_SENode."); if (final_trip_SENode->AsSEConstantNode()) { PrintDebug( "WeakZeroDestinationSIVTest has found final_trip_SENode as an " "SEConstantNode with value: " + ToString(final_trip_SENode->AsSEConstantNode()->FoldToSingleValue()) + "\n"); } if (destination == final_trip_SENode) { // We have found that peeling the last iteration will break dependency. PrintDebug( "WeakZeroDestinationSIVTest has found peeling final iteration will " "break dependency"); distance_entry->dependence_information = DistanceEntry::DependenceInformation::PEEL; distance_entry->peel_last = true; return false; } } else { PrintDebug( "WeakZeroDestinationSIVTest was unable to build final_trip_SENode"); } // We were unable to prove independence or discern any additional information. // Must assume <=> direction. PrintDebug( "WeakZeroDestinationSIVTest was unable to determine any dependence " "information."); distance_entry->direction = DistanceEntry::Directions::ALL; return false; } bool LoopDependenceAnalysis::WeakCrossingSIVTest( SENode* source, SENode* destination, SENode* coefficient, DistanceEntry* distance_entry) { PrintDebug("Performing WeakCrossingSIVTest."); // We currently can't handle symbolic WeakCrossingSIVTests. If either source // or destination are not SERecurrentNodes we must exit. if (!source->AsSERecurrentNode() || !destination->AsSERecurrentNode()) { PrintDebug( "WeakCrossingSIVTest found source or destination != SERecurrentNode. " "Exiting"); distance_entry->direction = DistanceEntry::Directions::ALL; return false; } // Build an SENode for distance. SENode* offset_delta = scalar_evolution_.SimplifyExpression(scalar_evolution_.CreateSubtraction( destination->AsSERecurrentNode()->GetOffset(), source->AsSERecurrentNode()->GetOffset())); // Scalar evolution doesn't perform division, so we must fold to constants and // do it manually. int64_t distance = 0; SEConstantNode* delta_constant = offset_delta->AsSEConstantNode(); SEConstantNode* coefficient_constant = coefficient->AsSEConstantNode(); if (delta_constant && coefficient_constant) { PrintDebug( "WeakCrossingSIVTest folding offset_delta and coefficient to " "constants."); int64_t delta_value = delta_constant->FoldToSingleValue(); int64_t coefficient_value = coefficient_constant->FoldToSingleValue(); // Check if the distance is not integral or if it has a non-integral part // equal to 1/2. if (delta_value % (2 * coefficient_value) != 0 && static_cast(delta_value % (2 * coefficient_value)) / static_cast(2 * coefficient_value) != 0.5) { PrintDebug( "WeakCrossingSIVTest proved independence through distance escaping " "the loop bounds."); distance_entry->dependence_information = DistanceEntry::DependenceInformation::DIRECTION; distance_entry->direction = DistanceEntry::Directions::NONE; return true; } else { distance = delta_value / (2 * coefficient_value); } if (distance == 0) { PrintDebug("WeakCrossingSIVTest found EQ dependence."); distance_entry->dependence_information = DistanceEntry::DependenceInformation::DISTANCE; distance_entry->direction = DistanceEntry::Directions::EQ; distance_entry->distance = 0; return false; } } else { PrintDebug( "WeakCrossingSIVTest was unable to fold offset_delta and coefficient " "to constants."); } // We were unable to prove independence or discern any additional information. // Must assume <=> direction. PrintDebug( "WeakCrossingSIVTest was unable to determine any dependence " "information."); distance_entry->direction = DistanceEntry::Directions::ALL; return false; } // Perform the GCD test if both, the source and the destination nodes, are in // the form a0*i0 + a1*i1 + ... an*in + c. bool LoopDependenceAnalysis::GCDMIVTest( const std::pair& subscript_pair) { auto source = std::get<0>(subscript_pair); auto destination = std::get<1>(subscript_pair); // Bail out if source/destination is in an unexpected form. if (!IsInCorrectFormForGCDTest(source) || !IsInCorrectFormForGCDTest(destination)) { return false; } auto source_recurrences = GetAllTopLevelRecurrences(source); auto dest_recurrences = GetAllTopLevelRecurrences(destination); // Bail out if all offsets and coefficients aren't constant. if (!AreOffsetsAndCoefficientsConstant(source_recurrences) || !AreOffsetsAndCoefficientsConstant(dest_recurrences)) { return false; } // Calculate the GCD of all coefficients. auto source_constants = GetAllTopLevelConstants(source); int64_t source_constant = CalculateConstantTerm(source_recurrences, source_constants); auto dest_constants = GetAllTopLevelConstants(destination); int64_t destination_constant = CalculateConstantTerm(dest_recurrences, dest_constants); int64_t delta = std::abs(source_constant - destination_constant); int64_t running_gcd = 0; running_gcd = CalculateGCDFromCoefficients(source_recurrences, running_gcd); running_gcd = CalculateGCDFromCoefficients(dest_recurrences, running_gcd); return delta % running_gcd != 0; } using PartitionedSubscripts = std::vector>>; PartitionedSubscripts LoopDependenceAnalysis::PartitionSubscripts( const std::vector& source_subscripts, const std::vector& destination_subscripts) { PartitionedSubscripts partitions{}; auto num_subscripts = source_subscripts.size(); // Create initial partitions with one subscript pair per partition. for (size_t i = 0; i < num_subscripts; ++i) { partitions.push_back({{source_subscripts[i], destination_subscripts[i]}}); } // Iterate over the loops to create all partitions for (auto loop : loops_) { int64_t k = -1; for (size_t j = 0; j < partitions.size(); ++j) { auto& current_partition = partitions[j]; // Does |loop| appear in |current_partition| auto it = std::find_if( current_partition.begin(), current_partition.end(), [loop, this](const std::pair& elem) -> bool { auto source_recurrences = scalar_evolution_.AnalyzeInstruction(std::get<0>(elem)) ->CollectRecurrentNodes(); auto destination_recurrences = scalar_evolution_.AnalyzeInstruction(std::get<1>(elem)) ->CollectRecurrentNodes(); source_recurrences.insert(source_recurrences.end(), destination_recurrences.begin(), destination_recurrences.end()); auto loops_in_pair = CollectLoops(source_recurrences); auto end_it = loops_in_pair.end(); return std::find(loops_in_pair.begin(), end_it, loop) != end_it; }); auto has_loop = it != current_partition.end(); if (has_loop) { if (k == -1) { k = j; } else { // Add |partitions[j]| to |partitions[k]| and discard |partitions[j]| partitions[static_cast(k)].insert(current_partition.begin(), current_partition.end()); current_partition.clear(); } } } } // Remove empty (discarded) partitions partitions.erase( std::remove_if( partitions.begin(), partitions.end(), [](const std::set>& partition) { return partition.empty(); }), partitions.end()); return partitions; } Constraint* LoopDependenceAnalysis::IntersectConstraints( Constraint* constraint_0, Constraint* constraint_1, const SENode* lower_bound, const SENode* upper_bound) { if (constraint_0->AsDependenceNone()) { return constraint_1; } else if (constraint_1->AsDependenceNone()) { return constraint_0; } // Both constraints are distances. Either the same distance or independent. if (constraint_0->AsDependenceDistance() && constraint_1->AsDependenceDistance()) { auto dist_0 = constraint_0->AsDependenceDistance(); auto dist_1 = constraint_1->AsDependenceDistance(); if (*dist_0->GetDistance() == *dist_1->GetDistance()) { return constraint_0; } else { return make_constraint(); } } // Both constraints are points. Either the same point or independent. if (constraint_0->AsDependencePoint() && constraint_1->AsDependencePoint()) { auto point_0 = constraint_0->AsDependencePoint(); auto point_1 = constraint_1->AsDependencePoint(); if (*point_0->GetSource() == *point_1->GetSource() && *point_0->GetDestination() == *point_1->GetDestination()) { return constraint_0; } else { return make_constraint(); } } // Both constraints are lines/distances. if ((constraint_0->AsDependenceDistance() || constraint_0->AsDependenceLine()) && (constraint_1->AsDependenceDistance() || constraint_1->AsDependenceLine())) { auto is_distance_0 = constraint_0->AsDependenceDistance() != nullptr; auto is_distance_1 = constraint_1->AsDependenceDistance() != nullptr; auto a0 = is_distance_0 ? scalar_evolution_.CreateConstant(1) : constraint_0->AsDependenceLine()->GetA(); auto b0 = is_distance_0 ? scalar_evolution_.CreateConstant(-1) : constraint_0->AsDependenceLine()->GetB(); auto c0 = is_distance_0 ? scalar_evolution_.SimplifyExpression( scalar_evolution_.CreateNegation( constraint_0->AsDependenceDistance()->GetDistance())) : constraint_0->AsDependenceLine()->GetC(); auto a1 = is_distance_1 ? scalar_evolution_.CreateConstant(1) : constraint_1->AsDependenceLine()->GetA(); auto b1 = is_distance_1 ? scalar_evolution_.CreateConstant(-1) : constraint_1->AsDependenceLine()->GetB(); auto c1 = is_distance_1 ? scalar_evolution_.SimplifyExpression( scalar_evolution_.CreateNegation( constraint_1->AsDependenceDistance()->GetDistance())) : constraint_1->AsDependenceLine()->GetC(); if (a0->AsSEConstantNode() && b0->AsSEConstantNode() && c0->AsSEConstantNode() && a1->AsSEConstantNode() && b1->AsSEConstantNode() && c1->AsSEConstantNode()) { auto constant_a0 = a0->AsSEConstantNode()->FoldToSingleValue(); auto constant_b0 = b0->AsSEConstantNode()->FoldToSingleValue(); auto constant_c0 = c0->AsSEConstantNode()->FoldToSingleValue(); auto constant_a1 = a1->AsSEConstantNode()->FoldToSingleValue(); auto constant_b1 = b1->AsSEConstantNode()->FoldToSingleValue(); auto constant_c1 = c1->AsSEConstantNode()->FoldToSingleValue(); // a & b can't both be zero, otherwise it wouldn't be line. if (NormalizeAndCompareFractions(constant_a0, constant_b0, constant_a1, constant_b1)) { // Slopes are equal, either parallel lines or the same line. if (constant_b0 == 0 && constant_b1 == 0) { if (NormalizeAndCompareFractions(constant_c0, constant_a0, constant_c1, constant_a1)) { return constraint_0; } return make_constraint(); } else if (NormalizeAndCompareFractions(constant_c0, constant_b0, constant_c1, constant_b1)) { // Same line. return constraint_0; } else { // Parallel lines can't intersect, report independence. return make_constraint(); } } else { // Lines are not parallel, therefore, they must intersect. // Calculate intersection. if (upper_bound->AsSEConstantNode() && lower_bound->AsSEConstantNode()) { auto constant_lower_bound = lower_bound->AsSEConstantNode()->FoldToSingleValue(); auto constant_upper_bound = upper_bound->AsSEConstantNode()->FoldToSingleValue(); auto up = constant_b1 * constant_c0 - constant_b0 * constant_c1; // Both b or both a can't be 0, so down is never 0 // otherwise would have entered the parallel line section. auto down = constant_b1 * constant_a0 - constant_b0 * constant_a1; auto x_coord = up / down; int64_t y_coord = 0; int64_t arg1 = 0; int64_t const_b_to_use = 0; if (constant_b1 != 0) { arg1 = constant_c1 - constant_a1 * x_coord; y_coord = arg1 / constant_b1; const_b_to_use = constant_b1; } else if (constant_b0 != 0) { arg1 = constant_c0 - constant_a0 * x_coord; y_coord = arg1 / constant_b0; const_b_to_use = constant_b0; } if (up % down == 0 && arg1 % const_b_to_use == 0 && // Coordinates are integers. constant_lower_bound <= x_coord && // x_coord is within loop bounds. x_coord <= constant_upper_bound && constant_lower_bound <= y_coord && // y_coord is within loop bounds. y_coord <= constant_upper_bound) { // Lines intersect at integer coordinates. return make_constraint( scalar_evolution_.CreateConstant(x_coord), scalar_evolution_.CreateConstant(y_coord), constraint_0->GetLoop()); } else { return make_constraint(); } } else { // Not constants, bail out. return make_constraint(); } } } else { // Not constants, bail out. return make_constraint(); } } // One constraint is a line/distance and the other is a point. if ((constraint_0->AsDependencePoint() && (constraint_1->AsDependenceLine() || constraint_1->AsDependenceDistance())) || (constraint_1->AsDependencePoint() && (constraint_0->AsDependenceLine() || constraint_0->AsDependenceDistance()))) { auto point_0 = constraint_0->AsDependencePoint() != nullptr; auto point = point_0 ? constraint_0->AsDependencePoint() : constraint_1->AsDependencePoint(); auto line_or_distance = point_0 ? constraint_1 : constraint_0; auto is_distance = line_or_distance->AsDependenceDistance() != nullptr; auto a = is_distance ? scalar_evolution_.CreateConstant(1) : line_or_distance->AsDependenceLine()->GetA(); auto b = is_distance ? scalar_evolution_.CreateConstant(-1) : line_or_distance->AsDependenceLine()->GetB(); auto c = is_distance ? scalar_evolution_.SimplifyExpression( scalar_evolution_.CreateNegation( line_or_distance->AsDependenceDistance()->GetDistance())) : line_or_distance->AsDependenceLine()->GetC(); auto x = point->GetSource(); auto y = point->GetDestination(); if (a->AsSEConstantNode() && b->AsSEConstantNode() && c->AsSEConstantNode() && x->AsSEConstantNode() && y->AsSEConstantNode()) { auto constant_a = a->AsSEConstantNode()->FoldToSingleValue(); auto constant_b = b->AsSEConstantNode()->FoldToSingleValue(); auto constant_c = c->AsSEConstantNode()->FoldToSingleValue(); auto constant_x = x->AsSEConstantNode()->FoldToSingleValue(); auto constant_y = y->AsSEConstantNode()->FoldToSingleValue(); auto left_hand_side = constant_a * constant_x + constant_b * constant_y; if (left_hand_side == constant_c) { // Point is on line, return point return point_0 ? constraint_0 : constraint_1; } else { // Point not on line, report independence (empty constraint). return make_constraint(); } } else { // Not constants, bail out. return make_constraint(); } } return nullptr; } // Propagate constraints function as described in section 5 of Practical // Dependence Testing, Goff, Kennedy, Tseng, 1991. SubscriptPair LoopDependenceAnalysis::PropagateConstraints( const SubscriptPair& subscript_pair, const std::vector& constraints) { SENode* new_first = subscript_pair.first; SENode* new_second = subscript_pair.second; for (auto& constraint : constraints) { // In the paper this is a[k]. We're extracting the coefficient ('a') of a // recurrent expression with respect to the loop 'k'. SENode* coefficient_of_recurrent = scalar_evolution_.GetCoefficientFromRecurrentTerm( new_first, constraint->GetLoop()); // In the paper this is a'[k]. SENode* coefficient_of_recurrent_prime = scalar_evolution_.GetCoefficientFromRecurrentTerm( new_second, constraint->GetLoop()); if (constraint->GetType() == Constraint::Distance) { DependenceDistance* as_distance = constraint->AsDependenceDistance(); // In the paper this is a[k]*d SENode* rhs = scalar_evolution_.CreateMultiplyNode( coefficient_of_recurrent, as_distance->GetDistance()); // In the paper this is a[k] <- 0 SENode* zeroed_coefficient = scalar_evolution_.BuildGraphWithoutRecurrentTerm( new_first, constraint->GetLoop()); // In the paper this is e <- e - a[k]*d. new_first = scalar_evolution_.CreateSubtraction(zeroed_coefficient, rhs); new_first = scalar_evolution_.SimplifyExpression(new_first); // In the paper this is a'[k] - a[k]. SENode* new_child = scalar_evolution_.SimplifyExpression( scalar_evolution_.CreateSubtraction(coefficient_of_recurrent_prime, coefficient_of_recurrent)); // In the paper this is a'[k]'i[k]. SERecurrentNode* prime_recurrent = scalar_evolution_.GetRecurrentTerm(new_second, constraint->GetLoop()); if (!prime_recurrent) continue; // As we hash the nodes we need to create a new node when we update a // child. SENode* new_recurrent = scalar_evolution_.CreateRecurrentExpression( constraint->GetLoop(), prime_recurrent->GetOffset(), new_child); // In the paper this is a'[k] <- a'[k] - a[k]. new_second = scalar_evolution_.UpdateChildNode( new_second, prime_recurrent, new_recurrent); } } new_second = scalar_evolution_.SimplifyExpression(new_second); return std::make_pair(new_first, new_second); } bool LoopDependenceAnalysis::DeltaTest( const std::vector& coupled_subscripts, DistanceVector* dv_entry) { std::vector constraints(loops_.size()); std::vector loop_appeared(loops_.size()); std::generate(std::begin(constraints), std::end(constraints), [this]() { return make_constraint(); }); // Separate SIV and MIV subscripts std::vector siv_subscripts{}; std::vector miv_subscripts{}; for (const auto& subscript_pair : coupled_subscripts) { if (IsSIV(subscript_pair)) { siv_subscripts.push_back(subscript_pair); } else { miv_subscripts.push_back(subscript_pair); } } // Delta Test while (!siv_subscripts.empty()) { std::vector results(siv_subscripts.size()); std::vector current_distances( siv_subscripts.size(), DistanceVector(loops_.size())); // Apply SIV test to all SIV subscripts, report independence if any of them // is independent std::transform( std::begin(siv_subscripts), std::end(siv_subscripts), std::begin(current_distances), std::begin(results), [this](SubscriptPair& p, DistanceVector& d) { return SIVTest(p, &d); }); if (std::accumulate(std::begin(results), std::end(results), false, std::logical_or{})) { return true; } // Derive new constraint vector. std::vector> all_new_constrants{}; for (size_t i = 0; i < siv_subscripts.size(); ++i) { auto loop = GetLoopForSubscriptPair(siv_subscripts[i]); auto loop_id = std::distance(std::begin(loops_), std::find(std::begin(loops_), std::end(loops_), loop)); loop_appeared[loop_id] = true; auto distance_entry = current_distances[i].GetEntries()[loop_id]; if (distance_entry.dependence_information == DistanceEntry::DependenceInformation::DISTANCE) { // Construct a DependenceDistance. auto node = scalar_evolution_.CreateConstant(distance_entry.distance); all_new_constrants.push_back( {make_constraint(node, loop), loop_id}); } else { // Construct a DependenceLine. const auto& subscript_pair = siv_subscripts[i]; SENode* source_node = std::get<0>(subscript_pair); SENode* destination_node = std::get<1>(subscript_pair); int64_t source_induction_count = CountInductionVariables(source_node); int64_t destination_induction_count = CountInductionVariables(destination_node); SENode* a = nullptr; SENode* b = nullptr; SENode* c = nullptr; if (destination_induction_count != 0) { a = destination_node->AsSERecurrentNode()->GetCoefficient(); c = scalar_evolution_.CreateNegation( destination_node->AsSERecurrentNode()->GetOffset()); } else { a = scalar_evolution_.CreateConstant(0); c = scalar_evolution_.CreateNegation(destination_node); } if (source_induction_count != 0) { b = scalar_evolution_.CreateNegation( source_node->AsSERecurrentNode()->GetCoefficient()); c = scalar_evolution_.CreateAddNode( c, source_node->AsSERecurrentNode()->GetOffset()); } else { b = scalar_evolution_.CreateConstant(0); c = scalar_evolution_.CreateAddNode(c, source_node); } a = scalar_evolution_.SimplifyExpression(a); b = scalar_evolution_.SimplifyExpression(b); c = scalar_evolution_.SimplifyExpression(c); all_new_constrants.push_back( {make_constraint(a, b, c, loop), loop_id}); } } // Calculate the intersection between the new and existing constraints. std::vector intersection = constraints; for (const auto& constraint_to_intersect : all_new_constrants) { auto loop_id = std::get<1>(constraint_to_intersect); auto loop = loops_[loop_id]; intersection[loop_id] = IntersectConstraints( intersection[loop_id], std::get<0>(constraint_to_intersect), GetLowerBound(loop), GetUpperBound(loop)); } // Report independence if an empty constraint (DependenceEmpty) is found. auto first_empty = std::find_if(std::begin(intersection), std::end(intersection), [](Constraint* constraint) { return constraint->AsDependenceEmpty() != nullptr; }); if (first_empty != std::end(intersection)) { return true; } std::vector new_siv_subscripts{}; std::vector new_miv_subscripts{}; auto equal = std::equal(std::begin(constraints), std::end(constraints), std::begin(intersection), [](Constraint* a, Constraint* b) { return *a == *b; }); // If any constraints have changed, propagate them into the rest of the // subscripts possibly creating new ZIV/SIV subscripts. if (!equal) { std::vector new_subscripts(miv_subscripts.size()); // Propagate constraints into MIV subscripts std::transform(std::begin(miv_subscripts), std::end(miv_subscripts), std::begin(new_subscripts), [this, &intersection](SubscriptPair& subscript_pair) { return PropagateConstraints(subscript_pair, intersection); }); // If a ZIV subscript is returned, apply test, otherwise, update untested // subscripts. for (auto& subscript : new_subscripts) { if (IsZIV(subscript) && ZIVTest(subscript)) { return true; } else if (IsSIV(subscript)) { new_siv_subscripts.push_back(subscript); } else { new_miv_subscripts.push_back(subscript); } } } // Set new constraints and subscripts to test. std::swap(siv_subscripts, new_siv_subscripts); std::swap(miv_subscripts, new_miv_subscripts); std::swap(constraints, intersection); } // Create the dependence vector from the constraints. for (size_t i = 0; i < loops_.size(); ++i) { // Don't touch entries for loops that weren't tested. if (loop_appeared[i]) { auto current_constraint = constraints[i]; auto& current_distance_entry = (*dv_entry).GetEntries()[i]; if (auto dependence_distance = current_constraint->AsDependenceDistance()) { if (auto constant_node = dependence_distance->GetDistance()->AsSEConstantNode()) { current_distance_entry.dependence_information = DistanceEntry::DependenceInformation::DISTANCE; current_distance_entry.distance = constant_node->FoldToSingleValue(); if (current_distance_entry.distance == 0) { current_distance_entry.direction = DistanceEntry::Directions::EQ; } else if (current_distance_entry.distance < 0) { current_distance_entry.direction = DistanceEntry::Directions::GT; } else { current_distance_entry.direction = DistanceEntry::Directions::LT; } } } else if (auto dependence_point = current_constraint->AsDependencePoint()) { auto source = dependence_point->GetSource(); auto destination = dependence_point->GetDestination(); if (source->AsSEConstantNode() && destination->AsSEConstantNode()) { current_distance_entry = DistanceEntry( source->AsSEConstantNode()->FoldToSingleValue(), destination->AsSEConstantNode()->FoldToSingleValue()); } } } } // Test any remaining MIV subscripts and report independence if found. std::vector results(miv_subscripts.size()); std::transform(std::begin(miv_subscripts), std::end(miv_subscripts), std::begin(results), [this](const SubscriptPair& p) { return GCDMIVTest(p); }); return std::accumulate(std::begin(results), std::end(results), false, std::logical_or{}); } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/loop_dependence.h000066400000000000000000000505621475742701700241370ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_LOOP_DEPENDENCE_H_ #define SOURCE_OPT_LOOP_DEPENDENCE_H_ #include #include #include #include #include #include #include #include #include #include #include "source/opt/instruction.h" #include "source/opt/ir_context.h" #include "source/opt/loop_descriptor.h" #include "source/opt/scalar_analysis.h" namespace spvtools { namespace opt { // Stores information about dependence between a load and a store wrt a single // loop in a loop nest. // DependenceInformation // * UNKNOWN if no dependence information can be gathered or is gathered // for it. // * DIRECTION if a dependence direction could be found, but not a // distance. // * DISTANCE if a dependence distance could be found. // * PEEL if peeling either the first or last iteration will break // dependence between the given load and store. // * IRRELEVANT if it has no effect on the dependence between the given // load and store. // // If peel_first == true, the analysis has found that peeling the first // iteration of this loop will break dependence. // // If peel_last == true, the analysis has found that peeling the last iteration // of this loop will break dependence. class DistanceEntry { public: enum DependenceInformation { UNKNOWN = 0, DIRECTION = 1, DISTANCE = 2, PEEL = 3, IRRELEVANT = 4, POINT = 5 }; enum Directions { NONE = 0, LT = 1, EQ = 2, LE = 3, GT = 4, NE = 5, GE = 6, ALL = 7 }; DependenceInformation dependence_information; Directions direction; int64_t distance; bool peel_first; bool peel_last; int64_t point_x; int64_t point_y; DistanceEntry() : dependence_information(DependenceInformation::UNKNOWN), direction(Directions::ALL), distance(0), peel_first(false), peel_last(false), point_x(0), point_y(0) {} explicit DistanceEntry(Directions direction_) : dependence_information(DependenceInformation::DIRECTION), direction(direction_), distance(0), peel_first(false), peel_last(false), point_x(0), point_y(0) {} DistanceEntry(Directions direction_, int64_t distance_) : dependence_information(DependenceInformation::DISTANCE), direction(direction_), distance(distance_), peel_first(false), peel_last(false), point_x(0), point_y(0) {} DistanceEntry(int64_t x, int64_t y) : dependence_information(DependenceInformation::POINT), direction(Directions::ALL), distance(0), peel_first(false), peel_last(false), point_x(x), point_y(y) {} bool operator==(const DistanceEntry& rhs) const { return direction == rhs.direction && peel_first == rhs.peel_first && peel_last == rhs.peel_last && distance == rhs.distance && point_x == rhs.point_x && point_y == rhs.point_y; } bool operator!=(const DistanceEntry& rhs) const { return !(*this == rhs); } }; // Stores a vector of DistanceEntrys, one per loop in the analysis. // A DistanceVector holds all of the information gathered in a dependence // analysis wrt the loops stored in the LoopDependenceAnalysis performing the // analysis. class DistanceVector { public: explicit DistanceVector(size_t size) : entries(size, DistanceEntry{}) {} explicit DistanceVector(std::vector entries_) : entries(entries_) {} DistanceEntry& GetEntry(size_t index) { return entries[index]; } const DistanceEntry& GetEntry(size_t index) const { return entries[index]; } std::vector& GetEntries() { return entries; } const std::vector& GetEntries() const { return entries; } bool operator==(const DistanceVector& rhs) const { if (entries.size() != rhs.entries.size()) { return false; } for (size_t i = 0; i < entries.size(); ++i) { if (entries[i] != rhs.entries[i]) { return false; } } return true; } bool operator!=(const DistanceVector& rhs) const { return !(*this == rhs); } private: std::vector entries; }; class DependenceLine; class DependenceDistance; class DependencePoint; class DependenceNone; class DependenceEmpty; class Constraint { public: explicit Constraint(const Loop* loop) : loop_(loop) {} enum ConstraintType { Line, Distance, Point, None, Empty }; virtual ConstraintType GetType() const = 0; virtual ~Constraint() {} // Get the loop this constraint belongs to. const Loop* GetLoop() const { return loop_; } bool operator==(const Constraint& other) const; bool operator!=(const Constraint& other) const; // clang-format off #define DeclareCastMethod(target) \ virtual target* As##target() { return nullptr; } \ virtual const target* As##target() const { return nullptr; } DeclareCastMethod(DependenceLine) DeclareCastMethod(DependenceDistance) DeclareCastMethod(DependencePoint) DeclareCastMethod(DependenceNone) DeclareCastMethod(DependenceEmpty) #undef DeclareCastMethod protected: const Loop* loop_; }; // clang-format on class DependenceLine : public Constraint { public: DependenceLine(SENode* a, SENode* b, SENode* c, const Loop* loop) : Constraint(loop), a_(a), b_(b), c_(c) {} ConstraintType GetType() const final { return Line; } DependenceLine* AsDependenceLine() final { return this; } const DependenceLine* AsDependenceLine() const final { return this; } SENode* GetA() const { return a_; } SENode* GetB() const { return b_; } SENode* GetC() const { return c_; } private: SENode* a_; SENode* b_; SENode* c_; }; class DependenceDistance : public Constraint { public: DependenceDistance(SENode* distance, const Loop* loop) : Constraint(loop), distance_(distance) {} ConstraintType GetType() const final { return Distance; } DependenceDistance* AsDependenceDistance() final { return this; } const DependenceDistance* AsDependenceDistance() const final { return this; } SENode* GetDistance() const { return distance_; } private: SENode* distance_; }; class DependencePoint : public Constraint { public: DependencePoint(SENode* source, SENode* destination, const Loop* loop) : Constraint(loop), source_(source), destination_(destination) {} ConstraintType GetType() const final { return Point; } DependencePoint* AsDependencePoint() final { return this; } const DependencePoint* AsDependencePoint() const final { return this; } SENode* GetSource() const { return source_; } SENode* GetDestination() const { return destination_; } private: SENode* source_; SENode* destination_; }; class DependenceNone : public Constraint { public: DependenceNone() : Constraint(nullptr) {} ConstraintType GetType() const final { return None; } DependenceNone* AsDependenceNone() final { return this; } const DependenceNone* AsDependenceNone() const final { return this; } }; class DependenceEmpty : public Constraint { public: DependenceEmpty() : Constraint(nullptr) {} ConstraintType GetType() const final { return Empty; } DependenceEmpty* AsDependenceEmpty() final { return this; } const DependenceEmpty* AsDependenceEmpty() const final { return this; } }; // Provides dependence information between a store instruction and a load // instruction inside the same loop in a loop nest. // // The analysis can only check dependence between stores and loads with regard // to the loop nest it is created with. // // The analysis can output debugging information to a stream. The output // describes the control flow of the analysis and what information it can deduce // at each step. // SetDebugStream and ClearDebugStream are provided for this functionality. // // The dependency algorithm is based on the 1990 Paper // Practical Dependence Testing // Gina Goff, Ken Kennedy, Chau-Wen Tseng // // The algorithm first identifies subscript pairs between the load and store. // Each pair is tested until all have been tested or independence is found. // The number of induction variables in a pair determines which test to perform // on it; // Zero Index Variable (ZIV) is used when no induction variables are present // in the pair. // Single Index Variable (SIV) is used when only one induction variable is // present, but may occur multiple times in the pair. // Multiple Index Variable (MIV) is used when more than one induction variable // is present in the pair. class LoopDependenceAnalysis { public: LoopDependenceAnalysis(IRContext* context, std::vector loops) : context_(context), loops_(loops), scalar_evolution_(context), debug_stream_(nullptr), constraints_{} {} // Finds the dependence between |source| and |destination|. // |source| should be an OpLoad. // |destination| should be an OpStore. // Any direction and distance information found will be stored in // |distance_vector|. // Returns true if independence is found, false otherwise. bool GetDependence(const Instruction* source, const Instruction* destination, DistanceVector* distance_vector); // Returns true if |subscript_pair| represents a Zero Index Variable pair // (ZIV) bool IsZIV(const std::pair& subscript_pair); // Returns true if |subscript_pair| represents a Single Index Variable // (SIV) pair bool IsSIV(const std::pair& subscript_pair); // Returns true if |subscript_pair| represents a Multiple Index Variable // (MIV) pair bool IsMIV(const std::pair& subscript_pair); // Finds the lower bound of |loop| as an SENode* and returns the result. // The lower bound is the starting value of the loops induction variable SENode* GetLowerBound(const Loop* loop); // Finds the upper bound of |loop| as an SENode* and returns the result. // The upper bound is the last value before the loop exit condition is met. SENode* GetUpperBound(const Loop* loop); // Returns true if |value| is between |bound_one| and |bound_two| (inclusive). bool IsWithinBounds(int64_t value, int64_t bound_one, int64_t bound_two); // Finds the bounds of |loop| as upper_bound - lower_bound and returns the // resulting SENode. // If the operations can not be completed a nullptr is returned. SENode* GetTripCount(const Loop* loop); // Returns the SENode* produced by building an SENode from the result of // calling GetInductionInitValue on |loop|. // If the operation can not be completed a nullptr is returned. SENode* GetFirstTripInductionNode(const Loop* loop); // Returns the SENode* produced by building an SENode from the result of // GetFirstTripInductionNode + (GetTripCount - 1) * induction_coefficient. // If the operation can not be completed a nullptr is returned. SENode* GetFinalTripInductionNode(const Loop* loop, SENode* induction_coefficient); // Returns all the distinct loops that appear in |nodes|. std::set CollectLoops( const std::vector& nodes); // Returns all the distinct loops that appear in |source| and |destination|. std::set CollectLoops(SENode* source, SENode* destination); // Returns true if |distance| is provably outside the loop bounds. // |coefficient| must be an SENode representing the coefficient of the // induction variable of |loop|. // This method is able to handle some symbolic cases which IsWithinBounds // can't handle. bool IsProvablyOutsideOfLoopBounds(const Loop* loop, SENode* distance, SENode* coefficient); // Sets the ostream for debug information for the analysis. void SetDebugStream(std::ostream& debug_stream) { debug_stream_ = &debug_stream; } // Clears the stored ostream to stop debug information printing. void ClearDebugStream() { debug_stream_ = nullptr; } // Returns the ScalarEvolutionAnalysis used by this analysis. ScalarEvolutionAnalysis* GetScalarEvolution() { return &scalar_evolution_; } // Creates a new constraint of type |T| and returns the pointer to it. template Constraint* make_constraint(Args&&... args) { constraints_.push_back( std::unique_ptr(new T(std::forward(args)...))); return constraints_.back().get(); } // Subscript partitioning as described in Figure 1 of 'Practical Dependence // Testing' by Gina Goff, Ken Kennedy, and Chau-Wen Tseng from PLDI '91. // Partitions the subscripts into independent subscripts and minimally coupled // sets of subscripts. // Returns the partitioning of subscript pairs. Sets of size 1 indicates an // independent subscript-pair and others indicate coupled sets. using PartitionedSubscripts = std::vector>>; PartitionedSubscripts PartitionSubscripts( const std::vector& source_subscripts, const std::vector& destination_subscripts); // Returns the Loop* matching the loop for |subscript_pair|. // |subscript_pair| must be an SIV pair. const Loop* GetLoopForSubscriptPair( const std::pair& subscript_pair); // Returns the DistanceEntry matching the loop for |subscript_pair|. // |subscript_pair| must be an SIV pair. DistanceEntry* GetDistanceEntryForSubscriptPair( const std::pair& subscript_pair, DistanceVector* distance_vector); // Returns the DistanceEntry matching |loop|. DistanceEntry* GetDistanceEntryForLoop(const Loop* loop, DistanceVector* distance_vector); // Returns a vector of Instruction* which form the subscripts of the array // access defined by the access chain |instruction|. std::vector GetSubscripts(const Instruction* instruction); // Delta test as described in Figure 3 of 'Practical Dependence // Testing' by Gina Goff, Ken Kennedy, and Chau-Wen Tseng from PLDI '91. bool DeltaTest( const std::vector>& coupled_subscripts, DistanceVector* dv_entry); // Constraint propagation as described in Figure 5 of 'Practical Dependence // Testing' by Gina Goff, Ken Kennedy, and Chau-Wen Tseng from PLDI '91. std::pair PropagateConstraints( const std::pair& subscript_pair, const std::vector& constraints); // Constraint intersection as described in Figure 4 of 'Practical Dependence // Testing' by Gina Goff, Ken Kennedy, and Chau-Wen Tseng from PLDI '91. Constraint* IntersectConstraints(Constraint* constraint_0, Constraint* constraint_1, const SENode* lower_bound, const SENode* upper_bound); // Returns true if each loop in |loops| is in a form supported by this // analysis. // A loop is supported if it has a single induction variable and that // induction variable has a step of +1 or -1 per loop iteration. bool CheckSupportedLoops(std::vector loops); // Returns true if |loop| is in a form supported by this analysis. // A loop is supported if it has a single induction variable and that // induction variable has a step of +1 or -1 per loop iteration. bool IsSupportedLoop(const Loop* loop); private: IRContext* context_; // The loop nest we are analysing the dependence of. std::vector loops_; // The ScalarEvolutionAnalysis used by this analysis to store and perform much // of its logic. ScalarEvolutionAnalysis scalar_evolution_; // The ostream debug information for the analysis to print to. std::ostream* debug_stream_; // Stores all the constraints created by the analysis. std::list> constraints_; // Returns true if independence can be proven and false if it can't be proven. bool ZIVTest(const std::pair& subscript_pair); // Analyzes the subscript pair to find an applicable SIV test. // Returns true if independence can be proven and false if it can't be proven. bool SIVTest(const std::pair& subscript_pair, DistanceVector* distance_vector); // Takes the form a*i + c1, a*i + c2 // When c1 and c2 are loop invariant and a is constant // distance = (c1 - c2)/a // < if distance > 0 // direction = = if distance = 0 // > if distance < 0 // Returns true if independence is proven and false if it can't be proven. bool StrongSIVTest(SENode* source, SENode* destination, SENode* coeff, DistanceEntry* distance_entry); // Takes for form a*i + c1, a*i + c2 // where c1 and c2 are loop invariant and a is constant. // c1 and/or c2 contain one or more SEValueUnknown nodes. bool SymbolicStrongSIVTest(SENode* source, SENode* destination, SENode* coefficient, DistanceEntry* distance_entry); // Takes the form a1*i + c1, a2*i + c2 // where a1 = 0 // distance = (c1 - c2) / a2 // Returns true if independence is proven and false if it can't be proven. bool WeakZeroSourceSIVTest(SENode* source, SERecurrentNode* destination, SENode* coefficient, DistanceEntry* distance_entry); // Takes the form a1*i + c1, a2*i + c2 // where a2 = 0 // distance = (c2 - c1) / a1 // Returns true if independence is proven and false if it can't be proven. bool WeakZeroDestinationSIVTest(SERecurrentNode* source, SENode* destination, SENode* coefficient, DistanceEntry* distance_entry); // Takes the form a1*i + c1, a2*i + c2 // where a1 = -a2 // distance = (c2 - c1) / 2*a1 // Returns true if independence is proven and false if it can't be proven. bool WeakCrossingSIVTest(SENode* source, SENode* destination, SENode* coefficient, DistanceEntry* distance_entry); // Uses the def_use_mgr to get the instruction referenced by // SingleWordInOperand(|id|) when called on |instruction|. Instruction* GetOperandDefinition(const Instruction* instruction, int id); // Perform the GCD test if both, the source and the destination nodes, are in // the form a0*i0 + a1*i1 + ... an*in + c. bool GCDMIVTest(const std::pair& subscript_pair); // Finds the number of induction variables in |node|. // Returns -1 on failure. int64_t CountInductionVariables(SENode* node); // Finds the number of induction variables shared between |source| and // |destination|. // Returns -1 on failure. int64_t CountInductionVariables(SENode* source, SENode* destination); // Takes the offset from the induction variable and subtracts the lower bound // from it to get the constant term added to the induction. // Returns the resuting constant term, or nullptr if it could not be produced. SENode* GetConstantTerm(const Loop* loop, SERecurrentNode* induction); // Marks all the distance entries in |distance_vector| that were relate to // loops in |loops_| but were not used in any subscripts as irrelevant to the // to the dependence test. void MarkUnsusedDistanceEntriesAsIrrelevant(const Instruction* source, const Instruction* destination, DistanceVector* distance_vector); // Converts |value| to a std::string and returns the result. // This is required because Android does not compile std::to_string. template std::string ToString(valueT value) { std::ostringstream string_stream; string_stream << value; return string_stream.str(); } // Prints |debug_msg| and "\n" to the ostream pointed to by |debug_stream_|. // Won't print anything if |debug_stream_| is nullptr. void PrintDebug(std::string debug_msg); }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_LOOP_DEPENDENCE_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/loop_dependence_helpers.cpp000066400000000000000000000443621475742701700262150ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include #include #include #include "source/opt/basic_block.h" #include "source/opt/instruction.h" #include "source/opt/loop_dependence.h" #include "source/opt/scalar_analysis_nodes.h" namespace spvtools { namespace opt { bool LoopDependenceAnalysis::IsZIV( const std::pair& subscript_pair) { return CountInductionVariables(subscript_pair.first, subscript_pair.second) == 0; } bool LoopDependenceAnalysis::IsSIV( const std::pair& subscript_pair) { return CountInductionVariables(subscript_pair.first, subscript_pair.second) == 1; } bool LoopDependenceAnalysis::IsMIV( const std::pair& subscript_pair) { return CountInductionVariables(subscript_pair.first, subscript_pair.second) > 1; } SENode* LoopDependenceAnalysis::GetLowerBound(const Loop* loop) { Instruction* cond_inst = loop->GetConditionInst(); if (!cond_inst) { return nullptr; } Instruction* lower_inst = GetOperandDefinition(cond_inst, 0); switch (cond_inst->opcode()) { case spv::Op::OpULessThan: case spv::Op::OpSLessThan: case spv::Op::OpULessThanEqual: case spv::Op::OpSLessThanEqual: case spv::Op::OpUGreaterThan: case spv::Op::OpSGreaterThan: case spv::Op::OpUGreaterThanEqual: case spv::Op::OpSGreaterThanEqual: { // If we have a phi we are looking at the induction variable. We look // through the phi to the initial value of the phi upon entering the loop. if (lower_inst->opcode() == spv::Op::OpPhi) { lower_inst = GetOperandDefinition(lower_inst, 0); // We don't handle looking through multiple phis. if (lower_inst->opcode() == spv::Op::OpPhi) { return nullptr; } } return scalar_evolution_.SimplifyExpression( scalar_evolution_.AnalyzeInstruction(lower_inst)); } default: return nullptr; } } SENode* LoopDependenceAnalysis::GetUpperBound(const Loop* loop) { Instruction* cond_inst = loop->GetConditionInst(); if (!cond_inst) { return nullptr; } Instruction* upper_inst = GetOperandDefinition(cond_inst, 1); switch (cond_inst->opcode()) { case spv::Op::OpULessThan: case spv::Op::OpSLessThan: { // When we have a < condition we must subtract 1 from the analyzed upper // instruction. SENode* upper_bound = scalar_evolution_.SimplifyExpression( scalar_evolution_.CreateSubtraction( scalar_evolution_.AnalyzeInstruction(upper_inst), scalar_evolution_.CreateConstant(1))); return upper_bound; } case spv::Op::OpUGreaterThan: case spv::Op::OpSGreaterThan: { // When we have a > condition we must add 1 to the analyzed upper // instruction. SENode* upper_bound = scalar_evolution_.SimplifyExpression(scalar_evolution_.CreateAddNode( scalar_evolution_.AnalyzeInstruction(upper_inst), scalar_evolution_.CreateConstant(1))); return upper_bound; } case spv::Op::OpULessThanEqual: case spv::Op::OpSLessThanEqual: case spv::Op::OpUGreaterThanEqual: case spv::Op::OpSGreaterThanEqual: { // We don't need to modify the results of analyzing when we have <= or >=. SENode* upper_bound = scalar_evolution_.SimplifyExpression( scalar_evolution_.AnalyzeInstruction(upper_inst)); return upper_bound; } default: return nullptr; } } bool LoopDependenceAnalysis::IsWithinBounds(int64_t value, int64_t bound_one, int64_t bound_two) { if (bound_one < bound_two) { // If |bound_one| is the lower bound. return (value >= bound_one && value <= bound_two); } else if (bound_one > bound_two) { // If |bound_two| is the lower bound. return (value >= bound_two && value <= bound_one); } else { // Both bounds have the same value. return value == bound_one; } } bool LoopDependenceAnalysis::IsProvablyOutsideOfLoopBounds( const Loop* loop, SENode* distance, SENode* coefficient) { // We test to see if we can reduce the coefficient to an integral constant. SEConstantNode* coefficient_constant = coefficient->AsSEConstantNode(); if (!coefficient_constant) { PrintDebug( "IsProvablyOutsideOfLoopBounds could not reduce coefficient to a " "SEConstantNode so must exit."); return false; } SENode* lower_bound = GetLowerBound(loop); SENode* upper_bound = GetUpperBound(loop); if (!lower_bound || !upper_bound) { PrintDebug( "IsProvablyOutsideOfLoopBounds could not get both the lower and upper " "bounds so must exit."); return false; } // If the coefficient is positive we calculate bounds as upper - lower // If the coefficient is negative we calculate bounds as lower - upper SENode* bounds = nullptr; if (coefficient_constant->FoldToSingleValue() >= 0) { PrintDebug( "IsProvablyOutsideOfLoopBounds found coefficient >= 0.\n" "Using bounds as upper - lower."); bounds = scalar_evolution_.SimplifyExpression( scalar_evolution_.CreateSubtraction(upper_bound, lower_bound)); } else { PrintDebug( "IsProvablyOutsideOfLoopBounds found coefficient < 0.\n" "Using bounds as lower - upper."); bounds = scalar_evolution_.SimplifyExpression( scalar_evolution_.CreateSubtraction(lower_bound, upper_bound)); } // We can attempt to deal with symbolic cases by subtracting |distance| and // the bound nodes. If we can subtract, simplify and produce a SEConstantNode // we can produce some information. SEConstantNode* distance_minus_bounds = scalar_evolution_ .SimplifyExpression( scalar_evolution_.CreateSubtraction(distance, bounds)) ->AsSEConstantNode(); if (distance_minus_bounds) { PrintDebug( "IsProvablyOutsideOfLoopBounds found distance - bounds as a " "SEConstantNode with value " + ToString(distance_minus_bounds->FoldToSingleValue())); // If distance - bounds > 0 we prove the distance is outwith the loop // bounds. if (distance_minus_bounds->FoldToSingleValue() > 0) { PrintDebug( "IsProvablyOutsideOfLoopBounds found distance escaped the loop " "bounds."); return true; } } return false; } const Loop* LoopDependenceAnalysis::GetLoopForSubscriptPair( const std::pair& subscript_pair) { // Collect all the SERecurrentNodes. std::vector source_nodes = std::get<0>(subscript_pair)->CollectRecurrentNodes(); std::vector destination_nodes = std::get<1>(subscript_pair)->CollectRecurrentNodes(); // Collect all the loops stored by the SERecurrentNodes. std::unordered_set loops{}; for (auto source_nodes_it = source_nodes.begin(); source_nodes_it != source_nodes.end(); ++source_nodes_it) { loops.insert((*source_nodes_it)->GetLoop()); } for (auto destination_nodes_it = destination_nodes.begin(); destination_nodes_it != destination_nodes.end(); ++destination_nodes_it) { loops.insert((*destination_nodes_it)->GetLoop()); } // If we didn't find 1 loop |subscript_pair| is a subscript over multiple or 0 // loops. We don't handle this so return nullptr. if (loops.size() != 1) { PrintDebug("GetLoopForSubscriptPair found loops.size() != 1."); return nullptr; } return *loops.begin(); } DistanceEntry* LoopDependenceAnalysis::GetDistanceEntryForLoop( const Loop* loop, DistanceVector* distance_vector) { if (!loop) { return nullptr; } DistanceEntry* distance_entry = nullptr; for (size_t loop_index = 0; loop_index < loops_.size(); ++loop_index) { if (loop == loops_[loop_index]) { distance_entry = &(distance_vector->GetEntries()[loop_index]); break; } } return distance_entry; } DistanceEntry* LoopDependenceAnalysis::GetDistanceEntryForSubscriptPair( const std::pair& subscript_pair, DistanceVector* distance_vector) { const Loop* loop = GetLoopForSubscriptPair(subscript_pair); return GetDistanceEntryForLoop(loop, distance_vector); } SENode* LoopDependenceAnalysis::GetTripCount(const Loop* loop) { BasicBlock* condition_block = loop->FindConditionBlock(); if (!condition_block) { return nullptr; } Instruction* induction_instr = loop->FindConditionVariable(condition_block); if (!induction_instr) { return nullptr; } Instruction* cond_instr = loop->GetConditionInst(); if (!cond_instr) { return nullptr; } size_t iteration_count = 0; // We have to check the instruction type here. If the condition instruction // isn't a supported type we can't calculate the trip count. if (loop->IsSupportedCondition(cond_instr->opcode())) { if (loop->FindNumberOfIterations(induction_instr, &*condition_block->tail(), &iteration_count)) { return scalar_evolution_.CreateConstant( static_cast(iteration_count)); } } return nullptr; } SENode* LoopDependenceAnalysis::GetFirstTripInductionNode(const Loop* loop) { BasicBlock* condition_block = loop->FindConditionBlock(); if (!condition_block) { return nullptr; } Instruction* induction_instr = loop->FindConditionVariable(condition_block); if (!induction_instr) { return nullptr; } int64_t induction_initial_value = 0; if (!loop->GetInductionInitValue(induction_instr, &induction_initial_value)) { return nullptr; } SENode* induction_init_SENode = scalar_evolution_.SimplifyExpression( scalar_evolution_.CreateConstant(induction_initial_value)); return induction_init_SENode; } SENode* LoopDependenceAnalysis::GetFinalTripInductionNode( const Loop* loop, SENode* induction_coefficient) { SENode* first_trip_induction_node = GetFirstTripInductionNode(loop); if (!first_trip_induction_node) { return nullptr; } // Get trip_count as GetTripCount - 1 // This is because the induction variable is not stepped on the first // iteration of the loop SENode* trip_count = scalar_evolution_.SimplifyExpression(scalar_evolution_.CreateSubtraction( GetTripCount(loop), scalar_evolution_.CreateConstant(1))); // Return first_trip_induction_node + trip_count * induction_coefficient return scalar_evolution_.SimplifyExpression(scalar_evolution_.CreateAddNode( first_trip_induction_node, scalar_evolution_.CreateMultiplyNode(trip_count, induction_coefficient))); } std::set LoopDependenceAnalysis::CollectLoops( const std::vector& recurrent_nodes) { // We don't handle loops with more than one induction variable. Therefore we // can identify the number of induction variables by collecting all of the // loops the collected recurrent nodes belong to. std::set loops{}; for (auto recurrent_nodes_it = recurrent_nodes.begin(); recurrent_nodes_it != recurrent_nodes.end(); ++recurrent_nodes_it) { loops.insert((*recurrent_nodes_it)->GetLoop()); } return loops; } int64_t LoopDependenceAnalysis::CountInductionVariables(SENode* node) { if (!node) { return -1; } std::vector recurrent_nodes = node->CollectRecurrentNodes(); // We don't handle loops with more than one induction variable. Therefore we // can identify the number of induction variables by collecting all of the // loops the collected recurrent nodes belong to. std::set loops = CollectLoops(recurrent_nodes); return static_cast(loops.size()); } std::set LoopDependenceAnalysis::CollectLoops( SENode* source, SENode* destination) { if (!source || !destination) { return std::set{}; } std::vector source_nodes = source->CollectRecurrentNodes(); std::vector destination_nodes = destination->CollectRecurrentNodes(); std::set loops = CollectLoops(source_nodes); std::set destination_loops = CollectLoops(destination_nodes); loops.insert(std::begin(destination_loops), std::end(destination_loops)); return loops; } int64_t LoopDependenceAnalysis::CountInductionVariables(SENode* source, SENode* destination) { if (!source || !destination) { return -1; } std::set loops = CollectLoops(source, destination); return static_cast(loops.size()); } Instruction* LoopDependenceAnalysis::GetOperandDefinition( const Instruction* instruction, int id) { return context_->get_def_use_mgr()->GetDef( instruction->GetSingleWordInOperand(id)); } std::vector LoopDependenceAnalysis::GetSubscripts( const Instruction* instruction) { Instruction* access_chain = GetOperandDefinition(instruction, 0); std::vector subscripts; for (auto i = 1u; i < access_chain->NumInOperandWords(); ++i) { subscripts.push_back(GetOperandDefinition(access_chain, i)); } return subscripts; } SENode* LoopDependenceAnalysis::GetConstantTerm(const Loop* loop, SERecurrentNode* induction) { SENode* offset = induction->GetOffset(); SENode* lower_bound = GetLowerBound(loop); if (!offset || !lower_bound) { return nullptr; } SENode* constant_term = scalar_evolution_.SimplifyExpression( scalar_evolution_.CreateSubtraction(offset, lower_bound)); return constant_term; } bool LoopDependenceAnalysis::CheckSupportedLoops( std::vector loops) { for (auto loop : loops) { if (!IsSupportedLoop(loop)) { return false; } } return true; } void LoopDependenceAnalysis::MarkUnsusedDistanceEntriesAsIrrelevant( const Instruction* source, const Instruction* destination, DistanceVector* distance_vector) { std::vector source_subscripts = GetSubscripts(source); std::vector destination_subscripts = GetSubscripts(destination); std::set used_loops{}; for (Instruction* source_inst : source_subscripts) { SENode* source_node = scalar_evolution_.SimplifyExpression( scalar_evolution_.AnalyzeInstruction(source_inst)); std::vector recurrent_nodes = source_node->CollectRecurrentNodes(); for (SERecurrentNode* recurrent_node : recurrent_nodes) { used_loops.insert(recurrent_node->GetLoop()); } } for (Instruction* destination_inst : destination_subscripts) { SENode* destination_node = scalar_evolution_.SimplifyExpression( scalar_evolution_.AnalyzeInstruction(destination_inst)); std::vector recurrent_nodes = destination_node->CollectRecurrentNodes(); for (SERecurrentNode* recurrent_node : recurrent_nodes) { used_loops.insert(recurrent_node->GetLoop()); } } for (size_t i = 0; i < loops_.size(); ++i) { if (used_loops.find(loops_[i]) == used_loops.end()) { distance_vector->GetEntries()[i].dependence_information = DistanceEntry::DependenceInformation::IRRELEVANT; } } } bool LoopDependenceAnalysis::IsSupportedLoop(const Loop* loop) { std::vector inductions{}; loop->GetInductionVariables(inductions); if (inductions.size() != 1) { return false; } Instruction* induction = inductions[0]; SENode* induction_node = scalar_evolution_.SimplifyExpression( scalar_evolution_.AnalyzeInstruction(induction)); if (!induction_node->AsSERecurrentNode()) { return false; } SENode* induction_step = induction_node->AsSERecurrentNode()->GetCoefficient(); if (!induction_step->AsSEConstantNode()) { return false; } if (!(induction_step->AsSEConstantNode()->FoldToSingleValue() == 1 || induction_step->AsSEConstantNode()->FoldToSingleValue() == -1)) { return false; } return true; } void LoopDependenceAnalysis::PrintDebug(std::string debug_msg) { if (debug_stream_) { (*debug_stream_) << debug_msg << "\n"; } } bool Constraint::operator==(const Constraint& other) const { // A distance of |d| is equivalent to a line |x - y = -d| if ((GetType() == ConstraintType::Distance && other.GetType() == ConstraintType::Line) || (GetType() == ConstraintType::Line && other.GetType() == ConstraintType::Distance)) { auto is_distance = AsDependenceLine() != nullptr; auto as_distance = is_distance ? AsDependenceDistance() : other.AsDependenceDistance(); auto distance = as_distance->GetDistance(); auto line = other.AsDependenceLine(); auto scalar_evolution = distance->GetParentAnalysis(); auto neg_distance = scalar_evolution->SimplifyExpression( scalar_evolution->CreateNegation(distance)); return *scalar_evolution->CreateConstant(1) == *line->GetA() && *scalar_evolution->CreateConstant(-1) == *line->GetB() && *neg_distance == *line->GetC(); } if (GetType() != other.GetType()) { return false; } if (AsDependenceDistance()) { return *AsDependenceDistance()->GetDistance() == *other.AsDependenceDistance()->GetDistance(); } if (AsDependenceLine()) { auto this_line = AsDependenceLine(); auto other_line = other.AsDependenceLine(); return *this_line->GetA() == *other_line->GetA() && *this_line->GetB() == *other_line->GetB() && *this_line->GetC() == *other_line->GetC(); } if (AsDependencePoint()) { auto this_point = AsDependencePoint(); auto other_point = other.AsDependencePoint(); return *this_point->GetSource() == *other_point->GetSource() && *this_point->GetDestination() == *other_point->GetDestination(); } return true; } bool Constraint::operator!=(const Constraint& other) const { return !(*this == other); } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/loop_descriptor.cpp000066400000000000000000001012621475742701700245500ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/loop_descriptor.h" #include #include #include #include #include #include "source/opt/cfg.h" #include "source/opt/constants.h" #include "source/opt/dominator_tree.h" #include "source/opt/ir_context.h" #include "source/opt/iterator.h" #include "source/opt/tree_iterator.h" #include "source/util/make_unique.h" namespace spvtools { namespace opt { // Takes in a phi instruction |induction| and the loop |header| and returns the // step operation of the loop. Instruction* Loop::GetInductionStepOperation( const Instruction* induction) const { // Induction must be a phi instruction. assert(induction->opcode() == spv::Op::OpPhi); Instruction* step = nullptr; analysis::DefUseManager* def_use_manager = context_->get_def_use_mgr(); // Traverse the incoming operands of the phi instruction. for (uint32_t operand_id = 1; operand_id < induction->NumInOperands(); operand_id += 2) { // Incoming edge. BasicBlock* incoming_block = context_->cfg()->block(induction->GetSingleWordInOperand(operand_id)); // Check if the block is dominated by header, and thus coming from within // the loop. if (IsInsideLoop(incoming_block)) { step = def_use_manager->GetDef( induction->GetSingleWordInOperand(operand_id - 1)); break; } } if (!step || !IsSupportedStepOp(step->opcode())) { return nullptr; } // The induction variable which binds the loop must only be modified once. uint32_t lhs = step->GetSingleWordInOperand(0); uint32_t rhs = step->GetSingleWordInOperand(1); // One of the left hand side or right hand side of the step instruction must // be the induction phi and the other must be an OpConstant. if (lhs != induction->result_id() && rhs != induction->result_id()) { return nullptr; } if (def_use_manager->GetDef(lhs)->opcode() != spv::Op::OpConstant && def_use_manager->GetDef(rhs)->opcode() != spv::Op::OpConstant) { return nullptr; } return step; } // Returns true if the |step| operation is an induction variable step operation // which is currently handled. bool Loop::IsSupportedStepOp(spv::Op step) const { switch (step) { case spv::Op::OpISub: case spv::Op::OpIAdd: return true; default: return false; } } bool Loop::IsSupportedCondition(spv::Op condition) const { switch (condition) { // < case spv::Op::OpULessThan: case spv::Op::OpSLessThan: // > case spv::Op::OpUGreaterThan: case spv::Op::OpSGreaterThan: // >= case spv::Op::OpSGreaterThanEqual: case spv::Op::OpUGreaterThanEqual: // <= case spv::Op::OpSLessThanEqual: case spv::Op::OpULessThanEqual: return true; default: return false; } } int64_t Loop::GetResidualConditionValue(spv::Op condition, int64_t initial_value, int64_t step_value, size_t number_of_iterations, size_t factor) { int64_t remainder = initial_value + (number_of_iterations % factor) * step_value; // We subtract or add one as the above formula calculates the remainder if the // loop where just less than or greater than. Adding or subtracting one should // give a functionally equivalent value. switch (condition) { case spv::Op::OpSGreaterThanEqual: case spv::Op::OpUGreaterThanEqual: { remainder -= 1; break; } case spv::Op::OpSLessThanEqual: case spv::Op::OpULessThanEqual: { remainder += 1; break; } default: break; } return remainder; } Instruction* Loop::GetConditionInst() const { BasicBlock* condition_block = FindConditionBlock(); if (!condition_block) { return nullptr; } Instruction* branch_conditional = &*condition_block->tail(); if (!branch_conditional || branch_conditional->opcode() != spv::Op::OpBranchConditional) { return nullptr; } Instruction* condition_inst = context_->get_def_use_mgr()->GetDef( branch_conditional->GetSingleWordInOperand(0)); if (IsSupportedCondition(condition_inst->opcode())) { return condition_inst; } return nullptr; } // Extract the initial value from the |induction| OpPhi instruction and store it // in |value|. If the function couldn't find the initial value of |induction| // return false. bool Loop::GetInductionInitValue(const Instruction* induction, int64_t* value) const { Instruction* constant_instruction = nullptr; analysis::DefUseManager* def_use_manager = context_->get_def_use_mgr(); for (uint32_t operand_id = 0; operand_id < induction->NumInOperands(); operand_id += 2) { BasicBlock* bb = context_->cfg()->block( induction->GetSingleWordInOperand(operand_id + 1)); if (!IsInsideLoop(bb)) { constant_instruction = def_use_manager->GetDef( induction->GetSingleWordInOperand(operand_id)); } } if (!constant_instruction) return false; const analysis::Constant* constant = context_->get_constant_mgr()->FindDeclaredConstant( constant_instruction->result_id()); if (!constant) return false; if (value) { const analysis::Integer* type = constant->type()->AsInteger(); if (!type) { return false; } *value = type->IsSigned() ? constant->GetSignExtendedValue() : constant->GetZeroExtendedValue(); } return true; } Loop::Loop(IRContext* context, DominatorAnalysis* dom_analysis, BasicBlock* header, BasicBlock* continue_target, BasicBlock* merge_target) : context_(context), loop_header_(header), loop_continue_(continue_target), loop_merge_(merge_target), loop_preheader_(nullptr), parent_(nullptr), loop_is_marked_for_removal_(false) { assert(context); assert(dom_analysis); loop_preheader_ = FindLoopPreheader(dom_analysis); loop_latch_ = FindLatchBlock(); } BasicBlock* Loop::FindLoopPreheader(DominatorAnalysis* dom_analysis) { CFG* cfg = context_->cfg(); DominatorTree& dom_tree = dom_analysis->GetDomTree(); DominatorTreeNode* header_node = dom_tree.GetTreeNode(loop_header_); // The loop predecessor. BasicBlock* loop_pred = nullptr; auto header_pred = cfg->preds(loop_header_->id()); for (uint32_t p_id : header_pred) { DominatorTreeNode* node = dom_tree.GetTreeNode(p_id); if (node && !dom_tree.Dominates(header_node, node)) { // The predecessor is not part of the loop, so potential loop preheader. if (loop_pred && node->bb_ != loop_pred) { // If we saw 2 distinct predecessors that are outside the loop, we don't // have a loop preheader. return nullptr; } loop_pred = node->bb_; } } // Safe guard against invalid code, SPIR-V spec forbids loop with the entry // node as header. assert(loop_pred && "The header node is the entry block ?"); // So we have a unique basic block that can enter this loop. // If this loop is the unique successor of this block, then it is a loop // preheader. bool is_preheader = true; uint32_t loop_header_id = loop_header_->id(); const auto* const_loop_pred = loop_pred; const_loop_pred->ForEachSuccessorLabel( [&is_preheader, loop_header_id](const uint32_t id) { if (id != loop_header_id) is_preheader = false; }); if (is_preheader) return loop_pred; return nullptr; } bool Loop::IsInsideLoop(Instruction* inst) const { const BasicBlock* parent_block = context_->get_instr_block(inst); if (!parent_block) return false; return IsInsideLoop(parent_block); } bool Loop::IsBasicBlockInLoopSlow(const BasicBlock* bb) { assert(bb->GetParent() && "The basic block does not belong to a function"); DominatorAnalysis* dom_analysis = context_->GetDominatorAnalysis(bb->GetParent()); if (dom_analysis->IsReachable(bb) && !dom_analysis->Dominates(GetHeaderBlock(), bb)) return false; return true; } BasicBlock* Loop::GetOrCreatePreHeaderBlock() { if (loop_preheader_) return loop_preheader_; CFG* cfg = context_->cfg(); loop_header_ = cfg->SplitLoopHeader(loop_header_); return loop_preheader_; } void Loop::SetContinueBlock(BasicBlock* continue_block) { assert(IsInsideLoop(continue_block)); loop_continue_ = continue_block; } void Loop::SetLatchBlock(BasicBlock* latch) { #ifndef NDEBUG assert(latch->GetParent() && "The basic block does not belong to a function"); const auto* const_latch = latch; const_latch->ForEachSuccessorLabel([this](uint32_t id) { assert((!IsInsideLoop(id) || id == GetHeaderBlock()->id()) && "A predecessor of the continue block does not belong to the loop"); }); #endif // NDEBUG assert(IsInsideLoop(latch) && "The continue block is not in the loop"); SetLatchBlockImpl(latch); } void Loop::SetMergeBlock(BasicBlock* merge) { #ifndef NDEBUG assert(merge->GetParent() && "The basic block does not belong to a function"); #endif // NDEBUG assert(!IsInsideLoop(merge) && "The merge block is in the loop"); SetMergeBlockImpl(merge); if (GetHeaderBlock()->GetLoopMergeInst()) { UpdateLoopMergeInst(); } } void Loop::SetPreHeaderBlock(BasicBlock* preheader) { if (preheader) { assert(!IsInsideLoop(preheader) && "The preheader block is in the loop"); assert(preheader->tail()->opcode() == spv::Op::OpBranch && "The preheader block does not unconditionally branch to the header " "block"); assert(preheader->tail()->GetSingleWordOperand(0) == GetHeaderBlock()->id() && "The preheader block does not unconditionally branch to the header " "block"); } loop_preheader_ = preheader; } BasicBlock* Loop::FindLatchBlock() { CFG* cfg = context_->cfg(); DominatorAnalysis* dominator_analysis = context_->GetDominatorAnalysis(loop_header_->GetParent()); // Look at the predecessors of the loop header to find a predecessor block // which is dominated by the loop continue target. There should only be one // block which meets this criteria and this is the latch block, as per the // SPIR-V spec. for (uint32_t block_id : cfg->preds(loop_header_->id())) { if (dominator_analysis->Dominates(loop_continue_->id(), block_id)) { return cfg->block(block_id); } } assert( false && "Every loop should have a latch block dominated by the continue target"); return nullptr; } void Loop::GetExitBlocks(std::unordered_set* exit_blocks) const { CFG* cfg = context_->cfg(); exit_blocks->clear(); for (uint32_t bb_id : GetBlocks()) { const BasicBlock* bb = cfg->block(bb_id); bb->ForEachSuccessorLabel([exit_blocks, this](uint32_t succ) { if (!IsInsideLoop(succ)) { exit_blocks->insert(succ); } }); } } void Loop::GetMergingBlocks( std::unordered_set* merging_blocks) const { assert(GetMergeBlock() && "This loop is not structured"); CFG* cfg = context_->cfg(); merging_blocks->clear(); std::stack to_visit; to_visit.push(GetMergeBlock()); while (!to_visit.empty()) { const BasicBlock* bb = to_visit.top(); to_visit.pop(); merging_blocks->insert(bb->id()); for (uint32_t pred_id : cfg->preds(bb->id())) { if (!IsInsideLoop(pred_id) && !merging_blocks->count(pred_id)) { to_visit.push(cfg->block(pred_id)); } } } } namespace { inline bool IsBasicBlockSafeToClone(IRContext* context, BasicBlock* bb) { for (Instruction& inst : *bb) { if (!inst.IsBranch() && !context->IsCombinatorInstruction(&inst)) return false; } return true; } } // namespace bool Loop::IsSafeToClone() const { CFG& cfg = *context_->cfg(); for (uint32_t bb_id : GetBlocks()) { BasicBlock* bb = cfg.block(bb_id); assert(bb); if (!IsBasicBlockSafeToClone(context_, bb)) return false; } // Look at the merge construct. if (GetHeaderBlock()->GetLoopMergeInst()) { std::unordered_set blocks; GetMergingBlocks(&blocks); blocks.erase(GetMergeBlock()->id()); for (uint32_t bb_id : blocks) { BasicBlock* bb = cfg.block(bb_id); assert(bb); if (!IsBasicBlockSafeToClone(context_, bb)) return false; } } return true; } bool Loop::IsLCSSA() const { CFG* cfg = context_->cfg(); analysis::DefUseManager* def_use_mgr = context_->get_def_use_mgr(); std::unordered_set exit_blocks; GetExitBlocks(&exit_blocks); // Declare ir_context so we can capture context_ in the below lambda IRContext* ir_context = context_; for (uint32_t bb_id : GetBlocks()) { for (Instruction& insn : *cfg->block(bb_id)) { // All uses must be either: // - In the loop; // - In an exit block and in a phi instruction. if (!def_use_mgr->WhileEachUser( &insn, [&exit_blocks, ir_context, this](Instruction* use) -> bool { BasicBlock* parent = ir_context->get_instr_block(use); assert(parent && "Invalid analysis"); if (IsInsideLoop(parent)) return true; if (use->opcode() != spv::Op::OpPhi) return false; return exit_blocks.count(parent->id()); })) return false; } } return true; } bool Loop::ShouldHoistInstruction(const Instruction& inst) const { return inst.IsOpcodeCodeMotionSafe() && AreAllOperandsOutsideLoop(inst) && (!inst.IsLoad() || inst.IsReadOnlyLoad()); } bool Loop::AreAllOperandsOutsideLoop(const Instruction& inst) const { analysis::DefUseManager* def_use_mgr = GetContext()->get_def_use_mgr(); const std::function operand_outside_loop = [this, &def_use_mgr](const uint32_t* id) { return !this->IsInsideLoop(def_use_mgr->GetDef(*id)); }; return inst.WhileEachInId(operand_outside_loop); } void Loop::ComputeLoopStructuredOrder( std::vector* ordered_loop_blocks, bool include_pre_header, bool include_merge) const { CFG& cfg = *context_->cfg(); // Reserve the memory: all blocks in the loop + extra if needed. ordered_loop_blocks->reserve(GetBlocks().size() + include_pre_header + include_merge); if (include_pre_header && GetPreHeaderBlock()) ordered_loop_blocks->push_back(loop_preheader_); bool is_shader = context_->get_feature_mgr()->HasCapability(spv::Capability::Shader); if (!is_shader) { cfg.ForEachBlockInReversePostOrder( loop_header_, [ordered_loop_blocks, this](BasicBlock* bb) { if (IsInsideLoop(bb)) ordered_loop_blocks->push_back(bb); }); } else { // If this is a shader, it is possible that there are unreachable merge and // continue blocks that must be copied to retain the structured order. // The structured order will include these. std::list order; cfg.ComputeStructuredOrder(loop_header_->GetParent(), loop_header_, loop_merge_, &order); for (BasicBlock* bb : order) { if (bb == GetMergeBlock()) { break; } ordered_loop_blocks->push_back(bb); } } if (include_merge && GetMergeBlock()) ordered_loop_blocks->push_back(loop_merge_); } LoopDescriptor::LoopDescriptor(IRContext* context, const Function* f) : loops_(), placeholder_top_loop_(nullptr) { PopulateList(context, f); } LoopDescriptor::~LoopDescriptor() { ClearLoops(); } void LoopDescriptor::PopulateList(IRContext* context, const Function* f) { DominatorAnalysis* dom_analysis = context->GetDominatorAnalysis(f); ClearLoops(); // Post-order traversal of the dominator tree to find all the OpLoopMerge // instructions. DominatorTree& dom_tree = dom_analysis->GetDomTree(); for (DominatorTreeNode& node : make_range(dom_tree.post_begin(), dom_tree.post_end())) { Instruction* merge_inst = node.bb_->GetLoopMergeInst(); if (merge_inst) { bool all_backedge_unreachable = true; for (uint32_t pid : context->cfg()->preds(node.bb_->id())) { if (dom_analysis->IsReachable(pid) && dom_analysis->Dominates(node.bb_->id(), pid)) { all_backedge_unreachable = false; break; } } if (all_backedge_unreachable) continue; // ignore this one, we actually never branch back. // The id of the merge basic block of this loop. uint32_t merge_bb_id = merge_inst->GetSingleWordOperand(0); // The id of the continue basic block of this loop. uint32_t continue_bb_id = merge_inst->GetSingleWordOperand(1); // The merge target of this loop. BasicBlock* merge_bb = context->cfg()->block(merge_bb_id); // The continue target of this loop. BasicBlock* continue_bb = context->cfg()->block(continue_bb_id); // The basic block containing the merge instruction. BasicBlock* header_bb = context->get_instr_block(merge_inst); // Add the loop to the list of all the loops in the function. Loop* current_loop = new Loop(context, dom_analysis, header_bb, continue_bb, merge_bb); loops_.push_back(current_loop); // We have a bottom-up construction, so if this loop has nested-loops, // they are by construction at the tail of the loop list. for (auto itr = loops_.rbegin() + 1; itr != loops_.rend(); ++itr) { Loop* previous_loop = *itr; // If the loop already has a parent, then it has been processed. if (previous_loop->HasParent()) continue; // If the current loop does not dominates the previous loop then it is // not nested loop. if (!dom_analysis->Dominates(header_bb, previous_loop->GetHeaderBlock())) continue; // If the current loop merge dominates the previous loop then it is // not nested loop. if (dom_analysis->Dominates(merge_bb, previous_loop->GetHeaderBlock())) continue; current_loop->AddNestedLoop(previous_loop); } DominatorTreeNode* dom_merge_node = dom_tree.GetTreeNode(merge_bb); for (DominatorTreeNode& loop_node : make_range(node.df_begin(), node.df_end())) { // Check if we are in the loop. if (dom_tree.Dominates(dom_merge_node, &loop_node)) continue; current_loop->AddBasicBlock(loop_node.bb_); basic_block_to_loop_.insert( std::make_pair(loop_node.bb_->id(), current_loop)); } } } for (Loop* loop : loops_) { if (!loop->HasParent()) placeholder_top_loop_.nested_loops_.push_back(loop); } } std::vector LoopDescriptor::GetLoopsInBinaryLayoutOrder() { std::vector ids{}; for (size_t i = 0; i < NumLoops(); ++i) { ids.push_back(GetLoopByIndex(i).GetHeaderBlock()->id()); } std::vector loops{}; if (!ids.empty()) { auto function = GetLoopByIndex(0).GetHeaderBlock()->GetParent(); for (const auto& block : *function) { auto block_id = block.id(); auto element = std::find(std::begin(ids), std::end(ids), block_id); if (element != std::end(ids)) { loops.push_back(&GetLoopByIndex(element - std::begin(ids))); } } } return loops; } BasicBlock* Loop::FindConditionBlock() const { if (!loop_merge_) { return nullptr; } BasicBlock* condition_block = nullptr; uint32_t in_loop_pred = 0; for (uint32_t p : context_->cfg()->preds(loop_merge_->id())) { if (IsInsideLoop(p)) { if (in_loop_pred) { // 2 in-loop predecessors. return nullptr; } in_loop_pred = p; } } if (!in_loop_pred) { // Merge block is unreachable. return nullptr; } BasicBlock* bb = context_->cfg()->block(in_loop_pred); if (!bb) return nullptr; const Instruction& branch = *bb->ctail(); // Make sure the branch is a conditional branch. if (branch.opcode() != spv::Op::OpBranchConditional) return nullptr; // Make sure one of the two possible branches is to the merge block. if (branch.GetSingleWordInOperand(1) == loop_merge_->id() || branch.GetSingleWordInOperand(2) == loop_merge_->id()) { condition_block = bb; } return condition_block; } bool Loop::FindNumberOfIterations(const Instruction* induction, const Instruction* branch_inst, size_t* iterations_out, int64_t* step_value_out, int64_t* init_value_out) const { // From the branch instruction find the branch condition. analysis::DefUseManager* def_use_manager = context_->get_def_use_mgr(); // Condition instruction from the OpConditionalBranch. Instruction* condition = def_use_manager->GetDef(branch_inst->GetSingleWordOperand(0)); assert(IsSupportedCondition(condition->opcode())); // Get the constant manager from the ir context. analysis::ConstantManager* const_manager = context_->get_constant_mgr(); // Find the constant value used by the condition variable. Exit out if it // isn't a constant int. const analysis::Constant* upper_bound = const_manager->FindDeclaredConstant(condition->GetSingleWordOperand(3)); if (!upper_bound) return false; // Must be integer because of the opcode on the condition. const analysis::Integer* type = upper_bound->type()->AsInteger(); if (!type || type->width() > 64) { return false; } int64_t condition_value = type->IsSigned() ? upper_bound->GetSignExtendedValue() : upper_bound->GetZeroExtendedValue(); // Find the instruction which is stepping through the loop. // // GetInductionStepOperation returns nullptr if |step_inst| is OpConstantNull. Instruction* step_inst = GetInductionStepOperation(induction); if (!step_inst) return false; // Find the constant value used by the condition variable. const analysis::Constant* step_constant = const_manager->FindDeclaredConstant(step_inst->GetSingleWordOperand(3)); if (!step_constant) return false; // Must be integer because of the opcode on the condition. int64_t step_value = 0; const analysis::Integer* step_type = step_constant->AsIntConstant()->type()->AsInteger(); if (step_type->IsSigned()) { step_value = step_constant->AsIntConstant()->GetS32BitValue(); } else { step_value = step_constant->AsIntConstant()->GetU32BitValue(); } // If this is a subtraction step we should negate the step value. if (step_inst->opcode() == spv::Op::OpISub) { step_value = -step_value; } // Find the initial value of the loop and make sure it is a constant integer. int64_t init_value = 0; if (!GetInductionInitValue(induction, &init_value)) return false; // If iterations is non null then store the value in that. int64_t num_itrs = GetIterations(condition->opcode(), condition_value, init_value, step_value); // If the loop body will not be reached return false. if (num_itrs <= 0) { return false; } if (iterations_out) { assert(static_cast(num_itrs) <= std::numeric_limits::max()); *iterations_out = static_cast(num_itrs); } if (step_value_out) { *step_value_out = step_value; } if (init_value_out) { *init_value_out = init_value; } return true; } // We retrieve the number of iterations using the following formula, diff / // |step_value| where diff is calculated differently according to the // |condition| and uses the |condition_value| and |init_value|. If diff / // |step_value| is NOT cleanly divisible then we add one to the sum. int64_t Loop::GetIterations(spv::Op condition, int64_t condition_value, int64_t init_value, int64_t step_value) const { if (step_value == 0) { return 0; } int64_t diff = 0; switch (condition) { case spv::Op::OpSLessThan: case spv::Op::OpULessThan: { // If the condition is not met to begin with the loop will never iterate. if (!(init_value < condition_value)) return 0; diff = condition_value - init_value; // If the operation is a less then operation then the diff and step must // have the same sign otherwise the induction will never cross the // condition (either never true or always true). if ((diff < 0 && step_value > 0) || (diff > 0 && step_value < 0)) { return 0; } break; } case spv::Op::OpSGreaterThan: case spv::Op::OpUGreaterThan: { // If the condition is not met to begin with the loop will never iterate. if (!(init_value > condition_value)) return 0; diff = init_value - condition_value; // If the operation is a greater than operation then the diff and step // must have opposite signs. Otherwise the condition will always be true // or will never be true. if ((diff < 0 && step_value < 0) || (diff > 0 && step_value > 0)) { return 0; } break; } case spv::Op::OpSGreaterThanEqual: case spv::Op::OpUGreaterThanEqual: { // If the condition is not met to begin with the loop will never iterate. if (!(init_value >= condition_value)) return 0; // We subtract one to make it the same as spv::Op::OpGreaterThan as it is // functionally equivalent. diff = init_value - (condition_value - 1); // If the operation is a greater than operation then the diff and step // must have opposite signs. Otherwise the condition will always be true // or will never be true. if ((diff > 0 && step_value > 0) || (diff < 0 && step_value < 0)) { return 0; } break; } case spv::Op::OpSLessThanEqual: case spv::Op::OpULessThanEqual: { // If the condition is not met to begin with the loop will never iterate. if (!(init_value <= condition_value)) return 0; // We add one to make it the same as spv::Op::OpLessThan as it is // functionally equivalent. diff = (condition_value + 1) - init_value; // If the operation is a less than operation then the diff and step must // have the same sign otherwise the induction will never cross the // condition (either never true or always true). if ((diff < 0 && step_value > 0) || (diff > 0 && step_value < 0)) { return 0; } break; } default: assert(false && "Could not retrieve number of iterations from the loop condition. " "Condition is not supported."); } // Take the abs of - step values. step_value = llabs(step_value); diff = llabs(diff); int64_t result = diff / step_value; if (diff % step_value != 0) { result += 1; } return result; } // Returns the list of induction variables within the loop. void Loop::GetInductionVariables( std::vector& induction_variables) const { for (Instruction& inst : *loop_header_) { if (inst.opcode() == spv::Op::OpPhi) { induction_variables.push_back(&inst); } } } Instruction* Loop::FindConditionVariable( const BasicBlock* condition_block) const { // Find the branch instruction. const Instruction& branch_inst = *condition_block->ctail(); Instruction* induction = nullptr; // Verify that the branch instruction is a conditional branch. if (branch_inst.opcode() == spv::Op::OpBranchConditional) { // From the branch instruction find the branch condition. analysis::DefUseManager* def_use_manager = context_->get_def_use_mgr(); // Find the instruction representing the condition used in the conditional // branch. Instruction* condition = def_use_manager->GetDef(branch_inst.GetSingleWordOperand(0)); // Ensure that the condition is a less than operation. if (condition && IsSupportedCondition(condition->opcode())) { // The left hand side operand of the operation. Instruction* variable_inst = def_use_manager->GetDef(condition->GetSingleWordOperand(2)); // Make sure the variable instruction used is a phi. if (!variable_inst || variable_inst->opcode() != spv::Op::OpPhi) return nullptr; // Make sure the phi instruction only has two incoming blocks. Each // incoming block will be represented by two in operands in the phi // instruction, the value and the block which that value came from. We // assume the cannocalised phi will have two incoming values, one from the // preheader and one from the continue block. size_t max_supported_operands = 4; if (variable_inst->NumInOperands() == max_supported_operands) { // The operand index of the first incoming block label. uint32_t operand_label_1 = 1; // The operand index of the second incoming block label. uint32_t operand_label_2 = 3; // Make sure one of them is the preheader. if (!IsInsideLoop( variable_inst->GetSingleWordInOperand(operand_label_1)) && !IsInsideLoop( variable_inst->GetSingleWordInOperand(operand_label_2))) { return nullptr; } // And make sure that the other is the latch block. if (variable_inst->GetSingleWordInOperand(operand_label_1) != loop_latch_->id() && variable_inst->GetSingleWordInOperand(operand_label_2) != loop_latch_->id()) { return nullptr; } } else { return nullptr; } if (!FindNumberOfIterations(variable_inst, &branch_inst, nullptr)) return nullptr; induction = variable_inst; } } return induction; } bool LoopDescriptor::CreatePreHeaderBlocksIfMissing() { auto modified = false; for (auto& loop : *this) { if (!loop.GetPreHeaderBlock()) { modified = true; // TODO(1841): Handle failure to create pre-header. loop.GetOrCreatePreHeaderBlock(); } } return modified; } // Add and remove loops which have been marked for addition and removal to // maintain the state of the loop descriptor class. void LoopDescriptor::PostModificationCleanup() { LoopContainerType loops_to_remove_; for (Loop* loop : loops_) { if (loop->IsMarkedForRemoval()) { loops_to_remove_.push_back(loop); if (loop->HasParent()) { loop->GetParent()->RemoveChildLoop(loop); } } } for (Loop* loop : loops_to_remove_) { loops_.erase(std::find(loops_.begin(), loops_.end(), loop)); delete loop; } for (auto& pair : loops_to_add_) { Loop* parent = pair.first; std::unique_ptr loop = std::move(pair.second); if (parent) { loop->SetParent(nullptr); parent->AddNestedLoop(loop.get()); for (uint32_t block_id : loop->GetBlocks()) { parent->AddBasicBlock(block_id); } } loops_.emplace_back(loop.release()); } loops_to_add_.clear(); } void LoopDescriptor::ClearLoops() { for (Loop* loop : loops_) { delete loop; } loops_.clear(); } // Adds a new loop nest to the descriptor set. Loop* LoopDescriptor::AddLoopNest(std::unique_ptr new_loop) { Loop* loop = new_loop.release(); if (!loop->HasParent()) placeholder_top_loop_.nested_loops_.push_back(loop); // Iterate from inner to outer most loop, adding basic block to loop mapping // as we go. for (Loop& current_loop : make_range(iterator::begin(loop), iterator::end(nullptr))) { loops_.push_back(¤t_loop); for (uint32_t bb_id : current_loop.GetBlocks()) basic_block_to_loop_.insert(std::make_pair(bb_id, ¤t_loop)); } return loop; } void LoopDescriptor::RemoveLoop(Loop* loop) { Loop* parent = loop->GetParent() ? loop->GetParent() : &placeholder_top_loop_; parent->nested_loops_.erase(std::find(parent->nested_loops_.begin(), parent->nested_loops_.end(), loop)); std::for_each( loop->nested_loops_.begin(), loop->nested_loops_.end(), [loop](Loop* sub_loop) { sub_loop->SetParent(loop->GetParent()); }); parent->nested_loops_.insert(parent->nested_loops_.end(), loop->nested_loops_.begin(), loop->nested_loops_.end()); for (uint32_t bb_id : loop->GetBlocks()) { Loop* l = FindLoopForBasicBlock(bb_id); if (l == loop) { SetBasicBlockToLoop(bb_id, l->GetParent()); } else { ForgetBasicBlock(bb_id); } } LoopContainerType::iterator it = std::find(loops_.begin(), loops_.end(), loop); assert(it != loops_.end()); delete loop; loops_.erase(it); } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/loop_descriptor.h000066400000000000000000000554551475742701700242310ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_LOOP_DESCRIPTOR_H_ #define SOURCE_OPT_LOOP_DESCRIPTOR_H_ #include #include #include #include #include #include #include #include #include "source/opt/basic_block.h" #include "source/opt/dominator_analysis.h" #include "source/opt/module.h" #include "source/opt/tree_iterator.h" namespace spvtools { namespace opt { class IRContext; class CFG; class LoopDescriptor; // A class to represent and manipulate a loop in structured control flow. class Loop { // The type used to represent nested child loops. using ChildrenList = std::vector; public: using iterator = ChildrenList::iterator; using const_iterator = ChildrenList::const_iterator; using BasicBlockListTy = std::unordered_set; explicit Loop(IRContext* context) : context_(context), loop_header_(nullptr), loop_continue_(nullptr), loop_merge_(nullptr), loop_preheader_(nullptr), loop_latch_(nullptr), parent_(nullptr), loop_is_marked_for_removal_(false) {} Loop(IRContext* context, DominatorAnalysis* analysis, BasicBlock* header, BasicBlock* continue_target, BasicBlock* merge_target); // Iterators over the immediate sub-loops. inline iterator begin() { return nested_loops_.begin(); } inline iterator end() { return nested_loops_.end(); } inline const_iterator begin() const { return cbegin(); } inline const_iterator end() const { return cend(); } inline const_iterator cbegin() const { return nested_loops_.begin(); } inline const_iterator cend() const { return nested_loops_.end(); } // Returns the header (first basic block of the loop). This block contains the // OpLoopMerge instruction. inline BasicBlock* GetHeaderBlock() { return loop_header_; } inline const BasicBlock* GetHeaderBlock() const { return loop_header_; } inline void SetHeaderBlock(BasicBlock* header) { loop_header_ = header; } // Updates the OpLoopMerge instruction to reflect the current state of the // loop. inline void UpdateLoopMergeInst() { assert(GetHeaderBlock()->GetLoopMergeInst() && "The loop is not structured"); Instruction* merge_inst = GetHeaderBlock()->GetLoopMergeInst(); merge_inst->SetInOperand(0, {GetMergeBlock()->id()}); } // Returns the continue target basic block. This is the block designated as // the continue target by the OpLoopMerge instruction. inline BasicBlock* GetContinueBlock() { return loop_continue_; } inline const BasicBlock* GetContinueBlock() const { return loop_continue_; } // Returns the latch basic block (basic block that holds the back-edge). // These functions return nullptr if the loop is not structured (i.e. if it // has more than one backedge). inline BasicBlock* GetLatchBlock() { return loop_latch_; } inline const BasicBlock* GetLatchBlock() const { return loop_latch_; } // Sets |latch| as the loop unique block branching back to the header. // A latch block must have the following properties: // - |latch| must be in the loop; // - must be the only block branching back to the header block. void SetLatchBlock(BasicBlock* latch); // Sets |continue_block| as the continue block of the loop. This should be the // continue target of the OpLoopMerge and should dominate the latch block. void SetContinueBlock(BasicBlock* continue_block); // Returns the basic block which marks the end of the loop. // These functions return nullptr if the loop is not structured. inline BasicBlock* GetMergeBlock() { return loop_merge_; } inline const BasicBlock* GetMergeBlock() const { return loop_merge_; } // Sets |merge| as the loop merge block. A merge block must have the following // properties: // - |merge| must not be in the loop; // - all its predecessors must be in the loop. // - it must not be already used as merge block. // If the loop has an OpLoopMerge in its header, this instruction is also // updated. void SetMergeBlock(BasicBlock* merge); // Returns the loop pre-header, nullptr means that the loop predecessor does // not qualify as a preheader. // The preheader is the unique predecessor that: // - Dominates the loop header; // - Has only the loop header as successor. inline BasicBlock* GetPreHeaderBlock() { return loop_preheader_; } // Returns the loop pre-header. inline const BasicBlock* GetPreHeaderBlock() const { return loop_preheader_; } // Sets |preheader| as the loop preheader block. A preheader block must have // the following properties: // - |merge| must not be in the loop; // - have an unconditional branch to the loop header. void SetPreHeaderBlock(BasicBlock* preheader); // Returns the loop pre-header, if there is no suitable preheader it will be // created. Returns |nullptr| if it fails to create the preheader. BasicBlock* GetOrCreatePreHeaderBlock(); // Returns true if this loop contains any nested loops. inline bool HasNestedLoops() const { return nested_loops_.size() != 0; } // Clears and fills |exit_blocks| with all basic blocks that are not in the // loop and has at least one predecessor in the loop. void GetExitBlocks(std::unordered_set* exit_blocks) const; // Clears and fills |merging_blocks| with all basic blocks that are // post-dominated by the merge block. The merge block must exist. // The set |merging_blocks| will only contain the merge block if it is // unreachable. void GetMergingBlocks(std::unordered_set* merging_blocks) const; // Returns true if the loop is in a Loop Closed SSA form. // In LCSSA form, all in-loop definitions are used in the loop or in phi // instructions in the loop exit blocks. bool IsLCSSA() const; // Returns the depth of this loop in the loop nest. // The outer-most loop has a depth of 1. inline size_t GetDepth() const { size_t lvl = 1; for (const Loop* loop = GetParent(); loop; loop = loop->GetParent()) lvl++; return lvl; } inline size_t NumImmediateChildren() const { return nested_loops_.size(); } inline bool HasChildren() const { return !nested_loops_.empty(); } // Adds |nested| as a nested loop of this loop. Automatically register |this| // as the parent of |nested|. inline void AddNestedLoop(Loop* nested) { assert(!nested->GetParent() && "The loop has another parent."); nested_loops_.push_back(nested); nested->SetParent(this); } inline Loop* GetParent() { return parent_; } inline const Loop* GetParent() const { return parent_; } inline bool HasParent() const { return parent_; } // Returns true if this loop is itself nested within another loop. inline bool IsNested() const { return parent_ != nullptr; } // Returns the set of all basic blocks contained within the loop. Will be all // BasicBlocks dominated by the header which are not also dominated by the // loop merge block. inline const BasicBlockListTy& GetBlocks() const { return loop_basic_blocks_; } // Returns true if the basic block |bb| is inside this loop. inline bool IsInsideLoop(const BasicBlock* bb) const { return IsInsideLoop(bb->id()); } // Returns true if the basic block id |bb_id| is inside this loop. inline bool IsInsideLoop(uint32_t bb_id) const { return loop_basic_blocks_.count(bb_id); } // Returns true if the instruction |inst| is inside this loop. bool IsInsideLoop(Instruction* inst) const; // Adds the Basic Block |bb| to this loop and its parents. void AddBasicBlock(const BasicBlock* bb) { AddBasicBlock(bb->id()); } // Adds the Basic Block with |id| to this loop and its parents. void AddBasicBlock(uint32_t id) { for (Loop* loop = this; loop != nullptr; loop = loop->parent_) { loop->loop_basic_blocks_.insert(id); } } // Removes the Basic Block id |bb_id| from this loop and its parents. // It the user responsibility to make sure the removed block is not a merge, // header or continue block. void RemoveBasicBlock(uint32_t bb_id) { for (Loop* loop = this; loop != nullptr; loop = loop->parent_) { loop->loop_basic_blocks_.erase(bb_id); } } // Removes all the basic blocks from the set of basic blocks within the loop. // This does not affect any of the stored pointers to the header, preheader, // merge, or continue blocks. void ClearBlocks() { loop_basic_blocks_.clear(); } // Adds the Basic Block |bb| this loop and its parents. void AddBasicBlockToLoop(const BasicBlock* bb) { assert(IsBasicBlockInLoopSlow(bb) && "Basic block does not belong to the loop"); AddBasicBlock(bb); } // Returns the list of induction variables within the loop. void GetInductionVariables(std::vector& inductions) const; // This function uses the |condition| to find the induction variable which is // used by the loop condition within the loop. This only works if the loop is // bound by a single condition and single induction variable. Instruction* FindConditionVariable(const BasicBlock* condition) const; // Returns the number of iterations within a loop when given the |induction| // variable and the loop |condition| check. It stores the found number of // iterations in the output parameter |iterations| and optionally, the step // value in |step_value| and the initial value of the induction variable in // |init_value|. bool FindNumberOfIterations(const Instruction* induction, const Instruction* condition, size_t* iterations, int64_t* step_amount = nullptr, int64_t* init_value = nullptr) const; // Returns the value of the OpLoopMerge control operand as a bool. Loop // control can be None(0), Unroll(1), or DontUnroll(2). This function returns // true if it is set to Unroll. inline bool HasUnrollLoopControl() const { assert(loop_header_); if (!loop_header_->GetLoopMergeInst()) return false; return loop_header_->GetLoopMergeInst()->GetSingleWordOperand(2) == 1; } // Finds the conditional block with a branch to the merge and continue blocks // within the loop body. BasicBlock* FindConditionBlock() const; // Remove the child loop form this loop. inline void RemoveChildLoop(Loop* loop) { nested_loops_.erase( std::find(nested_loops_.begin(), nested_loops_.end(), loop)); loop->SetParent(nullptr); } // Mark this loop to be removed later by a call to // LoopDescriptor::PostModificationCleanup. inline void MarkLoopForRemoval() { loop_is_marked_for_removal_ = true; } // Returns whether or not this loop has been marked for removal. inline bool IsMarkedForRemoval() const { return loop_is_marked_for_removal_; } // Returns true if all nested loops have been marked for removal. inline bool AreAllChildrenMarkedForRemoval() const { for (const Loop* child : nested_loops_) { if (!child->IsMarkedForRemoval()) { return false; } } return true; } // Checks if the loop contains any instruction that will prevent it from being // cloned. If the loop is structured, the merge construct is also considered. bool IsSafeToClone() const; // Sets the parent loop of this loop, that is, a loop which contains this loop // as a nested child loop. inline void SetParent(Loop* parent) { parent_ = parent; } // Returns true is the instruction is invariant and safe to move wrt loop. bool ShouldHoistInstruction(const Instruction& inst) const; // Returns true if all operands of inst are in basic blocks not contained in // loop. bool AreAllOperandsOutsideLoop(const Instruction& inst) const; // Extract the initial value from the |induction| variable and store it in // |value|. If the function couldn't find the initial value of |induction| // return false. bool GetInductionInitValue(const Instruction* induction, int64_t* value) const; // Takes in a phi instruction |induction| and the loop |header| and returns // the step operation of the loop. Instruction* GetInductionStepOperation(const Instruction* induction) const; // Returns true if we can deduce the number of loop iterations in the step // operation |step|. IsSupportedCondition must also be true for the condition // instruction. bool IsSupportedStepOp(spv::Op step) const; // Returns true if we can deduce the number of loop iterations in the // condition operation |condition|. IsSupportedStepOp must also be true for // the step instruction. bool IsSupportedCondition(spv::Op condition) const; // Creates the list of the loop's basic block in structured order and store // the result in |ordered_loop_blocks|. If |include_pre_header| is true, the // pre-header block will also be included at the beginning of the list if it // exist. If |include_merge| is true, the merge block will also be included at // the end of the list if it exist. void ComputeLoopStructuredOrder(std::vector* ordered_loop_blocks, bool include_pre_header = false, bool include_merge = false) const; // Given the loop |condition|, |initial_value|, |step_value|, the trip count // |number_of_iterations|, and the |unroll_factor| requested, get the new // condition value for the residual loop. static int64_t GetResidualConditionValue(spv::Op condition, int64_t initial_value, int64_t step_value, size_t number_of_iterations, size_t unroll_factor); // Returns the condition instruction for entry into the loop // Returns nullptr if it can't be found. Instruction* GetConditionInst() const; // Returns the context associated this loop. IRContext* GetContext() const { return context_; } // Looks at all the blocks with a branch to the header block to find one // which is also dominated by the loop continue block. This block is the latch // block. The specification mandates that this block should exist, therefore // this function will assert if it is not found. BasicBlock* FindLatchBlock(); private: IRContext* context_; // The block which marks the start of the loop. BasicBlock* loop_header_; // The block which begins the body of the loop. BasicBlock* loop_continue_; // The block which marks the end of the loop. BasicBlock* loop_merge_; // The block immediately before the loop header. BasicBlock* loop_preheader_; // The block containing the backedge to the loop header. BasicBlock* loop_latch_; // A parent of a loop is the loop which contains it as a nested child loop. Loop* parent_; // Nested child loops of this loop. ChildrenList nested_loops_; // A set of all the basic blocks which comprise the loop structure. Will be // computed only when needed on demand. BasicBlockListTy loop_basic_blocks_; // Check that |bb| is inside the loop using domination property. // Note: this is for assertion purposes only, IsInsideLoop should be used // instead. bool IsBasicBlockInLoopSlow(const BasicBlock* bb); // Returns the loop preheader if it exists, returns nullptr otherwise. BasicBlock* FindLoopPreheader(DominatorAnalysis* dom_analysis); // Sets |latch| as the loop unique latch block. No checks are performed // here. inline void SetLatchBlockImpl(BasicBlock* latch) { loop_latch_ = latch; } // Sets |merge| as the loop merge block. No checks are performed here. inline void SetMergeBlockImpl(BasicBlock* merge) { loop_merge_ = merge; } // Each different loop |condition| affects how we calculate the number of // iterations using the |condition_value|, |init_value|, and |step_values| of // the induction variable. This method will return the number of iterations in // a loop with those values for a given |condition|. Returns 0 if the number // of iterations could not be computed. int64_t GetIterations(spv::Op condition, int64_t condition_value, int64_t init_value, int64_t step_value) const; // This is to allow for loops to be removed mid iteration without invalidating // the iterators. bool loop_is_marked_for_removal_; // This is only to allow LoopDescriptor::placeholder_top_loop_ to add top // level loops as child. friend class LoopDescriptor; friend class LoopUtils; }; // Loop descriptions class for a given function. // For a given function, the class builds loop nests information. // The analysis expects a structured control flow. class LoopDescriptor { public: // Iterator interface (depth first postorder traversal). using iterator = PostOrderTreeDFIterator; using const_iterator = PostOrderTreeDFIterator; using pre_iterator = TreeDFIterator; using const_pre_iterator = TreeDFIterator; // Creates a loop object for all loops found in |f|. LoopDescriptor(IRContext* context, const Function* f); // Disable copy constructor, to avoid double-free on destruction. LoopDescriptor(const LoopDescriptor&) = delete; // Move constructor. LoopDescriptor(LoopDescriptor&& other) : placeholder_top_loop_(nullptr) { // We need to take ownership of the Loop objects in the other // LoopDescriptor, to avoid double-free. loops_ = std::move(other.loops_); other.loops_.clear(); basic_block_to_loop_ = std::move(other.basic_block_to_loop_); other.basic_block_to_loop_.clear(); placeholder_top_loop_ = std::move(other.placeholder_top_loop_); } // Destructor ~LoopDescriptor(); // Returns the number of loops found in the function. inline size_t NumLoops() const { return loops_.size(); } // Returns the loop at a particular |index|. The |index| must be in bounds, // check with NumLoops before calling. inline Loop& GetLoopByIndex(size_t index) const { assert(loops_.size() > index && "Index out of range (larger than loop count)"); return *loops_[index]; } // Returns the loops in |this| in the order their headers appear in the // binary. std::vector GetLoopsInBinaryLayoutOrder(); // Returns the inner most loop that contains the basic block id |block_id|. inline Loop* operator[](uint32_t block_id) const { return FindLoopForBasicBlock(block_id); } // Returns the inner most loop that contains the basic block |bb|. inline Loop* operator[](const BasicBlock* bb) const { return (*this)[bb->id()]; } // Iterators for post order depth first traversal of the loops. // Inner most loops will be visited first. inline iterator begin() { return iterator::begin(&placeholder_top_loop_); } inline iterator end() { return iterator::end(&placeholder_top_loop_); } inline const_iterator begin() const { return cbegin(); } inline const_iterator end() const { return cend(); } inline const_iterator cbegin() const { return const_iterator::begin(&placeholder_top_loop_); } inline const_iterator cend() const { return const_iterator::end(&placeholder_top_loop_); } // Iterators for pre-order depth first traversal of the loops. // Inner most loops will be visited first. inline pre_iterator pre_begin() { return ++pre_iterator(&placeholder_top_loop_); } inline pre_iterator pre_end() { return pre_iterator(); } inline const_pre_iterator pre_begin() const { return pre_cbegin(); } inline const_pre_iterator pre_end() const { return pre_cend(); } inline const_pre_iterator pre_cbegin() const { return ++const_pre_iterator(&placeholder_top_loop_); } inline const_pre_iterator pre_cend() const { return const_pre_iterator(); } // Returns the inner most loop that contains the basic block |bb|. inline void SetBasicBlockToLoop(uint32_t bb_id, Loop* loop) { basic_block_to_loop_[bb_id] = loop; } // Mark the loop |loop_to_add| as needing to be added when the user calls // PostModificationCleanup. |parent| may be null. inline void AddLoop(std::unique_ptr&& loop_to_add, Loop* parent) { loops_to_add_.emplace_back(std::make_pair(parent, std::move(loop_to_add))); } // Checks all loops in |this| and will create pre-headers for all loops // that don't have one. Returns |true| if any blocks were created. bool CreatePreHeaderBlocksIfMissing(); // Should be called to preserve the LoopAnalysis after loops have been marked // for addition with AddLoop or MarkLoopForRemoval. void PostModificationCleanup(); // Removes the basic block id |bb_id| from the block to loop mapping. inline void ForgetBasicBlock(uint32_t bb_id) { basic_block_to_loop_.erase(bb_id); } // Adds the loop |new_loop| and all its nested loops to the descriptor set. // The object takes ownership of all the loops. Loop* AddLoopNest(std::unique_ptr new_loop); // Remove the loop |loop|. void RemoveLoop(Loop* loop); void SetAsTopLoop(Loop* loop) { assert(std::find(placeholder_top_loop_.begin(), placeholder_top_loop_.end(), loop) == placeholder_top_loop_.end() && "already registered"); placeholder_top_loop_.nested_loops_.push_back(loop); } Loop* GetPlaceholderRootLoop() { return &placeholder_top_loop_; } const Loop* GetPlaceholderRootLoop() const { return &placeholder_top_loop_; } private: // TODO(dneto): This should be a vector of unique_ptr. But VisualStudio 2013 // is unable to compile it. using LoopContainerType = std::vector; using LoopsToAddContainerType = std::vector>>; // Creates loop descriptors for the function |f|. void PopulateList(IRContext* context, const Function* f); // Returns the inner most loop that contains the basic block id |block_id|. inline Loop* FindLoopForBasicBlock(uint32_t block_id) const { std::unordered_map::const_iterator it = basic_block_to_loop_.find(block_id); return it != basic_block_to_loop_.end() ? it->second : nullptr; } // Erase all the loop information. void ClearLoops(); // A list of all the loops in the function. This variable owns the Loop // objects. LoopContainerType loops_; // Placeholder root: this "loop" is only there to help iterators creation. Loop placeholder_top_loop_; std::unordered_map basic_block_to_loop_; // List of the loops marked for addition when PostModificationCleanup is // called. LoopsToAddContainerType loops_to_add_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_LOOP_DESCRIPTOR_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/loop_fission.cpp000066400000000000000000000465331475742701700240550ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/loop_fission.h" #include #include "source/opt/register_pressure.h" // Implement loop fission with an optional parameter to split only // if the register pressure in a given loop meets a certain criteria. This is // controlled via the constructors of LoopFissionPass. // // 1 - Build a list of loops to be split, these are top level loops (loops // without child loops themselves) which meet the register pressure criteria, as // determined by the ShouldSplitLoop method of LoopFissionPass. // // 2 - For each loop in the list, group each instruction into a set of related // instructions by traversing each instructions users and operands recursively. // We stop if we encounter an instruction we have seen before or an instruction // which we don't consider relevant (i.e OpLoopMerge). We then group these // groups into two different sets, one for the first loop and one for the // second. // // 3 - We then run CanPerformSplit to check that it would be legal to split a // loop using those two sets. We check that we haven't altered the relative // order load/stores appear in the binary and that we aren't breaking any // dependency between load/stores by splitting them into two loops. We also // check that none of the OpBranch instructions are dependent on a load as we // leave control flow structure intact and move only instructions in the body so // we want to avoid any loads with side affects or aliasing. // // 4 - We then split the loop by calling SplitLoop. This function clones the // loop and attaches it to the preheader and connects the new loops merge block // to the current loop header block. We then use the two sets built in step 2 to // remove instructions from each loop. If an instruction appears in the first // set it is removed from the second loop and vice versa. // // 5 - If the multiple split passes flag is set we check if each of the loops // still meet the register pressure criteria. If they do then we add them to the // list of loops to be split (created in step one) to allow for loops to be // split multiple times. // namespace spvtools { namespace opt { class LoopFissionImpl { public: LoopFissionImpl(IRContext* context, Loop* loop) : context_(context), loop_(loop), load_used_in_condition_(false) {} // Group each instruction in the loop into sets of instructions related by // their usedef chains. An instruction which uses another will appear in the // same set. Then merge those sets into just two sets. Returns false if there // was one or less sets created. bool GroupInstructionsByUseDef(); // Check if the sets built by GroupInstructionsByUseDef violate any data // dependence rules. bool CanPerformSplit(); // Split the loop and return a pointer to the new loop. Loop* SplitLoop(); // Checks if |inst| is safe to move. We can only move instructions which don't // have any side effects and OpLoads and OpStores. bool MovableInstruction(const Instruction& inst) const; private: // Traverse the def use chain of |inst| and add the users and uses of |inst| // which are in the same loop to the |returned_set|. void TraverseUseDef(Instruction* inst, std::set* returned_set, bool ignore_phi_users = false, bool report_loads = false); // We group the instructions in the block into two different groups, the // instructions to be kept in the original loop and the ones to be cloned into // the new loop. As the cloned loop is attached to the preheader it will be // the first loop and the second loop will be the original. std::set cloned_loop_instructions_; std::set original_loop_instructions_; // We need a set of all the instructions to be seen so we can break any // recursion and also so we can ignore certain instructions by preemptively // adding them to this set. std::set seen_instructions_; // A map of instructions to their relative position in the function. std::map instruction_order_; IRContext* context_; Loop* loop_; // This is set to true by TraverseUseDef when traversing the instructions // related to the loop condition and any if conditions should any of those // instructions be a load. bool load_used_in_condition_; }; bool LoopFissionImpl::MovableInstruction(const Instruction& inst) const { return inst.opcode() == spv::Op::OpLoad || inst.opcode() == spv::Op::OpStore || inst.opcode() == spv::Op::OpSelectionMerge || inst.opcode() == spv::Op::OpPhi || inst.IsOpcodeCodeMotionSafe(); } void LoopFissionImpl::TraverseUseDef(Instruction* inst, std::set* returned_set, bool ignore_phi_users, bool report_loads) { assert(returned_set && "Set to be returned cannot be null."); analysis::DefUseManager* def_use = context_->get_def_use_mgr(); std::set& inst_set = *returned_set; // We create this functor to traverse the use def chain to build the // grouping of related instructions. The lambda captures the std::function // to allow it to recurse. std::function traverser_functor; traverser_functor = [this, def_use, &inst_set, &traverser_functor, ignore_phi_users, report_loads](Instruction* user) { // If we've seen the instruction before or it is not inside the loop end the // traversal. if (!user || seen_instructions_.count(user) != 0 || !context_->get_instr_block(user) || !loop_->IsInsideLoop(context_->get_instr_block(user))) { return; } // Don't include labels or loop merge instructions in the instruction sets. // Including them would mean we group instructions related only by using the // same labels (i.e phis). We already preempt the inclusion of // OpSelectionMerge by adding related instructions to the seen_instructions_ // set. if (user->opcode() == spv::Op::OpLoopMerge || user->opcode() == spv::Op::OpLabel) return; // If the |report_loads| flag is set, set the class field // load_used_in_condition_ to false. This is used to check that none of the // condition checks in the loop rely on loads. if (user->opcode() == spv::Op::OpLoad && report_loads) { load_used_in_condition_ = true; } // Add the instruction to the set of instructions already seen, this breaks // recursion and allows us to ignore certain instructions. seen_instructions_.insert(user); inst_set.insert(user); // Wrapper functor to traverse the operands of each instruction. auto traverse_operand = [&traverser_functor, def_use](const uint32_t* id) { traverser_functor(def_use->GetDef(*id)); }; user->ForEachInOperand(traverse_operand); // For the first traversal we want to ignore the users of the phi. if (ignore_phi_users && user->opcode() == spv::Op::OpPhi) return; // Traverse each user with this lambda. def_use->ForEachUser(user, traverser_functor); // Wrapper functor for the use traversal. auto traverse_use = [&traverser_functor](Instruction* use, uint32_t) { traverser_functor(use); }; def_use->ForEachUse(user, traverse_use); }; // We start the traversal of the use def graph by invoking the above // lambda with the |inst| parameter. traverser_functor(inst); } bool LoopFissionImpl::GroupInstructionsByUseDef() { std::vector> sets{}; // We want to ignore all the instructions stemming from the loop condition // instruction. BasicBlock* condition_block = loop_->FindConditionBlock(); if (!condition_block) return false; Instruction* condition = &*condition_block->tail(); // We iterate over the blocks via iterating over all the blocks in the // function, we do this so we are iterating in the same order which the blocks // appear in the binary. Function& function = *loop_->GetHeaderBlock()->GetParent(); // Create a temporary set to ignore certain groups of instructions within the // loop. We don't want any instructions related to control flow to be removed // from either loop only instructions within the control flow bodies. std::set instructions_to_ignore{}; TraverseUseDef(condition, &instructions_to_ignore, true, true); // Traverse control flow instructions to ensure they are added to the // seen_instructions_ set and will be ignored when it it called with actual // sets. for (BasicBlock& block : function) { if (!loop_->IsInsideLoop(block.id())) continue; for (Instruction& inst : block) { // Ignore all instructions related to control flow. if (inst.opcode() == spv::Op::OpSelectionMerge || inst.IsBranch()) { TraverseUseDef(&inst, &instructions_to_ignore, true, true); } } } // Traverse the instructions and generate the sets, automatically ignoring any // instructions in instructions_to_ignore. for (BasicBlock& block : function) { if (!loop_->IsInsideLoop(block.id()) || loop_->GetHeaderBlock()->id() == block.id()) continue; for (Instruction& inst : block) { // Record the order that each load/store is seen. if (inst.opcode() == spv::Op::OpLoad || inst.opcode() == spv::Op::OpStore) { instruction_order_[&inst] = instruction_order_.size(); } // Ignore instructions already seen in a traversal. if (seen_instructions_.count(&inst) != 0) { continue; } // Build the set. std::set inst_set{}; TraverseUseDef(&inst, &inst_set); if (!inst_set.empty()) sets.push_back(std::move(inst_set)); } } // If we have one or zero sets return false to indicate that due to // insufficient instructions we couldn't split the loop into two groups and // thus the loop can't be split any further. if (sets.size() < 2) { return false; } // Merge the loop sets into two different sets. In CanPerformSplit we will // validate that we don't break the relative ordering of loads/stores by doing // this. for (size_t index = 0; index < sets.size() / 2; ++index) { cloned_loop_instructions_.insert(sets[index].begin(), sets[index].end()); } for (size_t index = sets.size() / 2; index < sets.size(); ++index) { original_loop_instructions_.insert(sets[index].begin(), sets[index].end()); } return true; } bool LoopFissionImpl::CanPerformSplit() { // Return false if any of the condition instructions in the loop depend on a // load. if (load_used_in_condition_) { return false; } // Build a list of all parent loops of this loop. Loop dependence analysis // needs this structure. std::vector loops; Loop* parent_loop = loop_; while (parent_loop) { loops.push_back(parent_loop); parent_loop = parent_loop->GetParent(); } LoopDependenceAnalysis analysis{context_, loops}; // A list of all the stores in the cloned loop. std::vector set_one_stores{}; // A list of all the loads in the cloned loop. std::vector set_one_loads{}; // Populate the above lists. for (Instruction* inst : cloned_loop_instructions_) { if (inst->opcode() == spv::Op::OpStore) { set_one_stores.push_back(inst); } else if (inst->opcode() == spv::Op::OpLoad) { set_one_loads.push_back(inst); } // If we find any instruction which we can't move (such as a barrier), // return false. if (!MovableInstruction(*inst)) return false; } // We need to calculate the depth of the loop to create the loop dependency // distance vectors. const size_t loop_depth = loop_->GetDepth(); // Check the dependencies between loads in the cloned loop and stores in the // original and vice versa. for (Instruction* inst : original_loop_instructions_) { // If we find any instruction which we can't move (such as a barrier), // return false. if (!MovableInstruction(*inst)) return false; // Look at the dependency between the loads in the original and stores in // the cloned loops. if (inst->opcode() == spv::Op::OpLoad) { for (Instruction* store : set_one_stores) { DistanceVector vec{loop_depth}; // If the store actually should appear after the load, return false. // This means the store has been placed in the wrong grouping. if (instruction_order_[store] > instruction_order_[inst]) { return false; } // If not independent check the distance vector. if (!analysis.GetDependence(store, inst, &vec)) { for (DistanceEntry& entry : vec.GetEntries()) { // A distance greater than zero means that the store in the cloned // loop has a dependency on the load in the original loop. if (entry.distance > 0) return false; } } } } else if (inst->opcode() == spv::Op::OpStore) { for (Instruction* load : set_one_loads) { DistanceVector vec{loop_depth}; // If the load actually should appear after the store, return false. if (instruction_order_[load] > instruction_order_[inst]) { return false; } // If not independent check the distance vector. if (!analysis.GetDependence(inst, load, &vec)) { for (DistanceEntry& entry : vec.GetEntries()) { // A distance less than zero means the load in the cloned loop is // dependent on the store instruction in the original loop. if (entry.distance < 0) return false; } } } } } return true; } Loop* LoopFissionImpl::SplitLoop() { // Clone the loop. LoopUtils util{context_, loop_}; LoopUtils::LoopCloningResult clone_results; Loop* cloned_loop = util.CloneAndAttachLoopToHeader(&clone_results); // Update the OpLoopMerge in the cloned loop. cloned_loop->UpdateLoopMergeInst(); // Add the loop_ to the module. // TODO(1841): Handle failure to create pre-header. Function::iterator it = util.GetFunction()->FindBlock(loop_->GetOrCreatePreHeaderBlock()->id()); util.GetFunction()->AddBasicBlocks(clone_results.cloned_bb_.begin(), clone_results.cloned_bb_.end(), ++it); loop_->SetPreHeaderBlock(cloned_loop->GetMergeBlock()); std::vector instructions_to_kill{}; // Kill all the instructions which should appear in the cloned loop but not in // the original loop. for (uint32_t id : loop_->GetBlocks()) { BasicBlock* block = context_->cfg()->block(id); for (Instruction& inst : *block) { // If the instruction appears in the cloned loop instruction group, kill // it. if (cloned_loop_instructions_.count(&inst) == 1 && original_loop_instructions_.count(&inst) == 0) { instructions_to_kill.push_back(&inst); if (inst.opcode() == spv::Op::OpPhi) { context_->ReplaceAllUsesWith( inst.result_id(), clone_results.value_map_[inst.result_id()]); } } } } // Kill all instructions which should appear in the original loop and not in // the cloned loop. for (uint32_t id : cloned_loop->GetBlocks()) { BasicBlock* block = context_->cfg()->block(id); for (Instruction& inst : *block) { Instruction* old_inst = clone_results.ptr_map_[&inst]; // If the instruction belongs to the original loop instruction group, kill // it. if (cloned_loop_instructions_.count(old_inst) == 0 && original_loop_instructions_.count(old_inst) == 1) { instructions_to_kill.push_back(&inst); } } } for (Instruction* i : instructions_to_kill) { context_->KillInst(i); } return cloned_loop; } LoopFissionPass::LoopFissionPass(const size_t register_threshold_to_split, bool split_multiple_times) : split_multiple_times_(split_multiple_times) { // Split if the number of registers in the loop exceeds // |register_threshold_to_split|. split_criteria_ = [register_threshold_to_split]( const RegisterLiveness::RegionRegisterLiveness& liveness) { return liveness.used_registers_ > register_threshold_to_split; }; } LoopFissionPass::LoopFissionPass() : split_multiple_times_(false) { // Split by default. split_criteria_ = [](const RegisterLiveness::RegionRegisterLiveness&) { return true; }; } bool LoopFissionPass::ShouldSplitLoop(const Loop& loop, IRContext* c) { LivenessAnalysis* analysis = c->GetLivenessAnalysis(); RegisterLiveness::RegionRegisterLiveness liveness{}; Function* function = loop.GetHeaderBlock()->GetParent(); analysis->Get(function)->ComputeLoopRegisterPressure(loop, &liveness); return split_criteria_(liveness); } Pass::Status LoopFissionPass::Process() { bool changed = false; for (Function& f : *context()->module()) { // We collect all the inner most loops in the function and run the loop // splitting util on each. The reason we do this is to allow us to iterate // over each, as creating new loops will invalidate the loop iterator. std::vector inner_most_loops{}; LoopDescriptor& loop_descriptor = *context()->GetLoopDescriptor(&f); for (Loop& loop : loop_descriptor) { if (!loop.HasChildren() && ShouldSplitLoop(loop, context())) { inner_most_loops.push_back(&loop); } } // List of new loops which meet the criteria to be split again. std::vector new_loops_to_split{}; while (!inner_most_loops.empty()) { for (Loop* loop : inner_most_loops) { LoopFissionImpl impl{context(), loop}; // Group the instructions in the loop into two different sets of related // instructions. If we can't group the instructions into the two sets // then we can't split the loop any further. if (!impl.GroupInstructionsByUseDef()) { continue; } if (impl.CanPerformSplit()) { Loop* second_loop = impl.SplitLoop(); changed = true; context()->InvalidateAnalysesExceptFor( IRContext::kAnalysisLoopAnalysis); // If the newly created loop meets the criteria to be split, split it // again. if (ShouldSplitLoop(*second_loop, context())) new_loops_to_split.push_back(second_loop); // If the original loop (now split) still meets the criteria to be // split, split it again. if (ShouldSplitLoop(*loop, context())) new_loops_to_split.push_back(loop); } } // If the split multiple times flag has been set add the new loops which // meet the splitting criteria into the list of loops to be split on the // next iteration. if (split_multiple_times_) { inner_most_loops = std::move(new_loops_to_split); new_loops_to_split = {}; } else { break; } } } return changed ? Pass::Status::SuccessWithChange : Pass::Status::SuccessWithoutChange; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/loop_fission.h000066400000000000000000000053171475742701700235150ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_LOOP_FISSION_H_ #define SOURCE_OPT_LOOP_FISSION_H_ #include #include #include #include #include #include "source/opt/cfg.h" #include "source/opt/loop_dependence.h" #include "source/opt/loop_utils.h" #include "source/opt/module.h" #include "source/opt/pass.h" #include "source/opt/tree_iterator.h" namespace spvtools { namespace opt { class LoopFissionPass : public Pass { public: // Function used to determine if a given loop should be split. Takes register // pressure region for that loop as a parameter and returns true if the loop // should be split. using FissionCriteriaFunction = std::function; // Pass built with this constructor will split all loops regardless of // register pressure. Will not split loops more than once. LoopFissionPass(); // Split the loop if the number of registers used in the loop exceeds // |register_threshold_to_split|. |split_multiple_times| flag determines // whether or not the pass should split loops after already splitting them // once. LoopFissionPass(size_t register_threshold_to_split, bool split_multiple_times = true); // Split loops whose register pressure meets the criteria of |functor|. LoopFissionPass(FissionCriteriaFunction functor, bool split_multiple_times = true) : split_criteria_(functor), split_multiple_times_(split_multiple_times) {} const char* name() const override { return "loop-fission"; } Pass::Status Process() override; // Checks if |loop| meets the register pressure criteria to be split. bool ShouldSplitLoop(const Loop& loop, IRContext* context); private: // Functor to run in ShouldSplitLoop to determine if the register pressure // criteria is met for splitting the loop. FissionCriteriaFunction split_criteria_; // Flag designating whether or not we should also split the result of // previously split loops if they meet the register presure criteria. bool split_multiple_times_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_LOOP_FISSION_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/loop_fusion.cpp000066400000000000000000000576131475742701700237070ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/loop_fusion.h" #include #include #include "source/opt/ir_context.h" #include "source/opt/loop_dependence.h" #include "source/opt/loop_descriptor.h" namespace spvtools { namespace opt { namespace { // Append all the loops nested in |loop| to |loops|. void CollectChildren(Loop* loop, std::vector* loops) { for (auto child : *loop) { loops->push_back(child); if (child->NumImmediateChildren() != 0) { CollectChildren(child, loops); } } } // Return the set of locations accessed by |stores| and |loads|. std::set GetLocationsAccessed( const std::map>& stores, const std::map>& loads) { std::set locations{}; for (const auto& kv : stores) { locations.insert(std::get<0>(kv)); } for (const auto& kv : loads) { locations.insert(std::get<0>(kv)); } return locations; } // Append all dependences from |sources| to |destinations| to |dependences|. void GetDependences(std::vector* dependences, LoopDependenceAnalysis* analysis, const std::vector& sources, const std::vector& destinations, size_t num_entries) { for (auto source : sources) { for (auto destination : destinations) { DistanceVector dist(num_entries); if (!analysis->GetDependence(source, destination, &dist)) { dependences->push_back(dist); } } } } // Apped all instructions in |block| to |instructions|. void AddInstructionsInBlock(std::vector* instructions, BasicBlock* block) { for (auto& inst : *block) { instructions->push_back(&inst); } instructions->push_back(block->GetLabelInst()); } } // namespace bool LoopFusion::UsedInContinueOrConditionBlock(Instruction* phi_instruction, Loop* loop) { auto condition_block = loop->FindConditionBlock()->id(); auto continue_block = loop->GetContinueBlock()->id(); auto not_used = context_->get_def_use_mgr()->WhileEachUser( phi_instruction, [this, condition_block, continue_block](Instruction* instruction) { auto block_id = context_->get_instr_block(instruction)->id(); return block_id != condition_block && block_id != continue_block; }); return !not_used; } void LoopFusion::RemoveIfNotUsedContinueOrConditionBlock( std::vector* instructions, Loop* loop) { instructions->erase( std::remove_if(std::begin(*instructions), std::end(*instructions), [this, loop](Instruction* instruction) { return !UsedInContinueOrConditionBlock(instruction, loop); }), std::end(*instructions)); } bool LoopFusion::AreCompatible() { // Check that the loops are in the same function. if (loop_0_->GetHeaderBlock()->GetParent() != loop_1_->GetHeaderBlock()->GetParent()) { return false; } // Check that both loops have pre-header blocks. if (!loop_0_->GetPreHeaderBlock() || !loop_1_->GetPreHeaderBlock()) { return false; } // Check there are no breaks. if (context_->cfg()->preds(loop_0_->GetMergeBlock()->id()).size() != 1 || context_->cfg()->preds(loop_1_->GetMergeBlock()->id()).size() != 1) { return false; } // Check there are no continues. if (context_->cfg()->preds(loop_0_->GetContinueBlock()->id()).size() != 1 || context_->cfg()->preds(loop_1_->GetContinueBlock()->id()).size() != 1) { return false; } // |GetInductionVariables| returns all OpPhi in the header. Check that both // loops have exactly one that is used in the continue and condition blocks. std::vector inductions_0{}, inductions_1{}; loop_0_->GetInductionVariables(inductions_0); RemoveIfNotUsedContinueOrConditionBlock(&inductions_0, loop_0_); if (inductions_0.size() != 1) { return false; } induction_0_ = inductions_0.front(); loop_1_->GetInductionVariables(inductions_1); RemoveIfNotUsedContinueOrConditionBlock(&inductions_1, loop_1_); if (inductions_1.size() != 1) { return false; } induction_1_ = inductions_1.front(); if (!CheckInit()) { return false; } if (!CheckCondition()) { return false; } if (!CheckStep()) { return false; } // Check adjacency, |loop_0_| should come just before |loop_1_|. // There is always at least one block between loops, even if it's empty. // We'll check at most 2 preceding blocks. auto pre_header_1 = loop_1_->GetPreHeaderBlock(); std::vector block_to_check{}; block_to_check.push_back(pre_header_1); if (loop_0_->GetMergeBlock() != loop_1_->GetPreHeaderBlock()) { // Follow CFG for one more block. auto preds = context_->cfg()->preds(pre_header_1->id()); if (preds.size() == 1) { auto block = &*containing_function_->FindBlock(preds.front()); if (block == loop_0_->GetMergeBlock()) { block_to_check.push_back(block); } else { return false; } } else { return false; } } // Check that the separating blocks are either empty or only contains a store // to a local variable that is never read (left behind by // '--eliminate-local-multi-store'). Also allow OpPhi, since the loop could be // in LCSSA form. for (auto block : block_to_check) { for (auto& inst : *block) { if (inst.opcode() == spv::Op::OpStore) { // Get the definition of the target to check it's function scope so // there are no observable side effects. auto variable = context_->get_def_use_mgr()->GetDef(inst.GetSingleWordInOperand(0)); if (variable->opcode() != spv::Op::OpVariable || spv::StorageClass(variable->GetSingleWordInOperand(0)) != spv::StorageClass::Function) { return false; } // Check the target is never loaded. auto is_used = false; context_->get_def_use_mgr()->ForEachUse( inst.GetSingleWordInOperand(0), [&is_used](Instruction* use_inst, uint32_t) { if (use_inst->opcode() == spv::Op::OpLoad) { is_used = true; } }); if (is_used) { return false; } } else if (inst.opcode() == spv::Op::OpPhi) { if (inst.NumInOperands() != 2) { return false; } } else if (inst.opcode() != spv::Op::OpBranch) { return false; } } } return true; } // namespace opt bool LoopFusion::ContainsBarriersOrFunctionCalls(Loop* loop) { for (const auto& block : loop->GetBlocks()) { for (const auto& inst : *containing_function_->FindBlock(block)) { auto opcode = inst.opcode(); if (opcode == spv::Op::OpFunctionCall || opcode == spv::Op::OpControlBarrier || opcode == spv::Op::OpMemoryBarrier || opcode == spv::Op::OpTypeNamedBarrier || opcode == spv::Op::OpNamedBarrierInitialize || opcode == spv::Op::OpMemoryNamedBarrier) { return true; } } } return false; } bool LoopFusion::CheckInit() { int64_t loop_0_init; if (!loop_0_->GetInductionInitValue(induction_0_, &loop_0_init)) { return false; } int64_t loop_1_init; if (!loop_1_->GetInductionInitValue(induction_1_, &loop_1_init)) { return false; } if (loop_0_init != loop_1_init) { return false; } return true; } bool LoopFusion::CheckCondition() { auto condition_0 = loop_0_->GetConditionInst(); auto condition_1 = loop_1_->GetConditionInst(); if (!loop_0_->IsSupportedCondition(condition_0->opcode()) || !loop_1_->IsSupportedCondition(condition_1->opcode())) { return false; } if (condition_0->opcode() != condition_1->opcode()) { return false; } for (uint32_t i = 0; i < condition_0->NumInOperandWords(); ++i) { auto arg_0 = context_->get_def_use_mgr()->GetDef( condition_0->GetSingleWordInOperand(i)); auto arg_1 = context_->get_def_use_mgr()->GetDef( condition_1->GetSingleWordInOperand(i)); if (arg_0 == induction_0_ && arg_1 == induction_1_) { continue; } if (arg_0 == induction_0_ && arg_1 != induction_1_) { return false; } if (arg_1 == induction_1_ && arg_0 != induction_0_) { return false; } if (arg_0 != arg_1) { return false; } } return true; } bool LoopFusion::CheckStep() { auto scalar_analysis = context_->GetScalarEvolutionAnalysis(); SENode* induction_node_0 = scalar_analysis->SimplifyExpression( scalar_analysis->AnalyzeInstruction(induction_0_)); if (!induction_node_0->AsSERecurrentNode()) { return false; } SENode* induction_step_0 = induction_node_0->AsSERecurrentNode()->GetCoefficient(); if (!induction_step_0->AsSEConstantNode()) { return false; } SENode* induction_node_1 = scalar_analysis->SimplifyExpression( scalar_analysis->AnalyzeInstruction(induction_1_)); if (!induction_node_1->AsSERecurrentNode()) { return false; } SENode* induction_step_1 = induction_node_1->AsSERecurrentNode()->GetCoefficient(); if (!induction_step_1->AsSEConstantNode()) { return false; } if (*induction_step_0 != *induction_step_1) { return false; } return true; } std::map> LoopFusion::LocationToMemOps( const std::vector& mem_ops) { std::map> location_map{}; for (auto instruction : mem_ops) { auto access_location = context_->get_def_use_mgr()->GetDef( instruction->GetSingleWordInOperand(0)); while (access_location->opcode() == spv::Op::OpAccessChain) { access_location = context_->get_def_use_mgr()->GetDef( access_location->GetSingleWordInOperand(0)); } location_map[access_location].push_back(instruction); } return location_map; } std::pair, std::vector> LoopFusion::GetLoadsAndStoresInLoop(Loop* loop) { std::vector loads{}; std::vector stores{}; for (auto block_id : loop->GetBlocks()) { if (block_id == loop->GetContinueBlock()->id()) { continue; } for (auto& instruction : *containing_function_->FindBlock(block_id)) { if (instruction.opcode() == spv::Op::OpLoad) { loads.push_back(&instruction); } else if (instruction.opcode() == spv::Op::OpStore) { stores.push_back(&instruction); } } } return std::make_pair(loads, stores); } bool LoopFusion::IsUsedInLoop(Instruction* instruction, Loop* loop) { auto not_used = context_->get_def_use_mgr()->WhileEachUser( instruction, [this, loop](Instruction* user) { auto block_id = context_->get_instr_block(user)->id(); return !loop->IsInsideLoop(block_id); }); return !not_used; } bool LoopFusion::IsLegal() { assert(AreCompatible() && "Fusion can't be legal, loops are not compatible."); // Bail out if there are function calls as they could have side-effects that // cause dependencies or if there are any barriers. if (ContainsBarriersOrFunctionCalls(loop_0_) || ContainsBarriersOrFunctionCalls(loop_1_)) { return false; } std::vector phi_instructions{}; loop_0_->GetInductionVariables(phi_instructions); // Check no OpPhi in |loop_0_| is used in |loop_1_|. for (auto phi_instruction : phi_instructions) { if (IsUsedInLoop(phi_instruction, loop_1_)) { return false; } } // Check no LCSSA OpPhi in merge block of |loop_0_| is used in |loop_1_|. auto phi_used = false; loop_0_->GetMergeBlock()->ForEachPhiInst( [this, &phi_used](Instruction* phi_instruction) { phi_used |= IsUsedInLoop(phi_instruction, loop_1_); }); if (phi_used) { return false; } // Grab loads & stores from both loops. auto loads_stores_0 = GetLoadsAndStoresInLoop(loop_0_); auto loads_stores_1 = GetLoadsAndStoresInLoop(loop_1_); // Build memory location to operation maps. auto load_locs_0 = LocationToMemOps(std::get<0>(loads_stores_0)); auto store_locs_0 = LocationToMemOps(std::get<1>(loads_stores_0)); auto load_locs_1 = LocationToMemOps(std::get<0>(loads_stores_1)); auto store_locs_1 = LocationToMemOps(std::get<1>(loads_stores_1)); // Get the locations accessed in both loops. auto locations_0 = GetLocationsAccessed(store_locs_0, load_locs_0); auto locations_1 = GetLocationsAccessed(store_locs_1, load_locs_1); std::vector potential_clashes{}; std::set_intersection(std::begin(locations_0), std::end(locations_0), std::begin(locations_1), std::end(locations_1), std::back_inserter(potential_clashes)); // If the loops don't access the same variables, the fusion is legal. if (potential_clashes.empty()) { return true; } // Find variables that have at least one store. std::vector potential_clashes_with_stores{}; for (auto location : potential_clashes) { if (store_locs_0.find(location) != std::end(store_locs_0) || store_locs_1.find(location) != std::end(store_locs_1)) { potential_clashes_with_stores.push_back(location); } } // If there are only loads to the same variables, the fusion is legal. if (potential_clashes_with_stores.empty()) { return true; } // Else if loads and at least one store (across loops) to the same variable // there is a potential dependence and we need to check the dependence // distance. // Find all the loops in this loop nest for the dependency analysis. std::vector loops{}; // Find the parents. for (auto current_loop = loop_0_; current_loop != nullptr; current_loop = current_loop->GetParent()) { loops.push_back(current_loop); } auto this_loop_position = loops.size() - 1; std::reverse(std::begin(loops), std::end(loops)); // Find the children. CollectChildren(loop_0_, &loops); CollectChildren(loop_1_, &loops); // Check that any dependes created are legal. That means the fused loops do // not have any dependencies with dependence distance greater than 0 that did // not exist in the original loops. LoopDependenceAnalysis analysis(context_, loops); analysis.GetScalarEvolution()->AddLoopsToPretendAreTheSame( {loop_0_, loop_1_}); for (auto location : potential_clashes_with_stores) { // Analyse dependences from |loop_0_| to |loop_1_|. std::vector dependences; // Read-After-Write. GetDependences(&dependences, &analysis, store_locs_0[location], load_locs_1[location], loops.size()); // Write-After-Read. GetDependences(&dependences, &analysis, load_locs_0[location], store_locs_1[location], loops.size()); // Write-After-Write. GetDependences(&dependences, &analysis, store_locs_0[location], store_locs_1[location], loops.size()); // Check that the induction variables either don't appear in the subscripts // or the dependence distance is negative. for (const auto& dependence : dependences) { const auto& entry = dependence.GetEntries()[this_loop_position]; if ((entry.dependence_information == DistanceEntry::DependenceInformation::DISTANCE && entry.distance < 1) || (entry.dependence_information == DistanceEntry::DependenceInformation::IRRELEVANT)) { continue; } else { return false; } } } return true; } void ReplacePhiParentWith(Instruction* inst, uint32_t orig_block, uint32_t new_block) { if (inst->GetSingleWordInOperand(1) == orig_block) { inst->SetInOperand(1, {new_block}); } else { inst->SetInOperand(3, {new_block}); } } void LoopFusion::Fuse() { assert(AreCompatible() && "Can't fuse, loops aren't compatible"); assert(IsLegal() && "Can't fuse, illegal"); // Save the pointers/ids, won't be found in the middle of doing modifications. auto header_1 = loop_1_->GetHeaderBlock()->id(); auto condition_1 = loop_1_->FindConditionBlock()->id(); auto continue_1 = loop_1_->GetContinueBlock()->id(); auto continue_0 = loop_0_->GetContinueBlock()->id(); auto condition_block_of_0 = loop_0_->FindConditionBlock(); // Find the blocks whose branches need updating. auto first_block_of_1 = &*(++containing_function_->FindBlock(condition_1)); auto last_block_of_1 = &*(--containing_function_->FindBlock(continue_1)); auto last_block_of_0 = &*(--containing_function_->FindBlock(continue_0)); // Update the branch for |last_block_of_loop_0| to go to |first_block_of_1|. last_block_of_0->ForEachSuccessorLabel( [first_block_of_1](uint32_t* succ) { *succ = first_block_of_1->id(); }); // Update the branch for the |last_block_of_loop_1| to go to the continue // block of |loop_0_|. last_block_of_1->ForEachSuccessorLabel( [this](uint32_t* succ) { *succ = loop_0_->GetContinueBlock()->id(); }); // Update merge block id in the header of |loop_0_| to the merge block of // |loop_1_|. loop_0_->GetHeaderBlock()->ForEachInst([this](Instruction* inst) { if (inst->opcode() == spv::Op::OpLoopMerge) { inst->SetInOperand(0, {loop_1_->GetMergeBlock()->id()}); } }); // Update condition branch target in |loop_0_| to the merge block of // |loop_1_|. condition_block_of_0->ForEachInst([this](Instruction* inst) { if (inst->opcode() == spv::Op::OpBranchConditional) { auto loop_0_merge_block_id = loop_0_->GetMergeBlock()->id(); if (inst->GetSingleWordInOperand(1) == loop_0_merge_block_id) { inst->SetInOperand(1, {loop_1_->GetMergeBlock()->id()}); } else { inst->SetInOperand(2, {loop_1_->GetMergeBlock()->id()}); } } }); // Move OpPhi instructions not corresponding to the induction variable from // the header of |loop_1_| to the header of |loop_0_|. std::vector instructions_to_move{}; for (auto& instruction : *loop_1_->GetHeaderBlock()) { if (instruction.opcode() == spv::Op::OpPhi && &instruction != induction_1_) { instructions_to_move.push_back(&instruction); } } for (auto& it : instructions_to_move) { it->RemoveFromList(); it->InsertBefore(induction_0_); } // Update the OpPhi parents to the correct blocks in |loop_0_|. loop_0_->GetHeaderBlock()->ForEachPhiInst([this](Instruction* i) { ReplacePhiParentWith(i, loop_1_->GetPreHeaderBlock()->id(), loop_0_->GetPreHeaderBlock()->id()); ReplacePhiParentWith(i, loop_1_->GetContinueBlock()->id(), loop_0_->GetContinueBlock()->id()); }); // Update instruction to block mapping & DefUseManager. for (auto& phi_instruction : instructions_to_move) { context_->set_instr_block(phi_instruction, loop_0_->GetHeaderBlock()); context_->get_def_use_mgr()->AnalyzeInstUse(phi_instruction); } // Replace the uses of the induction variable of |loop_1_| with that the // induction variable of |loop_0_|. context_->ReplaceAllUsesWith(induction_1_->result_id(), induction_0_->result_id()); // Replace LCSSA OpPhi in merge block of |loop_0_|. loop_0_->GetMergeBlock()->ForEachPhiInst([this](Instruction* instruction) { context_->ReplaceAllUsesWith(instruction->result_id(), instruction->GetSingleWordInOperand(0)); }); // Update LCSSA OpPhi in merge block of |loop_1_|. loop_1_->GetMergeBlock()->ForEachPhiInst( [condition_block_of_0](Instruction* instruction) { instruction->SetInOperand(1, {condition_block_of_0->id()}); }); // Move the continue block of |loop_0_| after the last block of |loop_1_|. containing_function_->MoveBasicBlockToAfter(continue_0, last_block_of_1); // Gather all instructions to be killed from |loop_1_| (induction variable // initialisation, header, condition and continue blocks). std::vector instr_to_delete{}; AddInstructionsInBlock(&instr_to_delete, loop_1_->GetPreHeaderBlock()); AddInstructionsInBlock(&instr_to_delete, loop_1_->GetHeaderBlock()); AddInstructionsInBlock(&instr_to_delete, loop_1_->FindConditionBlock()); AddInstructionsInBlock(&instr_to_delete, loop_1_->GetContinueBlock()); // There was an additional empty block between the loops, kill that too. if (loop_0_->GetMergeBlock() != loop_1_->GetPreHeaderBlock()) { AddInstructionsInBlock(&instr_to_delete, loop_0_->GetMergeBlock()); } // Update the CFG, so it wouldn't need invalidating. auto cfg = context_->cfg(); cfg->ForgetBlock(loop_1_->GetPreHeaderBlock()); cfg->ForgetBlock(loop_1_->GetHeaderBlock()); cfg->ForgetBlock(loop_1_->FindConditionBlock()); cfg->ForgetBlock(loop_1_->GetContinueBlock()); if (loop_0_->GetMergeBlock() != loop_1_->GetPreHeaderBlock()) { cfg->ForgetBlock(loop_0_->GetMergeBlock()); } cfg->RemoveEdge(last_block_of_0->id(), loop_0_->GetContinueBlock()->id()); cfg->AddEdge(last_block_of_0->id(), first_block_of_1->id()); cfg->AddEdge(last_block_of_1->id(), loop_0_->GetContinueBlock()->id()); cfg->AddEdge(loop_0_->GetContinueBlock()->id(), loop_1_->GetHeaderBlock()->id()); cfg->AddEdge(condition_block_of_0->id(), loop_1_->GetMergeBlock()->id()); // Update DefUseManager. auto def_use_mgr = context_->get_def_use_mgr(); // Uses of labels that are in updated branches need analysing. def_use_mgr->AnalyzeInstUse(last_block_of_0->terminator()); def_use_mgr->AnalyzeInstUse(last_block_of_1->terminator()); def_use_mgr->AnalyzeInstUse(loop_0_->GetHeaderBlock()->GetLoopMergeInst()); def_use_mgr->AnalyzeInstUse(condition_block_of_0->terminator()); // Update the LoopDescriptor, so it wouldn't need invalidating. auto ld = context_->GetLoopDescriptor(containing_function_); // Create a copy, so the iterator wouldn't be invalidated. std::vector loops_to_add_remove{}; for (auto child_loop : *loop_1_) { loops_to_add_remove.push_back(child_loop); } for (auto child_loop : loops_to_add_remove) { loop_1_->RemoveChildLoop(child_loop); loop_0_->AddNestedLoop(child_loop); } auto loop_1_blocks = loop_1_->GetBlocks(); for (auto block : loop_1_blocks) { loop_1_->RemoveBasicBlock(block); if (block != header_1 && block != condition_1 && block != continue_1) { loop_0_->AddBasicBlock(block); if ((*ld)[block] == loop_1_) { ld->SetBasicBlockToLoop(block, loop_0_); } } if ((*ld)[block] == loop_1_) { ld->ForgetBasicBlock(block); } } loop_1_->RemoveBasicBlock(loop_1_->GetPreHeaderBlock()->id()); ld->ForgetBasicBlock(loop_1_->GetPreHeaderBlock()->id()); if (loop_0_->GetMergeBlock() != loop_1_->GetPreHeaderBlock()) { loop_0_->RemoveBasicBlock(loop_0_->GetMergeBlock()->id()); ld->ForgetBasicBlock(loop_0_->GetMergeBlock()->id()); } loop_0_->SetMergeBlock(loop_1_->GetMergeBlock()); loop_1_->ClearBlocks(); ld->RemoveLoop(loop_1_); // Kill unnecessary instructions and remove all empty blocks. for (auto inst : instr_to_delete) { context_->KillInst(inst); } containing_function_->RemoveEmptyBlocks(); // Invalidate analyses. context_->InvalidateAnalysesExceptFor( IRContext::Analysis::kAnalysisInstrToBlockMapping | IRContext::Analysis::kAnalysisLoopAnalysis | IRContext::Analysis::kAnalysisDefUse | IRContext::Analysis::kAnalysisCFG); } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/loop_fusion.h000066400000000000000000000074411475742701700233460ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_LOOP_FUSION_H_ #define SOURCE_OPT_LOOP_FUSION_H_ #include #include #include #include #include "source/opt/ir_context.h" #include "source/opt/loop_descriptor.h" #include "source/opt/loop_utils.h" #include "source/opt/scalar_analysis.h" namespace spvtools { namespace opt { class LoopFusion { public: LoopFusion(IRContext* context, Loop* loop_0, Loop* loop_1) : context_(context), loop_0_(loop_0), loop_1_(loop_1), containing_function_(loop_0->GetHeaderBlock()->GetParent()) {} // Checks if the |loop_0| and |loop_1| are compatible for fusion. // That means: // * they both have one induction variable // * they have the same upper and lower bounds // - same initial value // - same condition // * they have the same update step // * they are adjacent, with |loop_0| appearing before |loop_1| // * there are no break/continue in either of them // * they both have pre-header blocks (required for ScalarEvolutionAnalysis // and dependence checking). bool AreCompatible(); // Checks if compatible |loop_0| and |loop_1| are legal to fuse. // * fused loops do not have any dependencies with dependence distance greater // than 0 that did not exist in the original loops. // * there are no function calls in the loops (could have side-effects) bool IsLegal(); // Perform the actual fusion of |loop_0_| and |loop_1_|. The loops have to be // compatible and the fusion has to be legal. void Fuse(); private: // Check that the initial values are the same. bool CheckInit(); // Check that the conditions are the same. bool CheckCondition(); // Check that the steps are the same. bool CheckStep(); // Returns |true| if |instruction| is used in the continue or condition block // of |loop|. bool UsedInContinueOrConditionBlock(Instruction* instruction, Loop* loop); // Remove entries in |instructions| that are not used in the continue or // condition block of |loop|. void RemoveIfNotUsedContinueOrConditionBlock( std::vector* instructions, Loop* loop); // Returns |true| if |instruction| is used in |loop|. bool IsUsedInLoop(Instruction* instruction, Loop* loop); // Returns |true| if |loop| has at least one barrier or function call. bool ContainsBarriersOrFunctionCalls(Loop* loop); // Get all instructions in the |loop| (except in the latch block) that have // the opcode |opcode|. std::pair, std::vector> GetLoadsAndStoresInLoop(Loop* loop); // Given a vector of memory operations (OpLoad/OpStore), constructs a map from // variables to the loads/stores that those variables. std::map> LocationToMemOps( const std::vector& mem_ops); IRContext* context_; // The original loops to be fused. Loop* loop_0_; Loop* loop_1_; // The function that contains |loop_0_| and |loop_1_|. Function* containing_function_ = nullptr; // The induction variables for |loop_0_| and |loop_1_|. Instruction* induction_0_ = nullptr; Instruction* induction_1_ = nullptr; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_LOOP_FUSION_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/loop_fusion_pass.cpp000066400000000000000000000042631475742701700247260ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/loop_fusion_pass.h" #include "source/opt/loop_descriptor.h" #include "source/opt/loop_fusion.h" #include "source/opt/register_pressure.h" namespace spvtools { namespace opt { Pass::Status LoopFusionPass::Process() { bool modified = false; Module* module = context()->module(); // Process each function in the module for (Function& f : *module) { modified |= ProcessFunction(&f); } return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } bool LoopFusionPass::ProcessFunction(Function* function) { LoopDescriptor& ld = *context()->GetLoopDescriptor(function); // If a loop doesn't have a preheader needs then it needs to be created. Make // sure to return Status::SuccessWithChange in that case. auto modified = ld.CreatePreHeaderBlocksIfMissing(); // TODO(tremmelg): Could the only loop that |loop| could possibly be fused be // picked out so don't have to check every loop for (auto& loop_0 : ld) { for (auto& loop_1 : ld) { LoopFusion fusion(context(), &loop_0, &loop_1); if (fusion.AreCompatible() && fusion.IsLegal()) { RegisterLiveness liveness(context(), function); RegisterLiveness::RegionRegisterLiveness reg_pressure{}; liveness.SimulateFusion(loop_0, loop_1, ®_pressure); if (reg_pressure.used_registers_ <= max_registers_per_loop_) { fusion.Fuse(); // Recurse, as the current iterators will have been invalidated. ProcessFunction(function); return true; } } } } return modified; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/loop_fusion_pass.h000066400000000000000000000034761475742701700244000ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_LOOP_FUSION_PASS_H_ #define SOURCE_OPT_LOOP_FUSION_PASS_H_ #include "source/opt/pass.h" namespace spvtools { namespace opt { // Implements a loop fusion pass. // This pass will look for adjacent loops that are compatible and legal to be // fused. It will fuse all such loops as long as the register usage for the // fused loop stays under the threshold defined by |max_registers_per_loop|. class LoopFusionPass : public Pass { public: explicit LoopFusionPass(size_t max_registers_per_loop) : Pass(), max_registers_per_loop_(max_registers_per_loop) {} const char* name() const override { return "loop-fusion"; } // Processes the given |module|. Returns Status::Failure if errors occur when // processing. Returns the corresponding Status::Success if processing is // successful to indicate whether changes have been made to the module. Status Process() override; private: // Fuse loops in |function| if compatible, legal and the fused loop won't use // too many registers. bool ProcessFunction(Function* function); // The maximum number of registers a fused loop is allowed to use. size_t max_registers_per_loop_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_LOOP_FUSION_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/loop_peeling.cpp000066400000000000000000001127741475742701700240270ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/loop_peeling.h" #include #include #include #include #include "source/opt/ir_builder.h" #include "source/opt/ir_context.h" #include "source/opt/loop_descriptor.h" #include "source/opt/loop_utils.h" #include "source/opt/scalar_analysis.h" #include "source/opt/scalar_analysis_nodes.h" namespace spvtools { namespace opt { namespace { // Gather the set of blocks for all the path from |entry| to |root|. void GetBlocksInPath(uint32_t block, uint32_t entry, std::unordered_set* blocks_in_path, const CFG& cfg) { for (uint32_t pid : cfg.preds(block)) { if (blocks_in_path->insert(pid).second) { if (pid != entry) { GetBlocksInPath(pid, entry, blocks_in_path, cfg); } } } } } // namespace size_t LoopPeelingPass::code_grow_threshold_ = 1000; void LoopPeeling::DuplicateAndConnectLoop( LoopUtils::LoopCloningResult* clone_results) { CFG& cfg = *context_->cfg(); analysis::DefUseManager* def_use_mgr = context_->get_def_use_mgr(); assert(CanPeelLoop() && "Cannot peel loop!"); std::vector ordered_loop_blocks; // TODO(1841): Handle failure to create pre-header. BasicBlock* pre_header = loop_->GetOrCreatePreHeaderBlock(); loop_->ComputeLoopStructuredOrder(&ordered_loop_blocks); cloned_loop_ = loop_utils_.CloneLoop(clone_results, ordered_loop_blocks); // Add the basic block to the function. Function::iterator it = loop_utils_.GetFunction()->FindBlock(pre_header->id()); assert(it != loop_utils_.GetFunction()->end() && "Pre-header not found in the function."); loop_utils_.GetFunction()->AddBasicBlocks( clone_results->cloned_bb_.begin(), clone_results->cloned_bb_.end(), ++it); // Make the |loop_|'s preheader the |cloned_loop_| one. BasicBlock* cloned_header = cloned_loop_->GetHeaderBlock(); pre_header->ForEachSuccessorLabel( [cloned_header](uint32_t* succ) { *succ = cloned_header->id(); }); // Update cfg. cfg.RemoveEdge(pre_header->id(), loop_->GetHeaderBlock()->id()); cloned_loop_->SetPreHeaderBlock(pre_header); loop_->SetPreHeaderBlock(nullptr); // When cloning the loop, we didn't cloned the merge block, so currently // |cloned_loop_| shares the same block as |loop_|. // We mutate all branches from |cloned_loop_| block to |loop_|'s merge into a // branch to |loop_|'s header (so header will also be the merge of // |cloned_loop_|). uint32_t cloned_loop_exit = 0; for (uint32_t pred_id : cfg.preds(loop_->GetMergeBlock()->id())) { if (loop_->IsInsideLoop(pred_id)) continue; BasicBlock* bb = cfg.block(pred_id); assert(cloned_loop_exit == 0 && "The loop has multiple exits."); cloned_loop_exit = bb->id(); bb->ForEachSuccessorLabel([this](uint32_t* succ) { if (*succ == loop_->GetMergeBlock()->id()) *succ = loop_->GetHeaderBlock()->id(); }); } // Update cfg. cfg.RemoveNonExistingEdges(loop_->GetMergeBlock()->id()); cfg.AddEdge(cloned_loop_exit, loop_->GetHeaderBlock()->id()); // Patch the phi of the original loop header: // - Set the loop entry branch to come from the cloned loop exit block; // - Set the initial value of the phi using the corresponding cloned loop // exit values. // // We patch the iterating value initializers of the original loop using the // corresponding cloned loop exit values. Connects the cloned loop iterating // values to the original loop. This make sure that the initial value of the // second loop starts with the last value of the first loop. // // For example, loops like: // // int z = 0; // for (int i = 0; i++ < M; i += cst1) { // if (cond) // z += cst2; // } // // Will become: // // int z = 0; // int i = 0; // for (; i++ < M; i += cst1) { // if (cond) // z += cst2; // } // for (; i++ < M; i += cst1) { // if (cond) // z += cst2; // } loop_->GetHeaderBlock()->ForEachPhiInst([cloned_loop_exit, def_use_mgr, clone_results, this](Instruction* phi) { for (uint32_t i = 0; i < phi->NumInOperands(); i += 2) { if (!loop_->IsInsideLoop(phi->GetSingleWordInOperand(i + 1))) { phi->SetInOperand(i, {clone_results->value_map_.at( exit_value_.at(phi->result_id())->result_id())}); phi->SetInOperand(i + 1, {cloned_loop_exit}); def_use_mgr->AnalyzeInstUse(phi); return; } } }); // Force the creation of a new preheader for the original loop and set it as // the merge block for the cloned loop. // TODO(1841): Handle failure to create pre-header. cloned_loop_->SetMergeBlock(loop_->GetOrCreatePreHeaderBlock()); } void LoopPeeling::InsertCanonicalInductionVariable( LoopUtils::LoopCloningResult* clone_results) { if (original_loop_canonical_induction_variable_) { canonical_induction_variable_ = context_->get_def_use_mgr()->GetDef(clone_results->value_map_.at( original_loop_canonical_induction_variable_->result_id())); return; } BasicBlock::iterator insert_point = GetClonedLoop()->GetLatchBlock()->tail(); if (GetClonedLoop()->GetLatchBlock()->GetMergeInst()) { --insert_point; } InstructionBuilder builder( context_, &*insert_point, IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); Instruction* uint_1_cst = builder.GetIntConstant(1, int_type_->IsSigned()); // Create the increment. // Note that we do "1 + 1" here, one of the operand should the phi // value but we don't have it yet. The operand will be set latter. Instruction* iv_inc = builder.AddIAdd( uint_1_cst->type_id(), uint_1_cst->result_id(), uint_1_cst->result_id()); builder.SetInsertPoint(&*GetClonedLoop()->GetHeaderBlock()->begin()); canonical_induction_variable_ = builder.AddPhi( uint_1_cst->type_id(), {builder.GetIntConstant(0, int_type_->IsSigned())->result_id(), GetClonedLoop()->GetPreHeaderBlock()->id(), iv_inc->result_id(), GetClonedLoop()->GetLatchBlock()->id()}); // Connect everything. iv_inc->SetInOperand(0, {canonical_induction_variable_->result_id()}); // Update def/use manager. context_->get_def_use_mgr()->AnalyzeInstUse(iv_inc); // If do-while form, use the incremented value. if (do_while_form_) { canonical_induction_variable_ = iv_inc; } } void LoopPeeling::GetIteratorUpdateOperations( const Loop* loop, Instruction* iterator, std::unordered_set* operations) { analysis::DefUseManager* def_use_mgr = context_->get_def_use_mgr(); operations->insert(iterator); iterator->ForEachInId([def_use_mgr, loop, operations, this](uint32_t* id) { Instruction* insn = def_use_mgr->GetDef(*id); if (insn->opcode() == spv::Op::OpLabel) { return; } if (operations->count(insn)) { return; } if (!loop->IsInsideLoop(insn)) { return; } GetIteratorUpdateOperations(loop, insn, operations); }); } bool LoopPeeling::IsConditionCheckSideEffectFree() const { CFG& cfg = *context_->cfg(); // The "do-while" form does not cause issues, the algorithm takes into account // the first iteration. if (!do_while_form_) { uint32_t condition_block_id = cfg.preds(loop_->GetMergeBlock()->id())[0]; std::unordered_set blocks_in_path; blocks_in_path.insert(condition_block_id); GetBlocksInPath(condition_block_id, loop_->GetHeaderBlock()->id(), &blocks_in_path, cfg); for (uint32_t bb_id : blocks_in_path) { BasicBlock* bb = cfg.block(bb_id); if (!bb->WhileEachInst([this](Instruction* insn) { if (insn->IsBranch()) return true; switch (insn->opcode()) { case spv::Op::OpLabel: case spv::Op::OpSelectionMerge: case spv::Op::OpLoopMerge: return true; default: break; } return context_->IsCombinatorInstruction(insn); })) { return false; } } } return true; } void LoopPeeling::GetIteratingExitValues() { CFG& cfg = *context_->cfg(); loop_->GetHeaderBlock()->ForEachPhiInst( [this](Instruction* phi) { exit_value_[phi->result_id()] = nullptr; }); if (!loop_->GetMergeBlock()) { return; } if (cfg.preds(loop_->GetMergeBlock()->id()).size() != 1) { return; } analysis::DefUseManager* def_use_mgr = context_->get_def_use_mgr(); uint32_t condition_block_id = cfg.preds(loop_->GetMergeBlock()->id())[0]; auto& header_pred = cfg.preds(loop_->GetHeaderBlock()->id()); do_while_form_ = std::find(header_pred.begin(), header_pred.end(), condition_block_id) != header_pred.end(); if (do_while_form_) { loop_->GetHeaderBlock()->ForEachPhiInst( [condition_block_id, def_use_mgr, this](Instruction* phi) { std::unordered_set operations; for (uint32_t i = 0; i < phi->NumInOperands(); i += 2) { if (condition_block_id == phi->GetSingleWordInOperand(i + 1)) { exit_value_[phi->result_id()] = def_use_mgr->GetDef(phi->GetSingleWordInOperand(i)); } } }); } else { DominatorTree* dom_tree = &context_->GetDominatorAnalysis(loop_utils_.GetFunction()) ->GetDomTree(); BasicBlock* condition_block = cfg.block(condition_block_id); loop_->GetHeaderBlock()->ForEachPhiInst( [dom_tree, condition_block, this](Instruction* phi) { std::unordered_set operations; // Not the back-edge value, check if the phi instruction is the only // possible candidate. GetIteratorUpdateOperations(loop_, phi, &operations); for (Instruction* insn : operations) { if (insn == phi) { continue; } if (dom_tree->Dominates(context_->get_instr_block(insn), condition_block)) { return; } } exit_value_[phi->result_id()] = phi; }); } } void LoopPeeling::FixExitCondition( const std::function& condition_builder) { CFG& cfg = *context_->cfg(); uint32_t condition_block_id = 0; for (uint32_t id : cfg.preds(GetClonedLoop()->GetMergeBlock()->id())) { if (GetClonedLoop()->IsInsideLoop(id)) { condition_block_id = id; break; } } assert(condition_block_id != 0 && "2nd loop in improperly connected"); BasicBlock* condition_block = cfg.block(condition_block_id); Instruction* exit_condition = condition_block->terminator(); assert(exit_condition->opcode() == spv::Op::OpBranchConditional); BasicBlock::iterator insert_point = condition_block->tail(); if (condition_block->GetMergeInst()) { --insert_point; } exit_condition->SetInOperand(0, {condition_builder(&*insert_point)}); uint32_t to_continue_block_idx = GetClonedLoop()->IsInsideLoop(exit_condition->GetSingleWordInOperand(1)) ? 1 : 2; exit_condition->SetInOperand( 1, {exit_condition->GetSingleWordInOperand(to_continue_block_idx)}); exit_condition->SetInOperand(2, {GetClonedLoop()->GetMergeBlock()->id()}); // Update def/use manager. context_->get_def_use_mgr()->AnalyzeInstUse(exit_condition); } BasicBlock* LoopPeeling::CreateBlockBefore(BasicBlock* bb) { analysis::DefUseManager* def_use_mgr = context_->get_def_use_mgr(); CFG& cfg = *context_->cfg(); assert(cfg.preds(bb->id()).size() == 1 && "More than one predecessor"); // TODO(1841): Handle id overflow. std::unique_ptr new_bb = MakeUnique(std::unique_ptr(new Instruction( context_, spv::Op::OpLabel, 0, context_->TakeNextId(), {}))); // Update the loop descriptor. Loop* in_loop = (*loop_utils_.GetLoopDescriptor())[bb]; if (in_loop) { in_loop->AddBasicBlock(new_bb.get()); loop_utils_.GetLoopDescriptor()->SetBasicBlockToLoop(new_bb->id(), in_loop); } context_->set_instr_block(new_bb->GetLabelInst(), new_bb.get()); def_use_mgr->AnalyzeInstDefUse(new_bb->GetLabelInst()); BasicBlock* bb_pred = cfg.block(cfg.preds(bb->id())[0]); bb_pred->tail()->ForEachInId([bb, &new_bb](uint32_t* id) { if (*id == bb->id()) { *id = new_bb->id(); } }); cfg.RemoveEdge(bb_pred->id(), bb->id()); cfg.AddEdge(bb_pred->id(), new_bb->id()); def_use_mgr->AnalyzeInstUse(&*bb_pred->tail()); // Update the incoming branch. bb->ForEachPhiInst([&new_bb, def_use_mgr](Instruction* phi) { phi->SetInOperand(1, {new_bb->id()}); def_use_mgr->AnalyzeInstUse(phi); }); InstructionBuilder( context_, new_bb.get(), IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping) .AddBranch(bb->id()); cfg.RegisterBlock(new_bb.get()); // Add the basic block to the function. Function::iterator it = loop_utils_.GetFunction()->FindBlock(bb->id()); assert(it != loop_utils_.GetFunction()->end() && "Basic block not found in the function."); BasicBlock* ret = new_bb.get(); loop_utils_.GetFunction()->AddBasicBlock(std::move(new_bb), it); return ret; } BasicBlock* LoopPeeling::ProtectLoop(Loop* loop, Instruction* condition, BasicBlock* if_merge) { // TODO(1841): Handle failure to create pre-header. BasicBlock* if_block = loop->GetOrCreatePreHeaderBlock(); // Will no longer be a pre-header because of the if. loop->SetPreHeaderBlock(nullptr); // Kill the branch to the header. context_->KillInst(&*if_block->tail()); InstructionBuilder builder( context_, if_block, IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); builder.AddConditionalBranch(condition->result_id(), loop->GetHeaderBlock()->id(), if_merge->id(), if_merge->id()); return if_block; } void LoopPeeling::PeelBefore(uint32_t peel_factor) { assert(CanPeelLoop() && "Cannot peel loop"); LoopUtils::LoopCloningResult clone_results; // Clone the loop and insert the cloned one before the loop. DuplicateAndConnectLoop(&clone_results); // Add a canonical induction variable "canonical_induction_variable_". InsertCanonicalInductionVariable(&clone_results); InstructionBuilder builder( context_, &*cloned_loop_->GetPreHeaderBlock()->tail(), IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); Instruction* factor = builder.GetIntConstant(peel_factor, int_type_->IsSigned()); Instruction* has_remaining_iteration = builder.AddLessThan( factor->result_id(), loop_iteration_count_->result_id()); Instruction* max_iteration = builder.AddSelect( factor->type_id(), has_remaining_iteration->result_id(), factor->result_id(), loop_iteration_count_->result_id()); // Change the exit condition of the cloned loop to be (exit when become // false): // "canonical_induction_variable_" < min("factor", "loop_iteration_count_") FixExitCondition([max_iteration, this](Instruction* insert_before_point) { return InstructionBuilder(context_, insert_before_point, IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping) .AddLessThan(canonical_induction_variable_->result_id(), max_iteration->result_id()) ->result_id(); }); // "Protect" the second loop: the second loop can only be executed if // |has_remaining_iteration| is true (i.e. factor < loop_iteration_count_). BasicBlock* if_merge_block = loop_->GetMergeBlock(); loop_->SetMergeBlock(CreateBlockBefore(loop_->GetMergeBlock())); // Prevent the second loop from being executed if we already executed all the // required iterations. BasicBlock* if_block = ProtectLoop(loop_, has_remaining_iteration, if_merge_block); // Patch the phi of the merge block. if_merge_block->ForEachPhiInst( [&clone_results, if_block, this](Instruction* phi) { // if_merge_block had previously only 1 predecessor. uint32_t incoming_value = phi->GetSingleWordInOperand(0); auto def_in_loop = clone_results.value_map_.find(incoming_value); if (def_in_loop != clone_results.value_map_.end()) incoming_value = def_in_loop->second; phi->AddOperand( {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {incoming_value}}); phi->AddOperand( {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {if_block->id()}}); context_->get_def_use_mgr()->AnalyzeInstUse(phi); }); context_->InvalidateAnalysesExceptFor( IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisLoopAnalysis | IRContext::kAnalysisCFG); } void LoopPeeling::PeelAfter(uint32_t peel_factor) { assert(CanPeelLoop() && "Cannot peel loop"); LoopUtils::LoopCloningResult clone_results; // Clone the loop and insert the cloned one before the loop. DuplicateAndConnectLoop(&clone_results); // Add a canonical induction variable "canonical_induction_variable_". InsertCanonicalInductionVariable(&clone_results); InstructionBuilder builder( context_, &*cloned_loop_->GetPreHeaderBlock()->tail(), IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); Instruction* factor = builder.GetIntConstant(peel_factor, int_type_->IsSigned()); Instruction* has_remaining_iteration = builder.AddLessThan( factor->result_id(), loop_iteration_count_->result_id()); // Change the exit condition of the cloned loop to be (exit when become // false): // "canonical_induction_variable_" + "factor" < "loop_iteration_count_" FixExitCondition([factor, this](Instruction* insert_before_point) { InstructionBuilder cond_builder( context_, insert_before_point, IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); // Build the following check: canonical_induction_variable_ + factor < // iteration_count return cond_builder .AddLessThan(cond_builder .AddIAdd(canonical_induction_variable_->type_id(), canonical_induction_variable_->result_id(), factor->result_id()) ->result_id(), loop_iteration_count_->result_id()) ->result_id(); }); // "Protect" the first loop: the first loop can only be executed if // factor < loop_iteration_count_. // The original loop's pre-header was the cloned loop merge block. GetClonedLoop()->SetMergeBlock( CreateBlockBefore(GetOriginalLoop()->GetPreHeaderBlock())); // Use the second loop preheader as if merge block. // Prevent the first loop if only the peeled loop needs it. BasicBlock* if_block = ProtectLoop(cloned_loop_, has_remaining_iteration, GetOriginalLoop()->GetPreHeaderBlock()); // Patch the phi of the header block. // We added an if to enclose the first loop and because the phi node are // connected to the exit value of the first loop, the definition no longer // dominate the preheader. // We had to the preheader (our if merge block) the required phi instruction // and patch the header phi. GetOriginalLoop()->GetHeaderBlock()->ForEachPhiInst( [&clone_results, if_block, this](Instruction* phi) { analysis::DefUseManager* def_use_mgr = context_->get_def_use_mgr(); auto find_value_idx = [](Instruction* phi_inst, Loop* loop) { uint32_t preheader_value_idx = !loop->IsInsideLoop(phi_inst->GetSingleWordInOperand(1)) ? 0 : 2; return preheader_value_idx; }; Instruction* cloned_phi = def_use_mgr->GetDef(clone_results.value_map_.at(phi->result_id())); uint32_t cloned_preheader_value = cloned_phi->GetSingleWordInOperand( find_value_idx(cloned_phi, GetClonedLoop())); Instruction* new_phi = InstructionBuilder(context_, &*GetOriginalLoop()->GetPreHeaderBlock()->tail(), IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping) .AddPhi(phi->type_id(), {phi->GetSingleWordInOperand( find_value_idx(phi, GetOriginalLoop())), GetClonedLoop()->GetMergeBlock()->id(), cloned_preheader_value, if_block->id()}); phi->SetInOperand(find_value_idx(phi, GetOriginalLoop()), {new_phi->result_id()}); def_use_mgr->AnalyzeInstUse(phi); }); context_->InvalidateAnalysesExceptFor( IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisLoopAnalysis | IRContext::kAnalysisCFG); } Pass::Status LoopPeelingPass::Process() { bool modified = false; Module* module = context()->module(); // Process each function in the module for (Function& f : *module) { modified |= ProcessFunction(&f); } return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } bool LoopPeelingPass::ProcessFunction(Function* f) { bool modified = false; LoopDescriptor& loop_descriptor = *context()->GetLoopDescriptor(f); std::vector to_process_loop; to_process_loop.reserve(loop_descriptor.NumLoops()); for (Loop& l : loop_descriptor) { to_process_loop.push_back(&l); } ScalarEvolutionAnalysis scev_analysis(context()); for (Loop* loop : to_process_loop) { CodeMetrics loop_size; loop_size.Analyze(*loop); auto try_peel = [&loop_size, &modified, this](Loop* loop_to_peel) -> Loop* { if (!loop_to_peel->IsLCSSA()) { LoopUtils(context(), loop_to_peel).MakeLoopClosedSSA(); } bool peeled_loop; Loop* still_peelable_loop; std::tie(peeled_loop, still_peelable_loop) = ProcessLoop(loop_to_peel, &loop_size); if (peeled_loop) { modified = true; } return still_peelable_loop; }; Loop* still_peelable_loop = try_peel(loop); // The pass is working out the maximum factor by which a loop can be peeled. // If the loop can potentially be peeled again, then there is only one // possible direction, so only one call is still needed. if (still_peelable_loop) { try_peel(loop); } } return modified; } std::pair LoopPeelingPass::ProcessLoop(Loop* loop, CodeMetrics* loop_size) { ScalarEvolutionAnalysis* scev_analysis = context()->GetScalarEvolutionAnalysis(); // Default values for bailing out. std::pair bail_out{false, nullptr}; BasicBlock* exit_block = loop->FindConditionBlock(); if (!exit_block) { return bail_out; } Instruction* exiting_iv = loop->FindConditionVariable(exit_block); if (!exiting_iv) { return bail_out; } size_t iterations = 0; if (!loop->FindNumberOfIterations(exiting_iv, &*exit_block->tail(), &iterations)) { return bail_out; } if (!iterations) { return bail_out; } Instruction* canonical_induction_variable = nullptr; loop->GetHeaderBlock()->WhileEachPhiInst([&canonical_induction_variable, scev_analysis, this](Instruction* insn) { if (const SERecurrentNode* iv = scev_analysis->AnalyzeInstruction(insn)->AsSERecurrentNode()) { const SEConstantNode* offset = iv->GetOffset()->AsSEConstantNode(); const SEConstantNode* coeff = iv->GetCoefficient()->AsSEConstantNode(); if (offset && coeff && offset->FoldToSingleValue() == 0 && coeff->FoldToSingleValue() == 1) { if (context()->get_type_mgr()->GetType(insn->type_id())->AsInteger()) { canonical_induction_variable = insn; return false; } } } return true; }); bool is_signed = canonical_induction_variable ? context() ->get_type_mgr() ->GetType(canonical_induction_variable->type_id()) ->AsInteger() ->IsSigned() : false; LoopPeeling peeler( loop, InstructionBuilder( context(), loop->GetHeaderBlock(), IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping) .GetIntConstant(static_cast(iterations), is_signed), canonical_induction_variable); if (!peeler.CanPeelLoop()) { return bail_out; } // For each basic block in the loop, check if it can be peeled. If it // can, get the direction (before/after) and by which factor. LoopPeelingInfo peel_info(loop, iterations, scev_analysis); uint32_t peel_before_factor = 0; uint32_t peel_after_factor = 0; for (uint32_t block : loop->GetBlocks()) { if (block == exit_block->id()) { continue; } BasicBlock* bb = cfg()->block(block); PeelDirection direction; uint32_t factor; std::tie(direction, factor) = peel_info.GetPeelingInfo(bb); if (direction == PeelDirection::kNone) { continue; } if (direction == PeelDirection::kBefore) { peel_before_factor = std::max(peel_before_factor, factor); } else { assert(direction == PeelDirection::kAfter); peel_after_factor = std::max(peel_after_factor, factor); } } PeelDirection direction = PeelDirection::kNone; uint32_t factor = 0; // Find which direction we should peel. if (peel_before_factor) { factor = peel_before_factor; direction = PeelDirection::kBefore; } if (peel_after_factor) { if (peel_before_factor < peel_after_factor) { // Favor a peel after here and give the peel before another shot later. factor = peel_after_factor; direction = PeelDirection::kAfter; } } // Do the peel if we can. if (direction == PeelDirection::kNone) return bail_out; // This does not take into account branch elimination opportunities and // the unrolling. It assumes the peeled loop will be unrolled as well. if (factor * loop_size->roi_size_ > code_grow_threshold_) { return bail_out; } loop_size->roi_size_ *= factor; // Find if a loop should be peeled again. Loop* extra_opportunity = nullptr; if (direction == PeelDirection::kBefore) { peeler.PeelBefore(factor); if (stats_) { stats_->peeled_loops_.emplace_back(loop, PeelDirection::kBefore, factor); } if (peel_after_factor) { // We could have peeled after, give it another try. extra_opportunity = peeler.GetOriginalLoop(); } } else { peeler.PeelAfter(factor); if (stats_) { stats_->peeled_loops_.emplace_back(loop, PeelDirection::kAfter, factor); } if (peel_before_factor) { // We could have peeled before, give it another try. extra_opportunity = peeler.GetClonedLoop(); } } return {true, extra_opportunity}; } uint32_t LoopPeelingPass::LoopPeelingInfo::GetFirstLoopInvariantOperand( Instruction* condition) const { for (uint32_t i = 0; i < condition->NumInOperands(); i++) { BasicBlock* bb = context_->get_instr_block(condition->GetSingleWordInOperand(i)); if (bb && loop_->IsInsideLoop(bb)) { return condition->GetSingleWordInOperand(i); } } return 0; } uint32_t LoopPeelingPass::LoopPeelingInfo::GetFirstNonLoopInvariantOperand( Instruction* condition) const { for (uint32_t i = 0; i < condition->NumInOperands(); i++) { BasicBlock* bb = context_->get_instr_block(condition->GetSingleWordInOperand(i)); if (!bb || !loop_->IsInsideLoop(bb)) { return condition->GetSingleWordInOperand(i); } } return 0; } static bool IsHandledCondition(spv::Op opcode) { switch (opcode) { case spv::Op::OpIEqual: case spv::Op::OpINotEqual: case spv::Op::OpUGreaterThan: case spv::Op::OpSGreaterThan: case spv::Op::OpUGreaterThanEqual: case spv::Op::OpSGreaterThanEqual: case spv::Op::OpULessThan: case spv::Op::OpSLessThan: case spv::Op::OpULessThanEqual: case spv::Op::OpSLessThanEqual: return true; default: return false; } } LoopPeelingPass::LoopPeelingInfo::Direction LoopPeelingPass::LoopPeelingInfo::GetPeelingInfo(BasicBlock* bb) const { if (bb->terminator()->opcode() != spv::Op::OpBranchConditional) { return GetNoneDirection(); } analysis::DefUseManager* def_use_mgr = context_->get_def_use_mgr(); Instruction* condition = def_use_mgr->GetDef(bb->terminator()->GetSingleWordInOperand(0)); if (!IsHandledCondition(condition->opcode())) { return GetNoneDirection(); } if (!GetFirstLoopInvariantOperand(condition)) { // No loop invariant, it cannot be peeled by this pass. return GetNoneDirection(); } if (!GetFirstNonLoopInvariantOperand(condition)) { // Seems to be a job for the unswitch pass. return GetNoneDirection(); } // Left hand-side. SExpression lhs = scev_analysis_->AnalyzeInstruction( def_use_mgr->GetDef(condition->GetSingleWordInOperand(0))); if (lhs->GetType() == SENode::CanNotCompute) { // Can't make any conclusion. return GetNoneDirection(); } // Right hand-side. SExpression rhs = scev_analysis_->AnalyzeInstruction( def_use_mgr->GetDef(condition->GetSingleWordInOperand(1))); if (rhs->GetType() == SENode::CanNotCompute) { // Can't make any conclusion. return GetNoneDirection(); } // Only take into account recurrent expression over the current loop. bool is_lhs_rec = !scev_analysis_->IsLoopInvariant(loop_, lhs); bool is_rhs_rec = !scev_analysis_->IsLoopInvariant(loop_, rhs); if ((is_lhs_rec && is_rhs_rec) || (!is_lhs_rec && !is_rhs_rec)) { return GetNoneDirection(); } if (is_lhs_rec) { if (!lhs->AsSERecurrentNode() || lhs->AsSERecurrentNode()->GetLoop() != loop_) { return GetNoneDirection(); } } if (is_rhs_rec) { if (!rhs->AsSERecurrentNode() || rhs->AsSERecurrentNode()->GetLoop() != loop_) { return GetNoneDirection(); } } // If the op code is ==, then we try a peel before or after. // If opcode is not <, >, <= or >=, we bail out. // // For the remaining cases, we canonicalize the expression so that the // constant expression is on the left hand side and the recurring expression // is on the right hand side. If we swap hand side, then < becomes >, <= // becomes >= etc. // If the opcode is <=, then we add 1 to the right hand side and do the peel // check on <. // If the opcode is >=, then we add 1 to the left hand side and do the peel // check on >. CmpOperator cmp_operator; switch (condition->opcode()) { default: return GetNoneDirection(); case spv::Op::OpIEqual: case spv::Op::OpINotEqual: return HandleEquality(lhs, rhs); case spv::Op::OpUGreaterThan: case spv::Op::OpSGreaterThan: { cmp_operator = CmpOperator::kGT; break; } case spv::Op::OpULessThan: case spv::Op::OpSLessThan: { cmp_operator = CmpOperator::kLT; break; } // We add one to transform >= into > and <= into <. case spv::Op::OpUGreaterThanEqual: case spv::Op::OpSGreaterThanEqual: { cmp_operator = CmpOperator::kGE; break; } case spv::Op::OpULessThanEqual: case spv::Op::OpSLessThanEqual: { cmp_operator = CmpOperator::kLE; break; } } // Force the left hand side to be the non recurring expression. if (is_lhs_rec) { std::swap(lhs, rhs); switch (cmp_operator) { case CmpOperator::kLT: { cmp_operator = CmpOperator::kGT; break; } case CmpOperator::kGT: { cmp_operator = CmpOperator::kLT; break; } case CmpOperator::kLE: { cmp_operator = CmpOperator::kGE; break; } case CmpOperator::kGE: { cmp_operator = CmpOperator::kLE; break; } } } return HandleInequality(cmp_operator, lhs, rhs->AsSERecurrentNode()); } SExpression LoopPeelingPass::LoopPeelingInfo::GetValueAtFirstIteration( SERecurrentNode* rec) const { return rec->GetOffset(); } SExpression LoopPeelingPass::LoopPeelingInfo::GetValueAtIteration( SERecurrentNode* rec, int64_t iteration) const { SExpression coeff = rec->GetCoefficient(); SExpression offset = rec->GetOffset(); return (coeff * iteration) + offset; } SExpression LoopPeelingPass::LoopPeelingInfo::GetValueAtLastIteration( SERecurrentNode* rec) const { return GetValueAtIteration(rec, loop_max_iterations_ - 1); } bool LoopPeelingPass::LoopPeelingInfo::EvalOperator(CmpOperator cmp_op, SExpression lhs, SExpression rhs, bool* result) const { assert(scev_analysis_->IsLoopInvariant(loop_, lhs)); assert(scev_analysis_->IsLoopInvariant(loop_, rhs)); // We perform the test: 0 cmp_op rhs - lhs // What is left is then to determine the sign of the expression. switch (cmp_op) { case CmpOperator::kLT: { return scev_analysis_->IsAlwaysGreaterThanZero(rhs - lhs, result); } case CmpOperator::kGT: { return scev_analysis_->IsAlwaysGreaterThanZero(lhs - rhs, result); } case CmpOperator::kLE: { return scev_analysis_->IsAlwaysGreaterOrEqualToZero(rhs - lhs, result); } case CmpOperator::kGE: { return scev_analysis_->IsAlwaysGreaterOrEqualToZero(lhs - rhs, result); } } return false; } LoopPeelingPass::LoopPeelingInfo::Direction LoopPeelingPass::LoopPeelingInfo::HandleEquality(SExpression lhs, SExpression rhs) const { { // Try peel before opportunity. SExpression lhs_cst = lhs; if (SERecurrentNode* rec_node = lhs->AsSERecurrentNode()) { lhs_cst = rec_node->GetOffset(); } SExpression rhs_cst = rhs; if (SERecurrentNode* rec_node = rhs->AsSERecurrentNode()) { rhs_cst = rec_node->GetOffset(); } if (lhs_cst == rhs_cst) { return Direction{LoopPeelingPass::PeelDirection::kBefore, 1}; } } { // Try peel after opportunity. SExpression lhs_cst = lhs; if (SERecurrentNode* rec_node = lhs->AsSERecurrentNode()) { // rec_node(x) = a * x + b // assign to lhs: a * (loop_max_iterations_ - 1) + b lhs_cst = GetValueAtLastIteration(rec_node); } SExpression rhs_cst = rhs; if (SERecurrentNode* rec_node = rhs->AsSERecurrentNode()) { // rec_node(x) = a * x + b // assign to lhs: a * (loop_max_iterations_ - 1) + b rhs_cst = GetValueAtLastIteration(rec_node); } if (lhs_cst == rhs_cst) { return Direction{LoopPeelingPass::PeelDirection::kAfter, 1}; } } return GetNoneDirection(); } LoopPeelingPass::LoopPeelingInfo::Direction LoopPeelingPass::LoopPeelingInfo::HandleInequality(CmpOperator cmp_op, SExpression lhs, SERecurrentNode* rhs) const { SExpression offset = rhs->GetOffset(); SExpression coefficient = rhs->GetCoefficient(); // Compute (cst - B) / A. std::pair flip_iteration = (lhs - offset) / coefficient; if (!flip_iteration.first->AsSEConstantNode()) { return GetNoneDirection(); } // note: !!flip_iteration.second normalize to 0/1 (via bool cast). int64_t iteration = flip_iteration.first->AsSEConstantNode()->FoldToSingleValue() + !!flip_iteration.second; if (iteration <= 0 || loop_max_iterations_ <= static_cast(iteration)) { // Always true or false within the loop bounds. return GetNoneDirection(); } // If this is a <= or >= operator and the iteration, make sure |iteration| is // the one flipping the condition. // If (cst - B) and A are not divisible, this equivalent to a < or > check, so // we skip this test. if (!flip_iteration.second && (cmp_op == CmpOperator::kLE || cmp_op == CmpOperator::kGE)) { bool first_iteration; bool current_iteration; if (!EvalOperator(cmp_op, lhs, offset, &first_iteration) || !EvalOperator(cmp_op, lhs, GetValueAtIteration(rhs, iteration), ¤t_iteration)) { return GetNoneDirection(); } // If the condition did not flip the next will. if (first_iteration == current_iteration) { iteration++; } } uint32_t cast_iteration = 0; // Integrity check: can we fit |iteration| in a uint32_t ? if (static_cast(iteration) < std::numeric_limits::max()) { cast_iteration = static_cast(iteration); } if (cast_iteration) { // Peel before if we are closer to the start, after if closer to the end. if (loop_max_iterations_ / 2 > cast_iteration) { return Direction{LoopPeelingPass::PeelDirection::kBefore, cast_iteration}; } else { return Direction{ LoopPeelingPass::PeelDirection::kAfter, static_cast(loop_max_iterations_ - cast_iteration)}; } } return GetNoneDirection(); } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/loop_peeling.h000066400000000000000000000316701475742701700234670ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_LOOP_PEELING_H_ #define SOURCE_OPT_LOOP_PEELING_H_ #include #include #include #include #include #include #include #include #include "source/opt/ir_context.h" #include "source/opt/loop_descriptor.h" #include "source/opt/loop_utils.h" #include "source/opt/pass.h" #include "source/opt/scalar_analysis.h" namespace spvtools { namespace opt { // Utility class to perform the peeling of a given loop. // The loop peeling transformation make a certain amount of a loop iterations to // be executed either before (peel before) or after (peel after) the transformed // loop. // // For peeling cases the transformation does the following steps: // - It clones the loop and inserts the cloned loop before the original loop; // - It connects all iterating values of the cloned loop with the // corresponding original loop values so that the second loop starts with // the appropriate values. // - It inserts a new induction variable "i" is inserted into the cloned that // starts with the value 0 and increment by step of one. // // The last step is specific to each case: // - Peel before: the transformation is to peel the "N" first iterations. // The exit condition of the cloned loop is changed so that the loop // exits when "i < N" becomes false. The original loop is then protected to // only execute if there is any iteration left to do. // - Peel after: the transformation is to peel the "N" last iterations, // then the exit condition of the cloned loop is changed so that the loop // exits when "i + N < max_iteration" becomes false, where "max_iteration" // is the upper bound of the loop. The cloned loop is then protected to // only execute if there is any iteration left to do no covered by the // second. // // To be peelable: // - The loop must be in LCSSA form; // - The loop must not contain any breaks; // - The loop must not have any ambiguous iterators updates (see // "CanPeelLoop"). // The method "CanPeelLoop" checks that those constrained are met. class LoopPeeling { public: // LoopPeeling constructor. // |loop| is the loop to peel. // |loop_iteration_count| is the instruction holding the |loop| iteration // count, must be invariant for |loop| and must be of an int 32 type (signed // or unsigned). // |canonical_induction_variable| is an induction variable that can be used to // count the number of iterations, must be of the same type as // |loop_iteration_count| and start at 0 and increase by step of one at each // iteration. The value nullptr is interpreted as no suitable variable exists // and one will be created. LoopPeeling(Loop* loop, Instruction* loop_iteration_count, Instruction* canonical_induction_variable = nullptr) : context_(loop->GetContext()), loop_utils_(loop->GetContext(), loop), loop_(loop), loop_iteration_count_(!loop->IsInsideLoop(loop_iteration_count) ? loop_iteration_count : nullptr), int_type_(nullptr), original_loop_canonical_induction_variable_( canonical_induction_variable), canonical_induction_variable_(nullptr) { if (loop_iteration_count_) { int_type_ = context_->get_type_mgr() ->GetType(loop_iteration_count_->type_id()) ->AsInteger(); if (canonical_induction_variable_) { assert(canonical_induction_variable_->type_id() == loop_iteration_count_->type_id() && "loop_iteration_count and canonical_induction_variable do not " "have the same type"); } } GetIteratingExitValues(); } // Returns true if the loop can be peeled. // To be peelable, all operation involved in the update of the loop iterators // must not dominates the exit condition. This restriction is a work around to // not miss compile code like: // // for (int i = 0; i + 1 < N; i++) {} // for (int i = 0; ++i < N; i++) {} // // The increment will happen before the test on the exit condition leading to // very look-a-like code. // // This restriction will not apply if a loop rotate is applied before (i.e. // becomes a do-while loop). bool CanPeelLoop() const { CFG& cfg = *context_->cfg(); if (!loop_iteration_count_) { return false; } if (!int_type_) { return false; } if (int_type_->width() != 32) { return false; } if (!loop_->IsLCSSA()) { return false; } if (!loop_->GetMergeBlock()) { return false; } if (cfg.preds(loop_->GetMergeBlock()->id()).size() != 1) { return false; } if (!IsConditionCheckSideEffectFree()) { return false; } return !std::any_of(exit_value_.cbegin(), exit_value_.cend(), [](std::pair it) { return it.second == nullptr; }); } // Moves the execution of the |factor| first iterations of the loop into a // dedicated loop. void PeelBefore(uint32_t factor); // Moves the execution of the |factor| last iterations of the loop into a // dedicated loop. void PeelAfter(uint32_t factor); // Returns the cloned loop. Loop* GetClonedLoop() { return cloned_loop_; } // Returns the original loop. Loop* GetOriginalLoop() { return loop_; } private: IRContext* context_; LoopUtils loop_utils_; // The original loop. Loop* loop_; // The initial |loop_| upper bound. Instruction* loop_iteration_count_; // The int type to use for the canonical_induction_variable_. analysis::Integer* int_type_; // The cloned loop. Loop* cloned_loop_; // This is set to true when the exit and back-edge branch instruction is the // same. bool do_while_form_; // The canonical induction variable from the original loop if it exists. Instruction* original_loop_canonical_induction_variable_; // The canonical induction variable of the cloned loop. The induction variable // is initialized to 0 and incremented by step of 1. Instruction* canonical_induction_variable_; // Map between loop iterators and exit values. Loop iterators std::unordered_map exit_value_; // Duplicate |loop_| and place the new loop before the cloned loop. Iterating // values from the cloned loop are then connected to the original loop as // initializer. void DuplicateAndConnectLoop(LoopUtils::LoopCloningResult* clone_results); // Insert the canonical induction variable into the first loop as a simplified // counter. void InsertCanonicalInductionVariable( LoopUtils::LoopCloningResult* clone_results); // Fixes the exit condition of the before loop. The function calls // |condition_builder| to get the condition to use in the conditional branch // of the loop exit. The loop will be exited if the condition evaluate to // true. |condition_builder| takes an Instruction* that represent the // insertion point. void FixExitCondition( const std::function& condition_builder); // Gathers all operations involved in the update of |iterator| into // |operations|. void GetIteratorUpdateOperations( const Loop* loop, Instruction* iterator, std::unordered_set* operations); // Gathers exiting iterator values. The function builds a map between each // iterating value in the loop (a phi instruction in the loop header) and its // SSA value when it exit the loop. If no exit value can be accurately found, // it is map to nullptr (see comment on CanPeelLoop). void GetIteratingExitValues(); // Returns true if a for-loop has no instruction with effects before the // condition check. bool IsConditionCheckSideEffectFree() const; // Creates a new basic block and insert it between |bb| and the predecessor of // |bb|. BasicBlock* CreateBlockBefore(BasicBlock* bb); // Inserts code to only execute |loop| only if the given |condition| is true. // |if_merge| is a suitable basic block to be used by the if condition as // merge block. // The function returns the if block protecting the loop. BasicBlock* ProtectLoop(Loop* loop, Instruction* condition, BasicBlock* if_merge); }; // Implements a loop peeling optimization. // For each loop, the pass will try to peel it if there is conditions that // are true for the "N" first or last iterations of the loop. // To avoid code size explosion, too large loops will not be peeled. class LoopPeelingPass : public Pass { public: // Describes the peeling direction. enum class PeelDirection { kNone, // Cannot peel kBefore, // Can peel before kAfter // Can peel last }; // Holds some statistics about peeled function. struct LoopPeelingStats { std::vector> peeled_loops_; }; LoopPeelingPass(LoopPeelingStats* stats = nullptr) : stats_(stats) {} // Sets the loop peeling growth threshold. If the code size increase is above // |code_grow_threshold|, the loop will not be peeled. The code size is // measured in terms of SPIR-V instructions. static void SetLoopPeelingThreshold(size_t code_grow_threshold) { code_grow_threshold_ = code_grow_threshold; } // Returns the loop peeling code growth threshold. static size_t GetLoopPeelingThreshold() { return code_grow_threshold_; } const char* name() const override { return "loop-peeling"; } // Processes the given |module|. Returns Status::Failure if errors occur when // processing. Returns the corresponding Status::Success if processing is // successful to indicate whether changes have been made to the module. Pass::Status Process() override; private: // Describes the peeling direction. enum class CmpOperator { kLT, // less than kGT, // greater than kLE, // less than or equal kGE, // greater than or equal }; class LoopPeelingInfo { public: using Direction = std::pair; LoopPeelingInfo(Loop* loop, size_t loop_max_iterations, ScalarEvolutionAnalysis* scev_analysis) : context_(loop->GetContext()), loop_(loop), scev_analysis_(scev_analysis), loop_max_iterations_(loop_max_iterations) {} // Returns by how much and to which direction a loop should be peeled to // make the conditional branch of the basic block |bb| an unconditional // branch. If |bb|'s terminator is not a conditional branch or the condition // is not workable then it returns PeelDirection::kNone and a 0 factor. Direction GetPeelingInfo(BasicBlock* bb) const; private: // Returns the id of the loop invariant operand of the conditional // expression |condition|. It returns if no operand is invariant. uint32_t GetFirstLoopInvariantOperand(Instruction* condition) const; // Returns the id of the non loop invariant operand of the conditional // expression |condition|. It returns if all operands are invariant. uint32_t GetFirstNonLoopInvariantOperand(Instruction* condition) const; // Returns the value of |rec| at the first loop iteration. SExpression GetValueAtFirstIteration(SERecurrentNode* rec) const; // Returns the value of |rec| at the given |iteration|. SExpression GetValueAtIteration(SERecurrentNode* rec, int64_t iteration) const; // Returns the value of |rec| at the last loop iteration. SExpression GetValueAtLastIteration(SERecurrentNode* rec) const; bool EvalOperator(CmpOperator cmp_op, SExpression lhs, SExpression rhs, bool* result) const; Direction HandleEquality(SExpression lhs, SExpression rhs) const; Direction HandleInequality(CmpOperator cmp_op, SExpression lhs, SERecurrentNode* rhs) const; static Direction GetNoneDirection() { return Direction{LoopPeelingPass::PeelDirection::kNone, 0}; } IRContext* context_; Loop* loop_; ScalarEvolutionAnalysis* scev_analysis_; size_t loop_max_iterations_; }; // Peel profitable loops in |f|. bool ProcessFunction(Function* f); // Peel |loop| if profitable. std::pair ProcessLoop(Loop* loop, CodeMetrics* loop_size); static size_t code_grow_threshold_; LoopPeelingStats* stats_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_LOOP_PEELING_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/loop_unroller.cpp000066400000000000000000001235141475742701700242400ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/loop_unroller.h" #include #include #include #include #include #include "source/opt/ir_builder.h" #include "source/opt/loop_utils.h" // Implements loop util unrolling functionality for fully and partially // unrolling loops. Given a factor it will duplicate the loop that many times, // appending each one to the end of the old loop and removing backedges, to // create a new unrolled loop. // // 1 - User calls LoopUtils::FullyUnroll or LoopUtils::PartiallyUnroll with a // loop they wish to unroll. LoopUtils::CanPerformUnroll is used to // validate that a given loop can be unrolled. That method (along with the // constructor of loop) checks that the IR is in the expected canonicalised // format. // // 2 - The LoopUtils methods create a LoopUnrollerUtilsImpl object to actually // perform the unrolling. This implements helper methods to copy the loop basic // blocks and remap the ids of instructions used inside them. // // 3 - The core of LoopUnrollerUtilsImpl is the Unroll method, this method // actually performs the loop duplication. It does this by creating a // LoopUnrollState object and then copying the loop as given by the factor // parameter. The LoopUnrollState object retains the state of the unroller // between the loop body copies as each iteration needs information on the last // to adjust the phi induction variable, adjust the OpLoopMerge instruction in // the main loop header, and change the previous continue block to point to the // new header and the new continue block to the main loop header. // // 4 - If the loop is to be fully unrolled then it is simply closed after step // 3, with the OpLoopMerge being deleted, the backedge removed, and the // condition blocks folded. // // 5 - If it is being partially unrolled: if the unrolling factor leaves the // loop with an even number of bodies with respect to the number of loop // iterations then step 3 is all that is needed. If it is uneven then we need to // duplicate the loop completely and unroll the duplicated loop to cover the // residual part and adjust the first loop to cover only the "even" part. For // instance if you request an unroll factor of 3 on a loop with 10 iterations // then copying the body three times would leave you with three bodies in the // loop // where the loop still iterates over each 4 times. So we make two loops one // iterating once then a second loop of three iterating 3 times. namespace spvtools { namespace opt { namespace { // Loop control constant value for DontUnroll flag. constexpr uint32_t kLoopControlDontUnrollIndex = 2; // Operand index of the loop control parameter of the OpLoopMerge. constexpr uint32_t kLoopControlIndex = 2; // This utility class encapsulates some of the state we need to maintain between // loop unrolls. Specifically it maintains key blocks and the induction variable // in the current loop duplication step and the blocks from the previous one. // This is because each step of the unroll needs to use data from both the // preceding step and the original loop. struct LoopUnrollState { LoopUnrollState() : previous_phi_(nullptr), previous_latch_block_(nullptr), previous_condition_block_(nullptr), new_phi(nullptr), new_continue_block(nullptr), new_condition_block(nullptr), new_header_block(nullptr) {} // Initialize from the loop descriptor class. LoopUnrollState(Instruction* induction, BasicBlock* latch_block, BasicBlock* condition, std::vector&& phis) : previous_phi_(induction), previous_latch_block_(latch_block), previous_condition_block_(condition), new_phi(nullptr), new_continue_block(nullptr), new_condition_block(nullptr), new_header_block(nullptr) { previous_phis_ = std::move(phis); } // Swap the state so that the new nodes are now the previous nodes. void NextIterationState() { previous_phi_ = new_phi; previous_latch_block_ = new_latch_block; previous_condition_block_ = new_condition_block; previous_phis_ = std::move(new_phis_); // Clear new nodes. new_phi = nullptr; new_continue_block = nullptr; new_condition_block = nullptr; new_header_block = nullptr; new_latch_block = nullptr; // Clear new block/instruction maps. new_blocks.clear(); new_inst.clear(); ids_to_new_inst.clear(); } // The induction variable from the immediately preceding loop body. Instruction* previous_phi_; // All the phi nodes from the previous loop iteration. std::vector previous_phis_; std::vector new_phis_; // The previous latch block. The backedge will be removed from this and // added to the new latch block. BasicBlock* previous_latch_block_; // The previous condition block. This may be folded to flatten the loop. BasicBlock* previous_condition_block_; // The new induction variable. Instruction* new_phi; // The new continue block. BasicBlock* new_continue_block; // The new condition block. BasicBlock* new_condition_block; // The new header block. BasicBlock* new_header_block; // The new latch block. BasicBlock* new_latch_block; // A mapping of new block ids to the original blocks which they were copied // from. std::unordered_map new_blocks; // A mapping of the original instruction ids to the instruction ids to their // copies. std::unordered_map new_inst; std::unordered_map ids_to_new_inst; }; // This class implements the actual unrolling. It uses a LoopUnrollState to // maintain the state of the unrolling in between steps. class LoopUnrollerUtilsImpl { public: using BasicBlockListTy = std::vector>; LoopUnrollerUtilsImpl(IRContext* c, Function* function) : context_(c), function_(*function), loop_condition_block_(nullptr), loop_induction_variable_(nullptr), number_of_loop_iterations_(0), loop_step_value_(0), loop_init_value_(0) {} // Unroll the |loop| by given |factor| by copying the whole body |factor| // times. The resulting basicblock structure will remain a loop. void PartiallyUnroll(Loop*, size_t factor); // If partially unrolling the |loop| would leave the loop with too many bodies // for its number of iterations then this method should be used. This method // will duplicate the |loop| completely, making the duplicated loop the // successor of the original's merge block. The original loop will have its // condition changed to loop over the residual part and the duplicate will be // partially unrolled. The resulting structure will be two loops. void PartiallyUnrollResidualFactor(Loop* loop, size_t factor); // Fully unroll the |loop| by copying the full body by the total number of // loop iterations, folding all conditions, and removing the backedge from the // continue block to the header. void FullyUnroll(Loop* loop); // Get the ID of the variable in the |phi| paired with |label|. uint32_t GetPhiDefID(const Instruction* phi, uint32_t label) const; // Close the loop by removing the OpLoopMerge from the |loop| header block and // making the backedge point to the merge block. void CloseUnrolledLoop(Loop* loop); // Remove the OpConditionalBranch instruction inside |conditional_block| used // to branch to either exit or continue the loop and replace it with an // unconditional OpBranch to block |new_target|. void FoldConditionBlock(BasicBlock* condtion_block, uint32_t new_target); // Add all blocks_to_add_ to function_ at the |insert_point|. void AddBlocksToFunction(const BasicBlock* insert_point); // Duplicates the |old_loop|, cloning each body and remapping the ids without // removing instructions or changing relative structure. Result will be stored // in |new_loop|. void DuplicateLoop(Loop* old_loop, Loop* new_loop); inline size_t GetLoopIterationCount() const { return number_of_loop_iterations_; } // Extracts the initial state information from the |loop|. void Init(Loop* loop); // Replace the uses of each induction variable outside the loop with the final // value of the induction variable before the loop exit. To reflect the proper // state of a fully unrolled loop. void ReplaceInductionUseWithFinalValue(Loop* loop); // Remove all the instructions in the invalidated_instructions_ vector. void RemoveDeadInstructions(); // Replace any use of induction variables outwith the loop with the final // value of the induction variable in the unrolled loop. void ReplaceOutsideLoopUseWithFinalValue(Loop* loop); // Set the LoopControl operand of the OpLoopMerge instruction to be // DontUnroll. void MarkLoopControlAsDontUnroll(Loop* loop) const; private: // Remap all the in |basic_block| to new IDs and keep the mapping of new ids // to old // ids. |loop| is used to identify special loop blocks (header, continue, // etc). void AssignNewResultIds(BasicBlock* basic_block); // Using the map built by AssignNewResultIds, replace the uses in |inst| // by the id that the use maps to. void RemapOperands(Instruction* inst); // Using the map built by AssignNewResultIds, for each instruction in // |basic_block| use // that map to substitute the IDs used by instructions (in the operands) with // the new ids. void RemapOperands(BasicBlock* basic_block); // Copy the whole body of the loop, all blocks dominated by the |loop| header // and not dominated by the |loop| merge. The copied body will be linked to by // the old |loop| continue block and the new body will link to the |loop| // header via the new continue block. |eliminate_conditions| is used to decide // whether or not to fold all the condition blocks other than the last one. void CopyBody(Loop* loop, bool eliminate_conditions); // Copy a given |block_to_copy| in the |loop| and record the mapping of the // old/new ids. |preserve_instructions| determines whether or not the method // will modify (other than result_id) instructions which are copied. void CopyBasicBlock(Loop* loop, const BasicBlock* block_to_copy, bool preserve_instructions); // The actual implementation of the unroll step. Unrolls |loop| by given // |factor| by copying the body by |factor| times. Also propagates the // induction variable value throughout the copies. void Unroll(Loop* loop, size_t factor); // Fills the loop_blocks_inorder_ field with the ordered list of basic blocks // as computed by the method ComputeLoopOrderedBlocks. void ComputeLoopOrderedBlocks(Loop* loop); // Adds the blocks_to_add_ to both the |loop| and to the parent of |loop| if // the parent exists. void AddBlocksToLoop(Loop* loop) const; // After the partially unroll step the phi instructions in the header block // will be in an illegal format. This function makes the phis legal by making // the edge from the latch block come from the new latch block and the value // to be the actual value of the phi at that point. void LinkLastPhisToStart(Loop* loop) const; // Kill all debug declaration instructions from |bb|. void KillDebugDeclares(BasicBlock* bb); // A pointer to the IRContext. Used to add/remove instructions and for usedef // chains. IRContext* context_; // A reference the function the loop is within. Function& function_; // A list of basic blocks to be added to the loop at the end of an unroll // step. BasicBlockListTy blocks_to_add_; // List of instructions which are now dead and can be removed. std::vector invalidated_instructions_; // Maintains the current state of the transform between calls to unroll. LoopUnrollState state_; // An ordered list containing the loop basic blocks. std::vector loop_blocks_inorder_; // The block containing the condition check which contains a conditional // branch to the merge and continue block. BasicBlock* loop_condition_block_; // The induction variable of the loop. Instruction* loop_induction_variable_; // Phis used in the loop need to be remapped to use the actual result values // and then be remapped at the end. std::vector loop_phi_instructions_; // The number of loop iterations that the loop would perform pre-unroll. size_t number_of_loop_iterations_; // The amount that the loop steps each iteration. int64_t loop_step_value_; // The value the loop starts stepping from. int64_t loop_init_value_; }; /* * Static helper functions. */ // Retrieve the index of the OpPhi instruction |phi| which corresponds to the // incoming |block| id. uint32_t GetPhiIndexFromLabel(const BasicBlock* block, const Instruction* phi) { for (uint32_t i = 1; i < phi->NumInOperands(); i += 2) { if (block->id() == phi->GetSingleWordInOperand(i)) { return i; } } assert(false && "Could not find operand in instruction."); return 0; } void LoopUnrollerUtilsImpl::Init(Loop* loop) { loop_condition_block_ = loop->FindConditionBlock(); // When we reinit the second loop during PartiallyUnrollResidualFactor we need // to use the cached value from the duplicate step as the dominator tree // basded solution, loop->FindConditionBlock, requires all the nodes to be // connected up with the correct branches. They won't be at this point. if (!loop_condition_block_) { loop_condition_block_ = state_.new_condition_block; } assert(loop_condition_block_); loop_induction_variable_ = loop->FindConditionVariable(loop_condition_block_); assert(loop_induction_variable_); bool found = loop->FindNumberOfIterations( loop_induction_variable_, &*loop_condition_block_->ctail(), &number_of_loop_iterations_, &loop_step_value_, &loop_init_value_); (void)found; // To silence unused variable warning on release builds. assert(found); // Blocks are stored in an unordered set of ids in the loop class, we need to // create the dominator ordered list. ComputeLoopOrderedBlocks(loop); } // This function is used to partially unroll the loop when the factor provided // would normally lead to an illegal optimization. Instead of just unrolling the // loop it creates two loops and unrolls one and adjusts the condition on the // other. The end result being that the new loop pair iterates over the correct // number of bodies. void LoopUnrollerUtilsImpl::PartiallyUnrollResidualFactor(Loop* loop, size_t factor) { // TODO(1841): Handle id overflow. std::unique_ptr new_label{new Instruction( context_, spv::Op::OpLabel, 0, context_->TakeNextId(), {})}; std::unique_ptr new_exit_bb{new BasicBlock(std::move(new_label))}; new_exit_bb->SetParent(&function_); // Save the id of the block before we move it. uint32_t new_merge_id = new_exit_bb->id(); // Add the block the list of blocks to add, we want this merge block to be // right at the start of the new blocks. blocks_to_add_.push_back(std::move(new_exit_bb)); BasicBlock* new_exit_bb_raw = blocks_to_add_[0].get(); Instruction& original_conditional_branch = *loop_condition_block_->tail(); // Duplicate the loop, providing access to the blocks of both loops. // This is a naked new due to the VS2013 requirement of not having unique // pointers in vectors, as it will be inserted into a vector with // loop_descriptor.AddLoop. std::unique_ptr new_loop = MakeUnique(*loop); // Clear the basic blocks of the new loop. new_loop->ClearBlocks(); DuplicateLoop(loop, new_loop.get()); // Add the blocks to the function. AddBlocksToFunction(loop->GetMergeBlock()); blocks_to_add_.clear(); // Create a new merge block for the first loop. InstructionBuilder builder{context_, new_exit_bb_raw}; // Make the first loop branch to the second. builder.AddBranch(new_loop->GetHeaderBlock()->id()); loop_condition_block_ = state_.new_condition_block; loop_induction_variable_ = state_.new_phi; // Unroll the new loop by the factor with the usual -1 to account for the // existing block iteration. Unroll(new_loop.get(), factor); LinkLastPhisToStart(new_loop.get()); AddBlocksToLoop(new_loop.get()); // Add the new merge block to the back of the list of blocks to be added. It // needs to be the last block added to maintain dominator order in the binary. blocks_to_add_.push_back( std::unique_ptr(new_loop->GetMergeBlock())); // Add the blocks to the function. AddBlocksToFunction(loop->GetMergeBlock()); // Reset the usedef analysis. context_->InvalidateAnalysesExceptFor( IRContext::Analysis::kAnalysisLoopAnalysis); analysis::DefUseManager* def_use_manager = context_->get_def_use_mgr(); // The loop condition. Instruction* condition_check = def_use_manager->GetDef( original_conditional_branch.GetSingleWordOperand(0)); // This should have been checked by the LoopUtils::CanPerformUnroll function // before entering this. assert(loop->IsSupportedCondition(condition_check->opcode())); // We need to account for the initial body when calculating the remainder. int64_t remainder = Loop::GetResidualConditionValue( condition_check->opcode(), loop_init_value_, loop_step_value_, number_of_loop_iterations_, factor); assert(remainder > std::numeric_limits::min() && remainder < std::numeric_limits::max()); Instruction* new_constant = nullptr; // If the remainder is negative then we add a signed constant, otherwise just // add an unsigned constant. if (remainder < 0) { new_constant = builder.GetSintConstant(static_cast(remainder)); } else { new_constant = builder.GetUintConstant(static_cast(remainder)); } uint32_t constant_id = new_constant->result_id(); // Update the condition check. condition_check->SetInOperand(1, {constant_id}); // Update the next phi node. The phi will have a constant value coming in from // the preheader block. For the duplicated loop we need to update the constant // to be the amount of iterations covered by the first loop and the incoming // block to be the first loops new merge block. std::vector new_inductions; new_loop->GetInductionVariables(new_inductions); std::vector old_inductions; loop->GetInductionVariables(old_inductions); for (size_t index = 0; index < new_inductions.size(); ++index) { Instruction* new_induction = new_inductions[index]; Instruction* old_induction = old_inductions[index]; // Get the index of the loop initalizer, the value coming in from the // preheader. uint32_t initalizer_index = GetPhiIndexFromLabel(new_loop->GetPreHeaderBlock(), old_induction); // Replace the second loop initalizer with the phi from the first new_induction->SetInOperand(initalizer_index - 1, {old_induction->result_id()}); new_induction->SetInOperand(initalizer_index, {new_merge_id}); // If the use of the first loop induction variable is outside of the loop // then replace that use with the second loop induction variable. uint32_t second_loop_induction = new_induction->result_id(); auto replace_use_outside_of_loop = [loop, second_loop_induction]( Instruction* user, uint32_t operand_index) { if (!loop->IsInsideLoop(user)) { user->SetOperand(operand_index, {second_loop_induction}); } }; context_->get_def_use_mgr()->ForEachUse(old_induction, replace_use_outside_of_loop); } context_->InvalidateAnalysesExceptFor( IRContext::Analysis::kAnalysisLoopAnalysis); context_->ReplaceAllUsesWith(loop->GetMergeBlock()->id(), new_merge_id); LoopDescriptor& loop_descriptor = *context_->GetLoopDescriptor(&function_); loop_descriptor.AddLoop(std::move(new_loop), loop->GetParent()); RemoveDeadInstructions(); } // Mark this loop as DontUnroll as it will already be unrolled and it may not // be safe to unroll a previously partially unrolled loop. void LoopUnrollerUtilsImpl::MarkLoopControlAsDontUnroll(Loop* loop) const { Instruction* loop_merge_inst = loop->GetHeaderBlock()->GetLoopMergeInst(); assert(loop_merge_inst && "Loop merge instruction could not be found after entering unroller " "(should have exited before this)"); loop_merge_inst->SetInOperand(kLoopControlIndex, {kLoopControlDontUnrollIndex}); } // Duplicate the |loop| body |factor| - 1 number of times while keeping the loop // backedge intact. This will leave the loop with |factor| number of bodies // after accounting for the initial body. void LoopUnrollerUtilsImpl::Unroll(Loop* loop, size_t factor) { // If we unroll a loop partially it will not be safe to unroll it further. // This is due to the current method of calculating the number of loop // iterations. MarkLoopControlAsDontUnroll(loop); std::vector inductions; loop->GetInductionVariables(inductions); state_ = LoopUnrollState{loop_induction_variable_, loop->GetLatchBlock(), loop_condition_block_, std::move(inductions)}; for (size_t i = 0; i < factor - 1; ++i) { CopyBody(loop, true); } } void LoopUnrollerUtilsImpl::RemoveDeadInstructions() { // Remove the dead instructions. for (Instruction* inst : invalidated_instructions_) { context_->KillInst(inst); } } void LoopUnrollerUtilsImpl::ReplaceInductionUseWithFinalValue(Loop* loop) { context_->InvalidateAnalysesExceptFor( IRContext::Analysis::kAnalysisLoopAnalysis | IRContext::Analysis::kAnalysisDefUse | IRContext::Analysis::kAnalysisInstrToBlockMapping); std::vector inductions; loop->GetInductionVariables(inductions); for (size_t index = 0; index < inductions.size(); ++index) { uint32_t trip_step_id = GetPhiDefID(state_.previous_phis_[index], state_.previous_latch_block_->id()); context_->ReplaceAllUsesWith(inductions[index]->result_id(), trip_step_id); invalidated_instructions_.push_back(inductions[index]); } } // Fully unroll the loop by partially unrolling it by the number of loop // iterations minus one for the body already accounted for. void LoopUnrollerUtilsImpl::FullyUnroll(Loop* loop) { // We unroll the loop by number of iterations in the loop. Unroll(loop, number_of_loop_iterations_); // The first condition block is preserved until now so it can be copied. FoldConditionBlock(loop_condition_block_, 1); // Delete the OpLoopMerge and remove the backedge to the header. CloseUnrolledLoop(loop); // Mark the loop for later deletion. This allows us to preserve the loop // iterators but still disregard dead loops. loop->MarkLoopForRemoval(); // If the loop has a parent add the new blocks to the parent. if (loop->GetParent()) { AddBlocksToLoop(loop->GetParent()); } // Add the blocks to the function. AddBlocksToFunction(loop->GetMergeBlock()); ReplaceInductionUseWithFinalValue(loop); RemoveDeadInstructions(); // Invalidate all analyses. context_->InvalidateAnalysesExceptFor( IRContext::Analysis::kAnalysisLoopAnalysis | IRContext::Analysis::kAnalysisDefUse); } void LoopUnrollerUtilsImpl::KillDebugDeclares(BasicBlock* bb) { // We cannot kill an instruction inside BasicBlock::ForEachInst() // because it will generate dangling pointers. We use |to_be_killed| // to kill them after the loop. std::vector to_be_killed; bb->ForEachInst([&to_be_killed, this](Instruction* inst) { if (context_->get_debug_info_mgr()->IsDebugDeclare(inst)) { to_be_killed.push_back(inst); } }); for (auto* inst : to_be_killed) context_->KillInst(inst); } // Copy a given basic block, give it a new result_id, and store the new block // and the id mapping in the state. |preserve_instructions| is used to determine // whether or not this function should edit instructions other than the // |result_id|. void LoopUnrollerUtilsImpl::CopyBasicBlock(Loop* loop, const BasicBlock* itr, bool preserve_instructions) { // Clone the block exactly, including the IDs. BasicBlock* basic_block = itr->Clone(context_); basic_block->SetParent(itr->GetParent()); // We do not want to duplicate DebugDeclare. KillDebugDeclares(basic_block); // Assign each result a new unique ID and keep a mapping of the old ids to // the new ones. AssignNewResultIds(basic_block); // If this is the continue block we are copying. if (itr == loop->GetContinueBlock()) { // Make the OpLoopMerge point to this block for the continue. if (!preserve_instructions) { Instruction* merge_inst = loop->GetHeaderBlock()->GetLoopMergeInst(); merge_inst->SetInOperand(1, {basic_block->id()}); context_->UpdateDefUse(merge_inst); } state_.new_continue_block = basic_block; } // If this is the header block we are copying. if (itr == loop->GetHeaderBlock()) { state_.new_header_block = basic_block; if (!preserve_instructions) { // Remove the loop merge instruction if it exists. Instruction* merge_inst = basic_block->GetLoopMergeInst(); if (merge_inst) invalidated_instructions_.push_back(merge_inst); } } // If this is the latch block being copied, record it in the state. if (itr == loop->GetLatchBlock()) state_.new_latch_block = basic_block; // If this is the condition block we are copying. if (itr == loop_condition_block_) { state_.new_condition_block = basic_block; } // Add this block to the list of blocks to add to the function at the end of // the unrolling process. blocks_to_add_.push_back(std::unique_ptr(basic_block)); // Keep tracking the old block via a map. state_.new_blocks[itr->id()] = basic_block; } void LoopUnrollerUtilsImpl::CopyBody(Loop* loop, bool eliminate_conditions) { // Copy each basic block in the loop, give them new ids, and save state // information. for (const BasicBlock* itr : loop_blocks_inorder_) { CopyBasicBlock(loop, itr, false); } // Set the previous latch block to point to the new header. Instruction* latch_branch = state_.previous_latch_block_->terminator(); latch_branch->SetInOperand(0, {state_.new_header_block->id()}); context_->UpdateDefUse(latch_branch); // As the algorithm copies the original loop blocks exactly, the tail of the // latch block on iterations after the first one will be a branch to the new // header and not the actual loop header. The last continue block in the loop // should always be a backedge to the global header. Instruction* new_latch_branch = state_.new_latch_block->terminator(); new_latch_branch->SetInOperand(0, {loop->GetHeaderBlock()->id()}); context_->AnalyzeUses(new_latch_branch); std::vector inductions; loop->GetInductionVariables(inductions); for (size_t index = 0; index < inductions.size(); ++index) { Instruction* primary_copy = inductions[index]; assert(primary_copy->result_id() != 0); Instruction* induction_clone = state_.ids_to_new_inst[state_.new_inst[primary_copy->result_id()]]; state_.new_phis_.push_back(induction_clone); assert(induction_clone->result_id() != 0); if (!state_.previous_phis_.empty()) { state_.new_inst[primary_copy->result_id()] = GetPhiDefID( state_.previous_phis_[index], state_.previous_latch_block_->id()); } else { // Do not replace the first phi block ids. state_.new_inst[primary_copy->result_id()] = primary_copy->result_id(); } } if (eliminate_conditions && state_.new_condition_block != loop_condition_block_) { FoldConditionBlock(state_.new_condition_block, 1); } // Only reference to the header block is the backedge in the latch block, // don't change this. state_.new_inst[loop->GetHeaderBlock()->id()] = loop->GetHeaderBlock()->id(); for (auto& pair : state_.new_blocks) { RemapOperands(pair.second); } for (Instruction* dead_phi : state_.new_phis_) invalidated_instructions_.push_back(dead_phi); // Swap the state so the new is now the previous. state_.NextIterationState(); } uint32_t LoopUnrollerUtilsImpl::GetPhiDefID(const Instruction* phi, uint32_t label) const { for (uint32_t operand = 3; operand < phi->NumOperands(); operand += 2) { if (phi->GetSingleWordOperand(operand) == label) { return phi->GetSingleWordOperand(operand - 1); } } assert(false && "Could not find a phi index matching the provided label"); return 0; } void LoopUnrollerUtilsImpl::FoldConditionBlock(BasicBlock* condition_block, uint32_t operand_label) { // Remove the old conditional branch to the merge and continue blocks. Instruction& old_branch = *condition_block->tail(); uint32_t new_target = old_branch.GetSingleWordOperand(operand_label); DebugScope scope = old_branch.GetDebugScope(); const std::vector lines = old_branch.dbg_line_insts(); context_->KillInst(&old_branch); // Add the new unconditional branch to the merge block. InstructionBuilder builder( context_, condition_block, IRContext::Analysis::kAnalysisDefUse | IRContext::Analysis::kAnalysisInstrToBlockMapping); Instruction* new_branch = builder.AddBranch(new_target); if (!lines.empty()) new_branch->AddDebugLine(&lines.back()); new_branch->SetDebugScope(scope); } void LoopUnrollerUtilsImpl::CloseUnrolledLoop(Loop* loop) { // Remove the OpLoopMerge instruction from the function. Instruction* merge_inst = loop->GetHeaderBlock()->GetLoopMergeInst(); invalidated_instructions_.push_back(merge_inst); // Remove the final backedge to the header and make it point instead to the // merge block. Instruction* latch_instruction = state_.previous_latch_block_->terminator(); latch_instruction->SetInOperand(0, {loop->GetMergeBlock()->id()}); context_->UpdateDefUse(latch_instruction); // Remove all induction variables as the phis will now be invalid. Replace all // uses with the constant initializer value (all uses of phis will be in // the first iteration with the subsequent phis already having been removed). std::vector inductions; loop->GetInductionVariables(inductions); // We can use the state instruction mechanism to replace all internal loop // values within the first loop trip (as the subsequent ones will be updated // by the copy function) with the value coming in from the preheader and then // use context ReplaceAllUsesWith for the uses outside the loop with the final // trip phi value. state_.new_inst.clear(); for (Instruction* induction : inductions) { uint32_t initalizer_id = GetPhiDefID(induction, loop->GetPreHeaderBlock()->id()); state_.new_inst[induction->result_id()] = initalizer_id; } for (BasicBlock* block : loop_blocks_inorder_) { RemapOperands(block); } for (auto& block_itr : blocks_to_add_) { RemapOperands(block_itr.get()); } // Rewrite the last phis, since they may still reference the original phi. for (Instruction* last_phi : state_.previous_phis_) { RemapOperands(last_phi); } } // Uses the first loop to create a copy of the loop with new IDs. void LoopUnrollerUtilsImpl::DuplicateLoop(Loop* old_loop, Loop* new_loop) { std::vector new_block_order; // Copy every block in the old loop. for (const BasicBlock* itr : loop_blocks_inorder_) { CopyBasicBlock(old_loop, itr, true); new_block_order.push_back(blocks_to_add_.back().get()); } // Clone the merge block, give it a new id and record it in the state. BasicBlock* new_merge = old_loop->GetMergeBlock()->Clone(context_); new_merge->SetParent(old_loop->GetMergeBlock()->GetParent()); AssignNewResultIds(new_merge); state_.new_blocks[old_loop->GetMergeBlock()->id()] = new_merge; // Remap the operands of every instruction in the loop to point to the new // copies. for (auto& pair : state_.new_blocks) { RemapOperands(pair.second); } loop_blocks_inorder_ = std::move(new_block_order); AddBlocksToLoop(new_loop); new_loop->SetHeaderBlock(state_.new_header_block); new_loop->SetContinueBlock(state_.new_continue_block); new_loop->SetLatchBlock(state_.new_latch_block); new_loop->SetMergeBlock(new_merge); } // Whenever the utility copies a block it stores it in a temporary buffer, this // function adds the buffer into the Function. The blocks will be inserted // after the block |insert_point|. void LoopUnrollerUtilsImpl::AddBlocksToFunction( const BasicBlock* insert_point) { for (auto basic_block_iterator = function_.begin(); basic_block_iterator != function_.end(); ++basic_block_iterator) { if (basic_block_iterator->id() == insert_point->id()) { basic_block_iterator.InsertBefore(&blocks_to_add_); return; } } assert( false && "Could not add basic blocks to function as insert point was not found."); } // Assign all result_ids in |basic_block| instructions to new IDs and preserve // the mapping of new ids to old ones. void LoopUnrollerUtilsImpl::AssignNewResultIds(BasicBlock* basic_block) { analysis::DefUseManager* def_use_mgr = context_->get_def_use_mgr(); // Label instructions aren't covered by normal traversal of the // instructions. // TODO(1841): Handle id overflow. uint32_t new_label_id = context_->TakeNextId(); // Assign a new id to the label. state_.new_inst[basic_block->GetLabelInst()->result_id()] = new_label_id; basic_block->GetLabelInst()->SetResultId(new_label_id); def_use_mgr->AnalyzeInstDefUse(basic_block->GetLabelInst()); for (Instruction& inst : *basic_block) { // Do def/use analysis on new lines for (auto& line : inst.dbg_line_insts()) def_use_mgr->AnalyzeInstDefUse(&line); uint32_t old_id = inst.result_id(); // Ignore stores etc. if (old_id == 0) { continue; } // Give the instruction a new id. // TODO(1841): Handle id overflow. inst.SetResultId(context_->TakeNextId()); def_use_mgr->AnalyzeInstDef(&inst); // Save the mapping of old_id -> new_id. state_.new_inst[old_id] = inst.result_id(); // Check if this instruction is the induction variable. if (loop_induction_variable_->result_id() == old_id) { // Save a pointer to the new copy of it. state_.new_phi = &inst; } state_.ids_to_new_inst[inst.result_id()] = &inst; } } void LoopUnrollerUtilsImpl::RemapOperands(Instruction* inst) { auto remap_operands_to_new_ids = [this](uint32_t* id) { auto itr = state_.new_inst.find(*id); if (itr != state_.new_inst.end()) { *id = itr->second; } }; inst->ForEachInId(remap_operands_to_new_ids); context_->AnalyzeUses(inst); } void LoopUnrollerUtilsImpl::RemapOperands(BasicBlock* basic_block) { for (Instruction& inst : *basic_block) { RemapOperands(&inst); } } // Generate the ordered list of basic blocks in the |loop| and cache it for // later use. void LoopUnrollerUtilsImpl::ComputeLoopOrderedBlocks(Loop* loop) { loop_blocks_inorder_.clear(); loop->ComputeLoopStructuredOrder(&loop_blocks_inorder_); } // Adds the blocks_to_add_ to both the loop and to the parent. void LoopUnrollerUtilsImpl::AddBlocksToLoop(Loop* loop) const { // Add the blocks to this loop. for (auto& block_itr : blocks_to_add_) { loop->AddBasicBlock(block_itr.get()); } // Add the blocks to the parent as well. if (loop->GetParent()) AddBlocksToLoop(loop->GetParent()); } void LoopUnrollerUtilsImpl::LinkLastPhisToStart(Loop* loop) const { std::vector inductions; loop->GetInductionVariables(inductions); for (size_t i = 0; i < inductions.size(); ++i) { Instruction* last_phi_in_block = state_.previous_phis_[i]; uint32_t phi_index = GetPhiIndexFromLabel(state_.previous_latch_block_, last_phi_in_block); uint32_t phi_variable = last_phi_in_block->GetSingleWordInOperand(phi_index - 1); uint32_t phi_label = last_phi_in_block->GetSingleWordInOperand(phi_index); Instruction* phi = inductions[i]; phi->SetInOperand(phi_index - 1, {phi_variable}); phi->SetInOperand(phi_index, {phi_label}); } } // Duplicate the |loop| body |factor| number of times while keeping the loop // backedge intact. void LoopUnrollerUtilsImpl::PartiallyUnroll(Loop* loop, size_t factor) { Unroll(loop, factor); LinkLastPhisToStart(loop); AddBlocksToLoop(loop); AddBlocksToFunction(loop->GetMergeBlock()); RemoveDeadInstructions(); } /* * End LoopUtilsImpl. */ } // namespace /* * * Begin Utils. * * */ bool LoopUtils::CanPerformUnroll() { // The loop is expected to be in structured order. if (!loop_->GetHeaderBlock()->GetMergeInst()) { return false; } // Find check the loop has a condition we can find and evaluate. const BasicBlock* condition = loop_->FindConditionBlock(); if (!condition) return false; // Check that we can find and process the induction variable. const Instruction* induction = loop_->FindConditionVariable(condition); if (!induction || induction->opcode() != spv::Op::OpPhi) return false; // Check that we can find the number of loop iterations. if (!loop_->FindNumberOfIterations(induction, &*condition->ctail(), nullptr)) return false; #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION // ClusterFuzz/OSS-Fuzz is likely to yield examples with very high loop // iteration counts. This can cause timeouts and memouts during fuzzing that // are not classed as bugs. To avoid this noise, loop unrolling is not applied // to loops with large iteration counts when fuzzing. constexpr size_t kFuzzerIterationLimit = 100; size_t num_iterations; loop_->FindNumberOfIterations(induction, &*condition->ctail(), &num_iterations); if (num_iterations > kFuzzerIterationLimit) { return false; } #endif // Make sure the latch block is a unconditional branch to the header // block. const Instruction& branch = *loop_->GetLatchBlock()->ctail(); bool branching_assumption = branch.opcode() == spv::Op::OpBranch && branch.GetSingleWordInOperand(0) == loop_->GetHeaderBlock()->id(); if (!branching_assumption) { return false; } std::vector inductions; loop_->GetInductionVariables(inductions); // Ban breaks within the loop. const std::vector& merge_block_preds = context_->cfg()->preds(loop_->GetMergeBlock()->id()); if (merge_block_preds.size() != 1) { return false; } // Ban continues within the loop. const std::vector& continue_block_preds = context_->cfg()->preds(loop_->GetContinueBlock()->id()); if (continue_block_preds.size() != 1) { return false; } // Ban returns in the loop. // Iterate over all the blocks within the loop and check that none of them // exit the loop. for (uint32_t label_id : loop_->GetBlocks()) { const BasicBlock* block = context_->cfg()->block(label_id); if (block->ctail()->opcode() == spv::Op::OpKill || block->ctail()->opcode() == spv::Op::OpReturn || block->ctail()->opcode() == spv::Op::OpReturnValue || block->ctail()->opcode() == spv::Op::OpTerminateInvocation) { return false; } } // Can only unroll inner loops. if (!loop_->AreAllChildrenMarkedForRemoval()) { return false; } return true; } bool LoopUtils::PartiallyUnroll(size_t factor) { if (factor == 1 || !CanPerformUnroll()) return false; // Create the unroller utility. LoopUnrollerUtilsImpl unroller{context_, loop_->GetHeaderBlock()->GetParent()}; unroller.Init(loop_); // If the unrolling factor is larger than or the same size as the loop just // fully unroll the loop. if (factor >= unroller.GetLoopIterationCount()) { unroller.FullyUnroll(loop_); return true; } // If the loop unrolling factor is an residual number of iterations we need to // let run the loop for the residual part then let it branch into the unrolled // remaining part. We add one when calucating the remainder to take into // account the one iteration already in the loop. if (unroller.GetLoopIterationCount() % factor != 0) { unroller.PartiallyUnrollResidualFactor(loop_, factor); } else { unroller.PartiallyUnroll(loop_, factor); } return true; } bool LoopUtils::FullyUnroll() { if (!CanPerformUnroll()) return false; std::vector inductions; loop_->GetInductionVariables(inductions); LoopUnrollerUtilsImpl unroller{context_, loop_->GetHeaderBlock()->GetParent()}; unroller.Init(loop_); unroller.FullyUnroll(loop_); return true; } void LoopUtils::Finalize() { // Clean up the loop descriptor to preserve the analysis. LoopDescriptor* LD = context_->GetLoopDescriptor(&function_); LD->PostModificationCleanup(); } /* * * Begin Pass. * */ Pass::Status LoopUnroller::Process() { bool changed = false; for (Function& f : *context()->module()) { if (f.IsDeclaration()) { continue; } LoopDescriptor* LD = context()->GetLoopDescriptor(&f); for (Loop& loop : *LD) { LoopUtils loop_utils{context(), &loop}; if (!loop.HasUnrollLoopControl() || !loop_utils.CanPerformUnroll()) { continue; } if (fully_unroll_) { loop_utils.FullyUnroll(); } else { loop_utils.PartiallyUnroll(unroll_factor_); } changed = true; } LD->PostModificationCleanup(); } return changed ? Status::SuccessWithChange : Status::SuccessWithoutChange; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/loop_unroller.h000066400000000000000000000030271475742701700237010ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_LOOP_UNROLLER_H_ #define SOURCE_OPT_LOOP_UNROLLER_H_ #include "source/opt/pass.h" namespace spvtools { namespace opt { class LoopUnroller : public Pass { public: LoopUnroller() : Pass(), fully_unroll_(true), unroll_factor_(0) {} LoopUnroller(bool fully_unroll, int unroll_factor) : Pass(), fully_unroll_(fully_unroll), unroll_factor_(unroll_factor) {} const char* name() const override { return "loop-unroll"; } Status Process() override; IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisDecorations | IRContext::kAnalysisCombinators | IRContext::kAnalysisNameMap | IRContext::kAnalysisConstants | IRContext::kAnalysisTypes; } private: bool fully_unroll_; int unroll_factor_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_LOOP_UNROLLER_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/loop_unswitch_pass.cpp000066400000000000000000000567321475742701700252770ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/loop_unswitch_pass.h" #include #include #include #include #include #include #include #include "source/opt/basic_block.h" #include "source/opt/dominator_tree.h" #include "source/opt/fold.h" #include "source/opt/function.h" #include "source/opt/instruction.h" #include "source/opt/ir_builder.h" #include "source/opt/ir_context.h" #include "source/opt/loop_descriptor.h" #include "source/opt/loop_utils.h" namespace spvtools { namespace opt { namespace { constexpr uint32_t kTypePointerStorageClassInIdx = 0; // This class handle the unswitch procedure for a given loop. // The unswitch will not happen if: // - The loop has any instruction that will prevent it; // - The loop invariant condition is not uniform. class LoopUnswitch { public: LoopUnswitch(IRContext* context, Function* function, Loop* loop, LoopDescriptor* loop_desc) : function_(function), loop_(loop), loop_desc_(*loop_desc), context_(context), switch_block_(nullptr) {} // Returns true if the loop can be unswitched. // Can be unswitch if: // - The loop has no instructions that prevents it (such as barrier); // - The loop has one conditional branch or switch that do not depends on the // loop; // - The loop invariant condition is uniform; bool CanUnswitchLoop() { if (switch_block_) return true; if (loop_->IsSafeToClone()) return false; CFG& cfg = *context_->cfg(); for (uint32_t bb_id : loop_->GetBlocks()) { BasicBlock* bb = cfg.block(bb_id); if (loop_->GetLatchBlock() == bb) { continue; } if (bb->terminator()->IsBranch() && bb->terminator()->opcode() != spv::Op::OpBranch) { if (IsConditionNonConstantLoopInvariant(bb->terminator())) { switch_block_ = bb; break; } } } return switch_block_; } // Return the iterator to the basic block |bb|. Function::iterator FindBasicBlockPosition(BasicBlock* bb_to_find) { Function::iterator it = function_->FindBlock(bb_to_find->id()); assert(it != function_->end() && "Basic Block not found"); return it; } // Creates a new basic block and insert it into the function |fn| at the // position |ip|. This function preserves the def/use and instr to block // managers. BasicBlock* CreateBasicBlock(Function::iterator ip) { analysis::DefUseManager* def_use_mgr = context_->get_def_use_mgr(); // TODO(1841): Handle id overflow. BasicBlock* bb = &*ip.InsertBefore(std::unique_ptr( new BasicBlock(std::unique_ptr(new Instruction( context_, spv::Op::OpLabel, 0, context_->TakeNextId(), {}))))); bb->SetParent(function_); def_use_mgr->AnalyzeInstDef(bb->GetLabelInst()); context_->set_instr_block(bb->GetLabelInst(), bb); return bb; } Instruction* GetValueForDefaultPathForSwitch(Instruction* switch_inst) { assert(switch_inst->opcode() == spv::Op::OpSwitch && "The given instructoin must be an OpSwitch."); // Find a value that can be used to select the default path. // If none are possible, then it will just use 0. The value does not matter // because this path will never be taken because the new switch outside of // the loop cannot select this path either. std::vector existing_values; for (uint32_t i = 2; i < switch_inst->NumInOperands(); i += 2) { existing_values.push_back(switch_inst->GetSingleWordInOperand(i)); } std::sort(existing_values.begin(), existing_values.end()); uint32_t value_for_default_path = 0; if (existing_values.size() < std::numeric_limits::max()) { for (value_for_default_path = 0; value_for_default_path < existing_values.size(); value_for_default_path++) { if (existing_values[value_for_default_path] != value_for_default_path) { break; } } } InstructionBuilder builder( context_, static_cast(nullptr), IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); return builder.GetUintConstant(value_for_default_path); } // Unswitches |loop_|. void PerformUnswitch() { assert(CanUnswitchLoop() && "Cannot unswitch if there is not constant condition"); assert(loop_->GetPreHeaderBlock() && "This loop has no pre-header block"); assert(loop_->IsLCSSA() && "This loop is not in LCSSA form"); CFG& cfg = *context_->cfg(); DominatorTree* dom_tree = &context_->GetDominatorAnalysis(function_)->GetDomTree(); analysis::DefUseManager* def_use_mgr = context_->get_def_use_mgr(); LoopUtils loop_utils(context_, loop_); ////////////////////////////////////////////////////////////////////////////// // Step 1: Create the if merge block for structured modules. // To do so, the |loop_| merge block will become the if's one and we // create a merge for the loop. This will limit the amount of duplicated // code the structured control flow imposes. // For non structured program, the new loop will be connected to // the old loop's exit blocks. ////////////////////////////////////////////////////////////////////////////// // Get the merge block if it exists. BasicBlock* if_merge_block = loop_->GetMergeBlock(); // The merge block is only created if the loop has a unique exit block. We // have this guarantee for structured loops, for compute loop it will // trivially help maintain both a structured-like form and LCSAA. BasicBlock* loop_merge_block = if_merge_block ? CreateBasicBlock(FindBasicBlockPosition(if_merge_block)) : nullptr; if (loop_merge_block) { // Add the instruction and update managers. InstructionBuilder builder( context_, loop_merge_block, IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); builder.AddBranch(if_merge_block->id()); builder.SetInsertPoint(&*loop_merge_block->begin()); cfg.RegisterBlock(loop_merge_block); def_use_mgr->AnalyzeInstDef(loop_merge_block->GetLabelInst()); // Update CFG. if_merge_block->ForEachPhiInst( [loop_merge_block, &builder, this](Instruction* phi) { Instruction* cloned = phi->Clone(context_); cloned->SetResultId(TakeNextId()); builder.AddInstruction(std::unique_ptr(cloned)); phi->SetInOperand(0, {cloned->result_id()}); phi->SetInOperand(1, {loop_merge_block->id()}); for (uint32_t j = phi->NumInOperands() - 1; j > 1; j--) phi->RemoveInOperand(j); }); // Copy the predecessor list (will get invalidated otherwise). std::vector preds = cfg.preds(if_merge_block->id()); for (uint32_t pid : preds) { if (pid == loop_merge_block->id()) continue; BasicBlock* p_bb = cfg.block(pid); p_bb->ForEachSuccessorLabel( [if_merge_block, loop_merge_block](uint32_t* id) { if (*id == if_merge_block->id()) *id = loop_merge_block->id(); }); cfg.AddEdge(pid, loop_merge_block->id()); } cfg.RemoveNonExistingEdges(if_merge_block->id()); // Update loop descriptor. if (Loop* ploop = loop_->GetParent()) { ploop->AddBasicBlock(loop_merge_block); loop_desc_.SetBasicBlockToLoop(loop_merge_block->id(), ploop); } // Update the dominator tree. DominatorTreeNode* loop_merge_dtn = dom_tree->GetOrInsertNode(loop_merge_block); DominatorTreeNode* if_merge_block_dtn = dom_tree->GetOrInsertNode(if_merge_block); loop_merge_dtn->parent_ = if_merge_block_dtn->parent_; loop_merge_dtn->children_.push_back(if_merge_block_dtn); loop_merge_dtn->parent_->children_.push_back(loop_merge_dtn); if_merge_block_dtn->parent_->children_.erase(std::find( if_merge_block_dtn->parent_->children_.begin(), if_merge_block_dtn->parent_->children_.end(), if_merge_block_dtn)); loop_->SetMergeBlock(loop_merge_block); } //////////////////////////////////////////////////////////////////////////// // Step 2: Build a new preheader for |loop_|, use the old one // for the invariant branch. //////////////////////////////////////////////////////////////////////////// BasicBlock* if_block = loop_->GetPreHeaderBlock(); // If this preheader is the parent loop header, // we need to create a dedicated block for the if. BasicBlock* loop_pre_header = CreateBasicBlock(++FindBasicBlockPosition(if_block)); InstructionBuilder( context_, loop_pre_header, IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping) .AddBranch(loop_->GetHeaderBlock()->id()); if_block->tail()->SetInOperand(0, {loop_pre_header->id()}); // Update loop descriptor. if (Loop* ploop = loop_desc_[if_block]) { ploop->AddBasicBlock(loop_pre_header); loop_desc_.SetBasicBlockToLoop(loop_pre_header->id(), ploop); } // Update the CFG. cfg.RegisterBlock(loop_pre_header); def_use_mgr->AnalyzeInstDef(loop_pre_header->GetLabelInst()); cfg.AddEdge(if_block->id(), loop_pre_header->id()); cfg.RemoveNonExistingEdges(loop_->GetHeaderBlock()->id()); loop_->GetHeaderBlock()->ForEachPhiInst( [loop_pre_header, if_block](Instruction* phi) { phi->ForEachInId([loop_pre_header, if_block](uint32_t* id) { if (*id == if_block->id()) { *id = loop_pre_header->id(); } }); }); loop_->SetPreHeaderBlock(loop_pre_header); // Update the dominator tree. DominatorTreeNode* loop_pre_header_dtn = dom_tree->GetOrInsertNode(loop_pre_header); DominatorTreeNode* if_block_dtn = dom_tree->GetTreeNode(if_block); loop_pre_header_dtn->parent_ = if_block_dtn; assert( if_block_dtn->children_.size() == 1 && "A loop preheader should only have the header block as a child in the " "dominator tree"); loop_pre_header_dtn->children_.push_back(if_block_dtn->children_[0]); if_block_dtn->children_.clear(); if_block_dtn->children_.push_back(loop_pre_header_dtn); // Make domination queries valid. dom_tree->ResetDFNumbering(); // Compute an ordered list of basic block to clone: loop blocks + pre-header // + merge block. loop_->ComputeLoopStructuredOrder(&ordered_loop_blocks_, true, true); ///////////////////////////// // Do the actual unswitch: // // - Clone the loop // // - Connect exits // // - Specialize the loop // ///////////////////////////// Instruction* iv_condition = &*switch_block_->tail(); spv::Op iv_opcode = iv_condition->opcode(); Instruction* condition = def_use_mgr->GetDef(iv_condition->GetOperand(0).words[0]); analysis::ConstantManager* cst_mgr = context_->get_constant_mgr(); const analysis::Type* cond_type = context_->get_type_mgr()->GetType(condition->type_id()); // Build the list of value for which we need to clone and specialize the // loop. std::vector> constant_branch; // Special case for the original loop Instruction* original_loop_constant_value; if (iv_opcode == spv::Op::OpBranchConditional) { constant_branch.emplace_back( cst_mgr->GetDefiningInstruction(cst_mgr->GetConstant(cond_type, {0})), nullptr); original_loop_constant_value = cst_mgr->GetDefiningInstruction(cst_mgr->GetConstant(cond_type, {1})); } else { // We are looking to take the default branch, so we can't provide a // specific value. original_loop_constant_value = GetValueForDefaultPathForSwitch(iv_condition); for (uint32_t i = 2; i < iv_condition->NumInOperands(); i += 2) { constant_branch.emplace_back( cst_mgr->GetDefiningInstruction(cst_mgr->GetConstant( cond_type, iv_condition->GetInOperand(i).words)), nullptr); } } // Get the loop landing pads. std::unordered_set if_merging_blocks; std::function is_from_original_loop; if (loop_->GetHeaderBlock()->GetLoopMergeInst()) { if_merging_blocks.insert(if_merge_block->id()); is_from_original_loop = [this](uint32_t id) { return loop_->IsInsideLoop(id) || loop_->GetMergeBlock()->id() == id; }; } else { loop_->GetExitBlocks(&if_merging_blocks); is_from_original_loop = [this](uint32_t id) { return loop_->IsInsideLoop(id); }; } for (auto& specialisation_pair : constant_branch) { Instruction* specialisation_value = specialisation_pair.first; ////////////////////////////////////////////////////////// // Step 3: Duplicate |loop_|. ////////////////////////////////////////////////////////// LoopUtils::LoopCloningResult clone_result; Loop* cloned_loop = loop_utils.CloneLoop(&clone_result, ordered_loop_blocks_); specialisation_pair.second = cloned_loop->GetPreHeaderBlock(); //////////////////////////////////// // Step 4: Specialize the loop. // //////////////////////////////////// { SpecializeLoop(cloned_loop, condition, specialisation_value); /////////////////////////////////////////////////////////// // Step 5: Connect convergent edges to the landing pads. // /////////////////////////////////////////////////////////// for (uint32_t merge_bb_id : if_merging_blocks) { BasicBlock* merge = context_->cfg()->block(merge_bb_id); // We are in LCSSA so we only care about phi instructions. merge->ForEachPhiInst( [is_from_original_loop, &clone_result](Instruction* phi) { uint32_t num_in_operands = phi->NumInOperands(); for (uint32_t i = 0; i < num_in_operands; i += 2) { uint32_t pred = phi->GetSingleWordInOperand(i + 1); if (is_from_original_loop(pred)) { pred = clone_result.value_map_.at(pred); uint32_t incoming_value_id = phi->GetSingleWordInOperand(i); // Not all the incoming values are coming from the loop. ValueMapTy::iterator new_value = clone_result.value_map_.find(incoming_value_id); if (new_value != clone_result.value_map_.end()) { incoming_value_id = new_value->second; } phi->AddOperand({SPV_OPERAND_TYPE_ID, {incoming_value_id}}); phi->AddOperand({SPV_OPERAND_TYPE_ID, {pred}}); } } }); } } function_->AddBasicBlocks(clone_result.cloned_bb_.begin(), clone_result.cloned_bb_.end(), ++FindBasicBlockPosition(if_block)); } // Specialize the existing loop. SpecializeLoop(loop_, condition, original_loop_constant_value); BasicBlock* original_loop_target = loop_->GetPreHeaderBlock(); ///////////////////////////////////// // Finally: connect the new loops. // ///////////////////////////////////// // Delete the old jump context_->KillInst(&*if_block->tail()); InstructionBuilder builder(context_, if_block); if (iv_opcode == spv::Op::OpBranchConditional) { assert(constant_branch.size() == 1); builder.AddConditionalBranch( condition->result_id(), original_loop_target->id(), constant_branch[0].second->id(), if_merge_block ? if_merge_block->id() : kInvalidId); } else { std::vector> targets; for (auto& t : constant_branch) { targets.emplace_back(t.first->GetInOperand(0).words, t.second->id()); } builder.AddSwitch(condition->result_id(), original_loop_target->id(), targets, if_merge_block ? if_merge_block->id() : kInvalidId); } switch_block_ = nullptr; ordered_loop_blocks_.clear(); context_->InvalidateAnalysesExceptFor( IRContext::Analysis::kAnalysisLoopAnalysis); } private: using ValueMapTy = std::unordered_map; using BlockMapTy = std::unordered_map; Function* function_; Loop* loop_; LoopDescriptor& loop_desc_; IRContext* context_; BasicBlock* switch_block_; // Map between instructions and if they are dynamically uniform. std::unordered_map dynamically_uniform_; // The loop basic blocks in structured order. std::vector ordered_loop_blocks_; // Returns the next usable id for the context. uint32_t TakeNextId() { // TODO(1841): Handle id overflow. return context_->TakeNextId(); } // Simplifies |loop| assuming the instruction |to_version_insn| takes the // value |cst_value|. |block_range| is an iterator range returning the loop // basic blocks in a structured order (dominator first). // The function will ignore basic blocks returned by |block_range| if they // does not belong to the loop. // The set |dead_blocks| will contain all the dead basic blocks. // // Requirements: // - |loop| must be in the LCSSA form; // - |cst_value| must be constant. void SpecializeLoop(Loop* loop, Instruction* to_version_insn, Instruction* cst_value) { analysis::DefUseManager* def_use_mgr = context_->get_def_use_mgr(); std::function ignore_node; ignore_node = [loop](uint32_t bb_id) { return !loop->IsInsideLoop(bb_id); }; std::vector> use_list; def_use_mgr->ForEachUse(to_version_insn, [&use_list, &ignore_node, this]( Instruction* inst, uint32_t operand_index) { BasicBlock* bb = context_->get_instr_block(inst); if (!bb || ignore_node(bb->id())) { // Out of the loop, the specialization does not // apply any more. return; } use_list.emplace_back(inst, operand_index); }); // First pass: inject the specialized value into the loop (and only the // loop). for (auto use : use_list) { Instruction* inst = use.first; uint32_t operand_index = use.second; // To also handle switch, cst_value can be nullptr: this case // means that we are looking to branch to the default target of // the switch. We don't actually know its value so we don't touch // it if it not a switch. assert(cst_value && "We do not have a value to use."); inst->SetOperand(operand_index, {cst_value->result_id()}); def_use_mgr->AnalyzeInstUse(inst); } } // Returns true if |var| is dynamically uniform. // Note: this is currently approximated as uniform. bool IsDynamicallyUniform(Instruction* var, const BasicBlock* entry, const DominatorTree& post_dom_tree) { assert(post_dom_tree.IsPostDominator()); analysis::DefUseManager* def_use_mgr = context_->get_def_use_mgr(); auto it = dynamically_uniform_.find(var->result_id()); if (it != dynamically_uniform_.end()) return it->second; analysis::DecorationManager* dec_mgr = context_->get_decoration_mgr(); bool& is_uniform = dynamically_uniform_[var->result_id()]; is_uniform = false; dec_mgr->WhileEachDecoration(var->result_id(), uint32_t(spv::Decoration::Uniform), [&is_uniform](const Instruction&) { is_uniform = true; return false; }); if (is_uniform) { return is_uniform; } BasicBlock* parent = context_->get_instr_block(var); if (!parent) { return is_uniform = true; } if (!post_dom_tree.Dominates(parent->id(), entry->id())) { return is_uniform = false; } if (var->opcode() == spv::Op::OpLoad) { const uint32_t PtrTypeId = def_use_mgr->GetDef(var->GetSingleWordInOperand(0))->type_id(); const Instruction* PtrTypeInst = def_use_mgr->GetDef(PtrTypeId); auto storage_class = spv::StorageClass( PtrTypeInst->GetSingleWordInOperand(kTypePointerStorageClassInIdx)); if (storage_class != spv::StorageClass::Uniform && storage_class != spv::StorageClass::UniformConstant) { return is_uniform = false; } } else { if (!context_->IsCombinatorInstruction(var)) { return is_uniform = false; } } return is_uniform = var->WhileEachInId([entry, &post_dom_tree, this](const uint32_t* id) { return IsDynamicallyUniform(context_->get_def_use_mgr()->GetDef(*id), entry, post_dom_tree); }); } // Returns true if |insn| is not a constant, but is loop invariant and // dynamically uniform. bool IsConditionNonConstantLoopInvariant(Instruction* insn) { assert(insn->IsBranch()); assert(insn->opcode() != spv::Op::OpBranch); analysis::DefUseManager* def_use_mgr = context_->get_def_use_mgr(); Instruction* condition = def_use_mgr->GetDef(insn->GetOperand(0).words[0]); if (condition->IsConstant()) { return false; } if (loop_->IsInsideLoop(condition)) { return false; } return IsDynamicallyUniform( condition, function_->entry().get(), context_->GetPostDominatorAnalysis(function_)->GetDomTree()); } }; } // namespace Pass::Status LoopUnswitchPass::Process() { bool modified = false; Module* module = context()->module(); // Process each function in the module for (Function& f : *module) { modified |= ProcessFunction(&f); } return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } bool LoopUnswitchPass::ProcessFunction(Function* f) { bool modified = false; std::unordered_set processed_loop; LoopDescriptor& loop_descriptor = *context()->GetLoopDescriptor(f); bool loop_changed = true; while (loop_changed) { loop_changed = false; for (Loop& loop : make_range( ++TreeDFIterator(loop_descriptor.GetPlaceholderRootLoop()), TreeDFIterator())) { if (processed_loop.count(&loop)) continue; processed_loop.insert(&loop); LoopUnswitch unswitcher(context(), f, &loop, &loop_descriptor); while (unswitcher.CanUnswitchLoop()) { if (!loop.IsLCSSA()) { LoopUtils(context(), &loop).MakeLoopClosedSSA(); } modified = true; loop_changed = true; unswitcher.PerformUnswitch(); } if (loop_changed) break; } } return modified; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/loop_unswitch_pass.h000066400000000000000000000027231475742701700247330ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_LOOP_UNSWITCH_PASS_H_ #define SOURCE_OPT_LOOP_UNSWITCH_PASS_H_ #include "source/opt/loop_descriptor.h" #include "source/opt/pass.h" namespace spvtools { namespace opt { // Implements the loop unswitch optimization. // The loop unswitch hoists invariant "if" statements if the conditions are // constant within the loop and clones the loop for each branch. class LoopUnswitchPass : public Pass { public: const char* name() const override { return "loop-unswitch"; } // Processes the given |module|. Returns Status::Failure if errors occur when // processing. Returns the corresponding Status::Success if processing is // successful to indicate whether changes have been made to the module. Pass::Status Process() override; private: bool ProcessFunction(Function* f); }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_LOOP_UNSWITCH_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/loop_utils.cpp000066400000000000000000000662641475742701700235460ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include #include #include #include "source/cfa.h" #include "source/opt/cfg.h" #include "source/opt/ir_builder.h" #include "source/opt/ir_context.h" #include "source/opt/loop_descriptor.h" #include "source/opt/loop_utils.h" namespace spvtools { namespace opt { namespace { // Return true if |bb| is dominated by at least one block in |exits| inline bool DominatesAnExit(BasicBlock* bb, const std::unordered_set& exits, const DominatorTree& dom_tree) { for (BasicBlock* e_bb : exits) if (dom_tree.Dominates(bb, e_bb)) return true; return false; } // Utility class to rewrite out-of-loop uses of an in-loop definition in terms // of phi instructions to achieve a LCSSA form. // For a given definition, the class user registers phi instructions using that // definition in all loop exit blocks by which the definition escapes. // Then, when rewriting a use of the definition, the rewriter walks the // paths from the use the loop exits. At each step, it will insert a phi // instruction to merge the incoming value according to exit blocks definition. class LCSSARewriter { public: LCSSARewriter(IRContext* context, const DominatorTree& dom_tree, const std::unordered_set& exit_bb, BasicBlock* merge_block) : context_(context), cfg_(context_->cfg()), dom_tree_(dom_tree), exit_bb_(exit_bb), merge_block_id_(merge_block ? merge_block->id() : 0) {} struct UseRewriter { explicit UseRewriter(LCSSARewriter* base, const Instruction& def_insn) : base_(base), def_insn_(def_insn) {} // Rewrites the use of |def_insn_| by the instruction |user| at the index // |operand_index| in terms of phi instruction. This recursively builds new // phi instructions from |user| to the loop exit blocks' phis. The use of // |def_insn_| in |user| is replaced by the relevant phi instruction at the // end of the operation. // It is assumed that |user| does not dominates any of the loop exit basic // block. This operation does not update the def/use manager, instead it // records what needs to be updated. The actual update is performed by // UpdateManagers. void RewriteUse(BasicBlock* bb, Instruction* user, uint32_t operand_index) { assert( (user->opcode() != spv::Op::OpPhi || bb != GetParent(user)) && "The root basic block must be the incoming edge if |user| is a phi " "instruction"); assert((user->opcode() == spv::Op::OpPhi || bb == GetParent(user)) && "The root basic block must be the instruction parent if |user| is " "not " "phi instruction"); Instruction* new_def = GetOrBuildIncoming(bb->id()); user->SetOperand(operand_index, {new_def->result_id()}); rewritten_.insert(user); } // In-place update of some managers (avoid full invalidation). inline void UpdateManagers() { analysis::DefUseManager* def_use_mgr = base_->context_->get_def_use_mgr(); // Register all new definitions. for (Instruction* insn : rewritten_) { def_use_mgr->AnalyzeInstDef(insn); } // Register all new uses. for (Instruction* insn : rewritten_) { def_use_mgr->AnalyzeInstUse(insn); } } private: // Return the basic block that |instr| belongs to. BasicBlock* GetParent(Instruction* instr) { return base_->context_->get_instr_block(instr); } // Builds a phi instruction for the basic block |bb|. The function assumes // that |defining_blocks| contains the list of basic block that define the // usable value for each predecessor of |bb|. inline Instruction* CreatePhiInstruction( BasicBlock* bb, const std::vector& defining_blocks) { std::vector incomings; const std::vector& bb_preds = base_->cfg_->preds(bb->id()); assert(bb_preds.size() == defining_blocks.size()); for (size_t i = 0; i < bb_preds.size(); i++) { incomings.push_back( GetOrBuildIncoming(defining_blocks[i])->result_id()); incomings.push_back(bb_preds[i]); } InstructionBuilder builder(base_->context_, &*bb->begin(), IRContext::kAnalysisInstrToBlockMapping); Instruction* incoming_phi = builder.AddPhi(def_insn_.type_id(), incomings); rewritten_.insert(incoming_phi); return incoming_phi; } // Builds a phi instruction for the basic block |bb|, all incoming values // will be |value|. inline Instruction* CreatePhiInstruction(BasicBlock* bb, const Instruction& value) { std::vector incomings; const std::vector& bb_preds = base_->cfg_->preds(bb->id()); for (size_t i = 0; i < bb_preds.size(); i++) { incomings.push_back(value.result_id()); incomings.push_back(bb_preds[i]); } InstructionBuilder builder(base_->context_, &*bb->begin(), IRContext::kAnalysisInstrToBlockMapping); Instruction* incoming_phi = builder.AddPhi(def_insn_.type_id(), incomings); rewritten_.insert(incoming_phi); return incoming_phi; } // Return the new def to use for the basic block |bb_id|. // If |bb_id| does not have a suitable def to use then we: // - return the common def used by all predecessors; // - if there is no common def, then we build a new phi instr at the // beginning of |bb_id| and return this new instruction. Instruction* GetOrBuildIncoming(uint32_t bb_id) { assert(base_->cfg_->block(bb_id) != nullptr && "Unknown basic block"); Instruction*& incoming_phi = bb_to_phi_[bb_id]; if (incoming_phi) { return incoming_phi; } BasicBlock* bb = &*base_->cfg_->block(bb_id); // If this is an exit basic block, look if there already is an eligible // phi instruction. An eligible phi has |def_insn_| as all incoming // values. if (base_->exit_bb_.count(bb)) { // Look if there is an eligible phi in this block. if (!bb->WhileEachPhiInst([&incoming_phi, this](Instruction* phi) { for (uint32_t i = 0; i < phi->NumInOperands(); i += 2) { if (phi->GetSingleWordInOperand(i) != def_insn_.result_id()) return true; } incoming_phi = phi; rewritten_.insert(incoming_phi); return false; })) { return incoming_phi; } incoming_phi = CreatePhiInstruction(bb, def_insn_); return incoming_phi; } // Get the block that defines the value to use for each predecessor. // If the vector has 1 value, then it means that this block does not need // to build a phi instruction unless |bb_id| is the loop merge block. const std::vector& defining_blocks = base_->GetDefiningBlocks(bb_id); // Special case for structured loops: merge block might be different from // the exit block set. To maintain structured properties it will ease // transformations if the merge block also holds a phi instruction like // the exit ones. if (defining_blocks.size() > 1 || bb_id == base_->merge_block_id_) { if (defining_blocks.size() > 1) { incoming_phi = CreatePhiInstruction(bb, defining_blocks); } else { assert(bb_id == base_->merge_block_id_); incoming_phi = CreatePhiInstruction(bb, *GetOrBuildIncoming(defining_blocks[0])); } } else { incoming_phi = GetOrBuildIncoming(defining_blocks[0]); } return incoming_phi; } LCSSARewriter* base_; const Instruction& def_insn_; std::unordered_map bb_to_phi_; std::unordered_set rewritten_; }; private: // Return the new def to use for the basic block |bb_id|. // If |bb_id| does not have a suitable def to use then we: // - return the common def used by all predecessors; // - if there is no common def, then we build a new phi instr at the // beginning of |bb_id| and return this new instruction. const std::vector& GetDefiningBlocks(uint32_t bb_id) { assert(cfg_->block(bb_id) != nullptr && "Unknown basic block"); std::vector& defining_blocks = bb_to_defining_blocks_[bb_id]; if (defining_blocks.size()) return defining_blocks; // Check if one of the loop exit basic block dominates |bb_id|. for (const BasicBlock* e_bb : exit_bb_) { if (dom_tree_.Dominates(e_bb->id(), bb_id)) { defining_blocks.push_back(e_bb->id()); return defining_blocks; } } // Process parents, they will returns their suitable blocks. // If they are all the same, this means this basic block is dominated by a // common block, so we won't need to build a phi instruction. for (uint32_t pred_id : cfg_->preds(bb_id)) { const std::vector& pred_blocks = GetDefiningBlocks(pred_id); if (pred_blocks.size() == 1) defining_blocks.push_back(pred_blocks[0]); else defining_blocks.push_back(pred_id); } assert(defining_blocks.size()); if (std::all_of(defining_blocks.begin(), defining_blocks.end(), [&defining_blocks](uint32_t id) { return id == defining_blocks[0]; })) { // No need for a phi. defining_blocks.resize(1); } return defining_blocks; } IRContext* context_; CFG* cfg_; const DominatorTree& dom_tree_; const std::unordered_set& exit_bb_; uint32_t merge_block_id_; // This map represent the set of known paths. For each key, the vector // represent the set of blocks holding the definition to be used to build the // phi instruction. // If the vector has 0 value, then the path is unknown yet, and must be built. // If the vector has 1 value, then the value defined by that basic block // should be used. // If the vector has more than 1 value, then a phi node must be created, the // basic block ordering is the same as the predecessor ordering. std::unordered_map> bb_to_defining_blocks_; }; // Make the set |blocks| closed SSA. The set is closed SSA if all the uses // outside the set are phi instructions in exiting basic block set (hold by // |lcssa_rewriter|). inline void MakeSetClosedSSA(IRContext* context, Function* function, const std::unordered_set& blocks, const std::unordered_set& exit_bb, LCSSARewriter* lcssa_rewriter) { CFG& cfg = *context->cfg(); DominatorTree& dom_tree = context->GetDominatorAnalysis(function)->GetDomTree(); analysis::DefUseManager* def_use_manager = context->get_def_use_mgr(); for (uint32_t bb_id : blocks) { BasicBlock* bb = cfg.block(bb_id); // If bb does not dominate an exit block, then it cannot have escaping defs. if (!DominatesAnExit(bb, exit_bb, dom_tree)) continue; for (Instruction& inst : *bb) { LCSSARewriter::UseRewriter rewriter(lcssa_rewriter, inst); def_use_manager->ForEachUse( &inst, [&blocks, &rewriter, &exit_bb, context]( Instruction* use, uint32_t operand_index) { BasicBlock* use_parent = context->get_instr_block(use); assert(use_parent); if (blocks.count(use_parent->id())) return; if (use->opcode() == spv::Op::OpPhi) { // If the use is a Phi instruction and the incoming block is // coming from the loop, then that's consistent with LCSSA form. if (exit_bb.count(use_parent)) { return; } else { // That's not an exit block, but the user is a phi instruction. // Consider the incoming branch only. use_parent = context->get_instr_block( use->GetSingleWordOperand(operand_index + 1)); } } // Rewrite the use. Note that this call does not invalidate the // def/use manager. So this operation is safe. rewriter.RewriteUse(use_parent, use, operand_index); }); rewriter.UpdateManagers(); } } } } // namespace void LoopUtils::CreateLoopDedicatedExits() { Function* function = loop_->GetHeaderBlock()->GetParent(); LoopDescriptor& loop_desc = *context_->GetLoopDescriptor(function); CFG& cfg = *context_->cfg(); analysis::DefUseManager* def_use_mgr = context_->get_def_use_mgr(); const IRContext::Analysis PreservedAnalyses = IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping; // Gathers the set of basic block that are not in this loop and have at least // one predecessor in the loop and one not in the loop. std::unordered_set exit_bb_set; loop_->GetExitBlocks(&exit_bb_set); std::unordered_set new_loop_exits; bool made_change = false; // For each block, we create a new one that gathers all branches from // the loop and fall into the block. for (uint32_t non_dedicate_id : exit_bb_set) { BasicBlock* non_dedicate = cfg.block(non_dedicate_id); const std::vector& bb_pred = cfg.preds(non_dedicate_id); // Ignore the block if all the predecessors are in the loop. if (std::all_of(bb_pred.begin(), bb_pred.end(), [this](uint32_t id) { return loop_->IsInsideLoop(id); })) { new_loop_exits.insert(non_dedicate); continue; } made_change = true; Function::iterator insert_pt = function->begin(); for (; insert_pt != function->end() && &*insert_pt != non_dedicate; ++insert_pt) { } assert(insert_pt != function->end() && "Basic Block not found"); // Create the dedicate exit basic block. // TODO(1841): Handle id overflow. BasicBlock& exit = *insert_pt.InsertBefore(std::unique_ptr( new BasicBlock(std::unique_ptr(new Instruction( context_, spv::Op::OpLabel, 0, context_->TakeNextId(), {}))))); exit.SetParent(function); // Redirect in loop predecessors to |exit| block. for (uint32_t exit_pred_id : bb_pred) { if (loop_->IsInsideLoop(exit_pred_id)) { BasicBlock* pred_block = cfg.block(exit_pred_id); pred_block->ForEachSuccessorLabel([non_dedicate, &exit](uint32_t* id) { if (*id == non_dedicate->id()) *id = exit.id(); }); // Update the CFG. // |non_dedicate|'s predecessor list will be updated at the end of the // loop. cfg.RegisterBlock(pred_block); } } // Register the label to the def/use manager, requires for the phi patching. def_use_mgr->AnalyzeInstDefUse(exit.GetLabelInst()); context_->set_instr_block(exit.GetLabelInst(), &exit); InstructionBuilder builder(context_, &exit, PreservedAnalyses); // Now jump from our dedicate basic block to the old exit. // We also reset the insert point so all instructions are inserted before // the branch. builder.SetInsertPoint(builder.AddBranch(non_dedicate->id())); non_dedicate->ForEachPhiInst( [&builder, &exit, def_use_mgr, this](Instruction* phi) { // New phi operands for this instruction. std::vector new_phi_op; // Phi operands for the dedicated exit block. std::vector exit_phi_op; for (uint32_t i = 0; i < phi->NumInOperands(); i += 2) { uint32_t def_id = phi->GetSingleWordInOperand(i); uint32_t incoming_id = phi->GetSingleWordInOperand(i + 1); if (loop_->IsInsideLoop(incoming_id)) { exit_phi_op.push_back(def_id); exit_phi_op.push_back(incoming_id); } else { new_phi_op.push_back(def_id); new_phi_op.push_back(incoming_id); } } // Build the new phi instruction dedicated exit block. Instruction* exit_phi = builder.AddPhi(phi->type_id(), exit_phi_op); // Build the new incoming branch. new_phi_op.push_back(exit_phi->result_id()); new_phi_op.push_back(exit.id()); // Rewrite operands. uint32_t idx = 0; for (; idx < new_phi_op.size(); idx++) phi->SetInOperand(idx, {new_phi_op[idx]}); // Remove extra operands, from last to first (more efficient). for (uint32_t j = phi->NumInOperands() - 1; j >= idx; j--) phi->RemoveInOperand(j); // Update the def/use manager for this |phi|. def_use_mgr->AnalyzeInstUse(phi); }); // Update the CFG. cfg.RegisterBlock(&exit); cfg.RemoveNonExistingEdges(non_dedicate->id()); new_loop_exits.insert(&exit); // If non_dedicate is in a loop, add the new dedicated exit in that loop. if (Loop* parent_loop = loop_desc[non_dedicate]) parent_loop->AddBasicBlock(&exit); } if (new_loop_exits.size() == 1) { loop_->SetMergeBlock(*new_loop_exits.begin()); } if (made_change) { context_->InvalidateAnalysesExceptFor( PreservedAnalyses | IRContext::kAnalysisCFG | IRContext::Analysis::kAnalysisLoopAnalysis); } } void LoopUtils::MakeLoopClosedSSA() { CreateLoopDedicatedExits(); Function* function = loop_->GetHeaderBlock()->GetParent(); CFG& cfg = *context_->cfg(); DominatorTree& dom_tree = context_->GetDominatorAnalysis(function)->GetDomTree(); std::unordered_set exit_bb; { std::unordered_set exit_bb_id; loop_->GetExitBlocks(&exit_bb_id); for (uint32_t bb_id : exit_bb_id) { exit_bb.insert(cfg.block(bb_id)); } } LCSSARewriter lcssa_rewriter(context_, dom_tree, exit_bb, loop_->GetMergeBlock()); MakeSetClosedSSA(context_, function, loop_->GetBlocks(), exit_bb, &lcssa_rewriter); // Make sure all defs post-dominated by the merge block have their last use no // further than the merge block. if (loop_->GetMergeBlock()) { std::unordered_set merging_bb_id; loop_->GetMergingBlocks(&merging_bb_id); merging_bb_id.erase(loop_->GetMergeBlock()->id()); // Reset the exit set, now only the merge block is the exit. exit_bb.clear(); exit_bb.insert(loop_->GetMergeBlock()); // LCSSARewriter is reusable here only because it forces the creation of a // phi instruction in the merge block. MakeSetClosedSSA(context_, function, merging_bb_id, exit_bb, &lcssa_rewriter); } context_->InvalidateAnalysesExceptFor( IRContext::Analysis::kAnalysisCFG | IRContext::Analysis::kAnalysisDominatorAnalysis | IRContext::Analysis::kAnalysisLoopAnalysis); } Loop* LoopUtils::CloneLoop(LoopCloningResult* cloning_result) const { // Compute the structured order of the loop basic blocks and store it in the // vector ordered_loop_blocks. std::vector ordered_loop_blocks; loop_->ComputeLoopStructuredOrder(&ordered_loop_blocks); // Clone the loop. return CloneLoop(cloning_result, ordered_loop_blocks); } Loop* LoopUtils::CloneAndAttachLoopToHeader(LoopCloningResult* cloning_result) { // Clone the loop. Loop* new_loop = CloneLoop(cloning_result); // Create a new exit block/label for the new loop. // TODO(1841): Handle id overflow. std::unique_ptr new_label{new Instruction( context_, spv::Op::OpLabel, 0, context_->TakeNextId(), {})}; std::unique_ptr new_exit_bb{new BasicBlock(std::move(new_label))}; new_exit_bb->SetParent(loop_->GetMergeBlock()->GetParent()); // Create an unconditional branch to the header block. InstructionBuilder builder{context_, new_exit_bb.get()}; builder.AddBranch(loop_->GetHeaderBlock()->id()); // Save the ids of the new and old merge block. const uint32_t old_merge_block = loop_->GetMergeBlock()->id(); const uint32_t new_merge_block = new_exit_bb->id(); // Replace the uses of the old merge block in the new loop with the new merge // block. for (std::unique_ptr& basic_block : cloning_result->cloned_bb_) { for (Instruction& inst : *basic_block) { // For each operand in each instruction check if it is using the old merge // block and change it to be the new merge block. auto replace_merge_use = [old_merge_block, new_merge_block](uint32_t* id) { if (*id == old_merge_block) *id = new_merge_block; }; inst.ForEachInOperand(replace_merge_use); } } const uint32_t old_header = loop_->GetHeaderBlock()->id(); const uint32_t new_header = new_loop->GetHeaderBlock()->id(); analysis::DefUseManager* def_use = context_->get_def_use_mgr(); def_use->ForEachUse(old_header, [new_header, this](Instruction* inst, uint32_t operand) { if (!this->loop_->IsInsideLoop(inst)) inst->SetOperand(operand, {new_header}); }); // TODO(1841): Handle failure to create pre-header. def_use->ForEachUse( loop_->GetOrCreatePreHeaderBlock()->id(), [new_merge_block, this](Instruction* inst, uint32_t operand) { if (this->loop_->IsInsideLoop(inst)) inst->SetOperand(operand, {new_merge_block}); }); new_loop->SetMergeBlock(new_exit_bb.get()); new_loop->SetPreHeaderBlock(loop_->GetPreHeaderBlock()); // Add the new block into the cloned instructions. cloning_result->cloned_bb_.push_back(std::move(new_exit_bb)); return new_loop; } Loop* LoopUtils::CloneLoop( LoopCloningResult* cloning_result, const std::vector& ordered_loop_blocks) const { analysis::DefUseManager* def_use_mgr = context_->get_def_use_mgr(); std::unique_ptr new_loop = MakeUnique(context_); CFG& cfg = *context_->cfg(); // Clone and place blocks in a SPIR-V compliant order (dominators first). for (BasicBlock* old_bb : ordered_loop_blocks) { // For each basic block in the loop, we clone it and register the mapping // between old and new ids. BasicBlock* new_bb = old_bb->Clone(context_); new_bb->SetParent(&function_); // TODO(1841): Handle id overflow. new_bb->GetLabelInst()->SetResultId(context_->TakeNextId()); def_use_mgr->AnalyzeInstDef(new_bb->GetLabelInst()); context_->set_instr_block(new_bb->GetLabelInst(), new_bb); cloning_result->cloned_bb_.emplace_back(new_bb); cloning_result->old_to_new_bb_[old_bb->id()] = new_bb; cloning_result->new_to_old_bb_[new_bb->id()] = old_bb; cloning_result->value_map_[old_bb->id()] = new_bb->id(); if (loop_->IsInsideLoop(old_bb)) new_loop->AddBasicBlock(new_bb); for (auto new_inst = new_bb->begin(), old_inst = old_bb->begin(); new_inst != new_bb->end(); ++new_inst, ++old_inst) { cloning_result->ptr_map_[&*new_inst] = &*old_inst; if (new_inst->HasResultId()) { // TODO(1841): Handle id overflow. new_inst->SetResultId(context_->TakeNextId()); cloning_result->value_map_[old_inst->result_id()] = new_inst->result_id(); // Only look at the defs for now, uses are not updated yet. def_use_mgr->AnalyzeInstDef(&*new_inst); } } } // All instructions (including all labels) have been cloned, // remap instruction operands id with the new ones. for (std::unique_ptr& bb_ref : cloning_result->cloned_bb_) { BasicBlock* bb = bb_ref.get(); for (Instruction& insn : *bb) { insn.ForEachInId([cloning_result](uint32_t* old_id) { // If the operand is defined in the loop, remap the id. auto id_it = cloning_result->value_map_.find(*old_id); if (id_it != cloning_result->value_map_.end()) { *old_id = id_it->second; } }); // Only look at what the instruction uses. All defs are register, so all // should be fine now. def_use_mgr->AnalyzeInstUse(&insn); context_->set_instr_block(&insn, bb); } cfg.RegisterBlock(bb); } PopulateLoopNest(new_loop.get(), *cloning_result); return new_loop.release(); } void LoopUtils::PopulateLoopNest( Loop* new_loop, const LoopCloningResult& cloning_result) const { std::unordered_map loop_mapping; loop_mapping[loop_] = new_loop; if (loop_->HasParent()) loop_->GetParent()->AddNestedLoop(new_loop); PopulateLoopDesc(new_loop, loop_, cloning_result); for (Loop& sub_loop : make_range(++TreeDFIterator(loop_), TreeDFIterator())) { Loop* cloned = new Loop(context_); if (Loop* parent = loop_mapping[sub_loop.GetParent()]) parent->AddNestedLoop(cloned); loop_mapping[&sub_loop] = cloned; PopulateLoopDesc(cloned, &sub_loop, cloning_result); } loop_desc_->AddLoopNest(std::unique_ptr(new_loop)); } // Populates |new_loop| descriptor according to |old_loop|'s one. void LoopUtils::PopulateLoopDesc( Loop* new_loop, Loop* old_loop, const LoopCloningResult& cloning_result) const { for (uint32_t bb_id : old_loop->GetBlocks()) { BasicBlock* bb = cloning_result.old_to_new_bb_.at(bb_id); new_loop->AddBasicBlock(bb); } new_loop->SetHeaderBlock( cloning_result.old_to_new_bb_.at(old_loop->GetHeaderBlock()->id())); if (old_loop->GetLatchBlock()) new_loop->SetLatchBlock( cloning_result.old_to_new_bb_.at(old_loop->GetLatchBlock()->id())); if (old_loop->GetContinueBlock()) new_loop->SetContinueBlock( cloning_result.old_to_new_bb_.at(old_loop->GetContinueBlock()->id())); if (old_loop->GetMergeBlock()) { auto it = cloning_result.old_to_new_bb_.find(old_loop->GetMergeBlock()->id()); BasicBlock* bb = it != cloning_result.old_to_new_bb_.end() ? it->second : old_loop->GetMergeBlock(); new_loop->SetMergeBlock(bb); } if (old_loop->GetPreHeaderBlock()) { auto it = cloning_result.old_to_new_bb_.find(old_loop->GetPreHeaderBlock()->id()); if (it != cloning_result.old_to_new_bb_.end()) { new_loop->SetPreHeaderBlock(it->second); } } } // Class to gather some metrics about a region of interest. void CodeMetrics::Analyze(const Loop& loop) { CFG& cfg = *loop.GetContext()->cfg(); roi_size_ = 0; block_sizes_.clear(); for (uint32_t id : loop.GetBlocks()) { const BasicBlock* bb = cfg.block(id); size_t bb_size = 0; bb->ForEachInst([&bb_size](const Instruction* insn) { if (insn->opcode() == spv::Op::OpLabel) return; if (insn->IsNop()) return; if (insn->opcode() == spv::Op::OpPhi) return; bb_size++; }); block_sizes_[bb->id()] = bb_size; roi_size_ += bb_size; } } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/loop_utils.h000066400000000000000000000152631475742701700232040ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_LOOP_UTILS_H_ #define SOURCE_OPT_LOOP_UTILS_H_ #include #include #include #include #include "source/opt/ir_context.h" #include "source/opt/loop_descriptor.h" namespace spvtools { namespace opt { // Class to gather some metrics about a Region Of Interest (ROI). // So far it counts the number of instructions in a ROI (excluding debug // and label instructions) per basic block and in total. struct CodeMetrics { void Analyze(const Loop& loop); // The number of instructions per basic block in the ROI. std::unordered_map block_sizes_; // Number of instruction in the ROI. size_t roi_size_; }; // LoopUtils is used to encapsulte loop optimizations and from the passes which // use them. Any pass which needs a loop optimization should do it through this // or through a pass which is using this. class LoopUtils { public: // Holds a auxiliary results of the loop cloning procedure. struct LoopCloningResult { using ValueMapTy = std::unordered_map; using BlockMapTy = std::unordered_map; using PtrMap = std::unordered_map; PtrMap ptr_map_; // Mapping between the original loop ids and the new one. ValueMapTy value_map_; // Mapping between original loop blocks to the cloned one. BlockMapTy old_to_new_bb_; // Mapping between the cloned loop blocks to original one. BlockMapTy new_to_old_bb_; // List of cloned basic block. std::vector> cloned_bb_; }; LoopUtils(IRContext* context, Loop* loop) : context_(context), loop_desc_( context->GetLoopDescriptor(loop->GetHeaderBlock()->GetParent())), loop_(loop), function_(*loop_->GetHeaderBlock()->GetParent()) {} // The converts the current loop to loop closed SSA form. // In the loop closed SSA, all loop exiting values go through a dedicated Phi // instruction. For instance: // // for (...) { // A1 = ... // if (...) // A2 = ... // A = phi A1, A2 // } // ... = op A ... // // Becomes // // for (...) { // A1 = ... // if (...) // A2 = ... // A = phi A1, A2 // } // C = phi A // ... = op C ... // // This makes some loop transformations (such as loop unswitch) simpler // (removes the needs to take care of exiting variables). void MakeLoopClosedSSA(); // Create dedicate exit basic block. This ensure all exit basic blocks has the // loop as sole predecessors. // By construction, structured control flow already has a dedicated exit // block. // Preserves: CFG, def/use and instruction to block mapping. void CreateLoopDedicatedExits(); // Clone |loop_| and remap its instructions. Newly created blocks // will be added to the |cloning_result.cloned_bb_| list, correctly ordered to // be inserted into a function. // It is assumed that |ordered_loop_blocks| is compatible with the result of // |Loop::ComputeLoopStructuredOrder|. If the preheader and merge block are in // the list they will also be cloned. If not, the resulting loop will share // them with the original loop. // The function preserves the def/use, cfg and instr to block analyses. // The cloned loop nest will be added to the loop descriptor and will have // ownership. Loop* CloneLoop(LoopCloningResult* cloning_result, const std::vector& ordered_loop_blocks) const; // Clone |loop_| and remap its instructions, as above. Overload to compute // loop block ordering within method rather than taking in as parameter. Loop* CloneLoop(LoopCloningResult* cloning_result) const; // Clone the |loop_| and make the new loop branch to the second loop on exit. Loop* CloneAndAttachLoopToHeader(LoopCloningResult* cloning_result); // Perform a partial unroll of |loop| by given |factor|. This will copy the // body of the loop |factor| times. So a |factor| of one would give a new loop // with the original body plus one unrolled copy body. bool PartiallyUnroll(size_t factor); // Fully unroll |loop|. bool FullyUnroll(); // This function validates that |loop| meets the assumptions made by the // implementation of the loop unroller. As the implementation accommodates // more types of loops this function can reduce its checks. // // The conditions checked to ensure the loop can be unrolled are as follows: // 1. That the loop is in structured order. // 2. That the continue block is a branch to the header. // 3. That the only phi used in the loop is the induction variable. // TODO(stephen@codeplay.com): This is a temporary measure, after the loop is // converted into LCSAA form and has a single entry and exit we can rewrite // the other phis. // 4. That this is an inner most loop, or that loops contained within this // loop have already been fully unrolled. // 5. That each instruction in the loop is only used within the loop. // (Related to the above phi condition). bool CanPerformUnroll(); // Maintains the loop descriptor object after the unroll functions have been // called, otherwise the analysis should be invalidated. void Finalize(); // Returns the context associate to |loop_|. IRContext* GetContext() { return context_; } // Returns the loop descriptor owning |loop_|. LoopDescriptor* GetLoopDescriptor() { return loop_desc_; } // Returns the loop on which the object operates on. Loop* GetLoop() const { return loop_; } // Returns the function that |loop_| belong to. Function* GetFunction() const { return &function_; } private: IRContext* context_; LoopDescriptor* loop_desc_; Loop* loop_; Function& function_; // Populates the loop nest of |new_loop| according to |loop_| nest. void PopulateLoopNest(Loop* new_loop, const LoopCloningResult& cloning_result) const; // Populates |new_loop| descriptor according to |old_loop|'s one. void PopulateLoopDesc(Loop* new_loop, Loop* old_loop, const LoopCloningResult& cloning_result) const; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_LOOP_UTILS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/mem_pass.cpp000066400000000000000000000422611475742701700231500ustar00rootroot00000000000000// Copyright (c) 2017 The Khronos Group Inc. // Copyright (c) 2017 Valve Corporation // Copyright (c) 2017 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/mem_pass.h" #include #include #include #include "source/cfa.h" #include "source/opt/basic_block.h" #include "source/opt/ir_context.h" namespace spvtools { namespace opt { namespace { constexpr uint32_t kCopyObjectOperandInIdx = 0; constexpr uint32_t kTypePointerStorageClassInIdx = 0; constexpr uint32_t kTypePointerTypeIdInIdx = 1; } // namespace bool MemPass::IsBaseTargetType(const Instruction* typeInst) const { switch (typeInst->opcode()) { case spv::Op::OpTypeInt: case spv::Op::OpTypeFloat: case spv::Op::OpTypeBool: case spv::Op::OpTypeVector: case spv::Op::OpTypeMatrix: case spv::Op::OpTypeImage: case spv::Op::OpTypeSampler: case spv::Op::OpTypeSampledImage: case spv::Op::OpTypePointer: case spv::Op::OpTypeCooperativeMatrixNV: case spv::Op::OpTypeCooperativeMatrixKHR: return true; default: break; } return false; } bool MemPass::IsTargetType(const Instruction* typeInst) const { if (IsBaseTargetType(typeInst)) return true; if (typeInst->opcode() == spv::Op::OpTypeArray) { if (!IsTargetType( get_def_use_mgr()->GetDef(typeInst->GetSingleWordOperand(1)))) { return false; } return true; } if (typeInst->opcode() != spv::Op::OpTypeStruct) return false; // All struct members must be math type return typeInst->WhileEachInId([this](const uint32_t* tid) { Instruction* compTypeInst = get_def_use_mgr()->GetDef(*tid); if (!IsTargetType(compTypeInst)) return false; return true; }); } bool MemPass::IsNonPtrAccessChain(const spv::Op opcode) const { return opcode == spv::Op::OpAccessChain || opcode == spv::Op::OpInBoundsAccessChain; } bool MemPass::IsPtr(uint32_t ptrId) { uint32_t varId = ptrId; Instruction* ptrInst = get_def_use_mgr()->GetDef(varId); if (ptrInst->opcode() == spv::Op::OpFunction) { // A function is not a pointer, but it's return type could be, which will // erroneously lead to this function returning true later on return false; } while (ptrInst->opcode() == spv::Op::OpCopyObject) { varId = ptrInst->GetSingleWordInOperand(kCopyObjectOperandInIdx); ptrInst = get_def_use_mgr()->GetDef(varId); } const spv::Op op = ptrInst->opcode(); if (op == spv::Op::OpVariable || IsNonPtrAccessChain(op)) return true; const uint32_t varTypeId = ptrInst->type_id(); if (varTypeId == 0) return false; const Instruction* varTypeInst = get_def_use_mgr()->GetDef(varTypeId); return varTypeInst->opcode() == spv::Op::OpTypePointer; } Instruction* MemPass::GetPtr(uint32_t ptrId, uint32_t* varId) { *varId = ptrId; Instruction* ptrInst = get_def_use_mgr()->GetDef(*varId); Instruction* varInst; if (ptrInst->opcode() == spv::Op::OpConstantNull) { *varId = 0; return ptrInst; } if (ptrInst->opcode() != spv::Op::OpVariable && ptrInst->opcode() != spv::Op::OpFunctionParameter) { varInst = ptrInst->GetBaseAddress(); } else { varInst = ptrInst; } if (varInst->opcode() == spv::Op::OpVariable) { *varId = varInst->result_id(); } else { *varId = 0; } while (ptrInst->opcode() == spv::Op::OpCopyObject) { uint32_t temp = ptrInst->GetSingleWordInOperand(0); ptrInst = get_def_use_mgr()->GetDef(temp); } return ptrInst; } Instruction* MemPass::GetPtr(Instruction* ip, uint32_t* varId) { assert(ip->opcode() == spv::Op::OpStore || ip->opcode() == spv::Op::OpLoad || ip->opcode() == spv::Op::OpImageTexelPointer || ip->IsAtomicWithLoad()); // All of these opcode place the pointer in position 0. const uint32_t ptrId = ip->GetSingleWordInOperand(0); return GetPtr(ptrId, varId); } bool MemPass::HasOnlyNamesAndDecorates(uint32_t id) const { return get_def_use_mgr()->WhileEachUser(id, [this](Instruction* user) { spv::Op op = user->opcode(); if (op != spv::Op::OpName && !IsNonTypeDecorate(op)) { return false; } return true; }); } void MemPass::KillAllInsts(BasicBlock* bp, bool killLabel) { bp->KillAllInsts(killLabel); } bool MemPass::HasLoads(uint32_t varId) const { return !get_def_use_mgr()->WhileEachUser(varId, [this](Instruction* user) { spv::Op op = user->opcode(); // TODO(): The following is slightly conservative. Could be // better handling of non-store/name. if (IsNonPtrAccessChain(op) || op == spv::Op::OpCopyObject) { if (HasLoads(user->result_id())) { return false; } } else if (op != spv::Op::OpStore && op != spv::Op::OpName && !IsNonTypeDecorate(op)) { return false; } return true; }); } bool MemPass::IsLiveVar(uint32_t varId) const { const Instruction* varInst = get_def_use_mgr()->GetDef(varId); // assume live if not a variable eg. function parameter if (varInst->opcode() != spv::Op::OpVariable) return true; // non-function scope vars are live const uint32_t varTypeId = varInst->type_id(); const Instruction* varTypeInst = get_def_use_mgr()->GetDef(varTypeId); if (spv::StorageClass(varTypeInst->GetSingleWordInOperand( kTypePointerStorageClassInIdx)) != spv::StorageClass::Function) return true; // test if variable is loaded from return HasLoads(varId); } void MemPass::AddStores(uint32_t ptr_id, std::queue* insts) { get_def_use_mgr()->ForEachUser(ptr_id, [this, insts](Instruction* user) { spv::Op op = user->opcode(); if (IsNonPtrAccessChain(op)) { AddStores(user->result_id(), insts); } else if (op == spv::Op::OpStore) { insts->push(user); } }); } void MemPass::DCEInst(Instruction* inst, const std::function& call_back) { std::queue deadInsts; deadInsts.push(inst); while (!deadInsts.empty()) { Instruction* di = deadInsts.front(); // Don't delete labels if (di->opcode() == spv::Op::OpLabel) { deadInsts.pop(); continue; } // Remember operands std::set ids; di->ForEachInId([&ids](uint32_t* iid) { ids.insert(*iid); }); uint32_t varId = 0; // Remember variable if dead load if (di->opcode() == spv::Op::OpLoad) (void)GetPtr(di, &varId); if (call_back) { call_back(di); } context()->KillInst(di); // For all operands with no remaining uses, add their instruction // to the dead instruction queue. for (auto id : ids) if (HasOnlyNamesAndDecorates(id)) { Instruction* odi = get_def_use_mgr()->GetDef(id); if (context()->IsCombinatorInstruction(odi)) deadInsts.push(odi); } // if a load was deleted and it was the variable's // last load, add all its stores to dead queue if (varId != 0 && !IsLiveVar(varId)) AddStores(varId, &deadInsts); deadInsts.pop(); } } MemPass::MemPass() {} bool MemPass::HasOnlySupportedRefs(uint32_t varId) { return get_def_use_mgr()->WhileEachUser(varId, [this](Instruction* user) { auto dbg_op = user->GetCommonDebugOpcode(); if (dbg_op == CommonDebugInfoDebugDeclare || dbg_op == CommonDebugInfoDebugValue) { return true; } spv::Op op = user->opcode(); if (op != spv::Op::OpStore && op != spv::Op::OpLoad && op != spv::Op::OpName && !IsNonTypeDecorate(op)) { return false; } return true; }); } uint32_t MemPass::Type2Undef(uint32_t type_id) { const auto uitr = type2undefs_.find(type_id); if (uitr != type2undefs_.end()) return uitr->second; const uint32_t undefId = TakeNextId(); if (undefId == 0) { return 0; } std::unique_ptr undef_inst( new Instruction(context(), spv::Op::OpUndef, type_id, undefId, {})); get_def_use_mgr()->AnalyzeInstDefUse(&*undef_inst); get_module()->AddGlobalValue(std::move(undef_inst)); type2undefs_[type_id] = undefId; return undefId; } bool MemPass::IsTargetVar(uint32_t varId) { if (varId == 0) { return false; } if (seen_non_target_vars_.find(varId) != seen_non_target_vars_.end()) return false; if (seen_target_vars_.find(varId) != seen_target_vars_.end()) return true; const Instruction* varInst = get_def_use_mgr()->GetDef(varId); if (varInst->opcode() != spv::Op::OpVariable) return false; const uint32_t varTypeId = varInst->type_id(); const Instruction* varTypeInst = get_def_use_mgr()->GetDef(varTypeId); if (spv::StorageClass(varTypeInst->GetSingleWordInOperand( kTypePointerStorageClassInIdx)) != spv::StorageClass::Function) { seen_non_target_vars_.insert(varId); return false; } const uint32_t varPteTypeId = varTypeInst->GetSingleWordInOperand(kTypePointerTypeIdInIdx); Instruction* varPteTypeInst = get_def_use_mgr()->GetDef(varPteTypeId); if (!IsTargetType(varPteTypeInst)) { seen_non_target_vars_.insert(varId); return false; } seen_target_vars_.insert(varId); return true; } // Remove all |phi| operands coming from unreachable blocks (i.e., blocks not in // |reachable_blocks|). There are two types of removal that this function can // perform: // // 1- Any operand that comes directly from an unreachable block is completely // removed. Since the block is unreachable, the edge between the unreachable // block and the block holding |phi| has been removed. // // 2- Any operand that comes via a live block and was defined at an unreachable // block gets its value replaced with an OpUndef value. Since the argument // was generated in an unreachable block, it no longer exists, so it cannot // be referenced. However, since the value does not reach |phi| directly // from the unreachable block, the operand cannot be removed from |phi|. // Therefore, we replace the argument value with OpUndef. // // For example, in the switch() below, assume that we want to remove the // argument with value %11 coming from block %41. // // [ ... ] // %41 = OpLabel <--- Unreachable block // %11 = OpLoad %int %y // [ ... ] // OpSelectionMerge %16 None // OpSwitch %12 %16 10 %13 13 %14 18 %15 // %13 = OpLabel // OpBranch %16 // %14 = OpLabel // OpStore %outparm %int_14 // OpBranch %16 // %15 = OpLabel // OpStore %outparm %int_15 // OpBranch %16 // %16 = OpLabel // %30 = OpPhi %int %11 %41 %int_42 %13 %11 %14 %11 %15 // // Since %41 is now an unreachable block, the first operand of |phi| needs to // be removed completely. But the operands (%11 %14) and (%11 %15) cannot be // removed because %14 and %15 are reachable blocks. Since %11 no longer exist, // in those arguments, we replace all references to %11 with an OpUndef value. // This results in |phi| looking like: // // %50 = OpUndef %int // [ ... ] // %30 = OpPhi %int %int_42 %13 %50 %14 %50 %15 void MemPass::RemovePhiOperands( Instruction* phi, const std::unordered_set& reachable_blocks) { std::vector keep_operands; uint32_t type_id = 0; // The id of an undefined value we've generated. uint32_t undef_id = 0; // Traverse all the operands in |phi|. Build the new operand vector by adding // all the original operands from |phi| except the unwanted ones. for (uint32_t i = 0; i < phi->NumOperands();) { if (i < 2) { // The first two arguments are always preserved. keep_operands.push_back(phi->GetOperand(i)); ++i; continue; } // The remaining Phi arguments come in pairs. Index 'i' contains the // variable id, index 'i + 1' is the originating block id. assert(i % 2 == 0 && i < phi->NumOperands() - 1 && "malformed Phi arguments"); BasicBlock* in_block = cfg()->block(phi->GetSingleWordOperand(i + 1)); if (reachable_blocks.find(in_block) == reachable_blocks.end()) { // If the incoming block is unreachable, remove both operands as this // means that the |phi| has lost an incoming edge. i += 2; continue; } // In all other cases, the operand must be kept but may need to be changed. uint32_t arg_id = phi->GetSingleWordOperand(i); Instruction* arg_def_instr = get_def_use_mgr()->GetDef(arg_id); BasicBlock* def_block = context()->get_instr_block(arg_def_instr); if (def_block && reachable_blocks.find(def_block) == reachable_blocks.end()) { // If the current |phi| argument was defined in an unreachable block, it // means that this |phi| argument is no longer defined. Replace it with // |undef_id|. if (!undef_id) { type_id = arg_def_instr->type_id(); undef_id = Type2Undef(type_id); } keep_operands.push_back( Operand(spv_operand_type_t::SPV_OPERAND_TYPE_ID, {undef_id})); } else { // Otherwise, the argument comes from a reachable block or from no block // at all (meaning that it was defined in the global section of the // program). In both cases, keep the argument intact. keep_operands.push_back(phi->GetOperand(i)); } keep_operands.push_back(phi->GetOperand(i + 1)); i += 2; } context()->ForgetUses(phi); phi->ReplaceOperands(keep_operands); context()->AnalyzeUses(phi); } void MemPass::RemoveBlock(Function::iterator* bi) { auto& rm_block = **bi; // Remove instructions from the block. rm_block.ForEachInst([&rm_block, this](Instruction* inst) { // Note that we do not kill the block label instruction here. The label // instruction is needed to identify the block, which is needed by the // removal of phi operands. if (inst != rm_block.GetLabelInst()) { context()->KillInst(inst); } }); // Remove the label instruction last. auto label = rm_block.GetLabelInst(); context()->KillInst(label); *bi = bi->Erase(); } bool MemPass::RemoveUnreachableBlocks(Function* func) { if (func->IsDeclaration()) return false; bool modified = false; // Mark reachable all blocks reachable from the function's entry block. std::unordered_set reachable_blocks; std::unordered_set visited_blocks; std::queue worklist; reachable_blocks.insert(func->entry().get()); // Initially mark the function entry point as reachable. worklist.push(func->entry().get()); auto mark_reachable = [&reachable_blocks, &visited_blocks, &worklist, this](uint32_t label_id) { auto successor = cfg()->block(label_id); if (visited_blocks.count(successor) == 0) { reachable_blocks.insert(successor); worklist.push(successor); visited_blocks.insert(successor); } }; // Transitively mark all blocks reachable from the entry as reachable. while (!worklist.empty()) { BasicBlock* block = worklist.front(); worklist.pop(); // All the successors of a live block are also live. static_cast(block)->ForEachSuccessorLabel( mark_reachable); // All the Merge and ContinueTarget blocks of a live block are also live. block->ForMergeAndContinueLabel(mark_reachable); } // Update operands of Phi nodes that reference unreachable blocks. for (auto& block : *func) { // If the block is about to be removed, don't bother updating its // Phi instructions. if (reachable_blocks.count(&block) == 0) { continue; } // If the block is reachable and has Phi instructions, remove all // operands from its Phi instructions that reference unreachable blocks. // If the block has no Phi instructions, this is a no-op. block.ForEachPhiInst([&reachable_blocks, this](Instruction* phi) { RemovePhiOperands(phi, reachable_blocks); }); } // Erase unreachable blocks. for (auto ebi = func->begin(); ebi != func->end();) { if (reachable_blocks.count(&*ebi) == 0) { RemoveBlock(&ebi); modified = true; } else { ++ebi; } } return modified; } bool MemPass::CFGCleanup(Function* func) { bool modified = false; modified |= RemoveUnreachableBlocks(func); return modified; } void MemPass::CollectTargetVars(Function* func) { seen_target_vars_.clear(); seen_non_target_vars_.clear(); type2undefs_.clear(); // Collect target (and non-) variable sets. Remove variables with // non-load/store refs from target variable set for (auto& blk : *func) { for (auto& inst : blk) { switch (inst.opcode()) { case spv::Op::OpStore: case spv::Op::OpLoad: { uint32_t varId; (void)GetPtr(&inst, &varId); if (!IsTargetVar(varId)) break; if (HasOnlySupportedRefs(varId)) break; seen_non_target_vars_.insert(varId); seen_target_vars_.erase(varId); } break; default: break; } } } } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/mem_pass.h000066400000000000000000000137401475742701700226150ustar00rootroot00000000000000// Copyright (c) 2017 The Khronos Group Inc. // Copyright (c) 2017 Valve Corporation // Copyright (c) 2017 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_MEM_PASS_H_ #define SOURCE_OPT_MEM_PASS_H_ #include #include #include #include #include #include #include #include "source/opt/basic_block.h" #include "source/opt/def_use_manager.h" #include "source/opt/dominator_analysis.h" #include "source/opt/module.h" #include "source/opt/pass.h" namespace spvtools { namespace opt { // A common base class for mem2reg-type passes. Provides common // utility functions and supporting state. class MemPass : public Pass { public: virtual ~MemPass() override = default; // Returns an undef value for the given |var_id|'s type. uint32_t GetUndefVal(uint32_t var_id) { return Type2Undef(GetPointeeTypeId(get_def_use_mgr()->GetDef(var_id))); } // Given a load or store |ip|, return the pointer instruction. // Also return the base variable's id in |varId|. If no base variable is // found, |varId| will be 0. Instruction* GetPtr(Instruction* ip, uint32_t* varId); // Return true if |varId| is a previously identified target variable. // Return false if |varId| is a previously identified non-target variable. // // Non-target variables are variable of function scope of a target type that // are accessed with constant-index access chains. not accessed with // non-constant-index access chains. Also cache non-target variables. // // If variable is not cached, return true if variable is a function scope // variable of target type, false otherwise. Updates caches of target and // non-target variables. bool IsTargetVar(uint32_t varId); // Collect target SSA variables. This traverses all the loads and stores in // function |func| looking for variables that can be replaced with SSA IDs. It // populates the sets |seen_target_vars_| and |seen_non_target_vars_|. void CollectTargetVars(Function* func); protected: MemPass(); // Returns true if |typeInst| is a scalar type // or a vector or matrix bool IsBaseTargetType(const Instruction* typeInst) const; // Returns true if |typeInst| is a math type or a struct or array // of a math type. // TODO(): Add more complex types to convert bool IsTargetType(const Instruction* typeInst) const; // Returns true if |opcode| is a non-ptr access chain op bool IsNonPtrAccessChain(const spv::Op opcode) const; // Given the id |ptrId|, return true if the top-most non-CopyObj is // a variable, a non-ptr access chain or a parameter of pointer type. bool IsPtr(uint32_t ptrId); // Given the id of a pointer |ptrId|, return the top-most non-CopyObj. // Also return the base variable's id in |varId|. If no base variable is // found, |varId| will be 0. Instruction* GetPtr(uint32_t ptrId, uint32_t* varId); // Return true if all uses of |id| are only name or decorate ops. bool HasOnlyNamesAndDecorates(uint32_t id) const; // Kill all instructions in block |bp|. Whether or not to kill the label is // indicated by |killLabel|. void KillAllInsts(BasicBlock* bp, bool killLabel = true); // Return true if any instruction loads from |varId| bool HasLoads(uint32_t varId) const; // Return true if |varId| is not a function variable or if it has // a load bool IsLiveVar(uint32_t varId) const; // Add stores using |ptr_id| to |insts| void AddStores(uint32_t ptr_id, std::queue* insts); // Delete |inst| and iterate DCE on all its operands if they are now // useless. If a load is deleted and its variable has no other loads, // delete all its variable's stores. void DCEInst(Instruction* inst, const std::function&); // Call all the cleanup helper functions on |func|. bool CFGCleanup(Function* func); // Return true if |op| is supported decorate. inline bool IsNonTypeDecorate(spv::Op op) const { return (op == spv::Op::OpDecorate || op == spv::Op::OpDecorateId); } // Return the id of an undef value with type |type_id|. Create and insert an // undef after the first non-variable in the function if it doesn't already // exist. Add undef to function undef map. Returns 0 of the value does not // exist, and cannot be created. uint32_t Type2Undef(uint32_t type_id); // Cache of verified target vars std::unordered_set seen_target_vars_; // Cache of verified non-target vars std::unordered_set seen_non_target_vars_; private: // Return true if all uses of |varId| are only through supported reference // operations ie. loads and store. Also cache in supported_ref_vars_. // TODO(dnovillo): This function is replicated in other passes and it's // slightly different in every pass. Is it possible to make one common // implementation? bool HasOnlySupportedRefs(uint32_t varId); // Remove all the unreachable basic blocks in |func|. bool RemoveUnreachableBlocks(Function* func); // Remove the block pointed by the iterator |*bi|. This also removes // all the instructions in the pointed-to block. void RemoveBlock(Function::iterator* bi); // Remove Phi operands in |phi| that are coming from blocks not in // |reachable_blocks|. void RemovePhiOperands( Instruction* phi, const std::unordered_set& reachable_blocks); // Map from type to undef std::unordered_map type2undefs_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_MEM_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/merge_return_pass.cpp000066400000000000000000000764731475742701700251040ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/merge_return_pass.h" #include #include #include #include "source/opt/instruction.h" #include "source/opt/ir_builder.h" #include "source/opt/ir_context.h" #include "source/opt/reflect.h" #include "source/util/bit_vector.h" #include "source/util/make_unique.h" namespace spvtools { namespace opt { Pass::Status MergeReturnPass::Process() { bool is_shader = context()->get_feature_mgr()->HasCapability(spv::Capability::Shader); bool failed = false; ProcessFunction pfn = [&failed, is_shader, this](Function* function) { std::vector return_blocks = CollectReturnBlocks(function); if (return_blocks.size() <= 1) { if (!is_shader || return_blocks.size() == 0) { return false; } bool isInConstruct = context()->GetStructuredCFGAnalysis()->ContainingConstruct( return_blocks[0]->id()) != 0; bool endsWithReturn = return_blocks[0] == function->tail(); if (!isInConstruct && endsWithReturn) { return false; } } function_ = function; return_flag_ = nullptr; return_value_ = nullptr; final_return_block_ = nullptr; if (is_shader) { if (!ProcessStructured(function, return_blocks)) { failed = true; } } else { MergeReturnBlocks(function, return_blocks); } return true; }; bool modified = context()->ProcessReachableCallTree(pfn); if (failed) { return Status::Failure; } return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } void MergeReturnPass::GenerateState(BasicBlock* block) { if (Instruction* mergeInst = block->GetMergeInst()) { if (mergeInst->opcode() == spv::Op::OpLoopMerge) { // If new loop, break to this loop merge block state_.emplace_back(mergeInst, mergeInst); } else { auto branchInst = mergeInst->NextNode(); if (branchInst->opcode() == spv::Op::OpSwitch) { // If switch inside of loop, break to innermost loop merge block. // Otherwise need to break to this switch merge block. auto lastMergeInst = state_.back().BreakMergeInst(); if (lastMergeInst && lastMergeInst->opcode() == spv::Op::OpLoopMerge) state_.emplace_back(lastMergeInst, mergeInst); else state_.emplace_back(mergeInst, mergeInst); } else { // If branch conditional inside loop, always break to innermost // loop merge block. If branch conditional inside switch, break to // innermost switch merge block. auto lastMergeInst = state_.back().BreakMergeInst(); state_.emplace_back(lastMergeInst, mergeInst); } } } } bool MergeReturnPass::ProcessStructured( Function* function, const std::vector& return_blocks) { if (HasNontrivialUnreachableBlocks(function)) { if (consumer()) { std::string message = "Module contains unreachable blocks during merge return. Run dead " "branch elimination before merge return."; consumer()(SPV_MSG_ERROR, 0, {0, 0, 0}, message.c_str()); } return false; } RecordImmediateDominators(function); if (!AddSingleCaseSwitchAroundFunction()) { return false; } std::list order; cfg()->ComputeStructuredOrder(function, &*function->begin(), &order); state_.clear(); state_.emplace_back(nullptr, nullptr); for (auto block : order) { if (cfg()->IsPseudoEntryBlock(block) || cfg()->IsPseudoExitBlock(block) || block == final_return_block_) { continue; } auto blockId = block->GetLabelInst()->result_id(); if (blockId == CurrentState().CurrentMergeId()) { // Pop the current state as we've hit the merge state_.pop_back(); } ProcessStructuredBlock(block); // Generate state for next block if warranted GenerateState(block); } state_.clear(); state_.emplace_back(nullptr, nullptr); std::unordered_set predicated; for (auto block : order) { if (cfg()->IsPseudoEntryBlock(block) || cfg()->IsPseudoExitBlock(block)) { continue; } auto blockId = block->id(); if (blockId == CurrentState().CurrentMergeId()) { // Pop the current state as we've hit the merge state_.pop_back(); } // Predicate successors of the original return blocks as necessary. if (std::find(return_blocks.begin(), return_blocks.end(), block) != return_blocks.end()) { if (!PredicateBlocks(block, &predicated, &order)) { return false; } } // Generate state for next block if warranted GenerateState(block); } // We have not kept the dominator tree up-to-date. // Invalidate it at this point to make sure it will be rebuilt. context()->RemoveDominatorAnalysis(function); AddNewPhiNodes(); return true; } void MergeReturnPass::CreateReturnBlock() { // Create a label for the new return block std::unique_ptr return_label( new Instruction(context(), spv::Op::OpLabel, 0u, TakeNextId(), {})); // Create the new basic block std::unique_ptr return_block( new BasicBlock(std::move(return_label))); function_->AddBasicBlock(std::move(return_block)); final_return_block_ = &*(--function_->end()); context()->AnalyzeDefUse(final_return_block_->GetLabelInst()); context()->set_instr_block(final_return_block_->GetLabelInst(), final_return_block_); assert(final_return_block_->GetParent() == function_ && "The function should have been set when the block was created."); } void MergeReturnPass::CreateReturn(BasicBlock* block) { AddReturnValue(); if (return_value_) { // Load and return the final return value uint32_t loadId = TakeNextId(); block->AddInstruction(MakeUnique( context(), spv::Op::OpLoad, function_->type_id(), loadId, std::initializer_list{ {SPV_OPERAND_TYPE_ID, {return_value_->result_id()}}})); Instruction* var_inst = block->terminator(); context()->AnalyzeDefUse(var_inst); context()->set_instr_block(var_inst, block); context()->get_decoration_mgr()->CloneDecorations( return_value_->result_id(), loadId, {spv::Decoration::RelaxedPrecision}); block->AddInstruction(MakeUnique( context(), spv::Op::OpReturnValue, 0, 0, std::initializer_list{{SPV_OPERAND_TYPE_ID, {loadId}}})); context()->AnalyzeDefUse(block->terminator()); context()->set_instr_block(block->terminator(), block); } else { block->AddInstruction( MakeUnique(context(), spv::Op::OpReturn)); context()->AnalyzeDefUse(block->terminator()); context()->set_instr_block(block->terminator(), block); } } void MergeReturnPass::ProcessStructuredBlock(BasicBlock* block) { spv::Op tail_opcode = block->tail()->opcode(); if (tail_opcode == spv::Op::OpReturn || tail_opcode == spv::Op::OpReturnValue) { if (!return_flag_) { AddReturnFlag(); } } if (tail_opcode == spv::Op::OpReturn || tail_opcode == spv::Op::OpReturnValue || tail_opcode == spv::Op::OpUnreachable) { assert(CurrentState().InBreakable() && "Should be in the placeholder construct."); BranchToBlock(block, CurrentState().BreakMergeId()); return_blocks_.insert(block->id()); } } void MergeReturnPass::BranchToBlock(BasicBlock* block, uint32_t target) { if (block->tail()->opcode() == spv::Op::OpReturn || block->tail()->opcode() == spv::Op::OpReturnValue) { RecordReturned(block); RecordReturnValue(block); } BasicBlock* target_block = context()->get_instr_block(target); if (target_block->GetLoopMergeInst()) { cfg()->SplitLoopHeader(target_block); } UpdatePhiNodes(block, target_block); Instruction* return_inst = block->terminator(); return_inst->SetOpcode(spv::Op::OpBranch); return_inst->ReplaceOperands({{SPV_OPERAND_TYPE_ID, {target}}}); context()->get_def_use_mgr()->AnalyzeInstDefUse(return_inst); new_edges_[target_block].insert(block->id()); cfg()->AddEdge(block->id(), target); } void MergeReturnPass::UpdatePhiNodes(BasicBlock* new_source, BasicBlock* target) { target->ForEachPhiInst([this, new_source](Instruction* inst) { uint32_t undefId = Type2Undef(inst->type_id()); inst->AddOperand({SPV_OPERAND_TYPE_ID, {undefId}}); inst->AddOperand({SPV_OPERAND_TYPE_ID, {new_source->id()}}); context()->UpdateDefUse(inst); }); } void MergeReturnPass::CreatePhiNodesForInst(BasicBlock* merge_block, Instruction& inst) { DominatorAnalysis* dom_tree = context()->GetDominatorAnalysis(merge_block->GetParent()); if (inst.result_id() != 0) { BasicBlock* inst_bb = context()->get_instr_block(&inst); std::vector users_to_update; context()->get_def_use_mgr()->ForEachUser( &inst, [&users_to_update, &dom_tree, &inst, inst_bb, this](Instruction* user) { BasicBlock* user_bb = nullptr; if (user->opcode() != spv::Op::OpPhi) { user_bb = context()->get_instr_block(user); } else { // For OpPhi, the use should be considered to be in the predecessor. for (uint32_t i = 0; i < user->NumInOperands(); i += 2) { if (user->GetSingleWordInOperand(i) == inst.result_id()) { uint32_t user_bb_id = user->GetSingleWordInOperand(i + 1); user_bb = context()->get_instr_block(user_bb_id); break; } } } // If |user_bb| is nullptr, then |user| is not in the function. It is // something like an OpName or decoration, which should not be // replaced with the result of the OpPhi. if (user_bb && !dom_tree->Dominates(inst_bb, user_bb)) { users_to_update.push_back(user); } }); if (users_to_update.empty()) { return; } // There is at least one values that needs to be replaced. // First create the OpPhi instruction. uint32_t undef_id = Type2Undef(inst.type_id()); std::vector phi_operands; const std::set& new_edges = new_edges_[merge_block]; // Add the OpPhi operands. If the predecessor is a return block use undef, // otherwise use |inst|'s id. std::vector preds = cfg()->preds(merge_block->id()); for (uint32_t pred_id : preds) { if (new_edges.count(pred_id)) { phi_operands.push_back(undef_id); } else { phi_operands.push_back(inst.result_id()); } phi_operands.push_back(pred_id); } Instruction* new_phi = nullptr; // If the instruction is a pointer and variable pointers are not an option, // then we have to regenerate the instruction instead of creating an OpPhi // instruction. If not, the Spir-V will be invalid. Instruction* inst_type = get_def_use_mgr()->GetDef(inst.type_id()); bool regenerateInstruction = false; if (inst_type->opcode() == spv::Op::OpTypePointer) { if (!context()->get_feature_mgr()->HasCapability( spv::Capability::VariablePointers)) { regenerateInstruction = true; } auto storage_class = spv::StorageClass(inst_type->GetSingleWordInOperand(0)); if (storage_class != spv::StorageClass::Workgroup && storage_class != spv::StorageClass::StorageBuffer) { regenerateInstruction = true; } } if (regenerateInstruction) { std::unique_ptr regen_inst(inst.Clone(context())); uint32_t new_id = TakeNextId(); regen_inst->SetResultId(new_id); Instruction* insert_pos = &*merge_block->begin(); while (insert_pos->opcode() == spv::Op::OpPhi) { insert_pos = insert_pos->NextNode(); } new_phi = insert_pos->InsertBefore(std::move(regen_inst)); get_def_use_mgr()->AnalyzeInstDefUse(new_phi); context()->set_instr_block(new_phi, merge_block); new_phi->ForEachInId([dom_tree, merge_block, this](uint32_t* use_id) { Instruction* use = get_def_use_mgr()->GetDef(*use_id); BasicBlock* use_bb = context()->get_instr_block(use); if (use_bb != nullptr && !dom_tree->Dominates(use_bb, merge_block)) { CreatePhiNodesForInst(merge_block, *use); } }); } else { InstructionBuilder builder( context(), &*merge_block->begin(), IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); new_phi = builder.AddPhi(inst.type_id(), phi_operands); } uint32_t result_of_phi = new_phi->result_id(); // Update all of the users to use the result of the new OpPhi. for (Instruction* user : users_to_update) { user->ForEachInId([&inst, result_of_phi](uint32_t* id) { if (*id == inst.result_id()) { *id = result_of_phi; } }); context()->AnalyzeUses(user); } } } bool MergeReturnPass::PredicateBlocks( BasicBlock* return_block, std::unordered_set* predicated, std::list* order) { // The CFG is being modified as the function proceeds so avoid caching // successors. if (predicated->count(return_block)) { return true; } BasicBlock* block = nullptr; const BasicBlock* const_block = const_cast(return_block); const_block->ForEachSuccessorLabel([this, &block](const uint32_t idx) { BasicBlock* succ_block = context()->get_instr_block(idx); assert(block == nullptr); block = succ_block; }); assert(block && "Return blocks should have returns already replaced by a single " "unconditional branch."); auto state = state_.rbegin(); std::unordered_set seen; if (block->id() == state->CurrentMergeId()) { state++; } else if (block->id() == state->BreakMergeId()) { while (state->BreakMergeId() == block->id()) { state++; } } while (block != nullptr && block != final_return_block_) { if (!predicated->insert(block).second) break; // Skip structured subgraphs. assert(state->InBreakable() && "Should be in the placeholder construct at the very least."); Instruction* break_merge_inst = state->BreakMergeInst(); uint32_t merge_block_id = break_merge_inst->GetSingleWordInOperand(0); while (state->BreakMergeId() == merge_block_id) { state++; } if (!BreakFromConstruct(block, predicated, order, break_merge_inst)) { return false; } block = context()->get_instr_block(merge_block_id); } return true; } bool MergeReturnPass::BreakFromConstruct( BasicBlock* block, std::unordered_set* predicated, std::list* order, Instruction* break_merge_inst) { // Make sure the CFG is build here. If we don't then it becomes very hard // to know which new blocks need to be updated. context()->InvalidateAnalyses(IRContext::kAnalysisCFG); context()->BuildInvalidAnalyses(IRContext::kAnalysisCFG); // When predicating, be aware of whether this block is a header block, a // merge block or both. // // If this block is a merge block, ensure the appropriate header stays // up-to-date with any changes (i.e. points to the pre-header). // // If this block is a header block, predicate the entire structured // subgraph. This can act recursively. // If |block| is a loop header, then the back edge must jump to the original // code, not the new header. if (block->GetLoopMergeInst()) { if (cfg()->SplitLoopHeader(block) == nullptr) { return false; } } uint32_t merge_block_id = break_merge_inst->GetSingleWordInOperand(0); BasicBlock* merge_block = context()->get_instr_block(merge_block_id); if (merge_block->GetLoopMergeInst()) { cfg()->SplitLoopHeader(merge_block); } // Leave the phi instructions behind. auto iter = block->begin(); while (iter->opcode() == spv::Op::OpPhi) { ++iter; } // Forget about the edges leaving block. They will be removed. cfg()->RemoveSuccessorEdges(block); auto old_body_id = TakeNextId(); BasicBlock* old_body = block->SplitBasicBlock(context(), old_body_id, iter); predicated->insert(old_body); // If a return block is being split, mark the new body block also as a return // block. if (return_blocks_.count(block->id())) { return_blocks_.insert(old_body_id); } // If |block| was a continue target for a loop |old_body| is now the correct // continue target. if (break_merge_inst->opcode() == spv::Op::OpLoopMerge && break_merge_inst->GetSingleWordInOperand(1) == block->id()) { break_merge_inst->SetInOperand(1, {old_body->id()}); context()->UpdateDefUse(break_merge_inst); } // Update |order| so old_block will be traversed. InsertAfterElement(block, old_body, order); // Within the new header we need the following: // 1. Load of the return status flag // 2. Branch to |merge_block| (true) or old body (false) // 3. Update OpPhi instructions in |merge_block|. // 4. Update the CFG. // // Since we are branching to the merge block of the current construct, there // is no need for an OpSelectionMerge. InstructionBuilder builder( context(), block, IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); // 1. Load of the return status flag analysis::Bool bool_type; uint32_t bool_id = context()->get_type_mgr()->GetId(&bool_type); assert(bool_id != 0); uint32_t load_id = builder.AddLoad(bool_id, return_flag_->result_id())->result_id(); // 2. Branch to |merge_block| (true) or |old_body| (false) builder.AddConditionalBranch(load_id, merge_block->id(), old_body->id(), old_body->id()); if (!new_edges_[merge_block].insert(block->id()).second) { // It is possible that we already inserted a new edge to the merge block. // If so, that edge now goes from |old_body| to |merge_block|. new_edges_[merge_block].insert(old_body->id()); } // 3. Update OpPhi instructions in |merge_block|. UpdatePhiNodes(block, merge_block); // 4. Update the CFG. We do this after updating the OpPhi instructions // because |UpdatePhiNodes| assumes the edge from |block| has not been added // to the CFG yet. cfg()->AddEdges(block); cfg()->RegisterBlock(old_body); assert(old_body->begin() != old_body->end()); assert(block->begin() != block->end()); return true; } void MergeReturnPass::RecordReturned(BasicBlock* block) { if (block->tail()->opcode() != spv::Op::OpReturn && block->tail()->opcode() != spv::Op::OpReturnValue) return; assert(return_flag_ && "Did not generate the return flag variable."); if (!constant_true_) { analysis::Bool temp; const analysis::Bool* bool_type = context()->get_type_mgr()->GetRegisteredType(&temp)->AsBool(); analysis::ConstantManager* const_mgr = context()->get_constant_mgr(); const analysis::Constant* true_const = const_mgr->GetConstant(bool_type, {true}); constant_true_ = const_mgr->GetDefiningInstruction(true_const); context()->UpdateDefUse(constant_true_); } std::unique_ptr return_store(new Instruction( context(), spv::Op::OpStore, 0, 0, std::initializer_list{ {SPV_OPERAND_TYPE_ID, {return_flag_->result_id()}}, {SPV_OPERAND_TYPE_ID, {constant_true_->result_id()}}})); Instruction* store_inst = &*block->tail().InsertBefore(std::move(return_store)); context()->set_instr_block(store_inst, block); context()->AnalyzeDefUse(store_inst); } void MergeReturnPass::RecordReturnValue(BasicBlock* block) { auto terminator = *block->tail(); if (terminator.opcode() != spv::Op::OpReturnValue) { return; } assert(return_value_ && "Did not generate the variable to hold the return value."); std::unique_ptr value_store(new Instruction( context(), spv::Op::OpStore, 0, 0, std::initializer_list{ {SPV_OPERAND_TYPE_ID, {return_value_->result_id()}}, {SPV_OPERAND_TYPE_ID, {terminator.GetSingleWordInOperand(0u)}}})); Instruction* store_inst = &*block->tail().InsertBefore(std::move(value_store)); context()->set_instr_block(store_inst, block); context()->AnalyzeDefUse(store_inst); } void MergeReturnPass::AddReturnValue() { if (return_value_) return; uint32_t return_type_id = function_->type_id(); if (get_def_use_mgr()->GetDef(return_type_id)->opcode() == spv::Op::OpTypeVoid) return; uint32_t return_ptr_type = context()->get_type_mgr()->FindPointerToType( return_type_id, spv::StorageClass::Function); uint32_t var_id = TakeNextId(); std::unique_ptr returnValue( new Instruction(context(), spv::Op::OpVariable, return_ptr_type, var_id, std::initializer_list{ {SPV_OPERAND_TYPE_STORAGE_CLASS, {uint32_t(spv::StorageClass::Function)}}})); auto insert_iter = function_->begin()->begin(); insert_iter.InsertBefore(std::move(returnValue)); BasicBlock* entry_block = &*function_->begin(); return_value_ = &*entry_block->begin(); context()->AnalyzeDefUse(return_value_); context()->set_instr_block(return_value_, entry_block); context()->get_decoration_mgr()->CloneDecorations( function_->result_id(), var_id, {spv::Decoration::RelaxedPrecision}); } void MergeReturnPass::AddReturnFlag() { if (return_flag_) return; analysis::TypeManager* type_mgr = context()->get_type_mgr(); analysis::ConstantManager* const_mgr = context()->get_constant_mgr(); analysis::Bool temp; uint32_t bool_id = type_mgr->GetTypeInstruction(&temp); analysis::Bool* bool_type = type_mgr->GetType(bool_id)->AsBool(); const analysis::Constant* false_const = const_mgr->GetConstant(bool_type, {false}); uint32_t const_false_id = const_mgr->GetDefiningInstruction(false_const)->result_id(); uint32_t bool_ptr_id = type_mgr->FindPointerToType(bool_id, spv::StorageClass::Function); uint32_t var_id = TakeNextId(); std::unique_ptr returnFlag(new Instruction( context(), spv::Op::OpVariable, bool_ptr_id, var_id, std::initializer_list{{SPV_OPERAND_TYPE_STORAGE_CLASS, {uint32_t(spv::StorageClass::Function)}}, {SPV_OPERAND_TYPE_ID, {const_false_id}}})); auto insert_iter = function_->begin()->begin(); insert_iter.InsertBefore(std::move(returnFlag)); BasicBlock* entry_block = &*function_->begin(); return_flag_ = &*entry_block->begin(); context()->AnalyzeDefUse(return_flag_); context()->set_instr_block(return_flag_, entry_block); } std::vector MergeReturnPass::CollectReturnBlocks( Function* function) { std::vector return_blocks; for (auto& block : *function) { Instruction& terminator = *block.tail(); if (terminator.opcode() == spv::Op::OpReturn || terminator.opcode() == spv::Op::OpReturnValue) { return_blocks.push_back(&block); } } return return_blocks; } void MergeReturnPass::MergeReturnBlocks( Function* function, const std::vector& return_blocks) { if (return_blocks.size() <= 1) { // No work to do. return; } CreateReturnBlock(); uint32_t return_id = final_return_block_->id(); auto ret_block_iter = --function->end(); // Create the PHI for the merged block (if necessary). // Create new return. std::vector phi_ops; for (auto block : return_blocks) { if (block->tail()->opcode() == spv::Op::OpReturnValue) { phi_ops.push_back( {SPV_OPERAND_TYPE_ID, {block->tail()->GetSingleWordInOperand(0u)}}); phi_ops.push_back({SPV_OPERAND_TYPE_ID, {block->id()}}); } } if (!phi_ops.empty()) { // Need a PHI node to select the correct return value. uint32_t phi_result_id = TakeNextId(); uint32_t phi_type_id = function->type_id(); std::unique_ptr phi_inst(new Instruction( context(), spv::Op::OpPhi, phi_type_id, phi_result_id, phi_ops)); ret_block_iter->AddInstruction(std::move(phi_inst)); BasicBlock::iterator phiIter = ret_block_iter->tail(); std::unique_ptr return_inst( new Instruction(context(), spv::Op::OpReturnValue, 0u, 0u, {{SPV_OPERAND_TYPE_ID, {phi_result_id}}})); ret_block_iter->AddInstruction(std::move(return_inst)); BasicBlock::iterator ret = ret_block_iter->tail(); // Register the phi def and mark instructions for use updates. get_def_use_mgr()->AnalyzeInstDefUse(&*phiIter); get_def_use_mgr()->AnalyzeInstDef(&*ret); } else { std::unique_ptr return_inst( new Instruction(context(), spv::Op::OpReturn)); ret_block_iter->AddInstruction(std::move(return_inst)); } // Replace returns with branches for (auto block : return_blocks) { context()->ForgetUses(block->terminator()); block->tail()->SetOpcode(spv::Op::OpBranch); block->tail()->ReplaceOperands({{SPV_OPERAND_TYPE_ID, {return_id}}}); get_def_use_mgr()->AnalyzeInstUse(block->terminator()); get_def_use_mgr()->AnalyzeInstUse(block->GetLabelInst()); } get_def_use_mgr()->AnalyzeInstDefUse(ret_block_iter->GetLabelInst()); } void MergeReturnPass::AddNewPhiNodes() { std::list order; cfg()->ComputeStructuredOrder(function_, &*function_->begin(), &order); for (BasicBlock* bb : order) { AddNewPhiNodes(bb); } } void MergeReturnPass::AddNewPhiNodes(BasicBlock* bb) { // New phi nodes are needed for any id whose definition used to dominate |bb|, // but no longer dominates |bb|. These are found by walking the dominator // tree starting at the original immediate dominator of |bb| and ending at its // current dominator. // Because we are walking the updated dominator tree it is important that the // new phi nodes for the original dominators of |bb| have already been added. // Otherwise some ids might be missed. Consider the case where bb1 dominates // bb2, and bb2 dominates bb3. Suppose there are changes such that bb1 no // longer dominates bb2 and the same for bb2 and bb3. This algorithm will not // look at the ids defined in bb1. However, calling |AddNewPhiNodes(bb2)| // first will add a phi node in bb2 for that value. Then a call to // |AddNewPhiNodes(bb3)| will process that value by processing the phi in bb2. DominatorAnalysis* dom_tree = context()->GetDominatorAnalysis(function_); BasicBlock* dominator = dom_tree->ImmediateDominator(bb); if (dominator == nullptr) { return; } BasicBlock* current_bb = context()->get_instr_block(original_dominator_[bb]); while (current_bb != nullptr && current_bb != dominator) { for (Instruction& inst : *current_bb) { CreatePhiNodesForInst(bb, inst); } current_bb = dom_tree->ImmediateDominator(current_bb); } } void MergeReturnPass::RecordImmediateDominators(Function* function) { DominatorAnalysis* dom_tree = context()->GetDominatorAnalysis(function); for (BasicBlock& bb : *function) { BasicBlock* dominator_bb = dom_tree->ImmediateDominator(&bb); if (dominator_bb && dominator_bb != cfg()->pseudo_entry_block()) { original_dominator_[&bb] = dominator_bb->terminator(); } else { original_dominator_[&bb] = nullptr; } } } void MergeReturnPass::InsertAfterElement(BasicBlock* element, BasicBlock* new_element, std::list* list) { auto pos = std::find(list->begin(), list->end(), element); assert(pos != list->end()); ++pos; list->insert(pos, new_element); } bool MergeReturnPass::AddSingleCaseSwitchAroundFunction() { CreateReturnBlock(); CreateReturn(final_return_block_); if (context()->AreAnalysesValid(IRContext::kAnalysisCFG)) { cfg()->RegisterBlock(final_return_block_); } if (!CreateSingleCaseSwitch(final_return_block_)) { return false; } return true; } BasicBlock* MergeReturnPass::CreateContinueTarget(uint32_t header_label_id) { std::unique_ptr label( new Instruction(context(), spv::Op::OpLabel, 0u, TakeNextId(), {})); // Create the new basic block std::unique_ptr block(new BasicBlock(std::move(label))); // Insert the new block just before the return block auto pos = function_->end(); assert(pos != function_->begin()); pos--; assert(pos != function_->begin()); assert(&*pos == final_return_block_); auto new_block = &*pos.InsertBefore(std::move(block)); new_block->SetParent(function_); context()->AnalyzeDefUse(new_block->GetLabelInst()); context()->set_instr_block(new_block->GetLabelInst(), new_block); InstructionBuilder builder( context(), new_block, IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); builder.AddBranch(header_label_id); if (context()->AreAnalysesValid(IRContext::kAnalysisCFG)) { cfg()->RegisterBlock(new_block); } return new_block; } bool MergeReturnPass::CreateSingleCaseSwitch(BasicBlock* merge_target) { // Insert the switch before any code is run. We have to split the entry // block to make sure the OpVariable instructions remain in the entry block. BasicBlock* start_block = &*function_->begin(); auto split_pos = start_block->begin(); while (split_pos->opcode() == spv::Op::OpVariable) { ++split_pos; } BasicBlock* old_block = start_block->SplitBasicBlock(context(), TakeNextId(), split_pos); // Add the switch to the end of the entry block. InstructionBuilder builder( context(), start_block, IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); uint32_t const_zero_id = builder.GetUintConstantId(0u); if (const_zero_id == 0) { return false; } builder.AddSwitch(const_zero_id, old_block->id(), {}, merge_target->id()); if (context()->AreAnalysesValid(IRContext::kAnalysisCFG)) { cfg()->RegisterBlock(old_block); cfg()->AddEdges(start_block); } return true; } bool MergeReturnPass::HasNontrivialUnreachableBlocks(Function* function) { utils::BitVector reachable_blocks; cfg()->ForEachBlockInPostOrder( function->entry().get(), [&reachable_blocks](BasicBlock* bb) { reachable_blocks.Set(bb->id()); }); for (auto& bb : *function) { if (reachable_blocks.Get(bb.id())) { continue; } StructuredCFGAnalysis* struct_cfg_analysis = context()->GetStructuredCFGAnalysis(); if (struct_cfg_analysis->IsContinueBlock(bb.id())) { // |bb| must be an empty block ending with a branch to the header. Instruction* inst = &*bb.begin(); if (inst->opcode() != spv::Op::OpBranch) { return true; } if (inst->GetSingleWordInOperand(0) != struct_cfg_analysis->ContainingLoop(bb.id())) { return true; } } else if (struct_cfg_analysis->IsMergeBlock(bb.id())) { // |bb| must be an empty block ending with OpUnreachable. if (bb.begin()->opcode() != spv::Op::OpUnreachable) { return true; } } else { return true; } } return false; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/merge_return_pass.h000066400000000000000000000333761475742701700245440ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_MERGE_RETURN_PASS_H_ #define SOURCE_OPT_MERGE_RETURN_PASS_H_ #include #include #include #include "source/opt/basic_block.h" #include "source/opt/function.h" #include "source/opt/mem_pass.h" namespace spvtools { namespace opt { /******************************************************************************* * * Handling Structured Control Flow: * * Structured control flow guarantees that the CFG will converge at a given * point (the merge block). Within structured control flow, all blocks must be * post-dominated by the merge block, except return blocks and break blocks. * A break block is a block that branches to a containing construct's merge * block. * * Beyond this, we further assume that all unreachable blocks have been * cleaned up. This means that the only unreachable blocks are those necessary * for valid structured control flow. * * Algorithm: * * If a return is encountered, it should record that: i) the function has * "returned" and ii) the value of the return. The return should be replaced * with a branch. If current block is not within structured control flow, this * is the final return. This block should branch to the new return block (its * direct successor). If the current block is within structured control flow, * the branch destination should be the innermost construct's merge. This * merge will always exist because a single case switch is added around the * entire function. If the merge block produces any live values it will need to * be predicated. While the merge is nested in structured control flow, the * predication path should branch to the merge block of the inner-most loop * (or switch if no loop) it is contained in. Once structured control flow has * been exited, it will be at the merge of the single case switch, which will * simply return. * * In the final return block, the return value should be loaded and returned. * Memory promotion passes should be able to promote the newly introduced * variables ("has returned" and "return value"). * * Predicating the Final Merge: * * At each merge block predication needs to be introduced (optimization: only if * that block produces value live beyond it). This needs to be done carefully. * The merge block should be split into multiple blocks. * * 1 (loop header) * / \ * (ret) 2 3 (merge) * * || * \/ * * 0 (single case switch header) * | * 1 (loop header) * / \ * 2 | (merge) * \ / * 3' (merge) * / \ * | 3 (original code in 3) * \ / * (ret) 4 (single case switch merge) * * In the above (simple) example, the return originally in |2| is passed through * the loop merge. That merge is predicated such that the old body of the block * is the else branch. The branch condition is based on the value of the "has * returned" variable. * ******************************************************************************/ // Documented in optimizer.hpp class MergeReturnPass : public MemPass { public: MergeReturnPass() : function_(nullptr), return_flag_(nullptr), return_value_(nullptr), constant_true_(nullptr), final_return_block_(nullptr) {} const char* name() const override { return "merge-return"; } Status Process() override; IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisConstants | IRContext::kAnalysisTypes; } private: // This class is used to store the a break merge instruction and a current // merge instruction. The intended use is to keep track of the block to // break to and the current innermost control flow construct merge block. class StructuredControlState { public: StructuredControlState(Instruction* break_merge, Instruction* merge) : break_merge_(break_merge), current_merge_(merge) {} bool InBreakable() const { return break_merge_; } bool InStructuredFlow() const { return CurrentMergeId() != 0; } uint32_t CurrentMergeId() const { return current_merge_ ? current_merge_->GetSingleWordInOperand(0u) : 0u; } uint32_t CurrentMergeHeader() const { return current_merge_ ? current_merge_->context() ->get_instr_block(current_merge_) ->id() : 0; } uint32_t BreakMergeId() const { return break_merge_ ? break_merge_->GetSingleWordInOperand(0u) : 0u; } Instruction* BreakMergeInst() const { return break_merge_; } private: Instruction* break_merge_; Instruction* current_merge_; }; // Returns all BasicBlocks terminated by OpReturn or OpReturnValue in // |function|. std::vector CollectReturnBlocks(Function* function); // Creates a new basic block with a single return. If |function| returns a // value, a phi node is created to select the correct value to return. // Replaces old returns with an unconditional branch to the new block. void MergeReturnBlocks(Function* function, const std::vector& returnBlocks); // Generate and push new control flow state if |block| contains a merge. void GenerateState(BasicBlock* block); // Merges the return instruction in |function| so that it has a single return // statement. It is assumed that |function| has structured control flow, and // that |return_blocks| is a list of all of the basic blocks in |function| // that have a return. bool ProcessStructured(Function* function, const std::vector& return_blocks); // Changes an OpReturn* or OpUnreachable instruction at the end of |block| // into a store to |return_flag_|, a store to |return_value_| (if necessary), // and a branch to the appropriate merge block. // // Is is assumed that |AddReturnValue| have already been called to created the // variable to store a return value if there is one. // // Note this will break the semantics. To fix this, PredicateBlock will have // to be called on the merge block the branch targets. void ProcessStructuredBlock(BasicBlock* block); // Creates a variable used to store whether or not the control flow has // traversed a block that used to have a return. A pointer to the instruction // declaring the variable is stored in |return_flag_|. void AddReturnFlag(); // Creates the variable used to store the return value when passing through // a block that use to contain an OpReturnValue. void AddReturnValue(); // Adds a store that stores true to |return_flag_| immediately before the // terminator of |block|. It is assumed that |AddReturnFlag| has already been // called. void RecordReturned(BasicBlock* block); // Adds an instruction that stores the value being returned in the // OpReturnValue in |block|. The value is stored to |return_value_|, and the // store is placed before the OpReturnValue. // // If |block| does not contain an OpReturnValue, then this function has no // effect. If |block| contains an OpReturnValue, then |AddReturnValue| must // have already been called to create the variable to store to. void RecordReturnValue(BasicBlock* block); // Adds an unconditional branch in |block| that branches to |target|. It also // adds stores to |return_flag_| and |return_value_| as needed. // |AddReturnFlag| and |AddReturnValue| must have already been called. void BranchToBlock(BasicBlock* block, uint32_t target); // For every basic block that is reachable from |return_block|, extra code is // added to jump around any code that should not be executed because the // original code would have already returned. This involves adding new // selections constructs to jump around these instructions. // // If new blocks that are created will be added to |order|. This way a call // can traverse these new block in structured order. // // Returns true if successful. bool PredicateBlocks(BasicBlock* return_block, std::unordered_set* pSet, std::list* order); // Add a conditional branch at the start of |block| that either jumps to // the merge block of |break_merge_inst| or the original code in |block| // depending on the value in |return_flag_|. The continue target in // |break_merge_inst| will be updated if needed. // // If new blocks that are created will be added to |order|. This way a call // can traverse these new block in structured order. // // Returns true if successful. bool BreakFromConstruct(BasicBlock* block, std::unordered_set* predicated, std::list* order, Instruction* break_merge_inst); // Add an |OpReturn| or |OpReturnValue| to the end of |block|. If an // |OpReturnValue| is needed, the return value is loaded from |return_value_|. void CreateReturn(BasicBlock* block); // Creates a block at the end of the function that will become the single // return block at the end of the pass. void CreateReturnBlock(); // Creates a Phi node in |merge_block| for the result of |inst|. // Any uses of the result of |inst| that are no longer // dominated by |inst|, are replaced with the result of the new |OpPhi| // instruction. void CreatePhiNodesForInst(BasicBlock* merge_block, Instruction& inst); // Add new phi nodes for any id that no longer dominate all of it uses. A phi // node is added to a block |bb| for an id if the id is defined between the // original immediate dominator of |bb| and its new immediate dominator. It // is assumed that at this point there are no unreachable blocks in the // control flow graph. void AddNewPhiNodes(); // Creates any new phi nodes that are needed in |bb|. |AddNewPhiNodes| must // have already been called on the original dominators of |bb|. void AddNewPhiNodes(BasicBlock* bb); // Records the terminator of immediate dominator for every basic block in // |function|. void RecordImmediateDominators(Function* function); // Modifies existing OpPhi instruction in |target| block to account for the // new edge from |new_source|. The value for that edge will be an Undef. // // The CFG must not include the edge from |new_source| to |target| yet. void UpdatePhiNodes(BasicBlock* new_source, BasicBlock* target); StructuredControlState& CurrentState() { return state_.back(); } // Inserts |new_element| into |list| after the first occurrence of |element|. // |element| must be in |list| at least once. void InsertAfterElement(BasicBlock* element, BasicBlock* new_element, std::list* list); // Creates a single case switch around all of the executable code of the // current function where the switch and case value are both zero and the // default is the merge block. Returns after the switch is executed. Sets // |final_return_block_|. bool AddSingleCaseSwitchAroundFunction(); // Creates a new basic block that branches to |header_label_id|. Returns the // new basic block. The block will be the second last basic block in the // function. BasicBlock* CreateContinueTarget(uint32_t header_label_id); // Creates a one case switch around the executable code of the function with // |merge_target| as the merge node. bool CreateSingleCaseSwitch(BasicBlock* merge_target); // Returns true if |function| has an unreachable block that is not a continue // target that simply branches back to the header, or a merge block containing // 1 instruction which is OpUnreachable. bool HasNontrivialUnreachableBlocks(Function* function); // A stack used to keep track of the break and current control flow construct // merge blocks. std::vector state_; // The current function being transformed. Function* function_; // The |OpVariable| instruction defining a boolean variable used to keep track // of whether or not the function is trying to return. Instruction* return_flag_; // The |OpVariable| instruction defining a variabled to used to keep track of // the value that was returned when passing through a block that use to // contain an |OpReturnValue|. Instruction* return_value_; // The instruction defining the boolean constant true. Instruction* constant_true_; // The basic block that is suppose to become the contain the only return value // after processing the current function. BasicBlock* final_return_block_; // This is a map from a node to its original immediate dominator identified by // the terminator if that block. We use the terminator because the block we // want may change if the block is split. std::unordered_map original_dominator_; // A map from a basic block, bb, to the set of basic blocks which represent // the new edges that reach |bb|. std::unordered_map> new_edges_; // Contains all return blocks that are merged. This is set is populated while // processing structured blocks and used to properly construct OpPhi // instructions. std::unordered_set return_blocks_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_MERGE_RETURN_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/modify_maximal_reconvergence.cpp000066400000000000000000000064121475742701700272460ustar00rootroot00000000000000// Copyright (c) 2024 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "modify_maximal_reconvergence.h" #include "source/opt/ir_context.h" #include "source/util/make_unique.h" namespace spvtools { namespace opt { Pass::Status ModifyMaximalReconvergence::Process() { bool changed = false; if (add_) { changed = AddMaximalReconvergence(); } else { changed = RemoveMaximalReconvergence(); } return changed ? Pass::Status::SuccessWithChange : Pass::Status::SuccessWithoutChange; } bool ModifyMaximalReconvergence::AddMaximalReconvergence() { bool changed = false; bool has_extension = false; bool has_shader = context()->get_feature_mgr()->HasCapability(spv::Capability::Shader); for (auto extension : context()->extensions()) { if (extension.GetOperand(0).AsString() == "SPV_KHR_maximal_reconvergence") { has_extension = true; break; } } std::unordered_set entry_points_with_mode; for (auto mode : get_module()->execution_modes()) { if (spv::ExecutionMode(mode.GetSingleWordInOperand(1)) == spv::ExecutionMode::MaximallyReconvergesKHR) { entry_points_with_mode.insert(mode.GetSingleWordInOperand(0)); } } for (auto entry_point : get_module()->entry_points()) { const uint32_t id = entry_point.GetSingleWordInOperand(1); if (!entry_points_with_mode.count(id)) { changed = true; if (!has_extension) { context()->AddExtension("SPV_KHR_maximal_reconvergence"); has_extension = true; } if (!has_shader) { context()->AddCapability(spv::Capability::Shader); has_shader = true; } context()->AddExecutionMode(MakeUnique( context(), spv::Op::OpExecutionMode, 0, 0, std::initializer_list{ {SPV_OPERAND_TYPE_ID, {id}}, {SPV_OPERAND_TYPE_EXECUTION_MODE, {static_cast( spv::ExecutionMode::MaximallyReconvergesKHR)}}})); entry_points_with_mode.insert(id); } } return changed; } bool ModifyMaximalReconvergence::RemoveMaximalReconvergence() { bool changed = false; std::vector to_remove; Instruction* mode = &*get_module()->execution_mode_begin(); while (mode) { if (mode->opcode() != spv::Op::OpExecutionMode && mode->opcode() != spv::Op::OpExecutionModeId) { break; } if (spv::ExecutionMode(mode->GetSingleWordInOperand(1)) == spv::ExecutionMode::MaximallyReconvergesKHR) { mode = context()->KillInst(mode); changed = true; } else { mode = mode->NextNode(); } } changed |= context()->RemoveExtension(Extension::kSPV_KHR_maximal_reconvergence); return changed; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/modify_maximal_reconvergence.h000066400000000000000000000036441475742701700267170ustar00rootroot00000000000000// Copyright (c) 2024 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef LIBSPIRV_OPT_MODIFY_MAXIMAL_RECONVERGENCE_H_ #define LIBSPIRV_OPT_MODIFY_MAXIMAL_RECONVERGENCE_H_ #include "pass.h" namespace spvtools { namespace opt { // Modifies entry points to either add or remove MaximallyReconvergesKHR // // This pass will either add or remove MaximallyReconvergesKHR to all entry // points in the module. When adding the execution mode, it does not attempt to // determine whether any ray tracing invocation repack instructions might be // executed because it is a runtime restriction. That is left to the user. class ModifyMaximalReconvergence : public Pass { public: const char* name() const override { return "modify-maximal-reconvergence"; } Status Process() override; explicit ModifyMaximalReconvergence(bool add = true) : Pass(), add_(add) {} IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisDecorations | IRContext::kAnalysisCombinators | IRContext::kAnalysisCFG | IRContext::kAnalysisNameMap | IRContext::kAnalysisConstants | IRContext::kAnalysisTypes; } private: bool AddMaximalReconvergence(); bool RemoveMaximalReconvergence(); bool add_; }; } // namespace opt } // namespace spvtools #endif // LIBSPIRV_OPT_MODIFY_MAXIMAL_RECONVERGENCE_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/module.cpp000066400000000000000000000232021475742701700226230ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/module.h" #include #include #include #include "source/operand.h" #include "source/opt/ir_context.h" #include "source/opt/reflect.h" namespace spvtools { namespace opt { uint32_t Module::TakeNextIdBound() { if (context()) { if (id_bound() >= context()->max_id_bound()) { return 0; } } else if (id_bound() >= kDefaultMaxIdBound) { return 0; } return header_.bound++; } std::vector Module::GetTypes() { std::vector type_insts; for (auto& inst : types_values_) { if (IsTypeInst(inst.opcode())) type_insts.push_back(&inst); } return type_insts; } std::vector Module::GetTypes() const { std::vector type_insts; for (auto& inst : types_values_) { if (IsTypeInst(inst.opcode())) type_insts.push_back(&inst); } return type_insts; } std::vector Module::GetConstants() { std::vector const_insts; for (auto& inst : types_values_) { if (IsConstantInst(inst.opcode())) const_insts.push_back(&inst); } return const_insts; } std::vector Module::GetConstants() const { std::vector const_insts; for (auto& inst : types_values_) { if (IsConstantInst(inst.opcode())) const_insts.push_back(&inst); } return const_insts; } uint32_t Module::GetGlobalValue(spv::Op opcode) const { for (auto& inst : types_values_) { if (inst.opcode() == opcode) return inst.result_id(); } return 0; } void Module::AddGlobalValue(spv::Op opcode, uint32_t result_id, uint32_t type_id) { std::unique_ptr newGlobal( new Instruction(context(), opcode, type_id, result_id, {})); AddGlobalValue(std::move(newGlobal)); } void Module::ForEachInst(const std::function& f, bool run_on_debug_line_insts) { #define DELEGATE(list) list.ForEachInst(f, run_on_debug_line_insts) DELEGATE(capabilities_); DELEGATE(extensions_); DELEGATE(ext_inst_imports_); if (memory_model_) memory_model_->ForEachInst(f, run_on_debug_line_insts); if (sampled_image_address_mode_) sampled_image_address_mode_->ForEachInst(f, run_on_debug_line_insts); DELEGATE(entry_points_); DELEGATE(execution_modes_); DELEGATE(debugs1_); DELEGATE(debugs2_); DELEGATE(debugs3_); DELEGATE(ext_inst_debuginfo_); DELEGATE(annotations_); DELEGATE(types_values_); for (auto& i : functions_) { i->ForEachInst(f, run_on_debug_line_insts, /* run_on_non_semantic_insts = */ true); } #undef DELEGATE } void Module::ForEachInst(const std::function& f, bool run_on_debug_line_insts) const { #define DELEGATE(i) i.ForEachInst(f, run_on_debug_line_insts) for (auto& i : capabilities_) DELEGATE(i); for (auto& i : extensions_) DELEGATE(i); for (auto& i : ext_inst_imports_) DELEGATE(i); if (memory_model_) static_cast(memory_model_.get()) ->ForEachInst(f, run_on_debug_line_insts); if (sampled_image_address_mode_) static_cast(sampled_image_address_mode_.get()) ->ForEachInst(f, run_on_debug_line_insts); for (auto& i : entry_points_) DELEGATE(i); for (auto& i : execution_modes_) DELEGATE(i); for (auto& i : debugs1_) DELEGATE(i); for (auto& i : debugs2_) DELEGATE(i); for (auto& i : debugs3_) DELEGATE(i); for (auto& i : annotations_) DELEGATE(i); for (auto& i : types_values_) DELEGATE(i); for (auto& i : ext_inst_debuginfo_) DELEGATE(i); for (auto& i : functions_) { static_cast(i.get())->ForEachInst( f, run_on_debug_line_insts, /* run_on_non_semantic_insts = */ true); } if (run_on_debug_line_insts) { for (auto& i : trailing_dbg_line_info_) DELEGATE(i); } #undef DELEGATE } void Module::ToBinary(std::vector* binary, bool skip_nop) const { binary->push_back(header_.magic_number); binary->push_back(header_.version); // TODO(antiagainst): should we change the generator number? binary->push_back(header_.generator); binary->push_back(header_.bound); binary->push_back(header_.schema); size_t bound_idx = binary->size() - 2; DebugScope last_scope(kNoDebugScope, kNoInlinedAt); const Instruction* last_line_inst = nullptr; bool between_merge_and_branch = false; bool between_label_and_phi_var = false; auto write_inst = [binary, skip_nop, &last_scope, &last_line_inst, &between_merge_and_branch, &between_label_and_phi_var, this](const Instruction* i) { // Skip emitting line instructions between merge and branch instructions. auto opcode = i->opcode(); if (between_merge_and_branch && i->IsLineInst()) { return; } if (last_line_inst != nullptr) { // If the current instruction is OpLine or DebugLine and it is the same // as the last line instruction that is still effective (can be applied // to the next instruction), we skip writing the current instruction. if (i->IsLine()) { uint32_t operand_index = 0; if (last_line_inst->WhileEachInOperand( [&operand_index, i](const uint32_t* word) { assert(i->NumInOperandWords() > operand_index); return *word == i->GetSingleWordInOperand(operand_index++); })) { return; } } else if (!i->IsNoLine() && i->dbg_line_insts().empty()) { // If the current instruction does not have the line information, // the last line information is not effective any more. Emit OpNoLine // or DebugNoLine to specify it. uint32_t shader_set_id = context() ->get_feature_mgr() ->GetExtInstImportId_Shader100DebugInfo(); if (shader_set_id != 0) { binary->push_back((5 << 16) | static_cast(spv::Op::OpExtInst)); binary->push_back(context()->get_type_mgr()->GetVoidTypeId()); binary->push_back(context()->TakeNextId()); binary->push_back(shader_set_id); binary->push_back(NonSemanticShaderDebugInfo100DebugNoLine); } else { binary->push_back((1 << 16) | static_cast(spv::Op::OpNoLine)); } last_line_inst = nullptr; } } if (opcode == spv::Op::OpLabel) { between_label_and_phi_var = true; } else if (opcode != spv::Op::OpVariable && opcode != spv::Op::OpPhi && !spvtools::opt::IsOpLineInst(opcode)) { between_label_and_phi_var = false; } if (!(skip_nop && i->IsNop())) { const auto& scope = i->GetDebugScope(); if (scope != last_scope && !between_merge_and_branch) { // Can only emit nonsemantic instructions after all phi instructions // in a block so don't emit scope instructions before phi instructions // for NonSemantic.Shader.DebugInfo.100. if (!between_label_and_phi_var || context() ->get_feature_mgr() ->GetExtInstImportId_OpenCL100DebugInfo()) { // Emit DebugScope |scope| to |binary|. auto dbg_inst = ext_inst_debuginfo_.begin(); scope.ToBinary(dbg_inst->type_id(), context()->TakeNextId(), dbg_inst->GetSingleWordOperand(2), binary); } last_scope = scope; } i->ToBinaryWithoutAttachedDebugInsts(binary); } // Update the last line instruction. between_merge_and_branch = false; if (spvOpcodeIsBlockTerminator(opcode) || i->IsNoLine()) { last_line_inst = nullptr; } else if (opcode == spv::Op::OpLoopMerge || opcode == spv::Op::OpSelectionMerge) { between_merge_and_branch = true; last_line_inst = nullptr; } else if (i->IsLine()) { last_line_inst = i; } }; ForEachInst(write_inst, true); // We create new instructions for DebugScope and DebugNoLine. The bound must // be updated. binary->data()[bound_idx] = header_.bound; } uint32_t Module::ComputeIdBound() const { uint32_t highest = 0; ForEachInst( [&highest](const Instruction* inst) { for (const auto& operand : *inst) { if (spvIsIdType(operand.type)) { highest = std::max(highest, operand.words[0]); } } }, true /* scan debug line insts as well */); return highest + 1; } bool Module::HasExplicitCapability(uint32_t cap) { for (auto& ci : capabilities_) { uint32_t tcap = ci.GetSingleWordOperand(0); if (tcap == cap) { return true; } } return false; } uint32_t Module::GetExtInstImportId(const char* extstr) { for (auto& ei : ext_inst_imports_) if (!ei.GetInOperand(0).AsString().compare(extstr)) return ei.result_id(); return 0; } std::ostream& operator<<(std::ostream& str, const Module& module) { module.ForEachInst([&str](const Instruction* inst) { str << *inst; if (inst->opcode() != spv::Op::OpFunctionEnd) { str << std::endl; } }); return str; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/module.h000066400000000000000000000477661475742701700223150ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_MODULE_H_ #define SOURCE_OPT_MODULE_H_ #include #include #include #include #include #include #include "source/opt/function.h" #include "source/opt/instruction.h" #include "source/opt/iterator.h" namespace spvtools { namespace opt { class IRContext; // A struct for containing the module header information. struct ModuleHeader { uint32_t magic_number; uint32_t version; uint32_t generator; uint32_t bound; uint32_t schema; }; // A SPIR-V module. It contains all the information for a SPIR-V module and // serves as the backbone of optimization transformations. class Module { public: using iterator = UptrVectorIterator; using const_iterator = UptrVectorIterator; using inst_iterator = InstructionList::iterator; using const_inst_iterator = InstructionList::const_iterator; // Creates an empty module with zero'd header. Module() : header_({}), contains_debug_info_(false) {} // Sets the header to the given |header|. void SetHeader(const ModuleHeader& header) { header_ = header; } // Sets the Id bound. The Id bound cannot be set to 0. void SetIdBound(uint32_t bound) { assert(bound != 0); header_.bound = bound; } // Returns the Id bound. uint32_t IdBound() const { return header_.bound; } // Returns the current Id bound and increases it to the next available value. // If the id bound has already reached its maximum value, then 0 is returned. // The maximum value for the id bound is obtained from the context. If there // is none, then the minimum that limit can be according to the spir-v // specification. // TODO(1841): Update the uses to check for a 0 return value. uint32_t TakeNextIdBound(); // Appends a capability instruction to this module. inline void AddCapability(std::unique_ptr c); // Appends an extension instruction to this module. inline void AddExtension(std::unique_ptr e); // Appends an extended instruction set instruction to this module. inline void AddExtInstImport(std::unique_ptr e); // Set the memory model for this module. inline void SetMemoryModel(std::unique_ptr m); // Set the sampled image addressing mode for this module. inline void SetSampledImageAddressMode(std::unique_ptr m); // Appends an entry point instruction to this module. inline void AddEntryPoint(std::unique_ptr e); // Appends an execution mode instruction to this module. inline void AddExecutionMode(std::unique_ptr e); // Appends a debug 1 instruction (excluding OpLine & OpNoLine) to this module. // "debug 1" instructions are the ones in layout section 7.a), see section // 2.4 Logical Layout of a Module from the SPIR-V specification. inline void AddDebug1Inst(std::unique_ptr d); // Appends a debug 2 instruction (excluding OpLine & OpNoLine) to this module. // "debug 2" instructions are the ones in layout section 7.b), see section // 2.4 Logical Layout of a Module from the SPIR-V specification. inline void AddDebug2Inst(std::unique_ptr d); // Appends a debug 3 instruction (OpModuleProcessed) to this module. // This is due to decision by the SPIR Working Group, pending publication. inline void AddDebug3Inst(std::unique_ptr d); // Appends a debug info extension (OpenCL.DebugInfo.100, // NonSemantic.Shader.DebugInfo.100, or DebugInfo) instruction to this module. inline void AddExtInstDebugInfo(std::unique_ptr d); // Appends an annotation instruction to this module. inline void AddAnnotationInst(std::unique_ptr a); // Appends a type-declaration instruction to this module. inline void AddType(std::unique_ptr t); // Appends a constant, global variable, or OpUndef instruction to this module. inline void AddGlobalValue(std::unique_ptr v); // Prepends a function declaration to this module. inline void AddFunctionDeclaration(std::unique_ptr f); // Appends a function to this module. inline void AddFunction(std::unique_ptr f); // Sets |contains_debug_info_| as true. inline void SetContainsDebugInfo(); inline bool ContainsDebugInfo() { return contains_debug_info_; } // Returns a vector of pointers to type-declaration instructions in this // module. std::vector GetTypes(); std::vector GetTypes() const; // Returns a vector of pointers to constant-creation instructions in this // module. std::vector GetConstants(); std::vector GetConstants() const; // Return result id of global value with |opcode|, 0 if not present. uint32_t GetGlobalValue(spv::Op opcode) const; // Add global value with |opcode|, |result_id| and |type_id| void AddGlobalValue(spv::Op opcode, uint32_t result_id, uint32_t type_id); inline uint32_t id_bound() const { return header_.bound; } inline uint32_t version() const { return header_.version; } inline uint32_t generator() const { return header_.generator; } inline uint32_t schema() const { return header_.schema; } inline void set_version(uint32_t v) { header_.version = v; } // Iterators for capabilities instructions contained in this module. inline inst_iterator capability_begin(); inline inst_iterator capability_end(); inline IteratorRange capabilities(); inline IteratorRange capabilities() const; // Iterators for ext_inst_imports instructions contained in this module. inline inst_iterator ext_inst_import_begin(); inline inst_iterator ext_inst_import_end(); inline IteratorRange ext_inst_imports(); inline IteratorRange ext_inst_imports() const; // Return the memory model instruction contained in this module. inline Instruction* GetMemoryModel() { return memory_model_.get(); } inline const Instruction* GetMemoryModel() const { return memory_model_.get(); } // Return the sampled image address mode instruction contained in this module. inline Instruction* GetSampledImageAddressMode() { return sampled_image_address_mode_.get(); } inline const Instruction* GetSampledImageAddressMode() const { return sampled_image_address_mode_.get(); } // There are several kinds of debug instructions, according to where they can // appear in the logical layout of a module: // - Section 7a: OpString, OpSourceExtension, OpSource, OpSourceContinued // - Section 7b: OpName, OpMemberName // - Section 7c: OpModuleProcessed // - Mostly anywhere: OpLine and OpNoLine // // Iterators for debug 1 instructions (excluding OpLine & OpNoLine) contained // in this module. These are for layout section 7a. inline inst_iterator debug1_begin(); inline inst_iterator debug1_end(); inline IteratorRange debugs1(); inline IteratorRange debugs1() const; // Iterators for debug 2 instructions (excluding OpLine & OpNoLine) contained // in this module. These are for layout section 7b. inline inst_iterator debug2_begin(); inline inst_iterator debug2_end(); inline IteratorRange debugs2(); inline IteratorRange debugs2() const; // Iterators for debug 3 instructions (excluding OpLine & OpNoLine) contained // in this module. These are for layout section 7c. inline inst_iterator debug3_begin(); inline inst_iterator debug3_end(); inline IteratorRange debugs3(); inline IteratorRange debugs3() const; // Iterators for debug info instructions (excluding OpLine & OpNoLine) // contained in this module. These are OpExtInst for DebugInfo extension // placed between section 9 and 10. inline inst_iterator ext_inst_debuginfo_begin(); inline inst_iterator ext_inst_debuginfo_end(); inline IteratorRange ext_inst_debuginfo(); inline IteratorRange ext_inst_debuginfo() const; // Iterators for entry point instructions contained in this module inline IteratorRange entry_points(); inline IteratorRange entry_points() const; // Iterators for execution_modes instructions contained in this module. inline inst_iterator execution_mode_begin(); inline inst_iterator execution_mode_end(); inline IteratorRange execution_modes(); inline IteratorRange execution_modes() const; // Iterators for annotation instructions contained in this module. inline inst_iterator annotation_begin(); inline inst_iterator annotation_end(); IteratorRange annotations(); IteratorRange annotations() const; // Iterators for extension instructions contained in this module. inline inst_iterator extension_begin(); inline inst_iterator extension_end(); IteratorRange extensions(); IteratorRange extensions() const; // Iterators for types, constants and global variables instructions. inline inst_iterator types_values_begin(); inline inst_iterator types_values_end(); inline IteratorRange types_values(); inline IteratorRange types_values() const; // Iterators for functions contained in this module. iterator begin() { return iterator(&functions_, functions_.begin()); } iterator end() { return iterator(&functions_, functions_.end()); } const_iterator begin() const { return cbegin(); } const_iterator end() const { return cend(); } inline const_iterator cbegin() const; inline const_iterator cend() const; // Invokes function |f| on all instructions in this module, and optionally on // the debug line instructions that precede them. void ForEachInst(const std::function& f, bool run_on_debug_line_insts = false); void ForEachInst(const std::function& f, bool run_on_debug_line_insts = false) const; // Pushes the binary segments for this instruction into the back of *|binary|. // If |skip_nop| is true and this is a OpNop, do nothing. void ToBinary(std::vector* binary, bool skip_nop) const; // Returns 1 more than the maximum Id value mentioned in the module. uint32_t ComputeIdBound() const; // Returns true if module has capability |cap| bool HasExplicitCapability(uint32_t cap); // Returns id for OpExtInst instruction for extension |extstr|. // Returns 0 if not found. uint32_t GetExtInstImportId(const char* extstr); // Sets the associated context for this module void SetContext(IRContext* c) { context_ = c; } // Gets the associated context for this module IRContext* context() const { return context_; } // Sets the trailing debug line info to |dbg_line_info|. void SetTrailingDbgLineInfo(std::vector&& dbg_line_info) { trailing_dbg_line_info_ = std::move(dbg_line_info); } std::vector& trailing_dbg_line_info() { return trailing_dbg_line_info_; } const std::vector& trailing_dbg_line_info() const { return trailing_dbg_line_info_; } private: ModuleHeader header_; // Module header // The following fields respect the "Logical Layout of a Module" in // Section 2.4 of the SPIR-V specification. IRContext* context_; InstructionList capabilities_; InstructionList extensions_; InstructionList ext_inst_imports_; // A module only has one memory model instruction. std::unique_ptr memory_model_; // A module can only have one optional sampled image addressing mode std::unique_ptr sampled_image_address_mode_; InstructionList entry_points_; InstructionList execution_modes_; InstructionList debugs1_; InstructionList debugs2_; InstructionList debugs3_; InstructionList ext_inst_debuginfo_; InstructionList annotations_; // Type declarations, constants, and global variable declarations. InstructionList types_values_; std::vector> functions_; // If the module ends with Op*Line instruction, they will not be attached to // any instruction. We record them here, so they will not be lost. std::vector trailing_dbg_line_info_; // This module contains DebugScope/DebugNoScope or OpLine/OpNoLine. bool contains_debug_info_; }; // Pretty-prints |module| to |str|. Returns |str|. std::ostream& operator<<(std::ostream& str, const Module& module); inline void Module::AddCapability(std::unique_ptr c) { capabilities_.push_back(std::move(c)); } inline void Module::AddExtension(std::unique_ptr e) { extensions_.push_back(std::move(e)); } inline void Module::AddExtInstImport(std::unique_ptr e) { ext_inst_imports_.push_back(std::move(e)); } inline void Module::SetMemoryModel(std::unique_ptr m) { memory_model_ = std::move(m); } inline void Module::SetSampledImageAddressMode(std::unique_ptr m) { sampled_image_address_mode_ = std::move(m); } inline void Module::AddEntryPoint(std::unique_ptr e) { entry_points_.push_back(std::move(e)); } inline void Module::AddExecutionMode(std::unique_ptr e) { execution_modes_.push_back(std::move(e)); } inline void Module::AddDebug1Inst(std::unique_ptr d) { debugs1_.push_back(std::move(d)); } inline void Module::AddDebug2Inst(std::unique_ptr d) { debugs2_.push_back(std::move(d)); } inline void Module::AddDebug3Inst(std::unique_ptr d) { debugs3_.push_back(std::move(d)); } inline void Module::AddExtInstDebugInfo(std::unique_ptr d) { ext_inst_debuginfo_.push_back(std::move(d)); } inline void Module::AddAnnotationInst(std::unique_ptr a) { annotations_.push_back(std::move(a)); } inline void Module::AddType(std::unique_ptr t) { types_values_.push_back(std::move(t)); } inline void Module::AddGlobalValue(std::unique_ptr v) { types_values_.push_back(std::move(v)); } inline void Module::AddFunctionDeclaration(std::unique_ptr f) { // function declarations must come before function definitions. functions_.emplace(functions_.begin(), std::move(f)); } inline void Module::AddFunction(std::unique_ptr f) { functions_.emplace_back(std::move(f)); } inline void Module::SetContainsDebugInfo() { contains_debug_info_ = true; } inline Module::inst_iterator Module::capability_begin() { return capabilities_.begin(); } inline Module::inst_iterator Module::capability_end() { return capabilities_.end(); } inline IteratorRange Module::capabilities() { return make_range(capabilities_.begin(), capabilities_.end()); } inline IteratorRange Module::capabilities() const { return make_range(capabilities_.begin(), capabilities_.end()); } inline Module::inst_iterator Module::ext_inst_import_begin() { return ext_inst_imports_.begin(); } inline Module::inst_iterator Module::ext_inst_import_end() { return ext_inst_imports_.end(); } inline IteratorRange Module::ext_inst_imports() { return make_range(ext_inst_imports_.begin(), ext_inst_imports_.end()); } inline IteratorRange Module::ext_inst_imports() const { return make_range(ext_inst_imports_.begin(), ext_inst_imports_.end()); } inline Module::inst_iterator Module::debug1_begin() { return debugs1_.begin(); } inline Module::inst_iterator Module::debug1_end() { return debugs1_.end(); } inline IteratorRange Module::debugs1() { return make_range(debugs1_.begin(), debugs1_.end()); } inline IteratorRange Module::debugs1() const { return make_range(debugs1_.begin(), debugs1_.end()); } inline Module::inst_iterator Module::debug2_begin() { return debugs2_.begin(); } inline Module::inst_iterator Module::debug2_end() { return debugs2_.end(); } inline IteratorRange Module::debugs2() { return make_range(debugs2_.begin(), debugs2_.end()); } inline IteratorRange Module::debugs2() const { return make_range(debugs2_.begin(), debugs2_.end()); } inline Module::inst_iterator Module::debug3_begin() { return debugs3_.begin(); } inline Module::inst_iterator Module::debug3_end() { return debugs3_.end(); } inline IteratorRange Module::debugs3() { return make_range(debugs3_.begin(), debugs3_.end()); } inline IteratorRange Module::debugs3() const { return make_range(debugs3_.begin(), debugs3_.end()); } inline Module::inst_iterator Module::ext_inst_debuginfo_begin() { return ext_inst_debuginfo_.begin(); } inline Module::inst_iterator Module::ext_inst_debuginfo_end() { return ext_inst_debuginfo_.end(); } inline IteratorRange Module::ext_inst_debuginfo() { return make_range(ext_inst_debuginfo_.begin(), ext_inst_debuginfo_.end()); } inline IteratorRange Module::ext_inst_debuginfo() const { return make_range(ext_inst_debuginfo_.begin(), ext_inst_debuginfo_.end()); } inline IteratorRange Module::entry_points() { return make_range(entry_points_.begin(), entry_points_.end()); } inline IteratorRange Module::entry_points() const { return make_range(entry_points_.begin(), entry_points_.end()); } inline Module::inst_iterator Module::execution_mode_begin() { return execution_modes_.begin(); } inline Module::inst_iterator Module::execution_mode_end() { return execution_modes_.end(); } inline IteratorRange Module::execution_modes() { return make_range(execution_modes_.begin(), execution_modes_.end()); } inline IteratorRange Module::execution_modes() const { return make_range(execution_modes_.begin(), execution_modes_.end()); } inline Module::inst_iterator Module::annotation_begin() { return annotations_.begin(); } inline Module::inst_iterator Module::annotation_end() { return annotations_.end(); } inline IteratorRange Module::annotations() { return make_range(annotations_.begin(), annotations_.end()); } inline IteratorRange Module::annotations() const { return make_range(annotations_.begin(), annotations_.end()); } inline Module::inst_iterator Module::extension_begin() { return extensions_.begin(); } inline Module::inst_iterator Module::extension_end() { return extensions_.end(); } inline IteratorRange Module::extensions() { return make_range(extensions_.begin(), extensions_.end()); } inline IteratorRange Module::extensions() const { return make_range(extensions_.begin(), extensions_.end()); } inline Module::inst_iterator Module::types_values_begin() { return types_values_.begin(); } inline Module::inst_iterator Module::types_values_end() { return types_values_.end(); } inline IteratorRange Module::types_values() { return make_range(types_values_.begin(), types_values_.end()); } inline IteratorRange Module::types_values() const { return make_range(types_values_.begin(), types_values_.end()); } inline Module::const_iterator Module::cbegin() const { return const_iterator(&functions_, functions_.cbegin()); } inline Module::const_iterator Module::cend() const { return const_iterator(&functions_, functions_.cend()); } } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_MODULE_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/null_pass.h000066400000000000000000000020261475742701700230040ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_NULL_PASS_H_ #define SOURCE_OPT_NULL_PASS_H_ #include "source/opt/module.h" #include "source/opt/pass.h" namespace spvtools { namespace opt { // See optimizer.hpp for documentation. class NullPass : public Pass { public: const char* name() const override { return "null"; } Status Process() override { return Status::SuccessWithoutChange; } }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_NULL_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/opextinst_forward_ref_fixup_pass.cpp000066400000000000000000000074241475742701700302240ustar00rootroot00000000000000// Copyright (c) 2024 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/opextinst_forward_ref_fixup_pass.h" #include #include #include "source/extensions.h" #include "source/opt/ir_context.h" #include "source/opt/module.h" #include "type_manager.h" namespace spvtools { namespace opt { namespace { // Returns true if the instruction |inst| has a forward reference to another // debug instruction. // |debug_ids| contains the list of IDs belonging to debug instructions. // |seen_ids| contains the list of IDs already seen. bool HasForwardReference(const Instruction& inst, const std::unordered_set& debug_ids, const std::unordered_set& seen_ids) { const uint32_t num_in_operands = inst.NumInOperands(); for (uint32_t i = 0; i < num_in_operands; ++i) { const Operand& op = inst.GetInOperand(i); if (!spvIsIdType(op.type)) continue; if (debug_ids.count(op.AsId()) == 0) continue; if (seen_ids.count(op.AsId()) == 0) return true; } return false; } // Replace |inst| opcode with OpExtInstWithForwardRefsKHR or OpExtInst // if required to comply with forward references. bool ReplaceOpcodeIfRequired(Instruction& inst, bool hasForwardReferences) { if (hasForwardReferences && inst.opcode() != spv::Op::OpExtInstWithForwardRefsKHR) inst.SetOpcode(spv::Op::OpExtInstWithForwardRefsKHR); else if (!hasForwardReferences && inst.opcode() != spv::Op::OpExtInst) inst.SetOpcode(spv::Op::OpExtInst); else return false; return true; } // Returns all the result IDs of the instructions in |range|. std::unordered_set gatherResultIds( const IteratorRange& range) { std::unordered_set output; for (const auto& it : range) output.insert(it.result_id()); return output; } } // namespace Pass::Status OpExtInstWithForwardReferenceFixupPass::Process() { std::unordered_set seen_ids = gatherResultIds(get_module()->ext_inst_imports()); std::unordered_set debug_ids = gatherResultIds(get_module()->ext_inst_debuginfo()); for (uint32_t id : seen_ids) debug_ids.insert(id); bool moduleChanged = false; bool hasAtLeastOneForwardReference = false; IRContext* ctx = context(); for (Instruction& inst : get_module()->ext_inst_debuginfo()) { if (inst.opcode() != spv::Op::OpExtInst && inst.opcode() != spv::Op::OpExtInstWithForwardRefsKHR) continue; seen_ids.insert(inst.result_id()); bool hasForwardReferences = HasForwardReference(inst, debug_ids, seen_ids); hasAtLeastOneForwardReference |= hasForwardReferences; if (ReplaceOpcodeIfRequired(inst, hasForwardReferences)) { moduleChanged = true; ctx->AnalyzeUses(&inst); } } if (hasAtLeastOneForwardReference != ctx->get_feature_mgr()->HasExtension( kSPV_KHR_relaxed_extended_instruction)) { if (hasAtLeastOneForwardReference) ctx->AddExtension("SPV_KHR_relaxed_extended_instruction"); else ctx->RemoveExtension(Extension::kSPV_KHR_relaxed_extended_instruction); moduleChanged = true; } return moduleChanged ? Status::SuccessWithChange : Status::SuccessWithoutChange; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/opextinst_forward_ref_fixup_pass.h000066400000000000000000000034521475742701700276660ustar00rootroot00000000000000// Copyright (c) 2024 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_OPEXTINST_FORWARD_REF_FIXUP_H #define SOURCE_OPT_OPEXTINST_FORWARD_REF_FIXUP_H #include "source/opt/ir_context.h" #include "source/opt/module.h" #include "source/opt/pass.h" namespace spvtools { namespace opt { class OpExtInstWithForwardReferenceFixupPass : public Pass { public: const char* name() const override { return "fix-opextinst-opcodes"; } Status Process() override; IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisDecorations | IRContext::kAnalysisCombinators | IRContext::kAnalysisCFG | IRContext::kAnalysisDominatorAnalysis | IRContext::kAnalysisLoopAnalysis | IRContext::kAnalysisNameMap | IRContext::kAnalysisScalarEvolution | IRContext::kAnalysisRegisterPressure | IRContext::kAnalysisValueNumberTable | IRContext::kAnalysisStructuredCFG | IRContext::kAnalysisBuiltinVarId | IRContext::kAnalysisIdToFuncMapping | IRContext::kAnalysisTypes | IRContext::kAnalysisDefUse | IRContext::kAnalysisConstants; } }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_OPEXTINST_FORWARD_REF_FIXUP_H KhronosGroup-SPIRV-Tools-f289d04/source/opt/optimizer.cpp000066400000000000000000001410301475742701700233600ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "spirv-tools/optimizer.hpp" #include #include #include #include #include #include #include #include #include "source/opt/build_module.h" #include "source/opt/graphics_robust_access_pass.h" #include "source/opt/log.h" #include "source/opt/pass_manager.h" #include "source/opt/passes.h" #include "source/spirv_optimizer_options.h" #include "source/util/make_unique.h" #include "source/util/string_utils.h" namespace spvtools { std::vector GetVectorOfStrings(const char** strings, const size_t string_count) { std::vector result; for (uint32_t i = 0; i < string_count; i++) { result.emplace_back(strings[i]); } return result; } struct Optimizer::PassToken::Impl { Impl(std::unique_ptr p) : pass(std::move(p)) {} std::unique_ptr pass; // Internal implementation pass. }; Optimizer::PassToken::PassToken( std::unique_ptr impl) : impl_(std::move(impl)) {} Optimizer::PassToken::PassToken(std::unique_ptr&& pass) : impl_(MakeUnique(std::move(pass))) {} Optimizer::PassToken::PassToken(PassToken&& that) : impl_(std::move(that.impl_)) {} Optimizer::PassToken& Optimizer::PassToken::operator=(PassToken&& that) { impl_ = std::move(that.impl_); return *this; } Optimizer::PassToken::~PassToken() {} struct Optimizer::Impl { explicit Impl(spv_target_env env) : target_env(env), pass_manager() {} spv_target_env target_env; // Target environment. opt::PassManager pass_manager; // Internal implementation pass manager. std::unordered_set live_locs; // Arg to debug dead output passes }; Optimizer::Optimizer(spv_target_env env) : impl_(new Impl(env)) { assert(env != SPV_ENV_WEBGPU_0); } Optimizer::~Optimizer() {} void Optimizer::SetMessageConsumer(MessageConsumer c) { // All passes' message consumer needs to be updated. for (uint32_t i = 0; i < impl_->pass_manager.NumPasses(); ++i) { impl_->pass_manager.GetPass(i)->SetMessageConsumer(c); } impl_->pass_manager.SetMessageConsumer(std::move(c)); } const MessageConsumer& Optimizer::consumer() const { return impl_->pass_manager.consumer(); } Optimizer& Optimizer::RegisterPass(PassToken&& p) { // Change to use the pass manager's consumer. p.impl_->pass->SetMessageConsumer(consumer()); impl_->pass_manager.AddPass(std::move(p.impl_->pass)); return *this; } // The legalization passes take a spir-v shader generated by an HLSL front-end // and turn it into a valid vulkan spir-v shader. There are two ways in which // the code will be invalid at the start: // // 1) There will be opaque objects, like images, which will be passed around // in intermediate objects. Valid spir-v will have to replace the use of // the opaque object with an intermediate object that is the result of the // load of the global opaque object. // // 2) There will be variables that contain pointers to structured or uniform // buffers. It be legal, the variables must be eliminated, and the // references to the structured buffers must use the result of OpVariable // in the Uniform storage class. // // Optimization in this list must accept shaders with these relaxation of the // rules. There is not guarantee that this list of optimizations is able to // legalize all inputs, but it is on a best effort basis. // // The legalization problem is essentially a very general copy propagation // problem. The optimization we use are all used to either do copy propagation // or enable more copy propagation. Optimizer& Optimizer::RegisterLegalizationPasses(bool preserve_interface) { return // Wrap OpKill instructions so all other code can be inlined. RegisterPass(CreateWrapOpKillPass()) // Remove unreachable block so that merge return works. .RegisterPass(CreateDeadBranchElimPass()) // Merge the returns so we can inline. .RegisterPass(CreateMergeReturnPass()) // Make sure uses and definitions are in the same function. .RegisterPass(CreateInlineExhaustivePass()) // Make private variable function scope .RegisterPass(CreateEliminateDeadFunctionsPass()) .RegisterPass(CreatePrivateToLocalPass()) // Fix up the storage classes that DXC may have purposely generated // incorrectly. All functions are inlined, and a lot of dead code has // been removed. .RegisterPass(CreateFixStorageClassPass()) // Propagate the value stored to the loads in very simple cases. .RegisterPass(CreateLocalSingleBlockLoadStoreElimPass()) .RegisterPass(CreateLocalSingleStoreElimPass()) .RegisterPass(CreateAggressiveDCEPass(preserve_interface)) // Split up aggregates so they are easier to deal with. .RegisterPass(CreateScalarReplacementPass(0)) // Remove loads and stores so everything is in intermediate values. // Takes care of copy propagation of non-members. .RegisterPass(CreateLocalSingleBlockLoadStoreElimPass()) .RegisterPass(CreateLocalSingleStoreElimPass()) .RegisterPass(CreateAggressiveDCEPass(preserve_interface)) .RegisterPass(CreateLocalMultiStoreElimPass()) .RegisterPass(CreateAggressiveDCEPass(preserve_interface)) // Propagate constants to get as many constant conditions on branches // as possible. .RegisterPass(CreateCCPPass()) .RegisterPass(CreateLoopUnrollPass(true)) .RegisterPass(CreateDeadBranchElimPass()) // Copy propagate members. Cleans up code sequences generated by // scalar replacement. Also important for removing OpPhi nodes. .RegisterPass(CreateSimplificationPass()) .RegisterPass(CreateAggressiveDCEPass(preserve_interface)) .RegisterPass(CreateCopyPropagateArraysPass()) // May need loop unrolling here see // https://github.com/Microsoft/DirectXShaderCompiler/pull/930 // Get rid of unused code that contain traces of illegal code // or unused references to unbound external objects .RegisterPass(CreateVectorDCEPass()) .RegisterPass(CreateDeadInsertElimPass()) .RegisterPass(CreateReduceLoadSizePass()) .RegisterPass(CreateAggressiveDCEPass(preserve_interface)) .RegisterPass(CreateRemoveUnusedInterfaceVariablesPass()) .RegisterPass(CreateInterpolateFixupPass()) .RegisterPass(CreateInvocationInterlockPlacementPass()) .RegisterPass(CreateOpExtInstWithForwardReferenceFixupPass()); } Optimizer& Optimizer::RegisterLegalizationPasses() { return RegisterLegalizationPasses(false); } Optimizer& Optimizer::RegisterPerformancePasses(bool preserve_interface) { return RegisterPass(CreateWrapOpKillPass()) .RegisterPass(CreateDeadBranchElimPass()) .RegisterPass(CreateMergeReturnPass()) .RegisterPass(CreateInlineExhaustivePass()) .RegisterPass(CreateEliminateDeadFunctionsPass()) .RegisterPass(CreateAggressiveDCEPass(preserve_interface)) .RegisterPass(CreatePrivateToLocalPass()) .RegisterPass(CreateLocalSingleBlockLoadStoreElimPass()) .RegisterPass(CreateLocalSingleStoreElimPass()) .RegisterPass(CreateAggressiveDCEPass(preserve_interface)) .RegisterPass(CreateScalarReplacementPass()) .RegisterPass(CreateLocalAccessChainConvertPass()) .RegisterPass(CreateLocalSingleBlockLoadStoreElimPass()) .RegisterPass(CreateLocalSingleStoreElimPass()) .RegisterPass(CreateAggressiveDCEPass(preserve_interface)) .RegisterPass(CreateLocalMultiStoreElimPass()) .RegisterPass(CreateAggressiveDCEPass(preserve_interface)) .RegisterPass(CreateCCPPass()) .RegisterPass(CreateAggressiveDCEPass(preserve_interface)) .RegisterPass(CreateLoopUnrollPass(true)) .RegisterPass(CreateDeadBranchElimPass()) .RegisterPass(CreateRedundancyEliminationPass()) .RegisterPass(CreateCombineAccessChainsPass()) .RegisterPass(CreateSimplificationPass()) .RegisterPass(CreateScalarReplacementPass()) .RegisterPass(CreateLocalAccessChainConvertPass()) .RegisterPass(CreateLocalSingleBlockLoadStoreElimPass()) .RegisterPass(CreateLocalSingleStoreElimPass()) .RegisterPass(CreateAggressiveDCEPass(preserve_interface)) .RegisterPass(CreateSSARewritePass()) .RegisterPass(CreateAggressiveDCEPass(preserve_interface)) .RegisterPass(CreateVectorDCEPass()) .RegisterPass(CreateDeadInsertElimPass()) .RegisterPass(CreateDeadBranchElimPass()) .RegisterPass(CreateSimplificationPass()) .RegisterPass(CreateIfConversionPass()) .RegisterPass(CreateCopyPropagateArraysPass()) .RegisterPass(CreateReduceLoadSizePass()) .RegisterPass(CreateAggressiveDCEPass(preserve_interface)) .RegisterPass(CreateBlockMergePass()) .RegisterPass(CreateRedundancyEliminationPass()) .RegisterPass(CreateDeadBranchElimPass()) .RegisterPass(CreateBlockMergePass()) .RegisterPass(CreateSimplificationPass()); } Optimizer& Optimizer::RegisterPerformancePasses() { return RegisterPerformancePasses(false); } Optimizer& Optimizer::RegisterSizePasses(bool preserve_interface) { return RegisterPass(CreateWrapOpKillPass()) .RegisterPass(CreateDeadBranchElimPass()) .RegisterPass(CreateMergeReturnPass()) .RegisterPass(CreateInlineExhaustivePass()) .RegisterPass(CreateEliminateDeadFunctionsPass()) .RegisterPass(CreatePrivateToLocalPass()) .RegisterPass(CreateScalarReplacementPass(0)) .RegisterPass(CreateLocalMultiStoreElimPass()) .RegisterPass(CreateCCPPass()) .RegisterPass(CreateLoopUnrollPass(true)) .RegisterPass(CreateDeadBranchElimPass()) .RegisterPass(CreateSimplificationPass()) .RegisterPass(CreateScalarReplacementPass(0)) .RegisterPass(CreateLocalSingleStoreElimPass()) .RegisterPass(CreateIfConversionPass()) .RegisterPass(CreateSimplificationPass()) .RegisterPass(CreateAggressiveDCEPass(preserve_interface)) .RegisterPass(CreateDeadBranchElimPass()) .RegisterPass(CreateBlockMergePass()) .RegisterPass(CreateLocalAccessChainConvertPass()) .RegisterPass(CreateLocalSingleBlockLoadStoreElimPass()) .RegisterPass(CreateAggressiveDCEPass(preserve_interface)) .RegisterPass(CreateCopyPropagateArraysPass()) .RegisterPass(CreateVectorDCEPass()) .RegisterPass(CreateDeadInsertElimPass()) .RegisterPass(CreateEliminateDeadMembersPass()) .RegisterPass(CreateLocalSingleStoreElimPass()) .RegisterPass(CreateBlockMergePass()) .RegisterPass(CreateLocalMultiStoreElimPass()) .RegisterPass(CreateRedundancyEliminationPass()) .RegisterPass(CreateSimplificationPass()) .RegisterPass(CreateAggressiveDCEPass(preserve_interface)) .RegisterPass(CreateCFGCleanupPass()); } Optimizer& Optimizer::RegisterSizePasses() { return RegisterSizePasses(false); } bool Optimizer::RegisterPassesFromFlags(const std::vector& flags) { return RegisterPassesFromFlags(flags, false); } bool Optimizer::RegisterPassesFromFlags(const std::vector& flags, bool preserve_interface) { for (const auto& flag : flags) { if (!RegisterPassFromFlag(flag, preserve_interface)) { return false; } } return true; } bool Optimizer::FlagHasValidForm(const std::string& flag) const { if (flag == "-O" || flag == "-Os") { return true; } else if (flag.size() > 2 && flag.substr(0, 2) == "--") { return true; } Errorf(consumer(), nullptr, {}, "%s is not a valid flag. Flag passes should have the form " "'--pass_name[=pass_args]'. Special flag names also accepted: -O " "and -Os.", flag.c_str()); return false; } bool Optimizer::RegisterPassFromFlag(const std::string& flag) { return RegisterPassFromFlag(flag, false); } bool Optimizer::RegisterPassFromFlag(const std::string& flag, bool preserve_interface) { if (!FlagHasValidForm(flag)) { return false; } // Split flags of the form --pass_name=pass_args. auto p = utils::SplitFlagArgs(flag); std::string pass_name = p.first; std::string pass_args = p.second; // FIXME(dnovillo): This should be re-factored so that pass names can be // automatically checked against Pass::name() and PassToken instances created // via a template function. Additionally, class Pass should have a desc() // method that describes the pass (so it can be used in --help). // // Both Pass::name() and Pass::desc() should be static class members so they // can be invoked without creating a pass instance. if (pass_name == "strip-debug") { RegisterPass(CreateStripDebugInfoPass()); } else if (pass_name == "strip-reflect") { RegisterPass(CreateStripReflectInfoPass()); } else if (pass_name == "strip-nonsemantic") { RegisterPass(CreateStripNonSemanticInfoPass()); } else if (pass_name == "fix-opextinst-opcodes") { RegisterPass(CreateOpExtInstWithForwardReferenceFixupPass()); } else if (pass_name == "set-spec-const-default-value") { if (pass_args.size() > 0) { auto spec_ids_vals = opt::SetSpecConstantDefaultValuePass::ParseDefaultValuesString( pass_args.c_str()); if (!spec_ids_vals) { Errorf(consumer(), nullptr, {}, "Invalid argument for --set-spec-const-default-value: %s", pass_args.c_str()); return false; } RegisterPass( CreateSetSpecConstantDefaultValuePass(std::move(*spec_ids_vals))); } else { Errorf(consumer(), nullptr, {}, "Invalid spec constant value string '%s'. Expected a string of " ": pairs.", pass_args.c_str()); return false; } } else if (pass_name == "if-conversion") { RegisterPass(CreateIfConversionPass()); } else if (pass_name == "freeze-spec-const") { RegisterPass(CreateFreezeSpecConstantValuePass()); } else if (pass_name == "inline-entry-points-exhaustive") { RegisterPass(CreateInlineExhaustivePass()); } else if (pass_name == "inline-entry-points-opaque") { RegisterPass(CreateInlineOpaquePass()); } else if (pass_name == "combine-access-chains") { RegisterPass(CreateCombineAccessChainsPass()); } else if (pass_name == "convert-local-access-chains") { RegisterPass(CreateLocalAccessChainConvertPass()); } else if (pass_name == "replace-desc-array-access-using-var-index") { RegisterPass(CreateReplaceDescArrayAccessUsingVarIndexPass()); } else if (pass_name == "spread-volatile-semantics") { RegisterPass(CreateSpreadVolatileSemanticsPass()); } else if (pass_name == "descriptor-scalar-replacement") { RegisterPass(CreateDescriptorScalarReplacementPass()); } else if (pass_name == "descriptor-composite-scalar-replacement") { RegisterPass(CreateDescriptorCompositeScalarReplacementPass()); } else if (pass_name == "descriptor-array-scalar-replacement") { RegisterPass(CreateDescriptorArrayScalarReplacementPass()); } else if (pass_name == "eliminate-dead-code-aggressive") { RegisterPass(CreateAggressiveDCEPass(preserve_interface)); } else if (pass_name == "eliminate-insert-extract") { RegisterPass(CreateInsertExtractElimPass()); } else if (pass_name == "eliminate-local-single-block") { RegisterPass(CreateLocalSingleBlockLoadStoreElimPass()); } else if (pass_name == "eliminate-local-single-store") { RegisterPass(CreateLocalSingleStoreElimPass()); } else if (pass_name == "merge-blocks") { RegisterPass(CreateBlockMergePass()); } else if (pass_name == "merge-return") { RegisterPass(CreateMergeReturnPass()); } else if (pass_name == "eliminate-dead-branches") { RegisterPass(CreateDeadBranchElimPass()); } else if (pass_name == "eliminate-dead-functions") { RegisterPass(CreateEliminateDeadFunctionsPass()); } else if (pass_name == "eliminate-local-multi-store") { RegisterPass(CreateLocalMultiStoreElimPass()); } else if (pass_name == "eliminate-dead-const") { RegisterPass(CreateEliminateDeadConstantPass()); } else if (pass_name == "eliminate-dead-inserts") { RegisterPass(CreateDeadInsertElimPass()); } else if (pass_name == "eliminate-dead-variables") { RegisterPass(CreateDeadVariableEliminationPass()); } else if (pass_name == "eliminate-dead-members") { RegisterPass(CreateEliminateDeadMembersPass()); } else if (pass_name == "fold-spec-const-op-composite") { RegisterPass(CreateFoldSpecConstantOpAndCompositePass()); } else if (pass_name == "loop-unswitch") { RegisterPass(CreateLoopUnswitchPass()); } else if (pass_name == "scalar-replacement") { if (pass_args.size() == 0) { RegisterPass(CreateScalarReplacementPass()); } else { int limit = -1; if (pass_args.find_first_not_of("0123456789") == std::string::npos) { limit = atoi(pass_args.c_str()); } if (limit >= 0) { RegisterPass(CreateScalarReplacementPass(limit)); } else { Error(consumer(), nullptr, {}, "--scalar-replacement must have no arguments or a non-negative " "integer argument"); return false; } } } else if (pass_name == "strength-reduction") { RegisterPass(CreateStrengthReductionPass()); } else if (pass_name == "unify-const") { RegisterPass(CreateUnifyConstantPass()); } else if (pass_name == "flatten-decorations") { RegisterPass(CreateFlattenDecorationPass()); } else if (pass_name == "compact-ids") { RegisterPass(CreateCompactIdsPass()); } else if (pass_name == "cfg-cleanup") { RegisterPass(CreateCFGCleanupPass()); } else if (pass_name == "local-redundancy-elimination") { RegisterPass(CreateLocalRedundancyEliminationPass()); } else if (pass_name == "loop-invariant-code-motion") { RegisterPass(CreateLoopInvariantCodeMotionPass()); } else if (pass_name == "reduce-load-size") { if (pass_args.size() == 0) { RegisterPass(CreateReduceLoadSizePass()); } else { double load_replacement_threshold = 0.9; if (pass_args.find_first_not_of(".0123456789") == std::string::npos) { load_replacement_threshold = atof(pass_args.c_str()); } if (load_replacement_threshold >= 0) { RegisterPass(CreateReduceLoadSizePass(load_replacement_threshold)); } else { Error(consumer(), nullptr, {}, "--reduce-load-size must have no arguments or a non-negative " "double argument"); return false; } } } else if (pass_name == "redundancy-elimination") { RegisterPass(CreateRedundancyEliminationPass()); } else if (pass_name == "private-to-local") { RegisterPass(CreatePrivateToLocalPass()); } else if (pass_name == "remove-duplicates") { RegisterPass(CreateRemoveDuplicatesPass()); } else if (pass_name == "workaround-1209") { RegisterPass(CreateWorkaround1209Pass()); } else if (pass_name == "replace-invalid-opcode") { RegisterPass(CreateReplaceInvalidOpcodePass()); } else if (pass_name == "convert-relaxed-to-half") { RegisterPass(CreateConvertRelaxedToHalfPass()); } else if (pass_name == "relax-float-ops") { RegisterPass(CreateRelaxFloatOpsPass()); } else if (pass_name == "simplify-instructions") { RegisterPass(CreateSimplificationPass()); } else if (pass_name == "ssa-rewrite") { RegisterPass(CreateSSARewritePass()); } else if (pass_name == "copy-propagate-arrays") { RegisterPass(CreateCopyPropagateArraysPass()); } else if (pass_name == "loop-fission") { int register_threshold_to_split = (pass_args.size() > 0) ? atoi(pass_args.c_str()) : -1; if (register_threshold_to_split > 0) { RegisterPass(CreateLoopFissionPass( static_cast(register_threshold_to_split))); } else { Error(consumer(), nullptr, {}, "--loop-fission must have a positive integer argument"); return false; } } else if (pass_name == "loop-fusion") { int max_registers_per_loop = (pass_args.size() > 0) ? atoi(pass_args.c_str()) : -1; if (max_registers_per_loop > 0) { RegisterPass( CreateLoopFusionPass(static_cast(max_registers_per_loop))); } else { Error(consumer(), nullptr, {}, "--loop-fusion must have a positive integer argument"); return false; } } else if (pass_name == "loop-unroll") { RegisterPass(CreateLoopUnrollPass(true)); } else if (pass_name == "upgrade-memory-model") { RegisterPass(CreateUpgradeMemoryModelPass()); } else if (pass_name == "vector-dce") { RegisterPass(CreateVectorDCEPass()); } else if (pass_name == "loop-unroll-partial") { int factor = (pass_args.size() > 0) ? atoi(pass_args.c_str()) : 0; if (factor > 0) { RegisterPass(CreateLoopUnrollPass(false, factor)); } else { Error(consumer(), nullptr, {}, "--loop-unroll-partial must have a positive integer argument"); return false; } } else if (pass_name == "loop-peeling") { RegisterPass(CreateLoopPeelingPass()); } else if (pass_name == "loop-peeling-threshold") { int factor = (pass_args.size() > 0) ? atoi(pass_args.c_str()) : 0; if (factor > 0) { opt::LoopPeelingPass::SetLoopPeelingThreshold(factor); } else { Error(consumer(), nullptr, {}, "--loop-peeling-threshold must have a positive integer argument"); return false; } } else if (pass_name == "ccp") { RegisterPass(CreateCCPPass()); } else if (pass_name == "code-sink") { RegisterPass(CreateCodeSinkingPass()); } else if (pass_name == "fix-storage-class") { RegisterPass(CreateFixStorageClassPass()); } else if (pass_name == "O") { RegisterPerformancePasses(preserve_interface); } else if (pass_name == "Os") { RegisterSizePasses(preserve_interface); } else if (pass_name == "legalize-hlsl") { RegisterLegalizationPasses(preserve_interface); } else if (pass_name == "remove-unused-interface-variables") { RegisterPass(CreateRemoveUnusedInterfaceVariablesPass()); } else if (pass_name == "graphics-robust-access") { RegisterPass(CreateGraphicsRobustAccessPass()); } else if (pass_name == "wrap-opkill") { RegisterPass(CreateWrapOpKillPass()); } else if (pass_name == "amd-ext-to-khr") { RegisterPass(CreateAmdExtToKhrPass()); } else if (pass_name == "interpolate-fixup") { RegisterPass(CreateInterpolateFixupPass()); } else if (pass_name == "remove-dont-inline") { RegisterPass(CreateRemoveDontInlinePass()); } else if (pass_name == "eliminate-dead-input-components") { RegisterPass(CreateEliminateDeadInputComponentsSafePass()); } else if (pass_name == "fix-func-call-param") { RegisterPass(CreateFixFuncCallArgumentsPass()); } else if (pass_name == "convert-to-sampled-image") { if (pass_args.size() > 0) { auto descriptor_set_binding_pairs = opt::ConvertToSampledImagePass::ParseDescriptorSetBindingPairsString( pass_args.c_str()); if (!descriptor_set_binding_pairs) { Errorf(consumer(), nullptr, {}, "Invalid argument for --convert-to-sampled-image: %s", pass_args.c_str()); return false; } RegisterPass(CreateConvertToSampledImagePass( std::move(*descriptor_set_binding_pairs))); } else { Errorf(consumer(), nullptr, {}, "Invalid pairs of descriptor set and binding '%s'. Expected a " "string of : pairs.", pass_args.c_str()); return false; } } else if (pass_name == "struct-packing") { if (pass_args.size() == 0) { Error(consumer(), nullptr, {}, "--struct-packing requires a name:rule argument."); return false; } auto separator_pos = pass_args.find(':'); if (separator_pos == std::string::npos || separator_pos == 0 || separator_pos + 1 == pass_args.size()) { Errorf(consumer(), nullptr, {}, "Invalid argument for --struct-packing: %s", pass_args.c_str()); return false; } const std::string struct_name = pass_args.substr(0, separator_pos); const std::string rule_name = pass_args.substr(separator_pos + 1); RegisterPass( CreateStructPackingPass(struct_name.c_str(), rule_name.c_str())); } else if (pass_name == "switch-descriptorset") { if (pass_args.size() == 0) { Error(consumer(), nullptr, {}, "--switch-descriptorset requires a from:to argument."); return false; } uint32_t from_set = 0, to_set = 0; const char* start = pass_args.data(); const char* end = pass_args.data() + pass_args.size(); auto result = std::from_chars(start, end, from_set); if (result.ec != std::errc()) { Errorf(consumer(), nullptr, {}, "Invalid argument for --switch-descriptorset: %s", pass_args.c_str()); return false; } start = result.ptr; if (start[0] != ':') { Errorf(consumer(), nullptr, {}, "Invalid argument for --switch-descriptorset: %s", pass_args.c_str()); return false; } start++; result = std::from_chars(start, end, to_set); if (result.ec != std::errc() || result.ptr != end) { Errorf(consumer(), nullptr, {}, "Invalid argument for --switch-descriptorset: %s", pass_args.c_str()); return false; } RegisterPass(CreateSwitchDescriptorSetPass(from_set, to_set)); } else if (pass_name == "modify-maximal-reconvergence") { if (pass_args.size() == 0) { Error(consumer(), nullptr, {}, "--modify-maximal-reconvergence requires an argument"); return false; } if (pass_args == "add") { RegisterPass(CreateModifyMaximalReconvergencePass(true)); } else if (pass_args == "remove") { RegisterPass(CreateModifyMaximalReconvergencePass(false)); } else { Errorf(consumer(), nullptr, {}, "Invalid argument for --modify-maximal-reconvergence: %s (must be " "'add' or 'remove')", pass_args.c_str()); return false; } } else if (pass_name == "trim-capabilities") { RegisterPass(CreateTrimCapabilitiesPass()); } else { Errorf(consumer(), nullptr, {}, "Unknown flag '--%s'. Use --help for a list of valid flags", pass_name.c_str()); return false; } return true; } void Optimizer::SetTargetEnv(const spv_target_env env) { impl_->target_env = env; } bool Optimizer::Run(const uint32_t* original_binary, const size_t original_binary_size, std::vector* optimized_binary) const { return Run(original_binary, original_binary_size, optimized_binary, OptimizerOptions()); } bool Optimizer::Run(const uint32_t* original_binary, const size_t original_binary_size, std::vector* optimized_binary, const ValidatorOptions& validator_options, bool skip_validation) const { OptimizerOptions opt_options; opt_options.set_run_validator(!skip_validation); opt_options.set_validator_options(validator_options); return Run(original_binary, original_binary_size, optimized_binary, opt_options); } bool Optimizer::Run(const uint32_t* original_binary, const size_t original_binary_size, std::vector* optimized_binary, const spv_optimizer_options opt_options) const { spvtools::SpirvTools tools(impl_->target_env); tools.SetMessageConsumer(impl_->pass_manager.consumer()); if (opt_options->run_validator_ && !tools.Validate(original_binary, original_binary_size, &opt_options->val_options_)) { return false; } std::unique_ptr context = BuildModule( impl_->target_env, consumer(), original_binary, original_binary_size); if (context == nullptr) return false; context->set_max_id_bound(opt_options->max_id_bound_); context->set_preserve_bindings(opt_options->preserve_bindings_); context->set_preserve_spec_constants(opt_options->preserve_spec_constants_); impl_->pass_manager.SetValidatorOptions(&opt_options->val_options_); impl_->pass_manager.SetTargetEnv(impl_->target_env); auto status = impl_->pass_manager.Run(context.get()); if (status == opt::Pass::Status::Failure) { return false; } #ifndef NDEBUG // We do not keep the result id of DebugScope in struct DebugScope. // Instead, we assign random ids for them, which results in integrity // check failures. In addition, propagating the OpLine/OpNoLine to preserve // the debug information through transformations results in integrity // check failures. We want to skip the integrity check when the module // contains DebugScope or OpLine/OpNoLine instructions. if (status == opt::Pass::Status::SuccessWithoutChange && !context->module()->ContainsDebugInfo()) { std::vector optimized_binary_with_nop; context->module()->ToBinary(&optimized_binary_with_nop, /* skip_nop = */ false); assert(optimized_binary_with_nop.size() == original_binary_size && "Binary size unexpectedly changed despite the optimizer saying " "there was no change"); // Compare the magic number to make sure the binaries were encoded in the // endianness. If not, the contents of the binaries will be different, so // do not check the contents. if (optimized_binary_with_nop[0] == original_binary[0]) { assert(memcmp(optimized_binary_with_nop.data(), original_binary, original_binary_size) == 0 && "Binary content unexpectedly changed despite the optimizer saying " "there was no change"); } } #endif // !NDEBUG // Note that |original_binary| and |optimized_binary| may share the same // buffer and the below will invalidate |original_binary|. optimized_binary->clear(); context->module()->ToBinary(optimized_binary, /* skip_nop = */ true); return true; } Optimizer& Optimizer::SetPrintAll(std::ostream* out) { impl_->pass_manager.SetPrintAll(out); return *this; } Optimizer& Optimizer::SetTimeReport(std::ostream* out) { impl_->pass_manager.SetTimeReport(out); return *this; } Optimizer& Optimizer::SetValidateAfterAll(bool validate) { impl_->pass_manager.SetValidateAfterAll(validate); return *this; } Optimizer::PassToken CreateNullPass() { return MakeUnique(MakeUnique()); } Optimizer::PassToken CreateStripDebugInfoPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateStripReflectInfoPass() { return CreateStripNonSemanticInfoPass(); } Optimizer::PassToken CreateStripNonSemanticInfoPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateEliminateDeadFunctionsPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateEliminateDeadMembersPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateSetSpecConstantDefaultValuePass( const std::unordered_map& id_value_map) { return MakeUnique( MakeUnique(id_value_map)); } Optimizer::PassToken CreateSetSpecConstantDefaultValuePass( const std::unordered_map>& id_value_map) { return MakeUnique( MakeUnique(id_value_map)); } Optimizer::PassToken CreateFlattenDecorationPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateFreezeSpecConstantValuePass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateFoldSpecConstantOpAndCompositePass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateUnifyConstantPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateEliminateDeadConstantPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateDeadVariableEliminationPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateStrengthReductionPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateBlockMergePass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateInlineExhaustivePass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateInlineOpaquePass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateLocalAccessChainConvertPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateLocalSingleBlockLoadStoreElimPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateLocalSingleStoreElimPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateInsertExtractElimPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateDeadInsertElimPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateDeadBranchElimPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateLocalMultiStoreElimPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateAggressiveDCEPass() { return MakeUnique( MakeUnique(false, false)); } Optimizer::PassToken CreateAggressiveDCEPass(bool preserve_interface) { return MakeUnique( MakeUnique(preserve_interface, false)); } Optimizer::PassToken CreateAggressiveDCEPass(bool preserve_interface, bool remove_outputs) { return MakeUnique( MakeUnique(preserve_interface, remove_outputs)); } Optimizer::PassToken CreateRemoveUnusedInterfaceVariablesPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreatePropagateLineInfoPass() { return MakeUnique(MakeUnique()); } Optimizer::PassToken CreateRedundantLineInfoElimPass() { return MakeUnique(MakeUnique()); } Optimizer::PassToken CreateCompactIdsPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateMergeReturnPass() { return MakeUnique( MakeUnique()); } std::vector Optimizer::GetPassNames() const { std::vector v; for (uint32_t i = 0; i < impl_->pass_manager.NumPasses(); i++) { v.push_back(impl_->pass_manager.GetPass(i)->name()); } return v; } Optimizer::PassToken CreateCFGCleanupPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateLocalRedundancyEliminationPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateLoopFissionPass(size_t threshold) { return MakeUnique( MakeUnique(threshold)); } Optimizer::PassToken CreateLoopFusionPass(size_t max_registers_per_loop) { return MakeUnique( MakeUnique(max_registers_per_loop)); } Optimizer::PassToken CreateLoopInvariantCodeMotionPass() { return MakeUnique(MakeUnique()); } Optimizer::PassToken CreateLoopPeelingPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateLoopUnswitchPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateRedundancyEliminationPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateRemoveDuplicatesPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateScalarReplacementPass(uint32_t size_limit) { return MakeUnique( MakeUnique(size_limit)); } Optimizer::PassToken CreatePrivateToLocalPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateCCPPass() { return MakeUnique(MakeUnique()); } Optimizer::PassToken CreateWorkaround1209Pass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateIfConversionPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateReplaceInvalidOpcodePass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateSimplificationPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateLoopUnrollPass(bool fully_unroll, int factor) { return MakeUnique( MakeUnique(fully_unroll, factor)); } Optimizer::PassToken CreateSSARewritePass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateCopyPropagateArraysPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateVectorDCEPass() { return MakeUnique(MakeUnique()); } Optimizer::PassToken CreateReduceLoadSizePass( double load_replacement_threshold) { return MakeUnique( MakeUnique(load_replacement_threshold)); } Optimizer::PassToken CreateCombineAccessChainsPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateUpgradeMemoryModelPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateConvertRelaxedToHalfPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateRelaxFloatOpsPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateCodeSinkingPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateFixStorageClassPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateGraphicsRobustAccessPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateReplaceDescArrayAccessUsingVarIndexPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateSpreadVolatileSemanticsPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateDescriptorScalarReplacementPass() { return MakeUnique( MakeUnique( /* flatten_composites= */ true, /* flatten_arrays= */ true)); } Optimizer::PassToken CreateDescriptorCompositeScalarReplacementPass() { return MakeUnique( MakeUnique( /* flatten_composites= */ true, /* flatten_arrays= */ false)); } Optimizer::PassToken CreateDescriptorArrayScalarReplacementPass() { return MakeUnique( MakeUnique( /* flatten_composites= */ false, /* flatten_arrays= */ true)); } Optimizer::PassToken CreateWrapOpKillPass() { return MakeUnique(MakeUnique()); } Optimizer::PassToken CreateAmdExtToKhrPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateInterpolateFixupPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateEliminateDeadInputComponentsPass() { return MakeUnique( MakeUnique(spv::StorageClass::Input, /* safe_mode */ false)); } Optimizer::PassToken CreateEliminateDeadOutputComponentsPass() { return MakeUnique( MakeUnique(spv::StorageClass::Output, /* safe_mode */ false)); } Optimizer::PassToken CreateEliminateDeadInputComponentsSafePass() { return MakeUnique( MakeUnique(spv::StorageClass::Input, /* safe_mode */ true)); } Optimizer::PassToken CreateAnalyzeLiveInputPass( std::unordered_set* live_locs, std::unordered_set* live_builtins) { return MakeUnique( MakeUnique(live_locs, live_builtins)); } Optimizer::PassToken CreateEliminateDeadOutputStoresPass( std::unordered_set* live_locs, std::unordered_set* live_builtins) { return MakeUnique( MakeUnique(live_locs, live_builtins)); } Optimizer::PassToken CreateConvertToSampledImagePass( const std::vector& descriptor_set_binding_pairs) { return MakeUnique( MakeUnique(descriptor_set_binding_pairs)); } Optimizer::PassToken CreateInterfaceVariableScalarReplacementPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateRemoveDontInlinePass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateFixFuncCallArgumentsPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateTrimCapabilitiesPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateStructPackingPass(const char* structToPack, const char* packingRule) { return MakeUnique( MakeUnique( structToPack, opt::StructPackingPass::ParsePackingRuleFromString(packingRule))); } Optimizer::PassToken CreateSwitchDescriptorSetPass(uint32_t from, uint32_t to) { return MakeUnique( MakeUnique(from, to)); } Optimizer::PassToken CreateInvocationInterlockPlacementPass() { return MakeUnique( MakeUnique()); } Optimizer::PassToken CreateModifyMaximalReconvergencePass(bool add) { return MakeUnique( MakeUnique(add)); } Optimizer::PassToken CreateOpExtInstWithForwardReferenceFixupPass() { return MakeUnique( MakeUnique()); } } // namespace spvtools extern "C" { SPIRV_TOOLS_EXPORT spv_optimizer_t* spvOptimizerCreate(spv_target_env env) { return reinterpret_cast(new spvtools::Optimizer(env)); } SPIRV_TOOLS_EXPORT void spvOptimizerDestroy(spv_optimizer_t* optimizer) { delete reinterpret_cast(optimizer); } SPIRV_TOOLS_EXPORT void spvOptimizerSetMessageConsumer( spv_optimizer_t* optimizer, spv_message_consumer consumer) { reinterpret_cast(optimizer)-> SetMessageConsumer( [consumer](spv_message_level_t level, const char* source, const spv_position_t& position, const char* message) { return consumer(level, source, &position, message); }); } SPIRV_TOOLS_EXPORT void spvOptimizerRegisterLegalizationPasses( spv_optimizer_t* optimizer) { reinterpret_cast(optimizer)-> RegisterLegalizationPasses(); } SPIRV_TOOLS_EXPORT void spvOptimizerRegisterPerformancePasses( spv_optimizer_t* optimizer) { reinterpret_cast(optimizer)-> RegisterPerformancePasses(); } SPIRV_TOOLS_EXPORT void spvOptimizerRegisterSizePasses( spv_optimizer_t* optimizer) { reinterpret_cast(optimizer)->RegisterSizePasses(); } SPIRV_TOOLS_EXPORT bool spvOptimizerRegisterPassFromFlag( spv_optimizer_t* optimizer, const char* flag) { return reinterpret_cast(optimizer)-> RegisterPassFromFlag(flag); } SPIRV_TOOLS_EXPORT bool spvOptimizerRegisterPassesFromFlags( spv_optimizer_t* optimizer, const char** flags, const size_t flag_count) { std::vector opt_flags = spvtools::GetVectorOfStrings(flags, flag_count); return reinterpret_cast(optimizer) ->RegisterPassesFromFlags(opt_flags, false); } SPIRV_TOOLS_EXPORT bool spvOptimizerRegisterPassesFromFlagsWhilePreservingTheInterface( spv_optimizer_t* optimizer, const char** flags, const size_t flag_count) { std::vector opt_flags = spvtools::GetVectorOfStrings(flags, flag_count); return reinterpret_cast(optimizer) ->RegisterPassesFromFlags(opt_flags, true); } SPIRV_TOOLS_EXPORT spv_result_t spvOptimizerRun(spv_optimizer_t* optimizer, const uint32_t* binary, const size_t word_count, spv_binary* optimized_binary, const spv_optimizer_options options) { std::vector optimized; if (!reinterpret_cast(optimizer)-> Run(binary, word_count, &optimized, options)) { return SPV_ERROR_INTERNAL; } auto result_binary = new spv_binary_t(); if (!result_binary) { *optimized_binary = nullptr; return SPV_ERROR_OUT_OF_MEMORY; } result_binary->code = new uint32_t[optimized.size()]; if (!result_binary->code) { delete result_binary; *optimized_binary = nullptr; return SPV_ERROR_OUT_OF_MEMORY; } result_binary->wordCount = optimized.size(); memcpy(result_binary->code, optimized.data(), optimized.size() * sizeof(uint32_t)); *optimized_binary = result_binary; return SPV_SUCCESS; } } // extern "C" KhronosGroup-SPIRV-Tools-f289d04/source/opt/pass.cpp000066400000000000000000000132061475742701700223070ustar00rootroot00000000000000// Copyright (c) 2017 The Khronos Group Inc. // Copyright (c) 2017 Valve Corporation // Copyright (c) 2017 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/pass.h" #include "source/opt/ir_builder.h" #include "source/opt/iterator.h" namespace spvtools { namespace opt { namespace { constexpr uint32_t kTypePointerTypeIdInIdx = 1; } // namespace Pass::Pass() : consumer_(nullptr), context_(nullptr), already_run_(false) {} Pass::Status Pass::Run(IRContext* ctx) { if (already_run_) { return Status::Failure; } already_run_ = true; context_ = ctx; Pass::Status status = Process(); context_ = nullptr; if (status == Status::SuccessWithChange) { ctx->InvalidateAnalysesExceptFor(GetPreservedAnalyses()); } if (!(status == Status::Failure || ctx->IsConsistent())) assert(false && "An analysis in the context is out of date."); return status; } uint32_t Pass::GetPointeeTypeId(const Instruction* ptrInst) const { const uint32_t ptrTypeId = ptrInst->type_id(); const Instruction* ptrTypeInst = get_def_use_mgr()->GetDef(ptrTypeId); return ptrTypeInst->GetSingleWordInOperand(kTypePointerTypeIdInIdx); } Instruction* Pass::GetBaseType(uint32_t ty_id) { Instruction* ty_inst = get_def_use_mgr()->GetDef(ty_id); if (ty_inst->opcode() == spv::Op::OpTypeMatrix) { uint32_t vty_id = ty_inst->GetSingleWordInOperand(0); ty_inst = get_def_use_mgr()->GetDef(vty_id); } if (ty_inst->opcode() == spv::Op::OpTypeVector) { uint32_t cty_id = ty_inst->GetSingleWordInOperand(0); ty_inst = get_def_use_mgr()->GetDef(cty_id); } return ty_inst; } bool Pass::IsFloat(uint32_t ty_id, uint32_t width) { Instruction* ty_inst = GetBaseType(ty_id); if (ty_inst->opcode() != spv::Op::OpTypeFloat) return false; return ty_inst->GetSingleWordInOperand(0) == width; } uint32_t Pass::GetNullId(uint32_t type_id) { if (IsFloat(type_id, 16)) context()->AddCapability(spv::Capability::Float16); analysis::TypeManager* type_mgr = context()->get_type_mgr(); analysis::ConstantManager* const_mgr = context()->get_constant_mgr(); const analysis::Type* type = type_mgr->GetType(type_id); const analysis::Constant* null_const = const_mgr->GetConstant(type, {}); Instruction* null_inst = const_mgr->GetDefiningInstruction(null_const, type_id); return null_inst->result_id(); } uint32_t Pass::GenerateCopy(Instruction* object_to_copy, uint32_t new_type_id, Instruction* insertion_position) { analysis::ConstantManager* const_mgr = context()->get_constant_mgr(); uint32_t original_type_id = object_to_copy->type_id(); if (original_type_id == new_type_id) { return object_to_copy->result_id(); } InstructionBuilder ir_builder( context(), insertion_position, IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisDefUse); Instruction* original_type = get_def_use_mgr()->GetDef(original_type_id); Instruction* new_type = get_def_use_mgr()->GetDef(new_type_id); if (new_type->opcode() != original_type->opcode()) { return 0; } switch (original_type->opcode()) { case spv::Op::OpTypeArray: { uint32_t original_element_type_id = original_type->GetSingleWordInOperand(0); uint32_t new_element_type_id = new_type->GetSingleWordInOperand(0); std::vector element_ids; uint32_t length_id = original_type->GetSingleWordInOperand(1); const analysis::Constant* length_const = const_mgr->FindDeclaredConstant(length_id); assert(length_const->AsIntConstant()); uint32_t array_length = length_const->AsIntConstant()->GetU32(); for (uint32_t i = 0; i < array_length; i++) { Instruction* extract = ir_builder.AddCompositeExtract( original_element_type_id, object_to_copy->result_id(), {i}); uint32_t new_id = GenerateCopy(extract, new_element_type_id, insertion_position); if (new_id == 0) { return 0; } element_ids.push_back(new_id); } return ir_builder.AddCompositeConstruct(new_type_id, element_ids) ->result_id(); } case spv::Op::OpTypeStruct: { std::vector element_ids; for (uint32_t i = 0; i < original_type->NumInOperands(); i++) { uint32_t orig_member_type_id = original_type->GetSingleWordInOperand(i); uint32_t new_member_type_id = new_type->GetSingleWordInOperand(i); Instruction* extract = ir_builder.AddCompositeExtract( orig_member_type_id, object_to_copy->result_id(), {i}); uint32_t new_id = GenerateCopy(extract, new_member_type_id, insertion_position); if (new_id == 0) { return 0; } element_ids.push_back(new_id); } return ir_builder.AddCompositeConstruct(new_type_id, element_ids) ->result_id(); } default: // If we do not have an aggregate type, then we have a problem. Either we // found multiple instances of the same type, or we are copying to an // incompatible type. Either way the code is illegal. Leave the code as // is and let the caller deal with it. return 0; } } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/pass.h000066400000000000000000000136711475742701700217620ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_PASS_H_ #define SOURCE_OPT_PASS_H_ #include #include #include #include #include #include "source/opt/basic_block.h" #include "source/opt/def_use_manager.h" #include "source/opt/ir_context.h" #include "source/opt/module.h" #include "spirv-tools/libspirv.hpp" #include "types.h" // Avoid unused variable warning/error on Linux #ifndef NDEBUG #define USE_ASSERT(x) assert(x) #else #define USE_ASSERT(x) ((void)(x)) #endif namespace spvtools { namespace opt { // Abstract class of a pass. All passes should implement this abstract class // and all analysis and transformation is done via the Process() method. class Pass { public: // The status of processing a module using a pass. // // The numbers for the cases are assigned to make sure that Failure & anything // is Failure, SuccessWithChange & any success is SuccessWithChange. enum class Status { Failure = 0x00, SuccessWithChange = 0x10, SuccessWithoutChange = 0x11, }; using ProcessFunction = std::function; // Destructs the pass. virtual ~Pass() = default; // Returns a descriptive name for this pass. // // NOTE: When deriving a new pass class, make sure you make the name // compatible with the corresponding spirv-opt command-line flag. For example, // if you add the flag --my-pass to spirv-opt, make this function return // "my-pass" (no leading hyphens). virtual const char* name() const = 0; // Sets the message consumer to the given |consumer|. |consumer| which will be // invoked every time there is a message to be communicated to the outside. void SetMessageConsumer(MessageConsumer c) { consumer_ = std::move(c); } // Returns the reference to the message consumer for this pass. const MessageConsumer& consumer() const { return consumer_; } // Returns the def-use manager used for this pass. TODO(dnovillo): This should // be handled by the pass manager. analysis::DefUseManager* get_def_use_mgr() const { return context()->get_def_use_mgr(); } analysis::DecorationManager* get_decoration_mgr() const { return context()->get_decoration_mgr(); } FeatureManager* get_feature_mgr() const { return context()->get_feature_mgr(); } // Returns a pointer to the current module for this pass. Module* get_module() const { return context_->module(); } // Sets the pointer to the current context for this pass. void SetContextForTesting(IRContext* ctx) { context_ = ctx; } // Returns a pointer to the current context for this pass. IRContext* context() const { return context_; } // Returns a pointer to the CFG for current module. CFG* cfg() const { return context()->cfg(); } // Run the pass on the given |module|. Returns Status::Failure if errors occur // when processing. Returns the corresponding Status::Success if processing is // successful to indicate whether changes are made to the module. If there // were any changes it will also invalidate the analyses in the IRContext // that are not preserved. // // It is an error if |Run| is called twice with the same instance of the pass. // If this happens the return value will be |Failure|. Status Run(IRContext* ctx); // Returns the set of analyses that the pass is guaranteed to preserve. virtual IRContext::Analysis GetPreservedAnalyses() { return IRContext::kAnalysisNone; } // Return type id for |ptrInst|'s pointee uint32_t GetPointeeTypeId(const Instruction* ptrInst) const; // Return base type of |ty_id| type Instruction* GetBaseType(uint32_t ty_id); // Return true if |inst| returns scalar, vector or matrix type with base // float and |width| bool IsFloat(uint32_t ty_id, uint32_t width); // Return the id of OpConstantNull of type |type_id|. Create if necessary. uint32_t GetNullId(uint32_t type_id); protected: // Constructs a new pass. // // The constructed instance will have an empty message consumer, which just // ignores all messages from the library. Use SetMessageConsumer() to supply // one if messages are of concern. Pass(); // Processes the given |module|. Returns Status::Failure if errors occur when // processing. Returns the corresponding Status::Success if processing is // successful to indicate whether changes are made to the module. virtual Status Process() = 0; // Return the next available SSA id and increment it. // TODO(1841): Handle id overflow. uint32_t TakeNextId() { return context_->TakeNextId(); } // Returns the id whose value is the same as |object_to_copy| except its type // is |new_type_id|. Any instructions needed to generate this value will be // inserted before |insertion_position|. Returns 0 if a copy could not be // done. uint32_t GenerateCopy(Instruction* object_to_copy, uint32_t new_type_id, Instruction* insertion_position); private: MessageConsumer consumer_; // Message consumer. // The context that this pass belongs to. IRContext* context_; // An instance of a pass can only be run once because it is too hard to // enforce proper resetting of internal state for each instance. This member // is used to check that we do not run the same instance twice. bool already_run_; }; inline Pass::Status CombineStatus(Pass::Status a, Pass::Status b) { return std::min(a, b); } } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/pass_manager.cpp000066400000000000000000000064131475742701700240030ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/pass_manager.h" #include #include #include #include "source/opt/ir_context.h" #include "source/util/timer.h" #include "spirv-tools/libspirv.hpp" namespace spvtools { namespace opt { Pass::Status PassManager::Run(IRContext* context) { auto status = Pass::Status::SuccessWithoutChange; // If print_all_stream_ is not null, prints the disassembly of the module // to that stream, with the given preamble and optionally the pass name. auto print_disassembly = [&context, this](const char* preamble, Pass* pass) { if (print_all_stream_) { std::vector binary; context->module()->ToBinary(&binary, false); SpirvTools t(target_env_); t.SetMessageConsumer(consumer()); std::string disassembly; std::string pass_name = (pass ? pass->name() : ""); if (!t.Disassemble(binary, &disassembly)) { std::string msg = "Disassembly failed before pass "; msg += pass_name + "\n"; spv_position_t null_pos{0, 0, 0}; consumer()(SPV_MSG_WARNING, "", null_pos, msg.c_str()); return; } *print_all_stream_ << preamble << pass_name << "\n" << disassembly << std::endl; } }; SPIRV_TIMER_DESCRIPTION(time_report_stream_, /* measure_mem_usage = */ true); for (auto& pass : passes_) { print_disassembly("; IR before pass ", pass.get()); SPIRV_TIMER_SCOPED(time_report_stream_, (pass ? pass->name() : ""), true); const auto one_status = pass->Run(context); if (one_status == Pass::Status::Failure) return one_status; if (one_status == Pass::Status::SuccessWithChange) status = one_status; if (validate_after_all_) { spvtools::SpirvTools tools(target_env_); tools.SetMessageConsumer(consumer()); std::vector binary; context->module()->ToBinary(&binary, true); if (!tools.Validate(binary.data(), binary.size(), val_options_)) { std::string msg = "Validation failed after pass "; msg += pass->name(); spv_position_t null_pos{0, 0, 0}; consumer()(SPV_MSG_INTERNAL_ERROR, "", null_pos, msg.c_str()); return Pass::Status::Failure; } } // Reset the pass to free any memory used by the pass. pass.reset(nullptr); } print_disassembly("; IR after last pass", nullptr); // Set the Id bound in the header in case a pass forgot to do so. // // TODO(dnovillo): This should be unnecessary and automatically maintained by // the IRContext. if (status == Pass::Status::SuccessWithChange) { context->module()->SetIdBound(context->module()->ComputeIdBound()); } passes_.clear(); return status; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/pass_manager.h000066400000000000000000000123301475742701700234430ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_PASS_MANAGER_H_ #define SOURCE_OPT_PASS_MANAGER_H_ #include #include #include #include #include "source/opt/log.h" #include "source/opt/module.h" #include "source/opt/pass.h" #include "source/opt/ir_context.h" #include "spirv-tools/libspirv.hpp" namespace spvtools { namespace opt { // The pass manager, responsible for tracking and running passes. // Clients should first call AddPass() to add passes and then call Run() // to run on a module. Passes are executed in the exact order of addition. class PassManager { public: // Constructs a pass manager. // // The constructed instance will have an empty message consumer, which just // ignores all messages from the library. Use SetMessageConsumer() to supply // one if messages are of concern. PassManager() : consumer_(nullptr), print_all_stream_(nullptr), time_report_stream_(nullptr), target_env_(SPV_ENV_UNIVERSAL_1_2), val_options_(nullptr), validate_after_all_(false) {} // Sets the message consumer to the given |consumer|. void SetMessageConsumer(MessageConsumer c) { consumer_ = std::move(c); } // Adds an externally constructed pass. void AddPass(std::unique_ptr pass); // Uses the argument |args| to construct a pass instance of type |T|, and adds // the pass instance to this pass manager. The pass added will use this pass // manager's message consumer. template void AddPass(Args&&... args); // Returns the number of passes added. uint32_t NumPasses() const; // Returns a pointer to the |index|th pass added. inline Pass* GetPass(uint32_t index) const; // Returns the message consumer. inline const MessageConsumer& consumer() const; // Runs all passes on the given |module|. Returns Status::Failure if errors // occur when processing using one of the registered passes. All passes // registered after the error-reporting pass will be skipped. Returns the // corresponding Status::Success if processing is successful to indicate // whether changes are made to the module. // // After running all the passes, they are removed from the list. Pass::Status Run(IRContext* context); // Sets the option to print the disassembly before each pass and after the // last pass. Output is written to |out| if that is not null. No output // is generated if |out| is null. PassManager& SetPrintAll(std::ostream* out) { print_all_stream_ = out; return *this; } // Sets the option to print the resource utilization of each pass. Output is // written to |out| if that is not null. No output is generated if |out| is // null. PassManager& SetTimeReport(std::ostream* out) { time_report_stream_ = out; return *this; } // Sets the target environment for validation. PassManager& SetTargetEnv(spv_target_env env) { target_env_ = env; return *this; } // Sets the validation options. PassManager& SetValidatorOptions(spv_validator_options options) { val_options_ = options; return *this; } // Sets the option to validate after each pass. PassManager& SetValidateAfterAll(bool validate) { validate_after_all_ = validate; return *this; } private: // Consumer for messages. MessageConsumer consumer_; // A vector of passes. Order matters. std::vector> passes_; // The output stream to write disassembly to before each pass, and after // the last pass. If this is null, no output is generated. std::ostream* print_all_stream_; // The output stream to write the resource utilization of each pass. If this // is null, no output is generated. std::ostream* time_report_stream_; // The target environment. spv_target_env target_env_; // The validator options (used when validating each pass). spv_validator_options val_options_; // Controls whether validation occurs after every pass. bool validate_after_all_; }; inline void PassManager::AddPass(std::unique_ptr pass) { passes_.push_back(std::move(pass)); } template inline void PassManager::AddPass(Args&&... args) { passes_.emplace_back(new T(std::forward(args)...)); passes_.back()->SetMessageConsumer(consumer_); } inline uint32_t PassManager::NumPasses() const { return static_cast(passes_.size()); } inline Pass* PassManager::GetPass(uint32_t index) const { SPIRV_ASSERT(consumer_, index < passes_.size(), "index out of bound"); return passes_[index].get(); } inline const MessageConsumer& PassManager::consumer() const { return consumer_; } } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_PASS_MANAGER_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/passes.h000066400000000000000000000100301475742701700222740ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_PASSES_H_ #define SOURCE_OPT_PASSES_H_ // A single header to include all passes. #include "source/opt/aggressive_dead_code_elim_pass.h" #include "source/opt/amd_ext_to_khr.h" #include "source/opt/analyze_live_input_pass.h" #include "source/opt/block_merge_pass.h" #include "source/opt/ccp_pass.h" #include "source/opt/cfg_cleanup_pass.h" #include "source/opt/code_sink.h" #include "source/opt/combine_access_chains.h" #include "source/opt/compact_ids_pass.h" #include "source/opt/convert_to_half_pass.h" #include "source/opt/convert_to_sampled_image_pass.h" #include "source/opt/copy_prop_arrays.h" #include "source/opt/dead_branch_elim_pass.h" #include "source/opt/dead_insert_elim_pass.h" #include "source/opt/dead_variable_elimination.h" #include "source/opt/desc_sroa.h" #include "source/opt/eliminate_dead_constant_pass.h" #include "source/opt/eliminate_dead_functions_pass.h" #include "source/opt/eliminate_dead_io_components_pass.h" #include "source/opt/eliminate_dead_members_pass.h" #include "source/opt/eliminate_dead_output_stores_pass.h" #include "source/opt/empty_pass.h" #include "source/opt/fix_func_call_arguments.h" #include "source/opt/fix_storage_class.h" #include "source/opt/flatten_decoration_pass.h" #include "source/opt/fold_spec_constant_op_and_composite_pass.h" #include "source/opt/freeze_spec_constant_value_pass.h" #include "source/opt/graphics_robust_access_pass.h" #include "source/opt/if_conversion.h" #include "source/opt/inline_exhaustive_pass.h" #include "source/opt/inline_opaque_pass.h" #include "source/opt/interface_var_sroa.h" #include "source/opt/interp_fixup_pass.h" #include "source/opt/invocation_interlock_placement_pass.h" #include "source/opt/licm_pass.h" #include "source/opt/local_access_chain_convert_pass.h" #include "source/opt/local_redundancy_elimination.h" #include "source/opt/local_single_block_elim_pass.h" #include "source/opt/local_single_store_elim_pass.h" #include "source/opt/loop_fission.h" #include "source/opt/loop_fusion_pass.h" #include "source/opt/loop_peeling.h" #include "source/opt/loop_unroller.h" #include "source/opt/loop_unswitch_pass.h" #include "source/opt/merge_return_pass.h" #include "source/opt/modify_maximal_reconvergence.h" #include "source/opt/null_pass.h" #include "source/opt/opextinst_forward_ref_fixup_pass.h" #include "source/opt/private_to_local_pass.h" #include "source/opt/reduce_load_size.h" #include "source/opt/redundancy_elimination.h" #include "source/opt/relax_float_ops_pass.h" #include "source/opt/remove_dontinline_pass.h" #include "source/opt/remove_duplicates_pass.h" #include "source/opt/remove_unused_interface_variables_pass.h" #include "source/opt/replace_desc_array_access_using_var_index.h" #include "source/opt/replace_invalid_opc.h" #include "source/opt/scalar_replacement_pass.h" #include "source/opt/set_spec_constant_default_value_pass.h" #include "source/opt/simplification_pass.h" #include "source/opt/spread_volatile_semantics.h" #include "source/opt/ssa_rewrite_pass.h" #include "source/opt/strength_reduction_pass.h" #include "source/opt/strip_debug_info_pass.h" #include "source/opt/strip_nonsemantic_info_pass.h" #include "source/opt/struct_packing_pass.h" #include "source/opt/switch_descriptorset_pass.h" #include "source/opt/trim_capabilities_pass.h" #include "source/opt/unify_const_pass.h" #include "source/opt/upgrade_memory_model.h" #include "source/opt/vector_dce.h" #include "source/opt/workaround1209.h" #include "source/opt/wrap_opkill.h" #endif // SOURCE_OPT_PASSES_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/pch_source_opt.cpp000066400000000000000000000011701475742701700243520ustar00rootroot00000000000000// Copyright (c) 2018 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "pch_source_opt.h" KhronosGroup-SPIRV-Tools-f289d04/source/opt/pch_source_opt.h000066400000000000000000000021161475742701700240200ustar00rootroot00000000000000// Copyright (c) 2018 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include #include #include #include #include #include #include "source/opt/basic_block.h" #include "source/opt/decoration_manager.h" #include "source/opt/def_use_manager.h" #include "source/opt/ir_context.h" #include "source/opt/mem_pass.h" #include "source/opt/module.h" #include "source/opt/pass.h" #include "source/util/hex_float.h" #include "source/util/make_unique.h" KhronosGroup-SPIRV-Tools-f289d04/source/opt/private_to_local_pass.cpp000066400000000000000000000176541475742701700257300ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/private_to_local_pass.h" #include #include #include #include "source/opt/ir_context.h" #include "source/spirv_constant.h" namespace spvtools { namespace opt { namespace { constexpr uint32_t kVariableStorageClassInIdx = 0; constexpr uint32_t kSpvTypePointerTypeIdInIdx = 1; } // namespace Pass::Status PrivateToLocalPass::Process() { bool modified = false; // Private variables require the shader capability. If this is not a shader, // there is no work to do. if (context()->get_feature_mgr()->HasCapability(spv::Capability::Addresses)) return Status::SuccessWithoutChange; std::vector> variables_to_move; std::unordered_set localized_variables; for (auto& inst : context()->types_values()) { if (inst.opcode() != spv::Op::OpVariable) { continue; } if (spv::StorageClass(inst.GetSingleWordInOperand( kVariableStorageClassInIdx)) != spv::StorageClass::Private) { continue; } Function* target_function = FindLocalFunction(inst); if (target_function != nullptr) { variables_to_move.push_back({&inst, target_function}); } } modified = !variables_to_move.empty(); for (auto p : variables_to_move) { if (!MoveVariable(p.first, p.second)) { return Status::Failure; } localized_variables.insert(p.first->result_id()); } if (get_module()->version() >= SPV_SPIRV_VERSION_WORD(1, 4)) { // In SPIR-V 1.4 and later entry points must list private storage class // variables that are statically used by the entry point. Go through the // entry points and remove any references to variables that were localized. for (auto& entry : get_module()->entry_points()) { std::vector new_operands; for (uint32_t i = 0; i < entry.NumInOperands(); ++i) { // Execution model, function id and name are always kept. if (i < 3 || !localized_variables.count(entry.GetSingleWordInOperand(i))) { new_operands.push_back(entry.GetInOperand(i)); } } if (new_operands.size() != entry.NumInOperands()) { entry.SetInOperands(std::move(new_operands)); context()->AnalyzeUses(&entry); } } } return (modified ? Status::SuccessWithChange : Status::SuccessWithoutChange); } Function* PrivateToLocalPass::FindLocalFunction(const Instruction& inst) const { bool found_first_use = false; Function* target_function = nullptr; context()->get_def_use_mgr()->ForEachUser( inst.result_id(), [&target_function, &found_first_use, this](Instruction* use) { BasicBlock* current_block = context()->get_instr_block(use); if (current_block == nullptr) { return; } if (!IsValidUse(use)) { found_first_use = true; target_function = nullptr; return; } Function* current_function = current_block->GetParent(); if (!found_first_use) { found_first_use = true; target_function = current_function; } else if (target_function != current_function) { target_function = nullptr; } }); return target_function; } // namespace opt bool PrivateToLocalPass::MoveVariable(Instruction* variable, Function* function) { // The variable needs to be removed from the global section, and placed in the // header of the function. First step remove from the global list. variable->RemoveFromList(); std::unique_ptr var(variable); // Take ownership. context()->ForgetUses(variable); // Update the storage class of the variable. variable->SetInOperand(kVariableStorageClassInIdx, {uint32_t(spv::StorageClass::Function)}); // Update the type as well. uint32_t new_type_id = GetNewType(variable->type_id()); if (new_type_id == 0) { return false; } variable->SetResultType(new_type_id); // Place the variable at the start of the first basic block. context()->AnalyzeUses(variable); context()->set_instr_block(variable, &*function->begin()); function->begin()->begin()->InsertBefore(std::move(var)); // Update uses where the type may have changed. return UpdateUses(variable); } uint32_t PrivateToLocalPass::GetNewType(uint32_t old_type_id) { auto type_mgr = context()->get_type_mgr(); Instruction* old_type_inst = get_def_use_mgr()->GetDef(old_type_id); uint32_t pointee_type_id = old_type_inst->GetSingleWordInOperand(kSpvTypePointerTypeIdInIdx); uint32_t new_type_id = type_mgr->FindPointerToType(pointee_type_id, spv::StorageClass::Function); if (new_type_id != 0) { context()->UpdateDefUse(context()->get_def_use_mgr()->GetDef(new_type_id)); } return new_type_id; } bool PrivateToLocalPass::IsValidUse(const Instruction* inst) const { // The cases in this switch have to match the cases in |UpdateUse|. // If we don't know how to update it, it is not valid. if (inst->GetCommonDebugOpcode() == CommonDebugInfoDebugGlobalVariable) { return true; } switch (inst->opcode()) { case spv::Op::OpLoad: case spv::Op::OpStore: case spv::Op::OpImageTexelPointer: // Treat like a load return true; case spv::Op::OpAccessChain: return context()->get_def_use_mgr()->WhileEachUser( inst, [this](const Instruction* user) { if (!IsValidUse(user)) return false; return true; }); case spv::Op::OpName: return true; default: return spvOpcodeIsDecoration(inst->opcode()); } } bool PrivateToLocalPass::UpdateUse(Instruction* inst, Instruction* user) { // The cases in this switch have to match the cases in |IsValidUse|. If we // don't think it is valid, the optimization will not view the variable as a // candidate, and therefore the use will not be updated. if (inst->GetCommonDebugOpcode() == CommonDebugInfoDebugGlobalVariable) { context()->get_debug_info_mgr()->ConvertDebugGlobalToLocalVariable(inst, user); return true; } switch (inst->opcode()) { case spv::Op::OpLoad: case spv::Op::OpStore: case spv::Op::OpImageTexelPointer: // Treat like a load // The type is fine because it is the type pointed to, and that does not // change. break; case spv::Op::OpAccessChain: { context()->ForgetUses(inst); uint32_t new_type_id = GetNewType(inst->type_id()); if (new_type_id == 0) { return false; } inst->SetResultType(new_type_id); context()->AnalyzeUses(inst); // Update uses where the type may have changed. if (!UpdateUses(inst)) { return false; } } break; case spv::Op::OpName: case spv::Op::OpEntryPoint: // entry points will be updated separately. break; default: assert(spvOpcodeIsDecoration(inst->opcode()) && "Do not know how to update the type for this instruction."); break; } return true; } bool PrivateToLocalPass::UpdateUses(Instruction* inst) { uint32_t id = inst->result_id(); std::vector uses; context()->get_def_use_mgr()->ForEachUser( id, [&uses](Instruction* use) { uses.push_back(use); }); for (Instruction* use : uses) { if (!UpdateUse(use, inst)) { return false; } } return true; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/private_to_local_pass.h000066400000000000000000000061061475742701700253630ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_PRIVATE_TO_LOCAL_PASS_H_ #define SOURCE_OPT_PRIVATE_TO_LOCAL_PASS_H_ #include "source/opt/ir_context.h" #include "source/opt/pass.h" namespace spvtools { namespace opt { // This pass implements total redundancy elimination. This is the same as // local redundancy elimination except it looks across basic block boundaries. // An instruction, inst, is totally redundant if there is another instruction // that dominates inst, and also computes the same value. class PrivateToLocalPass : public Pass { public: const char* name() const override { return "private-to-local"; } Status Process() override; IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisDecorations | IRContext::kAnalysisCombinators | IRContext::kAnalysisCFG | IRContext::kAnalysisDominatorAnalysis | IRContext::kAnalysisNameMap | IRContext::kAnalysisConstants | IRContext::kAnalysisTypes; } private: // Moves |variable| from the private storage class to the function storage // class of |function|. Returns false if the variable could not be moved. bool MoveVariable(Instruction* variable, Function* function); // |inst| is an instruction declaring a variable. If that variable is // referenced in a single function and all of uses are valid as defined by // |IsValidUse|, then that function is returned. Otherwise, the return // value is |nullptr|. Function* FindLocalFunction(const Instruction& inst) const; // Returns true is |inst| is a valid use of a pointer. In this case, a // valid use is one where the transformation is able to rewrite the type to // match a change in storage class of the original variable. bool IsValidUse(const Instruction* inst) const; // Given the result id of a pointer type, |old_type_id|, this function // returns the id of a the same pointer type except the storage class has // been changed to function. If the type does not already exist, it will be // created. Returns 0 if the new type could not be found or generated. uint32_t GetNewType(uint32_t old_type_id); // Updates |inst|, and any instruction dependent on |inst|, to reflect the // change of the base pointer now pointing to the function storage class. bool UpdateUse(Instruction* inst, Instruction* user); bool UpdateUses(Instruction* inst); }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_PRIVATE_TO_LOCAL_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/propagator.cpp000066400000000000000000000224321475742701700235200ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/propagator.h" namespace spvtools { namespace opt { void SSAPropagator::AddControlEdge(const Edge& edge) { BasicBlock* dest_bb = edge.dest; // Refuse to add the exit block to the work list. if (dest_bb == ctx_->cfg()->pseudo_exit_block()) { return; } // Try to mark the edge executable. If it was already in the set of // executable edges, do nothing. if (!MarkEdgeExecutable(edge)) { return; } // If the edge had not already been marked executable, add the destination // basic block to the work list. blocks_.push(dest_bb); } void SSAPropagator::AddSSAEdges(Instruction* instr) { // Ignore instructions that produce no result. if (instr->result_id() == 0) { return; } get_def_use_mgr()->ForEachUser( instr->result_id(), [this](Instruction* use_instr) { // If the basic block for |use_instr| has not been simulated yet, do // nothing. The instruction |use_instr| will be simulated next time the // block is scheduled. if (!BlockHasBeenSimulated(ctx_->get_instr_block(use_instr))) { return; } if (ShouldSimulateAgain(use_instr)) { ssa_edge_uses_.push(use_instr); } }); } bool SSAPropagator::IsPhiArgExecutable(Instruction* phi, uint32_t i) const { BasicBlock* phi_bb = ctx_->get_instr_block(phi); uint32_t in_label_id = phi->GetSingleWordOperand(i + 1); Instruction* in_label_instr = get_def_use_mgr()->GetDef(in_label_id); BasicBlock* in_bb = ctx_->get_instr_block(in_label_instr); return IsEdgeExecutable(Edge(in_bb, phi_bb)); } bool SSAPropagator::SetStatus(Instruction* inst, PropStatus status) { bool has_old_status = false; PropStatus old_status = kVarying; if (HasStatus(inst)) { has_old_status = true; old_status = Status(inst); } assert((!has_old_status || old_status <= status) && "Invalid lattice transition"); bool status_changed = !has_old_status || (old_status != status); if (status_changed) statuses_[inst] = status; return status_changed; } bool SSAPropagator::Simulate(Instruction* instr) { bool changed = false; // Don't bother visiting instructions that should not be simulated again. if (!ShouldSimulateAgain(instr)) { return changed; } BasicBlock* dest_bb = nullptr; PropStatus status = visit_fn_(instr, &dest_bb); bool status_changed = SetStatus(instr, status); if (status == kVarying) { // The statement produces a varying result, add it to the list of statements // not to simulate anymore and add its SSA def-use edges for simulation. DontSimulateAgain(instr); if (status_changed) { AddSSAEdges(instr); } // If |instr| is a block terminator, add all the control edges out of its // block. if (instr->IsBlockTerminator()) { BasicBlock* block = ctx_->get_instr_block(instr); for (const auto& e : bb_succs_.at(block)) { AddControlEdge(e); } } return false; } else if (status == kInteresting) { // Add the SSA edges coming out of this instruction if the propagation // status has changed. if (status_changed) { AddSSAEdges(instr); } // If there are multiple outgoing control flow edges and we know which one // will be taken, add the destination block to the CFG work list. if (dest_bb) { AddControlEdge(Edge(ctx_->get_instr_block(instr), dest_bb)); } changed = true; } // At this point, we are dealing with instructions that are in status // kInteresting or kNotInteresting. To decide whether this instruction should // be simulated again, we examine its operands. If at least one operand O is // defined at an instruction D that should be simulated again, then the output // of D might affect |instr|, so we should simulate |instr| again. bool has_operands_to_simulate = false; if (instr->opcode() == spv::Op::OpPhi) { // For Phi instructions, an operand causes the Phi to be simulated again if // the operand comes from an edge that has not yet been traversed or if its // definition should be simulated again. for (uint32_t i = 2; i < instr->NumOperands(); i += 2) { // Phi arguments come in pairs. Index 'i' contains the // variable id, index 'i + 1' is the originating block id. assert(i % 2 == 0 && i < instr->NumOperands() - 1 && "malformed Phi arguments"); uint32_t arg_id = instr->GetSingleWordOperand(i); Instruction* arg_def_instr = get_def_use_mgr()->GetDef(arg_id); if (!IsPhiArgExecutable(instr, i) || ShouldSimulateAgain(arg_def_instr)) { has_operands_to_simulate = true; break; } } } else { // For regular instructions, check if the defining instruction of each // operand needs to be simulated again. If so, then this instruction should // also be simulated again. has_operands_to_simulate = !instr->WhileEachInId([this](const uint32_t* use) { Instruction* def_instr = get_def_use_mgr()->GetDef(*use); if (ShouldSimulateAgain(def_instr)) { return false; } return true; }); } if (!has_operands_to_simulate) { DontSimulateAgain(instr); } return changed; } bool SSAPropagator::Simulate(BasicBlock* block) { if (block == ctx_->cfg()->pseudo_exit_block()) { return false; } // Always simulate Phi instructions, even if we have simulated this block // before. We do this because Phi instructions receive their inputs from // incoming edges. When those edges are marked executable, the corresponding // operand can be simulated. bool changed = false; block->ForEachPhiInst( [&changed, this](Instruction* instr) { changed |= Simulate(instr); }); // If this is the first time this block is being simulated, simulate every // statement in it. if (!BlockHasBeenSimulated(block)) { block->ForEachInst([this, &changed](Instruction* instr) { if (instr->opcode() != spv::Op::OpPhi) { changed |= Simulate(instr); } }); MarkBlockSimulated(block); // If this block has exactly one successor, mark the edge to its successor // as executable. if (bb_succs_.at(block).size() == 1) { AddControlEdge(bb_succs_.at(block).at(0)); } } return changed; } void SSAPropagator::Initialize(Function* fn) { // Compute predecessor and successor blocks for every block in |fn|'s CFG. // TODO(dnovillo): Move this to CFG and always build them. Alternately, // move it to IRContext and build CFG preds/succs on-demand. bb_succs_[ctx_->cfg()->pseudo_entry_block()].push_back( Edge(ctx_->cfg()->pseudo_entry_block(), fn->entry().get())); for (auto& block : *fn) { const auto& const_block = block; const_block.ForEachSuccessorLabel([this, &block](const uint32_t label_id) { BasicBlock* succ_bb = ctx_->get_instr_block(get_def_use_mgr()->GetDef(label_id)); bb_succs_[&block].push_back(Edge(&block, succ_bb)); bb_preds_[succ_bb].push_back(Edge(succ_bb, &block)); }); if (block.IsReturnOrAbort()) { bb_succs_[&block].push_back( Edge(&block, ctx_->cfg()->pseudo_exit_block())); bb_preds_[ctx_->cfg()->pseudo_exit_block()].push_back( Edge(ctx_->cfg()->pseudo_exit_block(), &block)); } } // Add the edges out of the entry block to seed the propagator. const auto& entry_succs = bb_succs_[ctx_->cfg()->pseudo_entry_block()]; for (const auto& e : entry_succs) { AddControlEdge(e); } } bool SSAPropagator::Run(Function* fn) { Initialize(fn); bool changed = false; while (!blocks_.empty() || !ssa_edge_uses_.empty()) { // Simulate all blocks first. Simulating blocks will add SSA edges to // follow after all the blocks have been simulated. if (!blocks_.empty()) { auto block = blocks_.front(); changed |= Simulate(block); blocks_.pop(); continue; } // Simulate edges from the SSA queue. if (!ssa_edge_uses_.empty()) { Instruction* instr = ssa_edge_uses_.front(); changed |= Simulate(instr); ssa_edge_uses_.pop(); } } #ifndef NDEBUG // Verify all visited values have settled. No value that has been simulated // should end on not interesting. fn->ForEachInst([this](Instruction* inst) { assert( (!HasStatus(inst) || Status(inst) != SSAPropagator::kNotInteresting) && "Unsettled value"); }); #endif return changed; } std::ostream& operator<<(std::ostream& str, const SSAPropagator::PropStatus& status) { switch (status) { case SSAPropagator::kVarying: str << "Varying"; break; case SSAPropagator::kInteresting: str << "Interesting"; break; default: str << "Not interesting"; break; } return str; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/propagator.h000066400000000000000000000322251475742701700231660ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_PROPAGATOR_H_ #define SOURCE_OPT_PROPAGATOR_H_ #include #include #include #include #include #include #include #include "source/opt/ir_context.h" #include "source/opt/module.h" namespace spvtools { namespace opt { // Represents a CFG control edge. struct Edge { Edge(BasicBlock* b1, BasicBlock* b2) : source(b1), dest(b2) { assert(source && "CFG edges cannot have a null source block."); assert(dest && "CFG edges cannot have a null destination block."); } BasicBlock* source; BasicBlock* dest; bool operator<(const Edge& o) const { return std::make_pair(source->id(), dest->id()) < std::make_pair(o.source->id(), o.dest->id()); } }; // This class implements a generic value propagation algorithm based on the // conditional constant propagation algorithm proposed in // // Constant propagation with conditional branches, // Wegman and Zadeck, ACM TOPLAS 13(2):181-210. // // A Propagation Engine for GCC // Diego Novillo, GCC Summit 2005 // http://ols.fedoraproject.org/GCC/Reprints-2005/novillo-Reprint.pdf // // The purpose of this implementation is to act as a common framework for any // transformation that needs to propagate values from statements producing new // values to statements using those values. Simulation proceeds as follows: // // 1- Initially, all edges of the CFG are marked not executable and the CFG // worklist is seeded with all the statements in the entry basic block. // // 2- Every instruction I is simulated by calling a pass-provided function // |visit_fn|. This function is responsible for three things: // // (a) Keep a value table of interesting values. This table maps SSA IDs to // their values. For instance, when implementing constant propagation, // given a store operation 'OpStore %f %int_3', |visit_fn| should assign // the value 3 to the table slot for %f. // // In general, |visit_fn| will need to use the value table to replace its // operands, fold the result and decide whether a new value needs to be // stored in the table. |visit_fn| should only create a new mapping in // the value table if all the operands in the instruction are known and // present in the value table. // // (b) Return a status indicator to direct the propagator logic. Once the // instruction is simulated, the propagator needs to know whether this // instruction produced something interesting. This is indicated via // |visit_fn|'s return value: // // SSAPropagator::kNotInteresting: Instruction I produces nothing of // interest and does not affect any of the work lists. The // propagator will visit the statement again if any of its operands // produce an interesting value in the future. // // |visit_fn| should always return this value when it is not sure // whether the instruction will produce an interesting value in the // future or not. For instance, for constant propagation, an OpIAdd // instruction may produce a constant if its two operands are // constant, but the first time we visit the instruction, we still // may not have its operands in the value table. // // SSAPropagator::kVarying: The value produced by I cannot be determined // at compile time. Further simulation of I is not required. The // propagator will not visit this instruction again. Additionally, // the propagator will add all the instructions at the end of SSA // def-use edges to be simulated again. // // If I is a basic block terminator, it will mark all outgoing edges // as executable so they are traversed one more time. Eventually // the kVarying attribute will be spread out to all the data and // control dependents for I. // // It is important for propagation to use kVarying as a bottom value // for the propagation lattice. It should never be possible for an // instruction to return kVarying once and kInteresting on a second // visit. Otherwise, propagation would not stabilize. // // SSAPropagator::kInteresting: Instruction I produces a value that can // be computed at compile time. In this case, |visit_fn| should // create a new mapping between I's result ID and the produced // value. Much like the kNotInteresting case, the propagator will // visit this instruction again if any of its operands changes. // This is useful when the statement changes from one interesting // state to another. // // (c) For conditional branches, |visit_fn| may decide which edge to take out // of I's basic block. For example, if the operand for an OpSwitch is // known to take a specific constant value, |visit_fn| should figure out // the destination basic block and pass it back by setting the second // argument to |visit_fn|. // // At the end of propagation, values in the value table are guaranteed to be // stable and can be replaced in the IR. // // 3- The propagator keeps two work queues. Instructions are only added to // these queues if they produce an interesting or varying value. None of this // should be handled by |visit_fn|. The propagator keeps track of this // automatically (see SSAPropagator::Simulate for implementation). // // CFG blocks: contains the queue of blocks to be simulated. // Blocks are added to this queue if their incoming edges are // executable. // // SSA Edges: An SSA edge is a def-use edge between a value-producing // instruction and its use instruction. The SSA edges list // contains the statements at the end of a def-use edge that need // to be re-visited when an instruction produces a kVarying or // kInteresting result. // // 4- Simulation terminates when all work queues are drained. // // // EXAMPLE: Basic constant store propagator. // // Suppose we want to propagate all constant assignments of the form "OpStore // %id %cst" where "%id" is some variable and "%cst" an OpConstant. The // following code builds a table |values| where every id that was assigned a // constant value is mapped to the constant value it was assigned. // // auto ctx = BuildModule(...); // std::map values; // const auto visit_fn = [&ctx, &values](Instruction* instr, // BasicBlock** dest_bb) { // if (instr->opcode() == spv::Op::OpStore) { // uint32_t rhs_id = instr->GetSingleWordOperand(1); // Instruction* rhs_def = ctx->get_def_use_mgr()->GetDef(rhs_id); // if (rhs_def->opcode() == spv::Op::OpConstant) { // uint32_t val = rhs_def->GetSingleWordOperand(2); // values[rhs_id] = val; // return SSAPropagator::kInteresting; // } // } // return SSAPropagator::kVarying; // }; // SSAPropagator propagator(ctx.get(), &cfg, visit_fn); // propagator.Run(&fn); // // Given the code: // // %int_4 = OpConstant %int 4 // %int_3 = OpConstant %int 3 // %int_1 = OpConstant %int 1 // OpStore %x %int_4 // OpStore %y %int_3 // OpStore %z %int_1 // // After SSAPropagator::Run returns, the |values| map will contain the entries: // values[%x] = 4, values[%y] = 3, and, values[%z] = 1. class SSAPropagator { public: // Lattice values used for propagation. See class documentation for // a description. enum PropStatus { kNotInteresting, kInteresting, kVarying }; using VisitFunction = std::function; SSAPropagator(IRContext* context, const VisitFunction& visit_fn) : ctx_(context), visit_fn_(visit_fn) {} // Runs the propagator on function |fn|. Returns true if changes were made to // the function. Otherwise, it returns false. bool Run(Function* fn); // Returns true if the |i|th argument for |phi| comes through a CFG edge that // has been marked executable. |i| should be an index value accepted by // Instruction::GetSingleWordOperand. bool IsPhiArgExecutable(Instruction* phi, uint32_t i) const; // Returns true if |inst| has a recorded status. This will be true once |inst| // has been simulated once. bool HasStatus(Instruction* inst) const { return statuses_.count(inst); } // Returns the current propagation status of |inst|. Assumes // |HasStatus(inst)| returns true. PropStatus Status(Instruction* inst) const { return statuses_.find(inst)->second; } // Records the propagation status |status| for |inst|. Returns true if the // status for |inst| has changed or set was set for the first time. bool SetStatus(Instruction* inst, PropStatus status); private: // Initialize processing. void Initialize(Function* fn); // Simulate the execution |block| by calling |visit_fn_| on every instruction // in it. bool Simulate(BasicBlock* block); // Simulate the execution of |instr| by replacing all the known values in // every operand and determining whether the result is interesting for // propagation. This invokes the callback function |visit_fn_| to determine // the value computed by |instr|. bool Simulate(Instruction* instr); // Returns true if |instr| should be simulated again. bool ShouldSimulateAgain(Instruction* instr) const { return do_not_simulate_.find(instr) == do_not_simulate_.end(); } // Add |instr| to the set of instructions not to simulate again. void DontSimulateAgain(Instruction* instr) { do_not_simulate_.insert(instr); } // Returns true if |block| has been simulated already. bool BlockHasBeenSimulated(BasicBlock* block) const { return simulated_blocks_.find(block) != simulated_blocks_.end(); } // Marks block |block| as simulated. void MarkBlockSimulated(BasicBlock* block) { simulated_blocks_.insert(block); } // Marks |edge| as executable. Returns false if the edge was already marked // as executable. bool MarkEdgeExecutable(const Edge& edge) { return executable_edges_.insert(edge).second; } // Returns true if |edge| has been marked as executable. bool IsEdgeExecutable(const Edge& edge) const { return executable_edges_.find(edge) != executable_edges_.end(); } // Returns a pointer to the def-use manager for |ctx_|. analysis::DefUseManager* get_def_use_mgr() const { return ctx_->get_def_use_mgr(); } // If the CFG edge |e| has not been executed, this function adds |e|'s // destination block to the work list. void AddControlEdge(const Edge& e); // Adds all the instructions that use the result of |instr| to the SSA edges // work list. If |instr| produces no result id, this does nothing. void AddSSAEdges(Instruction* instr); // IR context to use. IRContext* ctx_; // Function that visits instructions during simulation. The output of this // function is used to determine if the simulated instruction produced a value // interesting for propagation. The function is responsible for keeping // track of interesting values by storing them in some user-provided map. VisitFunction visit_fn_; // SSA def-use edges to traverse. Each entry is a destination statement for an // SSA def-use edge as returned by |def_use_manager_|. std::queue ssa_edge_uses_; // Blocks to simulate. std::queue blocks_; // Blocks simulated during propagation. std::unordered_set simulated_blocks_; // Set of instructions that should not be simulated again because they have // been found to be in the kVarying state. std::unordered_set do_not_simulate_; // Map between a basic block and its predecessor edges. // TODO(dnovillo): Move this to CFG and always build them. Alternately, // move it to IRContext and build CFG preds/succs on-demand. std::unordered_map> bb_preds_; // Map between a basic block and its successor edges. // TODO(dnovillo): Move this to CFG and always build them. Alternately, // move it to IRContext and build CFG preds/succs on-demand. std::unordered_map> bb_succs_; // Set of executable CFG edges. std::set executable_edges_; // Tracks instruction propagation status. std::unordered_map statuses_; }; std::ostream& operator<<(std::ostream& str, const SSAPropagator::PropStatus& status); } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_PROPAGATOR_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/reduce_load_size.cpp000066400000000000000000000145531475742701700246470ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/reduce_load_size.h" #include #include #include "source/opt/instruction.h" #include "source/opt/ir_builder.h" #include "source/opt/ir_context.h" #include "source/util/bit_vector.h" namespace spvtools { namespace opt { namespace { constexpr uint32_t kExtractCompositeIdInIdx = 0; constexpr uint32_t kVariableStorageClassInIdx = 0; constexpr uint32_t kLoadPointerInIdx = 0; } // namespace Pass::Status ReduceLoadSize::Process() { bool modified = false; for (auto& func : *get_module()) { func.ForEachInst([&modified, this](Instruction* inst) { if (inst->opcode() == spv::Op::OpCompositeExtract) { if (ShouldReplaceExtract(inst)) { modified |= ReplaceExtract(inst); } } }); } return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } bool ReduceLoadSize::ReplaceExtract(Instruction* inst) { assert(inst->opcode() == spv::Op::OpCompositeExtract && "Wrong opcode. Should be OpCompositeExtract."); analysis::DefUseManager* def_use_mgr = context()->get_def_use_mgr(); analysis::TypeManager* type_mgr = context()->get_type_mgr(); analysis::ConstantManager* const_mgr = context()->get_constant_mgr(); uint32_t composite_id = inst->GetSingleWordInOperand(kExtractCompositeIdInIdx); Instruction* composite_inst = def_use_mgr->GetDef(composite_id); if (composite_inst->opcode() != spv::Op::OpLoad) { return false; } analysis::Type* composite_type = type_mgr->GetType(composite_inst->type_id()); if (composite_type->kind() == analysis::Type::kVector || composite_type->kind() == analysis::Type::kMatrix) { return false; } Instruction* var = composite_inst->GetBaseAddress(); if (var == nullptr || var->opcode() != spv::Op::OpVariable) { return false; } spv::StorageClass storage_class = static_cast( var->GetSingleWordInOperand(kVariableStorageClassInIdx)); switch (storage_class) { case spv::StorageClass::Uniform: case spv::StorageClass::UniformConstant: case spv::StorageClass::Input: break; default: return false; } // Create a new access chain and load just after the old load. // We cannot create the new access chain load in the position of the extract // because the storage may have been written to in between. InstructionBuilder ir_builder( inst->context(), composite_inst, IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisDefUse); uint32_t pointer_to_result_type_id = type_mgr->FindPointerToType(inst->type_id(), storage_class); assert(pointer_to_result_type_id != 0 && "We did not find the pointer type that we need."); analysis::Integer int_type(32, false); const analysis::Type* uint32_type = type_mgr->GetRegisteredType(&int_type); std::vector ids; for (uint32_t i = 1; i < inst->NumInOperands(); ++i) { uint32_t index = inst->GetSingleWordInOperand(i); const analysis::Constant* index_const = const_mgr->GetConstant(uint32_type, {index}); ids.push_back(const_mgr->GetDefiningInstruction(index_const)->result_id()); } Instruction* new_access_chain = ir_builder.AddAccessChain( pointer_to_result_type_id, composite_inst->GetSingleWordInOperand(kLoadPointerInIdx), ids); Instruction* new_load = ir_builder.AddLoad(inst->type_id(), new_access_chain->result_id()); context()->ReplaceAllUsesWith(inst->result_id(), new_load->result_id()); context()->KillInst(inst); return true; } bool ReduceLoadSize::ShouldReplaceExtract(Instruction* inst) { analysis::DefUseManager* def_use_mgr = context()->get_def_use_mgr(); Instruction* op_inst = def_use_mgr->GetDef( inst->GetSingleWordInOperand(kExtractCompositeIdInIdx)); if (op_inst->opcode() != spv::Op::OpLoad) { return false; } auto cached_result = should_replace_cache_.find(op_inst->result_id()); if (cached_result != should_replace_cache_.end()) { return cached_result->second; } bool all_elements_used = false; std::set elements_used; all_elements_used = !def_use_mgr->WhileEachUser(op_inst, [&elements_used](Instruction* use) { if (use->IsCommonDebugInstr()) return true; if (use->opcode() != spv::Op::OpCompositeExtract || use->NumInOperands() == 1) { return false; } elements_used.insert(use->GetSingleWordInOperand(1)); return true; }); bool should_replace = false; if (all_elements_used) { should_replace = false; } else if (1.0 <= replacement_threshold_) { should_replace = true; } else { analysis::ConstantManager* const_mgr = context()->get_constant_mgr(); analysis::TypeManager* type_mgr = context()->get_type_mgr(); analysis::Type* load_type = type_mgr->GetType(op_inst->type_id()); uint32_t total_size = 1; switch (load_type->kind()) { case analysis::Type::kArray: { const analysis::Constant* size_const = const_mgr->FindDeclaredConstant(load_type->AsArray()->LengthId()); if (size_const) { assert(size_const->AsIntConstant()); total_size = size_const->GetU32(); } else { // The size is spec constant, so it is unknown at this time. Assume // it is very large. total_size = UINT32_MAX; } } break; case analysis::Type::kStruct: total_size = static_cast( load_type->AsStruct()->element_types().size()); break; default: break; } double percent_used = static_cast(elements_used.size()) / static_cast(total_size); should_replace = (percent_used < replacement_threshold_); } should_replace_cache_[op_inst->result_id()] = should_replace; return should_replace; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/reduce_load_size.h000066400000000000000000000053651475742701700243150ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_REDUCE_LOAD_SIZE_H_ #define SOURCE_OPT_REDUCE_LOAD_SIZE_H_ #include #include "source/opt/ir_context.h" #include "source/opt/module.h" #include "source/opt/pass.h" namespace spvtools { namespace opt { // See optimizer.hpp for documentation. class ReduceLoadSize : public Pass { public: explicit ReduceLoadSize(double replacement_threshold) : replacement_threshold_(replacement_threshold) {} const char* name() const override { return "reduce-load-size"; } Status Process() override; // Return the mask of preserved Analyses. IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisCombinators | IRContext::kAnalysisCFG | IRContext::kAnalysisDominatorAnalysis | IRContext::kAnalysisLoopAnalysis | IRContext::kAnalysisNameMap | IRContext::kAnalysisConstants | IRContext::kAnalysisTypes; } private: // Replaces |inst|, which must be an OpCompositeExtract instruction, with // an OpAccessChain and a load if possible. This happens only if it is a load // feeding |inst|. Returns true if the substitution happened. The position // of the new instructions will be in the same place as the load feeding the // extract. bool ReplaceExtract(Instruction* inst); // Returns true if the OpCompositeExtract instruction |inst| should be replace // or not. This is determined by looking at the load that feeds |inst| if // it is a load. |should_replace_cache_| is used to cache the results based // on the load feeding |inst|. bool ShouldReplaceExtract(Instruction* inst); // Threshold to determine whether we have to replace the load or not. If the // ratio of the used components of the load is less than the threshold, we // replace the load. double replacement_threshold_; // Maps the result id of an OpLoad instruction to the result of whether or // not the OpCompositeExtract that use the id should be replaced. std::unordered_map should_replace_cache_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_REDUCE_LOAD_SIZE_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/redundancy_elimination.cpp000066400000000000000000000036751475742701700260760ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/redundancy_elimination.h" #include "source/opt/value_number_table.h" namespace spvtools { namespace opt { Pass::Status RedundancyEliminationPass::Process() { bool modified = false; ValueNumberTable vnTable(context()); for (auto& func : *get_module()) { if (func.IsDeclaration()) { continue; } // Build the dominator tree for this function. It is how the code is // traversed. DominatorTree& dom_tree = context()->GetDominatorAnalysis(&func)->GetDomTree(); // Keeps track of all ids that contain a given value number. We keep // track of multiple values because they could have the same value, but // different decorations. std::map value_to_ids; if (EliminateRedundanciesFrom(dom_tree.GetRoot(), vnTable, value_to_ids)) { modified = true; } } return (modified ? Status::SuccessWithChange : Status::SuccessWithoutChange); } bool RedundancyEliminationPass::EliminateRedundanciesFrom( DominatorTreeNode* bb, const ValueNumberTable& vnTable, std::map value_to_ids) { bool modified = EliminateRedundanciesInBB(bb->bb_, vnTable, &value_to_ids); for (auto dominated_bb : bb->children_) { modified |= EliminateRedundanciesFrom(dominated_bb, vnTable, value_to_ids); } return modified; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/redundancy_elimination.h000066400000000000000000000041111475742701700255250ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_REDUNDANCY_ELIMINATION_H_ #define SOURCE_OPT_REDUNDANCY_ELIMINATION_H_ #include #include "source/opt/ir_context.h" #include "source/opt/local_redundancy_elimination.h" #include "source/opt/pass.h" #include "source/opt/value_number_table.h" namespace spvtools { namespace opt { // This pass implements total redundancy elimination. This is the same as // local redundancy elimination except it looks across basic block boundaries. // An instruction, inst, is totally redundant if there is another instruction // that dominates inst, and also computes the same value. class RedundancyEliminationPass : public LocalRedundancyEliminationPass { public: const char* name() const override { return "redundancy-elimination"; } Status Process() override; protected: // Removes for all total redundancies in the function starting at |bb|. // // |vnTable| must have computed a value number for every result id defined // in the function containing |bb|. // // |value_to_ids| is a map from value number to ids. If {vn, id} is in // |value_to_ids| then vn is the value number of id, and the definition of id // dominates |bb|. // // Returns true if at least one instruction is deleted. bool EliminateRedundanciesFrom(DominatorTreeNode* bb, const ValueNumberTable& vnTable, std::map value_to_ids); }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_REDUNDANCY_ELIMINATION_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/reflect.h000066400000000000000000000041321475742701700224300ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_REFLECT_H_ #define SOURCE_OPT_REFLECT_H_ #include "source/latest_version_spirv_header.h" #include "source/opcode.h" namespace spvtools { namespace opt { // Note that as SPIR-V evolves over time, new opcodes may appear. So the // following functions tend to be outdated and should be updated when SPIR-V // version bumps. inline bool IsDebug1Inst(spv::Op opcode) { return (opcode >= spv::Op::OpSourceContinued && opcode <= spv::Op::OpSourceExtension) || opcode == spv::Op::OpString; } inline bool IsDebug2Inst(spv::Op opcode) { return opcode == spv::Op::OpName || opcode == spv::Op::OpMemberName; } inline bool IsDebug3Inst(spv::Op opcode) { return opcode == spv::Op::OpModuleProcessed; } inline bool IsOpLineInst(spv::Op opcode) { return opcode == spv::Op::OpLine || opcode == spv::Op::OpNoLine; } inline bool IsAnnotationInst(spv::Op opcode) { return (opcode >= spv::Op::OpDecorate && opcode <= spv::Op::OpGroupMemberDecorate) || opcode == spv::Op::OpDecorateId || opcode == spv::Op::OpDecorateStringGOOGLE || opcode == spv::Op::OpMemberDecorateStringGOOGLE; } inline bool IsTypeInst(spv::Op opcode) { return spvOpcodeGeneratesType(opcode) || opcode == spv::Op::OpTypeForwardPointer; } inline bool IsConstantInst(spv::Op opcode) { return spvOpcodeIsConstant(opcode); } inline bool IsSpecConstantInst(spv::Op opcode) { return spvOpcodeIsSpecConstant(opcode); } } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_REFLECT_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/register_pressure.cpp000066400000000000000000000517551475742701700251300ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/register_pressure.h" #include #include #include "source/opt/cfg.h" #include "source/opt/def_use_manager.h" #include "source/opt/dominator_tree.h" #include "source/opt/function.h" #include "source/opt/ir_context.h" #include "source/opt/iterator.h" namespace spvtools { namespace opt { namespace { // Predicate for the FilterIterator to only consider instructions that are not // phi instructions defined in the basic block |bb|. class ExcludePhiDefinedInBlock { public: ExcludePhiDefinedInBlock(IRContext* context, const BasicBlock* bb) : context_(context), bb_(bb) {} bool operator()(Instruction* insn) const { return !(insn->opcode() == spv::Op::OpPhi && context_->get_instr_block(insn) == bb_); } private: IRContext* context_; const BasicBlock* bb_; }; // Returns true if |insn| generates a SSA register that is likely to require a // physical register. bool CreatesRegisterUsage(Instruction* insn) { if (!insn->HasResultId()) return false; if (insn->opcode() == spv::Op::OpUndef) return false; if (IsConstantInst(insn->opcode())) return false; if (insn->opcode() == spv::Op::OpLabel) return false; return true; } // Compute the register liveness for each basic block of a function. This also // fill-up some information about the pick register usage and a break down of // register usage. This implements: "A non-iterative data-flow algorithm for // computing liveness sets in strict ssa programs" from Boissinot et al. class ComputeRegisterLiveness { public: ComputeRegisterLiveness(RegisterLiveness* reg_pressure, Function* f) : reg_pressure_(reg_pressure), context_(reg_pressure->GetContext()), function_(f), cfg_(*reg_pressure->GetContext()->cfg()), def_use_manager_(*reg_pressure->GetContext()->get_def_use_mgr()), dom_tree_( reg_pressure->GetContext()->GetDominatorAnalysis(f)->GetDomTree()), loop_desc_(*reg_pressure->GetContext()->GetLoopDescriptor(f)) {} // Computes the register liveness for |function_| and then estimate the // register usage. The liveness algorithm works in 2 steps: // - First, compute the liveness for each basic blocks, but will ignore any // back-edge; // - Second, walk loop forest to propagate registers crossing back-edges // (add iterative values into the liveness set). void Compute() { for (BasicBlock& start_bb : *function_) { if (reg_pressure_->Get(start_bb.id()) != nullptr) { continue; } cfg_.ForEachBlockInPostOrder(&start_bb, [this](BasicBlock* bb) { if (reg_pressure_->Get(bb->id()) == nullptr) { ComputePartialLiveness(bb); } }); } DoLoopLivenessUnification(); EvaluateRegisterRequirements(); } private: // Registers all SSA register used by successors of |bb| in their phi // instructions. void ComputePhiUses(const BasicBlock& bb, RegisterLiveness::RegionRegisterLiveness::LiveSet* live) { uint32_t bb_id = bb.id(); bb.ForEachSuccessorLabel([live, bb_id, this](uint32_t sid) { BasicBlock* succ_bb = cfg_.block(sid); succ_bb->ForEachPhiInst([live, bb_id, this](const Instruction* phi) { for (uint32_t i = 0; i < phi->NumInOperands(); i += 2) { if (phi->GetSingleWordInOperand(i + 1) == bb_id) { Instruction* insn_op = def_use_manager_.GetDef(phi->GetSingleWordInOperand(i)); if (CreatesRegisterUsage(insn_op)) { live->insert(insn_op); break; } } } }); }); } // Computes register liveness for each basic blocks but ignores all // back-edges. void ComputePartialLiveness(BasicBlock* bb) { assert(reg_pressure_->Get(bb) == nullptr && "Basic block already processed"); RegisterLiveness::RegionRegisterLiveness* live_inout = reg_pressure_->GetOrInsert(bb->id()); ComputePhiUses(*bb, &live_inout->live_out_); const BasicBlock* cbb = bb; cbb->ForEachSuccessorLabel([&live_inout, bb, this](uint32_t sid) { // Skip back edges. if (dom_tree_.Dominates(sid, bb->id())) { return; } BasicBlock* succ_bb = cfg_.block(sid); RegisterLiveness::RegionRegisterLiveness* succ_live_inout = reg_pressure_->Get(succ_bb); assert(succ_live_inout && "Successor liveness analysis was not performed"); ExcludePhiDefinedInBlock predicate(context_, succ_bb); auto filter = MakeFilterIteratorRange(succ_live_inout->live_in_.begin(), succ_live_inout->live_in_.end(), predicate); live_inout->live_out_.insert(filter.begin(), filter.end()); }); live_inout->live_in_ = live_inout->live_out_; for (Instruction& insn : make_range(bb->rbegin(), bb->rend())) { if (insn.opcode() == spv::Op::OpPhi) { live_inout->live_in_.insert(&insn); break; } live_inout->live_in_.erase(&insn); insn.ForEachInId([live_inout, this](uint32_t* id) { Instruction* insn_op = def_use_manager_.GetDef(*id); if (CreatesRegisterUsage(insn_op)) { live_inout->live_in_.insert(insn_op); } }); } } // Propagates the register liveness information of each loop iterators. void DoLoopLivenessUnification() { for (const Loop* loop : *loop_desc_.GetPlaceholderRootLoop()) { DoLoopLivenessUnification(*loop); } } // Propagates the register liveness information of loop iterators trough-out // the loop body. void DoLoopLivenessUnification(const Loop& loop) { auto blocks_in_loop = MakeFilterIteratorRange( loop.GetBlocks().begin(), loop.GetBlocks().end(), [&loop, this](uint32_t bb_id) { return bb_id != loop.GetHeaderBlock()->id() && loop_desc_[bb_id] == &loop; }); RegisterLiveness::RegionRegisterLiveness* header_live_inout = reg_pressure_->Get(loop.GetHeaderBlock()); assert(header_live_inout && "Liveness analysis was not performed for the current block"); ExcludePhiDefinedInBlock predicate(context_, loop.GetHeaderBlock()); auto live_loop = MakeFilterIteratorRange(header_live_inout->live_in_.begin(), header_live_inout->live_in_.end(), predicate); for (uint32_t bb_id : blocks_in_loop) { BasicBlock* bb = cfg_.block(bb_id); RegisterLiveness::RegionRegisterLiveness* live_inout = reg_pressure_->Get(bb); live_inout->live_in_.insert(live_loop.begin(), live_loop.end()); live_inout->live_out_.insert(live_loop.begin(), live_loop.end()); } for (const Loop* inner_loop : loop) { RegisterLiveness::RegionRegisterLiveness* live_inout = reg_pressure_->Get(inner_loop->GetHeaderBlock()); live_inout->live_in_.insert(live_loop.begin(), live_loop.end()); live_inout->live_out_.insert(live_loop.begin(), live_loop.end()); DoLoopLivenessUnification(*inner_loop); } } // Get the number of required registers for this each basic block. void EvaluateRegisterRequirements() { for (BasicBlock& bb : *function_) { RegisterLiveness::RegionRegisterLiveness* live_inout = reg_pressure_->Get(bb.id()); assert(live_inout != nullptr && "Basic block not processed"); size_t reg_count = live_inout->live_out_.size(); for (Instruction* insn : live_inout->live_out_) { live_inout->AddRegisterClass(insn); } live_inout->used_registers_ = reg_count; std::unordered_set die_in_block; for (Instruction& insn : make_range(bb.rbegin(), bb.rend())) { // If it is a phi instruction, the register pressure will not change // anymore. if (insn.opcode() == spv::Op::OpPhi) { break; } insn.ForEachInId( [live_inout, &die_in_block, ®_count, this](uint32_t* id) { Instruction* op_insn = def_use_manager_.GetDef(*id); if (!CreatesRegisterUsage(op_insn) || live_inout->live_out_.count(op_insn)) { // already taken into account. return; } if (!die_in_block.count(*id)) { live_inout->AddRegisterClass(def_use_manager_.GetDef(*id)); reg_count++; die_in_block.insert(*id); } }); live_inout->used_registers_ = std::max(live_inout->used_registers_, reg_count); if (CreatesRegisterUsage(&insn)) { reg_count--; } } } } RegisterLiveness* reg_pressure_; IRContext* context_; Function* function_; CFG& cfg_; analysis::DefUseManager& def_use_manager_; DominatorTree& dom_tree_; LoopDescriptor& loop_desc_; }; } // namespace // Get the number of required registers for each basic block. void RegisterLiveness::RegionRegisterLiveness::AddRegisterClass( Instruction* insn) { assert(CreatesRegisterUsage(insn) && "Instruction does not use a register"); analysis::Type* type = insn->context()->get_type_mgr()->GetType(insn->type_id()); RegisterLiveness::RegisterClass reg_class{type, false}; insn->context()->get_decoration_mgr()->WhileEachDecoration( insn->result_id(), uint32_t(spv::Decoration::Uniform), [®_class](const Instruction&) { reg_class.is_uniform_ = true; return false; }); AddRegisterClass(reg_class); } void RegisterLiveness::Analyze(Function* f) { block_pressure_.clear(); ComputeRegisterLiveness(this, f).Compute(); } void RegisterLiveness::ComputeLoopRegisterPressure( const Loop& loop, RegionRegisterLiveness* loop_reg_pressure) const { loop_reg_pressure->Clear(); const RegionRegisterLiveness* header_live_inout = Get(loop.GetHeaderBlock()); loop_reg_pressure->live_in_ = header_live_inout->live_in_; std::unordered_set exit_blocks; loop.GetExitBlocks(&exit_blocks); for (uint32_t bb_id : exit_blocks) { const RegionRegisterLiveness* live_inout = Get(bb_id); loop_reg_pressure->live_out_.insert(live_inout->live_in_.begin(), live_inout->live_in_.end()); } std::unordered_set seen_insn; for (Instruction* insn : loop_reg_pressure->live_out_) { loop_reg_pressure->AddRegisterClass(insn); seen_insn.insert(insn->result_id()); } for (Instruction* insn : loop_reg_pressure->live_in_) { if (!seen_insn.count(insn->result_id())) { continue; } loop_reg_pressure->AddRegisterClass(insn); seen_insn.insert(insn->result_id()); } loop_reg_pressure->used_registers_ = 0; for (uint32_t bb_id : loop.GetBlocks()) { BasicBlock* bb = context_->cfg()->block(bb_id); const RegionRegisterLiveness* live_inout = Get(bb_id); assert(live_inout != nullptr && "Basic block not processed"); loop_reg_pressure->used_registers_ = std::max( loop_reg_pressure->used_registers_, live_inout->used_registers_); for (Instruction& insn : *bb) { if (insn.opcode() == spv::Op::OpPhi || !CreatesRegisterUsage(&insn) || seen_insn.count(insn.result_id())) { continue; } loop_reg_pressure->AddRegisterClass(&insn); } } } void RegisterLiveness::SimulateFusion( const Loop& l1, const Loop& l2, RegionRegisterLiveness* sim_result) const { sim_result->Clear(); // Compute the live-in state: // sim_result.live_in = l1.live_in U l2.live_in // This assumes that |l1| does not generated register that is live-out for // |l1|. const RegionRegisterLiveness* l1_header_live_inout = Get(l1.GetHeaderBlock()); sim_result->live_in_ = l1_header_live_inout->live_in_; const RegionRegisterLiveness* l2_header_live_inout = Get(l2.GetHeaderBlock()); sim_result->live_in_.insert(l2_header_live_inout->live_in_.begin(), l2_header_live_inout->live_in_.end()); // The live-out set of the fused loop is the l2 live-out set. std::unordered_set exit_blocks; l2.GetExitBlocks(&exit_blocks); for (uint32_t bb_id : exit_blocks) { const RegionRegisterLiveness* live_inout = Get(bb_id); sim_result->live_out_.insert(live_inout->live_in_.begin(), live_inout->live_in_.end()); } // Compute the register usage information. std::unordered_set seen_insn; for (Instruction* insn : sim_result->live_out_) { sim_result->AddRegisterClass(insn); seen_insn.insert(insn->result_id()); } for (Instruction* insn : sim_result->live_in_) { if (!seen_insn.count(insn->result_id())) { continue; } sim_result->AddRegisterClass(insn); seen_insn.insert(insn->result_id()); } sim_result->used_registers_ = 0; // The loop fusion is injecting the l1 before the l2, the latch of l1 will be // connected to the header of l2. // To compute the register usage, we inject the loop live-in (union of l1 and // l2 live-in header blocks) into the live in/out of each basic block of // l1 to get the peak register usage. We then repeat the operation to for l2 // basic blocks but in this case we inject the live-out of the latch of l1. auto live_loop = MakeFilterIteratorRange( sim_result->live_in_.begin(), sim_result->live_in_.end(), [&l1, &l2](Instruction* insn) { BasicBlock* bb = insn->context()->get_instr_block(insn); return insn->HasResultId() && !(insn->opcode() == spv::Op::OpPhi && (bb == l1.GetHeaderBlock() || bb == l2.GetHeaderBlock())); }); for (uint32_t bb_id : l1.GetBlocks()) { BasicBlock* bb = context_->cfg()->block(bb_id); const RegionRegisterLiveness* live_inout_info = Get(bb_id); assert(live_inout_info != nullptr && "Basic block not processed"); RegionRegisterLiveness::LiveSet live_out = live_inout_info->live_out_; live_out.insert(live_loop.begin(), live_loop.end()); sim_result->used_registers_ = std::max(sim_result->used_registers_, live_inout_info->used_registers_ + live_out.size() - live_inout_info->live_out_.size()); for (Instruction& insn : *bb) { if (insn.opcode() == spv::Op::OpPhi || !CreatesRegisterUsage(&insn) || seen_insn.count(insn.result_id())) { continue; } sim_result->AddRegisterClass(&insn); } } const RegionRegisterLiveness* l1_latch_live_inout_info = Get(l1.GetLatchBlock()->id()); assert(l1_latch_live_inout_info != nullptr && "Basic block not processed"); RegionRegisterLiveness::LiveSet l1_latch_live_out = l1_latch_live_inout_info->live_out_; l1_latch_live_out.insert(live_loop.begin(), live_loop.end()); auto live_loop_l2 = make_range(l1_latch_live_out.begin(), l1_latch_live_out.end()); for (uint32_t bb_id : l2.GetBlocks()) { BasicBlock* bb = context_->cfg()->block(bb_id); const RegionRegisterLiveness* live_inout_info = Get(bb_id); assert(live_inout_info != nullptr && "Basic block not processed"); RegionRegisterLiveness::LiveSet live_out = live_inout_info->live_out_; live_out.insert(live_loop_l2.begin(), live_loop_l2.end()); sim_result->used_registers_ = std::max(sim_result->used_registers_, live_inout_info->used_registers_ + live_out.size() - live_inout_info->live_out_.size()); for (Instruction& insn : *bb) { if (insn.opcode() == spv::Op::OpPhi || !CreatesRegisterUsage(&insn) || seen_insn.count(insn.result_id())) { continue; } sim_result->AddRegisterClass(&insn); } } } void RegisterLiveness::SimulateFission( const Loop& loop, const std::unordered_set& moved_inst, const std::unordered_set& copied_inst, RegionRegisterLiveness* l1_sim_result, RegionRegisterLiveness* l2_sim_result) const { l1_sim_result->Clear(); l2_sim_result->Clear(); // Filter predicates: consider instructions that only belong to the first and // second loop. auto belong_to_loop1 = [&moved_inst, &copied_inst, &loop](Instruction* insn) { return moved_inst.count(insn) || copied_inst.count(insn) || !loop.IsInsideLoop(insn); }; auto belong_to_loop2 = [&moved_inst](Instruction* insn) { return !moved_inst.count(insn); }; const RegionRegisterLiveness* header_live_inout = Get(loop.GetHeaderBlock()); // l1 live-in { auto live_loop = MakeFilterIteratorRange( header_live_inout->live_in_.begin(), header_live_inout->live_in_.end(), belong_to_loop1); l1_sim_result->live_in_.insert(live_loop.begin(), live_loop.end()); } // l2 live-in { auto live_loop = MakeFilterIteratorRange( header_live_inout->live_in_.begin(), header_live_inout->live_in_.end(), belong_to_loop2); l2_sim_result->live_in_.insert(live_loop.begin(), live_loop.end()); } std::unordered_set exit_blocks; loop.GetExitBlocks(&exit_blocks); // l2 live-out. for (uint32_t bb_id : exit_blocks) { const RegionRegisterLiveness* live_inout = Get(bb_id); l2_sim_result->live_out_.insert(live_inout->live_in_.begin(), live_inout->live_in_.end()); } // l1 live-out. { auto live_out = MakeFilterIteratorRange(l2_sim_result->live_out_.begin(), l2_sim_result->live_out_.end(), belong_to_loop1); l1_sim_result->live_out_.insert(live_out.begin(), live_out.end()); } { auto live_out = MakeFilterIteratorRange(l2_sim_result->live_in_.begin(), l2_sim_result->live_in_.end(), belong_to_loop1); l1_sim_result->live_out_.insert(live_out.begin(), live_out.end()); } // Lives out of l1 are live out of l2 so are live in of l2 as well. l2_sim_result->live_in_.insert(l1_sim_result->live_out_.begin(), l1_sim_result->live_out_.end()); for (Instruction* insn : l1_sim_result->live_in_) { l1_sim_result->AddRegisterClass(insn); } for (Instruction* insn : l2_sim_result->live_in_) { l2_sim_result->AddRegisterClass(insn); } l1_sim_result->used_registers_ = 0; l2_sim_result->used_registers_ = 0; for (uint32_t bb_id : loop.GetBlocks()) { BasicBlock* bb = context_->cfg()->block(bb_id); const RegisterLiveness::RegionRegisterLiveness* live_inout = Get(bb_id); assert(live_inout != nullptr && "Basic block not processed"); auto l1_block_live_out = MakeFilterIteratorRange(live_inout->live_out_.begin(), live_inout->live_out_.end(), belong_to_loop1); auto l2_block_live_out = MakeFilterIteratorRange(live_inout->live_out_.begin(), live_inout->live_out_.end(), belong_to_loop2); size_t l1_reg_count = std::distance(l1_block_live_out.begin(), l1_block_live_out.end()); size_t l2_reg_count = std::distance(l2_block_live_out.begin(), l2_block_live_out.end()); std::unordered_set die_in_block; for (Instruction& insn : make_range(bb->rbegin(), bb->rend())) { if (insn.opcode() == spv::Op::OpPhi) { break; } bool does_belong_to_loop1 = belong_to_loop1(&insn); bool does_belong_to_loop2 = belong_to_loop2(&insn); insn.ForEachInId([live_inout, &die_in_block, &l1_reg_count, &l2_reg_count, does_belong_to_loop1, does_belong_to_loop2, this](uint32_t* id) { Instruction* op_insn = context_->get_def_use_mgr()->GetDef(*id); if (!CreatesRegisterUsage(op_insn) || live_inout->live_out_.count(op_insn)) { // already taken into account. return; } if (!die_in_block.count(*id)) { if (does_belong_to_loop1) { l1_reg_count++; } if (does_belong_to_loop2) { l2_reg_count++; } die_in_block.insert(*id); } }); l1_sim_result->used_registers_ = std::max(l1_sim_result->used_registers_, l1_reg_count); l2_sim_result->used_registers_ = std::max(l2_sim_result->used_registers_, l2_reg_count); if (CreatesRegisterUsage(&insn)) { if (does_belong_to_loop1) { if (!l1_sim_result->live_in_.count(&insn)) { l1_sim_result->AddRegisterClass(&insn); } l1_reg_count--; } if (does_belong_to_loop2) { if (!l2_sim_result->live_in_.count(&insn)) { l2_sim_result->AddRegisterClass(&insn); } l2_reg_count--; } } } } } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/register_pressure.h000066400000000000000000000155641475742701700245730ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_REGISTER_PRESSURE_H_ #define SOURCE_OPT_REGISTER_PRESSURE_H_ #include #include #include #include #include "source/opt/function.h" #include "source/opt/types.h" namespace spvtools { namespace opt { class IRContext; class Loop; class LoopDescriptor; // Handles the register pressure of a function for different regions (function, // loop, basic block). It also contains some utilities to foresee the register // pressure following code transformations. class RegisterLiveness { public: // Classification of SSA registers. struct RegisterClass { analysis::Type* type_; bool is_uniform_; bool operator==(const RegisterClass& rhs) const { return std::tie(type_, is_uniform_) == std::tie(rhs.type_, rhs.is_uniform_); } }; struct RegionRegisterLiveness { using LiveSet = std::unordered_set; using RegClassSetTy = std::vector>; // SSA register live when entering the basic block. LiveSet live_in_; // SSA register live when exiting the basic block. LiveSet live_out_; // Maximum number of required registers. size_t used_registers_; // Break down of the number of required registers per class of register. RegClassSetTy registers_classes_; void Clear() { live_out_.clear(); live_in_.clear(); used_registers_ = 0; registers_classes_.clear(); } void AddRegisterClass(const RegisterClass& reg_class) { auto it = std::find_if( registers_classes_.begin(), registers_classes_.end(), [®_class](const std::pair& class_count) { return class_count.first == reg_class; }); if (it != registers_classes_.end()) { it->second++; } else { registers_classes_.emplace_back(std::move(reg_class), static_cast(1)); } } void AddRegisterClass(Instruction* insn); }; RegisterLiveness(IRContext* context, Function* f) : context_(context) { Analyze(f); } // Returns liveness and register information for the basic block |bb|. If no // entry exist for the basic block, the function returns null. const RegionRegisterLiveness* Get(const BasicBlock* bb) const { return Get(bb->id()); } // Returns liveness and register information for the basic block id |bb_id|. // If no entry exist for the basic block, the function returns null. const RegionRegisterLiveness* Get(uint32_t bb_id) const { RegionRegisterLivenessMap::const_iterator it = block_pressure_.find(bb_id); if (it != block_pressure_.end()) { return &it->second; } return nullptr; } IRContext* GetContext() const { return context_; } // Returns liveness and register information for the basic block |bb|. If no // entry exist for the basic block, the function returns null. RegionRegisterLiveness* Get(const BasicBlock* bb) { return Get(bb->id()); } // Returns liveness and register information for the basic block id |bb_id|. // If no entry exist for the basic block, the function returns null. RegionRegisterLiveness* Get(uint32_t bb_id) { RegionRegisterLivenessMap::iterator it = block_pressure_.find(bb_id); if (it != block_pressure_.end()) { return &it->second; } return nullptr; } // Returns liveness and register information for the basic block id |bb_id| or // create a new empty entry if no entry already existed. RegionRegisterLiveness* GetOrInsert(uint32_t bb_id) { return &block_pressure_[bb_id]; } // Compute the register pressure for the |loop| and store the result into // |reg_pressure|. The live-in set corresponds to the live-in set of the // header block, the live-out set of the loop corresponds to the union of the // live-in sets of each exit basic block. void ComputeLoopRegisterPressure(const Loop& loop, RegionRegisterLiveness* reg_pressure) const; // Estimate the register pressure for the |l1| and |l2| as if they were making // one unique loop. The result is stored into |simulation_result|. void SimulateFusion(const Loop& l1, const Loop& l2, RegionRegisterLiveness* simulation_result) const; // Estimate the register pressure of |loop| after it has been fissioned // according to |moved_instructions| and |copied_instructions|. The function // assumes that the fission creates a new loop before |loop|, moves any // instructions present inside |moved_instructions| and copies any // instructions present inside |copied_instructions| into this new loop. // The set |loop1_sim_result| store the simulation result of the loop with the // moved instructions. The set |loop2_sim_result| store the simulation result // of the loop with the removed instructions. void SimulateFission( const Loop& loop, const std::unordered_set& moved_instructions, const std::unordered_set& copied_instructions, RegionRegisterLiveness* loop1_sim_result, RegionRegisterLiveness* loop2_sim_result) const; private: using RegionRegisterLivenessMap = std::unordered_map; IRContext* context_; RegionRegisterLivenessMap block_pressure_; void Analyze(Function* f); }; // Handles the register pressure of a function for different regions (function, // loop, basic block). It also contains some utilities to foresee the register // pressure following code transformations. class LivenessAnalysis { using LivenessAnalysisMap = std::unordered_map; public: LivenessAnalysis(IRContext* context) : context_(context) {} // Computes the liveness analysis for the function |f| and cache the result. // If the analysis was performed for this function, then the cached analysis // is returned. const RegisterLiveness* Get(Function* f) { LivenessAnalysisMap::iterator it = analysis_cache_.find(f); if (it != analysis_cache_.end()) { return &it->second; } return &analysis_cache_.emplace(f, RegisterLiveness{context_, f}) .first->second; } private: IRContext* context_; LivenessAnalysisMap analysis_cache_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_REGISTER_PRESSURE_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/relax_float_ops_pass.cpp000066400000000000000000000153371475742701700255570ustar00rootroot00000000000000// Copyright (c) 2019 The Khronos Group Inc. // Copyright (c) 2019 Valve Corporation // Copyright (c) 2019 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "relax_float_ops_pass.h" #include "source/opt/ir_builder.h" namespace spvtools { namespace opt { bool RelaxFloatOpsPass::IsRelaxable(Instruction* inst) { return target_ops_core_f_rslt_.count(inst->opcode()) != 0 || target_ops_core_f_opnd_.count(inst->opcode()) != 0 || sample_ops_.count(inst->opcode()) != 0 || (inst->opcode() == spv::Op::OpExtInst && inst->GetSingleWordInOperand(0) == context()->get_feature_mgr()->GetExtInstImportId_GLSLstd450() && target_ops_450_.count(inst->GetSingleWordInOperand(1)) != 0); } bool RelaxFloatOpsPass::IsFloat32(Instruction* inst) { uint32_t ty_id; if (target_ops_core_f_opnd_.count(inst->opcode()) != 0) { uint32_t opnd_id = inst->GetSingleWordInOperand(0); Instruction* opnd_inst = get_def_use_mgr()->GetDef(opnd_id); ty_id = opnd_inst->type_id(); } else { ty_id = inst->type_id(); if (ty_id == 0) return false; } return IsFloat(ty_id, 32); } bool RelaxFloatOpsPass::IsRelaxed(uint32_t r_id) { for (auto r_inst : get_decoration_mgr()->GetDecorationsFor(r_id, false)) if (r_inst->opcode() == spv::Op::OpDecorate && spv::Decoration(r_inst->GetSingleWordInOperand(1)) == spv::Decoration::RelaxedPrecision) return true; return false; } bool RelaxFloatOpsPass::ProcessInst(Instruction* r_inst) { uint32_t r_id = r_inst->result_id(); if (r_id == 0) return false; if (!IsFloat32(r_inst)) return false; if (IsRelaxed(r_id)) return false; if (!IsRelaxable(r_inst)) return false; get_decoration_mgr()->AddDecoration( r_id, uint32_t(spv::Decoration::RelaxedPrecision)); return true; } bool RelaxFloatOpsPass::ProcessFunction(Function* func) { bool modified = false; cfg()->ForEachBlockInReversePostOrder( func->entry().get(), [&modified, this](BasicBlock* bb) { for (auto ii = bb->begin(); ii != bb->end(); ++ii) modified |= ProcessInst(&*ii); }); return modified; } Pass::Status RelaxFloatOpsPass::ProcessImpl() { Pass::ProcessFunction pfn = [this](Function* fp) { return ProcessFunction(fp); }; bool modified = context()->ProcessReachableCallTree(pfn); return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } Pass::Status RelaxFloatOpsPass::Process() { Initialize(); return ProcessImpl(); } void RelaxFloatOpsPass::Initialize() { target_ops_core_f_rslt_ = { spv::Op::OpLoad, spv::Op::OpPhi, spv::Op::OpVectorExtractDynamic, spv::Op::OpVectorInsertDynamic, spv::Op::OpVectorShuffle, spv::Op::OpCompositeExtract, spv::Op::OpCompositeConstruct, spv::Op::OpCompositeInsert, spv::Op::OpCopyObject, spv::Op::OpTranspose, spv::Op::OpConvertSToF, spv::Op::OpConvertUToF, spv::Op::OpFConvert, // spv::Op::OpQuantizeToF16, spv::Op::OpFNegate, spv::Op::OpFAdd, spv::Op::OpFSub, spv::Op::OpFMul, spv::Op::OpFDiv, spv::Op::OpFMod, spv::Op::OpVectorTimesScalar, spv::Op::OpMatrixTimesScalar, spv::Op::OpVectorTimesMatrix, spv::Op::OpMatrixTimesVector, spv::Op::OpMatrixTimesMatrix, spv::Op::OpOuterProduct, spv::Op::OpDot, spv::Op::OpSelect, }; target_ops_core_f_opnd_ = { spv::Op::OpFOrdEqual, spv::Op::OpFUnordEqual, spv::Op::OpFOrdNotEqual, spv::Op::OpFUnordNotEqual, spv::Op::OpFOrdLessThan, spv::Op::OpFUnordLessThan, spv::Op::OpFOrdGreaterThan, spv::Op::OpFUnordGreaterThan, spv::Op::OpFOrdLessThanEqual, spv::Op::OpFUnordLessThanEqual, spv::Op::OpFOrdGreaterThanEqual, spv::Op::OpFUnordGreaterThanEqual, }; target_ops_450_ = { GLSLstd450Round, GLSLstd450RoundEven, GLSLstd450Trunc, GLSLstd450FAbs, GLSLstd450FSign, GLSLstd450Floor, GLSLstd450Ceil, GLSLstd450Fract, GLSLstd450Radians, GLSLstd450Degrees, GLSLstd450Sin, GLSLstd450Cos, GLSLstd450Tan, GLSLstd450Asin, GLSLstd450Acos, GLSLstd450Atan, GLSLstd450Sinh, GLSLstd450Cosh, GLSLstd450Tanh, GLSLstd450Asinh, GLSLstd450Acosh, GLSLstd450Atanh, GLSLstd450Atan2, GLSLstd450Pow, GLSLstd450Exp, GLSLstd450Log, GLSLstd450Exp2, GLSLstd450Log2, GLSLstd450Sqrt, GLSLstd450InverseSqrt, GLSLstd450Determinant, GLSLstd450MatrixInverse, // TODO(greg-lunarg): GLSLstd450ModfStruct, GLSLstd450FMin, GLSLstd450FMax, GLSLstd450FClamp, GLSLstd450FMix, GLSLstd450Step, GLSLstd450SmoothStep, GLSLstd450Fma, // TODO(greg-lunarg): GLSLstd450FrexpStruct, GLSLstd450Ldexp, GLSLstd450Length, GLSLstd450Distance, GLSLstd450Cross, GLSLstd450Normalize, GLSLstd450FaceForward, GLSLstd450Reflect, GLSLstd450Refract, GLSLstd450NMin, GLSLstd450NMax, GLSLstd450NClamp}; sample_ops_ = {spv::Op::OpImageSampleImplicitLod, spv::Op::OpImageSampleExplicitLod, spv::Op::OpImageSampleDrefImplicitLod, spv::Op::OpImageSampleDrefExplicitLod, spv::Op::OpImageSampleProjImplicitLod, spv::Op::OpImageSampleProjExplicitLod, spv::Op::OpImageSampleProjDrefImplicitLod, spv::Op::OpImageSampleProjDrefExplicitLod, spv::Op::OpImageFetch, spv::Op::OpImageGather, spv::Op::OpImageDrefGather, spv::Op::OpImageRead, spv::Op::OpImageSparseSampleImplicitLod, spv::Op::OpImageSparseSampleExplicitLod, spv::Op::OpImageSparseSampleDrefImplicitLod, spv::Op::OpImageSparseSampleDrefExplicitLod, spv::Op::OpImageSparseSampleProjImplicitLod, spv::Op::OpImageSparseSampleProjExplicitLod, spv::Op::OpImageSparseSampleProjDrefImplicitLod, spv::Op::OpImageSparseSampleProjDrefExplicitLod, spv::Op::OpImageSparseFetch, spv::Op::OpImageSparseGather, spv::Op::OpImageSparseDrefGather, spv::Op::OpImageSparseTexelsResident, spv::Op::OpImageSparseRead}; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/relax_float_ops_pass.h000066400000000000000000000051351475742701700252170ustar00rootroot00000000000000// Copyright (c) 2019 Valve Corporation // Copyright (c) 2019 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef LIBSPIRV_OPT_RELAX_FLOAT_OPS_PASS_H_ #define LIBSPIRV_OPT_RELAX_FLOAT_OPS_PASS_H_ #include "source/opt/ir_builder.h" #include "source/opt/pass.h" namespace spvtools { namespace opt { class RelaxFloatOpsPass : public Pass { public: RelaxFloatOpsPass() : Pass() {} ~RelaxFloatOpsPass() override = default; IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping; } // See optimizer.hpp for pass user documentation. Status Process() override; const char* name() const override { return "convert-to-half-pass"; } private: // Return true if |inst| can have the RelaxedPrecision decoration applied // to it. bool IsRelaxable(Instruction* inst); // Return true if |inst| returns scalar, vector or matrix type with base // float and width 32 bool IsFloat32(Instruction* inst); // Return true if |r_id| is decorated with RelaxedPrecision bool IsRelaxed(uint32_t r_id); // If |inst| is an instruction of float32-based type and is not decorated // RelaxedPrecision, add such a decoration to the module. bool ProcessInst(Instruction* inst); // Call ProcessInst on every instruction in |func|. bool ProcessFunction(Function* func); Pass::Status ProcessImpl(); // Initialize state for converting to half void Initialize(); struct hasher { size_t operator()(const spv::Op& op) const noexcept { return std::hash()(uint32_t(op)); } }; // Set of float result core operations to be processed std::unordered_set target_ops_core_f_rslt_; // Set of float operand core operations to be processed std::unordered_set target_ops_core_f_opnd_; // Set of 450 extension operations to be processed std::unordered_set target_ops_450_; // Set of sample operations std::unordered_set sample_ops_; }; } // namespace opt } // namespace spvtools #endif // LIBSPIRV_OPT_RELAX_FLOAT_OPS_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/remove_dontinline_pass.cpp000066400000000000000000000032201475742701700261020ustar00rootroot00000000000000// Copyright (c) 2022 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/remove_dontinline_pass.h" namespace spvtools { namespace opt { Pass::Status RemoveDontInline::Process() { bool modified = false; modified = ClearDontInlineFunctionControl(); return (modified ? Status::SuccessWithChange : Status::SuccessWithoutChange); } bool RemoveDontInline::ClearDontInlineFunctionControl() { bool modified = false; for (auto& func : *get_module()) { ClearDontInlineFunctionControl(&func); } return modified; } bool RemoveDontInline::ClearDontInlineFunctionControl(Function* function) { constexpr uint32_t kFunctionControlInOperandIdx = 0; Instruction* function_inst = &function->DefInst(); uint32_t function_control = function_inst->GetSingleWordInOperand(kFunctionControlInOperandIdx); if ((function_control & uint32_t(spv::FunctionControlMask::DontInline)) == 0) { return false; } function_control &= ~uint32_t(spv::FunctionControlMask::DontInline); function_inst->SetInOperand(kFunctionControlInOperandIdx, {function_control}); return true; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/remove_dontinline_pass.h000066400000000000000000000025271475742701700255600ustar00rootroot00000000000000// Copyright (c) 2022 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_REMOVE_DONTINLINE_PASS_H_ #define SOURCE_OPT_REMOVE_DONTINLINE_PASS_H_ #include "source/opt/pass.h" namespace spvtools { namespace opt { // See optimizer.hpp for documentation. class RemoveDontInline : public Pass { public: const char* name() const override { return "remove-dont-inline"; } Status Process() override; private: // Clears the DontInline function control from every function in the module. // Returns true of a change was made. bool ClearDontInlineFunctionControl(); // Clears the DontInline function control from |function|. // Returns true of a change was made. bool ClearDontInlineFunctionControl(Function* function); }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_REMOVE_DONTINLINE_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/remove_duplicates_pass.cpp000066400000000000000000000146411475742701700261050ustar00rootroot00000000000000// Copyright (c) 2017 Pierre Moreau // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/remove_duplicates_pass.h" #include #include #include #include #include #include "source/opcode.h" #include "source/opt/decoration_manager.h" #include "source/opt/ir_context.h" namespace spvtools { namespace opt { Pass::Status RemoveDuplicatesPass::Process() { bool modified = RemoveDuplicateCapabilities(); modified |= RemoveDuplicatesExtInstImports(); modified |= RemoveDuplicateTypes(); modified |= RemoveDuplicateDecorations(); return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } bool RemoveDuplicatesPass::RemoveDuplicateCapabilities() const { bool modified = false; if (context()->capabilities().empty()) { return modified; } std::unordered_set capabilities; for (auto* i = &*context()->capability_begin(); i;) { auto res = capabilities.insert(i->GetSingleWordOperand(0u)); if (res.second) { // Never seen before, keep it. i = i->NextNode(); } else { // It's a duplicate, remove it. i = context()->KillInst(i); modified = true; } } return modified; } bool RemoveDuplicatesPass::RemoveDuplicatesExtInstImports() const { bool modified = false; if (context()->ext_inst_imports().empty()) { return modified; } std::unordered_map ext_inst_imports; for (auto* i = &*context()->ext_inst_import_begin(); i;) { auto res = ext_inst_imports.emplace(i->GetInOperand(0u).AsString(), i->result_id()); if (res.second) { // Never seen before, keep it. i = i->NextNode(); } else { // It's a duplicate, remove it. context()->ReplaceAllUsesWith(i->result_id(), res.first->second); i = context()->KillInst(i); modified = true; } } return modified; } bool RemoveDuplicatesPass::RemoveDuplicateTypes() const { bool modified = false; if (context()->types_values().empty()) { return modified; } analysis::TypeManager type_manager(context()->consumer(), context()); std::vector visited_types; std::vector visited_forward_pointers; std::vector to_delete; for (auto* i = &*context()->types_values_begin(); i; i = i->NextNode()) { const bool is_i_forward_pointer = i->opcode() == spv::Op::OpTypeForwardPointer; // We only care about types. if (!spvOpcodeGeneratesType(i->opcode()) && !is_i_forward_pointer) { continue; } if (!is_i_forward_pointer) { // Is the current type equal to one of the types we have already visited? spv::Id id_to_keep = 0u; analysis::Type* i_type = type_manager.GetType(i->result_id()); assert(i_type); // TODO(dneto0): Use a trie to avoid quadratic behaviour? Extract the // ResultIdTrie from unify_const_pass.cpp for this. for (auto j : visited_types) { analysis::Type* j_type = type_manager.GetType(j->result_id()); assert(j_type); if (*i_type == *j_type) { id_to_keep = j->result_id(); break; } } if (id_to_keep == 0u) { // This is a never seen before type, keep it around. visited_types.emplace_back(i); } else { // The same type has already been seen before, remove this one. context()->KillNamesAndDecorates(i->result_id()); context()->ReplaceAllUsesWith(i->result_id(), id_to_keep); modified = true; to_delete.emplace_back(i); } } else { analysis::ForwardPointer i_type( i->GetSingleWordInOperand(0u), (spv::StorageClass)i->GetSingleWordInOperand(1u)); i_type.SetTargetPointer( type_manager.GetType(i_type.target_id())->AsPointer()); // TODO(dneto0): Use a trie to avoid quadratic behaviour? Extract the // ResultIdTrie from unify_const_pass.cpp for this. const bool found_a_match = std::find(std::begin(visited_forward_pointers), std::end(visited_forward_pointers), i_type) != std::end(visited_forward_pointers); if (!found_a_match) { // This is a never seen before type, keep it around. visited_forward_pointers.emplace_back(i_type); } else { // The same type has already been seen before, remove this one. modified = true; to_delete.emplace_back(i); } } } for (auto i : to_delete) { context()->KillInst(i); } return modified; } // TODO(pierremoreau): Duplicate decoration groups should be removed. For // example, in // OpDecorate %1 Constant // %1 = OpDecorationGroup // OpDecorate %2 Constant // %2 = OpDecorationGroup // OpGroupDecorate %1 %3 // OpGroupDecorate %2 %4 // group %2 could be removed. bool RemoveDuplicatesPass::RemoveDuplicateDecorations() const { bool modified = false; std::vector visited_decorations; analysis::DecorationManager decoration_manager(context()->module()); for (auto* i = &*context()->annotation_begin(); i;) { // Is the current decoration equal to one of the decorations we have // already visited? bool already_visited = false; // TODO(dneto0): Use a trie to avoid quadratic behaviour? Extract the // ResultIdTrie from unify_const_pass.cpp for this. for (const Instruction* j : visited_decorations) { if (decoration_manager.AreDecorationsTheSame(&*i, j, false)) { already_visited = true; break; } } if (!already_visited) { // This is a never seen before decoration, keep it around. visited_decorations.emplace_back(&*i); i = i->NextNode(); } else { // The same decoration has already been seen before, remove this one. modified = true; i = context()->KillInst(i); } } return modified; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/remove_duplicates_pass.h000066400000000000000000000037041475742701700255500ustar00rootroot00000000000000// Copyright (c) 2017 Pierre Moreau // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_REMOVE_DUPLICATES_PASS_H_ #define SOURCE_OPT_REMOVE_DUPLICATES_PASS_H_ #include #include #include "source/opt/decoration_manager.h" #include "source/opt/def_use_manager.h" #include "source/opt/ir_context.h" #include "source/opt/module.h" #include "source/opt/pass.h" namespace spvtools { namespace opt { using IdDecorationsList = std::unordered_map>; // See optimizer.hpp for documentation. class RemoveDuplicatesPass : public Pass { public: const char* name() const override { return "remove-duplicates"; } Status Process() override; private: // Remove duplicate capabilities from the module // // Returns true if the module was modified, false otherwise. bool RemoveDuplicateCapabilities() const; // Remove duplicate extended instruction imports from the module // // Returns true if the module was modified, false otherwise. bool RemoveDuplicatesExtInstImports() const; // Remove duplicate types from the module // // Returns true if the module was modified, false otherwise. bool RemoveDuplicateTypes() const; // Remove duplicate decorations from the module // // Returns true if the module was modified, false otherwise. bool RemoveDuplicateDecorations() const; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_REMOVE_DUPLICATES_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/remove_unused_interface_variables_pass.cpp000066400000000000000000000066751475742701700313330ustar00rootroot00000000000000// Copyright (c) 2021 ZHOU He // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "remove_unused_interface_variables_pass.h" #include "source/spirv_constant.h" namespace spvtools { namespace opt { class RemoveUnusedInterfaceVariablesContext { RemoveUnusedInterfaceVariablesPass& parent_; Instruction& entry_; std::unordered_set used_variables_; std::vector operands_to_add_; IRContext::ProcessFunction pfn_ = std::bind(&RemoveUnusedInterfaceVariablesContext::processFunction, this, std::placeholders::_1); bool processFunction(Function* func) { for (const auto& basic_block : *func) for (const auto& instruction : basic_block) instruction.ForEachInId([&](const uint32_t* id) { if (used_variables_.count(*id)) return; auto* var = parent_.get_def_use_mgr()->GetDef(*id); if (!var || var->opcode() != spv::Op::OpVariable) return; auto storage_class = spv::StorageClass(var->GetSingleWordInOperand(0)); if (storage_class != spv::StorageClass::Function && (parent_.get_module()->version() >= SPV_SPIRV_VERSION_WORD(1, 4) || storage_class == spv::StorageClass::Input || storage_class == spv::StorageClass::Output)) { used_variables_.insert(*id); operands_to_add_.push_back(*id); } }); return false; } public: RemoveUnusedInterfaceVariablesContext( RemoveUnusedInterfaceVariablesPass& parent, Instruction& entry) : parent_(parent), entry_(entry) {} void CollectUsedVariables() { std::queue roots; roots.push(entry_.GetSingleWordInOperand(1)); parent_.context()->ProcessCallTreeFromRoots(pfn_, &roots); } bool ShouldModify() { std::unordered_set old_variables; for (int i = entry_.NumInOperands() - 1; i >= 3; --i) { auto variable = entry_.GetInOperand(i).words[0]; if (!used_variables_.count(variable)) return true; // It is unused. if (old_variables.count(variable)) return true; // It is duplicate. old_variables.insert(variable); } if (old_variables.size() != used_variables_.size()) // Missing IDs. return true; return false; } void Modify() { for (int i = entry_.NumInOperands() - 1; i >= 3; --i) entry_.RemoveInOperand(i); for (auto id : operands_to_add_) { entry_.AddOperand(Operand(SPV_OPERAND_TYPE_ID, {id})); } } }; RemoveUnusedInterfaceVariablesPass::Status RemoveUnusedInterfaceVariablesPass::Process() { bool modified = false; for (auto& entry : get_module()->entry_points()) { RemoveUnusedInterfaceVariablesContext context(*this, entry); context.CollectUsedVariables(); if (context.ShouldModify()) { context.Modify(); modified = true; } } return (modified ? Status::SuccessWithChange : Status::SuccessWithoutChange); } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/remove_unused_interface_variables_pass.h000066400000000000000000000020601475742701700307600ustar00rootroot00000000000000// Copyright (c) 2021 ZHOU He // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_REMOVE_UNUSED_INTERFACE_VARIABLES_PASS_H_ #define SOURCE_OPT_REMOVE_UNUSED_INTERFACE_VARIABLES_PASS_H_ #include "source/opt/pass.h" namespace spvtools { namespace opt { class RemoveUnusedInterfaceVariablesPass : public Pass { const char* name() const override { return "remove-unused-interface-variables-pass"; } Status Process() override; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_REMOVE_UNUSED_INTERFACE_VARIABLES_PASS_H_KhronosGroup-SPIRV-Tools-f289d04/source/opt/replace_desc_array_access_using_var_index.cpp000066400000000000000000000417011475742701700317360ustar00rootroot00000000000000// Copyright (c) 2021 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/replace_desc_array_access_using_var_index.h" #include "source/opt/desc_sroa_util.h" #include "source/opt/ir_builder.h" #include "source/util/string_utils.h" namespace spvtools { namespace opt { namespace { constexpr uint32_t kOpAccessChainInOperandIndexes = 1; constexpr uint32_t kOpTypePointerInOperandType = 1; constexpr uint32_t kOpTypeArrayInOperandType = 0; constexpr uint32_t kOpTypeStructInOperandMember = 0; IRContext::Analysis kAnalysisDefUseAndInstrToBlockMapping = IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping; uint32_t GetValueWithKeyExistenceCheck( uint32_t key, const std::unordered_map& map) { auto itr = map.find(key); assert(itr != map.end() && "Key does not exist"); return itr->second; } } // namespace Pass::Status ReplaceDescArrayAccessUsingVarIndex::Process() { Status status = Status::SuccessWithoutChange; for (Instruction& var : context()->types_values()) { if (descsroautil::IsDescriptorArray(context(), &var)) { if (ReplaceVariableAccessesWithConstantElements(&var)) status = Status::SuccessWithChange; } } return status; } bool ReplaceDescArrayAccessUsingVarIndex:: ReplaceVariableAccessesWithConstantElements(Instruction* var) const { std::vector work_list; get_def_use_mgr()->ForEachUser(var, [&work_list](Instruction* use) { switch (use->opcode()) { case spv::Op::OpAccessChain: case spv::Op::OpInBoundsAccessChain: work_list.push_back(use); break; default: break; } }); bool updated = false; for (Instruction* access_chain : work_list) { if (descsroautil::GetAccessChainIndexAsConst(context(), access_chain) == nullptr) { ReplaceAccessChain(var, access_chain); updated = true; } } // Note that we do not consider OpLoad and OpCompositeExtract because // OpCompositeExtract always has constant literals for indices. return updated; } void ReplaceDescArrayAccessUsingVarIndex::ReplaceAccessChain( Instruction* var, Instruction* access_chain) const { uint32_t number_of_elements = descsroautil::GetNumberOfElementsForArrayOrStruct(context(), var); assert(number_of_elements != 0 && "Number of element is 0"); if (number_of_elements == 1) { UseConstIndexForAccessChain(access_chain, 0); get_def_use_mgr()->AnalyzeInstUse(access_chain); return; } ReplaceUsersOfAccessChain(access_chain, number_of_elements); } void ReplaceDescArrayAccessUsingVarIndex::ReplaceUsersOfAccessChain( Instruction* access_chain, uint32_t number_of_elements) const { std::vector final_users; CollectRecursiveUsersWithConcreteType(access_chain, &final_users); for (auto* inst : final_users) { std::deque insts_to_be_cloned = CollectRequiredImageAndAccessInsts(inst); ReplaceNonUniformAccessWithSwitchCase( inst, access_chain, number_of_elements, insts_to_be_cloned); } } void ReplaceDescArrayAccessUsingVarIndex::CollectRecursiveUsersWithConcreteType( Instruction* access_chain, std::vector* final_users) const { std::queue work_list; work_list.push(access_chain); while (!work_list.empty()) { auto* inst_from_work_list = work_list.front(); work_list.pop(); get_def_use_mgr()->ForEachUser( inst_from_work_list, [this, final_users, &work_list](Instruction* use) { // TODO: Support Boolean type as well. if (!use->HasResultId() || IsConcreteType(use->type_id())) { final_users->push_back(use); } else { work_list.push(use); } }); } } std::deque ReplaceDescArrayAccessUsingVarIndex::CollectRequiredImageAndAccessInsts( Instruction* user) const { std::unordered_set seen_inst_ids; std::queue work_list; auto decision_to_include_operand = [this, &seen_inst_ids, &work_list](uint32_t* idp) { if (!seen_inst_ids.insert(*idp).second) return; Instruction* operand = get_def_use_mgr()->GetDef(*idp); if (context()->get_instr_block(operand) != nullptr && (HasImageOrImagePtrType(operand) || operand->opcode() == spv::Op::OpAccessChain || operand->opcode() == spv::Op::OpInBoundsAccessChain)) { work_list.push(operand); } }; std::deque required_insts; required_insts.push_front(user); user->ForEachInId(decision_to_include_operand); while (!work_list.empty()) { auto* inst_from_work_list = work_list.front(); work_list.pop(); required_insts.push_front(inst_from_work_list); inst_from_work_list->ForEachInId(decision_to_include_operand); } return required_insts; } bool ReplaceDescArrayAccessUsingVarIndex::HasImageOrImagePtrType( const Instruction* inst) const { assert(inst != nullptr && inst->type_id() != 0 && "Invalid instruction"); return IsImageOrImagePtrType(get_def_use_mgr()->GetDef(inst->type_id())); } bool ReplaceDescArrayAccessUsingVarIndex::IsImageOrImagePtrType( const Instruction* type_inst) const { if (type_inst->opcode() == spv::Op::OpTypeImage || type_inst->opcode() == spv::Op::OpTypeSampler || type_inst->opcode() == spv::Op::OpTypeSampledImage) { return true; } if (type_inst->opcode() == spv::Op::OpTypePointer) { Instruction* pointee_type_inst = get_def_use_mgr()->GetDef( type_inst->GetSingleWordInOperand(kOpTypePointerInOperandType)); return IsImageOrImagePtrType(pointee_type_inst); } if (type_inst->opcode() == spv::Op::OpTypeArray) { Instruction* element_type_inst = get_def_use_mgr()->GetDef( type_inst->GetSingleWordInOperand(kOpTypeArrayInOperandType)); return IsImageOrImagePtrType(element_type_inst); } if (type_inst->opcode() != spv::Op::OpTypeStruct) return false; for (uint32_t in_operand_idx = kOpTypeStructInOperandMember; in_operand_idx < type_inst->NumInOperands(); ++in_operand_idx) { Instruction* member_type_inst = get_def_use_mgr()->GetDef( type_inst->GetSingleWordInOperand(kOpTypeStructInOperandMember)); if (IsImageOrImagePtrType(member_type_inst)) return true; } return false; } bool ReplaceDescArrayAccessUsingVarIndex::IsConcreteType( uint32_t type_id) const { Instruction* type_inst = get_def_use_mgr()->GetDef(type_id); if (type_inst->opcode() == spv::Op::OpTypeInt || type_inst->opcode() == spv::Op::OpTypeFloat) { return true; } if (type_inst->opcode() == spv::Op::OpTypeVector || type_inst->opcode() == spv::Op::OpTypeMatrix || type_inst->opcode() == spv::Op::OpTypeArray) { return IsConcreteType(type_inst->GetSingleWordInOperand(0)); } if (type_inst->opcode() == spv::Op::OpTypeStruct) { for (uint32_t i = 0; i < type_inst->NumInOperands(); ++i) { if (!IsConcreteType(type_inst->GetSingleWordInOperand(i))) return false; } return true; } return false; } BasicBlock* ReplaceDescArrayAccessUsingVarIndex::CreateCaseBlock( Instruction* access_chain, uint32_t element_index, const std::deque& insts_to_be_cloned, uint32_t branch_target_id, std::unordered_map* old_ids_to_new_ids) const { auto* case_block = CreateNewBlock(); AddConstElementAccessToCaseBlock(case_block, access_chain, element_index, old_ids_to_new_ids); CloneInstsToBlock(case_block, access_chain, insts_to_be_cloned, old_ids_to_new_ids); AddBranchToBlock(case_block, branch_target_id); UseNewIdsInBlock(case_block, *old_ids_to_new_ids); return case_block; } void ReplaceDescArrayAccessUsingVarIndex::CloneInstsToBlock( BasicBlock* block, Instruction* inst_to_skip_cloning, const std::deque& insts_to_be_cloned, std::unordered_map* old_ids_to_new_ids) const { for (auto* inst_to_be_cloned : insts_to_be_cloned) { if (inst_to_be_cloned == inst_to_skip_cloning) continue; std::unique_ptr clone(inst_to_be_cloned->Clone(context())); if (inst_to_be_cloned->HasResultId()) { uint32_t new_id = context()->TakeNextId(); clone->SetResultId(new_id); (*old_ids_to_new_ids)[inst_to_be_cloned->result_id()] = new_id; } get_def_use_mgr()->AnalyzeInstDefUse(clone.get()); context()->set_instr_block(clone.get(), block); block->AddInstruction(std::move(clone)); } } void ReplaceDescArrayAccessUsingVarIndex::UseNewIdsInBlock( BasicBlock* block, const std::unordered_map& old_ids_to_new_ids) const { for (auto block_itr = block->begin(); block_itr != block->end(); ++block_itr) { (&*block_itr)->ForEachInId([&old_ids_to_new_ids](uint32_t* idp) { auto old_ids_to_new_ids_itr = old_ids_to_new_ids.find(*idp); if (old_ids_to_new_ids_itr == old_ids_to_new_ids.end()) return; *idp = old_ids_to_new_ids_itr->second; }); get_def_use_mgr()->AnalyzeInstUse(&*block_itr); } } void ReplaceDescArrayAccessUsingVarIndex::ReplaceNonUniformAccessWithSwitchCase( Instruction* access_chain_final_user, Instruction* access_chain, uint32_t number_of_elements, const std::deque& insts_to_be_cloned) const { auto* block = context()->get_instr_block(access_chain_final_user); // If the instruction does not belong to a block (i.e. in the case of // OpDecorate), no replacement is needed. if (!block) return; // Create merge block and add terminator auto* merge_block = SeparateInstructionsIntoNewBlock( block, access_chain_final_user->NextNode()); auto* function = block->GetParent(); // Add case blocks std::vector phi_operands; std::vector case_block_ids; for (uint32_t idx = 0; idx < number_of_elements; ++idx) { std::unordered_map old_ids_to_new_ids_for_cloned_insts; std::unique_ptr case_block(CreateCaseBlock( access_chain, idx, insts_to_be_cloned, merge_block->id(), &old_ids_to_new_ids_for_cloned_insts)); case_block_ids.push_back(case_block->id()); function->InsertBasicBlockBefore(std::move(case_block), merge_block); // Keep the operand for OpPhi if (!access_chain_final_user->HasResultId()) continue; uint32_t phi_operand = GetValueWithKeyExistenceCheck(access_chain_final_user->result_id(), old_ids_to_new_ids_for_cloned_insts); phi_operands.push_back(phi_operand); } // Create default block std::unique_ptr default_block( CreateDefaultBlock(access_chain_final_user->HasResultId(), &phi_operands, merge_block->id())); uint32_t default_block_id = default_block->id(); function->InsertBasicBlockBefore(std::move(default_block), merge_block); // Create OpSwitch uint32_t access_chain_index_var_id = descsroautil::GetFirstIndexOfAccessChain(access_chain); AddSwitchForAccessChain(block, access_chain_index_var_id, default_block_id, merge_block->id(), case_block_ids); // Create phi instructions if (!phi_operands.empty()) { uint32_t phi_id = CreatePhiInstruction(merge_block, phi_operands, case_block_ids, default_block_id); context()->ReplaceAllUsesWith(access_chain_final_user->result_id(), phi_id); } // Replace OpPhi incoming block operand that uses |block| with |merge_block| ReplacePhiIncomingBlock(block->id(), merge_block->id()); } BasicBlock* ReplaceDescArrayAccessUsingVarIndex::SeparateInstructionsIntoNewBlock( BasicBlock* block, Instruction* separation_begin_inst) const { auto separation_begin = block->begin(); while (separation_begin != block->end() && &*separation_begin != separation_begin_inst) { ++separation_begin; } return block->SplitBasicBlock(context(), context()->TakeNextId(), separation_begin); } BasicBlock* ReplaceDescArrayAccessUsingVarIndex::CreateNewBlock() const { auto* new_block = new BasicBlock(std::unique_ptr(new Instruction( context(), spv::Op::OpLabel, 0, context()->TakeNextId(), {}))); get_def_use_mgr()->AnalyzeInstDefUse(new_block->GetLabelInst()); context()->set_instr_block(new_block->GetLabelInst(), new_block); return new_block; } void ReplaceDescArrayAccessUsingVarIndex::UseConstIndexForAccessChain( Instruction* access_chain, uint32_t const_element_idx) const { uint32_t const_element_idx_id = context()->get_constant_mgr()->GetUIntConstId(const_element_idx); access_chain->SetInOperand(kOpAccessChainInOperandIndexes, {const_element_idx_id}); } void ReplaceDescArrayAccessUsingVarIndex::AddConstElementAccessToCaseBlock( BasicBlock* case_block, Instruction* access_chain, uint32_t const_element_idx, std::unordered_map* old_ids_to_new_ids) const { std::unique_ptr access_clone(access_chain->Clone(context())); UseConstIndexForAccessChain(access_clone.get(), const_element_idx); uint32_t new_access_id = context()->TakeNextId(); (*old_ids_to_new_ids)[access_clone->result_id()] = new_access_id; access_clone->SetResultId(new_access_id); get_def_use_mgr()->AnalyzeInstDefUse(access_clone.get()); context()->set_instr_block(access_clone.get(), case_block); case_block->AddInstruction(std::move(access_clone)); } void ReplaceDescArrayAccessUsingVarIndex::AddBranchToBlock( BasicBlock* parent_block, uint32_t branch_destination) const { InstructionBuilder builder{context(), parent_block, kAnalysisDefUseAndInstrToBlockMapping}; builder.AddBranch(branch_destination); } BasicBlock* ReplaceDescArrayAccessUsingVarIndex::CreateDefaultBlock( bool null_const_for_phi_is_needed, std::vector* phi_operands, uint32_t merge_block_id) const { auto* default_block = CreateNewBlock(); AddBranchToBlock(default_block, merge_block_id); if (!null_const_for_phi_is_needed) return default_block; // Create null value for OpPhi Instruction* inst = context()->get_def_use_mgr()->GetDef((*phi_operands)[0]); auto* null_const_inst = GetConstNull(inst->type_id()); phi_operands->push_back(null_const_inst->result_id()); return default_block; } Instruction* ReplaceDescArrayAccessUsingVarIndex::GetConstNull( uint32_t type_id) const { assert(type_id != 0 && "Result type is expected"); auto* type = context()->get_type_mgr()->GetType(type_id); auto* null_const = context()->get_constant_mgr()->GetConstant(type, {}); return context()->get_constant_mgr()->GetDefiningInstruction(null_const); } void ReplaceDescArrayAccessUsingVarIndex::AddSwitchForAccessChain( BasicBlock* parent_block, uint32_t access_chain_index_var_id, uint32_t default_id, uint32_t merge_id, const std::vector& case_block_ids) const { InstructionBuilder builder{context(), parent_block, kAnalysisDefUseAndInstrToBlockMapping}; std::vector> cases; for (uint32_t i = 0; i < static_cast(case_block_ids.size()); ++i) { cases.emplace_back(Operand::OperandData{i}, case_block_ids[i]); } builder.AddSwitch(access_chain_index_var_id, default_id, cases, merge_id); } uint32_t ReplaceDescArrayAccessUsingVarIndex::CreatePhiInstruction( BasicBlock* parent_block, const std::vector& phi_operands, const std::vector& case_block_ids, uint32_t default_block_id) const { std::vector incomings; assert(case_block_ids.size() + 1 == phi_operands.size() && "Number of Phi operands must be exactly 1 bigger than the one of case " "blocks"); for (size_t i = 0; i < case_block_ids.size(); ++i) { incomings.push_back(phi_operands[i]); incomings.push_back(case_block_ids[i]); } incomings.push_back(phi_operands.back()); incomings.push_back(default_block_id); InstructionBuilder builder{context(), &*parent_block->begin(), kAnalysisDefUseAndInstrToBlockMapping}; uint32_t phi_result_type_id = context()->get_def_use_mgr()->GetDef(phi_operands[0])->type_id(); auto* phi = builder.AddPhi(phi_result_type_id, incomings); return phi->result_id(); } void ReplaceDescArrayAccessUsingVarIndex::ReplacePhiIncomingBlock( uint32_t old_incoming_block_id, uint32_t new_incoming_block_id) const { context()->ReplaceAllUsesWithPredicate( old_incoming_block_id, new_incoming_block_id, [](Instruction* use) { return use->opcode() == spv::Op::OpPhi; }); } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/replace_desc_array_access_using_var_index.h000066400000000000000000000226461475742701700314120ustar00rootroot00000000000000// Copyright (c) 2021 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_REPLACE_DESC_VAR_INDEX_ACCESS_H_ #define SOURCE_OPT_REPLACE_DESC_VAR_INDEX_ACCESS_H_ #include #include #include #include #include #include #include "source/opt/function.h" #include "source/opt/pass.h" #include "source/opt/type_manager.h" namespace spvtools { namespace opt { // See optimizer.hpp for documentation. class ReplaceDescArrayAccessUsingVarIndex : public Pass { public: ReplaceDescArrayAccessUsingVarIndex() {} const char* name() const override { return "replace-desc-array-access-using-var-index"; } Status Process() override; IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisConstants | IRContext::kAnalysisTypes; } private: // Replaces all accesses to |var| using variable indices with constant // elements of the array |var|. Creates switch-case statements to determine // the value of the variable index for all the possible cases. Returns // whether replacement is done or not. bool ReplaceVariableAccessesWithConstantElements(Instruction* var) const; // Replaces the OpAccessChain or OpInBoundsAccessChain instruction |use| that // uses the descriptor variable |var| with the OpAccessChain or // OpInBoundsAccessChain instruction with a constant Indexes operand. void ReplaceAccessChain(Instruction* var, Instruction* use) const; // Updates the first Indexes operand of the OpAccessChain or // OpInBoundsAccessChain instruction |access_chain| to let it use a constant // index |const_element_idx|. void UseConstIndexForAccessChain(Instruction* access_chain, uint32_t const_element_idx) const; // Replaces users of the OpAccessChain or OpInBoundsAccessChain instruction // |access_chain| that accesses an array descriptor variable using variable // indices with constant elements. |number_of_elements| is the number // of array elements. void ReplaceUsersOfAccessChain(Instruction* access_chain, uint32_t number_of_elements) const; // Puts all the recursive users of |access_chain| with concrete result types // or the ones without result it in |final_users|. void CollectRecursiveUsersWithConcreteType( Instruction* access_chain, std::vector* final_users) const; // Recursively collects the operands of |user| (and operands of the operands) // whose result types are images/samplers (or pointers/arrays/ structs of // them) and access chains instructions and returns them. The returned // collection includes |user|. std::deque CollectRequiredImageAndAccessInsts( Instruction* user) const; // Returns whether result type of |inst| is an image/sampler/pointer of image // or sampler or not. bool HasImageOrImagePtrType(const Instruction* inst) const; // Returns whether |type_inst| is an image/sampler or pointer/array/struct of // image or sampler or not. bool IsImageOrImagePtrType(const Instruction* type_inst) const; // Returns whether the type with |type_id| is a concrete type or not. bool IsConcreteType(uint32_t type_id) const; // Replaces the non-uniform access to a descriptor variable // |access_chain_final_user| with OpSwitch instruction and case blocks. Each // case block will contain a clone of |access_chain| and clones of // |non_uniform_accesses_to_clone| that are recursively used by // |access_chain_final_user|. The clone of |access_chain| (or // OpInBoundsAccessChain) will have a constant index for its first index. The // OpSwitch instruction will have the cases for the variable index of // |access_chain| from 0 to |number_of_elements| - 1. void ReplaceNonUniformAccessWithSwitchCase( Instruction* access_chain_final_user, Instruction* access_chain, uint32_t number_of_elements, const std::deque& non_uniform_accesses_to_clone) const; // Creates and returns a new basic block that contains all instructions of // |block| after |separation_begin_inst|. The new basic block is added to the // function in this method. BasicBlock* SeparateInstructionsIntoNewBlock( BasicBlock* block, Instruction* separation_begin_inst) const; // Creates and returns a new block. BasicBlock* CreateNewBlock() const; // Returns the first operand id of the OpAccessChain or OpInBoundsAccessChain // instruction |access_chain|. uint32_t GetFirstIndexOfAccessChain(Instruction* access_chain) const; // Adds a clone of the OpAccessChain or OpInBoundsAccessChain instruction // |access_chain| to |case_block|. The clone of |access_chain| will use // |const_element_idx| for its first index. |old_ids_to_new_ids| keeps the // mapping from the result id of |access_chain| to the result of its clone. void AddConstElementAccessToCaseBlock( BasicBlock* case_block, Instruction* access_chain, uint32_t const_element_idx, std::unordered_map* old_ids_to_new_ids) const; // Clones all instructions in |insts_to_be_cloned| and put them to |block|. // |old_ids_to_new_ids| keeps the mapping from the result id of each // instruction of |insts_to_be_cloned| to the result of their clones. void CloneInstsToBlock( BasicBlock* block, Instruction* inst_to_skip_cloning, const std::deque& insts_to_be_cloned, std::unordered_map* old_ids_to_new_ids) const; // Adds OpBranch to |branch_destination| at the end of |parent_block|. void AddBranchToBlock(BasicBlock* parent_block, uint32_t branch_destination) const; // Replaces in-operands of all instructions in the basic block |block| using // |old_ids_to_new_ids|. It conducts the replacement only if the in-operand // id is a key of |old_ids_to_new_ids|. void UseNewIdsInBlock( BasicBlock* block, const std::unordered_map& old_ids_to_new_ids) const; // Creates a case block for |element_index| case. It adds clones of // |insts_to_be_cloned| and a clone of |access_chain| with |element_index| as // its first index. The termination instruction of the created case block will // be a branch to |branch_target_id|. Puts old ids to new ids map for the // cloned instructions in |old_ids_to_new_ids|. BasicBlock* CreateCaseBlock( Instruction* access_chain, uint32_t element_index, const std::deque& insts_to_be_cloned, uint32_t branch_target_id, std::unordered_map* old_ids_to_new_ids) const; // Creates a default block for switch-case statement that has only a single // instruction OpBranch whose target is a basic block with |merge_block_id|. // If |null_const_for_phi_is_needed| is true, gets or creates a default null // constant value for a phi instruction whose operands are |phi_operands| and // puts it in |phi_operands|. BasicBlock* CreateDefaultBlock(bool null_const_for_phi_is_needed, std::vector* phi_operands, uint32_t merge_block_id) const; // Creates and adds an OpSwitch used for the selection of OpAccessChain whose // first Indexes operand is |access_chain_index_var_id|. The OpSwitch will be // added at the end of |parent_block|. It will jump to |default_id| for the // default case and jumps to one of case blocks whose ids are |case_block_ids| // if |access_chain_index_var_id| matches the case number. |merge_id| is the // merge block id. void AddSwitchForAccessChain( BasicBlock* parent_block, uint32_t access_chain_index_var_id, uint32_t default_id, uint32_t merge_id, const std::vector& case_block_ids) const; // Creates a phi instruction with |phi_operands| as values and // |case_block_ids| and |default_block_id| as incoming blocks. The size of // |phi_operands| must be exactly 1 larger than the size of |case_block_ids|. // The last element of |phi_operands| will be used for |default_block_id|. It // adds the phi instruction to the beginning of |parent_block|. uint32_t CreatePhiInstruction(BasicBlock* parent_block, const std::vector& phi_operands, const std::vector& case_block_ids, uint32_t default_block_id) const; // Replaces the incoming block operand of OpPhi instructions with // |new_incoming_block_id| if the incoming block operand is // |old_incoming_block_id|. void ReplacePhiIncomingBlock(uint32_t old_incoming_block_id, uint32_t new_incoming_block_id) const; // Create an OpConstantNull instruction whose result type id is |type_id|. Instruction* GetConstNull(uint32_t type_id) const; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_REPLACE_DESC_VAR_INDEX_ACCESS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/replace_invalid_opc.cpp000066400000000000000000000176521475742701700253340ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/replace_invalid_opc.h" #include #include namespace spvtools { namespace opt { Pass::Status ReplaceInvalidOpcodePass::Process() { bool modified = false; if (context()->get_feature_mgr()->HasCapability(spv::Capability::Linkage)) { return Status::SuccessWithoutChange; } spv::ExecutionModel execution_model = GetExecutionModel(); if (execution_model == spv::ExecutionModel::Kernel) { // We do not handle kernels. return Status::SuccessWithoutChange; } if (execution_model == spv::ExecutionModel::Max) { // Mixed execution models for the entry points. This case is not currently // handled. return Status::SuccessWithoutChange; } for (Function& func : *get_module()) { modified |= RewriteFunction(&func, execution_model); } return (modified ? Status::SuccessWithChange : Status::SuccessWithoutChange); } spv::ExecutionModel ReplaceInvalidOpcodePass::GetExecutionModel() { spv::ExecutionModel result = spv::ExecutionModel::Max; bool first = true; for (Instruction& entry_point : get_module()->entry_points()) { if (first) { result = static_cast( entry_point.GetSingleWordInOperand(0)); first = false; } else { spv::ExecutionModel current_model = static_cast( entry_point.GetSingleWordInOperand(0)); if (current_model != result) { result = spv::ExecutionModel::Max; break; } } } return result; } bool ReplaceInvalidOpcodePass::RewriteFunction(Function* function, spv::ExecutionModel model) { bool modified = false; Instruction* last_line_dbg_inst = nullptr; function->ForEachInst( [model, &modified, &last_line_dbg_inst, this](Instruction* inst) { // Track the debug information so we can have a meaningful message. if (inst->opcode() == spv::Op::OpLabel || inst->IsNoLine()) { last_line_dbg_inst = nullptr; return; } else if (inst->IsLine()) { last_line_dbg_inst = inst; return; } bool replace = false; if (model != spv::ExecutionModel::Fragment && IsFragmentShaderOnlyInstruction(inst)) { replace = true; } if (model != spv::ExecutionModel::TessellationControl && model != spv::ExecutionModel::GLCompute && !context()->IsTargetEnvAtLeast(SPV_ENV_UNIVERSAL_1_3)) { if (inst->opcode() == spv::Op::OpControlBarrier) { assert(model != spv::ExecutionModel::Kernel && "Expecting to be working on a shader module."); replace = true; } } if (replace) { modified = true; if (last_line_dbg_inst == nullptr) { ReplaceInstruction(inst, nullptr, 0, 0); } else { // Get the name of the source file. uint32_t file_name_id = 0; if (last_line_dbg_inst->opcode() == spv::Op::OpLine) { file_name_id = last_line_dbg_inst->GetSingleWordInOperand(0); } else { // Shader100::DebugLine uint32_t debug_source_id = last_line_dbg_inst->GetSingleWordInOperand(2); Instruction* debug_source_inst = context()->get_def_use_mgr()->GetDef(debug_source_id); file_name_id = debug_source_inst->GetSingleWordInOperand(2); } Instruction* file_name = context()->get_def_use_mgr()->GetDef(file_name_id); const std::string source = file_name->GetInOperand(0).AsString(); // Get the line number and column number. uint32_t line_number = last_line_dbg_inst->GetSingleWordInOperand(1); uint32_t col_number = last_line_dbg_inst->GetSingleWordInOperand(2); // Replace the instruction. ReplaceInstruction(inst, source.c_str(), line_number, col_number); } } }, /* run_on_debug_line_insts = */ true); return modified; } bool ReplaceInvalidOpcodePass::IsFragmentShaderOnlyInstruction( Instruction* inst) { switch (inst->opcode()) { case spv::Op::OpDPdx: case spv::Op::OpDPdy: case spv::Op::OpFwidth: case spv::Op::OpDPdxFine: case spv::Op::OpDPdyFine: case spv::Op::OpFwidthFine: case spv::Op::OpDPdxCoarse: case spv::Op::OpDPdyCoarse: case spv::Op::OpFwidthCoarse: case spv::Op::OpImageSampleImplicitLod: case spv::Op::OpImageSampleDrefImplicitLod: case spv::Op::OpImageSampleProjImplicitLod: case spv::Op::OpImageSampleProjDrefImplicitLod: case spv::Op::OpImageSparseSampleImplicitLod: case spv::Op::OpImageSparseSampleDrefImplicitLod: case spv::Op::OpImageQueryLod: // TODO: Teach |ReplaceInstruction| to handle block terminators. Then // uncomment the OpKill case. // case spv::Op::OpKill: // case spv::Op::OpTerminateInstruction: return true; default: return false; } } void ReplaceInvalidOpcodePass::ReplaceInstruction(Instruction* inst, const char* source, uint32_t line_number, uint32_t column_number) { if (inst->result_id() != 0) { uint32_t const_id = GetSpecialConstant(inst->type_id()); context()->KillNamesAndDecorates(inst); context()->ReplaceAllUsesWith(inst->result_id(), const_id); } assert(!inst->IsBlockTerminator() && "We cannot simply delete a block terminator. It must be replaced " "with something."); if (consumer()) { std::string message = BuildWarningMessage(inst->opcode()); consumer()(SPV_MSG_WARNING, source, {line_number, column_number, 0}, message.c_str()); } context()->KillInst(inst); } uint32_t ReplaceInvalidOpcodePass::GetSpecialConstant(uint32_t type_id) { const analysis::Constant* special_const = nullptr; analysis::ConstantManager* const_mgr = context()->get_constant_mgr(); analysis::TypeManager* type_mgr = context()->get_type_mgr(); Instruction* type = context()->get_def_use_mgr()->GetDef(type_id); if (type->opcode() == spv::Op::OpTypeVector) { uint32_t component_const = GetSpecialConstant(type->GetSingleWordInOperand(0)); std::vector ids; for (uint32_t i = 0; i < type->GetSingleWordInOperand(1); ++i) { ids.push_back(component_const); } special_const = const_mgr->GetConstant(type_mgr->GetType(type_id), ids); } else { assert(type->opcode() == spv::Op::OpTypeInt || type->opcode() == spv::Op::OpTypeFloat); std::vector literal_words; for (uint32_t i = 0; i < type->GetSingleWordInOperand(0); i += 32) { literal_words.push_back(0xDEADBEEF); } special_const = const_mgr->GetConstant(type_mgr->GetType(type_id), literal_words); } assert(special_const != nullptr); return const_mgr->GetDefiningInstruction(special_const)->result_id(); } std::string ReplaceInvalidOpcodePass::BuildWarningMessage(spv::Op opcode) { spv_opcode_desc opcode_info; context()->grammar().lookupOpcode(opcode, &opcode_info); std::string message = "Removing "; message += opcode_info->name; message += " instruction because of incompatible execution model."; return message; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/replace_invalid_opc.h000066400000000000000000000054041475742701700247710ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_REPLACE_INVALID_OPC_H_ #define SOURCE_OPT_REPLACE_INVALID_OPC_H_ #include #include "source/opt/pass.h" namespace spvtools { namespace opt { // This pass will runs on shader modules only. It will replace the result of // instructions that are valid for shader modules, but not the current shader // stage, with a constant value. If the instruction does not have a return // value, the instruction will simply be deleted. class ReplaceInvalidOpcodePass : public Pass { public: const char* name() const override { return "replace-invalid-opcode"; } Status Process() override; private: // Returns the execution model that is used by every entry point in the // module. If more than one execution model is used in the module, then the // return value is spv::ExecutionModel::Max. spv::ExecutionModel GetExecutionModel(); // Replaces all instructions in |function| that are invalid with execution // model |mode|, but valid for another shader model, with a special constant // value. See |GetSpecialConstant|. bool RewriteFunction(Function* function, spv::ExecutionModel mode); // Returns true if |inst| is valid for fragment shaders only. bool IsFragmentShaderOnlyInstruction(Instruction* inst); // Replaces all uses of the result of |inst|, if there is one, with the id of // a special constant. Then |inst| is killed. |inst| cannot be a block // terminator because the basic block will then become invalid. |inst| is no // longer valid after calling this function. void ReplaceInstruction(Instruction* inst, const char* source, uint32_t line_number, uint32_t column_number); // Returns the id of a constant with type |type_id|. The type must be an // integer, float, or vector. For scalar types, the hex representation of the // constant will be the concatenation of 0xDEADBEEF with itself until the // width of the type has been reached. For a vector, each element of the // constant will be constructed the same way. uint32_t GetSpecialConstant(uint32_t type_id); std::string BuildWarningMessage(spv::Op opcode); }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_REPLACE_INVALID_OPC_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/scalar_analysis.cpp000066400000000000000000001012321475742701700245060ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/scalar_analysis.h" #include #include #include #include "source/opt/ir_context.h" // Transforms a given scalar operation instruction into a DAG representation. // // 1. Take an instruction and traverse its operands until we reach a // constant node or an instruction which we do not know how to compute the // value, such as a load. // // 2. Create a new node for each instruction traversed and build the nodes for // the in operands of that instruction as well. // // 3. Add the operand nodes as children of the first and hash the node. Use the // hash to see if the node is already in the cache. We ensure the children are // always in sorted order so that two nodes with the same children but inserted // in a different order have the same hash and so that the overloaded operator== // will return true. If the node is already in the cache return the cached // version instead. // // 4. The created DAG can then be simplified by // ScalarAnalysis::SimplifyExpression, implemented in // scalar_analysis_simplification.cpp. See that file for further information on // the simplification process. // namespace spvtools { namespace opt { uint32_t SENode::NumberOfNodes = 0; ScalarEvolutionAnalysis::ScalarEvolutionAnalysis(IRContext* context) : context_(context), pretend_equal_{} { // Create and cached the CantComputeNode. cached_cant_compute_ = GetCachedOrAdd(std::unique_ptr(new SECantCompute(this))); } SENode* ScalarEvolutionAnalysis::CreateNegation(SENode* operand) { // If operand is can't compute then the whole graph is can't compute. if (operand->IsCantCompute()) return CreateCantComputeNode(); if (operand->GetType() == SENode::Constant) { return CreateConstant(-operand->AsSEConstantNode()->FoldToSingleValue()); } std::unique_ptr negation_node{new SENegative(this)}; negation_node->AddChild(operand); return GetCachedOrAdd(std::move(negation_node)); } SENode* ScalarEvolutionAnalysis::CreateConstant(int64_t integer) { return GetCachedOrAdd( std::unique_ptr(new SEConstantNode(this, integer))); } SENode* ScalarEvolutionAnalysis::CreateRecurrentExpression( const Loop* loop, SENode* offset, SENode* coefficient) { assert(loop && "Recurrent add expressions must have a valid loop."); // If operands are can't compute then the whole graph is can't compute. if (offset->IsCantCompute() || coefficient->IsCantCompute()) return CreateCantComputeNode(); const Loop* loop_to_use = nullptr; if (pretend_equal_[loop]) { loop_to_use = pretend_equal_[loop]; } else { loop_to_use = loop; } std::unique_ptr phi_node{ new SERecurrentNode(this, loop_to_use)}; phi_node->AddOffset(offset); phi_node->AddCoefficient(coefficient); return GetCachedOrAdd(std::move(phi_node)); } SENode* ScalarEvolutionAnalysis::AnalyzeMultiplyOp( const Instruction* multiply) { assert(multiply->opcode() == spv::Op::OpIMul && "Multiply node did not come from a multiply instruction"); analysis::DefUseManager* def_use = context_->get_def_use_mgr(); SENode* op1 = AnalyzeInstruction(def_use->GetDef(multiply->GetSingleWordInOperand(0))); SENode* op2 = AnalyzeInstruction(def_use->GetDef(multiply->GetSingleWordInOperand(1))); return CreateMultiplyNode(op1, op2); } SENode* ScalarEvolutionAnalysis::CreateMultiplyNode(SENode* operand_1, SENode* operand_2) { // If operands are can't compute then the whole graph is can't compute. if (operand_1->IsCantCompute() || operand_2->IsCantCompute()) return CreateCantComputeNode(); if (operand_1->GetType() == SENode::Constant && operand_2->GetType() == SENode::Constant) { return CreateConstant(operand_1->AsSEConstantNode()->FoldToSingleValue() * operand_2->AsSEConstantNode()->FoldToSingleValue()); } std::unique_ptr multiply_node{new SEMultiplyNode(this)}; multiply_node->AddChild(operand_1); multiply_node->AddChild(operand_2); return GetCachedOrAdd(std::move(multiply_node)); } SENode* ScalarEvolutionAnalysis::CreateSubtraction(SENode* operand_1, SENode* operand_2) { // Fold if both operands are constant. if (operand_1->GetType() == SENode::Constant && operand_2->GetType() == SENode::Constant) { return CreateConstant(operand_1->AsSEConstantNode()->FoldToSingleValue() - operand_2->AsSEConstantNode()->FoldToSingleValue()); } return CreateAddNode(operand_1, CreateNegation(operand_2)); } SENode* ScalarEvolutionAnalysis::CreateAddNode(SENode* operand_1, SENode* operand_2) { // Fold if both operands are constant and the |simplify| flag is true. if (operand_1->GetType() == SENode::Constant && operand_2->GetType() == SENode::Constant) { return CreateConstant(operand_1->AsSEConstantNode()->FoldToSingleValue() + operand_2->AsSEConstantNode()->FoldToSingleValue()); } // If operands are can't compute then the whole graph is can't compute. if (operand_1->IsCantCompute() || operand_2->IsCantCompute()) return CreateCantComputeNode(); std::unique_ptr add_node{new SEAddNode(this)}; add_node->AddChild(operand_1); add_node->AddChild(operand_2); return GetCachedOrAdd(std::move(add_node)); } SENode* ScalarEvolutionAnalysis::AnalyzeInstruction(const Instruction* inst) { auto itr = recurrent_node_map_.find(inst); if (itr != recurrent_node_map_.end()) return itr->second; SENode* output = nullptr; switch (inst->opcode()) { case spv::Op::OpPhi: { output = AnalyzePhiInstruction(inst); break; } case spv::Op::OpConstant: case spv::Op::OpConstantNull: { output = AnalyzeConstant(inst); break; } case spv::Op::OpISub: case spv::Op::OpIAdd: { output = AnalyzeAddOp(inst); break; } case spv::Op::OpIMul: { output = AnalyzeMultiplyOp(inst); break; } default: { output = CreateValueUnknownNode(inst); break; } } return output; } SENode* ScalarEvolutionAnalysis::AnalyzeConstant(const Instruction* inst) { if (inst->opcode() == spv::Op::OpConstantNull) return CreateConstant(0); assert(inst->opcode() == spv::Op::OpConstant); assert(inst->NumInOperands() == 1); int64_t value = 0; // Look up the instruction in the constant manager. const analysis::Constant* constant = context_->get_constant_mgr()->FindDeclaredConstant(inst->result_id()); if (!constant) return CreateCantComputeNode(); const analysis::IntConstant* int_constant = constant->AsIntConstant(); // Exit out if it is a 64 bit integer. if (!int_constant || int_constant->words().size() != 1) return CreateCantComputeNode(); if (int_constant->type()->AsInteger()->IsSigned()) { value = int_constant->GetS32BitValue(); } else { value = int_constant->GetU32BitValue(); } return CreateConstant(value); } // Handles both addition and subtraction. If the |sub| flag is set then the // addition will be op1+(-op2) otherwise op1+op2. SENode* ScalarEvolutionAnalysis::AnalyzeAddOp(const Instruction* inst) { assert((inst->opcode() == spv::Op::OpIAdd || inst->opcode() == spv::Op::OpISub) && "Add node must be created from a OpIAdd or OpISub instruction"); analysis::DefUseManager* def_use = context_->get_def_use_mgr(); SENode* op1 = AnalyzeInstruction(def_use->GetDef(inst->GetSingleWordInOperand(0))); SENode* op2 = AnalyzeInstruction(def_use->GetDef(inst->GetSingleWordInOperand(1))); // To handle subtraction we wrap the second operand in a unary negation node. if (inst->opcode() == spv::Op::OpISub) { op2 = CreateNegation(op2); } return CreateAddNode(op1, op2); } SENode* ScalarEvolutionAnalysis::AnalyzePhiInstruction(const Instruction* phi) { // The phi should only have two incoming value pairs. if (phi->NumInOperands() != 4) { return CreateCantComputeNode(); } analysis::DefUseManager* def_use = context_->get_def_use_mgr(); // Get the basic block this instruction belongs to. BasicBlock* basic_block = context_->get_instr_block(const_cast(phi)); // And then the function that the basic blocks belongs to. Function* function = basic_block->GetParent(); // Use the function to get the loop descriptor. LoopDescriptor* loop_descriptor = context_->GetLoopDescriptor(function); // We only handle phis in loops at the moment. if (!loop_descriptor) return CreateCantComputeNode(); // Get the innermost loop which this block belongs to. Loop* loop = (*loop_descriptor)[basic_block->id()]; // If the loop doesn't exist or doesn't have a preheader or latch block, exit // out. if (!loop || !loop->GetLatchBlock() || !loop->GetPreHeaderBlock() || loop->GetHeaderBlock() != basic_block) return recurrent_node_map_[phi] = CreateCantComputeNode(); const Loop* loop_to_use = nullptr; if (pretend_equal_[loop]) { loop_to_use = pretend_equal_[loop]; } else { loop_to_use = loop; } std::unique_ptr phi_node{ new SERecurrentNode(this, loop_to_use)}; // We add the node to this map to allow it to be returned before the node is // fully built. This is needed as the subsequent call to AnalyzeInstruction // could lead back to this |phi| instruction so we return the pointer // immediately in AnalyzeInstruction to break the recursion. recurrent_node_map_[phi] = phi_node.get(); // Traverse the operands of the instruction an create new nodes for each one. for (uint32_t i = 0; i < phi->NumInOperands(); i += 2) { uint32_t value_id = phi->GetSingleWordInOperand(i); uint32_t incoming_label_id = phi->GetSingleWordInOperand(i + 1); Instruction* value_inst = def_use->GetDef(value_id); SENode* value_node = AnalyzeInstruction(value_inst); // If any operand is CantCompute then the whole graph is CantCompute. if (value_node->IsCantCompute()) return recurrent_node_map_[phi] = CreateCantComputeNode(); // If the value is coming from the preheader block then the value is the // initial value of the phi. if (incoming_label_id == loop->GetPreHeaderBlock()->id()) { phi_node->AddOffset(value_node); } else if (incoming_label_id == loop->GetLatchBlock()->id()) { // Assumed to be in the form of step + phi. if (value_node->GetType() != SENode::Add) return recurrent_node_map_[phi] = CreateCantComputeNode(); SENode* step_node = nullptr; SENode* phi_operand = nullptr; SENode* operand_1 = value_node->GetChild(0); SENode* operand_2 = value_node->GetChild(1); // Find which node is the step term. if (!operand_1->AsSERecurrentNode()) step_node = operand_1; else if (!operand_2->AsSERecurrentNode()) step_node = operand_2; // Find which node is the recurrent expression. if (operand_1->AsSERecurrentNode()) phi_operand = operand_1; else if (operand_2->AsSERecurrentNode()) phi_operand = operand_2; // If it is not in the form step + phi exit out. if (!(step_node && phi_operand)) return recurrent_node_map_[phi] = CreateCantComputeNode(); // If the phi operand is not the same phi node exit out. if (phi_operand != phi_node.get()) return recurrent_node_map_[phi] = CreateCantComputeNode(); if (!IsLoopInvariant(loop, step_node)) return recurrent_node_map_[phi] = CreateCantComputeNode(); phi_node->AddCoefficient(step_node); } } // Once the node is fully built we update the map with the version from the // cache (if it has already been added to the cache). return recurrent_node_map_[phi] = GetCachedOrAdd(std::move(phi_node)); } SENode* ScalarEvolutionAnalysis::CreateValueUnknownNode( const Instruction* inst) { std::unique_ptr load_node{ new SEValueUnknown(this, inst->result_id())}; return GetCachedOrAdd(std::move(load_node)); } SENode* ScalarEvolutionAnalysis::CreateCantComputeNode() { return cached_cant_compute_; } // Add the created node into the cache of nodes. If it already exists return it. SENode* ScalarEvolutionAnalysis::GetCachedOrAdd( std::unique_ptr prospective_node) { auto itr = node_cache_.find(prospective_node); if (itr != node_cache_.end()) { return (*itr).get(); } SENode* raw_ptr_to_node = prospective_node.get(); node_cache_.insert(std::move(prospective_node)); return raw_ptr_to_node; } bool ScalarEvolutionAnalysis::IsLoopInvariant(const Loop* loop, const SENode* node) const { for (auto itr = node->graph_cbegin(); itr != node->graph_cend(); ++itr) { if (const SERecurrentNode* rec = itr->AsSERecurrentNode()) { const BasicBlock* header = rec->GetLoop()->GetHeaderBlock(); // If the loop which the recurrent expression belongs to is either |loop // or a nested loop inside |loop| then we assume it is variant. if (loop->IsInsideLoop(header)) { return false; } } else if (const SEValueUnknown* unknown = itr->AsSEValueUnknown()) { // If the instruction is inside the loop we conservatively assume it is // loop variant. if (loop->IsInsideLoop(unknown->ResultId())) return false; } } return true; } SENode* ScalarEvolutionAnalysis::GetCoefficientFromRecurrentTerm( SENode* node, const Loop* loop) { // Traverse the DAG to find the recurrent expression belonging to |loop|. for (auto itr = node->graph_begin(); itr != node->graph_end(); ++itr) { SERecurrentNode* rec = itr->AsSERecurrentNode(); if (rec && rec->GetLoop() == loop) { return rec->GetCoefficient(); } } return CreateConstant(0); } SENode* ScalarEvolutionAnalysis::UpdateChildNode(SENode* parent, SENode* old_child, SENode* new_child) { // Only handles add. if (parent->GetType() != SENode::Add) return parent; std::vector new_children; for (SENode* child : *parent) { if (child == old_child) { new_children.push_back(new_child); } else { new_children.push_back(child); } } std::unique_ptr add_node{new SEAddNode(this)}; for (SENode* child : new_children) { add_node->AddChild(child); } return SimplifyExpression(GetCachedOrAdd(std::move(add_node))); } // Rebuild the |node| eliminating, if it exists, the recurrent term which // belongs to the |loop|. SENode* ScalarEvolutionAnalysis::BuildGraphWithoutRecurrentTerm( SENode* node, const Loop* loop) { // If the node is already a recurrent expression belonging to loop then just // return the offset. SERecurrentNode* recurrent = node->AsSERecurrentNode(); if (recurrent) { if (recurrent->GetLoop() == loop) { return recurrent->GetOffset(); } else { return node; } } std::vector new_children; // Otherwise find the recurrent node in the children of this node. for (auto itr : *node) { recurrent = itr->AsSERecurrentNode(); if (recurrent && recurrent->GetLoop() == loop) { new_children.push_back(recurrent->GetOffset()); } else { new_children.push_back(itr); } } std::unique_ptr add_node{new SEAddNode(this)}; for (SENode* child : new_children) { add_node->AddChild(child); } return SimplifyExpression(GetCachedOrAdd(std::move(add_node))); } // Return the recurrent term belonging to |loop| if it appears in the graph // starting at |node| or null if it doesn't. SERecurrentNode* ScalarEvolutionAnalysis::GetRecurrentTerm(SENode* node, const Loop* loop) { for (auto itr = node->graph_begin(); itr != node->graph_end(); ++itr) { SERecurrentNode* rec = itr->AsSERecurrentNode(); if (rec && rec->GetLoop() == loop) { return rec; } } return nullptr; } std::string SENode::AsString() const { switch (GetType()) { case Constant: return "Constant"; case RecurrentAddExpr: return "RecurrentAddExpr"; case Add: return "Add"; case Negative: return "Negative"; case Multiply: return "Multiply"; case ValueUnknown: return "Value Unknown"; case CanNotCompute: return "Can not compute"; } return "NULL"; } bool SENode::operator==(const SENode& other) const { if (GetType() != other.GetType()) return false; if (other.GetChildren().size() != children_.size()) return false; const SERecurrentNode* this_as_recurrent = AsSERecurrentNode(); // Check the children are the same, for SERecurrentNodes we need to check the // offset and coefficient manually as the child vector is sorted by ids so the // offset/coefficient information is lost. if (!this_as_recurrent) { for (size_t index = 0; index < children_.size(); ++index) { if (other.GetChildren()[index] != children_[index]) return false; } } else { const SERecurrentNode* other_as_recurrent = other.AsSERecurrentNode(); // We've already checked the types are the same, this should not fail if // this->AsSERecurrentNode() succeeded. assert(other_as_recurrent); if (this_as_recurrent->GetCoefficient() != other_as_recurrent->GetCoefficient()) return false; if (this_as_recurrent->GetOffset() != other_as_recurrent->GetOffset()) return false; if (this_as_recurrent->GetLoop() != other_as_recurrent->GetLoop()) return false; } // If we're dealing with a value unknown node check both nodes were created by // the same instruction. if (GetType() == SENode::ValueUnknown) { if (AsSEValueUnknown()->ResultId() != other.AsSEValueUnknown()->ResultId()) { return false; } } if (AsSEConstantNode()) { if (AsSEConstantNode()->FoldToSingleValue() != other.AsSEConstantNode()->FoldToSingleValue()) return false; } return true; } bool SENode::operator!=(const SENode& other) const { return !(*this == other); } namespace { // Helper functions to insert 32/64 bit values into the 32 bit hash string. This // allows us to add pointers to the string by reinterpreting the pointers as // uintptr_t. PushToString will deduce the type, call sizeof on it and use // that size to call into the correct PushToStringImpl functor depending on // whether it is 32 or 64 bit. template struct PushToStringImpl; template struct PushToStringImpl { void operator()(T id, std::u32string* str) { str->push_back(static_cast(id >> 32)); str->push_back(static_cast(id)); } }; template struct PushToStringImpl { void operator()(T id, std::u32string* str) { str->push_back(static_cast(id)); } }; template void PushToString(T id, std::u32string* str) { PushToStringImpl{}(id, str); } } // namespace // Implements the hashing of SENodes. size_t SENodeHash::operator()(const SENode* node) const { // Concatenate the terms into a string which we can hash. std::u32string hash_string{}; // Hashing the type as a string is safer than hashing the enum as the enum is // very likely to collide with constants. for (char ch : node->AsString()) { hash_string.push_back(static_cast(ch)); } // We just ignore the literal value unless it is a constant. if (node->GetType() == SENode::Constant) PushToString(node->AsSEConstantNode()->FoldToSingleValue(), &hash_string); const SERecurrentNode* recurrent = node->AsSERecurrentNode(); // If we're dealing with a recurrent expression hash the loop as well so that // nested inductions like i=0,i++ and j=0,j++ correspond to different nodes. if (recurrent) { PushToString(reinterpret_cast(recurrent->GetLoop()), &hash_string); // Recurrent expressions can't be hashed using the normal method as the // order of coefficient and offset matters to the hash. PushToString(reinterpret_cast(recurrent->GetCoefficient()), &hash_string); PushToString(reinterpret_cast(recurrent->GetOffset()), &hash_string); return std::hash{}(hash_string); } // Hash the result id of the original instruction which created this node if // it is a value unknown node. if (node->GetType() == SENode::ValueUnknown) { PushToString(node->AsSEValueUnknown()->ResultId(), &hash_string); } // Hash the pointers of the child nodes, each SENode has a unique pointer // associated with it. const std::vector& children = node->GetChildren(); for (const SENode* child : children) { PushToString(reinterpret_cast(child), &hash_string); } return std::hash{}(hash_string); } // This overload is the actual overload used by the node_cache_ set. size_t SENodeHash::operator()(const std::unique_ptr& node) const { return this->operator()(node.get()); } void SENode::DumpDot(std::ostream& out, bool recurse) const { size_t unique_id = std::hash{}(this); out << unique_id << " [label=\"" << AsString() << " "; if (GetType() == SENode::Constant) { out << "\nwith value: " << this->AsSEConstantNode()->FoldToSingleValue(); } out << "\"]\n"; for (const SENode* child : children_) { size_t child_unique_id = std::hash{}(child); out << unique_id << " -> " << child_unique_id << " \n"; if (recurse) child->DumpDot(out, true); } } namespace { class IsGreaterThanZero { public: explicit IsGreaterThanZero(IRContext* context) : context_(context) {} // Determine if the value of |node| is always strictly greater than zero if // |or_equal_zero| is false or greater or equal to zero if |or_equal_zero| is // true. It returns true is the evaluation was able to conclude something, in // which case the result is stored in |result|. // The algorithm work by going through all the nodes and determine the // sign of each of them. bool Eval(const SENode* node, bool or_equal_zero, bool* result) { *result = false; switch (Visit(node)) { case Signedness::kPositiveOrNegative: { return false; } case Signedness::kStrictlyNegative: { *result = false; break; } case Signedness::kNegative: { if (!or_equal_zero) { return false; } *result = false; break; } case Signedness::kStrictlyPositive: { *result = true; break; } case Signedness::kPositive: { if (!or_equal_zero) { return false; } *result = true; break; } } return true; } private: enum class Signedness { kPositiveOrNegative, // Yield a value positive or negative. kStrictlyNegative, // Yield a value strictly less than 0. kNegative, // Yield a value less or equal to 0. kStrictlyPositive, // Yield a value strictly greater than 0. kPositive // Yield a value greater or equal to 0. }; // Combine the signedness according to arithmetic rules of a given operator. using Combiner = std::function; // Returns a functor to interpret the signedness of 2 expressions as if they // were added. Combiner GetAddCombiner() const { return [](Signedness lhs, Signedness rhs) { switch (lhs) { case Signedness::kPositiveOrNegative: break; case Signedness::kStrictlyNegative: if (rhs == Signedness::kStrictlyNegative || rhs == Signedness::kNegative) return lhs; break; case Signedness::kNegative: { if (rhs == Signedness::kStrictlyNegative) return Signedness::kStrictlyNegative; if (rhs == Signedness::kNegative) return Signedness::kNegative; break; } case Signedness::kStrictlyPositive: { if (rhs == Signedness::kStrictlyPositive || rhs == Signedness::kPositive) { return Signedness::kStrictlyPositive; } break; } case Signedness::kPositive: { if (rhs == Signedness::kStrictlyPositive) return Signedness::kStrictlyPositive; if (rhs == Signedness::kPositive) return Signedness::kPositive; break; } } return Signedness::kPositiveOrNegative; }; } // Returns a functor to interpret the signedness of 2 expressions as if they // were multiplied. Combiner GetMulCombiner() const { return [](Signedness lhs, Signedness rhs) { switch (lhs) { case Signedness::kPositiveOrNegative: break; case Signedness::kStrictlyNegative: { switch (rhs) { case Signedness::kPositiveOrNegative: { break; } case Signedness::kStrictlyNegative: { return Signedness::kStrictlyPositive; } case Signedness::kNegative: { return Signedness::kPositive; } case Signedness::kStrictlyPositive: { return Signedness::kStrictlyNegative; } case Signedness::kPositive: { return Signedness::kNegative; } } break; } case Signedness::kNegative: { switch (rhs) { case Signedness::kPositiveOrNegative: { break; } case Signedness::kStrictlyNegative: case Signedness::kNegative: { return Signedness::kPositive; } case Signedness::kStrictlyPositive: case Signedness::kPositive: { return Signedness::kNegative; } } break; } case Signedness::kStrictlyPositive: { return rhs; } case Signedness::kPositive: { switch (rhs) { case Signedness::kPositiveOrNegative: { break; } case Signedness::kStrictlyNegative: case Signedness::kNegative: { return Signedness::kNegative; } case Signedness::kStrictlyPositive: case Signedness::kPositive: { return Signedness::kPositive; } } break; } } return Signedness::kPositiveOrNegative; }; } Signedness Visit(const SENode* node) { switch (node->GetType()) { case SENode::Constant: return Visit(node->AsSEConstantNode()); break; case SENode::RecurrentAddExpr: return Visit(node->AsSERecurrentNode()); break; case SENode::Negative: return Visit(node->AsSENegative()); break; case SENode::CanNotCompute: return Visit(node->AsSECantCompute()); break; case SENode::ValueUnknown: return Visit(node->AsSEValueUnknown()); break; case SENode::Add: return VisitExpr(node, GetAddCombiner()); break; case SENode::Multiply: return VisitExpr(node, GetMulCombiner()); break; } return Signedness::kPositiveOrNegative; } // Returns the signedness of a constant |node|. Signedness Visit(const SEConstantNode* node) { if (0 == node->FoldToSingleValue()) return Signedness::kPositive; if (0 < node->FoldToSingleValue()) return Signedness::kStrictlyPositive; if (0 > node->FoldToSingleValue()) return Signedness::kStrictlyNegative; return Signedness::kPositiveOrNegative; } // Returns the signedness of an unknown |node| based on its type. Signedness Visit(const SEValueUnknown* node) { Instruction* insn = context_->get_def_use_mgr()->GetDef(node->ResultId()); analysis::Type* type = context_->get_type_mgr()->GetType(insn->type_id()); assert(type && "Can't retrieve a type for the instruction"); analysis::Integer* int_type = type->AsInteger(); assert(type && "Can't retrieve an integer type for the instruction"); return int_type->IsSigned() ? Signedness::kPositiveOrNegative : Signedness::kPositive; } // Returns the signedness of a recurring expression. Signedness Visit(const SERecurrentNode* node) { Signedness coeff_sign = Visit(node->GetCoefficient()); // SERecurrentNode represent an affine expression in the range [0, // loop_bound], so the result cannot be strictly positive or negative. switch (coeff_sign) { default: break; case Signedness::kStrictlyNegative: coeff_sign = Signedness::kNegative; break; case Signedness::kStrictlyPositive: coeff_sign = Signedness::kPositive; break; } return GetAddCombiner()(coeff_sign, Visit(node->GetOffset())); } // Returns the signedness of a negation |node|. Signedness Visit(const SENegative* node) { switch (Visit(*node->begin())) { case Signedness::kPositiveOrNegative: { return Signedness::kPositiveOrNegative; } case Signedness::kStrictlyNegative: { return Signedness::kStrictlyPositive; } case Signedness::kNegative: { return Signedness::kPositive; } case Signedness::kStrictlyPositive: { return Signedness::kStrictlyNegative; } case Signedness::kPositive: { return Signedness::kNegative; } } return Signedness::kPositiveOrNegative; } Signedness Visit(const SECantCompute*) { return Signedness::kPositiveOrNegative; } // Returns the signedness of a binary expression by using the combiner // |reduce|. Signedness VisitExpr( const SENode* node, std::function reduce) { Signedness result = Visit(*node->begin()); for (const SENode* operand : make_range(++node->begin(), node->end())) { if (result == Signedness::kPositiveOrNegative) { return Signedness::kPositiveOrNegative; } result = reduce(result, Visit(operand)); } return result; } IRContext* context_; }; } // namespace bool ScalarEvolutionAnalysis::IsAlwaysGreaterThanZero(SENode* node, bool* is_gt_zero) const { return IsGreaterThanZero(context_).Eval(node, false, is_gt_zero); } bool ScalarEvolutionAnalysis::IsAlwaysGreaterOrEqualToZero( SENode* node, bool* is_ge_zero) const { return IsGreaterThanZero(context_).Eval(node, true, is_ge_zero); } namespace { // Remove |node| from the |mul| chain (of the form A * ... * |node| * ... * Z), // if |node| is not in the chain, returns the original chain. SENode* RemoveOneNodeFromMultiplyChain(SEMultiplyNode* mul, const SENode* node) { SENode* lhs = mul->GetChildren()[0]; SENode* rhs = mul->GetChildren()[1]; if (lhs == node) { return rhs; } if (rhs == node) { return lhs; } if (lhs->AsSEMultiplyNode()) { SENode* res = RemoveOneNodeFromMultiplyChain(lhs->AsSEMultiplyNode(), node); if (res != lhs) return mul->GetParentAnalysis()->CreateMultiplyNode(res, rhs); } if (rhs->AsSEMultiplyNode()) { SENode* res = RemoveOneNodeFromMultiplyChain(rhs->AsSEMultiplyNode(), node); if (res != rhs) return mul->GetParentAnalysis()->CreateMultiplyNode(res, rhs); } return mul; } } // namespace std::pair SExpression::operator/( SExpression rhs_wrapper) const { SENode* lhs = node_; SENode* rhs = rhs_wrapper.node_; // Check for division by 0. if (rhs->AsSEConstantNode() && !rhs->AsSEConstantNode()->FoldToSingleValue()) { return {scev_->CreateCantComputeNode(), 0}; } // Trivial case. if (lhs->AsSEConstantNode() && rhs->AsSEConstantNode()) { int64_t lhs_value = lhs->AsSEConstantNode()->FoldToSingleValue(); int64_t rhs_value = rhs->AsSEConstantNode()->FoldToSingleValue(); return {scev_->CreateConstant(lhs_value / rhs_value), lhs_value % rhs_value}; } // look for a "c U / U" pattern. if (lhs->AsSEMultiplyNode()) { assert(lhs->GetChildren().size() == 2 && "More than 2 operand for a multiply node."); SENode* res = RemoveOneNodeFromMultiplyChain(lhs->AsSEMultiplyNode(), rhs); if (res != lhs) { return {res, 0}; } } return {scev_->CreateCantComputeNode(), 0}; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/scalar_analysis.h000066400000000000000000000271651475742701700241670ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_SCALAR_ANALYSIS_H_ #define SOURCE_OPT_SCALAR_ANALYSIS_H_ #include #include #include #include #include #include #include #include "source/opt/basic_block.h" #include "source/opt/instruction.h" #include "source/opt/scalar_analysis_nodes.h" namespace spvtools { namespace opt { class IRContext; class Loop; // Manager for the Scalar Evolution analysis. Creates and maintains a DAG of // scalar operations generated from analysing the use def graph from incoming // instructions. Each node is hashed as it is added so like node (for instance, // two induction variables i=0,i++ and j=0,j++) become the same node. After // creating a DAG with AnalyzeInstruction it can the be simplified into a more // usable form with SimplifyExpression. class ScalarEvolutionAnalysis { public: explicit ScalarEvolutionAnalysis(IRContext* context); // Create a unary negative node on |operand|. SENode* CreateNegation(SENode* operand); // Creates a subtraction between the two operands by adding |operand_1| to the // negation of |operand_2|. SENode* CreateSubtraction(SENode* operand_1, SENode* operand_2); // Create an addition node between two operands. The |simplify| when set will // allow the function to return an SEConstant instead of an addition if the // two input operands are also constant. SENode* CreateAddNode(SENode* operand_1, SENode* operand_2); // Create a multiply node between two operands. SENode* CreateMultiplyNode(SENode* operand_1, SENode* operand_2); // Create a node representing a constant integer. SENode* CreateConstant(int64_t integer); // Create a value unknown node, such as a load. SENode* CreateValueUnknownNode(const Instruction* inst); // Create a CantComputeNode. Used to exit out of analysis. SENode* CreateCantComputeNode(); // Create a new recurrent node with |offset| and |coefficient|, with respect // to |loop|. SENode* CreateRecurrentExpression(const Loop* loop, SENode* offset, SENode* coefficient); // Construct the DAG by traversing use def chain of |inst|. SENode* AnalyzeInstruction(const Instruction* inst); // Simplify the |node| by grouping like terms or if contains a recurrent // expression, rewrite the graph so the whole DAG (from |node| down) is in // terms of that recurrent expression. // // For example. // Induction variable i=0, i++ would produce Rec(0,1) so i+1 could be // transformed into Rec(1,1). // // X+X*2+Y-Y+34-17 would be transformed into 3*X + 17, where X and Y are // ValueUnknown nodes (such as a load instruction). SENode* SimplifyExpression(SENode* node); // Add |prospective_node| into the cache and return a raw pointer to it. If // |prospective_node| is already in the cache just return the raw pointer. SENode* GetCachedOrAdd(std::unique_ptr prospective_node); // Checks that the graph starting from |node| is invariant to the |loop|. bool IsLoopInvariant(const Loop* loop, const SENode* node) const; // Sets |is_gt_zero| to true if |node| represent a value always strictly // greater than 0. The result of |is_gt_zero| is valid only if the function // returns true. bool IsAlwaysGreaterThanZero(SENode* node, bool* is_gt_zero) const; // Sets |is_ge_zero| to true if |node| represent a value greater or equals to // 0. The result of |is_ge_zero| is valid only if the function returns true. bool IsAlwaysGreaterOrEqualToZero(SENode* node, bool* is_ge_zero) const; // Find the recurrent term belonging to |loop| in the graph starting from // |node| and return the coefficient of that recurrent term. Constant zero // will be returned if no recurrent could be found. |node| should be in // simplest form. SENode* GetCoefficientFromRecurrentTerm(SENode* node, const Loop* loop); // Return a rebuilt graph starting from |node| with the recurrent expression // belonging to |loop| being zeroed out. Returned node will be simplified. SENode* BuildGraphWithoutRecurrentTerm(SENode* node, const Loop* loop); // Return the recurrent term belonging to |loop| if it appears in the graph // starting at |node| or null if it doesn't. SERecurrentNode* GetRecurrentTerm(SENode* node, const Loop* loop); SENode* UpdateChildNode(SENode* parent, SENode* child, SENode* new_child); // The loops in |loop_pair| will be considered the same when constructing // SERecurrentNode objects. This enables analysing dependencies that will be // created during loop fusion. void AddLoopsToPretendAreTheSame( const std::pair& loop_pair) { pretend_equal_[std::get<1>(loop_pair)] = std::get<0>(loop_pair); } private: SENode* AnalyzeConstant(const Instruction* inst); // Handles both addition and subtraction. If the |instruction| is OpISub // then the resulting node will be op1+(-op2) otherwise if it is OpIAdd then // the result will be op1+op2. |instruction| must be OpIAdd or OpISub. SENode* AnalyzeAddOp(const Instruction* instruction); SENode* AnalyzeMultiplyOp(const Instruction* multiply); SENode* AnalyzePhiInstruction(const Instruction* phi); IRContext* context_; // A map of instructions to SENodes. This is used to track recurrent // expressions as they are added when analyzing instructions. Recurrent // expressions come from phi nodes which by nature can include recursion so we // check if nodes have already been built when analyzing instructions. std::map recurrent_node_map_; // On creation we create and cache the CantCompute node so we not need to // perform a needless create step. SENode* cached_cant_compute_; // Helper functor to allow two unique_ptr to nodes to be compare. Only // needed // for the unordered_set implementation. struct NodePointersEquality { bool operator()(const std::unique_ptr& lhs, const std::unique_ptr& rhs) const { return *lhs == *rhs; } }; // Cache of nodes. All pointers to the nodes are references to the memory // managed by they set. std::unordered_set, SENodeHash, NodePointersEquality> node_cache_; // Loops that should be considered the same for performing analysis for loop // fusion. std::map pretend_equal_; }; // Wrapping class to manipulate SENode pointer using + - * / operators. class SExpression { public: // Implicit on purpose ! SExpression(SENode* node) : node_(node->GetParentAnalysis()->SimplifyExpression(node)), scev_(node->GetParentAnalysis()) {} inline operator SENode*() const { return node_; } inline SENode* operator->() const { return node_; } const SENode& operator*() const { return *node_; } inline ScalarEvolutionAnalysis* GetScalarEvolutionAnalysis() const { return scev_; } inline SExpression operator+(SENode* rhs) const; template ::value, int>::type = 0> inline SExpression operator+(T integer) const; inline SExpression operator+(SExpression rhs) const; inline SExpression operator-() const; inline SExpression operator-(SENode* rhs) const; template ::value, int>::type = 0> inline SExpression operator-(T integer) const; inline SExpression operator-(SExpression rhs) const; inline SExpression operator*(SENode* rhs) const; template ::value, int>::type = 0> inline SExpression operator*(T integer) const; inline SExpression operator*(SExpression rhs) const; template ::value, int>::type = 0> inline std::pair operator/(T integer) const; // Try to perform a division. Returns the pair . If it fails to simplify it, the function returns a // CanNotCompute node. std::pair operator/(SExpression rhs) const; private: SENode* node_; ScalarEvolutionAnalysis* scev_; }; inline SExpression SExpression::operator+(SENode* rhs) const { return scev_->CreateAddNode(node_, rhs); } template ::value, int>::type> inline SExpression SExpression::operator+(T integer) const { return *this + scev_->CreateConstant(integer); } inline SExpression SExpression::operator+(SExpression rhs) const { return *this + rhs.node_; } inline SExpression SExpression::operator-() const { return scev_->CreateNegation(node_); } inline SExpression SExpression::operator-(SENode* rhs) const { return *this + scev_->CreateNegation(rhs); } template ::value, int>::type> inline SExpression SExpression::operator-(T integer) const { return *this - scev_->CreateConstant(integer); } inline SExpression SExpression::operator-(SExpression rhs) const { return *this - rhs.node_; } inline SExpression SExpression::operator*(SENode* rhs) const { return scev_->CreateMultiplyNode(node_, rhs); } template ::value, int>::type> inline SExpression SExpression::operator*(T integer) const { return *this * scev_->CreateConstant(integer); } inline SExpression SExpression::operator*(SExpression rhs) const { return *this * rhs.node_; } template ::value, int>::type> inline std::pair SExpression::operator/(T integer) const { return *this / scev_->CreateConstant(integer); } template ::value, int>::type> inline SExpression operator+(T lhs, SExpression rhs) { return rhs + lhs; } inline SExpression operator+(SENode* lhs, SExpression rhs) { return rhs + lhs; } template ::value, int>::type> inline SExpression operator-(T lhs, SExpression rhs) { // NOLINTNEXTLINE(whitespace/braces) return SExpression{rhs.GetScalarEvolutionAnalysis()->CreateConstant(lhs)} - rhs; } inline SExpression operator-(SENode* lhs, SExpression rhs) { // NOLINTNEXTLINE(whitespace/braces) return SExpression{lhs} - rhs; } template ::value, int>::type> inline SExpression operator*(T lhs, SExpression rhs) { return rhs * lhs; } inline SExpression operator*(SENode* lhs, SExpression rhs) { return rhs * lhs; } template ::value, int>::type> inline std::pair operator/(T lhs, SExpression rhs) { // NOLINTNEXTLINE(whitespace/braces) return SExpression{rhs.GetScalarEvolutionAnalysis()->CreateConstant(lhs)} / rhs; } inline std::pair operator/(SENode* lhs, SExpression rhs) { // NOLINTNEXTLINE(whitespace/braces) return SExpression{lhs} / rhs; } } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_SCALAR_ANALYSIS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/scalar_analysis_nodes.h000066400000000000000000000275531475742701700253600ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASI, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_SCALAR_ANALYSIS_NODES_H_ #define SOURCE_OPT_SCALAR_ANALYSIS_NODES_H_ #include #include #include #include #include "source/opt/tree_iterator.h" namespace spvtools { namespace opt { class Loop; class ScalarEvolutionAnalysis; class SEConstantNode; class SERecurrentNode; class SEAddNode; class SEMultiplyNode; class SENegative; class SEValueUnknown; class SECantCompute; // Abstract class representing a node in the scalar evolution DAG. Each node // contains a vector of pointers to its children and each subclass of SENode // implements GetType and an As method to allow casting. SENodes can be hashed // using the SENodeHash functor. The vector of children is sorted when a node is // added. This is important as it allows the hash of X+Y to be the same as Y+X. class SENode { public: enum SENodeType { Constant, RecurrentAddExpr, Add, Multiply, Negative, ValueUnknown, CanNotCompute }; using ChildContainerType = std::vector; explicit SENode(ScalarEvolutionAnalysis* parent_analysis) : parent_analysis_(parent_analysis), unique_id_(++NumberOfNodes) {} virtual SENodeType GetType() const = 0; virtual ~SENode() {} virtual inline void AddChild(SENode* child) { // If this is a constant node, assert. if (AsSEConstantNode()) { assert(false && "Trying to add a child node to a constant!"); } // Find the first point in the vector where |child| is greater than the node // currently in the vector. auto find_first_less_than = [child](const SENode* node) { return child->unique_id_ <= node->unique_id_; }; auto position = std::find_if_not(children_.begin(), children_.end(), find_first_less_than); // Children are sorted so the hashing and equality operator will be the same // for a node with the same children. X+Y should be the same as Y+X. children_.insert(position, child); } // Get the type as an std::string. This is used to represent the node in the // dot output and is used to hash the type as well. std::string AsString() const; // Dump the SENode and its immediate children, if |recurse| is true then it // will recurse through all children to print the DAG starting from this node // as a root. void DumpDot(std::ostream& out, bool recurse = false) const; // Checks if two nodes are the same by hashing them. bool operator==(const SENode& other) const; // Checks if two nodes are not the same by comparing the hashes. bool operator!=(const SENode& other) const; // Return the child node at |index|. inline SENode* GetChild(size_t index) { return children_[index]; } inline const SENode* GetChild(size_t index) const { return children_[index]; } // Iterator to iterate over the child nodes. using iterator = ChildContainerType::iterator; using const_iterator = ChildContainerType::const_iterator; // Iterate over immediate child nodes. iterator begin() { return children_.begin(); } iterator end() { return children_.end(); } // Constant overloads for iterating over immediate child nodes. const_iterator begin() const { return children_.cbegin(); } const_iterator end() const { return children_.cend(); } const_iterator cbegin() { return children_.cbegin(); } const_iterator cend() { return children_.cend(); } // Collect all the recurrent nodes in this SENode std::vector CollectRecurrentNodes() { std::vector recurrent_nodes{}; if (auto recurrent_node = AsSERecurrentNode()) { recurrent_nodes.push_back(recurrent_node); } for (auto child : GetChildren()) { auto child_recurrent_nodes = child->CollectRecurrentNodes(); recurrent_nodes.insert(recurrent_nodes.end(), child_recurrent_nodes.begin(), child_recurrent_nodes.end()); } return recurrent_nodes; } // Collect all the value unknown nodes in this SENode std::vector CollectValueUnknownNodes() { std::vector value_unknown_nodes{}; if (auto value_unknown_node = AsSEValueUnknown()) { value_unknown_nodes.push_back(value_unknown_node); } for (auto child : GetChildren()) { auto child_value_unknown_nodes = child->CollectValueUnknownNodes(); value_unknown_nodes.insert(value_unknown_nodes.end(), child_value_unknown_nodes.begin(), child_value_unknown_nodes.end()); } return value_unknown_nodes; } // Iterator to iterate over the entire DAG. Even though we are using the tree // iterator it should still be safe to iterate over. However, nodes with // multiple parents will be visited multiple times, unlike in a tree. using dag_iterator = TreeDFIterator; using const_dag_iterator = TreeDFIterator; // Iterate over all child nodes in the graph. dag_iterator graph_begin() { return dag_iterator(this); } dag_iterator graph_end() { return dag_iterator(); } const_dag_iterator graph_begin() const { return graph_cbegin(); } const_dag_iterator graph_end() const { return graph_cend(); } const_dag_iterator graph_cbegin() const { return const_dag_iterator(this); } const_dag_iterator graph_cend() const { return const_dag_iterator(); } // Return the vector of immediate children. const ChildContainerType& GetChildren() const { return children_; } ChildContainerType& GetChildren() { return children_; } // Return true if this node is a can't compute node. bool IsCantCompute() const { return GetType() == CanNotCompute; } // Implements a casting method for each type. // clang-format off #define DeclareCastMethod(target) \ virtual target* As##target() { return nullptr; } \ virtual const target* As##target() const { return nullptr; } DeclareCastMethod(SEConstantNode) DeclareCastMethod(SERecurrentNode) DeclareCastMethod(SEAddNode) DeclareCastMethod(SEMultiplyNode) DeclareCastMethod(SENegative) DeclareCastMethod(SEValueUnknown) DeclareCastMethod(SECantCompute) #undef DeclareCastMethod // Get the analysis which has this node in its cache. inline ScalarEvolutionAnalysis* GetParentAnalysis() const { return parent_analysis_; } protected: ChildContainerType children_; ScalarEvolutionAnalysis* parent_analysis_; // The unique id of this node, assigned on creation by incrementing the static // node count. uint32_t unique_id_; // The number of nodes created. static uint32_t NumberOfNodes; }; // clang-format on // Function object to handle the hashing of SENodes. Hashing algorithm hashes // the type (as a string), the literal value of any constants, and the child // pointers which are assumed to be unique. struct SENodeHash { size_t operator()(const std::unique_ptr& node) const; size_t operator()(const SENode* node) const; }; // A node representing a constant integer. class SEConstantNode : public SENode { public: SEConstantNode(ScalarEvolutionAnalysis* parent_analysis, int64_t value) : SENode(parent_analysis), literal_value_(value) {} SENodeType GetType() const final { return Constant; } int64_t FoldToSingleValue() const { return literal_value_; } SEConstantNode* AsSEConstantNode() override { return this; } const SEConstantNode* AsSEConstantNode() const override { return this; } inline void AddChild(SENode*) final { assert(false && "Attempting to add a child to a constant node!"); } protected: int64_t literal_value_; }; // A node representing a recurrent expression in the code. A recurrent // expression is an expression whose value can be expressed as a linear // expression of the loop iterations. Such as an induction variable. The actual // value of a recurrent expression is coefficent_ * iteration + offset_, hence // an induction variable i=0, i++ becomes a recurrent expression with an offset // of zero and a coefficient of one. class SERecurrentNode : public SENode { public: SERecurrentNode(ScalarEvolutionAnalysis* parent_analysis, const Loop* loop) : SENode(parent_analysis), loop_(loop) {} SENodeType GetType() const final { return RecurrentAddExpr; } inline void AddCoefficient(SENode* child) { coefficient_ = child; SENode::AddChild(child); } inline void AddOffset(SENode* child) { offset_ = child; SENode::AddChild(child); } inline const SENode* GetCoefficient() const { return coefficient_; } inline SENode* GetCoefficient() { return coefficient_; } inline const SENode* GetOffset() const { return offset_; } inline SENode* GetOffset() { return offset_; } // Return the loop which this recurrent expression is recurring within. const Loop* GetLoop() const { return loop_; } SERecurrentNode* AsSERecurrentNode() override { return this; } const SERecurrentNode* AsSERecurrentNode() const override { return this; } private: SENode* coefficient_; SENode* offset_; const Loop* loop_; }; // A node representing an addition operation between child nodes. class SEAddNode : public SENode { public: explicit SEAddNode(ScalarEvolutionAnalysis* parent_analysis) : SENode(parent_analysis) {} SENodeType GetType() const final { return Add; } SEAddNode* AsSEAddNode() override { return this; } const SEAddNode* AsSEAddNode() const override { return this; } }; // A node representing a multiply operation between child nodes. class SEMultiplyNode : public SENode { public: explicit SEMultiplyNode(ScalarEvolutionAnalysis* parent_analysis) : SENode(parent_analysis) {} SENodeType GetType() const final { return Multiply; } SEMultiplyNode* AsSEMultiplyNode() override { return this; } const SEMultiplyNode* AsSEMultiplyNode() const override { return this; } }; // A node representing a unary negative operation. class SENegative : public SENode { public: explicit SENegative(ScalarEvolutionAnalysis* parent_analysis) : SENode(parent_analysis) {} SENodeType GetType() const final { return Negative; } SENegative* AsSENegative() override { return this; } const SENegative* AsSENegative() const override { return this; } }; // A node representing a value which we do not know the value of, such as a load // instruction. class SEValueUnknown : public SENode { public: // SEValueUnknowns must come from an instruction |unique_id| is the unique id // of that instruction. This is so we cancompare value unknowns and have a // unique value unknown for each instruction. SEValueUnknown(ScalarEvolutionAnalysis* parent_analysis, uint32_t result_id) : SENode(parent_analysis), result_id_(result_id) {} SENodeType GetType() const final { return ValueUnknown; } SEValueUnknown* AsSEValueUnknown() override { return this; } const SEValueUnknown* AsSEValueUnknown() const override { return this; } inline uint32_t ResultId() const { return result_id_; } private: uint32_t result_id_; }; // A node which we cannot reason about at all. class SECantCompute : public SENode { public: explicit SECantCompute(ScalarEvolutionAnalysis* parent_analysis) : SENode(parent_analysis) {} SENodeType GetType() const final { return CanNotCompute; } SECantCompute* AsSECantCompute() override { return this; } const SECantCompute* AsSECantCompute() const override { return this; } }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_SCALAR_ANALYSIS_NODES_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/scalar_analysis_simplification.cpp000066400000000000000000000473661475742701700276210ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include #include #include #include "source/opt/scalar_analysis.h" // Simplifies scalar analysis DAGs. // // 1. Given a node passed to SimplifyExpression we first simplify the graph by // calling SimplifyPolynomial. This groups like nodes following basic arithmetic // rules, so multiple adds of the same load instruction could be grouped into a // single multiply of that instruction. SimplifyPolynomial will traverse the DAG // and build up an accumulator buffer for each class of instruction it finds. // For example take the loop: // for (i=0, i accumulators_; }; // From a |multiply| build up the accumulator objects. bool SENodeSimplifyImpl::AccumulatorsFromMultiply(SENode* multiply, bool negation) { if (multiply->GetChildren().size() != 2 || multiply->GetType() != SENode::Multiply) return false; SENode* operand_1 = multiply->GetChild(0); SENode* operand_2 = multiply->GetChild(1); SENode* value_unknown = nullptr; SENode* constant = nullptr; // Work out which operand is the unknown value. if (operand_1->GetType() == SENode::ValueUnknown || operand_1->GetType() == SENode::RecurrentAddExpr) value_unknown = operand_1; else if (operand_2->GetType() == SENode::ValueUnknown || operand_2->GetType() == SENode::RecurrentAddExpr) value_unknown = operand_2; // Work out which operand is the constant coefficient. if (operand_1->GetType() == SENode::Constant) constant = operand_1; else if (operand_2->GetType() == SENode::Constant) constant = operand_2; // If the expression is not a variable multiplied by a constant coefficient, // exit out. if (!(value_unknown && constant)) { return false; } int64_t sign = negation ? -1 : 1; auto iterator = accumulators_.find(value_unknown); int64_t new_value = constant->AsSEConstantNode()->FoldToSingleValue() * sign; // Add the result of the multiplication to the accumulators. if (iterator != accumulators_.end()) { (*iterator).second += new_value; } else { accumulators_.insert({value_unknown, new_value}); } return true; } SENode* SENodeSimplifyImpl::Simplify() { // We only handle graphs with an addition, multiplication, or negation, at the // root. if (node_->GetType() != SENode::Add && node_->GetType() != SENode::Multiply && node_->GetType() != SENode::Negative) return node_; SENode* simplified_polynomial = SimplifyPolynomial(); SERecurrentNode* recurrent_expr = nullptr; node_ = simplified_polynomial; // Fold recurrent expressions which are with respect to the same loop into a // single recurrent expression. simplified_polynomial = FoldRecurrentAddExpressions(simplified_polynomial); simplified_polynomial = EliminateZeroCoefficientRecurrents(simplified_polynomial); // Traverse the immediate children of the new node to find the recurrent // expression. If there is more than one there is nothing further we can do. for (SENode* child : simplified_polynomial->GetChildren()) { if (child->GetType() == SENode::RecurrentAddExpr) { recurrent_expr = child->AsSERecurrentNode(); } } // We need to count the number of unique recurrent expressions in the DAG to // ensure there is only one. for (auto child_iterator = simplified_polynomial->graph_begin(); child_iterator != simplified_polynomial->graph_end(); ++child_iterator) { if (child_iterator->GetType() == SENode::RecurrentAddExpr && recurrent_expr != child_iterator->AsSERecurrentNode()) { return simplified_polynomial; } } if (recurrent_expr) { return SimplifyRecurrentAddExpression(recurrent_expr); } return simplified_polynomial; } // Traverse the graph to build up the accumulator objects. void SENodeSimplifyImpl::GatherAccumulatorsFromChildNodes(SENode* new_node, SENode* child, bool negation) { int32_t sign = negation ? -1 : 1; if (child->GetType() == SENode::Constant) { // Collect all the constants and add them together. constant_accumulator_ += child->AsSEConstantNode()->FoldToSingleValue() * sign; } else if (child->GetType() == SENode::ValueUnknown || child->GetType() == SENode::RecurrentAddExpr) { // To rebuild the graph of X+X+X*2 into 4*X we count the occurrences of X // and create a new node of count*X after. X can either be a ValueUnknown or // a RecurrentAddExpr. The count for each X is stored in the accumulators_ // map. auto iterator = accumulators_.find(child); // If we've encountered this term before add to the accumulator for it. if (iterator == accumulators_.end()) accumulators_.insert({child, sign}); else iterator->second += sign; } else if (child->GetType() == SENode::Multiply) { if (!AccumulatorsFromMultiply(child, negation)) { new_node->AddChild(child); } } else if (child->GetType() == SENode::Add) { for (SENode* next_child : *child) { GatherAccumulatorsFromChildNodes(new_node, next_child, negation); } } else if (child->GetType() == SENode::Negative) { SENode* negated_node = child->GetChild(0); GatherAccumulatorsFromChildNodes(new_node, negated_node, !negation); } else { // If we can't work out how to fold the expression just add it back into // the graph. new_node->AddChild(child); } } SERecurrentNode* SENodeSimplifyImpl::UpdateCoefficient( SERecurrentNode* recurrent, int64_t coefficient_update) const { std::unique_ptr new_recurrent_node{new SERecurrentNode( recurrent->GetParentAnalysis(), recurrent->GetLoop())}; SENode* new_coefficient = analysis_.CreateMultiplyNode( recurrent->GetCoefficient(), analysis_.CreateConstant(coefficient_update)); // See if the node can be simplified. SENode* simplified = analysis_.SimplifyExpression(new_coefficient); if (simplified->GetType() != SENode::CanNotCompute) new_coefficient = simplified; if (coefficient_update < 0) { new_recurrent_node->AddOffset( analysis_.CreateNegation(recurrent->GetOffset())); } else { new_recurrent_node->AddOffset(recurrent->GetOffset()); } new_recurrent_node->AddCoefficient(new_coefficient); return analysis_.GetCachedOrAdd(std::move(new_recurrent_node)) ->AsSERecurrentNode(); } // Simplify all the terms in the polynomial function. SENode* SENodeSimplifyImpl::SimplifyPolynomial() { std::unique_ptr new_add{new SEAddNode(node_->GetParentAnalysis())}; // Traverse the graph and gather the accumulators from it. GatherAccumulatorsFromChildNodes(new_add.get(), node_, false); // Fold all the constants into a single constant node. if (constant_accumulator_ != 0) { new_add->AddChild(analysis_.CreateConstant(constant_accumulator_)); } for (auto& pair : accumulators_) { SENode* term = pair.first; int64_t count = pair.second; // We can eliminate the term completely. if (count == 0) continue; if (count == 1) { new_add->AddChild(term); } else if (count == -1 && term->GetType() != SENode::RecurrentAddExpr) { // If the count is -1 we can just add a negative version of that node, // unless it is a recurrent expression as we would rather the negative // goes on the recurrent expressions children. This makes it easier to // work with in other places. new_add->AddChild(analysis_.CreateNegation(term)); } else { // Output value unknown terms as count*term and output recurrent // expression terms as rec(offset, coefficient + count) offset and // coefficient are the same as in the original expression. if (term->GetType() == SENode::ValueUnknown) { SENode* count_as_constant = analysis_.CreateConstant(count); new_add->AddChild( analysis_.CreateMultiplyNode(count_as_constant, term)); } else { assert(term->GetType() == SENode::RecurrentAddExpr && "We only handle value unknowns or recurrent expressions"); // Create a new recurrent expression by adding the count to the // coefficient of the old one. new_add->AddChild(UpdateCoefficient(term->AsSERecurrentNode(), count)); } } } // If there is only one term in the addition left just return that term. if (new_add->GetChildren().size() == 1) { return new_add->GetChild(0); } // If there are no terms left in the addition just return 0. if (new_add->GetChildren().size() == 0) { return analysis_.CreateConstant(0); } return analysis_.GetCachedOrAdd(std::move(new_add)); } SENode* SENodeSimplifyImpl::FoldRecurrentAddExpressions(SENode* root) { std::unique_ptr new_node{new SEAddNode(&analysis_)}; // A mapping of loops to the list of recurrent expressions which are with // respect to those loops. std::map>> loops_to_recurrent{}; bool has_multiple_same_loop_recurrent_terms = false; for (SENode* child : *root) { bool negation = false; if (child->GetType() == SENode::Negative) { child = child->GetChild(0); negation = true; } if (child->GetType() == SENode::RecurrentAddExpr) { const Loop* loop = child->AsSERecurrentNode()->GetLoop(); SERecurrentNode* rec = child->AsSERecurrentNode(); if (loops_to_recurrent.find(loop) == loops_to_recurrent.end()) { loops_to_recurrent[loop] = {std::make_pair(rec, negation)}; } else { loops_to_recurrent[loop].push_back(std::make_pair(rec, negation)); has_multiple_same_loop_recurrent_terms = true; } } else { new_node->AddChild(child); } } if (!has_multiple_same_loop_recurrent_terms) return root; for (auto pair : loops_to_recurrent) { std::vector>& recurrent_expressions = pair.second; const Loop* loop = pair.first; std::unique_ptr new_coefficient{new SEAddNode(&analysis_)}; std::unique_ptr new_offset{new SEAddNode(&analysis_)}; for (auto node_pair : recurrent_expressions) { SERecurrentNode* node = node_pair.first; bool negative = node_pair.second; if (!negative) { new_coefficient->AddChild(node->GetCoefficient()); new_offset->AddChild(node->GetOffset()); } else { new_coefficient->AddChild( analysis_.CreateNegation(node->GetCoefficient())); new_offset->AddChild(analysis_.CreateNegation(node->GetOffset())); } } std::unique_ptr new_recurrent{ new SERecurrentNode(&analysis_, loop)}; SENode* new_coefficient_simplified = analysis_.SimplifyExpression(new_coefficient.get()); SENode* new_offset_simplified = analysis_.SimplifyExpression(new_offset.get()); if (new_coefficient_simplified->GetType() == SENode::Constant && new_coefficient_simplified->AsSEConstantNode()->FoldToSingleValue() == 0) { return new_offset_simplified; } new_recurrent->AddCoefficient(new_coefficient_simplified); new_recurrent->AddOffset(new_offset_simplified); new_node->AddChild(analysis_.GetCachedOrAdd(std::move(new_recurrent))); } // If we only have one child in the add just return that. if (new_node->GetChildren().size() == 1) { return new_node->GetChild(0); } return analysis_.GetCachedOrAdd(std::move(new_node)); } SENode* SENodeSimplifyImpl::EliminateZeroCoefficientRecurrents(SENode* node) { if (node->GetType() != SENode::Add) return node; bool has_change = false; std::vector new_children{}; for (SENode* child : *node) { if (child->GetType() == SENode::RecurrentAddExpr) { SENode* coefficient = child->AsSERecurrentNode()->GetCoefficient(); // If coefficient is zero then we can eliminate the recurrent expression // entirely and just return the offset as the recurrent expression is // representing the equation coefficient*iterations + offset. if (coefficient->GetType() == SENode::Constant && coefficient->AsSEConstantNode()->FoldToSingleValue() == 0) { new_children.push_back(child->AsSERecurrentNode()->GetOffset()); has_change = true; } else { new_children.push_back(child); } } else { new_children.push_back(child); } } if (!has_change) return node; std::unique_ptr new_add{new SEAddNode(node_->GetParentAnalysis())}; for (SENode* child : new_children) { new_add->AddChild(child); } return analysis_.GetCachedOrAdd(std::move(new_add)); } SENode* SENodeSimplifyImpl::SimplifyRecurrentAddExpression( SERecurrentNode* recurrent_expr) { const std::vector& children = node_->GetChildren(); std::unique_ptr recurrent_node{new SERecurrentNode( recurrent_expr->GetParentAnalysis(), recurrent_expr->GetLoop())}; // Create and simplify the new offset node. std::unique_ptr new_offset{ new SEAddNode(recurrent_expr->GetParentAnalysis())}; new_offset->AddChild(recurrent_expr->GetOffset()); for (SENode* child : children) { if (child->GetType() != SENode::RecurrentAddExpr) { new_offset->AddChild(child); } } // Simplify the new offset. SENode* simplified_child = analysis_.SimplifyExpression(new_offset.get()); // If the child can be simplified, add the simplified form otherwise, add it // via the usual caching mechanism. if (simplified_child->GetType() != SENode::CanNotCompute) { recurrent_node->AddOffset(simplified_child); } else { recurrent_expr->AddOffset(analysis_.GetCachedOrAdd(std::move(new_offset))); } recurrent_node->AddCoefficient(recurrent_expr->GetCoefficient()); return analysis_.GetCachedOrAdd(std::move(recurrent_node)); } /* * Scalar Analysis simplification public methods. */ SENode* ScalarEvolutionAnalysis::SimplifyExpression(SENode* node) { SENodeSimplifyImpl impl{this, node}; return impl.Simplify(); } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/scalar_replacement_pass.cpp000066400000000000000000001053471475742701700262230ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // Modifications Copyright (C) 2024 Advanced Micro Devices, Inc. All rights // reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/scalar_replacement_pass.h" #include #include #include #include #include "source/extensions.h" #include "source/opt/reflect.h" #include "source/opt/types.h" #include "source/util/make_unique.h" namespace spvtools { namespace opt { namespace { constexpr uint32_t kDebugValueOperandValueIndex = 5; constexpr uint32_t kDebugValueOperandExpressionIndex = 6; constexpr uint32_t kDebugDeclareOperandVariableIndex = 5; } // namespace Pass::Status ScalarReplacementPass::Process() { Status status = Status::SuccessWithoutChange; for (auto& f : *get_module()) { if (f.IsDeclaration()) { continue; } Status functionStatus = ProcessFunction(&f); if (functionStatus == Status::Failure) return functionStatus; else if (functionStatus == Status::SuccessWithChange) status = functionStatus; } return status; } Pass::Status ScalarReplacementPass::ProcessFunction(Function* function) { std::queue worklist; BasicBlock& entry = *function->begin(); for (auto iter = entry.begin(); iter != entry.end(); ++iter) { // Function storage class OpVariables must appear as the first instructions // of the entry block. if (iter->opcode() != spv::Op::OpVariable) break; Instruction* varInst = &*iter; if (CanReplaceVariable(varInst)) { worklist.push(varInst); } } Status status = Status::SuccessWithoutChange; while (!worklist.empty()) { Instruction* varInst = worklist.front(); worklist.pop(); Status var_status = ReplaceVariable(varInst, &worklist); if (var_status == Status::Failure) return var_status; else if (var_status == Status::SuccessWithChange) status = var_status; } return status; } Pass::Status ScalarReplacementPass::ReplaceVariable( Instruction* inst, std::queue* worklist) { std::vector replacements; if (!CreateReplacementVariables(inst, &replacements)) { return Status::Failure; } std::vector dead; bool replaced_all_uses = get_def_use_mgr()->WhileEachUser( inst, [this, &replacements, &dead](Instruction* user) { if (user->GetCommonDebugOpcode() == CommonDebugInfoDebugDeclare) { if (ReplaceWholeDebugDeclare(user, replacements)) { dead.push_back(user); return true; } return false; } if (user->GetCommonDebugOpcode() == CommonDebugInfoDebugValue) { if (ReplaceWholeDebugValue(user, replacements)) { dead.push_back(user); return true; } return false; } if (!IsAnnotationInst(user->opcode())) { switch (user->opcode()) { case spv::Op::OpLoad: if (ReplaceWholeLoad(user, replacements)) { dead.push_back(user); } else { return false; } break; case spv::Op::OpStore: if (ReplaceWholeStore(user, replacements)) { dead.push_back(user); } else { return false; } break; case spv::Op::OpAccessChain: case spv::Op::OpInBoundsAccessChain: if (ReplaceAccessChain(user, replacements)) dead.push_back(user); else return false; break; case spv::Op::OpName: case spv::Op::OpMemberName: break; default: assert(false && "Unexpected opcode"); break; } } return true; }); if (replaced_all_uses) { dead.push_back(inst); } else { return Status::Failure; } // If there are no dead instructions to clean up, return with no changes. if (dead.empty()) return Status::SuccessWithoutChange; // Clean up some dead code. while (!dead.empty()) { Instruction* toKill = dead.back(); dead.pop_back(); context()->KillInst(toKill); } // Attempt to further scalarize. for (auto var : replacements) { if (var->opcode() == spv::Op::OpVariable) { if (get_def_use_mgr()->NumUsers(var) == 0) { context()->KillInst(var); } else if (CanReplaceVariable(var)) { worklist->push(var); } } } return Status::SuccessWithChange; } bool ScalarReplacementPass::ReplaceWholeDebugDeclare( Instruction* dbg_decl, const std::vector& replacements) { // Insert Deref operation to the front of the operation list of |dbg_decl|. Instruction* dbg_expr = context()->get_def_use_mgr()->GetDef( dbg_decl->GetSingleWordOperand(kDebugValueOperandExpressionIndex)); auto* deref_expr = context()->get_debug_info_mgr()->DerefDebugExpression(dbg_expr); // Add DebugValue instruction with Indexes operand and Deref operation. int32_t idx = 0; for (const auto* var : replacements) { Instruction* insert_before = var->NextNode(); while (insert_before->opcode() == spv::Op::OpVariable) insert_before = insert_before->NextNode(); assert(insert_before != nullptr && "unexpected end of list"); Instruction* added_dbg_value = context()->get_debug_info_mgr()->AddDebugValueForDecl( dbg_decl, /*value_id=*/var->result_id(), /*insert_before=*/insert_before, /*scope_and_line=*/dbg_decl); if (added_dbg_value == nullptr) return false; added_dbg_value->AddOperand( {SPV_OPERAND_TYPE_ID, {context()->get_constant_mgr()->GetSIntConstId(idx)}}); added_dbg_value->SetOperand(kDebugValueOperandExpressionIndex, {deref_expr->result_id()}); if (context()->AreAnalysesValid(IRContext::Analysis::kAnalysisDefUse)) { context()->get_def_use_mgr()->AnalyzeInstUse(added_dbg_value); } ++idx; } return true; } bool ScalarReplacementPass::ReplaceWholeDebugValue( Instruction* dbg_value, const std::vector& replacements) { int32_t idx = 0; BasicBlock* block = context()->get_instr_block(dbg_value); for (auto var : replacements) { // Clone the DebugValue. std::unique_ptr new_dbg_value(dbg_value->Clone(context())); uint32_t new_id = TakeNextId(); if (new_id == 0) return false; new_dbg_value->SetResultId(new_id); // Update 'Value' operand to the |replacements|. new_dbg_value->SetOperand(kDebugValueOperandValueIndex, {var->result_id()}); // Append 'Indexes' operand. new_dbg_value->AddOperand( {SPV_OPERAND_TYPE_ID, {context()->get_constant_mgr()->GetSIntConstId(idx)}}); // Insert the new DebugValue to the basic block. auto* added_instr = dbg_value->InsertBefore(std::move(new_dbg_value)); get_def_use_mgr()->AnalyzeInstDefUse(added_instr); context()->set_instr_block(added_instr, block); ++idx; } return true; } bool ScalarReplacementPass::ReplaceWholeLoad( Instruction* load, const std::vector& replacements) { // Replaces the load of the entire composite with a load from each replacement // variable followed by a composite construction. BasicBlock* block = context()->get_instr_block(load); std::vector loads; loads.reserve(replacements.size()); BasicBlock::iterator where(load); for (auto var : replacements) { // Create a load of each replacement variable. if (var->opcode() != spv::Op::OpVariable) { loads.push_back(var); continue; } Instruction* type = GetStorageType(var); uint32_t loadId = TakeNextId(); if (loadId == 0) { return false; } std::unique_ptr newLoad( new Instruction(context(), spv::Op::OpLoad, type->result_id(), loadId, std::initializer_list{ {SPV_OPERAND_TYPE_ID, {var->result_id()}}})); // Copy memory access attributes which start at index 1. Index 0 is the // pointer to load. for (uint32_t i = 1; i < load->NumInOperands(); ++i) { Operand copy(load->GetInOperand(i)); newLoad->AddOperand(std::move(copy)); } where = where.InsertBefore(std::move(newLoad)); get_def_use_mgr()->AnalyzeInstDefUse(&*where); context()->set_instr_block(&*where, block); where->UpdateDebugInfoFrom(load); loads.push_back(&*where); } // Construct a new composite. uint32_t compositeId = TakeNextId(); if (compositeId == 0) { return false; } where = load; std::unique_ptr compositeConstruct( new Instruction(context(), spv::Op::OpCompositeConstruct, load->type_id(), compositeId, {})); for (auto l : loads) { Operand op(SPV_OPERAND_TYPE_ID, std::initializer_list{l->result_id()}); compositeConstruct->AddOperand(std::move(op)); } where = where.InsertBefore(std::move(compositeConstruct)); get_def_use_mgr()->AnalyzeInstDefUse(&*where); where->UpdateDebugInfoFrom(load); context()->set_instr_block(&*where, block); context()->ReplaceAllUsesWith(load->result_id(), compositeId); return true; } bool ScalarReplacementPass::ReplaceWholeStore( Instruction* store, const std::vector& replacements) { // Replaces a store to the whole composite with a series of extract and stores // to each element. uint32_t storeInput = store->GetSingleWordInOperand(1u); BasicBlock* block = context()->get_instr_block(store); BasicBlock::iterator where(store); uint32_t elementIndex = 0; for (auto var : replacements) { // Create the extract. if (var->opcode() != spv::Op::OpVariable) { elementIndex++; continue; } Instruction* type = GetStorageType(var); uint32_t extractId = TakeNextId(); if (extractId == 0) { return false; } std::unique_ptr extract(new Instruction( context(), spv::Op::OpCompositeExtract, type->result_id(), extractId, std::initializer_list{ {SPV_OPERAND_TYPE_ID, {storeInput}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {elementIndex++}}})); auto iter = where.InsertBefore(std::move(extract)); iter->UpdateDebugInfoFrom(store); get_def_use_mgr()->AnalyzeInstDefUse(&*iter); context()->set_instr_block(&*iter, block); // Create the store. std::unique_ptr newStore( new Instruction(context(), spv::Op::OpStore, 0, 0, std::initializer_list{ {SPV_OPERAND_TYPE_ID, {var->result_id()}}, {SPV_OPERAND_TYPE_ID, {extractId}}})); // Copy memory access attributes which start at index 2. Index 0 is the // pointer and index 1 is the data. for (uint32_t i = 2; i < store->NumInOperands(); ++i) { Operand copy(store->GetInOperand(i)); newStore->AddOperand(std::move(copy)); } iter = where.InsertBefore(std::move(newStore)); iter->UpdateDebugInfoFrom(store); get_def_use_mgr()->AnalyzeInstDefUse(&*iter); context()->set_instr_block(&*iter, block); } return true; } bool ScalarReplacementPass::ReplaceAccessChain( Instruction* chain, const std::vector& replacements) { // Replaces the access chain with either another access chain (with one fewer // indexes) or a direct use of the replacement variable. uint32_t indexId = chain->GetSingleWordInOperand(1u); const Instruction* index = get_def_use_mgr()->GetDef(indexId); int64_t indexValue = context() ->get_constant_mgr() ->GetConstantFromInst(index) ->GetSignExtendedValue(); if (indexValue < 0 || indexValue >= static_cast(replacements.size())) { // Out of bounds access, this is illegal IR. Notice that OpAccessChain // indexing is 0-based, so we should also reject index == size-of-array. return false; } else { const Instruction* var = replacements[static_cast(indexValue)]; if (chain->NumInOperands() > 2) { // Replace input access chain with another access chain. BasicBlock::iterator chainIter(chain); uint32_t replacementId = TakeNextId(); if (replacementId == 0) { return false; } std::unique_ptr replacementChain(new Instruction( context(), chain->opcode(), chain->type_id(), replacementId, std::initializer_list{ {SPV_OPERAND_TYPE_ID, {var->result_id()}}})); // Add the remaining indexes. for (uint32_t i = 2; i < chain->NumInOperands(); ++i) { Operand copy(chain->GetInOperand(i)); replacementChain->AddOperand(std::move(copy)); } replacementChain->UpdateDebugInfoFrom(chain); auto iter = chainIter.InsertBefore(std::move(replacementChain)); get_def_use_mgr()->AnalyzeInstDefUse(&*iter); context()->set_instr_block(&*iter, context()->get_instr_block(chain)); context()->ReplaceAllUsesWith(chain->result_id(), replacementId); } else { // Replace with a use of the variable. context()->ReplaceAllUsesWith(chain->result_id(), var->result_id()); } } return true; } bool ScalarReplacementPass::CreateReplacementVariables( Instruction* inst, std::vector* replacements) { Instruction* type = GetStorageType(inst); std::unique_ptr> components_used = GetUsedComponents(inst); uint32_t elem = 0; switch (type->opcode()) { case spv::Op::OpTypeStruct: type->ForEachInOperand( [this, inst, &elem, replacements, &components_used](uint32_t* id) { if (!components_used || components_used->count(elem)) { CreateVariable(*id, inst, elem, replacements); } else { replacements->push_back(GetUndef(*id)); } elem++; }); break; case spv::Op::OpTypeArray: for (uint32_t i = 0; i != GetArrayLength(type); ++i) { if (!components_used || components_used->count(i)) { CreateVariable(type->GetSingleWordInOperand(0u), inst, i, replacements); } else { uint32_t element_type_id = type->GetSingleWordInOperand(0); replacements->push_back(GetUndef(element_type_id)); } } break; case spv::Op::OpTypeMatrix: case spv::Op::OpTypeVector: for (uint32_t i = 0; i != GetNumElements(type); ++i) { CreateVariable(type->GetSingleWordInOperand(0u), inst, i, replacements); } break; default: assert(false && "Unexpected type."); break; } TransferAnnotations(inst, replacements); return std::find(replacements->begin(), replacements->end(), nullptr) == replacements->end(); } Instruction* ScalarReplacementPass::GetUndef(uint32_t type_id) { return get_def_use_mgr()->GetDef(Type2Undef(type_id)); } void ScalarReplacementPass::TransferAnnotations( const Instruction* source, std::vector* replacements) { // Only transfer invariant and restrict decorations on the variable. There are // no type or member decorations that are necessary to transfer. for (auto inst : get_decoration_mgr()->GetDecorationsFor(source->result_id(), false)) { assert(inst->opcode() == spv::Op::OpDecorate); auto decoration = spv::Decoration(inst->GetSingleWordInOperand(1u)); if (decoration == spv::Decoration::Invariant || decoration == spv::Decoration::Restrict) { for (auto var : *replacements) { if (var == nullptr) { continue; } std::unique_ptr annotation(new Instruction( context(), spv::Op::OpDecorate, 0, 0, std::initializer_list{ {SPV_OPERAND_TYPE_ID, {var->result_id()}}, {SPV_OPERAND_TYPE_DECORATION, {uint32_t(decoration)}}})); for (uint32_t i = 2; i < inst->NumInOperands(); ++i) { Operand copy(inst->GetInOperand(i)); annotation->AddOperand(std::move(copy)); } context()->AddAnnotationInst(std::move(annotation)); get_def_use_mgr()->AnalyzeInstUse(&*--context()->annotation_end()); } } } } void ScalarReplacementPass::CreateVariable( uint32_t type_id, Instruction* var_inst, uint32_t index, std::vector* replacements) { uint32_t ptr_id = GetOrCreatePointerType(type_id); uint32_t id = TakeNextId(); if (id == 0) { replacements->push_back(nullptr); } std::unique_ptr variable( new Instruction(context(), spv::Op::OpVariable, ptr_id, id, std::initializer_list{ {SPV_OPERAND_TYPE_STORAGE_CLASS, {uint32_t(spv::StorageClass::Function)}}})); BasicBlock* block = context()->get_instr_block(var_inst); block->begin().InsertBefore(std::move(variable)); Instruction* inst = &*block->begin(); // If varInst was initialized, make sure to initialize its replacement. GetOrCreateInitialValue(var_inst, index, inst); get_def_use_mgr()->AnalyzeInstDefUse(inst); context()->set_instr_block(inst, block); CopyDecorationsToVariable(var_inst, inst, index); inst->UpdateDebugInfoFrom(var_inst); replacements->push_back(inst); } uint32_t ScalarReplacementPass::GetOrCreatePointerType(uint32_t id) { auto iter = pointee_to_pointer_.find(id); if (iter != pointee_to_pointer_.end()) return iter->second; analysis::TypeManager* type_mgr = context()->get_type_mgr(); uint32_t ptr_type_id = type_mgr->FindPointerToType(id, spv::StorageClass::Function); pointee_to_pointer_[id] = ptr_type_id; return ptr_type_id; } void ScalarReplacementPass::GetOrCreateInitialValue(Instruction* source, uint32_t index, Instruction* newVar) { assert(source->opcode() == spv::Op::OpVariable); if (source->NumInOperands() < 2) return; uint32_t initId = source->GetSingleWordInOperand(1u); uint32_t storageId = GetStorageType(newVar)->result_id(); Instruction* init = get_def_use_mgr()->GetDef(initId); uint32_t newInitId = 0; // TODO(dnovillo): Refactor this with constant propagation. if (init->opcode() == spv::Op::OpConstantNull) { // Initialize to appropriate NULL. auto iter = type_to_null_.find(storageId); if (iter == type_to_null_.end()) { newInitId = TakeNextId(); type_to_null_[storageId] = newInitId; context()->AddGlobalValue( MakeUnique(context(), spv::Op::OpConstantNull, storageId, newInitId, std::initializer_list{})); Instruction* newNull = &*--context()->types_values_end(); get_def_use_mgr()->AnalyzeInstDefUse(newNull); } else { newInitId = iter->second; } } else if (IsSpecConstantInst(init->opcode())) { // Create a new constant extract. newInitId = TakeNextId(); context()->AddGlobalValue(MakeUnique( context(), spv::Op::OpSpecConstantOp, storageId, newInitId, std::initializer_list{ {SPV_OPERAND_TYPE_SPEC_CONSTANT_OP_NUMBER, {uint32_t(spv::Op::OpCompositeExtract)}}, {SPV_OPERAND_TYPE_ID, {init->result_id()}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {index}}})); Instruction* newSpecConst = &*--context()->types_values_end(); get_def_use_mgr()->AnalyzeInstDefUse(newSpecConst); } else if (init->opcode() == spv::Op::OpConstantComposite) { // Get the appropriate index constant. newInitId = init->GetSingleWordInOperand(index); Instruction* element = get_def_use_mgr()->GetDef(newInitId); if (element->opcode() == spv::Op::OpUndef) { // Undef is not a valid initializer for a variable. newInitId = 0; } } else { assert(false); } if (newInitId != 0) { newVar->AddOperand({SPV_OPERAND_TYPE_ID, {newInitId}}); } } uint64_t ScalarReplacementPass::GetArrayLength( const Instruction* arrayType) const { assert(arrayType->opcode() == spv::Op::OpTypeArray); const Instruction* length = get_def_use_mgr()->GetDef(arrayType->GetSingleWordInOperand(1u)); return context() ->get_constant_mgr() ->GetConstantFromInst(length) ->GetZeroExtendedValue(); } uint64_t ScalarReplacementPass::GetNumElements(const Instruction* type) const { assert(type->opcode() == spv::Op::OpTypeVector || type->opcode() == spv::Op::OpTypeMatrix); const Operand& op = type->GetInOperand(1u); assert(op.words.size() <= 2); uint64_t len = 0; for (size_t i = 0; i != op.words.size(); ++i) { len |= (static_cast(op.words[i]) << (32ull * i)); } return len; } bool ScalarReplacementPass::IsSpecConstant(uint32_t id) const { const Instruction* inst = get_def_use_mgr()->GetDef(id); assert(inst); return spvOpcodeIsSpecConstant(inst->opcode()); } Instruction* ScalarReplacementPass::GetStorageType( const Instruction* inst) const { assert(inst->opcode() == spv::Op::OpVariable); uint32_t ptrTypeId = inst->type_id(); uint32_t typeId = get_def_use_mgr()->GetDef(ptrTypeId)->GetSingleWordInOperand(1u); return get_def_use_mgr()->GetDef(typeId); } bool ScalarReplacementPass::CanReplaceVariable( const Instruction* varInst) const { assert(varInst->opcode() == spv::Op::OpVariable); // Can only replace function scope variables. if (spv::StorageClass(varInst->GetSingleWordInOperand(0u)) != spv::StorageClass::Function) { return false; } if (!CheckTypeAnnotations(get_def_use_mgr()->GetDef(varInst->type_id()))) { return false; } const Instruction* typeInst = GetStorageType(varInst); if (!CheckType(typeInst)) { return false; } if (!CheckAnnotations(varInst)) { return false; } if (!CheckUses(varInst)) { return false; } return true; } bool ScalarReplacementPass::CheckType(const Instruction* typeInst) const { if (!CheckTypeAnnotations(typeInst)) { return false; } switch (typeInst->opcode()) { case spv::Op::OpTypeStruct: // Don't bother with empty structs or very large structs. if (typeInst->NumInOperands() == 0 || IsLargerThanSizeLimit(typeInst->NumInOperands())) { return false; } return true; case spv::Op::OpTypeArray: if (IsSpecConstant(typeInst->GetSingleWordInOperand(1u))) { return false; } if (IsLargerThanSizeLimit(GetArrayLength(typeInst))) { return false; } return true; // TODO(alanbaker): Develop some heuristics for when this should be // re-enabled. //// Specifically including matrix and vector in an attempt to reduce the //// number of vector registers required. // case spv::Op::OpTypeMatrix: // case spv::Op::OpTypeVector: // if (IsLargerThanSizeLimit(GetNumElements(typeInst))) return false; // return true; case spv::Op::OpTypeRuntimeArray: default: return false; } } bool ScalarReplacementPass::CheckTypeAnnotations( const Instruction* typeInst) const { for (auto inst : get_decoration_mgr()->GetDecorationsFor(typeInst->result_id(), false)) { uint32_t decoration; if (inst->opcode() == spv::Op::OpDecorate || inst->opcode() == spv::Op::OpDecorateId) { decoration = inst->GetSingleWordInOperand(1u); } else { assert(inst->opcode() == spv::Op::OpMemberDecorate); decoration = inst->GetSingleWordInOperand(2u); } switch (spv::Decoration(decoration)) { case spv::Decoration::RowMajor: case spv::Decoration::ColMajor: case spv::Decoration::ArrayStride: case spv::Decoration::MatrixStride: case spv::Decoration::CPacked: case spv::Decoration::Invariant: case spv::Decoration::Restrict: case spv::Decoration::Offset: case spv::Decoration::Alignment: case spv::Decoration::AlignmentId: case spv::Decoration::MaxByteOffset: case spv::Decoration::RelaxedPrecision: case spv::Decoration::AliasedPointer: case spv::Decoration::RestrictPointer: break; default: return false; } } return true; } bool ScalarReplacementPass::CheckAnnotations(const Instruction* varInst) const { for (auto inst : get_decoration_mgr()->GetDecorationsFor(varInst->result_id(), false)) { assert(inst->opcode() == spv::Op::OpDecorate); auto decoration = spv::Decoration(inst->GetSingleWordInOperand(1u)); switch (decoration) { case spv::Decoration::Invariant: case spv::Decoration::Restrict: case spv::Decoration::Alignment: case spv::Decoration::AlignmentId: case spv::Decoration::MaxByteOffset: case spv::Decoration::AliasedPointer: case spv::Decoration::RestrictPointer: break; default: return false; } } return true; } bool ScalarReplacementPass::CheckUses(const Instruction* inst) const { VariableStats stats = {0, 0}; bool ok = CheckUses(inst, &stats); // TODO(alanbaker/greg-lunarg): Add some meaningful heuristics about when // SRoA is costly, such as when the structure has many (unaccessed?) // members. return ok; } bool ScalarReplacementPass::CheckUses(const Instruction* inst, VariableStats* stats) const { uint64_t max_legal_index = GetMaxLegalIndex(inst); bool ok = true; get_def_use_mgr()->ForEachUse(inst, [this, max_legal_index, stats, &ok]( const Instruction* user, uint32_t index) { if (user->GetCommonDebugOpcode() == CommonDebugInfoDebugDeclare || user->GetCommonDebugOpcode() == CommonDebugInfoDebugValue) { // TODO: include num_partial_accesses if it uses Fragment operation or // DebugValue has Indexes operand. stats->num_full_accesses++; return; } // Annotations are check as a group separately. if (!IsAnnotationInst(user->opcode())) { switch (user->opcode()) { case spv::Op::OpAccessChain: case spv::Op::OpInBoundsAccessChain: if (index == 2u && user->NumInOperands() > 1) { uint32_t id = user->GetSingleWordInOperand(1u); const Instruction* opInst = get_def_use_mgr()->GetDef(id); const auto* constant = context()->get_constant_mgr()->GetConstantFromInst(opInst); if (!constant) { ok = false; } else if (constant->GetZeroExtendedValue() >= max_legal_index) { ok = false; } else { if (!CheckUsesRelaxed(user)) ok = false; } stats->num_partial_accesses++; } else { ok = false; } break; case spv::Op::OpLoad: if (!CheckLoad(user, index)) ok = false; stats->num_full_accesses++; break; case spv::Op::OpStore: if (!CheckStore(user, index)) ok = false; stats->num_full_accesses++; break; case spv::Op::OpName: case spv::Op::OpMemberName: break; default: ok = false; break; } } }); return ok; } bool ScalarReplacementPass::CheckUsesRelaxed(const Instruction* inst) const { bool ok = true; get_def_use_mgr()->ForEachUse( inst, [this, &ok](const Instruction* user, uint32_t index) { switch (user->opcode()) { case spv::Op::OpAccessChain: case spv::Op::OpInBoundsAccessChain: if (index != 2u) { ok = false; } else { if (!CheckUsesRelaxed(user)) ok = false; } break; case spv::Op::OpLoad: if (!CheckLoad(user, index)) ok = false; break; case spv::Op::OpStore: if (!CheckStore(user, index)) ok = false; break; case spv::Op::OpImageTexelPointer: if (!CheckImageTexelPointer(index)) ok = false; break; case spv::Op::OpExtInst: if (user->GetCommonDebugOpcode() != CommonDebugInfoDebugDeclare || !CheckDebugDeclare(index)) ok = false; break; default: ok = false; break; } }); return ok; } bool ScalarReplacementPass::CheckImageTexelPointer(uint32_t index) const { return index == 2u; } bool ScalarReplacementPass::CheckLoad(const Instruction* inst, uint32_t index) const { if (index != 2u) return false; if (inst->NumInOperands() >= 2 && inst->GetSingleWordInOperand(1u) & uint32_t(spv::MemoryAccessMask::Volatile)) return false; return true; } bool ScalarReplacementPass::CheckStore(const Instruction* inst, uint32_t index) const { if (index != 0u) return false; if (inst->NumInOperands() >= 3 && inst->GetSingleWordInOperand(2u) & uint32_t(spv::MemoryAccessMask::Volatile)) return false; return true; } bool ScalarReplacementPass::CheckDebugDeclare(uint32_t index) const { if (index != kDebugDeclareOperandVariableIndex) return false; return true; } bool ScalarReplacementPass::IsLargerThanSizeLimit(uint64_t length) const { if (max_num_elements_ == 0) { return false; } return length > max_num_elements_; } std::unique_ptr> ScalarReplacementPass::GetUsedComponents(Instruction* inst) { std::unique_ptr> result( new std::unordered_set()); analysis::DefUseManager* def_use_mgr = context()->get_def_use_mgr(); def_use_mgr->WhileEachUser(inst, [&result, def_use_mgr, this](Instruction* use) { switch (use->opcode()) { case spv::Op::OpLoad: { // Look for extract from the load. std::vector t; if (def_use_mgr->WhileEachUser(use, [&t](Instruction* use2) { if (use2->opcode() != spv::Op::OpCompositeExtract || use2->NumInOperands() <= 1) { return false; } t.push_back(use2->GetSingleWordInOperand(1)); return true; })) { result->insert(t.begin(), t.end()); return true; } else { result.reset(nullptr); return false; } } case spv::Op::OpName: case spv::Op::OpMemberName: case spv::Op::OpStore: // No components are used. return true; case spv::Op::OpAccessChain: case spv::Op::OpInBoundsAccessChain: { // Add the first index it if is a constant. // TODO: Could be improved by checking if the address is used in a load. analysis::ConstantManager* const_mgr = context()->get_constant_mgr(); uint32_t index_id = use->GetSingleWordInOperand(1); const analysis::Constant* index_const = const_mgr->FindDeclaredConstant(index_id); if (index_const) { result->insert(index_const->GetSignExtendedValue()); return true; } else { // Could be any element. Assuming all are used. result.reset(nullptr); return false; } } default: // We do not know what is happening. Have to assume the worst. result.reset(nullptr); return false; } }); return result; } uint64_t ScalarReplacementPass::GetMaxLegalIndex( const Instruction* var_inst) const { assert(var_inst->opcode() == spv::Op::OpVariable && "|var_inst| must be a variable instruction."); Instruction* type = GetStorageType(var_inst); switch (type->opcode()) { case spv::Op::OpTypeStruct: return type->NumInOperands(); case spv::Op::OpTypeArray: return GetArrayLength(type); case spv::Op::OpTypeMatrix: case spv::Op::OpTypeVector: return GetNumElements(type); default: return 0; } return 0; } void ScalarReplacementPass::CopyDecorationsToVariable(Instruction* from, Instruction* to, uint32_t member_index) { CopyPointerDecorationsToVariable(from, to); CopyNecessaryMemberDecorationsToVariable(from, to, member_index); } void ScalarReplacementPass::CopyPointerDecorationsToVariable(Instruction* from, Instruction* to) { // The RestrictPointer and AliasedPointer decorations are copied to all // members even if the new variable does not contain a pointer. It does // not hurt to do so. for (auto dec_inst : get_decoration_mgr()->GetDecorationsFor(from->result_id(), false)) { uint32_t decoration; decoration = dec_inst->GetSingleWordInOperand(1u); switch (spv::Decoration(decoration)) { case spv::Decoration::AliasedPointer: case spv::Decoration::RestrictPointer: { std::unique_ptr new_dec_inst(dec_inst->Clone(context())); new_dec_inst->SetInOperand(0, {to->result_id()}); context()->AddAnnotationInst(std::move(new_dec_inst)); } break; default: break; } } } void ScalarReplacementPass::CopyNecessaryMemberDecorationsToVariable( Instruction* from, Instruction* to, uint32_t member_index) { Instruction* type_inst = GetStorageType(from); for (auto dec_inst : get_decoration_mgr()->GetDecorationsFor(type_inst->result_id(), false)) { uint32_t decoration; if (dec_inst->opcode() == spv::Op::OpMemberDecorate) { if (dec_inst->GetSingleWordInOperand(1) != member_index) { continue; } decoration = dec_inst->GetSingleWordInOperand(2u); switch (spv::Decoration(decoration)) { case spv::Decoration::ArrayStride: case spv::Decoration::Alignment: case spv::Decoration::AlignmentId: case spv::Decoration::MaxByteOffset: case spv::Decoration::MaxByteOffsetId: case spv::Decoration::RelaxedPrecision: { std::unique_ptr new_dec_inst( new Instruction(context(), spv::Op::OpDecorate, 0, 0, {})); new_dec_inst->AddOperand( Operand(SPV_OPERAND_TYPE_ID, {to->result_id()})); for (uint32_t i = 2; i < dec_inst->NumInOperandWords(); ++i) { new_dec_inst->AddOperand(Operand(dec_inst->GetInOperand(i))); } context()->AddAnnotationInst(std::move(new_dec_inst)); } break; default: break; } } } } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/scalar_replacement_pass.h000066400000000000000000000300341475742701700256560ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_SCALAR_REPLACEMENT_PASS_H_ #define SOURCE_OPT_SCALAR_REPLACEMENT_PASS_H_ #include #include #include #include #include #include #include #include "source/opt/function.h" #include "source/opt/mem_pass.h" #include "source/opt/type_manager.h" namespace spvtools { namespace opt { // Documented in optimizer.hpp class ScalarReplacementPass : public MemPass { private: static constexpr uint32_t kDefaultLimit = 100; public: ScalarReplacementPass(uint32_t limit = kDefaultLimit) : max_num_elements_(limit) { const auto num_to_write = snprintf( name_, sizeof(name_), "scalar-replacement=%u", max_num_elements_); assert(size_t(num_to_write) < sizeof(name_)); (void)num_to_write; // Mark as unused #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION // ClusterFuzz/OSS-Fuzz is likely to yield examples with very large arrays. // This can cause timeouts and memouts during fuzzing that // are not classed as bugs. To avoid this noise, we set the // max_num_elements_ to a smaller value for fuzzing. max_num_elements_ = (max_num_elements_ > 0 && max_num_elements_ < 100 ? max_num_elements_ : 100); #endif } const char* name() const override { return name_; } // Attempts to scalarize all appropriate function scope variables. Returns // SuccessWithChange if any change is made. Status Process() override; IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisDecorations | IRContext::kAnalysisCombinators | IRContext::kAnalysisCFG | IRContext::kAnalysisNameMap | IRContext::kAnalysisConstants | IRContext::kAnalysisTypes; } private: // Small container for tracking statistics about variables. // // TODO(alanbaker): Develop some useful heuristics to tune this pass. struct VariableStats { uint32_t num_partial_accesses; uint32_t num_full_accesses; }; // Attempts to scalarize all appropriate function scope variables in // |function|. Returns SuccessWithChange if any changes are mode. Status ProcessFunction(Function* function); // Returns true if |varInst| can be scalarized. // // Examines the use chain of |varInst| to verify all uses are valid for // scalarization. bool CanReplaceVariable(const Instruction* varInst) const; // Returns true if |typeInst| is an acceptable type to scalarize. // // Allows all aggregate types except runtime arrays. Additionally, checks the // that the number of elements that would be scalarized is within bounds. bool CheckType(const Instruction* typeInst) const; // Returns true if all the decorations for |varInst| are acceptable for // scalarization. bool CheckAnnotations(const Instruction* varInst) const; // Returns true if all the decorations for |typeInst| are acceptable for // scalarization. bool CheckTypeAnnotations(const Instruction* typeInst) const; // Returns true if the uses of |inst| are acceptable for scalarization. // // Recursively checks all the uses of |inst|. For |inst| specifically, only // allows spv::Op::OpAccessChain, spv::Op::OpInBoundsAccessChain, // spv::Op::OpLoad and spv::Op::OpStore. Access chains must have the first // index be a compile-time constant. Subsequent uses of access chains // (including other access chains) are checked in a more relaxed manner. bool CheckUses(const Instruction* inst) const; // Helper function for the above |CheckUses|. // // This version tracks some stats about the current OpVariable. These stats // are used to drive heuristics about when to scalarize. bool CheckUses(const Instruction* inst, VariableStats* stats) const; // Relaxed helper function for |CheckUses|. bool CheckUsesRelaxed(const Instruction* inst) const; // Transfers appropriate decorations from |source| to |replacements|. void TransferAnnotations(const Instruction* source, std::vector* replacements); // Scalarizes |inst| and updates its uses. // // |inst| must be an OpVariable. It is replaced with an OpVariable for each // for element of the composite type. Uses of |inst| are updated as // appropriate. If the replacement variables are themselves scalarizable, they // get added to |worklist| for further processing. If any replacement // variable ends up with no uses it is erased. Returns // - Status::SuccessWithoutChange if the variable could not be replaced. // - Status::SuccessWithChange if it made replacements. // - Status::Failure if it couldn't create replacement variables. Pass::Status ReplaceVariable(Instruction* inst, std::queue* worklist); // Returns the underlying storage type for |inst|. // // |inst| must be an OpVariable. Returns the type that is pointed to by // |inst|. Instruction* GetStorageType(const Instruction* inst) const; // Returns true if the load can be scalarized. // // |inst| must be an OpLoad. Returns true if |index| is the pointer operand of // |inst| and the load is not from volatile memory. bool CheckLoad(const Instruction* inst, uint32_t index) const; // Returns true if the store can be scalarized. // // |inst| must be an OpStore. Returns true if |index| is the pointer operand // of |inst| and the store is not to volatile memory. bool CheckStore(const Instruction* inst, uint32_t index) const; // Returns true if the DebugDeclare can be scalarized at |index|. bool CheckDebugDeclare(uint32_t index) const; // Returns true if |index| is the pointer operand of an OpImageTexelPointer // instruction. bool CheckImageTexelPointer(uint32_t index) const; // Creates a variable of type |typeId| from the |index|'th element of // |varInst|. The new variable is added to |replacements|. If the variable // could not be created, then |nullptr| is appended to |replacements|. void CreateVariable(uint32_t typeId, Instruction* varInst, uint32_t index, std::vector* replacements); // Populates |replacements| with a new OpVariable for each element of |inst|. // Returns true if the replacement variables were successfully created. // // |inst| must be an OpVariable of a composite type. New variables are // initialized the same as the corresponding index in |inst|. |replacements| // will contain a variable for each element of the composite with matching // indexes (i.e. the 0'th element of |inst| is the 0'th entry of // |replacements|). bool CreateReplacementVariables(Instruction* inst, std::vector* replacements); // Returns the array length for |arrayInst|. uint64_t GetArrayLength(const Instruction* arrayInst) const; // Returns the number of elements in |type|. // // |type| must be a vector or matrix type. uint64_t GetNumElements(const Instruction* type) const; // Returns true if |id| is a specialization constant. // // |id| must be registered definition. bool IsSpecConstant(uint32_t id) const; // Returns an id for a pointer to |id|. uint32_t GetOrCreatePointerType(uint32_t id); // Creates the initial value for the |index| element of |source| in |newVar|. // // If there is an initial value for |source| for element |index|, it is // appended as an operand on |newVar|. If the initial value is OpUndef, no // initial value is added to |newVar|. void GetOrCreateInitialValue(Instruction* source, uint32_t index, Instruction* newVar); // Replaces the load to the entire composite. // // Generates a load for each replacement variable and then creates a new // composite by combining all of the loads. // // |load| must be a load. Returns true if successful. bool ReplaceWholeLoad(Instruction* load, const std::vector& replacements); // Replaces the store to the entire composite. // // Generates a composite extract and store for each element in the scalarized // variable from the original store data input. Returns true if successful. bool ReplaceWholeStore(Instruction* store, const std::vector& replacements); // Replaces the DebugDeclare to the entire composite. // // Generates a DebugValue with Deref operation for each element in the // scalarized variable from the original DebugDeclare. Returns true if // successful. bool ReplaceWholeDebugDeclare(Instruction* dbg_decl, const std::vector& replacements); // Replaces the DebugValue to the entire composite. // // Generates a DebugValue for each element in the scalarized variable from // the original DebugValue. Returns true if successful. bool ReplaceWholeDebugValue(Instruction* dbg_value, const std::vector& replacements); // Replaces an access chain to the composite variable with either a direct use // of the appropriate replacement variable or another access chain with the // replacement variable as the base and one fewer indexes. Returns true if // successful. bool ReplaceAccessChain(Instruction* chain, const std::vector& replacements); // Returns a set containing the which components of the result of |inst| are // potentially used. If the return value is |nullptr|, then every components // is possibly used. std::unique_ptr> GetUsedComponents( Instruction* inst); // Returns an instruction defining an undefined value type |type_id|. Instruction* GetUndef(uint32_t type_id); // Maps storage type to a pointer type enclosing that type. std::unordered_map pointee_to_pointer_; // Maps type id to OpConstantNull for that type. std::unordered_map type_to_null_; // Returns the number of elements in the variable |var_inst|. uint64_t GetMaxLegalIndex(const Instruction* var_inst) const; // Returns true if |length| is larger than limit on the size of the variable // that we will be willing to split. bool IsLargerThanSizeLimit(uint64_t length) const; // Copies all relevant decorations from `from` to `to`. This includes // decorations applied to the variable, and to the members of the type. // It is assumed that `to` is a variable that is intended to replace the // `member_index`th member of `from`. void CopyDecorationsToVariable(Instruction* from, Instruction* to, uint32_t member_index); // Copies pointer related decoration from `from` to `to` if they exist. void CopyPointerDecorationsToVariable(Instruction* from, Instruction* to); // Copies decorations that are needed from the `member_index` of `from` to // `to, if there was one. void CopyNecessaryMemberDecorationsToVariable(Instruction* from, Instruction* to, uint32_t member_index); // Limit on the number of members in an object that will be replaced. // 0 means there is no limit. uint32_t max_num_elements_; // This has to be big enough to fit "scalar-replacement=" followed by a // uint32_t number written in decimal (so 10 digits), and then a // terminating nul. char name_[30]; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_SCALAR_REPLACEMENT_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/set_spec_constant_default_value_pass.cpp000066400000000000000000000365611475742701700310160ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/set_spec_constant_default_value_pass.h" #include #include #include #include #include #include "source/opt/def_use_manager.h" #include "source/opt/types.h" #include "source/util/make_unique.h" #include "source/util/parse_number.h" #include "spirv-tools/libspirv.h" namespace spvtools { namespace opt { namespace { using utils::EncodeNumberStatus; using utils::NumberType; using utils::ParseAndEncodeNumber; using utils::ParseNumber; // Given a numeric value in a null-terminated c string and the expected type of // the value, parses the string and encodes it in a vector of words. If the // value is a scalar integer or floating point value, encodes the value in // SPIR-V encoding format. If the value is 'false' or 'true', returns a vector // with single word with value 0 or 1 respectively. Returns the vector // containing the encoded value on success. Otherwise returns an empty vector. std::vector ParseDefaultValueStr(const char* text, const analysis::Type* type) { std::vector result; if (!strcmp(text, "true") && type->AsBool()) { result.push_back(1u); } else if (!strcmp(text, "false") && type->AsBool()) { result.push_back(0u); } else { NumberType number_type = {32, SPV_NUMBER_UNSIGNED_INT}; if (const auto* IT = type->AsInteger()) { number_type.bitwidth = IT->width(); number_type.kind = IT->IsSigned() ? SPV_NUMBER_SIGNED_INT : SPV_NUMBER_UNSIGNED_INT; } else if (const auto* FT = type->AsFloat()) { number_type.bitwidth = FT->width(); number_type.kind = SPV_NUMBER_FLOATING; } else { // Does not handle types other then boolean, integer or float. Returns // empty vector. result.clear(); return result; } EncodeNumberStatus rc = ParseAndEncodeNumber( text, number_type, [&result](uint32_t word) { result.push_back(word); }, nullptr); // Clear the result vector on failure. if (rc != EncodeNumberStatus::kSuccess) { result.clear(); } } return result; } // Given a bit pattern and a type, checks if the bit pattern is compatible // with the type. If so, returns the bit pattern, otherwise returns an empty // bit pattern. If the given bit pattern is empty, returns an empty bit // pattern. If the given type represents a SPIR-V Boolean type, the bit pattern // to be returned is determined with the following standard: // If any words in the input bit pattern are non zero, returns a bit pattern // with 0x1, which represents a 'true'. // If all words in the bit pattern are zero, returns a bit pattern with 0x0, // which represents a 'false'. // For integer and floating point types narrower than 32 bits, the upper bits // in the input bit pattern are ignored. Instead the upper bits are set // according to SPIR-V literal requirements: sign extend a signed integer, and // otherwise set the upper bits to zero. std::vector ParseDefaultValueBitPattern( const std::vector& input_bit_pattern, const analysis::Type* type) { std::vector result; if (type->AsBool()) { if (std::any_of(input_bit_pattern.begin(), input_bit_pattern.end(), [](uint32_t i) { return i != 0; })) { result.push_back(1u); } else { result.push_back(0u); } return result; } else if (const auto* IT = type->AsInteger()) { const auto width = IT->width(); assert(width > 0); const auto adjusted_width = std::max(32u, width); if (adjusted_width == input_bit_pattern.size() * sizeof(uint32_t) * 8) { result = std::vector(input_bit_pattern); if (width < 32) { const uint32_t high_active_bit = (1u << width) >> 1; if (IT->IsSigned() && (high_active_bit & result[0])) { // Sign extend. This overwrites the sign bit again, but that's ok. result[0] = result[0] | ~(high_active_bit - 1); } else { // Upper bits must be zero. result[0] = result[0] & ((1u << width) - 1); } } return result; } } else if (const auto* FT = type->AsFloat()) { const auto width = FT->width(); const auto adjusted_width = std::max(32u, width); if (adjusted_width == input_bit_pattern.size() * sizeof(uint32_t) * 8) { result = std::vector(input_bit_pattern); if (width < 32) { // Upper bits must be zero. result[0] = result[0] & ((1u << width) - 1); } return result; } } result.clear(); return result; } // Returns true if the given instruction's result id could have a SpecId // decoration. bool CanHaveSpecIdDecoration(const Instruction& inst) { switch (inst.opcode()) { case spv::Op::OpSpecConstant: case spv::Op::OpSpecConstantFalse: case spv::Op::OpSpecConstantTrue: return true; default: return false; } } // Given a decoration group defining instruction that is decorated with SpecId // decoration, finds the spec constant defining instruction which is the real // target of the SpecId decoration. Returns the spec constant defining // instruction if such an instruction is found, otherwise returns a nullptr. Instruction* GetSpecIdTargetFromDecorationGroup( const Instruction& decoration_group_defining_inst, analysis::DefUseManager* def_use_mgr) { // Find the OpGroupDecorate instruction which consumes the given decoration // group. Note that the given decoration group has SpecId decoration, which // is unique for different spec constants. So the decoration group cannot be // consumed by different OpGroupDecorate instructions. Therefore we only need // the first OpGroupDecoration instruction that uses the given decoration // group. Instruction* group_decorate_inst = nullptr; if (def_use_mgr->WhileEachUser(&decoration_group_defining_inst, [&group_decorate_inst](Instruction* user) { if (user->opcode() == spv::Op::OpGroupDecorate) { group_decorate_inst = user; return false; } return true; })) return nullptr; // Scan through the target ids of the OpGroupDecorate instruction. There // should be only one spec constant target consumes the SpecId decoration. // If multiple target ids are presented in the OpGroupDecorate instruction, // they must be the same one that defined by an eligible spec constant // instruction. If the OpGroupDecorate instruction has different target ids // or a target id is not defined by an eligible spec cosntant instruction, // returns a nullptr. Instruction* target_inst = nullptr; for (uint32_t i = 1; i < group_decorate_inst->NumInOperands(); i++) { // All the operands of a OpGroupDecorate instruction should be of type // SPV_OPERAND_TYPE_ID. uint32_t candidate_id = group_decorate_inst->GetSingleWordInOperand(i); Instruction* candidate_inst = def_use_mgr->GetDef(candidate_id); if (!candidate_inst) { continue; } if (!target_inst) { // If the spec constant target has not been found yet, check if the // candidate instruction is the target. if (CanHaveSpecIdDecoration(*candidate_inst)) { target_inst = candidate_inst; } else { // Spec id decoration should not be applied on other instructions. // TODO(qining): Emit an error message in the invalid case once the // error handling is done. return nullptr; } } else { // If the spec constant target has been found, check if the candidate // instruction is the same one as the target. The module is invalid if // the candidate instruction is different with the found target. // TODO(qining): Emit an error messaage in the invalid case once the // error handling is done. if (candidate_inst != target_inst) return nullptr; } } return target_inst; } } // namespace Pass::Status SetSpecConstantDefaultValuePass::Process() { // The operand index of decoration target in an OpDecorate instruction. constexpr uint32_t kTargetIdOperandIndex = 0; // The operand index of the decoration literal in an OpDecorate instruction. constexpr uint32_t kDecorationOperandIndex = 1; // The operand index of Spec id literal value in an OpDecorate SpecId // instruction. constexpr uint32_t kSpecIdLiteralOperandIndex = 2; // The number of operands in an OpDecorate SpecId instruction. constexpr uint32_t kOpDecorateSpecIdNumOperands = 3; // The in-operand index of the default value in a OpSpecConstant instruction. constexpr uint32_t kOpSpecConstantLiteralInOperandIndex = 0; bool modified = false; // Scan through all the annotation instructions to find 'OpDecorate SpecId' // instructions. Then extract the decoration target of those instructions. // The decoration targets should be spec constant defining instructions with // opcode: OpSpecConstant{|True|False}. The spec id of those spec constants // will be used to look up their new default values in the mapping from // spec id to new default value strings. Once a new default value string // is found for a spec id, the string will be parsed according to the target // spec constant type. The parsed value will be used to replace the original // default value of the target spec constant. for (Instruction& inst : context()->annotations()) { // Only process 'OpDecorate SpecId' instructions if (inst.opcode() != spv::Op::OpDecorate) continue; if (inst.NumOperands() != kOpDecorateSpecIdNumOperands) continue; if (inst.GetSingleWordInOperand(kDecorationOperandIndex) != uint32_t(spv::Decoration::SpecId)) { continue; } // 'inst' is an OpDecorate SpecId instruction. uint32_t spec_id = inst.GetSingleWordOperand(kSpecIdLiteralOperandIndex); uint32_t target_id = inst.GetSingleWordOperand(kTargetIdOperandIndex); // Find the spec constant defining instruction. Note that the // target_id might be a decoration group id. Instruction* spec_inst = nullptr; if (Instruction* target_inst = get_def_use_mgr()->GetDef(target_id)) { if (target_inst->opcode() == spv::Op::OpDecorationGroup) { spec_inst = GetSpecIdTargetFromDecorationGroup(*target_inst, get_def_use_mgr()); } else { spec_inst = target_inst; } } else { continue; } if (!spec_inst) continue; // Get the default value bit pattern for this spec id. std::vector bit_pattern; if (spec_id_to_value_str_.size() != 0) { // Search for the new string-form default value for this spec id. auto iter = spec_id_to_value_str_.find(spec_id); if (iter == spec_id_to_value_str_.end()) { continue; } // Gets the string of the default value and parses it to bit pattern // with the type of the spec constant. const std::string& default_value_str = iter->second; bit_pattern = ParseDefaultValueStr( default_value_str.c_str(), context()->get_type_mgr()->GetType(spec_inst->type_id())); } else { // Search for the new bit-pattern-form default value for this spec id. auto iter = spec_id_to_value_bit_pattern_.find(spec_id); if (iter == spec_id_to_value_bit_pattern_.end()) { continue; } // Gets the bit-pattern of the default value from the map directly. bit_pattern = ParseDefaultValueBitPattern( iter->second, context()->get_type_mgr()->GetType(spec_inst->type_id())); } if (bit_pattern.empty()) continue; // Update the operand bit patterns of the spec constant defining // instruction. switch (spec_inst->opcode()) { case spv::Op::OpSpecConstant: // If the new value is the same with the original value, no // need to do anything. Otherwise update the operand words. if (spec_inst->GetInOperand(kOpSpecConstantLiteralInOperandIndex) .words != bit_pattern) { spec_inst->SetInOperand(kOpSpecConstantLiteralInOperandIndex, std::move(bit_pattern)); modified = true; } break; case spv::Op::OpSpecConstantTrue: // If the new value is also 'true', no need to change anything. // Otherwise, set the opcode to OpSpecConstantFalse; if (!static_cast(bit_pattern.front())) { spec_inst->SetOpcode(spv::Op::OpSpecConstantFalse); modified = true; } break; case spv::Op::OpSpecConstantFalse: // If the new value is also 'false', no need to change anything. // Otherwise, set the opcode to OpSpecConstantTrue; if (static_cast(bit_pattern.front())) { spec_inst->SetOpcode(spv::Op::OpSpecConstantTrue); modified = true; } break; default: break; } // No need to update the DefUse manager, as this pass does not change any // ids. } return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } // Returns true if the given char is ':', '\0' or considered as blank space // (i.e.: '\n', '\r', '\v', '\t', '\f' and ' '). bool IsSeparator(char ch) { return std::strchr(":\0", ch) || std::isspace(ch) != 0; } std::unique_ptr SetSpecConstantDefaultValuePass::ParseDefaultValuesString(const char* str) { if (!str) return nullptr; auto spec_id_to_value = MakeUnique(); // The parsing loop, break when points to the end. while (*str) { // Find the spec id. while (std::isspace(*str)) str++; // skip leading spaces. const char* entry_begin = str; while (!IsSeparator(*str)) str++; const char* entry_end = str; std::string spec_id_str(entry_begin, entry_end - entry_begin); uint32_t spec_id = 0; if (!ParseNumber(spec_id_str.c_str(), &spec_id)) { // The spec id is not a valid uint32 number. return nullptr; } auto iter = spec_id_to_value->find(spec_id); if (iter != spec_id_to_value->end()) { // Same spec id has been defined before return nullptr; } // Find the ':', spaces between the spec id and the ':' are not allowed. if (*str++ != ':') { // ':' not found return nullptr; } // Find the value string const char* val_begin = str; while (!IsSeparator(*str)) str++; const char* val_end = str; if (val_end == val_begin) { // Value string is empty. return nullptr; } // Update the mapping with spec id and value string. (*spec_id_to_value)[spec_id] = std::string(val_begin, val_end - val_begin); // Skip trailing spaces. while (std::isspace(*str)) str++; } return spec_id_to_value; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/set_spec_constant_default_value_pass.h000066400000000000000000000113741475742701700304560ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_SET_SPEC_CONSTANT_DEFAULT_VALUE_PASS_H_ #define SOURCE_OPT_SET_SPEC_CONSTANT_DEFAULT_VALUE_PASS_H_ #include #include #include #include #include #include "source/opt/ir_context.h" #include "source/opt/module.h" #include "source/opt/pass.h" namespace spvtools { namespace opt { // See optimizer.hpp for documentation. class SetSpecConstantDefaultValuePass : public Pass { public: using SpecIdToValueStrMap = std::unordered_map; using SpecIdToValueBitPatternMap = std::unordered_map>; using SpecIdToInstMap = std::unordered_map; // Constructs a pass instance with a map from spec ids to default values // in the form of string. explicit SetSpecConstantDefaultValuePass( const SpecIdToValueStrMap& default_values) : spec_id_to_value_str_(default_values), spec_id_to_value_bit_pattern_() {} explicit SetSpecConstantDefaultValuePass(SpecIdToValueStrMap&& default_values) : spec_id_to_value_str_(std::move(default_values)), spec_id_to_value_bit_pattern_() {} // Constructs a pass instance with a map from spec ids to default values in // the form of bit pattern. explicit SetSpecConstantDefaultValuePass( const SpecIdToValueBitPatternMap& default_values) : spec_id_to_value_str_(), spec_id_to_value_bit_pattern_(default_values) {} explicit SetSpecConstantDefaultValuePass( SpecIdToValueBitPatternMap&& default_values) : spec_id_to_value_str_(), spec_id_to_value_bit_pattern_(std::move(default_values)) {} const char* name() const override { return "set-spec-const-default-value"; } Status Process() override; // Parses the given null-terminated C string to get a mapping from Spec Id to // default value strings. Returns a unique pointer of the mapping from spec // ids to spec constant default value strings built from the given |str| on // success. Returns a nullptr if the given string is not valid for building // the mapping. // A valid string for building the mapping should follow the rule below: // // ": : ..." // Example: // "200:0x11 201:3.14 202:1.4728" // // Entries are separated with blank spaces (i.e.:' ', '\n', '\r', '\t', // '\f', '\v'). Each entry corresponds to a Spec Id and default value pair. // Multiple spaces between, before or after entries are allowed. However, // spaces are not allowed within spec id or the default value string because // spaces are always considered as delimiter to separate entries. // // In each entry, the spec id and value string is separated by ':'. Missing // ':' in any entry is invalid. And it is invalid to have blank spaces in // between the spec id and ':' or the default value and ':'. // // : specifies the spec id value. // The text must represent a valid uint32_t number. // Hex format with '0x' prefix is allowed. // Empty is not allowed. // One spec id value can only be defined once, multiple default values // defined for the same spec id is not allowed. Spec ids with same value // but different formats (e.g. 0x100 and 256) are considered the same. // // : the default value string. // Spaces before and after default value text is allowed. // Spaces within the text is not allowed. // Empty is not allowed. static std::unique_ptr ParseDefaultValuesString( const char* str); private: // The mappings from spec ids to default values. Two maps are defined here, // each to be used for one specific form of the default values. Only one of // them will be populated in practice. // The mapping from spec ids to their string-form default values to be set. const SpecIdToValueStrMap spec_id_to_value_str_; // The mapping from spec ids to their bitpattern-form default values to be // set. const SpecIdToValueBitPatternMap spec_id_to_value_bit_pattern_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_SET_SPEC_CONSTANT_DEFAULT_VALUE_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/simplification_pass.cpp000066400000000000000000000140671475742701700254070ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/simplification_pass.h" #include #include #include "source/opt/fold.h" namespace spvtools { namespace opt { Pass::Status SimplificationPass::Process() { bool modified = false; for (Function& function : *get_module()) { modified |= SimplifyFunction(&function); } return (modified ? Status::SuccessWithChange : Status::SuccessWithoutChange); } void SimplificationPass::AddNewOperands( Instruction* folded_inst, std::unordered_set* inst_seen, std::vector* work_list) { analysis::DefUseManager* def_use_mgr = get_def_use_mgr(); folded_inst->ForEachInId( [&inst_seen, &def_use_mgr, &work_list](uint32_t* iid) { Instruction* iid_inst = def_use_mgr->GetDef(*iid); if (!inst_seen->insert(iid_inst).second) return; work_list->push_back(iid_inst); }); } bool SimplificationPass::SimplifyFunction(Function* function) { if (function->IsDeclaration()) { return false; } bool modified = false; // Phase 1: Traverse all instructions in dominance order. // The second phase will only be on the instructions whose inputs have changed // after being processed during phase 1. Since OpPhi instructions are the // only instructions whose inputs do not necessarily dominate the use, we keep // track of the OpPhi instructions already seen, and add them to the work list // for phase 2 when needed. std::vector work_list; std::unordered_set process_phis; std::unordered_set inst_to_kill; std::unordered_set in_work_list; std::unordered_set inst_seen; const InstructionFolder& folder = context()->get_instruction_folder(); cfg()->ForEachBlockInReversePostOrder( function->entry().get(), [&modified, &process_phis, &work_list, &in_work_list, &inst_to_kill, &folder, &inst_seen, this](BasicBlock* bb) { for (Instruction* inst = &*bb->begin(); inst; inst = inst->NextNode()) { inst_seen.insert(inst); if (inst->opcode() == spv::Op::OpPhi) { process_phis.insert(inst); } bool is_foldable_copy = inst->opcode() == spv::Op::OpCopyObject && context()->get_decoration_mgr()->HaveSubsetOfDecorations( inst->result_id(), inst->GetSingleWordInOperand(0)); if (is_foldable_copy || folder.FoldInstruction(inst)) { modified = true; context()->AnalyzeUses(inst); get_def_use_mgr()->ForEachUser(inst, [&work_list, &process_phis, &in_work_list]( Instruction* use) { if (process_phis.count(use) && in_work_list.insert(use).second) { work_list.push_back(use); } }); AddNewOperands(inst, &inst_seen, &work_list); if (inst->opcode() == spv::Op::OpCopyObject) { context()->ReplaceAllUsesWithPredicate( inst->result_id(), inst->GetSingleWordInOperand(0), [](Instruction* user) { const auto opcode = user->opcode(); if (!spvOpcodeIsDebug(opcode) && !spvOpcodeIsDecoration(opcode)) { return true; } return false; }); inst_to_kill.insert(inst); in_work_list.insert(inst); } else if (inst->opcode() == spv::Op::OpNop) { inst_to_kill.insert(inst); in_work_list.insert(inst); } } } }); // Phase 2: process the instructions in the work list until all of the work is // done. This time we add all users to the work list because phase 1 // has already finished. for (size_t i = 0; i < work_list.size(); ++i) { Instruction* inst = work_list[i]; in_work_list.erase(inst); inst_seen.insert(inst); bool is_foldable_copy = inst->opcode() == spv::Op::OpCopyObject && context()->get_decoration_mgr()->HaveSubsetOfDecorations( inst->result_id(), inst->GetSingleWordInOperand(0)); if (is_foldable_copy || folder.FoldInstruction(inst)) { modified = true; context()->AnalyzeUses(inst); get_def_use_mgr()->ForEachUser( inst, [&work_list, &in_work_list](Instruction* use) { if (!use->IsDecoration() && use->opcode() != spv::Op::OpName && in_work_list.insert(use).second) { work_list.push_back(use); } }); AddNewOperands(inst, &inst_seen, &work_list); if (inst->opcode() == spv::Op::OpCopyObject) { context()->ReplaceAllUsesWithPredicate( inst->result_id(), inst->GetSingleWordInOperand(0), [](Instruction* user) { const auto opcode = user->opcode(); if (!spvOpcodeIsDebug(opcode) && !spvOpcodeIsDecoration(opcode)) { return true; } return false; }); inst_to_kill.insert(inst); in_work_list.insert(inst); } else if (inst->opcode() == spv::Op::OpNop) { inst_to_kill.insert(inst); in_work_list.insert(inst); } } } // Phase 3: Kill instructions we know are no longer needed. for (Instruction* inst : inst_to_kill) { context()->KillInst(inst); } return modified; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/simplification_pass.h000066400000000000000000000042261475742701700250500ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_SIMPLIFICATION_PASS_H_ #define SOURCE_OPT_SIMPLIFICATION_PASS_H_ #include "source/opt/function.h" #include "source/opt/ir_context.h" #include "source/opt/pass.h" namespace spvtools { namespace opt { // See optimizer.hpp for documentation. class SimplificationPass : public Pass { public: const char* name() const override { return "simplify-instructions"; } Status Process() override; IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisDecorations | IRContext::kAnalysisCombinators | IRContext::kAnalysisCFG | IRContext::kAnalysisDominatorAnalysis | IRContext::kAnalysisNameMap | IRContext::kAnalysisConstants | IRContext::kAnalysisTypes; } private: // Returns true if the module was changed. The simplifier is called on every // instruction in |function| until nothing else in the function can be // simplified. bool SimplifyFunction(Function* function); // FactorAddMul can create |folded_inst| Mul of new Add. If Mul, push any Add // operand not in |seen_inst| into |worklist|. This is heavily restricted to // improve compile time but can be expanded for future simplifications which // simiarly create new operations. void AddNewOperands(Instruction* folded_inst, std::unordered_set* inst_seen, std::vector* work_list); }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_SIMPLIFICATION_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/spread_volatile_semantics.cpp000066400000000000000000000265351475742701700265750ustar00rootroot00000000000000// Copyright (c) 2022 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/spread_volatile_semantics.h" #include "source/opt/decoration_manager.h" #include "source/spirv_constant.h" namespace spvtools { namespace opt { namespace { constexpr uint32_t kOpDecorateInOperandBuiltinDecoration = 2u; constexpr uint32_t kOpLoadInOperandMemoryOperands = 1u; constexpr uint32_t kOpEntryPointInOperandEntryPoint = 1u; constexpr uint32_t kOpEntryPointInOperandInterface = 3u; bool HasBuiltinDecoration(analysis::DecorationManager* decoration_manager, uint32_t var_id, uint32_t built_in) { return decoration_manager->FindDecoration( var_id, uint32_t(spv::Decoration::BuiltIn), [built_in](const Instruction& inst) { return built_in == inst.GetSingleWordInOperand( kOpDecorateInOperandBuiltinDecoration); }); } bool IsBuiltInForRayTracingVolatileSemantics(spv::BuiltIn built_in) { switch (built_in) { case spv::BuiltIn::SMIDNV: case spv::BuiltIn::WarpIDNV: case spv::BuiltIn::SubgroupSize: case spv::BuiltIn::SubgroupLocalInvocationId: case spv::BuiltIn::SubgroupEqMask: case spv::BuiltIn::SubgroupGeMask: case spv::BuiltIn::SubgroupGtMask: case spv::BuiltIn::SubgroupLeMask: case spv::BuiltIn::SubgroupLtMask: return true; default: return false; } } bool HasBuiltinForRayTracingVolatileSemantics( analysis::DecorationManager* decoration_manager, uint32_t var_id) { return decoration_manager->FindDecoration( var_id, uint32_t(spv::Decoration::BuiltIn), [](const Instruction& inst) { spv::BuiltIn built_in = spv::BuiltIn( inst.GetSingleWordInOperand(kOpDecorateInOperandBuiltinDecoration)); return IsBuiltInForRayTracingVolatileSemantics(built_in); }); } bool HasVolatileDecoration(analysis::DecorationManager* decoration_manager, uint32_t var_id) { return decoration_manager->HasDecoration(var_id, uint32_t(spv::Decoration::Volatile)); } } // namespace Pass::Status SpreadVolatileSemantics::Process() { if (HasNoExecutionModel()) { return Status::SuccessWithoutChange; } const bool is_vk_memory_model_enabled = context()->get_feature_mgr()->HasCapability( spv::Capability::VulkanMemoryModel); CollectTargetsForVolatileSemantics(is_vk_memory_model_enabled); // If VulkanMemoryModel capability is not enabled, we have to set Volatile // decoration for interface variables instead of setting Volatile for load // instructions. If an interface (or pointers to it) is used by two load // instructions in two entry points and one must be volatile while another // is not, we have to report an error for the conflict. if (!is_vk_memory_model_enabled && HasInterfaceInConflictOfVolatileSemantics()) { return Status::Failure; } return SpreadVolatileSemanticsToVariables(is_vk_memory_model_enabled); } Pass::Status SpreadVolatileSemantics::SpreadVolatileSemanticsToVariables( const bool is_vk_memory_model_enabled) { Status status = Status::SuccessWithoutChange; for (Instruction& var : context()->types_values()) { auto entry_function_ids = EntryFunctionsToSpreadVolatileSemanticsForVar(var.result_id()); if (entry_function_ids.empty()) { continue; } if (is_vk_memory_model_enabled) { SetVolatileForLoadsInEntries(&var, entry_function_ids); } else { DecorateVarWithVolatile(&var); } status = Status::SuccessWithChange; } return status; } bool SpreadVolatileSemantics::IsTargetUsedByNonVolatileLoadInEntryPoint( uint32_t var_id, Instruction* entry_point) { uint32_t entry_function_id = entry_point->GetSingleWordInOperand(kOpEntryPointInOperandEntryPoint); std::unordered_set funcs; context()->CollectCallTreeFromRoots(entry_function_id, &funcs); return !VisitLoadsOfPointersToVariableInEntries( var_id, [](Instruction* load) { // If it has a load without volatile memory operand, finish traversal // and return false. if (load->NumInOperands() <= kOpLoadInOperandMemoryOperands) { return false; } uint32_t memory_operands = load->GetSingleWordInOperand(kOpLoadInOperandMemoryOperands); return (memory_operands & uint32_t(spv::MemoryAccessMask::Volatile)) != 0; }, funcs); } bool SpreadVolatileSemantics::HasInterfaceInConflictOfVolatileSemantics() { for (Instruction& entry_point : get_module()->entry_points()) { spv::ExecutionModel execution_model = static_cast(entry_point.GetSingleWordInOperand(0)); for (uint32_t operand_index = kOpEntryPointInOperandInterface; operand_index < entry_point.NumInOperands(); ++operand_index) { uint32_t var_id = entry_point.GetSingleWordInOperand(operand_index); if (!EntryFunctionsToSpreadVolatileSemanticsForVar(var_id).empty() && !IsTargetForVolatileSemantics(var_id, execution_model) && IsTargetUsedByNonVolatileLoadInEntryPoint(var_id, &entry_point)) { Instruction* inst = context()->get_def_use_mgr()->GetDef(var_id); context()->EmitErrorMessage( "Variable is a target for Volatile semantics for an entry point, " "but it is not for another entry point", inst); return true; } } } return false; } void SpreadVolatileSemantics::MarkVolatileSemanticsForVariable( uint32_t var_id, Instruction* entry_point) { uint32_t entry_function_id = entry_point->GetSingleWordInOperand(kOpEntryPointInOperandEntryPoint); auto itr = var_ids_to_entry_fn_for_volatile_semantics_.find(var_id); if (itr == var_ids_to_entry_fn_for_volatile_semantics_.end()) { var_ids_to_entry_fn_for_volatile_semantics_[var_id] = {entry_function_id}; return; } itr->second.insert(entry_function_id); } void SpreadVolatileSemantics::CollectTargetsForVolatileSemantics( const bool is_vk_memory_model_enabled) { for (Instruction& entry_point : get_module()->entry_points()) { spv::ExecutionModel execution_model = static_cast(entry_point.GetSingleWordInOperand(0)); for (uint32_t operand_index = kOpEntryPointInOperandInterface; operand_index < entry_point.NumInOperands(); ++operand_index) { uint32_t var_id = entry_point.GetSingleWordInOperand(operand_index); if (!IsTargetForVolatileSemantics(var_id, execution_model)) { continue; } if (is_vk_memory_model_enabled || IsTargetUsedByNonVolatileLoadInEntryPoint(var_id, &entry_point)) { MarkVolatileSemanticsForVariable(var_id, &entry_point); } } } } void SpreadVolatileSemantics::DecorateVarWithVolatile(Instruction* var) { analysis::DecorationManager* decoration_manager = context()->get_decoration_mgr(); uint32_t var_id = var->result_id(); if (HasVolatileDecoration(decoration_manager, var_id)) { return; } get_decoration_mgr()->AddDecoration( spv::Op::OpDecorate, {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {var_id}}, {spv_operand_type_t::SPV_OPERAND_TYPE_LITERAL_INTEGER, {uint32_t(spv::Decoration::Volatile)}}}); } bool SpreadVolatileSemantics::VisitLoadsOfPointersToVariableInEntries( uint32_t var_id, const std::function& handle_load, const std::unordered_set& function_ids) { std::vector worklist({var_id}); auto* def_use_mgr = context()->get_def_use_mgr(); while (!worklist.empty()) { uint32_t ptr_id = worklist.back(); worklist.pop_back(); bool finish_traversal = !def_use_mgr->WhileEachUser( ptr_id, [this, &worklist, &ptr_id, handle_load, &function_ids](Instruction* user) { BasicBlock* block = context()->get_instr_block(user); if (block == nullptr || function_ids.find(block->GetParent()->result_id()) == function_ids.end()) { return true; } if (user->opcode() == spv::Op::OpAccessChain || user->opcode() == spv::Op::OpInBoundsAccessChain || user->opcode() == spv::Op::OpPtrAccessChain || user->opcode() == spv::Op::OpInBoundsPtrAccessChain || user->opcode() == spv::Op::OpCopyObject) { if (ptr_id == user->GetSingleWordInOperand(0)) worklist.push_back(user->result_id()); return true; } if (user->opcode() != spv::Op::OpLoad) { return true; } return handle_load(user); }); if (finish_traversal) return false; } return true; } void SpreadVolatileSemantics::SetVolatileForLoadsInEntries( Instruction* var, const std::unordered_set& entry_function_ids) { // Set Volatile memory operand for all load instructions if they do not have // it. for (auto entry_id : entry_function_ids) { std::unordered_set funcs; context()->CollectCallTreeFromRoots(entry_id, &funcs); VisitLoadsOfPointersToVariableInEntries( var->result_id(), [](Instruction* load) { if (load->NumInOperands() <= kOpLoadInOperandMemoryOperands) { load->AddOperand({SPV_OPERAND_TYPE_MEMORY_ACCESS, {uint32_t(spv::MemoryAccessMask::Volatile)}}); return true; } uint32_t memory_operands = load->GetSingleWordInOperand(kOpLoadInOperandMemoryOperands); memory_operands |= uint32_t(spv::MemoryAccessMask::Volatile); load->SetInOperand(kOpLoadInOperandMemoryOperands, {memory_operands}); return true; }, funcs); } } bool SpreadVolatileSemantics::IsTargetForVolatileSemantics( uint32_t var_id, spv::ExecutionModel execution_model) { analysis::DecorationManager* decoration_manager = context()->get_decoration_mgr(); if (execution_model == spv::ExecutionModel::Fragment) { return get_module()->version() >= SPV_SPIRV_VERSION_WORD(1, 6) && HasBuiltinDecoration(decoration_manager, var_id, uint32_t(spv::BuiltIn::HelperInvocation)); } if (execution_model == spv::ExecutionModel::IntersectionKHR || execution_model == spv::ExecutionModel::IntersectionNV) { if (HasBuiltinDecoration(decoration_manager, var_id, uint32_t(spv::BuiltIn::RayTmaxKHR))) { return true; } } switch (execution_model) { case spv::ExecutionModel::RayGenerationKHR: case spv::ExecutionModel::ClosestHitKHR: case spv::ExecutionModel::MissKHR: case spv::ExecutionModel::CallableKHR: case spv::ExecutionModel::IntersectionKHR: return HasBuiltinForRayTracingVolatileSemantics(decoration_manager, var_id); default: return false; } } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/spread_volatile_semantics.h000066400000000000000000000115041475742701700262300ustar00rootroot00000000000000// Copyright (c) 2022 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_SPREAD_VOLATILE_SEMANTICS_H_ #define SOURCE_OPT_SPREAD_VOLATILE_SEMANTICS_H_ #include "source/opt/pass.h" namespace spvtools { namespace opt { // See optimizer.hpp for documentation. class SpreadVolatileSemantics : public Pass { public: SpreadVolatileSemantics() {} const char* name() const override { return "spread-volatile-semantics"; } Status Process() override; IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisDefUse | IRContext::kAnalysisDecorations | IRContext::kAnalysisInstrToBlockMapping; } private: // Returns true if it does not have an execution model. Linkage shaders do not // have an execution model. bool HasNoExecutionModel() { return get_module()->entry_points().empty() && context()->get_feature_mgr()->HasCapability( spv::Capability::Linkage); } // Iterates interface variables and spreads the Volatile semantics if it has // load instructions for the Volatile semantics. Pass::Status SpreadVolatileSemanticsToVariables( const bool is_vk_memory_model_enabled); // Returns whether |var_id| is the result id of a target builtin variable for // the volatile semantics for |execution_model| based on the Vulkan spec // VUID-StandaloneSpirv-VulkanMemoryModel-04678 or // VUID-StandaloneSpirv-VulkanMemoryModel-04679. bool IsTargetForVolatileSemantics(uint32_t var_id, spv::ExecutionModel execution_model); // Collects interface variables that need the volatile semantics. // |is_vk_memory_model_enabled| is true if VulkanMemoryModel capability is // enabled. void CollectTargetsForVolatileSemantics( const bool is_vk_memory_model_enabled); // Reports an error if an interface variable is used by two entry points and // it needs the Volatile decoration for one but not for another. Returns true // if the error must be reported. bool HasInterfaceInConflictOfVolatileSemantics(); // Returns whether the variable whose result is |var_id| is used by a // non-volatile load or a pointer to it is used by a non-volatile load in // |entry_point| or not. bool IsTargetUsedByNonVolatileLoadInEntryPoint(uint32_t var_id, Instruction* entry_point); // Visits load instructions of pointers to variable whose result id is // |var_id| if the load instructions are in reachable functions from entry // points. |handle_load| is a function to do some actions for the load // instructions. Finishes the traversal and returns false if |handle_load| // returns false for a load instruction. Otherwise, returns true after running // |handle_load| for all the load instructions. bool VisitLoadsOfPointersToVariableInEntries( uint32_t var_id, const std::function& handle_load, const std::unordered_set& function_ids); // Sets Memory Operands of OpLoad instructions that load |var| or pointers // of |var| as Volatile if the function id of the OpLoad instruction is // included in |entry_function_ids|. void SetVolatileForLoadsInEntries( Instruction* var, const std::unordered_set& entry_function_ids); // Adds OpDecorate Volatile for |var| if it does not exist. void DecorateVarWithVolatile(Instruction* var); // Returns a set of entry function ids to spread the volatile semantics for // the variable with the result id |var_id|. std::unordered_set EntryFunctionsToSpreadVolatileSemanticsForVar( uint32_t var_id) { auto itr = var_ids_to_entry_fn_for_volatile_semantics_.find(var_id); if (itr == var_ids_to_entry_fn_for_volatile_semantics_.end()) return {}; return itr->second; } // Specifies that we have to spread the volatile semantics for the // variable with the result id |var_id| for the entry point |entry_point|. void MarkVolatileSemanticsForVariable(uint32_t var_id, Instruction* entry_point); // Result ids of variables to entry function ids for the volatile semantics // spread. std::unordered_map> var_ids_to_entry_fn_for_volatile_semantics_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_SPREAD_VOLATILE_SEMANTICS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/ssa_rewrite_pass.cpp000066400000000000000000000610031475742701700247140ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // This file implements the SSA rewriting algorithm proposed in // // Simple and Efficient Construction of Static Single Assignment Form. // Braun M., Buchwald S., Hack S., Leißa R., Mallon C., Zwinkau A. (2013) // In: Jhala R., De Bosschere K. (eds) // Compiler Construction. CC 2013. // Lecture Notes in Computer Science, vol 7791. // Springer, Berlin, Heidelberg // // https://link.springer.com/chapter/10.1007/978-3-642-37051-9_6 // // In contrast to common eager algorithms based on dominance and dominance // frontier information, this algorithm works backwards from load operations. // // When a target variable is loaded, it queries the variable's reaching // definition. If the reaching definition is unknown at the current location, // it searches backwards in the CFG, inserting Phi instructions at join points // in the CFG along the way until it finds the desired store instruction. // // The algorithm avoids repeated lookups using memoization. // // For reducible CFGs, which are a superset of the structured CFGs in SPIRV, // this algorithm is proven to produce minimal SSA. That is, it inserts the // minimal number of Phi instructions required to ensure the SSA property, but // some Phi instructions may be dead // (https://en.wikipedia.org/wiki/Static_single_assignment_form). #include "source/opt/ssa_rewrite_pass.h" #include #include #include "source/opcode.h" #include "source/opt/cfg.h" #include "source/opt/mem_pass.h" #include "source/opt/types.h" // Debug logging (0: Off, 1-N: Verbosity level). Replace this with the // implementation done for // https://github.com/KhronosGroup/SPIRV-Tools/issues/1351 // #define SSA_REWRITE_DEBUGGING_LEVEL 3 #ifdef SSA_REWRITE_DEBUGGING_LEVEL #include #else #define SSA_REWRITE_DEBUGGING_LEVEL 0 #endif namespace spvtools { namespace opt { namespace { constexpr uint32_t kStoreValIdInIdx = 1; constexpr uint32_t kVariableInitIdInIdx = 1; } // namespace std::string SSARewriter::PhiCandidate::PrettyPrint(const CFG* cfg) const { std::ostringstream str; str << "%" << result_id_ << " = Phi[%" << var_id_ << ", BB %" << bb_->id() << "]("; if (phi_args_.size() > 0) { uint32_t arg_ix = 0; for (uint32_t pred_label : cfg->preds(bb_->id())) { uint32_t arg_id = phi_args_[arg_ix++]; str << "[%" << arg_id << ", bb(%" << pred_label << ")] "; } } str << ")"; if (copy_of_ != 0) { str << " [COPY OF " << copy_of_ << "]"; } str << ((is_complete_) ? " [COMPLETE]" : " [INCOMPLETE]"); return str.str(); } SSARewriter::PhiCandidate& SSARewriter::CreatePhiCandidate(uint32_t var_id, BasicBlock* bb) { // TODO(1841): Handle id overflow. uint32_t phi_result_id = pass_->context()->TakeNextId(); auto result = phi_candidates_.emplace( phi_result_id, PhiCandidate(var_id, phi_result_id, bb)); PhiCandidate& phi_candidate = result.first->second; return phi_candidate; } void SSARewriter::ReplacePhiUsersWith(const PhiCandidate& phi_to_remove, uint32_t repl_id) { for (uint32_t user_id : phi_to_remove.users()) { PhiCandidate* user_phi = GetPhiCandidate(user_id); BasicBlock* bb = pass_->context()->get_instr_block(user_id); if (user_phi) { // If the user is a Phi candidate, replace all arguments that refer to // |phi_to_remove.result_id()| with |repl_id|. for (uint32_t& arg : user_phi->phi_args()) { if (arg == phi_to_remove.result_id()) { arg = repl_id; } } } else if (bb->id() == user_id) { // The phi candidate is the definition of the variable at basic block // |bb|. We must change this to the replacement. WriteVariable(phi_to_remove.var_id(), bb, repl_id); } else { // For regular loads, traverse the |load_replacement_| table looking for // instances of |phi_to_remove|. for (auto& it : load_replacement_) { if (it.second == phi_to_remove.result_id()) { it.second = repl_id; } } } } } uint32_t SSARewriter::TryRemoveTrivialPhi(PhiCandidate* phi_candidate) { uint32_t same_id = 0; for (uint32_t arg_id : phi_candidate->phi_args()) { if (arg_id == same_id || arg_id == phi_candidate->result_id()) { // This is a self-reference operand or a reference to the same value ID. continue; } if (same_id != 0) { // This Phi candidate merges at least two values. Therefore, it is not // trivial. assert(phi_candidate->copy_of() == 0 && "Phi candidate transitioning from copy to non-copy."); return phi_candidate->result_id(); } same_id = arg_id; } // The previous logic has determined that this Phi candidate |phi_candidate| // is trivial. It is essentially the copy operation phi_candidate->phi_result // = Phi(same, same, same, ...). Since it is not necessary, we can re-route // all the users of |phi_candidate->phi_result| to all its users, and remove // |phi_candidate|. // Mark the Phi candidate as a trivial copy of |same_id|, so it won't be // generated. phi_candidate->MarkCopyOf(same_id); assert(same_id != 0 && "Completed Phis cannot have %0 in their arguments"); // Since |phi_candidate| always produces |same_id|, replace all the users of // |phi_candidate| with |same_id|. ReplacePhiUsersWith(*phi_candidate, same_id); return same_id; } uint32_t SSARewriter::AddPhiOperands(PhiCandidate* phi_candidate) { assert(phi_candidate->phi_args().size() == 0 && "Phi candidate already has arguments"); bool found_0_arg = false; for (uint32_t pred : pass_->cfg()->preds(phi_candidate->bb()->id())) { BasicBlock* pred_bb = pass_->cfg()->block(pred); // If |pred_bb| is not sealed, use %0 to indicate that // |phi_candidate| needs to be completed after the whole CFG has // been processed. // // Note that we cannot call GetReachingDef() in these cases // because this would generate an empty Phi candidate in // |pred_bb|. When |pred_bb| is later processed, a new definition // for |phi_candidate->var_id_| will be lost because // |phi_candidate| will still be reached by the empty Phi. // // Consider: // // BB %23: // %38 = Phi[%i](%int_0[%1], %39[%25]) // // ... // // BB %25: [Starts unsealed] // %39 = Phi[%i]() // %34 = ... // OpStore %i %34 -> Currdef(%i) at %25 is %34 // OpBranch %23 // // When we first create the Phi in %38, we add an operandless Phi in // %39 to hold the unknown reaching def for %i. // // But then, when we go to complete %39 at the end. The reaching def // for %i in %25's predecessor is %38 itself. So we miss the fact // that %25 has a def for %i that should be used. // // By making the argument %0, we make |phi_candidate| incomplete, // which will cause it to be completed after the whole CFG has // been scanned. uint32_t arg_id = IsBlockSealed(pred_bb) ? GetReachingDef(phi_candidate->var_id(), pred_bb) : 0; phi_candidate->phi_args().push_back(arg_id); if (arg_id == 0) { found_0_arg = true; } else { // If this argument is another Phi candidate, add |phi_candidate| to the // list of users for the defining Phi. PhiCandidate* defining_phi = GetPhiCandidate(arg_id); if (defining_phi && defining_phi != phi_candidate) { defining_phi->AddUser(phi_candidate->result_id()); } } } // If we could not fill-in all the arguments of this Phi, mark it incomplete // so it gets completed after the whole CFG has been processed. if (found_0_arg) { phi_candidate->MarkIncomplete(); incomplete_phis_.push(phi_candidate); return phi_candidate->result_id(); } // Try to remove |phi_candidate|, if it's trivial. uint32_t repl_id = TryRemoveTrivialPhi(phi_candidate); if (repl_id == phi_candidate->result_id()) { // |phi_candidate| is complete and not trivial. Add it to the // list of Phi candidates to generate. phi_candidate->MarkComplete(); phis_to_generate_.push_back(phi_candidate); } return repl_id; } uint32_t SSARewriter::GetValueAtBlock(uint32_t var_id, BasicBlock* bb) { assert(bb != nullptr); const auto& bb_it = defs_at_block_.find(bb); if (bb_it != defs_at_block_.end()) { const auto& current_defs = bb_it->second; const auto& var_it = current_defs.find(var_id); if (var_it != current_defs.end()) { return var_it->second; } } return 0; } uint32_t SSARewriter::GetReachingDef(uint32_t var_id, BasicBlock* bb) { // If |var_id| has a definition in |bb|, return it. uint32_t val_id = GetValueAtBlock(var_id, bb); if (val_id != 0) return val_id; // Otherwise, look up the value for |var_id| in |bb|'s predecessors. auto& predecessors = pass_->cfg()->preds(bb->id()); if (predecessors.size() == 1) { // If |bb| has exactly one predecessor, we look for |var_id|'s definition // there. val_id = GetReachingDef(var_id, pass_->cfg()->block(predecessors[0])); } else if (predecessors.size() > 1) { // If there is more than one predecessor, this is a join block which may // require a Phi instruction. This will act as |var_id|'s current // definition to break potential cycles. PhiCandidate& phi_candidate = CreatePhiCandidate(var_id, bb); // Set the value for |bb| to avoid an infinite recursion. WriteVariable(var_id, bb, phi_candidate.result_id()); val_id = AddPhiOperands(&phi_candidate); } // If we could not find a store for this variable in the path from the root // of the CFG, the variable is not defined, so we use undef. if (val_id == 0) { val_id = pass_->GetUndefVal(var_id); if (val_id == 0) { return 0; } } WriteVariable(var_id, bb, val_id); return val_id; } void SSARewriter::SealBlock(BasicBlock* bb) { auto result = sealed_blocks_.insert(bb); (void)result; assert(result.second == true && "Tried to seal the same basic block more than once."); } void SSARewriter::ProcessStore(Instruction* inst, BasicBlock* bb) { auto opcode = inst->opcode(); assert((opcode == spv::Op::OpStore || opcode == spv::Op::OpVariable) && "Expecting a store or a variable definition instruction."); uint32_t var_id = 0; uint32_t val_id = 0; if (opcode == spv::Op::OpStore) { (void)pass_->GetPtr(inst, &var_id); val_id = inst->GetSingleWordInOperand(kStoreValIdInIdx); } else if (inst->NumInOperands() >= 2) { var_id = inst->result_id(); val_id = inst->GetSingleWordInOperand(kVariableInitIdInIdx); } if (pass_->IsTargetVar(var_id)) { WriteVariable(var_id, bb, val_id); pass_->context()->get_debug_info_mgr()->AddDebugValueForVariable( inst, var_id, val_id, inst); #if SSA_REWRITE_DEBUGGING_LEVEL > 1 std::cerr << "\tFound store '%" << var_id << " = %" << val_id << "': " << inst->PrettyPrint(SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES) << "\n"; #endif } } bool SSARewriter::ProcessLoad(Instruction* inst, BasicBlock* bb) { // Get the pointer that we are using to load from. uint32_t var_id = 0; (void)pass_->GetPtr(inst, &var_id); // Get the immediate reaching definition for |var_id|. // // In the presence of variable pointers, the reaching definition may be // another pointer. For example, the following fragment: // // %2 = OpVariable %_ptr_Input_float Input // %11 = OpVariable %_ptr_Function__ptr_Input_float Function // OpStore %11 %2 // %12 = OpLoad %_ptr_Input_float %11 // %13 = OpLoad %float %12 // // corresponds to the pseudo-code: // // layout(location = 0) in flat float *%2 // float %13; // float *%12; // float **%11; // *%11 = %2; // %12 = *%11; // %13 = *%12; // // which ultimately, should correspond to: // // %13 = *%2; // // During rewriting, the pointer %12 is found to be replaceable by %2 (i.e., // load_replacement_[12] is 2). However, when processing the load // %13 = *%12, the type of %12's reaching definition is another float // pointer (%2), instead of a float value. // // When this happens, we need to continue looking up the reaching definition // chain until we get to a float value or a non-target var (i.e. a variable // that cannot be SSA replaced, like %2 in this case since it is a function // argument). analysis::DefUseManager* def_use_mgr = pass_->context()->get_def_use_mgr(); analysis::TypeManager* type_mgr = pass_->context()->get_type_mgr(); analysis::Type* load_type = type_mgr->GetType(inst->type_id()); uint32_t val_id = 0; bool found_reaching_def = false; while (!found_reaching_def) { if (!pass_->IsTargetVar(var_id)) { // If the variable we are loading from is not an SSA target (globals, // function parameters), do nothing. return true; } val_id = GetReachingDef(var_id, bb); if (val_id == 0) { return false; } // If the reaching definition is a pointer type different than the type of // the instruction we are analyzing, then it must be a reference to another // pointer (otherwise, this would be invalid SPIRV). We continue // de-referencing it by making |val_id| be |var_id|. // // NOTE: if there is no reaching definition instruction, it means |val_id| // is an undef. Instruction* reaching_def_inst = def_use_mgr->GetDef(val_id); if (reaching_def_inst && !type_mgr->GetType(reaching_def_inst->type_id())->IsSame(load_type)) { var_id = val_id; } else { found_reaching_def = true; } } // Schedule a replacement for the result of this load instruction with // |val_id|. After all the rewriting decisions are made, every use of // this load will be replaced with |val_id|. uint32_t load_id = inst->result_id(); assert(load_replacement_.count(load_id) == 0); load_replacement_[load_id] = val_id; PhiCandidate* defining_phi = GetPhiCandidate(val_id); if (defining_phi) { defining_phi->AddUser(load_id); } #if SSA_REWRITE_DEBUGGING_LEVEL > 1 std::cerr << "\tFound load: " << inst->PrettyPrint(SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES) << " (replacement for %" << load_id << " is %" << val_id << ")\n"; #endif return true; } void SSARewriter::PrintPhiCandidates() const { std::cerr << "\nPhi candidates:\n"; for (const auto& phi_it : phi_candidates_) { std::cerr << "\tBB %" << phi_it.second.bb()->id() << ": " << phi_it.second.PrettyPrint(pass_->cfg()) << "\n"; } std::cerr << "\n"; } void SSARewriter::PrintReplacementTable() const { std::cerr << "\nLoad replacement table\n"; for (const auto& it : load_replacement_) { std::cerr << "\t%" << it.first << " -> %" << it.second << "\n"; } std::cerr << "\n"; } bool SSARewriter::GenerateSSAReplacements(BasicBlock* bb) { #if SSA_REWRITE_DEBUGGING_LEVEL > 1 std::cerr << "Generating SSA replacements for block: " << bb->id() << "\n"; std::cerr << bb->PrettyPrint(SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES) << "\n"; #endif for (auto& inst : *bb) { auto opcode = inst.opcode(); if (opcode == spv::Op::OpStore || opcode == spv::Op::OpVariable) { ProcessStore(&inst, bb); } else if (inst.opcode() == spv::Op::OpLoad) { if (!ProcessLoad(&inst, bb)) { return false; } } } // Seal |bb|. This means that all the stores in it have been scanned and // it's ready to feed them into its successors. SealBlock(bb); #if SSA_REWRITE_DEBUGGING_LEVEL > 1 PrintPhiCandidates(); PrintReplacementTable(); std::cerr << "\n\n"; #endif return true; } uint32_t SSARewriter::GetReplacement(std::pair repl) { uint32_t val_id = repl.second; auto it = load_replacement_.find(val_id); while (it != load_replacement_.end()) { val_id = it->second; it = load_replacement_.find(val_id); } return val_id; } uint32_t SSARewriter::GetPhiArgument(const PhiCandidate* phi_candidate, uint32_t ix) { assert(phi_candidate->IsReady() && "Tried to get the final argument from an incomplete/trivial Phi"); uint32_t arg_id = phi_candidate->phi_args()[ix]; while (arg_id != 0) { PhiCandidate* phi_user = GetPhiCandidate(arg_id); if (phi_user == nullptr || phi_user->IsReady()) { // If the argument is not a Phi or it's a Phi candidate ready to be // emitted, return it. return arg_id; } arg_id = phi_user->copy_of(); } assert(false && "No Phi candidates in the copy-of chain are ready to be generated"); return 0; } bool SSARewriter::ApplyReplacements() { bool modified = false; #if SSA_REWRITE_DEBUGGING_LEVEL > 2 std::cerr << "\n\nApplying replacement decisions to IR\n\n"; PrintPhiCandidates(); PrintReplacementTable(); std::cerr << "\n\n"; #endif // Add Phi instructions from completed Phi candidates. std::vector generated_phis; for (const PhiCandidate* phi_candidate : phis_to_generate_) { #if SSA_REWRITE_DEBUGGING_LEVEL > 2 std::cerr << "Phi candidate: " << phi_candidate->PrettyPrint(pass_->cfg()) << "\n"; #endif assert(phi_candidate->is_complete() && "Tried to instantiate a Phi instruction from an incomplete Phi " "candidate"); auto* local_var = pass_->get_def_use_mgr()->GetDef(phi_candidate->var_id()); // Build the vector of operands for the new OpPhi instruction. uint32_t type_id = pass_->GetPointeeTypeId(local_var); std::vector phi_operands; uint32_t arg_ix = 0; std::unordered_map already_seen; for (uint32_t pred_label : pass_->cfg()->preds(phi_candidate->bb()->id())) { uint32_t op_val_id = GetPhiArgument(phi_candidate, arg_ix++); if (already_seen.count(pred_label) == 0) { phi_operands.push_back( {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {op_val_id}}); phi_operands.push_back( {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {pred_label}}); already_seen[pred_label] = op_val_id; } else { // It is possible that there are two edges from the same parent block. // Since the OpPhi can have only one entry for each parent, we have to // make sure the two edges are consistent with each other. assert(already_seen[pred_label] == op_val_id && "Inconsistent value for duplicate edges."); } } // Generate a new OpPhi instruction and insert it in its basic // block. std::unique_ptr phi_inst( new Instruction(pass_->context(), spv::Op::OpPhi, type_id, phi_candidate->result_id(), phi_operands)); generated_phis.push_back(phi_inst.get()); pass_->get_def_use_mgr()->AnalyzeInstDef(&*phi_inst); pass_->context()->set_instr_block(&*phi_inst, phi_candidate->bb()); auto insert_it = phi_candidate->bb()->begin(); insert_it = insert_it.InsertBefore(std::move(phi_inst)); pass_->context()->get_decoration_mgr()->CloneDecorations( phi_candidate->var_id(), phi_candidate->result_id(), {spv::Decoration::RelaxedPrecision}); // Add DebugValue for the new OpPhi instruction. insert_it->SetDebugScope(local_var->GetDebugScope()); pass_->context()->get_debug_info_mgr()->AddDebugValueForVariable( &*insert_it, phi_candidate->var_id(), phi_candidate->result_id(), &*insert_it); modified = true; } // Scan uses for all inserted Phi instructions. Do this separately from the // registration of the Phi instruction itself to avoid trying to analyze // uses of Phi instructions that have not been registered yet. for (Instruction* phi_inst : generated_phis) { pass_->get_def_use_mgr()->AnalyzeInstUse(&*phi_inst); } #if SSA_REWRITE_DEBUGGING_LEVEL > 1 std::cerr << "\n\nReplacing the result of load instructions with the " "corresponding SSA id\n\n"; #endif // Apply replacements from the load replacement table. for (auto& repl : load_replacement_) { uint32_t load_id = repl.first; uint32_t val_id = GetReplacement(repl); Instruction* load_inst = pass_->context()->get_def_use_mgr()->GetDef(load_id); #if SSA_REWRITE_DEBUGGING_LEVEL > 2 std::cerr << "\t" << load_inst->PrettyPrint( SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES) << " (%" << load_id << " -> %" << val_id << ")\n"; #endif // Remove the load instruction and replace all the uses of this load's // result with |val_id|. Kill any names or decorates using the load's // result before replacing to prevent incorrect replacement in those // instructions. pass_->context()->KillNamesAndDecorates(load_id); pass_->context()->ReplaceAllUsesWith(load_id, val_id); pass_->context()->KillInst(load_inst); modified = true; } return modified; } void SSARewriter::FinalizePhiCandidate(PhiCandidate* phi_candidate) { assert(phi_candidate->phi_args().size() > 0 && "Phi candidate should have arguments"); uint32_t ix = 0; for (uint32_t pred : pass_->cfg()->preds(phi_candidate->bb()->id())) { BasicBlock* pred_bb = pass_->cfg()->block(pred); uint32_t& arg_id = phi_candidate->phi_args()[ix++]; if (arg_id == 0) { // If |pred_bb| is still not sealed, it means it's unreachable. In this // case, we just use Undef as an argument. arg_id = IsBlockSealed(pred_bb) ? GetReachingDef(phi_candidate->var_id(), pred_bb) : pass_->GetUndefVal(phi_candidate->var_id()); } } // This candidate is now completed. phi_candidate->MarkComplete(); // If |phi_candidate| is not trivial, add it to the list of Phis to // generate. if (TryRemoveTrivialPhi(phi_candidate) == phi_candidate->result_id()) { // If we could not remove |phi_candidate|, it means that it is complete // and not trivial. Add it to the list of Phis to generate. assert(!phi_candidate->copy_of() && "A completed Phi cannot be trivial."); phis_to_generate_.push_back(phi_candidate); } } void SSARewriter::FinalizePhiCandidates() { #if SSA_REWRITE_DEBUGGING_LEVEL > 1 std::cerr << "Finalizing Phi candidates:\n\n"; PrintPhiCandidates(); std::cerr << "\n"; #endif // Now, complete the collected candidates. while (incomplete_phis_.size() > 0) { PhiCandidate* phi_candidate = incomplete_phis_.front(); incomplete_phis_.pop(); FinalizePhiCandidate(phi_candidate); } } Pass::Status SSARewriter::RewriteFunctionIntoSSA(Function* fp) { #if SSA_REWRITE_DEBUGGING_LEVEL > 0 std::cerr << "Function before SSA rewrite:\n" << fp->PrettyPrint(0) << "\n\n\n"; #endif // Collect variables that can be converted into SSA IDs. pass_->CollectTargetVars(fp); // Generate all the SSA replacements and Phi candidates. This will // generate incomplete and trivial Phis. bool succeeded = pass_->cfg()->WhileEachBlockInReversePostOrder( fp->entry().get(), [this](BasicBlock* bb) { if (!GenerateSSAReplacements(bb)) { return false; } return true; }); if (!succeeded) { return Pass::Status::Failure; } // Remove trivial Phis and add arguments to incomplete Phis. FinalizePhiCandidates(); // Finally, apply all the replacements in the IR. bool modified = ApplyReplacements(); #if SSA_REWRITE_DEBUGGING_LEVEL > 0 std::cerr << "\n\n\nFunction after SSA rewrite:\n" << fp->PrettyPrint(0) << "\n"; #endif return modified ? Pass::Status::SuccessWithChange : Pass::Status::SuccessWithoutChange; } Pass::Status SSARewritePass::Process() { Status status = Status::SuccessWithoutChange; for (auto& fn : *get_module()) { if (fn.IsDeclaration()) { continue; } status = CombineStatus(status, SSARewriter(this).RewriteFunctionIntoSSA(&fn)); // Kill DebugDeclares for target variables. for (auto var_id : seen_target_vars_) { context()->get_debug_info_mgr()->KillDebugDeclares(var_id); } if (status == Status::Failure) { break; } } return status; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/ssa_rewrite_pass.h000066400000000000000000000303471475742701700243700ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_SSA_REWRITE_PASS_H_ #define SOURCE_OPT_SSA_REWRITE_PASS_H_ #include #include #include #include #include #include #include "source/opt/basic_block.h" #include "source/opt/ir_context.h" #include "source/opt/mem_pass.h" namespace spvtools { namespace opt { // Utility class for passes that need to rewrite a function into SSA. This // converts load/store operations on function-local variables into SSA IDs, // which allows them to be the target of optimizing transformations. // // Store and load operations to these variables are converted into // operations on SSA IDs. Phi instructions are added when needed. See the // SSA construction paper for algorithmic details // (https://link.springer.com/chapter/10.1007/978-3-642-37051-9_6) class SSARewriter { public: SSARewriter(MemPass* pass) : pass_(pass) {} // Rewrites SSA-target variables in function |fp| into SSA. This is the // entry point for the SSA rewrite algorithm. SSA-target variables are // locally defined variables that meet the criteria set by IsSSATargetVar. // // Returns whether the function was modified or not, and whether or not the // rewrite was successful. Pass::Status RewriteFunctionIntoSSA(Function* fp); private: class PhiCandidate { public: explicit PhiCandidate(uint32_t var, uint32_t result, BasicBlock* block) : var_id_(var), result_id_(result), bb_(block), phi_args_(), copy_of_(0), is_complete_(false), users_() {} uint32_t var_id() const { return var_id_; } uint32_t result_id() const { return result_id_; } BasicBlock* bb() const { return bb_; } std::vector& phi_args() { return phi_args_; } const std::vector& phi_args() const { return phi_args_; } uint32_t copy_of() const { return copy_of_; } bool is_complete() const { return is_complete_; } std::vector& users() { return users_; } const std::vector& users() const { return users_; } // Marks this phi candidate as a trivial copy of |orig_id|. void MarkCopyOf(uint32_t orig_id) { copy_of_ = orig_id; } // Marks this phi candidate as incomplete. void MarkIncomplete() { is_complete_ = false; } // Marks this phi candidate as complete. void MarkComplete() { is_complete_ = true; } // Returns true if this Phi candidate is ready to be emitted. bool IsReady() const { return is_complete() && copy_of() == 0; } // Pretty prints this Phi candidate into a string and returns it. |cfg| is // needed to lookup basic block predecessors. std::string PrettyPrint(const CFG* cfg) const; // Registers |operand_id| as a user of this Phi candidate. void AddUser(uint32_t operand_id) { users_.push_back(operand_id); } private: // Variable ID that this Phi is merging. uint32_t var_id_; // SSA ID generated by this Phi (i.e., this is the result ID of the eventual // Phi instruction). uint32_t result_id_; // Basic block to hold this Phi. BasicBlock* bb_; // Vector of operands for every predecessor block of |bb|. This vector is // organized so that the Ith slot contains the argument coming from the Ith // predecessor of |bb|. std::vector phi_args_; // If this Phi is a trivial copy of another Phi, this is the ID of the // original. If this is 0, it means that this is not a trivial Phi. uint32_t copy_of_; // False, if this Phi candidate has no arguments or at least one argument is // %0. bool is_complete_; // List of all users for this Phi instruction. Each element is the result ID // of the load instruction replaced by this Phi, or the result ID of a Phi // candidate that has this Phi in its list of operands. std::vector users_; }; // Type used to keep track of store operations in each basic block. typedef std::unordered_map> BlockDefsMap; // Generates all the SSA rewriting decisions for basic block |bb|. This // populates the Phi candidate table (|phi_candidate_|) and the load // replacement table (|load_replacement_). Returns true if successful. bool GenerateSSAReplacements(BasicBlock* bb); // Seals block |bb|. Sealing a basic block means |bb| and all its // predecessors of |bb| have been scanned for loads/stores. void SealBlock(BasicBlock* bb); // Returns true if |bb| has been sealed. bool IsBlockSealed(BasicBlock* bb) { return sealed_blocks_.count(bb) != 0; } // Returns the Phi candidate with result ID |id| if it exists in the table // |phi_candidates_|. If no such Phi candidate exists, it returns nullptr. PhiCandidate* GetPhiCandidate(uint32_t id) { auto it = phi_candidates_.find(id); return (it != phi_candidates_.end()) ? &it->second : nullptr; } // Replaces all the users of Phi candidate |phi_cand| to be users of // |repl_id|. void ReplacePhiUsersWith(const PhiCandidate& phi_cand, uint32_t repl_id); // Returns the value ID that should replace the load ID in the given // replacement pair |repl|. The replacement is a pair (|load_id|, |val_id|). // If |val_id| is itself replaced by another value in the table, this function // will look the replacement for |val_id| until it finds one that is not // itself replaced. For instance, given: // // %34 = OpLoad %float %f1 // OpStore %t %34 // %36 = OpLoad %float %t // // Assume that %f1 is reached by a Phi candidate %42, the load // replacement table will have the following entries: // // %34 -> %42 // %36 -> %34 // // So, when looking for the replacement for %36, we should not use // %34. Rather, we should use %42. To do this, the chain of // replacements must be followed until we reach an element that has // no replacement. uint32_t GetReplacement(std::pair repl); // Returns the argument at index |ix| from |phi_candidate|. If argument |ix| // comes from a trivial Phi, it follows the copy-of chain from that trivial // Phi until it finds the original Phi candidate. // // This is only valid after all Phi candidates have been completed. It can // only be called when generating the IR for these Phis. uint32_t GetPhiArgument(const PhiCandidate* phi_candidate, uint32_t ix); // Applies all the SSA replacement decisions. This replaces loads/stores to // SSA target variables with their corresponding SSA IDs, and inserts Phi // instructions for them. bool ApplyReplacements(); // Registers a definition for variable |var_id| in basic block |bb| with // value |val_id|. void WriteVariable(uint32_t var_id, BasicBlock* bb, uint32_t val_id) { defs_at_block_[bb][var_id] = val_id; if (auto* pc = GetPhiCandidate(val_id)) { pc->AddUser(bb->id()); } } // Returns the value of |var_id| at |bb| if |defs_at_block_| contains it. // Otherwise, returns 0. uint32_t GetValueAtBlock(uint32_t var_id, BasicBlock* bb); // Processes the store operation |inst| in basic block |bb|. This extracts // the variable ID being stored into, determines whether the variable is an // SSA-target variable, and, if it is, it stores its value in the // |defs_at_block_| map. void ProcessStore(Instruction* inst, BasicBlock* bb); // Processes the load operation |inst| in basic block |bb|. This extracts // the variable ID being stored into, determines whether the variable is an // SSA-target variable, and, if it is, it reads its reaching definition by // calling |GetReachingDef|. Returns true if successful. bool ProcessLoad(Instruction* inst, BasicBlock* bb); // Reads the current definition for variable |var_id| in basic block |bb|. // If |var_id| is not defined in block |bb| it walks up the predecessors of // |bb|, creating new Phi candidates along the way, if needed. // // It returns the value for |var_id| from the RHS of the current reaching // definition for |var_id|. uint32_t GetReachingDef(uint32_t var_id, BasicBlock* bb); // Adds arguments to |phi_candidate| by getting the reaching definition of // |phi_candidate|'s variable on each of the predecessors of its basic // block. After populating the argument list, it determines whether all its // arguments are the same. If so, it returns the ID of the argument that // this Phi copies. uint32_t AddPhiOperands(PhiCandidate* phi_candidate); // Creates a Phi candidate instruction for variable |var_id| in basic block // |bb|. // // Since the rewriting algorithm may remove Phi candidates when it finds // them to be trivial, we avoid the expense of creating actual Phi // instructions by keeping a pool of Phi candidates (|phi_candidates_|) // during rewriting. // // Once the candidate Phi is created, it returns its ID. PhiCandidate& CreatePhiCandidate(uint32_t var_id, BasicBlock* bb); // Attempts to remove a trivial Phi candidate |phi_cand|. Trivial Phis are // those that only reference themselves and one other value |val| any number // of times. This will try to remove any other Phis that become trivial // after |phi_cand| is removed. // // If |phi_cand| is trivial, it returns the SSA ID for the value that should // replace it. Otherwise, it returns the SSA ID for |phi_cand|. uint32_t TryRemoveTrivialPhi(PhiCandidate* phi_cand); // Finalizes |phi_candidate| by replacing every argument that is still %0 // with its reaching definition. void FinalizePhiCandidate(PhiCandidate* phi_candidate); // Finalizes processing of Phi candidates. Once the whole function has been // scanned for loads and stores, the CFG will still have some incomplete and // trivial Phis. This will add missing arguments and remove trivial Phi // candidates. void FinalizePhiCandidates(); // Prints the table of Phi candidates to std::cerr. void PrintPhiCandidates() const; // Prints the load replacement table to std::cerr. void PrintReplacementTable() const; // Map holding the value of every SSA-target variable at every basic block // where the variable is stored. defs_at_block_[block][var_id] = val_id // means that there is a store or Phi instruction for variable |var_id| at // basic block |block| with value |val_id|. BlockDefsMap defs_at_block_; // Map, indexed by Phi ID, holding all the Phi candidates created during SSA // rewriting. |phi_candidates_[id]| returns the Phi candidate whose result // is |id|. std::unordered_map phi_candidates_; // Queue of incomplete Phi candidates. These are Phi candidates created at // unsealed blocks. They need to be completed before they are instantiated // in ApplyReplacements. std::queue incomplete_phis_; // List of completed Phi candidates. These are the only candidates that // will become real Phi instructions. std::vector phis_to_generate_; // SSA replacement table. This maps variable IDs, resulting from a load // operation, to the value IDs that will replace them after SSA rewriting. // After all the rewriting decisions are made, a final scan through the IR // is done to replace all uses of the original load ID with the value ID. std::unordered_map load_replacement_; // Set of blocks that have been sealed already. std::unordered_set sealed_blocks_; // Memory pass requesting the SSA rewriter. MemPass* pass_; }; class SSARewritePass : public MemPass { public: SSARewritePass() = default; const char* name() const override { return "ssa-rewrite"; } Status Process() override; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_SSA_REWRITE_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/strength_reduction_pass.cpp000066400000000000000000000145311475742701700263030ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/strength_reduction_pass.h" #include #include #include #include #include "source/opt/def_use_manager.h" #include "source/opt/ir_context.h" #include "source/opt/log.h" #include "source/opt/reflect.h" namespace spvtools { namespace opt { namespace { // Count the number of trailing zeros in the binary representation of // |constVal|. uint32_t CountTrailingZeros(uint32_t constVal) { // Faster if we use the hardware count trailing zeros instruction. // If not available, we could create a table. uint32_t shiftAmount = 0; while ((constVal & 1) == 0) { ++shiftAmount; constVal = (constVal >> 1); } return shiftAmount; } // Return true if |val| is a power of 2. bool IsPowerOf2(uint32_t val) { // The idea is that the & will clear out the least // significant 1 bit. If it is a power of 2, then // there is exactly 1 bit set, and the value becomes 0. if (val == 0) return false; return ((val - 1) & val) == 0; } } // namespace Pass::Status StrengthReductionPass::Process() { // Initialize the member variables on a per module basis. bool modified = false; int32_type_id_ = 0; uint32_type_id_ = 0; std::memset(constant_ids_, 0, sizeof(constant_ids_)); FindIntTypesAndConstants(); modified = ScanFunctions(); return (modified ? Status::SuccessWithChange : Status::SuccessWithoutChange); } bool StrengthReductionPass::ReplaceMultiplyByPowerOf2( BasicBlock::iterator* inst) { assert((*inst)->opcode() == spv::Op::OpIMul && "Only works for multiplication of integers."); bool modified = false; // Currently only works on 32-bit integers. if ((*inst)->type_id() != int32_type_id_ && (*inst)->type_id() != uint32_type_id_) { return modified; } // Check the operands for a constant that is a power of 2. for (int i = 0; i < 2; i++) { uint32_t opId = (*inst)->GetSingleWordInOperand(i); Instruction* opInst = get_def_use_mgr()->GetDef(opId); if (opInst->opcode() == spv::Op::OpConstant) { // We found a constant operand. uint32_t constVal = opInst->GetSingleWordOperand(2); if (IsPowerOf2(constVal)) { modified = true; uint32_t shiftAmount = CountTrailingZeros(constVal); uint32_t shiftConstResultId = GetConstantId(shiftAmount); // Create the new instruction. uint32_t newResultId = TakeNextId(); std::vector newOperands; newOperands.push_back((*inst)->GetInOperand(1 - i)); Operand shiftOperand(spv_operand_type_t::SPV_OPERAND_TYPE_ID, {shiftConstResultId}); newOperands.push_back(shiftOperand); std::unique_ptr newInstruction( new Instruction(context(), spv::Op::OpShiftLeftLogical, (*inst)->type_id(), newResultId, newOperands)); // Insert the new instruction and update the data structures. (*inst) = (*inst).InsertBefore(std::move(newInstruction)); get_def_use_mgr()->AnalyzeInstDefUse(&*(*inst)); ++(*inst); context()->ReplaceAllUsesWith((*inst)->result_id(), newResultId); // Remove the old instruction. Instruction* inst_to_delete = &*(*inst); --(*inst); context()->KillInst(inst_to_delete); // We do not want to replace the instruction twice if both operands // are constants that are a power of 2. So we break here. break; } } } return modified; } void StrengthReductionPass::FindIntTypesAndConstants() { analysis::Integer int32(32, true); int32_type_id_ = context()->get_type_mgr()->GetId(&int32); analysis::Integer uint32(32, false); uint32_type_id_ = context()->get_type_mgr()->GetId(&uint32); for (auto iter = get_module()->types_values_begin(); iter != get_module()->types_values_end(); ++iter) { switch (iter->opcode()) { case spv::Op::OpConstant: if (iter->type_id() == uint32_type_id_) { uint32_t value = iter->GetSingleWordOperand(2); if (value <= 32) constant_ids_[value] = iter->result_id(); } break; default: break; } } } uint32_t StrengthReductionPass::GetConstantId(uint32_t val) { assert(val <= 32 && "This function does not handle constants larger than 32."); if (constant_ids_[val] == 0) { if (uint32_type_id_ == 0) { analysis::Integer uint(32, false); uint32_type_id_ = context()->get_type_mgr()->GetTypeInstruction(&uint); } // Construct the constant. uint32_t resultId = TakeNextId(); Operand constant(spv_operand_type_t::SPV_OPERAND_TYPE_LITERAL_INTEGER, {val}); std::unique_ptr newConstant(new Instruction( context(), spv::Op::OpConstant, uint32_type_id_, resultId, {constant})); get_module()->AddGlobalValue(std::move(newConstant)); // Notify the DefUseManager about this constant. auto constantIter = --get_module()->types_values_end(); get_def_use_mgr()->AnalyzeInstDef(&*constantIter); // Store the result id for next time. constant_ids_[val] = resultId; } return constant_ids_[val]; } bool StrengthReductionPass::ScanFunctions() { // I did not use |ForEachInst| in the module because the function that acts on // the instruction gets a pointer to the instruction. We cannot use that to // insert a new instruction. I want an iterator. bool modified = false; for (auto& func : *get_module()) { for (auto& bb : func) { for (auto inst = bb.begin(); inst != bb.end(); ++inst) { switch (inst->opcode()) { case spv::Op::OpIMul: if (ReplaceMultiplyByPowerOf2(&inst)) modified = true; break; default: break; } } } } return modified; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/strength_reduction_pass.h000066400000000000000000000043241475742701700257470ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_STRENGTH_REDUCTION_PASS_H_ #define SOURCE_OPT_STRENGTH_REDUCTION_PASS_H_ #include "source/opt/def_use_manager.h" #include "source/opt/ir_context.h" #include "source/opt/module.h" #include "source/opt/pass.h" namespace spvtools { namespace opt { // See optimizer.hpp for documentation. class StrengthReductionPass : public Pass { public: const char* name() const override { return "strength-reduction"; } Status Process() override; private: // Replaces multiple by power of 2 with an equivalent bit shift. // Returns true if something changed. bool ReplaceMultiplyByPowerOf2(BasicBlock::iterator*); // Scan the types and constants in the module looking for the integer // types that we are // interested in. The shift operation needs a small unsigned integer. We // need to find // them or create them. We do not want duplicates. void FindIntTypesAndConstants(); // Get the id for the given constant. If it does not exist, it will be // created. The parameter must be between 0 and 32 inclusive. uint32_t GetConstantId(uint32_t); // Replaces certain instructions in function bodies with presumably cheaper // ones. Returns true if something changed. bool ScanFunctions(); // Type ids for the types of interest, or 0 if they do not exist. uint32_t int32_type_id_; uint32_t uint32_type_id_; // constant_ids[i] is the id for unsigned integer constant i. // We set the limit at 32 because a bit shift of a 32-bit integer does not // need a value larger than 32. uint32_t constant_ids_[33]; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_STRENGTH_REDUCTION_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/strip_debug_info_pass.cpp000066400000000000000000000077441475742701700257230ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/strip_debug_info_pass.h" #include "source/opt/ir_context.h" #include "source/util/string_utils.h" namespace spvtools { namespace opt { Pass::Status StripDebugInfoPass::Process() { bool uses_non_semantic_info = false; for (auto& inst : context()->module()->extensions()) { const std::string ext_name = inst.GetInOperand(0).AsString(); if (ext_name == "SPV_KHR_non_semantic_info") { uses_non_semantic_info = true; } } std::vector to_kill; // if we use non-semantic info, it may reference OpString. Do a more // expensive pass checking the uses of the OpString to see if any are // OpExtInst on a non-semantic instruction set. If we're not using the // extension then we can do a simpler pass and kill all debug1 instructions if (uses_non_semantic_info) { for (auto& inst : context()->module()->debugs1()) { switch (inst.opcode()) { case spv::Op::OpString: { analysis::DefUseManager* def_use = context()->get_def_use_mgr(); // see if this string is used anywhere by a non-semantic instruction bool no_nonsemantic_use = def_use->WhileEachUser(&inst, [def_use](Instruction* use) { if (spvIsExtendedInstruction(use->opcode())) { auto ext_inst_set = def_use->GetDef(use->GetSingleWordInOperand(0u)); const std::string extension_name = ext_inst_set->GetInOperand(0).AsString(); if (spvtools::utils::starts_with(extension_name, "NonSemantic.")) { // found a non-semantic use, return false as we cannot // remove this OpString return false; } } // other instructions can't be a non-semantic use return true; }); if (no_nonsemantic_use) to_kill.push_back(&inst); break; } default: to_kill.push_back(&inst); break; } } } else { for (auto& dbg : context()->debugs1()) to_kill.push_back(&dbg); } for (auto& dbg : context()->debugs2()) to_kill.push_back(&dbg); for (auto& dbg : context()->debugs3()) to_kill.push_back(&dbg); for (auto& dbg : context()->ext_inst_debuginfo()) to_kill.push_back(&dbg); // OpName must come first, since they may refer to other debug instructions. // If they are after the instructions that refer to, then they will be killed // when that instruction is killed, which will lead to a double kill. std::sort(to_kill.begin(), to_kill.end(), [](Instruction* lhs, Instruction* rhs) -> bool { if (lhs->opcode() == spv::Op::OpName && rhs->opcode() != spv::Op::OpName) return true; return false; }); bool modified = !to_kill.empty(); for (auto* inst : to_kill) context()->KillInst(inst); // clear OpLine information context()->module()->ForEachInst([&modified](Instruction* inst) { modified |= !inst->dbg_line_insts().empty(); inst->dbg_line_insts().clear(); }); if (!get_module()->trailing_dbg_line_info().empty()) { modified = true; get_module()->trailing_dbg_line_info().clear(); } return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/strip_debug_info_pass.h000066400000000000000000000021061475742701700253530ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_STRIP_DEBUG_INFO_PASS_H_ #define SOURCE_OPT_STRIP_DEBUG_INFO_PASS_H_ #include "source/opt/ir_context.h" #include "source/opt/module.h" #include "source/opt/pass.h" namespace spvtools { namespace opt { // See optimizer.hpp for documentation. class StripDebugInfoPass : public Pass { public: const char* name() const override { return "strip-debug"; } Status Process() override; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_STRIP_DEBUG_INFO_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/strip_nonsemantic_info_pass.cpp000066400000000000000000000076351475742701700271520ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/strip_nonsemantic_info_pass.h" #include #include "source/opt/instruction.h" #include "source/opt/ir_context.h" #include "source/util/string_utils.h" namespace spvtools { namespace opt { Pass::Status StripNonSemanticInfoPass::Process() { bool modified = false; std::vector to_remove; bool other_uses_for_decorate_string = false; for (auto& inst : context()->module()->annotations()) { switch (inst.opcode()) { case spv::Op::OpDecorateStringGOOGLE: if (spv::Decoration(inst.GetSingleWordInOperand(1)) == spv::Decoration::HlslSemanticGOOGLE || spv::Decoration(inst.GetSingleWordInOperand(1)) == spv::Decoration::UserTypeGOOGLE) { to_remove.push_back(&inst); } else { other_uses_for_decorate_string = true; } break; case spv::Op::OpMemberDecorateStringGOOGLE: if (spv::Decoration(inst.GetSingleWordInOperand(2)) == spv::Decoration::HlslSemanticGOOGLE || spv::Decoration(inst.GetSingleWordInOperand(2)) == spv::Decoration::UserTypeGOOGLE) { to_remove.push_back(&inst); } else { other_uses_for_decorate_string = true; } break; case spv::Op::OpDecorateId: if (spv::Decoration(inst.GetSingleWordInOperand(1)) == spv::Decoration::HlslCounterBufferGOOGLE) { to_remove.push_back(&inst); } break; default: break; } } for (auto& inst : context()->module()->extensions()) { const std::string ext_name = inst.GetInOperand(0).AsString(); if (ext_name == "SPV_GOOGLE_hlsl_functionality1") { to_remove.push_back(&inst); } else if (ext_name == "SPV_GOOGLE_user_type") { to_remove.push_back(&inst); } else if (!other_uses_for_decorate_string && ext_name == "SPV_GOOGLE_decorate_string") { to_remove.push_back(&inst); } else if (ext_name == "SPV_KHR_non_semantic_info") { to_remove.push_back(&inst); } } // remove any extended inst imports that are non semantic std::unordered_set non_semantic_sets; for (auto& inst : context()->module()->ext_inst_imports()) { assert(inst.opcode() == spv::Op::OpExtInstImport && "Expecting an import of an extension's instruction set."); const std::string extension_name = inst.GetInOperand(0).AsString(); if (spvtools::utils::starts_with(extension_name, "NonSemantic.")) { non_semantic_sets.insert(inst.result_id()); to_remove.push_back(&inst); } } // if we removed some non-semantic sets, then iterate over the instructions in // the module to remove any OpExtInst that referenced those sets if (!non_semantic_sets.empty()) { context()->module()->ForEachInst( [&non_semantic_sets, &to_remove](Instruction* inst) { if (spvIsExtendedInstruction(inst->opcode())) { if (non_semantic_sets.find(inst->GetSingleWordInOperand(0)) != non_semantic_sets.end()) { to_remove.push_back(inst); } } }, true); } for (auto* inst : to_remove) { modified = true; context()->KillInst(inst); } return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/strip_nonsemantic_info_pass.h000066400000000000000000000030151475742701700266030ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_STRIP_NONSEMANTIC_INFO_PASS_H_ #define SOURCE_OPT_STRIP_NONSEMANTIC_INFO_PASS_H_ #include "source/opt/ir_context.h" #include "source/opt/module.h" #include "source/opt/pass.h" namespace spvtools { namespace opt { // See optimizer.hpp for documentation. class StripNonSemanticInfoPass : public Pass { public: const char* name() const override { return "strip-nonsemantic"; } Status Process() override; // Return the mask of preserved Analyses. IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisCombinators | IRContext::kAnalysisCFG | IRContext::kAnalysisDominatorAnalysis | IRContext::kAnalysisLoopAnalysis | IRContext::kAnalysisNameMap | IRContext::kAnalysisConstants | IRContext::kAnalysisTypes; } }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_STRIP_NONSEMANTIC_INFO_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/struct_cfg_analysis.cpp000066400000000000000000000171421475742701700254120ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/struct_cfg_analysis.h" #include "source/opt/ir_context.h" namespace spvtools { namespace opt { namespace { constexpr uint32_t kMergeNodeIndex = 0; constexpr uint32_t kContinueNodeIndex = 1; } // namespace StructuredCFGAnalysis::StructuredCFGAnalysis(IRContext* ctx) : context_(ctx) { // If this is not a shader, there are no merge instructions, and not // structured CFG to analyze. if (!context_->get_feature_mgr()->HasCapability(spv::Capability::Shader)) { return; } for (auto& func : *context_->module()) { AddBlocksInFunction(&func); } } void StructuredCFGAnalysis::AddBlocksInFunction(Function* func) { if (func->begin() == func->end()) return; std::list order; context_->cfg()->ComputeStructuredOrder(func, &*func->begin(), &order); struct TraversalInfo { ConstructInfo cinfo; uint32_t merge_node; uint32_t continue_node; }; // Set up a stack to keep track of currently active constructs. std::vector state; state.emplace_back(); state[0].cinfo.containing_construct = 0; state[0].cinfo.containing_loop = 0; state[0].cinfo.containing_switch = 0; state[0].cinfo.in_continue = false; state[0].merge_node = 0; state[0].continue_node = 0; for (BasicBlock* block : order) { if (context_->cfg()->IsPseudoEntryBlock(block) || context_->cfg()->IsPseudoExitBlock(block)) { continue; } if (block->id() == state.back().merge_node) { state.pop_back(); } // This works because the structured order is designed to keep the blocks in // the continue construct between the continue header and the merge node. if (block->id() == state.back().continue_node) { state.back().cinfo.in_continue = true; } bb_to_construct_.emplace(std::make_pair(block->id(), state.back().cinfo)); if (Instruction* merge_inst = block->GetMergeInst()) { TraversalInfo new_state; new_state.merge_node = merge_inst->GetSingleWordInOperand(kMergeNodeIndex); new_state.cinfo.containing_construct = block->id(); if (merge_inst->opcode() == spv::Op::OpLoopMerge) { new_state.cinfo.containing_loop = block->id(); new_state.cinfo.containing_switch = 0; new_state.continue_node = merge_inst->GetSingleWordInOperand(kContinueNodeIndex); if (block->id() == new_state.continue_node) { new_state.cinfo.in_continue = true; bb_to_construct_[block->id()].in_continue = true; } else { new_state.cinfo.in_continue = false; } } else { new_state.cinfo.containing_loop = state.back().cinfo.containing_loop; new_state.cinfo.in_continue = state.back().cinfo.in_continue; new_state.continue_node = state.back().continue_node; if (merge_inst->NextNode()->opcode() == spv::Op::OpSwitch) { new_state.cinfo.containing_switch = block->id(); } else { new_state.cinfo.containing_switch = state.back().cinfo.containing_switch; } } state.emplace_back(new_state); merge_blocks_.Set(new_state.merge_node); } } } uint32_t StructuredCFGAnalysis::ContainingConstruct(Instruction* inst) { uint32_t bb = context_->get_instr_block(inst)->id(); return ContainingConstruct(bb); } uint32_t StructuredCFGAnalysis::MergeBlock(uint32_t bb_id) { uint32_t header_id = ContainingConstruct(bb_id); if (header_id == 0) { return 0; } BasicBlock* header = context_->cfg()->block(header_id); Instruction* merge_inst = header->GetMergeInst(); return merge_inst->GetSingleWordInOperand(kMergeNodeIndex); } uint32_t StructuredCFGAnalysis::NestingDepth(uint32_t bb_id) { uint32_t result = 0; // Find the merge block of the current merge construct as long as the block is // inside a merge construct, exiting one for each iteration. for (uint32_t merge_block_id = MergeBlock(bb_id); merge_block_id != 0; merge_block_id = MergeBlock(merge_block_id)) { result++; } return result; } uint32_t StructuredCFGAnalysis::LoopMergeBlock(uint32_t bb_id) { uint32_t header_id = ContainingLoop(bb_id); if (header_id == 0) { return 0; } BasicBlock* header = context_->cfg()->block(header_id); Instruction* merge_inst = header->GetMergeInst(); return merge_inst->GetSingleWordInOperand(kMergeNodeIndex); } uint32_t StructuredCFGAnalysis::LoopContinueBlock(uint32_t bb_id) { uint32_t header_id = ContainingLoop(bb_id); if (header_id == 0) { return 0; } BasicBlock* header = context_->cfg()->block(header_id); Instruction* merge_inst = header->GetMergeInst(); return merge_inst->GetSingleWordInOperand(kContinueNodeIndex); } uint32_t StructuredCFGAnalysis::LoopNestingDepth(uint32_t bb_id) { uint32_t result = 0; // Find the merge block of the current loop as long as the block is inside a // loop, exiting a loop for each iteration. for (uint32_t merge_block_id = LoopMergeBlock(bb_id); merge_block_id != 0; merge_block_id = LoopMergeBlock(merge_block_id)) { result++; } return result; } uint32_t StructuredCFGAnalysis::SwitchMergeBlock(uint32_t bb_id) { uint32_t header_id = ContainingSwitch(bb_id); if (header_id == 0) { return 0; } BasicBlock* header = context_->cfg()->block(header_id); Instruction* merge_inst = header->GetMergeInst(); return merge_inst->GetSingleWordInOperand(kMergeNodeIndex); } bool StructuredCFGAnalysis::IsContinueBlock(uint32_t bb_id) { assert(bb_id != 0); return LoopContinueBlock(bb_id) == bb_id; } bool StructuredCFGAnalysis::IsInContainingLoopsContinueConstruct( uint32_t bb_id) { auto it = bb_to_construct_.find(bb_id); if (it == bb_to_construct_.end()) { return false; } return it->second.in_continue; } bool StructuredCFGAnalysis::IsInContinueConstruct(uint32_t bb_id) { while (bb_id != 0) { if (IsInContainingLoopsContinueConstruct(bb_id)) { return true; } bb_id = ContainingLoop(bb_id); } return false; } bool StructuredCFGAnalysis::IsMergeBlock(uint32_t bb_id) { return merge_blocks_.Get(bb_id); } std::unordered_set StructuredCFGAnalysis::FindFuncsCalledFromContinue() { std::unordered_set called_from_continue; std::queue funcs_to_process; // First collect the functions that are called directly from a continue // construct. for (Function& func : *context_->module()) { for (auto& bb : func) { if (IsInContainingLoopsContinueConstruct(bb.id())) { for (const Instruction& inst : bb) { if (inst.opcode() == spv::Op::OpFunctionCall) { funcs_to_process.push(inst.GetSingleWordInOperand(0)); } } } } } // Now collect all of the functions that are indirectly called as well. while (!funcs_to_process.empty()) { uint32_t func_id = funcs_to_process.front(); funcs_to_process.pop(); Function* func = context_->GetFunction(func_id); if (called_from_continue.insert(func_id).second) { context_->AddCalls(func, &funcs_to_process); } } return called_from_continue; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/struct_cfg_analysis.h000066400000000000000000000136671475742701700250670ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_STRUCT_CFG_ANALYSIS_H_ #define SOURCE_OPT_STRUCT_CFG_ANALYSIS_H_ #include #include #include "source/opt/function.h" #include "source/util/bit_vector.h" namespace spvtools { namespace opt { class IRContext; // An analysis that, for each basic block, finds the constructs in which it is // contained, so we can easily get headers and merge nodes. class StructuredCFGAnalysis { public: explicit StructuredCFGAnalysis(IRContext* ctx); // Returns the id of the header of the innermost merge construct // that contains |bb_id|. Returns |0| if |bb_id| is not contained in any // merge construct. uint32_t ContainingConstruct(uint32_t bb_id) { auto it = bb_to_construct_.find(bb_id); if (it == bb_to_construct_.end()) { return 0; } return it->second.containing_construct; } // Returns the id of the header of the innermost merge construct // that contains |inst|. Returns |0| if |inst| is not contained in any // merge construct. uint32_t ContainingConstruct(Instruction* inst); // Returns the id of the merge block of the innermost merge construct // that contains |bb_id|. Returns |0| if |bb_id| is not contained in any // merge construct. uint32_t MergeBlock(uint32_t bb_id); // Returns the nesting depth of the given block, i.e. the number of merge // constructs containing it. Headers and merge blocks are not considered part // of the corresponding merge constructs. uint32_t NestingDepth(uint32_t block_id); // Returns the id of the header of the innermost loop construct // that contains |bb_id|. Return |0| if |bb_id| is not contained in any loop // construct. uint32_t ContainingLoop(uint32_t bb_id) { auto it = bb_to_construct_.find(bb_id); if (it == bb_to_construct_.end()) { return 0; } return it->second.containing_loop; } // Returns the id of the merge block of the innermost loop construct // that contains |bb_id|. Return |0| if |bb_id| is not contained in any loop // construct. uint32_t LoopMergeBlock(uint32_t bb_id); // Returns the id of the continue block of the innermost loop construct // that contains |bb_id|. Return |0| if |bb_id| is not contained in any loop // construct. uint32_t LoopContinueBlock(uint32_t bb_id); // Returns the loop nesting depth of |bb_id| within its function, i.e. the // number of loop constructs in which |bb_id| is contained. As per other // functions in StructuredCFGAnalysis, a loop header is not regarded as being // part of the loop that it heads, so that e.g. the nesting depth of an // outer-most loop header is 0. uint32_t LoopNestingDepth(uint32_t bb_id); // Returns the id of the header of the innermost switch construct // that contains |bb_id| as long as there is no intervening loop. Returns |0| // if no such construct exists. uint32_t ContainingSwitch(uint32_t bb_id) { auto it = bb_to_construct_.find(bb_id); if (it == bb_to_construct_.end()) { return 0; } return it->second.containing_switch; } // Returns the id of the merge block of the innermost switch construct // that contains |bb_id| as long as there is no intervening loop. Return |0| // if no such block exists. uint32_t SwitchMergeBlock(uint32_t bb_id); // Returns true if |bb_id| is the continue block for a loop. bool IsContinueBlock(uint32_t bb_id); // Returns true if |bb_id| is in the continue construct for its inner most // containing loop. bool IsInContainingLoopsContinueConstruct(uint32_t bb_id); // Returns true if |bb_id| is in the continue construct for any loop in its // function. bool IsInContinueConstruct(uint32_t bb_id); // Return true if |bb_id| is the merge block for a construct. bool IsMergeBlock(uint32_t bb_id); // Returns the set of function ids that are called directly or indirectly from // a continue construct. std::unordered_set FindFuncsCalledFromContinue(); private: // Struct used to hold the information for a basic block. // |containing_construct| is the header for the innermost containing // construct, or 0 if no such construct exists. It could be a selection // construct or a loop construct. // // |containing_loop| is the innermost containing loop construct, or 0 if the // basic bloc is not in a loop. If the basic block is in a selection // construct that is contained in a loop construct, then these two values will // not be the same. // // |containing_switch| is the innermost contain selection construct with an // |OpSwitch| for the branch, as long as there is not intervening loop. This // is used to identify the selection construct from which it can break. // // |in_continue| is true of the block is in the continue construct for its // innermost containing loop. struct ConstructInfo { uint32_t containing_construct; uint32_t containing_loop; uint32_t containing_switch; bool in_continue; }; // Populates |bb_to_construct_| with the innermost containing merge and loop // constructs for each basic block in |func|. void AddBlocksInFunction(Function* func); IRContext* context_; // A map from a basic block to the headers of its inner most containing // constructs. std::unordered_map bb_to_construct_; utils::BitVector merge_blocks_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_STRUCT_CFG_ANALYSIS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/struct_packing_pass.cpp000066400000000000000000000443021475742701700254100ustar00rootroot00000000000000// Copyright (c) 2024 Epic Games, Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "struct_packing_pass.h" #include #include "source/opt/instruction.h" #include "source/opt/ir_context.h" namespace spvtools { namespace opt { /* Std140 packing rules from the original GLSL 140 specification (see https://registry.khronos.org/OpenGL/extensions/ARB/ARB_uniform_buffer_object.txt) When using the "std140" storage layout, structures will be laid out in buffer storage with its members stored in monotonically increasing order based on their location in the declaration. A structure and each structure member have a base offset and a base alignment, from which an aligned offset is computed by rounding the base offset up to a multiple of the base alignment. The base offset of the first member of a structure is taken from the aligned offset of the structure itself. The base offset of all other structure members is derived by taking the offset of the last basic machine unit consumed by the previous member and adding one. Each structure member is stored in memory at its aligned offset. The members of a top-level uniform block are laid out in buffer storage by treating the uniform block as a structure with a base offset of zero. (1) If the member is a scalar consuming basic machine units, the base alignment is . (2) If the member is a two- or four-component vector with components consuming basic machine units, the base alignment is 2 or 4, respectively. (3) If the member is a three-component vector with components consuming basic machine units, the base alignment is 4. (4) If the member is an array of scalars or vectors, the base alignment and array stride are set to match the base alignment of a single array element, according to rules (1), (2), and (3), and rounded up to the base alignment of a vec4. The array may have padding at the end; the base offset of the member following the array is rounded up to the next multiple of the base alignment. (5) If the member is a column-major matrix with columns and rows, the matrix is stored identically to an array of column vectors with components each, according to rule (4). (6) If the member is an array of column-major matrices with columns and rows, the matrix is stored identically to a row of * column vectors with components each, according to rule (4). (7) If the member is a row-major matrix with columns and rows, the matrix is stored identically to an array of row vectors with components each, according to rule (4). (8) If the member is an array of row-major matrices with columns and rows, the matrix is stored identically to a row of * row vectors with components each, according to rule (4). (9) If the member is a structure, the base alignment of the structure is , where is the largest base alignment value of any of its members, and rounded up to the base alignment of a vec4. The individual members of this sub-structure are then assigned offsets by applying this set of rules recursively, where the base offset of the first member of the sub-structure is equal to the aligned offset of the structure. The structure may have padding at the end; the base offset of the member following the sub-structure is rounded up to the next multiple of the base alignment of the structure. (10) If the member is an array of structures, the elements of the array are laid out in order, according to rule (9). */ static bool isPackingVec4Padded(StructPackingPass::PackingRules rules) { switch (rules) { case StructPackingPass::PackingRules::Std140: case StructPackingPass::PackingRules::Std140EnhancedLayout: case StructPackingPass::PackingRules::HlslCbuffer: case StructPackingPass::PackingRules::HlslCbufferPackOffset: return true; default: return false; } } static bool isPackingScalar(StructPackingPass::PackingRules rules) { switch (rules) { case StructPackingPass::PackingRules::Scalar: case StructPackingPass::PackingRules::ScalarEnhancedLayout: return true; default: return false; } } static bool isPackingHlsl(StructPackingPass::PackingRules rules) { switch (rules) { case StructPackingPass::PackingRules::HlslCbuffer: case StructPackingPass::PackingRules::HlslCbufferPackOffset: return true; default: return false; } } static uint32_t getPackedBaseSize(const analysis::Type& type) { switch (type.kind()) { case analysis::Type::kBool: return 1; case analysis::Type::kInteger: return type.AsInteger()->width() / 8; case analysis::Type::kFloat: return type.AsFloat()->width() / 8; case analysis::Type::kVector: return getPackedBaseSize(*type.AsVector()->element_type()); case analysis::Type::kMatrix: return getPackedBaseSize(*type.AsMatrix()->element_type()); default: break; // we only expect bool, int, float, vec, and mat here } assert(0 && "Unrecognized type to get base size"); return 0; } static uint32_t getScalarElementCount(const analysis::Type& type) { switch (type.kind()) { case analysis::Type::kVector: return type.AsVector()->element_count(); case analysis::Type::kMatrix: return getScalarElementCount(*type.AsMatrix()->element_type()); case analysis::Type::kStruct: assert(0 && "getScalarElementCount() does not recognized struct types"); return 0; default: return 1; } } // Aligns the specified value to a multiple of alignment, whereas the // alignment must be a power-of-two. static uint32_t alignPow2(uint32_t value, uint32_t alignment) { return (value + alignment - 1) & ~(alignment - 1); } void StructPackingPass::buildConstantsMap() { constantsMap_.clear(); for (Instruction* instr : context()->module()->GetConstants()) { constantsMap_[instr->result_id()] = instr; } } uint32_t StructPackingPass::getPackedAlignment( const analysis::Type& type) const { switch (type.kind()) { case analysis::Type::kArray: { // Get alignment of base type and round up to minimum alignment const uint32_t minAlignment = isPackingVec4Padded(packingRules_) ? 16 : 1; return std::max( minAlignment, getPackedAlignment(*type.AsArray()->element_type())); } case analysis::Type::kStruct: { // Rule 9. Struct alignment is maximum alignmnet of its members uint32_t alignment = 1; for (const analysis::Type* elementType : type.AsStruct()->element_types()) { alignment = std::max(alignment, getPackedAlignment(*elementType)); } if (isPackingVec4Padded(packingRules_)) alignment = std::max(alignment, 16u); return alignment; } default: { const uint32_t baseAlignment = getPackedBaseSize(type); // Scalar block layout always uses alignment for the most basic component if (isPackingScalar(packingRules_)) return baseAlignment; if (const analysis::Matrix* matrixType = type.AsMatrix()) { // Rule 5/7 if (isPackingVec4Padded(packingRules_) || matrixType->element_count() == 3) return baseAlignment * 4; else return baseAlignment * matrixType->element_count(); } else if (const analysis::Vector* vectorType = type.AsVector()) { // Rule 1 if (vectorType->element_count() == 1) return baseAlignment; // Rule 2 if (vectorType->element_count() == 2 || vectorType->element_count() == 4) return baseAlignment * vectorType->element_count(); // Rule 3 if (vectorType->element_count() == 3) return baseAlignment * 4; } else { // Rule 1 return baseAlignment; } } } assert(0 && "Unrecognized type to get packed alignment"); return 0; } static uint32_t getPadAlignment(const analysis::Type& type, uint32_t packedAlignment) { // The next member following a struct member is aligned to the base alignment // of a previous struct member. return type.kind() == analysis::Type::kStruct ? packedAlignment : 1; } uint32_t StructPackingPass::getPackedSize(const analysis::Type& type) const { switch (type.kind()) { case analysis::Type::kArray: { if (const analysis::Array* arrayType = type.AsArray()) { uint32_t size = getPackedArrayStride(*arrayType) * getArrayLength(*arrayType); // For arrays of vector and matrices in HLSL, the last element has a // size depending on its vector/matrix size to allow packing other // vectors in the last element. const analysis::Type* arraySubType = arrayType->element_type(); if (isPackingHlsl(packingRules_) && arraySubType->kind() != analysis::Type::kStruct) { size -= (4 - getScalarElementCount(*arraySubType)) * getPackedBaseSize(*arraySubType); } return size; } break; } case analysis::Type::kStruct: { uint32_t size = 0; uint32_t padAlignment = 1; for (const analysis::Type* memberType : type.AsStruct()->element_types()) { const uint32_t packedAlignment = getPackedAlignment(*memberType); const uint32_t alignment = std::max(packedAlignment, padAlignment); padAlignment = getPadAlignment(*memberType, packedAlignment); size = alignPow2(size, alignment); size += getPackedSize(*memberType); } return size; } default: { const uint32_t baseAlignment = getPackedBaseSize(type); if (isPackingScalar(packingRules_)) { return getScalarElementCount(type) * baseAlignment; } else { uint32_t size = 0; if (const analysis::Matrix* matrixType = type.AsMatrix()) { const analysis::Vector* matrixSubType = matrixType->element_type()->AsVector(); assert(matrixSubType != nullptr && "Matrix sub-type is expected to be a vector type"); if (isPackingVec4Padded(packingRules_) || matrixType->element_count() == 3) size = matrixSubType->element_count() * baseAlignment * 4; else size = matrixSubType->element_count() * baseAlignment * matrixType->element_count(); // For matrices in HLSL, the last element has a size depending on its // vector size to allow packing other vectors in the last element. if (isPackingHlsl(packingRules_)) { size -= (4 - matrixSubType->element_count()) * getPackedBaseSize(*matrixSubType); } } else if (const analysis::Vector* vectorType = type.AsVector()) { size = vectorType->element_count() * baseAlignment; } else { size = baseAlignment; } return size; } } } assert(0 && "Unrecognized type to get packed size"); return 0; } uint32_t StructPackingPass::getPackedArrayStride( const analysis::Array& arrayType) const { // Array stride is equal to aligned size of element type const uint32_t elementSize = getPackedSize(*arrayType.element_type()); const uint32_t alignment = getPackedAlignment(arrayType); return alignPow2(elementSize, alignment); } uint32_t StructPackingPass::getArrayLength( const analysis::Array& arrayType) const { return getConstantInt(arrayType.LengthId()); } uint32_t StructPackingPass::getConstantInt(spv::Id id) const { auto it = constantsMap_.find(id); assert(it != constantsMap_.end() && "Failed to map SPIR-V instruction ID to constant value"); [[maybe_unused]] const analysis::Type* constType = context()->get_type_mgr()->GetType(it->second->type_id()); assert(constType != nullptr && "Failed to map SPIR-V instruction result type to definition"); assert(constType->kind() == analysis::Type::kInteger && "Failed to map SPIR-V instruction result type to integer type"); return it->second->GetOperand(2).words[0]; } StructPackingPass::PackingRules StructPackingPass::ParsePackingRuleFromString( const std::string& s) { if (s == "std140") return PackingRules::Std140; if (s == "std140EnhancedLayout") return PackingRules::Std140EnhancedLayout; if (s == "std430") return PackingRules::Std430; if (s == "std430EnhancedLayout") return PackingRules::Std430EnhancedLayout; if (s == "hlslCbuffer") return PackingRules::HlslCbuffer; if (s == "hlslCbufferPackOffset") return PackingRules::HlslCbufferPackOffset; if (s == "scalar") return PackingRules::Scalar; if (s == "scalarEnhancedLayout") return PackingRules::ScalarEnhancedLayout; return PackingRules::Undefined; } StructPackingPass::StructPackingPass(const char* structToPack, PackingRules rules) : structToPack_{structToPack != nullptr ? structToPack : ""}, packingRules_{rules} {} Pass::Status StructPackingPass::Process() { if (packingRules_ == PackingRules::Undefined) { if (consumer()) { consumer()(SPV_MSG_ERROR, "", {0, 0, 0}, "Cannot pack struct with undefined rule"); } return Status::Failure; } // Build Id-to-instruction map for easier access buildConstantsMap(); // Find structure of interest const uint32_t structIdToPack = findStructIdByName(structToPack_.c_str()); const Instruction* structDef = context()->get_def_use_mgr()->GetDef(structIdToPack); if (structDef == nullptr || structDef->opcode() != spv::Op::OpTypeStruct) { if (consumer()) { const std::string message = "Failed to find struct with name " + structToPack_; consumer()(SPV_MSG_ERROR, "", {0, 0, 0}, message.c_str()); } return Status::Failure; } // Find all struct member types std::vector structMemberTypes = findStructMemberTypes(*structDef); return assignStructMemberOffsets(structIdToPack, structMemberTypes); } uint32_t StructPackingPass::findStructIdByName(const char* structName) const { for (Instruction& instr : context()->module()->debugs2()) { if (instr.opcode() == spv::Op::OpName && instr.GetOperand(1).AsString() == structName) { return instr.GetOperand(0).AsId(); } } return 0; } std::vector StructPackingPass::findStructMemberTypes( const Instruction& structDef) const { // Found struct type to pack, now collect all types of its members assert(structDef.NumOperands() > 0 && "Number of operands in OpTypeStruct instruction must not be zero"); const uint32_t numMembers = structDef.NumOperands() - 1; std::vector structMemberTypes; structMemberTypes.resize(numMembers); for (uint32_t i = 0; i < numMembers; ++i) { const spv::Id memberTypeId = structDef.GetOperand(1 + i).AsId(); if (const analysis::Type* memberType = context()->get_type_mgr()->GetType(memberTypeId)) { structMemberTypes[i] = memberType; } } return structMemberTypes; } Pass::Status StructPackingPass::assignStructMemberOffsets( uint32_t structIdToPack, const std::vector& structMemberTypes) { // Returns true if the specified instruction is a OpMemberDecorate for the // struct we're looking for with an offset decoration auto isMemberOffsetDecoration = [structIdToPack](const Instruction& instr) -> bool { return instr.opcode() == spv::Op::OpMemberDecorate && instr.GetOperand(0).AsId() == structIdToPack && static_cast(instr.GetOperand(2).words[0]) == spv::Decoration::Offset; }; bool modified = false; // Find and re-assign all member offset decorations for (auto it = context()->module()->annotation_begin(), itEnd = context()->module()->annotation_end(); it != itEnd; ++it) { if (isMemberOffsetDecoration(*it)) { // Found first member decoration with offset, we expect all other // offsets right after the first one uint32_t prevMemberIndex = 0; uint32_t currentOffset = 0; uint32_t padAlignment = 1; do { const uint32_t memberIndex = it->GetOperand(1).words[0]; if (memberIndex < prevMemberIndex) { // Failure: we expect all members to appear in consecutive order return Status::Failure; } // Apply alignment rules to current offset const analysis::Type& memberType = *structMemberTypes[memberIndex]; uint32_t packedAlignment = getPackedAlignment(memberType); uint32_t packedSize = getPackedSize(memberType); if (isPackingHlsl(packingRules_)) { // If a member crosses vec4 boundaries, alignment is size of vec4 if (currentOffset / 16 != (currentOffset + packedSize - 1) / 16) packedAlignment = std::max(packedAlignment, 16u); } const uint32_t alignment = std::max(packedAlignment, padAlignment); currentOffset = alignPow2(currentOffset, alignment); padAlignment = getPadAlignment(memberType, packedAlignment); // Override packed offset in instruction if (it->GetOperand(3).words[0] < currentOffset) { // Failure: packing resulted in higher offset for member than // previously generated return Status::Failure; } it->GetOperand(3).words[0] = currentOffset; modified = true; // Move to next member ++it; prevMemberIndex = memberIndex; currentOffset += packedSize; } while (it != itEnd && isMemberOffsetDecoration(*it)); // We're done with all decorations for the struct of interest break; } } return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/struct_packing_pass.h000066400000000000000000000053211475742701700250530ustar00rootroot00000000000000// Copyright (c) 2024 Epic Games, Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_STRUCT_PACKING_PASS_ #define SOURCE_OPT_STRUCT_PACKING_PASS_ #include #include "source/opt/ir_context.h" #include "source/opt/module.h" #include "source/opt/pass.h" namespace spvtools { namespace opt { // This pass re-assigns all field offsets under the specified packing rules. class StructPackingPass final : public Pass { public: enum class PackingRules { Undefined, Std140, Std140EnhancedLayout, Std430, Std430EnhancedLayout, HlslCbuffer, HlslCbufferPackOffset, Scalar, ScalarEnhancedLayout, }; static PackingRules ParsePackingRuleFromString(const std::string& s); StructPackingPass(const char* structToPack, PackingRules rules); const char* name() const override { return "struct-packing"; } Status Process() override; IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisCombinators | IRContext::kAnalysisCFG | IRContext::kAnalysisDominatorAnalysis | IRContext::kAnalysisLoopAnalysis | IRContext::kAnalysisNameMap | IRContext::kAnalysisScalarEvolution | IRContext::kAnalysisStructuredCFG | IRContext::kAnalysisConstants | IRContext::kAnalysisDebugInfo | IRContext::kAnalysisLiveness; } private: void buildConstantsMap(); uint32_t findStructIdByName(const char* structName) const; std::vector findStructMemberTypes( const Instruction& structDef) const; Status assignStructMemberOffsets( uint32_t structIdToPack, const std::vector& structMemberTypes); uint32_t getPackedAlignment(const analysis::Type& type) const; uint32_t getPackedSize(const analysis::Type& type) const; uint32_t getPackedArrayStride(const analysis::Array& arrayType) const; uint32_t getArrayLength(const analysis::Array& arrayType) const; uint32_t getConstantInt(spv::Id id) const; private: std::string structToPack_; PackingRules packingRules_ = PackingRules::Undefined; std::unordered_map constantsMap_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_STRUCT_PACKING_PASS_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/switch_descriptorset_pass.cpp000066400000000000000000000027421475742701700266450ustar00rootroot00000000000000// Copyright (c) 2023 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/switch_descriptorset_pass.h" #include "source/opt/ir_builder.h" #include "source/util/string_utils.h" namespace spvtools { namespace opt { Pass::Status SwitchDescriptorSetPass::Process() { Status status = Status::SuccessWithoutChange; auto* deco_mgr = context()->get_decoration_mgr(); for (Instruction& var : context()->types_values()) { if (var.opcode() != spv::Op::OpVariable) { continue; } auto decos = deco_mgr->GetDecorationsFor(var.result_id(), false); for (const auto& deco : decos) { spv::Decoration d = spv::Decoration(deco->GetSingleWordInOperand(1u)); if (d == spv::Decoration::DescriptorSet && deco->GetSingleWordInOperand(2u) == ds_from_) { deco->SetInOperand(2u, {ds_to_}); status = Status::SuccessWithChange; break; } } } return status; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/switch_descriptorset_pass.h000066400000000000000000000027261475742701700263140ustar00rootroot00000000000000// Copyright (c) 2023 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #pragma once #include #include #include #include #include #include #include "source/opt/pass.h" namespace spvtools { namespace opt { // See optimizer.hpp for documentation. class SwitchDescriptorSetPass : public Pass { public: SwitchDescriptorSetPass(uint32_t ds_from, uint32_t ds_to) : ds_from_(ds_from), ds_to_(ds_to) {} const char* name() const override { return "switch-descriptorset"; } Status Process() override; IRContext::Analysis GetPreservedAnalyses() override { // this pass preserves everything except decorations uint32_t mask = ((IRContext::kAnalysisEnd << 1) - 1); mask &= ~static_cast(IRContext::kAnalysisDecorations); return static_cast(mask); } private: uint32_t ds_from_; uint32_t ds_to_; }; } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/tree_iterator.h000066400000000000000000000210251475742701700236540ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_TREE_ITERATOR_H_ #define SOURCE_OPT_TREE_ITERATOR_H_ #include #include #include namespace spvtools { namespace opt { // Helper class to iterate over a tree in a depth first order. // The class assumes the data structure is a tree, tree node type implements a // forward iterator. // At each step, the iterator holds the pointer to the current node and state of // the walk. // The state is recorded by stacking the iteration position of the node // children. To move to the next node, the iterator: // - Looks at the top of the stack; // - Sets the node behind the iterator as the current node; // - Increments the iterator if it has more children to visit, pops otherwise; // - If the current node has children, the children iterator is pushed into the // stack. template class TreeDFIterator { static_assert(!std::is_pointer::value && !std::is_reference::value, "NodeTy should be a class"); // Type alias to keep track of the const qualifier. using NodeIterator = typename std::conditional::value, typename NodeTy::const_iterator, typename NodeTy::iterator>::type; // Type alias to keep track of the const qualifier. using NodePtr = NodeTy*; public: // Standard iterator interface. using reference = NodeTy&; using value_type = NodeTy; explicit inline TreeDFIterator(NodePtr top_node) : current_(top_node) { if (current_ && current_->begin() != current_->end()) parent_iterators_.emplace(make_pair(current_, current_->begin())); } // end() iterator. inline TreeDFIterator() : TreeDFIterator(nullptr) {} bool operator==(const TreeDFIterator& x) const { return current_ == x.current_; } bool operator!=(const TreeDFIterator& x) const { return !(*this == x); } reference operator*() const { return *current_; } NodePtr operator->() const { return current_; } TreeDFIterator& operator++() { MoveToNextNode(); return *this; } TreeDFIterator operator++(int) { TreeDFIterator tmp = *this; ++*this; return tmp; } private: // Moves the iterator to the next node in the tree. // If we are at the end, do nothing, otherwise // if our current node has children, use the children iterator and push the // current node into the stack. // If we reach the end of the local iterator, pop it. inline void MoveToNextNode() { if (!current_) return; if (parent_iterators_.empty()) { current_ = nullptr; return; } std::pair& next_it = parent_iterators_.top(); // Set the new node. current_ = *next_it.second; // Update the iterator for the next child. ++next_it.second; // If we finished with node, pop it. if (next_it.first->end() == next_it.second) parent_iterators_.pop(); // If our current node is not a leaf, store the iteration state for later. if (current_->begin() != current_->end()) parent_iterators_.emplace(make_pair(current_, current_->begin())); } // The current node of the tree. NodePtr current_; // State of the tree walk: each pair contains the parent node (which has been // already visited) and the iterator of the next children to visit. // When all the children has been visited, we pop the entry, get the next // child and push back the pair if the children iterator is not end(). std::stack> parent_iterators_; }; // Helper class to iterate over a tree in a depth first post-order. // The class assumes the data structure is a tree, tree node type implements a // forward iterator. // At each step, the iterator holds the pointer to the current node and state of // the walk. // The state is recorded by stacking the iteration position of the node // children. To move to the next node, the iterator: // - Looks at the top of the stack; // - If the children iterator has reach the end, then the node become the // current one and we pop the stack; // - Otherwise, we save the child and increment the iterator; // - We walk the child sub-tree until we find a leaf, stacking all non-leaves // states (pair of node pointer and child iterator) as we walk it. template class PostOrderTreeDFIterator { static_assert(!std::is_pointer::value && !std::is_reference::value, "NodeTy should be a class"); // Type alias to keep track of the const qualifier. using NodeIterator = typename std::conditional::value, typename NodeTy::const_iterator, typename NodeTy::iterator>::type; // Type alias to keep track of the const qualifier. using NodePtr = NodeTy*; public: // Standard iterator interface. using reference = NodeTy&; using value_type = NodeTy; static inline PostOrderTreeDFIterator begin(NodePtr top_node) { return PostOrderTreeDFIterator(top_node); } static inline PostOrderTreeDFIterator end(NodePtr sentinel_node) { return PostOrderTreeDFIterator(sentinel_node, false); } bool operator==(const PostOrderTreeDFIterator& x) const { return current_ == x.current_; } bool operator!=(const PostOrderTreeDFIterator& x) const { return !(*this == x); } reference operator*() const { return *current_; } NodePtr operator->() const { return current_; } PostOrderTreeDFIterator& operator++() { MoveToNextNode(); return *this; } PostOrderTreeDFIterator operator++(int) { PostOrderTreeDFIterator tmp = *this; ++*this; return tmp; } private: explicit inline PostOrderTreeDFIterator(NodePtr top_node) : current_(top_node) { if (current_) WalkToLeaf(); } // Constructor for the "end()" iterator. // |end_sentinel| is the value that acts as end value (can be null). The bool // parameters is to distinguish from the start() Ctor. inline PostOrderTreeDFIterator(NodePtr sentinel_node, bool) : current_(sentinel_node) {} // Moves the iterator to the next node in the tree. // If we are at the end, do nothing, otherwise // if our current node has children, use the children iterator and push the // current node into the stack. // If we reach the end of the local iterator, pop it. inline void MoveToNextNode() { if (!current_) return; if (parent_iterators_.empty()) { current_ = nullptr; return; } std::pair& next_it = parent_iterators_.top(); // If we visited all children, the current node is the top of the stack. if (next_it.second == next_it.first->end()) { // Set the new node. current_ = next_it.first; parent_iterators_.pop(); return; } // We have more children to visit, set the current node to the first child // and dive to leaf. current_ = *next_it.second; // Update the iterator for the next child (avoid unneeded pop). ++next_it.second; WalkToLeaf(); } // Moves the iterator to the next node in the tree. // If we are at the end, do nothing, otherwise // if our current node has children, use the children iterator and push the // current node into the stack. // If we reach the end of the local iterator, pop it. inline void WalkToLeaf() { while (current_->begin() != current_->end()) { NodeIterator next = ++current_->begin(); parent_iterators_.emplace(make_pair(current_, next)); // Set the first child as the new node. current_ = *current_->begin(); } } // The current node of the tree. NodePtr current_; // State of the tree walk: each pair contains the parent node and the iterator // of the next children to visit. // When all the children has been visited, we pop the first entry and the // parent node become the current node. std::stack> parent_iterators_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_TREE_ITERATOR_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/trim_capabilities_pass.cpp000066400000000000000000000647271475742701700260710ustar00rootroot00000000000000// Copyright (c) 2023 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/trim_capabilities_pass.h" #include #include #include #include #include #include #include #include #include #include #include "source/enum_set.h" #include "source/enum_string_mapping.h" #include "source/ext_inst.h" #include "source/opt/ir_context.h" #include "source/opt/reflect.h" #include "source/spirv_target_env.h" #include "source/util/string_utils.h" namespace spvtools { namespace opt { namespace { constexpr uint32_t kOpTypeFloatSizeIndex = 0; constexpr uint32_t kOpTypePointerStorageClassIndex = 0; constexpr uint32_t kTypeArrayTypeIndex = 0; constexpr uint32_t kOpTypeScalarBitWidthIndex = 0; constexpr uint32_t kTypePointerTypeIdInIndex = 1; constexpr uint32_t kOpTypeIntSizeIndex = 0; constexpr uint32_t kOpTypeImageDimIndex = 1; constexpr uint32_t kOpTypeImageArrayedIndex = kOpTypeImageDimIndex + 2; constexpr uint32_t kOpTypeImageMSIndex = kOpTypeImageArrayedIndex + 1; constexpr uint32_t kOpTypeImageSampledIndex = kOpTypeImageMSIndex + 1; constexpr uint32_t kOpTypeImageFormatIndex = kOpTypeImageSampledIndex + 1; constexpr uint32_t kOpImageReadImageIndex = 0; constexpr uint32_t kOpImageWriteImageIndex = 0; constexpr uint32_t kOpImageSparseReadImageIndex = 0; constexpr uint32_t kOpExtInstSetInIndex = 0; constexpr uint32_t kOpExtInstInstructionInIndex = 1; constexpr uint32_t kOpExtInstImportNameInIndex = 0; // DFS visit of the type defined by `instruction`. // If `condition` is true, children of the current node are visited. // If `condition` is false, the children of the current node are ignored. template static void DFSWhile(const Instruction* instruction, UnaryPredicate condition) { std::stack instructions_to_visit; instructions_to_visit.push(instruction->result_id()); const auto* def_use_mgr = instruction->context()->get_def_use_mgr(); while (!instructions_to_visit.empty()) { const Instruction* item = def_use_mgr->GetDef(instructions_to_visit.top()); instructions_to_visit.pop(); if (!condition(item)) { continue; } if (item->opcode() == spv::Op::OpTypePointer) { instructions_to_visit.push( item->GetSingleWordInOperand(kTypePointerTypeIdInIndex)); continue; } if (item->opcode() == spv::Op::OpTypeMatrix || item->opcode() == spv::Op::OpTypeVector || item->opcode() == spv::Op::OpTypeArray || item->opcode() == spv::Op::OpTypeRuntimeArray) { instructions_to_visit.push( item->GetSingleWordInOperand(kTypeArrayTypeIndex)); continue; } if (item->opcode() == spv::Op::OpTypeStruct) { item->ForEachInOperand([&instructions_to_visit](const uint32_t* op_id) { instructions_to_visit.push(*op_id); }); continue; } } } // Walks the type defined by `instruction` (OpType* only). // Returns `true` if any call to `predicate` with the type/subtype returns true. template static bool AnyTypeOf(const Instruction* instruction, UnaryPredicate predicate) { assert(IsTypeInst(instruction->opcode()) && "AnyTypeOf called with a non-type instruction."); bool found_one = false; DFSWhile(instruction, [&found_one, predicate](const Instruction* node) { if (found_one || predicate(node)) { found_one = true; return false; } return true; }); return found_one; } static bool is16bitType(const Instruction* instruction) { if (instruction->opcode() != spv::Op::OpTypeInt && instruction->opcode() != spv::Op::OpTypeFloat) { return false; } return instruction->GetSingleWordInOperand(kOpTypeScalarBitWidthIndex) == 16; } static bool Has16BitCapability(const FeatureManager* feature_manager) { const CapabilitySet& capabilities = feature_manager->GetCapabilities(); return capabilities.contains(spv::Capability::Float16) || capabilities.contains(spv::Capability::Int16); } } // namespace // ============== Begin opcode handler implementations. ======================= // // Adding support for a new capability should only require adding a new handler, // and updating the // kSupportedCapabilities/kUntouchableCapabilities/kFordiddenCapabilities lists. // // Handler names follow the following convention: // Handler__() static std::optional Handler_OpTypeFloat_Float16( const Instruction* instruction) { assert(instruction->opcode() == spv::Op::OpTypeFloat && "This handler only support OpTypeFloat opcodes."); const uint32_t size = instruction->GetSingleWordInOperand(kOpTypeFloatSizeIndex); return size == 16 ? std::optional(spv::Capability::Float16) : std::nullopt; } static std::optional Handler_OpTypeFloat_Float64( const Instruction* instruction) { assert(instruction->opcode() == spv::Op::OpTypeFloat && "This handler only support OpTypeFloat opcodes."); const uint32_t size = instruction->GetSingleWordInOperand(kOpTypeFloatSizeIndex); return size == 64 ? std::optional(spv::Capability::Float64) : std::nullopt; } static std::optional Handler_OpTypePointer_StorageInputOutput16(const Instruction* instruction) { assert(instruction->opcode() == spv::Op::OpTypePointer && "This handler only support OpTypePointer opcodes."); // This capability is only required if the variable has an Input/Output // storage class. spv::StorageClass storage_class = spv::StorageClass( instruction->GetSingleWordInOperand(kOpTypePointerStorageClassIndex)); if (storage_class != spv::StorageClass::Input && storage_class != spv::StorageClass::Output) { return std::nullopt; } if (!Has16BitCapability(instruction->context()->get_feature_mgr())) { return std::nullopt; } return AnyTypeOf(instruction, is16bitType) ? std::optional(spv::Capability::StorageInputOutput16) : std::nullopt; } static std::optional Handler_OpTypePointer_StoragePushConstant16(const Instruction* instruction) { assert(instruction->opcode() == spv::Op::OpTypePointer && "This handler only support OpTypePointer opcodes."); // This capability is only required if the variable has a PushConstant storage // class. spv::StorageClass storage_class = spv::StorageClass( instruction->GetSingleWordInOperand(kOpTypePointerStorageClassIndex)); if (storage_class != spv::StorageClass::PushConstant) { return std::nullopt; } if (!Has16BitCapability(instruction->context()->get_feature_mgr())) { return std::nullopt; } return AnyTypeOf(instruction, is16bitType) ? std::optional(spv::Capability::StoragePushConstant16) : std::nullopt; } static std::optional Handler_OpTypePointer_StorageUniformBufferBlock16( const Instruction* instruction) { assert(instruction->opcode() == spv::Op::OpTypePointer && "This handler only support OpTypePointer opcodes."); // This capability is only required if the variable has a Uniform storage // class. spv::StorageClass storage_class = spv::StorageClass( instruction->GetSingleWordInOperand(kOpTypePointerStorageClassIndex)); if (storage_class != spv::StorageClass::Uniform) { return std::nullopt; } if (!Has16BitCapability(instruction->context()->get_feature_mgr())) { return std::nullopt; } const auto* decoration_mgr = instruction->context()->get_decoration_mgr(); const bool matchesCondition = AnyTypeOf(instruction, [decoration_mgr](const Instruction* item) { if (!decoration_mgr->HasDecoration(item->result_id(), spv::Decoration::BufferBlock)) { return false; } return AnyTypeOf(item, is16bitType); }); return matchesCondition ? std::optional(spv::Capability::StorageUniformBufferBlock16) : std::nullopt; } static std::optional Handler_OpTypePointer_StorageUniform16( const Instruction* instruction) { assert(instruction->opcode() == spv::Op::OpTypePointer && "This handler only support OpTypePointer opcodes."); // This capability is only required if the variable has a Uniform storage // class. spv::StorageClass storage_class = spv::StorageClass( instruction->GetSingleWordInOperand(kOpTypePointerStorageClassIndex)); if (storage_class != spv::StorageClass::Uniform) { return std::nullopt; } const auto* feature_manager = instruction->context()->get_feature_mgr(); if (!Has16BitCapability(feature_manager)) { return std::nullopt; } const bool hasBufferBlockCapability = feature_manager->GetCapabilities().contains( spv::Capability::StorageUniformBufferBlock16); const auto* decoration_mgr = instruction->context()->get_decoration_mgr(); bool found16bitType = false; DFSWhile(instruction, [decoration_mgr, hasBufferBlockCapability, &found16bitType](const Instruction* item) { if (found16bitType) { return false; } if (hasBufferBlockCapability && decoration_mgr->HasDecoration(item->result_id(), spv::Decoration::BufferBlock)) { return false; } if (is16bitType(item)) { found16bitType = true; return false; } return true; }); return found16bitType ? std::optional(spv::Capability::StorageUniform16) : std::nullopt; } static std::optional Handler_OpTypeInt_Int16( const Instruction* instruction) { assert(instruction->opcode() == spv::Op::OpTypeInt && "This handler only support OpTypeInt opcodes."); const uint32_t size = instruction->GetSingleWordInOperand(kOpTypeIntSizeIndex); return size == 16 ? std::optional(spv::Capability::Int16) : std::nullopt; } static std::optional Handler_OpTypeInt_Int64( const Instruction* instruction) { assert(instruction->opcode() == spv::Op::OpTypeInt && "This handler only support OpTypeInt opcodes."); const uint32_t size = instruction->GetSingleWordInOperand(kOpTypeIntSizeIndex); return size == 64 ? std::optional(spv::Capability::Int64) : std::nullopt; } static std::optional Handler_OpTypeImage_ImageMSArray( const Instruction* instruction) { assert(instruction->opcode() == spv::Op::OpTypeImage && "This handler only support OpTypeImage opcodes."); const uint32_t arrayed = instruction->GetSingleWordInOperand(kOpTypeImageArrayedIndex); const uint32_t ms = instruction->GetSingleWordInOperand(kOpTypeImageMSIndex); const uint32_t sampled = instruction->GetSingleWordInOperand(kOpTypeImageSampledIndex); return arrayed == 1 && sampled == 2 && ms == 1 ? std::optional(spv::Capability::ImageMSArray) : std::nullopt; } static std::optional Handler_OpImageRead_StorageImageReadWithoutFormat( const Instruction* instruction) { assert(instruction->opcode() == spv::Op::OpImageRead && "This handler only support OpImageRead opcodes."); const auto* def_use_mgr = instruction->context()->get_def_use_mgr(); const uint32_t image_index = instruction->GetSingleWordInOperand(kOpImageReadImageIndex); const uint32_t type_index = def_use_mgr->GetDef(image_index)->type_id(); const Instruction* type = def_use_mgr->GetDef(type_index); const uint32_t dim = type->GetSingleWordInOperand(kOpTypeImageDimIndex); const uint32_t format = type->GetSingleWordInOperand(kOpTypeImageFormatIndex); // If the Image Format is Unknown and Dim is SubpassData, // StorageImageReadWithoutFormat is required. const bool is_unknown = spv::ImageFormat(format) == spv::ImageFormat::Unknown; const bool requires_capability_for_unknown = spv::Dim(dim) != spv::Dim::SubpassData; return is_unknown && requires_capability_for_unknown ? std::optional(spv::Capability::StorageImageReadWithoutFormat) : std::nullopt; } static std::optional Handler_OpImageWrite_StorageImageWriteWithoutFormat( const Instruction* instruction) { assert(instruction->opcode() == spv::Op::OpImageWrite && "This handler only support OpImageWrite opcodes."); const auto* def_use_mgr = instruction->context()->get_def_use_mgr(); const uint32_t image_index = instruction->GetSingleWordInOperand(kOpImageWriteImageIndex); const uint32_t type_index = def_use_mgr->GetDef(image_index)->type_id(); // If the Image Format is Unknown, StorageImageWriteWithoutFormat is required. const Instruction* type = def_use_mgr->GetDef(type_index); const uint32_t format = type->GetSingleWordInOperand(kOpTypeImageFormatIndex); const bool is_unknown = spv::ImageFormat(format) == spv::ImageFormat::Unknown; return is_unknown ? std::optional(spv::Capability::StorageImageWriteWithoutFormat) : std::nullopt; } static std::optional Handler_OpImageSparseRead_StorageImageReadWithoutFormat( const Instruction* instruction) { assert(instruction->opcode() == spv::Op::OpImageSparseRead && "This handler only support OpImageSparseRead opcodes."); const auto* def_use_mgr = instruction->context()->get_def_use_mgr(); const uint32_t image_index = instruction->GetSingleWordInOperand(kOpImageSparseReadImageIndex); const uint32_t type_index = def_use_mgr->GetDef(image_index)->type_id(); const Instruction* type = def_use_mgr->GetDef(type_index); const uint32_t format = type->GetSingleWordInOperand(kOpTypeImageFormatIndex); return spv::ImageFormat(format) == spv::ImageFormat::Unknown ? std::optional(spv::Capability::StorageImageReadWithoutFormat) : std::nullopt; } // Opcode of interest to determine capabilities requirements. constexpr std::array, 13> kOpcodeHandlers{{ // clang-format off {spv::Op::OpImageRead, Handler_OpImageRead_StorageImageReadWithoutFormat}, {spv::Op::OpImageWrite, Handler_OpImageWrite_StorageImageWriteWithoutFormat}, {spv::Op::OpImageSparseRead, Handler_OpImageSparseRead_StorageImageReadWithoutFormat}, {spv::Op::OpTypeFloat, Handler_OpTypeFloat_Float16 }, {spv::Op::OpTypeFloat, Handler_OpTypeFloat_Float64 }, {spv::Op::OpTypeImage, Handler_OpTypeImage_ImageMSArray}, {spv::Op::OpTypeInt, Handler_OpTypeInt_Int16 }, {spv::Op::OpTypeInt, Handler_OpTypeInt_Int64 }, {spv::Op::OpTypePointer, Handler_OpTypePointer_StorageInputOutput16}, {spv::Op::OpTypePointer, Handler_OpTypePointer_StoragePushConstant16}, {spv::Op::OpTypePointer, Handler_OpTypePointer_StorageUniform16}, {spv::Op::OpTypePointer, Handler_OpTypePointer_StorageUniform16}, {spv::Op::OpTypePointer, Handler_OpTypePointer_StorageUniformBufferBlock16}, // clang-format on }}; // ============== End opcode handler implementations. ======================= namespace { ExtensionSet getExtensionsRelatedTo(const CapabilitySet& capabilities, const AssemblyGrammar& grammar) { ExtensionSet output; const spv_operand_desc_t* desc = nullptr; for (auto capability : capabilities) { if (SPV_SUCCESS != grammar.lookupOperand(SPV_OPERAND_TYPE_CAPABILITY, static_cast(capability), &desc)) { continue; } for (uint32_t i = 0; i < desc->numExtensions; ++i) { output.insert(desc->extensions[i]); } } return output; } bool hasOpcodeConflictingCapabilities(spv::Op opcode) { switch (opcode) { case spv::Op::OpBeginInvocationInterlockEXT: case spv::Op::OpEndInvocationInterlockEXT: case spv::Op::OpGroupNonUniformIAdd: case spv::Op::OpGroupNonUniformFAdd: case spv::Op::OpGroupNonUniformIMul: case spv::Op::OpGroupNonUniformFMul: case spv::Op::OpGroupNonUniformSMin: case spv::Op::OpGroupNonUniformUMin: case spv::Op::OpGroupNonUniformFMin: case spv::Op::OpGroupNonUniformSMax: case spv::Op::OpGroupNonUniformUMax: case spv::Op::OpGroupNonUniformFMax: case spv::Op::OpGroupNonUniformBitwiseAnd: case spv::Op::OpGroupNonUniformBitwiseOr: case spv::Op::OpGroupNonUniformBitwiseXor: case spv::Op::OpGroupNonUniformLogicalAnd: case spv::Op::OpGroupNonUniformLogicalOr: case spv::Op::OpGroupNonUniformLogicalXor: return true; default: return false; } } } // namespace TrimCapabilitiesPass::TrimCapabilitiesPass() : supportedCapabilities_( TrimCapabilitiesPass::kSupportedCapabilities.cbegin(), TrimCapabilitiesPass::kSupportedCapabilities.cend()), forbiddenCapabilities_( TrimCapabilitiesPass::kForbiddenCapabilities.cbegin(), TrimCapabilitiesPass::kForbiddenCapabilities.cend()), untouchableCapabilities_( TrimCapabilitiesPass::kUntouchableCapabilities.cbegin(), TrimCapabilitiesPass::kUntouchableCapabilities.cend()), opcodeHandlers_(kOpcodeHandlers.cbegin(), kOpcodeHandlers.cend()) {} void TrimCapabilitiesPass::addInstructionRequirementsForOpcode( spv::Op opcode, CapabilitySet* capabilities, ExtensionSet* extensions) const { if (hasOpcodeConflictingCapabilities(opcode)) { return; } const spv_opcode_desc_t* desc = {}; auto result = context()->grammar().lookupOpcode(opcode, &desc); if (result != SPV_SUCCESS) { return; } addSupportedCapabilitiesToSet(desc, capabilities); addSupportedExtensionsToSet(desc, extensions); } void TrimCapabilitiesPass::addInstructionRequirementsForOperand( const Operand& operand, CapabilitySet* capabilities, ExtensionSet* extensions) const { // No supported capability relies on a 2+-word operand. if (operand.words.size() != 1) { return; } // No supported capability relies on a literal string operand or an ID. if (operand.type == SPV_OPERAND_TYPE_LITERAL_STRING || operand.type == SPV_OPERAND_TYPE_ID || operand.type == SPV_OPERAND_TYPE_RESULT_ID) { return; } // If the Vulkan memory model is declared and any instruction uses Device // scope, the VulkanMemoryModelDeviceScope capability must be declared. This // rule cannot be covered by the grammar, so must be checked explicitly. if (operand.type == SPV_OPERAND_TYPE_SCOPE_ID) { const Instruction* memory_model = context()->GetMemoryModel(); if (memory_model && memory_model->GetSingleWordInOperand(1u) == uint32_t(spv::MemoryModel::Vulkan)) { capabilities->insert(spv::Capability::VulkanMemoryModelDeviceScope); } } // case 1: Operand is a single value, can directly lookup. if (!spvOperandIsConcreteMask(operand.type)) { const spv_operand_desc_t* desc = {}; auto result = context()->grammar().lookupOperand(operand.type, operand.words[0], &desc); if (result != SPV_SUCCESS) { return; } addSupportedCapabilitiesToSet(desc, capabilities); addSupportedExtensionsToSet(desc, extensions); return; } // case 2: operand can be a bitmask, we need to decompose the lookup. for (uint32_t i = 0; i < 32; i++) { const uint32_t mask = (1 << i) & operand.words[0]; if (!mask) { continue; } const spv_operand_desc_t* desc = {}; auto result = context()->grammar().lookupOperand(operand.type, mask, &desc); if (result != SPV_SUCCESS) { continue; } addSupportedCapabilitiesToSet(desc, capabilities); addSupportedExtensionsToSet(desc, extensions); } } void TrimCapabilitiesPass::addInstructionRequirementsForExtInst( Instruction* instruction, CapabilitySet* capabilities) const { assert(instruction->opcode() == spv::Op::OpExtInst && "addInstructionRequirementsForExtInst must be passed an OpExtInst " "instruction"); const auto* def_use_mgr = context()->get_def_use_mgr(); const Instruction* extInstImport = def_use_mgr->GetDef( instruction->GetSingleWordInOperand(kOpExtInstSetInIndex)); uint32_t extInstruction = instruction->GetSingleWordInOperand(kOpExtInstInstructionInIndex); const Operand& extInstSet = extInstImport->GetInOperand(kOpExtInstImportNameInIndex); spv_ext_inst_type_t instructionSet = spvExtInstImportTypeGet(extInstSet.AsString().c_str()); spv_ext_inst_desc desc = {}; auto result = context()->grammar().lookupExtInst(instructionSet, extInstruction, &desc); if (result != SPV_SUCCESS) { return; } addSupportedCapabilitiesToSet(desc, capabilities); } void TrimCapabilitiesPass::addInstructionRequirements( Instruction* instruction, CapabilitySet* capabilities, ExtensionSet* extensions) const { // Ignoring OpCapability and OpExtension instructions. if (instruction->opcode() == spv::Op::OpCapability || instruction->opcode() == spv::Op::OpExtension) { return; } if (instruction->opcode() == spv::Op::OpExtInst) { addInstructionRequirementsForExtInst(instruction, capabilities); } else { addInstructionRequirementsForOpcode(instruction->opcode(), capabilities, extensions); } // Second case: one of the opcode operand is gated by a capability. const uint32_t operandCount = instruction->NumOperands(); for (uint32_t i = 0; i < operandCount; i++) { addInstructionRequirementsForOperand(instruction->GetOperand(i), capabilities, extensions); } // Last case: some complex logic needs to be run to determine capabilities. auto[begin, end] = opcodeHandlers_.equal_range(instruction->opcode()); for (auto it = begin; it != end; it++) { const OpcodeHandler handler = it->second; auto result = handler(instruction); if (!result.has_value()) { continue; } capabilities->insert(*result); } } void TrimCapabilitiesPass::AddExtensionsForOperand( const spv_operand_type_t type, const uint32_t value, ExtensionSet* extensions) const { const spv_operand_desc_t* desc = nullptr; spv_result_t result = context()->grammar().lookupOperand(type, value, &desc); if (result != SPV_SUCCESS) { return; } addSupportedExtensionsToSet(desc, extensions); } std::pair TrimCapabilitiesPass::DetermineRequiredCapabilitiesAndExtensions() const { CapabilitySet required_capabilities; ExtensionSet required_extensions; get_module()->ForEachInst([&](Instruction* instruction) { addInstructionRequirements(instruction, &required_capabilities, &required_extensions); }); for (auto capability : required_capabilities) { AddExtensionsForOperand(SPV_OPERAND_TYPE_CAPABILITY, static_cast(capability), &required_extensions); } #if !defined(NDEBUG) // Debug only. We check the outputted required capabilities against the // supported capabilities list. The supported capabilities list is useful for // API users to quickly determine if they can use the pass or not. But this // list has to remain up-to-date with the pass code. If we can detect a // capability as required, but it's not listed, it means the list is // out-of-sync. This method is not ideal, but should cover most cases. { for (auto capability : required_capabilities) { assert(supportedCapabilities_.contains(capability) && "Module is using a capability that is not listed as supported."); } } #endif return std::make_pair(std::move(required_capabilities), std::move(required_extensions)); } Pass::Status TrimCapabilitiesPass::TrimUnrequiredCapabilities( const CapabilitySet& required_capabilities) const { const FeatureManager* feature_manager = context()->get_feature_mgr(); CapabilitySet capabilities_to_trim; for (auto capability : feature_manager->GetCapabilities()) { // Some capabilities cannot be safely removed. Leaving them untouched. if (untouchableCapabilities_.contains(capability)) { continue; } // If the capability is unsupported, don't trim it. if (!supportedCapabilities_.contains(capability)) { continue; } if (required_capabilities.contains(capability)) { continue; } capabilities_to_trim.insert(capability); } for (auto capability : capabilities_to_trim) { context()->RemoveCapability(capability); } return capabilities_to_trim.size() == 0 ? Pass::Status::SuccessWithoutChange : Pass::Status::SuccessWithChange; } Pass::Status TrimCapabilitiesPass::TrimUnrequiredExtensions( const ExtensionSet& required_extensions) const { const auto supported_extensions = getExtensionsRelatedTo(supportedCapabilities_, context()->grammar()); bool modified_module = false; for (auto extension : supported_extensions) { if (required_extensions.contains(extension)) { continue; } if (context()->RemoveExtension(extension)) { modified_module = true; } } return modified_module ? Pass::Status::SuccessWithChange : Pass::Status::SuccessWithoutChange; } bool TrimCapabilitiesPass::HasForbiddenCapabilities() const { // EnumSet.HasAnyOf returns `true` if the given set is empty. if (forbiddenCapabilities_.size() == 0) { return false; } const auto& capabilities = context()->get_feature_mgr()->GetCapabilities(); return capabilities.HasAnyOf(forbiddenCapabilities_); } Pass::Status TrimCapabilitiesPass::Process() { if (HasForbiddenCapabilities()) { return Status::SuccessWithoutChange; } auto[required_capabilities, required_extensions] = DetermineRequiredCapabilitiesAndExtensions(); Pass::Status capStatus = TrimUnrequiredCapabilities(required_capabilities); Pass::Status extStatus = TrimUnrequiredExtensions(required_extensions); return capStatus == Pass::Status::SuccessWithChange || extStatus == Pass::Status::SuccessWithChange ? Pass::Status::SuccessWithChange : Pass::Status::SuccessWithoutChange; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/trim_capabilities_pass.h000066400000000000000000000210301475742701700255120ustar00rootroot00000000000000// Copyright (c) 2023 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_TRIM_CAPABILITIES_PASS_H_ #define SOURCE_OPT_TRIM_CAPABILITIES_PASS_H_ #include #include #include #include #include #include #include "source/enum_set.h" #include "source/extensions.h" #include "source/opt/ir_context.h" #include "source/opt/module.h" #include "source/opt/pass.h" #include "source/spirv_target_env.h" namespace spvtools { namespace opt { // This is required for NDK build. The unordered_set/unordered_map // implementation don't work with class enums. struct ClassEnumHash { std::size_t operator()(spv::Capability value) const { using StoringType = typename std::underlying_type_t; return std::hash{}(static_cast(value)); } std::size_t operator()(spv::Op value) const { using StoringType = typename std::underlying_type_t; return std::hash{}(static_cast(value)); } }; // An opcode handler is a function which, given an instruction, returns either // the required capability, or nothing. // Each handler checks one case for a capability requirement. // // Example: // - `OpTypeImage` can have operand `A` operand which requires capability 1 // - `OpTypeImage` can also have operand `B` which requires capability 2. // -> We have 2 handlers: `Handler_OpTypeImage_1` and // `Handler_OpTypeImage_2`. using OpcodeHandler = std::optional (*)(const Instruction* instruction); // This pass tried to remove superfluous capabilities declared in the module. // - If all the capabilities listed by an extension are removed, the extension // is also trimmed. // - If the module countains any capability listed in `kForbiddenCapabilities`, // the module is left untouched. // - No capabilities listed in `kUntouchableCapabilities` are trimmed, even when // not used. // - Only capabilitied listed in `kSupportedCapabilities` are supported. // - If the module contains unsupported capabilities, results might be // incorrect. class TrimCapabilitiesPass : public Pass { private: // All the capabilities supported by this optimization pass. If your module // contains unsupported instruction, the pass could yield bad results. static constexpr std::array kSupportedCapabilities{ // clang-format off spv::Capability::ComputeDerivativeGroupLinearKHR, spv::Capability::ComputeDerivativeGroupQuadsKHR, spv::Capability::Float16, spv::Capability::Float64, spv::Capability::FragmentShaderPixelInterlockEXT, spv::Capability::FragmentShaderSampleInterlockEXT, spv::Capability::FragmentShaderShadingRateInterlockEXT, spv::Capability::GroupNonUniform, spv::Capability::GroupNonUniformArithmetic, spv::Capability::GroupNonUniformClustered, spv::Capability::GroupNonUniformPartitionedNV, spv::Capability::GroupNonUniformVote, spv::Capability::Groups, spv::Capability::ImageMSArray, spv::Capability::Int16, spv::Capability::Int64, spv::Capability::InterpolationFunction, spv::Capability::Linkage, spv::Capability::MinLod, spv::Capability::PhysicalStorageBufferAddresses, spv::Capability::RayQueryKHR, spv::Capability::RayTracingKHR, spv::Capability::RayTraversalPrimitiveCullingKHR, spv::Capability::Shader, spv::Capability::ShaderClockKHR, spv::Capability::StorageImageReadWithoutFormat, spv::Capability::StorageImageWriteWithoutFormat, spv::Capability::StorageInputOutput16, spv::Capability::StoragePushConstant16, spv::Capability::StorageUniform16, spv::Capability::StorageUniformBufferBlock16, spv::Capability::VulkanMemoryModelDeviceScope, // clang-format on }; // Those capabilities disable all transformation of the module. static constexpr std::array kForbiddenCapabilities{ spv::Capability::Linkage, }; // Those capabilities are never removed from a module because we cannot // guess from the SPIR-V only if they are required or not. static constexpr std::array kUntouchableCapabilities{ spv::Capability::Shader, }; public: TrimCapabilitiesPass(); TrimCapabilitiesPass(const TrimCapabilitiesPass&) = delete; TrimCapabilitiesPass(TrimCapabilitiesPass&&) = delete; private: // Inserts every capability listed by `descriptor` this pass supports into // `output`. Expects a Descriptor like `spv_opcode_desc_t` or // `spv_operand_desc_t`. template inline void addSupportedCapabilitiesToSet(const Descriptor* const descriptor, CapabilitySet* output) const { const uint32_t capabilityCount = descriptor->numCapabilities; for (uint32_t i = 0; i < capabilityCount; ++i) { const auto capability = descriptor->capabilities[i]; if (supportedCapabilities_.contains(capability)) { output->insert(capability); } } } // Inserts every extension listed by `descriptor` required by the module into // `output`. Expects a Descriptor like `spv_opcode_desc_t` or // `spv_operand_desc_t`. template inline void addSupportedExtensionsToSet(const Descriptor* const descriptor, ExtensionSet* output) const { if (descriptor->minVersion <= spvVersionForTargetEnv(context()->GetTargetEnv())) { return; } output->insert(descriptor->extensions, descriptor->extensions + descriptor->numExtensions); } void addInstructionRequirementsForOpcode(spv::Op opcode, CapabilitySet* capabilities, ExtensionSet* extensions) const; void addInstructionRequirementsForOperand(const Operand& operand, CapabilitySet* capabilities, ExtensionSet* extensions) const; void addInstructionRequirementsForExtInst(Instruction* instruction, CapabilitySet* capabilities) const; // Given an `instruction`, determines the capabilities it requires, and output // them in `capabilities`. The returned capabilities form a subset of // kSupportedCapabilities. void addInstructionRequirements(Instruction* instruction, CapabilitySet* capabilities, ExtensionSet* extensions) const; // Given an operand `type` and `value`, adds the extensions it would require // to `extensions`. void AddExtensionsForOperand(const spv_operand_type_t type, const uint32_t value, ExtensionSet* extensions) const; // Returns the list of required capabilities and extensions for the module. // The returned capabilities form a subset of kSupportedCapabilities. std::pair DetermineRequiredCapabilitiesAndExtensions() const; // Trims capabilities not listed in `required_capabilities` if possible. // Returns whether or not the module was modified. Pass::Status TrimUnrequiredCapabilities( const CapabilitySet& required_capabilities) const; // Trims extensions not listed in `required_extensions` if supported by this // pass. An extensions is considered supported as soon as one capability this // pass support requires it. Pass::Status TrimUnrequiredExtensions( const ExtensionSet& required_extensions) const; // Returns if the analyzed module contains any forbidden capability. bool HasForbiddenCapabilities() const; public: const char* name() const override { return "trim-capabilities"; } Status Process() override; private: const CapabilitySet supportedCapabilities_; const CapabilitySet forbiddenCapabilities_; const CapabilitySet untouchableCapabilities_; const std::unordered_multimap opcodeHandlers_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_TRIM_CAPABILITIES_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/type_manager.cpp000066400000000000000000001272011475742701700240150ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // Modifications Copyright (C) 2024 Advanced Micro Devices, Inc. All rights // reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/type_manager.h" #include #include #include #include #include "source/opt/ir_context.h" #include "source/opt/log.h" #include "source/opt/reflect.h" #include "source/util/make_unique.h" #include "source/util/string_utils.h" namespace spvtools { namespace opt { namespace analysis { namespace { constexpr int kSpvTypePointerStorageClass = 1; constexpr int kSpvTypePointerTypeIdInIdx = 2; } // namespace TypeManager::TypeManager(const MessageConsumer& consumer, IRContext* c) : consumer_(consumer), context_(c) { AnalyzeTypes(*c->module()); } Type* TypeManager::GetType(uint32_t id) const { auto iter = id_to_type_.find(id); if (iter != id_to_type_.end()) return (*iter).second; iter = id_to_incomplete_type_.find(id); if (iter != id_to_incomplete_type_.end()) return (*iter).second; return nullptr; } std::pair> TypeManager::GetTypeAndPointerType( uint32_t id, spv::StorageClass sc) const { Type* type = GetType(id); if (type) { return std::make_pair(type, MakeUnique(type, sc)); } else { return std::make_pair(type, std::unique_ptr()); } } uint32_t TypeManager::GetId(const Type* type) const { auto iter = type_to_id_.find(type); if (iter != type_to_id_.end()) { return (*iter).second; } return 0; } void TypeManager::AnalyzeTypes(const Module& module) { // First pass through the constants, as some will be needed when traversing // the types in the next pass. for (const auto* inst : module.GetConstants()) { id_to_constant_inst_[inst->result_id()] = inst; } // Then pass through the types. Any types that reference a forward pointer // (directly or indirectly) are incomplete, and are added to incomplete types. for (const auto* inst : module.GetTypes()) { RecordIfTypeDefinition(*inst); } if (incomplete_types_.empty()) { return; } // Get the real pointer definition for all of the forward pointers. for (auto& type : incomplete_types_) { if (type.type()->kind() == Type::kForwardPointer) { auto* t = GetType(type.id()); assert(t); auto* p = t->AsPointer(); assert(p); type.type()->AsForwardPointer()->SetTargetPointer(p); } } // Replaces the references to the forward pointers in the incomplete types. for (auto& type : incomplete_types_) { ReplaceForwardPointers(type.type()); } // Delete the forward pointers now that they are not referenced anymore. for (auto& type : incomplete_types_) { if (type.type()->kind() == Type::kForwardPointer) { type.ResetType(nullptr); } } // Compare the complete types looking for types that are the same. If there // are two types that are the same, then replace one with the other. // Continue until we reach a fixed point. bool restart = true; while (restart) { restart = false; for (auto it1 = incomplete_types_.begin(); it1 != incomplete_types_.end(); ++it1) { uint32_t id1 = it1->id(); Type* type1 = it1->type(); if (!type1) { continue; } for (auto it2 = it1 + 1; it2 != incomplete_types_.end(); ++it2) { uint32_t id2 = it2->id(); (void)(id2 + id1); Type* type2 = it2->type(); if (!type2) { continue; } if (type1->IsSame(type2)) { ReplaceType(type1, type2); it2->ResetType(nullptr); id_to_incomplete_type_[it2->id()] = type1; restart = true; } } } } // Add the remaining incomplete types to the type pool. for (auto& type : incomplete_types_) { if (type.type() && !type.type()->AsForwardPointer()) { std::vector decorations = context()->get_decoration_mgr()->GetDecorationsFor(type.id(), true); for (auto dec : decorations) { AttachDecoration(*dec, type.type()); } auto pair = type_pool_.insert(type.ReleaseType()); id_to_type_[type.id()] = pair.first->get(); type_to_id_[pair.first->get()] = type.id(); id_to_incomplete_type_.erase(type.id()); } } // Add a mapping for any ids that whose original type was replaced by an // equivalent type. for (auto& type : id_to_incomplete_type_) { id_to_type_[type.first] = type.second; } #ifndef NDEBUG // Check if the type pool contains two types that are the same. This // is an indication that the hashing and comparison are wrong. It // will cause a problem if the type pool gets resized and everything // is rehashed. for (auto& i : type_pool_) { for (auto& j : type_pool_) { Type* ti = i.get(); Type* tj = j.get(); assert((ti == tj || !ti->IsSame(tj)) && "Type pool contains two types that are the same."); } } #endif } void TypeManager::RemoveId(uint32_t id) { auto iter = id_to_type_.find(id); if (iter == id_to_type_.end()) return; auto& type = iter->second; if (!type->IsUniqueType()) { auto tIter = type_to_id_.find(type); if (tIter != type_to_id_.end() && tIter->second == id) { // |type| currently maps to |id|. // Search for an equivalent type to re-map. bool found = false; for (auto& pair : id_to_type_) { if (pair.first != id && *pair.second == *type) { // Equivalent ambiguous type, re-map type. type_to_id_.erase(type); type_to_id_[pair.second] = pair.first; found = true; break; } } // No equivalent ambiguous type, remove mapping. if (!found) type_to_id_.erase(tIter); } } else { // Unique type, so just erase the entry. type_to_id_.erase(type); } // Erase the entry for |id|. id_to_type_.erase(iter); } uint32_t TypeManager::GetTypeInstruction(const Type* type) { uint32_t id = GetId(type); if (id != 0) return id; std::unique_ptr typeInst; // TODO(1841): Handle id overflow. id = context()->TakeNextId(); if (id == 0) { return 0; } RegisterType(id, *type); switch (type->kind()) { #define DefineParameterlessCase(kind) \ case Type::k##kind: \ typeInst = MakeUnique(context(), spv::Op::OpType##kind, 0, \ id, std::initializer_list{}); \ break DefineParameterlessCase(Void); DefineParameterlessCase(Bool); DefineParameterlessCase(Sampler); DefineParameterlessCase(Event); DefineParameterlessCase(DeviceEvent); DefineParameterlessCase(ReserveId); DefineParameterlessCase(Queue); DefineParameterlessCase(PipeStorage); DefineParameterlessCase(NamedBarrier); DefineParameterlessCase(AccelerationStructureNV); DefineParameterlessCase(RayQueryKHR); DefineParameterlessCase(HitObjectNV); #undef DefineParameterlessCase case Type::kInteger: typeInst = MakeUnique( context(), spv::Op::OpTypeInt, 0, id, std::initializer_list{ {SPV_OPERAND_TYPE_LITERAL_INTEGER, {type->AsInteger()->width()}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {(type->AsInteger()->IsSigned() ? 1u : 0u)}}}); break; case Type::kFloat: // TODO: Handle FP encoding enums once actually used. typeInst = MakeUnique( context(), spv::Op::OpTypeFloat, 0, id, std::initializer_list{ {SPV_OPERAND_TYPE_LITERAL_INTEGER, {type->AsFloat()->width()}}}); break; case Type::kVector: { uint32_t subtype = GetTypeInstruction(type->AsVector()->element_type()); if (subtype == 0) { return 0; } typeInst = MakeUnique(context(), spv::Op::OpTypeVector, 0, id, std::initializer_list{ {SPV_OPERAND_TYPE_ID, {subtype}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {type->AsVector()->element_count()}}}); break; } case Type::kMatrix: { uint32_t subtype = GetTypeInstruction(type->AsMatrix()->element_type()); if (subtype == 0) { return 0; } typeInst = MakeUnique(context(), spv::Op::OpTypeMatrix, 0, id, std::initializer_list{ {SPV_OPERAND_TYPE_ID, {subtype}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {type->AsMatrix()->element_count()}}}); break; } case Type::kImage: { const Image* image = type->AsImage(); uint32_t subtype = GetTypeInstruction(image->sampled_type()); if (subtype == 0) { return 0; } typeInst = MakeUnique( context(), spv::Op::OpTypeImage, 0, id, std::initializer_list{ {SPV_OPERAND_TYPE_ID, {subtype}}, {SPV_OPERAND_TYPE_DIMENSIONALITY, {static_cast(image->dim())}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {image->depth()}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {(image->is_arrayed() ? 1u : 0u)}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {(image->is_multisampled() ? 1u : 0u)}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {image->sampled()}}, {SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT, {static_cast(image->format())}}, {SPV_OPERAND_TYPE_ACCESS_QUALIFIER, {static_cast(image->access_qualifier())}}}); break; } case Type::kSampledImage: { uint32_t subtype = GetTypeInstruction(type->AsSampledImage()->image_type()); if (subtype == 0) { return 0; } typeInst = MakeUnique( context(), spv::Op::OpTypeSampledImage, 0, id, std::initializer_list{{SPV_OPERAND_TYPE_ID, {subtype}}}); break; } case Type::kArray: { uint32_t subtype = GetTypeInstruction(type->AsArray()->element_type()); if (subtype == 0) { return 0; } typeInst = MakeUnique( context(), spv::Op::OpTypeArray, 0, id, std::initializer_list{ {SPV_OPERAND_TYPE_ID, {subtype}}, {SPV_OPERAND_TYPE_ID, {type->AsArray()->LengthId()}}}); break; } case Type::kRuntimeArray: { uint32_t subtype = GetTypeInstruction(type->AsRuntimeArray()->element_type()); if (subtype == 0) { return 0; } typeInst = MakeUnique( context(), spv::Op::OpTypeRuntimeArray, 0, id, std::initializer_list{{SPV_OPERAND_TYPE_ID, {subtype}}}); break; } case Type::kNodePayloadArrayAMDX: { uint32_t subtype = GetTypeInstruction(type->AsNodePayloadArrayAMDX()->element_type()); if (subtype == 0) { return 0; } typeInst = MakeUnique( context(), spv::Op::OpTypeNodePayloadArrayAMDX, 0, id, std::initializer_list{{SPV_OPERAND_TYPE_ID, {subtype}}}); break; } case Type::kStruct: { std::vector ops; const Struct* structTy = type->AsStruct(); for (auto ty : structTy->element_types()) { uint32_t member_type_id = GetTypeInstruction(ty); if (member_type_id == 0) { return 0; } ops.push_back(Operand(SPV_OPERAND_TYPE_ID, {member_type_id})); } typeInst = MakeUnique(context(), spv::Op::OpTypeStruct, 0, id, ops); break; } case Type::kOpaque: { const Opaque* opaque = type->AsOpaque(); // Convert to null-terminated packed UTF-8 string. std::vector words = spvtools::utils::MakeVector(opaque->name()); typeInst = MakeUnique( context(), spv::Op::OpTypeOpaque, 0, id, std::initializer_list{ {SPV_OPERAND_TYPE_LITERAL_STRING, words}}); break; } case Type::kPointer: { const Pointer* pointer = type->AsPointer(); uint32_t subtype = GetTypeInstruction(pointer->pointee_type()); if (subtype == 0) { return 0; } typeInst = MakeUnique( context(), spv::Op::OpTypePointer, 0, id, std::initializer_list{ {SPV_OPERAND_TYPE_STORAGE_CLASS, {static_cast(pointer->storage_class())}}, {SPV_OPERAND_TYPE_ID, {subtype}}}); break; } case Type::kFunction: { std::vector ops; const Function* function = type->AsFunction(); uint32_t return_type_id = GetTypeInstruction(function->return_type()); if (return_type_id == 0) { return 0; } ops.push_back(Operand(SPV_OPERAND_TYPE_ID, {return_type_id})); for (auto ty : function->param_types()) { uint32_t paramater_type_id = GetTypeInstruction(ty); if (paramater_type_id == 0) { return 0; } ops.push_back(Operand(SPV_OPERAND_TYPE_ID, {paramater_type_id})); } typeInst = MakeUnique(context(), spv::Op::OpTypeFunction, 0, id, ops); break; } case Type::kPipe: typeInst = MakeUnique( context(), spv::Op::OpTypePipe, 0, id, std::initializer_list{ {SPV_OPERAND_TYPE_ACCESS_QUALIFIER, {static_cast(type->AsPipe()->access_qualifier())}}}); break; case Type::kForwardPointer: typeInst = MakeUnique( context(), spv::Op::OpTypeForwardPointer, 0, 0, std::initializer_list{ {SPV_OPERAND_TYPE_ID, {type->AsForwardPointer()->target_id()}}, {SPV_OPERAND_TYPE_STORAGE_CLASS, {static_cast( type->AsForwardPointer()->storage_class())}}}); break; case Type::kCooperativeMatrixNV: { auto coop_mat = type->AsCooperativeMatrixNV(); uint32_t const component_type = GetTypeInstruction(coop_mat->component_type()); if (component_type == 0) { return 0; } typeInst = MakeUnique( context(), spv::Op::OpTypeCooperativeMatrixNV, 0, id, std::initializer_list{ {SPV_OPERAND_TYPE_ID, {component_type}}, {SPV_OPERAND_TYPE_SCOPE_ID, {coop_mat->scope_id()}}, {SPV_OPERAND_TYPE_ID, {coop_mat->rows_id()}}, {SPV_OPERAND_TYPE_ID, {coop_mat->columns_id()}}}); break; } case Type::kCooperativeMatrixKHR: { auto coop_mat = type->AsCooperativeMatrixKHR(); uint32_t const component_type = GetTypeInstruction(coop_mat->component_type()); if (component_type == 0) { return 0; } typeInst = MakeUnique( context(), spv::Op::OpTypeCooperativeMatrixKHR, 0, id, std::initializer_list{ {SPV_OPERAND_TYPE_ID, {component_type}}, {SPV_OPERAND_TYPE_SCOPE_ID, {coop_mat->scope_id()}}, {SPV_OPERAND_TYPE_ID, {coop_mat->rows_id()}}, {SPV_OPERAND_TYPE_ID, {coop_mat->columns_id()}}, {SPV_OPERAND_TYPE_ID, {coop_mat->use_id()}}}); break; } case Type::kTensorLayoutNV: { auto tensor_layout = type->AsTensorLayoutNV(); typeInst = MakeUnique( context(), spv::Op::OpTypeTensorLayoutNV, 0, id, std::initializer_list{ {SPV_OPERAND_TYPE_ID, {tensor_layout->dim_id()}}, {SPV_OPERAND_TYPE_ID, {tensor_layout->clamp_mode_id()}}}); break; } case Type::kTensorViewNV: { auto tensor_view = type->AsTensorViewNV(); std::vector operands; operands.push_back(Operand{SPV_OPERAND_TYPE_ID, {tensor_view->dim_id()}}); operands.push_back( Operand{SPV_OPERAND_TYPE_ID, {tensor_view->has_dimensions_id()}}); for (auto p : tensor_view->perm()) { operands.push_back(Operand{SPV_OPERAND_TYPE_ID, {p}}); } typeInst = MakeUnique(context(), spv::Op::OpTypeTensorViewNV, 0, id, operands); break; } case Type::kCooperativeVectorNV: { auto coop_vec = type->AsCooperativeVectorNV(); uint32_t const component_type = GetTypeInstruction(coop_vec->component_type()); if (component_type == 0) { return 0; } typeInst = MakeUnique( context(), spv::Op::OpTypeCooperativeVectorNV, 0, id, std::initializer_list{ {SPV_OPERAND_TYPE_ID, {component_type}}, {SPV_OPERAND_TYPE_ID, {coop_vec->components()}}}); break; } default: assert(false && "Unexpected type"); break; } context()->AddType(std::move(typeInst)); context()->AnalyzeDefUse(&*--context()->types_values_end()); AttachDecorations(id, type); return id; } uint32_t TypeManager::FindPointerToType(uint32_t type_id, spv::StorageClass storage_class) { Type* pointeeTy = GetType(type_id); Pointer pointerTy(pointeeTy, storage_class); Module::inst_iterator type_itr = context()->module()->types_values_begin(); for (; type_itr != context()->module()->types_values_end(); ++type_itr) { const Instruction* type_inst = &*type_itr; if (type_inst->opcode() == spv::Op::OpTypePointer && type_inst->GetSingleWordOperand(kSpvTypePointerTypeIdInIdx) == type_id && spv::StorageClass(type_inst->GetSingleWordOperand( kSpvTypePointerStorageClass)) == storage_class) return type_inst->result_id(); } // Must create the pointer type. uint32_t resultId = context()->TakeNextId(); if (resultId == 0) { return 0; } std::unique_ptr type_inst( new Instruction(context(), spv::Op::OpTypePointer, 0, resultId, {{spv_operand_type_t::SPV_OPERAND_TYPE_STORAGE_CLASS, {uint32_t(storage_class)}}, {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {type_id}}})); context()->AddType(std::move(type_inst)); context()->get_type_mgr()->RegisterType(resultId, pointerTy); return resultId; } void TypeManager::AttachDecorations(uint32_t id, const Type* type) { for (auto vec : type->decorations()) { CreateDecoration(id, vec); } if (const Struct* structTy = type->AsStruct()) { for (auto pair : structTy->element_decorations()) { uint32_t element = pair.first; for (auto vec : pair.second) { CreateDecoration(id, vec, /* is_member */ true, element); } } } } void TypeManager::CreateDecoration(uint32_t target, const std::vector& decoration, bool is_member, uint32_t element) { std::vector ops; ops.push_back(Operand(SPV_OPERAND_TYPE_ID, {target})); if (is_member) { ops.push_back(Operand(SPV_OPERAND_TYPE_LITERAL_INTEGER, {element})); } ops.push_back(Operand(SPV_OPERAND_TYPE_DECORATION, {decoration[0]})); for (size_t i = 1; i < decoration.size(); ++i) { ops.push_back(Operand(SPV_OPERAND_TYPE_LITERAL_INTEGER, {decoration[i]})); } context()->AddAnnotationInst(MakeUnique( context(), (is_member ? spv::Op::OpMemberDecorate : spv::Op::OpDecorate), 0, 0, ops)); Instruction* inst = &*--context()->annotation_end(); context()->get_def_use_mgr()->AnalyzeInstUse(inst); } Type* TypeManager::RebuildType(uint32_t type_id, const Type& type) { assert(type_id != 0); // The comparison and hash on the type pool will avoid inserting the rebuilt // type if an equivalent type already exists. The rebuilt type will be deleted // when it goes out of scope at the end of the function in that case. Repeated // insertions of the same Type will, at most, keep one corresponding object in // the type pool. std::unique_ptr rebuilt_ty; // If |type_id| is already present in the type pool, return the existing type. // This saves extra work in the type builder and prevents running into // circular issues (https://github.com/KhronosGroup/SPIRV-Tools/issues/5623). Type* pool_ty = GetType(type_id); if (pool_ty != nullptr) { return pool_ty; } switch (type.kind()) { #define DefineNoSubtypeCase(kind) \ case Type::k##kind: \ rebuilt_ty.reset(type.Clone().release()); \ return type_pool_.insert(std::move(rebuilt_ty)).first->get() DefineNoSubtypeCase(Void); DefineNoSubtypeCase(Bool); DefineNoSubtypeCase(Integer); DefineNoSubtypeCase(Float); DefineNoSubtypeCase(Sampler); DefineNoSubtypeCase(Opaque); DefineNoSubtypeCase(Event); DefineNoSubtypeCase(DeviceEvent); DefineNoSubtypeCase(ReserveId); DefineNoSubtypeCase(Queue); DefineNoSubtypeCase(Pipe); DefineNoSubtypeCase(PipeStorage); DefineNoSubtypeCase(NamedBarrier); DefineNoSubtypeCase(AccelerationStructureNV); DefineNoSubtypeCase(RayQueryKHR); DefineNoSubtypeCase(HitObjectNV); #undef DefineNoSubtypeCase case Type::kVector: { const Vector* vec_ty = type.AsVector(); const Type* ele_ty = vec_ty->element_type(); rebuilt_ty = MakeUnique(RebuildType(GetId(ele_ty), *ele_ty), vec_ty->element_count()); break; } case Type::kMatrix: { const Matrix* mat_ty = type.AsMatrix(); const Type* ele_ty = mat_ty->element_type(); rebuilt_ty = MakeUnique(RebuildType(GetId(ele_ty), *ele_ty), mat_ty->element_count()); break; } case Type::kImage: { const Image* image_ty = type.AsImage(); const Type* ele_ty = image_ty->sampled_type(); rebuilt_ty = MakeUnique( RebuildType(GetId(ele_ty), *ele_ty), image_ty->dim(), image_ty->depth(), image_ty->is_arrayed(), image_ty->is_multisampled(), image_ty->sampled(), image_ty->format(), image_ty->access_qualifier()); break; } case Type::kSampledImage: { const SampledImage* image_ty = type.AsSampledImage(); const Type* ele_ty = image_ty->image_type(); rebuilt_ty = MakeUnique(RebuildType(GetId(ele_ty), *ele_ty)); break; } case Type::kArray: { const Array* array_ty = type.AsArray(); const Type* ele_ty = array_ty->element_type(); rebuilt_ty = MakeUnique(RebuildType(GetId(ele_ty), *ele_ty), array_ty->length_info()); break; } case Type::kRuntimeArray: { const RuntimeArray* array_ty = type.AsRuntimeArray(); const Type* ele_ty = array_ty->element_type(); rebuilt_ty = MakeUnique(RebuildType(GetId(ele_ty), *ele_ty)); break; } case Type::kNodePayloadArrayAMDX: { const NodePayloadArrayAMDX* array_ty = type.AsNodePayloadArrayAMDX(); const Type* ele_ty = array_ty->element_type(); rebuilt_ty = MakeUnique(RebuildType(GetId(ele_ty), *ele_ty)); break; } case Type::kStruct: { const Struct* struct_ty = type.AsStruct(); std::vector subtypes; subtypes.reserve(struct_ty->element_types().size()); for (const auto* ele_ty : struct_ty->element_types()) { subtypes.push_back(RebuildType(GetId(ele_ty), *ele_ty)); } rebuilt_ty = MakeUnique(subtypes); Struct* rebuilt_struct = rebuilt_ty->AsStruct(); for (auto pair : struct_ty->element_decorations()) { uint32_t index = pair.first; for (const auto& dec : pair.second) { // Explicit copy intended. std::vector copy(dec); rebuilt_struct->AddMemberDecoration(index, std::move(copy)); } } break; } case Type::kPointer: { const Pointer* pointer_ty = type.AsPointer(); const Type* ele_ty = pointer_ty->pointee_type(); rebuilt_ty = MakeUnique(RebuildType(GetId(ele_ty), *ele_ty), pointer_ty->storage_class()); break; } case Type::kFunction: { const Function* function_ty = type.AsFunction(); const Type* ret_ty = function_ty->return_type(); std::vector param_types; param_types.reserve(function_ty->param_types().size()); for (const auto* param_ty : function_ty->param_types()) { param_types.push_back(RebuildType(GetId(param_ty), *param_ty)); } rebuilt_ty = MakeUnique(RebuildType(GetId(ret_ty), *ret_ty), param_types); break; } case Type::kForwardPointer: { const ForwardPointer* forward_ptr_ty = type.AsForwardPointer(); rebuilt_ty = MakeUnique(forward_ptr_ty->target_id(), forward_ptr_ty->storage_class()); const Pointer* target_ptr = forward_ptr_ty->target_pointer(); if (target_ptr) { rebuilt_ty->AsForwardPointer()->SetTargetPointer( RebuildType(GetId(target_ptr), *target_ptr)->AsPointer()); } break; } case Type::kCooperativeMatrixNV: { const CooperativeMatrixNV* cm_type = type.AsCooperativeMatrixNV(); const Type* component_type = cm_type->component_type(); rebuilt_ty = MakeUnique( RebuildType(GetId(component_type), *component_type), cm_type->scope_id(), cm_type->rows_id(), cm_type->columns_id()); break; } case Type::kCooperativeMatrixKHR: { const CooperativeMatrixKHR* cm_type = type.AsCooperativeMatrixKHR(); const Type* component_type = cm_type->component_type(); rebuilt_ty = MakeUnique( RebuildType(GetId(component_type), *component_type), cm_type->scope_id(), cm_type->rows_id(), cm_type->columns_id(), cm_type->use_id()); break; } case Type::kTensorLayoutNV: { const TensorLayoutNV* tl_type = type.AsTensorLayoutNV(); rebuilt_ty = MakeUnique(tl_type->dim_id(), tl_type->clamp_mode_id()); break; } case Type::kTensorViewNV: { const TensorViewNV* tv_type = type.AsTensorViewNV(); rebuilt_ty = MakeUnique( tv_type->dim_id(), tv_type->has_dimensions_id(), tv_type->perm()); break; } case Type::kCooperativeVectorNV: { const CooperativeVectorNV* cv_type = type.AsCooperativeVectorNV(); const Type* component_type = cv_type->component_type(); rebuilt_ty = MakeUnique( RebuildType(GetId(component_type), *component_type), cv_type->components()); break; } default: assert(false && "Unhandled type"); return nullptr; } for (const auto& dec : type.decorations()) { // Explicit copy intended. std::vector copy(dec); rebuilt_ty->AddDecoration(std::move(copy)); } return type_pool_.insert(std::move(rebuilt_ty)).first->get(); } void TypeManager::RegisterType(uint32_t id, const Type& type) { // Rebuild |type| so it and all its constituent types are owned by the type // pool. Type* rebuilt = RebuildType(id, type); assert(rebuilt->IsSame(&type)); id_to_type_[id] = rebuilt; if (GetId(rebuilt) == 0) { type_to_id_[rebuilt] = id; } } Type* TypeManager::GetRegisteredType(const Type* type) { uint32_t id = GetTypeInstruction(type); if (id == 0) { return nullptr; } return GetType(id); } Type* TypeManager::RecordIfTypeDefinition(const Instruction& inst) { if (!IsTypeInst(inst.opcode())) return nullptr; Type* type = nullptr; switch (inst.opcode()) { case spv::Op::OpTypeVoid: type = new Void(); break; case spv::Op::OpTypeBool: type = new Bool(); break; case spv::Op::OpTypeInt: type = new Integer(inst.GetSingleWordInOperand(0), inst.GetSingleWordInOperand(1)); break; case spv::Op::OpTypeFloat: type = new Float(inst.GetSingleWordInOperand(0)); break; case spv::Op::OpTypeVector: type = new Vector(GetType(inst.GetSingleWordInOperand(0)), inst.GetSingleWordInOperand(1)); break; case spv::Op::OpTypeMatrix: type = new Matrix(GetType(inst.GetSingleWordInOperand(0)), inst.GetSingleWordInOperand(1)); break; case spv::Op::OpTypeImage: { const spv::AccessQualifier access = inst.NumInOperands() < 8 ? spv::AccessQualifier::ReadOnly : static_cast( inst.GetSingleWordInOperand(7)); type = new Image( GetType(inst.GetSingleWordInOperand(0)), static_cast(inst.GetSingleWordInOperand(1)), inst.GetSingleWordInOperand(2), inst.GetSingleWordInOperand(3) == 1, inst.GetSingleWordInOperand(4) == 1, inst.GetSingleWordInOperand(5), static_cast(inst.GetSingleWordInOperand(6)), access); } break; case spv::Op::OpTypeSampler: type = new Sampler(); break; case spv::Op::OpTypeSampledImage: type = new SampledImage(GetType(inst.GetSingleWordInOperand(0))); break; case spv::Op::OpTypeArray: { const uint32_t length_id = inst.GetSingleWordInOperand(1); const Instruction* length_constant_inst = id_to_constant_inst_[length_id]; assert(length_constant_inst); // How will we distinguish one length value from another? // Determine extra words required to distinguish this array length // from another. std::vector extra_words{Array::LengthInfo::kDefiningId}; // If it is a specialised constant, retrieve its SpecId. // Only OpSpecConstant has a SpecId. uint32_t spec_id = 0u; bool has_spec_id = false; if (length_constant_inst->opcode() == spv::Op::OpSpecConstant) { context()->get_decoration_mgr()->ForEachDecoration( length_id, uint32_t(spv::Decoration::SpecId), [&spec_id, &has_spec_id](const Instruction& decoration) { assert(decoration.opcode() == spv::Op::OpDecorate); spec_id = decoration.GetSingleWordOperand(2u); has_spec_id = true; }); } const auto opcode = length_constant_inst->opcode(); if (has_spec_id) { extra_words.push_back(spec_id); } if ((opcode == spv::Op::OpConstant) || (opcode == spv::Op::OpSpecConstant)) { // Always include the literal constant words. In the spec constant // case, the constant might not be overridden, so it's still // significant. extra_words.insert(extra_words.end(), length_constant_inst->GetOperand(2).words.begin(), length_constant_inst->GetOperand(2).words.end()); extra_words[0] = has_spec_id ? Array::LengthInfo::kConstantWithSpecId : Array::LengthInfo::kConstant; } else { assert(extra_words[0] == Array::LengthInfo::kDefiningId); extra_words.push_back(length_id); } assert(extra_words.size() >= 2); Array::LengthInfo length_info{length_id, extra_words}; type = new Array(GetType(inst.GetSingleWordInOperand(0)), length_info); if (id_to_incomplete_type_.count(inst.GetSingleWordInOperand(0))) { incomplete_types_.emplace_back(inst.result_id(), type); id_to_incomplete_type_[inst.result_id()] = type; return type; } } break; case spv::Op::OpTypeRuntimeArray: type = new RuntimeArray(GetType(inst.GetSingleWordInOperand(0))); if (id_to_incomplete_type_.count(inst.GetSingleWordInOperand(0))) { incomplete_types_.emplace_back(inst.result_id(), type); id_to_incomplete_type_[inst.result_id()] = type; return type; } break; case spv::Op::OpTypeNodePayloadArrayAMDX: type = new NodePayloadArrayAMDX(GetType(inst.GetSingleWordInOperand(0))); if (id_to_incomplete_type_.count(inst.GetSingleWordInOperand(0))) { incomplete_types_.emplace_back(inst.result_id(), type); id_to_incomplete_type_[inst.result_id()] = type; return type; } break; case spv::Op::OpTypeStruct: { std::vector element_types; bool incomplete_type = false; for (uint32_t i = 0; i < inst.NumInOperands(); ++i) { uint32_t type_id = inst.GetSingleWordInOperand(i); element_types.push_back(GetType(type_id)); if (id_to_incomplete_type_.count(type_id)) { incomplete_type = true; } } type = new Struct(element_types); if (incomplete_type) { incomplete_types_.emplace_back(inst.result_id(), type); id_to_incomplete_type_[inst.result_id()] = type; return type; } } break; case spv::Op::OpTypeOpaque: { type = new Opaque(inst.GetInOperand(0).AsString()); } break; case spv::Op::OpTypePointer: { uint32_t pointee_type_id = inst.GetSingleWordInOperand(1); type = new Pointer( GetType(pointee_type_id), static_cast(inst.GetSingleWordInOperand(0))); if (id_to_incomplete_type_.count(pointee_type_id)) { incomplete_types_.emplace_back(inst.result_id(), type); id_to_incomplete_type_[inst.result_id()] = type; return type; } id_to_incomplete_type_.erase(inst.result_id()); } break; case spv::Op::OpTypeFunction: { bool incomplete_type = false; uint32_t return_type_id = inst.GetSingleWordInOperand(0); if (id_to_incomplete_type_.count(return_type_id)) { incomplete_type = true; } Type* return_type = GetType(return_type_id); std::vector param_types; for (uint32_t i = 1; i < inst.NumInOperands(); ++i) { uint32_t param_type_id = inst.GetSingleWordInOperand(i); param_types.push_back(GetType(param_type_id)); if (id_to_incomplete_type_.count(param_type_id)) { incomplete_type = true; } } type = new Function(return_type, param_types); if (incomplete_type) { incomplete_types_.emplace_back(inst.result_id(), type); id_to_incomplete_type_[inst.result_id()] = type; return type; } } break; case spv::Op::OpTypeEvent: type = new Event(); break; case spv::Op::OpTypeDeviceEvent: type = new DeviceEvent(); break; case spv::Op::OpTypeReserveId: type = new ReserveId(); break; case spv::Op::OpTypeQueue: type = new Queue(); break; case spv::Op::OpTypePipe: type = new Pipe( static_cast(inst.GetSingleWordInOperand(0))); break; case spv::Op::OpTypeForwardPointer: { // Handling of forward pointers is different from the other types. uint32_t target_id = inst.GetSingleWordInOperand(0); type = new ForwardPointer(target_id, static_cast( inst.GetSingleWordInOperand(1))); incomplete_types_.emplace_back(target_id, type); id_to_incomplete_type_[target_id] = type; return type; } case spv::Op::OpTypePipeStorage: type = new PipeStorage(); break; case spv::Op::OpTypeNamedBarrier: type = new NamedBarrier(); break; case spv::Op::OpTypeAccelerationStructureNV: type = new AccelerationStructureNV(); break; case spv::Op::OpTypeCooperativeMatrixNV: type = new CooperativeMatrixNV(GetType(inst.GetSingleWordInOperand(0)), inst.GetSingleWordInOperand(1), inst.GetSingleWordInOperand(2), inst.GetSingleWordInOperand(3)); break; case spv::Op::OpTypeCooperativeMatrixKHR: type = new CooperativeMatrixKHR( GetType(inst.GetSingleWordInOperand(0)), inst.GetSingleWordInOperand(1), inst.GetSingleWordInOperand(2), inst.GetSingleWordInOperand(3), inst.GetSingleWordInOperand(4)); break; case spv::Op::OpTypeCooperativeVectorNV: type = new CooperativeVectorNV(GetType(inst.GetSingleWordInOperand(0)), inst.GetSingleWordInOperand(1)); break; case spv::Op::OpTypeRayQueryKHR: type = new RayQueryKHR(); break; case spv::Op::OpTypeHitObjectNV: type = new HitObjectNV(); break; case spv::Op::OpTypeTensorLayoutNV: type = new TensorLayoutNV(inst.GetSingleWordInOperand(0), inst.GetSingleWordInOperand(1)); break; case spv::Op::OpTypeTensorViewNV: { const auto count = inst.NumOperands(); std::vector perm; for (uint32_t i = 2; i < count; ++i) { perm.push_back(inst.GetSingleWordOperand(i)); } type = new TensorViewNV(inst.GetSingleWordInOperand(0), inst.GetSingleWordInOperand(1), perm); break; } default: assert(false && "Type not handled by the type manager."); break; } uint32_t id = inst.result_id(); SPIRV_ASSERT(consumer_, id != 0, "instruction without result id found"); SPIRV_ASSERT(consumer_, type != nullptr, "type should not be nullptr at this point"); std::vector decorations = context()->get_decoration_mgr()->GetDecorationsFor(id, true); for (auto dec : decorations) { AttachDecoration(*dec, type); } std::unique_ptr unique(type); auto pair = type_pool_.insert(std::move(unique)); id_to_type_[id] = pair.first->get(); type_to_id_[pair.first->get()] = id; return type; } void TypeManager::AttachDecoration(const Instruction& inst, Type* type) { const spv::Op opcode = inst.opcode(); if (!IsAnnotationInst(opcode)) return; switch (opcode) { case spv::Op::OpDecorate: case spv::Op::OpDecorateId: { const auto count = inst.NumOperands(); std::vector data; for (uint32_t i = 1; i < count; ++i) { data.push_back(inst.GetSingleWordOperand(i)); } type->AddDecoration(std::move(data)); } break; case spv::Op::OpMemberDecorate: { const auto count = inst.NumOperands(); const uint32_t index = inst.GetSingleWordOperand(1); std::vector data; for (uint32_t i = 2; i < count; ++i) { data.push_back(inst.GetSingleWordOperand(i)); } if (Struct* st = type->AsStruct()) { st->AddMemberDecoration(index, std::move(data)); } } break; default: assert(false && "Unexpected opcode for a decoration instruction."); break; } } const Type* TypeManager::GetMemberType( const Type* parent_type, const std::vector& access_chain) { for (uint32_t element_index : access_chain) { if (const Struct* struct_type = parent_type->AsStruct()) { parent_type = struct_type->element_types()[element_index]; } else if (const Array* array_type = parent_type->AsArray()) { parent_type = array_type->element_type(); } else if (const RuntimeArray* runtime_array_type = parent_type->AsRuntimeArray()) { parent_type = runtime_array_type->element_type(); } else if (const Vector* vector_type = parent_type->AsVector()) { parent_type = vector_type->element_type(); } else if (const Matrix* matrix_type = parent_type->AsMatrix()) { parent_type = matrix_type->element_type(); } else { assert(false && "Trying to get a member of a type without members."); } } return parent_type; } void TypeManager::ReplaceForwardPointers(Type* type) { switch (type->kind()) { case Type::kArray: { const ForwardPointer* element_type = type->AsArray()->element_type()->AsForwardPointer(); if (element_type) { type->AsArray()->ReplaceElementType(element_type->target_pointer()); } } break; case Type::kRuntimeArray: { const ForwardPointer* element_type = type->AsRuntimeArray()->element_type()->AsForwardPointer(); if (element_type) { type->AsRuntimeArray()->ReplaceElementType( element_type->target_pointer()); } } break; case Type::kStruct: { auto& member_types = type->AsStruct()->element_types(); for (auto& member_type : member_types) { if (member_type->AsForwardPointer()) { member_type = member_type->AsForwardPointer()->target_pointer(); assert(member_type); } } } break; case Type::kPointer: { const ForwardPointer* pointee_type = type->AsPointer()->pointee_type()->AsForwardPointer(); if (pointee_type) { type->AsPointer()->SetPointeeType(pointee_type->target_pointer()); } } break; case Type::kFunction: { Function* func_type = type->AsFunction(); const ForwardPointer* return_type = func_type->return_type()->AsForwardPointer(); if (return_type) { func_type->SetReturnType(return_type->target_pointer()); } auto& param_types = func_type->param_types(); for (auto& param_type : param_types) { if (param_type->AsForwardPointer()) { param_type = param_type->AsForwardPointer()->target_pointer(); } } } break; default: break; } } void TypeManager::ReplaceType(Type* new_type, Type* original_type) { assert(original_type->kind() == new_type->kind() && "Types must be the same for replacement.\n"); for (auto& p : incomplete_types_) { Type* type = p.type(); if (!type) { continue; } switch (type->kind()) { case Type::kArray: { const Type* element_type = type->AsArray()->element_type(); if (element_type == original_type) { type->AsArray()->ReplaceElementType(new_type); } } break; case Type::kRuntimeArray: { const Type* element_type = type->AsRuntimeArray()->element_type(); if (element_type == original_type) { type->AsRuntimeArray()->ReplaceElementType(new_type); } } break; case Type::kStruct: { auto& member_types = type->AsStruct()->element_types(); for (auto& member_type : member_types) { if (member_type == original_type) { member_type = new_type; } } } break; case Type::kPointer: { const Type* pointee_type = type->AsPointer()->pointee_type(); if (pointee_type == original_type) { type->AsPointer()->SetPointeeType(new_type); } } break; case Type::kFunction: { Function* func_type = type->AsFunction(); const Type* return_type = func_type->return_type(); if (return_type == original_type) { func_type->SetReturnType(new_type); } auto& param_types = func_type->param_types(); for (auto& param_type : param_types) { if (param_type == original_type) { param_type = new_type; } } } break; default: break; } } } } // namespace analysis } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/type_manager.h000066400000000000000000000242171475742701700234650ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_TYPE_MANAGER_H_ #define SOURCE_OPT_TYPE_MANAGER_H_ #include #include #include #include #include #include "source/opt/module.h" #include "source/opt/types.h" #include "spirv-tools/libspirv.hpp" namespace spvtools { namespace opt { class IRContext; namespace analysis { // Hashing functor. // // All type pointers must be non-null. struct HashTypePointer { size_t operator()(const Type* type) const { assert(type); return type->HashValue(); } }; struct HashTypeUniquePointer { size_t operator()(const std::unique_ptr& type) const { assert(type); return type->HashValue(); } }; // Equality functor. // // Checks if two types pointers are the same type. // // All type pointers must be non-null. struct CompareTypePointers { bool operator()(const Type* lhs, const Type* rhs) const { assert(lhs && rhs); return lhs->IsSame(rhs); } }; struct CompareTypeUniquePointers { bool operator()(const std::unique_ptr& lhs, const std::unique_ptr& rhs) const { assert(lhs && rhs); return lhs->IsSame(rhs.get()); } }; // A class for managing the SPIR-V type hierarchy. class TypeManager { public: using IdToTypeMap = std::unordered_map; // Constructs a type manager from the given |module|. All internal messages // will be communicated to the outside via the given message |consumer|. // This instance only keeps a reference to the |consumer|, so the |consumer| // should outlive this instance. TypeManager(const MessageConsumer& consumer, IRContext* c); TypeManager(const TypeManager&) = delete; TypeManager(TypeManager&&) = delete; TypeManager& operator=(const TypeManager&) = delete; TypeManager& operator=(TypeManager&&) = delete; // Returns the type for the given type |id|. Returns nullptr if the given |id| // does not define a type. Type* GetType(uint32_t id) const; // Returns the id for the given |type|. Returns 0 if can not find the given // |type|. uint32_t GetId(const Type* type) const; // Returns the number of types hold in this manager. size_t NumTypes() const { return id_to_type_.size(); } // Iterators for all types contained in this manager. IdToTypeMap::const_iterator begin() const { return id_to_type_.cbegin(); } IdToTypeMap::const_iterator end() const { return id_to_type_.cend(); } // Returns a pair of the type and pointer to the type in |sc|. // // |id| must be a registered type. std::pair> GetTypeAndPointerType( uint32_t id, spv::StorageClass sc) const; // Returns an id for a declaration representing |type|. Returns 0 if the type // does not exists, and could not be generated. // // If |type| is registered, then the registered id is returned. Otherwise, // this function recursively adds type and annotation instructions as // necessary to fully define |type|. uint32_t GetTypeInstruction(const Type* type); // Find pointer to type and storage in module, return its resultId. If it is // not found, a new type is created, and its id is returned. Returns 0 if the // type could not be created. uint32_t FindPointerToType(uint32_t type_id, spv::StorageClass storage_class); // Registers |id| to |type|. // // If GetId(|type|) already returns a non-zero id, that mapping will be // unchanged. void RegisterType(uint32_t id, const Type& type); // Return the registered type object that is the same as |type|. Type* GetRegisteredType(const Type* type); // Removes knowledge of |id| from the manager. // // If |id| is an ambiguous type the multiple ids may be registered to |id|'s // type (e.g. %struct1 and %struct1 might hash to the same type). In that // case, calling GetId() with |id|'s type will return another suitable id // defining that type. void RemoveId(uint32_t id); // Returns the type of the member of |parent_type| that is identified by // |access_chain|. The vector |access_chain| is a series of integers that are // used to pick members as in the |OpCompositeExtract| instructions. If you // want a member of an array, vector, or matrix that does not have a constant // index, you can use 0 in that position. All elements have the same type. const Type* GetMemberType(const Type* parent_type, const std::vector& access_chain); // Attaches the decoration encoded in |inst| to |type|. Does nothing if the // given instruction is not a decoration instruction. Assumes the target is // |type| (e.g. should be called in loop of |type|'s decorations). void AttachDecoration(const Instruction& inst, Type* type); Type* GetUIntType() { return GetIntType(32, false); } uint32_t GetUIntTypeId() { return GetTypeInstruction(GetUIntType()); } Type* GetIntType(int32_t bitWidth, bool isSigned) { Integer int_type(bitWidth, isSigned); return GetRegisteredType(&int_type); } Type* GetSIntType() { return GetIntType(32, true); } uint32_t GetSIntTypeId() { return GetTypeInstruction(GetSIntType()); } Type* GetFloatType() { Float float_type(32); return GetRegisteredType(&float_type); } uint32_t GetFloatTypeId() { return GetTypeInstruction(GetFloatType()); } Type* GetDoubleType() { Float float_type(64); return GetRegisteredType(&float_type); } uint32_t GetDoubleTypeId() { return GetTypeInstruction(GetDoubleType()); } Type* GetUIntVectorType(uint32_t size) { Vector vec_type(GetUIntType(), size); return GetRegisteredType(&vec_type); } uint32_t GetUIntVectorTypeId(uint32_t size) { return GetTypeInstruction(GetUIntVectorType(size)); } Type* GetSIntVectorType(uint32_t size) { Vector vec_type(GetSIntType(), size); return GetRegisteredType(&vec_type); } uint32_t GetSIntVectorTypeId(uint32_t size) { return GetTypeInstruction(GetSIntVectorType(size)); } Type* GetFloatVectorType(uint32_t size) { Vector vec_type(GetFloatType(), size); return GetRegisteredType(&vec_type); } uint32_t GetFloatVectorTypeId(uint32_t size) { return GetTypeInstruction(GetFloatVectorType(size)); } Type* GetBoolType() { Bool bool_type; return GetRegisteredType(&bool_type); } uint32_t GetBoolTypeId() { return GetTypeInstruction(GetBoolType()); } Type* GetVoidType() { Void void_type; return GetRegisteredType(&void_type); } uint32_t GetVoidTypeId() { return GetTypeInstruction(GetVoidType()); } private: using TypeToIdMap = std::unordered_map; using TypePool = std::unordered_set, HashTypeUniquePointer, CompareTypeUniquePointers>; class UnresolvedType { public: UnresolvedType(uint32_t i, Type* t) : id_(i), type_(t) {} UnresolvedType(const UnresolvedType&) = delete; UnresolvedType(UnresolvedType&& that) : id_(that.id_), type_(std::move(that.type_)) {} uint32_t id() { return id_; } Type* type() { return type_.get(); } std::unique_ptr&& ReleaseType() { return std::move(type_); } void ResetType(Type* t) { type_.reset(t); } private: uint32_t id_; std::unique_ptr type_; }; using IdToUnresolvedType = std::vector; // Analyzes the types and decorations on types in the given |module|. void AnalyzeTypes(const Module& module); IRContext* context() { return context_; } // Attaches the decorations on |type| to |id|. void AttachDecorations(uint32_t id, const Type* type); // Create the annotation instruction. // // If |is_member| is false, an OpDecorate of |decoration| on |id| is created, // otherwise an OpMemberDecorate is created at |element|. The annotation is // registered with the DefUseManager and the DecorationManager. void CreateDecoration(uint32_t id, const std::vector& decoration, bool is_member = false, uint32_t element = 0); // Creates and returns a type from the given SPIR-V |inst|. Returns nullptr if // the given instruction is not for defining a type. Type* RecordIfTypeDefinition(const Instruction& inst); // Returns an equivalent pointer to |type| built in terms of pointers owned by // |type_pool_|. For example, if |type| is a vec3 of bool, it will be rebuilt // replacing the bool subtype with one owned by |type_pool_|. // // The re-built type will have ID |type_id|. Type* RebuildType(uint32_t type_id, const Type& type); // Completes the incomplete type |type|, by replaces all references to // ForwardPointer by the defining Pointer. void ReplaceForwardPointers(Type* type); // Replaces all references to |original_type| in |incomplete_types_| by // |new_type|. void ReplaceType(Type* new_type, Type* original_type); const MessageConsumer& consumer_; // Message consumer. IRContext* context_; IdToTypeMap id_to_type_; // Mapping from ids to their type representations. TypeToIdMap type_to_id_; // Mapping from types to their defining ids. TypePool type_pool_; // Memory owner of type pointers. IdToUnresolvedType incomplete_types_; // All incomplete types. Stored in an // std::vector to make traversals // deterministic. IdToTypeMap id_to_incomplete_type_; // Maps ids to their type representations // for incomplete types. std::unordered_map id_to_constant_inst_; }; } // namespace analysis } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_TYPE_MANAGER_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/types.cpp000066400000000000000000000652031475742701700225110ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // Modifications Copyright (C) 2024 Advanced Micro Devices, Inc. All rights // reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/types.h" #include #include #include #include #include #include #include "source/util/hash_combine.h" #include "source/util/make_unique.h" namespace spvtools { namespace opt { namespace analysis { using spvtools::utils::hash_combine; using U32VecVec = std::vector>; namespace { // Returns true if the two vector of vectors are identical. bool CompareTwoVectors(const U32VecVec a, const U32VecVec b) { const auto size = a.size(); if (size != b.size()) return false; if (size == 0) return true; if (size == 1) return a.front() == b.front(); std::vector*> a_ptrs, b_ptrs; a_ptrs.reserve(size); a_ptrs.reserve(size); for (uint32_t i = 0; i < size; ++i) { a_ptrs.push_back(&a[i]); b_ptrs.push_back(&b[i]); } const auto cmp = [](const std::vector* m, const std::vector* n) { return m->front() < n->front(); }; std::sort(a_ptrs.begin(), a_ptrs.end(), cmp); std::sort(b_ptrs.begin(), b_ptrs.end(), cmp); for (uint32_t i = 0; i < size; ++i) { if (*a_ptrs[i] != *b_ptrs[i]) return false; } return true; } } // namespace std::string Type::GetDecorationStr() const { std::ostringstream oss; oss << "[["; for (const auto& decoration : decorations_) { oss << "("; for (size_t i = 0; i < decoration.size(); ++i) { oss << (i > 0 ? ", " : ""); oss << decoration.at(i); } oss << ")"; } oss << "]]"; return oss.str(); } bool Type::HasSameDecorations(const Type* that) const { return CompareTwoVectors(decorations_, that->decorations_); } bool Type::IsUniqueType() const { switch (kind_) { case kPointer: case kStruct: case kArray: case kRuntimeArray: case kNodePayloadArrayAMDX: return false; default: return true; } } std::unique_ptr Type::Clone() const { std::unique_ptr type; switch (kind_) { #define DeclareKindCase(kind) \ case k##kind: \ type = MakeUnique(*this->As##kind()); \ break DeclareKindCase(Void); DeclareKindCase(Bool); DeclareKindCase(Integer); DeclareKindCase(Float); DeclareKindCase(Vector); DeclareKindCase(Matrix); DeclareKindCase(Image); DeclareKindCase(Sampler); DeclareKindCase(SampledImage); DeclareKindCase(Array); DeclareKindCase(RuntimeArray); DeclareKindCase(Struct); DeclareKindCase(Opaque); DeclareKindCase(Pointer); DeclareKindCase(Function); DeclareKindCase(Event); DeclareKindCase(DeviceEvent); DeclareKindCase(ReserveId); DeclareKindCase(Queue); DeclareKindCase(Pipe); DeclareKindCase(ForwardPointer); DeclareKindCase(PipeStorage); DeclareKindCase(NamedBarrier); DeclareKindCase(AccelerationStructureNV); DeclareKindCase(CooperativeMatrixNV); DeclareKindCase(CooperativeMatrixKHR); DeclareKindCase(CooperativeVectorNV); DeclareKindCase(RayQueryKHR); DeclareKindCase(HitObjectNV); #undef DeclareKindCase default: assert(false && "Unhandled type"); } return type; } std::unique_ptr Type::RemoveDecorations() const { std::unique_ptr type(Clone()); type->ClearDecorations(); return type; } bool Type::operator==(const Type& other) const { if (kind_ != other.kind_) return false; switch (kind_) { #define DeclareKindCase(kind) \ case k##kind: \ return As##kind()->IsSame(&other) DeclareKindCase(Void); DeclareKindCase(Bool); DeclareKindCase(Integer); DeclareKindCase(Float); DeclareKindCase(Vector); DeclareKindCase(Matrix); DeclareKindCase(Image); DeclareKindCase(Sampler); DeclareKindCase(SampledImage); DeclareKindCase(Array); DeclareKindCase(RuntimeArray); DeclareKindCase(NodePayloadArrayAMDX); DeclareKindCase(Struct); DeclareKindCase(Opaque); DeclareKindCase(Pointer); DeclareKindCase(Function); DeclareKindCase(Event); DeclareKindCase(DeviceEvent); DeclareKindCase(ReserveId); DeclareKindCase(Queue); DeclareKindCase(Pipe); DeclareKindCase(ForwardPointer); DeclareKindCase(PipeStorage); DeclareKindCase(NamedBarrier); DeclareKindCase(AccelerationStructureNV); DeclareKindCase(CooperativeMatrixNV); DeclareKindCase(CooperativeMatrixKHR); DeclareKindCase(CooperativeVectorNV); DeclareKindCase(RayQueryKHR); DeclareKindCase(HitObjectNV); DeclareKindCase(TensorLayoutNV); DeclareKindCase(TensorViewNV); #undef DeclareKindCase default: assert(false && "Unhandled type"); return false; } } size_t Type::ComputeHashValue(size_t hash, SeenTypes* seen) const { // Linear search through a dense, cache coherent vector is faster than O(log // n) search in a complex data structure (eg std::set) for the generally small // number of nodes. It also skips the overhead of an new/delete per Type // (when inserting/removing from a set). if (std::find(seen->begin(), seen->end(), this) != seen->end()) { return hash; } seen->push_back(this); hash = hash_combine(hash, uint32_t(kind_)); for (const auto& d : decorations_) { hash = hash_combine(hash, d); } switch (kind_) { #define DeclareKindCase(type) \ case k##type: \ hash = As##type()->ComputeExtraStateHash(hash, seen); \ break DeclareKindCase(Void); DeclareKindCase(Bool); DeclareKindCase(Integer); DeclareKindCase(Float); DeclareKindCase(Vector); DeclareKindCase(Matrix); DeclareKindCase(Image); DeclareKindCase(Sampler); DeclareKindCase(SampledImage); DeclareKindCase(Array); DeclareKindCase(RuntimeArray); DeclareKindCase(NodePayloadArrayAMDX); DeclareKindCase(Struct); DeclareKindCase(Opaque); DeclareKindCase(Pointer); DeclareKindCase(Function); DeclareKindCase(Event); DeclareKindCase(DeviceEvent); DeclareKindCase(ReserveId); DeclareKindCase(Queue); DeclareKindCase(Pipe); DeclareKindCase(ForwardPointer); DeclareKindCase(PipeStorage); DeclareKindCase(NamedBarrier); DeclareKindCase(AccelerationStructureNV); DeclareKindCase(CooperativeMatrixNV); DeclareKindCase(CooperativeMatrixKHR); DeclareKindCase(CooperativeVectorNV); DeclareKindCase(RayQueryKHR); DeclareKindCase(HitObjectNV); DeclareKindCase(TensorLayoutNV); DeclareKindCase(TensorViewNV); #undef DeclareKindCase default: assert(false && "Unhandled type"); break; } seen->pop_back(); return hash; } size_t Type::HashValue() const { SeenTypes seen; return ComputeHashValue(0, &seen); } uint64_t Type::NumberOfComponents() const { switch (kind()) { case kVector: return AsVector()->element_count(); case kMatrix: return AsMatrix()->element_count(); case kArray: { Array::LengthInfo length_info = AsArray()->length_info(); if (length_info.words[0] != Array::LengthInfo::kConstant) { return UINT64_MAX; } assert(length_info.words.size() <= 3 && "The size of the array could not fit size_t."); uint64_t length = 0; length |= length_info.words[1]; if (length_info.words.size() > 2) { length |= static_cast(length_info.words[2]) << 32; } return length; } case kRuntimeArray: return UINT64_MAX; case kStruct: return AsStruct()->element_types().size(); default: return 0; } } bool Integer::IsSameImpl(const Type* that, IsSameCache*) const { const Integer* it = that->AsInteger(); return it && width_ == it->width_ && signed_ == it->signed_ && HasSameDecorations(that); } std::string Integer::str() const { std::ostringstream oss; oss << (signed_ ? "s" : "u") << "int" << width_; return oss.str(); } size_t Integer::ComputeExtraStateHash(size_t hash, SeenTypes*) const { return hash_combine(hash, width_, signed_); } bool Float::IsSameImpl(const Type* that, IsSameCache*) const { const Float* ft = that->AsFloat(); return ft && width_ == ft->width_ && HasSameDecorations(that); } std::string Float::str() const { std::ostringstream oss; oss << "float" << width_; return oss.str(); } size_t Float::ComputeExtraStateHash(size_t hash, SeenTypes*) const { return hash_combine(hash, width_); } Vector::Vector(const Type* type, uint32_t count) : Type(kVector), element_type_(type), count_(count) { assert(type->AsBool() || type->AsInteger() || type->AsFloat()); } bool Vector::IsSameImpl(const Type* that, IsSameCache* seen) const { const Vector* vt = that->AsVector(); if (!vt) return false; return count_ == vt->count_ && element_type_->IsSameImpl(vt->element_type_, seen) && HasSameDecorations(that); } std::string Vector::str() const { std::ostringstream oss; oss << "<" << element_type_->str() << ", " << count_ << ">"; return oss.str(); } size_t Vector::ComputeExtraStateHash(size_t hash, SeenTypes* seen) const { // prefer form that doesn't require push/pop from stack: add state and // make tail call. hash = hash_combine(hash, count_); return element_type_->ComputeHashValue(hash, seen); } Matrix::Matrix(const Type* type, uint32_t count) : Type(kMatrix), element_type_(type), count_(count) { assert(type->AsVector()); } bool Matrix::IsSameImpl(const Type* that, IsSameCache* seen) const { const Matrix* mt = that->AsMatrix(); if (!mt) return false; return count_ == mt->count_ && element_type_->IsSameImpl(mt->element_type_, seen) && HasSameDecorations(that); } std::string Matrix::str() const { std::ostringstream oss; oss << "<" << element_type_->str() << ", " << count_ << ">"; return oss.str(); } size_t Matrix::ComputeExtraStateHash(size_t hash, SeenTypes* seen) const { hash = hash_combine(hash, count_); return element_type_->ComputeHashValue(hash, seen); } Image::Image(Type* type, spv::Dim dimen, uint32_t d, bool array, bool multisample, uint32_t sampling, spv::ImageFormat f, spv::AccessQualifier qualifier) : Type(kImage), sampled_type_(type), dim_(dimen), depth_(d), arrayed_(array), ms_(multisample), sampled_(sampling), format_(f), access_qualifier_(qualifier) { // TODO(antiagainst): check sampled_type } bool Image::IsSameImpl(const Type* that, IsSameCache* seen) const { const Image* it = that->AsImage(); if (!it) return false; return dim_ == it->dim_ && depth_ == it->depth_ && arrayed_ == it->arrayed_ && ms_ == it->ms_ && sampled_ == it->sampled_ && format_ == it->format_ && access_qualifier_ == it->access_qualifier_ && sampled_type_->IsSameImpl(it->sampled_type_, seen) && HasSameDecorations(that); } std::string Image::str() const { std::ostringstream oss; oss << "image(" << sampled_type_->str() << ", " << uint32_t(dim_) << ", " << depth_ << ", " << arrayed_ << ", " << ms_ << ", " << sampled_ << ", " << uint32_t(format_) << ", " << uint32_t(access_qualifier_) << ")"; return oss.str(); } size_t Image::ComputeExtraStateHash(size_t hash, SeenTypes* seen) const { hash = hash_combine(hash, uint32_t(dim_), depth_, arrayed_, ms_, sampled_, uint32_t(format_), uint32_t(access_qualifier_)); return sampled_type_->ComputeHashValue(hash, seen); } bool SampledImage::IsSameImpl(const Type* that, IsSameCache* seen) const { const SampledImage* sit = that->AsSampledImage(); if (!sit) return false; return image_type_->IsSameImpl(sit->image_type_, seen) && HasSameDecorations(that); } std::string SampledImage::str() const { std::ostringstream oss; oss << "sampled_image(" << image_type_->str() << ")"; return oss.str(); } size_t SampledImage::ComputeExtraStateHash(size_t hash, SeenTypes* seen) const { return image_type_->ComputeHashValue(hash, seen); } Array::Array(const Type* type, const Array::LengthInfo& length_info_arg) : Type(kArray), element_type_(type), length_info_(length_info_arg) { assert(type != nullptr); assert(!type->AsVoid()); // We always have a word to say which case we're in, followed // by at least one more word. assert(length_info_arg.words.size() >= 2); } bool Array::IsSameImpl(const Type* that, IsSameCache* seen) const { const Array* at = that->AsArray(); if (!at) return false; bool is_same = element_type_->IsSameImpl(at->element_type_, seen); is_same = is_same && HasSameDecorations(that); is_same = is_same && (length_info_.words == at->length_info_.words); return is_same; } std::string Array::str() const { std::ostringstream oss; oss << "[" << element_type_->str() << ", id(" << LengthId() << "), words("; const char* spacer = ""; for (auto w : length_info_.words) { oss << spacer << w; spacer = ","; } oss << ")]"; return oss.str(); } size_t Array::ComputeExtraStateHash(size_t hash, SeenTypes* seen) const { hash = hash_combine(hash, length_info_.words); return element_type_->ComputeHashValue(hash, seen); } void Array::ReplaceElementType(const Type* type) { element_type_ = type; } Array::LengthInfo Array::GetConstantLengthInfo(uint32_t const_id, uint32_t length) const { std::vector extra_words{LengthInfo::Case::kConstant, length}; return {const_id, extra_words}; } RuntimeArray::RuntimeArray(const Type* type) : Type(kRuntimeArray), element_type_(type) { assert(!type->AsVoid()); } bool RuntimeArray::IsSameImpl(const Type* that, IsSameCache* seen) const { const RuntimeArray* rat = that->AsRuntimeArray(); if (!rat) return false; return element_type_->IsSameImpl(rat->element_type_, seen) && HasSameDecorations(that); } std::string RuntimeArray::str() const { std::ostringstream oss; oss << "[" << element_type_->str() << "]"; return oss.str(); } size_t RuntimeArray::ComputeExtraStateHash(size_t hash, SeenTypes* seen) const { return element_type_->ComputeHashValue(hash, seen); } void RuntimeArray::ReplaceElementType(const Type* type) { element_type_ = type; } NodePayloadArrayAMDX::NodePayloadArrayAMDX(const Type* type) : Type(kNodePayloadArrayAMDX), element_type_(type) { assert(!type->AsVoid()); } bool NodePayloadArrayAMDX::IsSameImpl(const Type* that, IsSameCache* seen) const { const NodePayloadArrayAMDX* rat = that->AsNodePayloadArrayAMDX(); if (!rat) return false; return element_type_->IsSameImpl(rat->element_type_, seen) && HasSameDecorations(that); } std::string NodePayloadArrayAMDX::str() const { std::ostringstream oss; oss << "[" << element_type_->str() << "]"; return oss.str(); } size_t NodePayloadArrayAMDX::ComputeExtraStateHash(size_t hash, SeenTypes* seen) const { return element_type_->ComputeHashValue(hash, seen); } void NodePayloadArrayAMDX::ReplaceElementType(const Type* type) { element_type_ = type; } Struct::Struct(const std::vector& types) : Type(kStruct), element_types_(types) { for (const auto* t : types) { (void)t; assert(!t->AsVoid()); } } void Struct::AddMemberDecoration(uint32_t index, std::vector&& decoration) { if (index >= element_types_.size()) { assert(0 && "index out of bound"); return; } element_decorations_[index].push_back(std::move(decoration)); } bool Struct::IsSameImpl(const Type* that, IsSameCache* seen) const { const Struct* st = that->AsStruct(); if (!st) return false; if (element_types_.size() != st->element_types_.size()) return false; const auto size = element_decorations_.size(); if (size != st->element_decorations_.size()) return false; if (!HasSameDecorations(that)) return false; for (size_t i = 0; i < element_types_.size(); ++i) { if (!element_types_[i]->IsSameImpl(st->element_types_[i], seen)) return false; } for (const auto& p : element_decorations_) { if (st->element_decorations_.count(p.first) == 0) return false; if (!CompareTwoVectors(p.second, st->element_decorations_.at(p.first))) return false; } return true; } std::string Struct::str() const { std::ostringstream oss; oss << "{"; const size_t count = element_types_.size(); for (size_t i = 0; i < count; ++i) { oss << element_types_[i]->str(); if (i + 1 != count) oss << ", "; } oss << "}"; return oss.str(); } size_t Struct::ComputeExtraStateHash(size_t hash, SeenTypes* seen) const { for (auto* t : element_types_) { hash = t->ComputeHashValue(hash, seen); } for (const auto& pair : element_decorations_) { hash = hash_combine(hash, pair.first, pair.second); } return hash; } bool Opaque::IsSameImpl(const Type* that, IsSameCache*) const { const Opaque* ot = that->AsOpaque(); if (!ot) return false; return name_ == ot->name_ && HasSameDecorations(that); } std::string Opaque::str() const { std::ostringstream oss; oss << "opaque('" << name_ << "')"; return oss.str(); } size_t Opaque::ComputeExtraStateHash(size_t hash, SeenTypes*) const { return hash_combine(hash, name_); } Pointer::Pointer(const Type* type, spv::StorageClass sc) : Type(kPointer), pointee_type_(type), storage_class_(sc) {} bool Pointer::IsSameImpl(const Type* that, IsSameCache* seen) const { const Pointer* pt = that->AsPointer(); if (!pt) return false; if (storage_class_ != pt->storage_class_) return false; auto p = seen->insert(std::make_pair(this, that->AsPointer())); if (!p.second) { return true; } bool same_pointee = pointee_type_->IsSameImpl(pt->pointee_type_, seen); seen->erase(p.first); if (!same_pointee) { return false; } return HasSameDecorations(that); } std::string Pointer::str() const { std::ostringstream os; os << pointee_type_->str() << " " << static_cast(storage_class_) << "*"; return os.str(); } size_t Pointer::ComputeExtraStateHash(size_t hash, SeenTypes* seen) const { hash = hash_combine(hash, uint32_t(storage_class_)); return pointee_type_->ComputeHashValue(hash, seen); } void Pointer::SetPointeeType(const Type* type) { pointee_type_ = type; } Function::Function(const Type* ret_type, const std::vector& params) : Type(kFunction), return_type_(ret_type), param_types_(params) {} Function::Function(const Type* ret_type, std::vector& params) : Type(kFunction), return_type_(ret_type), param_types_(params) {} bool Function::IsSameImpl(const Type* that, IsSameCache* seen) const { const Function* ft = that->AsFunction(); if (!ft) return false; if (!return_type_->IsSameImpl(ft->return_type_, seen)) return false; if (param_types_.size() != ft->param_types_.size()) return false; for (size_t i = 0; i < param_types_.size(); ++i) { if (!param_types_[i]->IsSameImpl(ft->param_types_[i], seen)) return false; } return HasSameDecorations(that); } std::string Function::str() const { std::ostringstream oss; const size_t count = param_types_.size(); oss << "("; for (size_t i = 0; i < count; ++i) { oss << param_types_[i]->str(); if (i + 1 != count) oss << ", "; } oss << ") -> " << return_type_->str(); return oss.str(); } size_t Function::ComputeExtraStateHash(size_t hash, SeenTypes* seen) const { for (const auto* t : param_types_) { hash = t->ComputeHashValue(hash, seen); } return return_type_->ComputeHashValue(hash, seen); } void Function::SetReturnType(const Type* type) { return_type_ = type; } bool Pipe::IsSameImpl(const Type* that, IsSameCache*) const { const Pipe* pt = that->AsPipe(); if (!pt) return false; return access_qualifier_ == pt->access_qualifier_ && HasSameDecorations(that); } std::string Pipe::str() const { std::ostringstream oss; oss << "pipe(" << uint32_t(access_qualifier_) << ")"; return oss.str(); } size_t Pipe::ComputeExtraStateHash(size_t hash, SeenTypes*) const { return hash_combine(hash, uint32_t(access_qualifier_)); } bool ForwardPointer::IsSameImpl(const Type* that, IsSameCache*) const { const ForwardPointer* fpt = that->AsForwardPointer(); if (!fpt) return false; return (pointer_ && fpt->pointer_ ? *pointer_ == *fpt->pointer_ : target_id_ == fpt->target_id_) && storage_class_ == fpt->storage_class_ && HasSameDecorations(that); } std::string ForwardPointer::str() const { std::ostringstream oss; oss << "forward_pointer("; if (pointer_ != nullptr) { oss << pointer_->str(); } else { oss << target_id_; } oss << ")"; return oss.str(); } size_t ForwardPointer::ComputeExtraStateHash(size_t hash, SeenTypes* seen) const { hash = hash_combine(hash, target_id_, uint32_t(storage_class_)); if (pointer_) hash = pointer_->ComputeHashValue(hash, seen); return hash; } CooperativeMatrixNV::CooperativeMatrixNV(const Type* type, const uint32_t scope, const uint32_t rows, const uint32_t columns) : Type(kCooperativeMatrixNV), component_type_(type), scope_id_(scope), rows_id_(rows), columns_id_(columns) { assert(type != nullptr); assert(scope != 0); assert(rows != 0); assert(columns != 0); } std::string CooperativeMatrixNV::str() const { std::ostringstream oss; oss << "<" << component_type_->str() << ", " << scope_id_ << ", " << rows_id_ << ", " << columns_id_ << ">"; return oss.str(); } size_t CooperativeMatrixNV::ComputeExtraStateHash(size_t hash, SeenTypes* seen) const { hash = hash_combine(hash, scope_id_, rows_id_, columns_id_); return component_type_->ComputeHashValue(hash, seen); } bool CooperativeMatrixNV::IsSameImpl(const Type* that, IsSameCache* seen) const { const CooperativeMatrixNV* mt = that->AsCooperativeMatrixNV(); if (!mt) return false; return component_type_->IsSameImpl(mt->component_type_, seen) && scope_id_ == mt->scope_id_ && rows_id_ == mt->rows_id_ && columns_id_ == mt->columns_id_ && HasSameDecorations(that); } CooperativeMatrixKHR::CooperativeMatrixKHR(const Type* type, const uint32_t scope, const uint32_t rows, const uint32_t columns, const uint32_t use) : Type(kCooperativeMatrixKHR), component_type_(type), scope_id_(scope), rows_id_(rows), columns_id_(columns), use_id_(use) { assert(type != nullptr); assert(scope != 0); assert(rows != 0); assert(columns != 0); } std::string CooperativeMatrixKHR::str() const { std::ostringstream oss; oss << "<" << component_type_->str() << ", " << scope_id_ << ", " << rows_id_ << ", " << columns_id_ << ", " << use_id_ << ">"; return oss.str(); } size_t CooperativeMatrixKHR::ComputeExtraStateHash(size_t hash, SeenTypes* seen) const { hash = hash_combine(hash, scope_id_, rows_id_, columns_id_, use_id_); return component_type_->ComputeHashValue(hash, seen); } bool CooperativeMatrixKHR::IsSameImpl(const Type* that, IsSameCache* seen) const { const CooperativeMatrixKHR* mt = that->AsCooperativeMatrixKHR(); if (!mt) return false; return component_type_->IsSameImpl(mt->component_type_, seen) && scope_id_ == mt->scope_id_ && rows_id_ == mt->rows_id_ && columns_id_ == mt->columns_id_ && use_id_ == mt->use_id_ && HasSameDecorations(that); } TensorLayoutNV::TensorLayoutNV(const uint32_t dim, const uint32_t clamp_mode) : Type(kTensorLayoutNV), dim_id_(dim), clamp_mode_id_(clamp_mode) {} std::string TensorLayoutNV::str() const { std::ostringstream oss; oss << "<" << dim_id_ << ", " << clamp_mode_id_ << ">"; return oss.str(); } size_t TensorLayoutNV::ComputeExtraStateHash(size_t hash, SeenTypes*) const { return hash_combine(hash, dim_id_, clamp_mode_id_); } bool TensorLayoutNV::IsSameImpl(const Type* that, IsSameCache*) const { const TensorLayoutNV* tl = that->AsTensorLayoutNV(); if (!tl) return false; return dim_id_ == tl->dim_id_ && clamp_mode_id_ == tl->clamp_mode_id_; } TensorViewNV::TensorViewNV(const uint32_t dim, const uint32_t clamp_mode, const std::vector& perm) : Type(kTensorViewNV), dim_id_(dim), has_dimensions_id_(clamp_mode), perm_(perm) {} std::string TensorViewNV::str() const { std::ostringstream oss; oss << "<" << dim_id_ << ", " << has_dimensions_id_; for (auto p : perm_) { oss << ", " << p; } oss << ">"; return oss.str(); } size_t TensorViewNV::ComputeExtraStateHash(size_t hash, SeenTypes*) const { return hash_combine(hash, dim_id_, has_dimensions_id_, perm_); } bool TensorViewNV::IsSameImpl(const Type* that, IsSameCache*) const { const TensorViewNV* tv = that->AsTensorViewNV(); if (!tv) return false; return dim_id_ == tv->dim_id_ && has_dimensions_id_ == tv->has_dimensions_id_ && perm_ == tv->perm_; } CooperativeVectorNV::CooperativeVectorNV(const Type* type, const uint32_t components) : Type(kCooperativeVectorNV), component_type_(type), components_(components) { assert(type != nullptr); assert(components != 0); } std::string CooperativeVectorNV::str() const { std::ostringstream oss; oss << "<" << component_type_->str() << ", " << components_ << ">"; return oss.str(); } size_t CooperativeVectorNV::ComputeExtraStateHash(size_t hash, SeenTypes* seen) const { hash = hash_combine(hash, components_); return component_type_->ComputeHashValue(hash, seen); } bool CooperativeVectorNV::IsSameImpl(const Type* that, IsSameCache* seen) const { const CooperativeVectorNV* mt = that->AsCooperativeVectorNV(); if (!mt) return false; return component_type_->IsSameImpl(mt->component_type_, seen) && components_ == mt->components_ && HasSameDecorations(that); } } // namespace analysis } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/types.h000066400000000000000000000625021475742701700221550ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // Modifications Copyright (C) 2024 Advanced Micro Devices, Inc. All rights // reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // This file provides a class hierarchy for representing SPIR-V types. #ifndef SOURCE_OPT_TYPES_H_ #define SOURCE_OPT_TYPES_H_ #include #include #include #include #include #include #include #include #include "source/latest_version_spirv_header.h" #include "source/opt/instruction.h" #include "source/util/small_vector.h" #include "spirv-tools/libspirv.h" namespace spvtools { namespace opt { namespace analysis { class Void; class Bool; class Integer; class Float; class Vector; class Matrix; class Image; class Sampler; class SampledImage; class Array; class RuntimeArray; class NodePayloadArrayAMDX; class Struct; class Opaque; class Pointer; class Function; class Event; class DeviceEvent; class ReserveId; class Queue; class Pipe; class ForwardPointer; class PipeStorage; class NamedBarrier; class AccelerationStructureNV; class CooperativeMatrixNV; class CooperativeMatrixKHR; class CooperativeVectorNV; class RayQueryKHR; class HitObjectNV; class TensorLayoutNV; class TensorViewNV; // Abstract class for a SPIR-V type. It has a bunch of As() methods, // which is used as a way to probe the actual . class Type { public: typedef std::set> IsSameCache; using SeenTypes = spvtools::utils::SmallVector; // Available subtypes. // // When adding a new derived class of Type, please add an entry to the enum. enum Kind { kVoid, kBool, kInteger, kFloat, kVector, kMatrix, kImage, kSampler, kSampledImage, kArray, kRuntimeArray, kNodePayloadArrayAMDX, kStruct, kOpaque, kPointer, kFunction, kEvent, kDeviceEvent, kReserveId, kQueue, kPipe, kForwardPointer, kPipeStorage, kNamedBarrier, kAccelerationStructureNV, kCooperativeMatrixNV, kCooperativeMatrixKHR, kCooperativeVectorNV, kRayQueryKHR, kHitObjectNV, kTensorLayoutNV, kTensorViewNV, kLast }; Type(Kind k) : kind_(k) {} virtual ~Type() = default; // Attaches a decoration directly on this type. void AddDecoration(std::vector&& d) { decorations_.push_back(std::move(d)); } // Returns the decorations on this type as a string. std::string GetDecorationStr() const; // Returns true if this type has exactly the same decorations as |that| type. bool HasSameDecorations(const Type* that) const; // Returns true if this type is exactly the same as |that| type, including // decorations. bool IsSame(const Type* that) const { IsSameCache seen; return IsSameImpl(that, &seen); } // Returns true if this type is exactly the same as |that| type, including // decorations. |seen| is the set of |Pointer*| pair that are currently being // compared in a parent call to |IsSameImpl|. virtual bool IsSameImpl(const Type* that, IsSameCache* seen) const = 0; // Returns a human-readable string to represent this type. virtual std::string str() const = 0; Kind kind() const { return kind_; } const std::vector>& decorations() const { return decorations_; } // Returns true if there is no decoration on this type. For struct types, // returns true only when there is no decoration for both the struct type // and the struct members. virtual bool decoration_empty() const { return decorations_.empty(); } // Creates a clone of |this|. std::unique_ptr Clone() const; // Returns a clone of |this| minus any decorations. std::unique_ptr RemoveDecorations() const; // Returns true if this cannot hash to the same value as another type in the // module. For example, structs are not unique types because the module could // have two types // // %1 = OpTypeStruct %int // %2 = OpTypeStruct %int // // The only way to distinguish these types is the result id. The type manager // will hash them to the same value. bool IsUniqueType() const; bool operator==(const Type& other) const; // Returns the hash value of this type. size_t HashValue() const; size_t ComputeHashValue(size_t hash, SeenTypes* seen) const; // Returns the number of components in a composite type. Returns 0 for a // non-composite type. uint64_t NumberOfComponents() const; // A bunch of methods for casting this type to a given type. Returns this if the // cast can be done, nullptr otherwise. // clang-format off #define DeclareCastMethod(target) \ virtual target* As##target() { return nullptr; } \ virtual const target* As##target() const { return nullptr; } DeclareCastMethod(Void) DeclareCastMethod(Bool) DeclareCastMethod(Integer) DeclareCastMethod(Float) DeclareCastMethod(Vector) DeclareCastMethod(Matrix) DeclareCastMethod(Image) DeclareCastMethod(Sampler) DeclareCastMethod(SampledImage) DeclareCastMethod(Array) DeclareCastMethod(RuntimeArray) DeclareCastMethod(NodePayloadArrayAMDX) DeclareCastMethod(Struct) DeclareCastMethod(Opaque) DeclareCastMethod(Pointer) DeclareCastMethod(Function) DeclareCastMethod(Event) DeclareCastMethod(DeviceEvent) DeclareCastMethod(ReserveId) DeclareCastMethod(Queue) DeclareCastMethod(Pipe) DeclareCastMethod(ForwardPointer) DeclareCastMethod(PipeStorage) DeclareCastMethod(NamedBarrier) DeclareCastMethod(AccelerationStructureNV) DeclareCastMethod(CooperativeMatrixNV) DeclareCastMethod(CooperativeMatrixKHR) DeclareCastMethod(CooperativeVectorNV) DeclareCastMethod(RayQueryKHR) DeclareCastMethod(HitObjectNV) DeclareCastMethod(TensorLayoutNV) DeclareCastMethod(TensorViewNV) #undef DeclareCastMethod protected: // Add any type-specific state to |hash| and returns new hash. virtual size_t ComputeExtraStateHash(size_t hash, SeenTypes* seen) const = 0; protected: // Decorations attached to this type. Each decoration is encoded as a vector // of uint32_t numbers. The first uint32_t number is the decoration value, // and the rest are the parameters to the decoration (if any exist). // The parameters can be either all literals or all ids depending on the // decoration value. std::vector> decorations_; private: // Removes decorations on this type. For struct types, also removes element // decorations. virtual void ClearDecorations() { decorations_.clear(); } Kind kind_; }; // clang-format on class Integer : public Type { public: Integer(uint32_t w, bool is_signed) : Type(kInteger), width_(w), signed_(is_signed) {} Integer(const Integer&) = default; std::string str() const override; Integer* AsInteger() override { return this; } const Integer* AsInteger() const override { return this; } uint32_t width() const { return width_; } bool IsSigned() const { return signed_; } size_t ComputeExtraStateHash(size_t hash, SeenTypes* seen) const override; private: bool IsSameImpl(const Type* that, IsSameCache*) const override; uint32_t width_; // bit width bool signed_; // true if this integer is signed }; class Float : public Type { public: Float(uint32_t w) : Type(kFloat), width_(w) {} Float(const Float&) = default; std::string str() const override; Float* AsFloat() override { return this; } const Float* AsFloat() const override { return this; } uint32_t width() const { return width_; } size_t ComputeExtraStateHash(size_t hash, SeenTypes* seen) const override; private: bool IsSameImpl(const Type* that, IsSameCache*) const override; uint32_t width_; // bit width }; class Vector : public Type { public: Vector(const Type* element_type, uint32_t count); Vector(const Vector&) = default; std::string str() const override; const Type* element_type() const { return element_type_; } uint32_t element_count() const { return count_; } Vector* AsVector() override { return this; } const Vector* AsVector() const override { return this; } size_t ComputeExtraStateHash(size_t hash, SeenTypes* seen) const override; private: bool IsSameImpl(const Type* that, IsSameCache*) const override; const Type* element_type_; uint32_t count_; }; class Matrix : public Type { public: Matrix(const Type* element_type, uint32_t count); Matrix(const Matrix&) = default; std::string str() const override; const Type* element_type() const { return element_type_; } uint32_t element_count() const { return count_; } Matrix* AsMatrix() override { return this; } const Matrix* AsMatrix() const override { return this; } size_t ComputeExtraStateHash(size_t hash, SeenTypes* seen) const override; private: bool IsSameImpl(const Type* that, IsSameCache*) const override; const Type* element_type_; uint32_t count_; }; class Image : public Type { public: Image(Type* type, spv::Dim dimen, uint32_t d, bool array, bool multisample, uint32_t sampling, spv::ImageFormat f, spv::AccessQualifier qualifier = spv::AccessQualifier::ReadOnly); Image(const Image&) = default; std::string str() const override; Image* AsImage() override { return this; } const Image* AsImage() const override { return this; } const Type* sampled_type() const { return sampled_type_; } spv::Dim dim() const { return dim_; } uint32_t depth() const { return depth_; } bool is_arrayed() const { return arrayed_; } bool is_multisampled() const { return ms_; } uint32_t sampled() const { return sampled_; } spv::ImageFormat format() const { return format_; } spv::AccessQualifier access_qualifier() const { return access_qualifier_; } size_t ComputeExtraStateHash(size_t hash, SeenTypes* seen) const override; private: bool IsSameImpl(const Type* that, IsSameCache*) const override; Type* sampled_type_; spv::Dim dim_; uint32_t depth_; bool arrayed_; bool ms_; uint32_t sampled_; spv::ImageFormat format_; spv::AccessQualifier access_qualifier_; }; class SampledImage : public Type { public: SampledImage(Type* image) : Type(kSampledImage), image_type_(image) {} SampledImage(const SampledImage&) = default; std::string str() const override; SampledImage* AsSampledImage() override { return this; } const SampledImage* AsSampledImage() const override { return this; } const Type* image_type() const { return image_type_; } size_t ComputeExtraStateHash(size_t hash, SeenTypes* seen) const override; private: bool IsSameImpl(const Type* that, IsSameCache*) const override; Type* image_type_; }; class Array : public Type { public: // Data about the length operand, that helps us distinguish between one // array length and another. struct LengthInfo { // The result id of the instruction defining the length. const uint32_t id; enum Case : uint32_t { kConstant = 0, kConstantWithSpecId = 1, kDefiningId = 2 }; // Extra words used to distinshish one array length and another. // - if OpConstant, then it's 0, then the words in the literal constant // value. // - if OpSpecConstant, then it's 1, then the SpecID decoration if there // is one, followed by the words in the literal constant value. // The spec might not be overridden, in which case we'll end up using // the literal value. // - Otherwise, it's an OpSpecConsant, and this 2, then the ID (again). const std::vector words; }; // Constructs an array type with given element and length. If the length // is an OpSpecConstant, then |spec_id| should be its SpecId decoration. Array(const Type* element_type, const LengthInfo& length_info_arg); Array(const Array&) = default; std::string str() const override; const Type* element_type() const { return element_type_; } uint32_t LengthId() const { return length_info_.id; } const LengthInfo& length_info() const { return length_info_; } Array* AsArray() override { return this; } const Array* AsArray() const override { return this; } size_t ComputeExtraStateHash(size_t hash, SeenTypes* seen) const override; void ReplaceElementType(const Type* element_type); LengthInfo GetConstantLengthInfo(uint32_t const_id, uint32_t length) const; private: bool IsSameImpl(const Type* that, IsSameCache*) const override; const Type* element_type_; const LengthInfo length_info_; }; class RuntimeArray : public Type { public: RuntimeArray(const Type* element_type); RuntimeArray(const RuntimeArray&) = default; std::string str() const override; const Type* element_type() const { return element_type_; } RuntimeArray* AsRuntimeArray() override { return this; } const RuntimeArray* AsRuntimeArray() const override { return this; } size_t ComputeExtraStateHash(size_t hash, SeenTypes* seen) const override; void ReplaceElementType(const Type* element_type); private: bool IsSameImpl(const Type* that, IsSameCache*) const override; const Type* element_type_; }; class NodePayloadArrayAMDX : public Type { public: NodePayloadArrayAMDX(const Type* element_type); NodePayloadArrayAMDX(const NodePayloadArrayAMDX&) = default; std::string str() const override; const Type* element_type() const { return element_type_; } NodePayloadArrayAMDX* AsNodePayloadArrayAMDX() override { return this; } const NodePayloadArrayAMDX* AsNodePayloadArrayAMDX() const override { return this; } size_t ComputeExtraStateHash(size_t hash, SeenTypes* seen) const override; void ReplaceElementType(const Type* element_type); private: bool IsSameImpl(const Type* that, IsSameCache*) const override; const Type* element_type_; }; class Struct : public Type { public: Struct(const std::vector& element_types); Struct(const Struct&) = default; // Adds a decoration to the member at the given index. The first word is the // decoration enum, and the remaining words, if any, are its operands. void AddMemberDecoration(uint32_t index, std::vector&& decoration); std::string str() const override; const std::vector& element_types() const { return element_types_; } std::vector& element_types() { return element_types_; } bool decoration_empty() const override { return decorations_.empty() && element_decorations_.empty(); } const std::map>>& element_decorations() const { return element_decorations_; } Struct* AsStruct() override { return this; } const Struct* AsStruct() const override { return this; } size_t ComputeExtraStateHash(size_t hash, SeenTypes* seen) const override; private: bool IsSameImpl(const Type* that, IsSameCache*) const override; void ClearDecorations() override { decorations_.clear(); element_decorations_.clear(); } std::vector element_types_; // We can attach decorations to struct members and that should not affect the // underlying element type. So we need an extra data structure here to keep // track of element type decorations. They must be stored in an ordered map // because |GetExtraHashWords| will traverse the structure. It must have a // fixed order in order to hash to the same value every time. std::map>> element_decorations_; }; class Opaque : public Type { public: Opaque(std::string n) : Type(kOpaque), name_(std::move(n)) {} Opaque(const Opaque&) = default; std::string str() const override; Opaque* AsOpaque() override { return this; } const Opaque* AsOpaque() const override { return this; } const std::string& name() const { return name_; } size_t ComputeExtraStateHash(size_t hash, SeenTypes* seen) const override; private: bool IsSameImpl(const Type* that, IsSameCache*) const override; std::string name_; }; class Pointer : public Type { public: Pointer(const Type* pointee, spv::StorageClass sc); Pointer(const Pointer&) = default; std::string str() const override; const Type* pointee_type() const { return pointee_type_; } spv::StorageClass storage_class() const { return storage_class_; } Pointer* AsPointer() override { return this; } const Pointer* AsPointer() const override { return this; } size_t ComputeExtraStateHash(size_t hash, SeenTypes* seen) const override; void SetPointeeType(const Type* type); private: bool IsSameImpl(const Type* that, IsSameCache*) const override; const Type* pointee_type_; spv::StorageClass storage_class_; }; class Function : public Type { public: Function(const Type* ret_type, const std::vector& params); Function(const Type* ret_type, std::vector& params); Function(const Function&) = default; std::string str() const override; Function* AsFunction() override { return this; } const Function* AsFunction() const override { return this; } const Type* return_type() const { return return_type_; } const std::vector& param_types() const { return param_types_; } std::vector& param_types() { return param_types_; } size_t ComputeExtraStateHash(size_t hash, SeenTypes* seen) const override; void SetReturnType(const Type* type); private: bool IsSameImpl(const Type* that, IsSameCache*) const override; const Type* return_type_; std::vector param_types_; }; class Pipe : public Type { public: Pipe(spv::AccessQualifier qualifier) : Type(kPipe), access_qualifier_(qualifier) {} Pipe(const Pipe&) = default; std::string str() const override; Pipe* AsPipe() override { return this; } const Pipe* AsPipe() const override { return this; } spv::AccessQualifier access_qualifier() const { return access_qualifier_; } size_t ComputeExtraStateHash(size_t hash, SeenTypes* seen) const override; private: bool IsSameImpl(const Type* that, IsSameCache*) const override; spv::AccessQualifier access_qualifier_; }; class ForwardPointer : public Type { public: ForwardPointer(uint32_t id, spv::StorageClass sc) : Type(kForwardPointer), target_id_(id), storage_class_(sc), pointer_(nullptr) {} ForwardPointer(const ForwardPointer&) = default; uint32_t target_id() const { return target_id_; } void SetTargetPointer(const Pointer* pointer) { pointer_ = pointer; } spv::StorageClass storage_class() const { return storage_class_; } const Pointer* target_pointer() const { return pointer_; } std::string str() const override; ForwardPointer* AsForwardPointer() override { return this; } const ForwardPointer* AsForwardPointer() const override { return this; } size_t ComputeExtraStateHash(size_t hash, SeenTypes* seen) const override; private: bool IsSameImpl(const Type* that, IsSameCache*) const override; uint32_t target_id_; spv::StorageClass storage_class_; const Pointer* pointer_; }; class CooperativeMatrixNV : public Type { public: CooperativeMatrixNV(const Type* type, const uint32_t scope, const uint32_t rows, const uint32_t columns); CooperativeMatrixNV(const CooperativeMatrixNV&) = default; std::string str() const override; CooperativeMatrixNV* AsCooperativeMatrixNV() override { return this; } const CooperativeMatrixNV* AsCooperativeMatrixNV() const override { return this; } size_t ComputeExtraStateHash(size_t hash, SeenTypes* seen) const override; const Type* component_type() const { return component_type_; } uint32_t scope_id() const { return scope_id_; } uint32_t rows_id() const { return rows_id_; } uint32_t columns_id() const { return columns_id_; } private: bool IsSameImpl(const Type* that, IsSameCache*) const override; const Type* component_type_; const uint32_t scope_id_; const uint32_t rows_id_; const uint32_t columns_id_; }; class CooperativeMatrixKHR : public Type { public: CooperativeMatrixKHR(const Type* type, const uint32_t scope, const uint32_t rows, const uint32_t columns, const uint32_t use); CooperativeMatrixKHR(const CooperativeMatrixKHR&) = default; std::string str() const override; CooperativeMatrixKHR* AsCooperativeMatrixKHR() override { return this; } const CooperativeMatrixKHR* AsCooperativeMatrixKHR() const override { return this; } size_t ComputeExtraStateHash(size_t hash, SeenTypes* seen) const override; const Type* component_type() const { return component_type_; } uint32_t scope_id() const { return scope_id_; } uint32_t rows_id() const { return rows_id_; } uint32_t columns_id() const { return columns_id_; } uint32_t use_id() const { return use_id_; } private: bool IsSameImpl(const Type* that, IsSameCache*) const override; const Type* component_type_; const uint32_t scope_id_; const uint32_t rows_id_; const uint32_t columns_id_; const uint32_t use_id_; }; class TensorLayoutNV : public Type { public: TensorLayoutNV(const uint32_t dim, const uint32_t clamp_mode); TensorLayoutNV(const TensorLayoutNV&) = default; std::string str() const override; TensorLayoutNV* AsTensorLayoutNV() override { return this; } const TensorLayoutNV* AsTensorLayoutNV() const override { return this; } size_t ComputeExtraStateHash(size_t hash, SeenTypes* seen) const override; uint32_t dim_id() const { return dim_id_; } uint32_t clamp_mode_id() const { return clamp_mode_id_; } private: bool IsSameImpl(const Type* that, IsSameCache*) const override; const uint32_t dim_id_; const uint32_t clamp_mode_id_; }; class TensorViewNV : public Type { public: TensorViewNV(const uint32_t dim, const uint32_t clamp_mode, const std::vector& perm); TensorViewNV(const TensorViewNV&) = default; std::string str() const override; TensorViewNV* AsTensorViewNV() override { return this; } const TensorViewNV* AsTensorViewNV() const override { return this; } size_t ComputeExtraStateHash(size_t hash, SeenTypes* seen) const override; uint32_t dim_id() const { return dim_id_; } uint32_t has_dimensions_id() const { return has_dimensions_id_; } const std::vector& perm() const { return perm_; } private: bool IsSameImpl(const Type* that, IsSameCache*) const override; const uint32_t dim_id_; const uint32_t has_dimensions_id_; std::vector perm_; }; class CooperativeVectorNV : public Type { public: CooperativeVectorNV(const Type* type, const uint32_t components); CooperativeVectorNV(const CooperativeVectorNV&) = default; std::string str() const override; CooperativeVectorNV* AsCooperativeVectorNV() override { return this; } const CooperativeVectorNV* AsCooperativeVectorNV() const override { return this; } size_t ComputeExtraStateHash(size_t hash, SeenTypes* seen) const override; const Type* component_type() const { return component_type_; } uint32_t components() const { return components_; } private: bool IsSameImpl(const Type* that, IsSameCache*) const override; const Type* component_type_; const uint32_t components_; }; #define DefineParameterlessType(type, name) \ class type : public Type { \ public: \ type() : Type(k##type) {} \ type(const type&) = default; \ \ std::string str() const override { return #name; } \ \ type* As##type() override { return this; } \ const type* As##type() const override { return this; } \ \ size_t ComputeExtraStateHash(size_t hash, SeenTypes*) const override { \ return hash; \ } \ \ private: \ bool IsSameImpl(const Type* that, IsSameCache*) const override { \ return that->As##type() && HasSameDecorations(that); \ } \ } DefineParameterlessType(Void, void); DefineParameterlessType(Bool, bool); DefineParameterlessType(Sampler, sampler); DefineParameterlessType(Event, event); DefineParameterlessType(DeviceEvent, device_event); DefineParameterlessType(ReserveId, reserve_id); DefineParameterlessType(Queue, queue); DefineParameterlessType(PipeStorage, pipe_storage); DefineParameterlessType(NamedBarrier, named_barrier); DefineParameterlessType(AccelerationStructureNV, accelerationStructureNV); DefineParameterlessType(RayQueryKHR, rayQueryKHR); DefineParameterlessType(HitObjectNV, hitObjectNV); #undef DefineParameterlessType } // namespace analysis } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_TYPES_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/unify_const_pass.cpp000066400000000000000000000156241475742701700247350ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/unify_const_pass.h" #include #include #include #include #include "source/opt/def_use_manager.h" #include "source/util/make_unique.h" namespace spvtools { namespace opt { namespace { // The trie that stores a bunch of result ids and, for a given instruction, // searches the result id that has been defined with the same opcode, type and // operands. class ResultIdTrie { public: ResultIdTrie() : root_(new Node) {} // For a given instruction, extracts its opcode, type id and operand words // as an array of keys, looks up the trie to find a result id which is stored // with the same opcode, type id and operand words. If none of such result id // is found, creates a trie node with those keys, stores the instruction's // result id and returns that result id. If an existing result id is found, // returns the existing result id. uint32_t LookupEquivalentResultFor(const Instruction& inst) { auto keys = GetLookUpKeys(inst); auto* node = root_.get(); for (uint32_t key : keys) { node = node->GetOrCreateTrieNodeFor(key); } if (node->result_id() == 0) { node->SetResultId(inst.result_id()); } return node->result_id(); } private: // The trie node to store result ids. class Node { public: using TrieNodeMap = std::unordered_map>; Node() : result_id_(0), next_() {} uint32_t result_id() const { return result_id_; } // Sets the result id stored in this node. void SetResultId(uint32_t id) { result_id_ = id; } // Searches for the child trie node with the given key. If the node is // found, returns that node. Otherwise creates an empty child node with // that key and returns that newly created node. Node* GetOrCreateTrieNodeFor(uint32_t key) { auto iter = next_.find(key); if (iter == next_.end()) { // insert a new node and return the node. return next_.insert(std::make_pair(key, MakeUnique())) .first->second.get(); } return iter->second.get(); } private: // The result id stored in this node. 0 means this node is empty. uint32_t result_id_; // The mapping from the keys to the child nodes of this node. TrieNodeMap next_; }; // Returns a vector of the opcode followed by the words in the raw SPIR-V // instruction encoding but without the result id. std::vector GetLookUpKeys(const Instruction& inst) { std::vector keys; // Need to use the opcode, otherwise there might be a conflict with the // following case when 's binary value equals xx's id: // OpSpecConstantOp tt yy zz // OpSpecConstantComposite tt xx yy zz; keys.push_back(static_cast(inst.opcode())); for (const auto& operand : inst) { if (operand.type == SPV_OPERAND_TYPE_RESULT_ID) continue; keys.insert(keys.end(), operand.words.cbegin(), operand.words.cend()); } return keys; } std::unique_ptr root_; // The root node of the trie. }; } // namespace Pass::Status UnifyConstantPass::Process() { bool modified = false; ResultIdTrie defined_constants; for (Instruction *next_instruction, *inst = &*(context()->types_values_begin()); inst; inst = next_instruction) { next_instruction = inst->NextNode(); // Do not handle the instruction when there are decorations upon the result // id. if (get_def_use_mgr()->GetAnnotations(inst->result_id()).size() != 0) { continue; } // The overall algorithm is to store the result ids of all the eligible // constants encountered so far in a trie. For a constant defining // instruction under consideration, use its opcode, result type id and // words in operands as an array of keys to lookup the trie. If a result id // can be found for that array of keys, a constant with exactly the same // value must has been defined before, the constant under processing // should be replaced by the constant previously defined. If no such result // id can be found for that array of keys, this must be the first time a // constant with its value be defined, we then create a new trie node to // store the result id with the keys. When replacing a duplicated constant // with a previously defined constant, all the uses of the duplicated // constant, which must be placed after the duplicated constant defining // instruction, will be updated. This way, the descendants of the // previously defined constant and the duplicated constant will both refer // to the previously defined constant. So that the operand ids which are // used in key arrays will be the ids of the unified constants, when // processing is up to a descendant. This makes comparing the key array // always valid for judging duplication. switch (inst->opcode()) { case spv::Op::OpConstantTrue: case spv::Op::OpConstantFalse: case spv::Op::OpConstant: case spv::Op::OpConstantNull: case spv::Op::OpConstantSampler: case spv::Op::OpConstantComposite: // Only spec constants defined with OpSpecConstantOp and // OpSpecConstantComposite should be processed in this pass. Spec // constants defined with OpSpecConstant{|True|False} are decorated with // 'SpecId' decoration and all of them should be treated as unique. // 'SpecId' is not applicable to SpecConstants defined with // OpSpecConstant{Op|Composite}, their values are not necessary to be // unique. When all the operands/components are the same between two // OpSpecConstant{Op|Composite} results, their result values must be the // same so are unifiable. case spv::Op::OpSpecConstantOp: case spv::Op::OpSpecConstantComposite: { uint32_t id = defined_constants.LookupEquivalentResultFor(*inst); if (id != inst->result_id()) { // The constant is a duplicated one, use the cached constant to // replace the uses of this duplicated one, then turn it to nop. context()->ReplaceAllUsesWith(inst->result_id(), id); context()->KillInst(inst); modified = true; } break; } default: break; } } return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/unify_const_pass.h000066400000000000000000000020661475742701700243760ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_UNIFY_CONST_PASS_H_ #define SOURCE_OPT_UNIFY_CONST_PASS_H_ #include "source/opt/ir_context.h" #include "source/opt/module.h" #include "source/opt/pass.h" namespace spvtools { namespace opt { // See optimizer.hpp for documentation. class UnifyConstantPass : public Pass { public: const char* name() const override { return "unify-const"; } Status Process() override; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_UNIFY_CONST_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/upgrade_memory_model.cpp000066400000000000000000000753231475742701700255500ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "upgrade_memory_model.h" #include #include "source/opt/ir_builder.h" #include "source/opt/ir_context.h" #include "source/spirv_constant.h" #include "source/util/make_unique.h" #include "source/util/string_utils.h" namespace spvtools { namespace opt { Pass::Status UpgradeMemoryModel::Process() { // TODO: This pass needs changes to support cooperative matrices. if (context()->get_feature_mgr()->HasCapability( spv::Capability::CooperativeMatrixNV)) { return Pass::Status::SuccessWithoutChange; } // Only update Logical GLSL450 to Logical VulkanKHR. Instruction* memory_model = get_module()->GetMemoryModel(); if (memory_model->GetSingleWordInOperand(0u) != uint32_t(spv::AddressingModel::Logical) || memory_model->GetSingleWordInOperand(1u) != uint32_t(spv::MemoryModel::GLSL450)) { return Pass::Status::SuccessWithoutChange; } UpgradeMemoryModelInstruction(); UpgradeInstructions(); CleanupDecorations(); UpgradeBarriers(); UpgradeMemoryScope(); return Pass::Status::SuccessWithChange; } void UpgradeMemoryModel::UpgradeMemoryModelInstruction() { // Overall changes necessary: // 1. Add the OpExtension. // 2. Add the OpCapability. // 3. Modify the memory model. Instruction* memory_model = get_module()->GetMemoryModel(); context()->AddCapability(MakeUnique( context(), spv::Op::OpCapability, 0, 0, std::initializer_list{ {SPV_OPERAND_TYPE_CAPABILITY, {uint32_t(spv::Capability::VulkanMemoryModelKHR)}}})); const std::string extension = "SPV_KHR_vulkan_memory_model"; std::vector words = spvtools::utils::MakeVector(extension); context()->AddExtension( MakeUnique(context(), spv::Op::OpExtension, 0, 0, std::initializer_list{ {SPV_OPERAND_TYPE_LITERAL_STRING, words}})); memory_model->SetInOperand(1u, {uint32_t(spv::MemoryModel::VulkanKHR)}); } void UpgradeMemoryModel::UpgradeInstructions() { // Coherent and Volatile decorations are deprecated. Remove them and replace // with flags on the memory/image operations. The decorations can occur on // OpVariable, OpFunctionParameter (of pointer type) and OpStructType (member // decoration). Trace from the decoration target(s) to the final memory/image // instructions. Additionally, Workgroup storage class variables and function // parameters are implicitly coherent in GLSL450. // Upgrade modf and frexp first since they generate new stores. // In SPIR-V 1.4 or later, normalize OpCopyMemory* access operands. for (auto& func : *get_module()) { func.ForEachInst([this](Instruction* inst) { if (inst->opcode() == spv::Op::OpExtInst) { auto ext_inst = inst->GetSingleWordInOperand(1u); if (ext_inst == GLSLstd450Modf || ext_inst == GLSLstd450Frexp) { auto import = get_def_use_mgr()->GetDef(inst->GetSingleWordInOperand(0u)); if (import->GetInOperand(0u).AsString() == "GLSL.std.450") { UpgradeExtInst(inst); } } } else if (get_module()->version() >= SPV_SPIRV_VERSION_WORD(1, 4)) { if (inst->opcode() == spv::Op::OpCopyMemory || inst->opcode() == spv::Op::OpCopyMemorySized) { uint32_t start_operand = inst->opcode() == spv::Op::OpCopyMemory ? 2u : 3u; if (inst->NumInOperands() > start_operand) { auto num_access_words = MemoryAccessNumWords( inst->GetSingleWordInOperand(start_operand)); if ((num_access_words + start_operand) == inst->NumInOperands()) { // There is a single memory access operand. Duplicate it to have a // separate operand for both source and target. for (uint32_t i = 0; i < num_access_words; ++i) { auto operand = inst->GetInOperand(start_operand + i); inst->AddOperand(std::move(operand)); } } } else { // Add two memory access operands. inst->AddOperand({SPV_OPERAND_TYPE_MEMORY_ACCESS, {uint32_t(spv::MemoryAccessMask::MaskNone)}}); inst->AddOperand({SPV_OPERAND_TYPE_MEMORY_ACCESS, {uint32_t(spv::MemoryAccessMask::MaskNone)}}); } } } }); } UpgradeMemoryAndImages(); UpgradeAtomics(); } void UpgradeMemoryModel::UpgradeMemoryAndImages() { for (auto& func : *get_module()) { func.ForEachInst([this](Instruction* inst) { bool is_coherent = false; bool is_volatile = false; bool src_coherent = false; bool src_volatile = false; bool dst_coherent = false; bool dst_volatile = false; uint32_t start_operand = 0u; spv::Scope scope = spv::Scope::QueueFamilyKHR; spv::Scope src_scope = spv::Scope::QueueFamilyKHR; spv::Scope dst_scope = spv::Scope::QueueFamilyKHR; switch (inst->opcode()) { case spv::Op::OpLoad: case spv::Op::OpStore: std::tie(is_coherent, is_volatile, scope) = GetInstructionAttributes(inst->GetSingleWordInOperand(0u)); break; case spv::Op::OpImageRead: case spv::Op::OpImageSparseRead: case spv::Op::OpImageWrite: std::tie(is_coherent, is_volatile, scope) = GetInstructionAttributes(inst->GetSingleWordInOperand(0u)); break; case spv::Op::OpCopyMemory: case spv::Op::OpCopyMemorySized: std::tie(dst_coherent, dst_volatile, dst_scope) = GetInstructionAttributes(inst->GetSingleWordInOperand(0u)); std::tie(src_coherent, src_volatile, src_scope) = GetInstructionAttributes(inst->GetSingleWordInOperand(1u)); break; default: break; } switch (inst->opcode()) { case spv::Op::OpLoad: UpgradeFlags(inst, 1u, is_coherent, is_volatile, kVisibility, kMemory); break; case spv::Op::OpStore: UpgradeFlags(inst, 2u, is_coherent, is_volatile, kAvailability, kMemory); break; case spv::Op::OpCopyMemory: case spv::Op::OpCopyMemorySized: start_operand = inst->opcode() == spv::Op::OpCopyMemory ? 2u : 3u; if (get_module()->version() >= SPV_SPIRV_VERSION_WORD(1, 4)) { // There are guaranteed to be two memory access operands at this // point so treat source and target separately. uint32_t num_access_words = MemoryAccessNumWords( inst->GetSingleWordInOperand(start_operand)); UpgradeFlags(inst, start_operand, dst_coherent, dst_volatile, kAvailability, kMemory); UpgradeFlags(inst, start_operand + num_access_words, src_coherent, src_volatile, kVisibility, kMemory); } else { UpgradeFlags(inst, start_operand, dst_coherent, dst_volatile, kAvailability, kMemory); UpgradeFlags(inst, start_operand, src_coherent, src_volatile, kVisibility, kMemory); } break; case spv::Op::OpImageRead: case spv::Op::OpImageSparseRead: UpgradeFlags(inst, 2u, is_coherent, is_volatile, kVisibility, kImage); break; case spv::Op::OpImageWrite: UpgradeFlags(inst, 3u, is_coherent, is_volatile, kAvailability, kImage); break; default: break; } // |is_coherent| is never used for the same instructions as // |src_coherent| and |dst_coherent|. if (is_coherent) { inst->AddOperand( {SPV_OPERAND_TYPE_SCOPE_ID, {GetScopeConstant(scope)}}); } if (get_module()->version() >= SPV_SPIRV_VERSION_WORD(1, 4)) { // There are two memory access operands. The first is for the target and // the second is for the source. if (dst_coherent || src_coherent) { start_operand = inst->opcode() == spv::Op::OpCopyMemory ? 2u : 3u; std::vector new_operands; uint32_t num_access_words = MemoryAccessNumWords(inst->GetSingleWordInOperand(start_operand)); // The flags were already updated so subtract if we're adding a // scope. if (dst_coherent) --num_access_words; for (uint32_t i = 0; i < start_operand + num_access_words; ++i) { new_operands.push_back(inst->GetInOperand(i)); } // Add the target scope if necessary. if (dst_coherent) { new_operands.push_back( {SPV_OPERAND_TYPE_SCOPE_ID, {GetScopeConstant(dst_scope)}}); } // Copy the remaining current operands. for (uint32_t i = start_operand + num_access_words; i < inst->NumInOperands(); ++i) { new_operands.push_back(inst->GetInOperand(i)); } // Add the source scope if necessary. if (src_coherent) { new_operands.push_back( {SPV_OPERAND_TYPE_SCOPE_ID, {GetScopeConstant(src_scope)}}); } inst->SetInOperands(std::move(new_operands)); } } else { // According to SPV_KHR_vulkan_memory_model, if both available and // visible flags are used the first scope operand is for availability // (writes) and the second is for visibility (reads). if (dst_coherent) { inst->AddOperand( {SPV_OPERAND_TYPE_SCOPE_ID, {GetScopeConstant(dst_scope)}}); } if (src_coherent) { inst->AddOperand( {SPV_OPERAND_TYPE_SCOPE_ID, {GetScopeConstant(src_scope)}}); } } }); } } void UpgradeMemoryModel::UpgradeAtomics() { for (auto& func : *get_module()) { func.ForEachInst([this](Instruction* inst) { if (spvOpcodeIsAtomicOp(inst->opcode())) { bool unused_coherent = false; bool is_volatile = false; spv::Scope unused_scope = spv::Scope::QueueFamilyKHR; std::tie(unused_coherent, is_volatile, unused_scope) = GetInstructionAttributes(inst->GetSingleWordInOperand(0)); UpgradeSemantics(inst, 2u, is_volatile); if (inst->opcode() == spv::Op::OpAtomicCompareExchange || inst->opcode() == spv::Op::OpAtomicCompareExchangeWeak) { UpgradeSemantics(inst, 3u, is_volatile); } } }); } } void UpgradeMemoryModel::UpgradeSemantics(Instruction* inst, uint32_t in_operand, bool is_volatile) { if (!is_volatile) return; uint32_t semantics_id = inst->GetSingleWordInOperand(in_operand); const analysis::Constant* constant = context()->get_constant_mgr()->FindDeclaredConstant(semantics_id); const analysis::Integer* type = constant->type()->AsInteger(); assert(type && type->width() == 32); uint32_t value = 0; if (type->IsSigned()) { value = static_cast(constant->GetS32()); } else { value = constant->GetU32(); } value |= uint32_t(spv::MemorySemanticsMask::Volatile); auto new_constant = context()->get_constant_mgr()->GetConstant(type, {value}); auto new_semantics = context()->get_constant_mgr()->GetDefiningInstruction(new_constant); inst->SetInOperand(in_operand, {new_semantics->result_id()}); } std::tuple UpgradeMemoryModel::GetInstructionAttributes( uint32_t id) { // |id| is a pointer used in a memory/image instruction. Need to determine if // that pointer points to volatile or coherent memory. Workgroup storage // class is implicitly coherent and cannot be decorated with volatile, so // short circuit that case. Instruction* inst = context()->get_def_use_mgr()->GetDef(id); analysis::Type* type = context()->get_type_mgr()->GetType(inst->type_id()); if (type->AsPointer() && type->AsPointer()->storage_class() == spv::StorageClass::Workgroup) { return std::make_tuple(true, false, spv::Scope::Workgroup); } bool is_coherent = false; bool is_volatile = false; std::unordered_set visited; std::tie(is_coherent, is_volatile) = TraceInstruction(context()->get_def_use_mgr()->GetDef(id), std::vector(), &visited); return std::make_tuple(is_coherent, is_volatile, spv::Scope::QueueFamilyKHR); } std::pair UpgradeMemoryModel::TraceInstruction( Instruction* inst, std::vector indices, std::unordered_set* visited) { auto iter = cache_.find(std::make_pair(inst->result_id(), indices)); if (iter != cache_.end()) { return iter->second; } if (!visited->insert(inst->result_id()).second) { return std::make_pair(false, false); } // Initialize the cache before |indices| is (potentially) modified. auto& cached_result = cache_[std::make_pair(inst->result_id(), indices)]; cached_result.first = false; cached_result.second = false; bool is_coherent = false; bool is_volatile = false; switch (inst->opcode()) { case spv::Op::OpVariable: case spv::Op::OpFunctionParameter: is_coherent |= HasDecoration(inst, 0, spv::Decoration::Coherent); is_volatile |= HasDecoration(inst, 0, spv::Decoration::Volatile); if (!is_coherent || !is_volatile) { bool type_coherent = false; bool type_volatile = false; std::tie(type_coherent, type_volatile) = CheckType(inst->type_id(), indices); is_coherent |= type_coherent; is_volatile |= type_volatile; } break; case spv::Op::OpAccessChain: case spv::Op::OpInBoundsAccessChain: // Store indices in reverse order. for (uint32_t i = inst->NumInOperands() - 1; i > 0; --i) { indices.push_back(inst->GetSingleWordInOperand(i)); } break; case spv::Op::OpPtrAccessChain: // Store indices in reverse order. Skip the |Element| operand. for (uint32_t i = inst->NumInOperands() - 1; i > 1; --i) { indices.push_back(inst->GetSingleWordInOperand(i)); } break; default: break; } // No point searching further. if (is_coherent && is_volatile) { cached_result.first = true; cached_result.second = true; return std::make_pair(true, true); } // Variables and function parameters are sources. Continue searching until we // reach them. if (inst->opcode() != spv::Op::OpVariable && inst->opcode() != spv::Op::OpFunctionParameter) { inst->ForEachInId([this, &is_coherent, &is_volatile, &indices, &visited](const uint32_t* id_ptr) { Instruction* op_inst = context()->get_def_use_mgr()->GetDef(*id_ptr); const analysis::Type* type = context()->get_type_mgr()->GetType(op_inst->type_id()); if (type && (type->AsPointer() || type->AsImage() || type->AsSampledImage())) { bool operand_coherent = false; bool operand_volatile = false; std::tie(operand_coherent, operand_volatile) = TraceInstruction(op_inst, indices, visited); is_coherent |= operand_coherent; is_volatile |= operand_volatile; } }); } cached_result.first = is_coherent; cached_result.second = is_volatile; return std::make_pair(is_coherent, is_volatile); } std::pair UpgradeMemoryModel::CheckType( uint32_t type_id, const std::vector& indices) { bool is_coherent = false; bool is_volatile = false; Instruction* type_inst = context()->get_def_use_mgr()->GetDef(type_id); assert(type_inst->opcode() == spv::Op::OpTypePointer); Instruction* element_inst = context()->get_def_use_mgr()->GetDef( type_inst->GetSingleWordInOperand(1u)); for (int i = (int)indices.size() - 1; i >= 0; --i) { if (is_coherent && is_volatile) break; if (element_inst->opcode() == spv::Op::OpTypePointer) { element_inst = context()->get_def_use_mgr()->GetDef( element_inst->GetSingleWordInOperand(1u)); } else if (element_inst->opcode() == spv::Op::OpTypeStruct) { uint32_t index = indices.at(i); Instruction* index_inst = context()->get_def_use_mgr()->GetDef(index); assert(index_inst->opcode() == spv::Op::OpConstant); uint64_t value = GetIndexValue(index_inst); is_coherent |= HasDecoration(element_inst, static_cast(value), spv::Decoration::Coherent); is_volatile |= HasDecoration(element_inst, static_cast(value), spv::Decoration::Volatile); element_inst = context()->get_def_use_mgr()->GetDef( element_inst->GetSingleWordInOperand(static_cast(value))); } else { assert(spvOpcodeIsComposite(element_inst->opcode())); element_inst = context()->get_def_use_mgr()->GetDef( element_inst->GetSingleWordInOperand(0u)); } } if (!is_coherent || !is_volatile) { bool remaining_coherent = false; bool remaining_volatile = false; std::tie(remaining_coherent, remaining_volatile) = CheckAllTypes(element_inst); is_coherent |= remaining_coherent; is_volatile |= remaining_volatile; } return std::make_pair(is_coherent, is_volatile); } std::pair UpgradeMemoryModel::CheckAllTypes( const Instruction* inst) { std::unordered_set visited; std::vector stack; stack.push_back(inst); bool is_coherent = false; bool is_volatile = false; while (!stack.empty()) { const Instruction* def = stack.back(); stack.pop_back(); if (!visited.insert(def).second) continue; if (def->opcode() == spv::Op::OpTypeStruct) { // Any member decorated with coherent and/or volatile is enough to have // the related operation be flagged as coherent and/or volatile. is_coherent |= HasDecoration(def, std::numeric_limits::max(), spv::Decoration::Coherent); is_volatile |= HasDecoration(def, std::numeric_limits::max(), spv::Decoration::Volatile); if (is_coherent && is_volatile) return std::make_pair(is_coherent, is_volatile); // Check the subtypes. for (uint32_t i = 0; i < def->NumInOperands(); ++i) { stack.push_back(context()->get_def_use_mgr()->GetDef( def->GetSingleWordInOperand(i))); } } else if (spvOpcodeIsComposite(def->opcode())) { stack.push_back(context()->get_def_use_mgr()->GetDef( def->GetSingleWordInOperand(0u))); } else if (def->opcode() == spv::Op::OpTypePointer) { stack.push_back(context()->get_def_use_mgr()->GetDef( def->GetSingleWordInOperand(1u))); } } return std::make_pair(is_coherent, is_volatile); } uint64_t UpgradeMemoryModel::GetIndexValue(Instruction* index_inst) { const analysis::Constant* index_constant = context()->get_constant_mgr()->GetConstantFromInst(index_inst); assert(index_constant->AsIntConstant()); if (index_constant->type()->AsInteger()->IsSigned()) { if (index_constant->type()->AsInteger()->width() == 32) { return index_constant->GetS32(); } else { return index_constant->GetS64(); } } else { if (index_constant->type()->AsInteger()->width() == 32) { return index_constant->GetU32(); } else { return index_constant->GetU64(); } } } bool UpgradeMemoryModel::HasDecoration(const Instruction* inst, uint32_t value, spv::Decoration decoration) { // If the iteration was terminated early then an appropriate decoration was // found. return !context()->get_decoration_mgr()->WhileEachDecoration( inst->result_id(), (uint32_t)decoration, [value](const Instruction& i) { if (i.opcode() == spv::Op::OpDecorate || i.opcode() == spv::Op::OpDecorateId) { return false; } else if (i.opcode() == spv::Op::OpMemberDecorate) { if (value == i.GetSingleWordInOperand(1u) || value == std::numeric_limits::max()) return false; } return true; }); } void UpgradeMemoryModel::UpgradeFlags(Instruction* inst, uint32_t in_operand, bool is_coherent, bool is_volatile, OperationType operation_type, InstructionType inst_type) { if (!is_coherent && !is_volatile) return; uint32_t flags = 0; if (inst->NumInOperands() > in_operand) { flags |= inst->GetSingleWordInOperand(in_operand); } if (is_coherent) { if (inst_type == kMemory) { flags |= uint32_t(spv::MemoryAccessMask::NonPrivatePointerKHR); if (operation_type == kVisibility) { flags |= uint32_t(spv::MemoryAccessMask::MakePointerVisibleKHR); } else { flags |= uint32_t(spv::MemoryAccessMask::MakePointerAvailableKHR); } } else { flags |= uint32_t(spv::ImageOperandsMask::NonPrivateTexelKHR); if (operation_type == kVisibility) { flags |= uint32_t(spv::ImageOperandsMask::MakeTexelVisibleKHR); } else { flags |= uint32_t(spv::ImageOperandsMask::MakeTexelAvailableKHR); } } } if (is_volatile) { if (inst_type == kMemory) { flags |= uint32_t(spv::MemoryAccessMask::Volatile); } else { flags |= uint32_t(spv::ImageOperandsMask::VolatileTexelKHR); } } if (inst->NumInOperands() > in_operand) { inst->SetInOperand(in_operand, {flags}); } else if (inst_type == kMemory) { inst->AddOperand({SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS, {flags}}); } else { inst->AddOperand({SPV_OPERAND_TYPE_OPTIONAL_IMAGE, {flags}}); } } uint32_t UpgradeMemoryModel::GetScopeConstant(spv::Scope scope) { analysis::Integer int_ty(32, false); uint32_t int_id = context()->get_type_mgr()->GetTypeInstruction(&int_ty); const analysis::Constant* constant = context()->get_constant_mgr()->GetConstant( context()->get_type_mgr()->GetType(int_id), {static_cast(scope)}); return context() ->get_constant_mgr() ->GetDefiningInstruction(constant) ->result_id(); } void UpgradeMemoryModel::CleanupDecorations() { // All of the volatile and coherent decorations have been dealt with, so now // we can just remove them. get_module()->ForEachInst([this](Instruction* inst) { if (inst->result_id() != 0) { context()->get_decoration_mgr()->RemoveDecorationsFrom( inst->result_id(), [](const Instruction& dec) { switch (dec.opcode()) { case spv::Op::OpDecorate: case spv::Op::OpDecorateId: if (spv::Decoration(dec.GetSingleWordInOperand(1u)) == spv::Decoration::Coherent || spv::Decoration(dec.GetSingleWordInOperand(1u)) == spv::Decoration::Volatile) return true; break; case spv::Op::OpMemberDecorate: if (spv::Decoration(dec.GetSingleWordInOperand(2u)) == spv::Decoration::Coherent || spv::Decoration(dec.GetSingleWordInOperand(2u)) == spv::Decoration::Volatile) return true; break; default: break; } return false; }); } }); } void UpgradeMemoryModel::UpgradeBarriers() { std::vector barriers; // Collects all the control barriers in |function|. Returns true if the // function operates on the Output storage class. ProcessFunction CollectBarriers = [this, &barriers](Function* function) { bool operates_on_output = false; for (auto& block : *function) { block.ForEachInst([this, &barriers, &operates_on_output](Instruction* inst) { if (inst->opcode() == spv::Op::OpControlBarrier) { barriers.push_back(inst); } else if (!operates_on_output) { // This instruction operates on output storage class if it is a // pointer to output type or any input operand is a pointer to output // type. analysis::Type* type = context()->get_type_mgr()->GetType(inst->type_id()); if (type && type->AsPointer() && type->AsPointer()->storage_class() == spv::StorageClass::Output) { operates_on_output = true; return; } inst->ForEachInId([this, &operates_on_output](uint32_t* id_ptr) { Instruction* op_inst = context()->get_def_use_mgr()->GetDef(*id_ptr); analysis::Type* op_type = context()->get_type_mgr()->GetType(op_inst->type_id()); if (op_type && op_type->AsPointer() && op_type->AsPointer()->storage_class() == spv::StorageClass::Output) operates_on_output = true; }); } }); } return operates_on_output; }; std::queue roots; for (auto& e : get_module()->entry_points()) if (spv::ExecutionModel(e.GetSingleWordInOperand(0u)) == spv::ExecutionModel::TessellationControl) { roots.push(e.GetSingleWordInOperand(1u)); if (context()->ProcessCallTreeFromRoots(CollectBarriers, &roots)) { for (auto barrier : barriers) { // Add OutputMemoryKHR to the semantics of the barriers. uint32_t semantics_id = barrier->GetSingleWordInOperand(2u); Instruction* semantics_inst = context()->get_def_use_mgr()->GetDef(semantics_id); analysis::Type* semantics_type = context()->get_type_mgr()->GetType(semantics_inst->type_id()); uint64_t semantics_value = GetIndexValue(semantics_inst); const analysis::Constant* constant = context()->get_constant_mgr()->GetConstant( semantics_type, {static_cast(semantics_value) | uint32_t(spv::MemorySemanticsMask::OutputMemoryKHR)}); barrier->SetInOperand(2u, {context() ->get_constant_mgr() ->GetDefiningInstruction(constant) ->result_id()}); } } barriers.clear(); } } void UpgradeMemoryModel::UpgradeMemoryScope() { get_module()->ForEachInst([this](Instruction* inst) { // Don't need to handle all the operations that take a scope. // * Group operations can only be subgroup // * Non-uniform can only be workgroup or subgroup // * Named barriers are not supported by Vulkan // * Workgroup ops (e.g. async_copy) have at most workgroup scope. if (spvOpcodeIsAtomicOp(inst->opcode())) { if (IsDeviceScope(inst->GetSingleWordInOperand(1))) { inst->SetInOperand(1, {GetScopeConstant(spv::Scope::QueueFamilyKHR)}); } } else if (inst->opcode() == spv::Op::OpControlBarrier) { if (IsDeviceScope(inst->GetSingleWordInOperand(1))) { inst->SetInOperand(1, {GetScopeConstant(spv::Scope::QueueFamilyKHR)}); } } else if (inst->opcode() == spv::Op::OpMemoryBarrier) { if (IsDeviceScope(inst->GetSingleWordInOperand(0))) { inst->SetInOperand(0, {GetScopeConstant(spv::Scope::QueueFamilyKHR)}); } } }); } bool UpgradeMemoryModel::IsDeviceScope(uint32_t scope_id) { const analysis::Constant* constant = context()->get_constant_mgr()->FindDeclaredConstant(scope_id); assert(constant && "Memory scope must be a constant"); const analysis::Integer* type = constant->type()->AsInteger(); assert(type); assert(type->width() == 32 || type->width() == 64); if (type->width() == 32) { if (type->IsSigned()) return static_cast(constant->GetS32()) == spv::Scope::Device; else return static_cast(constant->GetU32()) == spv::Scope::Device; } else { if (type->IsSigned()) return static_cast(constant->GetS64()) == spv::Scope::Device; else return static_cast(constant->GetU64()) == spv::Scope::Device; } assert(false); return false; } void UpgradeMemoryModel::UpgradeExtInst(Instruction* ext_inst) { const bool is_modf = ext_inst->GetSingleWordInOperand(1u) == GLSLstd450Modf; auto ptr_id = ext_inst->GetSingleWordInOperand(3u); auto ptr_type_id = get_def_use_mgr()->GetDef(ptr_id)->type_id(); auto pointee_type_id = get_def_use_mgr()->GetDef(ptr_type_id)->GetSingleWordInOperand(1u); auto element_type_id = ext_inst->type_id(); std::vector element_types(2); element_types[0] = context()->get_type_mgr()->GetType(element_type_id); element_types[1] = context()->get_type_mgr()->GetType(pointee_type_id); analysis::Struct struct_type(element_types); uint32_t struct_id = context()->get_type_mgr()->GetTypeInstruction(&struct_type); // Change the operation GLSLstd450 new_op = is_modf ? GLSLstd450ModfStruct : GLSLstd450FrexpStruct; ext_inst->SetOperand(3u, {static_cast(new_op)}); // Remove the pointer argument ext_inst->RemoveOperand(5u); // Set the type id to the new struct. ext_inst->SetResultType(struct_id); // The result is now a struct of the original result. The zero'th element is // old result and should replace the old result. The one'th element needs to // be stored via a new instruction. auto where = ext_inst->NextNode(); InstructionBuilder builder( context(), where, IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); auto extract_0 = builder.AddCompositeExtract(element_type_id, ext_inst->result_id(), {0}); context()->ReplaceAllUsesWith(ext_inst->result_id(), extract_0->result_id()); // The extract's input was just changed to itself, so fix that. extract_0->SetInOperand(0u, {ext_inst->result_id()}); auto extract_1 = builder.AddCompositeExtract(pointee_type_id, ext_inst->result_id(), {1}); builder.AddStore(ptr_id, extract_1->result_id()); } uint32_t UpgradeMemoryModel::MemoryAccessNumWords(uint32_t mask) { uint32_t result = 1; if (mask & uint32_t(spv::MemoryAccessMask::Aligned)) ++result; if (mask & uint32_t(spv::MemoryAccessMask::MakePointerAvailableKHR)) ++result; if (mask & uint32_t(spv::MemoryAccessMask::MakePointerVisibleKHR)) ++result; return result; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/upgrade_memory_model.h000066400000000000000000000135701475742701700252110ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef LIBSPIRV_OPT_UPGRADE_MEMORY_MODEL_H_ #define LIBSPIRV_OPT_UPGRADE_MEMORY_MODEL_H_ #include #include #include "pass.h" namespace spvtools { namespace opt { // Hashing functor for the memoized result store. struct CacheHash { size_t operator()( const std::pair>& item) const { std::u32string to_hash; to_hash.push_back(item.first); for (auto i : item.second) to_hash.push_back(i); return std::hash()(to_hash); } }; // Upgrades the memory model from Logical GLSL450 to Logical VulkanKHR. // // This pass remove deprecated decorations (Volatile and Coherent) and replaces // them with new flags on individual instructions. It adds the Output storage // class semantic to control barriers in tessellation control shaders that have // an access to Output memory. class UpgradeMemoryModel : public Pass { public: const char* name() const override { return "upgrade-memory-model"; } Status Process() override; private: // Used to indicate whether the operation performs an availability or // visibility operation. enum OperationType { kVisibility, kAvailability }; // Used to indicate whether the instruction is a memory or image instruction. enum InstructionType { kMemory, kImage }; // Modifies the OpMemoryModel to use VulkanKHR. Adds the Vulkan memory model // capability and extension. void UpgradeMemoryModelInstruction(); // Upgrades memory, image and atomic instructions. // Memory and image instructions convert coherent and volatile decorations // into flags on the instruction. // Atomic memory semantics convert volatile decoration into flags on the // instruction. void UpgradeInstructions(); // Upgrades memory and image operands for instructions that have them. void UpgradeMemoryAndImages(); // Adds the volatile memory semantic if necessary. void UpgradeAtomics(); // Returns whether |id| is coherent and/or volatile. std::tuple GetInstructionAttributes(uint32_t id); // Traces |inst| to determine if it is coherent and/or volatile. // |indices| tracks the access chain indices seen so far. std::pair TraceInstruction(Instruction* inst, std::vector indices, std::unordered_set* visited); // Return true if |inst| is decorated with |decoration|. // If |inst| is decorated by member decorations then either |value| must // match the index or |value| must be a maximum allowable value. The max // value allows any element to match. bool HasDecoration(const Instruction* inst, uint32_t value, spv::Decoration decoration); // Returns whether |type_id| indexed via |indices| is coherent and/or // volatile. std::pair CheckType(uint32_t type_id, const std::vector& indices); // Returns whether any type/element under |inst| is coherent and/or volatile. std::pair CheckAllTypes(const Instruction* inst); // Modifies the flags of |inst| to include the new flags for the Vulkan // memory model. |operation_type| indicates whether flags should use // MakeVisible or MakeAvailable variants. |inst_type| indicates whether the // Pointer or Texel variants of flags should be used. void UpgradeFlags(Instruction* inst, uint32_t in_operand, bool is_coherent, bool is_volatile, OperationType operation_type, InstructionType inst_type); // Modifies the semantics at |in_operand| of |inst| to include the volatile // bit if |is_volatile| is true. void UpgradeSemantics(Instruction* inst, uint32_t in_operand, bool is_volatile); // Returns the result id for a constant for |scope|. uint32_t GetScopeConstant(spv::Scope scope); // Returns the value of |index_inst|. |index_inst| must be an OpConstant of // integer type.g uint64_t GetIndexValue(Instruction* index_inst); // Removes coherent and volatile decorations. void CleanupDecorations(); // For all tessellation control entry points, if there is an operation on // Output storage class, then all barriers are modified to include the // OutputMemoryKHR semantic. void UpgradeBarriers(); // If the Vulkan memory model is specified, device scope actually means // device scope. The memory scope must be modified to be QueueFamilyKHR // scope. void UpgradeMemoryScope(); // Returns true if |scope_id| is spv::Scope::Device. bool IsDeviceScope(uint32_t scope_id); // Upgrades GLSL.std.450 modf and frexp. Both instructions are replaced with // their struct versions. New extracts and a store are added in order to // facilitate adding memory model flags. void UpgradeExtInst(Instruction* modf); // Returns the number of words taken up by a memory access argument and its // implied operands. uint32_t MemoryAccessNumWords(uint32_t mask); // Caches the result of TraceInstruction. For a given result id and set of // indices, stores whether that combination is coherent and/or volatile. std::unordered_map>, std::pair, CacheHash> cache_; }; } // namespace opt } // namespace spvtools #endif // LIBSPIRV_OPT_UPGRADE_MEMORY_MODEL_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/value_number_table.cpp000066400000000000000000000167561475742701700252110ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/value_number_table.h" #include #include "source/opt/cfg.h" #include "source/opt/ir_context.h" namespace spvtools { namespace opt { uint32_t ValueNumberTable::GetValueNumber(Instruction* inst) const { assert(inst->result_id() != 0 && "inst must have a result id to get a value number."); // Check if this instruction already has a value. auto result_id_to_val = id_to_value_.find(inst->result_id()); if (result_id_to_val != id_to_value_.end()) { return result_id_to_val->second; } return 0; } uint32_t ValueNumberTable::GetValueNumber(uint32_t id) const { return GetValueNumber(context()->get_def_use_mgr()->GetDef(id)); } uint32_t ValueNumberTable::AssignValueNumber(Instruction* inst) { // If it already has a value return that. uint32_t value = GetValueNumber(inst); if (value != 0) { return value; } // If the instruction has other side effects, then it must // have its own value number. // OpSampledImage and OpImage must remain in the same basic block in which // they are used, because of this we will assign each one it own value number. if (!context()->IsCombinatorInstruction(inst) && !inst->IsCommonDebugInstr()) { value = TakeNextValueNumber(); id_to_value_[inst->result_id()] = value; return value; } switch (inst->opcode()) { case spv::Op::OpSampledImage: case spv::Op::OpImage: case spv::Op::OpVariable: value = TakeNextValueNumber(); id_to_value_[inst->result_id()] = value; return value; default: break; } // If it is a load from memory that can be modified, we have to assume the // memory has been modified, so we give it a new value number. // // Note that this test will also handle volatile loads because they are not // read only. However, if this is ever relaxed because we analyze stores, we // will have to add a new case for volatile loads. if (inst->IsLoad() && !inst->IsReadOnlyLoad()) { value = TakeNextValueNumber(); id_to_value_[inst->result_id()] = value; return value; } analysis::DecorationManager* dec_mgr = context()->get_decoration_mgr(); // When we copy an object, the value numbers should be the same. if (inst->opcode() == spv::Op::OpCopyObject && dec_mgr->HaveTheSameDecorations(inst->result_id(), inst->GetSingleWordInOperand(0))) { value = GetValueNumber(inst->GetSingleWordInOperand(0)); if (value != 0) { id_to_value_[inst->result_id()] = value; return value; } } // Phi nodes are a type of copy. If all of the inputs have the same value // number, then we can assign the result of the phi the same value number. if (inst->opcode() == spv::Op::OpPhi && inst->NumInOperands() > 0 && dec_mgr->HaveTheSameDecorations(inst->result_id(), inst->GetSingleWordInOperand(0))) { value = GetValueNumber(inst->GetSingleWordInOperand(0)); if (value != 0) { for (uint32_t op = 2; op < inst->NumInOperands(); op += 2) { if (value != GetValueNumber(inst->GetSingleWordInOperand(op))) { value = 0; break; } } if (value != 0) { id_to_value_[inst->result_id()] = value; return value; } } } // Replace all of the operands by their value number. The sign bit will be // set to distinguish between an id and a value number. Instruction value_ins(context(), inst->opcode(), inst->type_id(), inst->result_id(), {}); for (uint32_t o = 0; o < inst->NumInOperands(); ++o) { const Operand& op = inst->GetInOperand(o); if (spvIsIdType(op.type)) { uint32_t id_value = op.words[0]; auto use_id_to_val = id_to_value_.find(id_value); if (use_id_to_val != id_to_value_.end()) { id_value = (1 << 31) | use_id_to_val->second; } value_ins.AddOperand(Operand(op.type, {id_value})); } else { value_ins.AddOperand(Operand(op.type, op.words)); } } // TODO: Implement a normal form for opcodes that commute like integer // addition. This will let us know that a+b is the same value as b+a. // Otherwise, we check if this value has been computed before. auto value_iterator = instruction_to_value_.find(value_ins); if (value_iterator != instruction_to_value_.end()) { value = id_to_value_[value_iterator->first.result_id()]; id_to_value_[inst->result_id()] = value; return value; } // If not, assign it a new value number. value = TakeNextValueNumber(); id_to_value_[inst->result_id()] = value; instruction_to_value_[value_ins] = value; return value; } void ValueNumberTable::BuildDominatorTreeValueNumberTable() { // First value number the headers. for (auto& inst : context()->annotations()) { if (inst.result_id() != 0) { AssignValueNumber(&inst); } } for (auto& inst : context()->capabilities()) { if (inst.result_id() != 0) { AssignValueNumber(&inst); } } for (auto& inst : context()->types_values()) { if (inst.result_id() != 0) { AssignValueNumber(&inst); } } for (auto& inst : context()->module()->ext_inst_imports()) { if (inst.result_id() != 0) { AssignValueNumber(&inst); } } for (auto& inst : context()->module()->ext_inst_debuginfo()) { if (inst.result_id() != 0) { AssignValueNumber(&inst); } } for (Function& func : *context()->module()) { // For best results we want to traverse the code in reverse post order. // This happens naturally because of the forward referencing rules. for (BasicBlock& block : func) { for (Instruction& inst : block) { if (inst.result_id() != 0) { AssignValueNumber(&inst); } } } } } bool ComputeSameValue::operator()(const Instruction& lhs, const Instruction& rhs) const { if (lhs.result_id() == 0 || rhs.result_id() == 0) { return false; } if (lhs.opcode() != rhs.opcode()) { return false; } if (lhs.type_id() != rhs.type_id()) { return false; } if (lhs.NumInOperands() != rhs.NumInOperands()) { return false; } for (uint32_t i = 0; i < lhs.NumInOperands(); ++i) { if (lhs.GetInOperand(i) != rhs.GetInOperand(i)) { return false; } } return lhs.context()->get_decoration_mgr()->HaveTheSameDecorations( lhs.result_id(), rhs.result_id()); } std::size_t ValueTableHash::operator()(const Instruction& inst) const { // We hash the opcode and in-operands, not the result, because we want // instructions that are the same except for the result to hash to the // same value. std::u32string h; h.push_back(uint32_t(inst.opcode())); h.push_back(inst.type_id()); for (uint32_t i = 0; i < inst.NumInOperands(); ++i) { const auto& opnd = inst.GetInOperand(i); for (uint32_t word : opnd.words) { h.push_back(word); } } return std::hash()(h); } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/value_number_table.h000066400000000000000000000061251475742701700246430ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_VALUE_NUMBER_TABLE_H_ #define SOURCE_OPT_VALUE_NUMBER_TABLE_H_ #include #include #include "source/opt/instruction.h" namespace spvtools { namespace opt { class IRContext; // Returns true if the two instructions compute the same value. Used by the // value number table to compare two instructions. class ComputeSameValue { public: bool operator()(const Instruction& lhs, const Instruction& rhs) const; }; // The hash function used in the value number table. class ValueTableHash { public: std::size_t operator()(const Instruction& inst) const; }; // This class implements the value number analysis. It is using a hash-based // approach to value numbering. It is essentially doing dominator-tree value // numbering described in // // Preston Briggs, Keith D. Cooper, and L. Taylor Simpson. 1997. Value // numbering. Softw. Pract. Exper. 27, 6 (June 1997), 701-724. // https://www.cs.rice.edu/~keith/Promo/CRPC-TR94517.pdf.gz // // The main difference is that because we do not perform redundancy elimination // as we build the value number table, we do not have to deal with cleaning up // the scope. class ValueNumberTable { public: ValueNumberTable(IRContext* ctx) : context_(ctx), next_value_number_(1) { BuildDominatorTreeValueNumberTable(); } // Returns the value number of the value computed by |inst|. |inst| must have // a result id that will hold the computed value. If no value number has been // assigned to the result id, then the return value is 0. uint32_t GetValueNumber(Instruction* inst) const; // Returns the value number of the value contain in |id|. Returns 0 if it // has not been assigned a value number. uint32_t GetValueNumber(uint32_t id) const; IRContext* context() const { return context_; } private: // Assigns a value number to every result id in the module. void BuildDominatorTreeValueNumberTable(); // Returns the new value number. uint32_t TakeNextValueNumber() { return next_value_number_++; } // Assigns a new value number to the result of |inst| if it does not already // have one. Return the value number for |inst|. |inst| must have a result // id. uint32_t AssignValueNumber(Instruction* inst); std::unordered_map instruction_to_value_; std::unordered_map id_to_value_; IRContext* context_; uint32_t next_value_number_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_VALUE_NUMBER_TABLE_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/vector_dce.cpp000066400000000000000000000373141475742701700234640ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/vector_dce.h" #include namespace spvtools { namespace opt { namespace { constexpr uint32_t kExtractCompositeIdInIdx = 0; constexpr uint32_t kInsertObjectIdInIdx = 0; constexpr uint32_t kInsertCompositeIdInIdx = 1; } // namespace Pass::Status VectorDCE::Process() { bool modified = false; for (Function& function : *get_module()) { modified |= VectorDCEFunction(&function); } return (modified ? Status::SuccessWithChange : Status::SuccessWithoutChange); } bool VectorDCE::VectorDCEFunction(Function* function) { LiveComponentMap live_components; FindLiveComponents(function, &live_components); return RewriteInstructions(function, live_components); } void VectorDCE::FindLiveComponents(Function* function, LiveComponentMap* live_components) { std::vector work_list; // Prime the work list. We will assume that any instruction that does // not result in a vector is live. // // Extending to structures and matrices is not as straight forward because of // the nesting. We cannot simply us a bit vector to keep track of which // components are live because of arbitrary nesting of structs. function->ForEachInst( [&work_list, this, live_components](Instruction* current_inst) { if (current_inst->IsCommonDebugInstr()) { return; } if (!HasVectorOrScalarResult(current_inst) || !context()->IsCombinatorInstruction(current_inst)) { MarkUsesAsLive(current_inst, all_components_live_, live_components, &work_list); } }); // Process the work list propagating liveness. for (uint32_t i = 0; i < work_list.size(); i++) { WorkListItem current_item = work_list[i]; Instruction* current_inst = current_item.instruction; switch (current_inst->opcode()) { case spv::Op::OpCompositeExtract: MarkExtractUseAsLive(current_inst, current_item.components, live_components, &work_list); break; case spv::Op::OpCompositeInsert: MarkInsertUsesAsLive(current_item, live_components, &work_list); break; case spv::Op::OpVectorShuffle: MarkVectorShuffleUsesAsLive(current_item, live_components, &work_list); break; case spv::Op::OpCompositeConstruct: MarkCompositeContructUsesAsLive(current_item, live_components, &work_list); break; default: if (current_inst->IsScalarizable()) { MarkUsesAsLive(current_inst, current_item.components, live_components, &work_list); } else { MarkUsesAsLive(current_inst, all_components_live_, live_components, &work_list); } break; } } } void VectorDCE::MarkExtractUseAsLive(const Instruction* current_inst, const utils::BitVector& live_elements, LiveComponentMap* live_components, std::vector* work_list) { analysis::DefUseManager* def_use_mgr = context()->get_def_use_mgr(); uint32_t operand_id = current_inst->GetSingleWordInOperand(kExtractCompositeIdInIdx); Instruction* operand_inst = def_use_mgr->GetDef(operand_id); if (HasVectorOrScalarResult(operand_inst)) { WorkListItem new_item; new_item.instruction = operand_inst; if (current_inst->NumInOperands() < 2) { new_item.components = live_elements; } else { uint32_t element_index = current_inst->GetSingleWordInOperand(1); uint32_t item_size = GetVectorComponentCount(operand_inst->type_id()); if (element_index < item_size) { new_item.components.Set(element_index); } } AddItemToWorkListIfNeeded(new_item, live_components, work_list); } } void VectorDCE::MarkInsertUsesAsLive( const VectorDCE::WorkListItem& current_item, LiveComponentMap* live_components, std::vector* work_list) { analysis::DefUseManager* def_use_mgr = context()->get_def_use_mgr(); if (current_item.instruction->NumInOperands() > 2) { uint32_t insert_position = current_item.instruction->GetSingleWordInOperand(2); // Add the elements of the composite object that are used. uint32_t operand_id = current_item.instruction->GetSingleWordInOperand( kInsertCompositeIdInIdx); Instruction* operand_inst = def_use_mgr->GetDef(operand_id); WorkListItem new_item; new_item.instruction = operand_inst; new_item.components = current_item.components; new_item.components.Clear(insert_position); AddItemToWorkListIfNeeded(new_item, live_components, work_list); // Add the element being inserted if it is used. if (current_item.components.Get(insert_position)) { uint32_t obj_operand_id = current_item.instruction->GetSingleWordInOperand( kInsertObjectIdInIdx); Instruction* obj_operand_inst = def_use_mgr->GetDef(obj_operand_id); WorkListItem new_item_for_obj; new_item_for_obj.instruction = obj_operand_inst; new_item_for_obj.components.Set(0); AddItemToWorkListIfNeeded(new_item_for_obj, live_components, work_list); } } else { // If there are no indices, then this is a copy of the object being // inserted. uint32_t object_id = current_item.instruction->GetSingleWordInOperand(kInsertObjectIdInIdx); Instruction* object_inst = def_use_mgr->GetDef(object_id); WorkListItem new_item; new_item.instruction = object_inst; new_item.components = current_item.components; AddItemToWorkListIfNeeded(new_item, live_components, work_list); } } void VectorDCE::MarkVectorShuffleUsesAsLive( const WorkListItem& current_item, VectorDCE::LiveComponentMap* live_components, std::vector* work_list) { analysis::DefUseManager* def_use_mgr = context()->get_def_use_mgr(); WorkListItem first_operand; first_operand.instruction = def_use_mgr->GetDef(current_item.instruction->GetSingleWordInOperand(0)); WorkListItem second_operand; second_operand.instruction = def_use_mgr->GetDef(current_item.instruction->GetSingleWordInOperand(1)); uint32_t size_of_first_operand = GetVectorComponentCount(first_operand.instruction->type_id()); uint32_t size_of_second_operand = GetVectorComponentCount(second_operand.instruction->type_id()); for (uint32_t in_op = 2; in_op < current_item.instruction->NumInOperands(); ++in_op) { uint32_t index = current_item.instruction->GetSingleWordInOperand(in_op); if (current_item.components.Get(in_op - 2)) { if (index < size_of_first_operand) { first_operand.components.Set(index); } else if (index - size_of_first_operand < size_of_second_operand) { second_operand.components.Set(index - size_of_first_operand); } } } AddItemToWorkListIfNeeded(first_operand, live_components, work_list); AddItemToWorkListIfNeeded(second_operand, live_components, work_list); } void VectorDCE::MarkCompositeContructUsesAsLive( VectorDCE::WorkListItem work_item, VectorDCE::LiveComponentMap* live_components, std::vector* work_list) { analysis::DefUseManager* def_use_mgr = context()->get_def_use_mgr(); uint32_t current_component = 0; Instruction* current_inst = work_item.instruction; uint32_t num_in_operands = current_inst->NumInOperands(); for (uint32_t i = 0; i < num_in_operands; ++i) { uint32_t id = current_inst->GetSingleWordInOperand(i); Instruction* op_inst = def_use_mgr->GetDef(id); if (HasScalarResult(op_inst)) { WorkListItem new_work_item; new_work_item.instruction = op_inst; if (work_item.components.Get(current_component)) { new_work_item.components.Set(0); } AddItemToWorkListIfNeeded(new_work_item, live_components, work_list); current_component++; } else { assert(HasVectorResult(op_inst)); WorkListItem new_work_item; new_work_item.instruction = op_inst; uint32_t op_vector_size = GetVectorComponentCount(op_inst->type_id()); for (uint32_t op_vector_idx = 0; op_vector_idx < op_vector_size; op_vector_idx++, current_component++) { if (work_item.components.Get(current_component)) { new_work_item.components.Set(op_vector_idx); } } AddItemToWorkListIfNeeded(new_work_item, live_components, work_list); } } } void VectorDCE::MarkUsesAsLive( Instruction* current_inst, const utils::BitVector& live_elements, LiveComponentMap* live_components, std::vector* work_list) { analysis::DefUseManager* def_use_mgr = context()->get_def_use_mgr(); current_inst->ForEachInId([&work_list, &live_elements, this, live_components, def_use_mgr](uint32_t* operand_id) { Instruction* operand_inst = def_use_mgr->GetDef(*operand_id); if (HasVectorResult(operand_inst)) { WorkListItem new_item; new_item.instruction = operand_inst; new_item.components = live_elements; AddItemToWorkListIfNeeded(new_item, live_components, work_list); } else if (HasScalarResult(operand_inst)) { WorkListItem new_item; new_item.instruction = operand_inst; new_item.components.Set(0); AddItemToWorkListIfNeeded(new_item, live_components, work_list); } }); } bool VectorDCE::HasVectorOrScalarResult(const Instruction* inst) const { return HasScalarResult(inst) || HasVectorResult(inst); } bool VectorDCE::HasVectorResult(const Instruction* inst) const { analysis::TypeManager* type_mgr = context()->get_type_mgr(); if (inst->type_id() == 0) { return false; } const analysis::Type* current_type = type_mgr->GetType(inst->type_id()); switch (current_type->kind()) { case analysis::Type::kVector: return true; default: return false; } } bool VectorDCE::HasScalarResult(const Instruction* inst) const { analysis::TypeManager* type_mgr = context()->get_type_mgr(); if (inst->type_id() == 0) { return false; } const analysis::Type* current_type = type_mgr->GetType(inst->type_id()); switch (current_type->kind()) { case analysis::Type::kBool: case analysis::Type::kInteger: case analysis::Type::kFloat: return true; default: return false; } } uint32_t VectorDCE::GetVectorComponentCount(uint32_t type_id) { assert(type_id != 0 && "Trying to get the vector element count, but the type id is 0"); analysis::TypeManager* type_mgr = context()->get_type_mgr(); const analysis::Type* type = type_mgr->GetType(type_id); const analysis::Vector* vector_type = type->AsVector(); assert( vector_type && "Trying to get the vector element count, but the type is not a vector"); return vector_type->element_count(); } bool VectorDCE::RewriteInstructions( Function* function, const VectorDCE::LiveComponentMap& live_components) { bool modified = false; // Kill DebugValue in the middle of the instruction iteration will result // in accessing a dangling pointer. We keep dead DebugValue instructions // in |dead_dbg_value| to kill them once after the iteration. std::vector dead_dbg_value; function->ForEachInst([&modified, this, live_components, &dead_dbg_value](Instruction* current_inst) { if (!context()->IsCombinatorInstruction(current_inst)) { return; } auto live_component = live_components.find(current_inst->result_id()); if (live_component == live_components.end()) { // If this instruction is not in live_components then it does not // produce a vector, or it is never referenced and ADCE will remove // it. No point in trying to differentiate. return; } // If no element in the current instruction is used replace it with an // OpUndef. if (live_component->second.Empty()) { modified = true; MarkDebugValueUsesAsDead(current_inst, &dead_dbg_value); uint32_t undef_id = this->Type2Undef(current_inst->type_id()); context()->KillNamesAndDecorates(current_inst); context()->ReplaceAllUsesWith(current_inst->result_id(), undef_id); context()->KillInst(current_inst); return; } switch (current_inst->opcode()) { case spv::Op::OpCompositeInsert: modified |= RewriteInsertInstruction( current_inst, live_component->second, &dead_dbg_value); break; case spv::Op::OpCompositeConstruct: // TODO: The members that are not live can be replaced by an undef // or constant. This will remove uses of those values, and possibly // create opportunities for ADCE. break; default: // Do nothing. break; } }); for (auto* i : dead_dbg_value) context()->KillInst(i); return modified; } bool VectorDCE::RewriteInsertInstruction( Instruction* current_inst, const utils::BitVector& live_components, std::vector* dead_dbg_value) { // If the value being inserted is not live, then we can skip the insert. if (current_inst->NumInOperands() == 2) { // If there are no indices, then this is the same as a copy. context()->KillNamesAndDecorates(current_inst->result_id()); uint32_t object_id = current_inst->GetSingleWordInOperand(kInsertObjectIdInIdx); context()->ReplaceAllUsesWith(current_inst->result_id(), object_id); return true; } uint32_t insert_index = current_inst->GetSingleWordInOperand(2); if (!live_components.Get(insert_index)) { MarkDebugValueUsesAsDead(current_inst, dead_dbg_value); context()->KillNamesAndDecorates(current_inst->result_id()); uint32_t composite_id = current_inst->GetSingleWordInOperand(kInsertCompositeIdInIdx); context()->ReplaceAllUsesWith(current_inst->result_id(), composite_id); return true; } // If the values already in the composite are not used, then replace it with // an undef. utils::BitVector temp = live_components; temp.Clear(insert_index); if (temp.Empty()) { context()->ForgetUses(current_inst); uint32_t undef_id = Type2Undef(current_inst->type_id()); current_inst->SetInOperand(kInsertCompositeIdInIdx, {undef_id}); context()->AnalyzeUses(current_inst); return true; } return false; } void VectorDCE::MarkDebugValueUsesAsDead( Instruction* composite, std::vector* dead_dbg_value) { context()->get_def_use_mgr()->ForEachUser( composite, [&dead_dbg_value](Instruction* use) { if (use->GetCommonDebugOpcode() == CommonDebugInfoDebugValue) dead_dbg_value->push_back(use); }); } void VectorDCE::AddItemToWorkListIfNeeded( WorkListItem work_item, VectorDCE::LiveComponentMap* live_components, std::vector* work_list) { Instruction* current_inst = work_item.instruction; auto it = live_components->find(current_inst->result_id()); if (it == live_components->end()) { live_components->emplace( std::make_pair(current_inst->result_id(), work_item.components)); work_list->emplace_back(work_item); } else { if (it->second.Or(work_item.components)) { work_list->emplace_back(work_item); } } } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/vector_dce.h000066400000000000000000000153421475742701700231260ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_VECTOR_DCE_H_ #define SOURCE_OPT_VECTOR_DCE_H_ #include #include #include "source/opt/mem_pass.h" #include "source/util/bit_vector.h" namespace spvtools { namespace opt { class VectorDCE : public MemPass { private: using LiveComponentMap = std::unordered_map; // According to the SPEC the maximum size for a vector is 16. See the data // rules in the universal validation rules (section 2.16.1). enum { kMaxVectorSize = 16 }; struct WorkListItem { WorkListItem() : instruction(nullptr), components(kMaxVectorSize) {} Instruction* instruction; utils::BitVector components; }; public: VectorDCE() : all_components_live_(kMaxVectorSize) { for (uint32_t i = 0; i < kMaxVectorSize; i++) { all_components_live_.Set(i); } } const char* name() const override { return "vector-dce"; } Status Process() override; IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisDefUse | IRContext::kAnalysisCFG | IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisLoopAnalysis | IRContext::kAnalysisDecorations | IRContext::kAnalysisDominatorAnalysis | IRContext::kAnalysisNameMap | IRContext::kAnalysisConstants | IRContext::kAnalysisTypes; } private: // Runs the vector dce pass on |function|. Returns true if |function| was // modified. bool VectorDCEFunction(Function* function); // Identifies the live components of the vectors that are results of // instructions in |function|. The results are stored in |live_components|. void FindLiveComponents(Function* function, LiveComponentMap* live_components); // Rewrites instructions in |function| that are dead or partially dead. If an // instruction does not have an entry in |live_components|, then it is not // changed. Returns true if |function| was modified. bool RewriteInstructions(Function* function, const LiveComponentMap& live_components); // Makes all DebugValue instructions that use |composite| for their values as // dead instructions by putting them into |dead_dbg_value|. void MarkDebugValueUsesAsDead(Instruction* composite, std::vector* dead_dbg_value); // Rewrites the OpCompositeInsert instruction |current_inst| to avoid // unnecessary computes given that the only components of the result that are // live are |live_components|. // // If the value being inserted is not live, then the result of |current_inst| // is replaced by the composite input to |current_inst|. // // If the composite input to |current_inst| is not live, then it is replaced // by and OpUndef in |current_inst|. bool RewriteInsertInstruction(Instruction* current_inst, const utils::BitVector& live_components, std::vector* dead_dbg_value); // Returns true if the result of |inst| is a vector or a scalar. bool HasVectorOrScalarResult(const Instruction* inst) const; // Returns true if the result of |inst| is a vector. bool HasVectorResult(const Instruction* inst) const; // Returns true if the result of |inst| is a scalar. bool HasScalarResult(const Instruction* inst) const; // Returns the number of elements in the vector type with id |type_id|. uint32_t GetVectorComponentCount(uint32_t type_id); // Adds |work_item| to |work_list| if it is not already live according to // |live_components|. |live_components| is updated to indicate that // |work_item| is now live. void AddItemToWorkListIfNeeded(WorkListItem work_item, LiveComponentMap* live_components, std::vector* work_list); // Marks the components |live_elements| of the uses in |current_inst| as live // according to |live_components|. If they were not live before, then they are // added to |work_list|. void MarkUsesAsLive(Instruction* current_inst, const utils::BitVector& live_elements, LiveComponentMap* live_components, std::vector* work_list); // Marks the uses in the OpVectorShuffle instruction in |current_item| as live // based on the live components in |current_item|. If anything becomes live // they are added to |work_list| and |live_components| is updated // accordingly. void MarkVectorShuffleUsesAsLive(const WorkListItem& current_item, VectorDCE::LiveComponentMap* live_components, std::vector* work_list); // Marks the uses in the OpCompositeInsert instruction in |current_item| as // live based on the live components in |current_item|. If anything becomes // live they are added to |work_list| and |live_components| is updated // accordingly. void MarkInsertUsesAsLive(const WorkListItem& current_item, LiveComponentMap* live_components, std::vector* work_list); // Marks the uses in the OpCompositeExtract instruction |current_inst| as // live. If anything becomes live they are added to |work_list| and // |live_components| is updated accordingly. void MarkExtractUseAsLive(const Instruction* current_inst, const utils::BitVector& live_elements, LiveComponentMap* live_components, std::vector* work_list); // Marks the uses in the OpCompositeConstruct instruction |current_inst| as // live. If anything becomes live they are added to |work_list| and // |live_components| is updated accordingly. void MarkCompositeContructUsesAsLive(WorkListItem work_item, LiveComponentMap* live_components, std::vector* work_list); // A BitVector that can always be used to say that all components of a vector // are live. utils::BitVector all_components_live_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_VECTOR_DCE_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/workaround1209.cpp000066400000000000000000000045241475742701700240530ustar00rootroot00000000000000// Copyright (c) 2018 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/workaround1209.h" #include #include #include #include namespace spvtools { namespace opt { Pass::Status Workaround1209::Process() { bool modified = false; modified = RemoveOpUnreachableInLoops(); return (modified ? Status::SuccessWithChange : Status::SuccessWithoutChange); } bool Workaround1209::RemoveOpUnreachableInLoops() { bool modified = false; for (auto& func : *get_module()) { std::list structured_order; cfg()->ComputeStructuredOrder(&func, &*func.begin(), &structured_order); // Keep track of the loop merges. The top of the stack will always be the // loop merge for the loop that immediately contains the basic block being // processed. std::stack loop_merges; for (BasicBlock* bb : structured_order) { if (!loop_merges.empty() && bb->id() == loop_merges.top()) { loop_merges.pop(); } if (bb->tail()->opcode() == spv::Op::OpUnreachable) { if (!loop_merges.empty()) { // We found an OpUnreachable inside a loop. // Replace it with an unconditional branch to the loop merge. context()->KillInst(&*bb->tail()); std::unique_ptr new_branch( new Instruction(context(), spv::Op::OpBranch, 0, 0, {{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {loop_merges.top()}}})); context()->AnalyzeDefUse(&*new_branch); bb->AddInstruction(std::move(new_branch)); modified = true; } } else { if (bb->GetLoopMergeInst()) { loop_merges.push(bb->MergeBlockIdIfAny()); } } } } return modified; } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/workaround1209.h000066400000000000000000000024101475742701700235100ustar00rootroot00000000000000// Copyright (c) 2018 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_WORKAROUND1209_H_ #define SOURCE_OPT_WORKAROUND1209_H_ #include "source/opt/pass.h" namespace spvtools { namespace opt { // See optimizer.hpp for documentation. class Workaround1209 : public Pass { public: const char* name() const override { return "workaround-1209"; } Status Process() override; private: // There is at least one driver where an OpUnreachable found in a loop is not // handled correctly. Workaround that by changing the OpUnreachable into a // branch to the loop merge. // // Returns true if the code changed. bool RemoveOpUnreachableInLoops(); }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_WORKAROUND1209_H_ KhronosGroup-SPIRV-Tools-f289d04/source/opt/wrap_opkill.cpp000066400000000000000000000143551475742701700236720ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/wrap_opkill.h" #include "ir_builder.h" namespace spvtools { namespace opt { Pass::Status WrapOpKill::Process() { bool modified = false; auto func_to_process = context()->GetStructuredCFGAnalysis()->FindFuncsCalledFromContinue(); for (uint32_t func_id : func_to_process) { Function* func = context()->GetFunction(func_id); bool successful = func->WhileEachInst([this, &modified](Instruction* inst) { const auto opcode = inst->opcode(); if ((opcode == spv::Op::OpKill) || (opcode == spv::Op::OpTerminateInvocation)) { modified = true; if (!ReplaceWithFunctionCall(inst)) { return false; } } return true; }); if (!successful) { return Status::Failure; } } if (opkill_function_ != nullptr) { assert(modified && "The function should only be generated if something was modified."); context()->AddFunction(std::move(opkill_function_)); } if (opterminateinvocation_function_ != nullptr) { assert(modified && "The function should only be generated if something was modified."); context()->AddFunction(std::move(opterminateinvocation_function_)); } return (modified ? Status::SuccessWithChange : Status::SuccessWithoutChange); } bool WrapOpKill::ReplaceWithFunctionCall(Instruction* inst) { assert((inst->opcode() == spv::Op::OpKill || inst->opcode() == spv::Op::OpTerminateInvocation) && "|inst| must be an OpKill or OpTerminateInvocation instruction."); InstructionBuilder ir_builder( context(), inst, IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); uint32_t func_id = GetKillingFuncId(inst->opcode()); if (func_id == 0) { return false; } Instruction* call_inst = ir_builder.AddFunctionCall(GetVoidTypeId(), func_id, {}); if (call_inst == nullptr) { return false; } call_inst->UpdateDebugInfoFrom(inst); Instruction* return_inst = nullptr; uint32_t return_type_id = GetOwningFunctionsReturnType(inst); if (return_type_id != GetVoidTypeId()) { Instruction* undef = ir_builder.AddNullaryOp(return_type_id, spv::Op::OpUndef); if (undef == nullptr) { return false; } return_inst = ir_builder.AddUnaryOp(0, spv::Op::OpReturnValue, undef->result_id()); } else { return_inst = ir_builder.AddNullaryOp(0, spv::Op::OpReturn); } if (return_inst == nullptr) { return false; } context()->KillInst(inst); return true; } uint32_t WrapOpKill::GetVoidTypeId() { if (void_type_id_ != 0) { return void_type_id_; } analysis::TypeManager* type_mgr = context()->get_type_mgr(); analysis::Void void_type; void_type_id_ = type_mgr->GetTypeInstruction(&void_type); return void_type_id_; } uint32_t WrapOpKill::GetVoidFunctionTypeId() { analysis::TypeManager* type_mgr = context()->get_type_mgr(); analysis::Void void_type; const analysis::Type* registered_void_type = type_mgr->GetRegisteredType(&void_type); analysis::Function func_type(registered_void_type, {}); return type_mgr->GetTypeInstruction(&func_type); } uint32_t WrapOpKill::GetKillingFuncId(spv::Op opcode) { // Parameterize by opcode assert(opcode == spv::Op::OpKill || opcode == spv::Op::OpTerminateInvocation); std::unique_ptr* const killing_func = (opcode == spv::Op::OpKill) ? &opkill_function_ : &opterminateinvocation_function_; if (*killing_func != nullptr) { return (*killing_func)->result_id(); } uint32_t killing_func_id = TakeNextId(); if (killing_func_id == 0) { return 0; } uint32_t void_type_id = GetVoidTypeId(); if (void_type_id == 0) { return 0; } // Generate the function start instruction std::unique_ptr func_start(new Instruction( context(), spv::Op::OpFunction, void_type_id, killing_func_id, {})); func_start->AddOperand({SPV_OPERAND_TYPE_FUNCTION_CONTROL, {0}}); func_start->AddOperand({SPV_OPERAND_TYPE_ID, {GetVoidFunctionTypeId()}}); (*killing_func).reset(new Function(std::move(func_start))); // Generate the function end instruction std::unique_ptr func_end( new Instruction(context(), spv::Op::OpFunctionEnd, 0, 0, {})); (*killing_func)->SetFunctionEnd(std::move(func_end)); // Create the one basic block for the function. uint32_t lab_id = TakeNextId(); if (lab_id == 0) { return 0; } std::unique_ptr label_inst( new Instruction(context(), spv::Op::OpLabel, 0, lab_id, {})); std::unique_ptr bb(new BasicBlock(std::move(label_inst))); // Add the OpKill to the basic block std::unique_ptr kill_inst( new Instruction(context(), opcode, 0, 0, {})); bb->AddInstruction(std::move(kill_inst)); // Add the bb to the function (*killing_func)->AddBasicBlock(std::move(bb)); // Add the function to the module. if (context()->AreAnalysesValid(IRContext::kAnalysisDefUse)) { (*killing_func)->ForEachInst([this](Instruction* inst) { context()->AnalyzeDefUse(inst); }); } if (context()->AreAnalysesValid(IRContext::kAnalysisInstrToBlockMapping)) { for (BasicBlock& basic_block : *(*killing_func)) { context()->set_instr_block(basic_block.GetLabelInst(), &basic_block); for (Instruction& inst : basic_block) { context()->set_instr_block(&inst, &basic_block); } } } return (*killing_func)->result_id(); } uint32_t WrapOpKill::GetOwningFunctionsReturnType(Instruction* inst) { BasicBlock* bb = context()->get_instr_block(inst); if (bb == nullptr) { return 0; } Function* func = bb->GetParent(); return func->type_id(); } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/opt/wrap_opkill.h000066400000000000000000000057751475742701700233450ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_OPT_WRAP_OPKILL_H_ #define SOURCE_OPT_WRAP_OPKILL_H_ #include "source/opt/pass.h" namespace spvtools { namespace opt { // Documented in optimizer.hpp class WrapOpKill : public Pass { public: WrapOpKill() : void_type_id_(0) {} const char* name() const override { return "wrap-opkill"; } Status Process() override; IRContext::Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisDecorations | IRContext::kAnalysisCombinators | IRContext::kAnalysisNameMap | IRContext::kAnalysisBuiltinVarId | IRContext::kAnalysisConstants | IRContext::kAnalysisTypes; } private: // Replaces the OpKill or OpTerminateInvocation instruction |inst| with a // function call to a function that contains a single instruction, a clone of // |inst|. An OpUnreachable instruction will be placed after the function // call. Return true if successful. bool ReplaceWithFunctionCall(Instruction* inst); // Returns the id of the void type. uint32_t GetVoidTypeId(); // Returns the id of the function type for a void function with no parameters. uint32_t GetVoidFunctionTypeId(); // Return the id of a function that has return type void, has no parameters, // and contains a single instruction, which is |opcode|, either OpKill or // OpTerminateInvocation. Returns 0 if the function could not be generated. uint32_t GetKillingFuncId(spv::Op opcode); // Returns the id of the return type for the function that contains |inst|. // Returns 0 if |inst| is not in a function. uint32_t GetOwningFunctionsReturnType(Instruction* inst); // The id of the void type. If its value is 0, then the void type has not // been found or created yet. uint32_t void_type_id_; // The function that is a single instruction, which is an OpKill. The // function has a void return type and takes no parameters. If the function is // |nullptr|, then the function has not been generated. std::unique_ptr opkill_function_; // The function that is a single instruction, which is an // OpTerminateInvocation. The function has a void return type and takes no // parameters. If the function is |nullptr|, then the function has not been // generated. std::unique_ptr opterminateinvocation_function_; }; } // namespace opt } // namespace spvtools #endif // SOURCE_OPT_WRAP_OPKILL_H_ KhronosGroup-SPIRV-Tools-f289d04/source/parsed_operand.cpp000066400000000000000000000050651475742701700235310ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // This file contains utility functions for spv_parsed_operand_t. #include "source/parsed_operand.h" #include #include "source/util/hex_float.h" namespace spvtools { void EmitNumericLiteral(std::ostream* out, const spv_parsed_instruction_t& inst, const spv_parsed_operand_t& operand) { if (operand.type != SPV_OPERAND_TYPE_LITERAL_INTEGER && operand.type != SPV_OPERAND_TYPE_LITERAL_FLOAT && operand.type != SPV_OPERAND_TYPE_TYPED_LITERAL_NUMBER && operand.type != SPV_OPERAND_TYPE_OPTIONAL_LITERAL_INTEGER && operand.type != SPV_OPERAND_TYPE_OPTIONAL_TYPED_LITERAL_INTEGER) return; if (operand.num_words < 1) return; // TODO(dneto): Support more than 64-bits at a time. if (operand.num_words > 2) return; const uint32_t word = inst.words[operand.offset]; if (operand.num_words == 1) { switch (operand.number_kind) { case SPV_NUMBER_SIGNED_INT: *out << int32_t(word); break; case SPV_NUMBER_UNSIGNED_INT: *out << word; break; case SPV_NUMBER_FLOATING: if (operand.number_bit_width == 16) { *out << spvtools::utils::FloatProxy( uint16_t(word & 0xFFFF)); } else { // Assume 32-bit floats. *out << spvtools::utils::FloatProxy(word); } break; default: break; } } else if (operand.num_words == 2) { // Multi-word numbers are presented with lower order words first. uint64_t bits = uint64_t(word) | (uint64_t(inst.words[operand.offset + 1]) << 32); switch (operand.number_kind) { case SPV_NUMBER_SIGNED_INT: *out << int64_t(bits); break; case SPV_NUMBER_UNSIGNED_INT: *out << bits; break; case SPV_NUMBER_FLOATING: // Assume only 64-bit floats. *out << spvtools::utils::FloatProxy(bits); break; default: break; } } } } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/parsed_operand.h000066400000000000000000000022421475742701700231700ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_PARSED_OPERAND_H_ #define SOURCE_PARSED_OPERAND_H_ #include #include "spirv-tools/libspirv.h" namespace spvtools { // Emits the numeric literal representation of the given instruction operand // to the stream. The operand must be of numeric type. If integral it may // be up to 64 bits wide. If floating point, then it must be 16, 32, or 64 // bits wide. void EmitNumericLiteral(std::ostream* out, const spv_parsed_instruction_t& inst, const spv_parsed_operand_t& operand); } // namespace spvtools #endif // SOURCE_PARSED_OPERAND_H_ KhronosGroup-SPIRV-Tools-f289d04/source/pch_source.cpp000066400000000000000000000011641475742701700226710ustar00rootroot00000000000000// Copyright (c) 2018 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "pch_source.h" KhronosGroup-SPIRV-Tools-f289d04/source/pch_source.h000066400000000000000000000012051475742701700223320ustar00rootroot00000000000000// Copyright (c) 2018 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/val/validation_state.h" KhronosGroup-SPIRV-Tools-f289d04/source/print.cpp000066400000000000000000000054061475742701700216760ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/print.h" #if defined(SPIRV_WINDOWS) #include namespace spvtools { static void SetConsoleForegroundColorPrimary(HANDLE hConsole, WORD color) { // Get screen buffer information from console handle CONSOLE_SCREEN_BUFFER_INFO bufInfo; GetConsoleScreenBufferInfo(hConsole, &bufInfo); // Get background color color = WORD(color | (bufInfo.wAttributes & 0xfff0)); // Set foreground color SetConsoleTextAttribute(hConsole, color); } static void SetConsoleForegroundColor(WORD color) { SetConsoleForegroundColorPrimary(GetStdHandle(STD_OUTPUT_HANDLE), color); SetConsoleForegroundColorPrimary(GetStdHandle(STD_ERROR_HANDLE), color); } clr::reset::operator const char*() { if (isPrint) { SetConsoleForegroundColor(0xf); return ""; } return "\x1b[0m"; } clr::grey::operator const char*() { if (isPrint) { SetConsoleForegroundColor(FOREGROUND_INTENSITY); return ""; } return "\x1b[1;30m"; } clr::red::operator const char*() { if (isPrint) { SetConsoleForegroundColor(FOREGROUND_RED); return ""; } return "\x1b[31m"; } clr::green::operator const char*() { if (isPrint) { SetConsoleForegroundColor(FOREGROUND_GREEN); return ""; } return "\x1b[32m"; } clr::yellow::operator const char*() { if (isPrint) { SetConsoleForegroundColor(FOREGROUND_RED | FOREGROUND_GREEN); return ""; } return "\x1b[33m"; } clr::blue::operator const char*() { // Blue all by itself is hard to see against a black background (the // default on command shell), or a medium blue background (the default // on PowerShell). So increase its intensity. if (isPrint) { SetConsoleForegroundColor(FOREGROUND_BLUE | FOREGROUND_INTENSITY); return ""; } return "\x1b[94m"; } } // namespace spvtools #else namespace spvtools { clr::reset::operator const char*() { return "\x1b[0m"; } clr::grey::operator const char*() { return "\x1b[1;30m"; } clr::red::operator const char*() { return "\x1b[31m"; } clr::green::operator const char*() { return "\x1b[32m"; } clr::yellow::operator const char*() { return "\x1b[33m"; } clr::blue::operator const char*() { return "\x1b[34m"; } } // namespace spvtools #endif KhronosGroup-SPIRV-Tools-f289d04/source/print.h000066400000000000000000000032021475742701700213330ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_PRINT_H_ #define SOURCE_PRINT_H_ #include #include namespace spvtools { // Wrapper for out stream selection. class out_stream { public: out_stream() : pStream(nullptr) {} explicit out_stream(std::stringstream& stream) : pStream(&stream) {} std::ostream& get() { if (pStream) { return *pStream; } return std::cout; } private: std::stringstream* pStream; }; namespace clr { // Resets console color. struct reset { operator const char*(); bool isPrint; }; // Sets console color to grey. struct grey { operator const char*(); bool isPrint; }; // Sets console color to red. struct red { operator const char*(); bool isPrint; }; // Sets console color to green. struct green { operator const char*(); bool isPrint; }; // Sets console color to yellow. struct yellow { operator const char*(); bool isPrint; }; // Sets console color to blue. struct blue { operator const char*(); bool isPrint; }; } // namespace clr } // namespace spvtools #endif // SOURCE_PRINT_H_ KhronosGroup-SPIRV-Tools-f289d04/source/reduce/000077500000000000000000000000001475742701700213005ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/reduce/CMakeLists.txt000066400000000000000000000123311475742701700240400ustar00rootroot00000000000000# Copyright (c) 2018 Google LLC # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. set(SPIRV_TOOLS_REDUCE_SOURCES change_operand_reduction_opportunity.h change_operand_to_undef_reduction_opportunity.h conditional_branch_to_simple_conditional_branch_opportunity_finder.h conditional_branch_to_simple_conditional_branch_reduction_opportunity.h merge_blocks_reduction_opportunity.h merge_blocks_reduction_opportunity_finder.h operand_to_const_reduction_opportunity_finder.h operand_to_undef_reduction_opportunity_finder.h operand_to_dominating_id_reduction_opportunity_finder.h reducer.h reduction_opportunity.h reduction_opportunity_finder.h reduction_pass.h reduction_util.h remove_block_reduction_opportunity.h remove_block_reduction_opportunity_finder.h remove_function_reduction_opportunity.h remove_function_reduction_opportunity_finder.h remove_instruction_reduction_opportunity.h remove_selection_reduction_opportunity.h remove_selection_reduction_opportunity_finder.h remove_struct_member_reduction_opportunity.h remove_unused_instruction_reduction_opportunity_finder.h remove_unused_struct_member_reduction_opportunity_finder.h simple_conditional_branch_to_branch_opportunity_finder.h simple_conditional_branch_to_branch_reduction_opportunity.h structured_construct_to_block_reduction_opportunity.h structured_construct_to_block_reduction_opportunity_finder.h structured_loop_to_selection_reduction_opportunity.h structured_loop_to_selection_reduction_opportunity_finder.h change_operand_reduction_opportunity.cpp change_operand_to_undef_reduction_opportunity.cpp conditional_branch_to_simple_conditional_branch_opportunity_finder.cpp conditional_branch_to_simple_conditional_branch_reduction_opportunity.cpp merge_blocks_reduction_opportunity.cpp merge_blocks_reduction_opportunity_finder.cpp operand_to_const_reduction_opportunity_finder.cpp operand_to_undef_reduction_opportunity_finder.cpp operand_to_dominating_id_reduction_opportunity_finder.cpp reducer.cpp reduction_opportunity.cpp reduction_opportunity_finder.cpp reduction_pass.cpp reduction_util.cpp remove_block_reduction_opportunity.cpp remove_block_reduction_opportunity_finder.cpp remove_function_reduction_opportunity.cpp remove_function_reduction_opportunity_finder.cpp remove_instruction_reduction_opportunity.cpp remove_selection_reduction_opportunity.cpp remove_selection_reduction_opportunity_finder.cpp remove_struct_member_reduction_opportunity.cpp remove_unused_instruction_reduction_opportunity_finder.cpp remove_unused_struct_member_reduction_opportunity_finder.cpp simple_conditional_branch_to_branch_opportunity_finder.cpp simple_conditional_branch_to_branch_reduction_opportunity.cpp structured_construct_to_block_reduction_opportunity.cpp structured_construct_to_block_reduction_opportunity_finder.cpp structured_loop_to_selection_reduction_opportunity.cpp structured_loop_to_selection_reduction_opportunity_finder.cpp ) if(MSVC AND (NOT ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang"))) # Enable parallel builds across four cores for this lib add_definitions(/MP4) endif() spvtools_pch(SPIRV_TOOLS_REDUCE_SOURCES pch_source_reduce) add_library(SPIRV-Tools-reduce ${SPIRV_TOOLS_LIBRARY_TYPE} ${SPIRV_TOOLS_REDUCE_SOURCES}) spvtools_default_compile_options(SPIRV-Tools-reduce) target_include_directories(SPIRV-Tools-reduce PUBLIC $ $ $ PRIVATE ${spirv-tools_BINARY_DIR} ) # The reducer reuses a lot of functionality from the SPIRV-Tools library. target_link_libraries(SPIRV-Tools-reduce PUBLIC ${SPIRV_TOOLS_FULL_VISIBILITY} PUBLIC SPIRV-Tools-opt) set_property(TARGET SPIRV-Tools-reduce PROPERTY FOLDER "SPIRV-Tools libraries") spvtools_check_symbol_exports(SPIRV-Tools-reduce) if(ENABLE_SPIRV_TOOLS_INSTALL) install(TARGETS SPIRV-Tools-reduce EXPORT SPIRV-Tools-reduceTargets) export(EXPORT SPIRV-Tools-reduceTargets FILE SPIRV-Tools-reduceTarget.cmake) spvtools_config_package_dir(SPIRV-Tools-reduce PACKAGE_DIR) install(EXPORT SPIRV-Tools-reduceTargets FILE SPIRV-Tools-reduceTarget.cmake DESTINATION ${PACKAGE_DIR}) spvtools_generate_config_file(SPIRV-Tools-reduce) install(FILES ${CMAKE_BINARY_DIR}/SPIRV-Tools-reduceConfig.cmake DESTINATION ${PACKAGE_DIR}) endif(ENABLE_SPIRV_TOOLS_INSTALL) KhronosGroup-SPIRV-Tools-f289d04/source/reduce/change_operand_reduction_opportunity.cpp000066400000000000000000000023541475742701700315150ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/change_operand_reduction_opportunity.h" #include "source/opt/ir_context.h" namespace spvtools { namespace reduce { bool ChangeOperandReductionOpportunity::PreconditionHolds() { // Check that the instruction still has the original operand. return inst_->NumOperands() > operand_index_ && inst_->GetOperand(operand_index_).words[0] == original_id_ && inst_->GetOperand(operand_index_).type == original_type_; } void ChangeOperandReductionOpportunity::Apply() { inst_->SetOperand(operand_index_, {new_id_}); inst_->context()->get_def_use_mgr()->UpdateDefUse(inst_); } } // namespace reduce } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/reduce/change_operand_reduction_opportunity.h000066400000000000000000000035021475742701700311560ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_REDUCE_CHANGE_OPERAND_REDUCTION_OPPORTUNITY_H_ #define SOURCE_REDUCE_CHANGE_OPERAND_REDUCTION_OPPORTUNITY_H_ #include "source/opt/instruction.h" #include "source/reduce/reduction_opportunity.h" #include "spirv-tools/libspirv.h" namespace spvtools { namespace reduce { // An opportunity to replace an id operand of an instruction with some other id. class ChangeOperandReductionOpportunity : public ReductionOpportunity { public: // Constructs the opportunity to replace operand |operand_index| of |inst| // with |new_id|. ChangeOperandReductionOpportunity(opt::Instruction* inst, uint32_t operand_index, uint32_t new_id) : inst_(inst), operand_index_(operand_index), original_id_(inst->GetOperand(operand_index).words[0]), original_type_(inst->GetOperand(operand_index).type), new_id_(new_id) {} bool PreconditionHolds() override; protected: void Apply() override; private: opt::Instruction* const inst_; const uint32_t operand_index_; const uint32_t original_id_; const spv_operand_type_t original_type_; const uint32_t new_id_; }; } // namespace reduce } // namespace spvtools #endif // SOURCE_REDUCE_CHANGE_OPERAND_REDUCTION_OPPORTUNITY_H_ KhronosGroup-SPIRV-Tools-f289d04/source/reduce/change_operand_to_undef_reduction_opportunity.cpp000066400000000000000000000031371475742701700334000ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/change_operand_to_undef_reduction_opportunity.h" #include "source/opt/ir_context.h" #include "source/reduce/reduction_util.h" namespace spvtools { namespace reduce { bool ChangeOperandToUndefReductionOpportunity::PreconditionHolds() { // Check that the instruction still has the original operand. return inst_->NumOperands() > operand_index_ && inst_->GetOperand(operand_index_).words[0] == original_id_; } void ChangeOperandToUndefReductionOpportunity::Apply() { auto operand = inst_->GetOperand(operand_index_); auto operand_id = operand.words[0]; auto operand_id_def = context_->get_def_use_mgr()->GetDef(operand_id); auto operand_type_id = operand_id_def->type_id(); // The opportunity should not exist unless this holds. assert(operand_type_id); auto undef_id = FindOrCreateGlobalUndef(context_, operand_type_id); inst_->SetOperand(operand_index_, {undef_id}); context_->InvalidateAnalyses(opt::IRContext::kAnalysisDefUse); } } // namespace reduce } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/reduce/change_operand_to_undef_reduction_opportunity.h000066400000000000000000000034651475742701700330510ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_REDUCE_CHANGE_OPERAND_TO_UNDEF_REDUCTION_OPPORTUNITY_H_ #define SOURCE_REDUCE_CHANGE_OPERAND_TO_UNDEF_REDUCTION_OPPORTUNITY_H_ #include "source/opt/instruction.h" #include "source/reduce/reduction_opportunity.h" #include "spirv-tools/libspirv.h" namespace spvtools { namespace reduce { // An opportunity to replace an id operand of an instruction with undef. class ChangeOperandToUndefReductionOpportunity : public ReductionOpportunity { public: // Constructs the opportunity to replace operand |operand_index| of |inst| // with undef. ChangeOperandToUndefReductionOpportunity(opt::IRContext* context, opt::Instruction* inst, uint32_t operand_index) : context_(context), inst_(inst), operand_index_(operand_index), original_id_(inst->GetOperand(operand_index).words[0]) {} bool PreconditionHolds() override; protected: void Apply() override; private: opt::IRContext* context_; opt::Instruction* const inst_; const uint32_t operand_index_; const uint32_t original_id_; }; } // namespace reduce } // namespace spvtools #endif // SOURCE_REDUCE_CHANGE_OPERAND_TO_UNDEF_REDUCTION_OPPORTUNITY_H_ conditional_branch_to_simple_conditional_branch_opportunity_finder.cpp000066400000000000000000000065761475742701700375610ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/reduce// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/conditional_branch_to_simple_conditional_branch_opportunity_finder.h" #include "source/reduce/conditional_branch_to_simple_conditional_branch_reduction_opportunity.h" #include "source/reduce/reduction_util.h" namespace spvtools { namespace reduce { std::vector> ConditionalBranchToSimpleConditionalBranchOpportunityFinder:: GetAvailableOpportunities(opt::IRContext* context, uint32_t target_function) const { std::vector> result; // Find the opportunities for redirecting all false targets before the // opportunities for redirecting all true targets because the former // opportunities disable the latter, and vice versa, and the efficiency of the // reducer is improved by avoiding contiguous opportunities that disable one // another. for (bool redirect_to_true : {true, false}) { // Consider every relevant function. for (auto* function : GetTargetFunctions(context, target_function)) { // Consider every block in the function. for (auto& block : *function) { // The terminator must be spv::Op::OpBranchConditional. opt::Instruction* terminator = block.terminator(); if (terminator->opcode() != spv::Op::OpBranchConditional) { continue; } uint32_t true_block_id = terminator->GetSingleWordInOperand(kTrueBranchOperandIndex); uint32_t false_block_id = terminator->GetSingleWordInOperand(kFalseBranchOperandIndex); // The conditional branch must not already be simplified. if (true_block_id == false_block_id) { continue; } // The redirected target must not be a back-edge to a structured loop // header. uint32_t redirected_block_id = redirect_to_true ? false_block_id : true_block_id; uint32_t containing_loop_header = context->GetStructuredCFGAnalysis()->ContainingLoop(block.id()); // The structured CFG analysis does not include a loop header as part // of the loop construct, but we want to include it, so handle this // special case: if (block.GetLoopMergeInst() != nullptr) { containing_loop_header = block.id(); } if (redirected_block_id == containing_loop_header) { continue; } result.push_back( MakeUnique< ConditionalBranchToSimpleConditionalBranchReductionOpportunity>( context, block.terminator(), redirect_to_true)); } } } return result; } std::string ConditionalBranchToSimpleConditionalBranchOpportunityFinder::GetName() const { return "ConditionalBranchToSimpleConditionalBranchOpportunityFinder"; } } // namespace reduce } // namespace spvtools conditional_branch_to_simple_conditional_branch_opportunity_finder.h000066400000000000000000000025521475742701700372140ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/reduce// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_REDUCE_SIMPLIFY_SELECTION_OPPORTUNITY_FINDER_H_ #define SOURCE_REDUCE_SIMPLIFY_SELECTION_OPPORTUNITY_FINDER_H_ #include "source/reduce/reduction_opportunity_finder.h" namespace spvtools { namespace reduce { // A finder for opportunities to simplify conditional branches into simple // conditional branches (conditional branches with one target). class ConditionalBranchToSimpleConditionalBranchOpportunityFinder : public ReductionOpportunityFinder { public: std::vector> GetAvailableOpportunities( opt::IRContext* context, uint32_t target_function) const override; std::string GetName() const override; }; } // namespace reduce } // namespace spvtools #endif // SOURCE_REDUCE_SIMPLIFY_SELECTION_OPPORTUNITY_FINDER_H_ conditional_branch_to_simple_conditional_branch_reduction_opportunity.cpp000066400000000000000000000051511475742701700402720ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/reduce// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/conditional_branch_to_simple_conditional_branch_reduction_opportunity.h" #include "source/reduce/reduction_util.h" namespace spvtools { namespace reduce { ConditionalBranchToSimpleConditionalBranchReductionOpportunity:: ConditionalBranchToSimpleConditionalBranchReductionOpportunity( opt::IRContext* context, opt::Instruction* conditional_branch_instruction, bool redirect_to_true) : context_(context), conditional_branch_instruction_(conditional_branch_instruction), redirect_to_true_(redirect_to_true) {} bool ConditionalBranchToSimpleConditionalBranchReductionOpportunity:: PreconditionHolds() { // Another opportunity may have already simplified this conditional branch, // which should disable this opportunity. return conditional_branch_instruction_->GetSingleWordInOperand( kTrueBranchOperandIndex) != conditional_branch_instruction_->GetSingleWordInOperand( kFalseBranchOperandIndex); } void ConditionalBranchToSimpleConditionalBranchReductionOpportunity::Apply() { uint32_t operand_to_modify = redirect_to_true_ ? kFalseBranchOperandIndex : kTrueBranchOperandIndex; uint32_t operand_to_copy = redirect_to_true_ ? kTrueBranchOperandIndex : kFalseBranchOperandIndex; auto old_successor_block_id = conditional_branch_instruction_->GetSingleWordInOperand( operand_to_modify); // Do the branch redirection. conditional_branch_instruction_->SetInOperand( operand_to_modify, {conditional_branch_instruction_->GetSingleWordInOperand( operand_to_copy)}); // The old successor block may have phi instructions; these will need to // respect the change in edges. AdaptPhiInstructionsForRemovedEdge( context_->get_instr_block(conditional_branch_instruction_)->id(), context_->cfg()->block(old_successor_block_id)); // We have changed the CFG. context_->InvalidateAnalysesExceptFor( opt::IRContext::Analysis::kAnalysisNone); } } // namespace reduce } // namespace spvtools conditional_branch_to_simple_conditional_branch_reduction_opportunity.h000066400000000000000000000037731475742701700377470ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/reduce// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_REDUCE_SIMPLIFY_CONDITIONAL_BRANCH_REDUCTION_OPPORTUNITY_H_ #define SOURCE_REDUCE_SIMPLIFY_CONDITIONAL_BRANCH_REDUCTION_OPPORTUNITY_H_ #include "source/opt/basic_block.h" #include "source/reduce/reduction_opportunity.h" namespace spvtools { namespace reduce { // An opportunity to simplify a conditional branch to a simple conditional // branch (a conditional branch with one target). class ConditionalBranchToSimpleConditionalBranchReductionOpportunity : public ReductionOpportunity { public: // Constructs an opportunity to simplify |conditional_branch_instruction|. If // |redirect_to_true| is true, the false target will be changed to also point // to the true target; otherwise, the true target will be changed to also // point to the false target. explicit ConditionalBranchToSimpleConditionalBranchReductionOpportunity( opt::IRContext* context, opt::Instruction* conditional_branch_instruction, bool redirect_to_true); bool PreconditionHolds() override; protected: void Apply() override; private: opt::IRContext* context_; opt::Instruction* conditional_branch_instruction_; // If true, the false target will be changed to point to the true target; // otherwise, the true target will be changed to point to the false target. bool redirect_to_true_; }; } // namespace reduce } // namespace spvtools #endif // SOURCE_REDUCE_SIMPLIFY_CONDITIONAL_BRANCH_REDUCTION_OPPORTUNITY_H_ KhronosGroup-SPIRV-Tools-f289d04/source/reduce/merge_blocks_reduction_opportunity.cpp000066400000000000000000000064401475742701700312140ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/merge_blocks_reduction_opportunity.h" #include "source/opt/block_merge_util.h" #include "source/opt/ir_context.h" namespace spvtools { namespace reduce { MergeBlocksReductionOpportunity::MergeBlocksReductionOpportunity( opt::IRContext* context, opt::Function* function, opt::BasicBlock* block) { // Precondition: the terminator has to be OpBranch. assert(block->terminator()->opcode() == spv::Op::OpBranch); context_ = context; function_ = function; // Get the successor block associated with the OpBranch. successor_block_ = context->cfg()->block(block->terminator()->GetSingleWordInOperand(0)); } bool MergeBlocksReductionOpportunity::PreconditionHolds() { // Merge block opportunities can disable each other. // Example: Given blocks: A->B->C. // A is a loop header; B and C are blocks in the loop; C ends with OpReturn. // There are two opportunities: B and C can be merged with their predecessors. // Merge C. B now ends with OpReturn. We now just have: A->B. // Merge B is now disabled, as this would lead to A, a loop header, ending // with an OpReturn, which is invalid. const auto predecessors = context_->cfg()->preds(successor_block_->id()); assert(1 == predecessors.size() && "For a successor to be merged into its predecessor, exactly one " "predecessor must be present."); const uint32_t predecessor_id = predecessors[0]; opt::BasicBlock* predecessor_block = context_->get_instr_block(predecessor_id); return opt::blockmergeutil::CanMergeWithSuccessor(context_, predecessor_block); } void MergeBlocksReductionOpportunity::Apply() { // While the original block that targeted the successor may not exist anymore // (it might have been merged with another block), some block must exist that // targets the successor. Find it. const auto predecessors = context_->cfg()->preds(successor_block_->id()); assert(1 == predecessors.size() && "For a successor to be merged into its predecessor, exactly one " "predecessor must be present."); const uint32_t predecessor_id = predecessors[0]; // We need an iterator pointing to the predecessor, hence the loop. for (auto bi = function_->begin(); bi != function_->end(); ++bi) { if (bi->id() == predecessor_id) { opt::blockmergeutil::MergeWithSuccessor(context_, function_, bi); // Block merging changes the control flow graph, so invalidate it. context_->InvalidateAnalysesExceptFor( opt::IRContext::Analysis::kAnalysisNone); return; } } assert(false && "Unreachable: we should have found a block with the desired id."); } } // namespace reduce } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/reduce/merge_blocks_reduction_opportunity.h000066400000000000000000000036201475742701700306560ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_REDUCE_MERGE_BLOCKS_REDUCTION_OPPORTUNITY_H_ #define SOURCE_REDUCE_MERGE_BLOCKS_REDUCTION_OPPORTUNITY_H_ #include "source/opt/basic_block.h" #include "source/opt/function.h" #include "source/reduce/reduction_opportunity.h" namespace spvtools { namespace reduce { // An opportunity to merge two blocks into one. class MergeBlocksReductionOpportunity : public ReductionOpportunity { public: // Creates the opportunity to merge |block| with its successor, where |block| // is inside |function|, and |context| is the enclosing IR context. MergeBlocksReductionOpportunity(opt::IRContext* context, opt::Function* function, opt::BasicBlock* block); bool PreconditionHolds() override; protected: void Apply() override; private: opt::IRContext* context_; opt::Function* function_; // Rather than holding on to the block that can be merged with its successor, // we hold on to its successor. This is because the predecessor block might // get merged with *its* predecessor, and so will no longer exist, while the // successor will continue to exist until this opportunity gets applied. opt::BasicBlock* successor_block_; }; } // namespace reduce } // namespace spvtools #endif // SOURCE_REDUCE_MERGE_BLOCKS_REDUCTION_OPPORTUNITY_H_ KhronosGroup-SPIRV-Tools-f289d04/source/reduce/merge_blocks_reduction_opportunity_finder.cpp000066400000000000000000000033061475742701700325410ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/merge_blocks_reduction_opportunity_finder.h" #include "source/opt/block_merge_util.h" #include "source/reduce/merge_blocks_reduction_opportunity.h" namespace spvtools { namespace reduce { std::string MergeBlocksReductionOpportunityFinder::GetName() const { return "MergeBlocksReductionOpportunityFinder"; } std::vector> MergeBlocksReductionOpportunityFinder::GetAvailableOpportunities( opt::IRContext* context, uint32_t target_function) const { std::vector> result; // Consider every block in every function. for (auto* function : GetTargetFunctions(context, target_function)) { for (auto& block : *function) { // See whether it is possible to merge this block with its successor. if (opt::blockmergeutil::CanMergeWithSuccessor(context, &block)) { // It is, so record an opportunity to do this. result.push_back(spvtools::MakeUnique( context, function, &block)); } } } return result; } } // namespace reduce } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/reduce/merge_blocks_reduction_opportunity_finder.h000066400000000000000000000026071475742701700322110ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_REDUCE_MERGE_BLOCKS_REDUCTION_OPPORTUNITY_FINDER_H_ #define SOURCE_REDUCE_MERGE_BLOCKS_REDUCTION_OPPORTUNITY_FINDER_H_ #include "source/reduce/reduction_opportunity_finder.h" namespace spvtools { namespace reduce { // A finder of opportunities to merge blocks together. class MergeBlocksReductionOpportunityFinder : public ReductionOpportunityFinder { public: MergeBlocksReductionOpportunityFinder() = default; ~MergeBlocksReductionOpportunityFinder() override = default; std::string GetName() const final; std::vector> GetAvailableOpportunities( opt::IRContext* context, uint32_t target_function) const final; private: }; } // namespace reduce } // namespace spvtools #endif // SOURCE_REDUCE_MERGE_BLOCKS_REDUCTION_OPPORTUNITY_FINDER_H_ KhronosGroup-SPIRV-Tools-f289d04/source/reduce/operand_to_const_reduction_opportunity_finder.cpp000066400000000000000000000065271475742701700334550ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/operand_to_const_reduction_opportunity_finder.h" #include "source/opt/instruction.h" #include "source/reduce/change_operand_reduction_opportunity.h" namespace spvtools { namespace reduce { std::vector> OperandToConstReductionOpportunityFinder::GetAvailableOpportunities( opt::IRContext* context, uint32_t target_function) const { std::vector> result; assert(result.empty()); // We first loop over all constants. This means that all the reduction // opportunities to replace an operand with a particular constant will be // contiguous, and in particular it means that multiple, incompatible // reduction opportunities that try to replace the same operand with distinct // constants are likely to be discontiguous. This is good because the // reducer works in the spirit of delta debugging and tries applying large // contiguous blocks of opportunities early on, and we want to avoid having a // large block of incompatible opportunities if possible. for (const auto& constant : context->GetConstants()) { for (auto* function : GetTargetFunctions(context, target_function)) { for (auto& block : *function) { for (auto& inst : block) { // We iterate through the operands using an explicit index (rather // than using a lambda) so that we use said index in the construction // of a ChangeOperandReductionOpportunity for (uint32_t index = 0; index < inst.NumOperands(); index++) { const auto& operand = inst.GetOperand(index); if (spvIsInIdType(operand.type)) { const auto id = operand.words[0]; auto def = context->get_def_use_mgr()->GetDef(id); if (spvOpcodeIsConstant(def->opcode())) { // The argument is already a constant. continue; } if (def->opcode() == spv::Op::OpFunction) { // The argument refers to a function, e.g. the function called // by OpFunctionCall; avoid replacing this with a constant of // the function's return type. continue; } auto type_id = def->type_id(); if (type_id) { if (constant->type_id() == type_id) { result.push_back( MakeUnique( &inst, index, constant->result_id())); } } } } } } } } return result; } std::string OperandToConstReductionOpportunityFinder::GetName() const { return "OperandToConstReductionOpportunityFinder"; } } // namespace reduce } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/reduce/operand_to_const_reduction_opportunity_finder.h000066400000000000000000000031151475742701700331100ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_REDUCE_OPERAND_TO_CONST_REDUCTION_OPPORTUNITY_FINDER_H_ #define SOURCE_REDUCE_OPERAND_TO_CONST_REDUCTION_OPPORTUNITY_FINDER_H_ #include "source/reduce/reduction_opportunity_finder.h" namespace spvtools { namespace reduce { // A finder for opportunities to replace id operands of instructions with ids of // constants. This reduces the extent to which ids of non-constants are used, // paving the way for instructions that generate them to be eliminated. class OperandToConstReductionOpportunityFinder : public ReductionOpportunityFinder { public: OperandToConstReductionOpportunityFinder() = default; ~OperandToConstReductionOpportunityFinder() override = default; std::string GetName() const final; std::vector> GetAvailableOpportunities( opt::IRContext* context, uint32_t target_function) const final; private: }; } // namespace reduce } // namespace spvtools #endif // SOURCE_REDUCE_OPERAND_TO_CONST_REDUCTION_OPPORTUNITY_FINDER_H_ operand_to_dominating_id_reduction_opportunity_finder.cpp000066400000000000000000000117251475742701700350510ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/reduce// Copyright (c) 2018 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/operand_to_dominating_id_reduction_opportunity_finder.h" #include "source/opt/instruction.h" #include "source/reduce/change_operand_reduction_opportunity.h" namespace spvtools { namespace reduce { std::vector> OperandToDominatingIdReductionOpportunityFinder::GetAvailableOpportunities( opt::IRContext* context, uint32_t target_function) const { std::vector> result; // Go through every instruction in every block, considering it as a potential // dominator of other instructions. We choose this order for two reasons: // // (1) it is profitable for multiple opportunities to replace the same id x by // different dominating ids y and z to be discontiguous, as they are // incompatible. // // (2) We want to prioritise opportunities to replace an id with a more // distant dominator. Intuitively, in a human-readable programming language // if we have a complex expression e with many sub-expressions, we would like // to prioritise replacing e with its smallest sub-expressions; generalising // this idea to dominating ids this roughly corresponds to more distant // dominators. for (auto* function : GetTargetFunctions(context, target_function)) { for (auto dominating_block = function->begin(); dominating_block != function->end(); ++dominating_block) { for (auto& dominating_inst : *dominating_block) { if (dominating_inst.HasResultId() && dominating_inst.type_id()) { // Consider replacing any operand with matching type in a dominated // instruction with the id generated by this instruction. GetOpportunitiesForDominatingInst( &result, &dominating_inst, dominating_block, function, context); } } } } return result; } void OperandToDominatingIdReductionOpportunityFinder:: GetOpportunitiesForDominatingInst( std::vector>* opportunities, opt::Instruction* candidate_dominator, opt::Function::iterator candidate_dominator_block, opt::Function* function, opt::IRContext* context) const { assert(candidate_dominator->HasResultId()); assert(candidate_dominator->type_id()); auto dominator_analysis = context->GetDominatorAnalysis(function); // SPIR-V requires a block to precede all blocks it dominates, so it suffices // to search from the candidate dominator block onwards. for (auto block = candidate_dominator_block; block != function->end(); ++block) { if (!dominator_analysis->Dominates(&*candidate_dominator_block, &*block)) { // If the candidate dominator block doesn't dominate this block then there // cannot be any of the desired reduction opportunities in this block. continue; } for (auto& inst : *block) { // We iterate through the operands using an explicit index (rather // than using a lambda) so that we use said index in the construction // of a ChangeOperandReductionOpportunity for (uint32_t index = 0; index < inst.NumOperands(); index++) { const auto& operand = inst.GetOperand(index); if (spvIsInIdType(operand.type)) { const auto id = operand.words[0]; auto def = context->get_def_use_mgr()->GetDef(id); assert(def); if (!context->get_instr_block(def)) { // The definition does not come from a block; e.g. it might be a // constant. It is thus not relevant to this pass. continue; } assert(!context->get_constant_mgr()->GetConstantFromInst(def) && "We should not get here if the argument is a constant."); if (def->type_id() != candidate_dominator->type_id()) { // The types need to match. continue; } if (candidate_dominator != def && dominator_analysis->Dominates(candidate_dominator, def)) { // A hit: the candidate dominator strictly dominates the definition. opportunities->push_back( MakeUnique( &inst, index, candidate_dominator->result_id())); } } } } } } std::string OperandToDominatingIdReductionOpportunityFinder::GetName() const { return "OperandToDominatingIdReductionOpportunityFinder"; } } // namespace reduce } // namespace spvtools operand_to_dominating_id_reduction_opportunity_finder.h000066400000000000000000000044201475742701700345100ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/reduce// Copyright (c) 2018 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_REDUCE_OPERAND_TO_DOMINATING_ID_REDUCTION_OPPORTUNITY_FINDER_H_ #define SOURCE_REDUCE_OPERAND_TO_DOMINATING_ID_REDUCTION_OPPORTUNITY_FINDER_H_ #include "source/reduce/reduction_opportunity_finder.h" namespace spvtools { namespace reduce { // A finder that aims to bring to SPIR-V (and generalize) the idea from // human-readable languages of e.g. finding opportunities to replace an // expression with one of its arguments, (x + y) -> x, or with a reference to an // identifier that was assigned to higher up in the program. The generalization // of this is to replace an id with a different id of the same type defined in // some dominating instruction. // // If id x is defined and then used several times, changing each use of x to // some dominating definition may eventually allow the statement defining x // to be eliminated by another pass. class OperandToDominatingIdReductionOpportunityFinder : public ReductionOpportunityFinder { public: OperandToDominatingIdReductionOpportunityFinder() = default; ~OperandToDominatingIdReductionOpportunityFinder() override = default; std::string GetName() const final; std::vector> GetAvailableOpportunities( opt::IRContext* context, uint32_t target_function) const final; private: void GetOpportunitiesForDominatingInst( std::vector>* opportunities, opt::Instruction* dominating_instruction, opt::Function::iterator candidate_dominator_block, opt::Function* function, opt::IRContext* context) const; }; } // namespace reduce } // namespace spvtools #endif // SOURCE_REDUCE_OPERAND_TO_DOMINATING_ID_REDUCTION_OPPORTUNITY_FINDER_H_ KhronosGroup-SPIRV-Tools-f289d04/source/reduce/operand_to_undef_reduction_opportunity_finder.cpp000066400000000000000000000064621475742701700334260ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/operand_to_undef_reduction_opportunity_finder.h" #include "source/opt/instruction.h" #include "source/reduce/change_operand_to_undef_reduction_opportunity.h" namespace spvtools { namespace reduce { std::vector> OperandToUndefReductionOpportunityFinder::GetAvailableOpportunities( opt::IRContext* context, uint32_t target_function) const { std::vector> result; for (auto* function : GetTargetFunctions(context, target_function)) { for (auto& block : *function) { for (auto& inst : block) { // Skip instructions that result in a pointer type. auto type_id = inst.type_id(); if (type_id) { auto type_id_def = context->get_def_use_mgr()->GetDef(type_id); if (type_id_def->opcode() == spv::Op::OpTypePointer) { continue; } } // We iterate through the operands using an explicit index (rather // than using a lambda) so that we use said index in the construction // of a ChangeOperandToUndefReductionOpportunity for (uint32_t index = 0; index < inst.NumOperands(); index++) { const auto& operand = inst.GetOperand(index); if (spvIsInIdType(operand.type)) { const auto operand_id = operand.words[0]; auto operand_id_def = context->get_def_use_mgr()->GetDef(operand_id); // Skip constant and undef operands. // We always want the reducer to make the module "smaller", which // ensures termination. // Therefore, we assume: id > undef id > constant id. if (spvOpcodeIsConstantOrUndef(operand_id_def->opcode())) { continue; } // Don't replace function operands with undef. if (operand_id_def->opcode() == spv::Op::OpFunction) { continue; } // Only consider operands that have a type. auto operand_type_id = operand_id_def->type_id(); if (operand_type_id) { auto operand_type_id_def = context->get_def_use_mgr()->GetDef(operand_type_id); // Skip pointer operands. if (operand_type_id_def->opcode() == spv::Op::OpTypePointer) { continue; } result.push_back( MakeUnique( context, &inst, index)); } } } } } } return result; } std::string OperandToUndefReductionOpportunityFinder::GetName() const { return "OperandToUndefReductionOpportunityFinder"; } } // namespace reduce } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/reduce/operand_to_undef_reduction_opportunity_finder.h000066400000000000000000000026771475742701700330770ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_REDUCE_OPERAND_TO_UNDEF_REDUCTION_OPPORTUNITY_FINDER_H_ #define SOURCE_REDUCE_OPERAND_TO_UNDEF_REDUCTION_OPPORTUNITY_FINDER_H_ #include "source/reduce/reduction_opportunity_finder.h" namespace spvtools { namespace reduce { // A finder of opportunities to replace id operands of instructions with ids of // undef. class OperandToUndefReductionOpportunityFinder : public ReductionOpportunityFinder { public: OperandToUndefReductionOpportunityFinder() = default; ~OperandToUndefReductionOpportunityFinder() override = default; std::string GetName() const final; std::vector> GetAvailableOpportunities( opt::IRContext* context, uint32_t target_function) const final; private: }; } // namespace reduce } // namespace spvtools #endif // SOURCE_REDUCE_OPERAND_TO_UNDEF_REDUCTION_OPPORTUNITY_FINDER_H_ KhronosGroup-SPIRV-Tools-f289d04/source/reduce/pch_source_reduce.cpp000066400000000000000000000011731475742701700254670ustar00rootroot00000000000000// Copyright (c) 2018 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "pch_source_reduce.h" KhronosGroup-SPIRV-Tools-f289d04/source/reduce/pch_source_reduce.h000066400000000000000000000020231475742701700251270ustar00rootroot00000000000000// Copyright (c) 2018 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include "source/reduce/change_operand_reduction_opportunity.h" #include "source/reduce/operand_to_const_reduction_opportunity_finder.h" #include "source/reduce/reduction_opportunity.h" #include "source/reduce/reduction_pass.h" #include "source/reduce/remove_instruction_reduction_opportunity.h" #include "source/reduce/remove_unused_instruction_reduction_opportunity_finder.h" KhronosGroup-SPIRV-Tools-f289d04/source/reduce/reducer.cpp000066400000000000000000000245571475742701700234520ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/reducer.h" #include #include #include "source/reduce/conditional_branch_to_simple_conditional_branch_opportunity_finder.h" #include "source/reduce/merge_blocks_reduction_opportunity_finder.h" #include "source/reduce/operand_to_const_reduction_opportunity_finder.h" #include "source/reduce/operand_to_dominating_id_reduction_opportunity_finder.h" #include "source/reduce/operand_to_undef_reduction_opportunity_finder.h" #include "source/reduce/remove_block_reduction_opportunity_finder.h" #include "source/reduce/remove_function_reduction_opportunity_finder.h" #include "source/reduce/remove_selection_reduction_opportunity_finder.h" #include "source/reduce/remove_unused_instruction_reduction_opportunity_finder.h" #include "source/reduce/remove_unused_struct_member_reduction_opportunity_finder.h" #include "source/reduce/simple_conditional_branch_to_branch_opportunity_finder.h" #include "source/reduce/structured_construct_to_block_reduction_opportunity_finder.h" #include "source/reduce/structured_loop_to_selection_reduction_opportunity_finder.h" #include "source/spirv_reducer_options.h" namespace spvtools { namespace reduce { Reducer::Reducer(spv_target_env target_env) : target_env_(target_env) {} Reducer::~Reducer() = default; void Reducer::SetMessageConsumer(MessageConsumer c) { for (auto& pass : passes_) { pass->SetMessageConsumer(c); } for (auto& pass : cleanup_passes_) { pass->SetMessageConsumer(c); } consumer_ = std::move(c); } void Reducer::SetInterestingnessFunction( Reducer::InterestingnessFunction interestingness_function) { interestingness_function_ = std::move(interestingness_function); } Reducer::ReductionResultStatus Reducer::Run( const std::vector& binary_in, std::vector* binary_out, spv_const_reducer_options options, spv_validator_options validator_options) { std::vector current_binary(binary_in); spvtools::SpirvTools tools(target_env_); assert(tools.IsValid() && "Failed to create SPIRV-Tools interface"); // Keeps track of how many reduction attempts have been tried. Reduction // bails out if this reaches a given limit. uint32_t reductions_applied = 0; // Initial state should be valid. if (!tools.Validate(¤t_binary[0], current_binary.size(), validator_options)) { consumer_(SPV_MSG_INFO, nullptr, {}, "Initial binary is invalid; stopping."); return Reducer::ReductionResultStatus::kInitialStateInvalid; } // Initial state should be interesting. if (!interestingness_function_(current_binary, reductions_applied)) { consumer_(SPV_MSG_INFO, nullptr, {}, "Initial state was not interesting; stopping."); return Reducer::ReductionResultStatus::kInitialStateNotInteresting; } Reducer::ReductionResultStatus result = RunPasses(&passes_, options, validator_options, tools, ¤t_binary, &reductions_applied); if (result == Reducer::ReductionResultStatus::kComplete) { // Cleanup passes. result = RunPasses(&cleanup_passes_, options, validator_options, tools, ¤t_binary, &reductions_applied); } if (result == Reducer::ReductionResultStatus::kComplete) { consumer_(SPV_MSG_INFO, nullptr, {}, "No more to reduce; stopping."); } // Even if the reduction has failed by this point (e.g. due to producing an // invalid binary), we still update the output binary for better debugging. *binary_out = std::move(current_binary); return result; } void Reducer::AddDefaultReductionPasses() { AddReductionPass( spvtools::MakeUnique( false)); AddReductionPass( spvtools::MakeUnique()); AddReductionPass( spvtools::MakeUnique()); AddReductionPass( spvtools::MakeUnique()); AddReductionPass(spvtools::MakeUnique< StructuredConstructToBlockReductionOpportunityFinder>()); AddReductionPass(spvtools::MakeUnique< StructuredLoopToSelectionReductionOpportunityFinder>()); AddReductionPass( spvtools::MakeUnique()); AddReductionPass( spvtools::MakeUnique()); AddReductionPass( spvtools::MakeUnique()); AddReductionPass( spvtools::MakeUnique()); AddReductionPass( spvtools::MakeUnique< ConditionalBranchToSimpleConditionalBranchOpportunityFinder>()); AddReductionPass( spvtools::MakeUnique()); AddReductionPass(spvtools::MakeUnique< RemoveUnusedStructMemberReductionOpportunityFinder>()); // Cleanup passes. AddCleanupReductionPass( spvtools::MakeUnique( true)); } void Reducer::AddReductionPass( std::unique_ptr finder) { passes_.push_back( spvtools::MakeUnique(target_env_, std::move(finder))); } void Reducer::AddCleanupReductionPass( std::unique_ptr finder) { cleanup_passes_.push_back( spvtools::MakeUnique(target_env_, std::move(finder))); } bool Reducer::ReachedStepLimit(uint32_t current_step, spv_const_reducer_options options) { return current_step >= options->step_limit; } Reducer::ReductionResultStatus Reducer::RunPasses( std::vector>* passes, spv_const_reducer_options options, spv_validator_options validator_options, const SpirvTools& tools, std::vector* current_binary, uint32_t* const reductions_applied) { // Determines whether, on completing one round of reduction passes, it is // worthwhile trying a further round. bool another_round_worthwhile = true; // Apply round after round of reduction passes until we hit the reduction // step limit, or deem that another round is not going to be worthwhile. while (!ReachedStepLimit(*reductions_applied, options) && another_round_worthwhile) { // At the start of a round of reduction passes, assume another round will // not be worthwhile unless we find evidence to the contrary. another_round_worthwhile = false; // Iterate through the available passes. for (auto& pass : *passes) { // If this pass hasn't reached its minimum granularity then it's // worth eventually doing another round of reductions, in order to // try this pass at a finer granularity. another_round_worthwhile |= !pass->ReachedMinimumGranularity(); // Keep applying this pass at its current granularity until it stops // working or we hit the reduction step limit. consumer_(SPV_MSG_INFO, nullptr, {}, ("Trying pass " + pass->GetName() + ".").c_str()); do { auto maybe_result = pass->TryApplyReduction(*current_binary, options->target_function); if (maybe_result.empty()) { // For this round, the pass has no more opportunities (chunks) to // apply, so move on to the next pass. consumer_( SPV_MSG_INFO, nullptr, {}, ("Pass " + pass->GetName() + " did not make a reduction step.") .c_str()); break; } bool interesting = false; std::stringstream stringstream; (*reductions_applied)++; stringstream << "Pass " << pass->GetName() << " made reduction step " << *reductions_applied << "."; consumer_(SPV_MSG_INFO, nullptr, {}, (stringstream.str().c_str())); if (!tools.Validate(&maybe_result[0], maybe_result.size(), validator_options)) { // The reduction step went wrong and an invalid binary was produced. // By design, this shouldn't happen; this is a safeguard to stop an // invalid binary from being regarded as interesting. consumer_(SPV_MSG_INFO, nullptr, {}, "Reduction step produced an invalid binary."); if (options->fail_on_validation_error) { // In this mode, we fail, so we update the current binary so it is // output for debugging. *current_binary = std::move(maybe_result); return Reducer::ReductionResultStatus::kStateInvalid; } } else if (interestingness_function_(maybe_result, *reductions_applied)) { // Success! The binary produced by this reduction step is // interesting, so make it the binary of interest henceforth, and // note that it's worth doing another round of reduction passes. consumer_(SPV_MSG_INFO, nullptr, {}, "Reduction step succeeded."); *current_binary = std::move(maybe_result); interesting = true; another_round_worthwhile = true; } // We must call this before the next call to TryApplyReduction. pass->NotifyInteresting(interesting); // Bail out if the reduction step limit has been reached. } while (!ReachedStepLimit(*reductions_applied, options)); } } // Report whether reduction completed, or bailed out early due to reaching // the step limit. if (ReachedStepLimit(*reductions_applied, options)) { consumer_(SPV_MSG_INFO, nullptr, {}, "Reached reduction step limit; stopping."); return Reducer::ReductionResultStatus::kReachedStepLimit; } // The passes completed successfully, although we may still run more passes. return Reducer::ReductionResultStatus::kComplete; } } // namespace reduce } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/reduce/reducer.h000066400000000000000000000111241475742701700231010ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_REDUCE_REDUCER_H_ #define SOURCE_REDUCE_REDUCER_H_ #include #include #include "source/reduce/reduction_pass.h" #include "spirv-tools/libspirv.hpp" namespace spvtools { namespace reduce { // This class manages the process of applying a reduction -- parameterized by a // number of reduction passes and an interestingness test, to a SPIR-V binary. class Reducer { public: // Possible statuses that can result from running a reduction. enum ReductionResultStatus { kInitialStateNotInteresting, kReachedStepLimit, kComplete, kInitialStateInvalid, // Returned when the fail-on-validation-error option is set and a // reduction step yields a state that fails validation. kStateInvalid, }; // The type for a function that will take a binary and return true if and // only if the binary is deemed interesting. (The function also takes an // integer argument that will be incremented each time the function is // called; this is for debugging purposes). // // The notion of "interesting" depends on what properties of the binary or // tools that process the binary we are trying to maintain during reduction. using InterestingnessFunction = std::function&, uint32_t)>; // Constructs an instance with the given target |target_env|, which is used to // decode the binary to be reduced later. // // The constructed instance will have an empty message consumer, which just // ignores all messages from the library. Use SetMessageConsumer() to supply // one if messages are of concern. // // The constructed instance also needs to have an interestingness function // set and some reduction passes added to it in order to be useful. explicit Reducer(spv_target_env target_env); // Disables copy/move constructor/assignment operations. Reducer(const Reducer&) = delete; Reducer(Reducer&&) = delete; Reducer& operator=(const Reducer&) = delete; Reducer& operator=(Reducer&&) = delete; // Destructs this instance. ~Reducer(); // Sets the message consumer to the given |consumer|. The |consumer| will be // invoked once for each message communicated from the library. void SetMessageConsumer(MessageConsumer consumer); // Sets the function that will be used to decide whether a reduced binary // turned out to be interesting. void SetInterestingnessFunction( InterestingnessFunction interestingness_function); // Adds all default reduction passes. void AddDefaultReductionPasses(); // Adds a reduction pass based on the given finder to the sequence of passes // that will be iterated over. void AddReductionPass(std::unique_ptr finder); // Adds a cleanup reduction pass based on the given finder to the sequence of // passes that will run after other passes. void AddCleanupReductionPass( std::unique_ptr finder); // Reduces the given SPIR-V module |binary_out|. // The reduced binary ends up in |binary_out|. // A status is returned. ReductionResultStatus Run(const std::vector& binary_in, std::vector* binary_out, spv_const_reducer_options options, spv_validator_options validator_options); private: static bool ReachedStepLimit(uint32_t current_step, spv_const_reducer_options options); ReductionResultStatus RunPasses( std::vector>* passes, spv_const_reducer_options options, spv_validator_options validator_options, const SpirvTools& tools, std::vector* current_binary, uint32_t* reductions_applied); const spv_target_env target_env_; MessageConsumer consumer_; InterestingnessFunction interestingness_function_; std::vector> passes_; std::vector> cleanup_passes_; }; } // namespace reduce } // namespace spvtools #endif // SOURCE_REDUCE_REDUCER_H_ KhronosGroup-SPIRV-Tools-f289d04/source/reduce/reduction_opportunity.cpp000066400000000000000000000014661475742701700265030ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/reduction_opportunity.h" namespace spvtools { namespace reduce { void ReductionOpportunity::TryToApply() { if (PreconditionHolds()) { Apply(); } } } // namespace reduce } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/reduce/reduction_opportunity.h000066400000000000000000000030541475742701700261430ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_REDUCE_REDUCTION_OPPORTUNITY_H_ #define SOURCE_REDUCE_REDUCTION_OPPORTUNITY_H_ #include "spirv-tools/libspirv.hpp" namespace spvtools { namespace reduce { // Abstract class: an opportunity to apply a reducing transformation. class ReductionOpportunity { public: ReductionOpportunity() = default; virtual ~ReductionOpportunity() = default; // Returns true if this opportunity has not been disabled by the application // of another conflicting opportunity. virtual bool PreconditionHolds() = 0; // Applies the opportunity, mutating the module from which the opportunity was // created. It is a no-op if PreconditionHolds() returns false. void TryToApply(); protected: // Applies the opportunity, mutating the module from which the opportunity was // created. // Precondition: PreconditionHolds() must return true. virtual void Apply() = 0; }; } // namespace reduce } // namespace spvtools #endif // SOURCE_REDUCE_REDUCTION_OPPORTUNITY_H_ KhronosGroup-SPIRV-Tools-f289d04/source/reduce/reduction_opportunity_finder.cpp000066400000000000000000000022401475742701700300210ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "reduction_opportunity_finder.h" namespace spvtools { namespace reduce { std::vector ReductionOpportunityFinder::GetTargetFunctions( opt::IRContext* ir_context, uint32_t target_function) { std::vector result; for (auto& function : *ir_context->module()) { if (!target_function || function.result_id() == target_function) { result.push_back(&function); } } assert((!target_function || !result.empty()) && "Requested target function must exist."); return result; } } // namespace reduce } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/reduce/reduction_opportunity_finder.h000066400000000000000000000042111475742701700274660ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_REDUCE_REDUCTION_OPPORTUNITY_FINDER_H_ #define SOURCE_REDUCE_REDUCTION_OPPORTUNITY_FINDER_H_ #include #include "source/opt/ir_context.h" #include "source/reduce/reduction_opportunity.h" namespace spvtools { namespace reduce { // Abstract class for finding opportunities for reducing a SPIR-V module. class ReductionOpportunityFinder { public: ReductionOpportunityFinder() = default; virtual ~ReductionOpportunityFinder() = default; // Finds and returns the reduction opportunities relevant to this pass that // could be applied to SPIR-V module |context|. // // If |target_function| is non-zero then the available opportunities will be // restricted to only those opportunities that modify the function with result // id |target_function|. virtual std::vector> GetAvailableOpportunities(opt::IRContext* context, uint32_t target_function) const = 0; // Provides a name for the finder. virtual std::string GetName() const = 0; protected: // Requires that |target_function| is zero or the id of a function in // |ir_context|. If |target_function| is zero, returns all the functions in // |ir_context|. Otherwise, returns the function with id |target_function|. // This allows fuzzer passes to restrict attention to a single function. static std::vector GetTargetFunctions( opt::IRContext* ir_context, uint32_t target_function); }; } // namespace reduce } // namespace spvtools #endif // SOURCE_REDUCE_REDUCTION_OPPORTUNITY_FINDER_H_ KhronosGroup-SPIRV-Tools-f289d04/source/reduce/reduction_pass.cpp000066400000000000000000000056251475742701700250360ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/reduction_pass.h" #include #include "source/opt/build_module.h" namespace spvtools { namespace reduce { std::vector ReductionPass::TryApplyReduction( const std::vector& binary, uint32_t target_function) { // We represent modules as binaries because (a) attempts at reduction need to // end up in binary form to be passed on to SPIR-V-consuming tools, and (b) // when we apply a reduction step we need to do it on a fresh version of the // module as if the reduction step proves to be uninteresting we need to // backtrack; re-parsing from binary provides a very clean way of cloning the // module. std::unique_ptr context = BuildModule(target_env_, consumer_, binary.data(), binary.size()); assert(context); std::vector> opportunities = finder_->GetAvailableOpportunities(context.get(), target_function); // There is no point in having a granularity larger than the number of // opportunities, so reduce the granularity in this case. if (granularity_ > opportunities.size()) { granularity_ = std::max((uint32_t)1, (uint32_t)opportunities.size()); } assert(granularity_ > 0); if (index_ >= opportunities.size()) { // We have reached the end of the available opportunities and, therefore, // the end of the round for this pass, so reset the index and decrease the // granularity for the next round. Return an empty vector to signal the end // of the round. index_ = 0; granularity_ = std::max((uint32_t)1, granularity_ / 2); return std::vector(); } for (uint32_t i = index_; i < std::min(index_ + granularity_, (uint32_t)opportunities.size()); ++i) { opportunities[i]->TryToApply(); } std::vector result; context->module()->ToBinary(&result, false); return result; } void ReductionPass::SetMessageConsumer(MessageConsumer consumer) { consumer_ = std::move(consumer); } bool ReductionPass::ReachedMinimumGranularity() const { assert(granularity_ != 0); return granularity_ == 1; } std::string ReductionPass::GetName() const { return finder_->GetName(); } void ReductionPass::NotifyInteresting(bool interesting) { if (!interesting) { index_ += granularity_; } } } // namespace reduce } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/reduce/reduction_pass.h000066400000000000000000000067271475742701700245070ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_REDUCE_REDUCTION_PASS_H_ #define SOURCE_REDUCE_REDUCTION_PASS_H_ #include #include "source/opt/ir_context.h" #include "source/reduce/reduction_opportunity_finder.h" #include "spirv-tools/libspirv.hpp" namespace spvtools { namespace reduce { // Abstract class representing a reduction pass, which can be repeatedly // invoked to find and apply particular reduction opportunities to a SPIR-V // binary. In the spirit of delta debugging, a pass initially tries to apply // large chunks of reduction opportunities, iterating through available // opportunities at a given granularity. When an iteration over available // opportunities completes, the granularity is reduced and iteration starts // again, until the minimum granularity is reached. class ReductionPass { public: // Constructs a reduction pass with a given target environment, |target_env|, // and a given finder of reduction opportunities, |finder|. explicit ReductionPass(const spv_target_env target_env, std::unique_ptr finder) : target_env_(target_env), finder_(std::move(finder)), index_(0), granularity_(std::numeric_limits::max()) {} // Applies the reduction pass to the given binary by applying a "chunk" of // reduction opportunities. Returns the new binary if a chunk was applied; in // this case, before the next call the caller must invoke // NotifyInteresting(...) to indicate whether the new binary is interesting. // Returns an empty vector if there are no more chunks left to apply; in this // case, the index will be reset and the granularity lowered for the next // round. // // If |target_function| is non-zero, only reduction opportunities that // simplify the internals of the function with result id |target_function| // will be applied. std::vector TryApplyReduction(const std::vector& binary, uint32_t target_function); // Notifies the reduction pass whether the binary returned from // TryApplyReduction is interesting, so that the next call to // TryApplyReduction will avoid applying the same chunk of opportunities. void NotifyInteresting(bool interesting); // Sets a consumer to which relevant messages will be directed. void SetMessageConsumer(MessageConsumer consumer); // Returns true if the granularity with which reduction opportunities are // applied has reached a minimum. bool ReachedMinimumGranularity() const; // Returns the name associated with this reduction pass (based on its // associated finder). std::string GetName() const; private: const spv_target_env target_env_; const std::unique_ptr finder_; MessageConsumer consumer_; uint32_t index_; uint32_t granularity_; }; } // namespace reduce } // namespace spvtools #endif // SOURCE_REDUCE_REDUCTION_PASS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/reduce/reduction_util.cpp000066400000000000000000000112421475742701700250350ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/reduction_util.h" #include "source/opt/ir_context.h" #include "source/util/make_unique.h" namespace spvtools { namespace reduce { const uint32_t kTrueBranchOperandIndex = 1; const uint32_t kFalseBranchOperandIndex = 2; uint32_t FindOrCreateGlobalVariable(opt::IRContext* context, uint32_t pointer_type_id) { for (auto& inst : context->module()->types_values()) { if (inst.opcode() != spv::Op::OpVariable) { continue; } if (inst.type_id() == pointer_type_id) { return inst.result_id(); } } const uint32_t variable_id = context->TakeNextId(); auto variable_inst = MakeUnique( context, spv::Op::OpVariable, pointer_type_id, variable_id, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_STORAGE_CLASS, {static_cast(context->get_type_mgr() ->GetType(pointer_type_id) ->AsPointer() ->storage_class())}}})); context->module()->AddGlobalValue(std::move(variable_inst)); return variable_id; } uint32_t FindOrCreateFunctionVariable(opt::IRContext* context, opt::Function* function, uint32_t pointer_type_id) { // The pointer type of a function variable must have Function storage class. assert(context->get_type_mgr() ->GetType(pointer_type_id) ->AsPointer() ->storage_class() == spv::StorageClass::Function); // Go through the instructions in the function's first block until we find a // suitable variable, or go past all the variables. opt::BasicBlock::iterator iter = function->begin()->begin(); for (;; ++iter) { // We will either find a suitable variable, or find a non-variable // instruction; we won't exhaust all instructions. assert(iter != function->begin()->end()); if (iter->opcode() != spv::Op::OpVariable) { // If we see a non-variable, we have gone through all the variables. break; } if (iter->type_id() == pointer_type_id) { return iter->result_id(); } } // At this point, iter refers to the first non-function instruction of the // function's entry block. const uint32_t variable_id = context->TakeNextId(); auto variable_inst = MakeUnique( context, spv::Op::OpVariable, pointer_type_id, variable_id, opt::Instruction::OperandList( {{SPV_OPERAND_TYPE_STORAGE_CLASS, {uint32_t(spv::StorageClass::Function)}}})); iter->InsertBefore(std::move(variable_inst)); return variable_id; } uint32_t FindOrCreateGlobalUndef(opt::IRContext* context, uint32_t type_id) { for (auto& inst : context->module()->types_values()) { if (inst.opcode() != spv::Op::OpUndef) { continue; } if (inst.type_id() == type_id) { return inst.result_id(); } } const uint32_t undef_id = context->TakeNextId(); auto undef_inst = MakeUnique(context, spv::Op::OpUndef, type_id, undef_id, opt::Instruction::OperandList()); assert(undef_id == undef_inst->result_id()); context->module()->AddGlobalValue(std::move(undef_inst)); return undef_id; } void AdaptPhiInstructionsForRemovedEdge(uint32_t from_id, opt::BasicBlock* to_block) { to_block->ForEachPhiInst([&from_id](opt::Instruction* phi_inst) { opt::Instruction::OperandList new_in_operands; // Go through the OpPhi's input operands in (variable, parent) pairs. for (uint32_t index = 0; index < phi_inst->NumInOperands(); index += 2) { // Keep all pairs where the parent is not the block from which the edge // is being removed. if (phi_inst->GetInOperand(index + 1).words[0] != from_id) { new_in_operands.push_back(phi_inst->GetInOperand(index)); new_in_operands.push_back(phi_inst->GetInOperand(index + 1)); } } phi_inst->SetInOperands(std::move(new_in_operands)); }); } } // namespace reduce } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/reduce/reduction_util.h000066400000000000000000000035421475742701700245060ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_REDUCE_REDUCTION_UTIL_H_ #define SOURCE_REDUCE_REDUCTION_UTIL_H_ #include "spirv-tools/libspirv.hpp" #include "source/opt/ir_context.h" #include "source/reduce/reduction_opportunity.h" namespace spvtools { namespace reduce { extern const uint32_t kTrueBranchOperandIndex; extern const uint32_t kFalseBranchOperandIndex; // Returns a global OpVariable of type |pointer_type_id|, adding one if none // exist. uint32_t FindOrCreateGlobalVariable(opt::IRContext* context, uint32_t pointer_type_id); // Returns an OpVariable of type |pointer_type_id| declared in |function|, // adding one if none exist. uint32_t FindOrCreateFunctionVariable(opt::IRContext* context, opt::Function*, uint32_t pointer_type_id); // Returns an OpUndef id from the global value list that is of the given type, // adding one if it does not exist. uint32_t FindOrCreateGlobalUndef(opt::IRContext* context, uint32_t type_id); // Removes any components of |to_block|'s phi instructions relating to // |from_id|. void AdaptPhiInstructionsForRemovedEdge(uint32_t from_id, opt::BasicBlock* to_block); } // namespace reduce } // namespace spvtools #endif // SOURCE_REDUCE_REDUCTION_UTIL_H_ KhronosGroup-SPIRV-Tools-f289d04/source/reduce/remove_block_reduction_opportunity.cpp000066400000000000000000000033471475742701700312320ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/remove_block_reduction_opportunity.h" #include "source/opt/ir_context.h" namespace spvtools { namespace reduce { RemoveBlockReductionOpportunity::RemoveBlockReductionOpportunity( opt::IRContext* context, opt::Function* function, opt::BasicBlock* block) : context_(context), function_(function), block_(block) { // precondition: assert(block_->begin() != block_->end() && context_->get_def_use_mgr()->NumUsers(block_->id()) == 0 && "RemoveBlockReductionOpportunity block must have 0 references"); } bool RemoveBlockReductionOpportunity::PreconditionHolds() { // Removing other blocks cannot disable this opportunity. return true; } void RemoveBlockReductionOpportunity::Apply() { // We need an iterator pointing to the block, hence the loop. for (auto bi = function_->begin(); bi != function_->end(); ++bi) { if (bi->id() == block_->id()) { bi.Erase(); context_->InvalidateAnalysesExceptFor(opt::IRContext::kAnalysisNone); return; } } assert(false && "Unreachable: we should have found a block with the desired id."); } } // namespace reduce } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/reduce/remove_block_reduction_opportunity.h000066400000000000000000000030631475742701700306720ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_REDUCE_REMOVE_BLOCK_REDUCTION_OPPORTUNITY_H_ #define SOURCE_REDUCE_REMOVE_BLOCK_REDUCTION_OPPORTUNITY_H_ #include "source/opt/basic_block.h" #include "source/opt/function.h" #include "source/reduce/reduction_opportunity.h" namespace spvtools { namespace reduce { // An opportunity to remove an unreferenced block. // See RemoveBlockReductionOpportunityFinder. class RemoveBlockReductionOpportunity : public ReductionOpportunity { public: // Creates the opportunity to remove |block| in |function| in |context|. RemoveBlockReductionOpportunity(opt::IRContext* context, opt::Function* function, opt::BasicBlock* block); bool PreconditionHolds() override; protected: void Apply() override; private: opt::IRContext* context_; opt::Function* function_; opt::BasicBlock* block_; }; } // namespace reduce } // namespace spvtools #endif // SOURCE_REDUCE_REMOVE_BLOCK_REDUCTION_OPPORTUNITY_H_ KhronosGroup-SPIRV-Tools-f289d04/source/reduce/remove_block_reduction_opportunity_finder.cpp000066400000000000000000000062461475742701700325620ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/remove_block_reduction_opportunity_finder.h" #include "source/reduce/remove_block_reduction_opportunity.h" namespace spvtools { namespace reduce { std::string RemoveBlockReductionOpportunityFinder::GetName() const { return "RemoveBlockReductionOpportunityFinder"; } std::vector> RemoveBlockReductionOpportunityFinder::GetAvailableOpportunities( opt::IRContext* context, uint32_t target_function) const { std::vector> result; // Consider every block in every relevant function. for (auto* function : GetTargetFunctions(context, target_function)) { for (auto bi = function->begin(); bi != function->end(); ++bi) { if (IsBlockValidOpportunity(context, function, &bi)) { result.push_back(MakeUnique( context, function, &*bi)); } } } return result; } bool RemoveBlockReductionOpportunityFinder::IsBlockValidOpportunity( opt::IRContext* context, opt::Function* function, opt::Function::iterator* bi) { assert(*bi != function->end() && "Block iterator was out of bounds"); // Don't remove first block; we don't want to end up with no blocks. if (*bi == function->begin()) { return false; } // Don't remove blocks with references. if (context->get_def_use_mgr()->NumUsers((*bi)->id()) > 0) { return false; } // Don't remove blocks whose instructions have outside references. if (!BlockInstructionsHaveNoOutsideReferences(context, *bi)) { return false; } return true; } bool RemoveBlockReductionOpportunityFinder:: BlockInstructionsHaveNoOutsideReferences( opt::IRContext* context, const opt::Function::iterator& bi) { // Get all instructions in block. std::unordered_set instructions_in_block; for (const opt::Instruction& instruction : *bi) { instructions_in_block.insert(instruction.unique_id()); } // For each instruction... for (const opt::Instruction& instruction : *bi) { // For each use of the instruction... bool no_uses_outside_block = context->get_def_use_mgr()->WhileEachUser( &instruction, [&instructions_in_block](opt::Instruction* user) -> bool { // If the use is in this block, continue (return true). Otherwise, we // found an outside use; return false (and stop). return instructions_in_block.find(user->unique_id()) != instructions_in_block.end(); }); if (!no_uses_outside_block) { return false; } } return true; } } // namespace reduce } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/reduce/remove_block_reduction_opportunity_finder.h000066400000000000000000000041331475742701700322200ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_REDUCE_REMOVE_BLOCK_REDUCTION_OPPORTUNITY_FINDER_H_ #define SOURCE_REDUCE_REMOVE_BLOCK_REDUCTION_OPPORTUNITY_FINDER_H_ #include "source/opt/function.h" #include "source/reduce/reduction_opportunity_finder.h" namespace spvtools { namespace reduce { // A finder of opportunities to remove a block. The optimizer can remove dead // code. However, the reducer needs to be able to remove at a fine-grained // level. class RemoveBlockReductionOpportunityFinder : public ReductionOpportunityFinder { public: RemoveBlockReductionOpportunityFinder() = default; ~RemoveBlockReductionOpportunityFinder() override = default; std::string GetName() const final; std::vector> GetAvailableOpportunities( opt::IRContext* context, uint32_t target_function) const final; private: // Returns true if the block |bi| in function |function| is a valid // opportunity according to various restrictions. static bool IsBlockValidOpportunity(opt::IRContext* context, opt::Function* function, opt::Function::iterator* bi); // Returns true if the instructions (definitions) in block |bi| have no // references, except for references from inside the block itself. static bool BlockInstructionsHaveNoOutsideReferences( opt::IRContext* context, const opt::Function::iterator& bi); }; } // namespace reduce } // namespace spvtools #endif // SOURCE_REDUCE_REMOVE_BLOCK_REDUCTION_OPPORTUNITY_FINDER_H_ KhronosGroup-SPIRV-Tools-f289d04/source/reduce/remove_function_reduction_opportunity.cpp000066400000000000000000000025521475742701700317620ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/remove_function_reduction_opportunity.h" #include "source/opt/eliminate_dead_functions_util.h" namespace spvtools { namespace reduce { bool RemoveFunctionReductionOpportunity::PreconditionHolds() { // Removing one function cannot influence whether another function can be // removed. return true; } void RemoveFunctionReductionOpportunity::Apply() { for (opt::Module::iterator function_it = context_->module()->begin(); function_it != context_->module()->end(); ++function_it) { if (&*function_it == function_) { function_it.Erase(); context_->InvalidateAnalysesExceptFor(opt::IRContext::kAnalysisNone); return; } } assert(0 && "Function to be removed was not found."); } } // namespace reduce } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/reduce/remove_function_reduction_opportunity.h000066400000000000000000000031041475742701700314210ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_REDUCE_REMOVE_FUNCTION_REDUCTION_OPPORTUNITY_H_ #define SOURCE_REDUCE_REMOVE_FUNCTION_REDUCTION_OPPORTUNITY_H_ #include "source/opt/function.h" #include "source/reduce/reduction_opportunity.h" namespace spvtools { namespace reduce { // An opportunity to remove an unreferenced function. class RemoveFunctionReductionOpportunity : public ReductionOpportunity { public: // Creates an opportunity to remove |function| from the module represented by // |context|. RemoveFunctionReductionOpportunity(opt::IRContext* context, opt::Function* function) : context_(context), function_(function) {} bool PreconditionHolds() override; protected: void Apply() override; private: // The IR context for the module under analysis. opt::IRContext* context_; // The function that can be removed. opt::Function* function_; }; } // namespace reduce } // namespace spvtools #endif // SOURCE_REDUCE_REMOVE_FUNCTION_REDUCTION_OPPORTUNITY_H_ KhronosGroup-SPIRV-Tools-f289d04/source/reduce/remove_function_reduction_opportunity_finder.cpp000066400000000000000000000033651475742701700333140ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/remove_function_reduction_opportunity_finder.h" #include "source/reduce/remove_function_reduction_opportunity.h" namespace spvtools { namespace reduce { std::vector> RemoveFunctionReductionOpportunityFinder::GetAvailableOpportunities( opt::IRContext* context, uint32_t target_function) const { if (target_function) { // If we are targeting a specific function then we are only interested in // opportunities that simplify the internals of that function; removing // whole functions does not fit the bill. return {}; } std::vector> result; // Consider each function. for (auto& function : *context->module()) { if (context->get_def_use_mgr()->NumUses(function.result_id()) > 0) { // If the function is referenced, ignore it. continue; } result.push_back( MakeUnique(context, &function)); } return result; } std::string RemoveFunctionReductionOpportunityFinder::GetName() const { return "RemoveFunctionReductionOpportunityFinder"; } } // namespace reduce } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/reduce/remove_function_reduction_opportunity_finder.h000066400000000000000000000026431475742701700327570ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_REDUCE_REMOVE_FUNCTION_REDUCTION_OPPORTUNITY_FINDER_H_ #define SOURCE_REDUCE_REMOVE_FUNCTION_REDUCTION_OPPORTUNITY_FINDER_H_ #include "source/reduce/reduction_opportunity_finder.h" namespace spvtools { namespace reduce { // A finder of opportunities to remove unreferenced functions. class RemoveFunctionReductionOpportunityFinder : public ReductionOpportunityFinder { public: RemoveFunctionReductionOpportunityFinder() = default; ~RemoveFunctionReductionOpportunityFinder() override = default; std::string GetName() const final; std::vector> GetAvailableOpportunities( opt::IRContext* context, uint32_t target_function) const final; private: }; } // namespace reduce } // namespace spvtools #endif // SOURCE_REDUCE_REMOVE_FUNCTION_REDUCTION_OPPORTUNITY_FINDER_H_ KhronosGroup-SPIRV-Tools-f289d04/source/reduce/remove_instruction_reduction_opportunity.cpp000066400000000000000000000030371475742701700325150ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/remove_instruction_reduction_opportunity.h" #include "source/opt/ir_context.h" namespace spvtools { namespace reduce { bool RemoveInstructionReductionOpportunity::PreconditionHolds() { return true; } void RemoveInstructionReductionOpportunity::Apply() { const uint32_t kNumEntryPointInOperandsBeforeInterfaceIds = 3; for (auto& entry_point : inst_->context()->module()->entry_points()) { opt::Instruction::OperandList new_entry_point_in_operands; for (uint32_t index = 0; index < entry_point.NumInOperands(); index++) { if (index >= kNumEntryPointInOperandsBeforeInterfaceIds && entry_point.GetSingleWordInOperand(index) == inst_->result_id()) { continue; } new_entry_point_in_operands.push_back(entry_point.GetInOperand(index)); } entry_point.SetInOperands(std::move(new_entry_point_in_operands)); } inst_->context()->KillInst(inst_); } } // namespace reduce } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/reduce/remove_instruction_reduction_opportunity.h000066400000000000000000000026571475742701700321710ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_REDUCE_REMOVE_INSTRUCTION_REDUCTION_OPPORTUNITY_H_ #define SOURCE_REDUCE_REMOVE_INSTRUCTION_REDUCTION_OPPORTUNITY_H_ #include "source/opt/instruction.h" #include "source/reduce/reduction_opportunity.h" namespace spvtools { namespace reduce { // An opportunity to remove an instruction from the SPIR-V module. class RemoveInstructionReductionOpportunity : public ReductionOpportunity { public: // Constructs the opportunity to remove |inst|. explicit RemoveInstructionReductionOpportunity(opt::Instruction* inst) : inst_(inst) {} // Always returns true, as this opportunity can always be applied. bool PreconditionHolds() override; protected: void Apply() override; private: opt::Instruction* inst_; }; } // namespace reduce } // namespace spvtools #endif // SOURCE_REDUCE_REMOVE_INSTRUCTION_REDUCTION_OPPORTUNITY_H_ KhronosGroup-SPIRV-Tools-f289d04/source/reduce/remove_selection_reduction_opportunity.cpp000066400000000000000000000020621475742701700321160ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/remove_selection_reduction_opportunity.h" #include "source/opt/basic_block.h" #include "source/opt/ir_context.h" namespace spvtools { namespace reduce { bool RemoveSelectionReductionOpportunity::PreconditionHolds() { return true; } void RemoveSelectionReductionOpportunity::Apply() { auto merge_instruction = header_block_->GetMergeInst(); merge_instruction->context()->KillInst(merge_instruction); } } // namespace reduce } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/reduce/remove_selection_reduction_opportunity.h000066400000000000000000000031511475742701700315630ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_REDUCE_REMOVE_SELECTION_REDUCTION_OPPORTUNITY_H_ #define SOURCE_REDUCE_REMOVE_SELECTION_REDUCTION_OPPORTUNITY_H_ #include "source/opt/basic_block.h" #include "source/reduce/reduction_opportunity.h" namespace spvtools { namespace reduce { // An opportunity for removing a selection construct by simply removing the // OpSelectionMerge instruction; thus, the selection must have already been // simplified to a point where the instruction can be trivially removed. class RemoveSelectionReductionOpportunity : public ReductionOpportunity { public: // Constructs a reduction opportunity from the selection header |block| in // |function|. RemoveSelectionReductionOpportunity(opt::BasicBlock* header_block) : header_block_(header_block) {} bool PreconditionHolds() override; protected: void Apply() override; private: // The header block of the selection. opt::BasicBlock* header_block_; }; } // namespace reduce } // namespace spvtools #endif // SOURCE_REDUCE_REMOVE_SELECTION_REDUCTION_OPPORTUNITY_H_ KhronosGroup-SPIRV-Tools-f289d04/source/reduce/remove_selection_reduction_opportunity_finder.cpp000066400000000000000000000124371475742701700334540ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/remove_selection_reduction_opportunity_finder.h" #include "source/reduce/remove_selection_reduction_opportunity.h" namespace spvtools { namespace reduce { namespace { const uint32_t kMergeNodeIndex = 0; const uint32_t kContinueNodeIndex = 1; } // namespace std::string RemoveSelectionReductionOpportunityFinder::GetName() const { return "RemoveSelectionReductionOpportunityFinder"; } std::vector> RemoveSelectionReductionOpportunityFinder::GetAvailableOpportunities( opt::IRContext* context, uint32_t target_function) const { // Get all loop merge and continue blocks so we can check for these later. std::unordered_set merge_and_continue_blocks_from_loops; for (auto* function : GetTargetFunctions(context, target_function)) { for (auto& block : *function) { if (auto merge_instruction = block.GetMergeInst()) { if (merge_instruction->opcode() == spv::Op::OpLoopMerge) { uint32_t merge_block_id = merge_instruction->GetSingleWordOperand(kMergeNodeIndex); uint32_t continue_block_id = merge_instruction->GetSingleWordOperand(kContinueNodeIndex); merge_and_continue_blocks_from_loops.insert(merge_block_id); merge_and_continue_blocks_from_loops.insert(continue_block_id); } } } } // Return all selection headers where the OpSelectionMergeInstruction can be // removed. std::vector> result; for (auto& function : *context->module()) { for (auto& block : function) { if (auto merge_instruction = block.GetMergeInst()) { if (merge_instruction->opcode() == spv::Op::OpSelectionMerge) { if (CanOpSelectionMergeBeRemoved( context, block, merge_instruction, merge_and_continue_blocks_from_loops)) { result.push_back( MakeUnique(&block)); } } } } } return result; } bool RemoveSelectionReductionOpportunityFinder::CanOpSelectionMergeBeRemoved( opt::IRContext* context, const opt::BasicBlock& header_block, opt::Instruction* merge_instruction, std::unordered_set merge_and_continue_blocks_from_loops) { assert(header_block.GetMergeInst() == merge_instruction && "CanOpSelectionMergeBeRemoved(...): header block and merge " "instruction mismatch"); // The OpSelectionMerge instruction is needed if either of the following are // true. // // 1. The header block has at least two (unique) successors that are not // merge or continue blocks of a loop. // // 2. The predecessors of the merge block are "using" the merge block to avoid // divergence. In other words, there exists a predecessor of the merge block // that has a successor that is not the merge block of this construct and not // a merge or continue block of a loop. // 1. { uint32_t divergent_successor_count = 0; std::unordered_set seen_successors; header_block.ForEachSuccessorLabel( [&seen_successors, &merge_and_continue_blocks_from_loops, &divergent_successor_count](uint32_t successor) { // Not already seen. if (seen_successors.find(successor) == seen_successors.end()) { seen_successors.insert(successor); // Not a loop continue or merge. if (merge_and_continue_blocks_from_loops.find(successor) == merge_and_continue_blocks_from_loops.end()) { ++divergent_successor_count; } } }); if (divergent_successor_count > 1) { return false; } } // 2. { uint32_t merge_block_id = merge_instruction->GetSingleWordOperand(kMergeNodeIndex); for (uint32_t predecessor_block_id : context->cfg()->preds(merge_block_id)) { const opt::BasicBlock* predecessor_block = context->cfg()->block(predecessor_block_id); assert(predecessor_block); bool found_divergent_successor = false; predecessor_block->ForEachSuccessorLabel( [&found_divergent_successor, merge_block_id, &merge_and_continue_blocks_from_loops](uint32_t successor_id) { // The successor is not the merge block, nor a loop merge or // continue. if (successor_id != merge_block_id && merge_and_continue_blocks_from_loops.find(successor_id) == merge_and_continue_blocks_from_loops.end()) { found_divergent_successor = true; } }); if (found_divergent_successor) { return false; } } } return true; } } // namespace reduce } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/reduce/remove_selection_reduction_opportunity_finder.h000066400000000000000000000036351475742701700331210ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_REDUCE_REMOVE_SELECTION_REDUCTION_OPPORTUNITY_FINDER_H_ #define SOURCE_REDUCE_REMOVE_SELECTION_REDUCTION_OPPORTUNITY_FINDER_H_ #include "source/reduce/reduction_opportunity_finder.h" namespace spvtools { namespace reduce { // A finder for opportunities for removing a selection construct by simply // removing the OpSelectionMerge instruction; thus, the selections must have // already been simplified to a point where they can be trivially removed. class RemoveSelectionReductionOpportunityFinder : public ReductionOpportunityFinder { public: RemoveSelectionReductionOpportunityFinder() = default; ~RemoveSelectionReductionOpportunityFinder() override = default; std::string GetName() const final; std::vector> GetAvailableOpportunities( opt::IRContext* context, uint32_t target_function) const final; // Returns true if the OpSelectionMerge instruction |merge_instruction| in // block |header_block| can be removed. static bool CanOpSelectionMergeBeRemoved( opt::IRContext* context, const opt::BasicBlock& header_block, opt::Instruction* merge_instruction, std::unordered_set merge_and_continue_blocks_from_loops); }; } // namespace reduce } // namespace spvtools #endif // SOURCE_REDUCE_REMOVE_SELECTION_REDUCTION_OPPORTUNITY_FINDER_H_ KhronosGroup-SPIRV-Tools-f289d04/source/reduce/remove_struct_member_reduction_opportunity.cpp000066400000000000000000000223771475742701700330170ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/remove_struct_member_reduction_opportunity.h" #include "source/opt/ir_context.h" namespace spvtools { namespace reduce { bool RemoveStructMemberReductionOpportunity::PreconditionHolds() { return struct_type_->NumInOperands() == original_number_of_members_; } void RemoveStructMemberReductionOpportunity::Apply() { std::set decorations_to_kill; // We need to remove decorations that target the removed struct member, and // adapt decorations that target later struct members by decrementing the // member identifier. We also need to adapt composite construction // instructions so that no id is provided for the member being removed. // // To do this, we consider every use of the struct type. struct_type_->context()->get_def_use_mgr()->ForEachUse( struct_type_, [this, &decorations_to_kill](opt::Instruction* user, uint32_t /*operand_index*/) { switch (user->opcode()) { case spv::Op::OpCompositeConstruct: case spv::Op::OpConstantComposite: // This use is constructing a composite of the struct type, so we // must remove the id that was provided for the member we are // removing. user->RemoveInOperand(member_index_); break; case spv::Op::OpMemberDecorate: // This use is decorating a member of the struct. if (user->GetSingleWordInOperand(1) == member_index_) { // The member we are removing is being decorated, so we record // that we need to get rid of the decoration. decorations_to_kill.insert(user); } else if (user->GetSingleWordInOperand(1) > member_index_) { // A member beyond the one we are removing is being decorated, so // we adjust the index that identifies the member. user->SetInOperand(1, {user->GetSingleWordInOperand(1) - 1}); } break; default: break; } }); // Get rid of all the decorations that were found to target the member being // removed. for (auto decoration_to_kill : decorations_to_kill) { decoration_to_kill->context()->KillInst(decoration_to_kill); } // We now look through all instructions that access composites via sequences // of indices. Every time we find an index into the struct whose member is // being removed, and if the member being accessed comes after the member // being removed, we need to adjust the index accordingly. // // We go through every relevant instruction in every block of every function, // and invoke a helper to adjust it. auto context = struct_type_->context(); for (auto& function : *context->module()) { for (auto& block : function) { for (auto& inst : block) { switch (inst.opcode()) { case spv::Op::OpAccessChain: case spv::Op::OpInBoundsAccessChain: { // These access chain instructions take sequences of ids for // indexing, starting from input operand 1. auto composite_type_id = context->get_def_use_mgr() ->GetDef(context->get_def_use_mgr() ->GetDef(inst.GetSingleWordInOperand(0)) ->type_id()) ->GetSingleWordInOperand(1); AdjustAccessedIndices(composite_type_id, 1, false, context, &inst); } break; case spv::Op::OpPtrAccessChain: case spv::Op::OpInBoundsPtrAccessChain: { // These access chain instructions take sequences of ids for // indexing, starting from input operand 2. auto composite_type_id = context->get_def_use_mgr() ->GetDef(context->get_def_use_mgr() ->GetDef(inst.GetSingleWordInOperand(1)) ->type_id()) ->GetSingleWordInOperand(1); AdjustAccessedIndices(composite_type_id, 2, false, context, &inst); } break; case spv::Op::OpCompositeExtract: { // OpCompositeExtract uses literals for indexing, starting at input // operand 1. auto composite_type_id = context->get_def_use_mgr() ->GetDef(inst.GetSingleWordInOperand(0)) ->type_id(); AdjustAccessedIndices(composite_type_id, 1, true, context, &inst); } break; case spv::Op::OpCompositeInsert: { // OpCompositeInsert uses literals for indexing, starting at input // operand 2. auto composite_type_id = context->get_def_use_mgr() ->GetDef(inst.GetSingleWordInOperand(1)) ->type_id(); AdjustAccessedIndices(composite_type_id, 2, true, context, &inst); } break; default: break; } } } } // Remove the member from the struct type. struct_type_->RemoveInOperand(member_index_); context->InvalidateAnalysesExceptFor(opt::IRContext::kAnalysisNone); } void RemoveStructMemberReductionOpportunity::AdjustAccessedIndices( uint32_t composite_type_id, uint32_t first_index_input_operand, bool literal_indices, opt::IRContext* context, opt::Instruction* composite_access_instruction) const { // Walk the series of types that are encountered by following the // instruction's sequence of indices. For all types except structs, this is // routine: the type of the composite dictates what the next type will be // regardless of the specific index value. uint32_t next_type = composite_type_id; for (uint32_t i = first_index_input_operand; i < composite_access_instruction->NumInOperands(); i++) { auto type_inst = context->get_def_use_mgr()->GetDef(next_type); switch (type_inst->opcode()) { case spv::Op::OpTypeArray: case spv::Op::OpTypeMatrix: case spv::Op::OpTypeRuntimeArray: case spv::Op::OpTypeVector: next_type = type_inst->GetSingleWordInOperand(0); break; case spv::Op::OpTypeStruct: { // Struct types are special because (a) we may need to adjust the index // being used, if the struct type is the one from which we are removing // a member, and (b) the type encountered by following the current index // is dependent on the value of the index. // Work out the member being accessed. If literal indexing is used this // is simple; otherwise we need to look up the id of the constant // instruction being used as an index and get the value of the constant. uint32_t index_operand = composite_access_instruction->GetSingleWordInOperand(i); uint32_t member = literal_indices ? index_operand : context->get_def_use_mgr() ->GetDef(index_operand) ->GetSingleWordInOperand(0); // The next type we will consider is obtained by looking up the struct // type at |member|. next_type = type_inst->GetSingleWordInOperand(member); if (type_inst == struct_type_ && member > member_index_) { // The struct type is the struct from which we are removing a member, // and the member being accessed is beyond the member we are removing. // We thus need to decrement the index by 1. uint32_t new_in_operand; if (literal_indices) { // With literal indexing this is straightforward. new_in_operand = member - 1; } else { // With id-based indexing this is more tricky: we need to find or // create a constant instruction whose value is one less than // |member|, and use the id of this constant as the replacement // input operand. auto constant_inst = context->get_def_use_mgr()->GetDef(index_operand); auto int_type = context->get_type_mgr() ->GetType(constant_inst->type_id()) ->AsInteger(); auto new_index_constant = opt::analysis::IntConstant(int_type, {member - 1}); new_in_operand = context->get_constant_mgr() ->GetDefiningInstruction(&new_index_constant) ->result_id(); } composite_access_instruction->SetInOperand(i, {new_in_operand}); } } break; default: assert(0 && "Unknown composite type."); break; } } } } // namespace reduce } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/reduce/remove_struct_member_reduction_opportunity.h000066400000000000000000000062641475742701700324610ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_REDUCE_REMOVE_STRUCT_MEMBER_REDUCTION_OPPORTUNITY_H_ #define SOURCE_REDUCE_REMOVE_STRUCT_MEMBER_REDUCTION_OPPORTUNITY_H_ #include "source/reduce/reduction_opportunity.h" #include "source/opt/instruction.h" namespace spvtools { namespace reduce { // An opportunity for removing a member from a struct type, adjusting all uses // of the struct accordingly. class RemoveStructMemberReductionOpportunity : public ReductionOpportunity { public: // Constructs a reduction opportunity from the struct type |struct_type|, for // removal of member |member_index|. RemoveStructMemberReductionOpportunity(opt::Instruction* struct_type, uint32_t member_index) : struct_type_(struct_type), member_index_(member_index), original_number_of_members_(struct_type->NumInOperands()) {} // Opportunities to remove fields from a common struct type mutually // invalidate each other. We guard against this by requiring that the struct // still has the number of members it had when the opportunity was created. bool PreconditionHolds() override; protected: void Apply() override; private: // |composite_access_instruction| is an instruction that accesses a composite // id using either a series of literal indices (e.g. in the case of // OpCompositeInsert) or a series of index ids (e.g. in the case of // OpAccessChain). // // This function adjusts the indices that are used by // |composite_access_instruction| to that whenever an index is accessing a // member of |struct_type_|, it is decremented if the member is beyond // |member_index_|, to account for the removal of the |member_index_|-th // member. // // |composite_type_id| is the id of the composite type that the series of // indices is to be applied to. // // |first_index_input_operand| specifies the first input operand that is an // index. // // |literal_indices| specifies whether indices are given as literals (true), // or as ids (false). // // If id-based indexing is used, this function will add a constant for // |member_index_| - 1 to the module if needed. void AdjustAccessedIndices( uint32_t composite_type_id, uint32_t first_index_input_operand, bool literal_indices, opt::IRContext* context, opt::Instruction* composite_access_instruction) const; // The struct type from which a member is to be removed. opt::Instruction* struct_type_; uint32_t member_index_; uint32_t original_number_of_members_; }; } // namespace reduce } // namespace spvtools #endif // SOURCE_REDUCE_REMOVE_STRUCT_MEMBER_REDUCTION_OPPORTUNITY_H_ remove_unused_instruction_reduction_opportunity_finder.cpp000066400000000000000000000140761475742701700353550ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/reduce// Copyright (c) 2018 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/remove_unused_instruction_reduction_opportunity_finder.h" #include "source/opcode.h" #include "source/opt/instruction.h" #include "source/reduce/remove_instruction_reduction_opportunity.h" namespace spvtools { namespace reduce { RemoveUnusedInstructionReductionOpportunityFinder:: RemoveUnusedInstructionReductionOpportunityFinder( bool remove_constants_and_undefs) : remove_constants_and_undefs_(remove_constants_and_undefs) {} std::vector> RemoveUnusedInstructionReductionOpportunityFinder::GetAvailableOpportunities( opt::IRContext* context, uint32_t target_function) const { std::vector> result; if (!target_function) { // We are not restricting reduction to a specific function, so we consider // unused instructions defined outside functions. for (auto& inst : context->module()->debugs1()) { if (context->get_def_use_mgr()->NumUses(&inst) > 0) { continue; } result.push_back( MakeUnique(&inst)); } for (auto& inst : context->module()->debugs2()) { if (context->get_def_use_mgr()->NumUses(&inst) > 0) { continue; } result.push_back( MakeUnique(&inst)); } for (auto& inst : context->module()->debugs3()) { if (context->get_def_use_mgr()->NumUses(&inst) > 0) { continue; } result.push_back( MakeUnique(&inst)); } for (auto& inst : context->module()->ext_inst_debuginfo()) { if (context->get_def_use_mgr()->NumUses(&inst) > 0) { continue; } result.push_back( MakeUnique(&inst)); } for (auto& inst : context->module()->types_values()) { if (!remove_constants_and_undefs_ && spvOpcodeIsConstantOrUndef(inst.opcode())) { continue; } if (!OnlyReferencedByIntimateDecorationOrEntryPointInterface(context, inst)) { continue; } result.push_back( MakeUnique(&inst)); } for (auto& inst : context->module()->annotations()) { if (context->get_def_use_mgr()->NumUsers(&inst) > 0) { continue; } if (!IsIndependentlyRemovableDecoration(inst)) { continue; } result.push_back( MakeUnique(&inst)); } } for (auto* function : GetTargetFunctions(context, target_function)) { for (auto& block : *function) { for (auto& inst : block) { if (context->get_def_use_mgr()->NumUses(&inst) > 0) { continue; } if (!remove_constants_and_undefs_ && spvOpcodeIsConstantOrUndef(inst.opcode())) { continue; } if (spvOpcodeIsBlockTerminator(inst.opcode()) || inst.opcode() == spv::Op::OpSelectionMerge || inst.opcode() == spv::Op::OpLoopMerge) { // In this reduction pass we do not want to affect static // control flow. continue; } // Given that we're in a block, we should only get here if // the instruction is not directly related to control flow; // i.e., it's some straightforward instruction with an // unused result, like an arithmetic operation or function // call. result.push_back( MakeUnique(&inst)); } } } return result; } std::string RemoveUnusedInstructionReductionOpportunityFinder::GetName() const { return "RemoveUnusedInstructionReductionOpportunityFinder"; } bool RemoveUnusedInstructionReductionOpportunityFinder:: OnlyReferencedByIntimateDecorationOrEntryPointInterface( opt::IRContext* context, const opt::Instruction& inst) const { return context->get_def_use_mgr()->WhileEachUse( &inst, [this](opt::Instruction* user, uint32_t use_index) -> bool { return (user->IsDecoration() && !IsIndependentlyRemovableDecoration(*user)) || (user->opcode() == spv::Op::OpEntryPoint && use_index > 2); }); } bool RemoveUnusedInstructionReductionOpportunityFinder:: IsIndependentlyRemovableDecoration(const opt::Instruction& inst) const { uint32_t decoration; switch (inst.opcode()) { case spv::Op::OpDecorate: case spv::Op::OpDecorateId: case spv::Op::OpDecorateString: decoration = inst.GetSingleWordInOperand(1u); break; case spv::Op::OpMemberDecorate: case spv::Op::OpMemberDecorateString: decoration = inst.GetSingleWordInOperand(2u); break; default: // The instruction is not a decoration. It is legitimate for this to be // reached: it allows the method to be invoked on arbitrary instructions. return false; } // We conservatively only remove specific decorations that we believe will // not change the shader interface, will not make the shader invalid, will // actually be found in practice, etc. switch (spv::Decoration(decoration)) { case spv::Decoration::RelaxedPrecision: case spv::Decoration::NoSignedWrap: case spv::Decoration::NoContraction: case spv::Decoration::NoUnsignedWrap: case spv::Decoration::UserSemantic: return true; default: return false; } } } // namespace reduce } // namespace spvtools remove_unused_instruction_reduction_opportunity_finder.h000066400000000000000000000051601475742701700350140ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/reduce// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_REDUCE_REMOVE_UNREFERENCED_INSTRUCTION_REDUCTION_OPPORTUNITY_FINDER_H_ #define SOURCE_REDUCE_REMOVE_UNREFERENCED_INSTRUCTION_REDUCTION_OPPORTUNITY_FINDER_H_ #include "source/reduce/reduction_opportunity_finder.h" namespace spvtools { namespace reduce { // A finder for opportunities to remove non-control-flow instructions in blocks // in cases where the instruction's id is either not referenced at all, or // referenced only in a trivial manner (for example, we regard a struct type as // unused if it is referenced only by struct layout decorations). As well as // making the module smaller, removing an instruction that references particular // ids may create opportunities for subsequently removing the instructions that // generated those ids. class RemoveUnusedInstructionReductionOpportunityFinder : public ReductionOpportunityFinder { public: explicit RemoveUnusedInstructionReductionOpportunityFinder( bool remove_constants_and_undefs); ~RemoveUnusedInstructionReductionOpportunityFinder() override = default; std::string GetName() const final; std::vector> GetAvailableOpportunities( opt::IRContext* context, uint32_t target_function) const final; private: // Returns true if and only if the only uses of |inst| are by decorations that // relate intimately to the instruction (as opposed to decorations that could // be removed independently), or by interface ids in OpEntryPoint. bool OnlyReferencedByIntimateDecorationOrEntryPointInterface( opt::IRContext* context, const opt::Instruction& inst) const; // Returns true if and only if |inst| is a decoration instruction that can // legitimately be removed on its own (rather than one that has to be removed // simultaneously with other instructions). bool IsIndependentlyRemovableDecoration(const opt::Instruction& inst) const; bool remove_constants_and_undefs_; }; } // namespace reduce } // namespace spvtools #endif // SOURCE_REDUCE_REMOVE_UNREFERENCED_INSTRUCTION_REDUCTION_OPPORTUNITY_FINDER_H_ remove_unused_struct_member_reduction_opportunity_finder.cpp000066400000000000000000000204541475742701700356440ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/reduce// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/remove_unused_struct_member_reduction_opportunity_finder.h" #include #include #include "source/reduce/remove_struct_member_reduction_opportunity.h" namespace spvtools { namespace reduce { std::vector> RemoveUnusedStructMemberReductionOpportunityFinder::GetAvailableOpportunities( opt::IRContext* context, uint32_t target_function) const { if (target_function) { // Removing an unused struct member is a global change, as struct types are // global. We thus do not consider such opportunities if we are targeting // a specific function. return {}; } std::vector> result; // We track those struct members that are never accessed. We do this by // associating a member index to all the structs that have this member index // but do not use it. This representation is designed to allow reduction // opportunities to be provided in a useful manner, so that opportunities // associated with the same struct are unlikely to be adjacent. std::map> unused_member_to_structs; // Consider every struct type in the module. for (auto& type_or_value : context->types_values()) { if (type_or_value.opcode() != spv::Op::OpTypeStruct) { continue; } // Initially, we assume that *every* member of the struct is unused. We // then refine this based on observed uses. std::set unused_members; for (uint32_t i = 0; i < type_or_value.NumInOperands(); i++) { unused_members.insert(i); } // A separate reduction pass deals with removal of names. If a struct // member is still named, we treat it as being used. context->get_def_use_mgr()->ForEachUse( &type_or_value, [&unused_members](opt::Instruction* user, uint32_t /*operand_index*/) { switch (user->opcode()) { case spv::Op::OpMemberName: unused_members.erase(user->GetSingleWordInOperand(1)); break; default: break; } }); for (uint32_t member : unused_members) { if (!unused_member_to_structs.count(member)) { unused_member_to_structs.insert( {member, std::set()}); } unused_member_to_structs.at(member).insert(&type_or_value); } } // We now go through every instruction that might index into a struct, and // refine our tracking of which struct members are used based on the struct // indexing we observe. We cannot just go through all uses of a struct type // because the type is not necessarily even referenced, e.g. when walking // arrays of structs. for (auto& function : *context->module()) { for (auto& block : function) { for (auto& inst : block) { switch (inst.opcode()) { // For each indexing operation we observe, we invoke a helper to // remove from our map those struct indices that are found to be used. // The way the helper is invoked depends on whether the instruction // uses literal or id indices, and the offset into the instruction's // input operands from which index operands are provided. case spv::Op::OpAccessChain: case spv::Op::OpInBoundsAccessChain: { auto composite_type_id = context->get_def_use_mgr() ->GetDef(context->get_def_use_mgr() ->GetDef(inst.GetSingleWordInOperand(0)) ->type_id()) ->GetSingleWordInOperand(1); MarkAccessedMembersAsUsed(context, composite_type_id, 1, false, inst, &unused_member_to_structs); } break; case spv::Op::OpPtrAccessChain: case spv::Op::OpInBoundsPtrAccessChain: { auto composite_type_id = context->get_def_use_mgr() ->GetDef(context->get_def_use_mgr() ->GetDef(inst.GetSingleWordInOperand(1)) ->type_id()) ->GetSingleWordInOperand(1); MarkAccessedMembersAsUsed(context, composite_type_id, 2, false, inst, &unused_member_to_structs); } break; case spv::Op::OpCompositeExtract: { auto composite_type_id = context->get_def_use_mgr() ->GetDef(inst.GetSingleWordInOperand(0)) ->type_id(); MarkAccessedMembersAsUsed(context, composite_type_id, 1, true, inst, &unused_member_to_structs); } break; case spv::Op::OpCompositeInsert: { auto composite_type_id = context->get_def_use_mgr() ->GetDef(inst.GetSingleWordInOperand(1)) ->type_id(); MarkAccessedMembersAsUsed(context, composite_type_id, 2, true, inst, &unused_member_to_structs); } break; default: break; } } } } // We now know those struct indices that are unused, and we make a reduction // opportunity for each of them. By mapping each relevant member index to the // structs in which it is unused, we will group all opportunities to remove // member k of a struct (for some k) together. This reduces the likelihood // that opportunities to remove members from the same struct will be adjacent, // which is good because such opportunities mutually disable one another. for (auto& entry : unused_member_to_structs) { for (auto struct_type : entry.second) { result.push_back(MakeUnique( struct_type, entry.first)); } } return result; } void RemoveUnusedStructMemberReductionOpportunityFinder:: MarkAccessedMembersAsUsed( opt::IRContext* context, uint32_t composite_type_id, uint32_t first_index_in_operand, bool literal_indices, const opt::Instruction& composite_access_instruction, std::map>* unused_member_to_structs) const { uint32_t next_type = composite_type_id; for (uint32_t i = first_index_in_operand; i < composite_access_instruction.NumInOperands(); i++) { auto type_inst = context->get_def_use_mgr()->GetDef(next_type); switch (type_inst->opcode()) { case spv::Op::OpTypeArray: case spv::Op::OpTypeMatrix: case spv::Op::OpTypeRuntimeArray: case spv::Op::OpTypeVector: next_type = type_inst->GetSingleWordInOperand(0); break; case spv::Op::OpTypeStruct: { uint32_t index_operand = composite_access_instruction.GetSingleWordInOperand(i); uint32_t member = literal_indices ? index_operand : context->get_def_use_mgr() ->GetDef(index_operand) ->GetSingleWordInOperand(0); // Remove the struct type from the struct types associated with this // member index, but only if a set of struct types is known to be // associated with this member index. if (unused_member_to_structs->count(member)) { unused_member_to_structs->at(member).erase(type_inst); } next_type = type_inst->GetSingleWordInOperand(member); } break; default: assert(0 && "Unknown composite type."); break; } } } std::string RemoveUnusedStructMemberReductionOpportunityFinder::GetName() const { return "RemoveUnusedStructMemberReductionOpportunityFinder"; } } // namespace reduce } // namespace spvtools remove_unused_struct_member_reduction_opportunity_finder.h000066400000000000000000000045001475742701700353030ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/reduce// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_REDUCE_REMOVE_UNUSED_STRUCT_MEMBER_REDUCTION_OPPORTUNITY_FINDER_H_ #define SOURCE_REDUCE_REMOVE_UNUSED_STRUCT_MEMBER_REDUCTION_OPPORTUNITY_FINDER_H_ #include "source/reduce/reduction_opportunity_finder.h" namespace spvtools { namespace reduce { // A finder for opportunities to remove struct members that are not explicitly // used by extract, insert or access chain instructions. class RemoveUnusedStructMemberReductionOpportunityFinder : public ReductionOpportunityFinder { public: RemoveUnusedStructMemberReductionOpportunityFinder() = default; ~RemoveUnusedStructMemberReductionOpportunityFinder() override = default; std::string GetName() const final; std::vector> GetAvailableOpportunities( opt::IRContext* context, uint32_t target_function) const final; private: // A helper method to update |unused_members_to_structs| by removing from it // all struct member accesses that take place in // |composite_access_instruction|. // // |composite_type_id| is the type of the root object indexed into by the // instruction. // // |first_index_in_operand| provides indicates where in the input operands the // sequence of indices begins. // // |literal_indices| indicates whether indices are literals (true) or ids // (false). void MarkAccessedMembersAsUsed( opt::IRContext* context, uint32_t composite_type_id, uint32_t first_index_in_operand, bool literal_indices, const opt::Instruction& composite_access_instruction, std::map>* unused_member_to_structs) const; }; } // namespace reduce } // namespace spvtools #endif // SOURCE_REDUCE_REMOVE_UNUSED_STRUCT_MEMBER_REDUCTION_OPPORTUNITY_FINDER_H_ simple_conditional_branch_to_branch_opportunity_finder.cpp000066400000000000000000000043751475742701700351710ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/reduce// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/simple_conditional_branch_to_branch_opportunity_finder.h" #include "source/reduce/reduction_util.h" #include "source/reduce/simple_conditional_branch_to_branch_reduction_opportunity.h" namespace spvtools { namespace reduce { std::vector> SimpleConditionalBranchToBranchOpportunityFinder::GetAvailableOpportunities( opt::IRContext* context, uint32_t target_function) const { std::vector> result; // Consider every function. for (auto* function : GetTargetFunctions(context, target_function)) { // Consider every block in the function. for (auto& block : *function) { // The terminator must be spv::Op::OpBranchConditional. opt::Instruction* terminator = block.terminator(); if (terminator->opcode() != spv::Op::OpBranchConditional) { continue; } // It must not be a selection header, as these cannot be followed by // OpBranch. if (block.GetMergeInst() && block.GetMergeInst()->opcode() == spv::Op::OpSelectionMerge) { continue; } // The conditional branch must be simplified. if (terminator->GetSingleWordInOperand(kTrueBranchOperandIndex) != terminator->GetSingleWordInOperand(kFalseBranchOperandIndex)) { continue; } result.push_back( MakeUnique( block.terminator())); } } return result; } std::string SimpleConditionalBranchToBranchOpportunityFinder::GetName() const { return "SimpleConditionalBranchToBranchOpportunityFinder"; } } // namespace reduce } // namespace spvtools simple_conditional_branch_to_branch_opportunity_finder.h000066400000000000000000000026051475742701700346300ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/reduce// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_REDUCE_SIMPLE_CONDITIONAL_BRANCH_TO_BRANCH_OPPORTUNITY_FINDER_H_ #define SOURCE_REDUCE_SIMPLE_CONDITIONAL_BRANCH_TO_BRANCH_OPPORTUNITY_FINDER_H_ #include "source/reduce/reduction_opportunity_finder.h" namespace spvtools { namespace reduce { // A finder for opportunities to change simple conditional branches (conditional // branches with one target) to an OpBranch. class SimpleConditionalBranchToBranchOpportunityFinder : public ReductionOpportunityFinder { public: std::vector> GetAvailableOpportunities( opt::IRContext* context, uint32_t target_function) const override; std::string GetName() const override; }; } // namespace reduce } // namespace spvtools #endif // SOURCE_REDUCE_SIMPLE_CONDITIONAL_BRANCH_TO_BRANCH_OPPORTUNITY_FINDER_H_ simple_conditional_branch_to_branch_reduction_opportunity.cpp000066400000000000000000000044551475742701700357150ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/reduce// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/simple_conditional_branch_to_branch_reduction_opportunity.h" #include "source/reduce/reduction_util.h" namespace spvtools { namespace reduce { SimpleConditionalBranchToBranchReductionOpportunity:: SimpleConditionalBranchToBranchReductionOpportunity( opt::Instruction* conditional_branch_instruction) : conditional_branch_instruction_(conditional_branch_instruction) {} bool SimpleConditionalBranchToBranchReductionOpportunity::PreconditionHolds() { // We find at most one opportunity per conditional branch and simplifying // another branch cannot disable this opportunity. return true; } void SimpleConditionalBranchToBranchReductionOpportunity::Apply() { assert(conditional_branch_instruction_->opcode() == spv::Op::OpBranchConditional && "SimpleConditionalBranchToBranchReductionOpportunity: branch was not " "a conditional branch"); assert(conditional_branch_instruction_->GetSingleWordInOperand( kTrueBranchOperandIndex) == conditional_branch_instruction_->GetSingleWordInOperand( kFalseBranchOperandIndex) && "SimpleConditionalBranchToBranchReductionOpportunity: branch was not " "simple"); // OpBranchConditional %condition %block_id %block_id ... // -> // OpBranch %block_id conditional_branch_instruction_->SetOpcode(spv::Op::OpBranch); conditional_branch_instruction_->ReplaceOperands( {{SPV_OPERAND_TYPE_ID, {conditional_branch_instruction_->GetSingleWordInOperand( kTrueBranchOperandIndex)}}}); conditional_branch_instruction_->context()->InvalidateAnalysesExceptFor( opt::IRContext::kAnalysisNone); } } // namespace reduce } // namespace spvtools simple_conditional_branch_to_branch_reduction_opportunity.h000066400000000000000000000030541475742701700353540ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/reduce// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_REDUCE_SIMPLE_CONDITIONAL_BRANCH_TO_BRANCH_REDUCTION_OPPORTUNITY_H_ #define SOURCE_REDUCE_SIMPLE_CONDITIONAL_BRANCH_TO_BRANCH_REDUCTION_OPPORTUNITY_H_ #include "source/opt/instruction.h" #include "source/reduce/reduction_opportunity.h" namespace spvtools { namespace reduce { // An opportunity to change simple conditional branches (conditional branches // with one target) to an OpBranch. class SimpleConditionalBranchToBranchReductionOpportunity : public ReductionOpportunity { public: // Constructs an opportunity to simplify |conditional_branch_instruction|. explicit SimpleConditionalBranchToBranchReductionOpportunity( opt::Instruction* conditional_branch_instruction); bool PreconditionHolds() override; protected: void Apply() override; private: opt::Instruction* conditional_branch_instruction_; }; } // namespace reduce } // namespace spvtools #endif // SOURCE_REDUCE_SIMPLE_CONDITIONAL_BRANCH_TO_BRANCH_REDUCTION_OPPORTUNITY_H_ structured_construct_to_block_reduction_opportunity.cpp000066400000000000000000000053561475742701700346720ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/reduce// Copyright (c) 2021 Alastair F. Donaldson // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/structured_construct_to_block_reduction_opportunity.h" namespace spvtools { namespace reduce { bool StructuredConstructToBlockReductionOpportunity::PreconditionHolds() { return context_->get_def_use_mgr()->GetDef(construct_header_) != nullptr; } void StructuredConstructToBlockReductionOpportunity::Apply() { auto header_block = context_->cfg()->block(construct_header_); auto merge_block = context_->cfg()->block(header_block->MergeBlockId()); auto* enclosing_function = header_block->GetParent(); // A region of blocks is defined in terms of dominators and post-dominators, // so we compute these for the enclosing function. auto* dominators = context_->GetDominatorAnalysis(enclosing_function); auto* postdominators = context_->GetPostDominatorAnalysis(enclosing_function); // For each block in the function, determine whether it is inside the region. // If it is, delete it. for (auto block_it = enclosing_function->begin(); block_it != enclosing_function->end();) { if (header_block != &*block_it && merge_block != &*block_it && dominators->Dominates(header_block, &*block_it) && postdominators->Dominates(merge_block, &*block_it)) { block_it = block_it.Erase(); } else { ++block_it; } } // Having removed some blocks from the module it is necessary to invalidate // analyses, since the remaining patch-up work depends on various analyses // which will otherwise reference blocks that have been deleted. context_->InvalidateAnalysesExceptFor(opt::IRContext::kAnalysisNone); // We demote the header of the region to a regular block by deleting its merge // instruction. context_->KillInst(header_block->GetMergeInst()); // The terminator for the header block is changed to be an unconditional // branch to the merge block. header_block->terminator()->SetOpcode(spv::Op::OpBranch); header_block->terminator()->SetInOperands( {{SPV_OPERAND_TYPE_ID, {merge_block->id()}}}); // This is an intrusive change, so we invalidate all analyses. context_->InvalidateAnalysesExceptFor(opt::IRContext::kAnalysisNone); } } // namespace reduce } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/reduce/structured_construct_to_block_reduction_opportunity.h000066400000000000000000000033271475742701700344120ustar00rootroot00000000000000// Copyright (c) 2021 Alastair F. Donaldson // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_REDUCE_STRUCTURED_CONSTRUCT_TO_BLOCK_REDUCTION_OPPORTUNITY_H_ #define SOURCE_REDUCE_STRUCTURED_CONSTRUCT_TO_BLOCK_REDUCTION_OPPORTUNITY_H_ #include "source/opt/ir_context.h" #include "source/reduce/reduction_opportunity.h" namespace spvtools { namespace reduce { // An opportunity to replace a skeletal structured control flow construct with a // single block. class StructuredConstructToBlockReductionOpportunity : public ReductionOpportunity { public: // Constructs an opportunity from a header block id. StructuredConstructToBlockReductionOpportunity(opt::IRContext* context, uint32_t construct_header) : context_(context), construct_header_(construct_header) {} // Returns true if and only if |construct_header_| exists in the module - // another opportunity may have removed it. bool PreconditionHolds() override; protected: void Apply() override; private: opt::IRContext* context_; uint32_t construct_header_; }; } // namespace reduce } // namespace spvtools #endif // SOURCE_REDUCE_STRUCTURED_CONSTRUCT_TO_BLOCK_REDUCTION_OPPORTUNITY_H_ structured_construct_to_block_reduction_opportunity_finder.cpp000066400000000000000000000173161475742701700362200ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/reduce// Copyright (c) 2021 Alastair F. Donaldson // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/structured_construct_to_block_reduction_opportunity_finder.h" #include #include "source/reduce/structured_construct_to_block_reduction_opportunity.h" namespace spvtools { namespace reduce { std::vector> StructuredConstructToBlockReductionOpportunityFinder::GetAvailableOpportunities( opt::IRContext* context, uint32_t target_function) const { std::vector> result; // Consider every function in the module. for (auto* function : GetTargetFunctions(context, target_function)) { // For every header block in the function, there is potentially a region of // blocks that could be collapsed. std::unordered_map> regions; // Regions are identified using dominators and postdominators, so we compute // those for the function. auto* dominators = context->GetDominatorAnalysis(function); auto* postdominators = context->GetPostDominatorAnalysis(function); // Consider every block in the function. for (auto& block : *function) { // If a block has an unreachable predecessor then folding away a region in // which that block is contained gets complicated, so we ignore regions // that contain such blocks. We note whether this block suffers from this // problem. bool has_unreachable_predecessor = HasUnreachablePredecessor(block, context); // Look through all the regions we have identified so far to see whether // this block is part of a region, or spoils a region (by having an // unreachable predecessor). for (auto entry = regions.begin(); entry != regions.end();) { // |block| is in this region if it is dominated by the header, // post-dominated by the merge, and different from the merge. assert(&block != entry->first && "The block should not be the region's header because we only " "make a region when we encounter its header."); if (entry->first->MergeBlockId() != block.id() && dominators->Dominates(entry->first, &block) && postdominators->Dominates( entry->first->GetMergeInst()->GetSingleWordInOperand(0), block.id())) { if (has_unreachable_predecessor) { // The block would be in this region, but it has an unreachable // predecessor. This spoils the region, so we remove it. entry = regions.erase(entry); continue; } else { // Add the block to the region. entry->second.insert(&block); } } ++entry; } if (block.MergeBlockIdIfAny() == 0) { // The block isn't a header, so it doesn't constitute a new region. continue; } if (!context->IsReachable(block)) { // The block isn't reachable, so it doesn't constitute a new region. continue; } auto* merge_block = context->cfg()->block( block.GetMergeInst()->GetSingleWordInOperand(0)); if (!context->IsReachable(*merge_block)) { // The block's merge is unreachable, so it doesn't constitute a new // region. continue; } assert(dominators->Dominates(&block, merge_block) && "The merge block is reachable, so the header must dominate it"); if (!postdominators->Dominates(merge_block, &block)) { // The block is not post-dominated by its merge. This happens for // instance when there is a break from a conditional, or an early exit. // This also means that we don't add a region. continue; } // We have a reachable header block with a reachable merge that // postdominates the header: this means we have a new region. regions.emplace(&block, std::unordered_set()); } // Now that we have found all the regions and blocks within them, we check // whether any region defines an id that is used outside the region. If this // is *not* the case, then we have an opportunity to collapse the region // down to its header block and merge block. for (auto& entry : regions) { if (DefinitionsRestrictedToRegion(*entry.first, entry.second, context)) { result.emplace_back( MakeUnique( context, entry.first->id())); } } } return result; } bool StructuredConstructToBlockReductionOpportunityFinder:: DefinitionsRestrictedToRegion( const opt::BasicBlock& header, const std::unordered_set& region, opt::IRContext* context) { // Consider every block in the region. for (auto& block : region) { // Consider every instruction in the block - this includes the label // instruction if (!block->WhileEachInst( [context, &header, ®ion](opt::Instruction* inst) -> bool { if (inst->result_id() == 0) { // The instruction does not generate a result id, thus it cannot // be referred to outside the region - this is fine. return true; } // Consider every use of the instruction's result id. if (!context->get_def_use_mgr()->WhileEachUse( inst->result_id(), [context, &header, ®ion](opt::Instruction* user, uint32_t) -> bool { auto user_block = context->get_instr_block(user); if (user == header.GetMergeInst() || user == header.terminator()) { // We are going to delete the header's merge // instruction and rewrite its terminator, so it does // not matter if the user is one of these // instructions. return true; } if (user_block == nullptr || region.count(user_block) == 0) { // The user is either a global instruction, or an // instruction in a block outside the region. Removing // the region would invalidate this user. return false; } return true; })) { return false; } return true; })) { return false; } } return true; } bool StructuredConstructToBlockReductionOpportunityFinder:: HasUnreachablePredecessor(const opt::BasicBlock& block, opt::IRContext* context) { for (auto pred : context->cfg()->preds(block.id())) { if (!context->IsReachable(*context->cfg()->block(pred))) { return true; } } return false; } std::string StructuredConstructToBlockReductionOpportunityFinder::GetName() const { return "StructuredConstructToBlockReductionOpportunityFinder"; } } // namespace reduce } // namespace spvtools structured_construct_to_block_reduction_opportunity_finder.h000066400000000000000000000045031475742701700356570ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/reduce// Copyright (c) 2021 Alastair F. Donaldson // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_REDUCE_STRUCTURED_CONSTRUCT_TO_BLOCK_REDUCTION_OPPORTUNITY_FINDER_H #define SOURCE_REDUCE_STRUCTURED_CONSTRUCT_TO_BLOCK_REDUCTION_OPPORTUNITY_FINDER_H #include "source/reduce/reduction_opportunity_finder.h" namespace spvtools { namespace reduce { // A finder for opportunities to replace a skeletal structured control flow // construct - that is, a construct that does not define anything that's used // outside the construct - into its header block. class StructuredConstructToBlockReductionOpportunityFinder : public ReductionOpportunityFinder { public: StructuredConstructToBlockReductionOpportunityFinder() = default; ~StructuredConstructToBlockReductionOpportunityFinder() override = default; std::string GetName() const final; std::vector> GetAvailableOpportunities( opt::IRContext* context, uint32_t target_function) const final; private: // Returns true if and only if all instructions defined in |region| are used // only inside |region|, with the exception that they may be used by the merge // or terminator instruction of |header|, which must be the header block for // the region. static bool DefinitionsRestrictedToRegion( const opt::BasicBlock& header, const std::unordered_set& region, opt::IRContext* context); // Returns true if and only if |block| has at least one predecessor that is // unreachable in the control flow graph of its function. static bool HasUnreachablePredecessor(const opt::BasicBlock& block, opt::IRContext* context); }; } // namespace reduce } // namespace spvtools #endif // SOURCE_REDUCE_STRUCTURED_CONSTRUCT_TO_BLOCK_REDUCTION_OPPORTUNITY_FINDER_H structured_loop_to_selection_reduction_opportunity.cpp000066400000000000000000000301371475742701700345050ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/reduce// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/structured_loop_to_selection_reduction_opportunity.h" #include "source/opt/aggressive_dead_code_elim_pass.h" #include "source/opt/ir_context.h" #include "source/reduce/reduction_util.h" namespace spvtools { namespace reduce { namespace { const uint32_t kMergeNodeIndex = 0; } // namespace bool StructuredLoopToSelectionReductionOpportunity::PreconditionHolds() { // Is the loop header reachable? return loop_construct_header_->GetLabel()->context()->IsReachable( *loop_construct_header_); } void StructuredLoopToSelectionReductionOpportunity::Apply() { // Force computation of dominator analysis, CFG and structured CFG analysis // before we start to mess with edges in the function. context_->GetDominatorAnalysis(loop_construct_header_->GetParent()); context_->cfg(); context_->GetStructuredCFGAnalysis(); // (1) Redirect edges that point to the loop's continue target to their // closest merge block. RedirectToClosestMergeBlock(loop_construct_header_->ContinueBlockId()); // (2) Redirect edges that point to the loop's merge block to their closest // merge block (which might be that of an enclosing selection, for instance). RedirectToClosestMergeBlock(loop_construct_header_->MergeBlockId()); // (3) Turn the loop construct header into a selection. ChangeLoopToSelection(); // We have made control flow changes that do not preserve the analyses that // were performed. context_->InvalidateAnalysesExceptFor( opt::IRContext::Analysis::kAnalysisNone); // (4) By changing CFG edges we may have created scenarios where ids are used // without being dominated; we fix instances of this. FixNonDominatedIdUses(); // Invalidate the analyses we just used. context_->InvalidateAnalysesExceptFor( opt::IRContext::Analysis::kAnalysisNone); } void StructuredLoopToSelectionReductionOpportunity::RedirectToClosestMergeBlock( uint32_t original_target_id) { // Consider every predecessor of the node with respect to which edges should // be redirected. std::set already_seen; for (auto pred : context_->cfg()->preds(original_target_id)) { if (already_seen.find(pred) != already_seen.end()) { // We have already handled this predecessor (this scenario can arise if // there are multiple edges from a block b to original_target_id). continue; } already_seen.insert(pred); if (!context_->IsReachable(*context_->cfg()->block(pred))) { // We do not care about unreachable predecessors (and dominance // information, and thus the notion of structured control flow, makes // little sense for unreachable blocks). continue; } // Find the merge block of the structured control construct that most // tightly encloses the predecessor. uint32_t new_merge_target; // The structured CFG analysis deliberately does not regard a header as // belonging to the structure that it heads. We want it to, so handle this // case specially. if (context_->cfg()->block(pred)->MergeBlockIdIfAny()) { new_merge_target = context_->cfg()->block(pred)->MergeBlockIdIfAny(); } else { new_merge_target = context_->GetStructuredCFGAnalysis()->MergeBlock(pred); } assert(new_merge_target != pred); if (!new_merge_target) { // If the loop being transformed is outermost, and the predecessor is // part of that loop's continue construct, there will be no such // enclosing control construct. In this case, the continue construct // will become unreachable anyway, so it is fine not to redirect the // edge. continue; } if (new_merge_target != original_target_id) { // Redirect the edge if it doesn't already point to the desired block. RedirectEdge(pred, original_target_id, new_merge_target); } } } void StructuredLoopToSelectionReductionOpportunity::RedirectEdge( uint32_t source_id, uint32_t original_target_id, uint32_t new_target_id) { // Redirect edge source_id->original_target_id to edge // source_id->new_target_id, where the blocks involved are all different. assert(source_id != original_target_id); assert(source_id != new_target_id); assert(original_target_id != new_target_id); // original_target_id must either be the merge target or continue construct // for the loop being operated on. assert(original_target_id == loop_construct_header_->MergeBlockId() || original_target_id == loop_construct_header_->ContinueBlockId()); auto terminator = context_->cfg()->block(source_id)->terminator(); // Figure out which operands of the terminator need to be considered for // redirection. std::vector operand_indices; if (terminator->opcode() == spv::Op::OpBranch) { operand_indices = {0}; } else if (terminator->opcode() == spv::Op::OpBranchConditional) { operand_indices = {1, 2}; } else { assert(terminator->opcode() == spv::Op::OpSwitch); for (uint32_t label_index = 1; label_index < terminator->NumOperands(); label_index += 2) { operand_indices.push_back(label_index); } } // Redirect the relevant operands, asserting that at least one redirection is // made. bool redirected = false; for (auto operand_index : operand_indices) { if (terminator->GetSingleWordOperand(operand_index) == original_target_id) { terminator->SetOperand(operand_index, {new_target_id}); redirected = true; } } (void)(redirected); assert(redirected); // The old and new targets may have phi instructions; these will need to // respect the change in edges. AdaptPhiInstructionsForRemovedEdge( source_id, context_->cfg()->block(original_target_id)); AdaptPhiInstructionsForAddedEdge(source_id, context_->cfg()->block(new_target_id)); } void StructuredLoopToSelectionReductionOpportunity:: AdaptPhiInstructionsForAddedEdge(uint32_t from_id, opt::BasicBlock* to_block) { to_block->ForEachPhiInst([this, &from_id](opt::Instruction* phi_inst) { // Add to the phi operand an (undef, from_id) pair to reflect the added // edge. auto undef_id = FindOrCreateGlobalUndef(context_, phi_inst->type_id()); phi_inst->AddOperand(opt::Operand(SPV_OPERAND_TYPE_ID, {undef_id})); phi_inst->AddOperand(opt::Operand(SPV_OPERAND_TYPE_ID, {from_id})); }); } void StructuredLoopToSelectionReductionOpportunity::ChangeLoopToSelection() { // Change the merge instruction from OpLoopMerge to OpSelectionMerge, with // the same merge block. auto loop_merge_inst = loop_construct_header_->GetLoopMergeInst(); auto const loop_merge_block_id = loop_merge_inst->GetSingleWordOperand(kMergeNodeIndex); loop_merge_inst->SetOpcode(spv::Op::OpSelectionMerge); loop_merge_inst->ReplaceOperands( {{loop_merge_inst->GetOperand(kMergeNodeIndex).type, {loop_merge_block_id}}, {SPV_OPERAND_TYPE_SELECTION_CONTROL, {uint32_t(spv::SelectionControlMask::MaskNone)}}}); // The loop header either finishes with OpBranch or OpBranchConditional. // The latter is fine for a selection. In the former case we need to turn // it into OpBranchConditional. We use "true" as the condition, and make // the "else" branch be the merge block. auto terminator = loop_construct_header_->terminator(); if (terminator->opcode() == spv::Op::OpBranch) { opt::analysis::Bool temp; const opt::analysis::Bool* bool_type = context_->get_type_mgr()->GetRegisteredType(&temp)->AsBool(); auto const_mgr = context_->get_constant_mgr(); auto true_const = const_mgr->GetConstant(bool_type, {1}); auto true_const_result_id = const_mgr->GetDefiningInstruction(true_const)->result_id(); auto original_branch_id = terminator->GetSingleWordOperand(0); terminator->SetOpcode(spv::Op::OpBranchConditional); terminator->ReplaceOperands({{SPV_OPERAND_TYPE_ID, {true_const_result_id}}, {SPV_OPERAND_TYPE_ID, {original_branch_id}}, {SPV_OPERAND_TYPE_ID, {loop_merge_block_id}}}); if (original_branch_id != loop_merge_block_id) { AdaptPhiInstructionsForAddedEdge( loop_construct_header_->id(), context_->cfg()->block(loop_merge_block_id)); } } } void StructuredLoopToSelectionReductionOpportunity::FixNonDominatedIdUses() { // Consider each instruction in the function. for (auto& block : *loop_construct_header_->GetParent()) { for (auto& def : block) { if (def.opcode() == spv::Op::OpVariable) { // Variables are defined at the start of the function, and can be // accessed by all blocks, even by unreachable blocks that have no // dominators, so we do not need to worry about them. continue; } context_->get_def_use_mgr()->ForEachUse(&def, [this, &block, &def]( opt::Instruction* use, uint32_t index) { // Ignore uses outside of blocks, such as in OpDecorate. if (context_->get_instr_block(use) == nullptr) { return; } // If a use is not appropriately dominated by its definition, // replace the use with an OpUndef, unless the definition is an // access chain, in which case replace it with some (possibly fresh) // variable (as we cannot load from / store to OpUndef). if (!DefinitionSufficientlyDominatesUse(&def, use, index, block)) { if (def.opcode() == spv::Op::OpAccessChain) { auto pointer_type = context_->get_type_mgr()->GetType(def.type_id())->AsPointer(); switch (pointer_type->storage_class()) { case spv::StorageClass::Function: use->SetOperand( index, {FindOrCreateFunctionVariable( context_, loop_construct_header_->GetParent(), context_->get_type_mgr()->GetId(pointer_type))}); break; default: // TODO(2183) Need to think carefully about whether it makes // sense to add new variables for all storage classes; it's // fine for Private but might not be OK for input/output // storage classes for example. use->SetOperand( index, {FindOrCreateGlobalVariable( context_, context_->get_type_mgr()->GetId(pointer_type))}); break; break; } } else { use->SetOperand(index, {FindOrCreateGlobalUndef(context_, def.type_id())}); } } }); } } } bool StructuredLoopToSelectionReductionOpportunity:: DefinitionSufficientlyDominatesUse(opt::Instruction* def, opt::Instruction* use, uint32_t use_index, opt::BasicBlock& def_block) { if (use->opcode() == spv::Op::OpPhi) { // A use in a phi doesn't need to be dominated by its definition, but the // associated parent block does need to be dominated by the definition. return context_->GetDominatorAnalysis(loop_construct_header_->GetParent()) ->Dominates(def_block.id(), use->GetSingleWordOperand(use_index + 1)); } // In non-phi cases, a use needs to be dominated by its definition. return context_->GetDominatorAnalysis(loop_construct_header_->GetParent()) ->Dominates(def, use); } } // namespace reduce } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/reduce/structured_loop_to_selection_reduction_opportunity.h000066400000000000000000000076021475742701700342320ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_REDUCE_STRUCTURED_LOOP_TO_SELECTION_REDUCTION_OPPORTUNITY_H_ #define SOURCE_REDUCE_STRUCTURED_LOOP_TO_SELECTION_REDUCTION_OPPORTUNITY_H_ #include "source/opt/def_use_manager.h" #include "source/opt/dominator_analysis.h" #include "source/opt/function.h" #include "source/reduce/reduction_opportunity.h" namespace spvtools { namespace reduce { // An opportunity to replace a structured loop with a selection. class StructuredLoopToSelectionReductionOpportunity : public ReductionOpportunity { public: // Constructs an opportunity from a loop header block and the function that // encloses it. explicit StructuredLoopToSelectionReductionOpportunity( opt::IRContext* context, opt::BasicBlock* loop_construct_header) : context_(context), loop_construct_header_(loop_construct_header) {} // Returns true if the loop header is reachable. A structured loop might // become unreachable as a result of turning another structured loop into // a selection. bool PreconditionHolds() override; protected: void Apply() override; private: // Parameter |original_target_id| is the id of the loop's merge block or // continue target. This method considers each edge of the form // b->original_target_id and transforms it into an edge of the form b->c, // where c is the merge block of the structured control flow construct that // most tightly contains b. void RedirectToClosestMergeBlock(uint32_t original_target_id); // |source_id|, |original_target_id| and |new_target_id| are required to all // be distinct, with a CFG edge existing from |source_id| to // |original_target_id|, and |original_target_id| being either the merge block // or continue target for the loop being operated on. // The method removes this edge and adds an edge from // |source_id| to |new_target_id|. It takes care of fixing up any OpPhi // instructions associated with |original_target_id| and |new_target_id|. void RedirectEdge(uint32_t source_id, uint32_t original_target_id, uint32_t new_target_id); // Adds components to |to_block|'s phi instructions to account for a new // incoming edge from |from_id|. void AdaptPhiInstructionsForAddedEdge(uint32_t from_id, opt::BasicBlock* to_block); // Turns the OpLoopMerge for the loop into OpSelectionMerge, and adapts the // following branch instruction accordingly. void ChangeLoopToSelection(); // Fixes any scenarios where, due to CFG changes, ids have uses not dominated // by their definitions, by changing such uses to uses of OpUndef or of // placeholder variables. void FixNonDominatedIdUses(); // Returns true if and only if at least one of the following holds: // 1) |def| dominates |use| // 2) |def| is an OpVariable // 3) |use| is part of an OpPhi, with associated incoming block b, and |def| // dominates b. bool DefinitionSufficientlyDominatesUse(opt::Instruction* def, opt::Instruction* use, uint32_t use_index, opt::BasicBlock& def_block); opt::IRContext* context_; opt::BasicBlock* loop_construct_header_; }; } // namespace reduce } // namespace spvtools #endif // SOURCE_REDUCE_STRUCTURED_LOOP_TO_SELECTION_REDUCTION_OPPORTUNITY_H_ structured_loop_to_selection_reduction_opportunity_finder.cpp000066400000000000000000000073631475742701700360410ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/reduce// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/structured_loop_to_selection_reduction_opportunity_finder.h" #include "source/reduce/structured_loop_to_selection_reduction_opportunity.h" namespace spvtools { namespace reduce { namespace { const uint32_t kMergeNodeIndex = 0; const uint32_t kContinueNodeIndex = 1; } // namespace std::vector> StructuredLoopToSelectionReductionOpportunityFinder::GetAvailableOpportunities( opt::IRContext* context, uint32_t target_function) const { std::vector> result; std::set merge_block_ids; for (auto* function : GetTargetFunctions(context, target_function)) { for (auto& block : *function) { auto merge_block_id = block.MergeBlockIdIfAny(); if (merge_block_id) { merge_block_ids.insert(merge_block_id); } } } // Consider each loop construct header in the module. for (auto* function : GetTargetFunctions(context, target_function)) { for (auto& block : *function) { auto loop_merge_inst = block.GetLoopMergeInst(); if (!loop_merge_inst) { // This is not a loop construct header. continue; } uint32_t continue_block_id = loop_merge_inst->GetSingleWordOperand(kContinueNodeIndex); // Check whether the loop construct's continue target is the merge block // of some structured control flow construct. If it is, we cautiously do // not consider applying a transformation. if (merge_block_ids.find(continue_block_id) != merge_block_ids.end()) { continue; } // Check whether the loop header block is also the continue target. If it // is, we cautiously do not consider applying a transformation. if (block.id() == continue_block_id) { continue; } // Check whether the loop construct header dominates its merge block. // If not, the merge block must be unreachable in the control flow graph // so we cautiously do not consider applying a transformation. auto merge_block_id = loop_merge_inst->GetSingleWordInOperand(kMergeNodeIndex); if (!context->GetDominatorAnalysis(function)->Dominates(block.id(), merge_block_id)) { continue; } // Check whether the loop construct merge block postdominates the loop // construct header. If not (e.g. because the loop contains OpReturn, // OpKill or OpUnreachable), we cautiously do not consider applying // a transformation. if (!context->GetPostDominatorAnalysis(function)->Dominates( merge_block_id, block.id())) { continue; } // We can turn this structured loop into a selection, so add the // opportunity to do so. result.push_back( MakeUnique(context, &block)); } } return result; } std::string StructuredLoopToSelectionReductionOpportunityFinder::GetName() const { return "StructuredLoopToSelectionReductionOpportunityFinder"; } } // namespace reduce } // namespace spvtools structured_loop_to_selection_reduction_opportunity_finder.h000066400000000000000000000034611475742701700355010ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/reduce// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_REDUCE_STRUCTURED_LOOP_TO_SELECTION_REDUCTION_OPPORTUNITY_FINDER_H #define SOURCE_REDUCE_STRUCTURED_LOOP_TO_SELECTION_REDUCTION_OPPORTUNITY_FINDER_H #include "source/reduce/reduction_opportunity_finder.h" namespace spvtools { namespace reduce { // A finder for opportunities to turn structured loops into selections, // generalizing from a human-writable language the idea of turning a loop: // // while (c) { // body; // } // // into: // // if (c) { // body; // } // // Applying such opportunities results in continue constructs of transformed // loops becoming unreachable, so that it may be possible to remove them // subsequently. class StructuredLoopToSelectionReductionOpportunityFinder : public ReductionOpportunityFinder { public: StructuredLoopToSelectionReductionOpportunityFinder() = default; ~StructuredLoopToSelectionReductionOpportunityFinder() override = default; std::string GetName() const final; std::vector> GetAvailableOpportunities( opt::IRContext* context, uint32_t target_function) const final; private: }; } // namespace reduce } // namespace spvtools #endif // SOURCE_REDUCE_STRUCTURED_LOOP_TO_SELECTION_REDUCTION_OPPORTUNITY_FINDER_H KhronosGroup-SPIRV-Tools-f289d04/source/software_version.cpp000066400000000000000000000015751475742701700241440ustar00rootroot00000000000000// Copyright (c) 2015-2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "spirv-tools/libspirv.h" namespace { const char* kBuildVersions[] = { #include "build-version.inc" }; } // anonymous namespace const char* spvSoftwareVersionString(void) { return kBuildVersions[0]; } const char* spvSoftwareVersionDetailsString(void) { return kBuildVersions[1]; } KhronosGroup-SPIRV-Tools-f289d04/source/spirv_constant.h000066400000000000000000000075031475742701700232630ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_SPIRV_CONSTANT_H_ #define SOURCE_SPIRV_CONSTANT_H_ #include "source/latest_version_spirv_header.h" #include "spirv-tools/libspirv.h" // Version number macros. // Evaluates to a well-formed version header word, given valid // SPIR-V version major and minor version numbers. #define SPV_SPIRV_VERSION_WORD(MAJOR, MINOR) \ ((uint32_t(uint8_t(MAJOR)) << 16) | (uint32_t(uint8_t(MINOR)) << 8)) // Returns the major version extracted from a version header word. #define SPV_SPIRV_VERSION_MAJOR_PART(WORD) ((uint32_t(WORD) >> 16) & 0xff) // Returns the minor version extracted from a version header word. #define SPV_SPIRV_VERSION_MINOR_PART(WORD) ((uint32_t(WORD) >> 8) & 0xff) // Header indices #define SPV_INDEX_MAGIC_NUMBER 0u #define SPV_INDEX_VERSION_NUMBER 1u #define SPV_INDEX_GENERATOR_NUMBER 2u #define SPV_INDEX_BOUND 3u #define SPV_INDEX_SCHEMA 4u #define SPV_INDEX_INSTRUCTION 5u // Universal limits // SPIR-V 1.0 limits #define SPV_LIMIT_INSTRUCTION_WORD_COUNT_MAX 0xffff #define SPV_LIMIT_LITERAL_STRING_UTF8_CHARS_MAX 0xffff // A single Unicode character in UTF-8 encoding can take // up 4 bytes. #define SPV_LIMIT_LITERAL_STRING_BYTES_MAX \ (SPV_LIMIT_LITERAL_STRING_UTF8_CHARS_MAX * 4) // NOTE: These are set to the minimum maximum values // TODO(dneto): Check these. // libspirv limits. #define SPV_LIMIT_RESULT_ID_BOUND 0x00400000 #define SPV_LIMIT_CONTROL_FLOW_NEST_DEPTH 0x00000400 #define SPV_LIMIT_GLOBAL_VARIABLES_MAX 0x00010000 #define SPV_LIMIT_LOCAL_VARIABLES_MAX 0x00080000 // TODO: Decorations per target ID max, depends on decoration table size #define SPV_LIMIT_EXECUTION_MODE_PER_ENTRY_POINT_MAX 0x00000100 #define SPV_LIMIT_INDICIES_MAX_ACCESS_CHAIN_COMPOSITE_MAX 0x00000100 #define SPV_LIMIT_FUNCTION_PARAMETERS_PER_FUNCTION_DECL 0x00000100 #define SPV_LIMIT_FUNCTION_CALL_ARGUMENTS_MAX 0x00000100 #define SPV_LIMIT_EXT_FUNCTION_CALL_ARGUMENTS_MAX 0x00000100 #define SPV_LIMIT_SWITCH_LITERAL_LABEL_PAIRS_MAX 0x00004000 #define SPV_LIMIT_STRUCT_MEMBERS_MAX 0x0000400 #define SPV_LIMIT_STRUCT_NESTING_DEPTH_MAX 0x00000100 // Enumerations // Values mapping to registered tools. See the registry at // https://www.khronos.org/registry/spir-v/api/spir-v.xml // These values occupy the higher order 16 bits of the generator magic word. typedef enum spv_generator_t { // TODO(dneto) Values 0 through 5 were registered only as vendor. SPV_GENERATOR_KHRONOS = 0, SPV_GENERATOR_LUNARG = 1, SPV_GENERATOR_VALVE = 2, SPV_GENERATOR_CODEPLAY = 3, SPV_GENERATOR_NVIDIA = 4, SPV_GENERATOR_ARM = 5, // These are vendor and tool. SPV_GENERATOR_KHRONOS_LLVM_TRANSLATOR = 6, SPV_GENERATOR_KHRONOS_ASSEMBLER = 7, SPV_GENERATOR_KHRONOS_GLSLANG = 8, SPV_GENERATOR_KHRONOS_LINKER = 17, SPV_GENERATOR_NUM_ENTRIES, SPV_FORCE_16_BIT_ENUM(spv_generator_t) } spv_generator_t; // Evaluates to a well-formed generator magic word from a tool value and // miscellaneous 16-bit value. #define SPV_GENERATOR_WORD(TOOL, MISC) \ ((uint32_t(uint16_t(TOOL)) << 16) | uint16_t(MISC)) // Returns the tool component of the generator word. #define SPV_GENERATOR_TOOL_PART(WORD) (uint32_t(WORD) >> 16) // Returns the misc part of the generator word. #define SPV_GENERATOR_MISC_PART(WORD) (uint32_t(WORD) & 0xFFFF) #endif // SOURCE_SPIRV_CONSTANT_H_ KhronosGroup-SPIRV-Tools-f289d04/source/spirv_definition.h000066400000000000000000000021351475742701700235560ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_SPIRV_DEFINITION_H_ #define SOURCE_SPIRV_DEFINITION_H_ #include #include "source/latest_version_spirv_header.h" #define spvIsInBitfield(value, bitfield) ((value) == ((value)&bitfield)) typedef struct spv_header_t { uint32_t magic; uint32_t version; uint32_t generator; uint32_t bound; uint32_t schema; // NOTE: Reserved const uint32_t* instructions; // NOTE: Unfixed pointer to instruction stream } spv_header_t; #endif // SOURCE_SPIRV_DEFINITION_H_ KhronosGroup-SPIRV-Tools-f289d04/source/spirv_endian.cpp000066400000000000000000000050151475742701700232170ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/spirv_endian.h" #include enum { I32_ENDIAN_LITTLE = 0x03020100ul, I32_ENDIAN_BIG = 0x00010203ul, }; // This constant value allows the detection of the host machine's endianness. // Accessing it through the "value" member is valid due to C++11 section 3.10 // paragraph 10. static const union { unsigned char bytes[4]; uint32_t value; } o32_host_order = {{0, 1, 2, 3}}; #define I32_ENDIAN_HOST (o32_host_order.value) uint32_t spvFixWord(const uint32_t word, const spv_endianness_t endian) { if ((SPV_ENDIANNESS_LITTLE == endian && I32_ENDIAN_HOST == I32_ENDIAN_BIG) || (SPV_ENDIANNESS_BIG == endian && I32_ENDIAN_HOST == I32_ENDIAN_LITTLE)) { return (word & 0x000000ff) << 24 | (word & 0x0000ff00) << 8 | (word & 0x00ff0000) >> 8 | (word & 0xff000000) >> 24; } return word; } uint64_t spvFixDoubleWord(const uint32_t low, const uint32_t high, const spv_endianness_t endian) { return (uint64_t(spvFixWord(high, endian)) << 32) | spvFixWord(low, endian); } spv_result_t spvBinaryEndianness(spv_const_binary binary, spv_endianness_t* pEndian) { if (!binary->code || !binary->wordCount) return SPV_ERROR_INVALID_BINARY; if (!pEndian) return SPV_ERROR_INVALID_POINTER; uint8_t bytes[4]; memcpy(bytes, binary->code, sizeof(uint32_t)); if (0x03 == bytes[0] && 0x02 == bytes[1] && 0x23 == bytes[2] && 0x07 == bytes[3]) { *pEndian = SPV_ENDIANNESS_LITTLE; return SPV_SUCCESS; } if (0x07 == bytes[0] && 0x23 == bytes[1] && 0x02 == bytes[2] && 0x03 == bytes[3]) { *pEndian = SPV_ENDIANNESS_BIG; return SPV_SUCCESS; } return SPV_ERROR_INVALID_BINARY; } bool spvIsHostEndian(spv_endianness_t endian) { return ((SPV_ENDIANNESS_LITTLE == endian) && (I32_ENDIAN_LITTLE == I32_ENDIAN_HOST)) || ((SPV_ENDIANNESS_BIG == endian) && (I32_ENDIAN_BIG == I32_ENDIAN_HOST)); } KhronosGroup-SPIRV-Tools-f289d04/source/spirv_endian.h000066400000000000000000000030501475742701700226610ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_SPIRV_ENDIAN_H_ #define SOURCE_SPIRV_ENDIAN_H_ #include "spirv-tools/libspirv.h" // Converts a word in the specified endianness to the host native endianness. uint32_t spvFixWord(const uint32_t word, const spv_endianness_t endianness); // Converts a pair of words in the specified endianness to the host native // endianness. uint64_t spvFixDoubleWord(const uint32_t low, const uint32_t high, const spv_endianness_t endianness); // Gets the endianness of the SPIR-V module given in the binary parameter. // Returns SPV_ENDIANNESS_UNKNOWN if the SPIR-V magic number is invalid, // otherwise writes the determined endianness into *endian. spv_result_t spvBinaryEndianness(const spv_const_binary binary, spv_endianness_t* endian); // Returns true if the given endianness matches the host's native endianness. bool spvIsHostEndian(spv_endianness_t endian); #endif // SOURCE_SPIRV_ENDIAN_H_ KhronosGroup-SPIRV-Tools-f289d04/source/spirv_fuzzer_options.cpp000066400000000000000000000042511475742701700250620ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/spirv_fuzzer_options.h" namespace { // The default maximum number of steps for the reducer to run before giving up. const uint32_t kDefaultStepLimit = 250; } // namespace spv_fuzzer_options_t::spv_fuzzer_options_t() : has_random_seed(false), random_seed(0), replay_range(0), replay_validation_enabled(false), shrinker_step_limit(kDefaultStepLimit), fuzzer_pass_validation_enabled(false), all_passes_enabled(false) {} SPIRV_TOOLS_EXPORT spv_fuzzer_options spvFuzzerOptionsCreate() { return new spv_fuzzer_options_t(); } SPIRV_TOOLS_EXPORT void spvFuzzerOptionsDestroy(spv_fuzzer_options options) { delete options; } SPIRV_TOOLS_EXPORT void spvFuzzerOptionsEnableReplayValidation( spv_fuzzer_options options) { options->replay_validation_enabled = true; } SPIRV_TOOLS_EXPORT void spvFuzzerOptionsSetRandomSeed( spv_fuzzer_options options, uint32_t seed) { options->has_random_seed = true; options->random_seed = seed; } SPIRV_TOOLS_EXPORT void spvFuzzerOptionsSetReplayRange( spv_fuzzer_options options, int32_t replay_range) { options->replay_range = replay_range; } SPIRV_TOOLS_EXPORT void spvFuzzerOptionsSetShrinkerStepLimit( spv_fuzzer_options options, uint32_t shrinker_step_limit) { options->shrinker_step_limit = shrinker_step_limit; } SPIRV_TOOLS_EXPORT void spvFuzzerOptionsEnableFuzzerPassValidation( spv_fuzzer_options options) { options->fuzzer_pass_validation_enabled = true; } SPIRV_TOOLS_EXPORT void spvFuzzerOptionsEnableAllPasses( spv_fuzzer_options options) { options->all_passes_enabled = true; } KhronosGroup-SPIRV-Tools-f289d04/source/spirv_fuzzer_options.h000066400000000000000000000026401475742701700245270ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_SPIRV_FUZZER_OPTIONS_H_ #define SOURCE_SPIRV_FUZZER_OPTIONS_H_ #include "spirv-tools/libspirv.h" #include #include // Manages command line options passed to the SPIR-V Fuzzer. New struct // members may be added for any new option. struct spv_fuzzer_options_t { spv_fuzzer_options_t(); // See spvFuzzerOptionsSetRandomSeed. bool has_random_seed; uint32_t random_seed; // See spvFuzzerOptionsSetReplayRange. int32_t replay_range; // See spvFuzzerOptionsEnableReplayValidation. bool replay_validation_enabled; // See spvFuzzerOptionsSetShrinkerStepLimit. uint32_t shrinker_step_limit; // See spvFuzzerOptionsValidateAfterEveryPass. bool fuzzer_pass_validation_enabled; // See spvFuzzerOptionsEnableAllPasses. bool all_passes_enabled; }; #endif // SOURCE_SPIRV_FUZZER_OPTIONS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/spirv_optimizer_options.cpp000066400000000000000000000032021475742701700255520ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "source/spirv_optimizer_options.h" SPIRV_TOOLS_EXPORT spv_optimizer_options spvOptimizerOptionsCreate(void) { return new spv_optimizer_options_t(); } SPIRV_TOOLS_EXPORT void spvOptimizerOptionsDestroy( spv_optimizer_options options) { delete options; } SPIRV_TOOLS_EXPORT void spvOptimizerOptionsSetRunValidator( spv_optimizer_options options, bool val) { options->run_validator_ = val; } SPIRV_TOOLS_EXPORT void spvOptimizerOptionsSetValidatorOptions( spv_optimizer_options options, spv_validator_options val) { options->val_options_ = *val; } SPIRV_TOOLS_EXPORT void spvOptimizerOptionsSetMaxIdBound( spv_optimizer_options options, uint32_t val) { options->max_id_bound_ = val; } SPIRV_TOOLS_EXPORT void spvOptimizerOptionsSetPreserveBindings( spv_optimizer_options options, bool val) { options->preserve_bindings_ = val; } SPIRV_TOOLS_EXPORT void spvOptimizerOptionsSetPreserveSpecConstants( spv_optimizer_options options, bool val) { options->preserve_spec_constants_ = val; } KhronosGroup-SPIRV-Tools-f289d04/source/spirv_optimizer_options.h000066400000000000000000000033701475742701700252250ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_SPIRV_OPTIMIZER_OPTIONS_H_ #define SOURCE_SPIRV_OPTIMIZER_OPTIONS_H_ #include "source/spirv_validator_options.h" #include "spirv-tools/libspirv.h" // Manages command line options passed to the SPIR-V Validator. New struct // members may be added for any new option. struct spv_optimizer_options_t { spv_optimizer_options_t() : run_validator_(true), val_options_(), max_id_bound_(kDefaultMaxIdBound), preserve_bindings_(false), preserve_spec_constants_(false) {} // When true the validator will be run before optimizations are run. bool run_validator_; // Options to pass to the validator if it is run. spv_validator_options_t val_options_; // The maximum value the id bound for a module can have. The Spir-V spec says // this value must be at least 0x3FFFFF, but implementations can allow for a // higher value. uint32_t max_id_bound_; // When true, all binding declarations within the module should be preserved. bool preserve_bindings_; // When true, all specialization constants within the module should be // preserved. bool preserve_spec_constants_; }; #endif // SOURCE_SPIRV_OPTIMIZER_OPTIONS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/spirv_reducer_options.cpp000066400000000000000000000032471475742701700251720ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "source/spirv_reducer_options.h" namespace { // The default maximum number of steps the reducer will take before giving up. const uint32_t kDefaultStepLimit = 2500; } // namespace spv_reducer_options_t::spv_reducer_options_t() : step_limit(kDefaultStepLimit), fail_on_validation_error(false), target_function(0) {} SPIRV_TOOLS_EXPORT spv_reducer_options spvReducerOptionsCreate() { return new spv_reducer_options_t(); } SPIRV_TOOLS_EXPORT void spvReducerOptionsDestroy(spv_reducer_options options) { delete options; } SPIRV_TOOLS_EXPORT void spvReducerOptionsSetStepLimit( spv_reducer_options options, uint32_t step_limit) { options->step_limit = step_limit; } SPIRV_TOOLS_EXPORT void spvReducerOptionsSetFailOnValidationError( spv_reducer_options options, bool fail_on_validation_error) { options->fail_on_validation_error = fail_on_validation_error; } SPIRV_TOOLS_EXPORT void spvReducerOptionsSetTargetFunction( spv_reducer_options options, uint32_t target_function) { options->target_function = target_function; } KhronosGroup-SPIRV-Tools-f289d04/source/spirv_reducer_options.h000066400000000000000000000022501475742701700246300ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_SPIRV_REDUCER_OPTIONS_H_ #define SOURCE_SPIRV_REDUCER_OPTIONS_H_ #include "spirv-tools/libspirv.h" #include #include // Manages command line options passed to the SPIR-V Reducer. New struct // members may be added for any new option. struct spv_reducer_options_t { spv_reducer_options_t(); // See spvReducerOptionsSetStepLimit. uint32_t step_limit; // See spvReducerOptionsSetFailOnValidationError. bool fail_on_validation_error; // See spvReducerOptionsSetTargetFunction. uint32_t target_function; }; #endif // SOURCE_SPIRV_REDUCER_OPTIONS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/spirv_target_env.cpp000066400000000000000000000411371475742701700241240ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/spirv_target_env.h" #include #include #include #include #include #include "source/latest_version_spirv_header.h" #include "source/spirv_constant.h" #include "spirv-tools/libspirv.h" const char* spvTargetEnvDescription(spv_target_env env) { switch (env) { case SPV_ENV_UNIVERSAL_1_0: return "SPIR-V 1.0"; case SPV_ENV_VULKAN_1_0: return "SPIR-V 1.0 (under Vulkan 1.0 semantics)"; case SPV_ENV_UNIVERSAL_1_1: return "SPIR-V 1.1"; case SPV_ENV_OPENCL_1_2: return "SPIR-V 1.0 (under OpenCL 1.2 Full Profile semantics)"; case SPV_ENV_OPENCL_EMBEDDED_1_2: return "SPIR-V 1.0 (under OpenCL 1.2 Embedded Profile semantics)"; case SPV_ENV_OPENCL_2_0: return "SPIR-V 1.0 (under OpenCL 2.0 Full Profile semantics)"; case SPV_ENV_OPENCL_EMBEDDED_2_0: return "SPIR-V 1.0 (under OpenCL 2.0 Embedded Profile semantics)"; case SPV_ENV_OPENCL_2_1: return "SPIR-V 1.0 (under OpenCL 2.1 Full Profile semantics)"; case SPV_ENV_OPENCL_EMBEDDED_2_1: return "SPIR-V 1.0 (under OpenCL 2.1 Embedded Profile semantics)"; case SPV_ENV_OPENCL_2_2: return "SPIR-V 1.2 (under OpenCL 2.2 Full Profile semantics)"; case SPV_ENV_OPENCL_EMBEDDED_2_2: return "SPIR-V 1.2 (under OpenCL 2.2 Embedded Profile semantics)"; case SPV_ENV_OPENGL_4_0: return "SPIR-V 1.0 (under OpenGL 4.0 semantics)"; case SPV_ENV_OPENGL_4_1: return "SPIR-V 1.0 (under OpenGL 4.1 semantics)"; case SPV_ENV_OPENGL_4_2: return "SPIR-V 1.0 (under OpenGL 4.2 semantics)"; case SPV_ENV_OPENGL_4_3: return "SPIR-V 1.0 (under OpenGL 4.3 semantics)"; case SPV_ENV_OPENGL_4_5: return "SPIR-V 1.0 (under OpenGL 4.5 semantics)"; case SPV_ENV_UNIVERSAL_1_2: return "SPIR-V 1.2"; case SPV_ENV_UNIVERSAL_1_3: return "SPIR-V 1.3"; case SPV_ENV_VULKAN_1_1: return "SPIR-V 1.3 (under Vulkan 1.1 semantics)"; case SPV_ENV_WEBGPU_0: assert(false && "Deprecated target environment value."); break; case SPV_ENV_UNIVERSAL_1_4: return "SPIR-V 1.4"; case SPV_ENV_VULKAN_1_1_SPIRV_1_4: return "SPIR-V 1.4 (under Vulkan 1.1 semantics)"; case SPV_ENV_UNIVERSAL_1_5: return "SPIR-V 1.5"; case SPV_ENV_VULKAN_1_2: return "SPIR-V 1.5 (under Vulkan 1.2 semantics)"; case SPV_ENV_UNIVERSAL_1_6: return "SPIR-V 1.6"; case SPV_ENV_VULKAN_1_3: return "SPIR-V 1.6 (under Vulkan 1.3 semantics)"; case SPV_ENV_VULKAN_1_4: return "SPIR-V 1.6 (under Vulkan 1.4 semantics)"; case SPV_ENV_MAX: assert(false && "Invalid target environment value."); break; } return ""; } uint32_t spvVersionForTargetEnv(spv_target_env env) { switch (env) { case SPV_ENV_UNIVERSAL_1_0: case SPV_ENV_VULKAN_1_0: case SPV_ENV_OPENCL_1_2: case SPV_ENV_OPENCL_EMBEDDED_1_2: case SPV_ENV_OPENCL_2_0: case SPV_ENV_OPENCL_EMBEDDED_2_0: case SPV_ENV_OPENCL_2_1: case SPV_ENV_OPENCL_EMBEDDED_2_1: case SPV_ENV_OPENGL_4_0: case SPV_ENV_OPENGL_4_1: case SPV_ENV_OPENGL_4_2: case SPV_ENV_OPENGL_4_3: case SPV_ENV_OPENGL_4_5: return SPV_SPIRV_VERSION_WORD(1, 0); case SPV_ENV_UNIVERSAL_1_1: return SPV_SPIRV_VERSION_WORD(1, 1); case SPV_ENV_UNIVERSAL_1_2: case SPV_ENV_OPENCL_2_2: case SPV_ENV_OPENCL_EMBEDDED_2_2: return SPV_SPIRV_VERSION_WORD(1, 2); case SPV_ENV_UNIVERSAL_1_3: case SPV_ENV_VULKAN_1_1: return SPV_SPIRV_VERSION_WORD(1, 3); case SPV_ENV_WEBGPU_0: assert(false && "Deprecated target environment value."); break; case SPV_ENV_UNIVERSAL_1_4: case SPV_ENV_VULKAN_1_1_SPIRV_1_4: return SPV_SPIRV_VERSION_WORD(1, 4); case SPV_ENV_UNIVERSAL_1_5: case SPV_ENV_VULKAN_1_2: return SPV_SPIRV_VERSION_WORD(1, 5); case SPV_ENV_UNIVERSAL_1_6: case SPV_ENV_VULKAN_1_3: case SPV_ENV_VULKAN_1_4: return SPV_SPIRV_VERSION_WORD(1, 6); case SPV_ENV_MAX: assert(false && "Invalid target environment value."); break; } return SPV_SPIRV_VERSION_WORD(0, 0); } // When a new SPIR-V version is released, update this table. static_assert(spv::Version == 0x10600); constexpr auto ordered_universal_envs = std::array{ SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1, SPV_ENV_UNIVERSAL_1_2, SPV_ENV_UNIVERSAL_1_3, SPV_ENV_UNIVERSAL_1_4, SPV_ENV_UNIVERSAL_1_5, SPV_ENV_UNIVERSAL_1_6, }; // When a new SPIR-V version is released, update this table. // Users see this ordered list when running 'spirv-val --help'. Order // matters for readability. static_assert(spv::Version == 0x10600); inline constexpr std::pair spvTargetEnvNameMap[] = { // Do not reorder blindly. The algorithm to find the target looks for // the first entry where the key is a prefix of the string provided by // the user. For example, if the user provides `vulkan1.2spv1.5`, it // will match `vulkan1.2`. If this feature is to work correctly, the // keys must be ordered so that a string is before its prefix. For // example, `vulkan1.1spv1.4` must be before `vulkan1.1`. Otherwise, // `vulkan1.1` will be returned when looking for `vulkan1.1spv1.4`. {"vulkan1.0", SPV_ENV_VULKAN_1_0}, {"vulkan1.1spv1.4", SPV_ENV_VULKAN_1_1_SPIRV_1_4}, {"vulkan1.1", SPV_ENV_VULKAN_1_1}, {"vulkan1.2", SPV_ENV_VULKAN_1_2}, {"vulkan1.3", SPV_ENV_VULKAN_1_3}, {"vulkan1.4", SPV_ENV_VULKAN_1_4}, {"spv1.0", SPV_ENV_UNIVERSAL_1_0}, {"spv1.1", SPV_ENV_UNIVERSAL_1_1}, {"spv1.2", SPV_ENV_UNIVERSAL_1_2}, {"spv1.3", SPV_ENV_UNIVERSAL_1_3}, {"spv1.4", SPV_ENV_UNIVERSAL_1_4}, {"spv1.5", SPV_ENV_UNIVERSAL_1_5}, {"spv1.6", SPV_ENV_UNIVERSAL_1_6}, {"opencl1.2embedded", SPV_ENV_OPENCL_EMBEDDED_1_2}, {"opencl1.2", SPV_ENV_OPENCL_1_2}, {"opencl2.0embedded", SPV_ENV_OPENCL_EMBEDDED_2_0}, {"opencl2.0", SPV_ENV_OPENCL_2_0}, {"opencl2.1embedded", SPV_ENV_OPENCL_EMBEDDED_2_1}, {"opencl2.1", SPV_ENV_OPENCL_2_1}, {"opencl2.2embedded", SPV_ENV_OPENCL_EMBEDDED_2_2}, {"opencl2.2", SPV_ENV_OPENCL_2_2}, {"opengl4.0", SPV_ENV_OPENGL_4_0}, {"opengl4.1", SPV_ENV_OPENGL_4_1}, {"opengl4.2", SPV_ENV_OPENGL_4_2}, {"opengl4.3", SPV_ENV_OPENGL_4_3}, {"opengl4.5", SPV_ENV_OPENGL_4_5}, }; bool spvParseTargetEnv(const char* s, spv_target_env* env) { auto match = [s](const char* b) { return s && (0 == strncmp(s, b, strlen(b))); }; for (auto& name_env : spvTargetEnvNameMap) { if (match(name_env.first)) { if (env) { *env = name_env.second; } return true; } } if (env) *env = SPV_ENV_UNIVERSAL_1_0; return false; } bool spvReadEnvironmentFromText(const std::vector& text, spv_target_env* env) { // Version is expected to match "; Version: 1.X" // Version string must occur in header, that is, initial lines of comments // Once a non-comment line occurs, the header has ended for (std::size_t i = 0; i < text.size(); ++i) { char c = text[i]; if (c == ';') { // Try to match against the expected version string constexpr const char* kVersionPrefix = "; Version: 1."; constexpr const auto kPrefixLength = 13; // 'minor_digit_pos' is the expected position of the version digit. const auto minor_digit_pos = i + kPrefixLength; if (minor_digit_pos >= text.size()) return false; // Match the prefix. auto j = 1; for (; j < kPrefixLength; ++j) { if (kVersionPrefix[j] != text[i + j]) break; } // j will match the prefix length if all characters before matched if (j == kPrefixLength) { // This expects only one digit in the minor number. static_assert(((spv::Version >> 8) & 0xff) < 10); char minor = text[minor_digit_pos]; char next_char = minor_digit_pos + 1 < text.size() ? text[minor_digit_pos + 1] : 0; if (std::isdigit(minor) && !std::isdigit(next_char)) { const auto index = minor - '0'; assert(index >= 0); if (static_cast(index) < ordered_universal_envs.size()) { *env = ordered_universal_envs[index]; return true; } } } // If no match, determine whether the header has ended (in which case, // assumption has failed.) // Skip until the next line. i += j; for (; i < text.size(); ++i) { if (text[i] == '\n') break; } } else if (!std::isspace(c)) { // Allow blanks, but end the search if we find something else. break; } } return false; } #define VULKAN_VER(MAJOR, MINOR) ((MAJOR << 22) | (MINOR << 12)) #define SPIRV_VER(MAJOR, MINOR) ((MAJOR << 16) | (MINOR << 8)) struct VulkanEnv { spv_target_env vulkan_env; uint32_t vulkan_ver; uint32_t spirv_ver; }; // Maps each Vulkan target environment enum to the Vulkan version, and the // maximum supported SPIR-V version for that Vulkan environment. // Keep this ordered from least capable to most capable. static const VulkanEnv ordered_vulkan_envs[] = { {SPV_ENV_VULKAN_1_0, VULKAN_VER(1, 0), SPIRV_VER(1, 0)}, {SPV_ENV_VULKAN_1_1, VULKAN_VER(1, 1), SPIRV_VER(1, 3)}, {SPV_ENV_VULKAN_1_1_SPIRV_1_4, VULKAN_VER(1, 1), SPIRV_VER(1, 4)}, {SPV_ENV_VULKAN_1_2, VULKAN_VER(1, 2), SPIRV_VER(1, 5)}, {SPV_ENV_VULKAN_1_3, VULKAN_VER(1, 3), SPIRV_VER(1, 6)}, {SPV_ENV_VULKAN_1_4, VULKAN_VER(1, 4), SPIRV_VER(1, 6)}}; bool spvParseVulkanEnv(uint32_t vulkan_ver, uint32_t spirv_ver, spv_target_env* env) { for (auto triple : ordered_vulkan_envs) { if (triple.vulkan_ver >= vulkan_ver && triple.spirv_ver >= spirv_ver) { *env = triple.vulkan_env; return true; } } return false; } bool spvIsVulkanEnv(spv_target_env env) { switch (env) { case SPV_ENV_UNIVERSAL_1_0: case SPV_ENV_OPENCL_1_2: case SPV_ENV_OPENCL_EMBEDDED_1_2: case SPV_ENV_OPENCL_2_0: case SPV_ENV_OPENCL_EMBEDDED_2_0: case SPV_ENV_OPENCL_2_1: case SPV_ENV_OPENCL_EMBEDDED_2_1: case SPV_ENV_OPENGL_4_0: case SPV_ENV_OPENGL_4_1: case SPV_ENV_OPENGL_4_2: case SPV_ENV_OPENGL_4_3: case SPV_ENV_OPENGL_4_5: case SPV_ENV_UNIVERSAL_1_1: case SPV_ENV_UNIVERSAL_1_2: case SPV_ENV_OPENCL_2_2: case SPV_ENV_OPENCL_EMBEDDED_2_2: case SPV_ENV_UNIVERSAL_1_3: case SPV_ENV_UNIVERSAL_1_4: case SPV_ENV_UNIVERSAL_1_5: case SPV_ENV_UNIVERSAL_1_6: return false; case SPV_ENV_VULKAN_1_0: case SPV_ENV_VULKAN_1_1: case SPV_ENV_VULKAN_1_1_SPIRV_1_4: case SPV_ENV_VULKAN_1_2: case SPV_ENV_VULKAN_1_3: case SPV_ENV_VULKAN_1_4: return true; case SPV_ENV_WEBGPU_0: assert(false && "Deprecated target environment value."); break; case SPV_ENV_MAX: assert(false && "Invalid target environment value."); break; } return false; } bool spvIsOpenCLEnv(spv_target_env env) { switch (env) { case SPV_ENV_UNIVERSAL_1_0: case SPV_ENV_VULKAN_1_0: case SPV_ENV_UNIVERSAL_1_1: case SPV_ENV_OPENGL_4_0: case SPV_ENV_OPENGL_4_1: case SPV_ENV_OPENGL_4_2: case SPV_ENV_OPENGL_4_3: case SPV_ENV_OPENGL_4_5: case SPV_ENV_UNIVERSAL_1_2: case SPV_ENV_UNIVERSAL_1_3: case SPV_ENV_VULKAN_1_1: case SPV_ENV_UNIVERSAL_1_4: case SPV_ENV_VULKAN_1_1_SPIRV_1_4: case SPV_ENV_UNIVERSAL_1_5: case SPV_ENV_VULKAN_1_2: case SPV_ENV_UNIVERSAL_1_6: case SPV_ENV_VULKAN_1_3: case SPV_ENV_VULKAN_1_4: return false; case SPV_ENV_OPENCL_1_2: case SPV_ENV_OPENCL_EMBEDDED_1_2: case SPV_ENV_OPENCL_2_0: case SPV_ENV_OPENCL_EMBEDDED_2_0: case SPV_ENV_OPENCL_EMBEDDED_2_1: case SPV_ENV_OPENCL_EMBEDDED_2_2: case SPV_ENV_OPENCL_2_1: case SPV_ENV_OPENCL_2_2: return true; case SPV_ENV_WEBGPU_0: assert(false && "Deprecated target environment value."); break; case SPV_ENV_MAX: assert(false && "Invalid target environment value."); break; } return false; } bool spvIsOpenGLEnv(spv_target_env env) { switch (env) { case SPV_ENV_UNIVERSAL_1_0: case SPV_ENV_VULKAN_1_0: case SPV_ENV_UNIVERSAL_1_1: case SPV_ENV_UNIVERSAL_1_2: case SPV_ENV_UNIVERSAL_1_3: case SPV_ENV_VULKAN_1_1: case SPV_ENV_OPENCL_1_2: case SPV_ENV_OPENCL_EMBEDDED_1_2: case SPV_ENV_OPENCL_2_0: case SPV_ENV_OPENCL_EMBEDDED_2_0: case SPV_ENV_OPENCL_EMBEDDED_2_1: case SPV_ENV_OPENCL_EMBEDDED_2_2: case SPV_ENV_OPENCL_2_1: case SPV_ENV_OPENCL_2_2: case SPV_ENV_UNIVERSAL_1_4: case SPV_ENV_VULKAN_1_1_SPIRV_1_4: case SPV_ENV_UNIVERSAL_1_5: case SPV_ENV_VULKAN_1_2: case SPV_ENV_UNIVERSAL_1_6: case SPV_ENV_VULKAN_1_3: case SPV_ENV_VULKAN_1_4: return false; case SPV_ENV_OPENGL_4_0: case SPV_ENV_OPENGL_4_1: case SPV_ENV_OPENGL_4_2: case SPV_ENV_OPENGL_4_3: case SPV_ENV_OPENGL_4_5: return true; case SPV_ENV_WEBGPU_0: assert(false && "Deprecated target environment value."); break; case SPV_ENV_MAX: assert(false && "Invalid target environment value."); break; } return false; } bool spvIsValidEnv(spv_target_env env) { switch (env) { case SPV_ENV_UNIVERSAL_1_0: case SPV_ENV_VULKAN_1_0: case SPV_ENV_UNIVERSAL_1_1: case SPV_ENV_UNIVERSAL_1_2: case SPV_ENV_UNIVERSAL_1_3: case SPV_ENV_VULKAN_1_1: case SPV_ENV_OPENCL_1_2: case SPV_ENV_OPENCL_EMBEDDED_1_2: case SPV_ENV_OPENCL_2_0: case SPV_ENV_OPENCL_EMBEDDED_2_0: case SPV_ENV_OPENCL_EMBEDDED_2_1: case SPV_ENV_OPENCL_EMBEDDED_2_2: case SPV_ENV_OPENCL_2_1: case SPV_ENV_OPENCL_2_2: case SPV_ENV_UNIVERSAL_1_4: case SPV_ENV_VULKAN_1_1_SPIRV_1_4: case SPV_ENV_UNIVERSAL_1_5: case SPV_ENV_VULKAN_1_2: case SPV_ENV_UNIVERSAL_1_6: case SPV_ENV_VULKAN_1_3: case SPV_ENV_VULKAN_1_4: case SPV_ENV_OPENGL_4_0: case SPV_ENV_OPENGL_4_1: case SPV_ENV_OPENGL_4_2: case SPV_ENV_OPENGL_4_3: case SPV_ENV_OPENGL_4_5: return true; case SPV_ENV_WEBGPU_0: case SPV_ENV_MAX: break; } return false; } std::string spvLogStringForEnv(spv_target_env env) { switch (env) { case SPV_ENV_OPENCL_1_2: case SPV_ENV_OPENCL_2_0: case SPV_ENV_OPENCL_2_1: case SPV_ENV_OPENCL_2_2: case SPV_ENV_OPENCL_EMBEDDED_1_2: case SPV_ENV_OPENCL_EMBEDDED_2_0: case SPV_ENV_OPENCL_EMBEDDED_2_1: case SPV_ENV_OPENCL_EMBEDDED_2_2: { return "OpenCL"; } case SPV_ENV_OPENGL_4_0: case SPV_ENV_OPENGL_4_1: case SPV_ENV_OPENGL_4_2: case SPV_ENV_OPENGL_4_3: case SPV_ENV_OPENGL_4_5: { return "OpenGL"; } case SPV_ENV_VULKAN_1_0: case SPV_ENV_VULKAN_1_1: case SPV_ENV_VULKAN_1_1_SPIRV_1_4: case SPV_ENV_VULKAN_1_2: case SPV_ENV_VULKAN_1_3: case SPV_ENV_VULKAN_1_4: { return "Vulkan"; } case SPV_ENV_UNIVERSAL_1_0: case SPV_ENV_UNIVERSAL_1_1: case SPV_ENV_UNIVERSAL_1_2: case SPV_ENV_UNIVERSAL_1_3: case SPV_ENV_UNIVERSAL_1_4: case SPV_ENV_UNIVERSAL_1_5: case SPV_ENV_UNIVERSAL_1_6: { return "Universal"; } case SPV_ENV_WEBGPU_0: assert(false && "Deprecated target environment value."); break; case SPV_ENV_MAX: assert(false && "Invalid target environment value."); break; } return "Unknown"; } std::string spvTargetEnvList(const int pad, const int wrap) { std::string ret; size_t max_line_len = wrap - pad; // The first line isn't padded std::string line; std::string sep = ""; for (auto& name_env : spvTargetEnvNameMap) { std::string word = sep + name_env.first; if (line.length() + word.length() > max_line_len) { // Adding one word wouldn't fit, commit the line in progress and // start a new one. ret += line + "\n"; line.assign(pad, ' '); // The first line is done. The max length now comprises the // padding. max_line_len = wrap; } line += word; sep = "|"; } ret += line; return ret; } KhronosGroup-SPIRV-Tools-f289d04/source/spirv_target_env.h000066400000000000000000000042261475742701700235670ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_SPIRV_TARGET_ENV_H_ #define SOURCE_SPIRV_TARGET_ENV_H_ #include #include #include #include "spirv-tools/libspirv.h" // Returns true if |env| is a VULKAN environment, false otherwise. bool spvIsVulkanEnv(spv_target_env env); // Returns true if |env| is an OPENCL environment, false otherwise. bool spvIsOpenCLEnv(spv_target_env env); // Returns true if |env| is an OPENGL environment, false otherwise. bool spvIsOpenGLEnv(spv_target_env env); // Returns true if |env| is an implemented/valid environment, false otherwise. bool spvIsValidEnv(spv_target_env env); // Returns the version number for the given SPIR-V target environment. uint32_t spvVersionForTargetEnv(spv_target_env env); // Returns a string to use in logging messages that indicates the class of // environment, i.e. "Vulkan", "OpenCL", etc. std::string spvLogStringForEnv(spv_target_env env); // Returns a formatted list of all SPIR-V target environment names that // can be parsed by spvParseTargetEnv. // |pad| is the number of space characters that the beginning of each line // except the first one will be padded with. // |wrap| is the max length of lines the user desires. Word-wrapping will // occur to satisfy this limit. std::string spvTargetEnvList(const int pad, const int wrap); // Reads the target environment from the header comments of disassembly. Returns // true if valid name found, false otherwise. bool spvReadEnvironmentFromText(const std::vector& text, spv_target_env* env); #endif // SOURCE_SPIRV_TARGET_ENV_H_ KhronosGroup-SPIRV-Tools-f289d04/source/spirv_validator_options.cpp000066400000000000000000000123141475742701700255210ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/spirv_validator_options.h" #include #include bool spvParseUniversalLimitsOptions(const char* s, spv_validator_limit* type) { auto match = [s](const char* b) { return s && (0 == strncmp(s, b, strlen(b))); }; if (match("--max-struct-members")) { *type = spv_validator_limit_max_struct_members; } else if (match("--max-struct_depth")) { *type = spv_validator_limit_max_struct_depth; } else if (match("--max-local-variables")) { *type = spv_validator_limit_max_local_variables; } else if (match("--max-global-variables")) { *type = spv_validator_limit_max_global_variables; } else if (match("--max-switch-branches")) { *type = spv_validator_limit_max_global_variables; } else if (match("--max-function-args")) { *type = spv_validator_limit_max_function_args; } else if (match("--max-control-flow-nesting-depth")) { *type = spv_validator_limit_max_control_flow_nesting_depth; } else if (match("--max-access-chain-indexes")) { *type = spv_validator_limit_max_access_chain_indexes; } else if (match("--max-id-bound")) { *type = spv_validator_limit_max_id_bound; } else { // The command line option for this validator limit has not been added. // Therefore we return false. return false; } return true; } spv_validator_options spvValidatorOptionsCreate(void) { return new spv_validator_options_t; } void spvValidatorOptionsDestroy(spv_validator_options options) { delete options; } void spvValidatorOptionsSetUniversalLimit(spv_validator_options options, spv_validator_limit limit_type, uint32_t limit) { assert(options && "Validator options object may not be Null"); switch (limit_type) { #define LIMIT(TYPE, FIELD) \ case TYPE: \ options->universal_limits_.FIELD = limit; \ break; LIMIT(spv_validator_limit_max_struct_members, max_struct_members) LIMIT(spv_validator_limit_max_struct_depth, max_struct_depth) LIMIT(spv_validator_limit_max_local_variables, max_local_variables) LIMIT(spv_validator_limit_max_global_variables, max_global_variables) LIMIT(spv_validator_limit_max_switch_branches, max_switch_branches) LIMIT(spv_validator_limit_max_function_args, max_function_args) LIMIT(spv_validator_limit_max_control_flow_nesting_depth, max_control_flow_nesting_depth) LIMIT(spv_validator_limit_max_access_chain_indexes, max_access_chain_indexes) LIMIT(spv_validator_limit_max_id_bound, max_id_bound) #undef LIMIT } } void spvValidatorOptionsSetRelaxStoreStruct(spv_validator_options options, bool val) { options->relax_struct_store = val; } void spvValidatorOptionsSetRelaxLogicalPointer(spv_validator_options options, bool val) { options->relax_logical_pointer = val; } void spvValidatorOptionsSetBeforeHlslLegalization(spv_validator_options options, bool val) { options->before_hlsl_legalization = val; options->relax_logical_pointer = val; } void spvValidatorOptionsSetRelaxBlockLayout(spv_validator_options options, bool val) { options->relax_block_layout = val; } void spvValidatorOptionsSetUniformBufferStandardLayout( spv_validator_options options, bool val) { options->uniform_buffer_standard_layout = val; } void spvValidatorOptionsSetScalarBlockLayout(spv_validator_options options, bool val) { options->scalar_block_layout = val; } void spvValidatorOptionsSetWorkgroupScalarBlockLayout(spv_validator_options options, bool val) { options->workgroup_scalar_block_layout = val; } void spvValidatorOptionsSetSkipBlockLayout(spv_validator_options options, bool val) { options->skip_block_layout = val; } void spvValidatorOptionsSetAllowLocalSizeId(spv_validator_options options, bool val) { options->allow_localsizeid = val; } void spvValidatorOptionsSetAllowOffsetTextureOperand( spv_validator_options options, bool val) { options->allow_offset_texture_operand = val; } void spvValidatorOptionsSetAllowVulkan32BitBitwise( spv_validator_options options, bool val) { options->allow_vulkan_32_bit_bitwise = val; } void spvValidatorOptionsSetFriendlyNames(spv_validator_options options, bool val) { options->use_friendly_names = val; } KhronosGroup-SPIRV-Tools-f289d04/source/spirv_validator_options.h000066400000000000000000000050561475742701700251730ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_SPIRV_VALIDATOR_OPTIONS_H_ #define SOURCE_SPIRV_VALIDATOR_OPTIONS_H_ #include "spirv-tools/libspirv.h" // Return true if the command line option for the validator limit is valid (Also // returns the Enum for option in this case). Returns false otherwise. bool spvParseUniversalLimitsOptions(const char* s, spv_validator_limit* limit); // Default initialization of this structure is to the default Universal Limits // described in the SPIR-V Spec. struct validator_universal_limits_t { uint32_t max_struct_members{16383}; uint32_t max_struct_depth{255}; uint32_t max_local_variables{524287}; uint32_t max_global_variables{65535}; uint32_t max_switch_branches{16383}; uint32_t max_function_args{255}; uint32_t max_control_flow_nesting_depth{1023}; uint32_t max_access_chain_indexes{255}; uint32_t max_id_bound{0x3FFFFF}; }; // Manages command line options passed to the SPIR-V Validator. New struct // members may be added for any new option. struct spv_validator_options_t { spv_validator_options_t() : universal_limits_(), relax_struct_store(false), relax_logical_pointer(false), relax_block_layout(false), uniform_buffer_standard_layout(false), scalar_block_layout(false), workgroup_scalar_block_layout(false), skip_block_layout(false), allow_localsizeid(false), allow_offset_texture_operand(false), allow_vulkan_32_bit_bitwise(false), before_hlsl_legalization(false), use_friendly_names(true) {} validator_universal_limits_t universal_limits_; bool relax_struct_store; bool relax_logical_pointer; bool relax_block_layout; bool uniform_buffer_standard_layout; bool scalar_block_layout; bool workgroup_scalar_block_layout; bool skip_block_layout; bool allow_localsizeid; bool allow_offset_texture_operand; bool allow_vulkan_32_bit_bitwise; bool before_hlsl_legalization; bool use_friendly_names; }; #endif // SOURCE_SPIRV_VALIDATOR_OPTIONS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/table.cpp000066400000000000000000000042671475742701700216350ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/table.h" #include spv_context spvContextCreate(spv_target_env env) { switch (env) { case SPV_ENV_UNIVERSAL_1_0: case SPV_ENV_VULKAN_1_0: case SPV_ENV_UNIVERSAL_1_1: case SPV_ENV_OPENCL_1_2: case SPV_ENV_OPENCL_EMBEDDED_1_2: case SPV_ENV_OPENCL_2_0: case SPV_ENV_OPENCL_EMBEDDED_2_0: case SPV_ENV_OPENCL_2_1: case SPV_ENV_OPENCL_EMBEDDED_2_1: case SPV_ENV_OPENCL_2_2: case SPV_ENV_OPENCL_EMBEDDED_2_2: case SPV_ENV_OPENGL_4_0: case SPV_ENV_OPENGL_4_1: case SPV_ENV_OPENGL_4_2: case SPV_ENV_OPENGL_4_3: case SPV_ENV_OPENGL_4_5: case SPV_ENV_UNIVERSAL_1_2: case SPV_ENV_UNIVERSAL_1_3: case SPV_ENV_VULKAN_1_1: case SPV_ENV_VULKAN_1_1_SPIRV_1_4: case SPV_ENV_UNIVERSAL_1_4: case SPV_ENV_UNIVERSAL_1_5: case SPV_ENV_VULKAN_1_2: case SPV_ENV_UNIVERSAL_1_6: case SPV_ENV_VULKAN_1_3: case SPV_ENV_VULKAN_1_4: break; default: return nullptr; } spv_opcode_table opcode_table; spv_operand_table operand_table; spv_ext_inst_table ext_inst_table; spvOpcodeTableGet(&opcode_table, env); spvOperandTableGet(&operand_table, env); spvExtInstTableGet(&ext_inst_table, env); return new spv_context_t{env, opcode_table, operand_table, ext_inst_table, nullptr /* a null default consumer */}; } void spvContextDestroy(spv_context context) { delete context; } void spvtools::SetContextMessageConsumer(spv_context context, spvtools::MessageConsumer consumer) { context->consumer = std::move(consumer); } KhronosGroup-SPIRV-Tools-f289d04/source/table.h000066400000000000000000000116631475742701700213000ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_TABLE_H_ #define SOURCE_TABLE_H_ #include "source/extensions.h" #include "source/latest_version_spirv_header.h" #include "spirv-tools/libspirv.hpp" typedef struct spv_opcode_desc_t { const char* name; const spv::Op opcode; const uint32_t numAliases; const char** aliases; const uint32_t numCapabilities; const spv::Capability* capabilities; // operandTypes[0..numTypes-1] describe logical operands for the instruction. // The operand types include result id and result-type id, followed by // the types of arguments. const uint16_t numTypes; spv_operand_type_t operandTypes[16]; // TODO: Smaller/larger? const bool hasResult; // Does the instruction have a result ID operand? const bool hasType; // Does the instruction have a type ID operand? // A set of extensions that enable this feature. If empty then this operand // value is in core and its availability is subject to minVersion. The // assembler, binary parser, and disassembler ignore this rule, so you can // freely process invalid modules. const uint32_t numExtensions; const spvtools::Extension* extensions; // Minimal core SPIR-V version required for this feature, if without // extensions. ~0u means reserved for future use. ~0u and non-empty extension // lists means only available in extensions. const uint32_t minVersion; const uint32_t lastVersion; } spv_opcode_desc_t; typedef struct spv_operand_desc_t { const char* name; const uint32_t value; const uint32_t numAliases; const char** aliases; const uint32_t numCapabilities; const spv::Capability* capabilities; // A set of extensions that enable this feature. If empty then this operand // value is in core and its availability is subject to minVersion. The // assembler, binary parser, and disassembler ignore this rule, so you can // freely process invalid modules. const uint32_t numExtensions; const spvtools::Extension* extensions; const spv_operand_type_t operandTypes[16]; // TODO: Smaller/larger? // Minimal core SPIR-V version required for this feature, if without // extensions. ~0u means reserved for future use. ~0u and non-empty extension // lists means only available in extensions. const uint32_t minVersion; const uint32_t lastVersion; } spv_operand_desc_t; typedef struct spv_operand_desc_group_t { const spv_operand_type_t type; const uint32_t count; const spv_operand_desc_t* entries; } spv_operand_desc_group_t; typedef struct spv_ext_inst_desc_t { const char* name; const uint32_t ext_inst; const uint32_t numCapabilities; const spv::Capability* capabilities; const spv_operand_type_t operandTypes[40]; // vksp needs at least 40 } spv_ext_inst_desc_t; typedef struct spv_ext_inst_group_t { const spv_ext_inst_type_t type; const uint32_t count; const spv_ext_inst_desc_t* entries; } spv_ext_inst_group_t; typedef struct spv_opcode_table_t { const uint32_t count; const spv_opcode_desc_t* entries; } spv_opcode_table_t; typedef struct spv_operand_table_t { const uint32_t count; const spv_operand_desc_group_t* types; } spv_operand_table_t; typedef struct spv_ext_inst_table_t { const uint32_t count; const spv_ext_inst_group_t* groups; } spv_ext_inst_table_t; typedef const spv_opcode_desc_t* spv_opcode_desc; typedef const spv_operand_desc_t* spv_operand_desc; typedef const spv_ext_inst_desc_t* spv_ext_inst_desc; typedef const spv_opcode_table_t* spv_opcode_table; typedef const spv_operand_table_t* spv_operand_table; typedef const spv_ext_inst_table_t* spv_ext_inst_table; struct spv_context_t { const spv_target_env target_env; const spv_opcode_table opcode_table; const spv_operand_table operand_table; const spv_ext_inst_table ext_inst_table; spvtools::MessageConsumer consumer; }; namespace spvtools { // Sets the message consumer to |consumer| in the given |context|. The original // message consumer will be overwritten. void SetContextMessageConsumer(spv_context context, MessageConsumer consumer); } // namespace spvtools // Populates *table with entries for env. spv_result_t spvOpcodeTableGet(spv_opcode_table* table, spv_target_env env); // Populates *table with entries for env. spv_result_t spvOperandTableGet(spv_operand_table* table, spv_target_env env); // Populates *table with entries for env. spv_result_t spvExtInstTableGet(spv_ext_inst_table* table, spv_target_env env); #endif // SOURCE_TABLE_H_ KhronosGroup-SPIRV-Tools-f289d04/source/text.cpp000066400000000000000000000771401475742701700215320ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/text.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include "source/assembly_grammar.h" #include "source/binary.h" #include "source/diagnostic.h" #include "source/ext_inst.h" #include "source/instruction.h" #include "source/opcode.h" #include "source/operand.h" #include "source/spirv_constant.h" #include "source/spirv_target_env.h" #include "source/table.h" #include "source/text_handler.h" #include "source/util/bitutils.h" #include "source/util/parse_number.h" #include "spirv-tools/libspirv.h" bool spvIsValidIDCharacter(const char value) { return value == '_' || 0 != ::isalnum(value); } // Returns true if the given string represents a valid ID name. bool spvIsValidID(const char* textValue) { const char* c = textValue; for (; *c != '\0'; ++c) { if (!spvIsValidIDCharacter(*c)) { return false; } } // If the string was empty, then the ID also is not valid. return c != textValue; } // Text API spv_result_t spvTextToLiteral(const char* textValue, spv_literal_t* pLiteral) { bool isSigned = false; int numPeriods = 0; bool isString = false; const size_t len = strlen(textValue); if (len == 0) return SPV_FAILED_MATCH; for (uint64_t index = 0; index < len; ++index) { switch (textValue[index]) { case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': break; case '.': numPeriods++; break; case '-': if (index == 0) { isSigned = true; } else { isString = true; } break; default: isString = true; index = len; // break out of the loop too. break; } } pLiteral->type = spv_literal_type_t(99); if (isString || numPeriods > 1 || (isSigned && len == 1)) { if (len < 2 || textValue[0] != '"' || textValue[len - 1] != '"') return SPV_FAILED_MATCH; bool escaping = false; for (const char* val = textValue + 1; val != textValue + len - 1; ++val) { if ((*val == '\\') && (!escaping)) { escaping = true; } else { // Have to save space for the null-terminator if (pLiteral->str.size() >= SPV_LIMIT_LITERAL_STRING_BYTES_MAX) return SPV_ERROR_OUT_OF_MEMORY; pLiteral->str.push_back(*val); escaping = false; } } pLiteral->type = SPV_LITERAL_TYPE_STRING; } else if (numPeriods == 1) { double d = std::strtod(textValue, nullptr); float f = (float)d; if (d == (double)f) { pLiteral->type = SPV_LITERAL_TYPE_FLOAT_32; pLiteral->value.f = f; } else { pLiteral->type = SPV_LITERAL_TYPE_FLOAT_64; pLiteral->value.d = d; } } else if (isSigned) { int64_t i64 = strtoll(textValue, nullptr, 10); int32_t i32 = (int32_t)i64; if (i64 == (int64_t)i32) { pLiteral->type = SPV_LITERAL_TYPE_INT_32; pLiteral->value.i32 = i32; } else { pLiteral->type = SPV_LITERAL_TYPE_INT_64; pLiteral->value.i64 = i64; } } else { uint64_t u64 = strtoull(textValue, nullptr, 10); uint32_t u32 = (uint32_t)u64; if (u64 == (uint64_t)u32) { pLiteral->type = SPV_LITERAL_TYPE_UINT_32; pLiteral->value.u32 = u32; } else { pLiteral->type = SPV_LITERAL_TYPE_UINT_64; pLiteral->value.u64 = u64; } } return SPV_SUCCESS; } namespace { /// Parses an immediate integer from text, guarding against overflow. If /// successful, adds the parsed value to pInst, advances the context past it, /// and returns SPV_SUCCESS. Otherwise, leaves pInst alone, emits diagnostics, /// and returns SPV_ERROR_INVALID_TEXT. spv_result_t encodeImmediate(spvtools::AssemblyContext* context, const char* text, spv_instruction_t* pInst) { assert(*text == '!'); uint32_t parse_result; if (!spvtools::utils::ParseNumber(text + 1, &parse_result)) { return context->diagnostic(SPV_ERROR_INVALID_TEXT) << "Invalid immediate integer: !" << text + 1; } context->binaryEncodeU32(parse_result, pInst); context->seekForward(static_cast(strlen(text))); return SPV_SUCCESS; } } // anonymous namespace /// @brief Translate an Opcode operand to binary form /// /// @param[in] grammar the grammar to use for compilation /// @param[in, out] context the dynamic compilation info /// @param[in] type of the operand /// @param[in] textValue word of text to be parsed /// @param[out] pInst return binary Opcode /// @param[in,out] pExpectedOperands the operand types expected /// /// @return result code spv_result_t spvTextEncodeOperand(const spvtools::AssemblyGrammar& grammar, spvtools::AssemblyContext* context, const spv_operand_type_t type, const char* textValue, spv_instruction_t* pInst, spv_operand_pattern_t* pExpectedOperands) { // NOTE: Handle immediate int in the stream if ('!' == textValue[0]) { if (auto error = encodeImmediate(context, textValue, pInst)) { return error; } *pExpectedOperands = spvAlternatePatternFollowingImmediate(*pExpectedOperands); return SPV_SUCCESS; } // Optional literal operands can fail to parse. In that case use // SPV_FAILED_MATCH to avoid emitting a diagnostic. Use the following // for those situations. spv_result_t error_code_for_literals = spvOperandIsOptional(type) ? SPV_FAILED_MATCH : SPV_ERROR_INVALID_TEXT; switch (type) { case SPV_OPERAND_TYPE_ID: case SPV_OPERAND_TYPE_TYPE_ID: case SPV_OPERAND_TYPE_RESULT_ID: case SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID: case SPV_OPERAND_TYPE_SCOPE_ID: case SPV_OPERAND_TYPE_OPTIONAL_ID: { if ('%' == textValue[0]) { textValue++; } else { return context->diagnostic() << "Expected id to start with %."; } if (!spvIsValidID(textValue)) { return context->diagnostic() << "Invalid ID " << textValue; } const uint32_t id = context->spvNamedIdAssignOrGet(textValue); if (type == SPV_OPERAND_TYPE_TYPE_ID) pInst->resultTypeId = id; spvInstructionAddWord(pInst, id); // Set the extended instruction type. // The import set id is the 3rd operand of OpExtInst. if (spvIsExtendedInstruction(pInst->opcode) && pInst->words.size() == 4) { auto ext_inst_type = context->getExtInstTypeForId(pInst->words[3]); if (ext_inst_type == SPV_EXT_INST_TYPE_NONE) { return context->diagnostic() << "Invalid extended instruction import Id " << pInst->words[2]; } pInst->extInstType = ext_inst_type; } } break; case SPV_OPERAND_TYPE_EXTENSION_INSTRUCTION_NUMBER: { // The assembler accepts the symbolic name for an extended instruction, // and emits its corresponding number. spv_ext_inst_desc extInst; if (grammar.lookupExtInst(pInst->extInstType, textValue, &extInst) == SPV_SUCCESS) { // if we know about this extended instruction, push the numeric value spvInstructionAddWord(pInst, extInst->ext_inst); // Prepare to parse the operands for the extended instructions. spvPushOperandTypes(extInst->operandTypes, pExpectedOperands); } else { // if we don't know this extended instruction and the set isn't // non-semantic, we cannot process further if (!spvExtInstIsNonSemantic(pInst->extInstType)) { return context->diagnostic() << "Invalid extended instruction name '" << textValue << "'."; } else { // for non-semantic instruction sets, as long as the text name is an // integer value we can encode it since we know the form of all such // extended instructions spv_literal_t extInstValue; if (spvTextToLiteral(textValue, &extInstValue) || extInstValue.type != SPV_LITERAL_TYPE_UINT_32) { return context->diagnostic() << "Couldn't translate unknown extended instruction name '" << textValue << "' to unsigned integer."; } spvInstructionAddWord(pInst, extInstValue.value.u32); // opcode contains an unknown number of IDs. pExpectedOperands->push_back(SPV_OPERAND_TYPE_VARIABLE_ID); } } } break; case SPV_OPERAND_TYPE_SPEC_CONSTANT_OP_NUMBER: { // The assembler accepts the symbolic name for the opcode, but without // the "Op" prefix. For example, "IAdd" is accepted. The number // of the opcode is emitted. spv::Op opcode; if (grammar.lookupSpecConstantOpcode(textValue, &opcode)) { return context->diagnostic() << "Invalid " << spvOperandTypeStr(type) << " '" << textValue << "'."; } spv_opcode_desc opcodeEntry = nullptr; if (grammar.lookupOpcode(opcode, &opcodeEntry)) { return context->diagnostic(SPV_ERROR_INTERNAL) << "OpSpecConstant opcode table out of sync"; } spvInstructionAddWord(pInst, uint32_t(opcodeEntry->opcode)); // Prepare to parse the operands for the opcode. Except skip the // type Id and result Id, since they've already been processed. assert(opcodeEntry->hasType); assert(opcodeEntry->hasResult); assert(opcodeEntry->numTypes >= 2); spvPushOperandTypes(opcodeEntry->operandTypes + 2, pExpectedOperands); } break; case SPV_OPERAND_TYPE_LITERAL_INTEGER: case SPV_OPERAND_TYPE_OPTIONAL_LITERAL_INTEGER: { // The current operand is an *unsigned* 32-bit integer. // That's just how the grammar works. spvtools::IdType expected_type = { 32, false, spvtools::IdTypeClass::kScalarIntegerType}; if (auto error = context->binaryEncodeNumericLiteral( textValue, error_code_for_literals, expected_type, pInst)) { return error; } } break; case SPV_OPERAND_TYPE_LITERAL_FLOAT: { // The current operand is a 32-bit float. // That's just how the grammar works. spvtools::IdType expected_type = { 32, false, spvtools::IdTypeClass::kScalarFloatType}; if (auto error = context->binaryEncodeNumericLiteral( textValue, error_code_for_literals, expected_type, pInst)) { return error; } } break; case SPV_OPERAND_TYPE_OPTIONAL_LITERAL_NUMBER: // This is a context-independent literal number which can be a 32-bit // number of floating point value. if (auto error = context->binaryEncodeNumericLiteral( textValue, error_code_for_literals, spvtools::kUnknownType, pInst)) { return error; } break; case SPV_OPERAND_TYPE_OPTIONAL_TYPED_LITERAL_INTEGER: case SPV_OPERAND_TYPE_TYPED_LITERAL_NUMBER: { spvtools::IdType expected_type = spvtools::kUnknownType; // The encoding for OpConstant, OpSpecConstant and OpSwitch all // depend on either their own result-id or the result-id of // one of their parameters. if (spv::Op::OpConstant == pInst->opcode || spv::Op::OpSpecConstant == pInst->opcode) { // The type of the literal is determined by the type Id of the // instruction. expected_type = context->getTypeOfTypeGeneratingValue(pInst->resultTypeId); if (!spvtools::isScalarFloating(expected_type) && !spvtools::isScalarIntegral(expected_type)) { spv_opcode_desc d; const char* opcode_name = "opcode"; if (SPV_SUCCESS == grammar.lookupOpcode(pInst->opcode, &d)) { opcode_name = d->name; } return context->diagnostic() << "Type for " << opcode_name << " must be a scalar floating point or integer type"; } } else if (pInst->opcode == spv::Op::OpSwitch) { // The type of the literal is the same as the type of the selector. expected_type = context->getTypeOfValueInstruction(pInst->words[1]); if (!spvtools::isScalarIntegral(expected_type)) { return context->diagnostic() << "The selector operand for OpSwitch must be the result" " of an instruction that generates an integer scalar"; } } if (auto error = context->binaryEncodeNumericLiteral( textValue, error_code_for_literals, expected_type, pInst)) { return error; } } break; case SPV_OPERAND_TYPE_LITERAL_STRING: case SPV_OPERAND_TYPE_OPTIONAL_LITERAL_STRING: { spv_literal_t literal = {}; spv_result_t error = spvTextToLiteral(textValue, &literal); if (error != SPV_SUCCESS) { if (error == SPV_ERROR_OUT_OF_MEMORY) return error; return context->diagnostic(error_code_for_literals) << "Invalid literal string '" << textValue << "'."; } if (literal.type != SPV_LITERAL_TYPE_STRING) { return context->diagnostic() << "Expected literal string, found literal number '" << textValue << "'."; } // NOTE: Special case for extended instruction library import if (spv::Op::OpExtInstImport == pInst->opcode) { const spv_ext_inst_type_t ext_inst_type = spvExtInstImportTypeGet(literal.str.c_str()); if (SPV_EXT_INST_TYPE_NONE == ext_inst_type) { return context->diagnostic() << "Invalid extended instruction import '" << literal.str << "'"; } if ((error = context->recordIdAsExtInstImport(pInst->words[1], ext_inst_type))) return error; } if (context->binaryEncodeString(literal.str.c_str(), pInst)) return SPV_ERROR_INVALID_TEXT; } break; // Masks. case SPV_OPERAND_TYPE_FP_FAST_MATH_MODE: case SPV_OPERAND_TYPE_FUNCTION_CONTROL: case SPV_OPERAND_TYPE_LOOP_CONTROL: case SPV_OPERAND_TYPE_IMAGE: case SPV_OPERAND_TYPE_OPTIONAL_IMAGE: case SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS: case SPV_OPERAND_TYPE_OPTIONAL_RAW_ACCESS_CHAIN_OPERANDS: case SPV_OPERAND_TYPE_SELECTION_CONTROL: case SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS: case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS: case SPV_OPERAND_TYPE_OPTIONAL_COOPERATIVE_MATRIX_OPERANDS: case SPV_OPERAND_TYPE_TENSOR_ADDRESSING_OPERANDS: case SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_REDUCE: case SPV_OPERAND_TYPE_OPTIONAL_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS: { uint32_t value; if (auto error = grammar.parseMaskOperand(type, textValue, &value)) { return context->diagnostic(error) << "Invalid " << spvOperandTypeStr(type) << " operand '" << textValue << "'."; } if (auto error = context->binaryEncodeU32(value, pInst)) return error; // Prepare to parse the operands for this logical operand. grammar.pushOperandTypesForMask(type, value, pExpectedOperands); } break; case SPV_OPERAND_TYPE_OPTIONAL_CIV: { auto error = spvTextEncodeOperand( grammar, context, SPV_OPERAND_TYPE_OPTIONAL_LITERAL_NUMBER, textValue, pInst, pExpectedOperands); if (error == SPV_FAILED_MATCH) { // It's not a literal number -- is it a literal string? error = spvTextEncodeOperand(grammar, context, SPV_OPERAND_TYPE_OPTIONAL_LITERAL_STRING, textValue, pInst, pExpectedOperands); } if (error == SPV_FAILED_MATCH) { // It's not a literal -- is it an ID? error = spvTextEncodeOperand(grammar, context, SPV_OPERAND_TYPE_OPTIONAL_ID, textValue, pInst, pExpectedOperands); } if (error) { return context->diagnostic(error) << "Invalid word following !: " << textValue; } if (pExpectedOperands->empty()) { pExpectedOperands->push_back(SPV_OPERAND_TYPE_OPTIONAL_CIV); } } break; default: { // NOTE: All non literal operands are handled here using the operand // table. spv_operand_desc entry; if (grammar.lookupOperand(type, textValue, strlen(textValue), &entry)) { return context->diagnostic() << "Invalid " << spvOperandTypeStr(type) << " '" << textValue << "'."; } if (context->binaryEncodeU32(entry->value, pInst)) { return context->diagnostic() << "Invalid " << spvOperandTypeStr(type) << " '" << textValue << "'."; } // Prepare to parse the operands for this logical operand. spvPushOperandTypes(entry->operandTypes, pExpectedOperands); } break; } return SPV_SUCCESS; } namespace { /// Encodes an instruction started by ! at the given position in text. /// /// Puts the encoded words into *pInst. If successful, moves position past the /// instruction and returns SPV_SUCCESS. Otherwise, returns an error code and /// leaves position pointing to the error in text. spv_result_t encodeInstructionStartingWithImmediate( const spvtools::AssemblyGrammar& grammar, spvtools::AssemblyContext* context, spv_instruction_t* pInst) { std::string firstWord; spv_position_t nextPosition = {}; auto error = context->getWord(&firstWord, &nextPosition); if (error) return context->diagnostic(error) << "Internal Error"; if ((error = encodeImmediate(context, firstWord.c_str(), pInst))) { return error; } while (context->advance() != SPV_END_OF_STREAM) { // A beginning of a new instruction means we're done. if (context->isStartOfNewInst()) return SPV_SUCCESS; // Otherwise, there must be an operand that's either a literal, an ID, or // an immediate. std::string operandValue; if ((error = context->getWord(&operandValue, &nextPosition))) return context->diagnostic(error) << "Internal Error"; if (operandValue == "=") return context->diagnostic() << firstWord << " not allowed before =."; // Needed to pass to spvTextEncodeOpcode(), but it shouldn't ever be // expanded. spv_operand_pattern_t dummyExpectedOperands; error = spvTextEncodeOperand( grammar, context, SPV_OPERAND_TYPE_OPTIONAL_CIV, operandValue.c_str(), pInst, &dummyExpectedOperands); if (error) return error; context->setPosition(nextPosition); } return SPV_SUCCESS; } /// @brief Translate single Opcode and operands to binary form /// /// @param[in] grammar the grammar to use for compilation /// @param[in, out] context the dynamic compilation info /// @param[in] text stream to translate /// @param[out] pInst returned binary Opcode /// @param[in,out] pPosition in the text stream /// /// @return result code spv_result_t spvTextEncodeOpcode(const spvtools::AssemblyGrammar& grammar, spvtools::AssemblyContext* context, spv_instruction_t* pInst) { // Check for ! first. if ('!' == context->peek()) { return encodeInstructionStartingWithImmediate(grammar, context, pInst); } std::string firstWord; spv_position_t nextPosition = {}; spv_result_t error = context->getWord(&firstWord, &nextPosition); if (error) return context->diagnostic() << "Internal Error"; std::string opcodeName; std::string result_id; spv_position_t result_id_position = {}; if (context->startsWithOp()) { opcodeName = firstWord; } else { result_id = firstWord; if ('%' != result_id.front()) { return context->diagnostic() << "Expected or at the beginning " "of an instruction, found '" << result_id << "'."; } result_id_position = context->position(); // The '=' sign. context->setPosition(nextPosition); if (context->advance()) return context->diagnostic() << "Expected '=', found end of stream."; std::string equal_sign; error = context->getWord(&equal_sign, &nextPosition); if ("=" != equal_sign) return context->diagnostic() << "'=' expected after result id but found '" << equal_sign << "'."; // The after the '=' sign. context->setPosition(nextPosition); if (context->advance()) return context->diagnostic() << "Expected opcode, found end of stream."; error = context->getWord(&opcodeName, &nextPosition); if (error) return context->diagnostic(error) << "Internal Error"; if (!context->startsWithOp()) { return context->diagnostic() << "Invalid Opcode prefix '" << opcodeName << "'."; } } // NOTE: The table contains Opcode names without the "Op" prefix. const char* pInstName = opcodeName.data() + 2; spv_opcode_desc opcodeEntry; error = grammar.lookupOpcode(pInstName, &opcodeEntry); if (error) { return context->diagnostic(error) << "Invalid Opcode name '" << opcodeName << "'"; } if (opcodeEntry->hasResult && result_id.empty()) { return context->diagnostic() << "Expected at the beginning of an instruction, found '" << firstWord << "'."; } if (!opcodeEntry->hasResult && !result_id.empty()) { return context->diagnostic() << "Cannot set ID " << result_id << " because " << opcodeName << " does not produce a result ID."; } pInst->opcode = opcodeEntry->opcode; context->setPosition(nextPosition); // Reserve the first word for the instruction. spvInstructionAddWord(pInst, 0); // Maintains the ordered list of expected operand types. // For many instructions we only need the {numTypes, operandTypes} // entries in opcodeEntry. However, sometimes we need to modify // the list as we parse the operands. This occurs when an operand // has its own logical operands (such as the LocalSize operand for // ExecutionMode), or for extended instructions that may have their // own operands depending on the selected extended instruction. spv_operand_pattern_t expectedOperands; expectedOperands.reserve(opcodeEntry->numTypes); for (auto i = 0; i < opcodeEntry->numTypes; i++) expectedOperands.push_back( opcodeEntry->operandTypes[opcodeEntry->numTypes - i - 1]); while (!expectedOperands.empty()) { const spv_operand_type_t type = expectedOperands.back(); expectedOperands.pop_back(); // Expand optional tuples lazily. if (spvExpandOperandSequenceOnce(type, &expectedOperands)) continue; if (type == SPV_OPERAND_TYPE_RESULT_ID && !result_id.empty()) { // Handle the for value generating instructions. // We've already consumed it from the text stream. Here // we inject its words into the instruction. spv_position_t temp_pos = context->position(); error = spvTextEncodeOperand(grammar, context, SPV_OPERAND_TYPE_RESULT_ID, result_id.c_str(), pInst, nullptr); result_id_position = context->position(); // Because we are injecting we have to reset the position afterwards. context->setPosition(temp_pos); if (error) return error; } else { // Find the next word. error = context->advance(); if (error == SPV_END_OF_STREAM) { if (spvOperandIsOptional(type)) { // This would have been the last potential operand for the // instruction, // and we didn't find one. We're finished parsing this instruction. break; } else { return context->diagnostic() << "Expected operand for " << opcodeName << " instruction, but found the end of the stream."; } } assert(error == SPV_SUCCESS && "Somebody added another way to fail"); if (context->isStartOfNewInst()) { if (spvOperandIsOptional(type)) { break; } else { return context->diagnostic() << "Expected operand for " << opcodeName << " instruction, but found the next instruction instead."; } } std::string operandValue; error = context->getWord(&operandValue, &nextPosition); if (error) return context->diagnostic(error) << "Internal Error"; error = spvTextEncodeOperand(grammar, context, type, operandValue.c_str(), pInst, &expectedOperands); if (error == SPV_FAILED_MATCH && spvOperandIsOptional(type)) return SPV_SUCCESS; if (error) return error; context->setPosition(nextPosition); } } if (spvOpcodeGeneratesType(pInst->opcode)) { if (context->recordTypeDefinition(pInst) != SPV_SUCCESS) { return SPV_ERROR_INVALID_TEXT; } } else if (opcodeEntry->hasType) { // SPIR-V dictates that if an instruction has both a return value and a // type ID then the type id is first, and the return value is second. assert(opcodeEntry->hasResult && "Unknown opcode: has a type but no result."); context->recordTypeIdForValue(pInst->words[2], pInst->words[1]); } if (pInst->words.size() > SPV_LIMIT_INSTRUCTION_WORD_COUNT_MAX) { return context->diagnostic() << opcodeName << " Instruction too long: " << pInst->words.size() << " words, but the limit is " << SPV_LIMIT_INSTRUCTION_WORD_COUNT_MAX; } pInst->words[0] = spvOpcodeMake(uint16_t(pInst->words.size()), opcodeEntry->opcode); return SPV_SUCCESS; } enum { kAssemblerVersion = 0 }; // Populates a binary stream's |header|. The target environment is specified via // |env| and Id bound is via |bound|. spv_result_t SetHeader(spv_target_env env, const uint32_t bound, uint32_t* header) { if (!header) return SPV_ERROR_INVALID_BINARY; header[SPV_INDEX_MAGIC_NUMBER] = spv::MagicNumber; header[SPV_INDEX_VERSION_NUMBER] = spvVersionForTargetEnv(env); header[SPV_INDEX_GENERATOR_NUMBER] = SPV_GENERATOR_WORD(SPV_GENERATOR_KHRONOS_ASSEMBLER, kAssemblerVersion); header[SPV_INDEX_BOUND] = bound; header[SPV_INDEX_SCHEMA] = 0; // NOTE: Reserved return SPV_SUCCESS; } // Collects all numeric ids in the module source into |numeric_ids|. // This function is essentially a dry-run of spvTextToBinary. spv_result_t GetNumericIds(const spvtools::AssemblyGrammar& grammar, const spvtools::MessageConsumer& consumer, const spv_text text, std::set* numeric_ids) { spvtools::AssemblyContext context(text, consumer); if (!text->str) return context.diagnostic() << "Missing assembly text."; if (!grammar.isValid()) { return SPV_ERROR_INVALID_TABLE; } // Skip past whitespace and comments. context.advance(); while (context.hasText()) { spv_instruction_t inst; // Operand parsing sometimes involves knowing the opcode of the instruction // being parsed. A malformed input might feature such an operand *before* // the opcode is known. To guard against accessing an uninitialized opcode, // the instruction's opcode is initialized to a default value. inst.opcode = spv::Op::Max; if (spvTextEncodeOpcode(grammar, &context, &inst)) { return SPV_ERROR_INVALID_TEXT; } if (context.advance()) break; } *numeric_ids = context.GetNumericIds(); return SPV_SUCCESS; } // Translates a given assembly language module into binary form. // If a diagnostic is generated, it is not yet marked as being // for a text-based input. spv_result_t spvTextToBinaryInternal(const spvtools::AssemblyGrammar& grammar, const spvtools::MessageConsumer& consumer, const spv_text text, const uint32_t options, spv_binary* pBinary) { // The ids in this set will have the same values both in source and binary. // All other ids will be generated by filling in the gaps. std::set ids_to_preserve; if (options & SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS) { // Collect all numeric ids from the source into ids_to_preserve. const spv_result_t result = GetNumericIds(grammar, consumer, text, &ids_to_preserve); if (result != SPV_SUCCESS) return result; } spvtools::AssemblyContext context(text, consumer, std::move(ids_to_preserve)); if (!text->str) return context.diagnostic() << "Missing assembly text."; if (!grammar.isValid()) { return SPV_ERROR_INVALID_TABLE; } if (!pBinary) return SPV_ERROR_INVALID_POINTER; std::vector instructions; // Skip past whitespace and comments. context.advance(); while (context.hasText()) { instructions.push_back({}); spv_instruction_t& inst = instructions.back(); if (auto error = spvTextEncodeOpcode(grammar, &context, &inst)) { return error; } if (context.advance()) break; } size_t totalSize = SPV_INDEX_INSTRUCTION; for (auto& inst : instructions) { totalSize += inst.words.size(); } uint32_t* data = new uint32_t[totalSize]; if (!data) return SPV_ERROR_OUT_OF_MEMORY; uint64_t currentIndex = SPV_INDEX_INSTRUCTION; for (auto& inst : instructions) { memcpy(data + currentIndex, inst.words.data(), sizeof(uint32_t) * inst.words.size()); currentIndex += inst.words.size(); } if (auto error = SetHeader(grammar.target_env(), context.getBound(), data)) return error; spv_binary binary = new spv_binary_t(); if (!binary) { delete[] data; return SPV_ERROR_OUT_OF_MEMORY; } binary->code = data; binary->wordCount = totalSize; *pBinary = binary; return SPV_SUCCESS; } } // anonymous namespace spv_result_t spvTextToBinary(const spv_const_context context, const char* input_text, const size_t input_text_size, spv_binary* pBinary, spv_diagnostic* pDiagnostic) { return spvTextToBinaryWithOptions(context, input_text, input_text_size, SPV_TEXT_TO_BINARY_OPTION_NONE, pBinary, pDiagnostic); } spv_result_t spvTextToBinaryWithOptions(const spv_const_context context, const char* input_text, const size_t input_text_size, const uint32_t options, spv_binary* pBinary, spv_diagnostic* pDiagnostic) { spv_context_t hijack_context = *context; if (pDiagnostic) { *pDiagnostic = nullptr; spvtools::UseDiagnosticAsMessageConsumer(&hijack_context, pDiagnostic); } spv_text_t text = {input_text, input_text_size}; spvtools::AssemblyGrammar grammar(&hijack_context); spv_result_t result = spvTextToBinaryInternal( grammar, hijack_context.consumer, &text, options, pBinary); if (pDiagnostic && *pDiagnostic) (*pDiagnostic)->isTextSource = true; return result; } void spvTextDestroy(spv_text text) { if (text) { if (text->str) delete[] text->str; delete text; } } KhronosGroup-SPIRV-Tools-f289d04/source/text.h000066400000000000000000000031141475742701700211650ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_TEXT_H_ #define SOURCE_TEXT_H_ #include #include "source/operand.h" #include "source/spirv_constant.h" #include "spirv-tools/libspirv.h" typedef enum spv_literal_type_t { SPV_LITERAL_TYPE_INT_32, SPV_LITERAL_TYPE_INT_64, SPV_LITERAL_TYPE_UINT_32, SPV_LITERAL_TYPE_UINT_64, SPV_LITERAL_TYPE_FLOAT_32, SPV_LITERAL_TYPE_FLOAT_64, SPV_LITERAL_TYPE_STRING, SPV_FORCE_32_BIT_ENUM(spv_literal_type_t) } spv_literal_type_t; typedef struct spv_literal_t { spv_literal_type_t type; union value_t { int32_t i32; int64_t i64; uint32_t u32; uint64_t u64; float f; double d; } value; std::string str; // Special field for literal string. } spv_literal_t; // Converts the given text string to a number/string literal and writes the // result to *literal. String literals must be surrounded by double-quotes ("), // which are then stripped. spv_result_t spvTextToLiteral(const char* text, spv_literal_t* literal); #endif // SOURCE_TEXT_H_ KhronosGroup-SPIRV-Tools-f289d04/source/text_handler.cpp000066400000000000000000000314701475742701700232230ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/text_handler.h" #include #include #include #include #include #include "source/assembly_grammar.h" #include "source/binary.h" #include "source/ext_inst.h" #include "source/instruction.h" #include "source/opcode.h" #include "source/text.h" #include "source/util/bitutils.h" #include "source/util/hex_float.h" #include "source/util/parse_number.h" #include "source/util/string_utils.h" namespace spvtools { namespace { // Advances |text| to the start of the next line and writes the new position to // |position|. spv_result_t advanceLine(spv_text text, spv_position position) { while (true) { if (position->index >= text->length) return SPV_END_OF_STREAM; switch (text->str[position->index]) { case '\0': return SPV_END_OF_STREAM; case '\n': position->column = 0; position->line++; position->index++; return SPV_SUCCESS; default: position->column++; position->index++; break; } } } // Advances |text| to first non white space character and writes the new // position to |position|. // If a null terminator is found during the text advance, SPV_END_OF_STREAM is // returned, SPV_SUCCESS otherwise. No error checking is performed on the // parameters, its the users responsibility to ensure these are non null. spv_result_t advance(spv_text text, spv_position position) { // NOTE: Consume white space, otherwise don't advance. while (true) { if (position->index >= text->length) return SPV_END_OF_STREAM; switch (text->str[position->index]) { case '\0': return SPV_END_OF_STREAM; case ';': if (spv_result_t error = advanceLine(text, position)) return error; continue; case ' ': case '\t': case '\r': position->column++; position->index++; continue; case '\n': position->column = 0; position->line++; position->index++; continue; default: return SPV_SUCCESS; } } } // Fetches the next word from the given text stream starting from the given // *position. On success, writes the decoded word into *word and updates // *position to the location past the returned word. // // A word ends at the next comment or whitespace. However, double-quoted // strings remain intact, and a backslash always escapes the next character. spv_result_t getWord(spv_text text, spv_position position, std::string* word) { if (!text->str || !text->length) return SPV_ERROR_INVALID_TEXT; if (!position) return SPV_ERROR_INVALID_POINTER; const size_t start_index = position->index; bool quoting = false; bool escaping = false; // NOTE: Assumes first character is not white space! while (true) { if (position->index >= text->length) { word->assign(text->str + start_index, text->str + position->index); return SPV_SUCCESS; } const char ch = text->str[position->index]; if (ch == '\\') { escaping = !escaping; } else { switch (ch) { case '"': if (!escaping) quoting = !quoting; break; case ' ': case ';': case '\t': case '\n': case '\r': if (escaping || quoting) break; word->assign(text->str + start_index, text->str + position->index); return SPV_SUCCESS; case '\0': { // NOTE: End of word found! word->assign(text->str + start_index, text->str + position->index); return SPV_SUCCESS; } default: break; } escaping = false; } position->column++; position->index++; } } // Returns true if the characters in the text as position represent // the start of an Opcode. bool startsWithOp(spv_text text, spv_position position) { if (text->length < position->index + 3) return false; char ch0 = text->str[position->index]; char ch1 = text->str[position->index + 1]; char ch2 = text->str[position->index + 2]; return ('O' == ch0 && 'p' == ch1 && ('A' <= ch2 && ch2 <= 'Z')); } } // namespace const IdType kUnknownType = {0, false, IdTypeClass::kBottom}; // TODO(dneto): Reorder AssemblyContext definitions to match declaration order. // This represents all of the data that is only valid for the duration of // a single compilation. uint32_t AssemblyContext::spvNamedIdAssignOrGet(const char* textValue) { if (!ids_to_preserve_.empty()) { uint32_t id = 0; if (spvtools::utils::ParseNumber(textValue, &id)) { if (ids_to_preserve_.find(id) != ids_to_preserve_.end()) { bound_ = std::max(bound_, id + 1); return id; } } } const auto it = named_ids_.find(textValue); if (it == named_ids_.end()) { uint32_t id = next_id_++; if (!ids_to_preserve_.empty()) { while (ids_to_preserve_.find(id) != ids_to_preserve_.end()) { id = next_id_++; } } named_ids_.emplace(textValue, id); bound_ = std::max(bound_, id + 1); return id; } return it->second; } uint32_t AssemblyContext::getBound() const { return bound_; } spv_result_t AssemblyContext::advance() { return spvtools::advance(text_, ¤t_position_); } spv_result_t AssemblyContext::getWord(std::string* word, spv_position next_position) { *next_position = current_position_; return spvtools::getWord(text_, next_position, word); } bool AssemblyContext::startsWithOp() { return spvtools::startsWithOp(text_, ¤t_position_); } bool AssemblyContext::isStartOfNewInst() { spv_position_t pos = current_position_; if (spvtools::advance(text_, &pos)) return false; if (spvtools::startsWithOp(text_, &pos)) return true; std::string word; pos = current_position_; if (spvtools::getWord(text_, &pos, &word)) return false; if ('%' != word.front()) return false; if (spvtools::advance(text_, &pos)) return false; if (spvtools::getWord(text_, &pos, &word)) return false; if ("=" != word) return false; if (spvtools::advance(text_, &pos)) return false; if (spvtools::startsWithOp(text_, &pos)) return true; return false; } char AssemblyContext::peek() const { return text_->str[current_position_.index]; } bool AssemblyContext::hasText() const { return text_->length > current_position_.index; } void AssemblyContext::seekForward(uint32_t size) { current_position_.index += size; current_position_.column += size; } spv_result_t AssemblyContext::binaryEncodeU32(const uint32_t value, spv_instruction_t* pInst) { pInst->words.insert(pInst->words.end(), value); return SPV_SUCCESS; } spv_result_t AssemblyContext::binaryEncodeNumericLiteral( const char* val, spv_result_t error_code, const IdType& type, spv_instruction_t* pInst) { using spvtools::utils::EncodeNumberStatus; // Populate the NumberType from the IdType for parsing. spvtools::utils::NumberType number_type; switch (type.type_class) { case IdTypeClass::kOtherType: return diagnostic(SPV_ERROR_INTERNAL) << "Unexpected numeric literal type"; case IdTypeClass::kScalarIntegerType: if (type.isSigned) { number_type = {type.bitwidth, SPV_NUMBER_SIGNED_INT}; } else { number_type = {type.bitwidth, SPV_NUMBER_UNSIGNED_INT}; } break; case IdTypeClass::kScalarFloatType: number_type = {type.bitwidth, SPV_NUMBER_FLOATING}; break; case IdTypeClass::kBottom: // kBottom means the type is unknown and we need to infer the type before // parsing the number. The rule is: If there is a decimal point, treat // the value as a floating point value, otherwise a integer value, then // if the first char of the integer text is '-', treat the integer as a // signed integer, otherwise an unsigned integer. uint32_t bitwidth = static_cast(assumedBitWidth(type)); if (strchr(val, '.')) { number_type = {bitwidth, SPV_NUMBER_FLOATING}; } else if (type.isSigned || val[0] == '-') { number_type = {bitwidth, SPV_NUMBER_SIGNED_INT}; } else { number_type = {bitwidth, SPV_NUMBER_UNSIGNED_INT}; } break; } std::string error_msg; EncodeNumberStatus parse_status = ParseAndEncodeNumber( val, number_type, [this, pInst](uint32_t d) { this->binaryEncodeU32(d, pInst); }, &error_msg); switch (parse_status) { case EncodeNumberStatus::kSuccess: return SPV_SUCCESS; case EncodeNumberStatus::kInvalidText: return diagnostic(error_code) << error_msg; case EncodeNumberStatus::kUnsupported: return diagnostic(SPV_ERROR_INTERNAL) << error_msg; case EncodeNumberStatus::kInvalidUsage: return diagnostic(SPV_ERROR_INVALID_TEXT) << error_msg; } // This line is not reachable, only added to satisfy the compiler. return diagnostic(SPV_ERROR_INTERNAL) << "Unexpected result code from ParseAndEncodeNumber()"; } spv_result_t AssemblyContext::binaryEncodeString(const char* value, spv_instruction_t* pInst) { const size_t length = strlen(value); const size_t wordCount = (length / 4) + 1; const size_t oldWordCount = pInst->words.size(); const size_t newWordCount = oldWordCount + wordCount; // TODO(dneto): We can just defer this check until later. if (newWordCount > SPV_LIMIT_INSTRUCTION_WORD_COUNT_MAX) { return diagnostic() << "Instruction too long: more than " << SPV_LIMIT_INSTRUCTION_WORD_COUNT_MAX << " words."; } pInst->words.reserve(newWordCount); spvtools::utils::AppendToVector(value, &pInst->words); return SPV_SUCCESS; } spv_result_t AssemblyContext::recordTypeDefinition( const spv_instruction_t* pInst) { uint32_t value = pInst->words[1]; if (types_.find(value) != types_.end()) { return diagnostic() << "Value " << value << " has already been used to generate a type"; } if (pInst->opcode == spv::Op::OpTypeInt) { if (pInst->words.size() != 4) return diagnostic() << "Invalid OpTypeInt instruction"; types_[value] = {pInst->words[2], pInst->words[3] != 0, IdTypeClass::kScalarIntegerType}; } else if (pInst->opcode == spv::Op::OpTypeFloat) { if ((pInst->words.size() != 3) && (pInst->words.size() != 4)) return diagnostic() << "Invalid OpTypeFloat instruction"; // TODO(kpet) Do we need to record the FP Encoding here? types_[value] = {pInst->words[2], false, IdTypeClass::kScalarFloatType}; } else { types_[value] = {0, false, IdTypeClass::kOtherType}; } return SPV_SUCCESS; } IdType AssemblyContext::getTypeOfTypeGeneratingValue(uint32_t value) const { auto type = types_.find(value); if (type == types_.end()) { return kUnknownType; } return std::get<1>(*type); } IdType AssemblyContext::getTypeOfValueInstruction(uint32_t value) const { auto type_value = value_types_.find(value); if (type_value == value_types_.end()) { return {0, false, IdTypeClass::kBottom}; } return getTypeOfTypeGeneratingValue(std::get<1>(*type_value)); } spv_result_t AssemblyContext::recordTypeIdForValue(uint32_t value, uint32_t type) { bool successfully_inserted = false; std::tie(std::ignore, successfully_inserted) = value_types_.insert(std::make_pair(value, type)); if (!successfully_inserted) return diagnostic() << "Value is being defined a second time"; return SPV_SUCCESS; } spv_result_t AssemblyContext::recordIdAsExtInstImport( uint32_t id, spv_ext_inst_type_t type) { bool successfully_inserted = false; std::tie(std::ignore, successfully_inserted) = import_id_to_ext_inst_type_.insert(std::make_pair(id, type)); if (!successfully_inserted) return diagnostic() << "Import Id is being defined a second time"; return SPV_SUCCESS; } spv_ext_inst_type_t AssemblyContext::getExtInstTypeForId(uint32_t id) const { auto type = import_id_to_ext_inst_type_.find(id); if (type == import_id_to_ext_inst_type_.end()) { return SPV_EXT_INST_TYPE_NONE; } return std::get<1>(*type); } std::set AssemblyContext::GetNumericIds() const { std::set ids; for (const auto& kv : named_ids_) { uint32_t id; if (spvtools::utils::ParseNumber(kv.first.c_str(), &id)) ids.insert(id); } return ids; } } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/text_handler.h000066400000000000000000000226671475742701700227000ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_TEXT_HANDLER_H_ #define SOURCE_TEXT_HANDLER_H_ #include #include #include #include #include #include #include #include "source/diagnostic.h" #include "source/instruction.h" #include "source/text.h" #include "spirv-tools/libspirv.h" namespace spvtools { // Structures // This is a lattice for tracking types. enum class IdTypeClass { kBottom = 0, // We have no information yet. kScalarIntegerType, kScalarFloatType, kOtherType }; // Contains ID type information that needs to be tracked across all Ids. // Bitwidth is only valid when type_class is kScalarIntegerType or // kScalarFloatType. struct IdType { uint32_t bitwidth; // Safe to assume that we will not have > 2^32 bits. bool isSigned; // This is only significant if type_class is integral. IdTypeClass type_class; }; // Default equality operator for IdType. Tests if all members are the same. inline bool operator==(const IdType& first, const IdType& second) { return (first.bitwidth == second.bitwidth) && (first.isSigned == second.isSigned) && (first.type_class == second.type_class); } // Tests whether any member of the IdTypes do not match. inline bool operator!=(const IdType& first, const IdType& second) { return !(first == second); } // A value representing an unknown type. extern const IdType kUnknownType; // Returns true if the type is a scalar integer type. inline bool isScalarIntegral(const IdType& type) { return type.type_class == IdTypeClass::kScalarIntegerType; } // Returns true if the type is a scalar floating point type. inline bool isScalarFloating(const IdType& type) { return type.type_class == IdTypeClass::kScalarFloatType; } // Returns the number of bits in the type. // This is only valid for bottom, scalar integer, and scalar floating // classes. For bottom, assume 32 bits. inline int assumedBitWidth(const IdType& type) { switch (type.type_class) { case IdTypeClass::kBottom: return 32; case IdTypeClass::kScalarIntegerType: case IdTypeClass::kScalarFloatType: return type.bitwidth; default: break; } // We don't care about this case. return 0; } // A templated class with a static member function Clamp, where Clamp // sets a referenced value of type T to 0 if T is an unsigned // integer type, and returns true if it modified the referenced // value. template class ClampToZeroIfUnsignedType { public: // The default specialization does not clamp the value. static bool Clamp(T*) { return false; } }; // The specialization of ClampToZeroIfUnsignedType for unsigned integer // types. template class ClampToZeroIfUnsignedType< T, typename std::enable_if::value>::type> { public: static bool Clamp(T* value_pointer) { if (*value_pointer) { *value_pointer = 0; return true; } return false; } }; // Encapsulates the data used during the assembly of a SPIR-V module. class AssemblyContext { public: AssemblyContext(spv_text text, const MessageConsumer& consumer, std::set&& ids_to_preserve = std::set()) : current_position_({}), consumer_(consumer), text_(text), bound_(1), next_id_(1), ids_to_preserve_(std::move(ids_to_preserve)) {} // Assigns a new integer value to the given text ID, or returns the previously // assigned integer value if the ID has been seen before. uint32_t spvNamedIdAssignOrGet(const char* textValue); // Returns the largest largest numeric ID that has been assigned. uint32_t getBound() const; // Advances position to point to the next word in the input stream. // Returns SPV_SUCCESS on success. spv_result_t advance(); // Sets word to the next word in the input text. Fills next_position with // the next location past the end of the word. spv_result_t getWord(std::string* word, spv_position next_position); // Returns true if the next word in the input is the start of a new Opcode. bool startsWithOp(); // Returns true if the next word in the input is the start of a new // instruction. bool isStartOfNewInst(); // Returns a diagnostic object initialized with current position in the input // stream, and for the given error code. Any data written to this object will // show up in pDiagnsotic on destruction. DiagnosticStream diagnostic(spv_result_t error) { return DiagnosticStream(current_position_, consumer_, "", error); } // Returns a diagnostic object with the default assembly error code. DiagnosticStream diagnostic() { // The default failure for assembly is invalid text. return diagnostic(SPV_ERROR_INVALID_TEXT); } // Returns then next character in the input stream. char peek() const; // Returns true if there is more text in the input stream. bool hasText() const; // Seeks the input stream forward by 'size' characters. void seekForward(uint32_t size); // Sets the current position in the input stream to the given position. void setPosition(const spv_position_t& newPosition) { current_position_ = newPosition; } // Returns the current position in the input stream. const spv_position_t& position() const { return current_position_; } // Appends the given 32-bit value to the given instruction. // Returns SPV_SUCCESS if the value could be correctly inserted in the // instruction. spv_result_t binaryEncodeU32(const uint32_t value, spv_instruction_t* pInst); // Appends the given string to the given instruction. // Returns SPV_SUCCESS if the value could be correctly inserted in the // instruction. spv_result_t binaryEncodeString(const char* value, spv_instruction_t* pInst); // Appends the given numeric literal to the given instruction. // Validates and respects the bitwidth supplied in the IdType argument. // If the type is of class kBottom the value will be encoded as a // 32-bit integer. // Returns SPV_SUCCESS if the value could be correctly added to the // instruction. Returns the given error code on failure, and emits // a diagnostic if that error code is not SPV_FAILED_MATCH. spv_result_t binaryEncodeNumericLiteral(const char* numeric_literal, spv_result_t error_code, const IdType& type, spv_instruction_t* pInst); // Returns the IdType associated with this type-generating value. // If the type has not been previously recorded with recordTypeDefinition, // kUnknownType will be returned. IdType getTypeOfTypeGeneratingValue(uint32_t value) const; // Returns the IdType that represents the return value of this Value // generating instruction. // If the value has not been recorded with recordTypeIdForValue, or the type // could not be determined kUnknownType will be returned. IdType getTypeOfValueInstruction(uint32_t value) const; // Tracks the type-defining instruction. The result of the tracking can // later be queried using getValueType. // pInst is expected to be completely filled in by the time this instruction // is called. // Returns SPV_SUCCESS on success, or SPV_ERROR_INVALID_VALUE on error. spv_result_t recordTypeDefinition(const spv_instruction_t* pInst); // Tracks the relationship between the value and its type. spv_result_t recordTypeIdForValue(uint32_t value, uint32_t type); // Records the given Id as being the import of the given extended instruction // type. spv_result_t recordIdAsExtInstImport(uint32_t id, spv_ext_inst_type_t type); // Returns the extended instruction type corresponding to the import with // the given Id, if it exists. Returns SPV_EXT_INST_TYPE_NONE if the // id is not the id for an extended instruction type. spv_ext_inst_type_t getExtInstTypeForId(uint32_t id) const; // Returns a set consisting of each ID generated by spvNamedIdAssignOrGet from // a numeric ID text representation. For example, generated from "%12" but not // from "%foo". std::set GetNumericIds() const; private: // Maps ID names to their corresponding numerical ids. using spv_named_id_table = std::unordered_map; // Maps type-defining IDs to their IdType. using spv_id_to_type_map = std::unordered_map; // Maps Ids to the id of their type. using spv_id_to_type_id = std::unordered_map; spv_named_id_table named_ids_; spv_id_to_type_map types_; spv_id_to_type_id value_types_; // Maps an extended instruction import Id to the extended instruction type. std::unordered_map import_id_to_ext_inst_type_; spv_position_t current_position_; MessageConsumer consumer_; spv_text text_; uint32_t bound_; uint32_t next_id_; std::set ids_to_preserve_; }; } // namespace spvtools #endif // SOURCE_TEXT_HANDLER_H_ KhronosGroup-SPIRV-Tools-f289d04/source/to_string.cpp000066400000000000000000000026101475742701700225440ustar00rootroot00000000000000// Copyright (c) 2024 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/to_string.h" #include namespace spvtools { std::string to_string(uint32_t n) { // This implementation avoids using standard library features that access // the locale. Using the locale requires taking a mutex which causes // annoying serialization. constexpr int max_digits = 10; // max uint has 10 digits // Contains the resulting digits, with least significant digit in the last // entry. char buf[max_digits]; int write_index = max_digits - 1; if (n == 0) { buf[write_index] = '0'; } else { while (n > 0) { int units = n % 10; buf[write_index--] = "0123456789"[units]; n = (n - units) / 10; } write_index++; } assert(write_index >= 0); return std::string(buf + write_index, max_digits - write_index); } } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/to_string.h000066400000000000000000000015761475742701700222230ustar00rootroot00000000000000// Copyright (c) 2024 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_TO_STRING_H_ #define SOURCE_TO_STRING_H_ #include #include namespace spvtools { // Returns the decimal representation of a number as a string, // without using the locale. std::string to_string(uint32_t n); } // namespace spvtools #endif // SOURCE_TO_STRING_H_ KhronosGroup-SPIRV-Tools-f289d04/source/util/000077500000000000000000000000001475742701700210065ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/util/bit_vector.cpp000066400000000000000000000040421475742701700236520ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/util/bit_vector.h" #include #include namespace spvtools { namespace utils { void BitVector::ReportDensity(std::ostream& out) { uint32_t count = 0; for (BitContainer e : bits_) { while (e != 0) { if ((e & 1) != 0) { ++count; } e = e >> 1; } } out << "count=" << count << ", total size (bytes)=" << bits_.size() * sizeof(BitContainer) << ", bytes per element=" << (double)(bits_.size() * sizeof(BitContainer)) / (double)(count); } bool BitVector::Or(const BitVector& other) { auto this_it = this->bits_.begin(); auto other_it = other.bits_.begin(); bool modified = false; while (this_it != this->bits_.end() && other_it != other.bits_.end()) { auto temp = *this_it | *other_it; if (temp != *this_it) { modified = true; *this_it = temp; } ++this_it; ++other_it; } if (other_it != other.bits_.end()) { modified = true; this->bits_.insert(this->bits_.end(), other_it, other.bits_.end()); } return modified; } std::ostream& operator<<(std::ostream& out, const BitVector& bv) { out << "{"; for (uint32_t i = 0; i < bv.bits_.size(); ++i) { BitVector::BitContainer b = bv.bits_[i]; uint32_t j = 0; while (b != 0) { if (b & 1) { out << ' ' << i * BitVector::kBitContainerSize + j; } ++j; b = b >> 1; } } out << "}"; return out; } } // namespace utils } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/util/bit_vector.h000066400000000000000000000064031475742701700233220ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_UTIL_BIT_VECTOR_H_ #define SOURCE_UTIL_BIT_VECTOR_H_ #include #include #include namespace spvtools { namespace utils { // Implements a bit vector class. // // All bits default to zero, and the upper bound is 2^32-1. class BitVector { private: using BitContainer = uint64_t; enum { kBitContainerSize = 64 }; enum { kInitialNumBits = 1024 }; public: // Creates a bit vector containing 0s. BitVector(uint32_t reserved_size = kInitialNumBits) : bits_((reserved_size - 1) / kBitContainerSize + 1, 0) {} // Sets the |i|th bit to 1. Returns the |i|th bit before it was set. bool Set(uint32_t i) { uint32_t element_index = i / kBitContainerSize; uint32_t bit_in_element = i % kBitContainerSize; if (element_index >= bits_.size()) { bits_.resize(element_index + 1, 0); } BitContainer original = bits_[element_index]; BitContainer ith_bit = static_cast(1) << bit_in_element; if ((original & ith_bit) != 0) { return true; } else { bits_[element_index] = original | ith_bit; return false; } } // Sets the |i|th bit to 0. Return the |i|th bit before it was cleared. bool Clear(uint32_t i) { uint32_t element_index = i / kBitContainerSize; uint32_t bit_in_element = i % kBitContainerSize; if (element_index >= bits_.size()) { return false; } BitContainer original = bits_[element_index]; BitContainer ith_bit = static_cast(1) << bit_in_element; if ((original & ith_bit) == 0) { return false; } else { bits_[element_index] = original & (~ith_bit); return true; } } // Returns the |i|th bit. bool Get(uint32_t i) const { uint32_t element_index = i / kBitContainerSize; uint32_t bit_in_element = i % kBitContainerSize; if (element_index >= bits_.size()) { return false; } return (bits_[element_index] & (static_cast(1) << bit_in_element)) != 0; } // Returns true if every bit is 0. bool Empty() const { for (BitContainer b : bits_) { if (b != 0) { return false; } } return true; } // Print a report on the densicy of the bit vector, number of 1 bits, number // of bytes, and average bytes for 1 bit, to |out|. void ReportDensity(std::ostream& out); friend std::ostream& operator<<(std::ostream&, const BitVector&); // Performs a bitwise-or operation on |this| and |that|, storing the result in // |this|. Return true if |this| changed. bool Or(const BitVector& that); private: std::vector bits_; }; } // namespace utils } // namespace spvtools #endif // SOURCE_UTIL_BIT_VECTOR_H_ KhronosGroup-SPIRV-Tools-f289d04/source/util/bitutils.h000066400000000000000000000201331475742701700230150ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_UTIL_BITUTILS_H_ #define SOURCE_UTIL_BITUTILS_H_ #include #include #include #include namespace spvtools { namespace utils { // Performs a bitwise copy of source to the destination type Dest. template Dest BitwiseCast(Src source) { Dest dest; static_assert(sizeof(source) == sizeof(dest), "BitwiseCast: Source and destination must have the same size"); std::memcpy(&dest, &source, sizeof(dest)); return dest; } // Calculates the bit width of the integer type |T|. template struct IntegerBitWidth { static_assert(std::is_integral::value, "Integer type required"); static const size_t kBitsPerByte = 8; static const size_t get = sizeof(T) * kBitsPerByte; }; // SetBits returns an integer of type with bits set // for position through , counting from the least // significant bit. In particular when Num == 0, no positions are set to 1. // A static assert will be triggered if First + Num > sizeof(T) * 8, that is, // a bit that will not fit in the underlying type is set. template struct SetBits { static_assert(First < IntegerBitWidth::get, "Tried to set a bit that is shifted too far."); const static T get = (T(1) << First) | SetBits::get; }; template struct SetBits { const static T get = T(0); }; // This is all compile-time so we can put our tests right here. static_assert(IntegerBitWidth::get == 32, "IntegerBitWidth mismatch"); static_assert(IntegerBitWidth::get == 32, "IntegerBitWidth mismatch"); static_assert(IntegerBitWidth::get == 64, "IntegerBitWidth mismatch"); static_assert(IntegerBitWidth::get == 8, "IntegerBitWidth mismatch"); static_assert(SetBits::get == uint32_t(0x00000000), "SetBits failed"); static_assert(SetBits::get == uint32_t(0x00000001), "SetBits failed"); static_assert(SetBits::get == uint32_t(0x80000000), "SetBits failed"); static_assert(SetBits::get == uint32_t(0x00000006), "SetBits failed"); static_assert(SetBits::get == uint32_t(0xc0000000), "SetBits failed"); static_assert(SetBits::get == uint32_t(0x7FFFFFFF), "SetBits failed"); static_assert(SetBits::get == uint32_t(0xFFFFFFFF), "SetBits failed"); static_assert(SetBits::get == uint32_t(0xFFFF0000), "SetBits failed"); static_assert(SetBits::get == uint64_t(0x0000000000000001LL), "SetBits failed"); static_assert(SetBits::get == uint64_t(0x8000000000000000LL), "SetBits failed"); static_assert(SetBits::get == uint64_t(0xc000000000000000LL), "SetBits failed"); static_assert(SetBits::get == uint64_t(0x0000000080000000LL), "SetBits failed"); static_assert(SetBits::get == uint64_t(0x00000000FFFF0000LL), "SetBits failed"); // Returns number of '1' bits in a word. template size_t CountSetBits(T word) { static_assert(std::is_integral::value, "CountSetBits requires integer type"); uint32_t count = 0; while (word) { word &= word - 1; ++count; } return count; } // Checks if the bit at the |position| is set to '1'. // Bits zero-indexed starting at the least significant bit. // |position| must be within the bit width of |T|. template bool IsBitAtPositionSet(T word, size_t position) { static_assert(std::is_integral::value, "Integer type required"); static_assert(std::is_unsigned::value, "Unsigned type required"); assert(position < IntegerBitWidth::get && "position must be less than the bit width"); return word & T(T(1) << position); } // Returns a value obtained by setting a range of adjacent bits of |word| to // |value|. Affected bits are within the range: // [first_position, first_position + num_bits_to_mutate), // assuming zero-based indexing starting at the least // significant bit. Bits to mutate must be within the bit width of |T|. template T MutateBits(T word, size_t first_position, size_t num_bits_to_mutate, bool value) { static_assert(std::is_integral::value, "Integer type required"); static_assert(std::is_unsigned::value, "Unsigned type required"); static const size_t word_bit_width = IntegerBitWidth::get; assert(first_position < word_bit_width && "Mutated bits must be within bit width"); assert(first_position + num_bits_to_mutate <= word_bit_width && "Mutated bits must be within bit width"); if (num_bits_to_mutate == 0) { return word; } const T all_ones = ~T(0); const size_t num_unaffected_low_bits = first_position; const T unaffected_low_mask = T(T(all_ones >> num_unaffected_low_bits) << num_unaffected_low_bits); const size_t num_unaffected_high_bits = word_bit_width - (first_position + num_bits_to_mutate); const T unaffected_high_mask = T(T(all_ones << num_unaffected_high_bits) >> num_unaffected_high_bits); const T mutation_mask = unaffected_low_mask & unaffected_high_mask; if (value) { return word | mutation_mask; } return word & T(~mutation_mask); } // Returns a value obtained by setting the |num_bits_to_set| highest bits to // '1'. |num_bits_to_set| must be not be greater than the bit width of |T|. template T SetHighBits(T word, size_t num_bits_to_set) { if (num_bits_to_set == 0) { return word; } const size_t word_bit_width = IntegerBitWidth::get; assert(num_bits_to_set <= word_bit_width && "Can't set more bits than bit width"); return MutateBits(word, word_bit_width - num_bits_to_set, num_bits_to_set, true); } // Returns a value obtained by setting the |num_bits_to_set| highest bits to // '0'. |num_bits_to_set| must be not be greater than the bit width of |T|. template T ClearHighBits(T word, size_t num_bits_to_set) { if (num_bits_to_set == 0) { return word; } const size_t word_bit_width = IntegerBitWidth::get; assert(num_bits_to_set <= word_bit_width && "Can't clear more bits than bit width"); return MutateBits(word, word_bit_width - num_bits_to_set, num_bits_to_set, false); } // Returns the value obtained by extracting the |number_of_bits| least // significant bits from |value|, and sign-extending it to 64-bits. template T SignExtendValue(T value, uint32_t number_of_bits) { const uint32_t bit_width = sizeof(value) * 8; if (number_of_bits == bit_width) return value; bool is_negative = utils::IsBitAtPositionSet(value, number_of_bits - 1); if (is_negative) { value = utils::SetHighBits(value, bit_width - number_of_bits); } else { value = utils::ClearHighBits(value, bit_width - number_of_bits); } return value; } // Returns the value obtained by extracting the |number_of_bits| least // significant bits from |value|, and zero-extending it to 64-bits. template T ZeroExtendValue(T value, uint32_t number_of_bits) { const uint32_t bit_width = sizeof(value) * 8; if (number_of_bits == bit_width) return value; return utils::ClearHighBits(value, bit_width - number_of_bits); } } // namespace utils } // namespace spvtools #endif // SOURCE_UTIL_BITUTILS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/util/hash_combine.h000066400000000000000000000031301475742701700235730ustar00rootroot00000000000000// Copyright (c) 2022 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_UTIL_HASH_COMBINE_H_ #define SOURCE_UTIL_HASH_COMBINE_H_ #include #include #include namespace spvtools { namespace utils { // Helpers for incrementally computing hashes. // For reference, see // http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3876.pdf template inline size_t hash_combine(std::size_t seed, const T& val) { return seed ^ (std::hash()(val) + 0x9e3779b9 + (seed << 6) + (seed >> 2)); } template inline size_t hash_combine(std::size_t hash, const std::vector& vals) { for (const T& val : vals) { hash = hash_combine(hash, val); } return hash; } inline size_t hash_combine(std::size_t hash) { return hash; } template inline size_t hash_combine(std::size_t hash, const T& val, const Types&... args) { return hash_combine(hash_combine(hash, val), args...); } } // namespace utils } // namespace spvtools #endif // SOURCE_UTIL_HASH_COMBINE_H_ KhronosGroup-SPIRV-Tools-f289d04/source/util/hex_float.h000066400000000000000000001331771475742701700231440ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_UTIL_HEX_FLOAT_H_ #define SOURCE_UTIL_HEX_FLOAT_H_ #include #include #include #include #include #include #include #include #include "source/util/bitutils.h" #ifndef __GNUC__ #define GCC_VERSION 0 #else #define GCC_VERSION \ (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) #endif namespace spvtools { namespace utils { class Float16 { public: Float16(uint16_t v) : val(v) {} Float16() = default; static bool isNan(const Float16& val) { return ((val.val & 0x7C00) == 0x7C00) && ((val.val & 0x3FF) != 0); } // Returns true if the given value is any kind of infinity. static bool isInfinity(const Float16& val) { return ((val.val & 0x7C00) == 0x7C00) && ((val.val & 0x3FF) == 0); } Float16(const Float16& other) { val = other.val; } uint16_t get_value() const { return val; } // Returns the maximum normal value. static Float16 max() { return Float16(0x7bff); } // Returns the lowest normal value. static Float16 lowest() { return Float16(0xfbff); } private: uint16_t val; }; // To specialize this type, you must override uint_type to define // an unsigned integer that can fit your floating point type. // You must also add a isNan function that returns true if // a value is Nan. template struct FloatProxyTraits { using uint_type = void; }; template <> struct FloatProxyTraits { using uint_type = uint32_t; static bool isNan(float f) { return std::isnan(f); } // Returns true if the given value is any kind of infinity. static bool isInfinity(float f) { return std::isinf(f); } // Returns the maximum normal value. static float max() { return std::numeric_limits::max(); } // Returns the lowest normal value. static float lowest() { return std::numeric_limits::lowest(); } // Returns the value as the native floating point format. static float getAsFloat(const uint_type& t) { return BitwiseCast(t); } // Returns the bits from the given floating pointer number. static uint_type getBitsFromFloat(const float& t) { return BitwiseCast(t); } // Returns the bitwidth. static uint32_t width() { return 32u; } }; template <> struct FloatProxyTraits { using uint_type = uint64_t; static bool isNan(double f) { return std::isnan(f); } // Returns true if the given value is any kind of infinity. static bool isInfinity(double f) { return std::isinf(f); } // Returns the maximum normal value. static double max() { return std::numeric_limits::max(); } // Returns the lowest normal value. static double lowest() { return std::numeric_limits::lowest(); } // Returns the value as the native floating point format. static double getAsFloat(const uint_type& t) { return BitwiseCast(t); } // Returns the bits from the given floating pointer number. static uint_type getBitsFromFloat(const double& t) { return BitwiseCast(t); } // Returns the bitwidth. static uint32_t width() { return 64u; } }; template <> struct FloatProxyTraits { using uint_type = uint16_t; static bool isNan(Float16 f) { return Float16::isNan(f); } // Returns true if the given value is any kind of infinity. static bool isInfinity(Float16 f) { return Float16::isInfinity(f); } // Returns the maximum normal value. static Float16 max() { return Float16::max(); } // Returns the lowest normal value. static Float16 lowest() { return Float16::lowest(); } // Returns the value as the native floating point format. static Float16 getAsFloat(const uint_type& t) { return Float16(t); } // Returns the bits from the given floating pointer number. static uint_type getBitsFromFloat(const Float16& t) { return t.get_value(); } // Returns the bitwidth. static uint32_t width() { return 16u; } }; // Since copying a floating point number (especially if it is NaN) // does not guarantee that bits are preserved, this class lets us // store the type and use it as a float when necessary. template class FloatProxy { public: using uint_type = typename FloatProxyTraits::uint_type; // Since this is to act similar to the normal floats, // do not initialize the data by default. FloatProxy() = default; // Intentionally non-explicit. This is a proxy type so // implicit conversions allow us to use it more transparently. FloatProxy(T val) { data_ = FloatProxyTraits::getBitsFromFloat(val); } // Intentionally non-explicit. This is a proxy type so // implicit conversions allow us to use it more transparently. FloatProxy(uint_type val) { data_ = val; } // This is helpful to have and is guaranteed not to stomp bits. FloatProxy operator-() const { return static_cast(data_ ^ (uint_type(0x1) << (sizeof(T) * 8 - 1))); } // Returns the data as a floating point value. T getAsFloat() const { return FloatProxyTraits::getAsFloat(data_); } // Returns the raw data. uint_type data() const { return data_; } // Returns a vector of words suitable for use in an Operand. std::vector GetWords() const { std::vector words; if (FloatProxyTraits::width() == 64) { FloatProxyTraits::uint_type d = data(); words.push_back(static_cast(d)); words.push_back(static_cast(d >> 32)); } else { words.push_back(static_cast(data())); } return words; } // Returns true if the value represents any type of NaN. bool isNan() { return FloatProxyTraits::isNan(getAsFloat()); } // Returns true if the value represents any type of infinity. bool isInfinity() { return FloatProxyTraits::isInfinity(getAsFloat()); } // Returns the maximum normal value. static FloatProxy max() { return FloatProxy(FloatProxyTraits::max()); } // Returns the lowest normal value. static FloatProxy lowest() { return FloatProxy(FloatProxyTraits::lowest()); } private: uint_type data_; }; template bool operator==(const FloatProxy& first, const FloatProxy& second) { return first.data() == second.data(); } // Reads a FloatProxy value as a normal float from a stream. template std::istream& operator>>(std::istream& is, FloatProxy& value) { T float_val = static_cast(0.0); is >> float_val; value = FloatProxy(float_val); return is; } // This is an example traits. It is not meant to be used in practice, but will // be the default for any non-specialized type. template struct HexFloatTraits { // Integer type that can store the bit representation of this hex-float. using uint_type = void; // Signed integer type that can store the bit representation of this // hex-float. using int_type = void; // The numerical type that this HexFloat represents. using underlying_type = void; // The type needed to construct the underlying type. using native_type = void; // The number of bits that are actually relevant in the uint_type. // This allows us to deal with, for example, 24-bit values in a 32-bit // integer. static const uint32_t num_used_bits = 0; // Number of bits that represent the exponent. static const uint32_t num_exponent_bits = 0; // Number of bits that represent the fractional part. static const uint32_t num_fraction_bits = 0; // The bias of the exponent. (How much we need to subtract from the stored // value to get the correct value.) static const uint32_t exponent_bias = 0; }; // Traits for IEEE float. // 1 sign bit, 8 exponent bits, 23 fractional bits. template <> struct HexFloatTraits> { using uint_type = uint32_t; using int_type = int32_t; using underlying_type = FloatProxy; using native_type = float; static const uint_type num_used_bits = 32; static const uint_type num_exponent_bits = 8; static const uint_type num_fraction_bits = 23; static const uint_type exponent_bias = 127; }; // Traits for IEEE double. // 1 sign bit, 11 exponent bits, 52 fractional bits. template <> struct HexFloatTraits> { using uint_type = uint64_t; using int_type = int64_t; using underlying_type = FloatProxy; using native_type = double; static const uint_type num_used_bits = 64; static const uint_type num_exponent_bits = 11; static const uint_type num_fraction_bits = 52; static const uint_type exponent_bias = 1023; }; // Traits for IEEE half. // 1 sign bit, 5 exponent bits, 10 fractional bits. template <> struct HexFloatTraits> { using uint_type = uint16_t; using int_type = int16_t; using underlying_type = uint16_t; using native_type = uint16_t; static const uint_type num_used_bits = 16; static const uint_type num_exponent_bits = 5; static const uint_type num_fraction_bits = 10; static const uint_type exponent_bias = 15; }; enum class round_direction { kToZero, kToNearestEven, kToPositiveInfinity, kToNegativeInfinity, max = kToNegativeInfinity }; // Template class that houses a floating pointer number. // It exposes a number of constants based on the provided traits to // assist in interpreting the bits of the value. template > class HexFloat { public: using uint_type = typename Traits::uint_type; using int_type = typename Traits::int_type; using underlying_type = typename Traits::underlying_type; using native_type = typename Traits::native_type; explicit HexFloat(T f) : value_(f) {} T value() const { return value_; } void set_value(T f) { value_ = f; } // These are all written like this because it is convenient to have // compile-time constants for all of these values. // Pass-through values to save typing. static const uint32_t num_used_bits = Traits::num_used_bits; static const uint32_t exponent_bias = Traits::exponent_bias; static const uint32_t num_exponent_bits = Traits::num_exponent_bits; static const uint32_t num_fraction_bits = Traits::num_fraction_bits; // Number of bits to shift left to set the highest relevant bit. static const uint32_t top_bit_left_shift = num_used_bits - 1; // How many nibbles (hex characters) the fractional part takes up. static const uint32_t fraction_nibbles = (num_fraction_bits + 3) / 4; // If the fractional part does not fit evenly into a hex character (4-bits) // then we have to left-shift to get rid of leading 0s. This is the amount // we have to shift (might be 0). static const uint32_t num_overflow_bits = fraction_nibbles * 4 - num_fraction_bits; // The representation of the fraction, not the actual bits. This // includes the leading bit that is usually implicit. static const uint_type fraction_represent_mask = SetBits::get; // The topmost bit in the nibble-aligned fraction. static const uint_type fraction_top_bit = uint_type(1) << (num_fraction_bits + num_overflow_bits - 1); // The least significant bit in the exponent, which is also the bit // immediately to the left of the significand. static const uint_type first_exponent_bit = uint_type(1) << (num_fraction_bits); // The mask for the encoded fraction. It does not include the // implicit bit. static const uint_type fraction_encode_mask = SetBits::get; // The bit that is used as a sign. static const uint_type sign_mask = uint_type(1) << top_bit_left_shift; // The bits that represent the exponent. static const uint_type exponent_mask = SetBits::get; // How far left the exponent is shifted. static const uint32_t exponent_left_shift = num_fraction_bits; // How far from the right edge the fraction is shifted. static const uint32_t fraction_right_shift = static_cast(sizeof(uint_type) * 8) - num_fraction_bits; // The maximum representable unbiased exponent. static const int_type max_exponent = (exponent_mask >> num_fraction_bits) - exponent_bias; // The minimum representable exponent for normalized numbers. static const int_type min_exponent = -static_cast(exponent_bias); // Returns the bits associated with the value. uint_type getBits() const { return value_.data(); } // Returns the bits associated with the value, without the leading sign bit. uint_type getUnsignedBits() const { return static_cast(value_.data() & ~sign_mask); } // Returns the bits associated with the exponent, shifted to start at the // lsb of the type. const uint_type getExponentBits() const { return static_cast((getBits() & exponent_mask) >> num_fraction_bits); } // Returns the exponent in unbiased form. This is the exponent in the // human-friendly form. const int_type getUnbiasedExponent() const { return static_cast(getExponentBits() - exponent_bias); } // Returns just the significand bits from the value. const uint_type getSignificandBits() const { return getBits() & fraction_encode_mask; } // If the number was normalized, returns the unbiased exponent. // If the number was denormal, normalize the exponent first. const int_type getUnbiasedNormalizedExponent() const { if ((getBits() & ~sign_mask) == 0) { // special case if everything is 0 return 0; } int_type exp = getUnbiasedExponent(); if (exp == min_exponent) { // We are in denorm land. uint_type significand_bits = getSignificandBits(); while ((significand_bits & (first_exponent_bit >> 1)) == 0) { significand_bits = static_cast(significand_bits << 1); exp = static_cast(exp - 1); } significand_bits &= fraction_encode_mask; } return exp; } // Returns the signficand after it has been normalized. const uint_type getNormalizedSignificand() const { int_type unbiased_exponent = getUnbiasedNormalizedExponent(); uint_type significand = getSignificandBits(); for (int_type i = unbiased_exponent; i <= min_exponent; ++i) { significand = static_cast(significand << 1); } significand &= fraction_encode_mask; return significand; } // Returns true if this number represents a negative value. bool isNegative() const { return (getBits() & sign_mask) != 0; } // Sets this HexFloat from the individual components. // Note this assumes EVERY significand is normalized, and has an implicit // leading one. This means that the only way that this method will set 0, // is if you set a number so denormalized that it underflows. // Do not use this method with raw bits extracted from a subnormal number, // since subnormals do not have an implicit leading 1 in the significand. // The significand is also expected to be in the // lowest-most num_fraction_bits of the uint_type. // The exponent is expected to be unbiased, meaning an exponent of // 0 actually means 0. // If underflow_round_up is set, then on underflow, if a number is non-0 // and would underflow, we round up to the smallest denorm. void setFromSignUnbiasedExponentAndNormalizedSignificand( bool negative, int_type exponent, uint_type significand, bool round_denorm_up) { bool significand_is_zero = significand == 0; if (exponent <= min_exponent) { // If this was denormalized, then we have to shift the bit on, meaning // the significand is not zero. significand_is_zero = false; significand |= first_exponent_bit; significand = static_cast(significand >> 1); } while (exponent < min_exponent) { significand = static_cast(significand >> 1); ++exponent; } if (exponent == min_exponent) { if (significand == 0 && !significand_is_zero && round_denorm_up) { significand = static_cast(0x1); } } uint_type new_value = 0; if (negative) { new_value = static_cast(new_value | sign_mask); } exponent = static_cast(exponent + exponent_bias); assert(exponent >= 0); // put it all together exponent = static_cast((exponent << exponent_left_shift) & exponent_mask); significand = static_cast(significand & fraction_encode_mask); new_value = static_cast(new_value | (exponent | significand)); value_ = T(new_value); } // Increments the significand of this number by the given amount. // If this would spill the significand into the implicit bit, // carry is set to true and the significand is shifted to fit into // the correct location, otherwise carry is set to false. // All significands and to_increment are assumed to be within the bounds // for a valid significand. static uint_type incrementSignificand(uint_type significand, uint_type to_increment, bool* carry) { significand = static_cast(significand + to_increment); *carry = false; if (significand & first_exponent_bit) { *carry = true; // The implicit 1-bit will have carried, so we should zero-out the // top bit and shift back. significand = static_cast(significand & ~first_exponent_bit); significand = static_cast(significand >> 1); } return significand; } #if GCC_VERSION == 40801 // These exist because MSVC throws warnings on negative right-shifts // even if they are not going to be executed. Eg: // constant_number < 0? 0: constant_number // These convert the negative left-shifts into right shifts. template struct negatable_left_shift { static uint_type val(uint_type val) { if (N > 0) { return static_cast(val << N); } else { return static_cast(val >> N); } } }; template struct negatable_right_shift { static uint_type val(uint_type val) { if (N > 0) { return static_cast(val >> N); } else { return static_cast(val << N); } } }; #else // These exist because MSVC throws warnings on negative right-shifts // even if they are not going to be executed. Eg: // constant_number < 0? 0: constant_number // These convert the negative left-shifts into right shifts. template struct negatable_left_shift { static uint_type val(uint_type val) { return static_cast(val >> -N); } }; template struct negatable_left_shift= 0>::type> { static uint_type val(uint_type val) { return static_cast(val << N); } }; template struct negatable_right_shift { static uint_type val(uint_type val) { return static_cast(val << -N); } }; template struct negatable_right_shift= 0>::type> { static uint_type val(uint_type val) { return static_cast(val >> N); } }; #endif // Returns the significand, rounded to fit in a significand in // other_T. This is shifted so that the most significant // bit of the rounded number lines up with the most significant bit // of the returned significand. template typename other_T::uint_type getRoundedNormalizedSignificand( round_direction dir, bool* carry_bit) { using other_uint_type = typename other_T::uint_type; static const int_type num_throwaway_bits = static_cast(num_fraction_bits) - static_cast(other_T::num_fraction_bits); static const uint_type last_significant_bit = (num_throwaway_bits < 0) ? 0 : negatable_left_shift::val(1u); static const uint_type first_rounded_bit = (num_throwaway_bits < 1) ? 0 : negatable_left_shift::val(1u); static const uint_type throwaway_mask_bits = num_throwaway_bits > 0 ? num_throwaway_bits : 0; static const uint_type throwaway_mask = SetBits::get; *carry_bit = false; other_uint_type out_val = 0; uint_type significand = getNormalizedSignificand(); // If we are up-casting, then we just have to shift to the right location. if (num_throwaway_bits <= 0) { out_val = static_cast(significand); uint_type shift_amount = static_cast(-num_throwaway_bits); out_val = static_cast(out_val << shift_amount); return out_val; } // If every non-representable bit is 0, then we don't have any casting to // do. if ((significand & throwaway_mask) == 0) { return static_cast( negatable_right_shift::val(significand)); } bool round_away_from_zero = false; // We actually have to narrow the significand here, so we have to follow the // rounding rules. switch (dir) { case round_direction::kToZero: break; case round_direction::kToPositiveInfinity: round_away_from_zero = !isNegative(); break; case round_direction::kToNegativeInfinity: round_away_from_zero = isNegative(); break; case round_direction::kToNearestEven: // Have to round down, round bit is 0 if ((first_rounded_bit & significand) == 0) { break; } if (((significand & throwaway_mask) & ~first_rounded_bit) != 0) { // If any subsequent bit of the rounded portion is non-0 then we round // up. round_away_from_zero = true; break; } // We are exactly half-way between 2 numbers, pick even. if ((significand & last_significant_bit) != 0) { // 1 for our last bit, round up. round_away_from_zero = true; break; } break; } if (round_away_from_zero) { return static_cast( negatable_right_shift::val(incrementSignificand( significand, last_significant_bit, carry_bit))); } else { return static_cast( negatable_right_shift::val(significand)); } } // Casts this value to another HexFloat. If the cast is widening, // then round_dir is ignored. If the cast is narrowing, then // the result is rounded in the direction specified. // This number will retain Nan and Inf values. // It will also saturate to Inf if the number overflows, and // underflow to (0 or min depending on rounding) if the number underflows. template void castTo(other_T& other, round_direction round_dir) { other = other_T(static_cast(0)); bool negate = isNegative(); if (getUnsignedBits() == 0) { if (negate) { other.set_value(-other.value()); } return; } uint_type significand = getSignificandBits(); bool carried = false; typename other_T::uint_type rounded_significand = getRoundedNormalizedSignificand(round_dir, &carried); int_type exponent = getUnbiasedExponent(); if (exponent == min_exponent) { // If we are denormal, normalize the exponent, so that we can encode // easily. exponent = static_cast(exponent + 1); for (uint_type check_bit = first_exponent_bit >> 1; check_bit != 0; check_bit = static_cast(check_bit >> 1)) { exponent = static_cast(exponent - 1); if (check_bit & significand) break; } } bool is_nan = (getBits() & exponent_mask) == exponent_mask && significand != 0; bool is_inf = !is_nan && ((exponent + carried) > static_cast(other_T::exponent_bias) || (significand == 0 && (getBits() & exponent_mask) == exponent_mask)); // If we are Nan or Inf we should pass that through. if (is_inf) { other.set_value(typename other_T::underlying_type( static_cast( (negate ? other_T::sign_mask : 0) | other_T::exponent_mask))); return; } if (is_nan) { typename other_T::uint_type shifted_significand; shifted_significand = static_cast( negatable_left_shift< static_cast(other_T::num_fraction_bits) - static_cast(num_fraction_bits)>::val(significand)); // We are some sort of Nan. We try to keep the bit-pattern of the Nan // as close as possible. If we had to shift off bits so we are 0, then we // just set the last bit. other.set_value(typename other_T::underlying_type( static_cast( (negate ? other_T::sign_mask : 0) | other_T::exponent_mask | (shifted_significand == 0 ? 0x1 : shifted_significand)))); return; } bool round_underflow_up = isNegative() ? round_dir == round_direction::kToNegativeInfinity : round_dir == round_direction::kToPositiveInfinity; using other_int_type = typename other_T::int_type; // setFromSignUnbiasedExponentAndNormalizedSignificand will // zero out any underflowing value (but retain the sign). other.setFromSignUnbiasedExponentAndNormalizedSignificand( negate, static_cast(exponent), rounded_significand, round_underflow_up); return; } private: T value_; static_assert(num_used_bits == Traits::num_exponent_bits + Traits::num_fraction_bits + 1, "The number of bits do not fit"); static_assert(sizeof(T) == sizeof(uint_type), "The type sizes do not match"); }; // Returns 4 bits represented by the hex character. inline uint8_t get_nibble_from_character(int character) { const char* dec = "0123456789"; const char* lower = "abcdef"; const char* upper = "ABCDEF"; const char* p = nullptr; if ((p = strchr(dec, character))) { return static_cast(p - dec); } else if ((p = strchr(lower, character))) { return static_cast(p - lower + 0xa); } else if ((p = strchr(upper, character))) { return static_cast(p - upper + 0xa); } assert(false && "This was called with a non-hex character"); return 0; } // Outputs the given HexFloat to the stream. template std::ostream& operator<<(std::ostream& os, const HexFloat& value) { using HF = HexFloat; using uint_type = typename HF::uint_type; using int_type = typename HF::int_type; static_assert(HF::num_used_bits != 0, "num_used_bits must be non-zero for a valid float"); static_assert(HF::num_exponent_bits != 0, "num_exponent_bits must be non-zero for a valid float"); static_assert(HF::num_fraction_bits != 0, "num_fractin_bits must be non-zero for a valid float"); const uint_type bits = value.value().data(); const char* const sign = (bits & HF::sign_mask) ? "-" : ""; const uint_type exponent = static_cast( (bits & HF::exponent_mask) >> HF::num_fraction_bits); uint_type fraction = static_cast((bits & HF::fraction_encode_mask) << HF::num_overflow_bits); const bool is_zero = exponent == 0 && fraction == 0; const bool is_denorm = exponent == 0 && !is_zero; // exponent contains the biased exponent we have to convert it back into // the normal range. int_type int_exponent = static_cast(exponent - HF::exponent_bias); // If the number is all zeros, then we actually have to NOT shift the // exponent. int_exponent = is_zero ? 0 : int_exponent; // If we are denorm, then start shifting, and decreasing the exponent until // our leading bit is 1. if (is_denorm) { while ((fraction & HF::fraction_top_bit) == 0) { fraction = static_cast(fraction << 1); int_exponent = static_cast(int_exponent - 1); } // Since this is denormalized, we have to consume the leading 1 since it // will end up being implicit. fraction = static_cast(fraction << 1); // eat the leading 1 fraction &= HF::fraction_represent_mask; } uint_type fraction_nibbles = HF::fraction_nibbles; // We do not have to display any trailing 0s, since this represents the // fractional part. while (fraction_nibbles > 0 && (fraction & 0xF) == 0) { // Shift off any trailing values; fraction = static_cast(fraction >> 4); --fraction_nibbles; } const auto saved_flags = os.flags(); const auto saved_fill = os.fill(); os << sign << "0x" << (is_zero ? '0' : '1'); if (fraction_nibbles) { // Make sure to keep the leading 0s in place, since this is the fractional // part. os << "." << std::setw(static_cast(fraction_nibbles)) << std::setfill('0') << std::hex << fraction; } os << "p" << std::dec << (int_exponent >= 0 ? "+" : "") << int_exponent; os.flags(saved_flags); os.fill(saved_fill); return os; } // Returns true if negate_value is true and the next character on the // input stream is a plus or minus sign. In that case we also set the fail bit // on the stream and set the value to the zero value for its type. template inline bool RejectParseDueToLeadingSign(std::istream& is, bool negate_value, HexFloat& value) { if (negate_value) { auto next_char = is.peek(); if (next_char == '-' || next_char == '+') { // Fail the parse. Emulate standard behaviour by setting the value to // the zero value, and set the fail bit on the stream. value = HexFloat(typename HexFloat::uint_type{0}); is.setstate(std::ios_base::failbit); return true; } } return false; } // Parses a floating point number from the given stream and stores it into the // value parameter. // If negate_value is true then the number may not have a leading minus or // plus, and if it successfully parses, then the number is negated before // being stored into the value parameter. // If the value cannot be correctly parsed or overflows the target floating // point type, then set the fail bit on the stream. // TODO(dneto): Promise C++11 standard behavior in how the value is set in // the error case, but only after all target platforms implement it correctly. // In particular, the Microsoft C++ runtime appears to be out of spec. template inline std::istream& ParseNormalFloat(std::istream& is, bool negate_value, HexFloat& value) { if (RejectParseDueToLeadingSign(is, negate_value, value)) { return is; } T val; is >> val; if (negate_value) { val = -val; } value.set_value(val); // In the failure case, map -0.0 to 0.0. if (is.fail() && value.getUnsignedBits() == 0u) { value = HexFloat(typename HexFloat::uint_type{0}); } if (val.isInfinity()) { // Fail the parse. Emulate standard behaviour by setting the value to // the closest normal value, and set the fail bit on the stream. value.set_value((value.isNegative() | negate_value) ? T::lowest() : T::max()); is.setstate(std::ios_base::failbit); } return is; } // Specialization of ParseNormalFloat for FloatProxy values. // This will parse the float as it were a 32-bit floating point number, // and then round it down to fit into a Float16 value. // The number is rounded towards zero. // If negate_value is true then the number may not have a leading minus or // plus, and if it successfully parses, then the number is negated before // being stored into the value parameter. // If the value cannot be correctly parsed or overflows the target floating // point type, then set the fail bit on the stream. // TODO(dneto): Promise C++11 standard behavior in how the value is set in // the error case, but only after all target platforms implement it correctly. // In particular, the Microsoft C++ runtime appears to be out of spec. template <> inline std::istream& ParseNormalFloat, HexFloatTraits>>( std::istream& is, bool negate_value, HexFloat, HexFloatTraits>>& value) { // First parse as a 32-bit float. HexFloat> float_val(0.0f); ParseNormalFloat(is, negate_value, float_val); // Then convert to 16-bit float, saturating at infinities, and // rounding toward zero. float_val.castTo(value, round_direction::kToZero); // Overflow on 16-bit behaves the same as for 32- and 64-bit: set the // fail bit and set the lowest or highest value. if (Float16::isInfinity(value.value().getAsFloat())) { value.set_value(value.isNegative() ? Float16::lowest() : Float16::max()); is.setstate(std::ios_base::failbit); } return is; } namespace detail { // Returns a new value formed from 'value' by setting 'bit' that is the // 'n'th most significant bit (where 0 is the most significant bit). // If 'bit' is zero or 'n' is more than the number of bits in the integer // type, then return the original value. template UINT_TYPE set_nth_most_significant_bit(UINT_TYPE value, UINT_TYPE bit, UINT_TYPE n) { constexpr UINT_TYPE max_position = std::numeric_limits::digits - 1; if ((bit != 0) && (n <= max_position)) { return static_cast(value | (bit << (max_position - n))); } return value; } // Attempts to increment the argument. // If it does not overflow, then increments the argument and returns true. // If it would overflow, returns false. template bool saturated_inc(INT_TYPE& value) { if (value == std::numeric_limits::max()) { return false; } value++; return true; } // Attempts to decrement the argument. // If it does not underflow, then decrements the argument and returns true. // If it would overflow, returns false. template bool saturated_dec(INT_TYPE& value) { if (value == std::numeric_limits::min()) { return false; } value--; return true; } } // namespace detail // Reads a HexFloat from the given stream. // If the float is not encoded as a hex-float then it will be parsed // as a regular float. // This may fail if your stream does not support at least one unget. // Nan values can be encoded with "0x1.p+exponent_bias". // This would normally overflow a float and round to // infinity but this special pattern is the exact representation for a NaN, // and therefore is actually encoded as the correct NaN. To encode inf, // either 0x0p+exponent_bias can be specified or any exponent greater than // exponent_bias. // Examples using IEEE 32-bit float encoding. // 0x1.0p+128 (+inf) // -0x1.0p-128 (-inf) // // 0x1.1p+128 (+Nan) // -0x1.1p+128 (-Nan) // // 0x1p+129 (+inf) // -0x1p+129 (-inf) template std::istream& operator>>(std::istream& is, HexFloat& value) { using HF = HexFloat; using uint_type = typename HF::uint_type; using int_type = typename HF::int_type; value.set_value(static_cast(0.f)); if (is.flags() & std::ios::skipws) { // If the user wants to skip whitespace , then we should obey that. while (std::isspace(is.peek())) { is.get(); } } auto next_char = is.peek(); bool negate_value = false; if (next_char != '-' && next_char != '0') { return ParseNormalFloat(is, negate_value, value); } if (next_char == '-') { negate_value = true; is.get(); next_char = is.peek(); } if (next_char == '0') { is.get(); // We may have to unget this. auto maybe_hex_start = is.peek(); if (maybe_hex_start != 'x' && maybe_hex_start != 'X') { is.unget(); return ParseNormalFloat(is, negate_value, value); } else { is.get(); // Throw away the 'x'; } } else { return ParseNormalFloat(is, negate_value, value); } // This "looks" like a hex-float so treat it as one. bool seen_p = false; bool seen_dot = false; // The mantissa bits, without the most significant 1 bit, and with the // the most recently read bits in the least significant positions. uint_type fraction = 0; // The number of mantissa bits that have been read, including the leading 1 // bit that is not written into 'fraction'. uint_type fraction_index = 0; // TODO(dneto): handle overflow and underflow int_type exponent = HF::exponent_bias; // Strip off leading zeros so we don't have to special-case them later. while ((next_char = is.peek()) == '0') { is.get(); } // Does the mantissa, as written, have non-zero digits to the left of // the decimal point. Assume no until proven otherwise. bool has_integer_part = false; bool bits_written = false; // Stays false until we write a bit. // Scan the mantissa hex digits until we see a '.' or the 'p' that // starts the exponent. while (!seen_p && !seen_dot) { // Handle characters that are left of the fractional part. if (next_char == '.') { seen_dot = true; } else if (next_char == 'p') { seen_p = true; } else if (::isxdigit(next_char)) { // We have stripped all leading zeroes and we have not yet seen a ".". has_integer_part = true; int number = get_nibble_from_character(next_char); for (int i = 0; i < 4; ++i, number <<= 1) { uint_type write_bit = (number & 0x8) ? 0x1 : 0x0; if (bits_written) { // If we are here the bits represented belong in the fractional // part of the float, and we have to adjust the exponent accordingly. fraction = detail::set_nth_most_significant_bit(fraction, write_bit, fraction_index); // Increment the fraction index. If the input has bizarrely many // significant digits, then silently drop them. detail::saturated_inc(fraction_index); if (!detail::saturated_inc(exponent)) { // Overflow failure is.setstate(std::ios::failbit); return is; } } // Since this updated after setting fraction bits, this effectively // drops the leading 1 bit. bits_written |= write_bit != 0; } } else { // We have not found our exponent yet, so we have to fail. is.setstate(std::ios::failbit); return is; } is.get(); next_char = is.peek(); } // Finished reading the part preceding any '.' or 'p'. bits_written = false; while (seen_dot && !seen_p) { // Handle only fractional parts now. if (next_char == 'p') { seen_p = true; } else if (::isxdigit(next_char)) { int number = get_nibble_from_character(next_char); for (int i = 0; i < 4; ++i, number <<= 1) { uint_type write_bit = (number & 0x8) ? 0x01 : 0x00; bits_written |= write_bit != 0; if ((!has_integer_part) && !bits_written) { // Handle modifying the exponent here this way we can handle // an arbitrary number of hex values without overflowing our // integer. if (!detail::saturated_dec(exponent)) { // Overflow failure is.setstate(std::ios::failbit); return is; } } else { fraction = detail::set_nth_most_significant_bit(fraction, write_bit, fraction_index); // Increment the fraction index. If the input has bizarrely many // significant digits, then silently drop them. detail::saturated_inc(fraction_index); } } } else { // We still have not found our 'p' exponent yet, so this is not a valid // hex-float. is.setstate(std::ios::failbit); return is; } is.get(); next_char = is.peek(); } // Finished reading the part preceding 'p'. // In hex floats syntax, the binary exponent is required. bool seen_exponent_sign = false; int8_t exponent_sign = 1; bool seen_written_exponent_digits = false; // The magnitude of the exponent, as written, or the sentinel value to signal // overflow. int_type written_exponent = 0; // A sentinel value signalling overflow of the magnitude of the written // exponent. We'll assume that -written_exponent_overflow is valid for the // type. Later we may add 1 or subtract 1 from the adjusted exponent, so leave // room for an extra 1. const int_type written_exponent_overflow = std::numeric_limits::max() - 1; while (true) { if (!seen_written_exponent_digits && (next_char == '-' || next_char == '+')) { if (seen_exponent_sign) { is.setstate(std::ios::failbit); return is; } seen_exponent_sign = true; exponent_sign = (next_char == '-') ? -1 : 1; } else if (::isdigit(next_char)) { seen_written_exponent_digits = true; // Hex-floats express their exponent as decimal. int_type digit = static_cast(static_cast(next_char) - '0'); if (written_exponent >= (written_exponent_overflow - digit) / 10) { // The exponent is very big. Saturate rather than overflow the exponent. // signed integer, which would be undefined behaviour. written_exponent = written_exponent_overflow; } else { written_exponent = static_cast( static_cast(written_exponent * 10) + digit); } } else { break; } is.get(); next_char = is.peek(); } if (!seen_written_exponent_digits) { // Binary exponent had no digits. is.setstate(std::ios::failbit); return is; } written_exponent = static_cast(written_exponent * exponent_sign); // Now fold in the exponent bias into the written exponent, updating exponent. // But avoid undefined behaviour that would result from overflowing int_type. if (written_exponent >= 0 && exponent >= 0) { // Saturate up to written_exponent_overflow. if (written_exponent_overflow - exponent > written_exponent) { exponent = static_cast(written_exponent + exponent); } else { exponent = written_exponent_overflow; } } else if (written_exponent < 0 && exponent < 0) { // Saturate down to -written_exponent_overflow. if (written_exponent_overflow + exponent > -written_exponent) { exponent = static_cast(written_exponent + exponent); } else { exponent = static_cast(-written_exponent_overflow); } } else { // They're of opposing sign, so it's safe to add. exponent = static_cast(written_exponent + exponent); } bool is_zero = (!has_integer_part) && (fraction == 0); if ((!has_integer_part) && !is_zero) { fraction = static_cast(fraction << 1); exponent = static_cast(exponent - 1); } else if (is_zero) { exponent = 0; } if (exponent <= 0 && !is_zero) { fraction = static_cast(fraction >> 1); fraction |= static_cast(1) << HF::top_bit_left_shift; } fraction = (fraction >> HF::fraction_right_shift) & HF::fraction_encode_mask; const int_type max_exponent = SetBits::get; // Handle denorm numbers while (exponent < 0 && !is_zero) { fraction = static_cast(fraction >> 1); exponent = static_cast(exponent + 1); fraction &= HF::fraction_encode_mask; if (fraction == 0) { // We have underflowed our fraction. We should clamp to zero. is_zero = true; exponent = 0; } } // We have overflowed so we should be inf/-inf. if (exponent > max_exponent) { exponent = max_exponent; fraction = 0; } uint_type output_bits = static_cast( static_cast(negate_value ? 1 : 0) << HF::top_bit_left_shift); output_bits |= fraction; uint_type shifted_exponent = static_cast( static_cast(exponent << HF::exponent_left_shift) & HF::exponent_mask); output_bits |= shifted_exponent; T output_float(output_bits); value.set_value(output_float); return is; } // Writes a FloatProxy value to a stream. // Zero and normal numbers are printed in the usual notation, but with // enough digits to fully reproduce the value. Other values (subnormal, // NaN, and infinity) are printed as a hex float. template std::ostream& operator<<(std::ostream& os, const FloatProxy& value) { auto float_val = value.getAsFloat(); switch (std::fpclassify(float_val)) { case FP_ZERO: case FP_NORMAL: { auto saved_precision = os.precision(); os.precision(std::numeric_limits::max_digits10); os << float_val; os.precision(saved_precision); } break; default: os << HexFloat>(value); break; } return os; } template <> inline std::ostream& operator<<(std::ostream& os, const FloatProxy& value) { os << HexFloat>(value); return os; } } // namespace utils } // namespace spvtools #endif // SOURCE_UTIL_HEX_FLOAT_H_ KhronosGroup-SPIRV-Tools-f289d04/source/util/ilist.h000066400000000000000000000261001475742701700223020ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_UTIL_ILIST_H_ #define SOURCE_UTIL_ILIST_H_ #include #include #include #include #include "source/util/ilist_node.h" namespace spvtools { namespace utils { // An IntrusiveList is a generic implementation of a doubly-linked list. The // intended convention for using this container is: // // class Node : public IntrusiveNodeBase { // // Note that "Node", the class being defined is the template. // // Must have a default constructor accessible to List. // // Add whatever data is needed in the node // }; // // using List = IntrusiveList; // // You can also inherit from IntrusiveList instead of a typedef if you want to // add more functionality. // // The condition on the template for IntrusiveNodeBase is there to add some type // checking to the container. The compiler will still allow inserting elements // of type IntrusiveNodeBase, but that would be an error. This assumption // allows NextNode and PreviousNode to return pointers to Node, and casting will // not be required by the user. template class IntrusiveList { public: static_assert( std::is_base_of, NodeType>::value, "The type from the node must be derived from IntrusiveNodeBase, with " "itself in the template."); // Creates an empty list. inline IntrusiveList(); // Moves the contents of the given list to the list being constructed. IntrusiveList(IntrusiveList&&); // Destroys the list. Note that the elements of the list will not be deleted, // but they will be removed from the list. virtual ~IntrusiveList(); // Moves all of the elements in the list on the RHS to the list on the LHS. IntrusiveList& operator=(IntrusiveList&&); // Basetype for iterators so an IntrusiveList can be traversed like STL // containers. template class iterator_template { public: iterator_template(const iterator_template& i) : node_(i.node_) {} iterator_template& operator++() { node_ = node_->next_node_; return *this; } iterator_template& operator--() { node_ = node_->previous_node_; return *this; } iterator_template& operator=(const iterator_template& i) { node_ = i.node_; return *this; } T& operator*() const { return *node_; } T* operator->() const { return node_; } friend inline bool operator==(const iterator_template& lhs, const iterator_template& rhs) { return lhs.node_ == rhs.node_; } friend inline bool operator!=(const iterator_template& lhs, const iterator_template& rhs) { return !(lhs == rhs); } // Moves the nodes in |list| to the list that |this| points to. The // positions of the nodes will be immediately before the element pointed to // by the iterator. The return value will be an iterator pointing to the // first of the newly inserted elements. iterator_template MoveBefore(IntrusiveList* list) { if (list->empty()) return *this; NodeType* first_node = list->sentinel_.next_node_; NodeType* last_node = list->sentinel_.previous_node_; this->node_->previous_node_->next_node_ = first_node; first_node->previous_node_ = this->node_->previous_node_; last_node->next_node_ = this->node_; this->node_->previous_node_ = last_node; list->sentinel_.next_node_ = &list->sentinel_; list->sentinel_.previous_node_ = &list->sentinel_; return iterator(first_node); } // Define standard iterator types needs so this class can be // used with . using iterator_category = std::bidirectional_iterator_tag; using difference_type = std::ptrdiff_t; using value_type = T; using pointer = T*; using const_pointer = const T*; using reference = T&; using const_reference = const T&; using size_type = size_t; protected: iterator_template() = delete; inline iterator_template(T* node) { node_ = node; } T* node_; friend IntrusiveList; }; using iterator = iterator_template; using const_iterator = iterator_template; // Various types of iterators for the start (begin) and one past the end (end) // of the list. // // Decrementing |end()| iterator will give and iterator pointing to the last // element in the list, if one exists. // // Incrementing |end()| iterator will give |begin()|. // // Decrementing |begin()| will give |end()|. // // TODO: Not marking these functions as noexcept because Visual Studio 2013 // does not support it. When we no longer care about that compiler, we should // mark these as noexcept. iterator begin(); iterator end(); const_iterator begin() const; const_iterator end() const; const_iterator cbegin() const; const_iterator cend() const; // Appends |node| to the end of the list. If |node| is already in a list, it // will be removed from that list first. void push_back(NodeType* node); // Returns true if the list is empty. bool empty() const; // Makes the current list empty. inline void clear(); // Returns references to the first or last element in the list. It is an // error to call these functions on an empty list. NodeType& front(); NodeType& back(); const NodeType& front() const; const NodeType& back() const; // Transfers [|first|, |last|) from |other| into the list at |where|. // // If |other| is |this|, no change is made. void Splice(iterator where, IntrusiveList* other, iterator first, iterator last); protected: // Doing a deep copy of the list does not make sense if the list does not own // the data. It is not clear who will own the newly created data. Making // copies illegal for that reason. IntrusiveList(const IntrusiveList&) = delete; IntrusiveList& operator=(const IntrusiveList&) = delete; // This function will assert if it finds the list containing |node| is not in // a valid state. static void Check(NodeType* node); // A special node used to represent both the start and end of the list, // without being part of the list. NodeType sentinel_; }; // Implementation of IntrusiveList template inline IntrusiveList::IntrusiveList() : sentinel_() { sentinel_.next_node_ = &sentinel_; sentinel_.previous_node_ = &sentinel_; sentinel_.is_sentinel_ = true; } template IntrusiveList::IntrusiveList(IntrusiveList&& list) : sentinel_() { sentinel_.next_node_ = &sentinel_; sentinel_.previous_node_ = &sentinel_; sentinel_.is_sentinel_ = true; list.sentinel_.ReplaceWith(&sentinel_); } template IntrusiveList::~IntrusiveList() { clear(); } template IntrusiveList& IntrusiveList::operator=( IntrusiveList&& list) { list.sentinel_.ReplaceWith(&sentinel_); return *this; } template inline typename IntrusiveList::iterator IntrusiveList::begin() { return iterator(sentinel_.next_node_); } template inline typename IntrusiveList::iterator IntrusiveList::end() { return iterator(&sentinel_); } template inline typename IntrusiveList::const_iterator IntrusiveList::begin() const { return const_iterator(sentinel_.next_node_); } template inline typename IntrusiveList::const_iterator IntrusiveList::end() const { return const_iterator(&sentinel_); } template inline typename IntrusiveList::const_iterator IntrusiveList::cbegin() const { return const_iterator(sentinel_.next_node_); } template inline typename IntrusiveList::const_iterator IntrusiveList::cend() const { return const_iterator(&sentinel_); } template void IntrusiveList::push_back(NodeType* node) { node->InsertBefore(&sentinel_); } template bool IntrusiveList::empty() const { return sentinel_.NextNode() == nullptr; } template void IntrusiveList::clear() { while (!empty()) { front().RemoveFromList(); } } template NodeType& IntrusiveList::front() { NodeType* node = sentinel_.NextNode(); assert(node != nullptr && "Can't get the front of an empty list."); return *node; } template NodeType& IntrusiveList::back() { NodeType* node = sentinel_.PreviousNode(); assert(node != nullptr && "Can't get the back of an empty list."); return *node; } template const NodeType& IntrusiveList::front() const { NodeType* node = sentinel_.NextNode(); assert(node != nullptr && "Can't get the front of an empty list."); return *node; } template const NodeType& IntrusiveList::back() const { NodeType* node = sentinel_.PreviousNode(); assert(node != nullptr && "Can't get the back of an empty list."); return *node; } template void IntrusiveList::Splice(iterator where, IntrusiveList* other, iterator first, iterator last) { if (first == last) return; if (other == this) return; NodeType* first_prev = first.node_->previous_node_; NodeType* where_next = where.node_->next_node_; // Attach first. where.node_->next_node_ = first.node_; first.node_->previous_node_ = where.node_; // Attach last. where_next->previous_node_ = last.node_->previous_node_; last.node_->previous_node_->next_node_ = where_next; // Fixup other. first_prev->next_node_ = last.node_; last.node_->previous_node_ = first_prev; } template void IntrusiveList::Check(NodeType* start) { int sentinel_count = 0; NodeType* p = start; do { assert(p != nullptr); assert(p->next_node_->previous_node_ == p); assert(p->previous_node_->next_node_ == p); if (p->is_sentinel_) sentinel_count++; p = p->next_node_; } while (p != start); assert(sentinel_count == 1 && "List should have exactly 1 sentinel node."); (void)sentinel_count; p = start; do { assert(p != nullptr); assert(p->previous_node_->next_node_ == p); assert(p->next_node_->previous_node_ == p); if (p->is_sentinel_) sentinel_count++; p = p->previous_node_; } while (p != start); } } // namespace utils } // namespace spvtools #endif // SOURCE_UTIL_ILIST_H_ KhronosGroup-SPIRV-Tools-f289d04/source/util/ilist_node.h000066400000000000000000000213531475742701700233140ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_UTIL_ILIST_NODE_H_ #define SOURCE_UTIL_ILIST_NODE_H_ #include namespace spvtools { namespace utils { template class IntrusiveList; // IntrusiveNodeBase is the base class for nodes in an IntrusiveList. // See the comments in ilist.h on how to use the class. template class IntrusiveNodeBase { public: // Creates a new node that is not in a list. inline IntrusiveNodeBase(); inline IntrusiveNodeBase(const IntrusiveNodeBase&); inline IntrusiveNodeBase& operator=(const IntrusiveNodeBase&); inline IntrusiveNodeBase(IntrusiveNodeBase&& that); // Destroys a node. It is an error to destroy a node that is part of a // list, unless it is a sentinel. virtual ~IntrusiveNodeBase(); IntrusiveNodeBase& operator=(IntrusiveNodeBase&& that); // Returns true if |this| is in a list. inline bool IsInAList() const; // Returns the node that comes after the given node in the list, if one // exists. If the given node is not in a list or is at the end of the list, // the return value is nullptr. inline NodeType* NextNode() const; // Returns the node that comes before the given node in the list, if one // exists. If the given node is not in a list or is at the start of the // list, the return value is nullptr. inline NodeType* PreviousNode() const; // Inserts the given node immediately before |pos| in the list. // If the given node is already in a list, it will first be removed // from that list. // // It is assumed that the given node is of type NodeType. It is an error if // |pos| is not already in a list. inline void InsertBefore(NodeType* pos); // Inserts the given node immediately after |pos| in the list. // If the given node is already in a list, it will first be removed // from that list. // // It is assumed that the given node is of type NodeType. It is an error if // |pos| is not already in a list, or if |pos| is equal to |this|. inline void InsertAfter(NodeType* pos); // Removes the given node from the list. It is assumed that the node is // in a list. Note that this does not free any storage related to the node, // it becomes the caller's responsibility to free the storage. inline void RemoveFromList(); protected: // Replaces |this| with |target|. |this| is a sentinel if and only if // |target| is also a sentinel. // // If neither node is a sentinel, |target| takes // the place of |this|. It is assumed that |target| is not in a list. // // If both are sentinels, then it will cause all of the // nodes in the list containing |this| to be moved to the list containing // |target|. In this case, it is assumed that |target| is an empty list. // // No storage will be deleted. void ReplaceWith(NodeType* target); // Returns true if |this| is the sentinel node of an empty list. bool IsEmptyList(); // The pointers to the next and previous nodes in the list. // If the current node is not part of a list, then |next_node_| and // |previous_node_| are equal to |nullptr|. NodeType* next_node_; NodeType* previous_node_; // Only true for the sentinel node stored in the list itself. bool is_sentinel_; friend IntrusiveList; }; // Implementation of IntrusiveNodeBase template inline IntrusiveNodeBase::IntrusiveNodeBase() : next_node_(nullptr), previous_node_(nullptr), is_sentinel_(false) {} template inline IntrusiveNodeBase::IntrusiveNodeBase( const IntrusiveNodeBase&) { next_node_ = nullptr; previous_node_ = nullptr; is_sentinel_ = false; } template inline IntrusiveNodeBase& IntrusiveNodeBase::operator=( const IntrusiveNodeBase&) { assert(!is_sentinel_); if (IsInAList()) { RemoveFromList(); } return *this; } template inline IntrusiveNodeBase::IntrusiveNodeBase(IntrusiveNodeBase&& that) : next_node_(nullptr), previous_node_(nullptr), is_sentinel_(that.is_sentinel_) { if (is_sentinel_) { next_node_ = this; previous_node_ = this; } that.ReplaceWith(this); } template IntrusiveNodeBase::~IntrusiveNodeBase() { assert(is_sentinel_ || !IsInAList()); } template IntrusiveNodeBase& IntrusiveNodeBase::operator=( IntrusiveNodeBase&& that) { that.ReplaceWith(this); return *this; } template inline bool IntrusiveNodeBase::IsInAList() const { return next_node_ != nullptr; } template inline NodeType* IntrusiveNodeBase::NextNode() const { if (!next_node_->is_sentinel_) return next_node_; return nullptr; } template inline NodeType* IntrusiveNodeBase::PreviousNode() const { if (!previous_node_->is_sentinel_) return previous_node_; return nullptr; } template inline void IntrusiveNodeBase::InsertBefore(NodeType* pos) { assert(!this->is_sentinel_ && "Sentinel nodes cannot be moved around."); assert(pos->IsInAList() && "Pos should already be in a list."); if (this->IsInAList()) this->RemoveFromList(); this->next_node_ = pos; this->previous_node_ = pos->previous_node_; pos->previous_node_ = static_cast(this); this->previous_node_->next_node_ = static_cast(this); } template inline void IntrusiveNodeBase::InsertAfter(NodeType* pos) { assert(!this->is_sentinel_ && "Sentinel nodes cannot be moved around."); assert(pos->IsInAList() && "Pos should already be in a list."); assert(this != pos && "Can't insert a node after itself."); if (this->IsInAList()) { this->RemoveFromList(); } this->previous_node_ = pos; this->next_node_ = pos->next_node_; pos->next_node_ = static_cast(this); this->next_node_->previous_node_ = static_cast(this); } template inline void IntrusiveNodeBase::RemoveFromList() { assert(!this->is_sentinel_ && "Sentinel nodes cannot be moved around."); assert(this->IsInAList() && "Cannot remove a node from a list if it is not in a list."); this->next_node_->previous_node_ = this->previous_node_; this->previous_node_->next_node_ = this->next_node_; this->next_node_ = nullptr; this->previous_node_ = nullptr; } template void IntrusiveNodeBase::ReplaceWith(NodeType* target) { if (this->is_sentinel_) { assert(target->IsEmptyList() && "If target is not an empty list, the nodes in that list would not " "be linked to a sentinel."); } else { assert(IsInAList() && "The node being replaced must be in a list."); assert(!target->is_sentinel_ && "Cannot turn a sentinel node into one that is not."); } if (!this->IsEmptyList()) { // Link target into the same position that |this| was in. target->next_node_ = this->next_node_; target->previous_node_ = this->previous_node_; target->next_node_->previous_node_ = target; target->previous_node_->next_node_ = target; // Reset |this| to itself default value. if (!this->is_sentinel_) { // Reset |this| so that it is not in a list. this->next_node_ = nullptr; this->previous_node_ = nullptr; } else { // Set |this| so that it is the head of an empty list. // We cannot treat sentinel nodes like others because it is invalid for // a sentinel node to not be in a list. this->next_node_ = static_cast(this); this->previous_node_ = static_cast(this); } } else { // If |this| points to itself, it must be a sentinel node with an empty // list. Reset |this| so that it is the head of an empty list. We want // |target| to be the same. The asserts above guarantee that. } } template bool IntrusiveNodeBase::IsEmptyList() { if (next_node_ == this) { assert(is_sentinel_ && "None sentinel nodes should never point to themselves."); assert(previous_node_ == this && "Inconsistency with the previous and next nodes."); return true; } return false; } } // namespace utils } // namespace spvtools #endif // SOURCE_UTIL_ILIST_NODE_H_ KhronosGroup-SPIRV-Tools-f289d04/source/util/make_unique.h000066400000000000000000000016601475742701700234650ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_UTIL_MAKE_UNIQUE_H_ #define SOURCE_UTIL_MAKE_UNIQUE_H_ #include #include namespace spvtools { template std::unique_ptr MakeUnique(Args&&... args) { return std::unique_ptr(new T(std::forward(args)...)); } } // namespace spvtools #endif // SOURCE_UTIL_MAKE_UNIQUE_H_ KhronosGroup-SPIRV-Tools-f289d04/source/util/parse_number.cpp000066400000000000000000000166111475742701700242010ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/util/parse_number.h" #include #include #include #include #include #include #include "source/util/hex_float.h" #include "source/util/make_unique.h" namespace spvtools { namespace utils { namespace { // A helper class that temporarily stores error messages and dump the messages // to a string which given as as pointer when it is destructed. If the given // pointer is a nullptr, this class does not store error message. class ErrorMsgStream { public: explicit ErrorMsgStream(std::string* error_msg_sink) : error_msg_sink_(error_msg_sink) { if (error_msg_sink_) stream_ = MakeUnique(); } ~ErrorMsgStream() { if (error_msg_sink_ && stream_) *error_msg_sink_ = stream_->str(); } template ErrorMsgStream& operator<<(T val) { if (stream_) *stream_ << val; return *this; } private: std::unique_ptr stream_; // The destination string to which this class dump the error message when // destructor is called. std::string* error_msg_sink_; }; } // namespace EncodeNumberStatus ParseAndEncodeIntegerNumber( const char* text, const NumberType& type, std::function emit, std::string* error_msg) { if (!text) { ErrorMsgStream(error_msg) << "The given text is a nullptr"; return EncodeNumberStatus::kInvalidText; } if (!IsIntegral(type)) { ErrorMsgStream(error_msg) << "The expected type is not a integer type"; return EncodeNumberStatus::kInvalidUsage; } const uint32_t bit_width = AssumedBitWidth(type); if (bit_width > 64) { ErrorMsgStream(error_msg) << "Unsupported " << bit_width << "-bit integer literals"; return EncodeNumberStatus::kUnsupported; } // Either we are expecting anything or integer. bool is_negative = text[0] == '-'; bool can_be_signed = IsSigned(type); if (is_negative && !can_be_signed) { ErrorMsgStream(error_msg) << "Cannot put a negative number in an unsigned literal"; return EncodeNumberStatus::kInvalidUsage; } const bool is_hex = text[0] == '0' && (text[1] == 'x' || text[1] == 'X'); uint64_t decoded_bits; if (is_negative) { int64_t decoded_signed = 0; if (!ParseNumber(text, &decoded_signed)) { ErrorMsgStream(error_msg) << "Invalid signed integer literal: " << text; return EncodeNumberStatus::kInvalidText; } if (!CheckRangeAndIfHexThenSignExtend(decoded_signed, type, is_hex, &decoded_signed)) { ErrorMsgStream(error_msg) << "Integer " << (is_hex ? std::hex : std::dec) << std::showbase << decoded_signed << " does not fit in a " << std::dec << bit_width << "-bit " << (IsSigned(type) ? "signed" : "unsigned") << " integer"; return EncodeNumberStatus::kInvalidText; } decoded_bits = decoded_signed; } else { // There's no leading minus sign, so parse it as an unsigned integer. if (!ParseNumber(text, &decoded_bits)) { ErrorMsgStream(error_msg) << "Invalid unsigned integer literal: " << text; return EncodeNumberStatus::kInvalidText; } if (!CheckRangeAndIfHexThenSignExtend(decoded_bits, type, is_hex, &decoded_bits)) { ErrorMsgStream(error_msg) << "Integer " << (is_hex ? std::hex : std::dec) << std::showbase << decoded_bits << " does not fit in a " << std::dec << bit_width << "-bit " << (IsSigned(type) ? "signed" : "unsigned") << " integer"; return EncodeNumberStatus::kInvalidText; } } if (bit_width > 32) { uint32_t low = uint32_t(0x00000000ffffffff & decoded_bits); uint32_t high = uint32_t((0xffffffff00000000 & decoded_bits) >> 32); emit(low); emit(high); } else { emit(uint32_t(decoded_bits)); } return EncodeNumberStatus::kSuccess; } EncodeNumberStatus ParseAndEncodeFloatingPointNumber( const char* text, const NumberType& type, std::function emit, std::string* error_msg) { if (!text) { ErrorMsgStream(error_msg) << "The given text is a nullptr"; return EncodeNumberStatus::kInvalidText; } if (!IsFloating(type)) { ErrorMsgStream(error_msg) << "The expected type is not a float type"; return EncodeNumberStatus::kInvalidUsage; } const auto bit_width = AssumedBitWidth(type); switch (bit_width) { case 16: { HexFloat> hVal(0); if (!ParseNumber(text, &hVal)) { ErrorMsgStream(error_msg) << "Invalid 16-bit float literal: " << text; return EncodeNumberStatus::kInvalidText; } // getAsFloat will return the Float16 value, and get_value // will return a uint16_t representing the bits of the float. // The encoding is therefore correct from the perspective of the SPIR-V // spec since the top 16 bits will be 0. emit(static_cast(hVal.value().getAsFloat().get_value())); return EncodeNumberStatus::kSuccess; } break; case 32: { HexFloat> fVal(0.0f); if (!ParseNumber(text, &fVal)) { ErrorMsgStream(error_msg) << "Invalid 32-bit float literal: " << text; return EncodeNumberStatus::kInvalidText; } emit(BitwiseCast(fVal)); return EncodeNumberStatus::kSuccess; } break; case 64: { HexFloat> dVal(0.0); if (!ParseNumber(text, &dVal)) { ErrorMsgStream(error_msg) << "Invalid 64-bit float literal: " << text; return EncodeNumberStatus::kInvalidText; } uint64_t decoded_val = BitwiseCast(dVal); uint32_t low = uint32_t(0x00000000ffffffff & decoded_val); uint32_t high = uint32_t((0xffffffff00000000 & decoded_val) >> 32); emit(low); emit(high); return EncodeNumberStatus::kSuccess; } break; default: break; } ErrorMsgStream(error_msg) << "Unsupported " << bit_width << "-bit float literals"; return EncodeNumberStatus::kUnsupported; } EncodeNumberStatus ParseAndEncodeNumber(const char* text, const NumberType& type, std::function emit, std::string* error_msg) { if (!text) { ErrorMsgStream(error_msg) << "The given text is a nullptr"; return EncodeNumberStatus::kInvalidText; } if (IsUnknown(type)) { ErrorMsgStream(error_msg) << "The expected type is not a integer or float type"; return EncodeNumberStatus::kInvalidUsage; } // If we explicitly expect a floating-point number, we should handle that // first. if (IsFloating(type)) { return ParseAndEncodeFloatingPointNumber(text, type, emit, error_msg); } return ParseAndEncodeIntegerNumber(text, type, emit, error_msg); } } // namespace utils } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/util/parse_number.h000066400000000000000000000231361475742701700236460ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_UTIL_PARSE_NUMBER_H_ #define SOURCE_UTIL_PARSE_NUMBER_H_ #include #include #include #include "source/util/hex_float.h" #include "spirv-tools/libspirv.h" namespace spvtools { namespace utils { // A struct to hold the expected type information for the number in text to be // parsed. struct NumberType { uint32_t bitwidth; // SPV_NUMBER_NONE means the type is unknown and is invalid to be used with // ParseAndEncode{|Integer|Floating}Number(). spv_number_kind_t kind; }; // Returns true if the type is a scalar integer type. inline bool IsIntegral(const NumberType& type) { return type.kind == SPV_NUMBER_UNSIGNED_INT || type.kind == SPV_NUMBER_SIGNED_INT; } // Returns true if the type is a scalar floating point type. inline bool IsFloating(const NumberType& type) { return type.kind == SPV_NUMBER_FLOATING; } // Returns true if the type is a signed value. inline bool IsSigned(const NumberType& type) { return type.kind == SPV_NUMBER_FLOATING || type.kind == SPV_NUMBER_SIGNED_INT; } // Returns true if the type is unknown. inline bool IsUnknown(const NumberType& type) { return type.kind == SPV_NUMBER_NONE; } // Returns the number of bits in the type. This is only valid for integer and // floating types. inline int AssumedBitWidth(const NumberType& type) { switch (type.kind) { case SPV_NUMBER_SIGNED_INT: case SPV_NUMBER_UNSIGNED_INT: case SPV_NUMBER_FLOATING: return type.bitwidth; default: break; } // We don't care about this case. return 0; } // A templated class with a static member function Clamp, where Clamp sets a // referenced value of type T to 0 if T is an unsigned integer type, and // returns true if it modified the referenced value. template class ClampToZeroIfUnsignedType { public: // The default specialization does not clamp the value. static bool Clamp(T*) { return false; } }; // The specialization of ClampToZeroIfUnsignedType for unsigned integer types. template class ClampToZeroIfUnsignedType< T, typename std::enable_if::value>::type> { public: static bool Clamp(T* value_pointer) { if (*value_pointer) { *value_pointer = 0; return true; } return false; } }; // Returns true if the given value fits within the target scalar integral type. // The target type may have an unusual bit width. If the value was originally // specified as a hexadecimal number, then the overflow bits should be zero. // If it was hex and the target type is signed, then return the sign-extended // value through the updated_value_for_hex pointer argument. On failure, // returns false. template bool CheckRangeAndIfHexThenSignExtend(T value, const NumberType& type, bool is_hex, T* updated_value_for_hex) { // The encoded result has three regions of bits that are of interest, from // least to most significant: // - magnitude bits, where the magnitude of the number would be stored if // we were using a signed-magnitude representation. // - an optional sign bit // - overflow bits, up to bit 63 of a 64-bit number // For example: // Type Overflow Sign Magnitude // --------------- -------- ---- --------- // unsigned 8 bit 8-63 n/a 0-7 // signed 8 bit 8-63 7 0-6 // unsigned 16 bit 16-63 n/a 0-15 // signed 16 bit 16-63 15 0-14 // We'll use masks to define the three regions. // At first we'll assume the number is unsigned. const uint32_t bit_width = AssumedBitWidth(type); uint64_t magnitude_mask = (bit_width == 64) ? -1 : ((uint64_t(1) << bit_width) - 1); uint64_t sign_mask = 0; uint64_t overflow_mask = ~magnitude_mask; if (value < 0 || IsSigned(type)) { // Accommodate the sign bit. magnitude_mask >>= 1; sign_mask = magnitude_mask + 1; } bool failed = false; if (value < 0) { // The top bits must all be 1 for a negative signed value. failed = ((value & overflow_mask) != overflow_mask) || ((value & sign_mask) != sign_mask); } else { if (is_hex) { // Hex values are a bit special. They decode as unsigned values, but may // represent a negative number. In this case, the overflow bits should // be zero. failed = (value & overflow_mask) != 0; } else { const uint64_t value_as_u64 = static_cast(value); // Check overflow in the ordinary case. failed = (value_as_u64 & magnitude_mask) != value_as_u64; } } if (failed) { return false; } // Sign extend hex the number. if (is_hex && (value & sign_mask)) *updated_value_for_hex = (value | overflow_mask); return true; } // Parses a numeric value of a given type from the given text. The number // should take up the entire string, and should be within bounds for the target // type. On success, returns true and populates the object referenced by // value_pointer. On failure, returns false. template bool ParseNumber(const char* text, T* value_pointer) { // C++11 doesn't define std::istringstream(int8_t&), so calling this method // with a single-byte type leads to implementation-defined behaviour. // Similarly for uint8_t. static_assert(sizeof(T) > 1, "Single-byte types are not supported in this parse method"); if (!text) return false; std::istringstream text_stream(text); // Allow both decimal and hex input for integers. // It also allows octal input, but we don't care about that case. text_stream >> std::setbase(0); text_stream >> *value_pointer; // We should have read something. bool ok = (text[0] != 0) && !text_stream.bad(); // It should have been all the text. ok = ok && text_stream.eof(); // It should have been in range. ok = ok && !text_stream.fail(); // Work around a bug in the GNU C++11 library. It will happily parse // "-1" for uint16_t as 65535. if (ok && text[0] == '-') ok = !ClampToZeroIfUnsignedType::Clamp(value_pointer); return ok; } // Enum to indicate the parsing and encoding status. enum class EncodeNumberStatus { kSuccess = 0, // Unsupported bit width etc. kUnsupported, // Expected type (NumberType) is not a scalar int or float, or putting a // negative number in an unsigned literal. kInvalidUsage, // Number value does not fit the bit width of the expected type etc. kInvalidText, }; // Parses an integer value of a given |type| from the given |text| and encodes // the number by the given |emit| function. On success, returns // EncodeNumberStatus::kSuccess and the parsed number will be consumed by the // given |emit| function word by word (least significant word first). On // failure, this function returns the error code of the encoding status and // |emit| function will not be called. If the string pointer |error_msg| is not // a nullptr, it will be overwritten with error messages in case of failure. In // case of success, |error_msg| will not be touched. Integers up to 64 bits are // supported. EncodeNumberStatus ParseAndEncodeIntegerNumber( const char* text, const NumberType& type, std::function emit, std::string* error_msg); // Parses a floating point value of a given |type| from the given |text| and // encodes the number by the given |emit| function. On success, returns // EncodeNumberStatus::kSuccess and the parsed number will be consumed by the // given |emit| function word by word (least significant word first). On // failure, this function returns the error code of the encoding status and // |emit| function will not be called. If the string pointer |error_msg| is not // a nullptr, it will be overwritten with error messages in case of failure. In // case of success, |error_msg| will not be touched. Only 16, 32 and 64 bit // floating point numbers are supported. EncodeNumberStatus ParseAndEncodeFloatingPointNumber( const char* text, const NumberType& type, std::function emit, std::string* error_msg); // Parses an integer or floating point number of a given |type| from the given // |text| and encodes the number by the given |emit| function. On success, // returns EncodeNumberStatus::kSuccess and the parsed number will be consumed // by the given |emit| function word by word (least significant word first). On // failure, this function returns the error code of the encoding status and // |emit| function will not be called. If the string pointer |error_msg| is not // a nullptr, it will be overwritten with error messages in case of failure. In // case of success, |error_msg| will not be touched. Integers up to 64 bits // and 16/32/64 bit floating point values are supported. EncodeNumberStatus ParseAndEncodeNumber(const char* text, const NumberType& type, std::function emit, std::string* error_msg); } // namespace utils } // namespace spvtools #endif // SOURCE_UTIL_PARSE_NUMBER_H_ KhronosGroup-SPIRV-Tools-f289d04/source/util/small_vector.h000066400000000000000000000315521475742701700236570ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_UTIL_SMALL_VECTOR_H_ #define SOURCE_UTIL_SMALL_VECTOR_H_ #include #include #include #include #include #include #include #include "source/util/make_unique.h" namespace spvtools { namespace utils { // The |SmallVector| class is intended to be a drop-in replacement for // |std::vector|. The difference is in the implementation. A |SmallVector| is // optimized for when the number of elements in the vector are small. Small is // defined by the template parameter |small_size|. // // Note that |SmallVector| is not always faster than an |std::vector|, so you // should experiment with different values for |small_size| and compare to // using and |std::vector|. // // TODO: I have implemented the public member functions from |std::vector| that // I needed. If others are needed they should be implemented. Do not implement // public member functions that are not defined by std::vector. template class SmallVector { public: using iterator = T*; using const_iterator = const T*; SmallVector() : size_(0), small_data_(reinterpret_cast(buffer)), large_data_(nullptr) {} SmallVector(const SmallVector& that) : SmallVector() { *this = that; } SmallVector(SmallVector&& that) : SmallVector() { *this = std::move(that); } SmallVector(const std::vector& vec) : SmallVector() { if (vec.size() > small_size) { large_data_ = MakeUnique>(vec); } else { size_ = vec.size(); for (uint32_t i = 0; i < size_; i++) { new (small_data_ + i) T(vec[i]); } } } template SmallVector(InputIt first, InputIt last) : SmallVector() { insert(end(), first, last); } SmallVector(std::vector&& vec) : SmallVector() { if (vec.size() > small_size) { large_data_ = MakeUnique>(std::move(vec)); } else { size_ = vec.size(); for (uint32_t i = 0; i < size_; i++) { new (small_data_ + i) T(std::move(vec[i])); } } vec.clear(); } SmallVector(std::initializer_list init_list) : SmallVector() { if (init_list.size() < small_size) { for (auto it = init_list.begin(); it != init_list.end(); ++it) { new (small_data_ + (size_++)) T(std::move(*it)); } } else { large_data_ = MakeUnique>(std::move(init_list)); } } SmallVector(size_t s, const T& v) : SmallVector() { resize(s, v); } virtual ~SmallVector() { for (T* p = small_data_; p < small_data_ + size_; ++p) { p->~T(); } } SmallVector& operator=(const SmallVector& that) { assert(small_data_); if (that.large_data_) { if (large_data_) { *large_data_ = *that.large_data_; } else { large_data_ = MakeUnique>(*that.large_data_); } } else { large_data_.reset(nullptr); size_t i = 0; // Do a copy for any element in |this| that is already constructed. for (; i < size_ && i < that.size_; ++i) { small_data_[i] = that.small_data_[i]; } if (i >= that.size_) { // If the size of |this| becomes smaller after the assignment, then // destroy any extra elements. for (; i < size_; ++i) { small_data_[i].~T(); } } else { // If the size of |this| becomes larger after the assignement, copy // construct the new elements that are needed. for (; i < that.size_; ++i) { new (small_data_ + i) T(that.small_data_[i]); } } size_ = that.size_; } return *this; } SmallVector& operator=(SmallVector&& that) { if (that.large_data_) { large_data_.reset(that.large_data_.release()); } else { large_data_.reset(nullptr); size_t i = 0; // Do a move for any element in |this| that is already constructed. for (; i < size_ && i < that.size_; ++i) { small_data_[i] = std::move(that.small_data_[i]); } if (i >= that.size_) { // If the size of |this| becomes smaller after the assignment, then // destroy any extra elements. for (; i < size_; ++i) { small_data_[i].~T(); } } else { // If the size of |this| becomes larger after the assignement, move // construct the new elements that are needed. for (; i < that.size_; ++i) { new (small_data_ + i) T(std::move(that.small_data_[i])); } } size_ = that.size_; } // Reset |that| because all of the data has been moved to |this|. that.DestructSmallData(); return *this; } template friend bool operator==(const SmallVector& lhs, const OtherVector& rhs) { if (lhs.size() != rhs.size()) { return false; } auto rit = rhs.begin(); for (auto lit = lhs.begin(); lit != lhs.end(); ++lit, ++rit) { if (*lit != *rit) { return false; } } return true; } // Avoid infinite recursion from rewritten operators in C++20 #if __cplusplus <= 201703L friend bool operator==(const std::vector& lhs, const SmallVector& rhs) { return rhs == lhs; } #endif friend bool operator!=(const SmallVector& lhs, const std::vector& rhs) { return !(lhs == rhs); } friend bool operator!=(const std::vector& lhs, const SmallVector& rhs) { return rhs != lhs; } T& operator[](size_t i) { if (!large_data_) { return small_data_[i]; } else { return (*large_data_)[i]; } } const T& operator[](size_t i) const { if (!large_data_) { return small_data_[i]; } else { return (*large_data_)[i]; } } size_t size() const { if (!large_data_) { return size_; } else { return large_data_->size(); } } iterator begin() { if (large_data_) { return large_data_->data(); } else { return small_data_; } } const_iterator begin() const { if (large_data_) { return large_data_->data(); } else { return small_data_; } } const_iterator cbegin() const { return begin(); } iterator end() { if (large_data_) { return large_data_->data() + large_data_->size(); } else { return small_data_ + size_; } } const_iterator end() const { if (large_data_) { return large_data_->data() + large_data_->size(); } else { return small_data_ + size_; } } const_iterator cend() const { return end(); } T* data() { return begin(); } const T* data() const { return cbegin(); } T& front() { return (*this)[0]; } const T& front() const { return (*this)[0]; } iterator erase(const_iterator pos) { return erase(pos, pos + 1); } iterator erase(const_iterator first, const_iterator last) { if (large_data_) { size_t start_index = first - large_data_->data(); size_t end_index = last - large_data_->data(); auto r = large_data_->erase(large_data_->begin() + start_index, large_data_->begin() + end_index); return large_data_->data() + (r - large_data_->begin()); } // Since C++11, std::vector has |const_iterator| for the parameters, so I // follow that. However, I need iterators to modify the current container, // which is not const. This is why I cast away the const. iterator f = const_cast(first); iterator l = const_cast(last); iterator e = end(); size_t num_of_del_elements = last - first; iterator ret = f; if (first == last) { return ret; } // Move |last| and any elements after it their earlier position. while (l != e) { *f = std::move(*l); ++f; ++l; } // Destroy the elements that were supposed to be deleted. while (f != l) { f->~T(); ++f; } // Update the size. size_ -= num_of_del_elements; return ret; } void push_back(const T& value) { if (!large_data_ && size_ == small_size) { MoveToLargeData(); } if (large_data_) { large_data_->push_back(value); return; } new (small_data_ + size_) T(value); ++size_; } void push_back(T&& value) { if (!large_data_ && size_ == small_size) { MoveToLargeData(); } if (large_data_) { large_data_->push_back(std::move(value)); return; } new (small_data_ + size_) T(std::move(value)); ++size_; } void pop_back() { if (large_data_) { large_data_->pop_back(); } else { --size_; small_data_[size_].~T(); } } template iterator insert(iterator pos, InputIt first, InputIt last) { size_t element_idx = (pos - begin()); size_t num_of_new_elements = std::distance(first, last); size_t new_size = size_ + num_of_new_elements; if (!large_data_ && new_size > small_size) { MoveToLargeData(); } if (large_data_) { typename std::vector::iterator new_pos = large_data_->begin() + element_idx; large_data_->insert(new_pos, first, last); return begin() + element_idx; } // Move |pos| and all of the elements after it over |num_of_new_elements| // places. We start at the end and work backwards, to make sure we do not // overwrite data that we have not moved yet. for (iterator i = begin() + new_size - 1, j = end() - 1; j >= pos; --i, --j) { if (i >= begin() + size_) { new (i) T(std::move(*j)); } else { *i = std::move(*j); } } // Copy the new elements into position. iterator p = pos; for (; first != last; ++p, ++first) { if (p >= small_data_ + size_) { new (p) T(*first); } else { *p = *first; } } // Update the size. size_ += num_of_new_elements; return pos; } bool empty() const { if (large_data_) { return large_data_->empty(); } return size_ == 0; } void clear() { if (large_data_) { large_data_->clear(); } else { DestructSmallData(); } } template void emplace_back(Args&&... args) { if (!large_data_ && size_ == small_size) { MoveToLargeData(); } if (large_data_) { large_data_->emplace_back(std::forward(args)...); } else { new (small_data_ + size_) T(std::forward(args)...); ++size_; } } void resize(size_t new_size, const T& v) { if (!large_data_ && new_size > small_size) { MoveToLargeData(); } if (large_data_) { large_data_->resize(new_size, v); return; } // If |new_size| < |size_|, then destroy the extra elements. for (size_t i = new_size; i < size_; ++i) { small_data_[i].~T(); } // If |new_size| > |size_|, the copy construct the new elements. for (size_t i = size_; i < new_size; ++i) { new (small_data_ + i) T(v); } // Update the size. size_ = new_size; } private: // Moves all of the element from |small_data_| into a new std::vector that can // be access through |large_data|. void MoveToLargeData() { assert(!large_data_); large_data_ = MakeUnique>(); for (size_t i = 0; i < size_; ++i) { large_data_->emplace_back(std::move(small_data_[i])); } DestructSmallData(); } // Destroys all of the elements in |small_data_| that have been constructed. void DestructSmallData() { for (size_t i = 0; i < size_; ++i) { small_data_[i].~T(); } size_ = 0; } // The number of elements in |small_data_| that have been constructed. size_t size_; // A type with the same alignment and size as T, but will is POD. struct alignas(T) PodType { std::array data; }; // The actual data used to store the array elements. It must never be used // directly, but must only be accessed through |small_data_|. PodType buffer[small_size]; // The pointed used to access the array of elements when the number of // elements is small. T* small_data_; // A pointer to a vector that is used to store the elements of the vector when // this size exceeds |small_size|. If |large_data_| is nullptr, then the data // is stored in |small_data_|. Otherwise, the data is stored in // |large_data_|. std::unique_ptr> large_data_; }; // namespace utils } // namespace utils } // namespace spvtools #endif // SOURCE_UTIL_SMALL_VECTOR_H_ KhronosGroup-SPIRV-Tools-f289d04/source/util/string_utils.cpp000066400000000000000000000033571475742701700242500ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include "source/util/string_utils.h" namespace spvtools { namespace utils { std::string CardinalToOrdinal(size_t cardinal) { const size_t mod10 = cardinal % 10; const size_t mod100 = cardinal % 100; std::string suffix; if (mod10 == 1 && mod100 != 11) suffix = "st"; else if (mod10 == 2 && mod100 != 12) suffix = "nd"; else if (mod10 == 3 && mod100 != 13) suffix = "rd"; else suffix = "th"; return ToString(cardinal) + suffix; } std::pair SplitFlagArgs(const std::string& flag) { if (flag.size() < 2) return make_pair(flag, std::string()); // Detect the last dash before the pass name. Since we have to // handle single dash options (-O and -Os), count up to two dashes. size_t dash_ix = 0; if (flag[0] == '-' && flag[1] == '-') dash_ix = 2; else if (flag[0] == '-') dash_ix = 1; size_t ix = flag.find('='); return (ix != std::string::npos) ? make_pair(flag.substr(dash_ix, ix - 2), flag.substr(ix + 1)) : make_pair(flag.substr(dash_ix), std::string()); } } // namespace utils } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/util/string_utils.h000066400000000000000000000110421475742701700237030ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_UTIL_STRING_UTILS_H_ #define SOURCE_UTIL_STRING_UTILS_H_ #include #include #include #include #include #include "source/util/string_utils.h" namespace spvtools { namespace utils { // Converts arithmetic value |val| to its default string representation. template std::string ToString(T val) { static_assert( std::is_arithmetic::value, "spvtools::utils::ToString is restricted to only arithmetic values"); std::stringstream os; os << val; return os.str(); } // Converts cardinal number to ordinal number string. std::string CardinalToOrdinal(size_t cardinal); // Splits the string |flag|, of the form '--pass_name[=pass_args]' into two // strings "pass_name" and "pass_args". If |flag| has no arguments, the second // string will be empty. std::pair SplitFlagArgs(const std::string& flag); // Encodes a string as a sequence of words, using the SPIR-V encoding, appending // to an existing vector. inline void AppendToVector(const std::string& input, std::vector* result) { uint32_t word = 0; size_t num_bytes = input.size(); // SPIR-V strings are null-terminated. The byte_index == num_bytes // case is used to push the terminating null byte. for (size_t byte_index = 0; byte_index <= num_bytes; byte_index++) { const auto new_byte = (byte_index < num_bytes ? uint8_t(input[byte_index]) : uint8_t(0)); word |= (new_byte << (8 * (byte_index % sizeof(uint32_t)))); if (3 == (byte_index % sizeof(uint32_t))) { result->push_back(word); word = 0; } } // Emit a trailing partial word. if ((num_bytes + 1) % sizeof(uint32_t)) { result->push_back(word); } } // Encodes a string as a sequence of words, using the SPIR-V encoding. inline std::vector MakeVector(const std::string& input) { std::vector result; AppendToVector(input, &result); return result; } // Decode a string from a sequence of words between first and last, using the // SPIR-V encoding. Assert that a terminating 0-byte was found (unless // assert_found_terminating_null is passed as false). template inline std::string MakeString(InputIt first, InputIt last, bool assert_found_terminating_null = true) { std::string result; constexpr size_t kCharsPerWord = sizeof(*first); static_assert(kCharsPerWord == 4, "expect 4-byte word"); for (InputIt pos = first; pos != last; ++pos) { uint32_t word = *pos; for (size_t byte_index = 0; byte_index < kCharsPerWord; byte_index++) { uint32_t extracted_word = (word >> (8 * byte_index)) & 0xFF; char c = static_cast(extracted_word); if (c == 0) { return result; } result += c; } } assert(!assert_found_terminating_null && "Did not find terminating null for the string."); (void)assert_found_terminating_null; /* No unused parameters in release builds. */ return result; } // Decode a string from a sequence of words in a vector, using the SPIR-V // encoding. template inline std::string MakeString(const VectorType& words, bool assert_found_terminating_null = true) { return MakeString(words.cbegin(), words.cend(), assert_found_terminating_null); } // Decode a string from array words, consuming up to count words, using the // SPIR-V encoding. inline std::string MakeString(const uint32_t* words, size_t num_words, bool assert_found_terminating_null = true) { return MakeString(words, words + num_words, assert_found_terminating_null); } // Check if str starts with prefix (only included since C++20) inline bool starts_with(const std::string& str, const char* prefix) { return 0 == str.compare(0, std::strlen(prefix), prefix); } } // namespace utils } // namespace spvtools #endif // SOURCE_UTIL_STRING_UTILS_H_ KhronosGroup-SPIRV-Tools-f289d04/source/util/timer.cpp000066400000000000000000000065411475742701700226400ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #if defined(SPIRV_TIMER_ENABLED) #include "source/util/timer.h" #include #include #include #include #include namespace spvtools { namespace utils { void PrintTimerDescription(std::ostream* out, bool measure_mem_usage) { if (out) { *out << std::setw(30) << "PASS name" << std::setw(12) << "CPU time" << std::setw(12) << "WALL time" << std::setw(12) << "USR time" << std::setw(12) << "SYS time"; if (measure_mem_usage) { *out << std::setw(12) << "RSS delta" << std::setw(16) << "PGFault delta"; } *out << std::endl; } } // Do not change the order of invoking system calls. We want to make CPU/Wall // time correct as much as possible. Calling functions to get CPU/Wall time must // closely surround the target code of measuring. void Timer::Start() { if (report_stream_) { if (getrusage(RUSAGE_SELF, &usage_before_) == -1) usage_status_ |= kGetrusageFailed; if (clock_gettime(CLOCK_MONOTONIC, &wall_before_) == -1) usage_status_ |= kClockGettimeWalltimeFailed; if (clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &cpu_before_) == -1) usage_status_ |= kClockGettimeCPUtimeFailed; } } // The order of invoking system calls is important with the same reason as // Timer::Start(). void Timer::Stop() { if (report_stream_ && usage_status_ == kSucceeded) { if (clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &cpu_after_) == -1) usage_status_ |= kClockGettimeCPUtimeFailed; if (clock_gettime(CLOCK_MONOTONIC, &wall_after_) == -1) usage_status_ |= kClockGettimeWalltimeFailed; if (getrusage(RUSAGE_SELF, &usage_after_) == -1) usage_status_ = kGetrusageFailed; } } void Timer::Report(const char* tag) { if (!report_stream_) return; report_stream_->precision(2); *report_stream_ << std::fixed << std::setw(30) << tag; if (usage_status_ & kClockGettimeCPUtimeFailed) *report_stream_ << std::setw(12) << "Failed"; else *report_stream_ << std::setw(12) << CPUTime(); if (usage_status_ & kClockGettimeWalltimeFailed) *report_stream_ << std::setw(12) << "Failed"; else *report_stream_ << std::setw(12) << WallTime(); if (usage_status_ & kGetrusageFailed) { *report_stream_ << std::setw(12) << "Failed" << std::setw(12) << "Failed"; if (measure_mem_usage_) { *report_stream_ << std::setw(12) << "Failed" << std::setw(12) << "Failed"; } } else { *report_stream_ << std::setw(12) << UserTime() << std::setw(12) << SystemTime(); if (measure_mem_usage_) { *report_stream_ << std::fixed << std::setw(12) << RSS() << std::setw(16) << PageFault(); } } *report_stream_ << std::endl; } } // namespace utils } // namespace spvtools #endif // defined(SPIRV_TIMER_ENABLED) KhronosGroup-SPIRV-Tools-f289d04/source/util/timer.h000066400000000000000000000345071475742701700223100ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Contains utils for getting resource utilization #ifndef SOURCE_UTIL_TIMER_H_ #define SOURCE_UTIL_TIMER_H_ #if defined(SPIRV_TIMER_ENABLED) #include #include #include // A macro to call spvtools::utils::PrintTimerDescription(std::ostream*, bool). // The first argument must be given as std::ostream*. If it is NULL, the // function does nothing. Otherwise, it prints resource types measured by Timer // class. The second is optional and if it is true, the function also prints // resource type fields related to memory. Otherwise, it does not print memory // related fields. Its default is false. In usual, this must be placed before // calling Timer::Report() to inform what those fields printed by // Timer::Report() indicate (or spvtools::utils::PrintTimerDescription() must be // used instead). #define SPIRV_TIMER_DESCRIPTION(...) \ spvtools::utils::PrintTimerDescription(__VA_ARGS__) // Creates an object of ScopedTimer to measure the resource utilization for the // scope surrounding it as the following example: // // { // <-- beginning of this scope // // /* ... code out of interest ... */ // // SPIRV_TIMER_SCOPED(std::cout, tag); // // /* ... lines of code that we want to know its resource usage ... */ // // } // <-- end of this scope. The destructor of ScopedTimer prints tag and // the resource utilization to std::cout. #define SPIRV_TIMER_SCOPED(...) \ spvtools::utils::ScopedTimer timer##__LINE__( \ __VA_ARGS__) namespace spvtools { namespace utils { // Prints the description of resource types measured by Timer class. If |out| is // NULL, it does nothing. Otherwise, it prints resource types. The second is // optional and if it is true, the function also prints resource type fields // related to memory. Its default is false. In usual, this must be placed before // calling Timer::Report() to inform what those fields printed by // Timer::Report() indicate. void PrintTimerDescription(std::ostream*, bool = false); // Status of Timer. kGetrusageFailed means it failed in calling getrusage(). // kClockGettimeWalltimeFailed means it failed in getting wall time when calling // clock_gettime(). kClockGettimeCPUtimeFailed means it failed in getting CPU // time when calling clock_gettime(). enum UsageStatus { kSucceeded = 0, kGetrusageFailed = 1 << 0, kClockGettimeWalltimeFailed = 1 << 1, kClockGettimeCPUtimeFailed = 1 << 2, }; // Timer measures the resource utilization for a range of code. The resource // utilization consists of CPU time (i.e., process time), WALL time (elapsed // time), USR time, SYS time, RSS delta, and the delta of the number of page // faults. RSS delta and the delta of the number of page faults are measured // only when |measure_mem_usage| given to the constructor is true. This class // should be used as the following example: // // spvtools::utils::Timer timer(std::cout); // timer.Start(); // <-- set |usage_before_|, |wall_before_|, // and |cpu_before_| // // /* ... lines of code that we want to know its resource usage ... */ // // timer.Stop(); // <-- set |cpu_after_|, |wall_after_|, and // |usage_after_| // timer.Report(tag); // <-- print tag and the resource utilization to // std::cout. class Timer { public: Timer(std::ostream* out, bool measure_mem_usage = false) : report_stream_(out), usage_status_(kSucceeded), measure_mem_usage_(measure_mem_usage) {} // Sets |usage_before_|, |wall_before_|, and |cpu_before_| as results of // getrusage(), clock_gettime() for the wall time, and clock_gettime() for the // CPU time respectively. Note that this method erases all previous state of // |usage_before_|, |wall_before_|, |cpu_before_|. virtual void Start(); // Sets |cpu_after_|, |wall_after_|, and |usage_after_| as results of // clock_gettime() for the wall time, and clock_gettime() for the CPU time, // getrusage() respectively. Note that this method erases all previous state // of |cpu_after_|, |wall_after_|, |usage_after_|. virtual void Stop(); // If |report_stream_| is NULL, it does nothing. Otherwise, it prints the // resource utilization (i.e., CPU/WALL/USR/SYS time, RSS delta) between the // time of calling Timer::Start() and the time of calling Timer::Stop(). If we // cannot get a resource usage because of failures, it prints "Failed" instead // for the resource. void Report(const char* tag); // Returns the measured CPU Time (i.e., process time) for a range of code // execution. If kClockGettimeCPUtimeFailed is set by the failure of calling // clock_gettime(), it returns -1. virtual double CPUTime() { if (usage_status_ & kClockGettimeCPUtimeFailed) return -1; return TimeDifference(cpu_before_, cpu_after_); } // Returns the measured Wall Time (i.e., elapsed time) for a range of code // execution. If kClockGettimeWalltimeFailed is set by the failure of // calling clock_gettime(), it returns -1. virtual double WallTime() { if (usage_status_ & kClockGettimeWalltimeFailed) return -1; return TimeDifference(wall_before_, wall_after_); } // Returns the measured USR Time for a range of code execution. If // kGetrusageFailed is set because of the failure of calling getrusage(), it // returns -1. virtual double UserTime() { if (usage_status_ & kGetrusageFailed) return -1; return TimeDifference(usage_before_.ru_utime, usage_after_.ru_utime); } // Returns the measured SYS Time for a range of code execution. If // kGetrusageFailed is set because of the failure of calling getrusage(), it // returns -1. virtual double SystemTime() { if (usage_status_ & kGetrusageFailed) return -1; return TimeDifference(usage_before_.ru_stime, usage_after_.ru_stime); } // Returns the measured RSS delta for a range of code execution. If // kGetrusageFailed is set because of the failure of calling getrusage(), it // returns -1. virtual long RSS() const { if (usage_status_ & kGetrusageFailed) return -1; return usage_after_.ru_maxrss - usage_before_.ru_maxrss; } // Returns the measured the delta of the number of page faults for a range of // code execution. If kGetrusageFailed is set because of the failure of // calling getrusage(), it returns -1. virtual long PageFault() const { if (usage_status_ & kGetrusageFailed) return -1; return (usage_after_.ru_minflt - usage_before_.ru_minflt) + (usage_after_.ru_majflt - usage_before_.ru_majflt); } virtual ~Timer() {} private: // Returns the time gap between |from| and |to| in seconds. static double TimeDifference(const timeval& from, const timeval& to) { assert((to.tv_sec > from.tv_sec) || (to.tv_sec == from.tv_sec && to.tv_usec >= from.tv_usec)); return static_cast(to.tv_sec - from.tv_sec) + static_cast(to.tv_usec - from.tv_usec) * .000001; } // Returns the time gap between |from| and |to| in seconds. static double TimeDifference(const timespec& from, const timespec& to) { assert((to.tv_sec > from.tv_sec) || (to.tv_sec == from.tv_sec && to.tv_nsec >= from.tv_nsec)); return static_cast(to.tv_sec - from.tv_sec) + static_cast(to.tv_nsec - from.tv_nsec) * .000000001; } // Output stream to print out the resource utilization. If it is NULL, // Report() does nothing. std::ostream* report_stream_; // Status to stop measurement if a system call returns an error. unsigned usage_status_; // Variable to save the result of clock_gettime(CLOCK_PROCESS_CPUTIME_ID) when // Timer::Start() is called. It is used as the base status of CPU time. timespec cpu_before_; // Variable to save the result of clock_gettime(CLOCK_MONOTONIC) when // Timer::Start() is called. It is used as the base status of WALL time. timespec wall_before_; // Variable to save the result of getrusage() when Timer::Start() is called. // It is used as the base status of USR time, SYS time, and RSS. rusage usage_before_; // Variable to save the result of clock_gettime(CLOCK_PROCESS_CPUTIME_ID) when // Timer::Stop() is called. It is used as the last status of CPU time. The // resource usage is measured by subtracting |cpu_before_| from it. timespec cpu_after_; // Variable to save the result of clock_gettime(CLOCK_MONOTONIC) when // Timer::Stop() is called. It is used as the last status of WALL time. The // resource usage is measured by subtracting |wall_before_| from it. timespec wall_after_; // Variable to save the result of getrusage() when Timer::Stop() is called. It // is used as the last status of USR time, SYS time, and RSS. Those resource // usages are measured by subtracting |usage_before_| from it. rusage usage_after_; // If true, Timer reports the memory usage information too. Otherwise, Timer // reports only USR time, WALL time, SYS time. bool measure_mem_usage_; }; // The purpose of ScopedTimer is to measure the resource utilization for a // scope. Simply creating a local variable of ScopedTimer will call // Timer::Start() and it calls Timer::Stop() and Timer::Report() at the end of // the scope by its destructor. When we use this class, we must choose the // proper Timer class (for class TimerType template) in advance. This class // should be used as the following example: // // { // <-- beginning of this scope // // /* ... code out of interest ... */ // // spvtools::utils::ScopedTimer // scopedtimer(std::cout, tag); // // /* ... lines of code that we want to know its resource usage ... */ // // } // <-- end of this scope. The destructor of ScopedTimer prints tag and // the resource utilization to std::cout. // // The template is used to choose a Timer class. Currently, // only options for the Timer class are Timer and MockTimer in the unit test. template class ScopedTimer { public: ScopedTimer(std::ostream* out, const char* tag, bool measure_mem_usage = false) : timer(new TimerType(out, measure_mem_usage)), tag_(tag) { timer->Start(); } // At the end of the scope surrounding the instance of this class, this // destructor saves the last status of resource usage and reports it. virtual ~ScopedTimer() { timer->Stop(); timer->Report(tag_); delete timer; } private: // Actual timer that measures the resource utilization. It must be an instance // of Timer class if there is no special reason to use other class. TimerType* timer; // A tag that will be printed in front of the trace reported by Timer class. const char* tag_; }; // CumulativeTimer is the same as Timer class, but it supports a cumulative // measurement as the following example: // // CumulativeTimer *ctimer = new CumulativeTimer(std::cout); // ctimer->Start(); // // /* ... lines of code that we want to know its resource usage ... */ // // ctimer->Stop(); // // /* ... code out of interest ... */ // // ctimer->Start(); // // /* ... lines of code that we want to know its resource usage ... */ // // ctimer->Stop(); // ctimer->Report(tag); // delete ctimer; // class CumulativeTimer : public Timer { public: CumulativeTimer(std::ostream* out, bool measure_mem_usage = false) : Timer(out, measure_mem_usage), cpu_time_(0), wall_time_(0), usr_time_(0), sys_time_(0), rss_(0), pgfaults_(0) {} // If we cannot get a resource usage because of failures, it sets -1 for the // resource usage. void Stop() override { Timer::Stop(); if (cpu_time_ >= 0 && Timer::CPUTime() >= 0) cpu_time_ += Timer::CPUTime(); else cpu_time_ = -1; if (wall_time_ >= 0 && Timer::WallTime() >= 0) wall_time_ += Timer::WallTime(); else wall_time_ = -1; if (usr_time_ >= 0 && Timer::UserTime() >= 0) usr_time_ += Timer::UserTime(); else usr_time_ = -1; if (sys_time_ >= 0 && Timer::SystemTime() >= 0) sys_time_ += Timer::SystemTime(); else sys_time_ = -1; if (rss_ >= 0 && Timer::RSS() >= 0) rss_ += Timer::RSS(); else rss_ = -1; if (pgfaults_ >= 0 && Timer::PageFault() >= 0) pgfaults_ += Timer::PageFault(); else pgfaults_ = -1; } // Returns the cumulative CPU Time (i.e., process time) for a range of code // execution. double CPUTime() override { return cpu_time_; } // Returns the cumulative Wall Time (i.e., elapsed time) for a range of code // execution. double WallTime() override { return wall_time_; } // Returns the cumulative USR Time for a range of code execution. double UserTime() override { return usr_time_; } // Returns the cumulative SYS Time for a range of code execution. double SystemTime() override { return sys_time_; } // Returns the cumulative RSS delta for a range of code execution. long RSS() const override { return rss_; } // Returns the cumulative delta of number of page faults for a range of code // execution. long PageFault() const override { return pgfaults_; } private: // Variable to save the cumulative CPU time (i.e., process time). double cpu_time_; // Variable to save the cumulative wall time (i.e., elapsed time). double wall_time_; // Variable to save the cumulative user time. double usr_time_; // Variable to save the cumulative system time. double sys_time_; // Variable to save the cumulative RSS delta. long rss_; // Variable to save the cumulative delta of the number of page faults. long pgfaults_; }; } // namespace utils } // namespace spvtools #else // defined(SPIRV_TIMER_ENABLED) #define SPIRV_TIMER_DESCRIPTION(...) #define SPIRV_TIMER_SCOPED(...) #endif // defined(SPIRV_TIMER_ENABLED) #endif // SOURCE_UTIL_TIMER_H_ KhronosGroup-SPIRV-Tools-f289d04/source/val/000077500000000000000000000000001475742701700206135ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/val/basic_block.cpp000066400000000000000000000133411475742701700235540ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/val/basic_block.h" #include #include namespace spvtools { namespace val { BasicBlock::BasicBlock(uint32_t label_id) : id_(label_id), immediate_dominator_(nullptr), immediate_structural_dominator_(nullptr), immediate_structural_post_dominator_(nullptr), predecessors_(), successors_(), type_(0), reachable_(false), structurally_reachable_(false), label_(nullptr), terminator_(nullptr) {} void BasicBlock::SetImmediateDominator(BasicBlock* dom_block) { immediate_dominator_ = dom_block; } void BasicBlock::SetImmediateStructuralDominator(BasicBlock* dom_block) { immediate_structural_dominator_ = dom_block; } void BasicBlock::SetImmediateStructuralPostDominator(BasicBlock* pdom_block) { immediate_structural_post_dominator_ = pdom_block; } const BasicBlock* BasicBlock::immediate_dominator() const { return immediate_dominator_; } const BasicBlock* BasicBlock::immediate_structural_dominator() const { return immediate_structural_dominator_; } const BasicBlock* BasicBlock::immediate_structural_post_dominator() const { return immediate_structural_post_dominator_; } BasicBlock* BasicBlock::immediate_dominator() { return immediate_dominator_; } BasicBlock* BasicBlock::immediate_structural_dominator() { return immediate_structural_dominator_; } BasicBlock* BasicBlock::immediate_structural_post_dominator() { return immediate_structural_post_dominator_; } void BasicBlock::RegisterSuccessors( const std::vector& next_blocks) { for (auto& block : next_blocks) { block->predecessors_.push_back(this); successors_.push_back(block); // Register structural successors/predecessors too. block->structural_predecessors_.push_back(this); structural_successors_.push_back(block); } } bool BasicBlock::dominates(const BasicBlock& other) const { return (this == &other) || !(other.dom_end() == std::find(other.dom_begin(), other.dom_end(), this)); } bool BasicBlock::structurally_dominates(const BasicBlock& other) const { return (this == &other) || !(other.structural_dom_end() == std::find(other.structural_dom_begin(), other.structural_dom_end(), this)); } bool BasicBlock::structurally_postdominates(const BasicBlock& other) const { return (this == &other) || !(other.structural_pdom_end() == std::find(other.structural_pdom_begin(), other.structural_pdom_end(), this)); } BasicBlock::DominatorIterator::DominatorIterator() : current_(nullptr) {} BasicBlock::DominatorIterator::DominatorIterator( const BasicBlock* block, std::function dominator_func) : current_(block), dom_func_(dominator_func) {} BasicBlock::DominatorIterator& BasicBlock::DominatorIterator::operator++() { if (current_ == dom_func_(current_)) { current_ = nullptr; } else { current_ = dom_func_(current_); } return *this; } const BasicBlock::DominatorIterator BasicBlock::dom_begin() const { return DominatorIterator( this, [](const BasicBlock* b) { return b->immediate_dominator(); }); } BasicBlock::DominatorIterator BasicBlock::dom_begin() { return DominatorIterator( this, [](const BasicBlock* b) { return b->immediate_dominator(); }); } const BasicBlock::DominatorIterator BasicBlock::dom_end() const { return DominatorIterator(); } BasicBlock::DominatorIterator BasicBlock::dom_end() { return DominatorIterator(); } const BasicBlock::DominatorIterator BasicBlock::structural_dom_begin() const { return DominatorIterator(this, [](const BasicBlock* b) { return b->immediate_structural_dominator(); }); } BasicBlock::DominatorIterator BasicBlock::structural_dom_begin() { return DominatorIterator(this, [](const BasicBlock* b) { return b->immediate_structural_dominator(); }); } const BasicBlock::DominatorIterator BasicBlock::structural_dom_end() const { return DominatorIterator(); } BasicBlock::DominatorIterator BasicBlock::structural_dom_end() { return DominatorIterator(); } const BasicBlock::DominatorIterator BasicBlock::structural_pdom_begin() const { return DominatorIterator(this, [](const BasicBlock* b) { return b->immediate_structural_post_dominator(); }); } BasicBlock::DominatorIterator BasicBlock::structural_pdom_begin() { return DominatorIterator(this, [](const BasicBlock* b) { return b->immediate_structural_post_dominator(); }); } const BasicBlock::DominatorIterator BasicBlock::structural_pdom_end() const { return DominatorIterator(); } BasicBlock::DominatorIterator BasicBlock::structural_pdom_end() { return DominatorIterator(); } bool operator==(const BasicBlock::DominatorIterator& lhs, const BasicBlock::DominatorIterator& rhs) { return lhs.current_ == rhs.current_; } bool operator!=(const BasicBlock::DominatorIterator& lhs, const BasicBlock::DominatorIterator& rhs) { return !(lhs == rhs); } const BasicBlock*& BasicBlock::DominatorIterator::operator*() { return current_; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/basic_block.h000066400000000000000000000252161475742701700232250ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_VAL_BASIC_BLOCK_H_ #define SOURCE_VAL_BASIC_BLOCK_H_ #include #include #include #include #include #include "source/latest_version_spirv_header.h" namespace spvtools { namespace val { enum BlockType : uint32_t { kBlockTypeUndefined, kBlockTypeSelection, kBlockTypeLoop, kBlockTypeMerge, kBlockTypeBreak, kBlockTypeContinue, kBlockTypeReturn, kBlockTypeCOUNT ///< Total number of block types. (must be the last element) }; class Instruction; // This class represents a basic block in a SPIR-V module class BasicBlock { public: /// Constructor for a BasicBlock /// /// @param[in] id The ID of the basic block explicit BasicBlock(uint32_t id); /// Returns the id of the BasicBlock uint32_t id() const { return id_; } /// Returns the predecessors of the BasicBlock const std::vector* predecessors() const { return &predecessors_; } /// Returns the predecessors of the BasicBlock std::vector* predecessors() { return &predecessors_; } /// Returns the successors of the BasicBlock const std::vector* successors() const { return &successors_; } /// Returns the successors of the BasicBlock std::vector* successors() { return &successors_; } /// Returns the structural successors of the BasicBlock std::vector* structural_predecessors() { return &structural_predecessors_; } /// Returns the structural predecessors of the BasicBlock const std::vector* structural_predecessors() const { return &structural_predecessors_; } /// Returns the structural successors of the BasicBlock std::vector* structural_successors() { return &structural_successors_; } /// Returns the structural predecessors of the BasicBlock const std::vector* structural_successors() const { return &structural_successors_; } /// Returns true if the block is reachable in the CFG. bool reachable() const { return reachable_; } /// Returns true if the block is structurally reachable in the CFG. bool structurally_reachable() const { return structurally_reachable_; } /// Returns true if BasicBlock is of the given type bool is_type(BlockType type) const { if (type == kBlockTypeUndefined) return type_.none(); return type_.test(type); } /// Sets the reachability of the basic block in the CFG void set_reachable(bool reachability) { reachable_ = reachability; } /// Sets the structural reachability of the basic block in the CFG void set_structurally_reachable(bool reachability) { structurally_reachable_ = reachability; } /// Sets the type of the BasicBlock void set_type(BlockType type) { if (type == kBlockTypeUndefined) type_.reset(); else type_.set(type); } /// Sets the immediate dominator of this basic block /// /// @param[in] dom_block The dominator block void SetImmediateDominator(BasicBlock* dom_block); /// Sets the immediate dominator of this basic block /// /// @param[in] dom_block The dominator block void SetImmediateStructuralDominator(BasicBlock* dom_block); /// Sets the immediate post dominator of this basic block /// /// @param[in] pdom_block The post dominator block void SetImmediateStructuralPostDominator(BasicBlock* pdom_block); /// Returns the immediate dominator of this basic block BasicBlock* immediate_dominator(); /// Returns the immediate dominator of this basic block const BasicBlock* immediate_dominator() const; /// Returns the immediate dominator of this basic block BasicBlock* immediate_structural_dominator(); /// Returns the immediate dominator of this basic block const BasicBlock* immediate_structural_dominator() const; /// Returns the immediate post dominator of this basic block BasicBlock* immediate_structural_post_dominator(); /// Returns the immediate post dominator of this basic block const BasicBlock* immediate_structural_post_dominator() const; /// Returns the label instruction for the block, or nullptr if not set. const Instruction* label() const { return label_; } //// Registers the label instruction for the block. void set_label(const Instruction* t) { label_ = t; } /// Registers the terminator instruction for the block. void set_terminator(const Instruction* t) { terminator_ = t; } /// Returns the terminator instruction for the block. const Instruction* terminator() const { return terminator_; } /// Adds @p next BasicBlocks as successors of this BasicBlock void RegisterSuccessors( const std::vector& next = std::vector()); /// Returns true if the id of the BasicBlock matches bool operator==(const BasicBlock& other) const { return other.id_ == id_; } /// Returns true if the id of the BasicBlock matches bool operator==(const uint32_t& other_id) const { return other_id == id_; } /// Returns true if this block dominates the other block. /// Assumes dominators have been computed. bool dominates(const BasicBlock& other) const; /// Returns true if this block structurally dominates the other block. /// Assumes structural dominators have been computed. bool structurally_dominates(const BasicBlock& other) const; /// Returns true if this block structurally postdominates the other block. /// Assumes structural dominators have been computed. bool structurally_postdominates(const BasicBlock& other) const; void RegisterStructuralSuccessor(BasicBlock* block) { block->structural_predecessors_.push_back(this); structural_successors_.push_back(block); } /// @brief A BasicBlock dominator iterator class /// /// This iterator will iterate over the (post)dominators of the block class DominatorIterator { public: using iterator_category = std::forward_iterator_tag; using value_type = BasicBlock*; using pointer = value_type*; using reference = value_type&; using difference_type = std::ptrdiff_t; /// @brief Constructs the end of dominator iterator /// /// This will create an iterator which will represent the element /// before the root node of the dominator tree DominatorIterator(); /// @brief Constructs an iterator for the given block which points to /// @p block /// /// @param block The block which is referenced by the iterator /// @param dominator_func This function will be called to get the immediate /// (post)dominator of the current block DominatorIterator( const BasicBlock* block, std::function dominator_func); /// @brief Advances the iterator DominatorIterator& operator++(); /// @brief Returns the current element const BasicBlock*& operator*(); friend bool operator==(const DominatorIterator& lhs, const DominatorIterator& rhs); private: const BasicBlock* current_; std::function dom_func_; }; /// Returns a dominator iterator which points to the current block const DominatorIterator dom_begin() const; /// Returns a dominator iterator which points to the current block DominatorIterator dom_begin(); /// Returns a dominator iterator which points to one element past the first /// block const DominatorIterator dom_end() const; /// Returns a dominator iterator which points to one element past the first /// block DominatorIterator dom_end(); /// Returns a dominator iterator which points to the current block const DominatorIterator structural_dom_begin() const; /// Returns a dominator iterator which points to the current block DominatorIterator structural_dom_begin(); /// Returns a dominator iterator which points to one element past the first /// block const DominatorIterator structural_dom_end() const; /// Returns a dominator iterator which points to one element past the first /// block DominatorIterator structural_dom_end(); /// Returns a post dominator iterator which points to the current block const DominatorIterator structural_pdom_begin() const; /// Returns a post dominator iterator which points to the current block DominatorIterator structural_pdom_begin(); /// Returns a post dominator iterator which points to one element past the /// last block const DominatorIterator structural_pdom_end() const; /// Returns a post dominator iterator which points to one element past the /// last block DominatorIterator structural_pdom_end(); private: /// Id of the BasicBlock const uint32_t id_; /// Pointer to the immediate dominator of the BasicBlock BasicBlock* immediate_dominator_; /// Pointer to the immediate structural dominator of the BasicBlock BasicBlock* immediate_structural_dominator_; /// Pointer to the immediate structural post dominator of the BasicBlock BasicBlock* immediate_structural_post_dominator_; /// The set of predecessors of the BasicBlock std::vector predecessors_; /// The set of successors of the BasicBlock std::vector successors_; /// The type of the block std::bitset type_; /// True if the block is reachable in the CFG bool reachable_; /// True if the block is structurally reachable in the CFG bool structurally_reachable_; /// label of this block, if any. const Instruction* label_; /// Terminator of this block. const Instruction* terminator_; std::vector structural_predecessors_; std::vector structural_successors_; }; /// @brief Returns true if the iterators point to the same element or if both /// iterators point to the @p dom_end block bool operator==(const BasicBlock::DominatorIterator& lhs, const BasicBlock::DominatorIterator& rhs); /// @brief Returns true if the iterators point to different elements and they /// do not both point to the @p dom_end block bool operator!=(const BasicBlock::DominatorIterator& lhs, const BasicBlock::DominatorIterator& rhs); } // namespace val } // namespace spvtools #endif // SOURCE_VAL_BASIC_BLOCK_H_ KhronosGroup-SPIRV-Tools-f289d04/source/val/construct.cpp000066400000000000000000000174241475742701700233530ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/val/construct.h" #include #include #include "source/val/function.h" #include "source/val/validation_state.h" namespace spvtools { namespace val { Construct::Construct(ConstructType construct_type, BasicBlock* entry, BasicBlock* exit, std::vector constructs) : type_(construct_type), corresponding_constructs_(constructs), entry_block_(entry), exit_block_(exit) {} ConstructType Construct::type() const { return type_; } const std::vector& Construct::corresponding_constructs() const { return corresponding_constructs_; } std::vector& Construct::corresponding_constructs() { return corresponding_constructs_; } bool ValidateConstructSize(ConstructType type, size_t size) { switch (type) { case ConstructType::kSelection: return size == 0; case ConstructType::kContinue: return size == 1; case ConstructType::kLoop: return size == 1; case ConstructType::kCase: return size >= 1; default: assert(1 == 0 && "Type not defined"); } return false; } void Construct::set_corresponding_constructs( std::vector constructs) { assert(ValidateConstructSize(type_, constructs.size())); corresponding_constructs_ = constructs; } const BasicBlock* Construct::entry_block() const { return entry_block_; } BasicBlock* Construct::entry_block() { return entry_block_; } const BasicBlock* Construct::exit_block() const { return exit_block_; } BasicBlock* Construct::exit_block() { return exit_block_; } void Construct::set_exit(BasicBlock* block) { exit_block_ = block; } Construct::ConstructBlockSet Construct::blocks(Function* /*function*/) const { const auto header = entry_block(); const auto exit = exit_block(); const bool is_continue = type() == ConstructType::kContinue; const bool is_loop = type() == ConstructType::kLoop; const BasicBlock* continue_header = nullptr; if (is_loop) { // The only corresponding construct for a loop is the continue. continue_header = (*corresponding_constructs().begin())->entry_block(); } std::vector stack; stack.push_back(const_cast(header)); ConstructBlockSet construct_blocks; while (!stack.empty()) { auto* block = stack.back(); stack.pop_back(); if (header->structurally_dominates(*block)) { bool include = false; if (is_continue && exit->structurally_postdominates(*block)) { // Continue construct include blocks dominated by the continue target // and post-dominated by the back-edge block. include = true; } else if (!exit->structurally_dominates(*block)) { // Selection and loop constructs include blocks dominated by the header // and not dominated by the merge. include = true; if (is_loop && continue_header->structurally_dominates(*block)) { // Loop constructs have an additional constraint that they do not // include blocks dominated by the continue construct. Since all // blocks in the continue construct are dominated by the continue // target, we just test for dominance by continue target. include = false; } } if (include) { if (!construct_blocks.insert(block).second) continue; for (auto succ : *block->structural_successors()) { stack.push_back(succ); } } } } return construct_blocks; } bool Construct::IsStructuredExit(ValidationState_t& _, BasicBlock* dest) const { // Structured Exits: // - Selection: // - branch to its merge // - branch to nearest enclosing loop merge or continue // - branch to nearest enclosing switch selection merge // - Loop: // - branch to its merge // - branch to its continue // - Continue: // - branch to loop header // - branch to loop merge // // Note: we will never see a case construct here. assert(type() != ConstructType::kCase); if (type() == ConstructType::kLoop) { auto header = entry_block(); auto terminator = header->terminator(); auto index = terminator - &_.ordered_instructions()[0]; auto merge_inst = &_.ordered_instructions()[index - 1]; auto merge_block_id = merge_inst->GetOperandAs(0u); auto continue_block_id = merge_inst->GetOperandAs(1u); if (dest->id() == merge_block_id || dest->id() == continue_block_id) { return true; } } else if (type() == ConstructType::kContinue) { auto loop_construct = corresponding_constructs()[0]; auto header = loop_construct->entry_block(); auto terminator = header->terminator(); auto index = terminator - &_.ordered_instructions()[0]; auto merge_inst = &_.ordered_instructions()[index - 1]; auto merge_block_id = merge_inst->GetOperandAs(0u); if (dest == header || dest->id() == merge_block_id) { return true; } } else { assert(type() == ConstructType::kSelection); if (dest == exit_block()) { return true; } // The next block in the traversal is either: // i. The header block that declares |block| as its merge block. // ii. The immediate dominator of |block|. auto NextBlock = [](const BasicBlock* block) -> const BasicBlock* { for (auto& use : block->label()->uses()) { if ((use.first->opcode() == spv::Op::OpLoopMerge || use.first->opcode() == spv::Op::OpSelectionMerge) && use.second == 1 && use.first->block()->structurally_dominates(*block) && // A header likely declared itself as its merge. use.first->block() != block) { return use.first->block(); } } return block->immediate_structural_dominator(); }; bool seen_switch = false; auto header = entry_block(); auto block = NextBlock(header); while (block) { auto terminator = block->terminator(); auto index = terminator - &_.ordered_instructions()[0]; auto merge_inst = &_.ordered_instructions()[index - 1]; if (merge_inst->opcode() == spv::Op::OpLoopMerge || (header->terminator()->opcode() != spv::Op::OpSwitch && merge_inst->opcode() == spv::Op::OpSelectionMerge && terminator->opcode() == spv::Op::OpSwitch)) { auto merge_target = merge_inst->GetOperandAs(0u); auto merge_block = merge_inst->function()->GetBlock(merge_target).first; if (merge_block->structurally_dominates(*header)) { block = NextBlock(block); continue; } if ((!seen_switch || merge_inst->opcode() == spv::Op::OpLoopMerge) && dest->id() == merge_target) { return true; } else if (merge_inst->opcode() == spv::Op::OpLoopMerge) { auto continue_target = merge_inst->GetOperandAs(1u); if (dest->id() == continue_target) { return true; } } if (terminator->opcode() == spv::Op::OpSwitch) { seen_switch = true; } // Hit an enclosing loop and didn't break or continue. if (merge_inst->opcode() == spv::Op::OpLoopMerge) return false; } block = NextBlock(block); } } return false; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/construct.h000066400000000000000000000145251475742701700230170ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_VAL_CONSTRUCT_H_ #define SOURCE_VAL_CONSTRUCT_H_ #include #include #include #include "source/val/basic_block.h" namespace spvtools { namespace val { class ValidationState_t; /// Functor for ordering BasicBlocks. BasicBlock pointers must not be null. struct less_than_id { bool operator()(const BasicBlock* lhs, const BasicBlock* rhs) const { return lhs->id() < rhs->id(); } }; enum class ConstructType : int { kNone = 0, /// The set of blocks dominated by a selection header, minus the set of blocks /// dominated by the header's merge block kSelection, /// The set of blocks dominated by an OpLoopMerge's Continue Target and post /// dominated by the corresponding back kContinue, /// The set of blocks dominated by a loop header, minus the set of blocks /// dominated by the loop's merge block, minus the loop's corresponding /// continue construct kLoop, /// The set of blocks dominated by an OpSwitch's Target or Default, minus the /// set of blocks dominated by the OpSwitch's merge block (this construct is /// only defined for those OpSwitch Target or Default that are not equal to /// the OpSwitch's corresponding merge block) kCase }; class Function; /// @brief This class tracks the CFG constructs as defined in the SPIR-V spec class Construct { public: Construct(ConstructType type, BasicBlock* dominator, BasicBlock* exit = nullptr, std::vector constructs = std::vector()); /// Returns the type of the construct ConstructType type() const; const std::vector& corresponding_constructs() const; std::vector& corresponding_constructs(); void set_corresponding_constructs(std::vector constructs); /// Returns the dominator block of the construct. /// /// This is usually the header block or the first block of the construct. const BasicBlock* entry_block() const; /// Returns the dominator block of the construct. /// /// This is usually the header block or the first block of the construct. BasicBlock* entry_block(); /// Returns the exit block of the construct. /// /// For a continue construct it is the backedge block of the corresponding /// loop construct. For the case construct it is the block that branches to /// the OpSwitch merge block or other case blocks. Otherwise it is the merge /// block of the corresponding header block const BasicBlock* exit_block() const; /// Returns the exit block of the construct. /// /// For a continue construct it is the backedge block of the corresponding /// loop construct. For the case construct it is the block that branches to /// the OpSwitch merge block or other case blocks. Otherwise it is the merge /// block of the corresponding header block BasicBlock* exit_block(); /// Sets the exit block for this construct. This is useful for continue /// constructs which do not know the back-edge block during construction void set_exit(BasicBlock* exit_block); // Returns whether the exit block of this construct is the merge block // for an OpLoopMerge or OpSelectionMerge bool ExitBlockIsMergeBlock() const { return type_ == ConstructType::kLoop || type_ == ConstructType::kSelection; } using ConstructBlockSet = std::set; // Returns the basic blocks in this construct. This function should not // be called before the exit block is set and dominators have been // calculated. ConstructBlockSet blocks(Function* function) const; // Returns true if |dest| is structured exit from the construct. Structured // exits depend on the construct type. // Selection: // * branch to the associated merge // * branch to the merge or continue of the innermost loop containing the // selection // * branch to the merge block of the innermost switch containing the // selection // Loop: // * branch to the associated merge or continue // Continue: // * back-edge to the associated loop header // * branch to the associated loop merge // // Note: the validator does not generate case constructs. Switches are // checked separately from other constructs. bool IsStructuredExit(ValidationState_t& _, BasicBlock* dest) const; private: /// The type of the construct ConstructType type_; /// These are the constructs that are related to this construct. These /// constructs can be the continue construct, for the corresponding loop /// construct, the case construct that are part of the same OpSwitch /// instruction /// /// Here is a table that describes what constructs are included in /// @p corresponding_constructs_ /// | this construct | corresponding construct | /// |----------------|----------------------------------| /// | loop | continue | /// | continue | loop | /// | case | other cases in the same OpSwitch | /// /// kContinue and kLoop constructs will always have corresponding /// constructs even if they are represented by the same block std::vector corresponding_constructs_; /// @brief Dominator block for the construct /// /// The dominator block for the construct. Depending on the construct this may /// be a selection header, a continue target of a loop, a loop header or a /// Target or Default block of a switch BasicBlock* entry_block_; /// @brief Exiting block for the construct /// /// The exit block for the construct. This can be a merge block for the loop /// and selection constructs, a back-edge block for a continue construct, or /// the branching block for the case construct BasicBlock* exit_block_; }; } // namespace val } // namespace spvtools #endif // SOURCE_VAL_CONSTRUCT_H_ KhronosGroup-SPIRV-Tools-f289d04/source/val/decoration.h000066400000000000000000000102451475742701700231150ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_VAL_DECORATION_H_ #define SOURCE_VAL_DECORATION_H_ #include #include #include #include #include "source/latest_version_spirv_header.h" namespace spvtools { namespace val { // An object of this class represents a specific decoration including its // parameters (if any). Decorations are used by OpDecorate and OpMemberDecorate, // and they describe certain properties that can be assigned to one or several // s. // // A Decoration object contains the decoration type (an enum), associated // literal parameters, and struct member index. If the decoration does not apply // to a struct member, then the index is kInvalidIndex. A Decoration object does // not store the target Id, i.e. the Id to which it applies. It is // possible for the same decoration to be applied to several s (and they // might be assigned using separate SPIR-V instructions, possibly using an // assignment through GroupDecorate). // // Example 1: Decoration for an object with no parameters: // OpDecorate %obj Flat // dec_type_ = spv::Decoration::Flat // params_ = empty vector // struct_member_index_ = kInvalidMember // // Example 2: Decoration for an object with two parameters: // OpDecorate %obj LinkageAttributes "link" Import // dec_type_ = spv::Decoration::LinkageAttributes // params_ = vector { link, Import } // struct_member_index_ = kInvalidMember // // Example 3: Decoration for a member of a structure with one parameter: // OpMemberDecorate %struct 2 Offset 2 // dec_type_ = spv::Decoration::Offset // params_ = vector { 2 } // struct_member_index_ = 2 // // Example 4: Decoration for a Builtin: // OpDecorate %var BuiltIn FragDepth // dec_type_ = spv::Decoration::BuiltIn // params_ = vector { FragDepth } // struct_member_index_ = kInvalidMember // class Decoration { public: enum { kInvalidMember = -1 }; Decoration(spv::Decoration t, const std::vector& parameters = std::vector(), uint32_t member_index = kInvalidMember) : dec_type_(t), params_(parameters), struct_member_index_(member_index) {} void set_struct_member_index(uint32_t index) { struct_member_index_ = index; } int struct_member_index() const { return struct_member_index_; } spv::Decoration dec_type() const { return dec_type_; } std::vector& params() { return params_; } const std::vector& params() const { return params_; } spv::BuiltIn builtin() const { assert(dec_type_ == spv::Decoration::BuiltIn); return spv::BuiltIn(params_[0]); } inline bool operator<(const Decoration& rhs) const { // Note: Sort by struct_member_index_ first, then type, so look up can be // efficient using lower_bound() and upper_bound(). if (struct_member_index_ < rhs.struct_member_index_) return true; if (rhs.struct_member_index_ < struct_member_index_) return false; if (dec_type_ < rhs.dec_type_) return true; if (rhs.dec_type_ < dec_type_) return false; return params_ < rhs.params_; } inline bool operator==(const Decoration& rhs) const { return (dec_type_ == rhs.dec_type_ && params_ == rhs.params_ && struct_member_index_ == rhs.struct_member_index_); } private: spv::Decoration dec_type_; std::vector params_; // If the decoration applies to a member of a structure type, then the index // of the member is stored here. Otherwise, this is kInvalidIndex. int struct_member_index_; }; } // namespace val } // namespace spvtools #endif // SOURCE_VAL_DECORATION_H_ KhronosGroup-SPIRV-Tools-f289d04/source/val/function.cpp000066400000000000000000000354111475742701700231500ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/val/function.h" #include #include #include #include #include #include "source/cfa.h" #include "source/val/basic_block.h" #include "source/val/construct.h" #include "source/val/validate.h" namespace spvtools { namespace val { // Universal Limit of ResultID + 1 static const uint32_t kInvalidId = 0x400000; Function::Function(uint32_t function_id, uint32_t result_type_id, spv::FunctionControlMask function_control, uint32_t function_type_id) : id_(function_id), function_type_id_(function_type_id), result_type_id_(result_type_id), function_control_(function_control), declaration_type_(FunctionDecl::kFunctionDeclUnknown), end_has_been_registered_(false), blocks_(), current_block_(nullptr), pseudo_entry_block_(0), pseudo_exit_block_(kInvalidId), cfg_constructs_(), variable_ids_(), parameter_ids_() {} bool Function::IsFirstBlock(uint32_t block_id) const { return !ordered_blocks_.empty() && *first_block() == block_id; } spv_result_t Function::RegisterFunctionParameter(uint32_t parameter_id, uint32_t type_id) { assert(current_block_ == nullptr && "RegisterFunctionParameter can only be called when parsing the binary " "outside of a block"); // TODO(umar): Validate function parameter type order and count // TODO(umar): Use these variables to validate parameter type (void)parameter_id; (void)type_id; return SPV_SUCCESS; } spv_result_t Function::RegisterLoopMerge(uint32_t merge_id, uint32_t continue_id) { RegisterBlock(merge_id, false); RegisterBlock(continue_id, false); BasicBlock& merge_block = blocks_.at(merge_id); BasicBlock& continue_target_block = blocks_.at(continue_id); assert(current_block_ && "RegisterLoopMerge must be called when called within a block"); current_block_->RegisterStructuralSuccessor(&merge_block); current_block_->RegisterStructuralSuccessor(&continue_target_block); current_block_->set_type(kBlockTypeLoop); merge_block.set_type(kBlockTypeMerge); continue_target_block.set_type(kBlockTypeContinue); Construct& loop_construct = AddConstruct({ConstructType::kLoop, current_block_, &merge_block}); Construct& continue_construct = AddConstruct({ConstructType::kContinue, &continue_target_block}); continue_construct.set_corresponding_constructs({&loop_construct}); loop_construct.set_corresponding_constructs({&continue_construct}); merge_block_header_[&merge_block] = current_block_; if (continue_target_headers_.find(&continue_target_block) == continue_target_headers_.end()) { continue_target_headers_[&continue_target_block] = {current_block_}; } else { continue_target_headers_[&continue_target_block].push_back(current_block_); } return SPV_SUCCESS; } spv_result_t Function::RegisterSelectionMerge(uint32_t merge_id) { RegisterBlock(merge_id, false); BasicBlock& merge_block = blocks_.at(merge_id); current_block_->set_type(kBlockTypeSelection); merge_block.set_type(kBlockTypeMerge); merge_block_header_[&merge_block] = current_block_; current_block_->RegisterStructuralSuccessor(&merge_block); AddConstruct({ConstructType::kSelection, current_block(), &merge_block}); return SPV_SUCCESS; } spv_result_t Function::RegisterSetFunctionDeclType(FunctionDecl type) { assert(declaration_type_ == FunctionDecl::kFunctionDeclUnknown); declaration_type_ = type; return SPV_SUCCESS; } spv_result_t Function::RegisterBlock(uint32_t block_id, bool is_definition) { assert( declaration_type_ == FunctionDecl::kFunctionDeclDefinition && "RegisterBlocks can only be called after declaration_type_ is defined"); std::unordered_map::iterator inserted_block; bool success = false; tie(inserted_block, success) = blocks_.insert({block_id, BasicBlock(block_id)}); if (is_definition) { // new block definition assert(current_block_ == nullptr && "Register Block can only be called when parsing a binary outside of " "a BasicBlock"); undefined_blocks_.erase(block_id); current_block_ = &inserted_block->second; ordered_blocks_.push_back(current_block_); } else if (success) { // Block doesn't exist but this is not a definition undefined_blocks_.insert(block_id); } return SPV_SUCCESS; } void Function::RegisterBlockEnd(std::vector next_list) { assert( current_block_ && "RegisterBlockEnd can only be called when parsing a binary in a block"); std::vector next_blocks; next_blocks.reserve(next_list.size()); std::unordered_map::iterator inserted_block; bool success; for (uint32_t successor_id : next_list) { tie(inserted_block, success) = blocks_.insert({successor_id, BasicBlock(successor_id)}); if (success) { undefined_blocks_.insert(successor_id); } next_blocks.push_back(&inserted_block->second); } if (current_block_->is_type(kBlockTypeLoop)) { // For each loop header, record the set of its successors, and include // its continue target if the continue target is not the loop header // itself. std::vector& next_blocks_plus_continue_target = loop_header_successors_plus_continue_target_map_[current_block_]; next_blocks_plus_continue_target = next_blocks; auto continue_target = FindConstructForEntryBlock(current_block_, ConstructType::kLoop) .corresponding_constructs() .back() ->entry_block(); if (continue_target != current_block_) { next_blocks_plus_continue_target.push_back(continue_target); } } current_block_->RegisterSuccessors(next_blocks); current_block_ = nullptr; return; } void Function::RegisterFunctionEnd() { if (!end_has_been_registered_) { end_has_been_registered_ = true; ComputeAugmentedCFG(); } } size_t Function::block_count() const { return blocks_.size(); } size_t Function::undefined_block_count() const { return undefined_blocks_.size(); } const std::vector& Function::ordered_blocks() const { return ordered_blocks_; } std::vector& Function::ordered_blocks() { return ordered_blocks_; } const BasicBlock* Function::current_block() const { return current_block_; } BasicBlock* Function::current_block() { return current_block_; } const std::list& Function::constructs() const { return cfg_constructs_; } std::list& Function::constructs() { return cfg_constructs_; } const BasicBlock* Function::first_block() const { if (ordered_blocks_.empty()) return nullptr; return ordered_blocks_[0]; } BasicBlock* Function::first_block() { if (ordered_blocks_.empty()) return nullptr; return ordered_blocks_[0]; } bool Function::IsBlockType(uint32_t merge_block_id, BlockType type) const { bool ret = false; const BasicBlock* block; std::tie(block, std::ignore) = GetBlock(merge_block_id); if (block) { ret = block->is_type(type); } return ret; } std::pair Function::GetBlock(uint32_t block_id) const { const auto b = blocks_.find(block_id); if (b != end(blocks_)) { const BasicBlock* block = &(b->second); bool defined = undefined_blocks_.find(block->id()) == std::end(undefined_blocks_); return std::make_pair(block, defined); } else { return std::make_pair(nullptr, false); } } std::pair Function::GetBlock(uint32_t block_id) { const BasicBlock* out; bool defined; std::tie(out, defined) = const_cast(this)->GetBlock(block_id); return std::make_pair(const_cast(out), defined); } Function::GetBlocksFunction Function::AugmentedCFGSuccessorsFunction() const { return [this](const BasicBlock* block) { auto where = augmented_successors_map_.find(block); return where == augmented_successors_map_.end() ? block->successors() : &(*where).second; }; } Function::GetBlocksFunction Function::AugmentedCFGPredecessorsFunction() const { return [this](const BasicBlock* block) { auto where = augmented_predecessors_map_.find(block); return where == augmented_predecessors_map_.end() ? block->predecessors() : &(*where).second; }; } Function::GetBlocksFunction Function::AugmentedStructuralCFGSuccessorsFunction() const { return [this](const BasicBlock* block) { auto where = augmented_successors_map_.find(block); return where == augmented_successors_map_.end() ? block->structural_successors() : &(*where).second; }; } Function::GetBlocksFunction Function::AugmentedStructuralCFGPredecessorsFunction() const { return [this](const BasicBlock* block) { auto where = augmented_predecessors_map_.find(block); return where == augmented_predecessors_map_.end() ? block->structural_predecessors() : &(*where).second; }; } void Function::ComputeAugmentedCFG() { // Compute the successors of the pseudo-entry block, and // the predecessors of the pseudo exit block. auto succ_func = [](const BasicBlock* b) { return b->structural_successors(); }; auto pred_func = [](const BasicBlock* b) { return b->structural_predecessors(); }; CFA::ComputeAugmentedCFG( ordered_blocks_, &pseudo_entry_block_, &pseudo_exit_block_, &augmented_successors_map_, &augmented_predecessors_map_, succ_func, pred_func); } Construct& Function::AddConstruct(const Construct& new_construct) { cfg_constructs_.push_back(new_construct); auto& result = cfg_constructs_.back(); entry_block_to_construct_[std::make_pair(new_construct.entry_block(), new_construct.type())] = &result; return result; } Construct& Function::FindConstructForEntryBlock(const BasicBlock* entry_block, ConstructType type) { auto where = entry_block_to_construct_.find(std::make_pair(entry_block, type)); assert(where != entry_block_to_construct_.end()); auto construct_ptr = (*where).second; assert(construct_ptr); return *construct_ptr; } int Function::GetBlockDepth(BasicBlock* bb) { // Guard against nullptr. if (!bb) { return 0; } // Only calculate the depth if it's not already calculated. // This function uses memoization to avoid duplicate CFG depth calculations. if (block_depth_.find(bb) != block_depth_.end()) { return block_depth_[bb]; } // Avoid recursion. Something is wrong if the same block is encountered // multiple times. block_depth_[bb] = 0; BasicBlock* bb_dom = bb->immediate_dominator(); if (!bb_dom || bb == bb_dom) { // This block has no dominator, so it's at depth 0. block_depth_[bb] = 0; } else if (bb->is_type(kBlockTypeContinue)) { // This rule must precede the rule for merge blocks in order to set up // depths correctly. If a block is both a merge and continue then the merge // is nested within the continue's loop (or the graph is incorrect). // The depth of the continue block entry point is 1 + loop header depth. Construct* continue_construct = entry_block_to_construct_[std::make_pair(bb, ConstructType::kContinue)]; assert(continue_construct); // Continue construct has only 1 corresponding construct (loop header). Construct* loop_construct = continue_construct->corresponding_constructs()[0]; assert(loop_construct); BasicBlock* loop_header = loop_construct->entry_block(); // The continue target may be the loop itself (while 1). // In such cases, the depth of the continue block is: 1 + depth of the // loop's dominator block. if (loop_header == bb) { block_depth_[bb] = 1 + GetBlockDepth(bb_dom); } else { block_depth_[bb] = 1 + GetBlockDepth(loop_header); } } else if (bb->is_type(kBlockTypeMerge)) { // If this is a merge block, its depth is equal to the block before // branching. BasicBlock* header = merge_block_header_[bb]; assert(header); block_depth_[bb] = GetBlockDepth(header); } else if (bb_dom->is_type(kBlockTypeSelection) || bb_dom->is_type(kBlockTypeLoop)) { // The dominator of the given block is a header block. So, the nesting // depth of this block is: 1 + nesting depth of the header. block_depth_[bb] = 1 + GetBlockDepth(bb_dom); } else { block_depth_[bb] = GetBlockDepth(bb_dom); } return block_depth_[bb]; } void Function::RegisterExecutionModelLimitation(spv::ExecutionModel model, const std::string& message) { execution_model_limitations_.push_back( [model, message](spv::ExecutionModel in_model, std::string* out_message) { if (model != in_model) { if (out_message) { *out_message = message; } return false; } return true; }); } bool Function::IsCompatibleWithExecutionModel(spv::ExecutionModel model, std::string* reason) const { bool return_value = true; std::stringstream ss_reason; for (const auto& is_compatible : execution_model_limitations_) { std::string message; if (!is_compatible(model, &message)) { if (!reason) return false; return_value = false; if (!message.empty()) { ss_reason << message << "\n"; } } } if (!return_value && reason) { *reason = ss_reason.str(); } return return_value; } bool Function::CheckLimitations(const ValidationState_t& _, const Function* entry_point, std::string* reason) const { bool return_value = true; std::stringstream ss_reason; for (const auto& is_compatible : limitations_) { std::string message; if (!is_compatible(_, entry_point, &message)) { if (!reason) return false; return_value = false; if (!message.empty()) { ss_reason << message << "\n"; } } } if (!return_value && reason) { *reason = ss_reason.str(); } return return_value; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/function.h000066400000000000000000000400441475742701700226130ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_VAL_FUNCTION_H_ #define SOURCE_VAL_FUNCTION_H_ #include #include #include #include #include #include #include #include #include #include #include "source/latest_version_spirv_header.h" #include "source/val/basic_block.h" #include "source/val/construct.h" #include "spirv-tools/libspirv.h" namespace spvtools { namespace val { struct bb_constr_type_pair_hash { std::size_t operator()( const std::pair& p) const { auto h1 = std::hash{}(p.first); auto h2 = std::hash::type>{}( static_cast::type>(p.second)); return (h1 ^ h2); } }; enum class FunctionDecl { kFunctionDeclUnknown, /// < Unknown function declaration kFunctionDeclDeclaration, /// < Function declaration kFunctionDeclDefinition /// < Function definition }; /// This class manages all function declaration and definitions in a module. It /// handles the state and id information while parsing a function in the SPIR-V /// binary. class Function { public: Function(uint32_t id, uint32_t result_type_id, spv::FunctionControlMask function_control, uint32_t function_type_id); /// Registers a function parameter in the current function /// @return Returns SPV_SUCCESS if the call was successful spv_result_t RegisterFunctionParameter(uint32_t id, uint32_t type_id); /// Sets the declaration type of the current function /// @return Returns SPV_SUCCESS if the call was successful spv_result_t RegisterSetFunctionDeclType(FunctionDecl type); /// Registers a block in the current function. Subsequent block instructions /// will target this block /// @param id The ID of the label of the block /// @return Returns SPV_SUCCESS if the call was successful spv_result_t RegisterBlock(uint32_t id, bool is_definition = true); /// Registers a variable in the current block /// /// @param[in] type_id The type ID of the variable /// @param[in] id The ID of the variable /// @param[in] storage The storage of the variable /// @param[in] init_id The initializer ID of the variable /// /// @return Returns SPV_SUCCESS if the call was successful spv_result_t RegisterBlockVariable(uint32_t type_id, uint32_t id, spv::StorageClass storage, uint32_t init_id); /// Registers a loop merge construct in the function /// /// @param[in] merge_id The merge block ID of the loop /// @param[in] continue_id The continue block ID of the loop /// /// @return Returns SPV_SUCCESS if the call was successful spv_result_t RegisterLoopMerge(uint32_t merge_id, uint32_t continue_id); /// Registers a selection merge construct in the function /// @return Returns SPV_SUCCESS if the call was successful spv_result_t RegisterSelectionMerge(uint32_t merge_id); /// Registers the end of the block /// /// @param[in] successors_list A list of ids to the block's successors void RegisterBlockEnd(std::vector successors_list); /// Registers the end of the function. This is idempotent. void RegisterFunctionEnd(); /// Returns true if the \p id block is the first block of this function bool IsFirstBlock(uint32_t id) const; /// Returns true if the \p merge_block_id is a BlockType of \p type bool IsBlockType(uint32_t merge_block_id, BlockType type) const; /// Returns a pair consisting of the BasicBlock with \p id and a bool /// which is true if the block has been defined, and false if it is /// declared but not defined. This function will return nullptr if the /// \p id was not declared and not defined at the current point in the binary std::pair GetBlock(uint32_t id) const; std::pair GetBlock(uint32_t id); /// Returns the first block of the current function const BasicBlock* first_block() const; /// Returns the first block of the current function BasicBlock* first_block(); /// Returns a vector of all the blocks in the function const std::vector& ordered_blocks() const; /// Returns a vector of all the blocks in the function std::vector& ordered_blocks(); /// Returns a list of all the cfg constructs in the function const std::list& constructs() const; /// Returns a list of all the cfg constructs in the function std::list& constructs(); /// Returns the number of blocks in the current function being parsed size_t block_count() const; /// Returns the id of the function uint32_t id() const { return id_; } /// Returns return type id of the function uint32_t GetResultTypeId() const { return result_type_id_; } /// Returns the number of blocks in the current function being parsed size_t undefined_block_count() const; const std::unordered_set& undefined_blocks() const { return undefined_blocks_; } /// Returns the block that is currently being parsed in the binary BasicBlock* current_block(); /// Returns the block that is currently being parsed in the binary const BasicBlock* current_block() const; // For dominance calculations, we want to analyze all the // blocks in the function, even in degenerate control flow cases // including unreachable blocks. We therefore make an "augmented CFG" // which is the same as the ordinary CFG but adds: // - A pseudo-entry node. // - A pseudo-exit node. // - A minimal set of edges so that a forward traversal from the // pseudo-entry node will visit all nodes. // - A minimal set of edges so that a backward traversal from the // pseudo-exit node will visit all nodes. // In particular, the pseudo-entry node is the unique source of the // augmented CFG, and the psueo-exit node is the unique sink of the // augmented CFG. /// Returns the pseudo exit block BasicBlock* pseudo_entry_block() { return &pseudo_entry_block_; } /// Returns the pseudo exit block const BasicBlock* pseudo_entry_block() const { return &pseudo_entry_block_; } /// Returns the pseudo exit block BasicBlock* pseudo_exit_block() { return &pseudo_exit_block_; } /// Returns the pseudo exit block const BasicBlock* pseudo_exit_block() const { return &pseudo_exit_block_; } using GetBlocksFunction = std::function*(const BasicBlock*)>; /// Returns the block successors function for the augmented CFG. GetBlocksFunction AugmentedCFGSuccessorsFunction() const; /// Returns the block predecessors function for the augmented CFG. GetBlocksFunction AugmentedCFGPredecessorsFunction() const; /// Returns the block structural successors function for the augmented CFG. GetBlocksFunction AugmentedStructuralCFGSuccessorsFunction() const; /// Returns the block structural predecessors function for the augmented CFG. GetBlocksFunction AugmentedStructuralCFGPredecessorsFunction() const; /// Returns the control flow nesting depth of the given basic block. /// This function only works when you have structured control flow. /// This function should only be called after the control flow constructs have /// been identified and dominators have been computed. int GetBlockDepth(BasicBlock* bb); /// Prints a GraphViz digraph of the CFG of the current function void PrintDotGraph() const; /// Prints a directed graph of the CFG of the current function void PrintBlocks() const; /// Registers execution model limitation such as "Feature X is only available /// with Execution Model Y". void RegisterExecutionModelLimitation(spv::ExecutionModel model, const std::string& message); /// Registers execution model limitation with an |is_compatible| functor. void RegisterExecutionModelLimitation( std::function is_compatible) { execution_model_limitations_.push_back(is_compatible); } /// Registers limitation with an |is_compatible| functor. void RegisterLimitation(std::function is_compatible) { limitations_.push_back(is_compatible); } bool CheckLimitations(const ValidationState_t& _, const Function* entry_point, std::string* reason) const; /// Returns true if the given execution model passes the limitations stored in /// execution_model_limitations_. Returns false otherwise and fills optional /// |reason| parameter. bool IsCompatibleWithExecutionModel(spv::ExecutionModel model, std::string* reason = nullptr) const; // Inserts id to the set of functions called from this function. void AddFunctionCallTarget(uint32_t call_target_id) { function_call_targets_.insert(call_target_id); } // Returns a set with ids of all functions called from this function. const std::set function_call_targets() const { return function_call_targets_; } // Returns the block containing the OpSelectionMerge or OpLoopMerge that // references |merge_block|. // Values of |merge_block_header_| inserted by CFGPass, so do not call before // the first iteration of ordered instructions in // ValidateBinaryUsingContextAndValidationState has completed. BasicBlock* GetMergeHeader(BasicBlock* merge_block) { return merge_block_header_[merge_block]; } // Returns vector of the blocks containing a OpLoopMerge that references // |continue_target|. // Values of |continue_target_headers_| inserted by CFGPass, so do not call // before the first iteration of ordered instructions in // ValidateBinaryUsingContextAndValidationState has completed. std::vector GetContinueHeaders(BasicBlock* continue_target) { if (continue_target_headers_.find(continue_target) == continue_target_headers_.end()) { return {}; } return continue_target_headers_[continue_target]; } private: // Computes the representation of the augmented CFG. // Populates augmented_successors_map_ and augmented_predecessors_map_. void ComputeAugmentedCFG(); // Adds a copy of the given Construct, and tracks it by its entry block. // Returns a reference to the stored construct. Construct& AddConstruct(const Construct& new_construct); // Returns a reference to the construct corresponding to the given entry // block. Construct& FindConstructForEntryBlock(const BasicBlock* entry_block, ConstructType t); /// The result id of OpFunction uint32_t id_; /// The type of the function uint32_t function_type_id_; /// The type of the return value uint32_t result_type_id_; /// The control fo the function spv::FunctionControlMask function_control_; /// The type of declaration of each function FunctionDecl declaration_type_; // Have we finished parsing this function? bool end_has_been_registered_; /// The blocks in the function mapped by block ID std::unordered_map blocks_; /// A list of blocks in the order they appeared in the binary std::vector ordered_blocks_; /// Blocks which are forward referenced by blocks but not defined std::unordered_set undefined_blocks_; /// The block that is currently being parsed BasicBlock* current_block_; /// A pseudo entry node used in dominance analysis. /// After the function end has been registered, the successor list of the /// pseudo entry node is the minimal set of nodes such that all nodes in the /// CFG can be reached by following successor lists. That is, the successors /// will be: /// - Any basic block without predecessors. This includes the entry /// block to the function. /// - A single node from each otherwise unreachable cycle in the CFG, if /// such cycles exist. /// The pseudo entry node does not appear in the predecessor or successor /// list of any ordinary block. /// It has no predecessors. /// It has Id 0. BasicBlock pseudo_entry_block_; /// A pseudo exit block used in dominance analysis. /// After the function end has been registered, the predecessor list of the /// pseudo exit node is the minimal set of nodes such that all nodes in the /// CFG can be reached by following predecessor lists. That is, the /// predecessors will be: /// - Any basic block without successors. This includes any basic block /// ending with an OpReturn, OpReturnValue or similar instructions. /// - A single node from each otherwise unreachable cycle in the CFG, if /// such cycles exist. /// The pseudo exit node does not appear in the predecessor or successor /// list of any ordinary block. /// It has no successors. BasicBlock pseudo_exit_block_; // Maps a block to its successors in the augmented CFG, if that set is // different from its successors in the ordinary CFG. std::unordered_map> augmented_successors_map_; // Maps a block to its predecessors in the augmented CFG, if that set is // different from its predecessors in the ordinary CFG. std::unordered_map> augmented_predecessors_map_; // Maps a structured loop header to its CFG successors and also its // continue target if that continue target is not the loop header // itself. This might have duplicates. std::unordered_map> loop_header_successors_plus_continue_target_map_; /// The constructs that are available in this function std::list cfg_constructs_; /// The variable IDs of the functions std::vector variable_ids_; /// The function parameter ids of the functions std::vector parameter_ids_; /// Maps a construct's entry block to the construct(s). /// Since a basic block may be the entry block of different types of /// constructs, the type of the construct should also be specified in order to /// get the unique construct. std::unordered_map, Construct*, bb_constr_type_pair_hash> entry_block_to_construct_; /// This map provides the header block for a given merge block. std::unordered_map merge_block_header_; /// This map provides the header blocks for a given continue target. std::unordered_map> continue_target_headers_; /// Stores the control flow nesting depth of a given basic block std::unordered_map block_depth_; /// Stores execution model limitations imposed by instructions used within the /// function. The functor stored in the list return true if execution model /// is compatible, false otherwise. If the functor returns false, it can also /// optionally fill the string parameter with the reason for incompatibility. std::list> execution_model_limitations_; /// Stores limitations imposed by instructions used within the function. /// Similar to execution_model_limitations_; std::list> limitations_; /// Stores ids of all functions called from this function. std::set function_call_targets_; }; } // namespace val } // namespace spvtools #endif // SOURCE_VAL_FUNCTION_H_ KhronosGroup-SPIRV-Tools-f289d04/source/val/instruction.cpp000066400000000000000000000036311475742701700237030ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/val/instruction.h" #include #include "source/binary.h" #include "source/util/string_utils.h" namespace spvtools { namespace val { Instruction::Instruction(const spv_parsed_instruction_t* inst) : words_(inst->words, inst->words + inst->num_words), operands_(inst->operands, inst->operands + inst->num_operands), inst_({words_.data(), inst->num_words, inst->opcode, inst->ext_inst_type, inst->type_id, inst->result_id, operands_.data(), inst->num_operands}) {} void Instruction::RegisterUse(const Instruction* inst, uint32_t index) { uses_.push_back(std::make_pair(inst, index)); } bool operator<(const Instruction& lhs, const Instruction& rhs) { return lhs.id() < rhs.id(); } bool operator<(const Instruction& lhs, uint32_t rhs) { return lhs.id() < rhs; } bool operator==(const Instruction& lhs, const Instruction& rhs) { return lhs.id() == rhs.id(); } bool operator==(const Instruction& lhs, uint32_t rhs) { return lhs.id() == rhs; } template <> std::string Instruction::GetOperandAs(size_t index) const { const spv_parsed_operand_t& o = operands_.at(index); assert(o.offset + o.num_words <= inst_.num_words); return spvtools::utils::MakeString(words_.data() + o.offset, o.num_words); } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/instruction.h000066400000000000000000000123021475742701700233430ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_VAL_INSTRUCTION_H_ #define SOURCE_VAL_INSTRUCTION_H_ #include #include #include #include #include #include "source/ext_inst.h" #include "source/opcode.h" #include "source/table.h" #include "spirv-tools/libspirv.h" namespace spvtools { namespace val { class BasicBlock; class Function; /// Wraps the spv_parsed_instruction struct along with use and definition of the /// instruction's result id class Instruction { public: explicit Instruction(const spv_parsed_instruction_t* inst); /// Registers the use of the Instruction in instruction \p inst at \p index void RegisterUse(const Instruction* inst, uint32_t index); uint32_t id() const { return inst_.result_id; } uint32_t type_id() const { return inst_.type_id; } spv::Op opcode() const { return static_cast(inst_.opcode); } /// Returns the Function where the instruction was defined. nullptr if it was /// defined outside of a Function const Function* function() const { return function_; } void set_function(Function* func) { function_ = func; } /// Returns the BasicBlock where the instruction was defined. nullptr if it /// was defined outside of a BasicBlock const BasicBlock* block() const { return block_; } void set_block(BasicBlock* b) { block_ = b; } /// Returns a vector of pairs of all references to this instruction's result /// id. The first element is the instruction in which this result id was /// referenced and the second is the index of the word in that instruction /// where this result id appeared const std::vector>& uses() const { return uses_; } /// The word used to define the Instruction uint32_t word(size_t index) const { return words_[index]; } /// The words used to define the Instruction const std::vector& words() const { return words_; } /// Returns the operand at |idx|. const spv_parsed_operand_t& operand(size_t idx) const { return operands_[idx]; } /// The operands of the Instruction const std::vector& operands() const { return operands_; } /// Provides direct access to the stored C instruction object. const spv_parsed_instruction_t& c_inst() const { return inst_; } /// Provides direct access to instructions spv_ext_inst_type_t object. const spv_ext_inst_type_t& ext_inst_type() const { return inst_.ext_inst_type; } bool IsNonSemantic() const { return spvIsExtendedInstruction(opcode()) && spvExtInstIsNonSemantic(inst_.ext_inst_type); } /// True if this is an OpExtInst for debug info extension. bool IsDebugInfo() const { return spvIsExtendedInstruction(opcode()) && spvExtInstIsDebugInfo(inst_.ext_inst_type); } // Casts the words belonging to the operand under |index| to |T| and returns. template T GetOperandAs(size_t index) const { const spv_parsed_operand_t& o = operands_.at(index); assert(o.num_words * 4 >= sizeof(T)); assert(o.offset + o.num_words <= inst_.num_words); return *reinterpret_cast(&words_[o.offset]); } size_t LineNum() const { return line_num_; } void SetLineNum(size_t pos) { line_num_ = pos; } private: const std::vector words_; const std::vector operands_; spv_parsed_instruction_t inst_; size_t line_num_ = 0; /// The function in which this instruction was declared Function* function_ = nullptr; /// The basic block in which this instruction was declared BasicBlock* block_ = nullptr; /// This is a vector of pairs of all references to this instruction's result /// id. The first element is the instruction in which this result id was /// referenced and the second is the index of the word in the referencing /// instruction where this instruction appeared std::vector> uses_; }; bool operator<(const Instruction& lhs, const Instruction& rhs); bool operator<(const Instruction& lhs, uint32_t rhs); bool operator==(const Instruction& lhs, const Instruction& rhs); bool operator==(const Instruction& lhs, uint32_t rhs); template <> std::string Instruction::GetOperandAs(size_t index) const; } // namespace val } // namespace spvtools // custom specialization of std::hash for Instruction namespace std { template <> struct hash { typedef spvtools::val::Instruction argument_type; typedef std::size_t result_type; result_type operator()(const argument_type& inst) const { return hash()(inst.id()); } }; } // namespace std #endif // SOURCE_VAL_INSTRUCTION_H_ KhronosGroup-SPIRV-Tools-f289d04/source/val/validate.cpp000066400000000000000000000467061475742701700231250ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/val/validate.h" #include #include #include #include #include #include "source/binary.h" #include "source/diagnostic.h" #include "source/enum_string_mapping.h" #include "source/extensions.h" #include "source/opcode.h" #include "source/spirv_constant.h" #include "source/spirv_endian.h" #include "source/spirv_target_env.h" #include "source/val/construct.h" #include "source/val/instruction.h" #include "source/val/validation_state.h" #include "spirv-tools/libspirv.h" namespace { // TODO(issue 1950): The validator only returns a single message anyway, so no // point in generating more than 1 warning. static uint32_t kDefaultMaxNumOfWarnings = 1; } // namespace namespace spvtools { namespace val { namespace { // Parses OpExtension instruction and registers extension. void RegisterExtension(ValidationState_t& _, const spv_parsed_instruction_t* inst) { const std::string extension_str = spvtools::GetExtensionString(inst); Extension extension; if (!GetExtensionFromString(extension_str.c_str(), &extension)) { // The error will be logged in the ProcessInstruction pass. return; } _.RegisterExtension(extension); } // Parses the beginning of the module searching for OpExtension instructions. // Registers extensions if recognized. Returns SPV_REQUESTED_TERMINATION // once an instruction which is not spv::Op::OpCapability and // spv::Op::OpExtension is encountered. According to the SPIR-V spec extensions // are declared after capabilities and before everything else. spv_result_t ProcessExtensions(void* user_data, const spv_parsed_instruction_t* inst) { const spv::Op opcode = static_cast(inst->opcode); if (opcode == spv::Op::OpCapability) return SPV_SUCCESS; if (opcode == spv::Op::OpExtension) { ValidationState_t& _ = *(reinterpret_cast(user_data)); RegisterExtension(_, inst); return SPV_SUCCESS; } // OpExtension block is finished, requesting termination. return SPV_REQUESTED_TERMINATION; } spv_result_t ProcessInstruction(void* user_data, const spv_parsed_instruction_t* inst) { ValidationState_t& _ = *(reinterpret_cast(user_data)); auto* instruction = _.AddOrderedInstruction(inst); _.RegisterDebugInstruction(instruction); return SPV_SUCCESS; } spv_result_t ValidateForwardDecls(ValidationState_t& _) { if (_.unresolved_forward_id_count() == 0) return SPV_SUCCESS; std::stringstream ss; std::vector ids = _.UnresolvedForwardIds(); std::transform( std::begin(ids), std::end(ids), std::ostream_iterator(ss, " "), bind(&ValidationState_t::getIdName, std::ref(_), std::placeholders::_1)); auto id_str = ss.str(); return _.diag(SPV_ERROR_INVALID_ID, nullptr) << "The following forward referenced IDs have not been defined:\n" << id_str.substr(0, id_str.size() - 1); } // Entry point validation. Based on 2.16.1 (Universal Validation Rules) of the // SPIRV spec: // * There is at least one OpEntryPoint instruction, unless the Linkage // capability is being used. // * No function can be targeted by both an OpEntryPoint instruction and an // OpFunctionCall instruction. // // Additionally enforces that entry points for Vulkan should not have recursion. spv_result_t ValidateEntryPoints(ValidationState_t& _) { _.ComputeFunctionToEntryPointMapping(); _.ComputeRecursiveEntryPoints(); if (_.entry_points().empty() && !_.HasCapability(spv::Capability::Linkage)) { return _.diag(SPV_ERROR_INVALID_BINARY, nullptr) << "No OpEntryPoint instruction was found. This is only allowed if " "the Linkage capability is being used."; } for (const auto& entry_point : _.entry_points()) { if (_.IsFunctionCallTarget(entry_point)) { return _.diag(SPV_ERROR_INVALID_BINARY, _.FindDef(entry_point)) << "A function (" << entry_point << ") may not be targeted by both an OpEntryPoint instruction and " "an OpFunctionCall instruction."; } // For Vulkan, the static function-call graph for an entry point // must not contain cycles. if (spvIsVulkanEnv(_.context()->target_env)) { if (_.recursive_entry_points().find(entry_point) != _.recursive_entry_points().end()) { return _.diag(SPV_ERROR_INVALID_BINARY, _.FindDef(entry_point)) << _.VkErrorID(4634) << "Entry points may not have a call graph with cycles."; } } } if (auto error = ValidateFloatControls2(_)) { return error; } if (auto error = ValidateDuplicateExecutionModes(_)) { return error; } return SPV_SUCCESS; } spv_result_t ValidateBinaryUsingContextAndValidationState( const spv_context_t& context, const uint32_t* words, const size_t num_words, spv_diagnostic* pDiagnostic, ValidationState_t* vstate) { auto binary = std::unique_ptr( new spv_const_binary_t{words, num_words}); spv_endianness_t endian; spv_position_t position = {}; if (spvBinaryEndianness(binary.get(), &endian)) { return DiagnosticStream(position, context.consumer, "", SPV_ERROR_INVALID_BINARY) << "Invalid SPIR-V magic number."; } spv_header_t header; if (spvBinaryHeaderGet(binary.get(), endian, &header)) { return DiagnosticStream(position, context.consumer, "", SPV_ERROR_INVALID_BINARY) << "Invalid SPIR-V header."; } if (header.version > spvVersionForTargetEnv(context.target_env)) { return DiagnosticStream(position, context.consumer, "", SPV_ERROR_WRONG_VERSION) << "Invalid SPIR-V binary version " << SPV_SPIRV_VERSION_MAJOR_PART(header.version) << "." << SPV_SPIRV_VERSION_MINOR_PART(header.version) << " for target environment " << spvTargetEnvDescription(context.target_env) << "."; } if (header.bound > vstate->options()->universal_limits_.max_id_bound) { return DiagnosticStream(position, context.consumer, "", SPV_ERROR_INVALID_BINARY) << "Invalid SPIR-V. The id bound is larger than the max id bound " << vstate->options()->universal_limits_.max_id_bound << "."; } // Look for OpExtension instructions and register extensions. // This parse should not produce any error messages. Hijack the context and // replace the message consumer so that we do not pollute any state in input // consumer. spv_context_t hijacked_context = context; hijacked_context.consumer = [](spv_message_level_t, const char*, const spv_position_t&, const char*) {}; spvBinaryParse(&hijacked_context, vstate, words, num_words, /* parsed_header = */ nullptr, ProcessExtensions, /* diagnostic = */ nullptr); // Parse the module and perform inline validation checks. These checks do // not require the knowledge of the whole module. if (auto error = spvBinaryParse(&context, vstate, words, num_words, /*parsed_header =*/nullptr, ProcessInstruction, pDiagnostic)) { return error; } bool has_mask_task_nv = false; bool has_mask_task_ext = false; std::vector visited_entry_points; for (auto& instruction : vstate->ordered_instructions()) { { // In order to do this work outside of Process Instruction we need to be // able to, briefly, de-const the instruction. Instruction* inst = const_cast(&instruction); if (inst->opcode() == spv::Op::OpEntryPoint) { const auto entry_point = inst->GetOperandAs(1); const auto execution_model = inst->GetOperandAs(0); const std::string desc_name = inst->GetOperandAs(2); ValidationState_t::EntryPointDescription desc; desc.name = desc_name; std::vector interfaces; for (size_t j = 3; j < inst->operands().size(); ++j) desc.interfaces.push_back(inst->word(inst->operand(j).offset)); vstate->RegisterEntryPoint(entry_point, execution_model, std::move(desc)); if (visited_entry_points.size() > 0) { for (const Instruction* check_inst : visited_entry_points) { const auto check_execution_model = check_inst->GetOperandAs(0); const std::string check_name = check_inst->GetOperandAs(2); if (desc_name == check_name && execution_model == check_execution_model) { return vstate->diag(SPV_ERROR_INVALID_DATA, inst) << "2 Entry points cannot share the same name and " "ExecutionMode."; } } } visited_entry_points.push_back(inst); has_mask_task_nv |= (execution_model == spv::ExecutionModel::TaskNV || execution_model == spv::ExecutionModel::MeshNV); has_mask_task_ext |= (execution_model == spv::ExecutionModel::TaskEXT || execution_model == spv::ExecutionModel::MeshEXT); } if (inst->opcode() == spv::Op::OpFunctionCall) { if (!vstate->in_function_body()) { return vstate->diag(SPV_ERROR_INVALID_LAYOUT, &instruction) << "A FunctionCall must happen within a function body."; } const auto called_id = inst->GetOperandAs(2); vstate->AddFunctionCallTarget(called_id); } if (vstate->in_function_body()) { inst->set_function(&(vstate->current_function())); inst->set_block(vstate->current_function().current_block()); if (vstate->in_block() && spvOpcodeIsBlockTerminator(inst->opcode())) { vstate->current_function().current_block()->set_terminator(inst); } } if (auto error = IdPass(*vstate, inst)) return error; } if (auto error = CapabilityPass(*vstate, &instruction)) return error; if (auto error = ModuleLayoutPass(*vstate, &instruction)) return error; if (auto error = CfgPass(*vstate, &instruction)) return error; if (auto error = InstructionPass(*vstate, &instruction)) return error; // Now that all of the checks are done, update the state. { Instruction* inst = const_cast(&instruction); vstate->RegisterInstruction(inst); if (inst->opcode() == spv::Op::OpTypeForwardPointer) { vstate->RegisterForwardPointer(inst->GetOperandAs(0)); } } } if (!vstate->has_memory_model_specified()) return vstate->diag(SPV_ERROR_INVALID_LAYOUT, nullptr) << "Missing required OpMemoryModel instruction."; if (vstate->in_function_body()) return vstate->diag(SPV_ERROR_INVALID_LAYOUT, nullptr) << "Missing OpFunctionEnd at end of module."; if (vstate->HasCapability(spv::Capability::BindlessTextureNV) && !vstate->has_samplerimage_variable_address_mode_specified()) return vstate->diag(SPV_ERROR_INVALID_LAYOUT, nullptr) << "Missing required OpSamplerImageAddressingModeNV instruction."; if (has_mask_task_ext && has_mask_task_nv) return vstate->diag(SPV_ERROR_INVALID_LAYOUT, nullptr) << vstate->VkErrorID(7102) << "Module can't mix MeshEXT/TaskEXT with MeshNV/TaskNV Execution " "Model."; // Catch undefined forward references before performing further checks. if (auto error = ValidateForwardDecls(*vstate)) return error; // Calculate reachability after all the blocks are parsed, but early that it // can be relied on in subsequent pases. ReachabilityPass(*vstate); // ID usage needs be handled in its own iteration of the instructions, // between the two others. It depends on the first loop to have been // finished, so that all instructions have been registered. And the following // loop depends on all of the usage data being populated. Thus it cannot live // in either of those iterations. // It should also live after the forward declaration check, since it will // have problems with missing forward declarations, but give less useful error // messages. for (size_t i = 0; i < vstate->ordered_instructions().size(); ++i) { auto& instruction = vstate->ordered_instructions()[i]; if (auto error = UpdateIdUse(*vstate, &instruction)) return error; } // Validate individual opcodes. for (size_t i = 0; i < vstate->ordered_instructions().size(); ++i) { auto& instruction = vstate->ordered_instructions()[i]; // Keep these passes in the order they appear in the SPIR-V specification // sections to maintain test consistency. if (auto error = MiscPass(*vstate, &instruction)) return error; if (auto error = DebugPass(*vstate, &instruction)) return error; if (auto error = AnnotationPass(*vstate, &instruction)) return error; if (auto error = ExtensionPass(*vstate, &instruction)) return error; if (auto error = ModeSettingPass(*vstate, &instruction)) return error; if (auto error = TypePass(*vstate, &instruction)) return error; if (auto error = ConstantPass(*vstate, &instruction)) return error; if (auto error = MemoryPass(*vstate, &instruction)) return error; if (auto error = FunctionPass(*vstate, &instruction)) return error; if (auto error = ImagePass(*vstate, &instruction)) return error; if (auto error = ConversionPass(*vstate, &instruction)) return error; if (auto error = CompositesPass(*vstate, &instruction)) return error; if (auto error = ArithmeticsPass(*vstate, &instruction)) return error; if (auto error = BitwisePass(*vstate, &instruction)) return error; if (auto error = LogicalsPass(*vstate, &instruction)) return error; if (auto error = ControlFlowPass(*vstate, &instruction)) return error; if (auto error = DerivativesPass(*vstate, &instruction)) return error; if (auto error = AtomicsPass(*vstate, &instruction)) return error; if (auto error = PrimitivesPass(*vstate, &instruction)) return error; if (auto error = BarriersPass(*vstate, &instruction)) return error; // Group // Device-Side Enqueue // Pipe if (auto error = NonUniformPass(*vstate, &instruction)) return error; if (auto error = LiteralsPass(*vstate, &instruction)) return error; if (auto error = RayQueryPass(*vstate, &instruction)) return error; if (auto error = RayTracingPass(*vstate, &instruction)) return error; if (auto error = RayReorderNVPass(*vstate, &instruction)) return error; if (auto error = MeshShadingPass(*vstate, &instruction)) return error; if (auto error = TensorLayoutPass(*vstate, &instruction)) return error; } // Validate the preconditions involving adjacent instructions. e.g. // spv::Op::OpPhi must only be preceded by spv::Op::OpLabel, spv::Op::OpPhi, // or spv::Op::OpLine. if (auto error = ValidateAdjacency(*vstate)) return error; if (auto error = ValidateEntryPoints(*vstate)) return error; // CFG checks are performed after the binary has been parsed // and the CFGPass has collected information about the control flow if (auto error = PerformCfgChecks(*vstate)) return error; if (auto error = CheckIdDefinitionDominateUse(*vstate)) return error; if (auto error = ValidateDecorations(*vstate)) return error; if (auto error = ValidateInterfaces(*vstate)) return error; // TODO(dsinclair): Restructure ValidateBuiltins so we can move into the // for() above as it loops over all ordered_instructions internally. if (auto error = ValidateBuiltIns(*vstate)) return error; // These checks must be performed after individual opcode checks because // those checks register the limitation checked here. for (const auto& inst : vstate->ordered_instructions()) { if (auto error = ValidateExecutionLimitations(*vstate, &inst)) return error; if (auto error = ValidateSmallTypeUses(*vstate, &inst)) return error; if (auto error = ValidateQCOMImageProcessingTextureUsages(*vstate, &inst)) return error; } return SPV_SUCCESS; } } // namespace spv_result_t ValidateBinaryAndKeepValidationState( const spv_const_context context, spv_const_validator_options options, const uint32_t* words, const size_t num_words, spv_diagnostic* pDiagnostic, std::unique_ptr* vstate) { spv_context_t hijack_context = *context; if (pDiagnostic) { *pDiagnostic = nullptr; UseDiagnosticAsMessageConsumer(&hijack_context, pDiagnostic); } vstate->reset(new ValidationState_t(&hijack_context, options, words, num_words, kDefaultMaxNumOfWarnings)); return ValidateBinaryUsingContextAndValidationState( hijack_context, words, num_words, pDiagnostic, vstate->get()); } } // namespace val } // namespace spvtools spv_result_t spvValidate(const spv_const_context context, const spv_const_binary binary, spv_diagnostic* pDiagnostic) { return spvValidateBinary(context, binary->code, binary->wordCount, pDiagnostic); } spv_result_t spvValidateBinary(const spv_const_context context, const uint32_t* words, const size_t num_words, spv_diagnostic* pDiagnostic) { spv_context_t hijack_context = *context; if (pDiagnostic) { *pDiagnostic = nullptr; spvtools::UseDiagnosticAsMessageConsumer(&hijack_context, pDiagnostic); } // This interface is used for default command line options. spv_validator_options default_options = spvValidatorOptionsCreate(); // Create the ValidationState using the context and default options. spvtools::val::ValidationState_t vstate(&hijack_context, default_options, words, num_words, kDefaultMaxNumOfWarnings); spv_result_t result = spvtools::val::ValidateBinaryUsingContextAndValidationState( hijack_context, words, num_words, pDiagnostic, &vstate); spvValidatorOptionsDestroy(default_options); return result; } spv_result_t spvValidateWithOptions(const spv_const_context context, spv_const_validator_options options, const spv_const_binary binary, spv_diagnostic* pDiagnostic) { spv_context_t hijack_context = *context; if (pDiagnostic) { *pDiagnostic = nullptr; spvtools::UseDiagnosticAsMessageConsumer(&hijack_context, pDiagnostic); } // Create the ValidationState using the context. spvtools::val::ValidationState_t vstate(&hijack_context, options, binary->code, binary->wordCount, kDefaultMaxNumOfWarnings); return spvtools::val::ValidateBinaryUsingContextAndValidationState( hijack_context, binary->code, binary->wordCount, pDiagnostic, &vstate); } KhronosGroup-SPIRV-Tools-f289d04/source/val/validate.h000066400000000000000000000253651475742701700225700ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_VAL_VALIDATE_H_ #define SOURCE_VAL_VALIDATE_H_ #include #include #include #include #include "source/instruction.h" #include "source/table.h" #include "spirv-tools/libspirv.h" namespace spvtools { namespace val { class ValidationState_t; class BasicBlock; class Instruction; /// @brief Performs the Control Flow Graph checks /// /// @param[in] _ the validation state of the module /// /// @return SPV_SUCCESS if no errors are found. SPV_ERROR_INVALID_CFG otherwise spv_result_t PerformCfgChecks(ValidationState_t& _); /// @brief Updates the use vectors of all instructions that can be referenced /// /// This function will update the vector which define where an instruction was /// referenced in the binary. /// /// @param[in] _ the validation state of the module /// /// @return SPV_SUCCESS if no errors are found. spv_result_t UpdateIdUse(ValidationState_t& _, const Instruction* inst); /// @brief This function checks all ID definitions dominate their use in the /// CFG. /// /// This function will iterate over all ID definitions that are defined in the /// functions of a module and make sure that the definitions appear in a /// block that dominates their use. /// /// @param[in] _ the validation state of the module /// /// @return SPV_SUCCESS if no errors are found. SPV_ERROR_INVALID_ID otherwise spv_result_t CheckIdDefinitionDominateUse(ValidationState_t& _); /// @brief This function checks for preconditions involving the adjacent /// instructions. /// /// This function will iterate over all instructions and check for any required /// predecessor and/or successor instructions. e.g. spv::Op::OpPhi must only be /// preceded by spv::Op::OpLabel, spv::Op::OpPhi, or spv::Op::OpLine. /// /// @param[in] _ the validation state of the module /// /// @return SPV_SUCCESS if no errors are found. SPV_ERROR_INVALID_DATA otherwise spv_result_t ValidateAdjacency(ValidationState_t& _); /// @brief Validates static uses of input and output variables /// /// Checks that any entry point that uses a input or output variable lists that /// variable in its interface. /// /// @param[in] _ the validation state of the module /// /// @return SPV_SUCCESS if no errors are found. spv_result_t ValidateInterfaces(ValidationState_t& _); /// @brief Validates entry point call tree requirements of /// SPV_KHR_float_controls2 /// /// Checks that no entry point using FPFastMathDefault uses: /// * FPFastMathMode Fast /// * NoContraction /// /// @param[in] _ the validation state of the module /// /// @return SPV_SUCCESS if no errors are found. spv_result_t ValidateFloatControls2(ValidationState_t& _); /// @brief Validates duplicated execution modes for each entry point. /// /// @param[in] _ the validation state of the module /// /// @return SPV_SUCCESS if no errors are found. spv_result_t ValidateDuplicateExecutionModes(ValidationState_t& _); /// @brief Validates memory instructions /// /// @param[in] _ the validation state of the module /// @return SPV_SUCCESS if no errors are found. spv_result_t MemoryPass(ValidationState_t& _, const Instruction* inst); /// @brief Updates the immediate dominator for each of the block edges /// /// Updates the immediate dominator of the blocks for each of the edges /// provided by the @p dom_edges parameter /// /// @param[in,out] dom_edges The edges of the dominator tree /// @param[in] set_func This function will be called to updated the Immediate /// dominator void UpdateImmediateDominators( const std::vector>& dom_edges, std::function set_func); /// @brief Prints all of the dominators of a BasicBlock /// /// @param[in] block The dominators of this block will be printed void printDominatorList(BasicBlock& block); /// Performs logical layout validation as described in section 2.4 of the SPIR-V /// spec. spv_result_t ModuleLayoutPass(ValidationState_t& _, const Instruction* inst); /// Performs Control Flow Graph validation and construction. spv_result_t CfgPass(ValidationState_t& _, const Instruction* inst); /// Validates Control Flow Graph instructions. spv_result_t ControlFlowPass(ValidationState_t& _, const Instruction* inst); /// Performs Id and SSA validation of a module spv_result_t IdPass(ValidationState_t& _, Instruction* inst); /// Performs instruction validation. spv_result_t InstructionPass(ValidationState_t& _, const Instruction* inst); /// Performs decoration validation. Assumes each decoration on a group /// has been propagated down to the group members. spv_result_t ValidateDecorations(ValidationState_t& _); /// Performs validation of built-in variables. spv_result_t ValidateBuiltIns(ValidationState_t& _); /// Validates type instructions. spv_result_t TypePass(ValidationState_t& _, const Instruction* inst); /// Validates constant instructions. spv_result_t ConstantPass(ValidationState_t& _, const Instruction* inst); /// Validates correctness of arithmetic instructions. spv_result_t ArithmeticsPass(ValidationState_t& _, const Instruction* inst); /// Validates correctness of composite instructions. spv_result_t CompositesPass(ValidationState_t& _, const Instruction* inst); /// Validates correctness of conversion instructions. spv_result_t ConversionPass(ValidationState_t& _, const Instruction* inst); /// Validates correctness of derivative instructions. spv_result_t DerivativesPass(ValidationState_t& _, const Instruction* inst); /// Validates correctness of logical instructions. spv_result_t LogicalsPass(ValidationState_t& _, const Instruction* inst); /// Validates correctness of bitwise instructions. spv_result_t BitwisePass(ValidationState_t& _, const Instruction* inst); /// Validates correctness of image instructions. spv_result_t ImagePass(ValidationState_t& _, const Instruction* inst); /// Validates correctness of atomic instructions. spv_result_t AtomicsPass(ValidationState_t& _, const Instruction* inst); /// Validates correctness of barrier instructions. spv_result_t BarriersPass(ValidationState_t& _, const Instruction* inst); /// Validates correctness of literal numbers. spv_result_t LiteralsPass(ValidationState_t& _, const Instruction* inst); /// Validates correctness of extension instructions. spv_result_t ExtensionPass(ValidationState_t& _, const Instruction* inst); /// Validates correctness of annotation instructions. spv_result_t AnnotationPass(ValidationState_t& _, const Instruction* inst); /// Validates correctness of non-uniform group instructions. spv_result_t NonUniformPass(ValidationState_t& _, const Instruction* inst); /// Validates correctness of debug instructions. spv_result_t DebugPass(ValidationState_t& _, const Instruction* inst); // Validates that capability declarations use operands allowed in the current // context. spv_result_t CapabilityPass(ValidationState_t& _, const Instruction* inst); /// Validates correctness of primitive instructions. spv_result_t PrimitivesPass(ValidationState_t& _, const Instruction* inst); /// Validates correctness of mode setting instructions. spv_result_t ModeSettingPass(ValidationState_t& _, const Instruction* inst); /// Validates correctness of function instructions. spv_result_t FunctionPass(ValidationState_t& _, const Instruction* inst); /// Validates correctness of miscellaneous instructions. spv_result_t MiscPass(ValidationState_t& _, const Instruction* inst); /// Validates correctness of ray query instructions. spv_result_t RayQueryPass(ValidationState_t& _, const Instruction* inst); /// Validates correctness of ray tracing instructions. spv_result_t RayTracingPass(ValidationState_t& _, const Instruction* inst); /// Validates correctness of shader execution reorder instructions. spv_result_t RayReorderNVPass(ValidationState_t& _, const Instruction* inst); /// Validates correctness of mesh shading instructions. spv_result_t MeshShadingPass(ValidationState_t& _, const Instruction* inst); /// Calculates the reachability of basic blocks. void ReachabilityPass(ValidationState_t& _); /// Validates tensor layout and view instructions. spv_result_t TensorLayoutPass(ValidationState_t& _, const Instruction* inst); /// Validates execution limitations. /// /// Verifies execution models are allowed for all functionality they contain. spv_result_t ValidateExecutionLimitations(ValidationState_t& _, const Instruction* inst); /// Validates restricted uses of 8- and 16-bit types. /// /// Validates shaders that uses 8- or 16-bit storage capabilities, but not full /// capabilities only have appropriate uses of those types. spv_result_t ValidateSmallTypeUses(ValidationState_t& _, const Instruction* inst); /// Validates restricted uses of QCOM decorated textures /// /// The textures that are decorated with some of QCOM image processing /// decorations must be used in the specified QCOM image processing built-in /// functions and not used in any other image functions. spv_result_t ValidateQCOMImageProcessingTextureUsages(ValidationState_t& _, const Instruction* inst); /// @brief Validate the ID's within a SPIR-V binary /// /// @param[in] pInstructions array of instructions /// @param[in] count number of elements in instruction array /// @param[in] bound the binary header /// @param[in,out] position current word in the binary /// @param[in] consumer message consumer callback /// /// @return result code spv_result_t spvValidateIDs(const spv_instruction_t* pInstructions, const uint64_t count, const uint32_t bound, spv_position position, const MessageConsumer& consumer); // Performs validation for the SPIRV-V module binary. // The main difference between this API and spvValidateBinary is that the // "Validation State" is not destroyed upon function return; it lives on and is // pointed to by the vstate unique_ptr. spv_result_t ValidateBinaryAndKeepValidationState( const spv_const_context context, spv_const_validator_options options, const uint32_t* words, const size_t num_words, spv_diagnostic* pDiagnostic, std::unique_ptr* vstate); } // namespace val } // namespace spvtools #endif // SOURCE_VAL_VALIDATE_H_ KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_adjacency.cpp000066400000000000000000000122131475742701700251100ustar00rootroot00000000000000// Copyright (c) 2018 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validates correctness of the intra-block preconditions of SPIR-V // instructions. #include #include "source/val/instruction.h" #include "source/val/validate.h" #include "source/val/validation_state.h" namespace spvtools { namespace val { enum { // Status right after meeting OpFunction. IN_NEW_FUNCTION, // Status right after meeting the entry block. IN_ENTRY_BLOCK, // Status right after meeting non-entry blocks. PHI_VALID, // Status right after meeting non-OpVariable instructions in the entry block // or non-OpPhi instructions in non-entry blocks, except OpLine. PHI_AND_VAR_INVALID, }; spv_result_t ValidateAdjacency(ValidationState_t& _) { const auto& instructions = _.ordered_instructions(); int adjacency_status = PHI_AND_VAR_INVALID; for (size_t i = 0; i < instructions.size(); ++i) { const auto& inst = instructions[i]; switch (inst.opcode()) { case spv::Op::OpFunction: case spv::Op::OpFunctionParameter: adjacency_status = IN_NEW_FUNCTION; break; case spv::Op::OpLabel: adjacency_status = adjacency_status == IN_NEW_FUNCTION ? IN_ENTRY_BLOCK : PHI_VALID; break; case spv::Op::OpExtInst: case spv::Op::OpExtInstWithForwardRefsKHR: // If it is a debug info instruction, we do not change the status to // allow debug info instructions before OpVariable in a function. // TODO(https://gitlab.khronos.org/spirv/SPIR-V/issues/533): We need // to discuss the location of DebugScope, DebugNoScope, DebugDeclare, // and DebugValue. // NOTE: This does not apply to the non-semantic vulkan debug info. if (!spvExtInstIsDebugInfo(inst.ext_inst_type()) || inst.ext_inst_type() == SPV_EXT_INST_TYPE_NONSEMANTIC_SHADER_DEBUGINFO_100) { adjacency_status = PHI_AND_VAR_INVALID; } break; case spv::Op::OpPhi: if (adjacency_status != PHI_VALID) { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << "OpPhi must appear within a non-entry block before all " << "non-OpPhi instructions " << "(except for OpLine, which can be mixed with OpPhi)."; } break; case spv::Op::OpLine: case spv::Op::OpNoLine: break; case spv::Op::OpLoopMerge: adjacency_status = PHI_AND_VAR_INVALID; if (i != (instructions.size() - 1)) { switch (instructions[i + 1].opcode()) { case spv::Op::OpBranch: case spv::Op::OpBranchConditional: break; default: return _.diag(SPV_ERROR_INVALID_DATA, &inst) << "OpLoopMerge must immediately precede either an " << "OpBranch or OpBranchConditional instruction. " << "OpLoopMerge must be the second-to-last instruction in " << "its block."; } } break; case spv::Op::OpSelectionMerge: adjacency_status = PHI_AND_VAR_INVALID; if (i != (instructions.size() - 1)) { switch (instructions[i + 1].opcode()) { case spv::Op::OpBranchConditional: case spv::Op::OpSwitch: break; default: return _.diag(SPV_ERROR_INVALID_DATA, &inst) << "OpSelectionMerge must immediately precede either an " << "OpBranchConditional or OpSwitch instruction. " << "OpSelectionMerge must be the second-to-last " << "instruction in its block."; } } break; case spv::Op::OpVariable: if (inst.GetOperandAs(2) == spv::StorageClass::Function && adjacency_status != IN_ENTRY_BLOCK) { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << "All OpVariable instructions in a function must be the " "first instructions in the first block."; } break; case spv::Op::OpUntypedVariableKHR: if (inst.GetOperandAs(2) == spv::StorageClass::Function && adjacency_status != IN_ENTRY_BLOCK) { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << "All OpUntypedVariableKHR instructions in a function must " "be the first instructions in the first block."; } break; default: adjacency_status = PHI_AND_VAR_INVALID; break; } } return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_annotation.cpp000066400000000000000000000537621475742701700253570ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // Modifications Copyright (C) 2024 Advanced Micro Devices, Inc. All rights // reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opcode.h" #include "source/spirv_target_env.h" #include "source/val/instruction.h" #include "source/val/validate.h" #include "source/val/validation_state.h" namespace spvtools { namespace val { namespace { // Returns true if the decoration takes ID parameters. // TODO(dneto): This can be generated from the grammar. bool DecorationTakesIdParameters(spv::Decoration type) { switch (type) { case spv::Decoration::UniformId: case spv::Decoration::AlignmentId: case spv::Decoration::MaxByteOffsetId: case spv::Decoration::HlslCounterBufferGOOGLE: case spv::Decoration::NodeMaxPayloadsAMDX: case spv::Decoration::NodeSharesPayloadLimitsWithAMDX: case spv::Decoration::PayloadNodeArraySizeAMDX: case spv::Decoration::PayloadNodeNameAMDX: case spv::Decoration::PayloadNodeBaseIndexAMDX: return true; default: break; } return false; } bool IsMemberDecorationOnly(spv::Decoration dec) { switch (dec) { case spv::Decoration::RowMajor: case spv::Decoration::ColMajor: case spv::Decoration::MatrixStride: // SPIR-V spec bug? Offset is generated on variables when dealing with // transform feedback. // case spv::Decoration::Offset: return true; default: break; } return false; } bool IsNotMemberDecoration(spv::Decoration dec) { switch (dec) { case spv::Decoration::SpecId: case spv::Decoration::Block: case spv::Decoration::BufferBlock: case spv::Decoration::ArrayStride: case spv::Decoration::GLSLShared: case spv::Decoration::GLSLPacked: case spv::Decoration::CPacked: // TODO: https://github.com/KhronosGroup/glslang/issues/703: // glslang applies Restrict to structure members. // case spv::Decoration::Restrict: case spv::Decoration::Aliased: case spv::Decoration::Constant: case spv::Decoration::Uniform: case spv::Decoration::UniformId: case spv::Decoration::SaturatedConversion: case spv::Decoration::Index: case spv::Decoration::Binding: case spv::Decoration::DescriptorSet: case spv::Decoration::FuncParamAttr: case spv::Decoration::FPRoundingMode: case spv::Decoration::FPFastMathMode: case spv::Decoration::LinkageAttributes: case spv::Decoration::NoContraction: case spv::Decoration::InputAttachmentIndex: case spv::Decoration::Alignment: case spv::Decoration::MaxByteOffset: case spv::Decoration::AlignmentId: case spv::Decoration::MaxByteOffsetId: case spv::Decoration::NoSignedWrap: case spv::Decoration::NoUnsignedWrap: case spv::Decoration::NonUniform: case spv::Decoration::RestrictPointer: case spv::Decoration::AliasedPointer: case spv::Decoration::CounterBuffer: return true; default: break; } return false; } spv_result_t ValidateDecorationTarget(ValidationState_t& _, spv::Decoration dec, const Instruction* inst, const Instruction* target) { auto fail = [&_, dec, inst, target](uint32_t vuid) -> DiagnosticStream { DiagnosticStream ds = std::move( _.diag(SPV_ERROR_INVALID_ID, inst) << _.VkErrorID(vuid) << _.SpvDecorationString(dec) << " decoration on target " << _.getIdName(target->id()) << " "); return ds; }; switch (dec) { case spv::Decoration::SpecId: if (!spvOpcodeIsScalarSpecConstant(target->opcode())) { return fail(0) << "must be a scalar specialization constant"; } break; case spv::Decoration::Block: case spv::Decoration::BufferBlock: case spv::Decoration::GLSLShared: case spv::Decoration::GLSLPacked: case spv::Decoration::CPacked: if (target->opcode() != spv::Op::OpTypeStruct) { return fail(0) << "must be a structure type"; } break; case spv::Decoration::ArrayStride: if (target->opcode() != spv::Op::OpTypeArray && target->opcode() != spv::Op::OpTypeRuntimeArray && target->opcode() != spv::Op::OpTypePointer && target->opcode() != spv::Op::OpTypeUntypedPointerKHR) { return fail(0) << "must be an array or pointer type"; } break; case spv::Decoration::BuiltIn: if (target->opcode() != spv::Op::OpVariable && target->opcode() != spv::Op::OpUntypedVariableKHR && !spvOpcodeIsConstant(target->opcode())) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "BuiltIns can only target variables, structure members or " "constants"; } if (_.HasCapability(spv::Capability::Shader) && inst->GetOperandAs(2) == spv::BuiltIn::WorkgroupSize) { if (!spvOpcodeIsConstant(target->opcode())) { return fail(0) << "must be a constant for WorkgroupSize"; } } else if (target->opcode() != spv::Op::OpVariable && target->opcode() != spv::Op::OpUntypedVariableKHR) { return fail(0) << "must be a variable"; } break; case spv::Decoration::NoPerspective: case spv::Decoration::Flat: case spv::Decoration::Patch: case spv::Decoration::Centroid: case spv::Decoration::Sample: case spv::Decoration::Restrict: case spv::Decoration::Aliased: case spv::Decoration::Volatile: case spv::Decoration::Coherent: case spv::Decoration::NonWritable: case spv::Decoration::NonReadable: case spv::Decoration::XfbBuffer: case spv::Decoration::XfbStride: case spv::Decoration::Component: case spv::Decoration::Stream: case spv::Decoration::RestrictPointer: case spv::Decoration::AliasedPointer: case spv::Decoration::PerPrimitiveEXT: if (target->opcode() != spv::Op::OpVariable && target->opcode() != spv::Op::OpUntypedVariableKHR && target->opcode() != spv::Op::OpFunctionParameter && target->opcode() != spv::Op::OpRawAccessChainNV) { return fail(0) << "must be a memory object declaration"; } if (!_.IsPointerType(target->type_id())) { return fail(0) << "must be a pointer type"; } break; case spv::Decoration::Invariant: case spv::Decoration::Constant: case spv::Decoration::Location: case spv::Decoration::Index: case spv::Decoration::Binding: case spv::Decoration::DescriptorSet: case spv::Decoration::InputAttachmentIndex: if (target->opcode() != spv::Op::OpVariable && target->opcode() != spv::Op::OpUntypedVariableKHR) { return fail(0) << "must be a variable"; } break; default: break; } if (spvIsVulkanEnv(_.context()->target_env)) { // The following were all checked as pointer types above. spv::StorageClass sc = spv::StorageClass::Uniform; const auto type = _.FindDef(target->type_id()); if (type && type->operands().size() > 2) { sc = type->GetOperandAs(1); } switch (dec) { case spv::Decoration::Location: case spv::Decoration::Component: // Location is used for input, output, tile image, and ray tracing // stages. if (sc != spv::StorageClass::Input && sc != spv::StorageClass::Output && sc != spv::StorageClass::RayPayloadKHR && sc != spv::StorageClass::IncomingRayPayloadKHR && sc != spv::StorageClass::HitAttributeKHR && sc != spv::StorageClass::CallableDataKHR && sc != spv::StorageClass::IncomingCallableDataKHR && sc != spv::StorageClass::ShaderRecordBufferKHR && sc != spv::StorageClass::HitObjectAttributeNV && sc != spv::StorageClass::TileImageEXT) { return _.diag(SPV_ERROR_INVALID_ID, target) << _.VkErrorID(6672) << _.SpvDecorationString(dec) << " decoration must not be applied to this storage class"; } break; case spv::Decoration::Index: // Langauge from SPIR-V definition of Index if (sc != spv::StorageClass::Output) { return fail(0) << "must be in the Output storage class"; } break; case spv::Decoration::Binding: case spv::Decoration::DescriptorSet: if (sc != spv::StorageClass::StorageBuffer && sc != spv::StorageClass::Uniform && sc != spv::StorageClass::UniformConstant) { return fail(6491) << "must be in the StorageBuffer, Uniform, or " "UniformConstant storage class"; } break; case spv::Decoration::InputAttachmentIndex: if (sc != spv::StorageClass::UniformConstant) { return fail(6678) << "must be in the UniformConstant storage class"; } break; case spv::Decoration::Flat: case spv::Decoration::NoPerspective: case spv::Decoration::Centroid: case spv::Decoration::Sample: if (sc != spv::StorageClass::Input && sc != spv::StorageClass::Output) { return fail(4670) << "storage class must be Input or Output"; } break; case spv::Decoration::PerVertexKHR: if (sc != spv::StorageClass::Input) { return fail(6777) << "storage class must be Input"; } break; default: break; } } return SPV_SUCCESS; } spv_result_t ValidateDecorate(ValidationState_t& _, const Instruction* inst) { const auto decoration = inst->GetOperandAs(1); const auto target_id = inst->GetOperandAs(0); const auto target = _.FindDef(target_id); if (!target) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "target is not defined"; } if (spvIsVulkanEnv(_.context()->target_env)) { if ((decoration == spv::Decoration::GLSLShared) || (decoration == spv::Decoration::GLSLPacked)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << _.VkErrorID(4669) << "OpDecorate decoration '" << _.SpvDecorationString(decoration) << "' is not valid for the Vulkan execution environment."; } } if (decoration == spv::Decoration::FPFastMathMode) { if (_.HasDecoration(target_id, spv::Decoration::NoContraction)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "FPFastMathMode and NoContraction cannot decorate the same " "target"; } auto mask = inst->GetOperandAs(2); if ((mask & spv::FPFastMathModeMask::AllowTransform) != spv::FPFastMathModeMask::MaskNone && ((mask & (spv::FPFastMathModeMask::AllowContract | spv::FPFastMathModeMask::AllowReassoc)) != (spv::FPFastMathModeMask::AllowContract | spv::FPFastMathModeMask::AllowReassoc))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "AllowReassoc and AllowContract must be specified when " "AllowTransform is specified"; } } // This is checked from both sides since we register decorations as we go. if (decoration == spv::Decoration::NoContraction) { if (_.HasDecoration(target_id, spv::Decoration::FPFastMathMode)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "FPFastMathMode and NoContraction cannot decorate the same " "target"; } } if (DecorationTakesIdParameters(decoration)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Decorations taking ID parameters may not be used with " "OpDecorateId"; } if (target->opcode() != spv::Op::OpDecorationGroup) { if (IsMemberDecorationOnly(decoration)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << _.SpvDecorationString(decoration) << " can only be applied to structure members"; } if (auto error = ValidateDecorationTarget(_, decoration, inst, target)) { return error; } } // TODO: Add validations for all decorations. return SPV_SUCCESS; } spv_result_t ValidateDecorateId(ValidationState_t& _, const Instruction* inst) { const auto decoration = inst->GetOperandAs(1); if (!DecorationTakesIdParameters(decoration)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Decorations that don't take ID parameters may not be used with " "OpDecorateId"; } // No member decorations take id parameters, so we don't bother checking if // we are using a member only decoration here. // TODO: Add validations for these decorations. // UniformId is covered elsewhere. return SPV_SUCCESS; } spv_result_t ValidateMemberDecorate(ValidationState_t& _, const Instruction* inst) { const auto struct_type_id = inst->GetOperandAs(0); const auto struct_type = _.FindDef(struct_type_id); if (!struct_type || spv::Op::OpTypeStruct != struct_type->opcode()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpMemberDecorate Structure type " << _.getIdName(struct_type_id) << " is not a struct type."; } const auto member = inst->GetOperandAs(1); const auto member_count = static_cast(struct_type->words().size() - 2); if (member_count <= member) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Index " << member << " provided in OpMemberDecorate for struct " << _.getIdName(struct_type_id) << " is out of bounds. The structure has " << member_count << " members. Largest valid index is " << member_count - 1 << "."; } const auto decoration = inst->GetOperandAs(2); if (IsNotMemberDecoration(decoration)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << _.SpvDecorationString(decoration) << " cannot be applied to structure members"; } return SPV_SUCCESS; } spv_result_t ValidateDecorationGroup(ValidationState_t& _, const Instruction* inst) { const auto decoration_group_id = inst->GetOperandAs(0); const auto decoration_group = _.FindDef(decoration_group_id); for (auto pair : decoration_group->uses()) { auto use = pair.first; if (use->opcode() != spv::Op::OpDecorate && use->opcode() != spv::Op::OpGroupDecorate && use->opcode() != spv::Op::OpGroupMemberDecorate && use->opcode() != spv::Op::OpName && use->opcode() != spv::Op::OpDecorateId && !use->IsNonSemantic()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Result id of OpDecorationGroup can only " << "be targeted by OpName, OpGroupDecorate, " << "OpDecorate, OpDecorateId, and OpGroupMemberDecorate"; } } return SPV_SUCCESS; } spv_result_t ValidateGroupDecorate(ValidationState_t& _, const Instruction* inst) { const auto decoration_group_id = inst->GetOperandAs(0); auto decoration_group = _.FindDef(decoration_group_id); if (!decoration_group || spv::Op::OpDecorationGroup != decoration_group->opcode()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpGroupDecorate Decoration group " << _.getIdName(decoration_group_id) << " is not a decoration group."; } for (unsigned i = 1; i < inst->operands().size(); ++i) { auto target_id = inst->GetOperandAs(i); auto target = _.FindDef(target_id); if (!target || target->opcode() == spv::Op::OpDecorationGroup) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpGroupDecorate may not target OpDecorationGroup " << _.getIdName(target_id); } } return SPV_SUCCESS; } spv_result_t ValidateGroupMemberDecorate(ValidationState_t& _, const Instruction* inst) { const auto decoration_group_id = inst->GetOperandAs(0); const auto decoration_group = _.FindDef(decoration_group_id); if (!decoration_group || spv::Op::OpDecorationGroup != decoration_group->opcode()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpGroupMemberDecorate Decoration group " << _.getIdName(decoration_group_id) << " is not a decoration group."; } // Grammar checks ensures that the number of arguments to this instruction // is an odd number: 1 decoration group + (id,literal) pairs. for (size_t i = 1; i + 1 < inst->operands().size(); i += 2) { const uint32_t struct_id = inst->GetOperandAs(i); const uint32_t index = inst->GetOperandAs(i + 1); auto struct_instr = _.FindDef(struct_id); if (!struct_instr || spv::Op::OpTypeStruct != struct_instr->opcode()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpGroupMemberDecorate Structure type " << _.getIdName(struct_id) << " is not a struct type."; } const uint32_t num_struct_members = static_cast(struct_instr->words().size() - 2); if (index >= num_struct_members) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Index " << index << " provided in OpGroupMemberDecorate for struct " << _.getIdName(struct_id) << " is out of bounds. The structure has " << num_struct_members << " members. Largest valid index is " << num_struct_members - 1 << "."; } } return SPV_SUCCESS; } // Registers necessary decoration(s) for the appropriate IDs based on the // instruction. spv_result_t RegisterDecorations(ValidationState_t& _, const Instruction* inst) { switch (inst->opcode()) { case spv::Op::OpDecorate: case spv::Op::OpDecorateId: { const uint32_t target_id = inst->word(1); const spv::Decoration dec_type = static_cast(inst->word(2)); std::vector dec_params; if (inst->words().size() > 3) { dec_params.insert(dec_params.end(), inst->words().begin() + 3, inst->words().end()); } _.RegisterDecorationForId(target_id, Decoration(dec_type, dec_params)); break; } case spv::Op::OpMemberDecorate: { const uint32_t struct_id = inst->word(1); const uint32_t index = inst->word(2); const spv::Decoration dec_type = static_cast(inst->word(3)); std::vector dec_params; if (inst->words().size() > 4) { dec_params.insert(dec_params.end(), inst->words().begin() + 4, inst->words().end()); } _.RegisterDecorationForId(struct_id, Decoration(dec_type, dec_params, index)); break; } case spv::Op::OpDecorationGroup: { // We don't need to do anything right now. Assigning decorations to groups // will be taken care of via OpGroupDecorate. break; } case spv::Op::OpGroupDecorate: { // Word 1 is the group . All subsequent words are target s that // are going to be decorated with the decorations. const uint32_t decoration_group_id = inst->word(1); std::set& group_decorations = _.id_decorations(decoration_group_id); for (size_t i = 2; i < inst->words().size(); ++i) { const uint32_t target_id = inst->word(i); _.RegisterDecorationsForId(target_id, group_decorations.begin(), group_decorations.end()); } break; } case spv::Op::OpGroupMemberDecorate: { // Word 1 is the Decoration Group followed by (struct,literal) // pairs. All decorations of the group should be applied to all the struct // members that are specified in the instructions. const uint32_t decoration_group_id = inst->word(1); std::set& group_decorations = _.id_decorations(decoration_group_id); // Grammar checks ensures that the number of arguments to this instruction // is an odd number: 1 decoration group + (id,literal) pairs. for (size_t i = 2; i + 1 < inst->words().size(); i = i + 2) { const uint32_t struct_id = inst->word(i); const uint32_t index = inst->word(i + 1); // ID validation phase ensures this is in fact a struct instruction and // that the index is not out of bound. _.RegisterDecorationsForStructMember(struct_id, index, group_decorations.begin(), group_decorations.end()); } break; } default: break; } return SPV_SUCCESS; } } // namespace spv_result_t AnnotationPass(ValidationState_t& _, const Instruction* inst) { switch (inst->opcode()) { case spv::Op::OpDecorate: if (auto error = ValidateDecorate(_, inst)) return error; break; case spv::Op::OpDecorateId: if (auto error = ValidateDecorateId(_, inst)) return error; break; // TODO(dneto): spv::Op::OpDecorateStringGOOGLE // See https://github.com/KhronosGroup/SPIRV-Tools/issues/2253 case spv::Op::OpMemberDecorate: if (auto error = ValidateMemberDecorate(_, inst)) return error; break; case spv::Op::OpDecorationGroup: if (auto error = ValidateDecorationGroup(_, inst)) return error; break; case spv::Op::OpGroupDecorate: if (auto error = ValidateGroupDecorate(_, inst)) return error; break; case spv::Op::OpGroupMemberDecorate: if (auto error = ValidateGroupMemberDecorate(_, inst)) return error; break; default: break; } // In order to validate decoration rules, we need to know all the decorations // that are applied to any given . RegisterDecorations(_, inst); return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_arithmetics.cpp000066400000000000000000001100161475742701700255030ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Performs validation of arithmetic instructions. #include #include "source/opcode.h" #include "source/val/instruction.h" #include "source/val/validate.h" #include "source/val/validation_state.h" namespace spvtools { namespace val { // Validates correctness of arithmetic instructions. spv_result_t ArithmeticsPass(ValidationState_t& _, const Instruction* inst) { const spv::Op opcode = inst->opcode(); const uint32_t result_type = inst->type_id(); switch (opcode) { case spv::Op::OpFAdd: case spv::Op::OpFSub: case spv::Op::OpFMul: case spv::Op::OpFDiv: case spv::Op::OpFRem: case spv::Op::OpFMod: case spv::Op::OpFNegate: { bool supportsCoopMat = (opcode != spv::Op::OpFMul && opcode != spv::Op::OpFRem && opcode != spv::Op::OpFMod); bool supportsCoopVec = (opcode != spv::Op::OpFRem && opcode != spv::Op::OpFMod); if (!_.IsFloatScalarType(result_type) && !_.IsFloatVectorType(result_type) && !(supportsCoopMat && _.IsFloatCooperativeMatrixType(result_type)) && !(opcode == spv::Op::OpFMul && _.IsCooperativeMatrixKHRType(result_type) && _.IsFloatCooperativeMatrixType(result_type)) && !(supportsCoopVec && _.IsFloatCooperativeVectorNVType(result_type))) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected floating scalar or vector type as Result Type: " << spvOpcodeString(opcode); for (size_t operand_index = 2; operand_index < inst->operands().size(); ++operand_index) { if (supportsCoopVec && _.IsCooperativeVectorNVType(result_type)) { const uint32_t type_id = _.GetOperandTypeId(inst, operand_index); if (!_.IsCooperativeVectorNVType(type_id)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected arithmetic operands to be of Result Type: " << spvOpcodeString(opcode) << " operand index " << operand_index; } spv_result_t ret = _.CooperativeVectorDimensionsMatch(inst, type_id, result_type); if (ret != SPV_SUCCESS) return ret; } else if (supportsCoopMat && _.IsCooperativeMatrixKHRType(result_type)) { const uint32_t type_id = _.GetOperandTypeId(inst, operand_index); if (!_.IsCooperativeMatrixKHRType(type_id) || !_.IsFloatCooperativeMatrixType(type_id)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected arithmetic operands to be of Result Type: " << spvOpcodeString(opcode) << " operand index " << operand_index; } spv_result_t ret = _.CooperativeMatrixShapesMatch(inst, result_type, type_id, false); if (ret != SPV_SUCCESS) return ret; } else if (_.GetOperandTypeId(inst, operand_index) != result_type) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected arithmetic operands to be of Result Type: " << spvOpcodeString(opcode) << " operand index " << operand_index; } break; } case spv::Op::OpUDiv: case spv::Op::OpUMod: { bool supportsCoopMat = (opcode == spv::Op::OpUDiv); bool supportsCoopVec = (opcode == spv::Op::OpUDiv); if (!_.IsUnsignedIntScalarType(result_type) && !_.IsUnsignedIntVectorType(result_type) && !(supportsCoopMat && _.IsUnsignedIntCooperativeMatrixType(result_type)) && !(supportsCoopVec && _.IsUnsignedIntCooperativeVectorNVType(result_type))) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected unsigned int scalar or vector type as Result Type: " << spvOpcodeString(opcode); for (size_t operand_index = 2; operand_index < inst->operands().size(); ++operand_index) { if (supportsCoopVec && _.IsCooperativeVectorNVType(result_type)) { const uint32_t type_id = _.GetOperandTypeId(inst, operand_index); if (!_.IsCooperativeVectorNVType(type_id)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected arithmetic operands to be of Result Type: " << spvOpcodeString(opcode) << " operand index " << operand_index; } spv_result_t ret = _.CooperativeVectorDimensionsMatch(inst, type_id, result_type); if (ret != SPV_SUCCESS) return ret; } else if (supportsCoopMat && _.IsCooperativeMatrixKHRType(result_type)) { const uint32_t type_id = _.GetOperandTypeId(inst, operand_index); if (!_.IsCooperativeMatrixKHRType(type_id) || !_.IsUnsignedIntCooperativeMatrixType(type_id)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected arithmetic operands to be of Result Type: " << spvOpcodeString(opcode) << " operand index " << operand_index; } spv_result_t ret = _.CooperativeMatrixShapesMatch(inst, result_type, type_id, false); if (ret != SPV_SUCCESS) return ret; } else if (_.GetOperandTypeId(inst, operand_index) != result_type) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected arithmetic operands to be of Result Type: " << spvOpcodeString(opcode) << " operand index " << operand_index; } break; } case spv::Op::OpISub: case spv::Op::OpIAdd: case spv::Op::OpIMul: case spv::Op::OpSDiv: case spv::Op::OpSMod: case spv::Op::OpSRem: case spv::Op::OpSNegate: { bool supportsCoopMat = (opcode != spv::Op::OpIMul && opcode != spv::Op::OpSRem && opcode != spv::Op::OpSMod); bool supportsCoopVec = (opcode != spv::Op::OpSRem && opcode != spv::Op::OpSMod); if (!_.IsIntScalarType(result_type) && !_.IsIntVectorType(result_type) && !(supportsCoopMat && _.IsIntCooperativeMatrixType(result_type)) && !(opcode == spv::Op::OpIMul && _.IsCooperativeMatrixKHRType(result_type) && _.IsIntCooperativeMatrixType(result_type)) && !(supportsCoopVec && _.IsIntCooperativeVectorNVType(result_type))) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected int scalar or vector type as Result Type: " << spvOpcodeString(opcode); const uint32_t dimension = _.GetDimension(result_type); const uint32_t bit_width = _.GetBitWidth(result_type); for (size_t operand_index = 2; operand_index < inst->operands().size(); ++operand_index) { const uint32_t type_id = _.GetOperandTypeId(inst, operand_index); if (supportsCoopVec && _.IsCooperativeVectorNVType(result_type)) { if (!_.IsCooperativeVectorNVType(type_id)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected arithmetic operands to be of Result Type: " << spvOpcodeString(opcode) << " operand index " << operand_index; } spv_result_t ret = _.CooperativeVectorDimensionsMatch(inst, type_id, result_type); if (ret != SPV_SUCCESS) return ret; } if (supportsCoopMat && _.IsCooperativeMatrixKHRType(result_type)) { if (!_.IsCooperativeMatrixKHRType(type_id) || !_.IsIntCooperativeMatrixType(type_id)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected arithmetic operands to be of Result Type: " << spvOpcodeString(opcode) << " operand index " << operand_index; } spv_result_t ret = _.CooperativeMatrixShapesMatch(inst, result_type, type_id, false); if (ret != SPV_SUCCESS) return ret; } if (!type_id || (!_.IsIntScalarType(type_id) && !_.IsIntVectorType(type_id) && !(supportsCoopMat && _.IsIntCooperativeMatrixType(result_type)) && !(opcode == spv::Op::OpIMul && _.IsCooperativeMatrixKHRType(result_type) && _.IsIntCooperativeMatrixType(result_type)) && !(supportsCoopVec && _.IsIntCooperativeVectorNVType(result_type)))) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected int scalar or vector type as operand: " << spvOpcodeString(opcode) << " operand index " << operand_index; if (_.GetDimension(type_id) != dimension) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected arithmetic operands to have the same dimension " << "as Result Type: " << spvOpcodeString(opcode) << " operand index " << operand_index; if (_.GetBitWidth(type_id) != bit_width) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected arithmetic operands to have the same bit width " << "as Result Type: " << spvOpcodeString(opcode) << " operand index " << operand_index; } break; } case spv::Op::OpDot: { if (!_.IsFloatScalarType(result_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected float scalar type as Result Type: " << spvOpcodeString(opcode); uint32_t first_vector_num_components = 0; for (size_t operand_index = 2; operand_index < inst->operands().size(); ++operand_index) { const uint32_t type_id = _.GetOperandTypeId(inst, operand_index); if (!type_id || !_.IsFloatVectorType(type_id)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected float vector as operand: " << spvOpcodeString(opcode) << " operand index " << operand_index; const uint32_t component_type = _.GetComponentType(type_id); if (component_type != result_type) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected component type to be equal to Result Type: " << spvOpcodeString(opcode) << " operand index " << operand_index; const uint32_t num_components = _.GetDimension(type_id); if (operand_index == 2) { first_vector_num_components = num_components; } else if (num_components != first_vector_num_components) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected operands to have the same number of components: " << spvOpcodeString(opcode); } } break; } case spv::Op::OpVectorTimesScalar: { if (!_.IsFloatVectorType(result_type) && !_.IsFloatCooperativeVectorNVType(result_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected float vector type as Result Type: " << spvOpcodeString(opcode); const uint32_t vector_type_id = _.GetOperandTypeId(inst, 2); if (result_type != vector_type_id) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected vector operand type to be equal to Result Type: " << spvOpcodeString(opcode); const uint32_t component_type = _.GetComponentType(vector_type_id); const uint32_t scalar_type_id = _.GetOperandTypeId(inst, 3); if (component_type != scalar_type_id) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected scalar operand type to be equal to the component " << "type of the vector operand: " << spvOpcodeString(opcode); break; } case spv::Op::OpMatrixTimesScalar: { if (!_.IsFloatMatrixType(result_type) && !(_.IsCooperativeMatrixType(result_type))) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected float matrix type as Result Type: " << spvOpcodeString(opcode); const uint32_t matrix_type_id = _.GetOperandTypeId(inst, 2); if (result_type != matrix_type_id) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected matrix operand type to be equal to Result Type: " << spvOpcodeString(opcode); const uint32_t component_type = _.GetComponentType(matrix_type_id); const uint32_t scalar_type_id = _.GetOperandTypeId(inst, 3); if (component_type != scalar_type_id) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected scalar operand type to be equal to the component " << "type of the matrix operand: " << spvOpcodeString(opcode); break; } case spv::Op::OpVectorTimesMatrix: { const uint32_t vector_type_id = _.GetOperandTypeId(inst, 2); const uint32_t matrix_type_id = _.GetOperandTypeId(inst, 3); if (!_.IsFloatVectorType(result_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected float vector type as Result Type: " << spvOpcodeString(opcode); const uint32_t res_component_type = _.GetComponentType(result_type); if (!vector_type_id || !_.IsFloatVectorType(vector_type_id)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected float vector type as left operand: " << spvOpcodeString(opcode); if (res_component_type != _.GetComponentType(vector_type_id)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected component types of Result Type and vector to be " << "equal: " << spvOpcodeString(opcode); uint32_t matrix_num_rows = 0; uint32_t matrix_num_cols = 0; uint32_t matrix_col_type = 0; uint32_t matrix_component_type = 0; if (!_.GetMatrixTypeInfo(matrix_type_id, &matrix_num_rows, &matrix_num_cols, &matrix_col_type, &matrix_component_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected float matrix type as right operand: " << spvOpcodeString(opcode); if (res_component_type != matrix_component_type) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected component types of Result Type and matrix to be " << "equal: " << spvOpcodeString(opcode); if (matrix_num_cols != _.GetDimension(result_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected number of columns of the matrix to be equal to " << "Result Type vector size: " << spvOpcodeString(opcode); if (matrix_num_rows != _.GetDimension(vector_type_id)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected number of rows of the matrix to be equal to the " << "vector operand size: " << spvOpcodeString(opcode); break; } case spv::Op::OpMatrixTimesVector: { const uint32_t matrix_type_id = _.GetOperandTypeId(inst, 2); const uint32_t vector_type_id = _.GetOperandTypeId(inst, 3); if (!_.IsFloatVectorType(result_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected float vector type as Result Type: " << spvOpcodeString(opcode); uint32_t matrix_num_rows = 0; uint32_t matrix_num_cols = 0; uint32_t matrix_col_type = 0; uint32_t matrix_component_type = 0; if (!_.GetMatrixTypeInfo(matrix_type_id, &matrix_num_rows, &matrix_num_cols, &matrix_col_type, &matrix_component_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected float matrix type as left operand: " << spvOpcodeString(opcode); if (result_type != matrix_col_type) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected column type of the matrix to be equal to Result " "Type: " << spvOpcodeString(opcode); if (!vector_type_id || !_.IsFloatVectorType(vector_type_id)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected float vector type as right operand: " << spvOpcodeString(opcode); if (matrix_component_type != _.GetComponentType(vector_type_id)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected component types of the operands to be equal: " << spvOpcodeString(opcode); if (matrix_num_cols != _.GetDimension(vector_type_id)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected number of columns of the matrix to be equal to the " << "vector size: " << spvOpcodeString(opcode); break; } case spv::Op::OpMatrixTimesMatrix: { const uint32_t left_type_id = _.GetOperandTypeId(inst, 2); const uint32_t right_type_id = _.GetOperandTypeId(inst, 3); uint32_t res_num_rows = 0; uint32_t res_num_cols = 0; uint32_t res_col_type = 0; uint32_t res_component_type = 0; if (!_.GetMatrixTypeInfo(result_type, &res_num_rows, &res_num_cols, &res_col_type, &res_component_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected float matrix type as Result Type: " << spvOpcodeString(opcode); uint32_t left_num_rows = 0; uint32_t left_num_cols = 0; uint32_t left_col_type = 0; uint32_t left_component_type = 0; if (!_.GetMatrixTypeInfo(left_type_id, &left_num_rows, &left_num_cols, &left_col_type, &left_component_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected float matrix type as left operand: " << spvOpcodeString(opcode); uint32_t right_num_rows = 0; uint32_t right_num_cols = 0; uint32_t right_col_type = 0; uint32_t right_component_type = 0; if (!_.GetMatrixTypeInfo(right_type_id, &right_num_rows, &right_num_cols, &right_col_type, &right_component_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected float matrix type as right operand: " << spvOpcodeString(opcode); if (!_.IsFloatScalarType(res_component_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected float matrix type as Result Type: " << spvOpcodeString(opcode); if (res_col_type != left_col_type) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected column types of Result Type and left matrix to be " << "equal: " << spvOpcodeString(opcode); if (res_component_type != right_component_type) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected component types of Result Type and right matrix to " "be " << "equal: " << spvOpcodeString(opcode); if (res_num_cols != right_num_cols) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected number of columns of Result Type and right matrix " "to " << "be equal: " << spvOpcodeString(opcode); if (left_num_cols != right_num_rows) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected number of columns of left matrix and number of " "rows " << "of right matrix to be equal: " << spvOpcodeString(opcode); assert(left_num_rows == res_num_rows); break; } case spv::Op::OpOuterProduct: { const uint32_t left_type_id = _.GetOperandTypeId(inst, 2); const uint32_t right_type_id = _.GetOperandTypeId(inst, 3); uint32_t res_num_rows = 0; uint32_t res_num_cols = 0; uint32_t res_col_type = 0; uint32_t res_component_type = 0; if (!_.GetMatrixTypeInfo(result_type, &res_num_rows, &res_num_cols, &res_col_type, &res_component_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected float matrix type as Result Type: " << spvOpcodeString(opcode); if (left_type_id != res_col_type) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected column type of Result Type to be equal to the type " << "of the left operand: " << spvOpcodeString(opcode); if (!right_type_id || !_.IsFloatVectorType(right_type_id)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected float vector type as right operand: " << spvOpcodeString(opcode); if (res_component_type != _.GetComponentType(right_type_id)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected component types of the operands to be equal: " << spvOpcodeString(opcode); if (res_num_cols != _.GetDimension(right_type_id)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected number of columns of the matrix to be equal to the " << "vector size of the right operand: " << spvOpcodeString(opcode); break; } case spv::Op::OpIAddCarry: case spv::Op::OpISubBorrow: case spv::Op::OpUMulExtended: case spv::Op::OpSMulExtended: { std::vector result_types; if (!_.GetStructMemberTypes(result_type, &result_types)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected a struct as Result Type: " << spvOpcodeString(opcode); if (result_types.size() != 2) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Result Type struct to have two members: " << spvOpcodeString(opcode); if (opcode == spv::Op::OpSMulExtended) { if (!_.IsIntScalarType(result_types[0]) && !_.IsIntVectorType(result_types[0])) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Result Type struct member types to be integer " "scalar " << "or vector: " << spvOpcodeString(opcode); } else { if (!_.IsUnsignedIntScalarType(result_types[0]) && !_.IsUnsignedIntVectorType(result_types[0])) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Result Type struct member types to be unsigned " << "integer scalar or vector: " << spvOpcodeString(opcode); } if (result_types[0] != result_types[1]) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Result Type struct member types to be identical: " << spvOpcodeString(opcode); const uint32_t left_type_id = _.GetOperandTypeId(inst, 2); const uint32_t right_type_id = _.GetOperandTypeId(inst, 3); if (left_type_id != result_types[0] || right_type_id != result_types[0]) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected both operands to be of Result Type member type: " << spvOpcodeString(opcode); break; } case spv::Op::OpCooperativeMatrixMulAddNV: { const uint32_t D_type_id = _.GetOperandTypeId(inst, 1); const uint32_t A_type_id = _.GetOperandTypeId(inst, 2); const uint32_t B_type_id = _.GetOperandTypeId(inst, 3); const uint32_t C_type_id = _.GetOperandTypeId(inst, 4); if (!_.IsCooperativeMatrixNVType(A_type_id)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected cooperative matrix type as A Type: " << spvOpcodeString(opcode); } if (!_.IsCooperativeMatrixNVType(B_type_id)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected cooperative matrix type as B Type: " << spvOpcodeString(opcode); } if (!_.IsCooperativeMatrixNVType(C_type_id)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected cooperative matrix type as C Type: " << spvOpcodeString(opcode); } if (!_.IsCooperativeMatrixNVType(D_type_id)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected cooperative matrix type as Result Type: " << spvOpcodeString(opcode); } const auto A = _.FindDef(A_type_id); const auto B = _.FindDef(B_type_id); const auto C = _.FindDef(C_type_id); const auto D = _.FindDef(D_type_id); std::tuple A_scope, B_scope, C_scope, D_scope, A_rows, B_rows, C_rows, D_rows, A_cols, B_cols, C_cols, D_cols; A_scope = _.EvalInt32IfConst(A->GetOperandAs(2)); B_scope = _.EvalInt32IfConst(B->GetOperandAs(2)); C_scope = _.EvalInt32IfConst(C->GetOperandAs(2)); D_scope = _.EvalInt32IfConst(D->GetOperandAs(2)); A_rows = _.EvalInt32IfConst(A->GetOperandAs(3)); B_rows = _.EvalInt32IfConst(B->GetOperandAs(3)); C_rows = _.EvalInt32IfConst(C->GetOperandAs(3)); D_rows = _.EvalInt32IfConst(D->GetOperandAs(3)); A_cols = _.EvalInt32IfConst(A->GetOperandAs(4)); B_cols = _.EvalInt32IfConst(B->GetOperandAs(4)); C_cols = _.EvalInt32IfConst(C->GetOperandAs(4)); D_cols = _.EvalInt32IfConst(D->GetOperandAs(4)); const auto notEqual = [](std::tuple X, std::tuple Y) { return (std::get<1>(X) && std::get<1>(Y) && std::get<2>(X) != std::get<2>(Y)); }; if (notEqual(A_scope, B_scope) || notEqual(A_scope, C_scope) || notEqual(A_scope, D_scope) || notEqual(B_scope, C_scope) || notEqual(B_scope, D_scope) || notEqual(C_scope, D_scope)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Cooperative matrix scopes must match: " << spvOpcodeString(opcode); } if (notEqual(A_rows, C_rows) || notEqual(A_rows, D_rows) || notEqual(C_rows, D_rows)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Cooperative matrix 'M' mismatch: " << spvOpcodeString(opcode); } if (notEqual(B_cols, C_cols) || notEqual(B_cols, D_cols) || notEqual(C_cols, D_cols)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Cooperative matrix 'N' mismatch: " << spvOpcodeString(opcode); } if (notEqual(A_cols, B_rows)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Cooperative matrix 'K' mismatch: " << spvOpcodeString(opcode); } break; } case spv::Op::OpCooperativeMatrixMulAddKHR: { const uint32_t D_type_id = _.GetOperandTypeId(inst, 1); const uint32_t A_type_id = _.GetOperandTypeId(inst, 2); const uint32_t B_type_id = _.GetOperandTypeId(inst, 3); const uint32_t C_type_id = _.GetOperandTypeId(inst, 4); if (!_.IsCooperativeMatrixAType(A_type_id)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Cooperative matrix type must be A Type: " << spvOpcodeString(opcode); } if (!_.IsCooperativeMatrixBType(B_type_id)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Cooperative matrix type must be B Type: " << spvOpcodeString(opcode); } if (!_.IsCooperativeMatrixAccType(C_type_id)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Cooperative matrix type must be Accumulator Type: " << spvOpcodeString(opcode); } if (!_.IsCooperativeMatrixKHRType(D_type_id)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected cooperative matrix type as Result Type: " << spvOpcodeString(opcode); } const auto A = _.FindDef(A_type_id); const auto B = _.FindDef(B_type_id); const auto C = _.FindDef(C_type_id); const auto D = _.FindDef(D_type_id); std::tuple A_scope, B_scope, C_scope, D_scope, A_rows, B_rows, C_rows, D_rows, A_cols, B_cols, C_cols, D_cols; A_scope = _.EvalInt32IfConst(A->GetOperandAs(2)); B_scope = _.EvalInt32IfConst(B->GetOperandAs(2)); C_scope = _.EvalInt32IfConst(C->GetOperandAs(2)); D_scope = _.EvalInt32IfConst(D->GetOperandAs(2)); A_rows = _.EvalInt32IfConst(A->GetOperandAs(3)); B_rows = _.EvalInt32IfConst(B->GetOperandAs(3)); C_rows = _.EvalInt32IfConst(C->GetOperandAs(3)); D_rows = _.EvalInt32IfConst(D->GetOperandAs(3)); A_cols = _.EvalInt32IfConst(A->GetOperandAs(4)); B_cols = _.EvalInt32IfConst(B->GetOperandAs(4)); C_cols = _.EvalInt32IfConst(C->GetOperandAs(4)); D_cols = _.EvalInt32IfConst(D->GetOperandAs(4)); const auto notEqual = [](std::tuple X, std::tuple Y) { return (std::get<1>(X) && std::get<1>(Y) && std::get<2>(X) != std::get<2>(Y)); }; if (notEqual(A_scope, B_scope) || notEqual(A_scope, C_scope) || notEqual(A_scope, D_scope) || notEqual(B_scope, C_scope) || notEqual(B_scope, D_scope) || notEqual(C_scope, D_scope)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Cooperative matrix scopes must match: " << spvOpcodeString(opcode); } if (notEqual(A_rows, C_rows) || notEqual(A_rows, D_rows) || notEqual(C_rows, D_rows)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Cooperative matrix 'M' mismatch: " << spvOpcodeString(opcode); } if (notEqual(B_cols, C_cols) || notEqual(B_cols, D_cols) || notEqual(C_cols, D_cols)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Cooperative matrix 'N' mismatch: " << spvOpcodeString(opcode); } if (notEqual(A_cols, B_rows)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Cooperative matrix 'K' mismatch: " << spvOpcodeString(opcode); } break; } case spv::Op::OpCooperativeMatrixReduceNV: { if (!_.IsCooperativeMatrixKHRType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Result Type must be a cooperative matrix type: " << spvOpcodeString(opcode); } const auto result_comp_type_id = _.FindDef(result_type)->GetOperandAs(1); const auto matrix_id = inst->GetOperandAs(2); const auto matrix = _.FindDef(matrix_id); const auto matrix_type_id = matrix->type_id(); if (!_.IsCooperativeMatrixKHRType(matrix_type_id)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Matrix must have a cooperative matrix type: " << spvOpcodeString(opcode); } const auto matrix_type = _.FindDef(matrix_type_id); const auto matrix_comp_type_id = matrix_type->GetOperandAs(1); if (matrix_comp_type_id != result_comp_type_id) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Result Type and Matrix type must have the same component " "type: " << spvOpcodeString(opcode); } if (_.FindDef(result_type)->GetOperandAs(2) != matrix_type->GetOperandAs(2)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Result Type and Matrix type must have the same scope: " << spvOpcodeString(opcode); } if (!_.IsCooperativeMatrixAccType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Result Type must have UseAccumulator: " << spvOpcodeString(opcode); } if (!_.IsCooperativeMatrixAccType(matrix_type_id)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Matrix type must have UseAccumulator: " << spvOpcodeString(opcode); } const auto reduce_value = inst->GetOperandAs(3); if ((reduce_value & uint32_t( spv::CooperativeMatrixReduceMask::CooperativeMatrixReduce2x2)) && (reduce_value & uint32_t(spv::CooperativeMatrixReduceMask::Row | spv::CooperativeMatrixReduceMask::Column))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Reduce 2x2 must not be used with Row/Column: " << spvOpcodeString(opcode); } std::tuple result_rows, result_cols, matrix_rows, matrix_cols; result_rows = _.EvalInt32IfConst(_.FindDef(result_type)->GetOperandAs(3)); result_cols = _.EvalInt32IfConst(_.FindDef(result_type)->GetOperandAs(4)); matrix_rows = _.EvalInt32IfConst(matrix_type->GetOperandAs(3)); matrix_cols = _.EvalInt32IfConst(matrix_type->GetOperandAs(4)); if (reduce_value & uint32_t( spv::CooperativeMatrixReduceMask::CooperativeMatrixReduce2x2)) { if (std::get<1>(result_rows) && std::get<1>(result_cols) && std::get<1>(matrix_rows) && std::get<1>(matrix_cols) && (std::get<2>(result_rows) != std::get<2>(matrix_rows) / 2 || std::get<2>(result_cols) != std::get<2>(matrix_cols) / 2)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "For Reduce2x2, result rows/cols must be half of matrix " "rows/cols: " << spvOpcodeString(opcode); } } if (reduce_value == uint32_t(spv::CooperativeMatrixReduceMask::Row)) { if (std::get<1>(result_rows) && std::get<1>(matrix_rows) && std::get<2>(result_rows) != std::get<2>(matrix_rows)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "For ReduceRow, result rows must match matrix rows: " << spvOpcodeString(opcode); } } if (reduce_value == uint32_t(spv::CooperativeMatrixReduceMask::Column)) { if (std::get<1>(result_cols) && std::get<1>(matrix_cols) && std::get<2>(result_cols) != std::get<2>(matrix_cols)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "For ReduceColumn, result cols must match matrix cols: " << spvOpcodeString(opcode); } } const auto combine_func_id = inst->GetOperandAs(4); const auto combine_func = _.FindDef(combine_func_id); if (!combine_func || combine_func->opcode() != spv::Op::OpFunction) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "CombineFunc must be a function: " << spvOpcodeString(opcode); } const auto function_type_id = combine_func->GetOperandAs(3); const auto function_type = _.FindDef(function_type_id); if (function_type->operands().size() != 4) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "CombineFunc must have two parameters: " << spvOpcodeString(opcode); } for (uint32_t i = 0; i < 3; ++i) { // checks return type and two params const auto param_type_id = function_type->GetOperandAs(i + 1); if (param_type_id != matrix_comp_type_id) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "CombineFunc return type and parameters must match matrix " "component type: " << spvOpcodeString(opcode); } } break; } default: break; } return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_atomics.cpp000066400000000000000000000433171475742701700246370ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights // reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validates correctness of atomic SPIR-V instructions. #include "source/opcode.h" #include "source/spirv_target_env.h" #include "source/util/bitutils.h" #include "source/val/instruction.h" #include "source/val/validate.h" #include "source/val/validate_memory_semantics.h" #include "source/val/validate_scopes.h" #include "source/val/validation_state.h" namespace { bool IsStorageClassAllowedByUniversalRules(spv::StorageClass storage_class) { switch (storage_class) { case spv::StorageClass::Uniform: case spv::StorageClass::StorageBuffer: case spv::StorageClass::Workgroup: case spv::StorageClass::CrossWorkgroup: case spv::StorageClass::Generic: case spv::StorageClass::AtomicCounter: case spv::StorageClass::Image: case spv::StorageClass::Function: case spv::StorageClass::PhysicalStorageBuffer: case spv::StorageClass::TaskPayloadWorkgroupEXT: return true; break; default: return false; } } bool HasReturnType(spv::Op opcode) { switch (opcode) { case spv::Op::OpAtomicStore: case spv::Op::OpAtomicFlagClear: return false; break; default: return true; } } bool HasOnlyFloatReturnType(spv::Op opcode) { switch (opcode) { case spv::Op::OpAtomicFAddEXT: case spv::Op::OpAtomicFMinEXT: case spv::Op::OpAtomicFMaxEXT: return true; break; default: return false; } } bool HasOnlyIntReturnType(spv::Op opcode) { switch (opcode) { case spv::Op::OpAtomicCompareExchange: case spv::Op::OpAtomicCompareExchangeWeak: case spv::Op::OpAtomicIIncrement: case spv::Op::OpAtomicIDecrement: case spv::Op::OpAtomicIAdd: case spv::Op::OpAtomicISub: case spv::Op::OpAtomicSMin: case spv::Op::OpAtomicUMin: case spv::Op::OpAtomicSMax: case spv::Op::OpAtomicUMax: case spv::Op::OpAtomicAnd: case spv::Op::OpAtomicOr: case spv::Op::OpAtomicXor: return true; break; default: return false; } } bool HasIntOrFloatReturnType(spv::Op opcode) { switch (opcode) { case spv::Op::OpAtomicLoad: case spv::Op::OpAtomicExchange: return true; break; default: return false; } } bool HasOnlyBoolReturnType(spv::Op opcode) { switch (opcode) { case spv::Op::OpAtomicFlagTestAndSet: return true; break; default: return false; } } } // namespace namespace spvtools { namespace val { // Validates correctness of atomic instructions. spv_result_t AtomicsPass(ValidationState_t& _, const Instruction* inst) { const spv::Op opcode = inst->opcode(); switch (opcode) { case spv::Op::OpAtomicLoad: case spv::Op::OpAtomicStore: case spv::Op::OpAtomicExchange: case spv::Op::OpAtomicFAddEXT: case spv::Op::OpAtomicCompareExchange: case spv::Op::OpAtomicCompareExchangeWeak: case spv::Op::OpAtomicIIncrement: case spv::Op::OpAtomicIDecrement: case spv::Op::OpAtomicIAdd: case spv::Op::OpAtomicISub: case spv::Op::OpAtomicSMin: case spv::Op::OpAtomicUMin: case spv::Op::OpAtomicFMinEXT: case spv::Op::OpAtomicSMax: case spv::Op::OpAtomicUMax: case spv::Op::OpAtomicFMaxEXT: case spv::Op::OpAtomicAnd: case spv::Op::OpAtomicOr: case spv::Op::OpAtomicXor: case spv::Op::OpAtomicFlagTestAndSet: case spv::Op::OpAtomicFlagClear: { const uint32_t result_type = inst->type_id(); // Validate return type first so can just check if pointer type is same // (if applicable) if (HasReturnType(opcode)) { if (HasOnlyFloatReturnType(opcode) && (!(_.HasCapability(spv::Capability::AtomicFloat16VectorNV) && _.IsFloat16Vector2Or4Type(result_type)) && !_.IsFloatScalarType(result_type))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": expected Result Type to be float scalar type"; } else if (HasOnlyIntReturnType(opcode) && !_.IsIntScalarType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": expected Result Type to be integer scalar type"; } else if (HasIntOrFloatReturnType(opcode) && !_.IsFloatScalarType(result_type) && !(opcode == spv::Op::OpAtomicExchange && _.HasCapability(spv::Capability::AtomicFloat16VectorNV) && _.IsFloat16Vector2Or4Type(result_type)) && !_.IsIntScalarType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": expected Result Type to be integer or float scalar type"; } else if (HasOnlyBoolReturnType(opcode) && !_.IsBoolScalarType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": expected Result Type to be bool scalar type"; } } uint32_t operand_index = HasReturnType(opcode) ? 2 : 0; const uint32_t pointer_type = _.GetOperandTypeId(inst, operand_index++); uint32_t data_type = 0; spv::StorageClass storage_class; if (!_.GetPointerTypeInfo(pointer_type, &data_type, &storage_class)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": expected Pointer to be a pointer type"; } // If the pointer is an untyped pointer, get the data type elsewhere. if (data_type == 0) { switch (opcode) { case spv::Op::OpAtomicLoad: case spv::Op::OpAtomicExchange: case spv::Op::OpAtomicFAddEXT: case spv::Op::OpAtomicCompareExchange: case spv::Op::OpAtomicCompareExchangeWeak: case spv::Op::OpAtomicIIncrement: case spv::Op::OpAtomicIDecrement: case spv::Op::OpAtomicIAdd: case spv::Op::OpAtomicISub: case spv::Op::OpAtomicSMin: case spv::Op::OpAtomicUMin: case spv::Op::OpAtomicFMinEXT: case spv::Op::OpAtomicSMax: case spv::Op::OpAtomicUMax: case spv::Op::OpAtomicFMaxEXT: case spv::Op::OpAtomicAnd: case spv::Op::OpAtomicOr: case spv::Op::OpAtomicXor: data_type = inst->type_id(); break; case spv::Op::OpAtomicFlagTestAndSet: case spv::Op::OpAtomicFlagClear: return _.diag(SPV_ERROR_INVALID_ID, inst) << "Untyped pointers are not supported by atomic flag " "instructions"; break; case spv::Op::OpAtomicStore: data_type = _.FindDef(inst->GetOperandAs(3))->type_id(); break; default: break; } } // Can't use result_type because OpAtomicStore doesn't have a result if (_.IsIntScalarType(data_type) && _.GetBitWidth(data_type) == 64 && !_.HasCapability(spv::Capability::Int64Atomics)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": 64-bit atomics require the Int64Atomics capability"; } // Validate storage class against universal rules if (!IsStorageClassAllowedByUniversalRules(storage_class)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": storage class forbidden by universal validation rules."; } // Then Shader rules if (_.HasCapability(spv::Capability::Shader)) { // Vulkan environment rule if (spvIsVulkanEnv(_.context()->target_env)) { if ((storage_class != spv::StorageClass::Uniform) && (storage_class != spv::StorageClass::StorageBuffer) && (storage_class != spv::StorageClass::Workgroup) && (storage_class != spv::StorageClass::Image) && (storage_class != spv::StorageClass::PhysicalStorageBuffer) && (storage_class != spv::StorageClass::TaskPayloadWorkgroupEXT)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(4686) << spvOpcodeString(opcode) << ": Vulkan spec only allows storage classes for atomic to " "be: Uniform, Workgroup, Image, StorageBuffer, " "PhysicalStorageBuffer or TaskPayloadWorkgroupEXT."; } } else if (storage_class == spv::StorageClass::Function) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": Function storage class forbidden when the Shader " "capability is declared."; } if (opcode == spv::Op::OpAtomicFAddEXT) { // result type being float checked already if (_.GetBitWidth(result_type) == 16) { if (_.IsFloat16Vector2Or4Type(result_type)) { if (!_.HasCapability(spv::Capability::AtomicFloat16VectorNV)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": float vector atomics require the " "AtomicFloat16VectorNV capability"; } else { if (!_.HasCapability(spv::Capability::AtomicFloat16AddEXT)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": float add atomics require the AtomicFloat32AddEXT " "capability"; } } } if ((_.GetBitWidth(result_type) == 32) && (!_.HasCapability(spv::Capability::AtomicFloat32AddEXT))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": float add atomics require the AtomicFloat32AddEXT " "capability"; } if ((_.GetBitWidth(result_type) == 64) && (!_.HasCapability(spv::Capability::AtomicFloat64AddEXT))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": float add atomics require the AtomicFloat64AddEXT " "capability"; } } else if (opcode == spv::Op::OpAtomicFMinEXT || opcode == spv::Op::OpAtomicFMaxEXT) { if (_.GetBitWidth(result_type) == 16) { if (_.IsFloat16Vector2Or4Type(result_type)) { if (!_.HasCapability(spv::Capability::AtomicFloat16VectorNV)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": float vector atomics require the " "AtomicFloat16VectorNV capability"; } else { if (!_.HasCapability(spv::Capability::AtomicFloat16MinMaxEXT)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": float min/max atomics require the " "AtomicFloat16MinMaxEXT capability"; } } } if ((_.GetBitWidth(result_type) == 32) && (!_.HasCapability(spv::Capability::AtomicFloat32MinMaxEXT))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": float min/max atomics require the " "AtomicFloat32MinMaxEXT capability"; } if ((_.GetBitWidth(result_type) == 64) && (!_.HasCapability(spv::Capability::AtomicFloat64MinMaxEXT))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": float min/max atomics require the " "AtomicFloat64MinMaxEXT capability"; } } } // And finally OpenCL environment rules if (spvIsOpenCLEnv(_.context()->target_env)) { if ((storage_class != spv::StorageClass::Function) && (storage_class != spv::StorageClass::Workgroup) && (storage_class != spv::StorageClass::CrossWorkgroup) && (storage_class != spv::StorageClass::Generic)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": storage class must be Function, Workgroup, " "CrossWorkGroup or Generic in the OpenCL environment."; } if (_.context()->target_env == SPV_ENV_OPENCL_1_2) { if (storage_class == spv::StorageClass::Generic) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Storage class cannot be Generic in OpenCL 1.2 " "environment"; } } } // If result and pointer type are different, need to do special check here if (opcode == spv::Op::OpAtomicFlagTestAndSet || opcode == spv::Op::OpAtomicFlagClear) { if (!_.IsIntScalarType(data_type) || _.GetBitWidth(data_type) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": expected Pointer to point to a value of 32-bit integer " "type"; } } else if (opcode == spv::Op::OpAtomicStore) { if (!_.IsFloatScalarType(data_type) && !_.IsIntScalarType(data_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": expected Pointer to be a pointer to integer or float " << "scalar type"; } } else if (data_type != result_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": expected Pointer to point to a value of type Result " "Type"; } auto memory_scope = inst->GetOperandAs(operand_index++); if (auto error = ValidateMemoryScope(_, inst, memory_scope)) { return error; } const auto equal_semantics_index = operand_index++; if (auto error = ValidateMemorySemantics(_, inst, equal_semantics_index, memory_scope)) return error; if (opcode == spv::Op::OpAtomicCompareExchange || opcode == spv::Op::OpAtomicCompareExchangeWeak) { const auto unequal_semantics_index = operand_index++; if (auto error = ValidateMemorySemantics( _, inst, unequal_semantics_index, memory_scope)) return error; // Volatile bits must match for equal and unequal semantics. Previous // checks guarantee they are 32-bit constants, but we need to recheck // whether they are evaluatable constants. bool is_int32 = false; bool is_equal_const = false; bool is_unequal_const = false; uint32_t equal_value = 0; uint32_t unequal_value = 0; std::tie(is_int32, is_equal_const, equal_value) = _.EvalInt32IfConst( inst->GetOperandAs(equal_semantics_index)); std::tie(is_int32, is_unequal_const, unequal_value) = _.EvalInt32IfConst( inst->GetOperandAs(unequal_semantics_index)); if (is_equal_const && is_unequal_const && ((equal_value & uint32_t(spv::MemorySemanticsMask::Volatile)) ^ (unequal_value & uint32_t(spv::MemorySemanticsMask::Volatile)))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Volatile mask setting must match for Equal and Unequal " "memory semantics"; } } if (opcode == spv::Op::OpAtomicStore) { const uint32_t value_type = _.GetOperandTypeId(inst, 3); if (value_type != data_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": expected Value type and the type pointed to by " "Pointer to be the same"; } } else if (opcode != spv::Op::OpAtomicLoad && opcode != spv::Op::OpAtomicIIncrement && opcode != spv::Op::OpAtomicIDecrement && opcode != spv::Op::OpAtomicFlagTestAndSet && opcode != spv::Op::OpAtomicFlagClear) { const uint32_t value_type = _.GetOperandTypeId(inst, operand_index++); if (value_type != result_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": expected Value to be of type Result Type"; } } if (opcode == spv::Op::OpAtomicCompareExchange || opcode == spv::Op::OpAtomicCompareExchangeWeak) { const uint32_t comparator_type = _.GetOperandTypeId(inst, operand_index++); if (comparator_type != result_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": expected Comparator to be of type Result Type"; } } break; } default: break; } return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_barriers.cpp000066400000000000000000000104461475742701700250060ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validates correctness of barrier SPIR-V instructions. #include #include "source/opcode.h" #include "source/spirv_constant.h" #include "source/val/instruction.h" #include "source/val/validate.h" #include "source/val/validate_memory_semantics.h" #include "source/val/validate_scopes.h" #include "source/val/validation_state.h" namespace spvtools { namespace val { // Validates correctness of barrier instructions. spv_result_t BarriersPass(ValidationState_t& _, const Instruction* inst) { const spv::Op opcode = inst->opcode(); const uint32_t result_type = inst->type_id(); switch (opcode) { case spv::Op::OpControlBarrier: { if (_.version() < SPV_SPIRV_VERSION_WORD(1, 3)) { _.function(inst->function()->id()) ->RegisterExecutionModelLimitation( [](spv::ExecutionModel model, std::string* message) { if (model != spv::ExecutionModel::TessellationControl && model != spv::ExecutionModel::GLCompute && model != spv::ExecutionModel::Kernel && model != spv::ExecutionModel::TaskNV && model != spv::ExecutionModel::MeshNV) { if (message) { *message = "OpControlBarrier requires one of the following " "Execution " "Models: TessellationControl, GLCompute, Kernel, " "MeshNV or TaskNV"; } return false; } return true; }); } const uint32_t execution_scope = inst->word(1); const uint32_t memory_scope = inst->word(2); if (auto error = ValidateExecutionScope(_, inst, execution_scope)) { return error; } if (auto error = ValidateMemoryScope(_, inst, memory_scope)) { return error; } if (auto error = ValidateMemorySemantics(_, inst, 2, memory_scope)) { return error; } break; } case spv::Op::OpMemoryBarrier: { const uint32_t memory_scope = inst->word(1); if (auto error = ValidateMemoryScope(_, inst, memory_scope)) { return error; } if (auto error = ValidateMemorySemantics(_, inst, 1, memory_scope)) { return error; } break; } case spv::Op::OpNamedBarrierInitialize: { if (_.GetIdOpcode(result_type) != spv::Op::OpTypeNamedBarrier) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": expected Result Type to be OpTypeNamedBarrier"; } const uint32_t subgroup_count_type = _.GetOperandTypeId(inst, 2); if (!_.IsIntScalarType(subgroup_count_type) || _.GetBitWidth(subgroup_count_type) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": expected Subgroup Count to be a 32-bit int"; } break; } case spv::Op::OpMemoryNamedBarrier: { const uint32_t named_barrier_type = _.GetOperandTypeId(inst, 0); if (_.GetIdOpcode(named_barrier_type) != spv::Op::OpTypeNamedBarrier) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": expected Named Barrier to be of type OpTypeNamedBarrier"; } const uint32_t memory_scope = inst->word(2); if (auto error = ValidateMemoryScope(_, inst, memory_scope)) { return error; } if (auto error = ValidateMemorySemantics(_, inst, 2, memory_scope)) { return error; } break; } default: break; } return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_bitwise.cpp000066400000000000000000000215051475742701700246410ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validates correctness of bitwise instructions. #include "source/opcode.h" #include "source/spirv_target_env.h" #include "source/val/instruction.h" #include "source/val/validate.h" #include "source/val/validation_state.h" namespace spvtools { namespace val { // Validates when base and result need to be the same type spv_result_t ValidateBaseType(ValidationState_t& _, const Instruction* inst, const uint32_t base_type) { const spv::Op opcode = inst->opcode(); if (!_.IsIntScalarType(base_type) && !_.IsIntVectorType(base_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected int scalar or vector type for Base operand: " << spvOpcodeString(opcode); } // Vulkan has a restriction to 32 bit for base if (spvIsVulkanEnv(_.context()->target_env)) { if (_.GetBitWidth(base_type) != 32 && !_.options()->allow_vulkan_32_bit_bitwise) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(4781) << "Expected 32-bit int type for Base operand: " << spvOpcodeString(opcode); } } // OpBitCount just needs same number of components if (base_type != inst->type_id() && opcode != spv::Op::OpBitCount) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Base Type to be equal to Result Type: " << spvOpcodeString(opcode); } return SPV_SUCCESS; } // Validates correctness of bitwise instructions. spv_result_t BitwisePass(ValidationState_t& _, const Instruction* inst) { const spv::Op opcode = inst->opcode(); const uint32_t result_type = inst->type_id(); switch (opcode) { case spv::Op::OpShiftRightLogical: case spv::Op::OpShiftRightArithmetic: case spv::Op::OpShiftLeftLogical: { if (!_.IsIntScalarType(result_type) && !_.IsIntVectorType(result_type) && !_.IsIntCooperativeVectorNVType(result_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected int scalar or vector type as Result Type: " << spvOpcodeString(opcode); const uint32_t result_dimension = _.GetDimension(result_type); const uint32_t base_type = _.GetOperandTypeId(inst, 2); const uint32_t shift_type = _.GetOperandTypeId(inst, 3); if (!base_type || (!_.IsIntScalarType(base_type) && !_.IsIntVectorType(base_type) && !_.IsIntCooperativeVectorNVType(base_type))) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Base to be int scalar or vector: " << spvOpcodeString(opcode); if (_.GetDimension(base_type) != result_dimension) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Base to have the same dimension " << "as Result Type: " << spvOpcodeString(opcode); if (_.GetBitWidth(base_type) != _.GetBitWidth(result_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Base to have the same bit width " << "as Result Type: " << spvOpcodeString(opcode); if (!shift_type || (!_.IsIntScalarType(shift_type) && !_.IsIntVectorType(shift_type) && !_.IsIntCooperativeVectorNVType(shift_type))) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Shift to be int scalar or vector: " << spvOpcodeString(opcode); if (_.GetDimension(shift_type) != result_dimension) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Shift to have the same dimension " << "as Result Type: " << spvOpcodeString(opcode); break; } case spv::Op::OpBitwiseOr: case spv::Op::OpBitwiseXor: case spv::Op::OpBitwiseAnd: case spv::Op::OpNot: { if (!_.IsIntScalarType(result_type) && !_.IsIntVectorType(result_type) && !_.IsIntCooperativeVectorNVType(result_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected int scalar or vector type as Result Type: " << spvOpcodeString(opcode); const uint32_t result_dimension = _.GetDimension(result_type); const uint32_t result_bit_width = _.GetBitWidth(result_type); for (size_t operand_index = 2; operand_index < inst->operands().size(); ++operand_index) { const uint32_t type_id = _.GetOperandTypeId(inst, operand_index); if (!type_id || (!_.IsIntScalarType(type_id) && !_.IsIntVectorType(type_id) && !_.IsIntCooperativeVectorNVType(type_id))) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected int scalar or vector as operand: " << spvOpcodeString(opcode) << " operand index " << operand_index; if (_.GetDimension(type_id) != result_dimension) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected operands to have the same dimension " << "as Result Type: " << spvOpcodeString(opcode) << " operand index " << operand_index; if (_.GetBitWidth(type_id) != result_bit_width) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected operands to have the same bit width " << "as Result Type: " << spvOpcodeString(opcode) << " operand index " << operand_index; } break; } case spv::Op::OpBitFieldInsert: { const uint32_t base_type = _.GetOperandTypeId(inst, 2); const uint32_t insert_type = _.GetOperandTypeId(inst, 3); const uint32_t offset_type = _.GetOperandTypeId(inst, 4); const uint32_t count_type = _.GetOperandTypeId(inst, 5); if (spv_result_t error = ValidateBaseType(_, inst, base_type)) { return error; } if (insert_type != result_type) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Insert Type to be equal to Result Type: " << spvOpcodeString(opcode); if (!offset_type || !_.IsIntScalarType(offset_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Offset Type to be int scalar: " << spvOpcodeString(opcode); if (!count_type || !_.IsIntScalarType(count_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Count Type to be int scalar: " << spvOpcodeString(opcode); break; } case spv::Op::OpBitFieldSExtract: case spv::Op::OpBitFieldUExtract: { const uint32_t base_type = _.GetOperandTypeId(inst, 2); const uint32_t offset_type = _.GetOperandTypeId(inst, 3); const uint32_t count_type = _.GetOperandTypeId(inst, 4); if (spv_result_t error = ValidateBaseType(_, inst, base_type)) { return error; } if (!offset_type || !_.IsIntScalarType(offset_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Offset Type to be int scalar: " << spvOpcodeString(opcode); if (!count_type || !_.IsIntScalarType(count_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Count Type to be int scalar: " << spvOpcodeString(opcode); break; } case spv::Op::OpBitReverse: { const uint32_t base_type = _.GetOperandTypeId(inst, 2); if (spv_result_t error = ValidateBaseType(_, inst, base_type)) { return error; } break; } case spv::Op::OpBitCount: { if (!_.IsIntScalarType(result_type) && !_.IsIntVectorType(result_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected int scalar or vector type as Result Type: " << spvOpcodeString(opcode); const uint32_t base_type = _.GetOperandTypeId(inst, 2); if (spv_result_t error = ValidateBaseType(_, inst, base_type)) { return error; } const uint32_t base_dimension = _.GetDimension(base_type); const uint32_t result_dimension = _.GetDimension(result_type); if (base_dimension != result_dimension) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Base dimension to be equal to Result Type " "dimension: " << spvOpcodeString(opcode); break; } default: break; } return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_builtins.cpp000066400000000000000000006370461475742701700250410ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights // reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validates correctness of built-in variables. #include #include #include #include #include #include #include #include #include #include "source/opcode.h" #include "source/spirv_target_env.h" #include "source/util/bitutils.h" #include "source/val/instruction.h" #include "source/val/validate.h" #include "source/val/validation_state.h" namespace spvtools { namespace val { namespace { // Returns a short textual description of the id defined by the given // instruction. std::string GetIdDesc(const Instruction& inst) { std::ostringstream ss; ss << "ID <" << inst.id() << "> (Op" << spvOpcodeString(inst.opcode()) << ")"; return ss.str(); } // Gets underlying data type which is // - member type if instruction is OpTypeStruct // (member index is taken from decoration). // - data type if id creates a pointer. // - type of the constant if instruction is OpConst or OpSpecConst. // // Fails in any other case. The function is based on built-ins allowed by // the Vulkan spec. // TODO: If non-Vulkan validation rules are added then it might need // to be refactored. spv_result_t GetUnderlyingType(ValidationState_t& _, const Decoration& decoration, const Instruction& inst, uint32_t* underlying_type) { if (decoration.struct_member_index() != Decoration::kInvalidMember) { if (inst.opcode() != spv::Op::OpTypeStruct) { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << GetIdDesc(inst) << "Attempted to get underlying data type via member index for " "non-struct type."; } *underlying_type = inst.word(decoration.struct_member_index() + 2); return SPV_SUCCESS; } if (inst.opcode() == spv::Op::OpTypeStruct) { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << GetIdDesc(inst) << " did not find an member index to get underlying data type for " "struct type."; } if (spvOpcodeIsConstant(inst.opcode())) { *underlying_type = inst.type_id(); return SPV_SUCCESS; } spv::StorageClass storage_class; if (!_.GetPointerTypeInfo(inst.type_id(), underlying_type, &storage_class)) { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << GetIdDesc(inst) << " is decorated with BuiltIn. BuiltIn decoration should only be " "applied to struct types, variables and constants."; } return SPV_SUCCESS; } // Returns Storage Class used by the instruction if applicable. // Returns spv::StorageClass::Max if not. spv::StorageClass GetStorageClass(const Instruction& inst) { switch (inst.opcode()) { case spv::Op::OpTypePointer: case spv::Op::OpTypeUntypedPointerKHR: case spv::Op::OpTypeForwardPointer: { return spv::StorageClass(inst.word(2)); } case spv::Op::OpVariable: { return spv::StorageClass(inst.word(3)); } case spv::Op::OpUntypedVariableKHR: { return spv::StorageClass(inst.word(4)); } case spv::Op::OpGenericCastToPtrExplicit: { return spv::StorageClass(inst.word(4)); } default: { break; } } return spv::StorageClass::Max; } typedef enum VUIDError_ { VUIDErrorExecutionModel = 0, VUIDErrorStorageClass = 1, VUIDErrorType = 2, VUIDErrorMax, } VUIDError; const static uint32_t NumVUIDBuiltins = 40; typedef struct { spv::BuiltIn builtIn; uint32_t vuid[VUIDErrorMax]; // execution mode, storage class, type VUIDs } BuiltinVUIDMapping; // Many built-ins have the same checks (Storage Class, Type, etc) // This table provides a nice LUT for the VUIDs std::array builtinVUIDInfo = {{ // clang-format off {spv::BuiltIn::SubgroupEqMask, {0, 4370, 4371}}, {spv::BuiltIn::SubgroupGeMask, {0, 4372, 4373}}, {spv::BuiltIn::SubgroupGtMask, {0, 4374, 4375}}, {spv::BuiltIn::SubgroupLeMask, {0, 4376, 4377}}, {spv::BuiltIn::SubgroupLtMask, {0, 4378, 4379}}, {spv::BuiltIn::SubgroupLocalInvocationId, {0, 4380, 4381}}, {spv::BuiltIn::SubgroupSize, {0, 4382, 4383}}, {spv::BuiltIn::GlobalInvocationId, {4236, 4237, 4238}}, {spv::BuiltIn::LocalInvocationId, {4281, 4282, 4283}}, {spv::BuiltIn::NumWorkgroups, {4296, 4297, 4298}}, {spv::BuiltIn::NumSubgroups, {4293, 4294, 4295}}, {spv::BuiltIn::SubgroupId, {4367, 4368, 4369}}, {spv::BuiltIn::WorkgroupId, {4422, 4423, 4424}}, {spv::BuiltIn::HitKindKHR, {4242, 4243, 4244}}, {spv::BuiltIn::HitTNV, {4245, 4246, 4247}}, {spv::BuiltIn::InstanceCustomIndexKHR, {4251, 4252, 4253}}, {spv::BuiltIn::InstanceId, {4254, 4255, 4256}}, {spv::BuiltIn::RayGeometryIndexKHR, {4345, 4346, 4347}}, {spv::BuiltIn::ObjectRayDirectionKHR, {4299, 4300, 4301}}, {spv::BuiltIn::ObjectRayOriginKHR, {4302, 4303, 4304}}, {spv::BuiltIn::ObjectToWorldKHR, {4305, 4306, 4307}}, {spv::BuiltIn::WorldToObjectKHR, {4434, 4435, 4436}}, {spv::BuiltIn::IncomingRayFlagsKHR, {4248, 4249, 4250}}, {spv::BuiltIn::RayTminKHR, {4351, 4352, 4353}}, {spv::BuiltIn::RayTmaxKHR, {4348, 4349, 4350}}, {spv::BuiltIn::WorldRayDirectionKHR, {4428, 4429, 4430}}, {spv::BuiltIn::WorldRayOriginKHR, {4431, 4432, 4433}}, {spv::BuiltIn::LaunchIdKHR, {4266, 4267, 4268}}, {spv::BuiltIn::LaunchSizeKHR, {4269, 4270, 4271}}, {spv::BuiltIn::FragInvocationCountEXT, {4217, 4218, 4219}}, {spv::BuiltIn::FragSizeEXT, {4220, 4221, 4222}}, {spv::BuiltIn::FragStencilRefEXT, {4223, 4224, 4225}}, {spv::BuiltIn::FullyCoveredEXT, {4232, 4233, 4234}}, {spv::BuiltIn::CullMaskKHR, {6735, 6736, 6737}}, {spv::BuiltIn::BaryCoordKHR, {4154, 4155, 4156}}, {spv::BuiltIn::BaryCoordNoPerspKHR, {4160, 4161, 4162}}, {spv::BuiltIn::PrimitivePointIndicesEXT, {7041, 7043, 7044}}, {spv::BuiltIn::PrimitiveLineIndicesEXT, {7047, 7049, 7050}}, {spv::BuiltIn::PrimitiveTriangleIndicesEXT, {7053, 7055, 7056}}, {spv::BuiltIn::CullPrimitiveEXT, {7034, 7035, 7036}}, // clang-format on }}; uint32_t GetVUIDForBuiltin(spv::BuiltIn builtIn, VUIDError type) { uint32_t vuid = 0; for (const auto& iter: builtinVUIDInfo) { if (iter.builtIn == builtIn) { assert(type < VUIDErrorMax); vuid = iter.vuid[type]; break; } } return vuid; } bool IsExecutionModelValidForRtBuiltIn(spv::BuiltIn builtin, spv::ExecutionModel stage) { switch (builtin) { case spv::BuiltIn::HitKindKHR: case spv::BuiltIn::HitTNV: if (stage == spv::ExecutionModel::AnyHitKHR || stage == spv::ExecutionModel::ClosestHitKHR) { return true; } break; case spv::BuiltIn::InstanceCustomIndexKHR: case spv::BuiltIn::InstanceId: case spv::BuiltIn::RayGeometryIndexKHR: case spv::BuiltIn::ObjectRayDirectionKHR: case spv::BuiltIn::ObjectRayOriginKHR: case spv::BuiltIn::ObjectToWorldKHR: case spv::BuiltIn::WorldToObjectKHR: switch (stage) { case spv::ExecutionModel::IntersectionKHR: case spv::ExecutionModel::AnyHitKHR: case spv::ExecutionModel::ClosestHitKHR: return true; default: return false; } break; case spv::BuiltIn::IncomingRayFlagsKHR: case spv::BuiltIn::RayTminKHR: case spv::BuiltIn::RayTmaxKHR: case spv::BuiltIn::WorldRayDirectionKHR: case spv::BuiltIn::WorldRayOriginKHR: case spv::BuiltIn::CullMaskKHR: switch (stage) { case spv::ExecutionModel::IntersectionKHR: case spv::ExecutionModel::AnyHitKHR: case spv::ExecutionModel::ClosestHitKHR: case spv::ExecutionModel::MissKHR: return true; default: return false; } break; case spv::BuiltIn::LaunchIdKHR: case spv::BuiltIn::LaunchSizeKHR: switch (stage) { case spv::ExecutionModel::RayGenerationKHR: case spv::ExecutionModel::IntersectionKHR: case spv::ExecutionModel::AnyHitKHR: case spv::ExecutionModel::ClosestHitKHR: case spv::ExecutionModel::MissKHR: case spv::ExecutionModel::CallableKHR: return true; default: return false; } break; default: break; } return false; } // Helper class managing validation of built-ins. // TODO: Generic functionality of this class can be moved into // ValidationState_t to be made available to other users. class BuiltInsValidator { public: BuiltInsValidator(ValidationState_t& vstate) : _(vstate) {} // Run validation. spv_result_t Run(); private: // Goes through all decorations in the module, if decoration is BuiltIn // calls ValidateSingleBuiltInAtDefinition(). spv_result_t ValidateBuiltInsAtDefinition(); // Validates the instruction defining an id with built-in decoration. // Can be called multiple times for the same id, if multiple built-ins are // specified. Seeds id_to_at_reference_checks_ with decorated ids if needed. spv_result_t ValidateSingleBuiltInAtDefinition(const Decoration& decoration, const Instruction& inst); spv_result_t ValidateSingleBuiltInAtDefinitionVulkan( const Decoration& decoration, const Instruction& inst, const spv::BuiltIn label); // The following section contains functions which are called when id defined // by |inst| is decorated with BuiltIn |decoration|. // Most functions are specific to a single built-in and have naming scheme: // ValidateXYZAtDefinition. Some functions are common to multiple kinds of // BuiltIn. spv_result_t ValidateClipOrCullDistanceAtDefinition( const Decoration& decoration, const Instruction& inst); spv_result_t ValidateFragCoordAtDefinition(const Decoration& decoration, const Instruction& inst); spv_result_t ValidateFragDepthAtDefinition(const Decoration& decoration, const Instruction& inst); spv_result_t ValidateFrontFacingAtDefinition(const Decoration& decoration, const Instruction& inst); spv_result_t ValidateHelperInvocationAtDefinition( const Decoration& decoration, const Instruction& inst); spv_result_t ValidateInvocationIdAtDefinition(const Decoration& decoration, const Instruction& inst); spv_result_t ValidateInstanceIndexAtDefinition(const Decoration& decoration, const Instruction& inst); spv_result_t ValidateLayerOrViewportIndexAtDefinition( const Decoration& decoration, const Instruction& inst); spv_result_t ValidatePatchVerticesAtDefinition(const Decoration& decoration, const Instruction& inst); spv_result_t ValidatePointCoordAtDefinition(const Decoration& decoration, const Instruction& inst); spv_result_t ValidatePointSizeAtDefinition(const Decoration& decoration, const Instruction& inst); spv_result_t ValidatePositionAtDefinition(const Decoration& decoration, const Instruction& inst); spv_result_t ValidatePrimitiveIdAtDefinition(const Decoration& decoration, const Instruction& inst); spv_result_t ValidateSampleIdAtDefinition(const Decoration& decoration, const Instruction& inst); spv_result_t ValidateSampleMaskAtDefinition(const Decoration& decoration, const Instruction& inst); spv_result_t ValidateSamplePositionAtDefinition(const Decoration& decoration, const Instruction& inst); spv_result_t ValidateTessCoordAtDefinition(const Decoration& decoration, const Instruction& inst); spv_result_t ValidateTessLevelOuterAtDefinition(const Decoration& decoration, const Instruction& inst); spv_result_t ValidateTessLevelInnerAtDefinition(const Decoration& decoration, const Instruction& inst); spv_result_t ValidateVertexIndexAtDefinition(const Decoration& decoration, const Instruction& inst); spv_result_t ValidateVertexIdAtDefinition(const Decoration& decoration, const Instruction& inst); spv_result_t ValidateLocalInvocationIndexAtDefinition( const Decoration& decoration, const Instruction& inst); spv_result_t ValidateWorkgroupSizeAtDefinition(const Decoration& decoration, const Instruction& inst); spv_result_t ValidateBaseInstanceOrVertexAtDefinition( const Decoration& decoration, const Instruction& inst); spv_result_t ValidateDrawIndexAtDefinition(const Decoration& decoration, const Instruction& inst); spv_result_t ValidateViewIndexAtDefinition(const Decoration& decoration, const Instruction& inst); spv_result_t ValidateDeviceIndexAtDefinition(const Decoration& decoration, const Instruction& inst); spv_result_t ValidateFragInvocationCountAtDefinition(const Decoration& decoration, const Instruction& inst); spv_result_t ValidateFragSizeAtDefinition(const Decoration& decoration, const Instruction& inst); spv_result_t ValidateFragStencilRefAtDefinition(const Decoration& decoration, const Instruction& inst); spv_result_t ValidateFullyCoveredAtDefinition(const Decoration& decoration, const Instruction& inst); // Used for GlobalInvocationId, LocalInvocationId, NumWorkgroups, WorkgroupId. spv_result_t ValidateComputeShaderI32Vec3InputAtDefinition( const Decoration& decoration, const Instruction& inst); spv_result_t ValidateNVSMOrARMCoreBuiltinsAtDefinition(const Decoration& decoration, const Instruction& inst); // Used for BaryCoord, BaryCoordNoPersp. spv_result_t ValidateFragmentShaderF32Vec3InputAtDefinition( const Decoration& decoration, const Instruction& inst); // Used for SubgroupEqMask, SubgroupGeMask, SubgroupGtMask, SubgroupLtMask, // SubgroupLeMask. spv_result_t ValidateI32Vec4InputAtDefinition(const Decoration& decoration, const Instruction& inst); // Used for SubgroupLocalInvocationId, SubgroupSize. spv_result_t ValidateI32InputAtDefinition(const Decoration& decoration, const Instruction& inst); // Used for SubgroupId, NumSubgroups. spv_result_t ValidateComputeI32InputAtDefinition(const Decoration& decoration, const Instruction& inst); spv_result_t ValidatePrimitiveShadingRateAtDefinition( const Decoration& decoration, const Instruction& inst); spv_result_t ValidateShadingRateAtDefinition(const Decoration& decoration, const Instruction& inst); spv_result_t ValidateRayTracingBuiltinsAtDefinition( const Decoration& decoration, const Instruction& inst); spv_result_t ValidateMeshShadingEXTBuiltinsAtDefinition( const Decoration& decoration, const Instruction& inst); // The following section contains functions which are called when id defined // by |referenced_inst| is // 1. referenced by |referenced_from_inst| // 2. dependent on |built_in_inst| which is decorated with BuiltIn // |decoration|. Most functions are specific to a single built-in and have // naming scheme: ValidateXYZAtReference. Some functions are common to // multiple kinds of BuiltIn. spv_result_t ValidateFragCoordAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); spv_result_t ValidateFragDepthAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); spv_result_t ValidateFrontFacingAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); spv_result_t ValidateHelperInvocationAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); spv_result_t ValidateInvocationIdAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); spv_result_t ValidateInstanceIndexAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); spv_result_t ValidatePatchVerticesAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); spv_result_t ValidatePointCoordAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); spv_result_t ValidatePointSizeAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); spv_result_t ValidatePositionAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); spv_result_t ValidatePrimitiveIdAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); spv_result_t ValidateSampleIdAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); spv_result_t ValidateSampleMaskAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); spv_result_t ValidateSamplePositionAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); spv_result_t ValidateTessCoordAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); spv_result_t ValidateTessLevelAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); spv_result_t ValidateLocalInvocationIndexAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); spv_result_t ValidateVertexIndexAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); spv_result_t ValidateLayerOrViewportIndexAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); spv_result_t ValidateWorkgroupSizeAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); spv_result_t ValidateClipOrCullDistanceAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); spv_result_t ValidateBaseInstanceOrVertexAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); spv_result_t ValidateDrawIndexAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); spv_result_t ValidateViewIndexAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); spv_result_t ValidateDeviceIndexAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); spv_result_t ValidateFragInvocationCountAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); spv_result_t ValidateFragSizeAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); spv_result_t ValidateFragStencilRefAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); spv_result_t ValidateFullyCoveredAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); // Used for GlobalInvocationId, LocalInvocationId, NumWorkgroups, WorkgroupId. spv_result_t ValidateComputeShaderI32Vec3InputAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); // Used for BaryCoord, BaryCoordNoPersp. spv_result_t ValidateFragmentShaderF32Vec3InputAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); // Used for SubgroupId and NumSubgroups. spv_result_t ValidateComputeI32InputAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); spv_result_t ValidateNVSMOrARMCoreBuiltinsAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); spv_result_t ValidatePrimitiveShadingRateAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); spv_result_t ValidateShadingRateAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); spv_result_t ValidateRayTracingBuiltinsAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); spv_result_t ValidateMeshShadingEXTBuiltinsAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); // Validates that |built_in_inst| is not (even indirectly) referenced from // within a function which can be called with |execution_model|. // // |vuid| - Vulkan ID for the error, or a negative value if none. // |comment| - text explaining why the restriction was imposed. // |decoration| - BuiltIn decoration which causes the restriction. // |referenced_inst| - instruction which is dependent on |built_in_inst| and // defines the id which was referenced. // |referenced_from_inst| - instruction which references id defined by // |referenced_inst| from within a function. spv_result_t ValidateNotCalledWithExecutionModel( int vuid, const char* comment, spv::ExecutionModel execution_model, const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst); // The following section contains functions which check that the decorated // variable has the type specified in the function name. |diag| would be // called with a corresponding error message, if validation is not successful. spv_result_t ValidateBool( const Decoration& decoration, const Instruction& inst, const std::function& diag); spv_result_t ValidateI( const Decoration& decoration, const Instruction& inst, const std::function& diag); spv_result_t ValidateI32( const Decoration& decoration, const Instruction& inst, const std::function& diag); spv_result_t ValidateI32Vec( const Decoration& decoration, const Instruction& inst, uint32_t num_components, const std::function& diag); spv_result_t ValidateI32Arr( const Decoration& decoration, const Instruction& inst, const std::function& diag); spv_result_t ValidateArrayedI32Vec( const Decoration& decoration, const Instruction& inst, uint32_t num_components, const std::function& diag); spv_result_t ValidateOptionalArrayedI32( const Decoration& decoration, const Instruction& inst, const std::function& diag); spv_result_t ValidateI32Helper( const Decoration& decoration, const Instruction& inst, const std::function& diag, uint32_t underlying_type); spv_result_t ValidateF32( const Decoration& decoration, const Instruction& inst, const std::function& diag); spv_result_t ValidateOptionalArrayedF32( const Decoration& decoration, const Instruction& inst, const std::function& diag); spv_result_t ValidateF32Helper( const Decoration& decoration, const Instruction& inst, const std::function& diag, uint32_t underlying_type); spv_result_t ValidateF32Vec( const Decoration& decoration, const Instruction& inst, uint32_t num_components, const std::function& diag); spv_result_t ValidateOptionalArrayedF32Vec( const Decoration& decoration, const Instruction& inst, uint32_t num_components, const std::function& diag); spv_result_t ValidateF32VecHelper( const Decoration& decoration, const Instruction& inst, uint32_t num_components, const std::function& diag, uint32_t underlying_type); // If |num_components| is zero, the number of components is not checked. spv_result_t ValidateF32Arr( const Decoration& decoration, const Instruction& inst, uint32_t num_components, const std::function& diag); spv_result_t ValidateOptionalArrayedF32Arr( const Decoration& decoration, const Instruction& inst, uint32_t num_components, const std::function& diag); spv_result_t ValidateF32ArrHelper( const Decoration& decoration, const Instruction& inst, uint32_t num_components, const std::function& diag, uint32_t underlying_type); spv_result_t ValidateF32Mat( const Decoration& decoration, const Instruction& inst, uint32_t req_num_rows, uint32_t req_num_columns, const std::function& diag); // Generates strings like "Member #0 of struct ID <2>". std::string GetDefinitionDesc(const Decoration& decoration, const Instruction& inst) const; // Generates strings like "ID <51> (OpTypePointer) is referencing ID <2> // (OpTypeStruct) which is decorated with BuiltIn Position". std::string GetReferenceDesc( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst, spv::ExecutionModel execution_model = spv::ExecutionModel::Max) const; // Generates strings like "ID <51> (OpTypePointer) uses storage class // UniformConstant". std::string GetStorageClassDesc(const Instruction& inst) const; // Updates inner working of the class. Is called sequentially for every // instruction. void Update(const Instruction& inst); // Check if "inst" is an interface variable // or type of a interface varibale of any mesh entry point bool isMeshInterfaceVar(const Instruction& inst) { auto getUnderlyingTypeId = [&](const Instruction* ifxVar) { auto pointerTypeInst = _.FindDef(ifxVar->type_id()); auto typeInst = _.FindDef(pointerTypeInst->GetOperandAs(2)); while (typeInst->opcode() == spv::Op::OpTypeArray) { typeInst = _.FindDef(typeInst->GetOperandAs(1)); }; return typeInst->id(); }; for (const uint32_t entry_point : _.entry_points()) { const auto* models = _.GetExecutionModels(entry_point); if (models->find(spv::ExecutionModel::MeshEXT) != models->end() || models->find(spv::ExecutionModel::MeshNV) != models->end()) { for (const auto& desc : _.entry_point_descriptions(entry_point)) { for (auto interface : desc.interfaces) { if (inst.opcode() == spv::Op::OpTypeStruct) { auto varInst = _.FindDef(interface); if (inst.id() == getUnderlyingTypeId(varInst)) return true; } else if (inst.id() == interface) { return true; } } } } } return false; } ValidationState_t& _; // Mapping id -> list of rules which validate instruction referencing the // id. Rules can create new rules and add them to this container. // Using std::map, and not std::unordered_map to avoid iterator invalidation // during rehashing. std::map>> id_to_at_reference_checks_; // Id of the function we are currently inside. 0 if not inside a function. uint32_t function_id_ = 0; // Entry points which can (indirectly) call the current function. // The pointer either points to a vector inside to function_to_entry_points_ // or to no_entry_points_. The pointer is guaranteed to never be null. const std::vector no_entry_points; const std::vector* entry_points_ = &no_entry_points; // Execution models with which the current function can be called. std::set execution_models_; }; void BuiltInsValidator::Update(const Instruction& inst) { const spv::Op opcode = inst.opcode(); if (opcode == spv::Op::OpFunction) { // Entering a function. assert(function_id_ == 0); function_id_ = inst.id(); execution_models_.clear(); entry_points_ = &_.FunctionEntryPoints(function_id_); // Collect execution models from all entry points from which the current // function can be called. for (const uint32_t entry_point : *entry_points_) { if (const auto* models = _.GetExecutionModels(entry_point)) { execution_models_.insert(models->begin(), models->end()); } } } if (opcode == spv::Op::OpFunctionEnd) { // Exiting a function. assert(function_id_ != 0); function_id_ = 0; entry_points_ = &no_entry_points; execution_models_.clear(); } } std::string BuiltInsValidator::GetDefinitionDesc( const Decoration& decoration, const Instruction& inst) const { std::ostringstream ss; if (decoration.struct_member_index() != Decoration::kInvalidMember) { assert(inst.opcode() == spv::Op::OpTypeStruct); ss << "Member #" << decoration.struct_member_index(); ss << " of struct ID <" << inst.id() << ">"; } else { ss << GetIdDesc(inst); } return ss.str(); } std::string BuiltInsValidator::GetReferenceDesc( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst, spv::ExecutionModel execution_model) const { std::ostringstream ss; ss << GetIdDesc(referenced_from_inst) << " is referencing " << GetIdDesc(referenced_inst); if (built_in_inst.id() != referenced_inst.id()) { ss << " which is dependent on " << GetIdDesc(built_in_inst); } ss << " which is decorated with BuiltIn "; ss << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, (uint32_t)decoration.builtin()); if (function_id_) { ss << " in function <" << function_id_ << ">"; if (execution_model != spv::ExecutionModel::Max) { ss << " called with execution model "; ss << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_EXECUTION_MODEL, uint32_t(execution_model)); } } ss << "."; return ss.str(); } std::string BuiltInsValidator::GetStorageClassDesc( const Instruction& inst) const { std::ostringstream ss; ss << GetIdDesc(inst) << " uses storage class "; ss << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_STORAGE_CLASS, uint32_t(GetStorageClass(inst))); ss << "."; return ss.str(); } spv_result_t BuiltInsValidator::ValidateBool( const Decoration& decoration, const Instruction& inst, const std::function& diag) { uint32_t underlying_type = 0; if (spv_result_t error = GetUnderlyingType(_, decoration, inst, &underlying_type)) { return error; } if (!_.IsBoolScalarType(underlying_type)) { return diag(GetDefinitionDesc(decoration, inst) + " is not a bool scalar."); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateI( const Decoration& decoration, const Instruction& inst, const std::function& diag) { uint32_t underlying_type = 0; if (spv_result_t error = GetUnderlyingType(_, decoration, inst, &underlying_type)) { return error; } if (!_.IsIntScalarType(underlying_type)) { return diag(GetDefinitionDesc(decoration, inst) + " is not an int scalar."); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateI32( const Decoration& decoration, const Instruction& inst, const std::function& diag) { uint32_t underlying_type = 0; if (spv_result_t error = GetUnderlyingType(_, decoration, inst, &underlying_type)) { return error; } return ValidateI32Helper(decoration, inst, diag, underlying_type); } spv_result_t BuiltInsValidator::ValidateOptionalArrayedI32( const Decoration& decoration, const Instruction& inst, const std::function& diag) { uint32_t underlying_type = 0; if (spv_result_t error = GetUnderlyingType(_, decoration, inst, &underlying_type)) { return error; } // Strip the array, if present. if (_.GetIdOpcode(underlying_type) == spv::Op::OpTypeArray) { underlying_type = _.FindDef(underlying_type)->word(2u); } return ValidateI32Helper(decoration, inst, diag, underlying_type); } spv_result_t BuiltInsValidator::ValidateI32Helper( const Decoration& decoration, const Instruction& inst, const std::function& diag, uint32_t underlying_type) { if (!_.IsIntScalarType(underlying_type)) { return diag(GetDefinitionDesc(decoration, inst) + " is not an int scalar."); } const uint32_t bit_width = _.GetBitWidth(underlying_type); if (bit_width != 32) { std::ostringstream ss; ss << GetDefinitionDesc(decoration, inst) << " has bit width " << bit_width << "."; return diag(ss.str()); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateOptionalArrayedF32( const Decoration& decoration, const Instruction& inst, const std::function& diag) { uint32_t underlying_type = 0; if (spv_result_t error = GetUnderlyingType(_, decoration, inst, &underlying_type)) { return error; } // Strip the array, if present. if (_.GetIdOpcode(underlying_type) == spv::Op::OpTypeArray) { underlying_type = _.FindDef(underlying_type)->word(2u); } return ValidateF32Helper(decoration, inst, diag, underlying_type); } spv_result_t BuiltInsValidator::ValidateF32( const Decoration& decoration, const Instruction& inst, const std::function& diag) { uint32_t underlying_type = 0; if (spv_result_t error = GetUnderlyingType(_, decoration, inst, &underlying_type)) { return error; } return ValidateF32Helper(decoration, inst, diag, underlying_type); } spv_result_t BuiltInsValidator::ValidateF32Helper( const Decoration& decoration, const Instruction& inst, const std::function& diag, uint32_t underlying_type) { if (!_.IsFloatScalarType(underlying_type)) { return diag(GetDefinitionDesc(decoration, inst) + " is not a float scalar."); } const uint32_t bit_width = _.GetBitWidth(underlying_type); if (bit_width != 32) { std::ostringstream ss; ss << GetDefinitionDesc(decoration, inst) << " has bit width " << bit_width << "."; return diag(ss.str()); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateI32Vec( const Decoration& decoration, const Instruction& inst, uint32_t num_components, const std::function& diag) { uint32_t underlying_type = 0; if (spv_result_t error = GetUnderlyingType(_, decoration, inst, &underlying_type)) { return error; } if (!_.IsIntVectorType(underlying_type)) { return diag(GetDefinitionDesc(decoration, inst) + " is not an int vector."); } const uint32_t actual_num_components = _.GetDimension(underlying_type); if (_.GetDimension(underlying_type) != num_components) { std::ostringstream ss; ss << GetDefinitionDesc(decoration, inst) << " has " << actual_num_components << " components."; return diag(ss.str()); } const uint32_t bit_width = _.GetBitWidth(underlying_type); if (bit_width != 32) { std::ostringstream ss; ss << GetDefinitionDesc(decoration, inst) << " has components with bit width " << bit_width << "."; return diag(ss.str()); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateArrayedI32Vec( const Decoration& decoration, const Instruction& inst, uint32_t num_components, const std::function& diag) { uint32_t underlying_type = 0; if (spv_result_t error = GetUnderlyingType(_, decoration, inst, &underlying_type)) { return error; } const Instruction* const type_inst = _.FindDef(underlying_type); if (type_inst->opcode() != spv::Op::OpTypeArray) { return diag(GetDefinitionDesc(decoration, inst) + " is not an array."); } const uint32_t component_type = type_inst->word(2); if (!_.IsIntVectorType(component_type)) { return diag(GetDefinitionDesc(decoration, inst) + " is not an int vector."); } const uint32_t actual_num_components = _.GetDimension(component_type); if (_.GetDimension(component_type) != num_components) { std::ostringstream ss; ss << GetDefinitionDesc(decoration, inst) << " has " << actual_num_components << " components."; return diag(ss.str()); } const uint32_t bit_width = _.GetBitWidth(component_type); if (bit_width != 32) { std::ostringstream ss; ss << GetDefinitionDesc(decoration, inst) << " has components with bit width " << bit_width << "."; return diag(ss.str()); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateOptionalArrayedF32Vec( const Decoration& decoration, const Instruction& inst, uint32_t num_components, const std::function& diag) { uint32_t underlying_type = 0; if (spv_result_t error = GetUnderlyingType(_, decoration, inst, &underlying_type)) { return error; } // Strip the array, if present. if (_.GetIdOpcode(underlying_type) == spv::Op::OpTypeArray) { underlying_type = _.FindDef(underlying_type)->word(2u); } return ValidateF32VecHelper(decoration, inst, num_components, diag, underlying_type); } spv_result_t BuiltInsValidator::ValidateF32Vec( const Decoration& decoration, const Instruction& inst, uint32_t num_components, const std::function& diag) { uint32_t underlying_type = 0; if (spv_result_t error = GetUnderlyingType(_, decoration, inst, &underlying_type)) { return error; } return ValidateF32VecHelper(decoration, inst, num_components, diag, underlying_type); } spv_result_t BuiltInsValidator::ValidateF32VecHelper( const Decoration& decoration, const Instruction& inst, uint32_t num_components, const std::function& diag, uint32_t underlying_type) { if (!_.IsFloatVectorType(underlying_type)) { return diag(GetDefinitionDesc(decoration, inst) + " is not a float vector."); } const uint32_t actual_num_components = _.GetDimension(underlying_type); if (_.GetDimension(underlying_type) != num_components) { std::ostringstream ss; ss << GetDefinitionDesc(decoration, inst) << " has " << actual_num_components << " components."; return diag(ss.str()); } const uint32_t bit_width = _.GetBitWidth(underlying_type); if (bit_width != 32) { std::ostringstream ss; ss << GetDefinitionDesc(decoration, inst) << " has components with bit width " << bit_width << "."; return diag(ss.str()); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateI32Arr( const Decoration& decoration, const Instruction& inst, const std::function& diag) { uint32_t underlying_type = 0; if (spv_result_t error = GetUnderlyingType(_, decoration, inst, &underlying_type)) { return error; } const Instruction* const type_inst = _.FindDef(underlying_type); if (type_inst->opcode() != spv::Op::OpTypeArray) { return diag(GetDefinitionDesc(decoration, inst) + " is not an array."); } const uint32_t component_type = type_inst->word(2); if (!_.IsIntScalarType(component_type)) { return diag(GetDefinitionDesc(decoration, inst) + " components are not int scalar."); } const uint32_t bit_width = _.GetBitWidth(component_type); if (bit_width != 32) { std::ostringstream ss; ss << GetDefinitionDesc(decoration, inst) << " has components with bit width " << bit_width << "."; return diag(ss.str()); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateF32Arr( const Decoration& decoration, const Instruction& inst, uint32_t num_components, const std::function& diag) { uint32_t underlying_type = 0; if (spv_result_t error = GetUnderlyingType(_, decoration, inst, &underlying_type)) { return error; } return ValidateF32ArrHelper(decoration, inst, num_components, diag, underlying_type); } spv_result_t BuiltInsValidator::ValidateOptionalArrayedF32Arr( const Decoration& decoration, const Instruction& inst, uint32_t num_components, const std::function& diag) { uint32_t underlying_type = 0; if (spv_result_t error = GetUnderlyingType(_, decoration, inst, &underlying_type)) { return error; } // Strip an extra layer of arraying if present. if (_.GetIdOpcode(underlying_type) == spv::Op::OpTypeArray) { uint32_t subtype = _.FindDef(underlying_type)->word(2u); if (_.GetIdOpcode(subtype) == spv::Op::OpTypeArray) { underlying_type = subtype; } } return ValidateF32ArrHelper(decoration, inst, num_components, diag, underlying_type); } spv_result_t BuiltInsValidator::ValidateF32ArrHelper( const Decoration& decoration, const Instruction& inst, uint32_t num_components, const std::function& diag, uint32_t underlying_type) { const Instruction* const type_inst = _.FindDef(underlying_type); if (type_inst->opcode() != spv::Op::OpTypeArray) { return diag(GetDefinitionDesc(decoration, inst) + " is not an array."); } const uint32_t component_type = type_inst->word(2); if (!_.IsFloatScalarType(component_type)) { return diag(GetDefinitionDesc(decoration, inst) + " components are not float scalar."); } const uint32_t bit_width = _.GetBitWidth(component_type); if (bit_width != 32) { std::ostringstream ss; ss << GetDefinitionDesc(decoration, inst) << " has components with bit width " << bit_width << "."; return diag(ss.str()); } if (num_components != 0) { uint64_t actual_num_components = 0; if (!_.EvalConstantValUint64(type_inst->word(3), &actual_num_components)) { assert(0 && "Array type definition is corrupt"); } if (actual_num_components != num_components) { std::ostringstream ss; ss << GetDefinitionDesc(decoration, inst) << " has " << actual_num_components << " components."; return diag(ss.str()); } } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateF32Mat( const Decoration& decoration, const Instruction& inst, uint32_t req_num_rows, uint32_t req_num_columns, const std::function& diag) { uint32_t underlying_type = 0; uint32_t num_rows = 0; uint32_t num_cols = 0; uint32_t col_type = 0; uint32_t component_type = 0; if (spv_result_t error = GetUnderlyingType(_, decoration, inst, &underlying_type)) { return error; } if (!_.GetMatrixTypeInfo(underlying_type, &num_rows, &num_cols, &col_type, &component_type) || num_rows != req_num_rows || num_cols != req_num_columns) { std::ostringstream ss; ss << GetDefinitionDesc(decoration, inst) << " has columns " << num_cols << " and rows " << num_rows << " not equal to expected " << req_num_columns << "x" << req_num_rows << "."; return diag(ss.str()); } return ValidateF32VecHelper(decoration, inst, req_num_rows, diag, col_type); } spv_result_t BuiltInsValidator::ValidateNotCalledWithExecutionModel( int vuid, const char* comment, spv::ExecutionModel execution_model, const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst) { if (function_id_) { if (execution_models_.count(execution_model)) { const char* execution_model_str = _.grammar().lookupOperandName( SPV_OPERAND_TYPE_EXECUTION_MODEL, uint32_t(execution_model)); const char* built_in_str = _.grammar().lookupOperandName( SPV_OPERAND_TYPE_BUILT_IN, (uint32_t)decoration.builtin()); return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << (vuid < 0 ? std::string("") : _.VkErrorID(vuid)) << comment << " " << GetIdDesc(referenced_inst) << " depends on " << GetIdDesc(built_in_inst) << " which is decorated with BuiltIn " << built_in_str << "." << " Id <" << referenced_inst.id() << "> is later referenced by " << GetIdDesc(referenced_from_inst) << " in function <" << function_id_ << "> which is called with execution model " << execution_model_str << "."; } } else { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back( std::bind(&BuiltInsValidator::ValidateNotCalledWithExecutionModel, this, vuid, comment, execution_model, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateClipOrCullDistanceAtDefinition( const Decoration& decoration, const Instruction& inst) { // Seed at reference checks with this built-in. return ValidateClipOrCullDistanceAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidateClipOrCullDistanceAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst) { uint32_t operand = (uint32_t)decoration.builtin(); if (spvIsVulkanEnv(_.context()->target_env)) { const spv::StorageClass storage_class = GetStorageClass(referenced_from_inst); if (storage_class != spv::StorageClass::Max && storage_class != spv::StorageClass::Input && storage_class != spv::StorageClass::Output) { uint32_t vuid = (decoration.builtin() == spv::BuiltIn::ClipDistance) ? 4190 : 4199; return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(vuid) << "Vulkan spec allows BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, operand) << " to be only used for variables with Input or Output storage " "class. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst) << " " << GetStorageClassDesc(referenced_from_inst); } if (storage_class == spv::StorageClass::Input) { assert(function_id_ == 0); uint32_t vuid = (decoration.builtin() == spv::BuiltIn::ClipDistance) ? 4188 : 4197; id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateNotCalledWithExecutionModel, this, vuid, "Vulkan spec doesn't allow BuiltIn ClipDistance/CullDistance to be " "used for variables with Input storage class if execution model is " "Vertex.", spv::ExecutionModel::Vertex, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateNotCalledWithExecutionModel, this, vuid, "Vulkan spec doesn't allow BuiltIn ClipDistance/CullDistance to be " "used for variables with Input storage class if execution model is " "MeshNV.", spv::ExecutionModel::MeshNV, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateNotCalledWithExecutionModel, this, vuid, "Vulkan spec doesn't allow BuiltIn ClipDistance/CullDistance to be " "used for variables with Input storage class if execution model is " "MeshEXT.", spv::ExecutionModel::MeshEXT, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } if (storage_class == spv::StorageClass::Output) { assert(function_id_ == 0); uint32_t vuid = (decoration.builtin() == spv::BuiltIn::ClipDistance) ? 4189 : 4198; id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateNotCalledWithExecutionModel, this, vuid, "Vulkan spec doesn't allow BuiltIn ClipDistance/CullDistance to be " "used for variables with Output storage class if execution model is " "Fragment.", spv::ExecutionModel::Fragment, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } for (const spv::ExecutionModel execution_model : execution_models_) { switch (execution_model) { case spv::ExecutionModel::Fragment: case spv::ExecutionModel::Vertex: { if (spv_result_t error = ValidateF32Arr( decoration, built_in_inst, /* Any number of components */ 0, [this, &decoration, &referenced_from_inst]( const std::string& message) -> spv_result_t { uint32_t vuid = (decoration.builtin() == spv::BuiltIn::ClipDistance) ? 4191 : 4200; return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(vuid) << "According to the Vulkan spec BuiltIn " << _.grammar().lookupOperandName( SPV_OPERAND_TYPE_BUILT_IN, (uint32_t)decoration.builtin()) << " variable needs to be a 32-bit float array. " << message; })) { return error; } break; } case spv::ExecutionModel::TessellationControl: case spv::ExecutionModel::TessellationEvaluation: case spv::ExecutionModel::Geometry: case spv::ExecutionModel::MeshNV: case spv::ExecutionModel::MeshEXT: { if (decoration.struct_member_index() != Decoration::kInvalidMember) { // The outer level of array is applied on the variable. if (spv_result_t error = ValidateF32Arr( decoration, built_in_inst, /* Any number of components */ 0, [this, &decoration, &referenced_from_inst]( const std::string& message) -> spv_result_t { uint32_t vuid = (decoration.builtin() == spv::BuiltIn::ClipDistance) ? 4191 : 4200; return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(vuid) << "According to the Vulkan spec BuiltIn " << _.grammar().lookupOperandName( SPV_OPERAND_TYPE_BUILT_IN, (uint32_t)decoration.builtin()) << " variable needs to be a 32-bit float array. " << message; })) { return error; } } else { if (spv_result_t error = ValidateOptionalArrayedF32Arr( decoration, built_in_inst, /* Any number of components */ 0, [this, &decoration, &referenced_from_inst]( const std::string& message) -> spv_result_t { uint32_t vuid = (decoration.builtin() == spv::BuiltIn::ClipDistance) ? 4191 : 4200; return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(vuid) << "According to the Vulkan spec BuiltIn " << _.grammar().lookupOperandName( SPV_OPERAND_TYPE_BUILT_IN, (uint32_t)decoration.builtin()) << " variable needs to be a 32-bit float array. " << message; })) { return error; } } break; } default: { uint32_t vuid = (decoration.builtin() == spv::BuiltIn::ClipDistance) ? 4187 : 4196; return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(vuid) << "Vulkan spec allows BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, operand) << " to be used only with Fragment, Vertex, " "TessellationControl, TessellationEvaluation or Geometry " "execution models. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst, execution_model); } } } } if (function_id_ == 0) { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back( std::bind(&BuiltInsValidator::ValidateClipOrCullDistanceAtReference, this, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateFragCoordAtDefinition( const Decoration& decoration, const Instruction& inst) { if (spvIsVulkanEnv(_.context()->target_env)) { if (spv_result_t error = ValidateF32Vec( decoration, inst, 4, [this, &inst](const std::string& message) -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(4212) << "According to the " << spvLogStringForEnv(_.context()->target_env) << " spec BuiltIn FragCoord " "variable needs to be a 4-component 32-bit float " "vector. " << message; })) { return error; } } // Seed at reference checks with this built-in. return ValidateFragCoordAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidateFragCoordAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::StorageClass storage_class = GetStorageClass(referenced_from_inst); if (storage_class != spv::StorageClass::Max && storage_class != spv::StorageClass::Input) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4211) << spvLogStringForEnv(_.context()->target_env) << " spec allows BuiltIn FragCoord to be only used for " "variables with Input storage class. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst) << " " << GetStorageClassDesc(referenced_from_inst); } for (const spv::ExecutionModel execution_model : execution_models_) { if (execution_model != spv::ExecutionModel::Fragment) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4210) << spvLogStringForEnv(_.context()->target_env) << " spec allows BuiltIn FragCoord to be used only with " "Fragment execution model. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst, execution_model); } } } if (function_id_ == 0) { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateFragCoordAtReference, this, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateFragDepthAtDefinition( const Decoration& decoration, const Instruction& inst) { if (spvIsVulkanEnv(_.context()->target_env)) { if (spv_result_t error = ValidateF32( decoration, inst, [this, &inst](const std::string& message) -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(4215) << "According to the " << spvLogStringForEnv(_.context()->target_env) << " spec BuiltIn FragDepth " "variable needs to be a 32-bit float scalar. " << message; })) { return error; } } // Seed at reference checks with this built-in. return ValidateFragDepthAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidateFragDepthAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::StorageClass storage_class = GetStorageClass(referenced_from_inst); if (storage_class != spv::StorageClass::Max && storage_class != spv::StorageClass::Output) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4214) << spvLogStringForEnv(_.context()->target_env) << " spec allows BuiltIn FragDepth to be only used for " "variables with Output storage class. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst) << " " << GetStorageClassDesc(referenced_from_inst); } for (const spv::ExecutionModel execution_model : execution_models_) { if (execution_model != spv::ExecutionModel::Fragment) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4213) << spvLogStringForEnv(_.context()->target_env) << " spec allows BuiltIn FragDepth to be used only with " "Fragment execution model. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst, execution_model); } } for (const uint32_t entry_point : *entry_points_) { // Every entry point from which this function is called needs to have // Execution Mode DepthReplacing. const auto* modes = _.GetExecutionModes(entry_point); if (!modes || !modes->count(spv::ExecutionMode::DepthReplacing)) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4216) << spvLogStringForEnv(_.context()->target_env) << " spec requires DepthReplacing execution mode to be " "declared when using BuiltIn FragDepth. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst); } } } if (function_id_ == 0) { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateFragDepthAtReference, this, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateFrontFacingAtDefinition( const Decoration& decoration, const Instruction& inst) { if (spvIsVulkanEnv(_.context()->target_env)) { if (spv_result_t error = ValidateBool( decoration, inst, [this, &inst](const std::string& message) -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(4231) << "According to the " << spvLogStringForEnv(_.context()->target_env) << " spec BuiltIn FrontFacing " "variable needs to be a bool scalar. " << message; })) { return error; } } // Seed at reference checks with this built-in. return ValidateFrontFacingAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidateFrontFacingAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::StorageClass storage_class = GetStorageClass(referenced_from_inst); if (storage_class != spv::StorageClass::Max && storage_class != spv::StorageClass::Input) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4230) << spvLogStringForEnv(_.context()->target_env) << " spec allows BuiltIn FrontFacing to be only used for " "variables with Input storage class. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst) << " " << GetStorageClassDesc(referenced_from_inst); } for (const spv::ExecutionModel execution_model : execution_models_) { if (execution_model != spv::ExecutionModel::Fragment) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4229) << spvLogStringForEnv(_.context()->target_env) << " spec allows BuiltIn FrontFacing to be used only with " "Fragment execution model. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst, execution_model); } } } if (function_id_ == 0) { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateFrontFacingAtReference, this, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateHelperInvocationAtDefinition( const Decoration& decoration, const Instruction& inst) { if (spvIsVulkanEnv(_.context()->target_env)) { if (spv_result_t error = ValidateBool( decoration, inst, [this, &inst](const std::string& message) -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(4241) << "According to the Vulkan spec BuiltIn HelperInvocation " "variable needs to be a bool scalar. " << message; })) { return error; } } // Seed at reference checks with this built-in. return ValidateHelperInvocationAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidateHelperInvocationAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::StorageClass storage_class = GetStorageClass(referenced_from_inst); if (storage_class != spv::StorageClass::Max && storage_class != spv::StorageClass::Input) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4240) << "Vulkan spec allows BuiltIn HelperInvocation to be only used " "for variables with Input storage class. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst) << " " << GetStorageClassDesc(referenced_from_inst); } for (const spv::ExecutionModel execution_model : execution_models_) { if (execution_model != spv::ExecutionModel::Fragment) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4239) << "Vulkan spec allows BuiltIn HelperInvocation to be used only " "with Fragment execution model. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst, execution_model); } } } if (function_id_ == 0) { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back( std::bind(&BuiltInsValidator::ValidateHelperInvocationAtReference, this, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateInvocationIdAtDefinition( const Decoration& decoration, const Instruction& inst) { if (spvIsVulkanEnv(_.context()->target_env)) { if (spv_result_t error = ValidateI32( decoration, inst, [this, &inst](const std::string& message) -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(4259) << "According to the Vulkan spec BuiltIn InvocationId " "variable needs to be a 32-bit int scalar. " << message; })) { return error; } } // Seed at reference checks with this built-in. return ValidateInvocationIdAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidateInvocationIdAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::StorageClass storage_class = GetStorageClass(referenced_from_inst); if (storage_class != spv::StorageClass::Max && storage_class != spv::StorageClass::Input) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4258) << "Vulkan spec allows BuiltIn InvocationId to be only used for " "variables with Input storage class. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst) << " " << GetStorageClassDesc(referenced_from_inst); } for (const spv::ExecutionModel execution_model : execution_models_) { if (execution_model != spv::ExecutionModel::TessellationControl && execution_model != spv::ExecutionModel::Geometry) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4257) << "Vulkan spec allows BuiltIn InvocationId to be used only " "with TessellationControl or Geometry execution models. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst, execution_model); } } } if (function_id_ == 0) { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateInvocationIdAtReference, this, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateInstanceIndexAtDefinition( const Decoration& decoration, const Instruction& inst) { if (spvIsVulkanEnv(_.context()->target_env)) { if (spv_result_t error = ValidateI32( decoration, inst, [this, &inst](const std::string& message) -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(4265) << "According to the " << spvLogStringForEnv(_.context()->target_env) << " spec BuiltIn InstanceIndex " "variable needs to be a 32-bit int scalar. " << message; })) { return error; } } // Seed at reference checks with this built-in. return ValidateInstanceIndexAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidateInstanceIndexAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::StorageClass storage_class = GetStorageClass(referenced_from_inst); if (storage_class != spv::StorageClass::Max && storage_class != spv::StorageClass::Input) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4264) << spvLogStringForEnv(_.context()->target_env) << " spec allows BuiltIn InstanceIndex to be only used for " "variables with Input storage class. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst) << " " << GetStorageClassDesc(referenced_from_inst); } for (const spv::ExecutionModel execution_model : execution_models_) { if (execution_model != spv::ExecutionModel::Vertex) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4263) << spvLogStringForEnv(_.context()->target_env) << " spec allows BuiltIn InstanceIndex to be used only " "with Vertex execution model. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst, execution_model); } } } if (function_id_ == 0) { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateInstanceIndexAtReference, this, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidatePatchVerticesAtDefinition( const Decoration& decoration, const Instruction& inst) { if (spvIsVulkanEnv(_.context()->target_env)) { if (spv_result_t error = ValidateI32( decoration, inst, [this, &inst](const std::string& message) -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(4310) << "According to the Vulkan spec BuiltIn PatchVertices " "variable needs to be a 32-bit int scalar. " << message; })) { return error; } } // Seed at reference checks with this built-in. return ValidatePatchVerticesAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidatePatchVerticesAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::StorageClass storage_class = GetStorageClass(referenced_from_inst); if (storage_class != spv::StorageClass::Max && storage_class != spv::StorageClass::Input) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4309) << "Vulkan spec allows BuiltIn PatchVertices to be only used for " "variables with Input storage class. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst) << " " << GetStorageClassDesc(referenced_from_inst); } for (const spv::ExecutionModel execution_model : execution_models_) { if (execution_model != spv::ExecutionModel::TessellationControl && execution_model != spv::ExecutionModel::TessellationEvaluation) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4308) << "Vulkan spec allows BuiltIn PatchVertices to be used only " "with TessellationControl or TessellationEvaluation " "execution models. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst, execution_model); } } } if (function_id_ == 0) { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidatePatchVerticesAtReference, this, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidatePointCoordAtDefinition( const Decoration& decoration, const Instruction& inst) { if (spvIsVulkanEnv(_.context()->target_env)) { if (spv_result_t error = ValidateF32Vec( decoration, inst, 2, [this, &inst](const std::string& message) -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(4313) << "According to the Vulkan spec BuiltIn PointCoord " "variable needs to be a 2-component 32-bit float " "vector. " << message; })) { return error; } } // Seed at reference checks with this built-in. return ValidatePointCoordAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidatePointCoordAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::StorageClass storage_class = GetStorageClass(referenced_from_inst); if (storage_class != spv::StorageClass::Max && storage_class != spv::StorageClass::Input) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4312) << "Vulkan spec allows BuiltIn PointCoord to be only used for " "variables with Input storage class. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst) << " " << GetStorageClassDesc(referenced_from_inst); } for (const spv::ExecutionModel execution_model : execution_models_) { if (execution_model != spv::ExecutionModel::Fragment) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4311) << "Vulkan spec allows BuiltIn PointCoord to be used only with " "Fragment execution model. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst, execution_model); } } } if (function_id_ == 0) { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidatePointCoordAtReference, this, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidatePointSizeAtDefinition( const Decoration& decoration, const Instruction& inst) { // Seed at reference checks with this built-in. return ValidatePointSizeAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidatePointSizeAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::StorageClass storage_class = GetStorageClass(referenced_from_inst); if (storage_class != spv::StorageClass::Max && storage_class != spv::StorageClass::Input && storage_class != spv::StorageClass::Output) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4316) << "Vulkan spec allows BuiltIn PointSize to be only used for " "variables with Input or Output storage class. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst) << " " << GetStorageClassDesc(referenced_from_inst); } if (storage_class == spv::StorageClass::Input) { assert(function_id_ == 0); id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateNotCalledWithExecutionModel, this, 4315, "Vulkan spec doesn't allow BuiltIn PointSize to be used for " "variables with Input storage class if execution model is " "Vertex.", spv::ExecutionModel::Vertex, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } for (const spv::ExecutionModel execution_model : execution_models_) { switch (execution_model) { case spv::ExecutionModel::Vertex: { if (spv_result_t error = ValidateF32( decoration, built_in_inst, [this, &referenced_from_inst]( const std::string& message) -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4317) << "According to the Vulkan spec BuiltIn PointSize " "variable needs to be a 32-bit float scalar. " << message; })) { return error; } break; } case spv::ExecutionModel::TessellationControl: case spv::ExecutionModel::TessellationEvaluation: case spv::ExecutionModel::Geometry: case spv::ExecutionModel::MeshNV: case spv::ExecutionModel::MeshEXT: { // PointSize can be a per-vertex variable for tessellation control, // tessellation evaluation and geometry shader stages. In such cases // variables will have an array of 32-bit floats. if (decoration.struct_member_index() != Decoration::kInvalidMember) { // The array is on the variable, so this must be a 32-bit float. if (spv_result_t error = ValidateF32( decoration, built_in_inst, [this, &referenced_from_inst]( const std::string& message) -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4317) << "According to the Vulkan spec BuiltIn " "PointSize variable needs to be a 32-bit " "float scalar. " << message; })) { return error; } } else { if (spv_result_t error = ValidateOptionalArrayedF32( decoration, built_in_inst, [this, &referenced_from_inst]( const std::string& message) -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4317) << "According to the Vulkan spec BuiltIn " "PointSize variable needs to be a 32-bit " "float scalar. " << message; })) { return error; } } break; } default: { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4314) << "Vulkan spec allows BuiltIn PointSize to be used only with " "Vertex, TessellationControl, TessellationEvaluation or " "Geometry execution models. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst, execution_model); } } } } if (function_id_ == 0) { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidatePointSizeAtReference, this, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidatePositionAtDefinition( const Decoration& decoration, const Instruction& inst) { // Seed at reference checks with this built-in. return ValidatePositionAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidatePositionAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::StorageClass storage_class = GetStorageClass(referenced_from_inst); if (storage_class != spv::StorageClass::Max && storage_class != spv::StorageClass::Input && storage_class != spv::StorageClass::Output) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4320) << "Vulkan spec allows BuiltIn Position to be only used for " "variables with Input or Output storage class. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst) << " " << GetStorageClassDesc(referenced_from_inst); } if (storage_class == spv::StorageClass::Input) { assert(function_id_ == 0); id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateNotCalledWithExecutionModel, this, 4319, "Vulkan spec doesn't allow BuiltIn Position to be used " "for variables " "with Input storage class if execution model is Vertex.", spv::ExecutionModel::Vertex, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateNotCalledWithExecutionModel, this, 4319, "Vulkan spec doesn't allow BuiltIn Position to be used " "for variables " "with Input storage class if execution model is MeshNV.", spv::ExecutionModel::MeshNV, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateNotCalledWithExecutionModel, this, 4319, "Vulkan spec doesn't allow BuiltIn Position to be used " "for variables " "with Input storage class if execution model is MeshEXT.", spv::ExecutionModel::MeshEXT, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } for (const spv::ExecutionModel execution_model : execution_models_) { switch (execution_model) { case spv::ExecutionModel::Vertex: { if (spv_result_t error = ValidateF32Vec( decoration, built_in_inst, 4, [this, &referenced_from_inst]( const std::string& message) -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4321) << "According to the Vulkan spec BuiltIn Position " "variable needs to be a 4-component 32-bit float " "vector. " << message; })) { return error; } break; } case spv::ExecutionModel::Geometry: case spv::ExecutionModel::TessellationControl: case spv::ExecutionModel::TessellationEvaluation: case spv::ExecutionModel::MeshNV: case spv::ExecutionModel::MeshEXT: { // Position can be a per-vertex variable for tessellation control, // tessellation evaluation, geometry and mesh shader stages. In such // cases variables will have an array of 4-component 32-bit float // vectors. if (decoration.struct_member_index() != Decoration::kInvalidMember) { // The array is on the variable, so this must be a 4-component // 32-bit float vector. if (spv_result_t error = ValidateF32Vec( decoration, built_in_inst, 4, [this, &referenced_from_inst]( const std::string& message) -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4321) << "According to the Vulkan spec BuiltIn Position " "variable needs to be a 4-component 32-bit " "float vector. " << message; })) { return error; } } else { if (spv_result_t error = ValidateOptionalArrayedF32Vec( decoration, built_in_inst, 4, [this, &referenced_from_inst]( const std::string& message) -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4321) << "According to the Vulkan spec BuiltIn Position " "variable needs to be a 4-component 32-bit " "float vector. " << message; })) { return error; } } break; } default: { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4318) << "Vulkan spec allows BuiltIn Position to be used only " "with Vertex, TessellationControl, TessellationEvaluation" " or Geometry execution models. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst, execution_model); } } } } if (function_id_ == 0) { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidatePositionAtReference, this, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidatePrimitiveIdAtDefinition( const Decoration& decoration, const Instruction& inst) { if (spvIsVulkanEnv(_.context()->target_env)) { // PrimitiveId can be a per-primitive variable for mesh shader stage. // In such cases variable will have an array of 32-bit integers. if (decoration.struct_member_index() != Decoration::kInvalidMember) { // This must be a 32-bit int scalar. if (spv_result_t error = ValidateI32( decoration, inst, [this, &inst](const std::string& message) -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(4337) << "According to the Vulkan spec BuiltIn PrimitiveId " "variable needs to be a 32-bit int scalar. " << message; })) { return error; } } else { if (spv_result_t error = ValidateOptionalArrayedI32( decoration, inst, [this, &inst](const std::string& message) -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(4337) << "According to the Vulkan spec BuiltIn PrimitiveId " "variable needs to be a 32-bit int scalar. " << message; })) { return error; } } if (_.HasCapability(spv::Capability::MeshShadingEXT)) { if (isMeshInterfaceVar(inst) && !_.HasDecoration(inst.id(), spv::Decoration::PerPrimitiveEXT)) { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(7040) << "According to the Vulkan spec the variable decorated with " "Builtin PrimitiveId within the MeshEXT Execution Model must " "also be decorated with the PerPrimitiveEXT decoration. "; } } } // Seed at reference checks with this built-in. return ValidatePrimitiveIdAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidatePrimitiveIdAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::StorageClass storage_class = GetStorageClass(referenced_from_inst); if (storage_class != spv::StorageClass::Max && storage_class != spv::StorageClass::Input && storage_class != spv::StorageClass::Output) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << "Vulkan spec allows BuiltIn PrimitiveId to be only used for " "variables with Input or Output storage class. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst) << " " << GetStorageClassDesc(referenced_from_inst); } if (storage_class == spv::StorageClass::Output) { assert(function_id_ == 0); id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateNotCalledWithExecutionModel, this, 4334, "Vulkan spec doesn't allow BuiltIn PrimitiveId to be used for " "variables with Output storage class if execution model is " "TessellationControl.", spv::ExecutionModel::TessellationControl, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateNotCalledWithExecutionModel, this, 4334, "Vulkan spec doesn't allow BuiltIn PrimitiveId to be used for " "variables with Output storage class if execution model is " "TessellationEvaluation.", spv::ExecutionModel::TessellationEvaluation, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateNotCalledWithExecutionModel, this, 4334, "Vulkan spec doesn't allow BuiltIn PrimitiveId to be used for " "variables with Output storage class if execution model is " "Fragment.", spv::ExecutionModel::Fragment, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateNotCalledWithExecutionModel, this, 4334, "Vulkan spec doesn't allow BuiltIn PrimitiveId to be used for " "variables with Output storage class if execution model is " "IntersectionKHR.", spv::ExecutionModel::IntersectionKHR, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateNotCalledWithExecutionModel, this, 4334, "Vulkan spec doesn't allow BuiltIn PrimitiveId to be used for " "variables with Output storage class if execution model is " "AnyHitKHR.", spv::ExecutionModel::AnyHitKHR, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateNotCalledWithExecutionModel, this, 4334, "Vulkan spec doesn't allow BuiltIn PrimitiveId to be used for " "variables with Output storage class if execution model is " "ClosestHitKHR.", spv::ExecutionModel::ClosestHitKHR, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } for (const spv::ExecutionModel execution_model : execution_models_) { switch (execution_model) { case spv::ExecutionModel::Fragment: case spv::ExecutionModel::TessellationControl: case spv::ExecutionModel::TessellationEvaluation: case spv::ExecutionModel::Geometry: case spv::ExecutionModel::MeshNV: case spv::ExecutionModel::MeshEXT: case spv::ExecutionModel::IntersectionKHR: case spv::ExecutionModel::AnyHitKHR: case spv::ExecutionModel::ClosestHitKHR: { // Ok. break; } default: { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4330) << "Vulkan spec allows BuiltIn PrimitiveId to be used only " "with Fragment, TessellationControl, " "TessellationEvaluation, Geometry, MeshNV, MeshEXT, " "IntersectionKHR, AnyHitKHR, and ClosestHitKHR execution models. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst, execution_model); } } } } if (function_id_ == 0) { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidatePrimitiveIdAtReference, this, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateSampleIdAtDefinition( const Decoration& decoration, const Instruction& inst) { if (spvIsVulkanEnv(_.context()->target_env)) { if (spv_result_t error = ValidateI32( decoration, inst, [this, &inst](const std::string& message) -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(4356) << "According to the Vulkan spec BuiltIn SampleId " "variable needs to be a 32-bit int scalar. " << message; })) { return error; } } // Seed at reference checks with this built-in. return ValidateSampleIdAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidateSampleIdAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::StorageClass storage_class = GetStorageClass(referenced_from_inst); if (storage_class != spv::StorageClass::Max && storage_class != spv::StorageClass::Input) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4355) << "Vulkan spec allows BuiltIn SampleId to be only used for " "variables with Input storage class. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst) << " " << GetStorageClassDesc(referenced_from_inst); } for (const spv::ExecutionModel execution_model : execution_models_) { if (execution_model != spv::ExecutionModel::Fragment) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4354) << "Vulkan spec allows BuiltIn SampleId to be used only with " "Fragment execution model. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst, execution_model); } } } if (function_id_ == 0) { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateSampleIdAtReference, this, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateSampleMaskAtDefinition( const Decoration& decoration, const Instruction& inst) { if (spvIsVulkanEnv(_.context()->target_env)) { if (spv_result_t error = ValidateI32Arr( decoration, inst, [this, &inst](const std::string& message) -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(4359) << "According to the Vulkan spec BuiltIn SampleMask " "variable needs to be a 32-bit int array. " << message; })) { return error; } } // Seed at reference checks with this built-in. return ValidateSampleMaskAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidateSampleMaskAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::StorageClass storage_class = GetStorageClass(referenced_from_inst); if (storage_class != spv::StorageClass::Max && storage_class != spv::StorageClass::Input && storage_class != spv::StorageClass::Output) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4358) << "Vulkan spec allows BuiltIn SampleMask to be only used for " "variables with Input or Output storage class. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst) << " " << GetStorageClassDesc(referenced_from_inst); } for (const spv::ExecutionModel execution_model : execution_models_) { if (execution_model != spv::ExecutionModel::Fragment) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4357) << "Vulkan spec allows BuiltIn SampleMask to be used only " "with " "Fragment execution model. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst, execution_model); } } } if (function_id_ == 0) { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateSampleMaskAtReference, this, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateSamplePositionAtDefinition( const Decoration& decoration, const Instruction& inst) { if (spvIsVulkanEnv(_.context()->target_env)) { if (spv_result_t error = ValidateF32Vec( decoration, inst, 2, [this, &inst](const std::string& message) -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(4362) << "According to the Vulkan spec BuiltIn SamplePosition " "variable needs to be a 2-component 32-bit float " "vector. " << message; })) { return error; } } // Seed at reference checks with this built-in. return ValidateSamplePositionAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidateSamplePositionAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::StorageClass storage_class = GetStorageClass(referenced_from_inst); if (storage_class != spv::StorageClass::Max && storage_class != spv::StorageClass::Input) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4361) << "Vulkan spec allows BuiltIn SamplePosition to be only used " "for " "variables with Input storage class. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst) << " " << GetStorageClassDesc(referenced_from_inst); } for (const spv::ExecutionModel execution_model : execution_models_) { if (execution_model != spv::ExecutionModel::Fragment) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4360) << "Vulkan spec allows BuiltIn SamplePosition to be used only " "with " "Fragment execution model. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst, execution_model); } } } if (function_id_ == 0) { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateSamplePositionAtReference, this, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateTessCoordAtDefinition( const Decoration& decoration, const Instruction& inst) { if (spvIsVulkanEnv(_.context()->target_env)) { if (spv_result_t error = ValidateF32Vec( decoration, inst, 3, [this, &inst](const std::string& message) -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(4389) << "According to the Vulkan spec BuiltIn TessCoord " "variable needs to be a 3-component 32-bit float " "vector. " << message; })) { return error; } } // Seed at reference checks with this built-in. return ValidateTessCoordAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidateTessCoordAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::StorageClass storage_class = GetStorageClass(referenced_from_inst); if (storage_class != spv::StorageClass::Max && storage_class != spv::StorageClass::Input) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4388) << "Vulkan spec allows BuiltIn TessCoord to be only used for " "variables with Input storage class. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst) << " " << GetStorageClassDesc(referenced_from_inst); } for (const spv::ExecutionModel execution_model : execution_models_) { if (execution_model != spv::ExecutionModel::TessellationEvaluation) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4387) << "Vulkan spec allows BuiltIn TessCoord to be used only with " "TessellationEvaluation execution model. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst, execution_model); } } } if (function_id_ == 0) { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateTessCoordAtReference, this, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateTessLevelOuterAtDefinition( const Decoration& decoration, const Instruction& inst) { if (spvIsVulkanEnv(_.context()->target_env)) { if (spv_result_t error = ValidateF32Arr( decoration, inst, 4, [this, &inst](const std::string& message) -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(4393) << "According to the Vulkan spec BuiltIn TessLevelOuter " "variable needs to be a 4-component 32-bit float " "array. " << message; })) { return error; } } // Seed at reference checks with this built-in. return ValidateTessLevelAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidateTessLevelInnerAtDefinition( const Decoration& decoration, const Instruction& inst) { if (spvIsVulkanEnv(_.context()->target_env)) { if (spv_result_t error = ValidateF32Arr( decoration, inst, 2, [this, &inst](const std::string& message) -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(4397) << "According to the Vulkan spec BuiltIn TessLevelOuter " "variable needs to be a 2-component 32-bit float " "array. " << message; })) { return error; } } // Seed at reference checks with this built-in. return ValidateTessLevelAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidateTessLevelAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst) { uint32_t operand = (uint32_t)decoration.builtin(); if (spvIsVulkanEnv(_.context()->target_env)) { const spv::StorageClass storage_class = GetStorageClass(referenced_from_inst); if (storage_class != spv::StorageClass::Max && storage_class != spv::StorageClass::Input && storage_class != spv::StorageClass::Output) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << "Vulkan spec allows BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, operand) << " to be only used for variables with Input or Output storage " "class. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst) << " " << GetStorageClassDesc(referenced_from_inst); } if (storage_class == spv::StorageClass::Input) { assert(function_id_ == 0); uint32_t vuid = (decoration.builtin() == spv::BuiltIn::TessLevelOuter) ? 4391 : 4395; id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateNotCalledWithExecutionModel, this, vuid, "Vulkan spec doesn't allow TessLevelOuter/TessLevelInner to be " "used " "for variables with Input storage class if execution model is " "TessellationControl.", spv::ExecutionModel::TessellationControl, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } if (storage_class == spv::StorageClass::Output) { assert(function_id_ == 0); uint32_t vuid = (decoration.builtin() == spv::BuiltIn::TessLevelOuter) ? 4392 : 4396; id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateNotCalledWithExecutionModel, this, vuid, "Vulkan spec doesn't allow TessLevelOuter/TessLevelInner to be " "used " "for variables with Output storage class if execution model is " "TessellationEvaluation.", spv::ExecutionModel::TessellationEvaluation, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } for (const spv::ExecutionModel execution_model : execution_models_) { switch (execution_model) { case spv::ExecutionModel::TessellationControl: case spv::ExecutionModel::TessellationEvaluation: { // Ok. break; } default: { uint32_t vuid = (spv::BuiltIn(operand) == spv::BuiltIn::TessLevelOuter) ? 4390 : 4394; return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(vuid) << "Vulkan spec allows BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, operand) << " to be used only with TessellationControl or " "TessellationEvaluation execution models. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst, execution_model); } } } } if (function_id_ == 0) { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateTessLevelAtReference, this, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateVertexIndexAtDefinition( const Decoration& decoration, const Instruction& inst) { if (spvIsVulkanEnv(_.context()->target_env)) { if (spv_result_t error = ValidateI32( decoration, inst, [this, &inst](const std::string& message) -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(4400) << "According to the " << spvLogStringForEnv(_.context()->target_env) << " spec BuiltIn VertexIndex variable needs to be a " "32-bit int scalar. " << message; })) { return error; } } // Seed at reference checks with this built-in. return ValidateVertexIndexAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidateVertexIdAtDefinition( const Decoration& decoration, const Instruction& inst) { (void)decoration; if (spvIsVulkanEnv(_.context()->target_env)) { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << "Vulkan spec doesn't allow BuiltIn VertexId " "to be used."; } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateLocalInvocationIndexAtDefinition( const Decoration& decoration, const Instruction& inst) { // Seed at reference checks with this built-in. return ValidateLocalInvocationIndexAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidateLocalInvocationIndexAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction&, const Instruction& referenced_from_inst) { if (function_id_ == 0) { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back( std::bind(&BuiltInsValidator::ValidateLocalInvocationIndexAtReference, this, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateVertexIndexAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::StorageClass storage_class = GetStorageClass(referenced_from_inst); if (storage_class != spv::StorageClass::Max && storage_class != spv::StorageClass::Input) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4399) << spvLogStringForEnv(_.context()->target_env) << " spec allows BuiltIn VertexIndex to be only used for " "variables with Input storage class. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst) << " " << GetStorageClassDesc(referenced_from_inst); } for (const spv::ExecutionModel execution_model : execution_models_) { if (execution_model != spv::ExecutionModel::Vertex) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4398) << spvLogStringForEnv(_.context()->target_env) << " spec allows BuiltIn VertexIndex to be used only with " "Vertex execution model. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst, execution_model); } } } if (function_id_ == 0) { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateVertexIndexAtReference, this, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateLayerOrViewportIndexAtDefinition( const Decoration& decoration, const Instruction& inst) { if (spvIsVulkanEnv(_.context()->target_env)) { // This can be a per-primitive variable for mesh shader stage. // In such cases variable will have an array of 32-bit integers. if (decoration.struct_member_index() != Decoration::kInvalidMember) { // This must be a 32-bit int scalar. if (spv_result_t error = ValidateI32( decoration, inst, [this, &decoration, &inst](const std::string& message) -> spv_result_t { uint32_t vuid = (decoration.builtin() == spv::BuiltIn::Layer) ? 4276 : 4408; return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(vuid) << "According to the Vulkan spec BuiltIn " << _.grammar().lookupOperandName( SPV_OPERAND_TYPE_BUILT_IN, (uint32_t)decoration.builtin()) << "variable needs to be a 32-bit int scalar. " << message; })) { return error; } } else { if (spv_result_t error = ValidateOptionalArrayedI32( decoration, inst, [this, &decoration, &inst](const std::string& message) -> spv_result_t { uint32_t vuid = (decoration.builtin() == spv::BuiltIn::Layer) ? 4276 : 4408; return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(vuid) << "According to the Vulkan spec BuiltIn " << _.grammar().lookupOperandName( SPV_OPERAND_TYPE_BUILT_IN, (uint32_t)decoration.builtin()) << "variable needs to be a 32-bit int scalar. " << message; })) { return error; } } if (isMeshInterfaceVar(inst) && _.HasCapability(spv::Capability::MeshShadingEXT) && !_.HasDecoration(inst.id(), spv::Decoration::PerPrimitiveEXT)) { const spv::BuiltIn label = spv::BuiltIn(decoration.params()[0]); uint32_t vkerrid = (label == spv::BuiltIn::Layer) ? 7039 : 7060; return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(vkerrid) << "According to the Vulkan spec the variable decorated with " "Builtin " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, decoration.params()[0]) << " within the MeshEXT Execution Model must also be decorated " "with the PerPrimitiveEXT decoration. "; } } // Seed at reference checks with this built-in. return ValidateLayerOrViewportIndexAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidateLayerOrViewportIndexAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst) { uint32_t operand = (uint32_t)decoration.builtin(); if (spvIsVulkanEnv(_.context()->target_env)) { const spv::StorageClass storage_class = GetStorageClass(referenced_from_inst); if (storage_class != spv::StorageClass::Max && storage_class != spv::StorageClass::Input && storage_class != spv::StorageClass::Output) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << "Vulkan spec allows BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, operand) << " to be only used for variables with Input or Output storage " "class. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst) << " " << GetStorageClassDesc(referenced_from_inst); } if (storage_class == spv::StorageClass::Input) { assert(function_id_ == 0); for (const auto em : {spv::ExecutionModel::Vertex, spv::ExecutionModel::TessellationEvaluation, spv::ExecutionModel::Geometry, spv::ExecutionModel::MeshNV, spv::ExecutionModel::MeshEXT}) { id_to_at_reference_checks_[referenced_from_inst.id()].push_back( std::bind(&BuiltInsValidator::ValidateNotCalledWithExecutionModel, this, ((spv::BuiltIn(operand) == spv::BuiltIn::Layer) ? 4274 : 4406), "Vulkan spec doesn't allow BuiltIn Layer and " "ViewportIndex to be " "used for variables with Input storage class if " "execution model is Vertex, TessellationEvaluation, " "Geometry, MeshNV or MeshEXT.", em, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } } if (storage_class == spv::StorageClass::Output) { assert(function_id_ == 0); id_to_at_reference_checks_[referenced_from_inst.id()].push_back( std::bind(&BuiltInsValidator::ValidateNotCalledWithExecutionModel, this, ((spv::BuiltIn(operand) == spv::BuiltIn::Layer) ? 4275 : 4407), "Vulkan spec doesn't allow BuiltIn Layer and " "ViewportIndex to be " "used for variables with Output storage class if " "execution model is " "Fragment.", spv::ExecutionModel::Fragment, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } for (const spv::ExecutionModel execution_model : execution_models_) { switch (execution_model) { case spv::ExecutionModel::Geometry: case spv::ExecutionModel::Fragment: case spv::ExecutionModel::MeshNV: case spv::ExecutionModel::MeshEXT: // Ok. break; case spv::ExecutionModel::Vertex: case spv::ExecutionModel::TessellationEvaluation: { if (!_.HasCapability(spv::Capability::ShaderViewportIndexLayerEXT)) { if (spv::BuiltIn(operand) == spv::BuiltIn::ViewportIndex && _.HasCapability(spv::Capability::ShaderViewportIndex)) break; // Ok if (spv::BuiltIn(operand) == spv::BuiltIn::Layer && _.HasCapability(spv::Capability::ShaderLayer)) break; // Ok const char* capability = "ShaderViewportIndexLayerEXT"; if (spv::BuiltIn(operand) == spv::BuiltIn::ViewportIndex) capability = "ShaderViewportIndexLayerEXT or ShaderViewportIndex"; if (spv::BuiltIn(operand) == spv::BuiltIn::Layer) capability = "ShaderViewportIndexLayerEXT or ShaderLayer"; uint32_t vuid = (spv::BuiltIn(operand) == spv::BuiltIn::Layer) ? 4273 : 4405; return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(vuid) << "Using BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, operand) << " in Vertex or Tessellation execution model requires the " << capability << " capability."; } break; } default: { uint32_t vuid = (spv::BuiltIn(operand) == spv::BuiltIn::Layer) ? 4272 : 4404; return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(vuid) << "Vulkan spec allows BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, operand) << " to be used only with Vertex, TessellationEvaluation, " "Geometry, or Fragment execution models. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst, execution_model); } } } } if (function_id_ == 0) { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back( std::bind(&BuiltInsValidator::ValidateLayerOrViewportIndexAtReference, this, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateFragmentShaderF32Vec3InputAtDefinition( const Decoration& decoration, const Instruction& inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::BuiltIn builtin = decoration.builtin(); if (spv_result_t error = ValidateF32Vec( decoration, inst, 3, [this, &inst, builtin](const std::string& message) -> spv_result_t { uint32_t vuid = GetVUIDForBuiltin(builtin, VUIDErrorType); return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(vuid) << "According to the " << spvLogStringForEnv(_.context()->target_env) << " spec BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, uint32_t(builtin)) << " variable needs to be a 3-component 32-bit float " "vector. " << message; })) { return error; } } // Seed at reference checks with this built-in. return ValidateFragmentShaderF32Vec3InputAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidateFragmentShaderF32Vec3InputAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::BuiltIn builtin = decoration.builtin(); const spv::StorageClass storage_class = GetStorageClass(referenced_from_inst); if (storage_class != spv::StorageClass::Max && storage_class != spv::StorageClass::Input) { uint32_t vuid = GetVUIDForBuiltin(builtin, VUIDErrorStorageClass); return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(vuid) << spvLogStringForEnv(_.context()->target_env) << " spec allows BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, uint32_t(builtin)) << " to be only used for variables with Input storage class. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst) << " " << GetStorageClassDesc(referenced_from_inst); } for (const spv::ExecutionModel execution_model : execution_models_) { if (execution_model != spv::ExecutionModel::Fragment) { uint32_t vuid = GetVUIDForBuiltin(builtin, VUIDErrorExecutionModel); return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(vuid) << spvLogStringForEnv(_.context()->target_env) << " spec allows BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, uint32_t(builtin)) << " to be used only with Fragment execution model. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst, execution_model); } } } if (function_id_ == 0) { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateFragmentShaderF32Vec3InputAtReference, this, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateComputeShaderI32Vec3InputAtDefinition( const Decoration& decoration, const Instruction& inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::BuiltIn builtin = decoration.builtin(); if (spv_result_t error = ValidateI32Vec( decoration, inst, 3, [this, &inst, builtin](const std::string& message) -> spv_result_t { uint32_t vuid = GetVUIDForBuiltin(builtin, VUIDErrorType); return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(vuid) << "According to the " << spvLogStringForEnv(_.context()->target_env) << " spec BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, uint32_t(builtin)) << " variable needs to be a 3-component 32-bit int " "vector. " << message; })) { return error; } } // Seed at reference checks with this built-in. return ValidateComputeShaderI32Vec3InputAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidateComputeShaderI32Vec3InputAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::BuiltIn builtin = decoration.builtin(); const spv::StorageClass storage_class = GetStorageClass(referenced_from_inst); if (storage_class != spv::StorageClass::Max && storage_class != spv::StorageClass::Input) { uint32_t vuid = GetVUIDForBuiltin(builtin, VUIDErrorStorageClass); return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(vuid) << spvLogStringForEnv(_.context()->target_env) << " spec allows BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, uint32_t(builtin)) << " to be only used for variables with Input storage class. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst) << " " << GetStorageClassDesc(referenced_from_inst); } for (const spv::ExecutionModel execution_model : execution_models_) { bool has_vulkan_model = execution_model == spv::ExecutionModel::GLCompute || execution_model == spv::ExecutionModel::TaskNV || execution_model == spv::ExecutionModel::MeshNV || execution_model == spv::ExecutionModel::TaskEXT || execution_model == spv::ExecutionModel::MeshEXT; if (spvIsVulkanEnv(_.context()->target_env) && !has_vulkan_model) { uint32_t vuid = GetVUIDForBuiltin(builtin, VUIDErrorExecutionModel); return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(vuid) << spvLogStringForEnv(_.context()->target_env) << " spec allows BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, uint32_t(builtin)) << " to be used only with GLCompute, MeshNV, TaskNV, MeshEXT or" << " TaskEXT execution model. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst, execution_model); } } } if (function_id_ == 0) { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateComputeShaderI32Vec3InputAtReference, this, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateComputeI32InputAtDefinition( const Decoration& decoration, const Instruction& inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::BuiltIn builtin = decoration.builtin(); if (decoration.struct_member_index() != Decoration::kInvalidMember) { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << "BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, uint32_t(builtin)) << " cannot be used as a member decoration "; } if (spv_result_t error = ValidateI32( decoration, inst, [this, &inst, builtin](const std::string& message) -> spv_result_t { uint32_t vuid = GetVUIDForBuiltin(builtin, VUIDErrorType); return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(vuid) << "According to the " << spvLogStringForEnv(_.context()->target_env) << " spec BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, uint32_t(builtin)) << " variable needs to be a 32-bit int " "vector. " << message; })) { return error; } } // Seed at reference checks with this built-in. return ValidateComputeI32InputAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidateComputeI32InputAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::BuiltIn builtin = decoration.builtin(); const spv::StorageClass storage_class = GetStorageClass(referenced_from_inst); if (storage_class != spv::StorageClass::Max && storage_class != spv::StorageClass::Input) { uint32_t vuid = GetVUIDForBuiltin(builtin, VUIDErrorStorageClass); return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(vuid) << spvLogStringForEnv(_.context()->target_env) << " spec allows BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, uint32_t(builtin)) << " to be only used for variables with Input storage class. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst) << " " << GetStorageClassDesc(referenced_from_inst); } for (const spv::ExecutionModel execution_model : execution_models_) { bool has_vulkan_model = execution_model == spv::ExecutionModel::GLCompute || execution_model == spv::ExecutionModel::TaskNV || execution_model == spv::ExecutionModel::MeshNV || execution_model == spv::ExecutionModel::TaskEXT || execution_model == spv::ExecutionModel::MeshEXT; if (spvIsVulkanEnv(_.context()->target_env) && !has_vulkan_model) { uint32_t vuid = GetVUIDForBuiltin(builtin, VUIDErrorExecutionModel); return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(vuid) << spvLogStringForEnv(_.context()->target_env) << " spec allows BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, uint32_t(builtin)) << " to be used only with GLCompute, MeshNV, TaskNV, MeshEXT or " << "TaskEXT execution model. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst, execution_model); } } } if (function_id_ == 0) { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back( std::bind(&BuiltInsValidator::ValidateComputeI32InputAtReference, this, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateI32InputAtDefinition( const Decoration& decoration, const Instruction& inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::BuiltIn builtin = decoration.builtin(); if (decoration.struct_member_index() != Decoration::kInvalidMember) { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << "BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, uint32_t(builtin)) << " cannot be used as a member decoration "; } if (spv_result_t error = ValidateI32( decoration, inst, [this, &inst, builtin](const std::string& message) -> spv_result_t { uint32_t vuid = GetVUIDForBuiltin(builtin, VUIDErrorType); return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(vuid) << "According to the " << spvLogStringForEnv(_.context()->target_env) << " spec BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, uint32_t(builtin)) << " variable needs to be a 32-bit int. " << message; })) { return error; } const spv::StorageClass storage_class = GetStorageClass(inst); if (storage_class != spv::StorageClass::Max && storage_class != spv::StorageClass::Input) { uint32_t vuid = GetVUIDForBuiltin(builtin, VUIDErrorStorageClass); return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(vuid) << spvLogStringForEnv(_.context()->target_env) << " spec allows BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, uint32_t(builtin)) << " to be only used for variables with Input storage class. " << GetReferenceDesc(decoration, inst, inst, inst) << " " << GetStorageClassDesc(inst); } } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateI32Vec4InputAtDefinition( const Decoration& decoration, const Instruction& inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::BuiltIn builtin = decoration.builtin(); if (decoration.struct_member_index() != Decoration::kInvalidMember) { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << "BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, uint32_t(builtin)) << " cannot be used as a member decoration "; } if (spv_result_t error = ValidateI32Vec( decoration, inst, 4, [this, &inst, builtin](const std::string& message) -> spv_result_t { uint32_t vuid = GetVUIDForBuiltin(builtin, VUIDErrorType); return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(vuid) << "According to the " << spvLogStringForEnv(_.context()->target_env) << " spec BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, uint32_t(builtin)) << " variable needs to be a 4-component 32-bit int " "vector. " << message; })) { return error; } const spv::StorageClass storage_class = GetStorageClass(inst); if (storage_class != spv::StorageClass::Max && storage_class != spv::StorageClass::Input) { uint32_t vuid = GetVUIDForBuiltin(builtin, VUIDErrorStorageClass); return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(vuid) << spvLogStringForEnv(_.context()->target_env) << " spec allows BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, uint32_t(builtin)) << " to be only used for variables with Input storage class. " << GetReferenceDesc(decoration, inst, inst, inst) << " " << GetStorageClassDesc(inst); } } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateWorkgroupSizeAtDefinition( const Decoration& decoration, const Instruction& inst) { // Vulkan requires 32-bit int, but Universal has no restrictions if (spvIsVulkanEnv(_.context()->target_env)) { if (spv_result_t error = ValidateI32Vec( decoration, inst, 3, [this, &inst](const std::string& message) -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(4427) << "According to the " << spvLogStringForEnv(_.context()->target_env) << " spec BuiltIn WorkgroupSize variable needs to be a " "3-component 32-bit int vector. " << message; })) { return error; } } if (!spvOpcodeIsConstant(inst.opcode())) { if (spvIsVulkanEnv(_.context()->target_env)) { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(4426) << "Vulkan spec requires BuiltIn WorkgroupSize to be a " "constant. " << GetIdDesc(inst) << " is not a constant."; } } else if (inst.opcode() == spv::Op::OpConstantComposite) { // can only validate product if static and not spec constant if (_.FindDef(inst.word(3))->opcode() == spv::Op::OpConstant && _.FindDef(inst.word(4))->opcode() == spv::Op::OpConstant && _.FindDef(inst.word(5))->opcode() == spv::Op::OpConstant) { uint64_t x_size, y_size, z_size; // ValidateI32Vec above confirms there will be 3 words to read bool static_x = _.EvalConstantValUint64(inst.word(3), &x_size); bool static_y = _.EvalConstantValUint64(inst.word(4), &y_size); bool static_z = _.EvalConstantValUint64(inst.word(5), &z_size); if (static_x && static_y && static_z && ((x_size * y_size * z_size) == 0)) { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << "WorkgroupSize decorations must not have a static " "product of zero (X = " << x_size << ", Y = " << y_size << ", Z = " << z_size << ")."; } } } // Seed at reference checks with this built-in. return ValidateWorkgroupSizeAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidateWorkgroupSizeAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst) { if (spvIsVulkanEnv(_.context()->target_env)) { for (const spv::ExecutionModel execution_model : execution_models_) { if (execution_model != spv::ExecutionModel::GLCompute && execution_model != spv::ExecutionModel::TaskNV && execution_model != spv::ExecutionModel::MeshNV && execution_model != spv::ExecutionModel::TaskEXT && execution_model != spv::ExecutionModel::MeshEXT) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4425) << spvLogStringForEnv(_.context()->target_env) << " spec allows BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, (uint32_t)decoration.builtin()) << " to be used only with GLCompute, MeshNV, TaskNV, MeshEXT or " << "TaskEXT execution model. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst, execution_model); } } } if (function_id_ == 0) { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateWorkgroupSizeAtReference, this, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateBaseInstanceOrVertexAtDefinition( const Decoration& decoration, const Instruction& inst) { if (spvIsVulkanEnv(_.context()->target_env)) { if (spv_result_t error = ValidateI32( decoration, inst, [this, &inst, &decoration](const std::string& message) -> spv_result_t { uint32_t vuid = (decoration.builtin() == spv::BuiltIn::BaseInstance) ? 4183 : 4186; return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(vuid) << "According to the Vulkan spec BuiltIn " << _.grammar().lookupOperandName( SPV_OPERAND_TYPE_BUILT_IN, (uint32_t)decoration.builtin()) << " variable needs to be a 32-bit int scalar. " << message; })) { return error; } } return ValidateBaseInstanceOrVertexAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidateBaseInstanceOrVertexAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst) { uint32_t operand = (uint32_t)decoration.builtin(); if (spvIsVulkanEnv(_.context()->target_env)) { const spv::StorageClass storage_class = GetStorageClass(referenced_from_inst); if (storage_class != spv::StorageClass::Max && storage_class != spv::StorageClass::Input) { uint32_t vuid = (spv::BuiltIn(operand) == spv::BuiltIn::BaseInstance) ? 4182 : 4185; return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(vuid) << "Vulkan spec allows BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, operand) << " to be only used for variables with Input storage class. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst) << " " << GetStorageClassDesc(referenced_from_inst); } for (const spv::ExecutionModel execution_model : execution_models_) { if (execution_model != spv::ExecutionModel::Vertex) { uint32_t vuid = (spv::BuiltIn(operand) == spv::BuiltIn::BaseInstance) ? 4181 : 4184; return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(vuid) << "Vulkan spec allows BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, operand) << " to be used only with Vertex execution model. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst, execution_model); } } } if (function_id_ == 0) { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back( std::bind(&BuiltInsValidator::ValidateBaseInstanceOrVertexAtReference, this, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateDrawIndexAtDefinition( const Decoration& decoration, const Instruction& inst) { if (spvIsVulkanEnv(_.context()->target_env)) { if (spv_result_t error = ValidateI32( decoration, inst, [this, &inst, &decoration](const std::string& message) -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(4209) << "According to the Vulkan spec BuiltIn " << _.grammar().lookupOperandName( SPV_OPERAND_TYPE_BUILT_IN, (uint32_t)decoration.builtin()) << " variable needs to be a 32-bit int scalar. " << message; })) { return error; } } return ValidateDrawIndexAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidateDrawIndexAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst) { uint32_t operand = (uint32_t)decoration.builtin(); if (spvIsVulkanEnv(_.context()->target_env)) { const spv::StorageClass storage_class = GetStorageClass(referenced_from_inst); if (storage_class != spv::StorageClass::Max && storage_class != spv::StorageClass::Input) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4208) << "Vulkan spec allows BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, operand) << " to be only used for variables with Input storage class. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst) << " " << GetStorageClassDesc(referenced_from_inst); } for (const spv::ExecutionModel execution_model : execution_models_) { if (execution_model != spv::ExecutionModel::Vertex && execution_model != spv::ExecutionModel::MeshNV && execution_model != spv::ExecutionModel::TaskNV && execution_model != spv::ExecutionModel::MeshEXT && execution_model != spv::ExecutionModel::TaskEXT) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4207) << "Vulkan spec allows BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, operand) << " to be used only with Vertex, MeshNV, TaskNV , MeshEXT or" << " TaskEXT execution " "model. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst, execution_model); } } } if (function_id_ == 0) { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateDrawIndexAtReference, this, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateViewIndexAtDefinition( const Decoration& decoration, const Instruction& inst) { if (spvIsVulkanEnv(_.context()->target_env)) { if (spv_result_t error = ValidateI32( decoration, inst, [this, &inst, &decoration](const std::string& message) -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(4403) << "According to the Vulkan spec BuiltIn " << _.grammar().lookupOperandName( SPV_OPERAND_TYPE_BUILT_IN, (uint32_t)decoration.builtin()) << " variable needs to be a 32-bit int scalar. " << message; })) { return error; } } return ValidateViewIndexAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidateViewIndexAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst) { uint32_t operand = (uint32_t)decoration.builtin(); if (spvIsVulkanEnv(_.context()->target_env)) { const spv::StorageClass storage_class = GetStorageClass(referenced_from_inst); if (storage_class != spv::StorageClass::Max && storage_class != spv::StorageClass::Input) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4402) << "Vulkan spec allows BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, operand) << " to be only used for variables with Input storage class. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst) << " " << GetStorageClassDesc(referenced_from_inst); } for (const spv::ExecutionModel execution_model : execution_models_) { if (execution_model == spv::ExecutionModel::GLCompute) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4401) << "Vulkan spec allows BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, operand) << " to be not be used with GLCompute execution model. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst, execution_model); } } } if (function_id_ == 0) { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateViewIndexAtReference, this, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateDeviceIndexAtDefinition( const Decoration& decoration, const Instruction& inst) { if (spvIsVulkanEnv(_.context()->target_env)) { if (spv_result_t error = ValidateI32( decoration, inst, [this, &inst, &decoration](const std::string& message) -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(4206) << "According to the Vulkan spec BuiltIn " << _.grammar().lookupOperandName( SPV_OPERAND_TYPE_BUILT_IN, (uint32_t)decoration.builtin()) << " variable needs to be a 32-bit int scalar. " << message; })) { return error; } } return ValidateDeviceIndexAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidateDeviceIndexAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst) { uint32_t operand = (uint32_t)decoration.builtin(); if (spvIsVulkanEnv(_.context()->target_env)) { const spv::StorageClass storage_class = GetStorageClass(referenced_from_inst); if (storage_class != spv::StorageClass::Max && storage_class != spv::StorageClass::Input) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4205) << "Vulkan spec allows BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, operand) << " to be only used for variables with Input storage class. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst) << " " << GetStorageClassDesc(referenced_from_inst); } } if (function_id_ == 0) { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateDeviceIndexAtReference, this, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateFragInvocationCountAtDefinition(const Decoration& decoration, const Instruction& inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::BuiltIn builtin = decoration.builtin(); if (spv_result_t error = ValidateI32( decoration, inst, [this, &inst, &builtin](const std::string& message) -> spv_result_t { uint32_t vuid = GetVUIDForBuiltin(builtin, VUIDErrorType); return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(vuid) << "According to the " << spvLogStringForEnv(_.context()->target_env) << " spec BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, uint32_t(builtin)) << " variable needs to be a 32-bit int scalar. " << message; })) { return error; } } return ValidateFragInvocationCountAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidateFragInvocationCountAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::BuiltIn builtin = decoration.builtin(); const spv::StorageClass storage_class = GetStorageClass(referenced_from_inst); if (storage_class != spv::StorageClass::Max && storage_class != spv::StorageClass::Input) { uint32_t vuid = GetVUIDForBuiltin(builtin, VUIDErrorStorageClass); return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(vuid) << spvLogStringForEnv(_.context()->target_env) << " spec allows BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, uint32_t(builtin)) << " to be only used for variables with Input storage class. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst) << " " << GetStorageClassDesc(referenced_from_inst); } for (const spv::ExecutionModel execution_model : execution_models_) { if (execution_model != spv::ExecutionModel::Fragment) { uint32_t vuid = GetVUIDForBuiltin(builtin, VUIDErrorExecutionModel); return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(vuid) << spvLogStringForEnv(_.context()->target_env) << " spec allows BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, uint32_t(builtin)) << " to be used only with Fragment execution model. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst, execution_model); } } } if (function_id_ == 0) { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateFragInvocationCountAtReference, this, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateFragSizeAtDefinition(const Decoration& decoration, const Instruction& inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::BuiltIn builtin = decoration.builtin(); if (spv_result_t error = ValidateI32Vec( decoration, inst, 2, [this, &inst, &builtin](const std::string& message) -> spv_result_t { uint32_t vuid = GetVUIDForBuiltin(builtin, VUIDErrorType); return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(vuid) << "According to the " << spvLogStringForEnv(_.context()->target_env) << " spec BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, uint32_t(builtin)) << " variable needs to be a 2-component 32-bit int vector. " << message; })) { return error; } } return ValidateFragSizeAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidateFragSizeAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::BuiltIn builtin = decoration.builtin(); const spv::StorageClass storage_class = GetStorageClass(referenced_from_inst); if (storage_class != spv::StorageClass::Max && storage_class != spv::StorageClass::Input) { uint32_t vuid = GetVUIDForBuiltin(builtin, VUIDErrorStorageClass); return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(vuid) << spvLogStringForEnv(_.context()->target_env) << " spec allows BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, uint32_t(builtin)) << " to be only used for variables with Input storage class. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst) << " " << GetStorageClassDesc(referenced_from_inst); } for (const spv::ExecutionModel execution_model : execution_models_) { if (execution_model != spv::ExecutionModel::Fragment) { uint32_t vuid = GetVUIDForBuiltin(builtin, VUIDErrorExecutionModel); return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(vuid) << spvLogStringForEnv(_.context()->target_env) << " spec allows BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, uint32_t(builtin)) << " to be used only with Fragment execution model. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst, execution_model); } } } if (function_id_ == 0) { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateFragSizeAtReference, this, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateFragStencilRefAtDefinition(const Decoration& decoration, const Instruction& inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::BuiltIn builtin = decoration.builtin(); if (spv_result_t error = ValidateI( decoration, inst, [this, &inst, &builtin](const std::string& message) -> spv_result_t { uint32_t vuid = GetVUIDForBuiltin(builtin, VUIDErrorType); return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(vuid) << "According to the " << spvLogStringForEnv(_.context()->target_env) << " spec BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, uint32_t(builtin)) << " variable needs to be a int scalar. " << message; })) { return error; } } return ValidateFragStencilRefAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidateFragStencilRefAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::BuiltIn builtin = decoration.builtin(); const spv::StorageClass storage_class = GetStorageClass(referenced_from_inst); if (storage_class != spv::StorageClass::Max && storage_class != spv::StorageClass::Output) { uint32_t vuid = GetVUIDForBuiltin(builtin, VUIDErrorStorageClass); return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(vuid) << spvLogStringForEnv(_.context()->target_env) << " spec allows BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, uint32_t(builtin)) << " to be only used for variables with Output storage class. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst) << " " << GetStorageClassDesc(referenced_from_inst); } for (const spv::ExecutionModel execution_model : execution_models_) { if (execution_model != spv::ExecutionModel::Fragment) { uint32_t vuid = GetVUIDForBuiltin(builtin, VUIDErrorExecutionModel); return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(vuid) << spvLogStringForEnv(_.context()->target_env) << " spec allows BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, uint32_t(builtin)) << " to be used only with Fragment execution model. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst, execution_model); } } } if (function_id_ == 0) { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateFragStencilRefAtReference, this, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateFullyCoveredAtDefinition(const Decoration& decoration, const Instruction& inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::BuiltIn builtin = decoration.builtin(); if (spv_result_t error = ValidateBool( decoration, inst, [this, &inst, &builtin](const std::string& message) -> spv_result_t { uint32_t vuid = GetVUIDForBuiltin(builtin, VUIDErrorType); return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(vuid) << "According to the " << spvLogStringForEnv(_.context()->target_env) << " spec BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, uint32_t(builtin)) << " variable needs to be a bool scalar. " << message; })) { return error; } } return ValidateFullyCoveredAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidateFullyCoveredAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::BuiltIn builtin = decoration.builtin(); const spv::StorageClass storage_class = GetStorageClass(referenced_from_inst); if (storage_class != spv::StorageClass::Max && storage_class != spv::StorageClass::Input) { uint32_t vuid = GetVUIDForBuiltin(builtin, VUIDErrorStorageClass); return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(vuid) << spvLogStringForEnv(_.context()->target_env) << " spec allows BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, uint32_t(builtin)) << " to be only used for variables with Input storage class. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst) << " " << GetStorageClassDesc(referenced_from_inst); } for (const spv::ExecutionModel execution_model : execution_models_) { if (execution_model != spv::ExecutionModel::Fragment) { uint32_t vuid = GetVUIDForBuiltin(builtin, VUIDErrorExecutionModel); return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(vuid) << spvLogStringForEnv(_.context()->target_env) << " spec allows BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, uint32_t(builtin)) << " to be used only with Fragment execution model. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst, execution_model); } } } if (function_id_ == 0) { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateFullyCoveredAtReference, this, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateNVSMOrARMCoreBuiltinsAtDefinition( const Decoration& decoration, const Instruction& inst) { if (spvIsVulkanEnv(_.context()->target_env)) { if (spv_result_t error = ValidateI32( decoration, inst, [this, &inst, &decoration](const std::string& message) -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << "According to the " << spvLogStringForEnv(_.context()->target_env) << " spec BuiltIn " << _.grammar().lookupOperandName( SPV_OPERAND_TYPE_BUILT_IN, (uint32_t)decoration.builtin()) << " variable needs to be a 32-bit int scalar. " << message; })) { return error; } } // Seed at reference checks with this built-in. return ValidateNVSMOrARMCoreBuiltinsAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidateNVSMOrARMCoreBuiltinsAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::StorageClass storage_class = GetStorageClass(referenced_from_inst); if (storage_class != spv::StorageClass::Max && storage_class != spv::StorageClass::Input) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << spvLogStringForEnv(_.context()->target_env) << " spec allows BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, (uint32_t)decoration.builtin()) << " to be only used for " "variables with Input storage class. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst) << " " << GetStorageClassDesc(referenced_from_inst); } } if (function_id_ == 0) { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateNVSMOrARMCoreBuiltinsAtReference, this, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidatePrimitiveShadingRateAtDefinition( const Decoration& decoration, const Instruction& inst) { if (spvIsVulkanEnv(_.context()->target_env)) { if (spv_result_t error = ValidateI32( decoration, inst, [this, &inst, &decoration](const std::string& message) -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(4486) << "According to the Vulkan spec BuiltIn " << _.grammar().lookupOperandName( SPV_OPERAND_TYPE_BUILT_IN, (uint32_t)decoration.builtin()) << " variable needs to be a 32-bit int scalar. " << message; })) { return error; } if (isMeshInterfaceVar(inst) && _.HasCapability(spv::Capability::MeshShadingEXT) && !_.HasDecoration(inst.id(), spv::Decoration::PerPrimitiveEXT)) { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(7059) << "The variable decorated with PrimitiveShadingRateKHR " "within the MeshEXT Execution Model must also be " "decorated with the PerPrimitiveEXT decoration"; } } // Seed at reference checks with this built-in. return ValidatePrimitiveShadingRateAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidatePrimitiveShadingRateAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::StorageClass storage_class = GetStorageClass(referenced_from_inst); if (storage_class != spv::StorageClass::Max && storage_class != spv::StorageClass::Output) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4485) << "Vulkan spec allows BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, (uint32_t)decoration.builtin()) << " to be only used for variables with Output storage class. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst) << " " << GetStorageClassDesc(referenced_from_inst); } for (const spv::ExecutionModel execution_model : execution_models_) { switch (execution_model) { case spv::ExecutionModel::Vertex: case spv::ExecutionModel::Geometry: case spv::ExecutionModel::MeshNV: case spv::ExecutionModel::MeshEXT: break; default: { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4484) << "Vulkan spec allows BuiltIn " << _.grammar().lookupOperandName( SPV_OPERAND_TYPE_BUILT_IN, (uint32_t)decoration.builtin()) << " to be used only with Vertex, Geometry, MeshNV or MeshEXT " "execution models. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst, execution_model); } } } } if (function_id_ == 0) { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back( std::bind(&BuiltInsValidator::ValidatePrimitiveShadingRateAtReference, this, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateShadingRateAtDefinition( const Decoration& decoration, const Instruction& inst) { if (spvIsVulkanEnv(_.context()->target_env)) { if (spv_result_t error = ValidateI32( decoration, inst, [this, &inst, &decoration](const std::string& message) -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(4492) << "According to the Vulkan spec BuiltIn " << _.grammar().lookupOperandName( SPV_OPERAND_TYPE_BUILT_IN, (uint32_t)decoration.builtin()) << " variable needs to be a 32-bit int scalar. " << message; })) { return error; } } // Seed at reference checks with this built-in. return ValidateShadingRateAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidateShadingRateAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::StorageClass storage_class = GetStorageClass(referenced_from_inst); if (storage_class != spv::StorageClass::Max && storage_class != spv::StorageClass::Input) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4491) << "Vulkan spec allows BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, (uint32_t)decoration.builtin()) << " to be only used for variables with Input storage class. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst) << " " << GetStorageClassDesc(referenced_from_inst); } for (const spv::ExecutionModel execution_model : execution_models_) { if (execution_model != spv::ExecutionModel::Fragment) { return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(4490) << "Vulkan spec allows BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, (uint32_t)decoration.builtin()) << " to be used only with the Fragment execution model. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst, execution_model); } } } if (function_id_ == 0) { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( &BuiltInsValidator::ValidateShadingRateAtReference, this, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateRayTracingBuiltinsAtDefinition( const Decoration& decoration, const Instruction& inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::BuiltIn builtin = decoration.builtin(); switch (builtin) { case spv::BuiltIn::HitTNV: case spv::BuiltIn::RayTminKHR: case spv::BuiltIn::RayTmaxKHR: // f32 scalar if (spv_result_t error = ValidateF32( decoration, inst, [this, &inst, builtin](const std::string& message) -> spv_result_t { uint32_t vuid = GetVUIDForBuiltin(builtin, VUIDErrorType); return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(vuid) << "According to the Vulkan spec BuiltIn " << _.grammar().lookupOperandName( SPV_OPERAND_TYPE_BUILT_IN, uint32_t(builtin)) << " variable needs to be a 32-bit float scalar. " << message; })) { return error; } break; case spv::BuiltIn::HitKindKHR: case spv::BuiltIn::InstanceCustomIndexKHR: case spv::BuiltIn::InstanceId: case spv::BuiltIn::RayGeometryIndexKHR: case spv::BuiltIn::IncomingRayFlagsKHR: case spv::BuiltIn::CullMaskKHR: // i32 scalar if (spv_result_t error = ValidateI32( decoration, inst, [this, &inst, builtin](const std::string& message) -> spv_result_t { uint32_t vuid = GetVUIDForBuiltin(builtin, VUIDErrorType); return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(vuid) << "According to the Vulkan spec BuiltIn " << _.grammar().lookupOperandName( SPV_OPERAND_TYPE_BUILT_IN, uint32_t(builtin)) << " variable needs to be a 32-bit int scalar. " << message; })) { return error; } break; case spv::BuiltIn::ObjectRayDirectionKHR: case spv::BuiltIn::ObjectRayOriginKHR: case spv::BuiltIn::WorldRayDirectionKHR: case spv::BuiltIn::WorldRayOriginKHR: // f32 vec3 if (spv_result_t error = ValidateF32Vec( decoration, inst, 3, [this, &inst, builtin](const std::string& message) -> spv_result_t { uint32_t vuid = GetVUIDForBuiltin(builtin, VUIDErrorType); return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(vuid) << "According to the Vulkan spec BuiltIn " << _.grammar().lookupOperandName( SPV_OPERAND_TYPE_BUILT_IN, uint32_t(builtin)) << " variable needs to be a 3-component 32-bit float " "vector. " << message; })) { return error; } break; case spv::BuiltIn::LaunchIdKHR: case spv::BuiltIn::LaunchSizeKHR: // i32 vec3 if (spv_result_t error = ValidateI32Vec( decoration, inst, 3, [this, &inst, builtin](const std::string& message) -> spv_result_t { uint32_t vuid = GetVUIDForBuiltin(builtin, VUIDErrorType); return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(vuid) << "According to the Vulkan spec BuiltIn " << _.grammar().lookupOperandName( SPV_OPERAND_TYPE_BUILT_IN, uint32_t(builtin)) << " variable needs to be a 3-component 32-bit int " "vector. " << message; })) { return error; } break; case spv::BuiltIn::ObjectToWorldKHR: case spv::BuiltIn::WorldToObjectKHR: // f32 mat4x3 if (spv_result_t error = ValidateF32Mat( decoration, inst, 3, 4, [this, &inst, builtin](const std::string& message) -> spv_result_t { uint32_t vuid = GetVUIDForBuiltin(builtin, VUIDErrorType); return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(vuid) << "According to the Vulkan spec BuiltIn " << _.grammar().lookupOperandName( SPV_OPERAND_TYPE_BUILT_IN, uint32_t(builtin)) << " variable needs to be a matrix with" << " 4 columns of 3-component vectors of 32-bit " "floats. " << message; })) { return error; } break; default: assert(0 && "Unexpected ray tracing builtin"); break; } } // Seed at reference checks with this built-in. return ValidateRayTracingBuiltinsAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidateRayTracingBuiltinsAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::BuiltIn builtin = decoration.builtin(); const spv::StorageClass storage_class = GetStorageClass(referenced_from_inst); if (storage_class != spv::StorageClass::Max && storage_class != spv::StorageClass::Input) { uint32_t vuid = GetVUIDForBuiltin(builtin, VUIDErrorStorageClass); return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(vuid) << "Vulkan spec allows BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, (uint32_t)decoration.builtin()) << " to be only used for variables with Input storage class. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst) << " " << GetStorageClassDesc(referenced_from_inst); } for (const spv::ExecutionModel execution_model : execution_models_) { if (!IsExecutionModelValidForRtBuiltIn(builtin, execution_model)) { uint32_t vuid = GetVUIDForBuiltin(builtin, VUIDErrorExecutionModel); return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(vuid) << "Vulkan spec does not allow BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, (uint32_t)decoration.builtin()) << " to be used with the execution model " << _.grammar().lookupOperandName( SPV_OPERAND_TYPE_EXECUTION_MODEL, uint32_t(execution_model)) << ".\n" << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst, execution_model); } } } if (function_id_ == 0) { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back( std::bind(&BuiltInsValidator::ValidateRayTracingBuiltinsAtReference, this, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateMeshShadingEXTBuiltinsAtDefinition( const Decoration& decoration, const Instruction& inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::BuiltIn builtin = decoration.builtin(); uint32_t vuid = GetVUIDForBuiltin(builtin, VUIDErrorType); switch (builtin) { case spv::BuiltIn::PrimitivePointIndicesEXT: if (spv_result_t error = ValidateI32Arr( decoration, inst, [this, &inst, &decoration, &vuid](const std::string& message) -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(vuid) << "According to the " << spvLogStringForEnv(_.context()->target_env) << " spec BuiltIn " << _.grammar().lookupOperandName( SPV_OPERAND_TYPE_BUILT_IN, (uint32_t)decoration.builtin()) << " variable needs to be a 32-bit int array." << message; })) { return error; } break; case spv::BuiltIn::PrimitiveLineIndicesEXT: if (spv_result_t error = ValidateArrayedI32Vec( decoration, inst, 2, [this, &inst, &decoration, &vuid](const std::string& message) -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(vuid) << "According to the " << spvLogStringForEnv(_.context()->target_env) << " spec BuiltIn " << _.grammar().lookupOperandName( SPV_OPERAND_TYPE_BUILT_IN, (uint32_t)decoration.builtin()) << " variable needs to be a 2-component 32-bit int " "array." << message; })) { return error; } break; case spv::BuiltIn::PrimitiveTriangleIndicesEXT: if (spv_result_t error = ValidateArrayedI32Vec( decoration, inst, 3, [this, &inst, &decoration, &vuid](const std::string& message) -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(vuid) << "According to the " << spvLogStringForEnv(_.context()->target_env) << " spec BuiltIn " << _.grammar().lookupOperandName( SPV_OPERAND_TYPE_BUILT_IN, (uint32_t)decoration.builtin()) << " variable needs to be a 3-component 32-bit int " "array." << message; })) { return error; } break; case spv::BuiltIn::CullPrimitiveEXT: if (spv_result_t error = ValidateBool( decoration, inst, [this, &inst, &decoration, &vuid](const std::string& message) -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(vuid) << "According to the " << spvLogStringForEnv(_.context()->target_env) << " spec BuiltIn " << _.grammar().lookupOperandName( SPV_OPERAND_TYPE_BUILT_IN, (uint32_t)decoration.builtin()) << " variable needs to be a boolean value " "array." << message; })) { return error; } if (!_.HasDecoration(inst.id(), spv::Decoration::PerPrimitiveEXT)) { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(7038) << "The variable decorated with CullPrimitiveEXT within the " "MeshEXT Execution Model must also be decorated with the " "PerPrimitiveEXT decoration "; } break; default: assert(0 && "Unexpected mesh EXT builtin"); } for (const uint32_t entry_point : _.entry_points()) { const auto* modes = _.GetExecutionModes(entry_point); uint64_t maxOutputPrimitives = _.GetOutputPrimitivesEXT(entry_point); uint32_t underlying_type = 0; if (spv_result_t error = GetUnderlyingType(_, decoration, inst, &underlying_type)) { return error; } uint64_t primitiveArrayDim = 0; if (_.GetIdOpcode(underlying_type) == spv::Op::OpTypeArray) { underlying_type = _.FindDef(underlying_type)->word(3u); if (!_.EvalConstantValUint64(underlying_type, &primitiveArrayDim)) { assert(0 && "Array type definition is corrupt"); } } switch (builtin) { case spv::BuiltIn::PrimitivePointIndicesEXT: if (!modes || !modes->count(spv::ExecutionMode::OutputPoints)) { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(7042) << "The PrimitivePointIndicesEXT decoration must be used " "with " "the OutputPoints Execution Mode. "; } if (primitiveArrayDim && primitiveArrayDim != maxOutputPrimitives) { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(7046) << "The size of the array decorated with " "PrimitivePointIndicesEXT must match the value specified " "by OutputPrimitivesEXT. "; } break; case spv::BuiltIn::PrimitiveLineIndicesEXT: if (!modes || !modes->count(spv::ExecutionMode::OutputLinesEXT)) { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(7048) << "The PrimitiveLineIndicesEXT decoration must be used " "with " "the OutputLinesEXT Execution Mode. "; } if (primitiveArrayDim && primitiveArrayDim != maxOutputPrimitives) { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(7052) << "The size of the array decorated with " "PrimitiveLineIndicesEXT must match the value specified " "by OutputPrimitivesEXT. "; } break; case spv::BuiltIn::PrimitiveTriangleIndicesEXT: if (!modes || !modes->count(spv::ExecutionMode::OutputTrianglesEXT)) { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(7054) << "The PrimitiveTriangleIndicesEXT decoration must be used " "with " "the OutputTrianglesEXT Execution Mode. "; } if (primitiveArrayDim && primitiveArrayDim != maxOutputPrimitives) { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(7058) << "The size of the array decorated with " "PrimitiveTriangleIndicesEXT must match the value " "specified " "by OutputPrimitivesEXT. "; } break; default: break; // no validation rules } } } // Seed at reference checks with this built-in. return ValidateMeshShadingEXTBuiltinsAtReference(decoration, inst, inst, inst); } spv_result_t BuiltInsValidator::ValidateMeshShadingEXTBuiltinsAtReference( const Decoration& decoration, const Instruction& built_in_inst, const Instruction& referenced_inst, const Instruction& referenced_from_inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const spv::BuiltIn builtin = decoration.builtin(); const spv::StorageClass storage_class = GetStorageClass(referenced_from_inst); if (storage_class != spv::StorageClass::Max && storage_class != spv::StorageClass::Output) { uint32_t vuid = GetVUIDForBuiltin(builtin, VUIDErrorStorageClass); return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(vuid) << spvLogStringForEnv(_.context()->target_env) << " spec allows BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, uint32_t(builtin)) << " to be only used for variables with Output storage class. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst) << " " << GetStorageClassDesc(referenced_from_inst); } for (const spv::ExecutionModel execution_model : execution_models_) { if (execution_model != spv::ExecutionModel::MeshEXT) { uint32_t vuid = GetVUIDForBuiltin(builtin, VUIDErrorExecutionModel); return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst) << _.VkErrorID(vuid) << spvLogStringForEnv(_.context()->target_env) << " spec allows BuiltIn " << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, uint32_t(builtin)) << " to be used only with MeshEXT execution model. " << GetReferenceDesc(decoration, built_in_inst, referenced_inst, referenced_from_inst, execution_model); } } } if (function_id_ == 0) { // Propagate this rule to all dependant ids in the global scope. id_to_at_reference_checks_[referenced_from_inst.id()].push_back( std::bind(&BuiltInsValidator::ValidateMeshShadingEXTBuiltinsAtReference, this, decoration, built_in_inst, referenced_from_inst, std::placeholders::_1)); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateSingleBuiltInAtDefinition( const Decoration& decoration, const Instruction& inst) { const spv::BuiltIn label = decoration.builtin(); // Universial checks if (label == spv::BuiltIn::WorkgroupSize) { return ValidateWorkgroupSizeAtDefinition(decoration, inst); } if (spvIsVulkanEnv(_.context()->target_env)) { return ValidateSingleBuiltInAtDefinitionVulkan(decoration, inst, label); } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateSingleBuiltInAtDefinitionVulkan( const Decoration& decoration, const Instruction& inst, const spv::BuiltIn label) { // If you are adding a new BuiltIn enum, please register it here. // If the newly added enum has validation rules associated with it // consider leaving a TODO and/or creating an issue. switch (label) { case spv::BuiltIn::ClipDistance: case spv::BuiltIn::CullDistance: { return ValidateClipOrCullDistanceAtDefinition(decoration, inst); } case spv::BuiltIn::FragCoord: { return ValidateFragCoordAtDefinition(decoration, inst); } case spv::BuiltIn::FragDepth: { return ValidateFragDepthAtDefinition(decoration, inst); } case spv::BuiltIn::FrontFacing: { return ValidateFrontFacingAtDefinition(decoration, inst); } case spv::BuiltIn::GlobalInvocationId: case spv::BuiltIn::LocalInvocationId: case spv::BuiltIn::NumWorkgroups: case spv::BuiltIn::WorkgroupId: { return ValidateComputeShaderI32Vec3InputAtDefinition(decoration, inst); } case spv::BuiltIn::BaryCoordKHR: case spv::BuiltIn::BaryCoordNoPerspKHR: { return ValidateFragmentShaderF32Vec3InputAtDefinition(decoration, inst); } case spv::BuiltIn::HelperInvocation: { return ValidateHelperInvocationAtDefinition(decoration, inst); } case spv::BuiltIn::InvocationId: { return ValidateInvocationIdAtDefinition(decoration, inst); } case spv::BuiltIn::InstanceIndex: { return ValidateInstanceIndexAtDefinition(decoration, inst); } case spv::BuiltIn::Layer: case spv::BuiltIn::ViewportIndex: { return ValidateLayerOrViewportIndexAtDefinition(decoration, inst); } case spv::BuiltIn::PatchVertices: { return ValidatePatchVerticesAtDefinition(decoration, inst); } case spv::BuiltIn::PointCoord: { return ValidatePointCoordAtDefinition(decoration, inst); } case spv::BuiltIn::PointSize: { return ValidatePointSizeAtDefinition(decoration, inst); } case spv::BuiltIn::Position: { return ValidatePositionAtDefinition(decoration, inst); } case spv::BuiltIn::PrimitiveId: { return ValidatePrimitiveIdAtDefinition(decoration, inst); } case spv::BuiltIn::SampleId: { return ValidateSampleIdAtDefinition(decoration, inst); } case spv::BuiltIn::SampleMask: { return ValidateSampleMaskAtDefinition(decoration, inst); } case spv::BuiltIn::SamplePosition: { return ValidateSamplePositionAtDefinition(decoration, inst); } case spv::BuiltIn::SubgroupId: case spv::BuiltIn::NumSubgroups: { return ValidateComputeI32InputAtDefinition(decoration, inst); } case spv::BuiltIn::SubgroupLocalInvocationId: case spv::BuiltIn::SubgroupSize: { return ValidateI32InputAtDefinition(decoration, inst); } case spv::BuiltIn::SubgroupEqMask: case spv::BuiltIn::SubgroupGeMask: case spv::BuiltIn::SubgroupGtMask: case spv::BuiltIn::SubgroupLeMask: case spv::BuiltIn::SubgroupLtMask: { return ValidateI32Vec4InputAtDefinition(decoration, inst); } case spv::BuiltIn::TessCoord: { return ValidateTessCoordAtDefinition(decoration, inst); } case spv::BuiltIn::TessLevelOuter: { return ValidateTessLevelOuterAtDefinition(decoration, inst); } case spv::BuiltIn::TessLevelInner: { return ValidateTessLevelInnerAtDefinition(decoration, inst); } case spv::BuiltIn::VertexIndex: { return ValidateVertexIndexAtDefinition(decoration, inst); } case spv::BuiltIn::VertexId: { return ValidateVertexIdAtDefinition(decoration, inst); } case spv::BuiltIn::LocalInvocationIndex: { return ValidateLocalInvocationIndexAtDefinition(decoration, inst); } case spv::BuiltIn::CoreIDARM: case spv::BuiltIn::CoreCountARM: case spv::BuiltIn::CoreMaxIDARM: case spv::BuiltIn::WarpIDARM: case spv::BuiltIn::WarpMaxIDARM: case spv::BuiltIn::WarpsPerSMNV: case spv::BuiltIn::SMCountNV: case spv::BuiltIn::WarpIDNV: case spv::BuiltIn::SMIDNV: { return ValidateNVSMOrARMCoreBuiltinsAtDefinition(decoration, inst); } case spv::BuiltIn::BaseInstance: case spv::BuiltIn::BaseVertex: { return ValidateBaseInstanceOrVertexAtDefinition(decoration, inst); } case spv::BuiltIn::DrawIndex: { return ValidateDrawIndexAtDefinition(decoration, inst); } case spv::BuiltIn::ViewIndex: { return ValidateViewIndexAtDefinition(decoration, inst); } case spv::BuiltIn::DeviceIndex: { return ValidateDeviceIndexAtDefinition(decoration, inst); } case spv::BuiltIn::FragInvocationCountEXT: { // alias spv::BuiltIn::InvocationsPerPixelNV return ValidateFragInvocationCountAtDefinition(decoration, inst); } case spv::BuiltIn::FragSizeEXT: { // alias spv::BuiltIn::FragmentSizeNV return ValidateFragSizeAtDefinition(decoration, inst); } case spv::BuiltIn::FragStencilRefEXT: { return ValidateFragStencilRefAtDefinition(decoration, inst); } case spv::BuiltIn::FullyCoveredEXT:{ return ValidateFullyCoveredAtDefinition(decoration, inst); } // Ray tracing builtins case spv::BuiltIn::HitKindKHR: // alias spv::BuiltIn::HitKindNV case spv::BuiltIn::HitTNV: // NOT present in KHR case spv::BuiltIn::InstanceId: case spv::BuiltIn::LaunchIdKHR: // alias spv::BuiltIn::LaunchIdNV case spv::BuiltIn::LaunchSizeKHR: // alias spv::BuiltIn::LaunchSizeNV case spv::BuiltIn::WorldRayOriginKHR: // alias spv::BuiltIn::WorldRayOriginNV case spv::BuiltIn::WorldRayDirectionKHR: // alias spv::BuiltIn::WorldRayDirectionNV case spv::BuiltIn::ObjectRayOriginKHR: // alias spv::BuiltIn::ObjectRayOriginNV case spv::BuiltIn::ObjectRayDirectionKHR: // alias // spv::BuiltIn::ObjectRayDirectionNV case spv::BuiltIn::RayTminKHR: // alias spv::BuiltIn::RayTminNV case spv::BuiltIn::RayTmaxKHR: // alias spv::BuiltIn::RayTmaxNV case spv::BuiltIn::InstanceCustomIndexKHR: // alias // spv::BuiltIn::InstanceCustomIndexNV case spv::BuiltIn::ObjectToWorldKHR: // alias spv::BuiltIn::ObjectToWorldNV case spv::BuiltIn::WorldToObjectKHR: // alias spv::BuiltIn::WorldToObjectNV case spv::BuiltIn::IncomingRayFlagsKHR: // alias spv::BuiltIn::IncomingRayFlagsNV case spv::BuiltIn::RayGeometryIndexKHR: // NOT present in NV case spv::BuiltIn::CullMaskKHR: { return ValidateRayTracingBuiltinsAtDefinition(decoration, inst); } case spv::BuiltIn::CullPrimitiveEXT: case spv::BuiltIn::PrimitivePointIndicesEXT: case spv::BuiltIn::PrimitiveLineIndicesEXT: case spv::BuiltIn::PrimitiveTriangleIndicesEXT: { return ValidateMeshShadingEXTBuiltinsAtDefinition(decoration, inst); } case spv::BuiltIn::PrimitiveShadingRateKHR: { return ValidatePrimitiveShadingRateAtDefinition(decoration, inst); } case spv::BuiltIn::ShadingRateKHR: { return ValidateShadingRateAtDefinition(decoration, inst); } default: // No validation rules (for the moment). break; } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::ValidateBuiltInsAtDefinition() { for (const auto& kv : _.id_decorations()) { const uint32_t id = kv.first; const auto& decorations = kv.second; if (decorations.empty()) { continue; } const Instruction* inst = _.FindDef(id); assert(inst); for (const auto& decoration : kv.second) { if (decoration.dec_type() != spv::Decoration::BuiltIn) { continue; } if (spv_result_t error = ValidateSingleBuiltInAtDefinition(decoration, *inst)) { return error; } } } return SPV_SUCCESS; } spv_result_t BuiltInsValidator::Run() { // First pass: validate all built-ins at definition and seed // id_to_at_reference_checks_ with built-ins. if (auto error = ValidateBuiltInsAtDefinition()) { return error; } if (id_to_at_reference_checks_.empty()) { // No validation tasks were seeded. Nothing else to do. return SPV_SUCCESS; } // Second pass: validate every id reference in the module using // rules in id_to_at_reference_checks_. for (const Instruction& inst : _.ordered_instructions()) { Update(inst); std::set already_checked; for (const auto& operand : inst.operands()) { if (!spvIsIdType(operand.type)) { // Not id. continue; } const uint32_t id = inst.word(operand.offset); if (id == inst.id()) { // No need to check result id. continue; } if (!already_checked.insert(id).second) { // The instruction has already referenced this id. continue; } // Instruction references the id. Run all checks associated with the id // on the instruction. id_to_at_reference_checks_ can be modified in the // process, iterators are safe because it's a tree-based map. const auto it = id_to_at_reference_checks_.find(id); if (it != id_to_at_reference_checks_.end()) { for (const auto& check : it->second) { if (spv_result_t error = check(inst)) { return error; } } } } } return SPV_SUCCESS; } } // namespace // Validates correctness of built-in variables. spv_result_t ValidateBuiltIns(ValidationState_t& _) { BuiltInsValidator validator(_); return validator.Run(); } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_capability.cpp000066400000000000000000000327301475742701700253160ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validates OpCapability instruction. #include #include #include "source/opcode.h" #include "source/val/instruction.h" #include "source/val/validate.h" #include "source/val/validation_state.h" namespace spvtools { namespace val { namespace { bool IsSupportGuaranteedVulkan_1_0(uint32_t capability) { switch (spv::Capability(capability)) { case spv::Capability::Matrix: case spv::Capability::Shader: case spv::Capability::InputAttachment: case spv::Capability::Sampled1D: case spv::Capability::Image1D: case spv::Capability::SampledBuffer: case spv::Capability::ImageBuffer: case spv::Capability::ImageQuery: case spv::Capability::DerivativeControl: return true; default: break; } return false; } bool IsSupportGuaranteedVulkan_1_1(uint32_t capability) { if (IsSupportGuaranteedVulkan_1_0(capability)) return true; switch (spv::Capability(capability)) { case spv::Capability::DeviceGroup: case spv::Capability::MultiView: return true; default: break; } return false; } bool IsSupportGuaranteedVulkan_1_2(uint32_t capability) { if (IsSupportGuaranteedVulkan_1_1(capability)) return true; switch (spv::Capability(capability)) { case spv::Capability::ShaderNonUniform: return true; default: break; } return false; } bool IsSupportOptionalVulkan_1_0(uint32_t capability) { switch (spv::Capability(capability)) { case spv::Capability::Geometry: case spv::Capability::Tessellation: case spv::Capability::Float64: case spv::Capability::Int64: case spv::Capability::Int16: case spv::Capability::TessellationPointSize: case spv::Capability::GeometryPointSize: case spv::Capability::ImageGatherExtended: case spv::Capability::StorageImageMultisample: case spv::Capability::UniformBufferArrayDynamicIndexing: case spv::Capability::SampledImageArrayDynamicIndexing: case spv::Capability::StorageBufferArrayDynamicIndexing: case spv::Capability::StorageImageArrayDynamicIndexing: case spv::Capability::ClipDistance: case spv::Capability::CullDistance: case spv::Capability::ImageCubeArray: case spv::Capability::SampleRateShading: case spv::Capability::SparseResidency: case spv::Capability::MinLod: case spv::Capability::SampledCubeArray: case spv::Capability::ImageMSArray: case spv::Capability::StorageImageExtendedFormats: case spv::Capability::InterpolationFunction: case spv::Capability::StorageImageReadWithoutFormat: case spv::Capability::StorageImageWriteWithoutFormat: case spv::Capability::MultiViewport: case spv::Capability::Int64Atomics: case spv::Capability::TransformFeedback: case spv::Capability::GeometryStreams: case spv::Capability::Float16: case spv::Capability::Int8: return true; default: break; } return false; } bool IsSupportOptionalVulkan_1_1(uint32_t capability) { if (IsSupportOptionalVulkan_1_0(capability)) return true; switch (spv::Capability(capability)) { case spv::Capability::GroupNonUniform: case spv::Capability::GroupNonUniformVote: case spv::Capability::GroupNonUniformArithmetic: case spv::Capability::GroupNonUniformBallot: case spv::Capability::GroupNonUniformShuffle: case spv::Capability::GroupNonUniformShuffleRelative: case spv::Capability::GroupNonUniformClustered: case spv::Capability::GroupNonUniformQuad: case spv::Capability::DrawParameters: // Alias spv::Capability::StorageBuffer16BitAccess. case spv::Capability::StorageUniformBufferBlock16: // Alias spv::Capability::UniformAndStorageBuffer16BitAccess. case spv::Capability::StorageUniform16: case spv::Capability::StoragePushConstant16: case spv::Capability::StorageInputOutput16: case spv::Capability::DeviceGroup: case spv::Capability::MultiView: case spv::Capability::VariablePointersStorageBuffer: case spv::Capability::VariablePointers: return true; default: break; } return false; } bool IsSupportOptionalVulkan_1_2(uint32_t capability) { if (IsSupportOptionalVulkan_1_1(capability)) return true; switch (spv::Capability(capability)) { case spv::Capability::DenormPreserve: case spv::Capability::DenormFlushToZero: case spv::Capability::SignedZeroInfNanPreserve: case spv::Capability::RoundingModeRTE: case spv::Capability::RoundingModeRTZ: case spv::Capability::VulkanMemoryModel: case spv::Capability::VulkanMemoryModelDeviceScope: case spv::Capability::StorageBuffer8BitAccess: case spv::Capability::UniformAndStorageBuffer8BitAccess: case spv::Capability::StoragePushConstant8: case spv::Capability::ShaderViewportIndex: case spv::Capability::ShaderLayer: case spv::Capability::PhysicalStorageBufferAddresses: case spv::Capability::RuntimeDescriptorArray: case spv::Capability::UniformTexelBufferArrayDynamicIndexing: case spv::Capability::StorageTexelBufferArrayDynamicIndexing: case spv::Capability::UniformBufferArrayNonUniformIndexing: case spv::Capability::SampledImageArrayNonUniformIndexing: case spv::Capability::StorageBufferArrayNonUniformIndexing: case spv::Capability::StorageImageArrayNonUniformIndexing: case spv::Capability::InputAttachmentArrayNonUniformIndexing: case spv::Capability::UniformTexelBufferArrayNonUniformIndexing: case spv::Capability::StorageTexelBufferArrayNonUniformIndexing: return true; default: break; } return false; } bool IsSupportGuaranteedOpenCL_1_2(uint32_t capability, bool embedded_profile) { switch (spv::Capability(capability)) { case spv::Capability::Addresses: case spv::Capability::Float16Buffer: case spv::Capability::Int16: case spv::Capability::Int8: case spv::Capability::Kernel: case spv::Capability::Linkage: case spv::Capability::Vector16: return true; case spv::Capability::Int64: return !embedded_profile; default: break; } return false; } bool IsSupportGuaranteedOpenCL_2_0(uint32_t capability, bool embedded_profile) { if (IsSupportGuaranteedOpenCL_1_2(capability, embedded_profile)) return true; switch (spv::Capability(capability)) { case spv::Capability::DeviceEnqueue: case spv::Capability::GenericPointer: case spv::Capability::Groups: case spv::Capability::Pipes: return true; default: break; } return false; } bool IsSupportGuaranteedOpenCL_2_2(uint32_t capability, bool embedded_profile) { if (IsSupportGuaranteedOpenCL_2_0(capability, embedded_profile)) return true; switch (spv::Capability(capability)) { case spv::Capability::SubgroupDispatch: case spv::Capability::PipeStorage: return true; default: break; } return false; } bool IsSupportOptionalOpenCL_1_2(uint32_t capability) { switch (spv::Capability(capability)) { case spv::Capability::ImageBasic: case spv::Capability::Float64: return true; default: break; } return false; } // Checks if |capability| was enabled by extension. bool IsEnabledByExtension(ValidationState_t& _, uint32_t capability) { spv_operand_desc operand_desc = nullptr; _.grammar().lookupOperand(SPV_OPERAND_TYPE_CAPABILITY, capability, &operand_desc); // operand_desc is expected to be not null, otherwise validator would have // failed at an earlier stage. This 'assert' is 'just in case'. assert(operand_desc); ExtensionSet operand_exts(operand_desc->numExtensions, operand_desc->extensions); if (operand_exts.empty()) return false; return _.HasAnyOfExtensions(operand_exts); } bool IsEnabledByCapabilityOpenCL_1_2(ValidationState_t& _, uint32_t capability) { if (_.HasCapability(spv::Capability::ImageBasic)) { switch (spv::Capability(capability)) { case spv::Capability::LiteralSampler: case spv::Capability::Sampled1D: case spv::Capability::Image1D: case spv::Capability::SampledBuffer: case spv::Capability::ImageBuffer: return true; default: break; } return false; } return false; } bool IsEnabledByCapabilityOpenCL_2_0(ValidationState_t& _, uint32_t capability) { if (_.HasCapability(spv::Capability::ImageBasic)) { switch (spv::Capability(capability)) { case spv::Capability::ImageReadWrite: case spv::Capability::LiteralSampler: case spv::Capability::Sampled1D: case spv::Capability::Image1D: case spv::Capability::SampledBuffer: case spv::Capability::ImageBuffer: return true; default: break; } return false; } return false; } } // namespace // Validates that capability declarations use operands allowed in the current // context. spv_result_t CapabilityPass(ValidationState_t& _, const Instruction* inst) { if (inst->opcode() != spv::Op::OpCapability) return SPV_SUCCESS; assert(inst->operands().size() == 1); const spv_parsed_operand_t& operand = inst->operand(0); assert(operand.num_words == 1); assert(operand.offset < inst->words().size()); const uint32_t capability = inst->word(operand.offset); const auto capability_str = [&_, capability]() { spv_operand_desc desc = nullptr; if (_.grammar().lookupOperand(SPV_OPERAND_TYPE_CAPABILITY, capability, &desc) != SPV_SUCCESS || !desc) { return std::string("Unknown"); } return std::string(desc->name); }; const auto env = _.context()->target_env; const bool opencl_embedded = env == SPV_ENV_OPENCL_EMBEDDED_1_2 || env == SPV_ENV_OPENCL_EMBEDDED_2_0 || env == SPV_ENV_OPENCL_EMBEDDED_2_1 || env == SPV_ENV_OPENCL_EMBEDDED_2_2; const std::string opencl_profile = opencl_embedded ? "Embedded" : "Full"; if (env == SPV_ENV_VULKAN_1_0) { if (!IsSupportGuaranteedVulkan_1_0(capability) && !IsSupportOptionalVulkan_1_0(capability) && !IsEnabledByExtension(_, capability)) { return _.diag(SPV_ERROR_INVALID_CAPABILITY, inst) << "Capability " << capability_str() << " is not allowed by Vulkan 1.0 specification" << " (or requires extension)"; } } else if (env == SPV_ENV_VULKAN_1_1) { if (!IsSupportGuaranteedVulkan_1_1(capability) && !IsSupportOptionalVulkan_1_1(capability) && !IsEnabledByExtension(_, capability)) { return _.diag(SPV_ERROR_INVALID_CAPABILITY, inst) << "Capability " << capability_str() << " is not allowed by Vulkan 1.1 specification" << " (or requires extension)"; } } else if (env == SPV_ENV_VULKAN_1_2) { if (!IsSupportGuaranteedVulkan_1_2(capability) && !IsSupportOptionalVulkan_1_2(capability) && !IsEnabledByExtension(_, capability)) { return _.diag(SPV_ERROR_INVALID_CAPABILITY, inst) << "Capability " << capability_str() << " is not allowed by Vulkan 1.2 specification" << " (or requires extension)"; } } else if (env == SPV_ENV_OPENCL_1_2 || env == SPV_ENV_OPENCL_EMBEDDED_1_2) { if (!IsSupportGuaranteedOpenCL_1_2(capability, opencl_embedded) && !IsSupportOptionalOpenCL_1_2(capability) && !IsEnabledByExtension(_, capability) && !IsEnabledByCapabilityOpenCL_1_2(_, capability)) { return _.diag(SPV_ERROR_INVALID_CAPABILITY, inst) << "Capability " << capability_str() << " is not allowed by OpenCL 1.2 " << opencl_profile << " Profile specification" << " (or requires extension or capability)"; } } else if (env == SPV_ENV_OPENCL_2_0 || env == SPV_ENV_OPENCL_EMBEDDED_2_0 || env == SPV_ENV_OPENCL_2_1 || env == SPV_ENV_OPENCL_EMBEDDED_2_1) { if (!IsSupportGuaranteedOpenCL_2_0(capability, opencl_embedded) && !IsSupportOptionalOpenCL_1_2(capability) && !IsEnabledByExtension(_, capability) && !IsEnabledByCapabilityOpenCL_2_0(_, capability)) { return _.diag(SPV_ERROR_INVALID_CAPABILITY, inst) << "Capability " << capability_str() << " is not allowed by OpenCL 2.0/2.1 " << opencl_profile << " Profile specification" << " (or requires extension or capability)"; } } else if (env == SPV_ENV_OPENCL_2_2 || env == SPV_ENV_OPENCL_EMBEDDED_2_2) { if (!IsSupportGuaranteedOpenCL_2_2(capability, opencl_embedded) && !IsSupportOptionalOpenCL_1_2(capability) && !IsEnabledByExtension(_, capability) && !IsEnabledByCapabilityOpenCL_2_0(_, capability)) { return _.diag(SPV_ERROR_INVALID_CAPABILITY, inst) << "Capability " << capability_str() << " is not allowed by OpenCL 2.2 " << opencl_profile << " Profile specification" << " (or requires extension or capability)"; } } return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_cfg.cpp000066400000000000000000001427201475742701700237350ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include #include #include #include #include #include #include #include "source/cfa.h" #include "source/opcode.h" #include "source/spirv_constant.h" #include "source/spirv_validator_options.h" #include "source/val/basic_block.h" #include "source/val/construct.h" #include "source/val/function.h" #include "source/val/validate.h" #include "source/val/validation_state.h" namespace spvtools { namespace val { namespace { spv_result_t ValidatePhi(ValidationState_t& _, const Instruction* inst) { auto block = inst->block(); size_t num_in_ops = inst->words().size() - 3; if (num_in_ops % 2 != 0) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpPhi does not have an equal number of incoming values and " "basic blocks."; } if (_.IsVoidType(inst->type_id())) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "OpPhi must not have void result type"; } if (_.IsPointerType(inst->type_id()) && _.addressing_model() == spv::AddressingModel::Logical) { if (!_.features().variable_pointers) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Using pointers with OpPhi requires capability " << "VariablePointers or VariablePointersStorageBuffer"; } } const Instruction* type_inst = _.FindDef(inst->type_id()); assert(type_inst); const spv::Op type_opcode = type_inst->opcode(); if (!_.options()->before_hlsl_legalization && !_.HasCapability(spv::Capability::BindlessTextureNV)) { if (type_opcode == spv::Op::OpTypeSampledImage || (_.HasCapability(spv::Capability::Shader) && (type_opcode == spv::Op::OpTypeImage || type_opcode == spv::Op::OpTypeSampler))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Result type cannot be Op" << spvOpcodeString(type_opcode); } } // Create a uniqued vector of predecessor ids for comparison against // incoming values. OpBranchConditional %cond %label %label produces two // predecessors in the CFG. std::vector pred_ids; std::transform(block->predecessors()->begin(), block->predecessors()->end(), std::back_inserter(pred_ids), [](const BasicBlock* b) { return b->id(); }); std::sort(pred_ids.begin(), pred_ids.end()); pred_ids.erase(std::unique(pred_ids.begin(), pred_ids.end()), pred_ids.end()); size_t num_edges = num_in_ops / 2; if (num_edges != pred_ids.size()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpPhi's number of incoming blocks (" << num_edges << ") does not match block's predecessor count (" << block->predecessors()->size() << ")."; } std::unordered_set observed_predecessors; for (size_t i = 3; i < inst->words().size(); ++i) { auto inc_id = inst->word(i); if (i % 2 == 1) { // Incoming value type must match the phi result type. auto inc_type_id = _.GetTypeId(inc_id); if (inst->type_id() != inc_type_id) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpPhi's result type " << _.getIdName(inst->type_id()) << " does not match incoming value " << _.getIdName(inc_id) << " type " << _.getIdName(inc_type_id) << "."; } } else { if (_.GetIdOpcode(inc_id) != spv::Op::OpLabel) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpPhi's incoming basic block " << _.getIdName(inc_id) << " is not an OpLabel."; } // Incoming basic block must be an immediate predecessor of the phi's // block. if (!std::binary_search(pred_ids.begin(), pred_ids.end(), inc_id)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpPhi's incoming basic block " << _.getIdName(inc_id) << " is not a predecessor of " << _.getIdName(block->id()) << "."; } // We must not have already seen this predecessor as one of the phi's // operands. if (observed_predecessors.count(inc_id) != 0) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpPhi references incoming basic block " << _.getIdName(inc_id) << " multiple times."; } // Note the fact that we have now observed this predecessor. observed_predecessors.insert(inc_id); } } return SPV_SUCCESS; } spv_result_t ValidateBranch(ValidationState_t& _, const Instruction* inst) { // target operands must be OpLabel const auto id = inst->GetOperandAs(0); const auto target = _.FindDef(id); if (!target || spv::Op::OpLabel != target->opcode()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "'Target Label' operands for OpBranch must be the ID " "of an OpLabel instruction"; } return SPV_SUCCESS; } spv_result_t ValidateBranchConditional(ValidationState_t& _, const Instruction* inst) { // num_operands is either 3 or 5 --- if 5, the last two need to be literal // integers const auto num_operands = inst->operands().size(); if (num_operands != 3 && num_operands != 5) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpBranchConditional requires either 3 or 5 parameters"; } // grab the condition operand and check that it is a bool const auto cond_id = inst->GetOperandAs(0); const auto cond_op = _.FindDef(cond_id); if (!cond_op || !cond_op->type_id() || !_.IsBoolScalarType(cond_op->type_id())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Condition operand for " "OpBranchConditional must be " "of boolean type"; } // target operands must be OpLabel // note that we don't need to check that the target labels are in the same // function, // PerformCfgChecks already checks for that const auto true_id = inst->GetOperandAs(1); const auto true_target = _.FindDef(true_id); if (!true_target || spv::Op::OpLabel != true_target->opcode()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "The 'True Label' operand for OpBranchConditional must be the " "ID of an OpLabel instruction"; } const auto false_id = inst->GetOperandAs(2); const auto false_target = _.FindDef(false_id); if (!false_target || spv::Op::OpLabel != false_target->opcode()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "The 'False Label' operand for OpBranchConditional must be the " "ID of an OpLabel instruction"; } // A similar requirement for SPV_KHR_maximal_reconvergence is deferred until // entry point call trees have been reconrded. if (_.version() >= SPV_SPIRV_VERSION_WORD(1, 6) && true_id == false_id) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "In SPIR-V 1.6 or later, True Label and False Label must be " "different labels"; } return SPV_SUCCESS; } spv_result_t ValidateSwitch(ValidationState_t& _, const Instruction* inst) { const auto num_operands = inst->operands().size(); // At least two operands (selector, default), any more than that are // literal/target. const auto sel_type_id = _.GetOperandTypeId(inst, 0); if (!_.IsIntScalarType(sel_type_id)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Selector type must be OpTypeInt"; } const auto default_label = _.FindDef(inst->GetOperandAs(1)); if (default_label->opcode() != spv::Op::OpLabel) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Default must be an OpLabel instruction"; } // target operands must be OpLabel for (size_t i = 2; i < num_operands; i += 2) { // literal, id const auto id = inst->GetOperandAs(i + 1); const auto target = _.FindDef(id); if (!target || spv::Op::OpLabel != target->opcode()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "'Target Label' operands for OpSwitch must be IDs of an " "OpLabel instruction"; } } return SPV_SUCCESS; } spv_result_t ValidateReturnValue(ValidationState_t& _, const Instruction* inst) { const auto value_id = inst->GetOperandAs(0); const auto value = _.FindDef(value_id); if (!value || !value->type_id()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpReturnValue Value " << _.getIdName(value_id) << " does not represent a value."; } auto value_type = _.FindDef(value->type_id()); if (!value_type || spv::Op::OpTypeVoid == value_type->opcode()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpReturnValue value's type " << _.getIdName(value->type_id()) << " is missing or void."; } if (_.addressing_model() == spv::AddressingModel::Logical && (spv::Op::OpTypePointer == value_type->opcode() || spv::Op::OpTypeUntypedPointerKHR == value_type->opcode()) && !_.features().variable_pointers && !_.options()->relax_logical_pointer) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpReturnValue value's type " << _.getIdName(value->type_id()) << " is a pointer, which is invalid in the Logical addressing " "model."; } const auto function = inst->function(); const auto return_type = _.FindDef(function->GetResultTypeId()); if (!return_type || return_type->id() != value_type->id()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpReturnValue Value " << _.getIdName(value_id) << "s type does not match OpFunction's return type."; } return SPV_SUCCESS; } uint32_t operator>>(const spv::LoopControlShift& lhs, const spv::LoopControlShift& rhs) { return uint32_t(lhs) >> uint32_t(rhs); } spv_result_t ValidateLoopMerge(ValidationState_t& _, const Instruction* inst) { const auto merge_id = inst->GetOperandAs(0); const auto merge = _.FindDef(merge_id); if (!merge || merge->opcode() != spv::Op::OpLabel) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Merge Block " << _.getIdName(merge_id) << " must be an OpLabel"; } if (merge_id == inst->block()->id()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Merge Block may not be the block containing the OpLoopMerge\n"; } const auto continue_id = inst->GetOperandAs(1); const auto continue_target = _.FindDef(continue_id); if (!continue_target || continue_target->opcode() != spv::Op::OpLabel) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Continue Target " << _.getIdName(continue_id) << " must be an OpLabel"; } if (merge_id == continue_id) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Merge Block and Continue Target must be different ids"; } const auto loop_control = inst->GetOperandAs(2); if ((loop_control >> spv::LoopControlShift::Unroll) & 0x1 && (loop_control >> spv::LoopControlShift::DontUnroll) & 0x1) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Unroll and DontUnroll loop controls must not both be specified"; } if ((loop_control >> spv::LoopControlShift::DontUnroll) & 0x1 && (loop_control >> spv::LoopControlShift::PeelCount) & 0x1) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "PeelCount and DontUnroll " "loop controls must not " "both be specified"; } if ((loop_control >> spv::LoopControlShift::DontUnroll) & 0x1 && (loop_control >> spv::LoopControlShift::PartialCount) & 0x1) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "PartialCount and " "DontUnroll loop controls " "must not both be specified"; } uint32_t operand = 3; if ((loop_control >> spv::LoopControlShift::DependencyLength) & 0x1) { ++operand; } if ((loop_control >> spv::LoopControlShift::MinIterations) & 0x1) { ++operand; } if ((loop_control >> spv::LoopControlShift::MaxIterations) & 0x1) { ++operand; } if ((loop_control >> spv::LoopControlShift::IterationMultiple) & 0x1) { if (inst->operands().size() < operand || inst->GetOperandAs(operand) == 0) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "IterationMultiple loop " "control operand must be " "greater than zero"; } ++operand; } if ((loop_control >> spv::LoopControlShift::PeelCount) & 0x1) { ++operand; } if ((loop_control >> spv::LoopControlShift::PartialCount) & 0x1) { ++operand; } // That the right number of operands is present is checked by the parser. The // above code tracks operands for expanded validation checking in the future. return SPV_SUCCESS; } } // namespace void printDominatorList(const BasicBlock& b) { std::cout << b.id() << " is dominated by: "; const BasicBlock* bb = &b; while (bb->immediate_dominator() != bb) { bb = bb->immediate_dominator(); std::cout << bb->id() << " "; } } #define CFG_ASSERT(ASSERT_FUNC, TARGET) \ if (spv_result_t rcode = ASSERT_FUNC(_, TARGET)) return rcode spv_result_t FirstBlockAssert(ValidationState_t& _, uint32_t target) { if (_.current_function().IsFirstBlock(target)) { return _.diag(SPV_ERROR_INVALID_CFG, _.FindDef(_.current_function().id())) << "First block " << _.getIdName(target) << " of function " << _.getIdName(_.current_function().id()) << " is targeted by block " << _.getIdName(_.current_function().current_block()->id()); } return SPV_SUCCESS; } spv_result_t MergeBlockAssert(ValidationState_t& _, uint32_t merge_block) { if (_.current_function().IsBlockType(merge_block, kBlockTypeMerge)) { return _.diag(SPV_ERROR_INVALID_CFG, _.FindDef(_.current_function().id())) << "Block " << _.getIdName(merge_block) << " is already a merge block for another header"; } return SPV_SUCCESS; } /// Update the continue construct's exit blocks once the backedge blocks are /// identified in the CFG. void UpdateContinueConstructExitBlocks( Function& function, const std::vector>& back_edges) { auto& constructs = function.constructs(); // TODO(umar): Think of a faster way to do this for (auto& edge : back_edges) { uint32_t back_edge_block_id; uint32_t loop_header_block_id; std::tie(back_edge_block_id, loop_header_block_id) = edge; auto is_this_header = [=](Construct& c) { return c.type() == ConstructType::kLoop && c.entry_block()->id() == loop_header_block_id; }; for (auto construct : constructs) { if (is_this_header(construct)) { Construct* continue_construct = construct.corresponding_constructs().back(); assert(continue_construct->type() == ConstructType::kContinue); BasicBlock* back_edge_block; std::tie(back_edge_block, std::ignore) = function.GetBlock(back_edge_block_id); continue_construct->set_exit(back_edge_block); } } } } std::tuple ConstructNames( ConstructType type) { std::string construct_name, header_name, exit_name; switch (type) { case ConstructType::kSelection: construct_name = "selection"; header_name = "selection header"; exit_name = "merge block"; break; case ConstructType::kLoop: construct_name = "loop"; header_name = "loop header"; exit_name = "merge block"; break; case ConstructType::kContinue: construct_name = "continue"; header_name = "continue target"; exit_name = "back-edge block"; break; case ConstructType::kCase: construct_name = "case"; header_name = "case entry block"; exit_name = "case exit block"; break; default: assert(1 == 0 && "Not defined type"); } return std::make_tuple(construct_name, header_name, exit_name); } /// Constructs an error message for construct validation errors std::string ConstructErrorString(const Construct& construct, const std::string& header_string, const std::string& exit_string, const std::string& dominate_text) { std::string construct_name, header_name, exit_name; std::tie(construct_name, header_name, exit_name) = ConstructNames(construct.type()); // TODO(umar): Add header block for continue constructs to error message return "The " + construct_name + " construct with the " + header_name + " " + header_string + " " + dominate_text + " the " + exit_name + " " + exit_string; } // Finds the fall through case construct of |target_block| and records it in // |case_fall_through|. Returns SPV_ERROR_INVALID_CFG if the case construct // headed by |target_block| branches to multiple case constructs. spv_result_t FindCaseFallThrough( ValidationState_t& _, BasicBlock* target_block, uint32_t* case_fall_through, const Construct& switch_construct, const std::unordered_set& case_targets) { const auto* merge = switch_construct.exit_block(); std::vector stack; stack.push_back(target_block); std::unordered_set visited; bool target_reachable = target_block->structurally_reachable(); while (!stack.empty()) { auto block = stack.back(); stack.pop_back(); if (block == merge) continue; if (!visited.insert(block).second) continue; if (target_reachable && block->structurally_reachable() && target_block->structurally_dominates(*block)) { // Still in the case construct. for (auto successor : *block->successors()) { stack.push_back(successor); } } else { // Exiting the case construct to non-merge block. if (!case_targets.count(block->id())) { // We have already filtered out the following: // * The switch's merge // * Other case targets // * Blocks in the same case construct // // So the only remaining valid branches are the structured exits from // the overall selection construct of the switch. if (switch_construct.IsStructuredExit(_, block)) { continue; } return _.diag(SPV_ERROR_INVALID_CFG, target_block->label()) << "Case construct that targets " << _.getIdName(target_block->id()) << " has invalid branch to block " << _.getIdName(block->id()) << " (not another case construct, corresponding merge, outer " "loop merge or outer loop continue)"; } if (*case_fall_through == 0u) { if (target_block != block) { *case_fall_through = block->id(); } } else if (*case_fall_through != block->id()) { // Case construct has at most one branch to another case construct. return _.diag(SPV_ERROR_INVALID_CFG, target_block->label()) << "Case construct that targets " << _.getIdName(target_block->id()) << " has branches to multiple other case construct targets " << _.getIdName(*case_fall_through) << " and " << _.getIdName(block->id()); } } } return SPV_SUCCESS; } spv_result_t StructuredSwitchChecks(ValidationState_t& _, Function* function, const Construct& switch_construct) { const auto* header = switch_construct.entry_block(); const auto* merge = switch_construct.exit_block(); const auto* switch_inst = header->terminator(); std::unordered_set case_targets; for (uint32_t i = 1; i < switch_inst->operands().size(); i += 2) { uint32_t target = switch_inst->GetOperandAs(i); if (target != merge->id()) case_targets.insert(target); } // Tracks how many times each case construct is targeted by another case // construct. std::map num_fall_through_targeted; uint32_t default_case_fall_through = 0u; uint32_t default_target = switch_inst->GetOperandAs(1u); bool default_appears_multiple_times = false; for (uint32_t i = 3; i < switch_inst->operands().size(); i += 2) { if (default_target == switch_inst->GetOperandAs(i)) { default_appears_multiple_times = true; break; } } std::unordered_map seen_to_fall_through; for (uint32_t i = 1; i < switch_inst->operands().size(); i += 2) { uint32_t target = switch_inst->GetOperandAs(i); if (target == merge->id()) continue; uint32_t case_fall_through = 0u; auto seen_iter = seen_to_fall_through.find(target); if (seen_iter == seen_to_fall_through.end()) { const auto target_block = function->GetBlock(target).first; // OpSwitch must dominate all its case constructs. if (header->structurally_reachable() && target_block->structurally_reachable() && !header->structurally_dominates(*target_block)) { return _.diag(SPV_ERROR_INVALID_CFG, header->label()) << "Switch header " << _.getIdName(header->id()) << " does not structurally dominate its case construct " << _.getIdName(target); } if (auto error = FindCaseFallThrough(_, target_block, &case_fall_through, switch_construct, case_targets)) { return error; } // Track how many time the fall through case has been targeted. if (case_fall_through != 0u) { auto where = num_fall_through_targeted.lower_bound(case_fall_through); if (where == num_fall_through_targeted.end() || where->first != case_fall_through) { num_fall_through_targeted.insert( where, std::make_pair(case_fall_through, 1)); } else { where->second++; } } seen_to_fall_through.insert(std::make_pair(target, case_fall_through)); } else { case_fall_through = seen_iter->second; } if (case_fall_through == default_target && !default_appears_multiple_times) { case_fall_through = default_case_fall_through; } if (case_fall_through != 0u) { bool is_default = i == 1; if (is_default) { default_case_fall_through = case_fall_through; } else { // Allow code like: // case x: // case y: // ... // case z: // // Where x and y target the same block and fall through to z. uint32_t j = i; while ((j + 2 < switch_inst->operands().size()) && target == switch_inst->GetOperandAs(j + 2)) { j += 2; } // If Target T1 branches to Target T2, or if Target T1 branches to the // Default target and the Default target branches to Target T2, then T1 // must immediately precede T2 in the list of OpSwitch Target operands. if ((switch_inst->operands().size() < j + 2) || (case_fall_through != switch_inst->GetOperandAs(j + 2))) { return _.diag(SPV_ERROR_INVALID_CFG, switch_inst) << "Case construct that targets " << _.getIdName(target) << " has branches to the case construct that targets " << _.getIdName(case_fall_through) << ", but does not immediately precede it in the " "OpSwitch's target list"; } } } } // Each case construct must be branched to by at most one other case // construct. for (const auto& pair : num_fall_through_targeted) { if (pair.second > 1) { return _.diag(SPV_ERROR_INVALID_CFG, _.FindDef(pair.first)) << "Multiple case constructs have branches to the case construct " "that targets " << _.getIdName(pair.first); } } return SPV_SUCCESS; } // Validates that all CFG divergences (i.e. conditional branch or switch) are // structured correctly. Either divergence is preceded by a merge instruction // or the divergence introduces at most one unseen label. spv_result_t ValidateStructuredSelections( ValidationState_t& _, const std::vector& postorder) { std::unordered_set seen; for (auto iter = postorder.rbegin(); iter != postorder.rend(); ++iter) { const auto* block = *iter; const auto* terminator = block->terminator(); if (!terminator) continue; const auto index = terminator - &_.ordered_instructions()[0]; auto* merge = &_.ordered_instructions()[index - 1]; // Marks merges and continues as seen. if (merge->opcode() == spv::Op::OpSelectionMerge) { seen.insert(merge->GetOperandAs(0)); } else if (merge->opcode() == spv::Op::OpLoopMerge) { seen.insert(merge->GetOperandAs(0)); seen.insert(merge->GetOperandAs(1)); } else { // Only track the pointer if it is a merge instruction. merge = nullptr; } // Skip unreachable blocks. if (!block->structurally_reachable()) continue; if (terminator->opcode() == spv::Op::OpBranchConditional) { const auto true_label = terminator->GetOperandAs(1); const auto false_label = terminator->GetOperandAs(2); // Mark the upcoming blocks as seen now, but only error out if this block // was missing a merge instruction and both labels hadn't been seen // previously. const bool true_label_unseen = seen.insert(true_label).second; const bool false_label_unseen = seen.insert(false_label).second; if ((!merge || merge->opcode() == spv::Op::OpLoopMerge) && true_label_unseen && false_label_unseen) { return _.diag(SPV_ERROR_INVALID_CFG, terminator) << "Selection must be structured"; } } else if (terminator->opcode() == spv::Op::OpSwitch) { if (!merge) { return _.diag(SPV_ERROR_INVALID_CFG, terminator) << "OpSwitch must be preceded by an OpSelectionMerge " "instruction"; } // Mark the targets as seen. for (uint32_t i = 1; i < terminator->operands().size(); i += 2) { const auto target = terminator->GetOperandAs(i); seen.insert(target); } } } return SPV_SUCCESS; } spv_result_t StructuredControlFlowChecks( ValidationState_t& _, Function* function, const std::vector>& back_edges, const std::vector& postorder) { /// Check all backedges target only loop headers and have exactly one /// back-edge branching to it // Map a loop header to blocks with back-edges to the loop header. std::map> loop_latch_blocks; for (auto back_edge : back_edges) { uint32_t back_edge_block; uint32_t header_block; std::tie(back_edge_block, header_block) = back_edge; if (!function->IsBlockType(header_block, kBlockTypeLoop)) { return _.diag(SPV_ERROR_INVALID_CFG, _.FindDef(back_edge_block)) << "Back-edges (" << _.getIdName(back_edge_block) << " -> " << _.getIdName(header_block) << ") can only be formed between a block and a loop header."; } loop_latch_blocks[header_block].insert(back_edge_block); } // Check the loop headers have exactly one back-edge branching to it for (BasicBlock* loop_header : function->ordered_blocks()) { if (!loop_header->structurally_reachable()) continue; if (!loop_header->is_type(kBlockTypeLoop)) continue; auto loop_header_id = loop_header->id(); auto num_latch_blocks = loop_latch_blocks[loop_header_id].size(); if (num_latch_blocks != 1) { return _.diag(SPV_ERROR_INVALID_CFG, _.FindDef(loop_header_id)) << "Loop header " << _.getIdName(loop_header_id) << " is targeted by " << num_latch_blocks << " back-edge blocks but the standard requires exactly one"; } } // Check construct rules for (const Construct& construct : function->constructs()) { auto header = construct.entry_block(); if (!header->structurally_reachable()) continue; auto merge = construct.exit_block(); if (!merge) { std::string construct_name, header_name, exit_name; std::tie(construct_name, header_name, exit_name) = ConstructNames(construct.type()); return _.diag(SPV_ERROR_INTERNAL, _.FindDef(header->id())) << "Construct " + construct_name + " with " + header_name + " " + _.getIdName(header->id()) + " does not have a " + exit_name + ". This may be a bug in the validator."; } // If the header is reachable, the merge is guaranteed to be structurally // reachable. if (!header->structurally_dominates(*merge)) { return _.diag(SPV_ERROR_INVALID_CFG, _.FindDef(merge->id())) << ConstructErrorString(construct, _.getIdName(header->id()), _.getIdName(merge->id()), "does not structurally dominate"); } // If it's really a merge block for a selection or loop, then it must be // *strictly* structrually dominated by the header. if (construct.ExitBlockIsMergeBlock() && (header == merge)) { return _.diag(SPV_ERROR_INVALID_CFG, _.FindDef(merge->id())) << ConstructErrorString(construct, _.getIdName(header->id()), _.getIdName(merge->id()), "does not strictly structurally dominate"); } // Check post-dominance for continue constructs. But dominance and // post-dominance only make sense when the construct is reachable. if (construct.type() == ConstructType::kContinue) { if (!merge->structurally_postdominates(*header)) { return _.diag(SPV_ERROR_INVALID_CFG, _.FindDef(merge->id())) << ConstructErrorString(construct, _.getIdName(header->id()), _.getIdName(merge->id()), "is not structurally post dominated by"); } } Construct::ConstructBlockSet construct_blocks = construct.blocks(function); std::string construct_name, header_name, exit_name; std::tie(construct_name, header_name, exit_name) = ConstructNames(construct.type()); for (auto block : construct_blocks) { // Check that all exits from the construct are via structured exits. for (auto succ : *block->successors()) { if (!construct_blocks.count(succ) && !construct.IsStructuredExit(_, succ)) { return _.diag(SPV_ERROR_INVALID_CFG, _.FindDef(block->id())) << "block " << _.getIdName(block->id()) << " exits the " << construct_name << " headed by " << _.getIdName(header->id()) << ", but not via a structured exit"; } } if (block == header) continue; // Check that for all non-header blocks, all predecessors are within this // construct. for (auto pred : *block->predecessors()) { if (pred->structurally_reachable() && !construct_blocks.count(pred)) { return _.diag(SPV_ERROR_INVALID_CFG, _.FindDef(pred->id())) << "block " << pred->id() << " branches to the " << construct_name << " construct, but not to the " << header_name << " " << header->id(); } } if (block->is_type(BlockType::kBlockTypeSelection) || block->is_type(BlockType::kBlockTypeLoop)) { size_t index = (block->terminator() - &_.ordered_instructions()[0]) - 1; const auto& merge_inst = _.ordered_instructions()[index]; if (merge_inst.opcode() == spv::Op::OpSelectionMerge || merge_inst.opcode() == spv::Op::OpLoopMerge) { uint32_t merge_id = merge_inst.GetOperandAs(0); auto merge_block = function->GetBlock(merge_id).first; if (merge_block->structurally_reachable() && !construct_blocks.count(merge_block)) { return _.diag(SPV_ERROR_INVALID_CFG, _.FindDef(block->id())) << "Header block " << _.getIdName(block->id()) << " is contained in the " << construct_name << " construct headed by " << _.getIdName(header->id()) << ", but its merge block " << _.getIdName(merge_id) << " is not"; } } } } if (construct.type() == ConstructType::kLoop) { // If the continue target differs from the loop header, then check that // all edges into the continue construct come from within the loop. const auto index = header->terminator() - &_.ordered_instructions()[0]; const auto& merge_inst = _.ordered_instructions()[index - 1]; const auto continue_id = merge_inst.GetOperandAs(1); const auto* continue_inst = _.FindDef(continue_id); // OpLabel instructions aren't stored as part of the basic block for // legacy reaasons. Grab the next instruction and use it's block pointer // instead. const auto next_index = (continue_inst - &_.ordered_instructions()[0]) + 1; const auto& next_inst = _.ordered_instructions()[next_index]; const auto* continue_target = next_inst.block(); if (header->id() != continue_id) { for (auto pred : *continue_target->predecessors()) { if (!pred->structurally_reachable()) { continue; } // Ignore back-edges from within the continue construct. bool is_back_edge = false; for (auto back_edge : back_edges) { uint32_t back_edge_block; uint32_t header_block; std::tie(back_edge_block, header_block) = back_edge; if (header_block == continue_id && back_edge_block == pred->id()) is_back_edge = true; } if (!construct_blocks.count(pred) && !is_back_edge) { return _.diag(SPV_ERROR_INVALID_CFG, pred->terminator()) << "Block " << _.getIdName(pred->id()) << " branches to the loop continue target " << _.getIdName(continue_id) << ", but is not contained in the associated loop construct " << _.getIdName(header->id()); } } } } // Checks rules for case constructs. if (construct.type() == ConstructType::kSelection && header->terminator()->opcode() == spv::Op::OpSwitch) { if (auto error = StructuredSwitchChecks(_, function, construct)) { return error; } } } if (auto error = ValidateStructuredSelections(_, postorder)) { return error; } return SPV_SUCCESS; } spv_result_t MaximalReconvergenceChecks(ValidationState_t& _) { // Find all the entry points with the MaximallyReconvergencesKHR execution // mode. std::unordered_set maximal_funcs; std::unordered_set maximal_entry_points; for (auto entry_point : _.entry_points()) { const auto* exec_modes = _.GetExecutionModes(entry_point); if (exec_modes && exec_modes->count(spv::ExecutionMode::MaximallyReconvergesKHR)) { maximal_entry_points.insert(entry_point); maximal_funcs.insert(entry_point); } } if (maximal_entry_points.empty()) { return SPV_SUCCESS; } // Find all the functions reachable from a maximal reconvergence entry point. for (const auto& func : _.functions()) { const auto& entry_points = _.EntryPointReferences(func.id()); for (auto id : entry_points) { if (maximal_entry_points.count(id)) { maximal_funcs.insert(func.id()); break; } } } // Check for conditional branches with the same true and false targets. for (const auto& inst : _.ordered_instructions()) { if (inst.opcode() == spv::Op::OpBranchConditional) { const auto true_id = inst.GetOperandAs(1); const auto false_id = inst.GetOperandAs(2); if (true_id == false_id && maximal_funcs.count(inst.function()->id())) { return _.diag(SPV_ERROR_INVALID_ID, &inst) << "In entry points using the MaximallyReconvergesKHR execution " "mode, True Label and False Label must be different labels"; } } } // Check for invalid multiple predecessors. Only loop headers, continue // targets, merge targets or switch targets or defaults may have multiple // unique predecessors. for (const auto& func : _.functions()) { if (!maximal_funcs.count(func.id())) continue; for (const auto* block : func.ordered_blocks()) { std::unordered_set unique_preds; const auto* preds = block->predecessors(); if (!preds) continue; for (const auto* pred : *preds) { unique_preds.insert(pred->id()); } if (unique_preds.size() < 2) continue; const auto* terminator = block->terminator(); const auto index = terminator - &_.ordered_instructions()[0]; const auto* pre_terminator = &_.ordered_instructions()[index - 1]; if (pre_terminator->opcode() == spv::Op::OpLoopMerge) continue; const auto* label = _.FindDef(block->id()); bool ok = false; for (const auto& pair : label->uses()) { const auto* use_inst = pair.first; switch (use_inst->opcode()) { case spv::Op::OpSelectionMerge: case spv::Op::OpLoopMerge: case spv::Op::OpSwitch: ok = true; break; default: break; } } if (!ok) { return _.diag(SPV_ERROR_INVALID_CFG, label) << "In entry points using the MaximallyReconvergesKHR " "execution mode, this basic block must not have multiple " "unique predecessors"; } } } return SPV_SUCCESS; } spv_result_t PerformCfgChecks(ValidationState_t& _) { for (auto& function : _.functions()) { // Check all referenced blocks are defined within a function if (function.undefined_block_count() != 0) { std::string undef_blocks("{"); bool first = true; for (auto undefined_block : function.undefined_blocks()) { undef_blocks += _.getIdName(undefined_block); if (!first) { undef_blocks += " "; } first = false; } return _.diag(SPV_ERROR_INVALID_CFG, _.FindDef(function.id())) << "Block(s) " << undef_blocks << "}" << " are referenced but not defined in function " << _.getIdName(function.id()); } // Set each block's immediate dominator. // // We want to analyze all the blocks in the function, even in degenerate // control flow cases including unreachable blocks. So use the augmented // CFG to ensure we cover all the blocks. std::vector postorder; auto ignore_block = [](const BasicBlock*) {}; auto no_terminal_blocks = [](const BasicBlock*) { return false; }; if (!function.ordered_blocks().empty()) { /// calculate dominators CFA::DepthFirstTraversal( function.first_block(), function.AugmentedCFGSuccessorsFunction(), ignore_block, [&](const BasicBlock* b) { postorder.push_back(b); }, no_terminal_blocks); auto edges = CFA::CalculateDominators( postorder, function.AugmentedCFGPredecessorsFunction()); for (auto edge : edges) { if (edge.first != edge.second) edge.first->SetImmediateDominator(edge.second); } } auto& blocks = function.ordered_blocks(); if (!blocks.empty()) { // Check if the order of blocks in the binary appear before the blocks // they dominate for (auto block = begin(blocks) + 1; block != end(blocks); ++block) { if (auto idom = (*block)->immediate_dominator()) { if (idom != function.pseudo_entry_block() && block == std::find(begin(blocks), block, idom)) { return _.diag(SPV_ERROR_INVALID_CFG, _.FindDef(idom->id())) << "Block " << _.getIdName((*block)->id()) << " appears in the binary before its dominator " << _.getIdName(idom->id()); } } } // If we have structured control flow, check that no block has a control // flow nesting depth larger than the limit. if (_.HasCapability(spv::Capability::Shader)) { const int control_flow_nesting_depth_limit = _.options()->universal_limits_.max_control_flow_nesting_depth; for (auto block = begin(blocks); block != end(blocks); ++block) { if (function.GetBlockDepth(*block) > control_flow_nesting_depth_limit) { return _.diag(SPV_ERROR_INVALID_CFG, _.FindDef((*block)->id())) << "Maximum Control Flow nesting depth exceeded."; } } } } /// Structured control flow checks are only required for shader capabilities if (_.HasCapability(spv::Capability::Shader)) { // Calculate structural dominance. postorder.clear(); std::vector postdom_postorder; std::vector> back_edges; if (!function.ordered_blocks().empty()) { /// calculate dominators CFA::DepthFirstTraversal( function.first_block(), function.AugmentedStructuralCFGSuccessorsFunction(), ignore_block, [&](const BasicBlock* b) { postorder.push_back(b); }, no_terminal_blocks); auto edges = CFA::CalculateDominators( postorder, function.AugmentedStructuralCFGPredecessorsFunction()); for (auto edge : edges) { if (edge.first != edge.second) edge.first->SetImmediateStructuralDominator(edge.second); } /// calculate post dominators CFA::DepthFirstTraversal( function.pseudo_exit_block(), function.AugmentedStructuralCFGPredecessorsFunction(), ignore_block, [&](const BasicBlock* b) { postdom_postorder.push_back(b); }, no_terminal_blocks); auto postdom_edges = CFA::CalculateDominators( postdom_postorder, function.AugmentedStructuralCFGSuccessorsFunction()); for (auto edge : postdom_edges) { edge.first->SetImmediateStructuralPostDominator(edge.second); } /// calculate back edges. CFA::DepthFirstTraversal( function.pseudo_entry_block(), function.AugmentedStructuralCFGSuccessorsFunction(), ignore_block, ignore_block, [&](const BasicBlock* from, const BasicBlock* to) { // A back edge must be a real edge. Since the augmented successors // contain structural edges, filter those from consideration. for (const auto* succ : *(from->successors())) { if (succ == to) back_edges.emplace_back(from->id(), to->id()); } }, no_terminal_blocks); } UpdateContinueConstructExitBlocks(function, back_edges); if (auto error = StructuredControlFlowChecks(_, &function, back_edges, postorder)) return error; } } if (auto error = MaximalReconvergenceChecks(_)) { return error; } return SPV_SUCCESS; } spv_result_t CfgPass(ValidationState_t& _, const Instruction* inst) { spv::Op opcode = inst->opcode(); switch (opcode) { case spv::Op::OpLabel: if (auto error = _.current_function().RegisterBlock(inst->id())) return error; // TODO(github:1661) This should be done in the // ValidationState::RegisterInstruction method but because of the order of // passes the OpLabel ends up not being part of the basic block it starts. _.current_function().current_block()->set_label(inst); break; case spv::Op::OpLoopMerge: { uint32_t merge_block = inst->GetOperandAs(0); uint32_t continue_block = inst->GetOperandAs(1); CFG_ASSERT(MergeBlockAssert, merge_block); if (auto error = _.current_function().RegisterLoopMerge(merge_block, continue_block)) return error; } break; case spv::Op::OpSelectionMerge: { uint32_t merge_block = inst->GetOperandAs(0); CFG_ASSERT(MergeBlockAssert, merge_block); if (auto error = _.current_function().RegisterSelectionMerge(merge_block)) return error; } break; case spv::Op::OpBranch: { uint32_t target = inst->GetOperandAs(0); CFG_ASSERT(FirstBlockAssert, target); _.current_function().RegisterBlockEnd({target}); } break; case spv::Op::OpBranchConditional: { uint32_t tlabel = inst->GetOperandAs(1); uint32_t flabel = inst->GetOperandAs(2); CFG_ASSERT(FirstBlockAssert, tlabel); CFG_ASSERT(FirstBlockAssert, flabel); _.current_function().RegisterBlockEnd({tlabel, flabel}); } break; case spv::Op::OpSwitch: { std::vector cases; for (size_t i = 1; i < inst->operands().size(); i += 2) { uint32_t target = inst->GetOperandAs(i); CFG_ASSERT(FirstBlockAssert, target); cases.push_back(target); } _.current_function().RegisterBlockEnd({cases}); } break; case spv::Op::OpReturn: { const uint32_t return_type = _.current_function().GetResultTypeId(); const Instruction* return_type_inst = _.FindDef(return_type); assert(return_type_inst); if (return_type_inst->opcode() != spv::Op::OpTypeVoid) return _.diag(SPV_ERROR_INVALID_CFG, inst) << "OpReturn can only be called from a function with void " << "return type."; _.current_function().RegisterBlockEnd(std::vector()); break; } case spv::Op::OpKill: case spv::Op::OpReturnValue: case spv::Op::OpUnreachable: case spv::Op::OpTerminateInvocation: case spv::Op::OpIgnoreIntersectionKHR: case spv::Op::OpTerminateRayKHR: case spv::Op::OpEmitMeshTasksEXT: _.current_function().RegisterBlockEnd(std::vector()); // Ops with dedicated passes check for the Execution Model there if (opcode == spv::Op::OpKill) { _.current_function().RegisterExecutionModelLimitation( spv::ExecutionModel::Fragment, "OpKill requires Fragment execution model"); } if (opcode == spv::Op::OpTerminateInvocation) { _.current_function().RegisterExecutionModelLimitation( spv::ExecutionModel::Fragment, "OpTerminateInvocation requires Fragment execution model"); } if (opcode == spv::Op::OpIgnoreIntersectionKHR) { _.current_function().RegisterExecutionModelLimitation( spv::ExecutionModel::AnyHitKHR, "OpIgnoreIntersectionKHR requires AnyHitKHR execution model"); } if (opcode == spv::Op::OpTerminateRayKHR) { _.current_function().RegisterExecutionModelLimitation( spv::ExecutionModel::AnyHitKHR, "OpTerminateRayKHR requires AnyHitKHR execution model"); } break; default: break; } return SPV_SUCCESS; } void ReachabilityPass(ValidationState_t& _) { for (auto& f : _.functions()) { std::vector stack; auto entry = f.first_block(); // Skip function declarations. if (entry) stack.push_back(entry); while (!stack.empty()) { auto block = stack.back(); stack.pop_back(); if (block->reachable()) continue; block->set_reachable(true); for (auto succ : *block->successors()) { stack.push_back(succ); } } } // Repeat for structural reachability. for (auto& f : _.functions()) { std::vector stack; auto entry = f.first_block(); // Skip function declarations. if (entry) stack.push_back(entry); while (!stack.empty()) { auto block = stack.back(); stack.pop_back(); if (block->structurally_reachable()) continue; block->set_structurally_reachable(true); for (auto succ : *block->structural_successors()) { stack.push_back(succ); } } } } spv_result_t ControlFlowPass(ValidationState_t& _, const Instruction* inst) { switch (inst->opcode()) { case spv::Op::OpPhi: if (auto error = ValidatePhi(_, inst)) return error; break; case spv::Op::OpBranch: if (auto error = ValidateBranch(_, inst)) return error; break; case spv::Op::OpBranchConditional: if (auto error = ValidateBranchConditional(_, inst)) return error; break; case spv::Op::OpReturnValue: if (auto error = ValidateReturnValue(_, inst)) return error; break; case spv::Op::OpSwitch: if (auto error = ValidateSwitch(_, inst)) return error; break; case spv::Op::OpLoopMerge: if (auto error = ValidateLoopMerge(_, inst)) return error; break; default: break; } return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_composites.cpp000066400000000000000000000613071475742701700253640ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // Modifications Copyright (C) 2024 Advanced Micro Devices, Inc. All rights // reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validates correctness of composite SPIR-V instructions. #include "source/opcode.h" #include "source/spirv_target_env.h" #include "source/val/instruction.h" #include "source/val/validate.h" #include "source/val/validation_state.h" namespace spvtools { namespace val { namespace { // Returns the type of the value accessed by OpCompositeExtract or // OpCompositeInsert instruction. The function traverses the hierarchy of // nested data structures (structs, arrays, vectors, matrices) as directed by // the sequence of indices in the instruction. May return error if traversal // fails (encountered non-composite, out of bounds, no indices, nesting too // deep). spv_result_t GetExtractInsertValueType(ValidationState_t& _, const Instruction* inst, uint32_t* member_type) { const spv::Op opcode = inst->opcode(); assert(opcode == spv::Op::OpCompositeExtract || opcode == spv::Op::OpCompositeInsert); uint32_t word_index = opcode == spv::Op::OpCompositeExtract ? 4 : 5; const uint32_t num_words = static_cast(inst->words().size()); const uint32_t composite_id_index = word_index - 1; const uint32_t num_indices = num_words - word_index; const uint32_t kCompositeExtractInsertMaxNumIndices = 255; if (num_indices == 0) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected at least one index to Op" << spvOpcodeString(inst->opcode()) << ", zero found"; } else if (num_indices > kCompositeExtractInsertMaxNumIndices) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "The number of indexes in Op" << spvOpcodeString(opcode) << " may not exceed " << kCompositeExtractInsertMaxNumIndices << ". Found " << num_indices << " indexes."; } *member_type = _.GetTypeId(inst->word(composite_id_index)); if (*member_type == 0) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Composite to be an object of composite type"; } for (; word_index < num_words; ++word_index) { const uint32_t component_index = inst->word(word_index); const Instruction* const type_inst = _.FindDef(*member_type); assert(type_inst); switch (type_inst->opcode()) { case spv::Op::OpTypeVector: { *member_type = type_inst->word(2); const uint32_t vector_size = type_inst->word(3); if (component_index >= vector_size) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Vector access is out of bounds, vector size is " << vector_size << ", but access index is " << component_index; } break; } case spv::Op::OpTypeMatrix: { *member_type = type_inst->word(2); const uint32_t num_cols = type_inst->word(3); if (component_index >= num_cols) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Matrix access is out of bounds, matrix has " << num_cols << " columns, but access index is " << component_index; } break; } case spv::Op::OpTypeArray: { uint64_t array_size = 0; auto size = _.FindDef(type_inst->word(3)); *member_type = type_inst->word(2); if (spvOpcodeIsSpecConstant(size->opcode())) { // Cannot verify against the size of this array. break; } if (!_.EvalConstantValUint64(type_inst->word(3), &array_size)) { assert(0 && "Array type definition is corrupt"); } if (component_index >= array_size) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Array access is out of bounds, array size is " << array_size << ", but access index is " << component_index; } break; } case spv::Op::OpTypeRuntimeArray: case spv::Op::OpTypeNodePayloadArrayAMDX: { *member_type = type_inst->word(2); // Array size is unknown. break; } case spv::Op::OpTypeStruct: { const size_t num_struct_members = type_inst->words().size() - 2; if (component_index >= num_struct_members) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Index is out of bounds, can not find index " << component_index << " in the structure '" << type_inst->id() << "'. This structure has " << num_struct_members << " members. Largest valid index is " << num_struct_members - 1 << "."; } *member_type = type_inst->word(component_index + 2); break; } case spv::Op::OpTypeCooperativeVectorNV: case spv::Op::OpTypeCooperativeMatrixKHR: case spv::Op::OpTypeCooperativeMatrixNV: { *member_type = type_inst->word(2); break; } default: return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Reached non-composite type while indexes still remain to " "be traversed."; } } return SPV_SUCCESS; } spv_result_t ValidateVectorExtractDynamic(ValidationState_t& _, const Instruction* inst) { const uint32_t result_type = inst->type_id(); const spv::Op result_opcode = _.GetIdOpcode(result_type); if (!spvOpcodeIsScalarType(result_opcode)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Result Type to be a scalar type"; } const uint32_t vector_type = _.GetOperandTypeId(inst, 2); const spv::Op vector_opcode = _.GetIdOpcode(vector_type); if (vector_opcode != spv::Op::OpTypeVector && vector_opcode != spv::Op::OpTypeCooperativeVectorNV) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Vector type to be OpTypeVector"; } if (_.GetComponentType(vector_type) != result_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Vector component type to be equal to Result Type"; } const auto index = _.FindDef(inst->GetOperandAs(3)); if (!index || index->type_id() == 0 || !_.IsIntScalarType(index->type_id())) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Index to be int scalar"; } if (_.HasCapability(spv::Capability::Shader) && _.ContainsLimitedUseIntOrFloatType(inst->type_id())) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Cannot extract from a vector of 8- or 16-bit types"; } return SPV_SUCCESS; } spv_result_t ValidateVectorInsertDyanmic(ValidationState_t& _, const Instruction* inst) { const uint32_t result_type = inst->type_id(); const spv::Op result_opcode = _.GetIdOpcode(result_type); if (result_opcode != spv::Op::OpTypeVector && result_opcode != spv::Op::OpTypeCooperativeVectorNV) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Result Type to be OpTypeVector"; } const uint32_t vector_type = _.GetOperandTypeId(inst, 2); if (vector_type != result_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Vector type to be equal to Result Type"; } const uint32_t component_type = _.GetOperandTypeId(inst, 3); if (_.GetComponentType(result_type) != component_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Component type to be equal to Result Type " << "component type"; } const uint32_t index_type = _.GetOperandTypeId(inst, 4); if (!_.IsIntScalarType(index_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Index to be int scalar"; } if (_.HasCapability(spv::Capability::Shader) && _.ContainsLimitedUseIntOrFloatType(inst->type_id())) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Cannot insert into a vector of 8- or 16-bit types"; } return SPV_SUCCESS; } spv_result_t ValidateCompositeConstruct(ValidationState_t& _, const Instruction* inst) { const uint32_t num_operands = static_cast(inst->operands().size()); const uint32_t result_type = inst->type_id(); const spv::Op result_opcode = _.GetIdOpcode(result_type); switch (result_opcode) { case spv::Op::OpTypeVector: case spv::Op::OpTypeCooperativeVectorNV: { uint32_t num_result_components = _.GetDimension(result_type); const uint32_t result_component_type = _.GetComponentType(result_type); uint32_t given_component_count = 0; bool comp_is_int32 = true, comp_is_const_int32 = true; if (result_opcode == spv::Op::OpTypeVector) { if (num_operands <= 3) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected number of constituents to be at least 2"; } } else { uint32_t comp_count_id = _.FindDef(result_type)->GetOperandAs(2); std::tie(comp_is_int32, comp_is_const_int32, num_result_components) = _.EvalInt32IfConst(comp_count_id); } for (uint32_t operand_index = 2; operand_index < num_operands; ++operand_index) { const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index); if (operand_type == result_component_type) { ++given_component_count; } else { if (_.GetIdOpcode(operand_type) != spv::Op::OpTypeVector || _.GetComponentType(operand_type) != result_component_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Constituents to be scalars or vectors of" << " the same type as Result Type components"; } given_component_count += _.GetDimension(operand_type); } } if (comp_is_const_int32 && num_result_components != given_component_count) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected total number of given components to be equal " << "to the size of Result Type vector"; } break; } case spv::Op::OpTypeMatrix: { uint32_t result_num_rows = 0; uint32_t result_num_cols = 0; uint32_t result_col_type = 0; uint32_t result_component_type = 0; if (!_.GetMatrixTypeInfo(result_type, &result_num_rows, &result_num_cols, &result_col_type, &result_component_type)) { assert(0); } if (result_num_cols + 2 != num_operands) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected total number of Constituents to be equal " << "to the number of columns of Result Type matrix"; } for (uint32_t operand_index = 2; operand_index < num_operands; ++operand_index) { const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index); if (operand_type != result_col_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Constituent type to be equal to the column " << "type Result Type matrix"; } } break; } case spv::Op::OpTypeArray: { const Instruction* const array_inst = _.FindDef(result_type); assert(array_inst); assert(array_inst->opcode() == spv::Op::OpTypeArray); auto size = _.FindDef(array_inst->word(3)); if (spvOpcodeIsSpecConstant(size->opcode())) { // Cannot verify against the size of this array. break; } uint64_t array_size = 0; if (!_.EvalConstantValUint64(array_inst->word(3), &array_size)) { assert(0 && "Array type definition is corrupt"); } if (array_size + 2 != num_operands) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected total number of Constituents to be equal " << "to the number of elements of Result Type array"; } const uint32_t result_component_type = array_inst->word(2); for (uint32_t operand_index = 2; operand_index < num_operands; ++operand_index) { const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index); if (operand_type != result_component_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Constituent type to be equal to the column " << "type Result Type array"; } } break; } case spv::Op::OpTypeStruct: { const Instruction* const struct_inst = _.FindDef(result_type); assert(struct_inst); assert(struct_inst->opcode() == spv::Op::OpTypeStruct); if (struct_inst->operands().size() + 1 != num_operands) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected total number of Constituents to be equal " << "to the number of members of Result Type struct"; } for (uint32_t operand_index = 2; operand_index < num_operands; ++operand_index) { const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index); const uint32_t member_type = struct_inst->word(operand_index); if (operand_type != member_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Constituent type to be equal to the " << "corresponding member type of Result Type struct"; } } break; } case spv::Op::OpTypeCooperativeMatrixKHR: { const auto result_type_inst = _.FindDef(result_type); assert(result_type_inst); const auto component_type_id = result_type_inst->GetOperandAs(1); if (3 != num_operands) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Must be only one constituent"; } const uint32_t operand_type_id = _.GetOperandTypeId(inst, 2); if (operand_type_id != component_type_id) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Constituent type to be equal to the component type"; } break; } case spv::Op::OpTypeCooperativeMatrixNV: { const auto result_type_inst = _.FindDef(result_type); assert(result_type_inst); const auto component_type_id = result_type_inst->GetOperandAs(1); if (3 != num_operands) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected single constituent"; } const uint32_t operand_type_id = _.GetOperandTypeId(inst, 2); if (operand_type_id != component_type_id) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Constituent type to be equal to the component type"; } break; } default: { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Result Type to be a composite type"; } } if (_.HasCapability(spv::Capability::Shader) && _.ContainsLimitedUseIntOrFloatType(inst->type_id())) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Cannot create a composite containing 8- or 16-bit types"; } return SPV_SUCCESS; } spv_result_t ValidateCompositeExtract(ValidationState_t& _, const Instruction* inst) { uint32_t member_type = 0; if (spv_result_t error = GetExtractInsertValueType(_, inst, &member_type)) { return error; } const uint32_t result_type = inst->type_id(); if (result_type != member_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Result type (Op" << spvOpcodeString(_.GetIdOpcode(result_type)) << ") does not match the type that results from indexing into " "the composite (Op" << spvOpcodeString(_.GetIdOpcode(member_type)) << ")."; } if (_.HasCapability(spv::Capability::Shader) && _.ContainsLimitedUseIntOrFloatType(inst->type_id())) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Cannot extract from a composite of 8- or 16-bit types"; } return SPV_SUCCESS; } spv_result_t ValidateCompositeInsert(ValidationState_t& _, const Instruction* inst) { const uint32_t object_type = _.GetOperandTypeId(inst, 2); const uint32_t composite_type = _.GetOperandTypeId(inst, 3); const uint32_t result_type = inst->type_id(); if (result_type != composite_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "The Result Type must be the same as Composite type in Op" << spvOpcodeString(inst->opcode()) << " yielding Result Id " << result_type << "."; } uint32_t member_type = 0; if (spv_result_t error = GetExtractInsertValueType(_, inst, &member_type)) { return error; } if (object_type != member_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "The Object type (Op" << spvOpcodeString(_.GetIdOpcode(object_type)) << ") does not match the type that results from indexing into the " "Composite (Op" << spvOpcodeString(_.GetIdOpcode(member_type)) << ")."; } if (_.HasCapability(spv::Capability::Shader) && _.ContainsLimitedUseIntOrFloatType(inst->type_id())) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Cannot insert into a composite of 8- or 16-bit types"; } return SPV_SUCCESS; } spv_result_t ValidateCopyObject(ValidationState_t& _, const Instruction* inst) { const uint32_t result_type = inst->type_id(); const uint32_t operand_type = _.GetOperandTypeId(inst, 2); if (operand_type != result_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Result Type and Operand type to be the same"; } if (_.IsVoidType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "OpCopyObject cannot have void result type"; } return SPV_SUCCESS; } spv_result_t ValidateTranspose(ValidationState_t& _, const Instruction* inst) { uint32_t result_num_rows = 0; uint32_t result_num_cols = 0; uint32_t result_col_type = 0; uint32_t result_component_type = 0; const uint32_t result_type = inst->type_id(); if (!_.GetMatrixTypeInfo(result_type, &result_num_rows, &result_num_cols, &result_col_type, &result_component_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Result Type to be a matrix type"; } const uint32_t matrix_type = _.GetOperandTypeId(inst, 2); uint32_t matrix_num_rows = 0; uint32_t matrix_num_cols = 0; uint32_t matrix_col_type = 0; uint32_t matrix_component_type = 0; if (!_.GetMatrixTypeInfo(matrix_type, &matrix_num_rows, &matrix_num_cols, &matrix_col_type, &matrix_component_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Matrix to be of type OpTypeMatrix"; } if (result_component_type != matrix_component_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected component types of Matrix and Result Type to be " << "identical"; } if (result_num_rows != matrix_num_cols || result_num_cols != matrix_num_rows) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected number of columns and the column size of Matrix " << "to be the reverse of those of Result Type"; } if (_.HasCapability(spv::Capability::Shader) && _.ContainsLimitedUseIntOrFloatType(inst->type_id())) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Cannot transpose matrices of 16-bit floats"; } return SPV_SUCCESS; } spv_result_t ValidateVectorShuffle(ValidationState_t& _, const Instruction* inst) { auto resultType = _.FindDef(inst->type_id()); if (!resultType || resultType->opcode() != spv::Op::OpTypeVector) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "The Result Type of OpVectorShuffle must be" << " OpTypeVector. Found Op" << spvOpcodeString(static_cast(resultType->opcode())) << "."; } // The number of components in Result Type must be the same as the number of // Component operands. auto componentCount = inst->operands().size() - 4; auto resultVectorDimension = resultType->GetOperandAs(2); if (componentCount != resultVectorDimension) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpVectorShuffle component literals count does not match " "Result Type " << _.getIdName(resultType->id()) << "s vector component count."; } // Vector 1 and Vector 2 must both have vector types, with the same Component // Type as Result Type. auto vector1Object = _.FindDef(inst->GetOperandAs(2)); auto vector1Type = _.FindDef(vector1Object->type_id()); auto vector2Object = _.FindDef(inst->GetOperandAs(3)); auto vector2Type = _.FindDef(vector2Object->type_id()); if (!vector1Type || vector1Type->opcode() != spv::Op::OpTypeVector) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "The type of Vector 1 must be OpTypeVector."; } if (!vector2Type || vector2Type->opcode() != spv::Op::OpTypeVector) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "The type of Vector 2 must be OpTypeVector."; } auto resultComponentType = resultType->GetOperandAs(1); if (vector1Type->GetOperandAs(1) != resultComponentType) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "The Component Type of Vector 1 must be the same as ResultType."; } if (vector2Type->GetOperandAs(1) != resultComponentType) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "The Component Type of Vector 2 must be the same as ResultType."; } // All Component literals must either be FFFFFFFF or in [0, N - 1]. auto vector1ComponentCount = vector1Type->GetOperandAs(2); auto vector2ComponentCount = vector2Type->GetOperandAs(2); auto N = vector1ComponentCount + vector2ComponentCount; auto firstLiteralIndex = 4; for (size_t i = firstLiteralIndex; i < inst->operands().size(); ++i) { auto literal = inst->GetOperandAs(i); if (literal != 0xFFFFFFFF && literal >= N) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Component index " << literal << " is out of bounds for " << "combined (Vector1 + Vector2) size of " << N << "."; } } if (_.HasCapability(spv::Capability::Shader) && _.ContainsLimitedUseIntOrFloatType(inst->type_id())) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Cannot shuffle a vector of 8- or 16-bit types"; } return SPV_SUCCESS; } spv_result_t ValidateCopyLogical(ValidationState_t& _, const Instruction* inst) { const auto result_type = _.FindDef(inst->type_id()); const auto source = _.FindDef(inst->GetOperandAs(2u)); const auto source_type = _.FindDef(source->type_id()); if (!source_type || !result_type || source_type == result_type) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Result Type must not equal the Operand type"; } if (!_.LogicallyMatch(source_type, result_type, false)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Result Type does not logically match the Operand type"; } if (_.HasCapability(spv::Capability::Shader) && _.ContainsLimitedUseIntOrFloatType(inst->type_id())) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Cannot copy composites of 8- or 16-bit types"; } return SPV_SUCCESS; } } // anonymous namespace // Validates correctness of composite instructions. spv_result_t CompositesPass(ValidationState_t& _, const Instruction* inst) { switch (inst->opcode()) { case spv::Op::OpVectorExtractDynamic: return ValidateVectorExtractDynamic(_, inst); case spv::Op::OpVectorInsertDynamic: return ValidateVectorInsertDyanmic(_, inst); case spv::Op::OpVectorShuffle: return ValidateVectorShuffle(_, inst); case spv::Op::OpCompositeConstruct: return ValidateCompositeConstruct(_, inst); case spv::Op::OpCompositeExtract: return ValidateCompositeExtract(_, inst); case spv::Op::OpCompositeInsert: return ValidateCompositeInsert(_, inst); case spv::Op::OpCopyObject: return ValidateCopyObject(_, inst); case spv::Op::OpTranspose: return ValidateTranspose(_, inst); case spv::Op::OpCopyLogical: return ValidateCopyLogical(_, inst); default: break; } return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_constants.cpp000066400000000000000000000461121475742701700252100ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opcode.h" #include "source/val/instruction.h" #include "source/val/validate.h" #include "source/val/validation_state.h" namespace spvtools { namespace val { namespace { spv_result_t ValidateConstantBool(ValidationState_t& _, const Instruction* inst) { auto type = _.FindDef(inst->type_id()); if (!type || type->opcode() != spv::Op::OpTypeBool) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Op" << spvOpcodeString(inst->opcode()) << " Result Type " << _.getIdName(inst->type_id()) << " is not a boolean type."; } return SPV_SUCCESS; } spv_result_t ValidateConstantComposite(ValidationState_t& _, const Instruction* inst) { std::string opcode_name = std::string("Op") + spvOpcodeString(inst->opcode()); const auto result_type = _.FindDef(inst->type_id()); if (!result_type || !spvOpcodeIsComposite(result_type->opcode())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opcode_name << " Result Type " << _.getIdName(inst->type_id()) << " is not a composite type."; } const auto constituent_count = inst->words().size() - 3; switch (result_type->opcode()) { case spv::Op::OpTypeVector: case spv::Op::OpTypeCooperativeVectorNV: { uint32_t num_result_components = _.GetDimension(result_type->id()); bool comp_is_int32 = true, comp_is_const_int32 = true; if (result_type->opcode() == spv::Op::OpTypeCooperativeVectorNV) { uint32_t comp_count_id = result_type->GetOperandAs(2); std::tie(comp_is_int32, comp_is_const_int32, num_result_components) = _.EvalInt32IfConst(comp_count_id); } if (comp_is_const_int32 && num_result_components != constituent_count) { // TODO: Output ID's on diagnostic return _.diag(SPV_ERROR_INVALID_ID, inst) << opcode_name << " Constituent count does not match " "Result Type " << _.getIdName(result_type->id()) << "s vector component count."; } const auto component_type = _.FindDef(result_type->GetOperandAs(1)); if (!component_type) { return _.diag(SPV_ERROR_INVALID_ID, result_type) << "Component type is not defined."; } for (size_t constituent_index = 2; constituent_index < inst->operands().size(); constituent_index++) { const auto constituent_id = inst->GetOperandAs(constituent_index); const auto constituent = _.FindDef(constituent_id); if (!constituent || !spvOpcodeIsConstantOrUndef(constituent->opcode())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opcode_name << " Constituent " << _.getIdName(constituent_id) << " is not a constant or undef."; } const auto constituent_result_type = _.FindDef(constituent->type_id()); if (!constituent_result_type || component_type->id() != constituent_result_type->id()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opcode_name << " Constituent " << _.getIdName(constituent_id) << "s type does not match Result Type " << _.getIdName(result_type->id()) << "s vector element type."; } } } break; case spv::Op::OpTypeMatrix: { const auto column_count = result_type->GetOperandAs(2); if (column_count != constituent_count) { // TODO: Output ID's on diagnostic return _.diag(SPV_ERROR_INVALID_ID, inst) << opcode_name << " Constituent count does not match " "Result Type " << _.getIdName(result_type->id()) << "s matrix column count."; } const auto column_type = _.FindDef(result_type->words()[2]); if (!column_type) { return _.diag(SPV_ERROR_INVALID_ID, result_type) << "Column type is not defined."; } const auto component_count = column_type->GetOperandAs(2); const auto component_type = _.FindDef(column_type->GetOperandAs(1)); if (!component_type) { return _.diag(SPV_ERROR_INVALID_ID, column_type) << "Component type is not defined."; } for (size_t constituent_index = 2; constituent_index < inst->operands().size(); constituent_index++) { const auto constituent_id = inst->GetOperandAs(constituent_index); const auto constituent = _.FindDef(constituent_id); if (!constituent || !spvOpcodeIsConstantOrUndef(constituent->opcode())) { // The message says "... or undef" because the spec does not say // undef is a constant. return _.diag(SPV_ERROR_INVALID_ID, inst) << opcode_name << " Constituent " << _.getIdName(constituent_id) << " is not a constant or undef."; } const auto vector = _.FindDef(constituent->type_id()); if (!vector) { return _.diag(SPV_ERROR_INVALID_ID, constituent) << "Result type is not defined."; } if (column_type->opcode() != vector->opcode()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opcode_name << " Constituent " << _.getIdName(constituent_id) << " type does not match Result Type " << _.getIdName(result_type->id()) << "s matrix column type."; } const auto vector_component_type = _.FindDef(vector->GetOperandAs(1)); if (component_type->id() != vector_component_type->id()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opcode_name << " Constituent " << _.getIdName(constituent_id) << " component type does not match Result Type " << _.getIdName(result_type->id()) << "s matrix column component type."; } if (component_count != vector->words()[3]) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opcode_name << " Constituent " << _.getIdName(constituent_id) << " vector component count does not match Result Type " << _.getIdName(result_type->id()) << "s vector component count."; } } } break; case spv::Op::OpTypeArray: { auto element_type = _.FindDef(result_type->GetOperandAs(1)); if (!element_type) { return _.diag(SPV_ERROR_INVALID_ID, result_type) << "Element type is not defined."; } const auto length = _.FindDef(result_type->GetOperandAs(2)); if (!length) { return _.diag(SPV_ERROR_INVALID_ID, result_type) << "Length is not defined."; } bool is_int32; bool is_const; uint32_t value; std::tie(is_int32, is_const, value) = _.EvalInt32IfConst(length->id()); if (is_int32 && is_const && value != constituent_count) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opcode_name << " Constituent count does not match " "Result Type " << _.getIdName(result_type->id()) << "s array length."; } for (size_t constituent_index = 2; constituent_index < inst->operands().size(); constituent_index++) { const auto constituent_id = inst->GetOperandAs(constituent_index); const auto constituent = _.FindDef(constituent_id); if (!constituent || !spvOpcodeIsConstantOrUndef(constituent->opcode())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opcode_name << " Constituent " << _.getIdName(constituent_id) << " is not a constant or undef."; } const auto constituent_type = _.FindDef(constituent->type_id()); if (!constituent_type) { return _.diag(SPV_ERROR_INVALID_ID, constituent) << "Result type is not defined."; } if (element_type->id() != constituent_type->id()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opcode_name << " Constituent " << _.getIdName(constituent_id) << "s type does not match Result Type " << _.getIdName(result_type->id()) << "s array element type."; } } } break; case spv::Op::OpTypeStruct: { const auto member_count = result_type->words().size() - 2; if (member_count != constituent_count) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opcode_name << " Constituent " << _.getIdName(inst->type_id()) << " count does not match Result Type " << _.getIdName(result_type->id()) << "s struct member count."; } for (uint32_t constituent_index = 2, member_index = 1; constituent_index < inst->operands().size(); constituent_index++, member_index++) { const auto constituent_id = inst->GetOperandAs(constituent_index); const auto constituent = _.FindDef(constituent_id); if (!constituent || !spvOpcodeIsConstantOrUndef(constituent->opcode())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opcode_name << " Constituent " << _.getIdName(constituent_id) << " is not a constant or undef."; } const auto constituent_type = _.FindDef(constituent->type_id()); if (!constituent_type) { return _.diag(SPV_ERROR_INVALID_ID, constituent) << "Result type is not defined."; } const auto member_type_id = result_type->GetOperandAs(member_index); const auto member_type = _.FindDef(member_type_id); if (!member_type || member_type->id() != constituent_type->id()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opcode_name << " Constituent " << _.getIdName(constituent_id) << " type does not match the Result Type " << _.getIdName(result_type->id()) << "s member type."; } } } break; case spv::Op::OpTypeCooperativeMatrixKHR: case spv::Op::OpTypeCooperativeMatrixNV: { if (1 != constituent_count) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opcode_name << " Constituent " << _.getIdName(inst->type_id()) << " count must be one."; } const auto constituent_id = inst->GetOperandAs(2); const auto constituent = _.FindDef(constituent_id); if (!constituent || !spvOpcodeIsConstantOrUndef(constituent->opcode())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opcode_name << " Constituent " << _.getIdName(constituent_id) << " is not a constant or undef."; } const auto constituent_type = _.FindDef(constituent->type_id()); if (!constituent_type) { return _.diag(SPV_ERROR_INVALID_ID, constituent) << "Result type is not defined."; } const auto component_type_id = result_type->GetOperandAs(1); const auto component_type = _.FindDef(component_type_id); if (!component_type || component_type->id() != constituent_type->id()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opcode_name << " Constituent " << _.getIdName(constituent_id) << " type does not match the Result Type " << _.getIdName(result_type->id()) << "s component type."; } } break; default: break; } return SPV_SUCCESS; } spv_result_t ValidateConstantSampler(ValidationState_t& _, const Instruction* inst) { const auto result_type = _.FindDef(inst->type_id()); if (!result_type || result_type->opcode() != spv::Op::OpTypeSampler) { return _.diag(SPV_ERROR_INVALID_ID, result_type) << "OpConstantSampler Result Type " << _.getIdName(inst->type_id()) << " is not a sampler type."; } return SPV_SUCCESS; } // True if instruction defines a type that can have a null value, as defined by // the SPIR-V spec. Tracks composite-type components through module to check // nullability transitively. bool IsTypeNullable(const std::vector& instruction, const ValidationState_t& _) { uint16_t opcode; uint16_t word_count; spvOpcodeSplit(instruction[0], &word_count, &opcode); switch (static_cast(opcode)) { case spv::Op::OpTypeBool: case spv::Op::OpTypeInt: case spv::Op::OpTypeFloat: case spv::Op::OpTypeEvent: case spv::Op::OpTypeDeviceEvent: case spv::Op::OpTypeReserveId: case spv::Op::OpTypeQueue: return true; case spv::Op::OpTypeArray: case spv::Op::OpTypeMatrix: case spv::Op::OpTypeCooperativeMatrixNV: case spv::Op::OpTypeCooperativeMatrixKHR: case spv::Op::OpTypeCooperativeVectorNV: case spv::Op::OpTypeVector: { auto base_type = _.FindDef(instruction[2]); return base_type && IsTypeNullable(base_type->words(), _); } case spv::Op::OpTypeStruct: { for (size_t elementIndex = 2; elementIndex < instruction.size(); ++elementIndex) { auto element = _.FindDef(instruction[elementIndex]); if (!element || !IsTypeNullable(element->words(), _)) return false; } return true; } case spv::Op::OpTypeUntypedPointerKHR: case spv::Op::OpTypePointer: if (spv::StorageClass(instruction[2]) == spv::StorageClass::PhysicalStorageBuffer) { return false; } return true; default: return false; } } spv_result_t ValidateConstantNull(ValidationState_t& _, const Instruction* inst) { const auto result_type = _.FindDef(inst->type_id()); if (!result_type || !IsTypeNullable(result_type->words(), _)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpConstantNull Result Type " << _.getIdName(inst->type_id()) << " cannot have a null value."; } return SPV_SUCCESS; } // Validates that OpSpecConstant specializes to either int or float type. spv_result_t ValidateSpecConstant(ValidationState_t& _, const Instruction* inst) { // Operand 0 is the of the type that we're specializing to. auto type_id = inst->GetOperandAs(0); auto type_instruction = _.FindDef(type_id); auto type_opcode = type_instruction->opcode(); if (type_opcode != spv::Op::OpTypeInt && type_opcode != spv::Op::OpTypeFloat) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Specialization constant " "must be an integer or " "floating-point number."; } return SPV_SUCCESS; } spv_result_t ValidateSpecConstantOp(ValidationState_t& _, const Instruction* inst) { const auto op = inst->GetOperandAs(2); // The binary parser already ensures that the op is valid for *some* // environment. Here we check restrictions. switch (op) { case spv::Op::OpQuantizeToF16: if (!_.HasCapability(spv::Capability::Shader)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Specialization constant operation " << spvOpcodeString(op) << " requires Shader capability"; } break; case spv::Op::OpUConvert: if (!_.features().uconvert_spec_constant_op && !_.HasCapability(spv::Capability::Kernel)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Prior to SPIR-V 1.4, specialization constant operation " "UConvert requires Kernel capability or extension " "SPV_AMD_gpu_shader_int16"; } break; case spv::Op::OpConvertFToS: case spv::Op::OpConvertSToF: case spv::Op::OpConvertFToU: case spv::Op::OpConvertUToF: case spv::Op::OpConvertPtrToU: case spv::Op::OpConvertUToPtr: case spv::Op::OpGenericCastToPtr: case spv::Op::OpPtrCastToGeneric: case spv::Op::OpBitcast: case spv::Op::OpFNegate: case spv::Op::OpFAdd: case spv::Op::OpFSub: case spv::Op::OpFMul: case spv::Op::OpFDiv: case spv::Op::OpFRem: case spv::Op::OpFMod: case spv::Op::OpAccessChain: case spv::Op::OpInBoundsAccessChain: case spv::Op::OpPtrAccessChain: case spv::Op::OpInBoundsPtrAccessChain: if (!_.HasCapability(spv::Capability::Kernel)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Specialization constant operation " << spvOpcodeString(op) << " requires Kernel capability"; } break; default: break; } // TODO(dneto): Validate result type and arguments to the various operations. return SPV_SUCCESS; } } // namespace spv_result_t ConstantPass(ValidationState_t& _, const Instruction* inst) { switch (inst->opcode()) { case spv::Op::OpConstantTrue: case spv::Op::OpConstantFalse: case spv::Op::OpSpecConstantTrue: case spv::Op::OpSpecConstantFalse: if (auto error = ValidateConstantBool(_, inst)) return error; break; case spv::Op::OpConstantComposite: case spv::Op::OpSpecConstantComposite: if (auto error = ValidateConstantComposite(_, inst)) return error; break; case spv::Op::OpConstantSampler: if (auto error = ValidateConstantSampler(_, inst)) return error; break; case spv::Op::OpConstantNull: if (auto error = ValidateConstantNull(_, inst)) return error; break; case spv::Op::OpSpecConstant: if (auto error = ValidateSpecConstant(_, inst)) return error; break; case spv::Op::OpSpecConstantOp: if (auto error = ValidateSpecConstantOp(_, inst)) return error; break; default: break; } // Generally disallow creating 8- or 16-bit constants unless the full // capabilities are present. if (spvOpcodeIsConstant(inst->opcode()) && _.HasCapability(spv::Capability::Shader) && !_.IsPointerType(inst->type_id()) && _.ContainsLimitedUseIntOrFloatType(inst->type_id())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Cannot form constants of 8- or 16-bit types"; } return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_conversion.cpp000066400000000000000000000730771475742701700253730ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validates correctness of conversion instructions. #include "source/opcode.h" #include "source/spirv_constant.h" #include "source/spirv_target_env.h" #include "source/val/instruction.h" #include "source/val/validate.h" #include "source/val/validation_state.h" namespace spvtools { namespace val { // Validates correctness of conversion instructions. spv_result_t ConversionPass(ValidationState_t& _, const Instruction* inst) { const spv::Op opcode = inst->opcode(); const uint32_t result_type = inst->type_id(); switch (opcode) { case spv::Op::OpConvertFToU: { if (!_.IsUnsignedIntScalarType(result_type) && !_.IsUnsignedIntVectorType(result_type) && !_.IsUnsignedIntCooperativeMatrixType(result_type) && !_.IsUnsignedIntCooperativeVectorNVType(result_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected unsigned int scalar or vector type as Result Type: " << spvOpcodeString(opcode); const uint32_t input_type = _.GetOperandTypeId(inst, 2); if (!input_type || (!_.IsFloatScalarType(input_type) && !_.IsFloatVectorType(input_type) && !_.IsFloatCooperativeMatrixType(input_type) && !_.IsFloatCooperativeVectorNVType(input_type))) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected input to be float scalar or vector: " << spvOpcodeString(opcode); if (_.IsCooperativeVectorNVType(result_type) || _.IsCooperativeVectorNVType(input_type)) { spv_result_t ret = _.CooperativeVectorDimensionsMatch(inst, result_type, input_type); if (ret != SPV_SUCCESS) return ret; } else if (_.IsCooperativeMatrixType(result_type) || _.IsCooperativeMatrixType(input_type)) { spv_result_t ret = _.CooperativeMatrixShapesMatch(inst, result_type, input_type, true); if (ret != SPV_SUCCESS) return ret; } else { if (_.GetDimension(result_type) != _.GetDimension(input_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected input to have the same dimension as Result Type: " << spvOpcodeString(opcode); } break; } case spv::Op::OpConvertFToS: { if (!_.IsIntScalarType(result_type) && !_.IsIntVectorType(result_type) && !_.IsIntCooperativeMatrixType(result_type) && !_.IsIntCooperativeVectorNVType(result_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected int scalar or vector type as Result Type: " << spvOpcodeString(opcode); const uint32_t input_type = _.GetOperandTypeId(inst, 2); if (!input_type || (!_.IsFloatScalarType(input_type) && !_.IsFloatVectorType(input_type) && !_.IsFloatCooperativeMatrixType(input_type) && !_.IsFloatCooperativeVectorNVType(input_type))) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected input to be float scalar or vector: " << spvOpcodeString(opcode); if (_.IsCooperativeVectorNVType(result_type) || _.IsCooperativeVectorNVType(input_type)) { spv_result_t ret = _.CooperativeVectorDimensionsMatch(inst, result_type, input_type); if (ret != SPV_SUCCESS) return ret; } else if (_.IsCooperativeMatrixType(result_type) || _.IsCooperativeMatrixType(input_type)) { spv_result_t ret = _.CooperativeMatrixShapesMatch(inst, result_type, input_type, true); if (ret != SPV_SUCCESS) return ret; } else { if (_.GetDimension(result_type) != _.GetDimension(input_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected input to have the same dimension as Result Type: " << spvOpcodeString(opcode); } break; } case spv::Op::OpConvertSToF: case spv::Op::OpConvertUToF: { if (!_.IsFloatScalarType(result_type) && !_.IsFloatVectorType(result_type) && !_.IsFloatCooperativeMatrixType(result_type) && !_.IsFloatCooperativeVectorNVType(result_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected float scalar or vector type as Result Type: " << spvOpcodeString(opcode); const uint32_t input_type = _.GetOperandTypeId(inst, 2); if (!input_type || (!_.IsIntScalarType(input_type) && !_.IsIntVectorType(input_type) && !_.IsIntCooperativeMatrixType(input_type) && !_.IsIntCooperativeVectorNVType(input_type))) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected input to be int scalar or vector: " << spvOpcodeString(opcode); if (_.IsCooperativeVectorNVType(result_type) || _.IsCooperativeVectorNVType(input_type)) { spv_result_t ret = _.CooperativeVectorDimensionsMatch(inst, result_type, input_type); if (ret != SPV_SUCCESS) return ret; } else if (_.IsCooperativeMatrixType(result_type) || _.IsCooperativeMatrixType(input_type)) { spv_result_t ret = _.CooperativeMatrixShapesMatch(inst, result_type, input_type, true); if (ret != SPV_SUCCESS) return ret; } else { if (_.GetDimension(result_type) != _.GetDimension(input_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected input to have the same dimension as Result Type: " << spvOpcodeString(opcode); } break; } case spv::Op::OpUConvert: { if (!_.IsUnsignedIntScalarType(result_type) && !_.IsUnsignedIntVectorType(result_type) && !_.IsUnsignedIntCooperativeMatrixType(result_type) && !_.IsUnsignedIntCooperativeVectorNVType(result_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected unsigned int scalar or vector type as Result Type: " << spvOpcodeString(opcode); const uint32_t input_type = _.GetOperandTypeId(inst, 2); if (!input_type || (!_.IsIntScalarType(input_type) && !_.IsIntVectorType(input_type) && !_.IsIntCooperativeMatrixType(input_type) && !_.IsIntCooperativeVectorNVType(input_type))) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected input to be int scalar or vector: " << spvOpcodeString(opcode); if (_.IsCooperativeVectorNVType(result_type) || _.IsCooperativeVectorNVType(input_type)) { spv_result_t ret = _.CooperativeVectorDimensionsMatch(inst, result_type, input_type); if (ret != SPV_SUCCESS) return ret; } else if (_.IsCooperativeMatrixType(result_type) || _.IsCooperativeMatrixType(input_type)) { spv_result_t ret = _.CooperativeMatrixShapesMatch(inst, result_type, input_type, true); if (ret != SPV_SUCCESS) return ret; } else { if (_.GetDimension(result_type) != _.GetDimension(input_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected input to have the same dimension as Result Type: " << spvOpcodeString(opcode); } if (_.GetBitWidth(result_type) == _.GetBitWidth(input_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected input to have different bit width from Result " "Type: " << spvOpcodeString(opcode); break; } case spv::Op::OpSConvert: { if (!_.IsIntScalarType(result_type) && !_.IsIntVectorType(result_type) && !_.IsIntCooperativeMatrixType(result_type) && !_.IsIntCooperativeVectorNVType(result_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected int scalar or vector type as Result Type: " << spvOpcodeString(opcode); const uint32_t input_type = _.GetOperandTypeId(inst, 2); if (!input_type || (!_.IsIntScalarType(input_type) && !_.IsIntVectorType(input_type) && !_.IsIntCooperativeMatrixType(input_type) && !_.IsIntCooperativeVectorNVType(input_type))) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected input to be int scalar or vector: " << spvOpcodeString(opcode); if (_.IsCooperativeVectorNVType(result_type) || _.IsCooperativeVectorNVType(input_type)) { spv_result_t ret = _.CooperativeVectorDimensionsMatch(inst, result_type, input_type); if (ret != SPV_SUCCESS) return ret; } else if (_.IsCooperativeMatrixType(result_type) || _.IsCooperativeMatrixType(input_type)) { spv_result_t ret = _.CooperativeMatrixShapesMatch(inst, result_type, input_type, true); if (ret != SPV_SUCCESS) return ret; } else { if (_.GetDimension(result_type) != _.GetDimension(input_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected input to have the same dimension as Result Type: " << spvOpcodeString(opcode); } if (_.GetBitWidth(result_type) == _.GetBitWidth(input_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected input to have different bit width from Result " "Type: " << spvOpcodeString(opcode); break; } case spv::Op::OpFConvert: { if (!_.IsFloatScalarType(result_type) && !_.IsFloatVectorType(result_type) && !_.IsFloatCooperativeMatrixType(result_type) && !_.IsFloatCooperativeVectorNVType(result_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected float scalar or vector type as Result Type: " << spvOpcodeString(opcode); const uint32_t input_type = _.GetOperandTypeId(inst, 2); if (!input_type || (!_.IsFloatScalarType(input_type) && !_.IsFloatVectorType(input_type) && !_.IsFloatCooperativeMatrixType(input_type) && !_.IsFloatCooperativeVectorNVType(input_type))) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected input to be float scalar or vector: " << spvOpcodeString(opcode); if (_.IsCooperativeVectorNVType(result_type) || _.IsCooperativeVectorNVType(input_type)) { spv_result_t ret = _.CooperativeVectorDimensionsMatch(inst, result_type, input_type); if (ret != SPV_SUCCESS) return ret; } else if (_.IsCooperativeMatrixType(result_type) || _.IsCooperativeMatrixType(input_type)) { spv_result_t ret = _.CooperativeMatrixShapesMatch(inst, result_type, input_type, true); if (ret != SPV_SUCCESS) return ret; } else { if (_.GetDimension(result_type) != _.GetDimension(input_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected input to have the same dimension as Result Type: " << spvOpcodeString(opcode); } if (_.GetBitWidth(result_type) == _.GetBitWidth(input_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected input to have different bit width from Result " "Type: " << spvOpcodeString(opcode); break; } case spv::Op::OpQuantizeToF16: { if ((!_.IsFloatScalarType(result_type) && !_.IsFloatVectorType(result_type)) || _.GetBitWidth(result_type) != 32) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected 32-bit float scalar or vector type as Result Type: " << spvOpcodeString(opcode); const uint32_t input_type = _.GetOperandTypeId(inst, 2); if (input_type != result_type) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected input type to be equal to Result Type: " << spvOpcodeString(opcode); break; } case spv::Op::OpConvertPtrToU: { if (!_.IsUnsignedIntScalarType(result_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected unsigned int scalar type as Result Type: " << spvOpcodeString(opcode); const uint32_t input_type = _.GetOperandTypeId(inst, 2); if (!_.IsPointerType(input_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected input to be a pointer: " << spvOpcodeString(opcode); if (_.addressing_model() == spv::AddressingModel::Logical) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Logical addressing not supported: " << spvOpcodeString(opcode); if (_.addressing_model() == spv::AddressingModel::PhysicalStorageBuffer64) { spv::StorageClass input_storage_class; uint32_t input_data_type = 0; _.GetPointerTypeInfo(input_type, &input_data_type, &input_storage_class); if (input_storage_class != spv::StorageClass::PhysicalStorageBuffer) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Pointer storage class must be PhysicalStorageBuffer: " << spvOpcodeString(opcode); if (spvIsVulkanEnv(_.context()->target_env)) { if (_.GetBitWidth(result_type) != 64) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(4710) << "PhysicalStorageBuffer64 addressing mode requires the " "result integer type to have a 64-bit width for Vulkan " "environment."; } } } break; } case spv::Op::OpSatConvertSToU: case spv::Op::OpSatConvertUToS: { if (!_.IsIntScalarType(result_type) && !_.IsIntVectorType(result_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected int scalar or vector type as Result Type: " << spvOpcodeString(opcode); const uint32_t input_type = _.GetOperandTypeId(inst, 2); if (!input_type || (!_.IsIntScalarType(input_type) && !_.IsIntVectorType(input_type))) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected int scalar or vector as input: " << spvOpcodeString(opcode); if (_.GetDimension(result_type) != _.GetDimension(input_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected input to have the same dimension as Result Type: " << spvOpcodeString(opcode); break; } case spv::Op::OpConvertUToPtr: { if (!_.IsPointerType(result_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Result Type to be a pointer: " << spvOpcodeString(opcode); const uint32_t input_type = _.GetOperandTypeId(inst, 2); if (!input_type || !_.IsIntScalarType(input_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected int scalar as input: " << spvOpcodeString(opcode); if (_.addressing_model() == spv::AddressingModel::Logical) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Logical addressing not supported: " << spvOpcodeString(opcode); if (_.addressing_model() == spv::AddressingModel::PhysicalStorageBuffer64) { spv::StorageClass result_storage_class; uint32_t result_data_type = 0; _.GetPointerTypeInfo(result_type, &result_data_type, &result_storage_class); if (result_storage_class != spv::StorageClass::PhysicalStorageBuffer) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Pointer storage class must be PhysicalStorageBuffer: " << spvOpcodeString(opcode); if (spvIsVulkanEnv(_.context()->target_env)) { if (_.GetBitWidth(input_type) != 64) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(4710) << "PhysicalStorageBuffer64 addressing mode requires the " "input integer to have a 64-bit width for Vulkan " "environment."; } } } break; } case spv::Op::OpPtrCastToGeneric: { spv::StorageClass result_storage_class; uint32_t result_data_type = 0; if (!_.GetPointerTypeInfo(result_type, &result_data_type, &result_storage_class)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Result Type to be a pointer: " << spvOpcodeString(opcode); if (result_storage_class != spv::StorageClass::Generic) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Result Type to have storage class Generic: " << spvOpcodeString(opcode); const uint32_t input_type = _.GetOperandTypeId(inst, 2); spv::StorageClass input_storage_class; uint32_t input_data_type = 0; if (!_.GetPointerTypeInfo(input_type, &input_data_type, &input_storage_class)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected input to be a pointer: " << spvOpcodeString(opcode); if (input_storage_class != spv::StorageClass::Workgroup && input_storage_class != spv::StorageClass::CrossWorkgroup && input_storage_class != spv::StorageClass::Function) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected input to have storage class Workgroup, " << "CrossWorkgroup or Function: " << spvOpcodeString(opcode); if (result_data_type != input_data_type) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected input and Result Type to point to the same type: " << spvOpcodeString(opcode); break; } case spv::Op::OpGenericCastToPtr: { spv::StorageClass result_storage_class; uint32_t result_data_type = 0; if (!_.GetPointerTypeInfo(result_type, &result_data_type, &result_storage_class)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Result Type to be a pointer: " << spvOpcodeString(opcode); if (result_storage_class != spv::StorageClass::Workgroup && result_storage_class != spv::StorageClass::CrossWorkgroup && result_storage_class != spv::StorageClass::Function) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Result Type to have storage class Workgroup, " << "CrossWorkgroup or Function: " << spvOpcodeString(opcode); const uint32_t input_type = _.GetOperandTypeId(inst, 2); spv::StorageClass input_storage_class; uint32_t input_data_type = 0; if (!_.GetPointerTypeInfo(input_type, &input_data_type, &input_storage_class)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected input to be a pointer: " << spvOpcodeString(opcode); if (input_storage_class != spv::StorageClass::Generic) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected input to have storage class Generic: " << spvOpcodeString(opcode); if (result_data_type != input_data_type) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected input and Result Type to point to the same type: " << spvOpcodeString(opcode); break; } case spv::Op::OpGenericCastToPtrExplicit: { spv::StorageClass result_storage_class; uint32_t result_data_type = 0; if (!_.GetPointerTypeInfo(result_type, &result_data_type, &result_storage_class)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Result Type to be a pointer: " << spvOpcodeString(opcode); const auto target_storage_class = inst->GetOperandAs(3); if (result_storage_class != target_storage_class) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Result Type to be of target storage class: " << spvOpcodeString(opcode); const uint32_t input_type = _.GetOperandTypeId(inst, 2); spv::StorageClass input_storage_class; uint32_t input_data_type = 0; if (!_.GetPointerTypeInfo(input_type, &input_data_type, &input_storage_class)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected input to be a pointer: " << spvOpcodeString(opcode); if (input_storage_class != spv::StorageClass::Generic) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected input to have storage class Generic: " << spvOpcodeString(opcode); if (result_data_type != input_data_type) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected input and Result Type to point to the same type: " << spvOpcodeString(opcode); if (target_storage_class != spv::StorageClass::Workgroup && target_storage_class != spv::StorageClass::CrossWorkgroup && target_storage_class != spv::StorageClass::Function) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected target storage class to be Workgroup, " << "CrossWorkgroup or Function: " << spvOpcodeString(opcode); break; } case spv::Op::OpBitcast: { const uint32_t input_type = _.GetOperandTypeId(inst, 2); if (!input_type) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected input to have a type: " << spvOpcodeString(opcode); const bool result_is_pointer = _.IsPointerType(result_type); const bool result_is_int_scalar = _.IsIntScalarType(result_type); const bool input_is_pointer = _.IsPointerType(input_type); const bool input_is_int_scalar = _.IsIntScalarType(input_type); const bool result_is_coopmat = _.IsCooperativeMatrixType(result_type); const bool input_is_coopmat = _.IsCooperativeMatrixType(input_type); const bool result_is_coopvec = _.IsCooperativeVectorNVType(result_type); const bool input_is_coopvec = _.IsCooperativeVectorNVType(input_type); if (!result_is_pointer && !result_is_int_scalar && !result_is_coopmat && !result_is_coopvec && !_.IsIntVectorType(result_type) && !_.IsFloatScalarType(result_type) && !_.IsFloatVectorType(result_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Result Type to be a pointer or int or float vector " << "or scalar type: " << spvOpcodeString(opcode); if (!input_is_pointer && !input_is_int_scalar && !input_is_coopmat && !input_is_coopvec && !_.IsIntVectorType(input_type) && !_.IsFloatScalarType(input_type) && !_.IsFloatVectorType(input_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected input to be a pointer or int or float vector " << "or scalar: " << spvOpcodeString(opcode); if (result_is_coopvec != input_is_coopvec) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Cooperative vector can only be cast to another cooperative " << "vector: " << spvOpcodeString(opcode); if (result_is_coopmat != input_is_coopmat) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Cooperative matrix can only be cast to another cooperative " << "matrix: " << spvOpcodeString(opcode); if (result_is_coopvec) { spv_result_t ret = _.CooperativeVectorDimensionsMatch(inst, result_type, input_type); if (ret != SPV_SUCCESS) return ret; } if (result_is_coopmat) { spv_result_t ret = _.CooperativeMatrixShapesMatch(inst, result_type, input_type, false); if (ret != SPV_SUCCESS) return ret; } if (_.version() >= SPV_SPIRV_VERSION_WORD(1, 5) || _.HasExtension(kSPV_KHR_physical_storage_buffer)) { const bool result_is_int_vector = _.IsIntVectorType(result_type); const bool result_has_int32 = _.ContainsSizedIntOrFloatType(result_type, spv::Op::OpTypeInt, 32); const bool input_is_int_vector = _.IsIntVectorType(input_type); const bool input_has_int32 = _.ContainsSizedIntOrFloatType(input_type, spv::Op::OpTypeInt, 32); if (result_is_pointer && !input_is_pointer && !input_is_int_scalar && !(input_is_int_vector && input_has_int32)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected input to be a pointer, int scalar or 32-bit int " "vector if Result Type is pointer: " << spvOpcodeString(opcode); if (input_is_pointer && !result_is_pointer && !result_is_int_scalar && !(result_is_int_vector && result_has_int32)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Pointer can only be converted to another pointer, int " "scalar or 32-bit int vector: " << spvOpcodeString(opcode); } else { if (result_is_pointer && !input_is_pointer && !input_is_int_scalar) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected input to be a pointer or int scalar if Result " "Type is pointer: " << spvOpcodeString(opcode); if (input_is_pointer && !result_is_pointer && !result_is_int_scalar) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Pointer can only be converted to another pointer or int " "scalar: " << spvOpcodeString(opcode); } if (!result_is_pointer && !input_is_pointer) { const uint32_t result_size = _.GetBitWidth(result_type) * _.GetDimension(result_type); const uint32_t input_size = _.GetBitWidth(input_type) * _.GetDimension(input_type); if (result_size != input_size) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected input to have the same total bit width as " << "Result Type: " << spvOpcodeString(opcode); } break; } case spv::Op::OpConvertUToAccelerationStructureKHR: { if (!_.IsAccelerationStructureType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Result Type to be a Acceleration Structure: " << spvOpcodeString(opcode); } const uint32_t input_type = _.GetOperandTypeId(inst, 2); if (!input_type || !_.IsUnsigned64BitHandle(input_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected 64-bit uint scalar or 2-component 32-bit uint " "vector as input: " << spvOpcodeString(opcode); } break; } case spv::Op::OpCooperativeMatrixConvertNV: case spv::Op::OpCooperativeMatrixTransposeNV: { if (!_.IsCooperativeMatrixType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected cooperative matrix Result Type: " << spvOpcodeString(opcode); } const uint32_t input_type = _.GetOperandTypeId(inst, 2); if (!_.IsCooperativeMatrixType(input_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected cooperative matrix type for Matrix input: " << spvOpcodeString(opcode); } bool swap_row_col = (opcode == spv::Op::OpCooperativeMatrixTransposeNV); if (auto error = _.CooperativeMatrixShapesMatch( inst, result_type, input_type, true, swap_row_col)) return error; if (opcode == spv::Op::OpCooperativeMatrixConvertNV) { if (_.FindDef(result_type)->GetOperandAs(1) != _.FindDef(input_type)->GetOperandAs(1)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Result Type and Matrix component types mismatch: " << spvOpcodeString(opcode); } } if (opcode == spv::Op::OpCooperativeMatrixTransposeNV) { if (!_.IsCooperativeMatrixBType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Result Type must have UseB: " << spvOpcodeString(opcode); } } break; } default: break; } if (_.HasCapability(spv::Capability::Shader)) { switch (inst->opcode()) { case spv::Op::OpConvertFToU: case spv::Op::OpConvertFToS: case spv::Op::OpConvertSToF: case spv::Op::OpConvertUToF: case spv::Op::OpBitcast: if (_.ContainsLimitedUseIntOrFloatType(inst->type_id()) || _.ContainsLimitedUseIntOrFloatType(_.GetOperandTypeId(inst, 2u))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "8- or 16-bit types can only be used with width-only " "conversions"; } break; default: break; } } return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_debug.cpp000066400000000000000000000045611475742701700242640ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/spirv_target_env.h" #include "source/val/instruction.h" #include "source/val/validate.h" #include "source/val/validation_state.h" namespace spvtools { namespace val { namespace { spv_result_t ValidateMemberName(ValidationState_t& _, const Instruction* inst) { const auto type_id = inst->GetOperandAs(0); const auto type = _.FindDef(type_id); if (!type || spv::Op::OpTypeStruct != type->opcode()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpMemberName Type " << _.getIdName(type_id) << " is not a struct type."; } const auto member_id = inst->GetOperandAs(1); const auto member_count = (uint32_t)(type->words().size() - 2); if (member_count <= member_id) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpMemberName Member " << _.getIdName(member_id) << " index is larger than Type " << _.getIdName(type->id()) << "s member count."; } return SPV_SUCCESS; } spv_result_t ValidateLine(ValidationState_t& _, const Instruction* inst) { const auto file_id = inst->GetOperandAs(0); const auto file = _.FindDef(file_id); if (!file || spv::Op::OpString != file->opcode()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpLine Target " << _.getIdName(file_id) << " is not an OpString."; } return SPV_SUCCESS; } } // namespace spv_result_t DebugPass(ValidationState_t& _, const Instruction* inst) { switch (inst->opcode()) { case spv::Op::OpMemberName: if (auto error = ValidateMemberName(_, inst)) return error; break; case spv::Op::OpLine: if (auto error = ValidateLine(_, inst)) return error; break; default: break; } return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_decorations.cpp000066400000000000000000002642761475742701700255230ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include #include #include #include #include #include "source/diagnostic.h" #include "source/opcode.h" #include "source/spirv_constant.h" #include "source/spirv_target_env.h" #include "source/spirv_validator_options.h" #include "source/util/string_utils.h" #include "source/val/validate_scopes.h" #include "source/val/validation_state.h" namespace spvtools { namespace val { namespace { // Distinguish between row and column major matrix layouts. enum MatrixLayout { kRowMajor, kColumnMajor }; // A functor for hashing a pair of integers. struct PairHash { std::size_t operator()(const std::pair pair) const { const uint32_t a = pair.first; const uint32_t b = pair.second; const uint32_t rotated_b = (b >> 2) | ((b & 3) << 30); return a ^ rotated_b; } }; // Struct member layout attributes that are inherited through arrays. struct LayoutConstraints { explicit LayoutConstraints( MatrixLayout the_majorness = MatrixLayout::kColumnMajor, uint32_t stride = 0) : majorness(the_majorness), matrix_stride(stride) {} MatrixLayout majorness; uint32_t matrix_stride; }; // A type for mapping (struct id, member id) to layout constraints. using MemberConstraints = std::unordered_map, LayoutConstraints, PairHash>; // Returns the array stride of the given array type. uint32_t GetArrayStride(uint32_t array_id, ValidationState_t& vstate) { for (auto& decoration : vstate.id_decorations(array_id)) { if (spv::Decoration::ArrayStride == decoration.dec_type()) { return decoration.params()[0]; } } return 0; } // Returns true if the given structure type has a Block decoration. bool isBlock(uint32_t struct_id, ValidationState_t& vstate) { const auto& decorations = vstate.id_decorations(struct_id); return std::any_of(decorations.begin(), decorations.end(), [](const Decoration& d) { return spv::Decoration::Block == d.dec_type(); }); } // Returns true if the given ID has the Import LinkageAttributes decoration. bool hasImportLinkageAttribute(uint32_t id, ValidationState_t& vstate) { const auto& decorations = vstate.id_decorations(id); return std::any_of( decorations.begin(), decorations.end(), [](const Decoration& d) { return spv::Decoration::LinkageAttributes == d.dec_type() && d.params().size() >= 2u && spv::LinkageType(d.params().back()) == spv::LinkageType::Import; }); } // Returns a vector of all members of a structure. std::vector getStructMembers(uint32_t struct_id, ValidationState_t& vstate) { const auto inst = vstate.FindDef(struct_id); return std::vector(inst->words().begin() + 2, inst->words().end()); } // Returns a vector of all members of a structure that have specific type. std::vector getStructMembers(uint32_t struct_id, spv::Op type, ValidationState_t& vstate) { std::vector members; for (auto id : getStructMembers(struct_id, vstate)) { if (type == vstate.FindDef(id)->opcode()) { members.push_back(id); } } return members; } // Returns whether the given structure is missing Offset decoration for any // member. Handles also nested structures. bool isMissingOffsetInStruct(uint32_t struct_id, ValidationState_t& vstate) { const auto* inst = vstate.FindDef(struct_id); std::vector hasOffset; std::vector struct_members; if (inst->opcode() == spv::Op::OpTypeStruct) { // Check offsets of member decorations. struct_members = getStructMembers(struct_id, vstate); hasOffset.resize(struct_members.size(), false); for (auto& decoration : vstate.id_decorations(struct_id)) { if (spv::Decoration::Offset == decoration.dec_type() && Decoration::kInvalidMember != decoration.struct_member_index()) { // Offset 0xffffffff is not valid so ignore it for simplicity's sake. if (decoration.params()[0] == 0xffffffff) return true; hasOffset[decoration.struct_member_index()] = true; } } } else if (inst->opcode() == spv::Op::OpTypeArray || inst->opcode() == spv::Op::OpTypeRuntimeArray) { hasOffset.resize(1, true); struct_members.push_back(inst->GetOperandAs(1u)); } // Look through nested structs (which may be in an array). bool nestedStructsMissingOffset = false; for (auto id : struct_members) { if (isMissingOffsetInStruct(id, vstate)) { nestedStructsMissingOffset = true; break; } } return nestedStructsMissingOffset || !std::all_of(hasOffset.begin(), hasOffset.end(), [](const bool b) { return b; }); } // Rounds x up to the next alignment. Assumes alignment is a power of two. uint32_t align(uint32_t x, uint32_t alignment) { return (x + alignment - 1) & ~(alignment - 1); } // Returns base alignment of struct member. If |roundUp| is true, also // ensure that structs, arrays, and matrices are aligned at least to a // multiple of 16 bytes. (That is, when roundUp is true, this function // returns the *extended* alignment as it's called by the Vulkan spec.) uint32_t getBaseAlignment(uint32_t member_id, bool roundUp, const LayoutConstraints& inherited, MemberConstraints& constraints, ValidationState_t& vstate) { const auto inst = vstate.FindDef(member_id); const auto& words = inst->words(); // Minimal alignment is byte-aligned. uint32_t baseAlignment = 1; switch (inst->opcode()) { case spv::Op::OpTypeSampledImage: case spv::Op::OpTypeSampler: case spv::Op::OpTypeImage: if (vstate.HasCapability(spv::Capability::BindlessTextureNV)) return vstate.samplerimage_variable_address_mode() / 8; assert(0); return 0; case spv::Op::OpTypeInt: case spv::Op::OpTypeFloat: baseAlignment = words[2] / 8; break; case spv::Op::OpTypeVector: { const auto componentId = words[2]; const auto numComponents = words[3]; const auto componentAlignment = getBaseAlignment( componentId, roundUp, inherited, constraints, vstate); baseAlignment = componentAlignment * (numComponents == 3 ? 4 : numComponents); break; } case spv::Op::OpTypeMatrix: { const auto column_type = words[2]; if (inherited.majorness == kColumnMajor) { baseAlignment = getBaseAlignment(column_type, roundUp, inherited, constraints, vstate); } else { // A row-major matrix of C columns has a base alignment equal to the // base alignment of a vector of C matrix components. const auto num_columns = words[3]; const auto component_inst = vstate.FindDef(column_type); const auto component_id = component_inst->words()[2]; const auto componentAlignment = getBaseAlignment( component_id, roundUp, inherited, constraints, vstate); baseAlignment = componentAlignment * (num_columns == 3 ? 4 : num_columns); } if (roundUp) baseAlignment = align(baseAlignment, 16u); } break; case spv::Op::OpTypeArray: case spv::Op::OpTypeRuntimeArray: baseAlignment = getBaseAlignment(words[2], roundUp, inherited, constraints, vstate); if (roundUp) baseAlignment = align(baseAlignment, 16u); break; case spv::Op::OpTypeStruct: { const auto members = getStructMembers(member_id, vstate); for (uint32_t memberIdx = 0, numMembers = uint32_t(members.size()); memberIdx < numMembers; ++memberIdx) { const auto id = members[memberIdx]; const auto& constraint = constraints[std::make_pair(member_id, memberIdx)]; baseAlignment = std::max( baseAlignment, getBaseAlignment(id, roundUp, constraint, constraints, vstate)); } if (roundUp) baseAlignment = align(baseAlignment, 16u); break; } case spv::Op::OpTypePointer: case spv::Op::OpTypeUntypedPointerKHR: baseAlignment = vstate.pointer_size_and_alignment(); break; default: assert(0); break; } return baseAlignment; } // Returns scalar alignment of a type. uint32_t getScalarAlignment(uint32_t type_id, ValidationState_t& vstate) { const auto inst = vstate.FindDef(type_id); const auto& words = inst->words(); switch (inst->opcode()) { case spv::Op::OpTypeSampledImage: case spv::Op::OpTypeSampler: case spv::Op::OpTypeImage: if (vstate.HasCapability(spv::Capability::BindlessTextureNV)) return vstate.samplerimage_variable_address_mode() / 8; assert(0); return 0; case spv::Op::OpTypeInt: case spv::Op::OpTypeFloat: return words[2] / 8; case spv::Op::OpTypeVector: case spv::Op::OpTypeMatrix: case spv::Op::OpTypeArray: case spv::Op::OpTypeRuntimeArray: { const auto compositeMemberTypeId = words[2]; return getScalarAlignment(compositeMemberTypeId, vstate); } case spv::Op::OpTypeStruct: { const auto members = getStructMembers(type_id, vstate); uint32_t max_member_alignment = 1; for (uint32_t memberIdx = 0, numMembers = uint32_t(members.size()); memberIdx < numMembers; ++memberIdx) { const auto id = members[memberIdx]; uint32_t member_alignment = getScalarAlignment(id, vstate); if (member_alignment > max_member_alignment) { max_member_alignment = member_alignment; } } return max_member_alignment; } break; case spv::Op::OpTypePointer: case spv::Op::OpTypeUntypedPointerKHR: return vstate.pointer_size_and_alignment(); default: assert(0); break; } return 1; } // Returns size of a struct member. Doesn't include padding at the end of struct // or array. Assumes that in the struct case, all members have offsets. uint32_t getSize(uint32_t member_id, const LayoutConstraints& inherited, MemberConstraints& constraints, ValidationState_t& vstate) { const auto inst = vstate.FindDef(member_id); const auto& words = inst->words(); switch (inst->opcode()) { case spv::Op::OpTypeSampledImage: case spv::Op::OpTypeSampler: case spv::Op::OpTypeImage: if (vstate.HasCapability(spv::Capability::BindlessTextureNV)) return vstate.samplerimage_variable_address_mode() / 8; assert(0); return 0; case spv::Op::OpTypeInt: case spv::Op::OpTypeFloat: return words[2] / 8; case spv::Op::OpTypeVector: { const auto componentId = words[2]; const auto numComponents = words[3]; const auto componentSize = getSize(componentId, inherited, constraints, vstate); const auto size = componentSize * numComponents; return size; } case spv::Op::OpTypeArray: { const auto sizeInst = vstate.FindDef(words[3]); if (spvOpcodeIsSpecConstant(sizeInst->opcode())) return 0; assert(spv::Op::OpConstant == sizeInst->opcode()); const uint32_t num_elem = sizeInst->words()[3]; const uint32_t elem_type = words[2]; const uint32_t elem_size = getSize(elem_type, inherited, constraints, vstate); // Account for gaps due to alignments in the first N-1 elements, // then add the size of the last element. const auto size = (num_elem - 1) * GetArrayStride(member_id, vstate) + elem_size; return size; } case spv::Op::OpTypeRuntimeArray: return 0; case spv::Op::OpTypeMatrix: { const auto num_columns = words[3]; if (inherited.majorness == kColumnMajor) { return num_columns * inherited.matrix_stride; } else { // Row major case. const auto column_type = words[2]; const auto component_inst = vstate.FindDef(column_type); const auto num_rows = component_inst->words()[3]; const auto scalar_elem_type = component_inst->words()[2]; const uint32_t scalar_elem_size = getSize(scalar_elem_type, inherited, constraints, vstate); return (num_rows - 1) * inherited.matrix_stride + num_columns * scalar_elem_size; } } case spv::Op::OpTypeStruct: { const auto& members = getStructMembers(member_id, vstate); if (members.empty()) return 0; const auto lastIdx = uint32_t(members.size() - 1); const auto& lastMember = members.back(); uint32_t offset = 0xffffffff; // Find the offset of the last element and add the size. auto member_decorations = vstate.id_member_decorations(member_id, lastIdx); for (auto decoration = member_decorations.begin; decoration != member_decorations.end; ++decoration) { assert(decoration->struct_member_index() == (int)lastIdx); if (spv::Decoration::Offset == decoration->dec_type()) { offset = decoration->params()[0]; } } // This check depends on the fact that all members have offsets. This // has been checked earlier in the flow. assert(offset != 0xffffffff); const auto& constraint = constraints[std::make_pair(lastMember, lastIdx)]; return offset + getSize(lastMember, constraint, constraints, vstate); } case spv::Op::OpTypePointer: case spv::Op::OpTypeUntypedPointerKHR: return vstate.pointer_size_and_alignment(); default: assert(0); return 0; } } // A member is defined to improperly straddle if either of the following are // true: // - It is a vector with total size less than or equal to 16 bytes, and has // Offset decorations placing its first byte at F and its last byte at L, where // floor(F / 16) != floor(L / 16). // - It is a vector with total size greater than 16 bytes and has its Offset // decorations placing its first byte at a non-integer multiple of 16. bool hasImproperStraddle(uint32_t id, uint32_t offset, const LayoutConstraints& inherited, MemberConstraints& constraints, ValidationState_t& vstate) { const auto size = getSize(id, inherited, constraints, vstate); const auto F = offset; const auto L = offset + size - 1; if (size <= 16) { if ((F >> 4) != (L >> 4)) return true; } else { if (F % 16 != 0) return true; } return false; } // Returns true if |offset| satsifies an alignment to |alignment|. In the case // of |alignment| of zero, the |offset| must also be zero. bool IsAlignedTo(uint32_t offset, uint32_t alignment) { if (alignment == 0) return offset == 0; return 0 == (offset % alignment); } // Returns SPV_SUCCESS if the given struct satisfies standard layout rules for // Block or BufferBlocks in Vulkan. Otherwise emits a diagnostic and returns // something other than SPV_SUCCESS. Matrices inherit the specified column // or row major-ness. spv_result_t checkLayout(uint32_t struct_id, const char* storage_class_str, const char* decoration_str, bool blockRules, bool scalar_block_layout, uint32_t incoming_offset, MemberConstraints& constraints, ValidationState_t& vstate) { if (vstate.options()->skip_block_layout) return SPV_SUCCESS; // blockRules are the same as bufferBlock rules if the uniform buffer // standard layout extension is being used. if (vstate.options()->uniform_buffer_standard_layout) blockRules = false; // Relaxed layout and scalar layout can both be in effect at the same time. // For example, relaxed layout is implied by Vulkan 1.1. But scalar layout // is more permissive than relaxed layout. const bool relaxed_block_layout = vstate.IsRelaxedBlockLayout(); auto fail = [&vstate, struct_id, storage_class_str, decoration_str, blockRules, relaxed_block_layout, scalar_block_layout](uint32_t member_idx) -> DiagnosticStream { DiagnosticStream ds = std::move(vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(struct_id)) << "Structure id " << struct_id << " decorated as " << decoration_str << " for variable in " << storage_class_str << " storage class must follow " << (scalar_block_layout ? "scalar " : (relaxed_block_layout ? "relaxed " : "standard ")) << (blockRules ? "uniform buffer" : "storage buffer") << " layout rules: member " << member_idx << " "); return ds; }; // If we are checking the layout of untyped pointers or physical storage // buffer pointers, we may not actually have a struct here. Instead, pretend // we have a struct with a single member at offset 0. const auto& struct_type = vstate.FindDef(struct_id); std::vector members; if (struct_type->opcode() == spv::Op::OpTypeStruct) { members = getStructMembers(struct_id, vstate); } else { members.push_back(struct_id); } // To check for member overlaps, we want to traverse the members in // offset order. struct MemberOffsetPair { uint32_t member; uint32_t offset; }; std::vector member_offsets; // With untyped pointers or physical storage buffers, we might be checking // layouts that do not originate from a structure. if (struct_type->opcode() == spv::Op::OpTypeStruct) { member_offsets.reserve(members.size()); for (uint32_t memberIdx = 0, numMembers = uint32_t(members.size()); memberIdx < numMembers; memberIdx++) { uint32_t offset = 0xffffffff; auto member_decorations = vstate.id_member_decorations(struct_id, memberIdx); for (auto decoration = member_decorations.begin; decoration != member_decorations.end; ++decoration) { assert(decoration->struct_member_index() == (int)memberIdx); switch (decoration->dec_type()) { case spv::Decoration::Offset: offset = decoration->params()[0]; break; default: break; } } member_offsets.push_back( MemberOffsetPair{memberIdx, incoming_offset + offset}); } std::stable_sort( member_offsets.begin(), member_offsets.end(), [](const MemberOffsetPair& lhs, const MemberOffsetPair& rhs) { return lhs.offset < rhs.offset; }); } else { member_offsets.push_back({0, 0}); } // Now scan from lowest offset to highest offset. uint32_t nextValidOffset = 0; for (size_t ordered_member_idx = 0; ordered_member_idx < member_offsets.size(); ordered_member_idx++) { const auto& member_offset = member_offsets[ordered_member_idx]; const auto memberIdx = member_offset.member; const auto offset = member_offset.offset; auto id = members[member_offset.member]; const LayoutConstraints& constraint = constraints[std::make_pair(struct_id, uint32_t(memberIdx))]; // Scalar layout takes precedence because it's more permissive, and implying // an alignment that divides evenly into the alignment that would otherwise // be used. const auto alignment = scalar_block_layout ? getScalarAlignment(id, vstate) : getBaseAlignment(id, blockRules, constraint, constraints, vstate); const auto inst = vstate.FindDef(id); const auto opcode = inst->opcode(); const auto size = getSize(id, constraint, constraints, vstate); // Check offset. if (offset == 0xffffffff) return fail(memberIdx) << "is missing an Offset decoration"; if (!scalar_block_layout && relaxed_block_layout && opcode == spv::Op::OpTypeVector) { // In relaxed block layout, the vector offset must be aligned to the // vector's scalar element type. const auto componentId = inst->words()[2]; const auto scalar_alignment = getScalarAlignment(componentId, vstate); if (!IsAlignedTo(offset, scalar_alignment)) { return fail(memberIdx) << "at offset " << offset << " is not aligned to scalar element size " << scalar_alignment; } } else { // Without relaxed block layout, the offset must be divisible by the // alignment requirement. if (!IsAlignedTo(offset, alignment)) { return fail(memberIdx) << "at offset " << offset << " is not aligned to " << alignment; } } if (offset < nextValidOffset) return fail(memberIdx) << "at offset " << offset << " overlaps previous member ending at offset " << nextValidOffset - 1; if (!scalar_block_layout && relaxed_block_layout) { // Check improper straddle of vectors. if (spv::Op::OpTypeVector == opcode && hasImproperStraddle(id, offset, constraint, constraints, vstate)) return fail(memberIdx) << "is an improperly straddling vector at offset " << offset; } // Check struct members recursively. spv_result_t recursive_status = SPV_SUCCESS; if (spv::Op::OpTypeStruct == opcode && SPV_SUCCESS != (recursive_status = checkLayout( id, storage_class_str, decoration_str, blockRules, scalar_block_layout, offset, constraints, vstate))) return recursive_status; // Check matrix stride. if (spv::Op::OpTypeMatrix == opcode) { const auto stride = constraint.matrix_stride; if (!IsAlignedTo(stride, alignment)) { return fail(memberIdx) << "is a matrix with stride " << stride << " not satisfying alignment to " << alignment; } } // Check arrays and runtime arrays recursively. auto array_inst = inst; auto array_alignment = alignment; while (array_inst->opcode() == spv::Op::OpTypeArray || array_inst->opcode() == spv::Op::OpTypeRuntimeArray) { const auto typeId = array_inst->word(2); const auto element_inst = vstate.FindDef(typeId); // Check array stride. uint32_t array_stride = 0; for (auto& decoration : vstate.id_decorations(array_inst->id())) { if (spv::Decoration::ArrayStride == decoration.dec_type()) { array_stride = decoration.params()[0]; if (array_stride == 0) { return fail(memberIdx) << "contains an array with stride 0"; } if (!IsAlignedTo(array_stride, array_alignment)) return fail(memberIdx) << "contains an array with stride " << decoration.params()[0] << " not satisfying alignment to " << alignment; } } bool is_int32 = false; bool is_const = false; uint32_t num_elements = 0; if (array_inst->opcode() == spv::Op::OpTypeArray) { std::tie(is_int32, is_const, num_elements) = vstate.EvalInt32IfConst(array_inst->word(3)); } num_elements = std::max(1u, num_elements); // Check each element recursively if it is a struct. There is a // limitation to this check if the array size is a spec constant or is a // runtime array then we will only check a single element. This means // some improper straddles might be missed. if (spv::Op::OpTypeStruct == element_inst->opcode()) { std::vector seen(16, false); for (uint32_t i = 0; i < num_elements; ++i) { uint32_t next_offset = i * array_stride + offset; // Stop checking if offsets repeat in terms of 16-byte multiples. if (seen[next_offset % 16]) { break; } if (SPV_SUCCESS != (recursive_status = checkLayout( typeId, storage_class_str, decoration_str, blockRules, scalar_block_layout, next_offset, constraints, vstate))) return recursive_status; seen[next_offset % 16] = true; } } else if (spv::Op::OpTypeMatrix == element_inst->opcode()) { // Matrix stride would be on the array element in the struct. const auto stride = constraint.matrix_stride; if (!IsAlignedTo(stride, alignment)) { return fail(memberIdx) << "is a matrix with stride " << stride << " not satisfying alignment to " << alignment; } } // Proceed to the element in case it is an array. array_inst = element_inst; array_alignment = scalar_block_layout ? getScalarAlignment(array_inst->id(), vstate) : getBaseAlignment(array_inst->id(), blockRules, constraint, constraints, vstate); const auto element_size = getSize(element_inst->id(), constraint, constraints, vstate); if (element_size > array_stride) { return fail(memberIdx) << "contains an array with stride " << array_stride << ", but with an element size of " << element_size; } } nextValidOffset = offset + size; if (!scalar_block_layout && (spv::Op::OpTypeArray == opcode || spv::Op::OpTypeStruct == opcode)) { // Non-scalar block layout rules don't permit anything in the padding of // a struct or array. nextValidOffset = align(nextValidOffset, alignment); } } return SPV_SUCCESS; } // Returns true if variable or structure id has given decoration. Handles also // nested structures. bool hasDecoration(uint32_t id, spv::Decoration decoration, ValidationState_t& vstate) { for (auto& dec : vstate.id_decorations(id)) { if (decoration == dec.dec_type()) return true; } if (spv::Op::OpTypeStruct != vstate.FindDef(id)->opcode()) { return false; } for (auto member_id : getStructMembers(id, spv::Op::OpTypeStruct, vstate)) { if (hasDecoration(member_id, decoration, vstate)) { return true; } } return false; } // Returns true if all ids of given type have a specified decoration. bool checkForRequiredDecoration(uint32_t struct_id, std::function checker, spv::Op type, ValidationState_t& vstate) { const auto& members = getStructMembers(struct_id, vstate); for (size_t memberIdx = 0; memberIdx < members.size(); memberIdx++) { auto id = members[memberIdx]; if (type == spv::Op::OpTypeMatrix) { // Matrix decorations also apply to arrays of matrices. auto memberInst = vstate.FindDef(id); while (memberInst->opcode() == spv::Op::OpTypeArray || memberInst->opcode() == spv::Op::OpTypeRuntimeArray) { memberInst = vstate.FindDef(memberInst->GetOperandAs(1u)); } id = memberInst->id(); } if (type != vstate.FindDef(id)->opcode()) continue; bool found = false; for (auto& dec : vstate.id_decorations(id)) { if (checker(dec.dec_type())) found = true; } for (auto& dec : vstate.id_decorations(struct_id)) { if (checker(dec.dec_type()) && (int)memberIdx == dec.struct_member_index()) { found = true; } } if (!found) { return false; } } for (auto id : getStructMembers(struct_id, spv::Op::OpTypeStruct, vstate)) { if (!checkForRequiredDecoration(id, checker, type, vstate)) { return false; } } return true; } spv_result_t CheckLinkageAttrOfFunctions(ValidationState_t& vstate) { for (const auto& function : vstate.functions()) { if (function.block_count() == 0u) { // A function declaration (an OpFunction with no basic blocks), must have // a Linkage Attributes Decoration with the Import Linkage Type. if (!hasImportLinkageAttribute(function.id(), vstate)) { return vstate.diag(SPV_ERROR_INVALID_BINARY, vstate.FindDef(function.id())) << "Function declaration (id " << function.id() << ") must have a LinkageAttributes decoration with the Import " "Linkage type."; } } else { if (hasImportLinkageAttribute(function.id(), vstate)) { return vstate.diag(SPV_ERROR_INVALID_BINARY, vstate.FindDef(function.id())) << "Function definition (id " << function.id() << ") may not be decorated with Import Linkage type."; } } } return SPV_SUCCESS; } // Checks whether an imported variable is initialized by this module. spv_result_t CheckImportedVariableInitialization(ValidationState_t& vstate) { // According the SPIR-V Spec 2.16.1, it is illegal to initialize an imported // variable. This means that a module-scope OpVariable with initialization // value cannot be marked with the Import Linkage Type (import type id = 1). for (auto global_var_id : vstate.global_vars()) { // Initializer is an optional argument for OpVariable. If initializer // is present, the instruction will have 5 words. auto variable_instr = vstate.FindDef(global_var_id); if (variable_instr->words().size() == 5u && hasImportLinkageAttribute(global_var_id, vstate)) { return vstate.diag(SPV_ERROR_INVALID_ID, variable_instr) << "A module-scope OpVariable with initialization value " "cannot be marked with the Import Linkage Type."; } } return SPV_SUCCESS; } // Checks whether a builtin variable is valid. spv_result_t CheckBuiltInVariable(uint32_t var_id, ValidationState_t& vstate) { const auto& decorations = vstate.id_decorations(var_id); for (const auto& d : decorations) { if (spvIsVulkanEnv(vstate.context()->target_env)) { if (d.dec_type() == spv::Decoration::Location || d.dec_type() == spv::Decoration::Component) { return vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(var_id)) << vstate.VkErrorID(4915) << "A BuiltIn variable (id " << var_id << ") cannot have any Location or Component decorations"; } } } return SPV_SUCCESS; } // Checks whether proper decorations have been applied to the entry points. spv_result_t CheckDecorationsOfEntryPoints(ValidationState_t& vstate) { for (uint32_t entry_point : vstate.entry_points()) { const auto& descs = vstate.entry_point_descriptions(entry_point); int num_builtin_block_inputs = 0; int num_builtin_block_outputs = 0; int num_workgroup_variables = 0; int num_workgroup_variables_with_block = 0; int num_workgroup_variables_with_aliased = 0; bool has_task_payload = false; for (const auto& desc : descs) { std::unordered_set seen_vars; std::unordered_set input_var_builtin; std::unordered_set output_var_builtin; for (auto interface : desc.interfaces) { Instruction* var_instr = vstate.FindDef(interface); if (!var_instr || (spv::Op::OpVariable != var_instr->opcode() && spv::Op::OpUntypedVariableKHR != var_instr->opcode())) { return vstate.diag(SPV_ERROR_INVALID_ID, var_instr) << "Interfaces passed to OpEntryPoint must be variables. " "Found Op" << spvOpcodeString(var_instr->opcode()) << "."; } const bool untyped_pointers = var_instr->opcode() == spv::Op::OpUntypedVariableKHR; const auto sc_index = 2u; const spv::StorageClass storage_class = var_instr->GetOperandAs(sc_index); if (vstate.version() >= SPV_SPIRV_VERSION_WORD(1, 4)) { // SPV_EXT_mesh_shader, at most one task payload is permitted // per entry point if (storage_class == spv::StorageClass::TaskPayloadWorkgroupEXT) { if (has_task_payload) { return vstate.diag(SPV_ERROR_INVALID_ID, var_instr) << "There can be at most one OpVariable with storage " "class TaskPayloadWorkgroupEXT associated with " "an OpEntryPoint"; } has_task_payload = true; } } if (vstate.version() >= SPV_SPIRV_VERSION_WORD(1, 4)) { // Starting in 1.4, OpEntryPoint must list all global variables // it statically uses and those interfaces must be unique. if (storage_class == spv::StorageClass::Function) { return vstate.diag(SPV_ERROR_INVALID_ID, var_instr) << "OpEntryPoint interfaces should only list global " "variables"; } if (!seen_vars.insert(var_instr).second) { return vstate.diag(SPV_ERROR_INVALID_ID, var_instr) << "Non-unique OpEntryPoint interface " << vstate.getIdName(interface) << " is disallowed"; } } else { if (storage_class != spv::StorageClass::Input && storage_class != spv::StorageClass::Output) { return vstate.diag(SPV_ERROR_INVALID_ID, var_instr) << "OpEntryPoint interfaces must be OpVariables with " "Storage Class of Input(1) or Output(3). Found Storage " "Class " << uint32_t(storage_class) << " for Entry Point id " << entry_point << "."; } } // It is guaranteed (by validator ID checks) that ptr_instr is // OpTypePointer. Word 3 of this instruction is the type being pointed // to. For untyped variables, the pointee type comes from the data type // operand. const uint32_t type_id = untyped_pointers ? var_instr->word(4) : vstate.FindDef(var_instr->word(1))->word(3); Instruction* type_instr = vstate.FindDef(type_id); const bool is_struct = type_instr && spv::Op::OpTypeStruct == type_instr->opcode(); // Search all Built-in (on the variable or the struct) bool has_built_in = false; for (auto& dec : vstate.id_decorations(is_struct ? type_id : interface)) { if (dec.dec_type() != spv::Decoration::BuiltIn) continue; has_built_in = true; if (!spvIsVulkanEnv(vstate.context()->target_env)) continue; const spv::BuiltIn builtin = dec.builtin(); if (storage_class == spv::StorageClass::Input) { if (!input_var_builtin.insert(builtin).second) { return vstate.diag(SPV_ERROR_INVALID_ID, var_instr) << vstate.VkErrorID(9658) << "OpEntryPoint contains duplicate input variables " "with " << vstate.grammar().lookupOperandName( SPV_OPERAND_TYPE_BUILT_IN, (uint32_t)builtin) << " builtin"; } } if (storage_class == spv::StorageClass::Output) { if (!output_var_builtin.insert(builtin).second) { return vstate.diag(SPV_ERROR_INVALID_ID, var_instr) << vstate.VkErrorID(9659) << "OpEntryPoint contains duplicate output variables " "with " << vstate.grammar().lookupOperandName( SPV_OPERAND_TYPE_BUILT_IN, (uint32_t)builtin) << " builtin"; } } } if (has_built_in) { if (auto error = CheckBuiltInVariable(interface, vstate)) return error; if (is_struct) { if (!isBlock(type_id, vstate)) { return vstate.diag(SPV_ERROR_INVALID_DATA, vstate.FindDef(type_id)) << vstate.VkErrorID(4919) << "Interface struct has no Block decoration but has " "BuiltIn members. " "Location decorations must be used on each member of " "OpVariable with a structure type that is a block not " "decorated with Location."; } if (storage_class == spv::StorageClass::Input) ++num_builtin_block_inputs; if (storage_class == spv::StorageClass::Output) ++num_builtin_block_outputs; if (num_builtin_block_inputs > 1 || num_builtin_block_outputs > 1) break; } } if (storage_class == spv::StorageClass::Workgroup) { ++num_workgroup_variables; if (type_instr) { if (spv::Op::OpTypeStruct == type_instr->opcode()) { if (hasDecoration(type_id, spv::Decoration::Block, vstate)) { ++num_workgroup_variables_with_block; } else if (untyped_pointers && vstate.HasCapability(spv::Capability::Shader)) { return vstate.diag(SPV_ERROR_INVALID_ID, var_instr) << "Untyped workgroup variables in shaders must be " "block decorated"; } if (hasDecoration(var_instr->id(), spv::Decoration::Aliased, vstate)) ++num_workgroup_variables_with_aliased; } else if (untyped_pointers && vstate.HasCapability(spv::Capability::Shader)) { return vstate.diag(SPV_ERROR_INVALID_ID, var_instr) << "Untyped workgroup variables in shaders must be block " "decorated structs"; } } } if (spvIsVulkanEnv(vstate.context()->target_env)) { const auto* models = vstate.GetExecutionModels(entry_point); const bool has_frag = models->find(spv::ExecutionModel::Fragment) != models->end(); const bool has_vert = models->find(spv::ExecutionModel::Vertex) != models->end(); for (const auto& decoration : vstate.id_decorations(var_instr->id())) { if (decoration == spv::Decoration::Flat || decoration == spv::Decoration::NoPerspective || decoration == spv::Decoration::Sample || decoration == spv::Decoration::Centroid) { // VUID 04670 already validates these decorations are input/output if (storage_class == spv::StorageClass::Input && (models->size() > 1 || has_vert)) { return vstate.diag(SPV_ERROR_INVALID_ID, var_instr) << vstate.VkErrorID(6202) << vstate.SpvDecorationString(decoration.dec_type()) << " decorated variable must not be used in vertex " "execution model as an Input storage class for Entry " "Point id " << entry_point << "."; } else if (storage_class == spv::StorageClass::Output && (models->size() > 1 || has_frag)) { return vstate.diag(SPV_ERROR_INVALID_ID, var_instr) << vstate.VkErrorID(6201) << vstate.SpvDecorationString(decoration.dec_type()) << " decorated variable must not be used in fragment " "execution model as an Output storage class for " "Entry Point id " << entry_point << "."; } } } const bool has_flat = hasDecoration(var_instr->id(), spv::Decoration::Flat, vstate); if (has_frag && storage_class == spv::StorageClass::Input && !has_flat && ((vstate.IsFloatScalarType(type_id) && vstate.GetBitWidth(type_id) == 64) || vstate.IsIntScalarOrVectorType(type_id))) { return vstate.diag(SPV_ERROR_INVALID_ID, var_instr) << vstate.VkErrorID(4744) << "Fragment OpEntryPoint operand " << interface << " with Input interfaces with integer or " "float type must have a Flat decoration " "for Entry Point id " << entry_point << "."; } } } if (num_builtin_block_inputs > 1 || num_builtin_block_outputs > 1) { return vstate.diag(SPV_ERROR_INVALID_BINARY, vstate.FindDef(entry_point)) << "There must be at most one object per Storage Class that can " "contain a structure type containing members decorated with " "BuiltIn, consumed per entry-point. Entry Point id " << entry_point << " does not meet this requirement."; } // The LinkageAttributes Decoration cannot be applied to functions // targeted by an OpEntryPoint instruction for (auto& decoration : vstate.id_decorations(entry_point)) { if (spv::Decoration::LinkageAttributes == decoration.dec_type()) { const std::string linkage_name = spvtools::utils::MakeString(decoration.params()); return vstate.diag(SPV_ERROR_INVALID_BINARY, vstate.FindDef(entry_point)) << "The LinkageAttributes Decoration (Linkage name: " << linkage_name << ") cannot be applied to function id " << entry_point << " because it is targeted by an OpEntryPoint instruction."; } } const bool workgroup_blocks_allowed = vstate.HasCapability( spv::Capability::WorkgroupMemoryExplicitLayoutKHR); if (workgroup_blocks_allowed && !vstate.HasCapability(spv::Capability::UntypedPointersKHR) && num_workgroup_variables > 0 && num_workgroup_variables_with_block > 0) { if (num_workgroup_variables != num_workgroup_variables_with_block) { return vstate.diag(SPV_ERROR_INVALID_BINARY, vstate.FindDef(entry_point)) << "When declaring WorkgroupMemoryExplicitLayoutKHR, " "either all or none of the Workgroup Storage Class " "variables " "in the entry point interface must point to struct types " "decorated with Block (unless the " "UntypedPointersKHR capability is declared). " "Entry point id " << entry_point << " does not meet this requirement."; } if (num_workgroup_variables_with_block > 1 && num_workgroup_variables_with_block != num_workgroup_variables_with_aliased) { return vstate.diag(SPV_ERROR_INVALID_BINARY, vstate.FindDef(entry_point)) << "When declaring WorkgroupMemoryExplicitLayoutKHR, " "if more than one Workgroup Storage Class variable in " "the entry point interface point to a type decorated " "with Block, all of them must be decorated with Aliased " "(unless the UntypedPointerWorkgroupKHR capability is " "declared). Entry point id " << entry_point << " does not meet this requirement."; } } else if (!workgroup_blocks_allowed && num_workgroup_variables_with_block > 0) { return vstate.diag(SPV_ERROR_INVALID_BINARY, vstate.FindDef(entry_point)) << "Workgroup Storage Class variables can't be decorated with " "Block unless declaring the WorkgroupMemoryExplicitLayoutKHR " "capability."; } } } return SPV_SUCCESS; } // Load |constraints| with all the member constraints for structs contained // within the given array type. void ComputeMemberConstraintsForArray(MemberConstraints* constraints, uint32_t array_id, const LayoutConstraints& inherited, ValidationState_t& vstate); // Load |constraints| with all the member constraints for the given struct, // and all its contained structs. void ComputeMemberConstraintsForStruct(MemberConstraints* constraints, uint32_t struct_id, const LayoutConstraints& inherited, ValidationState_t& vstate) { assert(constraints); const auto& members = getStructMembers(struct_id, vstate); for (uint32_t memberIdx = 0, numMembers = uint32_t(members.size()); memberIdx < numMembers; memberIdx++) { LayoutConstraints& constraint = (*constraints)[std::make_pair(struct_id, memberIdx)]; constraint = inherited; auto member_decorations = vstate.id_member_decorations(struct_id, memberIdx); for (auto decoration = member_decorations.begin; decoration != member_decorations.end; ++decoration) { assert(decoration->struct_member_index() == (int)memberIdx); switch (decoration->dec_type()) { case spv::Decoration::RowMajor: constraint.majorness = kRowMajor; break; case spv::Decoration::ColMajor: constraint.majorness = kColumnMajor; break; case spv::Decoration::MatrixStride: constraint.matrix_stride = decoration->params()[0]; break; default: break; } } // Now recurse auto member_type_id = members[memberIdx]; const auto member_type_inst = vstate.FindDef(member_type_id); const auto opcode = member_type_inst->opcode(); switch (opcode) { case spv::Op::OpTypeArray: case spv::Op::OpTypeRuntimeArray: ComputeMemberConstraintsForArray(constraints, member_type_id, inherited, vstate); break; case spv::Op::OpTypeStruct: ComputeMemberConstraintsForStruct(constraints, member_type_id, inherited, vstate); break; default: break; } } } void ComputeMemberConstraintsForArray(MemberConstraints* constraints, uint32_t array_id, const LayoutConstraints& inherited, ValidationState_t& vstate) { assert(constraints); auto elem_type_id = vstate.FindDef(array_id)->words()[2]; const auto elem_type_inst = vstate.FindDef(elem_type_id); const auto opcode = elem_type_inst->opcode(); switch (opcode) { case spv::Op::OpTypeArray: case spv::Op::OpTypeRuntimeArray: ComputeMemberConstraintsForArray(constraints, elem_type_id, inherited, vstate); break; case spv::Op::OpTypeStruct: ComputeMemberConstraintsForStruct(constraints, elem_type_id, inherited, vstate); break; default: break; } } spv_result_t CheckDecorationsOfBuffers(ValidationState_t& vstate) { // Set of entry points that are known to use a push constant. std::unordered_set uses_push_constant; for (const auto& inst : vstate.ordered_instructions()) { const auto& words = inst.words(); auto type_id = inst.type_id(); const Instruction* type_inst = vstate.FindDef(type_id); bool scalar_block_layout = false; MemberConstraints constraints; if (spv::Op::OpVariable == inst.opcode() || spv::Op::OpUntypedVariableKHR == inst.opcode()) { const bool untyped_pointer = inst.opcode() == spv::Op::OpUntypedVariableKHR; const auto var_id = inst.id(); // For storage class / decoration combinations, see Vulkan 14.5.4 "Offset // and Stride Assignment". const auto storageClassVal = words[3]; const auto storageClass = spv::StorageClass(storageClassVal); const bool uniform = storageClass == spv::StorageClass::Uniform; const bool uniform_constant = storageClass == spv::StorageClass::UniformConstant; const bool push_constant = storageClass == spv::StorageClass::PushConstant; const bool storage_buffer = storageClass == spv::StorageClass::StorageBuffer; if (spvIsVulkanEnv(vstate.context()->target_env)) { // Vulkan: There must be no more than one PushConstant block per entry // point. if (push_constant) { auto entry_points = vstate.EntryPointReferences(var_id); for (auto ep_id : entry_points) { const bool already_used = !uses_push_constant.insert(ep_id).second; if (already_used) { return vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(var_id)) << vstate.VkErrorID(6674) << "Entry point id '" << ep_id << "' uses more than one PushConstant interface.\n" << "From Vulkan spec:\n" << "There must be no more than one push constant block " << "statically used per shader entry point."; } } } // Vulkan: Check DescriptorSet and Binding decoration for // UniformConstant which cannot be a struct. if (uniform_constant) { auto entry_points = vstate.EntryPointReferences(var_id); if (!entry_points.empty() && !hasDecoration(var_id, spv::Decoration::DescriptorSet, vstate)) { return vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(var_id)) << vstate.VkErrorID(6677) << "UniformConstant id '" << var_id << "' is missing DescriptorSet decoration.\n" << "From Vulkan spec:\n" << "These variables must have DescriptorSet and Binding " "decorations specified"; } if (!entry_points.empty() && !hasDecoration(var_id, spv::Decoration::Binding, vstate)) { return vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(var_id)) << vstate.VkErrorID(6677) << "UniformConstant id '" << var_id << "' is missing Binding decoration.\n" << "From Vulkan spec:\n" << "These variables must have DescriptorSet and Binding " "decorations specified"; } } } if (spvIsOpenGLEnv(vstate.context()->target_env)) { bool has_block = hasDecoration(var_id, spv::Decoration::Block, vstate); bool has_buffer_block = hasDecoration(var_id, spv::Decoration::BufferBlock, vstate); if ((uniform && (has_block || has_buffer_block)) || (storage_buffer && has_block)) { auto entry_points = vstate.EntryPointReferences(var_id); if (!entry_points.empty() && !hasDecoration(var_id, spv::Decoration::Binding, vstate)) { return vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(var_id)) << (uniform ? "Uniform" : "Storage Buffer") << " id '" << var_id << "' is missing Binding decoration.\n" << "From ARB_gl_spirv extension:\n" << "Uniform and shader storage block variables must " << "also be decorated with a *Binding*."; } } } const bool phys_storage_buffer = storageClass == spv::StorageClass::PhysicalStorageBuffer; const bool workgroup = storageClass == spv::StorageClass::Workgroup && vstate.HasCapability( spv::Capability::WorkgroupMemoryExplicitLayoutKHR); if (uniform || push_constant || storage_buffer || phys_storage_buffer || workgroup) { const auto ptrInst = vstate.FindDef(words[1]); assert(spv::Op::OpTypePointer == ptrInst->opcode() || spv::Op::OpTypeUntypedPointerKHR == ptrInst->opcode()); auto id = untyped_pointer ? (words.size() > 4 ? words[4] : 0) : ptrInst->words()[3]; if (id != 0) { auto id_inst = vstate.FindDef(id); // Jump through one level of arraying. if (!workgroup && (id_inst->opcode() == spv::Op::OpTypeArray || id_inst->opcode() == spv::Op::OpTypeRuntimeArray)) { id = id_inst->GetOperandAs(1u); id_inst = vstate.FindDef(id); } // Struct requirement is checked on variables so just move on here. if (spv::Op::OpTypeStruct != id_inst->opcode()) continue; ComputeMemberConstraintsForStruct(&constraints, id, LayoutConstraints(), vstate); } // Prepare for messages const char* sc_str = uniform ? "Uniform" : (push_constant ? "PushConstant" : (workgroup ? "Workgroup" : "StorageBuffer")); if (spvIsVulkanEnv(vstate.context()->target_env)) { const bool block = hasDecoration(id, spv::Decoration::Block, vstate); const bool buffer_block = hasDecoration(id, spv::Decoration::BufferBlock, vstate); if (storage_buffer && buffer_block) { return vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(var_id)) << vstate.VkErrorID(6675) << "Storage buffer id '" << var_id << " In Vulkan, BufferBlock is disallowed on variables in " "the StorageBuffer storage class"; } // Vulkan: Check Block decoration for PushConstant, Uniform // and StorageBuffer variables. Uniform can also use BufferBlock. if (push_constant && !block) { return vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(id)) << vstate.VkErrorID(6675) << "PushConstant id '" << id << "' is missing Block decoration.\n" << "From Vulkan spec:\n" << "Such variables must be identified with a Block " "decoration"; } if (storage_buffer && !block) { return vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(id)) << vstate.VkErrorID(6675) << "StorageBuffer id '" << id << "' is missing Block decoration.\n" << "From Vulkan spec:\n" << "Such variables must be identified with a Block " "decoration"; } if (uniform && !block && !buffer_block) { return vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(id)) << vstate.VkErrorID(6676) << "Uniform id '" << id << "' is missing Block or BufferBlock decoration.\n" << "From Vulkan spec:\n" << "Such variables must be identified with a Block or " "BufferBlock decoration"; } // Vulkan: Check DescriptorSet and Binding decoration for // Uniform and StorageBuffer variables. if (uniform || storage_buffer) { auto entry_points = vstate.EntryPointReferences(var_id); if (!entry_points.empty() && !hasDecoration(var_id, spv::Decoration::DescriptorSet, vstate)) { return vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(var_id)) << vstate.VkErrorID(6677) << sc_str << " id '" << var_id << "' is missing DescriptorSet decoration.\n" << "From Vulkan spec:\n" << "These variables must have DescriptorSet and Binding " "decorations specified"; } if (!entry_points.empty() && !hasDecoration(var_id, spv::Decoration::Binding, vstate)) { return vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(var_id)) << vstate.VkErrorID(6677) << sc_str << " id '" << var_id << "' is missing Binding decoration.\n" << "From Vulkan spec:\n" << "These variables must have DescriptorSet and Binding " "decorations specified"; } } } if (id != 0) { for (const auto& dec : vstate.id_decorations(id)) { const bool blockDeco = spv::Decoration::Block == dec.dec_type(); const bool bufferDeco = spv::Decoration::BufferBlock == dec.dec_type(); const bool blockRules = uniform && blockDeco; const bool bufferRules = (uniform && bufferDeco) || ((push_constant || storage_buffer || phys_storage_buffer || workgroup) && blockDeco); if (uniform && blockDeco) { vstate.RegisterPointerToUniformBlock(ptrInst->id()); vstate.RegisterStructForUniformBlock(id); } if ((uniform && bufferDeco) || ((storage_buffer || phys_storage_buffer) && blockDeco)) { vstate.RegisterPointerToStorageBuffer(ptrInst->id()); vstate.RegisterStructForStorageBuffer(id); } if (blockRules || bufferRules) { const char* deco_str = blockDeco ? "Block" : "BufferBlock"; spv_result_t recursive_status = SPV_SUCCESS; scalar_block_layout = workgroup ? vstate.options()->workgroup_scalar_block_layout : vstate.options()->scalar_block_layout; if (isMissingOffsetInStruct(id, vstate)) { return vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(id)) << "Structure id " << id << " decorated as " << deco_str << " must be explicitly laid out with Offset " "decorations."; } if (!checkForRequiredDecoration( id, [](spv::Decoration d) { return d == spv::Decoration::ArrayStride; }, spv::Op::OpTypeArray, vstate)) { return vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(id)) << "Structure id " << id << " decorated as " << deco_str << " must be explicitly laid out with ArrayStride " "decorations."; } if (!checkForRequiredDecoration( id, [](spv::Decoration d) { return d == spv::Decoration::MatrixStride; }, spv::Op::OpTypeMatrix, vstate)) { return vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(id)) << "Structure id " << id << " decorated as " << deco_str << " must be explicitly laid out with MatrixStride " "decorations."; } if (!checkForRequiredDecoration( id, [](spv::Decoration d) { return d == spv::Decoration::RowMajor || d == spv::Decoration::ColMajor; }, spv::Op::OpTypeMatrix, vstate)) { return vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(id)) << "Structure id " << id << " decorated as " << deco_str << " must be explicitly laid out with RowMajor or " "ColMajor decorations."; } if (spvIsVulkanEnv(vstate.context()->target_env)) { if (blockRules && (SPV_SUCCESS != (recursive_status = checkLayout(id, sc_str, deco_str, true, scalar_block_layout, 0, constraints, vstate)))) { return recursive_status; } else if (bufferRules && (SPV_SUCCESS != (recursive_status = checkLayout( id, sc_str, deco_str, false, scalar_block_layout, 0, constraints, vstate)))) { return recursive_status; } } } } } } } else if (type_inst && type_inst->opcode() == spv::Op::OpTypePointer && type_inst->GetOperandAs(1u) == spv::StorageClass::PhysicalStorageBuffer) { const bool buffer = true; const auto pointee_type_id = type_inst->GetOperandAs(2u); const auto* data_type_inst = vstate.FindDef(pointee_type_id); scalar_block_layout = vstate.options()->scalar_block_layout; if (data_type_inst->opcode() == spv::Op::OpTypeStruct) { ComputeMemberConstraintsForStruct(&constraints, pointee_type_id, LayoutConstraints(), vstate); } if (auto res = checkLayout(pointee_type_id, "PhysicalStorageBuffer", "Block", !buffer, scalar_block_layout, 0, constraints, vstate)) { return res; } } else if (vstate.HasCapability(spv::Capability::UntypedPointersKHR) && spvIsVulkanEnv(vstate.context()->target_env)) { // Untyped variables are checked above. Here we check that instructions // using an untyped pointer have a valid layout. uint32_t ptr_ty_id = 0; uint32_t data_type_id = 0; switch (inst.opcode()) { case spv::Op::OpUntypedAccessChainKHR: case spv::Op::OpUntypedInBoundsAccessChainKHR: case spv::Op::OpUntypedPtrAccessChainKHR: case spv::Op::OpUntypedInBoundsPtrAccessChainKHR: ptr_ty_id = inst.type_id(); data_type_id = inst.GetOperandAs(2); break; case spv::Op::OpLoad: if (vstate.GetIdOpcode(vstate.GetOperandTypeId(&inst, 2)) == spv::Op::OpTypeUntypedPointerKHR) { const auto ptr_id = inst.GetOperandAs(2); ptr_ty_id = vstate.FindDef(ptr_id)->type_id(); data_type_id = inst.type_id(); } break; case spv::Op::OpStore: if (vstate.GetIdOpcode(vstate.GetOperandTypeId(&inst, 0)) == spv::Op::OpTypeUntypedPointerKHR) { const auto ptr_id = inst.GetOperandAs(0); ptr_ty_id = vstate.FindDef(ptr_id)->type_id(); data_type_id = vstate.GetOperandTypeId(&inst, 1); } break; case spv::Op::OpUntypedArrayLengthKHR: ptr_ty_id = vstate.FindDef(inst.GetOperandAs(3))->type_id(); data_type_id = inst.GetOperandAs(2); break; default: break; } if (ptr_ty_id == 0 || data_type_id == 0) { // Not an untyped pointer. continue; } const auto sc = vstate.FindDef(ptr_ty_id)->GetOperandAs(1); const char* sc_str = sc == spv::StorageClass::Uniform ? "Uniform" : (sc == spv::StorageClass::PushConstant ? "PushConstant" : (sc == spv::StorageClass::Workgroup ? "Workgroup" : "StorageBuffer")); auto data_type = vstate.FindDef(data_type_id); scalar_block_layout = sc == spv::StorageClass::Workgroup ? vstate.options()->workgroup_scalar_block_layout : vstate.options()->scalar_block_layout; // If the data type is an array that contains a Block- or // BufferBlock-decorated struct, then use the struct for layout checks // instead of the array. In this case, the array represents a descriptor // array which should not have an explicit layout. if (data_type->opcode() == spv::Op::OpTypeArray || data_type->opcode() == spv::Op::OpTypeRuntimeArray) { const auto ele_type = vstate.FindDef(data_type->GetOperandAs(1u)); if (ele_type->opcode() == spv::Op::OpTypeStruct && (vstate.HasDecoration(ele_type->id(), spv::Decoration::Block) || vstate.HasDecoration(ele_type->id(), spv::Decoration::BufferBlock))) { data_type = ele_type; data_type_id = ele_type->id(); } } // Assume uniform storage class uses block rules unless we see a // BufferBlock decorated struct in the data type. bool bufferRules = sc == spv::StorageClass::Uniform ? false : true; if (data_type->opcode() == spv::Op::OpTypeStruct) { if (sc == spv::StorageClass::Uniform) { bufferRules = vstate.HasDecoration(data_type_id, spv::Decoration::BufferBlock); } ComputeMemberConstraintsForStruct(&constraints, data_type_id, LayoutConstraints(), vstate); } const char* deco_str = bufferRules ? (sc == spv::StorageClass::Uniform ? "BufferBlock" : "Block") : "Block"; if (auto result = checkLayout(data_type_id, sc_str, deco_str, !bufferRules, scalar_block_layout, 0, constraints, vstate)) { return result; } } } return SPV_SUCCESS; } // Returns true if |decoration| cannot be applied to the same id more than once. bool AtMostOncePerId(spv::Decoration decoration) { return decoration != spv::Decoration::UserSemantic && decoration != spv::Decoration::FuncParamAttr; } // Returns true if |decoration| cannot be applied to the same member more than // once. bool AtMostOncePerMember(spv::Decoration decoration) { return decoration != spv::Decoration::UserSemantic; } spv_result_t CheckDecorationsCompatibility(ValidationState_t& vstate) { using PerIDKey = std::tuple; using PerMemberKey = std::tuple; // An Array of pairs where the decorations in the pair cannot both be applied // to the same id. static const spv::Decoration mutually_exclusive_per_id[][2] = { {spv::Decoration::Block, spv::Decoration::BufferBlock}, {spv::Decoration::Restrict, spv::Decoration::Aliased}, {spv::Decoration::RestrictPointer, spv::Decoration::AliasedPointer}}; static const auto num_mutually_exclusive_per_id_pairs = sizeof(mutually_exclusive_per_id) / (2 * sizeof(spv::Decoration)); // An Array of pairs where the decorations in the pair cannot both be applied // to the same member. static const spv::Decoration mutually_exclusive_per_member[][2] = { {spv::Decoration::RowMajor, spv::Decoration::ColMajor}}; static const auto num_mutually_exclusive_per_mem_pairs = sizeof(mutually_exclusive_per_member) / (2 * sizeof(spv::Decoration)); std::set seen_per_id; std::set seen_per_member; for (const auto& inst : vstate.ordered_instructions()) { const auto& words = inst.words(); if (spv::Op::OpDecorate == inst.opcode()) { const auto id = words[1]; const auto dec_type = static_cast(words[2]); const auto k = PerIDKey(dec_type, id); const auto already_used = !seen_per_id.insert(k).second; if (already_used && AtMostOncePerId(dec_type)) { return vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(id)) << "ID '" << id << "' decorated with " << vstate.SpvDecorationString(dec_type) << " multiple times is not allowed."; } // Verify certain mutually exclusive decorations are not both applied on // an ID. for (uint32_t pair_idx = 0; pair_idx < num_mutually_exclusive_per_id_pairs; ++pair_idx) { spv::Decoration excl_dec_type = spv::Decoration::Max; if (mutually_exclusive_per_id[pair_idx][0] == dec_type) { excl_dec_type = mutually_exclusive_per_id[pair_idx][1]; } else if (mutually_exclusive_per_id[pair_idx][1] == dec_type) { excl_dec_type = mutually_exclusive_per_id[pair_idx][0]; } else { continue; } const auto excl_k = PerIDKey(excl_dec_type, id); if (seen_per_id.find(excl_k) != seen_per_id.end()) { return vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(id)) << "ID '" << id << "' decorated with both " << vstate.SpvDecorationString(dec_type) << " and " << vstate.SpvDecorationString(excl_dec_type) << " is not allowed."; } } } else if (spv::Op::OpMemberDecorate == inst.opcode()) { const auto id = words[1]; const auto member_id = words[2]; const auto dec_type = static_cast(words[3]); const auto k = PerMemberKey(dec_type, id, member_id); const auto already_used = !seen_per_member.insert(k).second; if (already_used && AtMostOncePerMember(dec_type)) { return vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(id)) << "ID '" << id << "', member '" << member_id << "' decorated with " << vstate.SpvDecorationString(dec_type) << " multiple times is not allowed."; } // Verify certain mutually exclusive decorations are not both applied on // a (ID, member) tuple. for (uint32_t pair_idx = 0; pair_idx < num_mutually_exclusive_per_mem_pairs; ++pair_idx) { spv::Decoration excl_dec_type = spv::Decoration::Max; if (mutually_exclusive_per_member[pair_idx][0] == dec_type) { excl_dec_type = mutually_exclusive_per_member[pair_idx][1]; } else if (mutually_exclusive_per_member[pair_idx][1] == dec_type) { excl_dec_type = mutually_exclusive_per_member[pair_idx][0]; } else { continue; } const auto excl_k = PerMemberKey(excl_dec_type, id, member_id); if (seen_per_member.find(excl_k) != seen_per_member.end()) { return vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(id)) << "ID '" << id << "', member '" << member_id << "' decorated with both " << vstate.SpvDecorationString(dec_type) << " and " << vstate.SpvDecorationString(excl_dec_type) << " is not allowed."; } } } } return SPV_SUCCESS; } spv_result_t CheckVulkanMemoryModelDeprecatedDecorations( ValidationState_t& vstate) { if (vstate.memory_model() != spv::MemoryModel::VulkanKHR) return SPV_SUCCESS; std::string msg; std::ostringstream str(msg); for (const auto& def : vstate.all_definitions()) { const auto inst = def.second; const auto id = inst->id(); for (const auto& dec : vstate.id_decorations(id)) { const auto member = dec.struct_member_index(); if (dec.dec_type() == spv::Decoration::Coherent || dec.dec_type() == spv::Decoration::Volatile) { str << (dec.dec_type() == spv::Decoration::Coherent ? "Coherent" : "Volatile"); str << " decoration targeting " << vstate.getIdName(id); if (member != Decoration::kInvalidMember) { str << " (member index " << member << ")"; } str << " is banned when using the Vulkan memory model."; return vstate.diag(SPV_ERROR_INVALID_ID, inst) << str.str(); } } } return SPV_SUCCESS; } // Returns SPV_SUCCESS if validation rules are satisfied for FPRoundingMode // decorations. Otherwise emits a diagnostic and returns something other than // SPV_SUCCESS. spv_result_t CheckFPRoundingModeForShaders(ValidationState_t& vstate, const Instruction& inst, const Decoration& decoration) { // Validates width-only conversion instruction for floating-point object // i.e., OpFConvert if (inst.opcode() != spv::Op::OpFConvert) { return vstate.diag(SPV_ERROR_INVALID_ID, &inst) << "FPRoundingMode decoration can be applied only to a " "width-only conversion instruction for floating-point " "object."; } if (spvIsVulkanEnv(vstate.context()->target_env)) { const auto mode = spv::FPRoundingMode(decoration.params()[0]); if ((mode != spv::FPRoundingMode::RTE) && (mode != spv::FPRoundingMode::RTZ)) { return vstate.diag(SPV_ERROR_INVALID_ID, &inst) << vstate.VkErrorID(4675) << "In Vulkan, the FPRoundingMode mode must only by RTE or RTZ."; } } // Validates Object operand of an OpStore for (const auto& use : inst.uses()) { const auto store = use.first; if (store->opcode() == spv::Op::OpFConvert) continue; if (spvOpcodeIsDebug(store->opcode())) continue; if (store->IsNonSemantic()) continue; if (spvOpcodeIsDecoration(store->opcode())) continue; if (store->opcode() != spv::Op::OpStore) { return vstate.diag(SPV_ERROR_INVALID_ID, &inst) << "FPRoundingMode decoration can be applied only to the " "Object operand of an OpStore."; } if (use.second != 2) { return vstate.diag(SPV_ERROR_INVALID_ID, &inst) << "FPRoundingMode decoration can be applied only to the " "Object operand of an OpStore."; } const auto ptr_inst = vstate.FindDef(store->GetOperandAs(0)); const auto ptr_type = vstate.FindDef(ptr_inst->GetOperandAs(0)); const auto half_float_id = ptr_type->GetOperandAs(2); if (!vstate.IsFloatScalarOrVectorType(half_float_id) || vstate.GetBitWidth(half_float_id) != 16) { return vstate.diag(SPV_ERROR_INVALID_ID, &inst) << "FPRoundingMode decoration can be applied only to the " "Object operand of an OpStore storing through a pointer " "to " "a 16-bit floating-point scalar or vector object."; } // Validates storage class of the pointer to the OpStore const auto storage = ptr_type->GetOperandAs(1); if (storage != spv::StorageClass::StorageBuffer && storage != spv::StorageClass::Uniform && storage != spv::StorageClass::PushConstant && storage != spv::StorageClass::Input && storage != spv::StorageClass::Output && storage != spv::StorageClass::PhysicalStorageBuffer) { return vstate.diag(SPV_ERROR_INVALID_ID, &inst) << "FPRoundingMode decoration can be applied only to the " "Object operand of an OpStore in the StorageBuffer, " "PhysicalStorageBuffer, Uniform, PushConstant, Input, or " "Output Storage Classes."; } } return SPV_SUCCESS; } // Returns SPV_SUCCESS if validation rules are satisfied for the NonWritable // decoration. Otherwise emits a diagnostic and returns something other than // SPV_SUCCESS. The |inst| parameter is the object being decorated. This must // be called after TypePass and AnnotateCheckDecorationsOfBuffers are called. spv_result_t CheckNonWritableDecoration(ValidationState_t& vstate, const Instruction& inst, const Decoration& decoration) { assert(inst.id() && "Parser ensures the target of the decoration has an ID"); if (decoration.struct_member_index() == Decoration::kInvalidMember) { // The target must be a memory object declaration. // First, it must be a variable or function parameter. const auto opcode = inst.opcode(); const auto type_id = inst.type_id(); if (opcode != spv::Op::OpVariable && opcode != spv::Op::OpUntypedVariableKHR && opcode != spv::Op::OpFunctionParameter && opcode != spv::Op::OpRawAccessChainNV) { return vstate.diag(SPV_ERROR_INVALID_ID, &inst) << "Target of NonWritable decoration must be a memory object " "declaration (a variable or a function parameter)"; } const auto var_storage_class = opcode == spv::Op::OpVariable ? inst.GetOperandAs(2) : opcode == spv::Op::OpUntypedVariableKHR ? inst.GetOperandAs(3) : spv::StorageClass::Max; if ((var_storage_class == spv::StorageClass::Function || var_storage_class == spv::StorageClass::Private) && vstate.features().nonwritable_var_in_function_or_private) { // New permitted feature in SPIR-V 1.4. } else if ( // It may point to a UBO, SSBO, storage image, or raw access chain. vstate.IsPointerToUniformBlock(type_id) || vstate.IsPointerToStorageBuffer(type_id) || vstate.IsPointerToStorageImage(type_id) || opcode == spv::Op::OpRawAccessChainNV) { } else { return vstate.diag(SPV_ERROR_INVALID_ID, &inst) << "Target of NonWritable decoration is invalid: must point to a " "storage image, uniform block, " << (vstate.features().nonwritable_var_in_function_or_private ? "storage buffer, or variable in Private or Function " "storage class" : "or storage buffer"); } } return SPV_SUCCESS; } // Returns SPV_SUCCESS if validation rules are satisfied for Uniform or // UniformId decorations. Otherwise emits a diagnostic and returns something // other than SPV_SUCCESS. Assumes each decoration on a group has been // propagated down to the group members. The |inst| parameter is the object // being decorated. spv_result_t CheckUniformDecoration(ValidationState_t& vstate, const Instruction& inst, const Decoration& decoration) { const char* const dec_name = decoration.dec_type() == spv::Decoration::Uniform ? "Uniform" : "UniformId"; // Uniform or UniformId must decorate an "object" // - has a result ID // - is an instantiation of a non-void type. So it has a type ID, and that // type is not void. // We already know the result ID is non-zero. if (inst.type_id() == 0) { return vstate.diag(SPV_ERROR_INVALID_ID, &inst) << dec_name << " decoration applied to a non-object"; } if (Instruction* type_inst = vstate.FindDef(inst.type_id())) { if (type_inst->opcode() == spv::Op::OpTypeVoid) { return vstate.diag(SPV_ERROR_INVALID_ID, &inst) << dec_name << " decoration applied to a value with void type"; } } else { // We might never get here because this would have been rejected earlier in // the flow. return vstate.diag(SPV_ERROR_INVALID_ID, &inst) << dec_name << " decoration applied to an object with invalid type"; } // Use of Uniform with OpDecorate is checked elsewhere. // Use of UniformId with OpDecorateId is checked elsewhere. if (decoration.dec_type() == spv::Decoration::UniformId) { assert(decoration.params().size() == 1 && "Grammar ensures UniformId has one parameter"); // The scope id is an execution scope. if (auto error = ValidateExecutionScope(vstate, &inst, decoration.params()[0])) return error; } return SPV_SUCCESS; } // Returns SPV_SUCCESS if validation rules are satisfied for NoSignedWrap or // NoUnsignedWrap decorations. Otherwise emits a diagnostic and returns // something other than SPV_SUCCESS. Assumes each decoration on a group has been // propagated down to the group members. spv_result_t CheckIntegerWrapDecoration(ValidationState_t& vstate, const Instruction& inst, const Decoration& decoration) { switch (inst.opcode()) { case spv::Op::OpIAdd: case spv::Op::OpISub: case spv::Op::OpIMul: case spv::Op::OpShiftLeftLogical: case spv::Op::OpSNegate: return SPV_SUCCESS; case spv::Op::OpExtInst: case spv::Op::OpExtInstWithForwardRefsKHR: // TODO(dneto): Only certain extended instructions allow these // decorations. For now allow anything. return SPV_SUCCESS; default: break; } return vstate.diag(SPV_ERROR_INVALID_ID, &inst) << (decoration.dec_type() == spv::Decoration::NoSignedWrap ? "NoSignedWrap" : "NoUnsignedWrap") << " decoration may not be applied to " << spvOpcodeString(inst.opcode()); } // Returns SPV_SUCCESS if validation rules are satisfied for the Component // decoration. Otherwise emits a diagnostic and returns something other than // SPV_SUCCESS. spv_result_t CheckComponentDecoration(ValidationState_t& vstate, const Instruction& inst, const Decoration& decoration) { assert(inst.id() && "Parser ensures the target of the decoration has an ID"); assert(decoration.params().size() == 1 && "Grammar ensures Component has one parameter"); uint32_t type_id; if (decoration.struct_member_index() == Decoration::kInvalidMember) { // The target must be a memory object declaration. const auto opcode = inst.opcode(); if (opcode != spv::Op::OpVariable && opcode != spv::Op::OpFunctionParameter) { return vstate.diag(SPV_ERROR_INVALID_ID, &inst) << "Target of Component decoration must be a memory object " "declaration (a variable or a function parameter)"; } // Only valid for the Input and Output Storage Classes. const auto storage_class = opcode == spv::Op::OpVariable ? inst.GetOperandAs(2) : spv::StorageClass::Max; if (storage_class != spv::StorageClass::Input && storage_class != spv::StorageClass::Output && storage_class != spv::StorageClass::Max) { return vstate.diag(SPV_ERROR_INVALID_ID, &inst) << "Target of Component decoration is invalid: must point to a " "Storage Class of Input(1) or Output(3). Found Storage " "Class " << uint32_t(storage_class); } type_id = inst.type_id(); if (vstate.IsPointerType(type_id)) { const auto pointer = vstate.FindDef(type_id); type_id = pointer->GetOperandAs(2); } } else { if (inst.opcode() != spv::Op::OpTypeStruct) { return vstate.diag(SPV_ERROR_INVALID_DATA, &inst) << "Attempted to get underlying data type via member index for " "non-struct type."; } type_id = inst.word(decoration.struct_member_index() + 2); } if (spvIsVulkanEnv(vstate.context()->target_env)) { // Strip the array, if present. while (vstate.GetIdOpcode(type_id) == spv::Op::OpTypeArray) { type_id = vstate.FindDef(type_id)->word(2u); } if (!vstate.IsIntScalarOrVectorType(type_id) && !vstate.IsFloatScalarOrVectorType(type_id)) { return vstate.diag(SPV_ERROR_INVALID_ID, &inst) << vstate.VkErrorID(10583) << "Component decoration specified for type " << vstate.getIdName(type_id) << " that is not a scalar or vector"; } const auto component = decoration.params()[0]; if (component > 3) { return vstate.diag(SPV_ERROR_INVALID_ID, &inst) << vstate.VkErrorID(4920) << "Component decoration value must not be greater than 3"; } const auto dimension = vstate.GetDimension(type_id); const auto bit_width = vstate.GetBitWidth(type_id); if (bit_width == 16 || bit_width == 32) { const auto sum_component = component + dimension; if (sum_component > 4) { return vstate.diag(SPV_ERROR_INVALID_ID, &inst) << vstate.VkErrorID(4921) << "Sequence of components starting with " << component << " and ending with " << (sum_component - 1) << " gets larger than 3"; } } else if (bit_width == 64) { if (dimension > 2) { return vstate.diag(SPV_ERROR_INVALID_ID, &inst) << vstate.VkErrorID(7703) << "Component decoration only allowed on 64-bit scalar and " "2-component vector"; } if (component == 1 || component == 3) { return vstate.diag(SPV_ERROR_INVALID_ID, &inst) << vstate.VkErrorID(4923) << "Component decoration value must not be 1 or 3 for 64-bit " "data types"; } // 64-bit is double per component dimension const auto sum_component = component + (2 * dimension); if (sum_component > 4) { return vstate.diag(SPV_ERROR_INVALID_ID, &inst) << vstate.VkErrorID(4922) << "Sequence of components starting with " << component << " and ending with " << (sum_component - 1) << " gets larger than 3"; } } } return SPV_SUCCESS; } // Returns SPV_SUCCESS if validation rules are satisfied for the Block // decoration. Otherwise emits a diagnostic and returns something other than // SPV_SUCCESS. spv_result_t CheckBlockDecoration(ValidationState_t& vstate, const Instruction& inst, const Decoration& decoration) { assert(inst.id() && "Parser ensures the target of the decoration has an ID"); if (inst.opcode() != spv::Op::OpTypeStruct) { const char* const dec_name = decoration.dec_type() == spv::Decoration::Block ? "Block" : "BufferBlock"; return vstate.diag(SPV_ERROR_INVALID_ID, &inst) << dec_name << " decoration on a non-struct type."; } return SPV_SUCCESS; } spv_result_t CheckLocationDecoration(ValidationState_t& vstate, const Instruction& inst, const Decoration& decoration) { if (inst.opcode() == spv::Op::OpVariable) return SPV_SUCCESS; if (decoration.struct_member_index() != Decoration::kInvalidMember && inst.opcode() == spv::Op::OpTypeStruct) { return SPV_SUCCESS; } return vstate.diag(SPV_ERROR_INVALID_ID, &inst) << "Location decoration can only be applied to a variable or member " "of a structure type"; } spv_result_t CheckRelaxPrecisionDecoration(ValidationState_t& vstate, const Instruction& inst, const Decoration& decoration) { // This is not the most precise check, but the rules for RelaxPrecision are // very general, and it will be difficult to implement precisely. For now, // I will only check for the cases that cause problems for the optimizer. if (!spvOpcodeGeneratesType(inst.opcode())) { return SPV_SUCCESS; } if (decoration.struct_member_index() != Decoration::kInvalidMember && inst.opcode() == spv::Op::OpTypeStruct) { return SPV_SUCCESS; } return vstate.diag(SPV_ERROR_INVALID_ID, &inst) << "RelaxPrecision decoration cannot be applied to a type"; } #define PASS_OR_BAIL_AT_LINE(X, LINE) \ { \ spv_result_t e##LINE = (X); \ if (e##LINE != SPV_SUCCESS) return e##LINE; \ } static_assert(true, "require extra semicolon") #define PASS_OR_BAIL(X) PASS_OR_BAIL_AT_LINE(X, __LINE__) // Check rules for decorations where we start from the decoration rather // than the decorated object. Assumes each decoration on a group have been // propagated down to the group members. spv_result_t CheckDecorationsFromDecoration(ValidationState_t& vstate) { // Some rules are only checked for shaders. const bool is_shader = vstate.HasCapability(spv::Capability::Shader); for (const auto& kv : vstate.id_decorations()) { const uint32_t id = kv.first; const auto& decorations = kv.second; if (decorations.empty()) continue; const Instruction* inst = vstate.FindDef(id); assert(inst); // We assume the decorations applied to a decoration group have already // been propagated down to the group members. if (inst->opcode() == spv::Op::OpDecorationGroup) continue; for (const auto& decoration : decorations) { switch (decoration.dec_type()) { case spv::Decoration::Component: PASS_OR_BAIL(CheckComponentDecoration(vstate, *inst, decoration)); break; case spv::Decoration::FPRoundingMode: if (is_shader) PASS_OR_BAIL( CheckFPRoundingModeForShaders(vstate, *inst, decoration)); break; case spv::Decoration::NonWritable: PASS_OR_BAIL(CheckNonWritableDecoration(vstate, *inst, decoration)); break; case spv::Decoration::Uniform: case spv::Decoration::UniformId: PASS_OR_BAIL(CheckUniformDecoration(vstate, *inst, decoration)); break; case spv::Decoration::NoSignedWrap: case spv::Decoration::NoUnsignedWrap: PASS_OR_BAIL(CheckIntegerWrapDecoration(vstate, *inst, decoration)); break; case spv::Decoration::Block: case spv::Decoration::BufferBlock: PASS_OR_BAIL(CheckBlockDecoration(vstate, *inst, decoration)); break; case spv::Decoration::Location: PASS_OR_BAIL(CheckLocationDecoration(vstate, *inst, decoration)); break; case spv::Decoration::RelaxedPrecision: PASS_OR_BAIL( CheckRelaxPrecisionDecoration(vstate, *inst, decoration)); break; default: break; } } } return SPV_SUCCESS; } } // namespace spv_result_t ValidateDecorations(ValidationState_t& vstate) { if (auto error = CheckImportedVariableInitialization(vstate)) return error; if (auto error = CheckDecorationsOfEntryPoints(vstate)) return error; if (auto error = CheckDecorationsOfBuffers(vstate)) return error; if (auto error = CheckDecorationsCompatibility(vstate)) return error; if (auto error = CheckLinkageAttrOfFunctions(vstate)) return error; if (auto error = CheckVulkanMemoryModelDeprecatedDecorations(vstate)) return error; if (auto error = CheckDecorationsFromDecoration(vstate)) return error; return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_derivatives.cpp000066400000000000000000000106061475742701700255200ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validates correctness of derivative SPIR-V instructions. #include #include "source/opcode.h" #include "source/val/instruction.h" #include "source/val/validate.h" #include "source/val/validation_state.h" namespace spvtools { namespace val { // Validates correctness of derivative instructions. spv_result_t DerivativesPass(ValidationState_t& _, const Instruction* inst) { const spv::Op opcode = inst->opcode(); const uint32_t result_type = inst->type_id(); switch (opcode) { case spv::Op::OpDPdx: case spv::Op::OpDPdy: case spv::Op::OpFwidth: case spv::Op::OpDPdxFine: case spv::Op::OpDPdyFine: case spv::Op::OpFwidthFine: case spv::Op::OpDPdxCoarse: case spv::Op::OpDPdyCoarse: case spv::Op::OpFwidthCoarse: { if (!_.IsFloatScalarOrVectorType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Result Type to be float scalar or vector type: " << spvOpcodeString(opcode); } if (!_.ContainsSizedIntOrFloatType(result_type, spv::Op::OpTypeFloat, 32)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Result type component width must be 32 bits"; } const uint32_t p_type = _.GetOperandTypeId(inst, 2); if (p_type != result_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected P type and Result Type to be the same: " << spvOpcodeString(opcode); } _.function(inst->function()->id()) ->RegisterExecutionModelLimitation([opcode](spv::ExecutionModel model, std::string* message) { if (model != spv::ExecutionModel::Fragment && model != spv::ExecutionModel::GLCompute && model != spv::ExecutionModel::MeshEXT && model != spv::ExecutionModel::TaskEXT) { if (message) { *message = std::string( "Derivative instructions require Fragment, GLCompute, " "MeshEXT or TaskEXT execution model: ") + spvOpcodeString(opcode); } return false; } return true; }); _.function(inst->function()->id()) ->RegisterLimitation([opcode](const ValidationState_t& state, const Function* entry_point, std::string* message) { const auto* models = state.GetExecutionModels(entry_point->id()); const auto* modes = state.GetExecutionModes(entry_point->id()); if (models && (models->find(spv::ExecutionModel::GLCompute) != models->end() || models->find(spv::ExecutionModel::MeshEXT) != models->end() || models->find(spv::ExecutionModel::TaskEXT) != models->end()) && (!modes || (modes->find(spv::ExecutionMode::DerivativeGroupLinearKHR) == modes->end() && modes->find(spv::ExecutionMode::DerivativeGroupQuadsKHR) == modes->end()))) { if (message) { *message = std::string( "Derivative instructions require " "DerivativeGroupQuadsKHR " "or DerivativeGroupLinearKHR execution mode for " "GLCompute, MeshEXT or TaskEXT execution model: ") + spvOpcodeString(opcode); } return false; } return true; }); break; } default: break; } return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_execution_limitations.cpp000066400000000000000000000046301475742701700276120ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/val/validate.h" #include "source/val/validation_state.h" namespace spvtools { namespace val { spv_result_t ValidateExecutionLimitations(ValidationState_t& _, const Instruction* inst) { if (inst->opcode() != spv::Op::OpFunction) { return SPV_SUCCESS; } const auto func = _.function(inst->id()); if (!func) { return _.diag(SPV_ERROR_INTERNAL, inst) << "Internal error: missing function id " << inst->id() << "."; } for (uint32_t entry_id : _.FunctionEntryPoints(inst->id())) { const auto* models = _.GetExecutionModels(entry_id); if (models) { if (models->empty()) { return _.diag(SPV_ERROR_INTERNAL, inst) << "Internal error: empty execution models for function id " << entry_id << "."; } for (const auto model : *models) { std::string reason; if (!func->IsCompatibleWithExecutionModel(model, &reason)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpEntryPoint Entry Point " << _.getIdName(entry_id) << "s callgraph contains function " << _.getIdName(inst->id()) << ", which cannot be used with the current execution " "model:\n" << reason; } } } std::string reason; if (!func->CheckLimitations(_, _.function(entry_id), &reason)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpEntryPoint Entry Point " << _.getIdName(entry_id) << "s callgraph contains function " << _.getIdName(inst->id()) << ", which cannot be used with the current execution " "modes:\n" << reason; } } return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_extensions.cpp000066400000000000000000004626321475742701700254040ustar00rootroot00000000000000// Copyright (c) 2018 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validates correctness of extension SPIR-V instructions. #include #include #include #include #include "NonSemanticShaderDebugInfo100.h" #include "OpenCLDebugInfo100.h" #include "source/common_debug_info.h" #include "source/enum_string_mapping.h" #include "source/extensions.h" #include "source/latest_version_glsl_std_450_header.h" #include "source/latest_version_opencl_std_header.h" #include "source/spirv_constant.h" #include "source/val/instruction.h" #include "source/val/validate.h" #include "source/val/validation_state.h" #include "spirv/unified1/NonSemanticClspvReflection.h" namespace spvtools { namespace val { namespace { std::string ReflectionInstructionName(ValidationState_t& _, const Instruction* inst) { spv_ext_inst_desc desc = nullptr; if (_.grammar().lookupExtInst(SPV_EXT_INST_TYPE_NONSEMANTIC_CLSPVREFLECTION, inst->word(4), &desc) != SPV_SUCCESS || !desc) { return std::string("Unknown ExtInst"); } std::ostringstream ss; ss << desc->name; return ss.str(); } uint32_t GetSizeTBitWidth(const ValidationState_t& _) { if (_.addressing_model() == spv::AddressingModel::Physical32) return 32; if (_.addressing_model() == spv::AddressingModel::Physical64) return 64; return 0; } bool IsIntScalar(ValidationState_t& _, uint32_t id, bool must_len32, bool must_unsigned) { auto type = _.FindDef(id); if (!type || type->opcode() != spv::Op::OpTypeInt) { return false; } if (must_len32 && type->GetOperandAs(1) != 32) { return false; } return !must_unsigned || type->GetOperandAs(2) == 0; } bool IsUint32Constant(ValidationState_t& _, uint32_t id) { auto inst = _.FindDef(id); if (!inst || inst->opcode() != spv::Op::OpConstant) { return false; } return IsIntScalar(_, inst->type_id(), true, true); } uint32_t GetUint32Constant(ValidationState_t& _, uint32_t id) { auto inst = _.FindDef(id); return inst->word(3); } // Check that the operand of a debug info instruction |inst| at |word_index| // is a result id of an instruction with |expected_opcode|. spv_result_t ValidateOperandForDebugInfo( ValidationState_t& _, const std::string& operand_name, spv::Op expected_opcode, const Instruction* inst, uint32_t word_index, const std::function& ext_inst_name) { auto* operand = _.FindDef(inst->word(word_index)); if (operand->opcode() != expected_opcode) { spv_opcode_desc desc = nullptr; if (_.grammar().lookupOpcode(expected_opcode, &desc) != SPV_SUCCESS || !desc) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand " << operand_name << " is invalid"; } return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand " << operand_name << " must be a result id of " << "Op" << desc->name; } return SPV_SUCCESS; } // For NonSemantic.Shader.DebugInfo.100 check that the operand of a debug info // instruction |inst| at |word_index| is a result id of a 32-bit integer // OpConstant instruction. For OpenCL.DebugInfo.100 the parameter is a literal // word so cannot be validated. spv_result_t ValidateUint32ConstantOperandForDebugInfo( ValidationState_t& _, const std::string& operand_name, const Instruction* inst, uint32_t word_index, const std::function& ext_inst_name) { if (!IsUint32Constant(_, inst->word(word_index))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": expected operand " << operand_name << " must be a result id of 32-bit unsigned OpConstant"; } return SPV_SUCCESS; } #define CHECK_OPERAND(NAME, opcode, index) \ do { \ auto result = ValidateOperandForDebugInfo(_, NAME, opcode, inst, index, \ ext_inst_name); \ if (result != SPV_SUCCESS) return result; \ } while (0) #define CHECK_CONST_UINT_OPERAND(NAME, index) \ if (vulkanDebugInfo) { \ auto result = ValidateUint32ConstantOperandForDebugInfo( \ _, NAME, inst, index, ext_inst_name); \ if (result != SPV_SUCCESS) return result; \ } // True if the operand of a debug info instruction |inst| at |word_index| // satisfies |expectation| that is given as a function. Otherwise, // returns false. bool DoesDebugInfoOperandMatchExpectation( const ValidationState_t& _, const std::function& expectation, const Instruction* inst, uint32_t word_index) { if (inst->words().size() <= word_index) return false; auto* debug_inst = _.FindDef(inst->word(word_index)); if (!spvIsExtendedInstruction(debug_inst->opcode()) || (debug_inst->ext_inst_type() != SPV_EXT_INST_TYPE_OPENCL_DEBUGINFO_100 && debug_inst->ext_inst_type() != SPV_EXT_INST_TYPE_NONSEMANTIC_SHADER_DEBUGINFO_100) || !expectation(CommonDebugInfoInstructions(debug_inst->word(4)))) { return false; } return true; } // Overload for NonSemanticShaderDebugInfo100Instructions. bool DoesDebugInfoOperandMatchExpectation( const ValidationState_t& _, const std::function& expectation, const Instruction* inst, uint32_t word_index) { if (inst->words().size() <= word_index) return false; auto* debug_inst = _.FindDef(inst->word(word_index)); if (!spvIsExtendedInstruction(debug_inst->opcode()) || (debug_inst->ext_inst_type() != SPV_EXT_INST_TYPE_NONSEMANTIC_SHADER_DEBUGINFO_100) || !expectation( NonSemanticShaderDebugInfo100Instructions(debug_inst->word(4)))) { return false; } return true; } // Check that the operand of a debug info instruction |inst| at |word_index| // is a result id of an debug info instruction whose debug instruction type // is |expected_debug_inst|. spv_result_t ValidateDebugInfoOperand( ValidationState_t& _, const std::string& debug_inst_name, CommonDebugInfoInstructions expected_debug_inst, const Instruction* inst, uint32_t word_index, const std::function& ext_inst_name) { std::function expectation = [expected_debug_inst](CommonDebugInfoInstructions dbg_inst) { return dbg_inst == expected_debug_inst; }; if (DoesDebugInfoOperandMatchExpectation(_, expectation, inst, word_index)) return SPV_SUCCESS; spv_ext_inst_desc desc = nullptr; if (_.grammar().lookupExtInst(inst->ext_inst_type(), expected_debug_inst, &desc) != SPV_SUCCESS || !desc) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand " << debug_inst_name << " is invalid"; } return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand " << debug_inst_name << " must be a result id of " << desc->name; } #define CHECK_DEBUG_OPERAND(NAME, debug_opcode, index) \ do { \ auto result = ValidateDebugInfoOperand(_, NAME, debug_opcode, inst, index, \ ext_inst_name); \ if (result != SPV_SUCCESS) return result; \ } while (0) // Check that the operand of a debug info instruction |inst| at |word_index| // is a result id of an debug info instruction with DebugTypeBasic. spv_result_t ValidateOperandBaseType( ValidationState_t& _, const Instruction* inst, uint32_t word_index, const std::function& ext_inst_name) { return ValidateDebugInfoOperand(_, "Base Type", CommonDebugInfoDebugTypeBasic, inst, word_index, ext_inst_name); } // Check that the operand of a debug info instruction |inst| at |word_index| // is a result id of a debug lexical scope instruction which is one of // DebugCompilationUnit, DebugFunction, DebugLexicalBlock, or // DebugTypeComposite. spv_result_t ValidateOperandLexicalScope( ValidationState_t& _, const std::string& debug_inst_name, const Instruction* inst, uint32_t word_index, const std::function& ext_inst_name) { std::function expectation = [](CommonDebugInfoInstructions dbg_inst) { return dbg_inst == CommonDebugInfoDebugCompilationUnit || dbg_inst == CommonDebugInfoDebugFunction || dbg_inst == CommonDebugInfoDebugLexicalBlock || dbg_inst == CommonDebugInfoDebugTypeComposite; }; if (DoesDebugInfoOperandMatchExpectation(_, expectation, inst, word_index)) return SPV_SUCCESS; return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand " << debug_inst_name << " must be a result id of a lexical scope"; } // Check that the operand of a debug info instruction |inst| at |word_index| // is a result id of a debug type instruction (See DebugTypeXXX in // "4.3. Type instructions" section of OpenCL.DebugInfo.100 spec. spv_result_t ValidateOperandDebugType( ValidationState_t& _, const std::string& debug_inst_name, const Instruction* inst, uint32_t word_index, const std::function& ext_inst_name, bool allow_template_param) { // Check for NonSemanticShaderDebugInfo100 specific types. if (inst->ext_inst_type() == SPV_EXT_INST_TYPE_NONSEMANTIC_SHADER_DEBUGINFO_100) { std::function expectation = [](NonSemanticShaderDebugInfo100Instructions dbg_inst) { return dbg_inst == NonSemanticShaderDebugInfo100DebugTypeMatrix; }; if (DoesDebugInfoOperandMatchExpectation(_, expectation, inst, word_index)) return SPV_SUCCESS; } // Check for common types. std::function expectation = [&allow_template_param](CommonDebugInfoInstructions dbg_inst) { if (allow_template_param && (dbg_inst == CommonDebugInfoDebugTypeTemplateParameter || dbg_inst == CommonDebugInfoDebugTypeTemplateTemplateParameter)) { return true; } return CommonDebugInfoDebugTypeBasic <= dbg_inst && dbg_inst <= CommonDebugInfoDebugTypeTemplate; }; if (DoesDebugInfoOperandMatchExpectation(_, expectation, inst, word_index)) return SPV_SUCCESS; return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand " << debug_inst_name << " is not a valid debug type"; } spv_result_t ValidateClspvReflectionKernel(ValidationState_t& _, const Instruction* inst, uint32_t version) { const auto inst_name = ReflectionInstructionName(_, inst); const auto kernel_id = inst->GetOperandAs(4); const auto kernel = _.FindDef(kernel_id); if (kernel->opcode() != spv::Op::OpFunction) { return _.diag(SPV_ERROR_INVALID_ID, inst) << inst_name << " does not reference a function"; } bool found_kernel = false; for (auto entry_point : _.entry_points()) { if (entry_point == kernel_id) { found_kernel = true; break; } } if (!found_kernel) { return _.diag(SPV_ERROR_INVALID_ID, inst) << inst_name << " does not reference an entry-point"; } const auto* exec_models = _.GetExecutionModels(kernel_id); if (!exec_models || exec_models->empty()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << inst_name << " does not reference an entry-point"; } for (auto exec_model : *exec_models) { if (exec_model != spv::ExecutionModel::GLCompute) { return _.diag(SPV_ERROR_INVALID_ID, inst) << inst_name << " must refer only to GLCompute entry-points"; } } auto name = _.FindDef(inst->GetOperandAs(5)); if (!name || name->opcode() != spv::Op::OpString) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Name must be an OpString"; } const std::string name_str = name->GetOperandAs(1); bool found = false; for (auto& desc : _.entry_point_descriptions(kernel_id)) { if (name_str == desc.name) { found = true; break; } } if (!found) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Name must match an entry-point for Kernel"; } const auto num_operands = inst->operands().size(); if (version < 5 && num_operands > 6) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Version " << version << " of the " << inst_name << " instruction can only have 2 additional operands"; } if (num_operands > 6) { const auto num_args_id = inst->GetOperandAs(6); if (!IsUint32Constant(_, num_args_id)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "NumArguments must be a 32-bit unsigned integer OpConstant"; } } if (num_operands > 7) { const auto flags_id = inst->GetOperandAs(7); if (!IsUint32Constant(_, flags_id)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Flags must be a 32-bit unsigned integer OpConstant"; } } if (num_operands > 8) { const auto atts_id = inst->GetOperandAs(8); if (_.GetIdOpcode(atts_id) != spv::Op::OpString) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Attributes must be an OpString"; } } return SPV_SUCCESS; } spv_result_t ValidateClspvReflectionArgumentInfo(ValidationState_t& _, const Instruction* inst) { const auto num_operands = inst->operands().size(); if (_.GetIdOpcode(inst->GetOperandAs(4)) != spv::Op::OpString) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Name must be an OpString"; } if (num_operands > 5) { if (_.GetIdOpcode(inst->GetOperandAs(5)) != spv::Op::OpString) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "TypeName must be an OpString"; } } if (num_operands > 6) { if (!IsUint32Constant(_, inst->GetOperandAs(6))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "AddressQualifier must be a 32-bit unsigned integer " "OpConstant"; } } if (num_operands > 7) { if (!IsUint32Constant(_, inst->GetOperandAs(7))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "AccessQualifier must be a 32-bit unsigned integer " "OpConstant"; } } if (num_operands > 8) { if (!IsUint32Constant(_, inst->GetOperandAs(8))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "TypeQualifier must be a 32-bit unsigned integer " "OpConstant"; } } return SPV_SUCCESS; } spv_result_t ValidateKernelDecl(ValidationState_t& _, const Instruction* inst) { const auto decl_id = inst->GetOperandAs(4); const auto decl = _.FindDef(decl_id); if (!decl || !spvIsExtendedInstruction(decl->opcode())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Kernel must be a Kernel extended instruction"; } if (decl->GetOperandAs(2) != inst->GetOperandAs(2)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Kernel must be from the same extended instruction import"; } const auto ext_inst = decl->GetOperandAs(3); if (ext_inst != NonSemanticClspvReflectionKernel) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Kernel must be a Kernel extended instruction"; } return SPV_SUCCESS; } spv_result_t ValidateArgInfo(ValidationState_t& _, const Instruction* inst, uint32_t info_index) { auto info = _.FindDef(inst->GetOperandAs(info_index)); if (!info || !spvIsExtendedInstruction(info->opcode())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "ArgInfo must be an ArgumentInfo extended instruction"; } if (info->GetOperandAs(2) != inst->GetOperandAs(2)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "ArgInfo must be from the same extended instruction import"; } auto ext_inst = info->GetOperandAs(3); if (ext_inst != NonSemanticClspvReflectionArgumentInfo) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "ArgInfo must be an ArgumentInfo extended instruction"; } return SPV_SUCCESS; } spv_result_t ValidateClspvReflectionArgumentBuffer(ValidationState_t& _, const Instruction* inst) { const auto num_operands = inst->operands().size(); if (auto error = ValidateKernelDecl(_, inst)) { return error; } if (!IsUint32Constant(_, inst->GetOperandAs(5))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Ordinal must be a 32-bit unsigned integer OpConstant"; } if (!IsUint32Constant(_, inst->GetOperandAs(6))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "DescriptorSet must be a 32-bit unsigned integer OpConstant"; } if (!IsUint32Constant(_, inst->GetOperandAs(7))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Binding must be a 32-bit unsigned integer OpConstant"; } if (num_operands == 9) { if (auto error = ValidateArgInfo(_, inst, 8)) { return error; } } return SPV_SUCCESS; } spv_result_t ValidateClspvReflectionArgumentOffsetBuffer( ValidationState_t& _, const Instruction* inst) { const auto num_operands = inst->operands().size(); if (auto error = ValidateKernelDecl(_, inst)) { return error; } if (!IsUint32Constant(_, inst->GetOperandAs(5))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Ordinal must be a 32-bit unsigned integer OpConstant"; } if (!IsUint32Constant(_, inst->GetOperandAs(6))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "DescriptorSet must be a 32-bit unsigned integer OpConstant"; } if (!IsUint32Constant(_, inst->GetOperandAs(7))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Binding must be a 32-bit unsigned integer OpConstant"; } if (!IsUint32Constant(_, inst->GetOperandAs(8))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Offset must be a 32-bit unsigned integer OpConstant"; } if (!IsUint32Constant(_, inst->GetOperandAs(9))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Size must be a 32-bit unsigned integer OpConstant"; } if (num_operands == 11) { if (auto error = ValidateArgInfo(_, inst, 10)) { return error; } } return SPV_SUCCESS; } spv_result_t ValidateClspvReflectionArgumentPushConstant( ValidationState_t& _, const Instruction* inst) { const auto num_operands = inst->operands().size(); if (auto error = ValidateKernelDecl(_, inst)) { return error; } if (!IsUint32Constant(_, inst->GetOperandAs(5))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Ordinal must be a 32-bit unsigned integer OpConstant"; } if (!IsUint32Constant(_, inst->GetOperandAs(6))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Offset must be a 32-bit unsigned integer OpConstant"; } if (!IsUint32Constant(_, inst->GetOperandAs(7))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Size must be a 32-bit unsigned integer OpConstant"; } if (num_operands == 9) { if (auto error = ValidateArgInfo(_, inst, 8)) { return error; } } return SPV_SUCCESS; } spv_result_t ValidateClspvReflectionArgumentWorkgroup(ValidationState_t& _, const Instruction* inst) { const auto num_operands = inst->operands().size(); if (auto error = ValidateKernelDecl(_, inst)) { return error; } if (!IsUint32Constant(_, inst->GetOperandAs(5))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Ordinal must be a 32-bit unsigned integer OpConstant"; } if (!IsUint32Constant(_, inst->GetOperandAs(6))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "SpecId must be a 32-bit unsigned integer OpConstant"; } if (!IsUint32Constant(_, inst->GetOperandAs(7))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "ElemSize must be a 32-bit unsigned integer OpConstant"; } if (num_operands == 9) { if (auto error = ValidateArgInfo(_, inst, 8)) { return error; } } return SPV_SUCCESS; } spv_result_t ValidateClspvReflectionSpecConstantTriple( ValidationState_t& _, const Instruction* inst) { if (!IsUint32Constant(_, inst->GetOperandAs(4))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "X must be a 32-bit unsigned integer OpConstant"; } if (!IsUint32Constant(_, inst->GetOperandAs(5))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Y must be a 32-bit unsigned integer OpConstant"; } if (!IsUint32Constant(_, inst->GetOperandAs(6))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Z must be a 32-bit unsigned integer OpConstant"; } return SPV_SUCCESS; } spv_result_t ValidateClspvReflectionSpecConstantWorkDim( ValidationState_t& _, const Instruction* inst) { if (!IsUint32Constant(_, inst->GetOperandAs(4))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Dim must be a 32-bit unsigned integer OpConstant"; } return SPV_SUCCESS; } spv_result_t ValidateClspvReflectionPushConstant(ValidationState_t& _, const Instruction* inst) { if (!IsUint32Constant(_, inst->GetOperandAs(4))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Offset must be a 32-bit unsigned integer OpConstant"; } if (!IsUint32Constant(_, inst->GetOperandAs(5))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Size must be a 32-bit unsigned integer OpConstant"; } return SPV_SUCCESS; } spv_result_t ValidateClspvReflectionInitializedData(ValidationState_t& _, const Instruction* inst) { if (!IsUint32Constant(_, inst->GetOperandAs(4))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "DescriptorSet must be a 32-bit unsigned integer OpConstant"; } if (!IsUint32Constant(_, inst->GetOperandAs(5))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Binding must be a 32-bit unsigned integer OpConstant"; } if (_.GetIdOpcode(inst->GetOperandAs(6)) != spv::Op::OpString) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Data must be an OpString"; } return SPV_SUCCESS; } spv_result_t ValidateClspvReflectionSampler(ValidationState_t& _, const Instruction* inst) { if (!IsUint32Constant(_, inst->GetOperandAs(4))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "DescriptorSet must be a 32-bit unsigned integer OpConstant"; } if (!IsUint32Constant(_, inst->GetOperandAs(5))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Binding must be a 32-bit unsigned integer OpConstant"; } if (!IsUint32Constant(_, inst->GetOperandAs(6))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Mask must be a 32-bit unsigned integer OpConstant"; } return SPV_SUCCESS; } spv_result_t ValidateClspvReflectionPropertyRequiredWorkgroupSize( ValidationState_t& _, const Instruction* inst) { if (auto error = ValidateKernelDecl(_, inst)) { return error; } if (!IsUint32Constant(_, inst->GetOperandAs(5))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "X must be a 32-bit unsigned integer OpConstant"; } if (!IsUint32Constant(_, inst->GetOperandAs(6))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Y must be a 32-bit unsigned integer OpConstant"; } if (!IsUint32Constant(_, inst->GetOperandAs(7))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Z must be a 32-bit unsigned integer OpConstant"; } return SPV_SUCCESS; } spv_result_t ValidateClspvReflectionSubgroupMaxSize(ValidationState_t& _, const Instruction* inst) { const auto size_id = inst->GetOperandAs(4); if (!IsUint32Constant(_, size_id)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Size must be a 32-bit unsigned integer OpConstant"; } return SPV_SUCCESS; } spv_result_t ValidateClspvReflectionPointerRelocation(ValidationState_t& _, const Instruction* inst) { if (!IsUint32Constant(_, inst->GetOperandAs(4))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "ObjectOffset must be a 32-bit unsigned integer OpConstant"; } if (!IsUint32Constant(_, inst->GetOperandAs(5))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "PointerOffset must be a 32-bit unsigned integer OpConstant"; } if (!IsUint32Constant(_, inst->GetOperandAs(6))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "PointerSize must be a 32-bit unsigned integer OpConstant"; } return SPV_SUCCESS; } spv_result_t ValidateClspvReflectionImageMetadataPushConstant( ValidationState_t& _, const Instruction* inst) { if (auto error = ValidateKernelDecl(_, inst)) { return error; } if (!IsUint32Constant(_, inst->GetOperandAs(5))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Ordinal must be a 32-bit unsigned integer OpConstant"; } if (!IsUint32Constant(_, inst->GetOperandAs(6))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Offset must be a 32-bit unsigned integer OpConstant"; } if (!IsUint32Constant(_, inst->GetOperandAs(7))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Size must be a 32-bit unsigned integer OpConstant"; } return SPV_SUCCESS; } spv_result_t ValidateClspvReflectionImageMetadataUniform( ValidationState_t& _, const Instruction* inst) { if (auto error = ValidateKernelDecl(_, inst)) { return error; } if (!IsUint32Constant(_, inst->GetOperandAs(5))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Ordinal must be a 32-bit unsigned integer OpConstant"; } if (!IsUint32Constant(_, inst->GetOperandAs(6))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "DescriptorSet must be a 32-bit unsigned integer OpConstant"; } if (!IsUint32Constant(_, inst->GetOperandAs(7))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Binding must be a 32-bit unsigned integer OpConstant"; } if (!IsUint32Constant(_, inst->GetOperandAs(8))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Offset must be a 32-bit unsigned integer OpConstant"; } if (!IsUint32Constant(_, inst->GetOperandAs(9))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Size must be a 32-bit unsigned integer OpConstant"; } return SPV_SUCCESS; } spv_result_t ValidateClspvReflectionPushConstantData(ValidationState_t& _, const Instruction* inst) { if (!IsUint32Constant(_, inst->GetOperandAs(4))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Offset must be a 32-bit unsigned integer OpConstant"; } if (!IsUint32Constant(_, inst->GetOperandAs(5))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Size must be a 32-bit unsigned integer OpConstant"; } if (_.GetIdOpcode(inst->GetOperandAs(6)) != spv::Op::OpString) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Data must be an OpString"; } return SPV_SUCCESS; } spv_result_t ValidateClspvReflectionPrintfInfo(ValidationState_t& _, const Instruction* inst) { if (!IsUint32Constant(_, inst->GetOperandAs(4))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "PrintfID must be a 32-bit unsigned integer OpConstant"; } if (_.GetIdOpcode(inst->GetOperandAs(5)) != spv::Op::OpString) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "FormatString must be an OpString"; } for (size_t i = 6; i < inst->operands().size(); ++i) { if (!IsUint32Constant(_, inst->GetOperandAs(i))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "ArgumentSizes must be a 32-bit unsigned integer OpConstant"; } } return SPV_SUCCESS; } spv_result_t ValidateClspvReflectionPrintfStorageBuffer( ValidationState_t& _, const Instruction* inst) { if (!IsUint32Constant(_, inst->GetOperandAs(4))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "DescriptorSet must be a 32-bit unsigned integer OpConstant"; } if (!IsUint32Constant(_, inst->GetOperandAs(5))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Binding must be a 32-bit unsigned integer OpConstant"; } if (!IsUint32Constant(_, inst->GetOperandAs(6))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Size must be a 32-bit unsigned integer OpConstant"; } return SPV_SUCCESS; } spv_result_t ValidateClspvReflectionPrintfPushConstant( ValidationState_t& _, const Instruction* inst) { if (!IsUint32Constant(_, inst->GetOperandAs(4))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Offset must be a 32-bit unsigned integer OpConstant"; } if (!IsUint32Constant(_, inst->GetOperandAs(5))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Size must be a 32-bit unsigned integer OpConstant"; } if (!IsUint32Constant(_, inst->GetOperandAs(6))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "BufferSize must be a 32-bit unsigned integer OpConstant"; } return SPV_SUCCESS; } spv_result_t ValidateClspvReflectionInstruction(ValidationState_t& _, const Instruction* inst, uint32_t version) { if (!_.IsVoidType(inst->type_id())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Return Type must be OpTypeVoid"; } uint32_t required_version = 0; const auto ext_inst = inst->GetOperandAs(3); switch (ext_inst) { case NonSemanticClspvReflectionKernel: case NonSemanticClspvReflectionArgumentInfo: case NonSemanticClspvReflectionArgumentStorageBuffer: case NonSemanticClspvReflectionArgumentUniform: case NonSemanticClspvReflectionArgumentPodStorageBuffer: case NonSemanticClspvReflectionArgumentPodUniform: case NonSemanticClspvReflectionArgumentPodPushConstant: case NonSemanticClspvReflectionArgumentSampledImage: case NonSemanticClspvReflectionArgumentStorageImage: case NonSemanticClspvReflectionArgumentSampler: case NonSemanticClspvReflectionArgumentWorkgroup: case NonSemanticClspvReflectionSpecConstantWorkgroupSize: case NonSemanticClspvReflectionSpecConstantGlobalOffset: case NonSemanticClspvReflectionSpecConstantWorkDim: case NonSemanticClspvReflectionPushConstantGlobalOffset: case NonSemanticClspvReflectionPushConstantEnqueuedLocalSize: case NonSemanticClspvReflectionPushConstantGlobalSize: case NonSemanticClspvReflectionPushConstantRegionOffset: case NonSemanticClspvReflectionPushConstantNumWorkgroups: case NonSemanticClspvReflectionPushConstantRegionGroupOffset: case NonSemanticClspvReflectionConstantDataStorageBuffer: case NonSemanticClspvReflectionConstantDataUniform: case NonSemanticClspvReflectionLiteralSampler: case NonSemanticClspvReflectionPropertyRequiredWorkgroupSize: required_version = 1; break; case NonSemanticClspvReflectionSpecConstantSubgroupMaxSize: required_version = 2; break; case NonSemanticClspvReflectionArgumentPointerPushConstant: case NonSemanticClspvReflectionArgumentPointerUniform: case NonSemanticClspvReflectionProgramScopeVariablesStorageBuffer: case NonSemanticClspvReflectionProgramScopeVariablePointerRelocation: case NonSemanticClspvReflectionImageArgumentInfoChannelOrderPushConstant: case NonSemanticClspvReflectionImageArgumentInfoChannelDataTypePushConstant: case NonSemanticClspvReflectionImageArgumentInfoChannelOrderUniform: case NonSemanticClspvReflectionImageArgumentInfoChannelDataTypeUniform: required_version = 3; break; case NonSemanticClspvReflectionArgumentStorageTexelBuffer: case NonSemanticClspvReflectionArgumentUniformTexelBuffer: required_version = 4; break; case NonSemanticClspvReflectionConstantDataPointerPushConstant: case NonSemanticClspvReflectionProgramScopeVariablePointerPushConstant: case NonSemanticClspvReflectionPrintfInfo: case NonSemanticClspvReflectionPrintfBufferStorageBuffer: case NonSemanticClspvReflectionPrintfBufferPointerPushConstant: required_version = 5; break; default: break; } if (version < required_version) { return _.diag(SPV_ERROR_INVALID_ID, inst) << ReflectionInstructionName(_, inst) << " requires version " << required_version << ", but parsed version is " << version; } switch (ext_inst) { case NonSemanticClspvReflectionKernel: return ValidateClspvReflectionKernel(_, inst, version); case NonSemanticClspvReflectionArgumentInfo: return ValidateClspvReflectionArgumentInfo(_, inst); case NonSemanticClspvReflectionArgumentStorageBuffer: case NonSemanticClspvReflectionArgumentUniform: case NonSemanticClspvReflectionArgumentSampledImage: case NonSemanticClspvReflectionArgumentStorageImage: case NonSemanticClspvReflectionArgumentSampler: case NonSemanticClspvReflectionArgumentStorageTexelBuffer: case NonSemanticClspvReflectionArgumentUniformTexelBuffer: return ValidateClspvReflectionArgumentBuffer(_, inst); case NonSemanticClspvReflectionArgumentPodStorageBuffer: case NonSemanticClspvReflectionArgumentPodUniform: case NonSemanticClspvReflectionArgumentPointerUniform: return ValidateClspvReflectionArgumentOffsetBuffer(_, inst); case NonSemanticClspvReflectionArgumentPodPushConstant: case NonSemanticClspvReflectionArgumentPointerPushConstant: return ValidateClspvReflectionArgumentPushConstant(_, inst); case NonSemanticClspvReflectionArgumentWorkgroup: return ValidateClspvReflectionArgumentWorkgroup(_, inst); case NonSemanticClspvReflectionSpecConstantWorkgroupSize: case NonSemanticClspvReflectionSpecConstantGlobalOffset: return ValidateClspvReflectionSpecConstantTriple(_, inst); case NonSemanticClspvReflectionSpecConstantWorkDim: return ValidateClspvReflectionSpecConstantWorkDim(_, inst); case NonSemanticClspvReflectionPushConstantGlobalOffset: case NonSemanticClspvReflectionPushConstantEnqueuedLocalSize: case NonSemanticClspvReflectionPushConstantGlobalSize: case NonSemanticClspvReflectionPushConstantRegionOffset: case NonSemanticClspvReflectionPushConstantNumWorkgroups: case NonSemanticClspvReflectionPushConstantRegionGroupOffset: return ValidateClspvReflectionPushConstant(_, inst); case NonSemanticClspvReflectionConstantDataStorageBuffer: case NonSemanticClspvReflectionConstantDataUniform: case NonSemanticClspvReflectionProgramScopeVariablesStorageBuffer: return ValidateClspvReflectionInitializedData(_, inst); case NonSemanticClspvReflectionLiteralSampler: return ValidateClspvReflectionSampler(_, inst); case NonSemanticClspvReflectionPropertyRequiredWorkgroupSize: return ValidateClspvReflectionPropertyRequiredWorkgroupSize(_, inst); case NonSemanticClspvReflectionSpecConstantSubgroupMaxSize: return ValidateClspvReflectionSubgroupMaxSize(_, inst); case NonSemanticClspvReflectionProgramScopeVariablePointerRelocation: return ValidateClspvReflectionPointerRelocation(_, inst); case NonSemanticClspvReflectionImageArgumentInfoChannelOrderPushConstant: case NonSemanticClspvReflectionImageArgumentInfoChannelDataTypePushConstant: return ValidateClspvReflectionImageMetadataPushConstant(_, inst); case NonSemanticClspvReflectionImageArgumentInfoChannelOrderUniform: case NonSemanticClspvReflectionImageArgumentInfoChannelDataTypeUniform: return ValidateClspvReflectionImageMetadataUniform(_, inst); case NonSemanticClspvReflectionConstantDataPointerPushConstant: case NonSemanticClspvReflectionProgramScopeVariablePointerPushConstant: return ValidateClspvReflectionPushConstantData(_, inst); case NonSemanticClspvReflectionPrintfInfo: return ValidateClspvReflectionPrintfInfo(_, inst); case NonSemanticClspvReflectionPrintfBufferStorageBuffer: return ValidateClspvReflectionPrintfStorageBuffer(_, inst); case NonSemanticClspvReflectionPrintfBufferPointerPushConstant: return ValidateClspvReflectionPrintfPushConstant(_, inst); default: break; } return SPV_SUCCESS; } bool IsConstIntScalarTypeWith32Or64Bits(ValidationState_t& _, Instruction* instr) { if (instr->opcode() != spv::Op::OpConstant) return false; if (!_.IsIntScalarType(instr->type_id())) return false; uint32_t size_in_bits = _.GetBitWidth(instr->type_id()); return size_in_bits == 32 || size_in_bits == 64; } bool IsConstWithIntScalarType(ValidationState_t& _, const Instruction* inst, uint32_t word_index) { auto* int_scalar_const = _.FindDef(inst->word(word_index)); if (int_scalar_const->opcode() == spv::Op::OpConstant && _.IsIntScalarType(int_scalar_const->type_id())) { return true; } return false; } bool IsDebugVariableWithIntScalarType(ValidationState_t& _, const Instruction* inst, uint32_t word_index) { auto* dbg_int_scalar_var = _.FindDef(inst->word(word_index)); if (CommonDebugInfoInstructions(dbg_int_scalar_var->word(4)) == CommonDebugInfoDebugLocalVariable || CommonDebugInfoInstructions(dbg_int_scalar_var->word(4)) == CommonDebugInfoDebugGlobalVariable) { auto* dbg_type = _.FindDef(dbg_int_scalar_var->word(6)); if (CommonDebugInfoInstructions(dbg_type->word(4)) == CommonDebugInfoDebugTypeBasic) { const spv_ext_inst_type_t ext_inst_type = spv_ext_inst_type_t(inst->ext_inst_type()); const bool vulkanDebugInfo = ext_inst_type == SPV_EXT_INST_TYPE_NONSEMANTIC_SHADER_DEBUGINFO_100; uint32_t encoding = dbg_type->word(7); if (!vulkanDebugInfo || IsUint32Constant(_, encoding)) { auto ocl_encoding = OpenCLDebugInfo100DebugBaseTypeAttributeEncoding( vulkanDebugInfo ? GetUint32Constant(_, encoding) : encoding); if (ocl_encoding == OpenCLDebugInfo100Signed || ocl_encoding == OpenCLDebugInfo100Unsigned) { return true; } } } } return false; } } // anonymous namespace spv_result_t ValidateExtension(ValidationState_t& _, const Instruction* inst) { if (_.version() < SPV_SPIRV_VERSION_WORD(1, 4)) { std::string extension = GetExtensionString(&(inst->c_inst())); if (extension == ExtensionToString(kSPV_KHR_workgroup_memory_explicit_layout) || extension == ExtensionToString(kSPV_EXT_mesh_shader) || extension == ExtensionToString(kSPV_NV_shader_invocation_reorder) || extension == ExtensionToString(kSPV_NV_cluster_acceleration_structure) || extension == ExtensionToString(kSPV_NV_linear_swept_spheres)) { return _.diag(SPV_ERROR_WRONG_VERSION, inst) << extension << " extension requires SPIR-V version 1.4 or later."; } } return SPV_SUCCESS; } spv_result_t ValidateExtInstImport(ValidationState_t& _, const Instruction* inst) { const auto name_id = 1; if (_.version() <= SPV_SPIRV_VERSION_WORD(1, 5) && !_.HasExtension(kSPV_KHR_non_semantic_info)) { const std::string name = inst->GetOperandAs(name_id); if (name.find("NonSemantic.") == 0) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "NonSemantic extended instruction sets cannot be declared " "without SPV_KHR_non_semantic_info."; } } return SPV_SUCCESS; } spv_result_t ValidateExtInst(ValidationState_t& _, const Instruction* inst) { const uint32_t result_type = inst->type_id(); const uint32_t num_operands = static_cast(inst->operands().size()); const uint32_t ext_inst_set = inst->word(3); const uint32_t ext_inst_index = inst->word(4); const spv_ext_inst_type_t ext_inst_type = spv_ext_inst_type_t(inst->ext_inst_type()); auto ext_inst_name = [&_, ext_inst_set, ext_inst_type, ext_inst_index]() { spv_ext_inst_desc desc = nullptr; if (_.grammar().lookupExtInst(ext_inst_type, ext_inst_index, &desc) != SPV_SUCCESS || !desc) { return std::string("Unknown ExtInst"); } auto* import_inst = _.FindDef(ext_inst_set); assert(import_inst); std::ostringstream ss; ss << import_inst->GetOperandAs(1); ss << " "; ss << desc->name; return ss.str(); }; if (ext_inst_type == SPV_EXT_INST_TYPE_GLSL_STD_450) { const GLSLstd450 ext_inst_key = GLSLstd450(ext_inst_index); switch (ext_inst_key) { case GLSLstd450Round: case GLSLstd450RoundEven: case GLSLstd450FAbs: case GLSLstd450Trunc: case GLSLstd450FSign: case GLSLstd450Floor: case GLSLstd450Ceil: case GLSLstd450Fract: case GLSLstd450Sqrt: case GLSLstd450InverseSqrt: case GLSLstd450FMin: case GLSLstd450FMax: case GLSLstd450FClamp: case GLSLstd450FMix: case GLSLstd450Step: case GLSLstd450SmoothStep: case GLSLstd450Fma: case GLSLstd450Normalize: case GLSLstd450FaceForward: case GLSLstd450Reflect: case GLSLstd450NMin: case GLSLstd450NMax: case GLSLstd450NClamp: { bool supportsCoopVec = (ext_inst_key == GLSLstd450FMin || ext_inst_key == GLSLstd450FMax || ext_inst_key == GLSLstd450FClamp || ext_inst_key == GLSLstd450NMin || ext_inst_key == GLSLstd450NMax || ext_inst_key == GLSLstd450NClamp || ext_inst_key == GLSLstd450Step || ext_inst_key == GLSLstd450Fma); if (!_.IsFloatScalarOrVectorType(result_type) && !(supportsCoopVec && _.IsFloatCooperativeVectorNVType(result_type))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a float scalar or vector type"; } for (uint32_t operand_index = 4; operand_index < num_operands; ++operand_index) { const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index); if (result_type != operand_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected types of all operands to be equal to Result " "Type"; } } break; } case GLSLstd450SAbs: case GLSLstd450SSign: case GLSLstd450UMin: case GLSLstd450SMin: case GLSLstd450UMax: case GLSLstd450SMax: case GLSLstd450UClamp: case GLSLstd450SClamp: case GLSLstd450FindILsb: case GLSLstd450FindUMsb: case GLSLstd450FindSMsb: { bool supportsCoopVec = (ext_inst_key == GLSLstd450UMin || ext_inst_key == GLSLstd450UMax || ext_inst_key == GLSLstd450UClamp || ext_inst_key == GLSLstd450SMin || ext_inst_key == GLSLstd450SMax || ext_inst_key == GLSLstd450SClamp); if (!_.IsIntScalarOrVectorType(result_type) && !(supportsCoopVec && _.IsIntCooperativeVectorNVType(result_type))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be an int scalar or vector type"; } const uint32_t result_type_bit_width = _.GetBitWidth(result_type); const uint32_t result_type_dimension = _.GetDimension(result_type); for (uint32_t operand_index = 4; operand_index < num_operands; ++operand_index) { const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index); if (!operand_type || (!_.IsIntScalarOrVectorType(operand_type) && !(supportsCoopVec && _.IsIntCooperativeVectorNVType(operand_type)))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected all operands to be int scalars or vectors"; } if (result_type_dimension != _.GetDimension(operand_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected all operands to have the same dimension as " << "Result Type"; } if (result_type_bit_width != _.GetBitWidth(operand_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected all operands to have the same bit width as " << "Result Type"; } if (ext_inst_key == GLSLstd450FindUMsb || ext_inst_key == GLSLstd450FindSMsb) { if (result_type_bit_width != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "this instruction is currently limited to 32-bit width " << "components"; } } } break; } case GLSLstd450Radians: case GLSLstd450Degrees: case GLSLstd450Sin: case GLSLstd450Cos: case GLSLstd450Tan: case GLSLstd450Asin: case GLSLstd450Acos: case GLSLstd450Atan: case GLSLstd450Sinh: case GLSLstd450Cosh: case GLSLstd450Tanh: case GLSLstd450Asinh: case GLSLstd450Acosh: case GLSLstd450Atanh: case GLSLstd450Exp: case GLSLstd450Exp2: case GLSLstd450Log: case GLSLstd450Log2: case GLSLstd450Atan2: case GLSLstd450Pow: { bool supportsCoopVec = (ext_inst_key == GLSLstd450Atan || ext_inst_key == GLSLstd450Tanh || ext_inst_key == GLSLstd450Exp || ext_inst_key == GLSLstd450Log); if (!_.IsFloatScalarOrVectorType(result_type) && !(supportsCoopVec && _.IsFloatCooperativeVectorNVType(result_type))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a 16 or 32-bit scalar or " "vector float type"; } const uint32_t result_type_bit_width = _.GetBitWidth(result_type); if (result_type_bit_width != 16 && result_type_bit_width != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a 16 or 32-bit scalar or " "vector float type"; } for (uint32_t operand_index = 4; operand_index < num_operands; ++operand_index) { const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index); if (result_type != operand_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected types of all operands to be equal to Result " "Type"; } } break; } case GLSLstd450Determinant: { const uint32_t x_type = _.GetOperandTypeId(inst, 4); uint32_t num_rows = 0; uint32_t num_cols = 0; uint32_t col_type = 0; uint32_t component_type = 0; if (!_.GetMatrixTypeInfo(x_type, &num_rows, &num_cols, &col_type, &component_type) || num_rows != num_cols) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand X to be a square matrix"; } if (result_type != component_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand X component type to be equal to " << "Result Type"; } break; } case GLSLstd450MatrixInverse: { uint32_t num_rows = 0; uint32_t num_cols = 0; uint32_t col_type = 0; uint32_t component_type = 0; if (!_.GetMatrixTypeInfo(result_type, &num_rows, &num_cols, &col_type, &component_type) || num_rows != num_cols) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a square matrix"; } const uint32_t x_type = _.GetOperandTypeId(inst, 4); if (result_type != x_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand X type to be equal to Result Type"; } break; } case GLSLstd450Modf: { if (!_.IsFloatScalarOrVectorType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a scalar or vector float type"; } const uint32_t x_type = _.GetOperandTypeId(inst, 4); const uint32_t i_type = _.GetOperandTypeId(inst, 5); if (x_type != result_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand X type to be equal to Result Type"; } spv::StorageClass i_storage_class; uint32_t i_data_type = 0; if (!_.GetPointerTypeInfo(i_type, &i_data_type, &i_storage_class)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand I to be a pointer"; } if (i_data_type != result_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand I data type to be equal to Result Type"; } break; } case GLSLstd450ModfStruct: { std::vector result_types; if (!_.GetStructMemberTypes(result_type, &result_types) || result_types.size() != 2 || !_.IsFloatScalarOrVectorType(result_types[0]) || result_types[1] != result_types[0]) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a struct with two identical " << "scalar or vector float type members"; } const uint32_t x_type = _.GetOperandTypeId(inst, 4); if (x_type != result_types[0]) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand X type to be equal to members of " << "Result Type struct"; } break; } case GLSLstd450Frexp: { if (!_.IsFloatScalarOrVectorType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a scalar or vector float type"; } const uint32_t x_type = _.GetOperandTypeId(inst, 4); const uint32_t exp_type = _.GetOperandTypeId(inst, 5); if (x_type != result_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand X type to be equal to Result Type"; } spv::StorageClass exp_storage_class; uint32_t exp_data_type = 0; if (!_.GetPointerTypeInfo(exp_type, &exp_data_type, &exp_storage_class)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand Exp to be a pointer"; } if (!_.IsIntScalarOrVectorType(exp_data_type) || (!_.HasExtension(kSPV_AMD_gpu_shader_int16) && _.GetBitWidth(exp_data_type) != 32) || (_.HasExtension(kSPV_AMD_gpu_shader_int16) && _.GetBitWidth(exp_data_type) != 16 && _.GetBitWidth(exp_data_type) != 32)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand Exp data type to be a " << (_.HasExtension(kSPV_AMD_gpu_shader_int16) ? "16-bit or 32-bit " : "32-bit ") << "int scalar or vector type"; } if (_.GetDimension(result_type) != _.GetDimension(exp_data_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand Exp data type to have the same component " << "number as Result Type"; } break; } case GLSLstd450Ldexp: { if (!_.IsFloatScalarOrVectorType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a scalar or vector float type"; } const uint32_t x_type = _.GetOperandTypeId(inst, 4); const uint32_t exp_type = _.GetOperandTypeId(inst, 5); if (x_type != result_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand X type to be equal to Result Type"; } if (!_.IsIntScalarOrVectorType(exp_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand Exp to be a 32-bit int scalar " << "or vector type"; } if (_.GetDimension(result_type) != _.GetDimension(exp_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand Exp to have the same component " << "number as Result Type"; } break; } case GLSLstd450FrexpStruct: { std::vector result_types; if (!_.GetStructMemberTypes(result_type, &result_types) || result_types.size() != 2 || !_.IsFloatScalarOrVectorType(result_types[0]) || !_.IsIntScalarOrVectorType(result_types[1]) || (!_.HasExtension(kSPV_AMD_gpu_shader_int16) && _.GetBitWidth(result_types[1]) != 32) || (_.HasExtension(kSPV_AMD_gpu_shader_int16) && _.GetBitWidth(result_types[1]) != 16 && _.GetBitWidth(result_types[1]) != 32) || _.GetDimension(result_types[0]) != _.GetDimension(result_types[1])) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a struct with two members, " << "first member a float scalar or vector, second member a " << (_.HasExtension(kSPV_AMD_gpu_shader_int16) ? "16-bit or 32-bit " : "32-bit ") << "int scalar or vector with the same number of " << "components as the first member"; } const uint32_t x_type = _.GetOperandTypeId(inst, 4); if (x_type != result_types[0]) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand X type to be equal to the first member " << "of Result Type struct"; } break; } case GLSLstd450PackSnorm4x8: case GLSLstd450PackUnorm4x8: { if (!_.IsIntScalarType(result_type) || _.GetBitWidth(result_type) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be 32-bit int scalar type"; } const uint32_t v_type = _.GetOperandTypeId(inst, 4); if (!_.IsFloatVectorType(v_type) || _.GetDimension(v_type) != 4 || _.GetBitWidth(v_type) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand V to be a 32-bit float vector of size 4"; } break; } case GLSLstd450PackSnorm2x16: case GLSLstd450PackUnorm2x16: case GLSLstd450PackHalf2x16: { if (!_.IsIntScalarType(result_type) || _.GetBitWidth(result_type) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be 32-bit int scalar type"; } const uint32_t v_type = _.GetOperandTypeId(inst, 4); if (!_.IsFloatVectorType(v_type) || _.GetDimension(v_type) != 2 || _.GetBitWidth(v_type) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand V to be a 32-bit float vector of size 2"; } break; } case GLSLstd450PackDouble2x32: { if (!_.IsFloatScalarType(result_type) || _.GetBitWidth(result_type) != 64) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be 64-bit float scalar type"; } const uint32_t v_type = _.GetOperandTypeId(inst, 4); if (!_.IsIntVectorType(v_type) || _.GetDimension(v_type) != 2 || _.GetBitWidth(v_type) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand V to be a 32-bit int vector of size 2"; } break; } case GLSLstd450UnpackSnorm4x8: case GLSLstd450UnpackUnorm4x8: { if (!_.IsFloatVectorType(result_type) || _.GetDimension(result_type) != 4 || _.GetBitWidth(result_type) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a 32-bit float vector of size " "4"; } const uint32_t v_type = _.GetOperandTypeId(inst, 4); if (!_.IsIntScalarType(v_type) || _.GetBitWidth(v_type) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand P to be a 32-bit int scalar"; } break; } case GLSLstd450UnpackSnorm2x16: case GLSLstd450UnpackUnorm2x16: case GLSLstd450UnpackHalf2x16: { if (!_.IsFloatVectorType(result_type) || _.GetDimension(result_type) != 2 || _.GetBitWidth(result_type) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a 32-bit float vector of size " "2"; } const uint32_t v_type = _.GetOperandTypeId(inst, 4); if (!_.IsIntScalarType(v_type) || _.GetBitWidth(v_type) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand P to be a 32-bit int scalar"; } break; } case GLSLstd450UnpackDouble2x32: { if (!_.IsIntVectorType(result_type) || _.GetDimension(result_type) != 2 || _.GetBitWidth(result_type) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a 32-bit int vector of size " "2"; } const uint32_t v_type = _.GetOperandTypeId(inst, 4); if (!_.IsFloatScalarType(v_type) || _.GetBitWidth(v_type) != 64) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand V to be a 64-bit float scalar"; } break; } case GLSLstd450Length: { if (!_.IsFloatScalarType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a float scalar type"; } const uint32_t x_type = _.GetOperandTypeId(inst, 4); if (!_.IsFloatScalarOrVectorType(x_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand X to be of float scalar or vector type"; } if (result_type != _.GetComponentType(x_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand X component type to be equal to Result " "Type"; } break; } case GLSLstd450Distance: { if (!_.IsFloatScalarType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a float scalar type"; } const uint32_t p0_type = _.GetOperandTypeId(inst, 4); if (!_.IsFloatScalarOrVectorType(p0_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand P0 to be of float scalar or vector type"; } if (result_type != _.GetComponentType(p0_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand P0 component type to be equal to " << "Result Type"; } const uint32_t p1_type = _.GetOperandTypeId(inst, 5); if (!_.IsFloatScalarOrVectorType(p1_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand P1 to be of float scalar or vector type"; } if (result_type != _.GetComponentType(p1_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand P1 component type to be equal to " << "Result Type"; } if (_.GetDimension(p0_type) != _.GetDimension(p1_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operands P0 and P1 to have the same number of " << "components"; } break; } case GLSLstd450Cross: { if (!_.IsFloatVectorType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a float vector type"; } if (_.GetDimension(result_type) != 3) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to have 3 components"; } const uint32_t x_type = _.GetOperandTypeId(inst, 4); const uint32_t y_type = _.GetOperandTypeId(inst, 5); if (x_type != result_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand X type to be equal to Result Type"; } if (y_type != result_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand Y type to be equal to Result Type"; } break; } case GLSLstd450Refract: { if (!_.IsFloatScalarOrVectorType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a float scalar or vector type"; } const uint32_t i_type = _.GetOperandTypeId(inst, 4); const uint32_t n_type = _.GetOperandTypeId(inst, 5); const uint32_t eta_type = _.GetOperandTypeId(inst, 6); if (result_type != i_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand I to be of type equal to Result Type"; } if (result_type != n_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand N to be of type equal to Result Type"; } if (!_.IsFloatScalarType(eta_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand Eta to be a float scalar"; } break; } case GLSLstd450InterpolateAtCentroid: case GLSLstd450InterpolateAtSample: case GLSLstd450InterpolateAtOffset: { if (!_.HasCapability(spv::Capability::InterpolationFunction)) { return _.diag(SPV_ERROR_INVALID_CAPABILITY, inst) << ext_inst_name() << " requires capability InterpolationFunction"; } if (!_.IsFloatScalarOrVectorType(result_type) || _.GetBitWidth(result_type) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a 32-bit float scalar " << "or vector type"; } // If HLSL legalization and first operand is an OpLoad, use load // pointer as the interpolant lvalue. Else use interpolate first // operand. uint32_t interp_id = inst->GetOperandAs(4); auto* interp_inst = _.FindDef(interp_id); uint32_t interpolant_type = (_.options()->before_hlsl_legalization && interp_inst->opcode() == spv::Op::OpLoad) ? _.GetOperandTypeId(interp_inst, 2) : _.GetOperandTypeId(inst, 4); spv::StorageClass interpolant_storage_class; uint32_t interpolant_data_type = 0; if (!_.GetPointerTypeInfo(interpolant_type, &interpolant_data_type, &interpolant_storage_class)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Interpolant to be a pointer"; } if (result_type != interpolant_data_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Interpolant data type to be equal to Result Type"; } if (interpolant_storage_class != spv::StorageClass::Input) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Interpolant storage class to be Input"; } if (ext_inst_key == GLSLstd450InterpolateAtSample) { const uint32_t sample_type = _.GetOperandTypeId(inst, 5); if (!_.IsIntScalarType(sample_type) || _.GetBitWidth(sample_type) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Sample to be 32-bit integer"; } } if (ext_inst_key == GLSLstd450InterpolateAtOffset) { const uint32_t offset_type = _.GetOperandTypeId(inst, 5); if (!_.IsFloatVectorType(offset_type) || _.GetDimension(offset_type) != 2 || _.GetBitWidth(offset_type) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Offset to be a vector of 2 32-bit floats"; } } _.function(inst->function()->id()) ->RegisterExecutionModelLimitation( spv::ExecutionModel::Fragment, ext_inst_name() + std::string(" requires Fragment execution model")); break; } case GLSLstd450IMix: { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Extended instruction GLSLstd450IMix is not supported"; } case GLSLstd450Bad: { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Encountered extended instruction GLSLstd450Bad"; } case GLSLstd450Count: { assert(0); break; } } } else if (ext_inst_type == SPV_EXT_INST_TYPE_OPENCL_STD) { const OpenCLLIB::Entrypoints ext_inst_key = OpenCLLIB::Entrypoints(ext_inst_index); switch (ext_inst_key) { case OpenCLLIB::Acos: case OpenCLLIB::Acosh: case OpenCLLIB::Acospi: case OpenCLLIB::Asin: case OpenCLLIB::Asinh: case OpenCLLIB::Asinpi: case OpenCLLIB::Atan: case OpenCLLIB::Atan2: case OpenCLLIB::Atanh: case OpenCLLIB::Atanpi: case OpenCLLIB::Atan2pi: case OpenCLLIB::Cbrt: case OpenCLLIB::Ceil: case OpenCLLIB::Copysign: case OpenCLLIB::Cos: case OpenCLLIB::Cosh: case OpenCLLIB::Cospi: case OpenCLLIB::Erfc: case OpenCLLIB::Erf: case OpenCLLIB::Exp: case OpenCLLIB::Exp2: case OpenCLLIB::Exp10: case OpenCLLIB::Expm1: case OpenCLLIB::Fabs: case OpenCLLIB::Fdim: case OpenCLLIB::Floor: case OpenCLLIB::Fma: case OpenCLLIB::Fmax: case OpenCLLIB::Fmin: case OpenCLLIB::Fmod: case OpenCLLIB::Hypot: case OpenCLLIB::Lgamma: case OpenCLLIB::Log: case OpenCLLIB::Log2: case OpenCLLIB::Log10: case OpenCLLIB::Log1p: case OpenCLLIB::Logb: case OpenCLLIB::Mad: case OpenCLLIB::Maxmag: case OpenCLLIB::Minmag: case OpenCLLIB::Nextafter: case OpenCLLIB::Pow: case OpenCLLIB::Powr: case OpenCLLIB::Remainder: case OpenCLLIB::Rint: case OpenCLLIB::Round: case OpenCLLIB::Rsqrt: case OpenCLLIB::Sin: case OpenCLLIB::Sinh: case OpenCLLIB::Sinpi: case OpenCLLIB::Sqrt: case OpenCLLIB::Tan: case OpenCLLIB::Tanh: case OpenCLLIB::Tanpi: case OpenCLLIB::Tgamma: case OpenCLLIB::Trunc: case OpenCLLIB::Half_cos: case OpenCLLIB::Half_divide: case OpenCLLIB::Half_exp: case OpenCLLIB::Half_exp2: case OpenCLLIB::Half_exp10: case OpenCLLIB::Half_log: case OpenCLLIB::Half_log2: case OpenCLLIB::Half_log10: case OpenCLLIB::Half_powr: case OpenCLLIB::Half_recip: case OpenCLLIB::Half_rsqrt: case OpenCLLIB::Half_sin: case OpenCLLIB::Half_sqrt: case OpenCLLIB::Half_tan: case OpenCLLIB::Native_cos: case OpenCLLIB::Native_divide: case OpenCLLIB::Native_exp: case OpenCLLIB::Native_exp2: case OpenCLLIB::Native_exp10: case OpenCLLIB::Native_log: case OpenCLLIB::Native_log2: case OpenCLLIB::Native_log10: case OpenCLLIB::Native_powr: case OpenCLLIB::Native_recip: case OpenCLLIB::Native_rsqrt: case OpenCLLIB::Native_sin: case OpenCLLIB::Native_sqrt: case OpenCLLIB::Native_tan: case OpenCLLIB::FClamp: case OpenCLLIB::Degrees: case OpenCLLIB::FMax_common: case OpenCLLIB::FMin_common: case OpenCLLIB::Mix: case OpenCLLIB::Radians: case OpenCLLIB::Step: case OpenCLLIB::Smoothstep: case OpenCLLIB::Sign: { if (!_.IsFloatScalarOrVectorType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a float scalar or vector type"; } const uint32_t num_components = _.GetDimension(result_type); if (num_components > 4 && num_components != 8 && num_components != 16) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a scalar or a vector with 2, " "3, 4, 8 or 16 components"; } for (uint32_t operand_index = 4; operand_index < num_operands; ++operand_index) { const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index); if (result_type != operand_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected types of all operands to be equal to Result " "Type"; } } break; } case OpenCLLIB::Fract: case OpenCLLIB::Modf: case OpenCLLIB::Sincos: { if (!_.IsFloatScalarOrVectorType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a float scalar or vector type"; } const uint32_t num_components = _.GetDimension(result_type); if (num_components > 4 && num_components != 8 && num_components != 16) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a scalar or a vector with 2, " "3, 4, 8 or 16 components"; } const uint32_t x_type = _.GetOperandTypeId(inst, 4); if (result_type != x_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected type of operand X to be equal to Result Type"; } const uint32_t p_type = _.GetOperandTypeId(inst, 5); spv::StorageClass p_storage_class; uint32_t p_data_type = 0; if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected the last operand to be a pointer"; } if (p_storage_class != spv::StorageClass::Generic && p_storage_class != spv::StorageClass::CrossWorkgroup && p_storage_class != spv::StorageClass::Workgroup && p_storage_class != spv::StorageClass::Function) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected storage class of the pointer to be Generic, " "CrossWorkgroup, Workgroup or Function"; } if (!_.ContainsUntypedPointer(p_type) && result_type != p_data_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected data type of the pointer to be equal to Result " "Type"; } break; } case OpenCLLIB::Frexp: case OpenCLLIB::Lgamma_r: case OpenCLLIB::Remquo: { if (!_.IsFloatScalarOrVectorType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a float scalar or vector type"; } const uint32_t num_components = _.GetDimension(result_type); if (num_components > 4 && num_components != 8 && num_components != 16) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a scalar or a vector with 2, " "3, 4, 8 or 16 components"; } uint32_t operand_index = 4; const uint32_t x_type = _.GetOperandTypeId(inst, operand_index++); if (result_type != x_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected type of operand X to be equal to Result Type"; } if (ext_inst_key == OpenCLLIB::Remquo) { const uint32_t y_type = _.GetOperandTypeId(inst, operand_index++); if (result_type != y_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected type of operand Y to be equal to Result Type"; } } const uint32_t p_type = _.GetOperandTypeId(inst, operand_index++); spv::StorageClass p_storage_class; uint32_t p_data_type = 0; if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected the last operand to be a pointer"; } if (p_storage_class != spv::StorageClass::Generic && p_storage_class != spv::StorageClass::CrossWorkgroup && p_storage_class != spv::StorageClass::Workgroup && p_storage_class != spv::StorageClass::Function) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected storage class of the pointer to be Generic, " "CrossWorkgroup, Workgroup or Function"; } if ((!_.IsIntScalarOrVectorType(p_data_type) || _.GetBitWidth(p_data_type) != 32) && !_.ContainsUntypedPointer(p_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected data type of the pointer to be a 32-bit int " "scalar or vector type"; } if (!_.ContainsUntypedPointer(p_type) && _.GetDimension(p_data_type) != num_components) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected data type of the pointer to have the same number " "of components as Result Type"; } break; } case OpenCLLIB::Ilogb: { if (!_.IsIntScalarOrVectorType(result_type) || _.GetBitWidth(result_type) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a 32-bit int scalar or vector " "type"; } const uint32_t num_components = _.GetDimension(result_type); if (num_components > 4 && num_components != 8 && num_components != 16) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a scalar or a vector with 2, " "3, 4, 8 or 16 components"; } const uint32_t x_type = _.GetOperandTypeId(inst, 4); if (!_.IsFloatScalarOrVectorType(x_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand X to be a float scalar or vector"; } if (_.GetDimension(x_type) != num_components) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand X to have the same number of components " "as Result Type"; } break; } case OpenCLLIB::Ldexp: case OpenCLLIB::Pown: case OpenCLLIB::Rootn: { if (!_.IsFloatScalarOrVectorType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a float scalar or vector type"; } const uint32_t num_components = _.GetDimension(result_type); if (num_components > 4 && num_components != 8 && num_components != 16) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a scalar or a vector with 2, " "3, 4, 8 or 16 components"; } const uint32_t x_type = _.GetOperandTypeId(inst, 4); if (result_type != x_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected type of operand X to be equal to Result Type"; } const uint32_t exp_type = _.GetOperandTypeId(inst, 5); if (!_.IsIntScalarOrVectorType(exp_type) || _.GetBitWidth(exp_type) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected the exponent to be a 32-bit int scalar or vector"; } if (_.GetDimension(exp_type) != num_components) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected the exponent to have the same number of " "components as Result Type"; } break; } case OpenCLLIB::Nan: { if (!_.IsFloatScalarOrVectorType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a float scalar or vector type"; } const uint32_t num_components = _.GetDimension(result_type); if (num_components > 4 && num_components != 8 && num_components != 16) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a scalar or a vector with 2, " "3, 4, 8 or 16 components"; } const uint32_t nancode_type = _.GetOperandTypeId(inst, 4); if (!_.IsIntScalarOrVectorType(nancode_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Nancode to be an int scalar or vector type"; } if (_.GetDimension(nancode_type) != num_components) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Nancode to have the same number of components as " "Result Type"; } if (_.GetBitWidth(result_type) != _.GetBitWidth(nancode_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Nancode to have the same bit width as Result " "Type"; } break; } case OpenCLLIB::SAbs: case OpenCLLIB::SAbs_diff: case OpenCLLIB::SAdd_sat: case OpenCLLIB::UAdd_sat: case OpenCLLIB::SHadd: case OpenCLLIB::UHadd: case OpenCLLIB::SRhadd: case OpenCLLIB::URhadd: case OpenCLLIB::SClamp: case OpenCLLIB::UClamp: case OpenCLLIB::Clz: case OpenCLLIB::Ctz: case OpenCLLIB::SMad_hi: case OpenCLLIB::UMad_sat: case OpenCLLIB::SMad_sat: case OpenCLLIB::SMax: case OpenCLLIB::UMax: case OpenCLLIB::SMin: case OpenCLLIB::UMin: case OpenCLLIB::SMul_hi: case OpenCLLIB::Rotate: case OpenCLLIB::SSub_sat: case OpenCLLIB::USub_sat: case OpenCLLIB::Popcount: case OpenCLLIB::UAbs: case OpenCLLIB::UAbs_diff: case OpenCLLIB::UMul_hi: case OpenCLLIB::UMad_hi: { if (!_.IsIntScalarOrVectorType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be an int scalar or vector type"; } const uint32_t num_components = _.GetDimension(result_type); if (num_components > 4 && num_components != 8 && num_components != 16) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a scalar or a vector with 2, " "3, 4, 8 or 16 components"; } for (uint32_t operand_index = 4; operand_index < num_operands; ++operand_index) { const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index); if (result_type != operand_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected types of all operands to be equal to Result " "Type"; } } break; } case OpenCLLIB::U_Upsample: case OpenCLLIB::S_Upsample: { if (!_.IsIntScalarOrVectorType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be an int scalar or vector " "type"; } const uint32_t result_num_components = _.GetDimension(result_type); if (result_num_components > 4 && result_num_components != 8 && result_num_components != 16) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a scalar or a vector with 2, " "3, 4, 8 or 16 components"; } const uint32_t result_bit_width = _.GetBitWidth(result_type); if (result_bit_width != 16 && result_bit_width != 32 && result_bit_width != 64) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected bit width of Result Type components to be 16, 32 " "or 64"; } const uint32_t hi_type = _.GetOperandTypeId(inst, 4); const uint32_t lo_type = _.GetOperandTypeId(inst, 5); if (hi_type != lo_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Hi and Lo operands to have the same type"; } if (result_num_components != _.GetDimension(hi_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Hi and Lo operands to have the same number of " "components as Result Type"; } if (result_bit_width != 2 * _.GetBitWidth(hi_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected bit width of components of Hi and Lo operands to " "be half of the bit width of components of Result Type"; } break; } case OpenCLLIB::SMad24: case OpenCLLIB::UMad24: case OpenCLLIB::SMul24: case OpenCLLIB::UMul24: { if (!_.IsIntScalarOrVectorType(result_type) || _.GetBitWidth(result_type) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a 32-bit int scalar or vector " "type"; } const uint32_t num_components = _.GetDimension(result_type); if (num_components > 4 && num_components != 8 && num_components != 16) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a scalar or a vector with 2, " "3, 4, 8 or 16 components"; } for (uint32_t operand_index = 4; operand_index < num_operands; ++operand_index) { const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index); if (result_type != operand_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected types of all operands to be equal to Result " "Type"; } } break; } case OpenCLLIB::Cross: { if (!_.IsFloatVectorType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a float vector type"; } const uint32_t num_components = _.GetDimension(result_type); if (num_components != 3 && num_components != 4) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to have 3 or 4 components"; } const uint32_t x_type = _.GetOperandTypeId(inst, 4); const uint32_t y_type = _.GetOperandTypeId(inst, 5); if (x_type != result_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand X type to be equal to Result Type"; } if (y_type != result_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand Y type to be equal to Result Type"; } break; } case OpenCLLIB::Distance: case OpenCLLIB::Fast_distance: { if (!_.IsFloatScalarType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a float scalar type"; } const uint32_t p0_type = _.GetOperandTypeId(inst, 4); if (!_.IsFloatScalarOrVectorType(p0_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand P0 to be of float scalar or vector type"; } const uint32_t num_components = _.GetDimension(p0_type); if (num_components > 4) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand P0 to have no more than 4 components"; } if (result_type != _.GetComponentType(p0_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand P0 component type to be equal to " << "Result Type"; } const uint32_t p1_type = _.GetOperandTypeId(inst, 5); if (p0_type != p1_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operands P0 and P1 to be of the same type"; } break; } case OpenCLLIB::Length: case OpenCLLIB::Fast_length: { if (!_.IsFloatScalarType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a float scalar type"; } const uint32_t p_type = _.GetOperandTypeId(inst, 4); if (!_.IsFloatScalarOrVectorType(p_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand P to be a float scalar or vector"; } const uint32_t num_components = _.GetDimension(p_type); if (num_components > 4) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand P to have no more than 4 components"; } if (result_type != _.GetComponentType(p_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand P component type to be equal to Result " "Type"; } break; } case OpenCLLIB::Normalize: case OpenCLLIB::Fast_normalize: { if (!_.IsFloatScalarOrVectorType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a float scalar or vector type"; } const uint32_t num_components = _.GetDimension(result_type); if (num_components > 4) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to have no more than 4 components"; } const uint32_t p_type = _.GetOperandTypeId(inst, 4); if (p_type != result_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand P type to be equal to Result Type"; } break; } case OpenCLLIB::Bitselect: { if (!_.IsFloatScalarOrVectorType(result_type) && !_.IsIntScalarOrVectorType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be an int or float scalar or " "vector type"; } const uint32_t num_components = _.GetDimension(result_type); if (num_components > 4 && num_components != 8 && num_components != 16) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a scalar or a vector with 2, " "3, 4, 8 or 16 components"; } for (uint32_t operand_index = 4; operand_index < num_operands; ++operand_index) { const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index); if (result_type != operand_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected types of all operands to be equal to Result " "Type"; } } break; } case OpenCLLIB::Select: { if (!_.IsFloatScalarOrVectorType(result_type) && !_.IsIntScalarOrVectorType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be an int or float scalar or " "vector type"; } const uint32_t num_components = _.GetDimension(result_type); if (num_components > 4 && num_components != 8 && num_components != 16) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a scalar or a vector with 2, " "3, 4, 8 or 16 components"; } const uint32_t a_type = _.GetOperandTypeId(inst, 4); const uint32_t b_type = _.GetOperandTypeId(inst, 5); const uint32_t c_type = _.GetOperandTypeId(inst, 6); if (result_type != a_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand A type to be equal to Result Type"; } if (result_type != b_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand B type to be equal to Result Type"; } if (!_.IsIntScalarOrVectorType(c_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand C to be an int scalar or vector"; } if (num_components != _.GetDimension(c_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand C to have the same number of components " "as Result Type"; } if (_.GetBitWidth(result_type) != _.GetBitWidth(c_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand C to have the same bit width as Result " "Type"; } break; } case OpenCLLIB::Vloadn: { if (!_.IsFloatVectorType(result_type) && !_.IsIntVectorType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be an int or float vector type"; } const uint32_t num_components = _.GetDimension(result_type); if (num_components > 4 && num_components != 8 && num_components != 16) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to have 2, 3, 4, 8 or 16 components"; } const uint32_t offset_type = _.GetOperandTypeId(inst, 4); const uint32_t p_type = _.GetOperandTypeId(inst, 5); const uint32_t size_t_bit_width = GetSizeTBitWidth(_); if (!size_t_bit_width) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << " can only be used with physical addressing models"; } if (!_.IsIntScalarType(offset_type) || _.GetBitWidth(offset_type) != size_t_bit_width) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand Offset to be of type size_t (" << size_t_bit_width << "-bit integer for the addressing model used in the module)"; } spv::StorageClass p_storage_class; uint32_t p_data_type = 0; if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand P to be a pointer"; } if (p_storage_class != spv::StorageClass::UniformConstant && p_storage_class != spv::StorageClass::Generic && p_storage_class != spv::StorageClass::CrossWorkgroup && p_storage_class != spv::StorageClass::Workgroup && p_storage_class != spv::StorageClass::Function) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand P storage class to be UniformConstant, " "Generic, CrossWorkgroup, Workgroup or Function"; } if (_.GetComponentType(result_type) != p_data_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand P data type to be equal to component " "type of Result Type"; } const uint32_t n_value = inst->word(7); if (num_components != n_value) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected literal N to be equal to the number of " "components of Result Type"; } break; } case OpenCLLIB::Vstoren: { if (_.GetIdOpcode(result_type) != spv::Op::OpTypeVoid) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": expected Result Type to be void"; } const uint32_t data_type = _.GetOperandTypeId(inst, 4); const uint32_t offset_type = _.GetOperandTypeId(inst, 5); const uint32_t p_type = _.GetOperandTypeId(inst, 6); if (!_.IsFloatVectorType(data_type) && !_.IsIntVectorType(data_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Data to be an int or float vector"; } const uint32_t num_components = _.GetDimension(data_type); if (num_components > 4 && num_components != 8 && num_components != 16) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Data to have 2, 3, 4, 8 or 16 components"; } const uint32_t size_t_bit_width = GetSizeTBitWidth(_); if (!size_t_bit_width) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << " can only be used with physical addressing models"; } if (!_.IsIntScalarType(offset_type) || _.GetBitWidth(offset_type) != size_t_bit_width) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand Offset to be of type size_t (" << size_t_bit_width << "-bit integer for the addressing model used in the module)"; } spv::StorageClass p_storage_class; uint32_t p_data_type = 0; if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand P to be a pointer"; } if (p_storage_class != spv::StorageClass::Generic && p_storage_class != spv::StorageClass::CrossWorkgroup && p_storage_class != spv::StorageClass::Workgroup && p_storage_class != spv::StorageClass::Function) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand P storage class to be Generic, " "CrossWorkgroup, Workgroup or Function"; } if (_.GetComponentType(data_type) != p_data_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand P data type to be equal to the type of " "operand Data components"; } break; } case OpenCLLIB::Vload_half: { if (!_.IsFloatScalarType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a float scalar type"; } const uint32_t offset_type = _.GetOperandTypeId(inst, 4); const uint32_t p_type = _.GetOperandTypeId(inst, 5); const uint32_t size_t_bit_width = GetSizeTBitWidth(_); if (!size_t_bit_width) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << " can only be used with physical addressing models"; } if (!_.IsIntScalarType(offset_type) || _.GetBitWidth(offset_type) != size_t_bit_width) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand Offset to be of type size_t (" << size_t_bit_width << "-bit integer for the addressing model used in the module)"; } spv::StorageClass p_storage_class; uint32_t p_data_type = 0; if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand P to be a pointer"; } if (p_storage_class != spv::StorageClass::UniformConstant && p_storage_class != spv::StorageClass::Generic && p_storage_class != spv::StorageClass::CrossWorkgroup && p_storage_class != spv::StorageClass::Workgroup && p_storage_class != spv::StorageClass::Function) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand P storage class to be UniformConstant, " "Generic, CrossWorkgroup, Workgroup or Function"; } if ((!_.IsFloatScalarType(p_data_type) || _.GetBitWidth(p_data_type) != 16) && !_.ContainsUntypedPointer(p_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand P data type to be 16-bit float scalar"; } break; } case OpenCLLIB::Vload_halfn: case OpenCLLIB::Vloada_halfn: { if (!_.IsFloatVectorType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a float vector type"; } const uint32_t num_components = _.GetDimension(result_type); if (num_components > 4 && num_components != 8 && num_components != 16) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to have 2, 3, 4, 8 or 16 components"; } const uint32_t offset_type = _.GetOperandTypeId(inst, 4); const uint32_t p_type = _.GetOperandTypeId(inst, 5); const uint32_t size_t_bit_width = GetSizeTBitWidth(_); if (!size_t_bit_width) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << " can only be used with physical addressing models"; } if (!_.IsIntScalarType(offset_type) || _.GetBitWidth(offset_type) != size_t_bit_width) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand Offset to be of type size_t (" << size_t_bit_width << "-bit integer for the addressing model used in the module)"; } spv::StorageClass p_storage_class; uint32_t p_data_type = 0; if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand P to be a pointer"; } if (p_storage_class != spv::StorageClass::UniformConstant && p_storage_class != spv::StorageClass::Generic && p_storage_class != spv::StorageClass::CrossWorkgroup && p_storage_class != spv::StorageClass::Workgroup && p_storage_class != spv::StorageClass::Function) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand P storage class to be UniformConstant, " "Generic, CrossWorkgroup, Workgroup or Function"; } if ((!_.IsFloatScalarType(p_data_type) || _.GetBitWidth(p_data_type) != 16) && !_.ContainsUntypedPointer(p_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand P data type to be 16-bit float scalar"; } const uint32_t n_value = inst->word(7); if (num_components != n_value) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected literal N to be equal to the number of " "components of Result Type"; } break; } case OpenCLLIB::Vstore_half: case OpenCLLIB::Vstore_half_r: case OpenCLLIB::Vstore_halfn: case OpenCLLIB::Vstore_halfn_r: case OpenCLLIB::Vstorea_halfn: case OpenCLLIB::Vstorea_halfn_r: { if (_.GetIdOpcode(result_type) != spv::Op::OpTypeVoid) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": expected Result Type to be void"; } const uint32_t data_type = _.GetOperandTypeId(inst, 4); const uint32_t offset_type = _.GetOperandTypeId(inst, 5); const uint32_t p_type = _.GetOperandTypeId(inst, 6); const uint32_t data_type_bit_width = _.GetBitWidth(data_type); if (ext_inst_key == OpenCLLIB::Vstore_half || ext_inst_key == OpenCLLIB::Vstore_half_r) { if (!_.IsFloatScalarType(data_type) || (data_type_bit_width != 32 && data_type_bit_width != 64)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Data to be a 32 or 64-bit float scalar"; } } else { if (!_.IsFloatVectorType(data_type) || (data_type_bit_width != 32 && data_type_bit_width != 64)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Data to be a 32 or 64-bit float vector"; } const uint32_t num_components = _.GetDimension(data_type); if (num_components > 4 && num_components != 8 && num_components != 16) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Data to have 2, 3, 4, 8 or 16 components"; } } const uint32_t size_t_bit_width = GetSizeTBitWidth(_); if (!size_t_bit_width) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << " can only be used with physical addressing models"; } if (!_.IsIntScalarType(offset_type) || _.GetBitWidth(offset_type) != size_t_bit_width) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand Offset to be of type size_t (" << size_t_bit_width << "-bit integer for the addressing model used in the module)"; } spv::StorageClass p_storage_class; uint32_t p_data_type = 0; if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand P to be a pointer"; } if (p_storage_class != spv::StorageClass::Generic && p_storage_class != spv::StorageClass::CrossWorkgroup && p_storage_class != spv::StorageClass::Workgroup && p_storage_class != spv::StorageClass::Function) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand P storage class to be Generic, " "CrossWorkgroup, Workgroup or Function"; } if ((!_.IsFloatScalarType(p_data_type) || _.GetBitWidth(p_data_type) != 16) && !_.ContainsUntypedPointer(p_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand P data type to be 16-bit float scalar"; } // Rounding mode enum is checked by assembler. break; } case OpenCLLIB::Shuffle: case OpenCLLIB::Shuffle2: { if (!_.IsFloatVectorType(result_type) && !_.IsIntVectorType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be an int or float vector type"; } const uint32_t result_num_components = _.GetDimension(result_type); if (result_num_components != 2 && result_num_components != 4 && result_num_components != 8 && result_num_components != 16) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to have 2, 4, 8 or 16 components"; } uint32_t operand_index = 4; const uint32_t x_type = _.GetOperandTypeId(inst, operand_index++); if (ext_inst_key == OpenCLLIB::Shuffle2) { const uint32_t y_type = _.GetOperandTypeId(inst, operand_index++); if (x_type != y_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operands X and Y to be of the same type"; } } const uint32_t shuffle_mask_type = _.GetOperandTypeId(inst, operand_index++); if (!_.IsFloatVectorType(x_type) && !_.IsIntVectorType(x_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand X to be an int or float vector"; } const uint32_t x_num_components = _.GetDimension(x_type); if (x_num_components != 2 && x_num_components != 4 && x_num_components != 8 && x_num_components != 16) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand X to have 2, 4, 8 or 16 components"; } const uint32_t result_component_type = _.GetComponentType(result_type); if (result_component_type != _.GetComponentType(x_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand X and Result Type to have equal " "component types"; } if (!_.IsIntVectorType(shuffle_mask_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand Shuffle Mask to be an int vector"; } if (result_num_components != _.GetDimension(shuffle_mask_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand Shuffle Mask to have the same number of " "components as Result Type"; } if (_.GetBitWidth(result_component_type) != _.GetBitWidth(shuffle_mask_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand Shuffle Mask components to have the same " "bit width as Result Type components"; } break; } case OpenCLLIB::Printf: { if (!_.IsIntScalarType(result_type) || _.GetBitWidth(result_type) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a 32-bit int type"; } const uint32_t format_type = _.GetOperandTypeId(inst, 4); spv::StorageClass format_storage_class; uint32_t format_data_type = 0; if (!_.GetPointerTypeInfo(format_type, &format_data_type, &format_storage_class)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand Format to be a pointer"; } if (_.HasExtension( Extension::kSPV_EXT_relaxed_printf_string_address_space)) { if (format_storage_class != spv::StorageClass::UniformConstant && // Extension SPV_EXT_relaxed_printf_string_address_space allows // format strings in Global, Local, Private and Generic address // spaces // Global format_storage_class != spv::StorageClass::CrossWorkgroup && // Local format_storage_class != spv::StorageClass::Workgroup && // Private format_storage_class != spv::StorageClass::Function && // Generic format_storage_class != spv::StorageClass::Generic) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Format storage class to be UniformConstant, " "Crossworkgroup, Workgroup, Function, or Generic"; } } else { if (format_storage_class != spv::StorageClass::UniformConstant) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Format storage class to be UniformConstant"; } } // If pointer points to an array, get the type of an element if (_.IsIntArrayType(format_data_type)) format_data_type = _.GetComponentType(format_data_type); if ((!_.IsIntScalarType(format_data_type) || _.GetBitWidth(format_data_type) != 8) && !_.ContainsUntypedPointer(format_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Format data type to be 8-bit int"; } break; } case OpenCLLIB::Prefetch: { if (_.GetIdOpcode(result_type) != spv::Op::OpTypeVoid) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": expected Result Type to be void"; } const uint32_t p_type = _.GetOperandTypeId(inst, 4); const uint32_t num_elements_type = _.GetOperandTypeId(inst, 5); spv::StorageClass p_storage_class; uint32_t p_data_type = 0; if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand Ptr to be a pointer"; } if (p_storage_class != spv::StorageClass::CrossWorkgroup) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand Ptr storage class to be CrossWorkgroup"; } if (!_.IsFloatScalarOrVectorType(p_data_type) && !_.IsIntScalarOrVectorType(p_data_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Ptr data type to be int or float scalar or " "vector"; } const uint32_t num_components = _.GetDimension(p_data_type); if (num_components > 4 && num_components != 8 && num_components != 16) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected Result Type to be a scalar or a vector with 2, " "3, 4, 8 or 16 components"; } const uint32_t size_t_bit_width = GetSizeTBitWidth(_); if (!size_t_bit_width) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << " can only be used with physical addressing models"; } if (!_.IsIntScalarType(num_elements_type) || _.GetBitWidth(num_elements_type) != size_t_bit_width) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand Num Elements to be of type size_t (" << size_t_bit_width << "-bit integer for the addressing model used in the module)"; } break; } } } else if (ext_inst_type == SPV_EXT_INST_TYPE_OPENCL_DEBUGINFO_100 || ext_inst_type == SPV_EXT_INST_TYPE_NONSEMANTIC_SHADER_DEBUGINFO_100) { if (!_.IsVoidType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected result type must be a result id of " << "OpTypeVoid"; } const bool vulkanDebugInfo = ext_inst_type == SPV_EXT_INST_TYPE_NONSEMANTIC_SHADER_DEBUGINFO_100; auto num_words = inst->words().size(); // Handle any non-common NonSemanticShaderDebugInfo instructions. if (vulkanDebugInfo) { const NonSemanticShaderDebugInfo100Instructions ext_inst_key = NonSemanticShaderDebugInfo100Instructions(ext_inst_index); switch (ext_inst_key) { // The following block of instructions will be handled by the common // validation. case NonSemanticShaderDebugInfo100DebugInfoNone: case NonSemanticShaderDebugInfo100DebugCompilationUnit: case NonSemanticShaderDebugInfo100DebugTypePointer: case NonSemanticShaderDebugInfo100DebugTypeQualifier: case NonSemanticShaderDebugInfo100DebugTypeArray: case NonSemanticShaderDebugInfo100DebugTypeVector: case NonSemanticShaderDebugInfo100DebugTypedef: case NonSemanticShaderDebugInfo100DebugTypeFunction: case NonSemanticShaderDebugInfo100DebugTypeEnum: case NonSemanticShaderDebugInfo100DebugTypeComposite: case NonSemanticShaderDebugInfo100DebugTypeMember: case NonSemanticShaderDebugInfo100DebugTypeInheritance: case NonSemanticShaderDebugInfo100DebugTypePtrToMember: case NonSemanticShaderDebugInfo100DebugTypeTemplate: case NonSemanticShaderDebugInfo100DebugTypeTemplateParameter: case NonSemanticShaderDebugInfo100DebugTypeTemplateTemplateParameter: case NonSemanticShaderDebugInfo100DebugTypeTemplateParameterPack: case NonSemanticShaderDebugInfo100DebugGlobalVariable: case NonSemanticShaderDebugInfo100DebugFunctionDeclaration: case NonSemanticShaderDebugInfo100DebugFunction: case NonSemanticShaderDebugInfo100DebugLexicalBlock: case NonSemanticShaderDebugInfo100DebugLexicalBlockDiscriminator: case NonSemanticShaderDebugInfo100DebugScope: case NonSemanticShaderDebugInfo100DebugNoScope: case NonSemanticShaderDebugInfo100DebugInlinedAt: case NonSemanticShaderDebugInfo100DebugLocalVariable: case NonSemanticShaderDebugInfo100DebugInlinedVariable: case NonSemanticShaderDebugInfo100DebugValue: case NonSemanticShaderDebugInfo100DebugOperation: case NonSemanticShaderDebugInfo100DebugExpression: case NonSemanticShaderDebugInfo100DebugMacroDef: case NonSemanticShaderDebugInfo100DebugMacroUndef: case NonSemanticShaderDebugInfo100DebugImportedEntity: case NonSemanticShaderDebugInfo100DebugSource: break; // These checks are for operands that are differnet in // ShaderDebugInfo100 case NonSemanticShaderDebugInfo100DebugTypeBasic: { CHECK_CONST_UINT_OPERAND("Flags", 8); break; } case NonSemanticShaderDebugInfo100DebugDeclare: { for (uint32_t word_index = 8; word_index < num_words; ++word_index) { auto index_inst = _.FindDef(inst->word(word_index)); auto type_id = index_inst != nullptr ? index_inst->type_id() : 0; if (type_id == 0 || !IsIntScalar(_, type_id, false, false)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected index must be scalar integer"; } break; } case NonSemanticShaderDebugInfo100DebugTypeMatrix: { CHECK_DEBUG_OPERAND("Vector Type", CommonDebugInfoDebugTypeVector, 5); CHECK_CONST_UINT_OPERAND("Vector Count", 6); uint32_t vector_count = inst->word(6); uint64_t const_val; if (!_.EvalConstantValUint64(vector_count, &const_val)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": Vector Count must be 32-bit integer OpConstant"; } vector_count = const_val & 0xffffffff; if (!vector_count || vector_count > 4) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": Vector Count must be positive " << "integer less than or equal to 4"; } break; } case NonSemanticShaderDebugInfo100DebugFunctionDefinition: { CHECK_DEBUG_OPERAND("Function", CommonDebugInfoDebugFunction, 5); CHECK_OPERAND("Definition", spv::Op::OpFunction, 6); const auto* current_function = inst->function(); if (current_function->first_block()->id() != inst->block()->id()) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": must be in the entry basic block of the function"; } const uint32_t definition_id = inst->word(6); if (definition_id != current_function->id()) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": operand Definition must point to the OpFunction it is " "inside"; } break; } case NonSemanticShaderDebugInfo100DebugLine: { CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 5); CHECK_CONST_UINT_OPERAND("Line Start", 6); CHECK_CONST_UINT_OPERAND("Line End", 7); CHECK_CONST_UINT_OPERAND("Column Start", 8); CHECK_CONST_UINT_OPERAND("Column End", 9); // above already validates if 32-bit and non-spec constant // but want to use EvalInt32IfConst to be consistent with other Eval // locations bool is_int32 = false, is_const_int32 = false; uint32_t line_start = 0; uint32_t line_end = 0; uint32_t column_start = 0; uint32_t column_end = 0; std::tie(is_int32, is_const_int32, line_start) = _.EvalInt32IfConst(inst->word(6)); std::tie(is_int32, is_const_int32, line_end) = _.EvalInt32IfConst(inst->word(7)); std::tie(is_int32, is_const_int32, column_start) = _.EvalInt32IfConst(inst->word(8)); std::tie(is_int32, is_const_int32, column_end) = _.EvalInt32IfConst(inst->word(9)); if (line_end < line_start) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": operand Line End (" << line_end << ") is less than Line Start (" << line_start << ")"; } else if (line_start == line_end && column_end < column_start) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": operand Column End (" << column_end << ") is less than Column Start (" << column_start << ") when Line Start equals Line End"; } break; } case NonSemanticShaderDebugInfo100DebugSourceContinued: { CHECK_OPERAND("Text", spv::Op::OpString, 5); break; } case NonSemanticShaderDebugInfo100DebugBuildIdentifier: { CHECK_OPERAND("Identifier", spv::Op::OpString, 5); CHECK_CONST_UINT_OPERAND("Flags", 6); break; } case NonSemanticShaderDebugInfo100DebugStoragePath: { CHECK_OPERAND("Path", spv::Op::OpString, 5); break; } case NonSemanticShaderDebugInfo100DebugEntryPoint: { CHECK_DEBUG_OPERAND("Entry Point", CommonDebugInfoDebugFunction, 5); CHECK_DEBUG_OPERAND("Compilation Unit", CommonDebugInfoDebugCompilationUnit, 6); CHECK_OPERAND("Compiler Signature", spv::Op::OpString, 7); CHECK_OPERAND("Command-line Arguments", spv::Op::OpString, 8); break; } // Has no additional checks case NonSemanticShaderDebugInfo100DebugNoLine: break; case NonSemanticShaderDebugInfo100InstructionsMax: assert(0); break; } } // Handle any non-common OpenCL insts, then common if (ext_inst_type != SPV_EXT_INST_TYPE_OPENCL_DEBUGINFO_100 || OpenCLDebugInfo100Instructions(ext_inst_index) != OpenCLDebugInfo100DebugModuleINTEL) { const CommonDebugInfoInstructions ext_inst_key = CommonDebugInfoInstructions(ext_inst_index); switch (ext_inst_key) { case CommonDebugInfoDebugInfoNone: case CommonDebugInfoDebugNoScope: break; // The binary parser validates the opcode for DebugInfoNone, // DebugNoScope, DebugOperation. We just check the parameters to // DebugOperation are properly constants for vulkan debug info. case CommonDebugInfoDebugOperation: { CHECK_CONST_UINT_OPERAND("Operation", 5); for (uint32_t i = 6; i < num_words; ++i) { CHECK_CONST_UINT_OPERAND("Operand", i); } break; } case CommonDebugInfoDebugCompilationUnit: { CHECK_CONST_UINT_OPERAND("Version", 5); CHECK_CONST_UINT_OPERAND("DWARF Version", 6); CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 7); CHECK_CONST_UINT_OPERAND("Language", 8); break; } case CommonDebugInfoDebugSource: { CHECK_OPERAND("File", spv::Op::OpString, 5); if (num_words == 7) CHECK_OPERAND("Text", spv::Op::OpString, 6); break; } case CommonDebugInfoDebugTypeBasic: { CHECK_OPERAND("Name", spv::Op::OpString, 5); CHECK_OPERAND("Size", spv::Op::OpConstant, 6); CHECK_CONST_UINT_OPERAND("Encoding", 7); break; } case CommonDebugInfoDebugTypePointer: { auto validate_base_type = ValidateOperandDebugType( _, "Base Type", inst, 5, ext_inst_name, false); if (validate_base_type != SPV_SUCCESS) return validate_base_type; CHECK_CONST_UINT_OPERAND("Storage Class", 6); CHECK_CONST_UINT_OPERAND("Flags", 7); break; } case CommonDebugInfoDebugTypeQualifier: { auto validate_base_type = ValidateOperandDebugType( _, "Base Type", inst, 5, ext_inst_name, false); if (validate_base_type != SPV_SUCCESS) return validate_base_type; CHECK_CONST_UINT_OPERAND("Type Qualifier", 6); break; } case CommonDebugInfoDebugTypeVector: { auto validate_base_type = ValidateOperandBaseType(_, inst, 5, ext_inst_name); if (validate_base_type != SPV_SUCCESS) return validate_base_type; CHECK_CONST_UINT_OPERAND("Component Count", 6); uint32_t component_count = inst->word(6); if (vulkanDebugInfo) { uint64_t const_val; if (!_.EvalConstantValUint64(component_count, &const_val)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": Component Count must be 32-bit integer OpConstant"; } component_count = const_val & 0xffffffff; } if (!component_count || component_count > 4) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": Component Count must be positive " << "integer less than or equal to 4"; } break; } case CommonDebugInfoDebugTypeArray: { auto validate_base_type = ValidateOperandDebugType( _, "Base Type", inst, 5, ext_inst_name, false); if (validate_base_type != SPV_SUCCESS) return validate_base_type; for (uint32_t i = 6; i < num_words; ++i) { bool invalid = false; auto* component_count = _.FindDef(inst->word(i)); if (IsConstIntScalarTypeWith32Or64Bits(_, component_count)) { // TODO: We need a spec discussion for the runtime array for // OpenCL. if (!vulkanDebugInfo && !component_count->word(3)) { invalid = true; } } else if (component_count->words().size() > 6 && (CommonDebugInfoInstructions(component_count->word(4)) == CommonDebugInfoDebugLocalVariable || CommonDebugInfoInstructions(component_count->word(4)) == CommonDebugInfoDebugGlobalVariable)) { auto* component_count_type = _.FindDef(component_count->word(6)); if (component_count_type->words().size() > 7) { uint32_t encoding = component_count_type->word(7); if (CommonDebugInfoInstructions(component_count_type->word( 4)) != CommonDebugInfoDebugTypeBasic || (vulkanDebugInfo && !IsUint32Constant(_, encoding)) || OpenCLDebugInfo100DebugBaseTypeAttributeEncoding( vulkanDebugInfo ? GetUint32Constant(_, encoding) : encoding) != OpenCLDebugInfo100Unsigned) { invalid = true; } else { // DebugTypeBasic for DebugLocalVariable/DebugGlobalVariable // must have Unsigned encoding and 32 or 64 as its size in // bits. Instruction* size_in_bits = _.FindDef(component_count_type->word(6)); if (!_.IsIntScalarType(size_in_bits->type_id()) || (size_in_bits->word(3) != 32 && size_in_bits->word(3) != 64)) { invalid = true; } } } else { invalid = true; } } else { invalid = true; } if (invalid) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": Component Count must be " << "OpConstant with a 32- or 64-bits integer scalar type " "or " << "DebugGlobalVariable or DebugLocalVariable with a 32- " "or " << "64-bits unsigned integer scalar type"; } } break; } case CommonDebugInfoDebugTypedef: { CHECK_OPERAND("Name", spv::Op::OpString, 5); auto validate_base_type = ValidateOperandBaseType(_, inst, 6, ext_inst_name); if (validate_base_type != SPV_SUCCESS) return validate_base_type; CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 7); CHECK_CONST_UINT_OPERAND("Line", 8); CHECK_CONST_UINT_OPERAND("Column", 9); auto validate_parent = ValidateOperandLexicalScope(_, "Parent", inst, 10, ext_inst_name); if (validate_parent != SPV_SUCCESS) return validate_parent; break; } case CommonDebugInfoDebugTypeFunction: { CHECK_CONST_UINT_OPERAND("Flags", 5); auto* return_type = _.FindDef(inst->word(6)); // TODO: We need a spec discussion that we have to allow return and // parameter types of a DebugTypeFunction to have template parameter. if (return_type->opcode() != spv::Op::OpTypeVoid) { auto validate_return = ValidateOperandDebugType( _, "Return Type", inst, 6, ext_inst_name, true); if (validate_return != SPV_SUCCESS) return validate_return; } for (uint32_t word_index = 7; word_index < num_words; ++word_index) { auto validate_param = ValidateOperandDebugType( _, "Parameter Types", inst, word_index, ext_inst_name, true); if (validate_param != SPV_SUCCESS) return validate_param; } break; } case CommonDebugInfoDebugTypeEnum: { CHECK_OPERAND("Name", spv::Op::OpString, 5); if (!DoesDebugInfoOperandMatchExpectation( _, [](CommonDebugInfoInstructions dbg_inst) { return dbg_inst == CommonDebugInfoDebugInfoNone; }, inst, 6)) { auto validate_underlying_type = ValidateOperandDebugType( _, "Underlying Types", inst, 6, ext_inst_name, false); if (validate_underlying_type != SPV_SUCCESS) return validate_underlying_type; } CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 7); CHECK_CONST_UINT_OPERAND("Line", 8); CHECK_CONST_UINT_OPERAND("Column", 9); auto validate_parent = ValidateOperandLexicalScope(_, "Parent", inst, 10, ext_inst_name); if (validate_parent != SPV_SUCCESS) return validate_parent; CHECK_OPERAND("Size", spv::Op::OpConstant, 11); auto* size = _.FindDef(inst->word(11)); if (!_.IsIntScalarType(size->type_id()) || !size->word(3)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": expected operand Size is a " << "positive integer"; } CHECK_CONST_UINT_OPERAND("Flags", 12); for (uint32_t word_index = 13; word_index + 1 < num_words; word_index += 2) { CHECK_OPERAND("Value", spv::Op::OpConstant, word_index); CHECK_OPERAND("Name", spv::Op::OpString, word_index + 1); } break; } case CommonDebugInfoDebugTypeComposite: { CHECK_OPERAND("Name", spv::Op::OpString, 5); CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 7); CHECK_CONST_UINT_OPERAND("Line", 8); CHECK_CONST_UINT_OPERAND("Column", 9); auto validate_parent = ValidateOperandLexicalScope(_, "Parent", inst, 10, ext_inst_name); if (validate_parent != SPV_SUCCESS) return validate_parent; CHECK_OPERAND("Linkage Name", spv::Op::OpString, 11); if (!DoesDebugInfoOperandMatchExpectation( _, [](CommonDebugInfoInstructions dbg_inst) { return dbg_inst == CommonDebugInfoDebugInfoNone; }, inst, 12)) { CHECK_OPERAND("Size", spv::Op::OpConstant, 12); } CHECK_CONST_UINT_OPERAND("Flags", 13); for (uint32_t word_index = 14; word_index < num_words; ++word_index) { if (!DoesDebugInfoOperandMatchExpectation( _, [](CommonDebugInfoInstructions dbg_inst) { return dbg_inst == CommonDebugInfoDebugTypeMember || dbg_inst == CommonDebugInfoDebugFunction || dbg_inst == CommonDebugInfoDebugTypeInheritance; }, inst, word_index)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand Members " << "must be DebugTypeMember, DebugFunction, or " "DebugTypeInheritance"; } } break; } case CommonDebugInfoDebugTypeMember: { CHECK_OPERAND("Name", spv::Op::OpString, 5); // TODO: We need a spec discussion that we have to allow member types // to have template parameter. auto validate_type = ValidateOperandDebugType(_, "Type", inst, 6, ext_inst_name, true); if (validate_type != SPV_SUCCESS) return validate_type; CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 7); CHECK_CONST_UINT_OPERAND("Line", 8); CHECK_CONST_UINT_OPERAND("Column", 9); // NonSemantic.Shader.DebugInfo doesn't have the Parent operand if (vulkanDebugInfo) { CHECK_OPERAND("Offset", spv::Op::OpConstant, 10); CHECK_OPERAND("Size", spv::Op::OpConstant, 11); CHECK_CONST_UINT_OPERAND("Flags", 12); if (num_words == 14) CHECK_OPERAND("Value", spv::Op::OpConstant, 13); } else { CHECK_DEBUG_OPERAND("Parent", CommonDebugInfoDebugTypeComposite, 10); CHECK_OPERAND("Offset", spv::Op::OpConstant, 11); CHECK_OPERAND("Size", spv::Op::OpConstant, 12); CHECK_CONST_UINT_OPERAND("Flags", 13); if (num_words == 15) CHECK_OPERAND("Value", spv::Op::OpConstant, 14); } break; } case CommonDebugInfoDebugTypeInheritance: { CHECK_DEBUG_OPERAND("Child", CommonDebugInfoDebugTypeComposite, 5); auto* debug_inst = _.FindDef(inst->word(5)); auto composite_type = OpenCLDebugInfo100DebugCompositeType(debug_inst->word(6)); if (composite_type != OpenCLDebugInfo100Class && composite_type != OpenCLDebugInfo100Structure) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand Child must be class or struct debug " "type"; } CHECK_DEBUG_OPERAND("Parent", CommonDebugInfoDebugTypeComposite, 6); debug_inst = _.FindDef(inst->word(6)); composite_type = OpenCLDebugInfo100DebugCompositeType(debug_inst->word(6)); if (composite_type != OpenCLDebugInfo100Class && composite_type != OpenCLDebugInfo100Structure) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand Parent must be class or struct debug " "type"; } CHECK_OPERAND("Offset", spv::Op::OpConstant, 7); CHECK_OPERAND("Size", spv::Op::OpConstant, 8); CHECK_CONST_UINT_OPERAND("Flags", 9); break; } case CommonDebugInfoDebugFunction: { CHECK_OPERAND("Name", spv::Op::OpString, 5); CHECK_DEBUG_OPERAND("Type", CommonDebugInfoDebugTypeFunction, 6); CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 7); CHECK_CONST_UINT_OPERAND("Line", 8); CHECK_CONST_UINT_OPERAND("Column", 9); auto validate_parent = ValidateOperandLexicalScope(_, "Parent", inst, 10, ext_inst_name); if (validate_parent != SPV_SUCCESS) return validate_parent; CHECK_OPERAND("Linkage Name", spv::Op::OpString, 11); CHECK_CONST_UINT_OPERAND("Flags", 12); CHECK_CONST_UINT_OPERAND("Scope Line", 13); // NonSemantic.Shader.DebugInfo.100 doesn't include a reference to the // OpFunction if (vulkanDebugInfo) { if (num_words == 15) { CHECK_DEBUG_OPERAND("Declaration", CommonDebugInfoDebugFunctionDeclaration, 14); } } else { if (!DoesDebugInfoOperandMatchExpectation( _, [](CommonDebugInfoInstructions dbg_inst) { return dbg_inst == CommonDebugInfoDebugInfoNone; }, inst, 14)) { CHECK_OPERAND("Function", spv::Op::OpFunction, 14); } if (num_words == 16) { CHECK_DEBUG_OPERAND("Declaration", CommonDebugInfoDebugFunctionDeclaration, 15); } } break; } case CommonDebugInfoDebugFunctionDeclaration: { CHECK_OPERAND("Name", spv::Op::OpString, 5); CHECK_DEBUG_OPERAND("Type", CommonDebugInfoDebugTypeFunction, 6); CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 7); CHECK_CONST_UINT_OPERAND("Line", 8); CHECK_CONST_UINT_OPERAND("Column", 9); auto validate_parent = ValidateOperandLexicalScope(_, "Parent", inst, 10, ext_inst_name); if (validate_parent != SPV_SUCCESS) return validate_parent; CHECK_OPERAND("Linkage Name", spv::Op::OpString, 11); CHECK_CONST_UINT_OPERAND("Flags", 12); break; } case CommonDebugInfoDebugLexicalBlock: { CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 5); CHECK_CONST_UINT_OPERAND("Line", 6); CHECK_CONST_UINT_OPERAND("Column", 7); auto validate_parent = ValidateOperandLexicalScope(_, "Parent", inst, 8, ext_inst_name); if (validate_parent != SPV_SUCCESS) return validate_parent; if (num_words == 10) CHECK_OPERAND("Name", spv::Op::OpString, 9); break; } case CommonDebugInfoDebugScope: { auto validate_scope = ValidateOperandLexicalScope(_, "Scope", inst, 5, ext_inst_name); if (validate_scope != SPV_SUCCESS) return validate_scope; if (num_words == 7) { CHECK_DEBUG_OPERAND("Inlined At", CommonDebugInfoDebugInlinedAt, 6); } break; } case CommonDebugInfoDebugLocalVariable: { CHECK_OPERAND("Name", spv::Op::OpString, 5); // TODO: We need a spec discussion that we have to allow local // variable types to have template parameter. auto validate_type = ValidateOperandDebugType(_, "Type", inst, 6, ext_inst_name, true); if (validate_type != SPV_SUCCESS) return validate_type; CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 7); CHECK_CONST_UINT_OPERAND("Line", 8); CHECK_CONST_UINT_OPERAND("Column", 9); auto validate_parent = ValidateOperandLexicalScope(_, "Parent", inst, 10, ext_inst_name); if (validate_parent != SPV_SUCCESS) return validate_parent; CHECK_CONST_UINT_OPERAND("Flags", 11); if (num_words == 13) { CHECK_CONST_UINT_OPERAND("ArgNumber", 12); } break; } case CommonDebugInfoDebugDeclare: { CHECK_DEBUG_OPERAND("Local Variable", CommonDebugInfoDebugLocalVariable, 5); auto* operand = _.FindDef(inst->word(6)); if (operand->opcode() != spv::Op::OpVariable && operand->opcode() != spv::Op::OpFunctionParameter) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand Variable must be a result id of " "OpVariable or OpFunctionParameter"; } CHECK_DEBUG_OPERAND("Expression", CommonDebugInfoDebugExpression, 7); break; } case CommonDebugInfoDebugExpression: { for (uint32_t word_index = 5; word_index < num_words; ++word_index) { CHECK_DEBUG_OPERAND("Operation", CommonDebugInfoDebugOperation, word_index); } break; } case CommonDebugInfoDebugTypeTemplate: { if (!DoesDebugInfoOperandMatchExpectation( _, [](CommonDebugInfoInstructions dbg_inst) { return dbg_inst == CommonDebugInfoDebugTypeComposite || dbg_inst == CommonDebugInfoDebugFunction; }, inst, 5)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand Target must be DebugTypeComposite " << "or DebugFunction"; } for (uint32_t word_index = 6; word_index < num_words; ++word_index) { if (!DoesDebugInfoOperandMatchExpectation( _, [](CommonDebugInfoInstructions dbg_inst) { return dbg_inst == CommonDebugInfoDebugTypeTemplateParameter || dbg_inst == CommonDebugInfoDebugTypeTemplateTemplateParameter; }, inst, word_index)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand Parameters must be " << "DebugTypeTemplateParameter or " << "DebugTypeTemplateTemplateParameter"; } } break; } case CommonDebugInfoDebugTypeTemplateParameter: { CHECK_OPERAND("Name", spv::Op::OpString, 5); auto validate_actual_type = ValidateOperandDebugType( _, "Actual Type", inst, 6, ext_inst_name, false); if (validate_actual_type != SPV_SUCCESS) return validate_actual_type; if (!DoesDebugInfoOperandMatchExpectation( _, [](CommonDebugInfoInstructions dbg_inst) { return dbg_inst == CommonDebugInfoDebugInfoNone; }, inst, 7)) { CHECK_OPERAND("Value", spv::Op::OpConstant, 7); } CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 8); CHECK_CONST_UINT_OPERAND("Line", 9); CHECK_CONST_UINT_OPERAND("Column", 10); break; } case CommonDebugInfoDebugGlobalVariable: { CHECK_OPERAND("Name", spv::Op::OpString, 5); auto validate_type = ValidateOperandDebugType(_, "Type", inst, 6, ext_inst_name, false); if (validate_type != SPV_SUCCESS) return validate_type; CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 7); CHECK_CONST_UINT_OPERAND("Line", 8); CHECK_CONST_UINT_OPERAND("Column", 9); auto validate_scope = ValidateOperandLexicalScope(_, "Scope", inst, 10, ext_inst_name); if (validate_scope != SPV_SUCCESS) return validate_scope; CHECK_OPERAND("Linkage Name", spv::Op::OpString, 11); if (!DoesDebugInfoOperandMatchExpectation( _, [](CommonDebugInfoInstructions dbg_inst) { return dbg_inst == CommonDebugInfoDebugInfoNone; }, inst, 12)) { auto* operand = _.FindDef(inst->word(12)); if (operand->opcode() != spv::Op::OpVariable && operand->opcode() != spv::Op::OpConstant) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": " << "expected operand Variable must be a result id of " "OpVariable or OpConstant or DebugInfoNone"; } } if (num_words == 15) { CHECK_DEBUG_OPERAND("Static Member Declaration", CommonDebugInfoDebugTypeMember, 14); } break; } case CommonDebugInfoDebugInlinedAt: { CHECK_CONST_UINT_OPERAND("Line", 5); auto validate_scope = ValidateOperandLexicalScope(_, "Scope", inst, 6, ext_inst_name); if (validate_scope != SPV_SUCCESS) return validate_scope; if (num_words == 8) { CHECK_DEBUG_OPERAND("Inlined", CommonDebugInfoDebugInlinedAt, 7); } break; } case CommonDebugInfoDebugValue: { CHECK_DEBUG_OPERAND("Local Variable", CommonDebugInfoDebugLocalVariable, 5); CHECK_DEBUG_OPERAND("Expression", CommonDebugInfoDebugExpression, 7); for (uint32_t word_index = 8; word_index < num_words; ++word_index) { // TODO: The following code simply checks if it is a const int // scalar or a DebugLocalVariable or DebugGlobalVariable, but we // have to check it using the same validation for Indexes of // OpAccessChain. if (!IsConstWithIntScalarType(_, inst, word_index) && !IsDebugVariableWithIntScalarType(_, inst, word_index)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << ext_inst_name() << ": expected operand Indexes is " << "OpConstant, DebugGlobalVariable, or " << "type is OpConstant with an integer scalar type"; } } break; } // TODO: Add validation rules for remaining cases as well. case CommonDebugInfoDebugTypePtrToMember: case CommonDebugInfoDebugTypeTemplateTemplateParameter: case CommonDebugInfoDebugTypeTemplateParameterPack: case CommonDebugInfoDebugLexicalBlockDiscriminator: case CommonDebugInfoDebugInlinedVariable: case CommonDebugInfoDebugMacroDef: case CommonDebugInfoDebugMacroUndef: case CommonDebugInfoDebugImportedEntity: break; case CommonDebugInfoInstructionsMax: assert(0); break; } } } else if (ext_inst_type == SPV_EXT_INST_TYPE_NONSEMANTIC_CLSPVREFLECTION) { auto import_inst = _.FindDef(inst->GetOperandAs(2)); const std::string name = import_inst->GetOperandAs(1); const std::string reflection = "NonSemantic.ClspvReflection."; char* end_ptr; auto version_string = name.substr(reflection.size()); if (version_string.empty()) { return _.diag(SPV_ERROR_INVALID_DATA, import_inst) << "Missing NonSemantic.ClspvReflection import version"; } uint32_t version = static_cast( std::strtoul(version_string.c_str(), &end_ptr, 10)); if (end_ptr && *end_ptr != '\0') { return _.diag(SPV_ERROR_INVALID_DATA, import_inst) << "NonSemantic.ClspvReflection import does not encode the " "version correctly"; } if (version == 0 || version > NonSemanticClspvReflectionRevision) { return _.diag(SPV_ERROR_INVALID_DATA, import_inst) << "Unknown NonSemantic.ClspvReflection import version"; } return ValidateClspvReflectionInstruction(_, inst, version); } return SPV_SUCCESS; } spv_result_t ExtensionPass(ValidationState_t& _, const Instruction* inst) { const spv::Op opcode = inst->opcode(); if (opcode == spv::Op::OpExtension) return ValidateExtension(_, inst); if (opcode == spv::Op::OpExtInstImport) return ValidateExtInstImport(_, inst); if (spvIsExtendedInstruction(opcode)) return ValidateExtInst(_, inst); return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_function.cpp000066400000000000000000000345351475742701700250270ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "source/enum_string_mapping.h" #include "source/opcode.h" #include "source/val/instruction.h" #include "source/val/validate.h" #include "source/val/validation_state.h" namespace spvtools { namespace val { namespace { // Returns true if |a| and |b| are instructions defining pointers that point to // types logically match and the decorations that apply to |b| are a subset // of the decorations that apply to |a|. bool DoPointeesLogicallyMatch(val::Instruction* a, val::Instruction* b, ValidationState_t& _) { if (a->opcode() != spv::Op::OpTypePointer || b->opcode() != spv::Op::OpTypePointer) { return false; } const auto& dec_a = _.id_decorations(a->id()); const auto& dec_b = _.id_decorations(b->id()); for (const auto& dec : dec_b) { if (std::find(dec_a.begin(), dec_a.end(), dec) == dec_a.end()) { return false; } } uint32_t a_type = a->GetOperandAs(2); uint32_t b_type = b->GetOperandAs(2); if (a_type == b_type) { return true; } Instruction* a_type_inst = _.FindDef(a_type); Instruction* b_type_inst = _.FindDef(b_type); return _.LogicallyMatch(a_type_inst, b_type_inst, true); } spv_result_t ValidateFunction(ValidationState_t& _, const Instruction* inst) { const auto function_type_id = inst->GetOperandAs(3); const auto function_type = _.FindDef(function_type_id); if (!function_type || spv::Op::OpTypeFunction != function_type->opcode()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpFunction Function Type " << _.getIdName(function_type_id) << " is not a function type."; } const auto return_id = function_type->GetOperandAs(1); if (return_id != inst->type_id()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpFunction Result Type " << _.getIdName(inst->type_id()) << " does not match the Function Type's return type " << _.getIdName(return_id) << "."; } const std::vector acceptable = { spv::Op::OpGroupDecorate, spv::Op::OpDecorate, spv::Op::OpEnqueueKernel, spv::Op::OpEntryPoint, spv::Op::OpExecutionMode, spv::Op::OpExecutionModeId, spv::Op::OpFunctionCall, spv::Op::OpGetKernelNDrangeSubGroupCount, spv::Op::OpGetKernelNDrangeMaxSubGroupSize, spv::Op::OpGetKernelWorkGroupSize, spv::Op::OpGetKernelPreferredWorkGroupSizeMultiple, spv::Op::OpGetKernelLocalSizeForSubgroupCount, spv::Op::OpGetKernelMaxNumSubgroups, spv::Op::OpName, spv::Op::OpCooperativeMatrixPerElementOpNV, spv::Op::OpCooperativeMatrixReduceNV, spv::Op::OpCooperativeMatrixLoadTensorNV}; for (auto& pair : inst->uses()) { const auto* use = pair.first; if (std::find(acceptable.begin(), acceptable.end(), use->opcode()) == acceptable.end() && !use->IsNonSemantic() && !use->IsDebugInfo()) { return _.diag(SPV_ERROR_INVALID_ID, use) << "Invalid use of function result id " << _.getIdName(inst->id()) << "."; } } return SPV_SUCCESS; } spv_result_t ValidateFunctionParameter(ValidationState_t& _, const Instruction* inst) { // NOTE: Find OpFunction & ensure OpFunctionParameter is not out of place. size_t param_index = 0; size_t inst_num = inst->LineNum() - 1; if (inst_num == 0) { return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) << "Function parameter cannot be the first instruction."; } auto func_inst = &_.ordered_instructions()[inst_num]; while (--inst_num) { func_inst = &_.ordered_instructions()[inst_num]; if (func_inst->opcode() == spv::Op::OpFunction) { break; } else if (func_inst->opcode() == spv::Op::OpFunctionParameter) { ++param_index; } } if (func_inst->opcode() != spv::Op::OpFunction) { return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) << "Function parameter must be preceded by a function."; } const auto function_type_id = func_inst->GetOperandAs(3); const auto function_type = _.FindDef(function_type_id); if (!function_type) { return _.diag(SPV_ERROR_INVALID_ID, func_inst) << "Missing function type definition."; } if (param_index >= function_type->words().size() - 3) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Too many OpFunctionParameters for " << func_inst->id() << ": expected " << function_type->words().size() - 3 << " based on the function's type"; } const auto param_type = _.FindDef(function_type->GetOperandAs(param_index + 2)); if (!param_type || inst->type_id() != param_type->id()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpFunctionParameter Result Type " << _.getIdName(inst->type_id()) << " does not match the OpTypeFunction parameter " "type of the same index."; } return SPV_SUCCESS; } spv_result_t ValidateFunctionCall(ValidationState_t& _, const Instruction* inst) { const auto function_id = inst->GetOperandAs(2); const auto function = _.FindDef(function_id); if (!function || spv::Op::OpFunction != function->opcode()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpFunctionCall Function " << _.getIdName(function_id) << " is not a function."; } auto return_type = _.FindDef(function->type_id()); if (!return_type || return_type->id() != inst->type_id()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpFunctionCall Result Type " << _.getIdName(inst->type_id()) << "s type does not match Function " << _.getIdName(return_type->id()) << "s return type."; } const auto function_type_id = function->GetOperandAs(3); const auto function_type = _.FindDef(function_type_id); if (!function_type || function_type->opcode() != spv::Op::OpTypeFunction) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Missing function type definition."; } const auto function_call_arg_count = inst->words().size() - 4; const auto function_param_count = function_type->words().size() - 3; if (function_param_count != function_call_arg_count) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpFunctionCall Function 's parameter count does not match " "the argument count."; } for (size_t argument_index = 3, param_index = 2; argument_index < inst->operands().size(); argument_index++, param_index++) { const auto argument_id = inst->GetOperandAs(argument_index); const auto argument = _.FindDef(argument_id); if (!argument) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Missing argument " << argument_index - 3 << " definition."; } const auto argument_type = _.FindDef(argument->type_id()); if (!argument_type) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Missing argument " << argument_index - 3 << " type definition."; } const auto parameter_type_id = function_type->GetOperandAs(param_index); const auto parameter_type = _.FindDef(parameter_type_id); if (!parameter_type || argument_type->id() != parameter_type->id()) { if (!parameter_type || !_.options()->before_hlsl_legalization || !DoPointeesLogicallyMatch(argument_type, parameter_type, _)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpFunctionCall Argument " << _.getIdName(argument_id) << "s type does not match Function " << _.getIdName(parameter_type_id) << "s parameter type."; } } if (_.addressing_model() == spv::AddressingModel::Logical) { if ((parameter_type->opcode() == spv::Op::OpTypePointer || parameter_type->opcode() == spv::Op::OpTypeUntypedPointerKHR) && !_.options()->relax_logical_pointer) { spv::StorageClass sc = parameter_type->GetOperandAs(1u); // Validate which storage classes can be pointer operands. switch (sc) { case spv::StorageClass::UniformConstant: case spv::StorageClass::Function: case spv::StorageClass::Private: case spv::StorageClass::Workgroup: case spv::StorageClass::AtomicCounter: // These are always allowed. break; case spv::StorageClass::StorageBuffer: if (!_.features().variable_pointers) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "StorageBuffer pointer operand " << _.getIdName(argument_id) << " requires a variable pointers capability"; } break; default: return _.diag(SPV_ERROR_INVALID_ID, inst) << "Invalid storage class for pointer operand " << _.getIdName(argument_id); } // Validate memory object declaration requirements. if (argument->opcode() != spv::Op::OpVariable && argument->opcode() != spv::Op::OpUntypedVariableKHR && argument->opcode() != spv::Op::OpFunctionParameter) { const bool ssbo_vptr = _.HasCapability(spv::Capability::VariablePointersStorageBuffer) && sc == spv::StorageClass::StorageBuffer; const bool wg_vptr = _.HasCapability(spv::Capability::VariablePointers) && sc == spv::StorageClass::Workgroup; const bool uc_ptr = sc == spv::StorageClass::UniformConstant; if (!_.options()->before_hlsl_legalization && !ssbo_vptr && !wg_vptr && !uc_ptr) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Pointer operand " << _.getIdName(argument_id) << " must be a memory object declaration"; } } } } } return SPV_SUCCESS; } spv_result_t ValidateCooperativeMatrixPerElementOp(ValidationState_t& _, const Instruction* inst) { const auto function_id = inst->GetOperandAs(3); const auto function = _.FindDef(function_id); if (!function || spv::Op::OpFunction != function->opcode()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpCooperativeMatrixPerElementOpNV Function " << _.getIdName(function_id) << " is not a function."; } const auto matrix_id = inst->GetOperandAs(2); const auto matrix = _.FindDef(matrix_id); const auto matrix_type_id = matrix->type_id(); if (!_.IsCooperativeMatrixKHRType(matrix_type_id)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpCooperativeMatrixPerElementOpNV Matrix " << _.getIdName(matrix_id) << " is not a cooperative matrix."; } const auto result_type_id = inst->GetOperandAs(0); if (matrix_type_id != result_type_id) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpCooperativeMatrixPerElementOpNV Result Type " << _.getIdName(result_type_id) << " must match matrix type " << _.getIdName(matrix_type_id) << "."; } const auto matrix_comp_type_id = _.FindDef(matrix_type_id)->GetOperandAs(1); const auto function_type_id = function->GetOperandAs(3); const auto function_type = _.FindDef(function_type_id); auto return_type_id = function_type->GetOperandAs(1); if (return_type_id != matrix_comp_type_id) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpCooperativeMatrixPerElementOpNV function return type " << _.getIdName(return_type_id) << " must match matrix component type " << _.getIdName(matrix_comp_type_id) << "."; } if (function_type->operands().size() < 5) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpCooperativeMatrixPerElementOpNV function type " << _.getIdName(function_type_id) << " must have a least three parameters."; } const auto param0_id = function_type->GetOperandAs(2); const auto param1_id = function_type->GetOperandAs(3); const auto param2_id = function_type->GetOperandAs(4); if (!_.IsIntScalarType(param0_id) || _.GetBitWidth(param0_id) != 32) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpCooperativeMatrixPerElementOpNV function type first parameter " "type " << _.getIdName(param0_id) << " must be a 32-bit integer."; } if (!_.IsIntScalarType(param1_id) || _.GetBitWidth(param1_id) != 32) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpCooperativeMatrixPerElementOpNV function type second " "parameter type " << _.getIdName(param1_id) << " must be a 32-bit integer."; } if (param2_id != matrix_comp_type_id) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpCooperativeMatrixPerElementOpNV function type third parameter " "type " << _.getIdName(param2_id) << " must match matrix component type."; } return SPV_SUCCESS; } } // namespace spv_result_t FunctionPass(ValidationState_t& _, const Instruction* inst) { switch (inst->opcode()) { case spv::Op::OpFunction: if (auto error = ValidateFunction(_, inst)) return error; break; case spv::Op::OpFunctionParameter: if (auto error = ValidateFunctionParameter(_, inst)) return error; break; case spv::Op::OpFunctionCall: if (auto error = ValidateFunctionCall(_, inst)) return error; break; case spv::Op::OpCooperativeMatrixPerElementOpNV: if (auto error = ValidateCooperativeMatrixPerElementOp(_, inst)) return error; break; default: break; } return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_id.cpp000066400000000000000000000301151475742701700235640ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "source/instruction.h" #include "source/opcode.h" #include "source/operand.h" #include "source/val/function.h" #include "source/val/validate.h" #include "source/val/validation_state.h" #include "spirv-tools/libspirv.h" namespace spvtools { namespace val { spv_result_t UpdateIdUse(ValidationState_t& _, const Instruction* inst) { for (auto& operand : inst->operands()) { const spv_operand_type_t& type = operand.type; const uint32_t operand_id = inst->word(operand.offset); if (spvIsIdType(type) && type != SPV_OPERAND_TYPE_RESULT_ID) { if (auto def = _.FindDef(operand_id)) def->RegisterUse(inst, operand.offset); } } return SPV_SUCCESS; } /// This function checks all ID definitions dominate their use in the CFG. /// /// This function will iterate over all ID definitions that are defined in the /// functions of a module and make sure that the definitions appear in a /// block that dominates their use. /// /// NOTE: This function does NOT check module scoped functions which are /// checked during the initial binary parse in the IdPass below spv_result_t CheckIdDefinitionDominateUse(ValidationState_t& _) { std::vector phi_instructions; std::unordered_set phi_ids; for (const auto& inst : _.ordered_instructions()) { if (inst.id() == 0) continue; if (const Function* func = inst.function()) { if (const BasicBlock* block = inst.block()) { // If the Id is defined within a block then make sure all references to // that Id appear in a blocks that are dominated by the defining block for (auto& use_index_pair : inst.uses()) { const Instruction* use = use_index_pair.first; if (const BasicBlock* use_block = use->block()) { if (use_block->reachable() == false) continue; if (use->opcode() == spv::Op::OpPhi) { if (phi_ids.insert(use->id()).second) { phi_instructions.push_back(use); } } else if (!block->dominates(*use->block())) { return _.diag(SPV_ERROR_INVALID_ID, use_block->label()) << "ID " << _.getIdName(inst.id()) << " defined in block " << _.getIdName(block->id()) << " does not dominate its use in block " << _.getIdName(use_block->id()); } } } } else { // If the Ids defined within a function but not in a block(i.e. function // parameters, block ids), then make sure all references to that Id // appear within the same function for (auto use : inst.uses()) { const Instruction* user = use.first; if (user->function() && user->function() != func) { return _.diag(SPV_ERROR_INVALID_ID, _.FindDef(func->id())) << "ID " << _.getIdName(inst.id()) << " used in function " << _.getIdName(user->function()->id()) << " is used outside of it's defining function " << _.getIdName(func->id()); } } } } // NOTE: Ids defined outside of functions must appear before they are used // This check is being performed in the IdPass function } // Check all OpPhi parent blocks are dominated by the variable's defining // blocks for (const Instruction* phi : phi_instructions) { if (phi->block()->reachable() == false) continue; for (size_t i = 3; i < phi->operands().size(); i += 2) { const Instruction* variable = _.FindDef(phi->word(i)); const BasicBlock* parent = phi->function()->GetBlock(phi->word(i + 1)).first; if (variable->block() && parent->reachable() && !variable->block()->dominates(*parent)) { return _.diag(SPV_ERROR_INVALID_ID, phi) << "In OpPhi instruction " << _.getIdName(phi->id()) << ", ID " << _.getIdName(variable->id()) << " definition does not dominate its parent " << _.getIdName(parent->id()); } } } return SPV_SUCCESS; } // Performs SSA validation on the IDs of an instruction. The // can_have_forward_declared_ids functor should return true if the // instruction operand's ID can be forward referenced. spv_result_t IdPass(ValidationState_t& _, Instruction* inst) { auto can_have_forward_declared_ids = spvIsExtendedInstruction(inst->opcode()) && spvExtInstIsDebugInfo(inst->ext_inst_type()) ? spvDbgInfoExtOperandCanBeForwardDeclaredFunction( inst->opcode(), inst->ext_inst_type(), inst->word(4)) : spvOperandCanBeForwardDeclaredFunction(inst->opcode()); // Keep track of a result id defined by this instruction. 0 means it // does not define an id. uint32_t result_id = 0; bool has_forward_declared_ids = false; for (unsigned i = 0; i < inst->operands().size(); i++) { const spv_parsed_operand_t& operand = inst->operand(i); const spv_operand_type_t& type = operand.type; // We only care about Id operands, which are a single word. const uint32_t operand_word = inst->word(operand.offset); auto ret = SPV_ERROR_INTERNAL; switch (type) { case SPV_OPERAND_TYPE_RESULT_ID: // NOTE: Multiple Id definitions are being checked by the binary parser. // // Defer undefined-forward-reference removal until after we've analyzed // the remaining operands to this instruction. Deferral only matters // for OpPhi since it's the only case where it defines its own forward // reference. Other instructions that can have forward references // either don't define a value or the forward reference is to a function // Id (and hence defined outside of a function body). result_id = operand_word; // NOTE: The result Id is added (in RegisterInstruction) *after* all of // the other Ids have been checked to avoid premature use in the same // instruction. ret = SPV_SUCCESS; break; case SPV_OPERAND_TYPE_ID: case SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID: case SPV_OPERAND_TYPE_SCOPE_ID: if (const auto def = _.FindDef(operand_word)) { const auto opcode = inst->opcode(); if (spvOpcodeGeneratesType(def->opcode()) && !spvOpcodeGeneratesType(opcode) && !spvOpcodeIsDebug(opcode) && !inst->IsDebugInfo() && !inst->IsNonSemantic() && !spvOpcodeIsDecoration(opcode) && opcode != spv::Op::OpFunction && opcode != spv::Op::OpSizeOf && opcode != spv::Op::OpCooperativeMatrixLengthNV && opcode != spv::Op::OpCooperativeMatrixLengthKHR && !spvOpcodeGeneratesUntypedPointer(opcode) && opcode != spv::Op::OpUntypedArrayLengthKHR && !(opcode == spv::Op::OpSpecConstantOp && (spv::Op(inst->word(3)) == spv::Op::OpCooperativeMatrixLengthNV || spv::Op(inst->word(3)) == spv::Op::OpCooperativeMatrixLengthKHR))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Operand " << _.getIdName(operand_word) << " cannot be a type"; } else if (def->type_id() == 0 && !spvOpcodeGeneratesType(opcode) && !spvOpcodeIsDebug(opcode) && !inst->IsDebugInfo() && !inst->IsNonSemantic() && !spvOpcodeIsDecoration(opcode) && !spvOpcodeIsBranch(opcode) && opcode != spv::Op::OpPhi && opcode != spv::Op::OpExtInst && opcode != spv::Op::OpExtInstWithForwardRefsKHR && opcode != spv::Op::OpExtInstImport && opcode != spv::Op::OpSelectionMerge && opcode != spv::Op::OpLoopMerge && opcode != spv::Op::OpFunction && opcode != spv::Op::OpSizeOf && opcode != spv::Op::OpCooperativeMatrixLengthNV && opcode != spv::Op::OpCooperativeMatrixLengthKHR && !spvOpcodeGeneratesUntypedPointer(opcode) && opcode != spv::Op::OpUntypedArrayLengthKHR && !(opcode == spv::Op::OpSpecConstantOp && (spv::Op(inst->word(3)) == spv::Op::OpCooperativeMatrixLengthNV || spv::Op(inst->word(3)) == spv::Op::OpCooperativeMatrixLengthKHR))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Operand " << _.getIdName(operand_word) << " requires a type"; } else if (def->IsNonSemantic() && !inst->IsNonSemantic()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Operand " << _.getIdName(operand_word) << " in semantic instruction cannot be a non-semantic " "instruction"; } else { ret = SPV_SUCCESS; } } else if (can_have_forward_declared_ids(i)) { has_forward_declared_ids = true; if (spvOpcodeGeneratesType(inst->opcode()) && !_.IsForwardPointer(operand_word)) { ret = _.diag(SPV_ERROR_INVALID_ID, inst) << "Operand " << _.getIdName(operand_word) << " requires a previous definition"; } else { ret = _.ForwardDeclareId(operand_word); } } else { ret = _.diag(SPV_ERROR_INVALID_ID, inst) << "ID " << _.getIdName(operand_word) << " has not been defined"; } break; case SPV_OPERAND_TYPE_TYPE_ID: if (_.IsDefinedId(operand_word)) { auto* def = _.FindDef(operand_word); if (!spvOpcodeGeneratesType(def->opcode())) { ret = _.diag(SPV_ERROR_INVALID_ID, inst) << "ID " << _.getIdName(operand_word) << " is not a type id"; } else { ret = SPV_SUCCESS; } } else { ret = _.diag(SPV_ERROR_INVALID_ID, inst) << "ID " << _.getIdName(operand_word) << " has not been defined"; } break; case SPV_OPERAND_TYPE_EXTENSION_INSTRUCTION_NUMBER: // Ideally, this check would live in validate_extensions.cpp. But since // forward references are only allowed on non-semantic instructions, and // ID validation is done first, we would fail with a "ID had not been // defined" error before we could give a more helpful message. For this // reason, this test is done here, so we can be more helpful to the // user. if (inst->opcode() == spv::Op::OpExtInstWithForwardRefsKHR && !inst->IsNonSemantic()) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "OpExtInstWithForwardRefsKHR is only allowed with " "non-semantic instructions."; ret = SPV_SUCCESS; break; default: ret = SPV_SUCCESS; break; } if (SPV_SUCCESS != ret) return ret; } const bool must_have_forward_declared_ids = inst->opcode() == spv::Op::OpExtInstWithForwardRefsKHR; if (must_have_forward_declared_ids && !has_forward_declared_ids) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Opcode OpExtInstWithForwardRefsKHR must have at least one " "forward " "declared ID."; } if (result_id) _.RemoveIfForwardDeclared(result_id); return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_image.cpp000066400000000000000000002740061475742701700242630ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights // reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validates correctness of image instructions. #include #include "source/opcode.h" #include "source/spirv_constant.h" #include "source/spirv_target_env.h" #include "source/util/bitutils.h" #include "source/val/instruction.h" #include "source/val/validate.h" #include "source/val/validate_scopes.h" #include "source/val/validation_state.h" namespace spvtools { namespace val { namespace { // Performs compile time check that all spv::ImageOperandsMask::XXX cases are // handled in this module. If spv::ImageOperandsMask::XXX list changes, this // function will fail the build. For all other purposes this is a placeholder // function. bool CheckAllImageOperandsHandled() { spv::ImageOperandsMask enum_val = spv::ImageOperandsMask::Bias; // Some improvised code to prevent the compiler from considering enum_val // constant and optimizing the switch away. uint32_t stack_var = 0; if (reinterpret_cast(&stack_var) % 256) enum_val = spv::ImageOperandsMask::Lod; switch (enum_val) { // Please update the validation rules in this module if you are changing // the list of image operands, and add new enum values to this switch. case spv::ImageOperandsMask::MaskNone: return false; case spv::ImageOperandsMask::Bias: case spv::ImageOperandsMask::Lod: case spv::ImageOperandsMask::Grad: case spv::ImageOperandsMask::ConstOffset: case spv::ImageOperandsMask::Offset: case spv::ImageOperandsMask::ConstOffsets: case spv::ImageOperandsMask::Sample: case spv::ImageOperandsMask::MinLod: // TODO(dneto): Support image operands related to the Vulkan memory model. // https://gitlab.khronos.org/spirv/spirv-tools/issues/32 case spv::ImageOperandsMask::MakeTexelAvailableKHR: case spv::ImageOperandsMask::MakeTexelVisibleKHR: case spv::ImageOperandsMask::NonPrivateTexelKHR: case spv::ImageOperandsMask::VolatileTexelKHR: case spv::ImageOperandsMask::SignExtend: case spv::ImageOperandsMask::ZeroExtend: // TODO(jaebaek): Move this line properly after handling image offsets // operand. This line temporarily fixes CI failure that // blocks other PRs. // https://github.com/KhronosGroup/SPIRV-Tools/issues/4565 case spv::ImageOperandsMask::Offsets: case spv::ImageOperandsMask::Nontemporal: return true; } return false; } // Used by GetImageTypeInfo. See OpTypeImage spec for more information. struct ImageTypeInfo { uint32_t sampled_type = 0; spv::Dim dim = spv::Dim::Max; uint32_t depth = 0; uint32_t arrayed = 0; uint32_t multisampled = 0; uint32_t sampled = 0; spv::ImageFormat format = spv::ImageFormat::Max; spv::AccessQualifier access_qualifier = spv::AccessQualifier::Max; }; // Provides information on image type. |id| should be object of either // OpTypeImage or OpTypeSampledImage type. Returns false in case of failure // (not a valid id, failed to parse the instruction, etc). bool GetImageTypeInfo(const ValidationState_t& _, uint32_t id, ImageTypeInfo* info) { if (!id || !info) return false; const Instruction* inst = _.FindDef(id); assert(inst); if (inst->opcode() == spv::Op::OpTypeSampledImage) { inst = _.FindDef(inst->word(2)); assert(inst); } if (inst->opcode() != spv::Op::OpTypeImage) return false; const size_t num_words = inst->words().size(); if (num_words != 9 && num_words != 10) return false; info->sampled_type = inst->word(2); info->dim = static_cast(inst->word(3)); info->depth = inst->word(4); info->arrayed = inst->word(5); info->multisampled = inst->word(6); info->sampled = inst->word(7); info->format = static_cast(inst->word(8)); info->access_qualifier = num_words < 10 ? spv::AccessQualifier::Max : static_cast(inst->word(9)); return true; } bool IsImplicitLod(spv::Op opcode) { switch (opcode) { case spv::Op::OpImageSampleImplicitLod: case spv::Op::OpImageSampleDrefImplicitLod: case spv::Op::OpImageSampleProjImplicitLod: case spv::Op::OpImageSampleProjDrefImplicitLod: case spv::Op::OpImageSparseSampleImplicitLod: case spv::Op::OpImageSparseSampleDrefImplicitLod: case spv::Op::OpImageSparseSampleProjImplicitLod: case spv::Op::OpImageSparseSampleProjDrefImplicitLod: return true; default: break; } return false; } bool IsExplicitLod(spv::Op opcode) { switch (opcode) { case spv::Op::OpImageSampleExplicitLod: case spv::Op::OpImageSampleDrefExplicitLod: case spv::Op::OpImageSampleProjExplicitLod: case spv::Op::OpImageSampleProjDrefExplicitLod: case spv::Op::OpImageSparseSampleExplicitLod: case spv::Op::OpImageSparseSampleDrefExplicitLod: case spv::Op::OpImageSparseSampleProjExplicitLod: case spv::Op::OpImageSparseSampleProjDrefExplicitLod: return true; default: break; } return false; } bool IsValidLodOperand(const ValidationState_t& _, spv::Op opcode) { switch (opcode) { case spv::Op::OpImageRead: case spv::Op::OpImageWrite: case spv::Op::OpImageSparseRead: return _.HasCapability(spv::Capability::ImageReadWriteLodAMD); default: return IsExplicitLod(opcode); } } bool IsValidGatherLodBiasAMD(const ValidationState_t& _, spv::Op opcode) { switch (opcode) { case spv::Op::OpImageGather: case spv::Op::OpImageSparseGather: return _.HasCapability(spv::Capability::ImageGatherBiasLodAMD); default: break; } return false; } // Returns true if the opcode is a Image instruction which applies // homogenous projection to the coordinates. bool IsProj(spv::Op opcode) { switch (opcode) { case spv::Op::OpImageSampleProjImplicitLod: case spv::Op::OpImageSampleProjDrefImplicitLod: case spv::Op::OpImageSparseSampleProjImplicitLod: case spv::Op::OpImageSparseSampleProjDrefImplicitLod: case spv::Op::OpImageSampleProjExplicitLod: case spv::Op::OpImageSampleProjDrefExplicitLod: case spv::Op::OpImageSparseSampleProjExplicitLod: case spv::Op::OpImageSparseSampleProjDrefExplicitLod: return true; default: break; } return false; } // Returns the number of components in a coordinate used to access a texel in // a single plane of an image with the given parameters. uint32_t GetPlaneCoordSize(const ImageTypeInfo& info) { uint32_t plane_size = 0; // If this switch breaks your build, please add new values below. switch (info.dim) { case spv::Dim::Dim1D: case spv::Dim::Buffer: plane_size = 1; break; case spv::Dim::Dim2D: case spv::Dim::Rect: case spv::Dim::SubpassData: case spv::Dim::TileImageDataEXT: plane_size = 2; break; case spv::Dim::Dim3D: case spv::Dim::Cube: // For Cube direction vector is used instead of UV. plane_size = 3; break; case spv::Dim::Max: default: assert(0); break; } return plane_size; } // Returns minimal number of coordinates based on image dim, arrayed and whether // the instruction uses projection coordinates. uint32_t GetMinCoordSize(spv::Op opcode, const ImageTypeInfo& info) { if (info.dim == spv::Dim::Cube && (opcode == spv::Op::OpImageRead || opcode == spv::Op::OpImageWrite || opcode == spv::Op::OpImageSparseRead)) { // These opcodes use UV for Cube, not direction vector. return 3; } return GetPlaneCoordSize(info) + info.arrayed + (IsProj(opcode) ? 1 : 0); } // Checks ImageOperand bitfield and respective operands. // word_index is the index of the first word after the image-operand mask word. spv_result_t ValidateImageOperands(ValidationState_t& _, const Instruction* inst, const ImageTypeInfo& info, uint32_t word_index) { static const bool kAllImageOperandsHandled = CheckAllImageOperandsHandled(); (void)kAllImageOperandsHandled; const spv::Op opcode = inst->opcode(); const size_t num_words = inst->words().size(); const bool have_explicit_mask = (word_index - 1 < num_words); const uint32_t mask = have_explicit_mask ? inst->word(word_index - 1) : 0u; if (have_explicit_mask) { // NonPrivate, Volatile, SignExtend, ZeroExtend take no operand words. const uint32_t mask_bits_having_operands = mask & ~uint32_t(spv::ImageOperandsMask::NonPrivateTexelKHR | spv::ImageOperandsMask::VolatileTexelKHR | spv::ImageOperandsMask::SignExtend | spv::ImageOperandsMask::ZeroExtend | spv::ImageOperandsMask::Nontemporal); size_t expected_num_image_operand_words = spvtools::utils::CountSetBits(mask_bits_having_operands); if (mask & uint32_t(spv::ImageOperandsMask::Grad)) { // Grad uses two words. ++expected_num_image_operand_words; } if (expected_num_image_operand_words != num_words - word_index) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Number of image operand ids doesn't correspond to the bit " "mask"; } } else if (num_words != word_index - 1) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Number of image operand ids doesn't correspond to the bit mask"; } if (info.multisampled & (0 == (mask & uint32_t(spv::ImageOperandsMask::Sample)))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image Operand Sample is required for operation on " "multi-sampled image"; } // After this point, only set bits in the image operands mask can cause // the module to be invalid. if (mask == 0) return SPV_SUCCESS; if (spvtools::utils::CountSetBits( mask & uint32_t(spv::ImageOperandsMask::Offset | spv::ImageOperandsMask::ConstOffset | spv::ImageOperandsMask::ConstOffsets | spv::ImageOperandsMask::Offsets)) > 1) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image Operands Offset, ConstOffset, ConstOffsets, Offsets " "cannot be used together"; } const bool is_implicit_lod = IsImplicitLod(opcode); const bool is_explicit_lod = IsExplicitLod(opcode); const bool is_valid_lod_operand = IsValidLodOperand(_, opcode); const bool is_valid_gather_lod_bias_amd = IsValidGatherLodBiasAMD(_, opcode); // The checks should be done in the order of definition of OperandImage. if (mask & uint32_t(spv::ImageOperandsMask::Bias)) { if (!is_implicit_lod && !is_valid_gather_lod_bias_amd) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image Operand Bias can only be used with ImplicitLod opcodes"; } const uint32_t type_id = _.GetTypeId(inst->word(word_index++)); if (!_.IsFloatScalarType(type_id)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image Operand Bias to be float scalar"; } if (info.dim != spv::Dim::Dim1D && info.dim != spv::Dim::Dim2D && info.dim != spv::Dim::Dim3D && info.dim != spv::Dim::Cube) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image Operand Bias requires 'Dim' parameter to be 1D, 2D, 3D " "or Cube"; } // Multisampled is already checked. } if (mask & uint32_t(spv::ImageOperandsMask::Lod)) { if (!is_valid_lod_operand && opcode != spv::Op::OpImageFetch && opcode != spv::Op::OpImageSparseFetch && !is_valid_gather_lod_bias_amd) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image Operand Lod can only be used with ExplicitLod opcodes " << "and OpImageFetch"; } if (mask & uint32_t(spv::ImageOperandsMask::Grad)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image Operand bits Lod and Grad cannot be set at the same " "time"; } const uint32_t type_id = _.GetTypeId(inst->word(word_index++)); if (is_explicit_lod || is_valid_gather_lod_bias_amd) { if (!_.IsFloatScalarType(type_id)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image Operand Lod to be float scalar when used " << "with ExplicitLod"; } } else { if (!_.IsIntScalarType(type_id)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image Operand Lod to be int scalar when used with " << "OpImageFetch"; } } if (info.dim != spv::Dim::Dim1D && info.dim != spv::Dim::Dim2D && info.dim != spv::Dim::Dim3D && info.dim != spv::Dim::Cube) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image Operand Lod requires 'Dim' parameter to be 1D, 2D, 3D " "or Cube"; } // Multisampled is already checked. } if (mask & uint32_t(spv::ImageOperandsMask::Grad)) { if (!is_explicit_lod) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image Operand Grad can only be used with ExplicitLod opcodes"; } const uint32_t dx_type_id = _.GetTypeId(inst->word(word_index++)); const uint32_t dy_type_id = _.GetTypeId(inst->word(word_index++)); if (!_.IsFloatScalarOrVectorType(dx_type_id) || !_.IsFloatScalarOrVectorType(dy_type_id)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected both Image Operand Grad ids to be float scalars or " << "vectors"; } const uint32_t plane_size = GetPlaneCoordSize(info); const uint32_t dx_size = _.GetDimension(dx_type_id); const uint32_t dy_size = _.GetDimension(dy_type_id); if (plane_size != dx_size) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image Operand Grad dx to have " << plane_size << " components, but given " << dx_size; } if (plane_size != dy_size) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image Operand Grad dy to have " << plane_size << " components, but given " << dy_size; } // Multisampled is already checked. } if (mask & uint32_t(spv::ImageOperandsMask::ConstOffset)) { if (info.dim == spv::Dim::Cube) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image Operand ConstOffset cannot be used with Cube Image " "'Dim'"; } const uint32_t id = inst->word(word_index++); const uint32_t type_id = _.GetTypeId(id); if (!_.IsIntScalarOrVectorType(type_id)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image Operand ConstOffset to be int scalar or " << "vector"; } if (!spvOpcodeIsConstant(_.GetIdOpcode(id))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image Operand ConstOffset to be a const object"; } const uint32_t plane_size = GetPlaneCoordSize(info); const uint32_t offset_size = _.GetDimension(type_id); if (plane_size != offset_size) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image Operand ConstOffset to have " << plane_size << " components, but given " << offset_size; } } if (mask & uint32_t(spv::ImageOperandsMask::Offset)) { if (info.dim == spv::Dim::Cube) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image Operand Offset cannot be used with Cube Image 'Dim'"; } const uint32_t id = inst->word(word_index++); const uint32_t type_id = _.GetTypeId(id); if (!_.IsIntScalarOrVectorType(type_id)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image Operand Offset to be int scalar or " << "vector"; } const uint32_t plane_size = GetPlaneCoordSize(info); const uint32_t offset_size = _.GetDimension(type_id); if (plane_size != offset_size) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image Operand Offset to have " << plane_size << " components, but given " << offset_size; } if (!_.options()->before_hlsl_legalization && spvIsVulkanEnv(_.context()->target_env) && !_.options()->allow_offset_texture_operand) { if (opcode != spv::Op::OpImageGather && opcode != spv::Op::OpImageDrefGather && opcode != spv::Op::OpImageSparseGather && opcode != spv::Op::OpImageSparseDrefGather) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(10213) << "Image Operand Offset can only be used with " "OpImage*Gather operations"; } } } if (mask & uint32_t(spv::ImageOperandsMask::ConstOffsets)) { if (opcode != spv::Op::OpImageGather && opcode != spv::Op::OpImageDrefGather && opcode != spv::Op::OpImageSparseGather && opcode != spv::Op::OpImageSparseDrefGather) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image Operand ConstOffsets can only be used with " "OpImageGather and OpImageDrefGather"; } if (info.dim == spv::Dim::Cube) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image Operand ConstOffsets cannot be used with Cube Image " "'Dim'"; } const uint32_t id = inst->word(word_index++); const uint32_t type_id = _.GetTypeId(id); const Instruction* type_inst = _.FindDef(type_id); assert(type_inst); if (type_inst->opcode() != spv::Op::OpTypeArray) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image Operand ConstOffsets to be an array of size 4"; } uint64_t array_size = 0; if (!_.EvalConstantValUint64(type_inst->word(3), &array_size)) { assert(0 && "Array type definition is corrupt"); } if (array_size != 4) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image Operand ConstOffsets to be an array of size 4"; } const uint32_t component_type = type_inst->word(2); if (!_.IsIntVectorType(component_type) || _.GetDimension(component_type) != 2) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image Operand ConstOffsets array components to be " "int vectors of size 2"; } if (!spvOpcodeIsConstant(_.GetIdOpcode(id))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image Operand ConstOffsets to be a const object"; } } if (mask & uint32_t(spv::ImageOperandsMask::Sample)) { if (opcode != spv::Op::OpImageFetch && opcode != spv::Op::OpImageRead && opcode != spv::Op::OpImageWrite && opcode != spv::Op::OpImageSparseFetch && opcode != spv::Op::OpImageSparseRead) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image Operand Sample can only be used with OpImageFetch, " << "OpImageRead, OpImageWrite, OpImageSparseFetch and " << "OpImageSparseRead"; } if (info.multisampled == 0) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image Operand Sample requires non-zero 'MS' parameter"; } const uint32_t type_id = _.GetTypeId(inst->word(word_index++)); if (!_.IsIntScalarType(type_id)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image Operand Sample to be int scalar"; } } if (mask & uint32_t(spv::ImageOperandsMask::MinLod)) { if (!is_implicit_lod && !(mask & uint32_t(spv::ImageOperandsMask::Grad))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image Operand MinLod can only be used with ImplicitLod " << "opcodes or together with Image Operand Grad"; } const uint32_t type_id = _.GetTypeId(inst->word(word_index++)); if (!_.IsFloatScalarType(type_id)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image Operand MinLod to be float scalar"; } if (info.dim != spv::Dim::Dim1D && info.dim != spv::Dim::Dim2D && info.dim != spv::Dim::Dim3D && info.dim != spv::Dim::Cube) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image Operand MinLod requires 'Dim' parameter to be 1D, 2D, " "3D or Cube"; } if (info.multisampled != 0) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image Operand MinLod requires 'MS' parameter to be 0"; } } if (mask & uint32_t(spv::ImageOperandsMask::MakeTexelAvailableKHR)) { // Checked elsewhere: capability and memory model are correct. if (opcode != spv::Op::OpImageWrite) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image Operand MakeTexelAvailableKHR can only be used with Op" << spvOpcodeString(spv::Op::OpImageWrite) << ": Op" << spvOpcodeString(opcode); } if (!(mask & uint32_t(spv::ImageOperandsMask::NonPrivateTexelKHR))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image Operand MakeTexelAvailableKHR requires " "NonPrivateTexelKHR is also specified: Op" << spvOpcodeString(opcode); } const auto available_scope = inst->word(word_index++); if (auto error = ValidateMemoryScope(_, inst, available_scope)) return error; } if (mask & uint32_t(spv::ImageOperandsMask::MakeTexelVisibleKHR)) { // Checked elsewhere: capability and memory model are correct. if (opcode != spv::Op::OpImageRead && opcode != spv::Op::OpImageSparseRead) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image Operand MakeTexelVisibleKHR can only be used with Op" << spvOpcodeString(spv::Op::OpImageRead) << " or Op" << spvOpcodeString(spv::Op::OpImageSparseRead) << ": Op" << spvOpcodeString(opcode); } if (!(mask & uint32_t(spv::ImageOperandsMask::NonPrivateTexelKHR))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image Operand MakeTexelVisibleKHR requires NonPrivateTexelKHR " "is also specified: Op" << spvOpcodeString(opcode); } const auto visible_scope = inst->word(word_index++); if (auto error = ValidateMemoryScope(_, inst, visible_scope)) return error; } if (mask & uint32_t(spv::ImageOperandsMask::SignExtend)) { // Checked elsewhere: SPIR-V 1.4 version or later. // "The texel value is converted to the target value via sign extension. // Only valid when the texel type is a scalar or vector of integer type." // // We don't have enough information to know what the texel type is. // In OpenCL, knowledge is deferred until runtime: the image SampledType is // void, and the Format is Unknown. // In Vulkan, the texel type is only known in all cases by the pipeline // setup. } if (mask & uint32_t(spv::ImageOperandsMask::ZeroExtend)) { // Checked elsewhere: SPIR-V 1.4 version or later. // "The texel value is converted to the target value via zero extension. // Only valid when the texel type is a scalar or vector of integer type." // // We don't have enough information to know what the texel type is. // In OpenCL, knowledge is deferred until runtime: the image SampledType is // void, and the Format is Unknown. // In Vulkan, the texel type is only known in all cases by the pipeline // setup. } if (mask & uint32_t(spv::ImageOperandsMask::Offsets)) { // TODO: add validation } if (mask & uint32_t(spv::ImageOperandsMask::Nontemporal)) { // Checked elsewhere: SPIR-V 1.6 version or later. } return SPV_SUCCESS; } // Validate OpImage*Proj* instructions spv_result_t ValidateImageProj(ValidationState_t& _, const Instruction* inst, const ImageTypeInfo& info) { if (info.dim != spv::Dim::Dim1D && info.dim != spv::Dim::Dim2D && info.dim != spv::Dim::Dim3D && info.dim != spv::Dim::Rect) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image 'Dim' parameter to be 1D, 2D, 3D or Rect"; } if (info.multisampled != 0) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image 'MS' parameter to be 0"; } if (info.arrayed != 0) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image 'arrayed' parameter to be 0"; } return SPV_SUCCESS; } // Validate OpImage*Read and OpImage*Write instructions spv_result_t ValidateImageReadWrite(ValidationState_t& _, const Instruction* inst, const ImageTypeInfo& info) { if (info.sampled == 2) { if (info.dim == spv::Dim::Dim1D && !_.HasCapability(spv::Capability::Image1D)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Capability Image1D is required to access storage image"; } else if (info.dim == spv::Dim::Rect && !_.HasCapability(spv::Capability::ImageRect)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Capability ImageRect is required to access storage image"; } else if (info.dim == spv::Dim::Buffer && !_.HasCapability(spv::Capability::ImageBuffer)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Capability ImageBuffer is required to access storage image"; } else if (info.dim == spv::Dim::Cube && info.arrayed == 1 && !_.HasCapability(spv::Capability::ImageCubeArray)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Capability ImageCubeArray is required to access " << "storage image"; } if (info.multisampled == 1 && info.arrayed == 1 && info.sampled == 2 && !_.HasCapability(spv::Capability::ImageMSArray)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Capability ImageMSArray is required to access storage " << "image"; } } else if (info.sampled != 0) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image 'Sampled' parameter to be 0 or 2"; } return SPV_SUCCESS; } // Returns true if opcode is *ImageSparse*, false otherwise. bool IsSparse(spv::Op opcode) { switch (opcode) { case spv::Op::OpImageSparseSampleImplicitLod: case spv::Op::OpImageSparseSampleExplicitLod: case spv::Op::OpImageSparseSampleDrefImplicitLod: case spv::Op::OpImageSparseSampleDrefExplicitLod: case spv::Op::OpImageSparseSampleProjImplicitLod: case spv::Op::OpImageSparseSampleProjExplicitLod: case spv::Op::OpImageSparseSampleProjDrefImplicitLod: case spv::Op::OpImageSparseSampleProjDrefExplicitLod: case spv::Op::OpImageSparseFetch: case spv::Op::OpImageSparseGather: case spv::Op::OpImageSparseDrefGather: case spv::Op::OpImageSparseTexelsResident: case spv::Op::OpImageSparseRead: { return true; } default: { return false; } } return false; } // Checks sparse image opcode result type and returns the second struct member. // Returns inst.type_id for non-sparse image opcodes. // Not valid for sparse image opcodes which do not return a struct. spv_result_t GetActualResultType(ValidationState_t& _, const Instruction* inst, uint32_t* actual_result_type) { const spv::Op opcode = inst->opcode(); if (IsSparse(opcode)) { const Instruction* const type_inst = _.FindDef(inst->type_id()); assert(type_inst); if (!type_inst || type_inst->opcode() != spv::Op::OpTypeStruct) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Result Type to be OpTypeStruct"; } if (type_inst->words().size() != 4 || !_.IsIntScalarType(type_inst->word(2))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Result Type to be a struct containing an int " "scalar and a texel"; } *actual_result_type = type_inst->word(3); } else { *actual_result_type = inst->type_id(); } return SPV_SUCCESS; } // Returns a string describing actual result type of an opcode. // Not valid for sparse image opcodes which do not return a struct. const char* GetActualResultTypeStr(spv::Op opcode) { if (IsSparse(opcode)) return "Result Type's second member"; return "Result Type"; } spv_result_t ValidateTypeImage(ValidationState_t& _, const Instruction* inst) { assert(inst->type_id() == 0); ImageTypeInfo info; if (!GetImageTypeInfo(_, inst->word(1), &info)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Corrupt image type definition"; } if (_.IsIntScalarType(info.sampled_type) && (64 == _.GetBitWidth(info.sampled_type)) && !_.HasCapability(spv::Capability::Int64ImageEXT)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Capability Int64ImageEXT is required when using Sampled Type of " "64-bit int"; } const auto target_env = _.context()->target_env; if (spvIsVulkanEnv(target_env)) { if ((!_.IsFloatScalarType(info.sampled_type) && !_.IsIntScalarType(info.sampled_type)) || ((32 != _.GetBitWidth(info.sampled_type)) && (64 != _.GetBitWidth(info.sampled_type))) || ((64 == _.GetBitWidth(info.sampled_type)) && _.IsFloatScalarType(info.sampled_type))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(4656) << "Expected Sampled Type to be a 32-bit int, 64-bit int or " "32-bit float scalar type for Vulkan environment"; } } else if (spvIsOpenCLEnv(target_env)) { if (!_.IsVoidType(info.sampled_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Sampled Type must be OpTypeVoid in the OpenCL environment."; } } else { const spv::Op sampled_type_opcode = _.GetIdOpcode(info.sampled_type); if (sampled_type_opcode != spv::Op::OpTypeVoid && sampled_type_opcode != spv::Op::OpTypeInt && sampled_type_opcode != spv::Op::OpTypeFloat) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Sampled Type to be either void or" << " numerical scalar type"; } } // Universal checks on image type operands // Dim and Format and Access Qualifier are checked elsewhere. if (info.depth > 2) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Invalid Depth " << info.depth << " (must be 0, 1 or 2)"; } if (info.arrayed > 1) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Invalid Arrayed " << info.arrayed << " (must be 0 or 1)"; } if (info.multisampled > 1) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Invalid MS " << info.multisampled << " (must be 0 or 1)"; } if (info.sampled > 2) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Invalid Sampled " << info.sampled << " (must be 0, 1 or 2)"; } if (info.dim == spv::Dim::SubpassData) { if (info.sampled != 2) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(6214) << "Dim SubpassData requires Sampled to be 2"; } if (info.format != spv::ImageFormat::Unknown) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Dim SubpassData requires format Unknown"; } } else if (info.dim == spv::Dim::TileImageDataEXT) { if (_.IsVoidType(info.sampled_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Dim TileImageDataEXT requires Sampled Type to be not " "OpTypeVoid"; } if (info.sampled != 2) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Dim TileImageDataEXT requires Sampled to be 2"; } if (info.format != spv::ImageFormat::Unknown) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Dim TileImageDataEXT requires format Unknown"; } if (info.depth != 0) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Dim TileImageDataEXT requires Depth to be 0"; } if (info.arrayed != 0) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Dim TileImageDataEXT requires Arrayed to be 0"; } } else { if (info.multisampled && (info.sampled == 2) && !_.HasCapability(spv::Capability::StorageImageMultisample)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Capability StorageImageMultisample is required when using " "multisampled storage image"; } } if (spvIsOpenCLEnv(target_env)) { if ((info.arrayed == 1) && (info.dim != spv::Dim::Dim1D) && (info.dim != spv::Dim::Dim2D)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "In the OpenCL environment, Arrayed may only be set to 1 " << "when Dim is either 1D or 2D."; } if (info.multisampled != 0) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "MS must be 0 in the OpenCL environment."; } if (info.sampled != 0) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Sampled must be 0 in the OpenCL environment."; } if (info.access_qualifier == spv::AccessQualifier::Max) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "In the OpenCL environment, the optional Access Qualifier" << " must be present."; } } if (spvIsVulkanEnv(target_env)) { if (info.sampled == 0) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(4657) << "Sampled must be 1 or 2 in the Vulkan environment."; } if (info.dim == spv::Dim::SubpassData && info.arrayed != 0) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(6214) << "Dim SubpassData requires Arrayed to be 0 in the Vulkan " "environment"; } if (info.dim == spv::Dim::Rect) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(9638) << "Dim must not be Rect in the Vulkan environment"; } } return SPV_SUCCESS; } spv_result_t ValidateTypeSampledImage(ValidationState_t& _, const Instruction* inst) { const uint32_t image_type = inst->word(2); if (_.GetIdOpcode(image_type) != spv::Op::OpTypeImage) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image to be of type OpTypeImage"; } ImageTypeInfo info; if (!GetImageTypeInfo(_, image_type, &info)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Corrupt image type definition"; } // OpenCL requires Sampled=0, checked elsewhere. // Vulkan uses the Sampled=1 case. // If Dim is TileImageDataEXT, Sampled must be 2 and this is validated // elsewhere. if ((info.sampled != 0) && (info.sampled != 1)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(4657) << "Sampled image type requires an image type with \"Sampled\" " "operand set to 0 or 1"; } // This covers both OpTypeSampledImage and OpSampledImage. if (_.version() >= SPV_SPIRV_VERSION_WORD(1, 6) && info.dim == spv::Dim::Buffer) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "In SPIR-V 1.6 or later, sampled image dimension must not be " "Buffer"; } return SPV_SUCCESS; } bool IsAllowedSampledImageOperand(spv::Op opcode, ValidationState_t& _) { switch (opcode) { case spv::Op::OpSampledImage: case spv::Op::OpImageSampleImplicitLod: case spv::Op::OpImageSampleExplicitLod: case spv::Op::OpImageSampleDrefImplicitLod: case spv::Op::OpImageSampleDrefExplicitLod: case spv::Op::OpImageSampleProjImplicitLod: case spv::Op::OpImageSampleProjExplicitLod: case spv::Op::OpImageSampleProjDrefImplicitLod: case spv::Op::OpImageSampleProjDrefExplicitLod: case spv::Op::OpImageGather: case spv::Op::OpImageDrefGather: case spv::Op::OpImage: case spv::Op::OpImageQueryLod: case spv::Op::OpImageSparseSampleImplicitLod: case spv::Op::OpImageSparseSampleExplicitLod: case spv::Op::OpImageSparseSampleDrefImplicitLod: case spv::Op::OpImageSparseSampleDrefExplicitLod: case spv::Op::OpImageSparseGather: case spv::Op::OpImageSparseDrefGather: case spv::Op::OpCopyObject: case spv::Op::OpImageSampleWeightedQCOM: case spv::Op::OpImageBoxFilterQCOM: case spv::Op::OpImageBlockMatchSSDQCOM: case spv::Op::OpImageBlockMatchSADQCOM: case spv::Op::OpImageBlockMatchWindowSADQCOM: case spv::Op::OpImageBlockMatchWindowSSDQCOM: case spv::Op::OpImageBlockMatchGatherSADQCOM: case spv::Op::OpImageBlockMatchGatherSSDQCOM: case spv::Op::OpImageSampleFootprintNV: return true; case spv::Op::OpStore: if (_.HasCapability(spv::Capability::BindlessTextureNV)) return true; return false; default: return false; } } spv_result_t ValidateSampledImage(ValidationState_t& _, const Instruction* inst) { auto type_inst = _.FindDef(inst->type_id()); if (type_inst->opcode() != spv::Op::OpTypeSampledImage) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Result Type to be OpTypeSampledImage."; } const uint32_t image_type = _.GetOperandTypeId(inst, 2); if (_.GetIdOpcode(image_type) != spv::Op::OpTypeImage) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image to be of type OpTypeImage."; } ImageTypeInfo info; if (!GetImageTypeInfo(_, image_type, &info)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Corrupt image type definition"; } // Image operands must match except for depth. auto sampled_image_id = type_inst->GetOperandAs(1); if (sampled_image_id != image_type) { ImageTypeInfo sampled_info; if (!GetImageTypeInfo(_, sampled_image_id, &sampled_info)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Corrupt image type definition"; } if (info.sampled_type != sampled_info.sampled_type || info.dim != sampled_info.dim || info.arrayed != sampled_info.arrayed || info.multisampled != sampled_info.multisampled || info.sampled != sampled_info.sampled || info.format != sampled_info.format || info.access_qualifier != sampled_info.access_qualifier) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image operands must match result image operands except for " "depth"; } } if (spvIsVulkanEnv(_.context()->target_env)) { if (info.sampled != 1) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(6671) << "Expected Image 'Sampled' parameter to be 1 for Vulkan " "environment."; } } else { if (info.sampled != 0 && info.sampled != 1) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image 'Sampled' parameter to be 0 or 1"; } } if (info.dim == spv::Dim::SubpassData) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image 'Dim' parameter to be not SubpassData."; } if (_.GetIdOpcode(_.GetOperandTypeId(inst, 3)) != spv::Op::OpTypeSampler) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Sampler to be of type OpTypeSampler"; } // We need to validate 2 things: // * All OpSampledImage instructions must be in the same block in which their // Result are consumed. // * Result from OpSampledImage instructions must not appear as operands // to OpPhi instructions or OpSelect instructions, or any instructions other // than the image lookup and query instructions specified to take an operand // whose type is OpTypeSampledImage. std::vector consumers = _.getSampledImageConsumers(inst->id()); if (!consumers.empty()) { for (auto consumer_instr : consumers) { const auto consumer_opcode = consumer_instr->opcode(); if (consumer_instr->block() != inst->block()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "All OpSampledImage instructions must be in the same block " "in " "which their Result are consumed. OpSampledImage Result " "Type " << _.getIdName(inst->id()) << " has a consumer in a different basic " "block. The consumer instruction is " << _.getIdName(consumer_instr->id()) << "."; } if (consumer_opcode == spv::Op::OpPhi || consumer_opcode == spv::Op::OpSelect) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Result from OpSampledImage instruction must not appear " "as " "operands of Op" << spvOpcodeString(static_cast(consumer_opcode)) << "." << " Found result " << _.getIdName(inst->id()) << " as an operand of " << _.getIdName(consumer_instr->id()) << "."; } if (!IsAllowedSampledImageOperand(consumer_opcode, _)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Result from OpSampledImage instruction must not appear " "as operand for Op" << spvOpcodeString(static_cast(consumer_opcode)) << ", since it is not specified as taking an " << "OpTypeSampledImage." << " Found result " << _.getIdName(inst->id()) << " as an operand of " << _.getIdName(consumer_instr->id()) << "."; } } } const Instruction* ld_inst; { int t_idx = inst->GetOperandAs(2); ld_inst = _.FindDef(t_idx); } if (ld_inst->opcode() == spv::Op::OpLoad) { int texture_id = ld_inst->GetOperandAs(2); // variable to load _.RegisterQCOMImageProcessingTextureConsumer(texture_id, ld_inst, inst); } return SPV_SUCCESS; } spv_result_t ValidateImageTexelPointer(ValidationState_t& _, const Instruction* inst) { const auto result_type = _.FindDef(inst->type_id()); if (result_type->opcode() != spv::Op::OpTypePointer && result_type->opcode() != spv::Op::OpTypeUntypedPointerKHR) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Result Type to be a pointer"; } const auto storage_class = result_type->GetOperandAs(1); if (storage_class != spv::StorageClass::Image) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Result Type to be a pointer whose Storage Class " "operand is Image"; } uint32_t ptr_type = 0; if (result_type->opcode() == spv::Op::OpTypePointer) { ptr_type = result_type->GetOperandAs(2); const auto ptr_opcode = _.GetIdOpcode(ptr_type); if (ptr_opcode != spv::Op::OpTypeInt && ptr_opcode != spv::Op::OpTypeFloat && ptr_opcode != spv::Op::OpTypeVoid && !(ptr_opcode == spv::Op::OpTypeVector && _.HasCapability(spv::Capability::AtomicFloat16VectorNV) && _.IsFloat16Vector2Or4Type(ptr_type))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Result Type to be a pointer whose Type operand " "must be a scalar numerical type or OpTypeVoid"; } } const auto image_ptr = _.FindDef(_.GetOperandTypeId(inst, 2)); if (!image_ptr || image_ptr->opcode() != spv::Op::OpTypePointer) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image to be OpTypePointer"; } const auto image_type = image_ptr->GetOperandAs(2); if (_.GetIdOpcode(image_type) != spv::Op::OpTypeImage) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image to be OpTypePointer with Type OpTypeImage"; } ImageTypeInfo info; if (!GetImageTypeInfo(_, image_type, &info)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Corrupt image type definition"; } if (result_type->opcode() == spv::Op::OpTypePointer && info.sampled_type != ptr_type && !(_.HasCapability(spv::Capability::AtomicFloat16VectorNV) && _.IsFloat16Vector2Or4Type(ptr_type) && _.GetIdOpcode(info.sampled_type) == spv::Op::OpTypeFloat && ((_.GetDimension(ptr_type) == 2 && info.format == spv::ImageFormat::Rg16f) || (_.GetDimension(ptr_type) == 4 && info.format == spv::ImageFormat::Rgba16f)))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image 'Sampled Type' to be the same as the Type " "pointed to by Result Type"; } if (info.dim == spv::Dim::SubpassData) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image Dim SubpassData cannot be used with OpImageTexelPointer"; } if (info.dim == spv::Dim::TileImageDataEXT) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image Dim TileImageDataEXT cannot be used with " "OpImageTexelPointer"; } const uint32_t coord_type = _.GetOperandTypeId(inst, 3); if (!coord_type || !_.IsIntScalarOrVectorType(coord_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Coordinate to be integer scalar or vector"; } uint32_t expected_coord_size = 0; if (info.arrayed == 0) { expected_coord_size = GetPlaneCoordSize(info); } else if (info.arrayed == 1) { switch (info.dim) { case spv::Dim::Dim1D: expected_coord_size = 2; break; case spv::Dim::Cube: case spv::Dim::Dim2D: expected_coord_size = 3; break; default: return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image 'Dim' must be one of 1D, 2D, or Cube when " "Arrayed is 1"; break; } } const uint32_t actual_coord_size = _.GetDimension(coord_type); if (expected_coord_size != actual_coord_size) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Coordinate to have " << expected_coord_size << " components, but given " << actual_coord_size; } const uint32_t sample_type = _.GetOperandTypeId(inst, 4); if (!sample_type || !_.IsIntScalarType(sample_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Sample to be integer scalar"; } if (info.multisampled == 0) { uint64_t ms = 0; if (!_.EvalConstantValUint64(inst->GetOperandAs(4), &ms) || ms != 0) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Sample for Image with MS 0 to be a valid for " "the value 0"; } } if (spvIsVulkanEnv(_.context()->target_env)) { if ((info.format != spv::ImageFormat::R64i) && (info.format != spv::ImageFormat::R64ui) && (info.format != spv::ImageFormat::R32f) && (info.format != spv::ImageFormat::R32i) && (info.format != spv::ImageFormat::R32ui) && !((info.format == spv::ImageFormat::Rg16f || info.format == spv::ImageFormat::Rgba16f) && _.HasCapability(spv::Capability::AtomicFloat16VectorNV))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(4658) << "Expected the Image Format in Image to be R64i, R64ui, R32f, " "R32i, or R32ui for Vulkan environment"; } } return SPV_SUCCESS; } spv_result_t ValidateImageLod(ValidationState_t& _, const Instruction* inst) { const spv::Op opcode = inst->opcode(); uint32_t actual_result_type = 0; if (spv_result_t error = GetActualResultType(_, inst, &actual_result_type)) { return error; } if (!_.IsIntVectorType(actual_result_type) && !_.IsFloatVectorType(actual_result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected " << GetActualResultTypeStr(opcode) << " to be int or float vector type"; } if (_.GetDimension(actual_result_type) != 4) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected " << GetActualResultTypeStr(opcode) << " to have 4 components"; } const uint32_t image_type = _.GetOperandTypeId(inst, 2); if (_.GetIdOpcode(image_type) != spv::Op::OpTypeSampledImage) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Sampled Image to be of type OpTypeSampledImage"; } ImageTypeInfo info; if (!GetImageTypeInfo(_, image_type, &info)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Corrupt image type definition"; } if (IsProj(opcode)) { if (spv_result_t result = ValidateImageProj(_, inst, info)) return result; } if (info.multisampled) { // When using image operands, the Sample image operand is required if and // only if the image is multisampled (MS=1). The Sample image operand is // only allowed for fetch, read, and write. return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Sampling operation is invalid for multisample image"; } if (_.GetIdOpcode(info.sampled_type) != spv::Op::OpTypeVoid) { const uint32_t texel_component_type = _.GetComponentType(actual_result_type); if (texel_component_type != info.sampled_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image 'Sampled Type' to be the same as " << GetActualResultTypeStr(opcode) << " components"; } } const uint32_t coord_type = _.GetOperandTypeId(inst, 3); if ((opcode == spv::Op::OpImageSampleExplicitLod || opcode == spv::Op::OpImageSparseSampleExplicitLod) && _.HasCapability(spv::Capability::Kernel)) { if (!_.IsFloatScalarOrVectorType(coord_type) && !_.IsIntScalarOrVectorType(coord_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Coordinate to be int or float scalar or vector"; } } else { if (!_.IsFloatScalarOrVectorType(coord_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Coordinate to be float scalar or vector"; } } const uint32_t min_coord_size = GetMinCoordSize(opcode, info); const uint32_t actual_coord_size = _.GetDimension(coord_type); if (min_coord_size > actual_coord_size) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Coordinate to have at least " << min_coord_size << " components, but given only " << actual_coord_size; } const uint32_t mask = inst->words().size() <= 5 ? 0 : inst->word(5); if (mask & uint32_t(spv::ImageOperandsMask::ConstOffset)) { if (spvIsOpenCLEnv(_.context()->target_env)) { if (opcode == spv::Op::OpImageSampleExplicitLod) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "ConstOffset image operand not allowed " << "in the OpenCL environment."; } } } if (spv_result_t result = ValidateImageOperands(_, inst, info, /* word_index = */ 6)) return result; return SPV_SUCCESS; } // Validates anything OpImage*Dref* instruction spv_result_t ValidateImageDref(ValidationState_t& _, const Instruction* inst, const ImageTypeInfo& info) { const uint32_t dref_type = _.GetOperandTypeId(inst, 4); if (!_.IsFloatScalarType(dref_type) || _.GetBitWidth(dref_type) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Dref to be of 32-bit float type"; } if (spvIsVulkanEnv(_.context()->target_env)) { if (info.dim == spv::Dim::Dim3D) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(4777) << "In Vulkan, OpImage*Dref* instructions must not use images " "with a 3D Dim"; } } return SPV_SUCCESS; } spv_result_t ValidateImageDrefLod(ValidationState_t& _, const Instruction* inst) { const spv::Op opcode = inst->opcode(); uint32_t actual_result_type = 0; if (spv_result_t error = GetActualResultType(_, inst, &actual_result_type)) { return error; } if (!_.IsIntScalarType(actual_result_type) && !_.IsFloatScalarType(actual_result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected " << GetActualResultTypeStr(opcode) << " to be int or float scalar type"; } const uint32_t image_type = _.GetOperandTypeId(inst, 2); if (_.GetIdOpcode(image_type) != spv::Op::OpTypeSampledImage) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Sampled Image to be of type OpTypeSampledImage"; } ImageTypeInfo info; if (!GetImageTypeInfo(_, image_type, &info)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Corrupt image type definition"; } if (IsProj(opcode)) { if (spv_result_t result = ValidateImageProj(_, inst, info)) return result; } if (info.multisampled) { // When using image operands, the Sample image operand is required if and // only if the image is multisampled (MS=1). The Sample image operand is // only allowed for fetch, read, and write. return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Dref sampling operation is invalid for multisample image"; } if (actual_result_type != info.sampled_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image 'Sampled Type' to be the same as " << GetActualResultTypeStr(opcode); } const uint32_t coord_type = _.GetOperandTypeId(inst, 3); if (!_.IsFloatScalarOrVectorType(coord_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Coordinate to be float scalar or vector"; } const uint32_t min_coord_size = GetMinCoordSize(opcode, info); const uint32_t actual_coord_size = _.GetDimension(coord_type); if (min_coord_size > actual_coord_size) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Coordinate to have at least " << min_coord_size << " components, but given only " << actual_coord_size; } if (spv_result_t result = ValidateImageDref(_, inst, info)) return result; if (spv_result_t result = ValidateImageOperands(_, inst, info, /* word_index = */ 7)) return result; return SPV_SUCCESS; } spv_result_t ValidateImageFetch(ValidationState_t& _, const Instruction* inst) { uint32_t actual_result_type = 0; if (spv_result_t error = GetActualResultType(_, inst, &actual_result_type)) { return error; } const spv::Op opcode = inst->opcode(); if (!_.IsIntVectorType(actual_result_type) && !_.IsFloatVectorType(actual_result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected " << GetActualResultTypeStr(opcode) << " to be int or float vector type"; } if (_.GetDimension(actual_result_type) != 4) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected " << GetActualResultTypeStr(opcode) << " to have 4 components"; } const uint32_t image_type = _.GetOperandTypeId(inst, 2); if (_.GetIdOpcode(image_type) != spv::Op::OpTypeImage) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image to be of type OpTypeImage"; } ImageTypeInfo info; if (!GetImageTypeInfo(_, image_type, &info)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Corrupt image type definition"; } if (_.GetIdOpcode(info.sampled_type) != spv::Op::OpTypeVoid) { const uint32_t result_component_type = _.GetComponentType(actual_result_type); if (result_component_type != info.sampled_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image 'Sampled Type' to be the same as " << GetActualResultTypeStr(opcode) << " components"; } } if (info.dim == spv::Dim::Cube) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image 'Dim' cannot be Cube"; } if (info.sampled != 1) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image 'Sampled' parameter to be 1"; } const uint32_t coord_type = _.GetOperandTypeId(inst, 3); if (!_.IsIntScalarOrVectorType(coord_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Coordinate to be int scalar or vector"; } const uint32_t min_coord_size = GetMinCoordSize(opcode, info); const uint32_t actual_coord_size = _.GetDimension(coord_type); if (min_coord_size > actual_coord_size) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Coordinate to have at least " << min_coord_size << " components, but given only " << actual_coord_size; } if (spv_result_t result = ValidateImageOperands(_, inst, info, /* word_index = */ 6)) return result; return SPV_SUCCESS; } spv_result_t ValidateImageGather(ValidationState_t& _, const Instruction* inst) { uint32_t actual_result_type = 0; if (spv_result_t error = GetActualResultType(_, inst, &actual_result_type)) return error; const spv::Op opcode = inst->opcode(); if (!_.IsIntVectorType(actual_result_type) && !_.IsFloatVectorType(actual_result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected " << GetActualResultTypeStr(opcode) << " to be int or float vector type"; } if (_.GetDimension(actual_result_type) != 4) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected " << GetActualResultTypeStr(opcode) << " to have 4 components"; } const uint32_t image_type = _.GetOperandTypeId(inst, 2); if (_.GetIdOpcode(image_type) != spv::Op::OpTypeSampledImage) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Sampled Image to be of type OpTypeSampledImage"; } ImageTypeInfo info; if (!GetImageTypeInfo(_, image_type, &info)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Corrupt image type definition"; } if (info.multisampled) { // When using image operands, the Sample image operand is required if and // only if the image is multisampled (MS=1). The Sample image operand is // only allowed for fetch, read, and write. return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Gather operation is invalid for multisample image"; } if (opcode == spv::Op::OpImageDrefGather || opcode == spv::Op::OpImageSparseDrefGather || _.GetIdOpcode(info.sampled_type) != spv::Op::OpTypeVoid) { const uint32_t result_component_type = _.GetComponentType(actual_result_type); if (result_component_type != info.sampled_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image 'Sampled Type' to be the same as " << GetActualResultTypeStr(opcode) << " components"; } } if (info.dim != spv::Dim::Dim2D && info.dim != spv::Dim::Cube && info.dim != spv::Dim::Rect) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(4777) << "Expected Image 'Dim' to be 2D, Cube, or Rect"; } const uint32_t coord_type = _.GetOperandTypeId(inst, 3); if (!_.IsFloatScalarOrVectorType(coord_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Coordinate to be float scalar or vector"; } const uint32_t min_coord_size = GetMinCoordSize(opcode, info); const uint32_t actual_coord_size = _.GetDimension(coord_type); if (min_coord_size > actual_coord_size) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Coordinate to have at least " << min_coord_size << " components, but given only " << actual_coord_size; } if (opcode == spv::Op::OpImageGather || opcode == spv::Op::OpImageSparseGather) { const uint32_t component = inst->GetOperandAs(4); const uint32_t component_index_type = _.GetTypeId(component); if (!_.IsIntScalarType(component_index_type) || _.GetBitWidth(component_index_type) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Component to be 32-bit int scalar"; } if (spvIsVulkanEnv(_.context()->target_env)) { if (!spvOpcodeIsConstant(_.GetIdOpcode(component))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(4664) << "Expected Component Operand to be a const object for Vulkan " "environment"; } } } else { assert(opcode == spv::Op::OpImageDrefGather || opcode == spv::Op::OpImageSparseDrefGather); if (spv_result_t result = ValidateImageDref(_, inst, info)) return result; } if (spv_result_t result = ValidateImageOperands(_, inst, info, /* word_index = */ 7)) return result; return SPV_SUCCESS; } spv_result_t ValidateImageRead(ValidationState_t& _, const Instruction* inst) { const spv::Op opcode = inst->opcode(); uint32_t actual_result_type = 0; if (spv_result_t error = GetActualResultType(_, inst, &actual_result_type)) { return error; } if (!_.IsIntScalarOrVectorType(actual_result_type) && !_.IsFloatScalarOrVectorType(actual_result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected " << GetActualResultTypeStr(opcode) << " to be int or float scalar or vector type"; } const auto target_env = _.context()->target_env; // Vulkan requires the result to be a 4-element int or float // vector. if (spvIsVulkanEnv(target_env)) { if (_.GetDimension(actual_result_type) != 4) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(4780) << "Expected " << GetActualResultTypeStr(opcode) << " to have 4 components"; } } // Check OpenCL below, after we get the image info. const uint32_t image_type = _.GetOperandTypeId(inst, 2); if (_.GetIdOpcode(image_type) != spv::Op::OpTypeImage) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image to be of type OpTypeImage"; } ImageTypeInfo info; if (!GetImageTypeInfo(_, image_type, &info)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Corrupt image type definition"; } if (spvIsOpenCLEnv(target_env)) { // In OpenCL, a read from a depth image returns a scalar float. In other // cases, the result is always a 4-element vector. // https://www.khronos.org/registry/OpenCL/specs/3.0-unified/html/OpenCL_Env.html#_data_format_for_reading_and_writing_images // https://www.khronos.org/registry/OpenCL/specs/3.0-unified/html/OpenCL_C.html#image-read-and-write-functions // The builtins for reading depth images are: // float read_imagef(aQual image2d_depth_t image, int2 coord) // float read_imagef(aQual image2d_array_depth_t image, int4 coord) if (info.depth) { if (!_.IsFloatScalarType(actual_result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected " << GetActualResultTypeStr(opcode) << " from a depth image read to result in a scalar float value"; } } else { if (_.GetDimension(actual_result_type) != 4) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected " << GetActualResultTypeStr(opcode) << " to have 4 components"; } } const uint32_t mask = inst->words().size() <= 5 ? 0 : inst->word(5); if (mask & uint32_t(spv::ImageOperandsMask::ConstOffset)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "ConstOffset image operand not allowed " << "in the OpenCL environment."; } } if (info.dim == spv::Dim::SubpassData) { if (opcode == spv::Op::OpImageSparseRead) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image Dim SubpassData cannot be used with ImageSparseRead"; } _.function(inst->function()->id()) ->RegisterExecutionModelLimitation( spv::ExecutionModel::Fragment, std::string("Dim SubpassData requires Fragment execution model: ") + spvOpcodeString(opcode)); } if (info.dim == spv::Dim::TileImageDataEXT) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image Dim TileImageDataEXT cannot be used with " << spvOpcodeString(opcode); } if (_.GetIdOpcode(info.sampled_type) != spv::Op::OpTypeVoid) { const uint32_t result_component_type = _.GetComponentType(actual_result_type); if (result_component_type != info.sampled_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image 'Sampled Type' to be the same as " << GetActualResultTypeStr(opcode) << " components"; } } if (spv_result_t result = ValidateImageReadWrite(_, inst, info)) return result; const uint32_t coord_type = _.GetOperandTypeId(inst, 3); if (!_.IsIntScalarOrVectorType(coord_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Coordinate to be int scalar or vector"; } const uint32_t min_coord_size = GetMinCoordSize(opcode, info); const uint32_t actual_coord_size = _.GetDimension(coord_type); if (min_coord_size > actual_coord_size) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Coordinate to have at least " << min_coord_size << " components, but given only " << actual_coord_size; } if (spvIsVulkanEnv(_.context()->target_env)) { if (info.format == spv::ImageFormat::Unknown && info.dim != spv::Dim::SubpassData && !_.HasCapability(spv::Capability::StorageImageReadWithoutFormat)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Capability StorageImageReadWithoutFormat is required to " << "read storage image"; } } if (spv_result_t result = ValidateImageOperands(_, inst, info, /* word_index = */ 6)) return result; return SPV_SUCCESS; } spv_result_t ValidateImageWrite(ValidationState_t& _, const Instruction* inst) { const uint32_t image_type = _.GetOperandTypeId(inst, 0); if (_.GetIdOpcode(image_type) != spv::Op::OpTypeImage) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image to be of type OpTypeImage"; } ImageTypeInfo info; if (!GetImageTypeInfo(_, image_type, &info)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Corrupt image type definition"; } if (info.dim == spv::Dim::SubpassData) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image 'Dim' cannot be SubpassData"; } if (info.dim == spv::Dim::TileImageDataEXT) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image 'Dim' cannot be TileImageDataEXT"; } if (spv_result_t result = ValidateImageReadWrite(_, inst, info)) return result; const uint32_t coord_type = _.GetOperandTypeId(inst, 1); if (!_.IsIntScalarOrVectorType(coord_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Coordinate to be int scalar or vector"; } const uint32_t min_coord_size = GetMinCoordSize(inst->opcode(), info); const uint32_t actual_coord_size = _.GetDimension(coord_type); if (min_coord_size > actual_coord_size) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Coordinate to have at least " << min_coord_size << " components, but given only " << actual_coord_size; } // because it needs to match with 'Sampled Type' the Texel can't be a boolean const uint32_t texel_type = _.GetOperandTypeId(inst, 2); if (!_.IsIntScalarOrVectorType(texel_type) && !_.IsFloatScalarOrVectorType(texel_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Texel to be int or float vector or scalar"; } if (_.GetIdOpcode(info.sampled_type) != spv::Op::OpTypeVoid) { const uint32_t texel_component_type = _.GetComponentType(texel_type); if (texel_component_type != info.sampled_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image 'Sampled Type' to be the same as Texel " << "components"; } } if (spvIsVulkanEnv(_.context()->target_env)) { if (info.format == spv::ImageFormat::Unknown && info.dim != spv::Dim::SubpassData && !_.HasCapability(spv::Capability::StorageImageWriteWithoutFormat)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Capability StorageImageWriteWithoutFormat is required to " "write " << "to storage image"; } } if (inst->words().size() > 4) { if (spvIsOpenCLEnv(_.context()->target_env)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Optional Image Operands are not allowed in the OpenCL " << "environment."; } } if (spv_result_t result = ValidateImageOperands(_, inst, info, /* word_index = */ 5)) return result; return SPV_SUCCESS; } spv_result_t ValidateImage(ValidationState_t& _, const Instruction* inst) { const uint32_t result_type = inst->type_id(); if (_.GetIdOpcode(result_type) != spv::Op::OpTypeImage) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Result Type to be OpTypeImage"; } const uint32_t sampled_image_type = _.GetOperandTypeId(inst, 2); const Instruction* sampled_image_type_inst = _.FindDef(sampled_image_type); assert(sampled_image_type_inst); if (sampled_image_type_inst->opcode() != spv::Op::OpTypeSampledImage) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Sample Image to be of type OpTypeSampleImage"; } if (sampled_image_type_inst->word(2) != result_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Sample Image image type to be equal to Result Type"; } return SPV_SUCCESS; } spv_result_t ValidateImageQuerySizeLod(ValidationState_t& _, const Instruction* inst) { const uint32_t result_type = inst->type_id(); if (!_.IsIntScalarOrVectorType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Result Type to be int scalar or vector type"; } const uint32_t image_type = _.GetOperandTypeId(inst, 2); if (_.GetIdOpcode(image_type) != spv::Op::OpTypeImage) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image to be of type OpTypeImage"; } ImageTypeInfo info; if (!GetImageTypeInfo(_, image_type, &info)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Corrupt image type definition"; } uint32_t expected_num_components = info.arrayed; switch (info.dim) { case spv::Dim::Dim1D: expected_num_components += 1; break; case spv::Dim::Dim2D: case spv::Dim::Cube: expected_num_components += 2; break; case spv::Dim::Dim3D: expected_num_components += 3; break; default: return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image 'Dim' must be 1D, 2D, 3D or Cube"; } if (info.multisampled != 0) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image 'MS' must be 0"; } const auto target_env = _.context()->target_env; if (spvIsVulkanEnv(target_env)) { if (info.sampled != 1) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(4659) << "OpImageQuerySizeLod must only consume an \"Image\" operand " "whose type has its \"Sampled\" operand set to 1"; } } uint32_t result_num_components = _.GetDimension(result_type); if (result_num_components != expected_num_components) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Result Type has " << result_num_components << " components, " << "but " << expected_num_components << " expected"; } const uint32_t lod_type = _.GetOperandTypeId(inst, 3); if (!_.IsIntScalarType(lod_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Level of Detail to be int scalar"; } return SPV_SUCCESS; } spv_result_t ValidateImageQuerySize(ValidationState_t& _, const Instruction* inst) { const uint32_t result_type = inst->type_id(); if (!_.IsIntScalarOrVectorType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Result Type to be int scalar or vector type"; } const uint32_t image_type = _.GetOperandTypeId(inst, 2); if (_.GetIdOpcode(image_type) != spv::Op::OpTypeImage) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image to be of type OpTypeImage"; } ImageTypeInfo info; if (!GetImageTypeInfo(_, image_type, &info)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Corrupt image type definition"; } uint32_t expected_num_components = info.arrayed; switch (info.dim) { case spv::Dim::Dim1D: case spv::Dim::Buffer: expected_num_components += 1; break; case spv::Dim::Dim2D: case spv::Dim::Cube: case spv::Dim::Rect: expected_num_components += 2; break; case spv::Dim::Dim3D: expected_num_components += 3; break; default: return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image 'Dim' must be 1D, Buffer, 2D, Cube, 3D or Rect"; } if (info.dim == spv::Dim::Dim1D || info.dim == spv::Dim::Dim2D || info.dim == spv::Dim::Dim3D || info.dim == spv::Dim::Cube) { if (info.multisampled != 1 && info.sampled != 0 && info.sampled != 2) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image must have either 'MS'=1 or 'Sampled'=0 or 'Sampled'=2"; } } uint32_t result_num_components = _.GetDimension(result_type); if (result_num_components != expected_num_components) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Result Type has " << result_num_components << " components, " << "but " << expected_num_components << " expected"; } return SPV_SUCCESS; } spv_result_t ValidateImageQueryFormatOrOrder(ValidationState_t& _, const Instruction* inst) { if (!_.IsIntScalarType(inst->type_id())) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Result Type to be int scalar type"; } const uint32_t image_type = _.GetOperandTypeId(inst, 2); if (_.GetIdOpcode(image_type) != spv::Op::OpTypeImage) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected operand to be of type OpTypeImage"; } ImageTypeInfo info; if (!GetImageTypeInfo(_, image_type, &info)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Corrupt image type definition"; } if (info.dim == spv::Dim::TileImageDataEXT) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image 'Dim' cannot be TileImageDataEXT"; } return SPV_SUCCESS; } spv_result_t ValidateImageQueryLod(ValidationState_t& _, const Instruction* inst) { _.function(inst->function()->id()) ->RegisterExecutionModelLimitation( [&](spv::ExecutionModel model, std::string* message) { if (model != spv::ExecutionModel::Fragment && model != spv::ExecutionModel::GLCompute && model != spv::ExecutionModel::MeshEXT && model != spv::ExecutionModel::TaskEXT) { if (message) { *message = std::string( "OpImageQueryLod requires Fragment, GLCompute, MeshEXT or " "TaskEXT execution model"); } return false; } return true; }); _.function(inst->function()->id()) ->RegisterLimitation([](const ValidationState_t& state, const Function* entry_point, std::string* message) { const auto* models = state.GetExecutionModels(entry_point->id()); const auto* modes = state.GetExecutionModes(entry_point->id()); if (models && (models->find(spv::ExecutionModel::GLCompute) != models->end() || models->find(spv::ExecutionModel::MeshEXT) != models->end() || models->find(spv::ExecutionModel::TaskEXT) != models->end()) && (!modes || (modes->find(spv::ExecutionMode::DerivativeGroupLinearKHR) == modes->end() && modes->find(spv::ExecutionMode::DerivativeGroupQuadsKHR) == modes->end()))) { if (message) { *message = std::string( "OpImageQueryLod requires DerivativeGroupQuadsKHR " "or DerivativeGroupLinearKHR execution mode for GLCompute, " "MeshEXT or TaskEXT execution model"); } return false; } return true; }); const uint32_t result_type = inst->type_id(); if (!_.IsFloatVectorType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Result Type to be float vector type"; } if (_.GetDimension(result_type) != 2) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Result Type to have 2 components"; } const uint32_t image_type = _.GetOperandTypeId(inst, 2); if (_.GetIdOpcode(image_type) != spv::Op::OpTypeSampledImage) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image operand to be of type OpTypeSampledImage"; } ImageTypeInfo info; if (!GetImageTypeInfo(_, image_type, &info)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Corrupt image type definition"; } if (info.dim != spv::Dim::Dim1D && info.dim != spv::Dim::Dim2D && info.dim != spv::Dim::Dim3D && info.dim != spv::Dim::Cube) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image 'Dim' must be 1D, 2D, 3D or Cube"; } const uint32_t coord_type = _.GetOperandTypeId(inst, 3); if (_.HasCapability(spv::Capability::Kernel)) { if (!_.IsFloatScalarOrVectorType(coord_type) && !_.IsIntScalarOrVectorType(coord_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Coordinate to be int or float scalar or vector"; } } else { if (!_.IsFloatScalarOrVectorType(coord_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Coordinate to be float scalar or vector"; } } const uint32_t min_coord_size = GetPlaneCoordSize(info); const uint32_t actual_coord_size = _.GetDimension(coord_type); if (min_coord_size > actual_coord_size) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Coordinate to have at least " << min_coord_size << " components, but given only " << actual_coord_size; } // The operand is a sampled image. // The sampled image type is already checked to be parameterized by an image // type with Sampled=0 or Sampled=1. Vulkan bans Sampled=0, and so we have // Sampled=1. So the validator already enforces Vulkan VUID 4659: // OpImageQuerySizeLod must only consume an "Image" operand whose type has // its "Sampled" operand set to 1 return SPV_SUCCESS; } spv_result_t ValidateImageSparseLod(ValidationState_t& _, const Instruction* inst) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Instruction reserved for future use, use of this instruction " << "is invalid"; } spv_result_t ValidateImageQueryLevelsOrSamples(ValidationState_t& _, const Instruction* inst) { if (!_.IsIntScalarType(inst->type_id())) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Result Type to be int scalar type"; } const uint32_t image_type = _.GetOperandTypeId(inst, 2); if (_.GetIdOpcode(image_type) != spv::Op::OpTypeImage) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Image to be of type OpTypeImage"; } ImageTypeInfo info; if (!GetImageTypeInfo(_, image_type, &info)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Corrupt image type definition"; } const spv::Op opcode = inst->opcode(); if (opcode == spv::Op::OpImageQueryLevels) { if (info.dim != spv::Dim::Dim1D && info.dim != spv::Dim::Dim2D && info.dim != spv::Dim::Dim3D && info.dim != spv::Dim::Cube) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image 'Dim' must be 1D, 2D, 3D or Cube"; } const auto target_env = _.context()->target_env; if (spvIsVulkanEnv(target_env)) { if (info.sampled != 1) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(4659) << "OpImageQueryLevels must only consume an \"Image\" operand " "whose type has its \"Sampled\" operand set to 1"; } } } else { assert(opcode == spv::Op::OpImageQuerySamples); if (info.dim != spv::Dim::Dim2D) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image 'Dim' must be 2D"; } if (info.multisampled != 1) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Image 'MS' must be 1"; } } return SPV_SUCCESS; } spv_result_t ValidateImageSparseTexelsResident(ValidationState_t& _, const Instruction* inst) { if (!_.IsBoolScalarType(inst->type_id())) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Result Type to be bool scalar type"; } const uint32_t resident_code_type = _.GetOperandTypeId(inst, 2); if (!_.IsIntScalarType(resident_code_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Resident Code to be int scalar"; } return SPV_SUCCESS; } spv_result_t ValidateImageProcessingQCOMDecoration(ValidationState_t& _, int id, spv::Decoration decor) { const Instruction* si_inst = nullptr; const Instruction* ld_inst = _.FindDef(id); bool is_intf_obj = (ld_inst->opcode() == spv::Op::OpSampledImage); if (is_intf_obj == true) { si_inst = ld_inst; int t_idx = si_inst->GetOperandAs(2); // texture ld_inst = _.FindDef(t_idx); } if (ld_inst->opcode() != spv::Op::OpLoad) { return _.diag(SPV_ERROR_INVALID_DATA, ld_inst) << "Expect to see OpLoad"; } int texture_id = ld_inst->GetOperandAs(2); // variable to load if (!_.HasDecoration(texture_id, decor)) { return _.diag(SPV_ERROR_INVALID_DATA, ld_inst) << "Missing decoration " << _.SpvDecorationString(decor); } return SPV_SUCCESS; } spv_result_t ValidateImageProcessing2QCOMWindowDecoration(ValidationState_t& _, int id) { const Instruction* ld_inst = _.FindDef(id); bool is_intf_obj = (ld_inst->opcode() != spv::Op::OpSampledImage); if (is_intf_obj == true) { if (ld_inst->opcode() != spv::Op::OpLoad) { return _.diag(SPV_ERROR_INVALID_DATA, ld_inst) << "Expect to see OpLoad"; } int texture_id = ld_inst->GetOperandAs(2); // variable to load spv::Decoration decor = spv::Decoration::BlockMatchTextureQCOM; if (!_.HasDecoration(texture_id, decor)) { return _.diag(SPV_ERROR_INVALID_DATA, ld_inst) << "Missing decoration " << _.SpvDecorationString(decor); } decor = spv::Decoration::BlockMatchSamplerQCOM; if (!_.HasDecoration(texture_id, decor)) { return _.diag(SPV_ERROR_INVALID_DATA, ld_inst) << "Missing decoration " << _.SpvDecorationString(decor); } } else { const Instruction* si_inst = ld_inst; int t_idx = si_inst->GetOperandAs(2); // texture const Instruction* t_ld_inst = _.FindDef(t_idx); if (t_ld_inst->opcode() != spv::Op::OpLoad) { return _.diag(SPV_ERROR_INVALID_DATA, t_ld_inst) << "Expect to see OpLoad"; } int texture_id = t_ld_inst->GetOperandAs(2); // variable to load spv::Decoration decor = spv::Decoration::BlockMatchTextureQCOM; if (!_.HasDecoration(texture_id, decor)) { return _.diag(SPV_ERROR_INVALID_DATA, ld_inst) << "Missing decoration " << _.SpvDecorationString(decor); } int s_idx = si_inst->GetOperandAs(3); // sampler const Instruction* s_ld_inst = _.FindDef(s_idx); if (s_ld_inst->opcode() != spv::Op::OpLoad) { return _.diag(SPV_ERROR_INVALID_DATA, s_ld_inst) << "Expect to see OpLoad"; } int sampler_id = s_ld_inst->GetOperandAs(2); // variable to load decor = spv::Decoration::BlockMatchSamplerQCOM; if (!_.HasDecoration(sampler_id, decor)) { return _.diag(SPV_ERROR_INVALID_DATA, ld_inst) << "Missing decoration " << _.SpvDecorationString(decor); } } return SPV_SUCCESS; } spv_result_t ValidateImageProcessingQCOM(ValidationState_t& _, const Instruction* inst) { spv_result_t res = SPV_SUCCESS; const spv::Op opcode = inst->opcode(); switch (opcode) { case spv::Op::OpImageSampleWeightedQCOM: { int wi_idx = inst->GetOperandAs(4); // weight res = ValidateImageProcessingQCOMDecoration( _, wi_idx, spv::Decoration::WeightTextureQCOM); break; } case spv::Op::OpImageBlockMatchSSDQCOM: case spv::Op::OpImageBlockMatchSADQCOM: { int tgt_idx = inst->GetOperandAs(2); // target res = ValidateImageProcessingQCOMDecoration( _, tgt_idx, spv::Decoration::BlockMatchTextureQCOM); if (res != SPV_SUCCESS) break; int ref_idx = inst->GetOperandAs(4); // reference res = ValidateImageProcessingQCOMDecoration( _, ref_idx, spv::Decoration::BlockMatchTextureQCOM); break; } case spv::Op::OpImageBlockMatchWindowSSDQCOM: case spv::Op::OpImageBlockMatchWindowSADQCOM: { int tgt_idx = inst->GetOperandAs(2); // target res = ValidateImageProcessing2QCOMWindowDecoration(_, tgt_idx); if (res != SPV_SUCCESS) break; int ref_idx = inst->GetOperandAs(4); // reference res = ValidateImageProcessing2QCOMWindowDecoration(_, ref_idx); break; } case spv::Op::OpImageBlockMatchGatherSSDQCOM: case spv::Op::OpImageBlockMatchGatherSADQCOM: { int tgt_idx = inst->GetOperandAs(2); // target res = ValidateImageProcessingQCOMDecoration( _, tgt_idx, spv::Decoration::BlockMatchTextureQCOM); if (res != SPV_SUCCESS) break; int ref_idx = inst->GetOperandAs(4); // reference res = ValidateImageProcessingQCOMDecoration( _, ref_idx, spv::Decoration::BlockMatchTextureQCOM); break; } default: break; } return res; } } // namespace // Validates correctness of image instructions. spv_result_t ImagePass(ValidationState_t& _, const Instruction* inst) { const spv::Op opcode = inst->opcode(); if (IsImplicitLod(opcode)) { _.function(inst->function()->id()) ->RegisterExecutionModelLimitation([opcode](spv::ExecutionModel model, std::string* message) { if (model != spv::ExecutionModel::Fragment && model != spv::ExecutionModel::GLCompute && model != spv::ExecutionModel::MeshEXT && model != spv::ExecutionModel::TaskEXT) { if (message) { *message = std::string( "ImplicitLod instructions require Fragment, GLCompute, " "MeshEXT or TaskEXT execution model: ") + spvOpcodeString(opcode); } return false; } return true; }); _.function(inst->function()->id()) ->RegisterLimitation([opcode](const ValidationState_t& state, const Function* entry_point, std::string* message) { const auto* models = state.GetExecutionModels(entry_point->id()); const auto* modes = state.GetExecutionModes(entry_point->id()); if (models && (models->find(spv::ExecutionModel::GLCompute) != models->end() || models->find(spv::ExecutionModel::MeshEXT) != models->end() || models->find(spv::ExecutionModel::TaskEXT) != models->end()) && (!modes || (modes->find(spv::ExecutionMode::DerivativeGroupLinearKHR) == modes->end() && modes->find(spv::ExecutionMode::DerivativeGroupQuadsKHR) == modes->end()))) { if (message) { *message = std::string( "ImplicitLod instructions require " "DerivativeGroupQuadsKHR " "or DerivativeGroupLinearKHR execution mode for " "GLCompute, " "MeshEXT or TaskEXT execution model: ") + spvOpcodeString(opcode); } return false; } return true; }); } switch (opcode) { case spv::Op::OpTypeImage: return ValidateTypeImage(_, inst); case spv::Op::OpTypeSampledImage: return ValidateTypeSampledImage(_, inst); case spv::Op::OpSampledImage: return ValidateSampledImage(_, inst); case spv::Op::OpImageTexelPointer: return ValidateImageTexelPointer(_, inst); case spv::Op::OpImageSampleImplicitLod: case spv::Op::OpImageSampleExplicitLod: case spv::Op::OpImageSampleProjImplicitLod: case spv::Op::OpImageSampleProjExplicitLod: case spv::Op::OpImageSparseSampleImplicitLod: case spv::Op::OpImageSparseSampleExplicitLod: return ValidateImageLod(_, inst); case spv::Op::OpImageSampleDrefImplicitLod: case spv::Op::OpImageSampleDrefExplicitLod: case spv::Op::OpImageSampleProjDrefImplicitLod: case spv::Op::OpImageSampleProjDrefExplicitLod: case spv::Op::OpImageSparseSampleDrefImplicitLod: case spv::Op::OpImageSparseSampleDrefExplicitLod: return ValidateImageDrefLod(_, inst); case spv::Op::OpImageFetch: case spv::Op::OpImageSparseFetch: return ValidateImageFetch(_, inst); case spv::Op::OpImageGather: case spv::Op::OpImageDrefGather: case spv::Op::OpImageSparseGather: case spv::Op::OpImageSparseDrefGather: return ValidateImageGather(_, inst); case spv::Op::OpImageRead: case spv::Op::OpImageSparseRead: return ValidateImageRead(_, inst); case spv::Op::OpImageWrite: return ValidateImageWrite(_, inst); case spv::Op::OpImage: return ValidateImage(_, inst); case spv::Op::OpImageQueryFormat: case spv::Op::OpImageQueryOrder: return ValidateImageQueryFormatOrOrder(_, inst); case spv::Op::OpImageQuerySizeLod: return ValidateImageQuerySizeLod(_, inst); case spv::Op::OpImageQuerySize: return ValidateImageQuerySize(_, inst); case spv::Op::OpImageQueryLod: return ValidateImageQueryLod(_, inst); case spv::Op::OpImageQueryLevels: case spv::Op::OpImageQuerySamples: return ValidateImageQueryLevelsOrSamples(_, inst); case spv::Op::OpImageSparseSampleProjImplicitLod: case spv::Op::OpImageSparseSampleProjExplicitLod: case spv::Op::OpImageSparseSampleProjDrefImplicitLod: case spv::Op::OpImageSparseSampleProjDrefExplicitLod: return ValidateImageSparseLod(_, inst); case spv::Op::OpImageSparseTexelsResident: return ValidateImageSparseTexelsResident(_, inst); case spv::Op::OpImageSampleWeightedQCOM: case spv::Op::OpImageBoxFilterQCOM: case spv::Op::OpImageBlockMatchSSDQCOM: case spv::Op::OpImageBlockMatchSADQCOM: case spv::Op::OpImageBlockMatchWindowSADQCOM: case spv::Op::OpImageBlockMatchWindowSSDQCOM: case spv::Op::OpImageBlockMatchGatherSADQCOM: case spv::Op::OpImageBlockMatchGatherSSDQCOM: return ValidateImageProcessingQCOM(_, inst); default: break; } return SPV_SUCCESS; } bool IsImageInstruction(const spv::Op opcode) { switch (opcode) { case spv::Op::OpImageSampleImplicitLod: case spv::Op::OpImageSampleDrefImplicitLod: case spv::Op::OpImageSampleProjImplicitLod: case spv::Op::OpImageSampleProjDrefImplicitLod: case spv::Op::OpImageSparseSampleImplicitLod: case spv::Op::OpImageSparseSampleDrefImplicitLod: case spv::Op::OpImageSparseSampleProjImplicitLod: case spv::Op::OpImageSparseSampleProjDrefImplicitLod: case spv::Op::OpImageSampleExplicitLod: case spv::Op::OpImageSampleDrefExplicitLod: case spv::Op::OpImageSampleProjExplicitLod: case spv::Op::OpImageSampleProjDrefExplicitLod: case spv::Op::OpImageSparseSampleExplicitLod: case spv::Op::OpImageSparseSampleDrefExplicitLod: case spv::Op::OpImageSparseSampleProjExplicitLod: case spv::Op::OpImageSparseSampleProjDrefExplicitLod: case spv::Op::OpImage: case spv::Op::OpImageFetch: case spv::Op::OpImageSparseFetch: case spv::Op::OpImageGather: case spv::Op::OpImageDrefGather: case spv::Op::OpImageSparseGather: case spv::Op::OpImageSparseDrefGather: case spv::Op::OpImageRead: case spv::Op::OpImageSparseRead: case spv::Op::OpImageWrite: case spv::Op::OpImageQueryFormat: case spv::Op::OpImageQueryOrder: case spv::Op::OpImageQuerySizeLod: case spv::Op::OpImageQuerySize: case spv::Op::OpImageQueryLod: case spv::Op::OpImageQueryLevels: case spv::Op::OpImageQuerySamples: case spv::Op::OpImageSampleWeightedQCOM: case spv::Op::OpImageBoxFilterQCOM: case spv::Op::OpImageBlockMatchSSDQCOM: case spv::Op::OpImageBlockMatchSADQCOM: case spv::Op::OpImageBlockMatchWindowSADQCOM: case spv::Op::OpImageBlockMatchWindowSSDQCOM: case spv::Op::OpImageBlockMatchGatherSADQCOM: case spv::Op::OpImageBlockMatchGatherSSDQCOM: return true; default: break; } return false; } spv_result_t ValidateQCOMImageProcessingTextureUsages(ValidationState_t& _, const Instruction* inst) { const spv::Op opcode = inst->opcode(); if (!IsImageInstruction(opcode)) return SPV_SUCCESS; switch (opcode) { case spv::Op::OpImageSampleWeightedQCOM: case spv::Op::OpImageBoxFilterQCOM: case spv::Op::OpImageBlockMatchSSDQCOM: case spv::Op::OpImageBlockMatchSADQCOM: break; case spv::Op::OpImageBlockMatchWindowSADQCOM: case spv::Op::OpImageBlockMatchWindowSSDQCOM: case spv::Op::OpImageBlockMatchGatherSADQCOM: case spv::Op::OpImageBlockMatchGatherSSDQCOM: break; default: for (size_t i = 0; i < inst->operands().size(); ++i) { int id = inst->GetOperandAs(i); const Instruction* operand_inst = _.FindDef(id); if (operand_inst == nullptr) continue; if (operand_inst->opcode() == spv::Op::OpLoad) { if (_.IsQCOMImageProcessingTextureConsumer(id)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Illegal use of QCOM image processing decorated texture"; } } if (operand_inst->opcode() == spv::Op::OpSampledImage) { if (_.IsQCOMImageProcessingTextureConsumer(id)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Illegal use of QCOM image processing decorated texture"; } } } break; } return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_instruction.cpp000066400000000000000000000533111475742701700255540ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Performs validation on instructions that appear inside of a SPIR-V block. #include #include #include #include #include "source/enum_set.h" #include "source/enum_string_mapping.h" #include "source/extensions.h" #include "source/opcode.h" #include "source/operand.h" #include "source/spirv_constant.h" #include "source/spirv_target_env.h" #include "source/spirv_validator_options.h" #include "source/util/string_utils.h" #include "source/val/validate.h" #include "source/val/validation_state.h" namespace spvtools { namespace val { namespace { std::string ToString(const CapabilitySet& capabilities, const AssemblyGrammar& grammar) { std::stringstream ss; for (auto capability : capabilities) { spv_operand_desc desc; if (SPV_SUCCESS == grammar.lookupOperand(SPV_OPERAND_TYPE_CAPABILITY, uint32_t(capability), &desc)) ss << desc->name << " "; else ss << uint32_t(capability) << " "; } return ss.str(); } // Returns capabilities that enable an opcode. An empty result is interpreted // as no prohibition of use of the opcode. If the result is non-empty, then // the opcode may only be used if at least one of the capabilities is specified // by the module. CapabilitySet EnablingCapabilitiesForOp(const ValidationState_t& state, spv::Op opcode) { // Exceptions for SPV_AMD_shader_ballot switch (opcode) { // Normally these would require Group capability case spv::Op::OpGroupIAddNonUniformAMD: case spv::Op::OpGroupFAddNonUniformAMD: case spv::Op::OpGroupFMinNonUniformAMD: case spv::Op::OpGroupUMinNonUniformAMD: case spv::Op::OpGroupSMinNonUniformAMD: case spv::Op::OpGroupFMaxNonUniformAMD: case spv::Op::OpGroupUMaxNonUniformAMD: case spv::Op::OpGroupSMaxNonUniformAMD: if (state.HasExtension(kSPV_AMD_shader_ballot)) return CapabilitySet(); break; default: break; } // Look it up in the grammar spv_opcode_desc opcode_desc = {}; if (SPV_SUCCESS == state.grammar().lookupOpcode(opcode, &opcode_desc)) { return state.grammar().filterCapsAgainstTargetEnv( opcode_desc->capabilities, opcode_desc->numCapabilities); } return CapabilitySet(); } // Returns SPV_SUCCESS if, for the given operand, the target environment // satsifies minimum version requirements, or if the module declares an // enabling extension for the operand. Otherwise emit a diagnostic and // return an error code. spv_result_t OperandVersionExtensionCheck( ValidationState_t& _, const Instruction* inst, size_t which_operand, const spv_operand_desc_t& operand_desc, uint32_t word) { const uint32_t module_version = _.version(); const uint32_t operand_min_version = operand_desc.minVersion; const uint32_t operand_last_version = operand_desc.lastVersion; const bool reserved = operand_min_version == 0xffffffffu; const bool version_satisfied = !reserved && (operand_min_version <= module_version) && (module_version <= operand_last_version); if (version_satisfied) { return SPV_SUCCESS; } if (operand_last_version < module_version) { return _.diag(SPV_ERROR_WRONG_VERSION, inst) << spvtools::utils::CardinalToOrdinal(which_operand) << " operand of " << spvOpcodeString(inst->opcode()) << ": operand " << operand_desc.name << "(" << word << ") requires SPIR-V version " << SPV_SPIRV_VERSION_MAJOR_PART(operand_last_version) << "." << SPV_SPIRV_VERSION_MINOR_PART(operand_last_version) << " or earlier"; } if (!reserved && operand_desc.numExtensions == 0) { return _.diag(SPV_ERROR_WRONG_VERSION, inst) << spvtools::utils::CardinalToOrdinal(which_operand) << " operand of " << spvOpcodeString(inst->opcode()) << ": operand " << operand_desc.name << "(" << word << ") requires SPIR-V version " << SPV_SPIRV_VERSION_MAJOR_PART(operand_min_version) << "." << SPV_SPIRV_VERSION_MINOR_PART(operand_min_version) << " or later"; } else { ExtensionSet required_extensions(operand_desc.numExtensions, operand_desc.extensions); if (!_.HasAnyOfExtensions(required_extensions)) { return _.diag(SPV_ERROR_MISSING_EXTENSION, inst) << spvtools::utils::CardinalToOrdinal(which_operand) << " operand of " << spvOpcodeString(inst->opcode()) << ": operand " << operand_desc.name << "(" << word << ") requires one of these extensions: " << ExtensionSetToString(required_extensions); } } return SPV_SUCCESS; } // Returns SPV_SUCCESS if the given operand is enabled by capabilities declared // in the module. Otherwise issues an error message and returns // SPV_ERROR_INVALID_CAPABILITY. spv_result_t CheckRequiredCapabilities(ValidationState_t& state, const Instruction* inst, size_t which_operand, const spv_parsed_operand_t& operand, uint32_t word) { // Mere mention of PointSize, ClipDistance, or CullDistance in a Builtin // decoration does not require the associated capability. The use of such // a variable value should trigger the capability requirement, but that's // not implemented yet. This rule is independent of target environment. // See https://github.com/KhronosGroup/SPIRV-Tools/issues/365 if (operand.type == SPV_OPERAND_TYPE_BUILT_IN) { switch (spv::BuiltIn(word)) { case spv::BuiltIn::PointSize: case spv::BuiltIn::ClipDistance: case spv::BuiltIn::CullDistance: return SPV_SUCCESS; default: break; } } else if (operand.type == SPV_OPERAND_TYPE_FP_ROUNDING_MODE) { // Allow all FP rounding modes if requested if (state.features().free_fp_rounding_mode) { return SPV_SUCCESS; } } else if (operand.type == SPV_OPERAND_TYPE_GROUP_OPERATION && state.features().group_ops_reduce_and_scans && (word <= uint32_t(spv::GroupOperation::ExclusiveScan))) { // Allow certain group operations if requested. return SPV_SUCCESS; } CapabilitySet enabling_capabilities; spv_operand_desc operand_desc = nullptr; const auto lookup_result = state.grammar().lookupOperand(operand.type, word, &operand_desc); if (lookup_result == SPV_SUCCESS) { // Allow FPRoundingMode decoration if requested. if (operand.type == SPV_OPERAND_TYPE_DECORATION && spv::Decoration(operand_desc->value) == spv::Decoration::FPRoundingMode) { if (state.features().free_fp_rounding_mode) return SPV_SUCCESS; // Vulkan API requires more capabilities on rounding mode. if (spvIsVulkanEnv(state.context()->target_env)) { enabling_capabilities.insert( spv::Capability::StorageUniformBufferBlock16); enabling_capabilities.insert(spv::Capability::StorageUniform16); enabling_capabilities.insert(spv::Capability::StoragePushConstant16); enabling_capabilities.insert(spv::Capability::StorageInputOutput16); } } else { enabling_capabilities = state.grammar().filterCapsAgainstTargetEnv( operand_desc->capabilities, operand_desc->numCapabilities); } // When encountering an OpCapability instruction, the instruction pass // registers a capability with the module *before* checking capabilities. // So in the case of an OpCapability instruction, don't bother checking // enablement by another capability. if (inst->opcode() != spv::Op::OpCapability) { const bool enabled_by_cap = state.HasAnyOfCapabilities(enabling_capabilities); if (!enabling_capabilities.empty() && !enabled_by_cap) { return state.diag(SPV_ERROR_INVALID_CAPABILITY, inst) << "Operand " << which_operand << " of " << spvOpcodeString(inst->opcode()) << " requires one of these capabilities: " << ToString(enabling_capabilities, state.grammar()); } } return OperandVersionExtensionCheck(state, inst, which_operand, *operand_desc, word); } return SPV_SUCCESS; } // Returns SPV_ERROR_INVALID_BINARY and emits a diagnostic if the instruction // is explicitly reserved in the SPIR-V core spec. Otherwise return // SPV_SUCCESS. spv_result_t ReservedCheck(ValidationState_t& _, const Instruction* inst) { const spv::Op opcode = inst->opcode(); switch (opcode) { // These instructions are enabled by a capability, but should never // be used anyway. case spv::Op::OpImageSparseSampleProjImplicitLod: case spv::Op::OpImageSparseSampleProjExplicitLod: case spv::Op::OpImageSparseSampleProjDrefImplicitLod: case spv::Op::OpImageSparseSampleProjDrefExplicitLod: { spv_opcode_desc inst_desc; _.grammar().lookupOpcode(opcode, &inst_desc); return _.diag(SPV_ERROR_INVALID_BINARY, inst) << "Invalid Opcode name 'Op" << inst_desc->name << "'"; } default: break; } return SPV_SUCCESS; } // Returns SPV_ERROR_INVALID_CAPABILITY and emits a diagnostic if the // instruction is invalid because the required capability isn't declared // in the module. spv_result_t CapabilityCheck(ValidationState_t& _, const Instruction* inst) { const spv::Op opcode = inst->opcode(); CapabilitySet opcode_caps = EnablingCapabilitiesForOp(_, opcode); if (!_.HasAnyOfCapabilities(opcode_caps)) { return _.diag(SPV_ERROR_INVALID_CAPABILITY, inst) << "Opcode " << spvOpcodeString(opcode) << " requires one of these capabilities: " << ToString(opcode_caps, _.grammar()); } for (size_t i = 0; i < inst->operands().size(); ++i) { const auto& operand = inst->operand(i); const auto word = inst->word(operand.offset); if (spvOperandIsConcreteMask(operand.type)) { // Check for required capabilities for each bit position of the mask. for (uint32_t mask_bit = 0x80000000; mask_bit; mask_bit >>= 1) { if (word & mask_bit) { spv_result_t status = CheckRequiredCapabilities(_, inst, i + 1, operand, mask_bit); if (status != SPV_SUCCESS) return status; } } } else if (spvIsIdType(operand.type)) { // TODO(dneto): Check the value referenced by this Id, if we can compute // it. For now, just punt, to fix issue 248: // https://github.com/KhronosGroup/SPIRV-Tools/issues/248 } else { // Check the operand word as a whole. spv_result_t status = CheckRequiredCapabilities(_, inst, i + 1, operand, word); if (status != SPV_SUCCESS) return status; } } return SPV_SUCCESS; } // Checks that the instruction can be used in this target environment's base // version. Assumes that CapabilityCheck has checked direct capability // dependencies for the opcode. spv_result_t VersionCheck(ValidationState_t& _, const Instruction* inst) { const auto opcode = inst->opcode(); spv_opcode_desc inst_desc; const spv_result_t r = _.grammar().lookupOpcode(opcode, &inst_desc); assert(r == SPV_SUCCESS); (void)r; const auto min_version = inst_desc->minVersion; const auto last_version = inst_desc->lastVersion; const auto module_version = _.version(); if (last_version < module_version) { return _.diag(SPV_ERROR_WRONG_VERSION, inst) << spvOpcodeString(opcode) << " requires SPIR-V version " << SPV_SPIRV_VERSION_MAJOR_PART(last_version) << "." << SPV_SPIRV_VERSION_MINOR_PART(last_version) << " or earlier"; } // OpTerminateInvocation is special because it is enabled by Shader // capability, but also requires an extension and/or version check. const bool capability_check_is_sufficient = inst->opcode() != spv::Op::OpTerminateInvocation; if (capability_check_is_sufficient && (inst_desc->numCapabilities > 0u)) { // We already checked that the direct capability dependency has been // satisfied. We don't need to check any further. return SPV_SUCCESS; } ExtensionSet exts(inst_desc->numExtensions, inst_desc->extensions); if (exts.empty()) { // If no extensions can enable this instruction, then emit error // messages only concerning core SPIR-V versions if errors happen. if (min_version == ~0u) { return _.diag(SPV_ERROR_WRONG_VERSION, inst) << spvOpcodeString(opcode) << " is reserved for future use."; } if (module_version < min_version) { return _.diag(SPV_ERROR_WRONG_VERSION, inst) << spvOpcodeString(opcode) << " requires SPIR-V version " << SPV_SPIRV_VERSION_MAJOR_PART(min_version) << "." << SPV_SPIRV_VERSION_MINOR_PART(min_version) << " at minimum."; } } else if (!_.HasAnyOfExtensions(exts)) { // Otherwise, we only error out when no enabling extensions are // registered. if (min_version == ~0u) { return _.diag(SPV_ERROR_MISSING_EXTENSION, inst) << spvOpcodeString(opcode) << " requires one of the following extensions: " << ExtensionSetToString(exts); } if (module_version < min_version) { return _.diag(SPV_ERROR_WRONG_VERSION, inst) << spvOpcodeString(opcode) << " requires SPIR-V version " << SPV_SPIRV_VERSION_MAJOR_PART(min_version) << "." << SPV_SPIRV_VERSION_MINOR_PART(min_version) << " at minimum or one of the following extensions: " << ExtensionSetToString(exts); } } return SPV_SUCCESS; } // Checks that the Resuld is within the valid bound. spv_result_t LimitCheckIdBound(ValidationState_t& _, const Instruction* inst) { if (inst->id() >= _.getIdBound()) { return _.diag(SPV_ERROR_INVALID_BINARY, inst) << "Result '" << inst->id() << "' must be less than the ID bound '" << _.getIdBound() << "'."; } return SPV_SUCCESS; } // Checks that the number of OpTypeStruct members is within the limit. spv_result_t LimitCheckStruct(ValidationState_t& _, const Instruction* inst) { if (spv::Op::OpTypeStruct != inst->opcode()) { return SPV_SUCCESS; } // Number of members is the number of operands of the instruction minus 1. // One operand is the result ID. const uint16_t limit = static_cast(_.options()->universal_limits_.max_struct_members); if (inst->operands().size() - 1 > limit) { return _.diag(SPV_ERROR_INVALID_BINARY, inst) << "Number of OpTypeStruct members (" << inst->operands().size() - 1 << ") has exceeded the limit (" << limit << ")."; } // Section 2.17 of SPIRV Spec specifies that the "Structure Nesting Depth" // must be less than or equal to 255. // This is interpreted as structures including other structures as // members. The code does not follow pointers or look into arrays to see // if we reach a structure downstream. The nesting depth of a struct is // 1+(largest depth of any member). Scalars are at depth 0. uint32_t max_member_depth = 0; // Struct members start at word 2 of OpTypeStruct instruction. for (size_t word_i = 2; word_i < inst->words().size(); ++word_i) { auto member = inst->word(word_i); auto memberTypeInstr = _.FindDef(member); if (memberTypeInstr && spv::Op::OpTypeStruct == memberTypeInstr->opcode()) { max_member_depth = std::max( max_member_depth, _.struct_nesting_depth(memberTypeInstr->id())); } } const uint32_t depth_limit = _.options()->universal_limits_.max_struct_depth; const uint32_t cur_depth = 1 + max_member_depth; _.set_struct_nesting_depth(inst->id(), cur_depth); if (cur_depth > depth_limit) { return _.diag(SPV_ERROR_INVALID_BINARY, inst) << "Structure Nesting Depth may not be larger than " << depth_limit << ". Found " << cur_depth << "."; } return SPV_SUCCESS; } // Checks that the number of (literal, label) pairs in OpSwitch is within // the limit. spv_result_t LimitCheckSwitch(ValidationState_t& _, const Instruction* inst) { if (spv::Op::OpSwitch == inst->opcode()) { // The instruction syntax is as follows: // OpSwitch literal label literal label ... // literal,label pairs come after the first 2 operands. // It is guaranteed at this point that num_operands is an even number. size_t num_pairs = (inst->operands().size() - 2) / 2; const unsigned int num_pairs_limit = _.options()->universal_limits_.max_switch_branches; if (num_pairs > num_pairs_limit) { return _.diag(SPV_ERROR_INVALID_BINARY, inst) << "Number of (literal, label) pairs in OpSwitch (" << num_pairs << ") exceeds the limit (" << num_pairs_limit << ")."; } } return SPV_SUCCESS; } // Ensure the number of variables of the given class does not exceed the // limit. spv_result_t LimitCheckNumVars(ValidationState_t& _, const uint32_t var_id, const spv::StorageClass storage_class) { if (spv::StorageClass::Function == storage_class) { _.registerLocalVariable(var_id); const uint32_t num_local_vars_limit = _.options()->universal_limits_.max_local_variables; if (_.num_local_vars() > num_local_vars_limit) { return _.diag(SPV_ERROR_INVALID_BINARY, nullptr) << "Number of local variables ('Function' Storage Class) " "exceeded the valid limit (" << num_local_vars_limit << ")."; } } else { _.registerGlobalVariable(var_id); const uint32_t num_global_vars_limit = _.options()->universal_limits_.max_global_variables; if (_.num_global_vars() > num_global_vars_limit) { return _.diag(SPV_ERROR_INVALID_BINARY, nullptr) << "Number of Global Variables (Storage Class other than " "'Function') exceeded the valid limit (" << num_global_vars_limit << ")."; } } return SPV_SUCCESS; } // Parses OpExtension instruction and logs warnings if unsuccessful. spv_result_t CheckIfKnownExtension(ValidationState_t& _, const Instruction* inst) { const std::string extension_str = GetExtensionString(&(inst->c_inst())); Extension extension; if (!GetExtensionFromString(extension_str.c_str(), &extension)) { return _.diag(SPV_WARNING, inst) << "Found unrecognized extension " << extension_str; } return SPV_SUCCESS; } } // namespace spv_result_t InstructionPass(ValidationState_t& _, const Instruction* inst) { const spv::Op opcode = inst->opcode(); if (opcode == spv::Op::OpExtension) { CheckIfKnownExtension(_, inst); } else if (opcode == spv::Op::OpCapability) { _.RegisterCapability(inst->GetOperandAs(0)); } else if (opcode == spv::Op::OpMemoryModel) { if (_.has_memory_model_specified()) { return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) << "OpMemoryModel should only be provided once."; } _.set_addressing_model(inst->GetOperandAs(0)); _.set_memory_model(inst->GetOperandAs(1)); } else if (opcode == spv::Op::OpExecutionMode || opcode == spv::Op::OpExecutionModeId) { const uint32_t entry_point = inst->word(1); _.RegisterExecutionModeForEntryPoint(entry_point, spv::ExecutionMode(inst->word(2))); if (inst->GetOperandAs(1) == spv::ExecutionMode::LocalSize || inst->GetOperandAs(1) == spv::ExecutionMode::LocalSizeId) { _.RegisterEntryPointLocalSize(entry_point, inst); } if (inst->GetOperandAs(1) == spv::ExecutionMode::OutputPrimitivesEXT) { _.RegisterEntryPointOutputPrimitivesEXT(entry_point, inst); } } else if (opcode == spv::Op::OpVariable) { const auto storage_class = inst->GetOperandAs(2); if (auto error = LimitCheckNumVars(_, inst->id(), storage_class)) { return error; } } else if (opcode == spv::Op::OpSamplerImageAddressingModeNV) { if (!_.HasCapability(spv::Capability::BindlessTextureNV)) { return _.diag(SPV_ERROR_MISSING_EXTENSION, inst) << "OpSamplerImageAddressingModeNV supported only with extension " "SPV_NV_bindless_texture"; } uint32_t bitwidth = inst->GetOperandAs(0); if (_.samplerimage_variable_address_mode() != 0) { return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) << "OpSamplerImageAddressingModeNV should only be provided once"; } if (bitwidth != 32 && bitwidth != 64) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "OpSamplerImageAddressingModeNV bitwidth should be 64 or 32"; } _.set_samplerimage_variable_address_mode(bitwidth); } if (auto error = ReservedCheck(_, inst)) return error; if (auto error = CapabilityCheck(_, inst)) return error; if (auto error = LimitCheckIdBound(_, inst)) return error; if (auto error = LimitCheckStruct(_, inst)) return error; if (auto error = LimitCheckSwitch(_, inst)) return error; if (auto error = VersionCheck(_, inst)) return error; // All instruction checks have passed. return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_interfaces.cpp000066400000000000000000000607611475742701700253250ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "source/spirv_constant.h" #include "source/spirv_target_env.h" #include "source/val/function.h" #include "source/val/instruction.h" #include "source/val/validate.h" #include "source/val/validation_state.h" namespace spvtools { namespace val { namespace { // Limit the number of checked locations to 4096. Multiplied by 4 to represent // all the components. This limit is set to be well beyond practical use cases. const uint32_t kMaxLocations = 4096 * 4; // Returns true if \c inst is an input or output variable. bool is_interface_variable(const Instruction* inst, bool is_spv_1_4) { if (is_spv_1_4) { // Starting in SPIR-V 1.4, all global variables are interface variables. return (inst->opcode() == spv::Op::OpVariable || inst->opcode() == spv::Op::OpUntypedVariableKHR) && inst->GetOperandAs(2u) != spv::StorageClass::Function; } else { return (inst->opcode() == spv::Op::OpVariable || inst->opcode() == spv::Op::OpUntypedVariableKHR) && (inst->GetOperandAs(2u) == spv::StorageClass::Input || inst->GetOperandAs(2u) == spv::StorageClass::Output); } } // Checks that \c var is listed as an interface in all the entry points that use // it. spv_result_t check_interface_variable(ValidationState_t& _, const Instruction* var) { std::vector functions; std::vector uses; for (auto use : var->uses()) { uses.push_back(use.first); } for (uint32_t i = 0; i < uses.size(); ++i) { const auto user = uses[i]; if (const Function* func = user->function()) { functions.push_back(func); } else { // In the rare case that the variable is used by another instruction in // the global scope, continue searching for an instruction used in a // function. for (auto use : user->uses()) { uses.push_back(use.first); } } } std::sort(functions.begin(), functions.end(), [](const Function* lhs, const Function* rhs) { return lhs->id() < rhs->id(); }); functions.erase(std::unique(functions.begin(), functions.end()), functions.end()); std::vector entry_points; for (const auto func : functions) { for (auto id : _.FunctionEntryPoints(func->id())) { entry_points.push_back(id); } } std::sort(entry_points.begin(), entry_points.end()); entry_points.erase(std::unique(entry_points.begin(), entry_points.end()), entry_points.end()); for (auto id : entry_points) { for (const auto& desc : _.entry_point_descriptions(id)) { bool found = false; for (auto interface : desc.interfaces) { if (var->id() == interface) { found = true; break; } } if (!found) { return _.diag(SPV_ERROR_INVALID_ID, var) << "Interface variable id <" << var->id() << "> is used by entry point '" << desc.name << "' id <" << id << ">, but is not listed as an interface"; } } } return SPV_SUCCESS; } // This function assumes a base location has been determined already. As such // any further location decorations are invalid. // TODO: if this code turns out to be slow, there is an opportunity to cache // the result for a given type id. spv_result_t NumConsumedLocations(ValidationState_t& _, const Instruction* type, uint32_t* num_locations) { *num_locations = 0; switch (type->opcode()) { case spv::Op::OpTypeInt: case spv::Op::OpTypeFloat: // Scalars always consume a single location. *num_locations = 1; break; case spv::Op::OpTypeVector: // 3- and 4-component 64-bit vectors consume two locations. if ((_.ContainsSizedIntOrFloatType(type->id(), spv::Op::OpTypeInt, 64) || _.ContainsSizedIntOrFloatType(type->id(), spv::Op::OpTypeFloat, 64)) && (type->GetOperandAs(2) > 2)) { *num_locations = 2; } else { *num_locations = 1; } break; case spv::Op::OpTypeMatrix: // Matrices consume locations equal to the underlying vector type for // each column. NumConsumedLocations(_, _.FindDef(type->GetOperandAs(1)), num_locations); *num_locations *= type->GetOperandAs(2); break; case spv::Op::OpTypeArray: { // Arrays consume locations equal to the underlying type times the number // of elements in the vector. NumConsumedLocations(_, _.FindDef(type->GetOperandAs(1)), num_locations); bool is_int = false; bool is_const = false; uint32_t value = 0; // Attempt to evaluate the number of array elements. std::tie(is_int, is_const, value) = _.EvalInt32IfConst(type->GetOperandAs(2)); if (is_int && is_const) *num_locations *= value; break; } case spv::Op::OpTypeStruct: { // Members cannot have location decorations at this point. if (_.HasDecoration(type->id(), spv::Decoration::Location)) { return _.diag(SPV_ERROR_INVALID_DATA, type) << _.VkErrorID(4918) << "Members cannot be assigned a location"; } // Structs consume locations equal to the sum of the locations consumed // by the members. for (uint32_t i = 1; i < type->operands().size(); ++i) { uint32_t member_locations = 0; if (auto error = NumConsumedLocations( _, _.FindDef(type->GetOperandAs(i)), &member_locations)) { return error; } *num_locations += member_locations; } break; } case spv::Op::OpTypePointer: { if (_.addressing_model() == spv::AddressingModel::PhysicalStorageBuffer64 && type->GetOperandAs(1) == spv::StorageClass::PhysicalStorageBuffer) { *num_locations = 1; break; } [[fallthrough]]; } default: return _.diag(SPV_ERROR_INVALID_DATA, type) << "Invalid type to assign a location"; } return SPV_SUCCESS; } // Returns the number of components consumed by types that support a component // decoration. uint32_t NumConsumedComponents(ValidationState_t& _, const Instruction* type) { uint32_t num_components = 0; switch (type->opcode()) { case spv::Op::OpTypeInt: case spv::Op::OpTypeFloat: // 64-bit types consume two components. if (type->GetOperandAs(1) == 64) { num_components = 2; } else { num_components = 1; } break; case spv::Op::OpTypeVector: // Vectors consume components equal to the underlying type's consumption // times the number of elements in the vector. Note that 3- and 4-element // vectors cannot have a component decoration (i.e. assumed to be zero). num_components = NumConsumedComponents(_, _.FindDef(type->GetOperandAs(1))); num_components *= type->GetOperandAs(2); break; case spv::Op::OpTypeArray: // Skip the array. return NumConsumedComponents(_, _.FindDef(type->GetOperandAs(1))); case spv::Op::OpTypePointer: if (_.addressing_model() == spv::AddressingModel::PhysicalStorageBuffer64 && type->GetOperandAs(1) == spv::StorageClass::PhysicalStorageBuffer) { return 2; } break; default: // This is an error that is validated elsewhere. break; } return num_components; } // Populates |locations| (and/or |output_index1_locations|) with the use // location and component coordinates for |variable|. Indices are calculated as // 4 * location + component. spv_result_t GetLocationsForVariable( ValidationState_t& _, const Instruction* entry_point, const Instruction* variable, std::unordered_set* locations, std::unordered_set* output_index1_locations) { const bool is_fragment = entry_point->GetOperandAs(0) == spv::ExecutionModel::Fragment; const auto sc_index = 2u; const bool is_output = variable->GetOperandAs(sc_index) == spv::StorageClass::Output; auto ptr_type_id = variable->GetOperandAs(0); auto ptr_type = _.FindDef(ptr_type_id); auto type_id = ptr_type->GetOperandAs(2); auto type = _.FindDef(type_id); // Check for Location, Component and Index decorations on the variable. The // validator allows duplicate decorations if the location/component/index are // equal. Also track Patch and PerTaskNV decorations. bool has_location = false; uint32_t location = 0; uint32_t component = 0; bool has_index = false; uint32_t index = 0; bool has_patch = false; bool has_per_task_nv = false; bool has_per_vertex_khr = false; // Duplicate Location, Component, Index are checked elsewhere. for (auto& dec : _.id_decorations(variable->id())) { if (dec.dec_type() == spv::Decoration::Location) { has_location = true; location = dec.params()[0]; } else if (dec.dec_type() == spv::Decoration::Component) { component = dec.params()[0]; } else if (dec.dec_type() == spv::Decoration::Index) { if (!is_output || !is_fragment) { return _.diag(SPV_ERROR_INVALID_DATA, variable) << "Index can only be applied to Fragment output variables"; } has_index = true; index = dec.params()[0]; } else if (dec.dec_type() == spv::Decoration::BuiltIn) { // Don't check built-ins. return SPV_SUCCESS; } else if (dec.dec_type() == spv::Decoration::Patch) { has_patch = true; } else if (dec.dec_type() == spv::Decoration::PerTaskNV) { has_per_task_nv = true; } else if (dec.dec_type() == spv::Decoration::PerVertexKHR) { if (!is_fragment) { return _.diag(SPV_ERROR_INVALID_DATA, variable) << _.VkErrorID(6777) << "PerVertexKHR can only be applied to Fragment Execution " "Models"; } if (type->opcode() != spv::Op::OpTypeArray && type->opcode() != spv::Op::OpTypeRuntimeArray) { return _.diag(SPV_ERROR_INVALID_DATA, variable) << _.VkErrorID(6778) << "PerVertexKHR must be declared as arrays"; } has_per_vertex_khr = true; } } // Vulkan 14.1.3: Tessellation control and mesh per-vertex outputs and // tessellation control, evaluation and geometry per-vertex inputs have a // layer of arraying that is not included in interface matching. bool is_arrayed = false; switch (entry_point->GetOperandAs(0)) { case spv::ExecutionModel::TessellationControl: if (!has_patch) { is_arrayed = true; } break; case spv::ExecutionModel::TessellationEvaluation: if (!is_output && !has_patch) { is_arrayed = true; } break; case spv::ExecutionModel::Geometry: if (!is_output) { is_arrayed = true; } break; case spv::ExecutionModel::Fragment: if (!is_output && has_per_vertex_khr) { is_arrayed = true; } break; case spv::ExecutionModel::MeshNV: if (is_output && !has_per_task_nv) { is_arrayed = true; } break; default: break; } // Unpack arrayness. if (is_arrayed && (type->opcode() == spv::Op::OpTypeArray || type->opcode() == spv::Op::OpTypeRuntimeArray)) { type_id = type->GetOperandAs(1); type = _.FindDef(type_id); } if (type->opcode() == spv::Op::OpTypeStruct) { // Don't check built-ins. if (_.HasDecoration(type_id, spv::Decoration::BuiltIn)) return SPV_SUCCESS; } // Only block-decorated structs don't need a location on the variable. const bool is_block = _.HasDecoration(type_id, spv::Decoration::Block); if (!has_location && !is_block) { const auto vuid = (type->opcode() == spv::Op::OpTypeStruct) ? 4917 : 4916; return _.diag(SPV_ERROR_INVALID_DATA, variable) << _.VkErrorID(vuid) << "Variable must be decorated with a location"; } const std::string storage_class = is_output ? "output" : "input"; if (has_location) { auto sub_type = type; bool is_int = false; bool is_const = false; uint32_t array_size = 1; // If the variable is still arrayed, mark the locations/components per // index. if (type->opcode() == spv::Op::OpTypeArray) { // Determine the array size if possible and get the element type. std::tie(is_int, is_const, array_size) = _.EvalInt32IfConst(type->GetOperandAs(2)); if (!is_int || !is_const) array_size = 1; auto sub_type_id = type->GetOperandAs(1); sub_type = _.FindDef(sub_type_id); } uint32_t num_locations = 0; if (auto error = NumConsumedLocations(_, sub_type, &num_locations)) return error; uint32_t num_components = NumConsumedComponents(_, sub_type); for (uint32_t array_idx = 0; array_idx < array_size; ++array_idx) { uint32_t array_location = location + (num_locations * array_idx); uint32_t start = array_location * 4; if (kMaxLocations <= start) { // Too many locations, give up. break; } uint32_t end = (array_location + num_locations) * 4; if (num_components != 0) { start += component; end = array_location * 4 + component + num_components; } auto locs = locations; if (has_index && index == 1) locs = output_index1_locations; for (uint32_t i = start; i < end; ++i) { if (!locs->insert(i).second) { return _.diag(SPV_ERROR_INVALID_DATA, entry_point) << (is_output ? _.VkErrorID(8722) : _.VkErrorID(8721)) << "Entry-point has conflicting " << storage_class << " location assignment at location " << i / 4 << ", component " << i % 4; } } } } else { // For Block-decorated structs with no location assigned to the variable, // each member of the block must be assigned a location. Also record any // member component assignments. The validator allows duplicate decorations // if they agree on the location/component. std::unordered_map member_locations; std::unordered_map member_components; for (auto& dec : _.id_decorations(type_id)) { if (dec.dec_type() == spv::Decoration::Location) { auto where = member_locations.find(dec.struct_member_index()); if (where == member_locations.end()) { member_locations[dec.struct_member_index()] = dec.params()[0]; } else if (where->second != dec.params()[0]) { return _.diag(SPV_ERROR_INVALID_DATA, type) << "Member index " << dec.struct_member_index() << " has conflicting location assignments"; } } else if (dec.dec_type() == spv::Decoration::Component) { auto where = member_components.find(dec.struct_member_index()); if (where == member_components.end()) { member_components[dec.struct_member_index()] = dec.params()[0]; } else if (where->second != dec.params()[0]) { return _.diag(SPV_ERROR_INVALID_DATA, type) << "Member index " << dec.struct_member_index() << " has conflicting component assignments"; } } } for (uint32_t i = 1; i < type->operands().size(); ++i) { auto where = member_locations.find(i - 1); if (where == member_locations.end()) { return _.diag(SPV_ERROR_INVALID_DATA, type) << _.VkErrorID(4919) << "Member index " << i - 1 << " is missing a location assignment"; } location = where->second; auto member = _.FindDef(type->GetOperandAs(i)); uint32_t num_locations = 0; if (auto error = NumConsumedLocations(_, member, &num_locations)) return error; // If the component is not specified, it is assumed to be zero. uint32_t num_components = NumConsumedComponents(_, member); component = 0; if (member_components.count(i - 1)) { component = member_components[i - 1]; } uint32_t start = location * 4; if (kMaxLocations <= start) { // Too many locations, give up. continue; } if (member->opcode() == spv::Op::OpTypeArray && num_components >= 1 && num_components < 4) { // When an array has an element that takes less than a location in // size, calculate the used locations in a strided manner. for (uint32_t l = location; l < num_locations + location; ++l) { for (uint32_t c = component; c < component + num_components; ++c) { uint32_t check = 4 * l + c; if (!locations->insert(check).second) { return _.diag(SPV_ERROR_INVALID_DATA, entry_point) << (is_output ? _.VkErrorID(8722) : _.VkErrorID(8721)) << "Entry-point has conflicting " << storage_class << " location assignment at location " << l << ", component " << c; } } } } else { // TODO: There is a hole here is the member is an array of 3- or // 4-element vectors of 64-bit types. uint32_t end = (location + num_locations) * 4; if (num_components != 0) { start += component; end = location * 4 + component + num_components; } for (uint32_t l = start; l < end; ++l) { if (!locations->insert(l).second) { return _.diag(SPV_ERROR_INVALID_DATA, entry_point) << (is_output ? _.VkErrorID(8722) : _.VkErrorID(8721)) << "Entry-point has conflicting " << storage_class << " location assignment at location " << l / 4 << ", component " << l % 4; } } } } } return SPV_SUCCESS; } spv_result_t ValidateLocations(ValidationState_t& _, const Instruction* entry_point) { // According to Vulkan 14.1 only the following execution models have // locations assigned. // TODO(dneto): SPV_NV_ray_tracing also uses locations on interface variables, // in other shader stages. Similarly, the *provisional* version of // SPV_KHR_ray_tracing did as well, but not the final version. switch (entry_point->GetOperandAs(0)) { case spv::ExecutionModel::Vertex: case spv::ExecutionModel::TessellationControl: case spv::ExecutionModel::TessellationEvaluation: case spv::ExecutionModel::Geometry: case spv::ExecutionModel::Fragment: break; default: return SPV_SUCCESS; } // Locations are stored as a combined location and component values. std::unordered_set input_locations; std::unordered_set output_locations_index0; std::unordered_set output_locations_index1; std::unordered_set patch_locations_index0; std::unordered_set patch_locations_index1; std::unordered_set seen; for (uint32_t i = 3; i < entry_point->operands().size(); ++i) { auto interface_id = entry_point->GetOperandAs(i); auto interface_var = _.FindDef(interface_id); const auto sc_index = 2u; auto storage_class = interface_var->GetOperandAs(sc_index); if (storage_class != spv::StorageClass::Input && storage_class != spv::StorageClass::Output) { continue; } if (!seen.insert(interface_id).second) { // Pre-1.4 an interface variable could be listed multiple times in an // entry point. Validation for 1.4 or later is done elsewhere. continue; } // The two Tessellation stages have a "Patch" variable that interface with // the Location mechanism, but are not suppose to be tied to the "normal" // input/output Location. // TODO - SPIR-V allows the Patch decoration to be applied to struct // members, but is not allowed in GLSL/HLSL bool has_patch = false; for (auto& dec : _.id_decorations(interface_var->id())) { if (dec.dec_type() == spv::Decoration::Patch) { has_patch = true; if (auto error = GetLocationsForVariable(_, entry_point, interface_var, &patch_locations_index0, &patch_locations_index1)) return error; break; } } if (has_patch) { continue; } auto locations = (storage_class == spv::StorageClass::Input) ? &input_locations : &output_locations_index0; if (auto error = GetLocationsForVariable( _, entry_point, interface_var, locations, &output_locations_index1)) return error; } return SPV_SUCCESS; } spv_result_t ValidateStorageClass(ValidationState_t& _, const Instruction* entry_point) { bool has_push_constant = false; bool has_ray_payload = false; bool has_hit_attribute = false; bool has_callable_data = false; for (uint32_t i = 3; i < entry_point->operands().size(); ++i) { auto interface_id = entry_point->GetOperandAs(i); auto interface_var = _.FindDef(interface_id); auto storage_class = interface_var->GetOperandAs(2); switch (storage_class) { case spv::StorageClass::PushConstant: { if (has_push_constant) { return _.diag(SPV_ERROR_INVALID_DATA, entry_point) << _.VkErrorID(6673) << "Entry-point has more than one variable with the " "PushConstant storage class in the interface"; } has_push_constant = true; break; } case spv::StorageClass::IncomingRayPayloadKHR: { if (has_ray_payload) { return _.diag(SPV_ERROR_INVALID_DATA, entry_point) << _.VkErrorID(4700) << "Entry-point has more than one variable with the " "IncomingRayPayloadKHR storage class in the interface"; } has_ray_payload = true; break; } case spv::StorageClass::HitAttributeKHR: { if (has_hit_attribute) { return _.diag(SPV_ERROR_INVALID_DATA, entry_point) << _.VkErrorID(4702) << "Entry-point has more than one variable with the " "HitAttributeKHR storage class in the interface"; } has_hit_attribute = true; break; } case spv::StorageClass::IncomingCallableDataKHR: { if (has_callable_data) { return _.diag(SPV_ERROR_INVALID_DATA, entry_point) << _.VkErrorID(4706) << "Entry-point has more than one variable with the " "IncomingCallableDataKHR storage class in the interface"; } has_callable_data = true; break; } default: break; } } return SPV_SUCCESS; } } // namespace spv_result_t ValidateInterfaces(ValidationState_t& _) { bool is_spv_1_4 = _.version() >= SPV_SPIRV_VERSION_WORD(1, 4); for (auto& inst : _.ordered_instructions()) { if (is_interface_variable(&inst, is_spv_1_4)) { if (auto error = check_interface_variable(_, &inst)) { return error; } } } if (spvIsVulkanEnv(_.context()->target_env)) { for (auto& inst : _.ordered_instructions()) { if (inst.opcode() == spv::Op::OpEntryPoint) { if (auto error = ValidateLocations(_, &inst)) { return error; } if (auto error = ValidateStorageClass(_, &inst)) { return error; } } if (inst.opcode() == spv::Op::OpTypeVoid) break; } } return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_layout.cpp000066400000000000000000000404351475742701700245130ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Source code for logical layout validation as described in section 2.4 #include "DebugInfo.h" #include "NonSemanticShaderDebugInfo100.h" #include "OpenCLDebugInfo100.h" #include "source/opcode.h" #include "source/operand.h" #include "source/val/function.h" #include "source/val/instruction.h" #include "source/val/validate.h" #include "source/val/validation_state.h" namespace spvtools { namespace val { namespace { // Module scoped instructions are processed by determining if the opcode // is part of the current layout section. If it is not then the next sections is // checked. spv_result_t ModuleScopedInstructions(ValidationState_t& _, const Instruction* inst, spv::Op opcode) { switch (opcode) { case spv::Op::OpExtInst: case spv::Op::OpExtInstWithForwardRefsKHR: if (spvExtInstIsDebugInfo(inst->ext_inst_type())) { const uint32_t ext_inst_index = inst->word(4); bool local_debug_info = false; if (inst->ext_inst_type() == SPV_EXT_INST_TYPE_OPENCL_DEBUGINFO_100) { const OpenCLDebugInfo100Instructions ext_inst_key = OpenCLDebugInfo100Instructions(ext_inst_index); if (ext_inst_key == OpenCLDebugInfo100DebugScope || ext_inst_key == OpenCLDebugInfo100DebugNoScope || ext_inst_key == OpenCLDebugInfo100DebugDeclare || ext_inst_key == OpenCLDebugInfo100DebugValue) { local_debug_info = true; } } else if (inst->ext_inst_type() == SPV_EXT_INST_TYPE_NONSEMANTIC_SHADER_DEBUGINFO_100) { const NonSemanticShaderDebugInfo100Instructions ext_inst_key = NonSemanticShaderDebugInfo100Instructions(ext_inst_index); if (ext_inst_key == NonSemanticShaderDebugInfo100DebugScope || ext_inst_key == NonSemanticShaderDebugInfo100DebugNoScope || ext_inst_key == NonSemanticShaderDebugInfo100DebugDeclare || ext_inst_key == NonSemanticShaderDebugInfo100DebugValue || ext_inst_key == NonSemanticShaderDebugInfo100DebugLine || ext_inst_key == NonSemanticShaderDebugInfo100DebugNoLine || ext_inst_key == NonSemanticShaderDebugInfo100DebugFunctionDefinition) { local_debug_info = true; } } else { const DebugInfoInstructions ext_inst_key = DebugInfoInstructions(ext_inst_index); if (ext_inst_key == DebugInfoDebugScope || ext_inst_key == DebugInfoDebugNoScope || ext_inst_key == DebugInfoDebugDeclare || ext_inst_key == DebugInfoDebugValue) { local_debug_info = true; } } if (local_debug_info) { if (_.in_function_body() == false) { // TODO - Print the actual name of the instruction as this list is // not complete (see ext_inst_name in ValidateExtInst() for example) return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) << "DebugScope, DebugNoScope, DebugDeclare, DebugValue " << "of debug info extension must appear in a function " << "body"; } } else { // Debug info extinst opcodes other than DebugScope, DebugNoScope, // DebugDeclare, DebugValue must be placed between section 9 (types, // constants, global variables) and section 10 (function // declarations). if (_.current_layout_section() < kLayoutTypes || _.current_layout_section() >= kLayoutFunctionDeclarations) { return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) << "Debug info extension instructions other than " << "DebugScope, DebugNoScope, DebugDeclare, DebugValue " << "must appear between section 9 (types, constants, " << "global variables) and section 10 (function " << "declarations)"; } } } else if (spvExtInstIsNonSemantic(inst->ext_inst_type())) { // non-semantic extinst opcodes are allowed beginning in the types // section, but since they must name a return type they cannot be the // first instruction in the types section. Therefore check that we are // already in it. if (_.current_layout_section() < kLayoutTypes) { return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) << "Non-semantic OpExtInst must not appear before types " << "section"; } } else { // otherwise they must be used in a block if (_.current_layout_section() < kLayoutFunctionDefinitions) { return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) << spvOpcodeString(opcode) << " must appear in a block"; } } break; default: break; } while (_.IsOpcodeInCurrentLayoutSection(opcode) == false) { if (_.IsOpcodeInPreviousLayoutSection(opcode)) { return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) << spvOpcodeString(opcode) << " is in an invalid layout section"; } _.ProgressToNextLayoutSectionOrder(); switch (_.current_layout_section()) { case kLayoutMemoryModel: if (opcode != spv::Op::OpMemoryModel) { return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) << spvOpcodeString(opcode) << " cannot appear before the memory model instruction"; } break; case kLayoutFunctionDeclarations: // All module sections have been processed. Recursively call // ModuleLayoutPass to process the next section of the module return ModuleLayoutPass(_, inst); default: break; } } return SPV_SUCCESS; } // Function declaration validation is performed by making sure that the // FunctionParameter and FunctionEnd instructions only appear inside of // functions. It also ensures that the Function instruction does not appear // inside of another function. This stage ends when the first label is // encountered inside of a function. spv_result_t FunctionScopedInstructions(ValidationState_t& _, const Instruction* inst, spv::Op opcode) { // Make sure we advance into the function definitions when we hit // non-function declaration instructions. if (_.current_layout_section() == kLayoutFunctionDeclarations && !_.IsOpcodeInCurrentLayoutSection(opcode)) { _.ProgressToNextLayoutSectionOrder(); if (_.in_function_body()) { if (auto error = _.current_function().RegisterSetFunctionDeclType( FunctionDecl::kFunctionDeclDefinition)) { return error; } } } if (_.IsOpcodeInCurrentLayoutSection(opcode)) { switch (opcode) { case spv::Op::OpFunction: { if (_.in_function_body()) { return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) << "Cannot declare a function in a function body"; } auto control_mask = inst->GetOperandAs(2); if (auto error = _.RegisterFunction(inst->id(), inst->type_id(), control_mask, inst->GetOperandAs(3))) return error; if (_.current_layout_section() == kLayoutFunctionDefinitions) { if (auto error = _.current_function().RegisterSetFunctionDeclType( FunctionDecl::kFunctionDeclDefinition)) return error; } } break; case spv::Op::OpFunctionParameter: if (_.in_function_body() == false) { return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) << "Function parameter instructions must be in a " "function body"; } if (_.current_function().block_count() != 0) { return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) << "Function parameters must only appear immediately after " "the function definition"; } if (auto error = _.current_function().RegisterFunctionParameter( inst->id(), inst->type_id())) return error; break; case spv::Op::OpFunctionEnd: if (_.in_function_body() == false) { return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) << "Function end instructions must be in a function body"; } if (_.in_block()) { return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) << "Function end cannot be called in blocks"; } if (_.current_function().block_count() == 0 && _.current_layout_section() == kLayoutFunctionDefinitions) { return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) << "Function declarations must appear before " "function definitions."; } if (_.current_layout_section() == kLayoutFunctionDeclarations) { if (auto error = _.current_function().RegisterSetFunctionDeclType( FunctionDecl::kFunctionDeclDeclaration)) return error; } if (auto error = _.RegisterFunctionEnd()) return error; break; case spv::Op::OpLine: case spv::Op::OpNoLine: break; case spv::Op::OpLabel: // If the label is encountered then the current function is a // definition so set the function to a declaration and update the // module section if (_.in_function_body() == false) { return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) << "Label instructions must be in a function body"; } if (_.in_block()) { return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) << "A block must end with a branch instruction."; } break; case spv::Op::OpExtInst: case spv::Op::OpExtInstWithForwardRefsKHR: if (spvExtInstIsDebugInfo(inst->ext_inst_type())) { const uint32_t ext_inst_index = inst->word(4); bool local_debug_info = false; if (inst->ext_inst_type() == SPV_EXT_INST_TYPE_OPENCL_DEBUGINFO_100) { const OpenCLDebugInfo100Instructions ext_inst_key = OpenCLDebugInfo100Instructions(ext_inst_index); if (ext_inst_key == OpenCLDebugInfo100DebugScope || ext_inst_key == OpenCLDebugInfo100DebugNoScope || ext_inst_key == OpenCLDebugInfo100DebugDeclare || ext_inst_key == OpenCLDebugInfo100DebugValue) { local_debug_info = true; } } else if (inst->ext_inst_type() == SPV_EXT_INST_TYPE_NONSEMANTIC_SHADER_DEBUGINFO_100) { const NonSemanticShaderDebugInfo100Instructions ext_inst_key = NonSemanticShaderDebugInfo100Instructions(ext_inst_index); if (ext_inst_key == NonSemanticShaderDebugInfo100DebugScope || ext_inst_key == NonSemanticShaderDebugInfo100DebugNoScope || ext_inst_key == NonSemanticShaderDebugInfo100DebugDeclare || ext_inst_key == NonSemanticShaderDebugInfo100DebugValue || ext_inst_key == NonSemanticShaderDebugInfo100DebugLine || ext_inst_key == NonSemanticShaderDebugInfo100DebugNoLine || ext_inst_key == NonSemanticShaderDebugInfo100DebugFunctionDefinition) { local_debug_info = true; } } else { const DebugInfoInstructions ext_inst_key = DebugInfoInstructions(ext_inst_index); if (ext_inst_key == DebugInfoDebugScope || ext_inst_key == DebugInfoDebugNoScope || ext_inst_key == DebugInfoDebugDeclare || ext_inst_key == DebugInfoDebugValue) { local_debug_info = true; } } if (local_debug_info) { if (_.in_function_body() == false) { // DebugScope, DebugNoScope, DebugDeclare, DebugValue must // appear in a function body. return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) << "DebugScope, DebugNoScope, DebugDeclare, DebugValue " << "of debug info extension must appear in a function " << "body"; } } else { // Debug info extinst opcodes other than DebugScope, DebugNoScope, // DebugDeclare, DebugValue must be placed between section 9 (types, // constants, global variables) and section 10 (function // declarations). if (_.current_layout_section() < kLayoutTypes || _.current_layout_section() >= kLayoutFunctionDeclarations) { return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) << "Debug info extension instructions other than " << "DebugScope, DebugNoScope, DebugDeclare, DebugValue " << "must appear between section 9 (types, constants, " << "global variables) and section 10 (function " << "declarations)"; } } } else if (spvExtInstIsNonSemantic(inst->ext_inst_type())) { // non-semantic extinst opcodes are allowed beginning in the types // section, but must either be placed outside a function declaration, // or inside a block. if (_.current_layout_section() < kLayoutTypes) { return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) << "Non-semantic OpExtInst must not appear before types " << "section"; } else if (_.in_function_body() && _.in_block() == false) { return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) << "Non-semantic OpExtInst within function definition must " "appear in a block"; } } else { // otherwise they must be used in a block if (_.in_block() == false) { return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) << spvOpcodeString(opcode) << " must appear in a block"; } } break; default: if (_.current_layout_section() == kLayoutFunctionDeclarations && _.in_function_body()) { return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) << "A function must begin with a label"; } else { if (_.in_block() == false) { return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) << spvOpcodeString(opcode) << " must appear in a block"; } } break; } } else { return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) << spvOpcodeString(opcode) << " cannot appear in a function declaration"; } return SPV_SUCCESS; } } // namespace // TODO(umar): Check linkage capabilities for function declarations // TODO(umar): Better error messages // NOTE: This function does not handle CFG related validation // Performs logical layout validation. See Section 2.4 spv_result_t ModuleLayoutPass(ValidationState_t& _, const Instruction* inst) { const spv::Op opcode = inst->opcode(); switch (_.current_layout_section()) { case kLayoutCapabilities: case kLayoutExtensions: case kLayoutExtInstImport: case kLayoutMemoryModel: case kLayoutSamplerImageAddressMode: case kLayoutEntryPoint: case kLayoutExecutionMode: case kLayoutDebug1: case kLayoutDebug2: case kLayoutDebug3: case kLayoutAnnotations: case kLayoutTypes: if (auto error = ModuleScopedInstructions(_, inst, opcode)) return error; break; case kLayoutFunctionDeclarations: case kLayoutFunctionDefinitions: if (auto error = FunctionScopedInstructions(_, inst, opcode)) { return error; } break; } return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_literals.cpp000066400000000000000000000061621475742701700250140ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validates literal numbers. #include #include "source/val/instruction.h" #include "source/val/validate.h" #include "source/val/validation_state.h" namespace spvtools { namespace val { namespace { // Returns true if the operand holds a literal number bool IsLiteralNumber(const spv_parsed_operand_t& operand) { switch (operand.number_kind) { case SPV_NUMBER_SIGNED_INT: case SPV_NUMBER_UNSIGNED_INT: case SPV_NUMBER_FLOATING: return true; default: return false; } } // Verifies that the upper bits of the given upper |word| with given // lower |width| are zero- or sign-extended when |signed_int| is true bool VerifyUpperBits(uint32_t word, uint32_t width, bool signed_int) { assert(width < 32); assert(0 < width); const uint32_t upper_mask = 0xFFFFFFFFu << width; const uint32_t upper_bits = word & upper_mask; bool result = false; if (signed_int) { const uint32_t sign_bit = word & (1u << (width - 1)); if (sign_bit) { result = upper_bits == upper_mask; } else { result = upper_bits == 0; } } else { result = upper_bits == 0; } return result; } } // namespace // Validates that literal numbers are represented according to the spec spv_result_t LiteralsPass(ValidationState_t& _, const Instruction* inst) { // For every operand that is a literal number for (size_t i = 0; i < inst->operands().size(); i++) { const spv_parsed_operand_t& operand = inst->operand(i); if (!IsLiteralNumber(operand)) continue; // The upper bits are always in the last word (little-endian) int last_index = operand.offset + operand.num_words - 1; const uint32_t upper_word = inst->word(last_index); // TODO(jcaraban): is the |word size| defined in some header? const uint32_t word_size = 32; uint32_t bit_width = operand.number_bit_width; // Bit widths that are a multiple of the word size have no upper bits const auto remaining_value_bits = bit_width % word_size; if (remaining_value_bits == 0) continue; const bool signedness = operand.number_kind == SPV_NUMBER_SIGNED_INT; if (!VerifyUpperBits(upper_word, remaining_value_bits, signedness)) { return _.diag(SPV_ERROR_INVALID_VALUE, inst) << "The high-order bits of a literal number in instruction " << inst->id() << " must be 0 for a floating-point type, " << "or 0 for an integer type with Signedness of 0, " << "or sign extended when Signedness is 1"; } } return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_logicals.cpp000066400000000000000000000257631475742701700250020ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validates correctness of logical SPIR-V instructions. #include "source/opcode.h" #include "source/val/instruction.h" #include "source/val/validate.h" #include "source/val/validation_state.h" namespace spvtools { namespace val { // Validates correctness of logical instructions. spv_result_t LogicalsPass(ValidationState_t& _, const Instruction* inst) { const spv::Op opcode = inst->opcode(); const uint32_t result_type = inst->type_id(); switch (opcode) { case spv::Op::OpAny: case spv::Op::OpAll: { if (!_.IsBoolScalarType(result_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected bool scalar type as Result Type: " << spvOpcodeString(opcode); const uint32_t vector_type = _.GetOperandTypeId(inst, 2); if (!vector_type || !_.IsBoolVectorType(vector_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected operand to be vector bool: " << spvOpcodeString(opcode); break; } case spv::Op::OpIsNan: case spv::Op::OpIsInf: case spv::Op::OpIsFinite: case spv::Op::OpIsNormal: case spv::Op::OpSignBitSet: { if (!_.IsBoolScalarType(result_type) && !_.IsBoolVectorType(result_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected bool scalar or vector type as Result Type: " << spvOpcodeString(opcode); const uint32_t operand_type = _.GetOperandTypeId(inst, 2); if (!operand_type || (!_.IsFloatScalarType(operand_type) && !_.IsFloatVectorType(operand_type))) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected operand to be scalar or vector float: " << spvOpcodeString(opcode); if (_.GetDimension(result_type) != _.GetDimension(operand_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected vector sizes of Result Type and the operand to be " "equal: " << spvOpcodeString(opcode); break; } case spv::Op::OpFOrdEqual: case spv::Op::OpFUnordEqual: case spv::Op::OpFOrdNotEqual: case spv::Op::OpFUnordNotEqual: case spv::Op::OpFOrdLessThan: case spv::Op::OpFUnordLessThan: case spv::Op::OpFOrdGreaterThan: case spv::Op::OpFUnordGreaterThan: case spv::Op::OpFOrdLessThanEqual: case spv::Op::OpFUnordLessThanEqual: case spv::Op::OpFOrdGreaterThanEqual: case spv::Op::OpFUnordGreaterThanEqual: case spv::Op::OpLessOrGreater: case spv::Op::OpOrdered: case spv::Op::OpUnordered: { if (!_.IsBoolScalarType(result_type) && !_.IsBoolVectorType(result_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected bool scalar or vector type as Result Type: " << spvOpcodeString(opcode); const uint32_t left_operand_type = _.GetOperandTypeId(inst, 2); if (!left_operand_type || (!_.IsFloatScalarType(left_operand_type) && !_.IsFloatVectorType(left_operand_type))) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected operands to be scalar or vector float: " << spvOpcodeString(opcode); if (_.GetDimension(result_type) != _.GetDimension(left_operand_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected vector sizes of Result Type and the operands to be " "equal: " << spvOpcodeString(opcode); if (left_operand_type != _.GetOperandTypeId(inst, 3)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected left and right operands to have the same type: " << spvOpcodeString(opcode); break; } case spv::Op::OpLogicalEqual: case spv::Op::OpLogicalNotEqual: case spv::Op::OpLogicalOr: case spv::Op::OpLogicalAnd: { if (!_.IsBoolScalarType(result_type) && !_.IsBoolVectorType(result_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected bool scalar or vector type as Result Type: " << spvOpcodeString(opcode); if (result_type != _.GetOperandTypeId(inst, 2) || result_type != _.GetOperandTypeId(inst, 3)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected both operands to be of Result Type: " << spvOpcodeString(opcode); break; } case spv::Op::OpLogicalNot: { if (!_.IsBoolScalarType(result_type) && !_.IsBoolVectorType(result_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected bool scalar or vector type as Result Type: " << spvOpcodeString(opcode); if (result_type != _.GetOperandTypeId(inst, 2)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected operand to be of Result Type: " << spvOpcodeString(opcode); break; } case spv::Op::OpSelect: { uint32_t dimension = 1; { const Instruction* type_inst = _.FindDef(result_type); assert(type_inst); const auto composites = _.features().select_between_composites; auto fail = [&_, composites, inst, opcode]() -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected scalar or " << (composites ? "composite" : "vector") << " type as Result Type: " << spvOpcodeString(opcode); }; const spv::Op type_opcode = type_inst->opcode(); switch (type_opcode) { case spv::Op::OpTypeUntypedPointerKHR: case spv::Op::OpTypePointer: { if (_.addressing_model() == spv::AddressingModel::Logical && !_.HasCapability( spv::Capability::VariablePointersStorageBuffer)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Using pointers with OpSelect requires capability " << "VariablePointers or VariablePointersStorageBuffer"; break; } case spv::Op::OpTypeSampledImage: case spv::Op::OpTypeImage: case spv::Op::OpTypeSampler: { if (!_.HasCapability(spv::Capability::BindlessTextureNV)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Using image/sampler with OpSelect requires capability " << "BindlessTextureNV"; break; } case spv::Op::OpTypeVector: { dimension = type_inst->word(3); break; } case spv::Op::OpTypeBool: case spv::Op::OpTypeInt: case spv::Op::OpTypeFloat: { break; } // Not RuntimeArray because of other rules. case spv::Op::OpTypeArray: case spv::Op::OpTypeMatrix: case spv::Op::OpTypeStruct: { if (!composites) return fail(); break; } default: return fail(); } const uint32_t condition_type = _.GetOperandTypeId(inst, 2); const uint32_t left_type = _.GetOperandTypeId(inst, 3); const uint32_t right_type = _.GetOperandTypeId(inst, 4); if (!condition_type || (!_.IsBoolScalarType(condition_type) && !_.IsBoolVectorType(condition_type))) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected bool scalar or vector type as condition: " << spvOpcodeString(opcode); if (_.GetDimension(condition_type) != dimension) { // If the condition is a vector type, then the result must also be a // vector with matching dimensions. In SPIR-V 1.4, a scalar condition // can be used to select between vector types. |composites| is a // proxy for SPIR-V 1.4 functionality. if (!composites || _.IsBoolVectorType(condition_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected vector sizes of Result Type and the condition " "to be equal: " << spvOpcodeString(opcode); } } if (result_type != left_type || result_type != right_type) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected both objects to be of Result Type: " << spvOpcodeString(opcode); break; } } case spv::Op::OpIEqual: case spv::Op::OpINotEqual: case spv::Op::OpUGreaterThan: case spv::Op::OpUGreaterThanEqual: case spv::Op::OpULessThan: case spv::Op::OpULessThanEqual: case spv::Op::OpSGreaterThan: case spv::Op::OpSGreaterThanEqual: case spv::Op::OpSLessThan: case spv::Op::OpSLessThanEqual: { if (!_.IsBoolScalarType(result_type) && !_.IsBoolVectorType(result_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected bool scalar or vector type as Result Type: " << spvOpcodeString(opcode); const uint32_t left_type = _.GetOperandTypeId(inst, 2); const uint32_t right_type = _.GetOperandTypeId(inst, 3); if (!left_type || (!_.IsIntScalarType(left_type) && !_.IsIntVectorType(left_type))) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected operands to be scalar or vector int: " << spvOpcodeString(opcode); if (_.GetDimension(result_type) != _.GetDimension(left_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected vector sizes of Result Type and the operands to be" << " equal: " << spvOpcodeString(opcode); if (!right_type || (!_.IsIntScalarType(right_type) && !_.IsIntVectorType(right_type))) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected operands to be scalar or vector int: " << spvOpcodeString(opcode); if (_.GetDimension(result_type) != _.GetDimension(right_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected vector sizes of Result Type and the operands to be" << " equal: " << spvOpcodeString(opcode); if (_.GetBitWidth(left_type) != _.GetBitWidth(right_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected both operands to have the same component bit " "width: " << spvOpcodeString(opcode); break; } default: break; } return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_memory.cpp000066400000000000000000003577201475742701700245160ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // Modifications Copyright (C) 2020-2024 Advanced Micro Devices, Inc. All // rights reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include "source/opcode.h" #include "source/spirv_target_env.h" #include "source/val/instruction.h" #include "source/val/validate.h" #include "source/val/validate_scopes.h" #include "source/val/validation_state.h" namespace spvtools { namespace val { namespace { bool AreLayoutCompatibleStructs(ValidationState_t&, const Instruction*, const Instruction*); bool HaveLayoutCompatibleMembers(ValidationState_t&, const Instruction*, const Instruction*); bool HaveSameLayoutDecorations(ValidationState_t&, const Instruction*, const Instruction*); bool HasConflictingMemberOffsets(const std::set&, const std::set&); bool IsAllowedTypeOrArrayOfSame(ValidationState_t& _, const Instruction* type, std::initializer_list allowed) { if (std::find(allowed.begin(), allowed.end(), type->opcode()) != allowed.end()) { return true; } if (type->opcode() == spv::Op::OpTypeArray || type->opcode() == spv::Op::OpTypeRuntimeArray) { auto elem_type = _.FindDef(type->word(2)); return std::find(allowed.begin(), allowed.end(), elem_type->opcode()) != allowed.end(); } return false; } // Returns true if the two instructions represent structs that, as far as the // validator can tell, have the exact same data layout. bool AreLayoutCompatibleStructs(ValidationState_t& _, const Instruction* type1, const Instruction* type2) { if (type1->opcode() != spv::Op::OpTypeStruct) { return false; } if (type2->opcode() != spv::Op::OpTypeStruct) { return false; } if (!HaveLayoutCompatibleMembers(_, type1, type2)) return false; return HaveSameLayoutDecorations(_, type1, type2); } // Returns true if the operands to the OpTypeStruct instruction defining the // types are the same or are layout compatible types. |type1| and |type2| must // be OpTypeStruct instructions. bool HaveLayoutCompatibleMembers(ValidationState_t& _, const Instruction* type1, const Instruction* type2) { assert(type1->opcode() == spv::Op::OpTypeStruct && "type1 must be an OpTypeStruct instruction."); assert(type2->opcode() == spv::Op::OpTypeStruct && "type2 must be an OpTypeStruct instruction."); const auto& type1_operands = type1->operands(); const auto& type2_operands = type2->operands(); if (type1_operands.size() != type2_operands.size()) { return false; } for (size_t operand = 2; operand < type1_operands.size(); ++operand) { if (type1->word(operand) != type2->word(operand)) { auto def1 = _.FindDef(type1->word(operand)); auto def2 = _.FindDef(type2->word(operand)); if (!AreLayoutCompatibleStructs(_, def1, def2)) { return false; } } } return true; } // Returns true if all decorations that affect the data layout of the struct // (like Offset), are the same for the two types. |type1| and |type2| must be // OpTypeStruct instructions. bool HaveSameLayoutDecorations(ValidationState_t& _, const Instruction* type1, const Instruction* type2) { assert(type1->opcode() == spv::Op::OpTypeStruct && "type1 must be an OpTypeStruct instruction."); assert(type2->opcode() == spv::Op::OpTypeStruct && "type2 must be an OpTypeStruct instruction."); const std::set& type1_decorations = _.id_decorations(type1->id()); const std::set& type2_decorations = _.id_decorations(type2->id()); // TODO: Will have to add other check for arrays an matricies if we want to // handle them. if (HasConflictingMemberOffsets(type1_decorations, type2_decorations)) { return false; } return true; } bool HasConflictingMemberOffsets( const std::set& type1_decorations, const std::set& type2_decorations) { { // We are interested in conflicting decoration. If a decoration is in one // list but not the other, then we will assume the code is correct. We are // looking for things we know to be wrong. // // We do not have to traverse type2_decoration because, after traversing // type1_decorations, anything new will not be found in // type1_decoration. Therefore, it cannot lead to a conflict. for (const Decoration& decoration : type1_decorations) { switch (decoration.dec_type()) { case spv::Decoration::Offset: { // Since these affect the layout of the struct, they must be present // in both structs. auto compare = [&decoration](const Decoration& rhs) { if (rhs.dec_type() != spv::Decoration::Offset) return false; return decoration.struct_member_index() == rhs.struct_member_index(); }; auto i = std::find_if(type2_decorations.begin(), type2_decorations.end(), compare); if (i != type2_decorations.end() && decoration.params().front() != i->params().front()) { return true; } } break; default: // This decoration does not affect the layout of the structure, so // just moving on. break; } } } return false; } // If |skip_builtin| is true, returns true if |storage| contains bool within // it and no storage that contains the bool is builtin. // If |skip_builtin| is false, returns true if |storage| contains bool within // it. bool ContainsInvalidBool(ValidationState_t& _, const Instruction* storage, bool skip_builtin) { if (skip_builtin) { for (const Decoration& decoration : _.id_decorations(storage->id())) { if (decoration.dec_type() == spv::Decoration::BuiltIn) return false; } } const size_t elem_type_index = 1; uint32_t elem_type_id; Instruction* elem_type; switch (storage->opcode()) { case spv::Op::OpTypeBool: return true; case spv::Op::OpTypeVector: case spv::Op::OpTypeMatrix: case spv::Op::OpTypeArray: case spv::Op::OpTypeRuntimeArray: elem_type_id = storage->GetOperandAs(elem_type_index); elem_type = _.FindDef(elem_type_id); return ContainsInvalidBool(_, elem_type, skip_builtin); case spv::Op::OpTypeStruct: for (size_t member_type_index = 1; member_type_index < storage->operands().size(); ++member_type_index) { auto member_type_id = storage->GetOperandAs(member_type_index); auto member_type = _.FindDef(member_type_id); if (ContainsInvalidBool(_, member_type, skip_builtin)) return true; } default: break; } return false; } std::pair GetStorageClass( ValidationState_t& _, const Instruction* inst) { spv::StorageClass dst_sc = spv::StorageClass::Max; spv::StorageClass src_sc = spv::StorageClass::Max; switch (inst->opcode()) { case spv::Op::OpCooperativeMatrixLoadNV: case spv::Op::OpCooperativeMatrixLoadTensorNV: case spv::Op::OpCooperativeMatrixLoadKHR: case spv::Op::OpCooperativeVectorLoadNV: case spv::Op::OpLoad: { auto load_pointer = _.FindDef(inst->GetOperandAs(2)); auto load_pointer_type = _.FindDef(load_pointer->type_id()); dst_sc = load_pointer_type->GetOperandAs(1); break; } case spv::Op::OpCooperativeMatrixStoreNV: case spv::Op::OpCooperativeMatrixStoreTensorNV: case spv::Op::OpCooperativeMatrixStoreKHR: case spv::Op::OpCooperativeVectorStoreNV: case spv::Op::OpStore: { auto store_pointer = _.FindDef(inst->GetOperandAs(0)); auto store_pointer_type = _.FindDef(store_pointer->type_id()); dst_sc = store_pointer_type->GetOperandAs(1); break; } case spv::Op::OpCopyMemory: case spv::Op::OpCopyMemorySized: { auto dst = _.FindDef(inst->GetOperandAs(0)); auto dst_type = _.FindDef(dst->type_id()); dst_sc = dst_type->GetOperandAs(1); auto src = _.FindDef(inst->GetOperandAs(1)); auto src_type = _.FindDef(src->type_id()); src_sc = src_type->GetOperandAs(1); break; } default: break; } return std::make_pair(dst_sc, src_sc); } // Returns the number of instruction words taken up by a memory access // argument and its implied operands. int MemoryAccessNumWords(uint32_t mask) { int result = 1; // Count the mask if (mask & uint32_t(spv::MemoryAccessMask::Aligned)) ++result; if (mask & uint32_t(spv::MemoryAccessMask::MakePointerAvailableKHR)) ++result; if (mask & uint32_t(spv::MemoryAccessMask::MakePointerVisibleKHR)) ++result; return result; } // Returns the scope ID operand for MakeAvailable memory access with mask // at the given operand index. // This function is only called for OpLoad, OpStore, OpCopyMemory and // OpCopyMemorySized, OpCooperativeMatrixLoadNV, // OpCooperativeMatrixStoreNV, OpCooperativeVectorLoadNV, // OpCooperativeVectorStoreNV. uint32_t GetMakeAvailableScope(const Instruction* inst, uint32_t mask, uint32_t mask_index) { assert(mask & uint32_t(spv::MemoryAccessMask::MakePointerAvailableKHR)); uint32_t this_bit = uint32_t(spv::MemoryAccessMask::MakePointerAvailableKHR); uint32_t index = mask_index - 1 + MemoryAccessNumWords(mask & (this_bit | (this_bit - 1))); return inst->GetOperandAs(index); } // This function is only called for OpLoad, OpStore, OpCopyMemory, // OpCopyMemorySized, OpCooperativeMatrixLoadNV, // OpCooperativeMatrixStoreNV, OpCooperativeVectorLoadNV, // OpCooperativeVectorStoreNV. uint32_t GetMakeVisibleScope(const Instruction* inst, uint32_t mask, uint32_t mask_index) { assert(mask & uint32_t(spv::MemoryAccessMask::MakePointerVisibleKHR)); uint32_t this_bit = uint32_t(spv::MemoryAccessMask::MakePointerVisibleKHR); uint32_t index = mask_index - 1 + MemoryAccessNumWords(mask & (this_bit | (this_bit - 1))); return inst->GetOperandAs(index); } bool DoesStructContainRTA(const ValidationState_t& _, const Instruction* inst) { for (size_t member_index = 1; member_index < inst->operands().size(); ++member_index) { const auto member_id = inst->GetOperandAs(member_index); const auto member_type = _.FindDef(member_id); if (member_type->opcode() == spv::Op::OpTypeRuntimeArray) return true; } return false; } spv_result_t CheckMemoryAccess(ValidationState_t& _, const Instruction* inst, uint32_t index) { spv::StorageClass dst_sc, src_sc; std::tie(dst_sc, src_sc) = GetStorageClass(_, inst); if (inst->operands().size() <= index) { // Cases where lack of some operand is invalid if (src_sc == spv::StorageClass::PhysicalStorageBuffer || dst_sc == spv::StorageClass::PhysicalStorageBuffer) { return _.diag(SPV_ERROR_INVALID_ID, inst) << _.VkErrorID(4708) << "Memory accesses with PhysicalStorageBuffer must use Aligned."; } return SPV_SUCCESS; } const uint32_t mask = inst->GetOperandAs(index); if (mask & uint32_t(spv::MemoryAccessMask::MakePointerAvailableKHR)) { if (inst->opcode() == spv::Op::OpLoad || inst->opcode() == spv::Op::OpCooperativeMatrixLoadNV || inst->opcode() == spv::Op::OpCooperativeMatrixLoadTensorNV || inst->opcode() == spv::Op::OpCooperativeMatrixLoadKHR || inst->opcode() == spv::Op::OpCooperativeVectorLoadNV) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "MakePointerAvailableKHR cannot be used with OpLoad."; } if (!(mask & uint32_t(spv::MemoryAccessMask::NonPrivatePointerKHR))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "NonPrivatePointerKHR must be specified if " "MakePointerAvailableKHR is specified."; } // Check the associated scope for MakeAvailableKHR. const auto available_scope = GetMakeAvailableScope(inst, mask, index); if (auto error = ValidateMemoryScope(_, inst, available_scope)) return error; } if (mask & uint32_t(spv::MemoryAccessMask::MakePointerVisibleKHR)) { if (inst->opcode() == spv::Op::OpStore || inst->opcode() == spv::Op::OpCooperativeMatrixStoreNV || inst->opcode() == spv::Op::OpCooperativeMatrixStoreKHR || inst->opcode() == spv::Op::OpCooperativeMatrixStoreTensorNV || inst->opcode() == spv::Op::OpCooperativeVectorStoreNV) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "MakePointerVisibleKHR cannot be used with OpStore."; } if (!(mask & uint32_t(spv::MemoryAccessMask::NonPrivatePointerKHR))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "NonPrivatePointerKHR must be specified if " << "MakePointerVisibleKHR is specified."; } // Check the associated scope for MakeVisibleKHR. const auto visible_scope = GetMakeVisibleScope(inst, mask, index); if (auto error = ValidateMemoryScope(_, inst, visible_scope)) return error; } if (mask & uint32_t(spv::MemoryAccessMask::NonPrivatePointerKHR)) { if (dst_sc != spv::StorageClass::Uniform && dst_sc != spv::StorageClass::Workgroup && dst_sc != spv::StorageClass::CrossWorkgroup && dst_sc != spv::StorageClass::Generic && dst_sc != spv::StorageClass::Image && dst_sc != spv::StorageClass::StorageBuffer && dst_sc != spv::StorageClass::PhysicalStorageBuffer) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "NonPrivatePointerKHR requires a pointer in Uniform, " << "Workgroup, CrossWorkgroup, Generic, Image or StorageBuffer " << "storage classes."; } if (src_sc != spv::StorageClass::Max && src_sc != spv::StorageClass::Uniform && src_sc != spv::StorageClass::Workgroup && src_sc != spv::StorageClass::CrossWorkgroup && src_sc != spv::StorageClass::Generic && src_sc != spv::StorageClass::Image && src_sc != spv::StorageClass::StorageBuffer && src_sc != spv::StorageClass::PhysicalStorageBuffer) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "NonPrivatePointerKHR requires a pointer in Uniform, " << "Workgroup, CrossWorkgroup, Generic, Image or StorageBuffer " << "storage classes."; } } if (!(mask & uint32_t(spv::MemoryAccessMask::Aligned))) { if (src_sc == spv::StorageClass::PhysicalStorageBuffer || dst_sc == spv::StorageClass::PhysicalStorageBuffer) { return _.diag(SPV_ERROR_INVALID_ID, inst) << _.VkErrorID(4708) << "Memory accesses with PhysicalStorageBuffer must use Aligned."; } } return SPV_SUCCESS; } spv_result_t ValidateVariable(ValidationState_t& _, const Instruction* inst) { const bool untyped_pointer = inst->opcode() == spv::Op::OpUntypedVariableKHR; auto result_type = _.FindDef(inst->type_id()); if (untyped_pointer) { if (!result_type || result_type->opcode() != spv::Op::OpTypeUntypedPointerKHR) return _.diag(SPV_ERROR_INVALID_ID, inst) << "Result type must be an untyped pointer"; } else { if (!result_type || result_type->opcode() != spv::Op::OpTypePointer) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpVariable Result Type " << _.getIdName(inst->type_id()) << " is not a pointer type."; } } const auto storage_class_index = 2u; auto storage_class = inst->GetOperandAs(storage_class_index); uint32_t value_id = 0; if (untyped_pointer) { const auto has_data_type = 3u < inst->operands().size(); if (has_data_type) { value_id = inst->GetOperandAs(3u); auto data_type = _.FindDef(value_id); if (!data_type || !spvOpcodeGeneratesType(data_type->opcode())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Data type must be a type instruction"; } } else { if (storage_class == spv::StorageClass::Function || storage_class == spv::StorageClass::Private || storage_class == spv::StorageClass::Workgroup) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Data type must be specified for Function, Private, and " "Workgroup storage classes"; } if (spvIsVulkanEnv(_.context()->target_env)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Vulkan requires that data type be specified"; } } } // For OpVariable the data type comes from pointee type of the result type, // while for OpUntypedVariableKHR the data type comes from the operand. if (!untyped_pointer) { value_id = result_type->GetOperandAs(2); } auto value_type = value_id == 0 ? nullptr : _.FindDef(value_id); const auto initializer_index = untyped_pointer ? 4u : 3u; if (initializer_index < inst->operands().size()) { const auto initializer_id = inst->GetOperandAs(initializer_index); const auto initializer = _.FindDef(initializer_id); const auto is_module_scope_var = initializer && (initializer->opcode() == spv::Op::OpVariable || initializer->opcode() == spv::Op::OpUntypedVariableKHR) && (initializer->GetOperandAs(storage_class_index) != spv::StorageClass::Function); const auto is_constant = initializer && spvOpcodeIsConstant(initializer->opcode()); if (!initializer || !(is_constant || is_module_scope_var)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Variable Initializer " << _.getIdName(initializer_id) << " is not a constant or module-scope variable."; } if (initializer->type_id() != value_id) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Initializer type must match the data type"; } } if (storage_class != spv::StorageClass::Workgroup && storage_class != spv::StorageClass::CrossWorkgroup && storage_class != spv::StorageClass::Private && storage_class != spv::StorageClass::Function && storage_class != spv::StorageClass::UniformConstant && storage_class != spv::StorageClass::RayPayloadKHR && storage_class != spv::StorageClass::IncomingRayPayloadKHR && storage_class != spv::StorageClass::HitAttributeKHR && storage_class != spv::StorageClass::CallableDataKHR && storage_class != spv::StorageClass::IncomingCallableDataKHR && storage_class != spv::StorageClass::TaskPayloadWorkgroupEXT && storage_class != spv::StorageClass::HitObjectAttributeNV && storage_class != spv::StorageClass::NodePayloadAMDX) { bool storage_input_or_output = storage_class == spv::StorageClass::Input || storage_class == spv::StorageClass::Output; bool builtin = false; if (storage_input_or_output) { for (const Decoration& decoration : _.id_decorations(inst->id())) { if (decoration.dec_type() == spv::Decoration::BuiltIn) { builtin = true; break; } } } if (!builtin && value_type && ContainsInvalidBool(_, value_type, storage_input_or_output)) { if (storage_input_or_output) { return _.diag(SPV_ERROR_INVALID_ID, inst) << _.VkErrorID(7290) << "If OpTypeBool is stored in conjunction with OpVariable " "using Input or Output Storage Classes it requires a BuiltIn " "decoration"; } else { return _.diag(SPV_ERROR_INVALID_ID, inst) << "If OpTypeBool is stored in conjunction with OpVariable, it " "can only be used with non-externally visible shader Storage " "Classes: Workgroup, CrossWorkgroup, Private, Function, " "Input, Output, RayPayloadKHR, IncomingRayPayloadKHR, " "HitAttributeKHR, CallableDataKHR, " "IncomingCallableDataKHR, NodePayloadAMDX, or " "UniformConstant"; } } } if (!_.IsValidStorageClass(storage_class)) { return _.diag(SPV_ERROR_INVALID_BINARY, inst) << _.VkErrorID(4643) << "Invalid storage class for target environment"; } if (storage_class == spv::StorageClass::Generic) { return _.diag(SPV_ERROR_INVALID_BINARY, inst) << "Variable storage class cannot be Generic"; } if (inst->function() && storage_class != spv::StorageClass::Function) { return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) << "Variables must have a function[7] storage class inside" " of a function"; } if (!inst->function() && storage_class == spv::StorageClass::Function) { return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) << "Variables can not have a function[7] storage class " "outside of a function"; } // SPIR-V 3.32.8: Check that pointer type and variable type have the same // storage class. const auto result_storage_class_index = 1; const auto result_storage_class = result_type->GetOperandAs(result_storage_class_index); if (storage_class != result_storage_class) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Storage class must match result type storage class"; } // Variable pointer related restrictions. const auto pointee = untyped_pointer ? value_id == 0 ? nullptr : _.FindDef(value_id) : _.FindDef(result_type->word(3)); if (_.addressing_model() == spv::AddressingModel::Logical && !_.options()->relax_logical_pointer) { // VariablePointersStorageBuffer is implied by VariablePointers. if (pointee && pointee->opcode() == spv::Op::OpTypePointer) { if (!_.HasCapability(spv::Capability::VariablePointersStorageBuffer)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "In Logical addressing, variables may not allocate a pointer " << "type"; } else if (storage_class != spv::StorageClass::Function && storage_class != spv::StorageClass::Private) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "In Logical addressing with variable pointers, variables " << "that allocate pointers must be in Function or Private " << "storage classes"; } } } if (spvIsVulkanEnv(_.context()->target_env)) { // Vulkan Push Constant Interface section: Check type of PushConstant // variables. if (storage_class == spv::StorageClass::PushConstant) { if (pointee && pointee->opcode() != spv::Op::OpTypeStruct) { return _.diag(SPV_ERROR_INVALID_ID, inst) << _.VkErrorID(6808) << "PushConstant OpVariable " << _.getIdName(inst->id()) << " has illegal type.\n" << "From Vulkan spec, Push Constant Interface section:\n" << "Such variables must be typed as OpTypeStruct"; } } // Vulkan Descriptor Set Interface: Check type of UniformConstant and // Uniform variables. if (storage_class == spv::StorageClass::UniformConstant) { if (pointee && !IsAllowedTypeOrArrayOfSame( _, pointee, {spv::Op::OpTypeImage, spv::Op::OpTypeSampler, spv::Op::OpTypeSampledImage, spv::Op::OpTypeAccelerationStructureKHR})) { return _.diag(SPV_ERROR_INVALID_ID, inst) << _.VkErrorID(4655) << "UniformConstant OpVariable " << _.getIdName(inst->id()) << " has illegal type.\n" << "Variables identified with the UniformConstant storage class " << "are used only as handles to refer to opaque resources. Such " << "variables must be typed as OpTypeImage, OpTypeSampler, " << "OpTypeSampledImage, OpTypeAccelerationStructureKHR, " << "or an array of one of these types."; } } if (storage_class == spv::StorageClass::Uniform) { if (pointee && !IsAllowedTypeOrArrayOfSame(_, pointee, {spv::Op::OpTypeStruct})) { return _.diag(SPV_ERROR_INVALID_ID, inst) << _.VkErrorID(6807) << "Uniform OpVariable " << _.getIdName(inst->id()) << " has illegal type.\n" << "From Vulkan spec:\n" << "Variables identified with the Uniform storage class are " << "used to access transparent buffer backed resources. Such " << "variables must be typed as OpTypeStruct, or an array of " << "this type"; } } if (storage_class == spv::StorageClass::StorageBuffer) { if (pointee && !IsAllowedTypeOrArrayOfSame(_, pointee, {spv::Op::OpTypeStruct})) { return _.diag(SPV_ERROR_INVALID_ID, inst) << _.VkErrorID(6807) << "StorageBuffer OpVariable " << _.getIdName(inst->id()) << " has illegal type.\n" << "From Vulkan spec:\n" << "Variables identified with the StorageBuffer storage class " "are used to access transparent buffer backed resources. " "Such variables must be typed as OpTypeStruct, or an array " "of this type"; } } // Check for invalid use of Invariant if (storage_class != spv::StorageClass::Input && storage_class != spv::StorageClass::Output) { if (_.HasDecoration(inst->id(), spv::Decoration::Invariant)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << _.VkErrorID(4677) << "Variable decorated with Invariant must only be identified " "with the Input or Output storage class in Vulkan " "environment."; } // Need to check if only the members in a struct are decorated if (value_type && value_type->opcode() == spv::Op::OpTypeStruct) { if (_.HasDecoration(value_id, spv::Decoration::Invariant)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << _.VkErrorID(4677) << "Variable struct member decorated with Invariant must only " "be identified with the Input or Output storage class in " "Vulkan environment."; } } } } // Vulkan Appendix A: Check that if contains initializer, then // storage class is Output, Private, or Function. if (inst->operands().size() > initializer_index && storage_class != spv::StorageClass::Output && storage_class != spv::StorageClass::Private && storage_class != spv::StorageClass::Function) { if (spvIsVulkanEnv(_.context()->target_env)) { if (storage_class == spv::StorageClass::Workgroup) { auto init_id = inst->GetOperandAs(initializer_index); auto init = _.FindDef(init_id); if (init->opcode() != spv::Op::OpConstantNull) { return _.diag(SPV_ERROR_INVALID_ID, inst) << _.VkErrorID(4734) << "OpVariable, " << _.getIdName(inst->id()) << ", initializers are limited to OpConstantNull in " "Workgroup " "storage class"; } } else if (storage_class != spv::StorageClass::Output && storage_class != spv::StorageClass::Private && storage_class != spv::StorageClass::Function) { return _.diag(SPV_ERROR_INVALID_ID, inst) << _.VkErrorID(4651) << "OpVariable, " << _.getIdName(inst->id()) << ", has a disallowed initializer & storage class " << "combination.\n" << "From " << spvLogStringForEnv(_.context()->target_env) << " spec:\n" << "Variable declarations that include initializers must have " << "one of the following storage classes: Output, Private, " << "Function or Workgroup"; } } } if (initializer_index < inst->operands().size()) { if (storage_class == spv::StorageClass::TaskPayloadWorkgroupEXT) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpVariable, " << _.getIdName(inst->id()) << ", initializer are not allowed for TaskPayloadWorkgroupEXT"; } if (storage_class == spv::StorageClass::Input) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpVariable, " << _.getIdName(inst->id()) << ", initializer are not allowed for Input"; } if (storage_class == spv::StorageClass::HitObjectAttributeNV) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpVariable, " << _.getIdName(inst->id()) << ", initializer are not allowed for HitObjectAttributeNV"; } } if (storage_class == spv::StorageClass::PhysicalStorageBuffer) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "PhysicalStorageBuffer must not be used with OpVariable."; } // Vulkan specific validation rules for OpTypeRuntimeArray if (spvIsVulkanEnv(_.context()->target_env)) { // OpTypeRuntimeArray should only ever be in a container like OpTypeStruct, // so should never appear as a bare variable. // Unless the module has the RuntimeDescriptorArrayEXT capability. if (value_type && value_type->opcode() == spv::Op::OpTypeRuntimeArray) { if (!_.HasCapability(spv::Capability::RuntimeDescriptorArrayEXT)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << _.VkErrorID(4680) << "OpVariable, " << _.getIdName(inst->id()) << ", is attempting to create memory for an illegal type, " << "OpTypeRuntimeArray.\nFor Vulkan OpTypeRuntimeArray can only " << "appear as the final member of an OpTypeStruct, thus cannot " << "be instantiated via OpVariable"; } else { // A bare variable OpTypeRuntimeArray is allowed in this context, but // still need to check the storage class. if (storage_class != spv::StorageClass::StorageBuffer && storage_class != spv::StorageClass::Uniform && storage_class != spv::StorageClass::UniformConstant) { return _.diag(SPV_ERROR_INVALID_ID, inst) << _.VkErrorID(4680) << "For Vulkan with RuntimeDescriptorArrayEXT, a variable " << "containing OpTypeRuntimeArray must have storage class of " << "StorageBuffer, Uniform, or UniformConstant."; } } } // If an OpStruct has an OpTypeRuntimeArray somewhere within it, then it // must either have the storage class StorageBuffer and be decorated // with Block, or it must be in the Uniform storage class and be decorated // as BufferBlock. if (value_type && value_type->opcode() == spv::Op::OpTypeStruct) { if (DoesStructContainRTA(_, value_type)) { if (storage_class == spv::StorageClass::StorageBuffer || storage_class == spv::StorageClass::PhysicalStorageBuffer) { if (!_.HasDecoration(value_id, spv::Decoration::Block)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << _.VkErrorID(4680) << "For Vulkan, an OpTypeStruct variable containing an " << "OpTypeRuntimeArray must be decorated with Block if it " << "has storage class StorageBuffer or " "PhysicalStorageBuffer."; } } else if (storage_class == spv::StorageClass::Uniform) { if (!_.HasDecoration(value_id, spv::Decoration::BufferBlock)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << _.VkErrorID(4680) << "For Vulkan, an OpTypeStruct variable containing an " << "OpTypeRuntimeArray must be decorated with BufferBlock " << "if it has storage class Uniform."; } } else { return _.diag(SPV_ERROR_INVALID_ID, inst) << _.VkErrorID(4680) << "For Vulkan, OpTypeStruct variables containing " << "OpTypeRuntimeArray must have storage class of " << "StorageBuffer, PhysicalStorageBuffer, or Uniform."; } } } } // Cooperative matrix types can only be allocated in Function or Private if ((storage_class != spv::StorageClass::Function && storage_class != spv::StorageClass::Private) && pointee && _.ContainsType(pointee->id(), [](const Instruction* type_inst) { auto opcode = type_inst->opcode(); return opcode == spv::Op::OpTypeCooperativeMatrixNV || opcode == spv::Op::OpTypeCooperativeMatrixKHR; })) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Cooperative matrix types (or types containing them) can only be " "allocated " << "in Function or Private storage classes or as function " "parameters"; } if ((storage_class != spv::StorageClass::Function && storage_class != spv::StorageClass::Private) && pointee && _.ContainsType(pointee->id(), [](const Instruction* type_inst) { auto opcode = type_inst->opcode(); return opcode == spv::Op::OpTypeCooperativeVectorNV; })) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Cooperative vector types (or types containing them) can only be " "allocated " << "in Function or Private storage classes or as function " "parameters"; } if (_.HasCapability(spv::Capability::Shader)) { // Don't allow variables containing 16-bit elements without the appropriate // capabilities. if ((!_.HasCapability(spv::Capability::Int16) && _.ContainsSizedIntOrFloatType(value_id, spv::Op::OpTypeInt, 16)) || (!_.HasCapability(spv::Capability::Float16) && _.ContainsSizedIntOrFloatType(value_id, spv::Op::OpTypeFloat, 16))) { auto underlying_type = value_type; while (underlying_type && underlying_type->opcode() == spv::Op::OpTypePointer) { storage_class = underlying_type->GetOperandAs(1u); underlying_type = _.FindDef(underlying_type->GetOperandAs(2u)); } bool storage_class_ok = true; std::string sc_name = _.grammar().lookupOperandName( SPV_OPERAND_TYPE_STORAGE_CLASS, uint32_t(storage_class)); switch (storage_class) { case spv::StorageClass::StorageBuffer: case spv::StorageClass::PhysicalStorageBuffer: if (!_.HasCapability(spv::Capability::StorageBuffer16BitAccess)) { storage_class_ok = false; } break; case spv::StorageClass::Uniform: if (underlying_type && !_.HasCapability( spv::Capability::UniformAndStorageBuffer16BitAccess)) { if (underlying_type->opcode() == spv::Op::OpTypeArray || underlying_type->opcode() == spv::Op::OpTypeRuntimeArray) { underlying_type = _.FindDef(underlying_type->GetOperandAs(1u)); } if (!_.HasCapability(spv::Capability::StorageBuffer16BitAccess) || !_.HasDecoration(underlying_type->id(), spv::Decoration::BufferBlock)) { storage_class_ok = false; } } break; case spv::StorageClass::PushConstant: if (!_.HasCapability(spv::Capability::StoragePushConstant16)) { storage_class_ok = false; } break; case spv::StorageClass::Input: case spv::StorageClass::Output: if (!_.HasCapability(spv::Capability::StorageInputOutput16)) { storage_class_ok = false; } break; case spv::StorageClass::Workgroup: if (!_.HasCapability( spv::Capability:: WorkgroupMemoryExplicitLayout16BitAccessKHR)) { storage_class_ok = false; } break; default: return _.diag(SPV_ERROR_INVALID_ID, inst) << "Cannot allocate a variable containing a 16-bit type in " << sc_name << " storage class"; } if (!storage_class_ok) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Allocating a variable containing a 16-bit element in " << sc_name << " storage class requires an additional capability"; } } // Don't allow variables containing 8-bit elements without the appropriate // capabilities. if (!_.HasCapability(spv::Capability::Int8) && _.ContainsSizedIntOrFloatType(value_id, spv::Op::OpTypeInt, 8)) { auto underlying_type = value_type; while (underlying_type && underlying_type->opcode() == spv::Op::OpTypePointer) { storage_class = underlying_type->GetOperandAs(1u); underlying_type = _.FindDef(underlying_type->GetOperandAs(2u)); } bool storage_class_ok = true; std::string sc_name = _.grammar().lookupOperandName( SPV_OPERAND_TYPE_STORAGE_CLASS, uint32_t(storage_class)); switch (storage_class) { case spv::StorageClass::StorageBuffer: case spv::StorageClass::PhysicalStorageBuffer: if (!_.HasCapability(spv::Capability::StorageBuffer8BitAccess)) { storage_class_ok = false; } break; case spv::StorageClass::Uniform: if (underlying_type && !_.HasCapability( spv::Capability::UniformAndStorageBuffer8BitAccess)) { if (underlying_type->opcode() == spv::Op::OpTypeArray || underlying_type->opcode() == spv::Op::OpTypeRuntimeArray) { underlying_type = _.FindDef(underlying_type->GetOperandAs(1u)); } if (!_.HasCapability(spv::Capability::StorageBuffer8BitAccess) || !_.HasDecoration(underlying_type->id(), spv::Decoration::BufferBlock)) { storage_class_ok = false; } } break; case spv::StorageClass::PushConstant: if (!_.HasCapability(spv::Capability::StoragePushConstant8)) { storage_class_ok = false; } break; case spv::StorageClass::Workgroup: if (!_.HasCapability( spv::Capability:: WorkgroupMemoryExplicitLayout8BitAccessKHR)) { storage_class_ok = false; } break; default: return _.diag(SPV_ERROR_INVALID_ID, inst) << "Cannot allocate a variable containing a 8-bit type in " << sc_name << " storage class"; } if (!storage_class_ok) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Allocating a variable containing a 8-bit element in " << sc_name << " storage class requires an additional capability"; } } } return SPV_SUCCESS; } spv_result_t ValidateLoad(ValidationState_t& _, const Instruction* inst) { const auto result_type = _.FindDef(inst->type_id()); if (!result_type) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpLoad Result Type " << _.getIdName(inst->type_id()) << " is not defined."; } const auto pointer_index = 2; const auto pointer_id = inst->GetOperandAs(pointer_index); const auto pointer = _.FindDef(pointer_id); if (!pointer || ((_.addressing_model() == spv::AddressingModel::Logical) && ((!_.features().variable_pointers && !spvOpcodeReturnsLogicalPointer(pointer->opcode())) || (_.features().variable_pointers && !spvOpcodeReturnsLogicalVariablePointer(pointer->opcode()))))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpLoad Pointer " << _.getIdName(pointer_id) << " is not a logical pointer."; } const auto pointer_type = _.FindDef(pointer->type_id()); if (!pointer_type || (pointer_type->opcode() != spv::Op::OpTypePointer && pointer_type->opcode() != spv::Op::OpTypeUntypedPointerKHR)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpLoad type for pointer " << _.getIdName(pointer_id) << " is not a pointer type."; } if (pointer_type->opcode() == spv::Op::OpTypePointer) { const auto pointee_type = _.FindDef(pointer_type->GetOperandAs(2)); if (!pointee_type || result_type->id() != pointee_type->id()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpLoad Result Type " << _.getIdName(inst->type_id()) << " does not match Pointer " << _.getIdName(pointer->id()) << "s type."; } } if (!_.options()->before_hlsl_legalization && _.ContainsRuntimeArray(inst->type_id())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Cannot load a runtime-sized array"; } if (auto error = CheckMemoryAccess(_, inst, 3)) return error; if (_.HasCapability(spv::Capability::Shader) && _.ContainsLimitedUseIntOrFloatType(inst->type_id()) && result_type->opcode() != spv::Op::OpTypePointer) { if (result_type->opcode() != spv::Op::OpTypeInt && result_type->opcode() != spv::Op::OpTypeFloat && result_type->opcode() != spv::Op::OpTypeVector && result_type->opcode() != spv::Op::OpTypeMatrix) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "8- or 16-bit loads must be a scalar, vector or matrix type"; } } _.RegisterQCOMImageProcessingTextureConsumer(pointer_id, inst, nullptr); return SPV_SUCCESS; } spv_result_t ValidateStore(ValidationState_t& _, const Instruction* inst) { const auto pointer_index = 0; const auto pointer_id = inst->GetOperandAs(pointer_index); const auto pointer = _.FindDef(pointer_id); if (!pointer || (_.addressing_model() == spv::AddressingModel::Logical && ((!_.features().variable_pointers && !spvOpcodeReturnsLogicalPointer(pointer->opcode())) || (_.features().variable_pointers && !spvOpcodeReturnsLogicalVariablePointer(pointer->opcode()))))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpStore Pointer " << _.getIdName(pointer_id) << " is not a logical pointer."; } const auto pointer_type = _.FindDef(pointer->type_id()); if (!pointer_type || (pointer_type->opcode() != spv::Op::OpTypePointer && pointer_type->opcode() != spv::Op::OpTypeUntypedPointerKHR)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpStore type for pointer " << _.getIdName(pointer_id) << " is not a pointer type."; } Instruction* type = nullptr; if (pointer_type->opcode() == spv::Op::OpTypePointer) { const auto type_id = pointer_type->GetOperandAs(2); type = _.FindDef(type_id); if (!type || spv::Op::OpTypeVoid == type->opcode()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpStore Pointer " << _.getIdName(pointer_id) << "s type is void."; } } // validate storage class { uint32_t data_type; spv::StorageClass storage_class; if (!_.GetPointerTypeInfo(pointer_type->id(), &data_type, &storage_class)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpStore Pointer " << _.getIdName(pointer_id) << " is not pointer type"; } if (storage_class == spv::StorageClass::UniformConstant || storage_class == spv::StorageClass::Input || storage_class == spv::StorageClass::PushConstant) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpStore Pointer " << _.getIdName(pointer_id) << " storage class is read-only"; } else if (storage_class == spv::StorageClass::ShaderRecordBufferKHR) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "ShaderRecordBufferKHR Storage Class variables are read only"; } else if (storage_class == spv::StorageClass::HitAttributeKHR) { std::string errorVUID = _.VkErrorID(4703); _.function(inst->function()->id()) ->RegisterExecutionModelLimitation( [errorVUID](spv::ExecutionModel model, std::string* message) { if (model == spv::ExecutionModel::AnyHitKHR || model == spv::ExecutionModel::ClosestHitKHR) { if (message) { *message = errorVUID + "HitAttributeKHR Storage Class variables are read only " "with AnyHitKHR and ClosestHitKHR"; } return false; } return true; }); } if (spvIsVulkanEnv(_.context()->target_env) && storage_class == spv::StorageClass::Uniform) { auto base_ptr = _.TracePointer(pointer); if (base_ptr->opcode() == spv::Op::OpVariable) { // If it's not a variable a different check should catch the problem. auto base_type = _.FindDef(base_ptr->GetOperandAs(0)); // Get the pointed-to type. base_type = _.FindDef(base_type->GetOperandAs(2u)); if (base_type->opcode() == spv::Op::OpTypeArray || base_type->opcode() == spv::Op::OpTypeRuntimeArray) { base_type = _.FindDef(base_type->GetOperandAs(1u)); } if (_.HasDecoration(base_type->id(), spv::Decoration::Block)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << _.VkErrorID(6925) << "In the Vulkan environment, cannot store to Uniform Blocks"; } } } } const auto object_index = 1; const auto object_id = inst->GetOperandAs(object_index); const auto object = _.FindDef(object_id); if (!object || !object->type_id()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpStore Object " << _.getIdName(object_id) << " is not an object."; } const auto object_type = _.FindDef(object->type_id()); if (!object_type || spv::Op::OpTypeVoid == object_type->opcode()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpStore Object " << _.getIdName(object_id) << "s type is void."; } if (type && (type->id() != object_type->id())) { if (!_.options()->relax_struct_store || type->opcode() != spv::Op::OpTypeStruct || object_type->opcode() != spv::Op::OpTypeStruct) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpStore Pointer " << _.getIdName(pointer_id) << "s type does not match Object " << _.getIdName(object->id()) << "s type."; } // TODO: Check for layout compatible matricies and arrays as well. if (!AreLayoutCompatibleStructs(_, type, object_type)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpStore Pointer " << _.getIdName(pointer_id) << "s layout does not match Object " << _.getIdName(object->id()) << "s layout."; } } if (auto error = CheckMemoryAccess(_, inst, 2)) return error; if (_.HasCapability(spv::Capability::Shader) && _.ContainsLimitedUseIntOrFloatType(inst->type_id()) && object_type->opcode() != spv::Op::OpTypePointer) { if (object_type->opcode() != spv::Op::OpTypeInt && object_type->opcode() != spv::Op::OpTypeFloat && object_type->opcode() != spv::Op::OpTypeVector && object_type->opcode() != spv::Op::OpTypeMatrix) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "8- or 16-bit stores must be a scalar, vector or matrix type"; } } if (spvIsVulkanEnv(_.context()->target_env) && !_.options()->before_hlsl_legalization) { const auto isForbiddenType = [](const Instruction* type_inst) { auto opcode = type_inst->opcode(); return opcode == spv::Op::OpTypeImage || opcode == spv::Op::OpTypeSampler || opcode == spv::Op::OpTypeSampledImage || opcode == spv::Op::OpTypeAccelerationStructureKHR; }; if (_.ContainsType(object_type->id(), isForbiddenType)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << _.VkErrorID(6924) << "Cannot store to OpTypeImage, OpTypeSampler, " "OpTypeSampledImage, or OpTypeAccelerationStructureKHR objects"; } } return SPV_SUCCESS; } spv_result_t ValidateCopyMemoryMemoryAccess(ValidationState_t& _, const Instruction* inst) { assert(inst->opcode() == spv::Op::OpCopyMemory || inst->opcode() == spv::Op::OpCopyMemorySized); const uint32_t first_access_index = inst->opcode() == spv::Op::OpCopyMemory ? 2 : 3; if (inst->operands().size() > first_access_index) { if (auto error = CheckMemoryAccess(_, inst, first_access_index)) return error; const auto first_access = inst->GetOperandAs(first_access_index); const uint32_t second_access_index = first_access_index + MemoryAccessNumWords(first_access); if (inst->operands().size() > second_access_index) { if (_.features().copy_memory_permits_two_memory_accesses) { if (auto error = CheckMemoryAccess(_, inst, second_access_index)) return error; // In the two-access form in SPIR-V 1.4 and later: // - the first is the target (write) access and it can't have // make-visible. // - the second is the source (read) access and it can't have // make-available. if (first_access & uint32_t(spv::MemoryAccessMask::MakePointerVisibleKHR)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Target memory access must not include " "MakePointerVisibleKHR"; } const auto second_access = inst->GetOperandAs(second_access_index); if (second_access & uint32_t(spv::MemoryAccessMask::MakePointerAvailableKHR)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Source memory access must not include " "MakePointerAvailableKHR"; } } else { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(static_cast(inst->opcode())) << " with two memory access operands requires SPIR-V 1.4 or " "later"; } } } return SPV_SUCCESS; } spv_result_t ValidateCopyMemory(ValidationState_t& _, const Instruction* inst) { const auto target_index = 0; const auto target_id = inst->GetOperandAs(target_index); const auto target = _.FindDef(target_id); if (!target) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Target operand " << _.getIdName(target_id) << " is not defined."; } const auto source_index = 1; const auto source_id = inst->GetOperandAs(source_index); const auto source = _.FindDef(source_id); if (!source) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Source operand " << _.getIdName(source_id) << " is not defined."; } const auto target_pointer_type = _.FindDef(target->type_id()); if (!target_pointer_type || (target_pointer_type->opcode() != spv::Op::OpTypePointer && target_pointer_type->opcode() != spv::Op::OpTypeUntypedPointerKHR)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Target operand " << _.getIdName(target_id) << " is not a pointer."; } const auto source_pointer_type = _.FindDef(source->type_id()); if (!source_pointer_type || (source_pointer_type->opcode() != spv::Op::OpTypePointer && source_pointer_type->opcode() != spv::Op::OpTypeUntypedPointerKHR)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Source operand " << _.getIdName(source_id) << " is not a pointer."; } if (inst->opcode() == spv::Op::OpCopyMemory) { const bool target_typed = target_pointer_type->opcode() == spv::Op::OpTypePointer; const bool source_typed = source_pointer_type->opcode() == spv::Op::OpTypePointer; Instruction* target_type = nullptr; Instruction* source_type = nullptr; if (target_typed) { target_type = _.FindDef(target_pointer_type->GetOperandAs(2)); if (!target_type || target_type->opcode() == spv::Op::OpTypeVoid) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Target operand " << _.getIdName(target_id) << " cannot be a void pointer."; } } if (source_typed) { source_type = _.FindDef(source_pointer_type->GetOperandAs(2)); if (!source_type || source_type->opcode() == spv::Op::OpTypeVoid) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Source operand " << _.getIdName(source_id) << " cannot be a void pointer."; } } if (target_type && source_type && target_type->id() != source_type->id()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Target " << _.getIdName(source_id) << "s type does not match Source " << _.getIdName(source_type->id()) << "s type."; } if (!target_type && !source_type) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "One of Source or Target must be a typed pointer"; } if (auto error = CheckMemoryAccess(_, inst, 2)) return error; } else { const auto size_id = inst->GetOperandAs(2); const auto size = _.FindDef(size_id); if (!size) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Size operand " << _.getIdName(size_id) << " is not defined."; } const auto size_type = _.FindDef(size->type_id()); if (!_.IsIntScalarType(size_type->id())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Size operand " << _.getIdName(size_id) << " must be a scalar integer type."; } bool is_zero = true; switch (size->opcode()) { case spv::Op::OpConstantNull: return _.diag(SPV_ERROR_INVALID_ID, inst) << "Size operand " << _.getIdName(size_id) << " cannot be a constant zero."; case spv::Op::OpConstant: if (size_type->word(3) == 1 && size->word(size->words().size() - 1) & 0x80000000) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Size operand " << _.getIdName(size_id) << " cannot have the sign bit set to 1."; } for (size_t i = 3; is_zero && i < size->words().size(); ++i) { is_zero &= (size->word(i) == 0); } if (is_zero) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Size operand " << _.getIdName(size_id) << " cannot be a constant zero."; } break; default: // Cannot infer any other opcodes. break; } if (_.HasCapability(spv::Capability::Shader)) { bool is_int = false; bool is_const = false; uint32_t value = 0; std::tie(is_int, is_const, value) = _.EvalInt32IfConst(size_id); if (is_const) { if (value % 4 != 0) { const auto source_sc = source_pointer_type->GetOperandAs(1); const auto target_sc = target_pointer_type->GetOperandAs(1); const bool int8 = _.HasCapability(spv::Capability::Int8); const bool ubo_int8 = _.HasCapability( spv::Capability::UniformAndStorageBuffer8BitAccess); const bool ssbo_int8 = _.HasCapability(spv::Capability::StorageBuffer8BitAccess) || ubo_int8; const bool pc_int8 = _.HasCapability(spv::Capability::StoragePushConstant8); const bool wg_int8 = _.HasCapability( spv::Capability::WorkgroupMemoryExplicitLayout8BitAccessKHR); const bool int16 = _.HasCapability(spv::Capability::Int16) || int8; const bool ubo_int16 = _.HasCapability( spv::Capability::UniformAndStorageBuffer16BitAccess) || ubo_int8; const bool ssbo_int16 = _.HasCapability(spv::Capability::StorageBuffer16BitAccess) || ubo_int16 || ssbo_int8; const bool pc_int16 = _.HasCapability(spv::Capability::StoragePushConstant16) || pc_int8; const bool io_int16 = _.HasCapability(spv::Capability::StorageInputOutput16); const bool wg_int16 = _.HasCapability( spv::Capability::WorkgroupMemoryExplicitLayout16BitAccessKHR); bool source_int16_match = false; bool target_int16_match = false; bool source_int8_match = false; bool target_int8_match = false; switch (source_sc) { case spv::StorageClass::StorageBuffer: source_int16_match = ssbo_int16; source_int8_match = ssbo_int8; break; case spv::StorageClass::Uniform: source_int16_match = ubo_int16; source_int8_match = ubo_int8; break; case spv::StorageClass::PushConstant: source_int16_match = pc_int16; source_int8_match = pc_int8; break; case spv::StorageClass::Input: case spv::StorageClass::Output: source_int16_match = io_int16; break; case spv::StorageClass::Workgroup: source_int16_match = wg_int16; source_int8_match = wg_int8; break; default: break; } switch (target_sc) { case spv::StorageClass::StorageBuffer: target_int16_match = ssbo_int16; target_int8_match = ssbo_int8; break; case spv::StorageClass::Uniform: target_int16_match = ubo_int16; target_int8_match = ubo_int8; break; case spv::StorageClass::PushConstant: target_int16_match = pc_int16; target_int8_match = pc_int8; break; // Input is read-only so it cannot be the target pointer. case spv::StorageClass::Output: target_int16_match = io_int16; break; case spv::StorageClass::Workgroup: target_int16_match = wg_int16; target_int8_match = wg_int8; break; default: break; } if (!int8 && !int16 && !(source_int16_match && target_int16_match)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Size must be a multiple of 4"; } if (value % 2 != 0) { if (!int8 && !(source_int8_match && target_int8_match)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Size must be a multiple of 2"; } } } } } if (auto error = CheckMemoryAccess(_, inst, 3)) return error; } if (auto error = ValidateCopyMemoryMemoryAccess(_, inst)) return error; // Get past the pointers to avoid checking a pointer copy. if (target_pointer_type->opcode() == spv::Op::OpTypePointer) { auto sub_type = _.FindDef(target_pointer_type->GetOperandAs(2)); while (sub_type->opcode() == spv::Op::OpTypePointer) { sub_type = _.FindDef(sub_type->GetOperandAs(2)); } if (_.HasCapability(spv::Capability::Shader) && _.ContainsLimitedUseIntOrFloatType(sub_type->id())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Cannot copy memory of objects containing 8- or 16-bit types"; } } return SPV_SUCCESS; } spv_result_t ValidateAccessChain(ValidationState_t& _, const Instruction* inst) { std::string instr_name = "Op" + std::string(spvOpcodeString(static_cast(inst->opcode()))); const bool untyped_pointer = spvOpcodeGeneratesUntypedPointer(inst->opcode()); // The result type must be OpTypePointer for regular access chains and an // OpTypeUntypedPointerKHR for untyped access chains. auto result_type = _.FindDef(inst->type_id()); if (untyped_pointer) { if (!result_type || spv::Op::OpTypeUntypedPointerKHR != result_type->opcode()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "The Result Type of " << instr_name << " " << _.getIdName(inst->id()) << " must be OpTypeUntypedPointerKHR. Found Op" << spvOpcodeString(static_cast(result_type->opcode())) << "."; } } else { if (!result_type || spv::Op::OpTypePointer != result_type->opcode()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "The Result Type of " << instr_name << " " << _.getIdName(inst->id()) << " must be OpTypePointer. Found Op" << spvOpcodeString(static_cast(result_type->opcode())) << "."; } } if (untyped_pointer) { // Base type must be a non-pointer type. const auto base_type = _.FindDef(inst->GetOperandAs(2)); if (!base_type || !spvOpcodeGeneratesType(base_type->opcode()) || base_type->opcode() == spv::Op::OpTypePointer || base_type->opcode() == spv::Op::OpTypeUntypedPointerKHR) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Base type must be a non-pointer type"; } } // Base must be a pointer, pointing to the base of a composite object. const auto base_index = untyped_pointer ? 3 : 2; const auto base_id = inst->GetOperandAs(base_index); const auto base = _.FindDef(base_id); const auto base_type = _.FindDef(base->type_id()); if (!base_type || !(spv::Op::OpTypePointer == base_type->opcode() || (untyped_pointer && spv::Op::OpTypeUntypedPointerKHR == base_type->opcode()))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "The Base " << _.getIdName(base_id) << " in " << instr_name << " instruction must be a pointer."; } // The result pointer storage class and base pointer storage class must match. // Word 2 of OpTypePointer is the Storage Class. auto result_type_storage_class = result_type->word(2); auto base_type_storage_class = base_type->word(2); if (result_type_storage_class != base_type_storage_class) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "The result pointer storage class and base " "pointer storage class in " << instr_name << " do not match."; } // The type pointed to by OpTypePointer (word 3) must be a composite type. auto type_pointee = untyped_pointer ? _.FindDef(inst->GetOperandAs(2)) : _.FindDef(base_type->word(3)); // Check Universal Limit (SPIR-V Spec. Section 2.17). // The number of indexes passed to OpAccessChain may not exceed 255 // The instruction includes 4 words + N words (for N indexes) size_t num_indexes = inst->words().size() - 4; if (inst->opcode() == spv::Op::OpPtrAccessChain || inst->opcode() == spv::Op::OpInBoundsPtrAccessChain || inst->opcode() == spv::Op::OpUntypedPtrAccessChainKHR || inst->opcode() == spv::Op::OpUntypedInBoundsPtrAccessChainKHR) { // In pointer access chains, the element operand is required, but not // counted as an index. --num_indexes; } const size_t num_indexes_limit = _.options()->universal_limits_.max_access_chain_indexes; if (num_indexes > num_indexes_limit) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "The number of indexes in " << instr_name << " may not exceed " << num_indexes_limit << ". Found " << num_indexes << " indexes."; } // Indexes walk the type hierarchy to the desired depth, potentially down to // scalar granularity. The first index in Indexes will select the top-level // member/element/component/element of the base composite. All composite // constituents use zero-based numbering, as described by their OpType... // instruction. The second index will apply similarly to that result, and so // on. Once any non-composite type is reached, there must be no remaining // (unused) indexes. auto starting_index = untyped_pointer ? 5 : 4; if (inst->opcode() == spv::Op::OpPtrAccessChain || inst->opcode() == spv::Op::OpInBoundsPtrAccessChain || inst->opcode() == spv::Op::OpUntypedPtrAccessChainKHR || inst->opcode() == spv::Op::OpUntypedInBoundsPtrAccessChainKHR) { ++starting_index; } for (size_t i = starting_index; i < inst->words().size(); ++i) { const uint32_t cur_word = inst->words()[i]; // Earlier ID checks ensure that cur_word definition exists. auto cur_word_instr = _.FindDef(cur_word); // The index must be a scalar integer type (See OpAccessChain in the Spec.) auto index_type = _.FindDef(cur_word_instr->type_id()); if (!index_type || spv::Op::OpTypeInt != index_type->opcode()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Indexes passed to " << instr_name << " must be of type integer."; } switch (type_pointee->opcode()) { case spv::Op::OpTypeMatrix: case spv::Op::OpTypeVector: case spv::Op::OpTypeCooperativeVectorNV: case spv::Op::OpTypeCooperativeMatrixNV: case spv::Op::OpTypeCooperativeMatrixKHR: case spv::Op::OpTypeArray: case spv::Op::OpTypeRuntimeArray: case spv::Op::OpTypeNodePayloadArrayAMDX: { // In OpTypeMatrix, OpTypeVector, spv::Op::OpTypeCooperativeMatrixNV, // OpTypeCooperativeVectorNV, OpTypeArray, and OpTypeRuntimeArray, word // 2 is the Element Type. type_pointee = _.FindDef(type_pointee->word(2)); break; } case spv::Op::OpTypeStruct: { // In case of structures, there is an additional constraint on the // index: the index must be an OpConstant. int64_t cur_index; if (!_.EvalConstantValInt64(cur_word, &cur_index)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "The passed to " << instr_name << " to index " << _.getIdName(cur_word) << " into a " "structure must be an OpConstant."; } // The index points to the struct member we want, therefore, the index // should be less than the number of struct members. const int64_t num_struct_members = static_cast(type_pointee->words().size() - 2); if (cur_index >= num_struct_members || cur_index < 0) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Index " << _.getIdName(cur_word) << " is out of bounds: " << instr_name << " cannot find index " << cur_index << " into the structure " << _.getIdName(type_pointee->id()) << ". This structure has " << num_struct_members << " members. Largest valid index is " << num_struct_members - 1 << "."; } // Struct members IDs start at word 2 of OpTypeStruct. const size_t word_index = static_cast(cur_index) + 2; auto structMemberId = type_pointee->word(word_index); type_pointee = _.FindDef(structMemberId); break; } default: { // Give an error. reached non-composite type while indexes still remain. return _.diag(SPV_ERROR_INVALID_ID, inst) << instr_name << " reached non-composite type while indexes " "still remain to be traversed."; } } } if (!untyped_pointer) { // Result type is a pointer. Find out what it's pointing to. // This will be used to make sure the indexing results in the same type. // OpTypePointer word 3 is the type being pointed to. const auto result_type_pointee = _.FindDef(result_type->word(3)); // At this point, we have fully walked down from the base using the indeces. // The type being pointed to should be the same as the result type. if (type_pointee->id() != result_type_pointee->id()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << instr_name << " result type (Op" << spvOpcodeString( static_cast(result_type_pointee->opcode())) << ") does not match the type that results from indexing into the " "base " " (Op" << spvOpcodeString(static_cast(type_pointee->opcode())) << ")."; } } return SPV_SUCCESS; } spv_result_t ValidateRawAccessChain(ValidationState_t& _, const Instruction* inst) { std::string instr_name = "Op" + std::string(spvOpcodeString(inst->opcode())); // The result type must be OpTypePointer. const auto result_type = _.FindDef(inst->type_id()); if (spv::Op::OpTypePointer != result_type->opcode()) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "The Result Type of " << instr_name << " " << _.getIdName(inst->id()) << " must be OpTypePointer. Found Op" << spvOpcodeString(result_type->opcode()) << '.'; } // The pointed storage class must be valid. const auto storage_class = result_type->GetOperandAs(1); if (storage_class != spv::StorageClass::StorageBuffer && storage_class != spv::StorageClass::PhysicalStorageBuffer && storage_class != spv::StorageClass::Uniform) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "The Result Type of " << instr_name << " " << _.getIdName(inst->id()) << " must point to a storage class of " "StorageBuffer, PhysicalStorageBuffer, or Uniform."; } // The pointed type must not be one in the list below. const auto result_type_pointee = _.FindDef(result_type->GetOperandAs(2)); if (result_type_pointee->opcode() == spv::Op::OpTypeArray || result_type_pointee->opcode() == spv::Op::OpTypeMatrix || result_type_pointee->opcode() == spv::Op::OpTypeStruct) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "The Result Type of " << instr_name << " " << _.getIdName(inst->id()) << " must not point to " "OpTypeArray, OpTypeMatrix, or OpTypeStruct."; } // Validate Stride is a OpConstant. const auto stride = _.FindDef(inst->GetOperandAs(3)); if (stride->opcode() != spv::Op::OpConstant) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "The Stride of " << instr_name << " " << _.getIdName(inst->id()) << " must be OpConstant. Found Op" << spvOpcodeString(stride->opcode()) << '.'; } // Stride type must be OpTypeInt const auto stride_type = _.FindDef(stride->type_id()); if (stride_type->opcode() != spv::Op::OpTypeInt) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "The type of Stride of " << instr_name << " " << _.getIdName(inst->id()) << " must be OpTypeInt. Found Op" << spvOpcodeString(stride_type->opcode()) << '.'; } // Index and Offset type must be OpTypeInt with a width of 32 const auto ValidateType = [&](const char* name, int operandIndex) -> spv_result_t { const auto value = _.FindDef(inst->GetOperandAs(operandIndex)); const auto value_type = _.FindDef(value->type_id()); if (value_type->opcode() != spv::Op::OpTypeInt) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "The type of " << name << " of " << instr_name << " " << _.getIdName(inst->id()) << " must be OpTypeInt. Found Op" << spvOpcodeString(value_type->opcode()) << '.'; } const auto width = value_type->GetOperandAs(1); if (width != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "The integer width of " << name << " of " << instr_name << " " << _.getIdName(inst->id()) << " must be 32. Found " << width << '.'; } return SPV_SUCCESS; }; spv_result_t result; result = ValidateType("Index", 4); if (result != SPV_SUCCESS) { return result; } result = ValidateType("Offset", 5); if (result != SPV_SUCCESS) { return result; } uint32_t access_operands = 0; if (inst->operands().size() >= 7) { access_operands = inst->GetOperandAs(6); } if (access_operands & uint32_t(spv::RawAccessChainOperandsMask::RobustnessPerElementNV)) { uint64_t stride_value = 0; if (_.EvalConstantValUint64(stride->id(), &stride_value) && stride_value == 0) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Stride must not be zero when per-element robustness is used."; } } if (access_operands & uint32_t(spv::RawAccessChainOperandsMask::RobustnessPerComponentNV) || access_operands & uint32_t(spv::RawAccessChainOperandsMask::RobustnessPerElementNV)) { if (storage_class == spv::StorageClass::PhysicalStorageBuffer) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Storage class cannot be PhysicalStorageBuffer when " "raw access chain robustness is used."; } } if (access_operands & uint32_t(spv::RawAccessChainOperandsMask::RobustnessPerComponentNV) && access_operands & uint32_t(spv::RawAccessChainOperandsMask::RobustnessPerElementNV)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Per-component robustness and per-element robustness are " "mutually exclusive."; } return SPV_SUCCESS; } spv_result_t ValidatePtrAccessChain(ValidationState_t& _, const Instruction* inst) { if (_.addressing_model() == spv::AddressingModel::Logical && inst->opcode() == spv::Op::OpPtrAccessChain) { if (!_.features().variable_pointers) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Generating variable pointers requires capability " << "VariablePointers or VariablePointersStorageBuffer"; } } // Need to call first, will make sure Base is a valid ID if (auto error = ValidateAccessChain(_, inst)) return error; const bool untyped_pointer = spvOpcodeGeneratesUntypedPointer(inst->opcode()); const auto base_id = inst->GetOperandAs(2); const auto base = _.FindDef(base_id); const auto base_type = untyped_pointer ? _.FindDef(inst->GetOperandAs(2)) : _.FindDef(base->type_id()); const auto base_type_storage_class = base_type->GetOperandAs(1); if (_.HasCapability(spv::Capability::Shader) && (base_type_storage_class == spv::StorageClass::Uniform || base_type_storage_class == spv::StorageClass::StorageBuffer || base_type_storage_class == spv::StorageClass::PhysicalStorageBuffer || base_type_storage_class == spv::StorageClass::PushConstant || (_.HasCapability(spv::Capability::WorkgroupMemoryExplicitLayoutKHR) && base_type_storage_class == spv::StorageClass::Workgroup)) && !_.HasDecoration(base_type->id(), spv::Decoration::ArrayStride)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "OpPtrAccessChain must have a Base whose type is decorated " "with ArrayStride"; } if (spvIsVulkanEnv(_.context()->target_env)) { const auto untyped_cap = untyped_pointer && _.HasCapability(spv::Capability::UntypedPointersKHR); if (base_type_storage_class == spv::StorageClass::Workgroup) { if (!_.HasCapability(spv::Capability::VariablePointers) && !untyped_cap) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(7651) << "OpPtrAccessChain Base operand pointing to Workgroup " "storage class must use VariablePointers capability"; } } else if (base_type_storage_class == spv::StorageClass::StorageBuffer) { if (!_.features().variable_pointers && !untyped_cap) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(7652) << "OpPtrAccessChain Base operand pointing to StorageBuffer " "storage class must use VariablePointers or " "VariablePointersStorageBuffer capability"; } } else if (base_type_storage_class != spv::StorageClass::PhysicalStorageBuffer && !untyped_cap) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(7650) << "OpPtrAccessChain Base operand must point to Workgroup, " "StorageBuffer, or PhysicalStorageBuffer storage class"; } } return SPV_SUCCESS; } spv_result_t ValidateArrayLength(ValidationState_t& state, const Instruction* inst) { std::string instr_name = "Op" + std::string(spvOpcodeString(static_cast(inst->opcode()))); // Result type must be a 32-bit unsigned int. auto result_type = state.FindDef(inst->type_id()); if (result_type->opcode() != spv::Op::OpTypeInt || result_type->GetOperandAs(1) != 32 || result_type->GetOperandAs(2) != 0) { return state.diag(SPV_ERROR_INVALID_ID, inst) << "The Result Type of " << instr_name << " " << state.getIdName(inst->id()) << " must be OpTypeInt with width 32 and signedness 0."; } const bool untyped = inst->opcode() == spv::Op::OpUntypedArrayLengthKHR; auto pointer_ty_id = state.GetOperandTypeId(inst, (untyped ? 3 : 2)); auto pointer_ty = state.FindDef(pointer_ty_id); if (untyped) { if (pointer_ty->opcode() != spv::Op::OpTypeUntypedPointerKHR) { return state.diag(SPV_ERROR_INVALID_ID, inst) << "Pointer must be an untyped pointer"; } } else if (pointer_ty->opcode() != spv::Op::OpTypePointer) { return state.diag(SPV_ERROR_INVALID_ID, inst) << "The Structure's type in " << instr_name << " " << state.getIdName(inst->id()) << " must be a pointer to an OpTypeStruct."; } Instruction* structure_type = nullptr; if (untyped) { structure_type = state.FindDef(inst->GetOperandAs(2)); } else { structure_type = state.FindDef(pointer_ty->GetOperandAs(2)); } if (structure_type->opcode() != spv::Op::OpTypeStruct) { return state.diag(SPV_ERROR_INVALID_ID, inst) << "The Structure's type in " << instr_name << " " << state.getIdName(inst->id()) << " must be a pointer to an OpTypeStruct."; } auto num_of_members = structure_type->operands().size() - 1; auto last_member = state.FindDef(structure_type->GetOperandAs(num_of_members)); if (last_member->opcode() != spv::Op::OpTypeRuntimeArray) { return state.diag(SPV_ERROR_INVALID_ID, inst) << "The Structure's last member in " << instr_name << " " << state.getIdName(inst->id()) << " must be an OpTypeRuntimeArray."; } // The array member must the index of the last element (the run time // array). const auto index = untyped ? 4 : 3; if (inst->GetOperandAs(index) != num_of_members - 1) { return state.diag(SPV_ERROR_INVALID_ID, inst) << "The array member in " << instr_name << " " << state.getIdName(inst->id()) << " must be the last member of the struct."; } return SPV_SUCCESS; } spv_result_t ValidateCooperativeMatrixLengthNV(ValidationState_t& state, const Instruction* inst) { std::string instr_name = "Op" + std::string(spvOpcodeString(static_cast(inst->opcode()))); // Result type must be a 32-bit unsigned int. auto result_type = state.FindDef(inst->type_id()); if (result_type->opcode() != spv::Op::OpTypeInt || result_type->GetOperandAs(1) != 32 || result_type->GetOperandAs(2) != 0) { return state.diag(SPV_ERROR_INVALID_ID, inst) << "The Result Type of " << instr_name << " " << state.getIdName(inst->id()) << " must be OpTypeInt with width 32 and signedness 0."; } bool isKhr = inst->opcode() == spv::Op::OpCooperativeMatrixLengthKHR; auto type_id = inst->GetOperandAs(2); auto type = state.FindDef(type_id); if (isKhr && type->opcode() != spv::Op::OpTypeCooperativeMatrixKHR) { return state.diag(SPV_ERROR_INVALID_ID, inst) << "The type in " << instr_name << " " << state.getIdName(type_id) << " must be OpTypeCooperativeMatrixKHR."; } else if (!isKhr && type->opcode() != spv::Op::OpTypeCooperativeMatrixNV) { return state.diag(SPV_ERROR_INVALID_ID, inst) << "The type in " << instr_name << " " << state.getIdName(type_id) << " must be OpTypeCooperativeMatrixNV."; } return SPV_SUCCESS; } spv_result_t ValidateCooperativeMatrixLoadStoreNV(ValidationState_t& _, const Instruction* inst) { uint32_t type_id; const char* opname; if (inst->opcode() == spv::Op::OpCooperativeMatrixLoadNV) { type_id = inst->type_id(); opname = "spv::Op::OpCooperativeMatrixLoadNV"; } else { // get Object operand's type type_id = _.FindDef(inst->GetOperandAs(1))->type_id(); opname = "spv::Op::OpCooperativeMatrixStoreNV"; } auto matrix_type = _.FindDef(type_id); if (matrix_type->opcode() != spv::Op::OpTypeCooperativeMatrixNV) { if (inst->opcode() == spv::Op::OpCooperativeMatrixLoadNV) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "spv::Op::OpCooperativeMatrixLoadNV Result Type " << _.getIdName(type_id) << " is not a cooperative matrix type."; } else { return _.diag(SPV_ERROR_INVALID_ID, inst) << "spv::Op::OpCooperativeMatrixStoreNV Object type " << _.getIdName(type_id) << " is not a cooperative matrix type."; } } const auto pointer_index = (inst->opcode() == spv::Op::OpCooperativeMatrixLoadNV) ? 2u : 0u; const auto pointer_id = inst->GetOperandAs(pointer_index); const auto pointer = _.FindDef(pointer_id); if (!pointer || ((_.addressing_model() == spv::AddressingModel::Logical) && ((!_.features().variable_pointers && !spvOpcodeReturnsLogicalPointer(pointer->opcode())) || (_.features().variable_pointers && !spvOpcodeReturnsLogicalVariablePointer(pointer->opcode()))))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opname << " Pointer " << _.getIdName(pointer_id) << " is not a logical pointer."; } const auto pointer_type_id = pointer->type_id(); const auto pointer_type = _.FindDef(pointer_type_id); if (!pointer_type || pointer_type->opcode() != spv::Op::OpTypePointer) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opname << " type for pointer " << _.getIdName(pointer_id) << " is not a pointer type."; } const auto storage_class_index = 1u; const auto storage_class = pointer_type->GetOperandAs(storage_class_index); if (storage_class != spv::StorageClass::Workgroup && storage_class != spv::StorageClass::StorageBuffer && storage_class != spv::StorageClass::PhysicalStorageBuffer) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opname << " storage class for pointer type " << _.getIdName(pointer_type_id) << " is not Workgroup or StorageBuffer."; } const auto pointee_id = pointer_type->GetOperandAs(2); const auto pointee_type = _.FindDef(pointee_id); if (!pointee_type || !(_.IsIntScalarOrVectorType(pointee_id) || _.IsFloatScalarOrVectorType(pointee_id))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opname << " Pointer " << _.getIdName(pointer->id()) << "s Type must be a scalar or vector type."; } const auto stride_index = (inst->opcode() == spv::Op::OpCooperativeMatrixLoadNV) ? 3u : 2u; const auto stride_id = inst->GetOperandAs(stride_index); const auto stride = _.FindDef(stride_id); if (!stride || !_.IsIntScalarType(stride->type_id())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Stride operand " << _.getIdName(stride_id) << " must be a scalar integer type."; } const auto colmajor_index = (inst->opcode() == spv::Op::OpCooperativeMatrixLoadNV) ? 4u : 3u; const auto colmajor_id = inst->GetOperandAs(colmajor_index); const auto colmajor = _.FindDef(colmajor_id); if (!colmajor || !_.IsBoolScalarType(colmajor->type_id()) || !(spvOpcodeIsConstant(colmajor->opcode()) || spvOpcodeIsSpecConstant(colmajor->opcode()))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Column Major operand " << _.getIdName(colmajor_id) << " must be a boolean constant instruction."; } const auto memory_access_index = (inst->opcode() == spv::Op::OpCooperativeMatrixLoadNV) ? 5u : 4u; if (inst->operands().size() > memory_access_index) { if (auto error = CheckMemoryAccess(_, inst, memory_access_index)) return error; } return SPV_SUCCESS; } spv_result_t ValidateCooperativeMatrixLoadStoreKHR(ValidationState_t& _, const Instruction* inst) { uint32_t type_id; const char* opname; if (inst->opcode() == spv::Op::OpCooperativeMatrixLoadKHR) { type_id = inst->type_id(); opname = "spv::Op::OpCooperativeMatrixLoadKHR"; } else { // get Object operand's type type_id = _.FindDef(inst->GetOperandAs(1))->type_id(); opname = "spv::Op::OpCooperativeMatrixStoreKHR"; } auto matrix_type = _.FindDef(type_id); if (matrix_type->opcode() != spv::Op::OpTypeCooperativeMatrixKHR) { if (inst->opcode() == spv::Op::OpCooperativeMatrixLoadKHR) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "spv::Op::OpCooperativeMatrixLoadKHR Result Type " << _.getIdName(type_id) << " is not a cooperative matrix type."; } else { return _.diag(SPV_ERROR_INVALID_ID, inst) << "spv::Op::OpCooperativeMatrixStoreKHR Object type " << _.getIdName(type_id) << " is not a cooperative matrix type."; } } const auto pointer_index = (inst->opcode() == spv::Op::OpCooperativeMatrixLoadKHR) ? 2u : 0u; const auto pointer_id = inst->GetOperandAs(pointer_index); const auto pointer = _.FindDef(pointer_id); if (!pointer || ((_.addressing_model() == spv::AddressingModel::Logical) && ((!_.features().variable_pointers && !spvOpcodeReturnsLogicalPointer(pointer->opcode())) || (_.features().variable_pointers && !spvOpcodeReturnsLogicalVariablePointer(pointer->opcode()))))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opname << " Pointer " << _.getIdName(pointer_id) << " is not a logical pointer."; } const auto pointer_type_id = pointer->type_id(); const auto pointer_type = _.FindDef(pointer_type_id); if (!pointer_type || !(pointer_type->opcode() == spv::Op::OpTypePointer || pointer_type->opcode() == spv::Op::OpTypeUntypedPointerKHR)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opname << " type for pointer " << _.getIdName(pointer_id) << " is not a pointer type."; } const bool untyped = pointer_type->opcode() == spv::Op::OpTypeUntypedPointerKHR; const auto storage_class_index = 1u; const auto storage_class = pointer_type->GetOperandAs(storage_class_index); if (spvIsVulkanEnv(_.context()->target_env)) { if (storage_class != spv::StorageClass::Workgroup && storage_class != spv::StorageClass::StorageBuffer && storage_class != spv::StorageClass::PhysicalStorageBuffer) { return _.diag(SPV_ERROR_INVALID_ID, inst) << _.VkErrorID(8973) << opname << " storage class for pointer type " << _.getIdName(pointer_type_id) << " is not Workgroup, StorageBuffer, or PhysicalStorageBuffer."; } } if (!untyped) { const auto pointee_id = pointer_type->GetOperandAs(2); const auto pointee_type = _.FindDef(pointee_id); if (!pointee_type || !(_.IsIntScalarOrVectorType(pointee_id) || _.IsFloatScalarOrVectorType(pointee_id))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opname << " Pointer " << _.getIdName(pointer->id()) << "s Type must be a scalar or vector type."; } } const auto layout_index = (inst->opcode() == spv::Op::OpCooperativeMatrixLoadKHR) ? 3u : 2u; const auto layout_id = inst->GetOperandAs(layout_index); const auto layout_inst = _.FindDef(layout_id); if (!layout_inst || !_.IsIntScalarType(layout_inst->type_id()) || !spvOpcodeIsConstant(layout_inst->opcode())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "MemoryLayout operand " << _.getIdName(layout_id) << " must be a 32-bit integer constant instruction."; } bool stride_required = false; uint64_t layout; if (_.EvalConstantValUint64(layout_id, &layout)) { stride_required = (layout == (uint64_t)spv::CooperativeMatrixLayout::RowMajorKHR) || (layout == (uint64_t)spv::CooperativeMatrixLayout::ColumnMajorKHR); } const auto stride_index = (inst->opcode() == spv::Op::OpCooperativeMatrixLoadKHR) ? 4u : 3u; if (inst->operands().size() > stride_index) { const auto stride_id = inst->GetOperandAs(stride_index); const auto stride = _.FindDef(stride_id); if (!stride || !_.IsIntScalarType(stride->type_id())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Stride operand " << _.getIdName(stride_id) << " must be a scalar integer type."; } } else if (stride_required) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "MemoryLayout " << layout << " requires a Stride."; } const auto memory_access_index = (inst->opcode() == spv::Op::OpCooperativeMatrixLoadKHR) ? 5u : 4u; if (inst->operands().size() > memory_access_index) { if (auto error = CheckMemoryAccess(_, inst, memory_access_index)) return error; } return SPV_SUCCESS; } // Returns the number of instruction words taken up by a tensor addressing // operands argument and its implied operands. int TensorAddressingOperandsNumWords(spv::TensorAddressingOperandsMask mask) { int result = 1; // Count the mask if ((mask & spv::TensorAddressingOperandsMask::TensorView) != spv::TensorAddressingOperandsMask::MaskNone) ++result; if ((mask & spv::TensorAddressingOperandsMask::DecodeFunc) != spv::TensorAddressingOperandsMask::MaskNone) ++result; return result; } spv_result_t ValidateCooperativeMatrixLoadStoreTensorNV( ValidationState_t& _, const Instruction* inst) { uint32_t type_id; const char* opname; if (inst->opcode() == spv::Op::OpCooperativeMatrixLoadTensorNV) { type_id = inst->type_id(); opname = "spv::Op::OpCooperativeMatrixLoadTensorNV"; } else { // get Object operand's type type_id = _.FindDef(inst->GetOperandAs(1))->type_id(); opname = "spv::Op::OpCooperativeMatrixStoreTensorNV"; } auto matrix_type = _.FindDef(type_id); if (matrix_type->opcode() != spv::Op::OpTypeCooperativeMatrixKHR) { if (inst->opcode() == spv::Op::OpCooperativeMatrixLoadTensorNV) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "spv::Op::OpCooperativeMatrixLoadTensorNV Result Type " << _.getIdName(type_id) << " is not a cooperative matrix type."; } else { return _.diag(SPV_ERROR_INVALID_ID, inst) << "spv::Op::OpCooperativeMatrixStoreTensorNV Object type " << _.getIdName(type_id) << " is not a cooperative matrix type."; } } const auto pointer_index = (inst->opcode() == spv::Op::OpCooperativeMatrixLoadTensorNV) ? 2u : 0u; const auto pointer_id = inst->GetOperandAs(pointer_index); const auto pointer = _.FindDef(pointer_id); if (!pointer || ((_.addressing_model() == spv::AddressingModel::Logical) && ((!_.features().variable_pointers && !spvOpcodeReturnsLogicalPointer(pointer->opcode())) || (_.features().variable_pointers && !spvOpcodeReturnsLogicalVariablePointer(pointer->opcode()))))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opname << " Pointer " << _.getIdName(pointer_id) << " is not a logical pointer."; } const auto pointer_type_id = pointer->type_id(); const auto pointer_type = _.FindDef(pointer_type_id); if (!pointer_type || pointer_type->opcode() != spv::Op::OpTypePointer) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opname << " type for pointer " << _.getIdName(pointer_id) << " is not a pointer type."; } const auto storage_class_index = 1u; const auto storage_class = pointer_type->GetOperandAs(storage_class_index); if (storage_class != spv::StorageClass::Workgroup && storage_class != spv::StorageClass::StorageBuffer && storage_class != spv::StorageClass::PhysicalStorageBuffer) { return _.diag(SPV_ERROR_INVALID_ID, inst) << _.VkErrorID(8973) << opname << " storage class for pointer type " << _.getIdName(pointer_type_id) << " is not Workgroup, StorageBuffer, or PhysicalStorageBuffer."; } if (inst->opcode() == spv::Op::OpCooperativeMatrixLoadTensorNV) { const auto object_index = 3; const auto object_id = inst->GetOperandAs(object_index); const auto object = _.FindDef(object_id); if (!object || object->type_id() != type_id) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opname << " Object " << _.getIdName(object_id) << " type does not match Result Type."; } } const auto tensor_layout_index = (inst->opcode() == spv::Op::OpCooperativeMatrixLoadTensorNV) ? 4u : 2u; const auto tensor_layout_id = inst->GetOperandAs(tensor_layout_index); const auto tensor_layout = _.FindDef(tensor_layout_id); if (!tensor_layout || _.FindDef(tensor_layout->type_id())->opcode() != spv::Op::OpTypeTensorLayoutNV) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opname << " TensorLayout " << _.getIdName(tensor_layout_id) << " does not have a tensor layout type."; } const auto memory_access_index = (inst->opcode() == spv::Op::OpCooperativeMatrixLoadTensorNV) ? 5u : 3u; if (inst->operands().size() > memory_access_index) { if (auto error = CheckMemoryAccess(_, inst, memory_access_index)) return error; } const auto memory_access_mask = inst->GetOperandAs(memory_access_index); const auto tensor_operands_index = memory_access_index + MemoryAccessNumWords(memory_access_mask); const auto tensor_operands = inst->GetOperandAs( tensor_operands_index); if (inst->operands().size() < tensor_operands_index + TensorAddressingOperandsNumWords(tensor_operands)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opname << " not enough tensor addressing operands."; } uint32_t tensor_operand_index = tensor_operands_index + 1; if ((tensor_operands & spv::TensorAddressingOperandsMask::TensorView) != spv::TensorAddressingOperandsMask::MaskNone) { const auto tensor_view_id = inst->GetOperandAs(tensor_operand_index); const auto tensor_view = _.FindDef(tensor_view_id); if (!tensor_view || _.FindDef(tensor_view->type_id())->opcode() != spv::Op::OpTypeTensorViewNV) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opname << " TensorView " << _.getIdName(tensor_view_id) << " does not have a tensor view type."; } tensor_operand_index++; } if ((tensor_operands & spv::TensorAddressingOperandsMask::DecodeFunc) != spv::TensorAddressingOperandsMask::MaskNone) { if (inst->opcode() == spv::Op::OpCooperativeMatrixStoreTensorNV) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpCooperativeMatrixStoreTensorNV does not support DecodeFunc."; } const auto decode_func_id = inst->GetOperandAs(tensor_operand_index); const auto decode_func = _.FindDef(decode_func_id); if (!decode_func || decode_func->opcode() != spv::Op::OpFunction) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opname << " DecodeFunc " << _.getIdName(decode_func_id) << " is not a function."; } const auto component_type_index = 1; const auto component_type_id = matrix_type->GetOperandAs(component_type_index); const auto function_type = _.FindDef(decode_func->GetOperandAs(3)); if (function_type->GetOperandAs(1) != component_type_id) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opname << " DecodeFunc " << _.getIdName(decode_func_id) << " return type must match matrix component type."; } const auto decode_ptr_type_id = function_type->GetOperandAs(2); const auto decode_ptr_type = _.FindDef(decode_ptr_type_id); auto decode_storage_class = decode_ptr_type->GetOperandAs(storage_class_index); if (decode_storage_class != spv::StorageClass::PhysicalStorageBuffer) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opname << " DecodeFunc " << _.getIdName(decode_func_id) << " first parameter must be pointer to PhysicalStorageBuffer."; } const auto tensor_layout_type = _.FindDef(tensor_layout->type_id()); for (uint32_t param = 3; param < 5; ++param) { const auto param_type_id = function_type->GetOperandAs(param); const auto param_type = _.FindDef(param_type_id); if (param_type->opcode() != spv::Op::OpTypeArray) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opname << " DecodeFunc " << _.getIdName(decode_func_id) << " second/third parameter must be array of 32-bit integer " "with " << " dimension equal to the tensor dimension."; } const auto length_index = 2u; uint64_t array_length; if (_.EvalConstantValUint64( param_type->GetOperandAs(length_index), &array_length)) { const auto tensor_layout_dim_id = tensor_layout_type->GetOperandAs(1); uint64_t dim_value; if (_.EvalConstantValUint64(tensor_layout_dim_id, &dim_value)) { if (array_length != dim_value) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opname << " DecodeFunc " << _.getIdName(decode_func_id) << " second/third parameter must be array of 32-bit integer " "with " << " dimension equal to the tensor dimension."; } } } } tensor_operand_index++; } return SPV_SUCCESS; } spv_result_t ValidateInt32Operand(ValidationState_t& _, const Instruction* inst, uint32_t operand_index, const char* opcode_name, const char* operand_name) { const auto type_id = _.FindDef(inst->GetOperandAs(operand_index))->type_id(); if (!_.IsIntScalarType(type_id) || _.GetBitWidth(type_id) != 32) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opcode_name << " " << operand_name << " type " << _.getIdName(type_id) << " is not a 32 bit integer."; } return SPV_SUCCESS; } spv_result_t ValidateCooperativeVectorPointer(ValidationState_t& _, const Instruction* inst, const char* opname, uint32_t pointer_index) { const auto pointer_id = inst->GetOperandAs(pointer_index); const auto pointer = _.FindDef(pointer_id); if (!pointer || ((_.addressing_model() == spv::AddressingModel::Logical) && ((!_.features().variable_pointers && !spvOpcodeReturnsLogicalPointer(pointer->opcode())) || (_.features().variable_pointers && !spvOpcodeReturnsLogicalVariablePointer(pointer->opcode()))))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opname << " Pointer " << _.getIdName(pointer_id) << " is not a logical pointer."; } const auto pointer_type_id = pointer->type_id(); const auto pointer_type = _.FindDef(pointer_type_id); if (!pointer_type || pointer_type->opcode() != spv::Op::OpTypePointer) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opname << " type for pointer " << _.getIdName(pointer_id) << " is not a pointer type."; } const auto storage_class_index = 1u; const auto storage_class = pointer_type->GetOperandAs(storage_class_index); if (storage_class != spv::StorageClass::Workgroup && storage_class != spv::StorageClass::StorageBuffer && storage_class != spv::StorageClass::PhysicalStorageBuffer) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opname << " storage class for pointer type " << _.getIdName(pointer_type_id) << " is not Workgroup or StorageBuffer."; } const auto pointee_id = pointer_type->GetOperandAs(2); const auto pointee_type = _.FindDef(pointee_id); if (!pointee_type || (pointee_type->opcode() != spv::Op::OpTypeArray && pointee_type->opcode() != spv::Op::OpTypeRuntimeArray)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opname << " Pointer " << _.getIdName(pointer->id()) << "s Type must be an array type."; } const auto array_elem_type_id = pointee_type->GetOperandAs(1); auto array_elem_type = _.FindDef(array_elem_type_id); if (!array_elem_type || !(_.IsIntScalarOrVectorType(array_elem_type_id) || _.IsFloatScalarOrVectorType(array_elem_type_id))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opname << " Pointer " << _.getIdName(pointer->id()) << "s Type must be an array of scalar or vector type."; } return SPV_SUCCESS; } spv_result_t ValidateCooperativeVectorLoadStoreNV(ValidationState_t& _, const Instruction* inst) { uint32_t type_id; const char* opname; if (inst->opcode() == spv::Op::OpCooperativeVectorLoadNV) { type_id = inst->type_id(); opname = "spv::Op::OpCooperativeVectorLoadNV"; } else { // get Object operand's type type_id = _.FindDef(inst->GetOperandAs(2))->type_id(); opname = "spv::Op::OpCooperativeVectorStoreNV"; } auto vector_type = _.FindDef(type_id); if (vector_type->opcode() != spv::Op::OpTypeCooperativeVectorNV) { if (inst->opcode() == spv::Op::OpCooperativeVectorLoadNV) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "spv::Op::OpCooperativeVectorLoadNV Result Type " << _.getIdName(type_id) << " is not a cooperative vector type."; } else { return _.diag(SPV_ERROR_INVALID_ID, inst) << "spv::Op::OpCooperativeVectorStoreNV Object type " << _.getIdName(type_id) << " is not a cooperative vector type."; } } const auto pointer_index = (inst->opcode() == spv::Op::OpCooperativeVectorLoadNV) ? 2u : 0u; if (auto error = ValidateCooperativeVectorPointer(_, inst, opname, pointer_index)) { return error; } const auto memory_access_index = (inst->opcode() == spv::Op::OpCooperativeVectorLoadNV) ? 4u : 3u; if (inst->operands().size() > memory_access_index) { if (auto error = CheckMemoryAccess(_, inst, memory_access_index)) return error; } return SPV_SUCCESS; } spv_result_t ValidateCooperativeVectorOuterProductNV(ValidationState_t& _, const Instruction* inst) { const auto pointer_index = 0u; const auto opcode_name = "spv::Op::OpCooperativeVectorOuterProductAccumulateNV"; if (auto error = ValidateCooperativeVectorPointer(_, inst, opcode_name, pointer_index)) { return error; } auto type_id = _.FindDef(inst->GetOperandAs(2))->type_id(); auto a_type = _.FindDef(type_id); if (a_type->opcode() != spv::Op::OpTypeCooperativeVectorNV) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opcode_name << " A type " << _.getIdName(type_id) << " is not a cooperative vector type."; } type_id = _.FindDef(inst->GetOperandAs(3))->type_id(); auto b_type = _.FindDef(type_id); if (b_type->opcode() != spv::Op::OpTypeCooperativeVectorNV) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opcode_name << " B type " << _.getIdName(type_id) << " is not a cooperative vector type."; } const auto a_component_type_id = a_type->GetOperandAs(1); const auto b_component_type_id = b_type->GetOperandAs(1); if (a_component_type_id != b_component_type_id) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opcode_name << " A and B component types " << _.getIdName(a_component_type_id) << " and " << _.getIdName(b_component_type_id) << " do not match."; } if (auto error = ValidateInt32Operand(_, inst, 1, opcode_name, "Offset")) { return error; } if (auto error = ValidateInt32Operand(_, inst, 4, opcode_name, "MemoryLayout")) { return error; } if (auto error = ValidateInt32Operand(_, inst, 5, opcode_name, "MatrixInterpretation")) { return error; } if (inst->operands().size() > 6) { if (auto error = ValidateInt32Operand(_, inst, 6, opcode_name, "MatrixStride")) { return error; } } return SPV_SUCCESS; } spv_result_t ValidateCooperativeVectorReduceSumNV(ValidationState_t& _, const Instruction* inst) { const auto opcode_name = "spv::Op::OpCooperativeVectorReduceSumAccumulateNV"; const auto pointer_index = 0u; if (auto error = ValidateCooperativeVectorPointer(_, inst, opcode_name, pointer_index)) { return error; } auto type_id = _.FindDef(inst->GetOperandAs(2))->type_id(); auto v_type = _.FindDef(type_id); if (v_type->opcode() != spv::Op::OpTypeCooperativeVectorNV) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opcode_name << " V type " << _.getIdName(type_id) << " is not a cooperative vector type."; } if (auto error = ValidateInt32Operand(_, inst, 1, opcode_name, "Offset")) { return error; } return SPV_SUCCESS; } bool InterpretationIsPacked(spv::ComponentType interp) { switch (interp) { case spv::ComponentType::SignedInt8PackedNV: case spv::ComponentType::UnsignedInt8PackedNV: return true; default: return false; } } using std::get; spv_result_t ValidateCooperativeVectorMatrixMulNV(ValidationState_t& _, const Instruction* inst) { const bool has_bias = inst->opcode() == spv::Op::OpCooperativeVectorMatrixMulAddNV; const auto opcode_name = has_bias ? "spv::Op::OpCooperativeVectorMatrixMulAddNV" : "spv::Op::OpCooperativeVectorMatrixMulNV"; const auto bias_offset = has_bias ? 3 : 0; const auto result_type_index = 0u; const auto input_index = 2u; const auto input_interpretation_index = 3u; const auto matrix_index = 4u; const auto matrix_interpretation_index = 6u; const auto bias_index = 7u; const auto bias_interpretation_index = 9u; const auto m_index = 7u + bias_offset; const auto k_index = 8u + bias_offset; const auto memory_layout_index = 9u + bias_offset; const auto transpose_index = 10u + bias_offset; const auto result_type_id = inst->GetOperandAs(result_type_index); const auto input_id = inst->GetOperandAs(input_index); const auto input_interpretation_id = inst->GetOperandAs(input_interpretation_index); const auto matrix_interpretation_id = inst->GetOperandAs(matrix_interpretation_index); const auto bias_interpretation_id = inst->GetOperandAs(bias_interpretation_index); const auto m_id = inst->GetOperandAs(m_index); const auto k_id = inst->GetOperandAs(k_index); const auto memory_layout_id = inst->GetOperandAs(memory_layout_index); const auto transpose_id = inst->GetOperandAs(transpose_index); if (auto error = ValidateCooperativeVectorPointer(_, inst, opcode_name, matrix_index)) { return error; } if (inst->opcode() == spv::Op::OpCooperativeVectorMatrixMulAddNV) { if (auto error = ValidateCooperativeVectorPointer(_, inst, opcode_name, bias_index)) { return error; } } const auto result_type = _.FindDef(result_type_id); if (result_type->opcode() != spv::Op::OpTypeCooperativeVectorNV) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opcode_name << " result type " << _.getIdName(result_type_id) << " is not a cooperative vector type."; } const auto result_component_type_id = result_type->GetOperandAs(1u); if (!(_.IsIntScalarType(result_component_type_id) && _.GetBitWidth(result_component_type_id) == 32) && !(_.IsFloatScalarType(result_component_type_id) && (_.GetBitWidth(result_component_type_id) == 32 || _.GetBitWidth(result_component_type_id) == 16))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opcode_name << " result component type " << _.getIdName(result_component_type_id) << " is not a 32 bit int or 16/32 bit float."; } const auto m_eval = _.EvalInt32IfConst(m_id); const auto rc_eval = _.EvalInt32IfConst(result_type->GetOperandAs(2u)); if (get<1>(m_eval) && get<1>(rc_eval) && get<2>(m_eval) != get<2>(rc_eval)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opcode_name << " result type number of components " << get<2>(rc_eval) << " does not match M " << get<2>(m_eval); } const auto k_eval = _.EvalInt32IfConst(k_id); const auto input = _.FindDef(input_id); const auto input_type = _.FindDef(input->type_id()); const auto input_num_components_id = input_type->GetOperandAs(2u); auto input_interp_eval = _.EvalInt32IfConst(input_interpretation_id); if (get<1>(input_interp_eval) && !InterpretationIsPacked(spv::ComponentType{get<2>(input_interp_eval)})) { const auto inc_eval = _.EvalInt32IfConst(input_num_components_id); if (get<1>(inc_eval) && get<1>(k_eval) && get<2>(inc_eval) != get<2>(k_eval)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opcode_name << " input number of components " << get<2>(inc_eval) << " does not match K " << get<2>(k_eval); } } if (!_.IsBoolScalarType(_.FindDef(transpose_id)->type_id())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opcode_name << " Transpose " << _.getIdName(transpose_id) << " is not a scalar boolean."; } const auto check_constant = [&](uint32_t id, const char* operand_name) -> spv_result_t { if (!spvOpcodeIsConstant(_.GetIdOpcode(id))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << opcode_name << " " << operand_name << " " << _.getIdName(id) << " is not a constant instruction."; } return SPV_SUCCESS; }; if (auto error = check_constant(input_interpretation_id, "InputInterpretation")) { return error; } if (auto error = check_constant(matrix_interpretation_id, "MatrixInterpretation")) { return error; } if (has_bias) { if (auto error = check_constant(bias_interpretation_id, "BiasInterpretation")) { return error; } } if (auto error = check_constant(m_id, "M")) { return error; } if (auto error = check_constant(k_id, "K")) { return error; } if (auto error = check_constant(memory_layout_id, "MemoryLayout")) { return error; } if (auto error = check_constant(transpose_id, "Transpose")) { return error; } if (auto error = ValidateInt32Operand(_, inst, input_interpretation_index, opcode_name, "InputInterpretation")) { return error; } if (auto error = ValidateInt32Operand(_, inst, matrix_interpretation_index, opcode_name, "MatrixInterpretation")) { return error; } if (has_bias) { if (auto error = ValidateInt32Operand(_, inst, bias_interpretation_index, opcode_name, "BiasInterpretation")) { return error; } } if (auto error = ValidateInt32Operand(_, inst, m_index, opcode_name, "M")) { return error; } if (auto error = ValidateInt32Operand(_, inst, k_index, opcode_name, "K")) { return error; } if (auto error = ValidateInt32Operand(_, inst, memory_layout_index, opcode_name, "MemoryLayout")) { return error; } return SPV_SUCCESS; } spv_result_t ValidatePtrComparison(ValidationState_t& _, const Instruction* inst) { if (_.addressing_model() == spv::AddressingModel::Logical && !_.features().variable_pointers) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Instruction cannot for logical addressing model be used without " "a variable pointers capability"; } const auto result_type = _.FindDef(inst->type_id()); if (inst->opcode() == spv::Op::OpPtrDiff) { if (!result_type || result_type->opcode() != spv::Op::OpTypeInt) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Result Type must be an integer scalar"; } } else { if (!result_type || result_type->opcode() != spv::Op::OpTypeBool) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Result Type must be OpTypeBool"; } } const auto op1 = _.FindDef(inst->GetOperandAs(2u)); const auto op2 = _.FindDef(inst->GetOperandAs(3u)); const auto op1_type = _.FindDef(op1->type_id()); const auto op2_type = _.FindDef(op2->type_id()); if (!op1_type || (op1_type->opcode() != spv::Op::OpTypePointer && op1_type->opcode() != spv::Op::OpTypeUntypedPointerKHR)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Operand type must be a pointer"; } if (!op2_type || (op2_type->opcode() != spv::Op::OpTypePointer && op2_type->opcode() != spv::Op::OpTypeUntypedPointerKHR)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Operand type must be a pointer"; } if (inst->opcode() == spv::Op::OpPtrDiff) { if (op1->type_id() != op2->type_id()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "The types of Operand 1 and Operand 2 must match"; } } else { const auto either_untyped = op1_type->opcode() == spv::Op::OpTypeUntypedPointerKHR || op2_type->opcode() == spv::Op::OpTypeUntypedPointerKHR; if (either_untyped) { const auto sc1 = op1_type->GetOperandAs(1); const auto sc2 = op2_type->GetOperandAs(1); if (sc1 != sc2) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Pointer storage classes must match"; } } else if (op1->type_id() != op2->type_id()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "The types of Operand 1 and Operand 2 must match"; } } spv::StorageClass sc = op1_type->GetOperandAs(1u); if (_.addressing_model() == spv::AddressingModel::Logical) { if (sc != spv::StorageClass::Workgroup && sc != spv::StorageClass::StorageBuffer) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Invalid pointer storage class"; } if (sc == spv::StorageClass::Workgroup && !_.HasCapability(spv::Capability::VariablePointers)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Workgroup storage class pointer requires VariablePointers " "capability to be specified"; } } else if (sc == spv::StorageClass::PhysicalStorageBuffer) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Cannot use a pointer in the PhysicalStorageBuffer storage class"; } return SPV_SUCCESS; } } // namespace spv_result_t MemoryPass(ValidationState_t& _, const Instruction* inst) { switch (inst->opcode()) { case spv::Op::OpVariable: case spv::Op::OpUntypedVariableKHR: if (auto error = ValidateVariable(_, inst)) return error; break; case spv::Op::OpLoad: if (auto error = ValidateLoad(_, inst)) return error; break; case spv::Op::OpStore: if (auto error = ValidateStore(_, inst)) return error; break; case spv::Op::OpCopyMemory: case spv::Op::OpCopyMemorySized: if (auto error = ValidateCopyMemory(_, inst)) return error; break; case spv::Op::OpPtrAccessChain: case spv::Op::OpUntypedPtrAccessChainKHR: case spv::Op::OpUntypedInBoundsPtrAccessChainKHR: if (auto error = ValidatePtrAccessChain(_, inst)) return error; break; case spv::Op::OpAccessChain: case spv::Op::OpInBoundsAccessChain: case spv::Op::OpInBoundsPtrAccessChain: case spv::Op::OpUntypedAccessChainKHR: case spv::Op::OpUntypedInBoundsAccessChainKHR: if (auto error = ValidateAccessChain(_, inst)) return error; break; case spv::Op::OpRawAccessChainNV: if (auto error = ValidateRawAccessChain(_, inst)) return error; break; case spv::Op::OpArrayLength: case spv::Op::OpUntypedArrayLengthKHR: if (auto error = ValidateArrayLength(_, inst)) return error; break; case spv::Op::OpCooperativeMatrixLoadNV: case spv::Op::OpCooperativeMatrixStoreNV: if (auto error = ValidateCooperativeMatrixLoadStoreNV(_, inst)) return error; break; case spv::Op::OpCooperativeMatrixLengthKHR: case spv::Op::OpCooperativeMatrixLengthNV: if (auto error = ValidateCooperativeMatrixLengthNV(_, inst)) return error; break; case spv::Op::OpCooperativeMatrixLoadKHR: case spv::Op::OpCooperativeMatrixStoreKHR: if (auto error = ValidateCooperativeMatrixLoadStoreKHR(_, inst)) return error; break; case spv::Op::OpCooperativeMatrixLoadTensorNV: case spv::Op::OpCooperativeMatrixStoreTensorNV: if (auto error = ValidateCooperativeMatrixLoadStoreTensorNV(_, inst)) return error; break; case spv::Op::OpCooperativeVectorLoadNV: case spv::Op::OpCooperativeVectorStoreNV: if (auto error = ValidateCooperativeVectorLoadStoreNV(_, inst)) return error; break; case spv::Op::OpCooperativeVectorOuterProductAccumulateNV: if (auto error = ValidateCooperativeVectorOuterProductNV(_, inst)) return error; break; case spv::Op::OpCooperativeVectorReduceSumAccumulateNV: if (auto error = ValidateCooperativeVectorReduceSumNV(_, inst)) return error; break; case spv::Op::OpCooperativeVectorMatrixMulNV: case spv::Op::OpCooperativeVectorMatrixMulAddNV: if (auto error = ValidateCooperativeVectorMatrixMulNV(_, inst)) return error; break; case spv::Op::OpPtrEqual: case spv::Op::OpPtrNotEqual: case spv::Op::OpPtrDiff: if (auto error = ValidatePtrComparison(_, inst)) return error; break; case spv::Op::OpImageTexelPointer: case spv::Op::OpGenericPtrMemSemantics: default: break; } return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_memory_semantics.cpp000066400000000000000000000255141475742701700265550ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/val/validate_memory_semantics.h" #include "source/spirv_target_env.h" #include "source/util/bitutils.h" #include "source/val/instruction.h" #include "source/val/validation_state.h" namespace spvtools { namespace val { spv_result_t ValidateMemorySemantics(ValidationState_t& _, const Instruction* inst, uint32_t operand_index, uint32_t memory_scope) { const spv::Op opcode = inst->opcode(); const auto id = inst->GetOperandAs(operand_index); bool is_int32 = false, is_const_int32 = false; uint32_t value = 0; std::tie(is_int32, is_const_int32, value) = _.EvalInt32IfConst(id); if (!is_int32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": expected Memory Semantics to be a 32-bit int"; } if (!is_const_int32) { if (_.HasCapability(spv::Capability::Shader) && !_.HasCapability(spv::Capability::CooperativeMatrixNV)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Memory Semantics ids must be OpConstant when Shader " "capability is present"; } if (_.HasCapability(spv::Capability::Shader) && _.HasCapability(spv::Capability::CooperativeMatrixNV) && !spvOpcodeIsConstant(_.GetIdOpcode(id))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Memory Semantics must be a constant instruction when " "CooperativeMatrixNV capability is present"; } return SPV_SUCCESS; } const size_t num_memory_order_set_bits = spvtools::utils::CountSetBits( value & uint32_t(spv::MemorySemanticsMask::Acquire | spv::MemorySemanticsMask::Release | spv::MemorySemanticsMask::AcquireRelease | spv::MemorySemanticsMask::SequentiallyConsistent)); if (num_memory_order_set_bits > 1) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": Memory Semantics can have at most one of the following " "bits " "set: Acquire, Release, AcquireRelease or " "SequentiallyConsistent"; } if (_.memory_model() == spv::MemoryModel::VulkanKHR && value & uint32_t(spv::MemorySemanticsMask::SequentiallyConsistent)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "SequentiallyConsistent memory " "semantics cannot be used with " "the VulkanKHR memory model."; } if (value & uint32_t(spv::MemorySemanticsMask::MakeAvailableKHR) && !_.HasCapability(spv::Capability::VulkanMemoryModelKHR)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": Memory Semantics MakeAvailableKHR requires capability " << "VulkanMemoryModelKHR"; } if (value & uint32_t(spv::MemorySemanticsMask::MakeVisibleKHR) && !_.HasCapability(spv::Capability::VulkanMemoryModelKHR)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": Memory Semantics MakeVisibleKHR requires capability " << "VulkanMemoryModelKHR"; } if (value & uint32_t(spv::MemorySemanticsMask::OutputMemoryKHR) && !_.HasCapability(spv::Capability::VulkanMemoryModelKHR)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": Memory Semantics OutputMemoryKHR requires capability " << "VulkanMemoryModelKHR"; } if (value & uint32_t(spv::MemorySemanticsMask::Volatile)) { if (!_.HasCapability(spv::Capability::VulkanMemoryModelKHR)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": Memory Semantics Volatile requires capability " "VulkanMemoryModelKHR"; } if (!spvOpcodeIsAtomicOp(inst->opcode())) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Memory Semantics Volatile can only be used with atomic " "instructions"; } } if (value & uint32_t(spv::MemorySemanticsMask::UniformMemory) && !_.HasCapability(spv::Capability::Shader)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": Memory Semantics UniformMemory requires capability Shader"; } // Checking for spv::Capability::AtomicStorage is intentionally not done here. // See https://github.com/KhronosGroup/glslang/issues/1618 for the reasoning // why. if (value & uint32_t(spv::MemorySemanticsMask::MakeAvailableKHR | spv::MemorySemanticsMask::MakeVisibleKHR)) { const bool includes_storage_class = value & uint32_t(spv::MemorySemanticsMask::UniformMemory | spv::MemorySemanticsMask::SubgroupMemory | spv::MemorySemanticsMask::WorkgroupMemory | spv::MemorySemanticsMask::CrossWorkgroupMemory | spv::MemorySemanticsMask::AtomicCounterMemory | spv::MemorySemanticsMask::ImageMemory | spv::MemorySemanticsMask::OutputMemoryKHR); if (!includes_storage_class) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": expected Memory Semantics to include a storage class"; } } if (value & uint32_t(spv::MemorySemanticsMask::MakeVisibleKHR) && !(value & uint32_t(spv::MemorySemanticsMask::Acquire | spv::MemorySemanticsMask::AcquireRelease))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": MakeVisibleKHR Memory Semantics also requires either Acquire " "or AcquireRelease Memory Semantics"; } if (value & uint32_t(spv::MemorySemanticsMask::MakeAvailableKHR) && !(value & uint32_t(spv::MemorySemanticsMask::Release | spv::MemorySemanticsMask::AcquireRelease))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": MakeAvailableKHR Memory Semantics also requires either " "Release or AcquireRelease Memory Semantics"; } if (spvIsVulkanEnv(_.context()->target_env)) { const bool includes_storage_class = value & uint32_t(spv::MemorySemanticsMask::UniformMemory | spv::MemorySemanticsMask::WorkgroupMemory | spv::MemorySemanticsMask::ImageMemory | spv::MemorySemanticsMask::OutputMemoryKHR); if (opcode == spv::Op::OpMemoryBarrier && !num_memory_order_set_bits) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(4732) << spvOpcodeString(opcode) << ": Vulkan specification requires Memory Semantics to have " "one " "of the following bits set: Acquire, Release, " "AcquireRelease " "or SequentiallyConsistent"; } else if (opcode != spv::Op::OpMemoryBarrier && num_memory_order_set_bits) { // should leave only atomics and control barriers for Vulkan env bool memory_is_int32 = false, memory_is_const_int32 = false; uint32_t memory_value = 0; std::tie(memory_is_int32, memory_is_const_int32, memory_value) = _.EvalInt32IfConst(memory_scope); if (memory_is_int32 && spv::Scope(memory_value) == spv::Scope::Invocation) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(4641) << spvOpcodeString(opcode) << ": Vulkan specification requires Memory Semantics to be None " "if used with Invocation Memory Scope"; } } if (opcode == spv::Op::OpMemoryBarrier && !includes_storage_class) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(4733) << spvOpcodeString(opcode) << ": expected Memory Semantics to include a Vulkan-supported " "storage class"; } if (opcode == spv::Op::OpControlBarrier && value && !includes_storage_class) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(4650) << spvOpcodeString(opcode) << ": expected Memory Semantics to include a Vulkan-supported " "storage class if Memory Semantics is not None"; } } if (opcode == spv::Op::OpAtomicFlagClear && (value & uint32_t(spv::MemorySemanticsMask::Acquire) || value & uint32_t(spv::MemorySemanticsMask::AcquireRelease))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Memory Semantics Acquire and AcquireRelease cannot be used " "with " << spvOpcodeString(opcode); } if (opcode == spv::Op::OpAtomicCompareExchange && operand_index == 5 && (value & uint32_t(spv::MemorySemanticsMask::Release) || value & uint32_t(spv::MemorySemanticsMask::AcquireRelease))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": Memory Semantics Release and AcquireRelease cannot be " "used " "for operand Unequal"; } if (spvIsVulkanEnv(_.context()->target_env)) { if (opcode == spv::Op::OpAtomicLoad && (value & uint32_t(spv::MemorySemanticsMask::Release) || value & uint32_t(spv::MemorySemanticsMask::AcquireRelease) || value & uint32_t(spv::MemorySemanticsMask::SequentiallyConsistent))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(4731) << "Vulkan spec disallows OpAtomicLoad with Memory Semantics " "Release, AcquireRelease and SequentiallyConsistent"; } if (opcode == spv::Op::OpAtomicStore && (value & uint32_t(spv::MemorySemanticsMask::Acquire) || value & uint32_t(spv::MemorySemanticsMask::AcquireRelease) || value & uint32_t(spv::MemorySemanticsMask::SequentiallyConsistent))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(4730) << "Vulkan spec disallows OpAtomicStore with Memory Semantics " "Acquire, AcquireRelease and SequentiallyConsistent"; } } // TODO(atgoo@github.com) Add checks for OpenCL and OpenGL environments. return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_memory_semantics.h000066400000000000000000000020341475742701700262120ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validates correctness of memory semantics for SPIR-V instructions. #include "source/opcode.h" #include "source/val/validate.h" namespace spvtools { namespace val { spv_result_t ValidateMemorySemantics(ValidationState_t& _, const Instruction* inst, uint32_t operand_index, uint32_t memory_scope); } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_mesh_shading.cpp000066400000000000000000000143651475742701700256320ustar00rootroot00000000000000// Copyright (c) 2022 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validates ray query instructions from SPV_KHR_ray_query #include "source/opcode.h" #include "source/spirv_target_env.h" #include "source/val/instruction.h" #include "source/val/validate.h" #include "source/val/validation_state.h" namespace spvtools { namespace val { bool IsInterfaceVariable(ValidationState_t& _, const Instruction* inst, spv::ExecutionModel model) { bool foundInterface = false; for (auto entry_point : _.entry_points()) { const auto* models = _.GetExecutionModels(entry_point); if (models->find(model) == models->end()) return false; for (const auto& desc : _.entry_point_descriptions(entry_point)) { for (auto interface : desc.interfaces) { if (inst->id() == interface) { foundInterface = true; break; } } } } return foundInterface; } spv_result_t MeshShadingPass(ValidationState_t& _, const Instruction* inst) { const spv::Op opcode = inst->opcode(); switch (opcode) { case spv::Op::OpEmitMeshTasksEXT: { _.function(inst->function()->id()) ->RegisterExecutionModelLimitation( [](spv::ExecutionModel model, std::string* message) { if (model != spv::ExecutionModel::TaskEXT) { if (message) { *message = "OpEmitMeshTasksEXT requires TaskEXT execution model"; } return false; } return true; }); const uint32_t group_count_x = _.GetOperandTypeId(inst, 0); if (!_.IsUnsignedIntScalarType(group_count_x) || _.GetBitWidth(group_count_x) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Group Count X must be a 32-bit unsigned int scalar"; } const uint32_t group_count_y = _.GetOperandTypeId(inst, 1); if (!_.IsUnsignedIntScalarType(group_count_y) || _.GetBitWidth(group_count_y) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Group Count Y must be a 32-bit unsigned int scalar"; } const uint32_t group_count_z = _.GetOperandTypeId(inst, 2); if (!_.IsUnsignedIntScalarType(group_count_z) || _.GetBitWidth(group_count_z) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Group Count Z must be a 32-bit unsigned int scalar"; } if (inst->operands().size() == 4) { const auto payload = _.FindDef(inst->GetOperandAs(3)); if (payload->opcode() != spv::Op::OpVariable) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Payload must be the result of a OpVariable"; } if (payload->GetOperandAs(2) != spv::StorageClass::TaskPayloadWorkgroupEXT) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Payload OpVariable must have a storage class of " "TaskPayloadWorkgroupEXT"; } } break; } case spv::Op::OpSetMeshOutputsEXT: { _.function(inst->function()->id()) ->RegisterExecutionModelLimitation( [](spv::ExecutionModel model, std::string* message) { if (model != spv::ExecutionModel::MeshEXT) { if (message) { *message = "OpSetMeshOutputsEXT requires MeshEXT execution model"; } return false; } return true; }); const uint32_t vertex_count = _.GetOperandTypeId(inst, 0); if (!_.IsUnsignedIntScalarType(vertex_count) || _.GetBitWidth(vertex_count) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Vertex Count must be a 32-bit unsigned int scalar"; } const uint32_t primitive_count = _.GetOperandTypeId(inst, 1); if (!_.IsUnsignedIntScalarType(primitive_count) || _.GetBitWidth(primitive_count) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Primitive Count must be a 32-bit unsigned int scalar"; } break; } case spv::Op::OpWritePackedPrimitiveIndices4x8NV: { // No validation rules (for the moment). break; } case spv::Op::OpVariable: { if (_.HasCapability(spv::Capability::MeshShadingEXT)) { bool meshInterfaceVar = IsInterfaceVariable(_, inst, spv::ExecutionModel::MeshEXT); bool fragInterfaceVar = IsInterfaceVariable(_, inst, spv::ExecutionModel::Fragment); const spv::StorageClass storage_class = inst->GetOperandAs(2); bool storage_output = (storage_class == spv::StorageClass::Output); bool storage_input = (storage_class == spv::StorageClass::Input); if (_.HasDecoration(inst->id(), spv::Decoration::PerPrimitiveEXT)) { if (fragInterfaceVar && !storage_input) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "PerPrimitiveEXT decoration must be applied only to " "variables in the Input Storage Class in the Fragment " "Execution Model."; } if (meshInterfaceVar && !storage_output) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(4336) << "PerPrimitiveEXT decoration must be applied only to " "variables in the Output Storage Class in the " "Storage Class in the MeshEXT Execution Model."; } } } break; } default: break; } return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_misc.cpp000066400000000000000000000170721475742701700241320ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // Copyright (c) 2019 NVIDIA Corporation // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/val/validate.h" #include "source/opcode.h" #include "source/spirv_target_env.h" #include "source/val/instruction.h" #include "source/val/validate_scopes.h" #include "source/val/validation_state.h" namespace spvtools { namespace val { namespace { spv_result_t ValidateUndef(ValidationState_t& _, const Instruction* inst) { if (_.IsVoidType(inst->type_id())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Cannot create undefined values with void type"; } if (_.HasCapability(spv::Capability::Shader) && _.ContainsLimitedUseIntOrFloatType(inst->type_id()) && !_.IsPointerType(inst->type_id())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Cannot create undefined values with 8- or 16-bit types"; } return SPV_SUCCESS; } spv_result_t ValidateShaderClock(ValidationState_t& _, const Instruction* inst) { const uint32_t scope = inst->GetOperandAs(2); if (auto error = ValidateScope(_, inst, scope)) { return error; } bool is_int32 = false, is_const_int32 = false; uint32_t value = 0; std::tie(is_int32, is_const_int32, value) = _.EvalInt32IfConst(scope); if (is_const_int32) { spv::Scope scope_val{value}; if (spvIsVulkanEnv(_.context()->target_env)) { if (scope_val != spv::Scope::Subgroup && scope_val != spv::Scope::Device) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(4652) << "Scope must be Subgroup or Device"; } } else if (spvIsOpenCLEnv(_.context()->target_env)) { if (scope_val != spv::Scope::Workgroup && scope_val != spv::Scope::Subgroup && scope_val != spv::Scope::Device) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Scope must be Subgroup, Workgroup, or Device"; } } } // Result Type must be a 64 - bit unsigned integer type or // a vector of two - components of 32 - // bit unsigned integer type const uint32_t result_type = inst->type_id(); if (!_.IsUnsigned64BitHandle(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Value to be a " "vector of two components" " of unsigned integer" " or 64bit unsigned integer"; } return SPV_SUCCESS; } spv_result_t ValidateAssumeTrue(ValidationState_t& _, const Instruction* inst) { const auto operand_type_id = _.GetOperandTypeId(inst, 0); if (!operand_type_id || !_.IsBoolScalarType(operand_type_id)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Value operand of OpAssumeTrueKHR must be a boolean scalar"; } return SPV_SUCCESS; } spv_result_t ValidateExpect(ValidationState_t& _, const Instruction* inst) { const auto result_type = inst->type_id(); if (!_.IsBoolScalarOrVectorType(result_type) && !_.IsIntScalarOrVectorType(result_type)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Result of OpExpectKHR must be a scalar or vector of integer " "type or boolean type"; } if (_.GetOperandTypeId(inst, 2) != result_type) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Type of Value operand of OpExpectKHR does not match the result " "type "; } if (_.GetOperandTypeId(inst, 3) != result_type) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Type of ExpectedValue operand of OpExpectKHR does not match the " "result type "; } return SPV_SUCCESS; } } // namespace spv_result_t MiscPass(ValidationState_t& _, const Instruction* inst) { switch (inst->opcode()) { case spv::Op::OpUndef: if (auto error = ValidateUndef(_, inst)) return error; break; default: break; } switch (inst->opcode()) { case spv::Op::OpBeginInvocationInterlockEXT: case spv::Op::OpEndInvocationInterlockEXT: _.function(inst->function()->id()) ->RegisterExecutionModelLimitation( spv::ExecutionModel::Fragment, "OpBeginInvocationInterlockEXT/OpEndInvocationInterlockEXT " "require Fragment execution model"); _.function(inst->function()->id()) ->RegisterLimitation([](const ValidationState_t& state, const Function* entry_point, std::string* message) { const auto* execution_modes = state.GetExecutionModes(entry_point->id()); auto find_interlock = [](const spv::ExecutionMode& mode) { switch (mode) { case spv::ExecutionMode::PixelInterlockOrderedEXT: case spv::ExecutionMode::PixelInterlockUnorderedEXT: case spv::ExecutionMode::SampleInterlockOrderedEXT: case spv::ExecutionMode::SampleInterlockUnorderedEXT: case spv::ExecutionMode::ShadingRateInterlockOrderedEXT: case spv::ExecutionMode::ShadingRateInterlockUnorderedEXT: return true; default: return false; } }; bool found = false; if (execution_modes) { auto i = std::find_if(execution_modes->begin(), execution_modes->end(), find_interlock); found = (i != execution_modes->end()); } if (!found) { *message = "OpBeginInvocationInterlockEXT/OpEndInvocationInterlockEXT " "require a fragment shader interlock execution mode."; return false; } return true; }); break; case spv::Op::OpDemoteToHelperInvocationEXT: _.function(inst->function()->id()) ->RegisterExecutionModelLimitation( spv::ExecutionModel::Fragment, "OpDemoteToHelperInvocationEXT requires Fragment execution " "model"); break; case spv::Op::OpIsHelperInvocationEXT: { const uint32_t result_type = inst->type_id(); _.function(inst->function()->id()) ->RegisterExecutionModelLimitation( spv::ExecutionModel::Fragment, "OpIsHelperInvocationEXT requires Fragment execution model"); if (!_.IsBoolScalarType(result_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected bool scalar type as Result Type: " << spvOpcodeString(inst->opcode()); break; } case spv::Op::OpReadClockKHR: if (auto error = ValidateShaderClock(_, inst)) { return error; } break; case spv::Op::OpAssumeTrueKHR: if (auto error = ValidateAssumeTrue(_, inst)) { return error; } break; case spv::Op::OpExpectKHR: if (auto error = ValidateExpect(_, inst)) { return error; } break; default: break; } return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_mode_setting.cpp000066400000000000000000001221041475742701700256510ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // Modifications Copyright (C) 2024 Advanced Micro Devices, Inc. All rights // reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // #include #include "source/opcode.h" #include "source/spirv_target_env.h" #include "source/val/instruction.h" #include "source/val/validate.h" #include "source/val/validation_state.h" namespace spvtools { namespace val { namespace { spv_result_t ValidateEntryPoint(ValidationState_t& _, const Instruction* inst) { const auto entry_point_id = inst->GetOperandAs(1); auto entry_point = _.FindDef(entry_point_id); if (!entry_point || spv::Op::OpFunction != entry_point->opcode()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpEntryPoint Entry Point " << _.getIdName(entry_point_id) << " is not a function."; } // Only check the shader execution models const spv::ExecutionModel execution_model = inst->GetOperandAs(0); if (execution_model != spv::ExecutionModel::Kernel) { const auto entry_point_type_id = entry_point->GetOperandAs(3); const auto entry_point_type = _.FindDef(entry_point_type_id); if (!entry_point_type || 3 != entry_point_type->words().size()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << _.VkErrorID(4633) << "OpEntryPoint Entry Point " << _.getIdName(entry_point_id) << "s function parameter count is not zero."; } } auto return_type = _.FindDef(entry_point->type_id()); if (!return_type || spv::Op::OpTypeVoid != return_type->opcode()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << _.VkErrorID(4633) << "OpEntryPoint Entry Point " << _.getIdName(entry_point_id) << "s function return type is not void."; } const auto* execution_modes = _.GetExecutionModes(entry_point_id); if (_.HasCapability(spv::Capability::Shader)) { switch (execution_model) { case spv::ExecutionModel::Fragment: if (execution_modes && execution_modes->count(spv::ExecutionMode::OriginUpperLeft) && execution_modes->count(spv::ExecutionMode::OriginLowerLeft)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Fragment execution model entry points can only specify " "one of OriginUpperLeft or OriginLowerLeft execution " "modes."; } if (!execution_modes || (!execution_modes->count(spv::ExecutionMode::OriginUpperLeft) && !execution_modes->count(spv::ExecutionMode::OriginLowerLeft))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Fragment execution model entry points require either an " "OriginUpperLeft or OriginLowerLeft execution mode."; } if (execution_modes && 1 < std::count_if(execution_modes->begin(), execution_modes->end(), [](const spv::ExecutionMode& mode) { switch (mode) { case spv::ExecutionMode::DepthGreater: case spv::ExecutionMode::DepthLess: case spv::ExecutionMode::DepthUnchanged: return true; default: return false; } })) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Fragment execution model entry points can specify at most " "one of DepthGreater, DepthLess or DepthUnchanged " "execution modes."; } if (execution_modes && 1 < std::count_if( execution_modes->begin(), execution_modes->end(), [](const spv::ExecutionMode& mode) { switch (mode) { case spv::ExecutionMode::PixelInterlockOrderedEXT: case spv::ExecutionMode::PixelInterlockUnorderedEXT: case spv::ExecutionMode::SampleInterlockOrderedEXT: case spv::ExecutionMode::SampleInterlockUnorderedEXT: case spv::ExecutionMode::ShadingRateInterlockOrderedEXT: case spv::ExecutionMode:: ShadingRateInterlockUnorderedEXT: return true; default: return false; } })) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Fragment execution model entry points can specify at most " "one fragment shader interlock execution mode."; } if (execution_modes && 1 < std::count_if( execution_modes->begin(), execution_modes->end(), [](const spv::ExecutionMode& mode) { switch (mode) { case spv::ExecutionMode::StencilRefUnchangedFrontAMD: case spv::ExecutionMode::StencilRefLessFrontAMD: case spv::ExecutionMode::StencilRefGreaterFrontAMD: return true; default: return false; } })) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Fragment execution model entry points can specify at most " "one of StencilRefUnchangedFrontAMD, " "StencilRefLessFrontAMD or StencilRefGreaterFrontAMD " "execution modes."; } if (execution_modes && 1 < std::count_if( execution_modes->begin(), execution_modes->end(), [](const spv::ExecutionMode& mode) { switch (mode) { case spv::ExecutionMode::StencilRefUnchangedBackAMD: case spv::ExecutionMode::StencilRefLessBackAMD: case spv::ExecutionMode::StencilRefGreaterBackAMD: return true; default: return false; } })) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Fragment execution model entry points can specify at most " "one of StencilRefUnchangedBackAMD, " "StencilRefLessBackAMD or StencilRefGreaterBackAMD " "execution modes."; } break; case spv::ExecutionModel::TessellationControl: case spv::ExecutionModel::TessellationEvaluation: if (execution_modes && 1 < std::count_if( execution_modes->begin(), execution_modes->end(), [](const spv::ExecutionMode& mode) { switch (mode) { case spv::ExecutionMode::SpacingEqual: case spv::ExecutionMode::SpacingFractionalEven: case spv::ExecutionMode::SpacingFractionalOdd: return true; default: return false; } })) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Tessellation execution model entry points can specify at " "most one of SpacingEqual, SpacingFractionalOdd or " "SpacingFractionalEven execution modes."; } if (execution_modes && 1 < std::count_if(execution_modes->begin(), execution_modes->end(), [](const spv::ExecutionMode& mode) { switch (mode) { case spv::ExecutionMode::Triangles: case spv::ExecutionMode::Quads: case spv::ExecutionMode::Isolines: return true; default: return false; } })) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Tessellation execution model entry points can specify at " "most one of Triangles, Quads or Isolines execution modes."; } if (execution_modes && 1 < std::count_if(execution_modes->begin(), execution_modes->end(), [](const spv::ExecutionMode& mode) { switch (mode) { case spv::ExecutionMode::VertexOrderCw: case spv::ExecutionMode::VertexOrderCcw: return true; default: return false; } })) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Tessellation execution model entry points can specify at " "most one of VertexOrderCw or VertexOrderCcw execution " "modes."; } break; case spv::ExecutionModel::Geometry: if (!execution_modes || 1 != std::count_if( execution_modes->begin(), execution_modes->end(), [](const spv::ExecutionMode& mode) { switch (mode) { case spv::ExecutionMode::InputPoints: case spv::ExecutionMode::InputLines: case spv::ExecutionMode::InputLinesAdjacency: case spv::ExecutionMode::Triangles: case spv::ExecutionMode::InputTrianglesAdjacency: return true; default: return false; } })) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Geometry execution model entry points must specify " "exactly one of InputPoints, InputLines, " "InputLinesAdjacency, Triangles or InputTrianglesAdjacency " "execution modes."; } if (!execution_modes || 1 != std::count_if(execution_modes->begin(), execution_modes->end(), [](const spv::ExecutionMode& mode) { switch (mode) { case spv::ExecutionMode::OutputPoints: case spv::ExecutionMode::OutputLineStrip: case spv::ExecutionMode::OutputTriangleStrip: return true; default: return false; } })) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Geometry execution model entry points must specify " "exactly one of OutputPoints, OutputLineStrip or " "OutputTriangleStrip execution modes."; } break; case spv::ExecutionModel::MeshEXT: if (!execution_modes || 1 != std::count_if(execution_modes->begin(), execution_modes->end(), [](const spv::ExecutionMode& mode) { switch (mode) { case spv::ExecutionMode::OutputPoints: case spv::ExecutionMode::OutputLinesEXT: case spv::ExecutionMode::OutputTrianglesEXT: return true; default: return false; } })) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "MeshEXT execution model entry points must specify exactly " "one of OutputPoints, OutputLinesEXT, or " "OutputTrianglesEXT Execution Modes."; } else if (2 != std::count_if( execution_modes->begin(), execution_modes->end(), [](const spv::ExecutionMode& mode) { switch (mode) { case spv::ExecutionMode::OutputPrimitivesEXT: case spv::ExecutionMode::OutputVertices: return true; default: return false; } })) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "MeshEXT execution model entry points must specify both " "OutputPrimitivesEXT and OutputVertices Execution Modes."; } break; default: break; } } if (spvIsVulkanEnv(_.context()->target_env)) { switch (execution_model) { case spv::ExecutionModel::GLCompute: if (!execution_modes || !execution_modes->count(spv::ExecutionMode::LocalSize)) { bool ok = false; for (auto& i : _.ordered_instructions()) { if (i.opcode() == spv::Op::OpDecorate) { if (i.operands().size() > 2) { if (i.GetOperandAs(1) == spv::Decoration::BuiltIn && i.GetOperandAs(2) == spv::BuiltIn::WorkgroupSize) { ok = true; break; } } } if (i.opcode() == spv::Op::OpExecutionModeId) { const auto mode = i.GetOperandAs(1); if (mode == spv::ExecutionMode::LocalSizeId) { ok = true; break; } } } if (!ok) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(6426) << "In the Vulkan environment, GLCompute execution model " "entry points require either the LocalSize or " "LocalSizeId execution mode or an object decorated with " "WorkgroupSize must be specified."; } } break; default: break; } } if (_.EntryPointHasLocalSizeOrId(entry_point_id)) { const Instruction* local_size_inst = _.EntryPointLocalSizeOrId(entry_point_id); if (local_size_inst) { const auto mode = local_size_inst->GetOperandAs(1); const uint32_t operand_x = local_size_inst->GetOperandAs(2); const uint32_t operand_y = local_size_inst->GetOperandAs(3); const uint32_t operand_z = local_size_inst->GetOperandAs(4); if (mode == spv::ExecutionMode::LocalSize) { if ((operand_x * operand_y * operand_z) == 0) { return _.diag(SPV_ERROR_INVALID_DATA, local_size_inst) << "Local Size execution mode must not have a product of zero " "(X " "= " << operand_x << ", Y = " << operand_y << ", Z = " << operand_z << ")."; } } else if (mode == spv::ExecutionMode::LocalSizeId) { // can only validate product if static and not spec constant // (This is done for us in EvalConstantValUint64) uint64_t x_size, y_size, z_size; bool static_x = _.EvalConstantValUint64(operand_x, &x_size); bool static_y = _.EvalConstantValUint64(operand_y, &y_size); bool static_z = _.EvalConstantValUint64(operand_z, &z_size); if (static_x && static_y && static_z && ((x_size * y_size * z_size) == 0)) { return _.diag(SPV_ERROR_INVALID_DATA, local_size_inst) << "Local Size Id execution mode must not have a product of " "zero " "(X = " << x_size << ", Y = " << y_size << ", Z = " << z_size << ")."; } } } } return SPV_SUCCESS; } spv_result_t ValidateExecutionMode(ValidationState_t& _, const Instruction* inst) { const auto entry_point_id = inst->GetOperandAs(0); const auto found = std::find(_.entry_points().cbegin(), _.entry_points().cend(), entry_point_id); if (found == _.entry_points().cend()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpExecutionMode Entry Point " << _.getIdName(entry_point_id) << " is not the Entry Point " "operand of an OpEntryPoint."; } const auto mode = inst->GetOperandAs(1); if (inst->opcode() == spv::Op::OpExecutionModeId) { bool valid_mode = false; switch (mode) { case spv::ExecutionMode::SubgroupsPerWorkgroupId: case spv::ExecutionMode::LocalSizeHintId: case spv::ExecutionMode::LocalSizeId: case spv::ExecutionMode::FPFastMathDefault: case spv::ExecutionMode::MaximumRegistersIdINTEL: case spv::ExecutionMode::IsApiEntryAMDX: case spv::ExecutionMode::MaxNodeRecursionAMDX: case spv::ExecutionMode::MaxNumWorkgroupsAMDX: case spv::ExecutionMode::ShaderIndexAMDX: case spv::ExecutionMode::SharesInputWithAMDX: case spv::ExecutionMode::StaticNumWorkgroupsAMDX: valid_mode = true; break; default: valid_mode = false; break; } if (!valid_mode) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpExecutionModeId is only valid when the Mode operand is an " "execution mode that takes Extra Operands that are id " "operands."; } size_t operand_count = inst->operands().size(); for (size_t i = 2; i < operand_count; ++i) { const auto operand_id = inst->GetOperandAs(i); const auto* operand_inst = _.FindDef(operand_id); switch (mode) { case spv::ExecutionMode::SubgroupsPerWorkgroupId: case spv::ExecutionMode::LocalSizeHintId: case spv::ExecutionMode::LocalSizeId: case spv::ExecutionMode::IsApiEntryAMDX: case spv::ExecutionMode::MaxNodeRecursionAMDX: case spv::ExecutionMode::MaxNumWorkgroupsAMDX: case spv::ExecutionMode::ShaderIndexAMDX: case spv::ExecutionMode::SharesInputWithAMDX: case spv::ExecutionMode::StaticNumWorkgroupsAMDX: if (!spvOpcodeIsConstant(operand_inst->opcode())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "For OpExecutionModeId all Extra Operand ids must be " "constant instructions."; } break; case spv::ExecutionMode::FPFastMathDefault: if (i == 2) { if (!_.IsFloatScalarType(operand_id)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "The Target Type operand must be a floating-point " "scalar type"; } } else { bool is_int32 = false; bool is_const = false; uint32_t value = 0; std::tie(is_int32, is_const, value) = _.EvalInt32IfConst(operand_id); if (is_int32 && is_const) { // Valid values include up to 0x00040000 (AllowTransform). uint32_t invalid_mask = 0xfff80000; if ((invalid_mask & value) != 0) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "The Fast Math Default operand is an invalid bitmask " "value"; } if (value & static_cast(spv::FPFastMathModeMask::Fast)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "The Fast Math Default operand must not include Fast"; } const auto reassoc_contract = spv::FPFastMathModeMask::AllowContract | spv::FPFastMathModeMask::AllowReassoc; if ((value & static_cast( spv::FPFastMathModeMask::AllowTransform)) != 0 && ((value & static_cast(reassoc_contract)) != static_cast(reassoc_contract))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "The Fast Math Default operand must include " "AllowContract and AllowReassoc when AllowTransform " "is specified"; } } else { return _.diag(SPV_ERROR_INVALID_ID, inst) << "The Fast Math Default operand must be a " "non-specialization constant"; } } break; default: break; } } } else if (mode == spv::ExecutionMode::SubgroupsPerWorkgroupId || mode == spv::ExecutionMode::LocalSizeHintId || mode == spv::ExecutionMode::LocalSizeId || mode == spv::ExecutionMode::FPFastMathDefault || mode == spv::ExecutionMode::IsApiEntryAMDX || mode == spv::ExecutionMode::MaxNodeRecursionAMDX || mode == spv::ExecutionMode::MaxNumWorkgroupsAMDX || mode == spv::ExecutionMode::ShaderIndexAMDX || mode == spv::ExecutionMode::SharesInputWithAMDX || mode == spv::ExecutionMode::StaticNumWorkgroupsAMDX) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "OpExecutionMode is only valid when the Mode operand is an " "execution mode that takes no Extra Operands, or takes Extra " "Operands that are not id operands."; } const auto* models = _.GetExecutionModels(entry_point_id); switch (mode) { case spv::ExecutionMode::Invocations: case spv::ExecutionMode::InputPoints: case spv::ExecutionMode::InputLines: case spv::ExecutionMode::InputLinesAdjacency: case spv::ExecutionMode::InputTrianglesAdjacency: case spv::ExecutionMode::OutputLineStrip: case spv::ExecutionMode::OutputTriangleStrip: if (!std::all_of(models->begin(), models->end(), [](const spv::ExecutionModel& model) { return model == spv::ExecutionModel::Geometry; })) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Execution mode can only be used with the Geometry execution " "model."; } break; case spv::ExecutionMode::OutputPoints: if (!std::all_of( models->begin(), models->end(), [&_](const spv::ExecutionModel& model) { switch (model) { case spv::ExecutionModel::Geometry: return true; case spv::ExecutionModel::MeshNV: return _.HasCapability(spv::Capability::MeshShadingNV); case spv::ExecutionModel::MeshEXT: return _.HasCapability(spv::Capability::MeshShadingEXT); default: return false; } })) { if (_.HasCapability(spv::Capability::MeshShadingNV) || _.HasCapability(spv::Capability::MeshShadingEXT)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Execution mode can only be used with the Geometry " "MeshNV or MeshEXT execution model."; } else { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Execution mode can only be used with the Geometry " "execution " "model."; } } break; case spv::ExecutionMode::SpacingEqual: case spv::ExecutionMode::SpacingFractionalEven: case spv::ExecutionMode::SpacingFractionalOdd: case spv::ExecutionMode::VertexOrderCw: case spv::ExecutionMode::VertexOrderCcw: case spv::ExecutionMode::PointMode: case spv::ExecutionMode::Quads: case spv::ExecutionMode::Isolines: if (!std::all_of( models->begin(), models->end(), [](const spv::ExecutionModel& model) { return (model == spv::ExecutionModel::TessellationControl) || (model == spv::ExecutionModel::TessellationEvaluation); })) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Execution mode can only be used with a tessellation " "execution model."; } break; case spv::ExecutionMode::Triangles: if (!std::all_of(models->begin(), models->end(), [](const spv::ExecutionModel& model) { switch (model) { case spv::ExecutionModel::Geometry: case spv::ExecutionModel::TessellationControl: case spv::ExecutionModel::TessellationEvaluation: return true; default: return false; } })) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Execution mode can only be used with a Geometry or " "tessellation execution model."; } break; case spv::ExecutionMode::OutputVertices: if (!std::all_of( models->begin(), models->end(), [&_](const spv::ExecutionModel& model) { switch (model) { case spv::ExecutionModel::Geometry: case spv::ExecutionModel::TessellationControl: case spv::ExecutionModel::TessellationEvaluation: return true; case spv::ExecutionModel::MeshNV: return _.HasCapability(spv::Capability::MeshShadingNV); case spv::ExecutionModel::MeshEXT: return _.HasCapability(spv::Capability::MeshShadingEXT); default: return false; } })) { if (_.HasCapability(spv::Capability::MeshShadingNV) || _.HasCapability(spv::Capability::MeshShadingEXT)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Execution mode can only be used with a Geometry, " "tessellation, MeshNV or MeshEXT execution model."; } else { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Execution mode can only be used with a Geometry or " "tessellation execution model."; } } if (spvIsVulkanEnv(_.context()->target_env)) { if (_.HasCapability(spv::Capability::MeshShadingEXT) && inst->GetOperandAs(2) == 0) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(7330) << "In mesh shaders using the MeshEXT Execution Model the " "OutputVertices Execution Mode must be greater than 0"; } } break; case spv::ExecutionMode::OutputLinesEXT: case spv::ExecutionMode::OutputTrianglesEXT: case spv::ExecutionMode::OutputPrimitivesEXT: if (!std::all_of(models->begin(), models->end(), [](const spv::ExecutionModel& model) { return (model == spv::ExecutionModel::MeshEXT || model == spv::ExecutionModel::MeshNV); })) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Execution mode can only be used with the MeshEXT or MeshNV " "execution " "model."; } if (mode == spv::ExecutionMode::OutputPrimitivesEXT && spvIsVulkanEnv(_.context()->target_env)) { if (_.HasCapability(spv::Capability::MeshShadingEXT) && inst->GetOperandAs(2) == 0) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(7331) << "In mesh shaders using the MeshEXT Execution Model the " "OutputPrimitivesEXT Execution Mode must be greater than 0"; } } break; case spv::ExecutionMode::QuadDerivativesKHR: if (!std::all_of(models->begin(), models->end(), [](const spv::ExecutionModel& model) { return (model == spv::ExecutionModel::Fragment || model == spv::ExecutionModel::GLCompute); })) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Execution mode can only be used with the Fragment or " "GLCompute execution model."; } break; case spv::ExecutionMode::PixelCenterInteger: case spv::ExecutionMode::OriginUpperLeft: case spv::ExecutionMode::OriginLowerLeft: case spv::ExecutionMode::EarlyFragmentTests: case spv::ExecutionMode::DepthReplacing: case spv::ExecutionMode::DepthGreater: case spv::ExecutionMode::DepthLess: case spv::ExecutionMode::DepthUnchanged: case spv::ExecutionMode::NonCoherentColorAttachmentReadEXT: case spv::ExecutionMode::NonCoherentDepthAttachmentReadEXT: case spv::ExecutionMode::NonCoherentStencilAttachmentReadEXT: case spv::ExecutionMode::PixelInterlockOrderedEXT: case spv::ExecutionMode::PixelInterlockUnorderedEXT: case spv::ExecutionMode::SampleInterlockOrderedEXT: case spv::ExecutionMode::SampleInterlockUnorderedEXT: case spv::ExecutionMode::ShadingRateInterlockOrderedEXT: case spv::ExecutionMode::ShadingRateInterlockUnorderedEXT: case spv::ExecutionMode::EarlyAndLateFragmentTestsAMD: case spv::ExecutionMode::StencilRefUnchangedFrontAMD: case spv::ExecutionMode::StencilRefGreaterFrontAMD: case spv::ExecutionMode::StencilRefLessFrontAMD: case spv::ExecutionMode::StencilRefUnchangedBackAMD: case spv::ExecutionMode::StencilRefGreaterBackAMD: case spv::ExecutionMode::StencilRefLessBackAMD: case spv::ExecutionMode::RequireFullQuadsKHR: if (!std::all_of(models->begin(), models->end(), [](const spv::ExecutionModel& model) { return model == spv::ExecutionModel::Fragment; })) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Execution mode can only be used with the Fragment execution " "model."; } break; case spv::ExecutionMode::LocalSizeHint: case spv::ExecutionMode::VecTypeHint: case spv::ExecutionMode::ContractionOff: case spv::ExecutionMode::LocalSizeHintId: if (!std::all_of(models->begin(), models->end(), [](const spv::ExecutionModel& model) { return model == spv::ExecutionModel::Kernel; })) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Execution mode can only be used with the Kernel execution " "model."; } break; case spv::ExecutionMode::LocalSize: case spv::ExecutionMode::LocalSizeId: if (mode == spv::ExecutionMode::LocalSizeId && !_.IsLocalSizeIdAllowed()) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "LocalSizeId mode is not allowed by the current environment."; if (!std::all_of( models->begin(), models->end(), [&_](const spv::ExecutionModel& model) { switch (model) { case spv::ExecutionModel::Kernel: case spv::ExecutionModel::GLCompute: return true; case spv::ExecutionModel::TaskNV: case spv::ExecutionModel::MeshNV: return _.HasCapability(spv::Capability::MeshShadingNV); case spv::ExecutionModel::TaskEXT: case spv::ExecutionModel::MeshEXT: return _.HasCapability(spv::Capability::MeshShadingEXT); default: return false; } })) { if (_.HasCapability(spv::Capability::MeshShadingNV) || _.HasCapability(spv::Capability::MeshShadingEXT)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Execution mode can only be used with a Kernel, GLCompute, " "MeshNV, MeshEXT, TaskNV or TaskEXT execution model."; } else { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Execution mode can only be used with a Kernel or " "GLCompute " "execution model."; } } default: break; } if (mode == spv::ExecutionMode::FPFastMathDefault) { const auto* modes = _.GetExecutionModes(entry_point_id); if (modes && modes->count(spv::ExecutionMode::ContractionOff)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "FPFastMathDefault and ContractionOff execution modes cannot " "be applied to the same entry point"; } if (modes && modes->count(spv::ExecutionMode::SignedZeroInfNanPreserve)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "FPFastMathDefault and SignedZeroInfNanPreserve execution " "modes cannot be applied to the same entry point"; } } if (spvIsVulkanEnv(_.context()->target_env)) { if (mode == spv::ExecutionMode::OriginLowerLeft) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(4653) << "In the Vulkan environment, the OriginLowerLeft execution mode " "must not be used."; } if (mode == spv::ExecutionMode::PixelCenterInteger) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(4654) << "In the Vulkan environment, the PixelCenterInteger execution " "mode must not be used."; } } return SPV_SUCCESS; } spv_result_t ValidateMemoryModel(ValidationState_t& _, const Instruction* inst) { // Already produced an error if multiple memory model instructions are // present. if (_.memory_model() != spv::MemoryModel::VulkanKHR && _.HasCapability(spv::Capability::VulkanMemoryModelKHR)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "VulkanMemoryModelKHR capability must only be specified if " "the VulkanKHR memory model is used."; } if (spvIsOpenCLEnv(_.context()->target_env)) { if ((_.addressing_model() != spv::AddressingModel::Physical32) && (_.addressing_model() != spv::AddressingModel::Physical64)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Addressing model must be Physical32 or Physical64 " << "in the OpenCL environment."; } if (_.memory_model() != spv::MemoryModel::OpenCL) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Memory model must be OpenCL in the OpenCL environment."; } } if (spvIsVulkanEnv(_.context()->target_env)) { if ((_.addressing_model() != spv::AddressingModel::Logical) && (_.addressing_model() != spv::AddressingModel::PhysicalStorageBuffer64)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(4635) << "Addressing model must be Logical or PhysicalStorageBuffer64 " << "in the Vulkan environment."; } } return SPV_SUCCESS; } bool PerEntryExecutionMode(spv::ExecutionMode mode) { switch (mode) { // These execution modes can be specified multiple times per entry point. case spv::ExecutionMode::DenormPreserve: case spv::ExecutionMode::DenormFlushToZero: case spv::ExecutionMode::SignedZeroInfNanPreserve: case spv::ExecutionMode::RoundingModeRTE: case spv::ExecutionMode::RoundingModeRTZ: case spv::ExecutionMode::FPFastMathDefault: case spv::ExecutionMode::RoundingModeRTPINTEL: case spv::ExecutionMode::RoundingModeRTNINTEL: case spv::ExecutionMode::FloatingPointModeALTINTEL: case spv::ExecutionMode::FloatingPointModeIEEEINTEL: return false; default: return true; } } } // namespace spv_result_t ValidateFloatControls2(ValidationState_t& _) { std::unordered_set fp_fast_math_default_entry_points; for (auto entry_point : _.entry_points()) { const auto* exec_modes = _.GetExecutionModes(entry_point); if (exec_modes && exec_modes->count(spv::ExecutionMode::FPFastMathDefault)) { fp_fast_math_default_entry_points.insert(entry_point); } } std::vector> worklist; for (const auto& inst : _.ordered_instructions()) { if (inst.opcode() != spv::Op::OpDecorate) { continue; } const auto decoration = inst.GetOperandAs(1); const auto target_id = inst.GetOperandAs(0); const auto target = _.FindDef(target_id); if (decoration == spv::Decoration::NoContraction) { worklist.push_back(std::make_pair(target, decoration)); } else if (decoration == spv::Decoration::FPFastMathMode) { auto mask = inst.GetOperandAs(2); if ((mask & spv::FPFastMathModeMask::Fast) != spv::FPFastMathModeMask::MaskNone) { worklist.push_back(std::make_pair(target, decoration)); } } } std::unordered_set visited; while (!worklist.empty()) { const auto inst = worklist.back().first; const auto decoration = worklist.back().second; worklist.pop_back(); if (!visited.insert(inst).second) { continue; } const auto function = inst->function(); if (function) { const auto& entry_points = _.FunctionEntryPoints(function->id()); for (auto entry_point : entry_points) { if (fp_fast_math_default_entry_points.count(entry_point)) { const std::string dec = decoration == spv::Decoration::NoContraction ? "NoContraction" : "FPFastMathMode Fast"; return _.diag(SPV_ERROR_INVALID_DATA, inst) << dec << " cannot be used by an entry point with the " "FPFastMathDefault execution mode"; } } } else { for (const auto& pair : inst->uses()) { worklist.push_back(std::make_pair(pair.first, decoration)); } } } return SPV_SUCCESS; } spv_result_t ModeSettingPass(ValidationState_t& _, const Instruction* inst) { switch (inst->opcode()) { case spv::Op::OpEntryPoint: if (auto error = ValidateEntryPoint(_, inst)) return error; break; case spv::Op::OpExecutionMode: case spv::Op::OpExecutionModeId: if (auto error = ValidateExecutionMode(_, inst)) return error; break; case spv::Op::OpMemoryModel: if (auto error = ValidateMemoryModel(_, inst)) return error; break; default: break; } return SPV_SUCCESS; } spv_result_t ValidateDuplicateExecutionModes(ValidationState_t& _) { using PerEntryKey = std::tuple; using PerOperandKey = std::tuple; std::set seen_per_entry; std::set seen_per_operand; const auto lookupMode = [&_](spv::ExecutionMode mode) -> std::string { spv_operand_desc desc = nullptr; if (_.grammar().lookupOperand(SPV_OPERAND_TYPE_EXECUTION_MODE, static_cast(mode), &desc) == SPV_SUCCESS) { return std::string(desc->name); } return "Unknown"; }; for (const auto& inst : _.ordered_instructions()) { if (inst.opcode() != spv::Op::OpExecutionMode && inst.opcode() != spv::Op::OpExecutionModeId) { continue; } const auto entry = inst.GetOperandAs(0); const auto mode = inst.GetOperandAs(1); if (PerEntryExecutionMode(mode)) { if (!seen_per_entry.insert(std::make_tuple(mode, entry)).second) { return _.diag(SPV_ERROR_INVALID_ID, &inst) << lookupMode(mode) << " execution mode must not be specified multiple times per " "entry point"; } } else { // Execution modes allowed multiple times all take a single operand. const auto operand = inst.GetOperandAs(2); if (!seen_per_operand.insert(std::make_tuple(mode, entry, operand)) .second) { return _.diag(SPV_ERROR_INVALID_ID, &inst) << lookupMode(mode) << " execution mode must not be specified multiple times for " "the same entry point and operands"; } } } return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_non_uniform.cpp000066400000000000000000000450751475742701700255340ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validates correctness of barrier SPIR-V instructions. #include "source/opcode.h" #include "source/spirv_constant.h" #include "source/spirv_target_env.h" #include "source/val/instruction.h" #include "source/val/validate.h" #include "source/val/validate_scopes.h" #include "source/val/validation_state.h" namespace spvtools { namespace val { namespace { spv_result_t ValidateGroupNonUniformElect(ValidationState_t& _, const Instruction* inst) { if (!_.IsBoolScalarType(inst->type_id())) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Result must be a boolean scalar type"; } return SPV_SUCCESS; } spv_result_t ValidateGroupNonUniformAnyAll(ValidationState_t& _, const Instruction* inst) { if (!_.IsBoolScalarType(inst->type_id())) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Result must be a boolean scalar type"; } if (!_.IsBoolScalarType(_.GetOperandTypeId(inst, 3))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Predicate must be a boolean scalar type"; } return SPV_SUCCESS; } spv_result_t ValidateGroupNonUniformAllEqual(ValidationState_t& _, const Instruction* inst) { if (!_.IsBoolScalarType(inst->type_id())) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Result must be a boolean scalar type"; } const auto value_type = _.GetOperandTypeId(inst, 3); if (!_.IsFloatScalarOrVectorType(value_type) && !_.IsIntScalarOrVectorType(value_type) && !_.IsBoolScalarOrVectorType(value_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Value must be a scalar or vector of integer, floating-point, or " "boolean type"; } return SPV_SUCCESS; } spv_result_t ValidateGroupNonUniformBroadcastShuffle(ValidationState_t& _, const Instruction* inst) { const auto type_id = inst->type_id(); if (!_.IsFloatScalarOrVectorType(type_id) && !_.IsIntScalarOrVectorType(type_id) && !_.IsBoolScalarOrVectorType(type_id)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Result must be a scalar or vector of integer, floating-point, " "or boolean type"; } const auto value_type_id = _.GetOperandTypeId(inst, 3); if (value_type_id != type_id) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "The type of Value must match the Result type"; } const auto GetOperandName = [](const spv::Op opcode) { std::string operand; switch (opcode) { case spv::Op::OpGroupNonUniformBroadcast: case spv::Op::OpGroupNonUniformShuffle: operand = "Id"; break; case spv::Op::OpGroupNonUniformShuffleXor: operand = "Mask"; break; case spv::Op::OpGroupNonUniformQuadBroadcast: operand = "Index"; break; case spv::Op::OpGroupNonUniformQuadSwap: operand = "Direction"; break; case spv::Op::OpGroupNonUniformShuffleUp: case spv::Op::OpGroupNonUniformShuffleDown: default: operand = "Delta"; break; } return operand; }; const auto id_type_id = _.GetOperandTypeId(inst, 4); if (!_.IsUnsignedIntScalarType(id_type_id)) { std::string operand = GetOperandName(inst->opcode()); return _.diag(SPV_ERROR_INVALID_DATA, inst) << operand << " must be an unsigned integer scalar"; } const bool should_be_constant = inst->opcode() == spv::Op::OpGroupNonUniformQuadSwap || ((inst->opcode() == spv::Op::OpGroupNonUniformBroadcast || inst->opcode() == spv::Op::OpGroupNonUniformQuadBroadcast) && _.version() < SPV_SPIRV_VERSION_WORD(1, 5)); if (should_be_constant) { const auto id_id = inst->GetOperandAs(4); const auto id_op = _.GetIdOpcode(id_id); if (!spvOpcodeIsConstant(id_op)) { std::string operand = GetOperandName(inst->opcode()); return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Before SPIR-V 1.5, " << operand << " must be a constant instruction"; } } return SPV_SUCCESS; } spv_result_t ValidateGroupNonUniformBroadcastFirst(ValidationState_t& _, const Instruction* inst) { const auto type_id = inst->type_id(); if (!_.IsFloatScalarOrVectorType(type_id) && !_.IsIntScalarOrVectorType(type_id) && !_.IsBoolScalarOrVectorType(type_id)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Result must be a scalar or vector of integer, floating-point, " "or boolean type"; } const auto value_type_id = _.GetOperandTypeId(inst, 3); if (value_type_id != type_id) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "The type of Value must match the Result type"; } return SPV_SUCCESS; } spv_result_t ValidateGroupNonUniformBallot(ValidationState_t& _, const Instruction* inst) { if (!_.IsUnsignedIntVectorType(inst->type_id())) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Result must be a 4-component unsigned integer vector"; } if (_.GetDimension(inst->type_id()) != 4) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Result must be a 4-component unsigned integer vector"; } const auto pred_type_id = _.GetOperandTypeId(inst, 3); if (!_.IsBoolScalarType(pred_type_id)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Predicate must be a boolean scalar"; } return SPV_SUCCESS; } spv_result_t ValidateGroupNonUniformInverseBallot(ValidationState_t& _, const Instruction* inst) { if (!_.IsBoolScalarType(inst->type_id())) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Result must be a boolean scalar"; } const auto value_type_id = _.GetOperandTypeId(inst, 3); if (!_.IsUnsignedIntVectorType(value_type_id)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Value must be a 4-component unsigned integer vector"; } if (_.GetDimension(value_type_id) != 4) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Value must be a 4-component unsigned integer vector"; } return SPV_SUCCESS; } spv_result_t ValidateGroupNonUniformBallotBitExtract(ValidationState_t& _, const Instruction* inst) { if (!_.IsBoolScalarType(inst->type_id())) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Result must be a boolean scalar"; } const auto value_type_id = _.GetOperandTypeId(inst, 3); if (!_.IsUnsignedIntVectorType(value_type_id)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Value must be a 4-component unsigned integer vector"; } if (_.GetDimension(value_type_id) != 4) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Value must be a 4-component unsigned integer vector"; } const auto id_type_id = _.GetOperandTypeId(inst, 4); if (!_.IsUnsignedIntScalarType(id_type_id)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Id must be an unsigned integer scalar"; } return SPV_SUCCESS; } spv_result_t ValidateGroupNonUniformBallotBitCount(ValidationState_t& _, const Instruction* inst) { // Scope is already checked by ValidateExecutionScope() above. const uint32_t result_type = inst->type_id(); if (!_.IsUnsignedIntScalarType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Result Type to be an unsigned integer type scalar."; } const auto value = inst->GetOperandAs(4); const auto value_type = _.FindDef(value)->type_id(); if (!_.IsUnsignedIntVectorType(value_type) || _.GetDimension(value_type) != 4) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Value to be a " "vector of four components " "of integer type scalar"; } const auto group = inst->GetOperandAs(3); if (spvIsVulkanEnv(_.context()->target_env)) { if ((group != spv::GroupOperation::Reduce) && (group != spv::GroupOperation::InclusiveScan) && (group != spv::GroupOperation::ExclusiveScan)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(4685) << "In Vulkan: The OpGroupNonUniformBallotBitCount group " "operation must be only: Reduce, InclusiveScan, or " "ExclusiveScan."; } } return SPV_SUCCESS; } spv_result_t ValidateGroupNonUniformBallotFind(ValidationState_t& _, const Instruction* inst) { if (!_.IsUnsignedIntScalarType(inst->type_id())) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Result must be an unsigned integer scalar"; } const auto value_type_id = _.GetOperandTypeId(inst, 3); if (!_.IsUnsignedIntVectorType(value_type_id)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Value must be a 4-component unsigned integer vector"; } if (_.GetDimension(value_type_id) != 4) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Value must be a 4-component unsigned integer vector"; } return SPV_SUCCESS; } spv_result_t ValidateGroupNonUniformArithmetic(ValidationState_t& _, const Instruction* inst) { const bool is_unsigned = inst->opcode() == spv::Op::OpGroupNonUniformUMin || inst->opcode() == spv::Op::OpGroupNonUniformUMax; const bool is_float = inst->opcode() == spv::Op::OpGroupNonUniformFAdd || inst->opcode() == spv::Op::OpGroupNonUniformFMul || inst->opcode() == spv::Op::OpGroupNonUniformFMin || inst->opcode() == spv::Op::OpGroupNonUniformFMax; const bool is_bool = inst->opcode() == spv::Op::OpGroupNonUniformLogicalAnd || inst->opcode() == spv::Op::OpGroupNonUniformLogicalOr || inst->opcode() == spv::Op::OpGroupNonUniformLogicalXor; if (is_float) { if (!_.IsFloatScalarOrVectorType(inst->type_id())) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Result must be a floating-point scalar or vector"; } } else if (is_bool) { if (!_.IsBoolScalarOrVectorType(inst->type_id())) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Result must be a boolean scalar or vector"; } } else if (is_unsigned) { if (!_.IsUnsignedIntScalarOrVectorType(inst->type_id())) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Result must be an unsigned integer scalar or vector"; } } else if (!_.IsIntScalarOrVectorType(inst->type_id())) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Result must be an integer scalar or vector"; } const auto value_type_id = _.GetOperandTypeId(inst, 4); if (value_type_id != inst->type_id()) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "The type of Value must match the Result type"; } const auto group_op = inst->GetOperandAs(3); bool is_clustered_reduce = group_op == spv::GroupOperation::ClusteredReduce; bool is_partitioned_nv = group_op == spv::GroupOperation::PartitionedReduceNV || group_op == spv::GroupOperation::PartitionedInclusiveScanNV || group_op == spv::GroupOperation::PartitionedExclusiveScanNV; if (inst->operands().size() <= 5) { if (is_clustered_reduce) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "ClusterSize must be present when Operation is ClusteredReduce"; } else if (is_partitioned_nv) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Ballot must be present when Operation is PartitionedReduceNV, " "PartitionedInclusiveScanNV, or PartitionedExclusiveScanNV"; } } else { const auto operand_id = inst->GetOperandAs(5); const auto* operand = _.FindDef(operand_id); if (is_partitioned_nv) { if (!operand || !_.IsIntScalarOrVectorType(operand->type_id())) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Ballot must be a 4-component integer vector"; } if (_.GetDimension(operand->type_id()) != 4) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Ballot must be a 4-component integer vector"; } } else { if (!operand || !_.IsUnsignedIntScalarType(operand->type_id())) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "ClusterSize must be an unsigned integer scalar"; } if (!spvOpcodeIsConstant(operand->opcode())) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "ClusterSize must be a constant instruction"; } } } return SPV_SUCCESS; } spv_result_t ValidateGroupNonUniformRotateKHR(ValidationState_t& _, const Instruction* inst) { // Scope is already checked by ValidateExecutionScope() above. const uint32_t result_type = inst->type_id(); if (!_.IsIntScalarOrVectorType(result_type) && !_.IsFloatScalarOrVectorType(result_type) && !_.IsBoolScalarOrVectorType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Result Type to be a scalar or vector of " "floating-point, integer or boolean type."; } const uint32_t value_type = _.GetTypeId(inst->GetOperandAs(3)); if (value_type != result_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Result Type must be the same as the type of Value."; } const uint32_t delta_type = _.GetTypeId(inst->GetOperandAs(4)); if (!_.IsUnsignedIntScalarType(delta_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Delta must be a scalar of integer type, whose Signedness " "operand is 0."; } if (inst->words().size() > 6) { const uint32_t cluster_size_op_id = inst->GetOperandAs(5); const Instruction* cluster_size_inst = _.FindDef(cluster_size_op_id); if (!cluster_size_inst || !_.IsUnsignedIntScalarType(cluster_size_inst->type_id())) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "ClusterSize must be a scalar of integer type, whose " "Signedness operand is 0."; } if (!spvOpcodeIsConstant(cluster_size_inst->opcode())) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "ClusterSize must come from a constant instruction."; } uint64_t cluster_size; const bool valid_const = _.EvalConstantValUint64(cluster_size_op_id, &cluster_size); if (valid_const && ((cluster_size == 0) || ((cluster_size & (cluster_size - 1)) != 0))) { return _.diag(SPV_WARNING, inst) << "Behavior is undefined unless ClusterSize is at least 1 and a " "power of 2."; } // TODO(kpet) Warn about undefined behavior when ClusterSize is greater than // the declared SubGroupSize } return SPV_SUCCESS; } } // namespace // Validates correctness of non-uniform group instructions. spv_result_t NonUniformPass(ValidationState_t& _, const Instruction* inst) { const spv::Op opcode = inst->opcode(); if (spvOpcodeIsNonUniformGroupOperation(opcode)) { // OpGroupNonUniformQuadAllKHR and OpGroupNonUniformQuadAnyKHR don't have // scope paramter if ((opcode != spv::Op::OpGroupNonUniformQuadAllKHR) && (opcode != spv::Op::OpGroupNonUniformQuadAnyKHR)) { const uint32_t execution_scope = inst->GetOperandAs(2); if (auto error = ValidateExecutionScope(_, inst, execution_scope)) { return error; } } } switch (opcode) { case spv::Op::OpGroupNonUniformElect: return ValidateGroupNonUniformElect(_, inst); case spv::Op::OpGroupNonUniformAny: case spv::Op::OpGroupNonUniformAll: return ValidateGroupNonUniformAnyAll(_, inst); case spv::Op::OpGroupNonUniformAllEqual: return ValidateGroupNonUniformAllEqual(_, inst); case spv::Op::OpGroupNonUniformBroadcast: case spv::Op::OpGroupNonUniformShuffle: case spv::Op::OpGroupNonUniformShuffleXor: case spv::Op::OpGroupNonUniformShuffleUp: case spv::Op::OpGroupNonUniformShuffleDown: case spv::Op::OpGroupNonUniformQuadBroadcast: case spv::Op::OpGroupNonUniformQuadSwap: return ValidateGroupNonUniformBroadcastShuffle(_, inst); case spv::Op::OpGroupNonUniformBroadcastFirst: return ValidateGroupNonUniformBroadcastFirst(_, inst); case spv::Op::OpGroupNonUniformBallot: return ValidateGroupNonUniformBallot(_, inst); case spv::Op::OpGroupNonUniformInverseBallot: return ValidateGroupNonUniformInverseBallot(_, inst); case spv::Op::OpGroupNonUniformBallotBitExtract: return ValidateGroupNonUniformBallotBitExtract(_, inst); case spv::Op::OpGroupNonUniformBallotBitCount: return ValidateGroupNonUniformBallotBitCount(_, inst); case spv::Op::OpGroupNonUniformBallotFindLSB: case spv::Op::OpGroupNonUniformBallotFindMSB: return ValidateGroupNonUniformBallotFind(_, inst); case spv::Op::OpGroupNonUniformIAdd: case spv::Op::OpGroupNonUniformFAdd: case spv::Op::OpGroupNonUniformIMul: case spv::Op::OpGroupNonUniformFMul: case spv::Op::OpGroupNonUniformSMin: case spv::Op::OpGroupNonUniformUMin: case spv::Op::OpGroupNonUniformFMin: case spv::Op::OpGroupNonUniformSMax: case spv::Op::OpGroupNonUniformUMax: case spv::Op::OpGroupNonUniformFMax: case spv::Op::OpGroupNonUniformBitwiseAnd: case spv::Op::OpGroupNonUniformBitwiseOr: case spv::Op::OpGroupNonUniformBitwiseXor: case spv::Op::OpGroupNonUniformLogicalAnd: case spv::Op::OpGroupNonUniformLogicalOr: case spv::Op::OpGroupNonUniformLogicalXor: return ValidateGroupNonUniformArithmetic(_, inst); case spv::Op::OpGroupNonUniformRotateKHR: return ValidateGroupNonUniformRotateKHR(_, inst); default: break; } return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_primitives.cpp000066400000000000000000000043471475742701700253730ustar00rootroot00000000000000// Copyright (c) 2017 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validates correctness of primitive SPIR-V instructions. #include #include "source/opcode.h" #include "source/val/instruction.h" #include "source/val/validate.h" #include "source/val/validation_state.h" namespace spvtools { namespace val { // Validates correctness of primitive instructions. spv_result_t PrimitivesPass(ValidationState_t& _, const Instruction* inst) { const spv::Op opcode = inst->opcode(); switch (opcode) { case spv::Op::OpEmitVertex: case spv::Op::OpEndPrimitive: case spv::Op::OpEmitStreamVertex: case spv::Op::OpEndStreamPrimitive: _.function(inst->function()->id()) ->RegisterExecutionModelLimitation( spv::ExecutionModel::Geometry, std::string(spvOpcodeString(opcode)) + " instructions require Geometry execution model"); break; default: break; } switch (opcode) { case spv::Op::OpEmitStreamVertex: case spv::Op::OpEndStreamPrimitive: { const uint32_t stream_id = inst->word(1); const uint32_t stream_type = _.GetTypeId(stream_id); if (!_.IsIntScalarType(stream_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": expected Stream to be int scalar"; } const spv::Op stream_opcode = _.GetIdOpcode(stream_id); if (!spvOpcodeIsConstant(stream_opcode)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": expected Stream to be constant instruction"; } } default: break; } return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_ray_query.cpp000066400000000000000000000333351475742701700252170ustar00rootroot00000000000000// Copyright (c) 2022 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validates ray query instructions from SPV_KHR_ray_query #include "source/opcode.h" #include "source/val/instruction.h" #include "source/val/validate.h" #include "source/val/validation_state.h" namespace spvtools { namespace val { namespace { uint32_t GetArrayLength(ValidationState_t& _, const Instruction* array_type) { assert(array_type->opcode() == spv::Op::OpTypeArray); uint32_t const_int_id = array_type->GetOperandAs(2U); Instruction* array_length_inst = _.FindDef(const_int_id); uint32_t array_length = 0; if (array_length_inst->opcode() == spv::Op::OpConstant) { array_length = array_length_inst->GetOperandAs(2); } return array_length; } spv_result_t ValidateRayQueryPointer(ValidationState_t& _, const Instruction* inst, uint32_t ray_query_index) { const uint32_t ray_query_id = inst->GetOperandAs(ray_query_index); auto variable = _.FindDef(ray_query_id); const auto var_opcode = variable->opcode(); if (!variable || (var_opcode != spv::Op::OpVariable && var_opcode != spv::Op::OpFunctionParameter && var_opcode != spv::Op::OpAccessChain)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Ray Query must be a memory object declaration"; } auto pointer = _.FindDef(variable->GetOperandAs(0)); if (!pointer || pointer->opcode() != spv::Op::OpTypePointer) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Ray Query must be a pointer"; } auto type = _.FindDef(pointer->GetOperandAs(2)); if (!type || type->opcode() != spv::Op::OpTypeRayQueryKHR) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Ray Query must be a pointer to OpTypeRayQueryKHR"; } return SPV_SUCCESS; } spv_result_t ValidateIntersectionId(ValidationState_t& _, const Instruction* inst, uint32_t intersection_index) { const uint32_t intersection_id = inst->GetOperandAs(intersection_index); const uint32_t intersection_type = _.GetTypeId(intersection_id); const spv::Op intersection_opcode = _.GetIdOpcode(intersection_id); if (!_.IsIntScalarType(intersection_type) || _.GetBitWidth(intersection_type) != 32 || !spvOpcodeIsConstant(intersection_opcode)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "expected Intersection ID to be a constant 32-bit int scalar"; } return SPV_SUCCESS; } } // namespace spv_result_t RayQueryPass(ValidationState_t& _, const Instruction* inst) { const spv::Op opcode = inst->opcode(); const uint32_t result_type = inst->type_id(); switch (opcode) { case spv::Op::OpRayQueryInitializeKHR: { if (auto error = ValidateRayQueryPointer(_, inst, 0)) return error; if (_.GetIdOpcode(_.GetOperandTypeId(inst, 1)) != spv::Op::OpTypeAccelerationStructureKHR) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Acceleration Structure to be of type " "OpTypeAccelerationStructureKHR"; } const uint32_t ray_flags = _.GetOperandTypeId(inst, 2); if (!_.IsIntScalarType(ray_flags) || _.GetBitWidth(ray_flags) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Ray Flags must be a 32-bit int scalar"; } const uint32_t cull_mask = _.GetOperandTypeId(inst, 3); if (!_.IsIntScalarType(cull_mask) || _.GetBitWidth(cull_mask) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Cull Mask must be a 32-bit int scalar"; } const uint32_t ray_origin = _.GetOperandTypeId(inst, 4); if (!_.IsFloatVectorType(ray_origin) || _.GetDimension(ray_origin) != 3 || _.GetBitWidth(ray_origin) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Ray Origin must be a 32-bit float 3-component vector"; } const uint32_t ray_tmin = _.GetOperandTypeId(inst, 5); if (!_.IsFloatScalarType(ray_tmin) || _.GetBitWidth(ray_tmin) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Ray TMin must be a 32-bit float scalar"; } const uint32_t ray_direction = _.GetOperandTypeId(inst, 6); if (!_.IsFloatVectorType(ray_direction) || _.GetDimension(ray_direction) != 3 || _.GetBitWidth(ray_direction) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Ray Direction must be a 32-bit float 3-component vector"; } const uint32_t ray_tmax = _.GetOperandTypeId(inst, 7); if (!_.IsFloatScalarType(ray_tmax) || _.GetBitWidth(ray_tmax) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Ray TMax must be a 32-bit float scalar"; } break; } case spv::Op::OpRayQueryTerminateKHR: case spv::Op::OpRayQueryConfirmIntersectionKHR: { if (auto error = ValidateRayQueryPointer(_, inst, 0)) return error; break; } case spv::Op::OpRayQueryGenerateIntersectionKHR: { if (auto error = ValidateRayQueryPointer(_, inst, 0)) return error; const uint32_t hit_t_id = _.GetOperandTypeId(inst, 1); if (!_.IsFloatScalarType(hit_t_id) || _.GetBitWidth(hit_t_id) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Hit T must be a 32-bit float scalar"; } break; } case spv::Op::OpRayQueryGetIntersectionFrontFaceKHR: case spv::Op::OpRayQueryProceedKHR: case spv::Op::OpRayQueryGetIntersectionCandidateAABBOpaqueKHR: { if (auto error = ValidateRayQueryPointer(_, inst, 2)) return error; if (!_.IsBoolScalarType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "expected Result Type to be bool scalar type"; } if (opcode == spv::Op::OpRayQueryGetIntersectionFrontFaceKHR) { if (auto error = ValidateIntersectionId(_, inst, 3)) return error; } break; } case spv::Op::OpRayQueryGetIntersectionTKHR: case spv::Op::OpRayQueryGetRayTMinKHR: { if (auto error = ValidateRayQueryPointer(_, inst, 2)) return error; if (!_.IsFloatScalarType(result_type) || _.GetBitWidth(result_type) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "expected Result Type to be 32-bit float scalar type"; } if (opcode == spv::Op::OpRayQueryGetIntersectionTKHR) { if (auto error = ValidateIntersectionId(_, inst, 3)) return error; } break; } case spv::Op::OpRayQueryGetIntersectionTypeKHR: case spv::Op::OpRayQueryGetIntersectionInstanceCustomIndexKHR: case spv::Op::OpRayQueryGetIntersectionInstanceIdKHR: case spv::Op:: OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: case spv::Op::OpRayQueryGetIntersectionGeometryIndexKHR: case spv::Op::OpRayQueryGetIntersectionPrimitiveIndexKHR: case spv::Op::OpRayQueryGetRayFlagsKHR: { if (auto error = ValidateRayQueryPointer(_, inst, 2)) return error; if (!_.IsIntScalarType(result_type) || _.GetBitWidth(result_type) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "expected Result Type to be 32-bit int scalar type"; } if (opcode != spv::Op::OpRayQueryGetRayFlagsKHR) { if (auto error = ValidateIntersectionId(_, inst, 3)) return error; } break; } case spv::Op::OpRayQueryGetIntersectionObjectRayDirectionKHR: case spv::Op::OpRayQueryGetIntersectionObjectRayOriginKHR: case spv::Op::OpRayQueryGetWorldRayDirectionKHR: case spv::Op::OpRayQueryGetWorldRayOriginKHR: { if (auto error = ValidateRayQueryPointer(_, inst, 2)) return error; if (!_.IsFloatVectorType(result_type) || _.GetDimension(result_type) != 3 || _.GetBitWidth(result_type) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "expected Result Type to be 32-bit float 3-component " "vector type"; } if (opcode == spv::Op::OpRayQueryGetIntersectionObjectRayDirectionKHR || opcode == spv::Op::OpRayQueryGetIntersectionObjectRayOriginKHR) { if (auto error = ValidateIntersectionId(_, inst, 3)) return error; } break; } case spv::Op::OpRayQueryGetIntersectionBarycentricsKHR: { if (auto error = ValidateRayQueryPointer(_, inst, 2)) return error; if (auto error = ValidateIntersectionId(_, inst, 3)) return error; if (!_.IsFloatVectorType(result_type) || _.GetDimension(result_type) != 2 || _.GetBitWidth(result_type) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "expected Result Type to be 32-bit float 2-component " "vector type"; } break; } case spv::Op::OpRayQueryGetIntersectionObjectToWorldKHR: case spv::Op::OpRayQueryGetIntersectionWorldToObjectKHR: { if (auto error = ValidateRayQueryPointer(_, inst, 2)) return error; if (auto error = ValidateIntersectionId(_, inst, 3)) return error; uint32_t num_rows = 0; uint32_t num_cols = 0; uint32_t col_type = 0; uint32_t component_type = 0; if (!_.GetMatrixTypeInfo(result_type, &num_rows, &num_cols, &col_type, &component_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "expected matrix type as Result Type"; } if (num_cols != 4) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "expected Result Type matrix to have a Column Count of 4"; } if (!_.IsFloatScalarType(component_type) || _.GetBitWidth(result_type) != 32 || num_rows != 3) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "expected Result Type matrix to have a Column Type of " "3-component 32-bit float vectors"; } break; } case spv::Op::OpRayQueryGetClusterIdNV: { if (auto error = ValidateRayQueryPointer(_, inst, 2)) return error; if (auto error = ValidateIntersectionId(_, inst, 3)) return error; if (!_.IsIntScalarType(result_type) || _.GetBitWidth(result_type) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "expected Result Type to be 32-bit int scalar type"; } break; } case spv::Op::OpRayQueryGetIntersectionSpherePositionNV: { if (auto error = ValidateRayQueryPointer(_, inst, 2)) return error; if (auto error = ValidateIntersectionId(_, inst, 3)) return error; if (!_.IsFloatVectorType(result_type) || _.GetDimension(result_type) != 3 || _.GetBitWidth(result_type) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "expected Result Type to be 32-bit float 3-component " "vector type"; } break; } case spv::Op::OpRayQueryGetIntersectionLSSPositionsNV: { if (auto error = ValidateRayQueryPointer(_, inst, 2)) return error; if (auto error = ValidateIntersectionId(_, inst, 3)) return error; auto result_id = _.FindDef(result_type); if ((result_id->opcode() != spv::Op::OpTypeArray) || (GetArrayLength(_, result_id) != 2) || !_.IsFloatVectorType(_.GetComponentType(result_type)) || _.GetDimension(_.GetComponentType(result_type)) != 3) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected 2 element array of 32-bit 3 component float point " "vector as Result Type: " << spvOpcodeString(opcode); } break; } case spv::Op::OpRayQueryGetIntersectionLSSRadiiNV: { if (auto error = ValidateRayQueryPointer(_, inst, 2)) return error; if (auto error = ValidateIntersectionId(_, inst, 3)) return error; if (!_.IsFloatArrayType(result_type) || (GetArrayLength(_, _.FindDef(result_type)) != 2) || !_.IsFloatScalarType(_.GetComponentType(result_type))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected 32-bit floating point scalar as Result Type: " << spvOpcodeString(opcode); } break; } case spv::Op::OpRayQueryGetIntersectionSphereRadiusNV: case spv::Op::OpRayQueryGetIntersectionLSSHitValueNV: { if (auto error = ValidateRayQueryPointer(_, inst, 2)) return error; if (auto error = ValidateIntersectionId(_, inst, 3)) return error; if (!_.IsFloatScalarType(result_type) || _.GetBitWidth(result_type) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "expected Result Type to be 32-bit floating point " "scalar type"; } break; } case spv::Op::OpRayQueryIsSphereHitNV: case spv::Op::OpRayQueryIsLSSHitNV: { if (auto error = ValidateRayQueryPointer(_, inst, 2)) return error; if (auto error = ValidateIntersectionId(_, inst, 3)) return error; if (!_.IsBoolScalarType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "expected Result Type to be Boolean " "scalar type"; } break; } default: break; } return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_ray_tracing.cpp000066400000000000000000000203131475742701700254710ustar00rootroot00000000000000// Copyright (c) 2022 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validates ray tracing instructions from SPV_KHR_ray_tracing #include "source/opcode.h" #include "source/val/instruction.h" #include "source/val/validate.h" #include "source/val/validation_state.h" namespace spvtools { namespace val { spv_result_t RayTracingPass(ValidationState_t& _, const Instruction* inst) { const spv::Op opcode = inst->opcode(); const uint32_t result_type = inst->type_id(); switch (opcode) { case spv::Op::OpTraceRayKHR: { _.function(inst->function()->id()) ->RegisterExecutionModelLimitation( [](spv::ExecutionModel model, std::string* message) { if (model != spv::ExecutionModel::RayGenerationKHR && model != spv::ExecutionModel::ClosestHitKHR && model != spv::ExecutionModel::MissKHR) { if (message) { *message = "OpTraceRayKHR requires RayGenerationKHR, " "ClosestHitKHR and MissKHR execution models"; } return false; } return true; }); if (_.GetIdOpcode(_.GetOperandTypeId(inst, 0)) != spv::Op::OpTypeAccelerationStructureKHR) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Acceleration Structure to be of type " "OpTypeAccelerationStructureKHR"; } const uint32_t ray_flags = _.GetOperandTypeId(inst, 1); if (!_.IsIntScalarType(ray_flags) || _.GetBitWidth(ray_flags) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Ray Flags must be a 32-bit int scalar"; } const uint32_t cull_mask = _.GetOperandTypeId(inst, 2); if (!_.IsIntScalarType(cull_mask) || _.GetBitWidth(cull_mask) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Cull Mask must be a 32-bit int scalar"; } const uint32_t sbt_offset = _.GetOperandTypeId(inst, 3); if (!_.IsIntScalarType(sbt_offset) || _.GetBitWidth(sbt_offset) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "SBT Offset must be a 32-bit int scalar"; } const uint32_t sbt_stride = _.GetOperandTypeId(inst, 4); if (!_.IsIntScalarType(sbt_stride) || _.GetBitWidth(sbt_stride) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "SBT Stride must be a 32-bit int scalar"; } const uint32_t miss_index = _.GetOperandTypeId(inst, 5); if (!_.IsIntScalarType(miss_index) || _.GetBitWidth(miss_index) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Miss Index must be a 32-bit int scalar"; } const uint32_t ray_origin = _.GetOperandTypeId(inst, 6); if (!_.IsFloatVectorType(ray_origin) || _.GetDimension(ray_origin) != 3 || _.GetBitWidth(ray_origin) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Ray Origin must be a 32-bit float 3-component vector"; } const uint32_t ray_tmin = _.GetOperandTypeId(inst, 7); if (!_.IsFloatScalarType(ray_tmin) || _.GetBitWidth(ray_tmin) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Ray TMin must be a 32-bit float scalar"; } const uint32_t ray_direction = _.GetOperandTypeId(inst, 8); if (!_.IsFloatVectorType(ray_direction) || _.GetDimension(ray_direction) != 3 || _.GetBitWidth(ray_direction) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Ray Direction must be a 32-bit float 3-component vector"; } const uint32_t ray_tmax = _.GetOperandTypeId(inst, 9); if (!_.IsFloatScalarType(ray_tmax) || _.GetBitWidth(ray_tmax) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Ray TMax must be a 32-bit float scalar"; } const Instruction* payload = _.FindDef(inst->GetOperandAs(10)); if (payload->opcode() != spv::Op::OpVariable) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Payload must be the result of a OpVariable"; } else if (payload->GetOperandAs(2) != spv::StorageClass::RayPayloadKHR && payload->GetOperandAs(2) != spv::StorageClass::IncomingRayPayloadKHR) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Payload must have storage class RayPayloadKHR or " "IncomingRayPayloadKHR"; } break; } case spv::Op::OpReportIntersectionKHR: { _.function(inst->function()->id()) ->RegisterExecutionModelLimitation( [](spv::ExecutionModel model, std::string* message) { if (model != spv::ExecutionModel::IntersectionKHR) { if (message) { *message = "OpReportIntersectionKHR requires IntersectionKHR " "execution model"; } return false; } return true; }); if (!_.IsBoolScalarType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "expected Result Type to be bool scalar type"; } const uint32_t hit = _.GetOperandTypeId(inst, 2); if (!_.IsFloatScalarType(hit) || _.GetBitWidth(hit) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Hit must be a 32-bit int scalar"; } const uint32_t hit_kind = _.GetOperandTypeId(inst, 3); if (!_.IsUnsignedIntScalarType(hit_kind) || _.GetBitWidth(hit_kind) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Hit Kind must be a 32-bit unsigned int scalar"; } break; } case spv::Op::OpExecuteCallableKHR: { _.function(inst->function()->id()) ->RegisterExecutionModelLimitation([](spv::ExecutionModel model, std::string* message) { if (model != spv::ExecutionModel::RayGenerationKHR && model != spv::ExecutionModel::ClosestHitKHR && model != spv::ExecutionModel::MissKHR && model != spv::ExecutionModel::CallableKHR) { if (message) { *message = "OpExecuteCallableKHR requires RayGenerationKHR, " "ClosestHitKHR, MissKHR and CallableKHR execution models"; } return false; } return true; }); const uint32_t sbt_index = _.GetOperandTypeId(inst, 0); if (!_.IsUnsignedIntScalarType(sbt_index) || _.GetBitWidth(sbt_index) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "SBT Index must be a 32-bit unsigned int scalar"; } const auto callable_data = _.FindDef(inst->GetOperandAs(1)); if (callable_data->opcode() != spv::Op::OpVariable) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Callable Data must be the result of a OpVariable"; } else if (callable_data->GetOperandAs(2) != spv::StorageClass::CallableDataKHR && callable_data->GetOperandAs(2) != spv::StorageClass::IncomingCallableDataKHR) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Callable Data must have storage class CallableDataKHR or " "IncomingCallableDataKHR"; } break; } default: break; } return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_ray_tracing_reorder.cpp000066400000000000000000000715231475742701700272240ustar00rootroot00000000000000// Copyright (c) 2022 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validates ray tracing instructions from SPV_NV_shader_execution_reorder #include "source/opcode.h" #include "source/val/instruction.h" #include "source/val/validate.h" #include "source/val/validation_state.h" #include namespace spvtools { namespace val { static const uint32_t KRayParamInvalidId = std::numeric_limits::max(); uint32_t GetArrayLength(ValidationState_t& _, const Instruction* array_type) { assert(array_type->opcode() == spv::Op::OpTypeArray); uint32_t const_int_id = array_type->GetOperandAs(2U); Instruction* array_length_inst = _.FindDef(const_int_id); uint32_t array_length = 0; if (array_length_inst->opcode() == spv::Op::OpConstant) { array_length = array_length_inst->GetOperandAs(2); } return array_length; } spv_result_t ValidateHitObjectPointer(ValidationState_t& _, const Instruction* inst, uint32_t hit_object_index) { const uint32_t hit_object_id = inst->GetOperandAs(hit_object_index); auto variable = _.FindDef(hit_object_id); const auto var_opcode = variable->opcode(); if (!variable || (var_opcode != spv::Op::OpVariable && var_opcode != spv::Op::OpFunctionParameter && var_opcode != spv::Op::OpAccessChain)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Hit Object must be a memory object declaration"; } auto pointer = _.FindDef(variable->GetOperandAs(0)); if (!pointer || pointer->opcode() != spv::Op::OpTypePointer) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Hit Object must be a pointer"; } auto type = _.FindDef(pointer->GetOperandAs(2)); if (!type || type->opcode() != spv::Op::OpTypeHitObjectNV) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Type must be OpTypeHitObjectNV"; } return SPV_SUCCESS; } spv_result_t ValidateHitObjectInstructionCommonParameters( ValidationState_t& _, const Instruction* inst, uint32_t acceleration_struct_index, uint32_t instance_id_index, uint32_t primtive_id_index, uint32_t geometry_index, uint32_t ray_flags_index, uint32_t cull_mask_index, uint32_t hit_kind_index, uint32_t sbt_index, uint32_t sbt_offset_index, uint32_t sbt_stride_index, uint32_t sbt_record_offset_index, uint32_t sbt_record_stride_index, uint32_t miss_index, uint32_t ray_origin_index, uint32_t ray_tmin_index, uint32_t ray_direction_index, uint32_t ray_tmax_index, uint32_t payload_index, uint32_t hit_object_attr_index) { auto isValidId = [](uint32_t spvid) { return spvid < KRayParamInvalidId; }; if (isValidId(acceleration_struct_index) && _.GetIdOpcode(_.GetOperandTypeId(inst, acceleration_struct_index)) != spv::Op::OpTypeAccelerationStructureKHR) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Acceleration Structure to be of type " "OpTypeAccelerationStructureKHR"; } if (isValidId(instance_id_index)) { const uint32_t instance_id = _.GetOperandTypeId(inst, instance_id_index); if (!_.IsIntScalarType(instance_id) || _.GetBitWidth(instance_id) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Instance Id must be a 32-bit int scalar"; } } if (isValidId(primtive_id_index)) { const uint32_t primitive_id = _.GetOperandTypeId(inst, primtive_id_index); if (!_.IsIntScalarType(primitive_id) || _.GetBitWidth(primitive_id) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Primitive Id must be a 32-bit int scalar"; } } if (isValidId(geometry_index)) { const uint32_t geometry_index_id = _.GetOperandTypeId(inst, geometry_index); if (!_.IsIntScalarType(geometry_index_id) || _.GetBitWidth(geometry_index_id) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Geometry Index must be a 32-bit int scalar"; } } if (isValidId(miss_index)) { const uint32_t miss_index_id = _.GetOperandTypeId(inst, miss_index); if (!_.IsUnsignedIntScalarType(miss_index_id) || _.GetBitWidth(miss_index_id) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Miss Index must be a 32-bit int scalar"; } } if (isValidId(cull_mask_index)) { const uint32_t cull_mask_id = _.GetOperandTypeId(inst, cull_mask_index); if (!_.IsUnsignedIntScalarType(cull_mask_id) || _.GetBitWidth(cull_mask_id) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Cull mask must be a 32-bit int scalar"; } } if (isValidId(sbt_index)) { const uint32_t sbt_index_id = _.GetOperandTypeId(inst, sbt_index); if (!_.IsUnsignedIntScalarType(sbt_index_id) || _.GetBitWidth(sbt_index_id) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "SBT Index must be a 32-bit unsigned int scalar"; } } if (isValidId(sbt_offset_index)) { const uint32_t sbt_offset_id = _.GetOperandTypeId(inst, sbt_offset_index); if (!_.IsUnsignedIntScalarType(sbt_offset_id) || _.GetBitWidth(sbt_offset_id) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "SBT Offset must be a 32-bit unsigned int scalar"; } } if (isValidId(sbt_stride_index)) { const uint32_t sbt_stride_index_id = _.GetOperandTypeId(inst, sbt_stride_index); if (!_.IsUnsignedIntScalarType(sbt_stride_index_id) || _.GetBitWidth(sbt_stride_index_id) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "SBT Stride must be a 32-bit unsigned int scalar"; } } if (isValidId(sbt_record_offset_index)) { const uint32_t sbt_record_offset_index_id = _.GetOperandTypeId(inst, sbt_record_offset_index); if (!_.IsUnsignedIntScalarType(sbt_record_offset_index_id) || _.GetBitWidth(sbt_record_offset_index_id) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "SBT record offset must be a 32-bit unsigned int scalar"; } } if (isValidId(sbt_record_stride_index)) { const uint32_t sbt_record_stride_index_id = _.GetOperandTypeId(inst, sbt_record_stride_index); if (!_.IsUnsignedIntScalarType(sbt_record_stride_index_id) || _.GetBitWidth(sbt_record_stride_index_id) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "SBT record stride must be a 32-bit unsigned int scalar"; } } if (isValidId(ray_origin_index)) { const uint32_t ray_origin_id = _.GetOperandTypeId(inst, ray_origin_index); if (!_.IsFloatVectorType(ray_origin_id) || _.GetDimension(ray_origin_id) != 3 || _.GetBitWidth(ray_origin_id) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Ray Origin must be a 32-bit float 3-component vector"; } } if (isValidId(ray_tmin_index)) { const uint32_t ray_tmin_id = _.GetOperandTypeId(inst, ray_tmin_index); if (!_.IsFloatScalarType(ray_tmin_id) || _.GetBitWidth(ray_tmin_id) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Ray TMin must be a 32-bit float scalar"; } } if (isValidId(ray_direction_index)) { const uint32_t ray_direction_id = _.GetOperandTypeId(inst, ray_direction_index); if (!_.IsFloatVectorType(ray_direction_id) || _.GetDimension(ray_direction_id) != 3 || _.GetBitWidth(ray_direction_id) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Ray Direction must be a 32-bit float 3-component vector"; } } if (isValidId(ray_tmax_index)) { const uint32_t ray_tmax_id = _.GetOperandTypeId(inst, ray_tmax_index); if (!_.IsFloatScalarType(ray_tmax_id) || _.GetBitWidth(ray_tmax_id) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Ray TMax must be a 32-bit float scalar"; } } if (isValidId(ray_flags_index)) { const uint32_t ray_flags_id = _.GetOperandTypeId(inst, ray_flags_index); if (!_.IsIntScalarType(ray_flags_id) || _.GetBitWidth(ray_flags_id) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Ray Flags must be a 32-bit int scalar"; } } if (isValidId(payload_index)) { const uint32_t payload_id = inst->GetOperandAs(payload_index); auto variable = _.FindDef(payload_id); const auto var_opcode = variable->opcode(); if (!variable || var_opcode != spv::Op::OpVariable || (variable->GetOperandAs(2) != spv::StorageClass::RayPayloadKHR && variable->GetOperandAs(2) != spv::StorageClass::IncomingRayPayloadKHR)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "payload must be a OpVariable of storage " "class RayPayloadKHR or IncomingRayPayloadKHR"; } } if (isValidId(hit_kind_index)) { const uint32_t hit_kind_id = _.GetOperandTypeId(inst, hit_kind_index); if (!_.IsUnsignedIntScalarType(hit_kind_id) || _.GetBitWidth(hit_kind_id) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Hit Kind must be a 32-bit unsigned int scalar"; } } if (isValidId(hit_object_attr_index)) { const uint32_t hit_object_attr_id = inst->GetOperandAs(hit_object_attr_index); auto variable = _.FindDef(hit_object_attr_id); const auto var_opcode = variable->opcode(); if (!variable || var_opcode != spv::Op::OpVariable || (variable->GetOperandAs(2)) != spv::StorageClass::HitObjectAttributeNV) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Hit Object Attributes id must be a OpVariable of storage " "class HitObjectAttributeNV"; } } return SPV_SUCCESS; } spv_result_t RayReorderNVPass(ValidationState_t& _, const Instruction* inst) { const spv::Op opcode = inst->opcode(); const uint32_t result_type = inst->type_id(); auto RegisterOpcodeForValidModel = [](ValidationState_t& vs, const Instruction* rtinst) { std::string opcode_name = spvOpcodeString(rtinst->opcode()); vs.function(rtinst->function()->id()) ->RegisterExecutionModelLimitation( [opcode_name](spv::ExecutionModel model, std::string* message) { if (model != spv::ExecutionModel::RayGenerationKHR && model != spv::ExecutionModel::ClosestHitKHR && model != spv::ExecutionModel::MissKHR) { if (message) { *message = opcode_name + " requires RayGenerationKHR, ClosestHitKHR and " "MissKHR execution models"; } return false; } return true; }); return; }; switch (opcode) { case spv::Op::OpHitObjectIsMissNV: case spv::Op::OpHitObjectIsHitNV: case spv::Op::OpHitObjectIsEmptyNV: { RegisterOpcodeForValidModel(_, inst); if (!_.IsBoolScalarType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "expected Result Type to be bool scalar type"; } if (auto error = ValidateHitObjectPointer(_, inst, 2)) return error; break; } case spv::Op::OpHitObjectGetShaderRecordBufferHandleNV: { RegisterOpcodeForValidModel(_, inst); if (auto error = ValidateHitObjectPointer(_, inst, 2)) return error; if (!_.IsIntVectorType(result_type) || (_.GetDimension(result_type) != 2) || (_.GetBitWidth(result_type) != 32)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected 32-bit integer type 2-component vector as Result " "Type: " << spvOpcodeString(opcode); break; } case spv::Op::OpHitObjectGetHitKindNV: case spv::Op::OpHitObjectGetPrimitiveIndexNV: case spv::Op::OpHitObjectGetGeometryIndexNV: case spv::Op::OpHitObjectGetInstanceIdNV: case spv::Op::OpHitObjectGetInstanceCustomIndexNV: case spv::Op::OpHitObjectGetShaderBindingTableRecordIndexNV: { RegisterOpcodeForValidModel(_, inst); if (auto error = ValidateHitObjectPointer(_, inst, 2)) return error; if (!_.IsIntScalarType(result_type) || !_.GetBitWidth(result_type)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected 32-bit integer type scalar as Result Type: " << spvOpcodeString(opcode); break; } case spv::Op::OpHitObjectGetCurrentTimeNV: case spv::Op::OpHitObjectGetRayTMaxNV: case spv::Op::OpHitObjectGetRayTMinNV: { RegisterOpcodeForValidModel(_, inst); if (auto error = ValidateHitObjectPointer(_, inst, 2)) return error; if (!_.IsFloatScalarType(result_type) || _.GetBitWidth(result_type) != 32) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected 32-bit floating-point type scalar as Result Type: " << spvOpcodeString(opcode); break; } case spv::Op::OpHitObjectGetObjectToWorldNV: case spv::Op::OpHitObjectGetWorldToObjectNV: { RegisterOpcodeForValidModel(_, inst); if (auto error = ValidateHitObjectPointer(_, inst, 2)) return error; uint32_t num_rows = 0; uint32_t num_cols = 0; uint32_t col_type = 0; uint32_t component_type = 0; if (!_.GetMatrixTypeInfo(result_type, &num_rows, &num_cols, &col_type, &component_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "expected matrix type as Result Type: " << spvOpcodeString(opcode); } if (num_cols != 4) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "expected Result Type matrix to have a Column Count of 4" << spvOpcodeString(opcode); } if (!_.IsFloatScalarType(component_type) || _.GetBitWidth(result_type) != 32 || num_rows != 3) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "expected Result Type matrix to have a Column Type of " "3-component 32-bit float vectors: " << spvOpcodeString(opcode); } break; } case spv::Op::OpHitObjectGetObjectRayOriginNV: case spv::Op::OpHitObjectGetObjectRayDirectionNV: case spv::Op::OpHitObjectGetWorldRayDirectionNV: case spv::Op::OpHitObjectGetWorldRayOriginNV: { RegisterOpcodeForValidModel(_, inst); if (auto error = ValidateHitObjectPointer(_, inst, 2)) return error; if (!_.IsFloatVectorType(result_type) || (_.GetDimension(result_type) != 3) || (_.GetBitWidth(result_type) != 32)) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected 32-bit floating-point type 3-component vector as " "Result Type: " << spvOpcodeString(opcode); break; } case spv::Op::OpHitObjectGetAttributesNV: { RegisterOpcodeForValidModel(_, inst); if (auto error = ValidateHitObjectPointer(_, inst, 0)) return error; const uint32_t hit_object_attr_id = inst->GetOperandAs(1); auto variable = _.FindDef(hit_object_attr_id); const auto var_opcode = variable->opcode(); if (!variable || var_opcode != spv::Op::OpVariable || variable->GetOperandAs(2) != spv::StorageClass::HitObjectAttributeNV) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Hit Object Attributes id must be a OpVariable of storage " "class HitObjectAttributeNV"; } break; } case spv::Op::OpHitObjectExecuteShaderNV: { RegisterOpcodeForValidModel(_, inst); if (auto error = ValidateHitObjectPointer(_, inst, 0)) return error; const uint32_t hit_object_attr_id = inst->GetOperandAs(1); auto variable = _.FindDef(hit_object_attr_id); const auto var_opcode = variable->opcode(); if (!variable || var_opcode != spv::Op::OpVariable || (variable->GetOperandAs(2)) != spv::StorageClass::RayPayloadKHR) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Hit Object Attributes id must be a OpVariable of storage " "class RayPayloadKHR"; } break; } case spv::Op::OpHitObjectRecordEmptyNV: { RegisterOpcodeForValidModel(_, inst); if (auto error = ValidateHitObjectPointer(_, inst, 0)) return error; break; } case spv::Op::OpHitObjectRecordMissNV: { RegisterOpcodeForValidModel(_, inst); if (auto error = ValidateHitObjectPointer(_, inst, 0)) return error; const uint32_t miss_index = _.GetOperandTypeId(inst, 1); if (!_.IsUnsignedIntScalarType(miss_index) || _.GetBitWidth(miss_index) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Miss Index must be a 32-bit int scalar"; } const uint32_t ray_origin = _.GetOperandTypeId(inst, 2); if (!_.IsFloatVectorType(ray_origin) || _.GetDimension(ray_origin) != 3 || _.GetBitWidth(ray_origin) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Ray Origin must be a 32-bit float 3-component vector"; } const uint32_t ray_tmin = _.GetOperandTypeId(inst, 3); if (!_.IsFloatScalarType(ray_tmin) || _.GetBitWidth(ray_tmin) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Ray TMin must be a 32-bit float scalar"; } const uint32_t ray_direction = _.GetOperandTypeId(inst, 4); if (!_.IsFloatVectorType(ray_direction) || _.GetDimension(ray_direction) != 3 || _.GetBitWidth(ray_direction) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Ray Direction must be a 32-bit float 3-component vector"; } const uint32_t ray_tmax = _.GetOperandTypeId(inst, 5); if (!_.IsFloatScalarType(ray_tmax) || _.GetBitWidth(ray_tmax) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Ray TMax must be a 32-bit float scalar"; } break; } case spv::Op::OpHitObjectRecordHitWithIndexNV: { RegisterOpcodeForValidModel(_, inst); if (auto error = ValidateHitObjectPointer(_, inst, 0)) return error; if (auto error = ValidateHitObjectInstructionCommonParameters( _, inst, 1 /* Acceleration Struct */, 2 /* Instance Id */, 3 /* Primtive Id */, 4 /* Geometry Index */, KRayParamInvalidId /* Ray Flags */, KRayParamInvalidId /* Cull Mask */, 5 /* Hit Kind*/, 6 /* SBT index */, KRayParamInvalidId /* SBT Offset */, KRayParamInvalidId /* SBT Stride */, KRayParamInvalidId /* SBT Record Offset */, KRayParamInvalidId /* SBT Record Stride */, KRayParamInvalidId /* Miss Index */, 7 /* Ray Origin */, 8 /* Ray TMin */, 9 /* Ray Direction */, 10 /* Ray TMax */, KRayParamInvalidId /* Payload */, 11 /* Hit Object Attribute */)) return error; break; } case spv::Op::OpHitObjectRecordHitNV: { RegisterOpcodeForValidModel(_, inst); if (auto error = ValidateHitObjectPointer(_, inst, 0)) return error; if (auto error = ValidateHitObjectInstructionCommonParameters( _, inst, 1 /* Acceleration Struct */, 2 /* Instance Id */, 3 /* Primtive Id */, 4 /* Geometry Index */, KRayParamInvalidId /* Ray Flags */, KRayParamInvalidId /* Cull Mask */, 5 /* Hit Kind*/, KRayParamInvalidId /* SBT index */, KRayParamInvalidId /* SBT Offset */, KRayParamInvalidId /* SBT Stride */, 6 /* SBT Record Offset */, 7 /* SBT Record Stride */, KRayParamInvalidId /* Miss Index */, 8 /* Ray Origin */, 9 /* Ray TMin */, 10 /* Ray Direction */, 11 /* Ray TMax */, KRayParamInvalidId /* Payload */, 12 /* Hit Object Attribute */)) return error; break; } case spv::Op::OpHitObjectTraceRayMotionNV: { RegisterOpcodeForValidModel(_, inst); if (auto error = ValidateHitObjectPointer(_, inst, 0)) return error; if (auto error = ValidateHitObjectInstructionCommonParameters( _, inst, 1 /* Acceleration Struct */, KRayParamInvalidId /* Instance Id */, KRayParamInvalidId /* Primtive Id */, KRayParamInvalidId /* Geometry Index */, 2 /* Ray Flags */, 3 /* Cull Mask */, KRayParamInvalidId /* Hit Kind*/, KRayParamInvalidId /* SBT index */, 4 /* SBT Offset */, 5 /* SBT Stride */, KRayParamInvalidId /* SBT Record Offset */, KRayParamInvalidId /* SBT Record Stride */, 6 /* Miss Index */, 7 /* Ray Origin */, 8 /* Ray TMin */, 9 /* Ray Direction */, 10 /* Ray TMax */, 12 /* Payload */, KRayParamInvalidId /* Hit Object Attribute */)) return error; // Current Time const uint32_t current_time_id = _.GetOperandTypeId(inst, 11); if (!_.IsFloatScalarType(current_time_id) || _.GetBitWidth(current_time_id) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Current Times must be a 32-bit float scalar type"; } break; } case spv::Op::OpHitObjectTraceRayNV: { RegisterOpcodeForValidModel(_, inst); if (auto error = ValidateHitObjectPointer(_, inst, 0)) return error; if (auto error = ValidateHitObjectInstructionCommonParameters( _, inst, 1 /* Acceleration Struct */, KRayParamInvalidId /* Instance Id */, KRayParamInvalidId /* Primtive Id */, KRayParamInvalidId /* Geometry Index */, 2 /* Ray Flags */, 3 /* Cull Mask */, KRayParamInvalidId /* Hit Kind*/, KRayParamInvalidId /* SBT index */, 4 /* SBT Offset */, 5 /* SBT Stride */, KRayParamInvalidId /* SBT Record Offset */, KRayParamInvalidId /* SBT Record Stride */, 6 /* Miss Index */, 7 /* Ray Origin */, 8 /* Ray TMin */, 9 /* Ray Direction */, 10 /* Ray TMax */, 11 /* Payload */, KRayParamInvalidId /* Hit Object Attribute */)) return error; break; } case spv::Op::OpReorderThreadWithHitObjectNV: { std::string opcode_name = spvOpcodeString(inst->opcode()); _.function(inst->function()->id()) ->RegisterExecutionModelLimitation( [opcode_name](spv::ExecutionModel model, std::string* message) { if (model != spv::ExecutionModel::RayGenerationKHR) { if (message) { *message = opcode_name + " requires RayGenerationKHR execution model"; } return false; } return true; }); if (auto error = ValidateHitObjectPointer(_, inst, 0)) return error; if (inst->operands().size() > 1) { if (inst->operands().size() != 3) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Hint and Bits are optional together i.e " << " Either both Hint and Bits should be provided or neither."; } // Validate the optional opreands Hint and Bits const uint32_t hint_id = _.GetOperandTypeId(inst, 1); if (!_.IsIntScalarType(hint_id) || _.GetBitWidth(hint_id) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Hint must be a 32-bit int scalar"; } const uint32_t bits_id = _.GetOperandTypeId(inst, 2); if (!_.IsIntScalarType(bits_id) || _.GetBitWidth(bits_id) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "bits must be a 32-bit int scalar"; } } break; } case spv::Op::OpReorderThreadWithHintNV: { std::string opcode_name = spvOpcodeString(inst->opcode()); _.function(inst->function()->id()) ->RegisterExecutionModelLimitation( [opcode_name](spv::ExecutionModel model, std::string* message) { if (model != spv::ExecutionModel::RayGenerationKHR) { if (message) { *message = opcode_name + " requires RayGenerationKHR execution model"; } return false; } return true; }); const uint32_t hint_id = _.GetOperandTypeId(inst, 0); if (!_.IsIntScalarType(hint_id) || _.GetBitWidth(hint_id) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Hint must be a 32-bit int scalar"; } const uint32_t bits_id = _.GetOperandTypeId(inst, 1); if (!_.IsIntScalarType(bits_id) || _.GetBitWidth(bits_id) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "bits must be a 32-bit int scalar"; } break; } case spv::Op::OpHitObjectGetClusterIdNV: { RegisterOpcodeForValidModel(_, inst); if (auto error = ValidateHitObjectPointer(_, inst, 2)) return error; if (!_.IsIntScalarType(result_type) || _.GetBitWidth(result_type) != 32) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected 32-bit integer type scalar as Result Type: " << spvOpcodeString(opcode); break; } case spv::Op::OpHitObjectGetSpherePositionNV: { RegisterOpcodeForValidModel(_, inst); if (auto error = ValidateHitObjectPointer(_, inst, 2)) return error; if (!_.IsFloatVectorType(result_type) || _.GetDimension(result_type) != 3 || _.GetBitWidth(result_type) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected 32-bit floating point 2 component vector type as " "Result Type: " << spvOpcodeString(opcode); } break; } case spv::Op::OpHitObjectGetSphereRadiusNV: { RegisterOpcodeForValidModel(_, inst); if (auto error = ValidateHitObjectPointer(_, inst, 2)) return error; if (!_.IsFloatScalarType(result_type) || _.GetBitWidth(result_type) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected 32-bit floating point scalar as Result Type: " << spvOpcodeString(opcode); } break; } case spv::Op::OpHitObjectGetLSSPositionsNV: { RegisterOpcodeForValidModel(_, inst); if (auto error = ValidateHitObjectPointer(_, inst, 2)) return error; auto result_id = _.FindDef(result_type); if ((result_id->opcode() != spv::Op::OpTypeArray) || (GetArrayLength(_, result_id) != 2) || !_.IsFloatVectorType(_.GetComponentType(result_type)) || _.GetDimension(_.GetComponentType(result_type)) != 3) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected 2 element array of 32-bit 3 component float point " "vector as Result Type: " << spvOpcodeString(opcode); } break; } case spv::Op::OpHitObjectGetLSSRadiiNV: { RegisterOpcodeForValidModel(_, inst); if (auto error = ValidateHitObjectPointer(_, inst, 2)) return error; if (!_.IsFloatArrayType(result_type) || (GetArrayLength(_, _.FindDef(result_type)) != 2) || !_.IsFloatScalarType(_.GetComponentType(result_type))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected 2 element array of 32-bit floating point scalar as " "Result Type: " << spvOpcodeString(opcode); } break; } case spv::Op::OpHitObjectIsSphereHitNV: { RegisterOpcodeForValidModel(_, inst); if (auto error = ValidateHitObjectPointer(_, inst, 2)) return error; if (!_.IsBoolScalarType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Boolean scalar as Result Type: " << spvOpcodeString(opcode); } break; } case spv::Op::OpHitObjectIsLSSHitNV: { RegisterOpcodeForValidModel(_, inst); if (auto error = ValidateHitObjectPointer(_, inst, 2)) return error; if (!_.IsBoolScalarType(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Boolean scalar as Result Type: " << spvOpcodeString(opcode); } break; } default: break; } return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_scopes.cpp000066400000000000000000000310331475742701700244640ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/val/validate_scopes.h" #include "source/spirv_target_env.h" #include "source/val/instruction.h" #include "source/val/validation_state.h" namespace spvtools { namespace val { bool IsValidScope(uint32_t scope) { // Deliberately avoid a default case so we have to update the list when the // scopes list changes. switch (static_cast(scope)) { case spv::Scope::CrossDevice: case spv::Scope::Device: case spv::Scope::Workgroup: case spv::Scope::Subgroup: case spv::Scope::Invocation: case spv::Scope::QueueFamilyKHR: case spv::Scope::ShaderCallKHR: return true; case spv::Scope::Max: break; } return false; } spv_result_t ValidateScope(ValidationState_t& _, const Instruction* inst, uint32_t scope) { spv::Op opcode = inst->opcode(); bool is_int32 = false, is_const_int32 = false; uint32_t value = 0; std::tie(is_int32, is_const_int32, value) = _.EvalInt32IfConst(scope); if (!is_int32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": expected scope to be a 32-bit int"; } if (!is_const_int32) { if (_.HasCapability(spv::Capability::Shader) && !_.HasCapability(spv::Capability::CooperativeMatrixNV)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Scope ids must be OpConstant when Shader capability is " << "present"; } if (_.HasCapability(spv::Capability::Shader) && _.HasCapability(spv::Capability::CooperativeMatrixNV) && !spvOpcodeIsConstant(_.GetIdOpcode(scope))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Scope ids must be constant or specialization constant when " << "CooperativeMatrixNV capability is present"; } } if (is_const_int32 && !IsValidScope(value)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Invalid scope value:\n " << _.Disassemble(*_.FindDef(scope)); } return SPV_SUCCESS; } spv_result_t ValidateExecutionScope(ValidationState_t& _, const Instruction* inst, uint32_t scope) { spv::Op opcode = inst->opcode(); bool is_int32 = false, is_const_int32 = false; uint32_t tmp_value = 0; std::tie(is_int32, is_const_int32, tmp_value) = _.EvalInt32IfConst(scope); if (auto error = ValidateScope(_, inst, scope)) { return error; } if (!is_const_int32) { return SPV_SUCCESS; } spv::Scope value = spv::Scope(tmp_value); // Vulkan specific rules if (spvIsVulkanEnv(_.context()->target_env)) { // Vulkan 1.1 specific rules if (_.context()->target_env != SPV_ENV_VULKAN_1_0) { // Scope for Non Uniform Group Operations must be limited to Subgroup if ((spvOpcodeIsNonUniformGroupOperation(opcode) && (opcode != spv::Op::OpGroupNonUniformQuadAllKHR) && (opcode != spv::Op::OpGroupNonUniformQuadAnyKHR)) && (value != spv::Scope::Subgroup)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(4642) << spvOpcodeString(opcode) << ": in Vulkan environment Execution scope is limited to " << "Subgroup"; } } // OpControlBarrier must only use Subgroup execution scope for a subset of // execution models. if (opcode == spv::Op::OpControlBarrier && value != spv::Scope::Subgroup) { std::string errorVUID = _.VkErrorID(4682); _.function(inst->function()->id()) ->RegisterExecutionModelLimitation([errorVUID]( spv::ExecutionModel model, std::string* message) { if (model == spv::ExecutionModel::Fragment || model == spv::ExecutionModel::Vertex || model == spv::ExecutionModel::Geometry || model == spv::ExecutionModel::TessellationEvaluation || model == spv::ExecutionModel::RayGenerationKHR || model == spv::ExecutionModel::IntersectionKHR || model == spv::ExecutionModel::AnyHitKHR || model == spv::ExecutionModel::ClosestHitKHR || model == spv::ExecutionModel::MissKHR) { if (message) { *message = errorVUID + "in Vulkan environment, OpControlBarrier execution scope " "must be Subgroup for Fragment, Vertex, Geometry, " "TessellationEvaluation, RayGeneration, Intersection, " "AnyHit, ClosestHit, and Miss execution models"; } return false; } return true; }); } // Only subset of execution models support Workgroup. if (value == spv::Scope::Workgroup) { std::string errorVUID = _.VkErrorID(4637); _.function(inst->function()->id()) ->RegisterExecutionModelLimitation( [errorVUID](spv::ExecutionModel model, std::string* message) { if (model != spv::ExecutionModel::TaskNV && model != spv::ExecutionModel::MeshNV && model != spv::ExecutionModel::TaskEXT && model != spv::ExecutionModel::MeshEXT && model != spv::ExecutionModel::TessellationControl && model != spv::ExecutionModel::GLCompute) { if (message) { *message = errorVUID + "in Vulkan environment, Workgroup execution scope is " "only for TaskNV, MeshNV, TaskEXT, MeshEXT, " "TessellationControl, and GLCompute execution models"; } return false; } return true; }); } // Vulkan generic rules // Scope for execution must be limited to Workgroup or Subgroup if (value != spv::Scope::Workgroup && value != spv::Scope::Subgroup) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(4636) << spvOpcodeString(opcode) << ": in Vulkan environment Execution Scope is limited to " << "Workgroup and Subgroup"; } } // TODO(atgoo@github.com) Add checks for OpenCL and OpenGL environments. // General SPIRV rules // Scope for execution must be limited to Workgroup or Subgroup for // non-uniform operations if (spvOpcodeIsNonUniformGroupOperation(opcode) && opcode != spv::Op::OpGroupNonUniformQuadAllKHR && opcode != spv::Op::OpGroupNonUniformQuadAnyKHR && value != spv::Scope::Subgroup && value != spv::Scope::Workgroup) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": Execution scope is limited to Subgroup or Workgroup"; } return SPV_SUCCESS; } spv_result_t ValidateMemoryScope(ValidationState_t& _, const Instruction* inst, uint32_t scope) { const spv::Op opcode = inst->opcode(); bool is_int32 = false, is_const_int32 = false; uint32_t tmp_value = 0; std::tie(is_int32, is_const_int32, tmp_value) = _.EvalInt32IfConst(scope); if (auto error = ValidateScope(_, inst, scope)) { return error; } if (!is_const_int32) { return SPV_SUCCESS; } spv::Scope value = spv::Scope(tmp_value); if (value == spv::Scope::QueueFamilyKHR) { if (_.HasCapability(spv::Capability::VulkanMemoryModelKHR)) { return SPV_SUCCESS; } else { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << ": Memory Scope QueueFamilyKHR requires capability " << "VulkanMemoryModelKHR"; } } if (value == spv::Scope::Device && _.HasCapability(spv::Capability::VulkanMemoryModelKHR) && !_.HasCapability(spv::Capability::VulkanMemoryModelDeviceScopeKHR)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Use of device scope with VulkanKHR memory model requires the " << "VulkanMemoryModelDeviceScopeKHR capability"; } // Vulkan Specific rules if (spvIsVulkanEnv(_.context()->target_env)) { if (value != spv::Scope::Device && value != spv::Scope::Workgroup && value != spv::Scope::Subgroup && value != spv::Scope::Invocation && value != spv::Scope::ShaderCallKHR && value != spv::Scope::QueueFamily) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(4638) << spvOpcodeString(opcode) << ": in Vulkan environment Memory Scope is limited to Device, " "QueueFamily, Workgroup, ShaderCallKHR, Subgroup, or " "Invocation"; } else if (_.context()->target_env == SPV_ENV_VULKAN_1_0 && value == spv::Scope::Subgroup && !_.HasCapability(spv::Capability::SubgroupBallotKHR) && !_.HasCapability(spv::Capability::SubgroupVoteKHR)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(7951) << spvOpcodeString(opcode) << ": in Vulkan 1.0 environment Memory Scope is can not be " "Subgroup without SubgroupBallotKHR or SubgroupVoteKHR " "declared"; } if (value == spv::Scope::ShaderCallKHR) { std::string errorVUID = _.VkErrorID(4640); _.function(inst->function()->id()) ->RegisterExecutionModelLimitation( [errorVUID](spv::ExecutionModel model, std::string* message) { if (model != spv::ExecutionModel::RayGenerationKHR && model != spv::ExecutionModel::IntersectionKHR && model != spv::ExecutionModel::AnyHitKHR && model != spv::ExecutionModel::ClosestHitKHR && model != spv::ExecutionModel::MissKHR && model != spv::ExecutionModel::CallableKHR) { if (message) { *message = errorVUID + "ShaderCallKHR Memory Scope requires a ray tracing " "execution model"; } return false; } return true; }); } if (value == spv::Scope::Workgroup) { std::string errorVUID = _.VkErrorID(7321); _.function(inst->function()->id()) ->RegisterExecutionModelLimitation( [errorVUID](spv::ExecutionModel model, std::string* message) { if (model != spv::ExecutionModel::GLCompute && model != spv::ExecutionModel::TessellationControl && model != spv::ExecutionModel::TaskNV && model != spv::ExecutionModel::MeshNV && model != spv::ExecutionModel::TaskEXT && model != spv::ExecutionModel::MeshEXT) { if (message) { *message = errorVUID + "Workgroup Memory Scope is limited to MeshNV, " "TaskNV, MeshEXT, TaskEXT, TessellationControl, " "and GLCompute execution model"; } return false; } return true; }); if (_.memory_model() == spv::MemoryModel::GLSL450) { errorVUID = _.VkErrorID(7320); _.function(inst->function()->id()) ->RegisterExecutionModelLimitation( [errorVUID](spv::ExecutionModel model, std::string* message) { if (model == spv::ExecutionModel::TessellationControl) { if (message) { *message = errorVUID + "Workgroup Memory Scope can't be used with " "TessellationControl using GLSL450 Memory Model"; } return false; } return true; }); } } } // TODO(atgoo@github.com) Add checks for OpenCL and OpenGL environments. return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_scopes.h000066400000000000000000000022411475742701700241300ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validates correctness of scopes for SPIR-V instructions. #include "source/opcode.h" #include "source/val/validate.h" namespace spvtools { namespace val { spv_result_t ValidateScope(ValidationState_t& _, const Instruction* inst, uint32_t scope); spv_result_t ValidateExecutionScope(ValidationState_t& _, const Instruction* inst, uint32_t scope); spv_result_t ValidateMemoryScope(ValidationState_t& _, const Instruction* inst, uint32_t scope); } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_small_type_uses.cpp000066400000000000000000000035641475742701700264100ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/val/validate.h" #include "source/val/instruction.h" #include "source/val/validation_state.h" namespace spvtools { namespace val { spv_result_t ValidateSmallTypeUses(ValidationState_t& _, const Instruction* inst) { if (!_.HasCapability(spv::Capability::Shader) || inst->type_id() == 0 || !_.ContainsLimitedUseIntOrFloatType(inst->type_id())) { return SPV_SUCCESS; } if (_.IsPointerType(inst->type_id())) return SPV_SUCCESS; // The validator should previously have checked ways to generate 8- or 16-bit // types. So we only need to considervalid paths from source to sink. // When restricted, uses of 8- or 16-bit types can only be stores, // width-only conversions, decorations and copy object. for (auto use : inst->uses()) { const auto* user = use.first; switch (user->opcode()) { case spv::Op::OpDecorate: case spv::Op::OpDecorateId: case spv::Op::OpCopyObject: case spv::Op::OpStore: case spv::Op::OpFConvert: case spv::Op::OpUConvert: case spv::Op::OpSConvert: break; default: return _.diag(SPV_ERROR_INVALID_ID, user) << "Invalid use of 8- or 16-bit result"; } } return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_tensor_layout.cpp000066400000000000000000000143171475742701700261050ustar00rootroot00000000000000// Copyright (c) 2024 NVIDIA Corporation // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validate instructions that manipulate tensor layout and view objects #include "source/opcode.h" #include "source/spirv_target_env.h" #include "source/val/instruction.h" #include "source/val/validate.h" #include "source/val/validation_state.h" namespace spvtools { namespace val { namespace { spv_result_t ValidateTensorLayoutResultTypeNV(ValidationState_t& _, const Instruction* inst) { const auto result_type_index = 0; const auto result_type_id = inst->GetOperandAs(result_type_index); const auto result_type = _.FindDef(result_type_id); if (!result_type || spv::Op::OpTypeTensorLayoutNV != result_type->opcode()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << spvOpcodeString(inst->opcode()) << " Result Type " << _.getIdName(result_type_id) << " is not a tensor layout type."; } return SPV_SUCCESS; } spv_result_t ValidateTensorViewResultTypeNV(ValidationState_t& _, const Instruction* inst) { const auto result_type_index = 0; const auto result_type_id = inst->GetOperandAs(result_type_index); const auto result_type = _.FindDef(result_type_id); if (!result_type || spv::Op::OpTypeTensorViewNV != result_type->opcode()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << spvOpcodeString(inst->opcode()) << " Result Type " << _.getIdName(result_type_id) << " is not a tensor view type."; } return SPV_SUCCESS; } spv_result_t ValidateCreateTensorLayoutNV(ValidationState_t& _, const Instruction* inst) { if (auto error = ValidateTensorLayoutResultTypeNV(_, inst)) return error; return SPV_SUCCESS; } spv_result_t ValidateCreateTensorViewNV(ValidationState_t& _, const Instruction* inst) { if (auto error = ValidateTensorViewResultTypeNV(_, inst)) return error; return SPV_SUCCESS; } enum ExpectedNumValues { DIM, DIMx2, ONE, FOUR, }; spv_result_t ValidateTensorTypeWithDimValuesNV(ValidationState_t& _, const Instruction* inst, ExpectedNumValues expected, bool is_view) { std::string type_str; if (is_view) { if (auto error = ValidateTensorViewResultTypeNV(_, inst)) return error; type_str = "TensorView"; } else { if (auto error = ValidateTensorLayoutResultTypeNV(_, inst)) return error; type_str = "TensorLayout"; } const auto result_type_id = inst->GetOperandAs(0); const auto tensor_id = inst->GetOperandAs(2); const auto tensor = _.FindDef(tensor_id); if (!tensor || result_type_id != tensor->type_id()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << spvOpcodeString(inst->opcode()) << " Result Type " << _.getIdName(result_type_id) << " does not match " << type_str << " type."; } const auto num_values = inst->operands().size() - 3; const auto result_type = _.FindDef(result_type_id); const auto dim_index = 1; const auto dim_id = result_type->GetOperandAs(dim_index); uint64_t dim_value; if (_.EvalConstantValUint64(dim_id, &dim_value)) { uint64_t expected_num_values = 0; switch (expected) { case DIM: expected_num_values = dim_value; break; case DIMx2: expected_num_values = dim_value * 2; break; case ONE: expected_num_values = 1; break; case FOUR: expected_num_values = 4; break; } if (num_values != expected_num_values) { return _.diag(SPV_ERROR_INVALID_ID, inst) << spvOpcodeString(inst->opcode()) << " unexpected number of operands."; } } for (uint32_t i = 0; i < num_values; ++i) { const auto val_id = inst->GetOperandAs(i + 3); const auto val = _.FindDef(val_id); if (!val || !_.IsIntScalarType(val->type_id()) || _.GetBitWidth(val->type_id()) != 32) { return _.diag(SPV_ERROR_INVALID_ID, inst) << spvOpcodeString(inst->opcode()) << " operand " << _.getIdName(val_id) << " is not a 32-bit integer."; } } return SPV_SUCCESS; } } // namespace spv_result_t TensorLayoutPass(ValidationState_t& _, const Instruction* inst) { switch (inst->opcode()) { case spv::Op::OpCreateTensorLayoutNV: if (auto error = ValidateCreateTensorLayoutNV(_, inst)) return error; break; case spv::Op::OpCreateTensorViewNV: if (auto error = ValidateCreateTensorViewNV(_, inst)) return error; break; case spv::Op::OpTensorLayoutSetBlockSizeNV: case spv::Op::OpTensorLayoutSetDimensionNV: case spv::Op::OpTensorLayoutSetStrideNV: if (auto error = ValidateTensorTypeWithDimValuesNV(_, inst, DIM, false)) return error; break; case spv::Op::OpTensorLayoutSliceNV: if (auto error = ValidateTensorTypeWithDimValuesNV(_, inst, DIMx2, false)) return error; break; case spv::Op::OpTensorLayoutSetClampValueNV: if (auto error = ValidateTensorTypeWithDimValuesNV(_, inst, ONE, false)) return error; break; case spv::Op::OpTensorViewSetDimensionNV: case spv::Op::OpTensorViewSetStrideNV: if (auto error = ValidateTensorTypeWithDimValuesNV(_, inst, DIM, true)) return error; break; case spv::Op::OpTensorViewSetClipNV: if (auto error = ValidateTensorTypeWithDimValuesNV(_, inst, FOUR, true)) return error; break; default: break; } return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validate_type.cpp000066400000000000000000001101761475742701700241570ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // Modifications Copyright (C) 2024 Advanced Micro Devices, Inc. All rights // reserved. // Copyright (c) 2024 NVIDIA Corporation // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Ensures type declarations are unique unless allowed by the specification. #include "source/opcode.h" #include "source/spirv_target_env.h" #include "source/val/instruction.h" #include "source/val/validate.h" #include "source/val/validation_state.h" namespace spvtools { namespace val { namespace { // Validates that type declarations are unique, unless multiple declarations // of the same data type are allowed by the specification. // (see section 2.8 Types and Variables) // Doesn't do anything if SPV_VAL_ignore_type_decl_unique was declared in the // module. spv_result_t ValidateUniqueness(ValidationState_t& _, const Instruction* inst) { if (_.HasExtension(Extension::kSPV_VALIDATOR_ignore_type_decl_unique)) return SPV_SUCCESS; const auto opcode = inst->opcode(); if (opcode != spv::Op::OpTypeArray && opcode != spv::Op::OpTypeRuntimeArray && opcode != spv::Op::OpTypeNodePayloadArrayAMDX && opcode != spv::Op::OpTypeStruct && opcode != spv::Op::OpTypePointer && opcode != spv::Op::OpTypeUntypedPointerKHR && !_.RegisterUniqueTypeDeclaration(inst)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Duplicate non-aggregate type declarations are not allowed. " "Opcode: " << spvOpcodeString(opcode) << " id: " << inst->id(); } return SPV_SUCCESS; } spv_result_t ValidateTypeInt(ValidationState_t& _, const Instruction* inst) { // Validates that the number of bits specified for an Int type is valid. // Scalar integer types can be parameterized only with 32-bits. // Int8, Int16, and Int64 capabilities allow using 8-bit, 16-bit, and 64-bit // integers, respectively. auto num_bits = inst->GetOperandAs(1); if (num_bits != 32) { if (num_bits == 8) { if (_.features().declare_int8_type) { return SPV_SUCCESS; } return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Using an 8-bit integer type requires the Int8 capability," " or an extension that explicitly enables 8-bit integers."; } else if (num_bits == 16) { if (_.features().declare_int16_type) { return SPV_SUCCESS; } return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Using a 16-bit integer type requires the Int16 capability," " or an extension that explicitly enables 16-bit integers."; } else if (num_bits == 64) { if (_.HasCapability(spv::Capability::Int64)) { return SPV_SUCCESS; } return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Using a 64-bit integer type requires the Int64 capability."; } else { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Invalid number of bits (" << num_bits << ") used for OpTypeInt."; } } const auto signedness_index = 2; const auto signedness = inst->GetOperandAs(signedness_index); if (signedness != 0 && signedness != 1) { return _.diag(SPV_ERROR_INVALID_VALUE, inst) << "OpTypeInt has invalid signedness:"; } // SPIR-V Spec 2.16.3: Validation Rules for Kernel Capabilities: The // Signedness in OpTypeInt must always be 0. if (spv::Op::OpTypeInt == inst->opcode() && _.HasCapability(spv::Capability::Kernel) && inst->GetOperandAs(2) != 0u) { return _.diag(SPV_ERROR_INVALID_BINARY, inst) << "The Signedness in OpTypeInt " "must always be 0 when Kernel " "capability is used."; } return SPV_SUCCESS; } spv_result_t ValidateTypeFloat(ValidationState_t& _, const Instruction* inst) { // Validates that the number of bits specified for an Int type is valid. // Scalar integer types can be parameterized only with 32-bits. // Int8, Int16, and Int64 capabilities allow using 8-bit, 16-bit, and 64-bit // integers, respectively. auto num_bits = inst->GetOperandAs(1); if (num_bits == 32) { return SPV_SUCCESS; } if (num_bits == 16) { if (_.features().declare_float16_type) { return SPV_SUCCESS; } return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Using a 16-bit floating point " << "type requires the Float16 or Float16Buffer capability," " or an extension that explicitly enables 16-bit floating point."; } if (num_bits == 64) { if (_.HasCapability(spv::Capability::Float64)) { return SPV_SUCCESS; } return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Using a 64-bit floating point " << "type requires the Float64 capability."; } return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Invalid number of bits (" << num_bits << ") used for OpTypeFloat."; } spv_result_t ValidateTypeVector(ValidationState_t& _, const Instruction* inst) { const auto component_index = 1; const auto component_id = inst->GetOperandAs(component_index); const auto component_type = _.FindDef(component_id); if (!component_type || !spvOpcodeIsScalarType(component_type->opcode())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpTypeVector Component Type " << _.getIdName(component_id) << " is not a scalar type."; } // Validates that the number of components in the vector is valid. // Vector types can only be parameterized as having 2, 3, or 4 components. // If the Vector16 capability is added, 8 and 16 components are also allowed. auto num_components = inst->GetOperandAs(2); if (num_components == 2 || num_components == 3 || num_components == 4) { return SPV_SUCCESS; } else if (num_components == 8 || num_components == 16) { if (_.HasCapability(spv::Capability::Vector16)) { return SPV_SUCCESS; } return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Having " << num_components << " components for " << spvOpcodeString(inst->opcode()) << " requires the Vector16 capability"; } else { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Illegal number of components (" << num_components << ") for " << spvOpcodeString(inst->opcode()); } return SPV_SUCCESS; } spv_result_t ValidateTypeCooperativeVectorNV(ValidationState_t& _, const Instruction* inst) { const auto component_index = 1; const auto component_type_id = inst->GetOperandAs(component_index); const auto component_type = _.FindDef(component_type_id); if (!component_type || (spv::Op::OpTypeFloat != component_type->opcode() && spv::Op::OpTypeInt != component_type->opcode())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpTypeCooperativeVectorNV Component Type " << _.getIdName(component_type_id) << " is not a scalar numerical type."; } const auto num_components_index = 2; const auto num_components_id = inst->GetOperandAs(num_components_index); const auto num_components = _.FindDef(num_components_id); if (!num_components || !spvOpcodeIsConstant(num_components->opcode())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpTypeCooperativeVectorNV component count " << _.getIdName(num_components_id) << " is not a scalar constant type."; } // NOTE: Check the initialiser value of the constant const auto const_inst = num_components->words(); const auto const_result_type_index = 1; const auto const_result_type = _.FindDef(const_inst[const_result_type_index]); if (!const_result_type || spv::Op::OpTypeInt != const_result_type->opcode()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpTypeCooperativeVectorNV component count " << _.getIdName(num_components_id) << " is not a constant integer type."; } int64_t num_components_value; if (_.EvalConstantValInt64(num_components_id, &num_components_value)) { auto& type_words = const_result_type->words(); const bool is_signed = type_words[3] > 0; if (num_components_value == 0 || (num_components_value < 0 && is_signed)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpTypeCooperativeVectorNV component count " << _.getIdName(num_components_id) << " default value must be at least 1: found " << num_components_value; } } return SPV_SUCCESS; } spv_result_t ValidateTypeMatrix(ValidationState_t& _, const Instruction* inst) { const auto column_type_index = 1; const auto column_type_id = inst->GetOperandAs(column_type_index); const auto column_type = _.FindDef(column_type_id); if (!column_type || spv::Op::OpTypeVector != column_type->opcode()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Columns in a matrix must be of type vector."; } // Trace back once more to find out the type of components in the vector. // Operand 1 is the of the type of data in the vector. const auto comp_type_id = column_type->GetOperandAs(1); auto comp_type_instruction = _.FindDef(comp_type_id); if (comp_type_instruction->opcode() != spv::Op::OpTypeFloat) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Matrix types can only be " "parameterized with " "floating-point types."; } // Validates that the matrix has 2,3, or 4 columns. auto num_cols = inst->GetOperandAs(2); if (num_cols != 2 && num_cols != 3 && num_cols != 4) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Matrix types can only be " "parameterized as having " "only 2, 3, or 4 columns."; } return SPV_SUCCESS; } spv_result_t ValidateTypeArray(ValidationState_t& _, const Instruction* inst) { const auto element_type_index = 1; const auto element_type_id = inst->GetOperandAs(element_type_index); const auto element_type = _.FindDef(element_type_id); if (!element_type || !spvOpcodeGeneratesType(element_type->opcode())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpTypeArray Element Type " << _.getIdName(element_type_id) << " is not a type."; } if (element_type->opcode() == spv::Op::OpTypeVoid) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpTypeArray Element Type " << _.getIdName(element_type_id) << " is a void type."; } if (_.HasCapability(spv::Capability::Shader)) { if (element_type->opcode() == spv::Op::OpTypeStruct && (_.HasDecoration(element_type->id(), spv::Decoration::Block) || _.HasDecoration(element_type->id(), spv::Decoration::BufferBlock))) { if (_.HasDecoration(inst->id(), spv::Decoration::ArrayStride)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Array containing a Block or BufferBlock must not be " "decorated with ArrayStride"; } } } if (spvIsVulkanEnv(_.context()->target_env) && element_type->opcode() == spv::Op::OpTypeRuntimeArray) { return _.diag(SPV_ERROR_INVALID_ID, inst) << _.VkErrorID(4680) << "OpTypeArray Element Type " << _.getIdName(element_type_id) << " is not valid in " << spvLogStringForEnv(_.context()->target_env) << " environments."; } const auto length_index = 2; const auto length_id = inst->GetOperandAs(length_index); const auto length = _.FindDef(length_id); if (!length || !spvOpcodeIsConstant(length->opcode())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpTypeArray Length " << _.getIdName(length_id) << " is not a scalar constant type."; } // NOTE: Check the initialiser value of the constant const auto const_inst = length->words(); const auto const_result_type_index = 1; const auto const_result_type = _.FindDef(const_inst[const_result_type_index]); if (!const_result_type || spv::Op::OpTypeInt != const_result_type->opcode()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpTypeArray Length " << _.getIdName(length_id) << " is not a constant integer type."; } int64_t length_value; if (_.EvalConstantValInt64(length_id, &length_value)) { auto& type_words = const_result_type->words(); const bool is_signed = type_words[3] > 0; if (length_value == 0 || (length_value < 0 && is_signed)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpTypeArray Length " << _.getIdName(length_id) << " default value must be at least 1: found " << length_value; } } return SPV_SUCCESS; } spv_result_t ValidateTypeRuntimeArray(ValidationState_t& _, const Instruction* inst) { const auto element_type_index = 1; const auto element_id = inst->GetOperandAs(element_type_index); const auto element_type = _.FindDef(element_id); if (!element_type || !spvOpcodeGeneratesType(element_type->opcode())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpTypeRuntimeArray Element Type " << _.getIdName(element_id) << " is not a type."; } if (element_type->opcode() == spv::Op::OpTypeVoid) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpTypeRuntimeArray Element Type " << _.getIdName(element_id) << " is a void type."; } if (_.HasCapability(spv::Capability::Shader)) { if (element_type->opcode() == spv::Op::OpTypeStruct && (_.HasDecoration(element_type->id(), spv::Decoration::Block) || _.HasDecoration(element_type->id(), spv::Decoration::BufferBlock))) { if (_.HasDecoration(inst->id(), spv::Decoration::ArrayStride)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Array containing a Block or BufferBlock must not be " "decorated with ArrayStride"; } } } if (spvIsVulkanEnv(_.context()->target_env) && element_type->opcode() == spv::Op::OpTypeRuntimeArray) { return _.diag(SPV_ERROR_INVALID_ID, inst) << _.VkErrorID(4680) << "OpTypeRuntimeArray Element Type " << _.getIdName(element_id) << " is not valid in " << spvLogStringForEnv(_.context()->target_env) << " environments."; } return SPV_SUCCESS; } spv_result_t ValidateTypeStruct(ValidationState_t& _, const Instruction* inst) { const uint32_t struct_id = inst->GetOperandAs(0); for (size_t member_type_index = 1; member_type_index < inst->operands().size(); ++member_type_index) { auto member_type_id = inst->GetOperandAs(member_type_index); if (member_type_id == inst->id()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Structure members may not be self references"; } auto member_type = _.FindDef(member_type_id); if (!member_type || !spvOpcodeGeneratesType(member_type->opcode())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpTypeStruct Member Type " << _.getIdName(member_type_id) << " is not a type."; } if (member_type->opcode() == spv::Op::OpTypeVoid) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Structures cannot contain a void type."; } if (spv::Op::OpTypeStruct == member_type->opcode() && _.IsStructTypeWithBuiltInMember(member_type_id)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Structure " << _.getIdName(member_type_id) << " contains members with BuiltIn decoration. Therefore this " << "structure may not be contained as a member of another " << "structure " << "type. Structure " << _.getIdName(struct_id) << " contains structure " << _.getIdName(member_type_id) << "."; } if (spvIsVulkanEnv(_.context()->target_env) && member_type->opcode() == spv::Op::OpTypeRuntimeArray) { const bool is_last_member = member_type_index == inst->operands().size() - 1; if (!is_last_member) { return _.diag(SPV_ERROR_INVALID_ID, inst) << _.VkErrorID(4680) << "In " << spvLogStringForEnv(_.context()->target_env) << ", OpTypeRuntimeArray must only be used for the last member " "of an OpTypeStruct"; } if (!_.HasDecoration(inst->id(), spv::Decoration::Block) && !_.HasDecoration(inst->id(), spv::Decoration::BufferBlock)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << _.VkErrorID(4680) << spvLogStringForEnv(_.context()->target_env) << ", OpTypeStruct containing an OpTypeRuntimeArray " << "must be decorated with Block or BufferBlock."; } } } bool has_nested_blockOrBufferBlock_struct = false; // Struct members start at word 2 of OpTypeStruct instruction. for (size_t word_i = 2; word_i < inst->words().size(); ++word_i) { auto member = inst->word(word_i); if (_.ContainsType( member, [&_](const Instruction* type_inst) { if (type_inst->opcode() == spv::Op::OpTypeStruct && (_.HasDecoration(type_inst->id(), spv::Decoration::Block) || _.HasDecoration(type_inst->id(), spv::Decoration::BufferBlock))) { return true; } return false; }, /* traverse_all_types = */ false)) { has_nested_blockOrBufferBlock_struct = true; break; } } _.SetHasNestedBlockOrBufferBlockStruct(inst->id(), has_nested_blockOrBufferBlock_struct); if (_.GetHasNestedBlockOrBufferBlockStruct(inst->id()) && (_.HasDecoration(inst->id(), spv::Decoration::BufferBlock) || _.HasDecoration(inst->id(), spv::Decoration::Block))) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "rules: A Block or BufferBlock cannot be nested within another " "Block or BufferBlock. "; } std::unordered_set built_in_members; for (auto decoration : _.id_decorations(struct_id)) { if (decoration.dec_type() == spv::Decoration::BuiltIn && decoration.struct_member_index() != Decoration::kInvalidMember) { built_in_members.insert(decoration.struct_member_index()); } } int num_struct_members = static_cast(inst->operands().size() - 1); int num_builtin_members = static_cast(built_in_members.size()); if (num_builtin_members > 0 && num_builtin_members != num_struct_members) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "When BuiltIn decoration is applied to a structure-type member, " << "all members of that structure type must also be decorated with " << "BuiltIn (No allowed mixing of built-in variables and " << "non-built-in variables within a single structure). Structure id " << struct_id << " does not meet this requirement."; } if (num_builtin_members > 0) { _.RegisterStructTypeWithBuiltInMember(struct_id); } const auto isOpaqueType = [&_](const Instruction* opaque_inst) { auto opcode = opaque_inst->opcode(); if (_.HasCapability(spv::Capability::BindlessTextureNV) && (opcode == spv::Op::OpTypeImage || opcode == spv::Op::OpTypeSampler || opcode == spv::Op::OpTypeSampledImage)) { return false; } else if (spvOpcodeIsBaseOpaqueType(opcode)) { return true; } return false; }; if (spvIsVulkanEnv(_.context()->target_env) && !_.options()->before_hlsl_legalization && _.ContainsType(inst->id(), isOpaqueType)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << _.VkErrorID(4667) << "In " << spvLogStringForEnv(_.context()->target_env) << ", OpTypeStruct must not contain an opaque type."; } return SPV_SUCCESS; } spv_result_t ValidateTypePointer(ValidationState_t& _, const Instruction* inst) { auto type_id = inst->GetOperandAs(2); auto type = _.FindDef(type_id); if (!type || !spvOpcodeGeneratesType(type->opcode())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpTypePointer Type " << _.getIdName(type_id) << " is not a type."; } // See if this points to a storage image. const auto storage_class = inst->GetOperandAs(1); if (storage_class == spv::StorageClass::UniformConstant) { // Unpack an optional level of arraying. if (type->opcode() == spv::Op::OpTypeArray || type->opcode() == spv::Op::OpTypeRuntimeArray) { type_id = type->GetOperandAs(1); type = _.FindDef(type_id); } if (type->opcode() == spv::Op::OpTypeImage) { const auto sampled = type->GetOperandAs(6); // 2 indicates this image is known to be be used without a sampler, i.e. // a storage image. if (sampled == 2) _.RegisterPointerToStorageImage(inst->id()); } } if (!_.IsValidStorageClass(storage_class)) { return _.diag(SPV_ERROR_INVALID_BINARY, inst) << _.VkErrorID(4643) << "Invalid storage class for target environment"; } return SPV_SUCCESS; } spv_result_t ValidateTypeFunction(ValidationState_t& _, const Instruction* inst) { const auto return_type_id = inst->GetOperandAs(1); const auto return_type = _.FindDef(return_type_id); if (!return_type || !spvOpcodeGeneratesType(return_type->opcode())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpTypeFunction Return Type " << _.getIdName(return_type_id) << " is not a type."; } size_t num_args = 0; for (size_t param_type_index = 2; param_type_index < inst->operands().size(); ++param_type_index, ++num_args) { const auto param_id = inst->GetOperandAs(param_type_index); const auto param_type = _.FindDef(param_id); if (!param_type || !spvOpcodeGeneratesType(param_type->opcode())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpTypeFunction Parameter Type " << _.getIdName(param_id) << " is not a type."; } if (param_type->opcode() == spv::Op::OpTypeVoid) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpTypeFunction Parameter Type " << _.getIdName(param_id) << " cannot be OpTypeVoid."; } } const uint32_t num_function_args_limit = _.options()->universal_limits_.max_function_args; if (num_args > num_function_args_limit) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpTypeFunction may not take more than " << num_function_args_limit << " arguments. OpTypeFunction " << _.getIdName(inst->GetOperandAs(0)) << " has " << num_args << " arguments."; } // The only valid uses of OpTypeFunction are in an OpFunction, debugging, or // decoration instruction. for (auto& pair : inst->uses()) { const auto* use = pair.first; if (use->opcode() != spv::Op::OpFunction && !spvOpcodeIsDebug(use->opcode()) && !use->IsNonSemantic() && !spvOpcodeIsDecoration(use->opcode())) { return _.diag(SPV_ERROR_INVALID_ID, use) << "Invalid use of function type result id " << _.getIdName(inst->id()) << "."; } } return SPV_SUCCESS; } spv_result_t ValidateTypeForwardPointer(ValidationState_t& _, const Instruction* inst) { const auto pointer_type_id = inst->GetOperandAs(0); const auto pointer_type_inst = _.FindDef(pointer_type_id); if (pointer_type_inst->opcode() != spv::Op::OpTypePointer) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Pointer type in OpTypeForwardPointer is not a pointer type."; } const auto storage_class = inst->GetOperandAs(1); if (storage_class != pointer_type_inst->GetOperandAs(1)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Storage class in OpTypeForwardPointer does not match the " << "pointer definition."; } const auto pointee_type_id = pointer_type_inst->GetOperandAs(2); const auto pointee_type = _.FindDef(pointee_type_id); if (!pointee_type || pointee_type->opcode() != spv::Op::OpTypeStruct) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Forward pointers must point to a structure"; } if (spvIsVulkanEnv(_.context()->target_env)) { if (storage_class != spv::StorageClass::PhysicalStorageBuffer) { return _.diag(SPV_ERROR_INVALID_ID, inst) << _.VkErrorID(4711) << "In Vulkan, OpTypeForwardPointer must have " << "a storage class of PhysicalStorageBuffer."; } } return SPV_SUCCESS; } spv_result_t ValidateTypeCooperativeMatrix(ValidationState_t& _, const Instruction* inst) { const auto component_type_index = 1; const auto component_type_id = inst->GetOperandAs(component_type_index); const auto component_type = _.FindDef(component_type_id); if (!component_type || (spv::Op::OpTypeFloat != component_type->opcode() && spv::Op::OpTypeInt != component_type->opcode())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpTypeCooperativeMatrix Component Type " << _.getIdName(component_type_id) << " is not a scalar numerical type."; } const auto scope_index = 2; const auto scope_id = inst->GetOperandAs(scope_index); const auto scope = _.FindDef(scope_id); if (!scope || !_.IsIntScalarType(scope->type_id()) || !spvOpcodeIsConstant(scope->opcode())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpTypeCooperativeMatrix Scope " << _.getIdName(scope_id) << " is not a constant instruction with scalar integer type."; } const auto rows_index = 3; const auto rows_id = inst->GetOperandAs(rows_index); const auto rows = _.FindDef(rows_id); if (!rows || !_.IsIntScalarType(rows->type_id()) || !spvOpcodeIsConstant(rows->opcode())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpTypeCooperativeMatrix Rows " << _.getIdName(rows_id) << " is not a constant instruction with scalar integer type."; } const auto cols_index = 4; const auto cols_id = inst->GetOperandAs(cols_index); const auto cols = _.FindDef(cols_id); if (!cols || !_.IsIntScalarType(cols->type_id()) || !spvOpcodeIsConstant(cols->opcode())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpTypeCooperativeMatrix Cols " << _.getIdName(cols_id) << " is not a constant instruction with scalar integer type."; } if (inst->opcode() == spv::Op::OpTypeCooperativeMatrixKHR) { const auto use_index = 5; const auto use_id = inst->GetOperandAs(use_index); const auto use = _.FindDef(use_id); if (!use || !_.IsIntScalarType(use->type_id()) || !spvOpcodeIsConstant(use->opcode())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpTypeCooperativeMatrixKHR Use " << _.getIdName(use_id) << " is not a constant instruction with scalar integer type."; } } uint64_t scope_value; if (_.EvalConstantValUint64(scope_id, &scope_value)) { if (scope_value == static_cast(spv::Scope::Workgroup)) { for (auto entry_point_id : _.entry_points()) { if (!_.EntryPointHasLocalSizeOrId(entry_point_id)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpTypeCooperativeMatrixKHR with ScopeWorkgroup " << "used without specifying LocalSize or LocalSizeId " << "for entry point " << _.getIdName(entry_point_id); } const auto local_size = _.EntryPointLocalSizeOrId(entry_point_id); const auto mode = local_size->GetOperandAs(1); if (mode == spv::ExecutionMode::LocalSizeId) { uint32_t local_size_ids[3] = { local_size->GetOperandAs(2), local_size->GetOperandAs(3), local_size->GetOperandAs(4), }; for (auto id : local_size_ids) { if (_.FindDef(id) > inst) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpTypeCooperativeMatrixKHR with ScopeWorkgroup " << "used before LocalSizeId constant value " << _.getIdName(id) << " is defined."; } } } } } } return SPV_SUCCESS; } spv_result_t ValidateTypeUntypedPointerKHR(ValidationState_t& _, const Instruction* inst) { if (spvIsVulkanEnv(_.context()->target_env)) { const auto sc = inst->GetOperandAs(1); switch (sc) { case spv::StorageClass::Workgroup: if (!_.HasCapability( spv::Capability::WorkgroupMemoryExplicitLayoutKHR)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Workgroup storage class untyped pointers in Vulkan " "require WorkgroupMemoryExplicitLayoutKHR be declared"; } break; case spv::StorageClass::StorageBuffer: case spv::StorageClass::PhysicalStorageBuffer: case spv::StorageClass::Uniform: case spv::StorageClass::PushConstant: break; default: return _.diag(SPV_ERROR_INVALID_ID, inst) << "In Vulkan, untyped pointers can only be used in an " "explicitly laid out storage class"; } } return SPV_SUCCESS; } spv_result_t ValidateTensorDim(ValidationState_t& _, const Instruction* inst) { const auto dim_index = 1; const auto dim_id = inst->GetOperandAs(dim_index); const auto dim = _.FindDef(dim_id); if (!dim || !_.IsIntScalarType(dim->type_id()) || _.GetBitWidth(dim->type_id()) != 32) { return _.diag(SPV_ERROR_INVALID_ID, inst) << spvOpcodeString(inst->opcode()) << " Dim " << _.getIdName(dim_id) << " is not a 32-bit integer."; } constexpr uint32_t max_tensor_dim = 5; uint64_t dim_value; if (_.EvalConstantValUint64(dim_id, &dim_value)) { if (dim_value == 0 || dim_value > max_tensor_dim) { return _.diag(SPV_ERROR_INVALID_ID, inst) << spvOpcodeString(inst->opcode()) << " Dim " << _.getIdName(dim_id) << " must be between 1 and " << max_tensor_dim << "."; } } return SPV_SUCCESS; } spv_result_t ValidateTypeTensorLayoutNV(ValidationState_t& _, const Instruction* inst) { if (auto error = ValidateTensorDim(_, inst)) return error; const auto clamp_index = 2; const auto clamp_id = inst->GetOperandAs(clamp_index); const auto clamp = _.FindDef(clamp_id); if (!clamp || !_.IsIntScalarType(clamp->type_id()) || _.GetBitWidth(clamp->type_id()) != 32) { return _.diag(SPV_ERROR_INVALID_ID, inst) << spvOpcodeString(inst->opcode()) << " ClampMode " << _.getIdName(clamp_id) << " is not a 32-bit integer."; } uint64_t clamp_value; if (_.EvalConstantValUint64(clamp_id, &clamp_value)) { if (clamp_value > static_cast(spv::TensorClampMode::RepeatMirrored)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << spvOpcodeString(inst->opcode()) << " ClampMode " << _.getIdName(clamp_id) << " must be a valid TensorClampMode."; } } return SPV_SUCCESS; } spv_result_t ValidateTypeTensorViewNV(ValidationState_t& _, const Instruction* inst) { if (auto error = ValidateTensorDim(_, inst)) return error; const auto has_dim_index = 2; const auto has_dim_id = inst->GetOperandAs(has_dim_index); const auto has_dim = _.FindDef(has_dim_id); if (!has_dim || !_.IsBoolScalarType(has_dim->type_id())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << spvOpcodeString(inst->opcode()) << " HasDimensions " << _.getIdName(has_dim_id) << " is not a boolean value."; } uint32_t permutation_mask = 0; bool all_constant = true; const auto num_dim = inst->operands().size() - 3; for (size_t p_index = 3; p_index < inst->operands().size(); ++p_index) { auto p_id = inst->GetOperandAs(p_index); const auto p = _.FindDef(p_id); if (!p || !_.IsIntScalarType(p->type_id()) || _.GetBitWidth(p->type_id()) != 32) { return _.diag(SPV_ERROR_INVALID_ID, inst) << spvOpcodeString(inst->opcode()) << " Permutation " << _.getIdName(p_id) << " is not a 32-bit integer."; } uint64_t p_value; if (_.EvalConstantValUint64(p_id, &p_value)) { if (p_value >= num_dim) { return _.diag(SPV_ERROR_INVALID_ID, inst) << spvOpcodeString(inst->opcode()) << " Permutation " << _.getIdName(p_id) << " must be a valid dimension."; } permutation_mask |= 1 << p_value; } else { all_constant = false; } } if (all_constant && permutation_mask != (1U << num_dim) - 1U) { return _.diag(SPV_ERROR_INVALID_ID, inst) << spvOpcodeString(inst->opcode()) << " Permutation values don't form a valid permutation."; } uint64_t dim_value; if (_.EvalConstantValUint64(inst->GetOperandAs(1), &dim_value)) { if (dim_value != num_dim) { return _.diag(SPV_ERROR_INVALID_ID, inst) << spvOpcodeString(inst->opcode()) << " Incorrect number of permutation values."; } } return SPV_SUCCESS; } } // namespace spv_result_t TypePass(ValidationState_t& _, const Instruction* inst) { if (!spvOpcodeGeneratesType(inst->opcode()) && inst->opcode() != spv::Op::OpTypeForwardPointer) { return SPV_SUCCESS; } if (auto error = ValidateUniqueness(_, inst)) return error; switch (inst->opcode()) { case spv::Op::OpTypeInt: if (auto error = ValidateTypeInt(_, inst)) return error; break; case spv::Op::OpTypeFloat: if (auto error = ValidateTypeFloat(_, inst)) return error; break; case spv::Op::OpTypeVector: if (auto error = ValidateTypeVector(_, inst)) return error; break; case spv::Op::OpTypeMatrix: if (auto error = ValidateTypeMatrix(_, inst)) return error; break; case spv::Op::OpTypeArray: if (auto error = ValidateTypeArray(_, inst)) return error; break; case spv::Op::OpTypeRuntimeArray: if (auto error = ValidateTypeRuntimeArray(_, inst)) return error; break; case spv::Op::OpTypeStruct: if (auto error = ValidateTypeStruct(_, inst)) return error; break; case spv::Op::OpTypePointer: if (auto error = ValidateTypePointer(_, inst)) return error; break; case spv::Op::OpTypeFunction: if (auto error = ValidateTypeFunction(_, inst)) return error; break; case spv::Op::OpTypeForwardPointer: if (auto error = ValidateTypeForwardPointer(_, inst)) return error; break; case spv::Op::OpTypeCooperativeMatrixNV: case spv::Op::OpTypeCooperativeMatrixKHR: if (auto error = ValidateTypeCooperativeMatrix(_, inst)) return error; break; case spv::Op::OpTypeCooperativeVectorNV: if (auto error = ValidateTypeCooperativeVectorNV(_, inst)) return error; break; case spv::Op::OpTypeUntypedPointerKHR: if (auto error = ValidateTypeUntypedPointerKHR(_, inst)) return error; break; case spv::Op::OpTypeTensorLayoutNV: if (auto error = ValidateTypeTensorLayoutNV(_, inst)) return error; break; case spv::Op::OpTypeTensorViewNV: if (auto error = ValidateTypeTensorViewNV(_, inst)) return error; break; default: break; } return SPV_SUCCESS; } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validation_state.cpp000066400000000000000000002567371475742701700246750ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // Modifications Copyright (C) 2024 Advanced Micro Devices, Inc. All rights // reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/val/validation_state.h" #include #include #include #include "source/opcode.h" #include "source/spirv_constant.h" #include "source/spirv_target_env.h" #include "source/util/make_unique.h" #include "source/val/basic_block.h" #include "source/val/construct.h" #include "source/val/function.h" #include "spirv-tools/libspirv.h" namespace spvtools { namespace val { namespace { ModuleLayoutSection InstructionLayoutSection( ModuleLayoutSection current_section, spv::Op op) { // See Section 2.4 if (spvOpcodeGeneratesType(op) || spvOpcodeIsConstant(op)) return kLayoutTypes; switch (op) { case spv::Op::OpCapability: return kLayoutCapabilities; case spv::Op::OpExtension: return kLayoutExtensions; case spv::Op::OpExtInstImport: return kLayoutExtInstImport; case spv::Op::OpMemoryModel: return kLayoutMemoryModel; case spv::Op::OpEntryPoint: return kLayoutEntryPoint; case spv::Op::OpExecutionMode: case spv::Op::OpExecutionModeId: return kLayoutExecutionMode; case spv::Op::OpSourceContinued: case spv::Op::OpSource: case spv::Op::OpSourceExtension: case spv::Op::OpString: return kLayoutDebug1; case spv::Op::OpName: case spv::Op::OpMemberName: return kLayoutDebug2; case spv::Op::OpModuleProcessed: return kLayoutDebug3; case spv::Op::OpDecorate: case spv::Op::OpMemberDecorate: case spv::Op::OpGroupDecorate: case spv::Op::OpGroupMemberDecorate: case spv::Op::OpDecorationGroup: case spv::Op::OpDecorateId: case spv::Op::OpDecorateStringGOOGLE: case spv::Op::OpMemberDecorateStringGOOGLE: return kLayoutAnnotations; case spv::Op::OpTypeForwardPointer: return kLayoutTypes; case spv::Op::OpVariable: case spv::Op::OpUntypedVariableKHR: if (current_section == kLayoutTypes) return kLayoutTypes; return kLayoutFunctionDefinitions; case spv::Op::OpExtInst: case spv::Op::OpExtInstWithForwardRefsKHR: // spv::Op::OpExtInst is only allowed in types section for certain // extended instruction sets. This will be checked separately. if (current_section == kLayoutTypes) return kLayoutTypes; return kLayoutFunctionDefinitions; case spv::Op::OpLine: case spv::Op::OpNoLine: case spv::Op::OpUndef: if (current_section == kLayoutTypes) return kLayoutTypes; return kLayoutFunctionDefinitions; case spv::Op::OpFunction: case spv::Op::OpFunctionParameter: case spv::Op::OpFunctionEnd: if (current_section == kLayoutFunctionDeclarations) return kLayoutFunctionDeclarations; return kLayoutFunctionDefinitions; case spv::Op::OpSamplerImageAddressingModeNV: return kLayoutSamplerImageAddressMode; default: break; } return kLayoutFunctionDefinitions; } bool IsInstructionInLayoutSection(ModuleLayoutSection layout, spv::Op op) { return layout == InstructionLayoutSection(layout, op); } // Counts the number of instructions and functions in the file. spv_result_t CountInstructions(void* user_data, const spv_parsed_instruction_t* inst) { ValidationState_t& _ = *(reinterpret_cast(user_data)); if (spv::Op(inst->opcode) == spv::Op::OpFunction) { _.increment_total_functions(); } _.increment_total_instructions(); return SPV_SUCCESS; } spv_result_t setHeader(void* user_data, spv_endianness_t, uint32_t, uint32_t version, uint32_t generator, uint32_t id_bound, uint32_t) { ValidationState_t& vstate = *(reinterpret_cast(user_data)); vstate.setIdBound(id_bound); vstate.setGenerator(generator); vstate.setVersion(version); return SPV_SUCCESS; } // Add features based on SPIR-V core version number. void UpdateFeaturesBasedOnSpirvVersion(ValidationState_t::Feature* features, uint32_t version) { assert(features); if (version >= SPV_SPIRV_VERSION_WORD(1, 4)) { features->select_between_composites = true; features->copy_memory_permits_two_memory_accesses = true; features->uconvert_spec_constant_op = true; features->nonwritable_var_in_function_or_private = true; } } } // namespace ValidationState_t::ValidationState_t(const spv_const_context ctx, const spv_const_validator_options opt, const uint32_t* words, const size_t num_words, const uint32_t max_warnings) : context_(ctx), options_(opt), words_(words), num_words_(num_words), unresolved_forward_ids_{}, operand_names_{}, current_layout_section_(kLayoutCapabilities), module_functions_(), module_capabilities_(), module_extensions_(), ordered_instructions_(), all_definitions_(), global_vars_(), local_vars_(), struct_nesting_depth_(), struct_has_nested_blockorbufferblock_struct_(), grammar_(ctx), addressing_model_(spv::AddressingModel::Max), memory_model_(spv::MemoryModel::Max), pointer_size_and_alignment_(0), sampler_image_addressing_mode_(0), in_function_(false), num_of_warnings_(0), max_num_of_warnings_(max_warnings) { assert(opt && "Validator options may not be Null."); const auto env = context_->target_env; if (spvIsVulkanEnv(env)) { // Vulkan 1.1 includes VK_KHR_relaxed_block_layout in core. if (env != SPV_ENV_VULKAN_1_0) { features_.env_relaxed_block_layout = true; } } // LocalSizeId is only disallowed prior to Vulkan 1.3 without maintenance4. switch (env) { case SPV_ENV_VULKAN_1_0: case SPV_ENV_VULKAN_1_1: case SPV_ENV_VULKAN_1_1_SPIRV_1_4: case SPV_ENV_VULKAN_1_2: features_.env_allow_localsizeid = false; break; default: features_.env_allow_localsizeid = true; break; } // Only attempt to count if we have words, otherwise let the other validation // fail and generate an error. if (num_words > 0) { // Count the number of instructions in the binary. // This parse should not produce any error messages. Hijack the context and // replace the message consumer so that we do not pollute any state in input // consumer. spv_context_t hijacked_context = *ctx; hijacked_context.consumer = [](spv_message_level_t, const char*, const spv_position_t&, const char*) {}; spvBinaryParse(&hijacked_context, this, words, num_words, setHeader, CountInstructions, /* diagnostic = */ nullptr); preallocateStorage(); } UpdateFeaturesBasedOnSpirvVersion(&features_, version_); name_mapper_ = spvtools::GetTrivialNameMapper(); if (options_->use_friendly_names) { friendly_mapper_ = spvtools::MakeUnique( context_, words_, num_words_); name_mapper_ = friendly_mapper_->GetNameMapper(); } } void ValidationState_t::preallocateStorage() { ordered_instructions_.reserve(total_instructions_); module_functions_.reserve(total_functions_); } spv_result_t ValidationState_t::ForwardDeclareId(uint32_t id) { unresolved_forward_ids_.insert(id); return SPV_SUCCESS; } spv_result_t ValidationState_t::RemoveIfForwardDeclared(uint32_t id) { unresolved_forward_ids_.erase(id); return SPV_SUCCESS; } spv_result_t ValidationState_t::RegisterForwardPointer(uint32_t id) { forward_pointer_ids_.insert(id); return SPV_SUCCESS; } bool ValidationState_t::IsForwardPointer(uint32_t id) const { return (forward_pointer_ids_.find(id) != forward_pointer_ids_.end()); } void ValidationState_t::AssignNameToId(uint32_t id, std::string name) { operand_names_[id] = name; } std::string ValidationState_t::getIdName(uint32_t id) const { const std::string id_name = name_mapper_(id); std::stringstream out; out << "'" << id << "[%" << id_name << "]'"; return out.str(); } size_t ValidationState_t::unresolved_forward_id_count() const { return unresolved_forward_ids_.size(); } std::vector ValidationState_t::UnresolvedForwardIds() const { std::vector out(std::begin(unresolved_forward_ids_), std::end(unresolved_forward_ids_)); return out; } bool ValidationState_t::IsDefinedId(uint32_t id) const { return all_definitions_.find(id) != std::end(all_definitions_); } const Instruction* ValidationState_t::FindDef(uint32_t id) const { auto it = all_definitions_.find(id); if (it == all_definitions_.end()) return nullptr; return it->second; } Instruction* ValidationState_t::FindDef(uint32_t id) { auto it = all_definitions_.find(id); if (it == all_definitions_.end()) return nullptr; return it->second; } ModuleLayoutSection ValidationState_t::current_layout_section() const { return current_layout_section_; } void ValidationState_t::ProgressToNextLayoutSectionOrder() { // Guard against going past the last element(kLayoutFunctionDefinitions) if (current_layout_section_ <= kLayoutFunctionDefinitions) { current_layout_section_ = static_cast(current_layout_section_ + 1); } } bool ValidationState_t::IsOpcodeInPreviousLayoutSection(spv::Op op) { ModuleLayoutSection section = InstructionLayoutSection(current_layout_section_, op); return section < current_layout_section_; } bool ValidationState_t::IsOpcodeInCurrentLayoutSection(spv::Op op) { return IsInstructionInLayoutSection(current_layout_section_, op); } DiagnosticStream ValidationState_t::diag(spv_result_t error_code, const Instruction* inst) { if (error_code == SPV_WARNING) { if (num_of_warnings_ == max_num_of_warnings_) { DiagnosticStream({0, 0, 0}, context_->consumer, "", error_code) << "Other warnings have been suppressed.\n"; } if (num_of_warnings_ >= max_num_of_warnings_) { return DiagnosticStream({0, 0, 0}, nullptr, "", error_code); } ++num_of_warnings_; } std::string disassembly; if (inst) disassembly = Disassemble(*inst); return DiagnosticStream({0, 0, inst ? inst->LineNum() : 0}, context_->consumer, disassembly, error_code); } std::vector& ValidationState_t::functions() { return module_functions_; } Function& ValidationState_t::current_function() { assert(in_function_body()); return module_functions_.back(); } const Function& ValidationState_t::current_function() const { assert(in_function_body()); return module_functions_.back(); } const Function* ValidationState_t::function(uint32_t id) const { const auto it = id_to_function_.find(id); if (it == id_to_function_.end()) return nullptr; return it->second; } Function* ValidationState_t::function(uint32_t id) { auto it = id_to_function_.find(id); if (it == id_to_function_.end()) return nullptr; return it->second; } bool ValidationState_t::in_function_body() const { return in_function_; } bool ValidationState_t::in_block() const { return module_functions_.empty() == false && module_functions_.back().current_block() != nullptr; } void ValidationState_t::RegisterCapability(spv::Capability cap) { // Avoid redundant work. Otherwise the recursion could induce work // quadrdatic in the capability dependency depth. (Ok, not much, but // it's something.) if (module_capabilities_.contains(cap)) return; module_capabilities_.insert(cap); spv_operand_desc desc; if (SPV_SUCCESS == grammar_.lookupOperand(SPV_OPERAND_TYPE_CAPABILITY, uint32_t(cap), &desc)) { for (auto capability : CapabilitySet(desc->numCapabilities, desc->capabilities)) { RegisterCapability(capability); } } switch (cap) { case spv::Capability::Kernel: features_.group_ops_reduce_and_scans = true; break; case spv::Capability::Int8: features_.use_int8_type = true; features_.declare_int8_type = true; break; case spv::Capability::StorageBuffer8BitAccess: case spv::Capability::UniformAndStorageBuffer8BitAccess: case spv::Capability::StoragePushConstant8: case spv::Capability::WorkgroupMemoryExplicitLayout8BitAccessKHR: features_.declare_int8_type = true; break; case spv::Capability::Int16: features_.declare_int16_type = true; break; case spv::Capability::Float16: case spv::Capability::Float16Buffer: features_.declare_float16_type = true; break; case spv::Capability::StorageUniformBufferBlock16: case spv::Capability::StorageUniform16: case spv::Capability::StoragePushConstant16: case spv::Capability::StorageInputOutput16: case spv::Capability::WorkgroupMemoryExplicitLayout16BitAccessKHR: features_.declare_int16_type = true; features_.declare_float16_type = true; features_.free_fp_rounding_mode = true; break; case spv::Capability::VariablePointers: case spv::Capability::VariablePointersStorageBuffer: features_.variable_pointers = true; break; default: // TODO(dneto): For now don't validate SPV_NV_ray_tracing, which uses // capability spv::Capability::RayTracingNV. // spv::Capability::RayTracingProvisionalKHR would need the same // treatment. One of the differences going from SPV_KHR_ray_tracing from // provisional to final spec was the provisional spec uses Locations // for variables in certain storage classes, just like the // SPV_NV_ray_tracing extension. So it mimics the NVIDIA extension. // The final SPV_KHR_ray_tracing uses a different capability token // number, so it doesn't fall into this case. break; } } void ValidationState_t::RegisterExtension(Extension ext) { if (module_extensions_.contains(ext)) return; module_extensions_.insert(ext); switch (ext) { case kSPV_AMD_gpu_shader_half_float: case kSPV_AMD_gpu_shader_half_float_fetch: // SPV_AMD_gpu_shader_half_float enables float16 type. // https://github.com/KhronosGroup/SPIRV-Tools/issues/1375 features_.declare_float16_type = true; break; case kSPV_AMD_gpu_shader_int16: // This is not yet in the extension, but it's recommended for it. // See https://github.com/KhronosGroup/glslang/issues/848 features_.uconvert_spec_constant_op = true; break; case kSPV_AMD_shader_ballot: // The grammar doesn't encode the fact that SPV_AMD_shader_ballot // enables the use of group operations Reduce, InclusiveScan, // and ExclusiveScan. Enable it manually. // https://github.com/KhronosGroup/SPIRV-Tools/issues/991 features_.group_ops_reduce_and_scans = true; break; default: break; } } bool ValidationState_t::HasAnyOfCapabilities( const CapabilitySet& capabilities) const { return module_capabilities_.HasAnyOf(capabilities); } bool ValidationState_t::HasAnyOfExtensions( const ExtensionSet& extensions) const { return module_extensions_.HasAnyOf(extensions); } void ValidationState_t::set_addressing_model(spv::AddressingModel am) { addressing_model_ = am; switch (am) { case spv::AddressingModel::Physical32: pointer_size_and_alignment_ = 4; break; default: // fall through case spv::AddressingModel::Physical64: case spv::AddressingModel::PhysicalStorageBuffer64: pointer_size_and_alignment_ = 8; break; } } spv::AddressingModel ValidationState_t::addressing_model() const { return addressing_model_; } void ValidationState_t::set_memory_model(spv::MemoryModel mm) { memory_model_ = mm; } spv::MemoryModel ValidationState_t::memory_model() const { return memory_model_; } void ValidationState_t::set_samplerimage_variable_address_mode( uint32_t bit_width) { sampler_image_addressing_mode_ = bit_width; } uint32_t ValidationState_t::samplerimage_variable_address_mode() const { return sampler_image_addressing_mode_; } spv_result_t ValidationState_t::RegisterFunction( uint32_t id, uint32_t ret_type_id, spv::FunctionControlMask function_control, uint32_t function_type_id) { assert(in_function_body() == false && "RegisterFunction can only be called when parsing the binary outside " "of another function"); in_function_ = true; module_functions_.emplace_back(id, ret_type_id, function_control, function_type_id); id_to_function_.emplace(id, ¤t_function()); // TODO(umar): validate function type and type_id return SPV_SUCCESS; } spv_result_t ValidationState_t::RegisterFunctionEnd() { assert(in_function_body() == true && "RegisterFunctionEnd can only be called when parsing the binary " "inside of another function"); assert(in_block() == false && "RegisterFunctionParameter can only be called when parsing the binary " "outside of a block"); current_function().RegisterFunctionEnd(); in_function_ = false; return SPV_SUCCESS; } Instruction* ValidationState_t::AddOrderedInstruction( const spv_parsed_instruction_t* inst) { ordered_instructions_.emplace_back(inst); ordered_instructions_.back().SetLineNum(ordered_instructions_.size()); return &ordered_instructions_.back(); } // Improves diagnostic messages by collecting names of IDs void ValidationState_t::RegisterDebugInstruction(const Instruction* inst) { switch (inst->opcode()) { case spv::Op::OpName: { const auto target = inst->GetOperandAs(0); const std::string str = inst->GetOperandAs(1); AssignNameToId(target, str); break; } case spv::Op::OpMemberName: { const auto target = inst->GetOperandAs(0); const std::string str = inst->GetOperandAs(2); AssignNameToId(target, str); break; } case spv::Op::OpSourceContinued: case spv::Op::OpSource: case spv::Op::OpSourceExtension: case spv::Op::OpString: case spv::Op::OpLine: case spv::Op::OpNoLine: default: break; } } void ValidationState_t::RegisterInstruction(Instruction* inst) { if (inst->id()) all_definitions_.insert(std::make_pair(inst->id(), inst)); // Some validation checks are easier by getting all the consumers for (size_t i = 0; i < inst->operands().size(); ++i) { const spv_parsed_operand_t& operand = inst->operand(i); if ((SPV_OPERAND_TYPE_ID == operand.type) || (SPV_OPERAND_TYPE_TYPE_ID == operand.type)) { const uint32_t operand_word = inst->word(operand.offset); Instruction* operand_inst = FindDef(operand_word); if (!operand_inst) { continue; } // If the instruction is using an OpTypeSampledImage as an operand, it // should be recorded. The validator will ensure that all usages of an // OpTypeSampledImage and its definition are in the same basic block. if ((SPV_OPERAND_TYPE_ID == operand.type) && (spv::Op::OpSampledImage == operand_inst->opcode())) { RegisterSampledImageConsumer(operand_word, inst); } // In order to track storage classes (not Function) used per execution // model we can't use RegisterExecutionModelLimitation on instructions // like OpTypePointer which are going to be in the pre-function section. // Instead just need to register storage class usage for consumers in a // function block. if (inst->function()) { if (operand_inst->opcode() == spv::Op::OpTypePointer) { RegisterStorageClassConsumer( operand_inst->GetOperandAs(1), inst); } else if (operand_inst->opcode() == spv::Op::OpVariable) { RegisterStorageClassConsumer( operand_inst->GetOperandAs(2), inst); } } } } } std::vector ValidationState_t::getSampledImageConsumers( uint32_t sampled_image_id) const { std::vector result; auto iter = sampled_image_consumers_.find(sampled_image_id); if (iter != sampled_image_consumers_.end()) { result = iter->second; } return result; } void ValidationState_t::RegisterSampledImageConsumer(uint32_t sampled_image_id, Instruction* consumer) { sampled_image_consumers_[sampled_image_id].push_back(consumer); } void ValidationState_t::RegisterQCOMImageProcessingTextureConsumer( uint32_t texture_id, const Instruction* consumer0, const Instruction* consumer1) { if (HasDecoration(texture_id, spv::Decoration::WeightTextureQCOM) || HasDecoration(texture_id, spv::Decoration::BlockMatchTextureQCOM) || HasDecoration(texture_id, spv::Decoration::BlockMatchSamplerQCOM)) { qcom_image_processing_consumers_.insert(consumer0->id()); if (consumer1) { qcom_image_processing_consumers_.insert(consumer1->id()); } } } void ValidationState_t::RegisterStorageClassConsumer( spv::StorageClass storage_class, Instruction* consumer) { if (spvIsVulkanEnv(context()->target_env)) { if (storage_class == spv::StorageClass::Output) { std::string errorVUID = VkErrorID(4644); function(consumer->function()->id()) ->RegisterExecutionModelLimitation([errorVUID]( spv::ExecutionModel model, std::string* message) { if (model == spv::ExecutionModel::GLCompute || model == spv::ExecutionModel::RayGenerationKHR || model == spv::ExecutionModel::IntersectionKHR || model == spv::ExecutionModel::AnyHitKHR || model == spv::ExecutionModel::ClosestHitKHR || model == spv::ExecutionModel::MissKHR || model == spv::ExecutionModel::CallableKHR) { if (message) { *message = errorVUID + "in Vulkan environment, Output Storage Class must not be " "used in GLCompute, RayGenerationKHR, IntersectionKHR, " "AnyHitKHR, ClosestHitKHR, MissKHR, or CallableKHR " "execution models"; } return false; } return true; }); } if (storage_class == spv::StorageClass::Workgroup) { std::string errorVUID = VkErrorID(4645); function(consumer->function()->id()) ->RegisterExecutionModelLimitation([errorVUID]( spv::ExecutionModel model, std::string* message) { if (model != spv::ExecutionModel::GLCompute && model != spv::ExecutionModel::TaskNV && model != spv::ExecutionModel::MeshNV && model != spv::ExecutionModel::TaskEXT && model != spv::ExecutionModel::MeshEXT) { if (message) { *message = errorVUID + "in Vulkan environment, Workgroup Storage Class is limited " "to MeshNV, TaskNV, and GLCompute execution model"; } return false; } return true; }); } } if (storage_class == spv::StorageClass::CallableDataKHR) { std::string errorVUID = VkErrorID(4704); function(consumer->function()->id()) ->RegisterExecutionModelLimitation( [errorVUID](spv::ExecutionModel model, std::string* message) { if (model != spv::ExecutionModel::RayGenerationKHR && model != spv::ExecutionModel::ClosestHitKHR && model != spv::ExecutionModel::CallableKHR && model != spv::ExecutionModel::MissKHR) { if (message) { *message = errorVUID + "CallableDataKHR Storage Class is limited to " "RayGenerationKHR, ClosestHitKHR, CallableKHR, and " "MissKHR execution model"; } return false; } return true; }); } else if (storage_class == spv::StorageClass::IncomingCallableDataKHR) { std::string errorVUID = VkErrorID(4705); function(consumer->function()->id()) ->RegisterExecutionModelLimitation( [errorVUID](spv::ExecutionModel model, std::string* message) { if (model != spv::ExecutionModel::CallableKHR) { if (message) { *message = errorVUID + "IncomingCallableDataKHR Storage Class is limited to " "CallableKHR execution model"; } return false; } return true; }); } else if (storage_class == spv::StorageClass::RayPayloadKHR) { std::string errorVUID = VkErrorID(4698); function(consumer->function()->id()) ->RegisterExecutionModelLimitation([errorVUID]( spv::ExecutionModel model, std::string* message) { if (model != spv::ExecutionModel::RayGenerationKHR && model != spv::ExecutionModel::ClosestHitKHR && model != spv::ExecutionModel::MissKHR) { if (message) { *message = errorVUID + "RayPayloadKHR Storage Class is limited to RayGenerationKHR, " "ClosestHitKHR, and MissKHR execution model"; } return false; } return true; }); } else if (storage_class == spv::StorageClass::HitAttributeKHR) { std::string errorVUID = VkErrorID(4701); function(consumer->function()->id()) ->RegisterExecutionModelLimitation( [errorVUID](spv::ExecutionModel model, std::string* message) { if (model != spv::ExecutionModel::IntersectionKHR && model != spv::ExecutionModel::AnyHitKHR && model != spv::ExecutionModel::ClosestHitKHR) { if (message) { *message = errorVUID + "HitAttributeKHR Storage Class is limited to " "IntersectionKHR, AnyHitKHR, sand ClosestHitKHR " "execution model"; } return false; } return true; }); } else if (storage_class == spv::StorageClass::IncomingRayPayloadKHR) { std::string errorVUID = VkErrorID(4699); function(consumer->function()->id()) ->RegisterExecutionModelLimitation( [errorVUID](spv::ExecutionModel model, std::string* message) { if (model != spv::ExecutionModel::AnyHitKHR && model != spv::ExecutionModel::ClosestHitKHR && model != spv::ExecutionModel::MissKHR) { if (message) { *message = errorVUID + "IncomingRayPayloadKHR Storage Class is limited to " "AnyHitKHR, ClosestHitKHR, and MissKHR execution model"; } return false; } return true; }); } else if (storage_class == spv::StorageClass::ShaderRecordBufferKHR) { std::string errorVUID = VkErrorID(7119); function(consumer->function()->id()) ->RegisterExecutionModelLimitation( [errorVUID](spv::ExecutionModel model, std::string* message) { if (model != spv::ExecutionModel::RayGenerationKHR && model != spv::ExecutionModel::IntersectionKHR && model != spv::ExecutionModel::AnyHitKHR && model != spv::ExecutionModel::ClosestHitKHR && model != spv::ExecutionModel::CallableKHR && model != spv::ExecutionModel::MissKHR) { if (message) { *message = errorVUID + "ShaderRecordBufferKHR Storage Class is limited to " "RayGenerationKHR, IntersectionKHR, AnyHitKHR, " "ClosestHitKHR, CallableKHR, and MissKHR execution model"; } return false; } return true; }); } else if (storage_class == spv::StorageClass::TaskPayloadWorkgroupEXT) { function(consumer->function()->id()) ->RegisterExecutionModelLimitation( [](spv::ExecutionModel model, std::string* message) { if (model != spv::ExecutionModel::TaskEXT && model != spv::ExecutionModel::MeshEXT) { if (message) { *message = "TaskPayloadWorkgroupEXT Storage Class is limited to " "TaskEXT and MeshKHR execution model"; } return false; } return true; }); } else if (storage_class == spv::StorageClass::HitObjectAttributeNV) { function(consumer->function()->id()) ->RegisterExecutionModelLimitation([](spv::ExecutionModel model, std::string* message) { if (model != spv::ExecutionModel::RayGenerationKHR && model != spv::ExecutionModel::ClosestHitKHR && model != spv::ExecutionModel::MissKHR) { if (message) { *message = "HitObjectAttributeNV Storage Class is limited to " "RayGenerationKHR, ClosestHitKHR or MissKHR execution model"; } return false; } return true; }); } } uint32_t ValidationState_t::getIdBound() const { return id_bound_; } void ValidationState_t::setIdBound(const uint32_t bound) { id_bound_ = bound; } bool ValidationState_t::RegisterUniqueTypeDeclaration(const Instruction* inst) { std::vector key; key.push_back(static_cast(inst->opcode())); for (size_t index = 0; index < inst->operands().size(); ++index) { const spv_parsed_operand_t& operand = inst->operand(index); if (operand.type == SPV_OPERAND_TYPE_RESULT_ID) continue; const int words_begin = operand.offset; const int words_end = words_begin + operand.num_words; assert(words_end <= static_cast(inst->words().size())); key.insert(key.end(), inst->words().begin() + words_begin, inst->words().begin() + words_end); } return unique_type_declarations_.insert(std::move(key)).second; } uint32_t ValidationState_t::GetTypeId(uint32_t id) const { const Instruction* inst = FindDef(id); return inst ? inst->type_id() : 0; } spv::Op ValidationState_t::GetIdOpcode(uint32_t id) const { const Instruction* inst = FindDef(id); return inst ? inst->opcode() : spv::Op::OpNop; } uint32_t ValidationState_t::GetComponentType(uint32_t id) const { const Instruction* inst = FindDef(id); assert(inst); switch (inst->opcode()) { case spv::Op::OpTypeFloat: case spv::Op::OpTypeInt: case spv::Op::OpTypeBool: return id; case spv::Op::OpTypeArray: return inst->word(2); case spv::Op::OpTypeVector: return inst->word(2); case spv::Op::OpTypeMatrix: return GetComponentType(inst->word(2)); case spv::Op::OpTypeCooperativeMatrixNV: case spv::Op::OpTypeCooperativeMatrixKHR: case spv::Op::OpTypeCooperativeVectorNV: return inst->word(2); default: break; } if (inst->type_id()) return GetComponentType(inst->type_id()); assert(0); return 0; } uint32_t ValidationState_t::GetDimension(uint32_t id) const { const Instruction* inst = FindDef(id); assert(inst); switch (inst->opcode()) { case spv::Op::OpTypeFloat: case spv::Op::OpTypeInt: case spv::Op::OpTypeBool: return 1; case spv::Op::OpTypeVector: case spv::Op::OpTypeMatrix: return inst->word(3); case spv::Op::OpTypeCooperativeMatrixNV: case spv::Op::OpTypeCooperativeMatrixKHR: case spv::Op::OpTypeCooperativeVectorNV: // Actual dimension isn't known, return 0 return 0; default: break; } if (inst->type_id()) return GetDimension(inst->type_id()); assert(0); return 0; } uint32_t ValidationState_t::GetBitWidth(uint32_t id) const { const uint32_t component_type_id = GetComponentType(id); const Instruction* inst = FindDef(component_type_id); assert(inst); if (inst->opcode() == spv::Op::OpTypeFloat || inst->opcode() == spv::Op::OpTypeInt) return inst->word(2); if (inst->opcode() == spv::Op::OpTypeBool) return 1; assert(0); return 0; } bool ValidationState_t::IsVoidType(uint32_t id) const { const Instruction* inst = FindDef(id); return inst && inst->opcode() == spv::Op::OpTypeVoid; } bool ValidationState_t::IsFloatScalarType(uint32_t id) const { const Instruction* inst = FindDef(id); return inst && inst->opcode() == spv::Op::OpTypeFloat; } bool ValidationState_t::IsFloatArrayType(uint32_t id) const { const Instruction* inst = FindDef(id); if (!inst) { return false; } if (inst->opcode() == spv::Op::OpTypeArray) { return IsFloatScalarType(GetComponentType(id)); } return false; } bool ValidationState_t::IsFloatVectorType(uint32_t id) const { const Instruction* inst = FindDef(id); if (!inst) { return false; } if (inst->opcode() == spv::Op::OpTypeVector) { return IsFloatScalarType(GetComponentType(id)); } return false; } bool ValidationState_t::IsFloat16Vector2Or4Type(uint32_t id) const { const Instruction* inst = FindDef(id); assert(inst); if (inst->opcode() == spv::Op::OpTypeVector) { uint32_t vectorDim = GetDimension(id); return IsFloatScalarType(GetComponentType(id)) && (vectorDim == 2 || vectorDim == 4) && (GetBitWidth(GetComponentType(id)) == 16); } return false; } bool ValidationState_t::IsFloatScalarOrVectorType(uint32_t id) const { const Instruction* inst = FindDef(id); if (!inst) { return false; } if (inst->opcode() == spv::Op::OpTypeFloat) { return true; } if (inst->opcode() == spv::Op::OpTypeVector) { return IsFloatScalarType(GetComponentType(id)); } return false; } bool ValidationState_t::IsIntScalarType(uint32_t id) const { const Instruction* inst = FindDef(id); return inst && inst->opcode() == spv::Op::OpTypeInt; } bool ValidationState_t::IsIntArrayType(uint32_t id) const { const Instruction* inst = FindDef(id); if (!inst) { return false; } if (inst->opcode() == spv::Op::OpTypeArray) { return IsIntScalarType(GetComponentType(id)); } return false; } bool ValidationState_t::IsIntVectorType(uint32_t id) const { const Instruction* inst = FindDef(id); if (!inst) { return false; } if (inst->opcode() == spv::Op::OpTypeVector) { return IsIntScalarType(GetComponentType(id)); } return false; } bool ValidationState_t::IsIntScalarOrVectorType(uint32_t id) const { const Instruction* inst = FindDef(id); if (!inst) { return false; } if (inst->opcode() == spv::Op::OpTypeInt) { return true; } if (inst->opcode() == spv::Op::OpTypeVector) { return IsIntScalarType(GetComponentType(id)); } return false; } bool ValidationState_t::IsUnsignedIntScalarType(uint32_t id) const { const Instruction* inst = FindDef(id); return inst && inst->opcode() == spv::Op::OpTypeInt && inst->word(3) == 0; } bool ValidationState_t::IsUnsignedIntVectorType(uint32_t id) const { const Instruction* inst = FindDef(id); if (!inst) { return false; } if (inst->opcode() == spv::Op::OpTypeVector) { return IsUnsignedIntScalarType(GetComponentType(id)); } return false; } bool ValidationState_t::IsUnsignedIntScalarOrVectorType(uint32_t id) const { const Instruction* inst = FindDef(id); if (!inst) { return false; } if (inst->opcode() == spv::Op::OpTypeInt) { return inst->GetOperandAs(2) == 0; } if (inst->opcode() == spv::Op::OpTypeVector) { return IsUnsignedIntScalarType(GetComponentType(id)); } return false; } bool ValidationState_t::IsSignedIntScalarType(uint32_t id) const { const Instruction* inst = FindDef(id); return inst && inst->opcode() == spv::Op::OpTypeInt && inst->word(3) == 1; } bool ValidationState_t::IsSignedIntVectorType(uint32_t id) const { const Instruction* inst = FindDef(id); if (!inst) { return false; } if (inst->opcode() == spv::Op::OpTypeVector) { return IsSignedIntScalarType(GetComponentType(id)); } return false; } bool ValidationState_t::IsBoolScalarType(uint32_t id) const { const Instruction* inst = FindDef(id); return inst && inst->opcode() == spv::Op::OpTypeBool; } bool ValidationState_t::IsBoolVectorType(uint32_t id) const { const Instruction* inst = FindDef(id); if (!inst) { return false; } if (inst->opcode() == spv::Op::OpTypeVector) { return IsBoolScalarType(GetComponentType(id)); } return false; } bool ValidationState_t::IsBoolScalarOrVectorType(uint32_t id) const { const Instruction* inst = FindDef(id); if (!inst) { return false; } if (inst->opcode() == spv::Op::OpTypeBool) { return true; } if (inst->opcode() == spv::Op::OpTypeVector) { return IsBoolScalarType(GetComponentType(id)); } return false; } bool ValidationState_t::IsFloatMatrixType(uint32_t id) const { const Instruction* inst = FindDef(id); if (!inst) { return false; } if (inst->opcode() == spv::Op::OpTypeMatrix) { return IsFloatScalarType(GetComponentType(id)); } return false; } bool ValidationState_t::GetMatrixTypeInfo(uint32_t id, uint32_t* num_rows, uint32_t* num_cols, uint32_t* column_type, uint32_t* component_type) const { if (!id) return false; const Instruction* mat_inst = FindDef(id); assert(mat_inst); if (mat_inst->opcode() != spv::Op::OpTypeMatrix) return false; const uint32_t vec_type = mat_inst->word(2); const Instruction* vec_inst = FindDef(vec_type); assert(vec_inst); if (vec_inst->opcode() != spv::Op::OpTypeVector) { assert(0); return false; } *num_cols = mat_inst->word(3); *num_rows = vec_inst->word(3); *column_type = mat_inst->word(2); *component_type = vec_inst->word(2); return true; } bool ValidationState_t::GetStructMemberTypes( uint32_t struct_type_id, std::vector* member_types) const { member_types->clear(); if (!struct_type_id) return false; const Instruction* inst = FindDef(struct_type_id); assert(inst); if (inst->opcode() != spv::Op::OpTypeStruct) return false; *member_types = std::vector(inst->words().cbegin() + 2, inst->words().cend()); if (member_types->empty()) return false; return true; } bool ValidationState_t::IsPointerType(uint32_t id) const { if (!id) return false; const Instruction* inst = FindDef(id); assert(inst); return inst->opcode() == spv::Op::OpTypePointer || inst->opcode() == spv::Op::OpTypeUntypedPointerKHR; } bool ValidationState_t::GetPointerTypeInfo( uint32_t id, uint32_t* data_type, spv::StorageClass* storage_class) const { *storage_class = spv::StorageClass::Max; if (!id) return false; const Instruction* inst = FindDef(id); assert(inst); if (inst->opcode() == spv::Op::OpTypeUntypedPointerKHR) { *storage_class = spv::StorageClass(inst->word(2)); *data_type = 0; return true; } if (inst->opcode() != spv::Op::OpTypePointer) return false; *storage_class = spv::StorageClass(inst->word(2)); *data_type = inst->word(3); return true; } bool ValidationState_t::IsAccelerationStructureType(uint32_t id) const { const Instruction* inst = FindDef(id); return inst && inst->opcode() == spv::Op::OpTypeAccelerationStructureKHR; } bool ValidationState_t::IsCooperativeMatrixType(uint32_t id) const { const Instruction* inst = FindDef(id); return inst && (inst->opcode() == spv::Op::OpTypeCooperativeMatrixNV || inst->opcode() == spv::Op::OpTypeCooperativeMatrixKHR); } bool ValidationState_t::IsCooperativeMatrixNVType(uint32_t id) const { const Instruction* inst = FindDef(id); return inst && inst->opcode() == spv::Op::OpTypeCooperativeMatrixNV; } bool ValidationState_t::IsCooperativeMatrixKHRType(uint32_t id) const { const Instruction* inst = FindDef(id); return inst && inst->opcode() == spv::Op::OpTypeCooperativeMatrixKHR; } bool ValidationState_t::IsCooperativeMatrixAType(uint32_t id) const { if (!IsCooperativeMatrixKHRType(id)) return false; const Instruction* inst = FindDef(id); uint64_t matrixUse = 0; if (EvalConstantValUint64(inst->word(6), &matrixUse)) { return matrixUse == static_cast(spv::CooperativeMatrixUse::MatrixAKHR); } return false; } bool ValidationState_t::IsCooperativeMatrixBType(uint32_t id) const { if (!IsCooperativeMatrixKHRType(id)) return false; const Instruction* inst = FindDef(id); uint64_t matrixUse = 0; if (EvalConstantValUint64(inst->word(6), &matrixUse)) { return matrixUse == static_cast(spv::CooperativeMatrixUse::MatrixBKHR); } return false; } bool ValidationState_t::IsCooperativeMatrixAccType(uint32_t id) const { if (!IsCooperativeMatrixKHRType(id)) return false; const Instruction* inst = FindDef(id); uint64_t matrixUse = 0; if (EvalConstantValUint64(inst->word(6), &matrixUse)) { return matrixUse == static_cast( spv::CooperativeMatrixUse::MatrixAccumulatorKHR); } return false; } bool ValidationState_t::IsFloatCooperativeMatrixType(uint32_t id) const { if (!IsCooperativeMatrixNVType(id) && !IsCooperativeMatrixKHRType(id)) return false; return IsFloatScalarType(FindDef(id)->word(2)); } bool ValidationState_t::IsIntCooperativeMatrixType(uint32_t id) const { if (!IsCooperativeMatrixNVType(id) && !IsCooperativeMatrixKHRType(id)) return false; return IsIntScalarType(FindDef(id)->word(2)); } bool ValidationState_t::IsUnsignedIntCooperativeMatrixType(uint32_t id) const { if (!IsCooperativeMatrixNVType(id) && !IsCooperativeMatrixKHRType(id)) return false; return IsUnsignedIntScalarType(FindDef(id)->word(2)); } // Either a 32 bit 2-component uint vector or a 64 bit uint scalar bool ValidationState_t::IsUnsigned64BitHandle(uint32_t id) const { return ((IsUnsignedIntScalarType(id) && GetBitWidth(id) == 64) || (IsUnsignedIntVectorType(id) && GetDimension(id) == 2 && GetBitWidth(id) == 32)); } bool ValidationState_t::IsCooperativeVectorNVType(uint32_t id) const { const Instruction* inst = FindDef(id); return inst && inst->opcode() == spv::Op::OpTypeCooperativeVectorNV; } bool ValidationState_t::IsFloatCooperativeVectorNVType(uint32_t id) const { if (!IsCooperativeVectorNVType(id)) return false; return IsFloatScalarType(FindDef(id)->word(2)); } bool ValidationState_t::IsIntCooperativeVectorNVType(uint32_t id) const { if (!IsCooperativeVectorNVType(id)) return false; return IsIntScalarType(FindDef(id)->word(2)); } bool ValidationState_t::IsUnsignedIntCooperativeVectorNVType( uint32_t id) const { if (!IsCooperativeVectorNVType(id)) return false; return IsUnsignedIntScalarType(FindDef(id)->word(2)); } spv_result_t ValidationState_t::CooperativeMatrixShapesMatch( const Instruction* inst, uint32_t result_type_id, uint32_t m2, bool is_conversion, bool swap_row_col) { const auto m1_type = FindDef(result_type_id); const auto m2_type = FindDef(m2); if (m1_type->opcode() != m2_type->opcode()) { return diag(SPV_ERROR_INVALID_DATA, inst) << "Expected cooperative matrix types"; } uint32_t m1_scope_id = m1_type->GetOperandAs(2); uint32_t m1_rows_id = m1_type->GetOperandAs(3); uint32_t m1_cols_id = m1_type->GetOperandAs(4); uint32_t m2_scope_id = m2_type->GetOperandAs(2); uint32_t m2_rows_id = m2_type->GetOperandAs(3); uint32_t m2_cols_id = m2_type->GetOperandAs(4); if (swap_row_col) { std::swap(m1_rows_id, m1_cols_id); } bool m1_is_int32 = false, m1_is_const_int32 = false, m2_is_int32 = false, m2_is_const_int32 = false; uint32_t m1_value = 0, m2_value = 0; std::tie(m1_is_int32, m1_is_const_int32, m1_value) = EvalInt32IfConst(m1_scope_id); std::tie(m2_is_int32, m2_is_const_int32, m2_value) = EvalInt32IfConst(m2_scope_id); if (m1_is_const_int32 && m2_is_const_int32 && m1_value != m2_value) { return diag(SPV_ERROR_INVALID_DATA, inst) << "Expected scopes of Matrix and Result Type to be " << "identical"; } std::tie(m1_is_int32, m1_is_const_int32, m1_value) = EvalInt32IfConst(m1_rows_id); std::tie(m2_is_int32, m2_is_const_int32, m2_value) = EvalInt32IfConst(m2_rows_id); if (m1_is_const_int32 && m2_is_const_int32 && m1_value != m2_value) { return diag(SPV_ERROR_INVALID_DATA, inst) << "Expected rows of Matrix type and Result Type to be " << (swap_row_col ? "swapped with columns" : "identical"); } std::tie(m1_is_int32, m1_is_const_int32, m1_value) = EvalInt32IfConst(m1_cols_id); std::tie(m2_is_int32, m2_is_const_int32, m2_value) = EvalInt32IfConst(m2_cols_id); if (m1_is_const_int32 && m2_is_const_int32 && m1_value != m2_value) { return diag(SPV_ERROR_INVALID_DATA, inst) << "Expected columns of Matrix type and Result Type to be " << (swap_row_col ? "swapped with rows" : "identical"); } if (m1_type->opcode() == spv::Op::OpTypeCooperativeMatrixKHR) { uint32_t m1_use_id = m1_type->GetOperandAs(5); uint32_t m2_use_id = m2_type->GetOperandAs(5); std::tie(m1_is_int32, m1_is_const_int32, m1_value) = EvalInt32IfConst(m1_use_id); std::tie(m2_is_int32, m2_is_const_int32, m2_value) = EvalInt32IfConst(m2_use_id); if (m1_is_const_int32 && m2_is_const_int32 && m1_value != m2_value && // CooperativeMatrixConversionsNV allows conversions from Acc->A/B !(is_conversion && HasCapability(spv::Capability::CooperativeMatrixConversionsNV) && m2_value == (uint32_t)spv::CooperativeMatrixUse::MatrixAccumulatorKHR)) { return diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Use of Matrix type and Result Type to be " << "identical"; } } return SPV_SUCCESS; } spv_result_t ValidationState_t::CooperativeVectorDimensionsMatch( const Instruction* inst, uint32_t v1, uint32_t v2) { const auto v1_type = FindDef(v1); const auto v2_type = FindDef(v2); if (v1_type->opcode() != v2_type->opcode()) { return diag(SPV_ERROR_INVALID_DATA, inst) << "Expected cooperative vector types"; } uint32_t v1_components_id = v1_type->GetOperandAs(2); uint32_t v2_components_id = v2_type->GetOperandAs(2); bool v1_is_int32 = false, v1_is_const_int32 = false, v2_is_int32 = false, v2_is_const_int32 = false; uint32_t v1_value = 0, v2_value = 0; std::tie(v1_is_int32, v1_is_const_int32, v1_value) = EvalInt32IfConst(v1_components_id); std::tie(v2_is_int32, v2_is_const_int32, v2_value) = EvalInt32IfConst(v2_components_id); if (v1_is_const_int32 && v2_is_const_int32 && v1_value != v2_value) { return diag(SPV_ERROR_INVALID_DATA, inst) << "Expected number of components to be identical"; } return SPV_SUCCESS; } uint32_t ValidationState_t::GetOperandTypeId(const Instruction* inst, size_t operand_index) const { return GetTypeId(inst->GetOperandAs(operand_index)); } bool ValidationState_t::EvalConstantValUint64(uint32_t id, uint64_t* val) const { const Instruction* inst = FindDef(id); if (!inst) { assert(0 && "Instruction not found"); return false; } if (!IsIntScalarType(inst->type_id())) return false; if (inst->opcode() == spv::Op::OpConstantNull) { *val = 0; } else if (inst->opcode() != spv::Op::OpConstant) { // Spec constant values cannot be evaluated so don't consider constant for // static validation return false; } else if (inst->words().size() == 4) { *val = inst->word(3); } else { assert(inst->words().size() == 5); *val = inst->word(3); *val |= uint64_t(inst->word(4)) << 32; } return true; } bool ValidationState_t::EvalConstantValInt64(uint32_t id, int64_t* val) const { const Instruction* inst = FindDef(id); if (!inst) { assert(0 && "Instruction not found"); return false; } if (!IsIntScalarType(inst->type_id())) return false; if (inst->opcode() == spv::Op::OpConstantNull) { *val = 0; } else if (inst->opcode() != spv::Op::OpConstant) { // Spec constant values cannot be evaluated so don't consider constant for // static validation return false; } else if (inst->words().size() == 4) { *val = int32_t(inst->word(3)); } else { assert(inst->words().size() == 5); const uint32_t lo_word = inst->word(3); const uint32_t hi_word = inst->word(4); *val = static_cast(uint64_t(lo_word) | uint64_t(hi_word) << 32); } return true; } std::tuple ValidationState_t::EvalInt32IfConst( uint32_t id) const { const Instruction* const inst = FindDef(id); assert(inst); const uint32_t type = inst->type_id(); if (type == 0 || !IsIntScalarType(type) || GetBitWidth(type) != 32) { return std::make_tuple(false, false, 0); } // Spec constant values cannot be evaluated so don't consider constant for // the purpose of this method. if (!spvOpcodeIsConstant(inst->opcode()) || spvOpcodeIsSpecConstant(inst->opcode())) { return std::make_tuple(true, false, 0); } if (inst->opcode() == spv::Op::OpConstantNull) { return std::make_tuple(true, true, 0); } assert(inst->words().size() == 4); return std::make_tuple(true, true, inst->word(3)); } void ValidationState_t::ComputeFunctionToEntryPointMapping() { for (const uint32_t entry_point : entry_points()) { std::stack call_stack; std::set visited; call_stack.push(entry_point); while (!call_stack.empty()) { const uint32_t called_func_id = call_stack.top(); call_stack.pop(); if (!visited.insert(called_func_id).second) continue; function_to_entry_points_[called_func_id].push_back(entry_point); const Function* called_func = function(called_func_id); if (called_func) { // Other checks should error out on this invalid SPIR-V. for (const uint32_t new_call : called_func->function_call_targets()) { call_stack.push(new_call); } } } } } void ValidationState_t::ComputeRecursiveEntryPoints() { for (const Function& func : functions()) { std::stack call_stack; std::set visited; for (const uint32_t new_call : func.function_call_targets()) { call_stack.push(new_call); } while (!call_stack.empty()) { const uint32_t called_func_id = call_stack.top(); call_stack.pop(); if (!visited.insert(called_func_id).second) continue; if (called_func_id == func.id()) { for (const uint32_t entry_point : function_to_entry_points_[called_func_id]) recursive_entry_points_.insert(entry_point); break; } const Function* called_func = function(called_func_id); if (called_func) { // Other checks should error out on this invalid SPIR-V. for (const uint32_t new_call : called_func->function_call_targets()) { call_stack.push(new_call); } } } } } const std::vector& ValidationState_t::FunctionEntryPoints( uint32_t func) const { auto iter = function_to_entry_points_.find(func); if (iter == function_to_entry_points_.end()) { return empty_ids_; } else { return iter->second; } } std::set ValidationState_t::EntryPointReferences(uint32_t id) const { std::set referenced_entry_points; const auto inst = FindDef(id); if (!inst) return referenced_entry_points; std::vector stack; stack.push_back(inst); while (!stack.empty()) { const auto current_inst = stack.back(); stack.pop_back(); if (const auto func = current_inst->function()) { // Instruction lives in a function, we can stop searching. const auto function_entry_points = FunctionEntryPoints(func->id()); referenced_entry_points.insert(function_entry_points.begin(), function_entry_points.end()); } else { // Instruction is in the global scope, keep searching its uses. for (auto pair : current_inst->uses()) { const auto next_inst = pair.first; stack.push_back(next_inst); } } } return referenced_entry_points; } std::string ValidationState_t::Disassemble(const Instruction& inst) const { const spv_parsed_instruction_t& c_inst(inst.c_inst()); return Disassemble(c_inst.words, c_inst.num_words); } std::string ValidationState_t::Disassemble(const uint32_t* words, uint16_t num_words) const { uint32_t disassembly_options = SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES; return spvInstructionBinaryToText(context()->target_env, words, num_words, words_, num_words_, disassembly_options); } bool ValidationState_t::LogicallyMatch(const Instruction* lhs, const Instruction* rhs, bool check_decorations) { if (lhs->opcode() != rhs->opcode()) { return false; } if (check_decorations) { const auto& dec_a = id_decorations(lhs->id()); const auto& dec_b = id_decorations(rhs->id()); for (const auto& dec : dec_b) { if (std::find(dec_a.begin(), dec_a.end(), dec) == dec_a.end()) { return false; } } } if (lhs->opcode() == spv::Op::OpTypeArray) { // Size operands must match. if (lhs->GetOperandAs(2u) != rhs->GetOperandAs(2u)) { return false; } // Elements must match or logically match. const auto lhs_ele_id = lhs->GetOperandAs(1u); const auto rhs_ele_id = rhs->GetOperandAs(1u); if (lhs_ele_id == rhs_ele_id) { return true; } const auto lhs_ele = FindDef(lhs_ele_id); const auto rhs_ele = FindDef(rhs_ele_id); if (!lhs_ele || !rhs_ele) { return false; } return LogicallyMatch(lhs_ele, rhs_ele, check_decorations); } else if (lhs->opcode() == spv::Op::OpTypeStruct) { // Number of elements must match. if (lhs->operands().size() != rhs->operands().size()) { return false; } for (size_t i = 1u; i < lhs->operands().size(); ++i) { const auto lhs_ele_id = lhs->GetOperandAs(i); const auto rhs_ele_id = rhs->GetOperandAs(i); // Elements must match or logically match. if (lhs_ele_id == rhs_ele_id) { continue; } const auto lhs_ele = FindDef(lhs_ele_id); const auto rhs_ele = FindDef(rhs_ele_id); if (!lhs_ele || !rhs_ele) { return false; } if (!LogicallyMatch(lhs_ele, rhs_ele, check_decorations)) { return false; } } // All checks passed. return true; } // No other opcodes are acceptable at this point. Arrays and structs are // caught above and if they're elements are not arrays or structs they are // required to match exactly. return false; } const Instruction* ValidationState_t::TracePointer( const Instruction* inst) const { auto base_ptr = inst; while (base_ptr->opcode() == spv::Op::OpAccessChain || base_ptr->opcode() == spv::Op::OpInBoundsAccessChain || base_ptr->opcode() == spv::Op::OpPtrAccessChain || base_ptr->opcode() == spv::Op::OpInBoundsPtrAccessChain || base_ptr->opcode() == spv::Op::OpCopyObject) { base_ptr = FindDef(base_ptr->GetOperandAs(2u)); } return base_ptr; } bool ValidationState_t::ContainsType( uint32_t id, const std::function& f, bool traverse_all_types) const { const auto inst = FindDef(id); if (!inst) return false; if (f(inst)) return true; switch (inst->opcode()) { case spv::Op::OpTypeArray: case spv::Op::OpTypeRuntimeArray: case spv::Op::OpTypeVector: case spv::Op::OpTypeMatrix: case spv::Op::OpTypeImage: case spv::Op::OpTypeSampledImage: case spv::Op::OpTypeCooperativeMatrixNV: case spv::Op::OpTypeCooperativeMatrixKHR: case spv::Op::OpTypeCooperativeVectorNV: return ContainsType(inst->GetOperandAs(1u), f, traverse_all_types); case spv::Op::OpTypePointer: if (IsForwardPointer(id)) return false; if (traverse_all_types) { return ContainsType(inst->GetOperandAs(2u), f, traverse_all_types); } break; case spv::Op::OpTypeFunction: case spv::Op::OpTypeStruct: if (inst->opcode() == spv::Op::OpTypeFunction && !traverse_all_types) { return false; } for (uint32_t i = 1; i < inst->operands().size(); ++i) { if (ContainsType(inst->GetOperandAs(i), f, traverse_all_types)) { return true; } } break; default: break; } return false; } bool ValidationState_t::ContainsSizedIntOrFloatType(uint32_t id, spv::Op type, uint32_t width) const { if (type != spv::Op::OpTypeInt && type != spv::Op::OpTypeFloat) return false; const auto f = [type, width](const Instruction* inst) { if (inst->opcode() == type) { return inst->GetOperandAs(1u) == width; } return false; }; return ContainsType(id, f); } bool ValidationState_t::ContainsLimitedUseIntOrFloatType(uint32_t id) const { if ((!HasCapability(spv::Capability::Int16) && ContainsSizedIntOrFloatType(id, spv::Op::OpTypeInt, 16)) || (!HasCapability(spv::Capability::Int8) && ContainsSizedIntOrFloatType(id, spv::Op::OpTypeInt, 8)) || (!HasCapability(spv::Capability::Float16) && ContainsSizedIntOrFloatType(id, spv::Op::OpTypeFloat, 16))) { return true; } return false; } bool ValidationState_t::ContainsRuntimeArray(uint32_t id) const { const auto f = [](const Instruction* inst) { return inst->opcode() == spv::Op::OpTypeRuntimeArray; }; return ContainsType(id, f, /* traverse_all_types = */ false); } bool ValidationState_t::ContainsUntypedPointer(uint32_t id) const { const auto inst = FindDef(id); if (!inst) return false; if (!spvOpcodeGeneratesType(inst->opcode())) return false; if (inst->opcode() == spv::Op::OpTypeUntypedPointerKHR) return true; switch (inst->opcode()) { case spv::Op::OpTypeArray: case spv::Op::OpTypeRuntimeArray: case spv::Op::OpTypeVector: case spv::Op::OpTypeMatrix: case spv::Op::OpTypeImage: case spv::Op::OpTypeSampledImage: case spv::Op::OpTypeCooperativeMatrixNV: return ContainsUntypedPointer(inst->GetOperandAs(1u)); case spv::Op::OpTypePointer: if (IsForwardPointer(id)) return false; return ContainsUntypedPointer(inst->GetOperandAs(2u)); case spv::Op::OpTypeFunction: case spv::Op::OpTypeStruct: { for (uint32_t i = 1; i < inst->operands().size(); ++i) { if (ContainsUntypedPointer(inst->GetOperandAs(i))) return true; } return false; } default: return false; } return false; } bool ValidationState_t::IsValidStorageClass( spv::StorageClass storage_class) const { if (spvIsVulkanEnv(context()->target_env)) { switch (storage_class) { case spv::StorageClass::UniformConstant: case spv::StorageClass::Uniform: case spv::StorageClass::StorageBuffer: case spv::StorageClass::Input: case spv::StorageClass::Output: case spv::StorageClass::Image: case spv::StorageClass::Workgroup: case spv::StorageClass::Private: case spv::StorageClass::Function: case spv::StorageClass::PushConstant: case spv::StorageClass::PhysicalStorageBuffer: case spv::StorageClass::RayPayloadKHR: case spv::StorageClass::IncomingRayPayloadKHR: case spv::StorageClass::HitAttributeKHR: case spv::StorageClass::CallableDataKHR: case spv::StorageClass::IncomingCallableDataKHR: case spv::StorageClass::ShaderRecordBufferKHR: case spv::StorageClass::TaskPayloadWorkgroupEXT: case spv::StorageClass::HitObjectAttributeNV: case spv::StorageClass::TileImageEXT: case spv::StorageClass::NodePayloadAMDX: return true; default: return false; } } return true; } #define VUID_WRAP(vuid) "[" #vuid "] " // Currently no 2 VUID share the same id, so no need for |reference| std::string ValidationState_t::VkErrorID(uint32_t id, const char* /*reference*/) const { if (!spvIsVulkanEnv(context_->target_env)) { return ""; } // This large switch case is only searched when an error has occurred. // If an id is changed, the old case must be modified or removed. Each string // here is interpreted as being "implemented" // Clang format adds spaces between hyphens // clang-format off switch (id) { case 4154: return VUID_WRAP(VUID-BaryCoordKHR-BaryCoordKHR-04154); case 4155: return VUID_WRAP(VUID-BaryCoordKHR-BaryCoordKHR-04155); case 4156: return VUID_WRAP(VUID-BaryCoordKHR-BaryCoordKHR-04156); case 4160: return VUID_WRAP(VUID-BaryCoordNoPerspKHR-BaryCoordNoPerspKHR-04160); case 4161: return VUID_WRAP(VUID-BaryCoordNoPerspKHR-BaryCoordNoPerspKHR-04161); case 4162: return VUID_WRAP(VUID-BaryCoordNoPerspKHR-BaryCoordNoPerspKHR-04162); case 4181: return VUID_WRAP(VUID-BaseInstance-BaseInstance-04181); case 4182: return VUID_WRAP(VUID-BaseInstance-BaseInstance-04182); case 4183: return VUID_WRAP(VUID-BaseInstance-BaseInstance-04183); case 4184: return VUID_WRAP(VUID-BaseVertex-BaseVertex-04184); case 4185: return VUID_WRAP(VUID-BaseVertex-BaseVertex-04185); case 4186: return VUID_WRAP(VUID-BaseVertex-BaseVertex-04186); case 4187: return VUID_WRAP(VUID-ClipDistance-ClipDistance-04187); case 4188: return VUID_WRAP(VUID-ClipDistance-ClipDistance-04188); case 4189: return VUID_WRAP(VUID-ClipDistance-ClipDistance-04189); case 4190: return VUID_WRAP(VUID-ClipDistance-ClipDistance-04190); case 4191: return VUID_WRAP(VUID-ClipDistance-ClipDistance-04191); case 4196: return VUID_WRAP(VUID-CullDistance-CullDistance-04196); case 4197: return VUID_WRAP(VUID-CullDistance-CullDistance-04197); case 4198: return VUID_WRAP(VUID-CullDistance-CullDistance-04198); case 4199: return VUID_WRAP(VUID-CullDistance-CullDistance-04199); case 4200: return VUID_WRAP(VUID-CullDistance-CullDistance-04200); case 6735: return VUID_WRAP(VUID-CullMaskKHR-CullMaskKHR-06735); // Execution Model case 6736: return VUID_WRAP(VUID-CullMaskKHR-CullMaskKHR-06736); // input storage case 6737: return VUID_WRAP(VUID-CullMaskKHR-CullMaskKHR-06737); // 32 int scalar case 4205: return VUID_WRAP(VUID-DeviceIndex-DeviceIndex-04205); case 4206: return VUID_WRAP(VUID-DeviceIndex-DeviceIndex-04206); case 4207: return VUID_WRAP(VUID-DrawIndex-DrawIndex-04207); case 4208: return VUID_WRAP(VUID-DrawIndex-DrawIndex-04208); case 4209: return VUID_WRAP(VUID-DrawIndex-DrawIndex-04209); case 4210: return VUID_WRAP(VUID-FragCoord-FragCoord-04210); case 4211: return VUID_WRAP(VUID-FragCoord-FragCoord-04211); case 4212: return VUID_WRAP(VUID-FragCoord-FragCoord-04212); case 4213: return VUID_WRAP(VUID-FragDepth-FragDepth-04213); case 4214: return VUID_WRAP(VUID-FragDepth-FragDepth-04214); case 4215: return VUID_WRAP(VUID-FragDepth-FragDepth-04215); case 4216: return VUID_WRAP(VUID-FragDepth-FragDepth-04216); case 4217: return VUID_WRAP(VUID-FragInvocationCountEXT-FragInvocationCountEXT-04217); case 4218: return VUID_WRAP(VUID-FragInvocationCountEXT-FragInvocationCountEXT-04218); case 4219: return VUID_WRAP(VUID-FragInvocationCountEXT-FragInvocationCountEXT-04219); case 4220: return VUID_WRAP(VUID-FragSizeEXT-FragSizeEXT-04220); case 4221: return VUID_WRAP(VUID-FragSizeEXT-FragSizeEXT-04221); case 4222: return VUID_WRAP(VUID-FragSizeEXT-FragSizeEXT-04222); case 4223: return VUID_WRAP(VUID-FragStencilRefEXT-FragStencilRefEXT-04223); case 4224: return VUID_WRAP(VUID-FragStencilRefEXT-FragStencilRefEXT-04224); case 4225: return VUID_WRAP(VUID-FragStencilRefEXT-FragStencilRefEXT-04225); case 4229: return VUID_WRAP(VUID-FrontFacing-FrontFacing-04229); case 4230: return VUID_WRAP(VUID-FrontFacing-FrontFacing-04230); case 4231: return VUID_WRAP(VUID-FrontFacing-FrontFacing-04231); case 4232: return VUID_WRAP(VUID-FullyCoveredEXT-FullyCoveredEXT-04232); case 4233: return VUID_WRAP(VUID-FullyCoveredEXT-FullyCoveredEXT-04233); case 4234: return VUID_WRAP(VUID-FullyCoveredEXT-FullyCoveredEXT-04234); case 4236: return VUID_WRAP(VUID-GlobalInvocationId-GlobalInvocationId-04236); case 4237: return VUID_WRAP(VUID-GlobalInvocationId-GlobalInvocationId-04237); case 4238: return VUID_WRAP(VUID-GlobalInvocationId-GlobalInvocationId-04238); case 4239: return VUID_WRAP(VUID-HelperInvocation-HelperInvocation-04239); case 4240: return VUID_WRAP(VUID-HelperInvocation-HelperInvocation-04240); case 4241: return VUID_WRAP(VUID-HelperInvocation-HelperInvocation-04241); case 4242: return VUID_WRAP(VUID-HitKindKHR-HitKindKHR-04242); case 4243: return VUID_WRAP(VUID-HitKindKHR-HitKindKHR-04243); case 4244: return VUID_WRAP(VUID-HitKindKHR-HitKindKHR-04244); case 4245: return VUID_WRAP(VUID-HitTNV-HitTNV-04245); case 4246: return VUID_WRAP(VUID-HitTNV-HitTNV-04246); case 4247: return VUID_WRAP(VUID-HitTNV-HitTNV-04247); case 4248: return VUID_WRAP(VUID-IncomingRayFlagsKHR-IncomingRayFlagsKHR-04248); case 4249: return VUID_WRAP(VUID-IncomingRayFlagsKHR-IncomingRayFlagsKHR-04249); case 4250: return VUID_WRAP(VUID-IncomingRayFlagsKHR-IncomingRayFlagsKHR-04250); case 4251: return VUID_WRAP(VUID-InstanceCustomIndexKHR-InstanceCustomIndexKHR-04251); case 4252: return VUID_WRAP(VUID-InstanceCustomIndexKHR-InstanceCustomIndexKHR-04252); case 4253: return VUID_WRAP(VUID-InstanceCustomIndexKHR-InstanceCustomIndexKHR-04253); case 4254: return VUID_WRAP(VUID-InstanceId-InstanceId-04254); case 4255: return VUID_WRAP(VUID-InstanceId-InstanceId-04255); case 4256: return VUID_WRAP(VUID-InstanceId-InstanceId-04256); case 4257: return VUID_WRAP(VUID-InvocationId-InvocationId-04257); case 4258: return VUID_WRAP(VUID-InvocationId-InvocationId-04258); case 4259: return VUID_WRAP(VUID-InvocationId-InvocationId-04259); case 4263: return VUID_WRAP(VUID-InstanceIndex-InstanceIndex-04263); case 4264: return VUID_WRAP(VUID-InstanceIndex-InstanceIndex-04264); case 4265: return VUID_WRAP(VUID-InstanceIndex-InstanceIndex-04265); case 4266: return VUID_WRAP(VUID-LaunchIdKHR-LaunchIdKHR-04266); case 4267: return VUID_WRAP(VUID-LaunchIdKHR-LaunchIdKHR-04267); case 4268: return VUID_WRAP(VUID-LaunchIdKHR-LaunchIdKHR-04268); case 4269: return VUID_WRAP(VUID-LaunchSizeKHR-LaunchSizeKHR-04269); case 4270: return VUID_WRAP(VUID-LaunchSizeKHR-LaunchSizeKHR-04270); case 4271: return VUID_WRAP(VUID-LaunchSizeKHR-LaunchSizeKHR-04271); case 4272: return VUID_WRAP(VUID-Layer-Layer-04272); case 4273: return VUID_WRAP(VUID-Layer-Layer-04273); case 4274: return VUID_WRAP(VUID-Layer-Layer-04274); case 4275: return VUID_WRAP(VUID-Layer-Layer-04275); case 4276: return VUID_WRAP(VUID-Layer-Layer-04276); case 4281: return VUID_WRAP(VUID-LocalInvocationId-LocalInvocationId-04281); case 4282: return VUID_WRAP(VUID-LocalInvocationId-LocalInvocationId-04282); case 4283: return VUID_WRAP(VUID-LocalInvocationId-LocalInvocationId-04283); case 4293: return VUID_WRAP(VUID-NumSubgroups-NumSubgroups-04293); case 4294: return VUID_WRAP(VUID-NumSubgroups-NumSubgroups-04294); case 4295: return VUID_WRAP(VUID-NumSubgroups-NumSubgroups-04295); case 4296: return VUID_WRAP(VUID-NumWorkgroups-NumWorkgroups-04296); case 4297: return VUID_WRAP(VUID-NumWorkgroups-NumWorkgroups-04297); case 4298: return VUID_WRAP(VUID-NumWorkgroups-NumWorkgroups-04298); case 4299: return VUID_WRAP(VUID-ObjectRayDirectionKHR-ObjectRayDirectionKHR-04299); case 4300: return VUID_WRAP(VUID-ObjectRayDirectionKHR-ObjectRayDirectionKHR-04300); case 4301: return VUID_WRAP(VUID-ObjectRayDirectionKHR-ObjectRayDirectionKHR-04301); case 4302: return VUID_WRAP(VUID-ObjectRayOriginKHR-ObjectRayOriginKHR-04302); case 4303: return VUID_WRAP(VUID-ObjectRayOriginKHR-ObjectRayOriginKHR-04303); case 4304: return VUID_WRAP(VUID-ObjectRayOriginKHR-ObjectRayOriginKHR-04304); case 4305: return VUID_WRAP(VUID-ObjectToWorldKHR-ObjectToWorldKHR-04305); case 4306: return VUID_WRAP(VUID-ObjectToWorldKHR-ObjectToWorldKHR-04306); case 4307: return VUID_WRAP(VUID-ObjectToWorldKHR-ObjectToWorldKHR-04307); case 4308: return VUID_WRAP(VUID-PatchVertices-PatchVertices-04308); case 4309: return VUID_WRAP(VUID-PatchVertices-PatchVertices-04309); case 4310: return VUID_WRAP(VUID-PatchVertices-PatchVertices-04310); case 4311: return VUID_WRAP(VUID-PointCoord-PointCoord-04311); case 4312: return VUID_WRAP(VUID-PointCoord-PointCoord-04312); case 4313: return VUID_WRAP(VUID-PointCoord-PointCoord-04313); case 4314: return VUID_WRAP(VUID-PointSize-PointSize-04314); case 4315: return VUID_WRAP(VUID-PointSize-PointSize-04315); case 4316: return VUID_WRAP(VUID-PointSize-PointSize-04316); case 4317: return VUID_WRAP(VUID-PointSize-PointSize-04317); case 4318: return VUID_WRAP(VUID-Position-Position-04318); case 4319: return VUID_WRAP(VUID-Position-Position-04319); case 4320: return VUID_WRAP(VUID-Position-Position-04320); case 4321: return VUID_WRAP(VUID-Position-Position-04321); case 4330: return VUID_WRAP(VUID-PrimitiveId-PrimitiveId-04330); case 4334: return VUID_WRAP(VUID-PrimitiveId-PrimitiveId-04334); case 4336: return VUID_WRAP(VUID-PrimitiveId-PrimitiveId-04336); case 4337: return VUID_WRAP(VUID-PrimitiveId-PrimitiveId-04337); case 4345: return VUID_WRAP(VUID-RayGeometryIndexKHR-RayGeometryIndexKHR-04345); case 4346: return VUID_WRAP(VUID-RayGeometryIndexKHR-RayGeometryIndexKHR-04346); case 4347: return VUID_WRAP(VUID-RayGeometryIndexKHR-RayGeometryIndexKHR-04347); case 4348: return VUID_WRAP(VUID-RayTmaxKHR-RayTmaxKHR-04348); case 4349: return VUID_WRAP(VUID-RayTmaxKHR-RayTmaxKHR-04349); case 4350: return VUID_WRAP(VUID-RayTmaxKHR-RayTmaxKHR-04350); case 4351: return VUID_WRAP(VUID-RayTminKHR-RayTminKHR-04351); case 4352: return VUID_WRAP(VUID-RayTminKHR-RayTminKHR-04352); case 4353: return VUID_WRAP(VUID-RayTminKHR-RayTminKHR-04353); case 4354: return VUID_WRAP(VUID-SampleId-SampleId-04354); case 4355: return VUID_WRAP(VUID-SampleId-SampleId-04355); case 4356: return VUID_WRAP(VUID-SampleId-SampleId-04356); case 4357: return VUID_WRAP(VUID-SampleMask-SampleMask-04357); case 4358: return VUID_WRAP(VUID-SampleMask-SampleMask-04358); case 4359: return VUID_WRAP(VUID-SampleMask-SampleMask-04359); case 4360: return VUID_WRAP(VUID-SamplePosition-SamplePosition-04360); case 4361: return VUID_WRAP(VUID-SamplePosition-SamplePosition-04361); case 4362: return VUID_WRAP(VUID-SamplePosition-SamplePosition-04362); case 4367: return VUID_WRAP(VUID-SubgroupId-SubgroupId-04367); case 4368: return VUID_WRAP(VUID-SubgroupId-SubgroupId-04368); case 4369: return VUID_WRAP(VUID-SubgroupId-SubgroupId-04369); case 4370: return VUID_WRAP(VUID-SubgroupEqMask-SubgroupEqMask-04370); case 4371: return VUID_WRAP(VUID-SubgroupEqMask-SubgroupEqMask-04371); case 4372: return VUID_WRAP(VUID-SubgroupGeMask-SubgroupGeMask-04372); case 4373: return VUID_WRAP(VUID-SubgroupGeMask-SubgroupGeMask-04373); case 4374: return VUID_WRAP(VUID-SubgroupGtMask-SubgroupGtMask-04374); case 4375: return VUID_WRAP(VUID-SubgroupGtMask-SubgroupGtMask-04375); case 4376: return VUID_WRAP(VUID-SubgroupLeMask-SubgroupLeMask-04376); case 4377: return VUID_WRAP(VUID-SubgroupLeMask-SubgroupLeMask-04377); case 4378: return VUID_WRAP(VUID-SubgroupLtMask-SubgroupLtMask-04378); case 4379: return VUID_WRAP(VUID-SubgroupLtMask-SubgroupLtMask-04379); case 4380: return VUID_WRAP(VUID-SubgroupLocalInvocationId-SubgroupLocalInvocationId-04380); case 4381: return VUID_WRAP(VUID-SubgroupLocalInvocationId-SubgroupLocalInvocationId-04381); case 4382: return VUID_WRAP(VUID-SubgroupSize-SubgroupSize-04382); case 4383: return VUID_WRAP(VUID-SubgroupSize-SubgroupSize-04383); case 4387: return VUID_WRAP(VUID-TessCoord-TessCoord-04387); case 4388: return VUID_WRAP(VUID-TessCoord-TessCoord-04388); case 4389: return VUID_WRAP(VUID-TessCoord-TessCoord-04389); case 4390: return VUID_WRAP(VUID-TessLevelOuter-TessLevelOuter-04390); case 4391: return VUID_WRAP(VUID-TessLevelOuter-TessLevelOuter-04391); case 4392: return VUID_WRAP(VUID-TessLevelOuter-TessLevelOuter-04392); case 4393: return VUID_WRAP(VUID-TessLevelOuter-TessLevelOuter-04393); case 4394: return VUID_WRAP(VUID-TessLevelInner-TessLevelInner-04394); case 4395: return VUID_WRAP(VUID-TessLevelInner-TessLevelInner-04395); case 4396: return VUID_WRAP(VUID-TessLevelInner-TessLevelInner-04396); case 4397: return VUID_WRAP(VUID-TessLevelInner-TessLevelInner-04397); case 4398: return VUID_WRAP(VUID-VertexIndex-VertexIndex-04398); case 4399: return VUID_WRAP(VUID-VertexIndex-VertexIndex-04399); case 4400: return VUID_WRAP(VUID-VertexIndex-VertexIndex-04400); case 4401: return VUID_WRAP(VUID-ViewIndex-ViewIndex-04401); case 4402: return VUID_WRAP(VUID-ViewIndex-ViewIndex-04402); case 4403: return VUID_WRAP(VUID-ViewIndex-ViewIndex-04403); case 4404: return VUID_WRAP(VUID-ViewportIndex-ViewportIndex-04404); case 4405: return VUID_WRAP(VUID-ViewportIndex-ViewportIndex-04405); case 4406: return VUID_WRAP(VUID-ViewportIndex-ViewportIndex-04406); case 4407: return VUID_WRAP(VUID-ViewportIndex-ViewportIndex-04407); case 4408: return VUID_WRAP(VUID-ViewportIndex-ViewportIndex-04408); case 4422: return VUID_WRAP(VUID-WorkgroupId-WorkgroupId-04422); case 4423: return VUID_WRAP(VUID-WorkgroupId-WorkgroupId-04423); case 4424: return VUID_WRAP(VUID-WorkgroupId-WorkgroupId-04424); case 4425: return VUID_WRAP(VUID-WorkgroupSize-WorkgroupSize-04425); case 4426: return VUID_WRAP(VUID-WorkgroupSize-WorkgroupSize-04426); case 4427: return VUID_WRAP(VUID-WorkgroupSize-WorkgroupSize-04427); case 4428: return VUID_WRAP(VUID-WorldRayDirectionKHR-WorldRayDirectionKHR-04428); case 4429: return VUID_WRAP(VUID-WorldRayDirectionKHR-WorldRayDirectionKHR-04429); case 4430: return VUID_WRAP(VUID-WorldRayDirectionKHR-WorldRayDirectionKHR-04430); case 4431: return VUID_WRAP(VUID-WorldRayOriginKHR-WorldRayOriginKHR-04431); case 4432: return VUID_WRAP(VUID-WorldRayOriginKHR-WorldRayOriginKHR-04432); case 4433: return VUID_WRAP(VUID-WorldRayOriginKHR-WorldRayOriginKHR-04433); case 4434: return VUID_WRAP(VUID-WorldToObjectKHR-WorldToObjectKHR-04434); case 4435: return VUID_WRAP(VUID-WorldToObjectKHR-WorldToObjectKHR-04435); case 4436: return VUID_WRAP(VUID-WorldToObjectKHR-WorldToObjectKHR-04436); case 4484: return VUID_WRAP(VUID-PrimitiveShadingRateKHR-PrimitiveShadingRateKHR-04484); case 4485: return VUID_WRAP(VUID-PrimitiveShadingRateKHR-PrimitiveShadingRateKHR-04485); case 4486: return VUID_WRAP(VUID-PrimitiveShadingRateKHR-PrimitiveShadingRateKHR-04486); case 4490: return VUID_WRAP(VUID-ShadingRateKHR-ShadingRateKHR-04490); case 4491: return VUID_WRAP(VUID-ShadingRateKHR-ShadingRateKHR-04491); case 4492: return VUID_WRAP(VUID-ShadingRateKHR-ShadingRateKHR-04492); case 4633: return VUID_WRAP(VUID-StandaloneSpirv-None-04633); case 4634: return VUID_WRAP(VUID-StandaloneSpirv-None-04634); case 4635: return VUID_WRAP(VUID-StandaloneSpirv-None-04635); case 4636: return VUID_WRAP(VUID-StandaloneSpirv-None-04636); case 4637: return VUID_WRAP(VUID-StandaloneSpirv-None-04637); case 4638: return VUID_WRAP(VUID-StandaloneSpirv-None-04638); case 7321: return VUID_WRAP(VUID-StandaloneSpirv-None-07321); case 4640: return VUID_WRAP(VUID-StandaloneSpirv-None-04640); case 4641: return VUID_WRAP(VUID-StandaloneSpirv-None-04641); case 4642: return VUID_WRAP(VUID-StandaloneSpirv-None-04642); case 4643: return VUID_WRAP(VUID-StandaloneSpirv-None-04643); case 4644: return VUID_WRAP(VUID-StandaloneSpirv-None-04644); case 4645: return VUID_WRAP(VUID-StandaloneSpirv-None-04645); case 4650: return VUID_WRAP(VUID-StandaloneSpirv-OpControlBarrier-04650); case 4651: return VUID_WRAP(VUID-StandaloneSpirv-OpVariable-04651); case 4652: return VUID_WRAP(VUID-StandaloneSpirv-OpReadClockKHR-04652); case 4653: return VUID_WRAP(VUID-StandaloneSpirv-OriginLowerLeft-04653); case 4654: return VUID_WRAP(VUID-StandaloneSpirv-PixelCenterInteger-04654); case 4655: return VUID_WRAP(VUID-StandaloneSpirv-UniformConstant-04655); case 4656: return VUID_WRAP(VUID-StandaloneSpirv-OpTypeImage-04656); case 4657: return VUID_WRAP(VUID-StandaloneSpirv-OpTypeImage-04657); case 4658: return VUID_WRAP(VUID-StandaloneSpirv-OpImageTexelPointer-04658); case 4659: return VUID_WRAP(VUID-StandaloneSpirv-OpImageQuerySizeLod-04659); case 4664: return VUID_WRAP(VUID-StandaloneSpirv-OpImageGather-04664); case 4667: return VUID_WRAP(VUID-StandaloneSpirv-None-04667); case 4669: return VUID_WRAP(VUID-StandaloneSpirv-GLSLShared-04669); case 4670: return VUID_WRAP(VUID-StandaloneSpirv-Flat-04670); case 4675: return VUID_WRAP(VUID-StandaloneSpirv-FPRoundingMode-04675); case 4677: return VUID_WRAP(VUID-StandaloneSpirv-Invariant-04677); case 4680: return VUID_WRAP(VUID-StandaloneSpirv-OpTypeRuntimeArray-04680); case 4682: return VUID_WRAP(VUID-StandaloneSpirv-OpControlBarrier-04682); case 6426: return VUID_WRAP(VUID-StandaloneSpirv-LocalSize-06426); // formally 04683 case 4685: return VUID_WRAP(VUID-StandaloneSpirv-OpGroupNonUniformBallotBitCount-04685); case 4686: return VUID_WRAP(VUID-StandaloneSpirv-None-04686); case 4698: return VUID_WRAP(VUID-StandaloneSpirv-RayPayloadKHR-04698); case 4699: return VUID_WRAP(VUID-StandaloneSpirv-IncomingRayPayloadKHR-04699); case 4700: return VUID_WRAP(VUID-StandaloneSpirv-IncomingRayPayloadKHR-04700); case 4701: return VUID_WRAP(VUID-StandaloneSpirv-HitAttributeKHR-04701); case 4702: return VUID_WRAP(VUID-StandaloneSpirv-HitAttributeKHR-04702); case 4703: return VUID_WRAP(VUID-StandaloneSpirv-HitAttributeKHR-04703); case 4704: return VUID_WRAP(VUID-StandaloneSpirv-CallableDataKHR-04704); case 4705: return VUID_WRAP(VUID-StandaloneSpirv-IncomingCallableDataKHR-04705); case 4706: return VUID_WRAP(VUID-StandaloneSpirv-IncomingCallableDataKHR-04706); case 7119: return VUID_WRAP(VUID-StandaloneSpirv-ShaderRecordBufferKHR-07119); case 4708: return VUID_WRAP(VUID-StandaloneSpirv-PhysicalStorageBuffer64-04708); case 4710: return VUID_WRAP(VUID-StandaloneSpirv-PhysicalStorageBuffer64-04710); case 4711: return VUID_WRAP(VUID-StandaloneSpirv-OpTypeForwardPointer-04711); case 4730: return VUID_WRAP(VUID-StandaloneSpirv-OpAtomicStore-04730); case 4731: return VUID_WRAP(VUID-StandaloneSpirv-OpAtomicLoad-04731); case 4732: return VUID_WRAP(VUID-StandaloneSpirv-OpMemoryBarrier-04732); case 4733: return VUID_WRAP(VUID-StandaloneSpirv-OpMemoryBarrier-04733); case 4734: return VUID_WRAP(VUID-StandaloneSpirv-OpVariable-04734); case 4744: return VUID_WRAP(VUID-StandaloneSpirv-Flat-04744); case 4777: return VUID_WRAP(VUID-StandaloneSpirv-OpImage-04777); case 4780: return VUID_WRAP(VUID-StandaloneSpirv-Result-04780); case 4781: return VUID_WRAP(VUID-StandaloneSpirv-Base-04781); case 4915: return VUID_WRAP(VUID-StandaloneSpirv-Location-04915); case 4916: return VUID_WRAP(VUID-StandaloneSpirv-Location-04916); case 4917: return VUID_WRAP(VUID-StandaloneSpirv-Location-04917); case 4918: return VUID_WRAP(VUID-StandaloneSpirv-Location-04918); case 4919: return VUID_WRAP(VUID-StandaloneSpirv-Location-04919); case 4920: return VUID_WRAP(VUID-StandaloneSpirv-Component-04920); case 4921: return VUID_WRAP(VUID-StandaloneSpirv-Component-04921); case 4922: return VUID_WRAP(VUID-StandaloneSpirv-Component-04922); case 4923: return VUID_WRAP(VUID-StandaloneSpirv-Component-04923); case 6201: return VUID_WRAP(VUID-StandaloneSpirv-Flat-06201); case 6202: return VUID_WRAP(VUID-StandaloneSpirv-Flat-06202); case 6214: return VUID_WRAP(VUID-StandaloneSpirv-OpTypeImage-06214); case 6491: return VUID_WRAP(VUID-StandaloneSpirv-DescriptorSet-06491); case 6671: return VUID_WRAP(VUID-StandaloneSpirv-OpTypeSampledImage-06671); case 6672: return VUID_WRAP(VUID-StandaloneSpirv-Location-06672); case 6673: return VUID_WRAP(VUID-StandaloneSpirv-OpVariable-06673); case 6674: return VUID_WRAP(VUID-StandaloneSpirv-OpEntryPoint-06674); case 6675: return VUID_WRAP(VUID-StandaloneSpirv-PushConstant-06675); case 6676: return VUID_WRAP(VUID-StandaloneSpirv-Uniform-06676); case 6677: return VUID_WRAP(VUID-StandaloneSpirv-UniformConstant-06677); case 6678: return VUID_WRAP(VUID-StandaloneSpirv-InputAttachmentIndex-06678); case 6777: return VUID_WRAP(VUID-StandaloneSpirv-PerVertexKHR-06777); case 6778: return VUID_WRAP(VUID-StandaloneSpirv-Input-06778); case 6807: return VUID_WRAP(VUID-StandaloneSpirv-Uniform-06807); case 6808: return VUID_WRAP(VUID-StandaloneSpirv-PushConstant-06808); case 6924: return VUID_WRAP(VUID-StandaloneSpirv-OpTypeImage-06924); case 6925: return VUID_WRAP(VUID-StandaloneSpirv-Uniform-06925); case 7034: return VUID_WRAP(VUID-CullPrimitiveEXT-CullPrimitiveEXT-07034); case 7035: return VUID_WRAP(VUID-CullPrimitiveEXT-CullPrimitiveEXT-07035); case 7036: return VUID_WRAP(VUID-CullPrimitiveEXT-CullPrimitiveEXT-07036); case 7038: return VUID_WRAP(VUID-CullPrimitiveEXT-CullPrimitiveEXT-07038); case 7039: return VUID_WRAP(VUID-Layer-Layer-07039); case 7040: return VUID_WRAP(VUID-PrimitiveId-PrimitiveId-07040); case 7041: return VUID_WRAP(VUID-PrimitivePointIndicesEXT-PrimitivePointIndicesEXT-07041); case 7042: return VUID_WRAP(VUID-PrimitivePointIndicesEXT-PrimitivePointIndicesEXT-07042); case 7043: return VUID_WRAP(VUID-PrimitivePointIndicesEXT-PrimitivePointIndicesEXT-07043); case 7044: return VUID_WRAP(VUID-PrimitivePointIndicesEXT-PrimitivePointIndicesEXT-07044); case 7046: return VUID_WRAP(VUID-PrimitivePointIndicesEXT-PrimitivePointIndicesEXT-07046); case 7047: return VUID_WRAP(VUID-PrimitiveLineIndicesEXT-PrimitiveLineIndicesEXT-07047); case 7048: return VUID_WRAP(VUID-PrimitiveLineIndicesEXT-PrimitiveLineIndicesEXT-07048); case 7049: return VUID_WRAP(VUID-PrimitiveLineIndicesEXT-PrimitiveLineIndicesEXT-07049); case 7050: return VUID_WRAP(VUID-PrimitiveLineIndicesEXT-PrimitiveLineIndicesEXT-07050); case 7052: return VUID_WRAP(VUID-PrimitiveLineIndicesEXT-PrimitiveLineIndicesEXT-07052); case 7053: return VUID_WRAP(VUID-PrimitiveTriangleIndicesEXT-PrimitiveTriangleIndicesEXT-07053); case 7054: return VUID_WRAP(VUID-PrimitiveTriangleIndicesEXT-PrimitiveTriangleIndicesEXT-07054); case 7055: return VUID_WRAP(VUID-PrimitiveTriangleIndicesEXT-PrimitiveTriangleIndicesEXT-07055); case 7056: return VUID_WRAP(VUID-PrimitiveTriangleIndicesEXT-PrimitiveTriangleIndicesEXT-07056); case 7058: return VUID_WRAP(VUID-PrimitiveTriangleIndicesEXT-PrimitiveTriangleIndicesEXT-07058); case 7059: return VUID_WRAP(VUID-PrimitiveShadingRateKHR-PrimitiveShadingRateKHR-07059); case 7060: return VUID_WRAP(VUID-ViewportIndex-ViewportIndex-07060); case 7102: return VUID_WRAP(VUID-StandaloneSpirv-MeshEXT-07102); case 7290: return VUID_WRAP(VUID-StandaloneSpirv-Input-07290); case 7320: return VUID_WRAP(VUID-StandaloneSpirv-ExecutionModel-07320); case 7330: return VUID_WRAP(VUID-StandaloneSpirv-MeshEXT-07330); case 7331: return VUID_WRAP(VUID-StandaloneSpirv-MeshEXT-07331); case 7650: return VUID_WRAP(VUID-StandaloneSpirv-Base-07650); case 7651: return VUID_WRAP(VUID-StandaloneSpirv-Base-07651); case 7652: return VUID_WRAP(VUID-StandaloneSpirv-Base-07652); case 7703: return VUID_WRAP(VUID-StandaloneSpirv-Component-07703); case 7951: return VUID_WRAP(VUID-StandaloneSpirv-SubgroupVoteKHR-07951); case 8721: return VUID_WRAP(VUID-StandaloneSpirv-OpEntryPoint-08721); case 8722: return VUID_WRAP(VUID-StandaloneSpirv-OpEntryPoint-08722); case 8973: return VUID_WRAP(VUID-StandaloneSpirv-Pointer-08973); case 9638: return VUID_WRAP(VUID-StandaloneSpirv-OpTypeImage-09638); case 9658: return VUID_WRAP(VUID-StandaloneSpirv-OpEntryPoint-09658); case 9659: return VUID_WRAP(VUID-StandaloneSpirv-OpEntryPoint-09659); case 10213: // This use to be a standalone, but maintenance8 will set allow_offset_texture_operand now return VUID_WRAP(VUID-RuntimeSpirv-Offset-10213); case 10583: return VUID_WRAP(VUID-StandaloneSpirv-Component-10583); default: return ""; // unknown id } // clang-format on } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/source/val/validation_state.h000066400000000000000000001213511475742701700243210ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_VAL_VALIDATION_STATE_H_ #define SOURCE_VAL_VALIDATION_STATE_H_ #include #include #include #include #include #include #include #include #include "source/assembly_grammar.h" #include "source/diagnostic.h" #include "source/disassemble.h" #include "source/enum_set.h" #include "source/latest_version_spirv_header.h" #include "source/name_mapper.h" #include "source/spirv_definition.h" #include "source/spirv_validator_options.h" #include "source/val/decoration.h" #include "source/val/function.h" #include "source/val/instruction.h" #include "spirv-tools/libspirv.h" namespace spvtools { namespace val { /// This enum represents the sections of a SPIRV module. See section 2.4 /// of the SPIRV spec for additional details of the order. The enumerant values /// are in the same order as the vector returned by GetModuleOrder enum ModuleLayoutSection { kLayoutCapabilities, /// < Section 2.4 #1 kLayoutExtensions, /// < Section 2.4 #2 kLayoutExtInstImport, /// < Section 2.4 #3 kLayoutMemoryModel, /// < Section 2.4 #4 kLayoutSamplerImageAddressMode, /// < Section 2.4 #5 kLayoutEntryPoint, /// < Section 2.4 #6 kLayoutExecutionMode, /// < Section 2.4 #7 kLayoutDebug1, /// < Section 2.4 #8 > 1 kLayoutDebug2, /// < Section 2.4 #8 > 2 kLayoutDebug3, /// < Section 2.4 #8 > 3 kLayoutAnnotations, /// < Section 2.4 #9 kLayoutTypes, /// < Section 2.4 #10 kLayoutFunctionDeclarations, /// < Section 2.4 #11 kLayoutFunctionDefinitions /// < Section 2.4 #12 }; /// This class manages the state of the SPIR-V validation as it is being parsed. class ValidationState_t { public: // Features that can optionally be turned on by a capability or environment. struct Feature { bool declare_int16_type = false; // Allow OpTypeInt with 16 bit width? bool declare_float16_type = false; // Allow OpTypeFloat with 16 bit width? bool free_fp_rounding_mode = false; // Allow the FPRoundingMode decoration // and its values to be used without // requiring any capability // Allow functionalities enabled by VariablePointers or // VariablePointersStorageBuffer capability. bool variable_pointers = false; // Permit group oerations Reduce, InclusiveScan, ExclusiveScan bool group_ops_reduce_and_scans = false; // Allow OpTypeInt with 8 bit width? bool declare_int8_type = false; // Target environment uses relaxed block layout. // This is true for Vulkan 1.1 or later. bool env_relaxed_block_layout = false; // Allow an OpTypeInt with 8 bit width to be used in more than just int // conversion opcodes bool use_int8_type = false; // SPIR-V 1.4 allows us to select between any two composite values // of the same type. bool select_between_composites = false; // SPIR-V 1.4 allows two memory access operands for OpCopyMemory and // OpCopyMemorySized. bool copy_memory_permits_two_memory_accesses = false; // SPIR-V 1.4 allows UConvert as a spec constant op in any environment. // The Kernel capability already enables it, separately from this flag. bool uconvert_spec_constant_op = false; // SPIR-V 1.4 allows Function and Private variables to be NonWritable bool nonwritable_var_in_function_or_private = false; // Whether LocalSizeId execution mode is allowed by the environment. bool env_allow_localsizeid = false; }; ValidationState_t(const spv_const_context context, const spv_const_validator_options opt, const uint32_t* words, const size_t num_words, const uint32_t max_warnings); /// Returns the context spv_const_context context() const { return context_; } /// Returns the command line options spv_const_validator_options options() const { return options_; } /// Sets the ID of the generator for this module. void setGenerator(uint32_t gen) { generator_ = gen; } /// Returns the ID of the generator for this module. uint32_t generator() const { return generator_; } /// Sets the SPIR-V version of this module. void setVersion(uint32_t ver) { version_ = ver; } /// Gets the SPIR-V version of this module. uint32_t version() const { return version_; } /// Forward declares the id in the module spv_result_t ForwardDeclareId(uint32_t id); /// Removes a forward declared ID if it has been defined spv_result_t RemoveIfForwardDeclared(uint32_t id); /// Registers an ID as a forward pointer spv_result_t RegisterForwardPointer(uint32_t id); /// Returns whether or not an ID is a forward pointer bool IsForwardPointer(uint32_t id) const; /// Assigns a name to an ID void AssignNameToId(uint32_t id, std::string name); /// Returns a string representation of the ID in the format [Name] where /// the is the numeric valid of the id and the Name is a name assigned by /// the OpName instruction std::string getIdName(uint32_t id) const; /// Accessor function for ID bound. uint32_t getIdBound() const; /// Mutator function for ID bound. void setIdBound(uint32_t bound); /// Returns the number of ID which have been forward referenced but not /// defined size_t unresolved_forward_id_count() const; /// Returns a vector of unresolved forward ids. std::vector UnresolvedForwardIds() const; /// Returns true if the id has been defined bool IsDefinedId(uint32_t id) const; /// Increments the total number of instructions in the file. void increment_total_instructions() { total_instructions_++; } /// Increments the total number of functions in the file. void increment_total_functions() { total_functions_++; } /// Allocates internal storage. Note, calling this will invalidate any /// pointers to |ordered_instructions_| or |module_functions_| and, hence, /// should only be called at the beginning of validation. void preallocateStorage(); /// Returns the current layout section which is being processed ModuleLayoutSection current_layout_section() const; /// Increments the module_layout_order_section_ void ProgressToNextLayoutSectionOrder(); /// Determines if the op instruction is in a previous layout section bool IsOpcodeInPreviousLayoutSection(spv::Op op); /// Determines if the op instruction is part of the current section bool IsOpcodeInCurrentLayoutSection(spv::Op op); DiagnosticStream diag(spv_result_t error_code, const Instruction* inst); /// Returns the function states std::vector& functions(); /// Returns the function states Function& current_function(); const Function& current_function() const; /// Returns function state with the given id, or nullptr if no such function. const Function* function(uint32_t id) const; Function* function(uint32_t id); /// Returns true if the called after a function instruction but before the /// function end instruction bool in_function_body() const; /// Returns true if called after a label instruction but before a branch /// instruction bool in_block() const; struct EntryPointDescription { std::string name; std::vector interfaces; }; /// Registers |id| as an entry point with |execution_model| and |interfaces|. void RegisterEntryPoint(const uint32_t id, spv::ExecutionModel execution_model, EntryPointDescription&& desc) { entry_points_.push_back(id); entry_point_to_execution_models_[id].insert(execution_model); entry_point_descriptions_[id].emplace_back(desc); } /// Returns a list of entry point function ids const std::vector& entry_points() const { return entry_points_; } /// Returns the set of entry points that root call graphs that contain /// recursion. const std::set& recursive_entry_points() const { return recursive_entry_points_; } /// Registers execution mode for the given entry point. void RegisterExecutionModeForEntryPoint(uint32_t entry_point, spv::ExecutionMode execution_mode) { entry_point_to_execution_modes_[entry_point].insert(execution_mode); } /// Registers that the entry point declares its local size void RegisterEntryPointLocalSize(uint32_t entry_point, const Instruction* inst) { entry_point_to_local_size_or_id_[entry_point] = inst; } /// Registers that the entry point maximum number of primitives /// mesh shader will ever emit void RegisterEntryPointOutputPrimitivesEXT(uint32_t entry_point, const Instruction* inst) { entry_point_to_output_primitives_[entry_point] = inst; } /// Returns the maximum number of primitives mesh shader can emit uint32_t GetOutputPrimitivesEXT(uint32_t entry_point) { auto entry = entry_point_to_output_primitives_.find(entry_point); if (entry != entry_point_to_output_primitives_.end()) { auto inst = entry->second; return inst->GetOperandAs(2); } return 0; } /// Returns whether the entry point declares its local size bool EntryPointHasLocalSizeOrId(uint32_t entry_point) const { return entry_point_to_local_size_or_id_.find(entry_point) != entry_point_to_local_size_or_id_.end(); } /// Returns the id of the local size const Instruction* EntryPointLocalSizeOrId(uint32_t entry_point) const { return entry_point_to_local_size_or_id_.find(entry_point)->second; } /// Returns the interface descriptions of a given entry point. const std::vector& entry_point_descriptions( uint32_t entry_point) { return entry_point_descriptions_.at(entry_point); } /// Returns Execution Models for the given Entry Point. /// Returns nullptr if none found (would trigger assertion). const std::set* GetExecutionModels( uint32_t entry_point) const { const auto it = entry_point_to_execution_models_.find(entry_point); if (it == entry_point_to_execution_models_.end()) { assert(0); return nullptr; } return &it->second; } /// Returns Execution Modes for the given Entry Point. /// Returns nullptr if none found. const std::set* GetExecutionModes( uint32_t entry_point) const { const auto it = entry_point_to_execution_modes_.find(entry_point); if (it == entry_point_to_execution_modes_.end()) { return nullptr; } return &it->second; } /// Traverses call tree and computes function_to_entry_points_. /// Note: called after fully parsing the binary. void ComputeFunctionToEntryPointMapping(); /// Traverse call tree and computes recursive_entry_points_. /// Note: called after fully parsing the binary and calling /// ComputeFunctionToEntryPointMapping. void ComputeRecursiveEntryPoints(); /// Returns all the entry points that can call |func|. const std::vector& FunctionEntryPoints(uint32_t func) const; /// Returns all the entry points that statically use |id|. /// /// Note: requires ComputeFunctionToEntryPointMapping to have been called. std::set EntryPointReferences(uint32_t id) const; /// Inserts an to the set of functions that are target of OpFunctionCall. void AddFunctionCallTarget(const uint32_t id) { function_call_targets_.insert(id); current_function().AddFunctionCallTarget(id); } /// Returns whether or not a function is the target of OpFunctionCall. bool IsFunctionCallTarget(const uint32_t id) { return (function_call_targets_.find(id) != function_call_targets_.end()); } bool IsFunctionCallDefined(const uint32_t id) { return (id_to_function_.find(id) != id_to_function_.end()); } /// Registers the capability and its dependent capabilities void RegisterCapability(spv::Capability cap); /// Registers the extension. void RegisterExtension(Extension ext); /// Registers the function in the module. Subsequent instructions will be /// called against this function spv_result_t RegisterFunction(uint32_t id, uint32_t ret_type_id, spv::FunctionControlMask function_control, uint32_t function_type_id); /// Register a function end instruction spv_result_t RegisterFunctionEnd(); /// Returns true if the capability is enabled in the module. bool HasCapability(spv::Capability cap) const { return module_capabilities_.contains(cap); } /// Returns a reference to the set of capabilities in the module. /// This is provided for debuggability. const CapabilitySet& module_capabilities() const { return module_capabilities_; } /// Returns true if the extension is enabled in the module. bool HasExtension(Extension ext) const { return module_extensions_.contains(ext); } /// Returns true if any of the capabilities is enabled, or if |capabilities| /// is an empty set. bool HasAnyOfCapabilities(const CapabilitySet& capabilities) const; /// Returns true if any of the extensions is enabled, or if |extensions| /// is an empty set. bool HasAnyOfExtensions(const ExtensionSet& extensions) const; /// Sets the addressing model of this module (logical/physical). void set_addressing_model(spv::AddressingModel am); /// Returns true if the OpMemoryModel was found. bool has_memory_model_specified() const { return addressing_model_ != spv::AddressingModel::Max && memory_model_ != spv::MemoryModel::Max; } /// Returns the addressing model of this module, or Logical if uninitialized. spv::AddressingModel addressing_model() const; /// Returns the addressing model of this module, or Logical if uninitialized. uint32_t pointer_size_and_alignment() const { return pointer_size_and_alignment_; } /// Sets the memory model of this module. void set_memory_model(spv::MemoryModel mm); /// Returns the memory model of this module, or Simple if uninitialized. spv::MemoryModel memory_model() const; /// Sets the bit width for sampler/image type variables. If not set, they are /// considered opaque void set_samplerimage_variable_address_mode(uint32_t bit_width); /// Get the addressing mode currently set. If 0, it means addressing mode is /// invalid Sampler/Image type variables must be considered opaque This mode /// is only valid after the instruction has been read uint32_t samplerimage_variable_address_mode() const; /// Returns true if the OpSamplerImageAddressingModeNV was found. bool has_samplerimage_variable_address_mode_specified() const { return sampler_image_addressing_mode_ != 0; } const AssemblyGrammar& grammar() const { return grammar_; } /// Inserts the instruction into the list of ordered instructions in the file. Instruction* AddOrderedInstruction(const spv_parsed_instruction_t* inst); /// Registers the instruction. This will add the instruction to the list of /// definitions and register sampled image consumers. void RegisterInstruction(Instruction* inst); /// Registers the debug instruction information. void RegisterDebugInstruction(const Instruction* inst); /// Registers the decoration for the given void RegisterDecorationForId(uint32_t id, const Decoration& dec) { auto& dec_list = id_decorations_[id]; dec_list.insert(dec); } /// Registers the list of decorations for the given template void RegisterDecorationsForId(uint32_t id, InputIt begin, InputIt end) { std::set& cur_decs = id_decorations_[id]; cur_decs.insert(begin, end); } /// Registers the list of decorations for the given member of the given /// structure. template void RegisterDecorationsForStructMember(uint32_t struct_id, uint32_t member_index, InputIt begin, InputIt end) { std::set& cur_decs = id_decorations_[struct_id]; for (InputIt iter = begin; iter != end; ++iter) { Decoration dec = *iter; dec.set_struct_member_index(member_index); cur_decs.insert(dec); } } /// Returns all the decorations for the given . If no decorations exist /// for the , it registers an empty set for it in the map and /// returns the empty set. std::set& id_decorations(uint32_t id) { return id_decorations_[id]; } /// Returns the range of decorations for the given field of the given . struct FieldDecorationsIter { std::set::const_iterator begin; std::set::const_iterator end; }; FieldDecorationsIter id_member_decorations(uint32_t id, uint32_t member_index) { const auto& decorations = id_decorations_[id]; // The decorations are sorted by member_index, so this look up will give the // exact range of decorations for this member index. Decoration min_decoration((spv::Decoration)0, {}, member_index); Decoration max_decoration(spv::Decoration::Max, {}, member_index); FieldDecorationsIter result; result.begin = decorations.lower_bound(min_decoration); result.end = decorations.upper_bound(max_decoration); return result; } // Returns const pointer to the internal decoration container. const std::map>& id_decorations() const { return id_decorations_; } /// Returns true if the given id has the given decoration , /// otherwise returns false. bool HasDecoration(uint32_t id, spv::Decoration dec) { const auto& decorations = id_decorations_.find(id); if (decorations == id_decorations_.end()) return false; return std::any_of( decorations->second.begin(), decorations->second.end(), [dec](const Decoration& d) { return dec == d.dec_type(); }); } /// Finds id's def, if it exists. If found, returns the definition otherwise /// nullptr const Instruction* FindDef(uint32_t id) const; /// Finds id's def, if it exists. If found, returns the definition otherwise /// nullptr Instruction* FindDef(uint32_t id); /// Returns the instructions in the order they appear in the binary const std::vector& ordered_instructions() const { return ordered_instructions_; } /// Returns a map of instructions mapped by their result id const std::unordered_map& all_definitions() const { return all_definitions_; } /// Returns a vector containing the instructions that consume the given /// SampledImage id. std::vector getSampledImageConsumers(uint32_t id) const; /// Records cons_id as a consumer of sampled_image_id. void RegisterSampledImageConsumer(uint32_t sampled_image_id, Instruction* consumer); // Record a cons_id as a consumer of texture_id // if texture 'texture_id' has a QCOM image processing decoration // and consumer is a load or a sampled image instruction void RegisterQCOMImageProcessingTextureConsumer(uint32_t texture_id, const Instruction* consumer0, const Instruction* consumer1); // Record a function's storage class consumer instruction void RegisterStorageClassConsumer(spv::StorageClass storage_class, Instruction* consumer); /// Returns the set of Global Variables. std::unordered_set& global_vars() { return global_vars_; } /// Returns the set of Local Variables. std::unordered_set& local_vars() { return local_vars_; } /// Returns the number of Global Variables. size_t num_global_vars() { return global_vars_.size(); } /// Returns the number of Local Variables. size_t num_local_vars() { return local_vars_.size(); } /// Inserts a new to the set of Global Variables. void registerGlobalVariable(const uint32_t id) { global_vars_.insert(id); } /// Inserts a new to the set of Local Variables. void registerLocalVariable(const uint32_t id) { local_vars_.insert(id); } // Returns true if using relaxed block layout, equivalent to // VK_KHR_relaxed_block_layout. bool IsRelaxedBlockLayout() const { return features_.env_relaxed_block_layout || options()->relax_block_layout; } // Returns true if allowing localsizeid, either because the environment always // allows it, or because it is enabled from the command-line. bool IsLocalSizeIdAllowed() const { return features_.env_allow_localsizeid || options()->allow_localsizeid; } /// Sets the struct nesting depth for a given struct ID void set_struct_nesting_depth(uint32_t id, uint32_t depth) { struct_nesting_depth_[id] = depth; } /// Returns the nesting depth of a given structure ID uint32_t struct_nesting_depth(uint32_t id) { return struct_nesting_depth_[id]; } /// Records the has a nested block/bufferblock decorated struct for a given /// struct ID void SetHasNestedBlockOrBufferBlockStruct(uint32_t id, bool has) { struct_has_nested_blockorbufferblock_struct_[id] = has; } /// For a given struct ID returns true if it has a nested block/bufferblock /// decorated struct bool GetHasNestedBlockOrBufferBlockStruct(uint32_t id) { return struct_has_nested_blockorbufferblock_struct_[id]; } /// Records that the structure type has a member decorated with a built-in. void RegisterStructTypeWithBuiltInMember(uint32_t id) { builtin_structs_.insert(id); } /// Returns true if the struct type with the given Id has a BuiltIn member. bool IsStructTypeWithBuiltInMember(uint32_t id) const { return (builtin_structs_.find(id) != builtin_structs_.end()); } // Returns the state of optional features. const Feature& features() const { return features_; } /// Adds the instruction data to unique_type_declarations_. /// Returns false if an identical type declaration already exists. bool RegisterUniqueTypeDeclaration(const Instruction* inst); // Returns type_id of the scalar component of |id|. // |id| can be either // - scalar, vector or matrix type // - object of either scalar, vector or matrix type uint32_t GetComponentType(uint32_t id) const; // Returns // - 1 for scalar types or objects // - vector size for vector types or objects // - num columns for matrix types or objects // Should not be called with any other arguments (will return zero and invoke // assertion). uint32_t GetDimension(uint32_t id) const; // Returns bit width of scalar or component. // |id| can be // - scalar, vector or matrix type // - object of either scalar, vector or matrix type // Will invoke assertion and return 0 if |id| is none of the above. uint32_t GetBitWidth(uint32_t id) const; // Provides detailed information on matrix type. // Returns false iff |id| is not matrix type. bool GetMatrixTypeInfo(uint32_t id, uint32_t* num_rows, uint32_t* num_cols, uint32_t* column_type, uint32_t* component_type) const; // Collects struct member types into |member_types|. // Returns false iff not struct type or has no members. // Deletes prior contents of |member_types|. bool GetStructMemberTypes(uint32_t struct_type_id, std::vector* member_types) const; // Returns true iff |id| is a type corresponding to the name of the function. // Only works for types not for objects. bool IsVoidType(uint32_t id) const; bool IsFloatScalarType(uint32_t id) const; bool IsFloatArrayType(uint32_t id) const; bool IsFloatVectorType(uint32_t id) const; bool IsFloat16Vector2Or4Type(uint32_t id) const; bool IsFloatScalarOrVectorType(uint32_t id) const; bool IsFloatMatrixType(uint32_t id) const; bool IsIntScalarType(uint32_t id) const; bool IsIntArrayType(uint32_t id) const; bool IsIntVectorType(uint32_t id) const; bool IsIntScalarOrVectorType(uint32_t id) const; bool IsUnsignedIntScalarType(uint32_t id) const; bool IsUnsignedIntVectorType(uint32_t id) const; bool IsUnsignedIntScalarOrVectorType(uint32_t id) const; bool IsSignedIntScalarType(uint32_t id) const; bool IsSignedIntVectorType(uint32_t id) const; bool IsBoolScalarType(uint32_t id) const; bool IsBoolVectorType(uint32_t id) const; bool IsBoolScalarOrVectorType(uint32_t id) const; bool IsPointerType(uint32_t id) const; bool IsAccelerationStructureType(uint32_t id) const; bool IsCooperativeMatrixType(uint32_t id) const; bool IsCooperativeMatrixNVType(uint32_t id) const; bool IsCooperativeMatrixKHRType(uint32_t id) const; bool IsCooperativeMatrixAType(uint32_t id) const; bool IsCooperativeMatrixBType(uint32_t id) const; bool IsCooperativeMatrixAccType(uint32_t id) const; bool IsFloatCooperativeMatrixType(uint32_t id) const; bool IsIntCooperativeMatrixType(uint32_t id) const; bool IsUnsignedIntCooperativeMatrixType(uint32_t id) const; bool IsUnsigned64BitHandle(uint32_t id) const; bool IsCooperativeVectorNVType(uint32_t id) const; bool IsFloatCooperativeVectorNVType(uint32_t id) const; bool IsIntCooperativeVectorNVType(uint32_t id) const; bool IsUnsignedIntCooperativeVectorNVType(uint32_t id) const; // Returns true if |id| is a type id that contains |type| (or integer or // floating point type) of |width| bits. bool ContainsSizedIntOrFloatType(uint32_t id, spv::Op type, uint32_t width) const; // Returns true if |id| is a type id that contains a 8- or 16-bit int or // 16-bit float that is not generally enabled for use. bool ContainsLimitedUseIntOrFloatType(uint32_t id) const; // Returns true if |id| is a type that contains a runtime-sized array. // Does not consider a pointers as contains the array. bool ContainsRuntimeArray(uint32_t id) const; // Generic type traversal. // Only traverse pointers and functions if |traverse_all_types| is true. // Recursively tests |f| against the type hierarchy headed by |id|. bool ContainsType(uint32_t id, const std::function& f, bool traverse_all_types = true) const; // Returns true if |id| is type id that contains an untyped pointer. bool ContainsUntypedPointer(uint32_t id) const; // Returns type_id if id has type or zero otherwise. uint32_t GetTypeId(uint32_t id) const; // Returns opcode of the instruction which issued the id or OpNop if the // instruction is not registered. spv::Op GetIdOpcode(uint32_t id) const; // Returns type_id for given id operand if it has a type or zero otherwise. // |operand_index| is expected to be pointing towards an operand which is an // id. uint32_t GetOperandTypeId(const Instruction* inst, size_t operand_index) const; // Provides information on pointer type. Returns false iff not pointer type. bool GetPointerTypeInfo(uint32_t id, uint32_t* data_type, spv::StorageClass* storage_class) const; // Is the ID the type of a pointer to a uniform block: Block-decorated struct // in uniform storage class? The result is only valid after internal method // CheckDecorationsOfBuffers has been called. bool IsPointerToUniformBlock(uint32_t type_id) const { return pointer_to_uniform_block_.find(type_id) != pointer_to_uniform_block_.cend(); } // Save the ID of a pointer to uniform block. void RegisterPointerToUniformBlock(uint32_t type_id) { pointer_to_uniform_block_.insert(type_id); } // Is the ID the type of a struct used as a uniform block? // The result is only valid after internal method CheckDecorationsOfBuffers // has been called. bool IsStructForUniformBlock(uint32_t type_id) const { return struct_for_uniform_block_.find(type_id) != struct_for_uniform_block_.cend(); } // Save the ID of a struct of a uniform block. void RegisterStructForUniformBlock(uint32_t type_id) { struct_for_uniform_block_.insert(type_id); } // Is the ID the type of a pointer to a storage buffer: BufferBlock-decorated // struct in uniform storage class, or Block-decorated struct in StorageBuffer // storage class? The result is only valid after internal method // CheckDecorationsOfBuffers has been called. bool IsPointerToStorageBuffer(uint32_t type_id) const { return pointer_to_storage_buffer_.find(type_id) != pointer_to_storage_buffer_.cend(); } // Save the ID of a pointer to a storage buffer. void RegisterPointerToStorageBuffer(uint32_t type_id) { pointer_to_storage_buffer_.insert(type_id); } // Is the ID the type of a struct for storage buffer? // The result is only valid after internal method CheckDecorationsOfBuffers // has been called. bool IsStructForStorageBuffer(uint32_t type_id) const { return struct_for_storage_buffer_.find(type_id) != struct_for_storage_buffer_.cend(); } // Save the ID of a struct of a storage buffer. void RegisterStructForStorageBuffer(uint32_t type_id) { struct_for_storage_buffer_.insert(type_id); } // Is the ID the type of a pointer to a storage image? That is, the pointee // type is an image type which is known to not use a sampler. bool IsPointerToStorageImage(uint32_t type_id) const { return pointer_to_storage_image_.find(type_id) != pointer_to_storage_image_.cend(); } // Save the ID of a pointer to a storage image. void RegisterPointerToStorageImage(uint32_t type_id) { pointer_to_storage_image_.insert(type_id); } // Tries to evaluate a any scalar integer OpConstant as uint64. // OpConstantNull is defined as zero for scalar int (will return true) // OpSpecConstant* return false since their values cannot be relied upon // during validation. bool EvalConstantValUint64(uint32_t id, uint64_t* val) const; // Same as EvalConstantValUint64 but returns a signed int bool EvalConstantValInt64(uint32_t id, int64_t* val) const; // Tries to evaluate a 32-bit signed or unsigned scalar integer constant. // Returns tuple . // OpSpecConstant* return |is_const_int32| as false since their values cannot // be relied upon during validation. std::tuple EvalInt32IfConst(uint32_t id) const; // Returns the disassembly string for the given instruction. std::string Disassemble(const Instruction& inst) const; // Returns the disassembly string for the given instruction. std::string Disassemble(const uint32_t* words, uint16_t num_words) const; // Returns the string name for |decoration|. std::string SpvDecorationString(uint32_t decoration) { spv_operand_desc desc = nullptr; if (grammar_.lookupOperand(SPV_OPERAND_TYPE_DECORATION, decoration, &desc) != SPV_SUCCESS) { return std::string("Unknown"); } return std::string(desc->name); } std::string SpvDecorationString(spv::Decoration decoration) { return SpvDecorationString(uint32_t(decoration)); } // Returns whether type result_type_id and type m2 are cooperative matrices // with the same "shape" (matching scope, rows, cols). If any are // specialization constants, we assume they can match because we can't prove // they don't. spv_result_t CooperativeMatrixShapesMatch(const Instruction* inst, uint32_t result_type_id, uint32_t m2, bool is_conversion, bool swap_row_col = false); spv_result_t CooperativeVectorDimensionsMatch(const Instruction* inst, uint32_t v1, uint32_t v2); // Returns true if |lhs| and |rhs| logically match and, if the decorations of // |rhs| are a subset of |lhs|. // // 1. Must both be either OpTypeArray or OpTypeStruct // 2. If OpTypeArray, then // * Length must be the same // * Element type must match or logically match // 3. If OpTypeStruct, then // * Both have same number of elements // * Element N for both structs must match or logically match // // If |check_decorations| is false, then the decorations are not checked. bool LogicallyMatch(const Instruction* lhs, const Instruction* rhs, bool check_decorations); // Traces |inst| to find a single base pointer. Returns the base pointer. // Will trace through the following instructions: // * OpAccessChain // * OpInBoundsAccessChain // * OpPtrAccessChain // * OpInBoundsPtrAccessChain // * OpCopyObject const Instruction* TracePointer(const Instruction* inst) const; // Validates the storage class for the target environment. bool IsValidStorageClass(spv::StorageClass storage_class) const; // Takes a Vulkan Valid Usage ID (VUID) as |id| and optional |reference| and // will return a non-empty string only if ID is known and targeting Vulkan. // VUIDs are found in the Vulkan-Docs repo in the form "[[VUID-ref-ref-id]]" // where "id" is always an 5 char long number (with zeros padding) and matches // to |id|. |reference| is used if there is a "common validity" and the VUID // shares the same |id| value. // // More details about Vulkan validation can be found in Vulkan Guide: // https://github.com/KhronosGroup/Vulkan-Guide/blob/master/chapters/validation_overview.md std::string VkErrorID(uint32_t id, const char* reference = nullptr) const; // Testing method to allow setting the current layout section. void SetCurrentLayoutSectionForTesting(ModuleLayoutSection section) { current_layout_section_ = section; } // Check if instruction 'id' is a consumer of a texture decorated // with a QCOM image processing decoration bool IsQCOMImageProcessingTextureConsumer(uint32_t id) { return qcom_image_processing_consumers_.find(id) != qcom_image_processing_consumers_.end(); } private: ValidationState_t(const ValidationState_t&); const spv_const_context context_; /// Stores the Validator command line options. Must be a valid options object. const spv_const_validator_options options_; /// The SPIR-V binary module we're validating. const uint32_t* words_; const size_t num_words_; /// The generator of the SPIR-V. uint32_t generator_ = 0; /// The version of the SPIR-V. uint32_t version_ = 0; /// The total number of instructions in the binary. size_t total_instructions_ = 0; /// The total number of functions in the binary. size_t total_functions_ = 0; /// IDs which have been forward declared but have not been defined std::unordered_set unresolved_forward_ids_; /// IDs that have been declared as forward pointers. std::unordered_set forward_pointer_ids_; /// Stores a vector of instructions that use the result of a given /// OpSampledImage instruction. std::unordered_map> sampled_image_consumers_; /// Stores load instructions that load textures used // in QCOM image processing functions std::unordered_set qcom_image_processing_consumers_; /// A map of operand IDs and their names defined by the OpName instruction std::unordered_map operand_names_; /// The section of the code being processed ModuleLayoutSection current_layout_section_; /// A list of functions in the module. /// Pointers to objects in this container are guaranteed to be stable and /// valid until the end of lifetime of the validation state. std::vector module_functions_; /// Capabilities declared in the module CapabilitySet module_capabilities_; /// Extensions declared in the module ExtensionSet module_extensions_; /// List of all instructions in the order they appear in the binary std::vector ordered_instructions_; /// Instructions that can be referenced by Ids std::unordered_map all_definitions_; /// IDs that are entry points, ie, arguments to OpEntryPoint. std::vector entry_points_; /// Maps an entry point id to its descriptions. std::unordered_map> entry_point_descriptions_; /// IDs that are entry points, ie, arguments to OpEntryPoint, and root a call /// graph that recurses. std::set recursive_entry_points_; /// Functions IDs that are target of OpFunctionCall. std::unordered_set function_call_targets_; /// ID Bound from the Header uint32_t id_bound_; /// Set of Global Variable IDs (Storage Class other than 'Function') std::unordered_set global_vars_; /// Set of Local Variable IDs ('Function' Storage Class) std::unordered_set local_vars_; /// Set of struct types that have members with a BuiltIn decoration. std::unordered_set builtin_structs_; /// Structure Nesting Depth std::unordered_map struct_nesting_depth_; /// Structure has nested blockorbufferblock struct std::unordered_map struct_has_nested_blockorbufferblock_struct_; /// Stores the list of decorations for a given std::map> id_decorations_; /// Stores type declarations which need to be unique (i.e. non-aggregates), /// in the form [opcode, operand words], result_id is not stored. /// Using ordered set to avoid the need for a vector hash function. /// The size of this container is expected not to exceed double-digits. std::set> unique_type_declarations_; AssemblyGrammar grammar_; spv::AddressingModel addressing_model_; spv::MemoryModel memory_model_; // pointer size derived from addressing model. Assumes all storage classes // have the same pointer size (for physical pointer types). uint32_t pointer_size_and_alignment_; /// bit width of sampler/image type variables. Valid values are 32 and 64 uint32_t sampler_image_addressing_mode_; /// NOTE: See correspoding getter functions bool in_function_; /// The state of optional features. These are determined by capabilities /// declared by the module and the environment. Feature features_; /// Maps function ids to function stat objects. std::unordered_map id_to_function_; /// Mapping entry point -> execution models. It is presumed that the same /// function could theoretically be used as 'main' by multiple OpEntryPoint /// instructions. std::unordered_map> entry_point_to_execution_models_; /// Mapping entry point -> execution modes. std::unordered_map> entry_point_to_execution_modes_; // Mapping entry point -> local size execution mode instruction std::unordered_map entry_point_to_local_size_or_id_; // Mapping entry point -> OutputPrimitivesEXT execution mode instruction std::unordered_map entry_point_to_output_primitives_; /// Mapping function -> array of entry points inside this /// module which can (indirectly) call the function. std::unordered_map> function_to_entry_points_; const std::vector empty_ids_; // The IDs of types of pointers to Block-decorated structs in Uniform storage // class. This is populated at the start of ValidateDecorations. std::unordered_set pointer_to_uniform_block_; // The IDs of struct types for uniform blocks. // This is populated at the start of ValidateDecorations. std::unordered_set struct_for_uniform_block_; // The IDs of types of pointers to BufferBlock-decorated structs in Uniform // storage class, or Block-decorated structs in StorageBuffer storage class. // This is populated at the start of ValidateDecorations. std::unordered_set pointer_to_storage_buffer_; // The IDs of struct types for storage buffers. // This is populated at the start of ValidateDecorations. std::unordered_set struct_for_storage_buffer_; // The IDs of types of pointers to storage images. This is populated in the // TypePass. std::unordered_set pointer_to_storage_image_; /// Maps ids to friendly names. std::unique_ptr friendly_mapper_; spvtools::NameMapper name_mapper_; /// Variables used to reduce the number of diagnostic messages. uint32_t num_of_warnings_; uint32_t max_num_of_warnings_; }; } // namespace val } // namespace spvtools #endif // SOURCE_VAL_VALIDATION_STATE_H_ KhronosGroup-SPIRV-Tools-f289d04/source/wasm/000077500000000000000000000000001475742701700210005ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/source/wasm/README.md000066400000000000000000000017641475742701700222670ustar00rootroot00000000000000# SPIRV-Tools Wasm (WebAssembly) build of https://github.com/KhronosGroup/SPIRV-Tools ## Usage ```js const spirvTools = require("spirv-tools"); const test = async () => { // Load the library const spv = await spirvTools(); // assemble const source = ` OpCapability Linkage OpCapability Shader OpMemoryModel Logical GLSL450 OpSource GLSL 450 OpDecorate %spec SpecId 1 %int = OpTypeInt 32 1 %spec = OpSpecConstant %int 0 %const = OpConstant %int 42`; const asResult = spv.as( source, spv.SPV_ENV_UNIVERSAL_1_3, spv.SPV_TEXT_TO_BINARY_OPTION_NONE ); console.log(`as returned ${asResult.byteLength} bytes`); // re-disassemble const disResult = spv.dis( asResult, spv.SPV_ENV_UNIVERSAL_1_3, spv.SPV_BINARY_TO_TEXT_OPTION_INDENT | spv.SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES | spv.SPV_BINARY_TO_TEXT_OPTION_COLOR ); console.log("dis:\n", disResult); }; test(); ``` KhronosGroup-SPIRV-Tools-f289d04/source/wasm/build.sh000077500000000000000000000045341475742701700224440ustar00rootroot00000000000000#!/bin/bash # Copyright (c) 2020 The Khronos Group Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. set -e # This is required to run any git command in the docker since owner will # have changed between the clone environment, and the docker container. # Marking the root of the repo as safe for ownership changes. git config --global --add safe.directory /app NUM_CORES=$(nproc) echo "Detected $NUM_CORES cores for building" DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )" VERSION=$(sed -n '0,/^v20/ s/^v\(20[0-9.]*\).*/\1/p' $DIR/../../CHANGES).${GITHUB_RUN_NUMBER:-0} echo "Version: $VERSION" build() { type=$1 shift args=$@ mkdir -p build/$type pushd build/$type echo $args emcmake cmake \ -DCMAKE_BUILD_TYPE=Release \ $args \ ../.. emmake make -j $(( $NUM_CORES )) SPIRV-Tools-static echo Building js interface emcc \ --bind \ -I../../include \ -std=c++17 \ ../../source/wasm/spirv-tools.cpp \ source/libSPIRV-Tools.a \ -o spirv-tools.js \ -s MODULARIZE \ -Oz popd mkdir -p out/$type # copy other js files cp source/wasm/spirv-tools.d.ts out/$type/ sed -e 's/\("version"\s*:\s*\).*/\1"'$VERSION'",/' source/wasm/package.json > out/$type/package.json cp source/wasm/README.md out/$type/ cp LICENSE out/$type/ cp build/$type/spirv-tools.js out/$type/ gzip -9 -k -f out/$type/spirv-tools.js if [ -e build/$type/spirv-tools.wasm ] ; then cp build/$type/spirv-tools.wasm out/$type/ gzip -9 -k -f out/$type/spirv-tools.wasm fi } if [ ! -d external/spirv-headers ] ; then echo "Fetching deps" utils/git-sync-deps fi echo Building ${BASH_REMATCH[1]} build web\ -DSPIRV_COLOR_TERMINAL=OFF\ -DSPIRV_SKIP_TESTS=ON\ -DSPIRV_SKIP_EXECUTABLES=ON wc -c out/*/* KhronosGroup-SPIRV-Tools-f289d04/source/wasm/docker-compose.yml000066400000000000000000000003331475742701700244340ustar00rootroot00000000000000version: "3" services: build: image: emscripten/emsdk:3.1.28 environment: GITHUB_RUN_NUMBER: ${GITHUB_RUN_NUMBER:-} working_dir: /app command: ./source/wasm/build.sh volumes: - ./:/app KhronosGroup-SPIRV-Tools-f289d04/source/wasm/package.json000066400000000000000000000005401475742701700232650ustar00rootroot00000000000000{ "name": "spirv-tools", "version": "VERSION", "license": "Apache-2.0", "main": "spirv-tools", "types": "spirv-tools.d.ts", "files": [ "*.wasm", "*.js", "*.d.ts" ], "repository": { "type": "git", "url": "https://github.com/KhronosGroup/SPIRV-Tools" }, "homepage": "https://github.com/KhronosGroup/SPIRV-Tools" } KhronosGroup-SPIRV-Tools-f289d04/source/wasm/spirv-tools.cpp000066400000000000000000000116351475742701700240130ustar00rootroot00000000000000// Copyright (c) 2020 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "spirv-tools/libspirv.hpp" #include #include #include #include #include using namespace emscripten; void print_msg_to_stderr (spv_message_level_t, const char*, const spv_position_t&, const char* m) { std::cerr << "error: " << m << std::endl; }; std::string dis(std::string const& buffer, uint32_t env, uint32_t options) { spvtools::SpirvTools core(static_cast(env)); core.SetMessageConsumer(print_msg_to_stderr); std::vector spirv; const uint32_t* ptr = reinterpret_cast(buffer.data()); spirv.assign(ptr, ptr + buffer.size() / 4); std::string disassembly; if (!core.Disassemble(spirv, &disassembly, options)) return "Error"; return disassembly; } emscripten::val as(std::string const& source, uint32_t env, uint32_t options) { spvtools::SpirvTools core(static_cast(env)); core.SetMessageConsumer(print_msg_to_stderr); std::vector spirv; if (!core.Assemble(source, &spirv, options)) spirv.clear(); const uint8_t* ptr = reinterpret_cast(spirv.data()); return emscripten::val(emscripten::typed_memory_view(spirv.size() * 4, ptr)); } EMSCRIPTEN_BINDINGS(my_module) { function("dis", &dis); function("as", &as); constant("SPV_ENV_UNIVERSAL_1_0", static_cast(SPV_ENV_UNIVERSAL_1_0)); constant("SPV_ENV_VULKAN_1_0", static_cast(SPV_ENV_VULKAN_1_0)); constant("SPV_ENV_UNIVERSAL_1_1", static_cast(SPV_ENV_UNIVERSAL_1_1)); constant("SPV_ENV_OPENCL_2_1", static_cast(SPV_ENV_OPENCL_2_1)); constant("SPV_ENV_OPENCL_2_2", static_cast(SPV_ENV_OPENCL_2_2)); constant("SPV_ENV_OPENGL_4_0", static_cast(SPV_ENV_OPENGL_4_0)); constant("SPV_ENV_OPENGL_4_1", static_cast(SPV_ENV_OPENGL_4_1)); constant("SPV_ENV_OPENGL_4_2", static_cast(SPV_ENV_OPENGL_4_2)); constant("SPV_ENV_OPENGL_4_3", static_cast(SPV_ENV_OPENGL_4_3)); constant("SPV_ENV_OPENGL_4_5", static_cast(SPV_ENV_OPENGL_4_5)); constant("SPV_ENV_UNIVERSAL_1_2", static_cast(SPV_ENV_UNIVERSAL_1_2)); constant("SPV_ENV_OPENCL_1_2", static_cast(SPV_ENV_OPENCL_1_2)); constant("SPV_ENV_OPENCL_EMBEDDED_1_2", static_cast(SPV_ENV_OPENCL_EMBEDDED_1_2)); constant("SPV_ENV_OPENCL_2_0", static_cast(SPV_ENV_OPENCL_2_0)); constant("SPV_ENV_OPENCL_EMBEDDED_2_0", static_cast(SPV_ENV_OPENCL_EMBEDDED_2_0)); constant("SPV_ENV_OPENCL_EMBEDDED_2_1", static_cast(SPV_ENV_OPENCL_EMBEDDED_2_1)); constant("SPV_ENV_OPENCL_EMBEDDED_2_2", static_cast(SPV_ENV_OPENCL_EMBEDDED_2_2)); constant("SPV_ENV_UNIVERSAL_1_3", static_cast(SPV_ENV_UNIVERSAL_1_3)); constant("SPV_ENV_VULKAN_1_1", static_cast(SPV_ENV_VULKAN_1_1)); constant("SPV_ENV_WEBGPU_0", static_cast(SPV_ENV_WEBGPU_0)); constant("SPV_ENV_UNIVERSAL_1_4", static_cast(SPV_ENV_UNIVERSAL_1_4)); constant("SPV_ENV_VULKAN_1_1_SPIRV_1_4", static_cast(SPV_ENV_VULKAN_1_1_SPIRV_1_4)); constant("SPV_ENV_UNIVERSAL_1_5", static_cast(SPV_ENV_UNIVERSAL_1_5)); constant("SPV_ENV_VULKAN_1_2", static_cast(SPV_ENV_VULKAN_1_2)); constant("SPV_ENV_UNIVERSAL_1_6", static_cast(SPV_ENV_UNIVERSAL_1_6)); constant("SPV_BINARY_TO_TEXT_OPTION_NONE", static_cast(SPV_BINARY_TO_TEXT_OPTION_NONE)); constant("SPV_BINARY_TO_TEXT_OPTION_PRINT", static_cast(SPV_BINARY_TO_TEXT_OPTION_PRINT)); constant("SPV_BINARY_TO_TEXT_OPTION_COLOR", static_cast(SPV_BINARY_TO_TEXT_OPTION_COLOR)); constant("SPV_BINARY_TO_TEXT_OPTION_INDENT", static_cast(SPV_BINARY_TO_TEXT_OPTION_INDENT)); constant("SPV_BINARY_TO_TEXT_OPTION_SHOW_BYTE_OFFSET", static_cast(SPV_BINARY_TO_TEXT_OPTION_SHOW_BYTE_OFFSET)); constant("SPV_BINARY_TO_TEXT_OPTION_NO_HEADER", static_cast(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER)); constant("SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES", static_cast(SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES)); constant("SPV_TEXT_TO_BINARY_OPTION_NONE", static_cast(SPV_TEXT_TO_BINARY_OPTION_NONE)); constant("SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS", static_cast(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS)); } KhronosGroup-SPIRV-Tools-f289d04/source/wasm/spirv-tools.d.ts000066400000000000000000000040111475742701700240670ustar00rootroot00000000000000// Copyright (c) 2020 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. declare interface SpirvTools { as(input: string, env: number, options: number): Uint8Array; dis(input: Uint8Array, env: number, options: number): string; SPV_ENV_UNIVERSAL_1_0: number; SPV_ENV_VULKAN_1_0: number; SPV_ENV_UNIVERSAL_1_1: number; SPV_ENV_OPENCL_2_1: number; SPV_ENV_OPENCL_2_2: number; SPV_ENV_OPENGL_4_0: number; SPV_ENV_OPENGL_4_1: number; SPV_ENV_OPENGL_4_2: number; SPV_ENV_OPENGL_4_3: number; SPV_ENV_OPENGL_4_5: number; SPV_ENV_UNIVERSAL_1_2: number; SPV_ENV_OPENCL_1_2: number; SPV_ENV_OPENCL_EMBEDDED_1_2: number; SPV_ENV_OPENCL_2_0: number; SPV_ENV_OPENCL_EMBEDDED_2_0: number; SPV_ENV_OPENCL_EMBEDDED_2_1: number; SPV_ENV_OPENCL_EMBEDDED_2_2: number; SPV_ENV_UNIVERSAL_1_3: number; SPV_ENV_VULKAN_1_1: number; SPV_ENV_WEBGPU_0: number; SPV_ENV_UNIVERSAL_1_4: number; SPV_ENV_VULKAN_1_1_SPIRV_1_4: number; SPV_ENV_UNIVERSAL_1_5: number; SPV_ENV_VULKAN_1_2: number; SPV_ENV_UNIVERSAL_1_6: number; SPV_TEXT_TO_BINARY_OPTION_NONE: number; SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS: number; SPV_BINARY_TO_TEXT_OPTION_NONE: number; SPV_BINARY_TO_TEXT_OPTION_PRINT: number; SPV_BINARY_TO_TEXT_OPTION_COLOR: number; SPV_BINARY_TO_TEXT_OPTION_INDENT: number; SPV_BINARY_TO_TEXT_OPTION_SHOW_BYTE_OFFSET: number; SPV_BINARY_TO_TEXT_OPTION_NO_HEADER: number; SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES: number; } export default function (): Promise; KhronosGroup-SPIRV-Tools-f289d04/test/000077500000000000000000000000001475742701700175105ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/CMakeLists.txt000066400000000000000000000143001475742701700222460ustar00rootroot00000000000000# Copyright (c) 2015-2016 The Khronos Group Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. if (${SPIRV_SKIP_TESTS}) return() endif() if (TARGET gmock_main) message(STATUS "Found Google Mock, building tests.") else() message(STATUS "Did not find googletest, tests will not be built. " "To enable tests place googletest in '/external/googletest'.") endif() # Add a SPIR-V Tools unit test. Signature: # add_spvtools_unittest( # TARGET target_name # SRCS src_file.h src_file.cpp # LIBS lib1 lib2 # ) function(add_spvtools_unittest) if (NOT "${SPIRV_SKIP_TESTS}" AND TARGET gmock_main) set(one_value_args TARGET PCH_FILE) set(multi_value_args SRCS LIBS ENVIRONMENT DEFINES) cmake_parse_arguments( ARG "" "${one_value_args}" "${multi_value_args}" ${ARGN}) set(target test_${ARG_TARGET}) set(SRC_COPY ${ARG_SRCS}) if (DEFINED ARG_PCH_FILE) spvtools_pch(SRC_COPY ${ARG_PCH_FILE}) endif() add_executable(${target} ${SRC_COPY}) target_compile_definitions(${target} PUBLIC ${ARG_DEFINES}) spvtools_default_compile_options(${target}) if(${COMPILER_IS_LIKE_GNU}) target_compile_options(${target} PRIVATE -Wno-undef) # Effcee and RE2 headers exhibit shadowing. target_compile_options(${target} PRIVATE -Wno-shadow) endif() if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") # Disable C4503 "decorated name length exceeded" warning, # triggered by some heavily templated types. # We don't care much about that in test code. # Important to do since we have warnings-as-errors. target_compile_options(${target} PRIVATE /wd4503) # Googletest accidentally turns off support for ::testing::Combine # in VS 2017. See https://github.com/google/googletest/issues/1352 # Forcibly turn it on again. target_compile_options(${target} PRIVATE /DGTEST_HAS_COMBINE=1) endif() target_include_directories(${target} PRIVATE ${SPIRV_HEADER_INCLUDE_DIR} ${spirv-tools_SOURCE_DIR} ${spirv-tools_SOURCE_DIR}/include ${spirv-tools_SOURCE_DIR}/test ${spirv-tools_BINARY_DIR} ${gtest_SOURCE_DIR}/include ${gmock_SOURCE_DIR}/include ) if (TARGET effcee) # If using Effcee for testing, then add its include directory. target_include_directories(${target} PRIVATE ${effcee_SOURCE_DIR}) endif() target_link_libraries(${target} PRIVATE ${ARG_LIBS}) if (TARGET effcee) target_link_libraries(${target} PRIVATE effcee) endif() target_link_libraries(${target} PRIVATE gmock_main) add_test(NAME spirv-tools-${target} COMMAND ${target}) if (DEFINED ARG_ENVIRONMENT) set_tests_properties(spirv-tools-${target} PROPERTIES ENVIRONMENT ${ARG_ENVIRONMENT}) endif() set_property(TARGET ${target} PROPERTY FOLDER "SPIRV-Tools tests") endif() endfunction() set(TEST_SOURCES test_fixture.h unit_spirv.h ${spirv-tools_SOURCE_DIR}/tools/io.h assembly_context_test.cpp assembly_format_test.cpp binary_destroy_test.cpp binary_endianness_test.cpp binary_header_get_test.cpp binary_parse_test.cpp binary_strnlen_s_test.cpp binary_to_text_test.cpp binary_to_text.literal_test.cpp comment_test.cpp diagnostic_test.cpp enum_string_mapping_test.cpp enum_set_test.cpp ext_inst.cldebug100_test.cpp ext_inst.debuginfo_test.cpp ext_inst.glsl_test.cpp ext_inst.non_semantic_test.cpp ext_inst.opencl_test.cpp fix_word_test.cpp generator_magic_number_test.cpp hex_float_test.cpp hex_to_text_test.cpp immediate_int_test.cpp libspirv_macros_test.cpp named_id_test.cpp name_mapper_test.cpp opcode_make_test.cpp opcode_require_capabilities_test.cpp opcode_split_test.cpp opcode_table_get_test.cpp operand_capabilities_test.cpp operand_test.cpp operand_pattern_test.cpp parse_number_test.cpp preserve_numeric_ids_test.cpp software_version_test.cpp string_utils_test.cpp target_env_test.cpp text_advance_test.cpp text_destroy_test.cpp text_literal_test.cpp text_start_new_inst_test.cpp text_to_binary.annotation_test.cpp text_to_binary.barrier_test.cpp text_to_binary.composite_test.cpp text_to_binary.constant_test.cpp text_to_binary.control_flow_test.cpp text_to_binary_test.cpp text_to_binary.debug_test.cpp text_to_binary.device_side_enqueue_test.cpp text_to_binary.extension_test.cpp text_to_binary.function_test.cpp text_to_binary.group_test.cpp text_to_binary.image_test.cpp text_to_binary.literal_test.cpp text_to_binary.memory_test.cpp text_to_binary.misc_test.cpp text_to_binary.mode_setting_test.cpp text_to_binary.pipe_storage_test.cpp text_to_binary.type_declaration_test.cpp text_to_binary.subgroup_dispatch_test.cpp text_to_binary.reserved_sampling_test.cpp text_word_get_test.cpp to_string_test.cpp unit_spirv.cpp ${spirv-tools_SOURCE_DIR}/tools/io.cpp ) spvtools_pch(TEST_SOURCES pch_test) add_spvtools_unittest( TARGET spirv_unit_tests SRCS ${TEST_SOURCES} LIBS ${SPIRV_TOOLS_FULL_VISIBILITY}) add_spvtools_unittest( TARGET c_interface SRCS c_interface_test.cpp LIBS ${SPIRV_TOOLS_FULL_VISIBILITY}) add_spvtools_unittest( TARGET c_interface_shared SRCS c_interface_test.cpp LIBS ${SPIRV_TOOLS}-shared ENVIRONMENT PATH=$) add_spvtools_unittest( TARGET cpp_interface SRCS cpp_interface_test.cpp LIBS SPIRV-Tools-opt) if (${SPIRV_TIMER_ENABLED}) add_spvtools_unittest( TARGET timer SRCS timer_test.cpp LIBS ${SPIRV_TOOLS_FULL_VISIBILITY}) endif() add_subdirectory(diff) add_subdirectory(link) add_subdirectory(lint) add_subdirectory(opt) add_subdirectory(reduce) add_subdirectory(fuzz) add_subdirectory(tools) add_subdirectory(util) add_subdirectory(val) add_subdirectory(fuzzers) KhronosGroup-SPIRV-Tools-f289d04/test/assembly_context_test.cpp000066400000000000000000000044121475742701700246370ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gmock/gmock.h" #include "source/instruction.h" #include "source/util/string_utils.h" #include "test/unit_spirv.h" namespace spvtools { namespace { using spvtest::AutoText; using spvtest::Concatenate; using ::testing::Eq; struct EncodeStringCase { std::string str; std::vector initial_contents; }; using EncodeStringTest = ::testing::TestWithParam; TEST_P(EncodeStringTest, Sample) { AssemblyContext context(AutoText(""), nullptr); spv_instruction_t inst; inst.words = GetParam().initial_contents; ASSERT_EQ(SPV_SUCCESS, context.binaryEncodeString(GetParam().str.c_str(), &inst)); // We already trust MakeVector EXPECT_THAT(inst.words, Eq(Concatenate({GetParam().initial_contents, utils::MakeVector(GetParam().str)}))); } // clang-format off INSTANTIATE_TEST_SUITE_P( BinaryEncodeString, EncodeStringTest, ::testing::ValuesIn(std::vector{ // Use cases that exercise at least one to two words, // and both empty and non-empty initial contents. {"", {}}, {"", {1,2,3}}, {"a", {}}, {"a", {4}}, {"ab", {4}}, {"abc", {}}, {"abc", {18}}, {"abcd", {}}, {"abcd", {22}}, {"abcde", {4}}, {"abcdef", {}}, {"abcdef", {99,42}}, {"abcdefg", {}}, {"abcdefg", {101}}, {"abcdefgh", {}}, {"abcdefgh", {102, 103, 104}}, // A very long string, encoded after an initial word. // SPIR-V limits strings to 65535 characters. {std::string(65535, 'a'), {1}}, })); // clang-format on } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/assembly_format_test.cpp000066400000000000000000000033511475742701700244440ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "test/test_fixture.h" namespace svptools { namespace { using spvtest::ScopedContext; using spvtest::TextToBinaryTest; TEST_F(TextToBinaryTest, InstOpcodeProducesResultIDButNoIDDefinedFails) { SetText("OpTypeMatrix %1 %2 1000"); EXPECT_EQ(SPV_ERROR_INVALID_TEXT, spvTextToBinary(ScopedContext().context, text.str, text.length, &binary, &diagnostic)); ASSERT_NE(nullptr, diagnostic); EXPECT_STREQ( "Expected at the beginning of an instruction, found " "'OpTypeMatrix'.", diagnostic->error); EXPECT_EQ(0u, diagnostic->position.line); } TEST_F(TextToBinaryTest, InstDefinesResultIDButOpcodeDoesNotProduceAResultFails) { SetText("\n\n%foo = OpName %1 \"bar\""); EXPECT_EQ(SPV_ERROR_INVALID_TEXT, spvTextToBinary(ScopedContext().context, text.str, text.length, &binary, &diagnostic)); ASSERT_NE(nullptr, diagnostic); EXPECT_STREQ( "Cannot set ID %foo because OpName does not produce a result ID.", diagnostic->error); EXPECT_EQ(2u, diagnostic->position.line); } } // namespace } // namespace svptools KhronosGroup-SPIRV-Tools-f289d04/test/binary_destroy_test.cpp000066400000000000000000000027301475742701700243120ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "test/unit_spirv.h" #include "test/test_fixture.h" namespace spvtools { namespace { using spvtest::ScopedContext; TEST(BinaryDestroy, Null) { // There is no state or return value to check. Just check // for the ability to call the API without abnormal termination. spvBinaryDestroy(nullptr); } using BinaryDestroySomething = spvtest::TextToBinaryTest; // Checks safety of destroying a validly constructed binary. TEST_F(BinaryDestroySomething, Default) { // Use a binary object constructed by the API instead of rolling our own. SetText("OpSource OpenCL_C 120"); spv_binary my_binary = nullptr; ASSERT_EQ(SPV_SUCCESS, spvTextToBinary(ScopedContext().context, text.str, text.length, &my_binary, &diagnostic)); ASSERT_NE(nullptr, my_binary); spvBinaryDestroy(my_binary); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/binary_endianness_test.cpp000066400000000000000000000032151475742701700247470ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "test/unit_spirv.h" namespace spvtools { namespace { TEST(BinaryEndianness, InvalidCode) { uint32_t invalidMagicNumber[] = {0}; spv_const_binary_t binary = {invalidMagicNumber, 1}; spv_endianness_t endian; ASSERT_EQ(SPV_ERROR_INVALID_BINARY, spvBinaryEndianness(&binary, &endian)); } TEST(BinaryEndianness, Little) { uint32_t magicNumber; if (I32_ENDIAN_HOST == I32_ENDIAN_LITTLE) { magicNumber = 0x07230203; } else { magicNumber = 0x03022307; } spv_const_binary_t binary = {&magicNumber, 1}; spv_endianness_t endian; ASSERT_EQ(SPV_SUCCESS, spvBinaryEndianness(&binary, &endian)); ASSERT_EQ(SPV_ENDIANNESS_LITTLE, endian); } TEST(BinaryEndianness, Big) { uint32_t magicNumber; if (I32_ENDIAN_HOST == I32_ENDIAN_BIG) { magicNumber = 0x07230203; } else { magicNumber = 0x03022307; } spv_const_binary_t binary = {&magicNumber, 1}; spv_endianness_t endian; ASSERT_EQ(SPV_SUCCESS, spvBinaryEndianness(&binary, &endian)); ASSERT_EQ(SPV_ENDIANNESS_BIG, endian); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/binary_header_get_test.cpp000066400000000000000000000073621475742701700247160ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/spirv_constant.h" #include "test/unit_spirv.h" namespace spvtools { namespace { class BinaryHeaderGet : public ::testing::Test { public: BinaryHeaderGet() { memset(code, 0, sizeof(code)); } virtual void SetUp() { code[0] = static_cast(spv::MagicNumber); code[1] = static_cast(spv::Version); code[2] = SPV_GENERATOR_CODEPLAY; code[3] = 1; // NOTE: Bound code[4] = 0; // NOTE: Schema; reserved code[5] = 0; // NOTE: Instructions binary.code = code; binary.wordCount = 6; } spv_const_binary_t get_const_binary() { return spv_const_binary_t{binary.code, binary.wordCount}; } virtual void TearDown() {} uint32_t code[6]; spv_binary_t binary; }; TEST_F(BinaryHeaderGet, Default) { spv_endianness_t endian; spv_const_binary_t const_bin = get_const_binary(); ASSERT_EQ(SPV_SUCCESS, spvBinaryEndianness(&const_bin, &endian)); spv_header_t header; ASSERT_EQ(SPV_SUCCESS, spvBinaryHeaderGet(&const_bin, endian, &header)); ASSERT_EQ(static_cast(spv::MagicNumber), header.magic); // Expect SPIRV-Headers updated to SPIR-V 1.6. ASSERT_EQ(0x00010600u, header.version); ASSERT_EQ(static_cast(SPV_GENERATOR_CODEPLAY), header.generator); ASSERT_EQ(1u, header.bound); ASSERT_EQ(0u, header.schema); ASSERT_EQ(&code[5], header.instructions); } TEST_F(BinaryHeaderGet, InvalidCode) { spv_const_binary_t my_binary = {nullptr, 0}; spv_header_t header; ASSERT_EQ(SPV_ERROR_INVALID_BINARY, spvBinaryHeaderGet(&my_binary, SPV_ENDIANNESS_LITTLE, &header)); } TEST_F(BinaryHeaderGet, InvalidPointerHeader) { spv_const_binary_t const_bin = get_const_binary(); ASSERT_EQ(SPV_ERROR_INVALID_POINTER, spvBinaryHeaderGet(&const_bin, SPV_ENDIANNESS_LITTLE, nullptr)); } TEST_F(BinaryHeaderGet, TruncatedHeader) { for (uint8_t i = 1; i < SPV_INDEX_INSTRUCTION; i++) { binary.wordCount = i; spv_const_binary_t const_bin = get_const_binary(); ASSERT_EQ(SPV_ERROR_INVALID_BINARY, spvBinaryHeaderGet(&const_bin, SPV_ENDIANNESS_LITTLE, nullptr)); } } TEST_F(BinaryHeaderGet, VersionNonZeroHighByte) { spv_header_t header; code[1] = 0xFF010300; spv_const_binary_t const_bin = get_const_binary(); ASSERT_EQ(SPV_ERROR_INVALID_BINARY, spvBinaryHeaderGet(&const_bin, SPV_ENDIANNESS_LITTLE, &header)); } TEST_F(BinaryHeaderGet, VersionNonZeroLowByte) { spv_header_t header; code[1] = 0x000103F0; spv_const_binary_t const_bin = get_const_binary(); ASSERT_EQ(SPV_ERROR_INVALID_BINARY, spvBinaryHeaderGet(&const_bin, SPV_ENDIANNESS_LITTLE, &header)); } TEST_F(BinaryHeaderGet, VersionTooLow) { spv_header_t header; code[1] = 0x00000300; spv_const_binary_t const_bin = get_const_binary(); ASSERT_EQ(SPV_ERROR_INVALID_BINARY, spvBinaryHeaderGet(&const_bin, SPV_ENDIANNESS_LITTLE, &header)); } TEST_F(BinaryHeaderGet, VersionTooHigh) { spv_header_t header; code[1] = 0x000F0300; spv_const_binary_t const_bin = get_const_binary(); ASSERT_EQ(SPV_ERROR_INVALID_BINARY, spvBinaryHeaderGet(&const_bin, SPV_ENDIANNESS_LITTLE, &header)); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/binary_parse_test.cpp000066400000000000000000001521651475742701700237430ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include #include #include "gmock/gmock.h" #include "source/latest_version_opencl_std_header.h" #include "source/table.h" #include "source/util/string_utils.h" #include "test/test_fixture.h" #include "test/unit_spirv.h" // Returns true if two spv_parsed_operand_t values are equal. // To use this operator, this definition must appear in the same namespace // as spv_parsed_operand_t. static bool operator==(const spv_parsed_operand_t& a, const spv_parsed_operand_t& b) { return a.offset == b.offset && a.num_words == b.num_words && a.type == b.type && a.number_kind == b.number_kind && a.number_bit_width == b.number_bit_width; } namespace spvtools { namespace { using ::spvtest::Concatenate; using ::spvtest::MakeInstruction; using utils::MakeVector; using ::spvtest::ScopedContext; using ::testing::_; using ::testing::AnyOf; using ::testing::Eq; using ::testing::InSequence; using ::testing::Return; // An easily-constructible and comparable object for the contents of an // spv_parsed_instruction_t. Unlike spv_parsed_instruction_t, owns the memory // of its components. struct ParsedInstruction { explicit ParsedInstruction(const spv_parsed_instruction_t& inst) : words(inst.words, inst.words + inst.num_words), opcode(static_cast(inst.opcode)), ext_inst_type(inst.ext_inst_type), type_id(inst.type_id), result_id(inst.result_id), operands(inst.operands, inst.operands + inst.num_operands) {} std::vector words; spv::Op opcode; spv_ext_inst_type_t ext_inst_type; uint32_t type_id; uint32_t result_id; std::vector operands; bool operator==(const ParsedInstruction& b) const { return words == b.words && opcode == b.opcode && ext_inst_type == b.ext_inst_type && type_id == b.type_id && result_id == b.result_id && operands == b.operands; } }; // Prints a ParsedInstruction object to the given output stream, and returns // the stream. std::ostream& operator<<(std::ostream& os, const ParsedInstruction& inst) { os << "\nParsedInstruction( {"; spvtest::PrintTo(spvtest::WordVector(inst.words), &os); os << "}, opcode: " << int(inst.opcode) << " ext_inst_type: " << int(inst.ext_inst_type) << " type_id: " << inst.type_id << " result_id: " << inst.result_id; for (const auto& operand : inst.operands) { os << " { offset: " << operand.offset << " num_words: " << operand.num_words << " type: " << int(operand.type) << " number_kind: " << int(operand.number_kind) << " number_bit_width: " << int(operand.number_bit_width) << "}"; } os << ")"; return os; } // Basic check for the equality operator on ParsedInstruction. TEST(ParsedInstruction, ZeroInitializedAreEqual) { spv_parsed_instruction_t pi = {}; ParsedInstruction a(pi); ParsedInstruction b(pi); EXPECT_THAT(a, ::testing::TypedEq(b)); } // Googlemock class receiving Header/Instruction calls from spvBinaryParse(). class MockParseClient { public: MOCK_METHOD6(Header, spv_result_t(spv_endianness_t endian, uint32_t magic, uint32_t version, uint32_t generator, uint32_t id_bound, uint32_t reserved)); MOCK_METHOD1(Instruction, spv_result_t(const ParsedInstruction&)); }; // Casts user_data as MockParseClient and invokes its Header(). spv_result_t invoke_header(void* user_data, spv_endianness_t endian, uint32_t magic, uint32_t version, uint32_t generator, uint32_t id_bound, uint32_t reserved) { return static_cast(user_data)->Header( endian, magic, version, generator, id_bound, reserved); } // Casts user_data as MockParseClient and invokes its Instruction(). spv_result_t invoke_instruction( void* user_data, const spv_parsed_instruction_t* parsed_instruction) { return static_cast(user_data)->Instruction( ParsedInstruction(*parsed_instruction)); } // The SPIR-V module header words for the Khronos Assembler generator, // for a module with an ID bound of 1. const uint32_t kHeaderForBound1[] = { spv::MagicNumber, spv::Version, SPV_GENERATOR_WORD(SPV_GENERATOR_KHRONOS_ASSEMBLER, 0), 1 /*bound*/, 0 /*schema*/}; // Returns the expected SPIR-V module header words for the Khronos // Assembler generator, and with a given Id bound. std::vector ExpectedHeaderForBound(uint32_t bound) { return {spv::MagicNumber, 0x10000, SPV_GENERATOR_WORD(SPV_GENERATOR_KHRONOS_ASSEMBLER, 0), bound, 0}; } // Returns a parsed operand for a non-number value at the given word offset // within an instruction. spv_parsed_operand_t MakeSimpleOperand(uint16_t offset, spv_operand_type_t type) { return {offset, 1, type, SPV_NUMBER_NONE, 0}; } // Returns a parsed operand for a literal unsigned integer value at the given // word offset within an instruction. spv_parsed_operand_t MakeLiteralNumberOperand(uint16_t offset) { return {offset, 1, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_NUMBER_UNSIGNED_INT, 32}; } // Returns a parsed operand for a literal string value at the given // word offset within an instruction. spv_parsed_operand_t MakeLiteralStringOperand(uint16_t offset, uint16_t length) { return {offset, length, SPV_OPERAND_TYPE_LITERAL_STRING, SPV_NUMBER_NONE, 0}; } // Returns a ParsedInstruction for an OpTypeVoid instruction that would // generate the given result Id. ParsedInstruction MakeParsedVoidTypeInstruction(uint32_t result_id) { const auto void_inst = MakeInstruction(spv::Op::OpTypeVoid, {result_id}); const auto void_operands = std::vector{ MakeSimpleOperand(1, SPV_OPERAND_TYPE_RESULT_ID)}; const spv_parsed_instruction_t parsed_void_inst = { void_inst.data(), static_cast(void_inst.size()), uint16_t(spv::Op::OpTypeVoid), SPV_EXT_INST_TYPE_NONE, 0, // type id result_id, void_operands.data(), static_cast(void_operands.size())}; return ParsedInstruction(parsed_void_inst); } // Returns a ParsedInstruction for an OpTypeInt instruction that generates // the given result Id for a 32-bit signed integer scalar type. ParsedInstruction MakeParsedInt32TypeInstruction(uint32_t result_id) { const auto i32_inst = MakeInstruction(spv::Op::OpTypeInt, {result_id, 32, 1}); const auto i32_operands = std::vector{ MakeSimpleOperand(1, SPV_OPERAND_TYPE_RESULT_ID), MakeLiteralNumberOperand(2), MakeLiteralNumberOperand(3)}; spv_parsed_instruction_t parsed_i32_inst = { i32_inst.data(), static_cast(i32_inst.size()), uint16_t(spv::Op::OpTypeInt), SPV_EXT_INST_TYPE_NONE, 0, // type id result_id, i32_operands.data(), static_cast(i32_operands.size())}; return ParsedInstruction(parsed_i32_inst); } class BinaryParseTest : public spvtest::TextToBinaryTestBase<::testing::Test> { protected: ~BinaryParseTest() override { spvDiagnosticDestroy(diagnostic_); } void Parse(const SpirvVector& words, spv_result_t expected_result, bool flip_words = false) { SpirvVector flipped_words(words); MaybeFlipWords(flip_words, flipped_words.begin(), flipped_words.end()); EXPECT_EQ(expected_result, spvBinaryParse(ScopedContext().context, &client_, flipped_words.data(), flipped_words.size(), invoke_header, invoke_instruction, &diagnostic_)); } spv_diagnostic diagnostic_ = nullptr; MockParseClient client_; }; class CxxBinaryParseTest : public spvtest::TextToBinaryTestBase<::testing::Test> { protected: CxxBinaryParseTest() { header_parser_ = [this](const spv_endianness_t endianness, const spv_parsed_header_t& header) { return this->client_.Header(endianness, header.magic, header.version, header.generator, header.bound, header.reserved); }; instruction_parser_ = [this](const spv_parsed_instruction_t& instruction) { return this->client_.Instruction(ParsedInstruction(instruction)); }; } ~CxxBinaryParseTest() override { spvDiagnosticDestroy(diagnostic_); } void Parse(const SpirvVector& words, bool expected_result, bool flip_words = false, spv_target_env env = SPV_ENV_UNIVERSAL_1_0) { SpirvVector flipped_words(words); MaybeFlipWords(flip_words, flipped_words.begin(), flipped_words.end()); spvtools::SpirvTools tools(env); EXPECT_EQ(expected_result, tools.Parse(flipped_words, header_parser_, instruction_parser_, &diagnostic_)); } spv_diagnostic diagnostic_ = nullptr; MockParseClient client_; HeaderParser header_parser_; InstructionParser instruction_parser_; }; // Adds an EXPECT_CALL to client_->Header() with appropriate parameters, // including bound. Returns the EXPECT_CALL result. #define EXPECT_HEADER(bound) \ EXPECT_CALL(client_, \ Header(AnyOf(SPV_ENDIANNESS_LITTLE, SPV_ENDIANNESS_BIG), \ spv::MagicNumber, 0x10000, \ SPV_GENERATOR_WORD(SPV_GENERATOR_KHRONOS_ASSEMBLER, 0), \ bound, 0 /*reserved*/)) static const bool kSwapEndians[] = {false, true}; TEST_F(BinaryParseTest, EmptyModuleHasValidHeaderAndNoInstructionCallbacks) { for (bool endian_swap : kSwapEndians) { const auto words = CompileSuccessfully(""); EXPECT_HEADER(1).WillOnce(Return(SPV_SUCCESS)); EXPECT_CALL(client_, Instruction(_)).Times(0); // No instruction callback. Parse(words, SPV_SUCCESS, endian_swap); EXPECT_EQ(nullptr, diagnostic_); } } TEST_F(CxxBinaryParseTest, EmptyModuleHasValidHeaderAndNoInstructionCallbacks) { for (bool endian_swap : kSwapEndians) { const auto words = CompileSuccessfully(""); EXPECT_HEADER(1).WillOnce(Return(SPV_SUCCESS)); EXPECT_CALL(client_, Instruction(_)).Times(0); // No instruction callback. Parse(words, true, endian_swap); EXPECT_EQ(nullptr, diagnostic_); } } TEST_F(BinaryParseTest, NullDiagnosticsIsOkForGoodParse) { const auto words = CompileSuccessfully(""); EXPECT_HEADER(1).WillOnce(Return(SPV_SUCCESS)); EXPECT_CALL(client_, Instruction(_)).Times(0); // No instruction callback. EXPECT_EQ( SPV_SUCCESS, spvBinaryParse(ScopedContext().context, &client_, words.data(), words.size(), invoke_header, invoke_instruction, nullptr)); } TEST_F(CxxBinaryParseTest, NullDiagnosticsIsOkForGoodParse) { const auto words = CompileSuccessfully(""); EXPECT_HEADER(1).WillOnce(Return(SPV_SUCCESS)); EXPECT_CALL(client_, Instruction(_)).Times(0); // No instruction callback. spvtools::SpirvTools tools(SPV_ENV_UNIVERSAL_1_0); EXPECT_EQ(true, tools.Parse(words, header_parser_, instruction_parser_, nullptr)); } TEST_F(BinaryParseTest, NullDiagnosticsIsOkForBadParse) { auto words = CompileSuccessfully(""); words.push_back(0xffffffff); // Certainly invalid instruction header. EXPECT_HEADER(1).WillOnce(Return(SPV_SUCCESS)); EXPECT_CALL(client_, Instruction(_)).Times(0); // No instruction callback. EXPECT_EQ( SPV_ERROR_INVALID_BINARY, spvBinaryParse(ScopedContext().context, &client_, words.data(), words.size(), invoke_header, invoke_instruction, nullptr)); } TEST_F(CxxBinaryParseTest, NullDiagnosticsIsOkForBadParse) { auto words = CompileSuccessfully(""); words.push_back(0xffffffff); // Certainly invalid instruction header. EXPECT_HEADER(1).WillOnce(Return(SPV_SUCCESS)); EXPECT_CALL(client_, Instruction(_)).Times(0); // No instruction callback. spvtools::SpirvTools tools(SPV_ENV_UNIVERSAL_1_0); EXPECT_EQ(false, tools.Parse(words, header_parser_, instruction_parser_, nullptr)); } // Make sure that we don't blow up when both the consumer and the diagnostic are // null. TEST_F(BinaryParseTest, NullConsumerNullDiagnosticsForBadParse) { auto words = CompileSuccessfully(""); auto ctx = spvtools::Context(SPV_ENV_UNIVERSAL_1_1); ctx.SetMessageConsumer(nullptr); words.push_back(0xffffffff); // Certainly invalid instruction header. EXPECT_HEADER(1).WillOnce(Return(SPV_SUCCESS)); EXPECT_CALL(client_, Instruction(_)).Times(0); // No instruction callback. EXPECT_EQ(SPV_ERROR_INVALID_BINARY, spvBinaryParse(ctx.CContext(), &client_, words.data(), words.size(), invoke_header, invoke_instruction, nullptr)); } TEST_F(CxxBinaryParseTest, NullConsumerNullDiagnosticsForBadParse) { spvtools::SpirvTools tools(SPV_ENV_UNIVERSAL_1_1); tools.SetMessageConsumer(nullptr); auto words = CompileSuccessfully(""); words.push_back(0xffffffff); // Certainly invalid instruction header. EXPECT_HEADER(1).WillOnce(Return(SPV_SUCCESS)); EXPECT_CALL(client_, Instruction(_)).Times(0); // No instruction callback. EXPECT_EQ(false, tools.Parse(words, header_parser_, instruction_parser_, nullptr)); } TEST_F(BinaryParseTest, SpecifyConsumerNullDiagnosticsForGoodParse) { const auto words = CompileSuccessfully(""); auto ctx = spvtools::Context(SPV_ENV_UNIVERSAL_1_1); int invocation = 0; ctx.SetMessageConsumer([&invocation](spv_message_level_t, const char*, const spv_position_t&, const char*) { ++invocation; }); EXPECT_HEADER(1).WillOnce(Return(SPV_SUCCESS)); EXPECT_CALL(client_, Instruction(_)).Times(0); // No instruction callback. EXPECT_EQ(SPV_SUCCESS, spvBinaryParse(ctx.CContext(), &client_, words.data(), words.size(), invoke_header, invoke_instruction, nullptr)); EXPECT_EQ(0, invocation); } TEST_F(CxxBinaryParseTest, SpecifyConsumerNullDiagnosticsForGoodParse) { const auto words = CompileSuccessfully(""); spvtools::SpirvTools tools(SPV_ENV_UNIVERSAL_1_1); int invocation = 0; tools.SetMessageConsumer([&invocation](spv_message_level_t, const char*, const spv_position_t&, const char*) { ++invocation; }); EXPECT_HEADER(1).WillOnce(Return(SPV_SUCCESS)); EXPECT_CALL(client_, Instruction(_)).Times(0); // No instruction callback. EXPECT_EQ(true, tools.Parse(words, header_parser_, instruction_parser_, nullptr)); EXPECT_EQ(0, invocation); } TEST_F(BinaryParseTest, SpecifyConsumerNullDiagnosticsForBadParse) { auto words = CompileSuccessfully(""); auto ctx = spvtools::Context(SPV_ENV_UNIVERSAL_1_1); int invocation = 0; ctx.SetMessageConsumer( [&invocation](spv_message_level_t level, const char* source, const spv_position_t& position, const char* message) { ++invocation; EXPECT_EQ(SPV_MSG_ERROR, level); EXPECT_STREQ("input", source); EXPECT_EQ(0u, position.line); EXPECT_EQ(0u, position.column); EXPECT_EQ(1u, position.index); EXPECT_STREQ("Invalid opcode: 65535", message); }); words.push_back(0xffffffff); // Certainly invalid instruction header. EXPECT_HEADER(1).WillOnce(Return(SPV_SUCCESS)); EXPECT_CALL(client_, Instruction(_)).Times(0); // No instruction callback. EXPECT_EQ(SPV_ERROR_INVALID_BINARY, spvBinaryParse(ctx.CContext(), &client_, words.data(), words.size(), invoke_header, invoke_instruction, nullptr)); EXPECT_EQ(1, invocation); } TEST_F(CxxBinaryParseTest, SpecifyConsumerNullDiagnosticsForBadParse) { auto words = CompileSuccessfully(""); spvtools::SpirvTools tools(SPV_ENV_UNIVERSAL_1_1); int invocation = 0; tools.SetMessageConsumer( [&invocation](spv_message_level_t level, const char* source, const spv_position_t& position, const char* message) { ++invocation; EXPECT_EQ(SPV_MSG_ERROR, level); EXPECT_STREQ("input", source); EXPECT_EQ(0u, position.line); EXPECT_EQ(0u, position.column); EXPECT_EQ(1u, position.index); EXPECT_STREQ("Invalid opcode: 65535", message); }); words.push_back(0xffffffff); // Certainly invalid instruction header. EXPECT_HEADER(1).WillOnce(Return(SPV_SUCCESS)); EXPECT_CALL(client_, Instruction(_)).Times(0); // No instruction callback. EXPECT_EQ(false, tools.Parse(words, header_parser_, instruction_parser_, nullptr)); EXPECT_EQ(1, invocation); } TEST_F(BinaryParseTest, SpecifyConsumerSpecifyDiagnosticsForGoodParse) { const auto words = CompileSuccessfully(""); auto ctx = spvtools::Context(SPV_ENV_UNIVERSAL_1_1); int invocation = 0; ctx.SetMessageConsumer([&invocation](spv_message_level_t, const char*, const spv_position_t&, const char*) { ++invocation; }); EXPECT_HEADER(1).WillOnce(Return(SPV_SUCCESS)); EXPECT_CALL(client_, Instruction(_)).Times(0); // No instruction callback. EXPECT_EQ(SPV_SUCCESS, spvBinaryParse(ctx.CContext(), &client_, words.data(), words.size(), invoke_header, invoke_instruction, &diagnostic_)); EXPECT_EQ(0, invocation); EXPECT_EQ(nullptr, diagnostic_); } TEST_F(CxxBinaryParseTest, SpecifyConsumerSpecifyDiagnosticsForGoodParse) { const auto words = CompileSuccessfully(""); spvtools::SpirvTools tools(SPV_ENV_UNIVERSAL_1_1); int invocation = 0; tools.SetMessageConsumer([&invocation](spv_message_level_t, const char*, const spv_position_t&, const char*) { ++invocation; }); EXPECT_HEADER(1).WillOnce(Return(SPV_SUCCESS)); EXPECT_CALL(client_, Instruction(_)).Times(0); // No instruction callback. EXPECT_EQ(true, tools.Parse(words, header_parser_, instruction_parser_, &diagnostic_)); EXPECT_EQ(0, invocation); EXPECT_EQ(nullptr, diagnostic_); } TEST_F(BinaryParseTest, SpecifyConsumerSpecifyDiagnosticsForBadParse) { auto words = CompileSuccessfully(""); auto ctx = spvtools::Context(SPV_ENV_UNIVERSAL_1_1); int invocation = 0; ctx.SetMessageConsumer([&invocation](spv_message_level_t, const char*, const spv_position_t&, const char*) { ++invocation; }); words.push_back(0xffffffff); // Certainly invalid instruction header. EXPECT_HEADER(1).WillOnce(Return(SPV_SUCCESS)); EXPECT_CALL(client_, Instruction(_)).Times(0); // No instruction callback. EXPECT_EQ(SPV_ERROR_INVALID_BINARY, spvBinaryParse(ctx.CContext(), &client_, words.data(), words.size(), invoke_header, invoke_instruction, &diagnostic_)); EXPECT_EQ(0, invocation); EXPECT_STREQ("Invalid opcode: 65535", diagnostic_->error); } TEST_F(CxxBinaryParseTest, SpecifyConsumerSpecifyDiagnosticsForBadParse) { auto words = CompileSuccessfully(""); spvtools::SpirvTools tools(SPV_ENV_UNIVERSAL_1_1); int invocation = 0; tools.SetMessageConsumer([&invocation](spv_message_level_t, const char*, const spv_position_t&, const char*) { ++invocation; }); words.push_back(0xffffffff); // Certainly invalid instruction header. EXPECT_HEADER(1).WillOnce(Return(SPV_SUCCESS)); EXPECT_CALL(client_, Instruction(_)).Times(0); // No instruction callback. EXPECT_EQ(false, tools.Parse(words, header_parser_, instruction_parser_, &diagnostic_)); EXPECT_EQ(0, invocation); EXPECT_STREQ("Invalid opcode: 65535", diagnostic_->error); } TEST_F(BinaryParseTest, ModuleWithSingleInstructionHasValidHeaderAndInstructionCallback) { for (bool endian_swap : kSwapEndians) { const auto words = CompileSuccessfully("%1 = OpTypeVoid"); InSequence calls_expected_in_specific_order; EXPECT_HEADER(2).WillOnce(Return(SPV_SUCCESS)); EXPECT_CALL(client_, Instruction(MakeParsedVoidTypeInstruction(1))) .WillOnce(Return(SPV_SUCCESS)); Parse(words, SPV_SUCCESS, endian_swap); EXPECT_EQ(nullptr, diagnostic_); } } TEST_F(CxxBinaryParseTest, ModuleWithSingleInstructionHasValidHeaderAndInstructionCallback) { for (bool endian_swap : kSwapEndians) { const auto words = CompileSuccessfully("%1 = OpTypeVoid"); InSequence calls_expected_in_specific_order; EXPECT_HEADER(2).WillOnce(Return(SPV_SUCCESS)); EXPECT_CALL(client_, Instruction(MakeParsedVoidTypeInstruction(1))) .WillOnce(Return(SPV_SUCCESS)); Parse(words, true, endian_swap); EXPECT_EQ(nullptr, diagnostic_); } } TEST_F(BinaryParseTest, NullHeaderCallbackIsIgnored) { const auto words = CompileSuccessfully("%1 = OpTypeVoid"); EXPECT_CALL(client_, Header(_, _, _, _, _, _)) .Times(0); // No header callback. EXPECT_CALL(client_, Instruction(MakeParsedVoidTypeInstruction(1))) .WillOnce(Return(SPV_SUCCESS)); EXPECT_EQ(SPV_SUCCESS, spvBinaryParse(ScopedContext().context, &client_, words.data(), words.size(), nullptr, invoke_instruction, &diagnostic_)); EXPECT_EQ(nullptr, diagnostic_); } TEST_F(BinaryParseTest, NullInstructionCallbackIsIgnored) { const auto words = CompileSuccessfully("%1 = OpTypeVoid"); EXPECT_HEADER((2)).WillOnce(Return(SPV_SUCCESS)); EXPECT_CALL(client_, Instruction(_)).Times(0); // No instruction callback. EXPECT_EQ(SPV_SUCCESS, spvBinaryParse(ScopedContext().context, &client_, words.data(), words.size(), invoke_header, nullptr, &diagnostic_)); EXPECT_EQ(nullptr, diagnostic_); } // Check the result of multiple instruction callbacks. // // This test exercises non-default values for the following members of the // spv_parsed_instruction_t struct: words, num_words, opcode, result_id, // operands, num_operands. TEST_F(BinaryParseTest, TwoScalarTypesGenerateTwoInstructionCallbacks) { for (bool endian_swap : kSwapEndians) { const auto words = CompileSuccessfully( "%1 = OpTypeVoid " "%2 = OpTypeInt 32 1"); InSequence calls_expected_in_specific_order; EXPECT_HEADER(3).WillOnce(Return(SPV_SUCCESS)); EXPECT_CALL(client_, Instruction(MakeParsedVoidTypeInstruction(1))) .WillOnce(Return(SPV_SUCCESS)); EXPECT_CALL(client_, Instruction(MakeParsedInt32TypeInstruction(2))) .WillOnce(Return(SPV_SUCCESS)); Parse(words, SPV_SUCCESS, endian_swap); EXPECT_EQ(nullptr, diagnostic_); } } TEST_F(CxxBinaryParseTest, TwoScalarTypesGenerateTwoInstructionCallbacks) { for (bool endian_swap : kSwapEndians) { const auto words = CompileSuccessfully( "%1 = OpTypeVoid " "%2 = OpTypeInt 32 1"); InSequence calls_expected_in_specific_order; EXPECT_HEADER(3).WillOnce(Return(SPV_SUCCESS)); EXPECT_CALL(client_, Instruction(MakeParsedVoidTypeInstruction(1))) .WillOnce(Return(SPV_SUCCESS)); EXPECT_CALL(client_, Instruction(MakeParsedInt32TypeInstruction(2))) .WillOnce(Return(SPV_SUCCESS)); Parse(words, true, endian_swap); EXPECT_EQ(nullptr, diagnostic_); } } TEST_F(BinaryParseTest, EarlyReturnWithZeroPassingCallbacks) { for (bool endian_swap : kSwapEndians) { const auto words = CompileSuccessfully( "%1 = OpTypeVoid " "%2 = OpTypeInt 32 1"); InSequence calls_expected_in_specific_order; EXPECT_HEADER(3).WillOnce(Return(SPV_ERROR_INVALID_BINARY)); // Early exit means no calls to Instruction(). EXPECT_CALL(client_, Instruction(_)).Times(0); Parse(words, SPV_ERROR_INVALID_BINARY, endian_swap); // On error, the binary parser doesn't generate its own diagnostics. EXPECT_EQ(nullptr, diagnostic_); } } TEST_F(CxxBinaryParseTest, EarlyReturnWithZeroPassingCallbacks) { for (bool endian_swap : kSwapEndians) { const auto words = CompileSuccessfully( "%1 = OpTypeVoid " "%2 = OpTypeInt 32 1"); InSequence calls_expected_in_specific_order; EXPECT_HEADER(3).WillOnce(Return(SPV_ERROR_INVALID_BINARY)); // Early exit means no calls to Instruction(). EXPECT_CALL(client_, Instruction(_)).Times(0); Parse(words, false, endian_swap); // On error, the binary parser doesn't generate its own diagnostics. EXPECT_EQ(nullptr, diagnostic_); } } TEST_F(BinaryParseTest, EarlyReturnWithZeroPassingCallbacksAndSpecifiedResultCode) { for (bool endian_swap : kSwapEndians) { const auto words = CompileSuccessfully( "%1 = OpTypeVoid " "%2 = OpTypeInt 32 1"); InSequence calls_expected_in_specific_order; EXPECT_HEADER(3).WillOnce(Return(SPV_REQUESTED_TERMINATION)); // Early exit means no calls to Instruction(). EXPECT_CALL(client_, Instruction(_)).Times(0); Parse(words, SPV_REQUESTED_TERMINATION, endian_swap); // On early termination, the binary parser doesn't generate its own // diagnostics. EXPECT_EQ(nullptr, diagnostic_); } } TEST_F(CxxBinaryParseTest, EarlyReturnWithZeroPassingCallbacksAndSpecifiedResultCode) { for (bool endian_swap : kSwapEndians) { const auto words = CompileSuccessfully( "%1 = OpTypeVoid " "%2 = OpTypeInt 32 1"); InSequence calls_expected_in_specific_order; EXPECT_HEADER(3).WillOnce(Return(SPV_REQUESTED_TERMINATION)); // Early exit means no calls to Instruction(). EXPECT_CALL(client_, Instruction(_)).Times(0); Parse(words, false, endian_swap); // On early termination, the binary parser doesn't generate its own // diagnostics. EXPECT_EQ(nullptr, diagnostic_); } } TEST_F(BinaryParseTest, EarlyReturnWithOnePassingCallback) { for (bool endian_swap : kSwapEndians) { const auto words = CompileSuccessfully( "%1 = OpTypeVoid " "%2 = OpTypeInt 32 1 " "%3 = OpTypeFloat 32"); InSequence calls_expected_in_specific_order; EXPECT_HEADER(4).WillOnce(Return(SPV_SUCCESS)); EXPECT_CALL(client_, Instruction(MakeParsedVoidTypeInstruction(1))) .WillOnce(Return(SPV_REQUESTED_TERMINATION)); Parse(words, SPV_REQUESTED_TERMINATION, endian_swap); // On early termination, the binary parser doesn't generate its own // diagnostics. EXPECT_EQ(nullptr, diagnostic_); } } TEST_F(CxxBinaryParseTest, EarlyReturnWithOnePassingCallback) { for (bool endian_swap : kSwapEndians) { const auto words = CompileSuccessfully( "%1 = OpTypeVoid " "%2 = OpTypeInt 32 1 " "%3 = OpTypeFloat 32"); InSequence calls_expected_in_specific_order; EXPECT_HEADER(4).WillOnce(Return(SPV_SUCCESS)); EXPECT_CALL(client_, Instruction(MakeParsedVoidTypeInstruction(1))) .WillOnce(Return(SPV_REQUESTED_TERMINATION)); Parse(words, false, endian_swap); // On early termination, the binary parser doesn't generate its own // diagnostics. EXPECT_EQ(nullptr, diagnostic_); } } TEST_F(BinaryParseTest, EarlyReturnWithTwoPassingCallbacks) { for (bool endian_swap : kSwapEndians) { const auto words = CompileSuccessfully( "%1 = OpTypeVoid " "%2 = OpTypeInt 32 1 " "%3 = OpTypeFloat 32"); InSequence calls_expected_in_specific_order; EXPECT_HEADER(4).WillOnce(Return(SPV_SUCCESS)); EXPECT_CALL(client_, Instruction(MakeParsedVoidTypeInstruction(1))) .WillOnce(Return(SPV_SUCCESS)); EXPECT_CALL(client_, Instruction(MakeParsedInt32TypeInstruction(2))) .WillOnce(Return(SPV_REQUESTED_TERMINATION)); Parse(words, SPV_REQUESTED_TERMINATION, endian_swap); // On early termination, the binary parser doesn't generate its own // diagnostics. EXPECT_EQ(nullptr, diagnostic_); } } TEST_F(CxxBinaryParseTest, EarlyReturnWithTwoPassingCallbacks) { for (bool endian_swap : kSwapEndians) { const auto words = CompileSuccessfully( "%1 = OpTypeVoid " "%2 = OpTypeInt 32 1 " "%3 = OpTypeFloat 32"); InSequence calls_expected_in_specific_order; EXPECT_HEADER(4).WillOnce(Return(SPV_SUCCESS)); EXPECT_CALL(client_, Instruction(MakeParsedVoidTypeInstruction(1))) .WillOnce(Return(SPV_SUCCESS)); EXPECT_CALL(client_, Instruction(MakeParsedInt32TypeInstruction(2))) .WillOnce(Return(SPV_REQUESTED_TERMINATION)); Parse(words, false, endian_swap); // On early termination, the binary parser doesn't generate its own // diagnostics. EXPECT_EQ(nullptr, diagnostic_); } } TEST_F(BinaryParseTest, InstructionWithStringOperand) { for (bool endian_swap : kSwapEndians) { const std::string str = "the future is already here, it's just not evenly distributed"; const auto str_words = MakeVector(str); const auto instruction = MakeInstruction(spv::Op::OpName, {99}, str_words); const auto words = Concatenate({ExpectedHeaderForBound(100), instruction}); InSequence calls_expected_in_specific_order; EXPECT_HEADER(100).WillOnce(Return(SPV_SUCCESS)); const auto operands = std::vector{ MakeSimpleOperand(1, SPV_OPERAND_TYPE_ID), MakeLiteralStringOperand(2, static_cast(str_words.size()))}; EXPECT_CALL( client_, Instruction(ParsedInstruction(spv_parsed_instruction_t{ instruction.data(), static_cast(instruction.size()), uint16_t(spv::Op::OpName), SPV_EXT_INST_TYPE_NONE, 0 /*type id*/, 0 /* No result id for OpName*/, operands.data(), static_cast(operands.size())}))) .WillOnce(Return(SPV_SUCCESS)); Parse(words, SPV_SUCCESS, endian_swap); EXPECT_EQ(nullptr, diagnostic_); } } TEST_F(CxxBinaryParseTest, InstructionWithStringOperand) { for (bool endian_swap : kSwapEndians) { const std::string str = "the future is already here, it's just not evenly distributed"; const auto str_words = MakeVector(str); const auto instruction = MakeInstruction(spv::Op::OpName, {99}, str_words); const auto words = Concatenate({ExpectedHeaderForBound(100), instruction}); InSequence calls_expected_in_specific_order; EXPECT_HEADER(100).WillOnce(Return(SPV_SUCCESS)); const auto operands = std::vector{ MakeSimpleOperand(1, SPV_OPERAND_TYPE_ID), MakeLiteralStringOperand(2, static_cast(str_words.size()))}; EXPECT_CALL( client_, Instruction(ParsedInstruction(spv_parsed_instruction_t{ instruction.data(), static_cast(instruction.size()), uint16_t(spv::Op::OpName), SPV_EXT_INST_TYPE_NONE, 0 /*type id*/, 0 /* No result id for OpName*/, operands.data(), static_cast(operands.size())}))) .WillOnce(Return(SPV_SUCCESS)); Parse(words, true, endian_swap); EXPECT_EQ(nullptr, diagnostic_); } } // Checks for non-zero values for the result_id and ext_inst_type members // spv_parsed_instruction_t. TEST_F(BinaryParseTest, ExtendedInstruction) { const auto words = CompileSuccessfully( "%extcl = OpExtInstImport \"OpenCL.std\" " "%result = OpExtInst %float %extcl sqrt %x"); EXPECT_HEADER(5).WillOnce(Return(SPV_SUCCESS)); EXPECT_CALL(client_, Instruction(_)).WillOnce(Return(SPV_SUCCESS)); // We're only interested in the second call to Instruction(): const auto operands = std::vector{ MakeSimpleOperand(1, SPV_OPERAND_TYPE_TYPE_ID), MakeSimpleOperand(2, SPV_OPERAND_TYPE_RESULT_ID), MakeSimpleOperand(3, SPV_OPERAND_TYPE_ID), // Extended instruction set Id MakeSimpleOperand(4, SPV_OPERAND_TYPE_EXTENSION_INSTRUCTION_NUMBER), MakeSimpleOperand(5, SPV_OPERAND_TYPE_ID), // Id of the argument }; const auto instruction = MakeInstruction( spv::Op::OpExtInst, {2, 3, 1, static_cast(OpenCLLIB::Entrypoints::Sqrt), 4}); EXPECT_CALL(client_, Instruction(ParsedInstruction(spv_parsed_instruction_t{ instruction.data(), static_cast(instruction.size()), uint16_t(spv::Op::OpExtInst), SPV_EXT_INST_TYPE_OPENCL_STD, 2 /*type id*/, 3 /*result id*/, operands.data(), static_cast(operands.size())}))) .WillOnce(Return(SPV_SUCCESS)); // Since we are actually checking the output, don't test the // endian-swapped version. Parse(words, SPV_SUCCESS, false); EXPECT_EQ(nullptr, diagnostic_); } TEST_F(CxxBinaryParseTest, ExtendedInstruction) { const auto words = CompileSuccessfully( "%extcl = OpExtInstImport \"OpenCL.std\" " "%result = OpExtInst %float %extcl sqrt %x"); EXPECT_HEADER(5).WillOnce(Return(SPV_SUCCESS)); EXPECT_CALL(client_, Instruction(_)).WillOnce(Return(SPV_SUCCESS)); // We're only interested in the second call to Instruction(): const auto operands = std::vector{ MakeSimpleOperand(1, SPV_OPERAND_TYPE_TYPE_ID), MakeSimpleOperand(2, SPV_OPERAND_TYPE_RESULT_ID), MakeSimpleOperand(3, SPV_OPERAND_TYPE_ID), // Extended instruction set Id MakeSimpleOperand(4, SPV_OPERAND_TYPE_EXTENSION_INSTRUCTION_NUMBER), MakeSimpleOperand(5, SPV_OPERAND_TYPE_ID), // Id of the argument }; const auto instruction = MakeInstruction( spv::Op::OpExtInst, {2, 3, 1, static_cast(OpenCLLIB::Entrypoints::Sqrt), 4}); EXPECT_CALL(client_, Instruction(ParsedInstruction(spv_parsed_instruction_t{ instruction.data(), static_cast(instruction.size()), uint16_t(spv::Op::OpExtInst), SPV_EXT_INST_TYPE_OPENCL_STD, 2 /*type id*/, 3 /*result id*/, operands.data(), static_cast(operands.size())}))) .WillOnce(Return(SPV_SUCCESS)); // Since we are actually checking the output, don't test the // endian-swapped version. Parse(words, true, false); EXPECT_EQ(nullptr, diagnostic_); } // A binary parser diagnostic test case where we provide the words array // pointer and word count explicitly. struct WordsAndCountDiagnosticCase { const uint32_t* words; size_t num_words; std::string expected_diagnostic; }; using BinaryParseWordsAndCountDiagnosticTest = spvtest::TextToBinaryTestBase< ::testing::TestWithParam>; TEST_P(BinaryParseWordsAndCountDiagnosticTest, WordAndCountCases) { EXPECT_EQ( SPV_ERROR_INVALID_BINARY, spvBinaryParse(ScopedContext().context, nullptr, GetParam().words, GetParam().num_words, nullptr, nullptr, &diagnostic)); ASSERT_NE(nullptr, diagnostic); EXPECT_THAT(diagnostic->error, Eq(GetParam().expected_diagnostic)); } INSTANTIATE_TEST_SUITE_P( BinaryParseDiagnostic, BinaryParseWordsAndCountDiagnosticTest, ::testing::ValuesIn(std::vector{ {nullptr, 0, "Missing module."}, {kHeaderForBound1, 0, "Module has incomplete header: only 0 words instead of 5"}, {kHeaderForBound1, 1, "Module has incomplete header: only 1 words instead of 5"}, {kHeaderForBound1, 2, "Module has incomplete header: only 2 words instead of 5"}, {kHeaderForBound1, 3, "Module has incomplete header: only 3 words instead of 5"}, {kHeaderForBound1, 4, "Module has incomplete header: only 4 words instead of 5"}, })); // A binary parser diagnostic test case where a vector of words is // provided. We'll use this to express cases that can't be created // via the assembler. Either we want to make a malformed instruction, // or an invalid case the assembler would reject. struct WordVectorDiagnosticCase { std::vector words; std::string expected_diagnostic; }; using BinaryParseWordVectorDiagnosticTest = spvtest::TextToBinaryTestBase< ::testing::TestWithParam>; TEST_P(BinaryParseWordVectorDiagnosticTest, WordVectorCases) { const auto& words = GetParam().words; EXPECT_THAT(spvBinaryParse(ScopedContext().context, nullptr, words.data(), words.size(), nullptr, nullptr, &diagnostic), AnyOf(SPV_ERROR_INVALID_BINARY, SPV_ERROR_INVALID_ID)); ASSERT_NE(nullptr, diagnostic); EXPECT_THAT(diagnostic->error, Eq(GetParam().expected_diagnostic)); } INSTANTIATE_TEST_SUITE_P( BinaryParseDiagnostic, BinaryParseWordVectorDiagnosticTest, ::testing::ValuesIn(std::vector{ {Concatenate({ExpectedHeaderForBound(1), {spvOpcodeMake(0, spv::Op::OpNop)}}), "Invalid instruction word count: 0"}, {Concatenate( {ExpectedHeaderForBound(1), {spvOpcodeMake(1, static_cast( std::numeric_limits::max()))}}), "Invalid opcode: 65535"}, {Concatenate({ExpectedHeaderForBound(1), MakeInstruction(spv::Op::OpNop, {42})}), "Invalid instruction OpNop starting at word 5: expected " "no more operands after 1 words, but stated word count is 2."}, // Supply several more unexpected words. {Concatenate({ExpectedHeaderForBound(1), MakeInstruction(spv::Op::OpNop, {42, 43, 44, 45, 46, 47})}), "Invalid instruction OpNop starting at word 5: expected " "no more operands after 1 words, but stated word count is 7."}, {Concatenate({ExpectedHeaderForBound(1), MakeInstruction(spv::Op::OpTypeVoid, {1, 2})}), "Invalid instruction OpTypeVoid starting at word 5: expected " "no more operands after 2 words, but stated word count is 3."}, {Concatenate({ExpectedHeaderForBound(1), MakeInstruction(spv::Op::OpTypeVoid, {1, 2, 5, 9, 10})}), "Invalid instruction OpTypeVoid starting at word 5: expected " "no more operands after 2 words, but stated word count is 6."}, {Concatenate({ExpectedHeaderForBound(1), MakeInstruction(spv::Op::OpTypeInt, {1, 32, 1, 9})}), "Invalid instruction OpTypeInt starting at word 5: expected " "no more operands after 4 words, but stated word count is 5."}, {Concatenate({ExpectedHeaderForBound(1), MakeInstruction(spv::Op::OpTypeInt, {1})}), "End of input reached while decoding OpTypeInt starting at word 5:" " expected more operands after 2 words."}, // Check several cases for running off the end of input. // Detect a missing single word operand. {Concatenate({ExpectedHeaderForBound(1), {spvOpcodeMake(2, spv::Op::OpTypeStruct)}}), "End of input reached while decoding OpTypeStruct starting at word" " 5: missing result ID operand at word offset 1."}, // Detect this a missing a multi-word operand to OpConstant. // We also lie and say the OpConstant instruction has 5 words when // it only has 3. Corresponds to something like this: // %1 = OpTypeInt 64 0 // %2 = OpConstant %1 {Concatenate({ExpectedHeaderForBound(3), {MakeInstruction(spv::Op::OpTypeInt, {1, 64, 0})}, {spvOpcodeMake(5, spv::Op::OpConstant), 1, 2}}), "End of input reached while decoding OpConstant starting at word" " 9: missing possibly multi-word literal number operand at word " "offset 3."}, // Detect when we provide only one word from the 64-bit literal, // and again lie about the number of words in the instruction. {Concatenate({ExpectedHeaderForBound(3), {MakeInstruction(spv::Op::OpTypeInt, {1, 64, 0})}, {spvOpcodeMake(5, spv::Op::OpConstant), 1, 2, 42}}), "End of input reached while decoding OpConstant starting at word" " 9: truncated possibly multi-word literal number operand at word " "offset 3."}, // Detect when a required string operand is missing. // Also, lie about the length of the instruction. {Concatenate({ExpectedHeaderForBound(3), {spvOpcodeMake(3, spv::Op::OpString), 1}}), "End of input reached while decoding OpString starting at word" " 5: missing literal string operand at word offset 2."}, // Detect when a required string operand is truncated: it's missing // a null terminator. Catching the error avoids a buffer overrun. {Concatenate({ExpectedHeaderForBound(3), {spvOpcodeMake(4, spv::Op::OpString), 1, 0x41414141, 0x41414141}}), "End of input reached while decoding OpString starting at word" " 5: truncated literal string operand at word offset 2."}, // Detect when an optional string operand is truncated: it's missing // a null terminator. Catching the error avoids a buffer overrun. // (It is valid for an optional string operand to be absent.) {Concatenate({ExpectedHeaderForBound(3), {spvOpcodeMake(6, spv::Op::OpSource), static_cast(spv::SourceLanguage::OpenCL_C), 210, 1 /* file id */, /*start of string*/ 0x41414141, 0x41414141}}), "End of input reached while decoding OpSource starting at word" " 5: truncated literal string operand at word offset 4."}, // (End of input exhaustion test cases.) // In this case the instruction word count is too small, where // it would truncate a multi-word operand to OpConstant. {Concatenate({ExpectedHeaderForBound(3), {MakeInstruction(spv::Op::OpTypeInt, {1, 64, 0})}, {spvOpcodeMake(4, spv::Op::OpConstant), 1, 2, 44, 44}}), "Invalid word count: OpConstant starting at word 9 says it has 4" " words, but found 5 words instead."}, // Word count is to small, where it would truncate a literal string. {Concatenate({ExpectedHeaderForBound(2), {spvOpcodeMake(3, spv::Op::OpString), 1, 0x41414141, 0}}), "Invalid word count: OpString starting at word 5 says it has 3" " words, but found 4 words instead."}, // Word count is too large. The string terminates before the last // word. {Concatenate({ExpectedHeaderForBound(2), {spvOpcodeMake(4, spv::Op::OpString), 1 /* result id */}, MakeVector("abc"), {0 /* this word does not belong*/}}), "Invalid instruction OpString starting at word 5: expected no more" " operands after 3 words, but stated word count is 4."}, // Word count is too large. There are too many words after the string // literal. A linkage attribute decoration is the only case in SPIR-V // where a string operand is followed by another operand. {Concatenate( {ExpectedHeaderForBound(2), {spvOpcodeMake(6, spv::Op::OpDecorate), 1 /* target id */, static_cast(spv::Decoration::LinkageAttributes)}, MakeVector("abc"), {static_cast(spv::LinkageType::Import), 0 /* does not belong */}}), "Invalid instruction OpDecorate starting at word 5: expected no more" " operands after 5 words, but stated word count is 6."}, // Like the previous case, but with 5 extra words. {Concatenate( {ExpectedHeaderForBound(2), {spvOpcodeMake(10, spv::Op::OpDecorate), 1 /* target id */, static_cast(spv::Decoration::LinkageAttributes)}, MakeVector("abc"), {static_cast(spv::LinkageType::Import), /* don't belong */ 0, 1, 2, 3, 4}}), "Invalid instruction OpDecorate starting at word 5: expected no more" " operands after 5 words, but stated word count is 10."}, // Like the previous two cases, but with OpMemberDecorate. {Concatenate( {ExpectedHeaderForBound(2), {spvOpcodeMake(7, spv::Op::OpMemberDecorate), 1 /* target id */, 42 /* member index */, static_cast(spv::Decoration::LinkageAttributes)}, MakeVector("abc"), {static_cast(spv::LinkageType::Import), 0 /* does not belong */}}), "Invalid instruction OpMemberDecorate starting at word 5: expected no" " more operands after 6 words, but stated word count is 7."}, {Concatenate( {ExpectedHeaderForBound(2), {spvOpcodeMake(11, spv::Op::OpMemberDecorate), 1 /* target id */, 42 /* member index */, static_cast(spv::Decoration::LinkageAttributes)}, MakeVector("abc"), {static_cast(spv::LinkageType::Import), /* don't belong */ 0, 1, 2, 3, 4}}), "Invalid instruction OpMemberDecorate starting at word 5: expected no" " more operands after 6 words, but stated word count is 11."}, // Word count is too large. There should be no more words // after the RelaxedPrecision decoration. {Concatenate({ExpectedHeaderForBound(2), {spvOpcodeMake(4, spv::Op::OpDecorate), 1 /* target id */, static_cast(spv::Decoration::RelaxedPrecision), 0 /* does not belong */}}), "Invalid instruction OpDecorate starting at word 5: expected no" " more operands after 3 words, but stated word count is 4."}, // Word count is too large. There should be only one word after // the SpecId decoration enum word. {Concatenate({ExpectedHeaderForBound(2), {spvOpcodeMake(5, spv::Op::OpDecorate), 1 /* target id */, static_cast(spv::Decoration::SpecId), 42 /* the spec id */, 0 /* does not belong */}}), "Invalid instruction OpDecorate starting at word 5: expected no" " more operands after 4 words, but stated word count is 5."}, {Concatenate({ExpectedHeaderForBound(2), {spvOpcodeMake(2, spv::Op::OpTypeVoid), 0}}), "Error: Result Id is 0"}, {Concatenate({ ExpectedHeaderForBound(2), {spvOpcodeMake(2, spv::Op::OpTypeVoid), 1}, {spvOpcodeMake(2, spv::Op::OpTypeBool), 1}, }), "Id 1 is defined more than once"}, {Concatenate({ExpectedHeaderForBound(3), MakeInstruction(spv::Op::OpExtInst, {2, 3, 100, 4, 5})}), "OpExtInst set Id 100 does not reference an OpExtInstImport result " "Id"}, {Concatenate({ExpectedHeaderForBound(101), MakeInstruction(spv::Op::OpExtInstImport, {100}, MakeVector("OpenCL.std")), // OpenCL cos is #14 MakeInstruction(spv::Op::OpExtInst, {2, 3, 100, 14, 5, 999})}), "Invalid instruction OpExtInst starting at word 10: expected no " "more operands after 6 words, but stated word count is 7."}, // In this case, the OpSwitch selector refers to an invalid ID. {Concatenate({ExpectedHeaderForBound(3), MakeInstruction(spv::Op::OpSwitch, {1, 2, 42, 3})}), "Invalid OpSwitch: selector id 1 has no type"}, // In this case, the OpSwitch selector refers to an ID that has // no type. {Concatenate({ExpectedHeaderForBound(3), MakeInstruction(spv::Op::OpLabel, {1}), MakeInstruction(spv::Op::OpSwitch, {1, 2, 42, 3})}), "Invalid OpSwitch: selector id 1 has no type"}, {Concatenate({ExpectedHeaderForBound(3), MakeInstruction(spv::Op::OpTypeInt, {1, 32, 0}), MakeInstruction(spv::Op::OpSwitch, {1, 3, 42, 3})}), "Invalid OpSwitch: selector id 1 is a type, not a value"}, {Concatenate({ExpectedHeaderForBound(3), MakeInstruction(spv::Op::OpTypeFloat, {1, 32}), MakeInstruction(spv::Op::OpConstant, {1, 2, 0x78f00000}), MakeInstruction(spv::Op::OpSwitch, {2, 3, 42, 3})}), "Invalid OpSwitch: selector id 2 is not a scalar integer"}, {Concatenate({ExpectedHeaderForBound(3), MakeInstruction(spv::Op::OpExtInstImport, {1}, MakeVector("invalid-import"))}), "Invalid extended instruction import 'invalid-import'"}, {Concatenate({ ExpectedHeaderForBound(3), MakeInstruction(spv::Op::OpTypeInt, {1, 32, 0}), MakeInstruction(spv::Op::OpConstant, {2, 2, 42}), }), "Type Id 2 is not a type"}, {Concatenate({ ExpectedHeaderForBound(3), MakeInstruction(spv::Op::OpTypeBool, {1}), MakeInstruction(spv::Op::OpConstant, {1, 2, 42}), }), "Type Id 1 is not a scalar numeric type"}, })); // A binary parser diagnostic case generated from an assembly text input. struct AssemblyDiagnosticCase { std::string assembly; std::string expected_diagnostic; }; using BinaryParseAssemblyDiagnosticTest = spvtest::TextToBinaryTestBase< ::testing::TestWithParam>; TEST_P(BinaryParseAssemblyDiagnosticTest, AssemblyCases) { auto words = CompileSuccessfully(GetParam().assembly); EXPECT_THAT(spvBinaryParse(ScopedContext().context, nullptr, words.data(), words.size(), nullptr, nullptr, &diagnostic), AnyOf(SPV_ERROR_INVALID_BINARY, SPV_ERROR_INVALID_ID)); ASSERT_NE(nullptr, diagnostic); EXPECT_THAT(diagnostic->error, Eq(GetParam().expected_diagnostic)); } INSTANTIATE_TEST_SUITE_P( BinaryParseDiagnostic, BinaryParseAssemblyDiagnosticTest, ::testing::ValuesIn(std::vector{ {"%1 = OpConstant !0 42", "Error: Type Id is 0"}, // A required id is 0. {"OpName !0 \"foo\"", "Id is 0"}, // An optional id is 0, in this case the optional // initializer. {"%2 = OpVariable %1 CrossWorkgroup !0", "Id is 0"}, {"OpControlBarrier !0 %1 %2", "scope ID is 0"}, {"OpControlBarrier %1 !0 %2", "scope ID is 0"}, {"OpControlBarrier %1 %2 !0", "memory semantics ID is 0"}, {"%import = OpExtInstImport \"GLSL.std.450\" " "%result = OpExtInst %type %import !999999 %x", "Invalid extended instruction number: 999999"}, {"%2 = OpSpecConstantOp %1 !1000 %2", "Invalid OpSpecConstantOp opcode: 1000"}, {"OpCapability !9999", "Invalid capability operand: 9999"}, {"OpSource !9999 100", "Invalid source language operand: 9999, if you are creating a new " "source language please use value 0 (Unknown) and when ready, add " "your source language to SPIRV-Headers"}, {"OpEntryPoint !9999", "Invalid execution model operand: 9999"}, {"OpMemoryModel !9999", "Invalid addressing model operand: 9999"}, {"OpMemoryModel Logical !9999", "Invalid memory model operand: 9999"}, {"OpExecutionMode %1 !9999", "Invalid execution mode operand: 9999"}, {"OpTypeForwardPointer %1 !9999", "Invalid storage class operand: 9999"}, {"%2 = OpTypeImage %1 !9999", "Invalid dimensionality operand: 9999"}, {"%2 = OpTypeImage %1 1D 0 0 0 0 !9999", "Invalid image format operand: 9999"}, {"OpDecorate %1 FPRoundingMode !9999", "Invalid floating-point rounding mode operand: 9999"}, {"OpDecorate %1 LinkageAttributes \"C\" !9999", "Invalid linkage type operand: 9999"}, {"%1 = OpTypePipe !9999", "Invalid access qualifier operand: 9999"}, {"OpDecorate %1 FuncParamAttr !9999", "Invalid function parameter attribute operand: 9999"}, {"OpDecorate %1 !9999", "Invalid decoration operand: 9999"}, {"OpDecorate %1 BuiltIn !9999", "Invalid built-in operand: 9999"}, {"%2 = OpGroupIAdd %1 %3 !9999", "Invalid group operation operand: 9999"}, {"OpDecorate %1 FPFastMathMode !63", "Invalid floating-point fast math mode operand: 63 has invalid mask " "component 32"}, {"%2 = OpFunction %2 !31", "Invalid function control operand: 31 has invalid mask component 16"}, {"OpLoopMerge %1 %2 !1027", "Invalid loop control operand: 1027 has invalid mask component 1024"}, {"%2 = OpImageFetch %1 %image %coord !32770", "Invalid image operand: 32770 has invalid mask component 32768"}, {"OpSelectionMerge %1 !7", "Invalid selection control operand: 7 has invalid mask component 4"}, })); } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/binary_strnlen_s_test.cpp000066400000000000000000000020541475742701700246270ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "test/unit_spirv.h" namespace spvtools { namespace { TEST(Strnlen, Samples) { EXPECT_EQ(0u, spv_strnlen_s(nullptr, 0)); EXPECT_EQ(0u, spv_strnlen_s(nullptr, 5)); EXPECT_EQ(0u, spv_strnlen_s("abc", 0)); EXPECT_EQ(1u, spv_strnlen_s("abc", 1)); EXPECT_EQ(3u, spv_strnlen_s("abc", 3)); EXPECT_EQ(3u, spv_strnlen_s("abc\0", 5)); EXPECT_EQ(0u, spv_strnlen_s("\0", 5)); EXPECT_EQ(1u, spv_strnlen_s("a\0c", 5)); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/binary_to_text.literal_test.cpp000066400000000000000000000066501475742701700257470ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include "gmock/gmock.h" #include "test/test_fixture.h" #include "test/unit_spirv.h" namespace spvtools { namespace { using ::testing::Eq; using RoundTripLiteralsTest = spvtest::TextToBinaryTestBase<::testing::TestWithParam>; static const bool kSwapEndians[] = {false, true}; TEST_P(RoundTripLiteralsTest, Sample) { for (bool endian_swap : kSwapEndians) { EXPECT_THAT( EncodeAndDecodeSuccessfully(GetParam(), SPV_BINARY_TO_TEXT_OPTION_NONE, SPV_TEXT_TO_BINARY_OPTION_NONE, SPV_ENV_UNIVERSAL_1_0, endian_swap), Eq(GetParam())); } } // clang-format off INSTANTIATE_TEST_SUITE_P( StringLiterals, RoundTripLiteralsTest, ::testing::ValuesIn(std::vector{ "OpName %1 \"\"\n", // empty "OpName %1 \"foo\"\n", // normal "OpName %1 \"foo bar\"\n", // string with spaces "OpName %1 \"foo\tbar\"\n", // string with tab "OpName %1 \"\tfoo\"\n", // starts with tab "OpName %1 \" foo\"\n", // starts with space "OpName %1 \"foo \"\n", // ends with space "OpName %1 \"foo\t\"\n", // ends with tab "OpName %1 \"foo\nbar\"\n", // contains newline "OpName %1 \"\nfoo\nbar\"\n", // starts with newline "OpName %1 \"\n\n\nfoo\nbar\"\n", // multiple newlines "OpName %1 \"\\\"foo\nbar\\\"\"\n", // escaped quote "OpName %1 \"\\\\foo\nbar\\\\\"\n", // escaped backslash "OpName %1 \"\xE4\xBA\xB2\"\n", // UTF-8 })); // clang-format on using RoundTripSpecialCaseLiteralsTest = spvtest::TextToBinaryTestBase< ::testing::TestWithParam>>; // Test case where the generated disassembly is not the same as the // assembly passed in. TEST_P(RoundTripSpecialCaseLiteralsTest, Sample) { for (bool endian_swap : kSwapEndians) { EXPECT_THAT(EncodeAndDecodeSuccessfully(std::get<0>(GetParam()), SPV_BINARY_TO_TEXT_OPTION_NONE, SPV_TEXT_TO_BINARY_OPTION_NONE, SPV_ENV_UNIVERSAL_1_0, endian_swap), Eq(std::get<1>(GetParam()))); } } // clang-format off INSTANTIATE_TEST_SUITE_P( StringLiterals, RoundTripSpecialCaseLiteralsTest, ::testing::ValuesIn(std::vector>{ {"OpName %1 \"\\foo\"\n", "OpName %1 \"foo\"\n"}, // Escape f {"OpName %1 \"\\\nfoo\"\n", "OpName %1 \"\nfoo\"\n"}, // Escape newline {"OpName %1 \"\\\xE4\xBA\xB2\"\n", "OpName %1 \"\xE4\xBA\xB2\"\n"}, // Escape utf-8 })); // clang-format on } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/binary_to_text_test.cpp000066400000000000000000002663761475742701700243310ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include #include "gmock/gmock.h" #include "source/spirv_constant.h" #include "test/test_fixture.h" #include "test/unit_spirv.h" namespace spvtools { namespace { using spvtest::AutoText; using spvtest::ScopedContext; using spvtest::TextToBinaryTest; using ::testing::Combine; using ::testing::Eq; using ::testing::HasSubstr; class BinaryToText : public ::testing::Test { public: BinaryToText() : context(spvContextCreate(SPV_ENV_UNIVERSAL_1_0)), binary(nullptr) {} ~BinaryToText() override { spvBinaryDestroy(binary); spvContextDestroy(context); } void SetUp() override { const char* textStr = R"( OpSource OpenCL_C 12 OpMemoryModel Physical64 OpenCL OpSourceExtension "PlaceholderExtensionName" OpEntryPoint Kernel %1 "foo" OpExecutionMode %1 LocalSizeHint 1 1 1 %2 = OpTypeVoid %3 = OpTypeBool %4 = OpTypeInt 8 0 %5 = OpTypeInt 8 1 %6 = OpTypeInt 16 0 %7 = OpTypeInt 16 1 %8 = OpTypeInt 32 0 %9 = OpTypeInt 32 1 %10 = OpTypeInt 64 0 %11 = OpTypeInt 64 1 %12 = OpTypeFloat 16 %13 = OpTypeFloat 32 %14 = OpTypeFloat 64 %15 = OpTypeVector %4 2 )"; spv_text_t text = {textStr, strlen(textStr)}; spv_diagnostic diagnostic = nullptr; spv_result_t error = spvTextToBinary(context, text.str, text.length, &binary, &diagnostic); spvDiagnosticPrint(diagnostic); spvDiagnosticDestroy(diagnostic); ASSERT_EQ(SPV_SUCCESS, error); } void TearDown() override { spvBinaryDestroy(binary); binary = nullptr; } // Compiles the given assembly text, and saves it into 'binary'. void CompileSuccessfully(std::string text) { spvBinaryDestroy(binary); binary = nullptr; spv_diagnostic diagnostic = nullptr; EXPECT_EQ(SPV_SUCCESS, spvTextToBinary(context, text.c_str(), text.size(), &binary, &diagnostic)); } spv_context context; spv_binary binary; }; TEST_F(BinaryToText, Default) { spv_text text = nullptr; spv_diagnostic diagnostic = nullptr; ASSERT_EQ( SPV_SUCCESS, spvBinaryToText(context, binary->code, binary->wordCount, SPV_BINARY_TO_TEXT_OPTION_NONE, &text, &diagnostic)); printf("%s", text->str); spvTextDestroy(text); } TEST_F(BinaryToText, Print) { spv_text text = nullptr; spv_diagnostic diagnostic = nullptr; ASSERT_EQ( SPV_SUCCESS, spvBinaryToText(context, binary->code, binary->wordCount, SPV_BINARY_TO_TEXT_OPTION_PRINT, &text, &diagnostic)); ASSERT_EQ(text, nullptr); spvTextDestroy(text); } TEST_F(BinaryToText, MissingModule) { spv_text text; spv_diagnostic diagnostic = nullptr; EXPECT_EQ( SPV_ERROR_INVALID_BINARY, spvBinaryToText(context, nullptr, 42, SPV_BINARY_TO_TEXT_OPTION_NONE, &text, &diagnostic)); EXPECT_THAT(diagnostic->error, Eq(std::string("Missing module."))); if (diagnostic) { spvDiagnosticPrint(diagnostic); spvDiagnosticDestroy(diagnostic); } } TEST_F(BinaryToText, TruncatedModule) { // Make a valid module with zero instructions. CompileSuccessfully(""); EXPECT_EQ(SPV_INDEX_INSTRUCTION, binary->wordCount); for (size_t length = 0; length < SPV_INDEX_INSTRUCTION; length++) { spv_text text = nullptr; spv_diagnostic diagnostic = nullptr; EXPECT_EQ( SPV_ERROR_INVALID_BINARY, spvBinaryToText(context, binary->code, length, SPV_BINARY_TO_TEXT_OPTION_NONE, &text, &diagnostic)); ASSERT_NE(nullptr, diagnostic); std::stringstream expected; expected << "Module has incomplete header: only " << length << " words instead of " << SPV_INDEX_INSTRUCTION; EXPECT_THAT(diagnostic->error, Eq(expected.str())); spvDiagnosticDestroy(diagnostic); } } TEST_F(BinaryToText, InvalidMagicNumber) { CompileSuccessfully(""); std::vector damaged_binary(binary->code, binary->code + binary->wordCount); damaged_binary[SPV_INDEX_MAGIC_NUMBER] ^= 123; spv_diagnostic diagnostic = nullptr; spv_text text; EXPECT_EQ( SPV_ERROR_INVALID_BINARY, spvBinaryToText(context, damaged_binary.data(), damaged_binary.size(), SPV_BINARY_TO_TEXT_OPTION_NONE, &text, &diagnostic)); ASSERT_NE(nullptr, diagnostic); std::stringstream expected; expected << "Invalid SPIR-V magic number '" << std::hex << damaged_binary[SPV_INDEX_MAGIC_NUMBER] << "'."; EXPECT_THAT(diagnostic->error, Eq(expected.str())); spvDiagnosticDestroy(diagnostic); } struct FailedDecodeCase { std::string source_text; std::vector appended_instruction; std::string expected_error_message; }; using BinaryToTextFail = spvtest::TextToBinaryTestBase<::testing::TestWithParam>; TEST_P(BinaryToTextFail, EncodeSuccessfullyDecodeFailed) { EXPECT_THAT(EncodeSuccessfullyDecodeFailed(GetParam().source_text, GetParam().appended_instruction), Eq(GetParam().expected_error_message)); } INSTANTIATE_TEST_SUITE_P( InvalidIds, BinaryToTextFail, ::testing::ValuesIn(std::vector{ {"", spvtest::MakeInstruction(spv::Op::OpTypeVoid, {0}), "Error: Result Id is 0"}, {"", spvtest::MakeInstruction(spv::Op::OpConstant, {0, 1, 42}), "Error: Type Id is 0"}, {"%1 = OpTypeVoid", spvtest::MakeInstruction(spv::Op::OpTypeVoid, {1}), "Id 1 is defined more than once"}, {"%1 = OpTypeVoid\n" "%2 = OpNot %1 %foo", spvtest::MakeInstruction(spv::Op::OpNot, {1, 2, 3}), "Id 2 is defined more than once"}, {"%1 = OpTypeVoid\n" "%2 = OpNot %1 %foo", spvtest::MakeInstruction(spv::Op::OpNot, {1, 1, 3}), "Id 1 is defined more than once"}, // The following are the two failure cases for // Parser::setNumericTypeInfoForType. {"", spvtest::MakeInstruction(spv::Op::OpConstant, {500, 1, 42}), "Type Id 500 is not a type"}, {"%1 = OpTypeInt 32 0\n" "%2 = OpTypeVector %1 4", spvtest::MakeInstruction(spv::Op::OpConstant, {2, 3, 999}), "Type Id 2 is not a scalar numeric type"}, })); INSTANTIATE_TEST_SUITE_P( InvalidIdsCheckedDuringLiteralCaseParsing, BinaryToTextFail, ::testing::ValuesIn(std::vector{ {"", spvtest::MakeInstruction(spv::Op::OpSwitch, {1, 2, 3, 4}), "Invalid OpSwitch: selector id 1 has no type"}, {"%1 = OpTypeVoid\n", spvtest::MakeInstruction(spv::Op::OpSwitch, {1, 2, 3, 4}), "Invalid OpSwitch: selector id 1 is a type, not a value"}, {"%1 = OpConstantTrue !500", spvtest::MakeInstruction(spv::Op::OpSwitch, {1, 2, 3, 4}), "Type Id 500 is not a type"}, {"%1 = OpTypeFloat 32\n%2 = OpConstant %1 1.5", spvtest::MakeInstruction(spv::Op::OpSwitch, {2, 3, 4, 5}), "Invalid OpSwitch: selector id 2 is not a scalar integer"}, })); TEST_F(TextToBinaryTest, OneInstruction) { const std::string input = "OpSource OpenCL_C 12\n"; EXPECT_EQ(input, EncodeAndDecodeSuccessfully(input)); } // Exercise the case where an operand itself has operands. // This could detect problems in updating the expected-set-of-operands // list. TEST_F(TextToBinaryTest, OperandWithOperands) { const std::string input = R"(OpEntryPoint Kernel %1 "foo" OpExecutionMode %1 LocalSizeHint 100 200 300 %2 = OpTypeVoid %3 = OpTypeFunction %2 %1 = OpFunction %1 None %3 )"; EXPECT_EQ(input, EncodeAndDecodeSuccessfully(input)); } using RoundTripInstructionsTest = spvtest::TextToBinaryTestBase< ::testing::TestWithParam>>; TEST_P(RoundTripInstructionsTest, Sample) { EXPECT_THAT(EncodeAndDecodeSuccessfully( std::get<1>(GetParam()), SPV_BINARY_TO_TEXT_OPTION_NONE, SPV_TEXT_TO_BINARY_OPTION_NONE, std::get<0>(GetParam())), Eq(std::get<1>(GetParam()))); } // clang-format off INSTANTIATE_TEST_SUITE_P( NumericLiterals, RoundTripInstructionsTest, // This test is independent of environment, so just test the one. Combine(::testing::Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1, SPV_ENV_UNIVERSAL_1_2, SPV_ENV_UNIVERSAL_1_3), ::testing::ValuesIn(std::vector{ "%1 = OpTypeInt 12 0\n%2 = OpConstant %1 1867\n", "%1 = OpTypeInt 12 1\n%2 = OpConstant %1 1867\n", "%1 = OpTypeInt 12 1\n%2 = OpConstant %1 -1867\n", "%1 = OpTypeInt 32 0\n%2 = OpConstant %1 1867\n", "%1 = OpTypeInt 32 1\n%2 = OpConstant %1 1867\n", "%1 = OpTypeInt 32 1\n%2 = OpConstant %1 -1867\n", "%1 = OpTypeInt 64 0\n%2 = OpConstant %1 18446744073709551615\n", "%1 = OpTypeInt 64 1\n%2 = OpConstant %1 9223372036854775807\n", "%1 = OpTypeInt 64 1\n%2 = OpConstant %1 -9223372036854775808\n", // 16-bit floats print as hex floats. "%1 = OpTypeFloat 16\n%2 = OpConstant %1 0x1.ff4p+16\n", "%1 = OpTypeFloat 16\n%2 = OpConstant %1 -0x1.d2cp-10\n", // 32-bit floats "%1 = OpTypeFloat 32\n%2 = OpConstant %1 -3.125\n", "%1 = OpTypeFloat 32\n%2 = OpConstant %1 0x1.8p+128\n", // NaN "%1 = OpTypeFloat 32\n%2 = OpConstant %1 -0x1.0002p+128\n", // NaN "%1 = OpTypeFloat 32\n%2 = OpConstant %1 0x1p+128\n", // Inf "%1 = OpTypeFloat 32\n%2 = OpConstant %1 -0x1p+128\n", // -Inf // 64-bit floats "%1 = OpTypeFloat 64\n%2 = OpConstant %1 -3.125\n", "%1 = OpTypeFloat 64\n%2 = OpConstant %1 0x1.ffffffffffffap-1023\n", // small normal "%1 = OpTypeFloat 64\n%2 = OpConstant %1 -0x1.ffffffffffffap-1023\n", "%1 = OpTypeFloat 64\n%2 = OpConstant %1 0x1.8p+1024\n", // NaN "%1 = OpTypeFloat 64\n%2 = OpConstant %1 -0x1.0002p+1024\n", // NaN "%1 = OpTypeFloat 64\n%2 = OpConstant %1 0x1p+1024\n", // Inf "%1 = OpTypeFloat 64\n%2 = OpConstant %1 -0x1p+1024\n", // -Inf }))); // clang-format on INSTANTIATE_TEST_SUITE_P( MemoryAccessMasks, RoundTripInstructionsTest, Combine(::testing::Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1, SPV_ENV_UNIVERSAL_1_2, SPV_ENV_UNIVERSAL_1_3), ::testing::ValuesIn(std::vector{ "OpStore %1 %2\n", // 3 words long. "OpStore %1 %2 None\n", // 4 words long, explicit final 0. "OpStore %1 %2 Volatile\n", "OpStore %1 %2 Aligned 8\n", "OpStore %1 %2 Nontemporal\n", // Combinations show the names from LSB to MSB "OpStore %1 %2 Volatile|Aligned 16\n", "OpStore %1 %2 Volatile|Nontemporal\n", "OpStore %1 %2 Volatile|Aligned|Nontemporal 32\n", }))); INSTANTIATE_TEST_SUITE_P( FPFastMathModeMasks, RoundTripInstructionsTest, Combine( ::testing::Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1, SPV_ENV_UNIVERSAL_1_2, SPV_ENV_UNIVERSAL_1_3), ::testing::ValuesIn(std::vector{ "OpDecorate %1 FPFastMathMode None\n", "OpDecorate %1 FPFastMathMode NotNaN\n", "OpDecorate %1 FPFastMathMode NotInf\n", "OpDecorate %1 FPFastMathMode NSZ\n", "OpDecorate %1 FPFastMathMode AllowRecip\n", "OpDecorate %1 FPFastMathMode Fast\n", // Combinations show the names from LSB to MSB "OpDecorate %1 FPFastMathMode NotNaN|NotInf\n", "OpDecorate %1 FPFastMathMode NSZ|AllowRecip\n", "OpDecorate %1 FPFastMathMode NotNaN|NotInf|NSZ|AllowRecip|Fast\n", }))); INSTANTIATE_TEST_SUITE_P( LoopControlMasks, RoundTripInstructionsTest, Combine(::testing::Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1, SPV_ENV_UNIVERSAL_1_3, SPV_ENV_UNIVERSAL_1_2), ::testing::ValuesIn(std::vector{ "OpLoopMerge %1 %2 None\n", "OpLoopMerge %1 %2 Unroll\n", "OpLoopMerge %1 %2 DontUnroll\n", "OpLoopMerge %1 %2 Unroll|DontUnroll\n", }))); INSTANTIATE_TEST_SUITE_P(LoopControlMasksV11, RoundTripInstructionsTest, Combine(::testing::Values(SPV_ENV_UNIVERSAL_1_1, SPV_ENV_UNIVERSAL_1_2, SPV_ENV_UNIVERSAL_1_3), ::testing::ValuesIn(std::vector{ "OpLoopMerge %1 %2 DependencyInfinite\n", "OpLoopMerge %1 %2 DependencyLength 8\n", }))); INSTANTIATE_TEST_SUITE_P( SelectionControlMasks, RoundTripInstructionsTest, Combine(::testing::Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1, SPV_ENV_UNIVERSAL_1_3, SPV_ENV_UNIVERSAL_1_2), ::testing::ValuesIn(std::vector{ "OpSelectionMerge %1 None\n", "OpSelectionMerge %1 Flatten\n", "OpSelectionMerge %1 DontFlatten\n", "OpSelectionMerge %1 Flatten|DontFlatten\n", }))); INSTANTIATE_TEST_SUITE_P( FunctionControlMasks, RoundTripInstructionsTest, Combine(::testing::Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1, SPV_ENV_UNIVERSAL_1_2, SPV_ENV_UNIVERSAL_1_3), ::testing::ValuesIn(std::vector{ "%2 = OpFunction %1 None %3\n", "%2 = OpFunction %1 Inline %3\n", "%2 = OpFunction %1 DontInline %3\n", "%2 = OpFunction %1 Pure %3\n", "%2 = OpFunction %1 Const %3\n", "%2 = OpFunction %1 Inline|Pure|Const %3\n", "%2 = OpFunction %1 DontInline|Const %3\n", }))); INSTANTIATE_TEST_SUITE_P( ImageMasks, RoundTripInstructionsTest, Combine(::testing::Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1, SPV_ENV_UNIVERSAL_1_2, SPV_ENV_UNIVERSAL_1_3), ::testing::ValuesIn(std::vector{ "%2 = OpImageFetch %1 %3 %4\n", "%2 = OpImageFetch %1 %3 %4 None\n", "%2 = OpImageFetch %1 %3 %4 Bias %5\n", "%2 = OpImageFetch %1 %3 %4 Lod %5\n", "%2 = OpImageFetch %1 %3 %4 Grad %5 %6\n", "%2 = OpImageFetch %1 %3 %4 ConstOffset %5\n", "%2 = OpImageFetch %1 %3 %4 Offset %5\n", "%2 = OpImageFetch %1 %3 %4 ConstOffsets %5\n", "%2 = OpImageFetch %1 %3 %4 Sample %5\n", "%2 = OpImageFetch %1 %3 %4 MinLod %5\n", "%2 = OpImageFetch %1 %3 %4 Bias|Lod|Grad %5 %6 %7 %8\n", "%2 = OpImageFetch %1 %3 %4 ConstOffset|Offset|ConstOffsets" " %5 %6 %7\n", "%2 = OpImageFetch %1 %3 %4 Sample|MinLod %5 %6\n", "%2 = OpImageFetch %1 %3 %4" " Bias|Lod|Grad|ConstOffset|Offset|ConstOffsets|Sample|MinLod" " %5 %6 %7 %8 %9 %10 %11 %12 %13\n"}))); INSTANTIATE_TEST_SUITE_P( NewInstructionsInSPIRV1_2, RoundTripInstructionsTest, Combine(::testing::Values(SPV_ENV_UNIVERSAL_1_2, SPV_ENV_UNIVERSAL_1_3), ::testing::ValuesIn(std::vector{ "OpExecutionModeId %1 SubgroupsPerWorkgroupId %2\n", "OpExecutionModeId %1 LocalSizeId %2 %3 %4\n", "OpExecutionModeId %1 LocalSizeHintId %2 %3 %4\n", "OpDecorateId %1 AlignmentId %2\n", "OpDecorateId %1 MaxByteOffsetId %2\n", }))); INSTANTIATE_TEST_SUITE_P( CacheControlsINTEL, RoundTripInstructionsTest, Combine( ::testing::Values(SPV_ENV_UNIVERSAL_1_0), ::testing::ValuesIn(std::vector{ "OpDecorate %1 CacheControlLoadINTEL 0 UncachedINTEL\n", "OpDecorate %1 CacheControlLoadINTEL 1 CachedINTEL\n", "OpDecorate %1 CacheControlLoadINTEL 2 StreamingINTEL\n", "OpDecorate %1 CacheControlLoadINTEL 3 InvalidateAfterReadINTEL\n", "OpDecorate %1 CacheControlLoadINTEL 4 ConstCachedINTEL\n", "OpDecorate %1 CacheControlStoreINTEL 0 UncachedINTEL\n", "OpDecorate %1 CacheControlStoreINTEL 1 WriteThroughINTEL\n", "OpDecorate %1 CacheControlStoreINTEL 2 WriteBackINTEL\n", "OpDecorate %1 CacheControlStoreINTEL 3 StreamingINTEL\n", }))); INSTANTIATE_TEST_SUITE_P( HostAccessINTEL, RoundTripInstructionsTest, Combine(::testing::Values(SPV_ENV_UNIVERSAL_1_0), ::testing::ValuesIn(std::vector{ "OpDecorate %1 HostAccessINTEL NoneINTEL \"none\"\n", "OpDecorate %1 HostAccessINTEL ReadINTEL \"read\"\n", "OpDecorate %1 HostAccessINTEL WriteINTEL \"write\"\n", "OpDecorate %1 HostAccessINTEL ReadWriteINTEL \"readwrite\"\n", }))); // clang-format off INSTANTIATE_TEST_SUITE_P( MatrixMultiplyAccumulateOperands, RoundTripInstructionsTest, Combine(::testing::Values(SPV_ENV_UNIVERSAL_1_0), ::testing::ValuesIn(std::vector{ "%2 = OpSubgroupMatrixMultiplyAccumulateINTEL %1 %3 %4 %5 %6\n", "%2 = OpSubgroupMatrixMultiplyAccumulateINTEL %1 %3 %4 %5 %6 None\n", "%2 = OpSubgroupMatrixMultiplyAccumulateINTEL %1 %3 %4 %5 %6 MatrixASignedComponentsINTEL\n", "%2 = OpSubgroupMatrixMultiplyAccumulateINTEL %1 %3 %4 %5 %6 MatrixBSignedComponentsINTEL\n", "%2 = OpSubgroupMatrixMultiplyAccumulateINTEL %1 %3 %4 %5 %6 MatrixCBFloat16INTEL\n", "%2 = OpSubgroupMatrixMultiplyAccumulateINTEL %1 %3 %4 %5 %6 MatrixResultBFloat16INTEL\n", "%2 = OpSubgroupMatrixMultiplyAccumulateINTEL %1 %3 %4 %5 %6 MatrixAPackedInt8INTEL\n", "%2 = OpSubgroupMatrixMultiplyAccumulateINTEL %1 %3 %4 %5 %6 MatrixBPackedInt8INTEL\n", "%2 = OpSubgroupMatrixMultiplyAccumulateINTEL %1 %3 %4 %5 %6 MatrixAPackedInt4INTEL\n", "%2 = OpSubgroupMatrixMultiplyAccumulateINTEL %1 %3 %4 %5 %6 MatrixBPackedInt4INTEL\n", "%2 = OpSubgroupMatrixMultiplyAccumulateINTEL %1 %3 %4 %5 %6 MatrixATF32INTEL\n", "%2 = OpSubgroupMatrixMultiplyAccumulateINTEL %1 %3 %4 %5 %6 MatrixBTF32INTEL\n", "%2 = OpSubgroupMatrixMultiplyAccumulateINTEL %1 %3 %4 %5 %6 MatrixCBFloat16INTEL\n", "%2 = OpSubgroupMatrixMultiplyAccumulateINTEL %1 %3 %4 %5 %6 MatrixAPackedFloat16INTEL\n", "%2 = OpSubgroupMatrixMultiplyAccumulateINTEL %1 %3 %4 %5 %6 MatrixBPackedFloat16INTEL\n", "%2 = OpSubgroupMatrixMultiplyAccumulateINTEL %1 %3 %4 %5 %6 MatrixAPackedBFloat16INTEL\n", "%2 = OpSubgroupMatrixMultiplyAccumulateINTEL %1 %3 %4 %5 %6 MatrixBPackedBFloat16INTEL\n", "%2 = OpSubgroupMatrixMultiplyAccumulateINTEL %1 %3 %4 %5 %6 " "MatrixASignedComponentsINTEL|MatrixBSignedComponentsINTEL|MatrixAPackedInt8INTEL|MatrixBPackedInt8INTEL\n", }))); // clang-format on using MaskSorting = TextToBinaryTest; TEST_F(MaskSorting, MasksAreSortedFromLSBToMSB) { EXPECT_THAT(EncodeAndDecodeSuccessfully( "OpStore %1 %2 Nontemporal|Aligned|Volatile 32"), Eq("OpStore %1 %2 Volatile|Aligned|Nontemporal 32\n")); EXPECT_THAT( EncodeAndDecodeSuccessfully( "OpDecorate %1 FPFastMathMode NotInf|Fast|AllowRecip|NotNaN|NSZ"), Eq("OpDecorate %1 FPFastMathMode NotNaN|NotInf|NSZ|AllowRecip|Fast\n")); EXPECT_THAT( EncodeAndDecodeSuccessfully("OpLoopMerge %1 %2 DontUnroll|Unroll"), Eq("OpLoopMerge %1 %2 Unroll|DontUnroll\n")); EXPECT_THAT( EncodeAndDecodeSuccessfully("OpSelectionMerge %1 DontFlatten|Flatten"), Eq("OpSelectionMerge %1 Flatten|DontFlatten\n")); EXPECT_THAT(EncodeAndDecodeSuccessfully( "%2 = OpFunction %1 DontInline|Const|Pure|Inline %3"), Eq("%2 = OpFunction %1 Inline|DontInline|Pure|Const %3\n")); EXPECT_THAT(EncodeAndDecodeSuccessfully( "%2 = OpImageFetch %1 %3 %4" " MinLod|Sample|Offset|Lod|Grad|ConstOffsets|ConstOffset|Bias" " %5 %6 %7 %8 %9 %10 %11 %12 %13\n"), Eq("%2 = OpImageFetch %1 %3 %4" " Bias|Lod|Grad|ConstOffset|Offset|ConstOffsets|Sample|MinLod" " %5 %6 %7 %8 %9 %10 %11 %12 %13\n")); } using OperandTypeTest = TextToBinaryTest; TEST_F(OperandTypeTest, OptionalTypedLiteralNumber) { const std::string input = "%1 = OpTypeInt 32 0\n" "%2 = OpConstant %1 42\n" "OpSwitch %2 %3 100 %4\n"; EXPECT_EQ(input, EncodeAndDecodeSuccessfully(input)); } using IndentTest = spvtest::TextToBinaryTest; TEST_F(IndentTest, Sample) { const std::string input = R"( OpCapability Shader OpMemoryModel Logical GLSL450 %1 = OpTypeInt 32 0 %2 = OpTypeStruct %1 %3 %4 %5 %6 %7 %8 %9 %10 ; force IDs into double digits %11 = OpConstant %1 42 OpStore %2 %3 Aligned|Volatile 4 ; bogus, but not indented )"; const std::string expected = R"( OpCapability Shader OpMemoryModel Logical GLSL450 %1 = OpTypeInt 32 0 %2 = OpTypeStruct %1 %3 %4 %5 %6 %7 %8 %9 %10 %11 = OpConstant %1 42 OpStore %2 %3 Volatile|Aligned 4 )"; EXPECT_THAT( EncodeAndDecodeSuccessfully(input, SPV_BINARY_TO_TEXT_OPTION_INDENT), expected); } TEST_F(IndentTest, NestedIf) { const std::string input = R"( OpCapability Shader OpMemoryModel Logical Simple OpEntryPoint Fragment %100 "main" OpExecutionMode %100 OriginUpperLeft OpName %var "var" %void = OpTypeVoid %3 = OpTypeFunction %void %bool = OpTypeBool %5 = OpConstantNull %bool %true = OpConstantTrue %bool %false = OpConstantFalse %bool %uint = OpTypeInt 32 0 %int = OpTypeInt 32 1 %uint_42 = OpConstant %uint 42 %int_42 = OpConstant %int 42 %13 = OpTypeFunction %uint %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %uint_3 = OpConstant %uint 3 %uint_4 = OpConstant %uint 4 %uint_5 = OpConstant %uint 5 %uint_6 = OpConstant %uint 6 %uint_7 = OpConstant %uint 7 %uint_8 = OpConstant %uint 8 %uint_10 = OpConstant %uint 10 %uint_20 = OpConstant %uint 20 %uint_30 = OpConstant %uint 30 %uint_40 = OpConstant %uint 40 %uint_50 = OpConstant %uint 50 %uint_90 = OpConstant %uint 90 %uint_99 = OpConstant %uint 99 %_ptr_Private_uint = OpTypePointer Private %uint %var = OpVariable %_ptr_Private_uint Private %uint_999 = OpConstant %uint 999 %100 = OpFunction %void None %3 %10 = OpLabel OpStore %var %uint_0 OpSelectionMerge %99 None OpBranchConditional %5 %30 %40 %30 = OpLabel OpStore %var %uint_1 OpBranch %99 %40 = OpLabel OpStore %var %uint_2 OpBranch %99 %99 = OpLabel OpStore %var %uint_999 OpReturn OpFunctionEnd )"; const std::string expected = R"( OpCapability Shader OpMemoryModel Logical Simple OpEntryPoint Fragment %100 "main" OpExecutionMode %100 OriginUpperLeft OpName %1 "var" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeBool %5 = OpConstantNull %4 %6 = OpConstantTrue %4 %7 = OpConstantFalse %4 %8 = OpTypeInt 32 0 %9 = OpTypeInt 32 1 %11 = OpConstant %8 42 %12 = OpConstant %9 42 %13 = OpTypeFunction %8 %14 = OpConstant %8 0 %15 = OpConstant %8 1 %16 = OpConstant %8 2 %17 = OpConstant %8 3 %18 = OpConstant %8 4 %19 = OpConstant %8 5 %20 = OpConstant %8 6 %21 = OpConstant %8 7 %22 = OpConstant %8 8 %23 = OpConstant %8 10 %24 = OpConstant %8 20 %25 = OpConstant %8 30 %26 = OpConstant %8 40 %27 = OpConstant %8 50 %28 = OpConstant %8 90 %29 = OpConstant %8 99 %31 = OpTypePointer Private %8 %1 = OpVariable %31 Private %32 = OpConstant %8 999 %100 = OpFunction %2 None %3 %10 = OpLabel OpStore %1 %14 OpSelectionMerge %99 None OpBranchConditional %5 %30 %40 %30 = OpLabel OpStore %1 %15 OpBranch %99 %40 = OpLabel OpStore %1 %16 OpBranch %99 %99 = OpLabel OpStore %1 %32 OpReturn OpFunctionEnd )"; EXPECT_THAT(EncodeAndDecodeSuccessfully( input, SPV_BINARY_TO_TEXT_OPTION_INDENT | SPV_BINARY_TO_TEXT_OPTION_NESTED_INDENT, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS), expected); } TEST_F(IndentTest, NestedWhile) { const std::string input = R"( OpCapability Shader OpMemoryModel Logical Simple OpEntryPoint Fragment %100 "main" OpExecutionMode %100 OriginUpperLeft OpName %var "var" %void = OpTypeVoid %3 = OpTypeFunction %void %bool = OpTypeBool %5 = OpConstantNull %bool %true = OpConstantTrue %bool %false = OpConstantFalse %bool %uint = OpTypeInt 32 0 %int = OpTypeInt 32 1 %uint_42 = OpConstant %uint 42 %int_42 = OpConstant %int 42 %13 = OpTypeFunction %uint %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %uint_3 = OpConstant %uint 3 %uint_4 = OpConstant %uint 4 %uint_5 = OpConstant %uint 5 %uint_6 = OpConstant %uint 6 %uint_7 = OpConstant %uint 7 %uint_8 = OpConstant %uint 8 %uint_10 = OpConstant %uint 10 %uint_20 = OpConstant %uint 20 %uint_30 = OpConstant %uint 30 %uint_40 = OpConstant %uint 40 %uint_50 = OpConstant %uint 50 %uint_90 = OpConstant %uint 90 %uint_99 = OpConstant %uint 99 %_ptr_Private_uint = OpTypePointer Private %uint %var = OpVariable %_ptr_Private_uint Private %uint_999 = OpConstant %uint 999 %100 = OpFunction %void None %3 %10 = OpLabel OpStore %var %uint_0 OpBranch %20 %20 = OpLabel OpStore %var %uint_1 OpLoopMerge %99 %20 None OpBranch %80 %80 = OpLabel OpStore %var %uint_2 OpBranchConditional %5 %99 %20 %99 = OpLabel OpStore %var %uint_3 OpReturn OpFunctionEnd )"; const std::string expected = R"( OpCapability Shader OpMemoryModel Logical Simple OpEntryPoint Fragment %100 "main" OpExecutionMode %100 OriginUpperLeft OpName %1 "var" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeBool %5 = OpConstantNull %4 %6 = OpConstantTrue %4 %7 = OpConstantFalse %4 %8 = OpTypeInt 32 0 %9 = OpTypeInt 32 1 %11 = OpConstant %8 42 %12 = OpConstant %9 42 %13 = OpTypeFunction %8 %14 = OpConstant %8 0 %15 = OpConstant %8 1 %16 = OpConstant %8 2 %17 = OpConstant %8 3 %18 = OpConstant %8 4 %19 = OpConstant %8 5 %21 = OpConstant %8 6 %22 = OpConstant %8 7 %23 = OpConstant %8 8 %24 = OpConstant %8 10 %25 = OpConstant %8 20 %26 = OpConstant %8 30 %27 = OpConstant %8 40 %28 = OpConstant %8 50 %29 = OpConstant %8 90 %30 = OpConstant %8 99 %31 = OpTypePointer Private %8 %1 = OpVariable %31 Private %32 = OpConstant %8 999 %100 = OpFunction %2 None %3 %10 = OpLabel OpStore %1 %14 OpBranch %20 %20 = OpLabel OpStore %1 %15 OpLoopMerge %99 %20 None OpBranch %80 %80 = OpLabel OpStore %1 %16 OpBranchConditional %5 %99 %20 %99 = OpLabel OpStore %1 %17 OpReturn OpFunctionEnd )"; EXPECT_THAT(EncodeAndDecodeSuccessfully( input, SPV_BINARY_TO_TEXT_OPTION_INDENT | SPV_BINARY_TO_TEXT_OPTION_NESTED_INDENT, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS), expected); } TEST_F(IndentTest, NestedLoopInLoop) { const std::string input = R"( OpCapability Shader OpMemoryModel Logical Simple OpEntryPoint Fragment %100 "main" OpExecutionMode %100 OriginUpperLeft OpName %var "var" %void = OpTypeVoid %3 = OpTypeFunction %void %bool = OpTypeBool %5 = OpConstantNull %bool %true = OpConstantTrue %bool %false = OpConstantFalse %bool %uint = OpTypeInt 32 0 %int = OpTypeInt 32 1 %uint_42 = OpConstant %uint 42 %int_42 = OpConstant %int 42 %13 = OpTypeFunction %uint %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %uint_3 = OpConstant %uint 3 %uint_4 = OpConstant %uint 4 %uint_5 = OpConstant %uint 5 %uint_6 = OpConstant %uint 6 %uint_7 = OpConstant %uint 7 %uint_8 = OpConstant %uint 8 %uint_10 = OpConstant %uint 10 %uint_20 = OpConstant %uint 20 %uint_30 = OpConstant %uint 30 %uint_40 = OpConstant %uint 40 %uint_50 = OpConstant %uint 50 %uint_90 = OpConstant %uint 90 %uint_99 = OpConstant %uint 99 %_ptr_Private_uint = OpTypePointer Private %uint %var = OpVariable %_ptr_Private_uint Private %uint_999 = OpConstant %uint 999 %100 = OpFunction %void None %3 %10 = OpLabel OpBranch %20 %20 = OpLabel OpLoopMerge %99 %50 None OpBranchConditional %5 %30 %99 %30 = OpLabel OpLoopMerge %49 %40 None OpBranchConditional %true %35 %49 %35 = OpLabel OpBranch %37 %37 = OpLabel OpBranch %40 %40 = OpLabel OpBranch %30 %49 = OpLabel OpBranch %50 %50 = OpLabel OpBranch %20 %99 = OpLabel OpReturn OpFunctionEnd )"; const std::string expected = R"( OpCapability Shader OpMemoryModel Logical Simple OpEntryPoint Fragment %100 "main" OpExecutionMode %100 OriginUpperLeft OpName %1 "var" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeBool %5 = OpConstantNull %4 %6 = OpConstantTrue %4 %7 = OpConstantFalse %4 %8 = OpTypeInt 32 0 %9 = OpTypeInt 32 1 %11 = OpConstant %8 42 %12 = OpConstant %9 42 %13 = OpTypeFunction %8 %14 = OpConstant %8 0 %15 = OpConstant %8 1 %16 = OpConstant %8 2 %17 = OpConstant %8 3 %18 = OpConstant %8 4 %19 = OpConstant %8 5 %21 = OpConstant %8 6 %22 = OpConstant %8 7 %23 = OpConstant %8 8 %24 = OpConstant %8 10 %25 = OpConstant %8 20 %26 = OpConstant %8 30 %27 = OpConstant %8 40 %28 = OpConstant %8 50 %29 = OpConstant %8 90 %31 = OpConstant %8 99 %32 = OpTypePointer Private %8 %1 = OpVariable %32 Private %33 = OpConstant %8 999 %100 = OpFunction %2 None %3 %10 = OpLabel OpBranch %20 %20 = OpLabel OpLoopMerge %99 %50 None OpBranchConditional %5 %30 %99 %30 = OpLabel OpLoopMerge %49 %40 None OpBranchConditional %6 %35 %49 %35 = OpLabel OpBranch %37 %37 = OpLabel OpBranch %40 %40 = OpLabel OpBranch %30 %49 = OpLabel OpBranch %50 %50 = OpLabel OpBranch %20 %99 = OpLabel OpReturn OpFunctionEnd )"; EXPECT_THAT(EncodeAndDecodeSuccessfully( input, SPV_BINARY_TO_TEXT_OPTION_INDENT | SPV_BINARY_TO_TEXT_OPTION_NESTED_INDENT, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS), expected); } TEST_F(IndentTest, NestedSwitch) { const std::string input = R"( OpCapability Shader OpMemoryModel Logical Simple OpEntryPoint Fragment %100 "main" OpExecutionMode %100 OriginUpperLeft OpName %var "var" %void = OpTypeVoid %3 = OpTypeFunction %void %bool = OpTypeBool %5 = OpConstantNull %bool %true = OpConstantTrue %bool %false = OpConstantFalse %bool %uint = OpTypeInt 32 0 %int = OpTypeInt 32 1 %uint_42 = OpConstant %uint 42 %int_42 = OpConstant %int 42 %13 = OpTypeFunction %uint %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %uint_3 = OpConstant %uint 3 %uint_4 = OpConstant %uint 4 %uint_5 = OpConstant %uint 5 %uint_6 = OpConstant %uint 6 %uint_7 = OpConstant %uint 7 %uint_8 = OpConstant %uint 8 %uint_10 = OpConstant %uint 10 %uint_20 = OpConstant %uint 20 %uint_30 = OpConstant %uint 30 %uint_40 = OpConstant %uint 40 %uint_50 = OpConstant %uint 50 %uint_90 = OpConstant %uint 90 %uint_99 = OpConstant %uint 99 %_ptr_Private_uint = OpTypePointer Private %uint %var = OpVariable %_ptr_Private_uint Private %uint_999 = OpConstant %uint 999 %100 = OpFunction %void None %3 %10 = OpLabel OpSelectionMerge %99 None OpSwitch %uint_42 %80 20 %20 30 %30 %20 = OpLabel OpBranch %80 %80 = OpLabel OpBranch %30 %30 = OpLabel OpBranch %99 %99 = OpLabel OpReturn OpFunctionEnd )"; const std::string expected = R"( OpCapability Shader OpMemoryModel Logical Simple OpEntryPoint Fragment %100 "main" OpExecutionMode %100 OriginUpperLeft OpName %1 "var" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeBool %5 = OpConstantNull %4 %6 = OpConstantTrue %4 %7 = OpConstantFalse %4 %8 = OpTypeInt 32 0 %9 = OpTypeInt 32 1 %11 = OpConstant %8 42 %12 = OpConstant %9 42 %13 = OpTypeFunction %8 %14 = OpConstant %8 0 %15 = OpConstant %8 1 %16 = OpConstant %8 2 %17 = OpConstant %8 3 %18 = OpConstant %8 4 %19 = OpConstant %8 5 %21 = OpConstant %8 6 %22 = OpConstant %8 7 %23 = OpConstant %8 8 %24 = OpConstant %8 10 %25 = OpConstant %8 20 %26 = OpConstant %8 30 %27 = OpConstant %8 40 %28 = OpConstant %8 50 %29 = OpConstant %8 90 %31 = OpConstant %8 99 %32 = OpTypePointer Private %8 %1 = OpVariable %32 Private %33 = OpConstant %8 999 %100 = OpFunction %2 None %3 %10 = OpLabel OpSelectionMerge %99 None OpSwitch %11 %80 20 %20 30 %30 %20 = OpLabel OpBranch %80 %80 = OpLabel OpBranch %30 %30 = OpLabel OpBranch %99 %99 = OpLabel OpReturn OpFunctionEnd )"; EXPECT_THAT(EncodeAndDecodeSuccessfully( input, SPV_BINARY_TO_TEXT_OPTION_INDENT | SPV_BINARY_TO_TEXT_OPTION_NESTED_INDENT, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS), expected); } TEST_F(IndentTest, ReorderedIf) { const std::string input = R"( OpCapability Shader OpMemoryModel Logical Simple OpEntryPoint Fragment %100 "main" OpExecutionMode %100 OriginUpperLeft OpName %1 "var" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeBool %5 = OpConstantNull %4 %6 = OpConstantTrue %4 %7 = OpConstantFalse %4 %8 = OpTypeInt 32 0 %9 = OpTypeInt 32 1 %11 = OpConstant %8 42 %12 = OpConstant %9 42 %13 = OpTypeFunction %8 %14 = OpConstant %8 0 %15 = OpConstant %8 1 %16 = OpConstant %8 2 %17 = OpConstant %8 3 %18 = OpConstant %8 4 %19 = OpConstant %8 5 %21 = OpConstant %8 6 %22 = OpConstant %8 7 %23 = OpConstant %8 8 %24 = OpConstant %8 10 %25 = OpConstant %8 20 %26 = OpConstant %8 30 %27 = OpConstant %8 40 %28 = OpConstant %8 50 %29 = OpConstant %8 90 %31 = OpConstant %8 99 %32 = OpTypePointer Private %8 %1 = OpVariable %32 Private %33 = OpConstant %8 999 %100 = OpFunction %2 None %3 %10 = OpLabel OpSelectionMerge %99 None OpBranchConditional %5 %20 %50 %99 = OpLabel OpReturn %20 = OpLabel OpSelectionMerge %49 None OpBranchConditional %5 %30 %40 %49 = OpLabel OpBranch %99 %40 = OpLabel OpBranch %49 %30 = OpLabel OpBranch %49 %50 = OpLabel OpSelectionMerge %79 None OpBranchConditional %5 %60 %70 %79 = OpLabel OpBranch %99 %60 = OpLabel OpBranch %79 %70 = OpLabel OpBranch %79 OpFunctionEnd )"; const std::string expected = R"( OpCapability Shader OpMemoryModel Logical Simple OpEntryPoint Fragment %100 "main" OpExecutionMode %100 OriginUpperLeft OpName %1 "var" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeBool %5 = OpConstantNull %4 %6 = OpConstantTrue %4 %7 = OpConstantFalse %4 %8 = OpTypeInt 32 0 %9 = OpTypeInt 32 1 %11 = OpConstant %8 42 %12 = OpConstant %9 42 %13 = OpTypeFunction %8 %14 = OpConstant %8 0 %15 = OpConstant %8 1 %16 = OpConstant %8 2 %17 = OpConstant %8 3 %18 = OpConstant %8 4 %19 = OpConstant %8 5 %21 = OpConstant %8 6 %22 = OpConstant %8 7 %23 = OpConstant %8 8 %24 = OpConstant %8 10 %25 = OpConstant %8 20 %26 = OpConstant %8 30 %27 = OpConstant %8 40 %28 = OpConstant %8 50 %29 = OpConstant %8 90 %31 = OpConstant %8 99 %32 = OpTypePointer Private %8 %1 = OpVariable %32 Private %33 = OpConstant %8 999 %100 = OpFunction %2 None %3 %10 = OpLabel OpSelectionMerge %99 None OpBranchConditional %5 %20 %50 %20 = OpLabel OpSelectionMerge %49 None OpBranchConditional %5 %30 %40 %30 = OpLabel OpBranch %49 %40 = OpLabel OpBranch %49 %49 = OpLabel OpBranch %99 %50 = OpLabel OpSelectionMerge %79 None OpBranchConditional %5 %60 %70 %60 = OpLabel OpBranch %79 %70 = OpLabel OpBranch %79 %79 = OpLabel OpBranch %99 %99 = OpLabel OpReturn OpFunctionEnd )"; EXPECT_THAT(EncodeAndDecodeSuccessfully( input, SPV_BINARY_TO_TEXT_OPTION_INDENT | SPV_BINARY_TO_TEXT_OPTION_REORDER_BLOCKS, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS), expected); } TEST_F(IndentTest, ReorderedFallThroughInSwitch) { const std::string input = R"( OpCapability Shader OpMemoryModel Logical Simple OpEntryPoint Fragment %100 "main" OpExecutionMode %100 OriginUpperLeft OpName %1 "var" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeBool %5 = OpConstantNull %4 %6 = OpConstantTrue %4 %7 = OpConstantFalse %4 %8 = OpTypeInt 32 0 %9 = OpTypeInt 32 1 %11 = OpConstant %8 42 %12 = OpConstant %9 42 %13 = OpTypeFunction %8 %14 = OpConstant %8 0 %15 = OpConstant %8 1 %16 = OpConstant %8 2 %17 = OpConstant %8 3 %18 = OpConstant %8 4 %19 = OpConstant %8 5 %21 = OpConstant %8 6 %22 = OpConstant %8 7 %23 = OpConstant %8 8 %24 = OpConstant %8 10 %25 = OpConstant %8 20 %26 = OpConstant %8 30 %27 = OpConstant %8 40 %28 = OpConstant %8 50 %29 = OpConstant %8 90 %31 = OpConstant %8 99 %32 = OpTypePointer Private %8 %1 = OpVariable %32 Private %33 = OpConstant %8 999 %100 = OpFunction %2 None %3 %10 = OpLabel OpSelectionMerge %99 None OpSwitch %11 %50 20 %20 50 %50 %99 = OpLabel OpReturn %20 = OpLabel OpSelectionMerge %49 None OpBranchConditional %5 %30 %40 %49 = OpLabel OpBranchConditional %5 %99 %50 %30 = OpLabel OpBranch %49 %40 = OpLabel OpBranch %49 %50 = OpLabel OpSelectionMerge %79 None OpBranchConditional %5 %60 %70 %79 = OpLabel OpBranch %99 %60 = OpLabel OpBranch %79 %70 = OpLabel OpBranch %79 OpFunctionEnd )"; const std::string expected = R"( OpCapability Shader OpMemoryModel Logical Simple OpEntryPoint Fragment %100 "main" OpExecutionMode %100 OriginUpperLeft OpName %1 "var" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeBool %5 = OpConstantNull %4 %6 = OpConstantTrue %4 %7 = OpConstantFalse %4 %8 = OpTypeInt 32 0 %9 = OpTypeInt 32 1 %11 = OpConstant %8 42 %12 = OpConstant %9 42 %13 = OpTypeFunction %8 %14 = OpConstant %8 0 %15 = OpConstant %8 1 %16 = OpConstant %8 2 %17 = OpConstant %8 3 %18 = OpConstant %8 4 %19 = OpConstant %8 5 %21 = OpConstant %8 6 %22 = OpConstant %8 7 %23 = OpConstant %8 8 %24 = OpConstant %8 10 %25 = OpConstant %8 20 %26 = OpConstant %8 30 %27 = OpConstant %8 40 %28 = OpConstant %8 50 %29 = OpConstant %8 90 %31 = OpConstant %8 99 %32 = OpTypePointer Private %8 %1 = OpVariable %32 Private %33 = OpConstant %8 999 %100 = OpFunction %2 None %3 %10 = OpLabel OpSelectionMerge %99 None OpSwitch %11 %50 20 %20 50 %50 %20 = OpLabel OpSelectionMerge %49 None OpBranchConditional %5 %30 %40 %30 = OpLabel OpBranch %49 %40 = OpLabel OpBranch %49 %49 = OpLabel OpBranchConditional %5 %99 %50 %50 = OpLabel OpSelectionMerge %79 None OpBranchConditional %5 %60 %70 %60 = OpLabel OpBranch %79 %70 = OpLabel OpBranch %79 %79 = OpLabel OpBranch %99 %99 = OpLabel OpReturn OpFunctionEnd )"; EXPECT_THAT(EncodeAndDecodeSuccessfully( input, SPV_BINARY_TO_TEXT_OPTION_INDENT | SPV_BINARY_TO_TEXT_OPTION_REORDER_BLOCKS, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS), expected); } TEST_F(IndentTest, ReorderedNested) { const std::string input = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %204 OpExecutionMode %4 OriginUpperLeft OpSource GLSL 450 OpName %4 "main" OpName %16 "ff(vf2;f1;" OpName %14 "g" OpName %15 "f" OpName %19 "vg" OpName %20 "Block140" OpMemberName %20 0 "a" OpMemberName %20 1 "b" OpName %22 "b140" OpName %35 "sv" OpName %39 "s" OpName %46 "f" OpName %51 "g" OpName %57 "x" OpName %69 "param" OpName %75 "i" OpName %80 "vc" OpName %88 "j" OpName %95 "size" OpName %174 "v" OpName %187 "i" OpName %204 "o_color" OpMemberDecorate %20 0 Offset 0 OpMemberDecorate %20 1 Offset 16 OpDecorate %20 Block OpDecorate %22 DescriptorSet 1 OpDecorate %22 Binding 0 OpDecorate %39 DescriptorSet 0 OpDecorate %39 Binding 1 OpDecorate %95 SpecId 20 OpDecorate %204 Location 2 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 2 %8 = OpTypePointer Function %7 %9 = OpTypeVector %6 4 %10 = OpTypeInt 32 0 %11 = OpConstant %10 2 %12 = OpTypeArray %9 %11 %13 = OpTypeFunction %12 %8 %6 %18 = OpTypePointer Private %9 %19 = OpVariable %18 Private %20 = OpTypeStruct %6 %9 %21 = OpTypePointer Uniform %20 %22 = OpVariable %21 Uniform %23 = OpTypeInt 32 1 %24 = OpConstant %23 1 %25 = OpTypePointer Uniform %9 %28 = OpConstant %6 0 %29 = OpConstantComposite %9 %28 %28 %28 %28 %34 = OpTypePointer Function %9 %36 = OpTypeImage %6 2D 0 0 0 1 Unknown %37 = OpTypeSampledImage %36 %38 = OpTypePointer UniformConstant %37 %39 = OpVariable %38 UniformConstant %41 = OpConstantComposite %7 %28 %28 %45 = OpTypePointer Function %6 %47 = OpConstant %23 0 %48 = OpTypePointer Uniform %6 %53 = OpConstant %6 1 %55 = OpTypeBool %56 = OpTypePointer Function %55 %58 = OpConstant %10 0 %59 = OpTypePointer Private %6 %74 = OpTypePointer Function %23 %87 = OpTypePointer Function %10 %95 = OpSpecConstant %10 2 %100 = OpConstant %10 1 %109 = OpConstantComposite %9 %53 %53 %53 %53 %127 = OpConstant %23 10 %139 = OpConstant %6 2 %143 = OpConstant %6 3 %158 = OpConstant %6 4 %177 = OpConstant %6 0.5 %195 = OpConstant %23 100 %202 = OpTypeVector %10 4 %203 = OpTypePointer Output %202 %204 = OpVariable %203 Output %4 = OpFunction %2 None %3 %5 = OpLabel %35 = OpVariable %34 Function %46 = OpVariable %45 Function %51 = OpVariable %45 Function %57 = OpVariable %56 Function %69 = OpVariable %8 Function %75 = OpVariable %74 Function %80 = OpVariable %34 Function %88 = OpVariable %87 Function %174 = OpVariable %45 Function %187 = OpVariable %74 Function %26 = OpAccessChain %25 %22 %24 %27 = OpLoad %9 %26 OpStore %19 %27 %40 = OpLoad %37 %39 %42 = OpImageSampleImplicitLod %9 %40 %41 %43 = OpLoad %9 %19 %44 = OpFAdd %9 %42 %43 OpStore %35 %44 %49 = OpAccessChain %48 %22 %47 %50 = OpLoad %6 %49 OpStore %46 %50 %52 = OpLoad %6 %46 %54 = OpFAdd %6 %52 %53 OpStore %51 %54 %60 = OpAccessChain %59 %19 %58 %61 = OpLoad %6 %60 %62 = OpFOrdGreaterThan %55 %61 %28 OpSelectionMerge %64 None OpBranchConditional %62 %63 %64 %64 = OpLabel %73 = OpPhi %55 %62 %5 %72 %63 OpStore %57 %73 OpStore %75 %47 OpBranch %76 %197 = OpLabel OpBranch %190 %63 = OpLabel %65 = OpLoad %6 %46 %66 = OpLoad %6 %51 %67 = OpCompositeConstruct %7 %65 %66 %68 = OpLoad %6 %51 OpStore %69 %67 %70 = OpFunctionCall %12 %16 %69 %68 %71 = OpCompositeExtract %6 %70 0 0 %72 = OpFOrdGreaterThan %55 %71 %28 OpBranch %64 %77 = OpLabel %81 = OpLoad %9 %19 OpStore %80 %81 %82 = OpAccessChain %45 %80 %58 %83 = OpLoad %6 %82 %84 = OpFOrdGreaterThan %55 %83 %28 OpSelectionMerge %86 None OpBranchConditional %84 %85 %113 %85 = OpLabel OpStore %88 %58 OpBranch %89 %89 = OpLabel OpLoopMerge %91 %92 None OpBranch %93 %93 = OpLabel %94 = OpLoad %10 %88 %96 = OpULessThan %55 %94 %95 OpBranchConditional %96 %90 %91 %105 = OpLabel OpBranch %92 %198 = OpLabel OpBranch %191 %163 = OpLabel OpBranch %136 %104 = OpLabel OpBranch %91 %76 = OpLabel OpLoopMerge %78 %79 None OpBranch %77 %92 = OpLabel %107 = OpLoad %10 %88 %108 = OpIAdd %10 %107 %24 OpStore %88 %108 OpBranch %89 %91 = OpLabel %110 = OpLoad %9 %80 %111 = OpFAdd %9 %110 %109 OpStore %80 %111 OpBranch %79 %113 = OpLabel %114 = OpLoad %9 %80 %115 = OpFSub %9 %114 %109 OpStore %80 %115 OpBranch %86 %132 = OpLabel %137 = OpLoad %6 %51 %138 = OpFAdd %6 %137 %53 OpStore %51 %138 OpBranch %133 %86 = OpLabel %116 = OpAccessChain %45 %80 %100 %117 = OpLoad %6 %116 %118 = OpFOrdGreaterThan %55 %117 %28 OpSelectionMerge %120 None OpBranchConditional %118 %119 %120 %119 = OpLabel OpBranch %78 %120 = OpLabel %122 = OpAccessChain %45 %80 %11 %123 = OpLoad %6 %122 %124 = OpFAdd %6 %123 %53 %125 = OpAccessChain %45 %80 %11 OpStore %125 %124 OpBranch %79 %79 = OpLabel %126 = OpLoad %23 %75 %128 = OpSLessThan %55 %126 %127 OpBranchConditional %128 %76 %78 %78 = OpLabel %129 = OpAccessChain %48 %22 %47 %130 = OpLoad %6 %129 %131 = OpConvertFToS %23 %130 OpSelectionMerge %136 None OpSwitch %131 %135 0 %132 1 %132 2 %132 3 %133 4 %134 %90 = OpLabel %97 = OpLoad %9 %19 %98 = OpLoad %9 %80 %99 = OpFAdd %9 %98 %97 OpStore %80 %99 %101 = OpAccessChain %45 %80 %100 %102 = OpLoad %6 %101 %103 = OpFOrdLessThan %55 %102 %28 OpSelectionMerge %105 None OpBranchConditional %103 %104 %105 %161 = OpLabel OpLoopMerge %163 %164 None OpBranch %165 %165 = OpLabel %166 = OpLoad %6 %51 %167 = OpFOrdLessThan %55 %166 %139 OpBranchConditional %167 %162 %163 %164 = OpLabel OpBranch %161 %162 = OpLabel %168 = OpLoad %6 %46 %169 = OpFOrdLessThan %55 %168 %53 OpSelectionMerge %171 None OpBranchConditional %169 %170 %171 %135 = OpLabel %159 = OpLoad %6 %51 %160 = OpFAdd %6 %159 %158 OpStore %51 %160 OpBranch %161 %133 = OpLabel %140 = OpLoad %6 %51 %141 = OpFAdd %6 %140 %139 OpStore %51 %141 OpBranch %136 %134 = OpLabel %144 = OpLoad %6 %51 %145 = OpFAdd %6 %144 %143 OpStore %51 %145 OpBranch %146 %146 = OpLabel OpLoopMerge %148 %149 None OpBranch %150 %150 = OpLabel %151 = OpLoad %6 %51 %152 = OpFOrdLessThan %55 %151 %139 OpBranchConditional %152 %147 %148 %147 = OpLabel %153 = OpLoad %6 %46 %154 = OpFOrdLessThan %55 %153 %53 OpSelectionMerge %156 None OpBranchConditional %154 %155 %156 %155 = OpLabel OpBranch %148 %156 = OpLabel OpBranch %149 %149 = OpLabel OpBranch %146 %148 = OpLabel OpBranch %135 %136 = OpLabel OpStore %174 %53 %175 = OpAccessChain %45 %35 %58 %176 = OpLoad %6 %175 %178 = OpFOrdLessThanEqual %55 %176 %177 OpSelectionMerge %180 None OpBranchConditional %178 %179 %181 %179 = OpLabel OpStore %174 %28 OpBranch %180 %185 = OpLabel OpStore %174 %139 OpBranch %186 %181 = OpLabel %182 = OpAccessChain %45 %35 %58 %183 = OpLoad %6 %182 %184 = OpFOrdGreaterThanEqual %55 %183 %177 OpSelectionMerge %186 None OpBranchConditional %184 %185 %186 %170 = OpLabel OpBranch %163 %171 = OpLabel OpBranch %164 %186 = OpLabel OpBranch %180 %188 = OpLabel OpLoopMerge %190 %191 None OpBranch %189 %189 = OpLabel %192 = OpLoad %9 %19 %193 = OpFAdd %9 %192 %109 OpStore %19 %193 %194 = OpLoad %23 %187 %196 = OpSGreaterThan %55 %194 %195 OpSelectionMerge %198 None OpBranchConditional %196 %197 %198 %180 = OpLabel OpStore %187 %47 OpBranch %188 %191 = OpLabel %200 = OpLoad %23 %187 %201 = OpIAdd %23 %200 %24 OpStore %187 %201 OpBranch %188 %190 = OpLabel OpReturn OpFunctionEnd %16 = OpFunction %12 None %13 %14 = OpFunctionParameter %8 %15 = OpFunctionParameter %6 %17 = OpLabel %30 = OpCompositeConstruct %9 %15 %15 %15 %15 %31 = OpCompositeConstruct %12 %29 %30 OpReturnValue %31 OpFunctionEnd )"; const std::string expected = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %204 OpExecutionMode %4 OriginUpperLeft OpSource GLSL 450 OpName %4 "main" OpName %16 "ff(vf2;f1;" OpName %14 "g" OpName %15 "f" OpName %19 "vg" OpName %20 "Block140" OpMemberName %20 0 "a" OpMemberName %20 1 "b" OpName %22 "b140" OpName %35 "sv" OpName %39 "s" OpName %46 "f" OpName %51 "g" OpName %57 "x" OpName %69 "param" OpName %75 "i" OpName %80 "vc" OpName %88 "j" OpName %95 "size" OpName %174 "v" OpName %187 "i" OpName %204 "o_color" OpMemberDecorate %20 0 Offset 0 OpMemberDecorate %20 1 Offset 16 OpDecorate %20 Block OpDecorate %22 DescriptorSet 1 OpDecorate %22 Binding 0 OpDecorate %39 DescriptorSet 0 OpDecorate %39 Binding 1 OpDecorate %95 SpecId 20 OpDecorate %204 Location 2 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 2 %8 = OpTypePointer Function %7 %9 = OpTypeVector %6 4 %10 = OpTypeInt 32 0 %11 = OpConstant %10 2 %12 = OpTypeArray %9 %11 %13 = OpTypeFunction %12 %8 %6 %18 = OpTypePointer Private %9 %19 = OpVariable %18 Private %20 = OpTypeStruct %6 %9 %21 = OpTypePointer Uniform %20 %22 = OpVariable %21 Uniform %23 = OpTypeInt 32 1 %24 = OpConstant %23 1 %25 = OpTypePointer Uniform %9 %28 = OpConstant %6 0 %29 = OpConstantComposite %9 %28 %28 %28 %28 %34 = OpTypePointer Function %9 %36 = OpTypeImage %6 2D 0 0 0 1 Unknown %37 = OpTypeSampledImage %36 %38 = OpTypePointer UniformConstant %37 %39 = OpVariable %38 UniformConstant %41 = OpConstantComposite %7 %28 %28 %45 = OpTypePointer Function %6 %47 = OpConstant %23 0 %48 = OpTypePointer Uniform %6 %53 = OpConstant %6 1 %55 = OpTypeBool %56 = OpTypePointer Function %55 %58 = OpConstant %10 0 %59 = OpTypePointer Private %6 %74 = OpTypePointer Function %23 %87 = OpTypePointer Function %10 %95 = OpSpecConstant %10 2 %100 = OpConstant %10 1 %109 = OpConstantComposite %9 %53 %53 %53 %53 %127 = OpConstant %23 10 %139 = OpConstant %6 2 %143 = OpConstant %6 3 %158 = OpConstant %6 4 %177 = OpConstant %6 0.5 %195 = OpConstant %23 100 %202 = OpTypeVector %10 4 %203 = OpTypePointer Output %202 %204 = OpVariable %203 Output %4 = OpFunction %2 None %3 %5 = OpLabel %35 = OpVariable %34 Function %46 = OpVariable %45 Function %51 = OpVariable %45 Function %57 = OpVariable %56 Function %69 = OpVariable %8 Function %75 = OpVariable %74 Function %80 = OpVariable %34 Function %88 = OpVariable %87 Function %174 = OpVariable %45 Function %187 = OpVariable %74 Function %26 = OpAccessChain %25 %22 %24 %27 = OpLoad %9 %26 OpStore %19 %27 %40 = OpLoad %37 %39 %42 = OpImageSampleImplicitLod %9 %40 %41 %43 = OpLoad %9 %19 %44 = OpFAdd %9 %42 %43 OpStore %35 %44 %49 = OpAccessChain %48 %22 %47 %50 = OpLoad %6 %49 OpStore %46 %50 %52 = OpLoad %6 %46 %54 = OpFAdd %6 %52 %53 OpStore %51 %54 %60 = OpAccessChain %59 %19 %58 %61 = OpLoad %6 %60 %62 = OpFOrdGreaterThan %55 %61 %28 OpSelectionMerge %64 None OpBranchConditional %62 %63 %64 %63 = OpLabel %65 = OpLoad %6 %46 %66 = OpLoad %6 %51 %67 = OpCompositeConstruct %7 %65 %66 %68 = OpLoad %6 %51 OpStore %69 %67 %70 = OpFunctionCall %12 %16 %69 %68 %71 = OpCompositeExtract %6 %70 0 0 %72 = OpFOrdGreaterThan %55 %71 %28 OpBranch %64 %64 = OpLabel %73 = OpPhi %55 %62 %5 %72 %63 OpStore %57 %73 OpStore %75 %47 OpBranch %76 %76 = OpLabel OpLoopMerge %78 %79 None OpBranch %77 %77 = OpLabel %81 = OpLoad %9 %19 OpStore %80 %81 %82 = OpAccessChain %45 %80 %58 %83 = OpLoad %6 %82 %84 = OpFOrdGreaterThan %55 %83 %28 OpSelectionMerge %86 None OpBranchConditional %84 %85 %113 %85 = OpLabel OpStore %88 %58 OpBranch %89 %89 = OpLabel OpLoopMerge %91 %92 None OpBranch %93 %93 = OpLabel %94 = OpLoad %10 %88 %96 = OpULessThan %55 %94 %95 OpBranchConditional %96 %90 %91 %90 = OpLabel %97 = OpLoad %9 %19 %98 = OpLoad %9 %80 %99 = OpFAdd %9 %98 %97 OpStore %80 %99 %101 = OpAccessChain %45 %80 %100 %102 = OpLoad %6 %101 %103 = OpFOrdLessThan %55 %102 %28 OpSelectionMerge %105 None OpBranchConditional %103 %104 %105 %104 = OpLabel OpBranch %91 %105 = OpLabel OpBranch %92 %92 = OpLabel %107 = OpLoad %10 %88 %108 = OpIAdd %10 %107 %24 OpStore %88 %108 OpBranch %89 %91 = OpLabel %110 = OpLoad %9 %80 %111 = OpFAdd %9 %110 %109 OpStore %80 %111 OpBranch %79 %113 = OpLabel %114 = OpLoad %9 %80 %115 = OpFSub %9 %114 %109 OpStore %80 %115 OpBranch %86 %86 = OpLabel %116 = OpAccessChain %45 %80 %100 %117 = OpLoad %6 %116 %118 = OpFOrdGreaterThan %55 %117 %28 OpSelectionMerge %120 None OpBranchConditional %118 %119 %120 %119 = OpLabel OpBranch %78 %120 = OpLabel %122 = OpAccessChain %45 %80 %11 %123 = OpLoad %6 %122 %124 = OpFAdd %6 %123 %53 %125 = OpAccessChain %45 %80 %11 OpStore %125 %124 OpBranch %79 %79 = OpLabel %126 = OpLoad %23 %75 %128 = OpSLessThan %55 %126 %127 OpBranchConditional %128 %76 %78 %78 = OpLabel %129 = OpAccessChain %48 %22 %47 %130 = OpLoad %6 %129 %131 = OpConvertFToS %23 %130 OpSelectionMerge %136 None OpSwitch %131 %135 0 %132 1 %132 2 %132 3 %133 4 %134 %132 = OpLabel %137 = OpLoad %6 %51 %138 = OpFAdd %6 %137 %53 OpStore %51 %138 OpBranch %133 %133 = OpLabel %140 = OpLoad %6 %51 %141 = OpFAdd %6 %140 %139 OpStore %51 %141 OpBranch %136 %134 = OpLabel %144 = OpLoad %6 %51 %145 = OpFAdd %6 %144 %143 OpStore %51 %145 OpBranch %146 %146 = OpLabel OpLoopMerge %148 %149 None OpBranch %150 %150 = OpLabel %151 = OpLoad %6 %51 %152 = OpFOrdLessThan %55 %151 %139 OpBranchConditional %152 %147 %148 %147 = OpLabel %153 = OpLoad %6 %46 %154 = OpFOrdLessThan %55 %153 %53 OpSelectionMerge %156 None OpBranchConditional %154 %155 %156 %155 = OpLabel OpBranch %148 %156 = OpLabel OpBranch %149 %149 = OpLabel OpBranch %146 %148 = OpLabel OpBranch %135 %135 = OpLabel %159 = OpLoad %6 %51 %160 = OpFAdd %6 %159 %158 OpStore %51 %160 OpBranch %161 %161 = OpLabel OpLoopMerge %163 %164 None OpBranch %165 %165 = OpLabel %166 = OpLoad %6 %51 %167 = OpFOrdLessThan %55 %166 %139 OpBranchConditional %167 %162 %163 %162 = OpLabel %168 = OpLoad %6 %46 %169 = OpFOrdLessThan %55 %168 %53 OpSelectionMerge %171 None OpBranchConditional %169 %170 %171 %170 = OpLabel OpBranch %163 %171 = OpLabel OpBranch %164 %164 = OpLabel OpBranch %161 %163 = OpLabel OpBranch %136 %136 = OpLabel OpStore %174 %53 %175 = OpAccessChain %45 %35 %58 %176 = OpLoad %6 %175 %178 = OpFOrdLessThanEqual %55 %176 %177 OpSelectionMerge %180 None OpBranchConditional %178 %179 %181 %179 = OpLabel OpStore %174 %28 OpBranch %180 %181 = OpLabel %182 = OpAccessChain %45 %35 %58 %183 = OpLoad %6 %182 %184 = OpFOrdGreaterThanEqual %55 %183 %177 OpSelectionMerge %186 None OpBranchConditional %184 %185 %186 %185 = OpLabel OpStore %174 %139 OpBranch %186 %186 = OpLabel OpBranch %180 %180 = OpLabel OpStore %187 %47 OpBranch %188 %188 = OpLabel OpLoopMerge %190 %191 None OpBranch %189 %189 = OpLabel %192 = OpLoad %9 %19 %193 = OpFAdd %9 %192 %109 OpStore %19 %193 %194 = OpLoad %23 %187 %196 = OpSGreaterThan %55 %194 %195 OpSelectionMerge %198 None OpBranchConditional %196 %197 %198 %197 = OpLabel OpBranch %190 %198 = OpLabel OpBranch %191 %191 = OpLabel %200 = OpLoad %23 %187 %201 = OpIAdd %23 %200 %24 OpStore %187 %201 OpBranch %188 %190 = OpLabel OpReturn OpFunctionEnd %16 = OpFunction %12 None %13 %14 = OpFunctionParameter %8 %15 = OpFunctionParameter %6 %17 = OpLabel %30 = OpCompositeConstruct %9 %15 %15 %15 %15 %31 = OpCompositeConstruct %12 %29 %30 OpReturnValue %31 OpFunctionEnd )"; EXPECT_THAT(EncodeAndDecodeSuccessfully( input, SPV_BINARY_TO_TEXT_OPTION_INDENT | SPV_BINARY_TO_TEXT_OPTION_NESTED_INDENT | SPV_BINARY_TO_TEXT_OPTION_REORDER_BLOCKS, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS), expected); } using FriendlyNameDisassemblyTest = spvtest::TextToBinaryTest; TEST_F(FriendlyNameDisassemblyTest, Sample) { const std::string input = R"( OpCapability Shader OpMemoryModel Logical GLSL450 %1 = OpTypeInt 32 0 %2 = OpTypeStruct %1 %3 %4 %5 %6 %7 %8 %9 %10 ; force IDs into double digits %11 = OpConstant %1 42 )"; const std::string expected = R"(OpCapability Shader OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %_struct_2 = OpTypeStruct %uint %3 %4 %5 %6 %7 %8 %9 %10 %uint_42 = OpConstant %uint 42 )"; EXPECT_THAT(EncodeAndDecodeSuccessfully( input, SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES), expected); } TEST_F(TextToBinaryTest, ShowByteOffsetsWhenRequested) { const std::string input = R"( OpCapability Shader OpMemoryModel Logical GLSL450 %1 = OpTypeInt 32 0 %2 = OpTypeVoid )"; const std::string expected = R"(OpCapability Shader ; 0x00000014 OpMemoryModel Logical GLSL450 ; 0x0000001c %1 = OpTypeInt 32 0 ; 0x00000028 %2 = OpTypeVoid ; 0x00000038 )"; EXPECT_THAT(EncodeAndDecodeSuccessfully( input, SPV_BINARY_TO_TEXT_OPTION_SHOW_BYTE_OFFSET), expected); } TEST_F(TextToBinaryTest, Comments) { const std::string input = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %63 "main" %4 %22 OpExecutionMode %63 OriginUpperLeft OpSource GLSL 450 OpName %4 "_ue" OpName %8 "_uf" OpName %11 "_ug" OpName %12 "_uA" OpMemberName %12 0 "_ux" OpName %14 "_uc" OpName %15 "_uB" OpMemberName %15 0 "_ux" OpName %20 "_ud" OpName %22 "_ucol" OpName %26 "ANGLEDepthRangeParams" OpMemberName %26 0 "near" OpMemberName %26 1 "far" OpMemberName %26 2 "diff" OpMemberName %26 3 "reserved" OpName %27 "ANGLEUniformBlock" OpMemberName %27 0 "viewport" OpMemberName %27 1 "clipDistancesEnabled" OpMemberName %27 2 "xfbActiveUnpaused" OpMemberName %27 3 "xfbVerticesPerInstance" OpMemberName %27 4 "numSamples" OpMemberName %27 5 "xfbBufferOffsets" OpMemberName %27 6 "acbBufferOffsets" OpMemberName %27 7 "depthRange" OpName %29 "ANGLEUniforms" OpName %33 "_uc" OpName %32 "_uh" OpName %49 "_ux" OpName %50 "_uy" OpName %48 "_ui" OpName %63 "main" OpName %65 "param" OpName %68 "param" OpName %73 "param" OpDecorate %4 Location 0 OpDecorate %8 RelaxedPrecision OpDecorate %8 DescriptorSet 0 OpDecorate %8 Binding 0 OpDecorate %11 DescriptorSet 0 OpDecorate %11 Binding 1 OpMemberDecorate %12 0 Offset 0 OpMemberDecorate %12 0 RelaxedPrecision OpDecorate %12 Block OpDecorate %14 DescriptorSet 0 OpDecorate %14 Binding 2 OpMemberDecorate %15 0 Offset 0 OpMemberDecorate %15 0 RelaxedPrecision OpDecorate %15 BufferBlock OpDecorate %20 DescriptorSet 0 OpDecorate %20 Binding 3 OpDecorate %22 RelaxedPrecision OpDecorate %22 Location 0 OpMemberDecorate %26 0 Offset 0 OpMemberDecorate %26 1 Offset 4 OpMemberDecorate %26 2 Offset 8 OpMemberDecorate %26 3 Offset 12 OpMemberDecorate %27 0 Offset 0 OpMemberDecorate %27 1 Offset 16 OpMemberDecorate %27 2 Offset 20 OpMemberDecorate %27 3 Offset 24 OpMemberDecorate %27 4 Offset 28 OpMemberDecorate %27 5 Offset 32 OpMemberDecorate %27 6 Offset 48 OpMemberDecorate %27 7 Offset 64 OpMemberDecorate %27 2 RelaxedPrecision OpMemberDecorate %27 4 RelaxedPrecision OpDecorate %27 Block OpDecorate %29 DescriptorSet 0 OpDecorate %29 Binding 4 OpDecorate %32 RelaxedPrecision OpDecorate %33 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %38 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %41 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %43 RelaxedPrecision OpDecorate %48 RelaxedPrecision OpDecorate %49 RelaxedPrecision OpDecorate %50 RelaxedPrecision OpDecorate %52 RelaxedPrecision OpDecorate %53 RelaxedPrecision OpDecorate %54 RelaxedPrecision OpDecorate %55 RelaxedPrecision OpDecorate %56 RelaxedPrecision OpDecorate %57 RelaxedPrecision OpDecorate %58 RelaxedPrecision OpDecorate %59 RelaxedPrecision OpDecorate %60 RelaxedPrecision OpDecorate %67 RelaxedPrecision OpDecorate %68 RelaxedPrecision OpDecorate %72 RelaxedPrecision OpDecorate %73 RelaxedPrecision OpDecorate %75 RelaxedPrecision OpDecorate %76 RelaxedPrecision OpDecorate %77 RelaxedPrecision OpDecorate %80 RelaxedPrecision OpDecorate %81 RelaxedPrecision %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeImage %1 2D 0 0 0 1 Unknown %6 = OpTypeSampledImage %5 %9 = OpTypeImage %1 2D 0 0 0 2 Rgba8 %12 = OpTypeStruct %2 %15 = OpTypeStruct %2 %16 = OpTypeInt 32 0 %17 = OpConstant %16 2 %18 = OpTypeArray %15 %17 %23 = OpTypeInt 32 1 %24 = OpTypeVector %23 4 %25 = OpTypeVector %16 4 %26 = OpTypeStruct %1 %1 %1 %1 %27 = OpTypeStruct %2 %16 %16 %23 %23 %24 %25 %26 %35 = OpTypeVector %1 2 %40 = OpTypeVector %23 2 %61 = OpTypeVoid %69 = OpConstant %16 0 %78 = OpConstant %16 1 %3 = OpTypePointer Input %2 %7 = OpTypePointer UniformConstant %6 %10 = OpTypePointer UniformConstant %9 %13 = OpTypePointer Uniform %12 %19 = OpTypePointer Uniform %18 %21 = OpTypePointer Output %2 %28 = OpTypePointer Uniform %27 %30 = OpTypePointer Function %2 %70 = OpTypePointer Uniform %2 %31 = OpTypeFunction %2 %30 %47 = OpTypeFunction %2 %30 %30 %62 = OpTypeFunction %61 %4 = OpVariable %3 Input %8 = OpVariable %7 UniformConstant %11 = OpVariable %10 UniformConstant %14 = OpVariable %13 Uniform %20 = OpVariable %19 Uniform %22 = OpVariable %21 Output %29 = OpVariable %28 Uniform %32 = OpFunction %2 None %31 %33 = OpFunctionParameter %30 %34 = OpLabel %36 = OpLoad %6 %8 %37 = OpLoad %2 %33 %38 = OpVectorShuffle %35 %37 %37 0 1 %39 = OpImageSampleImplicitLod %2 %36 %38 %41 = OpLoad %2 %33 %42 = OpVectorShuffle %35 %41 %41 2 3 %43 = OpConvertFToS %40 %42 %44 = OpLoad %9 %11 %45 = OpImageRead %2 %44 %43 %46 = OpFAdd %2 %39 %45 OpReturnValue %46 OpFunctionEnd %48 = OpFunction %2 None %47 %49 = OpFunctionParameter %30 %50 = OpFunctionParameter %30 %51 = OpLabel %52 = OpLoad %2 %49 %53 = OpVectorShuffle %35 %52 %52 0 1 %54 = OpLoad %2 %50 %55 = OpVectorShuffle %35 %54 %54 2 3 %56 = OpCompositeExtract %1 %53 0 %57 = OpCompositeExtract %1 %53 1 %58 = OpCompositeExtract %1 %55 0 %59 = OpCompositeExtract %1 %55 1 %60 = OpCompositeConstruct %2 %56 %57 %58 %59 OpReturnValue %60 OpFunctionEnd %63 = OpFunction %61 None %62 %64 = OpLabel %65 = OpVariable %30 Function %68 = OpVariable %30 Function %73 = OpVariable %30 Function %66 = OpLoad %2 %4 OpStore %65 %66 %67 = OpFunctionCall %2 %32 %65 %71 = OpAccessChain %70 %14 %69 %72 = OpLoad %2 %71 OpStore %68 %72 %74 = OpAccessChain %70 %20 %69 %69 %75 = OpLoad %2 %74 OpStore %73 %75 %76 = OpFunctionCall %2 %48 %68 %73 %77 = OpFAdd %2 %67 %76 %79 = OpAccessChain %70 %20 %78 %69 %80 = OpLoad %2 %79 %81 = OpFAdd %2 %77 %80 OpStore %22 %81 OpReturn OpFunctionEnd )"; const std::string expected = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %63 "main" %4 %22 OpExecutionMode %63 OriginUpperLeft ; Debug Information OpSource GLSL 450 OpName %4 "_ue" ; id %4 OpName %8 "_uf" ; id %8 OpName %11 "_ug" ; id %11 OpName %12 "_uA" ; id %12 OpMemberName %12 0 "_ux" OpName %14 "_uc" ; id %14 OpName %15 "_uB" ; id %15 OpMemberName %15 0 "_ux" OpName %20 "_ud" ; id %20 OpName %22 "_ucol" ; id %22 OpName %26 "ANGLEDepthRangeParams" ; id %26 OpMemberName %26 0 "near" OpMemberName %26 1 "far" OpMemberName %26 2 "diff" OpMemberName %26 3 "reserved" OpName %27 "ANGLEUniformBlock" ; id %27 OpMemberName %27 0 "viewport" OpMemberName %27 1 "clipDistancesEnabled" OpMemberName %27 2 "xfbActiveUnpaused" OpMemberName %27 3 "xfbVerticesPerInstance" OpMemberName %27 4 "numSamples" OpMemberName %27 5 "xfbBufferOffsets" OpMemberName %27 6 "acbBufferOffsets" OpMemberName %27 7 "depthRange" OpName %29 "ANGLEUniforms" ; id %29 OpName %33 "_uc" ; id %33 OpName %32 "_uh" ; id %32 OpName %49 "_ux" ; id %49 OpName %50 "_uy" ; id %50 OpName %48 "_ui" ; id %48 OpName %63 "main" ; id %63 OpName %65 "param" ; id %65 OpName %68 "param" ; id %68 OpName %73 "param" ; id %73 ; Annotations OpDecorate %4 Location 0 OpDecorate %8 RelaxedPrecision OpDecorate %8 DescriptorSet 0 OpDecorate %8 Binding 0 OpDecorate %11 DescriptorSet 0 OpDecorate %11 Binding 1 OpMemberDecorate %12 0 Offset 0 OpMemberDecorate %12 0 RelaxedPrecision OpDecorate %12 Block OpDecorate %14 DescriptorSet 0 OpDecorate %14 Binding 2 OpMemberDecorate %15 0 Offset 0 OpMemberDecorate %15 0 RelaxedPrecision OpDecorate %15 BufferBlock OpDecorate %20 DescriptorSet 0 OpDecorate %20 Binding 3 OpDecorate %22 RelaxedPrecision OpDecorate %22 Location 0 OpMemberDecorate %26 0 Offset 0 OpMemberDecorate %26 1 Offset 4 OpMemberDecorate %26 2 Offset 8 OpMemberDecorate %26 3 Offset 12 OpMemberDecorate %27 0 Offset 0 OpMemberDecorate %27 1 Offset 16 OpMemberDecorate %27 2 Offset 20 OpMemberDecorate %27 3 Offset 24 OpMemberDecorate %27 4 Offset 28 OpMemberDecorate %27 5 Offset 32 OpMemberDecorate %27 6 Offset 48 OpMemberDecorate %27 7 Offset 64 OpMemberDecorate %27 2 RelaxedPrecision OpMemberDecorate %27 4 RelaxedPrecision OpDecorate %27 Block OpDecorate %29 DescriptorSet 0 OpDecorate %29 Binding 4 OpDecorate %32 RelaxedPrecision OpDecorate %33 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %38 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %41 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %43 RelaxedPrecision OpDecorate %48 RelaxedPrecision OpDecorate %49 RelaxedPrecision OpDecorate %50 RelaxedPrecision OpDecorate %52 RelaxedPrecision OpDecorate %53 RelaxedPrecision OpDecorate %54 RelaxedPrecision OpDecorate %55 RelaxedPrecision OpDecorate %56 RelaxedPrecision OpDecorate %57 RelaxedPrecision OpDecorate %58 RelaxedPrecision OpDecorate %59 RelaxedPrecision OpDecorate %60 RelaxedPrecision OpDecorate %67 RelaxedPrecision OpDecorate %68 RelaxedPrecision OpDecorate %72 RelaxedPrecision OpDecorate %73 RelaxedPrecision OpDecorate %75 RelaxedPrecision OpDecorate %76 RelaxedPrecision OpDecorate %77 RelaxedPrecision OpDecorate %80 RelaxedPrecision OpDecorate %81 RelaxedPrecision ; Types, variables and constants %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeImage %1 2D 0 0 0 1 Unknown %6 = OpTypeSampledImage %5 %9 = OpTypeImage %1 2D 0 0 0 2 Rgba8 %12 = OpTypeStruct %2 ; Block %15 = OpTypeStruct %2 ; BufferBlock %16 = OpTypeInt 32 0 %17 = OpConstant %16 2 %18 = OpTypeArray %15 %17 %23 = OpTypeInt 32 1 %24 = OpTypeVector %23 4 %25 = OpTypeVector %16 4 %26 = OpTypeStruct %1 %1 %1 %1 %27 = OpTypeStruct %2 %16 %16 %23 %23 %24 %25 %26 ; Block %35 = OpTypeVector %1 2 %40 = OpTypeVector %23 2 %61 = OpTypeVoid %69 = OpConstant %16 0 %78 = OpConstant %16 1 %3 = OpTypePointer Input %2 %7 = OpTypePointer UniformConstant %6 %10 = OpTypePointer UniformConstant %9 %13 = OpTypePointer Uniform %12 %19 = OpTypePointer Uniform %18 %21 = OpTypePointer Output %2 %28 = OpTypePointer Uniform %27 %30 = OpTypePointer Function %2 %70 = OpTypePointer Uniform %2 %31 = OpTypeFunction %2 %30 %47 = OpTypeFunction %2 %30 %30 %62 = OpTypeFunction %61 %4 = OpVariable %3 Input ; Location 0 %8 = OpVariable %7 UniformConstant ; RelaxedPrecision, DescriptorSet 0, Binding 0 %11 = OpVariable %10 UniformConstant ; DescriptorSet 0, Binding 1 %14 = OpVariable %13 Uniform ; DescriptorSet 0, Binding 2 %20 = OpVariable %19 Uniform ; DescriptorSet 0, Binding 3 %22 = OpVariable %21 Output ; RelaxedPrecision, Location 0 %29 = OpVariable %28 Uniform ; DescriptorSet 0, Binding 4 ; Function 32 %32 = OpFunction %2 None %31 ; RelaxedPrecision %33 = OpFunctionParameter %30 ; RelaxedPrecision %34 = OpLabel %36 = OpLoad %6 %8 ; RelaxedPrecision %37 = OpLoad %2 %33 ; RelaxedPrecision %38 = OpVectorShuffle %35 %37 %37 0 1 ; RelaxedPrecision %39 = OpImageSampleImplicitLod %2 %36 %38 ; RelaxedPrecision %41 = OpLoad %2 %33 ; RelaxedPrecision %42 = OpVectorShuffle %35 %41 %41 2 3 ; RelaxedPrecision %43 = OpConvertFToS %40 %42 ; RelaxedPrecision %44 = OpLoad %9 %11 %45 = OpImageRead %2 %44 %43 %46 = OpFAdd %2 %39 %45 OpReturnValue %46 OpFunctionEnd ; Function 48 %48 = OpFunction %2 None %47 ; RelaxedPrecision %49 = OpFunctionParameter %30 ; RelaxedPrecision %50 = OpFunctionParameter %30 ; RelaxedPrecision %51 = OpLabel %52 = OpLoad %2 %49 ; RelaxedPrecision %53 = OpVectorShuffle %35 %52 %52 0 1 ; RelaxedPrecision %54 = OpLoad %2 %50 ; RelaxedPrecision %55 = OpVectorShuffle %35 %54 %54 2 3 ; RelaxedPrecision %56 = OpCompositeExtract %1 %53 0 ; RelaxedPrecision %57 = OpCompositeExtract %1 %53 1 ; RelaxedPrecision %58 = OpCompositeExtract %1 %55 0 ; RelaxedPrecision %59 = OpCompositeExtract %1 %55 1 ; RelaxedPrecision %60 = OpCompositeConstruct %2 %56 %57 %58 %59 ; RelaxedPrecision OpReturnValue %60 OpFunctionEnd ; Function 63 %63 = OpFunction %61 None %62 %64 = OpLabel %65 = OpVariable %30 Function %68 = OpVariable %30 Function ; RelaxedPrecision %73 = OpVariable %30 Function ; RelaxedPrecision %66 = OpLoad %2 %4 OpStore %65 %66 %67 = OpFunctionCall %2 %32 %65 ; RelaxedPrecision %71 = OpAccessChain %70 %14 %69 %72 = OpLoad %2 %71 ; RelaxedPrecision OpStore %68 %72 %74 = OpAccessChain %70 %20 %69 %69 %75 = OpLoad %2 %74 ; RelaxedPrecision OpStore %73 %75 %76 = OpFunctionCall %2 %48 %68 %73 ; RelaxedPrecision %77 = OpFAdd %2 %67 %76 ; RelaxedPrecision %79 = OpAccessChain %70 %20 %78 %69 %80 = OpLoad %2 %79 ; RelaxedPrecision %81 = OpFAdd %2 %77 %80 ; RelaxedPrecision OpStore %22 %81 OpReturn OpFunctionEnd )"; EXPECT_THAT( EncodeAndDecodeSuccessfully( input, SPV_BINARY_TO_TEXT_OPTION_COMMENT | SPV_BINARY_TO_TEXT_OPTION_INDENT, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS), expected); } TEST_F(TextToBinaryTest, NestedWithComments) { const std::string input = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %8 %44 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "v" OpName %44 "color" OpDecorate %8 RelaxedPrecision OpDecorate %8 Location 0 OpDecorate %9 RelaxedPrecision OpDecorate %18 RelaxedPrecision OpDecorate %19 RelaxedPrecision OpDecorate %20 RelaxedPrecision OpDecorate %23 RelaxedPrecision OpDecorate %24 RelaxedPrecision OpDecorate %25 RelaxedPrecision OpDecorate %26 RelaxedPrecision OpDecorate %27 RelaxedPrecision OpDecorate %28 RelaxedPrecision OpDecorate %29 RelaxedPrecision OpDecorate %30 RelaxedPrecision OpDecorate %31 RelaxedPrecision OpDecorate %33 RelaxedPrecision OpDecorate %34 RelaxedPrecision OpDecorate %35 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %40 RelaxedPrecision OpDecorate %41 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %44 RelaxedPrecision OpDecorate %44 Location 0 OpDecorate %45 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Input %6 %8 = OpVariable %7 Input %10 = OpConstant %6 0 %11 = OpTypeBool %15 = OpTypeVector %6 4 %16 = OpTypePointer Function %15 %21 = OpConstant %6 -0.5 %22 = OpConstant %6 -0.300000012 %38 = OpConstant %6 0.5 %43 = OpTypePointer Output %15 %44 = OpVariable %43 Output %4 = OpFunction %2 None %3 %5 = OpLabel %9 = OpLoad %6 %8 %12 = OpFOrdLessThanEqual %11 %9 %10 OpSelectionMerge %14 None OpBranchConditional %12 %13 %32 %13 = OpLabel %18 = OpLoad %6 %8 %19 = OpExtInst %6 %1 Log %18 %20 = OpLoad %6 %8 %23 = OpExtInst %6 %1 FClamp %20 %21 %22 %24 = OpFMul %6 %19 %23 %25 = OpLoad %6 %8 %26 = OpExtInst %6 %1 Sin %25 %27 = OpLoad %6 %8 %28 = OpExtInst %6 %1 Cos %27 %29 = OpLoad %6 %8 %30 = OpExtInst %6 %1 Exp %29 %31 = OpCompositeConstruct %15 %24 %26 %28 %30 OpBranch %14 %32 = OpLabel %33 = OpLoad %6 %8 %34 = OpExtInst %6 %1 Sqrt %33 %35 = OpLoad %6 %8 %36 = OpExtInst %6 %1 FSign %35 %37 = OpLoad %6 %8 %39 = OpExtInst %6 %1 FMax %37 %38 %40 = OpLoad %6 %8 %41 = OpExtInst %6 %1 Floor %40 %42 = OpCompositeConstruct %15 %34 %36 %39 %41 OpBranch %14 %14 = OpLabel %45 = OpPhi %15 %31 %13 %42 %32 OpStore %44 %45 OpReturn OpFunctionEnd )"; const std::string expected = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %8 %44 OpExecutionMode %4 OriginUpperLeft ; Debug Information OpSource ESSL 310 OpName %4 "main" ; id %4 OpName %8 "v" ; id %8 OpName %44 "color" ; id %44 ; Annotations OpDecorate %8 RelaxedPrecision OpDecorate %8 Location 0 OpDecorate %9 RelaxedPrecision OpDecorate %18 RelaxedPrecision OpDecorate %19 RelaxedPrecision OpDecorate %20 RelaxedPrecision OpDecorate %23 RelaxedPrecision OpDecorate %24 RelaxedPrecision OpDecorate %25 RelaxedPrecision OpDecorate %26 RelaxedPrecision OpDecorate %27 RelaxedPrecision OpDecorate %28 RelaxedPrecision OpDecorate %29 RelaxedPrecision OpDecorate %30 RelaxedPrecision OpDecorate %31 RelaxedPrecision OpDecorate %33 RelaxedPrecision OpDecorate %34 RelaxedPrecision OpDecorate %35 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %40 RelaxedPrecision OpDecorate %41 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %44 RelaxedPrecision OpDecorate %44 Location 0 OpDecorate %45 RelaxedPrecision ; Types, variables and constants %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Input %6 %8 = OpVariable %7 Input ; RelaxedPrecision, Location 0 %10 = OpConstant %6 0 %11 = OpTypeBool %15 = OpTypeVector %6 4 %16 = OpTypePointer Function %15 %21 = OpConstant %6 -0.5 %22 = OpConstant %6 -0.300000012 %38 = OpConstant %6 0.5 %43 = OpTypePointer Output %15 %44 = OpVariable %43 Output ; RelaxedPrecision, Location 0 ; Function 4 %4 = OpFunction %2 None %3 %5 = OpLabel %9 = OpLoad %6 %8 ; RelaxedPrecision %12 = OpFOrdLessThanEqual %11 %9 %10 OpSelectionMerge %14 None OpBranchConditional %12 %13 %32 %13 = OpLabel %18 = OpLoad %6 %8 ; RelaxedPrecision %19 = OpExtInst %6 %1 Log %18 ; RelaxedPrecision %20 = OpLoad %6 %8 ; RelaxedPrecision %23 = OpExtInst %6 %1 FClamp %20 %21 %22 ; RelaxedPrecision %24 = OpFMul %6 %19 %23 ; RelaxedPrecision %25 = OpLoad %6 %8 ; RelaxedPrecision %26 = OpExtInst %6 %1 Sin %25 ; RelaxedPrecision %27 = OpLoad %6 %8 ; RelaxedPrecision %28 = OpExtInst %6 %1 Cos %27 ; RelaxedPrecision %29 = OpLoad %6 %8 ; RelaxedPrecision %30 = OpExtInst %6 %1 Exp %29 ; RelaxedPrecision %31 = OpCompositeConstruct %15 %24 %26 %28 %30 ; RelaxedPrecision OpBranch %14 %32 = OpLabel %33 = OpLoad %6 %8 ; RelaxedPrecision %34 = OpExtInst %6 %1 Sqrt %33 ; RelaxedPrecision %35 = OpLoad %6 %8 ; RelaxedPrecision %36 = OpExtInst %6 %1 FSign %35 ; RelaxedPrecision %37 = OpLoad %6 %8 ; RelaxedPrecision %39 = OpExtInst %6 %1 FMax %37 %38 ; RelaxedPrecision %40 = OpLoad %6 %8 ; RelaxedPrecision %41 = OpExtInst %6 %1 Floor %40 ; RelaxedPrecision %42 = OpCompositeConstruct %15 %34 %36 %39 %41 ; RelaxedPrecision OpBranch %14 %14 = OpLabel %45 = OpPhi %15 %31 %13 %42 %32 ; RelaxedPrecision OpStore %44 %45 OpReturn OpFunctionEnd )"; EXPECT_THAT( EncodeAndDecodeSuccessfully( input, SPV_BINARY_TO_TEXT_OPTION_COMMENT | SPV_BINARY_TO_TEXT_OPTION_INDENT | SPV_BINARY_TO_TEXT_OPTION_NESTED_INDENT, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS), expected); } // Test version string. TEST_F(TextToBinaryTest, VersionString) { auto words = CompileSuccessfully(""); spv_text decoded_text = nullptr; EXPECT_THAT(spvBinaryToText(ScopedContext().context, words.data(), words.size(), SPV_BINARY_TO_TEXT_OPTION_NONE, &decoded_text, &diagnostic), Eq(SPV_SUCCESS)); EXPECT_EQ(nullptr, diagnostic); EXPECT_THAT(decoded_text->str, HasSubstr("Version: 1.0\n")) << EncodeAndDecodeSuccessfully(""); spvTextDestroy(decoded_text); } // Test generator string. // A test case for the generator string. This allows us to // test both of the 16-bit components of the generator word. struct GeneratorStringCase { uint16_t generator; uint16_t misc; std::string expected; }; using GeneratorStringTest = spvtest::TextToBinaryTestBase< ::testing::TestWithParam>; TEST_P(GeneratorStringTest, Sample) { auto words = CompileSuccessfully(""); EXPECT_EQ(2u, SPV_INDEX_GENERATOR_NUMBER); words[SPV_INDEX_GENERATOR_NUMBER] = SPV_GENERATOR_WORD(GetParam().generator, GetParam().misc); spv_text decoded_text = nullptr; EXPECT_THAT(spvBinaryToText(ScopedContext().context, words.data(), words.size(), SPV_BINARY_TO_TEXT_OPTION_NONE, &decoded_text, &diagnostic), Eq(SPV_SUCCESS)); EXPECT_THAT(diagnostic, Eq(nullptr)); EXPECT_THAT(std::string(decoded_text->str), HasSubstr(GetParam().expected)); spvTextDestroy(decoded_text); } INSTANTIATE_TEST_SUITE_P(GeneratorStrings, GeneratorStringTest, ::testing::ValuesIn(std::vector{ {SPV_GENERATOR_KHRONOS, 12, "Khronos; 12"}, {SPV_GENERATOR_LUNARG, 99, "LunarG; 99"}, {SPV_GENERATOR_VALVE, 1, "Valve; 1"}, {SPV_GENERATOR_CODEPLAY, 65535, "Codeplay; 65535"}, {SPV_GENERATOR_NVIDIA, 19, "NVIDIA; 19"}, {SPV_GENERATOR_ARM, 1000, "ARM; 1000"}, {SPV_GENERATOR_KHRONOS_LLVM_TRANSLATOR, 38, "Khronos LLVM/SPIR-V Translator; 38"}, {SPV_GENERATOR_KHRONOS_ASSEMBLER, 2, "Khronos SPIR-V Tools Assembler; 2"}, {SPV_GENERATOR_KHRONOS_GLSLANG, 1, "Khronos Glslang Reference Front End; 1"}, {1000, 18, "Unknown(1000); 18"}, {65535, 32767, "Unknown(65535); 32767"}, })); // TODO(dneto): Test new instructions and enums in SPIR-V 1.3 } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/c_interface_test.cpp000066400000000000000000000247221475742701700235240ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "gtest/gtest.h" #include "source/table.h" #include "spirv-tools/libspirv.h" namespace spvtools { namespace { // TODO(antiagainst): Use public C API for setting the consumer once exists. #ifndef SPIRV_TOOLS_SHAREDLIB void SetContextMessageConsumer(spv_context context, MessageConsumer consumer) { spvtools::SetContextMessageConsumer(context, consumer); } #else void SetContextMessageConsumer(spv_context, MessageConsumer) {} #endif // The default consumer is a null std::function. TEST(CInterface, DefaultConsumerNullDiagnosticForValidInput) { auto context = spvContextCreate(SPV_ENV_UNIVERSAL_1_1); const char input_text[] = "OpCapability Shader\n" "OpCapability Linkage\n" "OpMemoryModel Logical GLSL450"; spv_binary binary = nullptr; EXPECT_EQ(SPV_SUCCESS, spvTextToBinary(context, input_text, sizeof(input_text), &binary, nullptr)); { // Sadly the compiler don't allow me to feed binary directly to // spvValidate(). spv_const_binary_t b{binary->code, binary->wordCount}; EXPECT_EQ(SPV_SUCCESS, spvValidate(context, &b, nullptr)); } spv_text text = nullptr; EXPECT_EQ(SPV_SUCCESS, spvBinaryToText(context, binary->code, binary->wordCount, 0, &text, nullptr)); spvTextDestroy(text); spvBinaryDestroy(binary); spvContextDestroy(context); } // The default consumer is a null std::function. TEST(CInterface, DefaultConsumerNullDiagnosticForInvalidAssembling) { auto context = spvContextCreate(SPV_ENV_UNIVERSAL_1_1); const char input_text[] = "%1 = OpName"; spv_binary binary = nullptr; EXPECT_EQ(SPV_ERROR_INVALID_TEXT, spvTextToBinary(context, input_text, sizeof(input_text), &binary, nullptr)); spvBinaryDestroy(binary); spvContextDestroy(context); } // The default consumer is a null std::function. TEST(CInterface, DefaultConsumerNullDiagnosticForInvalidDiassembling) { auto context = spvContextCreate(SPV_ENV_UNIVERSAL_1_1); const char input_text[] = "OpNop"; spv_binary binary = nullptr; ASSERT_EQ(SPV_SUCCESS, spvTextToBinary(context, input_text, sizeof(input_text), &binary, nullptr)); // Change OpNop to an invalid (wordcount|opcode) word. binary->code[binary->wordCount - 1] = 0xffffffff; spv_text text = nullptr; EXPECT_EQ(SPV_ERROR_INVALID_BINARY, spvBinaryToText(context, binary->code, binary->wordCount, 0, &text, nullptr)); spvTextDestroy(text); spvBinaryDestroy(binary); spvContextDestroy(context); } // The default consumer is a null std::function. TEST(CInterface, DefaultConsumerNullDiagnosticForInvalidValidating) { auto context = spvContextCreate(SPV_ENV_UNIVERSAL_1_1); const char input_text[] = "OpNop"; spv_binary binary = nullptr; ASSERT_EQ(SPV_SUCCESS, spvTextToBinary(context, input_text, sizeof(input_text), &binary, nullptr)); spv_const_binary_t b{binary->code, binary->wordCount}; EXPECT_EQ(SPV_ERROR_INVALID_LAYOUT, spvValidate(context, &b, nullptr)); spvBinaryDestroy(binary); spvContextDestroy(context); } TEST(CInterface, SpecifyConsumerNullDiagnosticForAssembling) { const char input_text[] = " OpName\n"; auto context = spvContextCreate(SPV_ENV_UNIVERSAL_1_1); int invocation = 0; SetContextMessageConsumer( context, [&invocation](spv_message_level_t level, const char* source, const spv_position_t& position, const char* message) { ++invocation; EXPECT_EQ(SPV_MSG_ERROR, level); // The error happens at scanning the beginning of second line. EXPECT_STREQ("input", source); EXPECT_EQ(1u, position.line); EXPECT_EQ(0u, position.column); EXPECT_EQ(12u, position.index); EXPECT_STREQ( "Expected operand for OpName instruction, but found the end of the " "stream.", message); }); spv_binary binary = nullptr; EXPECT_EQ(SPV_ERROR_INVALID_TEXT, spvTextToBinary(context, input_text, sizeof(input_text), &binary, nullptr)); #ifndef SPIRV_TOOLS_SHAREDLIB EXPECT_EQ(1, invocation); #endif spvBinaryDestroy(binary); spvContextDestroy(context); } TEST(CInterface, SpecifyConsumerNullDiagnosticForDisassembling) { const char input_text[] = "OpNop"; auto context = spvContextCreate(SPV_ENV_UNIVERSAL_1_1); int invocation = 0; SetContextMessageConsumer( context, [&invocation](spv_message_level_t level, const char* source, const spv_position_t& position, const char* message) { ++invocation; EXPECT_EQ(SPV_MSG_ERROR, level); EXPECT_STREQ("input", source); EXPECT_EQ(0u, position.line); EXPECT_EQ(0u, position.column); EXPECT_EQ(1u, position.index); EXPECT_STREQ("Invalid opcode: 65535", message); }); spv_binary binary = nullptr; ASSERT_EQ(SPV_SUCCESS, spvTextToBinary(context, input_text, sizeof(input_text), &binary, nullptr)); // Change OpNop to an invalid (wordcount|opcode) word. binary->code[binary->wordCount - 1] = 0xffffffff; spv_text text = nullptr; EXPECT_EQ(SPV_ERROR_INVALID_BINARY, spvBinaryToText(context, binary->code, binary->wordCount, 0, &text, nullptr)); #ifndef SPIRV_TOOLS_SHAREDLIB EXPECT_EQ(1, invocation); #endif spvTextDestroy(text); spvBinaryDestroy(binary); spvContextDestroy(context); } TEST(CInterface, SpecifyConsumerNullDiagnosticForValidating) { const char input_text[] = "OpNop"; auto context = spvContextCreate(SPV_ENV_UNIVERSAL_1_1); int invocation = 0; SetContextMessageConsumer( context, [&invocation](spv_message_level_t level, const char* source, const spv_position_t& position, const char* message) { ++invocation; EXPECT_EQ(SPV_MSG_ERROR, level); EXPECT_STREQ("input", source); EXPECT_EQ(0u, position.line); EXPECT_EQ(0u, position.column); // TODO(antiagainst): what validation reports is not a word offset here. // It is inconsistent with diassembler. Should be fixed. EXPECT_EQ(1u, position.index); EXPECT_STREQ( "Nop cannot appear before the memory model instruction\n" " OpNop\n", message); }); spv_binary binary = nullptr; ASSERT_EQ(SPV_SUCCESS, spvTextToBinary(context, input_text, sizeof(input_text), &binary, nullptr)); spv_const_binary_t b{binary->code, binary->wordCount}; EXPECT_EQ(SPV_ERROR_INVALID_LAYOUT, spvValidate(context, &b, nullptr)); #ifndef SPIRV_TOOLS_SHAREDLIB EXPECT_EQ(1, invocation); #endif spvBinaryDestroy(binary); spvContextDestroy(context); } // When having both a consumer and an diagnostic object, the diagnostic object // should take priority. TEST(CInterface, SpecifyConsumerSpecifyDiagnosticForAssembling) { const char input_text[] = " OpName"; auto context = spvContextCreate(SPV_ENV_UNIVERSAL_1_1); int invocation = 0; SetContextMessageConsumer( context, [&invocation](spv_message_level_t, const char*, const spv_position_t&, const char*) { ++invocation; }); spv_binary binary = nullptr; spv_diagnostic diagnostic = nullptr; EXPECT_EQ(SPV_ERROR_INVALID_TEXT, spvTextToBinary(context, input_text, sizeof(input_text), &binary, &diagnostic)); EXPECT_EQ(0, invocation); // Consumer should not be invoked at all. EXPECT_STREQ( "Expected operand for OpName instruction, but found the end of the " "stream.", diagnostic->error); spvDiagnosticDestroy(diagnostic); spvBinaryDestroy(binary); spvContextDestroy(context); } TEST(CInterface, SpecifyConsumerSpecifyDiagnosticForDisassembling) { const char input_text[] = "OpNop"; auto context = spvContextCreate(SPV_ENV_UNIVERSAL_1_1); int invocation = 0; SetContextMessageConsumer( context, [&invocation](spv_message_level_t, const char*, const spv_position_t&, const char*) { ++invocation; }); spv_binary binary = nullptr; ASSERT_EQ(SPV_SUCCESS, spvTextToBinary(context, input_text, sizeof(input_text), &binary, nullptr)); // Change OpNop to an invalid (wordcount|opcode) word. binary->code[binary->wordCount - 1] = 0xffffffff; spv_diagnostic diagnostic = nullptr; spv_text text = nullptr; EXPECT_EQ(SPV_ERROR_INVALID_BINARY, spvBinaryToText(context, binary->code, binary->wordCount, 0, &text, &diagnostic)); EXPECT_EQ(0, invocation); // Consumer should not be invoked at all. EXPECT_STREQ("Invalid opcode: 65535", diagnostic->error); spvTextDestroy(text); spvDiagnosticDestroy(diagnostic); spvBinaryDestroy(binary); spvContextDestroy(context); } TEST(CInterface, SpecifyConsumerSpecifyDiagnosticForValidating) { const char input_text[] = "OpNop"; auto context = spvContextCreate(SPV_ENV_UNIVERSAL_1_1); int invocation = 0; SetContextMessageConsumer( context, [&invocation](spv_message_level_t, const char*, const spv_position_t&, const char*) { ++invocation; }); spv_binary binary = nullptr; ASSERT_EQ(SPV_SUCCESS, spvTextToBinary(context, input_text, sizeof(input_text), &binary, nullptr)); spv_diagnostic diagnostic = nullptr; spv_const_binary_t b{binary->code, binary->wordCount}; EXPECT_EQ(SPV_ERROR_INVALID_LAYOUT, spvValidate(context, &b, &diagnostic)); EXPECT_EQ(0, invocation); // Consumer should not be invoked at all. EXPECT_STREQ( "Nop cannot appear before the memory model instruction\n" " OpNop\n", diagnostic->error); spvDiagnosticDestroy(diagnostic); spvBinaryDestroy(binary); spvContextDestroy(context); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/comment_test.cpp000066400000000000000000000032331475742701700227160ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gmock/gmock.h" #include "source/util/string_utils.h" #include "test/test_fixture.h" #include "test/unit_spirv.h" namespace spvtools { namespace { using spvtest::Concatenate; using spvtest::MakeInstruction; using utils::MakeVector; using spvtest::TextToBinaryTest; using testing::Eq; TEST_F(TextToBinaryTest, Whitespace) { std::string input = R"( ; I'm a proud comment at the beginning of the file ; I hide: OpCapability Shader OpMemoryModel Logical Simple ; comment after instruction ;;;;;;;; many ;'s %glsl450 = OpExtInstImport "GLSL.std.450" ; comment indented )"; EXPECT_THAT( CompiledInstructions(input), Eq(Concatenate({MakeInstruction(spv::Op::OpMemoryModel, {uint32_t(spv::AddressingModel::Logical), uint32_t(spv::MemoryModel::Simple)}), MakeInstruction(spv::Op::OpExtInstImport, {1}, MakeVector("GLSL.std.450"))}))); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/cpp_interface_test.cpp000066400000000000000000000300461475742701700240600ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include "gmock/gmock.h" #include "gtest/gtest.h" #include "spirv-tools/optimizer.hpp" #include "spirv/unified1/spirv.hpp11" namespace spvtools { namespace { using ::testing::ContainerEq; using ::testing::HasSubstr; // Return a string that contains the minimum instructions needed to form // a valid module. Other instructions can be appended to this string. std::string Header() { return R"(OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 )"; } // When we assemble with a target environment of SPIR-V 1.1, we expect // the following in the module header version word. const uint32_t kExpectedSpvVersion = 0x10100; TEST(CppInterface, SuccessfulRoundTrip) { const std::string input_text = "%2 = OpSizeOf %1 %3\n"; SpirvTools t(SPV_ENV_UNIVERSAL_1_1); std::vector binary; EXPECT_TRUE(t.Assemble(input_text, &binary)); EXPECT_TRUE(binary.size() > 5u); EXPECT_EQ(spv::MagicNumber, binary[0]); EXPECT_EQ(kExpectedSpvVersion, binary[1]); // This cannot pass validation since %1 is not defined. t.SetMessageConsumer([](spv_message_level_t level, const char* source, const spv_position_t& position, const char* message) { EXPECT_EQ(SPV_MSG_ERROR, level); EXPECT_STREQ("input", source); EXPECT_EQ(0u, position.line); EXPECT_EQ(0u, position.column); EXPECT_EQ(1u, position.index); EXPECT_STREQ("ID '1[%1]' has not been defined\n %2 = OpSizeOf %1 %3\n", message); }); EXPECT_FALSE(t.Validate(binary)); std::string output_text; EXPECT_TRUE(t.Disassemble(binary, &output_text)); EXPECT_EQ(input_text, output_text); } TEST(CppInterface, AssembleEmptyModule) { std::vector binary(10, 42); SpirvTools t(SPV_ENV_UNIVERSAL_1_1); EXPECT_TRUE(t.Assemble("", &binary)); // We only have the header. EXPECT_EQ(5u, binary.size()); EXPECT_EQ(spv::MagicNumber, binary[0]); EXPECT_EQ(kExpectedSpvVersion, binary[1]); } TEST(CppInterface, AssembleOverloads) { const std::string input_text = "%2 = OpSizeOf %1 %3\n"; SpirvTools t(SPV_ENV_UNIVERSAL_1_1); { std::vector binary; EXPECT_TRUE(t.Assemble(input_text, &binary)); EXPECT_TRUE(binary.size() > 5u); EXPECT_EQ(spv::MagicNumber, binary[0]); EXPECT_EQ(kExpectedSpvVersion, binary[1]); } { std::vector binary; EXPECT_TRUE(t.Assemble(input_text.data(), input_text.size(), &binary)); EXPECT_TRUE(binary.size() > 5u); EXPECT_EQ(spv::MagicNumber, binary[0]); EXPECT_EQ(kExpectedSpvVersion, binary[1]); } { // Ignore the last newline. std::vector binary; EXPECT_TRUE(t.Assemble(input_text.data(), input_text.size() - 1, &binary)); EXPECT_TRUE(binary.size() > 5u); EXPECT_EQ(spv::MagicNumber, binary[0]); EXPECT_EQ(kExpectedSpvVersion, binary[1]); } } TEST(CppInterface, DisassembleEmptyModule) { std::string text(10, 'x'); SpirvTools t(SPV_ENV_UNIVERSAL_1_1); int invocation_count = 0; t.SetMessageConsumer( [&invocation_count](spv_message_level_t level, const char* source, const spv_position_t& position, const char* message) { ++invocation_count; EXPECT_EQ(SPV_MSG_ERROR, level); EXPECT_STREQ("input", source); EXPECT_EQ(0u, position.line); EXPECT_EQ(0u, position.column); EXPECT_EQ(0u, position.index); EXPECT_STREQ("Missing module.", message); }); EXPECT_FALSE(t.Disassemble({}, &text)); EXPECT_EQ("xxxxxxxxxx", text); // The original string is unmodified. EXPECT_EQ(1, invocation_count); } TEST(CppInterface, DisassembleOverloads) { const std::string input_text = "%2 = OpSizeOf %1 %3\n"; SpirvTools t(SPV_ENV_UNIVERSAL_1_1); std::vector binary; EXPECT_TRUE(t.Assemble(input_text, &binary)); { std::string output_text; EXPECT_TRUE(t.Disassemble(binary, &output_text)); EXPECT_EQ(input_text, output_text); } { std::string output_text; EXPECT_TRUE(t.Disassemble(binary.data(), binary.size(), &output_text)); EXPECT_EQ(input_text, output_text); } } TEST(CppInterface, SuccessfulValidation) { SpirvTools t(SPV_ENV_UNIVERSAL_1_1); int invocation_count = 0; t.SetMessageConsumer([&invocation_count](spv_message_level_t, const char*, const spv_position_t&, const char*) { ++invocation_count; }); std::vector binary; EXPECT_TRUE(t.Assemble(Header(), &binary)); EXPECT_TRUE(t.Validate(binary)); EXPECT_EQ(0, invocation_count); } TEST(CppInterface, ValidateOverloads) { SpirvTools t(SPV_ENV_UNIVERSAL_1_1); std::vector binary; EXPECT_TRUE(t.Assemble(Header(), &binary)); { EXPECT_TRUE(t.Validate(binary)); } { EXPECT_TRUE(t.Validate(binary.data(), binary.size())); } } TEST(CppInterface, ValidateEmptyModule) { SpirvTools t(SPV_ENV_UNIVERSAL_1_1); int invocation_count = 0; t.SetMessageConsumer( [&invocation_count](spv_message_level_t level, const char* source, const spv_position_t& position, const char* message) { ++invocation_count; EXPECT_EQ(SPV_MSG_ERROR, level); EXPECT_STREQ("input", source); EXPECT_EQ(0u, position.line); EXPECT_EQ(0u, position.column); EXPECT_EQ(0u, position.index); EXPECT_STREQ("Invalid SPIR-V magic number.", message); }); EXPECT_FALSE(t.Validate({})); EXPECT_EQ(1, invocation_count); } // Returns the assembly for a SPIR-V module with a struct declaration // with the given number of members. std::string MakeModuleHavingStruct(int num_members) { std::stringstream os; os << Header(); os << R"(%1 = OpTypeInt 32 0 %2 = OpTypeStruct)"; for (int i = 0; i < num_members; i++) os << " %1"; return os.str(); } TEST(CppInterface, ValidateWithOptionsPass) { SpirvTools t(SPV_ENV_UNIVERSAL_1_1); std::vector binary; EXPECT_TRUE(t.Assemble(MakeModuleHavingStruct(10), &binary)); const ValidatorOptions opts; EXPECT_TRUE(t.Validate(binary.data(), binary.size(), opts)); } TEST(CppInterface, ValidateWithOptionsFail) { SpirvTools t(SPV_ENV_UNIVERSAL_1_1); std::vector binary; EXPECT_TRUE(t.Assemble(MakeModuleHavingStruct(10), &binary)); ValidatorOptions opts; opts.SetUniversalLimit(spv_validator_limit_max_struct_members, 9); std::stringstream os; t.SetMessageConsumer([&os](spv_message_level_t, const char*, const spv_position_t&, const char* message) { os << message; }); EXPECT_FALSE(t.Validate(binary.data(), binary.size(), opts)); EXPECT_THAT( os.str(), HasSubstr( "Number of OpTypeStruct members (10) has exceeded the limit (9)")); } // Checks that after running the given optimizer |opt| on the given |original| // source code, we can get the given |optimized| source code. void CheckOptimization(const std::string& original, const std::string& optimized, const Optimizer& opt) { SpirvTools t(SPV_ENV_UNIVERSAL_1_1); std::vector original_binary; ASSERT_TRUE(t.Assemble(original, &original_binary)); std::vector optimized_binary; EXPECT_TRUE(opt.Run(original_binary.data(), original_binary.size(), &optimized_binary)); std::string optimized_text; EXPECT_TRUE(t.Disassemble(optimized_binary, &optimized_text)); EXPECT_EQ(optimized, optimized_text); } TEST(CppInterface, OptimizeEmptyModule) { SpirvTools t(SPV_ENV_UNIVERSAL_1_1); std::vector binary; EXPECT_TRUE(t.Assemble("", &binary)); Optimizer o(SPV_ENV_UNIVERSAL_1_1); o.RegisterPass(CreateStripDebugInfoPass()); // Fails to validate. EXPECT_FALSE(o.Run(binary.data(), binary.size(), &binary)); } TEST(CppInterface, OptimizeModifiedModule) { Optimizer o(SPV_ENV_UNIVERSAL_1_1); o.RegisterPass(CreateStripDebugInfoPass()); CheckOptimization(Header() + "OpSource GLSL 450", Header(), o); } TEST(CppInterface, OptimizeMulitplePasses) { std::string original_text = Header() + "OpSource GLSL 450 " "OpDecorate %true SpecId 1 " "%bool = OpTypeBool " "%true = OpSpecConstantTrue %bool"; Optimizer o(SPV_ENV_UNIVERSAL_1_1); o.RegisterPass(CreateStripDebugInfoPass()) .RegisterPass(CreateFreezeSpecConstantValuePass()); std::string expected_text = Header() + "%bool = OpTypeBool\n" "%true = OpConstantTrue %bool\n"; CheckOptimization(original_text, expected_text, o); } TEST(CppInterface, OptimizeDoNothingWithPassToken) { CreateFreezeSpecConstantValuePass(); auto token = CreateUnifyConstantPass(); } TEST(CppInterface, OptimizeReassignPassToken) { auto token = CreateNullPass(); token = CreateStripDebugInfoPass(); CheckOptimization( Header() + "OpSource GLSL 450", Header(), Optimizer(SPV_ENV_UNIVERSAL_1_1).RegisterPass(std::move(token))); } TEST(CppInterface, OptimizeMoveConstructPassToken) { auto token1 = CreateStripDebugInfoPass(); Optimizer::PassToken token2(std::move(token1)); CheckOptimization( Header() + "OpSource GLSL 450", Header(), Optimizer(SPV_ENV_UNIVERSAL_1_1).RegisterPass(std::move(token2))); } TEST(CppInterface, OptimizeMoveAssignPassToken) { auto token1 = CreateStripDebugInfoPass(); auto token2 = CreateNullPass(); token2 = std::move(token1); CheckOptimization( Header() + "OpSource GLSL 450", Header(), Optimizer(SPV_ENV_UNIVERSAL_1_1).RegisterPass(std::move(token2))); } TEST(CppInterface, OptimizeSameAddressForOriginalOptimizedBinary) { SpirvTools t(SPV_ENV_UNIVERSAL_1_1); std::vector binary; ASSERT_TRUE(t.Assemble(Header() + "OpSource GLSL 450", &binary)); EXPECT_TRUE(Optimizer(SPV_ENV_UNIVERSAL_1_1) .RegisterPass(CreateStripDebugInfoPass()) .Run(binary.data(), binary.size(), &binary)); std::string optimized_text; EXPECT_TRUE(t.Disassemble(binary, &optimized_text)); EXPECT_EQ(Header(), optimized_text); } TEST(SpirvHeadersCpp, BitwiseOrMemoryAccessMask) { EXPECT_EQ(spv::MemoryAccessMask(6), spv::MemoryAccessMask::Aligned | spv::MemoryAccessMask::Nontemporal); } TEST(SpirvHeadersCpp, BitwiseAndMemoryAccessMask) { EXPECT_EQ(spv::MemoryAccessMask::Aligned, spv::MemoryAccessMask::Aligned & spv::MemoryAccessMask(6)); EXPECT_EQ(spv::MemoryAccessMask::Nontemporal, spv::MemoryAccessMask::Nontemporal & spv::MemoryAccessMask(6)); EXPECT_EQ(spv::MemoryAccessMask(0), spv::MemoryAccessMask::Nontemporal & spv::MemoryAccessMask::Aligned); } TEST(SpirvHeadersCpp, BitwiseXorMemoryAccessMask) { EXPECT_EQ(spv::MemoryAccessMask::Nontemporal, spv::MemoryAccessMask::Aligned ^ spv::MemoryAccessMask(6)); EXPECT_EQ(spv::MemoryAccessMask::Aligned, spv::MemoryAccessMask::Nontemporal ^ spv::MemoryAccessMask(6)); EXPECT_EQ(spv::MemoryAccessMask(6), spv::MemoryAccessMask::Nontemporal ^ spv::MemoryAccessMask::Aligned); EXPECT_EQ(spv::MemoryAccessMask(0), spv::MemoryAccessMask::Nontemporal ^ spv::MemoryAccessMask::Nontemporal); } TEST(SpirvHeadersCpp, BitwiseNegateMemoryAccessMask) { EXPECT_EQ(spv::MemoryAccessMask(~(uint32_t(4))), ~spv::MemoryAccessMask::Nontemporal); } // TODO(antiagainst): tests for SetMessageConsumer(). } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/diagnostic_test.cpp000066400000000000000000000114641475742701700234050ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include "gmock/gmock.h" #include "test/unit_spirv.h" namespace spvtools { namespace { using ::testing::Eq; // Returns a newly created diagnostic value. spv_diagnostic MakeValidDiagnostic() { spv_position_t position = {}; spv_diagnostic diagnostic = spvDiagnosticCreate(&position, ""); EXPECT_NE(nullptr, diagnostic); return diagnostic; } TEST(Diagnostic, DestroyNull) { spvDiagnosticDestroy(nullptr); } TEST(Diagnostic, DestroyValidDiagnostic) { spv_diagnostic diagnostic = MakeValidDiagnostic(); spvDiagnosticDestroy(diagnostic); // We aren't allowed to use the diagnostic pointer anymore. // So we can't test its behaviour. } TEST(Diagnostic, DestroyValidDiagnosticAfterReassignment) { spv_diagnostic diagnostic = MakeValidDiagnostic(); spv_diagnostic second_diagnostic = MakeValidDiagnostic(); EXPECT_TRUE(diagnostic != second_diagnostic); spvDiagnosticDestroy(diagnostic); diagnostic = second_diagnostic; spvDiagnosticDestroy(diagnostic); } TEST(Diagnostic, PrintDefault) { char message[] = "Test Diagnostic!"; spv_diagnostic_t diagnostic = {{2, 3, 5}, message}; // TODO: Redirect stderr ASSERT_EQ(SPV_SUCCESS, spvDiagnosticPrint(&diagnostic)); // TODO: Validate the output of spvDiagnosticPrint() // TODO: Remove the redirection of stderr } TEST(Diagnostic, PrintInvalidDiagnostic) { ASSERT_EQ(SPV_ERROR_INVALID_DIAGNOSTIC, spvDiagnosticPrint(nullptr)); } // TODO(dneto): We should be able to redirect the diagnostic printing. // Once we do that, we can test diagnostic corner cases. TEST(DiagnosticStream, ConversionToResultType) { // Check after the DiagnosticStream object is destroyed. spv_result_t value; { value = DiagnosticStream({}, nullptr, "", SPV_ERROR_INVALID_TEXT); } EXPECT_EQ(SPV_ERROR_INVALID_TEXT, value); // Check implicit conversion via plain assignment. value = DiagnosticStream({}, nullptr, "", SPV_SUCCESS); EXPECT_EQ(SPV_SUCCESS, value); // Check conversion via constructor. EXPECT_EQ(SPV_FAILED_MATCH, spv_result_t(DiagnosticStream({}, nullptr, "", SPV_FAILED_MATCH))); } TEST( DiagnosticStream, MoveConstructorPreservesPreviousMessagesAndPreventsOutputFromExpiringValue) { std::ostringstream messages; int message_count = 0; auto consumer = [&messages, &message_count](spv_message_level_t, const char*, const spv_position_t&, const char* msg) { message_count++; messages << msg; }; // Enclose the DiagnosticStream variables in a scope to force destruction. { DiagnosticStream ds0({}, consumer, "", SPV_ERROR_INVALID_BINARY); ds0 << "First"; DiagnosticStream ds1(std::move(ds0)); ds1 << "Second"; } EXPECT_THAT(message_count, Eq(1)); EXPECT_THAT(messages.str(), Eq("FirstSecond")); } TEST(DiagnosticStream, MoveConstructorCanBeDirectlyShiftedTo) { std::ostringstream messages; int message_count = 0; auto consumer = [&messages, &message_count](spv_message_level_t, const char*, const spv_position_t&, const char* msg) { message_count++; messages << msg; }; // Enclose the DiagnosticStream variables in a scope to force destruction. { DiagnosticStream ds0({}, consumer, "", SPV_ERROR_INVALID_BINARY); ds0 << "First"; std::move(ds0) << "Second"; } EXPECT_THAT(message_count, Eq(1)); EXPECT_THAT(messages.str(), Eq("FirstSecond")); } TEST(DiagnosticStream, DiagnosticFromLambdaReturnCanStillBeUsed) { std::ostringstream messages; int message_count = 0; auto consumer = [&messages, &message_count](spv_message_level_t, const char*, const spv_position_t&, const char* msg) { message_count++; messages << msg; }; { auto emitter = [&consumer]() -> DiagnosticStream { DiagnosticStream ds0({}, consumer, "", SPV_ERROR_INVALID_BINARY); ds0 << "First"; return ds0; }; emitter() << "Second"; } EXPECT_THAT(message_count, Eq(1)); EXPECT_THAT(messages.str(), Eq("FirstSecond")); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/diff/000077500000000000000000000000001475742701700204205ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/diff/CMakeLists.txt000066400000000000000000000016161475742701700231640ustar00rootroot00000000000000# Copyright (c) 2022 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. include(diff_files/diff_test_files_autogen.cmake) add_spvtools_unittest(TARGET lcs SRCS lcs_test.cpp LIBS SPIRV-Tools-diff ) add_spvtools_unittest(TARGET diff SRCS diff_test.cpp diff_test_utils.h diff_test_utils.cpp ${DIFF_TEST_FILES} ${spirv-tools_SOURCE_DIR}/tools/util/cli_consumer.cpp LIBS SPIRV-Tools-diff ) KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/000077500000000000000000000000001475742701700225125ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/.gitignore000066400000000000000000000002511475742701700245000ustar00rootroot00000000000000# To aid debugging no-dbg variants, the temporary files used to strip debug information are placed # in a hidden directory and aren't removed after generation. .no_dbg/ KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/OpExtInst_in_dst_only_autogen.cpp000066400000000000000000000172411475742701700312430ustar00rootroot00000000000000// GENERATED FILE - DO NOT EDIT. // Generated by generate_tests.py // // Copyright (c) 2022 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "../diff_test_utils.h" #include "gtest/gtest.h" namespace spvtools { namespace diff { namespace { // Tests a diff where the src shader doesn't have OpExtImport while the // dst shader does (and uses OpExtInst). This test ensures that when matching, // the OpExtImport instruction from the correct module is referenced. constexpr char kSrc[] = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %9 %11 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %9 "color" OpName %11 "v" OpDecorate %9 RelaxedPrecision OpDecorate %9 Location 0 OpDecorate %11 RelaxedPrecision OpDecorate %11 Location 0 OpDecorate %12 RelaxedPrecision OpDecorate %13 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypePointer Output %7 %9 = OpVariable %8 Output %10 = OpTypePointer Input %6 %11 = OpVariable %10 Input %4 = OpFunction %2 None %3 %5 = OpLabel %12 = OpLoad %6 %11 %13 = OpCompositeConstruct %7 %12 %12 %12 %12 OpStore %9 %13 OpReturn OpFunctionEnd )"; constexpr char kDst[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %9 %11 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %9 "color" OpName %11 "v" OpDecorate %9 RelaxedPrecision OpDecorate %9 Location 0 OpDecorate %11 RelaxedPrecision OpDecorate %11 Location 0 OpDecorate %12 RelaxedPrecision OpDecorate %13 RelaxedPrecision OpDecorate %14 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypePointer Output %7 %9 = OpVariable %8 Output %10 = OpTypePointer Input %6 %11 = OpVariable %10 Input %4 = OpFunction %2 None %3 %5 = OpLabel %12 = OpLoad %6 %11 %13 = OpExtInst %6 %1 Log2 %12 %14 = OpCompositeConstruct %7 %13 %13 %13 %13 OpStore %9 %14 OpReturn OpFunctionEnd )"; TEST(DiffTest, OpextinstInDstOnly) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 14 +; Bound: 16 ; Schema: 0 OpCapability Shader +%14 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %9 %11 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %9 "color" OpName %11 "v" OpDecorate %9 RelaxedPrecision OpDecorate %9 Location 0 OpDecorate %11 RelaxedPrecision OpDecorate %11 Location 0 OpDecorate %12 RelaxedPrecision +OpDecorate %15 RelaxedPrecision OpDecorate %13 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypePointer Output %7 %9 = OpVariable %8 Output %10 = OpTypePointer Input %6 %11 = OpVariable %10 Input %4 = OpFunction %2 None %3 %5 = OpLabel %12 = OpLoad %6 %11 +%15 = OpExtInst %6 %14 Log2 %12 -%13 = OpCompositeConstruct %7 %12 %12 %12 %12 +%13 = OpCompositeConstruct %7 %15 %15 %15 %15 OpStore %9 %13 OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrc, kDst, kDiff, options); } TEST(DiffTest, OpextinstInDstOnlyNoDebug) { constexpr char kSrcNoDebug[] = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %9 %11 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %9 RelaxedPrecision OpDecorate %9 Location 0 OpDecorate %11 RelaxedPrecision OpDecorate %11 Location 0 OpDecorate %12 RelaxedPrecision OpDecorate %13 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypePointer Output %7 %9 = OpVariable %8 Output %10 = OpTypePointer Input %6 %11 = OpVariable %10 Input %4 = OpFunction %2 None %3 %5 = OpLabel %12 = OpLoad %6 %11 %13 = OpCompositeConstruct %7 %12 %12 %12 %12 OpStore %9 %13 OpReturn OpFunctionEnd )"; constexpr char kDstNoDebug[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %9 %11 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %9 RelaxedPrecision OpDecorate %9 Location 0 OpDecorate %11 RelaxedPrecision OpDecorate %11 Location 0 OpDecorate %12 RelaxedPrecision OpDecorate %13 RelaxedPrecision OpDecorate %14 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypePointer Output %7 %9 = OpVariable %8 Output %10 = OpTypePointer Input %6 %11 = OpVariable %10 Input %4 = OpFunction %2 None %3 %5 = OpLabel %12 = OpLoad %6 %11 %13 = OpExtInst %6 %1 Log2 %12 %14 = OpCompositeConstruct %7 %13 %13 %13 %13 OpStore %9 %14 OpReturn OpFunctionEnd )"; constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 14 +; Bound: 16 ; Schema: 0 OpCapability Shader +%14 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %9 %11 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %9 RelaxedPrecision OpDecorate %9 Location 0 OpDecorate %11 RelaxedPrecision OpDecorate %11 Location 0 OpDecorate %12 RelaxedPrecision +OpDecorate %15 RelaxedPrecision OpDecorate %13 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypePointer Output %7 %9 = OpVariable %8 Output %10 = OpTypePointer Input %6 %11 = OpVariable %10 Input %4 = OpFunction %2 None %3 %5 = OpLabel %12 = OpLoad %6 %11 +%15 = OpExtInst %6 %14 Log2 %12 -%13 = OpCompositeConstruct %7 %12 %12 %12 %12 +%13 = OpCompositeConstruct %7 %15 %15 %15 %15 OpStore %9 %13 OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrcNoDebug, kDstNoDebug, kDiff, options); } } // namespace } // namespace diff } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/OpExtInst_in_dst_only_dst.spvasm000066400000000000000000000022741475742701700311220ustar00rootroot00000000000000 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %9 %11 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %9 "color" OpName %11 "v" OpDecorate %9 RelaxedPrecision OpDecorate %9 Location 0 OpDecorate %11 RelaxedPrecision OpDecorate %11 Location 0 OpDecorate %12 RelaxedPrecision OpDecorate %13 RelaxedPrecision OpDecorate %14 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypePointer Output %7 %9 = OpVariable %8 Output %10 = OpTypePointer Input %6 %11 = OpVariable %10 Input %4 = OpFunction %2 None %3 %5 = OpLabel %12 = OpLoad %6 %11 %13 = OpExtInst %6 %1 Log2 %12 %14 = OpCompositeConstruct %7 %13 %13 %13 %13 OpStore %9 %14 OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/OpExtInst_in_dst_only_src.spvasm000066400000000000000000000024251475742701700311150ustar00rootroot00000000000000;; Tests a diff where the src shader doesn't have OpExtImport while the ;; dst shader does (and uses OpExtInst). This test ensures that when matching, ;; the OpExtImport instruction from the correct module is referenced. OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %9 %11 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %9 "color" OpName %11 "v" OpDecorate %9 RelaxedPrecision OpDecorate %9 Location 0 OpDecorate %11 RelaxedPrecision OpDecorate %11 Location 0 OpDecorate %12 RelaxedPrecision OpDecorate %13 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypePointer Output %7 %9 = OpVariable %8 Output %10 = OpTypePointer Input %6 %11 = OpVariable %10 Input %4 = OpFunction %2 None %3 %5 = OpLabel %12 = OpLoad %6 %11 %13 = OpCompositeConstruct %7 %12 %12 %12 %12 OpStore %9 %13 OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/OpExtInst_in_src_only_autogen.cpp000066400000000000000000000172031475742701700312360ustar00rootroot00000000000000// GENERATED FILE - DO NOT EDIT. // Generated by generate_tests.py // // Copyright (c) 2022 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "../diff_test_utils.h" #include "gtest/gtest.h" namespace spvtools { namespace diff { namespace { // Tests a diff where the dst shader doesn't have OpExtImport while the // src shader does (and uses OpExtInst). This test ensures that when matching, // the OpExtImport instruction from the correct module is referenced. constexpr char kSrc[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %9 %11 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %9 "color" OpName %11 "v" OpDecorate %9 RelaxedPrecision OpDecorate %9 Location 0 OpDecorate %11 RelaxedPrecision OpDecorate %11 Location 0 OpDecorate %12 RelaxedPrecision OpDecorate %13 RelaxedPrecision OpDecorate %14 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypePointer Output %7 %9 = OpVariable %8 Output %10 = OpTypePointer Input %6 %11 = OpVariable %10 Input %4 = OpFunction %2 None %3 %5 = OpLabel %12 = OpLoad %6 %11 %13 = OpExtInst %6 %1 Log2 %12 %14 = OpCompositeConstruct %7 %13 %13 %13 %13 OpStore %9 %14 OpReturn OpFunctionEnd )"; constexpr char kDst[] = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %9 %11 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %9 "color" OpName %11 "v" OpDecorate %9 RelaxedPrecision OpDecorate %9 Location 0 OpDecorate %11 RelaxedPrecision OpDecorate %11 Location 0 OpDecorate %12 RelaxedPrecision OpDecorate %13 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypePointer Output %7 %9 = OpVariable %8 Output %10 = OpTypePointer Input %6 %11 = OpVariable %10 Input %4 = OpFunction %2 None %3 %5 = OpLabel %12 = OpLoad %6 %11 %13 = OpCompositeConstruct %7 %12 %12 %12 %12 OpStore %9 %13 OpReturn OpFunctionEnd )"; TEST(DiffTest, OpextinstInSrcOnly) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 15 ; Schema: 0 OpCapability Shader -%1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %9 %11 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %9 "color" OpName %11 "v" OpDecorate %9 RelaxedPrecision OpDecorate %9 Location 0 OpDecorate %11 RelaxedPrecision OpDecorate %11 Location 0 OpDecorate %12 RelaxedPrecision -OpDecorate %13 RelaxedPrecision OpDecorate %14 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypePointer Output %7 %9 = OpVariable %8 Output %10 = OpTypePointer Input %6 %11 = OpVariable %10 Input %4 = OpFunction %2 None %3 %5 = OpLabel %12 = OpLoad %6 %11 -%13 = OpExtInst %6 %1 Log2 %12 -%14 = OpCompositeConstruct %7 %13 %13 %13 %13 +%14 = OpCompositeConstruct %7 %12 %12 %12 %12 OpStore %9 %14 OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrc, kDst, kDiff, options); } TEST(DiffTest, OpextinstInSrcOnlyNoDebug) { constexpr char kSrcNoDebug[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %9 %11 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %9 RelaxedPrecision OpDecorate %9 Location 0 OpDecorate %11 RelaxedPrecision OpDecorate %11 Location 0 OpDecorate %12 RelaxedPrecision OpDecorate %13 RelaxedPrecision OpDecorate %14 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypePointer Output %7 %9 = OpVariable %8 Output %10 = OpTypePointer Input %6 %11 = OpVariable %10 Input %4 = OpFunction %2 None %3 %5 = OpLabel %12 = OpLoad %6 %11 %13 = OpExtInst %6 %1 Log2 %12 %14 = OpCompositeConstruct %7 %13 %13 %13 %13 OpStore %9 %14 OpReturn OpFunctionEnd )"; constexpr char kDstNoDebug[] = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %9 %11 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %9 RelaxedPrecision OpDecorate %9 Location 0 OpDecorate %11 RelaxedPrecision OpDecorate %11 Location 0 OpDecorate %12 RelaxedPrecision OpDecorate %13 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypePointer Output %7 %9 = OpVariable %8 Output %10 = OpTypePointer Input %6 %11 = OpVariable %10 Input %4 = OpFunction %2 None %3 %5 = OpLabel %12 = OpLoad %6 %11 %13 = OpCompositeConstruct %7 %12 %12 %12 %12 OpStore %9 %13 OpReturn OpFunctionEnd )"; constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 15 ; Schema: 0 OpCapability Shader -%1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %9 %11 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %9 RelaxedPrecision OpDecorate %9 Location 0 OpDecorate %11 RelaxedPrecision OpDecorate %11 Location 0 OpDecorate %12 RelaxedPrecision -OpDecorate %13 RelaxedPrecision OpDecorate %14 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypePointer Output %7 %9 = OpVariable %8 Output %10 = OpTypePointer Input %6 %11 = OpVariable %10 Input %4 = OpFunction %2 None %3 %5 = OpLabel %12 = OpLoad %6 %11 -%13 = OpExtInst %6 %1 Log2 %12 -%14 = OpCompositeConstruct %7 %13 %13 %13 %13 +%14 = OpCompositeConstruct %7 %12 %12 %12 %12 OpStore %9 %14 OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrcNoDebug, kDstNoDebug, kDiff, options); } } // namespace } // namespace diff } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/OpExtInst_in_src_only_dst.spvasm000066400000000000000000000020671475742701700311170ustar00rootroot00000000000000 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %9 %11 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %9 "color" OpName %11 "v" OpDecorate %9 RelaxedPrecision OpDecorate %9 Location 0 OpDecorate %11 RelaxedPrecision OpDecorate %11 Location 0 OpDecorate %12 RelaxedPrecision OpDecorate %13 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypePointer Output %7 %9 = OpVariable %8 Output %10 = OpTypePointer Input %6 %11 = OpVariable %10 Input %4 = OpFunction %2 None %3 %5 = OpLabel %12 = OpLoad %6 %11 %13 = OpCompositeConstruct %7 %12 %12 %12 %12 OpStore %9 %13 OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/OpExtInst_in_src_only_src.spvasm000066400000000000000000000026321475742701700311120ustar00rootroot00000000000000;; Tests a diff where the dst shader doesn't have OpExtImport while the ;; src shader does (and uses OpExtInst). This test ensures that when matching, ;; the OpExtImport instruction from the correct module is referenced. OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %9 %11 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %9 "color" OpName %11 "v" OpDecorate %9 RelaxedPrecision OpDecorate %9 Location 0 OpDecorate %11 RelaxedPrecision OpDecorate %11 Location 0 OpDecorate %12 RelaxedPrecision OpDecorate %13 RelaxedPrecision OpDecorate %14 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypePointer Output %7 %9 = OpVariable %8 Output %10 = OpTypePointer Input %6 %11 = OpVariable %10 Input %4 = OpFunction %2 None %3 %5 = OpLabel %12 = OpLoad %6 %11 %13 = OpExtInst %6 %1 Log2 %12 %14 = OpCompositeConstruct %7 %13 %13 %13 %13 OpStore %9 %14 OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/OpTypeForwardPointer_basic_autogen.cpp000066400000000000000000000111411475742701700322050ustar00rootroot00000000000000// GENERATED FILE - DO NOT EDIT. // Generated by generate_tests.py // // Copyright (c) 2022 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "../diff_test_utils.h" #include "gtest/gtest.h" namespace spvtools { namespace diff { namespace { // Basic test that OpTypeForwardPointer is matched constexpr char kSrc[] = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpName %structptr "structptr" OpTypeForwardPointer %structptr UniformConstant %uint = OpTypeInt 32 0 %structt1 = OpTypeStruct %structptr %uint %structt2 = OpTypeStruct %uint %structptr %structt3 = OpTypeStruct %uint %uint %structptr %structt4 = OpTypeStruct %uint %uint %uint %structptr %structptr = OpTypePointer UniformConstant %structt1)"; constexpr char kDst[] = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpName %structptr "structptr" OpName %structptr2 "structptr2" OpTypeForwardPointer %structptr UniformConstant OpTypeForwardPointer %structptr2 Function %uint = OpTypeInt 32 0 %structt1 = OpTypeStruct %structptr %uint %structt2 = OpTypeStruct %uint %structptr %structt3 = OpTypeStruct %uint %uint %structptr %structt4 = OpTypeStruct %uint %uint %uint %structptr %structptr = OpTypePointer UniformConstant %structt1 %structptr2 = OpTypePointer Function %structt1 )"; TEST(DiffTest, OptypeforwardpointerBasic) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 7 +; Bound: 8 ; Schema: 0 OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpName %1 "structptr" +OpName %7 "structptr2" OpTypeForwardPointer %1 UniformConstant +OpTypeForwardPointer %7 Function %2 = OpTypeInt 32 0 %3 = OpTypeStruct %1 %2 %4 = OpTypeStruct %2 %1 %5 = OpTypeStruct %2 %2 %1 %6 = OpTypeStruct %2 %2 %2 %1 %1 = OpTypePointer UniformConstant %3 +%7 = OpTypePointer Function %3 )"; Options options; DoStringDiffTest(kSrc, kDst, kDiff, options); } TEST(DiffTest, OptypeforwardpointerBasicNoDebug) { constexpr char kSrcNoDebug[] = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpTypeForwardPointer %structptr UniformConstant %uint = OpTypeInt 32 0 %structt1 = OpTypeStruct %structptr %uint %structt2 = OpTypeStruct %uint %structptr %structt3 = OpTypeStruct %uint %uint %structptr %structt4 = OpTypeStruct %uint %uint %uint %structptr %structptr = OpTypePointer UniformConstant %structt1 )"; constexpr char kDstNoDebug[] = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpTypeForwardPointer %structptr UniformConstant OpTypeForwardPointer %structptr2 Function %uint = OpTypeInt 32 0 %structt1 = OpTypeStruct %structptr %uint %structt2 = OpTypeStruct %uint %structptr %structt3 = OpTypeStruct %uint %uint %structptr %structt4 = OpTypeStruct %uint %uint %uint %structptr %structptr = OpTypePointer UniformConstant %structt1 %structptr2 = OpTypePointer Function %structt1 )"; constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 7 +; Bound: 8 ; Schema: 0 OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpTypeForwardPointer %1 UniformConstant +OpTypeForwardPointer %7 Function %2 = OpTypeInt 32 0 %3 = OpTypeStruct %1 %2 %4 = OpTypeStruct %2 %1 %5 = OpTypeStruct %2 %2 %1 %6 = OpTypeStruct %2 %2 %2 %1 %1 = OpTypePointer UniformConstant %3 +%7 = OpTypePointer Function %3 )"; Options options; DoStringDiffTest(kSrcNoDebug, kDstNoDebug, kDiff, options); } } // namespace } // namespace diff } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/OpTypeForwardPointer_basic_dst.spvasm000066400000000000000000000012711475742701700320670ustar00rootroot00000000000000 OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpName %structptr "structptr" OpName %structptr2 "structptr2" OpTypeForwardPointer %structptr UniformConstant OpTypeForwardPointer %structptr2 Function %uint = OpTypeInt 32 0 %structt1 = OpTypeStruct %structptr %uint %structt2 = OpTypeStruct %uint %structptr %structt3 = OpTypeStruct %uint %uint %structptr %structt4 = OpTypeStruct %uint %uint %uint %structptr %structptr = OpTypePointer UniformConstant %structt1 %structptr2 = OpTypePointer Function %structt1 KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/OpTypeForwardPointer_basic_src.spvasm000066400000000000000000000011231475742701700320600ustar00rootroot00000000000000;; Basic test that OpTypeForwardPointer is matched OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpName %structptr "structptr" OpTypeForwardPointer %structptr UniformConstant %uint = OpTypeInt 32 0 %structt1 = OpTypeStruct %structptr %uint %structt2 = OpTypeStruct %uint %structptr %structt3 = OpTypeStruct %uint %uint %structptr %structt4 = OpTypeStruct %uint %uint %uint %structptr %structptr = OpTypePointer UniformConstant %structt1 KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/OpTypeForwardPointer_intertwined_autogen.cpp000066400000000000000000000110761475742701700334670ustar00rootroot00000000000000// GENERATED FILE - DO NOT EDIT. // Generated by generate_tests.py // // Copyright (c) 2022 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "../diff_test_utils.h" #include "gtest/gtest.h" namespace spvtools { namespace diff { namespace { // Tests that two forwarded types whose declarations are intertwined match // correctly constexpr char kSrc[] = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpName %Aptr "Aptr" OpName %Bptr "Bptr" OpTypeForwardPointer %Aptr UniformConstant OpTypeForwardPointer %Bptr UniformConstant %uint = OpTypeInt 32 0 %A = OpTypeStruct %Aptr %uint %Bptr %B = OpTypeStruct %uint %Aptr %Bptr %Aptr = OpTypePointer UniformConstant %A %Bptr = OpTypePointer UniformConstant %B)"; constexpr char kDst[] = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpName %Aptr "Aptr" OpName %Bptr "Bptr" OpTypeForwardPointer %Bptr UniformConstant OpTypeForwardPointer %Aptr UniformConstant %uint = OpTypeInt 32 0 %B = OpTypeStruct %uint %Aptr %Bptr %uint %A = OpTypeStruct %Aptr %uint %Bptr %Aptr = OpTypePointer UniformConstant %A %Bptr = OpTypePointer UniformConstant %B )"; TEST(DiffTest, OptypeforwardpointerIntertwined) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 6 +; Bound: 7 ; Schema: 0 OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpName %1 "Aptr" OpName %2 "Bptr" OpTypeForwardPointer %1 UniformConstant OpTypeForwardPointer %2 UniformConstant %3 = OpTypeInt 32 0 +%6 = OpTypeStruct %3 %1 %2 %3 %4 = OpTypeStruct %1 %3 %2 -%5 = OpTypeStruct %3 %1 %2 %1 = OpTypePointer UniformConstant %4 -%2 = OpTypePointer UniformConstant %5 +%2 = OpTypePointer UniformConstant %6 )"; Options options; DoStringDiffTest(kSrc, kDst, kDiff, options); } TEST(DiffTest, OptypeforwardpointerIntertwinedNoDebug) { constexpr char kSrcNoDebug[] = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpTypeForwardPointer %Aptr UniformConstant OpTypeForwardPointer %Bptr UniformConstant %uint = OpTypeInt 32 0 %A = OpTypeStruct %Aptr %uint %Bptr %B = OpTypeStruct %uint %Aptr %Bptr %Aptr = OpTypePointer UniformConstant %A %Bptr = OpTypePointer UniformConstant %B )"; constexpr char kDstNoDebug[] = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpTypeForwardPointer %Bptr UniformConstant OpTypeForwardPointer %Aptr UniformConstant %uint = OpTypeInt 32 0 %B = OpTypeStruct %uint %Aptr %Bptr %uint %A = OpTypeStruct %Aptr %uint %Bptr %Aptr = OpTypePointer UniformConstant %A %Bptr = OpTypePointer UniformConstant %B )"; constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 6 +; Bound: 10 ; Schema: 0 OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL -OpTypeForwardPointer %1 UniformConstant -OpTypeForwardPointer %2 UniformConstant +OpTypeForwardPointer %6 UniformConstant +OpTypeForwardPointer %7 UniformConstant %3 = OpTypeInt 32 0 -%4 = OpTypeStruct %1 %3 %2 -%5 = OpTypeStruct %3 %1 %2 -%1 = OpTypePointer UniformConstant %4 -%2 = OpTypePointer UniformConstant %5 +%8 = OpTypeStruct %3 %7 %6 %3 +%9 = OpTypeStruct %7 %3 %6 +%7 = OpTypePointer UniformConstant %9 +%6 = OpTypePointer UniformConstant %8 )"; Options options; DoStringDiffTest(kSrcNoDebug, kDstNoDebug, kDiff, options); } } // namespace } // namespace diff } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/OpTypeForwardPointer_intertwined_dst.spvasm000066400000000000000000000010511475742701700333360ustar00rootroot00000000000000 OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpName %Aptr "Aptr" OpName %Bptr "Bptr" OpTypeForwardPointer %Bptr UniformConstant OpTypeForwardPointer %Aptr UniformConstant %uint = OpTypeInt 32 0 %B = OpTypeStruct %uint %Aptr %Bptr %uint %A = OpTypeStruct %Aptr %uint %Bptr %Aptr = OpTypePointer UniformConstant %A %Bptr = OpTypePointer UniformConstant %B KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/OpTypeForwardPointer_intertwined_src.spvasm000066400000000000000000000011731475742701700333400ustar00rootroot00000000000000;; Tests that two forwarded types whose declarations are intertwined match ;; correctly OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpName %Aptr "Aptr" OpName %Bptr "Bptr" OpTypeForwardPointer %Aptr UniformConstant OpTypeForwardPointer %Bptr UniformConstant %uint = OpTypeInt 32 0 %A = OpTypeStruct %Aptr %uint %Bptr %B = OpTypeStruct %uint %Aptr %Bptr %Aptr = OpTypePointer UniformConstant %A %Bptr = OpTypePointer UniformConstant %B OpTypeForwardPointer_mismatching_class_autogen.cpp000066400000000000000000000070611475742701700345430ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files// GENERATED FILE - DO NOT EDIT. // Generated by generate_tests.py // // Copyright (c) 2022 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "../diff_test_utils.h" #include "gtest/gtest.h" namespace spvtools { namespace diff { namespace { // Tests that two forwarded type pointers with mismatching storage classes // aren't matched constexpr char kSrc[] = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpName %Aptr "Aptr" OpTypeForwardPointer %Aptr UniformConstant %uint = OpTypeInt 32 0 %A = OpTypeStruct %Aptr %uint %Aptr = OpTypePointer UniformConstant %A)"; constexpr char kDst[] = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpName %Aptr "Aptr" OpTypeForwardPointer %Aptr Function %uint = OpTypeInt 32 0 %A = OpTypeStruct %Aptr %uint %Aptr = OpTypePointer Function %A )"; TEST(DiffTest, OptypeforwardpointerMismatchingClass) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 4 +; Bound: 6 ; Schema: 0 OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL -OpName %1 "Aptr" +OpName %4 "Aptr" -OpTypeForwardPointer %1 UniformConstant +OpTypeForwardPointer %4 Function %2 = OpTypeInt 32 0 -%3 = OpTypeStruct %1 %2 -%1 = OpTypePointer UniformConstant %3 +%5 = OpTypeStruct %4 %2 +%4 = OpTypePointer Function %5 )"; Options options; DoStringDiffTest(kSrc, kDst, kDiff, options); } TEST(DiffTest, OptypeforwardpointerMismatchingClassNoDebug) { constexpr char kSrcNoDebug[] = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpTypeForwardPointer %Aptr UniformConstant %uint = OpTypeInt 32 0 %A = OpTypeStruct %Aptr %uint %Aptr = OpTypePointer UniformConstant %A )"; constexpr char kDstNoDebug[] = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpTypeForwardPointer %Aptr Function %uint = OpTypeInt 32 0 %A = OpTypeStruct %Aptr %uint %Aptr = OpTypePointer Function %A )"; constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 4 +; Bound: 6 ; Schema: 0 OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL -OpTypeForwardPointer %1 UniformConstant +OpTypeForwardPointer %4 Function %2 = OpTypeInt 32 0 -%3 = OpTypeStruct %1 %2 -%1 = OpTypePointer UniformConstant %3 +%5 = OpTypeStruct %4 %2 +%4 = OpTypePointer Function %5 )"; Options options; DoStringDiffTest(kSrcNoDebug, kDstNoDebug, kDiff, options); } } // namespace } // namespace diff } // namespace spvtools OpTypeForwardPointer_mismatching_class_dst.spvasm000066400000000000000000000005311475742701700344150ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpName %Aptr "Aptr" OpTypeForwardPointer %Aptr Function %uint = OpTypeInt 32 0 %A = OpTypeStruct %Aptr %uint %Aptr = OpTypePointer Function %A OpTypeForwardPointer_mismatching_class_src.spvasm000066400000000000000000000007041475742701700344140ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files;; Tests that two forwarded type pointers with mismatching storage classes ;; aren't matched OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpName %Aptr "Aptr" OpTypeForwardPointer %Aptr UniformConstant %uint = OpTypeInt 32 0 %A = OpTypeStruct %Aptr %uint %Aptr = OpTypePointer UniformConstant %A OpTypeForwardPointer_mismatching_type_autogen.cpp000066400000000000000000000067361475742701700344270ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files// GENERATED FILE - DO NOT EDIT. // Generated by generate_tests.py // // Copyright (c) 2022 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "../diff_test_utils.h" #include "gtest/gtest.h" namespace spvtools { namespace diff { namespace { // Tests that two forwarded type pointers with mismatching types aren't matched constexpr char kSrc[] = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpName %Aptr "Aptr" OpTypeForwardPointer %Aptr UniformConstant %uint = OpTypeInt 32 0 %A = OpTypeStruct %Aptr %uint %Aptr = OpTypePointer UniformConstant %A)"; constexpr char kDst[] = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpName %Aptr "Aptr" OpTypeForwardPointer %Aptr UniformConstant %uint = OpTypeInt 32 0 %Aptr = OpTypePointer UniformConstant %uint )"; TEST(DiffTest, OptypeforwardpointerMismatchingType) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 4 +; Bound: 5 ; Schema: 0 OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL -OpName %1 "Aptr" +OpName %4 "Aptr" -OpTypeForwardPointer %1 UniformConstant +OpTypeForwardPointer %4 UniformConstant %2 = OpTypeInt 32 0 -%3 = OpTypeStruct %1 %2 -%1 = OpTypePointer UniformConstant %3 +%4 = OpTypePointer UniformConstant %2 )"; Options options; DoStringDiffTest(kSrc, kDst, kDiff, options); } TEST(DiffTest, OptypeforwardpointerMismatchingTypeNoDebug) { constexpr char kSrcNoDebug[] = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpTypeForwardPointer %Aptr UniformConstant %uint = OpTypeInt 32 0 %A = OpTypeStruct %Aptr %uint %Aptr = OpTypePointer UniformConstant %A )"; constexpr char kDstNoDebug[] = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpTypeForwardPointer %Aptr UniformConstant %uint = OpTypeInt 32 0 %Aptr = OpTypePointer UniformConstant %uint )"; constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 4 +; Bound: 5 ; Schema: 0 OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL -OpTypeForwardPointer %1 UniformConstant +OpTypeForwardPointer %4 UniformConstant %2 = OpTypeInt 32 0 -%3 = OpTypeStruct %1 %2 -%1 = OpTypePointer UniformConstant %3 +%4 = OpTypePointer UniformConstant %2 )"; Options options; DoStringDiffTest(kSrcNoDebug, kDstNoDebug, kDiff, options); } } // namespace } // namespace diff } // namespace spvtools OpTypeForwardPointer_mismatching_type_dst.spvasm000066400000000000000000000005021475742701700342670ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpName %Aptr "Aptr" OpTypeForwardPointer %Aptr UniformConstant %uint = OpTypeInt 32 0 %Aptr = OpTypePointer UniformConstant %uint OpTypeForwardPointer_mismatching_type_src.spvasm000066400000000000000000000006671475742701700343000ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files;; Tests that two forwarded type pointers with mismatching types aren't matched OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpName %Aptr "Aptr" OpTypeForwardPointer %Aptr UniformConstant %uint = OpTypeInt 32 0 %A = OpTypeStruct %Aptr %uint %Aptr = OpTypePointer UniformConstant %A KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/OpTypeForwardPointer_nested_autogen.cpp000066400000000000000000000100301475742701700324020ustar00rootroot00000000000000// GENERATED FILE - DO NOT EDIT. // Generated by generate_tests.py // // Copyright (c) 2022 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "../diff_test_utils.h" #include "gtest/gtest.h" namespace spvtools { namespace diff { namespace { // Tests that two forwarded declarations match even if the type pointer is used // in a nested struct declaration, and in multiple places constexpr char kSrc[] = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpName %Aptr "Aptr" OpTypeForwardPointer %Aptr UniformConstant %uint = OpTypeInt 32 0 %C = OpTypeStruct %Aptr %uint %Aptr %B = OpTypeStruct %C %Aptr %uint %A = OpTypeStruct %B %C %B %Aptr = OpTypePointer UniformConstant %A)"; constexpr char kDst[] = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpName %Aptr "Aptr" OpTypeForwardPointer %Aptr UniformConstant %uint = OpTypeInt 32 0 %C = OpTypeStruct %Aptr %uint %Aptr %B = OpTypeStruct %C %Aptr %A = OpTypeStruct %B %C %B %Aptr = OpTypePointer UniformConstant %A )"; TEST(DiffTest, OptypeforwardpointerNested) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 6 +; Bound: 8 ; Schema: 0 OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpName %1 "Aptr" OpTypeForwardPointer %1 UniformConstant %2 = OpTypeInt 32 0 %3 = OpTypeStruct %1 %2 %1 -%4 = OpTypeStruct %3 %1 %2 -%5 = OpTypeStruct %4 %3 %4 +%6 = OpTypeStruct %3 %1 +%7 = OpTypeStruct %6 %3 %6 -%1 = OpTypePointer UniformConstant %5 +%1 = OpTypePointer UniformConstant %7 )"; Options options; DoStringDiffTest(kSrc, kDst, kDiff, options); } TEST(DiffTest, OptypeforwardpointerNestedNoDebug) { constexpr char kSrcNoDebug[] = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpTypeForwardPointer %Aptr UniformConstant %uint = OpTypeInt 32 0 %C = OpTypeStruct %Aptr %uint %Aptr %B = OpTypeStruct %C %Aptr %uint %A = OpTypeStruct %B %C %B %Aptr = OpTypePointer UniformConstant %A )"; constexpr char kDstNoDebug[] = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpTypeForwardPointer %Aptr UniformConstant %uint = OpTypeInt 32 0 %C = OpTypeStruct %Aptr %uint %Aptr %B = OpTypeStruct %C %Aptr %A = OpTypeStruct %B %C %B %Aptr = OpTypePointer UniformConstant %A )"; constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 6 +; Bound: 8 ; Schema: 0 OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpTypeForwardPointer %1 UniformConstant %2 = OpTypeInt 32 0 %3 = OpTypeStruct %1 %2 %1 -%4 = OpTypeStruct %3 %1 %2 -%5 = OpTypeStruct %4 %3 %4 +%6 = OpTypeStruct %3 %1 +%7 = OpTypeStruct %6 %3 %6 -%1 = OpTypePointer UniformConstant %5 +%1 = OpTypePointer UniformConstant %7 )"; Options options; DoStringDiffTest(kSrcNoDebug, kDstNoDebug, kDiff, options); } } // namespace } // namespace diff } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/OpTypeForwardPointer_nested_dst.spvasm000066400000000000000000000006671475742701700323000ustar00rootroot00000000000000 OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpName %Aptr "Aptr" OpTypeForwardPointer %Aptr UniformConstant %uint = OpTypeInt 32 0 %C = OpTypeStruct %Aptr %uint %Aptr %B = OpTypeStruct %C %Aptr %A = OpTypeStruct %B %C %B %Aptr = OpTypePointer UniformConstant %A KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/OpTypeForwardPointer_nested_src.spvasm000066400000000000000000000011071475742701700322630ustar00rootroot00000000000000;; Tests that two forwarded declarations match even if the type pointer is used ;; in a nested struct declaration, and in multiple places OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpName %Aptr "Aptr" OpTypeForwardPointer %Aptr UniformConstant %uint = OpTypeInt 32 0 %C = OpTypeStruct %Aptr %uint %Aptr %B = OpTypeStruct %C %Aptr %uint %A = OpTypeStruct %B %C %B %Aptr = OpTypePointer UniformConstant %A OpTypeForwardPointer_onesided_debug_autogen.cpp000066400000000000000000000102621475742701700340100ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files// GENERATED FILE - DO NOT EDIT. // Generated by generate_tests.py // // Copyright (c) 2022 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "../diff_test_utils.h" #include "gtest/gtest.h" namespace spvtools { namespace diff { namespace { // Test that OpTypeForwardPointer is matched when one SPIR-V doesn't have debug // info constexpr char kSrc[] = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpName %structptr "structptr" OpTypeForwardPointer %structptr UniformConstant %uint = OpTypeInt 32 0 %structt1 = OpTypeStruct %structptr %uint %structt2 = OpTypeStruct %uint %structptr %structt3 = OpTypeStruct %uint %uint %structptr %structt4 = OpTypeStruct %uint %uint %uint %structptr %structptr = OpTypePointer UniformConstant %structt1)"; constexpr char kDst[] = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpTypeForwardPointer %structptr UniformConstant %uint = OpTypeInt 32 0 %structt1 = OpTypeStruct %structptr %uint %structt2 = OpTypeStruct %uint %structptr %structt3 = OpTypeStruct %uint %uint %structptr %structt4 = OpTypeStruct %uint %uint %uint %structptr %structptr = OpTypePointer UniformConstant %structt1 )"; TEST(DiffTest, OptypeforwardpointerOnesidedDebug) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 7 ; Schema: 0 OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL -OpName %1 "structptr" OpTypeForwardPointer %1 UniformConstant %2 = OpTypeInt 32 0 %3 = OpTypeStruct %1 %2 %4 = OpTypeStruct %2 %1 %5 = OpTypeStruct %2 %2 %1 %6 = OpTypeStruct %2 %2 %2 %1 %1 = OpTypePointer UniformConstant %3 )"; Options options; DoStringDiffTest(kSrc, kDst, kDiff, options); } TEST(DiffTest, OptypeforwardpointerOnesidedDebugNoDebug) { constexpr char kSrcNoDebug[] = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpTypeForwardPointer %structptr UniformConstant %uint = OpTypeInt 32 0 %structt1 = OpTypeStruct %structptr %uint %structt2 = OpTypeStruct %uint %structptr %structt3 = OpTypeStruct %uint %uint %structptr %structt4 = OpTypeStruct %uint %uint %uint %structptr %structptr = OpTypePointer UniformConstant %structt1 )"; constexpr char kDstNoDebug[] = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpTypeForwardPointer %structptr UniformConstant %uint = OpTypeInt 32 0 %structt1 = OpTypeStruct %structptr %uint %structt2 = OpTypeStruct %uint %structptr %structt3 = OpTypeStruct %uint %uint %structptr %structt4 = OpTypeStruct %uint %uint %uint %structptr %structptr = OpTypePointer UniformConstant %structt1 )"; constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 7 ; Schema: 0 OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpTypeForwardPointer %1 UniformConstant %2 = OpTypeInt 32 0 %3 = OpTypeStruct %1 %2 %4 = OpTypeStruct %2 %1 %5 = OpTypeStruct %2 %2 %1 %6 = OpTypeStruct %2 %2 %2 %1 %1 = OpTypePointer UniformConstant %3 )"; Options options; DoStringDiffTest(kSrcNoDebug, kDstNoDebug, kDiff, options); } } // namespace } // namespace diff } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/OpTypeForwardPointer_onesided_debug_dst.spvasm000066400000000000000000000007631475742701700337530ustar00rootroot00000000000000 OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpTypeForwardPointer %structptr UniformConstant %uint = OpTypeInt 32 0 %structt1 = OpTypeStruct %structptr %uint %structt2 = OpTypeStruct %uint %structptr %structt3 = OpTypeStruct %uint %uint %structptr %structt4 = OpTypeStruct %uint %uint %uint %structptr %structptr = OpTypePointer UniformConstant %structt1 KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/OpTypeForwardPointer_onesided_debug_src.spvasm000066400000000000000000000011701475742701700337410ustar00rootroot00000000000000;; Test that OpTypeForwardPointer is matched when one SPIR-V doesn't have debug ;; info OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpName %structptr "structptr" OpTypeForwardPointer %structptr UniformConstant %uint = OpTypeInt 32 0 %structt1 = OpTypeStruct %structptr %uint %structt2 = OpTypeStruct %uint %structptr %structt3 = OpTypeStruct %uint %uint %structptr %structt4 = OpTypeStruct %uint %uint %uint %structptr %structptr = OpTypePointer UniformConstant %structt1 KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/README.md000066400000000000000000000017351475742701700237770ustar00rootroot00000000000000# Diff tests This directory contains files used to ensure correctness of the `spirv-diff` implementation. The `generate_tests.py` script takes `name_src.spvasm` and `name_dst.spvasm` (for each `name`) and produces unit test files in the form of `name_autogen.cpp`. The unit test files test the diff between the src and dst inputs, as well as between debug-stripped versions of those. Additionally, based on the `{variant}_TESTS` lists defined in `generate_tests.py`, extra unit tests are added to exercise different options of spirv-diff. New tests are added simply by placing a new `name_src.spvasm` and `name_dst.spvasm` pair in this directory and running `generate_tests.py`. Note that this script needs the path to the spirv-diff executable that is built. The `generate_tests.py` script additionally expects `name_src.spvasm` to include a heading where the purpose of the test is explained. This heading is parsed as a block of lines starting with `;;` at the top of the file. KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/basic_autogen.cpp000066400000000000000000000250601475742701700260240ustar00rootroot00000000000000// GENERATED FILE - DO NOT EDIT. // Generated by generate_tests.py // // Copyright (c) 2022 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "../diff_test_utils.h" #include "gtest/gtest.h" namespace spvtools { namespace diff { namespace { // Basic test for spirv-diff constexpr char kSrc[] = R"(; SPIR-V ; Version: 1.0 ; Generator: Google ANGLE Shader Compiler; 0 ; Bound: 27 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %22 "main" %4 %14 %19 OpSource GLSL 450 OpName %4 "_ua_position" OpName %14 "ANGLEXfbPosition" OpName %17 "gl_PerVertex" OpMemberName %17 0 "gl_Position" OpMemberName %17 1 "gl_PointSize" OpMemberName %17 2 "gl_ClipDistance" OpMemberName %17 3 "gl_CullDistance" OpName %19 "" OpName %22 "main" OpDecorate %4 Location 0 OpDecorate %14 Location 0 OpMemberDecorate %17 1 RelaxedPrecision OpMemberDecorate %17 0 BuiltIn Position OpMemberDecorate %17 1 BuiltIn PointSize OpMemberDecorate %17 2 BuiltIn ClipDistance OpMemberDecorate %17 3 BuiltIn CullDistance OpDecorate %17 Block %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeInt 32 0 %6 = OpTypeInt 32 1 %15 = OpConstant %5 8 %16 = OpTypeArray %1 %15 %17 = OpTypeStruct %2 %1 %16 %16 %20 = OpTypeVoid %25 = OpConstant %6 0 %3 = OpTypePointer Input %2 %13 = OpTypePointer Output %2 %18 = OpTypePointer Output %17 %21 = OpTypeFunction %20 %4 = OpVariable %3 Input %14 = OpVariable %13 Output %19 = OpVariable %18 Output %22 = OpFunction %20 None %21 %23 = OpLabel %24 = OpLoad %2 %4 %26 = OpAccessChain %13 %19 %25 OpStore %26 %24 OpReturn OpFunctionEnd)"; constexpr char kDst[] = R"(; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 28 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %4 "main" %13 %17 %27 OpSource GLSL 450 OpName %4 "main" OpName %11 "gl_PerVertex" OpMemberName %11 0 "gl_Position" OpMemberName %11 1 "gl_PointSize" OpMemberName %11 2 "gl_ClipDistance" OpMemberName %11 3 "gl_CullDistance" OpName %13 "" OpName %17 "_ua_position" OpName %27 "ANGLEXfbPosition" OpMemberDecorate %11 0 BuiltIn Position OpMemberDecorate %11 1 BuiltIn PointSize OpMemberDecorate %11 2 BuiltIn ClipDistance OpMemberDecorate %11 3 BuiltIn CullDistance OpDecorate %11 Block OpDecorate %17 Location 0 OpDecorate %27 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypeInt 32 0 %9 = OpConstant %8 1 %10 = OpTypeArray %6 %9 %11 = OpTypeStruct %7 %6 %10 %10 %12 = OpTypePointer Output %11 %13 = OpVariable %12 Output %14 = OpTypeInt 32 1 %15 = OpConstant %14 0 %16 = OpTypePointer Input %7 %17 = OpVariable %16 Input %19 = OpTypePointer Output %7 %27 = OpVariable %19 Output %4 = OpFunction %2 None %3 %5 = OpLabel %18 = OpLoad %7 %17 %20 = OpAccessChain %19 %13 %15 OpStore %20 %18 OpReturn OpFunctionEnd )"; TEST(DiffTest, Basic) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 27 +; Bound: 30 ; Schema: 0 OpCapability Shader +%27 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 -OpEntryPoint Vertex %22 "main" %4 %14 %19 +OpEntryPoint Vertex %22 "main" %19 %4 %14 OpSource GLSL 450 OpName %4 "_ua_position" OpName %14 "ANGLEXfbPosition" OpName %17 "gl_PerVertex" OpMemberName %17 0 "gl_Position" OpMemberName %17 1 "gl_PointSize" OpMemberName %17 2 "gl_ClipDistance" OpMemberName %17 3 "gl_CullDistance" OpName %19 "" OpName %22 "main" OpDecorate %4 Location 0 OpDecorate %14 Location 0 -OpMemberDecorate %17 1 RelaxedPrecision OpMemberDecorate %17 0 BuiltIn Position OpMemberDecorate %17 1 BuiltIn PointSize OpMemberDecorate %17 2 BuiltIn ClipDistance OpMemberDecorate %17 3 BuiltIn CullDistance OpDecorate %17 Block %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeInt 32 0 %6 = OpTypeInt 32 1 -%15 = OpConstant %5 8 -%16 = OpTypeArray %1 %15 -%17 = OpTypeStruct %2 %1 %16 %16 +%17 = OpTypeStruct %2 %1 %29 %29 +%28 = OpConstant %5 1 +%29 = OpTypeArray %1 %28 %20 = OpTypeVoid %25 = OpConstant %6 0 %3 = OpTypePointer Input %2 %13 = OpTypePointer Output %2 %18 = OpTypePointer Output %17 %21 = OpTypeFunction %20 %4 = OpVariable %3 Input %14 = OpVariable %13 Output %19 = OpVariable %18 Output %22 = OpFunction %20 None %21 %23 = OpLabel %24 = OpLoad %2 %4 %26 = OpAccessChain %13 %19 %25 OpStore %26 %24 OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrc, kDst, kDiff, options); } TEST(DiffTest, BasicNoDebug) { constexpr char kSrcNoDebug[] = R"(; SPIR-V ; Version: 1.0 ; Generator: Google ANGLE Shader Compiler; 0 ; Bound: 27 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %22 "main" %4 %14 %19 OpSource GLSL 450 OpDecorate %4 Location 0 OpDecorate %14 Location 0 OpMemberDecorate %17 1 RelaxedPrecision OpMemberDecorate %17 0 BuiltIn Position OpMemberDecorate %17 1 BuiltIn PointSize OpMemberDecorate %17 2 BuiltIn ClipDistance OpMemberDecorate %17 3 BuiltIn CullDistance OpDecorate %17 Block %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeInt 32 0 %6 = OpTypeInt 32 1 %15 = OpConstant %5 8 %16 = OpTypeArray %1 %15 %17 = OpTypeStruct %2 %1 %16 %16 %20 = OpTypeVoid %25 = OpConstant %6 0 %3 = OpTypePointer Input %2 %13 = OpTypePointer Output %2 %18 = OpTypePointer Output %17 %21 = OpTypeFunction %20 %4 = OpVariable %3 Input %14 = OpVariable %13 Output %19 = OpVariable %18 Output %22 = OpFunction %20 None %21 %23 = OpLabel %24 = OpLoad %2 %4 %26 = OpAccessChain %13 %19 %25 OpStore %26 %24 OpReturn OpFunctionEnd )"; constexpr char kDstNoDebug[] = R"(; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 28 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %4 "main" %13 %17 %27 OpSource GLSL 450 OpMemberDecorate %11 0 BuiltIn Position OpMemberDecorate %11 1 BuiltIn PointSize OpMemberDecorate %11 2 BuiltIn ClipDistance OpMemberDecorate %11 3 BuiltIn CullDistance OpDecorate %11 Block OpDecorate %17 Location 0 OpDecorate %27 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypeInt 32 0 %9 = OpConstant %8 1 %10 = OpTypeArray %6 %9 %11 = OpTypeStruct %7 %6 %10 %10 %12 = OpTypePointer Output %11 %13 = OpVariable %12 Output %14 = OpTypeInt 32 1 %15 = OpConstant %14 0 %16 = OpTypePointer Input %7 %17 = OpVariable %16 Input %19 = OpTypePointer Output %7 %27 = OpVariable %19 Output %4 = OpFunction %2 None %3 %5 = OpLabel %18 = OpLoad %7 %17 %20 = OpAccessChain %19 %13 %15 OpStore %20 %18 OpReturn OpFunctionEnd )"; constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 27 +; Bound: 30 ; Schema: 0 OpCapability Shader +%27 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 -OpEntryPoint Vertex %22 "main" %4 %14 %19 +OpEntryPoint Vertex %22 "main" %19 %4 %14 OpSource GLSL 450 OpDecorate %4 Location 0 OpDecorate %14 Location 0 -OpMemberDecorate %17 1 RelaxedPrecision OpMemberDecorate %17 0 BuiltIn Position OpMemberDecorate %17 1 BuiltIn PointSize OpMemberDecorate %17 2 BuiltIn ClipDistance OpMemberDecorate %17 3 BuiltIn CullDistance OpDecorate %17 Block %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeInt 32 0 %6 = OpTypeInt 32 1 -%15 = OpConstant %5 8 -%16 = OpTypeArray %1 %15 -%17 = OpTypeStruct %2 %1 %16 %16 +%17 = OpTypeStruct %2 %1 %29 %29 +%28 = OpConstant %5 1 +%29 = OpTypeArray %1 %28 %20 = OpTypeVoid %25 = OpConstant %6 0 %3 = OpTypePointer Input %2 %13 = OpTypePointer Output %2 %18 = OpTypePointer Output %17 %21 = OpTypeFunction %20 %4 = OpVariable %3 Input %14 = OpVariable %13 Output %19 = OpVariable %18 Output %22 = OpFunction %20 None %21 %23 = OpLabel %24 = OpLoad %2 %4 %26 = OpAccessChain %13 %19 %25 OpStore %26 %24 OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrcNoDebug, kDstNoDebug, kDiff, options); } TEST(DiffTest, BasicDumpIds) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 27 +; Bound: 30 ; Schema: 0 OpCapability Shader +%27 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 -OpEntryPoint Vertex %22 "main" %4 %14 %19 +OpEntryPoint Vertex %22 "main" %19 %4 %14 OpSource GLSL 450 OpName %4 "_ua_position" OpName %14 "ANGLEXfbPosition" OpName %17 "gl_PerVertex" OpMemberName %17 0 "gl_Position" OpMemberName %17 1 "gl_PointSize" OpMemberName %17 2 "gl_ClipDistance" OpMemberName %17 3 "gl_CullDistance" OpName %19 "" OpName %22 "main" OpDecorate %4 Location 0 OpDecorate %14 Location 0 -OpMemberDecorate %17 1 RelaxedPrecision OpMemberDecorate %17 0 BuiltIn Position OpMemberDecorate %17 1 BuiltIn PointSize OpMemberDecorate %17 2 BuiltIn ClipDistance OpMemberDecorate %17 3 BuiltIn CullDistance OpDecorate %17 Block %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeInt 32 0 %6 = OpTypeInt 32 1 -%15 = OpConstant %5 8 -%16 = OpTypeArray %1 %15 -%17 = OpTypeStruct %2 %1 %16 %16 +%17 = OpTypeStruct %2 %1 %29 %29 +%28 = OpConstant %5 1 +%29 = OpTypeArray %1 %28 %20 = OpTypeVoid %25 = OpConstant %6 0 %3 = OpTypePointer Input %2 %13 = OpTypePointer Output %2 %18 = OpTypePointer Output %17 %21 = OpTypeFunction %20 %4 = OpVariable %3 Input %14 = OpVariable %13 Output %19 = OpVariable %18 Output %22 = OpFunction %20 None %21 %23 = OpLabel %24 = OpLoad %2 %4 %26 = OpAccessChain %13 %19 %25 OpStore %26 %24 OpReturn OpFunctionEnd Src -> Dst 1 -> 6 [TypeFloat] 2 -> 7 [TypeVector] 3 -> 16 [TypePointer] 4 -> 17 [Variable] 5 -> 8 [TypeInt] 6 -> 14 [TypeInt] 13 -> 19 [TypePointer] 14 -> 27 [Variable] 15 -> 28 [Constant] 16 -> 29 [TypeArray] 17 -> 11 [TypeStruct] 18 -> 12 [TypePointer] 19 -> 13 [Variable] 20 -> 2 [TypeVoid] 21 -> 3 [TypeFunction] 22 -> 4 [Function] 23 -> 5 [Label] 24 -> 18 [Load] 25 -> 15 [Constant] 26 -> 20 [AccessChain] )"; Options options; options.dump_id_map = true; DoStringDiffTest(kSrc, kDst, kDiff, options); } } // namespace } // namespace diff } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/basic_dst.spvasm000066400000000000000000000023671475742701700257100ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 28 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %4 "main" %13 %17 %27 OpSource GLSL 450 OpName %4 "main" OpName %11 "gl_PerVertex" OpMemberName %11 0 "gl_Position" OpMemberName %11 1 "gl_PointSize" OpMemberName %11 2 "gl_ClipDistance" OpMemberName %11 3 "gl_CullDistance" OpName %13 "" OpName %17 "_ua_position" OpName %27 "ANGLEXfbPosition" OpMemberDecorate %11 0 BuiltIn Position OpMemberDecorate %11 1 BuiltIn PointSize OpMemberDecorate %11 2 BuiltIn ClipDistance OpMemberDecorate %11 3 BuiltIn CullDistance OpDecorate %11 Block OpDecorate %17 Location 0 OpDecorate %27 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypeInt 32 0 %9 = OpConstant %8 1 %10 = OpTypeArray %6 %9 %11 = OpTypeStruct %7 %6 %10 %10 %12 = OpTypePointer Output %11 %13 = OpVariable %12 Output %14 = OpTypeInt 32 1 %15 = OpConstant %14 0 %16 = OpTypePointer Input %7 %17 = OpVariable %16 Input %19 = OpTypePointer Output %7 %27 = OpVariable %19 Output %4 = OpFunction %2 None %3 %5 = OpLabel %18 = OpLoad %7 %17 %20 = OpAccessChain %19 %13 %15 OpStore %20 %18 OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/basic_src.spvasm000066400000000000000000000024601475742701700256770ustar00rootroot00000000000000;; Basic test for spirv-diff ; SPIR-V ; Version: 1.0 ; Generator: Google ANGLE Shader Compiler; 0 ; Bound: 27 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %22 "main" %4 %14 %19 OpSource GLSL 450 OpName %4 "_ua_position" OpName %14 "ANGLEXfbPosition" OpName %17 "gl_PerVertex" OpMemberName %17 0 "gl_Position" OpMemberName %17 1 "gl_PointSize" OpMemberName %17 2 "gl_ClipDistance" OpMemberName %17 3 "gl_CullDistance" OpName %19 "" OpName %22 "main" OpDecorate %4 Location 0 OpDecorate %14 Location 0 OpMemberDecorate %17 1 RelaxedPrecision OpMemberDecorate %17 0 BuiltIn Position OpMemberDecorate %17 1 BuiltIn PointSize OpMemberDecorate %17 2 BuiltIn ClipDistance OpMemberDecorate %17 3 BuiltIn CullDistance OpDecorate %17 Block %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeInt 32 0 %6 = OpTypeInt 32 1 %15 = OpConstant %5 8 %16 = OpTypeArray %1 %15 %17 = OpTypeStruct %2 %1 %16 %16 %20 = OpTypeVoid %25 = OpConstant %6 0 %3 = OpTypePointer Input %2 %13 = OpTypePointer Output %2 %18 = OpTypePointer Output %17 %21 = OpTypeFunction %20 %4 = OpVariable %3 Input %14 = OpVariable %13 Output %19 = OpVariable %18 Output %22 = OpFunction %20 None %21 %23 = OpLabel %24 = OpLoad %2 %4 %26 = OpAccessChain %13 %19 %25 OpStore %26 %24 OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/constant_array_size_autogen.cpp000066400000000000000000000176011475742701700310260ustar00rootroot00000000000000// GENERATED FILE - DO NOT EDIT. // Generated by generate_tests.py // // Copyright (c) 2022 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "../diff_test_utils.h" #include "gtest/gtest.h" namespace spvtools { namespace diff { namespace { // Tests that identical integer constants are matched when used as array size, // regardless of int or uint. constexpr char kSrc[] = R"(; SPIR-V ; Version: 1.0 ; Generator: Google ANGLE Shader Compiler; 0 ; Bound: 27 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %22 "main" %4 %19 OpSource GLSL 450 OpName %4 "_ua_position" OpName %17 "gl_PerVertex" OpMemberName %17 0 "gl_Position" OpMemberName %17 1 "gl_PointSize" OpMemberName %17 2 "gl_ClipDistance" OpMemberName %17 3 "gl_CullDistance" OpName %19 "" OpName %22 "main" OpDecorate %4 Location 0 OpMemberDecorate %17 1 RelaxedPrecision OpMemberDecorate %17 0 BuiltIn Position OpMemberDecorate %17 1 BuiltIn PointSize OpMemberDecorate %17 2 BuiltIn ClipDistance OpMemberDecorate %17 3 BuiltIn CullDistance OpDecorate %17 Block %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeInt 32 0 %8 = OpTypeVector %5 4 %15 = OpConstant %5 8 %16 = OpTypeArray %1 %15 %17 = OpTypeStruct %2 %1 %16 %16 %20 = OpTypeVoid %25 = OpConstant %5 0 %3 = OpTypePointer Input %2 %13 = OpTypePointer Output %2 %18 = OpTypePointer Output %17 %21 = OpTypeFunction %20 %4 = OpVariable %3 Input %19 = OpVariable %18 Output %22 = OpFunction %20 None %21 %23 = OpLabel %24 = OpLoad %2 %4 %26 = OpAccessChain %13 %19 %25 OpStore %26 %24 OpReturn OpFunctionEnd)"; constexpr char kDst[] = R"(; SPIR-V ; Version: 1.0 ; Generator: Google ANGLE Shader Compiler; 0 ; Bound: 27 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %22 "main" %4 %19 OpSource GLSL 450 OpName %4 "_ua_position" OpName %17 "gl_PerVertex" OpMemberName %17 0 "gl_Position" OpMemberName %17 1 "gl_PointSize" OpMemberName %17 2 "gl_ClipDistance" OpMemberName %17 3 "gl_CullDistance" OpName %19 "" OpName %22 "main" OpDecorate %4 Location 0 OpMemberDecorate %17 1 RelaxedPrecision OpMemberDecorate %17 0 BuiltIn Position OpMemberDecorate %17 1 BuiltIn PointSize OpMemberDecorate %17 2 BuiltIn ClipDistance OpMemberDecorate %17 3 BuiltIn CullDistance OpDecorate %17 Block %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeInt 32 0 %6 = OpTypeInt 32 1 %8 = OpTypeVector %5 4 %15 = OpConstant %6 8 %16 = OpTypeArray %1 %15 %17 = OpTypeStruct %2 %1 %16 %16 %20 = OpTypeVoid %25 = OpConstant %5 0 %3 = OpTypePointer Input %2 %13 = OpTypePointer Output %2 %18 = OpTypePointer Output %17 %21 = OpTypeFunction %20 %4 = OpVariable %3 Input %19 = OpVariable %18 Output %22 = OpFunction %20 None %21 %23 = OpLabel %24 = OpLoad %2 %4 %26 = OpAccessChain %13 %19 %25 OpStore %26 %24 OpReturn OpFunctionEnd )"; TEST(DiffTest, ConstantArraySize) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 27 +; Bound: 28 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %22 "main" %4 %19 OpSource GLSL 450 OpName %4 "_ua_position" OpName %17 "gl_PerVertex" OpMemberName %17 0 "gl_Position" OpMemberName %17 1 "gl_PointSize" OpMemberName %17 2 "gl_ClipDistance" OpMemberName %17 3 "gl_CullDistance" OpName %19 "" OpName %22 "main" OpDecorate %4 Location 0 OpMemberDecorate %17 1 RelaxedPrecision OpMemberDecorate %17 0 BuiltIn Position OpMemberDecorate %17 1 BuiltIn PointSize OpMemberDecorate %17 2 BuiltIn ClipDistance OpMemberDecorate %17 3 BuiltIn CullDistance OpDecorate %17 Block %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeInt 32 0 +%27 = OpTypeInt 32 1 %8 = OpTypeVector %5 4 -%15 = OpConstant %5 8 +%15 = OpConstant %27 8 %16 = OpTypeArray %1 %15 %17 = OpTypeStruct %2 %1 %16 %16 %20 = OpTypeVoid %25 = OpConstant %5 0 %3 = OpTypePointer Input %2 %13 = OpTypePointer Output %2 %18 = OpTypePointer Output %17 %21 = OpTypeFunction %20 %4 = OpVariable %3 Input %19 = OpVariable %18 Output %22 = OpFunction %20 None %21 %23 = OpLabel %24 = OpLoad %2 %4 %26 = OpAccessChain %13 %19 %25 OpStore %26 %24 OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrc, kDst, kDiff, options); } TEST(DiffTest, ConstantArraySizeNoDebug) { constexpr char kSrcNoDebug[] = R"(; SPIR-V ; Version: 1.0 ; Generator: Google ANGLE Shader Compiler; 0 ; Bound: 27 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %22 "main" %4 %19 OpSource GLSL 450 OpDecorate %4 Location 0 OpMemberDecorate %17 1 RelaxedPrecision OpMemberDecorate %17 0 BuiltIn Position OpMemberDecorate %17 1 BuiltIn PointSize OpMemberDecorate %17 2 BuiltIn ClipDistance OpMemberDecorate %17 3 BuiltIn CullDistance OpDecorate %17 Block %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeInt 32 0 %8 = OpTypeVector %5 4 %15 = OpConstant %5 8 %16 = OpTypeArray %1 %15 %17 = OpTypeStruct %2 %1 %16 %16 %20 = OpTypeVoid %25 = OpConstant %5 0 %3 = OpTypePointer Input %2 %13 = OpTypePointer Output %2 %18 = OpTypePointer Output %17 %21 = OpTypeFunction %20 %4 = OpVariable %3 Input %19 = OpVariable %18 Output %22 = OpFunction %20 None %21 %23 = OpLabel %24 = OpLoad %2 %4 %26 = OpAccessChain %13 %19 %25 OpStore %26 %24 OpReturn OpFunctionEnd )"; constexpr char kDstNoDebug[] = R"(; SPIR-V ; Version: 1.0 ; Generator: Google ANGLE Shader Compiler; 0 ; Bound: 27 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %22 "main" %4 %19 OpSource GLSL 450 OpDecorate %4 Location 0 OpMemberDecorate %17 1 RelaxedPrecision OpMemberDecorate %17 0 BuiltIn Position OpMemberDecorate %17 1 BuiltIn PointSize OpMemberDecorate %17 2 BuiltIn ClipDistance OpMemberDecorate %17 3 BuiltIn CullDistance OpDecorate %17 Block %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeInt 32 0 %6 = OpTypeInt 32 1 %8 = OpTypeVector %5 4 %15 = OpConstant %6 8 %16 = OpTypeArray %1 %15 %17 = OpTypeStruct %2 %1 %16 %16 %20 = OpTypeVoid %25 = OpConstant %5 0 %3 = OpTypePointer Input %2 %13 = OpTypePointer Output %2 %18 = OpTypePointer Output %17 %21 = OpTypeFunction %20 %4 = OpVariable %3 Input %19 = OpVariable %18 Output %22 = OpFunction %20 None %21 %23 = OpLabel %24 = OpLoad %2 %4 %26 = OpAccessChain %13 %19 %25 OpStore %26 %24 OpReturn OpFunctionEnd )"; constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 27 +; Bound: 28 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %22 "main" %4 %19 OpSource GLSL 450 OpDecorate %4 Location 0 OpMemberDecorate %17 1 RelaxedPrecision OpMemberDecorate %17 0 BuiltIn Position OpMemberDecorate %17 1 BuiltIn PointSize OpMemberDecorate %17 2 BuiltIn ClipDistance OpMemberDecorate %17 3 BuiltIn CullDistance OpDecorate %17 Block %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeInt 32 0 +%27 = OpTypeInt 32 1 %8 = OpTypeVector %5 4 -%15 = OpConstant %5 8 +%15 = OpConstant %27 8 %16 = OpTypeArray %1 %15 %17 = OpTypeStruct %2 %1 %16 %16 %20 = OpTypeVoid %25 = OpConstant %5 0 %3 = OpTypePointer Input %2 %13 = OpTypePointer Output %2 %18 = OpTypePointer Output %17 %21 = OpTypeFunction %20 %4 = OpVariable %3 Input %19 = OpVariable %18 Output %22 = OpFunction %20 None %21 %23 = OpLabel %24 = OpLoad %2 %4 %26 = OpAccessChain %13 %19 %25 OpStore %26 %24 OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrcNoDebug, kDstNoDebug, kDiff, options); } } // namespace } // namespace diff } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/constant_array_size_dst.spvasm000066400000000000000000000022641475742701700307040ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google ANGLE Shader Compiler; 0 ; Bound: 27 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %22 "main" %4 %19 OpSource GLSL 450 OpName %4 "_ua_position" OpName %17 "gl_PerVertex" OpMemberName %17 0 "gl_Position" OpMemberName %17 1 "gl_PointSize" OpMemberName %17 2 "gl_ClipDistance" OpMemberName %17 3 "gl_CullDistance" OpName %19 "" OpName %22 "main" OpDecorate %4 Location 0 OpMemberDecorate %17 1 RelaxedPrecision OpMemberDecorate %17 0 BuiltIn Position OpMemberDecorate %17 1 BuiltIn PointSize OpMemberDecorate %17 2 BuiltIn ClipDistance OpMemberDecorate %17 3 BuiltIn CullDistance OpDecorate %17 Block %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeInt 32 0 %6 = OpTypeInt 32 1 %8 = OpTypeVector %5 4 %15 = OpConstant %6 8 %16 = OpTypeArray %1 %15 %17 = OpTypeStruct %2 %1 %16 %16 %20 = OpTypeVoid %25 = OpConstant %5 0 %3 = OpTypePointer Input %2 %13 = OpTypePointer Output %2 %18 = OpTypePointer Output %17 %21 = OpTypeFunction %20 %4 = OpVariable %3 Input %19 = OpVariable %18 Output %22 = OpFunction %20 None %21 %23 = OpLabel %24 = OpLoad %2 %4 %26 = OpAccessChain %13 %19 %25 OpStore %26 %24 OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/constant_array_size_src.spvasm000066400000000000000000000024151475742701700306770ustar00rootroot00000000000000;; Tests that identical integer constants are matched when used as array size, ;; regardless of int or uint. ; SPIR-V ; Version: 1.0 ; Generator: Google ANGLE Shader Compiler; 0 ; Bound: 27 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %22 "main" %4 %19 OpSource GLSL 450 OpName %4 "_ua_position" OpName %17 "gl_PerVertex" OpMemberName %17 0 "gl_Position" OpMemberName %17 1 "gl_PointSize" OpMemberName %17 2 "gl_ClipDistance" OpMemberName %17 3 "gl_CullDistance" OpName %19 "" OpName %22 "main" OpDecorate %4 Location 0 OpMemberDecorate %17 1 RelaxedPrecision OpMemberDecorate %17 0 BuiltIn Position OpMemberDecorate %17 1 BuiltIn PointSize OpMemberDecorate %17 2 BuiltIn ClipDistance OpMemberDecorate %17 3 BuiltIn CullDistance OpDecorate %17 Block %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeInt 32 0 %8 = OpTypeVector %5 4 %15 = OpConstant %5 8 %16 = OpTypeArray %1 %15 %17 = OpTypeStruct %2 %1 %16 %16 %20 = OpTypeVoid %25 = OpConstant %5 0 %3 = OpTypePointer Input %2 %13 = OpTypePointer Output %2 %18 = OpTypePointer Output %17 %21 = OpTypeFunction %20 %4 = OpVariable %3 Input %19 = OpVariable %18 Output %22 = OpFunction %20 None %21 %23 = OpLabel %24 = OpLoad %2 %4 %26 = OpAccessChain %13 %19 %25 OpStore %26 %24 OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/diff_test_files_autogen.cmake000066400000000000000000000041761475742701700303770ustar00rootroot00000000000000# GENERATED FILE - DO NOT EDIT. # Generated by generate_tests.py # # Copyright (c) 2022 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. list(APPEND DIFF_TEST_FILES "diff_files/OpExtInst_in_dst_only_autogen.cpp" "diff_files/OpExtInst_in_src_only_autogen.cpp" "diff_files/OpTypeForwardPointer_basic_autogen.cpp" "diff_files/OpTypeForwardPointer_intertwined_autogen.cpp" "diff_files/OpTypeForwardPointer_mismatching_class_autogen.cpp" "diff_files/OpTypeForwardPointer_mismatching_type_autogen.cpp" "diff_files/OpTypeForwardPointer_nested_autogen.cpp" "diff_files/OpTypeForwardPointer_onesided_debug_autogen.cpp" "diff_files/basic_autogen.cpp" "diff_files/constant_array_size_autogen.cpp" "diff_files/different_decorations_fragment_autogen.cpp" "diff_files/different_decorations_vertex_autogen.cpp" "diff_files/different_function_parameter_count_autogen.cpp" "diff_files/extra_if_block_autogen.cpp" "diff_files/index_signedness_autogen.cpp" "diff_files/int_vs_uint_constants_autogen.cpp" "diff_files/large_functions_large_diffs_autogen.cpp" "diff_files/large_functions_small_diffs_autogen.cpp" "diff_files/multiple_different_entry_points_autogen.cpp" "diff_files/multiple_same_entry_points_autogen.cpp" "diff_files/ray_query_types_autogen.cpp" "diff_files/reordered_if_blocks_autogen.cpp" "diff_files/reordered_switch_blocks_autogen.cpp" "diff_files/small_functions_small_diffs_autogen.cpp" "diff_files/spec_constant_array_size_autogen.cpp" "diff_files/spec_constant_composite_autogen.cpp" "diff_files/spec_constant_op_autogen.cpp" "diff_files/spec_constant_specid_autogen.cpp" "diff_files/string_in_ext_inst_autogen.cpp" "diff_files/unrelated_shaders_autogen.cpp" ) KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/different_decorations_fragment_autogen.cpp000066400000000000000000001324131475742701700331670ustar00rootroot00000000000000// GENERATED FILE - DO NOT EDIT. // Generated by generate_tests.py // // Copyright (c) 2022 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "../diff_test_utils.h" #include "gtest/gtest.h" namespace spvtools { namespace diff { namespace { // Test where variable set/binding/location decorations are different between // src and dst fragment shaders. constexpr char kSrc[] = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %63 "main" %4 %22 OpExecutionMode %63 OriginUpperLeft OpSource GLSL 450 OpName %4 "_ue" OpName %8 "_uf" OpName %11 "_ug" OpName %12 "_uA" OpMemberName %12 0 "_ux" OpName %14 "_uc" OpName %15 "_uB" OpMemberName %15 0 "_ux" OpName %20 "_ud" OpName %22 "_ucol" OpName %26 "ANGLEDepthRangeParams" OpMemberName %26 0 "near" OpMemberName %26 1 "far" OpMemberName %26 2 "diff" OpMemberName %26 3 "reserved" OpName %27 "ANGLEUniformBlock" OpMemberName %27 0 "viewport" OpMemberName %27 1 "clipDistancesEnabled" OpMemberName %27 2 "xfbActiveUnpaused" OpMemberName %27 3 "xfbVerticesPerInstance" OpMemberName %27 4 "numSamples" OpMemberName %27 5 "xfbBufferOffsets" OpMemberName %27 6 "acbBufferOffsets" OpMemberName %27 7 "depthRange" OpName %29 "ANGLEUniforms" OpName %33 "_uc" OpName %32 "_uh" OpName %49 "_ux" OpName %50 "_uy" OpName %48 "_ui" OpName %63 "main" OpName %65 "param" OpName %68 "param" OpName %73 "param" OpDecorate %4 Location 0 OpDecorate %8 RelaxedPrecision OpDecorate %8 DescriptorSet 0 OpDecorate %8 Binding 0 OpDecorate %11 DescriptorSet 0 OpDecorate %11 Binding 1 OpMemberDecorate %12 0 Offset 0 OpMemberDecorate %12 0 RelaxedPrecision OpDecorate %12 Block OpDecorate %14 DescriptorSet 0 OpDecorate %14 Binding 2 OpMemberDecorate %15 0 Offset 0 OpMemberDecorate %15 0 RelaxedPrecision OpDecorate %15 BufferBlock OpDecorate %20 DescriptorSet 0 OpDecorate %20 Binding 3 OpDecorate %22 RelaxedPrecision OpDecorate %22 Location 0 OpMemberDecorate %26 0 Offset 0 OpMemberDecorate %26 1 Offset 4 OpMemberDecorate %26 2 Offset 8 OpMemberDecorate %26 3 Offset 12 OpMemberDecorate %27 0 Offset 0 OpMemberDecorate %27 1 Offset 16 OpMemberDecorate %27 2 Offset 20 OpMemberDecorate %27 3 Offset 24 OpMemberDecorate %27 4 Offset 28 OpMemberDecorate %27 5 Offset 32 OpMemberDecorate %27 6 Offset 48 OpMemberDecorate %27 7 Offset 64 OpMemberDecorate %27 2 RelaxedPrecision OpMemberDecorate %27 4 RelaxedPrecision OpDecorate %27 Block OpDecorate %29 DescriptorSet 0 OpDecorate %29 Binding 4 OpDecorate %32 RelaxedPrecision OpDecorate %33 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %38 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %41 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %43 RelaxedPrecision OpDecorate %48 RelaxedPrecision OpDecorate %49 RelaxedPrecision OpDecorate %50 RelaxedPrecision OpDecorate %52 RelaxedPrecision OpDecorate %53 RelaxedPrecision OpDecorate %54 RelaxedPrecision OpDecorate %55 RelaxedPrecision OpDecorate %56 RelaxedPrecision OpDecorate %57 RelaxedPrecision OpDecorate %58 RelaxedPrecision OpDecorate %59 RelaxedPrecision OpDecorate %60 RelaxedPrecision OpDecorate %67 RelaxedPrecision OpDecorate %68 RelaxedPrecision OpDecorate %72 RelaxedPrecision OpDecorate %73 RelaxedPrecision OpDecorate %75 RelaxedPrecision OpDecorate %76 RelaxedPrecision OpDecorate %77 RelaxedPrecision OpDecorate %80 RelaxedPrecision OpDecorate %81 RelaxedPrecision %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeImage %1 2D 0 0 0 1 Unknown %6 = OpTypeSampledImage %5 %9 = OpTypeImage %1 2D 0 0 0 2 Rgba8 %12 = OpTypeStruct %2 %15 = OpTypeStruct %2 %16 = OpTypeInt 32 0 %17 = OpConstant %16 2 %18 = OpTypeArray %15 %17 %23 = OpTypeInt 32 1 %24 = OpTypeVector %23 4 %25 = OpTypeVector %16 4 %26 = OpTypeStruct %1 %1 %1 %1 %27 = OpTypeStruct %2 %16 %16 %23 %23 %24 %25 %26 %35 = OpTypeVector %1 2 %40 = OpTypeVector %23 2 %61 = OpTypeVoid %69 = OpConstant %16 0 %78 = OpConstant %16 1 %3 = OpTypePointer Input %2 %7 = OpTypePointer UniformConstant %6 %10 = OpTypePointer UniformConstant %9 %13 = OpTypePointer Uniform %12 %19 = OpTypePointer Uniform %18 %21 = OpTypePointer Output %2 %28 = OpTypePointer Uniform %27 %30 = OpTypePointer Function %2 %70 = OpTypePointer Uniform %2 %31 = OpTypeFunction %2 %30 %47 = OpTypeFunction %2 %30 %30 %62 = OpTypeFunction %61 %4 = OpVariable %3 Input %8 = OpVariable %7 UniformConstant %11 = OpVariable %10 UniformConstant %14 = OpVariable %13 Uniform %20 = OpVariable %19 Uniform %22 = OpVariable %21 Output %29 = OpVariable %28 Uniform %32 = OpFunction %2 None %31 %33 = OpFunctionParameter %30 %34 = OpLabel %36 = OpLoad %6 %8 %37 = OpLoad %2 %33 %38 = OpVectorShuffle %35 %37 %37 0 1 %39 = OpImageSampleImplicitLod %2 %36 %38 %41 = OpLoad %2 %33 %42 = OpVectorShuffle %35 %41 %41 2 3 %43 = OpConvertFToS %40 %42 %44 = OpLoad %9 %11 %45 = OpImageRead %2 %44 %43 %46 = OpFAdd %2 %39 %45 OpReturnValue %46 OpFunctionEnd %48 = OpFunction %2 None %47 %49 = OpFunctionParameter %30 %50 = OpFunctionParameter %30 %51 = OpLabel %52 = OpLoad %2 %49 %53 = OpVectorShuffle %35 %52 %52 0 1 %54 = OpLoad %2 %50 %55 = OpVectorShuffle %35 %54 %54 2 3 %56 = OpCompositeExtract %1 %53 0 %57 = OpCompositeExtract %1 %53 1 %58 = OpCompositeExtract %1 %55 0 %59 = OpCompositeExtract %1 %55 1 %60 = OpCompositeConstruct %2 %56 %57 %58 %59 OpReturnValue %60 OpFunctionEnd %63 = OpFunction %61 None %62 %64 = OpLabel %65 = OpVariable %30 Function %68 = OpVariable %30 Function %73 = OpVariable %30 Function %66 = OpLoad %2 %4 OpStore %65 %66 %67 = OpFunctionCall %2 %32 %65 %71 = OpAccessChain %70 %14 %69 %72 = OpLoad %2 %71 OpStore %68 %72 %74 = OpAccessChain %70 %20 %69 %69 %75 = OpLoad %2 %74 OpStore %73 %75 %76 = OpFunctionCall %2 %48 %68 %73 %77 = OpFAdd %2 %67 %76 %79 = OpAccessChain %70 %20 %78 %69 %80 = OpLoad %2 %79 %81 = OpFAdd %2 %77 %80 OpStore %22 %81 OpReturn OpFunctionEnd )"; constexpr char kDst[] = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %63 "main" %4 %22 OpExecutionMode %63 OriginUpperLeft OpSource GLSL 450 OpName %4 "_ue" OpName %8 "_uf" OpName %11 "_ug" OpName %12 "_uA" OpMemberName %12 0 "_ux" OpName %14 "_uc" OpName %15 "_uB" OpMemberName %15 0 "_ux" OpName %20 "_ud" OpName %22 "_ucol" OpName %26 "ANGLEDepthRangeParams" OpMemberName %26 0 "near" OpMemberName %26 1 "far" OpMemberName %26 2 "diff" OpMemberName %26 3 "reserved" OpName %27 "ANGLEUniformBlock" OpMemberName %27 0 "viewport" OpMemberName %27 1 "clipDistancesEnabled" OpMemberName %27 2 "xfbActiveUnpaused" OpMemberName %27 3 "xfbVerticesPerInstance" OpMemberName %27 4 "numSamples" OpMemberName %27 5 "xfbBufferOffsets" OpMemberName %27 6 "acbBufferOffsets" OpMemberName %27 7 "depthRange" OpName %29 "ANGLEUniforms" OpName %33 "_uc" OpName %32 "_uh" OpName %49 "_ux" OpName %50 "_uy" OpName %48 "_ui" OpName %63 "main" OpName %65 "param" OpName %68 "param" OpName %73 "param" OpDecorate %4 Location 1 OpDecorate %8 RelaxedPrecision OpDecorate %8 DescriptorSet 2 OpDecorate %8 Binding 0 OpDecorate %11 DescriptorSet 3 OpDecorate %11 Binding 0 OpMemberDecorate %12 0 Offset 0 OpMemberDecorate %12 0 RelaxedPrecision OpDecorate %12 Block OpDecorate %14 DescriptorSet 3 OpDecorate %14 Binding 1 OpMemberDecorate %15 0 Offset 0 OpMemberDecorate %15 0 RelaxedPrecision OpDecorate %15 BufferBlock OpDecorate %20 DescriptorSet 3 OpDecorate %20 Binding 2 OpDecorate %22 RelaxedPrecision OpDecorate %22 Location 1 OpMemberDecorate %26 0 Offset 0 OpMemberDecorate %26 1 Offset 4 OpMemberDecorate %26 2 Offset 8 OpMemberDecorate %26 3 Offset 12 OpMemberDecorate %27 0 Offset 0 OpMemberDecorate %27 1 Offset 16 OpMemberDecorate %27 2 Offset 20 OpMemberDecorate %27 3 Offset 24 OpMemberDecorate %27 4 Offset 28 OpMemberDecorate %27 5 Offset 32 OpMemberDecorate %27 6 Offset 48 OpMemberDecorate %27 7 Offset 64 OpMemberDecorate %27 2 RelaxedPrecision OpMemberDecorate %27 4 RelaxedPrecision OpDecorate %27 Block OpDecorate %29 DescriptorSet 0 OpDecorate %29 Binding 0 OpDecorate %32 RelaxedPrecision OpDecorate %33 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %38 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %41 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %43 RelaxedPrecision OpDecorate %48 RelaxedPrecision OpDecorate %49 RelaxedPrecision OpDecorate %50 RelaxedPrecision OpDecorate %52 RelaxedPrecision OpDecorate %53 RelaxedPrecision OpDecorate %54 RelaxedPrecision OpDecorate %55 RelaxedPrecision OpDecorate %56 RelaxedPrecision OpDecorate %57 RelaxedPrecision OpDecorate %58 RelaxedPrecision OpDecorate %59 RelaxedPrecision OpDecorate %60 RelaxedPrecision OpDecorate %67 RelaxedPrecision OpDecorate %68 RelaxedPrecision OpDecorate %72 RelaxedPrecision OpDecorate %73 RelaxedPrecision OpDecorate %75 RelaxedPrecision OpDecorate %76 RelaxedPrecision OpDecorate %77 RelaxedPrecision OpDecorate %80 RelaxedPrecision OpDecorate %81 RelaxedPrecision %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeImage %1 2D 0 0 0 1 Unknown %6 = OpTypeSampledImage %5 %9 = OpTypeImage %1 2D 0 0 0 2 Rgba8 %12 = OpTypeStruct %2 %15 = OpTypeStruct %2 %16 = OpTypeInt 32 0 %17 = OpConstant %16 2 %18 = OpTypeArray %15 %17 %23 = OpTypeInt 32 1 %24 = OpTypeVector %23 4 %25 = OpTypeVector %16 4 %26 = OpTypeStruct %1 %1 %1 %1 %27 = OpTypeStruct %2 %16 %16 %23 %23 %24 %25 %26 %35 = OpTypeVector %1 2 %40 = OpTypeVector %23 2 %61 = OpTypeVoid %69 = OpConstant %16 0 %78 = OpConstant %16 1 %82 = OpTypePointer Private %2 %3 = OpTypePointer Input %2 %7 = OpTypePointer UniformConstant %6 %10 = OpTypePointer UniformConstant %9 %13 = OpTypePointer Uniform %12 %19 = OpTypePointer Uniform %18 %83 = OpTypePointer Private %2 %21 = OpTypePointer Output %2 %28 = OpTypePointer Uniform %27 %30 = OpTypePointer Function %2 %70 = OpTypePointer Uniform %2 %31 = OpTypeFunction %2 %30 %47 = OpTypeFunction %2 %30 %30 %62 = OpTypeFunction %61 %4 = OpVariable %3 Input %8 = OpVariable %7 UniformConstant %11 = OpVariable %10 UniformConstant %14 = OpVariable %13 Uniform %20 = OpVariable %19 Uniform %22 = OpVariable %21 Output %29 = OpVariable %28 Uniform %84 = OpConstant %23 0 %85 = OpConstant %1 0.5 %32 = OpFunction %2 None %31 %33 = OpFunctionParameter %30 %34 = OpLabel %36 = OpLoad %6 %8 %37 = OpLoad %2 %33 %38 = OpVectorShuffle %35 %37 %37 0 1 %39 = OpImageSampleImplicitLod %2 %36 %38 %41 = OpLoad %2 %33 %42 = OpVectorShuffle %35 %41 %41 2 3 %43 = OpConvertFToS %40 %42 %44 = OpLoad %9 %11 %45 = OpImageRead %2 %44 %43 %46 = OpFAdd %2 %39 %45 OpReturnValue %46 OpFunctionEnd %48 = OpFunction %2 None %47 %49 = OpFunctionParameter %30 %50 = OpFunctionParameter %30 %51 = OpLabel %52 = OpLoad %2 %49 %53 = OpVectorShuffle %35 %52 %52 0 1 %54 = OpLoad %2 %50 %55 = OpVectorShuffle %35 %54 %54 2 3 %56 = OpCompositeExtract %1 %53 0 %57 = OpCompositeExtract %1 %53 1 %58 = OpCompositeExtract %1 %55 0 %59 = OpCompositeExtract %1 %55 1 %60 = OpCompositeConstruct %2 %56 %57 %58 %59 OpReturnValue %60 OpFunctionEnd %63 = OpFunction %61 None %62 %64 = OpLabel %65 = OpVariable %30 Function %68 = OpVariable %30 Function %73 = OpVariable %30 Function %66 = OpLoad %2 %4 OpStore %65 %66 %67 = OpFunctionCall %2 %32 %65 %71 = OpAccessChain %70 %14 %69 %72 = OpLoad %2 %71 OpStore %68 %72 %74 = OpAccessChain %70 %20 %69 %69 %75 = OpLoad %2 %74 OpStore %73 %75 %76 = OpFunctionCall %2 %48 %68 %73 %77 = OpFAdd %2 %67 %76 %79 = OpAccessChain %70 %20 %78 %69 %80 = OpLoad %2 %79 %81 = OpFAdd %2 %77 %80 OpStore %22 %81 OpReturn OpFunctionEnd )"; TEST(DiffTest, DifferentDecorationsFragment) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 82 +; Bound: 86 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %63 "main" %4 %22 OpExecutionMode %63 OriginUpperLeft OpSource GLSL 450 OpName %4 "_ue" OpName %8 "_uf" OpName %11 "_ug" OpName %12 "_uA" OpMemberName %12 0 "_ux" OpName %14 "_uc" OpName %15 "_uB" OpMemberName %15 0 "_ux" OpName %20 "_ud" OpName %22 "_ucol" OpName %26 "ANGLEDepthRangeParams" OpMemberName %26 0 "near" OpMemberName %26 1 "far" OpMemberName %26 2 "diff" OpMemberName %26 3 "reserved" OpName %27 "ANGLEUniformBlock" OpMemberName %27 0 "viewport" OpMemberName %27 1 "clipDistancesEnabled" OpMemberName %27 2 "xfbActiveUnpaused" OpMemberName %27 3 "xfbVerticesPerInstance" OpMemberName %27 4 "numSamples" OpMemberName %27 5 "xfbBufferOffsets" OpMemberName %27 6 "acbBufferOffsets" OpMemberName %27 7 "depthRange" OpName %29 "ANGLEUniforms" OpName %33 "_uc" OpName %32 "_uh" OpName %49 "_ux" OpName %50 "_uy" OpName %48 "_ui" OpName %63 "main" OpName %65 "param" OpName %68 "param" OpName %73 "param" -OpDecorate %4 Location 0 +OpDecorate %4 Location 1 OpDecorate %8 RelaxedPrecision -OpDecorate %8 DescriptorSet 0 +OpDecorate %8 DescriptorSet 2 OpDecorate %8 Binding 0 -OpDecorate %11 DescriptorSet 0 +OpDecorate %11 DescriptorSet 3 -OpDecorate %11 Binding 1 +OpDecorate %11 Binding 0 OpMemberDecorate %12 0 Offset 0 OpMemberDecorate %12 0 RelaxedPrecision OpDecorate %12 Block -OpDecorate %14 DescriptorSet 0 +OpDecorate %14 DescriptorSet 3 -OpDecorate %14 Binding 2 +OpDecorate %14 Binding 1 OpMemberDecorate %15 0 Offset 0 OpMemberDecorate %15 0 RelaxedPrecision OpDecorate %15 BufferBlock -OpDecorate %20 DescriptorSet 0 +OpDecorate %20 DescriptorSet 3 -OpDecorate %20 Binding 3 +OpDecorate %20 Binding 2 OpDecorate %22 RelaxedPrecision -OpDecorate %22 Location 0 +OpDecorate %22 Location 1 OpMemberDecorate %26 0 Offset 0 OpMemberDecorate %26 1 Offset 4 OpMemberDecorate %26 2 Offset 8 OpMemberDecorate %26 3 Offset 12 OpMemberDecorate %27 0 Offset 0 OpMemberDecorate %27 1 Offset 16 OpMemberDecorate %27 2 Offset 20 OpMemberDecorate %27 3 Offset 24 OpMemberDecorate %27 4 Offset 28 OpMemberDecorate %27 5 Offset 32 OpMemberDecorate %27 6 Offset 48 OpMemberDecorate %27 7 Offset 64 OpMemberDecorate %27 2 RelaxedPrecision OpMemberDecorate %27 4 RelaxedPrecision OpDecorate %27 Block OpDecorate %29 DescriptorSet 0 -OpDecorate %29 Binding 4 +OpDecorate %29 Binding 0 OpDecorate %32 RelaxedPrecision OpDecorate %33 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %38 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %41 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %43 RelaxedPrecision OpDecorate %48 RelaxedPrecision OpDecorate %49 RelaxedPrecision OpDecorate %50 RelaxedPrecision OpDecorate %52 RelaxedPrecision OpDecorate %53 RelaxedPrecision OpDecorate %54 RelaxedPrecision OpDecorate %55 RelaxedPrecision OpDecorate %56 RelaxedPrecision OpDecorate %57 RelaxedPrecision OpDecorate %58 RelaxedPrecision OpDecorate %59 RelaxedPrecision OpDecorate %60 RelaxedPrecision OpDecorate %67 RelaxedPrecision OpDecorate %68 RelaxedPrecision OpDecorate %72 RelaxedPrecision OpDecorate %73 RelaxedPrecision OpDecorate %75 RelaxedPrecision OpDecorate %76 RelaxedPrecision OpDecorate %77 RelaxedPrecision OpDecorate %80 RelaxedPrecision OpDecorate %81 RelaxedPrecision %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeImage %1 2D 0 0 0 1 Unknown %6 = OpTypeSampledImage %5 %9 = OpTypeImage %1 2D 0 0 0 2 Rgba8 %12 = OpTypeStruct %2 %15 = OpTypeStruct %2 %16 = OpTypeInt 32 0 %17 = OpConstant %16 2 %18 = OpTypeArray %15 %17 %23 = OpTypeInt 32 1 %24 = OpTypeVector %23 4 %25 = OpTypeVector %16 4 %26 = OpTypeStruct %1 %1 %1 %1 %27 = OpTypeStruct %2 %16 %16 %23 %23 %24 %25 %26 %35 = OpTypeVector %1 2 %40 = OpTypeVector %23 2 %61 = OpTypeVoid %69 = OpConstant %16 0 %78 = OpConstant %16 1 +%82 = OpTypePointer Private %2 %3 = OpTypePointer Input %2 %7 = OpTypePointer UniformConstant %6 %10 = OpTypePointer UniformConstant %9 %13 = OpTypePointer Uniform %12 %19 = OpTypePointer Uniform %18 +%83 = OpTypePointer Private %2 %21 = OpTypePointer Output %2 %28 = OpTypePointer Uniform %27 %30 = OpTypePointer Function %2 %70 = OpTypePointer Uniform %2 %31 = OpTypeFunction %2 %30 %47 = OpTypeFunction %2 %30 %30 %62 = OpTypeFunction %61 %4 = OpVariable %3 Input %8 = OpVariable %7 UniformConstant %11 = OpVariable %10 UniformConstant %14 = OpVariable %13 Uniform %20 = OpVariable %19 Uniform %22 = OpVariable %21 Output %29 = OpVariable %28 Uniform +%84 = OpConstant %23 0 +%85 = OpConstant %1 0.5 %32 = OpFunction %2 None %31 %33 = OpFunctionParameter %30 %34 = OpLabel %36 = OpLoad %6 %8 %37 = OpLoad %2 %33 %38 = OpVectorShuffle %35 %37 %37 0 1 %39 = OpImageSampleImplicitLod %2 %36 %38 %41 = OpLoad %2 %33 %42 = OpVectorShuffle %35 %41 %41 2 3 %43 = OpConvertFToS %40 %42 %44 = OpLoad %9 %11 %45 = OpImageRead %2 %44 %43 %46 = OpFAdd %2 %39 %45 OpReturnValue %46 OpFunctionEnd %48 = OpFunction %2 None %47 %49 = OpFunctionParameter %30 %50 = OpFunctionParameter %30 %51 = OpLabel %52 = OpLoad %2 %49 %53 = OpVectorShuffle %35 %52 %52 0 1 %54 = OpLoad %2 %50 %55 = OpVectorShuffle %35 %54 %54 2 3 %56 = OpCompositeExtract %1 %53 0 %57 = OpCompositeExtract %1 %53 1 %58 = OpCompositeExtract %1 %55 0 %59 = OpCompositeExtract %1 %55 1 %60 = OpCompositeConstruct %2 %56 %57 %58 %59 OpReturnValue %60 OpFunctionEnd %63 = OpFunction %61 None %62 %64 = OpLabel %65 = OpVariable %30 Function %68 = OpVariable %30 Function %73 = OpVariable %30 Function %66 = OpLoad %2 %4 OpStore %65 %66 %67 = OpFunctionCall %2 %32 %65 %71 = OpAccessChain %70 %14 %69 %72 = OpLoad %2 %71 OpStore %68 %72 %74 = OpAccessChain %70 %20 %69 %69 %75 = OpLoad %2 %74 OpStore %73 %75 %76 = OpFunctionCall %2 %48 %68 %73 %77 = OpFAdd %2 %67 %76 %79 = OpAccessChain %70 %20 %78 %69 %80 = OpLoad %2 %79 %81 = OpFAdd %2 %77 %80 OpStore %22 %81 OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrc, kDst, kDiff, options); } TEST(DiffTest, DifferentDecorationsFragmentNoDebug) { constexpr char kSrcNoDebug[] = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %63 "main" %4 %22 OpExecutionMode %63 OriginUpperLeft OpSource GLSL 450 OpDecorate %4 Location 0 OpDecorate %8 RelaxedPrecision OpDecorate %8 DescriptorSet 0 OpDecorate %8 Binding 0 OpDecorate %11 DescriptorSet 0 OpDecorate %11 Binding 1 OpMemberDecorate %12 0 Offset 0 OpMemberDecorate %12 0 RelaxedPrecision OpDecorate %12 Block OpDecorate %14 DescriptorSet 0 OpDecorate %14 Binding 2 OpMemberDecorate %15 0 Offset 0 OpMemberDecorate %15 0 RelaxedPrecision OpDecorate %15 BufferBlock OpDecorate %20 DescriptorSet 0 OpDecorate %20 Binding 3 OpDecorate %22 RelaxedPrecision OpDecorate %22 Location 0 OpMemberDecorate %26 0 Offset 0 OpMemberDecorate %26 1 Offset 4 OpMemberDecorate %26 2 Offset 8 OpMemberDecorate %26 3 Offset 12 OpMemberDecorate %27 0 Offset 0 OpMemberDecorate %27 1 Offset 16 OpMemberDecorate %27 2 Offset 20 OpMemberDecorate %27 3 Offset 24 OpMemberDecorate %27 4 Offset 28 OpMemberDecorate %27 5 Offset 32 OpMemberDecorate %27 6 Offset 48 OpMemberDecorate %27 7 Offset 64 OpMemberDecorate %27 2 RelaxedPrecision OpMemberDecorate %27 4 RelaxedPrecision OpDecorate %27 Block OpDecorate %29 DescriptorSet 0 OpDecorate %29 Binding 4 OpDecorate %32 RelaxedPrecision OpDecorate %33 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %38 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %41 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %43 RelaxedPrecision OpDecorate %48 RelaxedPrecision OpDecorate %49 RelaxedPrecision OpDecorate %50 RelaxedPrecision OpDecorate %52 RelaxedPrecision OpDecorate %53 RelaxedPrecision OpDecorate %54 RelaxedPrecision OpDecorate %55 RelaxedPrecision OpDecorate %56 RelaxedPrecision OpDecorate %57 RelaxedPrecision OpDecorate %58 RelaxedPrecision OpDecorate %59 RelaxedPrecision OpDecorate %60 RelaxedPrecision OpDecorate %67 RelaxedPrecision OpDecorate %68 RelaxedPrecision OpDecorate %72 RelaxedPrecision OpDecorate %73 RelaxedPrecision OpDecorate %75 RelaxedPrecision OpDecorate %76 RelaxedPrecision OpDecorate %77 RelaxedPrecision OpDecorate %80 RelaxedPrecision OpDecorate %81 RelaxedPrecision %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeImage %1 2D 0 0 0 1 Unknown %6 = OpTypeSampledImage %5 %9 = OpTypeImage %1 2D 0 0 0 2 Rgba8 %12 = OpTypeStruct %2 %15 = OpTypeStruct %2 %16 = OpTypeInt 32 0 %17 = OpConstant %16 2 %18 = OpTypeArray %15 %17 %23 = OpTypeInt 32 1 %24 = OpTypeVector %23 4 %25 = OpTypeVector %16 4 %26 = OpTypeStruct %1 %1 %1 %1 %27 = OpTypeStruct %2 %16 %16 %23 %23 %24 %25 %26 %35 = OpTypeVector %1 2 %40 = OpTypeVector %23 2 %61 = OpTypeVoid %69 = OpConstant %16 0 %78 = OpConstant %16 1 %3 = OpTypePointer Input %2 %7 = OpTypePointer UniformConstant %6 %10 = OpTypePointer UniformConstant %9 %13 = OpTypePointer Uniform %12 %19 = OpTypePointer Uniform %18 %21 = OpTypePointer Output %2 %28 = OpTypePointer Uniform %27 %30 = OpTypePointer Function %2 %70 = OpTypePointer Uniform %2 %31 = OpTypeFunction %2 %30 %47 = OpTypeFunction %2 %30 %30 %62 = OpTypeFunction %61 %4 = OpVariable %3 Input %8 = OpVariable %7 UniformConstant %11 = OpVariable %10 UniformConstant %14 = OpVariable %13 Uniform %20 = OpVariable %19 Uniform %22 = OpVariable %21 Output %29 = OpVariable %28 Uniform %32 = OpFunction %2 None %31 %33 = OpFunctionParameter %30 %34 = OpLabel %36 = OpLoad %6 %8 %37 = OpLoad %2 %33 %38 = OpVectorShuffle %35 %37 %37 0 1 %39 = OpImageSampleImplicitLod %2 %36 %38 %41 = OpLoad %2 %33 %42 = OpVectorShuffle %35 %41 %41 2 3 %43 = OpConvertFToS %40 %42 %44 = OpLoad %9 %11 %45 = OpImageRead %2 %44 %43 %46 = OpFAdd %2 %39 %45 OpReturnValue %46 OpFunctionEnd %48 = OpFunction %2 None %47 %49 = OpFunctionParameter %30 %50 = OpFunctionParameter %30 %51 = OpLabel %52 = OpLoad %2 %49 %53 = OpVectorShuffle %35 %52 %52 0 1 %54 = OpLoad %2 %50 %55 = OpVectorShuffle %35 %54 %54 2 3 %56 = OpCompositeExtract %1 %53 0 %57 = OpCompositeExtract %1 %53 1 %58 = OpCompositeExtract %1 %55 0 %59 = OpCompositeExtract %1 %55 1 %60 = OpCompositeConstruct %2 %56 %57 %58 %59 OpReturnValue %60 OpFunctionEnd %63 = OpFunction %61 None %62 %64 = OpLabel %65 = OpVariable %30 Function %68 = OpVariable %30 Function %73 = OpVariable %30 Function %66 = OpLoad %2 %4 OpStore %65 %66 %67 = OpFunctionCall %2 %32 %65 %71 = OpAccessChain %70 %14 %69 %72 = OpLoad %2 %71 OpStore %68 %72 %74 = OpAccessChain %70 %20 %69 %69 %75 = OpLoad %2 %74 OpStore %73 %75 %76 = OpFunctionCall %2 %48 %68 %73 %77 = OpFAdd %2 %67 %76 %79 = OpAccessChain %70 %20 %78 %69 %80 = OpLoad %2 %79 %81 = OpFAdd %2 %77 %80 OpStore %22 %81 OpReturn OpFunctionEnd )"; constexpr char kDstNoDebug[] = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %63 "main" %4 %22 OpExecutionMode %63 OriginUpperLeft OpSource GLSL 450 OpDecorate %4 Location 1 OpDecorate %8 RelaxedPrecision OpDecorate %8 DescriptorSet 2 OpDecorate %8 Binding 0 OpDecorate %11 DescriptorSet 3 OpDecorate %11 Binding 0 OpMemberDecorate %12 0 Offset 0 OpMemberDecorate %12 0 RelaxedPrecision OpDecorate %12 Block OpDecorate %14 DescriptorSet 3 OpDecorate %14 Binding 1 OpMemberDecorate %15 0 Offset 0 OpMemberDecorate %15 0 RelaxedPrecision OpDecorate %15 BufferBlock OpDecorate %20 DescriptorSet 3 OpDecorate %20 Binding 2 OpDecorate %22 RelaxedPrecision OpDecorate %22 Location 1 OpMemberDecorate %26 0 Offset 0 OpMemberDecorate %26 1 Offset 4 OpMemberDecorate %26 2 Offset 8 OpMemberDecorate %26 3 Offset 12 OpMemberDecorate %27 0 Offset 0 OpMemberDecorate %27 1 Offset 16 OpMemberDecorate %27 2 Offset 20 OpMemberDecorate %27 3 Offset 24 OpMemberDecorate %27 4 Offset 28 OpMemberDecorate %27 5 Offset 32 OpMemberDecorate %27 6 Offset 48 OpMemberDecorate %27 7 Offset 64 OpMemberDecorate %27 2 RelaxedPrecision OpMemberDecorate %27 4 RelaxedPrecision OpDecorate %27 Block OpDecorate %29 DescriptorSet 0 OpDecorate %29 Binding 0 OpDecorate %32 RelaxedPrecision OpDecorate %33 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %38 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %41 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %43 RelaxedPrecision OpDecorate %48 RelaxedPrecision OpDecorate %49 RelaxedPrecision OpDecorate %50 RelaxedPrecision OpDecorate %52 RelaxedPrecision OpDecorate %53 RelaxedPrecision OpDecorate %54 RelaxedPrecision OpDecorate %55 RelaxedPrecision OpDecorate %56 RelaxedPrecision OpDecorate %57 RelaxedPrecision OpDecorate %58 RelaxedPrecision OpDecorate %59 RelaxedPrecision OpDecorate %60 RelaxedPrecision OpDecorate %67 RelaxedPrecision OpDecorate %68 RelaxedPrecision OpDecorate %72 RelaxedPrecision OpDecorate %73 RelaxedPrecision OpDecorate %75 RelaxedPrecision OpDecorate %76 RelaxedPrecision OpDecorate %77 RelaxedPrecision OpDecorate %80 RelaxedPrecision OpDecorate %81 RelaxedPrecision %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeImage %1 2D 0 0 0 1 Unknown %6 = OpTypeSampledImage %5 %9 = OpTypeImage %1 2D 0 0 0 2 Rgba8 %12 = OpTypeStruct %2 %15 = OpTypeStruct %2 %16 = OpTypeInt 32 0 %17 = OpConstant %16 2 %18 = OpTypeArray %15 %17 %23 = OpTypeInt 32 1 %24 = OpTypeVector %23 4 %25 = OpTypeVector %16 4 %26 = OpTypeStruct %1 %1 %1 %1 %27 = OpTypeStruct %2 %16 %16 %23 %23 %24 %25 %26 %35 = OpTypeVector %1 2 %40 = OpTypeVector %23 2 %61 = OpTypeVoid %69 = OpConstant %16 0 %78 = OpConstant %16 1 %82 = OpTypePointer Private %2 %3 = OpTypePointer Input %2 %7 = OpTypePointer UniformConstant %6 %10 = OpTypePointer UniformConstant %9 %13 = OpTypePointer Uniform %12 %19 = OpTypePointer Uniform %18 %83 = OpTypePointer Private %2 %21 = OpTypePointer Output %2 %28 = OpTypePointer Uniform %27 %30 = OpTypePointer Function %2 %70 = OpTypePointer Uniform %2 %31 = OpTypeFunction %2 %30 %47 = OpTypeFunction %2 %30 %30 %62 = OpTypeFunction %61 %4 = OpVariable %3 Input %8 = OpVariable %7 UniformConstant %11 = OpVariable %10 UniformConstant %14 = OpVariable %13 Uniform %20 = OpVariable %19 Uniform %22 = OpVariable %21 Output %29 = OpVariable %28 Uniform %84 = OpConstant %23 0 %85 = OpConstant %1 0.5 %32 = OpFunction %2 None %31 %33 = OpFunctionParameter %30 %34 = OpLabel %36 = OpLoad %6 %8 %37 = OpLoad %2 %33 %38 = OpVectorShuffle %35 %37 %37 0 1 %39 = OpImageSampleImplicitLod %2 %36 %38 %41 = OpLoad %2 %33 %42 = OpVectorShuffle %35 %41 %41 2 3 %43 = OpConvertFToS %40 %42 %44 = OpLoad %9 %11 %45 = OpImageRead %2 %44 %43 %46 = OpFAdd %2 %39 %45 OpReturnValue %46 OpFunctionEnd %48 = OpFunction %2 None %47 %49 = OpFunctionParameter %30 %50 = OpFunctionParameter %30 %51 = OpLabel %52 = OpLoad %2 %49 %53 = OpVectorShuffle %35 %52 %52 0 1 %54 = OpLoad %2 %50 %55 = OpVectorShuffle %35 %54 %54 2 3 %56 = OpCompositeExtract %1 %53 0 %57 = OpCompositeExtract %1 %53 1 %58 = OpCompositeExtract %1 %55 0 %59 = OpCompositeExtract %1 %55 1 %60 = OpCompositeConstruct %2 %56 %57 %58 %59 OpReturnValue %60 OpFunctionEnd %63 = OpFunction %61 None %62 %64 = OpLabel %65 = OpVariable %30 Function %68 = OpVariable %30 Function %73 = OpVariable %30 Function %66 = OpLoad %2 %4 OpStore %65 %66 %67 = OpFunctionCall %2 %32 %65 %71 = OpAccessChain %70 %14 %69 %72 = OpLoad %2 %71 OpStore %68 %72 %74 = OpAccessChain %70 %20 %69 %69 %75 = OpLoad %2 %74 OpStore %73 %75 %76 = OpFunctionCall %2 %48 %68 %73 %77 = OpFAdd %2 %67 %76 %79 = OpAccessChain %70 %20 %78 %69 %80 = OpLoad %2 %79 %81 = OpFAdd %2 %77 %80 OpStore %22 %81 OpReturn OpFunctionEnd )"; constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 82 +; Bound: 89 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %63 "main" %4 %22 OpExecutionMode %63 OriginUpperLeft OpSource GLSL 450 -OpDecorate %4 Location 0 +OpDecorate %4 Location 1 OpDecorate %8 RelaxedPrecision -OpDecorate %8 DescriptorSet 0 +OpDecorate %8 DescriptorSet 2 OpDecorate %8 Binding 0 -OpDecorate %11 DescriptorSet 0 +OpDecorate %11 DescriptorSet 3 -OpDecorate %11 Binding 1 +OpDecorate %11 Binding 0 OpMemberDecorate %12 0 Offset 0 OpMemberDecorate %12 0 RelaxedPrecision OpDecorate %12 Block +OpDecorate %82 DescriptorSet 3 +OpDecorate %82 Binding 1 -OpDecorate %14 DescriptorSet 0 +OpDecorate %14 DescriptorSet 3 OpDecorate %14 Binding 2 OpMemberDecorate %15 0 Offset 0 OpMemberDecorate %15 0 RelaxedPrecision OpDecorate %15 BufferBlock -OpDecorate %20 DescriptorSet 0 -OpDecorate %20 Binding 3 OpDecorate %22 RelaxedPrecision -OpDecorate %22 Location 0 +OpDecorate %22 Location 1 OpMemberDecorate %26 0 Offset 0 OpMemberDecorate %26 1 Offset 4 OpMemberDecorate %26 2 Offset 8 OpMemberDecorate %26 3 Offset 12 OpMemberDecorate %27 0 Offset 0 OpMemberDecorate %27 1 Offset 16 OpMemberDecorate %27 2 Offset 20 OpMemberDecorate %27 3 Offset 24 OpMemberDecorate %27 4 Offset 28 OpMemberDecorate %27 5 Offset 32 OpMemberDecorate %27 6 Offset 48 OpMemberDecorate %27 7 Offset 64 OpMemberDecorate %27 2 RelaxedPrecision OpMemberDecorate %27 4 RelaxedPrecision OpDecorate %27 Block -OpDecorate %29 DescriptorSet 0 -OpDecorate %29 Binding 4 +OpDecorate %83 DescriptorSet 0 +OpDecorate %83 Binding 0 OpDecorate %32 RelaxedPrecision OpDecorate %33 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %38 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %41 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %43 RelaxedPrecision OpDecorate %48 RelaxedPrecision OpDecorate %49 RelaxedPrecision OpDecorate %50 RelaxedPrecision OpDecorate %52 RelaxedPrecision OpDecorate %53 RelaxedPrecision OpDecorate %54 RelaxedPrecision OpDecorate %55 RelaxedPrecision OpDecorate %56 RelaxedPrecision OpDecorate %57 RelaxedPrecision OpDecorate %58 RelaxedPrecision OpDecorate %59 RelaxedPrecision OpDecorate %60 RelaxedPrecision OpDecorate %67 RelaxedPrecision OpDecorate %68 RelaxedPrecision OpDecorate %72 RelaxedPrecision OpDecorate %73 RelaxedPrecision OpDecorate %75 RelaxedPrecision OpDecorate %76 RelaxedPrecision OpDecorate %77 RelaxedPrecision OpDecorate %80 RelaxedPrecision OpDecorate %81 RelaxedPrecision %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeImage %1 2D 0 0 0 1 Unknown %6 = OpTypeSampledImage %5 %9 = OpTypeImage %1 2D 0 0 0 2 Rgba8 %12 = OpTypeStruct %2 %15 = OpTypeStruct %2 %16 = OpTypeInt 32 0 %17 = OpConstant %16 2 %18 = OpTypeArray %15 %17 %23 = OpTypeInt 32 1 %24 = OpTypeVector %23 4 %25 = OpTypeVector %16 4 %26 = OpTypeStruct %1 %1 %1 %1 %27 = OpTypeStruct %2 %16 %16 %23 %23 %24 %25 %26 %35 = OpTypeVector %1 2 %40 = OpTypeVector %23 2 %61 = OpTypeVoid %69 = OpConstant %16 0 %78 = OpConstant %16 1 +%85 = OpTypePointer Private %2 %3 = OpTypePointer Input %2 %7 = OpTypePointer UniformConstant %6 %10 = OpTypePointer UniformConstant %9 %13 = OpTypePointer Uniform %12 %19 = OpTypePointer Uniform %18 +%86 = OpTypePointer Private %2 %21 = OpTypePointer Output %2 %28 = OpTypePointer Uniform %27 %30 = OpTypePointer Function %2 %70 = OpTypePointer Uniform %2 %31 = OpTypeFunction %2 %30 %47 = OpTypeFunction %2 %30 %30 %62 = OpTypeFunction %61 %4 = OpVariable %3 Input %8 = OpVariable %7 UniformConstant %11 = OpVariable %10 UniformConstant +%82 = OpVariable %13 Uniform -%14 = OpVariable %13 Uniform +%14 = OpVariable %19 Uniform -%20 = OpVariable %19 Uniform %22 = OpVariable %21 Output -%29 = OpVariable %28 Uniform +%83 = OpVariable %28 Uniform +%87 = OpConstant %23 0 +%88 = OpConstant %1 0.5 %32 = OpFunction %2 None %31 %33 = OpFunctionParameter %30 %34 = OpLabel %36 = OpLoad %6 %8 %37 = OpLoad %2 %33 %38 = OpVectorShuffle %35 %37 %37 0 1 %39 = OpImageSampleImplicitLod %2 %36 %38 %41 = OpLoad %2 %33 %42 = OpVectorShuffle %35 %41 %41 2 3 %43 = OpConvertFToS %40 %42 %44 = OpLoad %9 %11 %45 = OpImageRead %2 %44 %43 %46 = OpFAdd %2 %39 %45 OpReturnValue %46 OpFunctionEnd %48 = OpFunction %2 None %47 %49 = OpFunctionParameter %30 %50 = OpFunctionParameter %30 %51 = OpLabel %52 = OpLoad %2 %49 %53 = OpVectorShuffle %35 %52 %52 0 1 %54 = OpLoad %2 %50 %55 = OpVectorShuffle %35 %54 %54 2 3 %56 = OpCompositeExtract %1 %53 0 %57 = OpCompositeExtract %1 %53 1 %58 = OpCompositeExtract %1 %55 0 %59 = OpCompositeExtract %1 %55 1 %60 = OpCompositeConstruct %2 %56 %57 %58 %59 OpReturnValue %60 OpFunctionEnd %63 = OpFunction %61 None %62 %64 = OpLabel %65 = OpVariable %30 Function %68 = OpVariable %30 Function %73 = OpVariable %30 Function %66 = OpLoad %2 %4 OpStore %65 %66 %67 = OpFunctionCall %2 %32 %65 -%71 = OpAccessChain %70 %14 %69 +%84 = OpAccessChain %70 %82 %69 -%72 = OpLoad %2 %71 +%72 = OpLoad %2 %84 OpStore %68 %72 -%74 = OpAccessChain %70 %20 %69 %69 +%74 = OpAccessChain %70 %14 %69 %69 %75 = OpLoad %2 %74 OpStore %73 %75 %76 = OpFunctionCall %2 %48 %68 %73 %77 = OpFAdd %2 %67 %76 -%79 = OpAccessChain %70 %20 %78 %69 +%79 = OpAccessChain %70 %14 %78 %69 %80 = OpLoad %2 %79 %81 = OpFAdd %2 %77 %80 OpStore %22 %81 OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrcNoDebug, kDstNoDebug, kDiff, options); } TEST(DiffTest, DifferentDecorationsFragmentIgnoreLocation) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 82 +; Bound: 86 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %63 "main" %4 %22 OpExecutionMode %63 OriginUpperLeft OpSource GLSL 450 OpName %4 "_ue" OpName %8 "_uf" OpName %11 "_ug" OpName %12 "_uA" OpMemberName %12 0 "_ux" OpName %14 "_uc" OpName %15 "_uB" OpMemberName %15 0 "_ux" OpName %20 "_ud" OpName %22 "_ucol" OpName %26 "ANGLEDepthRangeParams" OpMemberName %26 0 "near" OpMemberName %26 1 "far" OpMemberName %26 2 "diff" OpMemberName %26 3 "reserved" OpName %27 "ANGLEUniformBlock" OpMemberName %27 0 "viewport" OpMemberName %27 1 "clipDistancesEnabled" OpMemberName %27 2 "xfbActiveUnpaused" OpMemberName %27 3 "xfbVerticesPerInstance" OpMemberName %27 4 "numSamples" OpMemberName %27 5 "xfbBufferOffsets" OpMemberName %27 6 "acbBufferOffsets" OpMemberName %27 7 "depthRange" OpName %29 "ANGLEUniforms" OpName %33 "_uc" OpName %32 "_uh" OpName %49 "_ux" OpName %50 "_uy" OpName %48 "_ui" OpName %63 "main" OpName %65 "param" OpName %68 "param" OpName %73 "param" -OpDecorate %4 Location 0 +OpDecorate %4 Location 1 OpDecorate %8 RelaxedPrecision -OpDecorate %8 DescriptorSet 0 +OpDecorate %8 DescriptorSet 2 OpDecorate %8 Binding 0 -OpDecorate %11 DescriptorSet 0 +OpDecorate %11 DescriptorSet 3 -OpDecorate %11 Binding 1 +OpDecorate %11 Binding 0 OpMemberDecorate %12 0 Offset 0 OpMemberDecorate %12 0 RelaxedPrecision OpDecorate %12 Block -OpDecorate %14 DescriptorSet 0 +OpDecorate %14 DescriptorSet 3 -OpDecorate %14 Binding 2 +OpDecorate %14 Binding 1 OpMemberDecorate %15 0 Offset 0 OpMemberDecorate %15 0 RelaxedPrecision OpDecorate %15 BufferBlock -OpDecorate %20 DescriptorSet 0 +OpDecorate %20 DescriptorSet 3 -OpDecorate %20 Binding 3 +OpDecorate %20 Binding 2 OpDecorate %22 RelaxedPrecision -OpDecorate %22 Location 0 +OpDecorate %22 Location 1 OpMemberDecorate %26 0 Offset 0 OpMemberDecorate %26 1 Offset 4 OpMemberDecorate %26 2 Offset 8 OpMemberDecorate %26 3 Offset 12 OpMemberDecorate %27 0 Offset 0 OpMemberDecorate %27 1 Offset 16 OpMemberDecorate %27 2 Offset 20 OpMemberDecorate %27 3 Offset 24 OpMemberDecorate %27 4 Offset 28 OpMemberDecorate %27 5 Offset 32 OpMemberDecorate %27 6 Offset 48 OpMemberDecorate %27 7 Offset 64 OpMemberDecorate %27 2 RelaxedPrecision OpMemberDecorate %27 4 RelaxedPrecision OpDecorate %27 Block OpDecorate %29 DescriptorSet 0 -OpDecorate %29 Binding 4 +OpDecorate %29 Binding 0 OpDecorate %32 RelaxedPrecision OpDecorate %33 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %38 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %41 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %43 RelaxedPrecision OpDecorate %48 RelaxedPrecision OpDecorate %49 RelaxedPrecision OpDecorate %50 RelaxedPrecision OpDecorate %52 RelaxedPrecision OpDecorate %53 RelaxedPrecision OpDecorate %54 RelaxedPrecision OpDecorate %55 RelaxedPrecision OpDecorate %56 RelaxedPrecision OpDecorate %57 RelaxedPrecision OpDecorate %58 RelaxedPrecision OpDecorate %59 RelaxedPrecision OpDecorate %60 RelaxedPrecision OpDecorate %67 RelaxedPrecision OpDecorate %68 RelaxedPrecision OpDecorate %72 RelaxedPrecision OpDecorate %73 RelaxedPrecision OpDecorate %75 RelaxedPrecision OpDecorate %76 RelaxedPrecision OpDecorate %77 RelaxedPrecision OpDecorate %80 RelaxedPrecision OpDecorate %81 RelaxedPrecision %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeImage %1 2D 0 0 0 1 Unknown %6 = OpTypeSampledImage %5 %9 = OpTypeImage %1 2D 0 0 0 2 Rgba8 %12 = OpTypeStruct %2 %15 = OpTypeStruct %2 %16 = OpTypeInt 32 0 %17 = OpConstant %16 2 %18 = OpTypeArray %15 %17 %23 = OpTypeInt 32 1 %24 = OpTypeVector %23 4 %25 = OpTypeVector %16 4 %26 = OpTypeStruct %1 %1 %1 %1 %27 = OpTypeStruct %2 %16 %16 %23 %23 %24 %25 %26 %35 = OpTypeVector %1 2 %40 = OpTypeVector %23 2 %61 = OpTypeVoid %69 = OpConstant %16 0 %78 = OpConstant %16 1 +%82 = OpTypePointer Private %2 %3 = OpTypePointer Input %2 %7 = OpTypePointer UniformConstant %6 %10 = OpTypePointer UniformConstant %9 %13 = OpTypePointer Uniform %12 %19 = OpTypePointer Uniform %18 +%83 = OpTypePointer Private %2 %21 = OpTypePointer Output %2 %28 = OpTypePointer Uniform %27 %30 = OpTypePointer Function %2 %70 = OpTypePointer Uniform %2 %31 = OpTypeFunction %2 %30 %47 = OpTypeFunction %2 %30 %30 %62 = OpTypeFunction %61 %4 = OpVariable %3 Input %8 = OpVariable %7 UniformConstant %11 = OpVariable %10 UniformConstant %14 = OpVariable %13 Uniform %20 = OpVariable %19 Uniform %22 = OpVariable %21 Output %29 = OpVariable %28 Uniform +%84 = OpConstant %23 0 +%85 = OpConstant %1 0.5 %32 = OpFunction %2 None %31 %33 = OpFunctionParameter %30 %34 = OpLabel %36 = OpLoad %6 %8 %37 = OpLoad %2 %33 %38 = OpVectorShuffle %35 %37 %37 0 1 %39 = OpImageSampleImplicitLod %2 %36 %38 %41 = OpLoad %2 %33 %42 = OpVectorShuffle %35 %41 %41 2 3 %43 = OpConvertFToS %40 %42 %44 = OpLoad %9 %11 %45 = OpImageRead %2 %44 %43 %46 = OpFAdd %2 %39 %45 OpReturnValue %46 OpFunctionEnd %48 = OpFunction %2 None %47 %49 = OpFunctionParameter %30 %50 = OpFunctionParameter %30 %51 = OpLabel %52 = OpLoad %2 %49 %53 = OpVectorShuffle %35 %52 %52 0 1 %54 = OpLoad %2 %50 %55 = OpVectorShuffle %35 %54 %54 2 3 %56 = OpCompositeExtract %1 %53 0 %57 = OpCompositeExtract %1 %53 1 %58 = OpCompositeExtract %1 %55 0 %59 = OpCompositeExtract %1 %55 1 %60 = OpCompositeConstruct %2 %56 %57 %58 %59 OpReturnValue %60 OpFunctionEnd %63 = OpFunction %61 None %62 %64 = OpLabel %65 = OpVariable %30 Function %68 = OpVariable %30 Function %73 = OpVariable %30 Function %66 = OpLoad %2 %4 OpStore %65 %66 %67 = OpFunctionCall %2 %32 %65 %71 = OpAccessChain %70 %14 %69 %72 = OpLoad %2 %71 OpStore %68 %72 %74 = OpAccessChain %70 %20 %69 %69 %75 = OpLoad %2 %74 OpStore %73 %75 %76 = OpFunctionCall %2 %48 %68 %73 %77 = OpFAdd %2 %67 %76 %79 = OpAccessChain %70 %20 %78 %69 %80 = OpLoad %2 %79 %81 = OpFAdd %2 %77 %80 OpStore %22 %81 OpReturn OpFunctionEnd )"; Options options; options.ignore_location = true; DoStringDiffTest(kSrc, kDst, kDiff, options); } TEST(DiffTest, DifferentDecorationsFragmentIgnoreSetBindingLocation) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 82 +; Bound: 86 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %63 "main" %4 %22 OpExecutionMode %63 OriginUpperLeft OpSource GLSL 450 OpName %4 "_ue" OpName %8 "_uf" OpName %11 "_ug" OpName %12 "_uA" OpMemberName %12 0 "_ux" OpName %14 "_uc" OpName %15 "_uB" OpMemberName %15 0 "_ux" OpName %20 "_ud" OpName %22 "_ucol" OpName %26 "ANGLEDepthRangeParams" OpMemberName %26 0 "near" OpMemberName %26 1 "far" OpMemberName %26 2 "diff" OpMemberName %26 3 "reserved" OpName %27 "ANGLEUniformBlock" OpMemberName %27 0 "viewport" OpMemberName %27 1 "clipDistancesEnabled" OpMemberName %27 2 "xfbActiveUnpaused" OpMemberName %27 3 "xfbVerticesPerInstance" OpMemberName %27 4 "numSamples" OpMemberName %27 5 "xfbBufferOffsets" OpMemberName %27 6 "acbBufferOffsets" OpMemberName %27 7 "depthRange" OpName %29 "ANGLEUniforms" OpName %33 "_uc" OpName %32 "_uh" OpName %49 "_ux" OpName %50 "_uy" OpName %48 "_ui" OpName %63 "main" OpName %65 "param" OpName %68 "param" OpName %73 "param" -OpDecorate %4 Location 0 +OpDecorate %4 Location 1 OpDecorate %8 RelaxedPrecision -OpDecorate %8 DescriptorSet 0 +OpDecorate %8 DescriptorSet 2 OpDecorate %8 Binding 0 -OpDecorate %11 DescriptorSet 0 +OpDecorate %11 DescriptorSet 3 -OpDecorate %11 Binding 1 +OpDecorate %11 Binding 0 OpMemberDecorate %12 0 Offset 0 OpMemberDecorate %12 0 RelaxedPrecision OpDecorate %12 Block -OpDecorate %14 DescriptorSet 0 +OpDecorate %14 DescriptorSet 3 -OpDecorate %14 Binding 2 +OpDecorate %14 Binding 1 OpMemberDecorate %15 0 Offset 0 OpMemberDecorate %15 0 RelaxedPrecision OpDecorate %15 BufferBlock -OpDecorate %20 DescriptorSet 0 +OpDecorate %20 DescriptorSet 3 -OpDecorate %20 Binding 3 +OpDecorate %20 Binding 2 OpDecorate %22 RelaxedPrecision -OpDecorate %22 Location 0 +OpDecorate %22 Location 1 OpMemberDecorate %26 0 Offset 0 OpMemberDecorate %26 1 Offset 4 OpMemberDecorate %26 2 Offset 8 OpMemberDecorate %26 3 Offset 12 OpMemberDecorate %27 0 Offset 0 OpMemberDecorate %27 1 Offset 16 OpMemberDecorate %27 2 Offset 20 OpMemberDecorate %27 3 Offset 24 OpMemberDecorate %27 4 Offset 28 OpMemberDecorate %27 5 Offset 32 OpMemberDecorate %27 6 Offset 48 OpMemberDecorate %27 7 Offset 64 OpMemberDecorate %27 2 RelaxedPrecision OpMemberDecorate %27 4 RelaxedPrecision OpDecorate %27 Block OpDecorate %29 DescriptorSet 0 -OpDecorate %29 Binding 4 +OpDecorate %29 Binding 0 OpDecorate %32 RelaxedPrecision OpDecorate %33 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %38 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %41 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %43 RelaxedPrecision OpDecorate %48 RelaxedPrecision OpDecorate %49 RelaxedPrecision OpDecorate %50 RelaxedPrecision OpDecorate %52 RelaxedPrecision OpDecorate %53 RelaxedPrecision OpDecorate %54 RelaxedPrecision OpDecorate %55 RelaxedPrecision OpDecorate %56 RelaxedPrecision OpDecorate %57 RelaxedPrecision OpDecorate %58 RelaxedPrecision OpDecorate %59 RelaxedPrecision OpDecorate %60 RelaxedPrecision OpDecorate %67 RelaxedPrecision OpDecorate %68 RelaxedPrecision OpDecorate %72 RelaxedPrecision OpDecorate %73 RelaxedPrecision OpDecorate %75 RelaxedPrecision OpDecorate %76 RelaxedPrecision OpDecorate %77 RelaxedPrecision OpDecorate %80 RelaxedPrecision OpDecorate %81 RelaxedPrecision %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeImage %1 2D 0 0 0 1 Unknown %6 = OpTypeSampledImage %5 %9 = OpTypeImage %1 2D 0 0 0 2 Rgba8 %12 = OpTypeStruct %2 %15 = OpTypeStruct %2 %16 = OpTypeInt 32 0 %17 = OpConstant %16 2 %18 = OpTypeArray %15 %17 %23 = OpTypeInt 32 1 %24 = OpTypeVector %23 4 %25 = OpTypeVector %16 4 %26 = OpTypeStruct %1 %1 %1 %1 %27 = OpTypeStruct %2 %16 %16 %23 %23 %24 %25 %26 %35 = OpTypeVector %1 2 %40 = OpTypeVector %23 2 %61 = OpTypeVoid %69 = OpConstant %16 0 %78 = OpConstant %16 1 +%82 = OpTypePointer Private %2 %3 = OpTypePointer Input %2 %7 = OpTypePointer UniformConstant %6 %10 = OpTypePointer UniformConstant %9 %13 = OpTypePointer Uniform %12 %19 = OpTypePointer Uniform %18 +%83 = OpTypePointer Private %2 %21 = OpTypePointer Output %2 %28 = OpTypePointer Uniform %27 %30 = OpTypePointer Function %2 %70 = OpTypePointer Uniform %2 %31 = OpTypeFunction %2 %30 %47 = OpTypeFunction %2 %30 %30 %62 = OpTypeFunction %61 %4 = OpVariable %3 Input %8 = OpVariable %7 UniformConstant %11 = OpVariable %10 UniformConstant %14 = OpVariable %13 Uniform %20 = OpVariable %19 Uniform %22 = OpVariable %21 Output %29 = OpVariable %28 Uniform +%84 = OpConstant %23 0 +%85 = OpConstant %1 0.5 %32 = OpFunction %2 None %31 %33 = OpFunctionParameter %30 %34 = OpLabel %36 = OpLoad %6 %8 %37 = OpLoad %2 %33 %38 = OpVectorShuffle %35 %37 %37 0 1 %39 = OpImageSampleImplicitLod %2 %36 %38 %41 = OpLoad %2 %33 %42 = OpVectorShuffle %35 %41 %41 2 3 %43 = OpConvertFToS %40 %42 %44 = OpLoad %9 %11 %45 = OpImageRead %2 %44 %43 %46 = OpFAdd %2 %39 %45 OpReturnValue %46 OpFunctionEnd %48 = OpFunction %2 None %47 %49 = OpFunctionParameter %30 %50 = OpFunctionParameter %30 %51 = OpLabel %52 = OpLoad %2 %49 %53 = OpVectorShuffle %35 %52 %52 0 1 %54 = OpLoad %2 %50 %55 = OpVectorShuffle %35 %54 %54 2 3 %56 = OpCompositeExtract %1 %53 0 %57 = OpCompositeExtract %1 %53 1 %58 = OpCompositeExtract %1 %55 0 %59 = OpCompositeExtract %1 %55 1 %60 = OpCompositeConstruct %2 %56 %57 %58 %59 OpReturnValue %60 OpFunctionEnd %63 = OpFunction %61 None %62 %64 = OpLabel %65 = OpVariable %30 Function %68 = OpVariable %30 Function %73 = OpVariable %30 Function %66 = OpLoad %2 %4 OpStore %65 %66 %67 = OpFunctionCall %2 %32 %65 %71 = OpAccessChain %70 %14 %69 %72 = OpLoad %2 %71 OpStore %68 %72 %74 = OpAccessChain %70 %20 %69 %69 %75 = OpLoad %2 %74 OpStore %73 %75 %76 = OpFunctionCall %2 %48 %68 %73 %77 = OpFAdd %2 %67 %76 %79 = OpAccessChain %70 %20 %78 %69 %80 = OpLoad %2 %79 %81 = OpFAdd %2 %77 %80 OpStore %22 %81 OpReturn OpFunctionEnd )"; Options options; options.ignore_set_binding = true; options.ignore_location = true; DoStringDiffTest(kSrc, kDst, kDiff, options); } } // namespace } // namespace diff } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/different_decorations_fragment_dst.spvasm000066400000000000000000000127161475742701700330510ustar00rootroot00000000000000OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %63 "main" %4 %22 OpExecutionMode %63 OriginUpperLeft OpSource GLSL 450 OpName %4 "_ue" OpName %8 "_uf" OpName %11 "_ug" OpName %12 "_uA" OpMemberName %12 0 "_ux" OpName %14 "_uc" OpName %15 "_uB" OpMemberName %15 0 "_ux" OpName %20 "_ud" OpName %22 "_ucol" OpName %26 "ANGLEDepthRangeParams" OpMemberName %26 0 "near" OpMemberName %26 1 "far" OpMemberName %26 2 "diff" OpMemberName %26 3 "reserved" OpName %27 "ANGLEUniformBlock" OpMemberName %27 0 "viewport" OpMemberName %27 1 "clipDistancesEnabled" OpMemberName %27 2 "xfbActiveUnpaused" OpMemberName %27 3 "xfbVerticesPerInstance" OpMemberName %27 4 "numSamples" OpMemberName %27 5 "xfbBufferOffsets" OpMemberName %27 6 "acbBufferOffsets" OpMemberName %27 7 "depthRange" OpName %29 "ANGLEUniforms" OpName %33 "_uc" OpName %32 "_uh" OpName %49 "_ux" OpName %50 "_uy" OpName %48 "_ui" OpName %63 "main" OpName %65 "param" OpName %68 "param" OpName %73 "param" OpDecorate %4 Location 1 OpDecorate %8 RelaxedPrecision OpDecorate %8 DescriptorSet 2 OpDecorate %8 Binding 0 OpDecorate %11 DescriptorSet 3 OpDecorate %11 Binding 0 OpMemberDecorate %12 0 Offset 0 OpMemberDecorate %12 0 RelaxedPrecision OpDecorate %12 Block OpDecorate %14 DescriptorSet 3 OpDecorate %14 Binding 1 OpMemberDecorate %15 0 Offset 0 OpMemberDecorate %15 0 RelaxedPrecision OpDecorate %15 BufferBlock OpDecorate %20 DescriptorSet 3 OpDecorate %20 Binding 2 OpDecorate %22 RelaxedPrecision OpDecorate %22 Location 1 OpMemberDecorate %26 0 Offset 0 OpMemberDecorate %26 1 Offset 4 OpMemberDecorate %26 2 Offset 8 OpMemberDecorate %26 3 Offset 12 OpMemberDecorate %27 0 Offset 0 OpMemberDecorate %27 1 Offset 16 OpMemberDecorate %27 2 Offset 20 OpMemberDecorate %27 3 Offset 24 OpMemberDecorate %27 4 Offset 28 OpMemberDecorate %27 5 Offset 32 OpMemberDecorate %27 6 Offset 48 OpMemberDecorate %27 7 Offset 64 OpMemberDecorate %27 2 RelaxedPrecision OpMemberDecorate %27 4 RelaxedPrecision OpDecorate %27 Block OpDecorate %29 DescriptorSet 0 OpDecorate %29 Binding 0 OpDecorate %32 RelaxedPrecision OpDecorate %33 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %38 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %41 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %43 RelaxedPrecision OpDecorate %48 RelaxedPrecision OpDecorate %49 RelaxedPrecision OpDecorate %50 RelaxedPrecision OpDecorate %52 RelaxedPrecision OpDecorate %53 RelaxedPrecision OpDecorate %54 RelaxedPrecision OpDecorate %55 RelaxedPrecision OpDecorate %56 RelaxedPrecision OpDecorate %57 RelaxedPrecision OpDecorate %58 RelaxedPrecision OpDecorate %59 RelaxedPrecision OpDecorate %60 RelaxedPrecision OpDecorate %67 RelaxedPrecision OpDecorate %68 RelaxedPrecision OpDecorate %72 RelaxedPrecision OpDecorate %73 RelaxedPrecision OpDecorate %75 RelaxedPrecision OpDecorate %76 RelaxedPrecision OpDecorate %77 RelaxedPrecision OpDecorate %80 RelaxedPrecision OpDecorate %81 RelaxedPrecision %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeImage %1 2D 0 0 0 1 Unknown %6 = OpTypeSampledImage %5 %9 = OpTypeImage %1 2D 0 0 0 2 Rgba8 %12 = OpTypeStruct %2 %15 = OpTypeStruct %2 %16 = OpTypeInt 32 0 %17 = OpConstant %16 2 %18 = OpTypeArray %15 %17 %23 = OpTypeInt 32 1 %24 = OpTypeVector %23 4 %25 = OpTypeVector %16 4 %26 = OpTypeStruct %1 %1 %1 %1 %27 = OpTypeStruct %2 %16 %16 %23 %23 %24 %25 %26 %35 = OpTypeVector %1 2 %40 = OpTypeVector %23 2 %61 = OpTypeVoid %69 = OpConstant %16 0 %78 = OpConstant %16 1 %82 = OpTypePointer Private %2 %3 = OpTypePointer Input %2 %7 = OpTypePointer UniformConstant %6 %10 = OpTypePointer UniformConstant %9 %13 = OpTypePointer Uniform %12 %19 = OpTypePointer Uniform %18 %83 = OpTypePointer Private %2 %21 = OpTypePointer Output %2 %28 = OpTypePointer Uniform %27 %30 = OpTypePointer Function %2 %70 = OpTypePointer Uniform %2 %31 = OpTypeFunction %2 %30 %47 = OpTypeFunction %2 %30 %30 %62 = OpTypeFunction %61 %4 = OpVariable %3 Input %8 = OpVariable %7 UniformConstant %11 = OpVariable %10 UniformConstant %14 = OpVariable %13 Uniform %20 = OpVariable %19 Uniform %22 = OpVariable %21 Output %29 = OpVariable %28 Uniform %84 = OpConstant %23 0 %85 = OpConstant %1 0.5 %32 = OpFunction %2 None %31 %33 = OpFunctionParameter %30 %34 = OpLabel %36 = OpLoad %6 %8 %37 = OpLoad %2 %33 %38 = OpVectorShuffle %35 %37 %37 0 1 %39 = OpImageSampleImplicitLod %2 %36 %38 %41 = OpLoad %2 %33 %42 = OpVectorShuffle %35 %41 %41 2 3 %43 = OpConvertFToS %40 %42 %44 = OpLoad %9 %11 %45 = OpImageRead %2 %44 %43 %46 = OpFAdd %2 %39 %45 OpReturnValue %46 OpFunctionEnd %48 = OpFunction %2 None %47 %49 = OpFunctionParameter %30 %50 = OpFunctionParameter %30 %51 = OpLabel %52 = OpLoad %2 %49 %53 = OpVectorShuffle %35 %52 %52 0 1 %54 = OpLoad %2 %50 %55 = OpVectorShuffle %35 %54 %54 2 3 %56 = OpCompositeExtract %1 %53 0 %57 = OpCompositeExtract %1 %53 1 %58 = OpCompositeExtract %1 %55 0 %59 = OpCompositeExtract %1 %55 1 %60 = OpCompositeConstruct %2 %56 %57 %58 %59 OpReturnValue %60 OpFunctionEnd %63 = OpFunction %61 None %62 %64 = OpLabel %65 = OpVariable %30 Function %68 = OpVariable %30 Function %73 = OpVariable %30 Function %66 = OpLoad %2 %4 OpStore %65 %66 %67 = OpFunctionCall %2 %32 %65 %71 = OpAccessChain %70 %14 %69 %72 = OpLoad %2 %71 OpStore %68 %72 %74 = OpAccessChain %70 %20 %69 %69 %75 = OpLoad %2 %74 OpStore %73 %75 %76 = OpFunctionCall %2 %48 %68 %73 %77 = OpFAdd %2 %67 %76 %79 = OpAccessChain %70 %20 %78 %69 %80 = OpLoad %2 %79 %81 = OpFAdd %2 %77 %80 OpStore %22 %81 OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/different_decorations_fragment_src.spvasm000066400000000000000000000127211475742701700330420ustar00rootroot00000000000000;; Test where variable set/binding/location decorations are different between ;; src and dst fragment shaders. OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %63 "main" %4 %22 OpExecutionMode %63 OriginUpperLeft OpSource GLSL 450 OpName %4 "_ue" OpName %8 "_uf" OpName %11 "_ug" OpName %12 "_uA" OpMemberName %12 0 "_ux" OpName %14 "_uc" OpName %15 "_uB" OpMemberName %15 0 "_ux" OpName %20 "_ud" OpName %22 "_ucol" OpName %26 "ANGLEDepthRangeParams" OpMemberName %26 0 "near" OpMemberName %26 1 "far" OpMemberName %26 2 "diff" OpMemberName %26 3 "reserved" OpName %27 "ANGLEUniformBlock" OpMemberName %27 0 "viewport" OpMemberName %27 1 "clipDistancesEnabled" OpMemberName %27 2 "xfbActiveUnpaused" OpMemberName %27 3 "xfbVerticesPerInstance" OpMemberName %27 4 "numSamples" OpMemberName %27 5 "xfbBufferOffsets" OpMemberName %27 6 "acbBufferOffsets" OpMemberName %27 7 "depthRange" OpName %29 "ANGLEUniforms" OpName %33 "_uc" OpName %32 "_uh" OpName %49 "_ux" OpName %50 "_uy" OpName %48 "_ui" OpName %63 "main" OpName %65 "param" OpName %68 "param" OpName %73 "param" OpDecorate %4 Location 0 OpDecorate %8 RelaxedPrecision OpDecorate %8 DescriptorSet 0 OpDecorate %8 Binding 0 OpDecorate %11 DescriptorSet 0 OpDecorate %11 Binding 1 OpMemberDecorate %12 0 Offset 0 OpMemberDecorate %12 0 RelaxedPrecision OpDecorate %12 Block OpDecorate %14 DescriptorSet 0 OpDecorate %14 Binding 2 OpMemberDecorate %15 0 Offset 0 OpMemberDecorate %15 0 RelaxedPrecision OpDecorate %15 BufferBlock OpDecorate %20 DescriptorSet 0 OpDecorate %20 Binding 3 OpDecorate %22 RelaxedPrecision OpDecorate %22 Location 0 OpMemberDecorate %26 0 Offset 0 OpMemberDecorate %26 1 Offset 4 OpMemberDecorate %26 2 Offset 8 OpMemberDecorate %26 3 Offset 12 OpMemberDecorate %27 0 Offset 0 OpMemberDecorate %27 1 Offset 16 OpMemberDecorate %27 2 Offset 20 OpMemberDecorate %27 3 Offset 24 OpMemberDecorate %27 4 Offset 28 OpMemberDecorate %27 5 Offset 32 OpMemberDecorate %27 6 Offset 48 OpMemberDecorate %27 7 Offset 64 OpMemberDecorate %27 2 RelaxedPrecision OpMemberDecorate %27 4 RelaxedPrecision OpDecorate %27 Block OpDecorate %29 DescriptorSet 0 OpDecorate %29 Binding 4 OpDecorate %32 RelaxedPrecision OpDecorate %33 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %38 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %41 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %43 RelaxedPrecision OpDecorate %48 RelaxedPrecision OpDecorate %49 RelaxedPrecision OpDecorate %50 RelaxedPrecision OpDecorate %52 RelaxedPrecision OpDecorate %53 RelaxedPrecision OpDecorate %54 RelaxedPrecision OpDecorate %55 RelaxedPrecision OpDecorate %56 RelaxedPrecision OpDecorate %57 RelaxedPrecision OpDecorate %58 RelaxedPrecision OpDecorate %59 RelaxedPrecision OpDecorate %60 RelaxedPrecision OpDecorate %67 RelaxedPrecision OpDecorate %68 RelaxedPrecision OpDecorate %72 RelaxedPrecision OpDecorate %73 RelaxedPrecision OpDecorate %75 RelaxedPrecision OpDecorate %76 RelaxedPrecision OpDecorate %77 RelaxedPrecision OpDecorate %80 RelaxedPrecision OpDecorate %81 RelaxedPrecision %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeImage %1 2D 0 0 0 1 Unknown %6 = OpTypeSampledImage %5 %9 = OpTypeImage %1 2D 0 0 0 2 Rgba8 %12 = OpTypeStruct %2 %15 = OpTypeStruct %2 %16 = OpTypeInt 32 0 %17 = OpConstant %16 2 %18 = OpTypeArray %15 %17 %23 = OpTypeInt 32 1 %24 = OpTypeVector %23 4 %25 = OpTypeVector %16 4 %26 = OpTypeStruct %1 %1 %1 %1 %27 = OpTypeStruct %2 %16 %16 %23 %23 %24 %25 %26 %35 = OpTypeVector %1 2 %40 = OpTypeVector %23 2 %61 = OpTypeVoid %69 = OpConstant %16 0 %78 = OpConstant %16 1 %3 = OpTypePointer Input %2 %7 = OpTypePointer UniformConstant %6 %10 = OpTypePointer UniformConstant %9 %13 = OpTypePointer Uniform %12 %19 = OpTypePointer Uniform %18 %21 = OpTypePointer Output %2 %28 = OpTypePointer Uniform %27 %30 = OpTypePointer Function %2 %70 = OpTypePointer Uniform %2 %31 = OpTypeFunction %2 %30 %47 = OpTypeFunction %2 %30 %30 %62 = OpTypeFunction %61 %4 = OpVariable %3 Input %8 = OpVariable %7 UniformConstant %11 = OpVariable %10 UniformConstant %14 = OpVariable %13 Uniform %20 = OpVariable %19 Uniform %22 = OpVariable %21 Output %29 = OpVariable %28 Uniform %32 = OpFunction %2 None %31 %33 = OpFunctionParameter %30 %34 = OpLabel %36 = OpLoad %6 %8 %37 = OpLoad %2 %33 %38 = OpVectorShuffle %35 %37 %37 0 1 %39 = OpImageSampleImplicitLod %2 %36 %38 %41 = OpLoad %2 %33 %42 = OpVectorShuffle %35 %41 %41 2 3 %43 = OpConvertFToS %40 %42 %44 = OpLoad %9 %11 %45 = OpImageRead %2 %44 %43 %46 = OpFAdd %2 %39 %45 OpReturnValue %46 OpFunctionEnd %48 = OpFunction %2 None %47 %49 = OpFunctionParameter %30 %50 = OpFunctionParameter %30 %51 = OpLabel %52 = OpLoad %2 %49 %53 = OpVectorShuffle %35 %52 %52 0 1 %54 = OpLoad %2 %50 %55 = OpVectorShuffle %35 %54 %54 2 3 %56 = OpCompositeExtract %1 %53 0 %57 = OpCompositeExtract %1 %53 1 %58 = OpCompositeExtract %1 %55 0 %59 = OpCompositeExtract %1 %55 1 %60 = OpCompositeConstruct %2 %56 %57 %58 %59 OpReturnValue %60 OpFunctionEnd %63 = OpFunction %61 None %62 %64 = OpLabel %65 = OpVariable %30 Function %68 = OpVariable %30 Function %73 = OpVariable %30 Function %66 = OpLoad %2 %4 OpStore %65 %66 %67 = OpFunctionCall %2 %32 %65 %71 = OpAccessChain %70 %14 %69 %72 = OpLoad %2 %71 OpStore %68 %72 %74 = OpAccessChain %70 %20 %69 %69 %75 = OpLoad %2 %74 OpStore %73 %75 %76 = OpFunctionCall %2 %48 %68 %73 %77 = OpFAdd %2 %67 %76 %79 = OpAccessChain %70 %20 %78 %69 %80 = OpLoad %2 %79 %81 = OpFAdd %2 %77 %80 OpStore %22 %81 OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/different_decorations_vertex_autogen.cpp000066400000000000000000001065601475742701700327050ustar00rootroot00000000000000// GENERATED FILE - DO NOT EDIT. // Generated by generate_tests.py // // Copyright (c) 2022 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "../diff_test_utils.h" #include "gtest/gtest.h" namespace spvtools { namespace diff { namespace { // Test where variable set/binding/location decorations are different between // src and dst vertex shaders. constexpr char kSrc[] = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %40 "main" %4 %5 %6 %8 %20 %25 OpSource GLSL 450 OpName %4 "_ub" OpName %5 "_uc" OpName %6 "_ud" OpName %8 "_ue" OpName %9 "defaultUniformsVS" OpMemberName %9 0 "_ua" OpName %11 "" OpName %16 "ANGLEDepthRangeParams" OpMemberName %16 0 "near" OpMemberName %16 1 "far" OpMemberName %16 2 "diff" OpMemberName %16 3 "reserved" OpName %17 "ANGLEUniformBlock" OpMemberName %17 0 "viewport" OpMemberName %17 1 "clipDistancesEnabled" OpMemberName %17 2 "xfbActiveUnpaused" OpMemberName %17 3 "xfbVerticesPerInstance" OpMemberName %17 4 "numSamples" OpMemberName %17 5 "xfbBufferOffsets" OpMemberName %17 6 "acbBufferOffsets" OpMemberName %17 7 "depthRange" OpName %19 "ANGLEUniforms" OpName %20 "ANGLEXfbPosition" OpName %23 "gl_PerVertex" OpMemberName %23 0 "gl_Position" OpMemberName %23 1 "gl_PointSize" OpMemberName %23 2 "gl_ClipDistance" OpMemberName %23 3 "gl_CullDistance" OpName %25 "" OpName %29 "_ua" OpName %28 "_uf" OpName %33 "_uf" OpName %32 "_ug" OpName %40 "main" OpName %42 "param" OpName %50 "param" OpName %53 "param" OpDecorate %4 Location 0 OpDecorate %5 Location 1 OpDecorate %6 Location 2 OpDecorate %8 Location 0 OpMemberDecorate %9 0 Offset 0 OpDecorate %9 Block OpDecorate %11 DescriptorSet 0 OpDecorate %11 Binding 0 OpMemberDecorate %16 0 Offset 0 OpMemberDecorate %16 1 Offset 4 OpMemberDecorate %16 2 Offset 8 OpMemberDecorate %16 3 Offset 12 OpMemberDecorate %17 0 Offset 0 OpMemberDecorate %17 1 Offset 16 OpMemberDecorate %17 2 Offset 20 OpMemberDecorate %17 3 Offset 24 OpMemberDecorate %17 4 Offset 28 OpMemberDecorate %17 5 Offset 32 OpMemberDecorate %17 6 Offset 48 OpMemberDecorate %17 7 Offset 64 OpMemberDecorate %17 2 RelaxedPrecision OpMemberDecorate %17 4 RelaxedPrecision OpDecorate %17 Block OpDecorate %19 DescriptorSet 0 OpDecorate %19 Binding 1 OpDecorate %20 Location 1 OpMemberDecorate %23 0 BuiltIn Position OpMemberDecorate %23 1 BuiltIn PointSize OpMemberDecorate %23 2 BuiltIn ClipDistance OpMemberDecorate %23 3 BuiltIn CullDistance OpDecorate %23 Block OpDecorate %28 RelaxedPrecision OpDecorate %29 RelaxedPrecision OpDecorate %31 RelaxedPrecision OpDecorate %32 RelaxedPrecision OpDecorate %33 RelaxedPrecision OpDecorate %35 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %44 RelaxedPrecision OpDecorate %52 RelaxedPrecision OpDecorate %55 RelaxedPrecision OpDecorate %56 RelaxedPrecision %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %9 = OpTypeStruct %2 %12 = OpTypeInt 32 0 %13 = OpTypeInt 32 1 %14 = OpTypeVector %13 4 %15 = OpTypeVector %12 4 %16 = OpTypeStruct %1 %1 %1 %1 %17 = OpTypeStruct %2 %12 %12 %13 %13 %14 %15 %16 %21 = OpConstant %12 8 %22 = OpTypeArray %1 %21 %23 = OpTypeStruct %2 %1 %22 %22 %38 = OpTypeVoid %45 = OpConstant %12 0 %3 = OpTypePointer Input %2 %7 = OpTypePointer Output %2 %10 = OpTypePointer Uniform %9 %18 = OpTypePointer Uniform %17 %24 = OpTypePointer Output %23 %26 = OpTypePointer Function %2 %46 = OpTypePointer Uniform %2 %27 = OpTypeFunction %2 %26 %39 = OpTypeFunction %38 %4 = OpVariable %3 Input %5 = OpVariable %3 Input %6 = OpVariable %3 Input %8 = OpVariable %7 Output %11 = OpVariable %10 Uniform %19 = OpVariable %18 Uniform %20 = OpVariable %7 Output %25 = OpVariable %24 Output %28 = OpFunction %2 None %27 %29 = OpFunctionParameter %26 %30 = OpLabel %31 = OpLoad %2 %29 OpReturnValue %31 OpFunctionEnd %32 = OpFunction %2 None %27 %33 = OpFunctionParameter %26 %34 = OpLabel %35 = OpLoad %2 %33 %36 = OpLoad %2 %33 %37 = OpFAdd %2 %35 %36 OpReturnValue %37 OpFunctionEnd %40 = OpFunction %38 None %39 %41 = OpLabel %42 = OpVariable %26 Function %50 = OpVariable %26 Function %53 = OpVariable %26 Function %43 = OpLoad %2 %4 OpStore %42 %43 %44 = OpFunctionCall %2 %28 %42 %47 = OpAccessChain %46 %11 %45 %48 = OpLoad %2 %47 %49 = OpFAdd %2 %44 %48 OpStore %8 %49 %51 = OpLoad %2 %5 OpStore %50 %51 %52 = OpFunctionCall %2 %32 %50 %54 = OpLoad %2 %6 OpStore %53 %54 %55 = OpFunctionCall %2 %28 %53 %56 = OpFAdd %2 %52 %55 %57 = OpAccessChain %7 %25 %45 OpStore %57 %56 OpReturn OpFunctionEnd )"; constexpr char kDst[] = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %40 "main" %4 %5 %6 %8 %25 OpSource GLSL 450 OpName %4 "_ub" OpName %5 "_uc" OpName %6 "_ud" OpName %8 "_ue" OpName %9 "defaultUniformsVS" OpMemberName %9 0 "_ua" OpName %11 "" OpName %16 "ANGLEDepthRangeParams" OpMemberName %16 0 "near" OpMemberName %16 1 "far" OpMemberName %16 2 "diff" OpMemberName %16 3 "reserved" OpName %17 "ANGLEUniformBlock" OpMemberName %17 0 "viewport" OpMemberName %17 1 "clipDistancesEnabled" OpMemberName %17 2 "xfbActiveUnpaused" OpMemberName %17 3 "xfbVerticesPerInstance" OpMemberName %17 4 "numSamples" OpMemberName %17 5 "xfbBufferOffsets" OpMemberName %17 6 "acbBufferOffsets" OpMemberName %17 7 "depthRange" OpName %19 "ANGLEUniforms" OpName %23 "gl_PerVertex" OpMemberName %23 0 "gl_Position" OpName %25 "" OpName %29 "_ua" OpName %28 "_uf" OpName %33 "_uf" OpName %32 "_ug" OpName %40 "main" OpName %42 "param" OpName %50 "param" OpName %53 "param" OpDecorate %4 Location 1 OpDecorate %5 Location 2 OpDecorate %6 Location 0 OpDecorate %8 Location 1 OpMemberDecorate %9 0 Offset 0 OpDecorate %9 Block OpDecorate %11 DescriptorSet 0 OpDecorate %11 Binding 1 OpMemberDecorate %16 0 Offset 0 OpMemberDecorate %16 1 Offset 4 OpMemberDecorate %16 2 Offset 8 OpMemberDecorate %16 3 Offset 12 OpMemberDecorate %17 0 Offset 0 OpMemberDecorate %17 1 Offset 16 OpMemberDecorate %17 2 Offset 20 OpMemberDecorate %17 3 Offset 24 OpMemberDecorate %17 4 Offset 28 OpMemberDecorate %17 5 Offset 32 OpMemberDecorate %17 6 Offset 48 OpMemberDecorate %17 7 Offset 64 OpMemberDecorate %17 2 RelaxedPrecision OpMemberDecorate %17 4 RelaxedPrecision OpDecorate %17 Block OpDecorate %19 DescriptorSet 2 OpDecorate %19 Binding 0 OpMemberDecorate %23 0 BuiltIn Position OpDecorate %23 Block OpDecorate %28 RelaxedPrecision OpDecorate %29 RelaxedPrecision OpDecorate %31 RelaxedPrecision OpDecorate %32 RelaxedPrecision OpDecorate %33 RelaxedPrecision OpDecorate %35 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %44 RelaxedPrecision OpDecorate %52 RelaxedPrecision OpDecorate %55 RelaxedPrecision OpDecorate %56 RelaxedPrecision %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %9 = OpTypeStruct %2 %12 = OpTypeInt 32 0 %13 = OpTypeInt 32 1 %14 = OpTypeVector %13 4 %15 = OpTypeVector %12 4 %16 = OpTypeStruct %1 %1 %1 %1 %17 = OpTypeStruct %2 %12 %12 %13 %13 %14 %15 %16 %21 = OpConstant %12 8 %22 = OpTypeArray %1 %21 %23 = OpTypeStruct %2 %38 = OpTypeVoid %45 = OpConstant %12 0 %58 = OpTypePointer Private %2 %3 = OpTypePointer Input %2 %59 = OpTypePointer Private %2 %7 = OpTypePointer Output %2 %10 = OpTypePointer Uniform %9 %18 = OpTypePointer Uniform %17 %24 = OpTypePointer Output %23 %26 = OpTypePointer Function %2 %46 = OpTypePointer Uniform %2 %27 = OpTypeFunction %2 %26 %39 = OpTypeFunction %38 %4 = OpVariable %3 Input %5 = OpVariable %3 Input %6 = OpVariable %3 Input %8 = OpVariable %7 Output %11 = OpVariable %10 Uniform %19 = OpVariable %18 Uniform %20 = OpVariable %59 Private %25 = OpVariable %24 Output %60 = OpConstant %13 0 %61 = OpConstant %1 0.5 %28 = OpFunction %2 None %27 %29 = OpFunctionParameter %26 %30 = OpLabel %31 = OpLoad %2 %29 OpReturnValue %31 OpFunctionEnd %32 = OpFunction %2 None %27 %33 = OpFunctionParameter %26 %34 = OpLabel %35 = OpLoad %2 %33 %36 = OpLoad %2 %33 %37 = OpFAdd %2 %35 %36 OpReturnValue %37 OpFunctionEnd %40 = OpFunction %38 None %39 %41 = OpLabel %42 = OpVariable %26 Function %50 = OpVariable %26 Function %53 = OpVariable %26 Function %43 = OpLoad %2 %4 OpStore %42 %43 %44 = OpFunctionCall %2 %28 %42 %47 = OpAccessChain %46 %11 %45 %48 = OpLoad %2 %47 %49 = OpFAdd %2 %44 %48 OpStore %8 %49 %51 = OpLoad %2 %5 OpStore %50 %51 %52 = OpFunctionCall %2 %32 %50 %54 = OpLoad %2 %6 OpStore %53 %54 %55 = OpFunctionCall %2 %28 %53 %56 = OpFAdd %2 %52 %55 %57 = OpAccessChain %7 %25 %45 OpStore %57 %56 %62 = OpAccessChain %7 %25 %60 %63 = OpLoad %2 %62 %64 = OpCompositeExtract %1 %63 0 %65 = OpCompositeExtract %1 %63 1 %66 = OpCompositeExtract %1 %63 2 %67 = OpCompositeExtract %1 %63 3 %69 = OpFNegate %1 %64 %70 = OpFAdd %1 %66 %67 %71 = OpFMul %1 %70 %61 %68 = OpCompositeConstruct %2 %65 %69 %71 %67 OpStore %62 %68 OpReturn OpFunctionEnd )"; TEST(DiffTest, DifferentDecorationsVertex) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 58 +; Bound: 73 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 -OpEntryPoint Vertex %40 "main" %4 %5 %6 %8 %20 %25 +OpEntryPoint Vertex %40 "main" %4 %5 %6 %8 %25 OpSource GLSL 450 OpName %4 "_ub" OpName %5 "_uc" OpName %6 "_ud" OpName %8 "_ue" OpName %9 "defaultUniformsVS" OpMemberName %9 0 "_ua" OpName %11 "" OpName %16 "ANGLEDepthRangeParams" OpMemberName %16 0 "near" OpMemberName %16 1 "far" OpMemberName %16 2 "diff" OpMemberName %16 3 "reserved" OpName %17 "ANGLEUniformBlock" OpMemberName %17 0 "viewport" OpMemberName %17 1 "clipDistancesEnabled" OpMemberName %17 2 "xfbActiveUnpaused" OpMemberName %17 3 "xfbVerticesPerInstance" OpMemberName %17 4 "numSamples" OpMemberName %17 5 "xfbBufferOffsets" OpMemberName %17 6 "acbBufferOffsets" OpMemberName %17 7 "depthRange" OpName %19 "ANGLEUniforms" -OpName %20 "ANGLEXfbPosition" OpName %23 "gl_PerVertex" OpMemberName %23 0 "gl_Position" -OpMemberName %23 1 "gl_PointSize" -OpMemberName %23 2 "gl_ClipDistance" -OpMemberName %23 3 "gl_CullDistance" OpName %25 "" OpName %29 "_ua" OpName %28 "_uf" OpName %33 "_uf" OpName %32 "_ug" OpName %40 "main" OpName %42 "param" OpName %50 "param" OpName %53 "param" -OpDecorate %4 Location 0 +OpDecorate %4 Location 1 -OpDecorate %5 Location 1 +OpDecorate %5 Location 2 -OpDecorate %6 Location 2 +OpDecorate %6 Location 0 -OpDecorate %8 Location 0 +OpDecorate %8 Location 1 OpMemberDecorate %9 0 Offset 0 OpDecorate %9 Block OpDecorate %11 DescriptorSet 0 -OpDecorate %11 Binding 0 +OpDecorate %11 Binding 1 OpMemberDecorate %16 0 Offset 0 OpMemberDecorate %16 1 Offset 4 OpMemberDecorate %16 2 Offset 8 OpMemberDecorate %16 3 Offset 12 OpMemberDecorate %17 0 Offset 0 OpMemberDecorate %17 1 Offset 16 OpMemberDecorate %17 2 Offset 20 OpMemberDecorate %17 3 Offset 24 OpMemberDecorate %17 4 Offset 28 OpMemberDecorate %17 5 Offset 32 OpMemberDecorate %17 6 Offset 48 OpMemberDecorate %17 7 Offset 64 OpMemberDecorate %17 2 RelaxedPrecision OpMemberDecorate %17 4 RelaxedPrecision OpDecorate %17 Block -OpDecorate %19 DescriptorSet 0 +OpDecorate %19 DescriptorSet 2 -OpDecorate %19 Binding 1 +OpDecorate %19 Binding 0 -OpDecorate %20 Location 1 OpMemberDecorate %23 0 BuiltIn Position -OpMemberDecorate %23 1 BuiltIn PointSize -OpMemberDecorate %23 2 BuiltIn ClipDistance -OpMemberDecorate %23 3 BuiltIn CullDistance OpDecorate %23 Block OpDecorate %28 RelaxedPrecision OpDecorate %29 RelaxedPrecision OpDecorate %31 RelaxedPrecision OpDecorate %32 RelaxedPrecision OpDecorate %33 RelaxedPrecision OpDecorate %35 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %44 RelaxedPrecision OpDecorate %52 RelaxedPrecision OpDecorate %55 RelaxedPrecision OpDecorate %56 RelaxedPrecision %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %9 = OpTypeStruct %2 %12 = OpTypeInt 32 0 %13 = OpTypeInt 32 1 %14 = OpTypeVector %13 4 %15 = OpTypeVector %12 4 %16 = OpTypeStruct %1 %1 %1 %1 %17 = OpTypeStruct %2 %12 %12 %13 %13 %14 %15 %16 %21 = OpConstant %12 8 %22 = OpTypeArray %1 %21 -%23 = OpTypeStruct %2 %1 %22 %22 +%23 = OpTypeStruct %2 %38 = OpTypeVoid %45 = OpConstant %12 0 +%59 = OpTypePointer Private %2 %3 = OpTypePointer Input %2 +%60 = OpTypePointer Private %2 %7 = OpTypePointer Output %2 %10 = OpTypePointer Uniform %9 %18 = OpTypePointer Uniform %17 %24 = OpTypePointer Output %23 %26 = OpTypePointer Function %2 %46 = OpTypePointer Uniform %2 %27 = OpTypeFunction %2 %26 %39 = OpTypeFunction %38 %4 = OpVariable %3 Input %5 = OpVariable %3 Input %6 = OpVariable %3 Input %8 = OpVariable %7 Output %11 = OpVariable %10 Uniform %19 = OpVariable %18 Uniform -%20 = OpVariable %7 Output +%58 = OpVariable %60 Private %25 = OpVariable %24 Output +%61 = OpConstant %13 0 +%62 = OpConstant %1 0.5 %28 = OpFunction %2 None %27 %29 = OpFunctionParameter %26 %30 = OpLabel %31 = OpLoad %2 %29 OpReturnValue %31 OpFunctionEnd %32 = OpFunction %2 None %27 %33 = OpFunctionParameter %26 %34 = OpLabel %35 = OpLoad %2 %33 %36 = OpLoad %2 %33 %37 = OpFAdd %2 %35 %36 OpReturnValue %37 OpFunctionEnd %40 = OpFunction %38 None %39 %41 = OpLabel %42 = OpVariable %26 Function %50 = OpVariable %26 Function %53 = OpVariable %26 Function %43 = OpLoad %2 %4 OpStore %42 %43 %44 = OpFunctionCall %2 %28 %42 %47 = OpAccessChain %46 %11 %45 %48 = OpLoad %2 %47 %49 = OpFAdd %2 %44 %48 OpStore %8 %49 %51 = OpLoad %2 %5 OpStore %50 %51 %52 = OpFunctionCall %2 %32 %50 %54 = OpLoad %2 %6 OpStore %53 %54 %55 = OpFunctionCall %2 %28 %53 %56 = OpFAdd %2 %52 %55 %57 = OpAccessChain %7 %25 %45 OpStore %57 %56 +%63 = OpAccessChain %7 %25 %61 +%64 = OpLoad %2 %63 +%65 = OpCompositeExtract %1 %64 0 +%66 = OpCompositeExtract %1 %64 1 +%67 = OpCompositeExtract %1 %64 2 +%68 = OpCompositeExtract %1 %64 3 +%70 = OpFNegate %1 %65 +%71 = OpFAdd %1 %67 %68 +%72 = OpFMul %1 %71 %62 +%69 = OpCompositeConstruct %2 %66 %70 %72 %68 +OpStore %63 %69 OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrc, kDst, kDiff, options); } TEST(DiffTest, DifferentDecorationsVertexNoDebug) { constexpr char kSrcNoDebug[] = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %40 "main" %4 %5 %6 %8 %20 %25 OpSource GLSL 450 OpDecorate %4 Location 0 OpDecorate %5 Location 1 OpDecorate %6 Location 2 OpDecorate %8 Location 0 OpMemberDecorate %9 0 Offset 0 OpDecorate %9 Block OpDecorate %11 DescriptorSet 0 OpDecorate %11 Binding 0 OpMemberDecorate %16 0 Offset 0 OpMemberDecorate %16 1 Offset 4 OpMemberDecorate %16 2 Offset 8 OpMemberDecorate %16 3 Offset 12 OpMemberDecorate %17 0 Offset 0 OpMemberDecorate %17 1 Offset 16 OpMemberDecorate %17 2 Offset 20 OpMemberDecorate %17 3 Offset 24 OpMemberDecorate %17 4 Offset 28 OpMemberDecorate %17 5 Offset 32 OpMemberDecorate %17 6 Offset 48 OpMemberDecorate %17 7 Offset 64 OpMemberDecorate %17 2 RelaxedPrecision OpMemberDecorate %17 4 RelaxedPrecision OpDecorate %17 Block OpDecorate %19 DescriptorSet 0 OpDecorate %19 Binding 1 OpDecorate %20 Location 1 OpMemberDecorate %23 0 BuiltIn Position OpMemberDecorate %23 1 BuiltIn PointSize OpMemberDecorate %23 2 BuiltIn ClipDistance OpMemberDecorate %23 3 BuiltIn CullDistance OpDecorate %23 Block OpDecorate %28 RelaxedPrecision OpDecorate %29 RelaxedPrecision OpDecorate %31 RelaxedPrecision OpDecorate %32 RelaxedPrecision OpDecorate %33 RelaxedPrecision OpDecorate %35 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %44 RelaxedPrecision OpDecorate %52 RelaxedPrecision OpDecorate %55 RelaxedPrecision OpDecorate %56 RelaxedPrecision %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %9 = OpTypeStruct %2 %12 = OpTypeInt 32 0 %13 = OpTypeInt 32 1 %14 = OpTypeVector %13 4 %15 = OpTypeVector %12 4 %16 = OpTypeStruct %1 %1 %1 %1 %17 = OpTypeStruct %2 %12 %12 %13 %13 %14 %15 %16 %21 = OpConstant %12 8 %22 = OpTypeArray %1 %21 %23 = OpTypeStruct %2 %1 %22 %22 %38 = OpTypeVoid %45 = OpConstant %12 0 %3 = OpTypePointer Input %2 %7 = OpTypePointer Output %2 %10 = OpTypePointer Uniform %9 %18 = OpTypePointer Uniform %17 %24 = OpTypePointer Output %23 %26 = OpTypePointer Function %2 %46 = OpTypePointer Uniform %2 %27 = OpTypeFunction %2 %26 %39 = OpTypeFunction %38 %4 = OpVariable %3 Input %5 = OpVariable %3 Input %6 = OpVariable %3 Input %8 = OpVariable %7 Output %11 = OpVariable %10 Uniform %19 = OpVariable %18 Uniform %20 = OpVariable %7 Output %25 = OpVariable %24 Output %28 = OpFunction %2 None %27 %29 = OpFunctionParameter %26 %30 = OpLabel %31 = OpLoad %2 %29 OpReturnValue %31 OpFunctionEnd %32 = OpFunction %2 None %27 %33 = OpFunctionParameter %26 %34 = OpLabel %35 = OpLoad %2 %33 %36 = OpLoad %2 %33 %37 = OpFAdd %2 %35 %36 OpReturnValue %37 OpFunctionEnd %40 = OpFunction %38 None %39 %41 = OpLabel %42 = OpVariable %26 Function %50 = OpVariable %26 Function %53 = OpVariable %26 Function %43 = OpLoad %2 %4 OpStore %42 %43 %44 = OpFunctionCall %2 %28 %42 %47 = OpAccessChain %46 %11 %45 %48 = OpLoad %2 %47 %49 = OpFAdd %2 %44 %48 OpStore %8 %49 %51 = OpLoad %2 %5 OpStore %50 %51 %52 = OpFunctionCall %2 %32 %50 %54 = OpLoad %2 %6 OpStore %53 %54 %55 = OpFunctionCall %2 %28 %53 %56 = OpFAdd %2 %52 %55 %57 = OpAccessChain %7 %25 %45 OpStore %57 %56 OpReturn OpFunctionEnd )"; constexpr char kDstNoDebug[] = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %40 "main" %4 %5 %6 %8 %25 OpSource GLSL 450 OpDecorate %4 Location 1 OpDecorate %5 Location 2 OpDecorate %6 Location 0 OpDecorate %8 Location 1 OpMemberDecorate %9 0 Offset 0 OpDecorate %9 Block OpDecorate %11 DescriptorSet 0 OpDecorate %11 Binding 1 OpMemberDecorate %16 0 Offset 0 OpMemberDecorate %16 1 Offset 4 OpMemberDecorate %16 2 Offset 8 OpMemberDecorate %16 3 Offset 12 OpMemberDecorate %17 0 Offset 0 OpMemberDecorate %17 1 Offset 16 OpMemberDecorate %17 2 Offset 20 OpMemberDecorate %17 3 Offset 24 OpMemberDecorate %17 4 Offset 28 OpMemberDecorate %17 5 Offset 32 OpMemberDecorate %17 6 Offset 48 OpMemberDecorate %17 7 Offset 64 OpMemberDecorate %17 2 RelaxedPrecision OpMemberDecorate %17 4 RelaxedPrecision OpDecorate %17 Block OpDecorate %19 DescriptorSet 2 OpDecorate %19 Binding 0 OpMemberDecorate %23 0 BuiltIn Position OpDecorate %23 Block OpDecorate %28 RelaxedPrecision OpDecorate %29 RelaxedPrecision OpDecorate %31 RelaxedPrecision OpDecorate %32 RelaxedPrecision OpDecorate %33 RelaxedPrecision OpDecorate %35 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %44 RelaxedPrecision OpDecorate %52 RelaxedPrecision OpDecorate %55 RelaxedPrecision OpDecorate %56 RelaxedPrecision %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %9 = OpTypeStruct %2 %12 = OpTypeInt 32 0 %13 = OpTypeInt 32 1 %14 = OpTypeVector %13 4 %15 = OpTypeVector %12 4 %16 = OpTypeStruct %1 %1 %1 %1 %17 = OpTypeStruct %2 %12 %12 %13 %13 %14 %15 %16 %21 = OpConstant %12 8 %22 = OpTypeArray %1 %21 %23 = OpTypeStruct %2 %38 = OpTypeVoid %45 = OpConstant %12 0 %58 = OpTypePointer Private %2 %3 = OpTypePointer Input %2 %59 = OpTypePointer Private %2 %7 = OpTypePointer Output %2 %10 = OpTypePointer Uniform %9 %18 = OpTypePointer Uniform %17 %24 = OpTypePointer Output %23 %26 = OpTypePointer Function %2 %46 = OpTypePointer Uniform %2 %27 = OpTypeFunction %2 %26 %39 = OpTypeFunction %38 %4 = OpVariable %3 Input %5 = OpVariable %3 Input %6 = OpVariable %3 Input %8 = OpVariable %7 Output %11 = OpVariable %10 Uniform %19 = OpVariable %18 Uniform %20 = OpVariable %59 Private %25 = OpVariable %24 Output %60 = OpConstant %13 0 %61 = OpConstant %1 0.5 %28 = OpFunction %2 None %27 %29 = OpFunctionParameter %26 %30 = OpLabel %31 = OpLoad %2 %29 OpReturnValue %31 OpFunctionEnd %32 = OpFunction %2 None %27 %33 = OpFunctionParameter %26 %34 = OpLabel %35 = OpLoad %2 %33 %36 = OpLoad %2 %33 %37 = OpFAdd %2 %35 %36 OpReturnValue %37 OpFunctionEnd %40 = OpFunction %38 None %39 %41 = OpLabel %42 = OpVariable %26 Function %50 = OpVariable %26 Function %53 = OpVariable %26 Function %43 = OpLoad %2 %4 OpStore %42 %43 %44 = OpFunctionCall %2 %28 %42 %47 = OpAccessChain %46 %11 %45 %48 = OpLoad %2 %47 %49 = OpFAdd %2 %44 %48 OpStore %8 %49 %51 = OpLoad %2 %5 OpStore %50 %51 %52 = OpFunctionCall %2 %32 %50 %54 = OpLoad %2 %6 OpStore %53 %54 %55 = OpFunctionCall %2 %28 %53 %56 = OpFAdd %2 %52 %55 %57 = OpAccessChain %7 %25 %45 OpStore %57 %56 %62 = OpAccessChain %7 %25 %60 %63 = OpLoad %2 %62 %64 = OpCompositeExtract %1 %63 0 %65 = OpCompositeExtract %1 %63 1 %66 = OpCompositeExtract %1 %63 2 %67 = OpCompositeExtract %1 %63 3 %69 = OpFNegate %1 %64 %70 = OpFAdd %1 %66 %67 %71 = OpFMul %1 %70 %61 %68 = OpCompositeConstruct %2 %65 %69 %71 %67 OpStore %62 %68 OpReturn OpFunctionEnd )"; constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 58 +; Bound: 77 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 -OpEntryPoint Vertex %40 "main" %4 %5 %6 %8 %20 %25 +OpEntryPoint Vertex %40 "main" %5 %6 %4 %20 %25 OpSource GLSL 450 OpDecorate %4 Location 0 OpDecorate %5 Location 1 OpDecorate %6 Location 2 -OpDecorate %8 Location 0 OpMemberDecorate %9 0 Offset 0 OpDecorate %9 Block -OpDecorate %11 DescriptorSet 0 +OpDecorate %11 DescriptorSet 2 OpDecorate %11 Binding 0 OpMemberDecorate %16 0 Offset 0 OpMemberDecorate %16 1 Offset 4 OpMemberDecorate %16 2 Offset 8 OpMemberDecorate %16 3 Offset 12 OpMemberDecorate %17 0 Offset 0 OpMemberDecorate %17 1 Offset 16 OpMemberDecorate %17 2 Offset 20 OpMemberDecorate %17 3 Offset 24 OpMemberDecorate %17 4 Offset 28 OpMemberDecorate %17 5 Offset 32 OpMemberDecorate %17 6 Offset 48 OpMemberDecorate %17 7 Offset 64 OpMemberDecorate %17 2 RelaxedPrecision OpMemberDecorate %17 4 RelaxedPrecision OpDecorate %17 Block OpDecorate %19 DescriptorSet 0 OpDecorate %19 Binding 1 OpDecorate %20 Location 1 OpMemberDecorate %23 0 BuiltIn Position -OpMemberDecorate %23 1 BuiltIn PointSize -OpMemberDecorate %23 2 BuiltIn ClipDistance -OpMemberDecorate %23 3 BuiltIn CullDistance OpDecorate %23 Block OpDecorate %28 RelaxedPrecision OpDecorate %29 RelaxedPrecision OpDecorate %31 RelaxedPrecision OpDecorate %32 RelaxedPrecision OpDecorate %33 RelaxedPrecision OpDecorate %35 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %44 RelaxedPrecision OpDecorate %52 RelaxedPrecision OpDecorate %55 RelaxedPrecision OpDecorate %56 RelaxedPrecision %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %9 = OpTypeStruct %2 %12 = OpTypeInt 32 0 %13 = OpTypeInt 32 1 %14 = OpTypeVector %13 4 %15 = OpTypeVector %12 4 %16 = OpTypeStruct %1 %1 %1 %1 %17 = OpTypeStruct %2 %12 %12 %13 %13 %14 %15 %16 %21 = OpConstant %12 8 %22 = OpTypeArray %1 %21 -%23 = OpTypeStruct %2 %1 %22 %22 +%23 = OpTypeStruct %2 %38 = OpTypeVoid %45 = OpConstant %12 0 +%63 = OpTypePointer Private %2 %3 = OpTypePointer Input %2 +%64 = OpTypePointer Private %2 %7 = OpTypePointer Output %2 %10 = OpTypePointer Uniform %9 %18 = OpTypePointer Uniform %17 %24 = OpTypePointer Output %23 %26 = OpTypePointer Function %2 %46 = OpTypePointer Uniform %2 %27 = OpTypeFunction %2 %26 %39 = OpTypeFunction %38 %4 = OpVariable %3 Input %5 = OpVariable %3 Input %6 = OpVariable %3 Input -%8 = OpVariable %7 Output -%11 = OpVariable %10 Uniform +%11 = OpVariable %18 Uniform -%19 = OpVariable %18 Uniform +%19 = OpVariable %10 Uniform %20 = OpVariable %7 Output +%58 = OpVariable %64 Private %25 = OpVariable %24 Output +%65 = OpConstant %13 0 +%66 = OpConstant %1 0.5 %28 = OpFunction %2 None %27 %29 = OpFunctionParameter %26 %30 = OpLabel %31 = OpLoad %2 %29 OpReturnValue %31 OpFunctionEnd %32 = OpFunction %2 None %27 %33 = OpFunctionParameter %26 %34 = OpLabel %35 = OpLoad %2 %33 %36 = OpLoad %2 %33 %37 = OpFAdd %2 %35 %36 OpReturnValue %37 OpFunctionEnd %40 = OpFunction %38 None %39 %41 = OpLabel %42 = OpVariable %26 Function %50 = OpVariable %26 Function %53 = OpVariable %26 Function -%43 = OpLoad %2 %4 +%59 = OpLoad %2 %5 -OpStore %42 %43 +OpStore %42 %59 %44 = OpFunctionCall %2 %28 %42 -%47 = OpAccessChain %46 %11 %45 +%60 = OpAccessChain %46 %19 %45 -%48 = OpLoad %2 %47 +%48 = OpLoad %2 %60 %49 = OpFAdd %2 %44 %48 -OpStore %8 %49 +OpStore %20 %49 -%51 = OpLoad %2 %5 +%61 = OpLoad %2 %6 -OpStore %50 %51 +OpStore %50 %61 %52 = OpFunctionCall %2 %32 %50 -%54 = OpLoad %2 %6 +%62 = OpLoad %2 %4 -OpStore %53 %54 +OpStore %53 %62 %55 = OpFunctionCall %2 %28 %53 %56 = OpFAdd %2 %52 %55 %57 = OpAccessChain %7 %25 %45 OpStore %57 %56 +%67 = OpAccessChain %7 %25 %65 +%68 = OpLoad %2 %67 +%69 = OpCompositeExtract %1 %68 0 +%70 = OpCompositeExtract %1 %68 1 +%71 = OpCompositeExtract %1 %68 2 +%72 = OpCompositeExtract %1 %68 3 +%74 = OpFNegate %1 %69 +%75 = OpFAdd %1 %71 %72 +%76 = OpFMul %1 %75 %66 +%73 = OpCompositeConstruct %2 %70 %74 %76 %72 +OpStore %67 %73 OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrcNoDebug, kDstNoDebug, kDiff, options); } TEST(DiffTest, DifferentDecorationsVertexIgnoreSetBinding) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 58 +; Bound: 73 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 -OpEntryPoint Vertex %40 "main" %4 %5 %6 %8 %20 %25 +OpEntryPoint Vertex %40 "main" %4 %5 %6 %8 %25 OpSource GLSL 450 OpName %4 "_ub" OpName %5 "_uc" OpName %6 "_ud" OpName %8 "_ue" OpName %9 "defaultUniformsVS" OpMemberName %9 0 "_ua" OpName %11 "" OpName %16 "ANGLEDepthRangeParams" OpMemberName %16 0 "near" OpMemberName %16 1 "far" OpMemberName %16 2 "diff" OpMemberName %16 3 "reserved" OpName %17 "ANGLEUniformBlock" OpMemberName %17 0 "viewport" OpMemberName %17 1 "clipDistancesEnabled" OpMemberName %17 2 "xfbActiveUnpaused" OpMemberName %17 3 "xfbVerticesPerInstance" OpMemberName %17 4 "numSamples" OpMemberName %17 5 "xfbBufferOffsets" OpMemberName %17 6 "acbBufferOffsets" OpMemberName %17 7 "depthRange" OpName %19 "ANGLEUniforms" -OpName %20 "ANGLEXfbPosition" OpName %23 "gl_PerVertex" OpMemberName %23 0 "gl_Position" -OpMemberName %23 1 "gl_PointSize" -OpMemberName %23 2 "gl_ClipDistance" -OpMemberName %23 3 "gl_CullDistance" OpName %25 "" OpName %29 "_ua" OpName %28 "_uf" OpName %33 "_uf" OpName %32 "_ug" OpName %40 "main" OpName %42 "param" OpName %50 "param" OpName %53 "param" -OpDecorate %4 Location 0 +OpDecorate %4 Location 1 -OpDecorate %5 Location 1 +OpDecorate %5 Location 2 -OpDecorate %6 Location 2 +OpDecorate %6 Location 0 -OpDecorate %8 Location 0 +OpDecorate %8 Location 1 OpMemberDecorate %9 0 Offset 0 OpDecorate %9 Block OpDecorate %11 DescriptorSet 0 -OpDecorate %11 Binding 0 +OpDecorate %11 Binding 1 OpMemberDecorate %16 0 Offset 0 OpMemberDecorate %16 1 Offset 4 OpMemberDecorate %16 2 Offset 8 OpMemberDecorate %16 3 Offset 12 OpMemberDecorate %17 0 Offset 0 OpMemberDecorate %17 1 Offset 16 OpMemberDecorate %17 2 Offset 20 OpMemberDecorate %17 3 Offset 24 OpMemberDecorate %17 4 Offset 28 OpMemberDecorate %17 5 Offset 32 OpMemberDecorate %17 6 Offset 48 OpMemberDecorate %17 7 Offset 64 OpMemberDecorate %17 2 RelaxedPrecision OpMemberDecorate %17 4 RelaxedPrecision OpDecorate %17 Block -OpDecorate %19 DescriptorSet 0 +OpDecorate %19 DescriptorSet 2 -OpDecorate %19 Binding 1 +OpDecorate %19 Binding 0 -OpDecorate %20 Location 1 OpMemberDecorate %23 0 BuiltIn Position -OpMemberDecorate %23 1 BuiltIn PointSize -OpMemberDecorate %23 2 BuiltIn ClipDistance -OpMemberDecorate %23 3 BuiltIn CullDistance OpDecorate %23 Block OpDecorate %28 RelaxedPrecision OpDecorate %29 RelaxedPrecision OpDecorate %31 RelaxedPrecision OpDecorate %32 RelaxedPrecision OpDecorate %33 RelaxedPrecision OpDecorate %35 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %44 RelaxedPrecision OpDecorate %52 RelaxedPrecision OpDecorate %55 RelaxedPrecision OpDecorate %56 RelaxedPrecision %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %9 = OpTypeStruct %2 %12 = OpTypeInt 32 0 %13 = OpTypeInt 32 1 %14 = OpTypeVector %13 4 %15 = OpTypeVector %12 4 %16 = OpTypeStruct %1 %1 %1 %1 %17 = OpTypeStruct %2 %12 %12 %13 %13 %14 %15 %16 %21 = OpConstant %12 8 %22 = OpTypeArray %1 %21 -%23 = OpTypeStruct %2 %1 %22 %22 +%23 = OpTypeStruct %2 %38 = OpTypeVoid %45 = OpConstant %12 0 +%59 = OpTypePointer Private %2 %3 = OpTypePointer Input %2 +%60 = OpTypePointer Private %2 %7 = OpTypePointer Output %2 %10 = OpTypePointer Uniform %9 %18 = OpTypePointer Uniform %17 %24 = OpTypePointer Output %23 %26 = OpTypePointer Function %2 %46 = OpTypePointer Uniform %2 %27 = OpTypeFunction %2 %26 %39 = OpTypeFunction %38 %4 = OpVariable %3 Input %5 = OpVariable %3 Input %6 = OpVariable %3 Input %8 = OpVariable %7 Output %11 = OpVariable %10 Uniform %19 = OpVariable %18 Uniform -%20 = OpVariable %7 Output +%58 = OpVariable %60 Private %25 = OpVariable %24 Output +%61 = OpConstant %13 0 +%62 = OpConstant %1 0.5 %28 = OpFunction %2 None %27 %29 = OpFunctionParameter %26 %30 = OpLabel %31 = OpLoad %2 %29 OpReturnValue %31 OpFunctionEnd %32 = OpFunction %2 None %27 %33 = OpFunctionParameter %26 %34 = OpLabel %35 = OpLoad %2 %33 %36 = OpLoad %2 %33 %37 = OpFAdd %2 %35 %36 OpReturnValue %37 OpFunctionEnd %40 = OpFunction %38 None %39 %41 = OpLabel %42 = OpVariable %26 Function %50 = OpVariable %26 Function %53 = OpVariable %26 Function %43 = OpLoad %2 %4 OpStore %42 %43 %44 = OpFunctionCall %2 %28 %42 %47 = OpAccessChain %46 %11 %45 %48 = OpLoad %2 %47 %49 = OpFAdd %2 %44 %48 OpStore %8 %49 %51 = OpLoad %2 %5 OpStore %50 %51 %52 = OpFunctionCall %2 %32 %50 %54 = OpLoad %2 %6 OpStore %53 %54 %55 = OpFunctionCall %2 %28 %53 %56 = OpFAdd %2 %52 %55 %57 = OpAccessChain %7 %25 %45 OpStore %57 %56 +%63 = OpAccessChain %7 %25 %61 +%64 = OpLoad %2 %63 +%65 = OpCompositeExtract %1 %64 0 +%66 = OpCompositeExtract %1 %64 1 +%67 = OpCompositeExtract %1 %64 2 +%68 = OpCompositeExtract %1 %64 3 +%70 = OpFNegate %1 %65 +%71 = OpFAdd %1 %67 %68 +%72 = OpFMul %1 %71 %62 +%69 = OpCompositeConstruct %2 %66 %70 %72 %68 +OpStore %63 %69 OpReturn OpFunctionEnd )"; Options options; options.ignore_set_binding = true; DoStringDiffTest(kSrc, kDst, kDiff, options); } TEST(DiffTest, DifferentDecorationsVertexIgnoreSetBindingLocation) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 58 +; Bound: 73 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 -OpEntryPoint Vertex %40 "main" %4 %5 %6 %8 %20 %25 +OpEntryPoint Vertex %40 "main" %4 %5 %6 %8 %25 OpSource GLSL 450 OpName %4 "_ub" OpName %5 "_uc" OpName %6 "_ud" OpName %8 "_ue" OpName %9 "defaultUniformsVS" OpMemberName %9 0 "_ua" OpName %11 "" OpName %16 "ANGLEDepthRangeParams" OpMemberName %16 0 "near" OpMemberName %16 1 "far" OpMemberName %16 2 "diff" OpMemberName %16 3 "reserved" OpName %17 "ANGLEUniformBlock" OpMemberName %17 0 "viewport" OpMemberName %17 1 "clipDistancesEnabled" OpMemberName %17 2 "xfbActiveUnpaused" OpMemberName %17 3 "xfbVerticesPerInstance" OpMemberName %17 4 "numSamples" OpMemberName %17 5 "xfbBufferOffsets" OpMemberName %17 6 "acbBufferOffsets" OpMemberName %17 7 "depthRange" OpName %19 "ANGLEUniforms" -OpName %20 "ANGLEXfbPosition" OpName %23 "gl_PerVertex" OpMemberName %23 0 "gl_Position" -OpMemberName %23 1 "gl_PointSize" -OpMemberName %23 2 "gl_ClipDistance" -OpMemberName %23 3 "gl_CullDistance" OpName %25 "" OpName %29 "_ua" OpName %28 "_uf" OpName %33 "_uf" OpName %32 "_ug" OpName %40 "main" OpName %42 "param" OpName %50 "param" OpName %53 "param" -OpDecorate %4 Location 0 +OpDecorate %4 Location 1 -OpDecorate %5 Location 1 +OpDecorate %5 Location 2 -OpDecorate %6 Location 2 +OpDecorate %6 Location 0 -OpDecorate %8 Location 0 +OpDecorate %8 Location 1 OpMemberDecorate %9 0 Offset 0 OpDecorate %9 Block OpDecorate %11 DescriptorSet 0 -OpDecorate %11 Binding 0 +OpDecorate %11 Binding 1 OpMemberDecorate %16 0 Offset 0 OpMemberDecorate %16 1 Offset 4 OpMemberDecorate %16 2 Offset 8 OpMemberDecorate %16 3 Offset 12 OpMemberDecorate %17 0 Offset 0 OpMemberDecorate %17 1 Offset 16 OpMemberDecorate %17 2 Offset 20 OpMemberDecorate %17 3 Offset 24 OpMemberDecorate %17 4 Offset 28 OpMemberDecorate %17 5 Offset 32 OpMemberDecorate %17 6 Offset 48 OpMemberDecorate %17 7 Offset 64 OpMemberDecorate %17 2 RelaxedPrecision OpMemberDecorate %17 4 RelaxedPrecision OpDecorate %17 Block -OpDecorate %19 DescriptorSet 0 +OpDecorate %19 DescriptorSet 2 -OpDecorate %19 Binding 1 +OpDecorate %19 Binding 0 -OpDecorate %20 Location 1 OpMemberDecorate %23 0 BuiltIn Position -OpMemberDecorate %23 1 BuiltIn PointSize -OpMemberDecorate %23 2 BuiltIn ClipDistance -OpMemberDecorate %23 3 BuiltIn CullDistance OpDecorate %23 Block OpDecorate %28 RelaxedPrecision OpDecorate %29 RelaxedPrecision OpDecorate %31 RelaxedPrecision OpDecorate %32 RelaxedPrecision OpDecorate %33 RelaxedPrecision OpDecorate %35 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %44 RelaxedPrecision OpDecorate %52 RelaxedPrecision OpDecorate %55 RelaxedPrecision OpDecorate %56 RelaxedPrecision %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %9 = OpTypeStruct %2 %12 = OpTypeInt 32 0 %13 = OpTypeInt 32 1 %14 = OpTypeVector %13 4 %15 = OpTypeVector %12 4 %16 = OpTypeStruct %1 %1 %1 %1 %17 = OpTypeStruct %2 %12 %12 %13 %13 %14 %15 %16 %21 = OpConstant %12 8 %22 = OpTypeArray %1 %21 -%23 = OpTypeStruct %2 %1 %22 %22 +%23 = OpTypeStruct %2 %38 = OpTypeVoid %45 = OpConstant %12 0 +%59 = OpTypePointer Private %2 %3 = OpTypePointer Input %2 +%60 = OpTypePointer Private %2 %7 = OpTypePointer Output %2 %10 = OpTypePointer Uniform %9 %18 = OpTypePointer Uniform %17 %24 = OpTypePointer Output %23 %26 = OpTypePointer Function %2 %46 = OpTypePointer Uniform %2 %27 = OpTypeFunction %2 %26 %39 = OpTypeFunction %38 %4 = OpVariable %3 Input %5 = OpVariable %3 Input %6 = OpVariable %3 Input %8 = OpVariable %7 Output %11 = OpVariable %10 Uniform %19 = OpVariable %18 Uniform -%20 = OpVariable %7 Output +%58 = OpVariable %60 Private %25 = OpVariable %24 Output +%61 = OpConstant %13 0 +%62 = OpConstant %1 0.5 %28 = OpFunction %2 None %27 %29 = OpFunctionParameter %26 %30 = OpLabel %31 = OpLoad %2 %29 OpReturnValue %31 OpFunctionEnd %32 = OpFunction %2 None %27 %33 = OpFunctionParameter %26 %34 = OpLabel %35 = OpLoad %2 %33 %36 = OpLoad %2 %33 %37 = OpFAdd %2 %35 %36 OpReturnValue %37 OpFunctionEnd %40 = OpFunction %38 None %39 %41 = OpLabel %42 = OpVariable %26 Function %50 = OpVariable %26 Function %53 = OpVariable %26 Function %43 = OpLoad %2 %4 OpStore %42 %43 %44 = OpFunctionCall %2 %28 %42 %47 = OpAccessChain %46 %11 %45 %48 = OpLoad %2 %47 %49 = OpFAdd %2 %44 %48 OpStore %8 %49 %51 = OpLoad %2 %5 OpStore %50 %51 %52 = OpFunctionCall %2 %32 %50 %54 = OpLoad %2 %6 OpStore %53 %54 %55 = OpFunctionCall %2 %28 %53 %56 = OpFAdd %2 %52 %55 %57 = OpAccessChain %7 %25 %45 OpStore %57 %56 +%63 = OpAccessChain %7 %25 %61 +%64 = OpLoad %2 %63 +%65 = OpCompositeExtract %1 %64 0 +%66 = OpCompositeExtract %1 %64 1 +%67 = OpCompositeExtract %1 %64 2 +%68 = OpCompositeExtract %1 %64 3 +%70 = OpFNegate %1 %65 +%71 = OpFAdd %1 %67 %68 +%72 = OpFMul %1 %71 %62 +%69 = OpCompositeConstruct %2 %66 %70 %72 %68 +OpStore %63 %69 OpReturn OpFunctionEnd )"; Options options; options.ignore_set_binding = true; options.ignore_location = true; DoStringDiffTest(kSrc, kDst, kDiff, options); } } // namespace } // namespace diff } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/different_decorations_vertex_dst.spvasm000066400000000000000000000102101475742701700325460ustar00rootroot00000000000000OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %40 "main" %4 %5 %6 %8 %25 OpSource GLSL 450 OpName %4 "_ub" OpName %5 "_uc" OpName %6 "_ud" OpName %8 "_ue" OpName %9 "defaultUniformsVS" OpMemberName %9 0 "_ua" OpName %11 "" OpName %16 "ANGLEDepthRangeParams" OpMemberName %16 0 "near" OpMemberName %16 1 "far" OpMemberName %16 2 "diff" OpMemberName %16 3 "reserved" OpName %17 "ANGLEUniformBlock" OpMemberName %17 0 "viewport" OpMemberName %17 1 "clipDistancesEnabled" OpMemberName %17 2 "xfbActiveUnpaused" OpMemberName %17 3 "xfbVerticesPerInstance" OpMemberName %17 4 "numSamples" OpMemberName %17 5 "xfbBufferOffsets" OpMemberName %17 6 "acbBufferOffsets" OpMemberName %17 7 "depthRange" OpName %19 "ANGLEUniforms" OpName %23 "gl_PerVertex" OpMemberName %23 0 "gl_Position" OpName %25 "" OpName %29 "_ua" OpName %28 "_uf" OpName %33 "_uf" OpName %32 "_ug" OpName %40 "main" OpName %42 "param" OpName %50 "param" OpName %53 "param" OpDecorate %4 Location 1 OpDecorate %5 Location 2 OpDecorate %6 Location 0 OpDecorate %8 Location 1 OpMemberDecorate %9 0 Offset 0 OpDecorate %9 Block OpDecorate %11 DescriptorSet 0 OpDecorate %11 Binding 1 OpMemberDecorate %16 0 Offset 0 OpMemberDecorate %16 1 Offset 4 OpMemberDecorate %16 2 Offset 8 OpMemberDecorate %16 3 Offset 12 OpMemberDecorate %17 0 Offset 0 OpMemberDecorate %17 1 Offset 16 OpMemberDecorate %17 2 Offset 20 OpMemberDecorate %17 3 Offset 24 OpMemberDecorate %17 4 Offset 28 OpMemberDecorate %17 5 Offset 32 OpMemberDecorate %17 6 Offset 48 OpMemberDecorate %17 7 Offset 64 OpMemberDecorate %17 2 RelaxedPrecision OpMemberDecorate %17 4 RelaxedPrecision OpDecorate %17 Block OpDecorate %19 DescriptorSet 2 OpDecorate %19 Binding 0 OpMemberDecorate %23 0 BuiltIn Position OpDecorate %23 Block OpDecorate %28 RelaxedPrecision OpDecorate %29 RelaxedPrecision OpDecorate %31 RelaxedPrecision OpDecorate %32 RelaxedPrecision OpDecorate %33 RelaxedPrecision OpDecorate %35 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %44 RelaxedPrecision OpDecorate %52 RelaxedPrecision OpDecorate %55 RelaxedPrecision OpDecorate %56 RelaxedPrecision %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %9 = OpTypeStruct %2 %12 = OpTypeInt 32 0 %13 = OpTypeInt 32 1 %14 = OpTypeVector %13 4 %15 = OpTypeVector %12 4 %16 = OpTypeStruct %1 %1 %1 %1 %17 = OpTypeStruct %2 %12 %12 %13 %13 %14 %15 %16 %21 = OpConstant %12 8 %22 = OpTypeArray %1 %21 %23 = OpTypeStruct %2 %38 = OpTypeVoid %45 = OpConstant %12 0 %58 = OpTypePointer Private %2 %3 = OpTypePointer Input %2 %59 = OpTypePointer Private %2 %7 = OpTypePointer Output %2 %10 = OpTypePointer Uniform %9 %18 = OpTypePointer Uniform %17 %24 = OpTypePointer Output %23 %26 = OpTypePointer Function %2 %46 = OpTypePointer Uniform %2 %27 = OpTypeFunction %2 %26 %39 = OpTypeFunction %38 %4 = OpVariable %3 Input %5 = OpVariable %3 Input %6 = OpVariable %3 Input %8 = OpVariable %7 Output %11 = OpVariable %10 Uniform %19 = OpVariable %18 Uniform %20 = OpVariable %59 Private %25 = OpVariable %24 Output %60 = OpConstant %13 0 %61 = OpConstant %1 0.5 %28 = OpFunction %2 None %27 %29 = OpFunctionParameter %26 %30 = OpLabel %31 = OpLoad %2 %29 OpReturnValue %31 OpFunctionEnd %32 = OpFunction %2 None %27 %33 = OpFunctionParameter %26 %34 = OpLabel %35 = OpLoad %2 %33 %36 = OpLoad %2 %33 %37 = OpFAdd %2 %35 %36 OpReturnValue %37 OpFunctionEnd %40 = OpFunction %38 None %39 %41 = OpLabel %42 = OpVariable %26 Function %50 = OpVariable %26 Function %53 = OpVariable %26 Function %43 = OpLoad %2 %4 OpStore %42 %43 %44 = OpFunctionCall %2 %28 %42 %47 = OpAccessChain %46 %11 %45 %48 = OpLoad %2 %47 %49 = OpFAdd %2 %44 %48 OpStore %8 %49 %51 = OpLoad %2 %5 OpStore %50 %51 %52 = OpFunctionCall %2 %32 %50 %54 = OpLoad %2 %6 OpStore %53 %54 %55 = OpFunctionCall %2 %28 %53 %56 = OpFAdd %2 %52 %55 %57 = OpAccessChain %7 %25 %45 OpStore %57 %56 %62 = OpAccessChain %7 %25 %60 %63 = OpLoad %2 %62 %64 = OpCompositeExtract %1 %63 0 %65 = OpCompositeExtract %1 %63 1 %66 = OpCompositeExtract %1 %63 2 %67 = OpCompositeExtract %1 %63 3 %69 = OpFNegate %1 %64 %70 = OpFAdd %1 %66 %67 %71 = OpFMul %1 %70 %61 %68 = OpCompositeConstruct %2 %65 %69 %71 %67 OpStore %62 %68 OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/different_decorations_vertex_src.spvasm000066400000000000000000000101731475742701700325530ustar00rootroot00000000000000;; Test where variable set/binding/location decorations are different between ;; src and dst vertex shaders. OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %40 "main" %4 %5 %6 %8 %20 %25 OpSource GLSL 450 OpName %4 "_ub" OpName %5 "_uc" OpName %6 "_ud" OpName %8 "_ue" OpName %9 "defaultUniformsVS" OpMemberName %9 0 "_ua" OpName %11 "" OpName %16 "ANGLEDepthRangeParams" OpMemberName %16 0 "near" OpMemberName %16 1 "far" OpMemberName %16 2 "diff" OpMemberName %16 3 "reserved" OpName %17 "ANGLEUniformBlock" OpMemberName %17 0 "viewport" OpMemberName %17 1 "clipDistancesEnabled" OpMemberName %17 2 "xfbActiveUnpaused" OpMemberName %17 3 "xfbVerticesPerInstance" OpMemberName %17 4 "numSamples" OpMemberName %17 5 "xfbBufferOffsets" OpMemberName %17 6 "acbBufferOffsets" OpMemberName %17 7 "depthRange" OpName %19 "ANGLEUniforms" OpName %20 "ANGLEXfbPosition" OpName %23 "gl_PerVertex" OpMemberName %23 0 "gl_Position" OpMemberName %23 1 "gl_PointSize" OpMemberName %23 2 "gl_ClipDistance" OpMemberName %23 3 "gl_CullDistance" OpName %25 "" OpName %29 "_ua" OpName %28 "_uf" OpName %33 "_uf" OpName %32 "_ug" OpName %40 "main" OpName %42 "param" OpName %50 "param" OpName %53 "param" OpDecorate %4 Location 0 OpDecorate %5 Location 1 OpDecorate %6 Location 2 OpDecorate %8 Location 0 OpMemberDecorate %9 0 Offset 0 OpDecorate %9 Block OpDecorate %11 DescriptorSet 0 OpDecorate %11 Binding 0 OpMemberDecorate %16 0 Offset 0 OpMemberDecorate %16 1 Offset 4 OpMemberDecorate %16 2 Offset 8 OpMemberDecorate %16 3 Offset 12 OpMemberDecorate %17 0 Offset 0 OpMemberDecorate %17 1 Offset 16 OpMemberDecorate %17 2 Offset 20 OpMemberDecorate %17 3 Offset 24 OpMemberDecorate %17 4 Offset 28 OpMemberDecorate %17 5 Offset 32 OpMemberDecorate %17 6 Offset 48 OpMemberDecorate %17 7 Offset 64 OpMemberDecorate %17 2 RelaxedPrecision OpMemberDecorate %17 4 RelaxedPrecision OpDecorate %17 Block OpDecorate %19 DescriptorSet 0 OpDecorate %19 Binding 1 OpDecorate %20 Location 1 OpMemberDecorate %23 0 BuiltIn Position OpMemberDecorate %23 1 BuiltIn PointSize OpMemberDecorate %23 2 BuiltIn ClipDistance OpMemberDecorate %23 3 BuiltIn CullDistance OpDecorate %23 Block OpDecorate %28 RelaxedPrecision OpDecorate %29 RelaxedPrecision OpDecorate %31 RelaxedPrecision OpDecorate %32 RelaxedPrecision OpDecorate %33 RelaxedPrecision OpDecorate %35 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %44 RelaxedPrecision OpDecorate %52 RelaxedPrecision OpDecorate %55 RelaxedPrecision OpDecorate %56 RelaxedPrecision %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %9 = OpTypeStruct %2 %12 = OpTypeInt 32 0 %13 = OpTypeInt 32 1 %14 = OpTypeVector %13 4 %15 = OpTypeVector %12 4 %16 = OpTypeStruct %1 %1 %1 %1 %17 = OpTypeStruct %2 %12 %12 %13 %13 %14 %15 %16 %21 = OpConstant %12 8 %22 = OpTypeArray %1 %21 %23 = OpTypeStruct %2 %1 %22 %22 %38 = OpTypeVoid %45 = OpConstant %12 0 %3 = OpTypePointer Input %2 %7 = OpTypePointer Output %2 %10 = OpTypePointer Uniform %9 %18 = OpTypePointer Uniform %17 %24 = OpTypePointer Output %23 %26 = OpTypePointer Function %2 %46 = OpTypePointer Uniform %2 %27 = OpTypeFunction %2 %26 %39 = OpTypeFunction %38 %4 = OpVariable %3 Input %5 = OpVariable %3 Input %6 = OpVariable %3 Input %8 = OpVariable %7 Output %11 = OpVariable %10 Uniform %19 = OpVariable %18 Uniform %20 = OpVariable %7 Output %25 = OpVariable %24 Output %28 = OpFunction %2 None %27 %29 = OpFunctionParameter %26 %30 = OpLabel %31 = OpLoad %2 %29 OpReturnValue %31 OpFunctionEnd %32 = OpFunction %2 None %27 %33 = OpFunctionParameter %26 %34 = OpLabel %35 = OpLoad %2 %33 %36 = OpLoad %2 %33 %37 = OpFAdd %2 %35 %36 OpReturnValue %37 OpFunctionEnd %40 = OpFunction %38 None %39 %41 = OpLabel %42 = OpVariable %26 Function %50 = OpVariable %26 Function %53 = OpVariable %26 Function %43 = OpLoad %2 %4 OpStore %42 %43 %44 = OpFunctionCall %2 %28 %42 %47 = OpAccessChain %46 %11 %45 %48 = OpLoad %2 %47 %49 = OpFAdd %2 %44 %48 OpStore %8 %49 %51 = OpLoad %2 %5 OpStore %50 %51 %52 = OpFunctionCall %2 %32 %50 %54 = OpLoad %2 %6 OpStore %53 %54 %55 = OpFunctionCall %2 %28 %53 %56 = OpFAdd %2 %52 %55 %57 = OpAccessChain %7 %25 %45 OpStore %57 %56 OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/different_function_parameter_count_autogen.cpp000066400000000000000000000236501475742701700340710ustar00rootroot00000000000000// GENERATED FILE - DO NOT EDIT. // Generated by generate_tests.py // // Copyright (c) 2022 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "../diff_test_utils.h" #include "gtest/gtest.h" namespace spvtools { namespace diff { namespace { // Test where src and dst have a function with different parameter count. constexpr char kSrc[] = R"(; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 25 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %20 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpName %4 "main" OpName %11 "f(vf2;" OpName %10 "v" OpName %20 "o" OpName %23 "param" OpDecorate %20 RelaxedPrecision OpDecorate %20 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 2 %8 = OpTypePointer Function %7 %9 = OpTypeFunction %7 %8 %14 = OpConstant %6 0.5 %15 = OpConstantComposite %7 %14 %14 %19 = OpTypePointer Output %7 %20 = OpVariable %19 Output %21 = OpConstant %6 0 %22 = OpConstantComposite %7 %21 %21 %4 = OpFunction %2 None %3 %5 = OpLabel %23 = OpVariable %8 Function OpStore %23 %22 %24 = OpFunctionCall %7 %11 %23 OpStore %20 %24 OpReturn OpFunctionEnd %11 = OpFunction %7 None %9 %10 = OpFunctionParameter %8 %12 = OpLabel %13 = OpLoad %7 %10 %16 = OpFAdd %7 %13 %15 OpReturnValue %16 OpFunctionEnd)"; constexpr char kDst[] = R"(; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 28 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %20 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpName %4 "main" OpName %12 "f(vf2;vf2;" OpName %10 "v" OpName %11 "v2" OpName %20 "o" OpName %25 "param" OpName %26 "param" OpDecorate %20 RelaxedPrecision OpDecorate %20 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 2 %8 = OpTypePointer Function %7 %9 = OpTypeFunction %7 %8 %8 %19 = OpTypePointer Output %7 %20 = OpVariable %19 Output %21 = OpConstant %6 0 %22 = OpConstantComposite %7 %21 %21 %23 = OpConstant %6 0.5 %24 = OpConstantComposite %7 %23 %23 %4 = OpFunction %2 None %3 %5 = OpLabel %25 = OpVariable %8 Function %26 = OpVariable %8 Function OpStore %25 %22 OpStore %26 %24 %27 = OpFunctionCall %7 %12 %25 %26 OpStore %20 %27 OpReturn OpFunctionEnd %12 = OpFunction %7 None %9 %10 = OpFunctionParameter %8 %11 = OpFunctionParameter %8 %13 = OpLabel %14 = OpLoad %7 %10 %15 = OpLoad %7 %11 %16 = OpFAdd %7 %14 %15 OpReturnValue %16 OpFunctionEnd )"; TEST(DiffTest, DifferentFunctionParameterCount) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 25 +; Bound: 31 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %20 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpName %4 "main" -OpName %11 "f(vf2;" +OpName %11 "f(vf2;vf2;" OpName %10 "v" +OpName %26 "v2" OpName %20 "o" OpName %23 "param" +OpName %29 "param" OpDecorate %20 RelaxedPrecision OpDecorate %20 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 2 %8 = OpTypePointer Function %7 -%9 = OpTypeFunction %7 %8 +%25 = OpTypeFunction %7 %8 %8 %14 = OpConstant %6 0.5 %15 = OpConstantComposite %7 %14 %14 %19 = OpTypePointer Output %7 %20 = OpVariable %19 Output %21 = OpConstant %6 0 %22 = OpConstantComposite %7 %21 %21 %4 = OpFunction %2 None %3 %5 = OpLabel %23 = OpVariable %8 Function +%29 = OpVariable %8 Function OpStore %23 %22 -%24 = OpFunctionCall %7 %11 %23 +OpStore %29 %15 +%30 = OpFunctionCall %7 %11 %23 %29 -OpStore %20 %24 +OpStore %20 %30 OpReturn OpFunctionEnd -%11 = OpFunction %7 None %9 +%11 = OpFunction %7 None %25 %10 = OpFunctionParameter %8 +%26 = OpFunctionParameter %8 %12 = OpLabel %13 = OpLoad %7 %10 -%16 = OpFAdd %7 %13 %15 +%27 = OpLoad %7 %26 +%28 = OpFAdd %7 %13 %27 -OpReturnValue %16 +OpReturnValue %28 OpFunctionEnd )"; Options options; DoStringDiffTest(kSrc, kDst, kDiff, options); } TEST(DiffTest, DifferentFunctionParameterCountNoDebug) { constexpr char kSrcNoDebug[] = R"(; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 25 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %20 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpDecorate %20 RelaxedPrecision OpDecorate %20 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 2 %8 = OpTypePointer Function %7 %9 = OpTypeFunction %7 %8 %14 = OpConstant %6 0.5 %15 = OpConstantComposite %7 %14 %14 %19 = OpTypePointer Output %7 %20 = OpVariable %19 Output %21 = OpConstant %6 0 %22 = OpConstantComposite %7 %21 %21 %4 = OpFunction %2 None %3 %5 = OpLabel %23 = OpVariable %8 Function OpStore %23 %22 %24 = OpFunctionCall %7 %11 %23 OpStore %20 %24 OpReturn OpFunctionEnd %11 = OpFunction %7 None %9 %10 = OpFunctionParameter %8 %12 = OpLabel %13 = OpLoad %7 %10 %16 = OpFAdd %7 %13 %15 OpReturnValue %16 OpFunctionEnd )"; constexpr char kDstNoDebug[] = R"(; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 28 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %20 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpDecorate %20 RelaxedPrecision OpDecorate %20 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 2 %8 = OpTypePointer Function %7 %9 = OpTypeFunction %7 %8 %8 %19 = OpTypePointer Output %7 %20 = OpVariable %19 Output %21 = OpConstant %6 0 %22 = OpConstantComposite %7 %21 %21 %23 = OpConstant %6 0.5 %24 = OpConstantComposite %7 %23 %23 %4 = OpFunction %2 None %3 %5 = OpLabel %25 = OpVariable %8 Function %26 = OpVariable %8 Function OpStore %25 %22 OpStore %26 %24 %27 = OpFunctionCall %7 %12 %25 %26 OpStore %20 %27 OpReturn OpFunctionEnd %12 = OpFunction %7 None %9 %10 = OpFunctionParameter %8 %11 = OpFunctionParameter %8 %13 = OpLabel %14 = OpLoad %7 %10 %15 = OpLoad %7 %11 %16 = OpFAdd %7 %14 %15 OpReturnValue %16 OpFunctionEnd )"; constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 25 +; Bound: 31 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %20 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpDecorate %20 RelaxedPrecision OpDecorate %20 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 2 %8 = OpTypePointer Function %7 -%9 = OpTypeFunction %7 %8 +%25 = OpTypeFunction %7 %8 %8 %14 = OpConstant %6 0.5 %15 = OpConstantComposite %7 %14 %14 %19 = OpTypePointer Output %7 %20 = OpVariable %19 Output %21 = OpConstant %6 0 %22 = OpConstantComposite %7 %21 %21 %4 = OpFunction %2 None %3 %5 = OpLabel %23 = OpVariable %8 Function +%29 = OpVariable %8 Function OpStore %23 %22 -%24 = OpFunctionCall %7 %11 %23 +OpStore %29 %15 +%30 = OpFunctionCall %7 %11 %23 %29 -OpStore %20 %24 +OpStore %20 %30 OpReturn OpFunctionEnd -%11 = OpFunction %7 None %9 +%11 = OpFunction %7 None %25 %10 = OpFunctionParameter %8 +%26 = OpFunctionParameter %8 %12 = OpLabel %13 = OpLoad %7 %10 -%16 = OpFAdd %7 %13 %15 +%27 = OpLoad %7 %26 +%28 = OpFAdd %7 %13 %27 -OpReturnValue %16 +OpReturnValue %28 OpFunctionEnd )"; Options options; DoStringDiffTest(kSrcNoDebug, kDstNoDebug, kDiff, options); } } // namespace } // namespace diff } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/different_function_parameter_count_dst.spvasm000066400000000000000000000033021475742701700337400ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 28 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %20 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpName %4 "main" OpName %12 "f(vf2;vf2;" OpName %10 "v" OpName %11 "v2" OpName %20 "o" OpName %25 "param" OpName %26 "param" OpDecorate %20 RelaxedPrecision OpDecorate %20 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 2 %8 = OpTypePointer Function %7 %9 = OpTypeFunction %7 %8 %8 %19 = OpTypePointer Output %7 %20 = OpVariable %19 Output %21 = OpConstant %6 0 %22 = OpConstantComposite %7 %21 %21 %23 = OpConstant %6 0.5 %24 = OpConstantComposite %7 %23 %23 %4 = OpFunction %2 None %3 %5 = OpLabel %25 = OpVariable %8 Function %26 = OpVariable %8 Function OpStore %25 %22 OpStore %26 %24 %27 = OpFunctionCall %7 %12 %25 %26 OpStore %20 %27 OpReturn OpFunctionEnd %12 = OpFunction %7 None %9 %10 = OpFunctionParameter %8 %11 = OpFunctionParameter %8 %13 = OpLabel %14 = OpLoad %7 %10 %15 = OpLoad %7 %11 %16 = OpFAdd %7 %14 %15 OpReturnValue %16 OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/different_function_parameter_count_src.spvasm000066400000000000000000000030671475742701700337450ustar00rootroot00000000000000;; Test where src and dst have a function with different parameter count. ; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 25 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %20 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpName %4 "main" OpName %11 "f(vf2;" OpName %10 "v" OpName %20 "o" OpName %23 "param" OpDecorate %20 RelaxedPrecision OpDecorate %20 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 2 %8 = OpTypePointer Function %7 %9 = OpTypeFunction %7 %8 %14 = OpConstant %6 0.5 %15 = OpConstantComposite %7 %14 %14 %19 = OpTypePointer Output %7 %20 = OpVariable %19 Output %21 = OpConstant %6 0 %22 = OpConstantComposite %7 %21 %21 %4 = OpFunction %2 None %3 %5 = OpLabel %23 = OpVariable %8 Function OpStore %23 %22 %24 = OpFunctionCall %7 %11 %23 OpStore %20 %24 OpReturn OpFunctionEnd %11 = OpFunction %7 None %9 %10 = OpFunctionParameter %8 %12 = OpLabel %13 = OpLoad %7 %10 %16 = OpFAdd %7 %13 %15 OpReturnValue %16 OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/extra_if_block_autogen.cpp000066400000000000000000000705321475742701700277220ustar00rootroot00000000000000// GENERATED FILE - DO NOT EDIT. // Generated by generate_tests.py // // Copyright (c) 2022 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "../diff_test_utils.h" #include "gtest/gtest.h" namespace spvtools { namespace diff { namespace { // Test where src has an extra if block in one function, and dst has an extra // if block in another function. constexpr char kSrc[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %63 %68 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "f1(" OpName %10 "f2(" OpName %13 "v" OpName %16 "Buffer" OpMemberName %16 0 "flag1" OpMemberName %16 1 "flag2" OpName %18 "" OpName %45 "v" OpName %63 "color" OpName %68 "v" OpDecorate %8 RelaxedPrecision OpDecorate %10 RelaxedPrecision OpDecorate %13 RelaxedPrecision OpMemberDecorate %16 0 RelaxedPrecision OpMemberDecorate %16 0 Offset 0 OpMemberDecorate %16 1 RelaxedPrecision OpMemberDecorate %16 1 Offset 4 OpDecorate %16 Block OpDecorate %18 DescriptorSet 0 OpDecorate %18 Binding 0 OpDecorate %23 RelaxedPrecision OpDecorate %30 RelaxedPrecision OpDecorate %31 RelaxedPrecision OpDecorate %34 RelaxedPrecision OpDecorate %35 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %38 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %40 RelaxedPrecision OpDecorate %41 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %45 RelaxedPrecision OpDecorate %47 RelaxedPrecision OpDecorate %48 RelaxedPrecision OpDecorate %50 RelaxedPrecision OpDecorate %51 RelaxedPrecision OpDecorate %54 RelaxedPrecision OpDecorate %55 RelaxedPrecision OpDecorate %56 RelaxedPrecision OpDecorate %57 RelaxedPrecision OpDecorate %58 RelaxedPrecision OpDecorate %63 RelaxedPrecision OpDecorate %63 Location 0 OpDecorate %64 RelaxedPrecision OpDecorate %65 RelaxedPrecision OpDecorate %66 RelaxedPrecision OpDecorate %68 RelaxedPrecision OpDecorate %68 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeFunction %6 %12 = OpTypePointer Function %6 %14 = OpConstant %6 0 %15 = OpTypeInt 32 0 %16 = OpTypeStruct %15 %15 %17 = OpTypePointer Uniform %16 %18 = OpVariable %17 Uniform %19 = OpTypeInt 32 1 %20 = OpConstant %19 0 %21 = OpTypePointer Uniform %15 %24 = OpConstant %15 0 %25 = OpTypeBool %29 = OpConstant %6 1 %32 = OpConstant %19 1 %49 = OpConstant %6 10 %52 = OpConstant %6 0.5 %53 = OpConstant %6 0.699999988 %61 = OpTypeVector %6 4 %62 = OpTypePointer Output %61 %63 = OpVariable %62 Output %67 = OpTypePointer Input %6 %68 = OpVariable %67 Input %4 = OpFunction %2 None %3 %5 = OpLabel %64 = OpFunctionCall %6 %8 %65 = OpFunctionCall %6 %10 %66 = OpCompositeConstruct %61 %64 %65 %14 %29 OpStore %63 %66 OpReturn OpFunctionEnd %8 = OpFunction %6 None %7 %9 = OpLabel %13 = OpVariable %12 Function OpStore %13 %14 %22 = OpAccessChain %21 %18 %20 %23 = OpLoad %15 %22 %26 = OpINotEqual %25 %23 %24 OpSelectionMerge %28 None OpBranchConditional %26 %27 %28 %27 = OpLabel %30 = OpLoad %6 %13 %31 = OpFAdd %6 %30 %29 OpStore %13 %31 OpBranch %28 %28 = OpLabel %33 = OpAccessChain %21 %18 %32 %34 = OpLoad %15 %33 %35 = OpConvertUToF %6 %34 %36 = OpExtInst %6 %1 Log2 %35 %37 = OpLoad %6 %13 %38 = OpFAdd %6 %37 %36 OpStore %13 %38 %39 = OpLoad %6 %13 %40 = OpLoad %6 %13 %41 = OpExtInst %6 %1 Sqrt %40 %42 = OpFSub %6 %39 %41 OpReturnValue %42 OpFunctionEnd %10 = OpFunction %6 None %7 %11 = OpLabel %45 = OpVariable %12 Function %46 = OpAccessChain %21 %18 %20 %47 = OpLoad %15 %46 %48 = OpConvertUToF %6 %47 %50 = OpFDiv %6 %48 %49 OpStore %45 %50 %51 = OpLoad %6 %45 %54 = OpExtInst %6 %1 FClamp %51 %52 %53 %55 = OpLoad %6 %45 %56 = OpFMul %6 %55 %54 OpStore %45 %56 %57 = OpLoad %6 %45 %58 = OpExtInst %6 %1 Exp %57 OpReturnValue %58 OpFunctionEnd )"; constexpr char kDst[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %63 %69 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "f1(" OpName %10 "f2(" OpName %13 "v" OpName %16 "Buffer" OpMemberName %16 0 "flag1" OpMemberName %16 1 "flag2" OpName %18 "" OpName %34 "v" OpName %63 "color" OpName %69 "v" OpDecorate %8 RelaxedPrecision OpDecorate %10 RelaxedPrecision OpDecorate %13 RelaxedPrecision OpMemberDecorate %16 0 RelaxedPrecision OpMemberDecorate %16 0 Offset 0 OpMemberDecorate %16 1 RelaxedPrecision OpMemberDecorate %16 1 Offset 4 OpDecorate %16 Block OpDecorate %18 DescriptorSet 0 OpDecorate %18 Binding 0 OpDecorate %23 RelaxedPrecision OpDecorate %24 RelaxedPrecision OpDecorate %25 RelaxedPrecision OpDecorate %26 RelaxedPrecision OpDecorate %27 RelaxedPrecision OpDecorate %28 RelaxedPrecision OpDecorate %29 RelaxedPrecision OpDecorate %30 RelaxedPrecision OpDecorate %31 RelaxedPrecision OpDecorate %34 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %38 RelaxedPrecision OpDecorate %40 RelaxedPrecision OpDecorate %41 RelaxedPrecision OpDecorate %44 RelaxedPrecision OpDecorate %45 RelaxedPrecision OpDecorate %46 RelaxedPrecision OpDecorate %48 RelaxedPrecision OpDecorate %55 RelaxedPrecision OpDecorate %56 RelaxedPrecision OpDecorate %57 RelaxedPrecision OpDecorate %58 RelaxedPrecision OpDecorate %63 RelaxedPrecision OpDecorate %63 Location 0 OpDecorate %64 RelaxedPrecision OpDecorate %65 RelaxedPrecision OpDecorate %67 RelaxedPrecision OpDecorate %69 RelaxedPrecision OpDecorate %69 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeFunction %6 %12 = OpTypePointer Function %6 %14 = OpConstant %6 0 %15 = OpTypeInt 32 0 %16 = OpTypeStruct %15 %15 %17 = OpTypePointer Uniform %16 %18 = OpVariable %17 Uniform %19 = OpTypeInt 32 1 %20 = OpConstant %19 1 %21 = OpTypePointer Uniform %15 %35 = OpConstant %19 0 %39 = OpConstant %6 10 %42 = OpConstant %6 0.5 %43 = OpConstant %6 0.699999988 %49 = OpConstant %15 0 %50 = OpTypeBool %54 = OpConstant %6 0.100000001 %61 = OpTypeVector %6 4 %62 = OpTypePointer Output %61 %63 = OpVariable %62 Output %66 = OpConstant %6 1 %68 = OpTypePointer Input %6 %69 = OpVariable %68 Input %4 = OpFunction %2 None %3 %5 = OpLabel %64 = OpFunctionCall %6 %8 %65 = OpFunctionCall %6 %10 %67 = OpCompositeConstruct %61 %64 %65 %14 %66 OpStore %63 %67 OpReturn OpFunctionEnd %8 = OpFunction %6 None %7 %9 = OpLabel %13 = OpVariable %12 Function OpStore %13 %14 %22 = OpAccessChain %21 %18 %20 %23 = OpLoad %15 %22 %24 = OpConvertUToF %6 %23 %25 = OpExtInst %6 %1 Log2 %24 %26 = OpLoad %6 %13 %27 = OpFAdd %6 %26 %25 OpStore %13 %27 %28 = OpLoad %6 %13 %29 = OpLoad %6 %13 %30 = OpExtInst %6 %1 Sqrt %29 %31 = OpFSub %6 %28 %30 OpReturnValue %31 OpFunctionEnd %10 = OpFunction %6 None %7 %11 = OpLabel %34 = OpVariable %12 Function %36 = OpAccessChain %21 %18 %35 %37 = OpLoad %15 %36 %38 = OpConvertUToF %6 %37 %40 = OpFDiv %6 %38 %39 OpStore %34 %40 %41 = OpLoad %6 %34 %44 = OpExtInst %6 %1 FClamp %41 %42 %43 %45 = OpLoad %6 %34 %46 = OpFMul %6 %45 %44 OpStore %34 %46 %47 = OpAccessChain %21 %18 %20 %48 = OpLoad %15 %47 %51 = OpINotEqual %50 %48 %49 OpSelectionMerge %53 None OpBranchConditional %51 %52 %53 %52 = OpLabel %55 = OpLoad %6 %34 %56 = OpFSub %6 %55 %54 OpStore %34 %56 OpBranch %53 %53 = OpLabel %57 = OpLoad %6 %34 %58 = OpExtInst %6 %1 Exp %57 OpReturnValue %58 OpFunctionEnd )"; TEST(DiffTest, ExtraIfBlock) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 69 +; Bound: 77 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %63 %68 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "f1(" OpName %10 "f2(" OpName %13 "v" OpName %16 "Buffer" OpMemberName %16 0 "flag1" OpMemberName %16 1 "flag2" OpName %18 "" OpName %45 "v" OpName %63 "color" OpName %68 "v" OpDecorate %8 RelaxedPrecision OpDecorate %10 RelaxedPrecision OpDecorate %13 RelaxedPrecision OpMemberDecorate %16 0 RelaxedPrecision OpMemberDecorate %16 0 Offset 0 OpMemberDecorate %16 1 RelaxedPrecision OpMemberDecorate %16 1 Offset 4 OpDecorate %16 Block OpDecorate %18 DescriptorSet 0 OpDecorate %18 Binding 0 -OpDecorate %23 RelaxedPrecision -OpDecorate %30 RelaxedPrecision -OpDecorate %31 RelaxedPrecision OpDecorate %34 RelaxedPrecision OpDecorate %35 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %38 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %40 RelaxedPrecision OpDecorate %41 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %45 RelaxedPrecision OpDecorate %47 RelaxedPrecision OpDecorate %48 RelaxedPrecision OpDecorate %50 RelaxedPrecision OpDecorate %51 RelaxedPrecision OpDecorate %54 RelaxedPrecision OpDecorate %55 RelaxedPrecision OpDecorate %56 RelaxedPrecision +OpDecorate %70 RelaxedPrecision OpDecorate %57 RelaxedPrecision +OpDecorate %75 RelaxedPrecision +OpDecorate %76 RelaxedPrecision OpDecorate %58 RelaxedPrecision OpDecorate %63 RelaxedPrecision OpDecorate %63 Location 0 OpDecorate %64 RelaxedPrecision OpDecorate %65 RelaxedPrecision OpDecorate %66 RelaxedPrecision OpDecorate %68 RelaxedPrecision OpDecorate %68 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeFunction %6 %12 = OpTypePointer Function %6 %14 = OpConstant %6 0 %15 = OpTypeInt 32 0 %16 = OpTypeStruct %15 %15 %17 = OpTypePointer Uniform %16 %18 = OpVariable %17 Uniform %19 = OpTypeInt 32 1 %20 = OpConstant %19 0 %21 = OpTypePointer Uniform %15 %24 = OpConstant %15 0 %25 = OpTypeBool %29 = OpConstant %6 1 %32 = OpConstant %19 1 %49 = OpConstant %6 10 %52 = OpConstant %6 0.5 +%74 = OpConstant %6 0.100000001 %53 = OpConstant %6 0.699999988 %61 = OpTypeVector %6 4 %62 = OpTypePointer Output %61 %63 = OpVariable %62 Output %67 = OpTypePointer Input %6 %68 = OpVariable %67 Input %4 = OpFunction %2 None %3 %5 = OpLabel %64 = OpFunctionCall %6 %8 %65 = OpFunctionCall %6 %10 %66 = OpCompositeConstruct %61 %64 %65 %14 %29 OpStore %63 %66 OpReturn OpFunctionEnd %8 = OpFunction %6 None %7 %9 = OpLabel %13 = OpVariable %12 Function OpStore %13 %14 -%22 = OpAccessChain %21 %18 %20 -%23 = OpLoad %15 %22 -%26 = OpINotEqual %25 %23 %24 -OpSelectionMerge %28 None -OpBranchConditional %26 %27 %28 -%27 = OpLabel -%30 = OpLoad %6 %13 -%31 = OpFAdd %6 %30 %29 -OpStore %13 %31 -OpBranch %28 -%28 = OpLabel %33 = OpAccessChain %21 %18 %32 %34 = OpLoad %15 %33 %35 = OpConvertUToF %6 %34 %36 = OpExtInst %6 %1 Log2 %35 %37 = OpLoad %6 %13 %38 = OpFAdd %6 %37 %36 OpStore %13 %38 %39 = OpLoad %6 %13 %40 = OpLoad %6 %13 %41 = OpExtInst %6 %1 Sqrt %40 %42 = OpFSub %6 %39 %41 OpReturnValue %42 OpFunctionEnd %10 = OpFunction %6 None %7 %11 = OpLabel %45 = OpVariable %12 Function %46 = OpAccessChain %21 %18 %20 %47 = OpLoad %15 %46 %48 = OpConvertUToF %6 %47 %50 = OpFDiv %6 %48 %49 OpStore %45 %50 %51 = OpLoad %6 %45 %54 = OpExtInst %6 %1 FClamp %51 %52 %53 %55 = OpLoad %6 %45 %56 = OpFMul %6 %55 %54 OpStore %45 %56 +%69 = OpAccessChain %21 %18 %32 +%70 = OpLoad %15 %69 +%71 = OpINotEqual %25 %70 %24 +OpSelectionMerge %73 None +OpBranchConditional %71 %72 %73 +%72 = OpLabel %57 = OpLoad %6 %45 +%75 = OpFSub %6 %57 %74 +OpStore %45 %75 +OpBranch %73 +%73 = OpLabel +%76 = OpLoad %6 %45 -%58 = OpExtInst %6 %1 Exp %57 +%58 = OpExtInst %6 %1 Exp %76 OpReturnValue %58 OpFunctionEnd )"; Options options; DoStringDiffTest(kSrc, kDst, kDiff, options); } TEST(DiffTest, ExtraIfBlockNoDebug) { constexpr char kSrcNoDebug[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %63 %68 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %8 RelaxedPrecision OpDecorate %10 RelaxedPrecision OpDecorate %13 RelaxedPrecision OpMemberDecorate %16 0 RelaxedPrecision OpMemberDecorate %16 0 Offset 0 OpMemberDecorate %16 1 RelaxedPrecision OpMemberDecorate %16 1 Offset 4 OpDecorate %16 Block OpDecorate %18 DescriptorSet 0 OpDecorate %18 Binding 0 OpDecorate %23 RelaxedPrecision OpDecorate %30 RelaxedPrecision OpDecorate %31 RelaxedPrecision OpDecorate %34 RelaxedPrecision OpDecorate %35 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %38 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %40 RelaxedPrecision OpDecorate %41 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %45 RelaxedPrecision OpDecorate %47 RelaxedPrecision OpDecorate %48 RelaxedPrecision OpDecorate %50 RelaxedPrecision OpDecorate %51 RelaxedPrecision OpDecorate %54 RelaxedPrecision OpDecorate %55 RelaxedPrecision OpDecorate %56 RelaxedPrecision OpDecorate %57 RelaxedPrecision OpDecorate %58 RelaxedPrecision OpDecorate %63 RelaxedPrecision OpDecorate %63 Location 0 OpDecorate %64 RelaxedPrecision OpDecorate %65 RelaxedPrecision OpDecorate %66 RelaxedPrecision OpDecorate %68 RelaxedPrecision OpDecorate %68 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeFunction %6 %12 = OpTypePointer Function %6 %14 = OpConstant %6 0 %15 = OpTypeInt 32 0 %16 = OpTypeStruct %15 %15 %17 = OpTypePointer Uniform %16 %18 = OpVariable %17 Uniform %19 = OpTypeInt 32 1 %20 = OpConstant %19 0 %21 = OpTypePointer Uniform %15 %24 = OpConstant %15 0 %25 = OpTypeBool %29 = OpConstant %6 1 %32 = OpConstant %19 1 %49 = OpConstant %6 10 %52 = OpConstant %6 0.5 %53 = OpConstant %6 0.699999988 %61 = OpTypeVector %6 4 %62 = OpTypePointer Output %61 %63 = OpVariable %62 Output %67 = OpTypePointer Input %6 %68 = OpVariable %67 Input %4 = OpFunction %2 None %3 %5 = OpLabel %64 = OpFunctionCall %6 %8 %65 = OpFunctionCall %6 %10 %66 = OpCompositeConstruct %61 %64 %65 %14 %29 OpStore %63 %66 OpReturn OpFunctionEnd %8 = OpFunction %6 None %7 %9 = OpLabel %13 = OpVariable %12 Function OpStore %13 %14 %22 = OpAccessChain %21 %18 %20 %23 = OpLoad %15 %22 %26 = OpINotEqual %25 %23 %24 OpSelectionMerge %28 None OpBranchConditional %26 %27 %28 %27 = OpLabel %30 = OpLoad %6 %13 %31 = OpFAdd %6 %30 %29 OpStore %13 %31 OpBranch %28 %28 = OpLabel %33 = OpAccessChain %21 %18 %32 %34 = OpLoad %15 %33 %35 = OpConvertUToF %6 %34 %36 = OpExtInst %6 %1 Log2 %35 %37 = OpLoad %6 %13 %38 = OpFAdd %6 %37 %36 OpStore %13 %38 %39 = OpLoad %6 %13 %40 = OpLoad %6 %13 %41 = OpExtInst %6 %1 Sqrt %40 %42 = OpFSub %6 %39 %41 OpReturnValue %42 OpFunctionEnd %10 = OpFunction %6 None %7 %11 = OpLabel %45 = OpVariable %12 Function %46 = OpAccessChain %21 %18 %20 %47 = OpLoad %15 %46 %48 = OpConvertUToF %6 %47 %50 = OpFDiv %6 %48 %49 OpStore %45 %50 %51 = OpLoad %6 %45 %54 = OpExtInst %6 %1 FClamp %51 %52 %53 %55 = OpLoad %6 %45 %56 = OpFMul %6 %55 %54 OpStore %45 %56 %57 = OpLoad %6 %45 %58 = OpExtInst %6 %1 Exp %57 OpReturnValue %58 OpFunctionEnd )"; constexpr char kDstNoDebug[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %63 %69 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %8 RelaxedPrecision OpDecorate %10 RelaxedPrecision OpDecorate %13 RelaxedPrecision OpMemberDecorate %16 0 RelaxedPrecision OpMemberDecorate %16 0 Offset 0 OpMemberDecorate %16 1 RelaxedPrecision OpMemberDecorate %16 1 Offset 4 OpDecorate %16 Block OpDecorate %18 DescriptorSet 0 OpDecorate %18 Binding 0 OpDecorate %23 RelaxedPrecision OpDecorate %24 RelaxedPrecision OpDecorate %25 RelaxedPrecision OpDecorate %26 RelaxedPrecision OpDecorate %27 RelaxedPrecision OpDecorate %28 RelaxedPrecision OpDecorate %29 RelaxedPrecision OpDecorate %30 RelaxedPrecision OpDecorate %31 RelaxedPrecision OpDecorate %34 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %38 RelaxedPrecision OpDecorate %40 RelaxedPrecision OpDecorate %41 RelaxedPrecision OpDecorate %44 RelaxedPrecision OpDecorate %45 RelaxedPrecision OpDecorate %46 RelaxedPrecision OpDecorate %48 RelaxedPrecision OpDecorate %55 RelaxedPrecision OpDecorate %56 RelaxedPrecision OpDecorate %57 RelaxedPrecision OpDecorate %58 RelaxedPrecision OpDecorate %63 RelaxedPrecision OpDecorate %63 Location 0 OpDecorate %64 RelaxedPrecision OpDecorate %65 RelaxedPrecision OpDecorate %67 RelaxedPrecision OpDecorate %69 RelaxedPrecision OpDecorate %69 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeFunction %6 %12 = OpTypePointer Function %6 %14 = OpConstant %6 0 %15 = OpTypeInt 32 0 %16 = OpTypeStruct %15 %15 %17 = OpTypePointer Uniform %16 %18 = OpVariable %17 Uniform %19 = OpTypeInt 32 1 %20 = OpConstant %19 1 %21 = OpTypePointer Uniform %15 %35 = OpConstant %19 0 %39 = OpConstant %6 10 %42 = OpConstant %6 0.5 %43 = OpConstant %6 0.699999988 %49 = OpConstant %15 0 %50 = OpTypeBool %54 = OpConstant %6 0.100000001 %61 = OpTypeVector %6 4 %62 = OpTypePointer Output %61 %63 = OpVariable %62 Output %66 = OpConstant %6 1 %68 = OpTypePointer Input %6 %69 = OpVariable %68 Input %4 = OpFunction %2 None %3 %5 = OpLabel %64 = OpFunctionCall %6 %8 %65 = OpFunctionCall %6 %10 %67 = OpCompositeConstruct %61 %64 %65 %14 %66 OpStore %63 %67 OpReturn OpFunctionEnd %8 = OpFunction %6 None %7 %9 = OpLabel %13 = OpVariable %12 Function OpStore %13 %14 %22 = OpAccessChain %21 %18 %20 %23 = OpLoad %15 %22 %24 = OpConvertUToF %6 %23 %25 = OpExtInst %6 %1 Log2 %24 %26 = OpLoad %6 %13 %27 = OpFAdd %6 %26 %25 OpStore %13 %27 %28 = OpLoad %6 %13 %29 = OpLoad %6 %13 %30 = OpExtInst %6 %1 Sqrt %29 %31 = OpFSub %6 %28 %30 OpReturnValue %31 OpFunctionEnd %10 = OpFunction %6 None %7 %11 = OpLabel %34 = OpVariable %12 Function %36 = OpAccessChain %21 %18 %35 %37 = OpLoad %15 %36 %38 = OpConvertUToF %6 %37 %40 = OpFDiv %6 %38 %39 OpStore %34 %40 %41 = OpLoad %6 %34 %44 = OpExtInst %6 %1 FClamp %41 %42 %43 %45 = OpLoad %6 %34 %46 = OpFMul %6 %45 %44 OpStore %34 %46 %47 = OpAccessChain %21 %18 %20 %48 = OpLoad %15 %47 %51 = OpINotEqual %50 %48 %49 OpSelectionMerge %53 None OpBranchConditional %51 %52 %53 %52 = OpLabel %55 = OpLoad %6 %34 %56 = OpFSub %6 %55 %54 OpStore %34 %56 OpBranch %53 %53 = OpLabel %57 = OpLoad %6 %34 %58 = OpExtInst %6 %1 Exp %57 OpReturnValue %58 OpFunctionEnd )"; constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 69 +; Bound: 77 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %63 %68 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %8 RelaxedPrecision OpDecorate %10 RelaxedPrecision OpDecorate %13 RelaxedPrecision OpMemberDecorate %16 0 RelaxedPrecision OpMemberDecorate %16 0 Offset 0 OpMemberDecorate %16 1 RelaxedPrecision OpMemberDecorate %16 1 Offset 4 OpDecorate %16 Block OpDecorate %18 DescriptorSet 0 OpDecorate %18 Binding 0 -OpDecorate %23 RelaxedPrecision -OpDecorate %30 RelaxedPrecision -OpDecorate %31 RelaxedPrecision OpDecorate %34 RelaxedPrecision OpDecorate %35 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %38 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %40 RelaxedPrecision OpDecorate %41 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %45 RelaxedPrecision OpDecorate %47 RelaxedPrecision OpDecorate %48 RelaxedPrecision OpDecorate %50 RelaxedPrecision OpDecorate %51 RelaxedPrecision OpDecorate %54 RelaxedPrecision OpDecorate %55 RelaxedPrecision OpDecorate %56 RelaxedPrecision +OpDecorate %70 RelaxedPrecision OpDecorate %57 RelaxedPrecision +OpDecorate %75 RelaxedPrecision +OpDecorate %76 RelaxedPrecision OpDecorate %58 RelaxedPrecision OpDecorate %63 RelaxedPrecision OpDecorate %63 Location 0 OpDecorate %64 RelaxedPrecision OpDecorate %65 RelaxedPrecision OpDecorate %66 RelaxedPrecision OpDecorate %68 RelaxedPrecision OpDecorate %68 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeFunction %6 %12 = OpTypePointer Function %6 %14 = OpConstant %6 0 %15 = OpTypeInt 32 0 %16 = OpTypeStruct %15 %15 %17 = OpTypePointer Uniform %16 %18 = OpVariable %17 Uniform %19 = OpTypeInt 32 1 %20 = OpConstant %19 0 %21 = OpTypePointer Uniform %15 %24 = OpConstant %15 0 %25 = OpTypeBool %29 = OpConstant %6 1 %32 = OpConstant %19 1 %49 = OpConstant %6 10 %52 = OpConstant %6 0.5 +%74 = OpConstant %6 0.100000001 %53 = OpConstant %6 0.699999988 %61 = OpTypeVector %6 4 %62 = OpTypePointer Output %61 %63 = OpVariable %62 Output %67 = OpTypePointer Input %6 %68 = OpVariable %67 Input %4 = OpFunction %2 None %3 %5 = OpLabel %64 = OpFunctionCall %6 %8 %65 = OpFunctionCall %6 %10 %66 = OpCompositeConstruct %61 %64 %65 %14 %29 OpStore %63 %66 OpReturn OpFunctionEnd %8 = OpFunction %6 None %7 %9 = OpLabel %13 = OpVariable %12 Function OpStore %13 %14 -%22 = OpAccessChain %21 %18 %20 -%23 = OpLoad %15 %22 -%26 = OpINotEqual %25 %23 %24 -OpSelectionMerge %28 None -OpBranchConditional %26 %27 %28 -%27 = OpLabel -%30 = OpLoad %6 %13 -%31 = OpFAdd %6 %30 %29 -OpStore %13 %31 -OpBranch %28 -%28 = OpLabel %33 = OpAccessChain %21 %18 %32 %34 = OpLoad %15 %33 %35 = OpConvertUToF %6 %34 %36 = OpExtInst %6 %1 Log2 %35 %37 = OpLoad %6 %13 %38 = OpFAdd %6 %37 %36 OpStore %13 %38 %39 = OpLoad %6 %13 %40 = OpLoad %6 %13 %41 = OpExtInst %6 %1 Sqrt %40 %42 = OpFSub %6 %39 %41 OpReturnValue %42 OpFunctionEnd %10 = OpFunction %6 None %7 %11 = OpLabel %45 = OpVariable %12 Function %46 = OpAccessChain %21 %18 %20 %47 = OpLoad %15 %46 %48 = OpConvertUToF %6 %47 %50 = OpFDiv %6 %48 %49 OpStore %45 %50 %51 = OpLoad %6 %45 %54 = OpExtInst %6 %1 FClamp %51 %52 %53 %55 = OpLoad %6 %45 %56 = OpFMul %6 %55 %54 OpStore %45 %56 +%69 = OpAccessChain %21 %18 %32 +%70 = OpLoad %15 %69 +%71 = OpINotEqual %25 %70 %24 +OpSelectionMerge %73 None +OpBranchConditional %71 %72 %73 +%72 = OpLabel %57 = OpLoad %6 %45 +%75 = OpFSub %6 %57 %74 +OpStore %45 %75 +OpBranch %73 +%73 = OpLabel +%76 = OpLoad %6 %45 -%58 = OpExtInst %6 %1 Exp %57 +%58 = OpExtInst %6 %1 Exp %76 OpReturnValue %58 OpFunctionEnd )"; Options options; DoStringDiffTest(kSrcNoDebug, kDstNoDebug, kDiff, options); } } // namespace } // namespace diff } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/extra_if_block_dst.spvasm000066400000000000000000000117741475742701700276040ustar00rootroot00000000000000 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %63 %69 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "f1(" OpName %10 "f2(" OpName %13 "v" OpName %16 "Buffer" OpMemberName %16 0 "flag1" OpMemberName %16 1 "flag2" OpName %18 "" OpName %34 "v" OpName %63 "color" OpName %69 "v" OpDecorate %8 RelaxedPrecision OpDecorate %10 RelaxedPrecision OpDecorate %13 RelaxedPrecision OpMemberDecorate %16 0 RelaxedPrecision OpMemberDecorate %16 0 Offset 0 OpMemberDecorate %16 1 RelaxedPrecision OpMemberDecorate %16 1 Offset 4 OpDecorate %16 Block OpDecorate %18 DescriptorSet 0 OpDecorate %18 Binding 0 OpDecorate %23 RelaxedPrecision OpDecorate %24 RelaxedPrecision OpDecorate %25 RelaxedPrecision OpDecorate %26 RelaxedPrecision OpDecorate %27 RelaxedPrecision OpDecorate %28 RelaxedPrecision OpDecorate %29 RelaxedPrecision OpDecorate %30 RelaxedPrecision OpDecorate %31 RelaxedPrecision OpDecorate %34 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %38 RelaxedPrecision OpDecorate %40 RelaxedPrecision OpDecorate %41 RelaxedPrecision OpDecorate %44 RelaxedPrecision OpDecorate %45 RelaxedPrecision OpDecorate %46 RelaxedPrecision OpDecorate %48 RelaxedPrecision OpDecorate %55 RelaxedPrecision OpDecorate %56 RelaxedPrecision OpDecorate %57 RelaxedPrecision OpDecorate %58 RelaxedPrecision OpDecorate %63 RelaxedPrecision OpDecorate %63 Location 0 OpDecorate %64 RelaxedPrecision OpDecorate %65 RelaxedPrecision OpDecorate %67 RelaxedPrecision OpDecorate %69 RelaxedPrecision OpDecorate %69 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeFunction %6 %12 = OpTypePointer Function %6 %14 = OpConstant %6 0 %15 = OpTypeInt 32 0 %16 = OpTypeStruct %15 %15 %17 = OpTypePointer Uniform %16 %18 = OpVariable %17 Uniform %19 = OpTypeInt 32 1 %20 = OpConstant %19 1 %21 = OpTypePointer Uniform %15 %35 = OpConstant %19 0 %39 = OpConstant %6 10 %42 = OpConstant %6 0.5 %43 = OpConstant %6 0.699999988 %49 = OpConstant %15 0 %50 = OpTypeBool %54 = OpConstant %6 0.100000001 %61 = OpTypeVector %6 4 %62 = OpTypePointer Output %61 %63 = OpVariable %62 Output %66 = OpConstant %6 1 %68 = OpTypePointer Input %6 %69 = OpVariable %68 Input %4 = OpFunction %2 None %3 %5 = OpLabel %64 = OpFunctionCall %6 %8 %65 = OpFunctionCall %6 %10 %67 = OpCompositeConstruct %61 %64 %65 %14 %66 OpStore %63 %67 OpReturn OpFunctionEnd %8 = OpFunction %6 None %7 %9 = OpLabel %13 = OpVariable %12 Function OpStore %13 %14 %22 = OpAccessChain %21 %18 %20 %23 = OpLoad %15 %22 %24 = OpConvertUToF %6 %23 %25 = OpExtInst %6 %1 Log2 %24 %26 = OpLoad %6 %13 %27 = OpFAdd %6 %26 %25 OpStore %13 %27 %28 = OpLoad %6 %13 %29 = OpLoad %6 %13 %30 = OpExtInst %6 %1 Sqrt %29 %31 = OpFSub %6 %28 %30 OpReturnValue %31 OpFunctionEnd %10 = OpFunction %6 None %7 %11 = OpLabel %34 = OpVariable %12 Function %36 = OpAccessChain %21 %18 %35 %37 = OpLoad %15 %36 %38 = OpConvertUToF %6 %37 %40 = OpFDiv %6 %38 %39 OpStore %34 %40 %41 = OpLoad %6 %34 %44 = OpExtInst %6 %1 FClamp %41 %42 %43 %45 = OpLoad %6 %34 %46 = OpFMul %6 %45 %44 OpStore %34 %46 %47 = OpAccessChain %21 %18 %20 %48 = OpLoad %15 %47 %51 = OpINotEqual %50 %48 %49 OpSelectionMerge %53 None OpBranchConditional %51 %52 %53 %52 = OpLabel %55 = OpLoad %6 %34 %56 = OpFSub %6 %55 %54 OpStore %34 %56 OpBranch %53 %53 = OpLabel %57 = OpLoad %6 %34 %58 = OpExtInst %6 %1 Exp %57 OpReturnValue %58 OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/extra_if_block_src.spvasm000066400000000000000000000121021475742701700275630ustar00rootroot00000000000000;; Test where src has an extra if block in one function, and dst has an extra ;; if block in another function. OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %63 %68 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "f1(" OpName %10 "f2(" OpName %13 "v" OpName %16 "Buffer" OpMemberName %16 0 "flag1" OpMemberName %16 1 "flag2" OpName %18 "" OpName %45 "v" OpName %63 "color" OpName %68 "v" OpDecorate %8 RelaxedPrecision OpDecorate %10 RelaxedPrecision OpDecorate %13 RelaxedPrecision OpMemberDecorate %16 0 RelaxedPrecision OpMemberDecorate %16 0 Offset 0 OpMemberDecorate %16 1 RelaxedPrecision OpMemberDecorate %16 1 Offset 4 OpDecorate %16 Block OpDecorate %18 DescriptorSet 0 OpDecorate %18 Binding 0 OpDecorate %23 RelaxedPrecision OpDecorate %30 RelaxedPrecision OpDecorate %31 RelaxedPrecision OpDecorate %34 RelaxedPrecision OpDecorate %35 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %38 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %40 RelaxedPrecision OpDecorate %41 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %45 RelaxedPrecision OpDecorate %47 RelaxedPrecision OpDecorate %48 RelaxedPrecision OpDecorate %50 RelaxedPrecision OpDecorate %51 RelaxedPrecision OpDecorate %54 RelaxedPrecision OpDecorate %55 RelaxedPrecision OpDecorate %56 RelaxedPrecision OpDecorate %57 RelaxedPrecision OpDecorate %58 RelaxedPrecision OpDecorate %63 RelaxedPrecision OpDecorate %63 Location 0 OpDecorate %64 RelaxedPrecision OpDecorate %65 RelaxedPrecision OpDecorate %66 RelaxedPrecision OpDecorate %68 RelaxedPrecision OpDecorate %68 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeFunction %6 %12 = OpTypePointer Function %6 %14 = OpConstant %6 0 %15 = OpTypeInt 32 0 %16 = OpTypeStruct %15 %15 %17 = OpTypePointer Uniform %16 %18 = OpVariable %17 Uniform %19 = OpTypeInt 32 1 %20 = OpConstant %19 0 %21 = OpTypePointer Uniform %15 %24 = OpConstant %15 0 %25 = OpTypeBool %29 = OpConstant %6 1 %32 = OpConstant %19 1 %49 = OpConstant %6 10 %52 = OpConstant %6 0.5 %53 = OpConstant %6 0.699999988 %61 = OpTypeVector %6 4 %62 = OpTypePointer Output %61 %63 = OpVariable %62 Output %67 = OpTypePointer Input %6 %68 = OpVariable %67 Input %4 = OpFunction %2 None %3 %5 = OpLabel %64 = OpFunctionCall %6 %8 %65 = OpFunctionCall %6 %10 %66 = OpCompositeConstruct %61 %64 %65 %14 %29 OpStore %63 %66 OpReturn OpFunctionEnd %8 = OpFunction %6 None %7 %9 = OpLabel %13 = OpVariable %12 Function OpStore %13 %14 %22 = OpAccessChain %21 %18 %20 %23 = OpLoad %15 %22 %26 = OpINotEqual %25 %23 %24 OpSelectionMerge %28 None OpBranchConditional %26 %27 %28 %27 = OpLabel %30 = OpLoad %6 %13 %31 = OpFAdd %6 %30 %29 OpStore %13 %31 OpBranch %28 %28 = OpLabel %33 = OpAccessChain %21 %18 %32 %34 = OpLoad %15 %33 %35 = OpConvertUToF %6 %34 %36 = OpExtInst %6 %1 Log2 %35 %37 = OpLoad %6 %13 %38 = OpFAdd %6 %37 %36 OpStore %13 %38 %39 = OpLoad %6 %13 %40 = OpLoad %6 %13 %41 = OpExtInst %6 %1 Sqrt %40 %42 = OpFSub %6 %39 %41 OpReturnValue %42 OpFunctionEnd %10 = OpFunction %6 None %7 %11 = OpLabel %45 = OpVariable %12 Function %46 = OpAccessChain %21 %18 %20 %47 = OpLoad %15 %46 %48 = OpConvertUToF %6 %47 %50 = OpFDiv %6 %48 %49 OpStore %45 %50 %51 = OpLoad %6 %45 %54 = OpExtInst %6 %1 FClamp %51 %52 %53 %55 = OpLoad %6 %45 %56 = OpFMul %6 %55 %54 OpStore %45 %56 %57 = OpLoad %6 %45 %58 = OpExtInst %6 %1 Exp %57 OpReturnValue %58 OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/generate_tests.py000077500000000000000000000233061475742701700261070ustar00rootroot00000000000000#! /usr/bin/python3 # # Copyright (c) 2022 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import glob import os import subprocess import sys # A handful of relevant tests are hand-picked to generate extra unit tests with # specific options of spirv-diff. IGNORE_SET_BINDING_TESTS = ['different_decorations_vertex'] IGNORE_LOCATION_TESTS = ['different_decorations_fragment'] IGNORE_DECORATIONS_TESTS = ['different_decorations_vertex', 'different_decorations_fragment'] DUMP_IDS_TESTS = ['basic', 'int_vs_uint_constants', 'multiple_same_entry_points', 'small_functions_small_diffs'] LICENSE = u"""Copyright (c) 2022 Google LLC. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. """ TEMPLATE_TEST_FILE = u"""// GENERATED FILE - DO NOT EDIT. // Generated by {script_name} // {license} #include "../diff_test_utils.h" #include "gtest/gtest.h" namespace spvtools {{ namespace diff {{ namespace {{ {test_comment} constexpr char kSrc[] = R"({src_spirv})"; constexpr char kDst[] = R"({dst_spirv})"; TEST(DiffTest, {test_name}) {{ constexpr char kDiff[] = R"({diff_spirv})"; Options options; DoStringDiffTest(kSrc, kDst, kDiff, options); }} TEST(DiffTest, {test_name}NoDebug) {{ constexpr char kSrcNoDebug[] = R"({src_spirv_no_debug})"; constexpr char kDstNoDebug[] = R"({dst_spirv_no_debug})"; constexpr char kDiff[] = R"({diff_spirv_no_debug})"; Options options; DoStringDiffTest(kSrcNoDebug, kDstNoDebug, kDiff, options); }} {extra_tests} }} // namespace }} // namespace diff }} // namespace spvtools """ TEMPLATE_TEST_FUNC = u""" TEST(DiffTest, {test_name}{test_tag}) {{ constexpr char kDiff[] = R"({diff_spirv})"; Options options; {test_options} DoStringDiffTest(kSrc, kDst, kDiff, options); }} """ TEMPLATE_TEST_FILES_CMAKE = u"""# GENERATED FILE - DO NOT EDIT. # Generated by {script_name} # {license} list(APPEND DIFF_TEST_FILES {test_files} ) """ VARIANT_NONE = 0 VARIANT_IGNORE_SET_BINDING = 1 VARIANT_IGNORE_LOCATION = 2 VARIANT_IGNORE_DECORATIONS = 3 VARIANT_DUMP_IDS = 4 def print_usage(): print("Usage: {} ".format(sys.argv[0])) def remove_debug_info(in_path): tmp_dir = '.no_dbg' if not os.path.exists(tmp_dir): os.makedirs(tmp_dir) (in_basename, in_ext) = os.path.splitext(in_path) out_name = in_basename + '_no_dbg' + in_ext out_path = os.path.join(tmp_dir, out_name) with open(in_path, 'r') as fin: with open(out_path, 'w') as fout: for line in fin: ops = line.strip().split() op = ops[0] if len(ops) > 0 else '' if (op != ';;' and op != 'OpName' and op != 'OpMemberName' and op != 'OpString' and op != 'OpLine' and op != 'OpNoLine' and op != 'OpModuleProcessed'): fout.write(line) return out_path def make_src_file(test_name): return '{}_src.spvasm'.format(test_name) def make_dst_file(test_name): return '{}_dst.spvasm'.format(test_name) def make_cpp_file(test_name): return '{}_autogen.cpp'.format(test_name) def make_camel_case(test_name): return test_name.replace('_', ' ').title().replace(' ', '') def make_comment(text, comment_prefix): return '\n'.join([comment_prefix + (' ' if line.strip() else '') + line for line in text.splitlines()]) def read_file(file_name): with open(file_name, 'r') as f: content = f.read() # Use unix line endings. content = content.replace('\r\n', '\n') return content def parse_test_comment(src_spirv_file_name, src_spirv): src_spirv_lines = src_spirv.splitlines() comment_line_count = 0 while comment_line_count < len(src_spirv_lines): if not src_spirv_lines[comment_line_count].strip().startswith(';;'): break comment_line_count += 1 if comment_line_count == 0: print("Expected comment on test file '{}'. See README.md next to this file.".format(src_spirv_file_name)) sys.exit(1) comment_block = src_spirv_lines[:comment_line_count] spirv_block = src_spirv_lines[comment_line_count:] comment_block = ['// ' + line.replace(';;', '').strip() for line in comment_block] return '\n'.join(spirv_block), '\n'.join(comment_block) def run_diff_tool(diff_tool, src_file, dst_file, variant): args = [diff_tool] if variant == VARIANT_IGNORE_SET_BINDING or variant == VARIANT_IGNORE_DECORATIONS: args.append('--ignore-set-binding') if variant == VARIANT_IGNORE_LOCATION or variant == VARIANT_IGNORE_DECORATIONS: args.append('--ignore-location') if variant == VARIANT_DUMP_IDS: args.append('--with-id-map') args.append('--no-color') args.append('--no-indent') args.append(src_file) args.append(dst_file) success = True print(' '.join(args)) process = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True) out, err = process.communicate() if process.returncode != 0: print(err) sys.exit(process.returncode) # Use unix line endings. out = out.replace('\r\n', '\n') return out def generate_extra_test(diff_tool, src_file, dst_file, variant, test_name_camel_case, test_tag, test_options): diff = run_diff_tool(diff_tool, src_file, dst_file, variant) return TEMPLATE_TEST_FUNC.format( test_name = test_name_camel_case, test_tag = test_tag, test_options = test_options, diff_spirv = diff) def generate_test(diff_tool, test_name): src_file = make_src_file(test_name) dst_file = make_dst_file(test_name) src_file_no_debug = remove_debug_info(src_file) dst_file_no_debug = remove_debug_info(dst_file) src_spirv = read_file(src_file) dst_spirv = read_file(dst_file) src_spirv_no_debug = read_file(src_file_no_debug) dst_spirv_no_debug = read_file(dst_file_no_debug) test_name_camel_case = make_camel_case(test_name) diff_spirv = run_diff_tool(diff_tool, src_file, dst_file, VARIANT_NONE) diff_spirv_no_debug = run_diff_tool(diff_tool, src_file_no_debug, dst_file_no_debug, VARIANT_NONE) extra_tests = [] if test_name in IGNORE_SET_BINDING_TESTS: extra_tests.append(generate_extra_test(diff_tool, src_file, dst_file, VARIANT_IGNORE_SET_BINDING, test_name_camel_case, 'IgnoreSetBinding', 'options.ignore_set_binding = true;')) if test_name in IGNORE_LOCATION_TESTS: extra_tests.append(generate_extra_test(diff_tool, src_file, dst_file, VARIANT_IGNORE_LOCATION, test_name_camel_case, 'IgnoreLocation', 'options.ignore_location = true;')) if test_name in IGNORE_DECORATIONS_TESTS: extra_tests.append(generate_extra_test(diff_tool, src_file, dst_file, VARIANT_IGNORE_DECORATIONS, test_name_camel_case, 'IgnoreSetBindingLocation', '\n '.join(['options.ignore_set_binding = true;', 'options.ignore_location = true;']))) if test_name in DUMP_IDS_TESTS: extra_tests.append(generate_extra_test(diff_tool, src_file, dst_file, VARIANT_DUMP_IDS, test_name_camel_case, 'DumpIds', 'options.dump_id_map = true;')) src_spirv, test_comment = parse_test_comment(src_file, src_spirv) test_file = TEMPLATE_TEST_FILE.format( script_name = os.path.basename(__file__), license = make_comment(LICENSE, '//'), test_comment = test_comment, test_name = test_name_camel_case, src_spirv = src_spirv, dst_spirv = dst_spirv, diff_spirv = diff_spirv, src_spirv_no_debug = src_spirv_no_debug, dst_spirv_no_debug = dst_spirv_no_debug, diff_spirv_no_debug = diff_spirv_no_debug, extra_tests = ''.join(extra_tests)) test_file_name = make_cpp_file(test_name) with open(test_file_name, 'wb') as fout: fout.write(str.encode(test_file)) return test_file_name def generate_tests(diff_tool, test_names): return [generate_test(diff_tool, test_name) for test_name in test_names] def generate_cmake(test_files): cmake = TEMPLATE_TEST_FILES_CMAKE.format( script_name = os.path.basename(__file__), license = make_comment(LICENSE, '#'), test_files = '\n'.join(['"diff_files/{}"'.format(f) for f in test_files])) with open('diff_test_files_autogen.cmake', 'wb') as fout: fout.write(str.encode(cmake)) def main(): if len(sys.argv) != 2: print_usage() return 1 diff_tool = sys.argv[1] if not os.path.exists(diff_tool): print("No such file: {}".format(diff_tool)) print_usage() return 1 diff_tool = os.path.realpath(diff_tool) os.chdir(os.path.dirname(__file__)) test_names = sorted([f[:-11] for f in glob.glob("*_src.spvasm")]) test_files = generate_tests(diff_tool, test_names) generate_cmake(test_files) return 0 if __name__ == '__main__': sys.exit(main()) KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/index_signedness_autogen.cpp000066400000000000000000000601351475742701700302760ustar00rootroot00000000000000// GENERATED FILE - DO NOT EDIT. // Generated by generate_tests.py // // Copyright (c) 2022 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "../diff_test_utils.h" #include "gtest/gtest.h" namespace spvtools { namespace diff { namespace { // Test where signedness of indices are different between src and dst. constexpr char kSrc[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpName %4 "main" OpName %13 "BufferOut" OpMemberName %13 0 "o1" OpMemberName %13 1 "o2" OpMemberName %13 2 "o3" OpName %15 "" OpName %22 "BufferIn" OpMemberName %22 0 "i1" OpMemberName %22 1 "i2" OpName %24 "" OpDecorate %8 ArrayStride 4 OpDecorate %9 ArrayStride 4 OpDecorate %11 ArrayStride 4 OpDecorate %12 ArrayStride 8 OpMemberDecorate %13 0 Offset 0 OpMemberDecorate %13 1 Offset 12 OpMemberDecorate %13 2 Offset 24 OpDecorate %13 BufferBlock OpDecorate %15 DescriptorSet 0 OpDecorate %15 Binding 1 OpDecorate %18 ArrayStride 16 OpDecorate %19 ArrayStride 48 OpDecorate %21 ArrayStride 16 OpMemberDecorate %22 0 Offset 0 OpMemberDecorate %22 1 Offset 96 OpDecorate %22 Block OpDecorate %24 DescriptorSet 0 OpDecorate %24 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpConstant %6 3 %8 = OpTypeArray %6 %7 %9 = OpTypeArray %6 %7 %10 = OpConstant %6 2 %11 = OpTypeArray %6 %10 %12 = OpTypeArray %11 %10 %13 = OpTypeStruct %8 %9 %12 %14 = OpTypePointer Uniform %13 %15 = OpVariable %14 Uniform %16 = OpTypeInt 32 1 %17 = OpConstant %16 0 %18 = OpTypeArray %6 %7 %19 = OpTypeArray %18 %10 %20 = OpConstant %6 4 %21 = OpTypeArray %6 %20 %22 = OpTypeStruct %19 %21 %23 = OpTypePointer Uniform %22 %24 = OpVariable %23 Uniform %25 = OpTypePointer Uniform %6 %28 = OpConstant %6 1 %31 = OpConstant %16 1 %34 = OpConstant %6 0 %37 = OpConstant %16 2 %61 = OpConstant %16 3 %4 = OpFunction %2 None %3 %5 = OpLabel %26 = OpAccessChain %25 %24 %17 %17 %17 %27 = OpLoad %6 %26 %29 = OpIAdd %6 %27 %28 %30 = OpAccessChain %25 %15 %17 %17 OpStore %30 %29 %32 = OpAccessChain %25 %24 %17 %31 %17 %33 = OpLoad %6 %32 %35 = OpIAdd %6 %33 %34 %36 = OpAccessChain %25 %15 %17 %31 OpStore %36 %35 %38 = OpAccessChain %25 %24 %17 %31 %31 %39 = OpLoad %6 %38 %40 = OpIAdd %6 %39 %10 %41 = OpAccessChain %25 %15 %17 %37 OpStore %41 %40 %42 = OpAccessChain %25 %24 %17 %17 %37 %43 = OpLoad %6 %42 %44 = OpAccessChain %25 %15 %31 %17 OpStore %44 %43 %45 = OpAccessChain %25 %24 %17 %17 %31 %46 = OpLoad %6 %45 %47 = OpIMul %6 %46 %7 %48 = OpAccessChain %25 %15 %31 %31 OpStore %48 %47 %49 = OpAccessChain %25 %24 %17 %31 %37 %50 = OpLoad %6 %49 %51 = OpAccessChain %25 %15 %31 %37 OpStore %51 %50 %52 = OpAccessChain %25 %24 %31 %17 %53 = OpLoad %6 %52 %54 = OpAccessChain %25 %15 %37 %17 %17 OpStore %54 %53 %55 = OpAccessChain %25 %24 %31 %31 %56 = OpLoad %6 %55 %57 = OpAccessChain %25 %15 %37 %17 %31 OpStore %57 %56 %58 = OpAccessChain %25 %24 %31 %37 %59 = OpLoad %6 %58 %60 = OpAccessChain %25 %15 %37 %31 %17 OpStore %60 %59 %62 = OpAccessChain %25 %24 %31 %61 %63 = OpLoad %6 %62 %64 = OpAccessChain %25 %15 %37 %31 %31 OpStore %64 %63 OpReturn OpFunctionEnd )"; constexpr char kDst[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpName %4 "main" OpName %13 "BufferOut" OpMemberName %13 0 "o1" OpMemberName %13 1 "o2" OpMemberName %13 2 "o3" OpName %15 "" OpName %22 "BufferIn" OpMemberName %22 0 "i1" OpMemberName %22 1 "i2" OpName %24 "" OpDecorate %8 ArrayStride 4 OpDecorate %9 ArrayStride 4 OpDecorate %11 ArrayStride 4 OpDecorate %12 ArrayStride 8 OpMemberDecorate %13 0 Offset 0 OpMemberDecorate %13 1 Offset 12 OpMemberDecorate %13 2 Offset 24 OpDecorate %13 BufferBlock OpDecorate %15 DescriptorSet 0 OpDecorate %15 Binding 1 OpDecorate %18 ArrayStride 16 OpDecorate %19 ArrayStride 48 OpDecorate %21 ArrayStride 16 OpMemberDecorate %22 0 Offset 0 OpMemberDecorate %22 1 Offset 96 OpDecorate %22 Block OpDecorate %24 DescriptorSet 0 OpDecorate %24 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %16 = OpTypeInt 32 1 %7 = OpConstant %16 3 %8 = OpTypeArray %6 %7 %9 = OpTypeArray %6 %7 %10 = OpConstant %16 2 %11 = OpTypeArray %6 %10 %12 = OpTypeArray %11 %10 %13 = OpTypeStruct %8 %9 %12 %14 = OpTypePointer Uniform %13 %15 = OpVariable %14 Uniform %18 = OpTypeArray %6 %7 %19 = OpTypeArray %18 %10 %20 = OpConstant %16 4 %21 = OpTypeArray %6 %20 %22 = OpTypeStruct %19 %21 %23 = OpTypePointer Uniform %22 %24 = OpVariable %23 Uniform %25 = OpTypePointer Uniform %6 %17 = OpConstant %16 0 %28 = OpConstant %16 1 %31 = OpConstant %6 1 %34 = OpConstant %6 0 %37 = OpConstant %6 2 %61 = OpConstant %6 3 %4 = OpFunction %2 None %3 %5 = OpLabel %26 = OpAccessChain %25 %24 %17 %17 %17 %27 = OpLoad %6 %26 %29 = OpIAdd %6 %27 %28 %30 = OpAccessChain %25 %15 %17 %17 OpStore %30 %29 %32 = OpAccessChain %25 %24 %17 %31 %17 %33 = OpLoad %6 %32 %35 = OpIAdd %6 %33 %34 %36 = OpAccessChain %25 %15 %17 %31 OpStore %36 %35 %38 = OpAccessChain %25 %24 %17 %31 %31 %39 = OpLoad %6 %38 %40 = OpIAdd %6 %39 %37 %41 = OpAccessChain %25 %15 %17 %10 OpStore %41 %40 %42 = OpAccessChain %25 %24 %17 %17 %10 %43 = OpLoad %6 %42 %44 = OpAccessChain %25 %15 %31 %17 OpStore %44 %43 %45 = OpAccessChain %25 %24 %17 %17 %31 %46 = OpLoad %6 %45 %47 = OpIMul %6 %46 %7 %48 = OpAccessChain %25 %15 %31 %31 OpStore %48 %47 %49 = OpAccessChain %25 %24 %17 %31 %10 %50 = OpLoad %6 %49 %51 = OpAccessChain %25 %15 %31 %10 OpStore %51 %50 %52 = OpAccessChain %25 %24 %31 %17 %53 = OpLoad %6 %52 %54 = OpAccessChain %25 %15 %37 %17 %17 OpStore %54 %53 %55 = OpAccessChain %25 %24 %31 %31 %56 = OpLoad %6 %55 %57 = OpAccessChain %25 %15 %37 %17 %31 OpStore %57 %56 %58 = OpAccessChain %25 %24 %31 %37 %59 = OpLoad %6 %58 %60 = OpAccessChain %25 %15 %37 %31 %17 OpStore %60 %59 %62 = OpAccessChain %25 %24 %31 %61 %63 = OpLoad %6 %62 %64 = OpAccessChain %25 %15 %37 %31 %31 OpStore %64 %63 OpReturn OpFunctionEnd )"; TEST(DiffTest, IndexSignedness) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 65 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpName %4 "main" OpName %13 "BufferOut" OpMemberName %13 0 "o1" OpMemberName %13 1 "o2" OpMemberName %13 2 "o3" OpName %15 "" OpName %22 "BufferIn" OpMemberName %22 0 "i1" OpMemberName %22 1 "i2" OpName %24 "" OpDecorate %8 ArrayStride 4 OpDecorate %9 ArrayStride 4 OpDecorate %11 ArrayStride 4 OpDecorate %12 ArrayStride 8 OpMemberDecorate %13 0 Offset 0 OpMemberDecorate %13 1 Offset 12 OpMemberDecorate %13 2 Offset 24 OpDecorate %13 BufferBlock OpDecorate %15 DescriptorSet 0 OpDecorate %15 Binding 1 OpDecorate %18 ArrayStride 16 OpDecorate %19 ArrayStride 48 OpDecorate %21 ArrayStride 16 OpMemberDecorate %22 0 Offset 0 OpMemberDecorate %22 1 Offset 96 OpDecorate %22 Block OpDecorate %24 DescriptorSet 0 OpDecorate %24 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpConstant %6 3 -%8 = OpTypeArray %6 %7 +%8 = OpTypeArray %6 %61 -%9 = OpTypeArray %6 %7 +%9 = OpTypeArray %6 %61 %10 = OpConstant %6 2 -%11 = OpTypeArray %6 %10 +%11 = OpTypeArray %6 %37 -%12 = OpTypeArray %11 %10 +%12 = OpTypeArray %11 %37 %13 = OpTypeStruct %8 %9 %12 %14 = OpTypePointer Uniform %13 %15 = OpVariable %14 Uniform %16 = OpTypeInt 32 1 %17 = OpConstant %16 0 -%18 = OpTypeArray %6 %7 +%18 = OpTypeArray %6 %61 -%19 = OpTypeArray %18 %10 +%19 = OpTypeArray %18 %37 -%20 = OpConstant %6 4 +%20 = OpConstant %16 4 %21 = OpTypeArray %6 %20 %22 = OpTypeStruct %19 %21 %23 = OpTypePointer Uniform %22 %24 = OpVariable %23 Uniform %25 = OpTypePointer Uniform %6 %28 = OpConstant %6 1 %31 = OpConstant %16 1 %34 = OpConstant %6 0 %37 = OpConstant %16 2 %61 = OpConstant %16 3 %4 = OpFunction %2 None %3 %5 = OpLabel %26 = OpAccessChain %25 %24 %17 %17 %17 %27 = OpLoad %6 %26 -%29 = OpIAdd %6 %27 %28 +%29 = OpIAdd %6 %27 %31 %30 = OpAccessChain %25 %15 %17 %17 OpStore %30 %29 -%32 = OpAccessChain %25 %24 %17 %31 %17 +%32 = OpAccessChain %25 %24 %17 %28 %17 %33 = OpLoad %6 %32 %35 = OpIAdd %6 %33 %34 -%36 = OpAccessChain %25 %15 %17 %31 +%36 = OpAccessChain %25 %15 %17 %28 OpStore %36 %35 -%38 = OpAccessChain %25 %24 %17 %31 %31 +%38 = OpAccessChain %25 %24 %17 %28 %28 %39 = OpLoad %6 %38 %40 = OpIAdd %6 %39 %10 %41 = OpAccessChain %25 %15 %17 %37 OpStore %41 %40 %42 = OpAccessChain %25 %24 %17 %17 %37 %43 = OpLoad %6 %42 -%44 = OpAccessChain %25 %15 %31 %17 +%44 = OpAccessChain %25 %15 %28 %17 OpStore %44 %43 -%45 = OpAccessChain %25 %24 %17 %17 %31 +%45 = OpAccessChain %25 %24 %17 %17 %28 %46 = OpLoad %6 %45 -%47 = OpIMul %6 %46 %7 +%47 = OpIMul %6 %46 %61 -%48 = OpAccessChain %25 %15 %31 %31 +%48 = OpAccessChain %25 %15 %28 %28 OpStore %48 %47 -%49 = OpAccessChain %25 %24 %17 %31 %37 +%49 = OpAccessChain %25 %24 %17 %28 %37 %50 = OpLoad %6 %49 -%51 = OpAccessChain %25 %15 %31 %37 +%51 = OpAccessChain %25 %15 %28 %37 OpStore %51 %50 -%52 = OpAccessChain %25 %24 %31 %17 +%52 = OpAccessChain %25 %24 %28 %17 %53 = OpLoad %6 %52 -%54 = OpAccessChain %25 %15 %37 %17 %17 +%54 = OpAccessChain %25 %15 %10 %17 %17 OpStore %54 %53 -%55 = OpAccessChain %25 %24 %31 %31 +%55 = OpAccessChain %25 %24 %28 %28 %56 = OpLoad %6 %55 -%57 = OpAccessChain %25 %15 %37 %17 %31 +%57 = OpAccessChain %25 %15 %10 %17 %28 OpStore %57 %56 -%58 = OpAccessChain %25 %24 %31 %37 +%58 = OpAccessChain %25 %24 %28 %10 %59 = OpLoad %6 %58 -%60 = OpAccessChain %25 %15 %37 %31 %17 +%60 = OpAccessChain %25 %15 %10 %28 %17 OpStore %60 %59 -%62 = OpAccessChain %25 %24 %31 %61 +%62 = OpAccessChain %25 %24 %28 %7 %63 = OpLoad %6 %62 -%64 = OpAccessChain %25 %15 %37 %31 %31 +%64 = OpAccessChain %25 %15 %10 %28 %28 OpStore %64 %63 OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrc, kDst, kDiff, options); } TEST(DiffTest, IndexSignednessNoDebug) { constexpr char kSrcNoDebug[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpDecorate %8 ArrayStride 4 OpDecorate %9 ArrayStride 4 OpDecorate %11 ArrayStride 4 OpDecorate %12 ArrayStride 8 OpMemberDecorate %13 0 Offset 0 OpMemberDecorate %13 1 Offset 12 OpMemberDecorate %13 2 Offset 24 OpDecorate %13 BufferBlock OpDecorate %15 DescriptorSet 0 OpDecorate %15 Binding 1 OpDecorate %18 ArrayStride 16 OpDecorate %19 ArrayStride 48 OpDecorate %21 ArrayStride 16 OpMemberDecorate %22 0 Offset 0 OpMemberDecorate %22 1 Offset 96 OpDecorate %22 Block OpDecorate %24 DescriptorSet 0 OpDecorate %24 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpConstant %6 3 %8 = OpTypeArray %6 %7 %9 = OpTypeArray %6 %7 %10 = OpConstant %6 2 %11 = OpTypeArray %6 %10 %12 = OpTypeArray %11 %10 %13 = OpTypeStruct %8 %9 %12 %14 = OpTypePointer Uniform %13 %15 = OpVariable %14 Uniform %16 = OpTypeInt 32 1 %17 = OpConstant %16 0 %18 = OpTypeArray %6 %7 %19 = OpTypeArray %18 %10 %20 = OpConstant %6 4 %21 = OpTypeArray %6 %20 %22 = OpTypeStruct %19 %21 %23 = OpTypePointer Uniform %22 %24 = OpVariable %23 Uniform %25 = OpTypePointer Uniform %6 %28 = OpConstant %6 1 %31 = OpConstant %16 1 %34 = OpConstant %6 0 %37 = OpConstant %16 2 %61 = OpConstant %16 3 %4 = OpFunction %2 None %3 %5 = OpLabel %26 = OpAccessChain %25 %24 %17 %17 %17 %27 = OpLoad %6 %26 %29 = OpIAdd %6 %27 %28 %30 = OpAccessChain %25 %15 %17 %17 OpStore %30 %29 %32 = OpAccessChain %25 %24 %17 %31 %17 %33 = OpLoad %6 %32 %35 = OpIAdd %6 %33 %34 %36 = OpAccessChain %25 %15 %17 %31 OpStore %36 %35 %38 = OpAccessChain %25 %24 %17 %31 %31 %39 = OpLoad %6 %38 %40 = OpIAdd %6 %39 %10 %41 = OpAccessChain %25 %15 %17 %37 OpStore %41 %40 %42 = OpAccessChain %25 %24 %17 %17 %37 %43 = OpLoad %6 %42 %44 = OpAccessChain %25 %15 %31 %17 OpStore %44 %43 %45 = OpAccessChain %25 %24 %17 %17 %31 %46 = OpLoad %6 %45 %47 = OpIMul %6 %46 %7 %48 = OpAccessChain %25 %15 %31 %31 OpStore %48 %47 %49 = OpAccessChain %25 %24 %17 %31 %37 %50 = OpLoad %6 %49 %51 = OpAccessChain %25 %15 %31 %37 OpStore %51 %50 %52 = OpAccessChain %25 %24 %31 %17 %53 = OpLoad %6 %52 %54 = OpAccessChain %25 %15 %37 %17 %17 OpStore %54 %53 %55 = OpAccessChain %25 %24 %31 %31 %56 = OpLoad %6 %55 %57 = OpAccessChain %25 %15 %37 %17 %31 OpStore %57 %56 %58 = OpAccessChain %25 %24 %31 %37 %59 = OpLoad %6 %58 %60 = OpAccessChain %25 %15 %37 %31 %17 OpStore %60 %59 %62 = OpAccessChain %25 %24 %31 %61 %63 = OpLoad %6 %62 %64 = OpAccessChain %25 %15 %37 %31 %31 OpStore %64 %63 OpReturn OpFunctionEnd )"; constexpr char kDstNoDebug[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpDecorate %8 ArrayStride 4 OpDecorate %9 ArrayStride 4 OpDecorate %11 ArrayStride 4 OpDecorate %12 ArrayStride 8 OpMemberDecorate %13 0 Offset 0 OpMemberDecorate %13 1 Offset 12 OpMemberDecorate %13 2 Offset 24 OpDecorate %13 BufferBlock OpDecorate %15 DescriptorSet 0 OpDecorate %15 Binding 1 OpDecorate %18 ArrayStride 16 OpDecorate %19 ArrayStride 48 OpDecorate %21 ArrayStride 16 OpMemberDecorate %22 0 Offset 0 OpMemberDecorate %22 1 Offset 96 OpDecorate %22 Block OpDecorate %24 DescriptorSet 0 OpDecorate %24 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %16 = OpTypeInt 32 1 %7 = OpConstant %16 3 %8 = OpTypeArray %6 %7 %9 = OpTypeArray %6 %7 %10 = OpConstant %16 2 %11 = OpTypeArray %6 %10 %12 = OpTypeArray %11 %10 %13 = OpTypeStruct %8 %9 %12 %14 = OpTypePointer Uniform %13 %15 = OpVariable %14 Uniform %18 = OpTypeArray %6 %7 %19 = OpTypeArray %18 %10 %20 = OpConstant %16 4 %21 = OpTypeArray %6 %20 %22 = OpTypeStruct %19 %21 %23 = OpTypePointer Uniform %22 %24 = OpVariable %23 Uniform %25 = OpTypePointer Uniform %6 %17 = OpConstant %16 0 %28 = OpConstant %16 1 %31 = OpConstant %6 1 %34 = OpConstant %6 0 %37 = OpConstant %6 2 %61 = OpConstant %6 3 %4 = OpFunction %2 None %3 %5 = OpLabel %26 = OpAccessChain %25 %24 %17 %17 %17 %27 = OpLoad %6 %26 %29 = OpIAdd %6 %27 %28 %30 = OpAccessChain %25 %15 %17 %17 OpStore %30 %29 %32 = OpAccessChain %25 %24 %17 %31 %17 %33 = OpLoad %6 %32 %35 = OpIAdd %6 %33 %34 %36 = OpAccessChain %25 %15 %17 %31 OpStore %36 %35 %38 = OpAccessChain %25 %24 %17 %31 %31 %39 = OpLoad %6 %38 %40 = OpIAdd %6 %39 %37 %41 = OpAccessChain %25 %15 %17 %10 OpStore %41 %40 %42 = OpAccessChain %25 %24 %17 %17 %10 %43 = OpLoad %6 %42 %44 = OpAccessChain %25 %15 %31 %17 OpStore %44 %43 %45 = OpAccessChain %25 %24 %17 %17 %31 %46 = OpLoad %6 %45 %47 = OpIMul %6 %46 %7 %48 = OpAccessChain %25 %15 %31 %31 OpStore %48 %47 %49 = OpAccessChain %25 %24 %17 %31 %10 %50 = OpLoad %6 %49 %51 = OpAccessChain %25 %15 %31 %10 OpStore %51 %50 %52 = OpAccessChain %25 %24 %31 %17 %53 = OpLoad %6 %52 %54 = OpAccessChain %25 %15 %37 %17 %17 OpStore %54 %53 %55 = OpAccessChain %25 %24 %31 %31 %56 = OpLoad %6 %55 %57 = OpAccessChain %25 %15 %37 %17 %31 OpStore %57 %56 %58 = OpAccessChain %25 %24 %31 %37 %59 = OpLoad %6 %58 %60 = OpAccessChain %25 %15 %37 %31 %17 OpStore %60 %59 %62 = OpAccessChain %25 %24 %31 %61 %63 = OpLoad %6 %62 %64 = OpAccessChain %25 %15 %37 %31 %31 OpStore %64 %63 OpReturn OpFunctionEnd )"; constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 65 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpDecorate %8 ArrayStride 4 OpDecorate %9 ArrayStride 4 OpDecorate %11 ArrayStride 4 OpDecorate %12 ArrayStride 8 OpMemberDecorate %13 0 Offset 0 OpMemberDecorate %13 1 Offset 12 OpMemberDecorate %13 2 Offset 24 OpDecorate %13 BufferBlock OpDecorate %15 DescriptorSet 0 OpDecorate %15 Binding 1 OpDecorate %18 ArrayStride 16 OpDecorate %19 ArrayStride 48 OpDecorate %21 ArrayStride 16 OpMemberDecorate %22 0 Offset 0 OpMemberDecorate %22 1 Offset 96 OpDecorate %22 Block OpDecorate %24 DescriptorSet 0 OpDecorate %24 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpConstant %6 3 -%8 = OpTypeArray %6 %7 +%8 = OpTypeArray %6 %61 -%9 = OpTypeArray %6 %7 +%9 = OpTypeArray %6 %61 %10 = OpConstant %6 2 -%11 = OpTypeArray %6 %10 +%11 = OpTypeArray %6 %37 -%12 = OpTypeArray %11 %10 +%12 = OpTypeArray %11 %37 %13 = OpTypeStruct %8 %9 %12 %14 = OpTypePointer Uniform %13 %15 = OpVariable %14 Uniform %16 = OpTypeInt 32 1 %17 = OpConstant %16 0 -%18 = OpTypeArray %6 %7 +%18 = OpTypeArray %6 %61 -%19 = OpTypeArray %18 %10 +%19 = OpTypeArray %18 %37 -%20 = OpConstant %6 4 +%20 = OpConstant %16 4 %21 = OpTypeArray %6 %20 %22 = OpTypeStruct %19 %21 %23 = OpTypePointer Uniform %22 %24 = OpVariable %23 Uniform %25 = OpTypePointer Uniform %6 %28 = OpConstant %6 1 %31 = OpConstant %16 1 %34 = OpConstant %6 0 %37 = OpConstant %16 2 %61 = OpConstant %16 3 %4 = OpFunction %2 None %3 %5 = OpLabel %26 = OpAccessChain %25 %24 %17 %17 %17 %27 = OpLoad %6 %26 -%29 = OpIAdd %6 %27 %28 +%29 = OpIAdd %6 %27 %31 %30 = OpAccessChain %25 %15 %17 %17 OpStore %30 %29 -%32 = OpAccessChain %25 %24 %17 %31 %17 +%32 = OpAccessChain %25 %24 %17 %28 %17 %33 = OpLoad %6 %32 %35 = OpIAdd %6 %33 %34 -%36 = OpAccessChain %25 %15 %17 %31 +%36 = OpAccessChain %25 %15 %17 %28 OpStore %36 %35 -%38 = OpAccessChain %25 %24 %17 %31 %31 +%38 = OpAccessChain %25 %24 %17 %28 %28 %39 = OpLoad %6 %38 %40 = OpIAdd %6 %39 %10 %41 = OpAccessChain %25 %15 %17 %37 OpStore %41 %40 %42 = OpAccessChain %25 %24 %17 %17 %37 %43 = OpLoad %6 %42 -%44 = OpAccessChain %25 %15 %31 %17 +%44 = OpAccessChain %25 %15 %28 %17 OpStore %44 %43 -%45 = OpAccessChain %25 %24 %17 %17 %31 +%45 = OpAccessChain %25 %24 %17 %17 %28 %46 = OpLoad %6 %45 -%47 = OpIMul %6 %46 %7 +%47 = OpIMul %6 %46 %61 -%48 = OpAccessChain %25 %15 %31 %31 +%48 = OpAccessChain %25 %15 %28 %28 OpStore %48 %47 -%49 = OpAccessChain %25 %24 %17 %31 %37 +%49 = OpAccessChain %25 %24 %17 %28 %37 %50 = OpLoad %6 %49 -%51 = OpAccessChain %25 %15 %31 %37 +%51 = OpAccessChain %25 %15 %28 %37 OpStore %51 %50 -%52 = OpAccessChain %25 %24 %31 %17 +%52 = OpAccessChain %25 %24 %28 %17 %53 = OpLoad %6 %52 -%54 = OpAccessChain %25 %15 %37 %17 %17 +%54 = OpAccessChain %25 %15 %10 %17 %17 OpStore %54 %53 -%55 = OpAccessChain %25 %24 %31 %31 +%55 = OpAccessChain %25 %24 %28 %28 %56 = OpLoad %6 %55 -%57 = OpAccessChain %25 %15 %37 %17 %31 +%57 = OpAccessChain %25 %15 %10 %17 %28 OpStore %57 %56 -%58 = OpAccessChain %25 %24 %31 %37 +%58 = OpAccessChain %25 %24 %28 %10 %59 = OpLoad %6 %58 -%60 = OpAccessChain %25 %15 %37 %31 %17 +%60 = OpAccessChain %25 %15 %10 %28 %17 OpStore %60 %59 -%62 = OpAccessChain %25 %24 %31 %61 +%62 = OpAccessChain %25 %24 %28 %7 %63 = OpLoad %6 %62 -%64 = OpAccessChain %25 %15 %37 %31 %31 +%64 = OpAccessChain %25 %15 %10 %28 %28 OpStore %64 %63 OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrcNoDebug, kDstNoDebug, kDiff, options); } } // namespace } // namespace diff } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/index_signedness_dst.spvasm000066400000000000000000000100171475742701700301470ustar00rootroot00000000000000 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpName %4 "main" OpName %13 "BufferOut" OpMemberName %13 0 "o1" OpMemberName %13 1 "o2" OpMemberName %13 2 "o3" OpName %15 "" OpName %22 "BufferIn" OpMemberName %22 0 "i1" OpMemberName %22 1 "i2" OpName %24 "" OpDecorate %8 ArrayStride 4 OpDecorate %9 ArrayStride 4 OpDecorate %11 ArrayStride 4 OpDecorate %12 ArrayStride 8 OpMemberDecorate %13 0 Offset 0 OpMemberDecorate %13 1 Offset 12 OpMemberDecorate %13 2 Offset 24 OpDecorate %13 BufferBlock OpDecorate %15 DescriptorSet 0 OpDecorate %15 Binding 1 OpDecorate %18 ArrayStride 16 OpDecorate %19 ArrayStride 48 OpDecorate %21 ArrayStride 16 OpMemberDecorate %22 0 Offset 0 OpMemberDecorate %22 1 Offset 96 OpDecorate %22 Block OpDecorate %24 DescriptorSet 0 OpDecorate %24 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %16 = OpTypeInt 32 1 %7 = OpConstant %16 3 %8 = OpTypeArray %6 %7 %9 = OpTypeArray %6 %7 %10 = OpConstant %16 2 %11 = OpTypeArray %6 %10 %12 = OpTypeArray %11 %10 %13 = OpTypeStruct %8 %9 %12 %14 = OpTypePointer Uniform %13 %15 = OpVariable %14 Uniform %18 = OpTypeArray %6 %7 %19 = OpTypeArray %18 %10 %20 = OpConstant %16 4 %21 = OpTypeArray %6 %20 %22 = OpTypeStruct %19 %21 %23 = OpTypePointer Uniform %22 %24 = OpVariable %23 Uniform %25 = OpTypePointer Uniform %6 %17 = OpConstant %16 0 %28 = OpConstant %16 1 %31 = OpConstant %6 1 %34 = OpConstant %6 0 %37 = OpConstant %6 2 %61 = OpConstant %6 3 %4 = OpFunction %2 None %3 %5 = OpLabel %26 = OpAccessChain %25 %24 %17 %17 %17 %27 = OpLoad %6 %26 %29 = OpIAdd %6 %27 %28 %30 = OpAccessChain %25 %15 %17 %17 OpStore %30 %29 %32 = OpAccessChain %25 %24 %17 %31 %17 %33 = OpLoad %6 %32 %35 = OpIAdd %6 %33 %34 %36 = OpAccessChain %25 %15 %17 %31 OpStore %36 %35 %38 = OpAccessChain %25 %24 %17 %31 %31 %39 = OpLoad %6 %38 %40 = OpIAdd %6 %39 %37 %41 = OpAccessChain %25 %15 %17 %10 OpStore %41 %40 %42 = OpAccessChain %25 %24 %17 %17 %10 %43 = OpLoad %6 %42 %44 = OpAccessChain %25 %15 %31 %17 OpStore %44 %43 %45 = OpAccessChain %25 %24 %17 %17 %31 %46 = OpLoad %6 %45 %47 = OpIMul %6 %46 %7 %48 = OpAccessChain %25 %15 %31 %31 OpStore %48 %47 %49 = OpAccessChain %25 %24 %17 %31 %10 %50 = OpLoad %6 %49 %51 = OpAccessChain %25 %15 %31 %10 OpStore %51 %50 %52 = OpAccessChain %25 %24 %31 %17 %53 = OpLoad %6 %52 %54 = OpAccessChain %25 %15 %37 %17 %17 OpStore %54 %53 %55 = OpAccessChain %25 %24 %31 %31 %56 = OpLoad %6 %55 %57 = OpAccessChain %25 %15 %37 %17 %31 OpStore %57 %56 %58 = OpAccessChain %25 %24 %31 %37 %59 = OpLoad %6 %58 %60 = OpAccessChain %25 %15 %37 %31 %17 OpStore %60 %59 %62 = OpAccessChain %25 %24 %31 %61 %63 = OpLoad %6 %62 %64 = OpAccessChain %25 %15 %37 %31 %31 OpStore %64 %63 OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/index_signedness_src.spvasm000066400000000000000000000101251475742701700301440ustar00rootroot00000000000000;; Test where signedness of indices are different between src and dst. OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpName %4 "main" OpName %13 "BufferOut" OpMemberName %13 0 "o1" OpMemberName %13 1 "o2" OpMemberName %13 2 "o3" OpName %15 "" OpName %22 "BufferIn" OpMemberName %22 0 "i1" OpMemberName %22 1 "i2" OpName %24 "" OpDecorate %8 ArrayStride 4 OpDecorate %9 ArrayStride 4 OpDecorate %11 ArrayStride 4 OpDecorate %12 ArrayStride 8 OpMemberDecorate %13 0 Offset 0 OpMemberDecorate %13 1 Offset 12 OpMemberDecorate %13 2 Offset 24 OpDecorate %13 BufferBlock OpDecorate %15 DescriptorSet 0 OpDecorate %15 Binding 1 OpDecorate %18 ArrayStride 16 OpDecorate %19 ArrayStride 48 OpDecorate %21 ArrayStride 16 OpMemberDecorate %22 0 Offset 0 OpMemberDecorate %22 1 Offset 96 OpDecorate %22 Block OpDecorate %24 DescriptorSet 0 OpDecorate %24 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpConstant %6 3 %8 = OpTypeArray %6 %7 %9 = OpTypeArray %6 %7 %10 = OpConstant %6 2 %11 = OpTypeArray %6 %10 %12 = OpTypeArray %11 %10 %13 = OpTypeStruct %8 %9 %12 %14 = OpTypePointer Uniform %13 %15 = OpVariable %14 Uniform %16 = OpTypeInt 32 1 %17 = OpConstant %16 0 %18 = OpTypeArray %6 %7 %19 = OpTypeArray %18 %10 %20 = OpConstant %6 4 %21 = OpTypeArray %6 %20 %22 = OpTypeStruct %19 %21 %23 = OpTypePointer Uniform %22 %24 = OpVariable %23 Uniform %25 = OpTypePointer Uniform %6 %28 = OpConstant %6 1 %31 = OpConstant %16 1 %34 = OpConstant %6 0 %37 = OpConstant %16 2 %61 = OpConstant %16 3 %4 = OpFunction %2 None %3 %5 = OpLabel %26 = OpAccessChain %25 %24 %17 %17 %17 %27 = OpLoad %6 %26 %29 = OpIAdd %6 %27 %28 %30 = OpAccessChain %25 %15 %17 %17 OpStore %30 %29 %32 = OpAccessChain %25 %24 %17 %31 %17 %33 = OpLoad %6 %32 %35 = OpIAdd %6 %33 %34 %36 = OpAccessChain %25 %15 %17 %31 OpStore %36 %35 %38 = OpAccessChain %25 %24 %17 %31 %31 %39 = OpLoad %6 %38 %40 = OpIAdd %6 %39 %10 %41 = OpAccessChain %25 %15 %17 %37 OpStore %41 %40 %42 = OpAccessChain %25 %24 %17 %17 %37 %43 = OpLoad %6 %42 %44 = OpAccessChain %25 %15 %31 %17 OpStore %44 %43 %45 = OpAccessChain %25 %24 %17 %17 %31 %46 = OpLoad %6 %45 %47 = OpIMul %6 %46 %7 %48 = OpAccessChain %25 %15 %31 %31 OpStore %48 %47 %49 = OpAccessChain %25 %24 %17 %31 %37 %50 = OpLoad %6 %49 %51 = OpAccessChain %25 %15 %31 %37 OpStore %51 %50 %52 = OpAccessChain %25 %24 %31 %17 %53 = OpLoad %6 %52 %54 = OpAccessChain %25 %15 %37 %17 %17 OpStore %54 %53 %55 = OpAccessChain %25 %24 %31 %31 %56 = OpLoad %6 %55 %57 = OpAccessChain %25 %15 %37 %17 %31 OpStore %57 %56 %58 = OpAccessChain %25 %24 %31 %37 %59 = OpLoad %6 %58 %60 = OpAccessChain %25 %15 %37 %31 %17 OpStore %60 %59 %62 = OpAccessChain %25 %24 %31 %61 %63 = OpLoad %6 %62 %64 = OpAccessChain %25 %15 %37 %31 %31 OpStore %64 %63 OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/int_vs_uint_constants_autogen.cpp000066400000000000000000000245141475742701700314030ustar00rootroot00000000000000// GENERATED FILE - DO NOT EDIT. // Generated by generate_tests.py // // Copyright (c) 2022 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "../diff_test_utils.h" #include "gtest/gtest.h" namespace spvtools { namespace diff { namespace { // Tests that identical integer constants are matched, regardless of int or // uint. This helps compare output from different generators that default to // int or uint for constants such as those passed to OpAccessChain. constexpr char kSrc[] = R"(; SPIR-V ; Version: 1.0 ; Generator: Google ANGLE Shader Compiler; 0 ; Bound: 27 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %22 "main" %4 %19 OpSource GLSL 450 OpName %4 "_ua_position" OpName %17 "gl_PerVertex" OpMemberName %17 0 "gl_Position" OpMemberName %17 1 "gl_PointSize" OpMemberName %17 2 "gl_ClipDistance" OpMemberName %17 3 "gl_CullDistance" OpName %19 "" OpName %22 "main" OpDecorate %4 Location 0 OpMemberDecorate %17 1 RelaxedPrecision OpMemberDecorate %17 0 BuiltIn Position OpMemberDecorate %17 1 BuiltIn PointSize OpMemberDecorate %17 2 BuiltIn ClipDistance OpMemberDecorate %17 3 BuiltIn CullDistance OpDecorate %17 Block %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeInt 32 0 %8 = OpTypeVector %5 4 %15 = OpConstant %5 8 %16 = OpTypeArray %1 %15 %17 = OpTypeStruct %2 %1 %16 %16 %20 = OpTypeVoid %25 = OpConstant %5 0 %3 = OpTypePointer Input %2 %13 = OpTypePointer Output %2 %18 = OpTypePointer Output %17 %21 = OpTypeFunction %20 %4 = OpVariable %3 Input %19 = OpVariable %18 Output %22 = OpFunction %20 None %21 %23 = OpLabel %24 = OpLoad %2 %4 %26 = OpAccessChain %13 %19 %25 OpStore %26 %24 OpReturn OpFunctionEnd)"; constexpr char kDst[] = R"(; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 28 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %4 "main" %13 %17 OpSource GLSL 450 OpName %4 "main" OpName %11 "gl_PerVertex" OpMemberName %11 0 "gl_Position" OpMemberName %11 1 "gl_PointSize" OpMemberName %11 2 "gl_ClipDistance" OpMemberName %11 3 "gl_CullDistance" OpName %13 "" OpName %17 "_ua_position" OpMemberDecorate %11 0 BuiltIn Position OpMemberDecorate %11 1 BuiltIn PointSize OpMemberDecorate %11 2 BuiltIn ClipDistance OpMemberDecorate %11 3 BuiltIn CullDistance OpDecorate %11 Block OpDecorate %17 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypeInt 32 0 %9 = OpConstant %8 1 %10 = OpTypeArray %6 %9 %11 = OpTypeStruct %7 %6 %10 %10 %12 = OpTypePointer Output %11 %13 = OpVariable %12 Output %14 = OpTypeInt 32 1 %15 = OpConstant %14 0 %16 = OpTypePointer Input %7 %17 = OpVariable %16 Input %19 = OpTypePointer Output %7 %4 = OpFunction %2 None %3 %5 = OpLabel %18 = OpLoad %7 %17 %20 = OpAccessChain %19 %13 %15 OpStore %20 %18 OpReturn OpFunctionEnd )"; TEST(DiffTest, IntVsUintConstants) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 27 +; Bound: 31 ; Schema: 0 OpCapability Shader +%27 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 -OpEntryPoint Vertex %22 "main" %4 %19 +OpEntryPoint Vertex %22 "main" %19 %4 OpSource GLSL 450 OpName %4 "_ua_position" OpName %17 "gl_PerVertex" OpMemberName %17 0 "gl_Position" OpMemberName %17 1 "gl_PointSize" OpMemberName %17 2 "gl_ClipDistance" OpMemberName %17 3 "gl_CullDistance" OpName %19 "" OpName %22 "main" OpDecorate %4 Location 0 -OpMemberDecorate %17 1 RelaxedPrecision OpMemberDecorate %17 0 BuiltIn Position OpMemberDecorate %17 1 BuiltIn PointSize OpMemberDecorate %17 2 BuiltIn ClipDistance OpMemberDecorate %17 3 BuiltIn CullDistance OpDecorate %17 Block %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeInt 32 0 -%8 = OpTypeVector %5 4 -%15 = OpConstant %5 8 -%16 = OpTypeArray %1 %15 -%17 = OpTypeStruct %2 %1 %16 %16 +%17 = OpTypeStruct %2 %1 %29 %29 %20 = OpTypeVoid +%28 = OpConstant %5 1 +%29 = OpTypeArray %1 %28 -%25 = OpConstant %5 0 +%25 = OpConstant %30 0 %3 = OpTypePointer Input %2 %13 = OpTypePointer Output %2 +%30 = OpTypeInt 32 1 %18 = OpTypePointer Output %17 %21 = OpTypeFunction %20 %4 = OpVariable %3 Input %19 = OpVariable %18 Output %22 = OpFunction %20 None %21 %23 = OpLabel %24 = OpLoad %2 %4 %26 = OpAccessChain %13 %19 %25 OpStore %26 %24 OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrc, kDst, kDiff, options); } TEST(DiffTest, IntVsUintConstantsNoDebug) { constexpr char kSrcNoDebug[] = R"(; SPIR-V ; Version: 1.0 ; Generator: Google ANGLE Shader Compiler; 0 ; Bound: 27 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %22 "main" %4 %19 OpSource GLSL 450 OpDecorate %4 Location 0 OpMemberDecorate %17 1 RelaxedPrecision OpMemberDecorate %17 0 BuiltIn Position OpMemberDecorate %17 1 BuiltIn PointSize OpMemberDecorate %17 2 BuiltIn ClipDistance OpMemberDecorate %17 3 BuiltIn CullDistance OpDecorate %17 Block %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeInt 32 0 %8 = OpTypeVector %5 4 %15 = OpConstant %5 8 %16 = OpTypeArray %1 %15 %17 = OpTypeStruct %2 %1 %16 %16 %20 = OpTypeVoid %25 = OpConstant %5 0 %3 = OpTypePointer Input %2 %13 = OpTypePointer Output %2 %18 = OpTypePointer Output %17 %21 = OpTypeFunction %20 %4 = OpVariable %3 Input %19 = OpVariable %18 Output %22 = OpFunction %20 None %21 %23 = OpLabel %24 = OpLoad %2 %4 %26 = OpAccessChain %13 %19 %25 OpStore %26 %24 OpReturn OpFunctionEnd )"; constexpr char kDstNoDebug[] = R"(; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 28 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %4 "main" %13 %17 OpSource GLSL 450 OpMemberDecorate %11 0 BuiltIn Position OpMemberDecorate %11 1 BuiltIn PointSize OpMemberDecorate %11 2 BuiltIn ClipDistance OpMemberDecorate %11 3 BuiltIn CullDistance OpDecorate %11 Block OpDecorate %17 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypeInt 32 0 %9 = OpConstant %8 1 %10 = OpTypeArray %6 %9 %11 = OpTypeStruct %7 %6 %10 %10 %12 = OpTypePointer Output %11 %13 = OpVariable %12 Output %14 = OpTypeInt 32 1 %15 = OpConstant %14 0 %16 = OpTypePointer Input %7 %17 = OpVariable %16 Input %19 = OpTypePointer Output %7 %4 = OpFunction %2 None %3 %5 = OpLabel %18 = OpLoad %7 %17 %20 = OpAccessChain %19 %13 %15 OpStore %20 %18 OpReturn OpFunctionEnd )"; constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 27 +; Bound: 31 ; Schema: 0 OpCapability Shader +%27 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 -OpEntryPoint Vertex %22 "main" %4 %19 +OpEntryPoint Vertex %22 "main" %19 %4 OpSource GLSL 450 OpDecorate %4 Location 0 -OpMemberDecorate %17 1 RelaxedPrecision OpMemberDecorate %17 0 BuiltIn Position OpMemberDecorate %17 1 BuiltIn PointSize OpMemberDecorate %17 2 BuiltIn ClipDistance OpMemberDecorate %17 3 BuiltIn CullDistance OpDecorate %17 Block %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeInt 32 0 -%8 = OpTypeVector %5 4 -%15 = OpConstant %5 8 -%16 = OpTypeArray %1 %15 -%17 = OpTypeStruct %2 %1 %16 %16 +%17 = OpTypeStruct %2 %1 %29 %29 %20 = OpTypeVoid +%28 = OpConstant %5 1 +%29 = OpTypeArray %1 %28 -%25 = OpConstant %5 0 +%25 = OpConstant %30 0 %3 = OpTypePointer Input %2 %13 = OpTypePointer Output %2 +%30 = OpTypeInt 32 1 %18 = OpTypePointer Output %17 %21 = OpTypeFunction %20 %4 = OpVariable %3 Input %19 = OpVariable %18 Output %22 = OpFunction %20 None %21 %23 = OpLabel %24 = OpLoad %2 %4 %26 = OpAccessChain %13 %19 %25 OpStore %26 %24 OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrcNoDebug, kDstNoDebug, kDiff, options); } TEST(DiffTest, IntVsUintConstantsDumpIds) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 27 +; Bound: 31 ; Schema: 0 OpCapability Shader +%27 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 -OpEntryPoint Vertex %22 "main" %4 %19 +OpEntryPoint Vertex %22 "main" %19 %4 OpSource GLSL 450 OpName %4 "_ua_position" OpName %17 "gl_PerVertex" OpMemberName %17 0 "gl_Position" OpMemberName %17 1 "gl_PointSize" OpMemberName %17 2 "gl_ClipDistance" OpMemberName %17 3 "gl_CullDistance" OpName %19 "" OpName %22 "main" OpDecorate %4 Location 0 -OpMemberDecorate %17 1 RelaxedPrecision OpMemberDecorate %17 0 BuiltIn Position OpMemberDecorate %17 1 BuiltIn PointSize OpMemberDecorate %17 2 BuiltIn ClipDistance OpMemberDecorate %17 3 BuiltIn CullDistance OpDecorate %17 Block %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeInt 32 0 -%8 = OpTypeVector %5 4 -%15 = OpConstant %5 8 -%16 = OpTypeArray %1 %15 -%17 = OpTypeStruct %2 %1 %16 %16 +%17 = OpTypeStruct %2 %1 %29 %29 %20 = OpTypeVoid +%28 = OpConstant %5 1 +%29 = OpTypeArray %1 %28 -%25 = OpConstant %5 0 +%25 = OpConstant %30 0 %3 = OpTypePointer Input %2 %13 = OpTypePointer Output %2 +%30 = OpTypeInt 32 1 %18 = OpTypePointer Output %17 %21 = OpTypeFunction %20 %4 = OpVariable %3 Input %19 = OpVariable %18 Output %22 = OpFunction %20 None %21 %23 = OpLabel %24 = OpLoad %2 %4 %26 = OpAccessChain %13 %19 %25 OpStore %26 %24 OpReturn OpFunctionEnd Src -> Dst 1 -> 6 [TypeFloat] 2 -> 7 [TypeVector] 3 -> 16 [TypePointer] 4 -> 17 [Variable] 5 -> 8 [TypeInt] 8 -> 21 [TypeVector] 13 -> 19 [TypePointer] 15 -> 22 [Constant] 16 -> 23 [TypeArray] 17 -> 11 [TypeStruct] 18 -> 12 [TypePointer] 19 -> 13 [Variable] 20 -> 2 [TypeVoid] 21 -> 3 [TypeFunction] 22 -> 4 [Function] 23 -> 5 [Label] 24 -> 18 [Load] 25 -> 15 [Constant] 26 -> 20 [AccessChain] )"; Options options; options.dump_id_map = true; DoStringDiffTest(kSrc, kDst, kDiff, options); } } // namespace } // namespace diff } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/int_vs_uint_constants_dst.spvasm000066400000000000000000000022371475742701700312600ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 28 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %4 "main" %13 %17 OpSource GLSL 450 OpName %4 "main" OpName %11 "gl_PerVertex" OpMemberName %11 0 "gl_Position" OpMemberName %11 1 "gl_PointSize" OpMemberName %11 2 "gl_ClipDistance" OpMemberName %11 3 "gl_CullDistance" OpName %13 "" OpName %17 "_ua_position" OpMemberDecorate %11 0 BuiltIn Position OpMemberDecorate %11 1 BuiltIn PointSize OpMemberDecorate %11 2 BuiltIn ClipDistance OpMemberDecorate %11 3 BuiltIn CullDistance OpDecorate %11 Block OpDecorate %17 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypeInt 32 0 %9 = OpConstant %8 1 %10 = OpTypeArray %6 %9 %11 = OpTypeStruct %7 %6 %10 %10 %12 = OpTypePointer Output %11 %13 = OpVariable %12 Output %14 = OpTypeInt 32 1 %15 = OpConstant %14 0 %16 = OpTypePointer Input %7 %17 = OpVariable %16 Input %19 = OpTypePointer Output %7 %4 = OpFunction %2 None %3 %5 = OpLabel %18 = OpLoad %7 %17 %20 = OpAccessChain %19 %13 %15 OpStore %20 %18 OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/int_vs_uint_constants_src.spvasm000066400000000000000000000025761475742701700312630ustar00rootroot00000000000000;; Tests that identical integer constants are matched, regardless of int or ;; uint. This helps compare output from different generators that default to ;; int or uint for constants such as those passed to OpAccessChain. ; SPIR-V ; Version: 1.0 ; Generator: Google ANGLE Shader Compiler; 0 ; Bound: 27 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %22 "main" %4 %19 OpSource GLSL 450 OpName %4 "_ua_position" OpName %17 "gl_PerVertex" OpMemberName %17 0 "gl_Position" OpMemberName %17 1 "gl_PointSize" OpMemberName %17 2 "gl_ClipDistance" OpMemberName %17 3 "gl_CullDistance" OpName %19 "" OpName %22 "main" OpDecorate %4 Location 0 OpMemberDecorate %17 1 RelaxedPrecision OpMemberDecorate %17 0 BuiltIn Position OpMemberDecorate %17 1 BuiltIn PointSize OpMemberDecorate %17 2 BuiltIn ClipDistance OpMemberDecorate %17 3 BuiltIn CullDistance OpDecorate %17 Block %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeInt 32 0 %8 = OpTypeVector %5 4 %15 = OpConstant %5 8 %16 = OpTypeArray %1 %15 %17 = OpTypeStruct %2 %1 %16 %16 %20 = OpTypeVoid %25 = OpConstant %5 0 %3 = OpTypePointer Input %2 %13 = OpTypePointer Output %2 %18 = OpTypePointer Output %17 %21 = OpTypeFunction %20 %4 = OpVariable %3 Input %19 = OpVariable %18 Output %22 = OpFunction %20 None %21 %23 = OpLabel %24 = OpLoad %2 %4 %26 = OpAccessChain %13 %19 %25 OpStore %26 %24 OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/large_functions_large_diffs_autogen.cpp000066400000000000000000001370301475742701700324530ustar00rootroot00000000000000// GENERATED FILE - DO NOT EDIT. // Generated by generate_tests.py // // Copyright (c) 2022 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "../diff_test_utils.h" #include "gtest/gtest.h" namespace spvtools { namespace diff { namespace { // Test where src and dst have a few large functions with large differences. constexpr char kSrc[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" %15 OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpName %4 "main" OpName %6 "f1(" OpName %8 "f2(" OpName %12 "x" OpName %15 "gl_LocalInvocationID" OpName %20 "y" OpName %27 "image" OpName %44 "sum" OpName %46 "i" OpName %56 "j" OpName %80 "BufferOut" OpMemberName %80 0 "o_uv4" OpMemberName %80 1 "o_v3" OpMemberName %80 2 "o_i" OpName %82 "" OpName %88 "BufferIn" OpMemberName %88 0 "i_u" OpMemberName %88 1 "i_v4" OpMemberName %88 2 "i_f" OpName %90 "" OpName %101 "i" OpName %128 "image2" OpDecorate %15 BuiltIn LocalInvocationId OpDecorate %27 DescriptorSet 0 OpDecorate %27 Binding 2 OpMemberDecorate %80 0 Offset 0 OpMemberDecorate %80 1 Offset 16 OpMemberDecorate %80 2 Offset 28 OpDecorate %80 BufferBlock OpDecorate %82 DescriptorSet 0 OpDecorate %82 Binding 1 OpMemberDecorate %88 0 Offset 0 OpMemberDecorate %88 1 RowMajor OpMemberDecorate %88 1 Offset 16 OpMemberDecorate %88 1 MatrixStride 16 OpMemberDecorate %88 2 Offset 80 OpDecorate %88 Block OpDecorate %90 DescriptorSet 0 OpDecorate %90 Binding 0 OpDecorate %128 DescriptorSet 0 OpDecorate %128 Binding 3 %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeInt 32 0 %11 = OpTypePointer Function %10 %13 = OpTypeVector %10 3 %14 = OpTypePointer Input %13 %15 = OpVariable %14 Input %16 = OpConstant %10 0 %17 = OpTypePointer Input %10 %21 = OpConstant %10 1 %24 = OpTypeInt 32 1 %25 = OpTypeImage %24 2D 0 0 0 2 R32i %26 = OpTypePointer UniformConstant %25 %27 = OpVariable %26 UniformConstant %29 = OpTypeVector %10 2 %32 = OpTypeVector %24 2 %38 = OpTypeVector %24 4 %40 = OpConstant %10 2 %41 = OpConstant %10 3400 %42 = OpConstant %10 264 %43 = OpTypePointer Function %24 %45 = OpConstant %24 0 %53 = OpConstant %24 2 %54 = OpTypeBool %73 = OpConstant %24 1 %77 = OpTypeVector %10 4 %78 = OpTypeFloat 32 %79 = OpTypeVector %78 3 %80 = OpTypeStruct %77 %79 %24 %81 = OpTypePointer Uniform %80 %82 = OpVariable %81 Uniform %84 = OpTypePointer Uniform %24 %86 = OpTypeVector %78 4 %87 = OpTypeMatrix %86 4 %88 = OpTypeStruct %10 %87 %78 %89 = OpTypePointer Uniform %88 %90 = OpVariable %89 Uniform %91 = OpTypePointer Uniform %87 %94 = OpTypePointer Uniform %77 %108 = OpConstant %24 3 %110 = OpTypePointer Uniform %79 %113 = OpTypePointer Uniform %78 %128 = OpVariable %26 UniformConstant %130 = OpConstantComposite %32 %45 %45 %4 = OpFunction %2 None %3 %5 = OpLabel %136 = OpFunctionCall %2 %6 %137 = OpFunctionCall %2 %8 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %12 = OpVariable %11 Function %20 = OpVariable %11 Function %44 = OpVariable %43 Function %46 = OpVariable %43 Function %56 = OpVariable %43 Function %18 = OpAccessChain %17 %15 %16 %19 = OpLoad %10 %18 OpStore %12 %19 %22 = OpAccessChain %17 %15 %21 %23 = OpLoad %10 %22 OpStore %20 %23 %28 = OpLoad %25 %27 %30 = OpLoad %13 %15 %31 = OpVectorShuffle %29 %30 %30 0 1 %33 = OpBitcast %32 %31 %34 = OpLoad %10 %12 %35 = OpLoad %10 %20 %36 = OpIAdd %10 %34 %35 %37 = OpBitcast %24 %36 %39 = OpCompositeConstruct %38 %37 %37 %37 %37 OpImageWrite %28 %33 %39 OpMemoryBarrier %40 %41 OpControlBarrier %40 %40 %42 OpStore %44 %45 OpStore %46 %45 OpBranch %47 %47 = OpLabel OpLoopMerge %49 %50 None OpBranch %51 %51 = OpLabel %52 = OpLoad %24 %46 %55 = OpSLessThan %54 %52 %53 OpBranchConditional %55 %48 %49 %48 = OpLabel OpStore %56 %45 OpBranch %57 %57 = OpLabel OpLoopMerge %59 %60 None OpBranch %61 %61 = OpLabel %62 = OpLoad %24 %56 %63 = OpSLessThan %54 %62 %53 OpBranchConditional %63 %58 %59 %58 = OpLabel %64 = OpLoad %25 %27 %65 = OpLoad %24 %46 %66 = OpLoad %24 %56 %67 = OpCompositeConstruct %32 %65 %66 %68 = OpImageRead %38 %64 %67 %69 = OpCompositeExtract %24 %68 0 %70 = OpLoad %24 %44 %71 = OpIMul %24 %70 %69 OpStore %44 %71 OpBranch %60 %60 = OpLabel %72 = OpLoad %24 %56 %74 = OpIAdd %24 %72 %73 OpStore %56 %74 OpBranch %57 %59 = OpLabel OpBranch %50 %50 = OpLabel %75 = OpLoad %24 %46 %76 = OpIAdd %24 %75 %73 OpStore %46 %76 OpBranch %47 %49 = OpLabel OpMemoryBarrier %40 %41 OpControlBarrier %40 %40 %42 %83 = OpLoad %24 %44 %85 = OpAccessChain %84 %82 %53 OpStore %85 %83 OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %101 = OpVariable %43 Function %92 = OpAccessChain %91 %90 %73 %93 = OpLoad %87 %92 %95 = OpAccessChain %94 %82 %45 %96 = OpLoad %77 %95 %97 = OpConvertUToF %86 %96 %98 = OpMatrixTimesVector %86 %93 %97 %99 = OpConvertFToU %77 %98 %100 = OpAccessChain %94 %82 %45 OpStore %100 %99 OpStore %101 %45 OpBranch %102 %102 = OpLabel OpLoopMerge %104 %105 None OpBranch %106 %106 = OpLabel %107 = OpLoad %24 %101 %109 = OpSLessThan %54 %107 %108 OpBranchConditional %109 %103 %104 %103 = OpLabel %111 = OpAccessChain %110 %82 %73 %112 = OpLoad %79 %111 %114 = OpAccessChain %113 %90 %53 %115 = OpLoad %78 %114 %116 = OpVectorTimesScalar %79 %112 %115 %117 = OpConvertFToU %13 %116 %118 = OpCompositeExtract %10 %117 0 %119 = OpCompositeExtract %10 %117 1 %120 = OpCompositeExtract %10 %117 2 %121 = OpCompositeConstruct %77 %118 %119 %120 %16 %122 = OpAccessChain %94 %82 %45 %123 = OpLoad %77 %122 %124 = OpIAdd %77 %123 %121 %125 = OpAccessChain %94 %82 %45 OpStore %125 %124 OpBranch %105 %105 = OpLabel %126 = OpLoad %24 %101 %127 = OpIAdd %24 %126 %73 OpStore %101 %127 OpBranch %102 %104 = OpLabel OpMemoryBarrier %40 %41 OpControlBarrier %40 %40 %42 %129 = OpLoad %25 %128 %131 = OpImageRead %38 %129 %130 %132 = OpCompositeExtract %24 %131 0 %133 = OpConvertSToF %78 %132 %134 = OpCompositeConstruct %79 %133 %133 %133 %135 = OpAccessChain %110 %82 %73 OpStore %135 %134 OpReturn OpFunctionEnd )"; constexpr char kDst[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" %15 %110 OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpName %4 "main" OpName %6 "f1(" OpName %8 "f2(" OpName %12 "x" OpName %15 "gl_GlobalInvocationID" OpName %20 "z" OpName %26 "i" OpName %40 "BufferOut" OpMemberName %40 0 "o_uv4" OpMemberName %40 1 "o_v3" OpMemberName %40 2 "o_i" OpName %42 "" OpName %63 "image2" OpName %79 "image" OpName %89 "i" OpName %110 "gl_LocalInvocationID" OpName %127 "BufferIn" OpMemberName %127 0 "i_u" OpMemberName %127 1 "i_v4" OpMemberName %127 2 "i_f" OpName %129 "" OpDecorate %15 BuiltIn GlobalInvocationId OpMemberDecorate %40 0 Offset 0 OpMemberDecorate %40 1 Offset 16 OpMemberDecorate %40 2 Offset 28 OpDecorate %40 BufferBlock OpDecorate %42 DescriptorSet 0 OpDecorate %42 Binding 1 OpDecorate %63 DescriptorSet 0 OpDecorate %63 Binding 3 OpDecorate %79 DescriptorSet 0 OpDecorate %79 Binding 2 OpDecorate %110 BuiltIn LocalInvocationId OpMemberDecorate %127 0 Offset 0 OpMemberDecorate %127 1 RowMajor OpMemberDecorate %127 1 Offset 16 OpMemberDecorate %127 1 MatrixStride 16 OpMemberDecorate %127 2 Offset 80 OpDecorate %127 Block OpDecorate %129 DescriptorSet 0 OpDecorate %129 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeInt 32 0 %11 = OpTypePointer Function %10 %13 = OpTypeVector %10 3 %14 = OpTypePointer Input %13 %15 = OpVariable %14 Input %16 = OpConstant %10 0 %17 = OpTypePointer Input %10 %21 = OpConstant %10 1 %24 = OpTypeInt 32 1 %25 = OpTypePointer Function %24 %27 = OpConstant %24 0 %34 = OpConstant %24 2 %35 = OpTypeBool %37 = OpTypeVector %10 4 %38 = OpTypeFloat 32 %39 = OpTypeVector %38 3 %40 = OpTypeStruct %37 %39 %24 %41 = OpTypePointer Uniform %40 %42 = OpVariable %41 Uniform %46 = OpTypeVector %10 2 %48 = OpTypePointer Uniform %37 %53 = OpTypePointer Uniform %10 %59 = OpConstant %24 1 %61 = OpTypeImage %24 2D 0 0 0 2 R32i %62 = OpTypePointer UniformConstant %61 %63 = OpVariable %62 UniformConstant %69 = OpTypeVector %24 2 %71 = OpTypeVector %24 4 %74 = OpTypePointer Uniform %24 %76 = OpConstant %10 2 %77 = OpConstant %10 3400 %78 = OpConstant %10 264 %79 = OpVariable %62 UniformConstant %96 = OpConstant %24 3 %103 = OpConstantComposite %69 %27 %27 %107 = OpTypePointer Uniform %38 %110 = OpVariable %14 Input %113 = OpTypeVector %38 2 %125 = OpTypeVector %38 4 %126 = OpTypeMatrix %125 4 %127 = OpTypeStruct %10 %126 %38 %128 = OpTypePointer Uniform %127 %129 = OpVariable %128 Uniform %4 = OpFunction %2 None %3 %5 = OpLabel %123 = OpFunctionCall %2 %8 %124 = OpFunctionCall %2 %6 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %12 = OpVariable %11 Function %20 = OpVariable %11 Function %26 = OpVariable %25 Function %18 = OpAccessChain %17 %15 %16 %19 = OpLoad %10 %18 OpStore %12 %19 %22 = OpAccessChain %17 %15 %21 %23 = OpLoad %10 %22 OpStore %20 %23 OpStore %26 %27 OpBranch %28 %28 = OpLabel OpLoopMerge %30 %31 None OpBranch %32 %32 = OpLabel %33 = OpLoad %24 %26 %36 = OpSLessThan %35 %33 %34 OpBranchConditional %36 %29 %30 %29 = OpLabel %43 = OpLoad %10 %12 %44 = OpLoad %10 %20 %45 = OpIAdd %10 %43 %44 %47 = OpCompositeConstruct %46 %45 %45 %49 = OpAccessChain %48 %42 %27 %50 = OpLoad %37 %49 %51 = OpVectorShuffle %46 %50 %50 0 1 %52 = OpIAdd %46 %51 %47 %54 = OpAccessChain %53 %42 %27 %16 %55 = OpCompositeExtract %10 %52 0 OpStore %54 %55 %56 = OpAccessChain %53 %42 %27 %21 %57 = OpCompositeExtract %10 %52 1 OpStore %56 %57 OpBranch %31 %31 = OpLabel %58 = OpLoad %24 %26 %60 = OpIAdd %24 %58 %59 OpStore %26 %60 OpBranch %28 %30 = OpLabel %64 = OpLoad %61 %63 %65 = OpLoad %10 %12 %66 = OpBitcast %24 %65 %67 = OpLoad %10 %20 %68 = OpBitcast %24 %67 %70 = OpCompositeConstruct %69 %66 %68 %72 = OpImageRead %71 %64 %70 %73 = OpCompositeExtract %24 %72 1 %75 = OpAccessChain %74 %42 %34 OpStore %75 %73 OpMemoryBarrier %76 %77 OpControlBarrier %76 %76 %78 %80 = OpLoad %61 %79 %81 = OpLoad %10 %20 %82 = OpBitcast %24 %81 %83 = OpLoad %10 %12 %84 = OpBitcast %24 %83 %85 = OpCompositeConstruct %69 %82 %84 %86 = OpAccessChain %74 %42 %34 %87 = OpLoad %24 %86 %88 = OpCompositeConstruct %71 %87 %27 %27 %27 OpImageWrite %80 %85 %88 OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %89 = OpVariable %25 Function OpStore %89 %27 OpBranch %90 %90 = OpLabel OpLoopMerge %92 %93 None OpBranch %94 %94 = OpLabel %95 = OpLoad %24 %89 %97 = OpSLessThan %35 %95 %96 OpBranchConditional %97 %91 %92 %91 = OpLabel %98 = OpLoad %24 %89 %99 = OpIEqual %35 %98 %27 OpSelectionMerge %101 None OpBranchConditional %99 %100 %109 %100 = OpLabel %102 = OpLoad %61 %63 %104 = OpImageRead %71 %102 %103 %105 = OpCompositeExtract %24 %104 0 %106 = OpConvertSToF %38 %105 %108 = OpAccessChain %107 %42 %59 %16 OpStore %108 %106 OpBranch %101 %109 = OpLabel %111 = OpLoad %13 %110 %112 = OpConvertUToF %39 %111 %114 = OpCompositeExtract %38 %112 0 %115 = OpCompositeExtract %38 %112 1 %116 = OpCompositeConstruct %113 %114 %115 %117 = OpAccessChain %107 %42 %59 %21 %118 = OpCompositeExtract %38 %116 0 OpStore %117 %118 %119 = OpAccessChain %107 %42 %59 %76 %120 = OpCompositeExtract %38 %116 1 OpStore %119 %120 OpBranch %101 %101 = OpLabel OpBranch %93 %93 = OpLabel %121 = OpLoad %24 %89 %122 = OpIAdd %24 %121 %59 OpStore %89 %122 OpBranch %90 %92 = OpLabel OpReturn OpFunctionEnd )"; TEST(DiffTest, LargeFunctionsLargeDiffs) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 138 +; Bound: 190 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 -OpEntryPoint GLCompute %4 "main" %15 +OpEntryPoint GLCompute %4 "main" %138 %15 OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpName %4 "main" OpName %6 "f1(" OpName %8 "f2(" OpName %12 "x" +OpName %138 "gl_GlobalInvocationID" OpName %15 "gl_LocalInvocationID" -OpName %20 "y" +OpName %20 "z" OpName %27 "image" -OpName %44 "sum" +OpName %44 "i" -OpName %46 "i" -OpName %56 "j" OpName %80 "BufferOut" OpMemberName %80 0 "o_uv4" OpMemberName %80 1 "o_v3" OpMemberName %80 2 "o_i" OpName %82 "" OpName %88 "BufferIn" OpMemberName %88 0 "i_u" OpMemberName %88 1 "i_v4" OpMemberName %88 2 "i_f" OpName %90 "" OpName %101 "i" OpName %128 "image2" +OpDecorate %138 BuiltIn GlobalInvocationId OpDecorate %15 BuiltIn LocalInvocationId OpDecorate %27 DescriptorSet 0 OpDecorate %27 Binding 2 OpMemberDecorate %80 0 Offset 0 OpMemberDecorate %80 1 Offset 16 OpMemberDecorate %80 2 Offset 28 OpDecorate %80 BufferBlock OpDecorate %82 DescriptorSet 0 OpDecorate %82 Binding 1 OpMemberDecorate %88 0 Offset 0 OpMemberDecorate %88 1 RowMajor OpMemberDecorate %88 1 Offset 16 OpMemberDecorate %88 1 MatrixStride 16 OpMemberDecorate %88 2 Offset 80 OpDecorate %88 Block OpDecorate %90 DescriptorSet 0 OpDecorate %90 Binding 0 OpDecorate %128 DescriptorSet 0 OpDecorate %128 Binding 3 %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeInt 32 0 %11 = OpTypePointer Function %10 %13 = OpTypeVector %10 3 %14 = OpTypePointer Input %13 +%138 = OpVariable %14 Input %15 = OpVariable %14 Input %16 = OpConstant %10 0 %17 = OpTypePointer Input %10 %21 = OpConstant %10 1 %24 = OpTypeInt 32 1 %25 = OpTypeImage %24 2D 0 0 0 2 R32i %26 = OpTypePointer UniformConstant %25 %27 = OpVariable %26 UniformConstant %29 = OpTypeVector %10 2 %32 = OpTypeVector %24 2 %38 = OpTypeVector %24 4 %40 = OpConstant %10 2 %41 = OpConstant %10 3400 %42 = OpConstant %10 264 %43 = OpTypePointer Function %24 %45 = OpConstant %24 0 +%149 = OpTypePointer Uniform %10 %53 = OpConstant %24 2 %54 = OpTypeBool %73 = OpConstant %24 1 %77 = OpTypeVector %10 4 %78 = OpTypeFloat 32 %79 = OpTypeVector %78 3 %80 = OpTypeStruct %77 %79 %24 %81 = OpTypePointer Uniform %80 %82 = OpVariable %81 Uniform %84 = OpTypePointer Uniform %24 %86 = OpTypeVector %78 4 %87 = OpTypeMatrix %86 4 %88 = OpTypeStruct %10 %87 %78 %89 = OpTypePointer Uniform %88 %90 = OpVariable %89 Uniform -%91 = OpTypePointer Uniform %87 +%179 = OpTypeVector %78 2 %94 = OpTypePointer Uniform %77 %108 = OpConstant %24 3 -%110 = OpTypePointer Uniform %79 %113 = OpTypePointer Uniform %78 %128 = OpVariable %26 UniformConstant %130 = OpConstantComposite %32 %45 %45 %4 = OpFunction %2 None %3 %5 = OpLabel -%136 = OpFunctionCall %2 %6 %137 = OpFunctionCall %2 %8 +%189 = OpFunctionCall %2 %6 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %12 = OpVariable %11 Function %20 = OpVariable %11 Function %44 = OpVariable %43 Function -%46 = OpVariable %43 Function -%56 = OpVariable %43 Function -%18 = OpAccessChain %17 %15 %16 +%139 = OpAccessChain %17 %138 %16 -%19 = OpLoad %10 %18 +%19 = OpLoad %10 %139 OpStore %12 %19 -%22 = OpAccessChain %17 %15 %21 +%140 = OpAccessChain %17 %138 %21 -%23 = OpLoad %10 %22 +%23 = OpLoad %10 %140 OpStore %20 %23 -%28 = OpLoad %25 %27 -%30 = OpLoad %13 %15 -%31 = OpVectorShuffle %29 %30 %30 0 1 -%33 = OpBitcast %32 %31 -%34 = OpLoad %10 %12 -%35 = OpLoad %10 %20 -%36 = OpIAdd %10 %34 %35 -%37 = OpBitcast %24 %36 -%39 = OpCompositeConstruct %38 %37 %37 %37 %37 -OpImageWrite %28 %33 %39 -OpMemoryBarrier %40 %41 -OpControlBarrier %40 %40 %42 OpStore %44 %45 -OpStore %46 %45 OpBranch %47 %47 = OpLabel -OpLoopMerge %49 %50 None +OpLoopMerge %49 %59 None OpBranch %51 %51 = OpLabel -%52 = OpLoad %24 %46 +%52 = OpLoad %24 %44 %55 = OpSLessThan %54 %52 %53 OpBranchConditional %55 %48 %49 %48 = OpLabel -OpStore %56 %45 -OpBranch %57 -%57 = OpLabel -OpLoopMerge %59 %60 None -OpBranch %61 -%61 = OpLabel -%62 = OpLoad %24 %56 -%63 = OpSLessThan %54 %62 %53 -OpBranchConditional %63 %58 %59 -%58 = OpLabel -%64 = OpLoad %25 %27 -%65 = OpLoad %24 %46 -%66 = OpLoad %24 %56 -%67 = OpCompositeConstruct %32 %65 %66 -%68 = OpImageRead %38 %64 %67 -%69 = OpCompositeExtract %24 %68 0 -%70 = OpLoad %24 %44 -%71 = OpIMul %24 %70 %69 +%141 = OpLoad %10 %12 +%142 = OpLoad %10 %20 +%143 = OpIAdd %10 %141 %142 +%144 = OpCompositeConstruct %29 %143 %143 +%145 = OpAccessChain %94 %82 %45 +%146 = OpLoad %77 %145 +%147 = OpVectorShuffle %29 %146 %146 0 1 +%148 = OpIAdd %29 %147 %144 +%150 = OpAccessChain %149 %82 %45 %16 +%151 = OpCompositeExtract %10 %148 0 -OpStore %44 %71 +OpStore %150 %151 -OpBranch %60 -%60 = OpLabel -%72 = OpLoad %24 %56 -%74 = OpIAdd %24 %72 %73 +%152 = OpAccessChain %149 %82 %45 %21 +%153 = OpCompositeExtract %10 %148 1 -OpStore %56 %74 +OpStore %152 %153 -OpBranch %57 +OpBranch %59 %59 = OpLabel -OpBranch %50 -%50 = OpLabel -%75 = OpLoad %24 %46 +%75 = OpLoad %24 %44 %76 = OpIAdd %24 %75 %73 -OpStore %46 %76 +OpStore %44 %76 OpBranch %47 %49 = OpLabel +%154 = OpLoad %25 %128 +%155 = OpLoad %10 %12 +%156 = OpBitcast %24 %155 +%157 = OpLoad %10 %20 +%158 = OpBitcast %24 %157 +%159 = OpCompositeConstruct %32 %156 %158 +%160 = OpImageRead %38 %154 %159 +%161 = OpCompositeExtract %24 %160 1 +%162 = OpAccessChain %84 %82 %53 +OpStore %162 %161 OpMemoryBarrier %40 %41 OpControlBarrier %40 %40 %42 -%83 = OpLoad %24 %44 +%163 = OpLoad %25 %27 +%164 = OpLoad %10 %20 +%165 = OpBitcast %24 %164 +%166 = OpLoad %10 %12 +%167 = OpBitcast %24 %166 +%168 = OpCompositeConstruct %32 %165 %167 %85 = OpAccessChain %84 %82 %53 -OpStore %85 %83 +%169 = OpLoad %24 %85 +%170 = OpCompositeConstruct %38 %169 %45 %45 %45 +OpImageWrite %163 %168 %170 OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %101 = OpVariable %43 Function -%92 = OpAccessChain %91 %90 %73 -%93 = OpLoad %87 %92 -%95 = OpAccessChain %94 %82 %45 -%96 = OpLoad %77 %95 -%97 = OpConvertUToF %86 %96 -%98 = OpMatrixTimesVector %86 %93 %97 -%99 = OpConvertFToU %77 %98 -%100 = OpAccessChain %94 %82 %45 -OpStore %100 %99 +OpStore %101 %45 -OpStore %101 %45 OpBranch %102 %102 = OpLabel -OpLoopMerge %104 %105 None +OpLoopMerge %171 %172 None OpBranch %106 %106 = OpLabel %107 = OpLoad %24 %101 %109 = OpSLessThan %54 %107 %108 -OpBranchConditional %109 %103 %104 +OpBranchConditional %109 %103 %171 %103 = OpLabel -%111 = OpAccessChain %110 %82 %73 -%112 = OpLoad %79 %111 -%114 = OpAccessChain %113 %90 %53 -%115 = OpLoad %78 %114 -%116 = OpVectorTimesScalar %79 %112 %115 -%117 = OpConvertFToU %13 %116 -%118 = OpCompositeExtract %10 %117 0 -%119 = OpCompositeExtract %10 %117 1 -%120 = OpCompositeExtract %10 %117 2 -%121 = OpCompositeConstruct %77 %118 %119 %120 %16 -%122 = OpAccessChain %94 %82 %45 -%123 = OpLoad %77 %122 -%124 = OpIAdd %77 %123 %121 -%125 = OpAccessChain %94 %82 %45 -OpStore %125 %124 -OpBranch %105 -%105 = OpLabel %126 = OpLoad %24 %101 -%127 = OpIAdd %24 %126 %73 +%173 = OpIEqual %54 %126 %45 +OpSelectionMerge %174 None +OpBranchConditional %173 %104 %176 +%176 = OpLabel +%177 = OpLoad %13 %15 +%178 = OpConvertUToF %79 %177 +%180 = OpCompositeExtract %78 %178 0 +%181 = OpCompositeExtract %78 %178 1 +%182 = OpCompositeConstruct %179 %180 %181 +%183 = OpAccessChain %113 %82 %73 %21 +%184 = OpCompositeExtract %78 %182 0 -OpStore %101 %127 +OpStore %183 %184 +%185 = OpAccessChain %113 %82 %73 %40 +%186 = OpCompositeExtract %78 %182 1 +OpStore %185 %186 -OpBranch %102 +OpBranch %174 %104 = OpLabel -OpMemoryBarrier %40 %41 -OpControlBarrier %40 %40 %42 %129 = OpLoad %25 %128 %131 = OpImageRead %38 %129 %130 %132 = OpCompositeExtract %24 %131 0 %133 = OpConvertSToF %78 %132 -%134 = OpCompositeConstruct %79 %133 %133 %133 -%135 = OpAccessChain %110 %82 %73 +%175 = OpAccessChain %113 %82 %73 %16 -OpStore %135 %134 +OpStore %175 %133 +OpBranch %174 +%174 = OpLabel +OpBranch %172 +%172 = OpLabel +%187 = OpLoad %24 %101 +%188 = OpIAdd %24 %187 %73 +OpStore %101 %188 +OpBranch %102 +%171 = OpLabel OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrc, kDst, kDiff, options); } TEST(DiffTest, LargeFunctionsLargeDiffsNoDebug) { constexpr char kSrcNoDebug[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" %15 OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpDecorate %15 BuiltIn LocalInvocationId OpDecorate %27 DescriptorSet 0 OpDecorate %27 Binding 2 OpMemberDecorate %80 0 Offset 0 OpMemberDecorate %80 1 Offset 16 OpMemberDecorate %80 2 Offset 28 OpDecorate %80 BufferBlock OpDecorate %82 DescriptorSet 0 OpDecorate %82 Binding 1 OpMemberDecorate %88 0 Offset 0 OpMemberDecorate %88 1 RowMajor OpMemberDecorate %88 1 Offset 16 OpMemberDecorate %88 1 MatrixStride 16 OpMemberDecorate %88 2 Offset 80 OpDecorate %88 Block OpDecorate %90 DescriptorSet 0 OpDecorate %90 Binding 0 OpDecorate %128 DescriptorSet 0 OpDecorate %128 Binding 3 %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeInt 32 0 %11 = OpTypePointer Function %10 %13 = OpTypeVector %10 3 %14 = OpTypePointer Input %13 %15 = OpVariable %14 Input %16 = OpConstant %10 0 %17 = OpTypePointer Input %10 %21 = OpConstant %10 1 %24 = OpTypeInt 32 1 %25 = OpTypeImage %24 2D 0 0 0 2 R32i %26 = OpTypePointer UniformConstant %25 %27 = OpVariable %26 UniformConstant %29 = OpTypeVector %10 2 %32 = OpTypeVector %24 2 %38 = OpTypeVector %24 4 %40 = OpConstant %10 2 %41 = OpConstant %10 3400 %42 = OpConstant %10 264 %43 = OpTypePointer Function %24 %45 = OpConstant %24 0 %53 = OpConstant %24 2 %54 = OpTypeBool %73 = OpConstant %24 1 %77 = OpTypeVector %10 4 %78 = OpTypeFloat 32 %79 = OpTypeVector %78 3 %80 = OpTypeStruct %77 %79 %24 %81 = OpTypePointer Uniform %80 %82 = OpVariable %81 Uniform %84 = OpTypePointer Uniform %24 %86 = OpTypeVector %78 4 %87 = OpTypeMatrix %86 4 %88 = OpTypeStruct %10 %87 %78 %89 = OpTypePointer Uniform %88 %90 = OpVariable %89 Uniform %91 = OpTypePointer Uniform %87 %94 = OpTypePointer Uniform %77 %108 = OpConstant %24 3 %110 = OpTypePointer Uniform %79 %113 = OpTypePointer Uniform %78 %128 = OpVariable %26 UniformConstant %130 = OpConstantComposite %32 %45 %45 %4 = OpFunction %2 None %3 %5 = OpLabel %136 = OpFunctionCall %2 %6 %137 = OpFunctionCall %2 %8 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %12 = OpVariable %11 Function %20 = OpVariable %11 Function %44 = OpVariable %43 Function %46 = OpVariable %43 Function %56 = OpVariable %43 Function %18 = OpAccessChain %17 %15 %16 %19 = OpLoad %10 %18 OpStore %12 %19 %22 = OpAccessChain %17 %15 %21 %23 = OpLoad %10 %22 OpStore %20 %23 %28 = OpLoad %25 %27 %30 = OpLoad %13 %15 %31 = OpVectorShuffle %29 %30 %30 0 1 %33 = OpBitcast %32 %31 %34 = OpLoad %10 %12 %35 = OpLoad %10 %20 %36 = OpIAdd %10 %34 %35 %37 = OpBitcast %24 %36 %39 = OpCompositeConstruct %38 %37 %37 %37 %37 OpImageWrite %28 %33 %39 OpMemoryBarrier %40 %41 OpControlBarrier %40 %40 %42 OpStore %44 %45 OpStore %46 %45 OpBranch %47 %47 = OpLabel OpLoopMerge %49 %50 None OpBranch %51 %51 = OpLabel %52 = OpLoad %24 %46 %55 = OpSLessThan %54 %52 %53 OpBranchConditional %55 %48 %49 %48 = OpLabel OpStore %56 %45 OpBranch %57 %57 = OpLabel OpLoopMerge %59 %60 None OpBranch %61 %61 = OpLabel %62 = OpLoad %24 %56 %63 = OpSLessThan %54 %62 %53 OpBranchConditional %63 %58 %59 %58 = OpLabel %64 = OpLoad %25 %27 %65 = OpLoad %24 %46 %66 = OpLoad %24 %56 %67 = OpCompositeConstruct %32 %65 %66 %68 = OpImageRead %38 %64 %67 %69 = OpCompositeExtract %24 %68 0 %70 = OpLoad %24 %44 %71 = OpIMul %24 %70 %69 OpStore %44 %71 OpBranch %60 %60 = OpLabel %72 = OpLoad %24 %56 %74 = OpIAdd %24 %72 %73 OpStore %56 %74 OpBranch %57 %59 = OpLabel OpBranch %50 %50 = OpLabel %75 = OpLoad %24 %46 %76 = OpIAdd %24 %75 %73 OpStore %46 %76 OpBranch %47 %49 = OpLabel OpMemoryBarrier %40 %41 OpControlBarrier %40 %40 %42 %83 = OpLoad %24 %44 %85 = OpAccessChain %84 %82 %53 OpStore %85 %83 OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %101 = OpVariable %43 Function %92 = OpAccessChain %91 %90 %73 %93 = OpLoad %87 %92 %95 = OpAccessChain %94 %82 %45 %96 = OpLoad %77 %95 %97 = OpConvertUToF %86 %96 %98 = OpMatrixTimesVector %86 %93 %97 %99 = OpConvertFToU %77 %98 %100 = OpAccessChain %94 %82 %45 OpStore %100 %99 OpStore %101 %45 OpBranch %102 %102 = OpLabel OpLoopMerge %104 %105 None OpBranch %106 %106 = OpLabel %107 = OpLoad %24 %101 %109 = OpSLessThan %54 %107 %108 OpBranchConditional %109 %103 %104 %103 = OpLabel %111 = OpAccessChain %110 %82 %73 %112 = OpLoad %79 %111 %114 = OpAccessChain %113 %90 %53 %115 = OpLoad %78 %114 %116 = OpVectorTimesScalar %79 %112 %115 %117 = OpConvertFToU %13 %116 %118 = OpCompositeExtract %10 %117 0 %119 = OpCompositeExtract %10 %117 1 %120 = OpCompositeExtract %10 %117 2 %121 = OpCompositeConstruct %77 %118 %119 %120 %16 %122 = OpAccessChain %94 %82 %45 %123 = OpLoad %77 %122 %124 = OpIAdd %77 %123 %121 %125 = OpAccessChain %94 %82 %45 OpStore %125 %124 OpBranch %105 %105 = OpLabel %126 = OpLoad %24 %101 %127 = OpIAdd %24 %126 %73 OpStore %101 %127 OpBranch %102 %104 = OpLabel OpMemoryBarrier %40 %41 OpControlBarrier %40 %40 %42 %129 = OpLoad %25 %128 %131 = OpImageRead %38 %129 %130 %132 = OpCompositeExtract %24 %131 0 %133 = OpConvertSToF %78 %132 %134 = OpCompositeConstruct %79 %133 %133 %133 %135 = OpAccessChain %110 %82 %73 OpStore %135 %134 OpReturn OpFunctionEnd )"; constexpr char kDstNoDebug[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" %15 %110 OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpDecorate %15 BuiltIn GlobalInvocationId OpMemberDecorate %40 0 Offset 0 OpMemberDecorate %40 1 Offset 16 OpMemberDecorate %40 2 Offset 28 OpDecorate %40 BufferBlock OpDecorate %42 DescriptorSet 0 OpDecorate %42 Binding 1 OpDecorate %63 DescriptorSet 0 OpDecorate %63 Binding 3 OpDecorate %79 DescriptorSet 0 OpDecorate %79 Binding 2 OpDecorate %110 BuiltIn LocalInvocationId OpMemberDecorate %127 0 Offset 0 OpMemberDecorate %127 1 RowMajor OpMemberDecorate %127 1 Offset 16 OpMemberDecorate %127 1 MatrixStride 16 OpMemberDecorate %127 2 Offset 80 OpDecorate %127 Block OpDecorate %129 DescriptorSet 0 OpDecorate %129 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeInt 32 0 %11 = OpTypePointer Function %10 %13 = OpTypeVector %10 3 %14 = OpTypePointer Input %13 %15 = OpVariable %14 Input %16 = OpConstant %10 0 %17 = OpTypePointer Input %10 %21 = OpConstant %10 1 %24 = OpTypeInt 32 1 %25 = OpTypePointer Function %24 %27 = OpConstant %24 0 %34 = OpConstant %24 2 %35 = OpTypeBool %37 = OpTypeVector %10 4 %38 = OpTypeFloat 32 %39 = OpTypeVector %38 3 %40 = OpTypeStruct %37 %39 %24 %41 = OpTypePointer Uniform %40 %42 = OpVariable %41 Uniform %46 = OpTypeVector %10 2 %48 = OpTypePointer Uniform %37 %53 = OpTypePointer Uniform %10 %59 = OpConstant %24 1 %61 = OpTypeImage %24 2D 0 0 0 2 R32i %62 = OpTypePointer UniformConstant %61 %63 = OpVariable %62 UniformConstant %69 = OpTypeVector %24 2 %71 = OpTypeVector %24 4 %74 = OpTypePointer Uniform %24 %76 = OpConstant %10 2 %77 = OpConstant %10 3400 %78 = OpConstant %10 264 %79 = OpVariable %62 UniformConstant %96 = OpConstant %24 3 %103 = OpConstantComposite %69 %27 %27 %107 = OpTypePointer Uniform %38 %110 = OpVariable %14 Input %113 = OpTypeVector %38 2 %125 = OpTypeVector %38 4 %126 = OpTypeMatrix %125 4 %127 = OpTypeStruct %10 %126 %38 %128 = OpTypePointer Uniform %127 %129 = OpVariable %128 Uniform %4 = OpFunction %2 None %3 %5 = OpLabel %123 = OpFunctionCall %2 %8 %124 = OpFunctionCall %2 %6 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %12 = OpVariable %11 Function %20 = OpVariable %11 Function %26 = OpVariable %25 Function %18 = OpAccessChain %17 %15 %16 %19 = OpLoad %10 %18 OpStore %12 %19 %22 = OpAccessChain %17 %15 %21 %23 = OpLoad %10 %22 OpStore %20 %23 OpStore %26 %27 OpBranch %28 %28 = OpLabel OpLoopMerge %30 %31 None OpBranch %32 %32 = OpLabel %33 = OpLoad %24 %26 %36 = OpSLessThan %35 %33 %34 OpBranchConditional %36 %29 %30 %29 = OpLabel %43 = OpLoad %10 %12 %44 = OpLoad %10 %20 %45 = OpIAdd %10 %43 %44 %47 = OpCompositeConstruct %46 %45 %45 %49 = OpAccessChain %48 %42 %27 %50 = OpLoad %37 %49 %51 = OpVectorShuffle %46 %50 %50 0 1 %52 = OpIAdd %46 %51 %47 %54 = OpAccessChain %53 %42 %27 %16 %55 = OpCompositeExtract %10 %52 0 OpStore %54 %55 %56 = OpAccessChain %53 %42 %27 %21 %57 = OpCompositeExtract %10 %52 1 OpStore %56 %57 OpBranch %31 %31 = OpLabel %58 = OpLoad %24 %26 %60 = OpIAdd %24 %58 %59 OpStore %26 %60 OpBranch %28 %30 = OpLabel %64 = OpLoad %61 %63 %65 = OpLoad %10 %12 %66 = OpBitcast %24 %65 %67 = OpLoad %10 %20 %68 = OpBitcast %24 %67 %70 = OpCompositeConstruct %69 %66 %68 %72 = OpImageRead %71 %64 %70 %73 = OpCompositeExtract %24 %72 1 %75 = OpAccessChain %74 %42 %34 OpStore %75 %73 OpMemoryBarrier %76 %77 OpControlBarrier %76 %76 %78 %80 = OpLoad %61 %79 %81 = OpLoad %10 %20 %82 = OpBitcast %24 %81 %83 = OpLoad %10 %12 %84 = OpBitcast %24 %83 %85 = OpCompositeConstruct %69 %82 %84 %86 = OpAccessChain %74 %42 %34 %87 = OpLoad %24 %86 %88 = OpCompositeConstruct %71 %87 %27 %27 %27 OpImageWrite %80 %85 %88 OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %89 = OpVariable %25 Function OpStore %89 %27 OpBranch %90 %90 = OpLabel OpLoopMerge %92 %93 None OpBranch %94 %94 = OpLabel %95 = OpLoad %24 %89 %97 = OpSLessThan %35 %95 %96 OpBranchConditional %97 %91 %92 %91 = OpLabel %98 = OpLoad %24 %89 %99 = OpIEqual %35 %98 %27 OpSelectionMerge %101 None OpBranchConditional %99 %100 %109 %100 = OpLabel %102 = OpLoad %61 %63 %104 = OpImageRead %71 %102 %103 %105 = OpCompositeExtract %24 %104 0 %106 = OpConvertSToF %38 %105 %108 = OpAccessChain %107 %42 %59 %16 OpStore %108 %106 OpBranch %101 %109 = OpLabel %111 = OpLoad %13 %110 %112 = OpConvertUToF %39 %111 %114 = OpCompositeExtract %38 %112 0 %115 = OpCompositeExtract %38 %112 1 %116 = OpCompositeConstruct %113 %114 %115 %117 = OpAccessChain %107 %42 %59 %21 %118 = OpCompositeExtract %38 %116 0 OpStore %117 %118 %119 = OpAccessChain %107 %42 %59 %76 %120 = OpCompositeExtract %38 %116 1 OpStore %119 %120 OpBranch %101 %101 = OpLabel OpBranch %93 %93 = OpLabel %121 = OpLoad %24 %89 %122 = OpIAdd %24 %121 %59 OpStore %89 %122 OpBranch %90 %92 = OpLabel OpReturn OpFunctionEnd )"; constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 138 +; Bound: 220 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 -OpEntryPoint GLCompute %4 "main" %15 +OpEntryPoint GLCompute %4 "main" %143 %15 OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 +OpDecorate %143 BuiltIn GlobalInvocationId OpDecorate %15 BuiltIn LocalInvocationId OpDecorate %27 DescriptorSet 0 OpDecorate %27 Binding 2 OpMemberDecorate %80 0 Offset 0 OpMemberDecorate %80 1 Offset 16 OpMemberDecorate %80 2 Offset 28 OpDecorate %80 BufferBlock OpDecorate %82 DescriptorSet 0 OpDecorate %82 Binding 1 OpMemberDecorate %88 0 Offset 0 OpMemberDecorate %88 1 RowMajor OpMemberDecorate %88 1 Offset 16 OpMemberDecorate %88 1 MatrixStride 16 OpMemberDecorate %88 2 Offset 80 OpDecorate %88 Block OpDecorate %90 DescriptorSet 0 OpDecorate %90 Binding 0 OpDecorate %128 DescriptorSet 0 OpDecorate %128 Binding 3 %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeInt 32 0 %11 = OpTypePointer Function %10 %13 = OpTypeVector %10 3 %14 = OpTypePointer Input %13 +%143 = OpVariable %14 Input %15 = OpVariable %14 Input %16 = OpConstant %10 0 %17 = OpTypePointer Input %10 %21 = OpConstant %10 1 %24 = OpTypeInt 32 1 %25 = OpTypeImage %24 2D 0 0 0 2 R32i %26 = OpTypePointer UniformConstant %25 %27 = OpVariable %26 UniformConstant %29 = OpTypeVector %10 2 %32 = OpTypeVector %24 2 %38 = OpTypeVector %24 4 %40 = OpConstant %10 2 %41 = OpConstant %10 3400 %42 = OpConstant %10 264 %43 = OpTypePointer Function %24 %45 = OpConstant %24 0 +%165 = OpTypePointer Uniform %10 %53 = OpConstant %24 2 %54 = OpTypeBool %73 = OpConstant %24 1 %77 = OpTypeVector %10 4 %78 = OpTypeFloat 32 %79 = OpTypeVector %78 3 %80 = OpTypeStruct %77 %79 %24 %81 = OpTypePointer Uniform %80 %82 = OpVariable %81 Uniform %84 = OpTypePointer Uniform %24 %86 = OpTypeVector %78 4 %87 = OpTypeMatrix %86 4 %88 = OpTypeStruct %10 %87 %78 %89 = OpTypePointer Uniform %88 %90 = OpVariable %89 Uniform -%91 = OpTypePointer Uniform %87 +%210 = OpTypeVector %78 2 %94 = OpTypePointer Uniform %77 %108 = OpConstant %24 3 -%110 = OpTypePointer Uniform %79 %113 = OpTypePointer Uniform %78 %128 = OpVariable %26 UniformConstant %130 = OpConstantComposite %32 %45 %45 %4 = OpFunction %2 None %3 %5 = OpLabel -%136 = OpFunctionCall %2 %6 +%136 = OpFunctionCall %2 %140 -%137 = OpFunctionCall %2 %8 +%137 = OpFunctionCall %2 %138 OpReturn OpFunctionEnd -%6 = OpFunction %2 None %3 -%7 = OpLabel -%12 = OpVariable %11 Function -%20 = OpVariable %11 Function -%44 = OpVariable %43 Function -%46 = OpVariable %43 Function -%56 = OpVariable %43 Function -%18 = OpAccessChain %17 %15 %16 -%19 = OpLoad %10 %18 -OpStore %12 %19 -%22 = OpAccessChain %17 %15 %21 -%23 = OpLoad %10 %22 -OpStore %20 %23 -%28 = OpLoad %25 %27 -%30 = OpLoad %13 %15 -%31 = OpVectorShuffle %29 %30 %30 0 1 -%33 = OpBitcast %32 %31 -%34 = OpLoad %10 %12 -%35 = OpLoad %10 %20 -%36 = OpIAdd %10 %34 %35 -%37 = OpBitcast %24 %36 -%39 = OpCompositeConstruct %38 %37 %37 %37 %37 -OpImageWrite %28 %33 %39 -OpMemoryBarrier %40 %41 -OpControlBarrier %40 %40 %42 -OpStore %44 %45 -OpStore %46 %45 -OpBranch %47 -%47 = OpLabel -OpLoopMerge %49 %50 None -OpBranch %51 -%51 = OpLabel -%52 = OpLoad %24 %46 -%55 = OpSLessThan %54 %52 %53 -OpBranchConditional %55 %48 %49 -%48 = OpLabel -OpStore %56 %45 -OpBranch %57 -%57 = OpLabel -OpLoopMerge %59 %60 None -OpBranch %61 -%61 = OpLabel -%62 = OpLoad %24 %56 -%63 = OpSLessThan %54 %62 %53 -OpBranchConditional %63 %58 %59 -%58 = OpLabel -%64 = OpLoad %25 %27 -%65 = OpLoad %24 %46 -%66 = OpLoad %24 %56 -%67 = OpCompositeConstruct %32 %65 %66 -%68 = OpImageRead %38 %64 %67 -%69 = OpCompositeExtract %24 %68 0 -%70 = OpLoad %24 %44 -%71 = OpIMul %24 %70 %69 -OpStore %44 %71 -OpBranch %60 -%60 = OpLabel -%72 = OpLoad %24 %56 -%74 = OpIAdd %24 %72 %73 -OpStore %56 %74 -OpBranch %57 -%59 = OpLabel -OpBranch %50 -%50 = OpLabel -%75 = OpLoad %24 %46 -%76 = OpIAdd %24 %75 %73 -OpStore %46 %76 -OpBranch %47 -%49 = OpLabel -OpMemoryBarrier %40 %41 -OpControlBarrier %40 %40 %42 -%83 = OpLoad %24 %44 -%85 = OpAccessChain %84 %82 %53 -OpStore %85 %83 -OpReturn -OpFunctionEnd -%8 = OpFunction %2 None %3 -%9 = OpLabel -%101 = OpVariable %43 Function -%92 = OpAccessChain %91 %90 %73 -%93 = OpLoad %87 %92 -%95 = OpAccessChain %94 %82 %45 -%96 = OpLoad %77 %95 -%97 = OpConvertUToF %86 %96 -%98 = OpMatrixTimesVector %86 %93 %97 -%99 = OpConvertFToU %77 %98 -%100 = OpAccessChain %94 %82 %45 -OpStore %100 %99 -OpStore %101 %45 -OpBranch %102 -%102 = OpLabel -OpLoopMerge %104 %105 None -OpBranch %106 -%106 = OpLabel -%107 = OpLoad %24 %101 -%109 = OpSLessThan %54 %107 %108 -OpBranchConditional %109 %103 %104 -%103 = OpLabel -%111 = OpAccessChain %110 %82 %73 -%112 = OpLoad %79 %111 -%114 = OpAccessChain %113 %90 %53 -%115 = OpLoad %78 %114 -%116 = OpVectorTimesScalar %79 %112 %115 -%117 = OpConvertFToU %13 %116 -%118 = OpCompositeExtract %10 %117 0 -%119 = OpCompositeExtract %10 %117 1 -%120 = OpCompositeExtract %10 %117 2 -%121 = OpCompositeConstruct %77 %118 %119 %120 %16 -%122 = OpAccessChain %94 %82 %45 -%123 = OpLoad %77 %122 -%124 = OpIAdd %77 %123 %121 -%125 = OpAccessChain %94 %82 %45 -OpStore %125 %124 -OpBranch %105 -%105 = OpLabel -%126 = OpLoad %24 %101 -%127 = OpIAdd %24 %126 %73 -OpStore %101 %127 -OpBranch %102 -%104 = OpLabel -OpMemoryBarrier %40 %41 -OpControlBarrier %40 %40 %42 -%129 = OpLoad %25 %128 -%131 = OpImageRead %38 %129 %130 -%132 = OpCompositeExtract %24 %131 0 -%133 = OpConvertSToF %78 %132 -%134 = OpCompositeConstruct %79 %133 %133 %133 -%135 = OpAccessChain %110 %82 %73 -OpStore %135 %134 -OpReturn -OpFunctionEnd +%138 = OpFunction %2 None %3 +%139 = OpLabel +%142 = OpVariable %11 Function +%146 = OpVariable %11 Function +%149 = OpVariable %43 Function +%144 = OpAccessChain %17 %143 %16 +%145 = OpLoad %10 %144 +OpStore %142 %145 +%147 = OpAccessChain %17 %143 %21 +%148 = OpLoad %10 %147 +OpStore %146 %148 +OpStore %149 %45 +OpBranch %150 +%150 = OpLabel +OpLoopMerge %152 %153 None +OpBranch %154 +%154 = OpLabel +%155 = OpLoad %24 %149 +%156 = OpSLessThan %54 %155 %53 +OpBranchConditional %156 %151 %152 +%151 = OpLabel +%157 = OpLoad %10 %142 +%158 = OpLoad %10 %146 +%159 = OpIAdd %10 %157 %158 +%160 = OpCompositeConstruct %29 %159 %159 +%161 = OpAccessChain %94 %82 %45 +%162 = OpLoad %77 %161 +%163 = OpVectorShuffle %29 %162 %162 0 1 +%164 = OpIAdd %29 %163 %160 +%166 = OpAccessChain %165 %82 %45 %16 +%167 = OpCompositeExtract %10 %164 0 +OpStore %166 %167 +%168 = OpAccessChain %165 %82 %45 %21 +%169 = OpCompositeExtract %10 %164 1 +OpStore %168 %169 +OpBranch %153 +%153 = OpLabel +%170 = OpLoad %24 %149 +%171 = OpIAdd %24 %170 %73 +OpStore %149 %171 +OpBranch %150 +%152 = OpLabel +%172 = OpLoad %25 %128 +%173 = OpLoad %10 %142 +%174 = OpBitcast %24 %173 +%175 = OpLoad %10 %146 +%176 = OpBitcast %24 %175 +%177 = OpCompositeConstruct %32 %174 %176 +%178 = OpImageRead %38 %172 %177 +%179 = OpCompositeExtract %24 %178 1 +%180 = OpAccessChain %84 %82 %53 +OpStore %180 %179 +OpMemoryBarrier %40 %41 +OpControlBarrier %40 %40 %42 +%181 = OpLoad %25 %27 +%182 = OpLoad %10 %146 +%183 = OpBitcast %24 %182 +%184 = OpLoad %10 %142 +%185 = OpBitcast %24 %184 +%186 = OpCompositeConstruct %32 %183 %185 +%187 = OpAccessChain %84 %82 %53 +%188 = OpLoad %24 %187 +%189 = OpCompositeConstruct %38 %188 %45 %45 %45 +OpImageWrite %181 %186 %189 +OpReturn +OpFunctionEnd +%140 = OpFunction %2 None %3 +%141 = OpLabel +%190 = OpVariable %43 Function +OpStore %190 %45 +OpBranch %191 +%191 = OpLabel +OpLoopMerge %193 %194 None +OpBranch %195 +%195 = OpLabel +%196 = OpLoad %24 %190 +%197 = OpSLessThan %54 %196 %108 +OpBranchConditional %197 %192 %193 +%192 = OpLabel +%198 = OpLoad %24 %190 +%199 = OpIEqual %54 %198 %45 +OpSelectionMerge %201 None +OpBranchConditional %199 %200 %207 +%207 = OpLabel +%208 = OpLoad %13 %15 +%209 = OpConvertUToF %79 %208 +%211 = OpCompositeExtract %78 %209 0 +%212 = OpCompositeExtract %78 %209 1 +%213 = OpCompositeConstruct %210 %211 %212 +%214 = OpAccessChain %113 %82 %73 %21 +%215 = OpCompositeExtract %78 %213 0 +OpStore %214 %215 +%216 = OpAccessChain %113 %82 %73 %40 +%217 = OpCompositeExtract %78 %213 1 +OpStore %216 %217 +OpBranch %201 +%200 = OpLabel +%202 = OpLoad %25 %128 +%203 = OpImageRead %38 %202 %130 +%204 = OpCompositeExtract %24 %203 0 +%205 = OpConvertSToF %78 %204 +%206 = OpAccessChain %113 %82 %73 %16 +OpStore %206 %205 +OpBranch %201 +%201 = OpLabel +OpBranch %194 +%194 = OpLabel +%218 = OpLoad %24 %190 +%219 = OpIAdd %24 %218 %73 +OpStore %190 %219 +OpBranch %191 +%193 = OpLabel +OpReturn +OpFunctionEnd )"; Options options; DoStringDiffTest(kSrcNoDebug, kDstNoDebug, kDiff, options); } } // namespace } // namespace diff } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/large_functions_large_diffs_dst.spvasm000066400000000000000000000170551475742701700323360ustar00rootroot00000000000000 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" %15 %110 OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpName %4 "main" OpName %6 "f1(" OpName %8 "f2(" OpName %12 "x" OpName %15 "gl_GlobalInvocationID" OpName %20 "z" OpName %26 "i" OpName %40 "BufferOut" OpMemberName %40 0 "o_uv4" OpMemberName %40 1 "o_v3" OpMemberName %40 2 "o_i" OpName %42 "" OpName %63 "image2" OpName %79 "image" OpName %89 "i" OpName %110 "gl_LocalInvocationID" OpName %127 "BufferIn" OpMemberName %127 0 "i_u" OpMemberName %127 1 "i_v4" OpMemberName %127 2 "i_f" OpName %129 "" OpDecorate %15 BuiltIn GlobalInvocationId OpMemberDecorate %40 0 Offset 0 OpMemberDecorate %40 1 Offset 16 OpMemberDecorate %40 2 Offset 28 OpDecorate %40 BufferBlock OpDecorate %42 DescriptorSet 0 OpDecorate %42 Binding 1 OpDecorate %63 DescriptorSet 0 OpDecorate %63 Binding 3 OpDecorate %79 DescriptorSet 0 OpDecorate %79 Binding 2 OpDecorate %110 BuiltIn LocalInvocationId OpMemberDecorate %127 0 Offset 0 OpMemberDecorate %127 1 RowMajor OpMemberDecorate %127 1 Offset 16 OpMemberDecorate %127 1 MatrixStride 16 OpMemberDecorate %127 2 Offset 80 OpDecorate %127 Block OpDecorate %129 DescriptorSet 0 OpDecorate %129 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeInt 32 0 %11 = OpTypePointer Function %10 %13 = OpTypeVector %10 3 %14 = OpTypePointer Input %13 %15 = OpVariable %14 Input %16 = OpConstant %10 0 %17 = OpTypePointer Input %10 %21 = OpConstant %10 1 %24 = OpTypeInt 32 1 %25 = OpTypePointer Function %24 %27 = OpConstant %24 0 %34 = OpConstant %24 2 %35 = OpTypeBool %37 = OpTypeVector %10 4 %38 = OpTypeFloat 32 %39 = OpTypeVector %38 3 %40 = OpTypeStruct %37 %39 %24 %41 = OpTypePointer Uniform %40 %42 = OpVariable %41 Uniform %46 = OpTypeVector %10 2 %48 = OpTypePointer Uniform %37 %53 = OpTypePointer Uniform %10 %59 = OpConstant %24 1 %61 = OpTypeImage %24 2D 0 0 0 2 R32i %62 = OpTypePointer UniformConstant %61 %63 = OpVariable %62 UniformConstant %69 = OpTypeVector %24 2 %71 = OpTypeVector %24 4 %74 = OpTypePointer Uniform %24 %76 = OpConstant %10 2 %77 = OpConstant %10 3400 %78 = OpConstant %10 264 %79 = OpVariable %62 UniformConstant %96 = OpConstant %24 3 %103 = OpConstantComposite %69 %27 %27 %107 = OpTypePointer Uniform %38 %110 = OpVariable %14 Input %113 = OpTypeVector %38 2 %125 = OpTypeVector %38 4 %126 = OpTypeMatrix %125 4 %127 = OpTypeStruct %10 %126 %38 %128 = OpTypePointer Uniform %127 %129 = OpVariable %128 Uniform %4 = OpFunction %2 None %3 %5 = OpLabel %123 = OpFunctionCall %2 %8 %124 = OpFunctionCall %2 %6 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %12 = OpVariable %11 Function %20 = OpVariable %11 Function %26 = OpVariable %25 Function %18 = OpAccessChain %17 %15 %16 %19 = OpLoad %10 %18 OpStore %12 %19 %22 = OpAccessChain %17 %15 %21 %23 = OpLoad %10 %22 OpStore %20 %23 OpStore %26 %27 OpBranch %28 %28 = OpLabel OpLoopMerge %30 %31 None OpBranch %32 %32 = OpLabel %33 = OpLoad %24 %26 %36 = OpSLessThan %35 %33 %34 OpBranchConditional %36 %29 %30 %29 = OpLabel %43 = OpLoad %10 %12 %44 = OpLoad %10 %20 %45 = OpIAdd %10 %43 %44 %47 = OpCompositeConstruct %46 %45 %45 %49 = OpAccessChain %48 %42 %27 %50 = OpLoad %37 %49 %51 = OpVectorShuffle %46 %50 %50 0 1 %52 = OpIAdd %46 %51 %47 %54 = OpAccessChain %53 %42 %27 %16 %55 = OpCompositeExtract %10 %52 0 OpStore %54 %55 %56 = OpAccessChain %53 %42 %27 %21 %57 = OpCompositeExtract %10 %52 1 OpStore %56 %57 OpBranch %31 %31 = OpLabel %58 = OpLoad %24 %26 %60 = OpIAdd %24 %58 %59 OpStore %26 %60 OpBranch %28 %30 = OpLabel %64 = OpLoad %61 %63 %65 = OpLoad %10 %12 %66 = OpBitcast %24 %65 %67 = OpLoad %10 %20 %68 = OpBitcast %24 %67 %70 = OpCompositeConstruct %69 %66 %68 %72 = OpImageRead %71 %64 %70 %73 = OpCompositeExtract %24 %72 1 %75 = OpAccessChain %74 %42 %34 OpStore %75 %73 OpMemoryBarrier %76 %77 OpControlBarrier %76 %76 %78 %80 = OpLoad %61 %79 %81 = OpLoad %10 %20 %82 = OpBitcast %24 %81 %83 = OpLoad %10 %12 %84 = OpBitcast %24 %83 %85 = OpCompositeConstruct %69 %82 %84 %86 = OpAccessChain %74 %42 %34 %87 = OpLoad %24 %86 %88 = OpCompositeConstruct %71 %87 %27 %27 %27 OpImageWrite %80 %85 %88 OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %89 = OpVariable %25 Function OpStore %89 %27 OpBranch %90 %90 = OpLabel OpLoopMerge %92 %93 None OpBranch %94 %94 = OpLabel %95 = OpLoad %24 %89 %97 = OpSLessThan %35 %95 %96 OpBranchConditional %97 %91 %92 %91 = OpLabel %98 = OpLoad %24 %89 %99 = OpIEqual %35 %98 %27 OpSelectionMerge %101 None OpBranchConditional %99 %100 %109 %100 = OpLabel %102 = OpLoad %61 %63 %104 = OpImageRead %71 %102 %103 %105 = OpCompositeExtract %24 %104 0 %106 = OpConvertSToF %38 %105 %108 = OpAccessChain %107 %42 %59 %16 OpStore %108 %106 OpBranch %101 %109 = OpLabel %111 = OpLoad %13 %110 %112 = OpConvertUToF %39 %111 %114 = OpCompositeExtract %38 %112 0 %115 = OpCompositeExtract %38 %112 1 %116 = OpCompositeConstruct %113 %114 %115 %117 = OpAccessChain %107 %42 %59 %21 %118 = OpCompositeExtract %38 %116 0 OpStore %117 %118 %119 = OpAccessChain %107 %42 %59 %76 %120 = OpCompositeExtract %38 %116 1 OpStore %119 %120 OpBranch %101 %101 = OpLabel OpBranch %93 %93 = OpLabel %121 = OpLoad %24 %89 %122 = OpIAdd %24 %121 %59 OpStore %89 %122 OpBranch %90 %92 = OpLabel OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/large_functions_large_diffs_src.spvasm000066400000000000000000000201271475742701700323250ustar00rootroot00000000000000;; Test where src and dst have a few large functions with large differences. OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" %15 OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpName %4 "main" OpName %6 "f1(" OpName %8 "f2(" OpName %12 "x" OpName %15 "gl_LocalInvocationID" OpName %20 "y" OpName %27 "image" OpName %44 "sum" OpName %46 "i" OpName %56 "j" OpName %80 "BufferOut" OpMemberName %80 0 "o_uv4" OpMemberName %80 1 "o_v3" OpMemberName %80 2 "o_i" OpName %82 "" OpName %88 "BufferIn" OpMemberName %88 0 "i_u" OpMemberName %88 1 "i_v4" OpMemberName %88 2 "i_f" OpName %90 "" OpName %101 "i" OpName %128 "image2" OpDecorate %15 BuiltIn LocalInvocationId OpDecorate %27 DescriptorSet 0 OpDecorate %27 Binding 2 OpMemberDecorate %80 0 Offset 0 OpMemberDecorate %80 1 Offset 16 OpMemberDecorate %80 2 Offset 28 OpDecorate %80 BufferBlock OpDecorate %82 DescriptorSet 0 OpDecorate %82 Binding 1 OpMemberDecorate %88 0 Offset 0 OpMemberDecorate %88 1 RowMajor OpMemberDecorate %88 1 Offset 16 OpMemberDecorate %88 1 MatrixStride 16 OpMemberDecorate %88 2 Offset 80 OpDecorate %88 Block OpDecorate %90 DescriptorSet 0 OpDecorate %90 Binding 0 OpDecorate %128 DescriptorSet 0 OpDecorate %128 Binding 3 %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeInt 32 0 %11 = OpTypePointer Function %10 %13 = OpTypeVector %10 3 %14 = OpTypePointer Input %13 %15 = OpVariable %14 Input %16 = OpConstant %10 0 %17 = OpTypePointer Input %10 %21 = OpConstant %10 1 %24 = OpTypeInt 32 1 %25 = OpTypeImage %24 2D 0 0 0 2 R32i %26 = OpTypePointer UniformConstant %25 %27 = OpVariable %26 UniformConstant %29 = OpTypeVector %10 2 %32 = OpTypeVector %24 2 %38 = OpTypeVector %24 4 %40 = OpConstant %10 2 %41 = OpConstant %10 3400 %42 = OpConstant %10 264 %43 = OpTypePointer Function %24 %45 = OpConstant %24 0 %53 = OpConstant %24 2 %54 = OpTypeBool %73 = OpConstant %24 1 %77 = OpTypeVector %10 4 %78 = OpTypeFloat 32 %79 = OpTypeVector %78 3 %80 = OpTypeStruct %77 %79 %24 %81 = OpTypePointer Uniform %80 %82 = OpVariable %81 Uniform %84 = OpTypePointer Uniform %24 %86 = OpTypeVector %78 4 %87 = OpTypeMatrix %86 4 %88 = OpTypeStruct %10 %87 %78 %89 = OpTypePointer Uniform %88 %90 = OpVariable %89 Uniform %91 = OpTypePointer Uniform %87 %94 = OpTypePointer Uniform %77 %108 = OpConstant %24 3 %110 = OpTypePointer Uniform %79 %113 = OpTypePointer Uniform %78 %128 = OpVariable %26 UniformConstant %130 = OpConstantComposite %32 %45 %45 %4 = OpFunction %2 None %3 %5 = OpLabel %136 = OpFunctionCall %2 %6 %137 = OpFunctionCall %2 %8 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %12 = OpVariable %11 Function %20 = OpVariable %11 Function %44 = OpVariable %43 Function %46 = OpVariable %43 Function %56 = OpVariable %43 Function %18 = OpAccessChain %17 %15 %16 %19 = OpLoad %10 %18 OpStore %12 %19 %22 = OpAccessChain %17 %15 %21 %23 = OpLoad %10 %22 OpStore %20 %23 %28 = OpLoad %25 %27 %30 = OpLoad %13 %15 %31 = OpVectorShuffle %29 %30 %30 0 1 %33 = OpBitcast %32 %31 %34 = OpLoad %10 %12 %35 = OpLoad %10 %20 %36 = OpIAdd %10 %34 %35 %37 = OpBitcast %24 %36 %39 = OpCompositeConstruct %38 %37 %37 %37 %37 OpImageWrite %28 %33 %39 OpMemoryBarrier %40 %41 OpControlBarrier %40 %40 %42 OpStore %44 %45 OpStore %46 %45 OpBranch %47 %47 = OpLabel OpLoopMerge %49 %50 None OpBranch %51 %51 = OpLabel %52 = OpLoad %24 %46 %55 = OpSLessThan %54 %52 %53 OpBranchConditional %55 %48 %49 %48 = OpLabel OpStore %56 %45 OpBranch %57 %57 = OpLabel OpLoopMerge %59 %60 None OpBranch %61 %61 = OpLabel %62 = OpLoad %24 %56 %63 = OpSLessThan %54 %62 %53 OpBranchConditional %63 %58 %59 %58 = OpLabel %64 = OpLoad %25 %27 %65 = OpLoad %24 %46 %66 = OpLoad %24 %56 %67 = OpCompositeConstruct %32 %65 %66 %68 = OpImageRead %38 %64 %67 %69 = OpCompositeExtract %24 %68 0 %70 = OpLoad %24 %44 %71 = OpIMul %24 %70 %69 OpStore %44 %71 OpBranch %60 %60 = OpLabel %72 = OpLoad %24 %56 %74 = OpIAdd %24 %72 %73 OpStore %56 %74 OpBranch %57 %59 = OpLabel OpBranch %50 %50 = OpLabel %75 = OpLoad %24 %46 %76 = OpIAdd %24 %75 %73 OpStore %46 %76 OpBranch %47 %49 = OpLabel OpMemoryBarrier %40 %41 OpControlBarrier %40 %40 %42 %83 = OpLoad %24 %44 %85 = OpAccessChain %84 %82 %53 OpStore %85 %83 OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %101 = OpVariable %43 Function %92 = OpAccessChain %91 %90 %73 %93 = OpLoad %87 %92 %95 = OpAccessChain %94 %82 %45 %96 = OpLoad %77 %95 %97 = OpConvertUToF %86 %96 %98 = OpMatrixTimesVector %86 %93 %97 %99 = OpConvertFToU %77 %98 %100 = OpAccessChain %94 %82 %45 OpStore %100 %99 OpStore %101 %45 OpBranch %102 %102 = OpLabel OpLoopMerge %104 %105 None OpBranch %106 %106 = OpLabel %107 = OpLoad %24 %101 %109 = OpSLessThan %54 %107 %108 OpBranchConditional %109 %103 %104 %103 = OpLabel %111 = OpAccessChain %110 %82 %73 %112 = OpLoad %79 %111 %114 = OpAccessChain %113 %90 %53 %115 = OpLoad %78 %114 %116 = OpVectorTimesScalar %79 %112 %115 %117 = OpConvertFToU %13 %116 %118 = OpCompositeExtract %10 %117 0 %119 = OpCompositeExtract %10 %117 1 %120 = OpCompositeExtract %10 %117 2 %121 = OpCompositeConstruct %77 %118 %119 %120 %16 %122 = OpAccessChain %94 %82 %45 %123 = OpLoad %77 %122 %124 = OpIAdd %77 %123 %121 %125 = OpAccessChain %94 %82 %45 OpStore %125 %124 OpBranch %105 %105 = OpLabel %126 = OpLoad %24 %101 %127 = OpIAdd %24 %126 %73 OpStore %101 %127 OpBranch %102 %104 = OpLabel OpMemoryBarrier %40 %41 OpControlBarrier %40 %40 %42 %129 = OpLoad %25 %128 %131 = OpImageRead %38 %129 %130 %132 = OpCompositeExtract %24 %131 0 %133 = OpConvertSToF %78 %132 %134 = OpCompositeConstruct %79 %133 %133 %133 %135 = OpAccessChain %110 %82 %73 OpStore %135 %134 OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/large_functions_small_diffs_autogen.cpp000066400000000000000000001257561475742701700325050ustar00rootroot00000000000000// GENERATED FILE - DO NOT EDIT. // Generated by generate_tests.py // // Copyright (c) 2022 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "../diff_test_utils.h" #include "gtest/gtest.h" namespace spvtools { namespace diff { namespace { // Test where src and dst have a few large functions with small differences. constexpr char kSrc[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" %15 OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpName %4 "main" OpName %6 "f1(" OpName %8 "f2(" OpName %12 "x" OpName %15 "gl_LocalInvocationID" OpName %20 "y" OpName %27 "image" OpName %44 "sum" OpName %46 "i" OpName %56 "j" OpName %80 "BufferOut" OpMemberName %80 0 "o_uv4" OpMemberName %80 1 "o_v3" OpMemberName %80 2 "o_i" OpName %82 "" OpName %88 "BufferIn" OpMemberName %88 0 "i_u" OpMemberName %88 1 "i_v4" OpMemberName %88 2 "i_f" OpName %90 "" OpName %101 "i" OpDecorate %15 BuiltIn LocalInvocationId OpDecorate %27 DescriptorSet 0 OpDecorate %27 Binding 2 OpMemberDecorate %80 0 Offset 0 OpMemberDecorate %80 1 Offset 16 OpMemberDecorate %80 2 Offset 28 OpDecorate %80 BufferBlock OpDecorate %82 DescriptorSet 0 OpDecorate %82 Binding 1 OpMemberDecorate %88 0 Offset 0 OpMemberDecorate %88 1 RowMajor OpMemberDecorate %88 1 Offset 16 OpMemberDecorate %88 1 MatrixStride 16 OpMemberDecorate %88 2 Offset 80 OpDecorate %88 Block OpDecorate %90 DescriptorSet 0 OpDecorate %90 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeInt 32 0 %11 = OpTypePointer Function %10 %13 = OpTypeVector %10 3 %14 = OpTypePointer Input %13 %15 = OpVariable %14 Input %16 = OpConstant %10 0 %17 = OpTypePointer Input %10 %21 = OpConstant %10 1 %24 = OpTypeInt 32 1 %25 = OpTypeImage %24 2D 0 0 0 2 R32i %26 = OpTypePointer UniformConstant %25 %27 = OpVariable %26 UniformConstant %29 = OpTypeVector %10 2 %32 = OpTypeVector %24 2 %38 = OpTypeVector %24 4 %40 = OpConstant %10 2 %41 = OpConstant %10 3400 %42 = OpConstant %10 264 %43 = OpTypePointer Function %24 %45 = OpConstant %24 0 %53 = OpConstant %24 2 %54 = OpTypeBool %73 = OpConstant %24 1 %77 = OpTypeVector %10 4 %78 = OpTypeFloat 32 %79 = OpTypeVector %78 3 %80 = OpTypeStruct %77 %79 %24 %81 = OpTypePointer Uniform %80 %82 = OpVariable %81 Uniform %84 = OpTypePointer Uniform %24 %86 = OpTypeVector %78 4 %87 = OpTypeMatrix %86 4 %88 = OpTypeStruct %10 %87 %78 %89 = OpTypePointer Uniform %88 %90 = OpVariable %89 Uniform %91 = OpTypePointer Uniform %87 %94 = OpTypePointer Uniform %77 %108 = OpConstant %24 3 %110 = OpTypePointer Uniform %79 %113 = OpTypePointer Uniform %78 %129 = OpConstantComposite %32 %45 %45 %4 = OpFunction %2 None %3 %5 = OpLabel %135 = OpFunctionCall %2 %6 %136 = OpFunctionCall %2 %8 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %12 = OpVariable %11 Function %20 = OpVariable %11 Function %44 = OpVariable %43 Function %46 = OpVariable %43 Function %56 = OpVariable %43 Function %18 = OpAccessChain %17 %15 %16 %19 = OpLoad %10 %18 OpStore %12 %19 %22 = OpAccessChain %17 %15 %21 %23 = OpLoad %10 %22 OpStore %20 %23 %28 = OpLoad %25 %27 %30 = OpLoad %13 %15 %31 = OpVectorShuffle %29 %30 %30 0 1 %33 = OpBitcast %32 %31 %34 = OpLoad %10 %12 %35 = OpLoad %10 %20 %36 = OpIAdd %10 %34 %35 %37 = OpBitcast %24 %36 %39 = OpCompositeConstruct %38 %37 %37 %37 %37 OpImageWrite %28 %33 %39 OpMemoryBarrier %40 %41 OpControlBarrier %40 %40 %42 OpStore %44 %45 OpStore %46 %45 OpBranch %47 %47 = OpLabel OpLoopMerge %49 %50 None OpBranch %51 %51 = OpLabel %52 = OpLoad %24 %46 %55 = OpSLessThan %54 %52 %53 OpBranchConditional %55 %48 %49 %48 = OpLabel OpStore %56 %45 OpBranch %57 %57 = OpLabel OpLoopMerge %59 %60 None OpBranch %61 %61 = OpLabel %62 = OpLoad %24 %56 %63 = OpSLessThan %54 %62 %53 OpBranchConditional %63 %58 %59 %58 = OpLabel %64 = OpLoad %25 %27 %65 = OpLoad %24 %46 %66 = OpLoad %24 %56 %67 = OpCompositeConstruct %32 %65 %66 %68 = OpImageRead %38 %64 %67 %69 = OpCompositeExtract %24 %68 0 %70 = OpLoad %24 %44 %71 = OpIAdd %24 %70 %69 OpStore %44 %71 OpBranch %60 %60 = OpLabel %72 = OpLoad %24 %56 %74 = OpIAdd %24 %72 %73 OpStore %56 %74 OpBranch %57 %59 = OpLabel OpBranch %50 %50 = OpLabel %75 = OpLoad %24 %46 %76 = OpIAdd %24 %75 %73 OpStore %46 %76 OpBranch %47 %49 = OpLabel OpMemoryBarrier %40 %41 OpControlBarrier %40 %40 %42 %83 = OpLoad %24 %44 %85 = OpAccessChain %84 %82 %53 OpStore %85 %83 OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %101 = OpVariable %43 Function %92 = OpAccessChain %91 %90 %73 %93 = OpLoad %87 %92 %95 = OpAccessChain %94 %82 %45 %96 = OpLoad %77 %95 %97 = OpConvertUToF %86 %96 %98 = OpMatrixTimesVector %86 %93 %97 %99 = OpConvertFToU %77 %98 %100 = OpAccessChain %94 %82 %45 OpStore %100 %99 OpStore %101 %45 OpBranch %102 %102 = OpLabel OpLoopMerge %104 %105 None OpBranch %106 %106 = OpLabel %107 = OpLoad %24 %101 %109 = OpSLessThan %54 %107 %108 OpBranchConditional %109 %103 %104 %103 = OpLabel %111 = OpAccessChain %110 %82 %73 %112 = OpLoad %79 %111 %114 = OpAccessChain %113 %90 %53 %115 = OpLoad %78 %114 %116 = OpVectorTimesScalar %79 %112 %115 %117 = OpConvertFToU %13 %116 %118 = OpCompositeExtract %10 %117 0 %119 = OpCompositeExtract %10 %117 1 %120 = OpCompositeExtract %10 %117 2 %121 = OpCompositeConstruct %77 %118 %119 %120 %16 %122 = OpAccessChain %94 %82 %45 %123 = OpLoad %77 %122 %124 = OpIAdd %77 %123 %121 %125 = OpAccessChain %94 %82 %45 OpStore %125 %124 OpBranch %105 %105 = OpLabel %126 = OpLoad %24 %101 %127 = OpIAdd %24 %126 %73 OpStore %101 %127 OpBranch %102 %104 = OpLabel OpMemoryBarrier %40 %41 OpControlBarrier %40 %40 %42 %128 = OpLoad %25 %27 %130 = OpImageRead %38 %128 %129 %131 = OpCompositeExtract %24 %130 0 %132 = OpConvertSToF %78 %131 %133 = OpCompositeConstruct %79 %132 %132 %132 %134 = OpAccessChain %110 %82 %73 OpStore %134 %133 OpReturn OpFunctionEnd )"; constexpr char kDst[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" %15 OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpName %4 "main" OpName %6 "f1(" OpName %8 "f2(" OpName %12 "x" OpName %15 "gl_LocalInvocationID" OpName %20 "y" OpName %27 "image" OpName %44 "sum" OpName %46 "i" OpName %56 "j" OpName %80 "BufferOut" OpMemberName %80 0 "o_uv4" OpMemberName %80 1 "o_v3" OpMemberName %80 2 "o_i" OpName %82 "" OpName %88 "BufferIn" OpMemberName %88 0 "i_u" OpMemberName %88 1 "i_v4" OpMemberName %88 2 "i_f" OpName %90 "" OpName %101 "i" OpName %128 "image2" OpDecorate %15 BuiltIn LocalInvocationId OpDecorate %27 DescriptorSet 0 OpDecorate %27 Binding 2 OpMemberDecorate %80 0 Offset 0 OpMemberDecorate %80 1 Offset 16 OpMemberDecorate %80 2 Offset 28 OpDecorate %80 BufferBlock OpDecorate %82 DescriptorSet 0 OpDecorate %82 Binding 1 OpMemberDecorate %88 0 Offset 0 OpMemberDecorate %88 1 RowMajor OpMemberDecorate %88 1 Offset 16 OpMemberDecorate %88 1 MatrixStride 16 OpMemberDecorate %88 2 Offset 80 OpDecorate %88 Block OpDecorate %90 DescriptorSet 0 OpDecorate %90 Binding 0 OpDecorate %128 DescriptorSet 0 OpDecorate %128 Binding 3 %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeInt 32 0 %11 = OpTypePointer Function %10 %13 = OpTypeVector %10 3 %14 = OpTypePointer Input %13 %15 = OpVariable %14 Input %16 = OpConstant %10 0 %17 = OpTypePointer Input %10 %21 = OpConstant %10 1 %24 = OpTypeInt 32 1 %25 = OpTypeImage %24 2D 0 0 0 2 R32i %26 = OpTypePointer UniformConstant %25 %27 = OpVariable %26 UniformConstant %29 = OpTypeVector %10 2 %32 = OpTypeVector %24 2 %38 = OpTypeVector %24 4 %40 = OpConstant %10 2 %41 = OpConstant %10 3400 %42 = OpConstant %10 264 %43 = OpTypePointer Function %24 %45 = OpConstant %24 0 %53 = OpConstant %24 2 %54 = OpTypeBool %73 = OpConstant %24 1 %77 = OpTypeVector %10 4 %78 = OpTypeFloat 32 %79 = OpTypeVector %78 3 %80 = OpTypeStruct %77 %79 %24 %81 = OpTypePointer Uniform %80 %82 = OpVariable %81 Uniform %84 = OpTypePointer Uniform %24 %86 = OpTypeVector %78 4 %87 = OpTypeMatrix %86 4 %88 = OpTypeStruct %10 %87 %78 %89 = OpTypePointer Uniform %88 %90 = OpVariable %89 Uniform %91 = OpTypePointer Uniform %87 %94 = OpTypePointer Uniform %77 %108 = OpConstant %24 3 %110 = OpTypePointer Uniform %79 %113 = OpTypePointer Uniform %78 %128 = OpVariable %26 UniformConstant %130 = OpConstantComposite %32 %45 %45 %4 = OpFunction %2 None %3 %5 = OpLabel %136 = OpFunctionCall %2 %6 %137 = OpFunctionCall %2 %8 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %12 = OpVariable %11 Function %20 = OpVariable %11 Function %44 = OpVariable %43 Function %46 = OpVariable %43 Function %56 = OpVariable %43 Function %18 = OpAccessChain %17 %15 %16 %19 = OpLoad %10 %18 OpStore %12 %19 %22 = OpAccessChain %17 %15 %21 %23 = OpLoad %10 %22 OpStore %20 %23 %28 = OpLoad %25 %27 %30 = OpLoad %13 %15 %31 = OpVectorShuffle %29 %30 %30 0 1 %33 = OpBitcast %32 %31 %34 = OpLoad %10 %12 %35 = OpLoad %10 %20 %36 = OpIAdd %10 %34 %35 %37 = OpBitcast %24 %36 %39 = OpCompositeConstruct %38 %37 %37 %37 %37 OpImageWrite %28 %33 %39 OpMemoryBarrier %40 %41 OpControlBarrier %40 %40 %42 OpStore %44 %45 OpStore %46 %45 OpBranch %47 %47 = OpLabel OpLoopMerge %49 %50 None OpBranch %51 %51 = OpLabel %52 = OpLoad %24 %46 %55 = OpSLessThan %54 %52 %53 OpBranchConditional %55 %48 %49 %48 = OpLabel OpStore %56 %45 OpBranch %57 %57 = OpLabel OpLoopMerge %59 %60 None OpBranch %61 %61 = OpLabel %62 = OpLoad %24 %56 %63 = OpSLessThan %54 %62 %53 OpBranchConditional %63 %58 %59 %58 = OpLabel %64 = OpLoad %25 %27 %65 = OpLoad %24 %46 %66 = OpLoad %24 %56 %67 = OpCompositeConstruct %32 %65 %66 %68 = OpImageRead %38 %64 %67 %69 = OpCompositeExtract %24 %68 0 %70 = OpLoad %24 %44 %71 = OpIMul %24 %70 %69 OpStore %44 %71 OpBranch %60 %60 = OpLabel %72 = OpLoad %24 %56 %74 = OpIAdd %24 %72 %73 OpStore %56 %74 OpBranch %57 %59 = OpLabel OpBranch %50 %50 = OpLabel %75 = OpLoad %24 %46 %76 = OpIAdd %24 %75 %73 OpStore %46 %76 OpBranch %47 %49 = OpLabel OpMemoryBarrier %40 %41 OpControlBarrier %40 %40 %42 %83 = OpLoad %24 %44 %85 = OpAccessChain %84 %82 %53 OpStore %85 %83 OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %101 = OpVariable %43 Function %92 = OpAccessChain %91 %90 %73 %93 = OpLoad %87 %92 %95 = OpAccessChain %94 %82 %45 %96 = OpLoad %77 %95 %97 = OpConvertUToF %86 %96 %98 = OpMatrixTimesVector %86 %93 %97 %99 = OpConvertFToU %77 %98 %100 = OpAccessChain %94 %82 %45 OpStore %100 %99 OpStore %101 %45 OpBranch %102 %102 = OpLabel OpLoopMerge %104 %105 None OpBranch %106 %106 = OpLabel %107 = OpLoad %24 %101 %109 = OpSLessThan %54 %107 %108 OpBranchConditional %109 %103 %104 %103 = OpLabel %111 = OpAccessChain %110 %82 %73 %112 = OpLoad %79 %111 %114 = OpAccessChain %113 %90 %53 %115 = OpLoad %78 %114 %116 = OpVectorTimesScalar %79 %112 %115 %117 = OpConvertFToU %13 %116 %118 = OpCompositeExtract %10 %117 0 %119 = OpCompositeExtract %10 %117 1 %120 = OpCompositeExtract %10 %117 2 %121 = OpCompositeConstruct %77 %118 %119 %120 %16 %122 = OpAccessChain %94 %82 %45 %123 = OpLoad %77 %122 %124 = OpIAdd %77 %123 %121 %125 = OpAccessChain %94 %82 %45 OpStore %125 %124 OpBranch %105 %105 = OpLabel %126 = OpLoad %24 %101 %127 = OpIAdd %24 %126 %73 OpStore %101 %127 OpBranch %102 %104 = OpLabel OpMemoryBarrier %40 %41 OpControlBarrier %40 %40 %42 %129 = OpLoad %25 %128 %131 = OpImageRead %38 %129 %130 %132 = OpCompositeExtract %24 %131 0 %133 = OpConvertSToF %78 %132 %134 = OpCompositeConstruct %79 %133 %133 %133 %135 = OpAccessChain %110 %82 %73 OpStore %135 %134 OpReturn OpFunctionEnd )"; TEST(DiffTest, LargeFunctionsSmallDiffs) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 137 +; Bound: 140 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" %15 OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpName %4 "main" OpName %6 "f1(" OpName %8 "f2(" OpName %12 "x" OpName %15 "gl_LocalInvocationID" OpName %20 "y" OpName %27 "image" OpName %44 "sum" OpName %46 "i" OpName %56 "j" OpName %80 "BufferOut" OpMemberName %80 0 "o_uv4" OpMemberName %80 1 "o_v3" OpMemberName %80 2 "o_i" OpName %82 "" OpName %88 "BufferIn" OpMemberName %88 0 "i_u" OpMemberName %88 1 "i_v4" OpMemberName %88 2 "i_f" OpName %90 "" OpName %101 "i" +OpName %138 "image2" OpDecorate %15 BuiltIn LocalInvocationId OpDecorate %27 DescriptorSet 0 OpDecorate %27 Binding 2 OpMemberDecorate %80 0 Offset 0 OpMemberDecorate %80 1 Offset 16 OpMemberDecorate %80 2 Offset 28 OpDecorate %80 BufferBlock OpDecorate %82 DescriptorSet 0 OpDecorate %82 Binding 1 OpMemberDecorate %88 0 Offset 0 OpMemberDecorate %88 1 RowMajor OpMemberDecorate %88 1 Offset 16 OpMemberDecorate %88 1 MatrixStride 16 OpMemberDecorate %88 2 Offset 80 OpDecorate %88 Block OpDecorate %90 DescriptorSet 0 OpDecorate %90 Binding 0 +OpDecorate %138 DescriptorSet 0 +OpDecorate %138 Binding 3 %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeInt 32 0 %11 = OpTypePointer Function %10 %13 = OpTypeVector %10 3 %14 = OpTypePointer Input %13 %15 = OpVariable %14 Input %16 = OpConstant %10 0 %17 = OpTypePointer Input %10 %21 = OpConstant %10 1 %24 = OpTypeInt 32 1 %25 = OpTypeImage %24 2D 0 0 0 2 R32i %26 = OpTypePointer UniformConstant %25 %27 = OpVariable %26 UniformConstant %29 = OpTypeVector %10 2 %32 = OpTypeVector %24 2 %38 = OpTypeVector %24 4 %40 = OpConstant %10 2 %41 = OpConstant %10 3400 %42 = OpConstant %10 264 %43 = OpTypePointer Function %24 %45 = OpConstant %24 0 %53 = OpConstant %24 2 %54 = OpTypeBool %73 = OpConstant %24 1 %77 = OpTypeVector %10 4 %78 = OpTypeFloat 32 %79 = OpTypeVector %78 3 %80 = OpTypeStruct %77 %79 %24 %81 = OpTypePointer Uniform %80 %82 = OpVariable %81 Uniform %84 = OpTypePointer Uniform %24 %86 = OpTypeVector %78 4 %87 = OpTypeMatrix %86 4 %88 = OpTypeStruct %10 %87 %78 %89 = OpTypePointer Uniform %88 %90 = OpVariable %89 Uniform %91 = OpTypePointer Uniform %87 %94 = OpTypePointer Uniform %77 %108 = OpConstant %24 3 %110 = OpTypePointer Uniform %79 %113 = OpTypePointer Uniform %78 +%138 = OpVariable %26 UniformConstant %129 = OpConstantComposite %32 %45 %45 %4 = OpFunction %2 None %3 %5 = OpLabel %135 = OpFunctionCall %2 %6 %136 = OpFunctionCall %2 %8 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %12 = OpVariable %11 Function %20 = OpVariable %11 Function %44 = OpVariable %43 Function %46 = OpVariable %43 Function %56 = OpVariable %43 Function %18 = OpAccessChain %17 %15 %16 %19 = OpLoad %10 %18 OpStore %12 %19 %22 = OpAccessChain %17 %15 %21 %23 = OpLoad %10 %22 OpStore %20 %23 %28 = OpLoad %25 %27 %30 = OpLoad %13 %15 %31 = OpVectorShuffle %29 %30 %30 0 1 %33 = OpBitcast %32 %31 %34 = OpLoad %10 %12 %35 = OpLoad %10 %20 %36 = OpIAdd %10 %34 %35 %37 = OpBitcast %24 %36 %39 = OpCompositeConstruct %38 %37 %37 %37 %37 OpImageWrite %28 %33 %39 OpMemoryBarrier %40 %41 OpControlBarrier %40 %40 %42 OpStore %44 %45 OpStore %46 %45 OpBranch %47 %47 = OpLabel OpLoopMerge %49 %50 None OpBranch %51 %51 = OpLabel %52 = OpLoad %24 %46 %55 = OpSLessThan %54 %52 %53 OpBranchConditional %55 %48 %49 %48 = OpLabel OpStore %56 %45 OpBranch %57 %57 = OpLabel OpLoopMerge %59 %60 None OpBranch %61 %61 = OpLabel %62 = OpLoad %24 %56 %63 = OpSLessThan %54 %62 %53 OpBranchConditional %63 %58 %59 %58 = OpLabel %64 = OpLoad %25 %27 %65 = OpLoad %24 %46 %66 = OpLoad %24 %56 %67 = OpCompositeConstruct %32 %65 %66 %68 = OpImageRead %38 %64 %67 %69 = OpCompositeExtract %24 %68 0 %70 = OpLoad %24 %44 -%71 = OpIAdd %24 %70 %69 +%137 = OpIMul %24 %70 %69 -OpStore %44 %71 +OpStore %44 %137 OpBranch %60 %60 = OpLabel %72 = OpLoad %24 %56 %74 = OpIAdd %24 %72 %73 OpStore %56 %74 OpBranch %57 %59 = OpLabel OpBranch %50 %50 = OpLabel %75 = OpLoad %24 %46 %76 = OpIAdd %24 %75 %73 OpStore %46 %76 OpBranch %47 %49 = OpLabel OpMemoryBarrier %40 %41 OpControlBarrier %40 %40 %42 %83 = OpLoad %24 %44 %85 = OpAccessChain %84 %82 %53 OpStore %85 %83 OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %101 = OpVariable %43 Function %92 = OpAccessChain %91 %90 %73 %93 = OpLoad %87 %92 %95 = OpAccessChain %94 %82 %45 %96 = OpLoad %77 %95 %97 = OpConvertUToF %86 %96 %98 = OpMatrixTimesVector %86 %93 %97 %99 = OpConvertFToU %77 %98 %100 = OpAccessChain %94 %82 %45 OpStore %100 %99 OpStore %101 %45 OpBranch %102 %102 = OpLabel OpLoopMerge %104 %105 None OpBranch %106 %106 = OpLabel %107 = OpLoad %24 %101 %109 = OpSLessThan %54 %107 %108 OpBranchConditional %109 %103 %104 %103 = OpLabel %111 = OpAccessChain %110 %82 %73 %112 = OpLoad %79 %111 %114 = OpAccessChain %113 %90 %53 %115 = OpLoad %78 %114 %116 = OpVectorTimesScalar %79 %112 %115 %117 = OpConvertFToU %13 %116 %118 = OpCompositeExtract %10 %117 0 %119 = OpCompositeExtract %10 %117 1 %120 = OpCompositeExtract %10 %117 2 %121 = OpCompositeConstruct %77 %118 %119 %120 %16 %122 = OpAccessChain %94 %82 %45 %123 = OpLoad %77 %122 %124 = OpIAdd %77 %123 %121 %125 = OpAccessChain %94 %82 %45 OpStore %125 %124 OpBranch %105 %105 = OpLabel %126 = OpLoad %24 %101 %127 = OpIAdd %24 %126 %73 OpStore %101 %127 OpBranch %102 %104 = OpLabel OpMemoryBarrier %40 %41 OpControlBarrier %40 %40 %42 -%128 = OpLoad %25 %27 +%139 = OpLoad %25 %138 -%130 = OpImageRead %38 %128 %129 +%130 = OpImageRead %38 %139 %129 %131 = OpCompositeExtract %24 %130 0 %132 = OpConvertSToF %78 %131 %133 = OpCompositeConstruct %79 %132 %132 %132 %134 = OpAccessChain %110 %82 %73 OpStore %134 %133 OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrc, kDst, kDiff, options); } TEST(DiffTest, LargeFunctionsSmallDiffsNoDebug) { constexpr char kSrcNoDebug[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" %15 OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpDecorate %15 BuiltIn LocalInvocationId OpDecorate %27 DescriptorSet 0 OpDecorate %27 Binding 2 OpMemberDecorate %80 0 Offset 0 OpMemberDecorate %80 1 Offset 16 OpMemberDecorate %80 2 Offset 28 OpDecorate %80 BufferBlock OpDecorate %82 DescriptorSet 0 OpDecorate %82 Binding 1 OpMemberDecorate %88 0 Offset 0 OpMemberDecorate %88 1 RowMajor OpMemberDecorate %88 1 Offset 16 OpMemberDecorate %88 1 MatrixStride 16 OpMemberDecorate %88 2 Offset 80 OpDecorate %88 Block OpDecorate %90 DescriptorSet 0 OpDecorate %90 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeInt 32 0 %11 = OpTypePointer Function %10 %13 = OpTypeVector %10 3 %14 = OpTypePointer Input %13 %15 = OpVariable %14 Input %16 = OpConstant %10 0 %17 = OpTypePointer Input %10 %21 = OpConstant %10 1 %24 = OpTypeInt 32 1 %25 = OpTypeImage %24 2D 0 0 0 2 R32i %26 = OpTypePointer UniformConstant %25 %27 = OpVariable %26 UniformConstant %29 = OpTypeVector %10 2 %32 = OpTypeVector %24 2 %38 = OpTypeVector %24 4 %40 = OpConstant %10 2 %41 = OpConstant %10 3400 %42 = OpConstant %10 264 %43 = OpTypePointer Function %24 %45 = OpConstant %24 0 %53 = OpConstant %24 2 %54 = OpTypeBool %73 = OpConstant %24 1 %77 = OpTypeVector %10 4 %78 = OpTypeFloat 32 %79 = OpTypeVector %78 3 %80 = OpTypeStruct %77 %79 %24 %81 = OpTypePointer Uniform %80 %82 = OpVariable %81 Uniform %84 = OpTypePointer Uniform %24 %86 = OpTypeVector %78 4 %87 = OpTypeMatrix %86 4 %88 = OpTypeStruct %10 %87 %78 %89 = OpTypePointer Uniform %88 %90 = OpVariable %89 Uniform %91 = OpTypePointer Uniform %87 %94 = OpTypePointer Uniform %77 %108 = OpConstant %24 3 %110 = OpTypePointer Uniform %79 %113 = OpTypePointer Uniform %78 %129 = OpConstantComposite %32 %45 %45 %4 = OpFunction %2 None %3 %5 = OpLabel %135 = OpFunctionCall %2 %6 %136 = OpFunctionCall %2 %8 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %12 = OpVariable %11 Function %20 = OpVariable %11 Function %44 = OpVariable %43 Function %46 = OpVariable %43 Function %56 = OpVariable %43 Function %18 = OpAccessChain %17 %15 %16 %19 = OpLoad %10 %18 OpStore %12 %19 %22 = OpAccessChain %17 %15 %21 %23 = OpLoad %10 %22 OpStore %20 %23 %28 = OpLoad %25 %27 %30 = OpLoad %13 %15 %31 = OpVectorShuffle %29 %30 %30 0 1 %33 = OpBitcast %32 %31 %34 = OpLoad %10 %12 %35 = OpLoad %10 %20 %36 = OpIAdd %10 %34 %35 %37 = OpBitcast %24 %36 %39 = OpCompositeConstruct %38 %37 %37 %37 %37 OpImageWrite %28 %33 %39 OpMemoryBarrier %40 %41 OpControlBarrier %40 %40 %42 OpStore %44 %45 OpStore %46 %45 OpBranch %47 %47 = OpLabel OpLoopMerge %49 %50 None OpBranch %51 %51 = OpLabel %52 = OpLoad %24 %46 %55 = OpSLessThan %54 %52 %53 OpBranchConditional %55 %48 %49 %48 = OpLabel OpStore %56 %45 OpBranch %57 %57 = OpLabel OpLoopMerge %59 %60 None OpBranch %61 %61 = OpLabel %62 = OpLoad %24 %56 %63 = OpSLessThan %54 %62 %53 OpBranchConditional %63 %58 %59 %58 = OpLabel %64 = OpLoad %25 %27 %65 = OpLoad %24 %46 %66 = OpLoad %24 %56 %67 = OpCompositeConstruct %32 %65 %66 %68 = OpImageRead %38 %64 %67 %69 = OpCompositeExtract %24 %68 0 %70 = OpLoad %24 %44 %71 = OpIAdd %24 %70 %69 OpStore %44 %71 OpBranch %60 %60 = OpLabel %72 = OpLoad %24 %56 %74 = OpIAdd %24 %72 %73 OpStore %56 %74 OpBranch %57 %59 = OpLabel OpBranch %50 %50 = OpLabel %75 = OpLoad %24 %46 %76 = OpIAdd %24 %75 %73 OpStore %46 %76 OpBranch %47 %49 = OpLabel OpMemoryBarrier %40 %41 OpControlBarrier %40 %40 %42 %83 = OpLoad %24 %44 %85 = OpAccessChain %84 %82 %53 OpStore %85 %83 OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %101 = OpVariable %43 Function %92 = OpAccessChain %91 %90 %73 %93 = OpLoad %87 %92 %95 = OpAccessChain %94 %82 %45 %96 = OpLoad %77 %95 %97 = OpConvertUToF %86 %96 %98 = OpMatrixTimesVector %86 %93 %97 %99 = OpConvertFToU %77 %98 %100 = OpAccessChain %94 %82 %45 OpStore %100 %99 OpStore %101 %45 OpBranch %102 %102 = OpLabel OpLoopMerge %104 %105 None OpBranch %106 %106 = OpLabel %107 = OpLoad %24 %101 %109 = OpSLessThan %54 %107 %108 OpBranchConditional %109 %103 %104 %103 = OpLabel %111 = OpAccessChain %110 %82 %73 %112 = OpLoad %79 %111 %114 = OpAccessChain %113 %90 %53 %115 = OpLoad %78 %114 %116 = OpVectorTimesScalar %79 %112 %115 %117 = OpConvertFToU %13 %116 %118 = OpCompositeExtract %10 %117 0 %119 = OpCompositeExtract %10 %117 1 %120 = OpCompositeExtract %10 %117 2 %121 = OpCompositeConstruct %77 %118 %119 %120 %16 %122 = OpAccessChain %94 %82 %45 %123 = OpLoad %77 %122 %124 = OpIAdd %77 %123 %121 %125 = OpAccessChain %94 %82 %45 OpStore %125 %124 OpBranch %105 %105 = OpLabel %126 = OpLoad %24 %101 %127 = OpIAdd %24 %126 %73 OpStore %101 %127 OpBranch %102 %104 = OpLabel OpMemoryBarrier %40 %41 OpControlBarrier %40 %40 %42 %128 = OpLoad %25 %27 %130 = OpImageRead %38 %128 %129 %131 = OpCompositeExtract %24 %130 0 %132 = OpConvertSToF %78 %131 %133 = OpCompositeConstruct %79 %132 %132 %132 %134 = OpAccessChain %110 %82 %73 OpStore %134 %133 OpReturn OpFunctionEnd )"; constexpr char kDstNoDebug[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" %15 OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpDecorate %15 BuiltIn LocalInvocationId OpDecorate %27 DescriptorSet 0 OpDecorate %27 Binding 2 OpMemberDecorate %80 0 Offset 0 OpMemberDecorate %80 1 Offset 16 OpMemberDecorate %80 2 Offset 28 OpDecorate %80 BufferBlock OpDecorate %82 DescriptorSet 0 OpDecorate %82 Binding 1 OpMemberDecorate %88 0 Offset 0 OpMemberDecorate %88 1 RowMajor OpMemberDecorate %88 1 Offset 16 OpMemberDecorate %88 1 MatrixStride 16 OpMemberDecorate %88 2 Offset 80 OpDecorate %88 Block OpDecorate %90 DescriptorSet 0 OpDecorate %90 Binding 0 OpDecorate %128 DescriptorSet 0 OpDecorate %128 Binding 3 %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeInt 32 0 %11 = OpTypePointer Function %10 %13 = OpTypeVector %10 3 %14 = OpTypePointer Input %13 %15 = OpVariable %14 Input %16 = OpConstant %10 0 %17 = OpTypePointer Input %10 %21 = OpConstant %10 1 %24 = OpTypeInt 32 1 %25 = OpTypeImage %24 2D 0 0 0 2 R32i %26 = OpTypePointer UniformConstant %25 %27 = OpVariable %26 UniformConstant %29 = OpTypeVector %10 2 %32 = OpTypeVector %24 2 %38 = OpTypeVector %24 4 %40 = OpConstant %10 2 %41 = OpConstant %10 3400 %42 = OpConstant %10 264 %43 = OpTypePointer Function %24 %45 = OpConstant %24 0 %53 = OpConstant %24 2 %54 = OpTypeBool %73 = OpConstant %24 1 %77 = OpTypeVector %10 4 %78 = OpTypeFloat 32 %79 = OpTypeVector %78 3 %80 = OpTypeStruct %77 %79 %24 %81 = OpTypePointer Uniform %80 %82 = OpVariable %81 Uniform %84 = OpTypePointer Uniform %24 %86 = OpTypeVector %78 4 %87 = OpTypeMatrix %86 4 %88 = OpTypeStruct %10 %87 %78 %89 = OpTypePointer Uniform %88 %90 = OpVariable %89 Uniform %91 = OpTypePointer Uniform %87 %94 = OpTypePointer Uniform %77 %108 = OpConstant %24 3 %110 = OpTypePointer Uniform %79 %113 = OpTypePointer Uniform %78 %128 = OpVariable %26 UniformConstant %130 = OpConstantComposite %32 %45 %45 %4 = OpFunction %2 None %3 %5 = OpLabel %136 = OpFunctionCall %2 %6 %137 = OpFunctionCall %2 %8 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %12 = OpVariable %11 Function %20 = OpVariable %11 Function %44 = OpVariable %43 Function %46 = OpVariable %43 Function %56 = OpVariable %43 Function %18 = OpAccessChain %17 %15 %16 %19 = OpLoad %10 %18 OpStore %12 %19 %22 = OpAccessChain %17 %15 %21 %23 = OpLoad %10 %22 OpStore %20 %23 %28 = OpLoad %25 %27 %30 = OpLoad %13 %15 %31 = OpVectorShuffle %29 %30 %30 0 1 %33 = OpBitcast %32 %31 %34 = OpLoad %10 %12 %35 = OpLoad %10 %20 %36 = OpIAdd %10 %34 %35 %37 = OpBitcast %24 %36 %39 = OpCompositeConstruct %38 %37 %37 %37 %37 OpImageWrite %28 %33 %39 OpMemoryBarrier %40 %41 OpControlBarrier %40 %40 %42 OpStore %44 %45 OpStore %46 %45 OpBranch %47 %47 = OpLabel OpLoopMerge %49 %50 None OpBranch %51 %51 = OpLabel %52 = OpLoad %24 %46 %55 = OpSLessThan %54 %52 %53 OpBranchConditional %55 %48 %49 %48 = OpLabel OpStore %56 %45 OpBranch %57 %57 = OpLabel OpLoopMerge %59 %60 None OpBranch %61 %61 = OpLabel %62 = OpLoad %24 %56 %63 = OpSLessThan %54 %62 %53 OpBranchConditional %63 %58 %59 %58 = OpLabel %64 = OpLoad %25 %27 %65 = OpLoad %24 %46 %66 = OpLoad %24 %56 %67 = OpCompositeConstruct %32 %65 %66 %68 = OpImageRead %38 %64 %67 %69 = OpCompositeExtract %24 %68 0 %70 = OpLoad %24 %44 %71 = OpIMul %24 %70 %69 OpStore %44 %71 OpBranch %60 %60 = OpLabel %72 = OpLoad %24 %56 %74 = OpIAdd %24 %72 %73 OpStore %56 %74 OpBranch %57 %59 = OpLabel OpBranch %50 %50 = OpLabel %75 = OpLoad %24 %46 %76 = OpIAdd %24 %75 %73 OpStore %46 %76 OpBranch %47 %49 = OpLabel OpMemoryBarrier %40 %41 OpControlBarrier %40 %40 %42 %83 = OpLoad %24 %44 %85 = OpAccessChain %84 %82 %53 OpStore %85 %83 OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %101 = OpVariable %43 Function %92 = OpAccessChain %91 %90 %73 %93 = OpLoad %87 %92 %95 = OpAccessChain %94 %82 %45 %96 = OpLoad %77 %95 %97 = OpConvertUToF %86 %96 %98 = OpMatrixTimesVector %86 %93 %97 %99 = OpConvertFToU %77 %98 %100 = OpAccessChain %94 %82 %45 OpStore %100 %99 OpStore %101 %45 OpBranch %102 %102 = OpLabel OpLoopMerge %104 %105 None OpBranch %106 %106 = OpLabel %107 = OpLoad %24 %101 %109 = OpSLessThan %54 %107 %108 OpBranchConditional %109 %103 %104 %103 = OpLabel %111 = OpAccessChain %110 %82 %73 %112 = OpLoad %79 %111 %114 = OpAccessChain %113 %90 %53 %115 = OpLoad %78 %114 %116 = OpVectorTimesScalar %79 %112 %115 %117 = OpConvertFToU %13 %116 %118 = OpCompositeExtract %10 %117 0 %119 = OpCompositeExtract %10 %117 1 %120 = OpCompositeExtract %10 %117 2 %121 = OpCompositeConstruct %77 %118 %119 %120 %16 %122 = OpAccessChain %94 %82 %45 %123 = OpLoad %77 %122 %124 = OpIAdd %77 %123 %121 %125 = OpAccessChain %94 %82 %45 OpStore %125 %124 OpBranch %105 %105 = OpLabel %126 = OpLoad %24 %101 %127 = OpIAdd %24 %126 %73 OpStore %101 %127 OpBranch %102 %104 = OpLabel OpMemoryBarrier %40 %41 OpControlBarrier %40 %40 %42 %129 = OpLoad %25 %128 %131 = OpImageRead %38 %129 %130 %132 = OpCompositeExtract %24 %131 0 %133 = OpConvertSToF %78 %132 %134 = OpCompositeConstruct %79 %133 %133 %133 %135 = OpAccessChain %110 %82 %73 OpStore %135 %134 OpReturn OpFunctionEnd )"; constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 137 +; Bound: 140 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" %15 OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpDecorate %15 BuiltIn LocalInvocationId OpDecorate %27 DescriptorSet 0 OpDecorate %27 Binding 2 OpMemberDecorate %80 0 Offset 0 OpMemberDecorate %80 1 Offset 16 OpMemberDecorate %80 2 Offset 28 OpDecorate %80 BufferBlock OpDecorate %82 DescriptorSet 0 OpDecorate %82 Binding 1 OpMemberDecorate %88 0 Offset 0 OpMemberDecorate %88 1 RowMajor OpMemberDecorate %88 1 Offset 16 OpMemberDecorate %88 1 MatrixStride 16 OpMemberDecorate %88 2 Offset 80 OpDecorate %88 Block OpDecorate %90 DescriptorSet 0 OpDecorate %90 Binding 0 +OpDecorate %138 DescriptorSet 0 +OpDecorate %138 Binding 3 %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeInt 32 0 %11 = OpTypePointer Function %10 %13 = OpTypeVector %10 3 %14 = OpTypePointer Input %13 %15 = OpVariable %14 Input %16 = OpConstant %10 0 %17 = OpTypePointer Input %10 %21 = OpConstant %10 1 %24 = OpTypeInt 32 1 %25 = OpTypeImage %24 2D 0 0 0 2 R32i %26 = OpTypePointer UniformConstant %25 %27 = OpVariable %26 UniformConstant %29 = OpTypeVector %10 2 %32 = OpTypeVector %24 2 %38 = OpTypeVector %24 4 %40 = OpConstant %10 2 %41 = OpConstant %10 3400 %42 = OpConstant %10 264 %43 = OpTypePointer Function %24 %45 = OpConstant %24 0 %53 = OpConstant %24 2 %54 = OpTypeBool %73 = OpConstant %24 1 %77 = OpTypeVector %10 4 %78 = OpTypeFloat 32 %79 = OpTypeVector %78 3 %80 = OpTypeStruct %77 %79 %24 %81 = OpTypePointer Uniform %80 %82 = OpVariable %81 Uniform %84 = OpTypePointer Uniform %24 %86 = OpTypeVector %78 4 %87 = OpTypeMatrix %86 4 %88 = OpTypeStruct %10 %87 %78 %89 = OpTypePointer Uniform %88 %90 = OpVariable %89 Uniform %91 = OpTypePointer Uniform %87 %94 = OpTypePointer Uniform %77 %108 = OpConstant %24 3 %110 = OpTypePointer Uniform %79 %113 = OpTypePointer Uniform %78 +%138 = OpVariable %26 UniformConstant %129 = OpConstantComposite %32 %45 %45 %4 = OpFunction %2 None %3 %5 = OpLabel %135 = OpFunctionCall %2 %6 %136 = OpFunctionCall %2 %8 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %12 = OpVariable %11 Function %20 = OpVariable %11 Function %44 = OpVariable %43 Function %46 = OpVariable %43 Function %56 = OpVariable %43 Function %18 = OpAccessChain %17 %15 %16 %19 = OpLoad %10 %18 OpStore %12 %19 %22 = OpAccessChain %17 %15 %21 %23 = OpLoad %10 %22 OpStore %20 %23 %28 = OpLoad %25 %27 %30 = OpLoad %13 %15 %31 = OpVectorShuffle %29 %30 %30 0 1 %33 = OpBitcast %32 %31 %34 = OpLoad %10 %12 %35 = OpLoad %10 %20 %36 = OpIAdd %10 %34 %35 %37 = OpBitcast %24 %36 %39 = OpCompositeConstruct %38 %37 %37 %37 %37 OpImageWrite %28 %33 %39 OpMemoryBarrier %40 %41 OpControlBarrier %40 %40 %42 OpStore %44 %45 OpStore %46 %45 OpBranch %47 %47 = OpLabel OpLoopMerge %49 %50 None OpBranch %51 %51 = OpLabel %52 = OpLoad %24 %46 %55 = OpSLessThan %54 %52 %53 OpBranchConditional %55 %48 %49 %48 = OpLabel OpStore %56 %45 OpBranch %57 %57 = OpLabel OpLoopMerge %59 %60 None OpBranch %61 %61 = OpLabel %62 = OpLoad %24 %56 %63 = OpSLessThan %54 %62 %53 OpBranchConditional %63 %58 %59 %58 = OpLabel %64 = OpLoad %25 %27 %65 = OpLoad %24 %46 %66 = OpLoad %24 %56 %67 = OpCompositeConstruct %32 %65 %66 %68 = OpImageRead %38 %64 %67 %69 = OpCompositeExtract %24 %68 0 %70 = OpLoad %24 %44 -%71 = OpIAdd %24 %70 %69 +%137 = OpIMul %24 %70 %69 -OpStore %44 %71 +OpStore %44 %137 OpBranch %60 %60 = OpLabel %72 = OpLoad %24 %56 %74 = OpIAdd %24 %72 %73 OpStore %56 %74 OpBranch %57 %59 = OpLabel OpBranch %50 %50 = OpLabel %75 = OpLoad %24 %46 %76 = OpIAdd %24 %75 %73 OpStore %46 %76 OpBranch %47 %49 = OpLabel OpMemoryBarrier %40 %41 OpControlBarrier %40 %40 %42 %83 = OpLoad %24 %44 %85 = OpAccessChain %84 %82 %53 OpStore %85 %83 OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %101 = OpVariable %43 Function %92 = OpAccessChain %91 %90 %73 %93 = OpLoad %87 %92 %95 = OpAccessChain %94 %82 %45 %96 = OpLoad %77 %95 %97 = OpConvertUToF %86 %96 %98 = OpMatrixTimesVector %86 %93 %97 %99 = OpConvertFToU %77 %98 %100 = OpAccessChain %94 %82 %45 OpStore %100 %99 OpStore %101 %45 OpBranch %102 %102 = OpLabel OpLoopMerge %104 %105 None OpBranch %106 %106 = OpLabel %107 = OpLoad %24 %101 %109 = OpSLessThan %54 %107 %108 OpBranchConditional %109 %103 %104 %103 = OpLabel %111 = OpAccessChain %110 %82 %73 %112 = OpLoad %79 %111 %114 = OpAccessChain %113 %90 %53 %115 = OpLoad %78 %114 %116 = OpVectorTimesScalar %79 %112 %115 %117 = OpConvertFToU %13 %116 %118 = OpCompositeExtract %10 %117 0 %119 = OpCompositeExtract %10 %117 1 %120 = OpCompositeExtract %10 %117 2 %121 = OpCompositeConstruct %77 %118 %119 %120 %16 %122 = OpAccessChain %94 %82 %45 %123 = OpLoad %77 %122 %124 = OpIAdd %77 %123 %121 %125 = OpAccessChain %94 %82 %45 OpStore %125 %124 OpBranch %105 %105 = OpLabel %126 = OpLoad %24 %101 %127 = OpIAdd %24 %126 %73 OpStore %101 %127 OpBranch %102 %104 = OpLabel OpMemoryBarrier %40 %41 OpControlBarrier %40 %40 %42 -%128 = OpLoad %25 %27 +%139 = OpLoad %25 %138 -%130 = OpImageRead %38 %128 %129 +%130 = OpImageRead %38 %139 %129 %131 = OpCompositeExtract %24 %130 0 %132 = OpConvertSToF %78 %131 %133 = OpCompositeConstruct %79 %132 %132 %132 %134 = OpAccessChain %110 %82 %73 OpStore %134 %133 OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrcNoDebug, kDstNoDebug, kDiff, options); } } // namespace } // namespace diff } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/large_functions_small_diffs_dst.spvasm000066400000000000000000000200121475742701700323370ustar00rootroot00000000000000 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" %15 OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpName %4 "main" OpName %6 "f1(" OpName %8 "f2(" OpName %12 "x" OpName %15 "gl_LocalInvocationID" OpName %20 "y" OpName %27 "image" OpName %44 "sum" OpName %46 "i" OpName %56 "j" OpName %80 "BufferOut" OpMemberName %80 0 "o_uv4" OpMemberName %80 1 "o_v3" OpMemberName %80 2 "o_i" OpName %82 "" OpName %88 "BufferIn" OpMemberName %88 0 "i_u" OpMemberName %88 1 "i_v4" OpMemberName %88 2 "i_f" OpName %90 "" OpName %101 "i" OpName %128 "image2" OpDecorate %15 BuiltIn LocalInvocationId OpDecorate %27 DescriptorSet 0 OpDecorate %27 Binding 2 OpMemberDecorate %80 0 Offset 0 OpMemberDecorate %80 1 Offset 16 OpMemberDecorate %80 2 Offset 28 OpDecorate %80 BufferBlock OpDecorate %82 DescriptorSet 0 OpDecorate %82 Binding 1 OpMemberDecorate %88 0 Offset 0 OpMemberDecorate %88 1 RowMajor OpMemberDecorate %88 1 Offset 16 OpMemberDecorate %88 1 MatrixStride 16 OpMemberDecorate %88 2 Offset 80 OpDecorate %88 Block OpDecorate %90 DescriptorSet 0 OpDecorate %90 Binding 0 OpDecorate %128 DescriptorSet 0 OpDecorate %128 Binding 3 %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeInt 32 0 %11 = OpTypePointer Function %10 %13 = OpTypeVector %10 3 %14 = OpTypePointer Input %13 %15 = OpVariable %14 Input %16 = OpConstant %10 0 %17 = OpTypePointer Input %10 %21 = OpConstant %10 1 %24 = OpTypeInt 32 1 %25 = OpTypeImage %24 2D 0 0 0 2 R32i %26 = OpTypePointer UniformConstant %25 %27 = OpVariable %26 UniformConstant %29 = OpTypeVector %10 2 %32 = OpTypeVector %24 2 %38 = OpTypeVector %24 4 %40 = OpConstant %10 2 %41 = OpConstant %10 3400 %42 = OpConstant %10 264 %43 = OpTypePointer Function %24 %45 = OpConstant %24 0 %53 = OpConstant %24 2 %54 = OpTypeBool %73 = OpConstant %24 1 %77 = OpTypeVector %10 4 %78 = OpTypeFloat 32 %79 = OpTypeVector %78 3 %80 = OpTypeStruct %77 %79 %24 %81 = OpTypePointer Uniform %80 %82 = OpVariable %81 Uniform %84 = OpTypePointer Uniform %24 %86 = OpTypeVector %78 4 %87 = OpTypeMatrix %86 4 %88 = OpTypeStruct %10 %87 %78 %89 = OpTypePointer Uniform %88 %90 = OpVariable %89 Uniform %91 = OpTypePointer Uniform %87 %94 = OpTypePointer Uniform %77 %108 = OpConstant %24 3 %110 = OpTypePointer Uniform %79 %113 = OpTypePointer Uniform %78 %128 = OpVariable %26 UniformConstant %130 = OpConstantComposite %32 %45 %45 %4 = OpFunction %2 None %3 %5 = OpLabel %136 = OpFunctionCall %2 %6 %137 = OpFunctionCall %2 %8 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %12 = OpVariable %11 Function %20 = OpVariable %11 Function %44 = OpVariable %43 Function %46 = OpVariable %43 Function %56 = OpVariable %43 Function %18 = OpAccessChain %17 %15 %16 %19 = OpLoad %10 %18 OpStore %12 %19 %22 = OpAccessChain %17 %15 %21 %23 = OpLoad %10 %22 OpStore %20 %23 %28 = OpLoad %25 %27 %30 = OpLoad %13 %15 %31 = OpVectorShuffle %29 %30 %30 0 1 %33 = OpBitcast %32 %31 %34 = OpLoad %10 %12 %35 = OpLoad %10 %20 %36 = OpIAdd %10 %34 %35 %37 = OpBitcast %24 %36 %39 = OpCompositeConstruct %38 %37 %37 %37 %37 OpImageWrite %28 %33 %39 OpMemoryBarrier %40 %41 OpControlBarrier %40 %40 %42 OpStore %44 %45 OpStore %46 %45 OpBranch %47 %47 = OpLabel OpLoopMerge %49 %50 None OpBranch %51 %51 = OpLabel %52 = OpLoad %24 %46 %55 = OpSLessThan %54 %52 %53 OpBranchConditional %55 %48 %49 %48 = OpLabel OpStore %56 %45 OpBranch %57 %57 = OpLabel OpLoopMerge %59 %60 None OpBranch %61 %61 = OpLabel %62 = OpLoad %24 %56 %63 = OpSLessThan %54 %62 %53 OpBranchConditional %63 %58 %59 %58 = OpLabel %64 = OpLoad %25 %27 %65 = OpLoad %24 %46 %66 = OpLoad %24 %56 %67 = OpCompositeConstruct %32 %65 %66 %68 = OpImageRead %38 %64 %67 %69 = OpCompositeExtract %24 %68 0 %70 = OpLoad %24 %44 %71 = OpIMul %24 %70 %69 OpStore %44 %71 OpBranch %60 %60 = OpLabel %72 = OpLoad %24 %56 %74 = OpIAdd %24 %72 %73 OpStore %56 %74 OpBranch %57 %59 = OpLabel OpBranch %50 %50 = OpLabel %75 = OpLoad %24 %46 %76 = OpIAdd %24 %75 %73 OpStore %46 %76 OpBranch %47 %49 = OpLabel OpMemoryBarrier %40 %41 OpControlBarrier %40 %40 %42 %83 = OpLoad %24 %44 %85 = OpAccessChain %84 %82 %53 OpStore %85 %83 OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %101 = OpVariable %43 Function %92 = OpAccessChain %91 %90 %73 %93 = OpLoad %87 %92 %95 = OpAccessChain %94 %82 %45 %96 = OpLoad %77 %95 %97 = OpConvertUToF %86 %96 %98 = OpMatrixTimesVector %86 %93 %97 %99 = OpConvertFToU %77 %98 %100 = OpAccessChain %94 %82 %45 OpStore %100 %99 OpStore %101 %45 OpBranch %102 %102 = OpLabel OpLoopMerge %104 %105 None OpBranch %106 %106 = OpLabel %107 = OpLoad %24 %101 %109 = OpSLessThan %54 %107 %108 OpBranchConditional %109 %103 %104 %103 = OpLabel %111 = OpAccessChain %110 %82 %73 %112 = OpLoad %79 %111 %114 = OpAccessChain %113 %90 %53 %115 = OpLoad %78 %114 %116 = OpVectorTimesScalar %79 %112 %115 %117 = OpConvertFToU %13 %116 %118 = OpCompositeExtract %10 %117 0 %119 = OpCompositeExtract %10 %117 1 %120 = OpCompositeExtract %10 %117 2 %121 = OpCompositeConstruct %77 %118 %119 %120 %16 %122 = OpAccessChain %94 %82 %45 %123 = OpLoad %77 %122 %124 = OpIAdd %77 %123 %121 %125 = OpAccessChain %94 %82 %45 OpStore %125 %124 OpBranch %105 %105 = OpLabel %126 = OpLoad %24 %101 %127 = OpIAdd %24 %126 %73 OpStore %101 %127 OpBranch %102 %104 = OpLabel OpMemoryBarrier %40 %41 OpControlBarrier %40 %40 %42 %129 = OpLoad %25 %128 %131 = OpImageRead %38 %129 %130 %132 = OpCompositeExtract %24 %131 0 %133 = OpConvertSToF %78 %132 %134 = OpCompositeConstruct %79 %133 %133 %133 %135 = OpAccessChain %110 %82 %73 OpStore %135 %134 OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/large_functions_small_diffs_src.spvasm000066400000000000000000000176541475742701700323560ustar00rootroot00000000000000;; Test where src and dst have a few large functions with small differences. OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" %15 OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpName %4 "main" OpName %6 "f1(" OpName %8 "f2(" OpName %12 "x" OpName %15 "gl_LocalInvocationID" OpName %20 "y" OpName %27 "image" OpName %44 "sum" OpName %46 "i" OpName %56 "j" OpName %80 "BufferOut" OpMemberName %80 0 "o_uv4" OpMemberName %80 1 "o_v3" OpMemberName %80 2 "o_i" OpName %82 "" OpName %88 "BufferIn" OpMemberName %88 0 "i_u" OpMemberName %88 1 "i_v4" OpMemberName %88 2 "i_f" OpName %90 "" OpName %101 "i" OpDecorate %15 BuiltIn LocalInvocationId OpDecorate %27 DescriptorSet 0 OpDecorate %27 Binding 2 OpMemberDecorate %80 0 Offset 0 OpMemberDecorate %80 1 Offset 16 OpMemberDecorate %80 2 Offset 28 OpDecorate %80 BufferBlock OpDecorate %82 DescriptorSet 0 OpDecorate %82 Binding 1 OpMemberDecorate %88 0 Offset 0 OpMemberDecorate %88 1 RowMajor OpMemberDecorate %88 1 Offset 16 OpMemberDecorate %88 1 MatrixStride 16 OpMemberDecorate %88 2 Offset 80 OpDecorate %88 Block OpDecorate %90 DescriptorSet 0 OpDecorate %90 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeInt 32 0 %11 = OpTypePointer Function %10 %13 = OpTypeVector %10 3 %14 = OpTypePointer Input %13 %15 = OpVariable %14 Input %16 = OpConstant %10 0 %17 = OpTypePointer Input %10 %21 = OpConstant %10 1 %24 = OpTypeInt 32 1 %25 = OpTypeImage %24 2D 0 0 0 2 R32i %26 = OpTypePointer UniformConstant %25 %27 = OpVariable %26 UniformConstant %29 = OpTypeVector %10 2 %32 = OpTypeVector %24 2 %38 = OpTypeVector %24 4 %40 = OpConstant %10 2 %41 = OpConstant %10 3400 %42 = OpConstant %10 264 %43 = OpTypePointer Function %24 %45 = OpConstant %24 0 %53 = OpConstant %24 2 %54 = OpTypeBool %73 = OpConstant %24 1 %77 = OpTypeVector %10 4 %78 = OpTypeFloat 32 %79 = OpTypeVector %78 3 %80 = OpTypeStruct %77 %79 %24 %81 = OpTypePointer Uniform %80 %82 = OpVariable %81 Uniform %84 = OpTypePointer Uniform %24 %86 = OpTypeVector %78 4 %87 = OpTypeMatrix %86 4 %88 = OpTypeStruct %10 %87 %78 %89 = OpTypePointer Uniform %88 %90 = OpVariable %89 Uniform %91 = OpTypePointer Uniform %87 %94 = OpTypePointer Uniform %77 %108 = OpConstant %24 3 %110 = OpTypePointer Uniform %79 %113 = OpTypePointer Uniform %78 %129 = OpConstantComposite %32 %45 %45 %4 = OpFunction %2 None %3 %5 = OpLabel %135 = OpFunctionCall %2 %6 %136 = OpFunctionCall %2 %8 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %12 = OpVariable %11 Function %20 = OpVariable %11 Function %44 = OpVariable %43 Function %46 = OpVariable %43 Function %56 = OpVariable %43 Function %18 = OpAccessChain %17 %15 %16 %19 = OpLoad %10 %18 OpStore %12 %19 %22 = OpAccessChain %17 %15 %21 %23 = OpLoad %10 %22 OpStore %20 %23 %28 = OpLoad %25 %27 %30 = OpLoad %13 %15 %31 = OpVectorShuffle %29 %30 %30 0 1 %33 = OpBitcast %32 %31 %34 = OpLoad %10 %12 %35 = OpLoad %10 %20 %36 = OpIAdd %10 %34 %35 %37 = OpBitcast %24 %36 %39 = OpCompositeConstruct %38 %37 %37 %37 %37 OpImageWrite %28 %33 %39 OpMemoryBarrier %40 %41 OpControlBarrier %40 %40 %42 OpStore %44 %45 OpStore %46 %45 OpBranch %47 %47 = OpLabel OpLoopMerge %49 %50 None OpBranch %51 %51 = OpLabel %52 = OpLoad %24 %46 %55 = OpSLessThan %54 %52 %53 OpBranchConditional %55 %48 %49 %48 = OpLabel OpStore %56 %45 OpBranch %57 %57 = OpLabel OpLoopMerge %59 %60 None OpBranch %61 %61 = OpLabel %62 = OpLoad %24 %56 %63 = OpSLessThan %54 %62 %53 OpBranchConditional %63 %58 %59 %58 = OpLabel %64 = OpLoad %25 %27 %65 = OpLoad %24 %46 %66 = OpLoad %24 %56 %67 = OpCompositeConstruct %32 %65 %66 %68 = OpImageRead %38 %64 %67 %69 = OpCompositeExtract %24 %68 0 %70 = OpLoad %24 %44 %71 = OpIAdd %24 %70 %69 OpStore %44 %71 OpBranch %60 %60 = OpLabel %72 = OpLoad %24 %56 %74 = OpIAdd %24 %72 %73 OpStore %56 %74 OpBranch %57 %59 = OpLabel OpBranch %50 %50 = OpLabel %75 = OpLoad %24 %46 %76 = OpIAdd %24 %75 %73 OpStore %46 %76 OpBranch %47 %49 = OpLabel OpMemoryBarrier %40 %41 OpControlBarrier %40 %40 %42 %83 = OpLoad %24 %44 %85 = OpAccessChain %84 %82 %53 OpStore %85 %83 OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %101 = OpVariable %43 Function %92 = OpAccessChain %91 %90 %73 %93 = OpLoad %87 %92 %95 = OpAccessChain %94 %82 %45 %96 = OpLoad %77 %95 %97 = OpConvertUToF %86 %96 %98 = OpMatrixTimesVector %86 %93 %97 %99 = OpConvertFToU %77 %98 %100 = OpAccessChain %94 %82 %45 OpStore %100 %99 OpStore %101 %45 OpBranch %102 %102 = OpLabel OpLoopMerge %104 %105 None OpBranch %106 %106 = OpLabel %107 = OpLoad %24 %101 %109 = OpSLessThan %54 %107 %108 OpBranchConditional %109 %103 %104 %103 = OpLabel %111 = OpAccessChain %110 %82 %73 %112 = OpLoad %79 %111 %114 = OpAccessChain %113 %90 %53 %115 = OpLoad %78 %114 %116 = OpVectorTimesScalar %79 %112 %115 %117 = OpConvertFToU %13 %116 %118 = OpCompositeExtract %10 %117 0 %119 = OpCompositeExtract %10 %117 1 %120 = OpCompositeExtract %10 %117 2 %121 = OpCompositeConstruct %77 %118 %119 %120 %16 %122 = OpAccessChain %94 %82 %45 %123 = OpLoad %77 %122 %124 = OpIAdd %77 %123 %121 %125 = OpAccessChain %94 %82 %45 OpStore %125 %124 OpBranch %105 %105 = OpLabel %126 = OpLoad %24 %101 %127 = OpIAdd %24 %126 %73 OpStore %101 %127 OpBranch %102 %104 = OpLabel OpMemoryBarrier %40 %41 OpControlBarrier %40 %40 %42 %128 = OpLoad %25 %27 %130 = OpImageRead %38 %128 %129 %131 = OpCompositeExtract %24 %130 0 %132 = OpConvertSToF %78 %131 %133 = OpCompositeConstruct %79 %132 %132 %132 %134 = OpAccessChain %110 %82 %73 OpStore %134 %133 OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/multiple_different_entry_points_autogen.cpp000066400000000000000000000246041475742701700334440ustar00rootroot00000000000000// GENERATED FILE - DO NOT EDIT. // Generated by generate_tests.py // // Copyright (c) 2022 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "../diff_test_utils.h" #include "gtest/gtest.h" namespace spvtools { namespace diff { namespace { // Basic test for multiple entry points. The entry points have different // execution models and so can be trivially matched. constexpr char kSrc[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %mainv "mainv" %vo %a OpEntryPoint Fragment %mainf "mainf" %color %vi OpExecutionMode %mainf OriginUpperLeft OpSource ESSL 310 OpName %mainv "mainv" OpName %mainf "mainf" OpName %a "a" OpName %vo "v" OpName %vi "v" OpName %color "color" OpDecorate %a Location 0 OpDecorate %vo Location 0 OpDecorate %vi Location 0 OpDecorate %color Location 0 OpDecorate %color RelaxedPrecision OpDecorate %vi RelaxedPrecision OpDecorate %12 RelaxedPrecision OpDecorate %13 RelaxedPrecision %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_float = OpTypePointer Input %float %a = OpVariable %_ptr_Input_float Input %_ptr_Output_float = OpTypePointer Output %float %vo = OpVariable %_ptr_Output_float Output %vi = OpVariable %_ptr_Input_float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %color = OpVariable %_ptr_Output_v4float Output %mainv = OpFunction %void None %3 %5 = OpLabel %11 = OpLoad %float %a OpStore %vo %11 OpReturn OpFunctionEnd %mainf = OpFunction %void None %3 %6 = OpLabel %12 = OpLoad %float %vi %13 = OpCompositeConstruct %v4float %12 %12 %12 %12 OpStore %color %13 OpReturn OpFunctionEnd)"; constexpr char kDst[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %frag "frag" %vi %color OpEntryPoint Vertex %vert "vert" %a %vo OpExecutionMode %frag OriginUpperLeft OpSource ESSL 310 OpName %frag "frag" OpName %vert "vert" OpName %vo "v" OpName %a "a" OpName %color "color" OpName %vi "v" OpDecorate %vi Location 0 OpDecorate %color Location 0 OpDecorate %a Location 0 OpDecorate %vo Location 0 OpDecorate %color RelaxedPrecision OpDecorate %vi RelaxedPrecision OpDecorate %14 RelaxedPrecision OpDecorate %17 RelaxedPrecision %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %void = OpTypeVoid %3 = OpTypeFunction %void %_ptr_Output_float = OpTypePointer Output %float %vo = OpVariable %_ptr_Output_float Output %_ptr_Input_float = OpTypePointer Input %float %a = OpVariable %_ptr_Input_float Input %vi = OpVariable %_ptr_Input_float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %color = OpVariable %_ptr_Output_v4float Output %frag = OpFunction %void None %3 %7 = OpLabel %14 = OpLoad %float %vi %17 = OpCompositeConstruct %v4float %14 %14 %14 %14 OpStore %color %17 OpReturn OpFunctionEnd %vert = OpFunction %void None %3 %8 = OpLabel %13 = OpLoad %float %a OpStore %vo %13 OpReturn OpFunctionEnd )"; TEST(DiffTest, MultipleDifferentEntryPoints) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 20 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 -OpEntryPoint Vertex %2 "mainv" %4 %7 +OpEntryPoint Vertex %2 "vert" %7 %4 -OpEntryPoint Fragment %8 "mainf" %9 %10 +OpEntryPoint Fragment %8 "frag" %10 %9 OpExecutionMode %8 OriginUpperLeft OpSource ESSL 310 -OpName %2 "mainv" +OpName %2 "vert" -OpName %8 "mainf" +OpName %8 "frag" OpName %7 "a" OpName %4 "v" OpName %10 "v" OpName %9 "color" OpDecorate %7 Location 0 OpDecorate %4 Location 0 OpDecorate %10 Location 0 OpDecorate %9 Location 0 OpDecorate %9 RelaxedPrecision OpDecorate %10 RelaxedPrecision OpDecorate %12 RelaxedPrecision OpDecorate %13 RelaxedPrecision %14 = OpTypeVoid %3 = OpTypeFunction %14 %15 = OpTypeFloat 32 %16 = OpTypeVector %15 4 %17 = OpTypePointer Input %15 %7 = OpVariable %17 Input %18 = OpTypePointer Output %15 %4 = OpVariable %18 Output %10 = OpVariable %17 Input %19 = OpTypePointer Output %16 %9 = OpVariable %19 Output %2 = OpFunction %14 None %3 %5 = OpLabel %11 = OpLoad %15 %7 OpStore %4 %11 OpReturn OpFunctionEnd %8 = OpFunction %14 None %3 %6 = OpLabel %12 = OpLoad %15 %10 %13 = OpCompositeConstruct %16 %12 %12 %12 %12 OpStore %9 %13 OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrc, kDst, kDiff, options); } TEST(DiffTest, MultipleDifferentEntryPointsNoDebug) { constexpr char kSrcNoDebug[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %mainv "mainv" %vo %a OpEntryPoint Fragment %mainf "mainf" %color %vi OpExecutionMode %mainf OriginUpperLeft OpSource ESSL 310 OpDecorate %a Location 0 OpDecorate %vo Location 0 OpDecorate %vi Location 0 OpDecorate %color Location 0 OpDecorate %color RelaxedPrecision OpDecorate %vi RelaxedPrecision OpDecorate %12 RelaxedPrecision OpDecorate %13 RelaxedPrecision %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_float = OpTypePointer Input %float %a = OpVariable %_ptr_Input_float Input %_ptr_Output_float = OpTypePointer Output %float %vo = OpVariable %_ptr_Output_float Output %vi = OpVariable %_ptr_Input_float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %color = OpVariable %_ptr_Output_v4float Output %mainv = OpFunction %void None %3 %5 = OpLabel %11 = OpLoad %float %a OpStore %vo %11 OpReturn OpFunctionEnd %mainf = OpFunction %void None %3 %6 = OpLabel %12 = OpLoad %float %vi %13 = OpCompositeConstruct %v4float %12 %12 %12 %12 OpStore %color %13 OpReturn OpFunctionEnd )"; constexpr char kDstNoDebug[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %frag "frag" %vi %color OpEntryPoint Vertex %vert "vert" %a %vo OpExecutionMode %frag OriginUpperLeft OpSource ESSL 310 OpDecorate %vi Location 0 OpDecorate %color Location 0 OpDecorate %a Location 0 OpDecorate %vo Location 0 OpDecorate %color RelaxedPrecision OpDecorate %vi RelaxedPrecision OpDecorate %14 RelaxedPrecision OpDecorate %17 RelaxedPrecision %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %void = OpTypeVoid %3 = OpTypeFunction %void %_ptr_Output_float = OpTypePointer Output %float %vo = OpVariable %_ptr_Output_float Output %_ptr_Input_float = OpTypePointer Input %float %a = OpVariable %_ptr_Input_float Input %vi = OpVariable %_ptr_Input_float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %color = OpVariable %_ptr_Output_v4float Output %frag = OpFunction %void None %3 %7 = OpLabel %14 = OpLoad %float %vi %17 = OpCompositeConstruct %v4float %14 %14 %14 %14 OpStore %color %17 OpReturn OpFunctionEnd %vert = OpFunction %void None %3 %8 = OpLabel %13 = OpLoad %float %a OpStore %vo %13 OpReturn OpFunctionEnd )"; constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 20 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 -OpEntryPoint Vertex %2 "mainv" %4 %7 +OpEntryPoint Vertex %2 "vert" %7 %4 -OpEntryPoint Fragment %8 "mainf" %9 %10 +OpEntryPoint Fragment %8 "frag" %10 %9 OpExecutionMode %8 OriginUpperLeft OpSource ESSL 310 OpDecorate %7 Location 0 OpDecorate %4 Location 0 OpDecorate %10 Location 0 OpDecorate %9 Location 0 OpDecorate %9 RelaxedPrecision OpDecorate %10 RelaxedPrecision OpDecorate %12 RelaxedPrecision OpDecorate %13 RelaxedPrecision %14 = OpTypeVoid %3 = OpTypeFunction %14 %15 = OpTypeFloat 32 %16 = OpTypeVector %15 4 %17 = OpTypePointer Input %15 %7 = OpVariable %17 Input %18 = OpTypePointer Output %15 %4 = OpVariable %18 Output %10 = OpVariable %17 Input %19 = OpTypePointer Output %16 %9 = OpVariable %19 Output %2 = OpFunction %14 None %3 %5 = OpLabel %11 = OpLoad %15 %7 OpStore %4 %11 OpReturn OpFunctionEnd %8 = OpFunction %14 None %3 %6 = OpLabel %12 = OpLoad %15 %10 %13 = OpCompositeConstruct %16 %12 %12 %12 %12 OpStore %9 %13 OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrcNoDebug, kDstNoDebug, kDiff, options); } } // namespace } // namespace diff } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/multiple_different_entry_points_dst.spvasm000066400000000000000000000033441475742701700333210ustar00rootroot00000000000000 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %frag "frag" %vi %color OpEntryPoint Vertex %vert "vert" %a %vo OpExecutionMode %frag OriginUpperLeft OpSource ESSL 310 OpName %frag "frag" OpName %vert "vert" OpName %vo "v" OpName %a "a" OpName %color "color" OpName %vi "v" OpDecorate %vi Location 0 OpDecorate %color Location 0 OpDecorate %a Location 0 OpDecorate %vo Location 0 OpDecorate %color RelaxedPrecision OpDecorate %vi RelaxedPrecision OpDecorate %14 RelaxedPrecision OpDecorate %17 RelaxedPrecision %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %void = OpTypeVoid %3 = OpTypeFunction %void %_ptr_Output_float = OpTypePointer Output %float %vo = OpVariable %_ptr_Output_float Output %_ptr_Input_float = OpTypePointer Input %float %a = OpVariable %_ptr_Input_float Input %vi = OpVariable %_ptr_Input_float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %color = OpVariable %_ptr_Output_v4float Output %frag = OpFunction %void None %3 %7 = OpLabel %14 = OpLoad %float %vi %17 = OpCompositeConstruct %v4float %14 %14 %14 %14 OpStore %color %17 OpReturn OpFunctionEnd %vert = OpFunction %void None %3 %8 = OpLabel %13 = OpLoad %float %a OpStore %vo %13 OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/multiple_different_entry_points_src.spvasm000066400000000000000000000035541475742701700333210ustar00rootroot00000000000000;; Basic test for multiple entry points. The entry points have different ;; execution models and so can be trivially matched. OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %mainv "mainv" %vo %a OpEntryPoint Fragment %mainf "mainf" %color %vi OpExecutionMode %mainf OriginUpperLeft OpSource ESSL 310 OpName %mainv "mainv" OpName %mainf "mainf" OpName %a "a" OpName %vo "v" OpName %vi "v" OpName %color "color" OpDecorate %a Location 0 OpDecorate %vo Location 0 OpDecorate %vi Location 0 OpDecorate %color Location 0 OpDecorate %color RelaxedPrecision OpDecorate %vi RelaxedPrecision OpDecorate %12 RelaxedPrecision OpDecorate %13 RelaxedPrecision %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_float = OpTypePointer Input %float %a = OpVariable %_ptr_Input_float Input %_ptr_Output_float = OpTypePointer Output %float %vo = OpVariable %_ptr_Output_float Output %vi = OpVariable %_ptr_Input_float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %color = OpVariable %_ptr_Output_v4float Output %mainv = OpFunction %void None %3 %5 = OpLabel %11 = OpLoad %float %a OpStore %vo %11 OpReturn OpFunctionEnd %mainf = OpFunction %void None %3 %6 = OpLabel %12 = OpLoad %float %vi %13 = OpCompositeConstruct %v4float %12 %12 %12 %12 OpStore %color %13 OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/multiple_same_entry_points_autogen.cpp000066400000000000000000000242371475742701700324250ustar00rootroot00000000000000// GENERATED FILE - DO NOT EDIT. // Generated by generate_tests.py // // Copyright (c) 2022 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "../diff_test_utils.h" #include "gtest/gtest.h" namespace spvtools { namespace diff { namespace { // Test for multiple entry points with the same execution model. constexpr char kSrc[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %4 "main1" %8 %10 OpEntryPoint Vertex %12 "main2" %13 %14 %15 OpSource ESSL 310 OpName %4 "main1" OpName %12 "main2" OpName %8 "v" OpName %10 "a" OpName %13 "v" OpName %14 "a" OpName %15 "b" OpDecorate %8 Location 0 OpDecorate %10 Location 0 OpDecorate %13 Location 0 OpDecorate %14 Location 0 OpDecorate %15 Location 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Output %6 %9 = OpTypePointer Input %6 %8 = OpVariable %7 Output %10 = OpVariable %9 Input %13 = OpVariable %7 Output %14 = OpVariable %9 Input %15 = OpVariable %9 Input %4 = OpFunction %2 None %3 %5 = OpLabel %11 = OpLoad %6 %10 OpStore %8 %11 OpReturn OpFunctionEnd %12 = OpFunction %2 None %3 %16 = OpLabel %17 = OpLoad %6 %14 %18 = OpLoad %6 %15 %19 = OpFAdd %6 %17 %18 OpStore %13 %19 OpReturn OpFunctionEnd)"; constexpr char kDst[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %4 "main2" %13 %14 %15 OpEntryPoint Vertex %12 "main1" %8 %10 OpSource ESSL 310 OpName %12 "main1" OpName %4 "main2" OpName %8 "v" OpName %10 "a" OpName %13 "v" OpName %14 "a" OpName %15 "b" OpDecorate %8 Location 0 OpDecorate %10 Location 0 OpDecorate %13 Location 0 OpDecorate %14 Location 0 OpDecorate %15 Location 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Output %6 %9 = OpTypePointer Input %6 %8 = OpVariable %7 Output %10 = OpVariable %9 Input %13 = OpVariable %7 Output %14 = OpVariable %9 Input %15 = OpVariable %9 Input %4 = OpFunction %2 None %3 %16 = OpLabel %17 = OpLoad %6 %14 %18 = OpLoad %6 %15 %19 = OpFAdd %6 %17 %18 OpStore %13 %19 OpReturn OpFunctionEnd %12 = OpFunction %2 None %3 %5 = OpLabel %11 = OpLoad %6 %10 OpStore %8 %11 OpReturn OpFunctionEnd )"; TEST(DiffTest, MultipleSameEntryPoints) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 20 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %4 "main1" %8 %10 OpEntryPoint Vertex %12 "main2" %13 %14 %15 OpSource ESSL 310 OpName %4 "main1" OpName %12 "main2" OpName %8 "v" OpName %10 "a" OpName %13 "v" OpName %14 "a" OpName %15 "b" OpDecorate %8 Location 0 OpDecorate %10 Location 0 OpDecorate %13 Location 0 OpDecorate %14 Location 0 OpDecorate %15 Location 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Output %6 %9 = OpTypePointer Input %6 %8 = OpVariable %7 Output %10 = OpVariable %9 Input %13 = OpVariable %7 Output %14 = OpVariable %9 Input %15 = OpVariable %9 Input %4 = OpFunction %2 None %3 %5 = OpLabel %11 = OpLoad %6 %10 OpStore %8 %11 OpReturn OpFunctionEnd %12 = OpFunction %2 None %3 %16 = OpLabel %17 = OpLoad %6 %14 %18 = OpLoad %6 %15 %19 = OpFAdd %6 %17 %18 OpStore %13 %19 OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrc, kDst, kDiff, options); } TEST(DiffTest, MultipleSameEntryPointsNoDebug) { constexpr char kSrcNoDebug[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %4 "main1" %8 %10 OpEntryPoint Vertex %12 "main2" %13 %14 %15 OpSource ESSL 310 OpDecorate %8 Location 0 OpDecorate %10 Location 0 OpDecorate %13 Location 0 OpDecorate %14 Location 0 OpDecorate %15 Location 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Output %6 %9 = OpTypePointer Input %6 %8 = OpVariable %7 Output %10 = OpVariable %9 Input %13 = OpVariable %7 Output %14 = OpVariable %9 Input %15 = OpVariable %9 Input %4 = OpFunction %2 None %3 %5 = OpLabel %11 = OpLoad %6 %10 OpStore %8 %11 OpReturn OpFunctionEnd %12 = OpFunction %2 None %3 %16 = OpLabel %17 = OpLoad %6 %14 %18 = OpLoad %6 %15 %19 = OpFAdd %6 %17 %18 OpStore %13 %19 OpReturn OpFunctionEnd )"; constexpr char kDstNoDebug[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %4 "main2" %13 %14 %15 OpEntryPoint Vertex %12 "main1" %8 %10 OpSource ESSL 310 OpDecorate %8 Location 0 OpDecorate %10 Location 0 OpDecorate %13 Location 0 OpDecorate %14 Location 0 OpDecorate %15 Location 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Output %6 %9 = OpTypePointer Input %6 %8 = OpVariable %7 Output %10 = OpVariable %9 Input %13 = OpVariable %7 Output %14 = OpVariable %9 Input %15 = OpVariable %9 Input %4 = OpFunction %2 None %3 %16 = OpLabel %17 = OpLoad %6 %14 %18 = OpLoad %6 %15 %19 = OpFAdd %6 %17 %18 OpStore %13 %19 OpReturn OpFunctionEnd %12 = OpFunction %2 None %3 %5 = OpLabel %11 = OpLoad %6 %10 OpStore %8 %11 OpReturn OpFunctionEnd )"; constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 20 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %4 "main1" %8 %10 OpEntryPoint Vertex %12 "main2" %13 %14 %15 OpSource ESSL 310 OpDecorate %8 Location 0 OpDecorate %10 Location 0 OpDecorate %13 Location 0 OpDecorate %14 Location 0 OpDecorate %15 Location 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Output %6 %9 = OpTypePointer Input %6 %8 = OpVariable %7 Output %10 = OpVariable %9 Input %13 = OpVariable %7 Output %14 = OpVariable %9 Input %15 = OpVariable %9 Input %4 = OpFunction %2 None %3 %5 = OpLabel %11 = OpLoad %6 %10 OpStore %8 %11 OpReturn OpFunctionEnd %12 = OpFunction %2 None %3 %16 = OpLabel %17 = OpLoad %6 %14 %18 = OpLoad %6 %15 %19 = OpFAdd %6 %17 %18 OpStore %13 %19 OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrcNoDebug, kDstNoDebug, kDiff, options); } TEST(DiffTest, MultipleSameEntryPointsDumpIds) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 20 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %4 "main1" %8 %10 OpEntryPoint Vertex %12 "main2" %13 %14 %15 OpSource ESSL 310 OpName %4 "main1" OpName %12 "main2" OpName %8 "v" OpName %10 "a" OpName %13 "v" OpName %14 "a" OpName %15 "b" OpDecorate %8 Location 0 OpDecorate %10 Location 0 OpDecorate %13 Location 0 OpDecorate %14 Location 0 OpDecorate %15 Location 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Output %6 %9 = OpTypePointer Input %6 %8 = OpVariable %7 Output %10 = OpVariable %9 Input %13 = OpVariable %7 Output %14 = OpVariable %9 Input %15 = OpVariable %9 Input %4 = OpFunction %2 None %3 %5 = OpLabel %11 = OpLoad %6 %10 OpStore %8 %11 OpReturn OpFunctionEnd %12 = OpFunction %2 None %3 %16 = OpLabel %17 = OpLoad %6 %14 %18 = OpLoad %6 %15 %19 = OpFAdd %6 %17 %18 OpStore %13 %19 OpReturn OpFunctionEnd Src -> Dst 1 -> 1 [ExtInstImport] 2 -> 2 [TypeVoid] 3 -> 3 [TypeFunction] 4 -> 12 [Function] 5 -> 5 [Label] 6 -> 6 [TypeFloat] 7 -> 7 [TypePointer] 8 -> 8 [Variable] 9 -> 9 [TypePointer] 10 -> 10 [Variable] 11 -> 11 [Load] 12 -> 4 [Function] 13 -> 13 [Variable] 14 -> 14 [Variable] 15 -> 15 [Variable] 16 -> 16 [Label] 17 -> 17 [Load] 18 -> 18 [Load] 19 -> 19 [FAdd] )"; Options options; options.dump_id_map = true; DoStringDiffTest(kSrc, kDst, kDiff, options); } } // namespace } // namespace diff } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/multiple_same_entry_points_dst.spvasm000066400000000000000000000026431475742701700323010ustar00rootroot00000000000000 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %4 "main2" %13 %14 %15 OpEntryPoint Vertex %12 "main1" %8 %10 OpSource ESSL 310 OpName %12 "main1" OpName %4 "main2" OpName %8 "v" OpName %10 "a" OpName %13 "v" OpName %14 "a" OpName %15 "b" OpDecorate %8 Location 0 OpDecorate %10 Location 0 OpDecorate %13 Location 0 OpDecorate %14 Location 0 OpDecorate %15 Location 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Output %6 %9 = OpTypePointer Input %6 %8 = OpVariable %7 Output %10 = OpVariable %9 Input %13 = OpVariable %7 Output %14 = OpVariable %9 Input %15 = OpVariable %9 Input %4 = OpFunction %2 None %3 %16 = OpLabel %17 = OpLoad %6 %14 %18 = OpLoad %6 %15 %19 = OpFAdd %6 %17 %18 OpStore %13 %19 OpReturn OpFunctionEnd %12 = OpFunction %2 None %3 %5 = OpLabel %11 = OpLoad %6 %10 OpStore %8 %11 OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/multiple_same_entry_points_src.spvasm000066400000000000000000000027451475742701700323010ustar00rootroot00000000000000;; Test for multiple entry points with the same execution model. OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %4 "main1" %8 %10 OpEntryPoint Vertex %12 "main2" %13 %14 %15 OpSource ESSL 310 OpName %4 "main1" OpName %12 "main2" OpName %8 "v" OpName %10 "a" OpName %13 "v" OpName %14 "a" OpName %15 "b" OpDecorate %8 Location 0 OpDecorate %10 Location 0 OpDecorate %13 Location 0 OpDecorate %14 Location 0 OpDecorate %15 Location 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Output %6 %9 = OpTypePointer Input %6 %8 = OpVariable %7 Output %10 = OpVariable %9 Input %13 = OpVariable %7 Output %14 = OpVariable %9 Input %15 = OpVariable %9 Input %4 = OpFunction %2 None %3 %5 = OpLabel %11 = OpLoad %6 %10 OpStore %8 %11 OpReturn OpFunctionEnd %12 = OpFunction %2 None %3 %16 = OpLabel %17 = OpLoad %6 %14 %18 = OpLoad %6 %15 %19 = OpFAdd %6 %17 %18 OpStore %13 %19 OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/ray_query_types_autogen.cpp000066400000000000000000000072511475742701700302110ustar00rootroot00000000000000// GENERATED FILE - DO NOT EDIT. // Generated by generate_tests.py // // Copyright (c) 2022 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "../diff_test_utils.h" #include "gtest/gtest.h" namespace spvtools { namespace diff { namespace { // Test that OpTypeAccelerationStructureNV and OpTypeRayQueryKHR are // matched. constexpr char kSrc[] = R"(OpCapability RayQueryKHR OpCapability Shader OpExtension "SPV_KHR_ray_query" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %43 "main" OpExecutionMode %43 LocalSize 1 1 1 %2 = OpTypeVoid %3 = OpTypeAccelerationStructureNV %13 = OpTypeRayQueryKHR %44 = OpTypeFunction %2 %43 = OpFunction %2 None %44 %42 = OpLabel OpReturn OpFunctionEnd)"; constexpr char kDst[] = R"(; SPIR-V ; Version: 1.4 ; Generator: rspirv ; Bound: 95 OpCapability RayQueryKHR OpCapability Shader OpExtension "SPV_KHR_ray_query" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %43 "main" OpExecutionMode %43 LocalSize 1 1 1 %2 = OpTypeVoid %3 = OpTypeAccelerationStructureNV %13 = OpTypeRayQueryKHR %44 = OpTypeFunction %2 %43 = OpFunction %2 None %44 %42 = OpLabel OpReturn OpFunctionEnd )"; TEST(DiffTest, RayQueryTypes) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 45 ; Schema: 0 OpCapability RayQueryKHR OpCapability Shader OpExtension "SPV_KHR_ray_query" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %43 "main" OpExecutionMode %43 LocalSize 1 1 1 %2 = OpTypeVoid %3 = OpTypeAccelerationStructureKHR %13 = OpTypeRayQueryKHR %44 = OpTypeFunction %2 %43 = OpFunction %2 None %44 %42 = OpLabel OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrc, kDst, kDiff, options); } TEST(DiffTest, RayQueryTypesNoDebug) { constexpr char kSrcNoDebug[] = R"(OpCapability RayQueryKHR OpCapability Shader OpExtension "SPV_KHR_ray_query" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %43 "main" OpExecutionMode %43 LocalSize 1 1 1 %2 = OpTypeVoid %3 = OpTypeAccelerationStructureNV %13 = OpTypeRayQueryKHR %44 = OpTypeFunction %2 %43 = OpFunction %2 None %44 %42 = OpLabel OpReturn OpFunctionEnd )"; constexpr char kDstNoDebug[] = R"(; SPIR-V ; Version: 1.4 ; Generator: rspirv ; Bound: 95 OpCapability RayQueryKHR OpCapability Shader OpExtension "SPV_KHR_ray_query" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %43 "main" OpExecutionMode %43 LocalSize 1 1 1 %2 = OpTypeVoid %3 = OpTypeAccelerationStructureNV %13 = OpTypeRayQueryKHR %44 = OpTypeFunction %2 %43 = OpFunction %2 None %44 %42 = OpLabel OpReturn OpFunctionEnd )"; constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 45 ; Schema: 0 OpCapability RayQueryKHR OpCapability Shader OpExtension "SPV_KHR_ray_query" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %43 "main" OpExecutionMode %43 LocalSize 1 1 1 %2 = OpTypeVoid %3 = OpTypeAccelerationStructureKHR %13 = OpTypeRayQueryKHR %44 = OpTypeFunction %2 %43 = OpFunction %2 None %44 %42 = OpLabel OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrcNoDebug, kDstNoDebug, kDiff, options); } } // namespace } // namespace diff } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/ray_query_types_dst.spvasm000066400000000000000000000006201475742701700300610ustar00rootroot00000000000000; SPIR-V ; Version: 1.4 ; Generator: rspirv ; Bound: 95 OpCapability RayQueryKHR OpCapability Shader OpExtension "SPV_KHR_ray_query" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %43 "main" OpExecutionMode %43 LocalSize 1 1 1 %2 = OpTypeVoid %3 = OpTypeAccelerationStructureNV %13 = OpTypeRayQueryKHR %44 = OpTypeFunction %2 %43 = OpFunction %2 None %44 %42 = OpLabel OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/ray_query_types_src.spvasm000066400000000000000000000006511475742701700300620ustar00rootroot00000000000000;; Test that OpTypeAccelerationStructureNV and OpTypeRayQueryKHR are ;; matched. OpCapability RayQueryKHR OpCapability Shader OpExtension "SPV_KHR_ray_query" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %43 "main" OpExecutionMode %43 LocalSize 1 1 1 %2 = OpTypeVoid %3 = OpTypeAccelerationStructureNV %13 = OpTypeRayQueryKHR %44 = OpTypeFunction %2 %43 = OpFunction %2 None %44 %42 = OpLabel OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/reordered_if_blocks_autogen.cpp000066400000000000000000000460301475742701700307310ustar00rootroot00000000000000// GENERATED FILE - DO NOT EDIT. // Generated by generate_tests.py // // Copyright (c) 2022 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "../diff_test_utils.h" #include "gtest/gtest.h" namespace spvtools { namespace diff { namespace { // Test where src and dst have the true and false blocks of an if reordered. constexpr char kSrc[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %8 %44 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "v" OpName %44 "color" OpDecorate %8 RelaxedPrecision OpDecorate %8 Location 0 OpDecorate %9 RelaxedPrecision OpDecorate %18 RelaxedPrecision OpDecorate %19 RelaxedPrecision OpDecorate %20 RelaxedPrecision OpDecorate %23 RelaxedPrecision OpDecorate %24 RelaxedPrecision OpDecorate %25 RelaxedPrecision OpDecorate %26 RelaxedPrecision OpDecorate %27 RelaxedPrecision OpDecorate %28 RelaxedPrecision OpDecorate %29 RelaxedPrecision OpDecorate %30 RelaxedPrecision OpDecorate %31 RelaxedPrecision OpDecorate %33 RelaxedPrecision OpDecorate %34 RelaxedPrecision OpDecorate %35 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %40 RelaxedPrecision OpDecorate %41 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %44 RelaxedPrecision OpDecorate %44 Location 0 OpDecorate %45 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Input %6 %8 = OpVariable %7 Input %10 = OpConstant %6 0 %11 = OpTypeBool %15 = OpTypeVector %6 4 %16 = OpTypePointer Function %15 %21 = OpConstant %6 -0.5 %22 = OpConstant %6 -0.300000012 %38 = OpConstant %6 0.5 %43 = OpTypePointer Output %15 %44 = OpVariable %43 Output %4 = OpFunction %2 None %3 %5 = OpLabel %9 = OpLoad %6 %8 %12 = OpFOrdLessThanEqual %11 %9 %10 OpSelectionMerge %14 None OpBranchConditional %12 %13 %32 %13 = OpLabel %18 = OpLoad %6 %8 %19 = OpExtInst %6 %1 Log %18 %20 = OpLoad %6 %8 %23 = OpExtInst %6 %1 FClamp %20 %21 %22 %24 = OpFMul %6 %19 %23 %25 = OpLoad %6 %8 %26 = OpExtInst %6 %1 Sin %25 %27 = OpLoad %6 %8 %28 = OpExtInst %6 %1 Cos %27 %29 = OpLoad %6 %8 %30 = OpExtInst %6 %1 Exp %29 %31 = OpCompositeConstruct %15 %24 %26 %28 %30 OpBranch %14 %32 = OpLabel %33 = OpLoad %6 %8 %34 = OpExtInst %6 %1 Sqrt %33 %35 = OpLoad %6 %8 %36 = OpExtInst %6 %1 FSign %35 %37 = OpLoad %6 %8 %39 = OpExtInst %6 %1 FMax %37 %38 %40 = OpLoad %6 %8 %41 = OpExtInst %6 %1 Floor %40 %42 = OpCompositeConstruct %15 %34 %36 %39 %41 OpBranch %14 %14 = OpLabel %45 = OpPhi %15 %31 %13 %42 %32 OpStore %44 %45 OpReturn OpFunctionEnd)"; constexpr char kDst[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %8 %44 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "v" OpName %44 "color" OpDecorate %8 RelaxedPrecision OpDecorate %8 Location 0 OpDecorate %9 RelaxedPrecision OpDecorate %18 RelaxedPrecision OpDecorate %19 RelaxedPrecision OpDecorate %20 RelaxedPrecision OpDecorate %21 RelaxedPrecision OpDecorate %22 RelaxedPrecision OpDecorate %24 RelaxedPrecision OpDecorate %25 RelaxedPrecision OpDecorate %26 RelaxedPrecision OpDecorate %27 RelaxedPrecision OpDecorate %29 RelaxedPrecision OpDecorate %30 RelaxedPrecision OpDecorate %31 RelaxedPrecision OpDecorate %34 RelaxedPrecision OpDecorate %35 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %38 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %40 RelaxedPrecision OpDecorate %41 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %44 RelaxedPrecision OpDecorate %44 Location 0 OpDecorate %45 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Input %6 %8 = OpVariable %7 Input %10 = OpConstant %6 0 %11 = OpTypeBool %15 = OpTypeVector %6 4 %16 = OpTypePointer Function %15 %23 = OpConstant %6 0.5 %32 = OpConstant %6 -0.5 %33 = OpConstant %6 -0.300000012 %43 = OpTypePointer Output %15 %44 = OpVariable %43 Output %4 = OpFunction %2 None %3 %5 = OpLabel %9 = OpLoad %6 %8 %12 = OpFOrdLessThanEqual %11 %9 %10 OpSelectionMerge %14 None OpBranchConditional %12 %28 %13 %13 = OpLabel %18 = OpLoad %6 %8 %19 = OpExtInst %6 %1 Sqrt %18 %20 = OpLoad %6 %8 %21 = OpExtInst %6 %1 FSign %20 %22 = OpLoad %6 %8 %24 = OpExtInst %6 %1 FMax %22 %23 %25 = OpLoad %6 %8 %26 = OpExtInst %6 %1 Floor %25 %27 = OpCompositeConstruct %15 %19 %21 %24 %26 OpBranch %14 %28 = OpLabel %29 = OpLoad %6 %8 %30 = OpExtInst %6 %1 Log %29 %31 = OpLoad %6 %8 %34 = OpExtInst %6 %1 FClamp %31 %32 %33 %35 = OpFMul %6 %30 %34 %36 = OpLoad %6 %8 %37 = OpExtInst %6 %1 Sin %36 %38 = OpLoad %6 %8 %39 = OpExtInst %6 %1 Cos %38 %40 = OpLoad %6 %8 %41 = OpExtInst %6 %1 Exp %40 %42 = OpCompositeConstruct %15 %35 %37 %39 %41 OpBranch %14 %14 = OpLabel %45 = OpPhi %15 %27 %13 %42 %28 OpStore %44 %45 OpReturn OpFunctionEnd )"; TEST(DiffTest, ReorderedIfBlocks) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 46 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %8 %44 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "v" OpName %44 "color" OpDecorate %8 RelaxedPrecision OpDecorate %8 Location 0 OpDecorate %9 RelaxedPrecision OpDecorate %18 RelaxedPrecision OpDecorate %19 RelaxedPrecision OpDecorate %20 RelaxedPrecision OpDecorate %23 RelaxedPrecision OpDecorate %24 RelaxedPrecision OpDecorate %25 RelaxedPrecision OpDecorate %26 RelaxedPrecision OpDecorate %27 RelaxedPrecision OpDecorate %28 RelaxedPrecision OpDecorate %29 RelaxedPrecision OpDecorate %30 RelaxedPrecision OpDecorate %31 RelaxedPrecision OpDecorate %33 RelaxedPrecision OpDecorate %34 RelaxedPrecision OpDecorate %35 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %40 RelaxedPrecision OpDecorate %41 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %44 RelaxedPrecision OpDecorate %44 Location 0 OpDecorate %45 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Input %6 %8 = OpVariable %7 Input %10 = OpConstant %6 0 %11 = OpTypeBool %15 = OpTypeVector %6 4 %16 = OpTypePointer Function %15 %21 = OpConstant %6 -0.5 %22 = OpConstant %6 -0.300000012 %38 = OpConstant %6 0.5 %43 = OpTypePointer Output %15 %44 = OpVariable %43 Output %4 = OpFunction %2 None %3 %5 = OpLabel %9 = OpLoad %6 %8 %12 = OpFOrdLessThanEqual %11 %9 %10 OpSelectionMerge %14 None OpBranchConditional %12 %13 %32 %32 = OpLabel %33 = OpLoad %6 %8 %34 = OpExtInst %6 %1 Sqrt %33 %35 = OpLoad %6 %8 %36 = OpExtInst %6 %1 FSign %35 %37 = OpLoad %6 %8 %39 = OpExtInst %6 %1 FMax %37 %38 %40 = OpLoad %6 %8 %41 = OpExtInst %6 %1 Floor %40 %42 = OpCompositeConstruct %15 %34 %36 %39 %41 OpBranch %14 %13 = OpLabel %18 = OpLoad %6 %8 %19 = OpExtInst %6 %1 Log %18 %20 = OpLoad %6 %8 %23 = OpExtInst %6 %1 FClamp %20 %21 %22 %24 = OpFMul %6 %19 %23 %25 = OpLoad %6 %8 %26 = OpExtInst %6 %1 Sin %25 %27 = OpLoad %6 %8 %28 = OpExtInst %6 %1 Cos %27 %29 = OpLoad %6 %8 %30 = OpExtInst %6 %1 Exp %29 %31 = OpCompositeConstruct %15 %24 %26 %28 %30 OpBranch %14 %14 = OpLabel -%45 = OpPhi %15 %31 %13 %42 %32 +%45 = OpPhi %15 %42 %32 %31 %13 OpStore %44 %45 OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrc, kDst, kDiff, options); } TEST(DiffTest, ReorderedIfBlocksNoDebug) { constexpr char kSrcNoDebug[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %8 %44 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %8 RelaxedPrecision OpDecorate %8 Location 0 OpDecorate %9 RelaxedPrecision OpDecorate %18 RelaxedPrecision OpDecorate %19 RelaxedPrecision OpDecorate %20 RelaxedPrecision OpDecorate %23 RelaxedPrecision OpDecorate %24 RelaxedPrecision OpDecorate %25 RelaxedPrecision OpDecorate %26 RelaxedPrecision OpDecorate %27 RelaxedPrecision OpDecorate %28 RelaxedPrecision OpDecorate %29 RelaxedPrecision OpDecorate %30 RelaxedPrecision OpDecorate %31 RelaxedPrecision OpDecorate %33 RelaxedPrecision OpDecorate %34 RelaxedPrecision OpDecorate %35 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %40 RelaxedPrecision OpDecorate %41 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %44 RelaxedPrecision OpDecorate %44 Location 0 OpDecorate %45 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Input %6 %8 = OpVariable %7 Input %10 = OpConstant %6 0 %11 = OpTypeBool %15 = OpTypeVector %6 4 %16 = OpTypePointer Function %15 %21 = OpConstant %6 -0.5 %22 = OpConstant %6 -0.300000012 %38 = OpConstant %6 0.5 %43 = OpTypePointer Output %15 %44 = OpVariable %43 Output %4 = OpFunction %2 None %3 %5 = OpLabel %9 = OpLoad %6 %8 %12 = OpFOrdLessThanEqual %11 %9 %10 OpSelectionMerge %14 None OpBranchConditional %12 %13 %32 %13 = OpLabel %18 = OpLoad %6 %8 %19 = OpExtInst %6 %1 Log %18 %20 = OpLoad %6 %8 %23 = OpExtInst %6 %1 FClamp %20 %21 %22 %24 = OpFMul %6 %19 %23 %25 = OpLoad %6 %8 %26 = OpExtInst %6 %1 Sin %25 %27 = OpLoad %6 %8 %28 = OpExtInst %6 %1 Cos %27 %29 = OpLoad %6 %8 %30 = OpExtInst %6 %1 Exp %29 %31 = OpCompositeConstruct %15 %24 %26 %28 %30 OpBranch %14 %32 = OpLabel %33 = OpLoad %6 %8 %34 = OpExtInst %6 %1 Sqrt %33 %35 = OpLoad %6 %8 %36 = OpExtInst %6 %1 FSign %35 %37 = OpLoad %6 %8 %39 = OpExtInst %6 %1 FMax %37 %38 %40 = OpLoad %6 %8 %41 = OpExtInst %6 %1 Floor %40 %42 = OpCompositeConstruct %15 %34 %36 %39 %41 OpBranch %14 %14 = OpLabel %45 = OpPhi %15 %31 %13 %42 %32 OpStore %44 %45 OpReturn OpFunctionEnd )"; constexpr char kDstNoDebug[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %8 %44 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %8 RelaxedPrecision OpDecorate %8 Location 0 OpDecorate %9 RelaxedPrecision OpDecorate %18 RelaxedPrecision OpDecorate %19 RelaxedPrecision OpDecorate %20 RelaxedPrecision OpDecorate %21 RelaxedPrecision OpDecorate %22 RelaxedPrecision OpDecorate %24 RelaxedPrecision OpDecorate %25 RelaxedPrecision OpDecorate %26 RelaxedPrecision OpDecorate %27 RelaxedPrecision OpDecorate %29 RelaxedPrecision OpDecorate %30 RelaxedPrecision OpDecorate %31 RelaxedPrecision OpDecorate %34 RelaxedPrecision OpDecorate %35 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %38 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %40 RelaxedPrecision OpDecorate %41 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %44 RelaxedPrecision OpDecorate %44 Location 0 OpDecorate %45 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Input %6 %8 = OpVariable %7 Input %10 = OpConstant %6 0 %11 = OpTypeBool %15 = OpTypeVector %6 4 %16 = OpTypePointer Function %15 %23 = OpConstant %6 0.5 %32 = OpConstant %6 -0.5 %33 = OpConstant %6 -0.300000012 %43 = OpTypePointer Output %15 %44 = OpVariable %43 Output %4 = OpFunction %2 None %3 %5 = OpLabel %9 = OpLoad %6 %8 %12 = OpFOrdLessThanEqual %11 %9 %10 OpSelectionMerge %14 None OpBranchConditional %12 %28 %13 %13 = OpLabel %18 = OpLoad %6 %8 %19 = OpExtInst %6 %1 Sqrt %18 %20 = OpLoad %6 %8 %21 = OpExtInst %6 %1 FSign %20 %22 = OpLoad %6 %8 %24 = OpExtInst %6 %1 FMax %22 %23 %25 = OpLoad %6 %8 %26 = OpExtInst %6 %1 Floor %25 %27 = OpCompositeConstruct %15 %19 %21 %24 %26 OpBranch %14 %28 = OpLabel %29 = OpLoad %6 %8 %30 = OpExtInst %6 %1 Log %29 %31 = OpLoad %6 %8 %34 = OpExtInst %6 %1 FClamp %31 %32 %33 %35 = OpFMul %6 %30 %34 %36 = OpLoad %6 %8 %37 = OpExtInst %6 %1 Sin %36 %38 = OpLoad %6 %8 %39 = OpExtInst %6 %1 Cos %38 %40 = OpLoad %6 %8 %41 = OpExtInst %6 %1 Exp %40 %42 = OpCompositeConstruct %15 %35 %37 %39 %41 OpBranch %14 %14 = OpLabel %45 = OpPhi %15 %27 %13 %42 %28 OpStore %44 %45 OpReturn OpFunctionEnd )"; constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 46 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %8 %44 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %8 RelaxedPrecision OpDecorate %8 Location 0 OpDecorate %9 RelaxedPrecision OpDecorate %18 RelaxedPrecision OpDecorate %19 RelaxedPrecision OpDecorate %20 RelaxedPrecision OpDecorate %23 RelaxedPrecision OpDecorate %24 RelaxedPrecision OpDecorate %25 RelaxedPrecision OpDecorate %26 RelaxedPrecision OpDecorate %27 RelaxedPrecision OpDecorate %28 RelaxedPrecision OpDecorate %29 RelaxedPrecision OpDecorate %30 RelaxedPrecision OpDecorate %31 RelaxedPrecision OpDecorate %33 RelaxedPrecision OpDecorate %34 RelaxedPrecision OpDecorate %35 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %40 RelaxedPrecision OpDecorate %41 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %44 RelaxedPrecision OpDecorate %44 Location 0 OpDecorate %45 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Input %6 %8 = OpVariable %7 Input %10 = OpConstant %6 0 %11 = OpTypeBool %15 = OpTypeVector %6 4 %16 = OpTypePointer Function %15 %21 = OpConstant %6 -0.5 %22 = OpConstant %6 -0.300000012 %38 = OpConstant %6 0.5 %43 = OpTypePointer Output %15 %44 = OpVariable %43 Output %4 = OpFunction %2 None %3 %5 = OpLabel %9 = OpLoad %6 %8 %12 = OpFOrdLessThanEqual %11 %9 %10 OpSelectionMerge %14 None OpBranchConditional %12 %13 %32 %32 = OpLabel %33 = OpLoad %6 %8 %34 = OpExtInst %6 %1 Sqrt %33 %35 = OpLoad %6 %8 %36 = OpExtInst %6 %1 FSign %35 %37 = OpLoad %6 %8 %39 = OpExtInst %6 %1 FMax %37 %38 %40 = OpLoad %6 %8 %41 = OpExtInst %6 %1 Floor %40 %42 = OpCompositeConstruct %15 %34 %36 %39 %41 OpBranch %14 %13 = OpLabel %18 = OpLoad %6 %8 %19 = OpExtInst %6 %1 Log %18 %20 = OpLoad %6 %8 %23 = OpExtInst %6 %1 FClamp %20 %21 %22 %24 = OpFMul %6 %19 %23 %25 = OpLoad %6 %8 %26 = OpExtInst %6 %1 Sin %25 %27 = OpLoad %6 %8 %28 = OpExtInst %6 %1 Cos %27 %29 = OpLoad %6 %8 %30 = OpExtInst %6 %1 Exp %29 %31 = OpCompositeConstruct %15 %24 %26 %28 %30 OpBranch %14 %14 = OpLabel -%45 = OpPhi %15 %31 %13 %42 %32 +%45 = OpPhi %15 %42 %32 %31 %13 OpStore %44 %45 OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrcNoDebug, kDstNoDebug, kDiff, options); } } // namespace } // namespace diff } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/reordered_if_blocks_dst.spvasm000066400000000000000000000064061475742701700306130ustar00rootroot00000000000000 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %8 %44 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "v" OpName %44 "color" OpDecorate %8 RelaxedPrecision OpDecorate %8 Location 0 OpDecorate %9 RelaxedPrecision OpDecorate %18 RelaxedPrecision OpDecorate %19 RelaxedPrecision OpDecorate %20 RelaxedPrecision OpDecorate %21 RelaxedPrecision OpDecorate %22 RelaxedPrecision OpDecorate %24 RelaxedPrecision OpDecorate %25 RelaxedPrecision OpDecorate %26 RelaxedPrecision OpDecorate %27 RelaxedPrecision OpDecorate %29 RelaxedPrecision OpDecorate %30 RelaxedPrecision OpDecorate %31 RelaxedPrecision OpDecorate %34 RelaxedPrecision OpDecorate %35 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %38 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %40 RelaxedPrecision OpDecorate %41 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %44 RelaxedPrecision OpDecorate %44 Location 0 OpDecorate %45 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Input %6 %8 = OpVariable %7 Input %10 = OpConstant %6 0 %11 = OpTypeBool %15 = OpTypeVector %6 4 %16 = OpTypePointer Function %15 %23 = OpConstant %6 0.5 %32 = OpConstant %6 -0.5 %33 = OpConstant %6 -0.300000012 %43 = OpTypePointer Output %15 %44 = OpVariable %43 Output %4 = OpFunction %2 None %3 %5 = OpLabel %9 = OpLoad %6 %8 %12 = OpFOrdLessThanEqual %11 %9 %10 OpSelectionMerge %14 None OpBranchConditional %12 %28 %13 %13 = OpLabel %18 = OpLoad %6 %8 %19 = OpExtInst %6 %1 Sqrt %18 %20 = OpLoad %6 %8 %21 = OpExtInst %6 %1 FSign %20 %22 = OpLoad %6 %8 %24 = OpExtInst %6 %1 FMax %22 %23 %25 = OpLoad %6 %8 %26 = OpExtInst %6 %1 Floor %25 %27 = OpCompositeConstruct %15 %19 %21 %24 %26 OpBranch %14 %28 = OpLabel %29 = OpLoad %6 %8 %30 = OpExtInst %6 %1 Log %29 %31 = OpLoad %6 %8 %34 = OpExtInst %6 %1 FClamp %31 %32 %33 %35 = OpFMul %6 %30 %34 %36 = OpLoad %6 %8 %37 = OpExtInst %6 %1 Sin %36 %38 = OpLoad %6 %8 %39 = OpExtInst %6 %1 Cos %38 %40 = OpLoad %6 %8 %41 = OpExtInst %6 %1 Exp %40 %42 = OpCompositeConstruct %15 %35 %37 %39 %41 OpBranch %14 %14 = OpLabel %45 = OpPhi %15 %27 %13 %42 %28 OpStore %44 %45 OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/reordered_if_blocks_src.spvasm000066400000000000000000000065221475742701700306070ustar00rootroot00000000000000;; Test where src and dst have the true and false blocks of an if reordered. OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %8 %44 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "v" OpName %44 "color" OpDecorate %8 RelaxedPrecision OpDecorate %8 Location 0 OpDecorate %9 RelaxedPrecision OpDecorate %18 RelaxedPrecision OpDecorate %19 RelaxedPrecision OpDecorate %20 RelaxedPrecision OpDecorate %23 RelaxedPrecision OpDecorate %24 RelaxedPrecision OpDecorate %25 RelaxedPrecision OpDecorate %26 RelaxedPrecision OpDecorate %27 RelaxedPrecision OpDecorate %28 RelaxedPrecision OpDecorate %29 RelaxedPrecision OpDecorate %30 RelaxedPrecision OpDecorate %31 RelaxedPrecision OpDecorate %33 RelaxedPrecision OpDecorate %34 RelaxedPrecision OpDecorate %35 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %37 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %40 RelaxedPrecision OpDecorate %41 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %44 RelaxedPrecision OpDecorate %44 Location 0 OpDecorate %45 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Input %6 %8 = OpVariable %7 Input %10 = OpConstant %6 0 %11 = OpTypeBool %15 = OpTypeVector %6 4 %16 = OpTypePointer Function %15 %21 = OpConstant %6 -0.5 %22 = OpConstant %6 -0.300000012 %38 = OpConstant %6 0.5 %43 = OpTypePointer Output %15 %44 = OpVariable %43 Output %4 = OpFunction %2 None %3 %5 = OpLabel %9 = OpLoad %6 %8 %12 = OpFOrdLessThanEqual %11 %9 %10 OpSelectionMerge %14 None OpBranchConditional %12 %13 %32 %13 = OpLabel %18 = OpLoad %6 %8 %19 = OpExtInst %6 %1 Log %18 %20 = OpLoad %6 %8 %23 = OpExtInst %6 %1 FClamp %20 %21 %22 %24 = OpFMul %6 %19 %23 %25 = OpLoad %6 %8 %26 = OpExtInst %6 %1 Sin %25 %27 = OpLoad %6 %8 %28 = OpExtInst %6 %1 Cos %27 %29 = OpLoad %6 %8 %30 = OpExtInst %6 %1 Exp %29 %31 = OpCompositeConstruct %15 %24 %26 %28 %30 OpBranch %14 %32 = OpLabel %33 = OpLoad %6 %8 %34 = OpExtInst %6 %1 Sqrt %33 %35 = OpLoad %6 %8 %36 = OpExtInst %6 %1 FSign %35 %37 = OpLoad %6 %8 %39 = OpExtInst %6 %1 FMax %37 %38 %40 = OpLoad %6 %8 %41 = OpExtInst %6 %1 Floor %40 %42 = OpCompositeConstruct %15 %34 %36 %39 %41 OpBranch %14 %14 = OpLabel %45 = OpPhi %15 %31 %13 %42 %32 OpStore %44 %45 OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/reordered_switch_blocks_autogen.cpp000066400000000000000000000424731475742701700316430ustar00rootroot00000000000000// GENERATED FILE - DO NOT EDIT. // Generated by generate_tests.py // // Copyright (c) 2022 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "../diff_test_utils.h" #include "gtest/gtest.h" namespace spvtools { namespace diff { namespace { // Test where src and dst have cases of a switch in different order. constexpr char kSrc[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpName %4 "main" OpName %7 "BufferIn" OpMemberName %7 0 "i" OpName %9 "" OpName %23 "BufferOut" OpMemberName %23 0 "o" OpName %25 "" OpMemberDecorate %7 0 Offset 0 OpDecorate %7 Block OpDecorate %9 DescriptorSet 0 OpDecorate %9 Binding 0 OpMemberDecorate %23 0 Offset 0 OpDecorate %23 BufferBlock OpDecorate %25 DescriptorSet 0 OpDecorate %25 Binding 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpTypeStruct %6 %8 = OpTypePointer Uniform %7 %9 = OpVariable %8 Uniform %10 = OpTypeInt 32 1 %11 = OpConstant %10 0 %12 = OpTypePointer Uniform %6 %23 = OpTypeStruct %6 %24 = OpTypePointer Uniform %23 %25 = OpVariable %24 Uniform %28 = OpConstant %10 1 %34 = OpConstant %6 2 %52 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %13 = OpAccessChain %12 %9 %11 %14 = OpLoad %6 %13 OpSelectionMerge %22 None OpSwitch %14 %21 0 %15 1 %16 2 %17 3 %18 4 %19 5 %20 %21 = OpLabel %54 = OpAccessChain %12 %25 %11 %55 = OpLoad %6 %54 %56 = OpIAdd %6 %55 %34 %57 = OpAccessChain %12 %25 %11 OpStore %57 %56 OpBranch %22 %15 = OpLabel %26 = OpAccessChain %12 %25 %11 %27 = OpLoad %6 %26 %29 = OpIAdd %6 %27 %28 OpStore %26 %29 OpBranch %22 %16 = OpLabel %31 = OpAccessChain %12 %25 %11 %32 = OpLoad %6 %31 %33 = OpISub %6 %32 %28 OpStore %31 %33 OpBranch %17 %17 = OpLabel %35 = OpAccessChain %12 %25 %11 %36 = OpLoad %6 %35 %37 = OpIMul %6 %36 %34 %38 = OpAccessChain %12 %25 %11 OpStore %38 %37 OpBranch %22 %18 = OpLabel %40 = OpAccessChain %12 %25 %11 %41 = OpLoad %6 %40 %42 = OpUDiv %6 %41 %34 %43 = OpAccessChain %12 %25 %11 OpStore %43 %42 OpBranch %22 %19 = OpLabel %45 = OpAccessChain %12 %25 %11 %46 = OpLoad %6 %45 %47 = OpAccessChain %12 %25 %11 %48 = OpLoad %6 %47 %49 = OpIMul %6 %46 %48 %50 = OpAccessChain %12 %25 %11 OpStore %50 %49 OpBranch %22 %20 = OpLabel %53 = OpAccessChain %12 %25 %11 OpStore %53 %52 OpBranch %21 %22 = OpLabel OpReturn OpFunctionEnd)"; constexpr char kDst[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpName %4 "main" OpName %7 "BufferIn" OpMemberName %7 0 "i" OpName %9 "" OpName %23 "BufferOut" OpMemberName %23 0 "o" OpName %25 "" OpMemberDecorate %7 0 Offset 0 OpDecorate %7 Block OpDecorate %9 DescriptorSet 0 OpDecorate %9 Binding 0 OpMemberDecorate %23 0 Offset 0 OpDecorate %23 BufferBlock OpDecorate %25 DescriptorSet 0 OpDecorate %25 Binding 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpTypeStruct %6 %8 = OpTypePointer Uniform %7 %9 = OpVariable %8 Uniform %10 = OpTypeInt 32 1 %11 = OpConstant %10 0 %12 = OpTypePointer Uniform %6 %23 = OpTypeStruct %6 %24 = OpTypePointer Uniform %23 %25 = OpVariable %24 Uniform %28 = OpConstant %10 1 %34 = OpConstant %6 2 %52 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %13 = OpAccessChain %12 %9 %11 %14 = OpLoad %6 %13 OpSelectionMerge %22 None OpSwitch %14 %21 0 %15 1 %16 2 %17 3 %18 4 %19 5 %20 %17 = OpLabel %35 = OpAccessChain %12 %25 %11 %36 = OpLoad %6 %35 %37 = OpIMul %6 %36 %34 %38 = OpAccessChain %12 %25 %11 OpStore %38 %37 OpBranch %22 %18 = OpLabel %40 = OpAccessChain %12 %25 %11 %41 = OpLoad %6 %40 %42 = OpUDiv %6 %41 %34 %43 = OpAccessChain %12 %25 %11 OpStore %43 %42 OpBranch %22 %21 = OpLabel %54 = OpAccessChain %12 %25 %11 %55 = OpLoad %6 %54 %56 = OpIAdd %6 %55 %34 %57 = OpAccessChain %12 %25 %11 OpStore %57 %56 OpBranch %22 %20 = OpLabel %53 = OpAccessChain %12 %25 %11 OpStore %53 %52 OpBranch %21 %15 = OpLabel %26 = OpAccessChain %12 %25 %11 %27 = OpLoad %6 %26 %29 = OpIAdd %6 %27 %28 OpStore %26 %29 OpBranch %22 %19 = OpLabel %45 = OpAccessChain %12 %25 %11 %46 = OpLoad %6 %45 %47 = OpAccessChain %12 %25 %11 %48 = OpLoad %6 %47 %49 = OpIMul %6 %46 %48 %50 = OpAccessChain %12 %25 %11 OpStore %50 %49 OpBranch %22 %16 = OpLabel %31 = OpAccessChain %12 %25 %11 %32 = OpLoad %6 %31 %33 = OpISub %6 %32 %28 OpStore %31 %33 OpBranch %17 %22 = OpLabel OpReturn OpFunctionEnd )"; TEST(DiffTest, ReorderedSwitchBlocks) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 58 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpName %4 "main" OpName %7 "BufferIn" OpMemberName %7 0 "i" OpName %9 "" OpName %23 "BufferOut" OpMemberName %23 0 "o" OpName %25 "" OpMemberDecorate %7 0 Offset 0 OpDecorate %7 Block OpDecorate %9 DescriptorSet 0 OpDecorate %9 Binding 0 OpMemberDecorate %23 0 Offset 0 OpDecorate %23 BufferBlock OpDecorate %25 DescriptorSet 0 OpDecorate %25 Binding 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpTypeStruct %6 %8 = OpTypePointer Uniform %7 %9 = OpVariable %8 Uniform %10 = OpTypeInt 32 1 %11 = OpConstant %10 0 %12 = OpTypePointer Uniform %6 %23 = OpTypeStruct %6 %24 = OpTypePointer Uniform %23 %25 = OpVariable %24 Uniform %28 = OpConstant %10 1 %34 = OpConstant %6 2 %52 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %13 = OpAccessChain %12 %9 %11 %14 = OpLoad %6 %13 OpSelectionMerge %22 None OpSwitch %14 %21 0 %15 1 %16 2 %17 3 %18 4 %19 5 %20 %20 = OpLabel %53 = OpAccessChain %12 %25 %11 OpStore %53 %52 OpBranch %21 %19 = OpLabel %45 = OpAccessChain %12 %25 %11 %46 = OpLoad %6 %45 %47 = OpAccessChain %12 %25 %11 %48 = OpLoad %6 %47 %49 = OpIMul %6 %46 %48 %50 = OpAccessChain %12 %25 %11 OpStore %50 %49 OpBranch %22 %18 = OpLabel %40 = OpAccessChain %12 %25 %11 %41 = OpLoad %6 %40 %42 = OpUDiv %6 %41 %34 %43 = OpAccessChain %12 %25 %11 OpStore %43 %42 OpBranch %22 %16 = OpLabel %31 = OpAccessChain %12 %25 %11 %32 = OpLoad %6 %31 %33 = OpISub %6 %32 %28 OpStore %31 %33 OpBranch %17 %17 = OpLabel %35 = OpAccessChain %12 %25 %11 %36 = OpLoad %6 %35 %37 = OpIMul %6 %36 %34 %38 = OpAccessChain %12 %25 %11 OpStore %38 %37 OpBranch %22 %15 = OpLabel %26 = OpAccessChain %12 %25 %11 %27 = OpLoad %6 %26 %29 = OpIAdd %6 %27 %28 OpStore %26 %29 OpBranch %22 %21 = OpLabel %54 = OpAccessChain %12 %25 %11 %55 = OpLoad %6 %54 %56 = OpIAdd %6 %55 %34 %57 = OpAccessChain %12 %25 %11 OpStore %57 %56 OpBranch %22 %22 = OpLabel OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrc, kDst, kDiff, options); } TEST(DiffTest, ReorderedSwitchBlocksNoDebug) { constexpr char kSrcNoDebug[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpMemberDecorate %7 0 Offset 0 OpDecorate %7 Block OpDecorate %9 DescriptorSet 0 OpDecorate %9 Binding 0 OpMemberDecorate %23 0 Offset 0 OpDecorate %23 BufferBlock OpDecorate %25 DescriptorSet 0 OpDecorate %25 Binding 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpTypeStruct %6 %8 = OpTypePointer Uniform %7 %9 = OpVariable %8 Uniform %10 = OpTypeInt 32 1 %11 = OpConstant %10 0 %12 = OpTypePointer Uniform %6 %23 = OpTypeStruct %6 %24 = OpTypePointer Uniform %23 %25 = OpVariable %24 Uniform %28 = OpConstant %10 1 %34 = OpConstant %6 2 %52 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %13 = OpAccessChain %12 %9 %11 %14 = OpLoad %6 %13 OpSelectionMerge %22 None OpSwitch %14 %21 0 %15 1 %16 2 %17 3 %18 4 %19 5 %20 %21 = OpLabel %54 = OpAccessChain %12 %25 %11 %55 = OpLoad %6 %54 %56 = OpIAdd %6 %55 %34 %57 = OpAccessChain %12 %25 %11 OpStore %57 %56 OpBranch %22 %15 = OpLabel %26 = OpAccessChain %12 %25 %11 %27 = OpLoad %6 %26 %29 = OpIAdd %6 %27 %28 OpStore %26 %29 OpBranch %22 %16 = OpLabel %31 = OpAccessChain %12 %25 %11 %32 = OpLoad %6 %31 %33 = OpISub %6 %32 %28 OpStore %31 %33 OpBranch %17 %17 = OpLabel %35 = OpAccessChain %12 %25 %11 %36 = OpLoad %6 %35 %37 = OpIMul %6 %36 %34 %38 = OpAccessChain %12 %25 %11 OpStore %38 %37 OpBranch %22 %18 = OpLabel %40 = OpAccessChain %12 %25 %11 %41 = OpLoad %6 %40 %42 = OpUDiv %6 %41 %34 %43 = OpAccessChain %12 %25 %11 OpStore %43 %42 OpBranch %22 %19 = OpLabel %45 = OpAccessChain %12 %25 %11 %46 = OpLoad %6 %45 %47 = OpAccessChain %12 %25 %11 %48 = OpLoad %6 %47 %49 = OpIMul %6 %46 %48 %50 = OpAccessChain %12 %25 %11 OpStore %50 %49 OpBranch %22 %20 = OpLabel %53 = OpAccessChain %12 %25 %11 OpStore %53 %52 OpBranch %21 %22 = OpLabel OpReturn OpFunctionEnd )"; constexpr char kDstNoDebug[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpMemberDecorate %7 0 Offset 0 OpDecorate %7 Block OpDecorate %9 DescriptorSet 0 OpDecorate %9 Binding 0 OpMemberDecorate %23 0 Offset 0 OpDecorate %23 BufferBlock OpDecorate %25 DescriptorSet 0 OpDecorate %25 Binding 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpTypeStruct %6 %8 = OpTypePointer Uniform %7 %9 = OpVariable %8 Uniform %10 = OpTypeInt 32 1 %11 = OpConstant %10 0 %12 = OpTypePointer Uniform %6 %23 = OpTypeStruct %6 %24 = OpTypePointer Uniform %23 %25 = OpVariable %24 Uniform %28 = OpConstant %10 1 %34 = OpConstant %6 2 %52 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %13 = OpAccessChain %12 %9 %11 %14 = OpLoad %6 %13 OpSelectionMerge %22 None OpSwitch %14 %21 0 %15 1 %16 2 %17 3 %18 4 %19 5 %20 %17 = OpLabel %35 = OpAccessChain %12 %25 %11 %36 = OpLoad %6 %35 %37 = OpIMul %6 %36 %34 %38 = OpAccessChain %12 %25 %11 OpStore %38 %37 OpBranch %22 %18 = OpLabel %40 = OpAccessChain %12 %25 %11 %41 = OpLoad %6 %40 %42 = OpUDiv %6 %41 %34 %43 = OpAccessChain %12 %25 %11 OpStore %43 %42 OpBranch %22 %21 = OpLabel %54 = OpAccessChain %12 %25 %11 %55 = OpLoad %6 %54 %56 = OpIAdd %6 %55 %34 %57 = OpAccessChain %12 %25 %11 OpStore %57 %56 OpBranch %22 %20 = OpLabel %53 = OpAccessChain %12 %25 %11 OpStore %53 %52 OpBranch %21 %15 = OpLabel %26 = OpAccessChain %12 %25 %11 %27 = OpLoad %6 %26 %29 = OpIAdd %6 %27 %28 OpStore %26 %29 OpBranch %22 %19 = OpLabel %45 = OpAccessChain %12 %25 %11 %46 = OpLoad %6 %45 %47 = OpAccessChain %12 %25 %11 %48 = OpLoad %6 %47 %49 = OpIMul %6 %46 %48 %50 = OpAccessChain %12 %25 %11 OpStore %50 %49 OpBranch %22 %16 = OpLabel %31 = OpAccessChain %12 %25 %11 %32 = OpLoad %6 %31 %33 = OpISub %6 %32 %28 OpStore %31 %33 OpBranch %17 %22 = OpLabel OpReturn OpFunctionEnd )"; constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 58 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpMemberDecorate %7 0 Offset 0 OpDecorate %7 Block OpDecorate %9 DescriptorSet 0 OpDecorate %9 Binding 0 OpMemberDecorate %23 0 Offset 0 OpDecorate %23 BufferBlock OpDecorate %25 DescriptorSet 0 OpDecorate %25 Binding 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpTypeStruct %6 %8 = OpTypePointer Uniform %7 %9 = OpVariable %8 Uniform %10 = OpTypeInt 32 1 %11 = OpConstant %10 0 %12 = OpTypePointer Uniform %6 %23 = OpTypeStruct %6 %24 = OpTypePointer Uniform %23 %25 = OpVariable %24 Uniform %28 = OpConstant %10 1 %34 = OpConstant %6 2 %52 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %13 = OpAccessChain %12 %9 %11 %14 = OpLoad %6 %13 OpSelectionMerge %22 None OpSwitch %14 %21 0 %15 1 %16 2 %17 3 %18 4 %19 5 %20 %20 = OpLabel %53 = OpAccessChain %12 %25 %11 OpStore %53 %52 OpBranch %21 %19 = OpLabel %45 = OpAccessChain %12 %25 %11 %46 = OpLoad %6 %45 %47 = OpAccessChain %12 %25 %11 %48 = OpLoad %6 %47 %49 = OpIMul %6 %46 %48 %50 = OpAccessChain %12 %25 %11 OpStore %50 %49 OpBranch %22 %18 = OpLabel %40 = OpAccessChain %12 %25 %11 %41 = OpLoad %6 %40 %42 = OpUDiv %6 %41 %34 %43 = OpAccessChain %12 %25 %11 OpStore %43 %42 OpBranch %22 %16 = OpLabel %31 = OpAccessChain %12 %25 %11 %32 = OpLoad %6 %31 %33 = OpISub %6 %32 %28 OpStore %31 %33 OpBranch %17 %17 = OpLabel %35 = OpAccessChain %12 %25 %11 %36 = OpLoad %6 %35 %37 = OpIMul %6 %36 %34 %38 = OpAccessChain %12 %25 %11 OpStore %38 %37 OpBranch %22 %15 = OpLabel %26 = OpAccessChain %12 %25 %11 %27 = OpLoad %6 %26 %29 = OpIAdd %6 %27 %28 OpStore %26 %29 OpBranch %22 %21 = OpLabel %54 = OpAccessChain %12 %25 %11 %55 = OpLoad %6 %54 %56 = OpIAdd %6 %55 %34 %57 = OpAccessChain %12 %25 %11 OpStore %57 %56 OpBranch %22 %22 = OpLabel OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrcNoDebug, kDstNoDebug, kDiff, options); } } // namespace } // namespace diff } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/reordered_switch_blocks_dst.spvasm000066400000000000000000000060571475742701700315200ustar00rootroot00000000000000 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpName %4 "main" OpName %7 "BufferIn" OpMemberName %7 0 "i" OpName %9 "" OpName %23 "BufferOut" OpMemberName %23 0 "o" OpName %25 "" OpMemberDecorate %7 0 Offset 0 OpDecorate %7 Block OpDecorate %9 DescriptorSet 0 OpDecorate %9 Binding 0 OpMemberDecorate %23 0 Offset 0 OpDecorate %23 BufferBlock OpDecorate %25 DescriptorSet 0 OpDecorate %25 Binding 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpTypeStruct %6 %8 = OpTypePointer Uniform %7 %9 = OpVariable %8 Uniform %10 = OpTypeInt 32 1 %11 = OpConstant %10 0 %12 = OpTypePointer Uniform %6 %23 = OpTypeStruct %6 %24 = OpTypePointer Uniform %23 %25 = OpVariable %24 Uniform %28 = OpConstant %10 1 %34 = OpConstant %6 2 %52 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %13 = OpAccessChain %12 %9 %11 %14 = OpLoad %6 %13 OpSelectionMerge %22 None OpSwitch %14 %21 0 %15 1 %16 2 %17 3 %18 4 %19 5 %20 %17 = OpLabel %35 = OpAccessChain %12 %25 %11 %36 = OpLoad %6 %35 %37 = OpIMul %6 %36 %34 %38 = OpAccessChain %12 %25 %11 OpStore %38 %37 OpBranch %22 %18 = OpLabel %40 = OpAccessChain %12 %25 %11 %41 = OpLoad %6 %40 %42 = OpUDiv %6 %41 %34 %43 = OpAccessChain %12 %25 %11 OpStore %43 %42 OpBranch %22 %21 = OpLabel %54 = OpAccessChain %12 %25 %11 %55 = OpLoad %6 %54 %56 = OpIAdd %6 %55 %34 %57 = OpAccessChain %12 %25 %11 OpStore %57 %56 OpBranch %22 %20 = OpLabel %53 = OpAccessChain %12 %25 %11 OpStore %53 %52 OpBranch %21 %15 = OpLabel %26 = OpAccessChain %12 %25 %11 %27 = OpLoad %6 %26 %29 = OpIAdd %6 %27 %28 OpStore %26 %29 OpBranch %22 %19 = OpLabel %45 = OpAccessChain %12 %25 %11 %46 = OpLoad %6 %45 %47 = OpAccessChain %12 %25 %11 %48 = OpLoad %6 %47 %49 = OpIMul %6 %46 %48 %50 = OpAccessChain %12 %25 %11 OpStore %50 %49 OpBranch %22 %16 = OpLabel %31 = OpAccessChain %12 %25 %11 %32 = OpLoad %6 %31 %33 = OpISub %6 %32 %28 OpStore %31 %33 OpBranch %17 %22 = OpLabel OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/reordered_switch_blocks_src.spvasm000066400000000000000000000061641475742701700315140ustar00rootroot00000000000000;; Test where src and dst have cases of a switch in different order. OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpName %4 "main" OpName %7 "BufferIn" OpMemberName %7 0 "i" OpName %9 "" OpName %23 "BufferOut" OpMemberName %23 0 "o" OpName %25 "" OpMemberDecorate %7 0 Offset 0 OpDecorate %7 Block OpDecorate %9 DescriptorSet 0 OpDecorate %9 Binding 0 OpMemberDecorate %23 0 Offset 0 OpDecorate %23 BufferBlock OpDecorate %25 DescriptorSet 0 OpDecorate %25 Binding 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpTypeStruct %6 %8 = OpTypePointer Uniform %7 %9 = OpVariable %8 Uniform %10 = OpTypeInt 32 1 %11 = OpConstant %10 0 %12 = OpTypePointer Uniform %6 %23 = OpTypeStruct %6 %24 = OpTypePointer Uniform %23 %25 = OpVariable %24 Uniform %28 = OpConstant %10 1 %34 = OpConstant %6 2 %52 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %13 = OpAccessChain %12 %9 %11 %14 = OpLoad %6 %13 OpSelectionMerge %22 None OpSwitch %14 %21 0 %15 1 %16 2 %17 3 %18 4 %19 5 %20 %21 = OpLabel %54 = OpAccessChain %12 %25 %11 %55 = OpLoad %6 %54 %56 = OpIAdd %6 %55 %34 %57 = OpAccessChain %12 %25 %11 OpStore %57 %56 OpBranch %22 %15 = OpLabel %26 = OpAccessChain %12 %25 %11 %27 = OpLoad %6 %26 %29 = OpIAdd %6 %27 %28 OpStore %26 %29 OpBranch %22 %16 = OpLabel %31 = OpAccessChain %12 %25 %11 %32 = OpLoad %6 %31 %33 = OpISub %6 %32 %28 OpStore %31 %33 OpBranch %17 %17 = OpLabel %35 = OpAccessChain %12 %25 %11 %36 = OpLoad %6 %35 %37 = OpIMul %6 %36 %34 %38 = OpAccessChain %12 %25 %11 OpStore %38 %37 OpBranch %22 %18 = OpLabel %40 = OpAccessChain %12 %25 %11 %41 = OpLoad %6 %40 %42 = OpUDiv %6 %41 %34 %43 = OpAccessChain %12 %25 %11 OpStore %43 %42 OpBranch %22 %19 = OpLabel %45 = OpAccessChain %12 %25 %11 %46 = OpLoad %6 %45 %47 = OpAccessChain %12 %25 %11 %48 = OpLoad %6 %47 %49 = OpIMul %6 %46 %48 %50 = OpAccessChain %12 %25 %11 OpStore %50 %49 OpBranch %22 %20 = OpLabel %53 = OpAccessChain %12 %25 %11 OpStore %53 %52 OpBranch %21 %22 = OpLabel OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/small_functions_small_diffs_autogen.cpp000066400000000000000000000515351475742701700325140ustar00rootroot00000000000000// GENERATED FILE - DO NOT EDIT. // Generated by generate_tests.py // // Copyright (c) 2022 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "../diff_test_utils.h" #include "gtest/gtest.h" namespace spvtools { namespace diff { namespace { // Test where src and dst have many small functions with small differences. constexpr char kSrc[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpName %4 "main" OpName %6 "f1(" OpName %8 "f2(" OpName %10 "f3(" OpName %12 "f4(" OpName %14 "f5(" OpName %17 "BufferOut" OpMemberName %17 0 "o" OpName %19 "" OpName %22 "BufferIn" OpMemberName %22 0 "i" OpName %24 "" OpMemberDecorate %17 0 Offset 0 OpDecorate %17 BufferBlock OpDecorate %19 DescriptorSet 0 OpDecorate %19 Binding 1 OpMemberDecorate %22 0 Offset 0 OpDecorate %22 Block OpDecorate %24 DescriptorSet 0 OpDecorate %24 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %16 = OpTypeInt 32 0 %17 = OpTypeStruct %16 %18 = OpTypePointer Uniform %17 %19 = OpVariable %18 Uniform %20 = OpTypeInt 32 1 %21 = OpConstant %20 0 %22 = OpTypeStruct %16 %23 = OpTypePointer Uniform %22 %24 = OpVariable %23 Uniform %25 = OpTypePointer Uniform %16 %31 = OpConstant %20 1 %36 = OpConstant %16 2 %4 = OpFunction %2 None %3 %5 = OpLabel %45 = OpFunctionCall %2 %6 %46 = OpFunctionCall %2 %8 %47 = OpFunctionCall %2 %10 %48 = OpFunctionCall %2 %12 %49 = OpFunctionCall %2 %14 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %26 = OpAccessChain %25 %24 %21 %27 = OpLoad %16 %26 %28 = OpAccessChain %25 %19 %21 OpStore %28 %27 OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %29 = OpAccessChain %25 %19 %21 %30 = OpLoad %16 %29 %32 = OpIAdd %16 %30 %31 OpStore %29 %32 OpReturn OpFunctionEnd %10 = OpFunction %2 None %3 %11 = OpLabel %33 = OpAccessChain %25 %19 %21 %34 = OpLoad %16 %33 %35 = OpISub %16 %34 %31 OpStore %33 %35 OpReturn OpFunctionEnd %12 = OpFunction %2 None %3 %13 = OpLabel %37 = OpAccessChain %25 %19 %21 %38 = OpLoad %16 %37 %39 = OpIMul %16 %38 %36 %40 = OpAccessChain %25 %19 %21 OpStore %40 %39 OpReturn OpFunctionEnd %14 = OpFunction %2 None %3 %15 = OpLabel %41 = OpAccessChain %25 %19 %21 %42 = OpLoad %16 %41 %43 = OpUDiv %16 %42 %36 %44 = OpAccessChain %25 %19 %21 OpStore %44 %43 OpReturn OpFunctionEnd )"; constexpr char kDst[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpName %4 "main" OpName %6 "f1(" OpName %8 "f2(" OpName %10 "f3(" OpName %12 "f4(" OpName %14 "f5(" OpName %17 "BufferOut" OpMemberName %17 0 "o" OpName %19 "" OpName %22 "BufferIn" OpMemberName %22 0 "i" OpName %24 "" OpMemberDecorate %17 0 Offset 0 OpDecorate %17 BufferBlock OpDecorate %19 DescriptorSet 0 OpDecorate %19 Binding 1 OpMemberDecorate %22 0 Offset 0 OpDecorate %22 Block OpDecorate %24 DescriptorSet 0 OpDecorate %24 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %16 = OpTypeInt 32 0 %17 = OpTypeStruct %16 %18 = OpTypePointer Uniform %17 %19 = OpVariable %18 Uniform %20 = OpTypeInt 32 1 %21 = OpConstant %20 0 %22 = OpTypeStruct %16 %23 = OpTypePointer Uniform %22 %24 = OpVariable %23 Uniform %25 = OpTypePointer Uniform %16 %31 = OpConstant %20 1 %36 = OpConstant %16 2 %6 = OpFunction %2 None %3 %7 = OpLabel %26 = OpAccessChain %25 %24 %21 %27 = OpLoad %16 %26 %28 = OpAccessChain %25 %19 %21 OpStore %28 %27 OpReturn OpFunctionEnd %14 = OpFunction %2 None %3 %15 = OpLabel %41 = OpAccessChain %25 %19 %21 %42 = OpLoad %16 %41 %43 = OpIAdd %16 %42 %36 %44 = OpAccessChain %25 %19 %21 OpStore %44 %43 OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %29 = OpAccessChain %25 %19 %21 %30 = OpLoad %16 %29 %32 = OpISub %16 %30 %31 OpStore %29 %32 OpReturn OpFunctionEnd %10 = OpFunction %2 None %3 %11 = OpLabel %33 = OpAccessChain %25 %19 %21 %34 = OpLoad %16 %33 %35 = OpIAdd %16 %34 %31 OpStore %33 %35 OpReturn OpFunctionEnd %4 = OpFunction %2 None %3 %5 = OpLabel %45 = OpFunctionCall %2 %6 %46 = OpFunctionCall %2 %8 %47 = OpFunctionCall %2 %10 %48 = OpFunctionCall %2 %12 %49 = OpFunctionCall %2 %14 OpReturn OpFunctionEnd %12 = OpFunction %2 None %3 %13 = OpLabel %37 = OpAccessChain %25 %19 %21 %38 = OpLoad %16 %37 %39 = OpISub %16 %38 %36 %40 = OpAccessChain %25 %19 %21 OpStore %40 %39 OpReturn OpFunctionEnd )"; TEST(DiffTest, SmallFunctionsSmallDiffs) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 50 +; Bound: 54 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpName %4 "main" OpName %6 "f1(" OpName %8 "f2(" OpName %10 "f3(" OpName %12 "f4(" OpName %14 "f5(" OpName %17 "BufferOut" OpMemberName %17 0 "o" OpName %19 "" OpName %22 "BufferIn" OpMemberName %22 0 "i" OpName %24 "" OpMemberDecorate %17 0 Offset 0 OpDecorate %17 BufferBlock OpDecorate %19 DescriptorSet 0 OpDecorate %19 Binding 1 OpMemberDecorate %22 0 Offset 0 OpDecorate %22 Block OpDecorate %24 DescriptorSet 0 OpDecorate %24 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %16 = OpTypeInt 32 0 %17 = OpTypeStruct %16 %18 = OpTypePointer Uniform %17 %19 = OpVariable %18 Uniform %20 = OpTypeInt 32 1 %21 = OpConstant %20 0 %22 = OpTypeStruct %16 %23 = OpTypePointer Uniform %22 %24 = OpVariable %23 Uniform %25 = OpTypePointer Uniform %16 %31 = OpConstant %20 1 %36 = OpConstant %16 2 %4 = OpFunction %2 None %3 %5 = OpLabel %45 = OpFunctionCall %2 %6 %46 = OpFunctionCall %2 %8 %47 = OpFunctionCall %2 %10 %48 = OpFunctionCall %2 %12 %49 = OpFunctionCall %2 %14 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %26 = OpAccessChain %25 %24 %21 %27 = OpLoad %16 %26 %28 = OpAccessChain %25 %19 %21 OpStore %28 %27 OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %29 = OpAccessChain %25 %19 %21 %30 = OpLoad %16 %29 -%32 = OpIAdd %16 %30 %31 +%50 = OpISub %16 %30 %31 -OpStore %29 %32 +OpStore %29 %50 OpReturn OpFunctionEnd %10 = OpFunction %2 None %3 %11 = OpLabel %33 = OpAccessChain %25 %19 %21 %34 = OpLoad %16 %33 -%35 = OpISub %16 %34 %31 +%51 = OpIAdd %16 %34 %31 -OpStore %33 %35 +OpStore %33 %51 OpReturn OpFunctionEnd %12 = OpFunction %2 None %3 %13 = OpLabel %37 = OpAccessChain %25 %19 %21 %38 = OpLoad %16 %37 -%39 = OpIMul %16 %38 %36 +%52 = OpISub %16 %38 %36 %40 = OpAccessChain %25 %19 %21 -OpStore %40 %39 +OpStore %40 %52 OpReturn OpFunctionEnd %14 = OpFunction %2 None %3 %15 = OpLabel %41 = OpAccessChain %25 %19 %21 %42 = OpLoad %16 %41 -%43 = OpUDiv %16 %42 %36 +%53 = OpIAdd %16 %42 %36 %44 = OpAccessChain %25 %19 %21 -OpStore %44 %43 +OpStore %44 %53 OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrc, kDst, kDiff, options); } TEST(DiffTest, SmallFunctionsSmallDiffsNoDebug) { constexpr char kSrcNoDebug[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpMemberDecorate %17 0 Offset 0 OpDecorate %17 BufferBlock OpDecorate %19 DescriptorSet 0 OpDecorate %19 Binding 1 OpMemberDecorate %22 0 Offset 0 OpDecorate %22 Block OpDecorate %24 DescriptorSet 0 OpDecorate %24 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %16 = OpTypeInt 32 0 %17 = OpTypeStruct %16 %18 = OpTypePointer Uniform %17 %19 = OpVariable %18 Uniform %20 = OpTypeInt 32 1 %21 = OpConstant %20 0 %22 = OpTypeStruct %16 %23 = OpTypePointer Uniform %22 %24 = OpVariable %23 Uniform %25 = OpTypePointer Uniform %16 %31 = OpConstant %20 1 %36 = OpConstant %16 2 %4 = OpFunction %2 None %3 %5 = OpLabel %45 = OpFunctionCall %2 %6 %46 = OpFunctionCall %2 %8 %47 = OpFunctionCall %2 %10 %48 = OpFunctionCall %2 %12 %49 = OpFunctionCall %2 %14 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %26 = OpAccessChain %25 %24 %21 %27 = OpLoad %16 %26 %28 = OpAccessChain %25 %19 %21 OpStore %28 %27 OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %29 = OpAccessChain %25 %19 %21 %30 = OpLoad %16 %29 %32 = OpIAdd %16 %30 %31 OpStore %29 %32 OpReturn OpFunctionEnd %10 = OpFunction %2 None %3 %11 = OpLabel %33 = OpAccessChain %25 %19 %21 %34 = OpLoad %16 %33 %35 = OpISub %16 %34 %31 OpStore %33 %35 OpReturn OpFunctionEnd %12 = OpFunction %2 None %3 %13 = OpLabel %37 = OpAccessChain %25 %19 %21 %38 = OpLoad %16 %37 %39 = OpIMul %16 %38 %36 %40 = OpAccessChain %25 %19 %21 OpStore %40 %39 OpReturn OpFunctionEnd %14 = OpFunction %2 None %3 %15 = OpLabel %41 = OpAccessChain %25 %19 %21 %42 = OpLoad %16 %41 %43 = OpUDiv %16 %42 %36 %44 = OpAccessChain %25 %19 %21 OpStore %44 %43 OpReturn OpFunctionEnd )"; constexpr char kDstNoDebug[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpMemberDecorate %17 0 Offset 0 OpDecorate %17 BufferBlock OpDecorate %19 DescriptorSet 0 OpDecorate %19 Binding 1 OpMemberDecorate %22 0 Offset 0 OpDecorate %22 Block OpDecorate %24 DescriptorSet 0 OpDecorate %24 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %16 = OpTypeInt 32 0 %17 = OpTypeStruct %16 %18 = OpTypePointer Uniform %17 %19 = OpVariable %18 Uniform %20 = OpTypeInt 32 1 %21 = OpConstant %20 0 %22 = OpTypeStruct %16 %23 = OpTypePointer Uniform %22 %24 = OpVariable %23 Uniform %25 = OpTypePointer Uniform %16 %31 = OpConstant %20 1 %36 = OpConstant %16 2 %6 = OpFunction %2 None %3 %7 = OpLabel %26 = OpAccessChain %25 %24 %21 %27 = OpLoad %16 %26 %28 = OpAccessChain %25 %19 %21 OpStore %28 %27 OpReturn OpFunctionEnd %14 = OpFunction %2 None %3 %15 = OpLabel %41 = OpAccessChain %25 %19 %21 %42 = OpLoad %16 %41 %43 = OpIAdd %16 %42 %36 %44 = OpAccessChain %25 %19 %21 OpStore %44 %43 OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %29 = OpAccessChain %25 %19 %21 %30 = OpLoad %16 %29 %32 = OpISub %16 %30 %31 OpStore %29 %32 OpReturn OpFunctionEnd %10 = OpFunction %2 None %3 %11 = OpLabel %33 = OpAccessChain %25 %19 %21 %34 = OpLoad %16 %33 %35 = OpIAdd %16 %34 %31 OpStore %33 %35 OpReturn OpFunctionEnd %4 = OpFunction %2 None %3 %5 = OpLabel %45 = OpFunctionCall %2 %6 %46 = OpFunctionCall %2 %8 %47 = OpFunctionCall %2 %10 %48 = OpFunctionCall %2 %12 %49 = OpFunctionCall %2 %14 OpReturn OpFunctionEnd %12 = OpFunction %2 None %3 %13 = OpLabel %37 = OpAccessChain %25 %19 %21 %38 = OpLoad %16 %37 %39 = OpISub %16 %38 %36 %40 = OpAccessChain %25 %19 %21 OpStore %40 %39 OpReturn OpFunctionEnd )"; constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 50 +; Bound: 52 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpMemberDecorate %17 0 Offset 0 OpDecorate %17 BufferBlock OpDecorate %19 DescriptorSet 0 OpDecorate %19 Binding 1 OpMemberDecorate %22 0 Offset 0 OpDecorate %22 Block OpDecorate %24 DescriptorSet 0 OpDecorate %24 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %16 = OpTypeInt 32 0 %17 = OpTypeStruct %16 %18 = OpTypePointer Uniform %17 %19 = OpVariable %18 Uniform %20 = OpTypeInt 32 1 %21 = OpConstant %20 0 %22 = OpTypeStruct %16 %23 = OpTypePointer Uniform %22 %24 = OpVariable %23 Uniform %25 = OpTypePointer Uniform %16 %31 = OpConstant %20 1 %36 = OpConstant %16 2 %4 = OpFunction %2 None %3 %5 = OpLabel %45 = OpFunctionCall %2 %6 -%46 = OpFunctionCall %2 %8 +%46 = OpFunctionCall %2 %10 -%47 = OpFunctionCall %2 %10 +%47 = OpFunctionCall %2 %8 %48 = OpFunctionCall %2 %12 %49 = OpFunctionCall %2 %14 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %26 = OpAccessChain %25 %24 %21 %27 = OpLoad %16 %26 %28 = OpAccessChain %25 %19 %21 OpStore %28 %27 OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %29 = OpAccessChain %25 %19 %21 %30 = OpLoad %16 %29 %32 = OpIAdd %16 %30 %31 OpStore %29 %32 OpReturn OpFunctionEnd %10 = OpFunction %2 None %3 %11 = OpLabel %33 = OpAccessChain %25 %19 %21 %34 = OpLoad %16 %33 %35 = OpISub %16 %34 %31 OpStore %33 %35 OpReturn OpFunctionEnd %12 = OpFunction %2 None %3 %13 = OpLabel %37 = OpAccessChain %25 %19 %21 %38 = OpLoad %16 %37 -%39 = OpIMul %16 %38 %36 +%50 = OpISub %16 %38 %36 %40 = OpAccessChain %25 %19 %21 -OpStore %40 %39 +OpStore %40 %50 OpReturn OpFunctionEnd %14 = OpFunction %2 None %3 %15 = OpLabel %41 = OpAccessChain %25 %19 %21 %42 = OpLoad %16 %41 -%43 = OpUDiv %16 %42 %36 +%51 = OpIAdd %16 %42 %36 %44 = OpAccessChain %25 %19 %21 -OpStore %44 %43 +OpStore %44 %51 OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrcNoDebug, kDstNoDebug, kDiff, options); } TEST(DiffTest, SmallFunctionsSmallDiffsDumpIds) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 50 +; Bound: 54 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpName %4 "main" OpName %6 "f1(" OpName %8 "f2(" OpName %10 "f3(" OpName %12 "f4(" OpName %14 "f5(" OpName %17 "BufferOut" OpMemberName %17 0 "o" OpName %19 "" OpName %22 "BufferIn" OpMemberName %22 0 "i" OpName %24 "" OpMemberDecorate %17 0 Offset 0 OpDecorate %17 BufferBlock OpDecorate %19 DescriptorSet 0 OpDecorate %19 Binding 1 OpMemberDecorate %22 0 Offset 0 OpDecorate %22 Block OpDecorate %24 DescriptorSet 0 OpDecorate %24 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %16 = OpTypeInt 32 0 %17 = OpTypeStruct %16 %18 = OpTypePointer Uniform %17 %19 = OpVariable %18 Uniform %20 = OpTypeInt 32 1 %21 = OpConstant %20 0 %22 = OpTypeStruct %16 %23 = OpTypePointer Uniform %22 %24 = OpVariable %23 Uniform %25 = OpTypePointer Uniform %16 %31 = OpConstant %20 1 %36 = OpConstant %16 2 %4 = OpFunction %2 None %3 %5 = OpLabel %45 = OpFunctionCall %2 %6 %46 = OpFunctionCall %2 %8 %47 = OpFunctionCall %2 %10 %48 = OpFunctionCall %2 %12 %49 = OpFunctionCall %2 %14 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %26 = OpAccessChain %25 %24 %21 %27 = OpLoad %16 %26 %28 = OpAccessChain %25 %19 %21 OpStore %28 %27 OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %29 = OpAccessChain %25 %19 %21 %30 = OpLoad %16 %29 -%32 = OpIAdd %16 %30 %31 +%50 = OpISub %16 %30 %31 -OpStore %29 %32 +OpStore %29 %50 OpReturn OpFunctionEnd %10 = OpFunction %2 None %3 %11 = OpLabel %33 = OpAccessChain %25 %19 %21 %34 = OpLoad %16 %33 -%35 = OpISub %16 %34 %31 +%51 = OpIAdd %16 %34 %31 -OpStore %33 %35 +OpStore %33 %51 OpReturn OpFunctionEnd %12 = OpFunction %2 None %3 %13 = OpLabel %37 = OpAccessChain %25 %19 %21 %38 = OpLoad %16 %37 -%39 = OpIMul %16 %38 %36 +%52 = OpISub %16 %38 %36 %40 = OpAccessChain %25 %19 %21 -OpStore %40 %39 +OpStore %40 %52 OpReturn OpFunctionEnd %14 = OpFunction %2 None %3 %15 = OpLabel %41 = OpAccessChain %25 %19 %21 %42 = OpLoad %16 %41 -%43 = OpUDiv %16 %42 %36 +%53 = OpIAdd %16 %42 %36 %44 = OpAccessChain %25 %19 %21 -OpStore %44 %43 +OpStore %44 %53 OpReturn OpFunctionEnd Src -> Dst 1 -> 1 [ExtInstImport] 2 -> 2 [TypeVoid] 3 -> 3 [TypeFunction] 4 -> 4 [Function] 5 -> 5 [Label] 6 -> 6 [Function] 7 -> 7 [Label] 8 -> 8 [Function] 9 -> 9 [Label] 10 -> 10 [Function] 11 -> 11 [Label] 12 -> 12 [Function] 13 -> 13 [Label] 14 -> 14 [Function] 15 -> 15 [Label] 16 -> 16 [TypeInt] 17 -> 17 [TypeStruct] 18 -> 18 [TypePointer] 19 -> 19 [Variable] 20 -> 20 [TypeInt] 21 -> 21 [Constant] 22 -> 22 [TypeStruct] 23 -> 23 [TypePointer] 24 -> 24 [Variable] 25 -> 25 [TypePointer] 26 -> 26 [AccessChain] 27 -> 27 [Load] 28 -> 28 [AccessChain] 29 -> 29 [AccessChain] 30 -> 30 [Load] 31 -> 31 [Constant] 32 -> 50 [IAdd] 33 -> 33 [AccessChain] 34 -> 34 [Load] 35 -> 51 [ISub] 36 -> 36 [Constant] 37 -> 37 [AccessChain] 38 -> 38 [Load] 39 -> 52 [IMul] 40 -> 40 [AccessChain] 41 -> 41 [AccessChain] 42 -> 42 [Load] 43 -> 53 [UDiv] 44 -> 44 [AccessChain] 45 -> 45 [FunctionCall] 46 -> 46 [FunctionCall] 47 -> 47 [FunctionCall] 48 -> 48 [FunctionCall] 49 -> 49 [FunctionCall] )"; Options options; options.dump_id_map = true; DoStringDiffTest(kSrc, kDst, kDiff, options); } } // namespace } // namespace diff } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/small_functions_small_diffs_dst.spvasm000066400000000000000000000060451475742701700323670ustar00rootroot00000000000000 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpName %4 "main" OpName %6 "f1(" OpName %8 "f2(" OpName %10 "f3(" OpName %12 "f4(" OpName %14 "f5(" OpName %17 "BufferOut" OpMemberName %17 0 "o" OpName %19 "" OpName %22 "BufferIn" OpMemberName %22 0 "i" OpName %24 "" OpMemberDecorate %17 0 Offset 0 OpDecorate %17 BufferBlock OpDecorate %19 DescriptorSet 0 OpDecorate %19 Binding 1 OpMemberDecorate %22 0 Offset 0 OpDecorate %22 Block OpDecorate %24 DescriptorSet 0 OpDecorate %24 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %16 = OpTypeInt 32 0 %17 = OpTypeStruct %16 %18 = OpTypePointer Uniform %17 %19 = OpVariable %18 Uniform %20 = OpTypeInt 32 1 %21 = OpConstant %20 0 %22 = OpTypeStruct %16 %23 = OpTypePointer Uniform %22 %24 = OpVariable %23 Uniform %25 = OpTypePointer Uniform %16 %31 = OpConstant %20 1 %36 = OpConstant %16 2 %6 = OpFunction %2 None %3 %7 = OpLabel %26 = OpAccessChain %25 %24 %21 %27 = OpLoad %16 %26 %28 = OpAccessChain %25 %19 %21 OpStore %28 %27 OpReturn OpFunctionEnd %14 = OpFunction %2 None %3 %15 = OpLabel %41 = OpAccessChain %25 %19 %21 %42 = OpLoad %16 %41 %43 = OpIAdd %16 %42 %36 %44 = OpAccessChain %25 %19 %21 OpStore %44 %43 OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %29 = OpAccessChain %25 %19 %21 %30 = OpLoad %16 %29 %32 = OpISub %16 %30 %31 OpStore %29 %32 OpReturn OpFunctionEnd %10 = OpFunction %2 None %3 %11 = OpLabel %33 = OpAccessChain %25 %19 %21 %34 = OpLoad %16 %33 %35 = OpIAdd %16 %34 %31 OpStore %33 %35 OpReturn OpFunctionEnd %4 = OpFunction %2 None %3 %5 = OpLabel %45 = OpFunctionCall %2 %6 %46 = OpFunctionCall %2 %8 %47 = OpFunctionCall %2 %10 %48 = OpFunctionCall %2 %12 %49 = OpFunctionCall %2 %14 OpReturn OpFunctionEnd %12 = OpFunction %2 None %3 %13 = OpLabel %37 = OpAccessChain %25 %19 %21 %38 = OpLoad %16 %37 %39 = OpISub %16 %38 %36 %40 = OpAccessChain %25 %19 %21 OpStore %40 %39 OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/small_functions_small_diffs_src.spvasm000066400000000000000000000061611475742701700323630ustar00rootroot00000000000000;; Test where src and dst have many small functions with small differences. OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpName %4 "main" OpName %6 "f1(" OpName %8 "f2(" OpName %10 "f3(" OpName %12 "f4(" OpName %14 "f5(" OpName %17 "BufferOut" OpMemberName %17 0 "o" OpName %19 "" OpName %22 "BufferIn" OpMemberName %22 0 "i" OpName %24 "" OpMemberDecorate %17 0 Offset 0 OpDecorate %17 BufferBlock OpDecorate %19 DescriptorSet 0 OpDecorate %19 Binding 1 OpMemberDecorate %22 0 Offset 0 OpDecorate %22 Block OpDecorate %24 DescriptorSet 0 OpDecorate %24 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %16 = OpTypeInt 32 0 %17 = OpTypeStruct %16 %18 = OpTypePointer Uniform %17 %19 = OpVariable %18 Uniform %20 = OpTypeInt 32 1 %21 = OpConstant %20 0 %22 = OpTypeStruct %16 %23 = OpTypePointer Uniform %22 %24 = OpVariable %23 Uniform %25 = OpTypePointer Uniform %16 %31 = OpConstant %20 1 %36 = OpConstant %16 2 %4 = OpFunction %2 None %3 %5 = OpLabel %45 = OpFunctionCall %2 %6 %46 = OpFunctionCall %2 %8 %47 = OpFunctionCall %2 %10 %48 = OpFunctionCall %2 %12 %49 = OpFunctionCall %2 %14 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %26 = OpAccessChain %25 %24 %21 %27 = OpLoad %16 %26 %28 = OpAccessChain %25 %19 %21 OpStore %28 %27 OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %29 = OpAccessChain %25 %19 %21 %30 = OpLoad %16 %29 %32 = OpIAdd %16 %30 %31 OpStore %29 %32 OpReturn OpFunctionEnd %10 = OpFunction %2 None %3 %11 = OpLabel %33 = OpAccessChain %25 %19 %21 %34 = OpLoad %16 %33 %35 = OpISub %16 %34 %31 OpStore %33 %35 OpReturn OpFunctionEnd %12 = OpFunction %2 None %3 %13 = OpLabel %37 = OpAccessChain %25 %19 %21 %38 = OpLoad %16 %37 %39 = OpIMul %16 %38 %36 %40 = OpAccessChain %25 %19 %21 OpStore %40 %39 OpReturn OpFunctionEnd %14 = OpFunction %2 None %3 %15 = OpLabel %41 = OpAccessChain %25 %19 %21 %42 = OpLoad %16 %41 %43 = OpUDiv %16 %42 %36 %44 = OpAccessChain %25 %19 %21 OpStore %44 %43 OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/spec_constant_array_size_autogen.cpp000066400000000000000000000200341475742701700320320ustar00rootroot00000000000000// GENERATED FILE - DO NOT EDIT. // Generated by generate_tests.py // // Copyright (c) 2022 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "../diff_test_utils.h" #include "gtest/gtest.h" namespace spvtools { namespace diff { namespace { // Tests that identical specialization constants are not matched with constants // when used as array size. constexpr char kSrc[] = R"(; SPIR-V ; Version: 1.0 ; Generator: Google ANGLE Shader Compiler; 0 ; Bound: 27 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %22 "main" %4 %19 OpSource GLSL 450 OpName %4 "_ua_position" OpName %17 "gl_PerVertex" OpMemberName %17 0 "gl_Position" OpMemberName %17 1 "gl_PointSize" OpMemberName %17 2 "gl_ClipDistance" OpMemberName %17 3 "gl_CullDistance" OpName %19 "" OpName %22 "main" OpDecorate %4 Location 0 OpMemberDecorate %17 1 RelaxedPrecision OpMemberDecorate %17 0 BuiltIn Position OpMemberDecorate %17 1 BuiltIn PointSize OpMemberDecorate %17 2 BuiltIn ClipDistance OpMemberDecorate %17 3 BuiltIn CullDistance OpDecorate %17 Block %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeInt 32 0 %8 = OpTypeVector %5 4 %15 = OpConstant %5 8 %16 = OpTypeArray %1 %15 %17 = OpTypeStruct %2 %1 %16 %16 %20 = OpTypeVoid %25 = OpConstant %5 0 %3 = OpTypePointer Input %2 %13 = OpTypePointer Output %2 %18 = OpTypePointer Output %17 %21 = OpTypeFunction %20 %4 = OpVariable %3 Input %19 = OpVariable %18 Output %22 = OpFunction %20 None %21 %23 = OpLabel %24 = OpLoad %2 %4 %26 = OpAccessChain %13 %19 %25 OpStore %26 %24 OpReturn OpFunctionEnd)"; constexpr char kDst[] = R"(; SPIR-V ; Version: 1.0 ; Generator: Google ANGLE Shader Compiler; 0 ; Bound: 27 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %22 "main" %4 %19 OpSource GLSL 450 OpName %4 "_ua_position" OpName %17 "gl_PerVertex" OpMemberName %17 0 "gl_Position" OpMemberName %17 1 "gl_PointSize" OpMemberName %17 2 "gl_ClipDistance" OpMemberName %17 3 "gl_CullDistance" OpName %19 "" OpName %22 "main" OpDecorate %4 Location 0 OpDecorate %15 SpecId 4 OpMemberDecorate %17 1 RelaxedPrecision OpMemberDecorate %17 0 BuiltIn Position OpMemberDecorate %17 1 BuiltIn PointSize OpMemberDecorate %17 2 BuiltIn ClipDistance OpMemberDecorate %17 3 BuiltIn CullDistance OpDecorate %17 Block %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeInt 32 0 %8 = OpTypeVector %5 4 %15 = OpSpecConstant %5 8 %16 = OpTypeArray %1 %15 %17 = OpTypeStruct %2 %1 %16 %16 %20 = OpTypeVoid %25 = OpConstant %5 0 %3 = OpTypePointer Input %2 %13 = OpTypePointer Output %2 %18 = OpTypePointer Output %17 %21 = OpTypeFunction %20 %4 = OpVariable %3 Input %19 = OpVariable %18 Output %22 = OpFunction %20 None %21 %23 = OpLabel %24 = OpLoad %2 %4 %26 = OpAccessChain %13 %19 %25 OpStore %26 %24 OpReturn OpFunctionEnd )"; TEST(DiffTest, SpecConstantArraySize) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 27 +; Bound: 29 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %22 "main" %4 %19 OpSource GLSL 450 OpName %4 "_ua_position" OpName %17 "gl_PerVertex" OpMemberName %17 0 "gl_Position" OpMemberName %17 1 "gl_PointSize" OpMemberName %17 2 "gl_ClipDistance" OpMemberName %17 3 "gl_CullDistance" OpName %19 "" OpName %22 "main" OpDecorate %4 Location 0 +OpDecorate %27 SpecId 4 OpMemberDecorate %17 1 RelaxedPrecision OpMemberDecorate %17 0 BuiltIn Position OpMemberDecorate %17 1 BuiltIn PointSize OpMemberDecorate %17 2 BuiltIn ClipDistance OpMemberDecorate %17 3 BuiltIn CullDistance OpDecorate %17 Block %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeInt 32 0 %8 = OpTypeVector %5 4 -%15 = OpConstant %5 8 -%16 = OpTypeArray %1 %15 +%27 = OpSpecConstant %5 8 +%28 = OpTypeArray %1 %27 -%17 = OpTypeStruct %2 %1 %16 %16 +%17 = OpTypeStruct %2 %1 %28 %28 %20 = OpTypeVoid %25 = OpConstant %5 0 %3 = OpTypePointer Input %2 %13 = OpTypePointer Output %2 %18 = OpTypePointer Output %17 %21 = OpTypeFunction %20 %4 = OpVariable %3 Input %19 = OpVariable %18 Output %22 = OpFunction %20 None %21 %23 = OpLabel %24 = OpLoad %2 %4 %26 = OpAccessChain %13 %19 %25 OpStore %26 %24 OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrc, kDst, kDiff, options); } TEST(DiffTest, SpecConstantArraySizeNoDebug) { constexpr char kSrcNoDebug[] = R"(; SPIR-V ; Version: 1.0 ; Generator: Google ANGLE Shader Compiler; 0 ; Bound: 27 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %22 "main" %4 %19 OpSource GLSL 450 OpDecorate %4 Location 0 OpMemberDecorate %17 1 RelaxedPrecision OpMemberDecorate %17 0 BuiltIn Position OpMemberDecorate %17 1 BuiltIn PointSize OpMemberDecorate %17 2 BuiltIn ClipDistance OpMemberDecorate %17 3 BuiltIn CullDistance OpDecorate %17 Block %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeInt 32 0 %8 = OpTypeVector %5 4 %15 = OpConstant %5 8 %16 = OpTypeArray %1 %15 %17 = OpTypeStruct %2 %1 %16 %16 %20 = OpTypeVoid %25 = OpConstant %5 0 %3 = OpTypePointer Input %2 %13 = OpTypePointer Output %2 %18 = OpTypePointer Output %17 %21 = OpTypeFunction %20 %4 = OpVariable %3 Input %19 = OpVariable %18 Output %22 = OpFunction %20 None %21 %23 = OpLabel %24 = OpLoad %2 %4 %26 = OpAccessChain %13 %19 %25 OpStore %26 %24 OpReturn OpFunctionEnd )"; constexpr char kDstNoDebug[] = R"(; SPIR-V ; Version: 1.0 ; Generator: Google ANGLE Shader Compiler; 0 ; Bound: 27 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %22 "main" %4 %19 OpSource GLSL 450 OpDecorate %4 Location 0 OpDecorate %15 SpecId 4 OpMemberDecorate %17 1 RelaxedPrecision OpMemberDecorate %17 0 BuiltIn Position OpMemberDecorate %17 1 BuiltIn PointSize OpMemberDecorate %17 2 BuiltIn ClipDistance OpMemberDecorate %17 3 BuiltIn CullDistance OpDecorate %17 Block %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeInt 32 0 %8 = OpTypeVector %5 4 %15 = OpSpecConstant %5 8 %16 = OpTypeArray %1 %15 %17 = OpTypeStruct %2 %1 %16 %16 %20 = OpTypeVoid %25 = OpConstant %5 0 %3 = OpTypePointer Input %2 %13 = OpTypePointer Output %2 %18 = OpTypePointer Output %17 %21 = OpTypeFunction %20 %4 = OpVariable %3 Input %19 = OpVariable %18 Output %22 = OpFunction %20 None %21 %23 = OpLabel %24 = OpLoad %2 %4 %26 = OpAccessChain %13 %19 %25 OpStore %26 %24 OpReturn OpFunctionEnd )"; constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 27 +; Bound: 29 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %22 "main" %4 %19 OpSource GLSL 450 OpDecorate %4 Location 0 +OpDecorate %27 SpecId 4 OpMemberDecorate %17 1 RelaxedPrecision OpMemberDecorate %17 0 BuiltIn Position OpMemberDecorate %17 1 BuiltIn PointSize OpMemberDecorate %17 2 BuiltIn ClipDistance OpMemberDecorate %17 3 BuiltIn CullDistance OpDecorate %17 Block %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeInt 32 0 %8 = OpTypeVector %5 4 -%15 = OpConstant %5 8 -%16 = OpTypeArray %1 %15 +%27 = OpSpecConstant %5 8 +%28 = OpTypeArray %1 %27 -%17 = OpTypeStruct %2 %1 %16 %16 +%17 = OpTypeStruct %2 %1 %28 %28 %20 = OpTypeVoid %25 = OpConstant %5 0 %3 = OpTypePointer Input %2 %13 = OpTypePointer Output %2 %18 = OpTypePointer Output %17 %21 = OpTypeFunction %20 %4 = OpVariable %3 Input %19 = OpVariable %18 Output %22 = OpFunction %20 None %21 %23 = OpLabel %24 = OpLoad %2 %4 %26 = OpAccessChain %13 %19 %25 OpStore %26 %24 OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrcNoDebug, kDstNoDebug, kDiff, options); } } // namespace } // namespace diff } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/spec_constant_array_size_dst.spvasm000066400000000000000000000022741475742701700317170ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Google ANGLE Shader Compiler; 0 ; Bound: 27 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %22 "main" %4 %19 OpSource GLSL 450 OpName %4 "_ua_position" OpName %17 "gl_PerVertex" OpMemberName %17 0 "gl_Position" OpMemberName %17 1 "gl_PointSize" OpMemberName %17 2 "gl_ClipDistance" OpMemberName %17 3 "gl_CullDistance" OpName %19 "" OpName %22 "main" OpDecorate %4 Location 0 OpDecorate %15 SpecId 4 OpMemberDecorate %17 1 RelaxedPrecision OpMemberDecorate %17 0 BuiltIn Position OpMemberDecorate %17 1 BuiltIn PointSize OpMemberDecorate %17 2 BuiltIn ClipDistance OpMemberDecorate %17 3 BuiltIn CullDistance OpDecorate %17 Block %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeInt 32 0 %8 = OpTypeVector %5 4 %15 = OpSpecConstant %5 8 %16 = OpTypeArray %1 %15 %17 = OpTypeStruct %2 %1 %16 %16 %20 = OpTypeVoid %25 = OpConstant %5 0 %3 = OpTypePointer Input %2 %13 = OpTypePointer Output %2 %18 = OpTypePointer Output %17 %21 = OpTypeFunction %20 %4 = OpVariable %3 Input %19 = OpVariable %18 Output %22 = OpFunction %20 None %21 %23 = OpLabel %24 = OpLoad %2 %4 %26 = OpAccessChain %13 %19 %25 OpStore %26 %24 OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/spec_constant_array_size_src.spvasm000066400000000000000000000024141475742701700317100ustar00rootroot00000000000000;; Tests that identical specialization constants are not matched with constants ;; when used as array size. ; SPIR-V ; Version: 1.0 ; Generator: Google ANGLE Shader Compiler; 0 ; Bound: 27 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %22 "main" %4 %19 OpSource GLSL 450 OpName %4 "_ua_position" OpName %17 "gl_PerVertex" OpMemberName %17 0 "gl_Position" OpMemberName %17 1 "gl_PointSize" OpMemberName %17 2 "gl_ClipDistance" OpMemberName %17 3 "gl_CullDistance" OpName %19 "" OpName %22 "main" OpDecorate %4 Location 0 OpMemberDecorate %17 1 RelaxedPrecision OpMemberDecorate %17 0 BuiltIn Position OpMemberDecorate %17 1 BuiltIn PointSize OpMemberDecorate %17 2 BuiltIn ClipDistance OpMemberDecorate %17 3 BuiltIn CullDistance OpDecorate %17 Block %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %5 = OpTypeInt 32 0 %8 = OpTypeVector %5 4 %15 = OpConstant %5 8 %16 = OpTypeArray %1 %15 %17 = OpTypeStruct %2 %1 %16 %16 %20 = OpTypeVoid %25 = OpConstant %5 0 %3 = OpTypePointer Input %2 %13 = OpTypePointer Output %2 %18 = OpTypePointer Output %17 %21 = OpTypeFunction %20 %4 = OpVariable %3 Input %19 = OpVariable %18 Output %22 = OpFunction %20 None %21 %23 = OpLabel %24 = OpLoad %2 %4 %26 = OpAccessChain %13 %19 %25 OpStore %26 %24 OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/spec_constant_composite_autogen.cpp000066400000000000000000000136451475742701700316760ustar00rootroot00000000000000// GENERATED FILE - DO NOT EDIT. // Generated by generate_tests.py // // Copyright (c) 2022 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "../diff_test_utils.h" #include "gtest/gtest.h" namespace spvtools { namespace diff { namespace { // Tests OpSpecConstantComposite matching. constexpr char kSrc[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpDecorate %7 SpecId 3 OpDecorate %8 SpecId 4 OpDecorate %gl_WorkGroupSize BuiltIn WorkgroupSize %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %7 = OpSpecConstant %uint 1 %8 = OpSpecConstant %uint 1 %uint_1 = OpConstant %uint 1 %v3uint = OpTypeVector %uint 3 %gl_WorkGroupSize = OpSpecConstantComposite %v3uint %7 %8 %uint_1 %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd)"; constexpr char kDst[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpDecorate %7 SpecId 3 OpDecorate %8 SpecId 4 OpDecorate %gl_WorkGroupSize BuiltIn WorkgroupSize %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %7 = OpSpecConstant %uint 2048 %8 = OpSpecConstant %uint 1 %uint_1 = OpConstant %uint 1 %v3uint = OpTypeVector %uint 3 %gl_WorkGroupSize = OpSpecConstantComposite %v3uint %7 %8 %uint_1 %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; TEST(DiffTest, SpecConstantComposite) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 12 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" OpExecutionMode %2 LocalSize 1 1 1 OpSource GLSL 450 OpName %2 "main" OpDecorate %7 SpecId 3 OpDecorate %8 SpecId 4 OpDecorate %4 BuiltIn WorkgroupSize %6 = OpTypeVoid %3 = OpTypeFunction %6 %9 = OpTypeInt 32 0 -%7 = OpSpecConstant %9 1 +%7 = OpSpecConstant %9 2048 %8 = OpSpecConstant %9 1 %10 = OpConstant %9 1 %11 = OpTypeVector %9 3 %4 = OpSpecConstantComposite %11 %7 %8 %10 %2 = OpFunction %6 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrc, kDst, kDiff, options); } TEST(DiffTest, SpecConstantCompositeNoDebug) { constexpr char kSrcNoDebug[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpDecorate %7 SpecId 3 OpDecorate %8 SpecId 4 OpDecorate %gl_WorkGroupSize BuiltIn WorkgroupSize %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %7 = OpSpecConstant %uint 1 %8 = OpSpecConstant %uint 1 %uint_1 = OpConstant %uint 1 %v3uint = OpTypeVector %uint 3 %gl_WorkGroupSize = OpSpecConstantComposite %v3uint %7 %8 %uint_1 %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; constexpr char kDstNoDebug[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpDecorate %7 SpecId 3 OpDecorate %8 SpecId 4 OpDecorate %gl_WorkGroupSize BuiltIn WorkgroupSize %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %7 = OpSpecConstant %uint 2048 %8 = OpSpecConstant %uint 1 %uint_1 = OpConstant %uint 1 %v3uint = OpTypeVector %uint 3 %gl_WorkGroupSize = OpSpecConstantComposite %v3uint %7 %8 %uint_1 %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 12 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" OpExecutionMode %2 LocalSize 1 1 1 OpSource GLSL 450 OpDecorate %7 SpecId 3 OpDecorate %8 SpecId 4 OpDecorate %4 BuiltIn WorkgroupSize %6 = OpTypeVoid %3 = OpTypeFunction %6 %9 = OpTypeInt 32 0 -%7 = OpSpecConstant %9 1 +%7 = OpSpecConstant %9 2048 %8 = OpSpecConstant %9 1 %10 = OpConstant %9 1 %11 = OpTypeVector %9 3 %4 = OpSpecConstantComposite %11 %7 %8 %10 %2 = OpFunction %6 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrcNoDebug, kDstNoDebug, kDiff, options); } } // namespace } // namespace diff } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/spec_constant_composite_dst.spvasm000066400000000000000000000015371475742701700315520ustar00rootroot00000000000000 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpDecorate %7 SpecId 3 OpDecorate %8 SpecId 4 OpDecorate %gl_WorkGroupSize BuiltIn WorkgroupSize %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %7 = OpSpecConstant %uint 2048 %8 = OpSpecConstant %uint 1 %uint_1 = OpConstant %uint 1 %v3uint = OpTypeVector %uint 3 %gl_WorkGroupSize = OpSpecConstantComposite %v3uint %7 %8 %uint_1 %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/spec_constant_composite_src.spvasm000066400000000000000000000016071475742701700315450ustar00rootroot00000000000000;; Tests OpSpecConstantComposite matching. OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpDecorate %7 SpecId 3 OpDecorate %8 SpecId 4 OpDecorate %gl_WorkGroupSize BuiltIn WorkgroupSize %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %7 = OpSpecConstant %uint 1 %8 = OpSpecConstant %uint 1 %uint_1 = OpConstant %uint 1 %v3uint = OpTypeVector %uint 3 %gl_WorkGroupSize = OpSpecConstantComposite %v3uint %7 %8 %uint_1 %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/spec_constant_op_autogen.cpp000066400000000000000000000123071475742701700303040ustar00rootroot00000000000000// GENERATED FILE - DO NOT EDIT. // Generated by generate_tests.py // // Copyright (c) 2022 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "../diff_test_utils.h" #include "gtest/gtest.h" namespace spvtools { namespace diff { namespace { // Tests OpSpecConstantOp matching. constexpr char kSrc[] = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeInt 32 0 %5 = OpTypeVector %4 3 %6 = OpConstant %4 1 %7 = OpSpecConstantComposite %5 %6 %6 %6 %8 = OpSpecConstantOp %4 CompositeExtract %7 2 %9 = OpSpecConstantOp %4 CompositeExtract %7 1 %10 = OpSpecConstantOp %4 CompositeExtract %7 0 %1 = OpFunction %2 None %3 %11 = OpLabel OpReturn OpFunctionEnd)"; constexpr char kDst[] = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeInt 32 0 %5 = OpTypeVector %4 3 %6 = OpConstant %4 1 %7 = OpSpecConstantComposite %5 %6 %6 %6 %8 = OpSpecConstantOp %4 CompositeExtract %7 2 %9 = OpSpecConstantOp %4 CompositeExtract %7 3 %10 = OpSpecConstantOp %4 IMul %8 %8 %1 = OpFunction %2 None %3 %11 = OpLabel OpReturn OpFunctionEnd )"; TEST(DiffTest, SpecConstantOp) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 12 +; Bound: 14 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeInt 32 0 %5 = OpTypeVector %4 3 %6 = OpConstant %4 1 %7 = OpSpecConstantComposite %5 %6 %6 %6 %8 = OpSpecConstantOp %4 CompositeExtract %7 2 -%9 = OpSpecConstantOp %4 CompositeExtract %7 1 -%10 = OpSpecConstantOp %4 CompositeExtract %7 0 +%12 = OpSpecConstantOp %4 CompositeExtract %7 3 +%13 = OpSpecConstantOp %4 IMul %8 %8 %1 = OpFunction %2 None %3 %11 = OpLabel OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrc, kDst, kDiff, options); } TEST(DiffTest, SpecConstantOpNoDebug) { constexpr char kSrcNoDebug[] = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeInt 32 0 %5 = OpTypeVector %4 3 %6 = OpConstant %4 1 %7 = OpSpecConstantComposite %5 %6 %6 %6 %8 = OpSpecConstantOp %4 CompositeExtract %7 2 %9 = OpSpecConstantOp %4 CompositeExtract %7 1 %10 = OpSpecConstantOp %4 CompositeExtract %7 0 %1 = OpFunction %2 None %3 %11 = OpLabel OpReturn OpFunctionEnd)"; constexpr char kDstNoDebug[] = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeInt 32 0 %5 = OpTypeVector %4 3 %6 = OpConstant %4 1 %7 = OpSpecConstantComposite %5 %6 %6 %6 %8 = OpSpecConstantOp %4 CompositeExtract %7 2 %9 = OpSpecConstantOp %4 CompositeExtract %7 3 %10 = OpSpecConstantOp %4 IMul %8 %8 %1 = OpFunction %2 None %3 %11 = OpLabel OpReturn OpFunctionEnd )"; constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 12 +; Bound: 14 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeInt 32 0 %5 = OpTypeVector %4 3 %6 = OpConstant %4 1 %7 = OpSpecConstantComposite %5 %6 %6 %6 %8 = OpSpecConstantOp %4 CompositeExtract %7 2 -%9 = OpSpecConstantOp %4 CompositeExtract %7 1 -%10 = OpSpecConstantOp %4 CompositeExtract %7 0 +%12 = OpSpecConstantOp %4 CompositeExtract %7 3 +%13 = OpSpecConstantOp %4 IMul %8 %8 %1 = OpFunction %2 None %3 %11 = OpLabel OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrcNoDebug, kDstNoDebug, kDiff, options); } } // namespace } // namespace diff } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/spec_constant_op_dst.spvasm000066400000000000000000000012171475742701700301610ustar00rootroot00000000000000 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeInt 32 0 %5 = OpTypeVector %4 3 %6 = OpConstant %4 1 %7 = OpSpecConstantComposite %5 %6 %6 %6 %8 = OpSpecConstantOp %4 CompositeExtract %7 2 %9 = OpSpecConstantOp %4 CompositeExtract %7 3 %10 = OpSpecConstantOp %4 IMul %8 %8 %1 = OpFunction %2 None %3 %11 = OpLabel OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/spec_constant_op_src.spvasm000066400000000000000000000012751475742701700301620ustar00rootroot00000000000000;; Tests OpSpecConstantOp matching. OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeInt 32 0 %5 = OpTypeVector %4 3 %6 = OpConstant %4 1 %7 = OpSpecConstantComposite %5 %6 %6 %6 %8 = OpSpecConstantOp %4 CompositeExtract %7 2 %9 = OpSpecConstantOp %4 CompositeExtract %7 1 %10 = OpSpecConstantOp %4 CompositeExtract %7 0 %1 = OpFunction %2 None %3 %11 = OpLabel OpReturn OpFunctionEndKhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/spec_constant_specid_autogen.cpp000066400000000000000000000101451475742701700311330ustar00rootroot00000000000000// GENERATED FILE - DO NOT EDIT. // Generated by generate_tests.py // // Copyright (c) 2022 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "../diff_test_utils.h" #include "gtest/gtest.h" namespace spvtools { namespace diff { namespace { // Tests OpSpecConstantComposite matching. constexpr char kSrc[] = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %sc SpecId 0 %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v3uint = OpTypeVector %uint 3 %sc = OpSpecConstant %uint 10 %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd)"; constexpr char kDst[] = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v3uint = OpTypeVector %uint 3 %ss = OpSpecConstant %uint 10 %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; TEST(DiffTest, SpecConstantSpecid) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 8 +; Bound: 9 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 -OpDecorate %2 SpecId 0 %4 = OpTypeVoid %3 = OpTypeFunction %4 %6 = OpTypeInt 32 0 %7 = OpTypeVector %6 3 -%2 = OpSpecConstant %6 10 +%8 = OpSpecConstant %6 10 %1 = OpFunction %4 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrc, kDst, kDiff, options); } TEST(DiffTest, SpecConstantSpecidNoDebug) { constexpr char kSrcNoDebug[] = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %sc SpecId 0 %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v3uint = OpTypeVector %uint 3 %sc = OpSpecConstant %uint 10 %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; constexpr char kDstNoDebug[] = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v3uint = OpTypeVector %uint 3 %ss = OpSpecConstant %uint 10 %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 8 +; Bound: 9 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 -OpDecorate %2 SpecId 0 %4 = OpTypeVoid %3 = OpTypeFunction %4 %6 = OpTypeInt 32 0 %7 = OpTypeVector %6 3 -%2 = OpSpecConstant %6 10 +%8 = OpSpecConstant %6 10 %1 = OpFunction %4 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrcNoDebug, kDstNoDebug, kDiff, options); } } // namespace } // namespace diff } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/spec_constant_specid_dst.spvasm000066400000000000000000000007231475742701700310130ustar00rootroot00000000000000 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v3uint = OpTypeVector %uint 3 %ss = OpSpecConstant %uint 10 %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/spec_constant_specid_src.spvasm000066400000000000000000000010451475742701700310060ustar00rootroot00000000000000;; Tests OpSpecConstantComposite matching. OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %sc SpecId 0 %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v3uint = OpTypeVector %uint 3 %sc = OpSpecConstant %uint 10 %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/string_in_ext_inst_autogen.cpp000066400000000000000000000153311475742701700306540ustar00rootroot00000000000000// GENERATED FILE - DO NOT EDIT. // Generated by generate_tests.py // // Copyright (c) 2022 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "../diff_test_utils.h" #include "gtest/gtest.h" namespace spvtools { namespace diff { namespace { // Tests a diff where the an OpString is used only as parameter of OpExtInst. constexpr char kSrc[] = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %1 = OpExtInstImport "GLSL.std.450" %12 = OpExtInstImport "NonSemantic.DebugPrintf" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %10 = OpString "unsigned == %u" OpSource GLSL 450 OpSourceExtension "GL_EXT_debug_printf" OpName %main "main" OpName %foo "foo" %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_ptr_Function_uint = OpTypePointer Function %uint %uint_127 = OpConstant %uint 127 %main = OpFunction %void None %3 %5 = OpLabel %foo = OpVariable %_ptr_Function_uint Function OpStore %foo %uint_127 %11 = OpLoad %uint %foo %13 = OpExtInst %void %12 1 %10 %11 OpReturn OpFunctionEnd)"; constexpr char kDst[] = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %1 = OpExtInstImport "GLSL.std.450" %12 = OpExtInstImport "NonSemantic.DebugPrintf" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %10 = OpString "signed == %d" OpSource GLSL 450 OpSourceExtension "GL_EXT_debug_printf" OpName %main "main" OpName %foo "foo" %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_ptr_Function_uint = OpTypePointer Function %uint %uint_127 = OpConstant %uint 127 %main = OpFunction %void None %3 %5 = OpLabel %foo = OpVariable %_ptr_Function_uint Function OpStore %foo %uint_127 %11 = OpLoad %uint %foo %13 = OpExtInst %void %12 1 %10 %11 OpReturn OpFunctionEnd )"; TEST(DiffTest, StringInExtInst) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 14 +; Bound: 15 ; Schema: 0 OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %1 = OpExtInstImport "GLSL.std.450" %12 = OpExtInstImport "NonSemantic.DebugPrintf" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" OpExecutionMode %2 LocalSize 1 1 1 -%10 = OpString "unsigned == %u" +%14 = OpString "signed == %d" OpSource GLSL 450 OpSourceExtension "GL_EXT_debug_printf" OpName %2 "main" OpName %4 "foo" %6 = OpTypeVoid %3 = OpTypeFunction %6 %7 = OpTypeInt 32 0 %8 = OpTypePointer Function %7 %9 = OpConstant %7 127 %2 = OpFunction %6 None %3 %5 = OpLabel %4 = OpVariable %8 Function OpStore %4 %9 %11 = OpLoad %7 %4 -%13 = OpExtInst %6 %12 1 %10 %11 +%13 = OpExtInst %6 %12 1 %14 %11 OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrc, kDst, kDiff, options); } TEST(DiffTest, StringInExtInstNoDebug) { constexpr char kSrcNoDebug[] = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %1 = OpExtInstImport "GLSL.std.450" %12 = OpExtInstImport "NonSemantic.DebugPrintf" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %10 = OpString "unsigned == %u" OpSource GLSL 450 OpSourceExtension "GL_EXT_debug_printf" %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_ptr_Function_uint = OpTypePointer Function %uint %uint_127 = OpConstant %uint 127 %main = OpFunction %void None %3 %5 = OpLabel %foo = OpVariable %_ptr_Function_uint Function OpStore %foo %uint_127 %11 = OpLoad %uint %foo %13 = OpExtInst %void %12 1 %10 %11 OpReturn OpFunctionEnd )"; constexpr char kDstNoDebug[] = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %1 = OpExtInstImport "GLSL.std.450" %12 = OpExtInstImport "NonSemantic.DebugPrintf" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %10 = OpString "signed == %d" OpSource GLSL 450 OpSourceExtension "GL_EXT_debug_printf" %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_ptr_Function_uint = OpTypePointer Function %uint %uint_127 = OpConstant %uint 127 %main = OpFunction %void None %3 %5 = OpLabel %foo = OpVariable %_ptr_Function_uint Function OpStore %foo %uint_127 %11 = OpLoad %uint %foo %13 = OpExtInst %void %12 1 %10 %11 OpReturn OpFunctionEnd )"; constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 14 +; Bound: 15 ; Schema: 0 OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %1 = OpExtInstImport "GLSL.std.450" %12 = OpExtInstImport "NonSemantic.DebugPrintf" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" OpExecutionMode %2 LocalSize 1 1 1 -%10 = OpString "unsigned == %u" +%14 = OpString "signed == %d" OpSource GLSL 450 OpSourceExtension "GL_EXT_debug_printf" %4 = OpTypeVoid %3 = OpTypeFunction %4 %6 = OpTypeInt 32 0 %7 = OpTypePointer Function %6 %8 = OpConstant %6 127 %2 = OpFunction %4 None %3 %5 = OpLabel %9 = OpVariable %7 Function OpStore %9 %8 %11 = OpLoad %6 %9 -%13 = OpExtInst %4 %12 1 %10 %11 +%13 = OpExtInst %4 %12 1 %14 %11 OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrcNoDebug, kDstNoDebug, kDiff, options); } } // namespace } // namespace diff } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/string_in_ext_inst_dst.spvasm000066400000000000000000000017531475742701700305360ustar00rootroot00000000000000 OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %1 = OpExtInstImport "GLSL.std.450" %12 = OpExtInstImport "NonSemantic.DebugPrintf" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %10 = OpString "signed == %d" OpSource GLSL 450 OpSourceExtension "GL_EXT_debug_printf" OpName %main "main" OpName %foo "foo" %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_ptr_Function_uint = OpTypePointer Function %uint %uint_127 = OpConstant %uint 127 %main = OpFunction %void None %3 %5 = OpLabel %foo = OpVariable %_ptr_Function_uint Function OpStore %foo %uint_127 %11 = OpLoad %uint %foo %13 = OpExtInst %void %12 1 %10 %11 OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/string_in_ext_inst_src.spvasm000066400000000000000000000020731475742701700305270ustar00rootroot00000000000000;; Tests a diff where the an OpString is used only as parameter of OpExtInst. OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %1 = OpExtInstImport "GLSL.std.450" %12 = OpExtInstImport "NonSemantic.DebugPrintf" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %10 = OpString "unsigned == %u" OpSource GLSL 450 OpSourceExtension "GL_EXT_debug_printf" OpName %main "main" OpName %foo "foo" %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_ptr_Function_uint = OpTypePointer Function %uint %uint_127 = OpConstant %uint 127 %main = OpFunction %void None %3 %5 = OpLabel %foo = OpVariable %_ptr_Function_uint Function OpStore %foo %uint_127 %11 = OpLoad %uint %foo %13 = OpExtInst %void %12 1 %10 %11 OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/unrelated_shaders_autogen.cpp000066400000000000000000000155721475742701700304460ustar00rootroot00000000000000// GENERATED FILE - DO NOT EDIT. // Generated by generate_tests.py // // Copyright (c) 2022 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "../diff_test_utils.h" #include "gtest/gtest.h" namespace spvtools { namespace diff { namespace { // Tests diff of unrelated shaders (with different execution models). constexpr char kSrc[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %4 "main" %8 %10 OpSource ESSL 310 OpName %4 "main" OpName %8 "v" OpName %10 "a" OpDecorate %8 Location 0 OpDecorate %10 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Output %6 %8 = OpVariable %7 Output %9 = OpTypePointer Input %6 %10 = OpVariable %9 Input %4 = OpFunction %2 None %3 %5 = OpLabel %11 = OpLoad %6 %10 OpStore %8 %11 OpReturn OpFunctionEnd )"; constexpr char kDst[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %9 %11 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %9 "color" OpName %11 "v" OpDecorate %9 RelaxedPrecision OpDecorate %9 Location 0 OpDecorate %11 RelaxedPrecision OpDecorate %11 Location 0 OpDecorate %12 RelaxedPrecision OpDecorate %13 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypePointer Output %7 %9 = OpVariable %8 Output %10 = OpTypePointer Input %6 %11 = OpVariable %10 Input %4 = OpFunction %2 None %3 %5 = OpLabel %12 = OpLoad %6 %11 %13 = OpCompositeConstruct %7 %12 %12 %12 %12 OpStore %9 %13 OpReturn OpFunctionEnd )"; TEST(DiffTest, UnrelatedShaders) { constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 12 +; Bound: 16 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 -OpEntryPoint Vertex %4 "main" %8 %10 +OpEntryPoint Fragment %4 "main" %14 %8 +OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" +OpName %14 "color" OpName %8 "v" -OpName %10 "a" +OpDecorate %14 RelaxedPrecision +OpDecorate %14 Location 0 +OpDecorate %8 RelaxedPrecision OpDecorate %8 Location 0 -OpDecorate %10 Location 0 +OpDecorate %11 RelaxedPrecision +OpDecorate %15 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 -%7 = OpTypePointer Output %6 +%12 = OpTypeVector %6 4 +%13 = OpTypePointer Output %12 +%14 = OpVariable %13 Output -%8 = OpVariable %7 Output +%8 = OpVariable %9 Input %9 = OpTypePointer Input %6 -%10 = OpVariable %9 Input %4 = OpFunction %2 None %3 %5 = OpLabel -%11 = OpLoad %6 %10 +%11 = OpLoad %6 %8 -OpStore %8 %11 +%15 = OpCompositeConstruct %12 %11 %11 %11 %11 +OpStore %14 %15 OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrc, kDst, kDiff, options); } TEST(DiffTest, UnrelatedShadersNoDebug) { constexpr char kSrcNoDebug[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %4 "main" %8 %10 OpSource ESSL 310 OpDecorate %8 Location 0 OpDecorate %10 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Output %6 %8 = OpVariable %7 Output %9 = OpTypePointer Input %6 %10 = OpVariable %9 Input %4 = OpFunction %2 None %3 %5 = OpLabel %11 = OpLoad %6 %10 OpStore %8 %11 OpReturn OpFunctionEnd )"; constexpr char kDstNoDebug[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %9 %11 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %9 RelaxedPrecision OpDecorate %9 Location 0 OpDecorate %11 RelaxedPrecision OpDecorate %11 Location 0 OpDecorate %12 RelaxedPrecision OpDecorate %13 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypePointer Output %7 %9 = OpVariable %8 Output %10 = OpTypePointer Input %6 %11 = OpVariable %10 Input %4 = OpFunction %2 None %3 %5 = OpLabel %12 = OpLoad %6 %11 %13 = OpCompositeConstruct %7 %12 %12 %12 %12 OpStore %9 %13 OpReturn OpFunctionEnd )"; constexpr char kDiff[] = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 -; Bound: 12 +; Bound: 15 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 -OpEntryPoint Vertex %4 "main" %8 %10 +OpEntryPoint Fragment %4 "main" %8 %10 +OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 +OpDecorate %8 RelaxedPrecision OpDecorate %8 Location 0 +OpDecorate %10 RelaxedPrecision OpDecorate %10 Location 0 +OpDecorate %11 RelaxedPrecision +OpDecorate %14 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 -%7 = OpTypePointer Output %6 +%12 = OpTypeVector %6 4 +%13 = OpTypePointer Output %12 -%8 = OpVariable %7 Output +%8 = OpVariable %13 Output %9 = OpTypePointer Input %6 %10 = OpVariable %9 Input %4 = OpFunction %2 None %3 %5 = OpLabel %11 = OpLoad %6 %10 +%14 = OpCompositeConstruct %12 %11 %11 %11 %11 -OpStore %8 %11 +OpStore %8 %14 OpReturn OpFunctionEnd )"; Options options; DoStringDiffTest(kSrcNoDebug, kDstNoDebug, kDiff, options); } } // namespace } // namespace diff } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/unrelated_shaders_dst.spvasm000066400000000000000000000021451475742701700303150ustar00rootroot00000000000000 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %9 %11 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %9 "color" OpName %11 "v" OpDecorate %9 RelaxedPrecision OpDecorate %9 Location 0 OpDecorate %11 RelaxedPrecision OpDecorate %11 Location 0 OpDecorate %12 RelaxedPrecision OpDecorate %13 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypePointer Output %7 %9 = OpVariable %8 Output %10 = OpTypePointer Input %6 %11 = OpVariable %10 Input %4 = OpFunction %2 None %3 %5 = OpLabel %12 = OpLoad %6 %11 %13 = OpCompositeConstruct %7 %12 %12 %12 %12 OpStore %9 %13 OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_files/unrelated_shaders_src.spvasm000066400000000000000000000015371475742701700303160ustar00rootroot00000000000000;; Tests diff of unrelated shaders (with different execution models). OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %4 "main" %8 %10 OpSource ESSL 310 OpName %4 "main" OpName %8 "v" OpName %10 "a" OpDecorate %8 Location 0 OpDecorate %10 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Output %6 %8 = OpVariable %7 Output %9 = OpTypePointer Input %6 %10 = OpVariable %9 Input %4 = OpFunction %2 None %3 %5 = OpLabel %11 = OpLoad %6 %10 OpStore %8 %11 OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_test.cpp000066400000000000000000000144401475742701700230760ustar00rootroot00000000000000// Copyright (c) 2022 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/diff/diff.h" #include "diff_test_utils.h" #include "source/opt/build_module.h" #include "source/opt/ir_context.h" #include "source/spirv_constant.h" #include "spirv-tools/libspirv.hpp" #include "tools/util/cli_consumer.h" #include #include #include "gtest/gtest.h" namespace spvtools { namespace diff { namespace { constexpr auto kDefaultEnvironment = SPV_ENV_UNIVERSAL_1_6; std::unique_ptr Assemble(const std::string& spirv) { spvtools::SpirvTools t(kDefaultEnvironment); t.SetMessageConsumer(spvtools::utils::CLIMessageConsumer); std::vector binary; if (!t.Assemble(spirv, &binary, spvtools::SpirvTools::kDefaultAssembleOption | SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS)) return nullptr; return spvtools::BuildModule(kDefaultEnvironment, spvtools::utils::CLIMessageConsumer, binary.data(), binary.size()); } TEST(DiffIndentTest, Diff) { const std::string src = R"(OpCapability Shader %ext_inst = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %func = OpTypeFunction %void %main = OpFunction %void None %func %main_entry = OpLabel OpReturn OpFunctionEnd;)"; const std::string dst = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %func = OpTypeFunction %void %main = OpFunction %void None %func %main_entry = OpLabel OpReturn OpFunctionEnd;)"; const std::string diff = R"( ; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 6 ; Schema: 0 OpCapability Shader - %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft %3 = OpTypeVoid %4 = OpTypeFunction %3 %2 = OpFunction %3 None %4 %5 = OpLabel OpReturn OpFunctionEnd )"; Options options; options.indent = true; DoStringDiffTest(src, dst, diff, options); } TEST(DiffNoHeaderTest, Diff) { const std::string src = R"(OpCapability Shader %ext_inst = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %func = OpTypeFunction %void %main = OpFunction %void None %func %main_entry = OpLabel OpReturn OpFunctionEnd;)"; const std::string dst = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %func = OpTypeFunction %void %main = OpFunction %void None %func %main_entry = OpLabel OpReturn OpFunctionEnd;)"; const std::string diff = R"( OpCapability Shader -%1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft %3 = OpTypeVoid %4 = OpTypeFunction %3 %2 = OpFunction %3 None %4 %5 = OpLabel OpReturn OpFunctionEnd )"; Options options; options.no_header = true; DoStringDiffTest(src, dst, diff, options); } TEST(DiffHeaderTest, Diff) { const std::string src_spirv = R"(OpCapability Shader %ext_inst = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %func = OpTypeFunction %void %main = OpFunction %void None %func %main_entry = OpLabel OpReturn OpFunctionEnd;)"; const std::string dst_spirv = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %func = OpTypeFunction %void %main = OpFunction %void None %func %main_entry = OpLabel OpReturn OpFunctionEnd;)"; const std::string diff = R"( ; SPIR-V -; Version: 1.3 +; Version: 1.2 -; Generator: Khronos SPIR-V Tools Assembler; 3 +; Generator: Khronos Glslang Reference Front End; 10 ; Bound: 6 ; Schema: 0 OpCapability Shader -%1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft %3 = OpTypeVoid %4 = OpTypeFunction %3 %2 = OpFunction %3 None %4 %5 = OpLabel OpReturn OpFunctionEnd )"; // Load the src and dst modules std::unique_ptr src = Assemble(src_spirv); ASSERT_TRUE(src); std::unique_ptr dst = Assemble(dst_spirv); ASSERT_TRUE(dst); // Differentiate them in the header. const spvtools::opt::ModuleHeader src_header = { spv::MagicNumber, SPV_SPIRV_VERSION_WORD(1, 3), SPV_GENERATOR_WORD(SPV_GENERATOR_KHRONOS_ASSEMBLER, 3), src->module()->IdBound(), src->module()->schema(), }; const spvtools::opt::ModuleHeader dst_header = { spv::MagicNumber, SPV_SPIRV_VERSION_WORD(1, 2), SPV_GENERATOR_WORD(SPV_GENERATOR_KHRONOS_GLSLANG, 10), dst->module()->IdBound(), dst->module()->schema(), }; src->module()->SetHeader(src_header); dst->module()->SetHeader(dst_header); // Take the diff Options options; std::ostringstream diff_result; spv_result_t result = spvtools::diff::Diff(src.get(), dst.get(), diff_result, options); ASSERT_EQ(result, SPV_SUCCESS); // Expect they match EXPECT_EQ(diff_result.str(), diff); } } // namespace } // namespace diff } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_test_utils.cpp000066400000000000000000000036751475742701700243260ustar00rootroot00000000000000// Copyright (c) 2022 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "diff_test_utils.h" #include "source/opt/build_module.h" #include "source/opt/ir_context.h" #include "spirv-tools/libspirv.hpp" #include "tools/util/cli_consumer.h" #include "gtest/gtest.h" namespace spvtools { namespace diff { static constexpr auto kDefaultEnvironment = SPV_ENV_UNIVERSAL_1_6; void DoStringDiffTest(const std::string& src_spirv, const std::string& dst_spirv, const std::string& expected_diff, Options options) { // Load the src and dst modules std::unique_ptr src = spvtools::BuildModule( kDefaultEnvironment, spvtools::utils::CLIMessageConsumer, src_spirv, spvtools::SpirvTools::kDefaultAssembleOption | SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); ASSERT_TRUE(src); std::unique_ptr dst = spvtools::BuildModule( kDefaultEnvironment, spvtools::utils::CLIMessageConsumer, dst_spirv, spvtools::SpirvTools::kDefaultAssembleOption | SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); ASSERT_TRUE(dst); // Take the diff std::ostringstream diff_result; spv_result_t result = spvtools::diff::Diff(src.get(), dst.get(), diff_result, options); ASSERT_EQ(result, SPV_SUCCESS); // Expect they match EXPECT_EQ(diff_result.str(), expected_diff); } } // namespace diff } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/diff/diff_test_utils.h000066400000000000000000000017541475742701700237670ustar00rootroot00000000000000// Copyright (c) 2022 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef TEST_DIFF_DIFF_TEST_UTILS_H_ #define TEST_DIFF_DIFF_TEST_UTILS_H_ #include "source/diff/diff.h" namespace spvtools { namespace diff { void DoStringDiffTest(const std::string& src_spirv, const std::string& dst_spirv, const std::string& expected_diff, Options options); } // namespace diff } // namespace spvtools #endif // TEST_DIFF_DIFF_TEST_UTILS_H_ KhronosGroup-SPIRV-Tools-f289d04/test/diff/lcs_test.cpp000066400000000000000000000315011475742701700227440ustar00rootroot00000000000000// Copyright (c) 2022 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/diff/lcs.h" #include #include "gtest/gtest.h" namespace spvtools { namespace diff { namespace { using Sequence = std::vector; using LCS = LongestCommonSubsequence; void VerifyMatch(const Sequence& src, const Sequence& dst, size_t expected_match_count) { DiffMatch src_match, dst_match; LCS lcs(src, dst); size_t match_count = lcs.Get([](int s, int d) { return s == d; }, &src_match, &dst_match); EXPECT_EQ(match_count, expected_match_count); size_t src_cur = 0; size_t dst_cur = 0; size_t matches_seen = 0; while (src_cur < src.size() && dst_cur < dst.size()) { if (src_match[src_cur] && dst_match[dst_cur]) { EXPECT_EQ(src[src_cur], dst[dst_cur]) << "Src: " << src_cur << " Dst: " << dst_cur; ++src_cur; ++dst_cur; ++matches_seen; continue; } if (!src_match[src_cur]) { ++src_cur; } if (!dst_match[dst_cur]) { ++dst_cur; } } EXPECT_EQ(matches_seen, expected_match_count); } TEST(LCSTest, EmptySequences) { Sequence src, dst; DiffMatch src_match, dst_match; LCS lcs(src, dst); size_t match_count = lcs.Get([](int s, int d) { return s == d; }, &src_match, &dst_match); EXPECT_EQ(match_count, 0u); EXPECT_TRUE(src_match.empty()); EXPECT_TRUE(dst_match.empty()); } TEST(LCSTest, EmptySrc) { Sequence src, dst = {1, 2, 3}; DiffMatch src_match, dst_match; LCS lcs(src, dst); size_t match_count = lcs.Get([](int s, int d) { return s == d; }, &src_match, &dst_match); EXPECT_EQ(match_count, 0u); EXPECT_TRUE(src_match.empty()); EXPECT_EQ(dst_match, DiffMatch(3, false)); } TEST(LCSTest, EmptyDst) { Sequence src = {1, 2, 3}, dst; DiffMatch src_match, dst_match; LCS lcs(src, dst); size_t match_count = lcs.Get([](int s, int d) { return s == d; }, &src_match, &dst_match); EXPECT_EQ(match_count, 0u); EXPECT_EQ(src_match, DiffMatch(3, false)); EXPECT_TRUE(dst_match.empty()); } TEST(LCSTest, Identical) { Sequence src = {1, 2, 3, 4, 5, 6}, dst = {1, 2, 3, 4, 5, 6}; DiffMatch src_match, dst_match; LCS lcs(src, dst); size_t match_count = lcs.Get([](int s, int d) { return s == d; }, &src_match, &dst_match); EXPECT_EQ(match_count, 6u); EXPECT_EQ(src_match, DiffMatch(6, true)); EXPECT_EQ(dst_match, DiffMatch(6, true)); } TEST(LCSTest, SrcPrefix) { Sequence src = {1, 2, 3, 4}, dst = {1, 2, 3, 4, 5, 6}; DiffMatch src_match, dst_match; LCS lcs(src, dst); size_t match_count = lcs.Get([](int s, int d) { return s == d; }, &src_match, &dst_match); const DiffMatch src_expect = {true, true, true, true}; const DiffMatch dst_expect = {true, true, true, true, false, false}; EXPECT_EQ(match_count, 4u); EXPECT_EQ(src_match, src_expect); EXPECT_EQ(dst_match, dst_expect); } TEST(LCSTest, DstPrefix) { Sequence src = {1, 2, 3, 4, 5, 6}, dst = {1, 2, 3, 4, 5}; DiffMatch src_match, dst_match; LCS lcs(src, dst); size_t match_count = lcs.Get([](int s, int d) { return s == d; }, &src_match, &dst_match); const DiffMatch src_expect = {true, true, true, true, true, false}; const DiffMatch dst_expect = {true, true, true, true, true}; EXPECT_EQ(match_count, 5u); EXPECT_EQ(src_match, src_expect); EXPECT_EQ(dst_match, dst_expect); } TEST(LCSTest, SrcSuffix) { Sequence src = {3, 4, 5, 6}, dst = {1, 2, 3, 4, 5, 6}; DiffMatch src_match, dst_match; LCS lcs(src, dst); size_t match_count = lcs.Get([](int s, int d) { return s == d; }, &src_match, &dst_match); const DiffMatch src_expect = {true, true, true, true}; const DiffMatch dst_expect = {false, false, true, true, true, true}; EXPECT_EQ(match_count, 4u); EXPECT_EQ(src_match, src_expect); EXPECT_EQ(dst_match, dst_expect); } TEST(LCSTest, DstSuffix) { Sequence src = {1, 2, 3, 4, 5, 6}, dst = {5, 6}; DiffMatch src_match, dst_match; LCS lcs(src, dst); size_t match_count = lcs.Get([](int s, int d) { return s == d; }, &src_match, &dst_match); const DiffMatch src_expect = {false, false, false, false, true, true}; const DiffMatch dst_expect = {true, true}; EXPECT_EQ(match_count, 2u); EXPECT_EQ(src_match, src_expect); EXPECT_EQ(dst_match, dst_expect); } TEST(LCSTest, None) { Sequence src = {1, 3, 5, 7, 9}, dst = {2, 4, 6, 8, 10, 12}; DiffMatch src_match, dst_match; LCS lcs(src, dst); size_t match_count = lcs.Get([](int s, int d) { return s == d; }, &src_match, &dst_match); EXPECT_EQ(match_count, 0u); EXPECT_EQ(src_match, DiffMatch(5, false)); EXPECT_EQ(dst_match, DiffMatch(6, false)); } TEST(LCSTest, NonContiguous) { Sequence src = {1, 2, 3, 4, 5, 6, 10}, dst = {2, 4, 5, 8, 9, 10, 12}; DiffMatch src_match, dst_match; LCS lcs(src, dst); size_t match_count = lcs.Get([](int s, int d) { return s == d; }, &src_match, &dst_match); const DiffMatch src_expect = {false, true, false, true, true, false, true}; const DiffMatch dst_expect = {true, true, true, false, false, true, false}; EXPECT_EQ(match_count, 4u); EXPECT_EQ(src_match, src_expect); EXPECT_EQ(dst_match, dst_expect); } TEST(LCSTest, WithDuplicates) { Sequence src = {1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4}, dst = {1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4}; VerifyMatch(src, dst, 6); } TEST(LCSTest, Large) { const std::string src_str = "GUJwrJSlkKJXxCVIAxlVgnUyOrdyRyFtlZwWMmFhYGfkFTNnhiBmClgHyrcXMVwfrRxNUfQk" "qaoGvCbPZHAzXsaZpXHPfJxOMCUtRDmIQpfiXKbHQbhTfPqhxBDWvmTQAqwsWTLajZYtMUnf" "hNNCfkuAXkZsaebwEbIZOxTDZsqSMUfCMoGeKJGVSNFgLTiBMbdvchHGfFRkHKcYCDjBfIcj" "todPnvDjzQYWBcvIfVvyBzHikrwpDORaGEZLhmyztIFCLJOqeLhOzERYmVqzlsoUzruTXTXq" "DLTxQRakOCMRrgRzCDTXfwwfDcKMBVnxRZemjcwcEsOVxwtwdBCWJycsDcZKlvrCvZaenKlv" "vyByDQeLdxAyBnPkIMQlMQwqjUfRLybeoaOanlbFkpTPPZdHelQrIvucTHzMpWWQTbuANwvN" "OVhCGGoIcGNDpfIsaBexlMMdHsxMGerTngmjpdPeQQJHfvKZkdYqAzrtDohqtDsaFMxQViVQ" "YszDVgyoSHZdOXAvXkJidojLvGZOzhRajVPhWDwKuGqdaympELxHsrXAJYufdCPwJdGJfWqq" "yvTWpcrFHOIuCEmNLnSCDsxQGRVDwyCykBJazhApfCnrOadnafvqfVuFqEXMSrYbHTfTnzbz" "MhISyOtMUITaurCXvanCbuOXBhHyCjOhVbxnMvhlPmZBMQgEHCghtAJVMXGPNRtszVZlPxVl" "QIPTBnPUPejlyZGPqeICyNngdQGkvKbIoWlTLBtVhMdBeUMozNlKQTIPYBeImVcMdLafuxUf" "TIXysmcTrUTcspOSKBxhdhLwiRnREGFWJTfUKsgGOAQeYojXdrqsGjMJfiKalyoiqrgLnlij" "CtOapoxDGVOOBalNYGzCtBlxbvaAzxipGnJpOEbmXcpeoIsAdxspKBzBDgoPVxnuRBUwmTSr" "CRpWhxikgUYQVCwalLUIeBPRyhhsECGCXJmGDZSCIUaBwROkigzdeVPOXhgCGBEprWtNdYfL" "tOUYJHQXxiIJgSGmWntezJFpNQoTPbRRYAGhtYvAechvBcYWocLkYFxsDAuszvQNLXdhmAHw" "DErcjbtCdQllnKcDADVNWVezljjLrAuyGHetINMgAvJZwOEYakihYVUbZGCsHEufluLNyNHy" "gqtSTSFFjBHiIqQejTPWybLdpWNwZrWvIWnlzUcGNQPEYHVPCbteWknjAnWrdTBeCbHUDBoK" "aHvDStmpNRGIjvlumiZTbdZNAzUeSFnFChCsSExwXeEfDJfjyOoSBofHzJqJErvHLNyUJTjX" "qmtgKPpMKohUPBMhtCteQFcNEpWrUVGbibMOpvBwdiWYXNissArpSasVJFgDzrqTyGkerTMX" "gcrzFUGFZRhNdekaJeKYPogsofJaRsUQmIRyYdkrxKeMgLPpwOfSKJOqzXDoeHljTzhOwEVy" "krOEnACFrWhufajsMitjOWdLOHHchQDddGPzxknEgdwmZepKDvRZGCuPqzeQkjOPqUBKpKLJ" "eKieSsRXkaqxSPGajfvPKmwFWdLByEcLgvrmteazgFjmMGrLYqRRxzUOfOCokenqHVYstBHf" "AwsWsqPTvqsRJUfGGTaYiylZMGbQqTzINhFHvdlRQvvYKBcuAHdBeKlHSxVrSsEKbcAvnIcf" "xzdVDdwQPHMCHeZZRpGHWvKzgTGzSTbYTeOPyKvvYWmQToTpsjAtKUJUjcEHWhmdBLDTBMHJ" "ivBXcLGtCsumNNVFyGbVviGmqHTdyBlkneibXBesKJGOUzOtIwXCPJggqBekSzNQYkALlItk" "cbEhbdXAIKVHYpInLwxXalKZrkrpxtfuagqMGmRJnJbFQaEoYMoqPsxZpocddPXXPyvxVkaF" "qdKISejWDhBImnEEOPDcyWTubbfVfwUztciaFJcsPLhgYVfhqlOfoNjKbmTFptFttYuyBrUI" "zzmZypOqrjQHTGFwlHStpIwxPtMvtsEDpsmWIgwzYgwmdpbMOnfElZMYpVIcvzSWejeJcdUB" "QUoBRUmGQVVWvEDseuozrDjgdXFScPwwsgaUPwSzScfBNrkpmEFDSZLKfNjMqvOmUtocUkbo" "VGFEKgGLbNruwLgXHTloWDrnqymPVAtzjWPutonIsMDPeeCmTjYWAFXcyTAlBeiJTIRkZxiM" "kLjMnAflSNJzmZkatXkYiPEMYSmzHbLKEizHbEjQOxBDzpRHiFjhedqiyMiUMvThjaRFmwll" "aMGgwKBIKepwyoEdnuhtzJzboiNEAFKiqiWxxmkRFRoTiFWXLPAWLuzSCrajgkQhDxAQDqyM" "VwZlhZicQLEDYYisEalesDWZAYzcvENuHUwRutIsGgsdoYwOZiURhcgdbTGWBNqhrFjvTQCj" "VlTPNlRdRLaaqzUBBwbdtyXFkCBUYYMbmRrkFxfxbCqkgZNGyHPKLkOPnezfVTRmRQgCgHbx" "wcZlInVOwmFePnSIbThMJosimzkhfuiqYEpwHQiemqsSDNNdbNhBLzbsPZBJZujSHJGtYKGb" "HaAYGJZxBumsKUrATwPuqXFLfwNyImLQbchBKiJAYRZhkcrKCHXBEGYyBhBGvSqvabcRUrfq" "AbPiMzjHAehGYjDEmxAnYLyoSFdeWVrfJUCuYZPluhXEBuyUpKaRXDKXeiCvGidpvATwMbcz" "DZpzxrhTZYyrFORFQWTbPLCBjMKMhlRMFEiarDgGPttjmkrQVlujztMSkxXffXFNqLWOLThI" "KBoyMHoFTEPCdUAZjLTifAdjjUehyDLEGKlRTFoLpjalziRSUjZfRYbNzhiHgTHowMMkKTwE" "ZgnqiirMtnNpaBJqhcIVrWXPpcPWZfRpsPstHleFJDZYAsxYhOREVbFtebXTZRAIjGgWeoiN" "qPLCCAVadqmUrjOcqIbdCTpcDRWuDVbHrZOQRPhqbyvOWwxAWJphjLiDgoAybcjzgfVktPlj" "kNBCjelpuQfnYsiTgPpCNKYtOrxGaLEEtAuLdGdDsONHNhSn"; const std::string dst_str = "KzitfifORCbGhfNEbnbObUdFLLaAsLOpMkOeKupjCoatzqfHBkNJfSgqSMYouswfNMnoQngK" "jWwyPKmEnoZWyPBUdQRmKUNudUclueKXKQefUdXWUyyqtumzsFKznrLVLwfvPZpLChNYrrHK" "AtpfOuVHiUKyeRCrktJAhkyFKmPWrASEMvBLNOzuGlvinZjvZUUXazNEkyMPiOLdqXvCIroC" "MeWsvjHShlLhDwLZrVlpYBnDJmILcsNFDSoaLWOKNNkNGBgNBvVjPCJXAuKfsrKZhYcdEpxK" "UihiRkYvMiLyOUvaqBMklLDwEhvQBfCXHSRoqsLsSCzLZQhIYMhBapvHaPbDoRrHoJXZsNXc" "rxZYCrOMIzYcVPwDCFiHBFnPNTTeAeKEMGeVUeCaAeuWZmngyPWlQBcgWumSUIfbhjVYdnpV" "hRSJXrIoFZubBXfNOMhilAkVPixrhILZKgDoFTvytPFPfBLMnbhSOBmLWCbJsLQxrCrMAlOw" "RmfSQyGhrjhzYVqFSBHeoQBagFwyxIjcHFZngntpVHbSwqhwHeMnWSsISPljTxSNXfCxLebW" "GhMdlphtJbdvhEcjNpwPCFqhdquxCyOxkjsDUPNgjpDcpIMhMwMclNhfESTrroJaoyeGQclV" "gonnhuQRmXcBwcsWeLqjNngZOlyMyfeQBwnwMVJEvGqknDyzSApniRTPgJpFoDkJJhXQFuFB" "VqhuEPMRGCeTDOSEFmXeIHOnDxaJacvnmORwVpmrRhGjDpUCkuODNPdZMdupYExDEDnDLdNF" "iObKBaVWpGVMKdgNLgsNxcpypBPPKKoaajeSGPZQJWSOKrkLjiFexYVmUGxJnbTNsCXXLfZp" "jfxQAEVYvqKehBzMsVHVGWmTshWFAoCNDkNppzzjHBZWckrzSTANICioCJSpLwPwQvtXVxst" "nTRBAboPFREEUFazibpFesCsjzUOnECwoPCOFiwGORlIZVLpUkJyhYXCENmzTBLVigOFuCWO" "IiXBYmiMtsxnUdoqSTTGyEFFrQsNAjcDdOKDtHwlANWoUVwiJCMCQFILdGqzEePuSXFbOEOz" "dLlEnTJbKRSTfAFToOZNtDXTfFgvQiefAKbSUWUXFcpCjRYCBNXCCcLMjjuUDXErpiNsRuIx" "mgHsrObTEXcnmjdqxTGhTjTeYizNnkrJRhNQIqDXmZMwArBccnixpcuiGOOexjgkpcEyGAnz" "UbgiBfflTUyJfZeFFLrZVueFkSRosebnnwAnakIrywTGByhQKWvmNQJsWQezqLhHQzXnEpeD" "rFRTSQSpVxPzSeEzfWYzfpcenxsUyzOMLxhNEhfcuprDtqubsXehuqKqZlLQeSclvoGjuKJK" "XoWrazsgjXXnkWHdqFESZdMGDYldyYdbpSZcgBPgEKLWZHfBirNPLUadmajYkiEzmGuWGELB" "WLiSrMdaGSbptKmgYVqMGcQaaATStiZYteGAPxSEBHuAzzjlRHYsrdDkaGNXmzRGoalJMiCC" "GMtWSDMhgvRSEgKnywbRgnqWXFlwrhXbbvcgLGtWSuKQBiqIlWkfPMozOTWgVoLHavDJGRYI" "YerrmZnTMtuuxmZALWakfzUbksTwoetqkOiRPGqGZepcVXHoZyOaaaijjZWQLlIhYwiQNbfc" "KCwhhFaMQBoaCnOecJEdKzdsMPFEYQuJNPYiiNtsYxaWBRuWjlLqGokHMNtyTQfSJKbgGdol" "fWlOZdupouQMfUWXIYHzyJHefMDnqxxasDxtgArvDqtwjDBaVEMACPkLFpiDOoKCHqkWVizh" "lKqbOHpsPKkhjRQRNGYRYEfxtBjYvlCvHBNUwVuIwDJYMqHxEFtwdLqYWvjdOfQmNiviDfUq" "pbucbNwjNQfMYgwUuPnQWIPOlqHcbjtuDXvTzLtkdBQanJbrmLSyFqSapZCSPMDOrxWVYzyO" "lwDTTJFmKxoyfPunadkHcrcSQaQsAbrQtbhqwSTXGTPURYTCbNozjAVwbmcyVxIbZudBZWYm" "rnSDyelGCRRWYtrUxvOVWlTLHHdYuAmVMGnGbHscbjmjmAzmYLaCxNNwhmMYdExKvySxuYpE" "rVGwfqMngBCHnZodotNaNJZiNRFWubuPDfiywXPiyVWoQMeOlSuWmpilLTIFOvfpjmJTgrWa" "dgoxYeyPyOaglOvZVGdFOBSeqEcGXBwjoeUAXqkpvOxEpSXhmklKZydTvRVYVvfQdRNNDkCT" "dLNfcZCFQbZORdcDOhwotoyccrSbWvlqYMoiAYeEpDzZTvkamapzZMmCpEutZFCcHBWGIIkr" "urwDNHrobaErPpclyEegLJDtkfUWSNWZosWSbBGAHIvJsFNUlJXbnkSVycLkOVQVcNcUtiBy" "djLDIFsycbPBEWaMvCbntNtJlOeCttvXypGnHAQFnFSiXFWWqonWuVIKmVPpKXuJtFguXCWC" "rNExYYvxLGEmuZJLJDjHgjlQyOzeieCpizJxkrdqKCgomyEkvsyVYSsLeyLvOZQrrgEJgRFK" "CjYtoOfluNrLdRMTRkQXmAiMRFwloYECpXCReAMxOkNiwCtutsrqWoMHsrogRqPoUCueonvW" "MTwmkAkajfGJkhnQidwpwIMEttQkzIMOPvvyWZHpqkMHWlNTeSKibfRfwDyxveKENZhtlPwP" "dfAjwegjRcavtFnkkTNVYdCdCrgdUvzsIcqmUjwGmVvuuQvjVrWWIDBmAzQtiZPYvCOEWjce" "rWzeqVKeiYTJBOedmQCVidOgUIEjfRnbGvUbctYxfRybJkdmeAkLZQMRMGPOnsPbFswXAoCK" "IxWGwohoPpEJxslbqHFKSwknxTmrDCITRZWEDkGQeucPxHBdYkduwbYhKnoxCKhgjBFiFawC" "QtgTDldTQmlOsBiGLquMjuecAbrUJJvNtXbFNGjWxaZPimSRXUJWgRbydpsczOqSFIeEtuKA" "ZpRhmLtPdVNKdSDQZeeImUFmUwXApRTUNHItyvFyJtNtn"; Sequence src; Sequence dst; src.reserve(src_str.length()); dst.reserve(dst_str.length()); for (char c : src_str) { src.push_back(c); } for (char c : dst_str) { dst.push_back(c); } VerifyMatch(src, dst, 723); } } // namespace } // namespace diff } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/enum_set_test.cpp000066400000000000000000000711241475742701700230770ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/enum_set.h" #include #include #include #include #include #include "gmock/gmock.h" #include "test/unit_spirv.h" namespace spvtools { namespace { using spvtest::ElementsIn; using ::testing::Eq; using ::testing::Values; using ::testing::ValuesIn; enum class TestEnum : uint32_t { ZERO = 0, ONE = 1, TWO = 2, THREE = 3, FOUR = 4, FIVE = 5, EIGHT = 8, TWENTY = 20, TWENTY_FOUR = 24, THIRTY = 30, ONE_HUNDRED = 100, ONE_HUNDRED_FIFTY = 150, TWO_HUNDRED = 200, THREE_HUNDRED = 300, FOUR_HUNDRED = 400, FIVE_HUNDRED = 500, SIX_HUNDRED = 600, }; constexpr std::array kCapabilities{ spv::Capability::Matrix, spv::Capability::Shader, spv::Capability::Geometry, spv::Capability::Tessellation, spv::Capability::Addresses, spv::Capability::Linkage, spv::Capability::Kernel, spv::Capability::Vector16, spv::Capability::Float16Buffer, spv::Capability::Float16, spv::Capability::Float64, spv::Capability::Int64, spv::Capability::Int64Atomics, spv::Capability::ImageBasic, spv::Capability::ImageReadWrite, spv::Capability::ImageMipmap, spv::Capability::Pipes, spv::Capability::Groups, spv::Capability::DeviceEnqueue, spv::Capability::LiteralSampler, spv::Capability::AtomicStorage, spv::Capability::Int16, spv::Capability::TessellationPointSize, spv::Capability::GeometryPointSize, spv::Capability::ImageGatherExtended, spv::Capability::StorageImageMultisample, spv::Capability::UniformBufferArrayDynamicIndexing, spv::Capability::SampledImageArrayDynamicIndexing, spv::Capability::StorageBufferArrayDynamicIndexing, spv::Capability::StorageImageArrayDynamicIndexing, spv::Capability::ClipDistance, spv::Capability::CullDistance, spv::Capability::ImageCubeArray, spv::Capability::SampleRateShading, spv::Capability::ImageRect, spv::Capability::SampledRect, spv::Capability::GenericPointer, spv::Capability::Int8, spv::Capability::InputAttachment, spv::Capability::SparseResidency, spv::Capability::MinLod, spv::Capability::Sampled1D, spv::Capability::Image1D, spv::Capability::SampledCubeArray, spv::Capability::SampledBuffer, spv::Capability::ImageBuffer, spv::Capability::ImageMSArray, spv::Capability::StorageImageExtendedFormats, spv::Capability::ImageQuery, spv::Capability::DerivativeControl, spv::Capability::InterpolationFunction, spv::Capability::TransformFeedback, spv::Capability::GeometryStreams, spv::Capability::StorageImageReadWithoutFormat, spv::Capability::StorageImageWriteWithoutFormat, spv::Capability::MultiViewport, spv::Capability::SubgroupDispatch, spv::Capability::NamedBarrier, spv::Capability::PipeStorage, spv::Capability::GroupNonUniform, spv::Capability::GroupNonUniformVote, spv::Capability::GroupNonUniformArithmetic, spv::Capability::GroupNonUniformBallot, spv::Capability::GroupNonUniformShuffle, spv::Capability::GroupNonUniformShuffleRelative, spv::Capability::GroupNonUniformClustered, spv::Capability::GroupNonUniformQuad, spv::Capability::ShaderLayer, spv::Capability::ShaderViewportIndex, spv::Capability::UniformDecoration, spv::Capability::CoreBuiltinsARM, spv::Capability::FragmentShadingRateKHR, spv::Capability::SubgroupBallotKHR, spv::Capability::DrawParameters, spv::Capability::WorkgroupMemoryExplicitLayoutKHR, spv::Capability::WorkgroupMemoryExplicitLayout8BitAccessKHR, spv::Capability::WorkgroupMemoryExplicitLayout16BitAccessKHR, spv::Capability::SubgroupVoteKHR, spv::Capability::StorageBuffer16BitAccess, spv::Capability::StorageUniformBufferBlock16, spv::Capability::StorageUniform16, spv::Capability::UniformAndStorageBuffer16BitAccess, spv::Capability::StoragePushConstant16, spv::Capability::StorageInputOutput16, spv::Capability::DeviceGroup, spv::Capability::MultiView, spv::Capability::VariablePointersStorageBuffer, spv::Capability::VariablePointers, spv::Capability::AtomicStorageOps, spv::Capability::SampleMaskPostDepthCoverage, spv::Capability::StorageBuffer8BitAccess, spv::Capability::UniformAndStorageBuffer8BitAccess, spv::Capability::StoragePushConstant8, spv::Capability::DenormPreserve, spv::Capability::DenormFlushToZero, spv::Capability::SignedZeroInfNanPreserve, spv::Capability::RoundingModeRTE, spv::Capability::RoundingModeRTZ, spv::Capability::RayQueryProvisionalKHR, spv::Capability::RayQueryKHR, spv::Capability::RayTraversalPrimitiveCullingKHR, spv::Capability::RayTracingKHR, spv::Capability::Float16ImageAMD, spv::Capability::ImageGatherBiasLodAMD, spv::Capability::FragmentMaskAMD, spv::Capability::StencilExportEXT, spv::Capability::ImageReadWriteLodAMD, spv::Capability::Int64ImageEXT, spv::Capability::ShaderClockKHR, spv::Capability::SampleMaskOverrideCoverageNV, spv::Capability::GeometryShaderPassthroughNV, spv::Capability::ShaderViewportIndexLayerEXT, spv::Capability::ShaderViewportIndexLayerNV, spv::Capability::ShaderViewportMaskNV, spv::Capability::ShaderStereoViewNV, spv::Capability::PerViewAttributesNV, spv::Capability::FragmentFullyCoveredEXT, spv::Capability::MeshShadingNV, spv::Capability::ImageFootprintNV, spv::Capability::MeshShadingEXT, spv::Capability::FragmentBarycentricKHR, spv::Capability::FragmentBarycentricNV, spv::Capability::ComputeDerivativeGroupQuadsNV, spv::Capability::FragmentDensityEXT, spv::Capability::ShadingRateNV, spv::Capability::GroupNonUniformPartitionedNV, spv::Capability::ShaderNonUniform, spv::Capability::ShaderNonUniformEXT, spv::Capability::RuntimeDescriptorArray, spv::Capability::RuntimeDescriptorArrayEXT, spv::Capability::InputAttachmentArrayDynamicIndexing, spv::Capability::InputAttachmentArrayDynamicIndexingEXT, spv::Capability::UniformTexelBufferArrayDynamicIndexing, spv::Capability::UniformTexelBufferArrayDynamicIndexingEXT, spv::Capability::StorageTexelBufferArrayDynamicIndexing, spv::Capability::StorageTexelBufferArrayDynamicIndexingEXT, spv::Capability::UniformBufferArrayNonUniformIndexing, spv::Capability::UniformBufferArrayNonUniformIndexingEXT, spv::Capability::SampledImageArrayNonUniformIndexing, spv::Capability::SampledImageArrayNonUniformIndexingEXT, spv::Capability::StorageBufferArrayNonUniformIndexing, spv::Capability::StorageBufferArrayNonUniformIndexingEXT, spv::Capability::StorageImageArrayNonUniformIndexing, spv::Capability::StorageImageArrayNonUniformIndexingEXT, spv::Capability::InputAttachmentArrayNonUniformIndexing, spv::Capability::InputAttachmentArrayNonUniformIndexingEXT, spv::Capability::UniformTexelBufferArrayNonUniformIndexing, spv::Capability::UniformTexelBufferArrayNonUniformIndexingEXT, spv::Capability::StorageTexelBufferArrayNonUniformIndexing, spv::Capability::StorageTexelBufferArrayNonUniformIndexingEXT, spv::Capability::RayTracingNV, spv::Capability::RayTracingMotionBlurNV, spv::Capability::VulkanMemoryModel, spv::Capability::VulkanMemoryModelKHR, spv::Capability::VulkanMemoryModelDeviceScope, spv::Capability::VulkanMemoryModelDeviceScopeKHR, spv::Capability::PhysicalStorageBufferAddresses, spv::Capability::PhysicalStorageBufferAddressesEXT, spv::Capability::ComputeDerivativeGroupLinearNV, spv::Capability::RayTracingProvisionalKHR, spv::Capability::CooperativeMatrixNV, spv::Capability::FragmentShaderSampleInterlockEXT, spv::Capability::FragmentShaderShadingRateInterlockEXT, spv::Capability::ShaderSMBuiltinsNV, spv::Capability::FragmentShaderPixelInterlockEXT, spv::Capability::DemoteToHelperInvocation, spv::Capability::DemoteToHelperInvocationEXT, spv::Capability::RayTracingOpacityMicromapEXT, spv::Capability::ShaderInvocationReorderNV, spv::Capability::BindlessTextureNV, spv::Capability::SubgroupShuffleINTEL, spv::Capability::SubgroupBufferBlockIOINTEL, spv::Capability::SubgroupImageBlockIOINTEL, spv::Capability::SubgroupImageMediaBlockIOINTEL, spv::Capability::RoundToInfinityINTEL, spv::Capability::FloatingPointModeINTEL, spv::Capability::IntegerFunctions2INTEL, spv::Capability::FunctionPointersINTEL, spv::Capability::IndirectReferencesINTEL, spv::Capability::AsmINTEL, spv::Capability::AtomicFloat32MinMaxEXT, spv::Capability::AtomicFloat64MinMaxEXT, spv::Capability::AtomicFloat16MinMaxEXT, spv::Capability::VectorComputeINTEL, spv::Capability::VectorAnyINTEL, spv::Capability::ExpectAssumeKHR, spv::Capability::SubgroupAvcMotionEstimationINTEL, spv::Capability::SubgroupAvcMotionEstimationIntraINTEL, spv::Capability::SubgroupAvcMotionEstimationChromaINTEL, spv::Capability::VariableLengthArrayINTEL, spv::Capability::FunctionFloatControlINTEL, spv::Capability::FPGAMemoryAttributesINTEL, spv::Capability::FPFastMathModeINTEL, spv::Capability::ArbitraryPrecisionIntegersINTEL, spv::Capability::ArbitraryPrecisionFloatingPointINTEL, spv::Capability::UnstructuredLoopControlsINTEL, spv::Capability::FPGALoopControlsINTEL, spv::Capability::KernelAttributesINTEL, spv::Capability::FPGAKernelAttributesINTEL, spv::Capability::FPGAMemoryAccessesINTEL, spv::Capability::FPGAClusterAttributesINTEL, spv::Capability::LoopFuseINTEL, spv::Capability::FPGADSPControlINTEL, spv::Capability::MemoryAccessAliasingINTEL, spv::Capability::FPGAInvocationPipeliningAttributesINTEL, spv::Capability::FPGABufferLocationINTEL, spv::Capability::ArbitraryPrecisionFixedPointINTEL, spv::Capability::USMStorageClassesINTEL, spv::Capability::RuntimeAlignedAttributeINTEL, spv::Capability::IOPipesINTEL, spv::Capability::BlockingPipesINTEL, spv::Capability::FPGARegINTEL, spv::Capability::DotProductInputAll, spv::Capability::DotProductInputAllKHR, spv::Capability::DotProductInput4x8Bit, spv::Capability::DotProductInput4x8BitKHR, spv::Capability::DotProductInput4x8BitPacked, spv::Capability::DotProductInput4x8BitPackedKHR, spv::Capability::DotProduct, spv::Capability::DotProductKHR, spv::Capability::RayCullMaskKHR, spv::Capability::BitInstructions, spv::Capability::GroupNonUniformRotateKHR, spv::Capability::AtomicFloat32AddEXT, spv::Capability::AtomicFloat64AddEXT, spv::Capability::LongCompositesINTEL, spv::Capability::OptNoneINTEL, spv::Capability::AtomicFloat16AddEXT, spv::Capability::DebugInfoModuleINTEL, spv::Capability::SplitBarrierINTEL, spv::Capability::GroupUniformArithmeticKHR, spv::Capability::Max, }; namespace { std::vector enumerateValuesFromToWithStep(size_t start, size_t end, size_t step) { assert(end > start && "end > start"); std::vector orderedValues; for (size_t i = start; i < end; i += step) { orderedValues.push_back(static_cast(i)); } return orderedValues; } EnumSet createSetUnorderedInsertion( const std::vector& values) { std::vector shuffledValues(values.cbegin(), values.cend()); std::mt19937 rng(0); std::shuffle(shuffledValues.begin(), shuffledValues.end(), rng); EnumSet set; for (auto value : shuffledValues) { set.insert(value); } return set; } } // namespace TEST(EnumSet, IsEmpty1) { EnumSet set; EXPECT_TRUE(set.empty()); set.insert(TestEnum::ZERO); EXPECT_FALSE(set.empty()); } TEST(EnumSet, IsEmpty2) { EnumSet set; EXPECT_TRUE(set.empty()); set.insert(TestEnum::ONE_HUNDRED_FIFTY); EXPECT_FALSE(set.empty()); } TEST(EnumSet, IsEmpty3) { EnumSet set(TestEnum::FOUR); EXPECT_FALSE(set.empty()); } TEST(EnumSet, IsEmpty4) { EnumSet set(TestEnum::THREE_HUNDRED); EXPECT_FALSE(set.empty()); } TEST(EnumSetHasAnyOf, EmptySetEmptyQuery) { const EnumSet set; const EnumSet empty; EXPECT_TRUE(set.HasAnyOf(empty)); EXPECT_TRUE(EnumSet().HasAnyOf(EnumSet())); } TEST(EnumSetHasAnyOf, MaskSetEmptyQuery) { EnumSet set; const EnumSet empty; set.insert(TestEnum::FIVE); set.insert(TestEnum::EIGHT); EXPECT_TRUE(set.HasAnyOf(empty)); } TEST(EnumSetHasAnyOf, OverflowSetEmptyQuery) { EnumSet set; const EnumSet empty; set.insert(TestEnum::TWO_HUNDRED); set.insert(TestEnum::THREE_HUNDRED); EXPECT_TRUE(set.HasAnyOf(empty)); } TEST(EnumSetHasAnyOf, EmptyQuery) { EnumSet set; const EnumSet empty; set.insert(TestEnum::FIVE); set.insert(TestEnum::EIGHT); set.insert(TestEnum::TWO_HUNDRED); set.insert(TestEnum::THREE_HUNDRED); EXPECT_TRUE(set.HasAnyOf(empty)); } TEST(EnumSetHasAnyOf, EmptyQueryAlwaysTrue) { EnumSet set; const EnumSet empty; EXPECT_TRUE(set.HasAnyOf(empty)); set.insert(TestEnum::FIVE); EXPECT_TRUE(set.HasAnyOf(empty)); EXPECT_TRUE( EnumSet(TestEnum::ONE_HUNDRED).HasAnyOf(EnumSet())); } TEST(EnumSetHasAnyOf, ReflexiveMask) { EnumSet set(TestEnum::THREE); set.insert(TestEnum::TWENTY_FOUR); set.insert(TestEnum::THIRTY); EXPECT_TRUE(set.HasAnyOf(set)); } TEST(EnumSetHasAnyOf, ReflexiveOverflow) { EnumSet set(TestEnum::TWO_HUNDRED); set.insert(TestEnum::TWO_HUNDRED); set.insert(TestEnum::FOUR_HUNDRED); EXPECT_TRUE(set.HasAnyOf(set)); } TEST(EnumSetHasAnyOf, Reflexive) { EnumSet set(TestEnum::THREE); set.insert(TestEnum::TWENTY_FOUR); set.insert(TestEnum::THREE_HUNDRED); set.insert(TestEnum::FOUR_HUNDRED); EXPECT_TRUE(set.HasAnyOf(set)); } TEST(EnumSetHasAnyOf, EmptySetHasNone) { EnumSet set; EnumSet items; for (uint32_t i = 0; i < 200; ++i) { TestEnum enumValue = static_cast(i); items.insert(enumValue); EXPECT_FALSE(set.HasAnyOf(items)); EXPECT_FALSE(set.HasAnyOf(EnumSet(enumValue))); } } TEST(EnumSetHasAnyOf, MaskSetMaskQuery) { EnumSet set(TestEnum::ZERO); EnumSet items(TestEnum::ONE); EXPECT_FALSE(set.HasAnyOf(items)); set.insert(TestEnum::TWO); items.insert(TestEnum::THREE); EXPECT_FALSE(set.HasAnyOf(items)); set.insert(TestEnum::THREE); EXPECT_TRUE(set.HasAnyOf(items)); set.insert(TestEnum::FOUR); EXPECT_TRUE(set.HasAnyOf(items)); } TEST(EnumSetHasAnyOf, OverflowSetOverflowQuery) { EnumSet set(TestEnum::ONE_HUNDRED); EnumSet items(TestEnum::TWO_HUNDRED); EXPECT_FALSE(set.HasAnyOf(items)); set.insert(TestEnum::THREE_HUNDRED); items.insert(TestEnum::FOUR_HUNDRED); EXPECT_FALSE(set.HasAnyOf(items)); set.insert(TestEnum::TWO_HUNDRED); EXPECT_TRUE(set.HasAnyOf(items)); set.insert(TestEnum::FIVE_HUNDRED); EXPECT_TRUE(set.HasAnyOf(items)); } TEST(EnumSetHasAnyOf, GeneralCase) { EnumSet set(TestEnum::ZERO); EnumSet items(TestEnum::ONE_HUNDRED); EXPECT_FALSE(set.HasAnyOf(items)); set.insert(TestEnum::THREE_HUNDRED); items.insert(TestEnum::FOUR); EXPECT_FALSE(set.HasAnyOf(items)); set.insert(TestEnum::FIVE); items.insert(TestEnum::FIVE_HUNDRED); EXPECT_FALSE(set.HasAnyOf(items)); set.insert(TestEnum::FIVE_HUNDRED); EXPECT_TRUE(set.HasAnyOf(items)); EXPECT_FALSE(set.HasAnyOf(EnumSet(TestEnum::TWENTY))); EXPECT_FALSE(set.HasAnyOf(EnumSet(TestEnum::SIX_HUNDRED))); EXPECT_TRUE(set.HasAnyOf(EnumSet(TestEnum::FIVE))); EXPECT_TRUE(set.HasAnyOf(EnumSet(TestEnum::THREE_HUNDRED))); EXPECT_TRUE(set.HasAnyOf(EnumSet(TestEnum::ZERO))); } TEST(EnumSet, DefaultIsEmpty) { EnumSet set; for (uint32_t i = 0; i < 1000; ++i) { EXPECT_FALSE(set.contains(static_cast(i))); } } TEST(EnumSet, EqualityCompareEmpty) { EnumSet set1; EnumSet set2; EXPECT_TRUE(set1 == set2); EXPECT_FALSE(set1 != set2); } TEST(EnumSet, EqualityCompareSame) { EnumSet set1; EnumSet set2; set1.insert(TestEnum::ONE); set1.insert(TestEnum::TWENTY); set2.insert(TestEnum::TWENTY); set2.insert(TestEnum::ONE); EXPECT_TRUE(set1 == set2); EXPECT_FALSE(set1 != set2); } TEST(EnumSet, EqualityCompareDifferent) { EnumSet set1; EnumSet set2; set1.insert(TestEnum::ONE); set1.insert(TestEnum::TWENTY); set2.insert(TestEnum::FIVE); set2.insert(TestEnum::ONE); EXPECT_FALSE(set1 == set2); EXPECT_TRUE(set1 != set2); } TEST(EnumSet, ConstructFromIterators) { auto orderedValues = enumerateValuesFromToWithStep(0, 2, /* step= */ 1); EnumSet set1 = createSetUnorderedInsertion(orderedValues); EnumSet set2(orderedValues.cbegin(), orderedValues.cend()); EXPECT_EQ(set1, set2); } TEST(EnumSet, InsertUsingIteratorRange) { auto orderedValues = enumerateValuesFromToWithStep(0, 2, /* step= */ 1); EnumSet set1 = createSetUnorderedInsertion(orderedValues); EnumSet set2; set2.insert(orderedValues.cbegin(), orderedValues.cend()); EXPECT_EQ(set1, set2); } TEST(CapabilitySet, RangeBasedLoopOrderIsEnumOrder) { auto orderedValues = enumerateValuesFromToWithStep(0, 2, /* step= */ 1); auto set = createSetUnorderedInsertion(orderedValues); size_t index = 0; for (auto value : set) { ASSERT_THAT(value, Eq(orderedValues[index])); index++; } } TEST(CapabilitySet, ConstructSingleMemberMatrix) { CapabilitySet s(spv::Capability::Matrix); EXPECT_TRUE(s.contains(spv::Capability::Matrix)); EXPECT_FALSE(s.contains(spv::Capability::Shader)); EXPECT_FALSE(s.contains(static_cast(1000))); } TEST(CapabilitySet, ConstructSingleMemberMaxInMask) { CapabilitySet s(static_cast(63)); EXPECT_FALSE(s.contains(spv::Capability::Matrix)); EXPECT_FALSE(s.contains(spv::Capability::Shader)); EXPECT_TRUE(s.contains(static_cast(63))); EXPECT_FALSE(s.contains(static_cast(64))); EXPECT_FALSE(s.contains(static_cast(1000))); } TEST(CapabilitySet, ConstructSingleMemberMinOverflow) { // Check the first one that forces overflow beyond the mask. CapabilitySet s(static_cast(64)); EXPECT_FALSE(s.contains(spv::Capability::Matrix)); EXPECT_FALSE(s.contains(spv::Capability::Shader)); EXPECT_FALSE(s.contains(static_cast(63))); EXPECT_TRUE(s.contains(static_cast(64))); EXPECT_FALSE(s.contains(static_cast(1000))); } TEST(CapabilitySet, ConstructSingleMemberMaxOverflow) { // Check the max 32-bit signed int. CapabilitySet s(static_cast(0x7fffffffu)); EXPECT_FALSE(s.contains(spv::Capability::Matrix)); EXPECT_FALSE(s.contains(spv::Capability::Shader)); EXPECT_FALSE(s.contains(static_cast(1000))); EXPECT_TRUE(s.contains(static_cast(0x7fffffffu))); } TEST(CapabilitySet, AddEnum) { CapabilitySet s(spv::Capability::Shader); s.insert(spv::Capability::Kernel); s.insert(static_cast(42)); EXPECT_FALSE(s.contains(spv::Capability::Matrix)); EXPECT_TRUE(s.contains(spv::Capability::Shader)); EXPECT_TRUE(s.contains(spv::Capability::Kernel)); EXPECT_TRUE(s.contains(static_cast(42))); } TEST(CapabilitySet, InsertReturnsIteratorToInserted) { CapabilitySet set; auto[it, inserted] = set.insert(spv::Capability::Kernel); EXPECT_TRUE(inserted); EXPECT_EQ(*it, spv::Capability::Kernel); } TEST(CapabilitySet, InsertReturnsIteratorToElementOnDoubleInsertion) { CapabilitySet set; EXPECT_FALSE(set.contains(spv::Capability::Shader)); { auto[it, inserted] = set.insert(spv::Capability::Shader); EXPECT_TRUE(inserted); EXPECT_EQ(*it, spv::Capability::Shader); } EXPECT_TRUE(set.contains(spv::Capability::Shader)); auto[it, inserted] = set.insert(spv::Capability::Shader); EXPECT_FALSE(inserted); EXPECT_EQ(*it, spv::Capability::Shader); EXPECT_TRUE(set.contains(spv::Capability::Shader)); } TEST(CapabilitySet, InsertWithHintWorks) { CapabilitySet set; EXPECT_FALSE(set.contains(spv::Capability::Shader)); auto it = set.insert(set.begin(), spv::Capability::Shader); EXPECT_EQ(*it, spv::Capability::Shader); EXPECT_TRUE(set.contains(spv::Capability::Shader)); } TEST(CapabilitySet, InsertWithEndHintWorks) { CapabilitySet set; EXPECT_FALSE(set.contains(spv::Capability::Shader)); auto it = set.insert(set.end(), spv::Capability::Shader); EXPECT_EQ(*it, spv::Capability::Shader); EXPECT_TRUE(set.contains(spv::Capability::Shader)); } TEST(CapabilitySet, IteratorCanBeCopied) { CapabilitySet set; set.insert(spv::Capability::Matrix); set.insert(spv::Capability::Shader); set.insert(spv::Capability::Geometry); set.insert(spv::Capability::Float64); set.insert(spv::Capability::Float16); auto a = set.begin(); ++a; auto b = a; EXPECT_EQ(*b, *a); ++b; EXPECT_NE(*b, *a); ++a; EXPECT_EQ(*b, *a); ++a; EXPECT_NE(*b, *a); } TEST(CapabilitySet, IteratorBeginToEndPostfix) { auto orderedValues = enumerateValuesFromToWithStep(0, 100, /* step= */ 1); auto set = createSetUnorderedInsertion(orderedValues); size_t index = 0; for (auto it = set.cbegin(); it != set.cend(); it++, index++) { EXPECT_EQ(*it, orderedValues[index]); } } TEST(CapabilitySet, IteratorBeginToEndPrefix) { auto orderedValues = enumerateValuesFromToWithStep(0, 100, /* step= */ 1); auto set = createSetUnorderedInsertion(orderedValues); size_t index = 0; for (auto it = set.cbegin(); it != set.cend(); ++it, index++) { EXPECT_EQ(*it, orderedValues[index]); } } TEST(CapabilitySet, IteratorBeginToEndPrefixStep) { auto orderedValues = enumerateValuesFromToWithStep(0, 100, /* step= */ 8); auto set = createSetUnorderedInsertion(orderedValues); size_t index = 0; for (auto it = set.cbegin(); it != set.cend(); ++it, index++) { ASSERT_EQ(*it, orderedValues[index]); } } TEST(CapabilitySet, IteratorBeginOnEmpty) { CapabilitySet set; auto begin = set.begin(); auto end = set.end(); ASSERT_EQ(begin, end); } TEST(CapabilitySet, IteratorBeginOnSingleNonZeroValue) { CapabilitySet set; set.insert(spv::Capability::Shader); auto begin = set.begin(); auto end = set.end(); ASSERT_NE(begin, end); ASSERT_EQ(*begin, spv::Capability::Shader); } TEST(CapabilitySet, IteratorForLoopNonZeroValue) { CapabilitySet set; set.insert(spv::Capability::Shader); set.insert(spv::Capability::Tessellation); auto begin = set.begin(); auto end = set.end(); ASSERT_NE(begin, end); ASSERT_EQ(*begin, spv::Capability::Shader); begin++; ASSERT_NE(begin, end); ASSERT_EQ(*begin, spv::Capability::Tessellation); begin++; ASSERT_EQ(begin, end); } TEST(CapabilitySet, IteratorPastEnd) { CapabilitySet set; set.insert(spv::Capability::Shader); auto begin = set.begin(); auto end = set.end(); ASSERT_NE(begin, end); ASSERT_EQ(*begin, spv::Capability::Shader); begin++; ASSERT_EQ(begin, end); begin++; ASSERT_EQ(begin, end); } TEST(CapabilitySet, CompatibleWithSTLFind) { CapabilitySet set; set.insert(spv::Capability::Matrix); set.insert(spv::Capability::Shader); set.insert(spv::Capability::Geometry); set.insert(spv::Capability::Tessellation); set.insert(spv::Capability::Addresses); set.insert(spv::Capability::Linkage); set.insert(spv::Capability::Kernel); set.insert(spv::Capability::Vector16); set.insert(spv::Capability::Float16Buffer); set.insert(spv::Capability::Float64); { auto it = std::find(set.cbegin(), set.cend(), spv::Capability::Vector16); ASSERT_NE(it, set.end()); ASSERT_EQ(*it, spv::Capability::Vector16); } { auto it = std::find(set.cbegin(), set.cend(), spv::Capability::Float16); ASSERT_EQ(it, set.end()); } } TEST(CapabilitySet, CompatibleWithSTLForEach) { auto orderedValues = enumerateValuesFromToWithStep(0, 100, /* step= */ 15); auto set = createSetUnorderedInsertion(orderedValues); size_t index = 0; std::for_each(set.cbegin(), set.cend(), [&](auto item) { ASSERT_EQ(item, orderedValues[index]); index++; }); } TEST(CapabilitySet, InitializerListEmpty) { CapabilitySet s{}; for (uint32_t i = 0; i < 1000; i++) { EXPECT_FALSE(s.contains(static_cast(i))); } } TEST(CapabilitySet, LargeSetHasInsertedElements) { CapabilitySet set; for (auto c : kCapabilities) { EXPECT_FALSE(set.contains(c)); } for (auto c : kCapabilities) { set.insert(c); EXPECT_TRUE(set.contains(c)); } for (auto c : kCapabilities) { EXPECT_TRUE(set.contains(c)); } } TEST(CapabilitySet, LargeSetHasUnsortedInsertedElements) { std::vector shuffledCapabilities(kCapabilities.cbegin(), kCapabilities.cend()); std::mt19937 rng(0); std::shuffle(shuffledCapabilities.begin(), shuffledCapabilities.end(), rng); CapabilitySet set; for (auto c : shuffledCapabilities) { EXPECT_FALSE(set.contains(c)); } for (auto c : shuffledCapabilities) { set.insert(c); EXPECT_TRUE(set.contains(c)); } for (auto c : shuffledCapabilities) { EXPECT_TRUE(set.contains(c)); } } TEST(CapabilitySet, LargeSetHasUnsortedRemovedElement) { std::vector shuffledCapabilities(kCapabilities.cbegin(), kCapabilities.cend()); std::mt19937 rng(0); std::shuffle(shuffledCapabilities.begin(), shuffledCapabilities.end(), rng); CapabilitySet set; for (auto c : shuffledCapabilities) { set.insert(c); EXPECT_TRUE(set.contains(c)); } for (auto c : kCapabilities) { set.erase(c); } for (auto c : shuffledCapabilities) { EXPECT_FALSE(set.contains(c)); } } struct ForEachCase { CapabilitySet capabilities; std::vector expected; }; using CapabilitySetForEachTest = ::testing::TestWithParam; TEST_P(CapabilitySetForEachTest, CallsAsExpected) { EXPECT_THAT(ElementsIn(GetParam().capabilities), Eq(GetParam().expected)); } TEST_P(CapabilitySetForEachTest, CopyConstructor) { CapabilitySet copy(GetParam().capabilities); EXPECT_THAT(ElementsIn(copy), Eq(GetParam().expected)); } TEST_P(CapabilitySetForEachTest, MoveConstructor) { // We need a writable copy to move from. CapabilitySet copy(GetParam().capabilities); CapabilitySet moved(std::move(copy)); EXPECT_THAT(ElementsIn(moved), Eq(GetParam().expected)); } TEST_P(CapabilitySetForEachTest, OperatorEquals) { CapabilitySet assigned = GetParam().capabilities; EXPECT_THAT(ElementsIn(assigned), Eq(GetParam().expected)); } TEST_P(CapabilitySetForEachTest, OperatorEqualsSelfAssign) { CapabilitySet assigned{GetParam().capabilities}; assigned = assigned; // NOLINT EXPECT_THAT(ElementsIn(assigned), Eq(GetParam().expected)); } INSTANTIATE_TEST_SUITE_P( Samples, CapabilitySetForEachTest, ValuesIn(std::vector{ {{}, {}}, {{spv::Capability::Matrix}, {spv::Capability::Matrix}}, {{spv::Capability::Kernel, spv::Capability::Shader}, {spv::Capability::Shader, spv::Capability::Kernel}}, {{static_cast(999)}, {static_cast(999)}}, {{static_cast(0x7fffffff)}, {static_cast(0x7fffffff)}}, // Mixture and out of order {{static_cast(0x7fffffff), static_cast(100), spv::Capability::Shader, spv::Capability::Matrix}, {spv::Capability::Matrix, spv::Capability::Shader, static_cast(100), static_cast(0x7fffffff)}}, })); using BoundaryTestWithParam = ::testing::TestWithParam; TEST_P(BoundaryTestWithParam, InsertedContains) { CapabilitySet set; set.insert(GetParam()); EXPECT_TRUE(set.contains(GetParam())); } INSTANTIATE_TEST_SUITE_P( Samples, BoundaryTestWithParam, Values(static_cast(0), static_cast(63), static_cast(64), static_cast(65), static_cast(127), static_cast(128), static_cast(129))); } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/enum_string_mapping_test.cpp000066400000000000000000000232301475742701700253200ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights // reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Tests for OpExtension validator rules. #include #include #include #include "gtest/gtest.h" #include "source/enum_string_mapping.h" #include "source/extensions.h" namespace spvtools { namespace { using ::testing::Values; using ::testing::ValuesIn; using ExtensionTest = ::testing::TestWithParam>; using UnknownExtensionTest = ::testing::TestWithParam; using CapabilityTest = ::testing::TestWithParam>; TEST_P(ExtensionTest, TestExtensionFromString) { const std::pair& param = GetParam(); const Extension extension = param.first; const std::string extension_str = param.second; Extension result_extension; ASSERT_TRUE(GetExtensionFromString(extension_str.c_str(), &result_extension)); EXPECT_EQ(extension, result_extension); } TEST_P(ExtensionTest, TestExtensionToString) { const std::pair& param = GetParam(); const Extension extension = param.first; const std::string extension_str = param.second; const std::string result_str = ExtensionToString(extension); EXPECT_EQ(extension_str, result_str); } TEST_P(UnknownExtensionTest, TestExtensionFromStringFails) { Extension result_extension; ASSERT_FALSE(GetExtensionFromString(GetParam().c_str(), &result_extension)); } TEST_P(CapabilityTest, TestCapabilityToString) { const std::pair& param = GetParam(); const spv::Capability capability = param.first; const std::string capability_str = param.second; const std::string result_str = CapabilityToString(capability); EXPECT_EQ(capability_str, result_str); } INSTANTIATE_TEST_SUITE_P( AllExtensions, ExtensionTest, ValuesIn(std::vector>({ {Extension::kSPV_KHR_16bit_storage, "SPV_KHR_16bit_storage"}, {Extension::kSPV_KHR_device_group, "SPV_KHR_device_group"}, {Extension::kSPV_KHR_multiview, "SPV_KHR_multiview"}, {Extension::kSPV_KHR_shader_ballot, "SPV_KHR_shader_ballot"}, {Extension::kSPV_KHR_shader_draw_parameters, "SPV_KHR_shader_draw_parameters"}, {Extension::kSPV_KHR_subgroup_vote, "SPV_KHR_subgroup_vote"}, {Extension::kSPV_NVX_multiview_per_view_attributes, "SPV_NVX_multiview_per_view_attributes"}, {Extension::kSPV_NV_geometry_shader_passthrough, "SPV_NV_geometry_shader_passthrough"}, {Extension::kSPV_NV_sample_mask_override_coverage, "SPV_NV_sample_mask_override_coverage"}, {Extension::kSPV_NV_stereo_view_rendering, "SPV_NV_stereo_view_rendering"}, {Extension::kSPV_NV_viewport_array2, "SPV_NV_viewport_array2"}, {Extension::kSPV_GOOGLE_decorate_string, "SPV_GOOGLE_decorate_string"}, {Extension::kSPV_GOOGLE_hlsl_functionality1, "SPV_GOOGLE_hlsl_functionality1"}, {Extension::kSPV_KHR_8bit_storage, "SPV_KHR_8bit_storage"}, }))); INSTANTIATE_TEST_SUITE_P(UnknownExtensions, UnknownExtensionTest, Values("", "SPV_KHR_", "SPV_KHR_device_group_ERROR", /*alphabetically before all extensions*/ "A", /*alphabetically after all extensions*/ "Z", "SPV_ERROR_random_string_hfsdklhlktherh")); INSTANTIATE_TEST_SUITE_P( AllCapabilities, CapabilityTest, ValuesIn(std::vector>( {{spv::Capability::Matrix, "Matrix"}, {spv::Capability::Shader, "Shader"}, {spv::Capability::Geometry, "Geometry"}, {spv::Capability::Tessellation, "Tessellation"}, {spv::Capability::Addresses, "Addresses"}, {spv::Capability::Linkage, "Linkage"}, {spv::Capability::Kernel, "Kernel"}, {spv::Capability::Vector16, "Vector16"}, {spv::Capability::Float16Buffer, "Float16Buffer"}, {spv::Capability::Float16, "Float16"}, {spv::Capability::Float64, "Float64"}, {spv::Capability::Int64, "Int64"}, {spv::Capability::Int64Atomics, "Int64Atomics"}, {spv::Capability::ImageBasic, "ImageBasic"}, {spv::Capability::ImageReadWrite, "ImageReadWrite"}, {spv::Capability::ImageMipmap, "ImageMipmap"}, {spv::Capability::Pipes, "Pipes"}, {spv::Capability::Groups, "Groups"}, {spv::Capability::DeviceEnqueue, "DeviceEnqueue"}, {spv::Capability::LiteralSampler, "LiteralSampler"}, {spv::Capability::AtomicStorage, "AtomicStorage"}, {spv::Capability::Int16, "Int16"}, {spv::Capability::TessellationPointSize, "TessellationPointSize"}, {spv::Capability::GeometryPointSize, "GeometryPointSize"}, {spv::Capability::ImageGatherExtended, "ImageGatherExtended"}, {spv::Capability::StorageImageMultisample, "StorageImageMultisample"}, {spv::Capability::UniformBufferArrayDynamicIndexing, "UniformBufferArrayDynamicIndexing"}, {spv::Capability::SampledImageArrayDynamicIndexing, "SampledImageArrayDynamicIndexing"}, {spv::Capability::StorageBufferArrayDynamicIndexing, "StorageBufferArrayDynamicIndexing"}, {spv::Capability::StorageImageArrayDynamicIndexing, "StorageImageArrayDynamicIndexing"}, {spv::Capability::ClipDistance, "ClipDistance"}, {spv::Capability::CullDistance, "CullDistance"}, {spv::Capability::ImageCubeArray, "ImageCubeArray"}, {spv::Capability::SampleRateShading, "SampleRateShading"}, {spv::Capability::ImageRect, "ImageRect"}, {spv::Capability::SampledRect, "SampledRect"}, {spv::Capability::GenericPointer, "GenericPointer"}, {spv::Capability::Int8, "Int8"}, {spv::Capability::InputAttachment, "InputAttachment"}, {spv::Capability::SparseResidency, "SparseResidency"}, {spv::Capability::MinLod, "MinLod"}, {spv::Capability::Sampled1D, "Sampled1D"}, {spv::Capability::Image1D, "Image1D"}, {spv::Capability::SampledCubeArray, "SampledCubeArray"}, {spv::Capability::SampledBuffer, "SampledBuffer"}, {spv::Capability::ImageBuffer, "ImageBuffer"}, {spv::Capability::ImageMSArray, "ImageMSArray"}, {spv::Capability::StorageImageExtendedFormats, "StorageImageExtendedFormats"}, {spv::Capability::ImageQuery, "ImageQuery"}, {spv::Capability::DerivativeControl, "DerivativeControl"}, {spv::Capability::InterpolationFunction, "InterpolationFunction"}, {spv::Capability::TransformFeedback, "TransformFeedback"}, {spv::Capability::GeometryStreams, "GeometryStreams"}, {spv::Capability::StorageImageReadWithoutFormat, "StorageImageReadWithoutFormat"}, {spv::Capability::StorageImageWriteWithoutFormat, "StorageImageWriteWithoutFormat"}, {spv::Capability::MultiViewport, "MultiViewport"}, {spv::Capability::SubgroupDispatch, "SubgroupDispatch"}, {spv::Capability::NamedBarrier, "NamedBarrier"}, {spv::Capability::PipeStorage, "PipeStorage"}, {spv::Capability::SubgroupBallotKHR, "SubgroupBallotKHR"}, {spv::Capability::DrawParameters, "DrawParameters"}, {spv::Capability::SubgroupVoteKHR, "SubgroupVoteKHR"}, {spv::Capability::StorageBuffer16BitAccess, "StorageBuffer16BitAccess"}, {spv::Capability::StorageUniformBufferBlock16, "StorageBuffer16BitAccess"}, // Preferred name {spv::Capability::UniformAndStorageBuffer16BitAccess, "UniformAndStorageBuffer16BitAccess"}, {spv::Capability::StorageUniform16, "UniformAndStorageBuffer16BitAccess"}, // Preferred name {spv::Capability::StoragePushConstant16, "StoragePushConstant16"}, {spv::Capability::StorageInputOutput16, "StorageInputOutput16"}, {spv::Capability::DeviceGroup, "DeviceGroup"}, {spv::Capability::AtomicFloat32AddEXT, "AtomicFloat32AddEXT"}, {spv::Capability::AtomicFloat64AddEXT, "AtomicFloat64AddEXT"}, {spv::Capability::AtomicFloat32MinMaxEXT, "AtomicFloat32MinMaxEXT"}, {spv::Capability::AtomicFloat64MinMaxEXT, "AtomicFloat64MinMaxEXT"}, {spv::Capability::MultiView, "MultiView"}, {spv::Capability::Int64ImageEXT, "Int64ImageEXT"}, {spv::Capability::SampleMaskOverrideCoverageNV, "SampleMaskOverrideCoverageNV"}, {spv::Capability::GeometryShaderPassthroughNV, "GeometryShaderPassthroughNV"}, // The next two are different names for the same token. {spv::Capability::ShaderViewportIndexLayerNV, "ShaderViewportIndexLayerEXT"}, {spv::Capability::ShaderViewportIndexLayerEXT, "ShaderViewportIndexLayerEXT"}, {spv::Capability::ShaderViewportMaskNV, "ShaderViewportMaskNV"}, {spv::Capability::ShaderStereoViewNV, "ShaderStereoViewNV"}, {spv::Capability::PerViewAttributesNV, "PerViewAttributesNV"}}))); } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/ext_inst.cldebug100_test.cpp000066400000000000000000001423541475742701700247460ustar00rootroot00000000000000// Copyright (c) 2017-2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "OpenCLDebugInfo100.h" #include "gmock/gmock.h" #include "source/util/string_utils.h" #include "test/test_fixture.h" #include "test/unit_spirv.h" // This file tests the correctness of encoding and decoding of instructions // involving the OpenCL.DebugInfo.100 extended instruction set. // Validation is not checked here. namespace spvtools { namespace { using spvtest::Concatenate; using spvtest::MakeInstruction; using testing::Eq; using utils::MakeVector; // Test values of enums vs. what is written in the spec. TEST(ExtInstCLDebugInfo, InstructionValues) { EXPECT_EQ(0, OpenCLDebugInfo100DebugInfoNone); EXPECT_EQ(1, OpenCLDebugInfo100DebugCompilationUnit); EXPECT_EQ(2, OpenCLDebugInfo100DebugTypeBasic); EXPECT_EQ(3, OpenCLDebugInfo100DebugTypePointer); EXPECT_EQ(4, OpenCLDebugInfo100DebugTypeQualifier); EXPECT_EQ(5, OpenCLDebugInfo100DebugTypeArray); EXPECT_EQ(6, OpenCLDebugInfo100DebugTypeVector); EXPECT_EQ(7, OpenCLDebugInfo100DebugTypedef); EXPECT_EQ(8, OpenCLDebugInfo100DebugTypeFunction); EXPECT_EQ(9, OpenCLDebugInfo100DebugTypeEnum); EXPECT_EQ(10, OpenCLDebugInfo100DebugTypeComposite); EXPECT_EQ(11, OpenCLDebugInfo100DebugTypeMember); EXPECT_EQ(12, OpenCLDebugInfo100DebugTypeInheritance); EXPECT_EQ(13, OpenCLDebugInfo100DebugTypePtrToMember); EXPECT_EQ(14, OpenCLDebugInfo100DebugTypeTemplate); EXPECT_EQ(15, OpenCLDebugInfo100DebugTypeTemplateParameter); EXPECT_EQ(16, OpenCLDebugInfo100DebugTypeTemplateTemplateParameter); EXPECT_EQ(17, OpenCLDebugInfo100DebugTypeTemplateParameterPack); EXPECT_EQ(18, OpenCLDebugInfo100DebugGlobalVariable); EXPECT_EQ(19, OpenCLDebugInfo100DebugFunctionDeclaration); EXPECT_EQ(20, OpenCLDebugInfo100DebugFunction); EXPECT_EQ(21, OpenCLDebugInfo100DebugLexicalBlock); EXPECT_EQ(22, OpenCLDebugInfo100DebugLexicalBlockDiscriminator); EXPECT_EQ(23, OpenCLDebugInfo100DebugScope); EXPECT_EQ(24, OpenCLDebugInfo100DebugNoScope); EXPECT_EQ(25, OpenCLDebugInfo100DebugInlinedAt); EXPECT_EQ(26, OpenCLDebugInfo100DebugLocalVariable); EXPECT_EQ(27, OpenCLDebugInfo100DebugInlinedVariable); EXPECT_EQ(28, OpenCLDebugInfo100DebugDeclare); EXPECT_EQ(29, OpenCLDebugInfo100DebugValue); EXPECT_EQ(30, OpenCLDebugInfo100DebugOperation); EXPECT_EQ(31, OpenCLDebugInfo100DebugExpression); EXPECT_EQ(32, OpenCLDebugInfo100DebugMacroDef); EXPECT_EQ(33, OpenCLDebugInfo100DebugMacroUndef); EXPECT_EQ(34, OpenCLDebugInfo100DebugImportedEntity); EXPECT_EQ(35, OpenCLDebugInfo100DebugSource); } TEST(ExtInstCLDebugInfo, InfoFlagValues) { EXPECT_EQ(1 << 0, OpenCLDebugInfo100FlagIsProtected); EXPECT_EQ(1 << 1, OpenCLDebugInfo100FlagIsPrivate); EXPECT_EQ(((1 << 0) | (1 << 1)), OpenCLDebugInfo100FlagIsPublic); EXPECT_EQ(1 << 2, OpenCLDebugInfo100FlagIsLocal); EXPECT_EQ(1 << 3, OpenCLDebugInfo100FlagIsDefinition); EXPECT_EQ(1 << 4, OpenCLDebugInfo100FlagFwdDecl); EXPECT_EQ(1 << 5, OpenCLDebugInfo100FlagArtificial); EXPECT_EQ(1 << 6, OpenCLDebugInfo100FlagExplicit); EXPECT_EQ(1 << 7, OpenCLDebugInfo100FlagPrototyped); EXPECT_EQ(1 << 8, OpenCLDebugInfo100FlagObjectPointer); EXPECT_EQ(1 << 9, OpenCLDebugInfo100FlagStaticMember); EXPECT_EQ(1 << 10, OpenCLDebugInfo100FlagIndirectVariable); EXPECT_EQ(1 << 11, OpenCLDebugInfo100FlagLValueReference); EXPECT_EQ(1 << 12, OpenCLDebugInfo100FlagRValueReference); EXPECT_EQ(1 << 13, OpenCLDebugInfo100FlagIsOptimized); EXPECT_EQ(1 << 14, OpenCLDebugInfo100FlagIsEnumClass); EXPECT_EQ(1 << 15, OpenCLDebugInfo100FlagTypePassByValue); EXPECT_EQ(1 << 16, OpenCLDebugInfo100FlagTypePassByReference); } TEST(ExtInstCLDebugInfo, BaseTypeAttributeEndodingValues) { EXPECT_EQ(0, OpenCLDebugInfo100Unspecified); EXPECT_EQ(1, OpenCLDebugInfo100Address); EXPECT_EQ(2, OpenCLDebugInfo100Boolean); EXPECT_EQ(3, OpenCLDebugInfo100Float); EXPECT_EQ(4, OpenCLDebugInfo100Signed); EXPECT_EQ(5, OpenCLDebugInfo100SignedChar); EXPECT_EQ(6, OpenCLDebugInfo100Unsigned); EXPECT_EQ(7, OpenCLDebugInfo100UnsignedChar); } TEST(ExtInstCLDebugInfo, CompositeTypeValues) { EXPECT_EQ(0, OpenCLDebugInfo100Class); EXPECT_EQ(1, OpenCLDebugInfo100Structure); EXPECT_EQ(2, OpenCLDebugInfo100Union); } TEST(ExtInstCLDebugInfo, TypeQualifierValues) { EXPECT_EQ(0, OpenCLDebugInfo100ConstType); EXPECT_EQ(1, OpenCLDebugInfo100VolatileType); EXPECT_EQ(2, OpenCLDebugInfo100RestrictType); EXPECT_EQ(3, OpenCLDebugInfo100AtomicType); } TEST(ExtInstCLDebugInfo, DebugOperationValues) { EXPECT_EQ(0, OpenCLDebugInfo100Deref); EXPECT_EQ(1, OpenCLDebugInfo100Plus); EXPECT_EQ(2, OpenCLDebugInfo100Minus); EXPECT_EQ(3, OpenCLDebugInfo100PlusUconst); EXPECT_EQ(4, OpenCLDebugInfo100BitPiece); EXPECT_EQ(5, OpenCLDebugInfo100Swap); EXPECT_EQ(6, OpenCLDebugInfo100Xderef); EXPECT_EQ(7, OpenCLDebugInfo100StackValue); EXPECT_EQ(8, OpenCLDebugInfo100Constu); EXPECT_EQ(9, OpenCLDebugInfo100Fragment); } TEST(ExtInstCLDebugInfo, ImportedEntityValues) { EXPECT_EQ(0, OpenCLDebugInfo100ImportedModule); EXPECT_EQ(1, OpenCLDebugInfo100ImportedDeclaration); } // Test round trip through assembler and disassembler. struct InstructionCase { uint32_t opcode; std::string name; std::string operands; std::vector expected_operands; }; using ExtInstCLDebugInfo100RoundTripTest = spvtest::TextToBinaryTestBase<::testing::TestWithParam>; using ExtInstCLDebugInfo100RoundTripTestExplicit = spvtest::TextToBinaryTest; TEST_P(ExtInstCLDebugInfo100RoundTripTest, ParameterizedExtInst) { const std::string input = "%1 = OpExtInstImport \"OpenCL.DebugInfo.100\"\n" "%3 = OpExtInst %2 %1 " + GetParam().name + GetParam().operands + "\n"; // First make sure it assembles correctly. std::cout << input << std::endl; EXPECT_THAT( CompiledInstructions(input), Eq(Concatenate( {MakeInstruction(spv::Op::OpExtInstImport, {1}, MakeVector("OpenCL.DebugInfo.100")), MakeInstruction(spv::Op::OpExtInst, {2, 3, 1, GetParam().opcode}, GetParam().expected_operands)}))) << input; // Now check the round trip through the disassembler. EXPECT_THAT(EncodeAndDecodeSuccessfully(input), input) << input; } #define EPREFIX "Debug" #define CASE_0(Enum) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, "", {} \ } #define CASE_ILL(Enum, L0, L1) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, \ " %4 " #L0 " " #L1, { \ 4, L0, L1 \ } \ } #define CASE_IL(Enum, L0) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, " %4 " #L0, { \ 4, L0 \ } \ } #define CASE_I(Enum) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, " %4", { 4 } \ } #define CASE_II(Enum) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, " %4 %5", { 4, 5 } \ } #define CASE_III(Enum) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, " %4 %5 %6", { \ 4, 5, 6 \ } \ } #define CASE_IIII(Enum) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, " %4 %5 %6 %7", { \ 4, 5, 6, 7 \ } \ } #define CASE_IIIII(Enum) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, " %4 %5 %6 %7 %8", \ { \ 4, 5, 6, 7, 8 \ } \ } #define CASE_IIIIII(Enum) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, \ " %4 %5 %6 %7 %8 %9", { \ 4, 5, 6, 7, 8, 9 \ } \ } #define CASE_IIIIIII(Enum) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, \ " %4 %5 %6 %7 %8 %9 %10", { \ 4, 5, 6, 7, 8, 9, 10 \ } \ } #define CASE_IIILLI(Enum, L0, L1) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, \ " %4 %5 %6 " #L0 " " #L1 " %7", { \ 4, 5, 6, L0, L1, 7 \ } \ } #define CASE_IIILLIF(Enum, L0, L1, Fstr, Fnum) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, \ " %4 %5 %6 " #L0 " " #L1 " %7 " Fstr, { \ 4, 5, 6, L0, L1, 7, Fnum \ } \ } #define CASE_IIILLIFL(Enum, L0, L1, Fstr, Fnum, L2) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, \ " %4 %5 %6 " #L0 " " #L1 " %7 " Fstr " " #L2, { \ 4, 5, 6, L0, L1, 7, Fnum, L2 \ } \ } #define CASE_IIILLIL(Enum, L0, L1, L2) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, \ " %4 %5 %6 " #L0 " " #L1 " %7 " #L2, { \ 4, 5, 6, L0, L1, 7, L2 \ } \ } #define CASE_IE(Enum, E0) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, " %4 " #E0, { \ 4, uint32_t(OpenCLDebugInfo100##E0) \ } \ } #define CASE_IEIILLI(Enum, E0, L1, L2) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, \ " %4 " #E0 " %5 %6 " #L1 " " #L2 " %7", { \ 4, uint32_t(OpenCLDebugInfo100##E0), 5, 6, L1, L2, 7 \ } \ } #define CASE_IIE(Enum, E0) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, " %4 %5 " #E0, { \ 4, 5, uint32_t(OpenCLDebugInfo100##E0) \ } \ } #define CASE_ISF(Enum, S0, Fstr, Fnum) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, \ " %4 " #S0 " " Fstr, { \ 4, uint32_t(spv::StorageClass::S0), Fnum \ } \ } #define CASE_LII(Enum, L0) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, " " #L0 " %4 %5", \ { \ L0, 4, 5 \ } \ } #define CASE_LLIe(Enum, L0, L1, RawEnumName, RawEnumValue) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, \ " " #L0 " " #L1 " %4 " RawEnumName, { \ L0, L1, 4, (uint32_t)RawEnumValue \ } \ } #define CASE_ILI(Enum, L0) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, " %4 " #L0 " %5", \ { \ 4, L0, 5 \ } \ } #define CASE_ILII(Enum, L0) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, \ " %4 " #L0 " %5 %6", { \ 4, L0, 5, 6 \ } \ } #define CASE_ILLII(Enum, L0, L1) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, \ " %4 " #L0 " " #L1 " %5 %6", { \ 4, L0, L1, 5, 6 \ } \ } #define CASE_IIILLIIF(Enum, L0, L1, Fstr, Fnum) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, \ " %4 %5 %6 " #L0 " " #L1 " %7 %8 " Fstr, { \ 4, 5, 6, L0, L1, 7, 8, Fnum \ } \ } #define CASE_IIILLIIFII(Enum, L0, L1, Fstr, Fnum) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, \ " %4 %5 %6 " #L0 " " #L1 " %7 %8 " Fstr " %9 %10", { \ 4, 5, 6, L0, L1, 7, 8, Fnum, 9, 10 \ } \ } #define CASE_IIILLIIFIIII(Enum, L0, L1, Fstr, Fnum) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, \ " %4 %5 %6 " #L0 " " #L1 " %7 %8 " Fstr " %9 %10 %11 %12", { \ 4, 5, 6, L0, L1, 7, 8, Fnum, 9, 10, 11, 12 \ } \ } #define CASE_IIILLIIFIIIIII(Enum, L0, L1, Fstr, Fnum) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, \ " %4 %5 %6 " #L0 " " #L1 " %7 %8 " Fstr " %9 %10 %11 %12 %13 %14", { \ 4, 5, 6, L0, L1, 7, 8, Fnum, 9, 10, 11, 12, 13, 14 \ } \ } #define CASE_IEILLIIIF(Enum, E0, L0, L1, Fstr, Fnum) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, \ " %4 " #E0 " %5 " #L0 " " #L1 " %6 %7 %8 " Fstr, { \ 4, uint32_t(OpenCLDebugInfo100##E0), 5, L0, L1, 6, 7, 8, Fnum \ } \ } #define CASE_IEILLIIIFI(Enum, E0, L0, L1, Fstr, Fnum) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, \ " %4 " #E0 " %5 " #L0 " " #L1 " %6 %7 %8 " Fstr " %9", { \ 4, uint32_t(OpenCLDebugInfo100##E0), 5, L0, L1, 6, 7, 8, Fnum, 9 \ } \ } #define CASE_IEILLIIIFII(Enum, E0, L0, L1, Fstr, Fnum) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, \ " %4 " #E0 " %5 " #L0 " " #L1 " %6 %7 %8 " Fstr " %9 %10", { \ 4, uint32_t(OpenCLDebugInfo100##E0), 5, L0, L1, 6, 7, 8, Fnum, 9, 10 \ } \ } #define CASE_IEILLIIIFIII(Enum, E0, L0, L1, Fstr, Fnum) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, \ " %4 " #E0 " %5 " #L0 " " #L1 " %6 %7 %8 " Fstr " %9 %10 %11", { \ 4, uint32_t(OpenCLDebugInfo100##E0), 5, L0, L1, 6, 7, 8, Fnum, 9, 10, 11 \ } \ } #define CASE_IEILLIIIFIIII(Enum, E0, L0, L1, Fstr, Fnum) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, \ " %4 " #E0 " %5 " #L0 " " #L1 " %6 %7 %8 " Fstr " %9 %10 %11 %12", { \ 4, uint32_t(OpenCLDebugInfo100##E0), 5, L0, L1, 6, 7, 8, Fnum, 9, 10, \ 11, 12 \ } \ } #define CASE_IIILLIIIF(Enum, L0, L1, Fstr, Fnum) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, \ " %4 %5 %6 " #L0 " " #L1 " %7 %8 %9 " Fstr, { \ 4, 5, 6, L0, L1, 7, 8, 9, Fnum \ } \ } #define CASE_IIILLIIIFI(Enum, L0, L1, Fstr, Fnum) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, \ " %4 %5 %6 " #L0 " " #L1 " %7 %8 %9 " Fstr " %10", { \ 4, 5, 6, L0, L1, 7, 8, 9, Fnum, 10 \ } \ } #define CASE_IIIIF(Enum, Fstr, Fnum) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, \ " %4 %5 %6 %7 " Fstr, { \ 4, 5, 6, 7, Fnum \ } \ } #define CASE_IIILL(Enum, L0, L1) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, \ " %4 %5 %6 " #L0 " " #L1, { \ 4, 5, 6, L0, L1 \ } \ } #define CASE_IIIILL(Enum, L0, L1) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, \ " %4 %5 %6 %7 " #L0 " " #L1, { \ 4, 5, 6, 7, L0, L1 \ } \ } #define CASE_IILLI(Enum, L0, L1) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, \ " %4 %5 " #L0 " " #L1 " %6", { \ 4, 5, L0, L1, 6 \ } \ } #define CASE_IILLII(Enum, L0, L1) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, \ " %4 %5 " #L0 " " #L1 " %6 %7", { \ 4, 5, L0, L1, 6, 7 \ } \ } #define CASE_IILLIII(Enum, L0, L1) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, \ " %4 %5 " #L0 " " #L1 " %6 %7 %8", { \ 4, 5, L0, L1, 6, 7, 8 \ } \ } #define CASE_IILLIIII(Enum, L0, L1) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, \ " %4 %5 " #L0 " " #L1 " %6 %7 %8 %9", { \ 4, 5, L0, L1, 6, 7, 8, 9 \ } \ } #define CASE_IIILLIIFLI(Enum, L0, L1, Fstr, Fnum, L2) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, \ " %4 %5 %6 " #L0 " " #L1 " %7 %8 " Fstr " " #L2 " %9", { \ 4, 5, 6, L0, L1, 7, 8, Fnum, L2, 9 \ } \ } #define CASE_IIILLIIFLII(Enum, L0, L1, Fstr, Fnum, L2) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, \ " %4 %5 %6 " #L0 " " #L1 " %7 %8 " Fstr " " #L2 " %9 %10", { \ 4, 5, 6, L0, L1, 7, 8, Fnum, L2, 9, 10 \ } \ } #define CASE_E(Enum, E0) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, " " #E0, { \ uint32_t(OpenCLDebugInfo100##E0) \ } \ } #define CASE_EI(Enum, E0) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, " " #E0 " %4", { \ uint32_t(OpenCLDebugInfo100##E0), 4 \ } \ } #define CASE_EII(Enum, E0) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, " " #E0 " %4 %5", \ { \ uint32_t(OpenCLDebugInfo100##E0), 4, 5 \ } \ } #define CASE_EIII(Enum, E0) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, \ " " #E0 " %4 %5 %6", { \ uint32_t(OpenCLDebugInfo100##E0), 4, 5, 6 \ } \ } #define CASE_EIIII(Enum, E0) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, \ " " #E0 " %4 %5 %6 %7", { \ uint32_t(OpenCLDebugInfo100##E0), 4, 5, 6, 7 \ } \ } #define CASE_EIIIII(Enum, E0) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, \ " " #E0 " %4 %5 %6 %7 %8", { \ uint32_t(OpenCLDebugInfo100##E0), 4, 5, 6, 7, 8 \ } \ } #define CASE_EL(Enum, E0, L0) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, " " #E0 " " #L0, { \ uint32_t(OpenCLDebugInfo100##E0), L0 \ } \ } #define CASE_ELL(Enum, E0, L0, L1) \ { \ uint32_t(OpenCLDebugInfo100Debug##Enum), EPREFIX #Enum, \ " " #E0 " " #L0 " " #L1, { \ uint32_t(OpenCLDebugInfo100##E0), L0, L1 \ } \ } // OpenCL.DebugInfo.100 4.1 Missing Debugging Information INSTANTIATE_TEST_SUITE_P(OpenCLDebugInfo100DebugInfoNone, ExtInstCLDebugInfo100RoundTripTest, ::testing::ValuesIn(std::vector({ CASE_0(InfoNone), // enum value 0 }))); // OpenCL.DebugInfo.100 4.2 Compilation Unit INSTANTIATE_TEST_SUITE_P( OpenCLDebugInfo100DebugCompilationUnit, ExtInstCLDebugInfo100RoundTripTest, ::testing::ValuesIn(std::vector({ CASE_LLIe(CompilationUnit, 100, 42, "HLSL", spv::SourceLanguage::HLSL), }))); INSTANTIATE_TEST_SUITE_P( OpenCLDebugInfo100DebugSource, ExtInstCLDebugInfo100RoundTripTest, ::testing::ValuesIn(std::vector({ // TODO(dneto): Should this be a list of sourc texts, // to accommodate length limits? CASE_I(Source), CASE_II(Source), }))); // OpenCL.DebugInfo.100 4.3 Type instructions INSTANTIATE_TEST_SUITE_P(OpenCLDebugInfo100DebugTypeBasic, ExtInstCLDebugInfo100RoundTripTest, ::testing::ValuesIn(std::vector({ CASE_IIE(TypeBasic, Unspecified), CASE_IIE(TypeBasic, Address), CASE_IIE(TypeBasic, Boolean), CASE_IIE(TypeBasic, Float), CASE_IIE(TypeBasic, Signed), CASE_IIE(TypeBasic, SignedChar), CASE_IIE(TypeBasic, Unsigned), CASE_IIE(TypeBasic, UnsignedChar), }))); // The FlagIsPublic is value is (1 << 0) | (1 << 2) which is the same // as the bitwise-OR of FlagIsProtected and FlagIsPrivate. // The disassembler will emit the compound expression instead. // There is no simple fix for this. This enum is not really a mask // for the bottom two bits. TEST_F(ExtInstCLDebugInfo100RoundTripTestExplicit, FlagIsPublic) { const std::string prefix = "%1 = OpExtInstImport \"DebugInfo\"\n" "%3 = OpExtInst %2 %1 DebugTypePointer %4 Private "; const std::string input = prefix + "FlagIsPublic\n"; const std::string expected = prefix + "FlagIsProtected|FlagIsPrivate\n"; // First make sure it assembles correctly. EXPECT_THAT(CompiledInstructions(input), Eq(Concatenate( {MakeInstruction(spv::Op::OpExtInstImport, {1}, MakeVector("DebugInfo")), MakeInstruction(spv::Op::OpExtInst, {2, 3, 1, OpenCLDebugInfo100DebugTypePointer, 4, uint32_t(spv::StorageClass::Private), OpenCLDebugInfo100FlagIsPublic})}))) << input; // Now check the round trip through the disassembler. EXPECT_THAT(EncodeAndDecodeSuccessfully(input), Eq(expected)) << input; } INSTANTIATE_TEST_SUITE_P( OpenCLDebugInfo100DebugTypePointer, ExtInstCLDebugInfo100RoundTripTest, ::testing::ValuesIn(std::vector({ //// Use each flag independently. CASE_ISF(TypePointer, Private, "FlagIsProtected", uint32_t(OpenCLDebugInfo100FlagIsProtected)), CASE_ISF(TypePointer, Private, "FlagIsPrivate", uint32_t(OpenCLDebugInfo100FlagIsPrivate)), // FlagIsPublic is tested above. CASE_ISF(TypePointer, Private, "FlagIsLocal", uint32_t(OpenCLDebugInfo100FlagIsLocal)), CASE_ISF(TypePointer, Private, "FlagIsDefinition", uint32_t(OpenCLDebugInfo100FlagIsDefinition)), CASE_ISF(TypePointer, Private, "FlagFwdDecl", uint32_t(OpenCLDebugInfo100FlagFwdDecl)), CASE_ISF(TypePointer, Private, "FlagArtificial", uint32_t(OpenCLDebugInfo100FlagArtificial)), CASE_ISF(TypePointer, Private, "FlagExplicit", uint32_t(OpenCLDebugInfo100FlagExplicit)), CASE_ISF(TypePointer, Private, "FlagPrototyped", uint32_t(OpenCLDebugInfo100FlagPrototyped)), CASE_ISF(TypePointer, Private, "FlagObjectPointer", uint32_t(OpenCLDebugInfo100FlagObjectPointer)), CASE_ISF(TypePointer, Private, "FlagStaticMember", uint32_t(OpenCLDebugInfo100FlagStaticMember)), CASE_ISF(TypePointer, Private, "FlagIndirectVariable", uint32_t(OpenCLDebugInfo100FlagIndirectVariable)), CASE_ISF(TypePointer, Private, "FlagLValueReference", uint32_t(OpenCLDebugInfo100FlagLValueReference)), CASE_ISF(TypePointer, Private, "FlagIsOptimized", uint32_t(OpenCLDebugInfo100FlagIsOptimized)), CASE_ISF(TypePointer, Private, "FlagIsEnumClass", uint32_t(OpenCLDebugInfo100FlagIsEnumClass)), CASE_ISF(TypePointer, Private, "FlagTypePassByValue", uint32_t(OpenCLDebugInfo100FlagTypePassByValue)), CASE_ISF(TypePointer, Private, "FlagTypePassByReference", uint32_t(OpenCLDebugInfo100FlagTypePassByReference)), //// Use flags in combination, and try different storage classes. CASE_ISF(TypePointer, Function, "FlagIsProtected|FlagIsPrivate", uint32_t(OpenCLDebugInfo100FlagIsProtected) | uint32_t(OpenCLDebugInfo100FlagIsPrivate)), CASE_ISF( TypePointer, Workgroup, "FlagIsPrivate|FlagFwdDecl|FlagIndirectVariable|FlagIsOptimized", uint32_t(OpenCLDebugInfo100FlagIsPrivate) | uint32_t(OpenCLDebugInfo100FlagFwdDecl) | uint32_t(OpenCLDebugInfo100FlagIndirectVariable) | uint32_t(OpenCLDebugInfo100FlagIsOptimized)), }))); INSTANTIATE_TEST_SUITE_P(OpenCLDebugInfo100DebugTypeQualifier, ExtInstCLDebugInfo100RoundTripTest, ::testing::ValuesIn(std::vector({ CASE_IE(TypeQualifier, ConstType), CASE_IE(TypeQualifier, VolatileType), CASE_IE(TypeQualifier, RestrictType), CASE_IE(TypeQualifier, AtomicType), }))); INSTANTIATE_TEST_SUITE_P(OpenCLDebugInfo100DebugTypeArray, ExtInstCLDebugInfo100RoundTripTest, ::testing::ValuesIn(std::vector({ CASE_II(TypeArray), CASE_III(TypeArray), CASE_IIII(TypeArray), CASE_IIIII(TypeArray), }))); INSTANTIATE_TEST_SUITE_P(OpenCLDebugInfo100DebugTypeVector, ExtInstCLDebugInfo100RoundTripTest, ::testing::ValuesIn(std::vector({ CASE_IL(TypeVector, 2), CASE_IL(TypeVector, 3), CASE_IL(TypeVector, 4), CASE_IL(TypeVector, 16), }))); INSTANTIATE_TEST_SUITE_P(OpenCLDebugInfo100DebugTypedef, ExtInstCLDebugInfo100RoundTripTest, ::testing::ValuesIn(std::vector({ CASE_IIILLI(Typedef, 12, 13), CASE_IIILLI(Typedef, 14, 99), }))); INSTANTIATE_TEST_SUITE_P(OpenCLDebugInfo100DebugTypeFunction, ExtInstCLDebugInfo100RoundTripTest, ::testing::ValuesIn(std::vector({ CASE_EI(TypeFunction, FlagIsProtected), CASE_EII(TypeFunction, FlagIsDefinition), CASE_EIII(TypeFunction, FlagArtificial), CASE_EIIII(TypeFunction, FlagExplicit), CASE_EIIIII(TypeFunction, FlagIsPrivate), }))); INSTANTIATE_TEST_SUITE_P( OpenCLDebugInfo100DebugTypeEnum, ExtInstCLDebugInfo100RoundTripTest, ::testing::ValuesIn(std::vector({ CASE_IIILLIIFII( TypeEnum, 12, 13, "FlagIsPrivate|FlagFwdDecl|FlagIndirectVariable|FlagIsOptimized", uint32_t(OpenCLDebugInfo100FlagIsPrivate) | uint32_t(OpenCLDebugInfo100FlagFwdDecl) | uint32_t(OpenCLDebugInfo100FlagIndirectVariable) | uint32_t(OpenCLDebugInfo100FlagIsOptimized)), CASE_IIILLIIFIIII(TypeEnum, 17, 18, "FlagStaticMember", uint32_t(OpenCLDebugInfo100FlagStaticMember)), CASE_IIILLIIFIIIIII(TypeEnum, 99, 1, "FlagStaticMember", uint32_t(OpenCLDebugInfo100FlagStaticMember)), }))); INSTANTIATE_TEST_SUITE_P( OpenCLDebugInfo100DebugTypeComposite, ExtInstCLDebugInfo100RoundTripTest, ::testing::ValuesIn(std::vector({ CASE_IEILLIIIF( TypeComposite, Class, 12, 13, "FlagIsPrivate|FlagFwdDecl|FlagIndirectVariable|FlagIsOptimized", uint32_t(OpenCLDebugInfo100FlagIsPrivate) | uint32_t(OpenCLDebugInfo100FlagFwdDecl) | uint32_t(OpenCLDebugInfo100FlagIndirectVariable) | uint32_t(OpenCLDebugInfo100FlagIsOptimized)), // Cover all tag values: Class, Structure, Union CASE_IEILLIIIF(TypeComposite, Class, 12, 13, "FlagIsPrivate", uint32_t(OpenCLDebugInfo100FlagIsPrivate)), CASE_IEILLIIIF(TypeComposite, Structure, 12, 13, "FlagIsPrivate", uint32_t(OpenCLDebugInfo100FlagIsPrivate)), CASE_IEILLIIIF(TypeComposite, Union, 12, 13, "FlagIsPrivate", uint32_t(OpenCLDebugInfo100FlagIsPrivate)), // Now add members CASE_IEILLIIIFI(TypeComposite, Class, 9, 10, "FlagIsPrivate", uint32_t(OpenCLDebugInfo100FlagIsPrivate)), CASE_IEILLIIIFII(TypeComposite, Class, 9, 10, "FlagIsPrivate", uint32_t(OpenCLDebugInfo100FlagIsPrivate)), CASE_IEILLIIIFIII(TypeComposite, Class, 9, 10, "FlagIsPrivate", uint32_t(OpenCLDebugInfo100FlagIsPrivate)), CASE_IEILLIIIFIIII(TypeComposite, Class, 9, 10, "FlagIsPrivate", uint32_t(OpenCLDebugInfo100FlagIsPrivate)), }))); INSTANTIATE_TEST_SUITE_P( OpenCLDebugInfo100DebugTypeMember, ExtInstCLDebugInfo100RoundTripTest, ::testing::ValuesIn(std::vector({ CASE_IIILLIIIF(TypeMember, 12, 13, "FlagIsPrivate", uint32_t(OpenCLDebugInfo100FlagIsPrivate)), CASE_IIILLIIIF(TypeMember, 99, 100, "FlagIsPrivate|FlagFwdDecl", uint32_t(OpenCLDebugInfo100FlagIsPrivate) | uint32_t(OpenCLDebugInfo100FlagFwdDecl)), // Add the optional Id argument. CASE_IIILLIIIFI(TypeMember, 12, 13, "FlagIsPrivate", uint32_t(OpenCLDebugInfo100FlagIsPrivate)), }))); INSTANTIATE_TEST_SUITE_P( OpenCLDebugInfo100DebugTypeInheritance, ExtInstCLDebugInfo100RoundTripTest, ::testing::ValuesIn(std::vector({ CASE_IIIIF(TypeInheritance, "FlagIsPrivate", uint32_t(OpenCLDebugInfo100FlagIsPrivate)), CASE_IIIIF(TypeInheritance, "FlagIsPrivate|FlagFwdDecl", uint32_t(OpenCLDebugInfo100FlagIsPrivate) | uint32_t(OpenCLDebugInfo100FlagFwdDecl)), }))); INSTANTIATE_TEST_SUITE_P(OpenCLDebugInfo100DebugTypePtrToMember, ExtInstCLDebugInfo100RoundTripTest, ::testing::ValuesIn(std::vector({ CASE_II(TypePtrToMember), }))); // OpenCL.DebugInfo.100 4.4 Templates INSTANTIATE_TEST_SUITE_P(OpenCLDebugInfo100DebugTypeTemplate, ExtInstCLDebugInfo100RoundTripTest, ::testing::ValuesIn(std::vector({ CASE_II(TypeTemplate), CASE_III(TypeTemplate), CASE_IIII(TypeTemplate), CASE_IIIII(TypeTemplate), }))); INSTANTIATE_TEST_SUITE_P(OpenCLDebugInfo100DebugTypeTemplateParameter, ExtInstCLDebugInfo100RoundTripTest, ::testing::ValuesIn(std::vector({ CASE_IIIILL(TypeTemplateParameter, 1, 2), CASE_IIIILL(TypeTemplateParameter, 99, 102), CASE_IIIILL(TypeTemplateParameter, 10, 7), }))); INSTANTIATE_TEST_SUITE_P(OpenCLDebugInfo100DebugTypeTemplateTemplateParameter, ExtInstCLDebugInfo100RoundTripTest, ::testing::ValuesIn(std::vector({ CASE_IIILL(TypeTemplateTemplateParameter, 1, 2), CASE_IIILL(TypeTemplateTemplateParameter, 99, 102), CASE_IIILL(TypeTemplateTemplateParameter, 10, 7), }))); INSTANTIATE_TEST_SUITE_P(OpenCLDebugInfo100DebugTypeTemplateParameterPack, ExtInstCLDebugInfo100RoundTripTest, ::testing::ValuesIn(std::vector({ CASE_IILLI(TypeTemplateParameterPack, 1, 2), CASE_IILLII(TypeTemplateParameterPack, 99, 102), CASE_IILLIII(TypeTemplateParameterPack, 10, 7), CASE_IILLIIII(TypeTemplateParameterPack, 10, 7), }))); // OpenCL.DebugInfo.100 4.5 Global Variables INSTANTIATE_TEST_SUITE_P( OpenCLDebugInfo100DebugGlobalVariable, ExtInstCLDebugInfo100RoundTripTest, ::testing::ValuesIn(std::vector({ CASE_IIILLIIIF(GlobalVariable, 1, 2, "FlagIsOptimized", uint32_t(OpenCLDebugInfo100FlagIsOptimized)), CASE_IIILLIIIF(GlobalVariable, 42, 43, "FlagIsOptimized", uint32_t(OpenCLDebugInfo100FlagIsOptimized)), CASE_IIILLIIIFI(GlobalVariable, 1, 2, "FlagIsOptimized", uint32_t(OpenCLDebugInfo100FlagIsOptimized)), CASE_IIILLIIIFI(GlobalVariable, 42, 43, "FlagIsOptimized", uint32_t(OpenCLDebugInfo100FlagIsOptimized)), }))); // OpenCL.DebugInfo.100 4.6 Functions INSTANTIATE_TEST_SUITE_P( OpenCLDebugInfo100DebugFunctionDeclaration, ExtInstCLDebugInfo100RoundTripTest, ::testing::ValuesIn(std::vector({ CASE_IIILLIIF(FunctionDeclaration, 1, 2, "FlagIsOptimized", uint32_t(OpenCLDebugInfo100FlagIsOptimized)), CASE_IIILLIIF(FunctionDeclaration, 42, 43, "FlagFwdDecl", uint32_t(OpenCLDebugInfo100FlagFwdDecl)), }))); INSTANTIATE_TEST_SUITE_P( OpenCLDebugInfo100DebugFunction, ExtInstCLDebugInfo100RoundTripTest, ::testing::ValuesIn(std::vector({ CASE_IIILLIIFLI(Function, 1, 2, "FlagIsOptimized", uint32_t(OpenCLDebugInfo100FlagIsOptimized), 3), CASE_IIILLIIFLI(Function, 42, 43, "FlagFwdDecl", uint32_t(OpenCLDebugInfo100FlagFwdDecl), 44), // Add the optional declaration Id. CASE_IIILLIIFLII(Function, 1, 2, "FlagIsOptimized", uint32_t(OpenCLDebugInfo100FlagIsOptimized), 3), CASE_IIILLIIFLII(Function, 42, 43, "FlagFwdDecl", uint32_t(OpenCLDebugInfo100FlagFwdDecl), 44), }))); // OpenCL.DebugInfo.100 4.7 Local Information INSTANTIATE_TEST_SUITE_P(OpenCLDebugInfo100DebugLexicalBlock, ExtInstCLDebugInfo100RoundTripTest, ::testing::ValuesIn(std::vector({ CASE_ILLII(LexicalBlock, 1, 2), CASE_ILLII(LexicalBlock, 42, 43), }))); INSTANTIATE_TEST_SUITE_P(OpenCLDebugInfo100DebugLexicalBlockDiscriminator, ExtInstCLDebugInfo100RoundTripTest, ::testing::ValuesIn(std::vector({ CASE_ILI(LexicalBlockDiscriminator, 1), CASE_ILI(LexicalBlockDiscriminator, 42), }))); INSTANTIATE_TEST_SUITE_P(OpenCLDebugInfo100DebugScope, ExtInstCLDebugInfo100RoundTripTest, ::testing::ValuesIn(std::vector({ CASE_I(Scope), CASE_II(Scope), }))); INSTANTIATE_TEST_SUITE_P(OpenCLDebugInfo100DebugNoScope, ExtInstCLDebugInfo100RoundTripTest, ::testing::ValuesIn(std::vector({ CASE_0(NoScope), }))); INSTANTIATE_TEST_SUITE_P(OpenCLDebugInfo100DebugInlinedAt, ExtInstCLDebugInfo100RoundTripTest, ::testing::ValuesIn(std::vector({ CASE_LII(InlinedAt, 1), CASE_LII(InlinedAt, 42), }))); // OpenCL.DebugInfo.100 4.8 Local Variables INSTANTIATE_TEST_SUITE_P( OpenCLDebugInfo100DebugLocalVariable, ExtInstCLDebugInfo100RoundTripTest, ::testing::ValuesIn(std::vector({ CASE_IIILLIF(LocalVariable, 1, 2, "FlagIsPrivate", OpenCLDebugInfo100FlagIsPrivate), CASE_IIILLIF(LocalVariable, 4, 5, "FlagIsProtected", OpenCLDebugInfo100FlagIsProtected), CASE_IIILLIFL(LocalVariable, 9, 99, "FlagIsProtected", OpenCLDebugInfo100FlagIsProtected, 195), CASE_IIILLIFL(LocalVariable, 19, 199, "FlagIsPrivate", OpenCLDebugInfo100FlagIsPrivate, 195), }))); INSTANTIATE_TEST_SUITE_P(OpenCLDebugInfo100DebugInlinedVariable, ExtInstCLDebugInfo100RoundTripTest, ::testing::ValuesIn(std::vector({ CASE_II(InlinedVariable), }))); INSTANTIATE_TEST_SUITE_P(OpenCLDebugInfo100DebugDebugDeclare, ExtInstCLDebugInfo100RoundTripTest, ::testing::ValuesIn(std::vector({ CASE_III(Declare), }))); INSTANTIATE_TEST_SUITE_P( OpenCLDebugInfo100DebugDebugValue, ExtInstCLDebugInfo100RoundTripTest, ::testing::ValuesIn(std::vector({ CASE_IIII(Value), CASE_IIIII(Value), CASE_IIIIII(Value), // Test up to 3 id parameters. We can always try more. CASE_IIIIIII(Value), }))); INSTANTIATE_TEST_SUITE_P(OpenCLDebugInfo100DebugDebugOperation, ExtInstCLDebugInfo100RoundTripTest, ::testing::ValuesIn(std::vector({ CASE_E(Operation, Deref), CASE_E(Operation, Plus), CASE_E(Operation, Minus), CASE_EL(Operation, PlusUconst, 1), CASE_EL(Operation, PlusUconst, 42), CASE_ELL(Operation, BitPiece, 1, 2), CASE_ELL(Operation, BitPiece, 4, 5), CASE_E(Operation, Swap), CASE_E(Operation, Xderef), CASE_E(Operation, StackValue), CASE_EL(Operation, Constu, 1), CASE_EL(Operation, Constu, 42), CASE_ELL(Operation, Fragment, 100, 200), CASE_ELL(Operation, Fragment, 8, 9), }))); INSTANTIATE_TEST_SUITE_P(OpenCLDebugInfo100DebugDebugExpression, ExtInstCLDebugInfo100RoundTripTest, ::testing::ValuesIn(std::vector({ CASE_0(Expression), CASE_I(Expression), CASE_II(Expression), CASE_III(Expression), CASE_IIII(Expression), CASE_IIIII(Expression), CASE_IIIIII(Expression), CASE_IIIIIII(Expression), }))); // OpenCL.DebugInfo.100 4.9 Macros INSTANTIATE_TEST_SUITE_P(OpenCLDebugInfo100DebugMacroDef, ExtInstCLDebugInfo100RoundTripTest, ::testing::ValuesIn(std::vector({ CASE_ILI(MacroDef, 1), CASE_ILI(MacroDef, 42), CASE_ILII(MacroDef, 1), CASE_ILII(MacroDef, 42), }))); INSTANTIATE_TEST_SUITE_P(OpenCLDebugInfo100DebugMacroUndef, ExtInstCLDebugInfo100RoundTripTest, ::testing::ValuesIn(std::vector({ CASE_ILI(MacroUndef, 1), CASE_ILI(MacroUndef, 42), }))); // OpenCL.DebugInfo.100 4.10 Imported Entities INSTANTIATE_TEST_SUITE_P( OpenCLDebugInfo100DebugImportedEntity, ExtInstCLDebugInfo100RoundTripTest, ::testing::ValuesIn(std::vector({ // ID Name // Literal Tag // ID Source // ID Entity // Literal Number Line // Literal Number Column // ID Parent CASE_IEIILLI(ImportedEntity, ImportedModule, 67, 68), CASE_IEIILLI(ImportedEntity, ImportedDeclaration, 42, 43), }))); #undef EPREFIX #undef CASE_0 #undef CASE_ILL #undef CASE_IL #undef CASE_I #undef CASE_II #undef CASE_III #undef CASE_IIII #undef CASE_IIIII #undef CASE_IIIIII #undef CASE_IIIIIII #undef CASE_IIILLI #undef CASE_IIILLIL #undef CASE_IE #undef CASE_IEIILLI #undef CASE_IIE #undef CASE_ISF #undef CASE_LII #undef CASE_LLIe #undef CASE_ILI #undef CASE_ILII #undef CASE_ILLII #undef CASE_IIILLIF #undef CASE_IIILLIFL #undef CASE_IIILLIIF #undef CASE_IIILLIIFII #undef CASE_IIILLIIFIIII #undef CASE_IIILLIIFIIIIII #undef CASE_IEILLIIIF #undef CASE_IEILLIIIFI #undef CASE_IEILLIIIFII #undef CASE_IEILLIIIFIII #undef CASE_IEILLIIIFIIII #undef CASE_IIILLIIIF #undef CASE_IIILLIIIFI #undef CASE_IIIIF #undef CASE_IIILL #undef CASE_IIIILL #undef CASE_IILLI #undef CASE_IILLII #undef CASE_IILLIII #undef CASE_IILLIIII #undef CASE_IIILLIIFLI #undef CASE_IIILLIIFLII #undef CASE_E #undef CASE_EI #undef CASE_EII #undef CASE_EIII #undef CASE_EIIII #undef CASE_EIIIII #undef CASE_EL #undef CASE_ELL } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/ext_inst.debuginfo_test.cpp000066400000000000000000001111741475742701700250560ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "DebugInfo.h" #include "gmock/gmock.h" #include "source/util/string_utils.h" #include "test/test_fixture.h" #include "test/unit_spirv.h" // This file tests the correctness of encoding and decoding of instructions // involving the DebugInfo extended instruction set. // Semantic correctness should be the responsibility of validator. // // See https://www.khronos.org/registry/spir-v/specs/1.0/DebugInfo.html namespace spvtools { namespace { using spvtest::Concatenate; using spvtest::MakeInstruction; using utils::MakeVector; using testing::Eq; struct InstructionCase { uint32_t opcode; std::string name; std::string operands; std::vector expected_operands; }; using ExtInstDebugInfoRoundTripTest = spvtest::TextToBinaryTestBase<::testing::TestWithParam>; using ExtInstDebugInfoRoundTripTestExplicit = spvtest::TextToBinaryTest; TEST_P(ExtInstDebugInfoRoundTripTest, ParameterizedExtInst) { const std::string input = "%1 = OpExtInstImport \"DebugInfo\"\n" "%3 = OpExtInst %2 %1 " + GetParam().name + GetParam().operands + "\n"; // First make sure it assembles correctly. EXPECT_THAT(CompiledInstructions(input), Eq(Concatenate({MakeInstruction(spv::Op::OpExtInstImport, {1}, MakeVector("DebugInfo")), MakeInstruction(spv::Op::OpExtInst, {2, 3, 1, GetParam().opcode}, GetParam().expected_operands)}))) << input; // Now check the round trip through the disassembler. EXPECT_THAT(EncodeAndDecodeSuccessfully(input), input) << input; } #define CASE_0(Enum) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, "", {} \ } #define CASE_ILL(Enum, L0, L1) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, " %4 " #L0 " " #L1, { \ 4, L0, L1 \ } \ } #define CASE_IL(Enum, L0) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, " %4 " #L0, { 4, L0 } \ } #define CASE_I(Enum) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, " %4", { 4 } \ } #define CASE_II(Enum) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, " %4 %5", { 4, 5 } \ } #define CASE_III(Enum) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, " %4 %5 %6", { 4, 5, 6 } \ } #define CASE_IIII(Enum) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, " %4 %5 %6 %7", { \ 4, 5, 6, 7 \ } \ } #define CASE_IIIII(Enum) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, " %4 %5 %6 %7 %8", { \ 4, 5, 6, 7, 8 \ } \ } #define CASE_IIIIII(Enum) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, " %4 %5 %6 %7 %8 %9", { \ 4, 5, 6, 7, 8, 9 \ } \ } #define CASE_IIIIIII(Enum) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, " %4 %5 %6 %7 %8 %9 %10", { \ 4, 5, 6, 7, 8, 9, 10 \ } \ } #define CASE_IIILLI(Enum, L0, L1) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, \ " %4 %5 %6 " #L0 " " #L1 " %7", { \ 4, 5, 6, L0, L1, 7 \ } \ } #define CASE_IIILLIL(Enum, L0, L1, L2) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, \ " %4 %5 %6 " #L0 " " #L1 " %7 " #L2, { \ 4, 5, 6, L0, L1, 7, L2 \ } \ } #define CASE_IE(Enum, E0) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, " %4 " #E0, { \ 4, uint32_t(DebugInfo##E0) \ } \ } #define CASE_IIE(Enum, E0) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, " %4 %5 " #E0, { \ 4, 5, uint32_t(DebugInfo##E0) \ } \ } #define CASE_ISF(Enum, S0, Fstr, Fnum) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, " %4 " #S0 " " Fstr, { \ 4, uint32_t(spv::StorageClass::S0), Fnum \ } \ } #define CASE_LII(Enum, L0) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, " " #L0 " %4 %5", { \ L0, 4, 5 \ } \ } #define CASE_ILI(Enum, L0) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, " %4 " #L0 " %5", { \ 4, L0, 5 \ } \ } #define CASE_ILII(Enum, L0) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, " %4 " #L0 " %5 %6", { \ 4, L0, 5, 6 \ } \ } #define CASE_ILLII(Enum, L0, L1) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, \ " %4 " #L0 " " #L1 " %5 %6", { \ 4, L0, L1, 5, 6 \ } \ } #define CASE_IIILLIIF(Enum, L0, L1, Fstr, Fnum) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, \ " %4 %5 %6 " #L0 " " #L1 " %7 %8 " Fstr, { \ 4, 5, 6, L0, L1, 7, 8, Fnum \ } \ } #define CASE_IIILLIIFII(Enum, L0, L1, Fstr, Fnum) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, \ " %4 %5 %6 " #L0 " " #L1 " %7 %8 " Fstr " %9 %10", { \ 4, 5, 6, L0, L1, 7, 8, Fnum, 9, 10 \ } \ } #define CASE_IIILLIIFIIII(Enum, L0, L1, Fstr, Fnum) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, \ " %4 %5 %6 " #L0 " " #L1 " %7 %8 " Fstr " %9 %10 %11 %12", { \ 4, 5, 6, L0, L1, 7, 8, Fnum, 9, 10, 11, 12 \ } \ } #define CASE_IIILLIIFIIIIII(Enum, L0, L1, Fstr, Fnum) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, \ " %4 %5 %6 " #L0 " " #L1 " %7 %8 " Fstr " %9 %10 %11 %12 %13 %14", { \ 4, 5, 6, L0, L1, 7, 8, Fnum, 9, 10, 11, 12, 13, 14 \ } \ } #define CASE_IEILLIIF(Enum, E0, L0, L1, Fstr, Fnum) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, \ " %4 " #E0 " %5 " #L0 " " #L1 " %6 %7 " Fstr, { \ 4, uint32_t(DebugInfo##E0), 5, L0, L1, 6, 7, Fnum \ } \ } #define CASE_IEILLIIFI(Enum, E0, L0, L1, Fstr, Fnum) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, \ " %4 " #E0 " %5 " #L0 " " #L1 " %6 %7 " Fstr " %8", { \ 4, uint32_t(DebugInfo##E0), 5, L0, L1, 6, 7, Fnum, 8 \ } \ } #define CASE_IEILLIIFII(Enum, E0, L0, L1, Fstr, Fnum) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, \ " %4 " #E0 " %5 " #L0 " " #L1 " %6 %7 " Fstr " %8 %9", { \ 4, uint32_t(DebugInfo##E0), 5, L0, L1, 6, 7, Fnum, 8, 9 \ } \ } #define CASE_IEILLIIFIII(Enum, E0, L0, L1, Fstr, Fnum) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, \ " %4 " #E0 " %5 " #L0 " " #L1 " %6 %7 " Fstr " %8 %9 %10", { \ 4, uint32_t(DebugInfo##E0), 5, L0, L1, 6, 7, Fnum, 8, 9, 10 \ } \ } #define CASE_IEILLIIFIIII(Enum, E0, L0, L1, Fstr, Fnum) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, \ " %4 " #E0 " %5 " #L0 " " #L1 " %6 %7 " Fstr " %8 %9 %10 %11", { \ 4, uint32_t(DebugInfo##E0), 5, L0, L1, 6, 7, Fnum, 8, 9, 10, 11 \ } \ } #define CASE_IIILLIIIF(Enum, L0, L1, Fstr, Fnum) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, \ " %4 %5 %6 " #L0 " " #L1 " %7 %8 %9 " Fstr, { \ 4, 5, 6, L0, L1, 7, 8, 9, Fnum \ } \ } #define CASE_IIILLIIIFI(Enum, L0, L1, Fstr, Fnum) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, \ " %4 %5 %6 " #L0 " " #L1 " %7 %8 %9 " Fstr " %10", { \ 4, 5, 6, L0, L1, 7, 8, 9, Fnum, 10 \ } \ } #define CASE_IIIIF(Enum, Fstr, Fnum) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, " %4 %5 %6 %7 " Fstr, { \ 4, 5, 6, 7, Fnum \ } \ } #define CASE_IIILL(Enum, L0, L1) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, " %4 %5 %6 " #L0 " " #L1, { \ 4, 5, 6, L0, L1 \ } \ } #define CASE_IIIILL(Enum, L0, L1) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, \ " %4 %5 %6 %7 " #L0 " " #L1, { \ 4, 5, 6, 7, L0, L1 \ } \ } #define CASE_IILLI(Enum, L0, L1) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, \ " %4 %5 " #L0 " " #L1 " %6", { \ 4, 5, L0, L1, 6 \ } \ } #define CASE_IILLII(Enum, L0, L1) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, \ " %4 %5 " #L0 " " #L1 " %6 %7", { \ 4, 5, L0, L1, 6, 7 \ } \ } #define CASE_IILLIII(Enum, L0, L1) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, \ " %4 %5 " #L0 " " #L1 " %6 %7 %8", { \ 4, 5, L0, L1, 6, 7, 8 \ } \ } #define CASE_IILLIIII(Enum, L0, L1) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, \ " %4 %5 " #L0 " " #L1 " %6 %7 %8 %9", { \ 4, 5, L0, L1, 6, 7, 8, 9 \ } \ } #define CASE_IIILLIIFLI(Enum, L0, L1, Fstr, Fnum, L2) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, \ " %4 %5 %6 " #L0 " " #L1 " %7 %8 " Fstr " " #L2 " %9", { \ 4, 5, 6, L0, L1, 7, 8, Fnum, L2, 9 \ } \ } #define CASE_IIILLIIFLII(Enum, L0, L1, Fstr, Fnum, L2) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, \ " %4 %5 %6 " #L0 " " #L1 " %7 %8 " Fstr " " #L2 " %9 %10", { \ 4, 5, 6, L0, L1, 7, 8, Fnum, L2, 9, 10 \ } \ } #define CASE_E(Enum, E0) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, " " #E0, { \ uint32_t(DebugInfo##E0) \ } \ } #define CASE_EL(Enum, E0, L0) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, " " #E0 " " #L0, { \ uint32_t(DebugInfo##E0), L0 \ } \ } #define CASE_ELL(Enum, E0, L0, L1) \ { \ uint32_t(DebugInfoDebug##Enum), "Debug" #Enum, " " #E0 " " #L0 " " #L1, { \ uint32_t(DebugInfo##E0), L0, L1 \ } \ } // DebugInfo 4.1 Absent Debugging Information INSTANTIATE_TEST_SUITE_P(DebugInfoDebugInfoNone, ExtInstDebugInfoRoundTripTest, ::testing::ValuesIn(std::vector({ CASE_0(InfoNone), // enum value 0 }))); // DebugInfo 4.2 Compilation Unit INSTANTIATE_TEST_SUITE_P(DebugInfoDebugCompilationUnit, ExtInstDebugInfoRoundTripTest, ::testing::ValuesIn(std::vector({ CASE_ILL(CompilationUnit, 100, 42), }))); // DebugInfo 4.3 Type instructions INSTANTIATE_TEST_SUITE_P(DebugInfoDebugTypeBasic, ExtInstDebugInfoRoundTripTest, ::testing::ValuesIn(std::vector({ CASE_IIE(TypeBasic, Unspecified), CASE_IIE(TypeBasic, Address), CASE_IIE(TypeBasic, Boolean), CASE_IIE(TypeBasic, Float), CASE_IIE(TypeBasic, Signed), CASE_IIE(TypeBasic, SignedChar), CASE_IIE(TypeBasic, Unsigned), CASE_IIE(TypeBasic, UnsignedChar), }))); // The FlagIsPublic is value is (1 << 0) | (1 << 2) which is the same // as the bitwise-OR of FlagIsProtected and FlagIsPrivate. // The disassembler will emit the compound expression instead. // There is no simple fix for this. This enum is not really a mask // for the bottom two bits. TEST_F(ExtInstDebugInfoRoundTripTestExplicit, FlagIsPublic) { const std::string prefix = "%1 = OpExtInstImport \"DebugInfo\"\n" "%3 = OpExtInst %2 %1 DebugTypePointer %4 Private "; const std::string input = prefix + "FlagIsPublic\n"; const std::string expected = prefix + "FlagIsProtected|FlagIsPrivate\n"; // First make sure it assembles correctly. EXPECT_THAT( CompiledInstructions(input), Eq(Concatenate({MakeInstruction(spv::Op::OpExtInstImport, {1}, MakeVector("DebugInfo")), MakeInstruction(spv::Op::OpExtInst, {2, 3, 1, DebugInfoDebugTypePointer, 4, uint32_t(spv::StorageClass::Private), DebugInfoFlagIsPublic})}))) << input; // Now check the round trip through the disassembler. EXPECT_THAT(EncodeAndDecodeSuccessfully(input), Eq(expected)) << input; } INSTANTIATE_TEST_SUITE_P( DebugInfoDebugTypePointer, ExtInstDebugInfoRoundTripTest, ::testing::ValuesIn(std::vector({ //// Use each flag independently. CASE_ISF(TypePointer, Private, "FlagIsProtected", uint32_t(DebugInfoFlagIsProtected)), CASE_ISF(TypePointer, Private, "FlagIsPrivate", uint32_t(DebugInfoFlagIsPrivate)), // FlagIsPublic is tested above. CASE_ISF(TypePointer, Private, "FlagIsLocal", uint32_t(DebugInfoFlagIsLocal)), CASE_ISF(TypePointer, Private, "FlagIsDefinition", uint32_t(DebugInfoFlagIsDefinition)), CASE_ISF(TypePointer, Private, "FlagFwdDecl", uint32_t(DebugInfoFlagFwdDecl)), CASE_ISF(TypePointer, Private, "FlagArtificial", uint32_t(DebugInfoFlagArtificial)), CASE_ISF(TypePointer, Private, "FlagExplicit", uint32_t(DebugInfoFlagExplicit)), CASE_ISF(TypePointer, Private, "FlagPrototyped", uint32_t(DebugInfoFlagPrototyped)), CASE_ISF(TypePointer, Private, "FlagObjectPointer", uint32_t(DebugInfoFlagObjectPointer)), CASE_ISF(TypePointer, Private, "FlagStaticMember", uint32_t(DebugInfoFlagStaticMember)), CASE_ISF(TypePointer, Private, "FlagIndirectVariable", uint32_t(DebugInfoFlagIndirectVariable)), CASE_ISF(TypePointer, Private, "FlagLValueReference", uint32_t(DebugInfoFlagLValueReference)), CASE_ISF(TypePointer, Private, "FlagIsOptimized", uint32_t(DebugInfoFlagIsOptimized)), //// Use flags in combination, and try different storage classes. CASE_ISF(TypePointer, Function, "FlagIsProtected|FlagIsPrivate", uint32_t(DebugInfoFlagIsProtected) | uint32_t(DebugInfoFlagIsPrivate)), CASE_ISF( TypePointer, Workgroup, "FlagIsPrivate|FlagFwdDecl|FlagIndirectVariable|FlagIsOptimized", uint32_t(DebugInfoFlagIsPrivate) | uint32_t(DebugInfoFlagFwdDecl) | uint32_t(DebugInfoFlagIndirectVariable) | uint32_t(DebugInfoFlagIsOptimized)), }))); INSTANTIATE_TEST_SUITE_P(DebugInfoDebugTypeQualifier, ExtInstDebugInfoRoundTripTest, ::testing::ValuesIn(std::vector({ CASE_IE(TypeQualifier, ConstType), CASE_IE(TypeQualifier, VolatileType), CASE_IE(TypeQualifier, RestrictType), }))); INSTANTIATE_TEST_SUITE_P(DebugInfoDebugTypeArray, ExtInstDebugInfoRoundTripTest, ::testing::ValuesIn(std::vector({ CASE_II(TypeArray), CASE_III(TypeArray), CASE_IIII(TypeArray), CASE_IIIII(TypeArray), }))); INSTANTIATE_TEST_SUITE_P(DebugInfoDebugTypeVector, ExtInstDebugInfoRoundTripTest, ::testing::ValuesIn(std::vector({ CASE_IL(TypeVector, 2), CASE_IL(TypeVector, 3), CASE_IL(TypeVector, 4), CASE_IL(TypeVector, 16), }))); INSTANTIATE_TEST_SUITE_P(DebugInfoDebugTypedef, ExtInstDebugInfoRoundTripTest, ::testing::ValuesIn(std::vector({ CASE_IIILLI(Typedef, 12, 13), CASE_IIILLI(Typedef, 14, 99), }))); INSTANTIATE_TEST_SUITE_P(DebugInfoDebugTypeFunction, ExtInstDebugInfoRoundTripTest, ::testing::ValuesIn(std::vector({ CASE_I(TypeFunction), CASE_II(TypeFunction), CASE_III(TypeFunction), CASE_IIII(TypeFunction), CASE_IIIII(TypeFunction), }))); INSTANTIATE_TEST_SUITE_P( DebugInfoDebugTypeEnum, ExtInstDebugInfoRoundTripTest, ::testing::ValuesIn(std::vector({ CASE_IIILLIIFII( TypeEnum, 12, 13, "FlagIsPrivate|FlagFwdDecl|FlagIndirectVariable|FlagIsOptimized", uint32_t(DebugInfoFlagIsPrivate) | uint32_t(DebugInfoFlagFwdDecl) | uint32_t(DebugInfoFlagIndirectVariable) | uint32_t(DebugInfoFlagIsOptimized)), CASE_IIILLIIFIIII(TypeEnum, 17, 18, "FlagStaticMember", uint32_t(DebugInfoFlagStaticMember)), CASE_IIILLIIFIIIIII(TypeEnum, 99, 1, "FlagStaticMember", uint32_t(DebugInfoFlagStaticMember)), }))); INSTANTIATE_TEST_SUITE_P( DebugInfoDebugTypeComposite, ExtInstDebugInfoRoundTripTest, ::testing::ValuesIn(std::vector({ CASE_IEILLIIF( TypeComposite, Class, 12, 13, "FlagIsPrivate|FlagFwdDecl|FlagIndirectVariable|FlagIsOptimized", uint32_t(DebugInfoFlagIsPrivate) | uint32_t(DebugInfoFlagFwdDecl) | uint32_t(DebugInfoFlagIndirectVariable) | uint32_t(DebugInfoFlagIsOptimized)), // Cover all tag values: Class, Structure, Union CASE_IEILLIIF(TypeComposite, Class, 12, 13, "FlagIsPrivate", uint32_t(DebugInfoFlagIsPrivate)), CASE_IEILLIIF(TypeComposite, Structure, 12, 13, "FlagIsPrivate", uint32_t(DebugInfoFlagIsPrivate)), CASE_IEILLIIF(TypeComposite, Union, 12, 13, "FlagIsPrivate", uint32_t(DebugInfoFlagIsPrivate)), // Now add members CASE_IEILLIIFI(TypeComposite, Class, 9, 10, "FlagIsPrivate", uint32_t(DebugInfoFlagIsPrivate)), CASE_IEILLIIFII(TypeComposite, Class, 9, 10, "FlagIsPrivate", uint32_t(DebugInfoFlagIsPrivate)), CASE_IEILLIIFIII(TypeComposite, Class, 9, 10, "FlagIsPrivate", uint32_t(DebugInfoFlagIsPrivate)), CASE_IEILLIIFIIII(TypeComposite, Class, 9, 10, "FlagIsPrivate", uint32_t(DebugInfoFlagIsPrivate)), }))); INSTANTIATE_TEST_SUITE_P( DebugInfoDebugTypeMember, ExtInstDebugInfoRoundTripTest, ::testing::ValuesIn(std::vector({ CASE_IIILLIIIF(TypeMember, 12, 13, "FlagIsPrivate", uint32_t(DebugInfoFlagIsPrivate)), CASE_IIILLIIIF(TypeMember, 99, 100, "FlagIsPrivate|FlagFwdDecl", uint32_t(DebugInfoFlagIsPrivate) | uint32_t(DebugInfoFlagFwdDecl)), // Add the optional Id argument. CASE_IIILLIIIFI(TypeMember, 12, 13, "FlagIsPrivate", uint32_t(DebugInfoFlagIsPrivate)), }))); INSTANTIATE_TEST_SUITE_P( DebugInfoDebugTypeInheritance, ExtInstDebugInfoRoundTripTest, ::testing::ValuesIn(std::vector({ CASE_IIIIF(TypeInheritance, "FlagIsPrivate", uint32_t(DebugInfoFlagIsPrivate)), CASE_IIIIF(TypeInheritance, "FlagIsPrivate|FlagFwdDecl", uint32_t(DebugInfoFlagIsPrivate) | uint32_t(DebugInfoFlagFwdDecl)), }))); INSTANTIATE_TEST_SUITE_P(DebugInfoDebugTypePtrToMember, ExtInstDebugInfoRoundTripTest, ::testing::ValuesIn(std::vector({ CASE_II(TypePtrToMember), }))); // DebugInfo 4.4 Templates INSTANTIATE_TEST_SUITE_P(DebugInfoDebugTypeTemplate, ExtInstDebugInfoRoundTripTest, ::testing::ValuesIn(std::vector({ CASE_II(TypeTemplate), CASE_III(TypeTemplate), CASE_IIII(TypeTemplate), CASE_IIIII(TypeTemplate), }))); INSTANTIATE_TEST_SUITE_P(DebugInfoDebugTypeTemplateParameter, ExtInstDebugInfoRoundTripTest, ::testing::ValuesIn(std::vector({ CASE_IIIILL(TypeTemplateParameter, 1, 2), CASE_IIIILL(TypeTemplateParameter, 99, 102), CASE_IIIILL(TypeTemplateParameter, 10, 7), }))); INSTANTIATE_TEST_SUITE_P(DebugInfoDebugTypeTemplateTemplateParameter, ExtInstDebugInfoRoundTripTest, ::testing::ValuesIn(std::vector({ CASE_IIILL(TypeTemplateTemplateParameter, 1, 2), CASE_IIILL(TypeTemplateTemplateParameter, 99, 102), CASE_IIILL(TypeTemplateTemplateParameter, 10, 7), }))); INSTANTIATE_TEST_SUITE_P(DebugInfoDebugTypeTemplateParameterPack, ExtInstDebugInfoRoundTripTest, ::testing::ValuesIn(std::vector({ CASE_IILLI(TypeTemplateParameterPack, 1, 2), CASE_IILLII(TypeTemplateParameterPack, 99, 102), CASE_IILLIII(TypeTemplateParameterPack, 10, 7), CASE_IILLIIII(TypeTemplateParameterPack, 10, 7), }))); // DebugInfo 4.5 Global Variables INSTANTIATE_TEST_SUITE_P( DebugInfoDebugGlobalVariable, ExtInstDebugInfoRoundTripTest, ::testing::ValuesIn(std::vector({ CASE_IIILLIIIF(GlobalVariable, 1, 2, "FlagIsOptimized", uint32_t(DebugInfoFlagIsOptimized)), CASE_IIILLIIIF(GlobalVariable, 42, 43, "FlagIsOptimized", uint32_t(DebugInfoFlagIsOptimized)), CASE_IIILLIIIFI(GlobalVariable, 1, 2, "FlagIsOptimized", uint32_t(DebugInfoFlagIsOptimized)), CASE_IIILLIIIFI(GlobalVariable, 42, 43, "FlagIsOptimized", uint32_t(DebugInfoFlagIsOptimized)), }))); // DebugInfo 4.6 Functions INSTANTIATE_TEST_SUITE_P( DebugInfoDebugFunctionDeclaration, ExtInstDebugInfoRoundTripTest, ::testing::ValuesIn(std::vector({ CASE_IIILLIIF(FunctionDeclaration, 1, 2, "FlagIsOptimized", uint32_t(DebugInfoFlagIsOptimized)), CASE_IIILLIIF(FunctionDeclaration, 42, 43, "FlagFwdDecl", uint32_t(DebugInfoFlagFwdDecl)), }))); INSTANTIATE_TEST_SUITE_P( DebugInfoDebugFunction, ExtInstDebugInfoRoundTripTest, ::testing::ValuesIn(std::vector({ CASE_IIILLIIFLI(Function, 1, 2, "FlagIsOptimized", uint32_t(DebugInfoFlagIsOptimized), 3), CASE_IIILLIIFLI(Function, 42, 43, "FlagFwdDecl", uint32_t(DebugInfoFlagFwdDecl), 44), // Add the optional declaration Id. CASE_IIILLIIFLII(Function, 1, 2, "FlagIsOptimized", uint32_t(DebugInfoFlagIsOptimized), 3), CASE_IIILLIIFLII(Function, 42, 43, "FlagFwdDecl", uint32_t(DebugInfoFlagFwdDecl), 44), }))); // DebugInfo 4.7 Local Information INSTANTIATE_TEST_SUITE_P(DebugInfoDebugLexicalBlock, ExtInstDebugInfoRoundTripTest, ::testing::ValuesIn(std::vector({ CASE_ILLII(LexicalBlock, 1, 2), CASE_ILLII(LexicalBlock, 42, 43), }))); INSTANTIATE_TEST_SUITE_P(DebugInfoDebugLexicalBlockDiscriminator, ExtInstDebugInfoRoundTripTest, ::testing::ValuesIn(std::vector({ CASE_ILI(LexicalBlockDiscriminator, 1), CASE_ILI(LexicalBlockDiscriminator, 42), }))); INSTANTIATE_TEST_SUITE_P(DebugInfoDebugScope, ExtInstDebugInfoRoundTripTest, ::testing::ValuesIn(std::vector({ CASE_I(Scope), CASE_II(Scope), }))); INSTANTIATE_TEST_SUITE_P(DebugInfoDebugNoScope, ExtInstDebugInfoRoundTripTest, ::testing::ValuesIn(std::vector({ CASE_0(NoScope), }))); INSTANTIATE_TEST_SUITE_P(DebugInfoDebugInlinedAt, ExtInstDebugInfoRoundTripTest, ::testing::ValuesIn(std::vector({ CASE_LII(InlinedAt, 1), CASE_LII(InlinedAt, 42), }))); // DebugInfo 4.8 Local Variables INSTANTIATE_TEST_SUITE_P(DebugInfoDebugLocalVariable, ExtInstDebugInfoRoundTripTest, ::testing::ValuesIn(std::vector({ CASE_IIILLI(LocalVariable, 1, 2), CASE_IIILLI(LocalVariable, 42, 43), CASE_IIILLIL(LocalVariable, 1, 2, 3), CASE_IIILLIL(LocalVariable, 42, 43, 44), }))); INSTANTIATE_TEST_SUITE_P(DebugInfoDebugInlinedVariable, ExtInstDebugInfoRoundTripTest, ::testing::ValuesIn(std::vector({ CASE_II(InlinedVariable), }))); INSTANTIATE_TEST_SUITE_P(DebugInfoDebugDebugDeclare, ExtInstDebugInfoRoundTripTest, ::testing::ValuesIn(std::vector({ CASE_III(Declare), }))); INSTANTIATE_TEST_SUITE_P( DebugInfoDebugDebugValue, ExtInstDebugInfoRoundTripTest, ::testing::ValuesIn(std::vector({ CASE_III(Value), CASE_IIII(Value), CASE_IIIII(Value), CASE_IIIIII(Value), // Test up to 4 id parameters. We can always try more. CASE_IIIIIII(Value), }))); INSTANTIATE_TEST_SUITE_P(DebugInfoDebugDebugOperation, ExtInstDebugInfoRoundTripTest, ::testing::ValuesIn(std::vector({ CASE_E(Operation, Deref), CASE_E(Operation, Plus), CASE_E(Operation, Minus), CASE_EL(Operation, PlusUconst, 1), CASE_EL(Operation, PlusUconst, 42), CASE_ELL(Operation, BitPiece, 1, 2), CASE_ELL(Operation, BitPiece, 4, 5), CASE_E(Operation, Swap), CASE_E(Operation, Xderef), CASE_E(Operation, StackValue), CASE_EL(Operation, Constu, 1), CASE_EL(Operation, Constu, 42), }))); INSTANTIATE_TEST_SUITE_P(DebugInfoDebugDebugExpression, ExtInstDebugInfoRoundTripTest, ::testing::ValuesIn(std::vector({ CASE_0(Expression), CASE_I(Expression), CASE_II(Expression), CASE_III(Expression), CASE_IIII(Expression), CASE_IIIII(Expression), CASE_IIIIII(Expression), CASE_IIIIIII(Expression), }))); // DebugInfo 4.9 Macros INSTANTIATE_TEST_SUITE_P(DebugInfoDebugMacroDef, ExtInstDebugInfoRoundTripTest, ::testing::ValuesIn(std::vector({ CASE_ILI(MacroDef, 1), CASE_ILI(MacroDef, 42), CASE_ILII(MacroDef, 1), CASE_ILII(MacroDef, 42), }))); INSTANTIATE_TEST_SUITE_P(DebugInfoDebugMacroUndef, ExtInstDebugInfoRoundTripTest, ::testing::ValuesIn(std::vector({ CASE_ILI(MacroUndef, 1), CASE_ILI(MacroUndef, 42), }))); #undef CASE_0 #undef CASE_ILL #undef CASE_IL #undef CASE_I #undef CASE_II #undef CASE_III #undef CASE_IIII #undef CASE_IIIII #undef CASE_IIIIII #undef CASE_IIIIIII #undef CASE_IIILLI #undef CASE_IIILLIL #undef CASE_IE #undef CASE_IIE #undef CASE_ISF #undef CASE_LII #undef CASE_ILI #undef CASE_ILII #undef CASE_ILLII #undef CASE_IIILLIIF #undef CASE_IIILLIIFII #undef CASE_IIILLIIFIIII #undef CASE_IIILLIIFIIIIII #undef CASE_IEILLIIF #undef CASE_IEILLIIFI #undef CASE_IEILLIIFII #undef CASE_IEILLIIFIII #undef CASE_IEILLIIFIIII #undef CASE_IIILLIIIF #undef CASE_IIILLIIIFI #undef CASE_IIIIF #undef CASE_IIILL #undef CASE_IIIILL #undef CASE_IILLI #undef CASE_IILLII #undef CASE_IILLIII #undef CASE_IILLIIII #undef CASE_IIILLIIFLI #undef CASE_IIILLIIFLII #undef CASE_E #undef CASE_EL #undef CASE_ELL } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/ext_inst.glsl_test.cpp000066400000000000000000000174361475742701700240630ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include "source/latest_version_glsl_std_450_header.h" #include "test/unit_spirv.h" namespace spvtools { namespace { /// Context for an extended instruction. /// /// Information about a GLSL extended instruction (including its opname, return /// type, etc.) and related instructions used to generate the return type and /// constant as the operands. Used in generating extended instruction tests. struct ExtInstContext { const char* extInstOpName; const char* extInstOperandVars; /// The following fields are used to check the SPIR-V binary representation /// of this instruction. uint32_t extInstOpcode; ///< Opcode value for this extended instruction. uint32_t extInstLength; ///< Wordcount of this extended instruction. std::vector extInstOperandIds; ///< Ids for operands. }; using ExtInstGLSLstd450RoundTripTest = ::testing::TestWithParam; TEST_P(ExtInstGLSLstd450RoundTripTest, ParameterizedExtInst) { spv_context context = spvContextCreate(SPV_ENV_UNIVERSAL_1_0); const std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical Simple OpEntryPoint Vertex %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %2 = OpFunction %3 None %5 %6 = OpLabel %8 = OpExtInst %7 %1 )" + std::string(GetParam().extInstOpName) + " " + GetParam().extInstOperandVars + R"( OpReturn OpFunctionEnd )"; const std::string spirv_header = R"(; SPIR-V ; Version: 1.0 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 9 ; Schema: 0)"; spv_binary binary = nullptr; spv_diagnostic diagnostic; spv_result_t error = spvTextToBinary(context, spirv.c_str(), spirv.size(), &binary, &diagnostic); if (error) { spvDiagnosticPrint(diagnostic); spvDiagnosticDestroy(diagnostic); ASSERT_EQ(SPV_SUCCESS, error) << "Source was: " << std::endl << spirv << std::endl << "Test case for : " << GetParam().extInstOpName << std::endl; } // Check we do have the extended instruction's corresponding binary code in // the generated SPIR-V binary. std::vector expected_contains( {12 /*OpExtInst*/ | GetParam().extInstLength << 16, 7 /*return type*/, 8 /*result id*/, 1 /*glsl450 import*/, GetParam().extInstOpcode}); for (uint32_t operand : GetParam().extInstOperandIds) { expected_contains.push_back(operand); } EXPECT_NE(binary->code + binary->wordCount, std::search(binary->code, binary->code + binary->wordCount, expected_contains.begin(), expected_contains.end())) << "Cannot find\n" << spvtest::WordVector(expected_contains).str() << "in\n" << spvtest::WordVector(*binary).str(); // Check round trip gives the same text. spv_text output_text = nullptr; error = spvBinaryToText(context, binary->code, binary->wordCount, SPV_BINARY_TO_TEXT_OPTION_NONE, &output_text, &diagnostic); if (error) { spvDiagnosticPrint(diagnostic); spvDiagnosticDestroy(diagnostic); ASSERT_EQ(SPV_SUCCESS, error); } EXPECT_EQ(spirv_header + spirv, output_text->str); spvTextDestroy(output_text); spvBinaryDestroy(binary); spvContextDestroy(context); } INSTANTIATE_TEST_SUITE_P( ExtInstParameters, ExtInstGLSLstd450RoundTripTest, ::testing::ValuesIn(std::vector({ // We are only testing the correctness of encoding and decoding here. // Semantic correctness should be the responsibility of validator. So // some of the instructions below have incorrect operand and/or return // types, e.g, Modf, ModfStruct, etc. {"Round", "%5", 1, 6, {5}}, {"RoundEven", "%5", 2, 6, {5}}, {"Trunc", "%5", 3, 6, {5}}, {"FAbs", "%5", 4, 6, {5}}, {"SAbs", "%5", 5, 6, {5}}, {"FSign", "%5", 6, 6, {5}}, {"SSign", "%5", 7, 6, {5}}, {"Floor", "%5", 8, 6, {5}}, {"Ceil", "%5", 9, 6, {5}}, {"Fract", "%5", 10, 6, {5}}, {"Radians", "%5", 11, 6, {5}}, {"Degrees", "%5", 12, 6, {5}}, {"Sin", "%5", 13, 6, {5}}, {"Cos", "%5", 14, 6, {5}}, {"Tan", "%5", 15, 6, {5}}, {"Asin", "%5", 16, 6, {5}}, {"Acos", "%5", 17, 6, {5}}, {"Atan", "%5", 18, 6, {5}}, {"Sinh", "%5", 19, 6, {5}}, {"Cosh", "%5", 20, 6, {5}}, {"Tanh", "%5", 21, 6, {5}}, {"Asinh", "%5", 22, 6, {5}}, {"Acosh", "%5", 23, 6, {5}}, {"Atanh", "%5", 24, 6, {5}}, {"Atan2", "%5 %5", 25, 7, {5, 5}}, {"Pow", "%5 %5", 26, 7, {5, 5}}, {"Exp", "%5", 27, 6, {5}}, {"Log", "%5", 28, 6, {5}}, {"Exp2", "%5", 29, 6, {5}}, {"Log2", "%5", 30, 6, {5}}, {"Sqrt", "%5", 31, 6, {5}}, {"InverseSqrt", "%5", 32, 6, {5}}, {"Determinant", "%5", 33, 6, {5}}, {"MatrixInverse", "%5", 34, 6, {5}}, {"Modf", "%5 %5", 35, 7, {5, 5}}, {"ModfStruct", "%5", 36, 6, {5}}, {"FMin", "%5 %5", 37, 7, {5, 5}}, {"UMin", "%5 %5", 38, 7, {5, 5}}, {"SMin", "%5 %5", 39, 7, {5, 5}}, {"FMax", "%5 %5", 40, 7, {5, 5}}, {"UMax", "%5 %5", 41, 7, {5, 5}}, {"SMax", "%5 %5", 42, 7, {5, 5}}, {"FClamp", "%5 %5 %5", 43, 8, {5, 5, 5}}, {"UClamp", "%5 %5 %5", 44, 8, {5, 5, 5}}, {"SClamp", "%5 %5 %5", 45, 8, {5, 5, 5}}, {"FMix", "%5 %5 %5", 46, 8, {5, 5, 5}}, {"IMix", "%5 %5 %5", 47, 8, {5, 5, 5}}, // Bug 15452. Reserved. {"Step", "%5 %5", 48, 7, {5, 5}}, {"SmoothStep", "%5 %5 %5", 49, 8, {5, 5, 5}}, {"Fma", "%5 %5 %5", 50, 8, {5, 5, 5}}, {"Frexp", "%5 %5", 51, 7, {5, 5}}, {"FrexpStruct", "%5", 52, 6, {5}}, {"Ldexp", "%5 %5", 53, 7, {5, 5}}, {"PackSnorm4x8", "%5", 54, 6, {5}}, {"PackUnorm4x8", "%5", 55, 6, {5}}, {"PackSnorm2x16", "%5", 56, 6, {5}}, {"PackUnorm2x16", "%5", 57, 6, {5}}, {"PackHalf2x16", "%5", 58, 6, {5}}, {"PackDouble2x32", "%5", 59, 6, {5}}, {"UnpackSnorm2x16", "%5", 60, 6, {5}}, {"UnpackUnorm2x16", "%5", 61, 6, {5}}, {"UnpackHalf2x16", "%5", 62, 6, {5}}, {"UnpackSnorm4x8", "%5", 63, 6, {5}}, {"UnpackUnorm4x8", "%5", 64, 6, {5}}, {"UnpackDouble2x32", "%5", 65, 6, {5}}, {"Length", "%5", 66, 6, {5}}, {"Distance", "%5 %5", 67, 7, {5, 5}}, {"Cross", "%5 %5", 68, 7, {5, 5}}, {"Normalize", "%5", 69, 6, {5}}, // clang-format off {"FaceForward", "%5 %5 %5", 70, 8, {5, 5, 5}}, // clang-format on {"Reflect", "%5 %5", 71, 7, {5, 5}}, {"Refract", "%5 %5 %5", 72, 8, {5, 5, 5}}, {"FindILsb", "%5", 73, 6, {5}}, {"FindSMsb", "%5", 74, 6, {5}}, {"FindUMsb", "%5", 75, 6, {5}}, {"InterpolateAtCentroid", "%5", 76, 6, {5}}, // clang-format off {"InterpolateAtSample", "%5 %5", 77, 7, {5, 5}}, {"InterpolateAtOffset", "%5 %5", 78, 7, {5, 5}}, // clang-format on {"NMin", "%5 %5", 79, 7, {5, 5}}, {"NMax", "%5 %5", 80, 7, {5, 5}}, {"NClamp", "%5 %5 %5", 81, 8, {5, 5, 5}}, }))); } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/ext_inst.non_semantic_test.cpp000066400000000000000000000053361475742701700255730ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Assembler tests for non-semantic extended instructions #include #include #include "gmock/gmock.h" #include "test/test_fixture.h" #include "test/unit_spirv.h" using ::testing::Eq; namespace spvtools { namespace { using NonSemanticRoundTripTest = RoundTripTest; using NonSemanticTextToBinaryTest = spvtest::TextToBinaryTest; TEST_F(NonSemanticRoundTripTest, NonSemanticInsts) { std::string spirv = R"(OpExtension "SPV_KHR_non_semantic_info" %1 = OpExtInstImport "NonSemantic.Testing.ExtInst" %2 = OpTypeVoid %3 = OpExtInst %2 %1 132384681 %2 %4 = OpTypeInt 32 0 %5 = OpConstant %4 123 %6 = OpString "Test string" %7 = OpExtInst %4 %1 82198732 %5 %6 %8 = OpExtInstImport "NonSemantic.Testing.AnotherUnknownExtInstSet" %9 = OpExtInst %4 %8 613874321 %7 %5 %6 )"; std::string disassembly = EncodeAndDecodeSuccessfully(spirv); EXPECT_THAT(disassembly, Eq(spirv)); } TEST_F(NonSemanticTextToBinaryTest, InvalidExtInstSetName) { std::string spirv = R"(OpExtension "SPV_KHR_non_semantic_info" %1 = OpExtInstImport "NonSemantic_Testing_ExtInst" )"; EXPECT_THAT( CompileFailure(spirv), Eq("Invalid extended instruction import 'NonSemantic_Testing_ExtInst'")); } TEST_F(NonSemanticTextToBinaryTest, NonSemanticIntParameter) { std::string spirv = R"(OpExtension "SPV_KHR_non_semantic_info" %1 = OpExtInstImport "NonSemantic.Testing.ExtInst" %2 = OpTypeVoid %3 = OpExtInst %2 %1 1 99999 )"; EXPECT_THAT(CompileFailure(spirv), Eq("Expected id to start with %.")); } TEST_F(NonSemanticTextToBinaryTest, NonSemanticFloatParameter) { std::string spirv = R"(OpExtension "SPV_KHR_non_semantic_info" %1 = OpExtInstImport "NonSemantic.Testing.ExtInst" %2 = OpTypeVoid %3 = OpExtInst %2 %1 1 3.141592 )"; EXPECT_THAT(CompileFailure(spirv), Eq("Expected id to start with %.")); } TEST_F(NonSemanticTextToBinaryTest, NonSemanticStringParameter) { std::string spirv = R"(OpExtension "SPV_KHR_non_semantic_info" %1 = OpExtInstImport "NonSemantic.Testing.ExtInst" %2 = OpTypeVoid %3 = OpExtInst %2 %1 1 "foobar" )"; EXPECT_THAT(CompileFailure(spirv), Eq("Expected id to start with %.")); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/ext_inst.opencl_test.cpp000066400000000000000000000330701475742701700243720ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gmock/gmock.h" #include "source/latest_version_opencl_std_header.h" #include "source/util/string_utils.h" #include "test/test_fixture.h" #include "test/unit_spirv.h" namespace spvtools { namespace { using spvtest::Concatenate; using spvtest::MakeInstruction; using utils::MakeVector; using spvtest::TextToBinaryTest; using testing::Eq; struct InstructionCase { uint32_t opcode; std::string name; std::string operands; std::vector expected_operands; }; using ExtInstOpenCLStdRoundTripTest = spvtest::TextToBinaryTestBase<::testing::TestWithParam>; TEST_P(ExtInstOpenCLStdRoundTripTest, ParameterizedExtInst) { // This example should not validate. const std::string input = "%1 = OpExtInstImport \"OpenCL.std\"\n" "%3 = OpExtInst %2 %1 " + GetParam().name + " " + GetParam().operands + "\n"; // First make sure it assembles correctly. EXPECT_THAT(CompiledInstructions(input), Eq(Concatenate({MakeInstruction(spv::Op::OpExtInstImport, {1}, MakeVector("OpenCL.std")), MakeInstruction(spv::Op::OpExtInst, {2, 3, 1, GetParam().opcode}, GetParam().expected_operands)}))) << input; // Now check the round trip through the disassembler. EXPECT_THAT(EncodeAndDecodeSuccessfully(input), input) << input; } #define CASE1(Enum, Name) \ { \ uint32_t(OpenCLLIB::Entrypoints::Enum), #Name, "%4", { 4 } \ } #define CASE2(Enum, Name) \ { \ uint32_t(OpenCLLIB::Entrypoints::Enum), #Name, "%4 %5", { 4, 5 } \ } #define CASE3(Enum, Name) \ { \ uint32_t(OpenCLLIB::Entrypoints::Enum), #Name, "%4 %5 %6", { 4, 5, 6 } \ } #define CASE4(Enum, Name) \ { \ uint32_t(OpenCLLIB::Entrypoints::Enum), #Name, "%4 %5 %6 %7", { \ 4, 5, 6, 7 \ } \ } #define CASE2Lit(Enum, Name, LiteralNumber) \ { \ uint32_t(OpenCLLIB::Entrypoints::Enum), #Name, "%4 %5 " #LiteralNumber, { \ 4, 5, LiteralNumber \ } \ } #define CASE3Round(Enum, Name, Mode) \ { \ uint32_t(OpenCLLIB::Entrypoints::Enum), #Name, "%4 %5 %6 " #Mode, { \ 4, 5, 6, uint32_t(spv::FPRoundingMode::Mode) \ } \ } // clang-format off // OpenCL.std: 2.1 Math extended instructions INSTANTIATE_TEST_SUITE_P( OpenCLMath, ExtInstOpenCLStdRoundTripTest, ::testing::ValuesIn(std::vector({ // We are only testing the correctness of encoding and decoding here. // Semantic correctness should be the responsibility of validator. CASE1(Acos, acos), // enum value 0 CASE1(Acosh, acosh), CASE1(Acospi, acospi), CASE1(Asin, asin), CASE1(Asinh, asinh), CASE1(Asinh, asinh), CASE1(Asinpi, asinpi), CASE1(Atan, atan), CASE2(Atan2, atan2), CASE1(Atanh, atanh), CASE1(Atanpi, atanpi), CASE2(Atan2pi, atan2pi), CASE1(Cbrt, cbrt), CASE1(Ceil, ceil), CASE1(Ceil, ceil), CASE2(Copysign, copysign), CASE1(Cos, cos), CASE1(Cosh, cosh), CASE1(Cospi, cospi), CASE1(Erfc, erfc), CASE1(Erf, erf), CASE1(Exp, exp), CASE1(Exp2, exp2), CASE1(Exp10, exp10), CASE1(Expm1, expm1), CASE1(Fabs, fabs), CASE2(Fdim, fdim), CASE1(Floor, floor), CASE3(Fma, fma), CASE2(Fmax, fmax), CASE2(Fmin, fmin), CASE2(Fmod, fmod), CASE2(Fract, fract), CASE2(Frexp, frexp), CASE2(Hypot, hypot), CASE1(Ilogb, ilogb), CASE2(Ldexp, ldexp), CASE1(Lgamma, lgamma), CASE2(Lgamma_r, lgamma_r), CASE1(Log, log), CASE1(Log2, log2), CASE1(Log10, log10), CASE1(Log1p, log1p), CASE3(Mad, mad), CASE2(Maxmag, maxmag), CASE2(Minmag, minmag), CASE2(Modf, modf), CASE1(Nan, nan), CASE2(Nextafter, nextafter), CASE2(Pow, pow), CASE2(Pown, pown), CASE2(Powr, powr), CASE2(Remainder, remainder), CASE3(Remquo, remquo), CASE1(Rint, rint), CASE2(Rootn, rootn), CASE1(Round, round), CASE1(Rsqrt, rsqrt), CASE1(Sin, sin), CASE2(Sincos, sincos), CASE1(Sinh, sinh), CASE1(Sinpi, sinpi), CASE1(Sqrt, sqrt), CASE1(Tan, tan), CASE1(Tanh, tanh), CASE1(Tanpi, tanpi), CASE1(Tgamma, tgamma), CASE1(Trunc, trunc), CASE1(Half_cos, half_cos), CASE2(Half_divide, half_divide), CASE1(Half_exp, half_exp), CASE1(Half_exp2, half_exp2), CASE1(Half_exp10, half_exp10), CASE1(Half_log, half_log), CASE1(Half_log2, half_log2), CASE1(Half_log10, half_log10), CASE2(Half_powr, half_powr), CASE1(Half_recip, half_recip), CASE1(Half_rsqrt, half_rsqrt), CASE1(Half_sin, half_sin), CASE1(Half_sqrt, half_sqrt), CASE1(Half_tan, half_tan), CASE1(Native_cos, native_cos), CASE2(Native_divide, native_divide), CASE1(Native_exp, native_exp), CASE1(Native_exp2, native_exp2), CASE1(Native_exp10, native_exp10), CASE1(Native_log, native_log), CASE1(Native_log10, native_log10), CASE2(Native_powr, native_powr), CASE1(Native_recip, native_recip), CASE1(Native_rsqrt, native_rsqrt), CASE1(Native_sin, native_sin), CASE1(Native_sqrt, native_sqrt), CASE1(Native_tan, native_tan), // enum value 94 }))); // OpenCL.std: 2.1 Integer instructions INSTANTIATE_TEST_SUITE_P( OpenCLInteger, ExtInstOpenCLStdRoundTripTest, ::testing::ValuesIn(std::vector({ CASE1(SAbs, s_abs), // enum value 141 CASE2(SAbs_diff, s_abs_diff), CASE2(SAdd_sat, s_add_sat), CASE2(UAdd_sat, u_add_sat), CASE2(SHadd, s_hadd), CASE2(UHadd, u_hadd), CASE2(SRhadd, s_rhadd), CASE2(SRhadd, s_rhadd), CASE3(SClamp, s_clamp), CASE3(UClamp, u_clamp), CASE1(Clz, clz), CASE1(Ctz, ctz), CASE3(SMad_hi, s_mad_hi), CASE3(UMad_sat, u_mad_sat), CASE3(SMad_sat, s_mad_sat), CASE2(SMax, s_max), CASE2(UMax, u_max), CASE2(SMin, s_min), CASE2(UMin, u_min), CASE2(SMul_hi, s_mul_hi), CASE2(Rotate, rotate), CASE2(SSub_sat, s_sub_sat), CASE2(USub_sat, u_sub_sat), CASE2(U_Upsample, u_upsample), CASE2(S_Upsample, s_upsample), CASE1(Popcount, popcount), CASE3(SMad24, s_mad24), CASE3(UMad24, u_mad24), CASE2(SMul24, s_mul24), CASE2(UMul24, u_mul24), // enum value 170 CASE1(UAbs, u_abs), // enum value 201 CASE2(UAbs_diff, u_abs_diff), CASE2(UMul_hi, u_mul_hi), CASE3(UMad_hi, u_mad_hi), // enum value 204 }))); // OpenCL.std: 2.3 Common instructions INSTANTIATE_TEST_SUITE_P( OpenCLCommon, ExtInstOpenCLStdRoundTripTest, ::testing::ValuesIn(std::vector({ CASE3(FClamp, fclamp), // enum value 95 CASE1(Degrees, degrees), CASE2(FMax_common, fmax_common), CASE2(FMin_common, fmin_common), CASE3(Mix, mix), CASE1(Radians, radians), CASE2(Step, step), CASE3(Smoothstep, smoothstep), CASE1(Sign, sign), // enum value 103 }))); // OpenCL.std: 2.4 Geometric instructions INSTANTIATE_TEST_SUITE_P( OpenCLGeometric, ExtInstOpenCLStdRoundTripTest, ::testing::ValuesIn(std::vector({ CASE2(Cross, cross), // enum value 104 CASE2(Distance, distance), CASE1(Length, length), CASE1(Normalize, normalize), CASE2(Fast_distance, fast_distance), CASE1(Fast_length, fast_length), CASE1(Fast_normalize, fast_normalize), // enum value 110 }))); // OpenCL.std: 2.5 Relational instructions INSTANTIATE_TEST_SUITE_P( OpenCLRelational, ExtInstOpenCLStdRoundTripTest, ::testing::ValuesIn(std::vector({ CASE3(Bitselect, bitselect), // enum value 186 CASE3(Select, select), // enum value 187 }))); // OpenCL.std: 2.6 Vector data load and store instructions INSTANTIATE_TEST_SUITE_P( OpenCLVectorLoadStore, ExtInstOpenCLStdRoundTripTest, ::testing::ValuesIn(std::vector({ // The last argument to Vloadn must be one of 2, 3, 4, 8, 16. CASE2Lit(Vloadn, vloadn, 2), CASE2Lit(Vloadn, vloadn, 3), CASE2Lit(Vloadn, vloadn, 4), CASE2Lit(Vloadn, vloadn, 8), CASE2Lit(Vloadn, vloadn, 16), CASE3(Vstoren, vstoren), CASE2(Vload_half, vload_half), CASE2Lit(Vload_halfn, vload_halfn, 2), CASE2Lit(Vload_halfn, vload_halfn, 3), CASE2Lit(Vload_halfn, vload_halfn, 4), CASE2Lit(Vload_halfn, vload_halfn, 8), CASE2Lit(Vload_halfn, vload_halfn, 16), CASE3(Vstore_half, vstore_half), // Try all the rounding modes. CASE3Round(Vstore_half_r, vstore_half_r, RTE), CASE3Round(Vstore_half_r, vstore_half_r, RTZ), CASE3Round(Vstore_half_r, vstore_half_r, RTP), CASE3Round(Vstore_half_r, vstore_half_r, RTN), CASE3(Vstore_halfn, vstore_halfn), CASE3Round(Vstore_halfn_r, vstore_halfn_r, RTE), CASE3Round(Vstore_halfn_r, vstore_halfn_r, RTZ), CASE3Round(Vstore_halfn_r, vstore_halfn_r, RTP), CASE3Round(Vstore_halfn_r, vstore_halfn_r, RTN), CASE2Lit(Vloada_halfn, vloada_halfn, 2), CASE2Lit(Vloada_halfn, vloada_halfn, 3), CASE2Lit(Vloada_halfn, vloada_halfn, 4), CASE2Lit(Vloada_halfn, vloada_halfn, 8), CASE2Lit(Vloada_halfn, vloada_halfn, 16), CASE3(Vstorea_halfn, vstorea_halfn), CASE3Round(Vstorea_halfn_r, vstorea_halfn_r, RTE), CASE3Round(Vstorea_halfn_r, vstorea_halfn_r, RTZ), CASE3Round(Vstorea_halfn_r, vstorea_halfn_r, RTP), CASE3Round(Vstorea_halfn_r, vstorea_halfn_r, RTN), }))); // OpenCL.std: 2.7 Miscellaneous vector instructions INSTANTIATE_TEST_SUITE_P( OpenCLMiscellaneousVector, ExtInstOpenCLStdRoundTripTest, ::testing::ValuesIn(std::vector({ CASE2(Shuffle, shuffle), CASE3(Shuffle2, shuffle2), }))); // OpenCL.std: 2.8 Miscellaneous instructions #define PREFIX uint32_t(OpenCLLIB::Entrypoints::Printf), "printf" INSTANTIATE_TEST_SUITE_P( OpenCLMiscPrintf, ExtInstOpenCLStdRoundTripTest, ::testing::ValuesIn(std::vector({ // Printf is interesting because it takes a variable number of arguments. // Start with zero optional arguments. {PREFIX, "%4", {4}}, {PREFIX, "%4 %5", {4, 5}}, {PREFIX, "%4 %5 %6", {4, 5, 6}}, {PREFIX, "%4 %5 %6 %7", {4, 5, 6, 7}}, {PREFIX, "%4 %5 %6 %7 %8", {4, 5, 6, 7, 8}}, {PREFIX, "%4 %5 %6 %7 %8 %9", {4, 5, 6, 7, 8, 9}}, {PREFIX, "%4 %5 %6 %7 %8 %9 %10", {4, 5, 6, 7, 8, 9, 10}}, {PREFIX, "%4 %5 %6 %7 %8 %9 %10 %11", {4, 5, 6, 7, 8, 9, 10, 11}}, {PREFIX, "%4 %5 %6 %7 %8 %9 %10 %11 %12", {4, 5, 6, 7, 8, 9, 10, 11, 12}}, {PREFIX, "%4 %5 %6 %7 %8 %9 %10 %11 %12 %13", {4, 5, 6, 7, 8, 9, 10, 11, 12, 13}}, {PREFIX, "%4 %5 %6 %7 %8 %9 %10 %11 %12 %13 %14", {4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}}, }))); #undef PREFIX INSTANTIATE_TEST_SUITE_P( OpenCLMiscPrefetch, ExtInstOpenCLStdRoundTripTest, ::testing::ValuesIn(std::vector({ CASE2(Prefetch, prefetch), }))); // OpenCL.std: 2.9.1 Image encoding // No new instructions defined in this section. // OpenCL.std: 2.9.2 Sampler encoding // No new instructions defined in this section. // OpenCL.std: 2.9.3 Image read // No new instructions defined in this section. // Use core instruction OpImageSampleExplicitLod instead. // OpenCL.std: 2.9.4 Image write // No new instructions defined in this section. // clang-format on #undef CASE1 #undef CASE2 #undef CASE3 #undef CASE4 #undef CASE2Lit #undef CASE3Round } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fix_word_test.cpp000066400000000000000000000036701475742701700231020ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "test/unit_spirv.h" namespace spvtools { namespace { TEST(FixWord, Default) { spv_endianness_t endian; if (I32_ENDIAN_HOST == I32_ENDIAN_LITTLE) { endian = SPV_ENDIANNESS_LITTLE; } else { endian = SPV_ENDIANNESS_BIG; } uint32_t word = 0x53780921; ASSERT_EQ(word, spvFixWord(word, endian)); } TEST(FixWord, Reorder) { spv_endianness_t endian; if (I32_ENDIAN_HOST == I32_ENDIAN_LITTLE) { endian = SPV_ENDIANNESS_BIG; } else { endian = SPV_ENDIANNESS_LITTLE; } uint32_t word = 0x53780921; uint32_t result = 0x21097853; ASSERT_EQ(result, spvFixWord(word, endian)); } TEST(FixDoubleWord, Default) { spv_endianness_t endian = (I32_ENDIAN_HOST == I32_ENDIAN_LITTLE ? SPV_ENDIANNESS_LITTLE : SPV_ENDIANNESS_BIG); uint32_t low = 0x53780921; uint32_t high = 0xdeadbeef; uint64_t result = 0xdeadbeef53780921; ASSERT_EQ(result, spvFixDoubleWord(low, high, endian)); } TEST(FixDoubleWord, Reorder) { spv_endianness_t endian = (I32_ENDIAN_HOST == I32_ENDIAN_LITTLE ? SPV_ENDIANNESS_BIG : SPV_ENDIANNESS_LITTLE); uint32_t low = 0x53780921; uint32_t high = 0xdeadbeef; uint64_t result = 0xefbeadde21097853; ASSERT_EQ(result, spvFixDoubleWord(low, high, endian)); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/000077500000000000000000000000001475742701700205065ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/CMakeLists.txt000066400000000000000000000157161475742701700232600ustar00rootroot00000000000000# Copyright (c) 2019 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. if (${SPIRV_BUILD_FUZZER}) set(SOURCES fuzz_test_util.h available_instructions_test.cpp call_graph_test.cpp comparator_deep_blocks_first_test.cpp data_synonym_transformation_test.cpp equivalence_relation_test.cpp fact_manager/constant_uniform_facts_test.cpp fact_manager/data_synonym_and_id_equation_facts_test.cpp fact_manager/dead_block_facts_test.cpp fact_manager/irrelevant_value_facts_test.cpp fuzz_test_util.cpp fuzzer_pass_add_opphi_synonyms_test.cpp fuzzer_pass_construct_composites_test.cpp fuzzer_pass_donate_modules_test.cpp fuzzer_pass_outline_functions_test.cpp fuzzerutil_test.cpp instruction_descriptor_test.cpp fuzzer_pass_test.cpp replayer_test.cpp shrinker_test.cpp transformation_access_chain_test.cpp transformation_add_bit_instruction_synonym_test.cpp transformation_add_constant_boolean_test.cpp transformation_add_constant_composite_test.cpp transformation_add_constant_null_test.cpp transformation_add_constant_scalar_test.cpp transformation_add_copy_memory_test.cpp transformation_add_dead_block_test.cpp transformation_add_dead_break_test.cpp transformation_add_dead_continue_test.cpp transformation_add_early_terminator_wrapper_test.cpp transformation_add_function_test.cpp transformation_add_global_undef_test.cpp transformation_add_global_variable_test.cpp transformation_add_image_sample_unused_components_test.cpp transformation_add_local_variable_test.cpp transformation_add_loop_preheader_test.cpp transformation_add_loop_to_create_int_constant_synonym_test.cpp transformation_add_no_contraction_decoration_test.cpp transformation_add_opphi_synonym_test.cpp transformation_add_parameter_test.cpp transformation_add_relaxed_decoration_test.cpp transformation_add_synonym_test.cpp transformation_add_type_array_test.cpp transformation_add_type_boolean_test.cpp transformation_add_type_float_test.cpp transformation_add_type_function_test.cpp transformation_add_type_int_test.cpp transformation_add_type_matrix_test.cpp transformation_add_type_pointer_test.cpp transformation_add_type_struct_test.cpp transformation_add_type_vector_test.cpp transformation_adjust_branch_weights_test.cpp transformation_composite_construct_test.cpp transformation_composite_extract_test.cpp transformation_composite_insert_test.cpp transformation_compute_data_synonym_fact_closure_test.cpp transformation_duplicate_region_with_selection_test.cpp transformation_equation_instruction_test.cpp transformation_expand_vector_reduction_test.cpp transformation_flatten_conditional_branch_test.cpp transformation_function_call_test.cpp transformation_inline_function_test.cpp transformation_invert_comparison_operator_test.cpp transformation_load_test.cpp transformation_make_vector_operation_dynamic_test.cpp transformation_merge_blocks_test.cpp transformation_merge_function_returns_test.cpp transformation_move_block_down_test.cpp transformation_move_instruction_down_test.cpp transformation_mutate_pointer_test.cpp transformation_outline_function_test.cpp transformation_permute_function_parameters_test.cpp transformation_permute_phi_operands_test.cpp transformation_propagate_instruction_down_test.cpp transformation_propagate_instruction_up_test.cpp transformation_push_id_through_variable_test.cpp transformation_replace_add_sub_mul_with_carrying_extended_test.cpp transformation_replace_boolean_constant_with_constant_binary_test.cpp transformation_replace_branch_from_dead_block_with_exit_test.cpp transformation_replace_copy_object_with_store_load_test.cpp transformation_replace_constant_with_uniform_test.cpp transformation_replace_copy_memory_with_load_store_test.cpp transformation_replace_id_with_synonym_test.cpp transformation_replace_irrelevant_id_test.cpp transformation_replace_linear_algebra_instruction_test.cpp transformation_replace_load_store_with_copy_memory_test.cpp transformation_replace_opphi_id_from_dead_predecessor_test.cpp transformation_replace_opselect_with_conditional_branch_test.cpp transformation_replace_parameter_with_global_test.cpp transformation_replace_params_with_struct_test.cpp transformation_set_function_control_test.cpp transformation_set_loop_control_test.cpp transformation_set_memory_operands_mask_test.cpp transformation_set_selection_control_test.cpp transformation_split_block_test.cpp transformation_store_test.cpp transformation_swap_commutable_operands_test.cpp transformation_swap_conditional_branch_operands_test.cpp transformation_swap_function_variables_test.cpp transformation_swap_two_functions_test.cpp transformation_toggle_access_chain_instruction_test.cpp transformation_record_synonymous_constants_test.cpp transformation_vector_shuffle_test.cpp transformation_wrap_early_terminator_in_function_test.cpp transformation_wrap_region_in_selection_test.cpp transformation_wrap_vector_synonym_test.cpp uniform_buffer_element_descriptor_test.cpp ${spirv-tools_SOURCE_DIR}/tools/io.cpp) if (${SPIRV_ENABLE_LONG_FUZZER_TESTS}) # These are long-running tests that depend on random seeds. We do not want # to run them during regular whole-project CI because they may reveal # spirv-fuzz bugs in changes that are totally unrelated to spirv-fuzz, # which would be counfounding. Instead, they should be run regularly but # separately. set(SOURCES ${SOURCES} fuzzer_replayer_test.cpp fuzzer_shrinker_test.cpp) endif() add_spvtools_unittest(TARGET fuzz SRCS ${SOURCES} LIBS SPIRV-Tools-fuzz ) endif() KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/available_instructions_test.cpp000066400000000000000000000300101475742701700270070ustar00rootroot00000000000000// Copyright (c) 2021 Alastair F. Donaldson // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/available_instructions.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(AvailableInstructionsTest, BasicTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFloat 32 %9 = OpTypePointer Function %8 %10 = OpTypeFunction %6 %7 %9 %15 = OpTypeVector %8 2 %16 = OpTypePointer Private %15 %17 = OpVariable %16 Private %18 = OpConstant %8 1 %19 = OpConstant %8 2 %20 = OpConstantComposite %15 %18 %19 %21 = OpTypeVector %8 4 %22 = OpTypePointer Private %21 %23 = OpVariable %22 Private %24 = OpConstant %8 10 %25 = OpConstant %8 20 %26 = OpConstant %8 30 %27 = OpConstant %8 40 %28 = OpConstantComposite %21 %24 %25 %26 %27 %31 = OpTypeInt 32 0 %32 = OpConstant %31 0 %33 = OpTypePointer Private %8 %41 = OpTypeBool %46 = OpConstant %6 1 %54 = OpConstant %6 10 %57 = OpConstant %31 3 %61 = OpConstant %6 0 %66 = OpConstant %6 3 %4 = OpFunction %2 None %3 %5 = OpLabel %55 = OpVariable %7 Function %56 = OpVariable %9 Function %65 = OpVariable %7 Function %68 = OpVariable %7 Function OpStore %17 %20 OpStore %23 %28 OpStore %55 %54 %58 = OpAccessChain %33 %23 %57 %59 = OpLoad %8 %58 OpStore %56 %59 %60 = OpFunctionCall %6 %13 %55 %56 %100 = OpCopyObject %21 %28 %62 = OpSGreaterThan %41 %60 %61 OpSelectionMerge %64 None OpBranchConditional %62 %63 %67 %63 = OpLabel OpStore %65 %66 %101 = OpCopyObject %21 %28 OpBranch %64 %67 = OpLabel OpStore %68 %61 OpBranch %69 %69 = OpLabel OpLoopMerge %71 %72 None OpBranch %73 %73 = OpLabel %74 = OpLoad %6 %68 %75 = OpSLessThan %41 %74 %54 OpBranchConditional %75 %70 %71 %70 = OpLabel %76 = OpLoad %6 %65 %77 = OpIAdd %6 %76 %46 OpStore %65 %77 OpBranch %72 %72 = OpLabel %78 = OpLoad %6 %68 %79 = OpIAdd %6 %78 %46 OpStore %68 %79 OpBranch %69 %71 = OpLabel %102 = OpCopyObject %21 %28 OpBranch %64 %64 = OpLabel OpReturn OpFunctionEnd %13 = OpFunction %6 None %10 %11 = OpFunctionParameter %7 %12 = OpFunctionParameter %9 %14 = OpLabel %29 = OpVariable %7 Function %30 = OpLoad %6 %11 %34 = OpAccessChain %33 %17 %32 %35 = OpLoad %8 %34 %36 = OpConvertFToS %6 %35 %37 = OpIAdd %6 %30 %36 OpStore %29 %37 %38 = OpLoad %6 %11 %39 = OpLoad %8 %12 %40 = OpConvertFToS %6 %39 %42 = OpSLessThan %41 %38 %40 %103 = OpCopyObject %21 %28 OpSelectionMerge %44 None OpBranchConditional %42 %43 %48 %43 = OpLabel %45 = OpLoad %6 %29 %47 = OpIAdd %6 %45 %46 OpStore %29 %47 OpBranch %44 %48 = OpLabel %49 = OpLoad %6 %29 %50 = OpISub %6 %49 %46 OpStore %29 %50 OpBranch %44 %44 = OpLabel %51 = OpLoad %6 %29 OpReturnValue %51 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); opt::Instruction* i1 = context->get_def_use_mgr()->GetDef(55); opt::Instruction* i2 = context->get_def_use_mgr()->GetDef(101); opt::Instruction* i3 = &*context->cfg()->block(67)->begin(); opt::Instruction* i4 = context->get_def_use_mgr()->GetDef(74); opt::Instruction* i5 = context->get_def_use_mgr()->GetDef(102); opt::Instruction* i6 = context->get_def_use_mgr()->GetDef(30); opt::Instruction* i7 = context->get_def_use_mgr()->GetDef(47); opt::Instruction* i8 = context->get_def_use_mgr()->GetDef(50); opt::Instruction* i9 = context->get_def_use_mgr()->GetDef(51); { AvailableInstructions no_instructions( context.get(), [](opt::IRContext*, opt::Instruction*) -> bool { return false; }); for (auto i : {i1, i2, i3, i4, i5, i6, i7, i8, i9}) { auto available = no_instructions.GetAvailableBeforeInstruction(i); ASSERT_EQ(0, available.size()); ASSERT_TRUE(available.empty()); } } { AvailableInstructions all_instructions( context.get(), [](opt::IRContext*, opt::Instruction*) -> bool { return true; }); { auto available = all_instructions.GetAvailableBeforeInstruction(i1); ASSERT_FALSE(available.empty()); ASSERT_EQ(30, available.size()); ASSERT_EQ(spv::Op::OpTypeVoid, available[0]->opcode()); ASSERT_EQ(spv::Op::OpVariable, available[15]->opcode()); } { auto available = all_instructions.GetAvailableBeforeInstruction(i2); ASSERT_FALSE(available.empty()); ASSERT_EQ(46, available.size()); ASSERT_EQ(spv::Op::OpTypeVoid, available[0]->opcode()); ASSERT_EQ(spv::Op::OpTypePointer, available[3]->opcode()); ASSERT_EQ(spv::Op::OpVariable, available[15]->opcode()); ASSERT_EQ(spv::Op::OpFunctionCall, available[40]->opcode()); ASSERT_EQ(spv::Op::OpStore, available[45]->opcode()); } { auto available = all_instructions.GetAvailableBeforeInstruction(i3); ASSERT_FALSE(available.empty()); ASSERT_EQ(45, available.size()); ASSERT_EQ(spv::Op::OpTypeVoid, available[0]->opcode()); ASSERT_EQ(spv::Op::OpTypePointer, available[3]->opcode()); ASSERT_EQ(spv::Op::OpVariable, available[15]->opcode()); ASSERT_EQ(spv::Op::OpFunctionCall, available[40]->opcode()); ASSERT_EQ(spv::Op::OpBranchConditional, available[44]->opcode()); } { auto available = all_instructions.GetAvailableBeforeInstruction(i6); ASSERT_FALSE(available.empty()); ASSERT_EQ(33, available.size()); ASSERT_EQ(spv::Op::OpTypeVoid, available[0]->opcode()); ASSERT_EQ(spv::Op::OpTypeFloat, available[4]->opcode()); ASSERT_EQ(spv::Op::OpTypePointer, available[8]->opcode()); ASSERT_EQ(spv::Op::OpConstantComposite, available[12]->opcode()); ASSERT_EQ(spv::Op::OpConstant, available[16]->opcode()); ASSERT_EQ(spv::Op::OpFunctionParameter, available[30]->opcode()); ASSERT_EQ(spv::Op::OpFunctionParameter, available[31]->opcode()); ASSERT_EQ(spv::Op::OpVariable, available[32]->opcode()); } } { AvailableInstructions vector_instructions( context.get(), [](opt::IRContext* ir_context, opt::Instruction* inst) -> bool { return inst->type_id() != 0 && ir_context->get_type_mgr() ->GetType(inst->type_id()) ->AsVector() != nullptr; }); { auto available = vector_instructions.GetAvailableBeforeInstruction(i4); ASSERT_FALSE(available.empty()); ASSERT_EQ(3, available.size()); ASSERT_EQ(spv::Op::OpConstantComposite, available[0]->opcode()); ASSERT_EQ(spv::Op::OpConstantComposite, available[1]->opcode()); ASSERT_EQ(spv::Op::OpCopyObject, available[2]->opcode()); } { auto available = vector_instructions.GetAvailableBeforeInstruction(i5); ASSERT_FALSE(available.empty()); ASSERT_EQ(3, available.size()); ASSERT_EQ(spv::Op::OpConstantComposite, available[0]->opcode()); ASSERT_EQ(spv::Op::OpConstantComposite, available[1]->opcode()); ASSERT_EQ(spv::Op::OpCopyObject, available[2]->opcode()); } { auto available = vector_instructions.GetAvailableBeforeInstruction(i6); ASSERT_FALSE(available.empty()); ASSERT_EQ(2, available.size()); ASSERT_EQ(spv::Op::OpConstantComposite, available[0]->opcode()); ASSERT_EQ(spv::Op::OpConstantComposite, available[1]->opcode()); } } { AvailableInstructions integer_add_instructions( context.get(), [](opt::IRContext*, opt::Instruction* inst) -> bool { return inst->opcode() == spv::Op::OpIAdd; }); { auto available = integer_add_instructions.GetAvailableBeforeInstruction(i7); ASSERT_FALSE(available.empty()); ASSERT_EQ(1, available.size()); ASSERT_EQ(spv::Op::OpIAdd, available[0]->opcode()); } { auto available = integer_add_instructions.GetAvailableBeforeInstruction(i8); ASSERT_FALSE(available.empty()); ASSERT_EQ(1, available.size()); ASSERT_EQ(spv::Op::OpIAdd, available[0]->opcode()); } { auto available = integer_add_instructions.GetAvailableBeforeInstruction(i9); ASSERT_FALSE(available.empty()); ASSERT_EQ(1, available.size()); ASSERT_EQ(spv::Op::OpIAdd, available[0]->opcode()); } } } TEST(AvailableInstructionsTest, UnreachableBlock) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpName %4 "main" OpName %8 "x" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpStore %8 %9 %12 = OpLoad %6 %8 OpReturn %10 = OpLabel %11 = OpLoad %6 %8 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); AvailableInstructions all_instructions( context.get(), [](opt::IRContext*, opt::Instruction*) -> bool { return true; }); ASSERT_EQ(7, all_instructions .GetAvailableBeforeInstruction( context->get_def_use_mgr()->GetDef(12)) .size()); #ifndef NDEBUG ASSERT_DEATH(all_instructions.GetAvailableBeforeInstruction( context->get_def_use_mgr()->GetDef(11)), "Availability can only be queried for reachable instructions."); #endif } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/call_graph_test.cpp000066400000000000000000000266441475742701700243610ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/call_graph.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { // The SPIR-V came from this GLSL, slightly modified // (main is %2, A is %35, B is %48, C is %50, D is %61): // // #version 310 es // // int A (int x) { // return x + 1; // } // // void D() { // } // // void C() { // int x = 0; // int y = 0; // // while (x < 10) { // while (y < 10) { // y = A(y); // } // x = A(x); // } // } // // void B () { // int x = 0; // int y = 0; // // while (x < 10) { // D(); // while (y < 10) { // y = A(y); // C(); // } // x++; // } // // } // // void main() // { // int x = 0; // int y = 0; // int z = 0; // // while (x < 10) { // while(y < 10) { // y = A(x); // while (z < 10) { // z = A(z); // } // } // x += 2; // } // // B(); // C(); // } std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpTypeFunction %5 %6 %8 = OpConstant %5 1 %9 = OpConstant %5 0 %10 = OpConstant %5 10 %11 = OpTypeBool %12 = OpConstant %5 2 %2 = OpFunction %3 None %4 %13 = OpLabel %14 = OpVariable %6 Function %15 = OpVariable %6 Function %16 = OpVariable %6 Function %17 = OpVariable %6 Function %18 = OpVariable %6 Function OpStore %14 %9 OpStore %15 %9 OpStore %16 %9 OpBranch %19 %19 = OpLabel OpLoopMerge %20 %21 None OpBranch %22 %22 = OpLabel %23 = OpLoad %5 %14 %24 = OpSLessThan %11 %23 %10 OpBranchConditional %24 %25 %20 %25 = OpLabel OpBranch %26 %26 = OpLabel OpLoopMerge %27 %28 None OpBranch %29 %29 = OpLabel %30 = OpLoad %5 %15 %31 = OpSLessThan %11 %30 %10 OpBranchConditional %31 %32 %27 %32 = OpLabel %33 = OpLoad %5 %14 OpStore %17 %33 %34 = OpFunctionCall %5 %35 %17 OpStore %15 %34 OpBranch %36 %36 = OpLabel OpLoopMerge %37 %38 None OpBranch %39 %39 = OpLabel %40 = OpLoad %5 %16 %41 = OpSLessThan %11 %40 %10 OpBranchConditional %41 %42 %37 %42 = OpLabel %43 = OpLoad %5 %16 OpStore %18 %43 %44 = OpFunctionCall %5 %35 %18 OpStore %16 %44 OpBranch %38 %38 = OpLabel OpBranch %36 %37 = OpLabel OpBranch %28 %28 = OpLabel OpBranch %26 %27 = OpLabel %45 = OpLoad %5 %14 %46 = OpIAdd %5 %45 %12 OpStore %14 %46 OpBranch %21 %21 = OpLabel OpBranch %19 %20 = OpLabel %47 = OpFunctionCall %3 %48 %49 = OpFunctionCall %3 %50 OpReturn OpFunctionEnd %35 = OpFunction %5 None %7 %51 = OpFunctionParameter %6 %52 = OpLabel %53 = OpLoad %5 %51 %54 = OpIAdd %5 %53 %8 OpReturnValue %54 OpFunctionEnd %48 = OpFunction %3 None %4 %55 = OpLabel %56 = OpVariable %6 Function %57 = OpVariable %6 Function %58 = OpVariable %6 Function OpStore %56 %9 OpStore %57 %9 OpBranch %59 %59 = OpLabel %60 = OpFunctionCall %3 %61 OpLoopMerge %62 %63 None OpBranch %64 %64 = OpLabel OpLoopMerge %65 %66 None OpBranch %67 %67 = OpLabel %68 = OpLoad %5 %57 %69 = OpSLessThan %11 %68 %10 OpBranchConditional %69 %70 %65 %70 = OpLabel %71 = OpLoad %5 %57 OpStore %58 %71 %72 = OpFunctionCall %5 %35 %58 OpStore %57 %72 %73 = OpFunctionCall %3 %50 OpBranch %66 %66 = OpLabel OpBranch %64 %65 = OpLabel %74 = OpLoad %5 %56 %75 = OpIAdd %5 %74 %8 OpStore %56 %75 OpBranch %63 %63 = OpLabel %76 = OpLoad %5 %56 %77 = OpSLessThan %11 %76 %10 OpBranchConditional %77 %59 %62 %62 = OpLabel OpReturn OpFunctionEnd %50 = OpFunction %3 None %4 %78 = OpLabel %79 = OpVariable %6 Function %80 = OpVariable %6 Function %81 = OpVariable %6 Function %82 = OpVariable %6 Function OpStore %79 %9 OpStore %80 %9 OpBranch %83 %83 = OpLabel OpLoopMerge %84 %85 None OpBranch %86 %86 = OpLabel %87 = OpLoad %5 %79 %88 = OpSLessThan %11 %87 %10 OpBranchConditional %88 %89 %84 %89 = OpLabel OpBranch %90 %90 = OpLabel OpLoopMerge %91 %92 None OpBranch %93 %93 = OpLabel %94 = OpLoad %5 %80 %95 = OpSLessThan %11 %94 %10 OpBranchConditional %95 %96 %91 %96 = OpLabel %97 = OpLoad %5 %80 OpStore %81 %97 %98 = OpFunctionCall %5 %35 %81 OpStore %80 %98 OpBranch %92 %92 = OpLabel OpBranch %90 %91 = OpLabel %99 = OpLoad %5 %79 OpStore %82 %99 %100 = OpFunctionCall %5 %35 %82 OpStore %79 %100 OpBranch %85 %85 = OpLabel OpBranch %83 %84 = OpLabel OpReturn OpFunctionEnd %61 = OpFunction %3 None %4 %101 = OpLabel OpReturn OpFunctionEnd )"; // We have that: // main calls: // - A (maximum loop nesting depth of function call: 3) // - B (0) // - C (0) // A calls nothing. // B calls: // - A (2) // - C (2) // - D (1) // C calls: // - A (2) // D calls nothing. TEST(CallGraphTest, FunctionInDegree) { const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); const auto graph = CallGraph(context.get()); const auto& function_in_degree = graph.GetFunctionInDegree(); // Check the in-degrees of, in order: main, A, B, C, D. ASSERT_EQ(function_in_degree.at(2), 0); ASSERT_EQ(function_in_degree.at(35), 3); ASSERT_EQ(function_in_degree.at(48), 1); ASSERT_EQ(function_in_degree.at(50), 2); ASSERT_EQ(function_in_degree.at(61), 1); } TEST(CallGraphTest, DirectCallees) { const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); const auto graph = CallGraph(context.get()); // Check the callee sets of, in order: main, A, B, C, D. ASSERT_EQ(graph.GetDirectCallees(2), std::set({35, 48, 50})); ASSERT_EQ(graph.GetDirectCallees(35), std::set({})); ASSERT_EQ(graph.GetDirectCallees(48), std::set({35, 50, 61})); ASSERT_EQ(graph.GetDirectCallees(50), std::set({35})); ASSERT_EQ(graph.GetDirectCallees(61), std::set({})); } TEST(CallGraphTest, IndirectCallees) { const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); const auto graph = CallGraph(context.get()); // Check the callee sets of, in order: main, A, B, C, D. ASSERT_EQ(graph.GetIndirectCallees(2), std::set({35, 48, 50, 61})); ASSERT_EQ(graph.GetDirectCallees(35), std::set({})); ASSERT_EQ(graph.GetDirectCallees(48), std::set({35, 50, 61})); ASSERT_EQ(graph.GetDirectCallees(50), std::set({35})); ASSERT_EQ(graph.GetDirectCallees(61), std::set({})); } TEST(CallGraphTest, TopologicalOrder) { const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); const auto graph = CallGraph(context.get()); const auto& topological_ordering = graph.GetFunctionsInTopologicalOrder(); // The possible topological orderings are: // - main, B, D, C, A // - main, B, C, D, A // - main, B, C, A, D ASSERT_TRUE( topological_ordering == std::vector({2, 48, 61, 50, 35}) || topological_ordering == std::vector({2, 48, 50, 61, 35}) || topological_ordering == std::vector({2, 48, 50, 35, 61})); } TEST(CallGraphTest, LoopNestingDepth) { const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); const auto graph = CallGraph(context.get()); // Check the maximum loop nesting depth for function calls to, in order: // main, A, B, C, D ASSERT_EQ(graph.GetMaxCallNestingDepth(2), 0); ASSERT_EQ(graph.GetMaxCallNestingDepth(35), 4); ASSERT_EQ(graph.GetMaxCallNestingDepth(48), 0); ASSERT_EQ(graph.GetMaxCallNestingDepth(50), 2); ASSERT_EQ(graph.GetMaxCallNestingDepth(61), 1); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/comparator_deep_blocks_first_test.cpp000066400000000000000000000113661475742701700301700ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/comparator_deep_blocks_first.h" #include "gtest/gtest.h" #include "source/fuzz/fact_manager/fact_manager.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/pseudo_random_generator.h" #include "source/fuzz/transformation_context.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpTypeInt 32 1 %8 = OpTypePointer Function %7 %9 = OpConstant %7 1 %10 = OpConstant %7 10 %11 = OpConstant %7 2 %2 = OpFunction %3 None %4 %12 = OpLabel OpSelectionMerge %13 None OpBranchConditional %6 %14 %15 %14 = OpLabel OpBranch %13 %15 = OpLabel OpBranch %16 %16 = OpLabel OpLoopMerge %17 %18 None OpBranch %19 %19 = OpLabel OpBranchConditional %6 %20 %17 %20 = OpLabel OpSelectionMerge %21 None OpBranchConditional %6 %22 %23 %22 = OpLabel OpBranch %21 %23 = OpLabel OpBranch %21 %21 = OpLabel OpBranch %18 %18 = OpLabel OpBranch %16 %17 = OpLabel OpBranch %13 %13 = OpLabel OpReturn OpFunctionEnd )"; TEST(ComparatorDeepBlocksFirstTest, Compare) { const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto is_deeper = ComparatorDeepBlocksFirst(context.get()); // The block ids and the corresponding depths are: // 12, 13 -> depth 0 // 14, 15, 16, 17 -> depth 1 // 18, 19, 20, 21 -> depth 2 // 22, 23 -> depth 3 // Perform some comparisons and check that they return true iff the first // block is deeper than the second. ASSERT_FALSE(is_deeper(12, 12)); ASSERT_FALSE(is_deeper(12, 13)); ASSERT_FALSE(is_deeper(12, 14)); ASSERT_FALSE(is_deeper(12, 18)); ASSERT_FALSE(is_deeper(12, 22)); ASSERT_TRUE(is_deeper(14, 12)); ASSERT_FALSE(is_deeper(14, 15)); ASSERT_FALSE(is_deeper(15, 14)); ASSERT_FALSE(is_deeper(14, 18)); ASSERT_TRUE(is_deeper(18, 12)); ASSERT_TRUE(is_deeper(18, 16)); } TEST(ComparatorDeepBlocksFirstTest, Sort) { const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Check that, sorting using the comparator, the blocks are ordered from more // deeply nested to less deeply nested. // 17 has depth 1, 20 has depth 2, 13 has depth 0. std::vector blocks = {context->get_instr_block(17), context->get_instr_block(20), context->get_instr_block(13)}; std::sort(blocks.begin(), blocks.end(), ComparatorDeepBlocksFirst(context.get())); // Check that the blocks are in the correct order. ASSERT_EQ(blocks[0]->id(), 20); ASSERT_EQ(blocks[1]->id(), 17); ASSERT_EQ(blocks[2]->id(), 13); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/data_synonym_transformation_test.cpp000066400000000000000000001530541475742701700301140ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/data_descriptor.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/id_use_descriptor.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/transformation_composite_extract.h" #include "source/fuzz/transformation_replace_id_with_synonym.h" #include "source/fuzz/transformation_vector_shuffle.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { // This file captures tests that check correctness of the collective use of a // number of transformations that relate to data synonyms. protobufs::Fact MakeSynonymFact(uint32_t first_id, const std::vector& first_indices, uint32_t second_id, const std::vector& second_indices) { protobufs::FactDataSynonym data_synonym_fact; *data_synonym_fact.mutable_data1() = MakeDataDescriptor(first_id, first_indices); *data_synonym_fact.mutable_data2() = MakeDataDescriptor(second_id, second_indices); protobufs::Fact result; *result.mutable_data_synonym_fact() = data_synonym_fact; return result; } TEST(DataSynonymTransformationTest, ArrayCompositeSynonyms) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %11 "A" OpName %20 "B" OpName %31 "g" OpName %35 "h" OpDecorate %11 RelaxedPrecision OpDecorate %22 RelaxedPrecision OpDecorate %27 RelaxedPrecision OpDecorate %35 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %40 RelaxedPrecision OpDecorate %41 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeInt 32 0 %8 = OpConstant %7 3 %9 = OpTypeArray %6 %8 %10 = OpTypePointer Function %9 %12 = OpConstant %6 0 %13 = OpConstant %6 3 %14 = OpTypePointer Function %6 %16 = OpTypeFloat 32 %17 = OpConstant %7 4 %18 = OpTypeArray %16 %17 %19 = OpTypePointer Function %18 %24 = OpTypePointer Function %16 %28 = OpConstant %16 42 %30 = OpConstant %6 2 %34 = OpConstant %6 1 %38 = OpConstant %6 42 %4 = OpFunction %2 None %3 %5 = OpLabel %11 = OpVariable %10 Function %20 = OpVariable %19 Function %31 = OpVariable %24 Function %35 = OpVariable %14 Function %15 = OpAccessChain %14 %11 %12 %21 = OpAccessChain %14 %11 %12 %22 = OpLoad %6 %21 %100 = OpCompositeConstruct %9 %12 %13 %22 OpStore %15 %13 %23 = OpConvertSToF %16 %22 %25 = OpAccessChain %24 %20 %12 OpStore %25 %23 %26 = OpAccessChain %14 %11 %12 %27 = OpLoad %6 %26 %29 = OpAccessChain %24 %20 %27 OpStore %29 %28 %32 = OpLoad %16 %31 %101 = OpCompositeConstruct %18 %28 %23 %32 %23 %50 = OpCopyObject %16 %23 %51 = OpCopyObject %16 %23 %33 = OpAccessChain %24 %20 %30 OpStore %33 %28 OpStore %33 %32 %36 = OpLoad %6 %35 %37 = OpAccessChain %14 %11 %34 OpStore %37 %36 %39 = OpAccessChain %14 %11 %12 %40 = OpLoad %6 %39 %41 = OpIAdd %6 %38 %40 %42 = OpAccessChain %14 %11 %30 OpStore %42 %41 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(12, {}, 100, {0})); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(13, {}, 100, {1})); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(22, {}, 100, {2})); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(28, {}, 101, {0})); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(23, {}, 101, {1})); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(32, {}, 101, {2})); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(23, {}, 101, {3})); // Replace %12 with %100[0] in '%25 = OpAccessChain %24 %20 %12' auto instruction_descriptor_1 = MakeInstructionDescriptor(25, spv::Op::OpAccessChain, 0); auto good_extract_1 = TransformationCompositeExtract(instruction_descriptor_1, 102, 100, {0}); // Bad: id already in use auto bad_extract_1 = TransformationCompositeExtract( MakeInstructionDescriptor(25, spv::Op::OpAccessChain, 0), 25, 100, {0}); ASSERT_TRUE( good_extract_1.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( bad_extract_1.IsApplicable(context.get(), transformation_context)); good_extract_1.Apply(context.get(), &transformation_context); auto replacement_1 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor(12, instruction_descriptor_1, 1), 102); ASSERT_TRUE( replacement_1.IsApplicable(context.get(), transformation_context)); replacement_1.Apply(context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Replace %13 with %100[1] in 'OpStore %15 %13' auto instruction_descriptor_2 = MakeInstructionDescriptor(100, spv::Op::OpStore, 0); auto good_extract_2 = TransformationCompositeExtract(instruction_descriptor_2, 103, 100, {1}); // No bad example provided here. ASSERT_TRUE( good_extract_2.IsApplicable(context.get(), transformation_context)); good_extract_2.Apply(context.get(), &transformation_context); auto replacement_2 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor(13, instruction_descriptor_2, 1), 103); ASSERT_TRUE( replacement_2.IsApplicable(context.get(), transformation_context)); replacement_2.Apply(context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Replace %22 with %100[2] in '%23 = OpConvertSToF %16 %22' auto instruction_descriptor_3 = MakeInstructionDescriptor(23, spv::Op::OpConvertSToF, 0); auto good_extract_3 = TransformationCompositeExtract(instruction_descriptor_3, 104, 100, {2}); ASSERT_TRUE( good_extract_3.IsApplicable(context.get(), transformation_context)); good_extract_3.Apply(context.get(), &transformation_context); auto replacement_3 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor(22, instruction_descriptor_3, 0), 104); // Bad: wrong input operand index auto bad_replacement_3 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor(22, instruction_descriptor_3, 1), 104); ASSERT_TRUE( replacement_3.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( bad_replacement_3.IsApplicable(context.get(), transformation_context)); replacement_3.Apply(context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Replace %28 with %101[0] in 'OpStore %33 %28' auto instruction_descriptor_4 = MakeInstructionDescriptor(33, spv::Op::OpStore, 0); auto good_extract_4 = TransformationCompositeExtract(instruction_descriptor_4, 105, 101, {0}); // Bad: instruction descriptor does not identify an appropriate instruction auto bad_extract_4 = TransformationCompositeExtract( MakeInstructionDescriptor(33, spv::Op::OpCopyObject, 0), 105, 101, {0}); ASSERT_TRUE( good_extract_4.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( bad_extract_4.IsApplicable(context.get(), transformation_context)); good_extract_4.Apply(context.get(), &transformation_context); auto replacement_4 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor(28, instruction_descriptor_4, 1), 105); ASSERT_TRUE( replacement_4.IsApplicable(context.get(), transformation_context)); replacement_4.Apply(context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Replace %23 with %101[1] in '%50 = OpCopyObject %16 %23' auto instruction_descriptor_5 = MakeInstructionDescriptor(50, spv::Op::OpCopyObject, 0); auto good_extract_5 = TransformationCompositeExtract(instruction_descriptor_5, 106, 101, {1}); ASSERT_TRUE( good_extract_5.IsApplicable(context.get(), transformation_context)); good_extract_5.Apply(context.get(), &transformation_context); auto replacement_5 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor(23, instruction_descriptor_5, 0), 106); // Bad: wrong synonym fact being used auto bad_replacement_5 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor(23, instruction_descriptor_5, 0), 105); ASSERT_TRUE( replacement_5.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( bad_replacement_5.IsApplicable(context.get(), transformation_context)); replacement_5.Apply(context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Replace %32 with %101[2] in 'OpStore %33 %32' auto instruction_descriptor_6 = MakeInstructionDescriptor(33, spv::Op::OpStore, 1); auto good_extract_6 = TransformationCompositeExtract(instruction_descriptor_6, 107, 101, {2}); // Bad: id 1001 does not exist auto bad_extract_6 = TransformationCompositeExtract(instruction_descriptor_6, 107, 1001, {2}); ASSERT_TRUE( good_extract_6.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( bad_extract_6.IsApplicable(context.get(), transformation_context)); good_extract_6.Apply(context.get(), &transformation_context); auto replacement_6 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor(32, instruction_descriptor_6, 1), 107); ASSERT_TRUE( replacement_6.IsApplicable(context.get(), transformation_context)); replacement_6.Apply(context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Replace %23 with %101[3] in '%51 = OpCopyObject %16 %23' auto instruction_descriptor_7 = MakeInstructionDescriptor(51, spv::Op::OpCopyObject, 0); auto good_extract_7 = TransformationCompositeExtract(instruction_descriptor_7, 108, 101, {3}); ASSERT_TRUE( good_extract_7.IsApplicable(context.get(), transformation_context)); good_extract_7.Apply(context.get(), &transformation_context); auto replacement_7 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor(23, instruction_descriptor_7, 0), 108); // Bad: use id 0 is invalid auto bad_replacement_7 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor(0, instruction_descriptor_7, 0), 108); ASSERT_TRUE( replacement_7.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( bad_replacement_7.IsApplicable(context.get(), transformation_context)); replacement_7.Apply(context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); const std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %11 "A" OpName %20 "B" OpName %31 "g" OpName %35 "h" OpDecorate %11 RelaxedPrecision OpDecorate %22 RelaxedPrecision OpDecorate %27 RelaxedPrecision OpDecorate %35 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %40 RelaxedPrecision OpDecorate %41 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeInt 32 0 %8 = OpConstant %7 3 %9 = OpTypeArray %6 %8 %10 = OpTypePointer Function %9 %12 = OpConstant %6 0 %13 = OpConstant %6 3 %14 = OpTypePointer Function %6 %16 = OpTypeFloat 32 %17 = OpConstant %7 4 %18 = OpTypeArray %16 %17 %19 = OpTypePointer Function %18 %24 = OpTypePointer Function %16 %28 = OpConstant %16 42 %30 = OpConstant %6 2 %34 = OpConstant %6 1 %38 = OpConstant %6 42 %4 = OpFunction %2 None %3 %5 = OpLabel %11 = OpVariable %10 Function %20 = OpVariable %19 Function %31 = OpVariable %24 Function %35 = OpVariable %14 Function %15 = OpAccessChain %14 %11 %12 %21 = OpAccessChain %14 %11 %12 %22 = OpLoad %6 %21 %100 = OpCompositeConstruct %9 %12 %13 %22 %103 = OpCompositeExtract %6 %100 1 OpStore %15 %103 %104 = OpCompositeExtract %6 %100 2 %23 = OpConvertSToF %16 %104 %102 = OpCompositeExtract %6 %100 0 %25 = OpAccessChain %24 %20 %102 OpStore %25 %23 %26 = OpAccessChain %14 %11 %12 %27 = OpLoad %6 %26 %29 = OpAccessChain %24 %20 %27 OpStore %29 %28 %32 = OpLoad %16 %31 %101 = OpCompositeConstruct %18 %28 %23 %32 %23 %106 = OpCompositeExtract %16 %101 1 %50 = OpCopyObject %16 %106 %108 = OpCompositeExtract %16 %101 3 %51 = OpCopyObject %16 %108 %33 = OpAccessChain %24 %20 %30 %105 = OpCompositeExtract %16 %101 0 OpStore %33 %105 %107 = OpCompositeExtract %16 %101 2 OpStore %33 %107 %36 = OpLoad %6 %35 %37 = OpAccessChain %14 %11 %34 OpStore %37 %36 %39 = OpAccessChain %14 %11 %12 %40 = OpLoad %6 %39 %41 = OpIAdd %6 %38 %40 %42 = OpAccessChain %14 %11 %30 OpStore %42 %41 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(DataSynonymTransformationTest, MatrixCompositeSynonyms) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %10 "m" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %50 = OpUndef %7 %8 = OpTypeMatrix %7 3 %9 = OpTypePointer Function %8 %11 = OpTypeInt 32 1 %12 = OpConstant %11 0 %13 = OpConstant %6 1 %14 = OpConstantComposite %7 %13 %13 %13 %13 %15 = OpTypePointer Function %7 %17 = OpConstant %11 1 %18 = OpConstant %6 2 %19 = OpConstantComposite %7 %18 %18 %18 %18 %21 = OpConstant %11 2 %4 = OpFunction %2 None %3 %5 = OpLabel %10 = OpVariable %9 Function %16 = OpAccessChain %15 %10 %12 OpStore %16 %14 %20 = OpAccessChain %15 %10 %17 OpStore %20 %19 %22 = OpAccessChain %15 %10 %12 %23 = OpLoad %7 %22 %24 = OpAccessChain %15 %10 %17 %25 = OpLoad %7 %24 %100 = OpCompositeConstruct %8 %23 %25 %50 %26 = OpFAdd %7 %23 %25 %27 = OpAccessChain %15 %10 %21 OpStore %27 %26 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(23, {}, 100, {0})); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(25, {}, 100, {1})); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(50, {}, 100, {2})); // Replace %23 with %100[0] in '%26 = OpFAdd %7 %23 %25' auto instruction_descriptor_1 = MakeInstructionDescriptor(26, spv::Op::OpFAdd, 0); auto extract_1 = TransformationCompositeExtract(instruction_descriptor_1, 101, 100, {0}); ASSERT_TRUE(extract_1.IsApplicable(context.get(), transformation_context)); extract_1.Apply(context.get(), &transformation_context); auto replacement_1 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor(23, instruction_descriptor_1, 0), 101); ASSERT_TRUE( replacement_1.IsApplicable(context.get(), transformation_context)); replacement_1.Apply(context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Replace %25 with %100[1] in '%26 = OpFAdd %7 %23 %25' auto instruction_descriptor_2 = MakeInstructionDescriptor(26, spv::Op::OpFAdd, 0); auto extract_2 = TransformationCompositeExtract(instruction_descriptor_2, 102, 100, {1}); ASSERT_TRUE(extract_2.IsApplicable(context.get(), transformation_context)); extract_2.Apply(context.get(), &transformation_context); auto replacement_2 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor(25, instruction_descriptor_2, 1), 102); ASSERT_TRUE( replacement_2.IsApplicable(context.get(), transformation_context)); replacement_2.Apply(context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); const std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %10 "m" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %50 = OpUndef %7 %8 = OpTypeMatrix %7 3 %9 = OpTypePointer Function %8 %11 = OpTypeInt 32 1 %12 = OpConstant %11 0 %13 = OpConstant %6 1 %14 = OpConstantComposite %7 %13 %13 %13 %13 %15 = OpTypePointer Function %7 %17 = OpConstant %11 1 %18 = OpConstant %6 2 %19 = OpConstantComposite %7 %18 %18 %18 %18 %21 = OpConstant %11 2 %4 = OpFunction %2 None %3 %5 = OpLabel %10 = OpVariable %9 Function %16 = OpAccessChain %15 %10 %12 OpStore %16 %14 %20 = OpAccessChain %15 %10 %17 OpStore %20 %19 %22 = OpAccessChain %15 %10 %12 %23 = OpLoad %7 %22 %24 = OpAccessChain %15 %10 %17 %25 = OpLoad %7 %24 %100 = OpCompositeConstruct %8 %23 %25 %50 %101 = OpCompositeExtract %7 %100 0 %102 = OpCompositeExtract %7 %100 1 %26 = OpFAdd %7 %101 %102 %27 = OpAccessChain %15 %10 %21 OpStore %27 %26 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(DataSynonymTransformationTest, StructCompositeSynonyms) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %9 "Inner" OpMemberName %9 0 "a" OpMemberName %9 1 "b" OpName %11 "i1" OpName %17 "i2" OpName %31 "Point" OpMemberName %31 0 "x" OpMemberName %31 1 "y" OpMemberName %31 2 "z" OpName %32 "Outer" OpMemberName %32 0 "c" OpMemberName %32 1 "d" OpName %34 "o1" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeFloat 32 %8 = OpTypeVector %7 2 %9 = OpTypeStruct %6 %8 %10 = OpTypePointer Function %9 %12 = OpConstant %6 1 %13 = OpConstant %7 2 %14 = OpConstant %7 3 %15 = OpConstantComposite %8 %13 %14 %16 = OpConstantComposite %9 %12 %15 %18 = OpConstant %6 0 %19 = OpTypePointer Function %6 %24 = OpTypePointer Function %8 %27 = OpConstant %7 4 %31 = OpTypeStruct %7 %7 %7 %32 = OpTypeStruct %9 %31 %33 = OpTypePointer Function %32 %36 = OpConstant %7 10 %37 = OpTypeInt 32 0 %38 = OpConstant %37 0 %39 = OpTypePointer Function %7 %42 = OpConstant %37 1 %4 = OpFunction %2 None %3 %5 = OpLabel %11 = OpVariable %10 Function %17 = OpVariable %10 Function %34 = OpVariable %33 Function %101 = OpCompositeConstruct %31 %27 %36 %27 OpStore %11 %16 %20 = OpAccessChain %19 %11 %18 %21 = OpLoad %6 %20 %22 = OpIAdd %6 %21 %12 %102 = OpCompositeConstruct %9 %22 %15 %23 = OpAccessChain %19 %17 %18 OpStore %23 %22 %25 = OpAccessChain %24 %17 %12 %26 = OpLoad %8 %25 %28 = OpCompositeConstruct %8 %27 %27 %29 = OpFAdd %8 %26 %28 %30 = OpAccessChain %24 %17 %12 OpStore %30 %29 %35 = OpLoad %9 %11 %40 = OpAccessChain %39 %11 %12 %38 %41 = OpLoad %7 %40 %43 = OpAccessChain %39 %11 %12 %42 %44 = OpLoad %7 %43 %45 = OpCompositeConstruct %31 %36 %41 %44 %100 = OpCompositeConstruct %32 %16 %45 %46 = OpCompositeConstruct %32 %35 %45 OpStore %34 %46 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(16, {}, 100, {0})); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(45, {}, 100, {1})); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(27, {}, 101, {0})); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(36, {}, 101, {1})); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(27, {}, 101, {2})); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(22, {}, 102, {0})); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(15, {}, 102, {1})); // Replace %45 with %100[1] in '%46 = OpCompositeConstruct %32 %35 %45' auto instruction_descriptor_1 = MakeInstructionDescriptor(46, spv::Op::OpCompositeConstruct, 0); auto extract_1 = TransformationCompositeExtract(instruction_descriptor_1, 201, 100, {1}); ASSERT_TRUE(extract_1.IsApplicable(context.get(), transformation_context)); extract_1.Apply(context.get(), &transformation_context); auto replacement_1 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor(45, instruction_descriptor_1, 1), 201); ASSERT_TRUE( replacement_1.IsApplicable(context.get(), transformation_context)); replacement_1.Apply(context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Replace second occurrence of %27 with %101[0] in '%28 = // OpCompositeConstruct %8 %27 %27' auto instruction_descriptor_2 = MakeInstructionDescriptor(28, spv::Op::OpCompositeConstruct, 0); auto extract_2 = TransformationCompositeExtract(instruction_descriptor_2, 202, 101, {0}); ASSERT_TRUE(extract_2.IsApplicable(context.get(), transformation_context)); extract_2.Apply(context.get(), &transformation_context); auto replacement_2 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor(27, instruction_descriptor_2, 1), 202); ASSERT_TRUE( replacement_2.IsApplicable(context.get(), transformation_context)); replacement_2.Apply(context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Replace %36 with %101[1] in '%45 = OpCompositeConstruct %31 %36 %41 %44' auto instruction_descriptor_3 = MakeInstructionDescriptor(45, spv::Op::OpCompositeConstruct, 0); auto extract_3 = TransformationCompositeExtract(instruction_descriptor_3, 203, 101, {1}); ASSERT_TRUE(extract_3.IsApplicable(context.get(), transformation_context)); extract_3.Apply(context.get(), &transformation_context); auto replacement_3 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor(36, instruction_descriptor_3, 0), 203); ASSERT_TRUE( replacement_3.IsApplicable(context.get(), transformation_context)); replacement_3.Apply(context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Replace first occurrence of %27 with %101[2] in '%28 = OpCompositeConstruct // %8 %27 %27' auto instruction_descriptor_4 = MakeInstructionDescriptor(28, spv::Op::OpCompositeConstruct, 0); auto extract_4 = TransformationCompositeExtract(instruction_descriptor_4, 204, 101, {2}); ASSERT_TRUE(extract_4.IsApplicable(context.get(), transformation_context)); extract_4.Apply(context.get(), &transformation_context); auto replacement_4 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor(27, instruction_descriptor_4, 0), 204); ASSERT_TRUE( replacement_4.IsApplicable(context.get(), transformation_context)); replacement_4.Apply(context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Replace %22 with %102[0] in 'OpStore %23 %22' auto instruction_descriptor_5 = MakeInstructionDescriptor(23, spv::Op::OpStore, 0); auto extract_5 = TransformationCompositeExtract(instruction_descriptor_5, 205, 102, {0}); ASSERT_TRUE(extract_5.IsApplicable(context.get(), transformation_context)); extract_5.Apply(context.get(), &transformation_context); auto replacement_5 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor(22, instruction_descriptor_5, 1), 205); ASSERT_TRUE( replacement_5.IsApplicable(context.get(), transformation_context)); replacement_5.Apply(context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); const std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %9 "Inner" OpMemberName %9 0 "a" OpMemberName %9 1 "b" OpName %11 "i1" OpName %17 "i2" OpName %31 "Point" OpMemberName %31 0 "x" OpMemberName %31 1 "y" OpMemberName %31 2 "z" OpName %32 "Outer" OpMemberName %32 0 "c" OpMemberName %32 1 "d" OpName %34 "o1" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeFloat 32 %8 = OpTypeVector %7 2 %9 = OpTypeStruct %6 %8 %10 = OpTypePointer Function %9 %12 = OpConstant %6 1 %13 = OpConstant %7 2 %14 = OpConstant %7 3 %15 = OpConstantComposite %8 %13 %14 %16 = OpConstantComposite %9 %12 %15 %18 = OpConstant %6 0 %19 = OpTypePointer Function %6 %24 = OpTypePointer Function %8 %27 = OpConstant %7 4 %31 = OpTypeStruct %7 %7 %7 %32 = OpTypeStruct %9 %31 %33 = OpTypePointer Function %32 %36 = OpConstant %7 10 %37 = OpTypeInt 32 0 %38 = OpConstant %37 0 %39 = OpTypePointer Function %7 %42 = OpConstant %37 1 %4 = OpFunction %2 None %3 %5 = OpLabel %11 = OpVariable %10 Function %17 = OpVariable %10 Function %34 = OpVariable %33 Function %101 = OpCompositeConstruct %31 %27 %36 %27 OpStore %11 %16 %20 = OpAccessChain %19 %11 %18 %21 = OpLoad %6 %20 %22 = OpIAdd %6 %21 %12 %102 = OpCompositeConstruct %9 %22 %15 %23 = OpAccessChain %19 %17 %18 %205 = OpCompositeExtract %6 %102 0 OpStore %23 %205 %25 = OpAccessChain %24 %17 %12 %26 = OpLoad %8 %25 %202 = OpCompositeExtract %7 %101 0 %204 = OpCompositeExtract %7 %101 2 %28 = OpCompositeConstruct %8 %204 %202 %29 = OpFAdd %8 %26 %28 %30 = OpAccessChain %24 %17 %12 OpStore %30 %29 %35 = OpLoad %9 %11 %40 = OpAccessChain %39 %11 %12 %38 %41 = OpLoad %7 %40 %43 = OpAccessChain %39 %11 %12 %42 %44 = OpLoad %7 %43 %203 = OpCompositeExtract %7 %101 1 %45 = OpCompositeConstruct %31 %203 %41 %44 %100 = OpCompositeConstruct %32 %16 %45 %201 = OpCompositeExtract %31 %100 1 %46 = OpCompositeConstruct %32 %35 %201 OpStore %34 %46 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(DataSynonymTransformationTest, VectorCompositeSynonyms) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "f" OpName %12 "v2" OpName %18 "v3" OpName %23 "v4" OpName %32 "b" OpName %36 "bv2" OpName %41 "bv3" OpName %50 "bv4" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %9 = OpConstant %6 42 %10 = OpTypeVector %6 2 %11 = OpTypePointer Function %10 %16 = OpTypeVector %6 3 %17 = OpTypePointer Function %16 %21 = OpTypeVector %6 4 %22 = OpTypePointer Function %21 %30 = OpTypeBool %31 = OpTypePointer Function %30 %33 = OpConstantFalse %30 %34 = OpTypeVector %30 2 %35 = OpTypePointer Function %34 %37 = OpConstantTrue %30 %38 = OpConstantComposite %34 %37 %37 %39 = OpTypeVector %30 3 %40 = OpTypePointer Function %39 %48 = OpTypeVector %30 4 %49 = OpTypePointer Function %48 %51 = OpTypeInt 32 0 %52 = OpConstant %51 2 %55 = OpConstant %6 0 %57 = OpConstant %51 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %12 = OpVariable %11 Function %18 = OpVariable %17 Function %23 = OpVariable %22 Function %32 = OpVariable %31 Function %36 = OpVariable %35 Function %41 = OpVariable %40 Function %50 = OpVariable %49 Function OpStore %8 %9 %13 = OpLoad %6 %8 %14 = OpLoad %6 %8 %15 = OpCompositeConstruct %10 %13 %14 OpStore %12 %15 %19 = OpLoad %10 %12 %20 = OpVectorShuffle %16 %19 %19 0 0 1 OpStore %18 %20 %24 = OpLoad %16 %18 %25 = OpLoad %6 %8 %26 = OpCompositeExtract %6 %24 0 %27 = OpCompositeExtract %6 %24 1 %28 = OpCompositeExtract %6 %24 2 %29 = OpCompositeConstruct %21 %26 %27 %28 %25 OpStore %23 %29 OpStore %32 %33 OpStore %36 %38 %42 = OpLoad %30 %32 %43 = OpLoad %34 %36 %44 = OpVectorShuffle %34 %43 %43 0 0 %45 = OpCompositeExtract %30 %44 0 %46 = OpCompositeExtract %30 %44 1 %47 = OpCompositeConstruct %39 %42 %45 %46 OpStore %41 %47 %53 = OpAccessChain %7 %23 %52 %54 = OpLoad %6 %53 %100 = OpCompositeConstruct %21 %20 %54 %101 = OpCompositeConstruct %21 %15 %19 %102 = OpCompositeConstruct %16 %27 %15 %103 = OpCompositeConstruct %48 %33 %47 %104 = OpCompositeConstruct %34 %42 %45 %105 = OpCompositeConstruct %39 %38 %46 %86 = OpCopyObject %30 %33 %56 = OpFOrdNotEqual %30 %54 %55 %80 = OpCopyObject %16 %20 %58 = OpAccessChain %7 %18 %57 %59 = OpLoad %6 %58 %60 = OpFOrdNotEqual %30 %59 %55 %61 = OpLoad %34 %36 %62 = OpLogicalAnd %30 %45 %46 %63 = OpLogicalOr %30 %45 %46 %64 = OpCompositeConstruct %48 %56 %60 %62 %63 OpStore %12 %15 %81 = OpVectorShuffle %16 %19 %19 0 0 1 %82 = OpCompositeConstruct %21 %26 %27 %28 %25 %83 = OpCopyObject %10 %15 %84 = OpCopyObject %39 %47 OpStore %50 %64 %85 = OpCopyObject %30 %42 OpStore %36 %38 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(20, {0}, 100, {0})); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(20, {1}, 100, {1})); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(20, {2}, 100, {2})); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(54, {}, 100, {3})); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(15, {0}, 101, {0})); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(15, {1}, 101, {1})); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(19, {0}, 101, {2})); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(19, {1}, 101, {3})); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(27, {}, 102, {0})); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(15, {0}, 102, {1})); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(15, {1}, 102, {2})); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(33, {}, 103, {0})); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(47, {0}, 103, {1})); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(47, {1}, 103, {2})); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(47, {2}, 103, {3})); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(42, {}, 104, {0})); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(45, {}, 104, {1})); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(38, {0}, 105, {0})); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(38, {1}, 105, {1})); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(46, {}, 105, {2})); // Replace %20 with %100[0:2] in '%80 = OpCopyObject %16 %20' auto instruction_descriptor_1 = MakeInstructionDescriptor(80, spv::Op::OpCopyObject, 0); auto shuffle_1 = TransformationVectorShuffle(instruction_descriptor_1, 200, 100, 100, {0, 1, 2}); ASSERT_TRUE(shuffle_1.IsApplicable(context.get(), transformation_context)); shuffle_1.Apply(context.get(), &transformation_context); transformation_context.GetFactManager()->ComputeClosureOfFacts(100); auto replacement_1 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor(20, instruction_descriptor_1, 0), 200); ASSERT_TRUE( replacement_1.IsApplicable(context.get(), transformation_context)); replacement_1.Apply(context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Replace %54 with %100[3] in '%56 = OpFOrdNotEqual %30 %54 %55' auto instruction_descriptor_2 = MakeInstructionDescriptor(56, spv::Op::OpFOrdNotEqual, 0); auto extract_2 = TransformationCompositeExtract(instruction_descriptor_2, 201, 100, {3}); ASSERT_TRUE(extract_2.IsApplicable(context.get(), transformation_context)); extract_2.Apply(context.get(), &transformation_context); auto replacement_2 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor(54, instruction_descriptor_2, 0), 201); ASSERT_TRUE( replacement_2.IsApplicable(context.get(), transformation_context)); replacement_2.Apply(context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Replace %15 with %101[0:1] in 'OpStore %12 %15' auto instruction_descriptor_3 = MakeInstructionDescriptor(64, spv::Op::OpStore, 0); auto shuffle_3 = TransformationVectorShuffle(instruction_descriptor_3, 202, 101, 101, {0, 1}); ASSERT_TRUE(shuffle_3.IsApplicable(context.get(), transformation_context)); shuffle_3.Apply(context.get(), &transformation_context); transformation_context.GetFactManager()->ComputeClosureOfFacts(100); auto replacement_3 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor(15, instruction_descriptor_3, 1), 202); ASSERT_TRUE( replacement_3.IsApplicable(context.get(), transformation_context)); replacement_3.Apply(context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Replace %19 with %101[2:3] in '%81 = OpVectorShuffle %16 %19 %19 0 0 1' auto instruction_descriptor_4 = MakeInstructionDescriptor(81, spv::Op::OpVectorShuffle, 0); auto shuffle_4 = TransformationVectorShuffle(instruction_descriptor_4, 203, 101, 101, {2, 3}); ASSERT_TRUE(shuffle_4.IsApplicable(context.get(), transformation_context)); shuffle_4.Apply(context.get(), &transformation_context); transformation_context.GetFactManager()->ComputeClosureOfFacts(100); auto replacement_4 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor(19, instruction_descriptor_4, 0), 203); ASSERT_TRUE( replacement_4.IsApplicable(context.get(), transformation_context)); replacement_4.Apply(context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Replace %27 with %102[0] in '%82 = OpCompositeConstruct %21 %26 %27 %28 // %25' auto instruction_descriptor_5 = MakeInstructionDescriptor(82, spv::Op::OpCompositeConstruct, 0); auto extract_5 = TransformationCompositeExtract(instruction_descriptor_5, 204, 102, {0}); ASSERT_TRUE(extract_5.IsApplicable(context.get(), transformation_context)); extract_5.Apply(context.get(), &transformation_context); auto replacement_5 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor(27, instruction_descriptor_5, 1), 204); ASSERT_TRUE( replacement_5.IsApplicable(context.get(), transformation_context)); replacement_5.Apply(context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Replace %15 with %102[1:2] in '%83 = OpCopyObject %10 %15' auto instruction_descriptor_6 = MakeInstructionDescriptor(83, spv::Op::OpCopyObject, 0); auto shuffle_6 = TransformationVectorShuffle(instruction_descriptor_6, 205, 102, 102, {1, 2}); ASSERT_TRUE(shuffle_6.IsApplicable(context.get(), transformation_context)); shuffle_6.Apply(context.get(), &transformation_context); transformation_context.GetFactManager()->ComputeClosureOfFacts(100); auto replacement_6 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor(15, instruction_descriptor_6, 0), 205); ASSERT_TRUE( replacement_6.IsApplicable(context.get(), transformation_context)); replacement_6.Apply(context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Replace %33 with %103[0] in '%86 = OpCopyObject %30 %33' auto instruction_descriptor_7 = MakeInstructionDescriptor(86, spv::Op::OpCopyObject, 0); auto extract_7 = TransformationCompositeExtract(instruction_descriptor_7, 206, 103, {0}); ASSERT_TRUE(extract_7.IsApplicable(context.get(), transformation_context)); extract_7.Apply(context.get(), &transformation_context); auto replacement_7 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor(33, instruction_descriptor_7, 0), 206); ASSERT_TRUE( replacement_7.IsApplicable(context.get(), transformation_context)); replacement_7.Apply(context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Replace %47 with %103[1:3] in '%84 = OpCopyObject %39 %47' auto instruction_descriptor_8 = MakeInstructionDescriptor(84, spv::Op::OpCopyObject, 0); auto shuffle_8 = TransformationVectorShuffle(instruction_descriptor_8, 207, 103, 103, {1, 2, 3}); ASSERT_TRUE(shuffle_8.IsApplicable(context.get(), transformation_context)); shuffle_8.Apply(context.get(), &transformation_context); transformation_context.GetFactManager()->ComputeClosureOfFacts(100); auto replacement_8 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor(47, instruction_descriptor_8, 0), 207); ASSERT_TRUE( replacement_8.IsApplicable(context.get(), transformation_context)); replacement_8.Apply(context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Replace %42 with %104[0] in '%85 = OpCopyObject %30 %42' auto instruction_descriptor_9 = MakeInstructionDescriptor(85, spv::Op::OpCopyObject, 0); auto extract_9 = TransformationCompositeExtract(instruction_descriptor_9, 208, 104, {0}); ASSERT_TRUE(extract_9.IsApplicable(context.get(), transformation_context)); extract_9.Apply(context.get(), &transformation_context); auto replacement_9 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor(42, instruction_descriptor_9, 0), 208); ASSERT_TRUE( replacement_9.IsApplicable(context.get(), transformation_context)); replacement_9.Apply(context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Replace %45 with %104[1] in '%63 = OpLogicalOr %30 %45 %46' auto instruction_descriptor_10 = MakeInstructionDescriptor(63, spv::Op::OpLogicalOr, 0); auto extract_10 = TransformationCompositeExtract(instruction_descriptor_10, 209, 104, {1}); ASSERT_TRUE(extract_10.IsApplicable(context.get(), transformation_context)); extract_10.Apply(context.get(), &transformation_context); auto replacement_10 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor(45, instruction_descriptor_10, 0), 209); ASSERT_TRUE( replacement_10.IsApplicable(context.get(), transformation_context)); replacement_10.Apply(context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Replace %38 with %105[0:1] in 'OpStore %36 %38' auto instruction_descriptor_11 = MakeInstructionDescriptor(85, spv::Op::OpStore, 0); auto shuffle_11 = TransformationVectorShuffle(instruction_descriptor_11, 210, 105, 105, {0, 1}); ASSERT_TRUE(shuffle_11.IsApplicable(context.get(), transformation_context)); shuffle_11.Apply(context.get(), &transformation_context); transformation_context.GetFactManager()->ComputeClosureOfFacts(100); auto replacement_11 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor(38, instruction_descriptor_11, 1), 210); ASSERT_TRUE( replacement_11.IsApplicable(context.get(), transformation_context)); replacement_11.Apply(context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Replace %46 with %105[2] in '%62 = OpLogicalAnd %30 %45 %46' auto instruction_descriptor_12 = MakeInstructionDescriptor(62, spv::Op::OpLogicalAnd, 0); auto extract_12 = TransformationCompositeExtract(instruction_descriptor_12, 211, 105, {2}); ASSERT_TRUE(extract_12.IsApplicable(context.get(), transformation_context)); extract_12.Apply(context.get(), &transformation_context); auto replacement_12 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor(46, instruction_descriptor_12, 1), 211); ASSERT_TRUE( replacement_12.IsApplicable(context.get(), transformation_context)); replacement_12.Apply(context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); const std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "f" OpName %12 "v2" OpName %18 "v3" OpName %23 "v4" OpName %32 "b" OpName %36 "bv2" OpName %41 "bv3" OpName %50 "bv4" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %9 = OpConstant %6 42 %10 = OpTypeVector %6 2 %11 = OpTypePointer Function %10 %16 = OpTypeVector %6 3 %17 = OpTypePointer Function %16 %21 = OpTypeVector %6 4 %22 = OpTypePointer Function %21 %30 = OpTypeBool %31 = OpTypePointer Function %30 %33 = OpConstantFalse %30 %34 = OpTypeVector %30 2 %35 = OpTypePointer Function %34 %37 = OpConstantTrue %30 %38 = OpConstantComposite %34 %37 %37 %39 = OpTypeVector %30 3 %40 = OpTypePointer Function %39 %48 = OpTypeVector %30 4 %49 = OpTypePointer Function %48 %51 = OpTypeInt 32 0 %52 = OpConstant %51 2 %55 = OpConstant %6 0 %57 = OpConstant %51 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %12 = OpVariable %11 Function %18 = OpVariable %17 Function %23 = OpVariable %22 Function %32 = OpVariable %31 Function %36 = OpVariable %35 Function %41 = OpVariable %40 Function %50 = OpVariable %49 Function OpStore %8 %9 %13 = OpLoad %6 %8 %14 = OpLoad %6 %8 %15 = OpCompositeConstruct %10 %13 %14 OpStore %12 %15 %19 = OpLoad %10 %12 %20 = OpVectorShuffle %16 %19 %19 0 0 1 OpStore %18 %20 %24 = OpLoad %16 %18 %25 = OpLoad %6 %8 %26 = OpCompositeExtract %6 %24 0 %27 = OpCompositeExtract %6 %24 1 %28 = OpCompositeExtract %6 %24 2 %29 = OpCompositeConstruct %21 %26 %27 %28 %25 OpStore %23 %29 OpStore %32 %33 OpStore %36 %38 %42 = OpLoad %30 %32 %43 = OpLoad %34 %36 %44 = OpVectorShuffle %34 %43 %43 0 0 %45 = OpCompositeExtract %30 %44 0 %46 = OpCompositeExtract %30 %44 1 %47 = OpCompositeConstruct %39 %42 %45 %46 OpStore %41 %47 %53 = OpAccessChain %7 %23 %52 %54 = OpLoad %6 %53 %100 = OpCompositeConstruct %21 %20 %54 %101 = OpCompositeConstruct %21 %15 %19 %102 = OpCompositeConstruct %16 %27 %15 %103 = OpCompositeConstruct %48 %33 %47 %104 = OpCompositeConstruct %34 %42 %45 %105 = OpCompositeConstruct %39 %38 %46 %206 = OpCompositeExtract %30 %103 0 %86 = OpCopyObject %30 %206 %201 = OpCompositeExtract %6 %100 3 %56 = OpFOrdNotEqual %30 %201 %55 %200 = OpVectorShuffle %16 %100 %100 0 1 2 %80 = OpCopyObject %16 %200 %58 = OpAccessChain %7 %18 %57 %59 = OpLoad %6 %58 %60 = OpFOrdNotEqual %30 %59 %55 %61 = OpLoad %34 %36 %211 = OpCompositeExtract %30 %105 2 %62 = OpLogicalAnd %30 %45 %211 %209 = OpCompositeExtract %30 %104 1 %63 = OpLogicalOr %30 %209 %46 %64 = OpCompositeConstruct %48 %56 %60 %62 %63 %202 = OpVectorShuffle %10 %101 %101 0 1 OpStore %12 %202 %203 = OpVectorShuffle %10 %101 %101 2 3 %81 = OpVectorShuffle %16 %203 %19 0 0 1 %204 = OpCompositeExtract %6 %102 0 %82 = OpCompositeConstruct %21 %26 %204 %28 %25 %205 = OpVectorShuffle %10 %102 %102 1 2 %83 = OpCopyObject %10 %205 %207 = OpVectorShuffle %39 %103 %103 1 2 3 %84 = OpCopyObject %39 %207 OpStore %50 %64 %208 = OpCompositeExtract %30 %104 0 %85 = OpCopyObject %30 %208 %210 = OpVectorShuffle %34 %105 %105 0 1 OpStore %36 %210 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/equivalence_relation_test.cpp000066400000000000000000000123111475742701700264450ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "source/fuzz/equivalence_relation.h" #include "gmock/gmock.h" #include "gtest/gtest.h" namespace spvtools { namespace fuzz { namespace { struct UInt32Equals { bool operator()(const uint32_t* first, const uint32_t* second) const { return *first == *second; } }; struct UInt32Hash { size_t operator()(const uint32_t* element) const { return static_cast(*element); } }; std::vector ToUIntVector( const std::vector& pointers) { std::vector result; for (auto pointer : pointers) { result.push_back(*pointer); } return result; } TEST(EquivalenceRelationTest, BasicTest) { EquivalenceRelation relation; ASSERT_TRUE(relation.GetAllKnownValues().empty()); for (uint32_t element = 0; element < 100; element++) { relation.Register(element); } for (uint32_t element = 2; element < 80; element += 2) { relation.MakeEquivalent(0, element); relation.MakeEquivalent(element - 1, element + 1); } for (uint32_t element = 82; element < 100; element += 2) { relation.MakeEquivalent(80, element); relation.MakeEquivalent(element - 1, element + 1); } relation.MakeEquivalent(78, 80); std::vector class1; for (uint32_t element = 0; element < 98; element += 2) { ASSERT_TRUE(relation.IsEquivalent(0, element)); ASSERT_TRUE(relation.IsEquivalent(element, element + 2)); class1.push_back(element); } class1.push_back(98); ASSERT_THAT(ToUIntVector(relation.GetEquivalenceClass(0)), testing::WhenSorted(class1)); ASSERT_THAT(ToUIntVector(relation.GetEquivalenceClass(4)), testing::WhenSorted(class1)); ASSERT_THAT(ToUIntVector(relation.GetEquivalenceClass(40)), testing::WhenSorted(class1)); std::vector class2; for (uint32_t element = 1; element < 79; element += 2) { ASSERT_TRUE(relation.IsEquivalent(1, element)); ASSERT_TRUE(relation.IsEquivalent(element, element + 2)); class2.push_back(element); } class2.push_back(79); ASSERT_THAT(ToUIntVector(relation.GetEquivalenceClass(1)), testing::WhenSorted(class2)); ASSERT_THAT(ToUIntVector(relation.GetEquivalenceClass(11)), testing::WhenSorted(class2)); ASSERT_THAT(ToUIntVector(relation.GetEquivalenceClass(31)), testing::WhenSorted(class2)); std::vector class3; for (uint32_t element = 81; element < 99; element += 2) { ASSERT_TRUE(relation.IsEquivalent(81, element)); ASSERT_TRUE(relation.IsEquivalent(element, element + 2)); class3.push_back(element); } class3.push_back(99); ASSERT_THAT(ToUIntVector(relation.GetEquivalenceClass(81)), testing::WhenSorted(class3)); ASSERT_THAT(ToUIntVector(relation.GetEquivalenceClass(91)), testing::WhenSorted(class3)); ASSERT_THAT(ToUIntVector(relation.GetEquivalenceClass(99)), testing::WhenSorted(class3)); bool first = true; std::vector previous_class; for (auto representative : relation.GetEquivalenceClassRepresentatives()) { std::vector current_class = relation.GetEquivalenceClass(*representative); ASSERT_TRUE(std::find(current_class.begin(), current_class.end(), representative) != current_class.end()); if (!first) { ASSERT_TRUE(std::find(previous_class.begin(), previous_class.end(), representative) == previous_class.end()); } previous_class = current_class; first = false; } } TEST(EquivalenceRelationTest, DeterministicEquivalenceClassOrder) { EquivalenceRelation relation1; EquivalenceRelation relation2; for (uint32_t i = 0; i < 1000; ++i) { relation1.Register(i); relation2.Register(i); } for (uint32_t i = 0; i < 1000; ++i) { if (i >= 10) { relation1.MakeEquivalent(i, i - 10); relation2.MakeEquivalent(i, i - 10); } } // We constructed the equivalence relations in the same way, so we would like // them to have identical representatives, and identically-ordered equivalence // classes per representative. ASSERT_THAT(ToUIntVector(relation1.GetEquivalenceClassRepresentatives()), ToUIntVector(relation2.GetEquivalenceClassRepresentatives())); for (auto representative : relation1.GetEquivalenceClassRepresentatives()) { ASSERT_THAT(ToUIntVector(relation1.GetEquivalenceClass(*representative)), ToUIntVector(relation2.GetEquivalenceClass(*representative))); } } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/fact_manager/000077500000000000000000000000001475742701700231155ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/fact_manager/constant_uniform_facts_test.cpp000066400000000000000000000724701475742701700314420ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "source/fuzz/fact_manager/fact_manager.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/uniform_buffer_element_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { using opt::analysis::BoolConstant; using opt::analysis::FloatConstant; using opt::analysis::IntConstant; using opt::analysis::ScalarConstant; using opt::analysis::Bool; using opt::analysis::Float; using opt::analysis::Integer; using opt::analysis::Type; bool AddFactHelper( FactManager* fact_manager, const std::vector& words, const protobufs::UniformBufferElementDescriptor& descriptor) { protobufs::FactConstantUniform constant_uniform_fact; for (auto word : words) { constant_uniform_fact.add_constant_word(word); } *constant_uniform_fact.mutable_uniform_buffer_element_descriptor() = descriptor; protobufs::Fact fact; *fact.mutable_constant_uniform_fact() = constant_uniform_fact; return fact_manager->MaybeAddFact(fact); } TEST(ConstantUniformFactsTest, ConstantsAvailableViaUniforms) { std::string shader = R"( OpCapability Shader OpCapability Int64 OpCapability Float64 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 450 OpName %4 "main" OpDecorate %100 DescriptorSet 0 OpDecorate %100 Binding 0 OpDecorate %200 DescriptorSet 0 OpDecorate %200 Binding 1 OpDecorate %300 DescriptorSet 0 OpDecorate %300 Binding 2 OpDecorate %400 DescriptorSet 0 OpDecorate %400 Binding 3 OpDecorate %500 DescriptorSet 0 OpDecorate %500 Binding 4 OpDecorate %600 DescriptorSet 0 OpDecorate %600 Binding 5 OpDecorate %700 DescriptorSet 0 OpDecorate %700 Binding 6 OpDecorate %800 DescriptorSet 1 OpDecorate %800 Binding 0 OpDecorate %900 DescriptorSet 1 OpDecorate %900 Binding 1 OpDecorate %1000 DescriptorSet 1 OpDecorate %1000 Binding 2 OpDecorate %1100 DescriptorSet 1 OpDecorate %1100 Binding 3 OpDecorate %1200 DescriptorSet 1 OpDecorate %1200 Binding 4 OpDecorate %1300 DescriptorSet 1 OpDecorate %1300 Binding 5 OpDecorate %1400 DescriptorSet 1 OpDecorate %1400 Binding 6 OpDecorate %1500 DescriptorSet 2 OpDecorate %1500 Binding 0 OpDecorate %1600 DescriptorSet 2 OpDecorate %1600 Binding 1 OpDecorate %1700 DescriptorSet 2 OpDecorate %1700 Binding 2 OpDecorate %1800 DescriptorSet 2 OpDecorate %1800 Binding 3 OpDecorate %1900 DescriptorSet 2 OpDecorate %1900 Binding 4 %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeInt 32 0 %11 = OpTypeInt 32 1 %12 = OpTypeInt 64 0 %13 = OpTypeInt 64 1 %15 = OpTypeFloat 32 %16 = OpTypeFloat 64 %17 = OpConstant %11 5 %18 = OpConstant %11 20 %19 = OpTypeVector %10 4 %20 = OpConstant %11 6 %21 = OpTypeVector %12 4 %22 = OpConstant %11 10 %23 = OpTypeVector %11 4 %102 = OpTypeStruct %10 %10 %23 %101 = OpTypePointer Uniform %102 %100 = OpVariable %101 Uniform %203 = OpTypeArray %23 %17 %202 = OpTypeArray %203 %18 %201 = OpTypePointer Uniform %202 %200 = OpVariable %201 Uniform %305 = OpTypeStruct %16 %16 %16 %11 %16 %304 = OpTypeStruct %16 %16 %305 %303 = OpTypeStruct %304 %302 = OpTypeStruct %10 %303 %301 = OpTypePointer Uniform %302 %300 = OpVariable %301 Uniform %400 = OpVariable %101 Uniform %500 = OpVariable %201 Uniform %604 = OpTypeArray %13 %20 %603 = OpTypeArray %604 %20 %602 = OpTypeArray %603 %20 %601 = OpTypePointer Uniform %602 %600 = OpVariable %601 Uniform %703 = OpTypeArray %13 %20 %702 = OpTypeArray %703 %20 %701 = OpTypePointer Uniform %702 %700 = OpVariable %701 Uniform %802 = OpTypeStruct %702 %602 %19 %202 %302 %801 = OpTypePointer Uniform %802 %800 = OpVariable %801 Uniform %902 = OpTypeStruct %702 %802 %19 %202 %302 %901 = OpTypePointer Uniform %902 %900 = OpVariable %901 Uniform %1003 = OpTypeStruct %802 %1002 = OpTypeArray %1003 %20 %1001 = OpTypePointer Uniform %1002 %1000 = OpVariable %1001 Uniform %1101 = OpTypePointer Uniform %21 %1100 = OpVariable %1101 Uniform %1202 = OpTypeArray %21 %20 %1201 = OpTypePointer Uniform %1202 %1200 = OpVariable %1201 Uniform %1302 = OpTypeArray %21 %20 %1301 = OpTypePointer Uniform %1302 %1300 = OpVariable %1301 Uniform %1402 = OpTypeArray %15 %22 %1401 = OpTypePointer Uniform %1402 %1400 = OpVariable %1401 Uniform %1501 = OpTypePointer Uniform %1402 %1500 = OpVariable %1501 Uniform %1602 = OpTypeArray %1402 %22 %1601 = OpTypePointer Uniform %1602 %1600 = OpVariable %1601 Uniform %1704 = OpTypeStruct %16 %16 %16 %1703 = OpTypeArray %1704 %22 %1702 = OpTypeArray %1703 %22 %1701 = OpTypePointer Uniform %1702 %1700 = OpVariable %1701 Uniform %1800 = OpVariable %1701 Uniform %1906 = OpTypeStruct %16 %1905 = OpTypeStruct %1906 %1904 = OpTypeStruct %1905 %1903 = OpTypeStruct %1904 %1902 = OpTypeStruct %1903 %1901 = OpTypePointer Uniform %1902 %1900 = OpVariable %1901 Uniform %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); uint32_t buffer_int32_min[1]; uint32_t buffer_int64_1[2]; uint32_t buffer_int64_max[2]; uint32_t buffer_uint64_1[2]; uint32_t buffer_uint64_max[2]; uint32_t buffer_float_10[1]; uint32_t buffer_double_10[2]; uint32_t buffer_double_20[2]; { int32_t temp = std::numeric_limits::min(); std::memcpy(&buffer_int32_min, &temp, sizeof(temp)); } { int64_t temp = 1; std::memcpy(&buffer_int64_1, &temp, sizeof(temp)); } { int64_t temp = std::numeric_limits::max(); std::memcpy(&buffer_int64_max, &temp, sizeof(temp)); } { uint64_t temp = 1; std::memcpy(&buffer_uint64_1, &temp, sizeof(temp)); } { uint64_t temp = std::numeric_limits::max(); std::memcpy(&buffer_uint64_max, &temp, sizeof(temp)); } { float temp = 10.0f; std::memcpy(&buffer_float_10, &temp, sizeof(float)); } { double temp = 10.0; std::memcpy(&buffer_double_10, &temp, sizeof(temp)); } { double temp = 20.0; std::memcpy(&buffer_double_20, &temp, sizeof(temp)); } FactManager fact_manager(context.get()); uint32_t type_int32_id = 11; uint32_t type_int64_id = 13; uint32_t type_uint32_id = 10; uint32_t type_uint64_id = 12; uint32_t type_float_id = 15; uint32_t type_double_id = 16; // Initially there should be no facts about uniforms. ASSERT_TRUE( fact_manager.GetConstantsAvailableFromUniformsForType(type_uint32_id) .empty()); // In the comments that follow we write v[...][...] to refer to uniform // variable v indexed with some given indices, when in practice v is // identified via a (descriptor set, binding) pair. // 100[2][3] == int(1) ASSERT_TRUE(AddFactHelper(&fact_manager, {1}, MakeUniformBufferElementDescriptor(0, 0, {2, 3}))); // 200[1][2][3] == int(1) ASSERT_TRUE(AddFactHelper( &fact_manager, {1}, MakeUniformBufferElementDescriptor(0, 1, {1, 2, 3}))); // 300[1][0][2][3] == int(1) ASSERT_TRUE( AddFactHelper(&fact_manager, {1}, MakeUniformBufferElementDescriptor(0, 2, {1, 0, 2, 3}))); // 400[2][3] = int32_min ASSERT_TRUE(AddFactHelper(&fact_manager, {buffer_int32_min[0]}, MakeUniformBufferElementDescriptor(0, 3, {2, 3}))); // 500[1][2][3] = int32_min ASSERT_TRUE( AddFactHelper(&fact_manager, {buffer_int32_min[0]}, MakeUniformBufferElementDescriptor(0, 4, {1, 2, 3}))); // 600[1][2][3] = int64_max ASSERT_TRUE( AddFactHelper(&fact_manager, {buffer_int64_max[0], buffer_int64_max[1]}, MakeUniformBufferElementDescriptor(0, 5, {1, 2, 3}))); // 700[1][1] = int64_max ASSERT_TRUE(AddFactHelper(&fact_manager, {buffer_int64_max[0], buffer_int64_max[1]}, MakeUniformBufferElementDescriptor(0, 6, {1, 1}))); // 800[2][3] = uint(1) ASSERT_TRUE(AddFactHelper(&fact_manager, {1}, MakeUniformBufferElementDescriptor(1, 0, {2, 3}))); // 900[1][2][3] = uint(1) ASSERT_TRUE(AddFactHelper( &fact_manager, {1}, MakeUniformBufferElementDescriptor(1, 1, {1, 2, 3}))); // 1000[1][0][2][3] = uint(1) ASSERT_TRUE( AddFactHelper(&fact_manager, {1}, MakeUniformBufferElementDescriptor(1, 2, {1, 0, 2, 3}))); // 1100[0] = uint64(1) ASSERT_TRUE(AddFactHelper(&fact_manager, {buffer_uint64_1[0], buffer_uint64_1[1]}, MakeUniformBufferElementDescriptor(1, 3, {0}))); // 1200[0][0] = uint64_max ASSERT_TRUE(AddFactHelper(&fact_manager, {buffer_uint64_max[0], buffer_uint64_max[1]}, MakeUniformBufferElementDescriptor(1, 4, {0, 0}))); // 1300[1][0] = uint64_max ASSERT_TRUE(AddFactHelper(&fact_manager, {buffer_uint64_max[0], buffer_uint64_max[1]}, MakeUniformBufferElementDescriptor(1, 5, {1, 0}))); // 1400[6] = float(10.0) ASSERT_TRUE(AddFactHelper(&fact_manager, {buffer_float_10[0]}, MakeUniformBufferElementDescriptor(1, 6, {6}))); // 1500[7] = float(10.0) ASSERT_TRUE(AddFactHelper(&fact_manager, {buffer_float_10[0]}, MakeUniformBufferElementDescriptor(2, 0, {7}))); // 1600[9][9] = float(10.0) ASSERT_TRUE(AddFactHelper(&fact_manager, {buffer_float_10[0]}, MakeUniformBufferElementDescriptor(2, 1, {9, 9}))); // 1700[9][9][1] = double(10.0) ASSERT_TRUE( AddFactHelper(&fact_manager, {buffer_double_10[0], buffer_double_10[1]}, MakeUniformBufferElementDescriptor(2, 2, {9, 9, 1}))); // 1800[9][9][2] = double(10.0) ASSERT_TRUE( AddFactHelper(&fact_manager, {buffer_double_10[0], buffer_double_10[1]}, MakeUniformBufferElementDescriptor(2, 3, {9, 9, 2}))); // 1900[0][0][0][0][0] = double(20.0) ASSERT_TRUE( AddFactHelper(&fact_manager, {buffer_double_20[0], buffer_double_20[1]}, MakeUniformBufferElementDescriptor(2, 4, {0, 0, 0, 0, 0}))); opt::Instruction::OperandList operands = { {SPV_OPERAND_TYPE_LITERAL_INTEGER, {1}}}; context->module()->AddGlobalValue(MakeUnique( context.get(), spv::Op::OpConstant, type_int32_id, 50, operands)); operands = {{SPV_OPERAND_TYPE_LITERAL_INTEGER, {buffer_int32_min[0]}}}; context->module()->AddGlobalValue(MakeUnique( context.get(), spv::Op::OpConstant, type_int32_id, 51, operands)); operands = {{SPV_OPERAND_TYPE_LITERAL_INTEGER, {buffer_int64_max[0]}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {buffer_int64_max[1]}}}; context->module()->AddGlobalValue(MakeUnique( context.get(), spv::Op::OpConstant, type_int64_id, 52, operands)); operands = {{SPV_OPERAND_TYPE_LITERAL_INTEGER, {1}}}; context->module()->AddGlobalValue(MakeUnique( context.get(), spv::Op::OpConstant, type_uint32_id, 53, operands)); operands = {{SPV_OPERAND_TYPE_LITERAL_INTEGER, {buffer_uint64_1[0]}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {buffer_uint64_1[1]}}}; context->module()->AddGlobalValue(MakeUnique( context.get(), spv::Op::OpConstant, type_uint64_id, 54, operands)); operands = {{SPV_OPERAND_TYPE_LITERAL_INTEGER, {buffer_uint64_max[0]}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {buffer_uint64_max[1]}}}; context->module()->AddGlobalValue(MakeUnique( context.get(), spv::Op::OpConstant, type_uint64_id, 55, operands)); operands = {{SPV_OPERAND_TYPE_LITERAL_INTEGER, {buffer_float_10[0]}}}; context->module()->AddGlobalValue(MakeUnique( context.get(), spv::Op::OpConstant, type_float_id, 56, operands)); operands = {{SPV_OPERAND_TYPE_LITERAL_INTEGER, {buffer_double_10[0]}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {buffer_double_10[1]}}}; context->module()->AddGlobalValue(MakeUnique( context.get(), spv::Op::OpConstant, type_double_id, 57, operands)); operands = {{SPV_OPERAND_TYPE_LITERAL_INTEGER, {buffer_double_20[0]}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {buffer_double_20[1]}}}; context->module()->AddGlobalValue(MakeUnique( context.get(), spv::Op::OpConstant, type_double_id, 58, operands)); // A duplicate of the constant with id 59. operands = {{SPV_OPERAND_TYPE_LITERAL_INTEGER, {1}}}; context->module()->AddGlobalValue(MakeUnique( context.get(), spv::Op::OpConstant, type_int32_id, 59, operands)); context->InvalidateAnalysesExceptFor(opt::IRContext::Analysis::kAnalysisNone); // Constants 1 and int32_min are available. ASSERT_EQ(2, fact_manager.GetConstantsAvailableFromUniformsForType(type_int32_id) .size()); // Constant int64_max is available. ASSERT_EQ(1, fact_manager.GetConstantsAvailableFromUniformsForType(type_int64_id) .size()); // Constant 1u is available. ASSERT_EQ( 1, fact_manager.GetConstantsAvailableFromUniformsForType(type_uint32_id) .size()); // Constants 1u and uint64_max are available. ASSERT_EQ( 2, fact_manager.GetConstantsAvailableFromUniformsForType(type_uint64_id) .size()); // Constant 10.0 is available. ASSERT_EQ(1, fact_manager.GetConstantsAvailableFromUniformsForType(type_float_id) .size()); // Constants 10.0 and 20.0 are available. ASSERT_EQ( 2, fact_manager.GetConstantsAvailableFromUniformsForType(type_double_id) .size()); ASSERT_EQ(std::numeric_limits::max(), context->get_constant_mgr() ->FindDeclaredConstant( fact_manager.GetConstantsAvailableFromUniformsForType( type_int64_id)[0]) ->AsIntConstant() ->GetS64()); ASSERT_EQ(1, context->get_constant_mgr() ->FindDeclaredConstant( fact_manager.GetConstantsAvailableFromUniformsForType( type_uint32_id)[0]) ->AsIntConstant() ->GetU32()); ASSERT_EQ(10.0f, context->get_constant_mgr() ->FindDeclaredConstant( fact_manager.GetConstantsAvailableFromUniformsForType( type_float_id)[0]) ->AsFloatConstant() ->GetFloat()); const std::vector& double_constant_ids = fact_manager.GetConstantsAvailableFromUniformsForType(type_double_id); ASSERT_EQ(10.0, context->get_constant_mgr() ->FindDeclaredConstant(double_constant_ids[0]) ->AsFloatConstant() ->GetDouble()); ASSERT_EQ(20.0, context->get_constant_mgr() ->FindDeclaredConstant(double_constant_ids[1]) ->AsFloatConstant() ->GetDouble()); const std::vector descriptors_for_double_10 = fact_manager.GetUniformDescriptorsForConstant(double_constant_ids[0]); ASSERT_EQ(2, descriptors_for_double_10.size()); { auto temp = MakeUniformBufferElementDescriptor(2, 2, {9, 9, 1}); ASSERT_TRUE(UniformBufferElementDescriptorEquals()( &temp, &descriptors_for_double_10[0])); } { auto temp = MakeUniformBufferElementDescriptor(2, 3, {9, 9, 2}); ASSERT_TRUE(UniformBufferElementDescriptorEquals()( &temp, &descriptors_for_double_10[1])); } const std::vector descriptors_for_double_20 = fact_manager.GetUniformDescriptorsForConstant(double_constant_ids[1]); ASSERT_EQ(1, descriptors_for_double_20.size()); { auto temp = MakeUniformBufferElementDescriptor(2, 4, {0, 0, 0, 0, 0}); ASSERT_TRUE(UniformBufferElementDescriptorEquals()( &temp, &descriptors_for_double_20[0])); } auto constant_1_id = fact_manager.GetConstantFromUniformDescriptor( MakeUniformBufferElementDescriptor(2, 3, {9, 9, 2})); ASSERT_TRUE(constant_1_id); auto constant_2_id = fact_manager.GetConstantFromUniformDescriptor( MakeUniformBufferElementDescriptor(2, 4, {0, 0, 0, 0, 0})); ASSERT_TRUE(constant_2_id); ASSERT_EQ(double_constant_ids[0], constant_1_id); ASSERT_EQ(double_constant_ids[1], constant_2_id); } TEST(ConstantUniformFactsTest, TwoConstantsWithSameValue) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "x" OpName %10 "buf" OpMemberName %10 0 "a" OpName %12 "" OpDecorate %8 RelaxedPrecision OpMemberDecorate %10 0 RelaxedPrecision OpMemberDecorate %10 0 Offset 0 OpDecorate %10 Block OpDecorate %12 DescriptorSet 0 OpDecorate %12 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %20 = OpConstant %6 1 %10 = OpTypeStruct %6 %11 = OpTypePointer Uniform %10 %12 = OpVariable %11 Uniform %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpStore %8 %9 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); FactManager fact_manager(context.get()); auto uniform_buffer_element_descriptor = MakeUniformBufferElementDescriptor(0, 0, {0}); // (0, 0, [0]) = int(1) ASSERT_TRUE( AddFactHelper(&fact_manager, {1}, uniform_buffer_element_descriptor)); auto constants = fact_manager.GetConstantsAvailableFromUniformsForType(6); ASSERT_EQ(1, constants.size()); ASSERT_TRUE(constants[0] == 9 || constants[0] == 20); auto constant = fact_manager.GetConstantFromUniformDescriptor( uniform_buffer_element_descriptor); ASSERT_TRUE(constant == 9 || constant == 20); // Because the constants with ids 9 and 20 are equal, we should get the same // single uniform buffer element descriptor when we look up the descriptors // for either one of them. for (auto constant_id : {9u, 20u}) { auto descriptors = fact_manager.GetUniformDescriptorsForConstant(constant_id); ASSERT_EQ(1, descriptors.size()); ASSERT_TRUE(UniformBufferElementDescriptorEquals()( &uniform_buffer_element_descriptor, &descriptors[0])); } } TEST(ConstantUniformFactsTest, NonFiniteFactsAreNotValid) { std::string shader = R"( OpCapability Shader OpCapability Float64 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %7 "buf" OpMemberName %7 0 "f" OpMemberName %7 1 "d" OpName %9 "" OpMemberDecorate %7 0 Offset 0 OpMemberDecorate %7 1 Offset 8 OpDecorate %7 Block OpDecorate %9 DescriptorSet 0 OpDecorate %9 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %10 = OpTypeFloat 64 %7 = OpTypeStruct %6 %10 %8 = OpTypePointer Uniform %7 %9 = OpVariable %8 Uniform %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); FactManager fact_manager(context.get()); auto uniform_buffer_element_descriptor_f = MakeUniformBufferElementDescriptor(0, 0, {0}); auto uniform_buffer_element_descriptor_d = MakeUniformBufferElementDescriptor(0, 0, {1}); if (std::numeric_limits::has_infinity) { // f == +inf float positive_infinity_float = std::numeric_limits::infinity(); uint32_t words[1]; memcpy(words, &positive_infinity_float, sizeof(float)); ASSERT_FALSE(AddFactHelper(&fact_manager, {words[0]}, uniform_buffer_element_descriptor_f)); // f == -inf float negative_infinity_float = std::numeric_limits::infinity(); memcpy(words, &negative_infinity_float, sizeof(float)); ASSERT_FALSE(AddFactHelper(&fact_manager, {words[0]}, uniform_buffer_element_descriptor_f)); } if (std::numeric_limits::has_quiet_NaN) { // f == NaN float quiet_nan_float = std::numeric_limits::quiet_NaN(); uint32_t words[1]; memcpy(words, &quiet_nan_float, sizeof(float)); ASSERT_FALSE(AddFactHelper(&fact_manager, {words[0]}, uniform_buffer_element_descriptor_f)); } if (std::numeric_limits::has_infinity) { // d == +inf double positive_infinity_double = std::numeric_limits::infinity(); uint32_t words[2]; memcpy(words, &positive_infinity_double, sizeof(double)); ASSERT_FALSE(AddFactHelper(&fact_manager, {words[0], words[1]}, uniform_buffer_element_descriptor_d)); // d == -inf double negative_infinity_double = -std::numeric_limits::infinity(); memcpy(words, &negative_infinity_double, sizeof(double)); ASSERT_FALSE(AddFactHelper(&fact_manager, {words[0], words[1]}, uniform_buffer_element_descriptor_d)); } if (std::numeric_limits::has_quiet_NaN) { // d == NaN double quiet_nan_double = std::numeric_limits::quiet_NaN(); uint32_t words[2]; memcpy(words, &quiet_nan_double, sizeof(double)); ASSERT_FALSE(AddFactHelper(&fact_manager, {words[0], words[1]}, uniform_buffer_element_descriptor_d)); } } TEST(ConstantUniformFactsTest, AmbiguousFact) { // This test came from the following GLSL: // // #version 310 es // // precision highp float; // // layout(set = 0, binding = 0) uniform buf { // float f; // }; // // layout(set = 0, binding = 0) uniform buf2 { // float g; // }; // // void main() { // // } std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %7 "buf" OpMemberName %7 0 "f" OpName %9 "" OpName %10 "buf2" OpMemberName %10 0 "g" OpName %12 "" OpMemberDecorate %7 0 Offset 0 OpDecorate %7 Block OpDecorate %9 DescriptorSet 0 OpDecorate %9 Binding 0 OpMemberDecorate %10 0 Offset 0 OpDecorate %10 Block OpDecorate %12 DescriptorSet 0 OpDecorate %12 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeStruct %6 %8 = OpTypePointer Uniform %7 %9 = OpVariable %8 Uniform %10 = OpTypeStruct %6 %11 = OpTypePointer Uniform %10 %12 = OpVariable %11 Uniform %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); FactManager fact_manager(context.get()); auto uniform_buffer_element_descriptor = MakeUniformBufferElementDescriptor(0, 0, {0}); // The fact cannot be added because it is ambiguous: there are two uniforms // with descriptor set 0 and binding 0. ASSERT_FALSE( AddFactHelper(&fact_manager, {1}, uniform_buffer_element_descriptor)); } TEST(ConstantUniformFactsTest, CheckingFactsDoesNotAddConstants) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpMemberDecorate %9 0 Offset 0 OpDecorate %9 Block OpDecorate %11 DescriptorSet 0 OpDecorate %11 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpTypeStruct %6 %10 = OpTypePointer Uniform %9 %11 = OpVariable %10 Uniform %12 = OpConstant %6 0 %13 = OpTypePointer Uniform %6 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %14 = OpAccessChain %13 %11 %12 %15 = OpLoad %6 %14 OpStore %8 %15 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); FactManager fact_manager(context.get()); // 8[0] == int(1) ASSERT_TRUE(AddFactHelper(&fact_manager, {1}, MakeUniformBufferElementDescriptor(0, 0, {0}))); // Although 8[0] has the value 1, we do not have the constant 1 in the module. // We thus should not find any constants available from uniforms for int type. // Furthermore, the act of looking for appropriate constants should not change // which constants are known to the constant manager. auto int_type = context->get_type_mgr()->GetType(6)->AsInteger(); opt::analysis::IntConstant constant_one(int_type, {1}); ASSERT_FALSE(context->get_constant_mgr()->FindConstant(&constant_one)); auto available_constants = fact_manager.GetConstantsAvailableFromUniformsForType(6); ASSERT_EQ(0, available_constants.size()); ASSERT_TRUE(IsEqual(env, shader, context.get())); ASSERT_FALSE(context->get_constant_mgr()->FindConstant(&constant_one)); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/fact_manager/data_synonym_and_id_equation_facts_test.cpp000066400000000000000000000715301475742701700337560ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fact_manager/fact_manager.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/transformation_merge_blocks.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { void CheckConsistencyOfSynonymFacts( opt::IRContext* ir_context, const TransformationContext& transformation_context) { for (uint32_t id : transformation_context.GetFactManager() ->GetIdsForWhichSynonymsAreKnown()) { // Every id reported by the fact manager should exist in the module. ASSERT_NE(ir_context->get_def_use_mgr()->GetDef(id), nullptr); auto synonyms = transformation_context.GetFactManager()->GetSynonymsForId(id); for (auto& dd : synonyms) { // Every reported synonym should have a base object that exists in the // module. ASSERT_NE(ir_context->get_def_use_mgr()->GetDef(dd->object()), nullptr); } } } TEST(DataSynonymAndIdEquationFactsTest, RecursiveAdditionOfFacts) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypeMatrix %7 4 %9 = OpConstant %6 0 %10 = OpConstantComposite %7 %9 %9 %9 %9 %11 = OpConstantComposite %8 %10 %10 %10 %10 %12 = OpFunction %2 None %3 %13 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); FactManager fact_manager(context.get()); fact_manager.AddFactDataSynonym(MakeDataDescriptor(10, {}), MakeDataDescriptor(11, {2})); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(10, {}), MakeDataDescriptor(11, {2}))); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(10, {0}), MakeDataDescriptor(11, {2, 0}))); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(10, {1}), MakeDataDescriptor(11, {2, 1}))); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(10, {2}), MakeDataDescriptor(11, {2, 2}))); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(10, {3}), MakeDataDescriptor(11, {2, 3}))); } TEST(DataSynonymAndIdEquationFactsTest, CorollaryConversionFacts) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeInt 32 0 %8 = OpTypeVector %6 2 %9 = OpTypeVector %7 2 %10 = OpTypeFloat 32 %11 = OpTypeVector %10 2 %15 = OpConstant %6 24 ; synonym of %16 %16 = OpConstant %6 24 %17 = OpConstant %7 24 ; synonym of %18 %18 = OpConstant %7 24 %19 = OpConstantComposite %8 %15 %15 ; synonym of %20 %20 = OpConstantComposite %8 %16 %16 %21 = OpConstantComposite %9 %17 %17 ; synonym of %22 %22 = OpConstantComposite %9 %18 %18 %23 = OpConstantComposite %8 %15 %15 ; not a synonym of %19 %12 = OpFunction %2 None %3 %13 = OpLabel %24 = OpConvertSToF %10 %15 ; synonym of %25 %25 = OpConvertSToF %10 %16 %26 = OpConvertUToF %10 %17 ; not a synonym of %27 (different opcode) %27 = OpConvertSToF %10 %18 %28 = OpConvertUToF %11 %19 ; synonym of %29 %29 = OpConvertUToF %11 %20 %30 = OpConvertSToF %11 %21 ; not a synonym of %31 (different opcode) %31 = OpConvertUToF %11 %22 %32 = OpConvertUToF %11 %23 ; not a synonym of %28 (operand is not synonymous) OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); FactManager fact_manager(context.get()); // Add equation facts fact_manager.AddFactIdEquation(24, spv::Op::OpConvertSToF, {15}); fact_manager.AddFactIdEquation(25, spv::Op::OpConvertSToF, {16}); fact_manager.AddFactIdEquation(26, spv::Op::OpConvertUToF, {17}); fact_manager.AddFactIdEquation(27, spv::Op::OpConvertSToF, {18}); fact_manager.AddFactIdEquation(28, spv::Op::OpConvertUToF, {19}); fact_manager.AddFactIdEquation(29, spv::Op::OpConvertUToF, {20}); fact_manager.AddFactIdEquation(30, spv::Op::OpConvertSToF, {21}); fact_manager.AddFactIdEquation(31, spv::Op::OpConvertUToF, {22}); fact_manager.AddFactIdEquation(32, spv::Op::OpConvertUToF, {23}); fact_manager.AddFactDataSynonym(MakeDataDescriptor(15, {}), MakeDataDescriptor(16, {})); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(24, {}), MakeDataDescriptor(25, {}))); fact_manager.AddFactDataSynonym(MakeDataDescriptor(17, {}), MakeDataDescriptor(18, {})); ASSERT_FALSE(fact_manager.IsSynonymous(MakeDataDescriptor(26, {}), MakeDataDescriptor(27, {}))); fact_manager.AddFactDataSynonym(MakeDataDescriptor(19, {}), MakeDataDescriptor(20, {})); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(28, {}), MakeDataDescriptor(29, {}))); fact_manager.AddFactDataSynonym(MakeDataDescriptor(21, {}), MakeDataDescriptor(22, {})); ASSERT_FALSE(fact_manager.IsSynonymous(MakeDataDescriptor(30, {}), MakeDataDescriptor(31, {}))); ASSERT_FALSE(fact_manager.IsSynonymous(MakeDataDescriptor(32, {}), MakeDataDescriptor(28, {}))); fact_manager.AddFactDataSynonym(MakeDataDescriptor(23, {}), MakeDataDescriptor(19, {})); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(32, {}), MakeDataDescriptor(28, {}))); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(32, {}), MakeDataDescriptor(29, {}))); } TEST(DataSynonymAndIdEquationFactsTest, HandlesCorollariesWithInvalidIds) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %8 = OpTypeInt 32 1 %9 = OpConstant %8 3 %12 = OpFunction %2 None %3 %13 = OpLabel %14 = OpConvertSToF %6 %9 OpBranch %16 %16 = OpLabel %17 = OpPhi %6 %14 %13 %15 = OpConvertSToF %6 %9 %18 = OpConvertSToF %6 %9 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Add required facts. transformation_context.GetFactManager()->AddFactIdEquation( 14, spv::Op::OpConvertSToF, {9}); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(14, {}), MakeDataDescriptor(17, {})); CheckConsistencyOfSynonymFacts(context.get(), transformation_context); // Apply TransformationMergeBlocks which will remove %17 from the module. TransformationMergeBlocks transformation(16); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); transformation.Apply(context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); CheckConsistencyOfSynonymFacts(context.get(), transformation_context); ASSERT_EQ(context->get_def_use_mgr()->GetDef(17), nullptr); // Add another equation. transformation_context.GetFactManager()->AddFactIdEquation( 15, spv::Op::OpConvertSToF, {9}); // Check that two ids are synonymous even though one of them doesn't exist in // the module (%17). ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(15, {}), MakeDataDescriptor(17, {}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(15, {}), MakeDataDescriptor(14, {}))); CheckConsistencyOfSynonymFacts(context.get(), transformation_context); // Remove some instructions from the module. At this point, the equivalence // class of %14 has no valid members. ASSERT_TRUE(context->KillDef(14)); ASSERT_TRUE(context->KillDef(15)); transformation_context.GetFactManager()->AddFactIdEquation( 18, spv::Op::OpConvertSToF, {9}); CheckConsistencyOfSynonymFacts(context.get(), transformation_context); // We don't create synonyms if at least one of the equivalence classes has no // valid members. ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(14, {}), MakeDataDescriptor(18, {}))); } TEST(DataSynonymAndIdEquationFactsTest, LogicalNotEquationFacts) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantTrue %6 %12 = OpFunction %2 None %3 %13 = OpLabel %14 = OpLogicalNot %6 %7 %15 = OpCopyObject %6 %7 %16 = OpCopyObject %6 %14 %17 = OpLogicalNot %6 %16 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); FactManager fact_manager(context.get()); fact_manager.AddFactDataSynonym(MakeDataDescriptor(15, {}), MakeDataDescriptor(7, {})); fact_manager.AddFactDataSynonym(MakeDataDescriptor(16, {}), MakeDataDescriptor(14, {})); fact_manager.AddFactIdEquation(14, spv::Op::OpLogicalNot, {7}); fact_manager.AddFactIdEquation(17, spv::Op::OpLogicalNot, {16}); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(15, {}), MakeDataDescriptor(7, {}))); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(17, {}), MakeDataDescriptor(7, {}))); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(15, {}), MakeDataDescriptor(17, {}))); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(16, {}), MakeDataDescriptor(14, {}))); } TEST(DataSynonymAndIdEquationFactsTest, SignedNegateEquationFacts) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpConstant %6 24 %12 = OpFunction %2 None %3 %13 = OpLabel %14 = OpSNegate %6 %7 %15 = OpSNegate %6 %14 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); FactManager fact_manager(context.get()); fact_manager.AddFactIdEquation(14, spv::Op::OpSNegate, {7}); fact_manager.AddFactIdEquation(15, spv::Op::OpSNegate, {14}); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(7, {}), MakeDataDescriptor(15, {}))); } TEST(DataSynonymAndIdEquationFactsTest, AddSubNegateFacts1) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %15 = OpConstant %6 24 %16 = OpConstant %6 37 %12 = OpFunction %2 None %3 %13 = OpLabel %14 = OpIAdd %6 %15 %16 %17 = OpCopyObject %6 %15 %18 = OpCopyObject %6 %16 %19 = OpISub %6 %14 %18 ; ==> synonymous(%19, %15) %20 = OpISub %6 %14 %17 ; ==> synonymous(%20, %16) %21 = OpCopyObject %6 %14 %22 = OpISub %6 %16 %21 %23 = OpCopyObject %6 %22 %24 = OpSNegate %6 %23 ; ==> synonymous(%24, %15) OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); FactManager fact_manager(context.get()); fact_manager.AddFactIdEquation(14, spv::Op::OpIAdd, {15, 16}); fact_manager.AddFactDataSynonym(MakeDataDescriptor(17, {}), MakeDataDescriptor(15, {})); fact_manager.AddFactDataSynonym(MakeDataDescriptor(18, {}), MakeDataDescriptor(16, {})); fact_manager.AddFactIdEquation(19, spv::Op::OpISub, {14, 18}); fact_manager.AddFactIdEquation(20, spv::Op::OpISub, {14, 17}); fact_manager.AddFactDataSynonym(MakeDataDescriptor(21, {}), MakeDataDescriptor(14, {})); fact_manager.AddFactIdEquation(22, spv::Op::OpISub, {16, 21}); fact_manager.AddFactDataSynonym(MakeDataDescriptor(23, {}), MakeDataDescriptor(22, {})); fact_manager.AddFactIdEquation(24, spv::Op::OpSNegate, {23}); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(19, {}), MakeDataDescriptor(15, {}))); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(20, {}), MakeDataDescriptor(16, {}))); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(24, {}), MakeDataDescriptor(15, {}))); } TEST(DataSynonymAndIdEquationFactsTest, AddSubNegateFacts2) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %15 = OpConstant %6 24 %16 = OpConstant %6 37 %12 = OpFunction %2 None %3 %13 = OpLabel %14 = OpISub %6 %15 %16 %17 = OpIAdd %6 %14 %16 ; ==> synonymous(%17, %15) %18 = OpIAdd %6 %16 %14 ; ==> synonymous(%17, %18, %15) %19 = OpISub %6 %14 %15 %20 = OpSNegate %6 %19 ; ==> synonymous(%20, %16) %21 = OpISub %6 %14 %19 ; ==> synonymous(%21, %15) %22 = OpISub %6 %14 %18 %23 = OpSNegate %6 %22 ; ==> synonymous(%23, %16) OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); FactManager fact_manager(context.get()); fact_manager.AddFactIdEquation(14, spv::Op::OpISub, {15, 16}); fact_manager.AddFactIdEquation(17, spv::Op::OpIAdd, {14, 16}); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(17, {}), MakeDataDescriptor(15, {}))); fact_manager.AddFactIdEquation(18, spv::Op::OpIAdd, {16, 14}); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(18, {}), MakeDataDescriptor(15, {}))); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(17, {}), MakeDataDescriptor(18, {}))); fact_manager.AddFactIdEquation(19, spv::Op::OpISub, {14, 15}); fact_manager.AddFactIdEquation(20, spv::Op::OpSNegate, {19}); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(20, {}), MakeDataDescriptor(16, {}))); fact_manager.AddFactIdEquation(21, spv::Op::OpISub, {14, 19}); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(21, {}), MakeDataDescriptor(15, {}))); fact_manager.AddFactIdEquation(22, spv::Op::OpISub, {14, 18}); fact_manager.AddFactIdEquation(23, spv::Op::OpSNegate, {22}); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(23, {}), MakeDataDescriptor(16, {}))); } TEST(DataSynonymAndIdEquationFactsTest, ConversionEquations) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeInt 32 1 %5 = OpTypeInt 32 0 %6 = OpTypeFloat 32 %14 = OpTypeVector %4 2 %15 = OpTypeVector %5 2 %24 = OpTypeVector %6 2 %16 = OpConstant %4 32 ; synonym of %17 %17 = OpConstant %4 32 %18 = OpConstant %5 32 ; synonym of %19 %19 = OpConstant %5 32 %20 = OpConstantComposite %14 %16 %16 ; synonym of %21 %21 = OpConstantComposite %14 %17 %17 %22 = OpConstantComposite %15 %18 %18 ; synonym of %23 %23 = OpConstantComposite %15 %19 %19 %12 = OpFunction %2 None %3 %13 = OpLabel %25 = OpConvertUToF %6 %16 ; synonym of %26 %26 = OpConvertUToF %6 %17 %27 = OpConvertSToF %24 %20 ; not a synonym of %28 (wrong opcode) %28 = OpConvertUToF %24 %21 %29 = OpConvertSToF %6 %18 ; not a synonym of %30 (wrong opcode) %30 = OpConvertUToF %6 %19 %31 = OpConvertSToF %24 %22 ; synonym of %32 %32 = OpConvertSToF %24 %23 %33 = OpConvertUToF %6 %17 ; synonym of %26 %34 = OpConvertSToF %24 %23 ; synonym of %32 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); FactManager fact_manager(context.get()); fact_manager.AddFactDataSynonym(MakeDataDescriptor(16, {}), MakeDataDescriptor(17, {})); fact_manager.AddFactDataSynonym(MakeDataDescriptor(18, {}), MakeDataDescriptor(19, {})); fact_manager.AddFactDataSynonym(MakeDataDescriptor(20, {}), MakeDataDescriptor(21, {})); fact_manager.AddFactDataSynonym(MakeDataDescriptor(22, {}), MakeDataDescriptor(23, {})); fact_manager.AddFactIdEquation(25, spv::Op::OpConvertUToF, {16}); fact_manager.AddFactIdEquation(26, spv::Op::OpConvertUToF, {17}); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(25, {}), MakeDataDescriptor(26, {}))); fact_manager.AddFactIdEquation(27, spv::Op::OpConvertSToF, {20}); fact_manager.AddFactIdEquation(28, spv::Op::OpConvertUToF, {21}); ASSERT_FALSE(fact_manager.IsSynonymous(MakeDataDescriptor(27, {}), MakeDataDescriptor(28, {}))); fact_manager.AddFactIdEquation(29, spv::Op::OpConvertSToF, {18}); fact_manager.AddFactIdEquation(30, spv::Op::OpConvertUToF, {19}); ASSERT_FALSE(fact_manager.IsSynonymous(MakeDataDescriptor(29, {}), MakeDataDescriptor(30, {}))); fact_manager.AddFactIdEquation(31, spv::Op::OpConvertSToF, {22}); fact_manager.AddFactIdEquation(32, spv::Op::OpConvertSToF, {23}); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(31, {}), MakeDataDescriptor(32, {}))); fact_manager.AddFactIdEquation(33, spv::Op::OpConvertUToF, {17}); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(33, {}), MakeDataDescriptor(26, {}))); fact_manager.AddFactIdEquation(34, spv::Op::OpConvertSToF, {23}); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(32, {}), MakeDataDescriptor(34, {}))); } TEST(DataSynonymAndIdEquationFactsTest, BitcastEquationFacts) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeInt 32 1 %5 = OpTypeInt 32 0 %8 = OpTypeFloat 32 %9 = OpTypeVector %4 2 %10 = OpTypeVector %5 2 %11 = OpTypeVector %8 2 %6 = OpConstant %4 23 %7 = OpConstant %5 23 %19 = OpConstant %8 23 %20 = OpConstantComposite %9 %6 %6 %21 = OpConstantComposite %10 %7 %7 %22 = OpConstantComposite %11 %19 %19 %12 = OpFunction %2 None %3 %13 = OpLabel %30 = OpBitcast %8 %6 %31 = OpBitcast %5 %6 %32 = OpBitcast %8 %7 %33 = OpBitcast %4 %7 %34 = OpBitcast %4 %19 %35 = OpBitcast %5 %19 %36 = OpBitcast %10 %20 %37 = OpBitcast %11 %20 %38 = OpBitcast %9 %21 %39 = OpBitcast %11 %21 %40 = OpBitcast %9 %22 %41 = OpBitcast %10 %22 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); FactManager fact_manager(context.get()); uint32_t lhs_id = 30; for (uint32_t rhs_id : {6, 6, 7, 7, 19, 19, 20, 20, 21, 21, 22, 22}) { fact_manager.AddFactIdEquation(lhs_id, spv::Op::OpBitcast, {rhs_id}); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(lhs_id, {}), MakeDataDescriptor(rhs_id, {}))); ++lhs_id; } } TEST(DataSynonymAndIdEquationFactsTest, EquationAndEquivalenceFacts) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %15 = OpConstant %6 24 %16 = OpConstant %6 37 %12 = OpFunction %2 None %3 %13 = OpLabel %14 = OpISub %6 %15 %16 %114 = OpCopyObject %6 %14 %17 = OpIAdd %6 %114 %16 ; ==> synonymous(%17, %15) %18 = OpIAdd %6 %16 %114 ; ==> synonymous(%17, %18, %15) %19 = OpISub %6 %114 %15 %119 = OpCopyObject %6 %19 %20 = OpSNegate %6 %119 ; ==> synonymous(%20, %16) %21 = OpISub %6 %14 %19 ; ==> synonymous(%21, %15) %22 = OpISub %6 %14 %18 %220 = OpCopyObject %6 %22 %23 = OpSNegate %6 %220 ; ==> synonymous(%23, %16) OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); FactManager fact_manager(context.get()); fact_manager.AddFactIdEquation(14, spv::Op::OpISub, {15, 16}); fact_manager.AddFactDataSynonym(MakeDataDescriptor(114, {}), MakeDataDescriptor(14, {})); fact_manager.AddFactIdEquation(17, spv::Op::OpIAdd, {114, 16}); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(17, {}), MakeDataDescriptor(15, {}))); fact_manager.AddFactIdEquation(18, spv::Op::OpIAdd, {16, 114}); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(18, {}), MakeDataDescriptor(15, {}))); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(17, {}), MakeDataDescriptor(18, {}))); fact_manager.AddFactIdEquation(19, spv::Op::OpISub, {14, 15}); fact_manager.AddFactDataSynonym(MakeDataDescriptor(119, {}), MakeDataDescriptor(19, {})); fact_manager.AddFactIdEquation(20, spv::Op::OpSNegate, {119}); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(20, {}), MakeDataDescriptor(16, {}))); fact_manager.AddFactIdEquation(21, spv::Op::OpISub, {14, 19}); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(21, {}), MakeDataDescriptor(15, {}))); fact_manager.AddFactIdEquation(22, spv::Op::OpISub, {14, 18}); fact_manager.AddFactDataSynonym(MakeDataDescriptor(22, {}), MakeDataDescriptor(220, {})); fact_manager.AddFactIdEquation(23, spv::Op::OpSNegate, {220}); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(23, {}), MakeDataDescriptor(16, {}))); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/fact_manager/dead_block_facts_test.cpp000066400000000000000000000045641475742701700301200ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fact_manager/fact_manager.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(DeadBlockFactsTest, BlockIsDead) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpTypeInt 32 1 %8 = OpTypePointer Function %7 %2 = OpFunction %3 None %4 %9 = OpLabel OpSelectionMerge %10 None OpBranchConditional %6 %11 %12 %11 = OpLabel OpBranch %10 %12 = OpLabel OpBranch %10 %10 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); FactManager fact_manager(context.get()); ASSERT_FALSE(fact_manager.BlockIsDead(9)); ASSERT_FALSE(fact_manager.BlockIsDead(11)); ASSERT_FALSE(fact_manager.BlockIsDead(12)); fact_manager.AddFactBlockIsDead(12); ASSERT_FALSE(fact_manager.BlockIsDead(9)); ASSERT_FALSE(fact_manager.BlockIsDead(11)); ASSERT_TRUE(fact_manager.BlockIsDead(12)); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/fact_manager/irrelevant_value_facts_test.cpp000066400000000000000000000135621475742701700314160ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fact_manager/fact_manager.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(IrrelevantValueFactsTest, IdIsIrrelevant) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %12 = OpConstant %6 0 %13 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); FactManager fact_manager(context.get()); ASSERT_FALSE(fact_manager.IdIsIrrelevant(12)); ASSERT_FALSE(fact_manager.IdIsIrrelevant(13)); fact_manager.AddFactIdIsIrrelevant(12); ASSERT_TRUE(fact_manager.IdIsIrrelevant(12)); ASSERT_FALSE(fact_manager.IdIsIrrelevant(13)); } TEST(IrrelevantValueFactsTest, GetIrrelevantIds) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %12 = OpConstant %6 0 %13 = OpConstant %6 1 %14 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); FactManager fact_manager(context.get()); ASSERT_EQ(fact_manager.GetIrrelevantIds(), std::unordered_set({})); fact_manager.AddFactIdIsIrrelevant(12); ASSERT_EQ(fact_manager.GetIrrelevantIds(), std::unordered_set({12})); fact_manager.AddFactIdIsIrrelevant(13); ASSERT_EQ(fact_manager.GetIrrelevantIds(), std::unordered_set({12, 13})); } TEST(IrrelevantValueFactsTest, IdsFromDeadBlocksAreIrrelevant) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpTypeInt 32 1 %8 = OpTypePointer Function %7 %9 = OpConstant %7 1 %2 = OpFunction %3 None %4 %10 = OpLabel %11 = OpVariable %8 Function OpSelectionMerge %12 None OpBranchConditional %6 %13 %14 %13 = OpLabel OpBranch %12 %14 = OpLabel %15 = OpCopyObject %8 %11 %16 = OpCopyObject %7 %9 %17 = OpFunctionCall %3 %18 OpBranch %12 %12 = OpLabel OpReturn OpFunctionEnd %18 = OpFunction %3 None %4 %19 = OpLabel %20 = OpVariable %8 Function %21 = OpCopyObject %7 %9 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); FactManager fact_manager(context.get()); ASSERT_FALSE(fact_manager.BlockIsDead(14)); ASSERT_FALSE(fact_manager.BlockIsDead(19)); // Initially no id is irrelevant. ASSERT_FALSE(fact_manager.IdIsIrrelevant(16)); ASSERT_FALSE(fact_manager.IdIsIrrelevant(17)); ASSERT_EQ(fact_manager.GetIrrelevantIds(), std::unordered_set({})); fact_manager.AddFactBlockIsDead(14); // %16 and %17 should now be considered irrelevant. ASSERT_TRUE(fact_manager.IdIsIrrelevant(16)); ASSERT_TRUE(fact_manager.IdIsIrrelevant(17)); ASSERT_EQ(fact_manager.GetIrrelevantIds(), std::unordered_set({16, 17})); // Similarly for %21. ASSERT_FALSE(fact_manager.IdIsIrrelevant(21)); fact_manager.AddFactBlockIsDead(19); ASSERT_TRUE(fact_manager.IdIsIrrelevant(21)); ASSERT_EQ(fact_manager.GetIrrelevantIds(), std::unordered_set({16, 17, 21})); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/fuzz_test_util.cpp000066400000000000000000000154431475742701700243130ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "test/fuzz/fuzz_test_util.h" #include "gtest/gtest.h" #include #include #include "source/opt/def_use_manager.h" #include "tools/io.h" namespace spvtools { namespace fuzz { const spvtools::MessageConsumer kConsoleMessageConsumer = [](spv_message_level_t level, const char*, const spv_position_t& position, const char* message) -> void { switch (level) { case SPV_MSG_FATAL: case SPV_MSG_INTERNAL_ERROR: case SPV_MSG_ERROR: std::cerr << "error: line " << position.index << ": " << message << std::endl; break; case SPV_MSG_WARNING: std::cout << "warning: line " << position.index << ": " << message << std::endl; break; case SPV_MSG_INFO: std::cout << "info: line " << position.index << ": " << message << std::endl; break; default: break; } }; bool IsEqual(const spv_target_env env, const std::vector& expected_binary, const std::vector& actual_binary) { if (expected_binary == actual_binary) { return true; } SpirvTools t(env); std::string expected_disassembled; std::string actual_disassembled; if (!t.Disassemble(expected_binary, &expected_disassembled, kFuzzDisassembleOption)) { return false; } if (!t.Disassemble(actual_binary, &actual_disassembled, kFuzzDisassembleOption)) { return false; } // Using expect gives us a string diff if the strings are not the same. EXPECT_EQ(expected_disassembled, actual_disassembled); // We then return the result of the equality comparison, to be used by an // assertion in the test root function. return expected_disassembled == actual_disassembled; } bool IsEqual(const spv_target_env env, const std::string& expected_text, const std::vector& actual_binary) { std::vector expected_binary; SpirvTools t(env); if (!t.Assemble(expected_text, &expected_binary, kFuzzAssembleOption)) { return false; } return IsEqual(env, expected_binary, actual_binary); } bool IsEqual(const spv_target_env env, const std::string& expected_text, const opt::IRContext* actual_ir) { std::vector actual_binary; actual_ir->module()->ToBinary(&actual_binary, false); return IsEqual(env, expected_text, actual_binary); } bool IsEqual(const spv_target_env env, const opt::IRContext* ir_1, const opt::IRContext* ir_2) { std::vector binary_1; ir_1->module()->ToBinary(&binary_1, false); std::vector binary_2; ir_2->module()->ToBinary(&binary_2, false); return IsEqual(env, binary_1, binary_2); } bool IsEqual(const spv_target_env env, const std::vector& binary_1, const opt::IRContext* ir_2) { std::vector binary_2; ir_2->module()->ToBinary(&binary_2, false); return IsEqual(env, binary_1, binary_2); } std::string ToString(spv_target_env env, const opt::IRContext* ir) { std::vector binary; ir->module()->ToBinary(&binary, false); return ToString(env, binary); } std::string ToString(spv_target_env env, const std::vector& binary) { SpirvTools t(env); std::string result; t.Disassemble(binary, &result, kFuzzDisassembleOption); return result; } void DumpShader(opt::IRContext* context, const char* filename) { std::vector binary; context->module()->ToBinary(&binary, false); DumpShader(binary, filename); } void DumpShader(const std::vector& binary, const char* filename) { auto write_file_succeeded = WriteFile(filename, "wb", &binary[0], binary.size()); if (!write_file_succeeded) { std::cerr << "Failed to dump shader" << std::endl; } } void DumpTransformationsBinary( const protobufs::TransformationSequence& transformations, const char* filename) { std::ofstream transformations_file; transformations_file.open(filename, std::ios::out | std::ios::binary); transformations.SerializeToOstream(&transformations_file); transformations_file.close(); } void DumpTransformationsJson( const protobufs::TransformationSequence& transformations, const char* filename) { std::string json_string; auto json_options = google::protobuf::util::JsonPrintOptions(); json_options.add_whitespace = true; auto json_generation_status = google::protobuf::util::MessageToJsonString( transformations, &json_string, json_options); if (json_generation_status.ok()) { std::ofstream transformations_json_file(filename); transformations_json_file << json_string; transformations_json_file.close(); } } void ApplyAndCheckFreshIds( const Transformation& transformation, opt::IRContext* ir_context, TransformationContext* transformation_context, const std::unordered_set& issued_overflow_ids) { // To ensure that we cover all ToMessage and message-based constructor methods // in our tests, we turn this into a message and back into a transformation, // and use the reconstructed transformation in the rest of the function. auto message = transformation.ToMessage(); auto reconstructed_transformation = Transformation::FromMessage(message); opt::analysis::DefUseManager::IdToDefMap before_transformation = ir_context->get_def_use_mgr()->id_to_defs(); reconstructed_transformation->Apply(ir_context, transformation_context); opt::analysis::DefUseManager::IdToDefMap after_transformation = ir_context->get_def_use_mgr()->id_to_defs(); std::unordered_set fresh_ids_for_transformation = reconstructed_transformation->GetFreshIds(); for (auto& entry : after_transformation) { uint32_t id = entry.first; bool introduced_by_transformation_message = fresh_ids_for_transformation.count(id); bool introduced_by_overflow_ids = issued_overflow_ids.count(id); ASSERT_FALSE(introduced_by_transformation_message && introduced_by_overflow_ids); if (before_transformation.count(entry.first)) { ASSERT_FALSE(introduced_by_transformation_message || introduced_by_overflow_ids); } else { ASSERT_TRUE(introduced_by_transformation_message || introduced_by_overflow_ids); } } } } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/fuzz_test_util.h000066400000000000000000000101661475742701700237550ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef TEST_FUZZ_FUZZ_TEST_UTIL_H_ #define TEST_FUZZ_FUZZ_TEST_UTIL_H_ #include #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/transformation.h" #include "source/fuzz/transformation_context.h" #include "source/opt/build_module.h" #include "source/opt/ir_context.h" #include "spirv-tools/libspirv.h" namespace spvtools { namespace fuzz { extern const spvtools::MessageConsumer kConsoleMessageConsumer; // Returns true if and only if the given binaries are bit-wise equal. bool IsEqual(spv_target_env env, const std::vector& expected_binary, const std::vector& actual_binary); // Assembles the given text and returns true if and only if the resulting binary // is bit-wise equal to the given binary. bool IsEqual(spv_target_env env, const std::string& expected_text, const std::vector& actual_binary); // Assembles the given text and turns the given IR into binary, then returns // true if and only if the resulting binaries are bit-wise equal. bool IsEqual(spv_target_env env, const std::string& expected_text, const opt::IRContext* actual_ir); // Turns the given IRs into binaries, then returns true if and only if the // resulting binaries are bit-wise equal. bool IsEqual(spv_target_env env, const opt::IRContext* ir_1, const opt::IRContext* ir_2); // Turns |ir_2| into a binary, then returns true if and only if the resulting // binary is bit-wise equal to |binary_1|. bool IsEqual(spv_target_env env, const std::vector& binary_1, const opt::IRContext* ir_2); // Assembles the given IR context, then returns its disassembly as a string. // Useful for debugging. std::string ToString(spv_target_env env, const opt::IRContext* ir); // Returns the disassembly of the given binary as a string. // Useful for debugging. std::string ToString(spv_target_env env, const std::vector& binary); // Assembly options for writing fuzzer tests. It simplifies matters if // numeric ids do not change. const uint32_t kFuzzAssembleOption = SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS; // Disassembly options for writing fuzzer tests. const uint32_t kFuzzDisassembleOption = SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_INDENT; // Dumps the SPIRV-V module in |context| to file |filename|. Useful for // interactive debugging. void DumpShader(opt::IRContext* context, const char* filename); // Dumps |binary| to file |filename|. Useful for interactive debugging. void DumpShader(const std::vector& binary, const char* filename); // Dumps |transformations| to file |filename| in binary format. Useful for // interactive debugging. void DumpTransformationsBinary( const protobufs::TransformationSequence& transformations, const char* filename); // Dumps |transformations| to file |filename| in JSON format. Useful for // interactive debugging. void DumpTransformationsJson( const protobufs::TransformationSequence& transformations, const char* filename); // Applies |transformation| to |ir_context| and |transformation_context|, and // asserts that any ids in |ir_context| that are only present post- // transformation are either contained in |transformation.GetFreshIds()|, or // in |issued_overflow_ids|. void ApplyAndCheckFreshIds( const Transformation& transformation, opt::IRContext* ir_context, TransformationContext* transformation_context, const std::unordered_set& issued_overflow_ids = {{}}); } // namespace fuzz } // namespace spvtools #endif // TEST_FUZZ_FUZZ_TEST_UTIL_H_ KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/fuzzer_pass_add_opphi_synonyms_test.cpp000066400000000000000000000143241475742701700306160ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_add_opphi_synonyms.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/pseudo_random_generator.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { protobufs::Fact MakeSynonymFact(uint32_t first, uint32_t second) { protobufs::FactDataSynonym data_synonym_fact; *data_synonym_fact.mutable_data1() = MakeDataDescriptor(first, {}); *data_synonym_fact.mutable_data2() = MakeDataDescriptor(second, {}); protobufs::Fact result; *result.mutable_data_synonym_fact() = data_synonym_fact; return result; } // Adds synonym facts to the fact manager. void SetUpIdSynonyms(FactManager* fact_manager) { // Synonyms {9, 11, 15, 16, 21, 22} fact_manager->MaybeAddFact(MakeSynonymFact(11, 9)); fact_manager->MaybeAddFact(MakeSynonymFact(15, 9)); fact_manager->MaybeAddFact(MakeSynonymFact(16, 9)); fact_manager->MaybeAddFact(MakeSynonymFact(21, 9)); fact_manager->MaybeAddFact(MakeSynonymFact(22, 9)); // Synonyms {10, 23} fact_manager->MaybeAddFact(MakeSynonymFact(10, 23)); // Synonyms {14, 27} fact_manager->MaybeAddFact(MakeSynonymFact(14, 27)); // Synonyms {24, 26, 30} fact_manager->MaybeAddFact(MakeSynonymFact(26, 24)); fact_manager->MaybeAddFact(MakeSynonymFact(30, 24)); } // Returns true if the given lists have the same elements, regardless of their // order. template bool ListsHaveTheSameElements(const std::vector& list1, const std::vector& list2) { auto sorted1 = list1; std::sort(sorted1.begin(), sorted1.end()); auto sorted2 = list2; std::sort(sorted2.begin(), sorted2.end()); return sorted1 == sorted2; } std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpTypeInt 32 1 %31 = OpTypeFunction %7 %8 = OpTypeInt 32 0 %9 = OpConstant %7 1 %10 = OpConstant %7 2 %11 = OpConstant %8 1 %12 = OpTypePointer Function %7 %2 = OpFunction %3 None %4 %13 = OpLabel %14 = OpVariable %12 Function %15 = OpCopyObject %7 %9 %16 = OpCopyObject %8 %11 OpBranch %17 %17 = OpLabel OpSelectionMerge %18 None OpBranchConditional %6 %19 %20 %19 = OpLabel %21 = OpCopyObject %7 %15 %22 = OpCopyObject %8 %16 %23 = OpCopyObject %7 %10 %24 = OpIAdd %7 %9 %10 OpBranch %18 %20 = OpLabel OpBranch %18 %18 = OpLabel %26 = OpIAdd %7 %15 %10 %27 = OpCopyObject %12 %14 OpSelectionMerge %28 None OpBranchConditional %6 %29 %28 %29 = OpLabel %30 = OpCopyObject %7 %26 OpBranch %28 %28 = OpLabel OpReturn OpFunctionEnd %32 = OpFunction %7 None %31 %33 = OpLabel OpReturnValue %9 OpFunctionEnd )"; TEST(FuzzerPassAddOpPhiSynonymsTest, HelperFunctions) { const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassAddOpPhiSynonyms fuzzer_pass(context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false); SetUpIdSynonyms(transformation_context.GetFactManager()); std::vector> expected_equivalence_classes = { {9, 15, 21}, {11, 16, 22}, {10, 23}, {6}, {24, 26, 30}}; ASSERT_TRUE(ListsHaveTheSameElements>( fuzzer_pass.GetIdEquivalenceClasses(), expected_equivalence_classes)); // The set {24, 26, 30} is not suitable for 18 (none if the ids is available // for predecessor 20). ASSERT_FALSE( fuzzer_pass.EquivalenceClassIsSuitableForBlock({24, 26, 30}, 18, 1)); // The set {6} is not suitable for 18 if we require at least 2 distinct // available ids. ASSERT_FALSE(fuzzer_pass.EquivalenceClassIsSuitableForBlock({6}, 18, 2)); // Only id 26 from the set {24, 26, 30} is available to use for the // transformation at block 29, so the set is not suitable if we want at least // 2 available ids. ASSERT_FALSE( fuzzer_pass.EquivalenceClassIsSuitableForBlock({24, 26, 30}, 29, 2)); ASSERT_TRUE( fuzzer_pass.EquivalenceClassIsSuitableForBlock({24, 26, 30}, 29, 1)); // %21 is not available at the end of block 20. ASSERT_TRUE(ListsHaveTheSameElements( fuzzer_pass.GetSuitableIds({9, 15, 21}, 20), {9, 15})); // %24 and %30 are not available at the end of block 18. ASSERT_TRUE(ListsHaveTheSameElements( fuzzer_pass.GetSuitableIds({24, 26, 30}, 18), {26})); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/fuzzer_pass_construct_composites_test.cpp000066400000000000000000000144341475742701700312030ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_construct_composites.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/pseudo_random_generator.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(FuzzerPassConstructCompositesTest, IsomorphicStructs) { // This test declares various isomorphic structs, and a struct that is made up // of these isomorphic structs. The pass to construct composites is then // applied several times to check that no issues arise related to using a // value of one struct type when a value of an isomorphic struct type is // required. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpConstant %6 0 %8 = OpTypeStruct %6 %6 %6 %9 = OpTypeStruct %6 %6 %6 %10 = OpTypeStruct %6 %6 %6 %11 = OpTypeStruct %6 %6 %6 %12 = OpTypeStruct %6 %6 %6 %13 = OpTypeStruct %8 %9 %10 %11 %12 %14 = OpConstantComposite %8 %7 %7 %7 %15 = OpConstantComposite %9 %7 %7 %7 %16 = OpConstantComposite %10 %7 %7 %7 %17 = OpConstantComposite %11 %7 %7 %7 %18 = OpConstantComposite %12 %7 %7 %7 %4 = OpFunction %2 None %3 %5 = OpLabel OpNop OpNop OpNop OpNop OpNop OpNop OpNop OpNop OpNop OpNop OpNop OpNop OpNop OpNop OpNop OpNop OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; FuzzerContext fuzzer_context(MakeUnique(0), 100, false); for (uint32_t i = 0; i < 10; i++) { const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); protobufs::TransformationSequence transformation_sequence; FuzzerPassConstructComposites fuzzer_pass( context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false); fuzzer_pass.Apply(); // We just check that the result is valid. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } } TEST(FuzzerPassConstructCompositesTest, IsomorphicArrays) { // This test declares various isomorphic arrays, and a struct that is made up // of these isomorphic arrays. The pass to construct composites is then // applied several times to check that no issues arise related to using a // value of one array type when a value of an isomorphic array type is // required. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %50 = OpTypeInt 32 0 %51 = OpConstant %50 3 %7 = OpConstant %6 0 %8 = OpTypeArray %6 %51 %9 = OpTypeArray %6 %51 %10 = OpTypeArray %6 %51 %11 = OpTypeArray %6 %51 %12 = OpTypeArray %6 %51 %13 = OpTypeStruct %8 %9 %10 %11 %12 %14 = OpConstantComposite %8 %7 %7 %7 %15 = OpConstantComposite %9 %7 %7 %7 %16 = OpConstantComposite %10 %7 %7 %7 %17 = OpConstantComposite %11 %7 %7 %7 %18 = OpConstantComposite %12 %7 %7 %7 %4 = OpFunction %2 None %3 %5 = OpLabel OpNop OpNop OpNop OpNop OpNop OpNop OpNop OpNop OpNop OpNop OpNop OpNop OpNop OpNop OpNop OpNop OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; FuzzerContext fuzzer_context(MakeUnique(0), 100, false); for (uint32_t i = 0; i < 10; i++) { const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); protobufs::TransformationSequence transformation_sequence; FuzzerPassConstructComposites fuzzer_pass( context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false); fuzzer_pass.Apply(); // We just check that the result is valid. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/fuzzer_pass_donate_modules_test.cpp000066400000000000000000002444211475742701700277150ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_donate_modules.h" #include #include "gtest/gtest.h" #include "source/fuzz/pseudo_random_generator.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(FuzzerPassDonateModulesTest, BasicDonation) { std::string recipient_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %10 "m" OpName %16 "v" OpDecorate %16 RelaxedPrecision OpDecorate %20 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 3 %8 = OpTypeMatrix %7 2 %9 = OpTypePointer Private %8 %10 = OpVariable %9 Private %11 = OpTypeInt 32 1 %12 = OpConstant %11 0 %13 = OpTypeInt 32 0 %14 = OpTypeVector %13 4 %15 = OpTypePointer Private %14 %16 = OpVariable %15 Private %17 = OpConstant %13 2 %18 = OpTypePointer Private %13 %22 = OpConstant %13 0 %23 = OpTypePointer Private %6 %4 = OpFunction %2 None %3 %5 = OpLabel %19 = OpAccessChain %18 %16 %17 %20 = OpLoad %13 %19 %21 = OpConvertUToF %6 %20 %24 = OpAccessChain %23 %10 %12 %22 OpStore %24 %21 OpReturn OpFunctionEnd )"; std::string donor_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %12 "bar(mf24;" OpName %11 "m" OpName %20 "foo(vu4;" OpName %19 "v" OpName %23 "x" OpName %26 "param" OpName %29 "result" OpName %31 "i" OpName %81 "param" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypeMatrix %7 2 %9 = OpTypePointer Function %8 %10 = OpTypeFunction %6 %9 %14 = OpTypeInt 32 0 %15 = OpTypeVector %14 4 %16 = OpTypePointer Function %15 %17 = OpTypeInt 32 1 %18 = OpTypeFunction %17 %16 %22 = OpTypePointer Function %17 %24 = OpConstant %14 2 %25 = OpConstantComposite %15 %24 %24 %24 %24 %28 = OpTypePointer Function %6 %30 = OpConstant %6 0 %32 = OpConstant %17 0 %39 = OpConstant %17 10 %40 = OpTypeBool %43 = OpConstant %17 3 %50 = OpConstant %17 1 %55 = OpConstant %14 0 %56 = OpTypePointer Function %14 %59 = OpConstant %14 1 %65 = OpConstant %17 2 %68 = OpConstant %6 1 %69 = OpConstant %6 2 %70 = OpConstant %6 3 %71 = OpConstant %6 4 %72 = OpConstant %14 3 %76 = OpConstant %6 6 %77 = OpConstant %6 7 %4 = OpFunction %2 None %3 %5 = OpLabel %23 = OpVariable %22 Function %26 = OpVariable %16 Function OpStore %26 %25 %27 = OpFunctionCall %17 %20 %26 OpStore %23 %27 OpReturn OpFunctionEnd %12 = OpFunction %6 None %10 %11 = OpFunctionParameter %9 %13 = OpLabel %29 = OpVariable %28 Function %31 = OpVariable %22 Function OpStore %29 %30 OpStore %31 %32 OpBranch %33 %33 = OpLabel OpLoopMerge %35 %36 None OpBranch %37 %37 = OpLabel %38 = OpLoad %17 %31 %41 = OpSLessThan %40 %38 %39 OpBranchConditional %41 %34 %35 %34 = OpLabel %42 = OpLoad %17 %31 %44 = OpExtInst %17 %1 SClamp %42 %32 %43 %45 = OpAccessChain %28 %11 %32 %44 %46 = OpLoad %6 %45 %47 = OpLoad %6 %29 %48 = OpFAdd %6 %47 %46 OpStore %29 %48 OpBranch %36 %36 = OpLabel %49 = OpLoad %17 %31 %51 = OpIAdd %17 %49 %50 OpStore %31 %51 OpBranch %33 %35 = OpLabel %52 = OpLoad %6 %29 OpReturnValue %52 OpFunctionEnd %20 = OpFunction %17 None %18 %19 = OpFunctionParameter %16 %21 = OpLabel %81 = OpVariable %9 Function %57 = OpAccessChain %56 %19 %55 %58 = OpLoad %14 %57 %60 = OpAccessChain %56 %19 %59 %61 = OpLoad %14 %60 %62 = OpUGreaterThan %40 %58 %61 OpSelectionMerge %64 None OpBranchConditional %62 %63 %67 %63 = OpLabel OpReturnValue %65 %67 = OpLabel %73 = OpAccessChain %56 %19 %72 %74 = OpLoad %14 %73 %75 = OpConvertUToF %6 %74 %78 = OpCompositeConstruct %7 %30 %68 %69 %70 %79 = OpCompositeConstruct %7 %71 %75 %76 %77 %80 = OpCompositeConstruct %8 %78 %79 OpStore %81 %80 %82 = OpFunctionCall %6 %12 %81 %83 = OpConvertFToS %17 %82 OpReturnValue %83 %64 = OpLabel %85 = OpUndef %17 OpReturnValue %85 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule(env, consumer, recipient_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule(env, consumer, donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); fuzzer_pass.DonateSingleModule(donor_context.get(), false); // We just check that the result is valid. Checking to what it should be // exactly equal to would be very fragile. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); } TEST(FuzzerPassDonateModulesTest, DonationWithUniforms) { // This test checks that when donating a shader that contains uniforms, // uniform variables and associated pointer types are demoted from having // Uniform storage class to Private storage class. std::string recipient_and_donor_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpMemberDecorate %9 0 Offset 0 OpDecorate %9 Block OpDecorate %11 DescriptorSet 0 OpDecorate %11 Binding 0 OpMemberDecorate %19 0 Offset 0 OpDecorate %19 Block OpDecorate %21 DescriptorSet 0 OpDecorate %21 Binding 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %9 = OpTypeStruct %6 %10 = OpTypePointer Uniform %9 %11 = OpVariable %10 Uniform %12 = OpTypeInt 32 1 %13 = OpConstant %12 0 %14 = OpTypePointer Uniform %6 %17 = OpTypePointer Function %12 %19 = OpTypeStruct %12 %20 = OpTypePointer Uniform %19 %21 = OpVariable %20 Uniform %22 = OpTypePointer Uniform %12 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %18 = OpVariable %17 Function %15 = OpAccessChain %14 %11 %13 %16 = OpLoad %6 %15 OpStore %8 %16 %23 = OpAccessChain %22 %21 %13 %24 = OpLoad %12 %23 OpStore %18 %24 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule( env, consumer, recipient_and_donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule( env, consumer, recipient_and_donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); fuzzer_pass.DonateSingleModule(donor_context.get(), false); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpMemberDecorate %9 0 Offset 0 OpDecorate %9 Block OpDecorate %11 DescriptorSet 0 OpDecorate %11 Binding 0 OpMemberDecorate %19 0 Offset 0 OpDecorate %19 Block OpDecorate %21 DescriptorSet 0 OpDecorate %21 Binding 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %9 = OpTypeStruct %6 %10 = OpTypePointer Uniform %9 %11 = OpVariable %10 Uniform %12 = OpTypeInt 32 1 %13 = OpConstant %12 0 %14 = OpTypePointer Uniform %6 %17 = OpTypePointer Function %12 %19 = OpTypeStruct %12 %20 = OpTypePointer Uniform %19 %21 = OpVariable %20 Uniform %22 = OpTypePointer Uniform %12 %100 = OpTypePointer Function %6 %101 = OpTypeStruct %6 %102 = OpTypePointer Private %101 %104 = OpConstant %6 0 %105 = OpConstantComposite %101 %104 %103 = OpVariable %102 Private %105 %106 = OpConstant %12 0 %107 = OpTypePointer Private %6 %108 = OpTypePointer Function %12 %109 = OpTypeStruct %12 %110 = OpTypePointer Private %109 %112 = OpConstantComposite %109 %13 %111 = OpVariable %110 Private %112 %113 = OpTypePointer Private %12 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %18 = OpVariable %17 Function %15 = OpAccessChain %14 %11 %13 %16 = OpLoad %6 %15 OpStore %8 %16 %23 = OpAccessChain %22 %21 %13 %24 = OpLoad %12 %23 OpStore %18 %24 OpReturn OpFunctionEnd %114 = OpFunction %2 None %3 %115 = OpLabel %116 = OpVariable %100 Function %104 %117 = OpVariable %108 Function %13 %118 = OpAccessChain %107 %103 %106 %119 = OpLoad %6 %118 OpStore %116 %119 %120 = OpAccessChain %113 %111 %106 %121 = OpLoad %12 %120 OpStore %117 %121 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, recipient_context.get())); } TEST(FuzzerPassDonateModulesTest, DonationWithInputAndOutputVariables) { // This test checks that when donating a shader that contains input and output // variables, such variables and associated pointer types are demoted to have // the Private storage class. std::string recipient_and_donor_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %9 %11 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %9 Location 0 OpDecorate %11 Location 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypePointer Output %7 %9 = OpVariable %8 Output %10 = OpTypePointer Input %7 %11 = OpVariable %10 Input %4 = OpFunction %2 None %3 %5 = OpLabel %12 = OpLoad %7 %11 OpStore %9 %12 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule( env, consumer, recipient_and_donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule( env, consumer, recipient_and_donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); fuzzer_pass.DonateSingleModule(donor_context.get(), false); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %9 %11 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %9 Location 0 OpDecorate %11 Location 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypePointer Output %7 %9 = OpVariable %8 Output %10 = OpTypePointer Input %7 %11 = OpVariable %10 Input %100 = OpTypePointer Private %7 %102 = OpConstant %6 0 %103 = OpConstantComposite %7 %102 %102 %102 %102 %101 = OpVariable %100 Private %103 %104 = OpTypePointer Private %7 %105 = OpVariable %104 Private %103 %4 = OpFunction %2 None %3 %5 = OpLabel %12 = OpLoad %7 %11 OpStore %9 %12 OpReturn OpFunctionEnd %106 = OpFunction %2 None %3 %107 = OpLabel %108 = OpLoad %7 %105 OpStore %101 %108 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, recipient_context.get())); } TEST(FuzzerPassDonateModulesTest, DonateFunctionTypeWithDifferentPointers) { std::string recipient_and_donor_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %2 %7 %4 = OpFunction %2 None %3 %5 = OpLabel %9 = OpVariable %7 Function %10 = OpFunctionCall %2 %11 %9 OpReturn OpFunctionEnd %11 = OpFunction %2 None %8 %12 = OpFunctionParameter %7 %13 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule( env, consumer, recipient_and_donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule( env, consumer, recipient_and_donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); fuzzer_pass.DonateSingleModule(donor_context.get(), false); // We just check that the result is valid. Checking to what it should be // exactly equal to would be very fragile. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); } TEST(FuzzerPassDonateModulesTest, DonateOpConstantNull) { std::string recipient_shader = R"( OpCapability Shader OpCapability ImageQuery OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpSourceExtension "GL_EXT_samplerless_texture_functions" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; std::string donor_shader = R"( OpCapability Shader OpCapability ImageQuery OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Private %6 %8 = OpConstantNull %7 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule(env, consumer, recipient_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule(env, consumer, donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); fuzzer_pass.DonateSingleModule(donor_context.get(), false); // We just check that the result is valid. Checking to what it should be // exactly equal to would be very fragile. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); } TEST(FuzzerPassDonateModulesTest, DonateCodeThatUsesImages) { std::string recipient_shader = R"( OpCapability Shader OpCapability ImageQuery %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpSourceExtension "GL_EXT_samplerless_texture_functions" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; std::string donor_shader = R"( OpCapability Shader OpCapability ImageQuery %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpSourceExtension "GL_EXT_samplerless_texture_functions" OpName %4 "main" OpName %10 "mySampler" OpName %21 "myTexture" OpName %33 "v" OpDecorate %10 RelaxedPrecision OpDecorate %10 DescriptorSet 0 OpDecorate %10 Binding 0 OpDecorate %11 RelaxedPrecision OpDecorate %21 RelaxedPrecision OpDecorate %21 DescriptorSet 0 OpDecorate %21 Binding 1 OpDecorate %22 RelaxedPrecision OpDecorate %34 RelaxedPrecision OpDecorate %40 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %43 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeImage %6 2D 0 0 0 1 Unknown %8 = OpTypeSampledImage %7 %9 = OpTypePointer UniformConstant %8 %10 = OpVariable %9 UniformConstant %12 = OpTypeInt 32 1 %13 = OpConstant %12 2 %15 = OpTypeVector %12 2 %17 = OpTypeInt 32 0 %18 = OpConstant %17 0 %20 = OpTypePointer UniformConstant %7 %21 = OpVariable %20 UniformConstant %23 = OpConstant %12 1 %25 = OpConstant %17 1 %27 = OpTypeBool %31 = OpTypeVector %6 4 %32 = OpTypePointer Function %31 %35 = OpConstantComposite %15 %23 %23 %36 = OpConstant %12 3 %37 = OpConstant %12 4 %38 = OpConstantComposite %15 %36 %37 %4 = OpFunction %2 None %3 %5 = OpLabel %33 = OpVariable %32 Function %11 = OpLoad %8 %10 %14 = OpImage %7 %11 %16 = OpImageQuerySizeLod %15 %14 %13 %19 = OpCompositeExtract %12 %16 0 %22 = OpLoad %7 %21 %24 = OpImageQuerySizeLod %15 %22 %23 %26 = OpCompositeExtract %12 %24 1 %28 = OpSGreaterThan %27 %19 %26 OpSelectionMerge %30 None OpBranchConditional %28 %29 %41 %29 = OpLabel %34 = OpLoad %8 %10 %39 = OpImage %7 %34 %40 = OpImageFetch %31 %39 %35 Lod|ConstOffset %13 %38 OpStore %33 %40 OpBranch %30 %41 = OpLabel %42 = OpLoad %7 %21 %43 = OpImageFetch %31 %42 %35 Lod|ConstOffset %13 %38 OpStore %33 %43 OpBranch %30 %30 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule(env, consumer, recipient_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule(env, consumer, donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); fuzzer_pass.DonateSingleModule(donor_context.get(), false); // We just check that the result is valid. Checking to what it should be // exactly equal to would be very fragile. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); } TEST(FuzzerPassDonateModulesTest, DonateCodeThatUsesSampler) { std::string recipient_shader = R"( OpCapability Shader OpCapability ImageQuery %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpSourceExtension "GL_EXT_samplerless_texture_functions" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; std::string donor_shader = R"( OpCapability Shader OpCapability ImageQuery %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpDecorate %16 DescriptorSet 0 OpDecorate %16 Binding 0 OpDecorate %12 DescriptorSet 0 OpDecorate %12 Binding 64 %2 = OpTypeVoid %3 = OpTypeFunction %2 %23 = OpTypeFloat 32 %6 = OpTypeImage %23 2D 2 0 0 1 Unknown %47 = OpTypePointer UniformConstant %6 %12 = OpVariable %47 UniformConstant %15 = OpTypeSampler %55 = OpTypePointer UniformConstant %15 %17 = OpTypeSampledImage %6 %16 = OpVariable %55 UniformConstant %37 = OpTypeVector %23 4 %109 = OpConstant %23 0 %66 = OpConstantComposite %37 %109 %109 %109 %109 %56 = OpTypeBool %54 = OpConstantTrue %56 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %50 %50 = OpLabel %51 = OpPhi %37 %66 %5 %111 %53 OpLoopMerge %52 %53 None OpBranchConditional %54 %53 %52 %53 = OpLabel %106 = OpLoad %6 %12 %107 = OpLoad %15 %16 %110 = OpSampledImage %17 %106 %107 %111 = OpImageSampleImplicitLod %37 %110 %66 Bias %109 OpBranch %50 %52 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule(env, consumer, recipient_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule(env, consumer, donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); fuzzer_pass.DonateSingleModule(donor_context.get(), false); // We just check that the result is valid. Checking to what it should be // exactly equal to would be very fragile. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); } TEST(FuzzerPassDonateModulesTest, DonateCodeThatUsesImageStructField) { std::string recipient_shader = R"( OpCapability Shader OpCapability ImageQuery %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpSourceExtension "GL_EXT_samplerless_texture_functions" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; std::string donor_shader = R"( OpCapability Shader OpCapability ImageQuery %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpSourceExtension "GL_EXT_samplerless_texture_functions" OpName %4 "main" OpName %10 "mySampler" OpName %21 "myTexture" OpName %33 "v" OpDecorate %10 RelaxedPrecision OpDecorate %10 DescriptorSet 0 OpDecorate %10 Binding 0 OpDecorate %11 RelaxedPrecision OpDecorate %21 RelaxedPrecision OpDecorate %21 DescriptorSet 0 OpDecorate %21 Binding 1 OpDecorate %22 RelaxedPrecision OpDecorate %34 RelaxedPrecision OpDecorate %40 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %43 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeImage %6 2D 0 0 0 1 Unknown %8 = OpTypeSampledImage %7 %9 = OpTypePointer UniformConstant %8 %10 = OpVariable %9 UniformConstant %12 = OpTypeInt 32 1 %13 = OpConstant %12 2 %15 = OpTypeVector %12 2 %17 = OpTypeInt 32 0 %18 = OpConstant %17 0 %20 = OpTypePointer UniformConstant %7 %21 = OpVariable %20 UniformConstant %23 = OpConstant %12 1 %25 = OpConstant %17 1 %27 = OpTypeBool %31 = OpTypeVector %6 4 %32 = OpTypePointer Function %31 %35 = OpConstantComposite %15 %23 %23 %36 = OpConstant %12 3 %37 = OpConstant %12 4 %38 = OpConstantComposite %15 %36 %37 %201 = OpTypeStruct %7 %7 %4 = OpFunction %2 None %3 %5 = OpLabel %33 = OpVariable %32 Function %11 = OpLoad %8 %10 %14 = OpImage %7 %11 %22 = OpLoad %7 %21 %200 = OpCompositeConstruct %201 %14 %22 %202 = OpCompositeExtract %7 %200 0 %203 = OpCompositeExtract %7 %200 1 %24 = OpImageQuerySizeLod %15 %203 %23 %16 = OpImageQuerySizeLod %15 %202 %13 %26 = OpCompositeExtract %12 %24 1 %19 = OpCompositeExtract %12 %16 0 %28 = OpSGreaterThan %27 %19 %26 OpSelectionMerge %30 None OpBranchConditional %28 %29 %41 %29 = OpLabel %34 = OpLoad %8 %10 %39 = OpImage %7 %34 %40 = OpImageFetch %31 %39 %35 Lod|ConstOffset %13 %38 OpStore %33 %40 OpBranch %30 %41 = OpLabel %42 = OpLoad %7 %21 %43 = OpImageFetch %31 %42 %35 Lod|ConstOffset %13 %38 OpStore %33 %43 OpBranch %30 %30 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule(env, consumer, recipient_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule(env, consumer, donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); fuzzer_pass.DonateSingleModule(donor_context.get(), false); // We just check that the result is valid. Checking to what it should be // exactly equal to would be very fragile. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); } TEST(FuzzerPassDonateModulesTest, DonateCodeThatUsesImageFunctionParameter) { std::string recipient_shader = R"( OpCapability Shader OpCapability ImageQuery %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpSourceExtension "GL_EXT_samplerless_texture_functions" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; std::string donor_shader = R"( OpCapability Shader OpCapability ImageQuery %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpSourceExtension "GL_EXT_samplerless_texture_functions" OpName %4 "main" OpName %10 "mySampler" OpName %21 "myTexture" OpName %33 "v" OpDecorate %10 RelaxedPrecision OpDecorate %10 DescriptorSet 0 OpDecorate %10 Binding 0 OpDecorate %11 RelaxedPrecision OpDecorate %21 RelaxedPrecision OpDecorate %21 DescriptorSet 0 OpDecorate %21 Binding 1 OpDecorate %22 RelaxedPrecision OpDecorate %34 RelaxedPrecision OpDecorate %40 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %43 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeImage %6 2D 0 0 0 1 Unknown %8 = OpTypeSampledImage %7 %9 = OpTypePointer UniformConstant %8 %10 = OpVariable %9 UniformConstant %12 = OpTypeInt 32 1 %13 = OpConstant %12 2 %15 = OpTypeVector %12 2 %17 = OpTypeInt 32 0 %18 = OpConstant %17 0 %20 = OpTypePointer UniformConstant %7 %21 = OpVariable %20 UniformConstant %23 = OpConstant %12 1 %25 = OpConstant %17 1 %27 = OpTypeBool %31 = OpTypeVector %6 4 %32 = OpTypePointer Function %31 %35 = OpConstantComposite %15 %23 %23 %36 = OpConstant %12 3 %37 = OpConstant %12 4 %38 = OpConstantComposite %15 %36 %37 %201 = OpTypeFunction %15 %7 %12 %4 = OpFunction %2 None %3 %5 = OpLabel %33 = OpVariable %32 Function %11 = OpLoad %8 %10 %14 = OpImage %7 %11 %16 = OpFunctionCall %15 %200 %14 %13 %19 = OpCompositeExtract %12 %16 0 %22 = OpLoad %7 %21 %24 = OpImageQuerySizeLod %15 %22 %23 %26 = OpCompositeExtract %12 %24 1 %28 = OpSGreaterThan %27 %19 %26 OpSelectionMerge %30 None OpBranchConditional %28 %29 %41 %29 = OpLabel %34 = OpLoad %8 %10 %39 = OpImage %7 %34 %40 = OpImageFetch %31 %39 %35 Lod|ConstOffset %13 %38 OpStore %33 %40 OpBranch %30 %41 = OpLabel %42 = OpLoad %7 %21 %43 = OpImageFetch %31 %42 %35 Lod|ConstOffset %13 %38 OpStore %33 %43 OpBranch %30 %30 = OpLabel OpReturn OpFunctionEnd %200 = OpFunction %15 None %201 %202 = OpFunctionParameter %7 %203 = OpFunctionParameter %12 %204 = OpLabel %205 = OpImageQuerySizeLod %15 %202 %203 OpReturnValue %205 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule(env, consumer, recipient_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule(env, consumer, donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); fuzzer_pass.DonateSingleModule(donor_context.get(), false); // We just check that the result is valid. Checking to what it should be // exactly equal to would be very fragile. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); } TEST(FuzzerPassDonateModulesTest, DonateShaderWithImageStorageClass) { std::string recipient_shader = R"( OpCapability Shader OpCapability ImageQuery %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpSourceExtension "GL_EXT_samplerless_texture_functions" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; std::string donor_shader = R"( OpCapability Shader OpCapability SampledBuffer OpCapability ImageBuffer %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "MainPSPacked" OpExecutionMode %2 OriginUpperLeft OpDecorate %18 DescriptorSet 0 OpDecorate %18 Binding 128 %49 = OpTypeInt 32 0 %50 = OpTypeFloat 32 %58 = OpConstant %50 1 %66 = OpConstant %49 0 %87 = OpTypeVector %50 2 %88 = OpConstantComposite %87 %58 %58 %17 = OpTypeImage %49 2D 2 0 0 2 R32ui %118 = OpTypePointer UniformConstant %17 %123 = OpTypeVector %49 2 %132 = OpTypeVoid %133 = OpTypeFunction %132 %142 = OpTypePointer Image %49 %18 = OpVariable %118 UniformConstant %2 = OpFunction %132 None %133 %153 = OpLabel %495 = OpConvertFToU %123 %88 %501 = OpImageTexelPointer %142 %18 %495 %66 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule(env, consumer, recipient_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule(env, consumer, donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); fuzzer_pass.DonateSingleModule(donor_context.get(), true); // We just check that the result is valid. Checking to what it should be // exactly equal to would be very fragile. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); } TEST(FuzzerPassDonateModulesTest, DonateComputeShaderWithRuntimeArray) { std::string recipient_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; std::string donor_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpDecorate %9 ArrayStride 4 OpMemberDecorate %10 0 Offset 0 OpDecorate %10 BufferBlock OpDecorate %12 DescriptorSet 0 OpDecorate %12 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpTypeRuntimeArray %6 %10 = OpTypeStruct %9 %11 = OpTypePointer Uniform %10 %12 = OpVariable %11 Uniform %13 = OpTypeInt 32 0 %16 = OpConstant %6 0 %18 = OpConstant %6 1 %20 = OpTypePointer Uniform %6 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %14 = OpArrayLength %13 %12 0 %15 = OpBitcast %6 %14 OpStore %8 %15 %17 = OpLoad %6 %8 %19 = OpISub %6 %17 %18 %21 = OpAccessChain %20 %12 %16 %19 OpStore %21 %16 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule(env, consumer, recipient_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule(env, consumer, donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); fuzzer_pass.DonateSingleModule(donor_context.get(), false); // We just check that the result is valid. Checking to what it should be // exactly equal to would be very fragile. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); } TEST(FuzzerPassDonateModulesTest, DonateComputeShaderWithRuntimeArrayLivesafe) { std::string recipient_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; std::string donor_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpDecorate %16 ArrayStride 4 OpMemberDecorate %17 0 Offset 0 OpDecorate %17 BufferBlock OpDecorate %19 DescriptorSet 0 OpDecorate %19 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpTypeRuntimeArray %6 %17 = OpTypeStruct %16 %18 = OpTypePointer Uniform %17 %19 = OpVariable %18 Uniform %20 = OpTypeInt 32 0 %23 = OpTypeBool %26 = OpConstant %6 32 %27 = OpTypePointer Uniform %6 %30 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %15 = OpLoad %6 %8 %21 = OpArrayLength %20 %19 0 %22 = OpBitcast %6 %21 %24 = OpSLessThan %23 %15 %22 OpBranchConditional %24 %11 %12 %11 = OpLabel %25 = OpLoad %6 %8 %28 = OpAccessChain %27 %19 %9 %25 OpStore %28 %26 OpBranch %13 %13 = OpLabel %29 = OpLoad %6 %8 %31 = OpIAdd %6 %29 %30 OpStore %8 %31 OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule(env, consumer, recipient_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule(env, consumer, donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); fuzzer_pass.DonateSingleModule(donor_context.get(), true); // We just check that the result is valid. Checking to what it should be // exactly equal to would be very fragile. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); } TEST(FuzzerPassDonateModulesTest, DonateComputeShaderWithWorkgroupVariables) { std::string recipient_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; std::string donor_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Workgroup %6 %8 = OpVariable %7 Workgroup %9 = OpConstant %6 2 %10 = OpVariable %7 Workgroup %4 = OpFunction %2 None %3 %5 = OpLabel OpStore %8 %9 %11 = OpLoad %6 %8 OpStore %10 %11 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule(env, consumer, recipient_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule(env, consumer, donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); fuzzer_pass.DonateSingleModule(donor_context.get(), true); // We just check that the result is valid. Checking to what it should be // exactly equal to would be very fragile. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); } TEST(FuzzerPassDonateModulesTest, DonateComputeShaderWithAtomics) { std::string recipient_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; std::string donor_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpMemberDecorate %9 0 Offset 0 OpDecorate %9 BufferBlock OpDecorate %11 DescriptorSet 0 OpDecorate %11 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpTypePointer Function %6 %9 = OpTypeStruct %6 %10 = OpTypePointer Uniform %9 %11 = OpVariable %10 Uniform %12 = OpTypeInt 32 1 %13 = OpConstant %12 0 %14 = OpTypePointer Uniform %6 %16 = OpConstant %6 1 %17 = OpConstant %6 0 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %15 = OpAccessChain %14 %11 %13 %18 = OpAtomicIAdd %6 %15 %16 %17 %16 OpStore %8 %18 %19 = OpAccessChain %14 %11 %13 %20 = OpLoad %6 %8 %21 = OpAtomicUMin %6 %19 %16 %17 %20 OpStore %8 %21 %22 = OpAccessChain %14 %11 %13 %23 = OpLoad %6 %8 %24 = OpAtomicUMax %6 %22 %16 %17 %23 OpStore %8 %24 %25 = OpAccessChain %14 %11 %13 %26 = OpLoad %6 %8 %27 = OpAtomicAnd %6 %25 %16 %17 %26 OpStore %8 %27 %28 = OpAccessChain %14 %11 %13 %29 = OpLoad %6 %8 %30 = OpAtomicOr %6 %28 %16 %17 %29 OpStore %8 %30 %31 = OpAccessChain %14 %11 %13 %32 = OpLoad %6 %8 %33 = OpAtomicXor %6 %31 %16 %17 %32 OpStore %8 %33 %34 = OpAccessChain %14 %11 %13 %35 = OpLoad %6 %8 %36 = OpAtomicExchange %6 %34 %16 %17 %35 OpStore %8 %36 %37 = OpAccessChain %14 %11 %13 %38 = OpLoad %6 %8 %39 = OpAtomicCompareExchange %6 %37 %16 %17 %17 %16 %38 OpStore %8 %39 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule(env, consumer, recipient_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule(env, consumer, donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); fuzzer_pass.DonateSingleModule(donor_context.get(), true); // We just check that the result is valid. Checking to what it should be // exactly equal to would be very fragile. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); } TEST(FuzzerPassDonateModulesTest, Miscellaneous1) { std::string recipient_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; std::string donor_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %6 "foo(" OpName %10 "x" OpName %12 "i" OpName %33 "i" OpName %42 "j" OpDecorate %10 RelaxedPrecision OpDecorate %12 RelaxedPrecision OpDecorate %19 RelaxedPrecision OpDecorate %23 RelaxedPrecision OpDecorate %24 RelaxedPrecision OpDecorate %25 RelaxedPrecision OpDecorate %26 RelaxedPrecision OpDecorate %27 RelaxedPrecision OpDecorate %28 RelaxedPrecision OpDecorate %30 RelaxedPrecision OpDecorate %33 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %49 RelaxedPrecision OpDecorate %52 RelaxedPrecision OpDecorate %53 RelaxedPrecision OpDecorate %58 RelaxedPrecision OpDecorate %59 RelaxedPrecision OpDecorate %60 RelaxedPrecision OpDecorate %63 RelaxedPrecision OpDecorate %64 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %11 = OpConstant %8 2 %13 = OpConstant %8 0 %20 = OpConstant %8 100 %21 = OpTypeBool %29 = OpConstant %8 1 %40 = OpConstant %8 10 %43 = OpConstant %8 20 %61 = OpConstant %8 4 %4 = OpFunction %2 None %3 %5 = OpLabel %33 = OpVariable %9 Function %42 = OpVariable %9 Function %32 = OpFunctionCall %2 %6 OpStore %33 %13 OpBranch %34 %34 = OpLabel OpLoopMerge %36 %37 None OpBranch %38 %38 = OpLabel %39 = OpLoad %8 %33 %41 = OpSLessThan %21 %39 %40 OpBranchConditional %41 %35 %36 %35 = OpLabel OpStore %42 %43 OpBranch %44 %44 = OpLabel OpLoopMerge %46 %47 None OpBranch %48 %48 = OpLabel %49 = OpLoad %8 %42 %50 = OpSGreaterThan %21 %49 %13 OpBranchConditional %50 %45 %46 %45 = OpLabel %51 = OpFunctionCall %2 %6 %52 = OpLoad %8 %42 %53 = OpISub %8 %52 %29 OpStore %42 %53 OpBranch %47 %47 = OpLabel OpBranch %44 %46 = OpLabel OpBranch %54 %54 = OpLabel OpLoopMerge %56 %57 None OpBranch %55 %55 = OpLabel %58 = OpLoad %8 %33 %59 = OpIAdd %8 %58 %29 OpStore %33 %59 OpBranch %57 %57 = OpLabel %60 = OpLoad %8 %33 %62 = OpSLessThan %21 %60 %61 OpBranchConditional %62 %54 %56 %56 = OpLabel OpBranch %37 %37 = OpLabel %63 = OpLoad %8 %33 %64 = OpIAdd %8 %63 %29 OpStore %33 %64 OpBranch %34 %36 = OpLabel OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %10 = OpVariable %9 Function %12 = OpVariable %9 Function OpStore %10 %11 OpStore %12 %13 OpBranch %14 %14 = OpLabel OpLoopMerge %16 %17 None OpBranch %18 %18 = OpLabel %19 = OpLoad %8 %12 %22 = OpSLessThan %21 %19 %20 OpBranchConditional %22 %15 %16 %15 = OpLabel %23 = OpLoad %8 %12 %24 = OpLoad %8 %10 %25 = OpIAdd %8 %24 %23 OpStore %10 %25 %26 = OpLoad %8 %10 %27 = OpIMul %8 %26 %11 OpStore %10 %27 OpBranch %17 %17 = OpLabel %28 = OpLoad %8 %12 %30 = OpIAdd %8 %28 %29 OpStore %12 %30 OpBranch %14 %16 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule(env, consumer, recipient_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule(env, consumer, donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); fuzzer_pass.DonateSingleModule(donor_context.get(), false); // We just check that the result is valid. Checking to what it should be // exactly equal to would be very fragile. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); } TEST(FuzzerPassDonateModulesTest, OpSpecConstantInstructions) { std::string donor_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpTypeInt 32 1 %8 = OpTypeStruct %6 %6 %7 %9 = OpSpecConstantTrue %6 %10 = OpSpecConstantFalse %6 %11 = OpSpecConstant %7 2 %12 = OpSpecConstantComposite %8 %9 %10 %11 %13 = OpSpecConstantOp %6 LogicalEqual %9 %10 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; std::string recipient_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule(env, consumer, recipient_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule(env, consumer, donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); fuzzer_pass.DonateSingleModule(donor_context.get(), false); // Check that the module is valid first. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); std::string expected_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %100 = OpTypeBool %101 = OpTypeInt 32 1 %102 = OpTypeStruct %100 %100 %101 %103 = OpConstantTrue %100 %104 = OpConstantFalse %100 %105 = OpConstant %101 2 %106 = OpConstantComposite %102 %103 %104 %105 %107 = OpSpecConstantOp %100 LogicalEqual %103 %104 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %108 = OpFunction %2 None %3 %109 = OpLabel OpReturn OpFunctionEnd )"; // Now check that the transformation has produced the expected result. ASSERT_TRUE(IsEqual(env, expected_shader, recipient_context.get())); } TEST(FuzzerPassDonateModulesTest, DonationSupportsOpTypeRuntimeArray) { std::string donor_shader = R"( OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %29 "kernel_1" OpEntryPoint GLCompute %37 "kernel_2" OpSource OpenCL_C 120 OpDecorate %2 ArrayStride 4 OpMemberDecorate %3 0 Offset 0 OpDecorate %3 Block OpMemberDecorate %5 0 Offset 0 OpMemberDecorate %6 0 Offset 0 OpDecorate %6 Block OpDecorate %21 BuiltIn WorkgroupSize OpDecorate %23 DescriptorSet 0 OpDecorate %23 Binding 0 OpDecorate %25 SpecId 3 OpDecorate %18 SpecId 0 OpDecorate %19 SpecId 1 OpDecorate %20 SpecId 2 %1 = OpTypeInt 32 0 %2 = OpTypeRuntimeArray %1 %3 = OpTypeStruct %2 %4 = OpTypePointer StorageBuffer %3 %5 = OpTypeStruct %1 %6 = OpTypeStruct %5 %7 = OpTypePointer PushConstant %6 %8 = OpTypeFloat 32 %9 = OpTypeVoid %10 = OpTypeFunction %9 %11 = OpTypePointer Workgroup %1 %12 = OpTypePointer PushConstant %5 %13 = OpTypePointer StorageBuffer %1 %14 = OpTypeFunction %1 %1 %15 = OpTypeVector %1 3 %16 = OpTypePointer Private %15 %17 = OpConstant %1 0 %18 = OpSpecConstant %1 1 %19 = OpSpecConstant %1 1 %20 = OpSpecConstant %1 1 %21 = OpSpecConstantComposite %15 %18 %19 %20 %25 = OpSpecConstant %1 1 %26 = OpTypeArray %1 %25 %27 = OpTypePointer Workgroup %26 %22 = OpVariable %16 Private %21 %23 = OpVariable %4 StorageBuffer %24 = OpVariable %7 PushConstant %28 = OpVariable %27 Workgroup %29 = OpFunction %9 None %10 %30 = OpLabel %31 = OpAccessChain %11 %28 %17 %32 = OpAccessChain %12 %24 %17 %33 = OpLoad %5 %32 %34 = OpCompositeExtract %1 %33 0 %35 = OpFunctionCall %1 %45 %34 %36 = OpAccessChain %13 %23 %17 %34 OpStore %36 %35 OpReturn OpFunctionEnd %37 = OpFunction %9 None %10 %38 = OpLabel %39 = OpAccessChain %11 %28 %17 %40 = OpAccessChain %12 %24 %17 %41 = OpLoad %5 %40 %42 = OpCompositeExtract %1 %41 0 %43 = OpFunctionCall %1 %45 %42 %44 = OpAccessChain %13 %23 %17 %42 OpStore %44 %43 OpReturn OpFunctionEnd %45 = OpFunction %1 Pure %14 %46 = OpFunctionParameter %1 %47 = OpLabel %48 = OpAccessChain %11 %28 %46 %49 = OpLoad %1 %48 OpReturnValue %49 OpFunctionEnd )"; std::string recipient_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_0; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule(env, consumer, recipient_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule(env, consumer, donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); fuzzer_pass.DonateSingleModule(donor_context.get(), false); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); } TEST(FuzzerPassDonateModulesTest, HandlesCapabilities) { std::string donor_shader = R"( OpCapability VariablePointersStorageBuffer %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %11 = OpConstant %6 23 %7 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpBranch %9 %9 = OpLabel %10 = OpPhi %7 %8 %5 OpStore %10 %11 OpReturn OpFunctionEnd )"; std::string recipient_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule(env, consumer, recipient_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule(env, consumer, donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); ASSERT_TRUE(donor_context->get_feature_mgr()->HasCapability( spv::Capability::VariablePointersStorageBuffer)); ASSERT_FALSE(recipient_context->get_feature_mgr()->HasCapability( spv::Capability::VariablePointersStorageBuffer)); fuzzer_pass.DonateSingleModule(donor_context.get(), false); // Check that recipient module hasn't changed. ASSERT_TRUE(IsEqual(env, recipient_shader, recipient_context.get())); // Add the missing capability. // // We are adding VariablePointers to test the case when donor and recipient // have different OpCapability instructions but the same capabilities. In our // example, VariablePointers implicitly declares // VariablePointersStorageBuffer. Thus, two modules must be compatible. recipient_context->AddCapability(spv::Capability::VariablePointers); ASSERT_TRUE(donor_context->get_feature_mgr()->HasCapability( spv::Capability::VariablePointersStorageBuffer)); ASSERT_TRUE(recipient_context->get_feature_mgr()->HasCapability( spv::Capability::VariablePointersStorageBuffer)); fuzzer_pass.DonateSingleModule(donor_context.get(), false); // Check that donation was successful. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %100 = OpTypeFloat 32 %101 = OpConstant %100 23 %102 = OpTypePointer Function %100 %105 = OpConstant %100 0 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %103 = OpFunction %2 None %3 %104 = OpLabel %106 = OpVariable %102 Function %105 OpBranch %107 %107 = OpLabel %108 = OpPhi %102 %106 %104 OpStore %108 %101 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, recipient_context.get())); } TEST(FuzzerPassDonateModulesTest, HandlesOpPhisInMergeBlock) { std::string donor_shader = R"( ; OpPhis don't support pointers without this capability ; and we need pointers to test some of the functionality OpCapability VariablePointers OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %14 = OpTypeBool %15 = OpConstantTrue %14 %42 = OpTypePointer Function %14 ; back-edge block is unreachable in the CFG %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %6 %6 = OpLabel OpLoopMerge %8 %7 None OpBranch %8 %7 = OpLabel OpBranch %6 %8 = OpLabel OpReturn OpFunctionEnd ; back-edge block already has an edge to the merge block %9 = OpFunction %2 None %3 %10 = OpLabel OpBranch %11 %11 = OpLabel OpLoopMerge %13 %12 None OpBranch %12 %12 = OpLabel OpBranchConditional %15 %11 %13 %13 = OpLabel OpReturn OpFunctionEnd ; merge block has no OpPhis %16 = OpFunction %2 None %3 %17 = OpLabel OpBranch %18 %18 = OpLabel OpLoopMerge %20 %19 None OpBranchConditional %15 %19 %20 %19 = OpLabel OpBranch %18 %20 = OpLabel OpReturn OpFunctionEnd ; merge block has OpPhis and some of their operands are available at ; the back-edge block %21 = OpFunction %2 None %3 %22 = OpLabel OpBranch %23 %23 = OpLabel %24 = OpCopyObject %14 %15 OpLoopMerge %28 %27 None OpBranchConditional %15 %25 %28 %25 = OpLabel %26 = OpCopyObject %14 %15 OpBranchConditional %15 %28 %27 %27 = OpLabel OpBranch %23 %28 = OpLabel %29 = OpPhi %14 %24 %23 %26 %25 OpReturn OpFunctionEnd ; none of the OpPhis' operands dominate the back-edge block but some of ; them have basic type %30 = OpFunction %2 None %3 %31 = OpLabel OpBranch %32 %32 = OpLabel OpLoopMerge %40 %39 None OpBranch %33 %33 = OpLabel OpSelectionMerge %38 None OpBranchConditional %15 %34 %36 %34 = OpLabel %35 = OpCopyObject %14 %15 OpBranchConditional %35 %38 %40 %36 = OpLabel %37 = OpCopyObject %14 %15 OpBranchConditional %37 %38 %40 %38 = OpLabel OpBranch %39 %39 = OpLabel OpBranch %32 %40 = OpLabel %41 = OpPhi %14 %35 %34 %37 %36 OpReturn OpFunctionEnd ; none of the OpPhis' operands dominate the back-edge block and none of ; them have basic type %43 = OpFunction %2 None %3 %44 = OpLabel %45 = OpVariable %42 Function OpBranch %46 %46 = OpLabel OpLoopMerge %54 %53 None OpBranch %47 %47 = OpLabel OpSelectionMerge %52 None OpBranchConditional %15 %48 %50 %48 = OpLabel %49 = OpCopyObject %42 %45 OpBranchConditional %15 %52 %54 %50 = OpLabel %51 = OpCopyObject %42 %45 OpBranchConditional %15 %52 %54 %52 = OpLabel OpBranch %53 %53 = OpLabel OpBranch %46 %54 = OpLabel %55 = OpPhi %42 %49 %48 %51 %50 OpReturn OpFunctionEnd )"; std::string recipient_shader = R"( ; OpPhis don't support pointers without this capability ; and we need pointers to test some of the functionality OpCapability VariablePointers OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule(env, consumer, recipient_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule(env, consumer, donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); fuzzer_pass.DonateSingleModule(donor_context.get(), true); // We just check that the result is valid. Checking to what it should be // exactly equal to would be very fragile. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/fuzzer_pass_outline_functions_test.cpp000066400000000000000000000512631475742701700304620ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fuzzer_pass_outline_functions.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/pseudo_random_generator.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" OpName %3 "a" OpName %4 "b" OpDecorate %3 RelaxedPrecision OpDecorate %4 RelaxedPrecision OpDecorate %5 RelaxedPrecision OpDecorate %6 RelaxedPrecision OpDecorate %7 RelaxedPrecision OpDecorate %8 RelaxedPrecision OpDecorate %9 RelaxedPrecision %10 = OpTypeVoid %11 = OpTypeFunction %10 %12 = OpTypeInt 32 1 %13 = OpTypePointer Function %12 %14 = OpConstant %12 8 %15 = OpConstant %12 23 %16 = OpTypeBool %17 = OpConstantTrue %16 %18 = OpConstant %12 0 %19 = OpConstant %12 1 %2 = OpFunction %10 None %11 %20 = OpLabel %3 = OpVariable %13 Function %4 = OpVariable %13 Function OpStore %3 %14 OpStore %4 %15 OpBranch %21 %21 = OpLabel OpLoopMerge %22 %23 None OpBranch %24 %24 = OpLabel %25 = OpPhi %12 %19 %21 %18 %26 OpLoopMerge %27 %26 None OpBranch %28 %28 = OpLabel %5 = OpLoad %12 %3 %29 = OpSGreaterThan %16 %5 %18 OpBranchConditional %29 %30 %27 %30 = OpLabel %6 = OpLoad %12 %4 %7 = OpISub %12 %6 %19 OpStore %4 %7 OpBranch %26 %26 = OpLabel %8 = OpLoad %12 %3 %9 = OpISub %12 %8 %19 OpStore %3 %9 OpBranch %24 %27 = OpLabel OpBranch %23 %23 = OpLabel OpBranch %21 %22 = OpLabel OpBranch %31 %31 = OpLabel OpLoopMerge %32 %31 None OpBranchConditional %17 %31 %32 %32 = OpLabel OpSelectionMerge %33 None OpBranchConditional %17 %34 %35 %34 = OpLabel OpBranch %33 %35 = OpLabel OpBranch %33 %33 = OpLabel %42 = OpPhi %12 %19 %33 %18 %34 %18 %35 OpLoopMerge %36 %33 None OpBranchConditional %17 %36 %33 %36 = OpLabel %43 = OpPhi %12 %18 %33 %18 %41 OpReturn %37 = OpLabel OpLoopMerge %38 %39 None OpBranch %40 %40 = OpLabel OpBranchConditional %17 %41 %38 %41 = OpLabel OpBranchConditional %17 %36 %39 %39 = OpLabel OpBranch %37 %38 = OpLabel OpReturn OpFunctionEnd )"; TEST(FuzzerPassOutlineFunctionsTest, EntryIsAlreadySuitable) { const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassOutlineFunctions fuzzer_pass(context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false); // Block 28 auto suitable_entry_block = fuzzer_pass.MaybeGetEntryBlockSuitableForOutlining( context->get_instr_block(28)); ASSERT_TRUE(suitable_entry_block); ASSERT_TRUE(suitable_entry_block->GetLabel()->result_id() == 28); // Block 32 suitable_entry_block = fuzzer_pass.MaybeGetEntryBlockSuitableForOutlining( context->get_instr_block(32)); ASSERT_TRUE(suitable_entry_block); ASSERT_TRUE(suitable_entry_block->GetLabel()->result_id() == 32); // Block 41 suitable_entry_block = fuzzer_pass.MaybeGetEntryBlockSuitableForOutlining( context->get_instr_block(41)); ASSERT_TRUE(suitable_entry_block); ASSERT_TRUE(suitable_entry_block->GetLabel()->result_id() == 41); // The module should not have been changed. ASSERT_TRUE(IsEqual(env, shader, context.get())); } TEST(FuzzerPassOutlineFunctionsTest, EntryHasOpVariable) { const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassOutlineFunctions fuzzer_pass(context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false); // Block 20 auto suitable_entry_block = fuzzer_pass.MaybeGetEntryBlockSuitableForOutlining( context->get_instr_block(20)); // The block should have been split, the new entry block being the block // generated by the splitting. ASSERT_TRUE(suitable_entry_block); ASSERT_TRUE(suitable_entry_block->GetLabel()->result_id() == 100); std::string after_adjustment = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" OpName %3 "a" OpName %4 "b" OpDecorate %3 RelaxedPrecision OpDecorate %4 RelaxedPrecision OpDecorate %5 RelaxedPrecision OpDecorate %6 RelaxedPrecision OpDecorate %7 RelaxedPrecision OpDecorate %8 RelaxedPrecision OpDecorate %9 RelaxedPrecision %10 = OpTypeVoid %11 = OpTypeFunction %10 %12 = OpTypeInt 32 1 %13 = OpTypePointer Function %12 %14 = OpConstant %12 8 %15 = OpConstant %12 23 %16 = OpTypeBool %17 = OpConstantTrue %16 %18 = OpConstant %12 0 %19 = OpConstant %12 1 %2 = OpFunction %10 None %11 %20 = OpLabel %3 = OpVariable %13 Function %4 = OpVariable %13 Function OpBranch %100 %100 = OpLabel OpStore %3 %14 OpStore %4 %15 OpBranch %21 %21 = OpLabel OpLoopMerge %22 %23 None OpBranch %24 %24 = OpLabel %25 = OpPhi %12 %19 %21 %18 %26 OpLoopMerge %27 %26 None OpBranch %28 %28 = OpLabel %5 = OpLoad %12 %3 %29 = OpSGreaterThan %16 %5 %18 OpBranchConditional %29 %30 %27 %30 = OpLabel %6 = OpLoad %12 %4 %7 = OpISub %12 %6 %19 OpStore %4 %7 OpBranch %26 %26 = OpLabel %8 = OpLoad %12 %3 %9 = OpISub %12 %8 %19 OpStore %3 %9 OpBranch %24 %27 = OpLabel OpBranch %23 %23 = OpLabel OpBranch %21 %22 = OpLabel OpBranch %31 %31 = OpLabel OpLoopMerge %32 %31 None OpBranchConditional %17 %31 %32 %32 = OpLabel OpSelectionMerge %33 None OpBranchConditional %17 %34 %35 %34 = OpLabel OpBranch %33 %35 = OpLabel OpBranch %33 %33 = OpLabel %42 = OpPhi %12 %19 %33 %18 %34 %18 %35 OpLoopMerge %36 %33 None OpBranchConditional %17 %36 %33 %36 = OpLabel %43 = OpPhi %12 %18 %33 %18 %41 OpReturn %37 = OpLabel OpLoopMerge %38 %39 None OpBranch %40 %40 = OpLabel OpBranchConditional %17 %41 %38 %41 = OpLabel OpBranchConditional %17 %36 %39 %39 = OpLabel OpBranch %37 %38 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_adjustment, context.get())); } TEST(FuzzerPassOutlineFunctionsTest, EntryBlockIsHeader) { const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassOutlineFunctions fuzzer_pass(context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false); // Block 21 auto suitable_entry_block = fuzzer_pass.MaybeGetEntryBlockSuitableForOutlining( context->get_instr_block(21)); // A suitable entry block should have been found by finding the preheader // (%20) and then splitting it. ASSERT_TRUE(suitable_entry_block); ASSERT_TRUE(suitable_entry_block->GetLabel()->result_id() == 100); // Block 24 suitable_entry_block = fuzzer_pass.MaybeGetEntryBlockSuitableForOutlining( context->get_instr_block(24)); // A preheader should have been created, because the current one is a loop // header. ASSERT_TRUE(suitable_entry_block); ASSERT_TRUE(suitable_entry_block->GetLabel()->result_id() == 101); // Block 31 suitable_entry_block = fuzzer_pass.MaybeGetEntryBlockSuitableForOutlining( context->get_instr_block(31)); // An existing suitable entry block should have been found by finding the // preheader (%22), which is already suitable. ASSERT_TRUE(suitable_entry_block); ASSERT_TRUE(suitable_entry_block->GetLabel()->result_id() == 22); // Block 33 suitable_entry_block = fuzzer_pass.MaybeGetEntryBlockSuitableForOutlining( context->get_instr_block(33)); // An existing suitable entry block should have been found by creating a new // preheader (there is not one already), and then splitting it (as it contains // OpPhi). ASSERT_TRUE(suitable_entry_block); ASSERT_TRUE(suitable_entry_block->GetLabel()->result_id() == 104); // Block 37 suitable_entry_block = fuzzer_pass.MaybeGetEntryBlockSuitableForOutlining( context->get_instr_block(37)); // No suitable entry block can be found for block 37, since it is a loop // header with only one predecessor (the back-edge block). ASSERT_FALSE(suitable_entry_block); std::string after_adjustments = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" OpName %3 "a" OpName %4 "b" OpDecorate %3 RelaxedPrecision OpDecorate %4 RelaxedPrecision OpDecorate %5 RelaxedPrecision OpDecorate %6 RelaxedPrecision OpDecorate %7 RelaxedPrecision OpDecorate %8 RelaxedPrecision OpDecorate %9 RelaxedPrecision %10 = OpTypeVoid %11 = OpTypeFunction %10 %12 = OpTypeInt 32 1 %13 = OpTypePointer Function %12 %14 = OpConstant %12 8 %15 = OpConstant %12 23 %16 = OpTypeBool %17 = OpConstantTrue %16 %18 = OpConstant %12 0 %19 = OpConstant %12 1 %2 = OpFunction %10 None %11 %20 = OpLabel %3 = OpVariable %13 Function %4 = OpVariable %13 Function OpBranch %100 %100 = OpLabel OpStore %3 %14 OpStore %4 %15 OpBranch %21 %21 = OpLabel OpLoopMerge %22 %23 None OpBranch %101 %101 = OpLabel OpBranch %24 %24 = OpLabel %25 = OpPhi %12 %19 %101 %18 %26 OpLoopMerge %27 %26 None OpBranch %28 %28 = OpLabel %5 = OpLoad %12 %3 %29 = OpSGreaterThan %16 %5 %18 OpBranchConditional %29 %30 %27 %30 = OpLabel %6 = OpLoad %12 %4 %7 = OpISub %12 %6 %19 OpStore %4 %7 OpBranch %26 %26 = OpLabel %8 = OpLoad %12 %3 %9 = OpISub %12 %8 %19 OpStore %3 %9 OpBranch %24 %27 = OpLabel OpBranch %23 %23 = OpLabel OpBranch %21 %22 = OpLabel OpBranch %31 %31 = OpLabel OpLoopMerge %32 %31 None OpBranchConditional %17 %31 %32 %32 = OpLabel OpSelectionMerge %102 None OpBranchConditional %17 %34 %35 %34 = OpLabel OpBranch %102 %35 = OpLabel OpBranch %102 %102 = OpLabel %103 = OpPhi %12 %18 %34 %18 %35 OpBranch %104 %104 = OpLabel OpBranch %33 %33 = OpLabel %42 = OpPhi %12 %103 %104 %19 %33 OpLoopMerge %36 %33 None OpBranchConditional %17 %36 %33 %36 = OpLabel %43 = OpPhi %12 %18 %33 %18 %41 OpReturn %37 = OpLabel OpLoopMerge %38 %39 None OpBranch %40 %40 = OpLabel OpBranchConditional %17 %41 %38 %41 = OpLabel OpBranchConditional %17 %36 %39 %39 = OpLabel OpBranch %37 %38 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_adjustments, context.get())); } TEST(FuzzerPassOutlineFunctionsTest, ExitBlock) { const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassOutlineFunctions fuzzer_pass(context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false); // Block 39 is not a merge block, so it is already suitable. auto suitable_exit_block = fuzzer_pass.MaybeGetExitBlockSuitableForOutlining( context->get_instr_block(39)); ASSERT_TRUE(suitable_exit_block); ASSERT_TRUE(suitable_exit_block->GetLabel()->result_id() == 39); // The following are merge blocks and, thus, they will need to be split. // Block 22 suitable_exit_block = fuzzer_pass.MaybeGetExitBlockSuitableForOutlining( context->get_instr_block(22)); ASSERT_TRUE(suitable_exit_block); ASSERT_TRUE(suitable_exit_block->GetLabel()->result_id() == 100); // Block 27 suitable_exit_block = fuzzer_pass.MaybeGetExitBlockSuitableForOutlining( context->get_instr_block(27)); ASSERT_TRUE(suitable_exit_block); ASSERT_TRUE(suitable_exit_block->GetLabel()->result_id() == 101); // Block 36 suitable_exit_block = fuzzer_pass.MaybeGetExitBlockSuitableForOutlining( context->get_instr_block(36)); ASSERT_TRUE(suitable_exit_block); ASSERT_TRUE(suitable_exit_block->GetLabel()->result_id() == 102); std::string after_adjustments = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" OpName %3 "a" OpName %4 "b" OpDecorate %3 RelaxedPrecision OpDecorate %4 RelaxedPrecision OpDecorate %5 RelaxedPrecision OpDecorate %6 RelaxedPrecision OpDecorate %7 RelaxedPrecision OpDecorate %8 RelaxedPrecision OpDecorate %9 RelaxedPrecision %10 = OpTypeVoid %11 = OpTypeFunction %10 %12 = OpTypeInt 32 1 %13 = OpTypePointer Function %12 %14 = OpConstant %12 8 %15 = OpConstant %12 23 %16 = OpTypeBool %17 = OpConstantTrue %16 %18 = OpConstant %12 0 %19 = OpConstant %12 1 %2 = OpFunction %10 None %11 %20 = OpLabel %3 = OpVariable %13 Function %4 = OpVariable %13 Function OpStore %3 %14 OpStore %4 %15 OpBranch %21 %21 = OpLabel OpLoopMerge %22 %23 None OpBranch %24 %24 = OpLabel %25 = OpPhi %12 %19 %21 %18 %26 OpLoopMerge %27 %26 None OpBranch %28 %28 = OpLabel %5 = OpLoad %12 %3 %29 = OpSGreaterThan %16 %5 %18 OpBranchConditional %29 %30 %27 %30 = OpLabel %6 = OpLoad %12 %4 %7 = OpISub %12 %6 %19 OpStore %4 %7 OpBranch %26 %26 = OpLabel %8 = OpLoad %12 %3 %9 = OpISub %12 %8 %19 OpStore %3 %9 OpBranch %24 %27 = OpLabel OpBranch %101 %101 = OpLabel OpBranch %23 %23 = OpLabel OpBranch %21 %22 = OpLabel OpBranch %100 %100 = OpLabel OpBranch %31 %31 = OpLabel OpLoopMerge %32 %31 None OpBranchConditional %17 %31 %32 %32 = OpLabel OpSelectionMerge %33 None OpBranchConditional %17 %34 %35 %34 = OpLabel OpBranch %33 %35 = OpLabel OpBranch %33 %33 = OpLabel %42 = OpPhi %12 %19 %33 %18 %34 %18 %35 OpLoopMerge %36 %33 None OpBranchConditional %17 %36 %33 %36 = OpLabel %43 = OpPhi %12 %18 %33 %18 %41 OpBranch %102 %102 = OpLabel OpReturn %37 = OpLabel OpLoopMerge %38 %39 None OpBranch %40 %40 = OpLabel OpBranchConditional %17 %41 %38 %41 = OpLabel OpBranchConditional %17 %36 %39 %39 = OpLabel OpBranch %37 %38 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_adjustments, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/fuzzer_pass_test.cpp000066400000000000000000000072761475742701700246400ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "gtest/gtest.h" #include "source/fuzz/fuzzer_pass_add_opphi_synonyms.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/pseudo_random_generator.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { class FuzzerPassMock : public FuzzerPass { public: FuzzerPassMock(opt::IRContext* ir_context, TransformationContext* transformation_context, FuzzerContext* fuzzer_context, protobufs::TransformationSequence* transformations) : FuzzerPass(ir_context, transformation_context, fuzzer_context, transformations, false) {} ~FuzzerPassMock() override = default; const std::unordered_set& GetReachedInstructions() const { return reached_ids_; } void Apply() override { ForEachInstructionWithInstructionDescriptor( [this](opt::Function* /*unused*/, opt::BasicBlock* /*unused*/, opt::BasicBlock::iterator inst_it, const protobufs::InstructionDescriptor& /*unused*/) { if (inst_it->result_id()) { reached_ids_.insert(inst_it->result_id()); } }); } private: std::unordered_set reached_ids_; }; TEST(FuzzerPassTest, ForEachInstructionWithInstructionDescriptor) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %4 = OpFunction %2 None %3 %5 = OpLabel %7 = OpUndef %6 OpReturn %8 = OpLabel %9 = OpUndef %6 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Check that %5 is reachable and %8 is unreachable as expected. const auto* dominator_analysis = context->GetDominatorAnalysis(context->GetFunction(4)); ASSERT_TRUE(dominator_analysis->IsReachable(5)); ASSERT_FALSE(dominator_analysis->IsReachable(8)); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformations; FuzzerPassMock fuzzer_pass_mock(context.get(), &transformation_context, &fuzzer_context, &transformations); fuzzer_pass_mock.Apply(); ASSERT_TRUE(fuzzer_pass_mock.GetReachedInstructions().count(7)); ASSERT_FALSE(fuzzer_pass_mock.GetReachedInstructions().count(9)); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/fuzzer_replayer_test.cpp000066400000000000000000001706071475742701700255140ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "gtest/gtest.h" #include "source/fuzz/fuzzer.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/pseudo_random_generator.h" #include "source/fuzz/replayer.h" #include "source/fuzz/uniform_buffer_element_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { const uint32_t kNumFuzzerRuns = 20; // The SPIR-V came from this GLSL: // // #version 310 es // // void foo() { // int x; // x = 2; // for (int i = 0; i < 100; i++) { // x += i; // x = x * 2; // } // return; // } // // void main() { // foo(); // for (int i = 0; i < 10; i++) { // int j = 20; // while(j > 0) { // foo(); // j--; // } // do { // i++; // } while(i < 4); // } // } const std::string kTestShader1 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %6 "foo(" OpName %10 "x" OpName %12 "i" OpName %33 "i" OpName %42 "j" OpDecorate %10 RelaxedPrecision OpDecorate %12 RelaxedPrecision OpDecorate %19 RelaxedPrecision OpDecorate %23 RelaxedPrecision OpDecorate %24 RelaxedPrecision OpDecorate %25 RelaxedPrecision OpDecorate %26 RelaxedPrecision OpDecorate %27 RelaxedPrecision OpDecorate %28 RelaxedPrecision OpDecorate %30 RelaxedPrecision OpDecorate %33 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %49 RelaxedPrecision OpDecorate %52 RelaxedPrecision OpDecorate %53 RelaxedPrecision OpDecorate %58 RelaxedPrecision OpDecorate %59 RelaxedPrecision OpDecorate %60 RelaxedPrecision OpDecorate %63 RelaxedPrecision OpDecorate %64 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %11 = OpConstant %8 2 %13 = OpConstant %8 0 %20 = OpConstant %8 100 %21 = OpTypeBool %29 = OpConstant %8 1 %40 = OpConstant %8 10 %43 = OpConstant %8 20 %61 = OpConstant %8 4 %4 = OpFunction %2 None %3 %5 = OpLabel %33 = OpVariable %9 Function %42 = OpVariable %9 Function %32 = OpFunctionCall %2 %6 OpStore %33 %13 OpBranch %34 %34 = OpLabel OpLoopMerge %36 %37 None OpBranch %38 %38 = OpLabel %39 = OpLoad %8 %33 %41 = OpSLessThan %21 %39 %40 OpBranchConditional %41 %35 %36 %35 = OpLabel OpStore %42 %43 OpBranch %44 %44 = OpLabel OpLoopMerge %46 %47 None OpBranch %48 %48 = OpLabel %49 = OpLoad %8 %42 %50 = OpSGreaterThan %21 %49 %13 OpBranchConditional %50 %45 %46 %45 = OpLabel %51 = OpFunctionCall %2 %6 %52 = OpLoad %8 %42 %53 = OpISub %8 %52 %29 OpStore %42 %53 OpBranch %47 %47 = OpLabel OpBranch %44 %46 = OpLabel OpBranch %54 %54 = OpLabel OpLoopMerge %56 %57 None OpBranch %55 %55 = OpLabel %58 = OpLoad %8 %33 %59 = OpIAdd %8 %58 %29 OpStore %33 %59 OpBranch %57 %57 = OpLabel %60 = OpLoad %8 %33 %62 = OpSLessThan %21 %60 %61 OpBranchConditional %62 %54 %56 %56 = OpLabel OpBranch %37 %37 = OpLabel %63 = OpLoad %8 %33 %64 = OpIAdd %8 %63 %29 OpStore %33 %64 OpBranch %34 %36 = OpLabel OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %10 = OpVariable %9 Function %12 = OpVariable %9 Function OpStore %10 %11 OpStore %12 %13 OpBranch %14 %14 = OpLabel OpLoopMerge %16 %17 None OpBranch %18 %18 = OpLabel %19 = OpLoad %8 %12 %22 = OpSLessThan %21 %19 %20 OpBranchConditional %22 %15 %16 %15 = OpLabel %23 = OpLoad %8 %12 %24 = OpLoad %8 %10 %25 = OpIAdd %8 %24 %23 OpStore %10 %25 %26 = OpLoad %8 %10 %27 = OpIMul %8 %26 %11 OpStore %10 %27 OpBranch %17 %17 = OpLabel %28 = OpLoad %8 %12 %30 = OpIAdd %8 %28 %29 OpStore %12 %30 OpBranch %14 %16 = OpLabel OpReturn OpFunctionEnd )"; // The SPIR-V came from this GLSL, which was then optimized using spirv-opt // with the -O argument: // // #version 310 es // // precision highp float; // // layout(location = 0) out vec4 _GLF_color; // // layout(set = 0, binding = 0) uniform buf0 { // vec2 injectionSwitch; // }; // layout(set = 0, binding = 1) uniform buf1 { // vec2 resolution; // }; // bool checkSwap(float a, float b) // { // return gl_FragCoord.y < resolution.y / 2.0 ? a > b : a < b; // } // void main() // { // float data[10]; // for(int i = 0; i < 10; i++) // { // data[i] = float(10 - i) * injectionSwitch.y; // } // for(int i = 0; i < 9; i++) // { // for(int j = 0; j < 10; j++) // { // if(j < i + 1) // { // continue; // } // bool doSwap = checkSwap(data[i], data[j]); // if(doSwap) // { // float temp = data[i]; // data[i] = data[j]; // data[j] = temp; // } // } // } // if(gl_FragCoord.x < resolution.x / 2.0) // { // _GLF_color = vec4(data[0] / 10.0, data[5] / 10.0, data[9] / 10.0, 1.0); // } // else // { // _GLF_color = vec4(data[5] / 10.0, data[9] / 10.0, data[0] / 10.0, 1.0); // } // } const std::string kTestShader2 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %16 %139 %25 %68 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %16 "gl_FragCoord" OpName %23 "buf1" OpMemberName %23 0 "resolution" OpName %25 "" OpName %61 "data" OpName %66 "buf0" OpMemberName %66 0 "injectionSwitch" OpName %68 "" OpName %139 "_GLF_color" OpDecorate %16 BuiltIn FragCoord OpMemberDecorate %23 0 Offset 0 OpDecorate %23 Block OpDecorate %25 DescriptorSet 0 OpDecorate %25 Binding 1 OpDecorate %64 RelaxedPrecision OpMemberDecorate %66 0 Offset 0 OpDecorate %66 Block OpDecorate %68 DescriptorSet 0 OpDecorate %68 Binding 0 OpDecorate %75 RelaxedPrecision OpDecorate %95 RelaxedPrecision OpDecorate %126 RelaxedPrecision OpDecorate %128 RelaxedPrecision OpDecorate %139 Location 0 OpDecorate %182 RelaxedPrecision OpDecorate %183 RelaxedPrecision OpDecorate %184 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %8 = OpTypeBool %14 = OpTypeVector %6 4 %15 = OpTypePointer Input %14 %16 = OpVariable %15 Input %17 = OpTypeInt 32 0 %18 = OpConstant %17 1 %19 = OpTypePointer Input %6 %22 = OpTypeVector %6 2 %23 = OpTypeStruct %22 %24 = OpTypePointer Uniform %23 %25 = OpVariable %24 Uniform %26 = OpTypeInt 32 1 %27 = OpConstant %26 0 %28 = OpTypePointer Uniform %6 %56 = OpConstant %26 10 %58 = OpConstant %17 10 %59 = OpTypeArray %6 %58 %60 = OpTypePointer Function %59 %66 = OpTypeStruct %22 %67 = OpTypePointer Uniform %66 %68 = OpVariable %67 Uniform %74 = OpConstant %26 1 %83 = OpConstant %26 9 %129 = OpConstant %17 0 %138 = OpTypePointer Output %14 %139 = OpVariable %138 Output %144 = OpConstant %26 5 %151 = OpConstant %6 1 %194 = OpConstant %6 0.5 %195 = OpConstant %6 0.100000001 %4 = OpFunction %2 None %3 %5 = OpLabel %61 = OpVariable %60 Function OpBranch %50 %50 = OpLabel %182 = OpPhi %26 %27 %5 %75 %51 %57 = OpSLessThan %8 %182 %56 OpLoopMerge %52 %51 None OpBranchConditional %57 %51 %52 %51 = OpLabel %64 = OpISub %26 %56 %182 %65 = OpConvertSToF %6 %64 %69 = OpAccessChain %28 %68 %27 %18 %70 = OpLoad %6 %69 %71 = OpFMul %6 %65 %70 %72 = OpAccessChain %7 %61 %182 OpStore %72 %71 %75 = OpIAdd %26 %182 %74 OpBranch %50 %52 = OpLabel OpBranch %77 %77 = OpLabel %183 = OpPhi %26 %27 %52 %128 %88 %84 = OpSLessThan %8 %183 %83 OpLoopMerge %79 %88 None OpBranchConditional %84 %78 %79 %78 = OpLabel OpBranch %86 %86 = OpLabel %184 = OpPhi %26 %27 %78 %126 %89 %92 = OpSLessThan %8 %184 %56 OpLoopMerge %1000 %89 None OpBranchConditional %92 %87 %1000 %87 = OpLabel %95 = OpIAdd %26 %183 %74 %96 = OpSLessThan %8 %184 %95 OpSelectionMerge %98 None OpBranchConditional %96 %97 %98 %97 = OpLabel OpBranch %89 %98 = OpLabel %104 = OpAccessChain %7 %61 %183 %105 = OpLoad %6 %104 %107 = OpAccessChain %7 %61 %184 %108 = OpLoad %6 %107 %166 = OpAccessChain %19 %16 %18 %167 = OpLoad %6 %166 %168 = OpAccessChain %28 %25 %27 %18 %169 = OpLoad %6 %168 %170 = OpFMul %6 %169 %194 %171 = OpFOrdLessThan %8 %167 %170 OpSelectionMerge %172 None OpBranchConditional %171 %173 %174 %173 = OpLabel %177 = OpFOrdGreaterThan %8 %105 %108 OpBranch %172 %174 = OpLabel %180 = OpFOrdLessThan %8 %105 %108 OpBranch %172 %172 = OpLabel %186 = OpPhi %8 %177 %173 %180 %174 OpSelectionMerge %112 None OpBranchConditional %186 %111 %112 %111 = OpLabel %116 = OpLoad %6 %104 %120 = OpLoad %6 %107 OpStore %104 %120 OpStore %107 %116 OpBranch %112 %112 = OpLabel OpBranch %89 %89 = OpLabel %126 = OpIAdd %26 %184 %74 OpBranch %86 %1000 = OpLabel OpBranch %88 %88 = OpLabel %128 = OpIAdd %26 %183 %74 OpBranch %77 %79 = OpLabel %130 = OpAccessChain %19 %16 %129 %131 = OpLoad %6 %130 %132 = OpAccessChain %28 %25 %27 %129 %133 = OpLoad %6 %132 %134 = OpFMul %6 %133 %194 %135 = OpFOrdLessThan %8 %131 %134 OpSelectionMerge %137 None OpBranchConditional %135 %136 %153 %136 = OpLabel %140 = OpAccessChain %7 %61 %27 %141 = OpLoad %6 %140 %143 = OpFMul %6 %141 %195 %145 = OpAccessChain %7 %61 %144 %146 = OpLoad %6 %145 %147 = OpFMul %6 %146 %195 %148 = OpAccessChain %7 %61 %83 %149 = OpLoad %6 %148 %150 = OpFMul %6 %149 %195 %152 = OpCompositeConstruct %14 %143 %147 %150 %151 OpStore %139 %152 OpBranch %137 %153 = OpLabel %154 = OpAccessChain %7 %61 %144 %155 = OpLoad %6 %154 %156 = OpFMul %6 %155 %195 %157 = OpAccessChain %7 %61 %83 %158 = OpLoad %6 %157 %159 = OpFMul %6 %158 %195 %160 = OpAccessChain %7 %61 %27 %161 = OpLoad %6 %160 %162 = OpFMul %6 %161 %195 %163 = OpCompositeConstruct %14 %156 %159 %162 %151 OpStore %139 %163 OpBranch %137 %137 = OpLabel OpReturn OpFunctionEnd )"; // The SPIR-V came from this GLSL, which was then optimized using spirv-opt // with the -O argument: // // #version 310 es // // precision highp float; // // layout(location = 0) out vec4 _GLF_color; // // layout(set = 0, binding = 0) uniform buf0 { // vec2 resolution; // }; // void main(void) // { // float A[50]; // for( // int i = 0; // i < 200; // i ++ // ) // { // if(i >= int(resolution.x)) // { // break; // } // if((4 * (i / 4)) == i) // { // A[i / 4] = float(i); // } // } // for( // int i = 0; // i < 50; // i ++ // ) // { // if(i < int(gl_FragCoord.x)) // { // break; // } // if(i > 0) // { // A[i] += A[i - 1]; // } // } // if(int(gl_FragCoord.x) < 20) // { // _GLF_color = vec4(A[0] / resolution.x, A[4] / resolution.y, 1.0, 1.0); // } // else // if(int(gl_FragCoord.x) < 40) // { // _GLF_color = vec4(A[5] / resolution.x, A[9] / resolution.y, 1.0, 1.0); // } // else // if(int(gl_FragCoord.x) < 60) // { // _GLF_color = vec4(A[10] / resolution.x, A[14] / resolution.y, // 1.0, 1.0); // } // else // if(int(gl_FragCoord.x) < 80) // { // _GLF_color = vec4(A[15] / resolution.x, A[19] / resolution.y, // 1.0, 1.0); // } // else // if(int(gl_FragCoord.x) < 100) // { // _GLF_color = vec4(A[20] / resolution.x, A[24] / resolution.y, // 1.0, 1.0); // } // else // if(int(gl_FragCoord.x) < 120) // { // _GLF_color = vec4(A[25] / resolution.x, A[29] / resolution.y, // 1.0, 1.0); // } // else // if(int(gl_FragCoord.x) < 140) // { // _GLF_color = vec4(A[30] / resolution.x, A[34] / resolution.y, // 1.0, 1.0); // } // else // if(int(gl_FragCoord.x) < 160) // { // _GLF_color = vec4(A[35] / resolution.x, A[39] / // resolution.y, 1.0, 1.0); // } // else // if(int(gl_FragCoord.x) < 180) // { // _GLF_color = vec4(A[40] / resolution.x, A[44] / // resolution.y, 1.0, 1.0); // } // else // if(int(gl_FragCoord.x) < 180) // { // _GLF_color = vec4(A[45] / resolution.x, A[49] / // resolution.y, 1.0, 1.0); // } // else // { // discard; // } // } const std::string kTestShader3 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %68 %100 %24 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %22 "buf0" OpMemberName %22 0 "resolution" OpName %24 "" OpName %46 "A" OpName %68 "gl_FragCoord" OpName %100 "_GLF_color" OpMemberDecorate %22 0 Offset 0 OpDecorate %22 Block OpDecorate %24 DescriptorSet 0 OpDecorate %24 Binding 0 OpDecorate %37 RelaxedPrecision OpDecorate %38 RelaxedPrecision OpDecorate %55 RelaxedPrecision OpDecorate %68 BuiltIn FragCoord OpDecorate %83 RelaxedPrecision OpDecorate %91 RelaxedPrecision OpDecorate %100 Location 0 OpDecorate %302 RelaxedPrecision OpDecorate %304 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %9 = OpConstant %6 0 %16 = OpConstant %6 200 %17 = OpTypeBool %20 = OpTypeFloat 32 %21 = OpTypeVector %20 2 %22 = OpTypeStruct %21 %23 = OpTypePointer Uniform %22 %24 = OpVariable %23 Uniform %25 = OpTypeInt 32 0 %26 = OpConstant %25 0 %27 = OpTypePointer Uniform %20 %35 = OpConstant %6 4 %43 = OpConstant %25 50 %44 = OpTypeArray %20 %43 %45 = OpTypePointer Function %44 %51 = OpTypePointer Function %20 %54 = OpConstant %6 1 %63 = OpConstant %6 50 %66 = OpTypeVector %20 4 %67 = OpTypePointer Input %66 %68 = OpVariable %67 Input %69 = OpTypePointer Input %20 %95 = OpConstant %6 20 %99 = OpTypePointer Output %66 %100 = OpVariable %99 Output %108 = OpConstant %25 1 %112 = OpConstant %20 1 %118 = OpConstant %6 40 %122 = OpConstant %6 5 %128 = OpConstant %6 9 %139 = OpConstant %6 60 %143 = OpConstant %6 10 %149 = OpConstant %6 14 %160 = OpConstant %6 80 %164 = OpConstant %6 15 %170 = OpConstant %6 19 %181 = OpConstant %6 100 %190 = OpConstant %6 24 %201 = OpConstant %6 120 %205 = OpConstant %6 25 %211 = OpConstant %6 29 %222 = OpConstant %6 140 %226 = OpConstant %6 30 %232 = OpConstant %6 34 %243 = OpConstant %6 160 %247 = OpConstant %6 35 %253 = OpConstant %6 39 %264 = OpConstant %6 180 %273 = OpConstant %6 44 %287 = OpConstant %6 45 %293 = OpConstant %6 49 %4 = OpFunction %2 None %3 %5 = OpLabel %46 = OpVariable %45 Function OpBranch %10 %10 = OpLabel %302 = OpPhi %6 %9 %5 %55 %42 %18 = OpSLessThan %17 %302 %16 OpLoopMerge %12 %42 None OpBranchConditional %18 %11 %12 %11 = OpLabel %28 = OpAccessChain %27 %24 %9 %26 %29 = OpLoad %20 %28 %30 = OpConvertFToS %6 %29 %31 = OpSGreaterThanEqual %17 %302 %30 OpSelectionMerge %33 None OpBranchConditional %31 %32 %33 %32 = OpLabel OpBranch %12 %33 = OpLabel %37 = OpSDiv %6 %302 %35 %38 = OpIMul %6 %35 %37 %40 = OpIEqual %17 %38 %302 OpBranchConditional %40 %41 %42 %41 = OpLabel %50 = OpConvertSToF %20 %302 %52 = OpAccessChain %51 %46 %37 OpStore %52 %50 OpBranch %42 %42 = OpLabel %55 = OpIAdd %6 %302 %54 OpBranch %10 %12 = OpLabel OpBranch %57 %57 = OpLabel %304 = OpPhi %6 %9 %12 %91 %80 %64 = OpSLessThan %17 %304 %63 OpLoopMerge %59 %80 None OpBranchConditional %64 %58 %59 %58 = OpLabel %70 = OpAccessChain %69 %68 %26 %71 = OpLoad %20 %70 %72 = OpConvertFToS %6 %71 %73 = OpSLessThan %17 %304 %72 OpSelectionMerge %75 None OpBranchConditional %73 %74 %75 %74 = OpLabel OpBranch %59 %75 = OpLabel %78 = OpSGreaterThan %17 %304 %9 OpBranchConditional %78 %79 %80 %79 = OpLabel %83 = OpISub %6 %304 %54 %84 = OpAccessChain %51 %46 %83 %85 = OpLoad %20 %84 %86 = OpAccessChain %51 %46 %304 %87 = OpLoad %20 %86 %88 = OpFAdd %20 %87 %85 OpStore %86 %88 OpBranch %80 %80 = OpLabel %91 = OpIAdd %6 %304 %54 OpBranch %57 %59 = OpLabel %92 = OpAccessChain %69 %68 %26 %93 = OpLoad %20 %92 %94 = OpConvertFToS %6 %93 %96 = OpSLessThan %17 %94 %95 OpSelectionMerge %98 None OpBranchConditional %96 %97 %114 %97 = OpLabel %101 = OpAccessChain %51 %46 %9 %102 = OpLoad %20 %101 %103 = OpAccessChain %27 %24 %9 %26 %104 = OpLoad %20 %103 %105 = OpFDiv %20 %102 %104 %106 = OpAccessChain %51 %46 %35 %107 = OpLoad %20 %106 %109 = OpAccessChain %27 %24 %9 %108 %110 = OpLoad %20 %109 %111 = OpFDiv %20 %107 %110 %113 = OpCompositeConstruct %66 %105 %111 %112 %112 OpStore %100 %113 OpBranch %98 %114 = OpLabel %119 = OpSLessThan %17 %94 %118 OpSelectionMerge %121 None OpBranchConditional %119 %120 %135 %120 = OpLabel %123 = OpAccessChain %51 %46 %122 %124 = OpLoad %20 %123 %125 = OpAccessChain %27 %24 %9 %26 %126 = OpLoad %20 %125 %127 = OpFDiv %20 %124 %126 %129 = OpAccessChain %51 %46 %128 %130 = OpLoad %20 %129 %131 = OpAccessChain %27 %24 %9 %108 %132 = OpLoad %20 %131 %133 = OpFDiv %20 %130 %132 %134 = OpCompositeConstruct %66 %127 %133 %112 %112 OpStore %100 %134 OpBranch %121 %135 = OpLabel %140 = OpSLessThan %17 %94 %139 OpSelectionMerge %142 None OpBranchConditional %140 %141 %156 %141 = OpLabel %144 = OpAccessChain %51 %46 %143 %145 = OpLoad %20 %144 %146 = OpAccessChain %27 %24 %9 %26 %147 = OpLoad %20 %146 %148 = OpFDiv %20 %145 %147 %150 = OpAccessChain %51 %46 %149 %151 = OpLoad %20 %150 %152 = OpAccessChain %27 %24 %9 %108 %153 = OpLoad %20 %152 %154 = OpFDiv %20 %151 %153 %155 = OpCompositeConstruct %66 %148 %154 %112 %112 OpStore %100 %155 OpBranch %142 %156 = OpLabel %161 = OpSLessThan %17 %94 %160 OpSelectionMerge %163 None OpBranchConditional %161 %162 %177 %162 = OpLabel %165 = OpAccessChain %51 %46 %164 %166 = OpLoad %20 %165 %167 = OpAccessChain %27 %24 %9 %26 %168 = OpLoad %20 %167 %169 = OpFDiv %20 %166 %168 %171 = OpAccessChain %51 %46 %170 %172 = OpLoad %20 %171 %173 = OpAccessChain %27 %24 %9 %108 %174 = OpLoad %20 %173 %175 = OpFDiv %20 %172 %174 %176 = OpCompositeConstruct %66 %169 %175 %112 %112 OpStore %100 %176 OpBranch %163 %177 = OpLabel %182 = OpSLessThan %17 %94 %181 OpSelectionMerge %184 None OpBranchConditional %182 %183 %197 %183 = OpLabel %185 = OpAccessChain %51 %46 %95 %186 = OpLoad %20 %185 %187 = OpAccessChain %27 %24 %9 %26 %188 = OpLoad %20 %187 %189 = OpFDiv %20 %186 %188 %191 = OpAccessChain %51 %46 %190 %192 = OpLoad %20 %191 %193 = OpAccessChain %27 %24 %9 %108 %194 = OpLoad %20 %193 %195 = OpFDiv %20 %192 %194 %196 = OpCompositeConstruct %66 %189 %195 %112 %112 OpStore %100 %196 OpBranch %184 %197 = OpLabel %202 = OpSLessThan %17 %94 %201 OpSelectionMerge %204 None OpBranchConditional %202 %203 %218 %203 = OpLabel %206 = OpAccessChain %51 %46 %205 %207 = OpLoad %20 %206 %208 = OpAccessChain %27 %24 %9 %26 %209 = OpLoad %20 %208 %210 = OpFDiv %20 %207 %209 %212 = OpAccessChain %51 %46 %211 %213 = OpLoad %20 %212 %214 = OpAccessChain %27 %24 %9 %108 %215 = OpLoad %20 %214 %216 = OpFDiv %20 %213 %215 %217 = OpCompositeConstruct %66 %210 %216 %112 %112 OpStore %100 %217 OpBranch %204 %218 = OpLabel %223 = OpSLessThan %17 %94 %222 OpSelectionMerge %225 None OpBranchConditional %223 %224 %239 %224 = OpLabel %227 = OpAccessChain %51 %46 %226 %228 = OpLoad %20 %227 %229 = OpAccessChain %27 %24 %9 %26 %230 = OpLoad %20 %229 %231 = OpFDiv %20 %228 %230 %233 = OpAccessChain %51 %46 %232 %234 = OpLoad %20 %233 %235 = OpAccessChain %27 %24 %9 %108 %236 = OpLoad %20 %235 %237 = OpFDiv %20 %234 %236 %238 = OpCompositeConstruct %66 %231 %237 %112 %112 OpStore %100 %238 OpBranch %225 %239 = OpLabel %244 = OpSLessThan %17 %94 %243 OpSelectionMerge %246 None OpBranchConditional %244 %245 %260 %245 = OpLabel %248 = OpAccessChain %51 %46 %247 %249 = OpLoad %20 %248 %250 = OpAccessChain %27 %24 %9 %26 %251 = OpLoad %20 %250 %252 = OpFDiv %20 %249 %251 %254 = OpAccessChain %51 %46 %253 %255 = OpLoad %20 %254 %256 = OpAccessChain %27 %24 %9 %108 %257 = OpLoad %20 %256 %258 = OpFDiv %20 %255 %257 %259 = OpCompositeConstruct %66 %252 %258 %112 %112 OpStore %100 %259 OpBranch %246 %260 = OpLabel %265 = OpSLessThan %17 %94 %264 OpSelectionMerge %267 None OpBranchConditional %265 %266 %280 %266 = OpLabel %268 = OpAccessChain %51 %46 %118 %269 = OpLoad %20 %268 %270 = OpAccessChain %27 %24 %9 %26 %271 = OpLoad %20 %270 %272 = OpFDiv %20 %269 %271 %274 = OpAccessChain %51 %46 %273 %275 = OpLoad %20 %274 %276 = OpAccessChain %27 %24 %9 %108 %277 = OpLoad %20 %276 %278 = OpFDiv %20 %275 %277 %279 = OpCompositeConstruct %66 %272 %278 %112 %112 OpStore %100 %279 OpBranch %267 %280 = OpLabel OpSelectionMerge %285 None OpBranchConditional %265 %285 %300 %285 = OpLabel %288 = OpAccessChain %51 %46 %287 %289 = OpLoad %20 %288 %290 = OpAccessChain %27 %24 %9 %26 %291 = OpLoad %20 %290 %292 = OpFDiv %20 %289 %291 %294 = OpAccessChain %51 %46 %293 %295 = OpLoad %20 %294 %296 = OpAccessChain %27 %24 %9 %108 %297 = OpLoad %20 %296 %298 = OpFDiv %20 %295 %297 %299 = OpCompositeConstruct %66 %292 %298 %112 %112 OpStore %100 %299 OpBranch %267 %300 = OpLabel OpKill %267 = OpLabel OpBranch %246 %246 = OpLabel OpBranch %225 %225 = OpLabel OpBranch %204 %204 = OpLabel OpBranch %184 %184 = OpLabel OpBranch %163 %163 = OpLabel OpBranch %142 %142 = OpLabel OpBranch %121 %121 = OpLabel OpBranch %98 %98 = OpLabel OpReturn OpFunctionEnd )"; // The SPIR-V comes from the 'matrices_smart_loops' GLSL shader that ships // with GraphicsFuzz. const std::string kTestShader4 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %327 %363 %65 %70 %80 %90 %99 %108 %117 %126 %135 %144 %333 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "matrix_number" OpName %12 "cols" OpName %23 "rows" OpName %31 "c" OpName %41 "r" OpName %65 "m22" OpName %68 "buf0" OpMemberName %68 0 "one" OpName %70 "" OpName %80 "m23" OpName %90 "m24" OpName %99 "m32" OpName %108 "m33" OpName %117 "m34" OpName %126 "m42" OpName %135 "m43" OpName %144 "m44" OpName %164 "sum_index" OpName %165 "cols" OpName %173 "rows" OpName %184 "sums" OpName %189 "c" OpName %198 "r" OpName %325 "region_x" OpName %327 "gl_FragCoord" OpName %331 "buf1" OpMemberName %331 0 "resolution" OpName %333 "" OpName %340 "region_y" OpName %348 "overall_region" OpName %363 "_GLF_color" OpDecorate %8 RelaxedPrecision OpDecorate %12 RelaxedPrecision OpDecorate %19 RelaxedPrecision OpDecorate %23 RelaxedPrecision OpDecorate %29 RelaxedPrecision OpDecorate %31 RelaxedPrecision OpDecorate %38 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %41 RelaxedPrecision OpDecorate %47 RelaxedPrecision OpDecorate %48 RelaxedPrecision OpDecorate %50 RelaxedPrecision OpDecorate %66 RelaxedPrecision OpDecorate %67 RelaxedPrecision OpMemberDecorate %68 0 Offset 0 OpDecorate %68 Block OpDecorate %70 DescriptorSet 0 OpDecorate %70 Binding 0 OpDecorate %81 RelaxedPrecision OpDecorate %82 RelaxedPrecision OpDecorate %91 RelaxedPrecision OpDecorate %92 RelaxedPrecision OpDecorate %100 RelaxedPrecision OpDecorate %101 RelaxedPrecision OpDecorate %109 RelaxedPrecision OpDecorate %110 RelaxedPrecision OpDecorate %118 RelaxedPrecision OpDecorate %119 RelaxedPrecision OpDecorate %127 RelaxedPrecision OpDecorate %128 RelaxedPrecision OpDecorate %136 RelaxedPrecision OpDecorate %137 RelaxedPrecision OpDecorate %145 RelaxedPrecision OpDecorate %146 RelaxedPrecision OpDecorate %152 RelaxedPrecision OpDecorate %154 RelaxedPrecision OpDecorate %155 RelaxedPrecision OpDecorate %156 RelaxedPrecision OpDecorate %157 RelaxedPrecision OpDecorate %159 RelaxedPrecision OpDecorate %160 RelaxedPrecision OpDecorate %161 RelaxedPrecision OpDecorate %162 RelaxedPrecision OpDecorate %163 RelaxedPrecision OpDecorate %164 RelaxedPrecision OpDecorate %165 RelaxedPrecision OpDecorate %171 RelaxedPrecision OpDecorate %173 RelaxedPrecision OpDecorate %179 RelaxedPrecision OpDecorate %185 RelaxedPrecision OpDecorate %189 RelaxedPrecision OpDecorate %195 RelaxedPrecision OpDecorate %196 RelaxedPrecision OpDecorate %198 RelaxedPrecision OpDecorate %204 RelaxedPrecision OpDecorate %205 RelaxedPrecision OpDecorate %207 RelaxedPrecision OpDecorate %218 RelaxedPrecision OpDecorate %219 RelaxedPrecision OpDecorate %220 RelaxedPrecision OpDecorate %228 RelaxedPrecision OpDecorate %229 RelaxedPrecision OpDecorate %230 RelaxedPrecision OpDecorate %238 RelaxedPrecision OpDecorate %239 RelaxedPrecision OpDecorate %240 RelaxedPrecision OpDecorate %248 RelaxedPrecision OpDecorate %249 RelaxedPrecision OpDecorate %250 RelaxedPrecision OpDecorate %258 RelaxedPrecision OpDecorate %259 RelaxedPrecision OpDecorate %260 RelaxedPrecision OpDecorate %268 RelaxedPrecision OpDecorate %269 RelaxedPrecision OpDecorate %270 RelaxedPrecision OpDecorate %278 RelaxedPrecision OpDecorate %279 RelaxedPrecision OpDecorate %280 RelaxedPrecision OpDecorate %288 RelaxedPrecision OpDecorate %289 RelaxedPrecision OpDecorate %290 RelaxedPrecision OpDecorate %298 RelaxedPrecision OpDecorate %299 RelaxedPrecision OpDecorate %300 RelaxedPrecision OpDecorate %309 RelaxedPrecision OpDecorate %310 RelaxedPrecision OpDecorate %311 RelaxedPrecision OpDecorate %312 RelaxedPrecision OpDecorate %313 RelaxedPrecision OpDecorate %319 RelaxedPrecision OpDecorate %320 RelaxedPrecision OpDecorate %321 RelaxedPrecision OpDecorate %322 RelaxedPrecision OpDecorate %323 RelaxedPrecision OpDecorate %324 RelaxedPrecision OpDecorate %325 RelaxedPrecision OpDecorate %327 BuiltIn FragCoord OpMemberDecorate %331 0 Offset 0 OpDecorate %331 Block OpDecorate %333 DescriptorSet 0 OpDecorate %333 Binding 1 OpDecorate %339 RelaxedPrecision OpDecorate %340 RelaxedPrecision OpDecorate %347 RelaxedPrecision OpDecorate %348 RelaxedPrecision OpDecorate %349 RelaxedPrecision OpDecorate %351 RelaxedPrecision OpDecorate %352 RelaxedPrecision OpDecorate %353 RelaxedPrecision OpDecorate %354 RelaxedPrecision OpDecorate %356 RelaxedPrecision OpDecorate %363 Location 0 OpDecorate %364 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %10 = OpTypeInt 32 1 %11 = OpTypePointer Function %10 %13 = OpConstant %10 2 %20 = OpConstant %10 4 %21 = OpTypeBool %32 = OpConstant %10 0 %61 = OpTypeFloat 32 %62 = OpTypeVector %61 2 %63 = OpTypeMatrix %62 2 %64 = OpTypePointer Private %63 %65 = OpVariable %64 Private %68 = OpTypeStruct %61 %69 = OpTypePointer Uniform %68 %70 = OpVariable %69 Uniform %71 = OpTypePointer Uniform %61 %74 = OpTypePointer Private %61 %77 = OpTypeVector %61 3 %78 = OpTypeMatrix %77 2 %79 = OpTypePointer Private %78 %80 = OpVariable %79 Private %87 = OpTypeVector %61 4 %88 = OpTypeMatrix %87 2 %89 = OpTypePointer Private %88 %90 = OpVariable %89 Private %97 = OpTypeMatrix %62 3 %98 = OpTypePointer Private %97 %99 = OpVariable %98 Private %106 = OpTypeMatrix %77 3 %107 = OpTypePointer Private %106 %108 = OpVariable %107 Private %115 = OpTypeMatrix %87 3 %116 = OpTypePointer Private %115 %117 = OpVariable %116 Private %124 = OpTypeMatrix %62 4 %125 = OpTypePointer Private %124 %126 = OpVariable %125 Private %133 = OpTypeMatrix %77 4 %134 = OpTypePointer Private %133 %135 = OpVariable %134 Private %142 = OpTypeMatrix %87 4 %143 = OpTypePointer Private %142 %144 = OpVariable %143 Private %153 = OpConstant %10 1 %158 = OpConstant %6 1 %181 = OpConstant %6 9 %182 = OpTypeArray %61 %181 %183 = OpTypePointer Function %182 %186 = OpConstant %61 0 %187 = OpTypePointer Function %61 %314 = OpConstant %61 16 %326 = OpTypePointer Input %87 %327 = OpVariable %326 Input %328 = OpTypePointer Input %61 %331 = OpTypeStruct %62 %332 = OpTypePointer Uniform %331 %333 = OpVariable %332 Uniform %336 = OpConstant %61 3 %350 = OpConstant %10 3 %357 = OpConstant %10 9 %362 = OpTypePointer Output %87 %363 = OpVariable %362 Output %368 = OpConstant %61 1 %374 = OpConstantComposite %87 %186 %186 %186 %368 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %12 = OpVariable %11 Function %23 = OpVariable %11 Function %31 = OpVariable %11 Function %41 = OpVariable %11 Function %164 = OpVariable %11 Function %165 = OpVariable %11 Function %173 = OpVariable %11 Function %184 = OpVariable %183 Function %189 = OpVariable %11 Function %198 = OpVariable %11 Function %325 = OpVariable %11 Function %340 = OpVariable %11 Function %348 = OpVariable %11 Function OpStore %8 %9 OpStore %12 %13 OpBranch %14 %14 = OpLabel OpLoopMerge %16 %17 None OpBranch %18 %18 = OpLabel %19 = OpLoad %10 %12 %22 = OpSLessThanEqual %21 %19 %20 OpBranchConditional %22 %15 %16 %15 = OpLabel OpStore %23 %13 OpBranch %24 %24 = OpLabel OpLoopMerge %26 %27 None OpBranch %28 %28 = OpLabel %29 = OpLoad %10 %23 %30 = OpSLessThanEqual %21 %29 %20 OpBranchConditional %30 %25 %26 %25 = OpLabel OpStore %31 %32 OpBranch %33 %33 = OpLabel OpLoopMerge %35 %36 None OpBranch %37 %37 = OpLabel %38 = OpLoad %10 %31 %39 = OpLoad %10 %12 %40 = OpSLessThan %21 %38 %39 OpBranchConditional %40 %34 %35 %34 = OpLabel OpStore %41 %32 OpBranch %42 %42 = OpLabel OpLoopMerge %44 %45 None OpBranch %46 %46 = OpLabel %47 = OpLoad %10 %41 %48 = OpLoad %10 %23 %49 = OpSLessThan %21 %47 %48 OpBranchConditional %49 %43 %44 %43 = OpLabel %50 = OpLoad %6 %8 OpSelectionMerge %60 None OpSwitch %50 %60 0 %51 1 %52 2 %53 3 %54 4 %55 5 %56 6 %57 7 %58 8 %59 %51 = OpLabel %66 = OpLoad %10 %31 %67 = OpLoad %10 %41 %72 = OpAccessChain %71 %70 %32 %73 = OpLoad %61 %72 %75 = OpAccessChain %74 %65 %66 %67 OpStore %75 %73 OpBranch %60 %52 = OpLabel %81 = OpLoad %10 %31 %82 = OpLoad %10 %41 %83 = OpAccessChain %71 %70 %32 %84 = OpLoad %61 %83 %85 = OpAccessChain %74 %80 %81 %82 OpStore %85 %84 OpBranch %60 %53 = OpLabel %91 = OpLoad %10 %31 %92 = OpLoad %10 %41 %93 = OpAccessChain %71 %70 %32 %94 = OpLoad %61 %93 %95 = OpAccessChain %74 %90 %91 %92 OpStore %95 %94 OpBranch %60 %54 = OpLabel %100 = OpLoad %10 %31 %101 = OpLoad %10 %41 %102 = OpAccessChain %71 %70 %32 %103 = OpLoad %61 %102 %104 = OpAccessChain %74 %99 %100 %101 OpStore %104 %103 OpBranch %60 %55 = OpLabel %109 = OpLoad %10 %31 %110 = OpLoad %10 %41 %111 = OpAccessChain %71 %70 %32 %112 = OpLoad %61 %111 %113 = OpAccessChain %74 %108 %109 %110 OpStore %113 %112 OpBranch %60 %56 = OpLabel %118 = OpLoad %10 %31 %119 = OpLoad %10 %41 %120 = OpAccessChain %71 %70 %32 %121 = OpLoad %61 %120 %122 = OpAccessChain %74 %117 %118 %119 OpStore %122 %121 OpBranch %60 %57 = OpLabel %127 = OpLoad %10 %31 %128 = OpLoad %10 %41 %129 = OpAccessChain %71 %70 %32 %130 = OpLoad %61 %129 %131 = OpAccessChain %74 %126 %127 %128 OpStore %131 %130 OpBranch %60 %58 = OpLabel %136 = OpLoad %10 %31 %137 = OpLoad %10 %41 %138 = OpAccessChain %71 %70 %32 %139 = OpLoad %61 %138 %140 = OpAccessChain %74 %135 %136 %137 OpStore %140 %139 OpBranch %60 %59 = OpLabel %145 = OpLoad %10 %31 %146 = OpLoad %10 %41 %147 = OpAccessChain %71 %70 %32 %148 = OpLoad %61 %147 %149 = OpAccessChain %74 %144 %145 %146 OpStore %149 %148 OpBranch %60 %60 = OpLabel OpBranch %45 %45 = OpLabel %152 = OpLoad %10 %41 %154 = OpIAdd %10 %152 %153 OpStore %41 %154 OpBranch %42 %44 = OpLabel OpBranch %36 %36 = OpLabel %155 = OpLoad %10 %31 %156 = OpIAdd %10 %155 %153 OpStore %31 %156 OpBranch %33 %35 = OpLabel %157 = OpLoad %6 %8 %159 = OpIAdd %6 %157 %158 OpStore %8 %159 OpBranch %27 %27 = OpLabel %160 = OpLoad %10 %23 %161 = OpIAdd %10 %160 %153 OpStore %23 %161 OpBranch %24 %26 = OpLabel OpBranch %17 %17 = OpLabel %162 = OpLoad %10 %12 %163 = OpIAdd %10 %162 %153 OpStore %12 %163 OpBranch %14 %16 = OpLabel OpStore %164 %32 OpStore %165 %13 OpBranch %166 %166 = OpLabel OpLoopMerge %168 %169 None OpBranch %170 %170 = OpLabel %171 = OpLoad %10 %165 %172 = OpSLessThanEqual %21 %171 %20 OpBranchConditional %172 %167 %168 %167 = OpLabel OpStore %173 %13 OpBranch %174 %174 = OpLabel OpLoopMerge %176 %177 None OpBranch %178 %178 = OpLabel %179 = OpLoad %10 %173 %180 = OpSLessThanEqual %21 %179 %20 OpBranchConditional %180 %175 %176 %175 = OpLabel %185 = OpLoad %10 %164 %188 = OpAccessChain %187 %184 %185 OpStore %188 %186 OpStore %189 %32 OpBranch %190 %190 = OpLabel OpLoopMerge %192 %193 None OpBranch %194 %194 = OpLabel %195 = OpLoad %10 %189 %196 = OpLoad %10 %165 %197 = OpSLessThan %21 %195 %196 OpBranchConditional %197 %191 %192 %191 = OpLabel OpStore %198 %32 OpBranch %199 %199 = OpLabel OpLoopMerge %201 %202 None OpBranch %203 %203 = OpLabel %204 = OpLoad %10 %198 %205 = OpLoad %10 %173 %206 = OpSLessThan %21 %204 %205 OpBranchConditional %206 %200 %201 %200 = OpLabel %207 = OpLoad %10 %164 OpSelectionMerge %217 None OpSwitch %207 %217 0 %208 1 %209 2 %210 3 %211 4 %212 5 %213 6 %214 7 %215 8 %216 %208 = OpLabel %218 = OpLoad %10 %164 %219 = OpLoad %10 %189 %220 = OpLoad %10 %198 %221 = OpAccessChain %74 %65 %219 %220 %222 = OpLoad %61 %221 %223 = OpAccessChain %187 %184 %218 %224 = OpLoad %61 %223 %225 = OpFAdd %61 %224 %222 %226 = OpAccessChain %187 %184 %218 OpStore %226 %225 OpBranch %217 %209 = OpLabel %228 = OpLoad %10 %164 %229 = OpLoad %10 %189 %230 = OpLoad %10 %198 %231 = OpAccessChain %74 %80 %229 %230 %232 = OpLoad %61 %231 %233 = OpAccessChain %187 %184 %228 %234 = OpLoad %61 %233 %235 = OpFAdd %61 %234 %232 %236 = OpAccessChain %187 %184 %228 OpStore %236 %235 OpBranch %217 %210 = OpLabel %238 = OpLoad %10 %164 %239 = OpLoad %10 %189 %240 = OpLoad %10 %198 %241 = OpAccessChain %74 %90 %239 %240 %242 = OpLoad %61 %241 %243 = OpAccessChain %187 %184 %238 %244 = OpLoad %61 %243 %245 = OpFAdd %61 %244 %242 %246 = OpAccessChain %187 %184 %238 OpStore %246 %245 OpBranch %217 %211 = OpLabel %248 = OpLoad %10 %164 %249 = OpLoad %10 %189 %250 = OpLoad %10 %198 %251 = OpAccessChain %74 %99 %249 %250 %252 = OpLoad %61 %251 %253 = OpAccessChain %187 %184 %248 %254 = OpLoad %61 %253 %255 = OpFAdd %61 %254 %252 %256 = OpAccessChain %187 %184 %248 OpStore %256 %255 OpBranch %217 %212 = OpLabel %258 = OpLoad %10 %164 %259 = OpLoad %10 %189 %260 = OpLoad %10 %198 %261 = OpAccessChain %74 %108 %259 %260 %262 = OpLoad %61 %261 %263 = OpAccessChain %187 %184 %258 %264 = OpLoad %61 %263 %265 = OpFAdd %61 %264 %262 %266 = OpAccessChain %187 %184 %258 OpStore %266 %265 OpBranch %217 %213 = OpLabel %268 = OpLoad %10 %164 %269 = OpLoad %10 %189 %270 = OpLoad %10 %198 %271 = OpAccessChain %74 %117 %269 %270 %272 = OpLoad %61 %271 %273 = OpAccessChain %187 %184 %268 %274 = OpLoad %61 %273 %275 = OpFAdd %61 %274 %272 %276 = OpAccessChain %187 %184 %268 OpStore %276 %275 OpBranch %217 %214 = OpLabel %278 = OpLoad %10 %164 %279 = OpLoad %10 %189 %280 = OpLoad %10 %198 %281 = OpAccessChain %74 %126 %279 %280 %282 = OpLoad %61 %281 %283 = OpAccessChain %187 %184 %278 %284 = OpLoad %61 %283 %285 = OpFAdd %61 %284 %282 %286 = OpAccessChain %187 %184 %278 OpStore %286 %285 OpBranch %217 %215 = OpLabel %288 = OpLoad %10 %164 %289 = OpLoad %10 %189 %290 = OpLoad %10 %198 %291 = OpAccessChain %74 %135 %289 %290 %292 = OpLoad %61 %291 %293 = OpAccessChain %187 %184 %288 %294 = OpLoad %61 %293 %295 = OpFAdd %61 %294 %292 %296 = OpAccessChain %187 %184 %288 OpStore %296 %295 OpBranch %217 %216 = OpLabel %298 = OpLoad %10 %164 %299 = OpLoad %10 %189 %300 = OpLoad %10 %198 %301 = OpAccessChain %74 %144 %299 %300 %302 = OpLoad %61 %301 %303 = OpAccessChain %187 %184 %298 %304 = OpLoad %61 %303 %305 = OpFAdd %61 %304 %302 %306 = OpAccessChain %187 %184 %298 OpStore %306 %305 OpBranch %217 %217 = OpLabel OpBranch %202 %202 = OpLabel %309 = OpLoad %10 %198 %310 = OpIAdd %10 %309 %153 OpStore %198 %310 OpBranch %199 %201 = OpLabel OpBranch %193 %193 = OpLabel %311 = OpLoad %10 %189 %312 = OpIAdd %10 %311 %153 OpStore %189 %312 OpBranch %190 %192 = OpLabel %313 = OpLoad %10 %164 %315 = OpAccessChain %187 %184 %313 %316 = OpLoad %61 %315 %317 = OpFDiv %61 %316 %314 %318 = OpAccessChain %187 %184 %313 OpStore %318 %317 %319 = OpLoad %10 %164 %320 = OpIAdd %10 %319 %153 OpStore %164 %320 OpBranch %177 %177 = OpLabel %321 = OpLoad %10 %173 %322 = OpIAdd %10 %321 %153 OpStore %173 %322 OpBranch %174 %176 = OpLabel OpBranch %169 %169 = OpLabel %323 = OpLoad %10 %165 %324 = OpIAdd %10 %323 %153 OpStore %165 %324 OpBranch %166 %168 = OpLabel %329 = OpAccessChain %328 %327 %9 %330 = OpLoad %61 %329 %334 = OpAccessChain %71 %333 %32 %9 %335 = OpLoad %61 %334 %337 = OpFDiv %61 %335 %336 %338 = OpFDiv %61 %330 %337 %339 = OpConvertFToS %10 %338 OpStore %325 %339 %341 = OpAccessChain %328 %327 %158 %342 = OpLoad %61 %341 %343 = OpAccessChain %71 %333 %32 %9 %344 = OpLoad %61 %343 %345 = OpFDiv %61 %344 %336 %346 = OpFDiv %61 %342 %345 %347 = OpConvertFToS %10 %346 OpStore %340 %347 %349 = OpLoad %10 %340 %351 = OpIMul %10 %349 %350 %352 = OpLoad %10 %325 %353 = OpIAdd %10 %351 %352 OpStore %348 %353 %354 = OpLoad %10 %348 %355 = OpSGreaterThan %21 %354 %32 %356 = OpLoad %10 %348 %358 = OpSLessThan %21 %356 %357 %359 = OpLogicalAnd %21 %355 %358 OpSelectionMerge %361 None OpBranchConditional %359 %360 %373 %360 = OpLabel %364 = OpLoad %10 %348 %365 = OpAccessChain %187 %184 %364 %366 = OpLoad %61 %365 %367 = OpCompositeConstruct %77 %366 %366 %366 %369 = OpCompositeExtract %61 %367 0 %370 = OpCompositeExtract %61 %367 1 %371 = OpCompositeExtract %61 %367 2 %372 = OpCompositeConstruct %87 %369 %370 %371 %368 OpStore %363 %372 OpBranch %361 %373 = OpLabel OpStore %363 %374 OpBranch %361 %361 = OpLabel OpReturn OpFunctionEnd )"; // The SPIR-V comes from the following GLSL: // // #version 310 es // precision highp float; // // layout(location = 0) out vec4 color; // // void main() // { // color = vec4(1.0, 0.0, 0.0, 1.0); // } const std::string kTestShader5 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %9 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %9 "color" OpDecorate %9 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypePointer Output %7 %9 = OpVariable %8 Output %10 = OpConstant %6 1 %11 = OpConstant %6 0 %12 = OpConstantComposite %7 %10 %11 %11 %10 %4 = OpFunction %2 None %3 %5 = OpLabel OpStore %9 %12 OpReturn OpFunctionEnd )"; // Some miscellaneous SPIR-V. const std::string kTestShader6 = R"( OpCapability Shader OpCapability SampledBuffer OpCapability ImageBuffer %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %40 %41 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 450 OpDecorate %40 DescriptorSet 0 OpDecorate %40 Binding 69 OpDecorate %41 DescriptorSet 0 OpDecorate %41 Binding 1 %54 = OpTypeFloat 32 %76 = OpTypeVector %54 4 %55 = OpConstant %54 0 %56 = OpTypeVector %54 3 %94 = OpTypeVector %54 2 %112 = OpConstantComposite %94 %55 %55 %57 = OpConstantComposite %56 %55 %55 %55 %15 = OpTypeImage %54 2D 2 0 0 1 Unknown %114 = OpTypePointer UniformConstant %15 %38 = OpTypeSampler %125 = OpTypePointer UniformConstant %38 %132 = OpTypeVoid %133 = OpTypeFunction %132 %45 = OpTypeSampledImage %15 %40 = OpVariable %114 UniformConstant %41 = OpVariable %125 UniformConstant %2 = OpFunction %132 None %133 %164 = OpLabel %184 = OpLoad %15 %40 %213 = OpLoad %38 %41 %216 = OpSampledImage %45 %184 %213 %217 = OpImageSampleImplicitLod %76 %216 %112 Bias %55 OpReturn OpFunctionEnd )"; // A virtually empty piece of SPIR-V. const std::string kTestShader7 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; void AddConstantUniformFact(protobufs::FactSequence* facts, uint32_t descriptor_set, uint32_t binding, std::vector&& indices, uint32_t value) { protobufs::FactConstantUniform fact; *fact.mutable_uniform_buffer_element_descriptor() = MakeUniformBufferElementDescriptor(descriptor_set, binding, std::move(indices)); *fact.mutable_constant_word()->Add() = value; protobufs::Fact temp; *temp.mutable_constant_uniform_fact() = fact; *facts->mutable_fact()->Add() = temp; } // Reinterpret the bits of |value| as a 32-bit unsigned int uint32_t FloatBitsAsUint(float value) { uint32_t result; memcpy(&result, &value, sizeof(float)); return result; } // Assembles the given |shader| text, and then runs the fuzzer |num_runs| // times, using successive seeds starting from |initial_seed|. Checks that // the binary produced after each fuzzer run is valid, and that replaying // the transformations that were applied during fuzzing leads to an // identical binary. void RunFuzzerAndReplayer(const std::string& shader, const protobufs::FactSequence& initial_facts, uint32_t initial_seed, uint32_t num_runs) { const auto env = SPV_ENV_UNIVERSAL_1_5; std::vector binary_in; SpirvTools t(env); t.SetMessageConsumer(kConsoleMessageConsumer); ASSERT_TRUE(t.Assemble(shader, &binary_in, kFuzzAssembleOption)); ASSERT_TRUE(t.Validate(binary_in)); std::vector donor_suppliers; for (auto donor : {&kTestShader1, &kTestShader2, &kTestShader3, &kTestShader4, &kTestShader5, &kTestShader6}) { donor_suppliers.emplace_back([donor]() { return BuildModule(env, kConsoleMessageConsumer, *donor, kFuzzAssembleOption); }); } std::vector strategies{ RepeatedPassStrategy::kSimple, RepeatedPassStrategy::kLoopedWithRecommendations, RepeatedPassStrategy::kRandomWithRecommendations}; uint32_t strategy_index = 0; for (uint32_t seed = initial_seed; seed < initial_seed + num_runs; seed++) { spvtools::ValidatorOptions validator_options; std::unique_ptr ir_context; ASSERT_TRUE(fuzzerutil::BuildIRContext(env, kConsoleMessageConsumer, binary_in, validator_options, &ir_context)); auto fuzzer_context = MakeUnique( MakeUnique(seed), FuzzerContext::GetMinFreshId(ir_context.get()), false); auto transformation_context = MakeUnique( MakeUnique(ir_context.get()), validator_options); transformation_context->GetFactManager()->AddInitialFacts( kConsoleMessageConsumer, initial_facts); // Every 4th time we run the fuzzer, enable all fuzzer passes. bool enable_all_passes = (seed % 4) == 0; Fuzzer fuzzer(std::move(ir_context), std::move(transformation_context), std::move(fuzzer_context), kConsoleMessageConsumer, donor_suppliers, enable_all_passes, strategies[strategy_index], true, validator_options, false); auto fuzzer_result = fuzzer.Run(0); // Cycle the repeated pass strategy so that we try a different one next time // we run the fuzzer. strategy_index = (strategy_index + 1) % static_cast(strategies.size()); ASSERT_NE(Fuzzer::Status::kFuzzerPassLedToInvalidModule, fuzzer_result.status); std::vector transformed_binary; fuzzer.GetIRContext()->module()->ToBinary(&transformed_binary, true); ASSERT_TRUE(t.Validate(transformed_binary)); auto replayer_result = Replayer(env, kConsoleMessageConsumer, binary_in, initial_facts, fuzzer.GetTransformationSequence(), static_cast( fuzzer.GetTransformationSequence().transformation_size()), false, validator_options) .Run(); ASSERT_EQ(Replayer::ReplayerResultStatus::kComplete, replayer_result.status); // After replaying the transformations applied by the fuzzer, exactly those // transformations should have been applied, and the binary resulting from // replay should be identical to that which resulted from fuzzing. std::string fuzzer_transformations_string; std::string replayer_transformations_string; fuzzer.GetTransformationSequence().SerializeToString( &fuzzer_transformations_string); replayer_result.applied_transformations.SerializeToString( &replayer_transformations_string); ASSERT_EQ(fuzzer_transformations_string, replayer_transformations_string); ASSERT_TRUE(IsEqual(env, transformed_binary, replayer_result.transformed_module.get())); } } TEST(FuzzerReplayerTest, Miscellaneous1) { // Do some fuzzer runs, starting from an initial seed of 0 (seed value chosen // arbitrarily). RunFuzzerAndReplayer(kTestShader1, protobufs::FactSequence(), 0, kNumFuzzerRuns); } TEST(FuzzerReplayerTest, Miscellaneous2) { // Do some fuzzer runs, starting from an initial seed of 10 (seed value chosen // arbitrarily). RunFuzzerAndReplayer(kTestShader2, protobufs::FactSequence(), 10, kNumFuzzerRuns); } TEST(FuzzerReplayerTest, Miscellaneous3) { // Add the facts "resolution.x == 250" and "resolution.y == 100". protobufs::FactSequence facts; AddConstantUniformFact(&facts, 0, 0, {0, 0}, 250); AddConstantUniformFact(&facts, 0, 0, {0, 1}, 100); // Do some fuzzer runs, starting from an initial seed of 94 (seed value chosen // arbitrarily). RunFuzzerAndReplayer(kTestShader3, facts, 94, kNumFuzzerRuns); } TEST(FuzzerReplayerTest, Miscellaneous4) { // Add the facts: // - "one == 1.0" // - "resolution.y == 256.0", protobufs::FactSequence facts; AddConstantUniformFact(&facts, 0, 0, {0}, FloatBitsAsUint(1.0)); AddConstantUniformFact(&facts, 0, 1, {0, 0}, FloatBitsAsUint(256.0)); AddConstantUniformFact(&facts, 0, 1, {0, 1}, FloatBitsAsUint(256.0)); // Do some fuzzer runs, starting from an initial seed of 14 (seed value chosen // arbitrarily). RunFuzzerAndReplayer(kTestShader4, facts, 14, kNumFuzzerRuns); } TEST(FuzzerReplayerTest, Miscellaneous5) { // Do some fuzzer runs, starting from an initial seed of 29 (seed value chosen // arbitrarily). RunFuzzerAndReplayer(kTestShader5, protobufs::FactSequence(), 29, kNumFuzzerRuns); } TEST(FuzzerReplayerTest, Miscellaneous6) { // Do some fuzzer runs, starting from an initial seed of 57 (seed value chosen // arbitrarily). RunFuzzerAndReplayer(kTestShader6, protobufs::FactSequence(), 57, kNumFuzzerRuns); } TEST(FuzzerReplayerTest, Miscellaneous7) { // Do some fuzzer runs, starting from an initial seed of 1 (seed value chosen // arbitrarily). RunFuzzerAndReplayer(kTestShader7, protobufs::FactSequence(), 1, kNumFuzzerRuns); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/fuzzer_shrinker_test.cpp000066400000000000000000001146341475742701700255140ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gtest/gtest.h" #include "source/fuzz/fuzzer.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/pseudo_random_generator.h" #include "source/fuzz/shrinker.h" #include "source/fuzz/uniform_buffer_element_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { // The following SPIR-V came from this GLSL: // // #version 310 es // // void foo() { // int x; // x = 2; // for (int i = 0; i < 100; i++) { // x += i; // x = x * 2; // } // return; // } // // void main() { // foo(); // for (int i = 0; i < 10; i++) { // int j = 20; // while(j > 0) { // foo(); // j--; // } // do { // i++; // } while(i < 4); // } // } const std::string kTestShader1 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %6 "foo(" OpName %10 "x" OpName %12 "i" OpName %33 "i" OpName %42 "j" OpDecorate %10 RelaxedPrecision OpDecorate %12 RelaxedPrecision OpDecorate %19 RelaxedPrecision OpDecorate %23 RelaxedPrecision OpDecorate %24 RelaxedPrecision OpDecorate %25 RelaxedPrecision OpDecorate %26 RelaxedPrecision OpDecorate %27 RelaxedPrecision OpDecorate %28 RelaxedPrecision OpDecorate %30 RelaxedPrecision OpDecorate %33 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %49 RelaxedPrecision OpDecorate %52 RelaxedPrecision OpDecorate %53 RelaxedPrecision OpDecorate %58 RelaxedPrecision OpDecorate %59 RelaxedPrecision OpDecorate %60 RelaxedPrecision OpDecorate %63 RelaxedPrecision OpDecorate %64 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %11 = OpConstant %8 2 %13 = OpConstant %8 0 %20 = OpConstant %8 100 %21 = OpTypeBool %29 = OpConstant %8 1 %40 = OpConstant %8 10 %43 = OpConstant %8 20 %61 = OpConstant %8 4 %4 = OpFunction %2 None %3 %5 = OpLabel %33 = OpVariable %9 Function %42 = OpVariable %9 Function %32 = OpFunctionCall %2 %6 OpStore %33 %13 OpBranch %34 %34 = OpLabel OpLoopMerge %36 %37 None OpBranch %38 %38 = OpLabel %39 = OpLoad %8 %33 %41 = OpSLessThan %21 %39 %40 OpBranchConditional %41 %35 %36 %35 = OpLabel OpStore %42 %43 OpBranch %44 %44 = OpLabel OpLoopMerge %46 %47 None OpBranch %48 %48 = OpLabel %49 = OpLoad %8 %42 %50 = OpSGreaterThan %21 %49 %13 OpBranchConditional %50 %45 %46 %45 = OpLabel %51 = OpFunctionCall %2 %6 %52 = OpLoad %8 %42 %53 = OpISub %8 %52 %29 OpStore %42 %53 OpBranch %47 %47 = OpLabel OpBranch %44 %46 = OpLabel OpBranch %54 %54 = OpLabel OpLoopMerge %56 %57 None OpBranch %55 %55 = OpLabel %58 = OpLoad %8 %33 %59 = OpIAdd %8 %58 %29 OpStore %33 %59 OpBranch %57 %57 = OpLabel %60 = OpLoad %8 %33 %62 = OpSLessThan %21 %60 %61 OpBranchConditional %62 %54 %56 %56 = OpLabel OpBranch %37 %37 = OpLabel %63 = OpLoad %8 %33 %64 = OpIAdd %8 %63 %29 OpStore %33 %64 OpBranch %34 %36 = OpLabel OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %10 = OpVariable %9 Function %12 = OpVariable %9 Function OpStore %10 %11 OpStore %12 %13 OpBranch %14 %14 = OpLabel OpLoopMerge %16 %17 None OpBranch %18 %18 = OpLabel %19 = OpLoad %8 %12 %22 = OpSLessThan %21 %19 %20 OpBranchConditional %22 %15 %16 %15 = OpLabel %23 = OpLoad %8 %12 %24 = OpLoad %8 %10 %25 = OpIAdd %8 %24 %23 OpStore %10 %25 %26 = OpLoad %8 %10 %27 = OpIMul %8 %26 %11 OpStore %10 %27 OpBranch %17 %17 = OpLabel %28 = OpLoad %8 %12 %30 = OpIAdd %8 %28 %29 OpStore %12 %30 OpBranch %14 %16 = OpLabel OpReturn OpFunctionEnd )"; // The following SPIR-V came from this GLSL, which was then optimized using // spirv-opt with the -O argument: // // #version 310 es // // precision highp float; // // layout(location = 0) out vec4 _GLF_color; // // layout(set = 0, binding = 0) uniform buf0 { // vec2 injectionSwitch; // }; // layout(set = 0, binding = 1) uniform buf1 { // vec2 resolution; // }; // bool checkSwap(float a, float b) // { // return gl_FragCoord.y < resolution.y / 2.0 ? a > b : a < b; // } // void main() // { // float data[10]; // for(int i = 0; i < 10; i++) // { // data[i] = float(10 - i) * injectionSwitch.y; // } // for(int i = 0; i < 9; i++) // { // for(int j = 0; j < 10; j++) // { // if(j < i + 1) // { // continue; // } // bool doSwap = checkSwap(data[i], data[j]); // if(doSwap) // { // float temp = data[i]; // data[i] = data[j]; // data[j] = temp; // } // } // } // if(gl_FragCoord.x < resolution.x / 2.0) // { // _GLF_color = vec4(data[0] / 10.0, data[5] / 10.0, data[9] / 10.0, 1.0); // } // else // { // _GLF_color = vec4(data[5] / 10.0, data[9] / 10.0, data[0] / 10.0, 1.0); // } // } const std::string kTestShader2 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %16 %139 %25 %68 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %16 "gl_FragCoord" OpName %23 "buf1" OpMemberName %23 0 "resolution" OpName %25 "" OpName %61 "data" OpName %66 "buf0" OpMemberName %66 0 "injectionSwitch" OpName %68 "" OpName %139 "_GLF_color" OpDecorate %16 BuiltIn FragCoord OpMemberDecorate %23 0 Offset 0 OpDecorate %23 Block OpDecorate %25 DescriptorSet 0 OpDecorate %25 Binding 1 OpDecorate %64 RelaxedPrecision OpMemberDecorate %66 0 Offset 0 OpDecorate %66 Block OpDecorate %68 DescriptorSet 0 OpDecorate %68 Binding 0 OpDecorate %75 RelaxedPrecision OpDecorate %95 RelaxedPrecision OpDecorate %126 RelaxedPrecision OpDecorate %128 RelaxedPrecision OpDecorate %139 Location 0 OpDecorate %182 RelaxedPrecision OpDecorate %183 RelaxedPrecision OpDecorate %184 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %8 = OpTypeBool %14 = OpTypeVector %6 4 %15 = OpTypePointer Input %14 %16 = OpVariable %15 Input %17 = OpTypeInt 32 0 %18 = OpConstant %17 1 %19 = OpTypePointer Input %6 %22 = OpTypeVector %6 2 %23 = OpTypeStruct %22 %24 = OpTypePointer Uniform %23 %25 = OpVariable %24 Uniform %26 = OpTypeInt 32 1 %27 = OpConstant %26 0 %28 = OpTypePointer Uniform %6 %56 = OpConstant %26 10 %58 = OpConstant %17 10 %59 = OpTypeArray %6 %58 %60 = OpTypePointer Function %59 %66 = OpTypeStruct %22 %67 = OpTypePointer Uniform %66 %68 = OpVariable %67 Uniform %74 = OpConstant %26 1 %83 = OpConstant %26 9 %129 = OpConstant %17 0 %138 = OpTypePointer Output %14 %139 = OpVariable %138 Output %144 = OpConstant %26 5 %151 = OpConstant %6 1 %194 = OpConstant %6 0.5 %195 = OpConstant %6 0.100000001 %4 = OpFunction %2 None %3 %5 = OpLabel %61 = OpVariable %60 Function OpBranch %50 %50 = OpLabel %182 = OpPhi %26 %27 %5 %75 %51 %57 = OpSLessThan %8 %182 %56 OpLoopMerge %52 %51 None OpBranchConditional %57 %51 %52 %51 = OpLabel %64 = OpISub %26 %56 %182 %65 = OpConvertSToF %6 %64 %69 = OpAccessChain %28 %68 %27 %18 %70 = OpLoad %6 %69 %71 = OpFMul %6 %65 %70 %72 = OpAccessChain %7 %61 %182 OpStore %72 %71 %75 = OpIAdd %26 %182 %74 OpBranch %50 %52 = OpLabel OpBranch %77 %77 = OpLabel %183 = OpPhi %26 %27 %52 %128 %88 %84 = OpSLessThan %8 %183 %83 OpLoopMerge %79 %88 None OpBranchConditional %84 %78 %79 %78 = OpLabel OpBranch %86 %86 = OpLabel %184 = OpPhi %26 %27 %78 %126 %89 %92 = OpSLessThan %8 %184 %56 OpLoopMerge %1000 %89 None OpBranchConditional %92 %87 %1000 %87 = OpLabel %95 = OpIAdd %26 %183 %74 %96 = OpSLessThan %8 %184 %95 OpSelectionMerge %98 None OpBranchConditional %96 %97 %98 %97 = OpLabel OpBranch %89 %98 = OpLabel %104 = OpAccessChain %7 %61 %183 %105 = OpLoad %6 %104 %107 = OpAccessChain %7 %61 %184 %108 = OpLoad %6 %107 %166 = OpAccessChain %19 %16 %18 %167 = OpLoad %6 %166 %168 = OpAccessChain %28 %25 %27 %18 %169 = OpLoad %6 %168 %170 = OpFMul %6 %169 %194 %171 = OpFOrdLessThan %8 %167 %170 OpSelectionMerge %172 None OpBranchConditional %171 %173 %174 %173 = OpLabel %177 = OpFOrdGreaterThan %8 %105 %108 OpBranch %172 %174 = OpLabel %180 = OpFOrdLessThan %8 %105 %108 OpBranch %172 %172 = OpLabel %186 = OpPhi %8 %177 %173 %180 %174 OpSelectionMerge %112 None OpBranchConditional %186 %111 %112 %111 = OpLabel %116 = OpLoad %6 %104 %120 = OpLoad %6 %107 OpStore %104 %120 OpStore %107 %116 OpBranch %112 %112 = OpLabel OpBranch %89 %89 = OpLabel %126 = OpIAdd %26 %184 %74 OpBranch %86 %1000 = OpLabel OpBranch %88 %88 = OpLabel %128 = OpIAdd %26 %183 %74 OpBranch %77 %79 = OpLabel %130 = OpAccessChain %19 %16 %129 %131 = OpLoad %6 %130 %132 = OpAccessChain %28 %25 %27 %129 %133 = OpLoad %6 %132 %134 = OpFMul %6 %133 %194 %135 = OpFOrdLessThan %8 %131 %134 OpSelectionMerge %137 None OpBranchConditional %135 %136 %153 %136 = OpLabel %140 = OpAccessChain %7 %61 %27 %141 = OpLoad %6 %140 %143 = OpFMul %6 %141 %195 %145 = OpAccessChain %7 %61 %144 %146 = OpLoad %6 %145 %147 = OpFMul %6 %146 %195 %148 = OpAccessChain %7 %61 %83 %149 = OpLoad %6 %148 %150 = OpFMul %6 %149 %195 %152 = OpCompositeConstruct %14 %143 %147 %150 %151 OpStore %139 %152 OpBranch %137 %153 = OpLabel %154 = OpAccessChain %7 %61 %144 %155 = OpLoad %6 %154 %156 = OpFMul %6 %155 %195 %157 = OpAccessChain %7 %61 %83 %158 = OpLoad %6 %157 %159 = OpFMul %6 %158 %195 %160 = OpAccessChain %7 %61 %27 %161 = OpLoad %6 %160 %162 = OpFMul %6 %161 %195 %163 = OpCompositeConstruct %14 %156 %159 %162 %151 OpStore %139 %163 OpBranch %137 %137 = OpLabel OpReturn OpFunctionEnd )"; // The following SPIR-V came from this GLSL, which was then optimized using // spirv-opt with the -O argument: // // #version 310 es // // precision highp float; // // layout(location = 0) out vec4 _GLF_color; // // layout(set = 0, binding = 0) uniform buf0 { // vec2 resolution; // }; // void main(void) // { // float A[50]; // for( // int i = 0; // i < 200; // i ++ // ) // { // if(i >= int(resolution.x)) // { // break; // } // if((4 * (i / 4)) == i) // { // A[i / 4] = float(i); // } // } // for( // int i = 0; // i < 50; // i ++ // ) // { // if(i < int(gl_FragCoord.x)) // { // break; // } // if(i > 0) // { // A[i] += A[i - 1]; // } // } // if(int(gl_FragCoord.x) < 20) // { // _GLF_color = vec4(A[0] / resolution.x, A[4] / resolution.y, 1.0, 1.0); // } // else // if(int(gl_FragCoord.x) < 40) // { // _GLF_color = vec4(A[5] / resolution.x, A[9] / resolution.y, 1.0, 1.0); // } // else // if(int(gl_FragCoord.x) < 60) // { // _GLF_color = vec4(A[10] / resolution.x, A[14] / resolution.y, // 1.0, 1.0); // } // else // if(int(gl_FragCoord.x) < 80) // { // _GLF_color = vec4(A[15] / resolution.x, A[19] / resolution.y, // 1.0, 1.0); // } // else // if(int(gl_FragCoord.x) < 100) // { // _GLF_color = vec4(A[20] / resolution.x, A[24] / resolution.y, // 1.0, 1.0); // } // else // if(int(gl_FragCoord.x) < 120) // { // _GLF_color = vec4(A[25] / resolution.x, A[29] / resolution.y, // 1.0, 1.0); // } // else // if(int(gl_FragCoord.x) < 140) // { // _GLF_color = vec4(A[30] / resolution.x, A[34] / resolution.y, // 1.0, 1.0); // } // else // if(int(gl_FragCoord.x) < 160) // { // _GLF_color = vec4(A[35] / resolution.x, A[39] / // resolution.y, 1.0, 1.0); // } // else // if(int(gl_FragCoord.x) < 180) // { // _GLF_color = vec4(A[40] / resolution.x, A[44] / // resolution.y, 1.0, 1.0); // } // else // if(int(gl_FragCoord.x) < 180) // { // _GLF_color = vec4(A[45] / resolution.x, A[49] / // resolution.y, 1.0, 1.0); // } // else // { // discard; // } // } const std::string kTestShader3 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %68 %100 %24 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %22 "buf0" OpMemberName %22 0 "resolution" OpName %24 "" OpName %46 "A" OpName %68 "gl_FragCoord" OpName %100 "_GLF_color" OpMemberDecorate %22 0 Offset 0 OpDecorate %22 Block OpDecorate %24 DescriptorSet 0 OpDecorate %24 Binding 0 OpDecorate %37 RelaxedPrecision OpDecorate %38 RelaxedPrecision OpDecorate %55 RelaxedPrecision OpDecorate %68 BuiltIn FragCoord OpDecorate %83 RelaxedPrecision OpDecorate %91 RelaxedPrecision OpDecorate %100 Location 0 OpDecorate %302 RelaxedPrecision OpDecorate %304 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %9 = OpConstant %6 0 %16 = OpConstant %6 200 %17 = OpTypeBool %20 = OpTypeFloat 32 %21 = OpTypeVector %20 2 %22 = OpTypeStruct %21 %23 = OpTypePointer Uniform %22 %24 = OpVariable %23 Uniform %25 = OpTypeInt 32 0 %26 = OpConstant %25 0 %27 = OpTypePointer Uniform %20 %35 = OpConstant %6 4 %43 = OpConstant %25 50 %44 = OpTypeArray %20 %43 %45 = OpTypePointer Function %44 %51 = OpTypePointer Function %20 %54 = OpConstant %6 1 %63 = OpConstant %6 50 %66 = OpTypeVector %20 4 %67 = OpTypePointer Input %66 %68 = OpVariable %67 Input %69 = OpTypePointer Input %20 %95 = OpConstant %6 20 %99 = OpTypePointer Output %66 %100 = OpVariable %99 Output %108 = OpConstant %25 1 %112 = OpConstant %20 1 %118 = OpConstant %6 40 %122 = OpConstant %6 5 %128 = OpConstant %6 9 %139 = OpConstant %6 60 %143 = OpConstant %6 10 %149 = OpConstant %6 14 %160 = OpConstant %6 80 %164 = OpConstant %6 15 %170 = OpConstant %6 19 %181 = OpConstant %6 100 %190 = OpConstant %6 24 %201 = OpConstant %6 120 %205 = OpConstant %6 25 %211 = OpConstant %6 29 %222 = OpConstant %6 140 %226 = OpConstant %6 30 %232 = OpConstant %6 34 %243 = OpConstant %6 160 %247 = OpConstant %6 35 %253 = OpConstant %6 39 %264 = OpConstant %6 180 %273 = OpConstant %6 44 %287 = OpConstant %6 45 %293 = OpConstant %6 49 %4 = OpFunction %2 None %3 %5 = OpLabel %46 = OpVariable %45 Function OpBranch %10 %10 = OpLabel %302 = OpPhi %6 %9 %5 %55 %42 %18 = OpSLessThan %17 %302 %16 OpLoopMerge %12 %42 None OpBranchConditional %18 %11 %12 %11 = OpLabel %28 = OpAccessChain %27 %24 %9 %26 %29 = OpLoad %20 %28 %30 = OpConvertFToS %6 %29 %31 = OpSGreaterThanEqual %17 %302 %30 OpSelectionMerge %33 None OpBranchConditional %31 %32 %33 %32 = OpLabel OpBranch %12 %33 = OpLabel %37 = OpSDiv %6 %302 %35 %38 = OpIMul %6 %35 %37 %40 = OpIEqual %17 %38 %302 OpBranchConditional %40 %41 %42 %41 = OpLabel %50 = OpConvertSToF %20 %302 %52 = OpAccessChain %51 %46 %37 OpStore %52 %50 OpBranch %42 %42 = OpLabel %55 = OpIAdd %6 %302 %54 OpBranch %10 %12 = OpLabel OpBranch %57 %57 = OpLabel %304 = OpPhi %6 %9 %12 %91 %80 %64 = OpSLessThan %17 %304 %63 OpLoopMerge %59 %80 None OpBranchConditional %64 %58 %59 %58 = OpLabel %70 = OpAccessChain %69 %68 %26 %71 = OpLoad %20 %70 %72 = OpConvertFToS %6 %71 %73 = OpSLessThan %17 %304 %72 OpSelectionMerge %75 None OpBranchConditional %73 %74 %75 %74 = OpLabel OpBranch %59 %75 = OpLabel %78 = OpSGreaterThan %17 %304 %9 OpBranchConditional %78 %79 %80 %79 = OpLabel %83 = OpISub %6 %304 %54 %84 = OpAccessChain %51 %46 %83 %85 = OpLoad %20 %84 %86 = OpAccessChain %51 %46 %304 %87 = OpLoad %20 %86 %88 = OpFAdd %20 %87 %85 OpStore %86 %88 OpBranch %80 %80 = OpLabel %91 = OpIAdd %6 %304 %54 OpBranch %57 %59 = OpLabel %92 = OpAccessChain %69 %68 %26 %93 = OpLoad %20 %92 %94 = OpConvertFToS %6 %93 %96 = OpSLessThan %17 %94 %95 OpSelectionMerge %98 None OpBranchConditional %96 %97 %114 %97 = OpLabel %101 = OpAccessChain %51 %46 %9 %102 = OpLoad %20 %101 %103 = OpAccessChain %27 %24 %9 %26 %104 = OpLoad %20 %103 %105 = OpFDiv %20 %102 %104 %106 = OpAccessChain %51 %46 %35 %107 = OpLoad %20 %106 %109 = OpAccessChain %27 %24 %9 %108 %110 = OpLoad %20 %109 %111 = OpFDiv %20 %107 %110 %113 = OpCompositeConstruct %66 %105 %111 %112 %112 OpStore %100 %113 OpBranch %98 %114 = OpLabel %119 = OpSLessThan %17 %94 %118 OpSelectionMerge %121 None OpBranchConditional %119 %120 %135 %120 = OpLabel %123 = OpAccessChain %51 %46 %122 %124 = OpLoad %20 %123 %125 = OpAccessChain %27 %24 %9 %26 %126 = OpLoad %20 %125 %127 = OpFDiv %20 %124 %126 %129 = OpAccessChain %51 %46 %128 %130 = OpLoad %20 %129 %131 = OpAccessChain %27 %24 %9 %108 %132 = OpLoad %20 %131 %133 = OpFDiv %20 %130 %132 %134 = OpCompositeConstruct %66 %127 %133 %112 %112 OpStore %100 %134 OpBranch %121 %135 = OpLabel %140 = OpSLessThan %17 %94 %139 OpSelectionMerge %142 None OpBranchConditional %140 %141 %156 %141 = OpLabel %144 = OpAccessChain %51 %46 %143 %145 = OpLoad %20 %144 %146 = OpAccessChain %27 %24 %9 %26 %147 = OpLoad %20 %146 %148 = OpFDiv %20 %145 %147 %150 = OpAccessChain %51 %46 %149 %151 = OpLoad %20 %150 %152 = OpAccessChain %27 %24 %9 %108 %153 = OpLoad %20 %152 %154 = OpFDiv %20 %151 %153 %155 = OpCompositeConstruct %66 %148 %154 %112 %112 OpStore %100 %155 OpBranch %142 %156 = OpLabel %161 = OpSLessThan %17 %94 %160 OpSelectionMerge %163 None OpBranchConditional %161 %162 %177 %162 = OpLabel %165 = OpAccessChain %51 %46 %164 %166 = OpLoad %20 %165 %167 = OpAccessChain %27 %24 %9 %26 %168 = OpLoad %20 %167 %169 = OpFDiv %20 %166 %168 %171 = OpAccessChain %51 %46 %170 %172 = OpLoad %20 %171 %173 = OpAccessChain %27 %24 %9 %108 %174 = OpLoad %20 %173 %175 = OpFDiv %20 %172 %174 %176 = OpCompositeConstruct %66 %169 %175 %112 %112 OpStore %100 %176 OpBranch %163 %177 = OpLabel %182 = OpSLessThan %17 %94 %181 OpSelectionMerge %184 None OpBranchConditional %182 %183 %197 %183 = OpLabel %185 = OpAccessChain %51 %46 %95 %186 = OpLoad %20 %185 %187 = OpAccessChain %27 %24 %9 %26 %188 = OpLoad %20 %187 %189 = OpFDiv %20 %186 %188 %191 = OpAccessChain %51 %46 %190 %192 = OpLoad %20 %191 %193 = OpAccessChain %27 %24 %9 %108 %194 = OpLoad %20 %193 %195 = OpFDiv %20 %192 %194 %196 = OpCompositeConstruct %66 %189 %195 %112 %112 OpStore %100 %196 OpBranch %184 %197 = OpLabel %202 = OpSLessThan %17 %94 %201 OpSelectionMerge %204 None OpBranchConditional %202 %203 %218 %203 = OpLabel %206 = OpAccessChain %51 %46 %205 %207 = OpLoad %20 %206 %208 = OpAccessChain %27 %24 %9 %26 %209 = OpLoad %20 %208 %210 = OpFDiv %20 %207 %209 %212 = OpAccessChain %51 %46 %211 %213 = OpLoad %20 %212 %214 = OpAccessChain %27 %24 %9 %108 %215 = OpLoad %20 %214 %216 = OpFDiv %20 %213 %215 %217 = OpCompositeConstruct %66 %210 %216 %112 %112 OpStore %100 %217 OpBranch %204 %218 = OpLabel %223 = OpSLessThan %17 %94 %222 OpSelectionMerge %225 None OpBranchConditional %223 %224 %239 %224 = OpLabel %227 = OpAccessChain %51 %46 %226 %228 = OpLoad %20 %227 %229 = OpAccessChain %27 %24 %9 %26 %230 = OpLoad %20 %229 %231 = OpFDiv %20 %228 %230 %233 = OpAccessChain %51 %46 %232 %234 = OpLoad %20 %233 %235 = OpAccessChain %27 %24 %9 %108 %236 = OpLoad %20 %235 %237 = OpFDiv %20 %234 %236 %238 = OpCompositeConstruct %66 %231 %237 %112 %112 OpStore %100 %238 OpBranch %225 %239 = OpLabel %244 = OpSLessThan %17 %94 %243 OpSelectionMerge %246 None OpBranchConditional %244 %245 %260 %245 = OpLabel %248 = OpAccessChain %51 %46 %247 %249 = OpLoad %20 %248 %250 = OpAccessChain %27 %24 %9 %26 %251 = OpLoad %20 %250 %252 = OpFDiv %20 %249 %251 %254 = OpAccessChain %51 %46 %253 %255 = OpLoad %20 %254 %256 = OpAccessChain %27 %24 %9 %108 %257 = OpLoad %20 %256 %258 = OpFDiv %20 %255 %257 %259 = OpCompositeConstruct %66 %252 %258 %112 %112 OpStore %100 %259 OpBranch %246 %260 = OpLabel %265 = OpSLessThan %17 %94 %264 OpSelectionMerge %267 None OpBranchConditional %265 %266 %280 %266 = OpLabel %268 = OpAccessChain %51 %46 %118 %269 = OpLoad %20 %268 %270 = OpAccessChain %27 %24 %9 %26 %271 = OpLoad %20 %270 %272 = OpFDiv %20 %269 %271 %274 = OpAccessChain %51 %46 %273 %275 = OpLoad %20 %274 %276 = OpAccessChain %27 %24 %9 %108 %277 = OpLoad %20 %276 %278 = OpFDiv %20 %275 %277 %279 = OpCompositeConstruct %66 %272 %278 %112 %112 OpStore %100 %279 OpBranch %267 %280 = OpLabel OpSelectionMerge %285 None OpBranchConditional %265 %285 %300 %285 = OpLabel %288 = OpAccessChain %51 %46 %287 %289 = OpLoad %20 %288 %290 = OpAccessChain %27 %24 %9 %26 %291 = OpLoad %20 %290 %292 = OpFDiv %20 %289 %291 %294 = OpAccessChain %51 %46 %293 %295 = OpLoad %20 %294 %296 = OpAccessChain %27 %24 %9 %108 %297 = OpLoad %20 %296 %298 = OpFDiv %20 %295 %297 %299 = OpCompositeConstruct %66 %292 %298 %112 %112 OpStore %100 %299 OpBranch %267 %300 = OpLabel OpKill %267 = OpLabel OpBranch %246 %246 = OpLabel OpBranch %225 %225 = OpLabel OpBranch %204 %204 = OpLabel OpBranch %184 %184 = OpLabel OpBranch %163 %163 = OpLabel OpBranch %142 %142 = OpLabel OpBranch %121 %121 = OpLabel OpBranch %98 %98 = OpLabel OpReturn OpFunctionEnd )"; // Abstract class exposing an interestingness function as a virtual method. class InterestingnessTest { public: virtual ~InterestingnessTest() = default; // Abstract method that subclasses should implement for specific notions of // interestingness. Its signature matches Shrinker::InterestingnessFunction. // Argument |binary| is the SPIR-V binary to be checked; |counter| is used for // debugging purposes. virtual bool Interesting(const std::vector& binary, uint32_t counter) = 0; // Yields the Interesting instance method wrapped in a function object. Shrinker::InterestingnessFunction AsFunction() { return std::bind(&InterestingnessTest::Interesting, this, std::placeholders::_1, std::placeholders::_2); } }; // A test that says all binaries are interesting. class AlwaysInteresting : public InterestingnessTest { public: bool Interesting(const std::vector&, uint32_t) override { return true; } }; // A test that says a binary is interesting first time round, and uninteresting // thereafter. class OnlyInterestingFirstTime : public InterestingnessTest { public: explicit OnlyInterestingFirstTime() : first_time_(true) {} bool Interesting(const std::vector&, uint32_t) override { if (first_time_) { first_time_ = false; return true; } return false; } private: bool first_time_; }; // A test that says a binary is interesting first time round, after which // interestingness ping pongs between false and true. class PingPong : public InterestingnessTest { public: explicit PingPong() : interesting_(false) {} bool Interesting(const std::vector&, uint32_t) override { interesting_ = !interesting_; return interesting_; } private: bool interesting_; }; // A test that says a binary is interesting first time round, thereafter // decides at random whether it is interesting. This allows the logic of the // shrinker to be exercised quite a bit. class InterestingThenRandom : public InterestingnessTest { public: InterestingThenRandom(const PseudoRandomGenerator& random_generator) : first_time_(true), random_generator_(random_generator) {} bool Interesting(const std::vector&, uint32_t) override { if (first_time_) { first_time_ = false; return true; } return random_generator_.RandomBool(); } private: bool first_time_; PseudoRandomGenerator random_generator_; }; // |binary_in| and |initial_facts| are a SPIR-V binary and sequence of facts to // which |transformation_sequence_in| can be applied. Shrinking of // |transformation_sequence_in| gets performed with respect to // |interestingness_function|. If |expected_binary_out| is non-empty, it must // match the binary obtained by applying the final shrunk set of // transformations, in which case the number of such transformations should // equal |expected_transformations_out_size|. // // The |step_limit| parameter restricts the number of steps that the shrinker // will try; it can be set to something small for a faster (but less thorough) // test. // // The |validator_options| parameter provides validator options that should be // used during shrinking. void RunAndCheckShrinker( const spv_target_env& target_env, const std::vector& binary_in, const protobufs::FactSequence& initial_facts, const protobufs::TransformationSequence& transformation_sequence_in, const Shrinker::InterestingnessFunction& interestingness_function, const std::vector& expected_binary_out, uint32_t expected_transformations_out_size, uint32_t step_limit, spv_validator_options validator_options) { // Run the shrinker. auto shrinker_result = Shrinker(target_env, kConsoleMessageConsumer, binary_in, initial_facts, transformation_sequence_in, interestingness_function, step_limit, false, validator_options) .Run(); ASSERT_TRUE(Shrinker::ShrinkerResultStatus::kComplete == shrinker_result.status || Shrinker::ShrinkerResultStatus::kStepLimitReached == shrinker_result.status); // If a non-empty expected binary was provided, check that it matches the // result of shrinking and that the expected number of transformations remain. if (!expected_binary_out.empty()) { ASSERT_EQ(expected_binary_out, shrinker_result.transformed_binary); ASSERT_EQ( expected_transformations_out_size, static_cast( shrinker_result.applied_transformations.transformation_size())); } } // Assembles the given |shader| text, and then: // - Runs the fuzzer with |seed| to yield a set of transformations // - Shrinks the transformation with various interestingness functions, // asserting some properties about the result each time void RunFuzzerAndShrinker(const std::string& shader, const protobufs::FactSequence& initial_facts, uint32_t seed) { const auto env = SPV_ENV_UNIVERSAL_1_5; std::vector binary_in; SpirvTools t(env); t.SetMessageConsumer(kConsoleMessageConsumer); ASSERT_TRUE(t.Assemble(shader, &binary_in, kFuzzAssembleOption)); ASSERT_TRUE(t.Validate(binary_in)); std::vector donor_suppliers; for (auto donor : {&kTestShader1, &kTestShader2, &kTestShader3}) { donor_suppliers.emplace_back([donor]() { return BuildModule(env, kConsoleMessageConsumer, *donor, kFuzzAssembleOption); }); } // Run the fuzzer and check that it successfully yields a valid binary. spvtools::ValidatorOptions validator_options; // Depending on the seed, decide whether to enable all passes and which // repeated pass manager to use. bool enable_all_passes = (seed % 4) == 0; RepeatedPassStrategy repeated_pass_strategy; if ((seed % 3) == 0) { repeated_pass_strategy = RepeatedPassStrategy::kSimple; } else if ((seed % 3) == 1) { repeated_pass_strategy = RepeatedPassStrategy::kLoopedWithRecommendations; } else { repeated_pass_strategy = RepeatedPassStrategy::kRandomWithRecommendations; } std::unique_ptr ir_context; ASSERT_TRUE(fuzzerutil::BuildIRContext( env, kConsoleMessageConsumer, binary_in, validator_options, &ir_context)); auto fuzzer_context = MakeUnique( MakeUnique(seed), FuzzerContext::GetMinFreshId(ir_context.get()), false); auto transformation_context = MakeUnique( MakeUnique(ir_context.get()), validator_options); transformation_context->GetFactManager()->AddInitialFacts( kConsoleMessageConsumer, initial_facts); Fuzzer fuzzer(std::move(ir_context), std::move(transformation_context), std::move(fuzzer_context), kConsoleMessageConsumer, donor_suppliers, enable_all_passes, repeated_pass_strategy, true, validator_options, false); auto fuzzer_result = fuzzer.Run(0); ASSERT_NE(Fuzzer::Status::kFuzzerPassLedToInvalidModule, fuzzer_result.status); std::vector transformed_binary; fuzzer.GetIRContext()->module()->ToBinary(&transformed_binary, true); ASSERT_TRUE(t.Validate(transformed_binary)); const uint32_t kReasonableStepLimit = 50; const uint32_t kSmallStepLimit = 20; // With the AlwaysInteresting test, we should quickly shrink to the original // binary with no transformations remaining. RunAndCheckShrinker(env, binary_in, initial_facts, fuzzer.GetTransformationSequence(), AlwaysInteresting().AsFunction(), binary_in, 0, kReasonableStepLimit, validator_options); // With the OnlyInterestingFirstTime test, no shrinking should be achieved. RunAndCheckShrinker( env, binary_in, initial_facts, fuzzer.GetTransformationSequence(), OnlyInterestingFirstTime().AsFunction(), transformed_binary, static_cast( fuzzer.GetTransformationSequence().transformation_size()), kReasonableStepLimit, validator_options); // The PingPong test is unpredictable; passing an empty expected binary // means that we don't check anything beyond that shrinking completes // successfully. RunAndCheckShrinker( env, binary_in, initial_facts, fuzzer.GetTransformationSequence(), PingPong().AsFunction(), {}, 0, kSmallStepLimit, validator_options); // The InterestingThenRandom test is unpredictable; passing an empty // expected binary means that we do not check anything about shrinking // results. RunAndCheckShrinker( env, binary_in, initial_facts, fuzzer.GetTransformationSequence(), InterestingThenRandom(PseudoRandomGenerator(seed)).AsFunction(), {}, 0, kSmallStepLimit, validator_options); } TEST(FuzzerShrinkerTest, Miscellaneous1) { RunFuzzerAndShrinker(kTestShader1, protobufs::FactSequence(), 2); } TEST(FuzzerShrinkerTest, Miscellaneous2) { RunFuzzerAndShrinker(kTestShader2, protobufs::FactSequence(), 19); } TEST(FuzzerShrinkerTest, Miscellaneous3) { // Add the facts "resolution.x == 250" and "resolution.y == 100". protobufs::FactSequence facts; { protobufs::FactConstantUniform resolution_x_eq_250; *resolution_x_eq_250.mutable_uniform_buffer_element_descriptor() = MakeUniformBufferElementDescriptor(0, 0, {0, 0}); *resolution_x_eq_250.mutable_constant_word()->Add() = 250; protobufs::Fact temp; *temp.mutable_constant_uniform_fact() = resolution_x_eq_250; *facts.mutable_fact()->Add() = temp; } { protobufs::FactConstantUniform resolution_y_eq_100; *resolution_y_eq_100.mutable_uniform_buffer_element_descriptor() = MakeUniformBufferElementDescriptor(0, 0, {0, 1}); *resolution_y_eq_100.mutable_constant_word()->Add() = 100; protobufs::Fact temp; *temp.mutable_constant_uniform_fact() = resolution_y_eq_100; *facts.mutable_fact()->Add() = temp; } // Also add an invalid fact, which should be ignored. { protobufs::FactConstantUniform bad_fact; // The descriptor set, binding and indices used here deliberately make no // sense. *bad_fact.mutable_uniform_buffer_element_descriptor() = MakeUniformBufferElementDescriptor(22, 33, {44, 55}); *bad_fact.mutable_constant_word()->Add() = 100; protobufs::Fact temp; *temp.mutable_constant_uniform_fact() = bad_fact; *facts.mutable_fact()->Add() = temp; } // Do 2 fuzzer runs, starting from an initial seed of 194 (seed value chosen // arbitrarily). RunFuzzerAndShrinker(kTestShader3, facts, 194); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/fuzzerutil_test.cpp000066400000000000000000002126151475742701700245030ustar00rootroot00000000000000// Copyright (c) 2021 Shiyu Liu // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(FuzzerUtilMaybeFindBlockTest, BasicTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %8 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %10 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpBranch %11 %11 = OpLabel OpStore %8 %9 OpBranch %12 %12 = OpLabel OpStore %8 %10 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const std::unique_ptr context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Only blocks with id 11 and 12 can be found. // Should return nullptr when id is not a label or id was not found. uint32_t block_id1 = 11; uint32_t block_id2 = 12; uint32_t block_id3 = 13; uint32_t block_id4 = 8; opt::IRContext* ir_context = context.get(); // Block with id 11 should be found. ASSERT_TRUE(fuzzerutil::MaybeFindBlock(ir_context, block_id1) != nullptr); // Block with id 12 should be found. ASSERT_TRUE(fuzzerutil::MaybeFindBlock(ir_context, block_id2) != nullptr); // Block with id 13 cannot be found. ASSERT_FALSE(fuzzerutil::MaybeFindBlock(ir_context, block_id3) != nullptr); // Block with id 8 exists but don't not of type OpLabel. ASSERT_FALSE(fuzzerutil::MaybeFindBlock(ir_context, block_id4) != nullptr); } TEST(FuzzerutilTest, FuzzerUtilMaybeGetBoolConstantTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %36 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "b1" OpName %10 "b2" OpName %12 "b3" OpName %13 "b4" OpName %16 "f1" OpName %18 "f2" OpName %20 "cf1" OpName %22 "cf2" OpName %26 "i1" OpName %28 "i2" OpName %30 "ci1" OpName %32 "ci2" OpName %36 "value" OpDecorate %26 RelaxedPrecision OpDecorate %28 RelaxedPrecision OpDecorate %30 RelaxedPrecision OpDecorate %32 RelaxedPrecision OpDecorate %36 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpTypePointer Function %6 %9 = OpConstantTrue %6 %11 = OpConstantFalse %6 %14 = OpTypeFloat 32 %15 = OpTypePointer Function %14 %17 = OpConstant %14 1.23000002 %19 = OpConstant %14 1.11000001 %21 = OpConstant %14 2 %23 = OpConstant %14 3.29999995 %24 = OpTypeInt 32 1 %25 = OpTypePointer Function %24 %27 = OpConstant %24 1 %29 = OpConstant %24 100 %31 = OpConstant %24 123 %33 = OpConstant %24 1111 %35 = OpTypePointer Input %14 %36 = OpVariable %35 Input %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %12 = OpVariable %7 Function %13 = OpVariable %7 Function %16 = OpVariable %15 Function %18 = OpVariable %15 Function %20 = OpVariable %15 Function %22 = OpVariable %15 Function %26 = OpVariable %25 Function %28 = OpVariable %25 Function %30 = OpVariable %25 Function %32 = OpVariable %25 Function OpStore %8 %9 OpStore %10 %11 OpStore %12 %9 OpStore %13 %11 OpStore %16 %17 OpStore %18 %19 OpStore %20 %21 OpStore %22 %23 OpStore %26 %27 OpStore %28 %29 OpStore %30 %31 OpStore %32 %33 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const std::unique_ptr context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); opt::IRContext* ir_context = context.get(); // A bool constant with value false exists and the id is 11. ASSERT_EQ(11, fuzzerutil::MaybeGetBoolConstant( ir_context, transformation_context, false, false)); // A bool constant with value true exists and the id is 9. ASSERT_EQ(9, fuzzerutil::MaybeGetBoolConstant( ir_context, transformation_context, true, false)); } TEST(FuzzerutilTest, FuzzerUtilMaybeGetBoolTypeTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %92 %52 %53 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %92 BuiltIn FragCoord %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeFloat 32 %8 = OpTypeStruct %6 %7 %9 = OpTypePointer Function %8 %10 = OpTypeFunction %6 %9 %14 = OpConstant %6 0 %15 = OpTypePointer Function %6 %51 = OpTypePointer Private %6 %21 = OpConstant %6 2 %23 = OpConstant %6 1 %24 = OpConstant %7 1 %25 = OpTypePointer Function %7 %50 = OpTypePointer Private %7 %34 = OpTypeBool %35 = OpConstantFalse %34 %52 = OpVariable %50 Private %53 = OpVariable %51 Private %80 = OpConstantComposite %8 %21 %24 %90 = OpTypeVector %7 4 %91 = OpTypePointer Input %90 %92 = OpVariable %91 Input %93 = OpConstantComposite %90 %24 %24 %24 %24 %4 = OpFunction %2 None %3 %5 = OpLabel %20 = OpVariable %9 Function %27 = OpVariable %9 Function %22 = OpAccessChain %15 %20 %14 %44 = OpCopyObject %9 %20 %26 = OpAccessChain %25 %20 %23 %29 = OpFunctionCall %6 %12 %27 %30 = OpAccessChain %15 %20 %14 %45 = OpCopyObject %15 %30 %81 = OpCopyObject %9 %27 %33 = OpAccessChain %15 %20 %14 OpSelectionMerge %37 None OpBranchConditional %35 %36 %37 %36 = OpLabel %38 = OpAccessChain %15 %20 %14 %40 = OpAccessChain %15 %20 %14 %43 = OpAccessChain %15 %20 %14 %82 = OpCopyObject %9 %27 OpBranch %37 %37 = OpLabel OpReturn OpFunctionEnd %12 = OpFunction %6 None %10 %11 = OpFunctionParameter %9 %13 = OpLabel %46 = OpCopyObject %9 %11 %16 = OpAccessChain %15 %11 %14 %95 = OpCopyObject %8 %80 OpReturnValue %21 %100 = OpLabel OpUnreachable OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const std::unique_ptr context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); opt::IRContext* ir_context = context.get(); // A bool type with result id of 34 exists. ASSERT_TRUE(fuzzerutil::MaybeGetBoolType(ir_context)); } TEST(FuzzerutilTest, FuzzerUtilMaybeGetCompositeConstantTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %54 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "b1" OpName %10 "b2" OpName %12 "b3" OpName %13 "b4" OpName %16 "f1" OpName %18 "f2" OpName %22 "zc" OpName %24 "i1" OpName %28 "i2" OpName %30 "i3" OpName %32 "i4" OpName %37 "f_arr" OpName %47 "i_arr" OpName %54 "value" OpDecorate %22 RelaxedPrecision OpDecorate %24 RelaxedPrecision OpDecorate %28 RelaxedPrecision OpDecorate %30 RelaxedPrecision OpDecorate %32 RelaxedPrecision OpDecorate %47 RelaxedPrecision OpDecorate %54 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpTypePointer Function %6 %9 = OpConstantTrue %6 %11 = OpConstantFalse %6 %14 = OpTypeFloat 32 %15 = OpTypePointer Function %14 %17 = OpConstant %14 1.23000002 %19 = OpConstant %14 1.11000001 %20 = OpTypeInt 32 1 %21 = OpTypePointer Function %20 %23 = OpConstant %20 0 %25 = OpConstant %20 1 %26 = OpTypeInt 32 0 %27 = OpTypePointer Function %26 %29 = OpConstant %26 100 %31 = OpConstant %20 -1 %33 = OpConstant %20 -99 %34 = OpConstant %26 5 %35 = OpTypeArray %14 %34 %36 = OpTypePointer Function %35 %38 = OpConstant %14 5.5 %39 = OpConstant %14 4.4000001 %40 = OpConstant %14 3.29999995 %41 = OpConstant %14 2.20000005 %42 = OpConstant %14 1.10000002 %43 = OpConstantComposite %35 %38 %39 %40 %41 %42 %44 = OpConstant %26 3 %45 = OpTypeArray %20 %44 %46 = OpTypePointer Function %45 %48 = OpConstant %20 3 %49 = OpConstant %20 7 %50 = OpConstant %20 9 %51 = OpConstantComposite %45 %48 %49 %50 %53 = OpTypePointer Input %14 %54 = OpVariable %53 Input %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %12 = OpVariable %7 Function %13 = OpVariable %7 Function %16 = OpVariable %15 Function %18 = OpVariable %15 Function %22 = OpVariable %21 Function %24 = OpVariable %21 Function %28 = OpVariable %27 Function %30 = OpVariable %21 Function %32 = OpVariable %21 Function %37 = OpVariable %36 Function %47 = OpVariable %46 Function OpStore %8 %9 OpStore %10 %11 OpStore %12 %9 OpStore %13 %11 OpStore %16 %17 OpStore %18 %19 OpStore %22 %23 OpStore %24 %25 OpStore %28 %29 OpStore %30 %31 OpStore %32 %33 OpStore %37 %43 OpStore %47 %51 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const std::unique_ptr context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); opt::IRContext* ir_context = context.get(); // %43 = OpConstantComposite %35 %38 %39 %40 %41 %42 // %51 = OpConstantComposite %45 %48 %49 %50 // This should pass as a float array with 5 elements exist and its id is 43. ASSERT_EQ(43, fuzzerutil::MaybeGetCompositeConstant( ir_context, transformation_context, {38, 39, 40, 41, 42}, 35, false)); // This should pass as an int array with 3 elements exist and its id is 51. ASSERT_EQ(51, fuzzerutil::MaybeGetCompositeConstant( ir_context, transformation_context, {48, 49, 50}, 45, false)); // An int array with 2 elements does not exist. ASSERT_EQ(0, fuzzerutil::MaybeGetCompositeConstant( ir_context, transformation_context, {48, 49}, 45, false)); } TEST(FuzzerutilTest, FuzzerUtilMaybeGetFloatConstantTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %36 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "b1" OpName %10 "b2" OpName %12 "b3" OpName %13 "b4" OpName %16 "f1" OpName %18 "f2" OpName %20 "cf1" OpName %22 "cf2" OpName %26 "i1" OpName %28 "i2" OpName %30 "ci1" OpName %32 "ci2" OpName %36 "value" OpDecorate %26 RelaxedPrecision OpDecorate %28 RelaxedPrecision OpDecorate %30 RelaxedPrecision OpDecorate %32 RelaxedPrecision OpDecorate %36 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpTypePointer Function %6 %9 = OpConstantTrue %6 %11 = OpConstantFalse %6 %14 = OpTypeFloat 32 %15 = OpTypePointer Function %14 %17 = OpConstant %14 1.23000002 %19 = OpConstant %14 1.11000001 %21 = OpConstant %14 2 %23 = OpConstant %14 3.29999995 %24 = OpTypeInt 32 1 %25 = OpTypePointer Function %24 %27 = OpConstant %24 1 %29 = OpConstant %24 100 %31 = OpConstant %24 123 %33 = OpConstant %24 1111 %35 = OpTypePointer Input %14 %36 = OpVariable %35 Input %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %12 = OpVariable %7 Function %13 = OpVariable %7 Function %16 = OpVariable %15 Function %18 = OpVariable %15 Function %20 = OpVariable %15 Function %22 = OpVariable %15 Function %26 = OpVariable %25 Function %28 = OpVariable %25 Function %30 = OpVariable %25 Function %32 = OpVariable %25 Function OpStore %8 %9 OpStore %10 %11 OpStore %12 %9 OpStore %13 %11 OpStore %16 %17 OpStore %18 %19 OpStore %20 %21 OpStore %22 %23 OpStore %26 %27 OpStore %28 %29 OpStore %30 %31 OpStore %32 %33 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const std::unique_ptr context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); opt::IRContext* ir_context = context.get(); uint32_t word1 = fuzzerutil::FloatToWord(2); uint32_t word2 = fuzzerutil::FloatToWord(1.23f); // A 32 bit float constant of value 2 exists and its id is 21. ASSERT_EQ(21, fuzzerutil::MaybeGetFloatConstant( ir_context, transformation_context, std::vector{word1}, 32, false)); // A 32 bit float constant of value 1.23 exists and its id is 17. ASSERT_EQ(17, fuzzerutil::MaybeGetFloatConstant( ir_context, transformation_context, std::vector{word2}, 32, false)); } TEST(FuzzerutilTest, FuzzerUtilMaybeGetFloatTypeTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %92 %52 %53 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %92 BuiltIn FragCoord %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeFloat 32 %8 = OpTypeStruct %6 %7 %9 = OpTypePointer Function %8 %10 = OpTypeFunction %6 %9 %14 = OpConstant %6 0 %15 = OpTypePointer Function %6 %51 = OpTypePointer Private %6 %21 = OpConstant %6 2 %23 = OpConstant %6 1 %24 = OpConstant %7 1 %25 = OpTypePointer Function %7 %50 = OpTypePointer Private %7 %34 = OpTypeBool %35 = OpConstantFalse %34 %52 = OpVariable %50 Private %53 = OpVariable %51 Private %80 = OpConstantComposite %8 %21 %24 %90 = OpTypeVector %7 4 %91 = OpTypePointer Input %90 %92 = OpVariable %91 Input %93 = OpConstantComposite %90 %24 %24 %24 %24 %4 = OpFunction %2 None %3 %5 = OpLabel %20 = OpVariable %9 Function %27 = OpVariable %9 Function %22 = OpAccessChain %15 %20 %14 %44 = OpCopyObject %9 %20 %26 = OpAccessChain %25 %20 %23 %29 = OpFunctionCall %6 %12 %27 %30 = OpAccessChain %15 %20 %14 %45 = OpCopyObject %15 %30 %81 = OpCopyObject %9 %27 %33 = OpAccessChain %15 %20 %14 OpSelectionMerge %37 None OpBranchConditional %35 %36 %37 %36 = OpLabel %38 = OpAccessChain %15 %20 %14 %40 = OpAccessChain %15 %20 %14 %43 = OpAccessChain %15 %20 %14 %82 = OpCopyObject %9 %27 OpBranch %37 %37 = OpLabel OpReturn OpFunctionEnd %12 = OpFunction %6 None %10 %11 = OpFunctionParameter %9 %13 = OpLabel %46 = OpCopyObject %9 %11 %16 = OpAccessChain %15 %11 %14 %95 = OpCopyObject %8 %80 OpReturnValue %21 %100 = OpLabel OpUnreachable OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const std::unique_ptr context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); opt::IRContext* ir_context = context.get(); // A float type with width = 32 and result id of 7 exists. ASSERT_EQ(7, fuzzerutil::MaybeGetFloatType(ir_context, 32)); // A float int type with width = 32 exists, but the id should be 7. ASSERT_NE(5, fuzzerutil::MaybeGetFloatType(ir_context, 32)); // A float type with width 30 does not exist. ASSERT_EQ(0, fuzzerutil::MaybeGetFloatType(ir_context, 30)); } TEST(FuzzerutilTest, FuzzerUtilMaybeGetIntegerConstantFromValueAndTypeTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %36 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "b1" OpName %10 "b2" OpName %12 "b3" OpName %13 "b4" OpName %16 "f1" OpName %18 "f2" OpName %22 "zc" OpName %24 "i1" OpName %28 "i2" OpName %30 "i3" OpName %32 "i4" OpName %36 "value" OpDecorate %22 RelaxedPrecision OpDecorate %24 RelaxedPrecision OpDecorate %28 RelaxedPrecision OpDecorate %30 RelaxedPrecision OpDecorate %32 RelaxedPrecision OpDecorate %36 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpTypePointer Function %6 %9 = OpConstantTrue %6 %11 = OpConstantFalse %6 %14 = OpTypeFloat 32 %15 = OpTypePointer Function %14 %17 = OpConstant %14 1.23000002 %19 = OpConstant %14 1.11000001 %20 = OpTypeInt 32 1 %21 = OpTypePointer Function %20 %23 = OpConstant %20 0 %25 = OpConstant %20 1 %26 = OpTypeInt 32 0 %27 = OpTypePointer Function %26 %29 = OpConstant %26 100 %31 = OpConstant %20 -1 %33 = OpConstant %20 -99 %35 = OpTypePointer Input %14 %36 = OpVariable %35 Input %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %12 = OpVariable %7 Function %13 = OpVariable %7 Function %16 = OpVariable %15 Function %18 = OpVariable %15 Function %22 = OpVariable %21 Function %24 = OpVariable %21 Function %28 = OpVariable %27 Function %30 = OpVariable %21 Function %32 = OpVariable %21 Function OpStore %8 %9 OpStore %10 %11 OpStore %12 %9 OpStore %13 %11 OpStore %16 %17 OpStore %18 %19 OpStore %22 %23 OpStore %24 %25 OpStore %28 %29 OpStore %30 %31 OpStore %32 %33 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const std::unique_ptr context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); opt::IRContext* ir_context = context.get(); // A 32 bit signed int constant (with int type id 20) with value 1 exists and // the id is 25. ASSERT_EQ(25, fuzzerutil::MaybeGetIntegerConstantFromValueAndType(ir_context, 1, 20)); // A 32 bit unsigned int constant (with int type id 0) with value 100 exists // and the id is 29. ASSERT_EQ(29, fuzzerutil::MaybeGetIntegerConstantFromValueAndType(ir_context, 100, 26)); // A 32 bit unsigned int constant with value 50 does not exist. ASSERT_EQ(0, fuzzerutil::MaybeGetIntegerConstantFromValueAndType(ir_context, 50, 26)); } TEST(FuzzerutilTest, FuzzerUtilMaybeGetIntegerConstantTest) { std::string shader = R"( OpCapability Shader OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %36 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "b1" OpName %10 "b2" OpName %12 "b3" OpName %13 "b4" OpName %16 "f1" OpName %18 "f2" OpName %22 "zc" OpName %24 "i1" OpName %28 "i2" OpName %30 "i3" OpName %32 "i4" OpName %36 "value" OpDecorate %22 RelaxedPrecision OpDecorate %24 RelaxedPrecision OpDecorate %28 RelaxedPrecision OpDecorate %30 RelaxedPrecision OpDecorate %32 RelaxedPrecision OpDecorate %36 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpTypePointer Function %6 %9 = OpConstantTrue %6 %11 = OpConstantFalse %6 %14 = OpTypeFloat 32 %15 = OpTypePointer Function %14 %17 = OpConstant %14 1.23000002 %19 = OpConstant %14 1.11000001 %20 = OpTypeInt 32 1 %21 = OpTypePointer Function %20 %23 = OpConstant %20 0 %25 = OpConstant %20 1 %26 = OpTypeInt 32 0 %27 = OpTypePointer Function %26 %29 = OpConstant %26 100 %31 = OpConstant %20 -1 %33 = OpConstant %20 -99 %35 = OpTypePointer Input %14 %36 = OpVariable %35 Input %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %12 = OpVariable %7 Function %13 = OpVariable %7 Function %16 = OpVariable %15 Function %18 = OpVariable %15 Function %22 = OpVariable %21 Function %24 = OpVariable %21 Function %28 = OpVariable %27 Function %30 = OpVariable %21 Function %32 = OpVariable %21 Function OpStore %8 %9 OpStore %10 %11 OpStore %12 %9 OpStore %13 %11 OpStore %16 %17 OpStore %18 %19 OpStore %22 %23 OpStore %24 %25 OpStore %28 %29 OpStore %30 %31 OpStore %32 %33 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const std::unique_ptr context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); opt::IRContext* ir_context = context.get(); // A 32 bit unsigned int constant with value 1 exists and the id is 25. ASSERT_EQ(25, fuzzerutil::MaybeGetIntegerConstant( ir_context, transformation_context, std::vector{1}, 32, true, false)); // A 32 bit unsigned int constant with value 100 exists and the id is 29. ASSERT_EQ(29, fuzzerutil::MaybeGetIntegerConstant( ir_context, transformation_context, std::vector{100}, 32, false, false)); // A 32 bit signed int constant with value 99 doesn't not exist and should // return 0. ASSERT_EQ(0, fuzzerutil::MaybeGetIntegerConstant( ir_context, transformation_context, std::vector{99}, 32, true, false)); } TEST(FuzzerutilTest, FuzzerUtilMaybeGetIntegerTypeTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %92 %52 %53 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %92 BuiltIn FragCoord %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeFloat 32 %8 = OpTypeStruct %6 %7 %9 = OpTypePointer Function %8 %10 = OpTypeFunction %6 %9 %14 = OpConstant %6 0 %15 = OpTypePointer Function %6 %51 = OpTypePointer Private %6 %21 = OpConstant %6 2 %23 = OpConstant %6 1 %24 = OpConstant %7 1 %25 = OpTypePointer Function %7 %50 = OpTypePointer Private %7 %34 = OpTypeBool %35 = OpConstantFalse %34 %52 = OpVariable %50 Private %53 = OpVariable %51 Private %80 = OpConstantComposite %8 %21 %24 %90 = OpTypeVector %7 4 %91 = OpTypePointer Input %90 %92 = OpVariable %91 Input %93 = OpConstantComposite %90 %24 %24 %24 %24 %4 = OpFunction %2 None %3 %5 = OpLabel %20 = OpVariable %9 Function %27 = OpVariable %9 Function %22 = OpAccessChain %15 %20 %14 %44 = OpCopyObject %9 %20 %26 = OpAccessChain %25 %20 %23 %29 = OpFunctionCall %6 %12 %27 %30 = OpAccessChain %15 %20 %14 %45 = OpCopyObject %15 %30 %81 = OpCopyObject %9 %27 %33 = OpAccessChain %15 %20 %14 OpSelectionMerge %37 None OpBranchConditional %35 %36 %37 %36 = OpLabel %38 = OpAccessChain %15 %20 %14 %40 = OpAccessChain %15 %20 %14 %43 = OpAccessChain %15 %20 %14 %82 = OpCopyObject %9 %27 OpBranch %37 %37 = OpLabel OpReturn OpFunctionEnd %12 = OpFunction %6 None %10 %11 = OpFunctionParameter %9 %13 = OpLabel %46 = OpCopyObject %9 %11 %16 = OpAccessChain %15 %11 %14 %95 = OpCopyObject %8 %80 OpReturnValue %21 %100 = OpLabel OpUnreachable OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const std::unique_ptr context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); opt::IRContext* ir_context = context.get(); // A signed int type with width = 32 and result id of 6 exists. ASSERT_EQ(6, fuzzerutil::MaybeGetIntegerType(ir_context, 32, true)); // A signed int type with width = 32 exists, but the id should be 6. ASSERT_FALSE(fuzzerutil::MaybeGetIntegerType(ir_context, 32, true) == 5); // A int type with width = 32 and result id of 6 exists, but it should be a // signed int. ASSERT_EQ(0, fuzzerutil::MaybeGetIntegerType(ir_context, 32, false)); // A signed int type with width 30 does not exist. ASSERT_EQ(0, fuzzerutil::MaybeGetIntegerType(ir_context, 30, true)); // An unsigned int type with width 22 does not exist. ASSERT_EQ(0, fuzzerutil::MaybeGetIntegerType(ir_context, 22, false)); } TEST(FuzzerutilTest, FuzzerUtilMaybeGetPointerTypeTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %92 %52 %53 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %92 BuiltIn FragCoord %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeFloat 32 %8 = OpTypeStruct %6 %7 %9 = OpTypePointer Function %8 %10 = OpTypeFunction %6 %9 %14 = OpConstant %6 0 %15 = OpTypePointer Function %6 %51 = OpTypePointer Private %6 %21 = OpConstant %6 2 %23 = OpConstant %6 1 %24 = OpConstant %7 1 %25 = OpTypePointer Function %7 %50 = OpTypePointer Private %7 %34 = OpTypeBool %35 = OpConstantFalse %34 %52 = OpVariable %50 Private %53 = OpVariable %51 Private %80 = OpConstantComposite %8 %21 %24 %90 = OpTypeVector %7 4 %91 = OpTypePointer Input %90 %92 = OpVariable %91 Input %93 = OpConstantComposite %90 %24 %24 %24 %24 %4 = OpFunction %2 None %3 %5 = OpLabel %20 = OpVariable %9 Function %27 = OpVariable %9 Function %22 = OpAccessChain %15 %20 %14 %44 = OpCopyObject %9 %20 %26 = OpAccessChain %25 %20 %23 %29 = OpFunctionCall %6 %12 %27 %30 = OpAccessChain %15 %20 %14 %45 = OpCopyObject %15 %30 %81 = OpCopyObject %9 %27 %33 = OpAccessChain %15 %20 %14 OpSelectionMerge %37 None OpBranchConditional %35 %36 %37 %36 = OpLabel %38 = OpAccessChain %15 %20 %14 %40 = OpAccessChain %15 %20 %14 %43 = OpAccessChain %15 %20 %14 %82 = OpCopyObject %9 %27 OpBranch %37 %37 = OpLabel OpReturn OpFunctionEnd %12 = OpFunction %6 None %10 %11 = OpFunctionParameter %9 %13 = OpLabel %46 = OpCopyObject %9 %11 %16 = OpAccessChain %15 %11 %14 %95 = OpCopyObject %8 %80 OpReturnValue %21 %100 = OpLabel OpUnreachable OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const std::unique_ptr context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); opt::IRContext* ir_context = context.get(); auto private_storage_class = spv::StorageClass::Private; auto function_storage_class = spv::StorageClass::Function; auto input_storage_class = spv::StorageClass::Input; // A valid pointer must have the correct |pointee_type_id| and |storageClass|. // A function type pointer with id = 9 and pointee type id 8 should be found. ASSERT_EQ(9, fuzzerutil::MaybeGetPointerType(ir_context, 8, function_storage_class)); // A function type pointer with id = 15 and pointee type id 6 should be found. ASSERT_EQ(15, fuzzerutil::MaybeGetPointerType(ir_context, 6, function_storage_class)); // A function type pointer with id = 25 and pointee type id 7 should be found. ASSERT_EQ(25, fuzzerutil::MaybeGetPointerType(ir_context, 7, function_storage_class)); // A private type pointer with id=51 and pointee type id 6 should be found. ASSERT_EQ(51, fuzzerutil::MaybeGetPointerType(ir_context, 6, private_storage_class)); // A function pointer with id=50 and pointee type id 7 should be found. ASSERT_EQ(50, fuzzerutil::MaybeGetPointerType(ir_context, 7, private_storage_class)); // A input type pointer with id=91 and pointee type id 90 should be found. ASSERT_EQ( 91, fuzzerutil::MaybeGetPointerType(ir_context, 90, input_storage_class)); // A pointer with id=91 and pointee type 90 exists, but the type should be // input. ASSERT_EQ(0, fuzzerutil::MaybeGetPointerType(ir_context, 90, function_storage_class)); // A input type pointer with id=91 exists but the pointee id should be 90. ASSERT_EQ( 0, fuzzerutil::MaybeGetPointerType(ir_context, 89, input_storage_class)); // A input type pointer with pointee id 90 exists but result id of the pointer // should be 91. ASSERT_NE( 58, fuzzerutil::MaybeGetPointerType(ir_context, 90, input_storage_class)); } TEST(FuzzerutilTest, FuzzerUtilMaybeGetScalarConstantTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %56 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "b1" OpName %10 "b2" OpName %12 "b3" OpName %13 "b4" OpName %16 "f1" OpName %18 "f2" OpName %22 "zc" OpName %24 "i1" OpName %28 "i2" OpName %30 "i" OpName %32 "i3" OpName %34 "i4" OpName %39 "f_arr" OpName %49 "i_arr" OpName %56 "value" OpDecorate %22 RelaxedPrecision OpDecorate %24 RelaxedPrecision OpDecorate %28 RelaxedPrecision OpDecorate %30 RelaxedPrecision OpDecorate %32 RelaxedPrecision OpDecorate %34 RelaxedPrecision OpDecorate %49 RelaxedPrecision OpDecorate %56 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpTypePointer Function %6 %9 = OpConstantTrue %6 %11 = OpConstantFalse %6 %14 = OpTypeFloat 32 %15 = OpTypePointer Function %14 %17 = OpConstant %14 1.23000002 %19 = OpConstant %14 1.11000001 %20 = OpTypeInt 32 1 %21 = OpTypePointer Function %20 %23 = OpConstant %20 0 %25 = OpConstant %20 1 %26 = OpTypeInt 32 0 %27 = OpTypePointer Function %26 %29 = OpConstant %26 100 %31 = OpConstant %26 0 %33 = OpConstant %20 -1 %35 = OpConstant %20 -99 %36 = OpConstant %26 5 %37 = OpTypeArray %14 %36 %38 = OpTypePointer Function %37 %40 = OpConstant %14 5.5 %41 = OpConstant %14 4.4000001 %42 = OpConstant %14 3.29999995 %43 = OpConstant %14 2.20000005 %44 = OpConstant %14 1.10000002 %45 = OpConstantComposite %37 %40 %41 %42 %43 %44 %46 = OpConstant %26 3 %47 = OpTypeArray %20 %46 %48 = OpTypePointer Function %47 %50 = OpConstant %20 3 %51 = OpConstant %20 7 %52 = OpConstant %20 9 %53 = OpConstantComposite %47 %50 %51 %52 %55 = OpTypePointer Input %14 %56 = OpVariable %55 Input %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %12 = OpVariable %7 Function %13 = OpVariable %7 Function %16 = OpVariable %15 Function %18 = OpVariable %15 Function %22 = OpVariable %21 Function %24 = OpVariable %21 Function %28 = OpVariable %27 Function %30 = OpVariable %27 Function %32 = OpVariable %21 Function %34 = OpVariable %21 Function %39 = OpVariable %38 Function %49 = OpVariable %48 Function OpStore %8 %9 OpStore %10 %11 OpStore %12 %9 OpStore %13 %11 OpStore %16 %17 OpStore %18 %19 OpStore %22 %23 OpStore %24 %25 OpStore %28 %29 OpStore %30 %31 OpStore %32 %33 OpStore %34 %35 OpStore %39 %45 OpStore %49 %53 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const std::unique_ptr context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); opt::IRContext* ir_context = context.get(); std::vector uint_words1 = fuzzerutil::IntToWords(100, 32, false); std::vector uint_words2 = fuzzerutil::IntToWords(0, 32, false); std::vector int_words1 = fuzzerutil::IntToWords(-99, 32, true); std::vector int_words2 = fuzzerutil::IntToWords(1, 32, true); uint32_t float_word1 = fuzzerutil::FloatToWord(1.11f); uint32_t float_word2 = fuzzerutil::FloatToWord(4.4f); // A unsigned int of value 100 that has a scalar type id of 26 exists and its // id is 29. ASSERT_EQ( 29, fuzzerutil::MaybeGetScalarConstant(ir_context, transformation_context, uint_words1, 26, false)); // A unsigned int of value 0 that has a scalar type id of 26 exists and its id // is 29. ASSERT_EQ( 31, fuzzerutil::MaybeGetScalarConstant(ir_context, transformation_context, uint_words2, 26, false)); // A signed int of value -99 that has a scalar type id of 20 exists and its id // is 35. ASSERT_EQ(35, fuzzerutil::MaybeGetScalarConstant( ir_context, transformation_context, int_words1, 20, false)); // A signed int of value 1 that has a scalar type id of 20 exists and its id // is 25. ASSERT_EQ(25, fuzzerutil::MaybeGetScalarConstant( ir_context, transformation_context, int_words2, 20, false)); // A float of value 1.11 that has a scalar type id of 14 exists and its id // is 19. ASSERT_EQ(19, fuzzerutil::MaybeGetScalarConstant( ir_context, transformation_context, std::vector{float_word1}, 14, false)); // A signed int of value 1 that has a scalar type id of 20 exists and its id // is 25. ASSERT_EQ(41, fuzzerutil::MaybeGetScalarConstant( ir_context, transformation_context, std::vector{float_word2}, 14, false)); } TEST(FuzzerutilTest, FuzzerUtilMaybeGetStructTypeTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %92 %52 %53 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %92 BuiltIn FragCoord %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeFloat 32 %8 = OpTypeStruct %6 %7 %9 = OpTypePointer Function %8 %10 = OpTypeFunction %6 %9 %14 = OpConstant %6 0 %15 = OpTypePointer Function %6 %51 = OpTypePointer Private %6 %21 = OpConstant %6 2 %23 = OpConstant %6 1 %24 = OpConstant %7 1 %25 = OpTypePointer Function %7 %50 = OpTypePointer Private %7 %34 = OpTypeBool %35 = OpConstantFalse %34 %52 = OpVariable %50 Private %53 = OpVariable %51 Private %80 = OpConstantComposite %8 %21 %24 %90 = OpTypeVector %7 4 %91 = OpTypePointer Input %90 %92 = OpVariable %91 Input %93 = OpConstantComposite %90 %24 %24 %24 %24 %4 = OpFunction %2 None %3 %5 = OpLabel %20 = OpVariable %9 Function %27 = OpVariable %9 Function %22 = OpAccessChain %15 %20 %14 %44 = OpCopyObject %9 %20 %26 = OpAccessChain %25 %20 %23 %29 = OpFunctionCall %6 %12 %27 %30 = OpAccessChain %15 %20 %14 %45 = OpCopyObject %15 %30 %81 = OpCopyObject %9 %27 %33 = OpAccessChain %15 %20 %14 OpSelectionMerge %37 None OpBranchConditional %35 %36 %37 %36 = OpLabel %38 = OpAccessChain %15 %20 %14 %40 = OpAccessChain %15 %20 %14 %43 = OpAccessChain %15 %20 %14 %82 = OpCopyObject %9 %27 OpBranch %37 %37 = OpLabel OpReturn OpFunctionEnd %12 = OpFunction %6 None %10 %11 = OpFunctionParameter %9 %13 = OpLabel %46 = OpCopyObject %9 %11 %16 = OpAccessChain %15 %11 %14 %95 = OpCopyObject %8 %80 OpReturnValue %21 %100 = OpLabel OpUnreachable OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const std::unique_ptr context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); opt::IRContext* ir_context = context.get(); // 6 and 7 are all valid ids from OpTypeInt and OpTypeFloat // so the result id of 8 should be found. ASSERT_EQ(8, fuzzerutil::MaybeGetStructType(ir_context, std::vector{6, 7})); // |component_type_id| of 16 does not exist in the module, so such a struct // type cannot be found. ASSERT_EQ(0, fuzzerutil::MaybeGetStructType(ir_context, std::vector(6, 16))); // |component_type_id| of 10 is of OpTypeFunction type and thus the struct // cannot be found. ASSERT_EQ(0, fuzzerutil::MaybeGetStructType(ir_context, std::vector(6, 10))); } TEST(FuzzerutilTest, FuzzerUtilMaybeGetVectorTypeTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %92 %52 %53 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %92 BuiltIn FragCoord %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeFloat 32 %8 = OpTypeStruct %6 %7 %9 = OpTypePointer Function %8 %10 = OpTypeFunction %6 %9 %14 = OpConstant %6 0 %15 = OpTypePointer Function %6 %51 = OpTypePointer Private %6 %21 = OpConstant %6 2 %23 = OpConstant %6 1 %24 = OpConstant %7 1 %25 = OpTypePointer Function %7 %50 = OpTypePointer Private %7 %34 = OpTypeBool %35 = OpConstantFalse %34 %52 = OpVariable %50 Private %53 = OpVariable %51 Private %80 = OpConstantComposite %8 %21 %24 %90 = OpTypeVector %7 4 %91 = OpTypePointer Input %90 %92 = OpVariable %91 Input %93 = OpConstantComposite %90 %24 %24 %24 %24 %4 = OpFunction %2 None %3 %5 = OpLabel %20 = OpVariable %9 Function %27 = OpVariable %9 Function %22 = OpAccessChain %15 %20 %14 %44 = OpCopyObject %9 %20 %26 = OpAccessChain %25 %20 %23 %29 = OpFunctionCall %6 %12 %27 %30 = OpAccessChain %15 %20 %14 %45 = OpCopyObject %15 %30 %81 = OpCopyObject %9 %27 %33 = OpAccessChain %15 %20 %14 OpSelectionMerge %37 None OpBranchConditional %35 %36 %37 %36 = OpLabel %38 = OpAccessChain %15 %20 %14 %40 = OpAccessChain %15 %20 %14 %43 = OpAccessChain %15 %20 %14 %82 = OpCopyObject %9 %27 OpBranch %37 %37 = OpLabel OpReturn OpFunctionEnd %12 = OpFunction %6 None %10 %11 = OpFunctionParameter %9 %13 = OpLabel %46 = OpCopyObject %9 %11 %16 = OpAccessChain %15 %11 %14 %95 = OpCopyObject %8 %80 OpReturnValue %21 %100 = OpLabel OpUnreachable OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const std::unique_ptr context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); opt::IRContext* ir_context = context.get(); // The vector type with |element_count| 4 and |component_type_id| 7 // is present and has a result id of 90. ASSERT_EQ(90, fuzzerutil::MaybeGetVectorType(ir_context, 7, 4)); // The vector type with |element_count| 3 and |component_type_id| 7 // is not present in the module. ASSERT_EQ(0, fuzzerutil::MaybeGetVectorType(ir_context, 7, 3)); #ifndef NDEBUG // It should abort with |component_type_id| of 100 // |component_type_id| must be a valid result id of an OpTypeInt, // OpTypeFloat or OpTypeBool instruction in the module. ASSERT_DEATH(fuzzerutil::MaybeGetVectorType(ir_context, 100, 4), "\\|component_type_id\\| is invalid"); // It should abort with |element_count| of 5. // |element_count| must be in the range [2,4]. ASSERT_DEATH(fuzzerutil::MaybeGetVectorType(ir_context, 7, 5), "Precondition: component count must be in range \\[2, 4\\]."); #endif } TEST(FuzzerutilTest, FuzzerUtilMaybeGetVoidTypeTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %92 %52 %53 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %92 BuiltIn FragCoord %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeFloat 32 %8 = OpTypeStruct %6 %7 %9 = OpTypePointer Function %8 %10 = OpTypeFunction %6 %9 %14 = OpConstant %6 0 %15 = OpTypePointer Function %6 %51 = OpTypePointer Private %6 %21 = OpConstant %6 2 %23 = OpConstant %6 1 %24 = OpConstant %7 1 %25 = OpTypePointer Function %7 %50 = OpTypePointer Private %7 %34 = OpTypeBool %35 = OpConstantFalse %34 %52 = OpVariable %50 Private %53 = OpVariable %51 Private %80 = OpConstantComposite %8 %21 %24 %90 = OpTypeVector %7 4 %91 = OpTypePointer Input %90 %92 = OpVariable %91 Input %93 = OpConstantComposite %90 %24 %24 %24 %24 %4 = OpFunction %2 None %3 %5 = OpLabel %20 = OpVariable %9 Function %27 = OpVariable %9 Function %22 = OpAccessChain %15 %20 %14 %44 = OpCopyObject %9 %20 %26 = OpAccessChain %25 %20 %23 %29 = OpFunctionCall %6 %12 %27 %30 = OpAccessChain %15 %20 %14 %45 = OpCopyObject %15 %30 %81 = OpCopyObject %9 %27 %33 = OpAccessChain %15 %20 %14 OpSelectionMerge %37 None OpBranchConditional %35 %36 %37 %36 = OpLabel %38 = OpAccessChain %15 %20 %14 %40 = OpAccessChain %15 %20 %14 %43 = OpAccessChain %15 %20 %14 %82 = OpCopyObject %9 %27 OpBranch %37 %37 = OpLabel OpReturn OpFunctionEnd %12 = OpFunction %6 None %10 %11 = OpFunctionParameter %9 %13 = OpLabel %46 = OpCopyObject %9 %11 %16 = OpAccessChain %15 %11 %14 %95 = OpCopyObject %8 %80 OpReturnValue %21 %100 = OpLabel OpUnreachable OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const std::unique_ptr context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); opt::IRContext* ir_context = context.get(); // A void type with a result id of 2 can be found. ASSERT_EQ(2, fuzzerutil::MaybeGetVoidType(ir_context)); } TEST(FuzzerutilTest, FuzzerUtilMaybeGetZeroConstantTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %56 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "b1" OpName %10 "b2" OpName %12 "b3" OpName %13 "b4" OpName %16 "f1" OpName %18 "f2" OpName %22 "zc" OpName %24 "i1" OpName %28 "i2" OpName %30 "i" OpName %32 "i3" OpName %34 "i4" OpName %39 "f_arr" OpName %49 "i_arr" OpName %56 "value" OpDecorate %22 RelaxedPrecision OpDecorate %24 RelaxedPrecision OpDecorate %28 RelaxedPrecision OpDecorate %30 RelaxedPrecision OpDecorate %32 RelaxedPrecision OpDecorate %34 RelaxedPrecision OpDecorate %49 RelaxedPrecision OpDecorate %56 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpTypePointer Function %6 %9 = OpConstantTrue %6 %11 = OpConstantFalse %6 %14 = OpTypeFloat 32 %15 = OpTypePointer Function %14 %17 = OpConstant %14 1.23000002 %19 = OpConstant %14 1.11000001 %20 = OpTypeInt 32 1 %21 = OpTypePointer Function %20 %23 = OpConstant %20 0 %25 = OpConstant %20 1 %26 = OpTypeInt 32 0 %27 = OpTypePointer Function %26 %29 = OpConstant %26 100 %31 = OpConstant %26 0 %33 = OpConstant %20 -1 %35 = OpConstant %20 -99 %36 = OpConstant %26 5 %37 = OpTypeArray %14 %36 %38 = OpTypePointer Function %37 %40 = OpConstant %14 5.5 %41 = OpConstant %14 4.4000001 %42 = OpConstant %14 3.29999995 %43 = OpConstant %14 2.20000005 %44 = OpConstant %14 1.10000002 %45 = OpConstantComposite %37 %40 %41 %42 %43 %44 %46 = OpConstant %26 3 %47 = OpTypeArray %20 %46 %48 = OpTypePointer Function %47 %50 = OpConstant %20 3 %51 = OpConstant %20 7 %52 = OpConstant %20 9 %53 = OpConstantComposite %47 %50 %51 %52 %55 = OpTypePointer Input %14 %56 = OpVariable %55 Input %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %12 = OpVariable %7 Function %13 = OpVariable %7 Function %16 = OpVariable %15 Function %18 = OpVariable %15 Function %22 = OpVariable %21 Function %24 = OpVariable %21 Function %28 = OpVariable %27 Function %30 = OpVariable %27 Function %32 = OpVariable %21 Function %34 = OpVariable %21 Function %39 = OpVariable %38 Function %49 = OpVariable %48 Function OpStore %8 %9 OpStore %10 %11 OpStore %12 %9 OpStore %13 %11 OpStore %16 %17 OpStore %18 %19 OpStore %22 %23 OpStore %24 %25 OpStore %28 %29 OpStore %30 %31 OpStore %32 %33 OpStore %34 %35 OpStore %39 %45 OpStore %49 %53 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const std::unique_ptr context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); opt::IRContext* ir_context = context.get(); // The id of a boolean constant will be returned give boolean type id 6. uint32_t maybe_bool_id = fuzzerutil::MaybeGetZeroConstant( ir_context, transformation_context, 6, false); // The id of a 32 bit float constant will be returned given the float type // id 14. uint32_t maybe_float_id = fuzzerutil::MaybeGetZeroConstant( ir_context, transformation_context, 14, false); uint32_t maybe_signed_int_id = fuzzerutil::MaybeGetZeroConstant( ir_context, transformation_context, 20, false); uint32_t maybe_unsigned_int_id = fuzzerutil::MaybeGetZeroConstant( ir_context, transformation_context, 26, false); // Lists of possible ids for float, signed int, unsigned int and array. std::vector float_ids{17, 19}; std::vector signed_int_ids{23, 25, 31, 33}; ASSERT_TRUE(maybe_bool_id == 9 || maybe_bool_id == 11); ASSERT_TRUE(std::find(signed_int_ids.begin(), signed_int_ids.end(), maybe_signed_int_id) != signed_int_ids.end()); // There is a unsigned int typed zero constant and its id is 31. ASSERT_EQ(31, maybe_unsigned_int_id); // There is no zero float constant. ASSERT_TRUE(std::find(float_ids.begin(), float_ids.end(), maybe_float_id) == float_ids.end()); } TEST(FuzzerutilTest, TypesAreCompatible) { const std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %9 = OpTypeInt 32 0 %8 = OpTypeStruct %6 %10 = OpTypePointer StorageBuffer %8 %11 = OpVariable %10 StorageBuffer %86 = OpTypeStruct %9 %87 = OpTypePointer Workgroup %86 %88 = OpVariable %87 Workgroup %89 = OpTypePointer Workgroup %9 %19 = OpConstant %9 0 %18 = OpConstant %9 1 %12 = OpConstant %6 0 %13 = OpTypePointer StorageBuffer %6 %15 = OpConstant %6 2 %16 = OpConstant %6 7 %20 = OpConstant %9 64 %4 = OpFunction %2 None %3 %5 = OpLabel %14 = OpAccessChain %13 %11 %12 %90 = OpAccessChain %89 %88 %19 %21 = OpAtomicLoad %6 %14 %15 %20 %22 = OpAtomicExchange %6 %14 %15 %20 %16 %23 = OpAtomicCompareExchange %6 %14 %15 %20 %12 %16 %15 %24 = OpAtomicIIncrement %6 %14 %15 %20 %25 = OpAtomicIDecrement %6 %14 %15 %20 %26 = OpAtomicIAdd %6 %14 %15 %20 %16 %27 = OpAtomicISub %6 %14 %15 %20 %16 %28 = OpAtomicSMin %6 %14 %15 %20 %16 %29 = OpAtomicUMin %9 %90 %15 %20 %18 %30 = OpAtomicSMax %6 %14 %15 %20 %15 %31 = OpAtomicUMax %9 %90 %15 %20 %18 %32 = OpAtomicAnd %6 %14 %15 %20 %16 %33 = OpAtomicOr %6 %14 %15 %20 %16 %34 = OpAtomicXor %6 %14 %15 %20 %16 OpAtomicStore %14 %15 %20 %16 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); const uint32_t int_type = 6; // The id of OpTypeInt 32 1 const uint32_t uint_type = 9; // The id of OpTypeInt 32 0 // OpAtomicLoad #ifndef NDEBUG ASSERT_DEATH( fuzzerutil::TypesAreCompatible(context.get(), spv::Op::OpAtomicLoad, 0, int_type, uint_type), "Signedness check should not occur on a pointer operand."); #endif ASSERT_TRUE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicLoad, 1, int_type, uint_type)); ASSERT_TRUE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicLoad, 2, int_type, uint_type)); // OpAtomicExchange #ifndef NDEBUG ASSERT_DEATH( fuzzerutil::TypesAreCompatible(context.get(), spv::Op::OpAtomicExchange, 0, int_type, uint_type), "Signedness check should not occur on a pointer operand."); #endif ASSERT_TRUE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicExchange, 1, int_type, uint_type)); ASSERT_TRUE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicExchange, 2, int_type, uint_type)); ASSERT_FALSE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicExchange, 3, int_type, uint_type)); // OpAtomicStore #ifndef NDEBUG ASSERT_DEATH( fuzzerutil::TypesAreCompatible(context.get(), spv::Op::OpAtomicStore, 0, int_type, uint_type), "Signedness check should not occur on a pointer operand."); #endif ASSERT_TRUE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicStore, 1, int_type, uint_type)); ASSERT_TRUE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicStore, 2, int_type, uint_type)); ASSERT_FALSE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicStore, 3, int_type, uint_type)); // OpAtomicCompareExchange #ifndef NDEBUG ASSERT_DEATH(fuzzerutil::TypesAreCompatible(context.get(), spv::Op::OpAtomicCompareExchange, 0, int_type, uint_type), "Signedness check should not occur on a pointer operand."); #endif ASSERT_TRUE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicCompareExchange, 1, int_type, uint_type)); ASSERT_TRUE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicCompareExchange, 2, int_type, uint_type)); ASSERT_TRUE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicCompareExchange, 3, int_type, uint_type)); ASSERT_FALSE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicCompareExchange, 4, int_type, uint_type)); // OpAtomicIIncrement #ifndef NDEBUG ASSERT_DEATH( fuzzerutil::TypesAreCompatible(context.get(), spv::Op::OpAtomicIIncrement, 0, int_type, uint_type), "Signedness check should not occur on a pointer operand."); #endif ASSERT_TRUE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicIIncrement, 1, int_type, uint_type)); ASSERT_TRUE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicIIncrement, 2, int_type, uint_type)); // OpAtomicIDecrement #ifndef NDEBUG ASSERT_DEATH( fuzzerutil::TypesAreCompatible(context.get(), spv::Op::OpAtomicStore, 0, int_type, uint_type), "Signedness check should not occur on a pointer operand."); #endif ASSERT_TRUE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicStore, 1, int_type, uint_type)); ASSERT_TRUE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicStore, 2, int_type, uint_type)); // OpAtomicIAdd #ifndef NDEBUG ASSERT_DEATH( fuzzerutil::TypesAreCompatible(context.get(), spv::Op::OpAtomicIAdd, 0, int_type, uint_type), "Signedness check should not occur on a pointer operand."); #endif ASSERT_TRUE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicIAdd, 1, int_type, uint_type)); ASSERT_TRUE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicIAdd, 2, int_type, uint_type)); ASSERT_FALSE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicIAdd, 3, int_type, uint_type)); // OpAtomicISub #ifndef NDEBUG ASSERT_DEATH( fuzzerutil::TypesAreCompatible(context.get(), spv::Op::OpAtomicISub, 0, int_type, uint_type), "Signedness check should not occur on a pointer operand."); #endif ASSERT_TRUE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicISub, 1, int_type, uint_type)); ASSERT_TRUE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicISub, 2, int_type, uint_type)); ASSERT_FALSE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicISub, 3, int_type, uint_type)); // OpAtomicSMin #ifndef NDEBUG ASSERT_DEATH( fuzzerutil::TypesAreCompatible(context.get(), spv::Op::OpAtomicSMin, 0, int_type, uint_type), "Signedness check should not occur on a pointer operand."); #endif ASSERT_TRUE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicSMin, 1, int_type, uint_type)); ASSERT_TRUE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicSMin, 2, int_type, uint_type)); ASSERT_FALSE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicSMin, 3, int_type, uint_type)); // OpAtomicUMin #ifndef NDEBUG ASSERT_DEATH( fuzzerutil::TypesAreCompatible(context.get(), spv::Op::OpAtomicUMin, 0, int_type, uint_type), "Signedness check should not occur on a pointer operand."); #endif ASSERT_TRUE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicUMin, 1, int_type, uint_type)); ASSERT_TRUE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicUMin, 2, int_type, uint_type)); ASSERT_FALSE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicUMin, 3, int_type, uint_type)); // OpAtomicSMax #ifndef NDEBUG ASSERT_DEATH( fuzzerutil::TypesAreCompatible(context.get(), spv::Op::OpAtomicSMax, 0, int_type, uint_type), "Signedness check should not occur on a pointer operand."); #endif ASSERT_TRUE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicSMax, 1, int_type, uint_type)); ASSERT_TRUE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicSMax, 2, int_type, uint_type)); ASSERT_FALSE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicSMax, 3, int_type, uint_type)); // OpAtomicUMax #ifndef NDEBUG ASSERT_DEATH( fuzzerutil::TypesAreCompatible(context.get(), spv::Op::OpAtomicUMax, 0, int_type, uint_type), "Signedness check should not occur on a pointer operand."); #endif ASSERT_TRUE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicUMax, 1, int_type, uint_type)); ASSERT_TRUE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicUMax, 2, int_type, uint_type)); ASSERT_FALSE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicUMax, 3, int_type, uint_type)); // OpAtomicAnd #ifndef NDEBUG ASSERT_DEATH(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicAnd, 0, int_type, uint_type), "Signedness check should not occur on a pointer operand."); #endif ASSERT_TRUE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicAnd, 1, int_type, uint_type)); ASSERT_TRUE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicAnd, 2, int_type, uint_type)); ASSERT_FALSE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicAnd, 3, int_type, uint_type)); // OpAtomicOr #ifndef NDEBUG ASSERT_DEATH(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicOr, 0, int_type, uint_type), "Signedness check should not occur on a pointer operand."); #endif ASSERT_TRUE(fuzzerutil::TypesAreCompatible(context.get(), spv::Op::OpAtomicOr, 1, int_type, uint_type)); ASSERT_TRUE(fuzzerutil::TypesAreCompatible(context.get(), spv::Op::OpAtomicOr, 2, int_type, uint_type)); ASSERT_FALSE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicOr, 3, int_type, uint_type)); // OpAtomicXor #ifndef NDEBUG ASSERT_DEATH(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicXor, 0, int_type, uint_type), "Signedness check should not occur on a pointer operand."); #endif ASSERT_TRUE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicXor, 1, int_type, uint_type)); ASSERT_TRUE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicXor, 2, int_type, uint_type)); ASSERT_FALSE(fuzzerutil::TypesAreCompatible( context.get(), spv::Op::OpAtomicXor, 3, int_type, uint_type)); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/instruction_descriptor_test.cpp000066400000000000000000000046731475742701700271020ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/instruction_descriptor.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(InstructionDescriptorTest, BasicTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %10 = OpTypeInt 32 1 %11 = OpTypePointer Function %10 %13 = OpConstant %10 2 %32 = OpConstant %10 0 %4 = OpFunction %2 None %3 %5 = OpLabel %164 = OpVariable %11 Function %165 = OpVariable %11 Function OpBranch %16 %16 = OpLabel OpStore %164 %32 OpStore %165 %13 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); for (auto& function : *context->module()) { for (auto& block : function) { for (auto inst_it = block.cbegin(); inst_it != block.cend(); ++inst_it) { ASSERT_EQ(&*inst_it, FindInstruction(MakeInstructionDescriptor(block, inst_it), context.get())); } } } } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/replayer_test.cpp000066400000000000000000000401461475742701700241010ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/replayer.h" #include "gtest/gtest.h" #include "source/fuzz/data_descriptor.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/transformation_add_constant_scalar.h" #include "source/fuzz/transformation_add_global_variable.h" #include "source/fuzz/transformation_add_parameter.h" #include "source/fuzz/transformation_add_synonym.h" #include "source/fuzz/transformation_flatten_conditional_branch.h" #include "source/fuzz/transformation_split_block.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(ReplayerTest, PartialReplay) { const std::string kTestShader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "g" OpName %11 "x" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Private %6 %8 = OpVariable %7 Private %9 = OpConstant %6 10 %10 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %5 = OpLabel %11 = OpVariable %10 Function OpStore %8 %9 %12 = OpLoad %6 %8 OpStore %11 %12 %13 = OpLoad %6 %8 OpStore %11 %13 %14 = OpLoad %6 %8 OpStore %11 %14 %15 = OpLoad %6 %8 OpStore %11 %15 %16 = OpLoad %6 %8 OpStore %11 %16 %17 = OpLoad %6 %8 OpStore %11 %17 %18 = OpLoad %6 %8 OpStore %11 %18 %19 = OpLoad %6 %8 OpStore %11 %19 %20 = OpLoad %6 %8 OpStore %11 %20 %21 = OpLoad %6 %8 OpStore %11 %21 %22 = OpLoad %6 %8 OpStore %11 %22 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; spvtools::ValidatorOptions validator_options; std::vector binary_in; SpirvTools t(env); t.SetMessageConsumer(kConsoleMessageConsumer); ASSERT_TRUE(t.Assemble(kTestShader, &binary_in, kFuzzAssembleOption)); ASSERT_TRUE(t.Validate(binary_in)); protobufs::TransformationSequence transformations; for (uint32_t id = 12; id <= 22; id++) { *transformations.add_transformation() = TransformationSplitBlock( MakeInstructionDescriptor(id, spv::Op::OpLoad, 0), id + 100) .ToMessage(); } { // Full replay protobufs::FactSequence empty_facts; auto replayer_result = Replayer(env, kConsoleMessageConsumer, binary_in, empty_facts, transformations, 11, true, validator_options) .Run(); // Replay should succeed. ASSERT_EQ(Replayer::ReplayerResultStatus::kComplete, replayer_result.status); // All transformations should be applied. ASSERT_TRUE(google::protobuf::util::MessageDifferencer::Equals( transformations, replayer_result.applied_transformations)); const std::string kFullySplitShader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "g" OpName %11 "x" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Private %6 %8 = OpVariable %7 Private %9 = OpConstant %6 10 %10 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %5 = OpLabel %11 = OpVariable %10 Function OpStore %8 %9 OpBranch %112 %112 = OpLabel %12 = OpLoad %6 %8 OpStore %11 %12 OpBranch %113 %113 = OpLabel %13 = OpLoad %6 %8 OpStore %11 %13 OpBranch %114 %114 = OpLabel %14 = OpLoad %6 %8 OpStore %11 %14 OpBranch %115 %115 = OpLabel %15 = OpLoad %6 %8 OpStore %11 %15 OpBranch %116 %116 = OpLabel %16 = OpLoad %6 %8 OpStore %11 %16 OpBranch %117 %117 = OpLabel %17 = OpLoad %6 %8 OpStore %11 %17 OpBranch %118 %118 = OpLabel %18 = OpLoad %6 %8 OpStore %11 %18 OpBranch %119 %119 = OpLabel %19 = OpLoad %6 %8 OpStore %11 %19 OpBranch %120 %120 = OpLabel %20 = OpLoad %6 %8 OpStore %11 %20 OpBranch %121 %121 = OpLabel %21 = OpLoad %6 %8 OpStore %11 %21 OpBranch %122 %122 = OpLabel %22 = OpLoad %6 %8 OpStore %11 %22 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, kFullySplitShader, replayer_result.transformed_module.get())); } { // Half replay protobufs::FactSequence empty_facts; auto replayer_result = Replayer(env, kConsoleMessageConsumer, binary_in, empty_facts, transformations, 5, true, validator_options) .Run(); // Replay should succeed. ASSERT_EQ(Replayer::ReplayerResultStatus::kComplete, replayer_result.status); // The first 5 transformations should be applied ASSERT_EQ(5, replayer_result.applied_transformations.transformation_size()); for (uint32_t i = 0; i < 5; i++) { ASSERT_TRUE(google::protobuf::util::MessageDifferencer::Equals( transformations.transformation(i), replayer_result.applied_transformations.transformation(i))); } const std::string kHalfSplitShader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "g" OpName %11 "x" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Private %6 %8 = OpVariable %7 Private %9 = OpConstant %6 10 %10 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %5 = OpLabel %11 = OpVariable %10 Function OpStore %8 %9 OpBranch %112 %112 = OpLabel %12 = OpLoad %6 %8 OpStore %11 %12 OpBranch %113 %113 = OpLabel %13 = OpLoad %6 %8 OpStore %11 %13 OpBranch %114 %114 = OpLabel %14 = OpLoad %6 %8 OpStore %11 %14 OpBranch %115 %115 = OpLabel %15 = OpLoad %6 %8 OpStore %11 %15 OpBranch %116 %116 = OpLabel %16 = OpLoad %6 %8 OpStore %11 %16 %17 = OpLoad %6 %8 OpStore %11 %17 %18 = OpLoad %6 %8 OpStore %11 %18 %19 = OpLoad %6 %8 OpStore %11 %19 %20 = OpLoad %6 %8 OpStore %11 %20 %21 = OpLoad %6 %8 OpStore %11 %21 %22 = OpLoad %6 %8 OpStore %11 %22 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, kHalfSplitShader, replayer_result.transformed_module.get())); } { // Empty replay protobufs::FactSequence empty_facts; auto replayer_result = Replayer(env, kConsoleMessageConsumer, binary_in, empty_facts, transformations, 0, true, validator_options) .Run(); // Replay should succeed. ASSERT_EQ(Replayer::ReplayerResultStatus::kComplete, replayer_result.status); // No transformations should be applied ASSERT_EQ(0, replayer_result.applied_transformations.transformation_size()); ASSERT_TRUE( IsEqual(env, kTestShader, replayer_result.transformed_module.get())); } { // Invalid replay: too many transformations protobufs::FactSequence empty_facts; // The number of transformations requested to be applied exceeds the number // of transformations auto replayer_result = Replayer(env, kConsoleMessageConsumer, binary_in, empty_facts, transformations, 12, true, validator_options) .Run(); // Replay should not succeed. ASSERT_EQ(Replayer::ReplayerResultStatus::kTooManyTransformationsRequested, replayer_result.status); // No transformations should be applied ASSERT_EQ(0, replayer_result.applied_transformations.transformation_size()); // The output binary should be empty ASSERT_EQ(nullptr, replayer_result.transformed_module); } } TEST(ReplayerTest, CheckFactsAfterReplay) { const std::string kTestShader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %50 = OpTypePointer Private %8 %11 = OpConstant %8 1 %4 = OpFunction %2 None %3 %5 = OpLabel %10 = OpVariable %9 Function OpStore %10 %11 %12 = OpFunctionCall %2 %6 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; spvtools::ValidatorOptions validator_options; std::vector binary_in; SpirvTools t(env); t.SetMessageConsumer(kConsoleMessageConsumer); ASSERT_TRUE(t.Assemble(kTestShader, &binary_in, kFuzzAssembleOption)); ASSERT_TRUE(t.Validate(binary_in)); protobufs::TransformationSequence transformations; *transformations.add_transformation() = TransformationAddConstantScalar(100, 8, {42}, true).ToMessage(); *transformations.add_transformation() = TransformationAddGlobalVariable(101, 50, spv::StorageClass::Private, 100, true) .ToMessage(); *transformations.add_transformation() = TransformationAddParameter(6, 102, 8, {{12, 100}}, 103).ToMessage(); *transformations.add_transformation() = TransformationAddSynonym( 11, protobufs::TransformationAddSynonym::SynonymType:: TransformationAddSynonym_SynonymType_COPY_OBJECT, 104, MakeInstructionDescriptor(12, spv::Op::OpFunctionCall, 0)) .ToMessage(); // Full replay protobufs::FactSequence empty_facts; auto replayer_result = Replayer(env, kConsoleMessageConsumer, binary_in, empty_facts, transformations, transformations.transformation_size(), true, validator_options) .Run(); // Replay should succeed. ASSERT_EQ(Replayer::ReplayerResultStatus::kComplete, replayer_result.status); // All transformations should be applied. ASSERT_TRUE(google::protobuf::util::MessageDifferencer::Equals( transformations, replayer_result.applied_transformations)); const std::string kExpected = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %50 = OpTypePointer Private %8 %11 = OpConstant %8 1 %100 = OpConstant %8 42 %101 = OpVariable %50 Private %100 %103 = OpTypeFunction %2 %8 %4 = OpFunction %2 None %3 %5 = OpLabel %10 = OpVariable %9 Function OpStore %10 %11 %104 = OpCopyObject %8 %11 %12 = OpFunctionCall %2 %6 %100 OpReturn OpFunctionEnd %6 = OpFunction %2 None %103 %102 = OpFunctionParameter %8 %7 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE( IsEqual(env, kExpected, replayer_result.transformed_module.get())); ASSERT_TRUE( replayer_result.transformation_context->GetFactManager()->IdIsIrrelevant( 100)); ASSERT_TRUE(replayer_result.transformation_context->GetFactManager() ->PointeeValueIsIrrelevant(101)); ASSERT_TRUE( replayer_result.transformation_context->GetFactManager()->IdIsIrrelevant( 102)); ASSERT_TRUE( replayer_result.transformation_context->GetFactManager()->IsSynonymous( MakeDataDescriptor(11, {}), MakeDataDescriptor(104, {}))); } TEST(ReplayerTest, ReplayWithOverflowIds) { const std::string kTestShader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %50 = OpTypePointer Private %6 %9 = OpConstant %6 2 %11 = OpConstant %6 0 %12 = OpTypeBool %17 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpStore %8 %9 %10 = OpLoad %6 %8 %13 = OpSGreaterThan %12 %10 %11 OpSelectionMerge %15 None OpBranchConditional %13 %14 %15 %14 = OpLabel %16 = OpLoad %6 %8 %18 = OpIAdd %6 %16 %17 OpStore %8 %18 OpBranch %15 %15 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; spvtools::ValidatorOptions validator_options; std::vector binary_in; SpirvTools t(env); t.SetMessageConsumer(kConsoleMessageConsumer); ASSERT_TRUE(t.Assemble(kTestShader, &binary_in, kFuzzAssembleOption)); ASSERT_TRUE(t.Validate(binary_in)); protobufs::TransformationSequence transformations; *transformations.add_transformation() = TransformationFlattenConditionalBranch(5, true, 0, 0, 0, {}).ToMessage(); *transformations.add_transformation() = TransformationAddGlobalVariable(101, 50, spv::StorageClass::Private, 11, true) .ToMessage(); protobufs::FactSequence empty_facts; auto replayer_result = Replayer(env, kConsoleMessageConsumer, binary_in, empty_facts, transformations, transformations.transformation_size(), true, validator_options) .Run(); // Replay should succeed. ASSERT_EQ(Replayer::ReplayerResultStatus::kComplete, replayer_result.status); // All transformations should be applied. ASSERT_EQ(2, replayer_result.applied_transformations.transformation_size()); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/shrinker_test.cpp000066400000000000000000000324501475742701700241020ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/shrinker.h" #include "gtest/gtest.h" #include "source/fuzz/fact_manager/fact_manager.h" #include "source/fuzz/fuzzer_context.h" #include "source/fuzz/fuzzer_pass_donate_modules.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/pseudo_random_generator.h" #include "source/fuzz/transformation_context.h" #include "source/opt/ir_context.h" #include "source/util/make_unique.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(ShrinkerTest, ReduceAddedFunctions) { const std::string kReferenceModule = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Private %6 %8 = OpVariable %7 Private %9 = OpConstant %6 2 %10 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %5 = OpLabel %11 = OpVariable %10 Function OpStore %8 %9 %12 = OpLoad %6 %8 OpStore %11 %12 OpReturn OpFunctionEnd )"; const std::string kDonorModule = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %6 %7 %12 = OpTypeFunction %2 %7 %17 = OpConstant %6 0 %26 = OpTypeBool %32 = OpConstant %6 1 %46 = OpTypePointer Private %6 %47 = OpVariable %46 Private %48 = OpConstant %6 3 %4 = OpFunction %2 None %3 %5 = OpLabel %49 = OpVariable %7 Function %50 = OpVariable %7 Function %51 = OpLoad %6 %49 OpStore %50 %51 %52 = OpFunctionCall %2 %14 %50 OpReturn OpFunctionEnd %10 = OpFunction %6 None %8 %9 = OpFunctionParameter %7 %11 = OpLabel %16 = OpVariable %7 Function %18 = OpVariable %7 Function OpStore %16 %17 OpStore %18 %17 OpBranch %19 %19 = OpLabel OpLoopMerge %21 %22 None OpBranch %23 %23 = OpLabel %24 = OpLoad %6 %18 %25 = OpLoad %6 %9 %27 = OpSLessThan %26 %24 %25 OpBranchConditional %27 %20 %21 %20 = OpLabel %28 = OpLoad %6 %9 %29 = OpLoad %6 %16 %30 = OpIAdd %6 %29 %28 OpStore %16 %30 OpBranch %22 %22 = OpLabel %31 = OpLoad %6 %18 %33 = OpIAdd %6 %31 %32 OpStore %18 %33 OpBranch %19 %21 = OpLabel %34 = OpLoad %6 %16 %35 = OpNot %6 %34 OpReturnValue %35 OpFunctionEnd %14 = OpFunction %2 None %12 %13 = OpFunctionParameter %7 %15 = OpLabel %37 = OpVariable %7 Function %38 = OpVariable %7 Function %39 = OpLoad %6 %13 OpStore %38 %39 %40 = OpFunctionCall %6 %10 %38 OpStore %37 %40 %41 = OpLoad %6 %37 %42 = OpLoad %6 %13 %43 = OpSGreaterThan %26 %41 %42 OpSelectionMerge %45 None OpBranchConditional %43 %44 %45 %44 = OpLabel OpStore %47 %48 OpBranch %45 %45 = OpLabel OpReturn OpFunctionEnd )"; // Note: |env| should ideally be declared const. However, due to a known // issue with older versions of MSVC we would have to mark |env| as being // captured due to its used in a lambda below, and other compilers would warn // that such capturing is not necessary. Not declaring |env| as const means // that it needs to be captured to be used in the lambda, and thus all // compilers are kept happy. See: // https://developercommunity.visualstudio.com/content/problem/367326/problems-with-capturing-constexpr-in-lambda.html spv_target_env env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = fuzzerutil::kSilentMessageConsumer; SpirvTools tools(env); std::vector reference_binary; ASSERT_TRUE( tools.Assemble(kReferenceModule, &reference_binary, kFuzzAssembleOption)); spvtools::ValidatorOptions validator_options; const auto variant_ir_context = BuildModule(env, consumer, kReferenceModule, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( variant_ir_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_ir_context = BuildModule(env, consumer, kDonorModule, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_ir_context.get(), validator_options, kConsoleMessageConsumer)); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); TransformationContext transformation_context( MakeUnique(variant_ir_context.get()), validator_options); protobufs::TransformationSequence transformations; FuzzerPassDonateModules pass(variant_ir_context.get(), &transformation_context, &fuzzer_context, &transformations, false, {}); pass.DonateSingleModule(donor_ir_context.get(), true); protobufs::FactSequence no_facts; Shrinker::InterestingnessFunction interestingness_function = [consumer, env](const std::vector& binary, uint32_t /*unused*/) -> bool { bool found_op_not = false; uint32_t op_call_count = 0; auto temp_ir_context = BuildModule(env, consumer, binary.data(), binary.size()); for (auto& function : *temp_ir_context->module()) { for (auto& block : function) { for (auto& inst : block) { if (inst.opcode() == spv::Op::OpNot) { found_op_not = true; } else if (inst.opcode() == spv::Op::OpFunctionCall) { op_call_count++; } } } } return found_op_not && op_call_count >= 2; }; auto shrinker_result = Shrinker(env, consumer, reference_binary, no_facts, transformations, interestingness_function, 1000, true, validator_options) .Run(); ASSERT_EQ(Shrinker::ShrinkerResultStatus::kComplete, shrinker_result.status); // We now check that the module after shrinking looks right. // The entry point should be identical to what it looked like in the // reference, while the other functions should be absolutely minimal, // containing only what is needed to satisfy the interestingness function. auto ir_context_after_shrinking = BuildModule(env, consumer, shrinker_result.transformed_binary.data(), shrinker_result.transformed_binary.size()); bool first_function = true; for (auto& function : *ir_context_after_shrinking->module()) { if (first_function) { first_function = false; bool first_block = true; for (auto& block : function) { ASSERT_TRUE(first_block); uint32_t counter = 0; for (auto& inst : block) { switch (counter) { case 0: ASSERT_EQ(spv::Op::OpVariable, inst.opcode()); ASSERT_EQ(11, inst.result_id()); break; case 1: ASSERT_EQ(spv::Op::OpStore, inst.opcode()); break; case 2: ASSERT_EQ(spv::Op::OpLoad, inst.opcode()); ASSERT_EQ(12, inst.result_id()); break; case 3: ASSERT_EQ(spv::Op::OpStore, inst.opcode()); break; case 4: ASSERT_EQ(spv::Op::OpReturn, inst.opcode()); break; default: FAIL(); } counter++; } } } else { bool first_block = true; for (auto& block : function) { ASSERT_TRUE(first_block); first_block = false; for (auto& inst : block) { switch (inst.opcode()) { case spv::Op::OpVariable: case spv::Op::OpNot: case spv::Op::OpReturn: case spv::Op::OpReturnValue: case spv::Op::OpFunctionCall: // These are the only instructions we expect to see. break; default: FAIL(); } } } } } } TEST(ShrinkerTest, HitStepLimitWhenReducingAddedFunctions) { const std::string kReferenceModule = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Private %6 %8 = OpVariable %7 Private %9 = OpConstant %6 2 %10 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %5 = OpLabel %11 = OpVariable %10 Function OpStore %8 %9 %12 = OpLoad %6 %8 OpStore %11 %12 OpReturn OpFunctionEnd )"; const std::string kDonorModule = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %48 = OpConstant %6 3 %4 = OpFunction %2 None %3 %5 = OpLabel %52 = OpCopyObject %6 %48 %53 = OpCopyObject %6 %52 %54 = OpCopyObject %6 %53 %55 = OpCopyObject %6 %54 %56 = OpCopyObject %6 %55 %57 = OpCopyObject %6 %56 %58 = OpCopyObject %6 %48 %59 = OpCopyObject %6 %58 %60 = OpCopyObject %6 %59 %61 = OpCopyObject %6 %60 %62 = OpCopyObject %6 %61 %63 = OpCopyObject %6 %62 %64 = OpCopyObject %6 %48 OpReturn OpFunctionEnd )"; spv_target_env env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = fuzzerutil::kSilentMessageConsumer; SpirvTools tools(env); std::vector reference_binary; ASSERT_TRUE( tools.Assemble(kReferenceModule, &reference_binary, kFuzzAssembleOption)); spvtools::ValidatorOptions validator_options; const auto variant_ir_context = BuildModule(env, consumer, kReferenceModule, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( variant_ir_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_ir_context = BuildModule(env, consumer, kDonorModule, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_ir_context.get(), validator_options, kConsoleMessageConsumer)); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); TransformationContext transformation_context( MakeUnique(variant_ir_context.get()), validator_options); protobufs::TransformationSequence transformations; FuzzerPassDonateModules pass(variant_ir_context.get(), &transformation_context, &fuzzer_context, &transformations, false, {}); pass.DonateSingleModule(donor_ir_context.get(), true); protobufs::FactSequence no_facts; Shrinker::InterestingnessFunction interestingness_function = [consumer, env](const std::vector& binary, uint32_t /*unused*/) -> bool { auto temp_ir_context = BuildModule(env, consumer, binary.data(), binary.size()); uint32_t copy_object_count = 0; temp_ir_context->module()->ForEachInst( [©_object_count](opt::Instruction* inst) { if (inst->opcode() == spv::Op::OpCopyObject) { copy_object_count++; } }); return copy_object_count >= 8; }; auto shrinker_result = Shrinker(env, consumer, reference_binary, no_facts, transformations, interestingness_function, 30, true, validator_options) .Run(); ASSERT_EQ(Shrinker::ShrinkerResultStatus::kStepLimitReached, shrinker_result.status); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_access_chain_test.cpp000066400000000000000000000734741475742701700300210ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_access_chain.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationAccessChainTest, BasicTest) { std::string shader = R"( OpCapability Shader OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %48 %54 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 2 %50 = OpTypeMatrix %7 2 %70 = OpTypePointer Function %7 %71 = OpTypePointer Function %50 %8 = OpTypeStruct %7 %6 %9 = OpTypePointer Function %8 %10 = OpTypeInt 32 1 %11 = OpTypePointer Function %10 %12 = OpTypeFunction %10 %9 %11 %17 = OpConstant %10 0 %18 = OpTypeInt 32 0 %19 = OpConstant %18 0 %20 = OpTypePointer Function %6 %99 = OpTypePointer Private %6 %29 = OpConstant %6 0 %30 = OpConstant %6 1 %31 = OpConstantComposite %7 %29 %30 %32 = OpConstant %6 2 %33 = OpConstantComposite %8 %31 %32 %35 = OpConstant %10 10 %51 = OpConstant %18 10 %80 = OpConstant %18 0 %81 = OpConstant %10 1 %82 = OpConstant %18 2 %83 = OpConstant %10 3 %84 = OpConstant %18 4 %85 = OpConstant %10 5 %52 = OpTypeArray %50 %51 %53 = OpTypePointer Private %52 %46 = OpConstantNull %9 %47 = OpTypePointer Private %8 %48 = OpVariable %47 Private %54 = OpVariable %53 Private %4 = OpFunction %2 None %3 %5 = OpLabel %28 = OpVariable %9 Function %34 = OpVariable %11 Function %36 = OpVariable %9 Function %38 = OpVariable %11 Function %44 = OpCopyObject %9 %36 OpStore %28 %33 OpStore %34 %35 %37 = OpLoad %8 %28 OpStore %36 %37 %39 = OpLoad %10 %34 OpStore %38 %39 %40 = OpFunctionCall %10 %15 %36 %38 %41 = OpLoad %10 %34 %42 = OpIAdd %10 %41 %40 OpStore %34 %42 OpReturn OpFunctionEnd %15 = OpFunction %10 None %12 %13 = OpFunctionParameter %9 %14 = OpFunctionParameter %11 %16 = OpLabel %21 = OpAccessChain %20 %13 %17 %19 %43 = OpCopyObject %9 %13 %22 = OpLoad %6 %21 %23 = OpConvertFToS %10 %22 %24 = OpLoad %10 %14 %25 = OpIAdd %10 %23 %24 OpReturnValue %25 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Types: // Ptr | Pointee | Storage class | GLSL for pointee | Ids of this type // ----+---------+---------------+---------------------+------------------ // 9 | 8 | Function | struct(vec2, float) | 28, 36, 44, 13, 43 // 11 | 10 | Function | int | 34, 38, 14 // 20 | 6 | Function | float | - // 99 | 6 | Private | float | - // 53 | 52 | Private | mat2x2[10] | 54 // 47 | 8 | Private | struct(vec2, float) | 48 // 70 | 7 | Function | vec2 | - // 71 | 59 | Function | mat2x2 | - // Indices 0-5 are in ids 80-85 TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactValueOfPointeeIsIrrelevant( 54); // Check the case where the index type is not a 32-bit integer. TransformationAccessChain invalid_index_example1( 101, 28, {29}, MakeInstructionDescriptor(42, spv::Op::OpReturn, 0)); // Since the index is not a 32-bit integer type but a 32-bit float type, // ValidIndexComposite should return false and thus the transformation is not // applicable. ASSERT_FALSE(invalid_index_example1.IsApplicable(context.get(), transformation_context)); // Bad: id is not fresh ASSERT_FALSE( TransformationAccessChain( 43, 43, {80}, MakeInstructionDescriptor(24, spv::Op::OpLoad, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: pointer id does not exist ASSERT_FALSE( TransformationAccessChain( 100, 1000, {80}, MakeInstructionDescriptor(24, spv::Op::OpLoad, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: pointer id is not a type ASSERT_FALSE( TransformationAccessChain( 100, 5, {80}, MakeInstructionDescriptor(24, spv::Op::OpLoad, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: pointer id is not a pointer ASSERT_FALSE( TransformationAccessChain( 100, 23, {80}, MakeInstructionDescriptor(24, spv::Op::OpLoad, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: index id does not exist ASSERT_FALSE( TransformationAccessChain( 100, 43, {1000}, MakeInstructionDescriptor(24, spv::Op::OpLoad, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: index id is not a constant and the pointer refers to a struct ASSERT_FALSE( TransformationAccessChain( 100, 43, {24}, MakeInstructionDescriptor(25, spv::Op::OpIAdd, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: too many indices ASSERT_FALSE(TransformationAccessChain( 100, 43, {80, 80, 80}, MakeInstructionDescriptor(24, spv::Op::OpLoad, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: index id is out of bounds when accessing a struct ASSERT_FALSE( TransformationAccessChain( 100, 43, {83, 80}, MakeInstructionDescriptor(24, spv::Op::OpLoad, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: attempt to insert before variable ASSERT_FALSE( TransformationAccessChain( 100, 34, {}, MakeInstructionDescriptor(36, spv::Op::OpVariable, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: OpTypeBool must be present in the module to clamp an index ASSERT_FALSE( TransformationAccessChain( 100, 36, {80, 81}, MakeInstructionDescriptor(37, spv::Op::OpStore, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: pointer not available ASSERT_FALSE(TransformationAccessChain( 100, 43, {80}, MakeInstructionDescriptor(21, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: instruction descriptor does not identify anything ASSERT_FALSE( TransformationAccessChain( 100, 43, {80}, MakeInstructionDescriptor(24, spv::Op::OpLoad, 100)) .IsApplicable(context.get(), transformation_context)); #ifndef NDEBUG // Bad: pointer is null ASSERT_DEATH( TransformationAccessChain( 100, 46, {80}, MakeInstructionDescriptor(24, spv::Op::OpLoad, 0)) .IsApplicable(context.get(), transformation_context), "Access chains should not be created from null/undefined pointers"); #endif // Bad: pointer to result type does not exist ASSERT_FALSE( TransformationAccessChain( 100, 52, {0}, MakeInstructionDescriptor(24, spv::Op::OpLoad, 0)) .IsApplicable(context.get(), transformation_context)); { TransformationAccessChain transformation( 100, 43, {80}, MakeInstructionDescriptor(24, spv::Op::OpLoad, 0)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_FALSE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(100)); } { TransformationAccessChain transformation( 101, 28, {81}, MakeInstructionDescriptor(42, spv::Op::OpReturn, 0)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_FALSE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(101)); } { TransformationAccessChain transformation( 102, 44, {}, MakeInstructionDescriptor(44, spv::Op::OpStore, 0)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_FALSE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(103)); } { TransformationAccessChain transformation( 103, 13, {80}, MakeInstructionDescriptor(21, spv::Op::OpAccessChain, 0)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_FALSE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(104)); } { TransformationAccessChain transformation( 104, 34, {}, MakeInstructionDescriptor(44, spv::Op::OpStore, 1)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_FALSE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(105)); } { TransformationAccessChain transformation( 105, 38, {}, MakeInstructionDescriptor(40, spv::Op::OpFunctionCall, 0)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_FALSE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(106)); } { TransformationAccessChain transformation( 106, 14, {}, MakeInstructionDescriptor(24, spv::Op::OpLoad, 0)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_FALSE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(107)); } { // Check the case where the access chain's base pointer has the irrelevant // pointee fact; the resulting access chain should inherit this fact. TransformationAccessChain transformation( 107, 54, {}, MakeInstructionDescriptor(24, spv::Op::OpLoad, 0)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(54)); } std::string after_transformation = R"( OpCapability Shader OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %48 %54 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 2 %50 = OpTypeMatrix %7 2 %70 = OpTypePointer Function %7 %71 = OpTypePointer Function %50 %8 = OpTypeStruct %7 %6 %9 = OpTypePointer Function %8 %10 = OpTypeInt 32 1 %11 = OpTypePointer Function %10 %12 = OpTypeFunction %10 %9 %11 %17 = OpConstant %10 0 %18 = OpTypeInt 32 0 %19 = OpConstant %18 0 %20 = OpTypePointer Function %6 %99 = OpTypePointer Private %6 %29 = OpConstant %6 0 %30 = OpConstant %6 1 %31 = OpConstantComposite %7 %29 %30 %32 = OpConstant %6 2 %33 = OpConstantComposite %8 %31 %32 %35 = OpConstant %10 10 %51 = OpConstant %18 10 %80 = OpConstant %18 0 %81 = OpConstant %10 1 %82 = OpConstant %18 2 %83 = OpConstant %10 3 %84 = OpConstant %18 4 %85 = OpConstant %10 5 %52 = OpTypeArray %50 %51 %53 = OpTypePointer Private %52 %46 = OpConstantNull %9 %47 = OpTypePointer Private %8 %48 = OpVariable %47 Private %54 = OpVariable %53 Private %4 = OpFunction %2 None %3 %5 = OpLabel %28 = OpVariable %9 Function %34 = OpVariable %11 Function %36 = OpVariable %9 Function %38 = OpVariable %11 Function %44 = OpCopyObject %9 %36 %102 = OpAccessChain %9 %44 OpStore %28 %33 %104 = OpAccessChain %11 %34 OpStore %34 %35 %37 = OpLoad %8 %28 OpStore %36 %37 %39 = OpLoad %10 %34 OpStore %38 %39 %105 = OpAccessChain %11 %38 %40 = OpFunctionCall %10 %15 %36 %38 %41 = OpLoad %10 %34 %42 = OpIAdd %10 %41 %40 OpStore %34 %42 %101 = OpAccessChain %20 %28 %81 OpReturn OpFunctionEnd %15 = OpFunction %10 None %12 %13 = OpFunctionParameter %9 %14 = OpFunctionParameter %11 %16 = OpLabel %103 = OpAccessChain %70 %13 %80 %21 = OpAccessChain %20 %13 %17 %19 %43 = OpCopyObject %9 %13 %22 = OpLoad %6 %21 %23 = OpConvertFToS %10 %22 %100 = OpAccessChain %70 %43 %80 %106 = OpAccessChain %11 %14 %107 = OpAccessChain %53 %54 %24 = OpLoad %10 %14 %25 = OpIAdd %10 %23 %24 OpReturnValue %25 OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationAccessChainTest, StructIndexMustBeConstant) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %20 = OpUndef %6 %7 = OpTypeStruct %6 %6 %8 = OpTypePointer Function %7 %10 = OpConstant %6 0 %11 = OpConstant %6 2 %12 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %5 = OpLabel %9 = OpVariable %8 Function OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Bad: %9 is a pointer to a struct, but %20 is not a constant. ASSERT_FALSE( TransformationAccessChain( 100, 9, {20}, MakeInstructionDescriptor(9, spv::Op::OpReturn, 0)) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationAccessChainTest, IsomorphicStructs) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %11 %12 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeStruct %6 %8 = OpTypePointer Private %7 %9 = OpTypeStruct %6 %10 = OpTypePointer Private %9 %11 = OpVariable %8 Private %12 = OpVariable %10 Private %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); { TransformationAccessChain transformation( 100, 11, {}, MakeInstructionDescriptor(5, spv::Op::OpReturn, 0)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } { TransformationAccessChain transformation( 101, 12, {}, MakeInstructionDescriptor(5, spv::Op::OpReturn, 0)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %11 %12 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeStruct %6 %8 = OpTypePointer Private %7 %9 = OpTypeStruct %6 %10 = OpTypePointer Private %9 %11 = OpVariable %8 Private %12 = OpVariable %10 Private %4 = OpFunction %2 None %3 %5 = OpLabel %100 = OpAccessChain %8 %11 %101 = OpAccessChain %10 %12 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationAccessChainTest, ClampingVariables) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %4 = OpTypeVoid %5 = OpTypeBool %6 = OpTypeFunction %4 %7 = OpTypeInt 32 1 %8 = OpTypeVector %7 4 %9 = OpTypePointer Function %8 %10 = OpConstant %7 0 %11 = OpConstant %7 1 %12 = OpConstant %7 3 %13 = OpConstant %7 2 %14 = OpConstantComposite %8 %10 %11 %12 %13 %15 = OpTypePointer Function %7 %16 = OpTypeInt 32 0 %17 = OpConstant %16 1 %18 = OpConstant %16 3 %19 = OpTypeStruct %8 %20 = OpTypePointer Function %19 %21 = OpConstant %7 9 %22 = OpConstant %16 10 %23 = OpTypeArray %19 %22 %24 = OpTypePointer Function %23 %25 = OpTypeFloat 32 %26 = OpTypeVector %25 4 %27 = OpTypePointer Output %26 %3 = OpVariable %27 Output %2 = OpFunction %4 None %6 %28 = OpLabel %29 = OpVariable %9 Function %30 = OpVariable %15 Function %31 = OpVariable %15 Function %32 = OpVariable %20 Function %33 = OpVariable %15 Function %34 = OpVariable %24 Function OpStore %29 %14 OpStore %30 %10 %36 = OpLoad %7 %30 %38 = OpLoad %8 %29 %39 = OpCompositeConstruct %19 %38 %40 = OpLoad %7 %30 %42 = OpLoad %8 %29 %43 = OpCompositeConstruct %19 %42 %45 = OpLoad %7 %30 %46 = OpLoad %7 %33 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Bad: no ids given for clamping ASSERT_FALSE( TransformationAccessChain( 100, 29, {17}, MakeInstructionDescriptor(36, spv::Op::OpLoad, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: an id given for clamping is not fresh ASSERT_FALSE(TransformationAccessChain( 100, 29, {17}, MakeInstructionDescriptor(36, spv::Op::OpLoad, 0), {{46, 201}}) .IsApplicable(context.get(), transformation_context)); // Bad: an id given for clamping is not fresh ASSERT_FALSE(TransformationAccessChain( 100, 29, {17}, MakeInstructionDescriptor(36, spv::Op::OpLoad, 0), {{200, 46}}) .IsApplicable(context.get(), transformation_context)); // Bad: an id given for clamping is the same as the id for the access chain ASSERT_FALSE(TransformationAccessChain( 100, 29, {17}, MakeInstructionDescriptor(36, spv::Op::OpLoad, 0), {{100, 201}}) .IsApplicable(context.get(), transformation_context)); // Bad: the fresh ids given are not distinct ASSERT_FALSE(TransformationAccessChain( 100, 29, {17}, MakeInstructionDescriptor(36, spv::Op::OpLoad, 0), {{200, 200}}) .IsApplicable(context.get(), transformation_context)); // Bad: not enough ids given for clamping (2 pairs needed) ASSERT_FALSE(TransformationAccessChain( 104, 34, {45, 10, 46}, MakeInstructionDescriptor(46, spv::Op::OpReturn, 0), {{208, 209}, {209, 211}}) .IsApplicable(context.get(), transformation_context)); // Bad: the fresh ids given are not distinct ASSERT_FALSE(TransformationAccessChain( 104, 34, {45, 10, 46}, MakeInstructionDescriptor(46, spv::Op::OpReturn, 0), {{208, 209}, {209, 211}}) .IsApplicable(context.get(), transformation_context)); { TransformationAccessChain transformation( 100, 29, {17}, MakeInstructionDescriptor(36, spv::Op::OpLoad, 0), {{200, 201}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } { TransformationAccessChain transformation( 101, 29, {36}, MakeInstructionDescriptor(38, spv::Op::OpLoad, 0), {{202, 203}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } { TransformationAccessChain transformation( 102, 32, {10, 40}, MakeInstructionDescriptor(42, spv::Op::OpLoad, 0), {{204, 205}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } { TransformationAccessChain transformation( 103, 34, {11}, MakeInstructionDescriptor(45, spv::Op::OpLoad, 0), {{206, 207}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } { TransformationAccessChain transformation( 104, 34, {45, 10, 46}, MakeInstructionDescriptor(46, spv::Op::OpReturn, 0), {{208, 209}, {210, 211}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %4 = OpTypeVoid %5 = OpTypeBool %6 = OpTypeFunction %4 %7 = OpTypeInt 32 1 %8 = OpTypeVector %7 4 %9 = OpTypePointer Function %8 %10 = OpConstant %7 0 %11 = OpConstant %7 1 %12 = OpConstant %7 3 %13 = OpConstant %7 2 %14 = OpConstantComposite %8 %10 %11 %12 %13 %15 = OpTypePointer Function %7 %16 = OpTypeInt 32 0 %17 = OpConstant %16 1 %18 = OpConstant %16 3 %19 = OpTypeStruct %8 %20 = OpTypePointer Function %19 %21 = OpConstant %7 9 %22 = OpConstant %16 10 %23 = OpTypeArray %19 %22 %24 = OpTypePointer Function %23 %25 = OpTypeFloat 32 %26 = OpTypeVector %25 4 %27 = OpTypePointer Output %26 %3 = OpVariable %27 Output %2 = OpFunction %4 None %6 %28 = OpLabel %29 = OpVariable %9 Function %30 = OpVariable %15 Function %31 = OpVariable %15 Function %32 = OpVariable %20 Function %33 = OpVariable %15 Function %34 = OpVariable %24 Function OpStore %29 %14 OpStore %30 %10 %200 = OpULessThanEqual %5 %17 %18 %201 = OpSelect %16 %200 %17 %18 %100 = OpAccessChain %15 %29 %201 %36 = OpLoad %7 %30 %202 = OpULessThanEqual %5 %36 %12 %203 = OpSelect %7 %202 %36 %12 %101 = OpAccessChain %15 %29 %203 %38 = OpLoad %8 %29 %39 = OpCompositeConstruct %19 %38 %40 = OpLoad %7 %30 %204 = OpULessThanEqual %5 %40 %12 %205 = OpSelect %7 %204 %40 %12 %102 = OpAccessChain %15 %32 %10 %205 %42 = OpLoad %8 %29 %43 = OpCompositeConstruct %19 %42 %206 = OpULessThanEqual %5 %11 %21 %207 = OpSelect %7 %206 %11 %21 %103 = OpAccessChain %20 %34 %207 %45 = OpLoad %7 %30 %46 = OpLoad %7 %33 %208 = OpULessThanEqual %5 %45 %21 %209 = OpSelect %7 %208 %45 %21 %210 = OpULessThanEqual %5 %46 %12 %211 = OpSelect %7 %210 %46 %12 %104 = OpAccessChain %15 %34 %209 %10 %211 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_add_bit_instruction_synonym_test.cpp000066400000000000000000001276171475742701700332400ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_bit_instruction_synonym.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationAddBitInstructionSynonymTest, IsApplicable) { std::string reference_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %37 "main" ; Types %2 = OpTypeInt 32 0 %3 = OpTypeVoid %4 = OpTypeFunction %3 ; Constants %5 = OpConstant %2 0 %6 = OpConstant %2 1 %7 = OpConstant %2 2 %8 = OpConstant %2 3 %9 = OpConstant %2 4 %10 = OpConstant %2 5 %11 = OpConstant %2 6 %12 = OpConstant %2 7 %13 = OpConstant %2 8 %14 = OpConstant %2 9 %15 = OpConstant %2 10 %16 = OpConstant %2 11 %17 = OpConstant %2 12 %18 = OpConstant %2 13 %19 = OpConstant %2 14 %20 = OpConstant %2 15 %21 = OpConstant %2 16 %22 = OpConstant %2 17 %23 = OpConstant %2 18 %24 = OpConstant %2 19 %25 = OpConstant %2 20 %26 = OpConstant %2 21 %27 = OpConstant %2 22 %28 = OpConstant %2 23 %29 = OpConstant %2 24 %30 = OpConstant %2 25 %31 = OpConstant %2 26 %32 = OpConstant %2 27 %33 = OpConstant %2 28 %34 = OpConstant %2 29 %35 = OpConstant %2 30 %36 = OpConstant %2 31 ; main function %37 = OpFunction %3 None %4 %38 = OpLabel ; Supported bit instructions %39 = OpBitwiseOr %2 %5 %6 %40 = OpBitwiseXor %2 %7 %8 %41 = OpBitwiseAnd %2 %9 %10 %42 = OpNot %2 %11 ; Not yet supported bit instructions %43 = OpShiftRightLogical %2 %12 %13 %44 = OpShiftRightArithmetic %2 %14 %15 %45 = OpShiftLeftLogical %2 %16 %17 %46 = OpBitReverse %2 %18 %47 = OpBitCount %2 %19 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Tests undefined bit instruction. auto transformation = TransformationAddBitInstructionSynonym( 48, {49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests false bit instruction. transformation = TransformationAddBitInstructionSynonym( 38, {48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests the number of fresh ids being different than the necessary. transformation = TransformationAddBitInstructionSynonym( 39, {48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests non-fresh ids. transformation = TransformationAddBitInstructionSynonym( 40, {47, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests unsupported transformation. transformation = TransformationAddBitInstructionSynonym( 43, {48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests supported transformation. transformation = TransformationAddBitInstructionSynonym( 41, {48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationAddBitInstructionSynonymTest, AddOpBitwiseOrSynonym) { std::string reference_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %37 "main" ; Types %2 = OpTypeInt 32 0 %3 = OpTypeVoid %4 = OpTypeFunction %3 ; Constants %5 = OpConstant %2 0 %6 = OpConstant %2 1 %7 = OpConstant %2 2 %8 = OpConstant %2 3 %9 = OpConstant %2 4 %10 = OpConstant %2 5 %11 = OpConstant %2 6 %12 = OpConstant %2 7 %13 = OpConstant %2 8 %14 = OpConstant %2 9 %15 = OpConstant %2 10 %16 = OpConstant %2 11 %17 = OpConstant %2 12 %18 = OpConstant %2 13 %19 = OpConstant %2 14 %20 = OpConstant %2 15 %21 = OpConstant %2 16 %22 = OpConstant %2 17 %23 = OpConstant %2 18 %24 = OpConstant %2 19 %25 = OpConstant %2 20 %26 = OpConstant %2 21 %27 = OpConstant %2 22 %28 = OpConstant %2 23 %29 = OpConstant %2 24 %30 = OpConstant %2 25 %31 = OpConstant %2 26 %32 = OpConstant %2 27 %33 = OpConstant %2 28 %34 = OpConstant %2 29 %35 = OpConstant %2 30 %36 = OpConstant %2 31 ; main function %37 = OpFunction %3 None %4 %38 = OpLabel %39 = OpBitwiseOr %2 %5 %6 ; bit instruction OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Adds OpBitwiseOr synonym. auto transformation = TransformationAddBitInstructionSynonym( 39, {40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(166, {}), MakeDataDescriptor(39, {}))); std::string variant_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %37 "main" ; Types %2 = OpTypeInt 32 0 %3 = OpTypeVoid %4 = OpTypeFunction %3 ; Constants %5 = OpConstant %2 0 %6 = OpConstant %2 1 %7 = OpConstant %2 2 %8 = OpConstant %2 3 %9 = OpConstant %2 4 %10 = OpConstant %2 5 %11 = OpConstant %2 6 %12 = OpConstant %2 7 %13 = OpConstant %2 8 %14 = OpConstant %2 9 %15 = OpConstant %2 10 %16 = OpConstant %2 11 %17 = OpConstant %2 12 %18 = OpConstant %2 13 %19 = OpConstant %2 14 %20 = OpConstant %2 15 %21 = OpConstant %2 16 %22 = OpConstant %2 17 %23 = OpConstant %2 18 %24 = OpConstant %2 19 %25 = OpConstant %2 20 %26 = OpConstant %2 21 %27 = OpConstant %2 22 %28 = OpConstant %2 23 %29 = OpConstant %2 24 %30 = OpConstant %2 25 %31 = OpConstant %2 26 %32 = OpConstant %2 27 %33 = OpConstant %2 28 %34 = OpConstant %2 29 %35 = OpConstant %2 30 %36 = OpConstant %2 31 ; main function %37 = OpFunction %3 None %4 %38 = OpLabel ; Add OpBitwiseOr synonym %40 = OpBitFieldUExtract %2 %5 %5 %6 ; extracts bit 0 from %5 %41 = OpBitFieldUExtract %2 %6 %5 %6 ; extracts bit 0 from %6 %42 = OpBitwiseOr %2 %40 %41 %43 = OpBitFieldUExtract %2 %5 %6 %6 ; extracts bit 1 from %5 %44 = OpBitFieldUExtract %2 %6 %6 %6 ; extracts bit 1 from %6 %45 = OpBitwiseOr %2 %43 %44 %46 = OpBitFieldUExtract %2 %5 %7 %6 ; extracts bit 2 from %5 %47 = OpBitFieldUExtract %2 %6 %7 %6 ; extracts bit 2 from %6 %48 = OpBitwiseOr %2 %46 %47 %49 = OpBitFieldUExtract %2 %5 %8 %6 ; extracts bit 3 from %5 %50 = OpBitFieldUExtract %2 %6 %8 %6 ; extracts bit 3 from %6 %51 = OpBitwiseOr %2 %49 %50 %52 = OpBitFieldUExtract %2 %5 %9 %6 ; extracts bit 4 from %5 %53 = OpBitFieldUExtract %2 %6 %9 %6 ; extracts bit 4 from %6 %54 = OpBitwiseOr %2 %52 %53 %55 = OpBitFieldUExtract %2 %5 %10 %6 ; extracts bit 5 from %5 %56 = OpBitFieldUExtract %2 %6 %10 %6 ; extracts bit 5 from %6 %57 = OpBitwiseOr %2 %55 %56 %58 = OpBitFieldUExtract %2 %5 %11 %6 ; extracts bit 6 from %5 %59 = OpBitFieldUExtract %2 %6 %11 %6 ; extracts bit 6 from %6 %60 = OpBitwiseOr %2 %58 %59 %61 = OpBitFieldUExtract %2 %5 %12 %6 ; extracts bit 7 from %5 %62 = OpBitFieldUExtract %2 %6 %12 %6 ; extracts bit 7 from %6 %63 = OpBitwiseOr %2 %61 %62 %64 = OpBitFieldUExtract %2 %5 %13 %6 ; extracts bit 8 from %5 %65 = OpBitFieldUExtract %2 %6 %13 %6 ; extracts bit 8 from %6 %66 = OpBitwiseOr %2 %64 %65 %67 = OpBitFieldUExtract %2 %5 %14 %6 ; extracts bit 9 from %5 %68 = OpBitFieldUExtract %2 %6 %14 %6 ; extracts bit 9 from %6 %69 = OpBitwiseOr %2 %67 %68 %70 = OpBitFieldUExtract %2 %5 %15 %6 ; extracts bit 10 from %5 %71 = OpBitFieldUExtract %2 %6 %15 %6 ; extracts bit 10 from %6 %72 = OpBitwiseOr %2 %70 %71 %73 = OpBitFieldUExtract %2 %5 %16 %6 ; extracts bit 11 from %5 %74 = OpBitFieldUExtract %2 %6 %16 %6 ; extracts bit 11 from %6 %75 = OpBitwiseOr %2 %73 %74 %76 = OpBitFieldUExtract %2 %5 %17 %6 ; extracts bit 12 from %5 %77 = OpBitFieldUExtract %2 %6 %17 %6 ; extracts bit 12 from %6 %78 = OpBitwiseOr %2 %76 %77 %79 = OpBitFieldUExtract %2 %5 %18 %6 ; extracts bit 13 from %5 %80 = OpBitFieldUExtract %2 %6 %18 %6 ; extracts bit 13 from %6 %81 = OpBitwiseOr %2 %79 %80 %82 = OpBitFieldUExtract %2 %5 %19 %6 ; extracts bit 14 from %5 %83 = OpBitFieldUExtract %2 %6 %19 %6 ; extracts bit 14 from %6 %84 = OpBitwiseOr %2 %82 %83 %85 = OpBitFieldUExtract %2 %5 %20 %6 ; extracts bit 15 from %5 %86 = OpBitFieldUExtract %2 %6 %20 %6 ; extracts bit 15 from %6 %87 = OpBitwiseOr %2 %85 %86 %88 = OpBitFieldUExtract %2 %5 %21 %6 ; extracts bit 16 from %5 %89 = OpBitFieldUExtract %2 %6 %21 %6 ; extracts bit 16 from %6 %90 = OpBitwiseOr %2 %88 %89 %91 = OpBitFieldUExtract %2 %5 %22 %6 ; extracts bit 17 from %5 %92 = OpBitFieldUExtract %2 %6 %22 %6 ; extracts bit 17 from %6 %93 = OpBitwiseOr %2 %91 %92 %94 = OpBitFieldUExtract %2 %5 %23 %6 ; extracts bit 18 from %5 %95 = OpBitFieldUExtract %2 %6 %23 %6 ; extracts bit 18 from %6 %96 = OpBitwiseOr %2 %94 %95 %97 = OpBitFieldUExtract %2 %5 %24 %6 ; extracts bit 19 from %5 %98 = OpBitFieldUExtract %2 %6 %24 %6 ; extracts bit 19 from %6 %99 = OpBitwiseOr %2 %97 %98 %100 = OpBitFieldUExtract %2 %5 %25 %6 ; extracts bit 20 from %5 %101 = OpBitFieldUExtract %2 %6 %25 %6 ; extracts bit 20 from %6 %102 = OpBitwiseOr %2 %100 %101 %103 = OpBitFieldUExtract %2 %5 %26 %6 ; extracts bit 21 from %5 %104 = OpBitFieldUExtract %2 %6 %26 %6 ; extracts bit 21 from %6 %105 = OpBitwiseOr %2 %103 %104 %106 = OpBitFieldUExtract %2 %5 %27 %6 ; extracts bit 22 from %5 %107 = OpBitFieldUExtract %2 %6 %27 %6 ; extracts bit 22 from %6 %108 = OpBitwiseOr %2 %106 %107 %109 = OpBitFieldUExtract %2 %5 %28 %6 ; extracts bit 23 from %5 %110 = OpBitFieldUExtract %2 %6 %28 %6 ; extracts bit 23 from %6 %111 = OpBitwiseOr %2 %109 %110 %112 = OpBitFieldUExtract %2 %5 %29 %6 ; extracts bit 24 from %5 %113 = OpBitFieldUExtract %2 %6 %29 %6 ; extracts bit 24 from %6 %114 = OpBitwiseOr %2 %112 %113 %115 = OpBitFieldUExtract %2 %5 %30 %6 ; extracts bit 25 from %5 %116 = OpBitFieldUExtract %2 %6 %30 %6 ; extracts bit 25 from %6 %117 = OpBitwiseOr %2 %115 %116 %118 = OpBitFieldUExtract %2 %5 %31 %6 ; extracts bit 26 from %5 %119 = OpBitFieldUExtract %2 %6 %31 %6 ; extracts bit 26 from %6 %120 = OpBitwiseOr %2 %118 %119 %121 = OpBitFieldUExtract %2 %5 %32 %6 ; extracts bit 27 from %5 %122 = OpBitFieldUExtract %2 %6 %32 %6 ; extracts bit 27 from %6 %123 = OpBitwiseOr %2 %121 %122 %124 = OpBitFieldUExtract %2 %5 %33 %6 ; extracts bit 28 from %5 %125 = OpBitFieldUExtract %2 %6 %33 %6 ; extracts bit 28 from %6 %126 = OpBitwiseOr %2 %124 %125 %127 = OpBitFieldUExtract %2 %5 %34 %6 ; extracts bit 29 from %5 %128 = OpBitFieldUExtract %2 %6 %34 %6 ; extracts bit 29 from %6 %129 = OpBitwiseOr %2 %127 %128 %130 = OpBitFieldUExtract %2 %5 %35 %6 ; extracts bit 30 from %5 %131 = OpBitFieldUExtract %2 %6 %35 %6 ; extracts bit 30 from %6 %132 = OpBitwiseOr %2 %130 %131 %133 = OpBitFieldUExtract %2 %5 %36 %6 ; extracts bit 31 from %5 %134 = OpBitFieldUExtract %2 %6 %36 %6 ; extracts bit 31 from %6 %135 = OpBitwiseOr %2 %133 %134 %136 = OpBitFieldInsert %2 %42 %45 %6 %6 ; inserts bit 1 %137 = OpBitFieldInsert %2 %136 %48 %7 %6 ; inserts bit 2 %138 = OpBitFieldInsert %2 %137 %51 %8 %6 ; inserts bit 3 %139 = OpBitFieldInsert %2 %138 %54 %9 %6 ; inserts bit 4 %140 = OpBitFieldInsert %2 %139 %57 %10 %6 ; inserts bit 5 %141 = OpBitFieldInsert %2 %140 %60 %11 %6 ; inserts bit 6 %142 = OpBitFieldInsert %2 %141 %63 %12 %6 ; inserts bit 7 %143 = OpBitFieldInsert %2 %142 %66 %13 %6 ; inserts bit 8 %144 = OpBitFieldInsert %2 %143 %69 %14 %6 ; inserts bit 9 %145 = OpBitFieldInsert %2 %144 %72 %15 %6 ; inserts bit 10 %146 = OpBitFieldInsert %2 %145 %75 %16 %6 ; inserts bit 11 %147 = OpBitFieldInsert %2 %146 %78 %17 %6 ; inserts bit 12 %148 = OpBitFieldInsert %2 %147 %81 %18 %6 ; inserts bit 13 %149 = OpBitFieldInsert %2 %148 %84 %19 %6 ; inserts bit 14 %150 = OpBitFieldInsert %2 %149 %87 %20 %6 ; inserts bit 15 %151 = OpBitFieldInsert %2 %150 %90 %21 %6 ; inserts bit 16 %152 = OpBitFieldInsert %2 %151 %93 %22 %6 ; inserts bit 17 %153 = OpBitFieldInsert %2 %152 %96 %23 %6 ; inserts bit 18 %154 = OpBitFieldInsert %2 %153 %99 %24 %6 ; inserts bit 19 %155 = OpBitFieldInsert %2 %154 %102 %25 %6 ; inserts bit 20 %156 = OpBitFieldInsert %2 %155 %105 %26 %6 ; inserts bit 21 %157 = OpBitFieldInsert %2 %156 %108 %27 %6 ; inserts bit 22 %158 = OpBitFieldInsert %2 %157 %111 %28 %6 ; inserts bit 23 %159 = OpBitFieldInsert %2 %158 %114 %29 %6 ; inserts bit 24 %160 = OpBitFieldInsert %2 %159 %117 %30 %6 ; inserts bit 25 %161 = OpBitFieldInsert %2 %160 %120 %31 %6 ; inserts bit 26 %162 = OpBitFieldInsert %2 %161 %123 %32 %6 ; inserts bit 27 %163 = OpBitFieldInsert %2 %162 %126 %33 %6 ; inserts bit 28 %164 = OpBitFieldInsert %2 %163 %129 %34 %6 ; inserts bit 29 %165 = OpBitFieldInsert %2 %164 %132 %35 %6 ; inserts bit 30 %166 = OpBitFieldInsert %2 %165 %135 %36 %6 ; inserts bit 31 %39 = OpBitwiseOr %2 %5 %6 OpReturn OpFunctionEnd )"; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(IsEqual(env, variant_shader, context.get())); } TEST(TransformationAddBitInstructionSynonymTest, AddOpNotSynonym) { std::string reference_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %37 "main" ; Types %2 = OpTypeInt 32 0 %3 = OpTypeVoid %4 = OpTypeFunction %3 ; Constants %5 = OpConstant %2 0 %6 = OpConstant %2 1 %7 = OpConstant %2 2 %8 = OpConstant %2 3 %9 = OpConstant %2 4 %10 = OpConstant %2 5 %11 = OpConstant %2 6 %12 = OpConstant %2 7 %13 = OpConstant %2 8 %14 = OpConstant %2 9 %15 = OpConstant %2 10 %16 = OpConstant %2 11 %17 = OpConstant %2 12 %18 = OpConstant %2 13 %19 = OpConstant %2 14 %20 = OpConstant %2 15 %21 = OpConstant %2 16 %22 = OpConstant %2 17 %23 = OpConstant %2 18 %24 = OpConstant %2 19 %25 = OpConstant %2 20 %26 = OpConstant %2 21 %27 = OpConstant %2 22 %28 = OpConstant %2 23 %29 = OpConstant %2 24 %30 = OpConstant %2 25 %31 = OpConstant %2 26 %32 = OpConstant %2 27 %33 = OpConstant %2 28 %34 = OpConstant %2 29 %35 = OpConstant %2 30 %36 = OpConstant %2 31 ; main function %37 = OpFunction %3 None %4 %38 = OpLabel %39 = OpNot %2 %5 ; bit instruction OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Adds OpNot synonym. auto transformation = TransformationAddBitInstructionSynonym( 39, {40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(134, {}), MakeDataDescriptor(39, {}))); std::string variant_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %37 "main" ; Types %2 = OpTypeInt 32 0 %3 = OpTypeVoid %4 = OpTypeFunction %3 ; Constants %5 = OpConstant %2 0 %6 = OpConstant %2 1 %7 = OpConstant %2 2 %8 = OpConstant %2 3 %9 = OpConstant %2 4 %10 = OpConstant %2 5 %11 = OpConstant %2 6 %12 = OpConstant %2 7 %13 = OpConstant %2 8 %14 = OpConstant %2 9 %15 = OpConstant %2 10 %16 = OpConstant %2 11 %17 = OpConstant %2 12 %18 = OpConstant %2 13 %19 = OpConstant %2 14 %20 = OpConstant %2 15 %21 = OpConstant %2 16 %22 = OpConstant %2 17 %23 = OpConstant %2 18 %24 = OpConstant %2 19 %25 = OpConstant %2 20 %26 = OpConstant %2 21 %27 = OpConstant %2 22 %28 = OpConstant %2 23 %29 = OpConstant %2 24 %30 = OpConstant %2 25 %31 = OpConstant %2 26 %32 = OpConstant %2 27 %33 = OpConstant %2 28 %34 = OpConstant %2 29 %35 = OpConstant %2 30 %36 = OpConstant %2 31 ; main function %37 = OpFunction %3 None %4 %38 = OpLabel ; Add OpNot synonym %40 = OpBitFieldUExtract %2 %5 %5 %6 ; extracts bit 0 from %5 %41 = OpNot %2 %40 %42 = OpBitFieldUExtract %2 %5 %6 %6 ; extracts bit 1 from %5 %43 = OpNot %2 %42 %44 = OpBitFieldUExtract %2 %5 %7 %6 ; extracts bit 2 from %5 %45 = OpNot %2 %44 %46 = OpBitFieldUExtract %2 %5 %8 %6 ; extracts bit 3 from %5 %47 = OpNot %2 %46 %48 = OpBitFieldUExtract %2 %5 %9 %6 ; extracts bit 4 from %5 %49 = OpNot %2 %48 %50 = OpBitFieldUExtract %2 %5 %10 %6 ; extracts bit 5 from %5 %51 = OpNot %2 %50 %52 = OpBitFieldUExtract %2 %5 %11 %6 ; extracts bit 6 from %5 %53 = OpNot %2 %52 %54 = OpBitFieldUExtract %2 %5 %12 %6 ; extracts bit 7 from %5 %55 = OpNot %2 %54 %56 = OpBitFieldUExtract %2 %5 %13 %6 ; extracts bit 8 from %5 %57 = OpNot %2 %56 %58 = OpBitFieldUExtract %2 %5 %14 %6 ; extracts bit 9 from %5 %59 = OpNot %2 %58 %60 = OpBitFieldUExtract %2 %5 %15 %6 ; extracts bit 10 from %5 %61 = OpNot %2 %60 %62 = OpBitFieldUExtract %2 %5 %16 %6 ; extracts bit 11 from %5 %63 = OpNot %2 %62 %64 = OpBitFieldUExtract %2 %5 %17 %6 ; extracts bit 12 from %5 %65 = OpNot %2 %64 %66 = OpBitFieldUExtract %2 %5 %18 %6 ; extracts bit 13 from %5 %67 = OpNot %2 %66 %68 = OpBitFieldUExtract %2 %5 %19 %6 ; extracts bit 14 from %5 %69 = OpNot %2 %68 %70 = OpBitFieldUExtract %2 %5 %20 %6 ; extracts bit 15 from %5 %71 = OpNot %2 %70 %72 = OpBitFieldUExtract %2 %5 %21 %6 ; extracts bit 16 from %5 %73 = OpNot %2 %72 %74 = OpBitFieldUExtract %2 %5 %22 %6 ; extracts bit 17 from %5 %75 = OpNot %2 %74 %76 = OpBitFieldUExtract %2 %5 %23 %6 ; extracts bit 18 from %5 %77 = OpNot %2 %76 %78 = OpBitFieldUExtract %2 %5 %24 %6 ; extracts bit 19 from %5 %79 = OpNot %2 %78 %80 = OpBitFieldUExtract %2 %5 %25 %6 ; extracts bit 20 from %5 %81 = OpNot %2 %80 %82 = OpBitFieldUExtract %2 %5 %26 %6 ; extracts bit 21 from %5 %83 = OpNot %2 %82 %84 = OpBitFieldUExtract %2 %5 %27 %6 ; extracts bit 22 from %5 %85 = OpNot %2 %84 %86 = OpBitFieldUExtract %2 %5 %28 %6 ; extracts bit 23 from %5 %87 = OpNot %2 %86 %88 = OpBitFieldUExtract %2 %5 %29 %6 ; extracts bit 24 from %5 %89 = OpNot %2 %88 %90 = OpBitFieldUExtract %2 %5 %30 %6 ; extracts bit 25 from %5 %91 = OpNot %2 %90 %92 = OpBitFieldUExtract %2 %5 %31 %6 ; extracts bit 26 from %5 %93 = OpNot %2 %92 %94 = OpBitFieldUExtract %2 %5 %32 %6 ; extracts bit 27 from %5 %95 = OpNot %2 %94 %96 = OpBitFieldUExtract %2 %5 %33 %6 ; extracts bit 28 from %5 %97 = OpNot %2 %96 %98 = OpBitFieldUExtract %2 %5 %34 %6 ; extracts bit 29 from %5 %99 = OpNot %2 %98 %100 = OpBitFieldUExtract %2 %5 %35 %6 ; extracts bit 30 from %5 %101 = OpNot %2 %100 %102 = OpBitFieldUExtract %2 %5 %36 %6 ; extracts bit 31 from %5 %103 = OpNot %2 %102 %104 = OpBitFieldInsert %2 %41 %43 %6 %6 ; inserts bit 1 %105 = OpBitFieldInsert %2 %104 %45 %7 %6 ; inserts bit 2 %106 = OpBitFieldInsert %2 %105 %47 %8 %6 ; inserts bit 3 %107 = OpBitFieldInsert %2 %106 %49 %9 %6 ; inserts bit 4 %108 = OpBitFieldInsert %2 %107 %51 %10 %6 ; inserts bit 5 %109 = OpBitFieldInsert %2 %108 %53 %11 %6 ; inserts bit 6 %110 = OpBitFieldInsert %2 %109 %55 %12 %6 ; inserts bit 7 %111 = OpBitFieldInsert %2 %110 %57 %13 %6 ; inserts bit 8 %112 = OpBitFieldInsert %2 %111 %59 %14 %6 ; inserts bit 9 %113 = OpBitFieldInsert %2 %112 %61 %15 %6 ; inserts bit 10 %114 = OpBitFieldInsert %2 %113 %63 %16 %6 ; inserts bit 11 %115 = OpBitFieldInsert %2 %114 %65 %17 %6 ; inserts bit 12 %116 = OpBitFieldInsert %2 %115 %67 %18 %6 ; inserts bit 13 %117 = OpBitFieldInsert %2 %116 %69 %19 %6 ; inserts bit 14 %118 = OpBitFieldInsert %2 %117 %71 %20 %6 ; inserts bit 15 %119 = OpBitFieldInsert %2 %118 %73 %21 %6 ; inserts bit 16 %120 = OpBitFieldInsert %2 %119 %75 %22 %6 ; inserts bit 17 %121 = OpBitFieldInsert %2 %120 %77 %23 %6 ; inserts bit 18 %122 = OpBitFieldInsert %2 %121 %79 %24 %6 ; inserts bit 19 %123 = OpBitFieldInsert %2 %122 %81 %25 %6 ; inserts bit 20 %124 = OpBitFieldInsert %2 %123 %83 %26 %6 ; inserts bit 21 %125 = OpBitFieldInsert %2 %124 %85 %27 %6 ; inserts bit 22 %126 = OpBitFieldInsert %2 %125 %87 %28 %6 ; inserts bit 23 %127 = OpBitFieldInsert %2 %126 %89 %29 %6 ; inserts bit 24 %128 = OpBitFieldInsert %2 %127 %91 %30 %6 ; inserts bit 25 %129 = OpBitFieldInsert %2 %128 %93 %31 %6 ; inserts bit 26 %130 = OpBitFieldInsert %2 %129 %95 %32 %6 ; inserts bit 27 %131 = OpBitFieldInsert %2 %130 %97 %33 %6 ; inserts bit 28 %132 = OpBitFieldInsert %2 %131 %99 %34 %6 ; inserts bit 29 %133 = OpBitFieldInsert %2 %132 %101 %35 %6 ; inserts bit 30 %134 = OpBitFieldInsert %2 %133 %103 %36 %6 ; inserts bit 31 %39 = OpNot %2 %5 OpReturn OpFunctionEnd )"; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(IsEqual(env, variant_shader, context.get())); } TEST(TransformationAddBitInstructionSynonymTest, NoSynonymWhenIdIsIrrelevant) { std::string reference_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %37 "main" ; Types %2 = OpTypeInt 32 0 %3 = OpTypeVoid %4 = OpTypeFunction %3 ; Constants %5 = OpConstant %2 0 %6 = OpConstant %2 1 %7 = OpConstant %2 2 %8 = OpConstant %2 3 %9 = OpConstant %2 4 %10 = OpConstant %2 5 %11 = OpConstant %2 6 %12 = OpConstant %2 7 %13 = OpConstant %2 8 %14 = OpConstant %2 9 %15 = OpConstant %2 10 %16 = OpConstant %2 11 %17 = OpConstant %2 12 %18 = OpConstant %2 13 %19 = OpConstant %2 14 %20 = OpConstant %2 15 %21 = OpConstant %2 16 %22 = OpConstant %2 17 %23 = OpConstant %2 18 %24 = OpConstant %2 19 %25 = OpConstant %2 20 %26 = OpConstant %2 21 %27 = OpConstant %2 22 %28 = OpConstant %2 23 %29 = OpConstant %2 24 %30 = OpConstant %2 25 %31 = OpConstant %2 26 %32 = OpConstant %2 27 %33 = OpConstant %2 28 %34 = OpConstant %2 29 %35 = OpConstant %2 30 %36 = OpConstant %2 31 ; main function %37 = OpFunction %3 None %4 %38 = OpLabel %39 = OpBitwiseOr %2 %5 %6 ; bit instruction OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Mark the result id of the bit instruction as irrelevant. transformation_context.GetFactManager()->AddFactIdIsIrrelevant(39); // Adds OpBitwiseOr synonym. auto transformation = TransformationAddBitInstructionSynonym( 39, {40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // No synonym should have been created, since the bit instruction is // irrelevant. ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(166, {}), MakeDataDescriptor(39, {}))); } TEST(TransformationAddBitInstructionSynonymTest, NoSynonymWhenBlockIsDead) { std::string reference_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %37 "main" ; Types %2 = OpTypeInt 32 0 %3 = OpTypeVoid %4 = OpTypeFunction %3 ; Constants %5 = OpConstant %2 0 %6 = OpConstant %2 1 %7 = OpConstant %2 2 %8 = OpConstant %2 3 %9 = OpConstant %2 4 %10 = OpConstant %2 5 %11 = OpConstant %2 6 %12 = OpConstant %2 7 %13 = OpConstant %2 8 %14 = OpConstant %2 9 %15 = OpConstant %2 10 %16 = OpConstant %2 11 %17 = OpConstant %2 12 %18 = OpConstant %2 13 %19 = OpConstant %2 14 %20 = OpConstant %2 15 %21 = OpConstant %2 16 %22 = OpConstant %2 17 %23 = OpConstant %2 18 %24 = OpConstant %2 19 %25 = OpConstant %2 20 %26 = OpConstant %2 21 %27 = OpConstant %2 22 %28 = OpConstant %2 23 %29 = OpConstant %2 24 %30 = OpConstant %2 25 %31 = OpConstant %2 26 %32 = OpConstant %2 27 %33 = OpConstant %2 28 %34 = OpConstant %2 29 %35 = OpConstant %2 30 %36 = OpConstant %2 31 ; main function %37 = OpFunction %3 None %4 %38 = OpLabel %39 = OpBitwiseOr %2 %5 %6 ; bit instruction OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Mark the block where we will try to create the synonym as dead. transformation_context.GetFactManager()->AddFactBlockIsDead(38); // Adds OpBitwiseOr synonym. auto transformation = TransformationAddBitInstructionSynonym( 39, {40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // No synonym should have been created, since the bit instruction is // irrelevant. ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(166, {}), MakeDataDescriptor(39, {}))); } TEST(TransformationAddBitInstructionSynonymTest, DifferentSingedness) { std::string reference_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %37 "main" ; Types %2 = OpTypeInt 32 0 %200 = OpTypeInt 32 1 %3 = OpTypeVoid %4 = OpTypeFunction %3 ; Constants %5 = OpConstant %2 0 %6 = OpConstant %2 1 %7 = OpConstant %2 2 %8 = OpConstant %2 3 %9 = OpConstant %2 4 %10 = OpConstant %2 5 %11 = OpConstant %2 6 %12 = OpConstant %2 7 %13 = OpConstant %2 8 %14 = OpConstant %2 9 %15 = OpConstant %2 10 %16 = OpConstant %2 11 %17 = OpConstant %2 12 %18 = OpConstant %2 13 %19 = OpConstant %2 14 %20 = OpConstant %2 15 %21 = OpConstant %2 16 %22 = OpConstant %2 17 %23 = OpConstant %2 18 %24 = OpConstant %2 19 %25 = OpConstant %2 20 %26 = OpConstant %2 21 %27 = OpConstant %2 22 %28 = OpConstant %2 23 %29 = OpConstant %2 24 %30 = OpConstant %2 25 %31 = OpConstant %2 26 %32 = OpConstant %2 27 %33 = OpConstant %2 28 %34 = OpConstant %2 29 %35 = OpConstant %2 30 %36 = OpConstant %2 31 %45 = OpConstant %200 32 ; main function %37 = OpFunction %3 None %4 %38 = OpLabel %39 = OpNot %200 %5 ; bit instruction %40 = OpBitwiseOr %200 %6 %45 ; bit instruction %41 = OpBitwiseAnd %2 %5 %6 ; bit instruction OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Invalid because the sign of id 200 result is not equal to the sign of id 5 // operand in OpNot. auto transformation = TransformationAddBitInstructionSynonym( 39, {300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Invalid because the sign of two operands not the same and the first operand // sign not equal the result sign in OpBitwiseOr. transformation = TransformationAddBitInstructionSynonym( 40, {300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Successful transformation { // Instruction operands are the same and it's equal with the result sign in // OpBitwiseAnd bitwise operation. transformation = TransformationAddBitInstructionSynonym( 41, {46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_add_constant_boolean_test.cpp000066400000000000000000000213431475742701700315420ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_constant_boolean.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationAddConstantBooleanTest, NeitherPresentInitiallyAddBoth) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %6 = OpTypeBool %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // True and false can both be added as neither is present. ASSERT_TRUE(TransformationAddConstantBoolean(7, true, false) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationAddConstantBoolean(7, false, false) .IsApplicable(context.get(), transformation_context)); // Irrelevant true and false can both be added as neither is present. ASSERT_TRUE(TransformationAddConstantBoolean(7, true, true) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationAddConstantBoolean(7, false, true) .IsApplicable(context.get(), transformation_context)); // Id 5 is already taken. ASSERT_FALSE(TransformationAddConstantBoolean(5, true, false) .IsApplicable(context.get(), transformation_context)); auto add_true = TransformationAddConstantBoolean(7, true, false); auto add_false = TransformationAddConstantBoolean(8, false, false); ASSERT_TRUE(add_true.IsApplicable(context.get(), transformation_context)); ASSERT_EQ(nullptr, context->get_def_use_mgr()->GetDef(7)); ASSERT_EQ(nullptr, context->get_constant_mgr()->FindDeclaredConstant(7)); ApplyAndCheckFreshIds(add_true, context.get(), &transformation_context); ASSERT_EQ(spv::Op::OpConstantTrue, context->get_def_use_mgr()->GetDef(7)->opcode()); ASSERT_TRUE(context->get_constant_mgr() ->FindDeclaredConstant(7) ->AsBoolConstant() ->value()); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Having added true, we cannot add it again with the same id. ASSERT_FALSE(add_true.IsApplicable(context.get(), transformation_context)); // But we can add it with a different id. auto add_true_again = TransformationAddConstantBoolean(100, true, false); ASSERT_TRUE( add_true_again.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(add_true_again, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(add_false.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(add_false, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Having added false, we cannot add it again with the same id. ASSERT_FALSE(add_false.IsApplicable(context.get(), transformation_context)); // But we can add it with a different id. auto add_false_again = TransformationAddConstantBoolean(101, false, false); ASSERT_TRUE( add_false_again.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(add_false_again, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // We can create an irrelevant OpConstantTrue. TransformationAddConstantBoolean irrelevant_true(102, true, true); ASSERT_TRUE( irrelevant_true.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(irrelevant_true, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // We can create an irrelevant OpConstantFalse. TransformationAddConstantBoolean irrelevant_false(103, false, true); ASSERT_TRUE( irrelevant_false.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(irrelevant_false, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_FALSE(transformation_context.GetFactManager()->IdIsIrrelevant(100)); ASSERT_FALSE(transformation_context.GetFactManager()->IdIsIrrelevant(101)); ASSERT_TRUE(transformation_context.GetFactManager()->IdIsIrrelevant(102)); ASSERT_TRUE(transformation_context.GetFactManager()->IdIsIrrelevant(103)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %6 = OpTypeBool %3 = OpTypeFunction %2 %7 = OpConstantTrue %6 %100 = OpConstantTrue %6 %8 = OpConstantFalse %6 %101 = OpConstantFalse %6 %102 = OpConstantTrue %6 %103 = OpConstantFalse %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationAddConstantBooleanTest, NoOpTypeBoolPresent) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Neither true nor false can be added as OpTypeBool is not present. ASSERT_FALSE(TransformationAddConstantBoolean(6, true, false) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationAddConstantBoolean(6, false, false) .IsApplicable(context.get(), transformation_context)); // This does not depend on whether the constant is relevant or not. ASSERT_FALSE(TransformationAddConstantBoolean(6, true, true) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationAddConstantBoolean(6, false, true) .IsApplicable(context.get(), transformation_context)); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_add_constant_composite_test.cpp000066400000000000000000000274541475742701700321360ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_constant_composite.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationAddConstantCompositeTest, BasicTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 2 %8 = OpTypeMatrix %7 3 %11 = OpConstant %6 0 %12 = OpConstant %6 1 %14 = OpConstant %6 2 %15 = OpConstant %6 3 %17 = OpConstant %6 4 %18 = OpConstant %6 5 %21 = OpTypeInt 32 1 %22 = OpTypeInt 32 0 %23 = OpConstant %22 3 %24 = OpTypeArray %21 %23 %25 = OpTypeBool %26 = OpTypeStruct %24 %25 %29 = OpConstant %21 1 %30 = OpConstant %21 2 %31 = OpConstant %21 3 %33 = OpConstantFalse %25 %35 = OpTypeVector %6 3 %38 = OpConstant %6 6 %39 = OpConstant %6 7 %40 = OpConstant %6 8 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Too few ids ASSERT_FALSE(TransformationAddConstantComposite(103, 8, {100, 101}, false) .IsApplicable(context.get(), transformation_context)); // Too many ids ASSERT_FALSE(TransformationAddConstantComposite(101, 7, {14, 15, 14}, false) .IsApplicable(context.get(), transformation_context)); // Id already in use ASSERT_FALSE(TransformationAddConstantComposite(40, 7, {11, 12}, false) .IsApplicable(context.get(), transformation_context)); // %39 is not a type ASSERT_FALSE(TransformationAddConstantComposite(100, 39, {11, 12}, false) .IsApplicable(context.get(), transformation_context)); { // %100 = OpConstantComposite %7 %11 %12 TransformationAddConstantComposite transformation(100, 7, {11, 12}, false); ASSERT_EQ(nullptr, context->get_def_use_mgr()->GetDef(100)); ASSERT_EQ(nullptr, context->get_constant_mgr()->FindDeclaredConstant(100)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_EQ(spv::Op::OpConstantComposite, context->get_def_use_mgr()->GetDef(100)->opcode()); ASSERT_EQ(0.0F, context->get_constant_mgr() ->FindDeclaredConstant(100) ->AsVectorConstant() ->GetComponents()[0] ->GetFloat()); ASSERT_EQ(1.0F, context->get_constant_mgr() ->FindDeclaredConstant(100) ->AsVectorConstant() ->GetComponents()[1] ->GetFloat()); } TransformationAddConstantComposite transformations[] = { // %101 = OpConstantComposite %7 %14 %15 TransformationAddConstantComposite(101, 7, {14, 15}, false), // %102 = OpConstantComposite %7 %17 %18 TransformationAddConstantComposite(102, 7, {17, 18}, false), // %103 = OpConstantComposite %8 %100 %101 %102 TransformationAddConstantComposite(103, 8, {100, 101, 102}, false), // %104 = OpConstantComposite %24 %29 %30 %31 TransformationAddConstantComposite(104, 24, {29, 30, 31}, false), // %105 = OpConstantComposite %26 %104 %33 TransformationAddConstantComposite(105, 26, {104, 33}, false), // %106 = OpConstantComposite %35 %38 %39 %40 TransformationAddConstantComposite(106, 35, {38, 39, 40}, false), // Same constants but with an irrelevant fact applied. // %107 = OpConstantComposite %7 %11 %12 TransformationAddConstantComposite(107, 7, {11, 12}, true), // %108 = OpConstantComposite %7 %14 %15 TransformationAddConstantComposite(108, 7, {14, 15}, true), // %109 = OpConstantComposite %7 %17 %18 TransformationAddConstantComposite(109, 7, {17, 18}, true), // %110 = OpConstantComposite %8 %100 %101 %102 TransformationAddConstantComposite(110, 8, {100, 101, 102}, true), // %111 = OpConstantComposite %24 %29 %30 %31 TransformationAddConstantComposite(111, 24, {29, 30, 31}, true), // %112 = OpConstantComposite %26 %104 %33 TransformationAddConstantComposite(112, 26, {104, 33}, true), // %113 = OpConstantComposite %35 %38 %39 %40 TransformationAddConstantComposite(113, 35, {38, 39, 40}, true)}; for (auto& transformation : transformations) { ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); for (uint32_t id = 100; id <= 106; ++id) { ASSERT_FALSE(transformation_context.GetFactManager()->IdIsIrrelevant(id)); } for (uint32_t id = 107; id <= 113; ++id) { ASSERT_TRUE(transformation_context.GetFactManager()->IdIsIrrelevant(id)); } std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 2 %8 = OpTypeMatrix %7 3 %11 = OpConstant %6 0 %12 = OpConstant %6 1 %14 = OpConstant %6 2 %15 = OpConstant %6 3 %17 = OpConstant %6 4 %18 = OpConstant %6 5 %21 = OpTypeInt 32 1 %22 = OpTypeInt 32 0 %23 = OpConstant %22 3 %24 = OpTypeArray %21 %23 %25 = OpTypeBool %26 = OpTypeStruct %24 %25 %29 = OpConstant %21 1 %30 = OpConstant %21 2 %31 = OpConstant %21 3 %33 = OpConstantFalse %25 %35 = OpTypeVector %6 3 %38 = OpConstant %6 6 %39 = OpConstant %6 7 %40 = OpConstant %6 8 %100 = OpConstantComposite %7 %11 %12 %101 = OpConstantComposite %7 %14 %15 %102 = OpConstantComposite %7 %17 %18 %103 = OpConstantComposite %8 %100 %101 %102 %104 = OpConstantComposite %24 %29 %30 %31 %105 = OpConstantComposite %26 %104 %33 %106 = OpConstantComposite %35 %38 %39 %40 %107 = OpConstantComposite %7 %11 %12 %108 = OpConstantComposite %7 %14 %15 %109 = OpConstantComposite %7 %17 %18 %110 = OpConstantComposite %8 %100 %101 %102 %111 = OpConstantComposite %24 %29 %30 %31 %112 = OpConstantComposite %26 %104 %33 %113 = OpConstantComposite %35 %38 %39 %40 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationAddConstantCompositeTest, DisallowBufferBlockDecoration) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 320 OpName %4 "main" OpName %7 "buf" OpMemberName %7 0 "a" OpMemberName %7 1 "b" OpName %9 "" OpMemberDecorate %7 0 Offset 0 OpMemberDecorate %7 1 Offset 4 OpDecorate %7 BufferBlock OpDecorate %9 DescriptorSet 0 OpDecorate %9 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %10 = OpConstant %6 42 %7 = OpTypeStruct %6 %6 %8 = OpTypePointer Uniform %7 %9 = OpVariable %8 Uniform %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_0; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_FALSE(TransformationAddConstantComposite(100, 7, {10, 10}, false) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationAddConstantCompositeTest, DisallowBlockDecoration) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" %9 OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 320 OpName %4 "main" OpName %7 "buf" OpMemberName %7 0 "a" OpMemberName %7 1 "b" OpName %9 "" OpMemberDecorate %7 0 Offset 0 OpMemberDecorate %7 1 Offset 4 OpDecorate %7 Block OpDecorate %9 DescriptorSet 0 OpDecorate %9 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %10 = OpConstant %6 42 %7 = OpTypeStruct %6 %6 %8 = OpTypePointer StorageBuffer %7 %9 = OpVariable %8 StorageBuffer %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_FALSE(TransformationAddConstantComposite(100, 7, {10, 10}, false) .IsApplicable(context.get(), transformation_context)); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_add_constant_null_test.cpp000066400000000000000000000127271475742701700311030ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_constant_null.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationAddConstantNullTest, BasicTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeInt 32 1 %8 = OpTypeVector %6 2 %9 = OpTypeVector %6 3 %10 = OpTypeVector %6 4 %11 = OpTypeVector %7 2 %20 = OpTypeSampler %21 = OpTypeImage %6 2D 0 0 0 0 Rgba32f %22 = OpTypeSampledImage %21 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Id already in use ASSERT_FALSE(TransformationAddConstantNull(4, 11).IsApplicable( context.get(), transformation_context)); // %1 is not a type ASSERT_FALSE(TransformationAddConstantNull(100, 1).IsApplicable( context.get(), transformation_context)); // %3 is a function type ASSERT_FALSE(TransformationAddConstantNull(100, 3).IsApplicable( context.get(), transformation_context)); // %20 is a sampler type ASSERT_FALSE(TransformationAddConstantNull(100, 20).IsApplicable( context.get(), transformation_context)); // %21 is an image type ASSERT_FALSE(TransformationAddConstantNull(100, 21).IsApplicable( context.get(), transformation_context)); // %22 is a sampled image type ASSERT_FALSE(TransformationAddConstantNull(100, 22).IsApplicable( context.get(), transformation_context)); { // %100 = OpConstantNull %6 TransformationAddConstantNull transformation(100, 6); ASSERT_EQ(nullptr, context->get_def_use_mgr()->GetDef(100)); ASSERT_EQ(nullptr, context->get_constant_mgr()->FindDeclaredConstant(100)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_EQ(spv::Op::OpConstantNull, context->get_def_use_mgr()->GetDef(100)->opcode()); ASSERT_EQ( 0.0F, context->get_constant_mgr()->FindDeclaredConstant(100)->GetFloat()); } TransformationAddConstantNull transformations[] = { // %101 = OpConstantNull %7 TransformationAddConstantNull(101, 7), // %102 = OpConstantNull %8 TransformationAddConstantNull(102, 8), // %103 = OpConstantNull %9 TransformationAddConstantNull(103, 9), // %104 = OpConstantNull %10 TransformationAddConstantNull(104, 10), // %105 = OpConstantNull %11 TransformationAddConstantNull(105, 11)}; for (auto& transformation : transformations) { ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeInt 32 1 %8 = OpTypeVector %6 2 %9 = OpTypeVector %6 3 %10 = OpTypeVector %6 4 %11 = OpTypeVector %7 2 %20 = OpTypeSampler %21 = OpTypeImage %6 2D 0 0 0 0 Rgba32f %22 = OpTypeSampledImage %21 %100 = OpConstantNull %6 %101 = OpConstantNull %7 %102 = OpConstantNull %8 %103 = OpConstantNull %9 %104 = OpConstantNull %10 %105 = OpConstantNull %11 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_add_constant_scalar_test.cpp000066400000000000000000000347271475742701700314020ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_constant_scalar.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationAddConstantScalarTest, IsApplicable) { std::string reference_shader = R"( OpCapability Shader OpCapability Int64 OpCapability Float64 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %17 "main" ; Types ; 32-bit types %2 = OpTypeInt 32 0 %3 = OpTypeInt 32 1 %4 = OpTypeFloat 32 ; 64-bit types %5 = OpTypeInt 64 0 %6 = OpTypeInt 64 1 %7 = OpTypeFloat 64 %8 = OpTypePointer Private %2 %9 = OpTypeVoid %10 = OpTypeFunction %9 ; Constants ; 32-bit constants %11 = OpConstant %2 1 %12 = OpConstant %3 2 %13 = OpConstant %4 3 ; 64-bit constants %14 = OpConstant %5 1 %15 = OpConstant %6 2 %16 = OpConstant %7 3 ; main function %17 = OpFunction %9 None %10 %18 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Tests |fresh_id| being non-fresh. auto transformation = TransformationAddConstantScalar(18, 2, {0}, false); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests undefined |type_id|. transformation = TransformationAddConstantScalar(19, 20, {0}, false); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests |type_id| not representing a type instruction. transformation = TransformationAddConstantScalar(19, 11, {0}, false); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests |type_id| representing an OpTypePointer instruction. transformation = TransformationAddConstantScalar(19, 8, {0}, false); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests |type_id| representing an OpTypeVoid instruction. transformation = TransformationAddConstantScalar(19, 9, {0}, false); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests |words| having no words. transformation = TransformationAddConstantScalar(19, 2, {}, false); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests |words| having 2 words for a 32-bit type. transformation = TransformationAddConstantScalar(19, 2, {0, 1}, false); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests |words| having 3 words for a 64-bit type. transformation = TransformationAddConstantScalar(19, 5, {0, 1, 2}, false); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests |words| having 2 words for a 32-bit float type. transformation = TransformationAddConstantScalar(19, 4, {0, 1}, false); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationAddConstantScalarTest, Apply) { std::string reference_shader = R"( OpCapability Shader OpCapability Int64 OpCapability Float64 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %17 "main" ; Types ; 32-bit types %2 = OpTypeInt 32 0 %3 = OpTypeInt 32 1 %4 = OpTypeFloat 32 ; 64-bit types %5 = OpTypeInt 64 0 %6 = OpTypeInt 64 1 %7 = OpTypeFloat 64 %8 = OpTypePointer Private %2 %9 = OpTypeVoid %10 = OpTypeFunction %9 ; Constants ; 32-bit constants %11 = OpConstant %2 1 %12 = OpConstant %3 2 %13 = OpConstant %4 3 ; 64-bit constants %14 = OpConstant %5 1 %15 = OpConstant %6 2 %16 = OpConstant %7 3 ; main function %17 = OpFunction %9 None %10 %18 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Adds 32-bit unsigned integer (1 logical operand with 1 word). auto transformation = TransformationAddConstantScalar(19, 2, {4}, false); ASSERT_EQ(nullptr, context->get_def_use_mgr()->GetDef(19)); ASSERT_EQ(nullptr, context->get_constant_mgr()->FindDeclaredConstant(19)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_EQ(spv::Op::OpConstant, context->get_def_use_mgr()->GetDef(19)->opcode()); ASSERT_EQ(4, context->get_constant_mgr()->FindDeclaredConstant(19)->GetU32()); auto* constant_instruction = context->get_def_use_mgr()->GetDef(19); EXPECT_EQ(constant_instruction->NumInOperands(), 1); EXPECT_EQ(constant_instruction->NumInOperandWords(), 1); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Adds 32-bit signed integer (1 logical operand with 1 word). transformation = TransformationAddConstantScalar(20, 3, {5}, false); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); constant_instruction = context->get_def_use_mgr()->GetDef(20); EXPECT_EQ(constant_instruction->NumInOperands(), 1); EXPECT_EQ(constant_instruction->NumInOperandWords(), 1); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Adds 32-bit float (1 logical operand with 1 word). transformation = TransformationAddConstantScalar( 21, 4, {0b01000000110000000000000000000000}, false); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); constant_instruction = context->get_def_use_mgr()->GetDef(21); EXPECT_EQ(constant_instruction->NumInOperands(), 1); EXPECT_EQ(constant_instruction->NumInOperandWords(), 1); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Adds 64-bit unsigned integer (1 logical operand with 2 words). transformation = TransformationAddConstantScalar(22, 5, {7, 0}, false); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); constant_instruction = context->get_def_use_mgr()->GetDef(22); EXPECT_EQ(constant_instruction->NumInOperands(), 1); EXPECT_EQ(constant_instruction->NumInOperandWords(), 2); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Adds 64-bit signed integer (1 logical operand with 2 words). transformation = TransformationAddConstantScalar(23, 6, {8, 0}, false); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); constant_instruction = context->get_def_use_mgr()->GetDef(23); EXPECT_EQ(constant_instruction->NumInOperands(), 1); EXPECT_EQ(constant_instruction->NumInOperandWords(), 2); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Adds 64-bit float (1 logical operand with 2 words). transformation = TransformationAddConstantScalar( 24, 7, {0, 0b01000000001000100000000000000000}, false); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); constant_instruction = context->get_def_use_mgr()->GetDef(24); EXPECT_EQ(constant_instruction->NumInOperands(), 1); EXPECT_EQ(constant_instruction->NumInOperandWords(), 2); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Adds irrelevant 32-bit unsigned integer (1 logical operand with 1 word). transformation = TransformationAddConstantScalar(25, 2, {10}, true); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); constant_instruction = context->get_def_use_mgr()->GetDef(25); EXPECT_EQ(constant_instruction->NumInOperands(), 1); EXPECT_EQ(constant_instruction->NumInOperandWords(), 1); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Adds irrelevant 32-bit signed integer (1 logical operand with 1 word). transformation = TransformationAddConstantScalar(26, 3, {11}, true); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); constant_instruction = context->get_def_use_mgr()->GetDef(26); EXPECT_EQ(constant_instruction->NumInOperands(), 1); EXPECT_EQ(constant_instruction->NumInOperandWords(), 1); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Adds irrelevant 32-bit float (1 logical operand with 1 word). transformation = TransformationAddConstantScalar( 27, 4, {0b01000001010000000000000000000000}, true); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); constant_instruction = context->get_def_use_mgr()->GetDef(27); EXPECT_EQ(constant_instruction->NumInOperands(), 1); EXPECT_EQ(constant_instruction->NumInOperandWords(), 1); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Adds irrelevant 64-bit unsigned integer (1 logical operand with 2 words). transformation = TransformationAddConstantScalar(28, 5, {13, 0}, true); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); constant_instruction = context->get_def_use_mgr()->GetDef(28); EXPECT_EQ(constant_instruction->NumInOperands(), 1); EXPECT_EQ(constant_instruction->NumInOperandWords(), 2); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Adds irrelevant 64-bit signed integer (1 logical operand with 2 words). transformation = TransformationAddConstantScalar(29, 6, {14, 0}, true); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); constant_instruction = context->get_def_use_mgr()->GetDef(29); EXPECT_EQ(constant_instruction->NumInOperands(), 1); EXPECT_EQ(constant_instruction->NumInOperandWords(), 2); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Adds irrelevant 64-bit float (1 logical operand with 2 words). transformation = TransformationAddConstantScalar( 30, 7, {0, 0b01000000001011100000000000000000}, true); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); constant_instruction = context->get_def_use_mgr()->GetDef(30); EXPECT_EQ(constant_instruction->NumInOperands(), 1); EXPECT_EQ(constant_instruction->NumInOperandWords(), 2); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); for (uint32_t result_id = 19; result_id <= 24; ++result_id) { ASSERT_FALSE( transformation_context.GetFactManager()->IdIsIrrelevant(result_id)); } for (uint32_t result_id = 25; result_id <= 30; ++result_id) { ASSERT_TRUE( transformation_context.GetFactManager()->IdIsIrrelevant(result_id)); } std::string variant_shader = R"( OpCapability Shader OpCapability Int64 OpCapability Float64 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %17 "main" ; Types ; 32-bit types %2 = OpTypeInt 32 0 %3 = OpTypeInt 32 1 %4 = OpTypeFloat 32 ; 64-bit types %5 = OpTypeInt 64 0 %6 = OpTypeInt 64 1 %7 = OpTypeFloat 64 %8 = OpTypePointer Private %2 %9 = OpTypeVoid %10 = OpTypeFunction %9 ; Constants ; 32-bit constants %11 = OpConstant %2 1 %12 = OpConstant %3 2 %13 = OpConstant %4 3 ; 64-bit constants %14 = OpConstant %5 1 %15 = OpConstant %6 2 %16 = OpConstant %7 3 ; added constants %19 = OpConstant %2 4 %20 = OpConstant %3 5 %21 = OpConstant %4 6 %22 = OpConstant %5 7 %23 = OpConstant %6 8 %24 = OpConstant %7 9 %25 = OpConstant %2 10 %26 = OpConstant %3 11 %27 = OpConstant %4 12 %28 = OpConstant %5 13 %29 = OpConstant %6 14 %30 = OpConstant %7 15 ; main function %17 = OpFunction %9 None %10 %18 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, variant_shader, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_add_copy_memory_test.cpp000066400000000000000000000455471475742701700305700ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_copy_memory.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationAddCopyMemoryTest, BasicTest) { std::string shader = R"( OpCapability Shader OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %19 RelaxedPrecision OpMemberDecorate %66 0 RelaxedPrecision OpDecorate %69 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpTypePointer Function %6 %78 = OpTypePointer Private %6 %8 = OpTypeFunction %6 %7 %17 = OpTypeInt 32 1 %18 = OpTypePointer Function %17 %79 = OpTypePointer Private %17 %20 = OpConstant %17 0 %21 = OpTypeFloat 32 %22 = OpTypePointer Function %21 %80 = OpTypePointer Private %21 %24 = OpConstant %21 0 %25 = OpConstantFalse %6 %32 = OpConstantTrue %6 %33 = OpTypeVector %21 4 %34 = OpTypePointer Function %33 %81 = OpTypePointer Private %33 %36 = OpConstantComposite %33 %24 %24 %24 %24 %37 = OpTypeMatrix %33 4 %84 = OpConstantComposite %37 %36 %36 %36 %36 %38 = OpTypePointer Function %37 %82 = OpTypePointer Private %37 %44 = OpConstant %21 1 %66 = OpTypeStruct %17 %21 %6 %33 %37 %85 = OpConstantComposite %66 %20 %24 %25 %36 %84 %67 = OpTypePointer Function %66 %83 = OpTypePointer Private %66 %86 = OpVariable %79 Private %20 %88 = OpConstantNull %79 %4 = OpFunction %2 None %3 %5 = OpLabel %19 = OpVariable %18 Function %23 = OpVariable %22 Function %26 = OpVariable %7 Function %30 = OpVariable %7 Function %35 = OpVariable %34 Function %39 = OpVariable %38 Function %68 = OpVariable %67 Function OpStore %19 %20 OpStore %23 %24 OpStore %26 %25 %27 = OpFunctionCall %6 %10 %26 OpSelectionMerge %29 None OpBranchConditional %27 %28 %31 %28 = OpLabel %89 = OpCopyObject %18 %19 OpBranch %29 %31 = OpLabel OpBranch %29 %76 = OpLabel %77 = OpLogicalEqual %6 %25 %32 OpBranch %29 %29 = OpLabel %75 = OpPhi %6 %25 %31 %32 %28 %77 %76 OpStore %30 %75 %40 = OpLoad %33 %35 %41 = OpLoad %33 %35 %42 = OpLoad %33 %35 %43 = OpLoad %33 %35 %45 = OpCompositeExtract %21 %40 0 %46 = OpCompositeExtract %21 %40 1 %47 = OpCompositeExtract %21 %40 2 %48 = OpCompositeExtract %21 %40 3 %49 = OpCompositeExtract %21 %41 0 %50 = OpCompositeExtract %21 %41 1 %51 = OpCompositeExtract %21 %41 2 %52 = OpCompositeExtract %21 %41 3 %53 = OpCompositeExtract %21 %42 0 %54 = OpCompositeExtract %21 %42 1 %55 = OpCompositeExtract %21 %42 2 %56 = OpCompositeExtract %21 %42 3 %57 = OpCompositeExtract %21 %43 0 %58 = OpCompositeExtract %21 %43 1 %59 = OpCompositeExtract %21 %43 2 %60 = OpCompositeExtract %21 %43 3 %61 = OpCompositeConstruct %33 %45 %46 %47 %48 %62 = OpCompositeConstruct %33 %49 %50 %51 %52 %63 = OpCompositeConstruct %33 %53 %54 %55 %56 %64 = OpCompositeConstruct %33 %57 %58 %59 %60 %65 = OpCompositeConstruct %37 %61 %62 %63 %64 OpStore %39 %65 %69 = OpLoad %17 %19 %70 = OpLoad %21 %23 %71 = OpLoad %6 %30 %72 = OpLoad %33 %35 %73 = OpLoad %37 %39 %74 = OpCompositeConstruct %66 %69 %70 %71 %72 %73 OpStore %68 %74 OpReturn OpFunctionEnd %10 = OpFunction %6 None %8 %9 = OpFunctionParameter %7 %11 = OpLabel %12 = OpVariable %7 Function %13 = OpLoad %6 %9 OpStore %12 %13 %14 = OpLoad %6 %12 OpReturnValue %14 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Target id is not fresh (59). ASSERT_FALSE(TransformationAddCopyMemory( MakeInstructionDescriptor(27, spv::Op::OpFunctionCall, 0), 59, 19, spv::StorageClass::Private, 20) .IsApplicable(context.get(), transformation_context)); // Instruction descriptor is invalid (id 90 is undefined). ASSERT_FALSE(TransformationAddCopyMemory( MakeInstructionDescriptor(90, spv::Op::OpVariable, 0), 90, 19, spv::StorageClass::Private, 20) .IsApplicable(context.get(), transformation_context)); // Cannot insert OpCopyMemory before OpPhi. ASSERT_FALSE(TransformationAddCopyMemory( MakeInstructionDescriptor(75, spv::Op::OpPhi, 0), 90, 19, spv::StorageClass::Private, 20) .IsApplicable(context.get(), transformation_context)); // Source instruction is invalid. ASSERT_FALSE(TransformationAddCopyMemory( MakeInstructionDescriptor(27, spv::Op::OpFunctionCall, 0), 90, 76, spv::StorageClass::Private, 0) .IsApplicable(context.get(), transformation_context)); // Source instruction's type doesn't exist. ASSERT_FALSE(TransformationAddCopyMemory( MakeInstructionDescriptor(27, spv::Op::OpFunctionCall, 0), 90, 5, spv::StorageClass::Private, 0) .IsApplicable(context.get(), transformation_context)); // Source instruction's type is invalid. ASSERT_FALSE(TransformationAddCopyMemory( MakeInstructionDescriptor(41, spv::Op::OpLoad, 0), 90, 40, spv::StorageClass::Private, 0) .IsApplicable(context.get(), transformation_context)); // Source instruction is OpConstantNull. ASSERT_FALSE(TransformationAddCopyMemory( MakeInstructionDescriptor(41, spv::Op::OpLoad, 0), 90, 88, spv::StorageClass::Private, 0) .IsApplicable(context.get(), transformation_context)); // Storage class is invalid. ASSERT_FALSE(TransformationAddCopyMemory( MakeInstructionDescriptor(27, spv::Op::OpFunctionCall, 0), 90, 19, spv::StorageClass::Workgroup, 20) .IsApplicable(context.get(), transformation_context)); // Initializer is 0. ASSERT_FALSE(TransformationAddCopyMemory( MakeInstructionDescriptor(27, spv::Op::OpFunctionCall, 0), 90, 19, spv::StorageClass::Private, 0) .IsApplicable(context.get(), transformation_context)); // Initializer has wrong type. ASSERT_FALSE(TransformationAddCopyMemory( MakeInstructionDescriptor(27, spv::Op::OpFunctionCall, 0), 90, 19, spv::StorageClass::Private, 25) .IsApplicable(context.get(), transformation_context)); // Source and target instructions are in different functions. ASSERT_FALSE(TransformationAddCopyMemory( MakeInstructionDescriptor(13, spv::Op::OpLoad, 0), 90, 19, spv::StorageClass::Private, 20) .IsApplicable(context.get(), transformation_context)); // Source instruction doesn't dominate the target instruction. ASSERT_FALSE(TransformationAddCopyMemory( MakeInstructionDescriptor(77, spv::Op::OpLogicalEqual, 0), 90, 89, spv::StorageClass::Private, 20) .IsApplicable(context.get(), transformation_context)); // Source and target instructions are the same. ASSERT_FALSE(TransformationAddCopyMemory( MakeInstructionDescriptor(19, spv::Op::OpVariable, 0), 90, 19, spv::StorageClass::Private, 20) .IsApplicable(context.get(), transformation_context)); // Correct transformations. uint32_t fresh_id = 90; auto descriptor = MakeInstructionDescriptor(27, spv::Op::OpFunctionCall, 0); std::vector source_ids = {19, 23, 26, 30, 35, 39, 68, 86}; std::vector initializers = {20, 24, 25, 25, 36, 84, 85, 20}; std::vector storage_classes = { spv::StorageClass::Private, spv::StorageClass::Function}; for (size_t i = 0, n = source_ids.size(); i < n; ++i) { TransformationAddCopyMemory transformation( descriptor, fresh_id, source_ids[i], storage_classes[i % storage_classes.size()], initializers[i]); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant( fresh_id)); fresh_id++; } std::string expected = R"( OpCapability Shader OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %19 RelaxedPrecision OpMemberDecorate %66 0 RelaxedPrecision OpDecorate %69 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpTypePointer Function %6 %78 = OpTypePointer Private %6 %8 = OpTypeFunction %6 %7 %17 = OpTypeInt 32 1 %18 = OpTypePointer Function %17 %79 = OpTypePointer Private %17 %20 = OpConstant %17 0 %21 = OpTypeFloat 32 %22 = OpTypePointer Function %21 %80 = OpTypePointer Private %21 %24 = OpConstant %21 0 %25 = OpConstantFalse %6 %32 = OpConstantTrue %6 %33 = OpTypeVector %21 4 %34 = OpTypePointer Function %33 %81 = OpTypePointer Private %33 %36 = OpConstantComposite %33 %24 %24 %24 %24 %37 = OpTypeMatrix %33 4 %84 = OpConstantComposite %37 %36 %36 %36 %36 %38 = OpTypePointer Function %37 %82 = OpTypePointer Private %37 %44 = OpConstant %21 1 %66 = OpTypeStruct %17 %21 %6 %33 %37 %85 = OpConstantComposite %66 %20 %24 %25 %36 %84 %67 = OpTypePointer Function %66 %83 = OpTypePointer Private %66 %86 = OpVariable %79 Private %20 %88 = OpConstantNull %79 %90 = OpVariable %79 Private %20 %92 = OpVariable %78 Private %25 %94 = OpVariable %81 Private %36 %96 = OpVariable %83 Private %85 %4 = OpFunction %2 None %3 %5 = OpLabel %97 = OpVariable %18 Function %20 %95 = OpVariable %38 Function %84 %93 = OpVariable %7 Function %25 %91 = OpVariable %22 Function %24 %19 = OpVariable %18 Function %23 = OpVariable %22 Function %26 = OpVariable %7 Function %30 = OpVariable %7 Function %35 = OpVariable %34 Function %39 = OpVariable %38 Function %68 = OpVariable %67 Function OpStore %19 %20 OpStore %23 %24 OpStore %26 %25 OpCopyMemory %90 %19 OpCopyMemory %91 %23 OpCopyMemory %92 %26 OpCopyMemory %93 %30 OpCopyMemory %94 %35 OpCopyMemory %95 %39 OpCopyMemory %96 %68 OpCopyMemory %97 %86 %27 = OpFunctionCall %6 %10 %26 OpSelectionMerge %29 None OpBranchConditional %27 %28 %31 %28 = OpLabel %89 = OpCopyObject %18 %19 OpBranch %29 %31 = OpLabel OpBranch %29 %76 = OpLabel %77 = OpLogicalEqual %6 %25 %32 OpBranch %29 %29 = OpLabel %75 = OpPhi %6 %25 %31 %32 %28 %77 %76 OpStore %30 %75 %40 = OpLoad %33 %35 %41 = OpLoad %33 %35 %42 = OpLoad %33 %35 %43 = OpLoad %33 %35 %45 = OpCompositeExtract %21 %40 0 %46 = OpCompositeExtract %21 %40 1 %47 = OpCompositeExtract %21 %40 2 %48 = OpCompositeExtract %21 %40 3 %49 = OpCompositeExtract %21 %41 0 %50 = OpCompositeExtract %21 %41 1 %51 = OpCompositeExtract %21 %41 2 %52 = OpCompositeExtract %21 %41 3 %53 = OpCompositeExtract %21 %42 0 %54 = OpCompositeExtract %21 %42 1 %55 = OpCompositeExtract %21 %42 2 %56 = OpCompositeExtract %21 %42 3 %57 = OpCompositeExtract %21 %43 0 %58 = OpCompositeExtract %21 %43 1 %59 = OpCompositeExtract %21 %43 2 %60 = OpCompositeExtract %21 %43 3 %61 = OpCompositeConstruct %33 %45 %46 %47 %48 %62 = OpCompositeConstruct %33 %49 %50 %51 %52 %63 = OpCompositeConstruct %33 %53 %54 %55 %56 %64 = OpCompositeConstruct %33 %57 %58 %59 %60 %65 = OpCompositeConstruct %37 %61 %62 %63 %64 OpStore %39 %65 %69 = OpLoad %17 %19 %70 = OpLoad %21 %23 %71 = OpLoad %6 %30 %72 = OpLoad %33 %35 %73 = OpLoad %37 %39 %74 = OpCompositeConstruct %66 %69 %70 %71 %72 %73 OpStore %68 %74 OpReturn OpFunctionEnd %10 = OpFunction %6 None %8 %9 = OpFunctionParameter %7 %11 = OpLabel %12 = OpVariable %7 Function %13 = OpLoad %6 %9 OpStore %12 %13 %14 = OpLoad %6 %12 OpReturnValue %14 OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected, context.get())); } TEST(TransformationAddCopyMemoryTest, DisallowBufferBlockDecoration) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 320 OpName %4 "main" OpName %7 "buf" OpMemberName %7 0 "a" OpMemberName %7 1 "b" OpName %9 "" OpMemberDecorate %7 0 Offset 0 OpMemberDecorate %7 1 Offset 4 OpDecorate %7 BufferBlock OpDecorate %9 DescriptorSet 0 OpDecorate %9 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %10 = OpConstant %6 42 %7 = OpTypeStruct %6 %6 %8 = OpTypePointer Uniform %7 %9 = OpVariable %8 Uniform %50 = OpUndef %7 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_0; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_FALSE(TransformationAddCopyMemory( MakeInstructionDescriptor(5, spv::Op::OpReturn, 0), 100, 9, spv::StorageClass::Private, 50) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationAddCopyMemoryTest, DisallowBlockDecoration) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" %9 OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 320 OpName %4 "main" OpName %7 "buf" OpMemberName %7 0 "a" OpMemberName %7 1 "b" OpName %9 "" OpMemberDecorate %7 0 Offset 0 OpMemberDecorate %7 1 Offset 4 OpDecorate %7 Block OpDecorate %9 DescriptorSet 0 OpDecorate %9 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %10 = OpConstant %6 42 %7 = OpTypeStruct %6 %6 %8 = OpTypePointer StorageBuffer %7 %9 = OpVariable %8 StorageBuffer %50 = OpUndef %7 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_FALSE(TransformationAddCopyMemory( MakeInstructionDescriptor(5, spv::Op::OpReturn, 0), 100, 9, spv::StorageClass::Private, 50) .IsApplicable(context.get(), transformation_context)); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_add_dead_block_test.cpp000066400000000000000000000406431475742701700302650ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_dead_block.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationAddDeadBlockTest, BasicTest) { std::string reference_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %6 "main" OpExecutionMode %6 OriginUpperLeft ; Types %2 = OpTypeBool %3 = OpTypeVoid %4 = OpTypeFunction %3 ; Constants %5 = OpConstantTrue %2 ; main function %6 = OpFunction %3 None %4 %7 = OpLabel OpSelectionMerge %11 None OpBranchConditional %5 %8 %9 %8 = OpLabel OpBranch %10 %9 = OpLabel OpBranch %10 %10 = OpLabel OpBranch %11 %11 = OpLabel OpBranch %13 %12 = OpLabel OpBranch %13 %13 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Id 4 is already in use auto transformation = TransformationAddDeadBlock(4, 11, true); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Id 5 is not a block transformation = TransformationAddDeadBlock(14, 5, true); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests existing block not dominating its successor block. transformation = TransformationAddDeadBlock(14, 8, true); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); transformation = TransformationAddDeadBlock(14, 9, true); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests existing block being an unreachable block. transformation = TransformationAddDeadBlock(14, 12, true); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests applicable case. transformation = TransformationAddDeadBlock(14, 11, true); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->BlockIsDead(14)); std::string variant_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %6 "main" OpExecutionMode %6 OriginUpperLeft ; Types %2 = OpTypeBool %3 = OpTypeVoid %4 = OpTypeFunction %3 ; Constants %5 = OpConstantTrue %2 ; main function %6 = OpFunction %3 None %4 %7 = OpLabel OpSelectionMerge %11 None OpBranchConditional %5 %8 %9 %8 = OpLabel OpBranch %10 %9 = OpLabel OpBranch %10 %10 = OpLabel OpBranch %11 %11 = OpLabel OpSelectionMerge %13 None OpBranchConditional %5 %13 %14 %14 = OpLabel OpBranch %13 %12 = OpLabel OpBranch %13 %13 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(IsEqual(env, variant_shader, context.get())); } TEST(TransformationAddDeadBlockTest, ApplicableWithFalseCondition) { std::string reference_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %6 "main" OpExecutionMode %6 OriginUpperLeft ; Types %2 = OpTypeBool %3 = OpTypeVoid %4 = OpTypeFunction %3 ; Constants %5 = OpConstantFalse %2 ; main function %6 = OpFunction %3 None %4 %7 = OpLabel OpSelectionMerge %11 None OpBranchConditional %5 %8 %9 %8 = OpLabel OpBranch %10 %9 = OpLabel OpBranch %10 %10 = OpLabel OpBranch %11 %11 = OpLabel OpBranch %13 %12 = OpLabel OpBranch %13 %13 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto transformation = TransformationAddDeadBlock(14, 11, false); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); std::string variant_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %6 "main" OpExecutionMode %6 OriginUpperLeft ; Types %2 = OpTypeBool %3 = OpTypeVoid %4 = OpTypeFunction %3 ; Constants %5 = OpConstantFalse %2 ; main function %6 = OpFunction %3 None %4 %7 = OpLabel OpSelectionMerge %11 None OpBranchConditional %5 %8 %9 %8 = OpLabel OpBranch %10 %9 = OpLabel OpBranch %10 %10 = OpLabel OpBranch %11 %11 = OpLabel OpSelectionMerge %13 None OpBranchConditional %5 %14 %13 %14 = OpLabel OpBranch %13 %12 = OpLabel OpBranch %13 %13 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(IsEqual(env, variant_shader, context.get())); } TEST(TransformationAddDeadBlockTest, TargetBlockMustNotBeSelectionMerge) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantTrue %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %10 None OpBranchConditional %7 %8 %9 %8 = OpLabel OpBranch %10 %9 = OpLabel OpBranch %10 %10 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_FALSE(TransformationAddDeadBlock(100, 9, true) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationAddDeadBlockTest, TargetBlockMustNotBeLoopMergeOrContinue) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %6 "main" OpExecutionMode %6 OriginUpperLeft ; Types %2 = OpTypeBool %3 = OpTypeVoid %4 = OpTypeFunction %3 ; Constants %5 = OpConstantTrue %2 ; main function %6 = OpFunction %3 None %4 %7 = OpLabel OpBranch %8 %8 = OpLabel OpLoopMerge %12 %11 None OpBranch %13 %13 = OpLabel OpSelectionMerge %14 None OpBranchConditional %5 %9 %10 %9 = OpLabel OpBranch %11 %10 = OpLabel OpBranch %12 %14 = OpLabel OpUnreachable %11 = OpLabel OpBranch %8 %12 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Bad because 9's successor is the loop continue target. ASSERT_FALSE(TransformationAddDeadBlock(100, 9, true) .IsApplicable(context.get(), transformation_context)); // Bad because 10's successor is the loop merge. ASSERT_FALSE(TransformationAddDeadBlock(100, 10, true) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationAddDeadBlockTest, SourceBlockMustNotBeLoopHead) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantTrue %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %8 %8 = OpLabel OpLoopMerge %11 %12 None OpBranch %9 %9 = OpLabel OpBranchConditional %7 %11 %12 %12 = OpLabel OpBranch %8 %11 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Bad because 8 is a loop head. ASSERT_FALSE(TransformationAddDeadBlock(100, 8, true) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationAddDeadBlockTest, OpPhiInTarget) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantTrue %6 %9 = OpTypeInt 32 0 %10 = OpConstant %9 1 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %8 %8 = OpLabel %12 = OpPhi %6 %7 %5 %13 = OpPhi %9 %10 %5 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationAddDeadBlock transformation(100, 5, true); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->BlockIsDead(100)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantTrue %6 %9 = OpTypeInt 32 0 %10 = OpConstant %9 1 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %8 None OpBranchConditional %7 %8 %100 %100 = OpLabel OpBranch %8 %8 = OpLabel %12 = OpPhi %6 %7 %5 %7 %100 %13 = OpPhi %9 %10 %5 %10 %100 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationAddDeadBlockTest, BackEdge) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantTrue %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %8 %8 = OpLabel OpLoopMerge %10 %9 None OpBranchConditional %7 %9 %10 %9 = OpLabel OpBranch %8 %10 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // 9 is a back edge block, so it would not be OK to add a dead block here, // as then both 9 and the dead block would branch to the loop header, 8. ASSERT_FALSE(TransformationAddDeadBlock(100, 9, true) .IsApplicable(context.get(), transformation_context)); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_add_dead_break_test.cpp000066400000000000000000003241621475742701700302600ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_dead_break.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationAddDeadBreakTest, BreaksOutOfSimpleIf) { // For a simple if-then-else, checks that some dead break scenarios are // possible, and that some invalid scenarios are indeed not allowed. // The SPIR-V for this test is adapted from the following GLSL, by separating // some assignments into their own basic blocks, and adding constants for true // and false: // // void main() { // int x; // int y; // x = 1; // if (x < y) { // x = 2; // x = 3; // } else { // y = 2; // y = 3; // } // x = y; // } std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "x" OpName %11 "y" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %13 = OpTypeBool %17 = OpConstant %6 2 %18 = OpConstant %6 3 %25 = OpConstantTrue %13 %26 = OpConstantFalse %13 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %11 = OpVariable %7 Function OpStore %8 %9 %10 = OpLoad %6 %8 %12 = OpLoad %6 %11 %14 = OpSLessThan %13 %10 %12 OpSelectionMerge %16 None OpBranchConditional %14 %15 %19 %15 = OpLabel OpStore %8 %17 OpBranch %21 %21 = OpLabel OpStore %8 %18 OpBranch %22 %22 = OpLabel OpBranch %16 %19 = OpLabel OpStore %11 %17 OpBranch %23 %23 = OpLabel OpStore %11 %18 OpBranch %24 %24 = OpLabel OpBranch %16 %16 = OpLabel %20 = OpLoad %6 %11 OpStore %8 %20 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); const uint32_t merge_block = 16; // These are all possibilities. ASSERT_TRUE(TransformationAddDeadBreak(15, merge_block, true, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationAddDeadBreak(15, merge_block, false, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationAddDeadBreak(21, merge_block, true, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationAddDeadBreak(21, merge_block, false, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationAddDeadBreak(22, merge_block, true, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationAddDeadBreak(22, merge_block, false, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationAddDeadBreak(19, merge_block, true, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationAddDeadBreak(19, merge_block, false, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationAddDeadBreak(23, merge_block, true, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationAddDeadBreak(23, merge_block, false, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationAddDeadBreak(24, merge_block, true, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationAddDeadBreak(24, merge_block, false, {}) .IsApplicable(context.get(), transformation_context)); // Inapplicable: 100 is not a block id. ASSERT_FALSE(TransformationAddDeadBreak(100, merge_block, true, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationAddDeadBreak(15, 100, true, {}) .IsApplicable(context.get(), transformation_context)); // Inapplicable: 24 is not a merge block. ASSERT_FALSE(TransformationAddDeadBreak(15, 24, true, {}) .IsApplicable(context.get(), transformation_context)); // These are the transformations we will apply. auto transformation1 = TransformationAddDeadBreak(15, merge_block, true, {}); auto transformation2 = TransformationAddDeadBreak(21, merge_block, false, {}); auto transformation3 = TransformationAddDeadBreak(22, merge_block, true, {}); auto transformation4 = TransformationAddDeadBreak(19, merge_block, false, {}); auto transformation5 = TransformationAddDeadBreak(23, merge_block, true, {}); auto transformation6 = TransformationAddDeadBreak(24, merge_block, false, {}); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation3.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation3, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation4.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation4, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation5.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation5, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation6.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation6, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "x" OpName %11 "y" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %13 = OpTypeBool %17 = OpConstant %6 2 %18 = OpConstant %6 3 %25 = OpConstantTrue %13 %26 = OpConstantFalse %13 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %11 = OpVariable %7 Function OpStore %8 %9 %10 = OpLoad %6 %8 %12 = OpLoad %6 %11 %14 = OpSLessThan %13 %10 %12 OpSelectionMerge %16 None OpBranchConditional %14 %15 %19 %15 = OpLabel OpStore %8 %17 OpBranchConditional %25 %21 %16 %21 = OpLabel OpStore %8 %18 OpBranchConditional %26 %16 %22 %22 = OpLabel OpBranchConditional %25 %16 %16 %19 = OpLabel OpStore %11 %17 OpBranchConditional %26 %16 %23 %23 = OpLabel OpStore %11 %18 OpBranchConditional %25 %24 %16 %24 = OpLabel OpBranchConditional %26 %16 %16 %16 = OpLabel %20 = OpLoad %6 %11 OpStore %8 %20 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationAddDeadBreakTest, BreakOutOfNestedIfs) { // Checks some allowed and disallowed scenarios for nests of ifs. // The SPIR-V for this test is adapted from the following GLSL: // // void main() { // int x; // int y; // x = 1; // if (x < y) { // x = 2; // x = 3; // if (x == y) { // y = 3; // } // } else { // y = 2; // y = 3; // } // if (x == y) { // x = 2; // } // x = y; // } std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "x" OpName %11 "y" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %13 = OpTypeBool %17 = OpConstant %6 2 %18 = OpConstant %6 3 %31 = OpConstantTrue %13 %32 = OpConstantFalse %13 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %11 = OpVariable %7 Function OpStore %8 %9 %10 = OpLoad %6 %8 %12 = OpLoad %6 %11 %14 = OpSLessThan %13 %10 %12 OpSelectionMerge %16 None OpBranchConditional %14 %15 %24 %15 = OpLabel OpStore %8 %17 OpBranch %33 %33 = OpLabel OpStore %8 %18 %19 = OpLoad %6 %8 OpBranch %34 %34 = OpLabel %20 = OpLoad %6 %11 %21 = OpIEqual %13 %19 %20 OpSelectionMerge %23 None OpBranchConditional %21 %22 %23 %22 = OpLabel OpStore %11 %18 OpBranch %35 %35 = OpLabel OpBranch %23 %23 = OpLabel OpBranch %16 %24 = OpLabel OpStore %11 %17 OpBranch %36 %36 = OpLabel OpStore %11 %18 OpBranch %16 %16 = OpLabel %25 = OpLoad %6 %8 OpBranch %37 %37 = OpLabel %26 = OpLoad %6 %11 %27 = OpIEqual %13 %25 %26 OpSelectionMerge %29 None OpBranchConditional %27 %28 %29 %28 = OpLabel OpStore %8 %17 OpBranch %38 %38 = OpLabel OpBranch %29 %29 = OpLabel %30 = OpLoad %6 %11 OpStore %8 %30 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // The header and merge blocks const uint32_t header_inner = 34; const uint32_t merge_inner = 23; const uint32_t header_outer = 5; const uint32_t merge_outer = 16; const uint32_t header_after = 37; const uint32_t merge_after = 29; // The non-merge-nor-header blocks in each construct const uint32_t inner_block_1 = 22; const uint32_t inner_block_2 = 35; const uint32_t outer_block_1 = 15; const uint32_t outer_block_2 = 33; const uint32_t outer_block_3 = 24; const uint32_t outer_block_4 = 36; const uint32_t after_block_1 = 28; const uint32_t after_block_2 = 38; // Fine to break from a construct to its merge ASSERT_TRUE(TransformationAddDeadBreak(inner_block_1, merge_inner, true, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationAddDeadBreak(inner_block_2, merge_inner, false, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationAddDeadBreak(outer_block_1, merge_outer, true, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationAddDeadBreak(outer_block_2, merge_outer, false, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationAddDeadBreak(outer_block_3, merge_outer, true, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationAddDeadBreak(outer_block_4, merge_outer, false, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationAddDeadBreak(after_block_1, merge_after, true, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationAddDeadBreak(after_block_2, merge_after, false, {}) .IsApplicable(context.get(), transformation_context)); // Not OK to break to the wrong merge (whether enclosing or not) ASSERT_FALSE(TransformationAddDeadBreak(inner_block_1, merge_outer, true, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationAddDeadBreak(inner_block_2, merge_after, false, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationAddDeadBreak(outer_block_1, merge_inner, true, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationAddDeadBreak(outer_block_2, merge_after, false, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationAddDeadBreak(after_block_1, merge_inner, true, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationAddDeadBreak(after_block_2, merge_outer, false, {}) .IsApplicable(context.get(), transformation_context)); // Not OK to break from header (as it does not branch unconditionally) ASSERT_FALSE(TransformationAddDeadBreak(header_inner, merge_inner, true, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationAddDeadBreak(header_outer, merge_outer, false, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationAddDeadBreak(header_after, merge_after, true, {}) .IsApplicable(context.get(), transformation_context)); // Not OK to break to non-merge ASSERT_FALSE( TransformationAddDeadBreak(inner_block_1, inner_block_2, true, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( TransformationAddDeadBreak(outer_block_2, after_block_1, false, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationAddDeadBreak(outer_block_1, header_after, true, {}) .IsApplicable(context.get(), transformation_context)); auto transformation1 = TransformationAddDeadBreak(inner_block_1, merge_inner, true, {}); auto transformation2 = TransformationAddDeadBreak(inner_block_2, merge_inner, false, {}); auto transformation3 = TransformationAddDeadBreak(outer_block_1, merge_outer, true, {}); auto transformation4 = TransformationAddDeadBreak(outer_block_2, merge_outer, false, {}); auto transformation5 = TransformationAddDeadBreak(outer_block_3, merge_outer, true, {}); auto transformation6 = TransformationAddDeadBreak(outer_block_4, merge_outer, false, {}); auto transformation7 = TransformationAddDeadBreak(after_block_1, merge_after, true, {}); auto transformation8 = TransformationAddDeadBreak(after_block_2, merge_after, false, {}); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation3.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation3, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation4.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation4, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation5.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation5, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation6.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation6, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation7.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation7, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation8.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation8, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "x" OpName %11 "y" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %13 = OpTypeBool %17 = OpConstant %6 2 %18 = OpConstant %6 3 %31 = OpConstantTrue %13 %32 = OpConstantFalse %13 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %11 = OpVariable %7 Function OpStore %8 %9 %10 = OpLoad %6 %8 %12 = OpLoad %6 %11 %14 = OpSLessThan %13 %10 %12 OpSelectionMerge %16 None OpBranchConditional %14 %15 %24 %15 = OpLabel OpStore %8 %17 OpBranchConditional %31 %33 %16 %33 = OpLabel OpStore %8 %18 %19 = OpLoad %6 %8 OpBranchConditional %32 %16 %34 %34 = OpLabel %20 = OpLoad %6 %11 %21 = OpIEqual %13 %19 %20 OpSelectionMerge %23 None OpBranchConditional %21 %22 %23 %22 = OpLabel OpStore %11 %18 OpBranchConditional %31 %35 %23 %35 = OpLabel OpBranchConditional %32 %23 %23 %23 = OpLabel OpBranch %16 %24 = OpLabel OpStore %11 %17 OpBranchConditional %31 %36 %16 %36 = OpLabel OpStore %11 %18 OpBranchConditional %32 %16 %16 %16 = OpLabel %25 = OpLoad %6 %8 OpBranch %37 %37 = OpLabel %26 = OpLoad %6 %11 %27 = OpIEqual %13 %25 %26 OpSelectionMerge %29 None OpBranchConditional %27 %28 %29 %28 = OpLabel OpStore %8 %17 OpBranchConditional %31 %38 %29 %38 = OpLabel OpBranchConditional %32 %29 %29 %29 = OpLabel %30 = OpLoad %6 %11 OpStore %8 %30 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationAddDeadBreakTest, BreakOutOfNestedSwitches) { // Checks some allowed and disallowed scenarios for nests of switches. // The SPIR-V for this test is adapted from the following GLSL: // // void main() { // int x; // int y; // x = 1; // if (x < y) { // switch (x) { // case 0: // case 1: // if (x == y) { // } // x = 2; // break; // case 3: // if (y == 4) { // y = 2; // x = 3; // } // case 10: // break; // default: // switch (y) { // case 1: // break; // case 2: // x = 4; // y = 2; // default: // x = 3; // break; // } // } // } else { // switch (y) { // case 1: // x = 4; // case 2: // y = 3; // default: // x = y; // break; // } // } // } std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "x" OpName %11 "y" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %13 = OpTypeBool %29 = OpConstant %6 2 %32 = OpConstant %6 4 %36 = OpConstant %6 3 %60 = OpConstantTrue %13 %61 = OpConstantFalse %13 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %11 = OpVariable %7 Function OpStore %8 %9 %10 = OpLoad %6 %8 %12 = OpLoad %6 %11 %14 = OpSLessThan %13 %10 %12 OpSelectionMerge %16 None OpBranchConditional %14 %15 %47 %15 = OpLabel %17 = OpLoad %6 %8 OpSelectionMerge %22 None OpSwitch %17 %21 0 %18 1 %18 3 %19 10 %20 %21 = OpLabel %38 = OpLoad %6 %11 OpSelectionMerge %42 None OpSwitch %38 %41 1 %39 2 %40 %41 = OpLabel OpStore %8 %36 OpBranch %42 %39 = OpLabel OpBranch %42 %40 = OpLabel OpStore %8 %32 OpStore %11 %29 OpBranch %41 %42 = OpLabel OpBranch %22 %18 = OpLabel %23 = OpLoad %6 %8 OpBranch %63 %63 = OpLabel %24 = OpLoad %6 %11 %25 = OpIEqual %13 %23 %24 OpSelectionMerge %27 None OpBranchConditional %25 %26 %27 %26 = OpLabel OpBranch %27 %27 = OpLabel OpStore %8 %29 OpBranch %22 %19 = OpLabel %31 = OpLoad %6 %11 %33 = OpIEqual %13 %31 %32 OpSelectionMerge %35 None OpBranchConditional %33 %34 %35 %34 = OpLabel OpStore %11 %29 OpBranch %62 %62 = OpLabel OpStore %8 %36 OpBranch %35 %35 = OpLabel OpBranch %20 %20 = OpLabel OpBranch %22 %22 = OpLabel OpBranch %16 %47 = OpLabel %48 = OpLoad %6 %11 OpSelectionMerge %52 None OpSwitch %48 %51 1 %49 2 %50 %51 = OpLabel %53 = OpLoad %6 %11 OpStore %8 %53 OpBranch %52 %49 = OpLabel OpStore %8 %32 OpBranch %50 %50 = OpLabel OpStore %11 %36 OpBranch %51 %52 = OpLabel OpBranch %16 %16 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // The header and merge blocks const uint32_t header_outer_if = 5; const uint32_t merge_outer_if = 16; const uint32_t header_then_outer_switch = 15; const uint32_t merge_then_outer_switch = 22; const uint32_t header_then_inner_switch = 21; const uint32_t merge_then_inner_switch = 42; const uint32_t header_else_switch = 47; const uint32_t merge_else_switch = 52; const uint32_t header_inner_if_1 = 19; const uint32_t merge_inner_if_1 = 35; const uint32_t header_inner_if_2 = 63; const uint32_t merge_inner_if_2 = 27; // The non-merge-nor-header blocks in each construct const uint32_t then_outer_switch_block_1 = 18; const uint32_t then_inner_switch_block_1 = 39; const uint32_t then_inner_switch_block_2 = 40; const uint32_t then_inner_switch_block_3 = 41; const uint32_t else_switch_block_1 = 49; const uint32_t else_switch_block_2 = 50; const uint32_t else_switch_block_3 = 51; const uint32_t inner_if_1_block_1 = 34; const uint32_t inner_if_1_block_2 = 62; const uint32_t inner_if_2_block_1 = 26; // Fine to branch straight to direct merge block for a construct ASSERT_TRUE(TransformationAddDeadBreak(then_outer_switch_block_1, merge_then_outer_switch, true, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationAddDeadBreak(then_inner_switch_block_1, merge_then_inner_switch, false, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationAddDeadBreak(then_inner_switch_block_2, merge_then_inner_switch, true, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationAddDeadBreak(then_inner_switch_block_3, merge_then_inner_switch, true, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationAddDeadBreak(else_switch_block_1, merge_else_switch, false, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationAddDeadBreak(else_switch_block_2, merge_else_switch, true, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationAddDeadBreak(else_switch_block_3, merge_else_switch, false, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE( TransformationAddDeadBreak(inner_if_1_block_1, merge_inner_if_1, true, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationAddDeadBreak(inner_if_1_block_2, merge_inner_if_1, false, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE( TransformationAddDeadBreak(inner_if_2_block_1, merge_inner_if_2, true, {}) .IsApplicable(context.get(), transformation_context)); // Not OK to break out of a switch from a selection construct inside the // switch. ASSERT_FALSE(TransformationAddDeadBreak(inner_if_1_block_1, merge_then_outer_switch, true, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationAddDeadBreak(inner_if_1_block_2, merge_then_outer_switch, false, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationAddDeadBreak(inner_if_2_block_1, merge_then_outer_switch, true, {}) .IsApplicable(context.get(), transformation_context)); // Some miscellaneous inapplicable cases. ASSERT_FALSE( TransformationAddDeadBreak(header_outer_if, merge_outer_if, true, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationAddDeadBreak(header_inner_if_1, inner_if_1_block_2, false, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationAddDeadBreak(header_then_inner_switch, header_then_outer_switch, false, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationAddDeadBreak(header_else_switch, then_inner_switch_block_3, false, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationAddDeadBreak(header_inner_if_2, header_inner_if_2, false, {}) .IsApplicable(context.get(), transformation_context)); auto transformation1 = TransformationAddDeadBreak( then_outer_switch_block_1, merge_then_outer_switch, true, {}); auto transformation2 = TransformationAddDeadBreak( then_inner_switch_block_1, merge_then_inner_switch, false, {}); auto transformation3 = TransformationAddDeadBreak( then_inner_switch_block_2, merge_then_inner_switch, true, {}); auto transformation4 = TransformationAddDeadBreak( then_inner_switch_block_3, merge_then_inner_switch, true, {}); auto transformation5 = TransformationAddDeadBreak( else_switch_block_1, merge_else_switch, false, {}); auto transformation6 = TransformationAddDeadBreak( else_switch_block_2, merge_else_switch, true, {}); auto transformation7 = TransformationAddDeadBreak( else_switch_block_3, merge_else_switch, false, {}); auto transformation8 = TransformationAddDeadBreak(inner_if_1_block_1, merge_inner_if_1, true, {}); auto transformation9 = TransformationAddDeadBreak( inner_if_1_block_2, merge_inner_if_1, false, {}); auto transformation10 = TransformationAddDeadBreak( inner_if_2_block_1, merge_inner_if_2, true, {}); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation3.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation3, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation4.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation4, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation5.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation5, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation6.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation6, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation7.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation7, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation8.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation8, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation9.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation9, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation10.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation10, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "x" OpName %11 "y" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %13 = OpTypeBool %29 = OpConstant %6 2 %32 = OpConstant %6 4 %36 = OpConstant %6 3 %60 = OpConstantTrue %13 %61 = OpConstantFalse %13 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %11 = OpVariable %7 Function OpStore %8 %9 %10 = OpLoad %6 %8 %12 = OpLoad %6 %11 %14 = OpSLessThan %13 %10 %12 OpSelectionMerge %16 None OpBranchConditional %14 %15 %47 %15 = OpLabel %17 = OpLoad %6 %8 OpSelectionMerge %22 None OpSwitch %17 %21 0 %18 1 %18 3 %19 10 %20 %21 = OpLabel %38 = OpLoad %6 %11 OpSelectionMerge %42 None OpSwitch %38 %41 1 %39 2 %40 %41 = OpLabel OpStore %8 %36 OpBranchConditional %60 %42 %42 %39 = OpLabel OpBranchConditional %61 %42 %42 %40 = OpLabel OpStore %8 %32 OpStore %11 %29 OpBranchConditional %60 %41 %42 %42 = OpLabel OpBranch %22 %18 = OpLabel %23 = OpLoad %6 %8 OpBranchConditional %60 %63 %22 %63 = OpLabel %24 = OpLoad %6 %11 %25 = OpIEqual %13 %23 %24 OpSelectionMerge %27 None OpBranchConditional %25 %26 %27 %26 = OpLabel OpBranchConditional %60 %27 %27 %27 = OpLabel OpStore %8 %29 OpBranch %22 %19 = OpLabel %31 = OpLoad %6 %11 %33 = OpIEqual %13 %31 %32 OpSelectionMerge %35 None OpBranchConditional %33 %34 %35 %34 = OpLabel OpStore %11 %29 OpBranchConditional %60 %62 %35 %62 = OpLabel OpStore %8 %36 OpBranchConditional %61 %35 %35 %35 = OpLabel OpBranch %20 %20 = OpLabel OpBranch %22 %22 = OpLabel OpBranch %16 %47 = OpLabel %48 = OpLoad %6 %11 OpSelectionMerge %52 None OpSwitch %48 %51 1 %49 2 %50 %51 = OpLabel %53 = OpLoad %6 %11 OpStore %8 %53 OpBranchConditional %61 %52 %52 %49 = OpLabel OpStore %8 %32 OpBranchConditional %61 %52 %50 %50 = OpLabel OpStore %11 %36 OpBranchConditional %60 %51 %52 %52 = OpLabel OpBranch %16 %16 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationAddDeadBreakTest, BreakOutOfLoopNest) { // Checks some allowed and disallowed scenarios for a nest of loops, including // breaking from an if or switch right out of a loop. // The SPIR-V for this test is adapted from the following GLSL: // // void main() { // int x, y; // do { // x++; // for (int j = 0; j < 100; j++) { // y++; // if (x == y) { // x++; // if (x == 2) { // y++; // } // switch (x) { // case 0: // x = 2; // default: // break; // } // } // } // } while (x > y); // // for (int i = 0; i < 100; i++) { // x++; // } // } std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %12 "x" OpName %16 "j" OpName %27 "y" OpName %55 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeInt 32 1 %11 = OpTypePointer Function %10 %14 = OpConstant %10 1 %17 = OpConstant %10 0 %24 = OpConstant %10 100 %25 = OpTypeBool %38 = OpConstant %10 2 %67 = OpConstantTrue %25 %68 = OpConstantFalse %25 %4 = OpFunction %2 None %3 %5 = OpLabel %12 = OpVariable %11 Function %16 = OpVariable %11 Function %27 = OpVariable %11 Function %55 = OpVariable %11 Function OpBranch %6 %6 = OpLabel OpLoopMerge %8 %9 None OpBranch %7 %7 = OpLabel %13 = OpLoad %10 %12 %15 = OpIAdd %10 %13 %14 OpStore %12 %15 OpStore %16 %17 OpBranch %18 %18 = OpLabel OpLoopMerge %20 %21 None OpBranch %22 %22 = OpLabel %23 = OpLoad %10 %16 %26 = OpSLessThan %25 %23 %24 OpBranchConditional %26 %19 %20 %19 = OpLabel %28 = OpLoad %10 %27 %29 = OpIAdd %10 %28 %14 OpStore %27 %29 %30 = OpLoad %10 %12 %31 = OpLoad %10 %27 %32 = OpIEqual %25 %30 %31 OpSelectionMerge %34 None OpBranchConditional %32 %33 %34 %33 = OpLabel %35 = OpLoad %10 %12 %36 = OpIAdd %10 %35 %14 OpStore %12 %36 %37 = OpLoad %10 %12 %39 = OpIEqual %25 %37 %38 OpSelectionMerge %41 None OpBranchConditional %39 %40 %41 %40 = OpLabel %42 = OpLoad %10 %27 %43 = OpIAdd %10 %42 %14 OpStore %27 %43 OpBranch %41 %41 = OpLabel %44 = OpLoad %10 %12 OpSelectionMerge %47 None OpSwitch %44 %46 0 %45 %46 = OpLabel OpBranch %47 %45 = OpLabel OpStore %12 %38 OpBranch %46 %47 = OpLabel OpBranch %34 %34 = OpLabel OpBranch %21 %21 = OpLabel %50 = OpLoad %10 %16 %51 = OpIAdd %10 %50 %14 OpStore %16 %51 OpBranch %18 %20 = OpLabel OpBranch %9 %9 = OpLabel %52 = OpLoad %10 %12 %53 = OpLoad %10 %27 %54 = OpSGreaterThan %25 %52 %53 OpBranchConditional %54 %6 %8 %8 = OpLabel OpStore %55 %17 OpBranch %56 %56 = OpLabel OpLoopMerge %58 %59 None OpBranch %60 %60 = OpLabel %61 = OpLoad %10 %55 %62 = OpSLessThan %25 %61 %24 OpBranchConditional %62 %57 %58 %57 = OpLabel %63 = OpLoad %10 %12 %64 = OpIAdd %10 %63 %14 OpStore %12 %64 OpBranch %59 %59 = OpLabel %65 = OpLoad %10 %55 %66 = OpIAdd %10 %65 %14 OpStore %55 %66 OpBranch %56 %58 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // The header and merge blocks const uint32_t header_do_while = 6; const uint32_t merge_do_while = 8; const uint32_t header_for_j = 18; const uint32_t merge_for_j = 20; const uint32_t header_for_i = 56; const uint32_t merge_for_i = 58; const uint32_t header_switch = 41; const uint32_t merge_switch = 47; const uint32_t header_if_x_eq_y = 19; const uint32_t merge_if_x_eq_y = 34; const uint32_t header_if_x_eq_2 = 33; const uint32_t merge_if_x_eq_2 = 41; // Loop continue targets const uint32_t continue_do_while = 9; const uint32_t continue_for_j = 21; const uint32_t continue_for_i = 59; // Some blocks in these constructs const uint32_t block_in_inner_if = 40; const uint32_t block_switch_case = 46; const uint32_t block_switch_default = 45; const uint32_t block_in_for_i_loop = 57; // Fine to break from any loop header to its merge ASSERT_TRUE( TransformationAddDeadBreak(header_do_while, merge_do_while, true, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationAddDeadBreak(header_for_i, merge_for_i, false, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationAddDeadBreak(header_for_j, merge_for_j, true, {}) .IsApplicable(context.get(), transformation_context)); // Fine to break from any of the blocks in constructs in the "for j" loop to // that loop's merge ASSERT_TRUE( TransformationAddDeadBreak(block_in_inner_if, merge_for_j, false, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE( TransformationAddDeadBreak(block_switch_case, merge_for_j, true, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE( TransformationAddDeadBreak(block_switch_default, merge_for_j, false, {}) .IsApplicable(context.get(), transformation_context)); // Fine to break from the body of the "for i" loop to that loop's merge ASSERT_TRUE( TransformationAddDeadBreak(block_in_for_i_loop, merge_for_i, true, {}) .IsApplicable(context.get(), transformation_context)); // Not OK to break from multiple loops ASSERT_FALSE( TransformationAddDeadBreak(block_in_inner_if, merge_do_while, false, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( TransformationAddDeadBreak(block_switch_case, merge_do_while, true, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationAddDeadBreak(block_switch_default, merge_do_while, false, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( TransformationAddDeadBreak(header_for_j, merge_do_while, true, {}) .IsApplicable(context.get(), transformation_context)); // Not OK to break loop from its continue construct, except from the back-edge // block. ASSERT_FALSE( TransformationAddDeadBreak(continue_do_while, merge_do_while, true, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationAddDeadBreak(continue_for_j, merge_for_j, false, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationAddDeadBreak(continue_for_i, merge_for_i, true, {}) .IsApplicable(context.get(), transformation_context)); // Not OK to break out of multiple non-loop constructs if not breaking to a // loop merge ASSERT_FALSE( TransformationAddDeadBreak(block_in_inner_if, merge_if_x_eq_y, false, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( TransformationAddDeadBreak(block_switch_case, merge_if_x_eq_y, true, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationAddDeadBreak(block_switch_default, merge_if_x_eq_y, false, {}) .IsApplicable(context.get(), transformation_context)); // Some miscellaneous inapplicable transformations ASSERT_FALSE( TransformationAddDeadBreak(header_if_x_eq_2, header_if_x_eq_y, false, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( TransformationAddDeadBreak(merge_if_x_eq_2, merge_switch, false, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( TransformationAddDeadBreak(header_switch, header_switch, false, {}) .IsApplicable(context.get(), transformation_context)); auto transformation1 = TransformationAddDeadBreak(header_do_while, merge_do_while, true, {}); auto transformation2 = TransformationAddDeadBreak(header_for_i, merge_for_i, false, {}); auto transformation3 = TransformationAddDeadBreak(header_for_j, merge_for_j, true, {}); auto transformation4 = TransformationAddDeadBreak(block_in_inner_if, merge_for_j, false, {}); auto transformation5 = TransformationAddDeadBreak(block_switch_case, merge_for_j, true, {}); auto transformation6 = TransformationAddDeadBreak(block_switch_default, merge_for_j, false, {}); auto transformation7 = TransformationAddDeadBreak(block_in_for_i_loop, merge_for_i, true, {}); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation3.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation3, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation4.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation4, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation5.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation5, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation6.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation6, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation7.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation7, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %12 "x" OpName %16 "j" OpName %27 "y" OpName %55 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeInt 32 1 %11 = OpTypePointer Function %10 %14 = OpConstant %10 1 %17 = OpConstant %10 0 %24 = OpConstant %10 100 %25 = OpTypeBool %38 = OpConstant %10 2 %67 = OpConstantTrue %25 %68 = OpConstantFalse %25 %4 = OpFunction %2 None %3 %5 = OpLabel %12 = OpVariable %11 Function %16 = OpVariable %11 Function %27 = OpVariable %11 Function %55 = OpVariable %11 Function OpBranch %6 %6 = OpLabel OpLoopMerge %8 %9 None OpBranchConditional %67 %7 %8 %7 = OpLabel %13 = OpLoad %10 %12 %15 = OpIAdd %10 %13 %14 OpStore %12 %15 OpStore %16 %17 OpBranch %18 %18 = OpLabel OpLoopMerge %20 %21 None OpBranchConditional %67 %22 %20 %22 = OpLabel %23 = OpLoad %10 %16 %26 = OpSLessThan %25 %23 %24 OpBranchConditional %26 %19 %20 %19 = OpLabel %28 = OpLoad %10 %27 %29 = OpIAdd %10 %28 %14 OpStore %27 %29 %30 = OpLoad %10 %12 %31 = OpLoad %10 %27 %32 = OpIEqual %25 %30 %31 OpSelectionMerge %34 None OpBranchConditional %32 %33 %34 %33 = OpLabel %35 = OpLoad %10 %12 %36 = OpIAdd %10 %35 %14 OpStore %12 %36 %37 = OpLoad %10 %12 %39 = OpIEqual %25 %37 %38 OpSelectionMerge %41 None OpBranchConditional %39 %40 %41 %40 = OpLabel %42 = OpLoad %10 %27 %43 = OpIAdd %10 %42 %14 OpStore %27 %43 OpBranchConditional %68 %20 %41 %41 = OpLabel %44 = OpLoad %10 %12 OpSelectionMerge %47 None OpSwitch %44 %46 0 %45 %46 = OpLabel OpBranchConditional %67 %47 %20 %45 = OpLabel OpStore %12 %38 OpBranchConditional %68 %20 %46 %47 = OpLabel OpBranch %34 %34 = OpLabel OpBranch %21 %21 = OpLabel %50 = OpLoad %10 %16 %51 = OpIAdd %10 %50 %14 OpStore %16 %51 OpBranch %18 %20 = OpLabel OpBranch %9 %9 = OpLabel %52 = OpLoad %10 %12 %53 = OpLoad %10 %27 %54 = OpSGreaterThan %25 %52 %53 OpBranchConditional %54 %6 %8 %8 = OpLabel OpStore %55 %17 OpBranch %56 %56 = OpLabel OpLoopMerge %58 %59 None OpBranchConditional %68 %58 %60 %60 = OpLabel %61 = OpLoad %10 %55 %62 = OpSLessThan %25 %61 %24 OpBranchConditional %62 %57 %58 %57 = OpLabel %63 = OpLoad %10 %12 %64 = OpIAdd %10 %63 %14 OpStore %12 %64 OpBranchConditional %67 %59 %58 %59 = OpLabel %65 = OpLoad %10 %55 %66 = OpIAdd %10 %65 %14 OpStore %55 %66 OpBranch %56 %58 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationAddDeadBreakTest, NoBreakFromContinueConstruct) { // Checks that it is illegal to break straight from a continue construct. // The SPIR-V for this test is adapted from the following GLSL: // // void main() { // for (int i = 0; i < 100; i++) { // } // } std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "i" OpDecorate %8 RelaxedPrecision OpDecorate %15 RelaxedPrecision OpDecorate %19 RelaxedPrecision OpDecorate %21 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 100 %17 = OpTypeBool %22 = OpConstantTrue %17 %20 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %15 = OpLoad %6 %8 %18 = OpSLessThan %17 %15 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel OpBranch %13 %13 = OpLabel %19 = OpLoad %6 %8 %21 = OpIAdd %6 %19 %20 OpBranch %23 %23 = OpLabel OpStore %8 %21 OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Not OK to break loop from its continue construct, except from the back-edge // block. ASSERT_FALSE(TransformationAddDeadBreak(13, 12, true, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationAddDeadBreak(23, 12, true, {}) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationAddDeadBreakTest, BreakFromBackEdgeBlock) { std::string reference_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %10 "main" ; Types %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeInt 32 0 %5 = OpTypeBool %6 = OpTypePointer Function %4 ; Constants %7 = OpConstant %4 0 %8 = OpConstant %4 1 %9 = OpConstantTrue %5 ; main function %10 = OpFunction %2 None %3 %11 = OpLabel %12 = OpVariable %6 Function OpStore %12 %7 OpBranch %13 %13 = OpLabel OpLoopMerge %21 %18 None ; structured loop OpBranch %14 %14 = OpLabel %15 = OpLoad %4 %12 %16 = OpULessThan %5 %15 %8 ; i < 1 ? OpBranchConditional %16 %17 %21 ; body or break %17 = OpLabel ; body OpBranch %18 %18 = OpLabel ; continue target does not strictly dominates the back-edge block %19 = OpLoad %4 %12 %20 = OpIAdd %4 %19 %8 ; ++i OpStore %12 %20 OpBranch %13 %21 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto transformation = TransformationAddDeadBreak(18, 21, true, {}); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); std::string variant_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %10 "main" ; Types %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeInt 32 0 %5 = OpTypeBool %6 = OpTypePointer Function %4 ; Constants %7 = OpConstant %4 0 %8 = OpConstant %4 1 %9 = OpConstantTrue %5 ; main function %10 = OpFunction %2 None %3 %11 = OpLabel %12 = OpVariable %6 Function OpStore %12 %7 OpBranch %13 %13 = OpLabel OpLoopMerge %21 %18 None ; structured loop OpBranch %14 %14 = OpLabel %15 = OpLoad %4 %12 %16 = OpULessThan %5 %15 %8 ; i < 1 ? OpBranchConditional %16 %17 %21 ; body or break %17 = OpLabel ; body OpBranch %18 %18 = OpLabel ; continue target does not strictly dominates the back-edge block %19 = OpLoad %4 %12 %20 = OpIAdd %4 %19 %8 ; ++i OpStore %12 %20 OpBranchConditional %9 %13 %21 %21 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(IsEqual(env, variant_shader, context.get())); } TEST(TransformationAddDeadBreakTest, SelectionInContinueConstruct) { // Considers some scenarios where there is a selection construct in a loop's // continue construct. // The SPIR-V for this test is adapted from the following GLSL: // // void main() { // for (int i = 0; i < 100; i = (i < 50 ? i + 2 : i + 1)) { // } // } std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 100 %17 = OpTypeBool %99 = OpConstantTrue %17 %20 = OpConstant %6 50 %26 = OpConstant %6 2 %30 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %22 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %15 = OpLoad %6 %8 %18 = OpSLessThan %17 %15 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel OpBranch %13 %13 = OpLabel %19 = OpLoad %6 %8 %21 = OpSLessThan %17 %19 %20 OpSelectionMerge %24 None OpBranchConditional %21 %23 %28 %23 = OpLabel %25 = OpLoad %6 %8 OpBranch %100 %100 = OpLabel %27 = OpIAdd %6 %25 %26 OpStore %22 %27 OpBranch %24 %28 = OpLabel %29 = OpLoad %6 %8 OpBranch %101 %101 = OpLabel %31 = OpIAdd %6 %29 %30 OpStore %22 %31 OpBranch %24 %24 = OpLabel %32 = OpLoad %6 %22 OpStore %8 %32 OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); const uint32_t loop_merge = 12; const uint32_t selection_merge = 24; const uint32_t in_selection_1 = 23; const uint32_t in_selection_2 = 100; const uint32_t in_selection_3 = 28; const uint32_t in_selection_4 = 101; // Not OK to jump from the selection to the loop merge, as this would break // from the loop's continue construct. ASSERT_FALSE(TransformationAddDeadBreak(in_selection_1, loop_merge, true, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationAddDeadBreak(in_selection_2, loop_merge, true, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationAddDeadBreak(in_selection_3, loop_merge, true, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationAddDeadBreak(in_selection_4, loop_merge, true, {}) .IsApplicable(context.get(), transformation_context)); // But fine to jump from the selection to its merge. auto transformation1 = TransformationAddDeadBreak(in_selection_1, selection_merge, true, {}); auto transformation2 = TransformationAddDeadBreak(in_selection_2, selection_merge, true, {}); auto transformation3 = TransformationAddDeadBreak(in_selection_3, selection_merge, true, {}); auto transformation4 = TransformationAddDeadBreak(in_selection_4, selection_merge, true, {}); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation3.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation3, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation4.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation4, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 100 %17 = OpTypeBool %99 = OpConstantTrue %17 %20 = OpConstant %6 50 %26 = OpConstant %6 2 %30 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %22 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %15 = OpLoad %6 %8 %18 = OpSLessThan %17 %15 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel OpBranch %13 %13 = OpLabel %19 = OpLoad %6 %8 %21 = OpSLessThan %17 %19 %20 OpSelectionMerge %24 None OpBranchConditional %21 %23 %28 %23 = OpLabel %25 = OpLoad %6 %8 OpBranchConditional %99 %100 %24 %100 = OpLabel %27 = OpIAdd %6 %25 %26 OpStore %22 %27 OpBranchConditional %99 %24 %24 %28 = OpLabel %29 = OpLoad %6 %8 OpBranchConditional %99 %101 %24 %101 = OpLabel %31 = OpIAdd %6 %29 %30 OpStore %22 %31 OpBranchConditional %99 %24 %24 %24 = OpLabel %32 = OpLoad %6 %22 OpStore %8 %32 OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationAddDeadBreakTest, LoopInContinueConstruct) { // Considers some scenarios where there is a loop in a loop's continue // construct. // The SPIR-V for this test is adapted from the following GLSL, with inlining // applied so that the loop from foo is in the main loop's continue construct: // // int foo() { // int result = 0; // for (int j = 0; j < 10; j++) { // result++; // } // return result; // } // // void main() { // for (int i = 0; i < 100; i += foo()) { // } // } std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %31 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeFunction %6 %10 = OpTypePointer Function %6 %12 = OpConstant %6 0 %20 = OpConstant %6 10 %21 = OpTypeBool %100 = OpConstantTrue %21 %24 = OpConstant %6 1 %38 = OpConstant %6 100 %4 = OpFunction %2 None %3 %5 = OpLabel %43 = OpVariable %10 Function %44 = OpVariable %10 Function %45 = OpVariable %10 Function %31 = OpVariable %10 Function OpStore %31 %12 OpBranch %32 %32 = OpLabel OpLoopMerge %34 %35 None OpBranch %36 %36 = OpLabel %37 = OpLoad %6 %31 %39 = OpSLessThan %21 %37 %38 OpBranchConditional %39 %33 %34 %33 = OpLabel OpBranch %35 %35 = OpLabel OpStore %43 %12 OpStore %44 %12 OpBranch %46 %46 = OpLabel OpLoopMerge %47 %48 None OpBranch %49 %49 = OpLabel %50 = OpLoad %6 %44 %51 = OpSLessThan %21 %50 %20 OpBranchConditional %51 %52 %47 %52 = OpLabel %53 = OpLoad %6 %43 OpBranch %101 %101 = OpLabel %54 = OpIAdd %6 %53 %24 OpStore %43 %54 OpBranch %48 %48 = OpLabel %55 = OpLoad %6 %44 %56 = OpIAdd %6 %55 %24 OpStore %44 %56 OpBranch %46 %47 = OpLabel %57 = OpLoad %6 %43 OpStore %45 %57 %40 = OpLoad %6 %45 %41 = OpLoad %6 %31 %42 = OpIAdd %6 %41 %40 OpStore %31 %42 OpBranch %32 %34 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); const uint32_t outer_loop_merge = 34; const uint32_t outer_loop_block = 33; const uint32_t inner_loop_merge = 47; const uint32_t inner_loop_block = 52; // Some inapplicable cases ASSERT_FALSE( TransformationAddDeadBreak(inner_loop_block, outer_loop_merge, true, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( TransformationAddDeadBreak(outer_loop_block, inner_loop_merge, true, {}) .IsApplicable(context.get(), transformation_context)); auto transformation1 = TransformationAddDeadBreak(inner_loop_block, inner_loop_merge, true, {}); auto transformation2 = TransformationAddDeadBreak(outer_loop_block, outer_loop_merge, true, {}); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %31 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeFunction %6 %10 = OpTypePointer Function %6 %12 = OpConstant %6 0 %20 = OpConstant %6 10 %21 = OpTypeBool %100 = OpConstantTrue %21 %24 = OpConstant %6 1 %38 = OpConstant %6 100 %4 = OpFunction %2 None %3 %5 = OpLabel %43 = OpVariable %10 Function %44 = OpVariable %10 Function %45 = OpVariable %10 Function %31 = OpVariable %10 Function OpStore %31 %12 OpBranch %32 %32 = OpLabel OpLoopMerge %34 %35 None OpBranch %36 %36 = OpLabel %37 = OpLoad %6 %31 %39 = OpSLessThan %21 %37 %38 OpBranchConditional %39 %33 %34 %33 = OpLabel OpBranchConditional %100 %35 %34 %35 = OpLabel OpStore %43 %12 OpStore %44 %12 OpBranch %46 %46 = OpLabel OpLoopMerge %47 %48 None OpBranch %49 %49 = OpLabel %50 = OpLoad %6 %44 %51 = OpSLessThan %21 %50 %20 OpBranchConditional %51 %52 %47 %52 = OpLabel %53 = OpLoad %6 %43 OpBranchConditional %100 %101 %47 %101 = OpLabel %54 = OpIAdd %6 %53 %24 OpStore %43 %54 OpBranch %48 %48 = OpLabel %55 = OpLoad %6 %44 %56 = OpIAdd %6 %55 %24 OpStore %44 %56 OpBranch %46 %47 = OpLabel %57 = OpLoad %6 %43 OpStore %45 %57 %40 = OpLoad %6 %45 %41 = OpLoad %6 %31 %42 = OpIAdd %6 %41 %40 OpStore %31 %42 OpBranch %32 %34 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationAddDeadBreakTest, PhiInstructions) { // Checks that the transformation works in the presence of phi instructions. // The SPIR-V for this test is adapted from the following GLSL, with a bit of // extra and artificial work to get some interesting uses of OpPhi: // // void main() { // int x; int y; // float f; // x = 2; // f = 3.0; // if (x > y) { // x = 3; // f = 4.0; // } else { // x = x + 2; // f = f + 10.0; // } // while (x < y) { // x = x + 1; // f = f + 1.0; // } // y = x; // f = f + 3.0; // } std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "x" OpName %12 "f" OpName %15 "y" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 2 %10 = OpTypeFloat 32 %11 = OpTypePointer Function %10 %13 = OpConstant %10 3 %17 = OpTypeBool %80 = OpConstantTrue %17 %21 = OpConstant %6 3 %22 = OpConstant %10 4 %27 = OpConstant %10 10 %38 = OpConstant %6 1 %41 = OpConstant %10 1 %46 = OpUndef %6 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %12 = OpVariable %11 Function %15 = OpVariable %7 Function OpStore %8 %9 OpStore %12 %13 %18 = OpSGreaterThan %17 %9 %46 OpSelectionMerge %20 None OpBranchConditional %18 %19 %23 %19 = OpLabel OpStore %8 %21 OpStore %12 %22 OpBranch %20 %23 = OpLabel %25 = OpIAdd %6 %9 %9 OpStore %8 %25 OpBranch %70 %70 = OpLabel %28 = OpFAdd %10 %13 %27 OpStore %12 %28 OpBranch %20 %20 = OpLabel %52 = OpPhi %10 %22 %19 %28 %70 %48 = OpPhi %6 %21 %19 %25 %70 OpBranch %29 %29 = OpLabel %51 = OpPhi %10 %52 %20 %42 %32 %47 = OpPhi %6 %48 %20 %39 %32 OpLoopMerge %31 %32 None OpBranch %33 %33 = OpLabel %36 = OpSLessThan %17 %47 %46 OpBranchConditional %36 %30 %31 %30 = OpLabel %39 = OpIAdd %6 %47 %38 OpStore %8 %39 OpBranch %75 %75 = OpLabel %42 = OpFAdd %10 %51 %41 OpStore %12 %42 OpBranch %32 %32 = OpLabel OpBranch %29 %31 = OpLabel %71 = OpPhi %6 %47 %33 %72 = OpPhi %10 %51 %33 OpStore %15 %71 %45 = OpFAdd %10 %72 %13 OpStore %12 %45 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Some inapplicable transformations // Not applicable because there is already an edge 19->20, so the OpPhis at 20 // do not need to be updated ASSERT_FALSE(TransformationAddDeadBreak(19, 20, true, {13, 21}) .IsApplicable(context.get(), transformation_context)); // Not applicable because two OpPhis (not zero) need to be updated at 20 ASSERT_FALSE(TransformationAddDeadBreak(23, 20, true, {}) .IsApplicable(context.get(), transformation_context)); // Not applicable because two OpPhis (not just one) need to be updated at 20 ASSERT_FALSE(TransformationAddDeadBreak(23, 20, true, {13}) .IsApplicable(context.get(), transformation_context)); // Not applicable because the given ids do not have types that match the // OpPhis at 20, in order ASSERT_FALSE(TransformationAddDeadBreak(23, 20, true, {21, 13}) .IsApplicable(context.get(), transformation_context)); // Not applicable because id 23 is a label ASSERT_FALSE(TransformationAddDeadBreak(23, 20, true, {21, 23}) .IsApplicable(context.get(), transformation_context)); // Not applicable because 101 is not an id ASSERT_FALSE(TransformationAddDeadBreak(23, 20, true, {21, 101}) .IsApplicable(context.get(), transformation_context)); // Not applicable because ids 51 and 47 are not available at the end of block // 23 ASSERT_FALSE(TransformationAddDeadBreak(23, 20, true, {51, 47}) .IsApplicable(context.get(), transformation_context)); // Not applicable because OpConstantFalse is not present in the module ASSERT_FALSE(TransformationAddDeadBreak(19, 20, false, {}) .IsApplicable(context.get(), transformation_context)); auto transformation1 = TransformationAddDeadBreak(19, 20, true, {}); auto transformation2 = TransformationAddDeadBreak(23, 20, true, {13, 21}); auto transformation3 = TransformationAddDeadBreak(70, 20, true, {}); auto transformation4 = TransformationAddDeadBreak(30, 31, true, {21, 13}); auto transformation5 = TransformationAddDeadBreak(75, 31, true, {47, 51}); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation3.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation3, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation4.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation4, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation5.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation5, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "x" OpName %12 "f" OpName %15 "y" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 2 %10 = OpTypeFloat 32 %11 = OpTypePointer Function %10 %13 = OpConstant %10 3 %17 = OpTypeBool %80 = OpConstantTrue %17 %21 = OpConstant %6 3 %22 = OpConstant %10 4 %27 = OpConstant %10 10 %38 = OpConstant %6 1 %41 = OpConstant %10 1 %46 = OpUndef %6 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %12 = OpVariable %11 Function %15 = OpVariable %7 Function OpStore %8 %9 OpStore %12 %13 %18 = OpSGreaterThan %17 %9 %46 OpSelectionMerge %20 None OpBranchConditional %18 %19 %23 %19 = OpLabel OpStore %8 %21 OpStore %12 %22 OpBranchConditional %80 %20 %20 %23 = OpLabel %25 = OpIAdd %6 %9 %9 OpStore %8 %25 OpBranchConditional %80 %70 %20 %70 = OpLabel %28 = OpFAdd %10 %13 %27 OpStore %12 %28 OpBranchConditional %80 %20 %20 %20 = OpLabel %52 = OpPhi %10 %22 %19 %28 %70 %13 %23 %48 = OpPhi %6 %21 %19 %25 %70 %21 %23 OpBranch %29 %29 = OpLabel %51 = OpPhi %10 %52 %20 %42 %32 %47 = OpPhi %6 %48 %20 %39 %32 OpLoopMerge %31 %32 None OpBranch %33 %33 = OpLabel %36 = OpSLessThan %17 %47 %46 OpBranchConditional %36 %30 %31 %30 = OpLabel %39 = OpIAdd %6 %47 %38 OpStore %8 %39 OpBranchConditional %80 %75 %31 %75 = OpLabel %42 = OpFAdd %10 %51 %41 OpStore %12 %42 OpBranchConditional %80 %32 %31 %32 = OpLabel OpBranch %29 %31 = OpLabel %71 = OpPhi %6 %47 %33 %21 %30 %47 %75 %72 = OpPhi %10 %51 %33 %13 %30 %51 %75 OpStore %15 %71 %45 = OpFAdd %10 %72 %13 OpStore %12 %45 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationAddDeadBreakTest, RespectDominanceRules1) { // Right after the loop, an OpCopyObject defined by the loop is used. Adding // a dead break would prevent that use from being dominated by its definition, // so is not allowed. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeBool %11 = OpConstantFalse %10 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %100 %100 = OpLabel OpLoopMerge %101 %102 None OpBranch %103 %103 = OpLabel %200 = OpCopyObject %10 %11 OpBranch %104 %104 = OpLabel OpBranch %102 %102 = OpLabel OpBranchConditional %11 %100 %101 %101 = OpLabel %201 = OpCopyObject %10 %200 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto bad_transformation = TransformationAddDeadBreak(100, 101, false, {}); ASSERT_FALSE( bad_transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationAddDeadBreakTest, RespectDominanceRules2) { // This example captures the following idiom: // // if { // L1: // } // definition; // L2: // use; // // Adding a dead jump from L1 to L2 would lead to 'definition' no longer // dominating 'use', and so is not allowed. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeBool %11 = OpConstantFalse %10 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %100 %100 = OpLabel OpSelectionMerge %101 None OpBranchConditional %11 %102 %103 %102 = OpLabel OpBranch %103 %103 = OpLabel %200 = OpCopyObject %10 %11 OpBranch %101 %101 = OpLabel %201 = OpCopyObject %10 %200 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto bad_transformation = TransformationAddDeadBreak(102, 101, false, {}); ASSERT_FALSE( bad_transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationAddDeadBreakTest, RespectDominanceRules3) { // Right after the loop, an OpCopyObject defined by the loop is used in an // OpPhi. Adding a dead break is OK in this case, due to the use being in an // OpPhi. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeBool %11 = OpConstantFalse %10 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %100 %100 = OpLabel OpLoopMerge %101 %102 None OpBranch %103 %103 = OpLabel %200 = OpCopyObject %10 %11 OpBranch %104 %104 = OpLabel OpBranch %102 %102 = OpLabel OpBranchConditional %11 %100 %101 %101 = OpLabel %201 = OpPhi %10 %200 %102 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto good_transformation = TransformationAddDeadBreak(100, 101, false, {11}); ASSERT_TRUE( good_transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(good_transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeBool %11 = OpConstantFalse %10 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %100 %100 = OpLabel OpLoopMerge %101 %102 None OpBranchConditional %11 %101 %103 %103 = OpLabel %200 = OpCopyObject %10 %11 OpBranch %104 %104 = OpLabel OpBranch %102 %102 = OpLabel OpBranchConditional %11 %100 %101 %101 = OpLabel %201 = OpPhi %10 %200 %102 %11 %100 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationAddDeadBreakTest, RespectDominanceRules4) { // This example captures the following idiom: // // if { // L1: // } // definition; // L2: // use in OpPhi; // // Adding a dead jump from L1 to L2 is OK, due to 'use' being in an OpPhi. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeBool %11 = OpConstantFalse %10 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %100 %100 = OpLabel OpSelectionMerge %101 None OpBranchConditional %11 %102 %103 %102 = OpLabel OpBranch %103 %103 = OpLabel %200 = OpCopyObject %10 %11 OpBranch %101 %101 = OpLabel %201 = OpPhi %10 %200 %103 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto good_transformation = TransformationAddDeadBreak(102, 101, false, {11}); ASSERT_TRUE( good_transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(good_transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeBool %11 = OpConstantFalse %10 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %100 %100 = OpLabel OpSelectionMerge %101 None OpBranchConditional %11 %102 %103 %102 = OpLabel OpBranchConditional %11 %101 %103 %103 = OpLabel %200 = OpCopyObject %10 %11 OpBranch %101 %101 = OpLabel %201 = OpPhi %10 %200 %103 %11 %102 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationAddDeadBreakTest, RespectDominanceRules5) { // After, but not right after, the loop, an OpCopyObject defined by the loop // is used in an OpPhi. Adding a dead break is not OK in this case. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeBool %11 = OpConstantFalse %10 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %100 %100 = OpLabel OpLoopMerge %101 %102 None OpBranch %103 %103 = OpLabel %200 = OpCopyObject %10 %11 OpBranch %104 %104 = OpLabel OpBranch %102 %102 = OpLabel OpBranchConditional %11 %100 %101 %101 = OpLabel OpBranch %105 %105 = OpLabel %201 = OpPhi %10 %200 %101 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto bad_transformation = TransformationAddDeadBreak(100, 101, false, {}); ASSERT_FALSE( bad_transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationAddDeadBreakTest, RespectDominanceRules6) { // This example captures the following idiom: // // if { // L1: // } // definition; // L2: // goto L3; // L3: // use in OpPhi; // // Adding a dead jump from L1 to L2 not OK, due to the use in an OpPhi being // in L3. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeBool %11 = OpConstantFalse %10 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %100 %100 = OpLabel OpSelectionMerge %101 None OpBranchConditional %11 %102 %103 %102 = OpLabel OpBranch %103 %103 = OpLabel %200 = OpCopyObject %10 %11 OpBranch %101 %101 = OpLabel OpBranch %150 %150 = OpLabel %201 = OpPhi %10 %200 %101 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto bad_transformation = TransformationAddDeadBreak(102, 101, false, {}); ASSERT_FALSE( bad_transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationAddDeadBreakTest, RespectDominanceRules7) { // This example - a variation on an earlier test - captures the following // idiom: // // loop { // L1: // } // definition; // L2: // use; // // Adding a dead jump from L1 to L2 would lead to 'definition' no longer // dominating 'use', and so is not allowed. // // This version of the test captures the case where L1 appears after the // loop merge (which SPIR-V dominance rules allow). std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeBool %11 = OpConstantFalse %10 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %100 %100 = OpLabel OpLoopMerge %101 %104 None OpBranch %105 %105 = OpLabel OpSelectionMerge %106 None OpBranchConditional %11 %102 %103 %103 = OpLabel %200 = OpCopyObject %10 %11 OpBranch %101 %101 = OpLabel %201 = OpCopyObject %10 %200 OpReturn %102 = OpLabel OpBranch %103 %106 = OpLabel OpUnreachable %104 = OpLabel OpBranch %100 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto bad_transformation = TransformationAddDeadBreak(102, 101, false, {}); ASSERT_FALSE( bad_transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationAddDeadBreakTest, RespectDominanceRules8) { // A variation of RespectDominanceRules8 where the defining block appears // in the loop, but after the definition of interest. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeBool %11 = OpConstantFalse %10 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %100 %100 = OpLabel OpLoopMerge %101 %104 None OpBranch %105 %105 = OpLabel OpSelectionMerge %106 None OpBranchConditional %11 %102 %103 %103 = OpLabel %200 = OpCopyObject %10 %11 OpBranch %101 %102 = OpLabel OpBranch %103 %106 = OpLabel OpUnreachable %101 = OpLabel %201 = OpCopyObject %10 %200 OpReturn %104 = OpLabel OpBranch %100 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto bad_transformation = TransformationAddDeadBreak(102, 101, false, {}); ASSERT_FALSE( bad_transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationAddDeadBreakTest, BreakWouldDisobeyDominanceBlockOrderingRules) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %9 = OpConstantTrue %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %10 %10 = OpLabel OpLoopMerge %16 %15 None OpBranch %11 %11 = OpLabel OpSelectionMerge %14 None OpBranchConditional %9 %12 %13 %14 = OpLabel OpBranch %15 %12 = OpLabel OpBranch %16 %13 = OpLabel OpBranch %16 %15 = OpLabel OpBranch %10 %16 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Bad because 14 comes before 12 in the module, and 14 has no predecessors. // This means that an edge from 12 to 14 will lead to 12 dominating 14, which // is illegal if 12 appears after 14. auto bad_transformation = TransformationAddDeadBreak(12, 14, true, {}); ASSERT_FALSE( bad_transformation.IsApplicable(context.get(), transformation_context)); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_add_dead_continue_test.cpp000066400000000000000000001572451475742701700310260ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_dead_continue.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationAddDeadContinueTest, SimpleExample) { // For a simple loop, checks that some dead continue scenarios are possible, // checks that some invalid scenarios are indeed not allowed, and then applies // a transformation. // The SPIR-V for this test is adapted from the following GLSL, by separating // some assignments into their own basic blocks, and adding constants for true // and false: // // void main() { // int x = 0; // for (int i = 0; i < 10; i++) { // x = x + i; // x = x + i; // } // } std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "x" OpName %10 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %17 = OpConstant %6 10 %18 = OpTypeBool %41 = OpConstantTrue %18 %42 = OpConstantFalse %18 %27 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function OpStore %8 %9 OpStore %10 %9 OpBranch %11 %11 = OpLabel OpLoopMerge %13 %14 None OpBranch %15 %15 = OpLabel %16 = OpLoad %6 %10 %19 = OpSLessThan %18 %16 %17 OpBranchConditional %19 %12 %13 %12 = OpLabel %20 = OpLoad %6 %8 %21 = OpLoad %6 %10 %22 = OpIAdd %6 %20 %21 OpStore %8 %22 OpBranch %40 %40 = OpLabel %23 = OpLoad %6 %8 %24 = OpLoad %6 %10 %25 = OpIAdd %6 %23 %24 OpStore %8 %25 OpBranch %14 %14 = OpLabel %26 = OpLoad %6 %10 %28 = OpIAdd %6 %26 %27 OpStore %10 %28 OpBranch %11 %13 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // These are all possibilities. ASSERT_TRUE(TransformationAddDeadContinue(11, true, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationAddDeadContinue(11, false, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationAddDeadContinue(12, true, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationAddDeadContinue(12, false, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationAddDeadContinue(40, true, {}) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationAddDeadContinue(40, false, {}) .IsApplicable(context.get(), transformation_context)); // Inapplicable: 100 is not a block id. ASSERT_FALSE(TransformationAddDeadContinue(100, true, {}) .IsApplicable(context.get(), transformation_context)); // Inapplicable: 10 is not in a loop. ASSERT_FALSE(TransformationAddDeadContinue(10, true, {}) .IsApplicable(context.get(), transformation_context)); // Inapplicable: 15 does not branch unconditionally to a single successor. ASSERT_FALSE(TransformationAddDeadContinue(15, true, {}) .IsApplicable(context.get(), transformation_context)); // Inapplicable: 13 is not in a loop and has no successor. ASSERT_FALSE(TransformationAddDeadContinue(13, true, {}) .IsApplicable(context.get(), transformation_context)); // Inapplicable: 14 is the loop continue target, so it's not OK to jump to // the loop continue from there. ASSERT_FALSE(TransformationAddDeadContinue(14, false, {}) .IsApplicable(context.get(), transformation_context)); // These are the transformations we will apply. auto transformation1 = TransformationAddDeadContinue(11, true, {}); auto transformation2 = TransformationAddDeadContinue(12, false, {}); auto transformation3 = TransformationAddDeadContinue(40, true, {}); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( transformation3.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation3, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "x" OpName %10 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %17 = OpConstant %6 10 %18 = OpTypeBool %41 = OpConstantTrue %18 %42 = OpConstantFalse %18 %27 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function OpStore %8 %9 OpStore %10 %9 OpBranch %11 %11 = OpLabel OpLoopMerge %13 %14 None OpBranchConditional %41 %15 %14 %15 = OpLabel %16 = OpLoad %6 %10 %19 = OpSLessThan %18 %16 %17 OpBranchConditional %19 %12 %13 %12 = OpLabel %20 = OpLoad %6 %8 %21 = OpLoad %6 %10 %22 = OpIAdd %6 %20 %21 OpStore %8 %22 OpBranchConditional %42 %14 %40 %40 = OpLabel %23 = OpLoad %6 %8 %24 = OpLoad %6 %10 %25 = OpIAdd %6 %23 %24 OpStore %8 %25 OpBranchConditional %41 %14 %14 %14 = OpLabel %26 = OpLoad %6 %10 %28 = OpIAdd %6 %26 %27 OpStore %10 %28 OpBranch %11 %13 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationAddDeadContinueTest, LoopNest) { // Checks some allowed and disallowed scenarios for a nest of loops, including // continuing a loop from an if or switch. // The SPIR-V for this test is adapted from the following GLSL: // // void main() { // int x, y; // do { // x++; // for (int j = 0; j < 100; j++) { // y++; // if (x == y) { // x++; // if (x == 2) { // y++; // } // switch (x) { // case 0: // x = 2; // default: // break; // } // } // } // } while (x > y); // // for (int i = 0; i < 100; i++) { // x++; // } // } std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %12 "x" OpName %16 "j" OpName %27 "y" OpName %55 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeInt 32 1 %11 = OpTypePointer Function %10 %14 = OpConstant %10 1 %17 = OpConstant %10 0 %24 = OpConstant %10 100 %25 = OpTypeBool %38 = OpConstant %10 2 %67 = OpConstantTrue %25 %68 = OpConstantFalse %25 %4 = OpFunction %2 None %3 %5 = OpLabel %12 = OpVariable %11 Function %16 = OpVariable %11 Function %27 = OpVariable %11 Function %55 = OpVariable %11 Function OpBranch %6 %6 = OpLabel OpLoopMerge %8 %9 None OpBranch %7 %7 = OpLabel %13 = OpLoad %10 %12 %15 = OpIAdd %10 %13 %14 OpStore %12 %15 OpStore %16 %17 OpBranch %18 %18 = OpLabel OpLoopMerge %20 %21 None OpBranch %22 %22 = OpLabel %23 = OpLoad %10 %16 %26 = OpSLessThan %25 %23 %24 OpBranchConditional %26 %19 %20 %19 = OpLabel %28 = OpLoad %10 %27 %29 = OpIAdd %10 %28 %14 OpStore %27 %29 %30 = OpLoad %10 %12 %31 = OpLoad %10 %27 %32 = OpIEqual %25 %30 %31 OpSelectionMerge %34 None OpBranchConditional %32 %33 %34 %33 = OpLabel %35 = OpLoad %10 %12 %36 = OpIAdd %10 %35 %14 OpStore %12 %36 %37 = OpLoad %10 %12 %39 = OpIEqual %25 %37 %38 OpSelectionMerge %41 None OpBranchConditional %39 %40 %41 %40 = OpLabel %42 = OpLoad %10 %27 %43 = OpIAdd %10 %42 %14 OpStore %27 %43 OpBranch %41 %41 = OpLabel %44 = OpLoad %10 %12 OpSelectionMerge %47 None OpSwitch %44 %46 0 %45 %46 = OpLabel OpBranch %47 %45 = OpLabel OpStore %12 %38 OpBranch %46 %47 = OpLabel OpBranch %34 %34 = OpLabel OpBranch %21 %21 = OpLabel %50 = OpLoad %10 %16 %51 = OpIAdd %10 %50 %14 OpStore %16 %51 OpBranch %18 %20 = OpLabel OpBranch %9 %9 = OpLabel %52 = OpLoad %10 %12 %53 = OpLoad %10 %27 %54 = OpSGreaterThan %25 %52 %53 OpBranchConditional %54 %6 %8 %8 = OpLabel OpStore %55 %17 OpBranch %56 %56 = OpLabel OpLoopMerge %58 %59 None OpBranch %60 %60 = OpLabel %61 = OpLoad %10 %55 %62 = OpSLessThan %25 %61 %24 OpBranchConditional %62 %57 %58 %57 = OpLabel %63 = OpLoad %10 %12 %64 = OpIAdd %10 %63 %14 OpStore %12 %64 OpBranch %59 %59 = OpLabel %65 = OpLoad %10 %55 %66 = OpIAdd %10 %65 %14 OpStore %55 %66 OpBranch %56 %58 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); std::vector good = {6, 7, 18, 20, 34, 40, 45, 46, 47, 56, 57}; std::vector bad = {5, 8, 9, 19, 21, 22, 33, 41, 58, 59, 60}; for (uint32_t from_block : bad) { ASSERT_FALSE(TransformationAddDeadContinue(from_block, true, {}) .IsApplicable(context.get(), transformation_context)); } for (uint32_t from_block : good) { const TransformationAddDeadContinue transformation(from_block, true, {}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); } std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %12 "x" OpName %16 "j" OpName %27 "y" OpName %55 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeInt 32 1 %11 = OpTypePointer Function %10 %14 = OpConstant %10 1 %17 = OpConstant %10 0 %24 = OpConstant %10 100 %25 = OpTypeBool %38 = OpConstant %10 2 %67 = OpConstantTrue %25 %68 = OpConstantFalse %25 %4 = OpFunction %2 None %3 %5 = OpLabel %12 = OpVariable %11 Function %16 = OpVariable %11 Function %27 = OpVariable %11 Function %55 = OpVariable %11 Function OpBranch %6 %6 = OpLabel OpLoopMerge %8 %9 None OpBranchConditional %67 %7 %9 %7 = OpLabel %13 = OpLoad %10 %12 %15 = OpIAdd %10 %13 %14 OpStore %12 %15 OpStore %16 %17 OpBranchConditional %67 %18 %9 %18 = OpLabel OpLoopMerge %20 %21 None OpBranchConditional %67 %22 %21 %22 = OpLabel %23 = OpLoad %10 %16 %26 = OpSLessThan %25 %23 %24 OpBranchConditional %26 %19 %20 %19 = OpLabel %28 = OpLoad %10 %27 %29 = OpIAdd %10 %28 %14 OpStore %27 %29 %30 = OpLoad %10 %12 %31 = OpLoad %10 %27 %32 = OpIEqual %25 %30 %31 OpSelectionMerge %34 None OpBranchConditional %32 %33 %34 %33 = OpLabel %35 = OpLoad %10 %12 %36 = OpIAdd %10 %35 %14 OpStore %12 %36 %37 = OpLoad %10 %12 %39 = OpIEqual %25 %37 %38 OpSelectionMerge %41 None OpBranchConditional %39 %40 %41 %40 = OpLabel %42 = OpLoad %10 %27 %43 = OpIAdd %10 %42 %14 OpStore %27 %43 OpBranchConditional %67 %41 %21 %41 = OpLabel %44 = OpLoad %10 %12 OpSelectionMerge %47 None OpSwitch %44 %46 0 %45 %46 = OpLabel OpBranchConditional %67 %47 %21 %45 = OpLabel OpStore %12 %38 OpBranchConditional %67 %46 %21 %47 = OpLabel OpBranchConditional %67 %34 %21 %34 = OpLabel OpBranchConditional %67 %21 %21 %21 = OpLabel %50 = OpLoad %10 %16 %51 = OpIAdd %10 %50 %14 OpStore %16 %51 OpBranch %18 %20 = OpLabel OpBranchConditional %67 %9 %9 %9 = OpLabel %52 = OpLoad %10 %12 %53 = OpLoad %10 %27 %54 = OpSGreaterThan %25 %52 %53 OpBranchConditional %54 %6 %8 %8 = OpLabel OpStore %55 %17 OpBranch %56 %56 = OpLabel OpLoopMerge %58 %59 None OpBranchConditional %67 %60 %59 %60 = OpLabel %61 = OpLoad %10 %55 %62 = OpSLessThan %25 %61 %24 OpBranchConditional %62 %57 %58 %57 = OpLabel %63 = OpLoad %10 %12 %64 = OpIAdd %10 %63 %14 OpStore %12 %64 OpBranchConditional %67 %59 %59 %59 = OpLabel %65 = OpLoad %10 %55 %66 = OpIAdd %10 %65 %14 OpStore %55 %66 OpBranch %56 %58 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationAddDeadConditionalTest, LoopInContinueConstruct) { // Considers some scenarios where there is a loop in a loop's continue // construct. // The SPIR-V for this test is adapted from the following GLSL, with inlining // applied so that the loop from foo is in the main loop's continue construct: // // int foo() { // int result = 0; // for (int j = 0; j < 10; j++) { // result++; // } // return result; // } // // void main() { // for (int i = 0; i < 100; i += foo()) { // } // } std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %31 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeFunction %6 %10 = OpTypePointer Function %6 %12 = OpConstant %6 0 %20 = OpConstant %6 10 %21 = OpTypeBool %100 = OpConstantFalse %21 %24 = OpConstant %6 1 %38 = OpConstant %6 100 %4 = OpFunction %2 None %3 %5 = OpLabel %43 = OpVariable %10 Function %44 = OpVariable %10 Function %45 = OpVariable %10 Function %31 = OpVariable %10 Function OpStore %31 %12 OpBranch %32 %32 = OpLabel OpLoopMerge %34 %35 None OpBranch %36 %36 = OpLabel %37 = OpLoad %6 %31 %39 = OpSLessThan %21 %37 %38 OpBranchConditional %39 %33 %34 %33 = OpLabel OpBranch %35 %35 = OpLabel OpStore %43 %12 OpStore %44 %12 OpBranch %46 %46 = OpLabel OpLoopMerge %47 %48 None OpBranch %49 %49 = OpLabel %50 = OpLoad %6 %44 %51 = OpSLessThan %21 %50 %20 OpBranchConditional %51 %52 %47 %52 = OpLabel %53 = OpLoad %6 %43 OpBranch %101 %101 = OpLabel %54 = OpIAdd %6 %53 %24 OpStore %43 %54 OpBranch %48 %48 = OpLabel %55 = OpLoad %6 %44 %56 = OpIAdd %6 %55 %24 OpStore %44 %56 OpBranch %46 %47 = OpLabel %57 = OpLoad %6 %43 OpStore %45 %57 %40 = OpLoad %6 %45 %41 = OpLoad %6 %31 %42 = OpIAdd %6 %41 %40 OpStore %31 %42 OpBranch %32 %34 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); std::vector good = {32, 33, 46, 52, 101}; std::vector bad = {5, 34, 36, 35, 47, 49, 48}; for (uint32_t from_block : bad) { ASSERT_FALSE(TransformationAddDeadContinue(from_block, false, {}) .IsApplicable(context.get(), transformation_context)); } for (uint32_t from_block : good) { const TransformationAddDeadContinue transformation(from_block, false, {}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); } std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %31 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeFunction %6 %10 = OpTypePointer Function %6 %12 = OpConstant %6 0 %20 = OpConstant %6 10 %21 = OpTypeBool %100 = OpConstantFalse %21 %24 = OpConstant %6 1 %38 = OpConstant %6 100 %4 = OpFunction %2 None %3 %5 = OpLabel %43 = OpVariable %10 Function %44 = OpVariable %10 Function %45 = OpVariable %10 Function %31 = OpVariable %10 Function OpStore %31 %12 OpBranch %32 %32 = OpLabel OpLoopMerge %34 %35 None OpBranchConditional %100 %35 %36 %36 = OpLabel %37 = OpLoad %6 %31 %39 = OpSLessThan %21 %37 %38 OpBranchConditional %39 %33 %34 %33 = OpLabel OpBranchConditional %100 %35 %35 %35 = OpLabel OpStore %43 %12 OpStore %44 %12 OpBranch %46 %46 = OpLabel OpLoopMerge %47 %48 None OpBranchConditional %100 %48 %49 %49 = OpLabel %50 = OpLoad %6 %44 %51 = OpSLessThan %21 %50 %20 OpBranchConditional %51 %52 %47 %52 = OpLabel %53 = OpLoad %6 %43 OpBranchConditional %100 %48 %101 %101 = OpLabel %54 = OpIAdd %6 %53 %24 OpStore %43 %54 OpBranchConditional %100 %48 %48 %48 = OpLabel %55 = OpLoad %6 %44 %56 = OpIAdd %6 %55 %24 OpStore %44 %56 OpBranch %46 %47 = OpLabel %57 = OpLoad %6 %43 OpStore %45 %57 %40 = OpLoad %6 %45 %41 = OpLoad %6 %31 %42 = OpIAdd %6 %41 %40 OpStore %31 %42 OpBranch %32 %34 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationAddDeadContinueTest, PhiInstructions) { // Checks that the transformation works in the presence of phi instructions. // The SPIR-V for this test is adapted from the following GLSL, with a bit of // extra and artificial work to get some interesting uses of OpPhi: // // void main() { // int x; int y; // float f; // x = 2; // f = 3.0; // if (x > y) { // x = 3; // f = 4.0; // } else { // x = x + 2; // f = f + 10.0; // } // while (x < y) { // x = x + 1; // f = f + 1.0; // } // y = x; // f = f + 3.0; // } std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "x" OpName %12 "f" OpName %15 "y" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 2 %10 = OpTypeFloat 32 %11 = OpTypePointer Function %10 %13 = OpConstant %10 3 %17 = OpTypeBool %80 = OpConstantTrue %17 %21 = OpConstant %6 3 %22 = OpConstant %10 4 %27 = OpConstant %10 10 %38 = OpConstant %6 1 %41 = OpConstant %10 1 %46 = OpUndef %6 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %12 = OpVariable %11 Function %15 = OpVariable %7 Function OpStore %8 %9 OpStore %12 %13 %18 = OpSGreaterThan %17 %9 %46 OpSelectionMerge %20 None OpBranchConditional %18 %19 %23 %19 = OpLabel OpStore %8 %21 OpStore %12 %22 OpBranch %20 %23 = OpLabel %25 = OpIAdd %6 %9 %9 OpStore %8 %25 OpBranch %70 %70 = OpLabel %28 = OpFAdd %10 %13 %27 OpStore %12 %28 OpBranch %20 %20 = OpLabel %52 = OpPhi %10 %22 %19 %28 %70 %48 = OpPhi %6 %21 %19 %25 %70 OpBranch %29 %29 = OpLabel %51 = OpPhi %10 %52 %20 %100 %32 %47 = OpPhi %6 %48 %20 %101 %32 OpLoopMerge %31 %32 None OpBranch %33 %33 = OpLabel %36 = OpSLessThan %17 %47 %46 OpBranchConditional %36 %30 %31 %30 = OpLabel %39 = OpIAdd %6 %47 %38 OpStore %8 %39 OpBranch %75 %75 = OpLabel %42 = OpFAdd %10 %51 %41 OpStore %12 %42 OpBranch %32 %32 = OpLabel %100 = OpPhi %10 %42 %75 %101 = OpPhi %6 %39 %75 OpBranch %29 %31 = OpLabel %71 = OpPhi %6 %47 %33 %72 = OpPhi %10 %51 %33 OpStore %15 %71 %45 = OpFAdd %10 %72 %13 OpStore %12 %45 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); std::vector bad = {5, 19, 20, 23, 31, 32, 33, 70}; std::vector good = {29, 30, 75}; for (uint32_t from_block : bad) { ASSERT_FALSE(TransformationAddDeadContinue(from_block, true, {}) .IsApplicable(context.get(), transformation_context)); } auto transformation1 = TransformationAddDeadContinue(29, true, {13, 21}); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); auto transformation2 = TransformationAddDeadContinue(30, true, {22, 46}); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); // 75 already has the continue block as a successor, so we should not provide // phi ids. auto transformationBad = TransformationAddDeadContinue(75, true, {27, 46}); ASSERT_FALSE( transformationBad.IsApplicable(context.get(), transformation_context)); auto transformation3 = TransformationAddDeadContinue(75, true, {}); ASSERT_TRUE( transformation3.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation3, context.get(), &transformation_context); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "x" OpName %12 "f" OpName %15 "y" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 2 %10 = OpTypeFloat 32 %11 = OpTypePointer Function %10 %13 = OpConstant %10 3 %17 = OpTypeBool %80 = OpConstantTrue %17 %21 = OpConstant %6 3 %22 = OpConstant %10 4 %27 = OpConstant %10 10 %38 = OpConstant %6 1 %41 = OpConstant %10 1 %46 = OpUndef %6 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %12 = OpVariable %11 Function %15 = OpVariable %7 Function OpStore %8 %9 OpStore %12 %13 %18 = OpSGreaterThan %17 %9 %46 OpSelectionMerge %20 None OpBranchConditional %18 %19 %23 %19 = OpLabel OpStore %8 %21 OpStore %12 %22 OpBranch %20 %23 = OpLabel %25 = OpIAdd %6 %9 %9 OpStore %8 %25 OpBranch %70 %70 = OpLabel %28 = OpFAdd %10 %13 %27 OpStore %12 %28 OpBranch %20 %20 = OpLabel %52 = OpPhi %10 %22 %19 %28 %70 %48 = OpPhi %6 %21 %19 %25 %70 OpBranch %29 %29 = OpLabel %51 = OpPhi %10 %52 %20 %100 %32 %47 = OpPhi %6 %48 %20 %101 %32 OpLoopMerge %31 %32 None OpBranchConditional %80 %33 %32 %33 = OpLabel %36 = OpSLessThan %17 %47 %46 OpBranchConditional %36 %30 %31 %30 = OpLabel %39 = OpIAdd %6 %47 %38 OpStore %8 %39 OpBranchConditional %80 %75 %32 %75 = OpLabel %42 = OpFAdd %10 %51 %41 OpStore %12 %42 OpBranchConditional %80 %32 %32 %32 = OpLabel %100 = OpPhi %10 %42 %75 %13 %29 %22 %30 %101 = OpPhi %6 %39 %75 %21 %29 %46 %30 OpBranch %29 %31 = OpLabel %71 = OpPhi %6 %47 %33 %72 = OpPhi %10 %51 %33 OpStore %15 %71 %45 = OpFAdd %10 %72 %13 OpStore %12 %45 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationAddDeadContinueTest, RespectDominanceRules1) { // Checks that a dead continue cannot be added if it would prevent a block // later in the loop from dominating the loop's continue construct, in the // case where said block defines and id that is used in the loop's continue // construct. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeBool %11 = OpConstantFalse %10 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %6 %6 = OpLabel OpLoopMerge %8 %9 None OpBranch %7 %7 = OpLabel %21 = OpCopyObject %10 %11 OpBranch %9 %9 = OpLabel %20 = OpPhi %10 %21 %7 OpBranchConditional %11 %6 %8 %8 = OpLabel OpBranch %12 %12 = OpLabel OpLoopMerge %14 %15 None OpBranch %13 %13 = OpLabel OpBranch %22 %22 = OpLabel %23 = OpCopyObject %10 %11 OpBranch %25 %25 = OpLabel OpBranch %15 %15 = OpLabel %26 = OpCopyObject %10 %23 OpBranchConditional %11 %12 %14 %14 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // This transformation is not applicable because the dead continue from the // loop body prevents the definition of %23 later in the loop body from // dominating its use in the loop's continue target. auto bad_transformation = TransformationAddDeadContinue(13, false, {}); ASSERT_FALSE( bad_transformation.IsApplicable(context.get(), transformation_context)); auto good_transformation_1 = TransformationAddDeadContinue(7, false, {}); ASSERT_TRUE(good_transformation_1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(good_transformation_1, context.get(), &transformation_context); auto good_transformation_2 = TransformationAddDeadContinue(22, false, {}); ASSERT_TRUE(good_transformation_2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(good_transformation_2, context.get(), &transformation_context); // This transformation is OK, because the definition of %21 in the loop body // is only used in an OpPhi in the loop's continue target. auto good_transformation_3 = TransformationAddDeadContinue(6, false, {11}); ASSERT_TRUE(good_transformation_3.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(good_transformation_3, context.get(), &transformation_context); std::string after_transformations = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeBool %11 = OpConstantFalse %10 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %6 %6 = OpLabel OpLoopMerge %8 %9 None OpBranchConditional %11 %9 %7 %7 = OpLabel %21 = OpCopyObject %10 %11 OpBranchConditional %11 %9 %9 %9 = OpLabel %20 = OpPhi %10 %21 %7 %11 %6 OpBranchConditional %11 %6 %8 %8 = OpLabel OpBranch %12 %12 = OpLabel OpLoopMerge %14 %15 None OpBranch %13 %13 = OpLabel OpBranch %22 %22 = OpLabel %23 = OpCopyObject %10 %11 OpBranchConditional %11 %15 %25 %25 = OpLabel OpBranch %15 %15 = OpLabel %26 = OpCopyObject %10 %23 OpBranchConditional %11 %12 %14 %14 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformations, context.get())); } TEST(TransformationAddDeadContinueTest, RespectDominanceRules2) { // Checks that a dead continue cannot be added if it would lead to a use after // the loop failing to be dominated by its definition. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeBool %11 = OpConstantFalse %10 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %100 %100 = OpLabel OpLoopMerge %101 %102 None OpBranch %103 %103 = OpLabel %200 = OpCopyObject %10 %11 OpBranch %104 %104 = OpLabel OpBranch %102 %102 = OpLabel OpBranchConditional %11 %100 %101 %101 = OpLabel %201 = OpCopyObject %10 %200 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // This transformation would shortcut the part of the loop body that defines // an id used after the loop. auto bad_transformation = TransformationAddDeadContinue(100, false, {}); ASSERT_FALSE( bad_transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationAddDeadContinueTest, RespectDominanceRules3) { // Checks that a dead continue cannot be added if it would lead to a dominance // problem with an id used in an OpPhi after the loop. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeBool %11 = OpConstantFalse %10 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %100 %100 = OpLabel OpLoopMerge %101 %102 None OpBranch %103 %103 = OpLabel %200 = OpCopyObject %10 %11 OpBranch %104 %104 = OpLabel OpBranch %102 %102 = OpLabel OpBranchConditional %11 %100 %101 %101 = OpLabel %201 = OpPhi %10 %200 %102 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // This transformation would shortcut the part of the loop body that defines // an id used after the loop. auto bad_transformation = TransformationAddDeadContinue(100, false, {}); ASSERT_FALSE( bad_transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationAddDeadContinueTest, Miscellaneous1) { // A miscellaneous test that exposed a bug in spirv-fuzz. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %586 %623 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpMemberDecorate %34 0 Offset 0 OpDecorate %34 Block OpDecorate %36 DescriptorSet 0 OpDecorate %36 Binding 0 OpDecorate %586 BuiltIn FragCoord OpMemberDecorate %591 0 Offset 0 OpDecorate %591 Block OpDecorate %593 DescriptorSet 0 OpDecorate %593 Binding 1 OpDecorate %623 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 2 %17 = OpTypeBool %27 = OpTypeFloat 32 %28 = OpTypeVector %27 2 %29 = OpTypeMatrix %28 2 %30 = OpTypePointer Private %29 %31 = OpVariable %30 Private %34 = OpTypeStruct %27 %35 = OpTypePointer Uniform %34 %36 = OpVariable %35 Uniform %37 = OpTypePointer Uniform %27 %40 = OpTypePointer Private %27 %43 = OpConstant %6 1 %62 = OpConstant %6 3 %64 = OpTypeVector %27 3 %65 = OpTypeMatrix %64 2 %66 = OpTypePointer Private %65 %67 = OpVariable %66 Private %92 = OpConstant %6 4 %94 = OpTypeVector %27 4 %95 = OpTypeMatrix %94 2 %96 = OpTypePointer Private %95 %97 = OpVariable %96 Private %123 = OpTypeMatrix %28 3 %124 = OpTypePointer Private %123 %125 = OpVariable %124 Private %151 = OpTypeMatrix %64 3 %152 = OpTypePointer Private %151 %153 = OpVariable %152 Private %179 = OpTypeMatrix %94 3 %180 = OpTypePointer Private %179 %181 = OpVariable %180 Private %207 = OpTypeMatrix %28 4 %208 = OpTypePointer Private %207 %209 = OpVariable %208 Private %235 = OpTypeMatrix %64 4 %236 = OpTypePointer Private %235 %237 = OpVariable %236 Private %263 = OpTypeMatrix %94 4 %264 = OpTypePointer Private %263 %265 = OpVariable %264 Private %275 = OpTypeInt 32 0 %276 = OpConstant %275 9 %277 = OpTypeArray %27 %276 %278 = OpTypePointer Function %277 %280 = OpConstant %27 0 %281 = OpTypePointer Function %27 %311 = OpConstant %27 16 %448 = OpConstant %6 5 %482 = OpConstant %6 6 %516 = OpConstant %6 7 %550 = OpConstant %6 8 %585 = OpTypePointer Input %94 %586 = OpVariable %585 Input %587 = OpConstant %275 0 %588 = OpTypePointer Input %27 %591 = OpTypeStruct %28 %592 = OpTypePointer Uniform %591 %593 = OpVariable %592 Uniform %596 = OpConstant %27 3 %601 = OpConstant %275 1 %617 = OpConstant %6 9 %622 = OpTypePointer Output %94 %623 = OpVariable %622 Output %628 = OpConstant %27 1 %634 = OpConstantComposite %94 %280 %280 %280 %628 %635 = OpUndef %6 %636 = OpUndef %17 %637 = OpUndef %27 %638 = OpUndef %64 %639 = OpUndef %94 %640 = OpConstantTrue %17 %736 = OpConstantFalse %17 %642 = OpVariable %37 Uniform %643 = OpVariable %40 Private %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %164 %164 = OpLabel OpLoopMerge %166 %167 None OpBranch %165 %165 = OpLabel OpBranch %172 %172 = OpLabel OpSelectionMerge %174 None OpBranchConditional %640 %174 %174 %174 = OpLabel %785 = OpCopyObject %6 %43 OpBranch %167 %167 = OpLabel %190 = OpIAdd %6 %9 %785 OpBranchConditional %640 %164 %166 %166 = OpLabel OpBranch %196 %196 = OpLabel OpBranch %194 %194 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // This transformation would shortcut the part of the loop body that defines // an id used in the continue target. auto bad_transformation = TransformationAddDeadContinue(165, false, {}); ASSERT_FALSE( bad_transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationAddDeadContinueTest, Miscellaneous2) { // A miscellaneous test that exposed a bug in spirv-fuzz. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %51 = OpTypeBool %395 = OpConstantTrue %51 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %389 %389 = OpLabel OpLoopMerge %388 %391 None OpBranch %339 %339 = OpLabel OpSelectionMerge %396 None OpBranchConditional %395 %388 %396 %396 = OpLabel OpBranch %1552 %1552 = OpLabel OpLoopMerge %1553 %1554 None OpBranch %1556 %1556 = OpLabel OpLoopMerge %1557 %1570 None OpBranchConditional %395 %1562 %1557 %1562 = OpLabel OpBranchConditional %395 %1571 %1570 %1571 = OpLabel OpBranch %1557 %1570 = OpLabel OpBranch %1556 %1557 = OpLabel OpSelectionMerge %1586 None OpBranchConditional %395 %1553 %1586 %1586 = OpLabel OpBranch %1553 %1554 = OpLabel OpBranch %1552 %1553 = OpLabel OpBranch %388 %391 = OpLabel OpBranch %389 %388 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // This transformation would introduce a branch from a continue target to // itself. auto bad_transformation = TransformationAddDeadContinue(1554, true, {}); ASSERT_FALSE( bad_transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationAddDeadContinueTest, Miscellaneous3) { // A miscellaneous test that exposed a bug in spirv-fuzz. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %85 = OpTypeBool %434 = OpConstantFalse %85 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %234 %234 = OpLabel OpLoopMerge %235 %236 None OpBranch %259 %259 = OpLabel OpLoopMerge %260 %274 None OpBranchConditional %434 %265 %260 %265 = OpLabel OpBranch %275 %275 = OpLabel OpBranch %260 %274 = OpLabel OpBranch %259 %260 = OpLabel OpSelectionMerge %298 None OpBranchConditional %434 %299 %300 %300 = OpLabel OpBranch %235 %298 = OpLabel OpUnreachable %236 = OpLabel OpBranch %234 %299 = OpLabel OpBranch %235 %235 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto bad_transformation = TransformationAddDeadContinue(299, false, {}); // The continue edge would connect %299 to the previously-unreachable %236, // making %299 dominate %236, and breaking the rule that block ordering must // respect dominance. ASSERT_FALSE( bad_transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationAddDeadContinueTest, Miscellaneous4) { // A miscellaneous test that exposed a bug in spirv-fuzz. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 100 %17 = OpTypeBool %100 = OpConstantFalse %17 %21 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %13 = OpLabel %20 = OpLoad %6 %8 %22 = OpIAdd %6 %20 %21 OpStore %8 %22 OpBranch %10 %10 = OpLabel OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %15 = OpLoad %6 %8 %18 = OpSLessThan %17 %15 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel OpBranch %12 %12 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto bad_transformation = TransformationAddDeadContinue(10, false, {}); // The continue edge would connect %10 to the previously-unreachable %13, // making %10 dominate %13, and breaking the rule that block ordering must // respect dominance. ASSERT_FALSE( bad_transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationAddDeadContinueTest, Miscellaneous5) { // A miscellaneous test that exposed a bug in spirv-fuzz. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpTypePointer Function %6 %9 = OpConstantTrue %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %98 %98 = OpLabel OpLoopMerge %100 %101 None OpBranch %99 %99 = OpLabel OpSelectionMerge %111 None OpBranchConditional %9 %110 %111 %110 = OpLabel OpBranch %100 %111 = OpLabel %200 = OpCopyObject %6 %9 OpBranch %101 %101 = OpLabel %201 = OpCopyObject %6 %200 OpBranchConditional %9 %98 %100 %100 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto bad_transformation = TransformationAddDeadContinue(110, true, {}); // The continue edge would lead to the use of %200 in block %101 no longer // being dominated by its definition in block %111. ASSERT_FALSE( bad_transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationAddDeadContinueTest, Miscellaneous6) { // A miscellaneous test that exposed a bug in spirv-fuzz. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %9 = OpConstantTrue %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %10 %10 = OpLabel OpLoopMerge %13 %12 None OpBranch %11 %11 = OpLabel %20 = OpCopyObject %6 %9 OpBranch %12 %12 = OpLabel OpBranchConditional %9 %10 %13 %13 = OpLabel %21 = OpCopyObject %6 %20 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto bad_transformation = TransformationAddDeadContinue(10, true, {}); ASSERT_FALSE( bad_transformation.IsApplicable(context.get(), transformation_context)); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_add_early_terminator_wrapper_test.cpp000066400000000000000000000145501475742701700333340ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_early_terminator_wrapper.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationAddEarlyTerminatorWrapperTest, NoVoidType) { std::string shader = R"( OpCapability Shader OpCapability Linkage %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpSource ESSL 320 )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_FALSE( TransformationAddEarlyTerminatorWrapper(100, 101, spv::Op::OpKill) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationAddEarlyTerminatorWrapperTest, NoVoidFunctionType) { std::string shader = R"( OpCapability Shader OpCapability Linkage %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpSource ESSL 320 %2 = OpTypeVoid )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_FALSE( TransformationAddEarlyTerminatorWrapper(100, 101, spv::Op::OpKill) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationAddEarlyTerminatorWrapperTest, BasicTest) { std::string shader = R"( OpCapability Shader OpExtension "SPV_KHR_terminate_invocation" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_FALSE(TransformationAddEarlyTerminatorWrapper(2, 101, spv::Op::OpKill) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationAddEarlyTerminatorWrapper(100, 4, spv::Op::OpKill) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( TransformationAddEarlyTerminatorWrapper(100, 100, spv::Op::OpKill) .IsApplicable(context.get(), transformation_context)); #ifndef NDEBUG ASSERT_DEATH( TransformationAddEarlyTerminatorWrapper(100, 101, spv::Op::OpReturn) .IsApplicable(context.get(), transformation_context), "Invalid opcode."); #endif auto transformation1 = TransformationAddEarlyTerminatorWrapper(100, 101, spv::Op::OpKill); auto transformation2 = TransformationAddEarlyTerminatorWrapper(102, 103, spv::Op::OpUnreachable); auto transformation3 = TransformationAddEarlyTerminatorWrapper( 104, 105, spv::Op::OpTerminateInvocation); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); ASSERT_TRUE( transformation3.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation3, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader OpExtension "SPV_KHR_terminate_invocation" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %100 = OpFunction %2 None %3 %101 = OpLabel OpKill OpFunctionEnd %102 = OpFunction %2 None %3 %103 = OpLabel OpUnreachable OpFunctionEnd %104 = OpFunction %2 None %3 %105 = OpLabel OpTerminateInvocation OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_add_function_test.cpp000066400000000000000000003617321475742701700300500ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_function.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_message.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { protobufs::AccessChainClampingInfo MakeAccessClampingInfo( uint32_t access_chain_id, const std::vector>& compare_and_select_ids) { protobufs::AccessChainClampingInfo result; result.set_access_chain_id(access_chain_id); for (auto& compare_and_select_id : compare_and_select_ids) { auto pair = result.add_compare_and_select_ids(); pair->set_first(compare_and_select_id.first); pair->set_second(compare_and_select_id.second); } return result; } std::vector GetInstructionsForFunction( spv_target_env env, const MessageConsumer& consumer, const std::string& donor, uint32_t function_id) { std::vector result; const auto donor_context = BuildModule(env, consumer, donor, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; assert(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer) && "The given donor must be valid."); for (auto& function : *donor_context->module()) { if (function.result_id() == function_id) { function.ForEachInst([&result](opt::Instruction* inst) { opt::Instruction::OperandList input_operands; for (uint32_t i = 0; i < inst->NumInOperands(); i++) { input_operands.push_back(inst->GetInOperand(i)); } result.push_back(MakeInstructionMessage(inst->opcode(), inst->type_id(), inst->result_id(), input_operands)); }); break; } } assert(!result.empty() && "The required function should have been found."); return result; } // Returns true if and only if every pointer parameter and variable associated // with |function_id| in |context| is known by |transformation_context| to be // irrelevant, with the exception of |loop_limiter_id|, which must not be // irrelevant. (It can be 0 if no loop limiter is expected, and 0 should not be // deemed irrelevant). bool AllVariablesAndParametersExceptLoopLimiterAreIrrelevant( opt::IRContext* context, const TransformationContext& transformation_context, uint32_t function_id, uint32_t loop_limiter_id) { // Look at all the functions until the function of interest is found. for (auto& function : *context->module()) { if (function.result_id() != function_id) { continue; } // Check that the parameters are all irrelevant. bool found_non_irrelevant_parameter = false; function.ForEachParam([context, &transformation_context, &found_non_irrelevant_parameter]( opt::Instruction* inst) { if (context->get_def_use_mgr()->GetDef(inst->type_id())->opcode() == spv::Op::OpTypePointer && !transformation_context.GetFactManager()->PointeeValueIsIrrelevant( inst->result_id())) { found_non_irrelevant_parameter = true; } }); if (found_non_irrelevant_parameter) { // A non-irrelevant parameter was found. return false; } // Look through the instructions in the function's first block. for (auto& inst : *function.begin()) { if (inst.opcode() != spv::Op::OpVariable) { // We have found a non-variable instruction; this means we have gotten // past all variables, so we are done. return true; } // The variable should be irrelevant if and only if it is not the loop // limiter. if ((inst.result_id() == loop_limiter_id) == transformation_context.GetFactManager()->PointeeValueIsIrrelevant( inst.result_id())) { return false; } } assert(false && "We should have processed all variables and returned by " "this point."); } assert(false && "We should have found the function of interest."); return true; } TEST(TransformationAddFunctionTest, BasicTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFloat 32 %9 = OpTypePointer Function %8 %10 = OpTypeFunction %8 %7 %9 %18 = OpConstant %8 0 %20 = OpConstant %6 0 %28 = OpTypeBool %37 = OpConstant %6 1 %42 = OpTypePointer Private %8 %43 = OpVariable %42 Private %47 = OpConstant %8 1 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationAddFunction transformation1(std::vector( {MakeInstructionMessage(spv::Op::OpFunction, 8, 13, {{SPV_OPERAND_TYPE_FUNCTION_CONTROL, {uint32_t(spv::FunctionControlMask::MaskNone)}}, {SPV_OPERAND_TYPE_ID, {10}}}), MakeInstructionMessage(spv::Op::OpFunctionParameter, 7, 11, {}), MakeInstructionMessage(spv::Op::OpFunctionParameter, 9, 12, {}), MakeInstructionMessage(spv::Op::OpLabel, 0, 14, {}), MakeInstructionMessage(spv::Op::OpVariable, 9, 17, {{SPV_OPERAND_TYPE_STORAGE_CLASS, {uint32_t(spv::StorageClass::Function)}}}), MakeInstructionMessage(spv::Op::OpVariable, 7, 19, {{SPV_OPERAND_TYPE_STORAGE_CLASS, {uint32_t(spv::StorageClass::Function)}}}), MakeInstructionMessage( spv::Op::OpStore, 0, 0, {{SPV_OPERAND_TYPE_ID, {17}}, {SPV_OPERAND_TYPE_ID, {18}}}), MakeInstructionMessage( spv::Op::OpStore, 0, 0, {{SPV_OPERAND_TYPE_ID, {19}}, {SPV_OPERAND_TYPE_ID, {20}}}), MakeInstructionMessage(spv::Op::OpBranch, 0, 0, {{SPV_OPERAND_TYPE_ID, {21}}}), MakeInstructionMessage(spv::Op::OpLabel, 0, 21, {}), MakeInstructionMessage(spv::Op::OpLoopMerge, 0, 0, {{SPV_OPERAND_TYPE_ID, {23}}, {SPV_OPERAND_TYPE_ID, {24}}, {SPV_OPERAND_TYPE_LOOP_CONTROL, {uint32_t(spv::LoopControlMask::MaskNone)}}}), MakeInstructionMessage(spv::Op::OpBranch, 0, 0, {{SPV_OPERAND_TYPE_ID, {25}}}), MakeInstructionMessage(spv::Op::OpLabel, 0, 25, {}), MakeInstructionMessage(spv::Op::OpLoad, 6, 26, {{SPV_OPERAND_TYPE_ID, {19}}}), MakeInstructionMessage(spv::Op::OpLoad, 6, 27, {{SPV_OPERAND_TYPE_ID, {11}}}), MakeInstructionMessage( spv::Op::OpSLessThan, 28, 29, {{SPV_OPERAND_TYPE_ID, {26}}, {SPV_OPERAND_TYPE_ID, {27}}}), MakeInstructionMessage(spv::Op::OpBranchConditional, 0, 0, {{SPV_OPERAND_TYPE_ID, {29}}, {SPV_OPERAND_TYPE_ID, {22}}, {SPV_OPERAND_TYPE_ID, {23}}}), MakeInstructionMessage(spv::Op::OpLabel, 0, 22, {}), MakeInstructionMessage(spv::Op::OpLoad, 8, 30, {{SPV_OPERAND_TYPE_ID, {12}}}), MakeInstructionMessage(spv::Op::OpLoad, 6, 31, {{SPV_OPERAND_TYPE_ID, {19}}}), MakeInstructionMessage(spv::Op::OpConvertSToF, 8, 32, {{SPV_OPERAND_TYPE_ID, {31}}}), MakeInstructionMessage( spv::Op::OpFMul, 8, 33, {{SPV_OPERAND_TYPE_ID, {30}}, {SPV_OPERAND_TYPE_ID, {32}}}), MakeInstructionMessage(spv::Op::OpLoad, 8, 34, {{SPV_OPERAND_TYPE_ID, {17}}}), MakeInstructionMessage( spv::Op::OpFAdd, 8, 35, {{SPV_OPERAND_TYPE_ID, {34}}, {SPV_OPERAND_TYPE_ID, {33}}}), MakeInstructionMessage( spv::Op::OpStore, 0, 0, {{SPV_OPERAND_TYPE_ID, {17}}, {SPV_OPERAND_TYPE_ID, {35}}}), MakeInstructionMessage(spv::Op::OpBranch, 0, 0, {{SPV_OPERAND_TYPE_ID, {24}}}), MakeInstructionMessage(spv::Op::OpLabel, 0, 24, {}), MakeInstructionMessage(spv::Op::OpLoad, 6, 36, {{SPV_OPERAND_TYPE_ID, {19}}}), MakeInstructionMessage( spv::Op::OpIAdd, 6, 38, {{SPV_OPERAND_TYPE_ID, {36}}, {SPV_OPERAND_TYPE_ID, {37}}}), MakeInstructionMessage( spv::Op::OpStore, 0, 0, {{SPV_OPERAND_TYPE_ID, {19}}, {SPV_OPERAND_TYPE_ID, {38}}}), MakeInstructionMessage(spv::Op::OpBranch, 0, 0, {{SPV_OPERAND_TYPE_ID, {21}}}), MakeInstructionMessage(spv::Op::OpLabel, 0, 23, {}), MakeInstructionMessage(spv::Op::OpLoad, 8, 39, {{SPV_OPERAND_TYPE_ID, {17}}}), MakeInstructionMessage(spv::Op::OpReturnValue, 0, 0, {{SPV_OPERAND_TYPE_ID, {39}}}), MakeInstructionMessage(spv::Op::OpFunctionEnd, 0, 0, {})})); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation1 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFloat 32 %9 = OpTypePointer Function %8 %10 = OpTypeFunction %8 %7 %9 %18 = OpConstant %8 0 %20 = OpConstant %6 0 %28 = OpTypeBool %37 = OpConstant %6 1 %42 = OpTypePointer Private %8 %43 = OpVariable %42 Private %47 = OpConstant %8 1 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %13 = OpFunction %8 None %10 %11 = OpFunctionParameter %7 %12 = OpFunctionParameter %9 %14 = OpLabel %17 = OpVariable %9 Function %19 = OpVariable %7 Function OpStore %17 %18 OpStore %19 %20 OpBranch %21 %21 = OpLabel OpLoopMerge %23 %24 None OpBranch %25 %25 = OpLabel %26 = OpLoad %6 %19 %27 = OpLoad %6 %11 %29 = OpSLessThan %28 %26 %27 OpBranchConditional %29 %22 %23 %22 = OpLabel %30 = OpLoad %8 %12 %31 = OpLoad %6 %19 %32 = OpConvertSToF %8 %31 %33 = OpFMul %8 %30 %32 %34 = OpLoad %8 %17 %35 = OpFAdd %8 %34 %33 OpStore %17 %35 OpBranch %24 %24 = OpLabel %36 = OpLoad %6 %19 %38 = OpIAdd %6 %36 %37 OpStore %19 %38 OpBranch %21 %23 = OpLabel %39 = OpLoad %8 %17 OpReturnValue %39 OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation1, context.get())); ASSERT_TRUE(transformation_context.GetFactManager()->BlockIsDead(14)); ASSERT_TRUE(transformation_context.GetFactManager()->BlockIsDead(21)); ASSERT_TRUE(transformation_context.GetFactManager()->BlockIsDead(22)); ASSERT_TRUE(transformation_context.GetFactManager()->BlockIsDead(23)); ASSERT_TRUE(transformation_context.GetFactManager()->BlockIsDead(24)); ASSERT_TRUE(transformation_context.GetFactManager()->BlockIsDead(25)); TransformationAddFunction transformation2(std::vector( {MakeInstructionMessage(spv::Op::OpFunction, 2, 15, {{SPV_OPERAND_TYPE_FUNCTION_CONTROL, {uint32_t(spv::FunctionControlMask::MaskNone)}}, {SPV_OPERAND_TYPE_ID, {3}}}), MakeInstructionMessage(spv::Op::OpLabel, 0, 16, {}), MakeInstructionMessage(spv::Op::OpVariable, 7, 44, {{SPV_OPERAND_TYPE_STORAGE_CLASS, {uint32_t(spv::StorageClass::Function)}}}), MakeInstructionMessage(spv::Op::OpVariable, 9, 45, {{SPV_OPERAND_TYPE_STORAGE_CLASS, {uint32_t(spv::StorageClass::Function)}}}), MakeInstructionMessage(spv::Op::OpVariable, 7, 48, {{SPV_OPERAND_TYPE_STORAGE_CLASS, {uint32_t(spv::StorageClass::Function)}}}), MakeInstructionMessage(spv::Op::OpVariable, 9, 49, {{SPV_OPERAND_TYPE_STORAGE_CLASS, {uint32_t(spv::StorageClass::Function)}}}), MakeInstructionMessage( spv::Op::OpStore, 0, 0, {{SPV_OPERAND_TYPE_ID, {44}}, {SPV_OPERAND_TYPE_ID, {20}}}), MakeInstructionMessage( spv::Op::OpStore, 0, 0, {{SPV_OPERAND_TYPE_ID, {45}}, {SPV_OPERAND_TYPE_ID, {18}}}), MakeInstructionMessage(spv::Op::OpFunctionCall, 8, 46, {{SPV_OPERAND_TYPE_ID, {13}}, {SPV_OPERAND_TYPE_ID, {44}}, {SPV_OPERAND_TYPE_ID, {45}}}), MakeInstructionMessage( spv::Op::OpStore, 0, 0, {{SPV_OPERAND_TYPE_ID, {48}}, {SPV_OPERAND_TYPE_ID, {37}}}), MakeInstructionMessage( spv::Op::OpStore, 0, 0, {{SPV_OPERAND_TYPE_ID, {49}}, {SPV_OPERAND_TYPE_ID, {47}}}), MakeInstructionMessage(spv::Op::OpFunctionCall, 8, 50, {{SPV_OPERAND_TYPE_ID, {13}}, {SPV_OPERAND_TYPE_ID, {48}}, {SPV_OPERAND_TYPE_ID, {49}}}), MakeInstructionMessage( spv::Op::OpFAdd, 8, 51, {{SPV_OPERAND_TYPE_ID, {46}}, {SPV_OPERAND_TYPE_ID, {50}}}), MakeInstructionMessage( spv::Op::OpStore, 0, 0, {{SPV_OPERAND_TYPE_ID, {43}}, {SPV_OPERAND_TYPE_ID, {51}}}), MakeInstructionMessage(spv::Op::OpReturn, 0, 0, {}), MakeInstructionMessage(spv::Op::OpFunctionEnd, 0, 0, {})})); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation2 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFloat 32 %9 = OpTypePointer Function %8 %10 = OpTypeFunction %8 %7 %9 %18 = OpConstant %8 0 %20 = OpConstant %6 0 %28 = OpTypeBool %37 = OpConstant %6 1 %42 = OpTypePointer Private %8 %43 = OpVariable %42 Private %47 = OpConstant %8 1 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %13 = OpFunction %8 None %10 %11 = OpFunctionParameter %7 %12 = OpFunctionParameter %9 %14 = OpLabel %17 = OpVariable %9 Function %19 = OpVariable %7 Function OpStore %17 %18 OpStore %19 %20 OpBranch %21 %21 = OpLabel OpLoopMerge %23 %24 None OpBranch %25 %25 = OpLabel %26 = OpLoad %6 %19 %27 = OpLoad %6 %11 %29 = OpSLessThan %28 %26 %27 OpBranchConditional %29 %22 %23 %22 = OpLabel %30 = OpLoad %8 %12 %31 = OpLoad %6 %19 %32 = OpConvertSToF %8 %31 %33 = OpFMul %8 %30 %32 %34 = OpLoad %8 %17 %35 = OpFAdd %8 %34 %33 OpStore %17 %35 OpBranch %24 %24 = OpLabel %36 = OpLoad %6 %19 %38 = OpIAdd %6 %36 %37 OpStore %19 %38 OpBranch %21 %23 = OpLabel %39 = OpLoad %8 %17 OpReturnValue %39 OpFunctionEnd %15 = OpFunction %2 None %3 %16 = OpLabel %44 = OpVariable %7 Function %45 = OpVariable %9 Function %48 = OpVariable %7 Function %49 = OpVariable %9 Function OpStore %44 %20 OpStore %45 %18 %46 = OpFunctionCall %8 %13 %44 %45 OpStore %48 %37 OpStore %49 %47 %50 = OpFunctionCall %8 %13 %48 %49 %51 = OpFAdd %8 %46 %50 OpStore %43 %51 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation2, context.get())); ASSERT_TRUE(transformation_context.GetFactManager()->BlockIsDead(16)); } TEST(TransformationAddFunctionTest, InapplicableTransformations) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFloat 32 %9 = OpTypePointer Function %8 %10 = OpTypeFunction %8 %7 %9 %18 = OpConstant %8 0 %20 = OpConstant %6 0 %28 = OpTypeBool %37 = OpConstant %6 1 %42 = OpTypePointer Private %8 %43 = OpVariable %42 Private %47 = OpConstant %8 1 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %13 = OpFunction %8 None %10 %11 = OpFunctionParameter %7 %12 = OpFunctionParameter %9 %14 = OpLabel %17 = OpVariable %9 Function %19 = OpVariable %7 Function OpStore %17 %18 OpStore %19 %20 OpBranch %21 %21 = OpLabel OpLoopMerge %23 %24 None OpBranch %25 %25 = OpLabel %26 = OpLoad %6 %19 %27 = OpLoad %6 %11 %29 = OpSLessThan %28 %26 %27 OpBranchConditional %29 %22 %23 %22 = OpLabel %30 = OpLoad %8 %12 %31 = OpLoad %6 %19 %32 = OpConvertSToF %8 %31 %33 = OpFMul %8 %30 %32 %34 = OpLoad %8 %17 %35 = OpFAdd %8 %34 %33 OpStore %17 %35 OpBranch %24 %24 = OpLabel %36 = OpLoad %6 %19 %38 = OpIAdd %6 %36 %37 OpStore %19 %38 OpBranch %21 %23 = OpLabel %39 = OpLoad %8 %17 OpReturnValue %39 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // No instructions ASSERT_FALSE( TransformationAddFunction(std::vector({})) .IsApplicable(context.get(), transformation_context)); // No function begin ASSERT_FALSE( TransformationAddFunction( std::vector( {MakeInstructionMessage(spv::Op::OpFunctionParameter, 7, 11, {}), MakeInstructionMessage(spv::Op::OpFunctionParameter, 9, 12, {}), MakeInstructionMessage(spv::Op::OpLabel, 0, 14, {})})) .IsApplicable(context.get(), transformation_context)); // No OpLabel ASSERT_FALSE( TransformationAddFunction( std::vector( {MakeInstructionMessage( spv::Op::OpFunction, 8, 13, {{SPV_OPERAND_TYPE_FUNCTION_CONTROL, {uint32_t(spv::FunctionControlMask::MaskNone)}}, {SPV_OPERAND_TYPE_ID, {10}}}), MakeInstructionMessage(spv::Op::OpReturnValue, 0, 0, {{SPV_OPERAND_TYPE_ID, {39}}}), MakeInstructionMessage(spv::Op::OpFunctionEnd, 0, 0, {})})) .IsApplicable(context.get(), transformation_context)); // Abrupt end of instructions ASSERT_FALSE(TransformationAddFunction( std::vector({MakeInstructionMessage( spv::Op::OpFunction, 8, 13, {{SPV_OPERAND_TYPE_FUNCTION_CONTROL, {uint32_t(spv::FunctionControlMask::MaskNone)}}, {SPV_OPERAND_TYPE_ID, {10}}})})) .IsApplicable(context.get(), transformation_context)); // No function end ASSERT_FALSE(TransformationAddFunction( std::vector( {MakeInstructionMessage( spv::Op::OpFunction, 8, 13, {{SPV_OPERAND_TYPE_FUNCTION_CONTROL, {uint32_t(spv::FunctionControlMask::MaskNone)}}, {SPV_OPERAND_TYPE_ID, {10}}}), MakeInstructionMessage(spv::Op::OpLabel, 0, 14, {}), MakeInstructionMessage(spv::Op::OpReturnValue, 0, 0, {{SPV_OPERAND_TYPE_ID, {39}}})})) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationAddFunctionTest, LoopLimiters) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpTypePointer Function %6 %8 = OpConstant %6 0 %9 = OpConstant %6 1 %10 = OpConstant %6 5 %11 = OpTypeBool %12 = OpConstantTrue %11 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; std::vector instructions; instructions.push_back( MakeInstructionMessage(spv::Op::OpFunction, 2, 30, {{SPV_OPERAND_TYPE_FUNCTION_CONTROL, {uint32_t(spv::FunctionControlMask::MaskNone)}}, {SPV_OPERAND_TYPE_TYPE_ID, {3}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLabel, 0, 31, {})); instructions.push_back(MakeInstructionMessage(spv::Op::OpBranch, 0, 0, {{SPV_OPERAND_TYPE_ID, {20}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLabel, 0, 20, {})); instructions.push_back( MakeInstructionMessage(spv::Op::OpLoopMerge, 0, 0, {{SPV_OPERAND_TYPE_ID, {21}}, {SPV_OPERAND_TYPE_ID, {22}}, {SPV_OPERAND_TYPE_LOOP_CONTROL, {uint32_t(spv::LoopControlMask::MaskNone)}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpBranchConditional, 0, 0, {{SPV_OPERAND_TYPE_ID, {12}}, {SPV_OPERAND_TYPE_ID, {23}}, {SPV_OPERAND_TYPE_ID, {21}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLabel, 0, 23, {})); instructions.push_back( MakeInstructionMessage(spv::Op::OpLoopMerge, 0, 0, {{SPV_OPERAND_TYPE_ID, {25}}, {SPV_OPERAND_TYPE_ID, {26}}, {SPV_OPERAND_TYPE_LOOP_CONTROL, {uint32_t(spv::LoopControlMask::MaskNone)}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpBranch, 0, 0, {{SPV_OPERAND_TYPE_ID, {28}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLabel, 0, 28, {})); instructions.push_back(MakeInstructionMessage(spv::Op::OpBranchConditional, 0, 0, {{SPV_OPERAND_TYPE_ID, {12}}, {SPV_OPERAND_TYPE_ID, {26}}, {SPV_OPERAND_TYPE_ID, {25}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLabel, 0, 26, {})); instructions.push_back(MakeInstructionMessage(spv::Op::OpBranch, 0, 0, {{SPV_OPERAND_TYPE_ID, {23}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLabel, 0, 25, {})); instructions.push_back( MakeInstructionMessage(spv::Op::OpLoopMerge, 0, 0, {{SPV_OPERAND_TYPE_ID, {24}}, {SPV_OPERAND_TYPE_ID, {27}}, {SPV_OPERAND_TYPE_LOOP_CONTROL, {uint32_t(spv::LoopControlMask::MaskNone)}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpBranchConditional, 0, 0, {{SPV_OPERAND_TYPE_ID, {12}}, {SPV_OPERAND_TYPE_ID, {24}}, {SPV_OPERAND_TYPE_ID, {27}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLabel, 0, 27, {})); instructions.push_back(MakeInstructionMessage(spv::Op::OpBranch, 0, 0, {{SPV_OPERAND_TYPE_ID, {25}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLabel, 0, 24, {})); instructions.push_back(MakeInstructionMessage(spv::Op::OpBranch, 0, 0, {{SPV_OPERAND_TYPE_ID, {22}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLabel, 0, 22, {})); instructions.push_back(MakeInstructionMessage(spv::Op::OpBranch, 0, 0, {{SPV_OPERAND_TYPE_ID, {20}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLabel, 0, 21, {})); instructions.push_back(MakeInstructionMessage(spv::Op::OpReturn, 0, 0, {})); instructions.push_back( MakeInstructionMessage(spv::Op::OpFunctionEnd, 0, 0, {})); spvtools::ValidatorOptions validator_options; const auto context1 = BuildModule(env, consumer, shader, kFuzzAssembleOption); const auto context2 = BuildModule(env, consumer, shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context1.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context1( MakeUnique(context1.get()), validator_options); TransformationContext transformation_context2( MakeUnique(context2.get()), validator_options); TransformationAddFunction add_dead_function(instructions); ASSERT_TRUE( add_dead_function.IsApplicable(context1.get(), transformation_context1)); ApplyAndCheckFreshIds(add_dead_function, context1.get(), &transformation_context1); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context1.get(), validator_options, kConsoleMessageConsumer)); // The added function should not be deemed livesafe. ASSERT_FALSE( transformation_context1.GetFactManager()->FunctionIsLivesafe(30)); // All variables/parameters in the function should be deemed irrelevant. ASSERT_TRUE(AllVariablesAndParametersExceptLoopLimiterAreIrrelevant( context1.get(), transformation_context1, 30, 0)); std::string added_as_dead_code = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpTypePointer Function %6 %8 = OpConstant %6 0 %9 = OpConstant %6 1 %10 = OpConstant %6 5 %11 = OpTypeBool %12 = OpConstantTrue %11 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %30 = OpFunction %2 None %3 %31 = OpLabel OpBranch %20 %20 = OpLabel OpLoopMerge %21 %22 None OpBranchConditional %12 %23 %21 %23 = OpLabel OpLoopMerge %25 %26 None OpBranch %28 %28 = OpLabel OpBranchConditional %12 %26 %25 %26 = OpLabel OpBranch %23 %25 = OpLabel OpLoopMerge %24 %27 None OpBranchConditional %12 %24 %27 %27 = OpLabel OpBranch %25 %24 = OpLabel OpBranch %22 %22 = OpLabel OpBranch %20 %21 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, added_as_dead_code, context1.get())); protobufs::LoopLimiterInfo loop_limiter1; loop_limiter1.set_loop_header_id(20); loop_limiter1.set_load_id(101); loop_limiter1.set_increment_id(102); loop_limiter1.set_compare_id(103); loop_limiter1.set_logical_op_id(104); protobufs::LoopLimiterInfo loop_limiter2; loop_limiter2.set_loop_header_id(23); loop_limiter2.set_load_id(105); loop_limiter2.set_increment_id(106); loop_limiter2.set_compare_id(107); loop_limiter2.set_logical_op_id(108); protobufs::LoopLimiterInfo loop_limiter3; loop_limiter3.set_loop_header_id(25); loop_limiter3.set_load_id(109); loop_limiter3.set_increment_id(110); loop_limiter3.set_compare_id(111); loop_limiter3.set_logical_op_id(112); std::vector loop_limiters = { loop_limiter1, loop_limiter2, loop_limiter3}; TransformationAddFunction add_livesafe_function(instructions, 100, 10, loop_limiters, 0, {}); ASSERT_TRUE(add_livesafe_function.IsApplicable(context2.get(), transformation_context2)); ApplyAndCheckFreshIds(add_livesafe_function, context2.get(), &transformation_context2); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context2.get(), validator_options, kConsoleMessageConsumer)); // The added function should indeed be deemed livesafe. ASSERT_TRUE(transformation_context2.GetFactManager()->FunctionIsLivesafe(30)); // All variables/parameters in the function should be deemed irrelevant, // except the loop limiter. ASSERT_TRUE(AllVariablesAndParametersExceptLoopLimiterAreIrrelevant( context2.get(), transformation_context2, 30, 100)); std::string added_as_livesafe_code = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpTypePointer Function %6 %8 = OpConstant %6 0 %9 = OpConstant %6 1 %10 = OpConstant %6 5 %11 = OpTypeBool %12 = OpConstantTrue %11 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %30 = OpFunction %2 None %3 %31 = OpLabel %100 = OpVariable %7 Function %8 OpBranch %20 %20 = OpLabel OpLoopMerge %21 %22 None OpBranchConditional %12 %23 %21 %23 = OpLabel OpLoopMerge %25 %26 None OpBranch %28 %28 = OpLabel OpBranchConditional %12 %26 %25 %26 = OpLabel %105 = OpLoad %6 %100 %106 = OpIAdd %6 %105 %9 OpStore %100 %106 %107 = OpUGreaterThanEqual %11 %105 %10 OpBranchConditional %107 %25 %23 %25 = OpLabel OpLoopMerge %24 %27 None OpBranchConditional %12 %24 %27 %27 = OpLabel %109 = OpLoad %6 %100 %110 = OpIAdd %6 %109 %9 OpStore %100 %110 %111 = OpUGreaterThanEqual %11 %109 %10 OpBranchConditional %111 %24 %25 %24 = OpLabel OpBranch %22 %22 = OpLabel %101 = OpLoad %6 %100 %102 = OpIAdd %6 %101 %9 OpStore %100 %102 %103 = OpUGreaterThanEqual %11 %101 %10 OpBranchConditional %103 %21 %20 %21 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, added_as_livesafe_code, context2.get())); } TEST(TransformationAddFunctionTest, KillAndUnreachableInVoidFunction) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %2 %7 %13 = OpConstant %6 2 %14 = OpTypeBool %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; std::vector instructions; instructions.push_back( MakeInstructionMessage(spv::Op::OpFunction, 2, 10, {{SPV_OPERAND_TYPE_FUNCTION_CONTROL, {uint32_t(spv::FunctionControlMask::MaskNone)}}, {SPV_OPERAND_TYPE_TYPE_ID, {8}}})); instructions.push_back( MakeInstructionMessage(spv::Op::OpFunctionParameter, 7, 9, {})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLabel, 0, 11, {})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLoad, 6, 12, {{SPV_OPERAND_TYPE_ID, {9}}})); instructions.push_back(MakeInstructionMessage( spv::Op::OpIEqual, 14, 15, {{SPV_OPERAND_TYPE_ID, {12}}, {SPV_OPERAND_TYPE_ID, {13}}})); instructions.push_back(MakeInstructionMessage( spv::Op::OpSelectionMerge, 0, 0, {{SPV_OPERAND_TYPE_ID, {17}}, {SPV_OPERAND_TYPE_SELECTION_CONTROL, {uint32_t(spv::SelectionControlMask::MaskNone)}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpBranchConditional, 0, 0, {{SPV_OPERAND_TYPE_ID, {15}}, {SPV_OPERAND_TYPE_ID, {16}}, {SPV_OPERAND_TYPE_ID, {17}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLabel, 0, 16, {})); instructions.push_back( MakeInstructionMessage(spv::Op::OpUnreachable, 0, 0, {})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLabel, 0, 17, {})); instructions.push_back(MakeInstructionMessage(spv::Op::OpKill, 0, 0, {})); instructions.push_back( MakeInstructionMessage(spv::Op::OpFunctionEnd, 0, 0, {})); spvtools::ValidatorOptions validator_options; const auto context1 = BuildModule(env, consumer, shader, kFuzzAssembleOption); const auto context2 = BuildModule(env, consumer, shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context1.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context1( MakeUnique(context1.get()), validator_options); TransformationContext transformation_context2( MakeUnique(context2.get()), validator_options); TransformationAddFunction add_dead_function(instructions); ASSERT_TRUE( add_dead_function.IsApplicable(context1.get(), transformation_context1)); ApplyAndCheckFreshIds(add_dead_function, context1.get(), &transformation_context1); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context1.get(), validator_options, kConsoleMessageConsumer)); // The added function should not be deemed livesafe. ASSERT_FALSE( transformation_context1.GetFactManager()->FunctionIsLivesafe(10)); // All variables/parameters in the function should be deemed irrelevant. ASSERT_TRUE(AllVariablesAndParametersExceptLoopLimiterAreIrrelevant( context1.get(), transformation_context1, 10, 0)); std::string added_as_dead_code = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %2 %7 %13 = OpConstant %6 2 %14 = OpTypeBool %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %10 = OpFunction %2 None %8 %9 = OpFunctionParameter %7 %11 = OpLabel %12 = OpLoad %6 %9 %15 = OpIEqual %14 %12 %13 OpSelectionMerge %17 None OpBranchConditional %15 %16 %17 %16 = OpLabel OpUnreachable %17 = OpLabel OpKill OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, added_as_dead_code, context1.get())); TransformationAddFunction add_livesafe_function(instructions, 0, 0, {}, 0, {}); ASSERT_TRUE(add_livesafe_function.IsApplicable(context2.get(), transformation_context2)); ApplyAndCheckFreshIds(add_livesafe_function, context2.get(), &transformation_context2); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context2.get(), validator_options, kConsoleMessageConsumer)); // The added function should indeed be deemed livesafe. ASSERT_TRUE(transformation_context2.GetFactManager()->FunctionIsLivesafe(10)); // All variables/parameters in the function should be deemed irrelevant. ASSERT_TRUE(AllVariablesAndParametersExceptLoopLimiterAreIrrelevant( context2.get(), transformation_context2, 10, 0)); std::string added_as_livesafe_code = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %2 %7 %13 = OpConstant %6 2 %14 = OpTypeBool %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %10 = OpFunction %2 None %8 %9 = OpFunctionParameter %7 %11 = OpLabel %12 = OpLoad %6 %9 %15 = OpIEqual %14 %12 %13 OpSelectionMerge %17 None OpBranchConditional %15 %16 %17 %16 = OpLabel OpReturn %17 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, added_as_livesafe_code, context2.get())); } TEST(TransformationAddFunctionTest, KillAndUnreachableInNonVoidFunction) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %2 %7 %50 = OpTypeFunction %6 %7 %13 = OpConstant %6 2 %14 = OpTypeBool %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; std::vector instructions; instructions.push_back( MakeInstructionMessage(spv::Op::OpFunction, 6, 10, {{SPV_OPERAND_TYPE_FUNCTION_CONTROL, {uint32_t(spv::FunctionControlMask::MaskNone)}}, {SPV_OPERAND_TYPE_TYPE_ID, {50}}})); instructions.push_back( MakeInstructionMessage(spv::Op::OpFunctionParameter, 7, 9, {})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLabel, 0, 11, {})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLoad, 6, 12, {{SPV_OPERAND_TYPE_ID, {9}}})); instructions.push_back(MakeInstructionMessage( spv::Op::OpIEqual, 14, 15, {{SPV_OPERAND_TYPE_ID, {12}}, {SPV_OPERAND_TYPE_ID, {13}}})); instructions.push_back(MakeInstructionMessage( spv::Op::OpSelectionMerge, 0, 0, {{SPV_OPERAND_TYPE_ID, {17}}, {SPV_OPERAND_TYPE_SELECTION_CONTROL, {uint32_t(spv::SelectionControlMask::MaskNone)}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpBranchConditional, 0, 0, {{SPV_OPERAND_TYPE_ID, {15}}, {SPV_OPERAND_TYPE_ID, {16}}, {SPV_OPERAND_TYPE_ID, {17}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLabel, 0, 16, {})); instructions.push_back( MakeInstructionMessage(spv::Op::OpUnreachable, 0, 0, {})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLabel, 0, 17, {})); instructions.push_back(MakeInstructionMessage(spv::Op::OpKill, 0, 0, {})); instructions.push_back( MakeInstructionMessage(spv::Op::OpFunctionEnd, 0, 0, {})); spvtools::ValidatorOptions validator_options; const auto context1 = BuildModule(env, consumer, shader, kFuzzAssembleOption); const auto context2 = BuildModule(env, consumer, shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context1.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context1( MakeUnique(context1.get()), validator_options); TransformationContext transformation_context2( MakeUnique(context2.get()), validator_options); TransformationAddFunction add_dead_function(instructions); ASSERT_TRUE( add_dead_function.IsApplicable(context1.get(), transformation_context1)); ApplyAndCheckFreshIds(add_dead_function, context1.get(), &transformation_context1); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context1.get(), validator_options, kConsoleMessageConsumer)); // The added function should not be deemed livesafe. ASSERT_FALSE( transformation_context1.GetFactManager()->FunctionIsLivesafe(10)); // All variables/parameters in the function should be deemed irrelevant. ASSERT_TRUE(AllVariablesAndParametersExceptLoopLimiterAreIrrelevant( context1.get(), transformation_context1, 10, 0)); std::string added_as_dead_code = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %2 %7 %50 = OpTypeFunction %6 %7 %13 = OpConstant %6 2 %14 = OpTypeBool %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %10 = OpFunction %6 None %50 %9 = OpFunctionParameter %7 %11 = OpLabel %12 = OpLoad %6 %9 %15 = OpIEqual %14 %12 %13 OpSelectionMerge %17 None OpBranchConditional %15 %16 %17 %16 = OpLabel OpUnreachable %17 = OpLabel OpKill OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, added_as_dead_code, context1.get())); TransformationAddFunction add_livesafe_function(instructions, 0, 0, {}, 13, {}); ASSERT_TRUE(add_livesafe_function.IsApplicable(context2.get(), transformation_context2)); ApplyAndCheckFreshIds(add_livesafe_function, context2.get(), &transformation_context2); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context2.get(), validator_options, kConsoleMessageConsumer)); // The added function should indeed be deemed livesafe. ASSERT_TRUE(transformation_context2.GetFactManager()->FunctionIsLivesafe(10)); // All variables/parameters in the function should be deemed irrelevant. ASSERT_TRUE(AllVariablesAndParametersExceptLoopLimiterAreIrrelevant( context2.get(), transformation_context2, 10, 0)); std::string added_as_livesafe_code = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %2 %7 %50 = OpTypeFunction %6 %7 %13 = OpConstant %6 2 %14 = OpTypeBool %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %10 = OpFunction %6 None %50 %9 = OpFunctionParameter %7 %11 = OpLabel %12 = OpLoad %6 %9 %15 = OpIEqual %14 %12 %13 OpSelectionMerge %17 None OpBranchConditional %15 %16 %17 %16 = OpLabel OpReturnValue %13 %17 = OpLabel OpReturnValue %13 OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, added_as_livesafe_code, context2.get())); } TEST(TransformationAddFunctionTest, ClampedAccessChains) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %100 = OpTypeBool %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %15 = OpTypeInt 32 0 %102 = OpTypePointer Function %15 %8 = OpTypeFunction %2 %7 %102 %7 %16 = OpConstant %15 5 %17 = OpTypeArray %6 %16 %18 = OpTypeArray %17 %16 %19 = OpTypePointer Private %18 %20 = OpVariable %19 Private %21 = OpConstant %6 0 %23 = OpTypePointer Private %6 %26 = OpTypePointer Function %17 %29 = OpTypePointer Private %17 %33 = OpConstant %6 4 %200 = OpConstant %15 4 %35 = OpConstant %15 10 %36 = OpTypeArray %6 %35 %37 = OpTypePointer Private %36 %38 = OpVariable %37 Private %54 = OpTypeFloat 32 %55 = OpTypeVector %54 4 %56 = OpTypePointer Private %55 %57 = OpVariable %56 Private %59 = OpTypeVector %54 3 %60 = OpTypeMatrix %59 2 %61 = OpTypePointer Private %60 %62 = OpVariable %61 Private %64 = OpTypePointer Private %54 %69 = OpConstant %54 2 %71 = OpConstant %6 1 %72 = OpConstant %6 2 %201 = OpConstant %15 2 %73 = OpConstant %6 3 %202 = OpConstant %15 3 %203 = OpConstant %6 1 %204 = OpConstant %6 9 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; std::vector instructions; instructions.push_back( MakeInstructionMessage(spv::Op::OpFunction, 2, 12, {{SPV_OPERAND_TYPE_FUNCTION_CONTROL, {uint32_t(spv::FunctionControlMask::MaskNone)}}, {SPV_OPERAND_TYPE_TYPE_ID, {8}}})); instructions.push_back( MakeInstructionMessage(spv::Op::OpFunctionParameter, 7, 9, {})); instructions.push_back( MakeInstructionMessage(spv::Op::OpFunctionParameter, 102, 10, {})); instructions.push_back( MakeInstructionMessage(spv::Op::OpFunctionParameter, 7, 11, {})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLabel, 0, 13, {})); instructions.push_back( MakeInstructionMessage(spv::Op::OpVariable, 7, 14, {{SPV_OPERAND_TYPE_STORAGE_CLASS, {uint32_t(spv::StorageClass::Function)}}})); instructions.push_back( MakeInstructionMessage(spv::Op::OpVariable, 26, 27, {{SPV_OPERAND_TYPE_STORAGE_CLASS, {uint32_t(spv::StorageClass::Function)}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLoad, 6, 22, {{SPV_OPERAND_TYPE_ID, {11}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpAccessChain, 23, 24, {{SPV_OPERAND_TYPE_ID, {20}}, {SPV_OPERAND_TYPE_ID, {21}}, {SPV_OPERAND_TYPE_ID, {22}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLoad, 6, 25, {{SPV_OPERAND_TYPE_ID, {24}}})); instructions.push_back(MakeInstructionMessage( spv::Op::OpStore, 0, 0, {{SPV_OPERAND_TYPE_ID, {14}}, {SPV_OPERAND_TYPE_ID, {25}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLoad, 15, 28, {{SPV_OPERAND_TYPE_ID, {10}}})); instructions.push_back(MakeInstructionMessage( spv::Op::OpAccessChain, 29, 30, {{SPV_OPERAND_TYPE_ID, {20}}, {SPV_OPERAND_TYPE_ID, {28}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLoad, 17, 31, {{SPV_OPERAND_TYPE_ID, {30}}})); instructions.push_back(MakeInstructionMessage( spv::Op::OpStore, 0, 0, {{SPV_OPERAND_TYPE_ID, {27}}, {SPV_OPERAND_TYPE_ID, {31}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLoad, 6, 32, {{SPV_OPERAND_TYPE_ID, {9}}})); instructions.push_back(MakeInstructionMessage( spv::Op::OpInBoundsAccessChain, 7, 34, {{SPV_OPERAND_TYPE_ID, {27}}, {SPV_OPERAND_TYPE_ID, {32}}})); instructions.push_back(MakeInstructionMessage( spv::Op::OpStore, 0, 0, {{SPV_OPERAND_TYPE_ID, {34}}, {SPV_OPERAND_TYPE_ID, {33}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLoad, 6, 39, {{SPV_OPERAND_TYPE_ID, {9}}})); instructions.push_back(MakeInstructionMessage( spv::Op::OpAccessChain, 23, 40, {{SPV_OPERAND_TYPE_ID, {38}}, {SPV_OPERAND_TYPE_ID, {33}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLoad, 6, 41, {{SPV_OPERAND_TYPE_ID, {40}}})); instructions.push_back(MakeInstructionMessage( spv::Op::OpInBoundsAccessChain, 23, 42, {{SPV_OPERAND_TYPE_ID, {38}}, {SPV_OPERAND_TYPE_ID, {39}}})); instructions.push_back(MakeInstructionMessage( spv::Op::OpStore, 0, 0, {{SPV_OPERAND_TYPE_ID, {42}}, {SPV_OPERAND_TYPE_ID, {41}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLoad, 15, 43, {{SPV_OPERAND_TYPE_ID, {10}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLoad, 6, 44, {{SPV_OPERAND_TYPE_ID, {11}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLoad, 6, 45, {{SPV_OPERAND_TYPE_ID, {9}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLoad, 15, 46, {{SPV_OPERAND_TYPE_ID, {10}}})); instructions.push_back(MakeInstructionMessage( spv::Op::OpIAdd, 6, 47, {{SPV_OPERAND_TYPE_ID, {45}}, {SPV_OPERAND_TYPE_ID, {46}}})); instructions.push_back(MakeInstructionMessage( spv::Op::OpAccessChain, 23, 48, {{SPV_OPERAND_TYPE_ID, {38}}, {SPV_OPERAND_TYPE_ID, {47}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLoad, 6, 49, {{SPV_OPERAND_TYPE_ID, {48}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpInBoundsAccessChain, 23, 50, {{SPV_OPERAND_TYPE_ID, {20}}, {SPV_OPERAND_TYPE_ID, {43}}, {SPV_OPERAND_TYPE_ID, {44}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLoad, 6, 51, {{SPV_OPERAND_TYPE_ID, {50}}})); instructions.push_back(MakeInstructionMessage( spv::Op::OpIAdd, 6, 52, {{SPV_OPERAND_TYPE_ID, {51}}, {SPV_OPERAND_TYPE_ID, {49}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpAccessChain, 23, 53, {{SPV_OPERAND_TYPE_ID, {20}}, {SPV_OPERAND_TYPE_ID, {43}}, {SPV_OPERAND_TYPE_ID, {44}}})); instructions.push_back(MakeInstructionMessage( spv::Op::OpStore, 0, 0, {{SPV_OPERAND_TYPE_ID, {53}}, {SPV_OPERAND_TYPE_ID, {52}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLoad, 15, 58, {{SPV_OPERAND_TYPE_ID, {10}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLoad, 6, 63, {{SPV_OPERAND_TYPE_ID, {11}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpAccessChain, 64, 65, {{SPV_OPERAND_TYPE_ID, {62}}, {SPV_OPERAND_TYPE_ID, {21}}, {SPV_OPERAND_TYPE_ID, {63}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpAccessChain, 64, 101, {{SPV_OPERAND_TYPE_ID, {62}}, {SPV_OPERAND_TYPE_ID, {45}}, {SPV_OPERAND_TYPE_ID, {46}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLoad, 54, 66, {{SPV_OPERAND_TYPE_ID, {65}}})); instructions.push_back(MakeInstructionMessage( spv::Op::OpAccessChain, 64, 67, {{SPV_OPERAND_TYPE_ID, {57}}, {SPV_OPERAND_TYPE_ID, {58}}})); instructions.push_back(MakeInstructionMessage( spv::Op::OpStore, 0, 0, {{SPV_OPERAND_TYPE_ID, {67}}, {SPV_OPERAND_TYPE_ID, {66}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLoad, 6, 68, {{SPV_OPERAND_TYPE_ID, {9}}})); instructions.push_back(MakeInstructionMessage( spv::Op::OpInBoundsAccessChain, 64, 70, {{SPV_OPERAND_TYPE_ID, {57}}, {SPV_OPERAND_TYPE_ID, {68}}})); instructions.push_back(MakeInstructionMessage( spv::Op::OpStore, 0, 0, {{SPV_OPERAND_TYPE_ID, {70}}, {SPV_OPERAND_TYPE_ID, {69}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpReturn, 0, 0, {})); instructions.push_back( MakeInstructionMessage(spv::Op::OpFunctionEnd, 0, 0, {})); spvtools::ValidatorOptions validator_options; const auto context1 = BuildModule(env, consumer, shader, kFuzzAssembleOption); const auto context2 = BuildModule(env, consumer, shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context1.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context1( MakeUnique(context1.get()), validator_options); TransformationContext transformation_context2( MakeUnique(context2.get()), validator_options); TransformationAddFunction add_dead_function(instructions); ASSERT_TRUE( add_dead_function.IsApplicable(context1.get(), transformation_context1)); ApplyAndCheckFreshIds(add_dead_function, context1.get(), &transformation_context1); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context1.get(), validator_options, kConsoleMessageConsumer)); // The function should not be deemed livesafe ASSERT_FALSE( transformation_context1.GetFactManager()->FunctionIsLivesafe(12)); // All variables/parameters in the function should be deemed irrelevant. ASSERT_TRUE(AllVariablesAndParametersExceptLoopLimiterAreIrrelevant( context1.get(), transformation_context1, 12, 0)); std::string added_as_dead_code = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %100 = OpTypeBool %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %15 = OpTypeInt 32 0 %102 = OpTypePointer Function %15 %8 = OpTypeFunction %2 %7 %102 %7 %16 = OpConstant %15 5 %17 = OpTypeArray %6 %16 %18 = OpTypeArray %17 %16 %19 = OpTypePointer Private %18 %20 = OpVariable %19 Private %21 = OpConstant %6 0 %23 = OpTypePointer Private %6 %26 = OpTypePointer Function %17 %29 = OpTypePointer Private %17 %33 = OpConstant %6 4 %200 = OpConstant %15 4 %35 = OpConstant %15 10 %36 = OpTypeArray %6 %35 %37 = OpTypePointer Private %36 %38 = OpVariable %37 Private %54 = OpTypeFloat 32 %55 = OpTypeVector %54 4 %56 = OpTypePointer Private %55 %57 = OpVariable %56 Private %59 = OpTypeVector %54 3 %60 = OpTypeMatrix %59 2 %61 = OpTypePointer Private %60 %62 = OpVariable %61 Private %64 = OpTypePointer Private %54 %69 = OpConstant %54 2 %71 = OpConstant %6 1 %72 = OpConstant %6 2 %201 = OpConstant %15 2 %73 = OpConstant %6 3 %202 = OpConstant %15 3 %203 = OpConstant %6 1 %204 = OpConstant %6 9 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %12 = OpFunction %2 None %8 %9 = OpFunctionParameter %7 %10 = OpFunctionParameter %102 %11 = OpFunctionParameter %7 %13 = OpLabel %14 = OpVariable %7 Function %27 = OpVariable %26 Function %22 = OpLoad %6 %11 %24 = OpAccessChain %23 %20 %21 %22 %25 = OpLoad %6 %24 OpStore %14 %25 %28 = OpLoad %15 %10 %30 = OpAccessChain %29 %20 %28 %31 = OpLoad %17 %30 OpStore %27 %31 %32 = OpLoad %6 %9 %34 = OpInBoundsAccessChain %7 %27 %32 OpStore %34 %33 %39 = OpLoad %6 %9 %40 = OpAccessChain %23 %38 %33 %41 = OpLoad %6 %40 %42 = OpInBoundsAccessChain %23 %38 %39 OpStore %42 %41 %43 = OpLoad %15 %10 %44 = OpLoad %6 %11 %45 = OpLoad %6 %9 %46 = OpLoad %15 %10 %47 = OpIAdd %6 %45 %46 %48 = OpAccessChain %23 %38 %47 %49 = OpLoad %6 %48 %50 = OpInBoundsAccessChain %23 %20 %43 %44 %51 = OpLoad %6 %50 %52 = OpIAdd %6 %51 %49 %53 = OpAccessChain %23 %20 %43 %44 OpStore %53 %52 %58 = OpLoad %15 %10 %63 = OpLoad %6 %11 %65 = OpAccessChain %64 %62 %21 %63 %101 = OpAccessChain %64 %62 %45 %46 %66 = OpLoad %54 %65 %67 = OpAccessChain %64 %57 %58 OpStore %67 %66 %68 = OpLoad %6 %9 %70 = OpInBoundsAccessChain %64 %57 %68 OpStore %70 %69 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, added_as_dead_code, context1.get())); std::vector access_chain_clamping_info; access_chain_clamping_info.push_back( MakeAccessClampingInfo(24, {{1001, 2001}, {1002, 2002}})); access_chain_clamping_info.push_back( MakeAccessClampingInfo(30, {{1003, 2003}})); access_chain_clamping_info.push_back( MakeAccessClampingInfo(34, {{1004, 2004}})); access_chain_clamping_info.push_back( MakeAccessClampingInfo(40, {{1005, 2005}})); access_chain_clamping_info.push_back( MakeAccessClampingInfo(42, {{1006, 2006}})); access_chain_clamping_info.push_back( MakeAccessClampingInfo(48, {{1007, 2007}})); access_chain_clamping_info.push_back( MakeAccessClampingInfo(50, {{1008, 2008}, {1009, 2009}})); access_chain_clamping_info.push_back( MakeAccessClampingInfo(53, {{1010, 2010}, {1011, 2011}})); access_chain_clamping_info.push_back( MakeAccessClampingInfo(65, {{1012, 2012}, {1013, 2013}})); access_chain_clamping_info.push_back( MakeAccessClampingInfo(101, {{1014, 2014}, {1015, 2015}})); access_chain_clamping_info.push_back( MakeAccessClampingInfo(67, {{1016, 2016}})); access_chain_clamping_info.push_back( MakeAccessClampingInfo(70, {{1017, 2017}})); TransformationAddFunction add_livesafe_function(instructions, 0, 0, {}, 13, access_chain_clamping_info); ASSERT_TRUE(add_livesafe_function.IsApplicable(context2.get(), transformation_context2)); ApplyAndCheckFreshIds(add_livesafe_function, context2.get(), &transformation_context2); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context2.get(), validator_options, kConsoleMessageConsumer)); // The function should be deemed livesafe ASSERT_TRUE(transformation_context2.GetFactManager()->FunctionIsLivesafe(12)); // All variables/parameters in the function should be deemed irrelevant. ASSERT_TRUE(AllVariablesAndParametersExceptLoopLimiterAreIrrelevant( context2.get(), transformation_context2, 12, 0)); std::string added_as_livesafe_code = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %100 = OpTypeBool %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %15 = OpTypeInt 32 0 %102 = OpTypePointer Function %15 %8 = OpTypeFunction %2 %7 %102 %7 %16 = OpConstant %15 5 %17 = OpTypeArray %6 %16 %18 = OpTypeArray %17 %16 %19 = OpTypePointer Private %18 %20 = OpVariable %19 Private %21 = OpConstant %6 0 %23 = OpTypePointer Private %6 %26 = OpTypePointer Function %17 %29 = OpTypePointer Private %17 %33 = OpConstant %6 4 %200 = OpConstant %15 4 %35 = OpConstant %15 10 %36 = OpTypeArray %6 %35 %37 = OpTypePointer Private %36 %38 = OpVariable %37 Private %54 = OpTypeFloat 32 %55 = OpTypeVector %54 4 %56 = OpTypePointer Private %55 %57 = OpVariable %56 Private %59 = OpTypeVector %54 3 %60 = OpTypeMatrix %59 2 %61 = OpTypePointer Private %60 %62 = OpVariable %61 Private %64 = OpTypePointer Private %54 %69 = OpConstant %54 2 %71 = OpConstant %6 1 %72 = OpConstant %6 2 %201 = OpConstant %15 2 %73 = OpConstant %6 3 %202 = OpConstant %15 3 %203 = OpConstant %6 1 %204 = OpConstant %6 9 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %12 = OpFunction %2 None %8 %9 = OpFunctionParameter %7 %10 = OpFunctionParameter %102 %11 = OpFunctionParameter %7 %13 = OpLabel %14 = OpVariable %7 Function %27 = OpVariable %26 Function %22 = OpLoad %6 %11 %1002 = OpULessThanEqual %100 %22 %33 %2002 = OpSelect %6 %1002 %22 %33 %24 = OpAccessChain %23 %20 %21 %2002 %25 = OpLoad %6 %24 OpStore %14 %25 %28 = OpLoad %15 %10 %1003 = OpULessThanEqual %100 %28 %200 %2003 = OpSelect %15 %1003 %28 %200 %30 = OpAccessChain %29 %20 %2003 %31 = OpLoad %17 %30 OpStore %27 %31 %32 = OpLoad %6 %9 %1004 = OpULessThanEqual %100 %32 %33 %2004 = OpSelect %6 %1004 %32 %33 %34 = OpInBoundsAccessChain %7 %27 %2004 OpStore %34 %33 %39 = OpLoad %6 %9 %40 = OpAccessChain %23 %38 %33 %41 = OpLoad %6 %40 %1006 = OpULessThanEqual %100 %39 %204 %2006 = OpSelect %6 %1006 %39 %204 %42 = OpInBoundsAccessChain %23 %38 %2006 OpStore %42 %41 %43 = OpLoad %15 %10 %44 = OpLoad %6 %11 %45 = OpLoad %6 %9 %46 = OpLoad %15 %10 %47 = OpIAdd %6 %45 %46 %1007 = OpULessThanEqual %100 %47 %204 %2007 = OpSelect %6 %1007 %47 %204 %48 = OpAccessChain %23 %38 %2007 %49 = OpLoad %6 %48 %1008 = OpULessThanEqual %100 %43 %200 %2008 = OpSelect %15 %1008 %43 %200 %1009 = OpULessThanEqual %100 %44 %33 %2009 = OpSelect %6 %1009 %44 %33 %50 = OpInBoundsAccessChain %23 %20 %2008 %2009 %51 = OpLoad %6 %50 %52 = OpIAdd %6 %51 %49 %1010 = OpULessThanEqual %100 %43 %200 %2010 = OpSelect %15 %1010 %43 %200 %1011 = OpULessThanEqual %100 %44 %33 %2011 = OpSelect %6 %1011 %44 %33 %53 = OpAccessChain %23 %20 %2010 %2011 OpStore %53 %52 %58 = OpLoad %15 %10 %63 = OpLoad %6 %11 %1013 = OpULessThanEqual %100 %63 %72 %2013 = OpSelect %6 %1013 %63 %72 %65 = OpAccessChain %64 %62 %21 %2013 %1014 = OpULessThanEqual %100 %45 %71 %2014 = OpSelect %6 %1014 %45 %71 %1015 = OpULessThanEqual %100 %46 %201 %2015 = OpSelect %15 %1015 %46 %201 %101 = OpAccessChain %64 %62 %2014 %2015 %66 = OpLoad %54 %65 %1016 = OpULessThanEqual %100 %58 %202 %2016 = OpSelect %15 %1016 %58 %202 %67 = OpAccessChain %64 %57 %2016 OpStore %67 %66 %68 = OpLoad %6 %9 %1017 = OpULessThanEqual %100 %68 %73 %2017 = OpSelect %6 %1017 %68 %73 %70 = OpInBoundsAccessChain %64 %57 %2017 OpStore %70 %69 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, added_as_livesafe_code, context2.get())); } TEST(TransformationAddFunctionTest, LivesafeCanCallLivesafe) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; std::vector instructions; instructions.push_back( MakeInstructionMessage(spv::Op::OpFunction, 2, 8, {{SPV_OPERAND_TYPE_FUNCTION_CONTROL, {uint32_t(spv::FunctionControlMask::MaskNone)}}, {SPV_OPERAND_TYPE_TYPE_ID, {3}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLabel, 0, 9, {})); instructions.push_back(MakeInstructionMessage(spv::Op::OpFunctionCall, 2, 11, {{SPV_OPERAND_TYPE_ID, {6}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpReturn, 0, 0, {})); instructions.push_back( MakeInstructionMessage(spv::Op::OpFunctionEnd, 0, 0, {})); spvtools::ValidatorOptions validator_options; const auto context1 = BuildModule(env, consumer, shader, kFuzzAssembleOption); const auto context2 = BuildModule(env, consumer, shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context1.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context1( MakeUnique(context1.get()), validator_options); TransformationContext transformation_context2( MakeUnique(context2.get()), validator_options); // Mark function 6 as livesafe. transformation_context2.GetFactManager()->AddFactFunctionIsLivesafe(6); TransformationAddFunction add_dead_function(instructions); ASSERT_TRUE( add_dead_function.IsApplicable(context1.get(), transformation_context1)); ApplyAndCheckFreshIds(add_dead_function, context1.get(), &transformation_context1); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context1.get(), validator_options, kConsoleMessageConsumer)); // The function should not be deemed livesafe ASSERT_FALSE(transformation_context1.GetFactManager()->FunctionIsLivesafe(8)); // All variables/parameters in the function should be deemed irrelevant. ASSERT_TRUE(AllVariablesAndParametersExceptLoopLimiterAreIrrelevant( context1.get(), transformation_context1, 8, 0)); std::string added_as_live_or_dead_code = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %11 = OpFunctionCall %2 %6 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, added_as_live_or_dead_code, context1.get())); TransformationAddFunction add_livesafe_function(instructions, 0, 0, {}, 0, {}); ASSERT_TRUE(add_livesafe_function.IsApplicable(context2.get(), transformation_context2)); ApplyAndCheckFreshIds(add_livesafe_function, context2.get(), &transformation_context2); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context2.get(), validator_options, kConsoleMessageConsumer)); // The function should be deemed livesafe ASSERT_TRUE(transformation_context2.GetFactManager()->FunctionIsLivesafe(8)); // All variables/parameters in the function should be deemed irrelevant. ASSERT_TRUE(AllVariablesAndParametersExceptLoopLimiterAreIrrelevant( context2.get(), transformation_context2, 8, 0)); ASSERT_TRUE(IsEqual(env, added_as_live_or_dead_code, context2.get())); } TEST(TransformationAddFunctionTest, LivesafeOnlyCallsLivesafe) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel OpKill OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; std::vector instructions; instructions.push_back( MakeInstructionMessage(spv::Op::OpFunction, 2, 8, {{SPV_OPERAND_TYPE_FUNCTION_CONTROL, {uint32_t(spv::FunctionControlMask::MaskNone)}}, {SPV_OPERAND_TYPE_TYPE_ID, {3}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpLabel, 0, 9, {})); instructions.push_back(MakeInstructionMessage(spv::Op::OpFunctionCall, 2, 11, {{SPV_OPERAND_TYPE_ID, {6}}})); instructions.push_back(MakeInstructionMessage(spv::Op::OpReturn, 0, 0, {})); instructions.push_back( MakeInstructionMessage(spv::Op::OpFunctionEnd, 0, 0, {})); spvtools::ValidatorOptions validator_options; const auto context1 = BuildModule(env, consumer, shader, kFuzzAssembleOption); const auto context2 = BuildModule(env, consumer, shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context1.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context1( MakeUnique(context1.get()), validator_options); TransformationContext transformation_context2( MakeUnique(context2.get()), validator_options); TransformationAddFunction add_dead_function(instructions); ASSERT_TRUE( add_dead_function.IsApplicable(context1.get(), transformation_context1)); ApplyAndCheckFreshIds(add_dead_function, context1.get(), &transformation_context1); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context1.get(), validator_options, kConsoleMessageConsumer)); // The function should not be deemed livesafe ASSERT_FALSE(transformation_context1.GetFactManager()->FunctionIsLivesafe(8)); // All variables/parameters in the function should be deemed irrelevant. ASSERT_TRUE(AllVariablesAndParametersExceptLoopLimiterAreIrrelevant( context1.get(), transformation_context1, 8, 0)); std::string added_as_dead_code = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel OpKill OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %11 = OpFunctionCall %2 %6 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, added_as_dead_code, context1.get())); TransformationAddFunction add_livesafe_function(instructions, 0, 0, {}, 0, {}); ASSERT_FALSE(add_livesafe_function.IsApplicable(context2.get(), transformation_context2)); } TEST(TransformationAddFunctionTest, LoopLimitersBackEdgeBlockEndsWithConditional1) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %11 = OpConstant %8 0 %18 = OpConstant %8 10 %19 = OpTypeBool %26 = OpConstantTrue %19 %27 = OpConstantFalse %19 %28 = OpTypeInt 32 0 %29 = OpTypePointer Function %28 %30 = OpConstant %28 0 %31 = OpConstant %28 1 %32 = OpConstant %28 5 %22 = OpConstant %8 1 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; std::string donor = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %11 = OpConstant %8 0 %18 = OpConstant %8 10 %19 = OpTypeBool %26 = OpConstantTrue %19 %27 = OpConstantFalse %19 %28 = OpTypeInt 32 0 %29 = OpTypePointer Function %28 %30 = OpConstant %28 0 %31 = OpConstant %28 1 %32 = OpConstant %28 5 %22 = OpConstant %8 1 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %10 = OpVariable %9 Function OpStore %10 %11 OpBranch %12 %12 = OpLabel OpLoopMerge %14 %15 None OpBranch %15 %15 = OpLabel %17 = OpLoad %8 %10 %20 = OpSLessThan %19 %17 %18 %21 = OpLoad %8 %10 %23 = OpIAdd %8 %21 %22 OpStore %10 %23 OpBranchConditional %20 %12 %14 %14 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Make a sequence of instruction messages corresponding to function %6 in // |donor|. std::vector instructions = GetInstructionsForFunction(env, consumer, donor, 6); protobufs::LoopLimiterInfo loop_limiter_info; loop_limiter_info.set_loop_header_id(12); loop_limiter_info.set_load_id(102); loop_limiter_info.set_increment_id(103); loop_limiter_info.set_compare_id(104); loop_limiter_info.set_logical_op_id(105); TransformationAddFunction add_livesafe_function(instructions, 100, 32, {loop_limiter_info}, 0, {}); ASSERT_TRUE(add_livesafe_function.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(add_livesafe_function, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string expected = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %11 = OpConstant %8 0 %18 = OpConstant %8 10 %19 = OpTypeBool %26 = OpConstantTrue %19 %27 = OpConstantFalse %19 %28 = OpTypeInt 32 0 %29 = OpTypePointer Function %28 %30 = OpConstant %28 0 %31 = OpConstant %28 1 %32 = OpConstant %28 5 %22 = OpConstant %8 1 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %100 = OpVariable %29 Function %30 %10 = OpVariable %9 Function OpStore %10 %11 OpBranch %12 %12 = OpLabel OpLoopMerge %14 %15 None OpBranch %15 %15 = OpLabel %17 = OpLoad %8 %10 %20 = OpSLessThan %19 %17 %18 %21 = OpLoad %8 %10 %23 = OpIAdd %8 %21 %22 OpStore %10 %23 %102 = OpLoad %28 %100 %103 = OpIAdd %28 %102 %31 OpStore %100 %103 %104 = OpULessThan %19 %102 %32 %105 = OpLogicalAnd %19 %20 %104 OpBranchConditional %105 %12 %14 %14 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected, context.get())); } TEST(TransformationAddFunctionTest, LoopLimitersBackEdgeBlockEndsWithConditional2) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %11 = OpConstant %8 0 %18 = OpConstant %8 10 %19 = OpTypeBool %26 = OpConstantTrue %19 %27 = OpConstantFalse %19 %28 = OpTypeInt 32 0 %29 = OpTypePointer Function %28 %30 = OpConstant %28 0 %31 = OpConstant %28 1 %32 = OpConstant %28 5 %22 = OpConstant %8 1 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; std::string donor = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %11 = OpConstant %8 0 %18 = OpConstant %8 10 %19 = OpTypeBool %26 = OpConstantTrue %19 %27 = OpConstantFalse %19 %28 = OpTypeInt 32 0 %29 = OpTypePointer Function %28 %30 = OpConstant %28 0 %31 = OpConstant %28 1 %32 = OpConstant %28 5 %22 = OpConstant %8 1 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %10 = OpVariable %9 Function OpStore %10 %11 OpBranch %12 %12 = OpLabel OpLoopMerge %14 %15 None OpBranch %15 %15 = OpLabel %17 = OpLoad %8 %10 %20 = OpSLessThan %19 %17 %18 %21 = OpLoad %8 %10 %23 = OpIAdd %8 %21 %22 OpStore %10 %23 %50 = OpLogicalNot %19 %20 OpBranchConditional %50 %14 %12 %14 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Make a sequence of instruction messages corresponding to function %6 in // |donor|. std::vector instructions = GetInstructionsForFunction(env, consumer, donor, 6); protobufs::LoopLimiterInfo loop_limiter_info; loop_limiter_info.set_loop_header_id(12); loop_limiter_info.set_load_id(102); loop_limiter_info.set_increment_id(103); loop_limiter_info.set_compare_id(104); loop_limiter_info.set_logical_op_id(105); TransformationAddFunction add_livesafe_function(instructions, 100, 32, {loop_limiter_info}, 0, {}); ASSERT_TRUE(add_livesafe_function.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(add_livesafe_function, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string expected = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %11 = OpConstant %8 0 %18 = OpConstant %8 10 %19 = OpTypeBool %26 = OpConstantTrue %19 %27 = OpConstantFalse %19 %28 = OpTypeInt 32 0 %29 = OpTypePointer Function %28 %30 = OpConstant %28 0 %31 = OpConstant %28 1 %32 = OpConstant %28 5 %22 = OpConstant %8 1 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %100 = OpVariable %29 Function %30 %10 = OpVariable %9 Function OpStore %10 %11 OpBranch %12 %12 = OpLabel OpLoopMerge %14 %15 None OpBranch %15 %15 = OpLabel %17 = OpLoad %8 %10 %20 = OpSLessThan %19 %17 %18 %21 = OpLoad %8 %10 %23 = OpIAdd %8 %21 %22 OpStore %10 %23 %50 = OpLogicalNot %19 %20 %102 = OpLoad %28 %100 %103 = OpIAdd %28 %102 %31 OpStore %100 %103 %104 = OpUGreaterThanEqual %19 %102 %32 %105 = OpLogicalOr %19 %50 %104 OpBranchConditional %105 %14 %12 %14 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected, context.get())); } TEST(TransformationAddFunctionTest, LoopLimitersHeaderIsBackEdgeBlock) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %11 = OpConstant %8 0 %18 = OpConstant %8 10 %19 = OpTypeBool %26 = OpConstantTrue %19 %27 = OpConstantFalse %19 %28 = OpTypeInt 32 0 %29 = OpTypePointer Function %28 %30 = OpConstant %28 0 %31 = OpConstant %28 1 %32 = OpConstant %28 5 %22 = OpConstant %8 1 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; std::string donor = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %11 = OpConstant %8 0 %18 = OpConstant %8 10 %19 = OpTypeBool %26 = OpConstantTrue %19 %27 = OpConstantFalse %19 %28 = OpTypeInt 32 0 %29 = OpTypePointer Function %28 %30 = OpConstant %28 0 %31 = OpConstant %28 1 %32 = OpConstant %28 5 %22 = OpConstant %8 1 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %10 = OpVariable %9 Function OpStore %10 %11 OpBranch %12 %12 = OpLabel %17 = OpLoad %8 %10 %20 = OpSLessThan %19 %17 %18 %21 = OpLoad %8 %10 %23 = OpIAdd %8 %21 %22 OpStore %10 %23 %50 = OpLogicalNot %19 %20 OpLoopMerge %14 %12 None OpBranchConditional %50 %14 %12 %14 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Make a sequence of instruction messages corresponding to function %6 in // |donor|. std::vector instructions = GetInstructionsForFunction(env, consumer, donor, 6); protobufs::LoopLimiterInfo loop_limiter_info; loop_limiter_info.set_loop_header_id(12); loop_limiter_info.set_load_id(102); loop_limiter_info.set_increment_id(103); loop_limiter_info.set_compare_id(104); loop_limiter_info.set_logical_op_id(105); TransformationAddFunction add_livesafe_function(instructions, 100, 32, {loop_limiter_info}, 0, {}); ASSERT_TRUE(add_livesafe_function.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(add_livesafe_function, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string expected = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %11 = OpConstant %8 0 %18 = OpConstant %8 10 %19 = OpTypeBool %26 = OpConstantTrue %19 %27 = OpConstantFalse %19 %28 = OpTypeInt 32 0 %29 = OpTypePointer Function %28 %30 = OpConstant %28 0 %31 = OpConstant %28 1 %32 = OpConstant %28 5 %22 = OpConstant %8 1 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %100 = OpVariable %29 Function %30 %10 = OpVariable %9 Function OpStore %10 %11 OpBranch %12 %12 = OpLabel %17 = OpLoad %8 %10 %20 = OpSLessThan %19 %17 %18 %21 = OpLoad %8 %10 %23 = OpIAdd %8 %21 %22 OpStore %10 %23 %50 = OpLogicalNot %19 %20 %102 = OpLoad %28 %100 %103 = OpIAdd %28 %102 %31 OpStore %100 %103 %104 = OpUGreaterThanEqual %19 %102 %32 %105 = OpLogicalOr %19 %50 %104 OpLoopMerge %14 %12 None OpBranchConditional %105 %14 %12 %14 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected, context.get())); } TEST(TransformationAddFunctionTest, InfiniteLoop) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %11 = OpConstant %8 0 %18 = OpConstant %8 10 %19 = OpTypeBool %26 = OpConstantTrue %19 %27 = OpConstantFalse %19 %28 = OpTypeInt 32 0 %29 = OpTypePointer Function %28 %30 = OpConstant %28 0 %31 = OpConstant %28 1 %32 = OpConstant %28 5 %22 = OpConstant %8 1 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; std::string donor = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %11 = OpConstant %8 0 %18 = OpConstant %8 10 %19 = OpTypeBool %26 = OpConstantTrue %19 %27 = OpConstantFalse %19 %28 = OpTypeInt 32 0 %29 = OpTypePointer Function %28 %30 = OpConstant %28 0 %31 = OpConstant %28 1 %32 = OpConstant %28 5 %22 = OpConstant %8 1 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %10 = OpVariable %9 Function OpStore %10 %11 OpBranch %12 %12 = OpLabel OpLoopMerge %14 %12 None OpBranch %12 %14 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Make a sequence of instruction messages corresponding to function %6 in // |donor|. std::vector instructions = GetInstructionsForFunction(env, consumer, donor, 6); protobufs::LoopLimiterInfo loop_limiter_info; loop_limiter_info.set_loop_header_id(12); loop_limiter_info.set_load_id(102); loop_limiter_info.set_increment_id(103); loop_limiter_info.set_compare_id(104); loop_limiter_info.set_logical_op_id(105); TransformationAddFunction add_livesafe_function(instructions, 100, 32, {loop_limiter_info}, 0, {}); // To make sure the loop's merge block is reachable, it must be dominated by // the loop header. ASSERT_FALSE(add_livesafe_function.IsApplicable(context.get(), transformation_context)); } TEST(TransformationAddFunctionTest, UnreachableContinueConstruct) { // This captures the case where the loop's continue construct is statically // unreachable. In this case the loop cannot iterate and so we do not add // a loop limiter. (The reason we do not just add one anyway is that // detecting which block would be the back-edge block is difficult in the // absence of reliable dominance information.) std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %11 = OpConstant %8 0 %18 = OpConstant %8 10 %19 = OpTypeBool %23 = OpConstant %8 1 %26 = OpConstantTrue %19 %27 = OpConstantFalse %19 %28 = OpTypeInt 32 0 %29 = OpTypePointer Function %28 %30 = OpConstant %28 0 %31 = OpConstant %28 1 %32 = OpConstant %28 5 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; std::string donor = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %11 = OpConstant %8 0 %18 = OpConstant %8 10 %19 = OpTypeBool %23 = OpConstant %8 1 %26 = OpConstantTrue %19 %27 = OpConstantFalse %19 %28 = OpTypeInt 32 0 %29 = OpTypePointer Function %28 %30 = OpConstant %28 0 %31 = OpConstant %28 1 %32 = OpConstant %28 5 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %10 = OpVariable %9 Function OpStore %10 %11 OpBranch %12 %12 = OpLabel OpLoopMerge %14 %15 None OpBranch %16 %16 = OpLabel %17 = OpLoad %8 %10 %20 = OpSLessThan %19 %17 %18 OpBranchConditional %20 %13 %14 %13 = OpLabel OpBranch %14 %15 = OpLabel %22 = OpLoad %8 %10 %24 = OpIAdd %8 %22 %23 OpStore %10 %24 OpBranch %12 %14 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Make a sequence of instruction messages corresponding to function %6 in // |donor|. std::vector instructions = GetInstructionsForFunction(env, consumer, donor, 6); protobufs::LoopLimiterInfo loop_limiter_info; loop_limiter_info.set_loop_header_id(12); loop_limiter_info.set_load_id(102); loop_limiter_info.set_increment_id(103); loop_limiter_info.set_compare_id(104); loop_limiter_info.set_logical_op_id(105); TransformationAddFunction add_livesafe_function(instructions, 100, 32, {loop_limiter_info}, 0, {}); ASSERT_TRUE(add_livesafe_function.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(add_livesafe_function, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string expected = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %11 = OpConstant %8 0 %18 = OpConstant %8 10 %19 = OpTypeBool %23 = OpConstant %8 1 %26 = OpConstantTrue %19 %27 = OpConstantFalse %19 %28 = OpTypeInt 32 0 %29 = OpTypePointer Function %28 %30 = OpConstant %28 0 %31 = OpConstant %28 1 %32 = OpConstant %28 5 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %100 = OpVariable %29 Function %30 %10 = OpVariable %9 Function OpStore %10 %11 OpBranch %12 %12 = OpLabel OpLoopMerge %14 %15 None OpBranch %16 %16 = OpLabel %17 = OpLoad %8 %10 %20 = OpSLessThan %19 %17 %18 OpBranchConditional %20 %13 %14 %13 = OpLabel OpBranch %14 %15 = OpLabel %22 = OpLoad %8 %10 %24 = OpIAdd %8 %22 %23 OpStore %10 %24 OpBranch %12 %14 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected, context.get())); } TEST(TransformationAddFunctionTest, LoopLimitersAndOpPhi1) { // This captures the scenario where breaking a loop due to a loop limiter // requires patching up OpPhi instructions occurring at the loop merge block. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %50 = OpTypeInt 32 0 %51 = OpConstant %50 0 %52 = OpConstant %50 1 %53 = OpTypePointer Function %50 %7 = OpTypeFunction %6 %10 = OpTypePointer Function %6 %12 = OpConstant %6 0 %19 = OpConstant %6 100 %20 = OpTypeBool %23 = OpConstant %6 20 %28 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; std::string donor = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeFunction %6 %10 = OpTypePointer Function %6 %12 = OpConstant %6 0 %19 = OpConstant %6 100 %20 = OpTypeBool %23 = OpConstant %6 20 %28 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %36 = OpFunctionCall %6 %8 OpReturn OpFunctionEnd %8 = OpFunction %6 None %7 %9 = OpLabel %11 = OpVariable %10 Function OpStore %11 %12 OpBranch %13 %13 = OpLabel %37 = OpPhi %6 %12 %9 %32 %16 OpLoopMerge %15 %16 None OpBranch %17 %17 = OpLabel %21 = OpSLessThan %20 %37 %19 OpBranchConditional %21 %14 %15 %14 = OpLabel %24 = OpSGreaterThan %20 %37 %23 OpSelectionMerge %26 None OpBranchConditional %24 %25 %26 %25 = OpLabel %29 = OpIAdd %6 %37 %28 OpStore %11 %29 OpBranch %15 %26 = OpLabel OpBranch %16 %16 = OpLabel %32 = OpIAdd %6 %37 %28 OpStore %11 %32 OpBranch %13 %15 = OpLabel %38 = OpPhi %6 %37 %17 %29 %25 OpReturnValue %38 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Make a sequence of instruction messages corresponding to function %8 in // |donor|. std::vector instructions = GetInstructionsForFunction(env, consumer, donor, 8); protobufs::LoopLimiterInfo loop_limiter_info; loop_limiter_info.set_loop_header_id(13); loop_limiter_info.set_load_id(102); loop_limiter_info.set_increment_id(103); loop_limiter_info.set_compare_id(104); loop_limiter_info.set_logical_op_id(105); TransformationAddFunction no_op_phi_data(instructions, 100, 28, {loop_limiter_info}, 0, {}); // The loop limiter info is not good enough; it does not include ids to patch // up the OpPhi at the loop merge. ASSERT_FALSE( no_op_phi_data.IsApplicable(context.get(), transformation_context)); // Add a phi id for the new edge from the loop back edge block to the loop // merge. loop_limiter_info.add_phi_id(28); TransformationAddFunction with_op_phi_data(instructions, 100, 28, {loop_limiter_info}, 0, {}); ASSERT_TRUE( with_op_phi_data.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(with_op_phi_data, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string expected = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %50 = OpTypeInt 32 0 %51 = OpConstant %50 0 %52 = OpConstant %50 1 %53 = OpTypePointer Function %50 %7 = OpTypeFunction %6 %10 = OpTypePointer Function %6 %12 = OpConstant %6 0 %19 = OpConstant %6 100 %20 = OpTypeBool %23 = OpConstant %6 20 %28 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %8 = OpFunction %6 None %7 %9 = OpLabel %100 = OpVariable %53 Function %51 %11 = OpVariable %10 Function OpStore %11 %12 OpBranch %13 %13 = OpLabel %37 = OpPhi %6 %12 %9 %32 %16 OpLoopMerge %15 %16 None OpBranch %17 %17 = OpLabel %21 = OpSLessThan %20 %37 %19 OpBranchConditional %21 %14 %15 %14 = OpLabel %24 = OpSGreaterThan %20 %37 %23 OpSelectionMerge %26 None OpBranchConditional %24 %25 %26 %25 = OpLabel %29 = OpIAdd %6 %37 %28 OpStore %11 %29 OpBranch %15 %26 = OpLabel OpBranch %16 %16 = OpLabel %32 = OpIAdd %6 %37 %28 OpStore %11 %32 %102 = OpLoad %50 %100 %103 = OpIAdd %50 %102 %52 OpStore %100 %103 %104 = OpUGreaterThanEqual %20 %102 %28 OpBranchConditional %104 %15 %13 %15 = OpLabel %38 = OpPhi %6 %37 %17 %29 %25 %28 %16 OpReturnValue %38 OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected, context.get())); } TEST(TransformationAddFunctionTest, LoopLimitersAndOpPhi2) { // This captures the scenario where the loop merge block already has an OpPhi // with the loop back edge block as a predecessor. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %50 = OpTypeInt 32 0 %51 = OpConstant %50 0 %52 = OpConstant %50 1 %53 = OpTypePointer Function %50 %7 = OpTypeFunction %6 %10 = OpTypePointer Function %6 %12 = OpConstant %6 0 %19 = OpConstant %6 100 %20 = OpTypeBool %60 = OpConstantTrue %20 %23 = OpConstant %6 20 %28 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; std::string donor = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %50 = OpTypeInt 32 0 %51 = OpConstant %50 0 %52 = OpConstant %50 1 %53 = OpTypePointer Function %50 %7 = OpTypeFunction %6 %10 = OpTypePointer Function %6 %12 = OpConstant %6 0 %19 = OpConstant %6 100 %20 = OpTypeBool %60 = OpConstantTrue %20 %23 = OpConstant %6 20 %28 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %8 = OpFunction %6 None %7 %9 = OpLabel %11 = OpVariable %10 Function OpStore %11 %12 OpBranch %13 %13 = OpLabel %37 = OpPhi %6 %12 %9 %32 %16 OpLoopMerge %15 %16 None OpBranch %17 %17 = OpLabel %21 = OpSLessThan %20 %37 %19 OpBranchConditional %21 %14 %15 %14 = OpLabel %24 = OpSGreaterThan %20 %37 %23 OpSelectionMerge %26 None OpBranchConditional %24 %25 %26 %25 = OpLabel %29 = OpIAdd %6 %37 %28 OpStore %11 %29 OpBranch %15 %26 = OpLabel OpBranch %16 %16 = OpLabel %32 = OpIAdd %6 %37 %28 OpStore %11 %32 OpBranchConditional %60 %15 %13 %15 = OpLabel %38 = OpPhi %6 %37 %17 %29 %25 %23 %16 OpReturnValue %38 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Make a sequence of instruction messages corresponding to function %8 in // |donor|. std::vector instructions = GetInstructionsForFunction(env, consumer, donor, 8); protobufs::LoopLimiterInfo loop_limiter_info; loop_limiter_info.set_loop_header_id(13); loop_limiter_info.set_load_id(102); loop_limiter_info.set_increment_id(103); loop_limiter_info.set_compare_id(104); loop_limiter_info.set_logical_op_id(105); TransformationAddFunction transformation(instructions, 100, 28, {loop_limiter_info}, 0, {}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string expected = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %50 = OpTypeInt 32 0 %51 = OpConstant %50 0 %52 = OpConstant %50 1 %53 = OpTypePointer Function %50 %7 = OpTypeFunction %6 %10 = OpTypePointer Function %6 %12 = OpConstant %6 0 %19 = OpConstant %6 100 %20 = OpTypeBool %60 = OpConstantTrue %20 %23 = OpConstant %6 20 %28 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %8 = OpFunction %6 None %7 %9 = OpLabel %100 = OpVariable %53 Function %51 %11 = OpVariable %10 Function OpStore %11 %12 OpBranch %13 %13 = OpLabel %37 = OpPhi %6 %12 %9 %32 %16 OpLoopMerge %15 %16 None OpBranch %17 %17 = OpLabel %21 = OpSLessThan %20 %37 %19 OpBranchConditional %21 %14 %15 %14 = OpLabel %24 = OpSGreaterThan %20 %37 %23 OpSelectionMerge %26 None OpBranchConditional %24 %25 %26 %25 = OpLabel %29 = OpIAdd %6 %37 %28 OpStore %11 %29 OpBranch %15 %26 = OpLabel OpBranch %16 %16 = OpLabel %32 = OpIAdd %6 %37 %28 OpStore %11 %32 %102 = OpLoad %50 %100 %103 = OpIAdd %50 %102 %52 OpStore %100 %103 %104 = OpUGreaterThanEqual %20 %102 %28 %105 = OpLogicalOr %20 %60 %104 OpBranchConditional %105 %15 %13 %15 = OpLabel %38 = OpPhi %6 %37 %17 %29 %25 %23 %16 OpReturnValue %38 OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected, context.get())); } TEST(TransformationAddFunctionTest, StaticallyOutOfBoundsArrayAccess) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeInt 32 1 %9 = OpTypeInt 32 0 %10 = OpConstant %9 3 %11 = OpTypeArray %8 %10 %12 = OpTypePointer Private %11 %13 = OpVariable %12 Private %14 = OpConstant %8 3 %20 = OpConstant %8 2 %15 = OpConstant %8 1 %21 = OpTypeBool %16 = OpTypePointer Private %8 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; std::string donor = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeInt 32 1 %9 = OpTypeInt 32 0 %10 = OpConstant %9 3 %11 = OpTypeArray %8 %10 %12 = OpTypePointer Private %11 %13 = OpVariable %12 Private %14 = OpConstant %8 3 %15 = OpConstant %8 1 %16 = OpTypePointer Private %8 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %17 = OpAccessChain %16 %13 %14 OpStore %17 %15 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Make a sequence of instruction messages corresponding to function %6 in // |donor|. std::vector instructions = GetInstructionsForFunction(env, consumer, donor, 6); TransformationAddFunction add_livesafe_function( instructions, 0, 0, {}, 0, {MakeAccessClampingInfo(17, {{100, 101}})}); ASSERT_TRUE(add_livesafe_function.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(add_livesafe_function, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string expected = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeInt 32 1 %9 = OpTypeInt 32 0 %10 = OpConstant %9 3 %11 = OpTypeArray %8 %10 %12 = OpTypePointer Private %11 %13 = OpVariable %12 Private %14 = OpConstant %8 3 %20 = OpConstant %8 2 %15 = OpConstant %8 1 %21 = OpTypeBool %16 = OpTypePointer Private %8 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %100 = OpULessThanEqual %21 %14 %20 %101 = OpSelect %8 %100 %14 %20 %17 = OpAccessChain %16 %13 %101 OpStore %17 %15 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_add_global_undef_test.cpp000066400000000000000000000110341475742701700306270ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_global_undef.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationAddGlobalUndefTest, BasicTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeInt 32 1 %8 = OpTypeVector %6 2 %9 = OpTypeVector %6 3 %10 = OpTypeVector %6 4 %11 = OpTypeVector %7 2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Id already in use ASSERT_FALSE(TransformationAddGlobalUndef(4, 11).IsApplicable( context.get(), transformation_context)); // %1 is not a type ASSERT_FALSE(TransformationAddGlobalUndef(100, 1).IsApplicable( context.get(), transformation_context)); // %3 is a function type ASSERT_FALSE(TransformationAddGlobalUndef(100, 3).IsApplicable( context.get(), transformation_context)); { // %100 = OpUndef %6 TransformationAddGlobalUndef transformation(100, 6); ASSERT_EQ(nullptr, context->get_def_use_mgr()->GetDef(100)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_EQ(spv::Op::OpUndef, context->get_def_use_mgr()->GetDef(100)->opcode()); } TransformationAddGlobalUndef transformations[] = { // %101 = OpUndef %7 TransformationAddGlobalUndef(101, 7), // %102 = OpUndef %8 TransformationAddGlobalUndef(102, 8), // %103 = OpUndef %9 TransformationAddGlobalUndef(103, 9), // %104 = OpUndef %10 TransformationAddGlobalUndef(104, 10), // %105 = OpUndef %11 TransformationAddGlobalUndef(105, 11)}; for (auto& transformation : transformations) { ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeInt 32 1 %8 = OpTypeVector %6 2 %9 = OpTypeVector %6 3 %10 = OpTypeVector %6 4 %11 = OpTypeVector %7 2 %100 = OpUndef %6 %101 = OpUndef %7 %102 = OpUndef %8 %103 = OpUndef %9 %104 = OpUndef %10 %105 = OpUndef %11 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_add_global_variable_test.cpp000066400000000000000000000523031475742701700313170ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_global_variable.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationAddGlobalVariableTest, BasicTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %40 = OpConstant %6 0 %7 = OpTypeInt 32 1 %8 = OpTypeVector %6 2 %41 = OpConstantComposite %8 %40 %40 %9 = OpTypePointer Function %6 %10 = OpTypePointer Private %6 %20 = OpTypePointer Uniform %6 %11 = OpTypePointer Function %7 %12 = OpTypePointer Private %7 %13 = OpTypePointer Private %8 %14 = OpVariable %10 Private %15 = OpVariable %20 Uniform %16 = OpConstant %7 1 %17 = OpTypePointer Private %10 %18 = OpTypeBool %19 = OpTypePointer Private %18 %21 = OpConstantTrue %18 %22 = OpConstantFalse %18 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Id already in use ASSERT_FALSE(TransformationAddGlobalVariable( 4, 10, spv::StorageClass::Private, 0, true) .IsApplicable(context.get(), transformation_context)); // %1 is not a type ASSERT_FALSE(TransformationAddGlobalVariable( 100, 1, spv::StorageClass::Private, 0, false) .IsApplicable(context.get(), transformation_context)); // %7 is not a pointer type ASSERT_FALSE(TransformationAddGlobalVariable( 100, 7, spv::StorageClass::Private, 0, true) .IsApplicable(context.get(), transformation_context)); // %9 does not have Private storage class ASSERT_FALSE(TransformationAddGlobalVariable( 100, 9, spv::StorageClass::Private, 0, false) .IsApplicable(context.get(), transformation_context)); // %15 does not have Private storage class ASSERT_FALSE(TransformationAddGlobalVariable( 100, 15, spv::StorageClass::Private, 0, true) .IsApplicable(context.get(), transformation_context)); // %10 is a pointer to float, while %16 is an int constant ASSERT_FALSE(TransformationAddGlobalVariable( 100, 10, spv::StorageClass::Private, 16, false) .IsApplicable(context.get(), transformation_context)); // %10 is a Private pointer to float, while %15 is a variable with type // Uniform float pointer ASSERT_FALSE(TransformationAddGlobalVariable( 100, 10, spv::StorageClass::Private, 15, true) .IsApplicable(context.get(), transformation_context)); // %12 is a Private pointer to int, while %10 is a variable with type // Private float pointer ASSERT_FALSE(TransformationAddGlobalVariable( 100, 12, spv::StorageClass::Private, 10, false) .IsApplicable(context.get(), transformation_context)); // %10 is pointer-to-float, and %14 has type pointer-to-float; that's not OK // since the initializer's type should be the *pointee* type. ASSERT_FALSE(TransformationAddGlobalVariable( 104, 10, spv::StorageClass::Private, 14, true) .IsApplicable(context.get(), transformation_context)); // This would work in principle, but logical addressing does not allow // a pointer to a pointer. ASSERT_FALSE(TransformationAddGlobalVariable( 104, 17, spv::StorageClass::Private, 14, false) .IsApplicable(context.get(), transformation_context)); { // %100 = OpVariable %12 Private ASSERT_EQ(nullptr, context->get_def_use_mgr()->GetDef(100)); TransformationAddGlobalVariable transformation( 100, 12, spv::StorageClass::Private, 16, true); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_EQ(spv::Op::OpVariable, context->get_def_use_mgr()->GetDef(100)->opcode()); ASSERT_EQ( spv::StorageClass::Private, static_cast( context->get_def_use_mgr()->GetDef(100)->GetSingleWordInOperand( 0))); } TransformationAddGlobalVariable transformations[] = { // %101 = OpVariable %10 Private TransformationAddGlobalVariable(101, 10, spv::StorageClass::Private, 40, false), // %102 = OpVariable %13 Private TransformationAddGlobalVariable(102, 13, spv::StorageClass::Private, 41, true), // %103 = OpVariable %12 Private %16 TransformationAddGlobalVariable(103, 12, spv::StorageClass::Private, 16, false), // %104 = OpVariable %19 Private %21 TransformationAddGlobalVariable(104, 19, spv::StorageClass::Private, 21, true), // %105 = OpVariable %19 Private %22 TransformationAddGlobalVariable(105, 19, spv::StorageClass::Private, 22, false)}; for (auto& transformation : transformations) { ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } ASSERT_TRUE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(100)); ASSERT_TRUE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(102)); ASSERT_TRUE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(104)); ASSERT_FALSE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(101)); ASSERT_FALSE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(103)); ASSERT_FALSE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(105)); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %40 = OpConstant %6 0 %7 = OpTypeInt 32 1 %8 = OpTypeVector %6 2 %41 = OpConstantComposite %8 %40 %40 %9 = OpTypePointer Function %6 %10 = OpTypePointer Private %6 %20 = OpTypePointer Uniform %6 %11 = OpTypePointer Function %7 %12 = OpTypePointer Private %7 %13 = OpTypePointer Private %8 %14 = OpVariable %10 Private %15 = OpVariable %20 Uniform %16 = OpConstant %7 1 %17 = OpTypePointer Private %10 %18 = OpTypeBool %19 = OpTypePointer Private %18 %21 = OpConstantTrue %18 %22 = OpConstantFalse %18 %100 = OpVariable %12 Private %16 %101 = OpVariable %10 Private %40 %102 = OpVariable %13 Private %41 %103 = OpVariable %12 Private %16 %104 = OpVariable %19 Private %21 %105 = OpVariable %19 Private %22 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationAddGlobalVariableTest, TestEntryPointInterfaceEnlargement) { // This checks that when global variables are added to a SPIR-V 1.4+ module, // they are also added to entry points of that module. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "m1" OpEntryPoint Vertex %5 "m2" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeInt 32 1 %8 = OpTypeVector %6 2 %9 = OpTypePointer Function %6 %10 = OpTypePointer Private %6 %11 = OpTypePointer Function %7 %12 = OpTypePointer Private %7 %13 = OpTypePointer Private %8 %14 = OpVariable %10 Private %16 = OpConstant %7 1 %17 = OpTypePointer Private %10 %18 = OpTypeBool %19 = OpTypePointer Private %18 %21 = OpConstantTrue %18 %4 = OpFunction %2 None %3 %30 = OpLabel OpReturn OpFunctionEnd %5 = OpFunction %2 None %3 %31 = OpLabel OpReturn OpFunctionEnd )"; for (auto env : {SPV_ENV_UNIVERSAL_1_4, SPV_ENV_UNIVERSAL_1_5, SPV_ENV_VULKAN_1_1_SPIRV_1_4, SPV_ENV_VULKAN_1_2}) { const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationAddGlobalVariable transformations[] = { // %100 = OpVariable %12 Private TransformationAddGlobalVariable(100, 12, spv::StorageClass::Private, 16, true), // %101 = OpVariable %12 Private %16 TransformationAddGlobalVariable(101, 12, spv::StorageClass::Private, 16, false), // %102 = OpVariable %19 Private %21 TransformationAddGlobalVariable(102, 19, spv::StorageClass::Private, 21, true)}; for (auto& transformation : transformations) { ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } ASSERT_TRUE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(100)); ASSERT_TRUE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(102)); ASSERT_FALSE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(101)); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation_enlarged_interface = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "m1" %100 %101 %102 OpEntryPoint Vertex %5 "m2" %100 %101 %102 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeInt 32 1 %8 = OpTypeVector %6 2 %9 = OpTypePointer Function %6 %10 = OpTypePointer Private %6 %11 = OpTypePointer Function %7 %12 = OpTypePointer Private %7 %13 = OpTypePointer Private %8 %14 = OpVariable %10 Private %16 = OpConstant %7 1 %17 = OpTypePointer Private %10 %18 = OpTypeBool %19 = OpTypePointer Private %18 %21 = OpConstantTrue %18 %100 = OpVariable %12 Private %16 %101 = OpVariable %12 Private %16 %102 = OpVariable %19 Private %21 %4 = OpFunction %2 None %3 %30 = OpLabel OpReturn OpFunctionEnd %5 = OpFunction %2 None %3 %31 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE( IsEqual(env, after_transformation_enlarged_interface, context.get())); } } TEST(TransformationAddGlobalVariableTest, TestEntryPointInterfaceNoEnlargement) { // This checks that when global variables are added to a SPIR-V 1.3- module, // they are not added to entry points of that module. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "m1" OpEntryPoint Vertex %5 "m2" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeInt 32 1 %8 = OpTypeVector %6 2 %9 = OpTypePointer Function %6 %10 = OpTypePointer Private %6 %11 = OpTypePointer Function %7 %12 = OpTypePointer Private %7 %13 = OpTypePointer Private %8 %14 = OpVariable %10 Private %16 = OpConstant %7 1 %17 = OpTypePointer Private %10 %18 = OpTypeBool %19 = OpTypePointer Private %18 %21 = OpConstantTrue %18 %4 = OpFunction %2 None %3 %30 = OpLabel OpReturn OpFunctionEnd %5 = OpFunction %2 None %3 %31 = OpLabel OpReturn OpFunctionEnd )"; for (auto env : {SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1, SPV_ENV_UNIVERSAL_1_2, SPV_ENV_UNIVERSAL_1_3, SPV_ENV_VULKAN_1_0, SPV_ENV_VULKAN_1_1}) { const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationAddGlobalVariable transformations[] = { // %100 = OpVariable %12 Private TransformationAddGlobalVariable(100, 12, spv::StorageClass::Private, 16, true), // %101 = OpVariable %12 Private %16 TransformationAddGlobalVariable(101, 12, spv::StorageClass::Private, 16, false), // %102 = OpVariable %19 Private %21 TransformationAddGlobalVariable(102, 19, spv::StorageClass::Private, 21, true)}; for (auto& transformation : transformations) { ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } ASSERT_TRUE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(100)); ASSERT_TRUE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(102)); ASSERT_FALSE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(101)); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation_fixed_interface = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "m1" OpEntryPoint Vertex %5 "m2" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeInt 32 1 %8 = OpTypeVector %6 2 %9 = OpTypePointer Function %6 %10 = OpTypePointer Private %6 %11 = OpTypePointer Function %7 %12 = OpTypePointer Private %7 %13 = OpTypePointer Private %8 %14 = OpVariable %10 Private %16 = OpConstant %7 1 %17 = OpTypePointer Private %10 %18 = OpTypeBool %19 = OpTypePointer Private %18 %21 = OpConstantTrue %18 %100 = OpVariable %12 Private %16 %101 = OpVariable %12 Private %16 %102 = OpVariable %19 Private %21 %4 = OpFunction %2 None %3 %30 = OpLabel OpReturn OpFunctionEnd %5 = OpFunction %2 None %3 %31 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE( IsEqual(env, after_transformation_fixed_interface, context.get())); } } TEST(TransformationAddGlobalVariableTest, TestAddingWorkgroupGlobals) { // This checks that workgroup globals can be added to a compute shader. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Workgroup %6 %50 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); #ifndef NDEBUG ASSERT_DEATH( TransformationAddGlobalVariable(8, 7, spv::StorageClass::Workgroup, 50, true) .IsApplicable(context.get(), transformation_context), "By construction this transformation should not have an.*initializer " "when Workgroup storage class is used"); #endif TransformationAddGlobalVariable transformations[] = { // %8 = OpVariable %7 Workgroup TransformationAddGlobalVariable(8, 7, spv::StorageClass::Workgroup, 0, true), // %10 = OpVariable %7 Workgroup TransformationAddGlobalVariable(10, 7, spv::StorageClass::Workgroup, 0, false)}; for (auto& transformation : transformations) { ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } ASSERT_TRUE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(8)); ASSERT_FALSE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(10)); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" %8 %10 OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Workgroup %6 %50 = OpConstant %6 2 %8 = OpVariable %7 Workgroup %10 = OpVariable %7 Workgroup %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools transformation_add_image_sample_unused_components_test.cpp000066400000000000000000000236111475742701700344060ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/fuzz// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_image_sample_unused_components.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationAddImageSampleUnusedComponentsTest, IsApplicable) { std::string shader = R"( OpCapability Shader OpCapability LiteralSampler %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %18 "main" %17 OpExecutionMode %18 OriginUpperLeft OpSource ESSL 310 OpName %18 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeFloat 32 %5 = OpTypeVector %4 2 %6 = OpTypeVector %4 3 %7 = OpTypeVector %4 4 %8 = OpTypeImage %4 2D 0 0 0 1 Rgba32f %9 = OpTypePointer Image %8 %10 = OpTypeSampledImage %8 %11 = OpTypeSampler %12 = OpConstant %4 1 %13 = OpConstant %4 2 %14 = OpConstant %4 3 %15 = OpConstant %4 4 %16 = OpConstantSampler %11 None 0 Linear %17 = OpVariable %9 Image %18 = OpFunction %2 None %3 %19 = OpLabel %20 = OpLoad %8 %17 %21 = OpSampledImage %10 %20 %16 %22 = OpCompositeConstruct %5 %12 %13 %23 = OpCompositeConstruct %6 %22 %14 %24 = OpCompositeConstruct %7 %23 %15 %25 = OpImageSampleImplicitLod %7 %21 %22 %26 = OpImageSampleExplicitLod %7 %21 %23 Lod %12 %27 = OpImageSampleExplicitLod %7 %21 %24 Lod %12 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Tests applicable image instruction. auto instruction_descriptor = MakeInstructionDescriptor(25, spv::Op::OpImageSampleImplicitLod, 0); auto transformation = TransformationAddImageSampleUnusedComponents(23, instruction_descriptor); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); instruction_descriptor = MakeInstructionDescriptor(26, spv::Op::OpImageSampleExplicitLod, 0); transformation = TransformationAddImageSampleUnusedComponents(24, instruction_descriptor); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); // Tests undefined image instructions. instruction_descriptor = MakeInstructionDescriptor(27, spv::Op::OpImageSampleImplicitLod, 0); transformation = TransformationAddImageSampleUnusedComponents(23, instruction_descriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); instruction_descriptor = MakeInstructionDescriptor(28, spv::Op::OpImageSampleExplicitLod, 0); transformation = TransformationAddImageSampleUnusedComponents(23, instruction_descriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests non-image instructions. instruction_descriptor = MakeInstructionDescriptor(19, spv::Op::OpLabel, 0); transformation = TransformationAddImageSampleUnusedComponents(24, instruction_descriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); instruction_descriptor = MakeInstructionDescriptor(20, spv::Op::OpLoad, 0); transformation = TransformationAddImageSampleUnusedComponents(24, instruction_descriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests coordinate operand being a vec4. instruction_descriptor = MakeInstructionDescriptor(27, spv::Op::OpImageSampleExplicitLod, 0); transformation = TransformationAddImageSampleUnusedComponents(22, instruction_descriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests undefined coordinate with unused operands. instruction_descriptor = MakeInstructionDescriptor(25, spv::Op::OpImageSampleImplicitLod, 0); transformation = TransformationAddImageSampleUnusedComponents(27, instruction_descriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests coordinate with unused operands being a non-OpCompositeConstruct // instruction. instruction_descriptor = MakeInstructionDescriptor(25, spv::Op::OpImageSampleImplicitLod, 0); transformation = TransformationAddImageSampleUnusedComponents(21, instruction_descriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests the first OpCompositeConstruct constituent not being the original // coordinate. instruction_descriptor = MakeInstructionDescriptor(25, spv::Op::OpImageSampleImplicitLod, 0); transformation = TransformationAddImageSampleUnusedComponents(22, instruction_descriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationAddImageSampleUnusedComponentsTest, Apply) { std::string reference_shader = R"( OpCapability Shader OpCapability LiteralSampler %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %18 "main" %17 OpExecutionMode %18 OriginUpperLeft OpSource ESSL 310 OpName %18 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeFloat 32 %5 = OpTypeVector %4 2 %6 = OpTypeVector %4 3 %7 = OpTypeVector %4 4 %8 = OpTypeImage %4 2D 0 0 0 1 Rgba32f %9 = OpTypePointer Image %8 %10 = OpTypeSampledImage %8 %11 = OpTypeSampler %12 = OpConstant %4 1 %13 = OpConstant %4 2 %14 = OpConstant %4 3 %15 = OpConstant %4 4 %16 = OpConstantSampler %11 None 0 Linear %17 = OpVariable %9 Image %18 = OpFunction %2 None %3 %19 = OpLabel %20 = OpLoad %8 %17 %21 = OpSampledImage %10 %20 %16 %22 = OpCompositeConstruct %5 %12 %13 %23 = OpCompositeConstruct %6 %22 %14 %24 = OpCompositeConstruct %7 %23 %15 %25 = OpImageSampleImplicitLod %7 %21 %22 %26 = OpImageSampleExplicitLod %7 %21 %23 Lod %12 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto instruction_descriptor = MakeInstructionDescriptor(25, spv::Op::OpImageSampleImplicitLod, 0); auto transformation = TransformationAddImageSampleUnusedComponents(23, instruction_descriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); instruction_descriptor = MakeInstructionDescriptor(26, spv::Op::OpImageSampleExplicitLod, 0); transformation = TransformationAddImageSampleUnusedComponents(24, instruction_descriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); std::string variant_shader = R"( OpCapability Shader OpCapability LiteralSampler %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %18 "main" %17 OpExecutionMode %18 OriginUpperLeft OpSource ESSL 310 OpName %18 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeFloat 32 %5 = OpTypeVector %4 2 %6 = OpTypeVector %4 3 %7 = OpTypeVector %4 4 %8 = OpTypeImage %4 2D 0 0 0 1 Rgba32f %9 = OpTypePointer Image %8 %10 = OpTypeSampledImage %8 %11 = OpTypeSampler %12 = OpConstant %4 1 %13 = OpConstant %4 2 %14 = OpConstant %4 3 %15 = OpConstant %4 4 %16 = OpConstantSampler %11 None 0 Linear %17 = OpVariable %9 Image %18 = OpFunction %2 None %3 %19 = OpLabel %20 = OpLoad %8 %17 %21 = OpSampledImage %10 %20 %16 %22 = OpCompositeConstruct %5 %12 %13 %23 = OpCompositeConstruct %6 %22 %14 %24 = OpCompositeConstruct %7 %23 %15 %25 = OpImageSampleImplicitLod %7 %21 %23 %26 = OpImageSampleExplicitLod %7 %21 %24 Lod %12 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, variant_shader, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_add_local_variable_test.cpp000066400000000000000000000214241475742701700311510ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_local_variable.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationAddLocalVariableTest, BasicTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeStruct %6 %6 %8 = OpTypePointer Function %7 %10 = OpConstant %6 1 %11 = OpConstant %6 2 %12 = OpConstantComposite %7 %10 %11 %13 = OpTypeFloat 32 %14 = OpTypeInt 32 0 %15 = OpConstant %14 3 %16 = OpTypeArray %13 %15 %17 = OpTypeBool %18 = OpTypeStruct %16 %7 %17 %19 = OpTypePointer Function %18 %21 = OpConstant %13 1 %22 = OpConstant %13 2 %23 = OpConstant %13 4 %24 = OpConstantComposite %16 %21 %22 %23 %25 = OpConstant %6 5 %26 = OpConstant %6 6 %27 = OpConstantComposite %7 %25 %26 %28 = OpConstantFalse %17 %29 = OpConstantComposite %18 %24 %27 %28 %30 = OpTypeVector %13 2 %31 = OpTypePointer Function %30 %33 = OpConstantComposite %30 %21 %21 %34 = OpTypeVector %17 3 %35 = OpTypePointer Function %34 %37 = OpConstantTrue %17 %38 = OpConstantComposite %34 %37 %28 %28 %39 = OpTypeVector %13 4 %40 = OpTypeMatrix %39 3 %41 = OpTypePointer Function %40 %43 = OpConstantComposite %39 %21 %22 %23 %21 %44 = OpConstantComposite %39 %22 %23 %21 %22 %45 = OpConstantComposite %39 %23 %21 %22 %23 %46 = OpConstantComposite %40 %43 %44 %45 %50 = OpTypePointer Function %14 %51 = OpConstantNull %14 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // A few cases of inapplicable transformations: // Id 4 is already in use ASSERT_FALSE(TransformationAddLocalVariable(4, 50, 4, 51, true) .IsApplicable(context.get(), transformation_context)); // Type mismatch between initializer and pointer ASSERT_FALSE(TransformationAddLocalVariable(105, 46, 4, 51, true) .IsApplicable(context.get(), transformation_context)); // Id 5 is not a function ASSERT_FALSE(TransformationAddLocalVariable(105, 50, 5, 51, true) .IsApplicable(context.get(), transformation_context)); // %105 = OpVariable %50 Function %51 { TransformationAddLocalVariable transformation(105, 50, 4, 51, true); ASSERT_EQ(nullptr, context->get_def_use_mgr()->GetDef(105)); ASSERT_EQ(nullptr, context->get_instr_block(105)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_EQ(spv::Op::OpVariable, context->get_def_use_mgr()->GetDef(105)->opcode()); ASSERT_EQ(5, context->get_instr_block(105)->id()); } // %104 = OpVariable %41 Function %46 { TransformationAddLocalVariable transformation(104, 41, 4, 46, false); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } // %103 = OpVariable %35 Function %38 { TransformationAddLocalVariable transformation(103, 35, 4, 38, true); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } // %102 = OpVariable %31 Function %33 { TransformationAddLocalVariable transformation(102, 31, 4, 33, false); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } // %101 = OpVariable %19 Function %29 { TransformationAddLocalVariable transformation(101, 19, 4, 29, true); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } // %100 = OpVariable %8 Function %12 { TransformationAddLocalVariable transformation(100, 8, 4, 12, false); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } ASSERT_FALSE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(100)); ASSERT_TRUE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(101)); ASSERT_FALSE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(102)); ASSERT_TRUE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(103)); ASSERT_FALSE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(104)); ASSERT_TRUE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(105)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeStruct %6 %6 %8 = OpTypePointer Function %7 %10 = OpConstant %6 1 %11 = OpConstant %6 2 %12 = OpConstantComposite %7 %10 %11 %13 = OpTypeFloat 32 %14 = OpTypeInt 32 0 %15 = OpConstant %14 3 %16 = OpTypeArray %13 %15 %17 = OpTypeBool %18 = OpTypeStruct %16 %7 %17 %19 = OpTypePointer Function %18 %21 = OpConstant %13 1 %22 = OpConstant %13 2 %23 = OpConstant %13 4 %24 = OpConstantComposite %16 %21 %22 %23 %25 = OpConstant %6 5 %26 = OpConstant %6 6 %27 = OpConstantComposite %7 %25 %26 %28 = OpConstantFalse %17 %29 = OpConstantComposite %18 %24 %27 %28 %30 = OpTypeVector %13 2 %31 = OpTypePointer Function %30 %33 = OpConstantComposite %30 %21 %21 %34 = OpTypeVector %17 3 %35 = OpTypePointer Function %34 %37 = OpConstantTrue %17 %38 = OpConstantComposite %34 %37 %28 %28 %39 = OpTypeVector %13 4 %40 = OpTypeMatrix %39 3 %41 = OpTypePointer Function %40 %43 = OpConstantComposite %39 %21 %22 %23 %21 %44 = OpConstantComposite %39 %22 %23 %21 %22 %45 = OpConstantComposite %39 %23 %21 %22 %23 %46 = OpConstantComposite %40 %43 %44 %45 %50 = OpTypePointer Function %14 %51 = OpConstantNull %14 %4 = OpFunction %2 None %3 %5 = OpLabel %100 = OpVariable %8 Function %12 %101 = OpVariable %19 Function %29 %102 = OpVariable %31 Function %33 %103 = OpVariable %35 Function %38 %104 = OpVariable %41 Function %46 %105 = OpVariable %50 Function %51 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_add_loop_preheader_test.cpp000066400000000000000000000243331475742701700312040ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_loop_preheader.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationAddLoopPreheaderTest, SimpleTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantFalse %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %10 None OpBranchConditional %7 %8 %9 %8 = OpLabel OpBranch %10 %9 = OpLabel OpBranch %10 %10 = OpLabel OpLoopMerge %12 %11 None OpBranch %11 %11 = OpLabel OpBranchConditional %7 %10 %12 %12 = OpLabel OpLoopMerge %14 %13 None OpBranch %13 %13 = OpLabel OpBranchConditional %7 %14 %12 %15 = OpLabel OpLoopMerge %17 %16 None OpBranch %16 %16 = OpLabel OpBranchConditional %7 %15 %17 %17 = OpLabel OpBranch %14 %14 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // %9 is not a loop header ASSERT_FALSE(TransformationAddLoopPreheader(9, 15, {}).IsApplicable( context.get(), transformation_context)); // The id %12 is not fresh ASSERT_FALSE(TransformationAddLoopPreheader(10, 12, {}) .IsApplicable(context.get(), transformation_context)); // Loop header %15 is not reachable (the only predecessor is the back-edge // block) ASSERT_FALSE(TransformationAddLoopPreheader(15, 100, {}) .IsApplicable(context.get(), transformation_context)); auto transformation1 = TransformationAddLoopPreheader(10, 20, {}); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); auto transformation2 = TransformationAddLoopPreheader(12, 21, {}); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformations = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantFalse %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %20 None OpBranchConditional %7 %8 %9 %8 = OpLabel OpBranch %20 %9 = OpLabel OpBranch %20 %20 = OpLabel OpBranch %10 %10 = OpLabel OpLoopMerge %21 %11 None OpBranch %11 %11 = OpLabel OpBranchConditional %7 %10 %21 %21 = OpLabel OpBranch %12 %12 = OpLabel OpLoopMerge %14 %13 None OpBranch %13 %13 = OpLabel OpBranchConditional %7 %14 %12 %15 = OpLabel OpLoopMerge %17 %16 None OpBranch %16 %16 = OpLabel OpBranchConditional %7 %15 %17 %17 = OpLabel OpBranch %14 %14 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformations, context.get())); } TEST(TransformationAddLoopPreheaderTest, OpPhi) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantFalse %6 %4 = OpFunction %2 None %3 %5 = OpLabel %20 = OpCopyObject %6 %7 OpBranch %8 %8 = OpLabel %31 = OpPhi %6 %20 %5 %21 %9 OpLoopMerge %10 %9 None OpBranch %9 %9 = OpLabel %21 = OpCopyObject %6 %7 OpBranchConditional %7 %8 %10 %10 = OpLabel OpSelectionMerge %13 None OpBranchConditional %7 %11 %12 %11 = OpLabel %22 = OpCopyObject %6 %7 OpBranch %13 %12 = OpLabel %23 = OpCopyObject %6 %7 OpBranch %13 %13 = OpLabel %32 = OpPhi %6 %22 %11 %23 %12 %24 %14 %33 = OpPhi %6 %7 %11 %7 %12 %24 %14 OpLoopMerge %15 %14 None OpBranch %14 %14 = OpLabel %24 = OpCopyObject %6 %7 OpBranchConditional %7 %13 %15 %15 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); auto transformation1 = TransformationAddLoopPreheader(8, 40, {}); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); // Not enough ids for the OpPhi instructions are given ASSERT_FALSE(TransformationAddLoopPreheader(13, 41, {}) .IsApplicable(context.get(), transformation_context)); // Not enough ids for the OpPhi instructions are given ASSERT_FALSE(TransformationAddLoopPreheader(13, 41, {42}) .IsApplicable(context.get(), transformation_context)); // One of the ids is not fresh ASSERT_FALSE(TransformationAddLoopPreheader(13, 41, {31, 42}) .IsApplicable(context.get(), transformation_context)); // One of the ids is repeated ASSERT_FALSE(TransformationAddLoopPreheader(13, 41, {41, 42}) .IsApplicable(context.get(), transformation_context)); auto transformation2 = TransformationAddLoopPreheader(13, 41, {42, 43}); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformations = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantFalse %6 %4 = OpFunction %2 None %3 %5 = OpLabel %20 = OpCopyObject %6 %7 OpBranch %40 %40 = OpLabel OpBranch %8 %8 = OpLabel %31 = OpPhi %6 %20 %40 %21 %9 OpLoopMerge %10 %9 None OpBranch %9 %9 = OpLabel %21 = OpCopyObject %6 %7 OpBranchConditional %7 %8 %10 %10 = OpLabel OpSelectionMerge %41 None OpBranchConditional %7 %11 %12 %11 = OpLabel %22 = OpCopyObject %6 %7 OpBranch %41 %12 = OpLabel %23 = OpCopyObject %6 %7 OpBranch %41 %41 = OpLabel %42 = OpPhi %6 %22 %11 %23 %12 %43 = OpPhi %6 %7 %11 %7 %12 OpBranch %13 %13 = OpLabel %32 = OpPhi %6 %42 %41 %24 %14 %33 = OpPhi %6 %43 %41 %24 %14 OpLoopMerge %15 %14 None OpBranch %14 %14 = OpLabel %24 = OpCopyObject %6 %7 OpBranchConditional %7 %13 %15 %15 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformations, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools transformation_add_loop_to_create_int_constant_synonym_test.cpp000066400000000000000000001337021475742701700355130ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/fuzz// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_loop_to_create_int_constant_synonym.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationAddLoopToCreateIntConstantSynonymTest, ConstantsNotSuitable) { std::string shader = R"( OpCapability Shader OpCapability Int64 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %36 = OpTypeBool %5 = OpTypeInt 32 1 %6 = OpConstant %5 -1 %7 = OpConstant %5 0 %8 = OpConstant %5 1 %9 = OpConstant %5 2 %10 = OpConstant %5 5 %11 = OpConstant %5 10 %12 = OpConstant %5 20 %13 = OpConstant %5 33 %14 = OpTypeVector %5 2 %15 = OpConstantComposite %14 %10 %11 %16 = OpConstantComposite %14 %12 %12 %17 = OpTypeVector %5 3 %18 = OpConstantComposite %17 %11 %7 %11 %19 = OpTypeInt 64 1 %20 = OpConstant %19 0 %21 = OpConstant %19 10 %22 = OpTypeVector %19 2 %23 = OpConstantComposite %22 %21 %20 %24 = OpTypeFloat 32 %25 = OpConstant %24 0 %26 = OpConstant %24 5 %27 = OpConstant %24 10 %28 = OpConstant %24 20 %29 = OpTypeVector %24 3 %30 = OpConstantComposite %29 %26 %27 %26 %31 = OpConstantComposite %29 %28 %28 %28 %32 = OpConstantComposite %29 %27 %25 %27 %2 = OpFunction %3 None %4 %33 = OpLabel %34 = OpCopyObject %5 %11 OpBranch %35 %35 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Reminder: the first four parameters of the constructor are the constants // with values for C, I, S, N respectively. // %70 does not correspond to an id in the module. ASSERT_FALSE(TransformationAddLoopToCreateIntConstantSynonym( 70, 12, 10, 9, 35, 100, 101, 102, 103, 104, 105, 106, 107) .IsApplicable(context.get(), transformation_context)); // %35 is not a constant. ASSERT_FALSE(TransformationAddLoopToCreateIntConstantSynonym( 35, 12, 10, 9, 35, 100, 101, 102, 103, 104, 105, 106, 107) .IsApplicable(context.get(), transformation_context)); // %27, %28 and %26 are not integer constants, but scalar floats. ASSERT_FALSE(TransformationAddLoopToCreateIntConstantSynonym( 27, 28, 26, 9, 35, 100, 101, 102, 103, 104, 105, 106, 107) .IsApplicable(context.get(), transformation_context)); // %32, %31 and %30 are not integer constants, but vector floats. ASSERT_FALSE(TransformationAddLoopToCreateIntConstantSynonym( 32, 31, 30, 9, 35, 100, 101, 102, 103, 104, 105, 106, 107) .IsApplicable(context.get(), transformation_context)); // %18=(10, 0, 10) has 3 components, while %16=(20, 20) and %15=(5, 10) // have 2. ASSERT_FALSE(TransformationAddLoopToCreateIntConstantSynonym( 18, 16, 15, 9, 35, 100, 101, 102, 103, 104, 105, 106, 107) .IsApplicable(context.get(), transformation_context)); // %21 has bit width 64, while the width of %12 and %10 is 32. ASSERT_FALSE(TransformationAddLoopToCreateIntConstantSynonym( 21, 12, 10, 9, 35, 100, 101, 102, 103, 104, 105, 106, 107) .IsApplicable(context.get(), transformation_context)); // %13 has component width 64, while the component width of %16 and %15 is 32. ASSERT_FALSE(TransformationAddLoopToCreateIntConstantSynonym( 13, 16, 15, 9, 35, 100, 101, 102, 103, 104, 105, 106, 107) .IsApplicable(context.get(), transformation_context)); // %21 (N) is a 64-bit integer, not 32-bit. ASSERT_FALSE(TransformationAddLoopToCreateIntConstantSynonym( 7, 7, 7, 21, 35, 100, 101, 102, 103, 104, 105, 106, 107) .IsApplicable(context.get(), transformation_context)); // %7 (N) has value 0, so N <= 0. ASSERT_FALSE(TransformationAddLoopToCreateIntConstantSynonym( 7, 7, 7, 7, 35, 100, 101, 102, 103, 104, 105, 106, 107) .IsApplicable(context.get(), transformation_context)); // %6 (N) has value -1, so N <= 1. ASSERT_FALSE(TransformationAddLoopToCreateIntConstantSynonym( 7, 7, 7, 6, 35, 100, 101, 102, 103, 104, 105, 106, 107) .IsApplicable(context.get(), transformation_context)); // %13 (N) has value 33, so N > 32. ASSERT_FALSE(TransformationAddLoopToCreateIntConstantSynonym( 7, 7, 7, 6, 13, 100, 101, 102, 103, 104, 105, 106, 107) .IsApplicable(context.get(), transformation_context)); // C(%11)=10, I(%12)=20, S(%10)=5, N(%8)=1, so C=I-S*N does not hold, as // 20-5*1=15. ASSERT_FALSE(TransformationAddLoopToCreateIntConstantSynonym( 11, 12, 10, 8, 35, 100, 101, 102, 103, 104, 105, 106, 107) .IsApplicable(context.get(), transformation_context)); // C(%15)=(5, 10), I(%16)=(20, 20), S(%15)=(5, 10), N(%8)=1, so C=I-S*N does // not hold, as (20, 20)-1*(5, 10) = (15, 10). ASSERT_FALSE(TransformationAddLoopToCreateIntConstantSynonym( 15, 16, 15, 8, 35, 100, 101, 102, 103, 104, 105, 106, 107) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationAddLoopToCreateIntConstantSynonymTest, MissingConstantsOrBoolType) { { // The shader is missing the boolean type. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %20 = OpConstant %5 0 %6 = OpConstant %5 1 %7 = OpConstant %5 2 %8 = OpConstant %5 5 %9 = OpConstant %5 10 %10 = OpConstant %5 20 %2 = OpFunction %3 None %4 %11 = OpLabel OpBranch %12 %12 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_FALSE(TransformationAddLoopToCreateIntConstantSynonym( 9, 10, 8, 7, 12, 100, 101, 102, 103, 104, 105, 106, 107) .IsApplicable(context.get(), transformation_context)); } { // The shader is missing a 32-bit integer 0 constant. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %20 = OpTypeBool %5 = OpTypeInt 32 1 %6 = OpConstant %5 1 %7 = OpConstant %5 2 %8 = OpConstant %5 5 %9 = OpConstant %5 10 %10 = OpConstant %5 20 %2 = OpFunction %3 None %4 %11 = OpLabel OpBranch %12 %12 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_FALSE(TransformationAddLoopToCreateIntConstantSynonym( 9, 10, 8, 7, 12, 100, 101, 102, 103, 104, 105, 106, 107) .IsApplicable(context.get(), transformation_context)); } { // The shader is missing a 32-bit integer 1 constant. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %20 = OpTypeBool %5 = OpTypeInt 32 1 %6 = OpConstant %5 0 %7 = OpConstant %5 2 %8 = OpConstant %5 5 %9 = OpConstant %5 10 %10 = OpConstant %5 20 %2 = OpFunction %3 None %4 %11 = OpLabel OpBranch %12 %12 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_FALSE(TransformationAddLoopToCreateIntConstantSynonym( 9, 10, 8, 7, 12, 100, 101, 102, 103, 104, 105, 106, 107) .IsApplicable(context.get(), transformation_context)); } } TEST(TransformationAddLoopToCreateIntConstantSynonymTest, Simple) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpTypeInt 32 1 %8 = OpConstant %7 0 %9 = OpConstant %7 1 %10 = OpConstant %7 2 %11 = OpConstant %7 5 %12 = OpConstant %7 10 %13 = OpConstant %7 20 %2 = OpFunction %3 None %4 %14 = OpLabel OpBranch %15 %15 = OpLabel %22 = OpPhi %7 %12 %14 OpSelectionMerge %16 None OpBranchConditional %6 %17 %18 %17 = OpLabel %23 = OpPhi %7 %13 %15 OpBranch %18 %18 = OpLabel OpBranch %16 %16 = OpLabel OpBranch %19 %19 = OpLabel OpLoopMerge %20 %19 None OpBranchConditional %6 %20 %19 %20 = OpLabel OpBranch %21 %21 = OpLabel OpBranch %24 %24 = OpLabel OpLoopMerge %27 %25 None OpBranch %25 %25 = OpLabel OpBranch %26 %26 = OpLabel OpBranchConditional %6 %24 %27 %27 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Block %14 has no predecessors. ASSERT_FALSE(TransformationAddLoopToCreateIntConstantSynonym( 12, 13, 11, 10, 14, 100, 101, 102, 103, 104, 105, 106, 107) .IsApplicable(context.get(), transformation_context)); // Block %18 has more than one predecessor. ASSERT_FALSE(TransformationAddLoopToCreateIntConstantSynonym( 12, 13, 11, 10, 18, 100, 101, 102, 103, 104, 105, 106, 107) .IsApplicable(context.get(), transformation_context)); // Block %16 is a merge block. ASSERT_FALSE(TransformationAddLoopToCreateIntConstantSynonym( 12, 13, 11, 10, 16, 100, 101, 102, 103, 104, 105, 106, 107) .IsApplicable(context.get(), transformation_context)); // Block %25 is a continue block. ASSERT_FALSE(TransformationAddLoopToCreateIntConstantSynonym( 12, 13, 11, 10, 25, 100, 101, 102, 103, 104, 105, 106, 107) .IsApplicable(context.get(), transformation_context)); // Block %19 has more than one predecessor. ASSERT_FALSE(TransformationAddLoopToCreateIntConstantSynonym( 12, 13, 11, 10, 19, 100, 101, 102, 103, 104, 105, 106, 107) .IsApplicable(context.get(), transformation_context)); // Block %20 is a merge block. ASSERT_FALSE(TransformationAddLoopToCreateIntConstantSynonym( 12, 13, 11, 10, 20, 100, 101, 102, 103, 104, 105, 106, 107) .IsApplicable(context.get(), transformation_context)); // Id %20 is supposed to be fresh, but it is not. ASSERT_FALSE(TransformationAddLoopToCreateIntConstantSynonym( 12, 13, 11, 10, 15, 100, 20, 102, 103, 104, 105, 106, 107) .IsApplicable(context.get(), transformation_context)); // Id %100 is used twice. ASSERT_FALSE(TransformationAddLoopToCreateIntConstantSynonym( 12, 13, 11, 10, 15, 100, 100, 102, 103, 104, 105, 106, 107) .IsApplicable(context.get(), transformation_context)); // Id %100 is used twice. ASSERT_FALSE(TransformationAddLoopToCreateIntConstantSynonym( 12, 13, 11, 10, 15, 100, 101, 102, 103, 104, 105, 106, 100) .IsApplicable(context.get(), transformation_context)); // Only the last id (for the additional block) is optional, so the other ones // cannot be 0. ASSERT_FALSE(TransformationAddLoopToCreateIntConstantSynonym( 12, 13, 11, 10, 15, 0, 101, 102, 103, 104, 105, 106, 100) .IsApplicable(context.get(), transformation_context)); // This transformation will create a synonym of constant %12 from a 1-block // loop. auto transformation1 = TransformationAddLoopToCreateIntConstantSynonym( 12, 13, 11, 10, 15, 100, 101, 102, 103, 104, 105, 106, 0); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(12, {}), MakeDataDescriptor(100, {}))); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // This transformation will create a synonym of constant %12 from a 2-block // loop. auto transformation2 = TransformationAddLoopToCreateIntConstantSynonym( 12, 13, 11, 10, 17, 107, 108, 109, 110, 111, 112, 113, 114); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(12, {}), MakeDataDescriptor(107, {}))); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // This transformation will create a synonym of constant %12 from a 2-block // loop. auto transformation3 = TransformationAddLoopToCreateIntConstantSynonym( 12, 13, 11, 10, 26, 115, 116, 117, 118, 119, 120, 121, 0); ASSERT_TRUE( transformation3.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation3, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(12, {}), MakeDataDescriptor(115, {}))); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformations = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpTypeInt 32 1 %8 = OpConstant %7 0 %9 = OpConstant %7 1 %10 = OpConstant %7 2 %11 = OpConstant %7 5 %12 = OpConstant %7 10 %13 = OpConstant %7 20 %2 = OpFunction %3 None %4 %14 = OpLabel OpBranch %101 %101 = OpLabel %102 = OpPhi %7 %8 %14 %105 %101 %103 = OpPhi %7 %13 %14 %104 %101 %104 = OpISub %7 %103 %11 %105 = OpIAdd %7 %102 %9 %106 = OpSLessThan %5 %105 %10 OpLoopMerge %15 %101 None OpBranchConditional %106 %101 %15 %15 = OpLabel %100 = OpPhi %7 %104 %101 %22 = OpPhi %7 %12 %101 OpSelectionMerge %16 None OpBranchConditional %6 %108 %18 %108 = OpLabel %109 = OpPhi %7 %8 %15 %112 %114 %110 = OpPhi %7 %13 %15 %111 %114 OpLoopMerge %17 %114 None OpBranch %114 %114 = OpLabel %111 = OpISub %7 %110 %11 %112 = OpIAdd %7 %109 %9 %113 = OpSLessThan %5 %112 %10 OpBranchConditional %113 %108 %17 %17 = OpLabel %107 = OpPhi %7 %111 %114 %23 = OpPhi %7 %13 %114 OpBranch %18 %18 = OpLabel OpBranch %16 %16 = OpLabel OpBranch %19 %19 = OpLabel OpLoopMerge %20 %19 None OpBranchConditional %6 %20 %19 %20 = OpLabel OpBranch %21 %21 = OpLabel OpBranch %24 %24 = OpLabel OpLoopMerge %27 %25 None OpBranch %25 %25 = OpLabel OpBranch %116 %116 = OpLabel %117 = OpPhi %7 %8 %25 %120 %116 %118 = OpPhi %7 %13 %25 %119 %116 %119 = OpISub %7 %118 %11 %120 = OpIAdd %7 %117 %9 %121 = OpSLessThan %5 %120 %10 OpLoopMerge %26 %116 None OpBranchConditional %121 %116 %26 %26 = OpLabel %115 = OpPhi %7 %119 %116 OpBranchConditional %6 %24 %27 %27 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformations, context.get())); } TEST(TransformationAddLoopToCreateIntConstantSynonymTest, DifferentSignednessAndVectors) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpTypeInt 32 1 %8 = OpConstant %7 0 %9 = OpConstant %7 1 %10 = OpConstant %7 2 %11 = OpConstant %7 5 %12 = OpConstant %7 10 %13 = OpConstant %7 20 %14 = OpTypeInt 32 0 %15 = OpConstant %14 0 %16 = OpConstant %14 5 %17 = OpConstant %14 10 %18 = OpConstant %14 20 %19 = OpTypeVector %7 2 %20 = OpTypeVector %14 2 %21 = OpConstantComposite %19 %12 %8 %22 = OpConstantComposite %20 %17 %15 %23 = OpConstantComposite %19 %13 %12 %24 = OpConstantComposite %19 %11 %11 %2 = OpFunction %3 None %4 %25 = OpLabel OpBranch %26 %26 = OpLabel OpBranch %27 %27 = OpLabel OpBranch %28 %28 = OpLabel OpBranch %29 %29 = OpLabel OpBranch %30 %30 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // These tests check that the transformation is applicable and is applied // correctly with integers, scalar and vectors, of different signedness. // %12 is a signed integer, %18 and %16 are unsigned integers. auto transformation1 = TransformationAddLoopToCreateIntConstantSynonym( 12, 18, 16, 10, 26, 100, 101, 102, 103, 104, 105, 106, 0); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(12, {}), MakeDataDescriptor(100, {}))); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // %12 and %11 are signed integers, %18 is an unsigned integer. auto transformation2 = TransformationAddLoopToCreateIntConstantSynonym( 12, 18, 11, 10, 27, 108, 109, 110, 111, 112, 113, 114, 0); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(12, {}), MakeDataDescriptor(108, {}))); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // %17, %18 and %16 are all signed integers. auto transformation3 = TransformationAddLoopToCreateIntConstantSynonym( 17, 18, 16, 10, 28, 115, 116, 117, 118, 119, 120, 121, 0); ASSERT_TRUE( transformation3.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation3, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(17, {}), MakeDataDescriptor(115, {}))); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // %22 is an unsigned integer vector, %23 and %24 are signed integer vectors. auto transformation4 = TransformationAddLoopToCreateIntConstantSynonym( 22, 23, 24, 10, 29, 122, 123, 124, 125, 126, 127, 128, 0); ASSERT_TRUE( transformation4.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation4, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(22, {}), MakeDataDescriptor(122, {}))); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // %21, %23 and %24 are all signed integer vectors. auto transformation5 = TransformationAddLoopToCreateIntConstantSynonym( 21, 23, 24, 10, 30, 129, 130, 131, 132, 133, 134, 135, 0); ASSERT_TRUE( transformation5.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation5, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(21, {}), MakeDataDescriptor(129, {}))); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformations = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpTypeInt 32 1 %8 = OpConstant %7 0 %9 = OpConstant %7 1 %10 = OpConstant %7 2 %11 = OpConstant %7 5 %12 = OpConstant %7 10 %13 = OpConstant %7 20 %14 = OpTypeInt 32 0 %15 = OpConstant %14 0 %16 = OpConstant %14 5 %17 = OpConstant %14 10 %18 = OpConstant %14 20 %19 = OpTypeVector %7 2 %20 = OpTypeVector %14 2 %21 = OpConstantComposite %19 %12 %8 %22 = OpConstantComposite %20 %17 %15 %23 = OpConstantComposite %19 %13 %12 %24 = OpConstantComposite %19 %11 %11 %2 = OpFunction %3 None %4 %25 = OpLabel OpBranch %101 %101 = OpLabel %102 = OpPhi %7 %8 %25 %105 %101 %103 = OpPhi %14 %18 %25 %104 %101 %104 = OpISub %14 %103 %16 %105 = OpIAdd %7 %102 %9 %106 = OpSLessThan %5 %105 %10 OpLoopMerge %26 %101 None OpBranchConditional %106 %101 %26 %26 = OpLabel %100 = OpPhi %14 %104 %101 OpBranch %109 %109 = OpLabel %110 = OpPhi %7 %8 %26 %113 %109 %111 = OpPhi %14 %18 %26 %112 %109 %112 = OpISub %14 %111 %11 %113 = OpIAdd %7 %110 %9 %114 = OpSLessThan %5 %113 %10 OpLoopMerge %27 %109 None OpBranchConditional %114 %109 %27 %27 = OpLabel %108 = OpPhi %14 %112 %109 OpBranch %116 %116 = OpLabel %117 = OpPhi %7 %8 %27 %120 %116 %118 = OpPhi %14 %18 %27 %119 %116 %119 = OpISub %14 %118 %16 %120 = OpIAdd %7 %117 %9 %121 = OpSLessThan %5 %120 %10 OpLoopMerge %28 %116 None OpBranchConditional %121 %116 %28 %28 = OpLabel %115 = OpPhi %14 %119 %116 OpBranch %123 %123 = OpLabel %124 = OpPhi %7 %8 %28 %127 %123 %125 = OpPhi %19 %23 %28 %126 %123 %126 = OpISub %19 %125 %24 %127 = OpIAdd %7 %124 %9 %128 = OpSLessThan %5 %127 %10 OpLoopMerge %29 %123 None OpBranchConditional %128 %123 %29 %29 = OpLabel %122 = OpPhi %19 %126 %123 OpBranch %130 %130 = OpLabel %131 = OpPhi %7 %8 %29 %134 %130 %132 = OpPhi %19 %23 %29 %133 %130 %133 = OpISub %19 %132 %24 %134 = OpIAdd %7 %131 %9 %135 = OpSLessThan %5 %134 %10 OpLoopMerge %30 %130 None OpBranchConditional %135 %130 %30 %30 = OpLabel %129 = OpPhi %19 %133 %130 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformations, context.get())); } TEST(TransformationAddLoopToCreateIntConstantSynonymTest, 64BitConstants) { std::string shader = R"( OpCapability Shader OpCapability Int64 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpTypeInt 32 1 %8 = OpConstant %7 0 %9 = OpConstant %7 1 %10 = OpConstant %7 2 %11 = OpTypeInt 64 1 %12 = OpConstant %11 5 %13 = OpConstant %11 10 %14 = OpConstant %11 20 %15 = OpTypeVector %11 2 %16 = OpConstantComposite %15 %13 %13 %17 = OpConstantComposite %15 %14 %14 %18 = OpConstantComposite %15 %12 %12 %2 = OpFunction %3 None %4 %19 = OpLabel OpBranch %20 %20 = OpLabel OpBranch %21 %21 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // These tests check that the transformation can be applied, and is applied // correctly, to 64-bit integer (scalar and vector) constants. // 64-bit scalar integers. auto transformation1 = TransformationAddLoopToCreateIntConstantSynonym( 13, 14, 12, 10, 20, 100, 101, 102, 103, 104, 105, 106, 0); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(13, {}), MakeDataDescriptor(100, {}))); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // 64-bit vector integers. auto transformation2 = TransformationAddLoopToCreateIntConstantSynonym( 16, 17, 18, 10, 21, 107, 108, 109, 110, 111, 112, 113, 0); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(16, {}), MakeDataDescriptor(107, {}))); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformations = R"( OpCapability Shader OpCapability Int64 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpTypeInt 32 1 %8 = OpConstant %7 0 %9 = OpConstant %7 1 %10 = OpConstant %7 2 %11 = OpTypeInt 64 1 %12 = OpConstant %11 5 %13 = OpConstant %11 10 %14 = OpConstant %11 20 %15 = OpTypeVector %11 2 %16 = OpConstantComposite %15 %13 %13 %17 = OpConstantComposite %15 %14 %14 %18 = OpConstantComposite %15 %12 %12 %2 = OpFunction %3 None %4 %19 = OpLabel OpBranch %101 %101 = OpLabel %102 = OpPhi %7 %8 %19 %105 %101 %103 = OpPhi %11 %14 %19 %104 %101 %104 = OpISub %11 %103 %12 %105 = OpIAdd %7 %102 %9 %106 = OpSLessThan %5 %105 %10 OpLoopMerge %20 %101 None OpBranchConditional %106 %101 %20 %20 = OpLabel %100 = OpPhi %11 %104 %101 OpBranch %108 %108 = OpLabel %109 = OpPhi %7 %8 %20 %112 %108 %110 = OpPhi %15 %17 %20 %111 %108 %111 = OpISub %15 %110 %18 %112 = OpIAdd %7 %109 %9 %113 = OpSLessThan %5 %112 %10 OpLoopMerge %21 %108 None OpBranchConditional %113 %108 %21 %21 = OpLabel %107 = OpPhi %15 %111 %108 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformations, context.get())); } TEST(TransformationAddLoopToCreateIntConstantSynonymTest, Underflow) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpTypeInt 32 1 %8 = OpConstant %7 0 %9 = OpConstant %7 1 %10 = OpConstant %7 2 %11 = OpConstant %7 20 %12 = OpConstant %7 -4 %13 = OpTypeInt 32 0 %14 = OpConstant %13 214748365 %15 = OpConstant %13 4294967256 %2 = OpFunction %3 None %4 %16 = OpLabel OpBranch %17 %17 = OpLabel OpBranch %18 %18 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // These tests check that underflows are taken into consideration when // deciding if transformation is applicable. // Subtracting 2147483648 20 times from 32-bit integer 0 underflows 2 times // and the result is equivalent to -4. auto transformation1 = TransformationAddLoopToCreateIntConstantSynonym( 12, 8, 14, 11, 17, 100, 101, 102, 103, 104, 105, 106, 0); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(12, {}), MakeDataDescriptor(100, {}))); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Subtracting 20 twice from 0 underflows and gives the unsigned integer // 4294967256. auto transformation2 = TransformationAddLoopToCreateIntConstantSynonym( 15, 8, 11, 10, 18, 107, 108, 109, 110, 111, 112, 113, 0); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(15, {}), MakeDataDescriptor(107, {}))); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformations = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpTypeInt 32 1 %8 = OpConstant %7 0 %9 = OpConstant %7 1 %10 = OpConstant %7 2 %11 = OpConstant %7 20 %12 = OpConstant %7 -4 %13 = OpTypeInt 32 0 %14 = OpConstant %13 214748365 %15 = OpConstant %13 4294967256 %2 = OpFunction %3 None %4 %16 = OpLabel OpBranch %101 %101 = OpLabel %102 = OpPhi %7 %8 %16 %105 %101 %103 = OpPhi %7 %8 %16 %104 %101 %104 = OpISub %7 %103 %14 %105 = OpIAdd %7 %102 %9 %106 = OpSLessThan %5 %105 %11 OpLoopMerge %17 %101 None OpBranchConditional %106 %101 %17 %17 = OpLabel %100 = OpPhi %7 %104 %101 OpBranch %108 %108 = OpLabel %109 = OpPhi %7 %8 %17 %112 %108 %110 = OpPhi %7 %8 %17 %111 %108 %111 = OpISub %7 %110 %11 %112 = OpIAdd %7 %109 %9 %113 = OpSLessThan %5 %112 %10 OpLoopMerge %18 %108 None OpBranchConditional %113 %108 %18 %18 = OpLabel %107 = OpPhi %7 %111 %108 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformations, context.get())); } TEST(TransformationAddLoopToCreateIntConstantSynonymTest, InapplicableDueToDeadBlockOrIrrelevantId) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpTypeInt 32 1 %8 = OpConstant %7 0 %9 = OpConstant %7 1 %10 = OpConstant %7 2 %11 = OpConstant %7 5 %12 = OpConstant %7 10 %13 = OpConstant %7 20 %1010 = OpConstant %7 2 %1011 = OpConstant %7 5 %1012 = OpConstant %7 10 %1013 = OpConstant %7 20 %2 = OpFunction %3 None %4 %14 = OpLabel OpSelectionMerge %16 None OpBranchConditional %6 %16 %15 %15 = OpLabel OpBranch %16 %16 = OpLabel OpBranch %17 %17 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactBlockIsDead(15); transformation_context.GetFactManager()->AddFactIdIsIrrelevant(1010); transformation_context.GetFactManager()->AddFactIdIsIrrelevant(1011); transformation_context.GetFactManager()->AddFactIdIsIrrelevant(1012); transformation_context.GetFactManager()->AddFactIdIsIrrelevant(1013); // Bad because the block before which the loop would be inserted is dead. ASSERT_FALSE(TransformationAddLoopToCreateIntConstantSynonym( 12, 13, 11, 10, 15, 100, 101, 102, 103, 104, 105, 106, 0) .IsApplicable(context.get(), transformation_context)); // OK ASSERT_TRUE(TransformationAddLoopToCreateIntConstantSynonym( 12, 13, 11, 10, 17, 100, 101, 102, 103, 104, 105, 106, 0) .IsApplicable(context.get(), transformation_context)); // Bad because in each case one of the constants involved is irrelevant. ASSERT_FALSE(TransformationAddLoopToCreateIntConstantSynonym( 1012, 13, 11, 10, 17, 100, 101, 102, 103, 104, 105, 106, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationAddLoopToCreateIntConstantSynonym( 12, 1013, 11, 10, 17, 100, 101, 102, 103, 104, 105, 106, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationAddLoopToCreateIntConstantSynonym( 12, 13, 1011, 10, 17, 100, 101, 102, 103, 104, 105, 106, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationAddLoopToCreateIntConstantSynonym( 12, 13, 11, 1010, 17, 100, 101, 102, 103, 104, 105, 106, 0) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationAddLoopToCreateIntConstantSynonymTest, InserBeforeOpSwitch) { // Checks that it is acceptable for a loop to be added before a target of an // OpSwitch instruction. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpConstant %6 0 %20 = OpConstant %6 1 %21 = OpConstant %6 2 %22 = OpTypeBool %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %10 None OpSwitch %7 %9 0 %8 %9 = OpLabel OpBranch %10 %8 = OpLabel OpBranch %10 %10 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto transformation1 = TransformationAddLoopToCreateIntConstantSynonym( 20, 21, 20, 20, 9, 100, 101, 102, 103, 104, 105, 106, 0); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(20, {}), MakeDataDescriptor(100, {}))); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); auto transformation2 = TransformationAddLoopToCreateIntConstantSynonym( 20, 21, 20, 20, 8, 200, 201, 202, 203, 204, 205, 206, 0); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(20, {}), MakeDataDescriptor(200, {}))); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformations = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpConstant %6 0 %20 = OpConstant %6 1 %21 = OpConstant %6 2 %22 = OpTypeBool %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %10 None OpSwitch %7 %101 0 %201 %101 = OpLabel %102 = OpPhi %6 %7 %5 %105 %101 %103 = OpPhi %6 %21 %5 %104 %101 %104 = OpISub %6 %103 %20 %105 = OpIAdd %6 %102 %20 %106 = OpSLessThan %22 %105 %20 OpLoopMerge %9 %101 None OpBranchConditional %106 %101 %9 %9 = OpLabel %100 = OpPhi %6 %104 %101 OpBranch %10 %201 = OpLabel %202 = OpPhi %6 %7 %5 %205 %201 %203 = OpPhi %6 %21 %5 %204 %201 %204 = OpISub %6 %203 %20 %205 = OpIAdd %6 %202 %20 %206 = OpSLessThan %22 %205 %20 OpLoopMerge %8 %201 None OpBranchConditional %206 %201 %8 %8 = OpLabel %200 = OpPhi %6 %204 %201 OpBranch %10 %10 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformations, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_add_no_contraction_decoration_test.cpp000066400000000000000000000153121475742701700334370ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_no_contraction_decoration.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationAddNoContractionDecorationTest, BasicScenarios) { // This is a simple transformation and this test handles the main cases. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "x" OpName %10 "y" OpName %14 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %11 = OpConstant %6 2 %12 = OpTypeInt 32 1 %13 = OpTypePointer Function %12 %15 = OpConstant %12 0 %22 = OpConstant %12 10 %23 = OpTypeBool %31 = OpConstant %6 3.5999999 %38 = OpConstant %12 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %14 = OpVariable %13 Function OpStore %8 %9 OpStore %10 %11 OpStore %14 %15 OpBranch %16 %16 = OpLabel OpLoopMerge %18 %19 None OpBranch %20 %20 = OpLabel %21 = OpLoad %12 %14 %24 = OpSLessThan %23 %21 %22 OpBranchConditional %24 %17 %18 %17 = OpLabel %25 = OpLoad %6 %10 %26 = OpLoad %6 %10 %27 = OpFMul %6 %25 %26 %28 = OpLoad %6 %8 %29 = OpFAdd %6 %28 %27 OpStore %8 %29 %30 = OpLoad %6 %10 %32 = OpFDiv %6 %30 %31 OpStore %10 %32 %33 = OpLoad %12 %14 %34 = OpConvertSToF %6 %33 %35 = OpLoad %6 %8 %36 = OpFAdd %6 %35 %34 OpStore %8 %36 OpBranch %19 %19 = OpLabel %37 = OpLoad %12 %14 %39 = OpIAdd %12 %37 %38 OpStore %14 %39 OpBranch %16 %18 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Invalid: 200 is not an id ASSERT_FALSE(TransformationAddNoContractionDecoration(200).IsApplicable( context.get(), transformation_context)); // Invalid: 17 is a block id ASSERT_FALSE(TransformationAddNoContractionDecoration(17).IsApplicable( context.get(), transformation_context)); // Invalid: 24 is not arithmetic ASSERT_FALSE(TransformationAddNoContractionDecoration(24).IsApplicable( context.get(), transformation_context)); // It is valid to add NoContraction to each of these ids. for (uint32_t result_id : {32u, 27u, 29u, 39u}) { TransformationAddNoContractionDecoration transformation(result_id); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "x" OpName %10 "y" OpName %14 "i" OpDecorate %32 NoContraction OpDecorate %27 NoContraction OpDecorate %29 NoContraction OpDecorate %39 NoContraction %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %11 = OpConstant %6 2 %12 = OpTypeInt 32 1 %13 = OpTypePointer Function %12 %15 = OpConstant %12 0 %22 = OpConstant %12 10 %23 = OpTypeBool %31 = OpConstant %6 3.5999999 %38 = OpConstant %12 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %14 = OpVariable %13 Function OpStore %8 %9 OpStore %10 %11 OpStore %14 %15 OpBranch %16 %16 = OpLabel OpLoopMerge %18 %19 None OpBranch %20 %20 = OpLabel %21 = OpLoad %12 %14 %24 = OpSLessThan %23 %21 %22 OpBranchConditional %24 %17 %18 %17 = OpLabel %25 = OpLoad %6 %10 %26 = OpLoad %6 %10 %27 = OpFMul %6 %25 %26 %28 = OpLoad %6 %8 %29 = OpFAdd %6 %28 %27 OpStore %8 %29 %30 = OpLoad %6 %10 %32 = OpFDiv %6 %30 %31 OpStore %10 %32 %33 = OpLoad %12 %14 %34 = OpConvertSToF %6 %33 %35 = OpLoad %6 %8 %36 = OpFAdd %6 %35 %34 OpStore %8 %36 OpBranch %19 %19 = OpLabel %37 = OpLoad %12 %14 %39 = OpIAdd %12 %37 %38 OpStore %14 %39 OpBranch %16 %18 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_add_opphi_synonym_test.cpp000066400000000000000000000441331475742701700311270ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_opphi_synonym.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { protobufs::Fact MakeSynonymFact(uint32_t first, uint32_t second) { protobufs::FactDataSynonym data_synonym_fact; *data_synonym_fact.mutable_data1() = MakeDataDescriptor(first, {}); *data_synonym_fact.mutable_data2() = MakeDataDescriptor(second, {}); protobufs::Fact result; *result.mutable_data_synonym_fact() = data_synonym_fact; return result; } // Adds synonym facts to the fact manager. void SetUpIdSynonyms(FactManager* fact_manager) { fact_manager->MaybeAddFact(MakeSynonymFact(11, 9)); fact_manager->MaybeAddFact(MakeSynonymFact(13, 9)); fact_manager->MaybeAddFact(MakeSynonymFact(14, 9)); fact_manager->MaybeAddFact(MakeSynonymFact(19, 9)); fact_manager->MaybeAddFact(MakeSynonymFact(20, 9)); fact_manager->MaybeAddFact(MakeSynonymFact(10, 21)); } TEST(TransformationAddOpPhiSynonymTest, Inapplicable) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpTypeInt 32 1 %8 = OpTypeInt 32 0 %22 = OpTypePointer Function %7 %9 = OpConstant %7 1 %10 = OpConstant %7 2 %11 = OpConstant %8 1 %2 = OpFunction %3 None %4 %12 = OpLabel %23 = OpVariable %22 Function %13 = OpCopyObject %7 %9 %14 = OpCopyObject %8 %11 OpBranch %15 %15 = OpLabel OpSelectionMerge %16 None OpBranchConditional %6 %17 %18 %17 = OpLabel %19 = OpCopyObject %7 %13 %20 = OpCopyObject %8 %14 %21 = OpCopyObject %7 %10 OpBranch %16 %18 = OpLabel %24 = OpCopyObject %22 %23 OpBranch %16 %16 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); SetUpIdSynonyms(transformation_context.GetFactManager()); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(23, 24)); // %13 is not a block label. ASSERT_FALSE(TransformationAddOpPhiSynonym(13, {{}}, 100) .IsApplicable(context.get(), transformation_context)); // Block %12 does not have a predecessor. ASSERT_FALSE(TransformationAddOpPhiSynonym(12, {{}}, 100) .IsApplicable(context.get(), transformation_context)); // Not all predecessors of %16 (%17 and %18) are considered in the map. ASSERT_FALSE(TransformationAddOpPhiSynonym(16, {{{17, 19}}}, 100) .IsApplicable(context.get(), transformation_context)); // %30 does not exist in the module. ASSERT_FALSE(TransformationAddOpPhiSynonym(16, {{{30, 19}}}, 100) .IsApplicable(context.get(), transformation_context)); // %20 is not a block label. ASSERT_FALSE(TransformationAddOpPhiSynonym(16, {{{20, 19}}}, 100) .IsApplicable(context.get(), transformation_context)); // %15 is not the id of one of the predecessors of the block. ASSERT_FALSE(TransformationAddOpPhiSynonym(16, {{{15, 19}}}, 100) .IsApplicable(context.get(), transformation_context)); // %30 does not exist in the module. ASSERT_FALSE(TransformationAddOpPhiSynonym(16, {{{17, 30}, {18, 13}}}, 100) .IsApplicable(context.get(), transformation_context)); // %19 and %10 are not synonymous. ASSERT_FALSE(TransformationAddOpPhiSynonym(16, {{{17, 19}, {18, 10}}}, 100) .IsApplicable(context.get(), transformation_context)); // %19 and %14 do not have the same type. ASSERT_FALSE(TransformationAddOpPhiSynonym(16, {{{17, 19}, {18, 14}}}, 100) .IsApplicable(context.get(), transformation_context)); // %19 is not available at the end of %18. ASSERT_FALSE(TransformationAddOpPhiSynonym(16, {{{17, 9}, {18, 19}}}, 100) .IsApplicable(context.get(), transformation_context)); // %21 is not a fresh id. ASSERT_FALSE(TransformationAddOpPhiSynonym(16, {{{17, 9}, {18, 9}}}, 21) .IsApplicable(context.get(), transformation_context)); // %23 and %24 have pointer id. ASSERT_FALSE(TransformationAddOpPhiSynonym(16, {{{17, 23}, {18, 24}}}, 100) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationAddOpPhiSynonymTest, Apply) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpTypeInt 32 1 %8 = OpTypeInt 32 0 %9 = OpConstant %7 1 %10 = OpConstant %7 2 %11 = OpConstant %8 1 %2 = OpFunction %3 None %4 %12 = OpLabel %13 = OpCopyObject %7 %9 %14 = OpCopyObject %8 %11 OpBranch %15 %15 = OpLabel OpSelectionMerge %16 None OpBranchConditional %6 %17 %18 %17 = OpLabel %19 = OpCopyObject %7 %13 %20 = OpCopyObject %8 %14 %21 = OpCopyObject %7 %10 OpBranch %16 %18 = OpLabel OpBranch %16 %16 = OpLabel OpBranch %22 %22 = OpLabel OpLoopMerge %23 %24 None OpBranchConditional %6 %25 %23 %25 = OpLabel OpSelectionMerge %26 None OpBranchConditional %6 %27 %26 %27 = OpLabel %28 = OpCopyObject %7 %13 OpBranch %23 %26 = OpLabel OpSelectionMerge %29 None OpBranchConditional %6 %29 %24 %29 = OpLabel %30 = OpCopyObject %7 %13 OpBranch %23 %24 = OpLabel OpBranch %22 %23 = OpLabel OpSelectionMerge %31 None OpBranchConditional %6 %31 %31 %31 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); SetUpIdSynonyms(transformation_context.GetFactManager()); // Add some further synonym facts. transformation_context.GetFactManager()->MaybeAddFact(MakeSynonymFact(28, 9)); transformation_context.GetFactManager()->MaybeAddFact(MakeSynonymFact(30, 9)); auto transformation1 = TransformationAddOpPhiSynonym(17, {{{15, 13}}}, 100); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(100, {}), MakeDataDescriptor(9, {}))); auto transformation2 = TransformationAddOpPhiSynonym(16, {{{17, 19}, {18, 13}}}, 101); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(101, {}), MakeDataDescriptor(9, {}))); auto transformation3 = TransformationAddOpPhiSynonym(23, {{{22, 13}, {27, 28}, {29, 30}}}, 102); ASSERT_TRUE( transformation3.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation3, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(102, {}), MakeDataDescriptor(9, {}))); auto transformation4 = TransformationAddOpPhiSynonym(31, {{{23, 13}}}, 103); ASSERT_TRUE( transformation4.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation4, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(103, {}), MakeDataDescriptor(9, {}))); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformations = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpTypeInt 32 1 %8 = OpTypeInt 32 0 %9 = OpConstant %7 1 %10 = OpConstant %7 2 %11 = OpConstant %8 1 %2 = OpFunction %3 None %4 %12 = OpLabel %13 = OpCopyObject %7 %9 %14 = OpCopyObject %8 %11 OpBranch %15 %15 = OpLabel OpSelectionMerge %16 None OpBranchConditional %6 %17 %18 %17 = OpLabel %100 = OpPhi %7 %13 %15 %19 = OpCopyObject %7 %13 %20 = OpCopyObject %8 %14 %21 = OpCopyObject %7 %10 OpBranch %16 %18 = OpLabel OpBranch %16 %16 = OpLabel %101 = OpPhi %7 %19 %17 %13 %18 OpBranch %22 %22 = OpLabel OpLoopMerge %23 %24 None OpBranchConditional %6 %25 %23 %25 = OpLabel OpSelectionMerge %26 None OpBranchConditional %6 %27 %26 %27 = OpLabel %28 = OpCopyObject %7 %13 OpBranch %23 %26 = OpLabel OpSelectionMerge %29 None OpBranchConditional %6 %29 %24 %29 = OpLabel %30 = OpCopyObject %7 %13 OpBranch %23 %24 = OpLabel OpBranch %22 %23 = OpLabel %102 = OpPhi %7 %13 %22 %28 %27 %30 %29 OpSelectionMerge %31 None OpBranchConditional %6 %31 %31 %31 = OpLabel %103 = OpPhi %7 %13 %23 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformations, context.get())); } TEST(TransformationAddOpPhiSynonymTest, VariablePointers) { std::string shader = R"( OpCapability Shader OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeBool %7 = OpConstantTrue %6 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %10 = OpTypePointer Workgroup %8 %3 = OpVariable %10 Workgroup %2 = OpFunction %4 None %5 %11 = OpLabel %12 = OpVariable %9 Function OpSelectionMerge %13 None OpBranchConditional %7 %14 %13 %14 = OpLabel %15 = OpCopyObject %10 %3 %16 = OpCopyObject %9 %12 OpBranch %13 %13 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Declare synonyms transformation_context.GetFactManager()->MaybeAddFact(MakeSynonymFact(3, 15)); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(12, 16)); // Remove the VariablePointers capability. context.get()->RemoveCapability(spv::Capability::VariablePointers); // The VariablePointers capability is required to add an OpPhi instruction of // pointer type. ASSERT_FALSE(TransformationAddOpPhiSynonym(13, {{{11, 3}, {14, 15}}}, 100) .IsApplicable(context.get(), transformation_context)); // Add the VariablePointers capability back. context.get()->AddCapability(spv::Capability::VariablePointers); // If the ids have pointer type, the storage class must be Workgroup or // StorageBuffer, but it is Function in this case. ASSERT_FALSE(TransformationAddOpPhiSynonym(13, {{{11, 12}, {14, 16}}}, 100) .IsApplicable(context.get(), transformation_context)); auto transformation = TransformationAddOpPhiSynonym(13, {{{11, 3}, {14, 15}}}, 100); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); std::string after_transformation = R"( OpCapability Shader OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeBool %7 = OpConstantTrue %6 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %10 = OpTypePointer Workgroup %8 %3 = OpVariable %10 Workgroup %2 = OpFunction %4 None %5 %11 = OpLabel %12 = OpVariable %9 Function OpSelectionMerge %13 None OpBranchConditional %7 %14 %13 %14 = OpLabel %15 = OpCopyObject %10 %3 %16 = OpCopyObject %9 %12 OpBranch %13 %13 = OpLabel %100 = OpPhi %10 %3 %11 %15 %14 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationAddOpPhiSynonymTest, DeadBlock) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 2 %10 = OpTypeBool %11 = OpConstantFalse %10 %15 = OpConstant %6 0 %50 = OpConstant %6 0 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpStore %8 %9 OpSelectionMerge %13 None OpBranchConditional %11 %12 %13 %12 = OpLabel %14 = OpLoad %6 %8 %16 = OpIEqual %10 %14 %15 OpSelectionMerge %18 None OpBranchConditional %16 %17 %40 %17 = OpLabel OpBranch %18 %40 = OpLabel OpBranch %18 %18 = OpLabel OpBranch %13 %13 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Dead blocks transformation_context.GetFactManager()->AddFactBlockIsDead(12); transformation_context.GetFactManager()->AddFactBlockIsDead(17); transformation_context.GetFactManager()->AddFactBlockIsDead(18); // Declare synonym ASSERT_TRUE(transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(15, 50))); // Bad because the block 18 is dead. ASSERT_FALSE(TransformationAddOpPhiSynonym(18, {{{17, 15}, {40, 50}}}, 100) .IsApplicable(context.get(), transformation_context)); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_add_parameter_test.cpp000066400000000000000000001260311475742701700301720ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_parameter.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationAddParameterTest, NonPointerBasicTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %7 = OpTypeBool %11 = OpTypeInt 32 1 %16 = OpTypeFloat 32 %51 = OpConstant %11 2 %52 = OpTypeArray %16 %51 %53 = OpConstant %16 7 %54 = OpConstantComposite %52 %53 %53 %3 = OpTypeFunction %2 %6 = OpTypeFunction %7 %7 %8 = OpConstant %11 23 %12 = OpConstantTrue %7 %15 = OpTypeFunction %2 %16 %24 = OpTypeFunction %2 %16 %7 %31 = OpTypeStruct %7 %11 %32 = OpConstant %16 23 %33 = OpConstantComposite %31 %12 %8 %41 = OpTypeStruct %11 %16 %42 = OpConstantComposite %41 %8 %32 %43 = OpTypeFunction %2 %41 %44 = OpTypeFunction %2 %41 %7 %4 = OpFunction %2 None %3 %5 = OpLabel %13 = OpFunctionCall %7 %9 %12 OpReturn OpFunctionEnd ; adjust type of the function in-place %9 = OpFunction %7 None %6 %14 = OpFunctionParameter %7 %10 = OpLabel OpReturnValue %12 OpFunctionEnd ; reuse an existing function type %17 = OpFunction %2 None %15 %18 = OpFunctionParameter %16 %19 = OpLabel OpReturn OpFunctionEnd %20 = OpFunction %2 None %15 %21 = OpFunctionParameter %16 %22 = OpLabel OpReturn OpFunctionEnd %25 = OpFunction %2 None %24 %26 = OpFunctionParameter %16 %27 = OpFunctionParameter %7 %28 = OpLabel OpReturn OpFunctionEnd ; create a new function type %29 = OpFunction %2 None %3 %30 = OpLabel OpReturn OpFunctionEnd ; don't adjust the type of the function if it creates a duplicate %34 = OpFunction %2 None %43 %35 = OpFunctionParameter %41 %36 = OpLabel OpReturn OpFunctionEnd %37 = OpFunction %2 None %44 %38 = OpFunctionParameter %41 %39 = OpFunctionParameter %7 %40 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Can't modify entry point function. ASSERT_FALSE(TransformationAddParameter(4, 60, 7, {{}}, 61) .IsApplicable(context.get(), transformation_context)); // There is no function with result id 60. ASSERT_FALSE(TransformationAddParameter(60, 60, 11, {{}}, 61) .IsApplicable(context.get(), transformation_context)); // Parameter id is not fresh. ASSERT_FALSE(TransformationAddParameter(9, 14, 11, {{{13, 8}}}, 61) .IsApplicable(context.get(), transformation_context)); // Function type id is not fresh. ASSERT_FALSE(TransformationAddParameter(9, 60, 11, {{{13, 8}}}, 14) .IsApplicable(context.get(), transformation_context)); // Function type id and parameter type id are equal. ASSERT_FALSE(TransformationAddParameter(9, 60, 11, {{{13, 8}}}, 60) .IsApplicable(context.get(), transformation_context)); // Parameter's initializer doesn't exist. ASSERT_FALSE(TransformationAddParameter(9, 60, 11, {{{13, 60}}}, 61) .IsApplicable(context.get(), transformation_context)); // Correct transformations. { TransformationAddParameter correct(9, 60, 11, {{{13, 8}}}, 61); ASSERT_TRUE(correct.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(correct, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IdIsIrrelevant(60)); } { TransformationAddParameter correct(9, 68, 52, {{{13, 54}}}, 69); ASSERT_TRUE(correct.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(correct, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IdIsIrrelevant(68)); } { TransformationAddParameter correct(17, 62, 7, {{}}, 63); ASSERT_TRUE(correct.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(correct, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IdIsIrrelevant(62)); } { TransformationAddParameter correct(29, 64, 31, {{}}, 65); ASSERT_TRUE(correct.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(correct, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IdIsIrrelevant(64)); } { TransformationAddParameter correct(34, 66, 7, {{}}, 67); ASSERT_TRUE(correct.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(correct, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IdIsIrrelevant(66)); } std::string expected_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %7 = OpTypeBool %11 = OpTypeInt 32 1 %16 = OpTypeFloat 32 %51 = OpConstant %11 2 %52 = OpTypeArray %16 %51 %53 = OpConstant %16 7 %54 = OpConstantComposite %52 %53 %53 %3 = OpTypeFunction %2 %8 = OpConstant %11 23 %12 = OpConstantTrue %7 %15 = OpTypeFunction %2 %16 %24 = OpTypeFunction %2 %16 %7 %31 = OpTypeStruct %7 %11 %32 = OpConstant %16 23 %33 = OpConstantComposite %31 %12 %8 %41 = OpTypeStruct %11 %16 %42 = OpConstantComposite %41 %8 %32 %44 = OpTypeFunction %2 %41 %7 %6 = OpTypeFunction %7 %7 %11 %52 %65 = OpTypeFunction %2 %31 %4 = OpFunction %2 None %3 %5 = OpLabel %13 = OpFunctionCall %7 %9 %12 %8 %54 OpReturn OpFunctionEnd ; adjust type of the function in-place %9 = OpFunction %7 None %6 %14 = OpFunctionParameter %7 %60 = OpFunctionParameter %11 %68 = OpFunctionParameter %52 %10 = OpLabel OpReturnValue %12 OpFunctionEnd ; reuse an existing function type %17 = OpFunction %2 None %24 %18 = OpFunctionParameter %16 %62 = OpFunctionParameter %7 %19 = OpLabel OpReturn OpFunctionEnd %20 = OpFunction %2 None %15 %21 = OpFunctionParameter %16 %22 = OpLabel OpReturn OpFunctionEnd %25 = OpFunction %2 None %24 %26 = OpFunctionParameter %16 %27 = OpFunctionParameter %7 %28 = OpLabel OpReturn OpFunctionEnd ; create a new function type %29 = OpFunction %2 None %65 %64 = OpFunctionParameter %31 %30 = OpLabel OpReturn OpFunctionEnd ; don't adjust the type of the function if it creates a duplicate %34 = OpFunction %2 None %44 %35 = OpFunctionParameter %41 %66 = OpFunctionParameter %7 %36 = OpLabel OpReturn OpFunctionEnd %37 = OpFunction %2 None %44 %38 = OpFunctionParameter %41 %39 = OpFunctionParameter %7 %40 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected_shader, context.get())); } TEST(TransformationAddParameterTest, NonPointerNotApplicableTest) { // This types handles case of adding a new parameter of a non-pointer type // where the transformation is not applicable. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %6 "fun1(" OpName %12 "fun2(i1;" OpName %11 "a" OpName %14 "fun3(" OpName %24 "f1" OpName %27 "f2" OpName %30 "i1" OpName %31 "i2" OpName %32 "param" OpName %35 "i3" OpName %36 "param" %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %10 = OpTypeFunction %8 %9 %18 = OpConstant %8 2 %22 = OpTypeFloat 32 %23 = OpTypePointer Private %22 %24 = OpVariable %23 Private %25 = OpConstant %22 1 %26 = OpTypePointer Function %22 %28 = OpConstant %22 2 %4 = OpFunction %2 None %3 %5 = OpLabel %27 = OpVariable %26 Function %30 = OpVariable %9 Function %31 = OpVariable %9 Function %32 = OpVariable %9 Function %35 = OpVariable %9 Function %36 = OpVariable %9 Function OpStore %24 %25 OpStore %27 %28 %29 = OpFunctionCall %2 %6 OpStore %30 %18 %33 = OpLoad %8 %30 OpStore %32 %33 %34 = OpFunctionCall %8 %12 %32 OpStore %31 %34 %37 = OpLoad %8 %31 OpStore %36 %37 %38 = OpFunctionCall %8 %12 %36 OpStore %35 %38 ; %39 = OpFunctionCall %2 %14 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel OpReturn OpFunctionEnd %12 = OpFunction %8 None %10 %11 = OpFunctionParameter %9 %13 = OpLabel %17 = OpLoad %8 %11 %19 = OpIAdd %8 %17 %18 OpReturnValue %19 OpFunctionEnd %14 = OpFunction %2 None %3 %15 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Bad: Id 19 is not available in the caller that has id 34. TransformationAddParameter transformation_bad_1(12, 50, 8, {{{34, 19}, {38, 19}}}, 51); ASSERT_FALSE( transformation_bad_1.IsApplicable(context.get(), transformation_context)); // Bad: Id 8 does not have a type. TransformationAddParameter transformation_bad_2(12, 50, 8, {{{34, 8}, {38, 8}}}, 51); ASSERT_FALSE( transformation_bad_2.IsApplicable(context.get(), transformation_context)); // Bad: Types of id 25 and id 18 are different. TransformationAddParameter transformation_bad_3(12, 50, 22, {{{34, 25}, {38, 18}}}, 51); ASSERT_FALSE( transformation_bad_3.IsApplicable(context.get(), transformation_context)); // Function with id 14 does not have any callers. // Bad: Id 18 is not a valid type. TransformationAddParameter transformation_bad_4(14, 50, 18, {{}}, 51); ASSERT_FALSE( transformation_bad_4.IsApplicable(context.get(), transformation_context)); // Function with id 14 does not have any callers. // Bad: Id 3 refers to OpTypeVoid, which is not supported. TransformationAddParameter transformation_bad_6(14, 50, 3, {{}}, 51); ASSERT_FALSE( transformation_bad_6.IsApplicable(context.get(), transformation_context)); } TEST(TransformationAddParameterTest, PointerFunctionTest) { // This types handles case of adding a new parameter of a pointer type with // storage class Function. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %6 "fun1(" OpName %12 "fun2(i1;" OpName %11 "a" OpName %14 "fun3(" OpName %17 "s" OpName %24 "s" OpName %28 "f1" OpName %31 "f2" OpName %34 "i1" OpName %35 "i2" OpName %36 "param" OpName %39 "i3" OpName %40 "param" %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %10 = OpTypeFunction %8 %9 %20 = OpConstant %8 2 %25 = OpConstant %8 0 %26 = OpTypeFloat 32 %27 = OpTypePointer Private %26 %28 = OpVariable %27 Private %60 = OpTypePointer Output %26 %61 = OpVariable %60 Output %29 = OpConstant %26 1 %30 = OpTypePointer Function %26 %32 = OpConstant %26 2 %4 = OpFunction %2 None %3 %5 = OpLabel %31 = OpVariable %30 Function %34 = OpVariable %9 Function %35 = OpVariable %9 Function %36 = OpVariable %9 Function %39 = OpVariable %9 Function %40 = OpVariable %9 Function OpStore %28 %29 OpStore %31 %32 %33 = OpFunctionCall %2 %6 OpStore %34 %20 %37 = OpLoad %8 %34 OpStore %36 %37 %38 = OpFunctionCall %8 %12 %36 OpStore %35 %38 %41 = OpLoad %8 %35 OpStore %40 %41 %42 = OpFunctionCall %8 %12 %40 OpStore %39 %42 %43 = OpFunctionCall %2 %14 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel OpReturn OpFunctionEnd %12 = OpFunction %8 None %10 %11 = OpFunctionParameter %9 %13 = OpLabel %17 = OpVariable %9 Function %18 = OpLoad %8 %11 OpStore %17 %18 %19 = OpLoad %8 %17 %21 = OpIAdd %8 %19 %20 OpReturnValue %21 OpFunctionEnd %14 = OpFunction %2 None %3 %15 = OpLabel %24 = OpVariable %9 Function OpStore %24 %25 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Bad: Pointer of id 61 has storage class Output, which is not supported. TransformationAddParameter transformation_bad_1(12, 50, 60, {{{38, 61}, {42, 61}}}, 51); ASSERT_FALSE( transformation_bad_1.IsApplicable(context.get(), transformation_context)); // Good: Local variable of id 31 is defined in the caller (main). TransformationAddParameter transformation_good_1(12, 50, 30, {{{38, 31}, {42, 31}}}, 51); ASSERT_TRUE(transformation_good_1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Good: Local variable of id 34 is defined in the caller (main). TransformationAddParameter transformation_good_2(14, 52, 9, {{{43, 34}}}, 53); ASSERT_TRUE(transformation_good_2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Good: Local variable of id 39 is defined in the caller (main). TransformationAddParameter transformation_good_3(6, 54, 9, {{{33, 39}}}, 55); ASSERT_TRUE(transformation_good_3.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_3, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Good: This adds another pointer parameter to the function of id 6. TransformationAddParameter transformation_good_4(6, 56, 30, {{{33, 31}}}, 57); ASSERT_TRUE(transformation_good_4.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_4, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string expected_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %6 "fun1(" OpName %12 "fun2(i1;" OpName %11 "a" OpName %14 "fun3(" OpName %17 "s" OpName %24 "s" OpName %28 "f1" OpName %31 "f2" OpName %34 "i1" OpName %35 "i2" OpName %36 "param" OpName %39 "i3" OpName %40 "param" %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %20 = OpConstant %8 2 %25 = OpConstant %8 0 %26 = OpTypeFloat 32 %27 = OpTypePointer Private %26 %28 = OpVariable %27 Private %60 = OpTypePointer Output %26 %61 = OpVariable %60 Output %29 = OpConstant %26 1 %30 = OpTypePointer Function %26 %32 = OpConstant %26 2 %10 = OpTypeFunction %8 %9 %30 %53 = OpTypeFunction %2 %9 %57 = OpTypeFunction %2 %9 %30 %4 = OpFunction %2 None %3 %5 = OpLabel %31 = OpVariable %30 Function %34 = OpVariable %9 Function %35 = OpVariable %9 Function %36 = OpVariable %9 Function %39 = OpVariable %9 Function %40 = OpVariable %9 Function OpStore %28 %29 OpStore %31 %32 %33 = OpFunctionCall %2 %6 %39 %31 OpStore %34 %20 %37 = OpLoad %8 %34 OpStore %36 %37 %38 = OpFunctionCall %8 %12 %36 %31 OpStore %35 %38 %41 = OpLoad %8 %35 OpStore %40 %41 %42 = OpFunctionCall %8 %12 %40 %31 OpStore %39 %42 %43 = OpFunctionCall %2 %14 %34 OpReturn OpFunctionEnd %6 = OpFunction %2 None %57 %54 = OpFunctionParameter %9 %56 = OpFunctionParameter %30 %7 = OpLabel OpReturn OpFunctionEnd %12 = OpFunction %8 None %10 %11 = OpFunctionParameter %9 %50 = OpFunctionParameter %30 %13 = OpLabel %17 = OpVariable %9 Function %18 = OpLoad %8 %11 OpStore %17 %18 %19 = OpLoad %8 %17 %21 = OpIAdd %8 %19 %20 OpReturnValue %21 OpFunctionEnd %14 = OpFunction %2 None %53 %52 = OpFunctionParameter %9 %15 = OpLabel %24 = OpVariable %9 Function OpStore %24 %25 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected_shader, context.get())); } TEST(TransformationAddParameterTest, PointerPrivateWorkgroupTest) { // This types handles case of adding a new parameter of a pointer type with // storage class Private or Workgroup. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %6 "fun1(" OpName %12 "fun2(i1;" OpName %11 "a" OpName %14 "fun3(" OpName %17 "s" OpName %24 "s" OpName %28 "f1" OpName %31 "f2" OpName %34 "i1" OpName %35 "i2" OpName %36 "param" OpName %39 "i3" OpName %40 "param" %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %10 = OpTypeFunction %8 %9 %20 = OpConstant %8 2 %25 = OpConstant %8 0 %26 = OpTypeFloat 32 %27 = OpTypePointer Private %26 %28 = OpVariable %27 Private %60 = OpTypePointer Workgroup %26 %61 = OpVariable %60 Workgroup %29 = OpConstant %26 1 %30 = OpTypePointer Function %26 %32 = OpConstant %26 2 %4 = OpFunction %2 None %3 %5 = OpLabel %31 = OpVariable %30 Function %34 = OpVariable %9 Function %35 = OpVariable %9 Function %36 = OpVariable %9 Function %39 = OpVariable %9 Function %40 = OpVariable %9 Function OpStore %28 %29 OpStore %31 %32 %33 = OpFunctionCall %2 %6 OpStore %34 %20 %37 = OpLoad %8 %34 OpStore %36 %37 %38 = OpFunctionCall %8 %12 %36 OpStore %35 %38 %41 = OpLoad %8 %35 OpStore %40 %41 %42 = OpFunctionCall %8 %12 %40 OpStore %39 %42 %43 = OpFunctionCall %2 %14 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel OpReturn OpFunctionEnd %12 = OpFunction %8 None %10 %11 = OpFunctionParameter %9 %13 = OpLabel %17 = OpVariable %9 Function %18 = OpLoad %8 %11 OpStore %17 %18 %19 = OpLoad %8 %17 %21 = OpIAdd %8 %19 %20 OpReturnValue %21 OpFunctionEnd %14 = OpFunction %2 None %3 %15 = OpLabel %24 = OpVariable %9 Function OpStore %24 %25 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Good: Global variable of id 28 (storage class Private) is defined in the // caller (main). TransformationAddParameter transformation_good_1(12, 70, 27, {{{38, 28}, {42, 28}}}, 71); ASSERT_TRUE(transformation_good_1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Good: Global variable of id 61 is (storage class Workgroup) is defined in // the caller (main). TransformationAddParameter transformation_good_2(12, 72, 27, {{{38, 28}, {42, 28}}}, 73); ASSERT_TRUE(transformation_good_2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_2, context.get(), &transformation_context); // Good: Global variable of id 28 (storage class Private) is defined in the // caller (main). TransformationAddParameter transformation_good_3(6, 74, 27, {{{33, 28}}}, 75); ASSERT_TRUE(transformation_good_3.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_3, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Good: Global variable of id 61 is (storage class Workgroup) is defined in // the caller (main). TransformationAddParameter transformation_good_4(6, 76, 60, {{{33, 61}}}, 77); ASSERT_TRUE(transformation_good_4.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_4, context.get(), &transformation_context); // Good: Global variable of id 28 (storage class Private) is defined in the // caller (main). TransformationAddParameter transformation_good_5(14, 78, 27, {{{43, 28}}}, 79); ASSERT_TRUE(transformation_good_5.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_5, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Good: Global variable of id 61 is (storage class Workgroup) is defined in // the caller (main). TransformationAddParameter transformation_good_6(14, 80, 60, {{{43, 61}}}, 81); ASSERT_TRUE(transformation_good_6.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_6, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string expected_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %6 "fun1(" OpName %12 "fun2(i1;" OpName %11 "a" OpName %14 "fun3(" OpName %17 "s" OpName %24 "s" OpName %28 "f1" OpName %31 "f2" OpName %34 "i1" OpName %35 "i2" OpName %36 "param" OpName %39 "i3" OpName %40 "param" %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %20 = OpConstant %8 2 %25 = OpConstant %8 0 %26 = OpTypeFloat 32 %27 = OpTypePointer Private %26 %28 = OpVariable %27 Private %60 = OpTypePointer Workgroup %26 %61 = OpVariable %60 Workgroup %29 = OpConstant %26 1 %30 = OpTypePointer Function %26 %32 = OpConstant %26 2 %10 = OpTypeFunction %8 %9 %27 %27 %75 = OpTypeFunction %2 %27 %60 %4 = OpFunction %2 None %3 %5 = OpLabel %31 = OpVariable %30 Function %34 = OpVariable %9 Function %35 = OpVariable %9 Function %36 = OpVariable %9 Function %39 = OpVariable %9 Function %40 = OpVariable %9 Function OpStore %28 %29 OpStore %31 %32 %33 = OpFunctionCall %2 %6 %28 %61 OpStore %34 %20 %37 = OpLoad %8 %34 OpStore %36 %37 %38 = OpFunctionCall %8 %12 %36 %28 %28 OpStore %35 %38 %41 = OpLoad %8 %35 OpStore %40 %41 %42 = OpFunctionCall %8 %12 %40 %28 %28 OpStore %39 %42 %43 = OpFunctionCall %2 %14 %28 %61 OpReturn OpFunctionEnd %6 = OpFunction %2 None %75 %74 = OpFunctionParameter %27 %76 = OpFunctionParameter %60 %7 = OpLabel OpReturn OpFunctionEnd %12 = OpFunction %8 None %10 %11 = OpFunctionParameter %9 %70 = OpFunctionParameter %27 %72 = OpFunctionParameter %27 %13 = OpLabel %17 = OpVariable %9 Function %18 = OpLoad %8 %11 OpStore %17 %18 %19 = OpLoad %8 %17 %21 = OpIAdd %8 %19 %20 OpReturnValue %21 OpFunctionEnd %14 = OpFunction %2 None %75 %78 = OpFunctionParameter %27 %80 = OpFunctionParameter %60 %15 = OpLabel %24 = OpVariable %9 Function OpStore %24 %25 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected_shader, context.get())); } TEST(TransformationAddParameterTest, PointerMoreEntriesInMapTest) { // This types handles case where call_parameter_id has an entry for at least // every caller (there are more entries than it is necessary). std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %10 "fun(i1;" OpName %9 "a" OpName %12 "s" OpName %19 "i1" OpName %21 "i2" OpName %22 "i3" OpName %24 "i4" OpName %25 "param" OpName %28 "i5" OpName %29 "param" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %6 %7 %15 = OpConstant %6 2 %20 = OpConstant %6 1 %23 = OpConstant %6 3 %4 = OpFunction %2 None %3 %5 = OpLabel %19 = OpVariable %7 Function %21 = OpVariable %7 Function %22 = OpVariable %7 Function %24 = OpVariable %7 Function %25 = OpVariable %7 Function %28 = OpVariable %7 Function %29 = OpVariable %7 Function OpStore %19 %20 OpStore %21 %15 OpStore %22 %23 %26 = OpLoad %6 %19 OpStore %25 %26 %27 = OpFunctionCall %6 %10 %25 OpStore %24 %27 %30 = OpLoad %6 %21 OpStore %29 %30 %31 = OpFunctionCall %6 %10 %29 OpStore %28 %31 OpReturn OpFunctionEnd %10 = OpFunction %6 None %8 %9 = OpFunctionParameter %7 %11 = OpLabel %12 = OpVariable %7 Function %13 = OpLoad %6 %9 OpStore %12 %13 %14 = OpLoad %6 %12 %16 = OpIAdd %6 %14 %15 OpReturnValue %16 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Good: Local variable of id 21 is defined in every caller (id 27 and id 31). TransformationAddParameter transformation_good_1( 10, 70, 7, {{{27, 21}, {31, 21}, {30, 21}}}, 71); ASSERT_TRUE(transformation_good_1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Good: Local variable of id 28 is defined in every caller (id 27 and id 31). TransformationAddParameter transformation_good_2( 10, 72, 7, {{{27, 28}, {31, 28}, {14, 21}, {16, 14}}}, 73); ASSERT_TRUE(transformation_good_2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string expected_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %10 "fun(i1;" OpName %9 "a" OpName %12 "s" OpName %19 "i1" OpName %21 "i2" OpName %22 "i3" OpName %24 "i4" OpName %25 "param" OpName %28 "i5" OpName %29 "param" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %15 = OpConstant %6 2 %20 = OpConstant %6 1 %23 = OpConstant %6 3 %8 = OpTypeFunction %6 %7 %7 %7 %4 = OpFunction %2 None %3 %5 = OpLabel %19 = OpVariable %7 Function %21 = OpVariable %7 Function %22 = OpVariable %7 Function %24 = OpVariable %7 Function %25 = OpVariable %7 Function %28 = OpVariable %7 Function %29 = OpVariable %7 Function OpStore %19 %20 OpStore %21 %15 OpStore %22 %23 %26 = OpLoad %6 %19 OpStore %25 %26 %27 = OpFunctionCall %6 %10 %25 %21 %28 OpStore %24 %27 %30 = OpLoad %6 %21 OpStore %29 %30 %31 = OpFunctionCall %6 %10 %29 %21 %28 OpStore %28 %31 OpReturn OpFunctionEnd %10 = OpFunction %6 None %8 %9 = OpFunctionParameter %7 %70 = OpFunctionParameter %7 %72 = OpFunctionParameter %7 %11 = OpLabel %12 = OpVariable %7 Function %13 = OpLoad %6 %9 OpStore %12 %13 %14 = OpLoad %6 %12 %16 = OpIAdd %6 %14 %15 OpReturnValue %16 OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected_shader, context.get())); } TEST(TransformationAddParameterTest, PointeeValueIsIrrelevantTest) { // This test checks if the transformation has correctly applied the // PointeeValueIsIrrelevant fact for new pointer parameters. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %10 "fun(i1;" OpName %9 "a" OpName %12 "s" OpName %20 "b" OpName %22 "i1" OpName %24 "i2" OpName %25 "i3" OpName %26 "param" OpName %29 "i4" OpName %30 "param" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %50 = OpTypePointer Workgroup %6 %51 = OpVariable %50 Workgroup %8 = OpTypeFunction %6 %7 %15 = OpConstant %6 2 %19 = OpTypePointer Private %6 %20 = OpVariable %19 Private %21 = OpConstant %6 0 %23 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %22 = OpVariable %7 Function %24 = OpVariable %7 Function %25 = OpVariable %7 Function %26 = OpVariable %7 Function %29 = OpVariable %7 Function %30 = OpVariable %7 Function OpStore %20 %21 OpStore %22 %23 OpStore %24 %15 %27 = OpLoad %6 %22 OpStore %26 %27 %28 = OpFunctionCall %6 %10 %26 OpStore %25 %28 %31 = OpLoad %6 %24 OpStore %30 %31 %32 = OpFunctionCall %6 %10 %30 OpStore %29 %32 OpReturn OpFunctionEnd %10 = OpFunction %6 None %8 %9 = OpFunctionParameter %7 %11 = OpLabel %12 = OpVariable %7 Function %13 = OpLoad %6 %9 OpStore %12 %13 %14 = OpLoad %6 %12 %16 = OpIAdd %6 %14 %15 OpReturnValue %16 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationAddParameter transformation_good_1(10, 70, 7, {{{28, 22}, {32, 22}}}, 71); ASSERT_TRUE(transformation_good_1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Check if the fact PointeeValueIsIrrelevant is set for the new parameter // (storage class Function). ASSERT_TRUE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(70)); TransformationAddParameter transformation_good_2(10, 72, 19, {{{28, 20}, {32, 20}}}, 73); ASSERT_TRUE(transformation_good_2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Check if the fact PointeeValueIsIrrelevant is set for the new parameter // (storage class Private). ASSERT_TRUE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(72)); TransformationAddParameter transformation_good_3(10, 74, 50, {{{28, 51}, {32, 51}}}, 75); ASSERT_TRUE(transformation_good_3.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_3, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Check if the fact PointeeValueIsIrrelevant is set for the new parameter // (storage class Workgroup). ASSERT_TRUE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(74)); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_add_relaxed_decoration_test.cpp000066400000000000000000000123701475742701700320450ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_relaxed_decoration.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationAddRelaxedDecorationTest, BasicScenarios) { // This is a simple transformation and this test handles the main cases. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "a" OpName %10 "b" OpName %14 "c" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 4 %11 = OpConstant %6 6 %12 = OpTypeBool %13 = OpTypePointer Function %12 %15 = OpConstantTrue %12 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %14 = OpVariable %13 Function OpStore %8 %9 OpStore %10 %11 OpStore %14 %15 OpSelectionMerge %19 None OpBranchConditional %15 %19 %100 %100 = OpLabel %25 = OpISub %6 %9 %11 %28 = OpLogicalNot %12 %15 OpBranch %19 %19 = OpLabel %27 = OpISub %6 %9 %11 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactBlockIsDead(100); // Invalid: 200 is not an id. ASSERT_FALSE(TransformationAddRelaxedDecoration(200).IsApplicable( context.get(), transformation_context)); // Invalid: 1 is not in a block. ASSERT_FALSE(TransformationAddRelaxedDecoration(1).IsApplicable( context.get(), transformation_context)); // Invalid: 27 is not in a dead block. ASSERT_FALSE(TransformationAddRelaxedDecoration(27).IsApplicable( context.get(), transformation_context)); // Invalid: 28 is in a dead block, but returns bool (not numeric). ASSERT_FALSE(TransformationAddRelaxedDecoration(28).IsApplicable( context.get(), transformation_context)); // It is valid to add RelaxedPrecision to 25 for (uint32_t result_id : {25u}) { TransformationAddRelaxedDecoration transformation(result_id); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "a" OpName %10 "b" OpName %14 "c" OpDecorate %25 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 4 %11 = OpConstant %6 6 %12 = OpTypeBool %13 = OpTypePointer Function %12 %15 = OpConstantTrue %12 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %14 = OpVariable %13 Function OpStore %8 %9 OpStore %10 %11 OpStore %14 %15 OpSelectionMerge %19 None OpBranchConditional %15 %19 %100 %100 = OpLabel %25 = OpISub %6 %9 %11 %28 = OpLogicalNot %12 %15 OpBranch %19 %19 = OpLabel %27 = OpISub %6 %9 %11 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_add_synonym_test.cpp000066400000000000000000001656631475742701700277440ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_synonym.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationAddSynonymTest, NotApplicable) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %8 RelaxedPrecision OpDecorate %22 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 3 %10 = OpTypeFloat 32 %11 = OpTypePointer Function %10 %13 = OpConstant %10 4.5 %14 = OpTypeVector %10 2 %15 = OpTypePointer Function %14 %17 = OpConstant %10 3 %18 = OpConstant %10 4 %19 = OpConstantComposite %14 %17 %18 %20 = OpTypeVector %6 2 %21 = OpTypePointer Function %20 %23 = OpConstant %6 4 %24 = OpConstantComposite %20 %9 %23 %26 = OpConstantNull %6 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %12 = OpVariable %11 Function %16 = OpVariable %15 Function %22 = OpVariable %21 Function OpStore %8 %9 OpStore %12 %13 OpStore %16 %19 OpStore %22 %24 %25 = OpUndef %6 %27 = OpLoad %6 %8 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactIdIsIrrelevant(24); auto insert_before = MakeInstructionDescriptor(22, spv::Op::OpReturn, 0); #ifndef NDEBUG ASSERT_DEATH( TransformationAddSynonym( 9, static_cast(-1), 40, insert_before) .IsApplicable(context.get(), transformation_context), "Synonym type is invalid"); #endif // These tests should succeed regardless of the synonym type. for (int i = 0; i < protobufs::TransformationAddSynonym::SynonymType_descriptor() ->value_count(); ++i) { const auto* synonym_value = protobufs::TransformationAddSynonym::SynonymType_descriptor()->value(i); ASSERT_TRUE(protobufs::TransformationAddSynonym::SynonymType_IsValid( synonym_value->number())); auto synonym_type = static_cast( synonym_value->number()); // |synonym_fresh_id| is not fresh. ASSERT_FALSE(TransformationAddSynonym(9, synonym_type, 9, insert_before) .IsApplicable(context.get(), transformation_context)); // |result_id| is invalid. ASSERT_FALSE(TransformationAddSynonym(40, synonym_type, 40, insert_before) .IsApplicable(context.get(), transformation_context)); // Instruction with |result_id| has no type id. ASSERT_FALSE(TransformationAddSynonym(5, synonym_type, 40, insert_before) .IsApplicable(context.get(), transformation_context)); // Instruction with |result_id| is an OpUndef. ASSERT_FALSE(TransformationAddSynonym(25, synonym_type, 40, insert_before) .IsApplicable(context.get(), transformation_context)); // Instruction with |result_id| is an OpConstantNull. ASSERT_FALSE(TransformationAddSynonym(26, synonym_type, 40, insert_before) .IsApplicable(context.get(), transformation_context)); // |result_id| is irrelevant. ASSERT_FALSE(TransformationAddSynonym(24, synonym_type, 40, insert_before) .IsApplicable(context.get(), transformation_context)); // |insert_before| is invalid. ASSERT_FALSE(TransformationAddSynonym( 9, synonym_type, 40, MakeInstructionDescriptor(25, spv::Op::OpStore, 0)) .IsApplicable(context.get(), transformation_context)); // Can't insert before |insert_before|. ASSERT_FALSE(TransformationAddSynonym( 9, synonym_type, 40, MakeInstructionDescriptor(5, spv::Op::OpLabel, 0)) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationAddSynonym( 9, synonym_type, 40, MakeInstructionDescriptor(22, spv::Op::OpVariable, 0)) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationAddSynonym( 9, synonym_type, 40, MakeInstructionDescriptor(25, spv::Op::OpFunctionEnd, 0)) .IsApplicable(context.get(), transformation_context)); // Domination rules are not satisfied. ASSERT_FALSE(TransformationAddSynonym( 27, synonym_type, 40, MakeInstructionDescriptor(27, spv::Op::OpLoad, 0)) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationAddSynonym( 27, synonym_type, 40, MakeInstructionDescriptor(22, spv::Op::OpStore, 1)) .IsApplicable(context.get(), transformation_context)); } } TEST(TransformationAddSynonymTest, AddZeroSubZeroMulOne) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpConstant %6 0 %8 = OpConstant %6 1 %9 = OpConstant %6 34 %10 = OpTypeInt 32 0 %13 = OpConstant %10 34 %14 = OpTypeFloat 32 %15 = OpConstant %14 0 %16 = OpConstant %14 1 %17 = OpConstant %14 34 %18 = OpTypeVector %14 2 %19 = OpConstantComposite %18 %15 %15 %20 = OpConstantComposite %18 %16 %16 %21 = OpConstant %14 3 %22 = OpConstant %14 4 %23 = OpConstantComposite %18 %21 %22 %24 = OpTypeVector %6 2 %25 = OpConstantComposite %24 %7 %7 %26 = OpConstantComposite %24 %8 %8 %27 = OpConstant %6 3 %28 = OpConstant %6 4 %29 = OpConstantComposite %24 %27 %28 %30 = OpTypeVector %10 2 %33 = OpConstant %10 3 %34 = OpConstant %10 4 %35 = OpConstantComposite %30 %33 %34 %36 = OpTypeBool %37 = OpTypeVector %36 2 %38 = OpConstantTrue %36 %39 = OpConstantComposite %37 %38 %38 %40 = OpConstant %6 37 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto insert_before = MakeInstructionDescriptor(5, spv::Op::OpReturn, 0); uint32_t fresh_id = 50; for (auto synonym_type : {protobufs::TransformationAddSynonym::ADD_ZERO, protobufs::TransformationAddSynonym::SUB_ZERO, protobufs::TransformationAddSynonym::MUL_ONE}) { ASSERT_TRUE( TransformationAddSynonym::IsAdditionalConstantRequired(synonym_type)); // Can't create a synonym of a scalar or a vector of a wrong (in this case - // boolean) type. ASSERT_FALSE( TransformationAddSynonym(38, synonym_type, fresh_id, insert_before) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( TransformationAddSynonym(39, synonym_type, fresh_id, insert_before) .IsApplicable(context.get(), transformation_context)); // Required constant is not present in the module. ASSERT_FALSE( TransformationAddSynonym(13, synonym_type, fresh_id, insert_before) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( TransformationAddSynonym(35, synonym_type, fresh_id, insert_before) .IsApplicable(context.get(), transformation_context)); for (auto result_id : {9, 17, 23, 29}) { TransformationAddSynonym transformation(result_id, synonym_type, fresh_id, insert_before); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(result_id, {}), MakeDataDescriptor(fresh_id, {}))); ++fresh_id; } } { TransformationAddSynonym transformation( 40, protobufs::TransformationAddSynonym::BITWISE_OR, fresh_id, insert_before); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(40, {}), MakeDataDescriptor(fresh_id, {}))); ++fresh_id; } { TransformationAddSynonym transformation( 40, protobufs::TransformationAddSynonym::BITWISE_XOR, fresh_id, insert_before); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(40, {}), MakeDataDescriptor(fresh_id, {}))); } std::string expected_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpConstant %6 0 %8 = OpConstant %6 1 %9 = OpConstant %6 34 %10 = OpTypeInt 32 0 %13 = OpConstant %10 34 %14 = OpTypeFloat 32 %15 = OpConstant %14 0 %16 = OpConstant %14 1 %17 = OpConstant %14 34 %18 = OpTypeVector %14 2 %19 = OpConstantComposite %18 %15 %15 %20 = OpConstantComposite %18 %16 %16 %21 = OpConstant %14 3 %22 = OpConstant %14 4 %23 = OpConstantComposite %18 %21 %22 %24 = OpTypeVector %6 2 %25 = OpConstantComposite %24 %7 %7 %26 = OpConstantComposite %24 %8 %8 %27 = OpConstant %6 3 %28 = OpConstant %6 4 %29 = OpConstantComposite %24 %27 %28 %30 = OpTypeVector %10 2 %33 = OpConstant %10 3 %34 = OpConstant %10 4 %35 = OpConstantComposite %30 %33 %34 %36 = OpTypeBool %37 = OpTypeVector %36 2 %38 = OpConstantTrue %36 %39 = OpConstantComposite %37 %38 %38 %40 = OpConstant %6 37 %4 = OpFunction %2 None %3 %5 = OpLabel %50 = OpIAdd %6 %9 %7 %51 = OpFAdd %14 %17 %15 %52 = OpFAdd %18 %23 %19 %53 = OpIAdd %24 %29 %25 %54 = OpISub %6 %9 %7 %55 = OpFSub %14 %17 %15 %56 = OpFSub %18 %23 %19 %57 = OpISub %24 %29 %25 %58 = OpIMul %6 %9 %8 %59 = OpFMul %14 %17 %16 %60 = OpFMul %18 %23 %20 %61 = OpIMul %24 %29 %26 %62 = OpBitwiseOr %6 %40 %7 %63 = OpBitwiseXor %6 %40 %7 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected_shader, context.get())); } TEST(TransformationAddSynonymTest, LogicalAndLogicalOr) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantFalse %6 %9 = OpConstantTrue %6 %10 = OpTypeVector %6 2 %11 = OpConstantComposite %10 %7 %9 %12 = OpConstantComposite %10 %7 %7 %13 = OpConstantComposite %10 %9 %9 %14 = OpTypeFloat 32 %17 = OpConstant %14 35 %18 = OpTypeVector %14 2 %21 = OpConstant %14 3 %22 = OpConstant %14 4 %23 = OpConstantComposite %18 %21 %22 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto insert_before = MakeInstructionDescriptor(5, spv::Op::OpReturn, 0); uint32_t fresh_id = 50; for (auto synonym_type : {protobufs::TransformationAddSynonym::LOGICAL_AND, protobufs::TransformationAddSynonym::LOGICAL_OR}) { ASSERT_TRUE( TransformationAddSynonym::IsAdditionalConstantRequired(synonym_type)); // Can't create a synonym of a scalar or a vector of a wrong (in this case - // float) type. ASSERT_FALSE( TransformationAddSynonym(17, synonym_type, fresh_id, insert_before) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( TransformationAddSynonym(23, synonym_type, fresh_id, insert_before) .IsApplicable(context.get(), transformation_context)); for (auto result_id : {9, 11}) { TransformationAddSynonym transformation(result_id, synonym_type, fresh_id, insert_before); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(result_id, {}), MakeDataDescriptor(fresh_id, {}))); ++fresh_id; } } std::string expected_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantFalse %6 %9 = OpConstantTrue %6 %10 = OpTypeVector %6 2 %11 = OpConstantComposite %10 %7 %9 %12 = OpConstantComposite %10 %7 %7 %13 = OpConstantComposite %10 %9 %9 %14 = OpTypeFloat 32 %17 = OpConstant %14 35 %18 = OpTypeVector %14 2 %21 = OpConstant %14 3 %22 = OpConstant %14 4 %23 = OpConstantComposite %18 %21 %22 %4 = OpFunction %2 None %3 %5 = OpLabel %50 = OpLogicalAnd %6 %9 %9 %51 = OpLogicalAnd %10 %11 %13 %52 = OpLogicalOr %6 %9 %7 %53 = OpLogicalOr %10 %11 %12 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected_shader, context.get())); } TEST(TransformationAddSynonymTest, LogicalAndConstantIsNotPresent) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantFalse %6 %10 = OpTypeVector %6 2 %12 = OpConstantComposite %10 %7 %7 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto insert_before = MakeInstructionDescriptor(5, spv::Op::OpReturn, 0); const auto synonym_type = protobufs::TransformationAddSynonym::LOGICAL_AND; // Required constant is not present in the module. ASSERT_FALSE(TransformationAddSynonym(7, synonym_type, 50, insert_before) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationAddSynonym(12, synonym_type, 50, insert_before) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationAddSynonymTest, LogicalOrConstantIsNotPresent) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantTrue %6 %10 = OpTypeVector %6 2 %12 = OpConstantComposite %10 %7 %7 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto insert_before = MakeInstructionDescriptor(5, spv::Op::OpReturn, 0); const auto synonym_type = protobufs::TransformationAddSynonym::LOGICAL_OR; // Required constant is not present in the module. ASSERT_FALSE(TransformationAddSynonym(7, synonym_type, 50, insert_before) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationAddSynonym(12, synonym_type, 50, insert_before) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationAddSynonymTest, CopyObject) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %8 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 4 %10 = OpTypeFloat 32 %11 = OpTypePointer Function %10 %13 = OpConstant %10 4 %14 = OpTypeVector %10 2 %15 = OpTypePointer Function %14 %17 = OpConstant %10 3.4000001 %18 = OpConstantComposite %14 %17 %17 %19 = OpTypeBool %20 = OpTypeStruct %19 %21 = OpTypePointer Function %20 %23 = OpConstantTrue %19 %24 = OpConstantComposite %20 %23 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %12 = OpVariable %11 Function %16 = OpVariable %15 Function %22 = OpVariable %21 Function OpStore %8 %9 OpStore %12 %13 OpStore %16 %18 OpStore %22 %24 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto insert_before = MakeInstructionDescriptor(5, spv::Op::OpReturn, 0); const auto synonym_type = protobufs::TransformationAddSynonym::COPY_OBJECT; ASSERT_FALSE( TransformationAddSynonym::IsAdditionalConstantRequired(synonym_type)); uint32_t fresh_id = 50; for (auto result_id : {9, 13, 17, 18, 23, 24, 22}) { TransformationAddSynonym transformation(result_id, synonym_type, fresh_id, insert_before); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(result_id, {}), MakeDataDescriptor(fresh_id, {}))); ++fresh_id; } std::string expected_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %8 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 4 %10 = OpTypeFloat 32 %11 = OpTypePointer Function %10 %13 = OpConstant %10 4 %14 = OpTypeVector %10 2 %15 = OpTypePointer Function %14 %17 = OpConstant %10 3.4000001 %18 = OpConstantComposite %14 %17 %17 %19 = OpTypeBool %20 = OpTypeStruct %19 %21 = OpTypePointer Function %20 %23 = OpConstantTrue %19 %24 = OpConstantComposite %20 %23 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %12 = OpVariable %11 Function %16 = OpVariable %15 Function %22 = OpVariable %21 Function OpStore %8 %9 OpStore %12 %13 OpStore %16 %18 OpStore %22 %24 %50 = OpCopyObject %6 %9 %51 = OpCopyObject %10 %13 %52 = OpCopyObject %10 %17 %53 = OpCopyObject %14 %18 %54 = OpCopyObject %19 %23 %55 = OpCopyObject %20 %24 %56 = OpCopyObject %21 %22 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected_shader, context.get())); } TEST(TransformationAddSynonymTest, CopyBooleanConstants) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %6 = OpTypeBool %7 = OpConstantTrue %6 %8 = OpConstantFalse %6 %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_EQ(0, transformation_context.GetFactManager() ->GetIdsForWhichSynonymsAreKnown() .size()); { TransformationAddSynonym copy_true( 7, protobufs::TransformationAddSynonym::COPY_OBJECT, 100, MakeInstructionDescriptor(5, spv::Op::OpReturn, 0)); ASSERT_TRUE(copy_true.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(copy_true, context.get(), &transformation_context); std::vector ids_for_which_synonyms_are_known = transformation_context.GetFactManager() ->GetIdsForWhichSynonymsAreKnown(); ASSERT_EQ(2, ids_for_which_synonyms_are_known.size()); ASSERT_TRUE(std::find(ids_for_which_synonyms_are_known.begin(), ids_for_which_synonyms_are_known.end(), 7) != ids_for_which_synonyms_are_known.end()); ASSERT_EQ( 2, transformation_context.GetFactManager()->GetSynonymsForId(7).size()); protobufs::DataDescriptor descriptor_100 = MakeDataDescriptor(100, {}); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(7, {}), descriptor_100)); } { TransformationAddSynonym copy_false( 8, protobufs::TransformationAddSynonym::COPY_OBJECT, 101, MakeInstructionDescriptor(100, spv::Op::OpReturn, 0)); ASSERT_TRUE(copy_false.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(copy_false, context.get(), &transformation_context); std::vector ids_for_which_synonyms_are_known = transformation_context.GetFactManager() ->GetIdsForWhichSynonymsAreKnown(); ASSERT_EQ(4, ids_for_which_synonyms_are_known.size()); ASSERT_TRUE(std::find(ids_for_which_synonyms_are_known.begin(), ids_for_which_synonyms_are_known.end(), 8) != ids_for_which_synonyms_are_known.end()); ASSERT_EQ( 2, transformation_context.GetFactManager()->GetSynonymsForId(8).size()); protobufs::DataDescriptor descriptor_101 = MakeDataDescriptor(101, {}); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(8, {}), descriptor_101)); } { TransformationAddSynonym copy_false_again( 101, protobufs::TransformationAddSynonym::COPY_OBJECT, 102, MakeInstructionDescriptor(5, spv::Op::OpReturn, 0)); ASSERT_TRUE( copy_false_again.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(copy_false_again, context.get(), &transformation_context); std::vector ids_for_which_synonyms_are_known = transformation_context.GetFactManager() ->GetIdsForWhichSynonymsAreKnown(); ASSERT_EQ(5, ids_for_which_synonyms_are_known.size()); ASSERT_TRUE(std::find(ids_for_which_synonyms_are_known.begin(), ids_for_which_synonyms_are_known.end(), 101) != ids_for_which_synonyms_are_known.end()); ASSERT_EQ( 3, transformation_context.GetFactManager()->GetSynonymsForId(101).size()); protobufs::DataDescriptor descriptor_102 = MakeDataDescriptor(102, {}); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(101, {}), descriptor_102)); } { TransformationAddSynonym copy_true_again( 7, protobufs::TransformationAddSynonym::COPY_OBJECT, 103, MakeInstructionDescriptor(102, spv::Op::OpReturn, 0)); ASSERT_TRUE( copy_true_again.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(copy_true_again, context.get(), &transformation_context); std::vector ids_for_which_synonyms_are_known = transformation_context.GetFactManager() ->GetIdsForWhichSynonymsAreKnown(); ASSERT_EQ(6, ids_for_which_synonyms_are_known.size()); ASSERT_TRUE(std::find(ids_for_which_synonyms_are_known.begin(), ids_for_which_synonyms_are_known.end(), 7) != ids_for_which_synonyms_are_known.end()); ASSERT_EQ( 3, transformation_context.GetFactManager()->GetSynonymsForId(7).size()); protobufs::DataDescriptor descriptor_103 = MakeDataDescriptor(103, {}); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(7, {}), descriptor_103)); } std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %6 = OpTypeBool %7 = OpConstantTrue %6 %8 = OpConstantFalse %6 %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel %100 = OpCopyObject %6 %7 %101 = OpCopyObject %6 %8 %102 = OpCopyObject %6 %101 %103 = OpCopyObject %6 %7 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationAddSynonymTest, CheckIllegalCases) { // The following SPIR-V comes from this GLSL, pushed through spirv-opt // and then doctored a bit. // // #version 310 es // // precision highp float; // // struct S { // int a; // float b; // }; // // layout(set = 0, binding = 2) uniform block { // S s; // lowp float f; // int ii; // } ubuf; // // layout(location = 0) out vec4 color; // // void main() { // float c = 0.0; // lowp float d = 0.0; // S localS = ubuf.s; // for (int i = 0; i < ubuf.s.a; i++) { // switch (ubuf.ii) { // case 0: // c += 0.1; // d += 0.2; // case 1: // c += 0.1; // if (c > d) { // d += 0.2; // } else { // d += c; // } // break; // default: // i += 1; // localS.b += d; // } // } // color = vec4(c, d, localS.b, 1.0); // } std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %80 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %12 "S" OpMemberName %12 0 "a" OpMemberName %12 1 "b" OpName %15 "S" OpMemberName %15 0 "a" OpMemberName %15 1 "b" OpName %16 "block" OpMemberName %16 0 "s" OpMemberName %16 1 "f" OpMemberName %16 2 "ii" OpName %18 "ubuf" OpName %80 "color" OpMemberDecorate %12 0 RelaxedPrecision OpMemberDecorate %15 0 RelaxedPrecision OpMemberDecorate %15 0 Offset 0 OpMemberDecorate %15 1 Offset 4 OpMemberDecorate %16 0 Offset 0 OpMemberDecorate %16 1 RelaxedPrecision OpMemberDecorate %16 1 Offset 16 OpMemberDecorate %16 2 RelaxedPrecision OpMemberDecorate %16 2 Offset 20 OpDecorate %16 Block OpDecorate %18 DescriptorSet 0 OpDecorate %18 Binding 2 OpDecorate %38 RelaxedPrecision OpDecorate %43 RelaxedPrecision OpDecorate %53 RelaxedPrecision OpDecorate %62 RelaxedPrecision OpDecorate %69 RelaxedPrecision OpDecorate %77 RelaxedPrecision OpDecorate %80 Location 0 OpDecorate %101 RelaxedPrecision OpDecorate %102 RelaxedPrecision OpDecorate %96 RelaxedPrecision OpDecorate %108 RelaxedPrecision OpDecorate %107 RelaxedPrecision OpDecorate %98 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %9 = OpConstant %6 0 %11 = OpTypeInt 32 1 %12 = OpTypeStruct %11 %6 %15 = OpTypeStruct %11 %6 %16 = OpTypeStruct %15 %6 %11 %17 = OpTypePointer Uniform %16 %18 = OpVariable %17 Uniform %19 = OpConstant %11 0 %20 = OpTypePointer Uniform %15 %27 = OpConstant %11 1 %36 = OpTypePointer Uniform %11 %39 = OpTypeBool %41 = OpConstant %11 2 %48 = OpConstant %6 0.100000001 %51 = OpConstant %6 0.200000003 %78 = OpTypeVector %6 4 %79 = OpTypePointer Output %78 %80 = OpVariable %79 Output %85 = OpConstant %6 1 %95 = OpUndef %12 %112 = OpTypePointer Uniform %6 %113 = OpTypeInt 32 0 %114 = OpConstant %113 1 %179 = OpTypePointer Function %39 %4 = OpFunction %2 None %3 %5 = OpLabel %180 = OpVariable %179 Function %181 = OpVariable %179 Function %182 = OpVariable %179 Function %21 = OpAccessChain %20 %18 %19 %115 = OpAccessChain %112 %21 %114 %116 = OpLoad %6 %115 %90 = OpCompositeInsert %12 %116 %95 1 OpBranch %30 %30 = OpLabel %99 = OpPhi %12 %90 %5 %109 %47 %98 = OpPhi %6 %9 %5 %107 %47 %97 = OpPhi %6 %9 %5 %105 %47 %96 = OpPhi %11 %19 %5 %77 %47 %37 = OpAccessChain %36 %18 %19 %19 %38 = OpLoad %11 %37 %40 = OpSLessThan %39 %96 %38 OpLoopMerge %32 %47 None OpBranchConditional %40 %31 %32 %31 = OpLabel %42 = OpAccessChain %36 %18 %41 %43 = OpLoad %11 %42 OpSelectionMerge %45 None OpSwitch %43 %46 0 %44 1 %45 %46 = OpLabel %69 = OpIAdd %11 %96 %27 %72 = OpCompositeExtract %6 %99 1 %73 = OpFAdd %6 %72 %98 %93 = OpCompositeInsert %12 %73 %99 1 OpBranch %47 %44 = OpLabel %50 = OpFAdd %6 %97 %48 %53 = OpFAdd %6 %98 %51 OpBranch %45 %45 = OpLabel %101 = OpPhi %6 %98 %31 %53 %44 %100 = OpPhi %6 %97 %31 %50 %44 %55 = OpFAdd %6 %100 %48 %58 = OpFOrdGreaterThan %39 %55 %101 OpSelectionMerge %60 None OpBranchConditional %58 %59 %63 %59 = OpLabel %62 = OpFAdd %6 %101 %51 OpBranch %60 %63 = OpLabel %66 = OpFAdd %6 %101 %55 OpBranch %60 %60 = OpLabel %108 = OpPhi %6 %62 %59 %66 %63 OpBranch %47 %47 = OpLabel %109 = OpPhi %12 %93 %46 %99 %60 %107 = OpPhi %6 %98 %46 %108 %60 %105 = OpPhi %6 %97 %46 %55 %60 %102 = OpPhi %11 %69 %46 %96 %60 %77 = OpIAdd %11 %102 %27 OpBranch %30 %32 = OpLabel %84 = OpCompositeExtract %6 %99 1 %86 = OpCompositeConstruct %78 %97 %98 %84 %85 OpStore %80 %86 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Inapplicable because %18 is decorated. ASSERT_FALSE(TransformationAddSynonym( 18, protobufs::TransformationAddSynonym::COPY_OBJECT, 200, MakeInstructionDescriptor(21, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Inapplicable because %77 is decorated. ASSERT_FALSE(TransformationAddSynonym( 77, protobufs::TransformationAddSynonym::COPY_OBJECT, 200, MakeInstructionDescriptor(77, spv::Op::OpBranch, 0)) .IsApplicable(context.get(), transformation_context)); // Inapplicable because %80 is decorated. ASSERT_FALSE(TransformationAddSynonym( 80, protobufs::TransformationAddSynonym::COPY_OBJECT, 200, MakeInstructionDescriptor(77, spv::Op::OpIAdd, 0)) .IsApplicable(context.get(), transformation_context)); // Inapplicable because %84 is not available at the requested point ASSERT_FALSE( TransformationAddSynonym( 84, protobufs::TransformationAddSynonym::COPY_OBJECT, 200, MakeInstructionDescriptor(32, spv::Op::OpCompositeExtract, 0)) .IsApplicable(context.get(), transformation_context)); // Fine because %84 is available at the requested point ASSERT_TRUE( TransformationAddSynonym( 84, protobufs::TransformationAddSynonym::COPY_OBJECT, 200, MakeInstructionDescriptor(32, spv::Op::OpCompositeConstruct, 0)) .IsApplicable(context.get(), transformation_context)); // Inapplicable because id %9 is already in use ASSERT_FALSE( TransformationAddSynonym( 84, protobufs::TransformationAddSynonym::COPY_OBJECT, 9, MakeInstructionDescriptor(32, spv::Op::OpCompositeConstruct, 0)) .IsApplicable(context.get(), transformation_context)); // Inapplicable because the requested point does not exist ASSERT_FALSE(TransformationAddSynonym( 84, protobufs::TransformationAddSynonym::COPY_OBJECT, 200, MakeInstructionDescriptor(86, spv::Op::OpReturn, 2)) .IsApplicable(context.get(), transformation_context)); // Inapplicable because %9 is not in a function ASSERT_FALSE(TransformationAddSynonym( 9, protobufs::TransformationAddSynonym::COPY_OBJECT, 200, MakeInstructionDescriptor(9, spv::Op::OpTypeInt, 0)) .IsApplicable(context.get(), transformation_context)); // Inapplicable because the insert point is right before, or inside, a chunk // of OpPhis ASSERT_FALSE(TransformationAddSynonym( 9, protobufs::TransformationAddSynonym::COPY_OBJECT, 200, MakeInstructionDescriptor(30, spv::Op::OpPhi, 0)) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationAddSynonym( 9, protobufs::TransformationAddSynonym::COPY_OBJECT, 200, MakeInstructionDescriptor(99, spv::Op::OpPhi, 1)) .IsApplicable(context.get(), transformation_context)); // OK, because the insert point is just after a chunk of OpPhis. ASSERT_TRUE(TransformationAddSynonym( 9, protobufs::TransformationAddSynonym::COPY_OBJECT, 200, MakeInstructionDescriptor(96, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Inapplicable because the insert point is right after an OpSelectionMerge ASSERT_FALSE( TransformationAddSynonym( 9, protobufs::TransformationAddSynonym::COPY_OBJECT, 200, MakeInstructionDescriptor(58, spv::Op::OpBranchConditional, 0)) .IsApplicable(context.get(), transformation_context)); // OK, because the insert point is right before the OpSelectionMerge ASSERT_TRUE(TransformationAddSynonym( 9, protobufs::TransformationAddSynonym::COPY_OBJECT, 200, MakeInstructionDescriptor(58, spv::Op::OpSelectionMerge, 0)) .IsApplicable(context.get(), transformation_context)); // Inapplicable because the insert point is right after an OpSelectionMerge ASSERT_FALSE(TransformationAddSynonym( 9, protobufs::TransformationAddSynonym::COPY_OBJECT, 200, MakeInstructionDescriptor(43, spv::Op::OpSwitch, 0)) .IsApplicable(context.get(), transformation_context)); // OK, because the insert point is right before the OpSelectionMerge ASSERT_TRUE(TransformationAddSynonym( 9, protobufs::TransformationAddSynonym::COPY_OBJECT, 200, MakeInstructionDescriptor(43, spv::Op::OpSelectionMerge, 0)) .IsApplicable(context.get(), transformation_context)); // Inapplicable because the insert point is right after an OpLoopMerge ASSERT_FALSE( TransformationAddSynonym( 9, protobufs::TransformationAddSynonym::COPY_OBJECT, 200, MakeInstructionDescriptor(40, spv::Op::OpBranchConditional, 0)) .IsApplicable(context.get(), transformation_context)); // OK, because the insert point is right before the OpLoopMerge ASSERT_TRUE(TransformationAddSynonym( 9, protobufs::TransformationAddSynonym::COPY_OBJECT, 200, MakeInstructionDescriptor(40, spv::Op::OpLoopMerge, 0)) .IsApplicable(context.get(), transformation_context)); // Inapplicable because id %300 does not exist ASSERT_FALSE(TransformationAddSynonym( 300, protobufs::TransformationAddSynonym::COPY_OBJECT, 200, MakeInstructionDescriptor(40, spv::Op::OpLoopMerge, 0)) .IsApplicable(context.get(), transformation_context)); // Inapplicable because the following instruction is OpVariable ASSERT_FALSE(TransformationAddSynonym( 9, protobufs::TransformationAddSynonym::COPY_OBJECT, 200, MakeInstructionDescriptor(180, spv::Op::OpVariable, 0)) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationAddSynonym( 9, protobufs::TransformationAddSynonym::COPY_OBJECT, 200, MakeInstructionDescriptor(181, spv::Op::OpVariable, 0)) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationAddSynonym( 9, protobufs::TransformationAddSynonym::COPY_OBJECT, 200, MakeInstructionDescriptor(182, spv::Op::OpVariable, 0)) .IsApplicable(context.get(), transformation_context)); // OK, because this is just past the group of OpVariable instructions. ASSERT_TRUE(TransformationAddSynonym( 9, protobufs::TransformationAddSynonym::COPY_OBJECT, 200, MakeInstructionDescriptor(182, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationAddSynonymTest, MiscellaneousCopies) { // The following SPIR-V comes from this GLSL: // // #version 310 es // // precision highp float; // // float g; // // vec4 h; // // void main() { // int a; // int b; // b = int(g); // h.x = float(a); // } std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "b" OpName %11 "g" OpName %16 "h" OpName %17 "a" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpTypeFloat 32 %10 = OpTypePointer Private %9 %11 = OpVariable %10 Private %14 = OpTypeVector %9 4 %15 = OpTypePointer Private %14 %16 = OpVariable %15 Private %20 = OpTypeInt 32 0 %21 = OpConstant %20 0 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %17 = OpVariable %7 Function %12 = OpLoad %9 %11 %13 = OpConvertFToS %6 %12 OpStore %8 %13 %18 = OpLoad %6 %17 %19 = OpConvertSToF %9 %18 %22 = OpAccessChain %10 %16 %21 OpStore %22 %19 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); std::vector transformations = { TransformationAddSynonym( 19, protobufs::TransformationAddSynonym::COPY_OBJECT, 100, MakeInstructionDescriptor(22, spv::Op::OpStore, 0)), TransformationAddSynonym( 22, protobufs::TransformationAddSynonym::COPY_OBJECT, 101, MakeInstructionDescriptor(22, spv::Op::OpCopyObject, 0)), TransformationAddSynonym( 12, protobufs::TransformationAddSynonym::COPY_OBJECT, 102, MakeInstructionDescriptor(22, spv::Op::OpCopyObject, 0)), TransformationAddSynonym( 11, protobufs::TransformationAddSynonym::COPY_OBJECT, 103, MakeInstructionDescriptor(22, spv::Op::OpCopyObject, 0)), TransformationAddSynonym( 16, protobufs::TransformationAddSynonym::COPY_OBJECT, 104, MakeInstructionDescriptor(22, spv::Op::OpCopyObject, 0)), TransformationAddSynonym( 8, protobufs::TransformationAddSynonym::COPY_OBJECT, 105, MakeInstructionDescriptor(22, spv::Op::OpCopyObject, 0)), TransformationAddSynonym( 17, protobufs::TransformationAddSynonym::COPY_OBJECT, 106, MakeInstructionDescriptor(22, spv::Op::OpCopyObject, 0))}; for (auto& transformation : transformations) { ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "b" OpName %11 "g" OpName %16 "h" OpName %17 "a" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpTypeFloat 32 %10 = OpTypePointer Private %9 %11 = OpVariable %10 Private %14 = OpTypeVector %9 4 %15 = OpTypePointer Private %14 %16 = OpVariable %15 Private %20 = OpTypeInt 32 0 %21 = OpConstant %20 0 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %17 = OpVariable %7 Function %12 = OpLoad %9 %11 %13 = OpConvertFToS %6 %12 OpStore %8 %13 %18 = OpLoad %6 %17 %19 = OpConvertSToF %9 %18 %22 = OpAccessChain %10 %16 %21 %106 = OpCopyObject %7 %17 %105 = OpCopyObject %7 %8 %104 = OpCopyObject %15 %16 %103 = OpCopyObject %10 %11 %102 = OpCopyObject %9 %12 %101 = OpCopyObject %10 %22 %100 = OpCopyObject %9 %19 OpStore %22 %19 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationAddSynonymTest, DoNotCopyNullPointers) { std::string shader = R"( OpCapability Shader OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpConstantNull %7 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Illegal to copy null. ASSERT_FALSE(TransformationAddSynonym( 8, protobufs::TransformationAddSynonym::COPY_OBJECT, 100, MakeInstructionDescriptor(5, spv::Op::OpReturn, 0)) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationAddSynonymTest, PropagateIrrelevantPointeeFact) { // Checks that if a pointer is known to have an irrelevant value, the same // holds after the pointer is copied. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %9 = OpVariable %7 Function OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactValueOfPointeeIsIrrelevant(8); TransformationAddSynonym transformation1( 8, protobufs::TransformationAddSynonym::COPY_OBJECT, 100, MakeInstructionDescriptor(9, spv::Op::OpReturn, 0)); TransformationAddSynonym transformation2( 9, protobufs::TransformationAddSynonym::COPY_OBJECT, 101, MakeInstructionDescriptor(9, spv::Op::OpReturn, 0)); TransformationAddSynonym transformation3( 100, protobufs::TransformationAddSynonym::COPY_OBJECT, 102, MakeInstructionDescriptor(9, spv::Op::OpReturn, 0)); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); ASSERT_TRUE( transformation3.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation3, context.get(), &transformation_context); ASSERT_TRUE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(8)); ASSERT_TRUE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(100)); ASSERT_TRUE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(102)); ASSERT_FALSE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(9)); ASSERT_FALSE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(101)); } TEST(TransformationAddSynonymTest, DoNotCopyOpSampledImage) { // This checks that we do not try to copy the result id of an OpSampledImage // instruction. std::string shader = R"( OpCapability Shader OpCapability SampledBuffer OpCapability ImageBuffer %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %40 %41 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 450 OpDecorate %40 DescriptorSet 0 OpDecorate %40 Binding 69 OpDecorate %41 DescriptorSet 0 OpDecorate %41 Binding 1 %54 = OpTypeFloat 32 %76 = OpTypeVector %54 4 %55 = OpConstant %54 0 %56 = OpTypeVector %54 3 %94 = OpTypeVector %54 2 %112 = OpConstantComposite %94 %55 %55 %57 = OpConstantComposite %56 %55 %55 %55 %15 = OpTypeImage %54 2D 2 0 0 1 Unknown %114 = OpTypePointer UniformConstant %15 %38 = OpTypeSampler %125 = OpTypePointer UniformConstant %38 %132 = OpTypeVoid %133 = OpTypeFunction %132 %45 = OpTypeSampledImage %15 %40 = OpVariable %114 UniformConstant %41 = OpVariable %125 UniformConstant %2 = OpFunction %132 None %133 %164 = OpLabel %184 = OpLoad %15 %40 %213 = OpLoad %38 %41 %216 = OpSampledImage %45 %184 %213 %217 = OpImageSampleImplicitLod %76 %216 %112 Bias %55 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_FALSE( TransformationAddSynonym( 216, protobufs::TransformationAddSynonym::COPY_OBJECT, 500, MakeInstructionDescriptor(217, spv::Op::OpImageSampleImplicitLod, 0)) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationAddSynonymTest, DoNotCopyVoidRunctionResult) { // This checks that we do not try to copy the result of a void function. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpName %4 "main" OpName %6 "foo(" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpFunctionCall %2 %6 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_FALSE(TransformationAddSynonym( 8, protobufs::TransformationAddSynonym::COPY_OBJECT, 500, MakeInstructionDescriptor(8, spv::Op::OpReturn, 0)) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationAddSynonymTest, HandlesDeadBlocks) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantTrue %6 %11 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %5 = OpLabel %12 = OpVariable %11 Function OpSelectionMerge %10 None OpBranchConditional %7 %8 %9 %8 = OpLabel OpBranch %10 %9 = OpLabel OpBranch %10 %10 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactBlockIsDead(9); auto insert_before = MakeInstructionDescriptor(9, spv::Op::OpBranch, 0); ASSERT_FALSE(TransformationAddSynonym( 7, protobufs::TransformationAddSynonym::COPY_OBJECT, 100, insert_before) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationAddSynonym( 12, protobufs::TransformationAddSynonym::COPY_OBJECT, 100, insert_before) .IsApplicable(context.get(), transformation_context)); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_add_type_array_test.cpp000066400000000000000000000133521475742701700303720ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_type_array.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationAddTypeArrayTest, BasicTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeInt 32 1 %8 = OpTypeVector %6 2 %9 = OpTypeVector %6 3 %10 = OpTypeVector %6 4 %11 = OpTypeVector %7 2 %12 = OpConstant %7 3 %13 = OpConstant %7 0 %14 = OpConstant %7 -1 %15 = OpTypeInt 32 0 %16 = OpConstant %15 5 %17 = OpConstant %15 0 %18 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Id already in use ASSERT_FALSE(TransformationAddTypeArray(4, 10, 16).IsApplicable( context.get(), transformation_context)); // %1 is not a type ASSERT_FALSE(TransformationAddTypeArray(100, 1, 16) .IsApplicable(context.get(), transformation_context)); // %3 is a function type ASSERT_FALSE(TransformationAddTypeArray(100, 3, 16) .IsApplicable(context.get(), transformation_context)); // %2 is not a constant ASSERT_FALSE(TransformationAddTypeArray(100, 11, 2) .IsApplicable(context.get(), transformation_context)); // %18 is not an integer ASSERT_FALSE(TransformationAddTypeArray(100, 11, 18) .IsApplicable(context.get(), transformation_context)); // %13 is signed 0 ASSERT_FALSE(TransformationAddTypeArray(100, 11, 13) .IsApplicable(context.get(), transformation_context)); // %14 is negative ASSERT_FALSE(TransformationAddTypeArray(100, 11, 14) .IsApplicable(context.get(), transformation_context)); // %17 is unsigned 0 ASSERT_FALSE(TransformationAddTypeArray(100, 11, 17) .IsApplicable(context.get(), transformation_context)); { // %100 = OpTypeArray %10 %16 TransformationAddTypeArray transformation(100, 10, 16); ASSERT_EQ(nullptr, context->get_def_use_mgr()->GetDef(100)); ASSERT_EQ(nullptr, context->get_type_mgr()->GetType(100)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_EQ(spv::Op::OpTypeArray, context->get_def_use_mgr()->GetDef(100)->opcode()); ASSERT_NE(nullptr, context->get_type_mgr()->GetType(100)->AsArray()); } { // %101 = OpTypeArray %7 %12 TransformationAddTypeArray transformation(101, 7, 12); ASSERT_EQ(nullptr, context->get_def_use_mgr()->GetDef(101)); ASSERT_EQ(nullptr, context->get_type_mgr()->GetType(101)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_EQ(spv::Op::OpTypeArray, context->get_def_use_mgr()->GetDef(100)->opcode()); ASSERT_NE(nullptr, context->get_type_mgr()->GetType(100)->AsArray()); } ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeInt 32 1 %8 = OpTypeVector %6 2 %9 = OpTypeVector %6 3 %10 = OpTypeVector %6 4 %11 = OpTypeVector %7 2 %12 = OpConstant %7 3 %13 = OpConstant %7 0 %14 = OpConstant %7 -1 %15 = OpTypeInt 32 0 %16 = OpConstant %15 5 %17 = OpConstant %15 0 %18 = OpConstant %6 1 %100 = OpTypeArray %10 %16 %101 = OpTypeArray %7 %12 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_add_type_boolean_test.cpp000066400000000000000000000066351475742701700307010ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_type_boolean.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationAddTypeBooleanTest, BasicTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Not applicable because id 1 is already in use. ASSERT_FALSE(TransformationAddTypeBoolean(1).IsApplicable( context.get(), transformation_context)); auto add_type_bool = TransformationAddTypeBoolean(100); ASSERT_EQ(nullptr, context->get_def_use_mgr()->GetDef(100)); ASSERT_EQ(nullptr, context->get_type_mgr()->GetType(100)); ASSERT_TRUE( add_type_bool.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(add_type_bool, context.get(), &transformation_context); ASSERT_EQ(spv::Op::OpTypeBool, context->get_def_use_mgr()->GetDef(100)->opcode()); ASSERT_NE(nullptr, context->get_type_mgr()->GetType(100)->AsBool()); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Not applicable as we already have this type now. ASSERT_FALSE(TransformationAddTypeBoolean(101).IsApplicable( context.get(), transformation_context)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %100 = OpTypeBool %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_add_type_float_test.cpp000066400000000000000000000140471475742701700303630ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_type_float.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationAddTypeFloatTest, IsApplicable) { std::string reference_shader = R"( OpCapability Shader OpCapability Float16 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %5 "main" ; Types %2 = OpTypeFloat 16 %3 = OpTypeVoid %4 = OpTypeFunction %3 ; main function %5 = OpFunction %3 None %4 %6 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Tests non-fresh id. auto transformation = TransformationAddTypeFloat(1, 32); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests missing Float64 capability. transformation = TransformationAddTypeFloat(7, 64); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // The transformation is not applicable because there is already a 16-bit // float type declared in the module. transformation = TransformationAddTypeFloat(7, 16); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests adding 32-bit float type. transformation = TransformationAddTypeFloat(7, 32); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); // By default, SPIR-V does not support 64-bit float types. // Below we add such capability, so the test should now pass. context.get()->AddCapability(spv::Capability::Float64); ASSERT_TRUE(TransformationAddTypeFloat(7, 64).IsApplicable( context.get(), transformation_context)); #ifndef NDEBUG // Should not be able to add float type of width different from 16/32/64 ASSERT_DEATH(TransformationAddTypeFloat(7, 20).IsApplicable( context.get(), transformation_context), "Unexpected float type width"); #endif } TEST(TransformationAddTypeFloatTest, Apply) { std::string reference_shader = R"( OpCapability Shader OpCapability Float16 OpCapability Float64 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %4 "main" ; Types %2 = OpTypeVoid %3 = OpTypeFunction %2 ; main function %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Adds 16-bit float type. auto transformation = TransformationAddTypeFloat(6, 16); ASSERT_EQ(nullptr, context->get_def_use_mgr()->GetDef(6)); ASSERT_EQ(nullptr, context->get_type_mgr()->GetType(6)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_EQ(spv::Op::OpTypeFloat, context->get_def_use_mgr()->GetDef(6)->opcode()); ASSERT_NE(nullptr, context->get_type_mgr()->GetType(6)->AsFloat()); // Adds 32-bit float type. transformation = TransformationAddTypeFloat(7, 32); ASSERT_EQ(nullptr, context->get_def_use_mgr()->GetDef(7)); ASSERT_EQ(nullptr, context->get_type_mgr()->GetType(7)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_EQ(spv::Op::OpTypeFloat, context->get_def_use_mgr()->GetDef(7)->opcode()); ASSERT_NE(nullptr, context->get_type_mgr()->GetType(7)->AsFloat()); // Adds 64-bit float type. transformation = TransformationAddTypeFloat(8, 64); ASSERT_EQ(nullptr, context->get_def_use_mgr()->GetDef(8)); ASSERT_EQ(nullptr, context->get_type_mgr()->GetType(8)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_EQ(spv::Op::OpTypeFloat, context->get_def_use_mgr()->GetDef(8)->opcode()); ASSERT_NE(nullptr, context->get_type_mgr()->GetType(8)->AsFloat()); std::string variant_shader = R"( OpCapability Shader OpCapability Float16 OpCapability Float64 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %4 "main" ; Types %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 16 %7 = OpTypeFloat 32 %8 = OpTypeFloat 64 ; main function %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(IsEqual(env, variant_shader, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_add_type_function_test.cpp000066400000000000000000000123061475742701700310770ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_type_function.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationAddTypeFunctionTest, BasicTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %2 %7 %12 = OpTypeFloat 32 %13 = OpTypeStruct %6 %12 %14 = OpTypePointer Function %13 %200 = OpTypePointer Function %13 %15 = OpTypeVector %12 3 %16 = OpTypePointer Function %15 %17 = OpTypeVector %12 2 %18 = OpTypeFunction %17 %14 %16 %23 = OpConstant %12 1 %24 = OpConstantComposite %17 %23 %23 %27 = OpConstant %6 3 %30 = OpConstant %6 1 %31 = OpConstant %12 2 %32 = OpConstantComposite %13 %30 %31 %33 = OpConstantComposite %15 %23 %23 %23 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Id already in use ASSERT_FALSE(TransformationAddTypeFunction(4, 12, {12, 16, 14}) .IsApplicable(context.get(), transformation_context)); // %1 is not a type ASSERT_FALSE(TransformationAddTypeFunction(100, 1, {12, 16, 14}) .IsApplicable(context.get(), transformation_context)); // %18 is a function type ASSERT_FALSE(TransformationAddTypeFunction(100, 12, {18}) .IsApplicable(context.get(), transformation_context)); // A function of this signature already exists ASSERT_FALSE(TransformationAddTypeFunction(100, 17, {14, 16}) .IsApplicable(context.get(), transformation_context)); TransformationAddTypeFunction transformations[] = { // %100 = OpTypeFunction %12 %12 %16 %14 TransformationAddTypeFunction(100, 12, {12, 16, 14}), // %101 = OpTypeFunction %12 TransformationAddTypeFunction(101, 12, {}), // %102 = OpTypeFunction %17 %200 %16 TransformationAddTypeFunction(102, 17, {200, 16})}; for (auto& transformation : transformations) { ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %2 %7 %12 = OpTypeFloat 32 %13 = OpTypeStruct %6 %12 %14 = OpTypePointer Function %13 %200 = OpTypePointer Function %13 %15 = OpTypeVector %12 3 %16 = OpTypePointer Function %15 %17 = OpTypeVector %12 2 %18 = OpTypeFunction %17 %14 %16 %23 = OpConstant %12 1 %24 = OpConstantComposite %17 %23 %23 %27 = OpConstant %6 3 %30 = OpConstant %6 1 %31 = OpConstant %12 2 %32 = OpConstantComposite %13 %30 %31 %33 = OpConstantComposite %15 %23 %23 %23 %100 = OpTypeFunction %12 %12 %16 %14 %101 = OpTypeFunction %12 %102 = OpTypeFunction %17 %200 %16 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_add_type_int_test.cpp000066400000000000000000000173231475742701700300500ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_type_int.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationAddTypeIntTest, IsApplicable) { std::string reference_shader = R"( OpCapability Shader OpCapability Int8 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %5 "main" ; Types %2 = OpTypeInt 8 1 %3 = OpTypeVoid %4 = OpTypeFunction %3 ; main function %5 = OpFunction %3 None %4 %6 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Tests non-fresh id. auto transformation = TransformationAddTypeInt(1, 32, false); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests missing Int16 capability. transformation = TransformationAddTypeInt(7, 16, false); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests missing Int64 capability. transformation = TransformationAddTypeInt(7, 64, false); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests existing signed 8-bit integer type. transformation = TransformationAddTypeInt(7, 8, true); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests adding unsigned 8-bit integer type. transformation = TransformationAddTypeInt(7, 8, false); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); // Tests adding unsigned 32-bit integer type. transformation = TransformationAddTypeInt(7, 32, false); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); // Tests adding signed 32-bit integer type. transformation = TransformationAddTypeInt(7, 32, true); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); // By default SPIR-V does not support 16-bit integers. // Below we add such capability, so the test should now be successful. context.get()->AddCapability(spv::Capability::Int16); ASSERT_TRUE(TransformationAddTypeInt(7, 16, true) .IsApplicable(context.get(), transformation_context)); // By default SPIR-V does not support 64-bit integers. // Below we add such capability, so the test should now pass. context.get()->AddCapability(spv::Capability::Int64); ASSERT_TRUE(TransformationAddTypeInt(7, 64, true) .IsApplicable(context.get(), transformation_context)); #ifndef NDEBUG // Should not be able to add signed/unsigned integers of width different from // 16/32/64 bits. ASSERT_DEATH(TransformationAddTypeInt(7, 20, false) .IsApplicable(context.get(), transformation_context), "Unexpected integer type width"); ASSERT_DEATH(TransformationAddTypeInt(12, 15, false) .IsApplicable(context.get(), transformation_context), "Unexpected integer type width"); #endif } TEST(TransformationAddTypeIntTest, Apply) { std::string reference_shader = R"( OpCapability Shader OpCapability Int8 OpCapability Int16 OpCapability Int64 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %4 "main" ; Types %2 = OpTypeVoid %3 = OpTypeFunction %2 ; main function %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Adds signed 8-bit integer type. // For this transformation we also check that the def-use manager and type // manager are updated appropriately. auto transformation = TransformationAddTypeInt(6, 8, true); ASSERT_EQ(nullptr, context->get_def_use_mgr()->GetDef(6)); ASSERT_EQ(nullptr, context->get_type_mgr()->GetType(6)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_EQ(spv::Op::OpTypeInt, context->get_def_use_mgr()->GetDef(6)->opcode()); ASSERT_NE(nullptr, context->get_type_mgr()->GetType(6)->AsInteger()); // Adds signed 16-bit integer type. transformation = TransformationAddTypeInt(7, 16, true); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); // Adds signed 32-bit integer type. transformation = TransformationAddTypeInt(8, 32, true); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); // Adds signed 64-bit integer type. transformation = TransformationAddTypeInt(9, 64, true); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); // Adds unsigned 8-bit integer type. transformation = TransformationAddTypeInt(10, 8, false); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); // Adds unsigned 16-bit integer type. transformation = TransformationAddTypeInt(11, 16, false); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); // Adds unsigned 32-bit integer type. transformation = TransformationAddTypeInt(12, 32, false); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); // Adds unsigned 64-bit integer type. transformation = TransformationAddTypeInt(13, 64, false); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); std::string variant_shader = R"( OpCapability Shader OpCapability Int8 OpCapability Int16 OpCapability Int64 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %4 "main" ; Types %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 8 1 %7 = OpTypeInt 16 1 %8 = OpTypeInt 32 1 %9 = OpTypeInt 64 1 %10 = OpTypeInt 8 0 %11 = OpTypeInt 16 0 %12 = OpTypeInt 32 0 %13 = OpTypeInt 64 0 ; main function %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(IsEqual(env, variant_shader, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_add_type_matrix_test.cpp000066400000000000000000000122001475742701700305470ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_type_matrix.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationAddTypeMatrixTest, BasicTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeInt 32 1 %8 = OpTypeVector %6 2 %9 = OpTypeVector %6 3 %10 = OpTypeVector %6 4 %11 = OpTypeVector %7 2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Id already in use ASSERT_FALSE(TransformationAddTypeMatrix(4, 9, 2).IsApplicable( context.get(), transformation_context)); // %1 is not a type ASSERT_FALSE(TransformationAddTypeMatrix(100, 1, 2).IsApplicable( context.get(), transformation_context)); // %11 is not a floating-point vector ASSERT_FALSE(TransformationAddTypeMatrix(100, 11, 2) .IsApplicable(context.get(), transformation_context)); { // %100 = OpTypeMatrix %8 2 TransformationAddTypeMatrix transformation(100, 8, 2); ASSERT_EQ(nullptr, context->get_def_use_mgr()->GetDef(100)); ASSERT_EQ(nullptr, context->get_type_mgr()->GetType(100)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_EQ(spv::Op::OpTypeMatrix, context->get_def_use_mgr()->GetDef(100)->opcode()); ASSERT_NE(nullptr, context->get_type_mgr()->GetType(100)->AsMatrix()); } TransformationAddTypeMatrix transformations[] = { // %101 = OpTypeMatrix %8 3 TransformationAddTypeMatrix(101, 8, 3), // %102 = OpTypeMatrix %8 4 TransformationAddTypeMatrix(102, 8, 4), // %103 = OpTypeMatrix %9 2 TransformationAddTypeMatrix(103, 9, 2), // %104 = OpTypeMatrix %9 3 TransformationAddTypeMatrix(104, 9, 3), // %105 = OpTypeMatrix %9 4 TransformationAddTypeMatrix(105, 9, 4), // %106 = OpTypeMatrix %10 2 TransformationAddTypeMatrix(106, 10, 2), // %107 = OpTypeMatrix %10 3 TransformationAddTypeMatrix(107, 10, 3), // %108 = OpTypeMatrix %10 4 TransformationAddTypeMatrix(108, 10, 4)}; for (auto& transformation : transformations) { ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeInt 32 1 %8 = OpTypeVector %6 2 %9 = OpTypeVector %6 3 %10 = OpTypeVector %6 4 %11 = OpTypeVector %7 2 %100 = OpTypeMatrix %8 2 %101 = OpTypeMatrix %8 3 %102 = OpTypeMatrix %8 4 %103 = OpTypeMatrix %9 2 %104 = OpTypeMatrix %9 3 %105 = OpTypeMatrix %9 4 %106 = OpTypeMatrix %10 2 %107 = OpTypeMatrix %10 3 %108 = OpTypeMatrix %10 4 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_add_type_pointer_test.cpp000066400000000000000000000205011475742701700307260ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_type_pointer.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationAddTypePointerTest, BasicTest) { // The SPIR-V was obtained from this GLSL: // // #version 450 // // int x; // float y; // vec2 z; // // struct T { // int a, b; // }; // // struct S { // T t; // int u; // }; // // void main() { // S myS = S(T(1, 2), 3); // myS.u = x; // } std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 450 OpName %4 "main" OpName %7 "T" OpMemberName %7 0 "a" OpMemberName %7 1 "b" OpName %8 "S" OpMemberName %8 0 "t" OpMemberName %8 1 "u" OpName %10 "myS" OpName %17 "x" OpName %23 "y" OpName %26 "z" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeStruct %6 %6 %8 = OpTypeStruct %7 %6 %9 = OpTypePointer Function %8 %11 = OpConstant %6 1 %12 = OpConstant %6 2 %13 = OpConstantComposite %7 %11 %12 %14 = OpConstant %6 3 %15 = OpConstantComposite %8 %13 %14 %16 = OpTypePointer Private %6 %17 = OpVariable %16 Private %19 = OpTypePointer Function %6 %21 = OpTypeFloat 32 %22 = OpTypePointer Private %21 %23 = OpVariable %22 Private %24 = OpTypeVector %21 2 %25 = OpTypePointer Private %24 %26 = OpVariable %25 Private %4 = OpFunction %2 None %3 %5 = OpLabel %10 = OpVariable %9 Function OpStore %10 %15 %18 = OpLoad %6 %17 %20 = OpAccessChain %19 %10 %11 OpStore %20 %18 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto bad_type_id_does_not_exist = TransformationAddTypePointer(100, spv::StorageClass::Function, 101); auto bad_type_id_is_not_type = TransformationAddTypePointer(100, spv::StorageClass::Function, 23); auto bad_result_id_is_not_fresh = TransformationAddTypePointer(17, spv::StorageClass::Function, 21); auto good_new_private_pointer_to_t = TransformationAddTypePointer(101, spv::StorageClass::Private, 7); auto good_new_uniform_pointer_to_t = TransformationAddTypePointer(102, spv::StorageClass::Uniform, 7); auto good_another_function_pointer_to_s = TransformationAddTypePointer(103, spv::StorageClass::Function, 8); auto good_new_uniform_pointer_to_s = TransformationAddTypePointer(104, spv::StorageClass::Uniform, 8); auto good_another_private_pointer_to_float = TransformationAddTypePointer(105, spv::StorageClass::Private, 21); auto good_new_private_pointer_to_private_pointer_to_float = TransformationAddTypePointer(106, spv::StorageClass::Private, 105); auto good_new_uniform_pointer_to_vec2 = TransformationAddTypePointer(107, spv::StorageClass::Uniform, 24); auto good_new_private_pointer_to_uniform_pointer_to_vec2 = TransformationAddTypePointer(108, spv::StorageClass::Private, 107); ASSERT_FALSE(bad_type_id_does_not_exist.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(bad_type_id_is_not_type.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(bad_result_id_is_not_fresh.IsApplicable(context.get(), transformation_context)); { auto& transformation = good_new_private_pointer_to_t; ASSERT_EQ(nullptr, context->get_def_use_mgr()->GetDef(101)); ASSERT_EQ(nullptr, context->get_type_mgr()->GetType(101)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_EQ(spv::Op::OpTypePointer, context->get_def_use_mgr()->GetDef(101)->opcode()); ASSERT_NE(nullptr, context->get_type_mgr()->GetType(101)->AsPointer()); } for (auto& transformation : {good_new_uniform_pointer_to_t, good_another_function_pointer_to_s, good_new_uniform_pointer_to_s, good_another_private_pointer_to_float, good_new_private_pointer_to_private_pointer_to_float, good_new_uniform_pointer_to_vec2, good_new_private_pointer_to_uniform_pointer_to_vec2}) { ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 450 OpName %4 "main" OpName %7 "T" OpMemberName %7 0 "a" OpMemberName %7 1 "b" OpName %8 "S" OpMemberName %8 0 "t" OpMemberName %8 1 "u" OpName %10 "myS" OpName %17 "x" OpName %23 "y" OpName %26 "z" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeStruct %6 %6 %8 = OpTypeStruct %7 %6 %9 = OpTypePointer Function %8 %11 = OpConstant %6 1 %12 = OpConstant %6 2 %13 = OpConstantComposite %7 %11 %12 %14 = OpConstant %6 3 %15 = OpConstantComposite %8 %13 %14 %16 = OpTypePointer Private %6 %17 = OpVariable %16 Private %19 = OpTypePointer Function %6 %21 = OpTypeFloat 32 %22 = OpTypePointer Private %21 %23 = OpVariable %22 Private %24 = OpTypeVector %21 2 %25 = OpTypePointer Private %24 %26 = OpVariable %25 Private %101 = OpTypePointer Private %7 %102 = OpTypePointer Uniform %7 %103 = OpTypePointer Function %8 %104 = OpTypePointer Uniform %8 %105 = OpTypePointer Private %21 %106 = OpTypePointer Private %105 %107 = OpTypePointer Uniform %24 %108 = OpTypePointer Private %107 %4 = OpFunction %2 None %3 %5 = OpLabel %10 = OpVariable %9 Function OpStore %10 %15 %18 = OpLoad %6 %17 %20 = OpAccessChain %19 %10 %11 OpStore %20 %18 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_add_type_struct_test.cpp000066400000000000000000000142651475742701700306040ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_type_struct.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationAddTypeStructTest, BasicTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeInt 32 1 %8 = OpTypeVector %6 2 %9 = OpTypeVector %6 3 %10 = OpTypeVector %6 4 %11 = OpTypeVector %7 2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Id already in use ASSERT_FALSE(TransformationAddTypeStruct(4, {}).IsApplicable( context.get(), transformation_context)); // %1 is not a type ASSERT_FALSE(TransformationAddTypeStruct(100, {1}).IsApplicable( context.get(), transformation_context)); // %3 is a function type ASSERT_FALSE(TransformationAddTypeStruct(100, {3}).IsApplicable( context.get(), transformation_context)); { // %100 = OpTypeStruct %6 %7 %8 %9 %10 %11 TransformationAddTypeStruct transformation(100, {6, 7, 8, 9, 10, 11}); ASSERT_EQ(nullptr, context->get_def_use_mgr()->GetDef(100)); ASSERT_EQ(nullptr, context->get_type_mgr()->GetType(100)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_EQ(spv::Op::OpTypeStruct, context->get_def_use_mgr()->GetDef(100)->opcode()); ASSERT_NE(nullptr, context->get_type_mgr()->GetType(100)->AsStruct()); } TransformationAddTypeStruct transformations[] = { // %101 = OpTypeStruct TransformationAddTypeStruct(101, {}), // %102 = OpTypeStruct %6 TransformationAddTypeStruct(102, {6}), // %103 = OpTypeStruct %6 %6 TransformationAddTypeStruct(103, {6, 6})}; for (auto& transformation : transformations) { ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeInt 32 1 %8 = OpTypeVector %6 2 %9 = OpTypeVector %6 3 %10 = OpTypeVector %6 4 %11 = OpTypeVector %7 2 %100 = OpTypeStruct %6 %7 %8 %9 %10 %11 %101 = OpTypeStruct %102 = OpTypeStruct %6 %103 = OpTypeStruct %6 %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationAddTypeStructTest, HandlesBuiltInMembers) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %2 "main" OpMemberDecorate %4 0 BuiltIn Position OpMemberDecorate %4 1 BuiltIn PointSize OpMemberDecorate %4 2 BuiltIn ClipDistance %6 = OpTypeFloat 32 %5 = OpTypeVector %6 4 %9 = OpTypeInt 32 1 %8 = OpConstant %9 1 %7 = OpTypeArray %6 %8 %4 = OpTypeStruct %5 %6 %7 %27 = OpTypeVoid %28 = OpTypeFunction %27 %2 = OpFunction %27 None %28 %29 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // From the spec for the BuiltIn decoration: // - When applied to a structure-type member, that structure type cannot // be contained as a member of another structure type. // // OpTypeStruct with id %4 has BuiltIn members. ASSERT_FALSE(TransformationAddTypeStruct(50, {6, 5, 4, 6, 7}) .IsApplicable(context.get(), transformation_context)); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_add_type_vector_test.cpp000066400000000000000000000103731475742701700305560ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_add_type_vector.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationAddTypeVectorTest, BasicTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeInt 32 1 %8 = OpTypeInt 32 0 %9 = OpTypeBool %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Id already in use ASSERT_FALSE(TransformationAddTypeVector(4, 6, 2).IsApplicable( context.get(), transformation_context)); // %1 is not a type ASSERT_FALSE(TransformationAddTypeVector(100, 1, 2).IsApplicable( context.get(), transformation_context)); { // %100 = OpTypeVector %6 2 TransformationAddTypeVector transformation(100, 6, 2); ASSERT_EQ(nullptr, context->get_def_use_mgr()->GetDef(100)); ASSERT_EQ(nullptr, context->get_type_mgr()->GetType(100)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_EQ(spv::Op::OpTypeVector, context->get_def_use_mgr()->GetDef(100)->opcode()); ASSERT_NE(nullptr, context->get_type_mgr()->GetType(100)->AsVector()); } TransformationAddTypeVector transformations[] = { // %101 = OpTypeVector %7 3 TransformationAddTypeVector(101, 7, 3), // %102 = OpTypeVector %8 4 TransformationAddTypeVector(102, 8, 4), // %103 = OpTypeVector %9 2 TransformationAddTypeVector(103, 9, 2)}; for (auto& transformation : transformations) { ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeInt 32 1 %8 = OpTypeInt 32 0 %9 = OpTypeBool %100 = OpTypeVector %6 2 %101 = OpTypeVector %7 3 %102 = OpTypeVector %8 4 %103 = OpTypeVector %9 2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_adjust_branch_weights_test.cpp000066400000000000000000000315561475742701700317520ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_adjust_branch_weights.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationAdjustBranchWeightsTest, IsApplicableTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %51 %27 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %25 "buf" OpMemberName %25 0 "value" OpName %27 "" OpName %51 "color" OpMemberDecorate %25 0 Offset 0 OpDecorate %25 Block OpDecorate %27 DescriptorSet 0 OpDecorate %27 Binding 0 OpDecorate %51 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %150 = OpTypeVector %6 2 %10 = OpConstant %6 0.300000012 %11 = OpConstant %6 0.400000006 %12 = OpConstant %6 0.5 %13 = OpConstant %6 1 %14 = OpConstantComposite %7 %10 %11 %12 %13 %15 = OpTypeInt 32 1 %18 = OpConstant %15 0 %25 = OpTypeStruct %6 %26 = OpTypePointer Uniform %25 %27 = OpVariable %26 Uniform %28 = OpTypePointer Uniform %6 %32 = OpTypeBool %103 = OpConstantTrue %32 %34 = OpConstant %6 0.100000001 %48 = OpConstant %15 1 %50 = OpTypePointer Output %7 %51 = OpVariable %50 Output %100 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %5 = OpLabel %101 = OpVariable %100 Function %102 = OpVariable %100 Function OpBranch %19 %19 = OpLabel %60 = OpPhi %7 %14 %5 %58 %20 %59 = OpPhi %15 %18 %5 %49 %20 %29 = OpAccessChain %28 %27 %18 %30 = OpLoad %6 %29 %31 = OpConvertFToS %15 %30 %33 = OpSLessThan %32 %59 %31 OpLoopMerge %21 %20 None OpBranchConditional %33 %20 %21 1 2 %20 = OpLabel %39 = OpCompositeExtract %6 %60 0 %40 = OpFAdd %6 %39 %34 %55 = OpCompositeInsert %7 %40 %60 0 %44 = OpCompositeExtract %6 %60 1 %45 = OpFSub %6 %44 %34 %58 = OpCompositeInsert %7 %45 %55 1 %49 = OpIAdd %15 %59 %48 OpBranch %19 %21 = OpLabel OpStore %51 %60 OpSelectionMerge %105 None OpBranchConditional %103 %104 %105 %104 = OpLabel OpBranch %105 %105 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Tests OpBranchConditional instruction with weights. auto instruction_descriptor = MakeInstructionDescriptor(33, spv::Op::OpBranchConditional, 0); auto transformation = TransformationAdjustBranchWeights(instruction_descriptor, {0, 1}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); // Tests the two branch weights equal to 0. instruction_descriptor = MakeInstructionDescriptor(33, spv::Op::OpBranchConditional, 0); transformation = TransformationAdjustBranchWeights(instruction_descriptor, {0, 0}); #ifndef NDEBUG ASSERT_DEATH( transformation.IsApplicable(context.get(), transformation_context), "At least one weight must be non-zero"); #endif // Tests 32-bit unsigned integer overflow. instruction_descriptor = MakeInstructionDescriptor(33, spv::Op::OpBranchConditional, 0); transformation = TransformationAdjustBranchWeights(instruction_descriptor, {UINT32_MAX, 0}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); instruction_descriptor = MakeInstructionDescriptor(33, spv::Op::OpBranchConditional, 0); transformation = TransformationAdjustBranchWeights(instruction_descriptor, {1, UINT32_MAX}); #ifndef NDEBUG ASSERT_DEATH( transformation.IsApplicable(context.get(), transformation_context), "The sum of the two weights must not be greater than UINT32_MAX"); #endif // Tests OpBranchConditional instruction with no weights. instruction_descriptor = MakeInstructionDescriptor(21, spv::Op::OpBranchConditional, 0); transformation = TransformationAdjustBranchWeights(instruction_descriptor, {0, 1}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); // Tests non-OpBranchConditional instructions. instruction_descriptor = MakeInstructionDescriptor(2, spv::Op::OpTypeVoid, 0); transformation = TransformationAdjustBranchWeights(instruction_descriptor, {5, 6}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); instruction_descriptor = MakeInstructionDescriptor(20, spv::Op::OpLabel, 0); transformation = TransformationAdjustBranchWeights(instruction_descriptor, {1, 2}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); instruction_descriptor = MakeInstructionDescriptor(49, spv::Op::OpIAdd, 0); transformation = TransformationAdjustBranchWeights(instruction_descriptor, {1, 2}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationAdjustBranchWeightsTest, ApplyTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %51 %27 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %25 "buf" OpMemberName %25 0 "value" OpName %27 "" OpName %51 "color" OpMemberDecorate %25 0 Offset 0 OpDecorate %25 Block OpDecorate %27 DescriptorSet 0 OpDecorate %27 Binding 0 OpDecorate %51 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %150 = OpTypeVector %6 2 %10 = OpConstant %6 0.300000012 %11 = OpConstant %6 0.400000006 %12 = OpConstant %6 0.5 %13 = OpConstant %6 1 %14 = OpConstantComposite %7 %10 %11 %12 %13 %15 = OpTypeInt 32 1 %18 = OpConstant %15 0 %25 = OpTypeStruct %6 %26 = OpTypePointer Uniform %25 %27 = OpVariable %26 Uniform %28 = OpTypePointer Uniform %6 %32 = OpTypeBool %103 = OpConstantTrue %32 %34 = OpConstant %6 0.100000001 %48 = OpConstant %15 1 %50 = OpTypePointer Output %7 %51 = OpVariable %50 Output %100 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %5 = OpLabel %101 = OpVariable %100 Function %102 = OpVariable %100 Function OpBranch %19 %19 = OpLabel %60 = OpPhi %7 %14 %5 %58 %20 %59 = OpPhi %15 %18 %5 %49 %20 %29 = OpAccessChain %28 %27 %18 %30 = OpLoad %6 %29 %31 = OpConvertFToS %15 %30 %33 = OpSLessThan %32 %59 %31 OpLoopMerge %21 %20 None OpBranchConditional %33 %20 %21 1 2 %20 = OpLabel %39 = OpCompositeExtract %6 %60 0 %40 = OpFAdd %6 %39 %34 %55 = OpCompositeInsert %7 %40 %60 0 %44 = OpCompositeExtract %6 %60 1 %45 = OpFSub %6 %44 %34 %58 = OpCompositeInsert %7 %45 %55 1 %49 = OpIAdd %15 %59 %48 OpBranch %19 %21 = OpLabel OpStore %51 %60 OpSelectionMerge %105 None OpBranchConditional %103 %104 %105 %104 = OpLabel OpBranch %105 %105 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto instruction_descriptor = MakeInstructionDescriptor(33, spv::Op::OpBranchConditional, 0); auto transformation = TransformationAdjustBranchWeights(instruction_descriptor, {5, 6}); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); instruction_descriptor = MakeInstructionDescriptor(21, spv::Op::OpBranchConditional, 0); transformation = TransformationAdjustBranchWeights(instruction_descriptor, {7, 8}); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); std::string variant_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %51 %27 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %25 "buf" OpMemberName %25 0 "value" OpName %27 "" OpName %51 "color" OpMemberDecorate %25 0 Offset 0 OpDecorate %25 Block OpDecorate %27 DescriptorSet 0 OpDecorate %27 Binding 0 OpDecorate %51 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %150 = OpTypeVector %6 2 %10 = OpConstant %6 0.300000012 %11 = OpConstant %6 0.400000006 %12 = OpConstant %6 0.5 %13 = OpConstant %6 1 %14 = OpConstantComposite %7 %10 %11 %12 %13 %15 = OpTypeInt 32 1 %18 = OpConstant %15 0 %25 = OpTypeStruct %6 %26 = OpTypePointer Uniform %25 %27 = OpVariable %26 Uniform %28 = OpTypePointer Uniform %6 %32 = OpTypeBool %103 = OpConstantTrue %32 %34 = OpConstant %6 0.100000001 %48 = OpConstant %15 1 %50 = OpTypePointer Output %7 %51 = OpVariable %50 Output %100 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %5 = OpLabel %101 = OpVariable %100 Function %102 = OpVariable %100 Function OpBranch %19 %19 = OpLabel %60 = OpPhi %7 %14 %5 %58 %20 %59 = OpPhi %15 %18 %5 %49 %20 %29 = OpAccessChain %28 %27 %18 %30 = OpLoad %6 %29 %31 = OpConvertFToS %15 %30 %33 = OpSLessThan %32 %59 %31 OpLoopMerge %21 %20 None OpBranchConditional %33 %20 %21 5 6 %20 = OpLabel %39 = OpCompositeExtract %6 %60 0 %40 = OpFAdd %6 %39 %34 %55 = OpCompositeInsert %7 %40 %60 0 %44 = OpCompositeExtract %6 %60 1 %45 = OpFSub %6 %44 %34 %58 = OpCompositeInsert %7 %45 %55 1 %49 = OpIAdd %15 %59 %48 OpBranch %19 %21 = OpLabel OpStore %51 %60 OpSelectionMerge %105 None OpBranchConditional %103 %104 %105 7 8 %104 = OpLabel OpBranch %105 %105 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, variant_shader, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_composite_construct_test.cpp000066400000000000000000002205271475742701700315150ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_composite_construct.h" #include "gtest/gtest.h" #include "source/fuzz/data_descriptor.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationCompositeConstructTest, ConstructArrays) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %11 "floats" OpName %22 "x" OpName %39 "vecs" OpName %49 "bools" OpName %60 "many_uvec3s" OpDecorate %60 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeInt 32 0 %8 = OpConstant %7 2 %9 = OpTypeArray %6 %8 %10 = OpTypePointer Function %9 %12 = OpTypeInt 32 1 %13 = OpConstant %12 0 %14 = OpConstant %6 1 %15 = OpTypePointer Function %6 %17 = OpConstant %12 1 %18 = OpConstant %6 2 %20 = OpTypeVector %6 2 %21 = OpTypePointer Function %20 %32 = OpTypeBool %36 = OpConstant %7 3 %37 = OpTypeArray %20 %36 %38 = OpTypePointer Private %37 %39 = OpVariable %38 Private %40 = OpConstant %6 3 %41 = OpConstantComposite %20 %40 %40 %42 = OpTypePointer Private %20 %44 = OpConstant %12 2 %47 = OpTypeArray %32 %36 %48 = OpTypePointer Function %47 %50 = OpConstantTrue %32 %51 = OpTypePointer Function %32 %56 = OpTypeVector %7 3 %57 = OpTypeArray %56 %8 %58 = OpTypeArray %57 %8 %59 = OpTypePointer Function %58 %61 = OpConstant %7 4 %62 = OpConstantComposite %56 %61 %61 %61 %63 = OpTypePointer Function %56 %65 = OpConstant %7 5 %66 = OpConstantComposite %56 %65 %65 %65 %67 = OpConstant %7 6 %68 = OpConstantComposite %56 %67 %67 %67 %69 = OpConstantComposite %57 %66 %68 %100 = OpUndef %57 %70 = OpTypePointer Function %57 %4 = OpFunction %2 None %3 %5 = OpLabel %11 = OpVariable %10 Function %22 = OpVariable %21 Function %49 = OpVariable %48 Function %60 = OpVariable %59 Function %16 = OpAccessChain %15 %11 %13 OpStore %16 %14 %19 = OpAccessChain %15 %11 %17 OpStore %19 %18 %23 = OpAccessChain %15 %11 %13 %24 = OpLoad %6 %23 %25 = OpAccessChain %15 %11 %17 %26 = OpLoad %6 %25 %27 = OpCompositeConstruct %20 %24 %26 OpStore %22 %27 %28 = OpAccessChain %15 %11 %13 %29 = OpLoad %6 %28 %30 = OpAccessChain %15 %11 %17 %31 = OpLoad %6 %30 %33 = OpFOrdGreaterThan %32 %29 %31 OpSelectionMerge %35 None OpBranchConditional %33 %34 %35 %34 = OpLabel %43 = OpAccessChain %42 %39 %17 OpStore %43 %41 %45 = OpLoad %20 %22 %46 = OpAccessChain %42 %39 %44 OpStore %46 %45 OpBranch %35 %35 = OpLabel %52 = OpAccessChain %51 %49 %13 OpStore %52 %50 %53 = OpAccessChain %51 %49 %13 %54 = OpLoad %32 %53 %55 = OpAccessChain %51 %49 %17 OpStore %55 %54 %64 = OpAccessChain %63 %60 %13 %13 OpStore %64 %62 %71 = OpAccessChain %70 %60 %17 OpStore %71 %69 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Make a vec2[3] TransformationCompositeConstruct make_vec2_array_length_3( 37, {41, 45, 27}, MakeInstructionDescriptor(46, spv::Op::OpAccessChain, 0), 200); // Bad: there are too many components TransformationCompositeConstruct make_vec2_array_length_3_bad( 37, {41, 45, 27, 27}, MakeInstructionDescriptor(46, spv::Op::OpAccessChain, 0), 200); // The first component does not correspond to an instruction with a result // type so this check should return false. TransformationCompositeConstruct make_vec2_array_length_3_nores( 37, {2, 45, 27}, MakeInstructionDescriptor(46, spv::Op::OpAccessChain, 0), 200); ASSERT_TRUE(make_vec2_array_length_3.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(make_vec2_array_length_3_bad.IsApplicable( context.get(), transformation_context)); ASSERT_FALSE(make_vec2_array_length_3_nores.IsApplicable( context.get(), transformation_context)); ASSERT_EQ(nullptr, context->get_def_use_mgr()->GetDef(200)); ASSERT_EQ(nullptr, context->get_instr_block(200)); uint32_t num_uses_of_41_before = context->get_def_use_mgr()->NumUses(41); uint32_t num_uses_of_45_before = context->get_def_use_mgr()->NumUses(45); uint32_t num_uses_of_27_before = context->get_def_use_mgr()->NumUses(27); ApplyAndCheckFreshIds(make_vec2_array_length_3, context.get(), &transformation_context); ASSERT_EQ(spv::Op::OpCompositeConstruct, context->get_def_use_mgr()->GetDef(200)->opcode()); ASSERT_EQ(34, context->get_instr_block(200)->id()); ASSERT_EQ(num_uses_of_41_before + 1, context->get_def_use_mgr()->NumUses(41)); ASSERT_EQ(num_uses_of_45_before + 1, context->get_def_use_mgr()->NumUses(45)); ASSERT_EQ(num_uses_of_27_before + 1, context->get_def_use_mgr()->NumUses(27)); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(41, {}), MakeDataDescriptor(200, {0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(45, {}), MakeDataDescriptor(200, {1}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(27, {}), MakeDataDescriptor(200, {2}))); // Make a float[2] TransformationCompositeConstruct make_float_array_length_2( 9, {24, 40}, MakeInstructionDescriptor(71, spv::Op::OpStore, 0), 201); // Bad: %41 does not have type float TransformationCompositeConstruct make_float_array_length_2_bad( 9, {41, 40}, MakeInstructionDescriptor(71, spv::Op::OpStore, 0), 201); ASSERT_TRUE(make_float_array_length_2.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(make_float_array_length_2_bad.IsApplicable( context.get(), transformation_context)); ApplyAndCheckFreshIds(make_float_array_length_2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(24, {}), MakeDataDescriptor(201, {0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(40, {}), MakeDataDescriptor(201, {1}))); // Make a bool[3] TransformationCompositeConstruct make_bool_array_length_3( 47, {33, 50, 50}, MakeInstructionDescriptor(33, spv::Op::OpSelectionMerge, 0), 202); // Bad: %54 is not available at the desired program point. TransformationCompositeConstruct make_bool_array_length_3_bad( 47, {33, 54, 50}, MakeInstructionDescriptor(33, spv::Op::OpSelectionMerge, 0), 202); ASSERT_TRUE(make_bool_array_length_3.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(make_bool_array_length_3_bad.IsApplicable( context.get(), transformation_context)); ApplyAndCheckFreshIds(make_bool_array_length_3, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(33, {}), MakeDataDescriptor(202, {0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(50, {}), MakeDataDescriptor(202, {1}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(50, {}), MakeDataDescriptor(202, {2}))); // make a uvec3[2][2] TransformationCompositeConstruct make_uvec3_array_length_2_2( 58, {69, 100}, MakeInstructionDescriptor(64, spv::Op::OpStore, 0), 203); // Bad: Skip count 100 is too large. TransformationCompositeConstruct make_uvec3_array_length_2_2_bad( 58, {33, 54}, MakeInstructionDescriptor(64, spv::Op::OpStore, 100), 203); ASSERT_TRUE(make_uvec3_array_length_2_2.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(make_uvec3_array_length_2_2_bad.IsApplicable( context.get(), transformation_context)); ApplyAndCheckFreshIds(make_uvec3_array_length_2_2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(69, {}), MakeDataDescriptor(203, {0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(100, {}), MakeDataDescriptor(203, {1}))); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %11 "floats" OpName %22 "x" OpName %39 "vecs" OpName %49 "bools" OpName %60 "many_uvec3s" OpDecorate %60 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeInt 32 0 %8 = OpConstant %7 2 %9 = OpTypeArray %6 %8 %10 = OpTypePointer Function %9 %12 = OpTypeInt 32 1 %13 = OpConstant %12 0 %14 = OpConstant %6 1 %15 = OpTypePointer Function %6 %17 = OpConstant %12 1 %18 = OpConstant %6 2 %20 = OpTypeVector %6 2 %21 = OpTypePointer Function %20 %32 = OpTypeBool %36 = OpConstant %7 3 %37 = OpTypeArray %20 %36 %38 = OpTypePointer Private %37 %39 = OpVariable %38 Private %40 = OpConstant %6 3 %41 = OpConstantComposite %20 %40 %40 %42 = OpTypePointer Private %20 %44 = OpConstant %12 2 %47 = OpTypeArray %32 %36 %48 = OpTypePointer Function %47 %50 = OpConstantTrue %32 %51 = OpTypePointer Function %32 %56 = OpTypeVector %7 3 %57 = OpTypeArray %56 %8 %58 = OpTypeArray %57 %8 %59 = OpTypePointer Function %58 %61 = OpConstant %7 4 %62 = OpConstantComposite %56 %61 %61 %61 %63 = OpTypePointer Function %56 %65 = OpConstant %7 5 %66 = OpConstantComposite %56 %65 %65 %65 %67 = OpConstant %7 6 %68 = OpConstantComposite %56 %67 %67 %67 %69 = OpConstantComposite %57 %66 %68 %100 = OpUndef %57 %70 = OpTypePointer Function %57 %4 = OpFunction %2 None %3 %5 = OpLabel %11 = OpVariable %10 Function %22 = OpVariable %21 Function %49 = OpVariable %48 Function %60 = OpVariable %59 Function %16 = OpAccessChain %15 %11 %13 OpStore %16 %14 %19 = OpAccessChain %15 %11 %17 OpStore %19 %18 %23 = OpAccessChain %15 %11 %13 %24 = OpLoad %6 %23 %25 = OpAccessChain %15 %11 %17 %26 = OpLoad %6 %25 %27 = OpCompositeConstruct %20 %24 %26 OpStore %22 %27 %28 = OpAccessChain %15 %11 %13 %29 = OpLoad %6 %28 %30 = OpAccessChain %15 %11 %17 %31 = OpLoad %6 %30 %33 = OpFOrdGreaterThan %32 %29 %31 %202 = OpCompositeConstruct %47 %33 %50 %50 OpSelectionMerge %35 None OpBranchConditional %33 %34 %35 %34 = OpLabel %43 = OpAccessChain %42 %39 %17 OpStore %43 %41 %45 = OpLoad %20 %22 %200 = OpCompositeConstruct %37 %41 %45 %27 %46 = OpAccessChain %42 %39 %44 OpStore %46 %45 OpBranch %35 %35 = OpLabel %52 = OpAccessChain %51 %49 %13 OpStore %52 %50 %53 = OpAccessChain %51 %49 %13 %54 = OpLoad %32 %53 %55 = OpAccessChain %51 %49 %17 OpStore %55 %54 %64 = OpAccessChain %63 %60 %13 %13 %203 = OpCompositeConstruct %58 %69 %100 OpStore %64 %62 %71 = OpAccessChain %70 %60 %17 %201 = OpCompositeConstruct %9 %24 %40 OpStore %71 %69 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationCompositeConstructTest, ConstructMatrices) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %9 "v1" OpName %12 "v2" OpName %14 "v3" OpName %19 "v4" OpName %26 "v5" OpName %29 "v6" OpName %34 "m34" OpName %37 "m43" OpName %43 "vecs" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 3 %8 = OpTypePointer Function %7 %10 = OpConstant %6 1 %11 = OpConstantComposite %7 %10 %10 %10 %17 = OpTypeVector %6 4 %18 = OpTypePointer Function %17 %21 = OpConstant %6 2 %32 = OpTypeMatrix %17 3 %33 = OpTypePointer Private %32 %34 = OpVariable %33 Private %35 = OpTypeMatrix %7 4 %36 = OpTypePointer Private %35 %37 = OpVariable %36 Private %38 = OpTypeVector %6 2 %39 = OpTypeInt 32 0 %40 = OpConstant %39 3 %41 = OpTypeArray %38 %40 %42 = OpTypePointer Private %41 %43 = OpVariable %42 Private %100 = OpUndef %7 %101 = OpUndef %17 %4 = OpFunction %2 None %3 %5 = OpLabel %9 = OpVariable %8 Function %12 = OpVariable %8 Function %14 = OpVariable %8 Function %19 = OpVariable %18 Function %26 = OpVariable %18 Function %29 = OpVariable %18 Function OpStore %9 %11 %13 = OpLoad %7 %9 OpStore %12 %13 %15 = OpLoad %7 %12 %16 = OpVectorShuffle %7 %15 %15 2 1 0 OpStore %14 %16 %20 = OpLoad %7 %14 %22 = OpCompositeExtract %6 %20 0 %23 = OpCompositeExtract %6 %20 1 %24 = OpCompositeExtract %6 %20 2 %25 = OpCompositeConstruct %17 %22 %23 %24 %21 OpStore %19 %25 %27 = OpLoad %17 %19 %28 = OpVectorShuffle %17 %27 %27 3 2 1 0 OpStore %26 %28 %30 = OpLoad %7 %9 %31 = OpVectorShuffle %17 %30 %30 0 0 1 1 OpStore %29 %31 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // make a mat3x4 TransformationCompositeConstruct make_mat34( 32, {25, 28, 31}, MakeInstructionDescriptor(31, spv::Op::OpReturn, 0), 200); // Bad: %35 is mat4x3, not mat3x4. TransformationCompositeConstruct make_mat34_bad( 35, {25, 28, 31}, MakeInstructionDescriptor(31, spv::Op::OpReturn, 0), 200); // The first component does not correspond to an instruction with a result // type so this check should return false. TransformationCompositeConstruct make_mat34_nores( 32, {2, 28, 31}, MakeInstructionDescriptor(31, spv::Op::OpReturn, 0), 200); ASSERT_TRUE(make_mat34.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( make_mat34_bad.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( make_mat34_nores.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(make_mat34, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(25, {}), MakeDataDescriptor(200, {0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(28, {}), MakeDataDescriptor(200, {1}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(31, {}), MakeDataDescriptor(200, {2}))); // make a mat4x3 TransformationCompositeConstruct make_mat43( 35, {11, 13, 16, 100}, MakeInstructionDescriptor(31, spv::Op::OpStore, 0), 201); // Bad: %25 does not match the matrix's column type. TransformationCompositeConstruct make_mat43_bad( 35, {25, 13, 16, 100}, MakeInstructionDescriptor(31, spv::Op::OpStore, 0), 201); ASSERT_TRUE(make_mat43.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( make_mat43_bad.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(make_mat43, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(11, {}), MakeDataDescriptor(201, {0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(13, {}), MakeDataDescriptor(201, {1}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(16, {}), MakeDataDescriptor(201, {2}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(100, {}), MakeDataDescriptor(201, {3}))); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %9 "v1" OpName %12 "v2" OpName %14 "v3" OpName %19 "v4" OpName %26 "v5" OpName %29 "v6" OpName %34 "m34" OpName %37 "m43" OpName %43 "vecs" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 3 %8 = OpTypePointer Function %7 %10 = OpConstant %6 1 %11 = OpConstantComposite %7 %10 %10 %10 %17 = OpTypeVector %6 4 %18 = OpTypePointer Function %17 %21 = OpConstant %6 2 %32 = OpTypeMatrix %17 3 %33 = OpTypePointer Private %32 %34 = OpVariable %33 Private %35 = OpTypeMatrix %7 4 %36 = OpTypePointer Private %35 %37 = OpVariable %36 Private %38 = OpTypeVector %6 2 %39 = OpTypeInt 32 0 %40 = OpConstant %39 3 %41 = OpTypeArray %38 %40 %42 = OpTypePointer Private %41 %43 = OpVariable %42 Private %100 = OpUndef %7 %101 = OpUndef %17 %4 = OpFunction %2 None %3 %5 = OpLabel %9 = OpVariable %8 Function %12 = OpVariable %8 Function %14 = OpVariable %8 Function %19 = OpVariable %18 Function %26 = OpVariable %18 Function %29 = OpVariable %18 Function OpStore %9 %11 %13 = OpLoad %7 %9 OpStore %12 %13 %15 = OpLoad %7 %12 %16 = OpVectorShuffle %7 %15 %15 2 1 0 OpStore %14 %16 %20 = OpLoad %7 %14 %22 = OpCompositeExtract %6 %20 0 %23 = OpCompositeExtract %6 %20 1 %24 = OpCompositeExtract %6 %20 2 %25 = OpCompositeConstruct %17 %22 %23 %24 %21 OpStore %19 %25 %27 = OpLoad %17 %19 %28 = OpVectorShuffle %17 %27 %27 3 2 1 0 OpStore %26 %28 %30 = OpLoad %7 %9 %31 = OpVectorShuffle %17 %30 %30 0 0 1 1 %201 = OpCompositeConstruct %35 %11 %13 %16 %100 OpStore %29 %31 %200 = OpCompositeConstruct %32 %25 %28 %31 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationCompositeConstructTest, ConstructStructs) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %9 "Inner" OpMemberName %9 0 "a" OpMemberName %9 1 "b" OpName %11 "i1" OpName %22 "i2" OpName %33 "Outer" OpMemberName %33 0 "c" OpMemberName %33 1 "d" OpMemberName %33 2 "e" OpName %35 "o" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 2 %8 = OpTypeInt 32 1 %9 = OpTypeStruct %7 %8 %10 = OpTypePointer Function %9 %12 = OpConstant %8 0 %13 = OpConstant %6 2 %14 = OpTypeInt 32 0 %15 = OpConstant %14 0 %16 = OpTypePointer Function %6 %18 = OpConstant %8 1 %19 = OpConstant %8 3 %20 = OpTypePointer Function %8 %23 = OpTypePointer Function %7 %31 = OpConstant %14 2 %32 = OpTypeArray %9 %31 %33 = OpTypeStruct %32 %9 %6 %34 = OpTypePointer Function %33 %36 = OpConstant %6 1 %37 = OpConstantComposite %7 %36 %13 %38 = OpConstant %8 2 %39 = OpConstantComposite %9 %37 %38 %40 = OpConstant %6 3 %41 = OpConstant %6 4 %42 = OpConstantComposite %7 %40 %41 %56 = OpConstant %6 5 %100 = OpUndef %9 %4 = OpFunction %2 None %3 %5 = OpLabel %11 = OpVariable %10 Function %22 = OpVariable %10 Function %35 = OpVariable %34 Function %17 = OpAccessChain %16 %11 %12 %15 OpStore %17 %13 %21 = OpAccessChain %20 %11 %18 OpStore %21 %19 %24 = OpAccessChain %23 %11 %12 %25 = OpLoad %7 %24 %26 = OpAccessChain %23 %22 %12 OpStore %26 %25 %27 = OpAccessChain %20 %11 %18 %28 = OpLoad %8 %27 %29 = OpIAdd %8 %28 %18 %30 = OpAccessChain %20 %22 %18 OpStore %30 %29 %43 = OpAccessChain %20 %11 %18 %44 = OpLoad %8 %43 %45 = OpCompositeConstruct %9 %42 %44 %46 = OpCompositeConstruct %32 %39 %45 %47 = OpLoad %9 %22 %48 = OpCompositeConstruct %33 %46 %47 %40 OpStore %35 %48 %49 = OpLoad %9 %11 %50 = OpAccessChain %10 %35 %12 %12 OpStore %50 %49 %51 = OpLoad %9 %22 %52 = OpAccessChain %10 %35 %12 %18 OpStore %52 %51 %53 = OpAccessChain %10 %35 %12 %12 %54 = OpLoad %9 %53 %55 = OpAccessChain %10 %35 %18 OpStore %55 %54 %57 = OpAccessChain %16 %35 %38 OpStore %57 %56 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // make an Inner TransformationCompositeConstruct make_inner( 9, {25, 19}, MakeInstructionDescriptor(57, spv::Op::OpAccessChain, 0), 200); // Bad: Too few fields to make the struct. TransformationCompositeConstruct make_inner_bad( 9, {25}, MakeInstructionDescriptor(57, spv::Op::OpAccessChain, 0), 200); // The first component does not correspond to an instruction with a result // type so this check should return false. TransformationCompositeConstruct make_inner_nores( 9, {2, 19}, MakeInstructionDescriptor(57, spv::Op::OpAccessChain, 0), 200); ASSERT_TRUE(make_inner.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( make_inner_bad.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( make_inner_nores.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(make_inner, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(25, {}), MakeDataDescriptor(200, {0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(19, {}), MakeDataDescriptor(200, {1}))); // make an Outer TransformationCompositeConstruct make_outer( 33, {46, 200, 56}, MakeInstructionDescriptor(200, spv::Op::OpAccessChain, 0), 201); // Bad: %200 is not available at the desired program point. TransformationCompositeConstruct make_outer_bad( 33, {46, 200, 56}, MakeInstructionDescriptor(200, spv::Op::OpCompositeConstruct, 0), 201); ASSERT_TRUE(make_outer.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( make_outer_bad.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(make_outer, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(46, {}), MakeDataDescriptor(201, {0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(200, {}), MakeDataDescriptor(201, {1}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(56, {}), MakeDataDescriptor(201, {2}))); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %9 "Inner" OpMemberName %9 0 "a" OpMemberName %9 1 "b" OpName %11 "i1" OpName %22 "i2" OpName %33 "Outer" OpMemberName %33 0 "c" OpMemberName %33 1 "d" OpMemberName %33 2 "e" OpName %35 "o" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 2 %8 = OpTypeInt 32 1 %9 = OpTypeStruct %7 %8 %10 = OpTypePointer Function %9 %12 = OpConstant %8 0 %13 = OpConstant %6 2 %14 = OpTypeInt 32 0 %15 = OpConstant %14 0 %16 = OpTypePointer Function %6 %18 = OpConstant %8 1 %19 = OpConstant %8 3 %20 = OpTypePointer Function %8 %23 = OpTypePointer Function %7 %31 = OpConstant %14 2 %32 = OpTypeArray %9 %31 %33 = OpTypeStruct %32 %9 %6 %34 = OpTypePointer Function %33 %36 = OpConstant %6 1 %37 = OpConstantComposite %7 %36 %13 %38 = OpConstant %8 2 %39 = OpConstantComposite %9 %37 %38 %40 = OpConstant %6 3 %41 = OpConstant %6 4 %42 = OpConstantComposite %7 %40 %41 %56 = OpConstant %6 5 %100 = OpUndef %9 %4 = OpFunction %2 None %3 %5 = OpLabel %11 = OpVariable %10 Function %22 = OpVariable %10 Function %35 = OpVariable %34 Function %17 = OpAccessChain %16 %11 %12 %15 OpStore %17 %13 %21 = OpAccessChain %20 %11 %18 OpStore %21 %19 %24 = OpAccessChain %23 %11 %12 %25 = OpLoad %7 %24 %26 = OpAccessChain %23 %22 %12 OpStore %26 %25 %27 = OpAccessChain %20 %11 %18 %28 = OpLoad %8 %27 %29 = OpIAdd %8 %28 %18 %30 = OpAccessChain %20 %22 %18 OpStore %30 %29 %43 = OpAccessChain %20 %11 %18 %44 = OpLoad %8 %43 %45 = OpCompositeConstruct %9 %42 %44 %46 = OpCompositeConstruct %32 %39 %45 %47 = OpLoad %9 %22 %48 = OpCompositeConstruct %33 %46 %47 %40 OpStore %35 %48 %49 = OpLoad %9 %11 %50 = OpAccessChain %10 %35 %12 %12 OpStore %50 %49 %51 = OpLoad %9 %22 %52 = OpAccessChain %10 %35 %12 %18 OpStore %52 %51 %53 = OpAccessChain %10 %35 %12 %12 %54 = OpLoad %9 %53 %55 = OpAccessChain %10 %35 %18 OpStore %55 %54 %200 = OpCompositeConstruct %9 %25 %19 %201 = OpCompositeConstruct %33 %46 %200 %56 %57 = OpAccessChain %16 %35 %38 OpStore %57 %56 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationCompositeConstructTest, ConstructVectors) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %9 "v2" OpName %27 "v3" OpName %46 "v4" OpName %53 "iv2" OpName %61 "uv3" OpName %72 "bv4" OpName %88 "uv2" OpName %95 "bv3" OpName %104 "bv2" OpName %116 "iv3" OpName %124 "iv4" OpName %133 "uv4" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 2 %8 = OpTypePointer Function %7 %10 = OpConstant %6 1 %11 = OpConstant %6 2 %12 = OpConstantComposite %7 %10 %11 %13 = OpTypeInt 32 0 %14 = OpConstant %13 0 %15 = OpTypePointer Function %6 %18 = OpConstant %13 1 %21 = OpTypeBool %25 = OpTypeVector %6 3 %26 = OpTypePointer Function %25 %33 = OpConstant %6 3 %34 = OpConstant %6 -0.756802499 %38 = OpConstant %13 2 %44 = OpTypeVector %6 4 %45 = OpTypePointer Function %44 %50 = OpTypeInt 32 1 %51 = OpTypeVector %50 2 %52 = OpTypePointer Function %51 %57 = OpTypePointer Function %50 %59 = OpTypeVector %13 3 %60 = OpTypePointer Function %59 %65 = OpConstant %13 3 %67 = OpTypePointer Function %13 %70 = OpTypeVector %21 4 %71 = OpTypePointer Function %70 %73 = OpConstantTrue %21 %74 = OpTypePointer Function %21 %86 = OpTypeVector %13 2 %87 = OpTypePointer Function %86 %93 = OpTypeVector %21 3 %94 = OpTypePointer Function %93 %102 = OpTypeVector %21 2 %103 = OpTypePointer Function %102 %111 = OpConstantFalse %21 %114 = OpTypeVector %50 3 %115 = OpTypePointer Function %114 %117 = OpConstant %50 3 %122 = OpTypeVector %50 4 %123 = OpTypePointer Function %122 %131 = OpTypeVector %13 4 %132 = OpTypePointer Function %131 %4 = OpFunction %2 None %3 %5 = OpLabel %9 = OpVariable %8 Function %27 = OpVariable %26 Function %46 = OpVariable %45 Function %53 = OpVariable %52 Function %61 = OpVariable %60 Function %72 = OpVariable %71 Function %88 = OpVariable %87 Function %95 = OpVariable %94 Function %104 = OpVariable %103 Function %116 = OpVariable %115 Function %124 = OpVariable %123 Function %133 = OpVariable %132 Function OpStore %9 %12 %16 = OpAccessChain %15 %9 %14 %17 = OpLoad %6 %16 %19 = OpAccessChain %15 %9 %18 %20 = OpLoad %6 %19 %22 = OpFOrdGreaterThan %21 %17 %20 OpSelectionMerge %24 None OpBranchConditional %22 %23 %101 %23 = OpLabel %28 = OpAccessChain %15 %9 %14 %29 = OpLoad %6 %28 %30 = OpAccessChain %15 %9 %18 %31 = OpLoad %6 %30 %32 = OpFAdd %6 %29 %31 %35 = OpCompositeConstruct %25 %32 %33 %34 OpStore %27 %35 %36 = OpAccessChain %15 %27 %14 %37 = OpLoad %6 %36 %39 = OpAccessChain %15 %27 %38 %40 = OpLoad %6 %39 %41 = OpFOrdLessThan %21 %37 %40 OpSelectionMerge %43 None OpBranchConditional %41 %42 %69 %42 = OpLabel %47 = OpAccessChain %15 %9 %18 %48 = OpLoad %6 %47 %49 = OpAccessChain %15 %46 %14 OpStore %49 %48 %54 = OpAccessChain %15 %27 %38 %55 = OpLoad %6 %54 %56 = OpConvertFToS %50 %55 %58 = OpAccessChain %57 %53 %14 OpStore %58 %56 %62 = OpAccessChain %15 %46 %14 %63 = OpLoad %6 %62 %64 = OpConvertFToU %13 %63 %66 = OpIAdd %13 %64 %65 %68 = OpAccessChain %67 %61 %14 OpStore %68 %66 OpBranch %43 %69 = OpLabel %75 = OpAccessChain %74 %72 %14 OpStore %75 %73 %76 = OpAccessChain %74 %72 %14 %77 = OpLoad %21 %76 %78 = OpLogicalNot %21 %77 %79 = OpAccessChain %74 %72 %18 OpStore %79 %78 %80 = OpAccessChain %74 %72 %14 %81 = OpLoad %21 %80 %82 = OpAccessChain %74 %72 %18 %83 = OpLoad %21 %82 %84 = OpLogicalAnd %21 %81 %83 %85 = OpAccessChain %74 %72 %38 OpStore %85 %84 %89 = OpAccessChain %67 %88 %14 %90 = OpLoad %13 %89 %91 = OpINotEqual %21 %90 %14 %92 = OpAccessChain %74 %72 %65 OpStore %92 %91 OpBranch %43 %43 = OpLabel %96 = OpLoad %70 %72 %97 = OpCompositeExtract %21 %96 0 %98 = OpCompositeExtract %21 %96 1 %99 = OpCompositeExtract %21 %96 2 %100 = OpCompositeConstruct %93 %97 %98 %99 OpStore %95 %100 OpBranch %24 %101 = OpLabel %105 = OpAccessChain %67 %88 %14 %106 = OpLoad %13 %105 %107 = OpINotEqual %21 %106 %14 %108 = OpCompositeConstruct %102 %107 %107 OpStore %104 %108 OpBranch %24 %24 = OpLabel %109 = OpAccessChain %74 %104 %18 %110 = OpLoad %21 %109 %112 = OpLogicalOr %21 %110 %111 %113 = OpAccessChain %74 %104 %14 OpStore %113 %112 %118 = OpAccessChain %57 %116 %14 OpStore %118 %117 %119 = OpAccessChain %57 %116 %14 %120 = OpLoad %50 %119 %121 = OpAccessChain %57 %53 %18 OpStore %121 %120 %125 = OpAccessChain %57 %116 %14 %126 = OpLoad %50 %125 %127 = OpAccessChain %57 %53 %18 %128 = OpLoad %50 %127 %129 = OpIAdd %50 %126 %128 %130 = OpAccessChain %57 %124 %65 OpStore %130 %129 %134 = OpAccessChain %57 %116 %14 %135 = OpLoad %50 %134 %136 = OpBitcast %13 %135 %137 = OpAccessChain %67 %133 %14 OpStore %137 %136 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationCompositeConstruct make_vec2( 7, {17, 11}, MakeInstructionDescriptor(100, spv::Op::OpStore, 0), 200); // Bad: not enough data for a vec2 TransformationCompositeConstruct make_vec2_bad( 7, {11}, MakeInstructionDescriptor(100, spv::Op::OpStore, 0), 200); ASSERT_TRUE(make_vec2.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( make_vec2_bad.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(make_vec2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(17, {}), MakeDataDescriptor(200, {0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(11, {}), MakeDataDescriptor(200, {1}))); TransformationCompositeConstruct make_vec3( 25, {12, 32}, MakeInstructionDescriptor(35, spv::Op::OpCompositeConstruct, 0), 201); // Bad: too much data for a vec3 TransformationCompositeConstruct make_vec3_bad( 25, {12, 32, 32}, MakeInstructionDescriptor(35, spv::Op::OpCompositeConstruct, 0), 201); ASSERT_TRUE(make_vec3.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( make_vec3_bad.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(make_vec3, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(12, {0}), MakeDataDescriptor(201, {0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(12, {1}), MakeDataDescriptor(201, {1}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(32, {}), MakeDataDescriptor(201, {2}))); TransformationCompositeConstruct make_vec4( 44, {32, 32, 10, 11}, MakeInstructionDescriptor(75, spv::Op::OpAccessChain, 0), 202); // Bad: id 48 is not available at the insertion points TransformationCompositeConstruct make_vec4_bad( 44, {48, 32, 10, 11}, MakeInstructionDescriptor(75, spv::Op::OpAccessChain, 0), 202); ASSERT_TRUE(make_vec4.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( make_vec4_bad.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(make_vec4, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(32, {}), MakeDataDescriptor(202, {0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(32, {}), MakeDataDescriptor(202, {1}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(10, {}), MakeDataDescriptor(202, {2}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(11, {}), MakeDataDescriptor(202, {3}))); TransformationCompositeConstruct make_ivec2( 51, {126, 120}, MakeInstructionDescriptor(128, spv::Op::OpLoad, 0), 203); // Bad: if 128 is not available at the instruction that defines 128 TransformationCompositeConstruct make_ivec2_bad( 51, {128, 120}, MakeInstructionDescriptor(128, spv::Op::OpLoad, 0), 203); ASSERT_TRUE(make_ivec2.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( make_ivec2_bad.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(make_ivec2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(126, {}), MakeDataDescriptor(203, {0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(120, {}), MakeDataDescriptor(203, {1}))); TransformationCompositeConstruct make_ivec3( 114, {56, 117, 56}, MakeInstructionDescriptor(66, spv::Op::OpAccessChain, 0), 204); // Bad because 1300 is not an id TransformationCompositeConstruct make_ivec3_bad( 114, {56, 117, 1300}, MakeInstructionDescriptor(66, spv::Op::OpAccessChain, 0), 204); ASSERT_TRUE(make_ivec3.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( make_ivec3_bad.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(make_ivec3, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(56, {}), MakeDataDescriptor(204, {0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(117, {}), MakeDataDescriptor(204, {1}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(56, {}), MakeDataDescriptor(204, {2}))); TransformationCompositeConstruct make_ivec4( 122, {56, 117, 117, 117}, MakeInstructionDescriptor(66, spv::Op::OpIAdd, 0), 205); // Bad because 86 is the wrong type. TransformationCompositeConstruct make_ivec4_bad( 86, {56, 117, 117, 117}, MakeInstructionDescriptor(66, spv::Op::OpIAdd, 0), 205); ASSERT_TRUE(make_ivec4.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( make_ivec4_bad.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(make_ivec4, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(56, {}), MakeDataDescriptor(205, {0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(117, {}), MakeDataDescriptor(205, {1}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(117, {}), MakeDataDescriptor(205, {2}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(117, {}), MakeDataDescriptor(205, {3}))); TransformationCompositeConstruct make_uvec2( 86, {18, 38}, MakeInstructionDescriptor(133, spv::Op::OpAccessChain, 0), 206); TransformationCompositeConstruct make_uvec2_bad( 86, {18, 38}, MakeInstructionDescriptor(133, spv::Op::OpAccessChain, 200), 206); ASSERT_TRUE(make_uvec2.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( make_uvec2_bad.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(make_uvec2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(18, {}), MakeDataDescriptor(206, {0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(38, {}), MakeDataDescriptor(206, {1}))); TransformationCompositeConstruct make_uvec3( 59, {14, 18, 136}, MakeInstructionDescriptor(137, spv::Op::OpReturn, 0), 207); // Bad because 1300 is not an id TransformationCompositeConstruct make_uvec3_bad( 59, {14, 18, 1300}, MakeInstructionDescriptor(137, spv::Op::OpReturn, 0), 207); ASSERT_TRUE(make_uvec3.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( make_uvec3_bad.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(make_uvec3, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(14, {}), MakeDataDescriptor(207, {0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(18, {}), MakeDataDescriptor(207, {1}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(136, {}), MakeDataDescriptor(207, {2}))); TransformationCompositeConstruct make_uvec4( 131, {14, 18, 136, 136}, MakeInstructionDescriptor(137, spv::Op::OpAccessChain, 0), 208); // Bad because 86 is the wrong type. TransformationCompositeConstruct make_uvec4_bad( 86, {14, 18, 136, 136}, MakeInstructionDescriptor(137, spv::Op::OpAccessChain, 0), 208); ASSERT_TRUE(make_uvec4.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( make_uvec4_bad.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(make_uvec4, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(14, {}), MakeDataDescriptor(208, {0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(18, {}), MakeDataDescriptor(208, {1}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(136, {}), MakeDataDescriptor(208, {2}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(136, {}), MakeDataDescriptor(208, {3}))); TransformationCompositeConstruct make_bvec2( 102, { 111, 41, }, MakeInstructionDescriptor(75, spv::Op::OpAccessChain, 0), 209); // Bad because 0 is not a valid base instruction id TransformationCompositeConstruct make_bvec2_bad( 102, { 111, 41, }, MakeInstructionDescriptor(0, spv::Op::OpExtInstImport, 0), 209); ASSERT_TRUE(make_bvec2.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( make_bvec2_bad.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(make_bvec2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(111, {}), MakeDataDescriptor(209, {0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(41, {}), MakeDataDescriptor(209, {1}))); TransformationCompositeConstruct make_bvec3( 93, {108, 73}, MakeInstructionDescriptor(108, spv::Op::OpStore, 0), 210); // Bad because there are too many components for a bvec3 TransformationCompositeConstruct make_bvec3_bad( 93, {108, 108}, MakeInstructionDescriptor(108, spv::Op::OpStore, 0), 210); ASSERT_TRUE(make_bvec3.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( make_bvec3_bad.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(make_bvec3, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(108, {0}), MakeDataDescriptor(210, {0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(108, {1}), MakeDataDescriptor(210, {1}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(73, {}), MakeDataDescriptor(210, {2}))); TransformationCompositeConstruct make_bvec4( 70, {108, 108}, MakeInstructionDescriptor(108, spv::Op::OpBranch, 0), 211); // Bad because 21 is a type, not a result id TransformationCompositeConstruct make_bvec4_bad( 70, {21, 108}, MakeInstructionDescriptor(108, spv::Op::OpBranch, 0), 211); ASSERT_TRUE(make_bvec4.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( make_bvec4_bad.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(make_bvec4, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(108, {0}), MakeDataDescriptor(211, {0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(108, {1}), MakeDataDescriptor(211, {1}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(108, {0}), MakeDataDescriptor(211, {2}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(108, {1}), MakeDataDescriptor(211, {3}))); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %9 "v2" OpName %27 "v3" OpName %46 "v4" OpName %53 "iv2" OpName %61 "uv3" OpName %72 "bv4" OpName %88 "uv2" OpName %95 "bv3" OpName %104 "bv2" OpName %116 "iv3" OpName %124 "iv4" OpName %133 "uv4" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 2 %8 = OpTypePointer Function %7 %10 = OpConstant %6 1 %11 = OpConstant %6 2 %12 = OpConstantComposite %7 %10 %11 %13 = OpTypeInt 32 0 %14 = OpConstant %13 0 %15 = OpTypePointer Function %6 %18 = OpConstant %13 1 %21 = OpTypeBool %25 = OpTypeVector %6 3 %26 = OpTypePointer Function %25 %33 = OpConstant %6 3 %34 = OpConstant %6 -0.756802499 %38 = OpConstant %13 2 %44 = OpTypeVector %6 4 %45 = OpTypePointer Function %44 %50 = OpTypeInt 32 1 %51 = OpTypeVector %50 2 %52 = OpTypePointer Function %51 %57 = OpTypePointer Function %50 %59 = OpTypeVector %13 3 %60 = OpTypePointer Function %59 %65 = OpConstant %13 3 %67 = OpTypePointer Function %13 %70 = OpTypeVector %21 4 %71 = OpTypePointer Function %70 %73 = OpConstantTrue %21 %74 = OpTypePointer Function %21 %86 = OpTypeVector %13 2 %87 = OpTypePointer Function %86 %93 = OpTypeVector %21 3 %94 = OpTypePointer Function %93 %102 = OpTypeVector %21 2 %103 = OpTypePointer Function %102 %111 = OpConstantFalse %21 %114 = OpTypeVector %50 3 %115 = OpTypePointer Function %114 %117 = OpConstant %50 3 %122 = OpTypeVector %50 4 %123 = OpTypePointer Function %122 %131 = OpTypeVector %13 4 %132 = OpTypePointer Function %131 %4 = OpFunction %2 None %3 %5 = OpLabel %9 = OpVariable %8 Function %27 = OpVariable %26 Function %46 = OpVariable %45 Function %53 = OpVariable %52 Function %61 = OpVariable %60 Function %72 = OpVariable %71 Function %88 = OpVariable %87 Function %95 = OpVariable %94 Function %104 = OpVariable %103 Function %116 = OpVariable %115 Function %124 = OpVariable %123 Function %133 = OpVariable %132 Function OpStore %9 %12 %206 = OpCompositeConstruct %86 %18 %38 %16 = OpAccessChain %15 %9 %14 %17 = OpLoad %6 %16 %19 = OpAccessChain %15 %9 %18 %20 = OpLoad %6 %19 %22 = OpFOrdGreaterThan %21 %17 %20 OpSelectionMerge %24 None OpBranchConditional %22 %23 %101 %23 = OpLabel %28 = OpAccessChain %15 %9 %14 %29 = OpLoad %6 %28 %30 = OpAccessChain %15 %9 %18 %31 = OpLoad %6 %30 %32 = OpFAdd %6 %29 %31 %201 = OpCompositeConstruct %25 %12 %32 %35 = OpCompositeConstruct %25 %32 %33 %34 OpStore %27 %35 %36 = OpAccessChain %15 %27 %14 %37 = OpLoad %6 %36 %39 = OpAccessChain %15 %27 %38 %40 = OpLoad %6 %39 %41 = OpFOrdLessThan %21 %37 %40 OpSelectionMerge %43 None OpBranchConditional %41 %42 %69 %42 = OpLabel %47 = OpAccessChain %15 %9 %18 %48 = OpLoad %6 %47 %49 = OpAccessChain %15 %46 %14 OpStore %49 %48 %54 = OpAccessChain %15 %27 %38 %55 = OpLoad %6 %54 %56 = OpConvertFToS %50 %55 %58 = OpAccessChain %57 %53 %14 OpStore %58 %56 %62 = OpAccessChain %15 %46 %14 %63 = OpLoad %6 %62 %64 = OpConvertFToU %13 %63 %205 = OpCompositeConstruct %122 %56 %117 %117 %117 %66 = OpIAdd %13 %64 %65 %204 = OpCompositeConstruct %114 %56 %117 %56 %68 = OpAccessChain %67 %61 %14 OpStore %68 %66 OpBranch %43 %69 = OpLabel %202 = OpCompositeConstruct %44 %32 %32 %10 %11 %209 = OpCompositeConstruct %102 %111 %41 %75 = OpAccessChain %74 %72 %14 OpStore %75 %73 %76 = OpAccessChain %74 %72 %14 %77 = OpLoad %21 %76 %78 = OpLogicalNot %21 %77 %79 = OpAccessChain %74 %72 %18 OpStore %79 %78 %80 = OpAccessChain %74 %72 %14 %81 = OpLoad %21 %80 %82 = OpAccessChain %74 %72 %18 %83 = OpLoad %21 %82 %84 = OpLogicalAnd %21 %81 %83 %85 = OpAccessChain %74 %72 %38 OpStore %85 %84 %89 = OpAccessChain %67 %88 %14 %90 = OpLoad %13 %89 %91 = OpINotEqual %21 %90 %14 %92 = OpAccessChain %74 %72 %65 OpStore %92 %91 OpBranch %43 %43 = OpLabel %96 = OpLoad %70 %72 %97 = OpCompositeExtract %21 %96 0 %98 = OpCompositeExtract %21 %96 1 %99 = OpCompositeExtract %21 %96 2 %100 = OpCompositeConstruct %93 %97 %98 %99 %200 = OpCompositeConstruct %7 %17 %11 OpStore %95 %100 OpBranch %24 %101 = OpLabel %105 = OpAccessChain %67 %88 %14 %106 = OpLoad %13 %105 %107 = OpINotEqual %21 %106 %14 %108 = OpCompositeConstruct %102 %107 %107 %210 = OpCompositeConstruct %93 %108 %73 OpStore %104 %108 %211 = OpCompositeConstruct %70 %108 %108 OpBranch %24 %24 = OpLabel %109 = OpAccessChain %74 %104 %18 %110 = OpLoad %21 %109 %112 = OpLogicalOr %21 %110 %111 %113 = OpAccessChain %74 %104 %14 OpStore %113 %112 %118 = OpAccessChain %57 %116 %14 OpStore %118 %117 %119 = OpAccessChain %57 %116 %14 %120 = OpLoad %50 %119 %121 = OpAccessChain %57 %53 %18 OpStore %121 %120 %125 = OpAccessChain %57 %116 %14 %126 = OpLoad %50 %125 %127 = OpAccessChain %57 %53 %18 %203 = OpCompositeConstruct %51 %126 %120 %128 = OpLoad %50 %127 %129 = OpIAdd %50 %126 %128 %130 = OpAccessChain %57 %124 %65 OpStore %130 %129 %134 = OpAccessChain %57 %116 %14 %135 = OpLoad %50 %134 %136 = OpBitcast %13 %135 %208 = OpCompositeConstruct %131 %14 %18 %136 %136 %137 = OpAccessChain %67 %133 %14 OpStore %137 %136 %207 = OpCompositeConstruct %59 %14 %18 %136 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationCompositeConstructTest, AddSynonymsForRelevantIds) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 3 %8 = OpTypePointer Function %7 %10 = OpConstant %6 1 %11 = OpConstantComposite %7 %10 %10 %10 %17 = OpTypeVector %6 4 %18 = OpTypePointer Function %17 %21 = OpConstant %6 2 %32 = OpTypeMatrix %17 3 %33 = OpTypePointer Private %32 %34 = OpVariable %33 Private %35 = OpTypeMatrix %7 4 %36 = OpTypePointer Private %35 %37 = OpVariable %36 Private %38 = OpTypeVector %6 2 %39 = OpTypeInt 32 0 %40 = OpConstant %39 3 %41 = OpTypeArray %38 %40 %42 = OpTypePointer Private %41 %43 = OpVariable %42 Private %100 = OpUndef %7 %101 = OpUndef %17 %4 = OpFunction %2 None %3 %5 = OpLabel %9 = OpVariable %8 Function %12 = OpVariable %8 Function %14 = OpVariable %8 Function %19 = OpVariable %18 Function %26 = OpVariable %18 Function %29 = OpVariable %18 Function OpStore %9 %11 %13 = OpLoad %7 %9 OpStore %12 %13 %15 = OpLoad %7 %12 %16 = OpVectorShuffle %7 %15 %15 2 1 0 OpStore %14 %16 %20 = OpLoad %7 %14 %22 = OpCompositeExtract %6 %20 0 %23 = OpCompositeExtract %6 %20 1 %24 = OpCompositeExtract %6 %20 2 %25 = OpCompositeConstruct %17 %22 %23 %24 %21 OpStore %19 %25 %27 = OpLoad %17 %19 %28 = OpVectorShuffle %17 %27 %27 3 2 1 0 OpStore %26 %28 %30 = OpLoad %7 %9 %31 = OpVectorShuffle %17 %30 %30 0 0 1 1 OpStore %29 %31 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationCompositeConstruct transformation( 32, {25, 28, 31}, MakeInstructionDescriptor(31, spv::Op::OpReturn, 0), 200); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(25, {}), MakeDataDescriptor(200, {0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(28, {}), MakeDataDescriptor(200, {1}))); } TEST(TransformationCompositeConstructTest, DontAddSynonymsForIrrelevantIds) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 3 %8 = OpTypePointer Function %7 %10 = OpConstant %6 1 %11 = OpConstantComposite %7 %10 %10 %10 %17 = OpTypeVector %6 4 %18 = OpTypePointer Function %17 %21 = OpConstant %6 2 %32 = OpTypeMatrix %17 3 %33 = OpTypePointer Private %32 %34 = OpVariable %33 Private %35 = OpTypeMatrix %7 4 %36 = OpTypePointer Private %35 %37 = OpVariable %36 Private %38 = OpTypeVector %6 2 %39 = OpTypeInt 32 0 %40 = OpConstant %39 3 %41 = OpTypeArray %38 %40 %42 = OpTypePointer Private %41 %43 = OpVariable %42 Private %100 = OpUndef %7 %101 = OpUndef %17 %4 = OpFunction %2 None %3 %5 = OpLabel %9 = OpVariable %8 Function %12 = OpVariable %8 Function %14 = OpVariable %8 Function %19 = OpVariable %18 Function %26 = OpVariable %18 Function %29 = OpVariable %18 Function OpStore %9 %11 %13 = OpLoad %7 %9 OpStore %12 %13 %15 = OpLoad %7 %12 %16 = OpVectorShuffle %7 %15 %15 2 1 0 OpStore %14 %16 %20 = OpLoad %7 %14 %22 = OpCompositeExtract %6 %20 0 %23 = OpCompositeExtract %6 %20 1 %24 = OpCompositeExtract %6 %20 2 %25 = OpCompositeConstruct %17 %22 %23 %24 %21 OpStore %19 %25 %27 = OpLoad %17 %19 %28 = OpVectorShuffle %17 %27 %27 3 2 1 0 OpStore %26 %28 %30 = OpLoad %7 %9 %31 = OpVectorShuffle %17 %30 %30 0 0 1 1 OpStore %29 %31 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactIdIsIrrelevant(25); TransformationCompositeConstruct transformation( 32, {25, 28, 31}, MakeInstructionDescriptor(31, spv::Op::OpReturn, 0), 200); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(25, {}), MakeDataDescriptor(200, {0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(28, {}), MakeDataDescriptor(200, {1}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(31, {}), MakeDataDescriptor(200, {2}))); } TEST(TransformationCompositeConstructTest, DontAddSynonymsInDeadBlock) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeVector %6 2 %8 = OpTypePointer Function %7 %10 = OpConstant %6 0 %11 = OpConstant %6 1 %12 = OpConstantComposite %7 %10 %11 %13 = OpTypeBool %14 = OpConstantFalse %13 %4 = OpFunction %2 None %3 %5 = OpLabel %9 = OpVariable %8 Function OpStore %9 %12 OpSelectionMerge %16 None OpBranchConditional %14 %15 %16 %15 = OpLabel OpBranch %16 %16 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactBlockIsDead(15); TransformationCompositeConstruct transformation( 7, {10, 11}, MakeInstructionDescriptor(15, spv::Op::OpBranch, 0), 100); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(100, {0}), MakeDataDescriptor(10, {}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(100, {1}), MakeDataDescriptor(11, {}))); } TEST(TransformationCompositeConstructTest, OneIrrelevantComponent) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeStruct %6 %6 %6 %8 = OpConstant %6 42 %9 = OpConstant %6 50 %10 = OpConstant %6 51 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactIdIsIrrelevant(8); TransformationCompositeConstruct transformation( 7, {8, 9, 10}, MakeInstructionDescriptor(5, spv::Op::OpReturn, 0), 100); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(100, {0}), MakeDataDescriptor(8, {}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(100, {1}), MakeDataDescriptor(9, {}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(100, {2}), MakeDataDescriptor(10, {}))); } TEST(TransformationCompositeConstructTest, IrrelevantVec2ThenFloat) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 2 %8 = OpTypeVector %6 3 %9 = OpConstant %6 0 %11 = OpConstant %6 1 %12 = OpConstant %6 2 %10 = OpConstantComposite %7 %11 %12 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactIdIsIrrelevant(10); TransformationCompositeConstruct transformation( 8, {10, 9}, MakeInstructionDescriptor(5, spv::Op::OpReturn, 0), 100); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(100, {0}), MakeDataDescriptor(10, {0}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(100, {1}), MakeDataDescriptor(10, {1}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(100, {2}), MakeDataDescriptor(9, {}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(100, {1}), MakeDataDescriptor(9, {}))); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_composite_extract_test.cpp000066400000000000000000000637401475742701700311450ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_composite_extract.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationCompositeExtractTest, BasicTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "a" OpName %10 "b" OpName %17 "FunnyPoint" OpMemberName %17 0 "x" OpMemberName %17 1 "y" OpMemberName %17 2 "z" OpName %19 "p" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %12 = OpTypeBool %16 = OpTypeFloat 32 %17 = OpTypeStruct %16 %16 %6 %81 = OpTypeStruct %17 %16 %18 = OpTypePointer Function %17 %20 = OpConstant %6 0 %23 = OpTypePointer Function %16 %26 = OpConstant %6 1 %30 = OpConstant %6 2 %80 = OpUndef %16 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %19 = OpVariable %18 Function %9 = OpLoad %6 %8 %11 = OpLoad %6 %10 %100 = OpCompositeConstruct %17 %80 %80 %26 %104 = OpCompositeConstruct %81 %100 %80 %13 = OpIEqual %12 %9 %11 OpSelectionMerge %15 None OpBranchConditional %13 %14 %25 %14 = OpLabel %21 = OpLoad %6 %8 %22 = OpConvertSToF %16 %21 %101 = OpCompositeConstruct %17 %22 %80 %30 %24 = OpAccessChain %23 %19 %20 OpStore %24 %22 OpBranch %15 %25 = OpLabel %27 = OpLoad %6 %10 %28 = OpConvertSToF %16 %27 %102 = OpCompositeConstruct %17 %80 %28 %27 %29 = OpAccessChain %23 %19 %26 OpStore %29 %28 OpBranch %15 %15 = OpLabel %31 = OpAccessChain %23 %19 %20 %32 = OpLoad %16 %31 %33 = OpAccessChain %23 %19 %26 %34 = OpLoad %16 %33 %103 = OpCompositeConstruct %17 %34 %32 %9 %35 = OpFAdd %16 %32 %34 %36 = OpConvertFToS %6 %35 %37 = OpAccessChain %7 %19 %30 OpStore %37 %36 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Instruction does not exist. ASSERT_FALSE( TransformationCompositeExtract( MakeInstructionDescriptor(36, spv::Op::OpIAdd, 0), 200, 101, {0}) .IsApplicable(context.get(), transformation_context)); // Id for composite is not a composite. ASSERT_FALSE( TransformationCompositeExtract( MakeInstructionDescriptor(37, spv::Op::OpAccessChain, 0), 200, 32, {}) .IsApplicable(context.get(), transformation_context)); // Composite does not dominate instruction being inserted before. ASSERT_FALSE(TransformationCompositeExtract( MakeInstructionDescriptor(37, spv::Op::OpAccessChain, 0), 200, 101, {0}) .IsApplicable(context.get(), transformation_context)); // Too many indices for extraction from struct composite. ASSERT_FALSE(TransformationCompositeExtract( MakeInstructionDescriptor(24, spv::Op::OpAccessChain, 0), 200, 101, {0, 0}) .IsApplicable(context.get(), transformation_context)); // Too many indices for extraction from struct composite. ASSERT_FALSE(TransformationCompositeExtract( MakeInstructionDescriptor(13, spv::Op::OpIEqual, 0), 200, 104, {0, 0, 0}) .IsApplicable(context.get(), transformation_context)); // Out of bounds index for extraction from struct composite. ASSERT_FALSE( TransformationCompositeExtract( MakeInstructionDescriptor(13, spv::Op::OpIEqual, 0), 200, 104, {0, 3}) .IsApplicable(context.get(), transformation_context)); // Result id already used. ASSERT_FALSE( TransformationCompositeExtract( MakeInstructionDescriptor(35, spv::Op::OpFAdd, 0), 80, 103, {0}) .IsApplicable(context.get(), transformation_context)); TransformationCompositeExtract transformation_1( MakeInstructionDescriptor(36, spv::Op::OpConvertFToS, 0), 201, 100, {2}); ASSERT_EQ(nullptr, context->get_def_use_mgr()->GetDef(201)); ASSERT_EQ(nullptr, context->get_instr_block(201)); uint32_t num_uses_of_100_before = context->get_def_use_mgr()->NumUses(100); ASSERT_TRUE( transformation_1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_1, context.get(), &transformation_context); ASSERT_EQ(spv::Op::OpCompositeExtract, context->get_def_use_mgr()->GetDef(201)->opcode()); ASSERT_EQ(15, context->get_instr_block(201)->id()); ASSERT_EQ(num_uses_of_100_before + 1, context->get_def_use_mgr()->NumUses(100)); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationCompositeExtract transformation_2( MakeInstructionDescriptor(37, spv::Op::OpAccessChain, 0), 202, 104, {0, 2}); ASSERT_TRUE( transformation_2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationCompositeExtract transformation_3( MakeInstructionDescriptor(29, spv::Op::OpAccessChain, 0), 203, 104, {0}); ASSERT_TRUE( transformation_3.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_3, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationCompositeExtract transformation_4( MakeInstructionDescriptor(24, spv::Op::OpStore, 0), 204, 101, {0}); ASSERT_TRUE( transformation_4.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_4, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationCompositeExtract transformation_5( MakeInstructionDescriptor(29, spv::Op::OpBranch, 0), 205, 102, {2}); ASSERT_TRUE( transformation_5.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_5, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationCompositeExtract transformation_6( MakeInstructionDescriptor(37, spv::Op::OpReturn, 0), 206, 103, {1}); ASSERT_TRUE( transformation_6.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_6, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(201, {}), MakeDataDescriptor(100, {2}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(202, {}), MakeDataDescriptor(104, {0, 2}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(203, {}), MakeDataDescriptor(104, {0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(204, {}), MakeDataDescriptor(101, {0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(205, {}), MakeDataDescriptor(102, {2}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(206, {}), MakeDataDescriptor(103, {1}))); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "a" OpName %10 "b" OpName %17 "FunnyPoint" OpMemberName %17 0 "x" OpMemberName %17 1 "y" OpMemberName %17 2 "z" OpName %19 "p" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %12 = OpTypeBool %16 = OpTypeFloat 32 %17 = OpTypeStruct %16 %16 %6 %81 = OpTypeStruct %17 %16 %18 = OpTypePointer Function %17 %20 = OpConstant %6 0 %23 = OpTypePointer Function %16 %26 = OpConstant %6 1 %30 = OpConstant %6 2 %80 = OpUndef %16 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %19 = OpVariable %18 Function %9 = OpLoad %6 %8 %11 = OpLoad %6 %10 %100 = OpCompositeConstruct %17 %80 %80 %26 %104 = OpCompositeConstruct %81 %100 %80 %13 = OpIEqual %12 %9 %11 OpSelectionMerge %15 None OpBranchConditional %13 %14 %25 %14 = OpLabel %21 = OpLoad %6 %8 %22 = OpConvertSToF %16 %21 %101 = OpCompositeConstruct %17 %22 %80 %30 %24 = OpAccessChain %23 %19 %20 %204 = OpCompositeExtract %16 %101 0 OpStore %24 %22 OpBranch %15 %25 = OpLabel %27 = OpLoad %6 %10 %28 = OpConvertSToF %16 %27 %102 = OpCompositeConstruct %17 %80 %28 %27 %203 = OpCompositeExtract %17 %104 0 %29 = OpAccessChain %23 %19 %26 OpStore %29 %28 %205 = OpCompositeExtract %6 %102 2 OpBranch %15 %15 = OpLabel %31 = OpAccessChain %23 %19 %20 %32 = OpLoad %16 %31 %33 = OpAccessChain %23 %19 %26 %34 = OpLoad %16 %33 %103 = OpCompositeConstruct %17 %34 %32 %9 %35 = OpFAdd %16 %32 %34 %201 = OpCompositeExtract %6 %100 2 %36 = OpConvertFToS %6 %35 %202 = OpCompositeExtract %6 %104 0 2 %37 = OpAccessChain %7 %19 %30 OpStore %37 %36 %206 = OpCompositeExtract %16 %103 1 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationCompositeExtractTest, IllegalInsertionPoints) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %51 %27 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %25 "buf" OpMemberName %25 0 "value" OpName %27 "" OpName %51 "color" OpMemberDecorate %25 0 Offset 0 OpDecorate %25 Block OpDecorate %27 DescriptorSet 0 OpDecorate %27 Binding 0 OpDecorate %51 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %10 = OpConstant %6 0.300000012 %11 = OpConstant %6 0.400000006 %12 = OpConstant %6 0.5 %13 = OpConstant %6 1 %14 = OpConstantComposite %7 %10 %11 %12 %13 %15 = OpTypeInt 32 1 %18 = OpConstant %15 0 %25 = OpTypeStruct %6 %26 = OpTypePointer Uniform %25 %27 = OpVariable %26 Uniform %28 = OpTypePointer Uniform %6 %32 = OpTypeBool %103 = OpConstantTrue %32 %34 = OpConstant %6 0.100000001 %48 = OpConstant %15 1 %50 = OpTypePointer Output %7 %51 = OpVariable %50 Output %100 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %5 = OpLabel %101 = OpVariable %100 Function %102 = OpVariable %100 Function OpBranch %19 %19 = OpLabel %60 = OpPhi %7 %14 %5 %58 %20 %59 = OpPhi %15 %18 %5 %49 %20 %29 = OpAccessChain %28 %27 %18 %30 = OpLoad %6 %29 %31 = OpConvertFToS %15 %30 %33 = OpSLessThan %32 %59 %31 OpLoopMerge %21 %20 None OpBranchConditional %33 %20 %21 %20 = OpLabel %39 = OpCompositeExtract %6 %60 0 %40 = OpFAdd %6 %39 %34 %55 = OpCompositeInsert %7 %40 %60 0 %44 = OpCompositeExtract %6 %60 1 %45 = OpFSub %6 %44 %34 %58 = OpCompositeInsert %7 %45 %55 1 %49 = OpIAdd %15 %59 %48 OpBranch %19 %21 = OpLabel OpStore %51 %60 OpSelectionMerge %105 None OpBranchConditional %103 %104 %105 %104 = OpLabel OpBranch %105 %105 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Cannot insert before the OpVariables of a function. ASSERT_FALSE( TransformationCompositeExtract( MakeInstructionDescriptor(101, spv::Op::OpVariable, 0), 200, 14, {0}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( TransformationCompositeExtract( MakeInstructionDescriptor(101, spv::Op::OpVariable, 1), 200, 14, {1}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( TransformationCompositeExtract( MakeInstructionDescriptor(102, spv::Op::OpVariable, 0), 200, 14, {1}) .IsApplicable(context.get(), transformation_context)); // OK to insert right after the OpVariables. ASSERT_FALSE( TransformationCompositeExtract( MakeInstructionDescriptor(102, spv::Op::OpBranch, 1), 200, 14, {1}) .IsApplicable(context.get(), transformation_context)); // Cannot insert before the OpPhis of a block. ASSERT_FALSE( TransformationCompositeExtract( MakeInstructionDescriptor(60, spv::Op::OpPhi, 0), 200, 14, {2}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( TransformationCompositeExtract( MakeInstructionDescriptor(59, spv::Op::OpPhi, 0), 200, 14, {3}) .IsApplicable(context.get(), transformation_context)); // OK to insert after the OpPhis. ASSERT_TRUE(TransformationCompositeExtract( MakeInstructionDescriptor(59, spv::Op::OpAccessChain, 0), 200, 14, {3}) .IsApplicable(context.get(), transformation_context)); // Cannot insert before OpLoopMerge ASSERT_FALSE( TransformationCompositeExtract( MakeInstructionDescriptor(33, spv::Op::OpBranchConditional, 0), 200, 14, {3}) .IsApplicable(context.get(), transformation_context)); // Cannot insert before OpSelectionMerge ASSERT_FALSE( TransformationCompositeExtract( MakeInstructionDescriptor(21, spv::Op::OpBranchConditional, 0), 200, 14, {2}) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationCompositeExtractTest, AddSynonymsForRelevantIds) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "a" OpName %10 "b" OpName %17 "FunnyPoint" OpMemberName %17 0 "x" OpMemberName %17 1 "y" OpMemberName %17 2 "z" OpName %19 "p" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %12 = OpTypeBool %16 = OpTypeFloat 32 %17 = OpTypeStruct %16 %16 %6 %81 = OpTypeStruct %17 %16 %18 = OpTypePointer Function %17 %20 = OpConstant %6 0 %23 = OpTypePointer Function %16 %26 = OpConstant %6 1 %30 = OpConstant %6 2 %80 = OpUndef %16 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %19 = OpVariable %18 Function %9 = OpLoad %6 %8 %11 = OpLoad %6 %10 %100 = OpCompositeConstruct %17 %80 %80 %26 %104 = OpCompositeConstruct %81 %100 %80 %13 = OpIEqual %12 %9 %11 OpSelectionMerge %15 None OpBranchConditional %13 %14 %25 %14 = OpLabel %21 = OpLoad %6 %8 %22 = OpConvertSToF %16 %21 %101 = OpCompositeConstruct %17 %22 %80 %30 %24 = OpAccessChain %23 %19 %20 OpStore %24 %22 OpBranch %15 %25 = OpLabel %27 = OpLoad %6 %10 %28 = OpConvertSToF %16 %27 %102 = OpCompositeConstruct %17 %80 %28 %27 %29 = OpAccessChain %23 %19 %26 OpStore %29 %28 OpBranch %15 %15 = OpLabel %31 = OpAccessChain %23 %19 %20 %32 = OpLoad %16 %31 %33 = OpAccessChain %23 %19 %26 %34 = OpLoad %16 %33 %103 = OpCompositeConstruct %17 %34 %32 %9 %35 = OpFAdd %16 %32 %34 %36 = OpConvertFToS %6 %35 %37 = OpAccessChain %7 %19 %30 OpStore %37 %36 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationCompositeExtract transformation( MakeInstructionDescriptor(36, spv::Op::OpConvertFToS, 0), 201, 100, {2}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(201, {}), MakeDataDescriptor(100, {2}))); } TEST(TransformationCompositeExtractTest, DontAddSynonymsForIrrelevantIds) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "a" OpName %10 "b" OpName %17 "FunnyPoint" OpMemberName %17 0 "x" OpMemberName %17 1 "y" OpMemberName %17 2 "z" OpName %19 "p" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %12 = OpTypeBool %16 = OpTypeFloat 32 %17 = OpTypeStruct %16 %16 %6 %81 = OpTypeStruct %17 %16 %18 = OpTypePointer Function %17 %20 = OpConstant %6 0 %23 = OpTypePointer Function %16 %26 = OpConstant %6 1 %30 = OpConstant %6 2 %80 = OpUndef %16 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %19 = OpVariable %18 Function %9 = OpLoad %6 %8 %11 = OpLoad %6 %10 %100 = OpCompositeConstruct %17 %80 %80 %26 %104 = OpCompositeConstruct %81 %100 %80 %13 = OpIEqual %12 %9 %11 OpSelectionMerge %15 None OpBranchConditional %13 %14 %25 %14 = OpLabel %21 = OpLoad %6 %8 %22 = OpConvertSToF %16 %21 %101 = OpCompositeConstruct %17 %22 %80 %30 %24 = OpAccessChain %23 %19 %20 OpStore %24 %22 OpBranch %15 %25 = OpLabel %27 = OpLoad %6 %10 %28 = OpConvertSToF %16 %27 %102 = OpCompositeConstruct %17 %80 %28 %27 %29 = OpAccessChain %23 %19 %26 OpStore %29 %28 OpBranch %15 %15 = OpLabel %31 = OpAccessChain %23 %19 %20 %32 = OpLoad %16 %31 %33 = OpAccessChain %23 %19 %26 %34 = OpLoad %16 %33 %103 = OpCompositeConstruct %17 %34 %32 %9 %35 = OpFAdd %16 %32 %34 %36 = OpConvertFToS %6 %35 %37 = OpAccessChain %7 %19 %30 OpStore %37 %36 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactIdIsIrrelevant(100); TransformationCompositeExtract transformation( MakeInstructionDescriptor(36, spv::Op::OpConvertFToS, 0), 201, 100, {2}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(201, {}), MakeDataDescriptor(100, {2}))); } TEST(TransformationCompositeExtractTest, DontAddSynonymInDeadBlock) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeVector %6 2 %8 = OpTypePointer Function %7 %10 = OpConstant %6 0 %11 = OpConstant %6 1 %12 = OpConstantComposite %7 %10 %11 %13 = OpTypeBool %14 = OpConstantFalse %13 %4 = OpFunction %2 None %3 %5 = OpLabel %9 = OpVariable %8 Function OpStore %9 %12 OpSelectionMerge %16 None OpBranchConditional %14 %15 %16 %15 = OpLabel OpBranch %16 %16 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactBlockIsDead(15); TransformationCompositeExtract transformation( MakeInstructionDescriptor(15, spv::Op::OpBranch, 0), 100, 12, {0}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(100, {}), MakeDataDescriptor(12, {0}))); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_composite_insert_test.cpp000066400000000000000000001135221475742701700307710ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_composite_insert.h" #include "gtest/gtest.h" #include "source/fuzz/data_descriptor.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationCompositeInsertTest, NotApplicableScenarios) { // This test handles cases where IsApplicable() returns false. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "i1" OpName %10 "i2" OpName %12 "base" OpMemberName %12 0 "a1" OpMemberName %12 1 "a2" OpName %14 "b" OpName %18 "level_1" OpMemberName %18 0 "b1" OpMemberName %18 1 "b2" OpName %20 "l1" OpName %24 "level_2" OpMemberName %24 0 "c1" OpMemberName %24 1 "c2" OpName %26 "l2" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %11 = OpConstant %6 2 %12 = OpTypeStruct %6 %6 %13 = OpTypePointer Function %12 %18 = OpTypeStruct %12 %12 %19 = OpTypePointer Function %18 %24 = OpTypeStruct %18 %18 %25 = OpTypePointer Function %24 %30 = OpTypeBool %31 = OpConstantTrue %30 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %14 = OpVariable %13 Function %20 = OpVariable %19 Function %26 = OpVariable %25 Function OpStore %8 %9 OpStore %10 %11 %15 = OpLoad %6 %8 %16 = OpLoad %6 %10 %17 = OpCompositeConstruct %12 %15 %16 OpStore %14 %17 %21 = OpLoad %12 %14 %22 = OpLoad %12 %14 %23 = OpCompositeConstruct %18 %21 %22 OpStore %20 %23 %27 = OpLoad %18 %20 %28 = OpLoad %18 %20 %29 = OpCompositeConstruct %24 %27 %28 OpStore %26 %29 OpSelectionMerge %33 None OpBranchConditional %31 %32 %33 %32 = OpLabel OpBranch %33 %33 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Bad: |fresh_id| is not fresh. auto transformation_bad_1 = TransformationCompositeInsert( MakeInstructionDescriptor(29, spv::Op::OpStore, 0), 20, 29, 11, {1, 0, 0}); ASSERT_FALSE( transformation_bad_1.IsApplicable(context.get(), transformation_context)); // Bad: |composite_id| does not refer to a existing instruction. auto transformation_bad_2 = TransformationCompositeInsert( MakeInstructionDescriptor(29, spv::Op::OpStore, 0), 50, 40, 11, {1, 0, 0}); ASSERT_FALSE( transformation_bad_2.IsApplicable(context.get(), transformation_context)); // Bad: |composite_id| does not refer to a composite value. auto transformation_bad_3 = TransformationCompositeInsert( MakeInstructionDescriptor(29, spv::Op::OpStore, 0), 50, 9, 11, {1, 0, 0}); ASSERT_FALSE( transformation_bad_3.IsApplicable(context.get(), transformation_context)); // Bad: |object_id| does not refer to a defined instruction. auto transformation_bad_4 = TransformationCompositeInsert( MakeInstructionDescriptor(29, spv::Op::OpStore, 0), 50, 29, 40, {1, 0, 0}); ASSERT_FALSE( transformation_bad_4.IsApplicable(context.get(), transformation_context)); // Bad: |object_id| cannot refer to a pointer. auto transformation_bad_5 = TransformationCompositeInsert( MakeInstructionDescriptor(29, spv::Op::OpStore, 0), 50, 29, 8, {1, 0, 0}); ASSERT_FALSE( transformation_bad_5.IsApplicable(context.get(), transformation_context)); // Bad: |index| is not a correct index. auto transformation_bad_6 = TransformationCompositeInsert( MakeInstructionDescriptor(29, spv::Op::OpStore, 0), 50, 29, 11, {2, 0, 0}); ASSERT_FALSE( transformation_bad_6.IsApplicable(context.get(), transformation_context)); // Bad: Type id of the object to be inserted and the type id of the // component at |index| are not the same. auto transformation_bad_7 = TransformationCompositeInsert( MakeInstructionDescriptor(29, spv::Op::OpStore, 0), 50, 29, 11, {1, 0}); ASSERT_FALSE( transformation_bad_7.IsApplicable(context.get(), transformation_context)); // Bad: |instruction_to_insert_before| does not refer to a defined // instruction. auto transformation_bad_8 = TransformationCompositeInsert( MakeInstructionDescriptor(29, spv::Op::OpIMul, 0), 50, 29, 11, {1, 0, 0}); ASSERT_FALSE( transformation_bad_8.IsApplicable(context.get(), transformation_context)); // Bad: OpCompositeInsert cannot be inserted before OpBranchConditional with // OpSelectionMerge above it. auto transformation_bad_9 = TransformationCompositeInsert( MakeInstructionDescriptor(29, spv::Op::OpBranchConditional, 0), 50, 29, 11, {1, 0, 0}); ASSERT_FALSE( transformation_bad_9.IsApplicable(context.get(), transformation_context)); // Bad: |composite_id| does not have a type_id. auto transformation_bad_10 = TransformationCompositeInsert( MakeInstructionDescriptor(29, spv::Op::OpStore, 0), 50, 1, 11, {1, 0, 0}); ASSERT_FALSE(transformation_bad_10.IsApplicable(context.get(), transformation_context)); } TEST(TransformationCompositeInsertTest, EmptyCompositeScenarios) { // This test handles cases where either the composite is empty or the // composite contains an empty composite. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "i1" OpName %10 "i2" OpName %12 "base" OpMemberName %12 0 "a1" OpMemberName %12 1 "a2" OpName %14 "b" %2 = OpTypeVoid %60 = OpTypeStruct %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %11 = OpConstant %6 2 %61 = OpConstantComposite %60 %62 = OpConstantComposite %60 %12 = OpTypeStruct %6 %6 %63 = OpTypeStruct %6 %60 %13 = OpTypePointer Function %12 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %14 = OpVariable %13 Function OpStore %8 %9 OpStore %10 %11 %15 = OpLoad %6 %8 %16 = OpLoad %6 %10 %17 = OpCompositeConstruct %12 %15 %16 %64 = OpCompositeConstruct %63 %15 %61 OpStore %14 %17 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Bad: The composite with |composite_id| cannot be empty. auto transformation_bad_1 = TransformationCompositeInsert( MakeInstructionDescriptor(64, spv::Op::OpStore, 0), 50, 61, 62, {1}); ASSERT_FALSE( transformation_bad_1.IsApplicable(context.get(), transformation_context)); // Good: It is possible to insert into a composite an element which is an // empty composite. auto transformation_good_1 = TransformationCompositeInsert( MakeInstructionDescriptor(64, spv::Op::OpStore, 0), 50, 64, 62, {1}); ASSERT_TRUE(transformation_good_1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformations = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "i1" OpName %10 "i2" OpName %12 "base" OpMemberName %12 0 "a1" OpMemberName %12 1 "a2" OpName %14 "b" %2 = OpTypeVoid %60 = OpTypeStruct %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %11 = OpConstant %6 2 %61 = OpConstantComposite %60 %62 = OpConstantComposite %60 %12 = OpTypeStruct %6 %6 %63 = OpTypeStruct %6 %60 %13 = OpTypePointer Function %12 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %14 = OpVariable %13 Function OpStore %8 %9 OpStore %10 %11 %15 = OpLoad %6 %8 %16 = OpLoad %6 %10 %17 = OpCompositeConstruct %12 %15 %16 %64 = OpCompositeConstruct %63 %15 %61 %50 = OpCompositeInsert %63 %62 %64 1 OpStore %14 %17 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformations, context.get())); } TEST(TransformationCompositeInsertTest, IrrelevantCompositeNoSynonyms) { // This test handles cases where either |composite| is irrelevant. // The transformation shouldn't create any synonyms. // The member composite has a different number of elements than the parent // composite. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "i1" OpName %10 "i2" OpName %12 "base" OpMemberName %12 0 "a1" OpMemberName %12 1 "a2" OpName %14 "b" OpName %18 "level_1" OpMemberName %18 0 "b1" OpMemberName %18 1 "b2" OpMemberName %18 2 "b3" OpName %20 "l1" OpName %25 "level_2" OpMemberName %25 0 "c1" OpMemberName %25 1 "c2" OpName %27 "l2" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %11 = OpConstant %6 2 %12 = OpTypeStruct %6 %6 %13 = OpTypePointer Function %12 %18 = OpTypeStruct %12 %12 %12 %19 = OpTypePointer Function %18 %25 = OpTypeStruct %18 %18 %26 = OpTypePointer Function %25 %31 = OpTypeBool %32 = OpConstantTrue %31 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %14 = OpVariable %13 Function %20 = OpVariable %19 Function %27 = OpVariable %26 Function OpStore %8 %9 OpStore %10 %11 %15 = OpLoad %6 %8 %16 = OpLoad %6 %10 %17 = OpCompositeConstruct %12 %15 %16 OpStore %14 %17 %21 = OpLoad %12 %14 %22 = OpLoad %12 %14 %23 = OpLoad %12 %14 %24 = OpCompositeConstruct %18 %21 %22 %23 OpStore %20 %24 %28 = OpLoad %18 %20 %29 = OpLoad %18 %20 %30 = OpCompositeConstruct %25 %28 %29 OpStore %27 %30 OpSelectionMerge %34 None OpBranchConditional %32 %33 %34 %33 = OpLabel OpBranch %34 %34 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Add fact that the composite is irrelevant. transformation_context.GetFactManager()->AddFactIdIsIrrelevant(30); auto transformation_good_1 = TransformationCompositeInsert( MakeInstructionDescriptor(30, spv::Op::OpStore, 0), 50, 30, 11, {1, 0, 0}); ASSERT_TRUE(transformation_good_1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // No synonyms that involve the original object - %30 - should have been // added. ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(30, {0}), MakeDataDescriptor(50, {0}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(30, {1, 1}), MakeDataDescriptor(50, {1, 1}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(30, {1, 2}), MakeDataDescriptor(50, {1, 2}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(30, {1, 0, 1}), MakeDataDescriptor(50, {1, 0, 1}))); // We *should* have a synonym between %11 and the component of %50 into which // it has been inserted. ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(50, {1, 0, 0}), MakeDataDescriptor(11, {}))); } TEST(TransformationCompositeInsertTest, IrrelevantObjectNoSynonyms) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "i1" OpName %10 "i2" OpName %12 "base" OpMemberName %12 0 "a1" OpMemberName %12 1 "a2" OpName %14 "b" OpName %18 "level_1" OpMemberName %18 0 "b1" OpMemberName %18 1 "b2" OpMemberName %18 2 "b3" OpName %20 "l1" OpName %25 "level_2" OpMemberName %25 0 "c1" OpMemberName %25 1 "c2" OpName %27 "l2" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %11 = OpConstant %6 2 %12 = OpTypeStruct %6 %6 %13 = OpTypePointer Function %12 %18 = OpTypeStruct %12 %12 %12 %19 = OpTypePointer Function %18 %25 = OpTypeStruct %18 %18 %26 = OpTypePointer Function %25 %31 = OpTypeBool %32 = OpConstantTrue %31 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %14 = OpVariable %13 Function %20 = OpVariable %19 Function %27 = OpVariable %26 Function OpStore %8 %9 OpStore %10 %11 %15 = OpLoad %6 %8 %16 = OpLoad %6 %10 %17 = OpCompositeConstruct %12 %15 %16 OpStore %14 %17 %21 = OpLoad %12 %14 %22 = OpLoad %12 %14 %23 = OpLoad %12 %14 %24 = OpCompositeConstruct %18 %21 %22 %23 OpStore %20 %24 %28 = OpLoad %18 %20 %29 = OpLoad %18 %20 %30 = OpCompositeConstruct %25 %28 %29 OpStore %27 %30 OpSelectionMerge %34 None OpBranchConditional %32 %33 %34 %33 = OpLabel OpBranch %34 %34 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Add fact that the object is irrelevant. transformation_context.GetFactManager()->AddFactIdIsIrrelevant(11); auto transformation_good_1 = TransformationCompositeInsert( MakeInstructionDescriptor(30, spv::Op::OpStore, 0), 50, 30, 11, {1, 0, 0}); ASSERT_TRUE(transformation_good_1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Since %30 and %50 are not irrelevant, they should be synonymous at all // indices unaffected by the insertion. ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(30, {0}), MakeDataDescriptor(50, {0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(30, {1, 1}), MakeDataDescriptor(50, {1, 1}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(30, {1, 2}), MakeDataDescriptor(50, {1, 2}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(30, {1, 0, 1}), MakeDataDescriptor(50, {1, 0, 1}))); // Since %11 is irrelevant it should not be synonymous with the component into // which it has been inserted. ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(50, {1, 0, 0}), MakeDataDescriptor(11, {}))); } TEST(TransformationCompositeInsertTest, ApplicableCreatedSynonyms) { // This test handles cases where neither |composite| nor |object| is // irrelevant. The transformation should create synonyms. // The member composite has a different number of elements than the parent // composite. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "i1" OpName %10 "i2" OpName %12 "base" OpMemberName %12 0 "a1" OpMemberName %12 1 "a2" OpName %14 "b" OpName %18 "level_1" OpMemberName %18 0 "b1" OpMemberName %18 1 "b2" OpMemberName %18 2 "b3" OpName %20 "l1" OpName %25 "level_2" OpMemberName %25 0 "c1" OpMemberName %25 1 "c2" OpName %27 "l2" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %11 = OpConstant %6 2 %12 = OpTypeStruct %6 %6 %13 = OpTypePointer Function %12 %18 = OpTypeStruct %12 %12 %12 %19 = OpTypePointer Function %18 %25 = OpTypeStruct %18 %18 %26 = OpTypePointer Function %25 %31 = OpTypeBool %32 = OpConstantTrue %31 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %14 = OpVariable %13 Function %20 = OpVariable %19 Function %27 = OpVariable %26 Function OpStore %8 %9 OpStore %10 %11 %15 = OpLoad %6 %8 %16 = OpLoad %6 %10 %17 = OpCompositeConstruct %12 %15 %16 OpStore %14 %17 %21 = OpLoad %12 %14 %22 = OpLoad %12 %14 %23 = OpLoad %12 %14 %24 = OpCompositeConstruct %18 %21 %22 %23 OpStore %20 %24 %28 = OpLoad %18 %20 %29 = OpLoad %18 %20 %30 = OpCompositeConstruct %25 %28 %29 OpStore %27 %30 OpSelectionMerge %34 None OpBranchConditional %32 %33 %34 %33 = OpLabel OpBranch %34 %34 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto transformation_good_1 = TransformationCompositeInsert( MakeInstructionDescriptor(30, spv::Op::OpStore, 0), 50, 30, 11, {1, 0, 0}); ASSERT_TRUE(transformation_good_1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // These synonyms should have been added. ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(30, {0}), MakeDataDescriptor(50, {0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(30, {1, 1}), MakeDataDescriptor(50, {1, 1}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(30, {1, 2}), MakeDataDescriptor(50, {1, 2}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(30, {1, 0, 1}), MakeDataDescriptor(50, {1, 0, 1}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(50, {1, 0, 0}), MakeDataDescriptor(11, {}))); // These synonyms should not have been added. ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(30, {1}), MakeDataDescriptor(50, {1}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(30, {1, 0}), MakeDataDescriptor(50, {1, 0}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(30, {1, 0, 0}), MakeDataDescriptor(50, {1, 0, 0}))); auto transformation_good_2 = TransformationCompositeInsert( MakeInstructionDescriptor(50, spv::Op::OpStore, 0), 51, 50, 11, {0, 1, 1}); ASSERT_TRUE(transformation_good_2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // These synonyms should have been added. ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(50, {1}), MakeDataDescriptor(51, {1}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(50, {0, 0}), MakeDataDescriptor(51, {0, 0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(50, {0, 2}), MakeDataDescriptor(51, {0, 2}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(50, {0, 1, 0}), MakeDataDescriptor(51, {0, 1, 0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(51, {0, 1, 1}), MakeDataDescriptor(11, {}))); // These synonyms should not have been added. ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(50, {0}), MakeDataDescriptor(51, {0}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(50, {0, 1}), MakeDataDescriptor(51, {0, 1}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(50, {0, 1, 1}), MakeDataDescriptor(51, {0, 1, 1}))); std::string after_transformations = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "i1" OpName %10 "i2" OpName %12 "base" OpMemberName %12 0 "a1" OpMemberName %12 1 "a2" OpName %14 "b" OpName %18 "level_1" OpMemberName %18 0 "b1" OpMemberName %18 1 "b2" OpMemberName %18 2 "b3" OpName %20 "l1" OpName %25 "level_2" OpMemberName %25 0 "c1" OpMemberName %25 1 "c2" OpName %27 "l2" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %11 = OpConstant %6 2 %12 = OpTypeStruct %6 %6 %13 = OpTypePointer Function %12 %18 = OpTypeStruct %12 %12 %12 %19 = OpTypePointer Function %18 %25 = OpTypeStruct %18 %18 %26 = OpTypePointer Function %25 %31 = OpTypeBool %32 = OpConstantTrue %31 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %14 = OpVariable %13 Function %20 = OpVariable %19 Function %27 = OpVariable %26 Function OpStore %8 %9 OpStore %10 %11 %15 = OpLoad %6 %8 %16 = OpLoad %6 %10 %17 = OpCompositeConstruct %12 %15 %16 OpStore %14 %17 %21 = OpLoad %12 %14 %22 = OpLoad %12 %14 %23 = OpLoad %12 %14 %24 = OpCompositeConstruct %18 %21 %22 %23 OpStore %20 %24 %28 = OpLoad %18 %20 %29 = OpLoad %18 %20 %30 = OpCompositeConstruct %25 %28 %29 %50 = OpCompositeInsert %25 %11 %30 1 0 0 %51 = OpCompositeInsert %25 %11 %50 0 1 1 OpStore %27 %30 OpSelectionMerge %34 None OpBranchConditional %32 %33 %34 %33 = OpLabel OpBranch %34 %34 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformations, context.get())); } TEST(TransformationCompositeInsertTest, IdNotAvailableScenarios) { // This test handles cases where either the composite or the object is not // available before the |instruction_to_insert_before|. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "i1" OpName %10 "i2" OpName %12 "base" OpMemberName %12 0 "a1" OpMemberName %12 1 "a2" OpName %14 "b1" OpName %18 "b2" OpName %22 "lvl1" OpMemberName %22 0 "b1" OpMemberName %22 1 "b2" OpName %24 "l1" OpName %28 "i3" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %11 = OpConstant %6 2 %12 = OpTypeStruct %6 %6 %13 = OpTypePointer Function %12 %22 = OpTypeStruct %12 %12 %23 = OpTypePointer Function %22 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %14 = OpVariable %13 Function %18 = OpVariable %13 Function %24 = OpVariable %23 Function %28 = OpVariable %7 Function OpStore %8 %9 OpStore %10 %11 %15 = OpLoad %6 %8 %16 = OpLoad %6 %10 %17 = OpCompositeConstruct %12 %15 %16 OpStore %14 %17 %19 = OpLoad %6 %10 %20 = OpLoad %6 %8 %21 = OpCompositeConstruct %12 %19 %20 OpStore %18 %21 %25 = OpLoad %12 %14 %26 = OpLoad %12 %18 %27 = OpCompositeConstruct %22 %25 %26 OpStore %24 %27 %29 = OpLoad %6 %8 %30 = OpLoad %6 %10 %31 = OpIMul %6 %29 %30 OpStore %28 %31 %60 = OpCompositeConstruct %12 %20 %19 %61 = OpCompositeConstruct %22 %26 %25 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Bad: The object with |object_id| is not available at // |instruction_to_insert_before|. auto transformation_bad_1 = TransformationCompositeInsert( MakeInstructionDescriptor(31, spv::Op::OpIMul, 0), 50, 27, 60, {1}); ASSERT_FALSE( transformation_bad_1.IsApplicable(context.get(), transformation_context)); // Bad: The composite with |composite_id| is not available at // |instruction_to_insert_before|. auto transformation_bad_2 = TransformationCompositeInsert( MakeInstructionDescriptor(31, spv::Op::OpIMul, 0), 50, 61, 21, {1}); ASSERT_FALSE( transformation_bad_2.IsApplicable(context.get(), transformation_context)); // Bad: The |instruction_to_insert_before| is the composite itself and is // available. auto transformation_bad_3 = TransformationCompositeInsert( MakeInstructionDescriptor(61, spv::Op::OpCompositeConstruct, 0), 50, 61, 21, {1}); ASSERT_FALSE( transformation_bad_3.IsApplicable(context.get(), transformation_context)); // Bad: The |instruction_to_insert_before| is the object itself and is not // available. auto transformation_bad_4 = TransformationCompositeInsert( MakeInstructionDescriptor(60, spv::Op::OpCompositeConstruct, 0), 50, 27, 60, {1}); ASSERT_FALSE( transformation_bad_4.IsApplicable(context.get(), transformation_context)); } TEST(TransformationCompositeInsertTest, CompositeInsertionWithIrrelevantIds) { // This checks that we do *not* get data synonym facts when we do composite // insertion using irrelevant ids or in dead blocks. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeVector %6 2 %8 = OpConstant %6 0 %9 = OpConstantComposite %7 %8 %8 %10 = OpTypeBool %11 = OpConstantFalse %10 %16 = OpConstant %6 0 %17 = OpConstant %6 1 %18 = OpConstantComposite %7 %8 %8 %12 = OpFunction %2 None %3 %13 = OpLabel OpSelectionMerge %15 None OpBranchConditional %11 %14 %15 %14 = OpLabel OpBranch %15 %15 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactBlockIsDead(14); transformation_context.GetFactManager()->AddFactIdIsIrrelevant(16); transformation_context.GetFactManager()->AddFactIdIsIrrelevant(18); // Leads to synonyms - nothing is irrelevant. auto transformation1 = TransformationCompositeInsert( MakeInstructionDescriptor(13, spv::Op::OpSelectionMerge, 0), 100, 9, 17, {0}); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(100, {0}), MakeDataDescriptor(17, {}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(100, {1}), MakeDataDescriptor(9, {1}))); // Because %16 is irrelevant, we don't get a synonym with the component to // which it has been inserted (but we do for the other component). auto transformation2 = TransformationCompositeInsert( MakeInstructionDescriptor(13, spv::Op::OpSelectionMerge, 0), 101, 9, 16, {0}); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(101, {0}), MakeDataDescriptor(16, {}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(101, {1}), MakeDataDescriptor(9, {1}))); // Because %18 is irrelevant we only get a synonym for the component into // which insertion has taken place. auto transformation3 = TransformationCompositeInsert( MakeInstructionDescriptor(13, spv::Op::OpSelectionMerge, 0), 102, 18, 17, {0}); ASSERT_TRUE( transformation3.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation3, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(102, {0}), MakeDataDescriptor(17, {}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(102, {1}), MakeDataDescriptor(18, {1}))); // Does not lead to synonyms as block %14 is dead. auto transformation4 = TransformationCompositeInsert( MakeInstructionDescriptor(14, spv::Op::OpBranch, 0), 103, 9, 17, {0}); ASSERT_TRUE( transformation4.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation4, context.get(), &transformation_context); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(103, {0}), MakeDataDescriptor(17, {}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(103, {1}), MakeDataDescriptor(9, {1}))); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_compute_data_synonym_fact_closure_test.cpp000066400000000000000000000574541475742701700344100ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_compute_data_synonym_fact_closure.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationComputeDataSynonymFactClosureTest, DataSynonymFacts) { // The SPIR-V types and constants come from the following code. The body of // the SPIR-V function then constructs a composite that is synonymous with // myT. // // #version 310 es // // precision highp float; // // struct S { // int a; // uvec2 b; // }; // // struct T { // bool c[5]; // mat4x2 d; // S e; // }; // // void main() { // T myT = T(bool[5](true, false, true, false, true), // mat4x2(vec2(1.0, 2.0), vec2(3.0, 4.0), // vec2(5.0, 6.0), vec2(7.0, 8.0)), // S(10, uvec2(100u, 200u))); // } std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %15 "S" OpMemberName %15 0 "a" OpMemberName %15 1 "b" OpName %16 "T" OpMemberName %16 0 "c" OpMemberName %16 1 "d" OpMemberName %16 2 "e" OpName %18 "myT" OpMemberDecorate %15 0 RelaxedPrecision OpMemberDecorate %15 1 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpTypeInt 32 0 %8 = OpConstant %7 5 %9 = OpTypeArray %6 %8 %10 = OpTypeFloat 32 %11 = OpTypeVector %10 2 %12 = OpTypeMatrix %11 4 %13 = OpTypeInt 32 1 %14 = OpTypeVector %7 2 %15 = OpTypeStruct %13 %14 %16 = OpTypeStruct %9 %12 %15 %17 = OpTypePointer Function %16 %19 = OpConstantTrue %6 %20 = OpConstantFalse %6 %21 = OpConstantComposite %9 %19 %20 %19 %20 %19 %22 = OpConstant %10 1 %23 = OpConstant %10 2 %24 = OpConstantComposite %11 %22 %23 %25 = OpConstant %10 3 %26 = OpConstant %10 4 %27 = OpConstantComposite %11 %25 %26 %28 = OpConstant %10 5 %29 = OpConstant %10 6 %30 = OpConstantComposite %11 %28 %29 %31 = OpConstant %10 7 %32 = OpConstant %10 8 %33 = OpConstantComposite %11 %31 %32 %34 = OpConstantComposite %12 %24 %27 %30 %33 %35 = OpConstant %13 10 %36 = OpConstant %7 100 %37 = OpConstant %7 200 %38 = OpConstantComposite %14 %36 %37 %39 = OpConstantComposite %15 %35 %38 %40 = OpConstantComposite %16 %21 %34 %39 %4 = OpFunction %2 None %3 %5 = OpLabel %18 = OpVariable %17 Function OpStore %18 %40 %100 = OpCompositeConstruct %9 %19 %20 %19 %20 %19 %101 = OpCompositeConstruct %11 %22 %23 %102 = OpCompositeConstruct %11 %25 %26 %103 = OpCompositeConstruct %11 %28 %29 %104 = OpCompositeConstruct %11 %31 %32 %105 = OpCompositeConstruct %12 %101 %102 %103 %104 %106 = OpCompositeConstruct %14 %36 %37 %107 = OpCompositeConstruct %15 %35 %106 %108 = OpCompositeConstruct %16 %100 %105 %107 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_TRUE(TransformationComputeDataSynonymFactClosure(100).IsApplicable( context.get(), transformation_context)); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(24, {}), MakeDataDescriptor(101, {}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(24, {0}), MakeDataDescriptor(101, {0}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(24, {1}), MakeDataDescriptor(101, {1}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(24, {0}), MakeDataDescriptor(101, {1}))); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(24, {}), MakeDataDescriptor(101, {})); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(24, {}), MakeDataDescriptor(101, {}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(24, {0}), MakeDataDescriptor(101, {0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(24, {1}), MakeDataDescriptor(101, {1}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(24, {0}), MakeDataDescriptor(101, {1}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(27, {}), MakeDataDescriptor(102, {}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(27, {0}), MakeDataDescriptor(102, {0}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(27, {1}), MakeDataDescriptor(102, {1}))); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(27, {0}), MakeDataDescriptor(102, {0})); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(27, {}), MakeDataDescriptor(102, {}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(27, {0}), MakeDataDescriptor(102, {0}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(27, {1}), MakeDataDescriptor(102, {1}))); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(27, {1}), MakeDataDescriptor(102, {1})); ApplyAndCheckFreshIds(TransformationComputeDataSynonymFactClosure(100), context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(27, {}), MakeDataDescriptor(102, {}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(27, {0}), MakeDataDescriptor(102, {0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(27, {1}), MakeDataDescriptor(102, {1}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(30, {}), MakeDataDescriptor(103, {}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(30, {0}), MakeDataDescriptor(103, {0}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(30, {1}), MakeDataDescriptor(103, {1}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(33, {}), MakeDataDescriptor(104, {}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(33, {0}), MakeDataDescriptor(104, {0}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(33, {1}), MakeDataDescriptor(104, {1}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(34, {}), MakeDataDescriptor(105, {}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(34, {0}), MakeDataDescriptor(105, {0}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(34, {1}), MakeDataDescriptor(105, {1}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(34, {2}), MakeDataDescriptor(105, {2}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(34, {3}), MakeDataDescriptor(105, {3}))); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(30, {}), MakeDataDescriptor(103, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(33, {}), MakeDataDescriptor(104, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(34, {0}), MakeDataDescriptor(105, {0})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(34, {1}), MakeDataDescriptor(105, {1})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(34, {2}), MakeDataDescriptor(105, {2})); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(30, {}), MakeDataDescriptor(103, {}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(30, {0}), MakeDataDescriptor(103, {0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(30, {1}), MakeDataDescriptor(103, {1}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(33, {}), MakeDataDescriptor(104, {}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(33, {0}), MakeDataDescriptor(104, {0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(33, {1}), MakeDataDescriptor(104, {1}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(34, {}), MakeDataDescriptor(105, {}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(34, {0}), MakeDataDescriptor(105, {0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(34, {1}), MakeDataDescriptor(105, {1}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(34, {2}), MakeDataDescriptor(105, {2}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(34, {3}), MakeDataDescriptor(105, {3}))); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(34, {3}), MakeDataDescriptor(105, {3})); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(33, {0}), MakeDataDescriptor(104, {0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(34, {3}), MakeDataDescriptor(105, {3}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(21, {}), MakeDataDescriptor(100, {}))); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(21, {0}), MakeDataDescriptor(100, {0})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(21, {1}), MakeDataDescriptor(100, {1})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(21, {2}), MakeDataDescriptor(100, {2})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(21, {3}), MakeDataDescriptor(100, {3})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(21, {4}), MakeDataDescriptor(100, {4})); ApplyAndCheckFreshIds(TransformationComputeDataSynonymFactClosure(100), context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(21, {}), MakeDataDescriptor(100, {}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(39, {0}), MakeDataDescriptor(107, {0}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(35, {}), MakeDataDescriptor(39, {0}))); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(39, {0}), MakeDataDescriptor(35, {})); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(39, {0}), MakeDataDescriptor(107, {0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(35, {}), MakeDataDescriptor(39, {0}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(38, {0}), MakeDataDescriptor(36, {}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(38, {1}), MakeDataDescriptor(37, {}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(106, {0}), MakeDataDescriptor(36, {}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(106, {1}), MakeDataDescriptor(37, {}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(38, {}), MakeDataDescriptor(106, {}))); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(38, {0}), MakeDataDescriptor(36, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(106, {0}), MakeDataDescriptor(36, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(38, {1}), MakeDataDescriptor(37, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(106, {1}), MakeDataDescriptor(37, {})); ApplyAndCheckFreshIds(TransformationComputeDataSynonymFactClosure(100), context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(38, {0}), MakeDataDescriptor(36, {}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(38, {1}), MakeDataDescriptor(37, {}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(106, {0}), MakeDataDescriptor(36, {}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(106, {1}), MakeDataDescriptor(37, {}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(38, {}), MakeDataDescriptor(106, {}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(40, {}), MakeDataDescriptor(108, {}))); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(107, {0}), MakeDataDescriptor(35, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(40, {0}), MakeDataDescriptor(108, {0})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(40, {1}), MakeDataDescriptor(108, {1})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(40, {2}), MakeDataDescriptor(108, {2})); ApplyAndCheckFreshIds(TransformationComputeDataSynonymFactClosure(100), context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(40, {}), MakeDataDescriptor(108, {}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(40, {0}), MakeDataDescriptor(108, {0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(40, {1}), MakeDataDescriptor(108, {1}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(40, {2}), MakeDataDescriptor(108, {2}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(40, {0, 0}), MakeDataDescriptor(108, {0, 0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(40, {0, 1}), MakeDataDescriptor(108, {0, 1}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(40, {0, 2}), MakeDataDescriptor(108, {0, 2}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(40, {0, 3}), MakeDataDescriptor(108, {0, 3}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(40, {0, 4}), MakeDataDescriptor(108, {0, 4}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(40, {1, 0}), MakeDataDescriptor(108, {1, 0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(40, {1, 1}), MakeDataDescriptor(108, {1, 1}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(40, {1, 2}), MakeDataDescriptor(108, {1, 2}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(40, {1, 3}), MakeDataDescriptor(108, {1, 3}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(40, {1, 0, 0}), MakeDataDescriptor(108, {1, 0, 0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(40, {1, 1, 0}), MakeDataDescriptor(108, {1, 1, 0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(40, {1, 2, 0}), MakeDataDescriptor(108, {1, 2, 0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(40, {1, 3, 0}), MakeDataDescriptor(108, {1, 3, 0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(40, {1, 0, 1}), MakeDataDescriptor(108, {1, 0, 1}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(40, {1, 1, 1}), MakeDataDescriptor(108, {1, 1, 1}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(40, {1, 2, 1}), MakeDataDescriptor(108, {1, 2, 1}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(40, {1, 3, 1}), MakeDataDescriptor(108, {1, 3, 1}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(40, {2, 0}), MakeDataDescriptor(108, {2, 0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(40, {2, 1}), MakeDataDescriptor(108, {2, 1}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(40, {2, 1, 0}), MakeDataDescriptor(108, {2, 1, 0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(40, {2, 1, 1}), MakeDataDescriptor(108, {2, 1, 1}))); } TEST(TransformationComputeDataSynonymFactClosureTest, ComputeClosureWithMissingIds) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeVector %6 4 %15 = OpConstant %6 24 %16 = OpConstantComposite %7 %15 %15 %15 %15 %17 = OpConstantComposite %7 %15 %15 %15 %15 %18 = OpTypeStruct %7 %19 = OpConstantComposite %18 %16 %30 = OpConstantComposite %18 %17 %12 = OpFunction %2 None %3 %13 = OpLabel %50 = OpCopyObject %7 %16 %51 = OpCopyObject %7 %17 %20 = OpCopyObject %6 %15 %21 = OpCopyObject %6 %15 %22 = OpCopyObject %6 %15 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(20, {}), MakeDataDescriptor(15, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(21, {}), MakeDataDescriptor(15, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(22, {}), MakeDataDescriptor(15, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(17, {0}), MakeDataDescriptor(15, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(17, {1}), MakeDataDescriptor(15, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(17, {2}), MakeDataDescriptor(15, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(17, {3}), MakeDataDescriptor(15, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(16, {0}), MakeDataDescriptor(20, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(16, {1}), MakeDataDescriptor(21, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(16, {2}), MakeDataDescriptor(22, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(16, {3}), MakeDataDescriptor(15, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(51, {0}), MakeDataDescriptor(15, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(51, {1}), MakeDataDescriptor(15, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(51, {2}), MakeDataDescriptor(15, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(51, {3}), MakeDataDescriptor(15, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(50, {0}), MakeDataDescriptor(20, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(50, {1}), MakeDataDescriptor(21, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(50, {2}), MakeDataDescriptor(22, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(50, {3}), MakeDataDescriptor(15, {})); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(19, {}), MakeDataDescriptor(30, {}))); context->KillDef(20); context->KillDef(21); context->KillDef(22); context->KillDef(50); context->KillDef(51); context->InvalidateAnalysesExceptFor(opt::IRContext::kAnalysisNone); ApplyAndCheckFreshIds(TransformationComputeDataSynonymFactClosure(100), context.get(), &transformation_context); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(19, {}), MakeDataDescriptor(30, {}))); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_duplicate_region_with_selection_test.cpp000066400000000000000000002634421475742701700340270ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_duplicate_region_with_selection.h" #include "gtest/gtest.h" #include "source/fuzz/counter_overflow_id_source.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationDuplicateRegionWithSelectionTest, BasicUseTest) { // This test handles a case where the ids from the original region are used in // subsequent block. std::string shader = R"( OpCapability Shader OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %10 "fun(i1;" OpName %9 "a" OpName %12 "b" OpName %18 "c" OpName %20 "param" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %2 %7 %14 = OpConstant %6 2 %16 = OpTypeBool %17 = OpTypePointer Function %16 %19 = OpConstantTrue %16 %4 = OpFunction %2 None %3 %5 = OpLabel %18 = OpVariable %17 Function %20 = OpVariable %7 Function OpStore %18 %19 OpStore %20 %14 %21 = OpFunctionCall %2 %10 %20 OpReturn OpFunctionEnd %10 = OpFunction %2 None %8 %9 = OpFunctionParameter %7 %11 = OpLabel %12 = OpVariable %7 Function OpBranch %800 %800 = OpLabel %13 = OpLoad %6 %9 %15 = OpIAdd %6 %13 %14 OpStore %12 %15 OpBranch %900 %900 = OpLabel %901 = OpIAdd %6 %15 %13 %902 = OpISub %6 %13 %15 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationDuplicateRegionWithSelection transformation_good_1 = TransformationDuplicateRegionWithSelection( 500, 19, 501, 800, 800, {{800, 100}}, {{13, 201}, {15, 202}}, {{13, 301}, {15, 302}}); ASSERT_TRUE(transformation_good_1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string expected_shader = R"( OpCapability Shader OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %10 "fun(i1;" OpName %9 "a" OpName %12 "b" OpName %18 "c" OpName %20 "param" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %2 %7 %14 = OpConstant %6 2 %16 = OpTypeBool %17 = OpTypePointer Function %16 %19 = OpConstantTrue %16 %4 = OpFunction %2 None %3 %5 = OpLabel %18 = OpVariable %17 Function %20 = OpVariable %7 Function OpStore %18 %19 OpStore %20 %14 %21 = OpFunctionCall %2 %10 %20 OpReturn OpFunctionEnd %10 = OpFunction %2 None %8 %9 = OpFunctionParameter %7 %11 = OpLabel %12 = OpVariable %7 Function OpBranch %500 %500 = OpLabel OpSelectionMerge %501 None OpBranchConditional %19 %800 %100 %800 = OpLabel %13 = OpLoad %6 %9 %15 = OpIAdd %6 %13 %14 OpStore %12 %15 OpBranch %501 %100 = OpLabel %201 = OpLoad %6 %9 %202 = OpIAdd %6 %201 %14 OpStore %12 %202 OpBranch %501 %501 = OpLabel %301 = OpPhi %6 %13 %800 %201 %100 %302 = OpPhi %6 %15 %800 %202 %100 OpBranch %900 %900 = OpLabel %901 = OpIAdd %6 %302 %301 %902 = OpISub %6 %301 %302 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected_shader, context.get())); } TEST(TransformationDuplicateRegionWithSelectionTest, BasicExitBlockTest) { // This test handles a case where the exit block of the region is the exit // block of the containing function. std::string shader = R"( OpCapability Shader OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %10 "fun(i1;" OpName %9 "a" OpName %12 "b" OpName %18 "c" OpName %20 "param" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %2 %7 %14 = OpConstant %6 2 %16 = OpTypeBool %17 = OpTypePointer Function %16 %19 = OpConstantTrue %16 %4 = OpFunction %2 None %3 %5 = OpLabel %18 = OpVariable %17 Function %20 = OpVariable %7 Function OpStore %18 %19 OpStore %20 %14 %21 = OpFunctionCall %2 %10 %20 OpReturn OpFunctionEnd %10 = OpFunction %2 None %8 %9 = OpFunctionParameter %7 %11 = OpLabel %12 = OpVariable %7 Function OpBranch %800 %800 = OpLabel %13 = OpLoad %6 %9 %15 = OpIAdd %6 %13 %14 OpStore %12 %15 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationDuplicateRegionWithSelection transformation_good_1 = TransformationDuplicateRegionWithSelection( 500, 19, 501, 800, 800, {{800, 100}}, {{13, 201}, {15, 202}}, {{13, 301}, {15, 302}}); ASSERT_TRUE(transformation_good_1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string expected_shader = R"( OpCapability Shader OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %10 "fun(i1;" OpName %9 "a" OpName %12 "b" OpName %18 "c" OpName %20 "param" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %2 %7 %14 = OpConstant %6 2 %16 = OpTypeBool %17 = OpTypePointer Function %16 %19 = OpConstantTrue %16 %4 = OpFunction %2 None %3 %5 = OpLabel %18 = OpVariable %17 Function %20 = OpVariable %7 Function OpStore %18 %19 OpStore %20 %14 %21 = OpFunctionCall %2 %10 %20 OpReturn OpFunctionEnd %10 = OpFunction %2 None %8 %9 = OpFunctionParameter %7 %11 = OpLabel %12 = OpVariable %7 Function OpBranch %500 %500 = OpLabel OpSelectionMerge %501 None OpBranchConditional %19 %800 %100 %800 = OpLabel %13 = OpLoad %6 %9 %15 = OpIAdd %6 %13 %14 OpStore %12 %15 OpBranch %501 %100 = OpLabel %201 = OpLoad %6 %9 %202 = OpIAdd %6 %201 %14 OpStore %12 %202 OpBranch %501 %501 = OpLabel %301 = OpPhi %6 %13 %800 %201 %100 %302 = OpPhi %6 %15 %800 %202 %100 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected_shader, context.get())); } TEST(TransformationDuplicateRegionWithSelectionTest, NotApplicableCFGTest) { // This test handles few cases where the transformation is not applicable // because of the control flow graph or layout of the blocks. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %10 "fun(i1;" OpName %9 "a" OpName %18 "b" OpName %25 "c" OpName %27 "param" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %2 %7 %13 = OpConstant %6 2 %14 = OpTypeBool %24 = OpTypePointer Function %14 %26 = OpConstantTrue %14 %4 = OpFunction %2 None %3 %5 = OpLabel %25 = OpVariable %24 Function %27 = OpVariable %7 Function OpStore %25 %26 OpStore %27 %13 %28 = OpFunctionCall %2 %10 %27 OpReturn OpFunctionEnd %10 = OpFunction %2 None %8 %9 = OpFunctionParameter %7 %11 = OpLabel %18 = OpVariable %7 Function %12 = OpLoad %6 %9 %15 = OpSLessThan %14 %12 %13 OpSelectionMerge %17 None OpBranchConditional %15 %16 %21 %16 = OpLabel %19 = OpLoad %6 %9 %20 = OpIAdd %6 %19 %13 OpStore %18 %20 OpBranch %17 %21 = OpLabel %22 = OpLoad %6 %9 %23 = OpISub %6 %22 %13 OpStore %18 %23 OpBranch %17 %17 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Bad: |entry_block_id| refers to the entry block of the function (this // transformation currently avoids such cases). TransformationDuplicateRegionWithSelection transformation_bad_1 = TransformationDuplicateRegionWithSelection( 500, 26, 501, 11, 11, {{11, 100}}, {{18, 201}, {12, 202}, {15, 203}}, {{18, 301}, {12, 302}, {15, 303}}); ASSERT_FALSE( transformation_bad_1.IsApplicable(context.get(), transformation_context)); // Bad: The block with id 16 does not dominate the block with id 21. TransformationDuplicateRegionWithSelection transformation_bad_2 = TransformationDuplicateRegionWithSelection( 500, 26, 501, 16, 21, {{16, 100}, {21, 101}}, {{19, 201}, {20, 202}, {22, 203}, {23, 204}}, {{19, 301}, {20, 302}, {22, 303}, {23, 304}}); ASSERT_FALSE( transformation_bad_2.IsApplicable(context.get(), transformation_context)); // Bad: The block with id 21 does not post-dominate the block with id 11. TransformationDuplicateRegionWithSelection transformation_bad_3 = TransformationDuplicateRegionWithSelection( 500, 26, 501, 11, 21, {{11, 100}, {21, 101}}, {{18, 201}, {12, 202}, {15, 203}, {22, 204}, {23, 205}}, {{18, 301}, {12, 302}, {15, 303}, {22, 304}, {23, 305}}); ASSERT_FALSE( transformation_bad_3.IsApplicable(context.get(), transformation_context)); // Bad: The block with id 5 is contained in a different function than the // block with id 11. TransformationDuplicateRegionWithSelection transformation_bad_4 = TransformationDuplicateRegionWithSelection( 500, 26, 501, 5, 11, {{5, 100}, {11, 101}}, {{25, 201}, {27, 202}, {28, 203}, {18, 204}, {12, 205}, {15, 206}}, {{25, 301}, {27, 302}, {28, 303}, {18, 304}, {12, 305}, {15, 306}}); ASSERT_FALSE( transformation_bad_4.IsApplicable(context.get(), transformation_context)); } TEST(TransformationDuplicateRegionWithSelectionTest, NotApplicableIdTest) { // This test handles a case where the supplied ids are either not fresh, not // distinct, not valid in their context or do not refer to the existing // instructions. std::string shader = R"( OpCapability Shader OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %10 "fun(i1;" OpName %9 "a" OpName %12 "b" OpName %18 "c" OpName %20 "param" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %2 %7 %14 = OpConstant %6 2 %16 = OpTypeBool %17 = OpTypePointer Function %16 %19 = OpConstantTrue %16 %4 = OpFunction %2 None %3 %5 = OpLabel %18 = OpVariable %17 Function %20 = OpVariable %7 Function OpStore %18 %19 OpStore %20 %14 %21 = OpFunctionCall %2 %10 %20 OpReturn OpFunctionEnd %10 = OpFunction %2 None %8 %9 = OpFunctionParameter %7 %11 = OpLabel %12 = OpVariable %7 Function OpBranch %800 %800 = OpLabel %13 = OpLoad %6 %9 %15 = OpIAdd %6 %13 %14 OpStore %12 %15 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Bad: A value in the |original_label_to_duplicate_label| is not a fresh id. TransformationDuplicateRegionWithSelection transformation_bad_1 = TransformationDuplicateRegionWithSelection( 500, 19, 501, 800, 800, {{800, 21}}, {{13, 201}, {15, 202}}, {{13, 301}, {15, 302}}); ASSERT_FALSE( transformation_bad_1.IsApplicable(context.get(), transformation_context)); // Bad: Values in the |original_id_to_duplicate_id| are not distinct. TransformationDuplicateRegionWithSelection transformation_bad_2 = TransformationDuplicateRegionWithSelection( 500, 19, 501, 800, 800, {{800, 100}}, {{13, 201}, {15, 201}}, {{13, 301}, {15, 302}}); ASSERT_FALSE( transformation_bad_2.IsApplicable(context.get(), transformation_context)); // Bad: Values in the |original_id_to_phi_id| are not fresh and are not // distinct with previous values. TransformationDuplicateRegionWithSelection transformation_bad_3 = TransformationDuplicateRegionWithSelection( 500, 19, 501, 800, 800, {{800, 100}}, {{13, 201}, {15, 202}}, {{13, 18}, {15, 202}}); ASSERT_FALSE( transformation_bad_3.IsApplicable(context.get(), transformation_context)); // Bad: |entry_block_id| does not refer to an existing instruction. TransformationDuplicateRegionWithSelection transformation_bad_4 = TransformationDuplicateRegionWithSelection( 500, 19, 501, 802, 800, {{800, 100}}, {{13, 201}, {15, 202}}, {{13, 301}, {15, 302}}); ASSERT_FALSE( transformation_bad_4.IsApplicable(context.get(), transformation_context)); // Bad: |exit_block_id| does not refer to a block. TransformationDuplicateRegionWithSelection transformation_bad_5 = TransformationDuplicateRegionWithSelection( 500, 19, 501, 800, 9, {{800, 100}}, {{13, 201}, {15, 202}}, {{13, 301}, {15, 302}}); ASSERT_FALSE( transformation_bad_5.IsApplicable(context.get(), transformation_context)); // Bad: |new_entry_fresh_id| is not fresh. TransformationDuplicateRegionWithSelection transformation_bad_6 = TransformationDuplicateRegionWithSelection( 20, 19, 501, 800, 800, {{800, 100}}, {{13, 201}, {15, 202}}, {{13, 301}, {15, 302}}); ASSERT_FALSE( transformation_bad_6.IsApplicable(context.get(), transformation_context)); // Bad: |merge_label_fresh_id| is not fresh. TransformationDuplicateRegionWithSelection transformation_bad_7 = TransformationDuplicateRegionWithSelection( 500, 19, 20, 800, 800, {{800, 100}}, {{13, 201}, {15, 202}}, {{13, 301}, {15, 302}}); ASSERT_FALSE( transformation_bad_7.IsApplicable(context.get(), transformation_context)); #ifndef NDEBUG // Bad: Instruction with id 15 is from the original region and is available // at the end of the region but it is not present in the // |original_id_to_phi_id|. TransformationDuplicateRegionWithSelection transformation_bad_8 = TransformationDuplicateRegionWithSelection( 500, 19, 501, 800, 800, {{800, 100}}, {{13, 201}, {15, 202}}, {{13, 301}}); ASSERT_DEATH( transformation_bad_8.IsApplicable(context.get(), transformation_context), "Bad attempt to query whether overflow ids are available."); // Bad: Instruction with id 15 is from the original region but it is // not present in the |original_id_to_duplicate_id|. TransformationDuplicateRegionWithSelection transformation_bad_9 = TransformationDuplicateRegionWithSelection(500, 19, 501, 800, 800, {{800, 100}}, {{13, 201}}, {{13, 301}, {15, 302}}); ASSERT_DEATH( transformation_bad_9.IsApplicable(context.get(), transformation_context), "Bad attempt to query whether overflow ids are available."); #endif // Bad: |condition_id| does not refer to the valid instruction. TransformationDuplicateRegionWithSelection transformation_bad_10 = TransformationDuplicateRegionWithSelection( 500, 200, 501, 800, 800, {{800, 100}}, {{13, 201}, {15, 202}}, {{13, 301}, {15, 302}}); ASSERT_FALSE(transformation_bad_10.IsApplicable(context.get(), transformation_context)); // Bad: |condition_id| does not refer to the instruction of type OpTypeBool TransformationDuplicateRegionWithSelection transformation_bad_11 = TransformationDuplicateRegionWithSelection( 500, 14, 501, 800, 800, {{800, 100}}, {{13, 201}, {15, 202}}, {{13, 301}, {15, 302}}); ASSERT_FALSE(transformation_bad_11.IsApplicable(context.get(), transformation_context)); } TEST(TransformationDuplicateRegionWithSelectionTest, NotApplicableCFGTest2) { // This test handles few cases where the transformation is not applicable // because of the control flow graph or the layout of the blocks. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %6 "fun(" OpName %10 "s" OpName %12 "i" OpName %29 "b" %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %11 = OpConstant %8 0 %19 = OpConstant %8 10 %20 = OpTypeBool %26 = OpConstant %8 1 %28 = OpTypePointer Function %20 %30 = OpConstantTrue %20 %4 = OpFunction %2 None %3 %5 = OpLabel %29 = OpVariable %28 Function OpStore %29 %30 %31 = OpFunctionCall %2 %6 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %10 = OpVariable %9 Function %12 = OpVariable %9 Function OpStore %10 %11 OpStore %12 %11 OpBranch %13 %13 = OpLabel OpLoopMerge %15 %16 None OpBranch %17 %17 = OpLabel %18 = OpLoad %8 %12 %21 = OpSLessThan %20 %18 %19 OpBranchConditional %21 %14 %15 %14 = OpLabel %22 = OpLoad %8 %10 %23 = OpLoad %8 %12 %24 = OpIAdd %8 %22 %23 OpStore %10 %24 OpBranch %16 %16 = OpLabel OpBranch %50 %50 = OpLabel %25 = OpLoad %8 %12 %27 = OpIAdd %8 %25 %26 OpStore %12 %27 OpBranch %13 %15 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Bad: The exit block cannot be a header of a loop, because the region won't // be a single-entry, single-exit region. TransformationDuplicateRegionWithSelection transformation_bad_1 = TransformationDuplicateRegionWithSelection(500, 30, 501, 13, 13, {{13, 100}}, {{}}, {{}}); ASSERT_FALSE( transformation_bad_1.IsApplicable(context.get(), transformation_context)); // Bad: The block with id 13, the loop header, is in the region. The block // with id 15, the loop merge block, is not in the region. TransformationDuplicateRegionWithSelection transformation_bad_2 = TransformationDuplicateRegionWithSelection( 500, 30, 501, 13, 17, {{13, 100}, {17, 101}}, {{18, 201}, {21, 202}}, {{18, 301}, {21, 302}}); ASSERT_FALSE( transformation_bad_2.IsApplicable(context.get(), transformation_context)); // Bad: The block with id 13, the loop header, is not in the region. The block // with id 16, the loop continue target, is in the region. TransformationDuplicateRegionWithSelection transformation_bad_3 = TransformationDuplicateRegionWithSelection( 500, 30, 501, 16, 50, {{16, 100}, {50, 101}}, {{25, 201}, {27, 202}}, {{25, 301}, {27, 302}}); ASSERT_FALSE( transformation_bad_3.IsApplicable(context.get(), transformation_context)); } TEST(TransformationDuplicateRegionWithSelectionTest, NotApplicableCFGTest3) { // This test handles a case where for the block which is not the exit block, // not all successors are in the region. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %6 "fun(" OpName %14 "a" OpName %19 "b" %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeBool %9 = OpConstantTrue %8 %12 = OpTypeInt 32 1 %13 = OpTypePointer Function %12 %15 = OpConstant %12 2 %17 = OpConstant %12 3 %18 = OpTypePointer Function %8 %4 = OpFunction %2 None %3 %5 = OpLabel %19 = OpVariable %18 Function OpStore %19 %9 %20 = OpFunctionCall %2 %6 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %14 = OpVariable %13 Function OpSelectionMerge %11 None OpBranchConditional %9 %10 %16 %10 = OpLabel OpStore %14 %15 OpBranch %11 %16 = OpLabel OpStore %14 %17 OpBranch %11 %11 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Bad: The block with id 7, which is not an exit block, has two successors: // the block with id 10 and the block with id 16. The block with id 16 is not // in the region. TransformationDuplicateRegionWithSelection transformation_bad_1 = TransformationDuplicateRegionWithSelection( 500, 30, 501, 7, 10, {{13, 100}}, {{14, 201}}, {{14, 301}}); ASSERT_FALSE( transformation_bad_1.IsApplicable(context.get(), transformation_context)); } TEST(TransformationDuplicateRegionWithSelectionTest, MultipleBlocksLoopTest) { // This test handles a case where the region consists of multiple blocks // (they form a loop). The transformation is applicable and the region is // duplicated. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %6 "fun(" OpName %10 "s" OpName %12 "i" OpName %29 "b" %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %11 = OpConstant %8 0 %19 = OpConstant %8 10 %20 = OpTypeBool %26 = OpConstant %8 1 %28 = OpTypePointer Function %20 %30 = OpConstantTrue %20 %4 = OpFunction %2 None %3 %5 = OpLabel %29 = OpVariable %28 Function OpStore %29 %30 %31 = OpFunctionCall %2 %6 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %10 = OpVariable %9 Function %12 = OpVariable %9 Function OpStore %10 %11 OpStore %12 %11 OpBranch %50 %50 = OpLabel OpBranch %13 %13 = OpLabel OpLoopMerge %15 %16 None OpBranch %17 %17 = OpLabel %18 = OpLoad %8 %12 %21 = OpSLessThan %20 %18 %19 OpBranchConditional %21 %14 %15 %14 = OpLabel %22 = OpLoad %8 %10 %23 = OpLoad %8 %12 %24 = OpIAdd %8 %22 %23 OpStore %10 %24 OpBranch %16 %16 = OpLabel %25 = OpLoad %8 %12 %27 = OpIAdd %8 %25 %26 OpStore %12 %27 OpBranch %13 %15 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationDuplicateRegionWithSelection transformation_good_1 = TransformationDuplicateRegionWithSelection( 500, 30, 501, 50, 15, {{50, 100}, {13, 101}, {14, 102}, {15, 103}, {16, 104}, {17, 105}}, {{22, 201}, {23, 202}, {24, 203}, {25, 204}, {27, 205}, {18, 206}, {21, 207}}, {{22, 301}, {23, 302}, {24, 303}, {25, 304}, {27, 305}, {18, 306}, {21, 307}}); ASSERT_TRUE(transformation_good_1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string expected_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %6 "fun(" OpName %10 "s" OpName %12 "i" OpName %29 "b" %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %11 = OpConstant %8 0 %19 = OpConstant %8 10 %20 = OpTypeBool %26 = OpConstant %8 1 %28 = OpTypePointer Function %20 %30 = OpConstantTrue %20 %4 = OpFunction %2 None %3 %5 = OpLabel %29 = OpVariable %28 Function OpStore %29 %30 %31 = OpFunctionCall %2 %6 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %10 = OpVariable %9 Function %12 = OpVariable %9 Function OpStore %10 %11 OpStore %12 %11 OpBranch %500 %500 = OpLabel OpSelectionMerge %501 None OpBranchConditional %30 %50 %100 %50 = OpLabel OpBranch %13 %13 = OpLabel OpLoopMerge %15 %16 None OpBranch %17 %17 = OpLabel %18 = OpLoad %8 %12 %21 = OpSLessThan %20 %18 %19 OpBranchConditional %21 %14 %15 %14 = OpLabel %22 = OpLoad %8 %10 %23 = OpLoad %8 %12 %24 = OpIAdd %8 %22 %23 OpStore %10 %24 OpBranch %16 %16 = OpLabel %25 = OpLoad %8 %12 %27 = OpIAdd %8 %25 %26 OpStore %12 %27 OpBranch %13 %15 = OpLabel OpBranch %501 %100 = OpLabel OpBranch %101 %101 = OpLabel OpLoopMerge %103 %104 None OpBranch %105 %105 = OpLabel %206 = OpLoad %8 %12 %207 = OpSLessThan %20 %206 %19 OpBranchConditional %207 %102 %103 %102 = OpLabel %201 = OpLoad %8 %10 %202 = OpLoad %8 %12 %203 = OpIAdd %8 %201 %202 OpStore %10 %203 OpBranch %104 %104 = OpLabel %204 = OpLoad %8 %12 %205 = OpIAdd %8 %204 %26 OpStore %12 %205 OpBranch %101 %103 = OpLabel OpBranch %501 %501 = OpLabel %306 = OpPhi %8 %18 %15 %206 %103 %307 = OpPhi %20 %21 %15 %207 %103 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected_shader, context.get())); } TEST(TransformationDuplicateRegionWithSelectionTest, ResolvingOpPhiExitBlockTest) { // This test handles a case where the region under the transformation is // referenced in OpPhi instructions. Since the new merge block becomes the // exit of the region, these OpPhi instructions need to be updated. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %10 "fun(i1;" OpName %9 "a" OpName %12 "s" OpName %26 "b" OpName %29 "param" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %2 %7 %13 = OpConstant %6 0 %15 = OpConstant %6 2 %16 = OpTypeBool %25 = OpTypePointer Function %16 %27 = OpConstantTrue %16 %28 = OpConstant %6 3 %4 = OpFunction %2 None %3 %5 = OpLabel %26 = OpVariable %25 Function %29 = OpVariable %7 Function OpStore %26 %27 OpStore %29 %28 %30 = OpFunctionCall %2 %10 %29 OpReturn OpFunctionEnd %10 = OpFunction %2 None %8 %9 = OpFunctionParameter %7 %11 = OpLabel %12 = OpVariable %7 Function OpStore %12 %13 %14 = OpLoad %6 %9 %17 = OpSLessThan %16 %14 %15 OpSelectionMerge %19 None OpBranchConditional %17 %18 %22 %18 = OpLabel %20 = OpLoad %6 %9 %21 = OpIAdd %6 %20 %15 OpStore %12 %21 OpBranch %19 %22 = OpLabel %23 = OpLoad %6 %9 %24 = OpIMul %6 %23 %15 OpStore %12 %24 OpBranch %19 %19 = OpLabel %40 = OpPhi %6 %21 %18 %24 %22 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationDuplicateRegionWithSelection transformation_good_1 = TransformationDuplicateRegionWithSelection( 500, 27, 501, 22, 22, {{22, 100}}, {{23, 201}, {24, 202}}, {{23, 301}, {24, 302}}); ASSERT_TRUE(transformation_good_1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string expected_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %10 "fun(i1;" OpName %9 "a" OpName %12 "s" OpName %26 "b" OpName %29 "param" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %2 %7 %13 = OpConstant %6 0 %15 = OpConstant %6 2 %16 = OpTypeBool %25 = OpTypePointer Function %16 %27 = OpConstantTrue %16 %28 = OpConstant %6 3 %4 = OpFunction %2 None %3 %5 = OpLabel %26 = OpVariable %25 Function %29 = OpVariable %7 Function OpStore %26 %27 OpStore %29 %28 %30 = OpFunctionCall %2 %10 %29 OpReturn OpFunctionEnd %10 = OpFunction %2 None %8 %9 = OpFunctionParameter %7 %11 = OpLabel %12 = OpVariable %7 Function OpStore %12 %13 %14 = OpLoad %6 %9 %17 = OpSLessThan %16 %14 %15 OpSelectionMerge %19 None OpBranchConditional %17 %18 %500 %18 = OpLabel %20 = OpLoad %6 %9 %21 = OpIAdd %6 %20 %15 OpStore %12 %21 OpBranch %19 %500 = OpLabel OpSelectionMerge %501 None OpBranchConditional %27 %22 %100 %22 = OpLabel %23 = OpLoad %6 %9 %24 = OpIMul %6 %23 %15 OpStore %12 %24 OpBranch %501 %100 = OpLabel %201 = OpLoad %6 %9 %202 = OpIMul %6 %201 %15 OpStore %12 %202 OpBranch %501 %501 = OpLabel %301 = OpPhi %6 %23 %22 %201 %100 %302 = OpPhi %6 %24 %22 %202 %100 OpBranch %19 %19 = OpLabel %40 = OpPhi %6 %21 %18 %302 %501 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected_shader, context.get())); } TEST(TransformationDuplicateRegionWithSelectionTest, NotApplicableEarlyReturn) { // This test handles a case where one of the blocks has successor outside of // the region, which has an early return from the function, so that the // transformation is not applicable. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %10 "fun(i1;" OpName %9 "a" OpName %12 "s" OpName %27 "b" OpName %30 "param" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %2 %7 %13 = OpConstant %6 0 %15 = OpConstant %6 2 %16 = OpTypeBool %26 = OpTypePointer Function %16 %28 = OpConstantTrue %16 %29 = OpConstant %6 3 %4 = OpFunction %2 None %3 %5 = OpLabel %27 = OpVariable %26 Function %30 = OpVariable %7 Function OpStore %27 %28 OpStore %30 %29 %31 = OpFunctionCall %2 %10 %30 OpReturn OpFunctionEnd %10 = OpFunction %2 None %8 %9 = OpFunctionParameter %7 %11 = OpLabel %12 = OpVariable %7 Function OpBranch %50 %50 = OpLabel OpStore %12 %13 %14 = OpLoad %6 %9 %17 = OpSLessThan %16 %14 %15 OpSelectionMerge %19 None OpBranchConditional %17 %18 %22 %18 = OpLabel %20 = OpLoad %6 %9 %21 = OpIAdd %6 %20 %15 OpStore %12 %21 OpBranch %19 %22 = OpLabel OpReturn %19 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Bad: The block with id 50, which is the entry block, has two successors: // the block with id 18 and the block with id 22. The block 22 has an early // return from the function, so that the entry block is not post-dominated by // the exit block. TransformationDuplicateRegionWithSelection transformation_bad_1 = TransformationDuplicateRegionWithSelection( 500, 28, 501, 50, 19, {{50, 100}, {18, 101}, {22, 102}, {19, 103}}, {{14, 202}, {17, 203}, {20, 204}, {21, 205}}, {{14, 302}, {17, 303}, {20, 304}, {21, 305}}); ASSERT_FALSE( transformation_bad_1.IsApplicable(context.get(), transformation_context)); } TEST(TransformationDuplicateRegionWithSelectionTest, ResolvingOpPhiEntryBlockOnePredecessor) { // This test handles a case where the entry block has an OpPhi instruction // referring to its predecessor. After transformation, this instruction needs // to be updated. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %10 "fun(i1;" OpName %9 "a" OpName %12 "s" OpName %14 "t" OpName %20 "b" OpName %23 "param" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %2 %7 %13 = OpConstant %6 0 %15 = OpConstant %6 2 %18 = OpTypeBool %19 = OpTypePointer Function %18 %21 = OpConstantTrue %18 %22 = OpConstant %6 3 %4 = OpFunction %2 None %3 %5 = OpLabel %20 = OpVariable %19 Function %23 = OpVariable %7 Function OpStore %20 %21 OpStore %23 %22 %24 = OpFunctionCall %2 %10 %23 OpReturn OpFunctionEnd %10 = OpFunction %2 None %8 %9 = OpFunctionParameter %7 %11 = OpLabel %12 = OpVariable %7 Function %14 = OpVariable %7 Function OpStore %12 %13 %16 = OpLoad %6 %12 %17 = OpIMul %6 %15 %16 OpStore %14 %17 OpBranch %50 %50 = OpLabel %51 = OpPhi %6 %17 %11 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationDuplicateRegionWithSelection transformation_good_1 = TransformationDuplicateRegionWithSelection( 500, 21, 501, 50, 50, {{50, 100}}, {{51, 201}}, {{51, 301}}); ASSERT_TRUE(transformation_good_1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string expected_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %10 "fun(i1;" OpName %9 "a" OpName %12 "s" OpName %14 "t" OpName %20 "b" OpName %23 "param" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %2 %7 %13 = OpConstant %6 0 %15 = OpConstant %6 2 %18 = OpTypeBool %19 = OpTypePointer Function %18 %21 = OpConstantTrue %18 %22 = OpConstant %6 3 %4 = OpFunction %2 None %3 %5 = OpLabel %20 = OpVariable %19 Function %23 = OpVariable %7 Function OpStore %20 %21 OpStore %23 %22 %24 = OpFunctionCall %2 %10 %23 OpReturn OpFunctionEnd %10 = OpFunction %2 None %8 %9 = OpFunctionParameter %7 %11 = OpLabel %12 = OpVariable %7 Function %14 = OpVariable %7 Function OpStore %12 %13 %16 = OpLoad %6 %12 %17 = OpIMul %6 %15 %16 OpStore %14 %17 OpBranch %500 %500 = OpLabel OpSelectionMerge %501 None OpBranchConditional %21 %50 %100 %50 = OpLabel %51 = OpPhi %6 %17 %500 OpBranch %501 %100 = OpLabel %201 = OpPhi %6 %17 %500 OpBranch %501 %501 = OpLabel %301 = OpPhi %6 %51 %50 %201 %100 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected_shader, context.get())); } TEST(TransformationDuplicateRegionWithSelectionTest, NotApplicableNoVariablePointerCapability) { // This test handles a case where the transformation would create an OpPhi // instruction with pointer operands, however there is no cab // CapabilityVariablePointers. Hence, the transformation is not applicable. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %10 "fun(i1;" OpName %9 "a" OpName %12 "s" OpName %14 "t" OpName %20 "b" OpName %23 "param" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %2 %7 %13 = OpConstant %6 0 %15 = OpConstant %6 2 %18 = OpTypeBool %19 = OpTypePointer Function %18 %21 = OpConstantTrue %18 %22 = OpConstant %6 3 %4 = OpFunction %2 None %3 %5 = OpLabel %20 = OpVariable %19 Function %23 = OpVariable %7 Function OpStore %20 %21 OpStore %23 %22 %24 = OpFunctionCall %2 %10 %23 OpReturn OpFunctionEnd %10 = OpFunction %2 None %8 %9 = OpFunctionParameter %7 %11 = OpLabel %12 = OpVariable %7 Function %14 = OpVariable %7 Function OpStore %12 %13 %16 = OpLoad %6 %12 %17 = OpIMul %6 %15 %16 OpStore %14 %17 OpBranch %50 %50 = OpLabel %51 = OpCopyObject %7 %12 OpBranch %52 %52 = OpLabel %53 = OpCopyObject %7 %51 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Bad: There is no required capability CapabilityVariablePointers TransformationDuplicateRegionWithSelection transformation_bad_1 = TransformationDuplicateRegionWithSelection( 500, 21, 501, 50, 50, {{50, 100}}, {{51, 201}}, {{51, 301}}); ASSERT_FALSE( transformation_bad_1.IsApplicable(context.get(), transformation_context)); } TEST(TransformationDuplicateRegionWithSelectionTest, ExitBlockTerminatorOpUnreachable) { // This test handles a case where the exit block ends with OpUnreachable. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %6 "fun(" OpName %10 "s" OpName %17 "b" %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %11 = OpConstant %8 0 %13 = OpConstant %8 2 %15 = OpTypeBool %16 = OpTypePointer Function %15 %18 = OpConstantTrue %15 %4 = OpFunction %2 None %3 %5 = OpLabel %17 = OpVariable %16 Function OpStore %17 %18 %19 = OpFunctionCall %2 %6 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %10 = OpVariable %9 Function OpBranch %50 %50 = OpLabel OpStore %10 %11 %12 = OpLoad %8 %10 %14 = OpIAdd %8 %12 %13 OpStore %10 %14 OpUnreachable OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationDuplicateRegionWithSelection transformation_good_1 = TransformationDuplicateRegionWithSelection( 500, 18, 501, 50, 50, {{50, 100}}, {{12, 201}, {14, 202}}, {{12, 301}, {14, 302}}); ASSERT_TRUE(transformation_good_1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string expected_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %6 "fun(" OpName %10 "s" OpName %17 "b" %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %11 = OpConstant %8 0 %13 = OpConstant %8 2 %15 = OpTypeBool %16 = OpTypePointer Function %15 %18 = OpConstantTrue %15 %4 = OpFunction %2 None %3 %5 = OpLabel %17 = OpVariable %16 Function OpStore %17 %18 %19 = OpFunctionCall %2 %6 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %10 = OpVariable %9 Function OpBranch %500 %500 = OpLabel OpSelectionMerge %501 None OpBranchConditional %18 %50 %100 %50 = OpLabel OpStore %10 %11 %12 = OpLoad %8 %10 %14 = OpIAdd %8 %12 %13 OpStore %10 %14 OpBranch %501 %100 = OpLabel OpStore %10 %11 %201 = OpLoad %8 %10 %202 = OpIAdd %8 %201 %13 OpStore %10 %202 OpBranch %501 %501 = OpLabel %301 = OpPhi %8 %12 %50 %201 %100 %302 = OpPhi %8 %14 %50 %202 %100 OpUnreachable OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected_shader, context.get())); } TEST(TransformationDuplicateRegionWithSelectionTest, ExitBlockTerminatorOpKill) { // This test handles a case where the exit block ends with OpKill. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %6 "fun(" OpName %10 "s" OpName %17 "b" %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %11 = OpConstant %8 0 %13 = OpConstant %8 2 %15 = OpTypeBool %16 = OpTypePointer Function %15 %18 = OpConstantTrue %15 %4 = OpFunction %2 None %3 %5 = OpLabel %17 = OpVariable %16 Function OpStore %17 %18 %19 = OpFunctionCall %2 %6 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %10 = OpVariable %9 Function OpBranch %50 %50 = OpLabel OpStore %10 %11 %12 = OpLoad %8 %10 %14 = OpIAdd %8 %12 %13 OpStore %10 %14 OpKill OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationDuplicateRegionWithSelection transformation_good_1 = TransformationDuplicateRegionWithSelection( 500, 18, 501, 50, 50, {{50, 100}}, {{12, 201}, {14, 202}}, {{12, 301}, {14, 302}}); ASSERT_TRUE(transformation_good_1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string expected_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %6 "fun(" OpName %10 "s" OpName %17 "b" %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %11 = OpConstant %8 0 %13 = OpConstant %8 2 %15 = OpTypeBool %16 = OpTypePointer Function %15 %18 = OpConstantTrue %15 %4 = OpFunction %2 None %3 %5 = OpLabel %17 = OpVariable %16 Function OpStore %17 %18 %19 = OpFunctionCall %2 %6 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %10 = OpVariable %9 Function OpBranch %500 %500 = OpLabel OpSelectionMerge %501 None OpBranchConditional %18 %50 %100 %50 = OpLabel OpStore %10 %11 %12 = OpLoad %8 %10 %14 = OpIAdd %8 %12 %13 OpStore %10 %14 OpBranch %501 %100 = OpLabel OpStore %10 %11 %201 = OpLoad %8 %10 %202 = OpIAdd %8 %201 %13 OpStore %10 %202 OpBranch %501 %501 = OpLabel %301 = OpPhi %8 %12 %50 %201 %100 %302 = OpPhi %8 %14 %50 %202 %100 OpKill OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected_shader, context.get())); } TEST(TransformationDuplicateRegionWithSelectionTest, ContinueExitBlockNotApplicable) { // This test handles a case where the exit block is the continue target and // the transformation is not applicable. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "s" OpName %10 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %17 = OpConstant %6 10 %18 = OpTypeBool %24 = OpConstant %6 5 %30 = OpConstant %6 1 %50 = OpConstantTrue %18 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function OpStore %8 %9 OpStore %10 %9 OpBranch %11 %11 = OpLabel OpLoopMerge %13 %14 None OpBranch %15 %15 = OpLabel %16 = OpLoad %6 %10 %19 = OpSLessThan %18 %16 %17 OpBranchConditional %19 %12 %13 %12 = OpLabel %20 = OpLoad %6 %10 %21 = OpLoad %6 %8 %22 = OpIAdd %6 %21 %20 OpStore %8 %22 %23 = OpLoad %6 %10 %25 = OpIEqual %18 %23 %24 OpSelectionMerge %27 None OpBranchConditional %25 %26 %27 %26 = OpLabel OpBranch %13 %27 = OpLabel OpBranch %14 %14 = OpLabel %29 = OpLoad %6 %10 %31 = OpIAdd %6 %29 %30 OpStore %10 %31 OpBranch %11 %13 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationDuplicateRegionWithSelection transformation_bad = TransformationDuplicateRegionWithSelection( 500, 50, 501, 27, 14, {{27, 101}, {14, 102}}, {{29, 201}, {31, 202}}, {{29, 301}, {31, 302}}); ASSERT_FALSE( transformation_bad.IsApplicable(context.get(), transformation_context)); } TEST(TransformationDuplicateRegionWithSelectionTest, MultiplePredecessorsNotApplicableTest) { // This test handles a case where the entry block has multiple predecessors // and the transformation is not applicable. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %10 "fun1(i1;" OpName %9 "a" OpName %18 "b" OpName %24 "b" OpName %27 "param" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %2 %7 %13 = OpConstant %6 2 %14 = OpTypeBool %23 = OpTypePointer Function %14 %25 = OpConstantTrue %14 %26 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %24 = OpVariable %23 Function %27 = OpVariable %7 Function OpStore %24 %25 OpStore %27 %26 %28 = OpFunctionCall %2 %10 %27 OpReturn OpFunctionEnd %10 = OpFunction %2 None %8 %9 = OpFunctionParameter %7 %11 = OpLabel %18 = OpVariable %7 Function %12 = OpLoad %6 %9 %15 = OpSLessThan %14 %12 %13 OpSelectionMerge %17 None OpBranchConditional %15 %16 %20 %16 = OpLabel %19 = OpLoad %6 %9 OpStore %18 %19 OpBranch %60 %20 = OpLabel %21 = OpLoad %6 %9 %22 = OpIAdd %6 %21 %13 OpStore %18 %22 OpBranch %60 %60 = OpLabel OpBranch %17 %17 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationDuplicateRegionWithSelection transformation_bad = TransformationDuplicateRegionWithSelection(500, 25, 501, 60, 60, {{60, 101}}, {{}}, {{}}); ASSERT_FALSE( transformation_bad.IsApplicable(context.get(), transformation_context)); } TEST(TransformationDuplicateRegionWithSelectionTest, OverflowIds) { // This test checks that the transformation correctly uses overflow ids, when // they are both needed and provided. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %6 "fun(" OpName %10 "s" OpName %17 "b" %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %11 = OpConstant %8 0 %13 = OpConstant %8 2 %15 = OpTypeBool %16 = OpTypePointer Function %15 %18 = OpConstantTrue %15 %4 = OpFunction %2 None %3 %5 = OpLabel %17 = OpVariable %16 Function OpStore %17 %18 %19 = OpFunctionCall %2 %6 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %10 = OpVariable %9 Function OpBranch %50 %50 = OpLabel OpStore %10 %11 %12 = OpLoad %8 %10 %14 = OpIAdd %8 %12 %13 OpStore %10 %14 OpKill OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); auto overflow_ids_unique_ptr = MakeUnique(1000); auto overflow_ids_ptr = overflow_ids_unique_ptr.get(); TransformationContext transformation_context( MakeUnique(context.get()), validator_options, std::move(overflow_ids_unique_ptr)); // The mappings do not provide sufficient ids, thus overflow ids are required. TransformationDuplicateRegionWithSelection transformation_good_1 = TransformationDuplicateRegionWithSelection(500, 18, 501, 50, 50, {}, {{12, 201}}, {{14, 302}}); ASSERT_TRUE(transformation_good_1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_1, context.get(), &transformation_context, overflow_ids_ptr->GetIssuedOverflowIds()); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string expected_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %6 "fun(" OpName %10 "s" OpName %17 "b" %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %11 = OpConstant %8 0 %13 = OpConstant %8 2 %15 = OpTypeBool %16 = OpTypePointer Function %15 %18 = OpConstantTrue %15 %4 = OpFunction %2 None %3 %5 = OpLabel %17 = OpVariable %16 Function OpStore %17 %18 %19 = OpFunctionCall %2 %6 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %10 = OpVariable %9 Function OpBranch %500 %500 = OpLabel OpSelectionMerge %501 None OpBranchConditional %18 %50 %1000 %50 = OpLabel OpStore %10 %11 %12 = OpLoad %8 %10 %14 = OpIAdd %8 %12 %13 OpStore %10 %14 OpBranch %501 %1000 = OpLabel OpStore %10 %11 %201 = OpLoad %8 %10 %1002 = OpIAdd %8 %201 %13 OpStore %10 %1002 OpBranch %501 %501 = OpLabel %1001 = OpPhi %8 %12 %50 %201 %1000 %302 = OpPhi %8 %14 %50 %1002 %1000 OpKill OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected_shader, context.get())); } TEST(TransformationDuplicateRegionWithSelectionTest, RegionExitIsOpBranchConditional) { // Checks the case where the exit block of a region ends with // OpBranchConditional (but is not a header). std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpName %4 "main" OpName %8 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 100 %17 = OpTypeBool %50 = OpConstantTrue %17 %20 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %15 = OpLoad %6 %8 %18 = OpSLessThan %17 %15 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %19 = OpLoad %6 %8 %21 = OpIAdd %6 %19 %20 OpStore %8 %21 OpBranchConditional %50 %13 %12 %13 = OpLabel %22 = OpLoad %6 %8 %23 = OpIAdd %6 %22 %20 OpStore %8 %23 OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationDuplicateRegionWithSelection transformation_good_1 = TransformationDuplicateRegionWithSelection( 600, 50, 601, 11, 11, {{11, 602}}, {{19, 603}, {21, 604}}, {{19, 605}, {21, 606}}); ASSERT_TRUE(transformation_good_1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string expected_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpName %4 "main" OpName %8 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 100 %17 = OpTypeBool %50 = OpConstantTrue %17 %20 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %15 = OpLoad %6 %8 %18 = OpSLessThan %17 %15 %16 OpBranchConditional %18 %600 %12 %600 = OpLabel OpSelectionMerge %601 None OpBranchConditional %50 %11 %602 %11 = OpLabel %19 = OpLoad %6 %8 %21 = OpIAdd %6 %19 %20 OpStore %8 %21 OpBranch %601 %602 = OpLabel %603 = OpLoad %6 %8 %604 = OpIAdd %6 %603 %20 OpStore %8 %604 OpBranch %601 %601 = OpLabel %605 = OpPhi %6 %19 %11 %603 %602 %606 = OpPhi %6 %21 %11 %604 %602 OpBranchConditional %50 %13 %12 %13 = OpLabel %22 = OpLoad %6 %8 %23 = OpIAdd %6 %22 %20 OpStore %8 %23 OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected_shader, context.get())); } TEST(TransformationDuplicateRegionWithSelectionTest, RegionExitIsOpBranchConditionalUsingBooleanDefinedInBlock) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpName %4 "main" OpName %8 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 100 %17 = OpTypeBool %50 = OpConstantTrue %17 %20 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %15 = OpLoad %6 %8 %18 = OpSLessThan %17 %15 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %19 = OpLoad %6 %8 %21 = OpIAdd %6 %19 %20 %70 = OpCopyObject %17 %50 OpStore %8 %21 OpBranchConditional %70 %13 %12 %13 = OpLabel %22 = OpLoad %6 %8 %23 = OpIAdd %6 %22 %20 OpStore %8 %23 OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationDuplicateRegionWithSelection transformation_good_1 = TransformationDuplicateRegionWithSelection( 600, 50, 601, 11, 11, {{11, 602}}, {{19, 603}, {21, 604}, {70, 608}}, {{19, 605}, {21, 606}, {70, 607}}); ASSERT_TRUE(transformation_good_1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string expected_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpName %4 "main" OpName %8 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 100 %17 = OpTypeBool %50 = OpConstantTrue %17 %20 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %15 = OpLoad %6 %8 %18 = OpSLessThan %17 %15 %16 OpBranchConditional %18 %600 %12 %600 = OpLabel OpSelectionMerge %601 None OpBranchConditional %50 %11 %602 %11 = OpLabel %19 = OpLoad %6 %8 %21 = OpIAdd %6 %19 %20 %70 = OpCopyObject %17 %50 OpStore %8 %21 OpBranch %601 %602 = OpLabel %603 = OpLoad %6 %8 %604 = OpIAdd %6 %603 %20 %608 = OpCopyObject %17 %50 OpStore %8 %604 OpBranch %601 %601 = OpLabel %605 = OpPhi %6 %19 %11 %603 %602 %606 = OpPhi %6 %21 %11 %604 %602 %607 = OpPhi %17 %70 %11 %608 %602 OpBranchConditional %607 %13 %12 %13 = OpLabel %22 = OpLoad %6 %8 %23 = OpIAdd %6 %22 %20 OpStore %8 %23 OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected_shader, context.get())); } TEST(TransformationDuplicateRegionWithSelectionTest, RegionExitUsesOpReturnValueWithIdDefinedInRegion) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeFunction %6 %10 = OpConstant %6 2 %30 = OpTypeBool %31 = OpConstantTrue %30 %4 = OpFunction %2 None %3 %5 = OpLabel %13 = OpFunctionCall %6 %8 OpReturn OpFunctionEnd %8 = OpFunction %6 None %7 %9 = OpLabel OpBranch %20 %20 = OpLabel %21 = OpCopyObject %6 %10 OpReturnValue %21 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationDuplicateRegionWithSelection transformation_good_1 = TransformationDuplicateRegionWithSelection( 600, 31, 601, 20, 20, {{20, 602}}, {{21, 603}}, {{21, 605}}); ASSERT_TRUE(transformation_good_1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string expected_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeFunction %6 %10 = OpConstant %6 2 %30 = OpTypeBool %31 = OpConstantTrue %30 %4 = OpFunction %2 None %3 %5 = OpLabel %13 = OpFunctionCall %6 %8 OpReturn OpFunctionEnd %8 = OpFunction %6 None %7 %9 = OpLabel OpBranch %600 %600 = OpLabel OpSelectionMerge %601 None OpBranchConditional %31 %20 %602 %20 = OpLabel %21 = OpCopyObject %6 %10 OpBranch %601 %602 = OpLabel %603 = OpCopyObject %6 %10 OpBranch %601 %601 = OpLabel %605 = OpPhi %6 %21 %20 %603 %602 OpReturnValue %605 OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected_shader, context.get())); } TEST(TransformationDuplicateRegionWithSelectionTest, InapplicableDueToOpTypeSampledImage) { std::string reference_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %10 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpDecorate %10 RelaxedPrecision OpDecorate %10 DescriptorSet 0 OpDecorate %10 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeImage %6 2D 0 0 0 1 Unknown %8 = OpTypeSampledImage %7 %9 = OpTypePointer UniformConstant %8 %10 = OpVariable %9 UniformConstant %12 = OpTypeVector %6 2 %13 = OpConstant %6 0 %14 = OpConstantComposite %12 %13 %13 %15 = OpTypeVector %6 4 %30 = OpTypeBool %31 = OpConstantTrue %30 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %20 %20 = OpLabel %11 = OpLoad %8 %10 OpBranch %21 %21 = OpLabel %16 = OpImageSampleImplicitLod %15 %11 %14 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_FALSE(TransformationDuplicateRegionWithSelection( 600, 31, 601, 20, 20, {{20, 602}}, {{11, 603}}, {{11, 605}}) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationDuplicateRegionWithSelectionTest, DoNotProduceOpPhiWithVoidType) { std::string reference_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeBool %11 = OpConstantTrue %10 %4 = OpFunction %2 None %3 %12 = OpLabel OpBranch %5 %5 = OpLabel %8 = OpFunctionCall %2 %6 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationDuplicateRegionWithSelection transformation( 100, 11, 101, 5, 5, {{5, 102}}, {{8, 103}}, {}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string expected_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeBool %11 = OpConstantTrue %10 %4 = OpFunction %2 None %3 %12 = OpLabel OpBranch %100 %100 = OpLabel OpSelectionMerge %101 None OpBranchConditional %11 %5 %102 %5 = OpLabel %8 = OpFunctionCall %2 %6 OpBranch %101 %102 = OpLabel %103 = OpFunctionCall %2 %6 OpBranch %101 %101 = OpLabel OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected_shader, context.get())); } TEST(TransformationDuplicateRegionWithSelectionTest, DoNotProduceOpPhiWithDisallowedType) { std::string reference_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpDecorate %13 DescriptorSet 0 OpDecorate %13 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 2 %8 = OpTypePointer Function %7 %10 = OpTypeImage %6 2D 0 0 0 1 Unknown %11 = OpTypeSampledImage %10 %12 = OpTypePointer UniformConstant %11 %13 = OpVariable %12 UniformConstant %15 = OpConstant %6 1 %16 = OpConstantComposite %7 %15 %15 %17 = OpTypeVector %6 4 %19 = OpTypeInt 32 0 %20 = OpConstant %19 0 %22 = OpTypePointer Function %6 %90 = OpTypeBool %91 = OpConstantTrue %90 %4 = OpFunction %2 None %3 %5 = OpLabel %9 = OpVariable %8 Function OpBranch %81 %81 = OpLabel %14 = OpLoad %11 %13 %18 = OpImageSampleImplicitLod %17 %14 %16 %21 = OpCompositeExtract %6 %18 0 %23 = OpAccessChain %22 %9 %20 OpStore %23 %21 OpBranch %80 %80 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationDuplicateRegionWithSelection transformation( 100, 91, 101, 81, 81, {{81, 102}}, {{14, 103}, {18, 104}, {21, 105}, {23, 106}}, {{18, 107}, {21, 108}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string expected_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpDecorate %13 DescriptorSet 0 OpDecorate %13 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 2 %8 = OpTypePointer Function %7 %10 = OpTypeImage %6 2D 0 0 0 1 Unknown %11 = OpTypeSampledImage %10 %12 = OpTypePointer UniformConstant %11 %13 = OpVariable %12 UniformConstant %15 = OpConstant %6 1 %16 = OpConstantComposite %7 %15 %15 %17 = OpTypeVector %6 4 %19 = OpTypeInt 32 0 %20 = OpConstant %19 0 %22 = OpTypePointer Function %6 %90 = OpTypeBool %91 = OpConstantTrue %90 %4 = OpFunction %2 None %3 %5 = OpLabel %9 = OpVariable %8 Function OpBranch %100 %100 = OpLabel OpSelectionMerge %101 None OpBranchConditional %91 %81 %102 %81 = OpLabel %14 = OpLoad %11 %13 %18 = OpImageSampleImplicitLod %17 %14 %16 %21 = OpCompositeExtract %6 %18 0 %23 = OpAccessChain %22 %9 %20 OpStore %23 %21 OpBranch %101 %102 = OpLabel %103 = OpLoad %11 %13 %104 = OpImageSampleImplicitLod %17 %103 %16 %105 = OpCompositeExtract %6 %104 0 %106 = OpAccessChain %22 %9 %20 OpStore %106 %105 OpBranch %101 %101 = OpLabel %107 = OpPhi %17 %18 %81 %104 %102 %108 = OpPhi %6 %21 %81 %105 %102 OpBranch %80 %80 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected_shader, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_equation_instruction_test.cpp000066400000000000000000002125421475742701700316730ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_equation_instruction.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationEquationInstructionTest, SignedNegate) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpConstant %6 24 %40 = OpTypeBool %41 = OpConstantTrue %40 %20 = OpUndef %6 %12 = OpFunction %2 None %3 %13 = OpLabel %30 = OpCopyObject %6 %7 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); protobufs::InstructionDescriptor return_instruction = MakeInstructionDescriptor(13, spv::Op::OpReturn, 0); // Bad: id already in use. ASSERT_FALSE(TransformationEquationInstruction(7, spv::Op::OpSNegate, {7}, return_instruction) .IsApplicable(context.get(), transformation_context)); // Bad: identified instruction does not exist. ASSERT_FALSE(TransformationEquationInstruction( 14, spv::Op::OpSNegate, {7}, MakeInstructionDescriptor(13, spv::Op::OpLoad, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: id 100 does not exist ASSERT_FALSE(TransformationEquationInstruction(14, spv::Op::OpSNegate, {100}, return_instruction) .IsApplicable(context.get(), transformation_context)); // Bad: id 20 is an OpUndef ASSERT_FALSE(TransformationEquationInstruction(14, spv::Op::OpSNegate, {20}, return_instruction) .IsApplicable(context.get(), transformation_context)); // Bad: id 30 is not available right before its definition ASSERT_FALSE(TransformationEquationInstruction( 14, spv::Op::OpSNegate, {30}, MakeInstructionDescriptor(30, spv::Op::OpCopyObject, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: too many arguments to OpSNegate. ASSERT_FALSE(TransformationEquationInstruction(14, spv::Op::OpSNegate, {7, 7}, return_instruction) .IsApplicable(context.get(), transformation_context)); // Bad: 40 is a type id. ASSERT_FALSE(TransformationEquationInstruction(14, spv::Op::OpSNegate, {40}, return_instruction) .IsApplicable(context.get(), transformation_context)); // Bad: wrong type of argument to OpSNegate. ASSERT_FALSE(TransformationEquationInstruction(14, spv::Op::OpSNegate, {41}, return_instruction) .IsApplicable(context.get(), transformation_context)); auto transformation1 = TransformationEquationInstruction( 14, spv::Op::OpSNegate, {7}, return_instruction); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ASSERT_EQ(nullptr, context->get_def_use_mgr()->GetDef(14)); ASSERT_EQ(nullptr, context->get_instr_block(14)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); ASSERT_EQ(spv::Op::OpSNegate, context->get_def_use_mgr()->GetDef(14)->opcode()); ASSERT_EQ(13, context->get_instr_block(14)->id()); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); auto transformation2 = TransformationEquationInstruction( 15, spv::Op::OpSNegate, {14}, return_instruction); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(15, {}), MakeDataDescriptor(7, {}))); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpConstant %6 24 %40 = OpTypeBool %41 = OpConstantTrue %40 %20 = OpUndef %6 %12 = OpFunction %2 None %3 %13 = OpLabel %30 = OpCopyObject %6 %7 %14 = OpSNegate %6 %7 %15 = OpSNegate %6 %14 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationEquationInstructionTest, LogicalNot) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantTrue %6 %20 = OpTypeInt 32 0 %21 = OpConstant %20 5 %12 = OpFunction %2 None %3 %13 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); protobufs::InstructionDescriptor return_instruction = MakeInstructionDescriptor(13, spv::Op::OpReturn, 0); // Bad: too few arguments to OpLogicalNot. ASSERT_FALSE(TransformationEquationInstruction(14, spv::Op::OpLogicalNot, {}, return_instruction) .IsApplicable(context.get(), transformation_context)); // Bad: 6 is a type id. ASSERT_FALSE(TransformationEquationInstruction(14, spv::Op::OpLogicalNot, {6}, return_instruction) .IsApplicable(context.get(), transformation_context)); // Bad: wrong type of argument to OpLogicalNot. ASSERT_FALSE(TransformationEquationInstruction(14, spv::Op::OpLogicalNot, {21}, return_instruction) .IsApplicable(context.get(), transformation_context)); auto transformation1 = TransformationEquationInstruction( 14, spv::Op::OpLogicalNot, {7}, return_instruction); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); auto transformation2 = TransformationEquationInstruction( 15, spv::Op::OpLogicalNot, {14}, return_instruction); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(15, {}), MakeDataDescriptor(7, {}))); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantTrue %6 %20 = OpTypeInt 32 0 %21 = OpConstant %20 5 %12 = OpFunction %2 None %3 %13 = OpLabel %14 = OpLogicalNot %6 %7 %15 = OpLogicalNot %6 %14 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationEquationInstructionTest, AddSubNegate1) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %30 = OpTypeVector %6 3 %15 = OpConstant %6 24 %16 = OpConstant %6 37 %31 = OpConstantComposite %30 %15 %16 %15 %33 = OpTypeBool %32 = OpConstantTrue %33 %12 = OpFunction %2 None %3 %13 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); protobufs::InstructionDescriptor return_instruction = MakeInstructionDescriptor(13, spv::Op::OpReturn, 0); // Bad: too many arguments to OpIAdd. ASSERT_FALSE(TransformationEquationInstruction( 14, spv::Op::OpIAdd, {15, 16, 16}, return_instruction) .IsApplicable(context.get(), transformation_context)); // Bad: boolean argument to OpIAdd. ASSERT_FALSE(TransformationEquationInstruction(14, spv::Op::OpIAdd, {15, 32}, return_instruction) .IsApplicable(context.get(), transformation_context)); // Bad: type as argument to OpIAdd. ASSERT_FALSE(TransformationEquationInstruction(14, spv::Op::OpIAdd, {33, 16}, return_instruction) .IsApplicable(context.get(), transformation_context)); // Bad: arguments of mismatched widths ASSERT_FALSE(TransformationEquationInstruction(14, spv::Op::OpIAdd, {15, 31}, return_instruction) .IsApplicable(context.get(), transformation_context)); // Bad: arguments of mismatched widths ASSERT_FALSE(TransformationEquationInstruction(14, spv::Op::OpIAdd, {31, 15}, return_instruction) .IsApplicable(context.get(), transformation_context)); auto transformation1 = TransformationEquationInstruction( 14, spv::Op::OpIAdd, {15, 16}, return_instruction); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); auto transformation2 = TransformationEquationInstruction( 19, spv::Op::OpISub, {14, 16}, return_instruction); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(15, {}), MakeDataDescriptor(19, {}))); auto transformation3 = TransformationEquationInstruction( 20, spv::Op::OpISub, {14, 15}, return_instruction); ASSERT_TRUE( transformation3.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation3, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(20, {}), MakeDataDescriptor(16, {}))); auto transformation4 = TransformationEquationInstruction( 22, spv::Op::OpISub, {16, 14}, return_instruction); ASSERT_TRUE( transformation4.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation4, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); auto transformation5 = TransformationEquationInstruction( 24, spv::Op::OpSNegate, {22}, return_instruction); ASSERT_TRUE( transformation5.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation5, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(24, {}), MakeDataDescriptor(15, {}))); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %30 = OpTypeVector %6 3 %15 = OpConstant %6 24 %16 = OpConstant %6 37 %31 = OpConstantComposite %30 %15 %16 %15 %33 = OpTypeBool %32 = OpConstantTrue %33 %12 = OpFunction %2 None %3 %13 = OpLabel %14 = OpIAdd %6 %15 %16 %19 = OpISub %6 %14 %16 ; ==> synonymous(%19, %15) %20 = OpISub %6 %14 %15 ; ==> synonymous(%20, %16) %22 = OpISub %6 %16 %14 %24 = OpSNegate %6 %22 ; ==> synonymous(%24, %15) OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationEquationInstructionTest, AddSubNegate2) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %15 = OpConstant %6 24 %16 = OpConstant %6 37 %12 = OpFunction %2 None %3 %13 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); protobufs::InstructionDescriptor return_instruction = MakeInstructionDescriptor(13, spv::Op::OpReturn, 0); auto transformation1 = TransformationEquationInstruction( 14, spv::Op::OpISub, {15, 16}, return_instruction); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); auto transformation2 = TransformationEquationInstruction( 17, spv::Op::OpIAdd, {14, 16}, return_instruction); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(17, {}), MakeDataDescriptor(15, {}))); auto transformation3 = TransformationEquationInstruction( 18, spv::Op::OpIAdd, {16, 14}, return_instruction); ASSERT_TRUE( transformation3.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation3, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(17, {}), MakeDataDescriptor(18, {}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(18, {}), MakeDataDescriptor(15, {}))); auto transformation4 = TransformationEquationInstruction( 19, spv::Op::OpISub, {14, 15}, return_instruction); ASSERT_TRUE( transformation4.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation4, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); auto transformation5 = TransformationEquationInstruction( 20, spv::Op::OpSNegate, {19}, return_instruction); ASSERT_TRUE( transformation5.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation5, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(20, {}), MakeDataDescriptor(16, {}))); auto transformation6 = TransformationEquationInstruction( 21, spv::Op::OpISub, {14, 19}, return_instruction); ASSERT_TRUE( transformation6.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation6, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(21, {}), MakeDataDescriptor(15, {}))); auto transformation7 = TransformationEquationInstruction( 22, spv::Op::OpISub, {14, 18}, return_instruction); ASSERT_TRUE( transformation7.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation7, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); auto transformation8 = TransformationEquationInstruction( 23, spv::Op::OpSNegate, {22}, return_instruction); ASSERT_TRUE( transformation8.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation8, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(23, {}), MakeDataDescriptor(16, {}))); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %15 = OpConstant %6 24 %16 = OpConstant %6 37 %12 = OpFunction %2 None %3 %13 = OpLabel %14 = OpISub %6 %15 %16 %17 = OpIAdd %6 %14 %16 ; ==> synonymous(%17, %15) %18 = OpIAdd %6 %16 %14 ; ==> synonymous(%17, %18, %15) %19 = OpISub %6 %14 %15 %20 = OpSNegate %6 %19 ; ==> synonymous(%20, %16) %21 = OpISub %6 %14 %19 ; ==> synonymous(%21, %15) %22 = OpISub %6 %14 %18 %23 = OpSNegate %6 %22 ; ==> synonymous(%23, %16) OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationEquationInstructionTest, Bitcast) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeInt 32 0 %8 = OpTypeFloat 32 %9 = OpTypeVector %6 2 %10 = OpTypeVector %7 2 %11 = OpTypeVector %8 2 %21 = OpTypeBool %22 = OpTypeVector %21 2 %15 = OpConstant %6 24 %16 = OpConstant %7 24 %17 = OpConstant %8 24 %18 = OpConstantComposite %9 %15 %15 %19 = OpConstantComposite %10 %16 %16 %20 = OpConstantComposite %11 %17 %17 %23 = OpConstantTrue %21 %24 = OpConstantComposite %22 %23 %23 %12 = OpFunction %2 None %3 %13 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto insert_before = MakeInstructionDescriptor(13, spv::Op::OpReturn, 0); // Too many operands. ASSERT_FALSE(TransformationEquationInstruction(50, spv::Op::OpBitcast, {15, 16}, insert_before) .IsApplicable(context.get(), transformation_context)); // Too few operands. ASSERT_FALSE(TransformationEquationInstruction(50, spv::Op::OpBitcast, {}, insert_before) .IsApplicable(context.get(), transformation_context)); // Operand's id is invalid. ASSERT_FALSE(TransformationEquationInstruction(50, spv::Op::OpBitcast, {50}, insert_before) .IsApplicable(context.get(), transformation_context)); // Operand's type is invalid ASSERT_FALSE(TransformationEquationInstruction(50, spv::Op::OpBitcast, {13}, insert_before) .IsApplicable(context.get(), transformation_context)); // Operand must be a scalar or a vector of numerical type. #ifndef NDEBUG ASSERT_DEATH(TransformationEquationInstruction(50, spv::Op::OpBitcast, {23}, insert_before) .IsApplicable(context.get(), transformation_context), "Operand is not a scalar or a vector of numerical type"); ASSERT_DEATH(TransformationEquationInstruction(50, spv::Op::OpBitcast, {24}, insert_before) .IsApplicable(context.get(), transformation_context), "Only vectors of numerical components are supported"); #else ASSERT_FALSE(TransformationEquationInstruction(50, spv::Op::OpBitcast, {23}, insert_before) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationEquationInstruction(50, spv::Op::OpBitcast, {24}, insert_before) .IsApplicable(context.get(), transformation_context)); #endif for (uint32_t operand_id = 15, fresh_id = 50; operand_id <= 20; ++operand_id, ++fresh_id) { TransformationEquationInstruction transformation( fresh_id, spv::Op::OpBitcast, {operand_id}, insert_before); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } std::string expected_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeInt 32 0 %8 = OpTypeFloat 32 %9 = OpTypeVector %6 2 %10 = OpTypeVector %7 2 %11 = OpTypeVector %8 2 %21 = OpTypeBool %22 = OpTypeVector %21 2 %15 = OpConstant %6 24 %16 = OpConstant %7 24 %17 = OpConstant %8 24 %18 = OpConstantComposite %9 %15 %15 %19 = OpConstantComposite %10 %16 %16 %20 = OpConstantComposite %11 %17 %17 %23 = OpConstantTrue %21 %24 = OpConstantComposite %22 %23 %23 %12 = OpFunction %2 None %3 %13 = OpLabel %50 = OpBitcast %8 %15 %51 = OpBitcast %8 %16 %52 = OpBitcast %6 %17 %53 = OpBitcast %11 %18 %54 = OpBitcast %11 %19 %55 = OpBitcast %9 %20 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected_shader, context.get())); } TEST(TransformationEquationInstructionTest, BitcastResultTypeFloatDoesNotExist) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeInt 32 0 %9 = OpTypeVector %6 2 %10 = OpTypeVector %7 2 %15 = OpConstant %6 24 %16 = OpConstant %7 24 %18 = OpConstantComposite %9 %15 %15 %19 = OpConstantComposite %10 %16 %16 %12 = OpFunction %2 None %3 %13 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto insert_before = MakeInstructionDescriptor(13, spv::Op::OpReturn, 0); // Scalar floating-point type does not exist. ASSERT_FALSE(TransformationEquationInstruction(50, spv::Op::OpBitcast, {15}, insert_before) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationEquationInstruction(50, spv::Op::OpBitcast, {16}, insert_before) .IsApplicable(context.get(), transformation_context)); // Vector of floating-point components does not exist. ASSERT_FALSE(TransformationEquationInstruction(50, spv::Op::OpBitcast, {18}, insert_before) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationEquationInstruction(50, spv::Op::OpBitcast, {19}, insert_before) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationEquationInstructionTest, BitcastResultTypeIntDoesNotExist1) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeFloat 32 %11 = OpTypeVector %8 2 %17 = OpConstant %8 24 %20 = OpConstantComposite %11 %17 %17 %12 = OpFunction %2 None %3 %13 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto insert_before = MakeInstructionDescriptor(13, spv::Op::OpReturn, 0); // Scalar integral type does not exist. ASSERT_FALSE(TransformationEquationInstruction(50, spv::Op::OpBitcast, {17}, insert_before) .IsApplicable(context.get(), transformation_context)); // Vector of integral components does not exist. ASSERT_FALSE(TransformationEquationInstruction(50, spv::Op::OpBitcast, {20}, insert_before) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationEquationInstructionTest, BitcastResultTypeIntDoesNotExist2) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeInt 32 0 %8 = OpTypeFloat 32 %9 = OpTypeVector %4 2 %11 = OpTypeVector %8 2 %17 = OpConstant %8 24 %20 = OpConstantComposite %11 %17 %17 %12 = OpFunction %2 None %3 %13 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto insert_before = MakeInstructionDescriptor(13, spv::Op::OpReturn, 0); { TransformationEquationInstruction transformation(50, spv::Op::OpBitcast, {17}, insert_before); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } { TransformationEquationInstruction transformation(51, spv::Op::OpBitcast, {20}, insert_before); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } std::string expected_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeInt 32 0 %8 = OpTypeFloat 32 %9 = OpTypeVector %4 2 %11 = OpTypeVector %8 2 %17 = OpConstant %8 24 %20 = OpConstantComposite %11 %17 %17 %12 = OpFunction %2 None %3 %13 = OpLabel %50 = OpBitcast %4 %17 %51 = OpBitcast %9 %20 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected_shader, context.get())); } TEST(TransformationEquationInstructionTest, BitcastResultTypeIntDoesNotExist3) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeInt 32 1 %8 = OpTypeFloat 32 %9 = OpTypeVector %4 2 %11 = OpTypeVector %8 2 %17 = OpConstant %8 24 %20 = OpConstantComposite %11 %17 %17 %12 = OpFunction %2 None %3 %13 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto insert_before = MakeInstructionDescriptor(13, spv::Op::OpReturn, 0); { TransformationEquationInstruction transformation(50, spv::Op::OpBitcast, {17}, insert_before); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } { TransformationEquationInstruction transformation(51, spv::Op::OpBitcast, {20}, insert_before); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } std::string expected_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeInt 32 1 %8 = OpTypeFloat 32 %9 = OpTypeVector %4 2 %11 = OpTypeVector %8 2 %17 = OpConstant %8 24 %20 = OpConstantComposite %11 %17 %17 %12 = OpFunction %2 None %3 %13 = OpLabel %50 = OpBitcast %4 %17 %51 = OpBitcast %9 %20 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected_shader, context.get())); } TEST(TransformationEquationInstructionTest, BitcastResultTypeIntDoesNotExist4) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeInt 32 1 %8 = OpTypeFloat 32 %11 = OpTypeVector %8 2 %17 = OpConstant %8 24 %20 = OpConstantComposite %11 %17 %17 %12 = OpFunction %2 None %3 %13 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto insert_before = MakeInstructionDescriptor(13, spv::Op::OpReturn, 0); { TransformationEquationInstruction transformation(50, spv::Op::OpBitcast, {17}, insert_before); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } ASSERT_FALSE(TransformationEquationInstruction(51, spv::Op::OpBitcast, {20}, insert_before) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string expected_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeInt 32 1 %8 = OpTypeFloat 32 %11 = OpTypeVector %8 2 %17 = OpConstant %8 24 %20 = OpConstantComposite %11 %17 %17 %12 = OpFunction %2 None %3 %13 = OpLabel %50 = OpBitcast %4 %17 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected_shader, context.get())); } TEST(TransformationEquationInstructionTest, BitcastResultTypeIntDoesNotExist5) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeInt 32 0 %8 = OpTypeFloat 32 %11 = OpTypeVector %8 2 %17 = OpConstant %8 24 %20 = OpConstantComposite %11 %17 %17 %12 = OpFunction %2 None %3 %13 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto insert_before = MakeInstructionDescriptor(13, spv::Op::OpReturn, 0); { TransformationEquationInstruction transformation(50, spv::Op::OpBitcast, {17}, insert_before); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } ASSERT_FALSE(TransformationEquationInstruction(51, spv::Op::OpBitcast, {20}, insert_before) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string expected_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeInt 32 0 %8 = OpTypeFloat 32 %11 = OpTypeVector %8 2 %17 = OpConstant %8 24 %20 = OpConstantComposite %11 %17 %17 %12 = OpFunction %2 None %3 %13 = OpLabel %50 = OpBitcast %4 %17 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected_shader, context.get())); } TEST(TransformationEquationInstructionTest, BitcastResultTypeIntDoesNotExist6) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeInt 32 1 %5 = OpTypeInt 32 0 %8 = OpTypeFloat 32 %9 = OpTypeVector %5 2 %11 = OpTypeVector %8 2 %17 = OpConstant %8 24 %20 = OpConstantComposite %11 %17 %17 %12 = OpFunction %2 None %3 %13 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto insert_before = MakeInstructionDescriptor(13, spv::Op::OpReturn, 0); { TransformationEquationInstruction transformation(50, spv::Op::OpBitcast, {17}, insert_before); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } { TransformationEquationInstruction transformation(51, spv::Op::OpBitcast, {20}, insert_before); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string expected_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeInt 32 1 %5 = OpTypeInt 32 0 %8 = OpTypeFloat 32 %9 = OpTypeVector %5 2 %11 = OpTypeVector %8 2 %17 = OpConstant %8 24 %20 = OpConstantComposite %11 %17 %17 %12 = OpFunction %2 None %3 %13 = OpLabel %50 = OpBitcast %4 %17 %51 = OpBitcast %9 %20 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected_shader, context.get())); } TEST(TransformationEquationInstructionTest, BitcastResultTypeIntDoesNotExist7) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeInt 32 1 %5 = OpTypeInt 32 0 %8 = OpTypeFloat 32 %9 = OpTypeVector %4 2 %11 = OpTypeVector %8 2 %17 = OpConstant %8 24 %20 = OpConstantComposite %11 %17 %17 %12 = OpFunction %2 None %3 %13 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto insert_before = MakeInstructionDescriptor(13, spv::Op::OpReturn, 0); { TransformationEquationInstruction transformation(50, spv::Op::OpBitcast, {17}, insert_before); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } { TransformationEquationInstruction transformation(51, spv::Op::OpBitcast, {20}, insert_before); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string expected_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeInt 32 1 %5 = OpTypeInt 32 0 %8 = OpTypeFloat 32 %9 = OpTypeVector %4 2 %11 = OpTypeVector %8 2 %17 = OpConstant %8 24 %20 = OpConstantComposite %11 %17 %17 %12 = OpFunction %2 None %3 %13 = OpLabel %50 = OpBitcast %4 %17 %51 = OpBitcast %9 %20 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected_shader, context.get())); } TEST(TransformationEquationInstructionTest, Miscellaneous1) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %113 = OpConstant %6 24 %12 = OpFunction %2 None %3 %13 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); protobufs::InstructionDescriptor return_instruction = MakeInstructionDescriptor(13, spv::Op::OpReturn, 0); auto transformation1 = TransformationEquationInstruction( 522, spv::Op::OpISub, {113, 113}, return_instruction); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); auto transformation2 = TransformationEquationInstruction( 570, spv::Op::OpIAdd, {522, 113}, return_instruction); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %113 = OpConstant %6 24 %12 = OpFunction %2 None %3 %13 = OpLabel %522 = OpISub %6 %113 %113 %570 = OpIAdd %6 %522 %113 OpReturn OpFunctionEnd )"; ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(570, {}), MakeDataDescriptor(113, {}))); ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationEquationInstructionTest, Miscellaneous2) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %113 = OpConstant %6 24 %12 = OpFunction %2 None %3 %13 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); protobufs::InstructionDescriptor return_instruction = MakeInstructionDescriptor(13, spv::Op::OpReturn, 0); auto transformation1 = TransformationEquationInstruction( 522, spv::Op::OpISub, {113, 113}, return_instruction); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); auto transformation2 = TransformationEquationInstruction( 570, spv::Op::OpIAdd, {522, 113}, return_instruction); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %113 = OpConstant %6 24 %12 = OpFunction %2 None %3 %13 = OpLabel %522 = OpISub %6 %113 %113 %570 = OpIAdd %6 %522 %113 OpReturn OpFunctionEnd )"; ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(570, {}), MakeDataDescriptor(113, {}))); ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationEquationInstructionTest, ConversionInstructions) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %4 = OpTypeInt 32 0 %5 = OpTypeFloat 32 %7 = OpTypeVector %6 3 %8 = OpTypeVector %4 3 %9 = OpTypeVector %5 3 %10 = OpConstant %6 12 %20 = OpConstant %6 12 %11 = OpConstant %4 12 %21 = OpConstant %4 12 %14 = OpConstant %5 12 %15 = OpConstantComposite %7 %10 %10 %10 %18 = OpConstantComposite %7 %10 %10 %10 %16 = OpConstantComposite %8 %11 %11 %11 %19 = OpConstantComposite %8 %11 %11 %11 %17 = OpConstantComposite %9 %14 %14 %14 %12 = OpFunction %2 None %3 %13 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); protobufs::InstructionDescriptor return_instruction = MakeInstructionDescriptor(13, spv::Op::OpReturn, 0); // Too few instruction operands. ASSERT_FALSE(TransformationEquationInstruction(50, spv::Op::OpConvertSToF, {}, return_instruction) .IsApplicable(context.get(), transformation_context)); // Too many instruction operands. ASSERT_FALSE(TransformationEquationInstruction(50, spv::Op::OpConvertSToF, {15, 16}, return_instruction) .IsApplicable(context.get(), transformation_context)); // Operand has no type id. ASSERT_FALSE(TransformationEquationInstruction(50, spv::Op::OpConvertSToF, {7}, return_instruction) .IsApplicable(context.get(), transformation_context)); // OpConvertSToF and OpConvertUToF require an operand to have scalar or vector // of integral components type. ASSERT_FALSE(TransformationEquationInstruction(50, spv::Op::OpConvertSToF, {17}, return_instruction) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationEquationInstruction(50, spv::Op::OpConvertSToF, {14}, return_instruction) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationEquationInstruction(50, spv::Op::OpConvertUToF, {17}, return_instruction) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationEquationInstruction(50, spv::Op::OpConvertUToF, {14}, return_instruction) .IsApplicable(context.get(), transformation_context)); { TransformationEquationInstruction transformation(50, spv::Op::OpConvertSToF, {15}, return_instruction); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } { TransformationEquationInstruction transformation(51, spv::Op::OpConvertSToF, {10}, return_instruction); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } { TransformationEquationInstruction transformation(52, spv::Op::OpConvertUToF, {16}, return_instruction); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } { TransformationEquationInstruction transformation(53, spv::Op::OpConvertUToF, {11}, return_instruction); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } { TransformationEquationInstruction transformation(58, spv::Op::OpConvertSToF, {18}, return_instruction); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } { TransformationEquationInstruction transformation(59, spv::Op::OpConvertUToF, {19}, return_instruction); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } { TransformationEquationInstruction transformation(60, spv::Op::OpConvertSToF, {20}, return_instruction); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } { TransformationEquationInstruction transformation(61, spv::Op::OpConvertUToF, {21}, return_instruction); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformations = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %4 = OpTypeInt 32 0 %5 = OpTypeFloat 32 %7 = OpTypeVector %6 3 %8 = OpTypeVector %4 3 %9 = OpTypeVector %5 3 %10 = OpConstant %6 12 %20 = OpConstant %6 12 %11 = OpConstant %4 12 %21 = OpConstant %4 12 %14 = OpConstant %5 12 %15 = OpConstantComposite %7 %10 %10 %10 %18 = OpConstantComposite %7 %10 %10 %10 %16 = OpConstantComposite %8 %11 %11 %11 %19 = OpConstantComposite %8 %11 %11 %11 %17 = OpConstantComposite %9 %14 %14 %14 %12 = OpFunction %2 None %3 %13 = OpLabel %50 = OpConvertSToF %9 %15 %51 = OpConvertSToF %5 %10 %52 = OpConvertUToF %9 %16 %53 = OpConvertUToF %5 %11 %58 = OpConvertSToF %9 %18 %59 = OpConvertUToF %9 %19 %60 = OpConvertSToF %5 %20 %61 = OpConvertUToF %5 %21 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformations, context.get())); } TEST(TransformationEquationInstructionTest, FloatResultTypeDoesNotExist) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpTypeInt 32 1 %8 = OpTypeVector %6 3 %9 = OpTypeVector %7 3 %10 = OpConstant %6 24 %11 = OpConstant %7 25 %14 = OpConstantComposite %8 %10 %10 %10 %15 = OpConstantComposite %9 %11 %11 %11 %12 = OpFunction %2 None %3 %13 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); protobufs::InstructionDescriptor return_instruction = MakeInstructionDescriptor(13, spv::Op::OpReturn, 0); // Scalar float type doesn't exist. ASSERT_FALSE(TransformationEquationInstruction(16, spv::Op::OpConvertUToF, {10}, return_instruction) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationEquationInstruction(16, spv::Op::OpConvertSToF, {11}, return_instruction) .IsApplicable(context.get(), transformation_context)); // Vector float type doesn't exist. ASSERT_FALSE(TransformationEquationInstruction(16, spv::Op::OpConvertUToF, {14}, return_instruction) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationEquationInstruction(16, spv::Op::OpConvertSToF, {15}, return_instruction) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationEquationInstructionTest, HandlesIrrelevantIds) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %30 = OpTypeVector %6 3 %15 = OpConstant %6 24 %16 = OpConstant %6 37 %31 = OpConstantComposite %30 %15 %16 %15 %33 = OpTypeBool %32 = OpConstantTrue %33 %12 = OpFunction %2 None %3 %13 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto return_instruction = MakeInstructionDescriptor(13, spv::Op::OpReturn, 0); // Applicable. TransformationEquationInstruction transformation( 14, spv::Op::OpIAdd, {15, 16}, return_instruction); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); // Handles irrelevant ids. transformation_context.GetFactManager()->AddFactIdIsIrrelevant(16); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); transformation_context.GetFactManager()->AddFactIdIsIrrelevant(15); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationEquationInstructionTest, HandlesDeadBlock) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %30 = OpTypeVector %6 3 %15 = OpConstant %6 24 %16 = OpConstant %6 37 %31 = OpConstantComposite %30 %15 %16 %15 %33 = OpTypeBool %32 = OpConstantTrue %33 %12 = OpFunction %2 None %3 %13 = OpLabel OpSelectionMerge %40 None OpBranchConditional %32 %40 %41 %41 = OpLabel OpBranch %40 %40 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactBlockIsDead(41); TransformationEquationInstruction transformation1( 14, spv::Op::OpIAdd, {15, 16}, MakeInstructionDescriptor(13, spv::Op::OpSelectionMerge, 0)); // No synonym is created since block is dead. TransformationEquationInstruction transformation2( 100, spv::Op::OpISub, {14, 16}, MakeInstructionDescriptor(41, spv::Op::OpBranch, 0)); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(100, {}), MakeDataDescriptor(15, {}))); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_expand_vector_reduction_test.cpp000066400000000000000000000241561475742701700323240ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_expand_vector_reduction.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationExpandVectorReductionTest, IsApplicable) { std::string reference_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %9 "main" ; Types %2 = OpTypeBool %3 = OpTypeVector %2 2 %4 = OpTypeVoid %5 = OpTypeFunction %4 ; Constants %6 = OpConstantTrue %2 %7 = OpConstantFalse %2 %8 = OpConstantComposite %3 %6 %7 ; main function %9 = OpFunction %4 None %5 %10 = OpLabel %11 = OpAny %2 %8 %12 = OpAll %2 %8 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Tests undefined instruction. auto transformation = TransformationExpandVectorReduction(13, {14, 15, 16}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests non OpAny or OpAll instruction. transformation = TransformationExpandVectorReduction(10, {13, 14, 15}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests the number of fresh ids being different than the necessary. transformation = TransformationExpandVectorReduction(11, {13, 14}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); transformation = TransformationExpandVectorReduction(12, {13, 14, 15, 16}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests non-fresh ids. transformation = TransformationExpandVectorReduction(11, {12, 13, 14}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests duplicated fresh ids. transformation = TransformationExpandVectorReduction(11, {13, 13, 14}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests applicable transformations. transformation = TransformationExpandVectorReduction(11, {13, 14, 15}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); transformation = TransformationExpandVectorReduction(12, {13, 14, 15}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationExpandVectorReductionTest, Apply) { std::string reference_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %13 "main" ; Types %2 = OpTypeBool %3 = OpTypeVector %2 2 %4 = OpTypeVector %2 3 %5 = OpTypeVector %2 4 %6 = OpTypeVoid %7 = OpTypeFunction %6 ; Constants %8 = OpConstantTrue %2 %9 = OpConstantFalse %2 %10 = OpConstantComposite %3 %8 %9 %11 = OpConstantComposite %4 %8 %9 %8 %12 = OpConstantComposite %5 %8 %9 %8 %9 ; main function %13 = OpFunction %6 None %7 %14 = OpLabel ; OpAny for 2-dimensional vector %15 = OpAny %2 %10 ; OpAny for 3-dimensional vector %16 = OpAny %2 %11 ; OpAny for 4-dimensional vector %17 = OpAny %2 %12 ; OpAll for 2-dimensional vector %18 = OpAll %2 %10 ; OpAll for 3-dimensional vector %19 = OpAll %2 %11 ; OpAll for 4-dimensional vector %20 = OpAll %2 %12 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Adds OpAny synonym for 2-dimensional vector. auto transformation = TransformationExpandVectorReduction(15, {21, 22, 23}); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(23, {}), MakeDataDescriptor(15, {}))); // Adds OpAny synonym for 3-dimensional vector. transformation = TransformationExpandVectorReduction(16, {24, 25, 26, 27, 28}); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(28, {}), MakeDataDescriptor(16, {}))); // Adds OpAny synonym for 4-dimensional vector. transformation = TransformationExpandVectorReduction(17, {29, 30, 31, 32, 33, 34, 35}); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(35, {}), MakeDataDescriptor(17, {}))); // Adds OpAll synonym for 2-dimensional vector. transformation = TransformationExpandVectorReduction(18, {36, 37, 38}); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(38, {}), MakeDataDescriptor(18, {}))); // Adds OpAll synonym for 3-dimensional vector. transformation = TransformationExpandVectorReduction(19, {39, 40, 41, 42, 43}); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(43, {}), MakeDataDescriptor(19, {}))); // Adds OpAll synonym for 4-dimensional vector. transformation = TransformationExpandVectorReduction(20, {44, 45, 46, 47, 48, 49, 50}); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(50, {}), MakeDataDescriptor(20, {}))); std::string variant_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %13 "main" ; Types %2 = OpTypeBool %3 = OpTypeVector %2 2 %4 = OpTypeVector %2 3 %5 = OpTypeVector %2 4 %6 = OpTypeVoid %7 = OpTypeFunction %6 ; Constants %8 = OpConstantTrue %2 %9 = OpConstantFalse %2 %10 = OpConstantComposite %3 %8 %9 %11 = OpConstantComposite %4 %8 %9 %8 %12 = OpConstantComposite %5 %8 %9 %8 %9 ; main function %13 = OpFunction %6 None %7 %14 = OpLabel ; Add OpAny synonym for 2-dimensional vector %21 = OpCompositeExtract %2 %10 0 %22 = OpCompositeExtract %2 %10 1 %23 = OpLogicalOr %2 %21 %22 %15 = OpAny %2 %10 ; Add OpAny synonym for 3-dimensional vector %24 = OpCompositeExtract %2 %11 0 %25 = OpCompositeExtract %2 %11 1 %26 = OpCompositeExtract %2 %11 2 %27 = OpLogicalOr %2 %24 %25 %28 = OpLogicalOr %2 %26 %27 %16 = OpAny %2 %11 ; Add OpAny synonym for 4-dimensional vector %29 = OpCompositeExtract %2 %12 0 %30 = OpCompositeExtract %2 %12 1 %31 = OpCompositeExtract %2 %12 2 %32 = OpCompositeExtract %2 %12 3 %33 = OpLogicalOr %2 %29 %30 %34 = OpLogicalOr %2 %31 %33 %35 = OpLogicalOr %2 %32 %34 %17 = OpAny %2 %12 ; Add OpAll synonym for 2-dimensional vector %36 = OpCompositeExtract %2 %10 0 %37 = OpCompositeExtract %2 %10 1 %38 = OpLogicalAnd %2 %36 %37 %18 = OpAll %2 %10 ; Add OpAll synonym for 3-dimensional vector %39 = OpCompositeExtract %2 %11 0 %40 = OpCompositeExtract %2 %11 1 %41 = OpCompositeExtract %2 %11 2 %42 = OpLogicalAnd %2 %39 %40 %43 = OpLogicalAnd %2 %41 %42 %19 = OpAll %2 %11 ; Add OpAll synonym for 4-dimensional vector %44 = OpCompositeExtract %2 %12 0 %45 = OpCompositeExtract %2 %12 1 %46 = OpCompositeExtract %2 %12 2 %47 = OpCompositeExtract %2 %12 3 %48 = OpLogicalAnd %2 %44 %45 %49 = OpLogicalAnd %2 %46 %48 %50 = OpLogicalAnd %2 %47 %49 %20 = OpAll %2 %12 OpReturn OpFunctionEnd )"; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(IsEqual(env, variant_shader, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_flatten_conditional_branch_test.cpp000066400000000000000000002364771475742701700327570ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_flatten_conditional_branch.h" #include "gtest/gtest.h" #include "source/fuzz/counter_overflow_id_source.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { protobufs::SideEffectWrapperInfo MakeSideEffectWrapperInfo( const protobufs::InstructionDescriptor& instruction, uint32_t merge_block_id, uint32_t execute_block_id, uint32_t actual_result_id, uint32_t alternative_block_id, uint32_t placeholder_result_id, uint32_t value_to_copy_id) { protobufs::SideEffectWrapperInfo result; *result.mutable_instruction() = instruction; result.set_merge_block_id(merge_block_id); result.set_execute_block_id(execute_block_id); result.set_actual_result_id(actual_result_id); result.set_alternative_block_id(alternative_block_id); result.set_placeholder_result_id(placeholder_result_id); result.set_value_to_copy_id(value_to_copy_id); return result; } protobufs::SideEffectWrapperInfo MakeSideEffectWrapperInfo( const protobufs::InstructionDescriptor& instruction, uint32_t merge_block_id, uint32_t execute_block_id) { return MakeSideEffectWrapperInfo(instruction, merge_block_id, execute_block_id, 0, 0, 0, 0); } TEST(TransformationFlattenConditionalBranchTest, Inapplicable) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeInt 32 1 %7 = OpTypeInt 32 0 %8 = OpConstant %7 0 %9 = OpTypeBool %10 = OpConstantTrue %9 %11 = OpTypePointer Function %6 %12 = OpTypePointer Workgroup %6 %3 = OpVariable %12 Workgroup %13 = OpConstant %6 2 %2 = OpFunction %4 None %5 %14 = OpLabel OpBranch %15 %15 = OpLabel OpSelectionMerge %16 None OpSwitch %13 %17 2 %18 %17 = OpLabel OpBranch %16 %18 = OpLabel OpBranch %16 %16 = OpLabel OpLoopMerge %19 %16 None OpBranchConditional %10 %16 %19 %19 = OpLabel OpSelectionMerge %20 None OpBranchConditional %10 %21 %20 %21 = OpLabel OpReturn %20 = OpLabel OpSelectionMerge %22 None OpBranchConditional %10 %23 %22 %23 = OpLabel OpSelectionMerge %24 None OpBranchConditional %10 %25 %24 %25 = OpLabel OpBranch %24 %24 = OpLabel OpBranch %22 %22 = OpLabel OpSelectionMerge %26 None OpBranchConditional %10 %26 %27 %27 = OpLabel OpBranch %28 %28 = OpLabel OpLoopMerge %29 %28 None OpBranchConditional %10 %28 %29 %29 = OpLabel OpBranch %26 %26 = OpLabel OpSelectionMerge %30 None OpBranchConditional %10 %30 %31 %31 = OpLabel OpBranch %32 %32 = OpLabel %33 = OpAtomicLoad %6 %3 %8 %8 OpBranch %30 %30 = OpLabel OpSelectionMerge %34 None OpBranchConditional %10 %35 %34 %35 = OpLabel OpMemoryBarrier %8 %8 OpBranch %34 %34 = OpLabel OpLoopMerge %40 %39 None OpBranchConditional %10 %36 %40 %36 = OpLabel OpSelectionMerge %38 None OpBranchConditional %10 %37 %38 %37 = OpLabel OpBranch %40 %38 = OpLabel OpBranch %39 %39 = OpLabel OpBranch %34 %40 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Block %15 does not end with OpBranchConditional. ASSERT_FALSE(TransformationFlattenConditionalBranch(15, true, 0, 0, 0, {}) .IsApplicable(context.get(), transformation_context)); // Block %17 is not a selection header. ASSERT_FALSE(TransformationFlattenConditionalBranch(17, true, 0, 0, 0, {}) .IsApplicable(context.get(), transformation_context)); // Block %16 is a loop header, not a selection header. ASSERT_FALSE(TransformationFlattenConditionalBranch(16, true, 0, 0, 0, {}) .IsApplicable(context.get(), transformation_context)); // Block %19 and the corresponding merge block do not describe a single-entry, // single-exit region, because there is a return instruction in %21. ASSERT_FALSE(TransformationFlattenConditionalBranch(19, true, 0, 0, 0, {}) .IsApplicable(context.get(), transformation_context)); // Block %20 is the header of a construct containing an inner selection // construct. ASSERT_FALSE(TransformationFlattenConditionalBranch(20, true, 0, 0, 0, {}) .IsApplicable(context.get(), transformation_context)); // Block %22 is the header of a construct containing an inner loop. ASSERT_FALSE(TransformationFlattenConditionalBranch(22, true, 0, 0, 0, {}) .IsApplicable(context.get(), transformation_context)); // Block %30 is the header of a construct containing a barrier instruction. ASSERT_FALSE(TransformationFlattenConditionalBranch(30, true, 0, 0, 0, {}) .IsApplicable(context.get(), transformation_context)); // %33 is not a block. ASSERT_FALSE(TransformationFlattenConditionalBranch(33, true, 0, 0, 0, {}) .IsApplicable(context.get(), transformation_context)); // Block %36 and the corresponding merge block do not describe a single-entry, // single-exit region, because block %37 breaks out of the outer loop. ASSERT_FALSE(TransformationFlattenConditionalBranch(36, true, 0, 0, 0, {}) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationFlattenConditionalBranchTest, Simple) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeBool %4 = OpConstantTrue %3 %5 = OpTypeVoid %6 = OpTypeFunction %5 %2 = OpFunction %5 None %6 %7 = OpLabel OpSelectionMerge %8 None OpBranchConditional %4 %9 %10 %10 = OpLabel %26 = OpPhi %3 %4 %7 OpBranch %8 %9 = OpLabel %27 = OpPhi %3 %4 %7 %11 = OpCopyObject %3 %4 OpBranch %8 %8 = OpLabel %12 = OpPhi %3 %11 %9 %4 %10 %23 = OpPhi %3 %4 %9 %4 %10 OpBranch %13 %13 = OpLabel %14 = OpCopyObject %3 %4 OpSelectionMerge %15 None OpBranchConditional %4 %16 %17 %16 = OpLabel %28 = OpPhi %3 %4 %13 OpBranch %18 %18 = OpLabel OpBranch %19 %17 = OpLabel %29 = OpPhi %3 %4 %13 %20 = OpCopyObject %3 %4 OpBranch %19 %19 = OpLabel %21 = OpPhi %3 %4 %18 %20 %17 OpBranch %15 %15 = OpLabel OpSelectionMerge %22 None OpBranchConditional %4 %22 %22 %22 = OpLabel %30 = OpPhi %3 %4 %15 OpSelectionMerge %25 None OpBranchConditional %4 %24 %24 %24 = OpLabel OpBranch %25 %25 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto transformation1 = TransformationFlattenConditionalBranch(7, true, 0, 0, 0, {}); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); auto transformation2 = TransformationFlattenConditionalBranch(13, false, 0, 0, 0, {}); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); auto transformation3 = TransformationFlattenConditionalBranch(15, true, 0, 0, 0, {}); ASSERT_TRUE( transformation3.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation3, context.get(), &transformation_context); auto transformation4 = TransformationFlattenConditionalBranch(22, false, 0, 0, 0, {}); ASSERT_TRUE( transformation4.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation4, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformations = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeBool %4 = OpConstantTrue %3 %5 = OpTypeVoid %6 = OpTypeFunction %5 %2 = OpFunction %5 None %6 %7 = OpLabel OpBranch %9 %9 = OpLabel %27 = OpPhi %3 %4 %7 %11 = OpCopyObject %3 %4 OpBranch %10 %10 = OpLabel %26 = OpPhi %3 %4 %9 OpBranch %8 %8 = OpLabel %12 = OpSelect %3 %4 %11 %4 %23 = OpSelect %3 %4 %4 %4 OpBranch %13 %13 = OpLabel %14 = OpCopyObject %3 %4 OpBranch %17 %17 = OpLabel %29 = OpPhi %3 %4 %13 %20 = OpCopyObject %3 %4 OpBranch %16 %16 = OpLabel %28 = OpPhi %3 %4 %17 OpBranch %18 %18 = OpLabel OpBranch %19 %19 = OpLabel %21 = OpSelect %3 %4 %4 %20 OpBranch %15 %15 = OpLabel OpBranch %22 %22 = OpLabel %30 = OpPhi %3 %4 %15 OpBranch %24 %24 = OpLabel OpBranch %25 %25 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformations, context.get())); } TEST(TransformationFlattenConditionalBranchTest, LoadStoreFunctionCall) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %9 = OpTypeVoid %10 = OpTypeFunction %9 %11 = OpTypeInt 32 1 %12 = OpTypeVector %11 4 %13 = OpTypeFunction %11 %70 = OpConstant %11 0 %14 = OpConstant %11 1 %15 = OpTypeFloat 32 %16 = OpTypeVector %15 2 %17 = OpConstant %15 1 %18 = OpConstantComposite %16 %17 %17 %19 = OpTypeBool %20 = OpConstantTrue %19 %21 = OpTypePointer Function %11 %22 = OpTypeSampler %23 = OpTypeImage %9 2D 2 0 0 1 Unknown %24 = OpTypeSampledImage %23 %25 = OpTypePointer Function %23 %26 = OpTypePointer Function %22 %27 = OpTypeInt 32 0 %28 = OpConstant %27 2 %29 = OpTypeArray %11 %28 %30 = OpTypePointer Function %29 %2 = OpFunction %9 None %10 %31 = OpLabel %4 = OpVariable %21 Function %5 = OpVariable %30 Function %32 = OpVariable %25 Function %33 = OpVariable %26 Function %34 = OpLoad %23 %32 %35 = OpLoad %22 %33 OpSelectionMerge %36 None OpBranchConditional %20 %37 %36 %37 = OpLabel %6 = OpLoad %11 %4 %7 = OpIAdd %11 %6 %14 OpStore %4 %7 OpBranch %36 %36 = OpLabel %42 = OpPhi %11 %14 %37 %14 %31 OpSelectionMerge %43 None OpBranchConditional %20 %44 %45 %44 = OpLabel %8 = OpFunctionCall %11 %3 OpStore %4 %8 OpBranch %46 %45 = OpLabel %47 = OpAccessChain %21 %5 %14 OpStore %47 %14 OpBranch %46 %46 = OpLabel OpStore %4 %14 OpBranch %43 %43 = OpLabel OpStore %4 %14 OpSelectionMerge %48 None OpBranchConditional %20 %49 %48 %49 = OpLabel OpBranch %48 %48 = OpLabel OpSelectionMerge %50 None OpBranchConditional %20 %51 %50 %51 = OpLabel %52 = OpSampledImage %24 %34 %35 %53 = OpLoad %11 %4 %54 = OpImageSampleImplicitLod %12 %52 %18 OpBranch %50 %50 = OpLabel OpReturn OpFunctionEnd %3 = OpFunction %11 None %13 %55 = OpLabel OpReturnValue %14 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); #ifndef NDEBUG // The following checks lead to assertion failures, since some entries // requiring fresh ids are not present in the map, and the transformation // context does not have a source overflow ids. ASSERT_DEATH(TransformationFlattenConditionalBranch(31, true, 0, 0, 0, {}) .IsApplicable(context.get(), transformation_context), "Bad attempt to query whether overflow ids are available."); ASSERT_DEATH(TransformationFlattenConditionalBranch( 31, true, 0, 0, 0, {{MakeSideEffectWrapperInfo( MakeInstructionDescriptor(6, spv::Op::OpLoad, 0), 100, 101, 102, 103, 104, 14)}}) .IsApplicable(context.get(), transformation_context), "Bad attempt to query whether overflow ids are available."); #endif // The map maps from an instruction to a list with not enough fresh ids. ASSERT_FALSE(TransformationFlattenConditionalBranch( 31, true, 0, 0, 0, {{MakeSideEffectWrapperInfo( MakeInstructionDescriptor(6, spv::Op::OpLoad, 0), 100, 101, 102, 103, 0, 0)}}) .IsApplicable(context.get(), transformation_context)); // Not all fresh ids given are distinct. ASSERT_FALSE(TransformationFlattenConditionalBranch( 31, true, 0, 0, 0, {{MakeSideEffectWrapperInfo( MakeInstructionDescriptor(6, spv::Op::OpLoad, 0), 100, 100, 102, 103, 104, 0)}}) .IsApplicable(context.get(), transformation_context)); // %48 heads a construct containing an OpSampledImage instruction. ASSERT_FALSE(TransformationFlattenConditionalBranch( 48, true, 0, 0, 0, {{MakeSideEffectWrapperInfo( MakeInstructionDescriptor(53, spv::Op::OpLoad, 0), 100, 101, 102, 103, 104, 0)}}) .IsApplicable(context.get(), transformation_context)); // %0 is not a valid id. ASSERT_FALSE( TransformationFlattenConditionalBranch( 31, true, 0, 0, 0, {MakeSideEffectWrapperInfo( MakeInstructionDescriptor(6, spv::Op::OpLoad, 0), 104, 100, 101, 102, 103, 0), MakeSideEffectWrapperInfo( MakeInstructionDescriptor(6, spv::Op::OpStore, 0), 106, 105)}) .IsApplicable(context.get(), transformation_context)); // %17 is a float constant, while %6 has int type. ASSERT_FALSE( TransformationFlattenConditionalBranch( 31, true, 0, 0, 0, {MakeSideEffectWrapperInfo( MakeInstructionDescriptor(6, spv::Op::OpLoad, 0), 104, 100, 101, 102, 103, 17), MakeSideEffectWrapperInfo( MakeInstructionDescriptor(6, spv::Op::OpStore, 0), 106, 105)}) .IsApplicable(context.get(), transformation_context)); auto transformation1 = TransformationFlattenConditionalBranch( 31, true, 0, 0, 0, {MakeSideEffectWrapperInfo( MakeInstructionDescriptor(6, spv::Op::OpLoad, 0), 104, 100, 101, 102, 103, 70), MakeSideEffectWrapperInfo( MakeInstructionDescriptor(6, spv::Op::OpStore, 0), 106, 105)}); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); // Check that the placeholder id was marked as irrelevant. ASSERT_TRUE(transformation_context.GetFactManager()->IdIsIrrelevant(103)); // Make a new transformation context with a source of overflow ids. auto overflow_ids_unique_ptr = MakeUnique(1000); auto overflow_ids_ptr = overflow_ids_unique_ptr.get(); TransformationContext new_transformation_context( MakeUnique(context.get()), validator_options, std::move(overflow_ids_unique_ptr)); auto transformation2 = TransformationFlattenConditionalBranch( 36, false, 0, 0, 0, {MakeSideEffectWrapperInfo( MakeInstructionDescriptor(8, spv::Op::OpStore, 0), 114, 113)}); ASSERT_TRUE( transformation2.IsApplicable(context.get(), new_transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &new_transformation_context, overflow_ids_ptr->GetIssuedOverflowIds()); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformations = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %9 = OpTypeVoid %10 = OpTypeFunction %9 %11 = OpTypeInt 32 1 %12 = OpTypeVector %11 4 %13 = OpTypeFunction %11 %70 = OpConstant %11 0 %14 = OpConstant %11 1 %15 = OpTypeFloat 32 %16 = OpTypeVector %15 2 %17 = OpConstant %15 1 %18 = OpConstantComposite %16 %17 %17 %19 = OpTypeBool %20 = OpConstantTrue %19 %21 = OpTypePointer Function %11 %22 = OpTypeSampler %23 = OpTypeImage %9 2D 2 0 0 1 Unknown %24 = OpTypeSampledImage %23 %25 = OpTypePointer Function %23 %26 = OpTypePointer Function %22 %27 = OpTypeInt 32 0 %28 = OpConstant %27 2 %29 = OpTypeArray %11 %28 %30 = OpTypePointer Function %29 %2 = OpFunction %9 None %10 %31 = OpLabel %4 = OpVariable %21 Function %5 = OpVariable %30 Function %32 = OpVariable %25 Function %33 = OpVariable %26 Function %34 = OpLoad %23 %32 %35 = OpLoad %22 %33 OpBranch %37 %37 = OpLabel OpSelectionMerge %104 None OpBranchConditional %20 %100 %102 %100 = OpLabel %101 = OpLoad %11 %4 OpBranch %104 %102 = OpLabel %103 = OpCopyObject %11 %70 OpBranch %104 %104 = OpLabel %6 = OpPhi %11 %101 %100 %103 %102 %7 = OpIAdd %11 %6 %14 OpSelectionMerge %106 None OpBranchConditional %20 %105 %106 %105 = OpLabel OpStore %4 %7 OpBranch %106 %106 = OpLabel OpBranch %36 %36 = OpLabel %42 = OpSelect %11 %20 %14 %14 OpBranch %45 %45 = OpLabel %47 = OpAccessChain %21 %5 %14 OpSelectionMerge %1005 None OpBranchConditional %20 %1005 %1006 %1006 = OpLabel OpStore %47 %14 OpBranch %1005 %1005 = OpLabel OpBranch %44 %44 = OpLabel OpSelectionMerge %1000 None OpBranchConditional %20 %1001 %1003 %1001 = OpLabel %1002 = OpFunctionCall %11 %3 OpBranch %1000 %1003 = OpLabel %1004 = OpCopyObject %11 %70 OpBranch %1000 %1000 = OpLabel %8 = OpPhi %11 %1002 %1001 %1004 %1003 OpSelectionMerge %114 None OpBranchConditional %20 %113 %114 %113 = OpLabel OpStore %4 %8 OpBranch %114 %114 = OpLabel OpBranch %46 %46 = OpLabel OpStore %4 %14 OpBranch %43 %43 = OpLabel OpStore %4 %14 OpSelectionMerge %48 None OpBranchConditional %20 %49 %48 %49 = OpLabel OpBranch %48 %48 = OpLabel OpSelectionMerge %50 None OpBranchConditional %20 %51 %50 %51 = OpLabel %52 = OpSampledImage %24 %34 %35 %53 = OpLoad %11 %4 %54 = OpImageSampleImplicitLod %12 %52 %18 OpBranch %50 %50 = OpLabel OpReturn OpFunctionEnd %3 = OpFunction %11 None %13 %55 = OpLabel OpReturnValue %14 OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformations, context.get())); } // namespace TEST(TransformationFlattenConditionalBranchTest, EdgeCases) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeBool %5 = OpConstantTrue %4 %6 = OpTypeFunction %3 %2 = OpFunction %3 None %6 %7 = OpLabel OpSelectionMerge %8 None OpBranchConditional %5 %9 %8 %9 = OpLabel %10 = OpFunctionCall %3 %11 OpBranch %8 %8 = OpLabel OpSelectionMerge %12 None OpBranchConditional %5 %13 %12 %13 = OpLabel %14 = OpFunctionCall %3 %11 OpBranch %12 %12 = OpLabel OpReturn %16 = OpLabel OpSelectionMerge %17 None OpBranchConditional %5 %18 %17 %18 = OpLabel OpBranch %17 %17 = OpLabel OpReturn OpFunctionEnd %11 = OpFunction %3 None %6 %19 = OpLabel OpBranch %20 %20 = OpLabel OpSelectionMerge %25 None OpBranchConditional %5 %21 %22 %21 = OpLabel OpBranch %22 %22 = OpLabel OpSelectionMerge %24 None OpBranchConditional %5 %24 %23 %23 = OpLabel OpBranch %24 %24 = OpLabel OpBranch %25 %25 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); #ifndef NDEBUG // The selection construct headed by %7 requires fresh ids because it contains // a function call. This causes an assertion failure because transformation // context does not have a source of overflow ids. ASSERT_DEATH(TransformationFlattenConditionalBranch(7, true, 0, 0, 0, {}) .IsApplicable(context.get(), transformation_context), "Bad attempt to query whether overflow ids are available."); #endif auto transformation1 = TransformationFlattenConditionalBranch( 7, true, 0, 0, 0, {{MakeSideEffectWrapperInfo( MakeInstructionDescriptor(10, spv::Op::OpFunctionCall, 0), 100, 101)}}); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); // The selection construct headed by %8 cannot be flattened because it // contains a function call returning void, whose result id is used. ASSERT_FALSE( TransformationFlattenConditionalBranch( 7, true, 0, 0, 0, {{MakeSideEffectWrapperInfo( MakeInstructionDescriptor(14, spv::Op::OpFunctionCall, 0), 102, 103)}}) .IsApplicable(context.get(), transformation_context)); // Block %16 is unreachable. ASSERT_FALSE(TransformationFlattenConditionalBranch(16, true, 0, 0, 0, {}) .IsApplicable(context.get(), transformation_context)); auto transformation2 = TransformationFlattenConditionalBranch(20, false, 0, 0, 0, {}); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeBool %5 = OpConstantTrue %4 %6 = OpTypeFunction %3 %2 = OpFunction %3 None %6 %7 = OpLabel OpBranch %9 %9 = OpLabel OpSelectionMerge %100 None OpBranchConditional %5 %101 %100 %101 = OpLabel %10 = OpFunctionCall %3 %11 OpBranch %100 %100 = OpLabel OpBranch %8 %8 = OpLabel OpSelectionMerge %12 None OpBranchConditional %5 %13 %12 %13 = OpLabel %14 = OpFunctionCall %3 %11 OpBranch %12 %12 = OpLabel OpReturn %16 = OpLabel OpSelectionMerge %17 None OpBranchConditional %5 %18 %17 %18 = OpLabel OpBranch %17 %17 = OpLabel OpReturn OpFunctionEnd %11 = OpFunction %3 None %6 %19 = OpLabel OpBranch %20 %20 = OpLabel OpBranch %21 %21 = OpLabel OpBranch %22 %22 = OpLabel OpSelectionMerge %24 None OpBranchConditional %5 %24 %23 %23 = OpLabel OpBranch %24 %24 = OpLabel OpBranch %25 %25 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationFlattenConditionalBranchTest, PhiToSelect1) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeBool %5 = OpConstantTrue %4 %10 = OpConstantFalse %4 %6 = OpTypeFunction %3 %2 = OpFunction %3 None %6 %7 = OpLabel OpSelectionMerge %8 None OpBranchConditional %5 %9 %8 %9 = OpLabel OpBranch %8 %8 = OpLabel %11 = OpPhi %4 %5 %9 %10 %7 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto transformation = TransformationFlattenConditionalBranch(7, true, 0, 0, 0, {}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeBool %5 = OpConstantTrue %4 %10 = OpConstantFalse %4 %6 = OpTypeFunction %3 %2 = OpFunction %3 None %6 %7 = OpLabel OpBranch %9 %9 = OpLabel OpBranch %8 %8 = OpLabel %11 = OpSelect %4 %5 %5 %10 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationFlattenConditionalBranchTest, PhiToSelect2) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeBool %5 = OpConstantTrue %4 %10 = OpConstantFalse %4 %6 = OpTypeFunction %3 %2 = OpFunction %3 None %6 %7 = OpLabel OpSelectionMerge %8 None OpBranchConditional %5 %9 %8 %9 = OpLabel OpBranch %8 %8 = OpLabel %11 = OpPhi %4 %10 %7 %5 %9 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto transformation = TransformationFlattenConditionalBranch(7, true, 0, 0, 0, {}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeBool %5 = OpConstantTrue %4 %10 = OpConstantFalse %4 %6 = OpTypeFunction %3 %2 = OpFunction %3 None %6 %7 = OpLabel OpBranch %9 %9 = OpLabel OpBranch %8 %8 = OpLabel %11 = OpSelect %4 %5 %5 %10 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationFlattenConditionalBranchTest, PhiToSelect3) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeBool %5 = OpConstantTrue %4 %10 = OpConstantFalse %4 %6 = OpTypeFunction %3 %2 = OpFunction %3 None %6 %7 = OpLabel OpSelectionMerge %8 None OpBranchConditional %5 %9 %12 %9 = OpLabel OpBranch %8 %12 = OpLabel OpBranch %8 %8 = OpLabel %11 = OpPhi %4 %10 %12 %5 %9 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto transformation = TransformationFlattenConditionalBranch(7, true, 0, 0, 0, {}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeBool %5 = OpConstantTrue %4 %10 = OpConstantFalse %4 %6 = OpTypeFunction %3 %2 = OpFunction %3 None %6 %7 = OpLabel OpBranch %9 %9 = OpLabel OpBranch %12 %12 = OpLabel OpBranch %8 %8 = OpLabel %11 = OpSelect %4 %5 %5 %10 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationFlattenConditionalBranchTest, PhiToSelect4) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeBool %5 = OpConstantTrue %4 %10 = OpConstantFalse %4 %6 = OpTypeFunction %3 %2 = OpFunction %3 None %6 %7 = OpLabel OpSelectionMerge %8 None OpBranchConditional %5 %9 %12 %9 = OpLabel OpBranch %8 %12 = OpLabel OpBranch %8 %8 = OpLabel %11 = OpPhi %4 %5 %9 %10 %12 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto transformation = TransformationFlattenConditionalBranch(7, true, 0, 0, 0, {}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeBool %5 = OpConstantTrue %4 %10 = OpConstantFalse %4 %6 = OpTypeFunction %3 %2 = OpFunction %3 None %6 %7 = OpLabel OpBranch %9 %9 = OpLabel OpBranch %12 %12 = OpLabel OpBranch %8 %8 = OpLabel %11 = OpSelect %4 %5 %5 %10 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationFlattenConditionalBranchTest, PhiToSelect5) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeBool %5 = OpConstantTrue %4 %10 = OpConstantFalse %4 %6 = OpTypeFunction %3 %100 = OpTypePointer Function %4 %2 = OpFunction %3 None %6 %7 = OpLabel %101 = OpVariable %100 Function %102 = OpVariable %100 Function OpSelectionMerge %470 None OpBranchConditional %5 %454 %462 %454 = OpLabel %522 = OpLoad %4 %101 OpBranch %470 %462 = OpLabel %466 = OpLoad %4 %102 OpBranch %470 %470 = OpLabel %534 = OpPhi %4 %522 %454 %466 %462 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto transformation = TransformationFlattenConditionalBranch( 7, true, 0, 0, 0, {MakeSideEffectWrapperInfo( MakeInstructionDescriptor(522, spv::Op::OpLoad, 0), 200, 201, 202, 203, 204, 5), MakeSideEffectWrapperInfo( MakeInstructionDescriptor(466, spv::Op::OpLoad, 0), 300, 301, 302, 303, 304, 5)}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeBool %5 = OpConstantTrue %4 %10 = OpConstantFalse %4 %6 = OpTypeFunction %3 %100 = OpTypePointer Function %4 %2 = OpFunction %3 None %6 %7 = OpLabel %101 = OpVariable %100 Function %102 = OpVariable %100 Function OpBranch %454 %454 = OpLabel OpSelectionMerge %200 None OpBranchConditional %5 %201 %203 %201 = OpLabel %202 = OpLoad %4 %101 OpBranch %200 %203 = OpLabel %204 = OpCopyObject %4 %5 OpBranch %200 %200 = OpLabel %522 = OpPhi %4 %202 %201 %204 %203 OpBranch %462 %462 = OpLabel OpSelectionMerge %300 None OpBranchConditional %5 %303 %301 %301 = OpLabel %302 = OpLoad %4 %102 OpBranch %300 %303 = OpLabel %304 = OpCopyObject %4 %5 OpBranch %300 %300 = OpLabel %466 = OpPhi %4 %302 %301 %304 %303 OpBranch %470 %470 = OpLabel %534 = OpSelect %4 %5 %522 %466 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationFlattenConditionalBranchTest, LoadFromBufferBlockDecoratedStruct) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpMemberDecorate %11 0 Offset 0 OpDecorate %11 BufferBlock OpDecorate %13 DescriptorSet 0 OpDecorate %13 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantTrue %6 %10 = OpTypeInt 32 1 %11 = OpTypeStruct %10 %12 = OpTypePointer Uniform %11 %13 = OpVariable %12 Uniform %21 = OpUndef %11 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %9 None OpBranchConditional %7 %8 %9 %8 = OpLabel %20 = OpLoad %11 %13 OpBranch %9 %9 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto transformation = TransformationFlattenConditionalBranch( 5, true, 0, 0, 0, {MakeSideEffectWrapperInfo( MakeInstructionDescriptor(20, spv::Op::OpLoad, 0), 100, 101, 102, 103, 104, 21)}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); } TEST(TransformationFlattenConditionalBranchTest, InapplicableSampledImageLoad) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %12 %96 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpDecorate %12 BuiltIn FragCoord OpDecorate %91 DescriptorSet 0 OpDecorate %91 Binding 0 OpDecorate %96 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 2 %10 = OpTypeVector %6 4 %11 = OpTypePointer Input %10 %12 = OpVariable %11 Input %21 = OpConstant %6 2 %24 = OpTypeInt 32 1 %33 = OpTypeBool %35 = OpConstantTrue %33 %88 = OpTypeImage %6 2D 0 0 0 1 Unknown %89 = OpTypeSampledImage %88 %90 = OpTypePointer UniformConstant %89 %91 = OpVariable %90 UniformConstant %95 = OpTypePointer Output %10 %96 = OpVariable %95 Output %200 = OpUndef %89 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %28 %28 = OpLabel OpSelectionMerge %38 None OpBranchConditional %35 %32 %37 %32 = OpLabel %40 = OpLoad %89 %91 OpBranch %38 %37 = OpLabel OpBranch %38 %38 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_FALSE(TransformationFlattenConditionalBranch( 28, true, 0, 0, 0, {MakeSideEffectWrapperInfo( MakeInstructionDescriptor(40, spv::Op::OpLoad, 0), 100, 101, 102, 103, 104, 200)}) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationFlattenConditionalBranchTest, InapplicablePhiToSelectVector) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantTrue %6 %10 = OpTypeInt 32 1 %11 = OpTypeVector %10 3 %12 = OpUndef %11 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %20 None OpBranchConditional %7 %8 %9 %8 = OpLabel OpBranch %20 %9 = OpLabel OpBranch %20 %20 = OpLabel %21 = OpPhi %11 %12 %8 %12 %9 OpReturn OpFunctionEnd )"; for (auto env : {SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1, SPV_ENV_UNIVERSAL_1_2, SPV_ENV_UNIVERSAL_1_3, SPV_ENV_VULKAN_1_0, SPV_ENV_VULKAN_1_1}) { const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto transformation = TransformationFlattenConditionalBranch(5, true, 0, 0, 0, {}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); } } TEST(TransformationFlattenConditionalBranchTest, InapplicablePhiToSelectVector2) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %30 = OpTypeVector %6 3 %31 = OpTypeVector %6 2 %7 = OpConstantTrue %6 %10 = OpTypeInt 32 1 %11 = OpTypeVector %10 3 %40 = OpTypeFloat 32 %41 = OpTypeVector %40 4 %12 = OpUndef %11 %60 = OpUndef %41 %61 = OpConstantComposite %31 %7 %7 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %20 None OpBranchConditional %7 %8 %9 %8 = OpLabel OpBranch %20 %9 = OpLabel OpBranch %20 %20 = OpLabel %21 = OpPhi %11 %12 %8 %12 %9 %22 = OpPhi %11 %12 %8 %12 %9 %23 = OpPhi %41 %60 %8 %60 %9 %24 = OpPhi %31 %61 %8 %61 %9 %25 = OpPhi %41 %60 %8 %60 %9 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto transformation = TransformationFlattenConditionalBranch(5, true, 101, 102, 103, {}); // bvec4 is not present in the module. ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } TEST(TransformationFlattenConditionalBranchTest, InapplicablePhiToSelectMatrix) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantTrue %6 %10 = OpTypeFloat 32 %30 = OpTypeVector %10 3 %11 = OpTypeMatrix %30 3 %12 = OpUndef %11 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %20 None OpBranchConditional %7 %8 %9 %8 = OpLabel OpBranch %20 %9 = OpLabel OpBranch %20 %20 = OpLabel %21 = OpPhi %11 %12 %8 %12 %9 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto transformation = TransformationFlattenConditionalBranch(5, true, 0, 0, 0, {}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationFlattenConditionalBranchTest, ApplicablePhiToSelectVector) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantTrue %6 %10 = OpTypeInt 32 1 %11 = OpTypeVector %10 3 %12 = OpUndef %11 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %20 None OpBranchConditional %7 %8 %9 %8 = OpLabel OpBranch %20 %9 = OpLabel OpBranch %20 %20 = OpLabel %21 = OpPhi %11 %12 %8 %12 %9 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto transformation = TransformationFlattenConditionalBranch(5, true, 0, 0, 0, {}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string expected_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantTrue %6 %10 = OpTypeInt 32 1 %11 = OpTypeVector %10 3 %12 = OpUndef %11 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %8 %8 = OpLabel OpBranch %9 %9 = OpLabel OpBranch %20 %20 = OpLabel %21 = OpSelect %11 %7 %12 %12 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected_shader, context.get())); } TEST(TransformationFlattenConditionalBranchTest, ApplicablePhiToSelectVector2) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %30 = OpTypeVector %6 3 %31 = OpTypeVector %6 2 %32 = OpTypeVector %6 4 %7 = OpConstantTrue %6 %10 = OpTypeInt 32 1 %11 = OpTypeVector %10 3 %40 = OpTypeFloat 32 %41 = OpTypeVector %40 4 %12 = OpUndef %11 %60 = OpUndef %41 %61 = OpConstantComposite %31 %7 %7 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %20 None OpBranchConditional %7 %8 %9 %8 = OpLabel OpBranch %20 %9 = OpLabel OpBranch %20 %20 = OpLabel %21 = OpPhi %11 %12 %8 %12 %9 %22 = OpPhi %11 %12 %8 %12 %9 %23 = OpPhi %41 %60 %8 %60 %9 %24 = OpPhi %31 %61 %8 %61 %9 %25 = OpPhi %41 %60 %8 %60 %9 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // No id for the 2D vector case is provided. ASSERT_FALSE(TransformationFlattenConditionalBranch(5, true, 0, 102, 103, {}) .IsApplicable(context.get(), transformation_context)); // No id for the 3D vector case is provided. ASSERT_FALSE(TransformationFlattenConditionalBranch(5, true, 101, 0, 103, {}) .IsApplicable(context.get(), transformation_context)); // No id for the 4D vector case is provided. ASSERT_FALSE(TransformationFlattenConditionalBranch(5, true, 101, 102, 0, {}) .IsApplicable(context.get(), transformation_context)); // %10 is not fresh ASSERT_FALSE(TransformationFlattenConditionalBranch(5, true, 10, 102, 103, {}) .IsApplicable(context.get(), transformation_context)); // %10 is not fresh ASSERT_FALSE(TransformationFlattenConditionalBranch(5, true, 101, 10, 103, {}) .IsApplicable(context.get(), transformation_context)); // %10 is not fresh ASSERT_FALSE(TransformationFlattenConditionalBranch(5, true, 101, 102, 10, {}) .IsApplicable(context.get(), transformation_context)); // Duplicate "fresh" ids used for boolean vector constructors ASSERT_FALSE( TransformationFlattenConditionalBranch(5, true, 101, 102, 102, {}) .IsApplicable(context.get(), transformation_context)); auto transformation = TransformationFlattenConditionalBranch(5, true, 101, 102, 103, {}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string expected_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %30 = OpTypeVector %6 3 %31 = OpTypeVector %6 2 %32 = OpTypeVector %6 4 %7 = OpConstantTrue %6 %10 = OpTypeInt 32 1 %11 = OpTypeVector %10 3 %40 = OpTypeFloat 32 %41 = OpTypeVector %40 4 %12 = OpUndef %11 %60 = OpUndef %41 %61 = OpConstantComposite %31 %7 %7 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %8 %8 = OpLabel OpBranch %9 %9 = OpLabel OpBranch %20 %20 = OpLabel %103 = OpCompositeConstruct %32 %7 %7 %7 %7 %102 = OpCompositeConstruct %30 %7 %7 %7 %101 = OpCompositeConstruct %31 %7 %7 %21 = OpSelect %11 %102 %12 %12 %22 = OpSelect %11 %102 %12 %12 %23 = OpSelect %41 %103 %60 %60 %24 = OpSelect %31 %101 %61 %61 %25 = OpSelect %41 %103 %60 %60 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected_shader, context.get())); } TEST(TransformationFlattenConditionalBranchTest, ApplicablePhiToSelectVector3) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %30 = OpTypeVector %6 3 %31 = OpTypeVector %6 2 %32 = OpTypeVector %6 4 %7 = OpConstantTrue %6 %10 = OpTypeInt 32 1 %11 = OpTypeVector %10 3 %40 = OpTypeFloat 32 %41 = OpTypeVector %40 4 %12 = OpUndef %11 %60 = OpUndef %41 %61 = OpConstantComposite %31 %7 %7 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %20 None OpBranchConditional %7 %8 %9 %8 = OpLabel OpBranch %20 %9 = OpLabel OpBranch %20 %20 = OpLabel %21 = OpPhi %11 %12 %8 %12 %9 %22 = OpPhi %11 %12 %8 %12 %9 %23 = OpPhi %41 %60 %8 %60 %9 %24 = OpPhi %31 %61 %8 %61 %9 %25 = OpPhi %41 %60 %8 %60 %9 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto transformation = TransformationFlattenConditionalBranch(5, true, 101, 0, 103, {}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Check that the in operands of any OpSelect instructions all have the // appropriate operand type. context->module()->ForEachInst([](opt::Instruction* inst) { if (inst->opcode() == spv::Op::OpSelect) { ASSERT_EQ(SPV_OPERAND_TYPE_ID, inst->GetInOperand(0).type); ASSERT_EQ(SPV_OPERAND_TYPE_ID, inst->GetInOperand(1).type); ASSERT_EQ(SPV_OPERAND_TYPE_ID, inst->GetInOperand(2).type); } }); std::string expected_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %30 = OpTypeVector %6 3 %31 = OpTypeVector %6 2 %32 = OpTypeVector %6 4 %7 = OpConstantTrue %6 %10 = OpTypeInt 32 1 %11 = OpTypeVector %10 3 %40 = OpTypeFloat 32 %41 = OpTypeVector %40 4 %12 = OpUndef %11 %60 = OpUndef %41 %61 = OpConstantComposite %31 %7 %7 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %8 %8 = OpLabel OpBranch %9 %9 = OpLabel OpBranch %20 %20 = OpLabel %103 = OpCompositeConstruct %32 %7 %7 %7 %7 %101 = OpCompositeConstruct %31 %7 %7 %21 = OpSelect %11 %7 %12 %12 %22 = OpSelect %11 %7 %12 %12 %23 = OpSelect %41 %103 %60 %60 %24 = OpSelect %31 %101 %61 %61 %25 = OpSelect %41 %103 %60 %60 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected_shader, context.get())); } TEST(TransformationFlattenConditionalBranchTest, ApplicablePhiToSelectMatrix) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantTrue %6 %10 = OpTypeFloat 32 %30 = OpTypeVector %10 3 %11 = OpTypeMatrix %30 3 %12 = OpUndef %11 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %20 None OpBranchConditional %7 %8 %9 %8 = OpLabel OpBranch %20 %9 = OpLabel OpBranch %20 %20 = OpLabel %21 = OpPhi %11 %12 %8 %12 %9 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto transformation = TransformationFlattenConditionalBranch(5, true, 0, 0, 0, {}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string expected_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantTrue %6 %10 = OpTypeFloat 32 %30 = OpTypeVector %10 3 %11 = OpTypeMatrix %30 3 %12 = OpUndef %11 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %8 %8 = OpLabel OpBranch %9 %9 = OpLabel OpBranch %20 %20 = OpLabel %21 = OpSelect %11 %7 %12 %12 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected_shader, context.get())); } TEST(TransformationFlattenConditionalBranchTest, InapplicableConditionIsIrrelevant) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantTrue %6 %10 = OpTypeInt 32 1 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %9 None OpBranchConditional %7 %8 %9 %8 = OpLabel OpBranch %9 %9 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactIdIsIrrelevant(7); // Inapplicable because the branch condition, %7, is irrelevant. ASSERT_FALSE(TransformationFlattenConditionalBranch(5, true, 0, 0, 0, {}) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationFlattenConditionalBranchTest, OpPhiWhenTrueBranchIsConvergenceBlock) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantTrue %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %9 None OpBranchConditional %7 %9 %8 %8 = OpLabel %10 = OpCopyObject %6 %7 OpBranch %9 %9 = OpLabel %11 = OpPhi %6 %10 %8 %7 %5 %12 = OpPhi %6 %7 %5 %10 %8 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationFlattenConditionalBranch transformation(5, true, 0, 0, 0, {}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string expected = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantTrue %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %8 %8 = OpLabel %10 = OpCopyObject %6 %7 OpBranch %9 %9 = OpLabel %11 = OpSelect %6 %7 %7 %10 %12 = OpSelect %6 %7 %7 %10 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected, context.get())); } TEST(TransformationFlattenConditionalBranchTest, OpPhiWhenFalseBranchIsConvergenceBlock) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantTrue %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %9 None OpBranchConditional %7 %8 %9 %8 = OpLabel %10 = OpCopyObject %6 %7 OpBranch %9 %9 = OpLabel %11 = OpPhi %6 %10 %8 %7 %5 %12 = OpPhi %6 %7 %5 %10 %8 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationFlattenConditionalBranch transformation(5, true, 0, 0, 0, {}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string expected = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantTrue %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %8 %8 = OpLabel %10 = OpCopyObject %6 %7 OpBranch %9 %9 = OpLabel %11 = OpSelect %6 %7 %10 %7 %12 = OpSelect %6 %7 %10 %7 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected, context.get())); } TEST(TransformationFlattenConditionalBranchTest, ContainsDeadBlocksTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantFalse %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %9 None OpBranchConditional %7 %8 %9 %8 = OpLabel %10 = OpCopyObject %6 %7 OpBranch %9 %9 = OpLabel %11 = OpPhi %6 %10 %8 %7 %5 %12 = OpPhi %6 %7 %5 %10 %8 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationFlattenConditionalBranch transformation(5, true, 0, 0, 0, {}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); transformation_context.GetFactManager()->AddFactBlockIsDead(8); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationFlattenConditionalBranchTest, ContainsContinueBlockTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantFalse %6 %4 = OpFunction %2 None %3 %12 = OpLabel OpBranch %13 %13 = OpLabel OpLoopMerge %15 %14 None OpBranchConditional %7 %5 %15 %5 = OpLabel OpSelectionMerge %11 None OpBranchConditional %7 %9 %10 %9 = OpLabel OpBranch %11 %10 = OpLabel OpBranch %14 %11 = OpLabel OpBranch %14 %14 = OpLabel OpBranch %13 %15 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_FALSE(TransformationFlattenConditionalBranch(5, true, 0, 0, 0, {}) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationFlattenConditionalBranchTest, ContainsSynonymCreation) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantFalse %6 %8 = OpTypeInt 32 0 %9 = OpTypePointer Function %8 %10 = OpConstant %8 42 %80 = OpConstant %8 0 %4 = OpFunction %2 None %3 %11 = OpLabel %20 = OpVariable %9 Function OpBranch %12 %12 = OpLabel OpSelectionMerge %31 None OpBranchConditional %7 %30 %31 %30 = OpLabel OpStore %20 %10 %21 = OpLoad %8 %20 OpBranch %31 %31 = OpLabel OpBranch %14 %14 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(10, {}), MakeDataDescriptor(21, {})); ASSERT_FALSE( TransformationFlattenConditionalBranch( 12, true, 0, 0, 0, {MakeSideEffectWrapperInfo( MakeInstructionDescriptor(30, spv::Op::OpStore, 0), 100, 101), MakeSideEffectWrapperInfo( MakeInstructionDescriptor(21, spv::Op::OpLoad, 0), 102, 103, 104, 105, 106, 80)}) .IsApplicable(context.get(), transformation_context)); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_function_call_test.cpp000066400000000000000000000453461475742701700302330ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_function_call.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationFunctionCallTest, BasicTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %6 %7 %12 = OpTypeFloat 32 %13 = OpTypePointer Function %12 %14 = OpTypeFunction %6 %7 %13 %27 = OpConstant %6 1 %50 = OpConstant %12 1 %57 = OpTypeBool %58 = OpConstantFalse %57 %204 = OpUndef %6 %4 = OpFunction %2 None %3 %5 = OpLabel %61 = OpVariable %7 Function %62 = OpVariable %7 Function %65 = OpVariable %13 Function %66 = OpVariable %7 Function %68 = OpVariable %13 Function %71 = OpVariable %7 Function %72 = OpVariable %13 Function %73 = OpVariable %7 Function %75 = OpVariable %13 Function %78 = OpVariable %7 Function %98 = OpAccessChain %7 %71 %99 = OpCopyObject %7 %71 OpSelectionMerge %60 None OpBranchConditional %58 %59 %60 %59 = OpLabel OpBranch %60 %60 = OpLabel OpReturn OpFunctionEnd %10 = OpFunction %6 None %8 %9 = OpFunctionParameter %7 %11 = OpLabel %26 = OpLoad %6 %9 %28 = OpIAdd %6 %26 %27 OpSelectionMerge %97 None OpBranchConditional %58 %96 %97 %96 = OpLabel OpBranch %97 %97 = OpLabel OpReturnValue %28 OpFunctionEnd %17 = OpFunction %6 None %14 %15 = OpFunctionParameter %7 %16 = OpFunctionParameter %13 %18 = OpLabel %31 = OpVariable %7 Function %32 = OpLoad %6 %15 OpStore %31 %32 %33 = OpFunctionCall %6 %10 %31 OpReturnValue %33 OpFunctionEnd %21 = OpFunction %6 None %14 %19 = OpFunctionParameter %7 %20 = OpFunctionParameter %13 %22 = OpLabel %36 = OpLoad %6 %19 %37 = OpLoad %12 %20 %38 = OpConvertFToS %6 %37 %39 = OpIAdd %6 %36 %38 OpReturnValue %39 OpFunctionEnd %24 = OpFunction %6 None %8 %23 = OpFunctionParameter %7 %25 = OpLabel %44 = OpVariable %7 Function %46 = OpVariable %13 Function %51 = OpVariable %7 Function %52 = OpVariable %13 Function %42 = OpLoad %6 %23 %43 = OpConvertSToF %12 %42 %45 = OpLoad %6 %23 OpStore %44 %45 OpStore %46 %43 %47 = OpFunctionCall %6 %17 %44 %46 %48 = OpLoad %6 %23 %49 = OpIAdd %6 %48 %27 OpStore %51 %49 OpStore %52 %50 %53 = OpFunctionCall %6 %17 %51 %52 %54 = OpIAdd %6 %47 %53 OpReturnValue %54 OpFunctionEnd %200 = OpFunction %6 None %14 %201 = OpFunctionParameter %7 %202 = OpFunctionParameter %13 %203 = OpLabel OpSelectionMerge %206 None OpBranchConditional %58 %205 %206 %205 = OpLabel OpBranch %206 %206 = OpLabel OpReturnValue %204 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactBlockIsDead(59); transformation_context.GetFactManager()->AddFactBlockIsDead(11); transformation_context.GetFactManager()->AddFactBlockIsDead(18); transformation_context.GetFactManager()->AddFactBlockIsDead(25); transformation_context.GetFactManager()->AddFactBlockIsDead(96); transformation_context.GetFactManager()->AddFactBlockIsDead(205); transformation_context.GetFactManager()->AddFactFunctionIsLivesafe(21); transformation_context.GetFactManager()->AddFactFunctionIsLivesafe(200); transformation_context.GetFactManager()->AddFactValueOfPointeeIsIrrelevant( 71); transformation_context.GetFactManager()->AddFactValueOfPointeeIsIrrelevant( 72); transformation_context.GetFactManager()->AddFactValueOfPointeeIsIrrelevant( 19); transformation_context.GetFactManager()->AddFactValueOfPointeeIsIrrelevant( 20); transformation_context.GetFactManager()->AddFactValueOfPointeeIsIrrelevant( 23); transformation_context.GetFactManager()->AddFactValueOfPointeeIsIrrelevant( 44); transformation_context.GetFactManager()->AddFactValueOfPointeeIsIrrelevant( 46); transformation_context.GetFactManager()->AddFactValueOfPointeeIsIrrelevant( 51); transformation_context.GetFactManager()->AddFactValueOfPointeeIsIrrelevant( 52); // Livesafe functions with argument types: 21(7, 13), 200(7, 13) // Non-livesafe functions with argument types: 4(), 10(7), 17(7, 13), 24(7) // Call graph edges: // 17 -> 10 // 24 -> 17 // Bad transformations // Too many arguments ASSERT_FALSE(TransformationFunctionCall( 100, 21, {71, 72, 71}, MakeInstructionDescriptor(59, spv::Op::OpBranch, 0)) .IsApplicable(context.get(), transformation_context)); // Too few arguments ASSERT_FALSE( TransformationFunctionCall( 100, 21, {71}, MakeInstructionDescriptor(59, spv::Op::OpBranch, 0)) .IsApplicable(context.get(), transformation_context)); // Arguments are the wrong way around (types do not match) ASSERT_FALSE(TransformationFunctionCall( 100, 21, {72, 71}, MakeInstructionDescriptor(59, spv::Op::OpBranch, 0)) .IsApplicable(context.get(), transformation_context)); // 21 is not an appropriate argument ASSERT_FALSE(TransformationFunctionCall( 100, 21, {21, 72}, MakeInstructionDescriptor(59, spv::Op::OpBranch, 0)) .IsApplicable(context.get(), transformation_context)); // 300 does not exist ASSERT_FALSE(TransformationFunctionCall( 100, 21, {300, 72}, MakeInstructionDescriptor(59, spv::Op::OpBranch, 0)) .IsApplicable(context.get(), transformation_context)); // 71 is not a function ASSERT_FALSE(TransformationFunctionCall( 100, 71, {71, 72}, MakeInstructionDescriptor(59, spv::Op::OpBranch, 0)) .IsApplicable(context.get(), transformation_context)); // 500 does not exist ASSERT_FALSE(TransformationFunctionCall( 100, 500, {71, 72}, MakeInstructionDescriptor(59, spv::Op::OpBranch, 0)) .IsApplicable(context.get(), transformation_context)); // Id is not fresh ASSERT_FALSE( TransformationFunctionCall( 21, 21, {71, 72}, MakeInstructionDescriptor(59, spv::Op::OpBranch, 0)) .IsApplicable(context.get(), transformation_context)); // Access chain as pointer parameter ASSERT_FALSE(TransformationFunctionCall( 100, 21, {98, 72}, MakeInstructionDescriptor(59, spv::Op::OpBranch, 0)) .IsApplicable(context.get(), transformation_context)); // Copied object as pointer parameter ASSERT_FALSE(TransformationFunctionCall( 100, 21, {99, 72}, MakeInstructionDescriptor(59, spv::Op::OpBranch, 0)) .IsApplicable(context.get(), transformation_context)); // Non-livesafe called from original live block ASSERT_FALSE(TransformationFunctionCall( 100, 10, {71}, MakeInstructionDescriptor(99, spv::Op::OpSelectionMerge, 0)) .IsApplicable(context.get(), transformation_context)); // Non-livesafe called from livesafe function ASSERT_FALSE(TransformationFunctionCall( 100, 10, {19}, MakeInstructionDescriptor(38, spv::Op::OpConvertFToS, 0)) .IsApplicable(context.get(), transformation_context)); // Livesafe function called with pointer to non-arbitrary local variable ASSERT_FALSE(TransformationFunctionCall( 100, 21, {61, 72}, MakeInstructionDescriptor(38, spv::Op::OpConvertFToS, 0)) .IsApplicable(context.get(), transformation_context)); // Direct recursion ASSERT_FALSE( TransformationFunctionCall( 100, 4, {}, MakeInstructionDescriptor(59, spv::Op::OpBranch, 0)) .IsApplicable(context.get(), transformation_context)); // Indirect recursion ASSERT_FALSE( TransformationFunctionCall( 100, 24, {9}, MakeInstructionDescriptor(96, spv::Op::OpBranch, 0)) .IsApplicable(context.get(), transformation_context)); // Parameter 23 is not available at the call site ASSERT_FALSE( TransformationFunctionCall( 104, 10, {23}, MakeInstructionDescriptor(205, spv::Op::OpBranch, 0)) .IsApplicable(context.get(), transformation_context)); // Good transformations { // Livesafe called from dead block: fine TransformationFunctionCall transformation( 100, 21, {71, 72}, MakeInstructionDescriptor(59, spv::Op::OpBranch, 0)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } { // Livesafe called from original live block: fine TransformationFunctionCall transformation( 101, 21, {71, 72}, MakeInstructionDescriptor(98, spv::Op::OpAccessChain, 0)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } { // Livesafe called from livesafe function: fine TransformationFunctionCall transformation( 102, 200, {19, 20}, MakeInstructionDescriptor(36, spv::Op::OpLoad, 0)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } { // Dead called from dead block in injected function: fine TransformationFunctionCall transformation( 103, 10, {23}, MakeInstructionDescriptor(45, spv::Op::OpLoad, 0)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } { // Non-livesafe called from dead block in livesafe function: OK TransformationFunctionCall transformation( 104, 10, {201}, MakeInstructionDescriptor(205, spv::Op::OpBranch, 0)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } { // Livesafe called from dead block with non-arbitrary parameter TransformationFunctionCall transformation( 105, 21, {62, 65}, MakeInstructionDescriptor(59, spv::Op::OpBranch, 0)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %6 %7 %12 = OpTypeFloat 32 %13 = OpTypePointer Function %12 %14 = OpTypeFunction %6 %7 %13 %27 = OpConstant %6 1 %50 = OpConstant %12 1 %57 = OpTypeBool %58 = OpConstantFalse %57 %204 = OpUndef %6 %4 = OpFunction %2 None %3 %5 = OpLabel %61 = OpVariable %7 Function %62 = OpVariable %7 Function %65 = OpVariable %13 Function %66 = OpVariable %7 Function %68 = OpVariable %13 Function %71 = OpVariable %7 Function %72 = OpVariable %13 Function %73 = OpVariable %7 Function %75 = OpVariable %13 Function %78 = OpVariable %7 Function %101 = OpFunctionCall %6 %21 %71 %72 %98 = OpAccessChain %7 %71 %99 = OpCopyObject %7 %71 OpSelectionMerge %60 None OpBranchConditional %58 %59 %60 %59 = OpLabel %100 = OpFunctionCall %6 %21 %71 %72 %105 = OpFunctionCall %6 %21 %62 %65 OpBranch %60 %60 = OpLabel OpReturn OpFunctionEnd %10 = OpFunction %6 None %8 %9 = OpFunctionParameter %7 %11 = OpLabel %26 = OpLoad %6 %9 %28 = OpIAdd %6 %26 %27 OpSelectionMerge %97 None OpBranchConditional %58 %96 %97 %96 = OpLabel OpBranch %97 %97 = OpLabel OpReturnValue %28 OpFunctionEnd %17 = OpFunction %6 None %14 %15 = OpFunctionParameter %7 %16 = OpFunctionParameter %13 %18 = OpLabel %31 = OpVariable %7 Function %32 = OpLoad %6 %15 OpStore %31 %32 %33 = OpFunctionCall %6 %10 %31 OpReturnValue %33 OpFunctionEnd %21 = OpFunction %6 None %14 %19 = OpFunctionParameter %7 %20 = OpFunctionParameter %13 %22 = OpLabel %102 = OpFunctionCall %6 %200 %19 %20 %36 = OpLoad %6 %19 %37 = OpLoad %12 %20 %38 = OpConvertFToS %6 %37 %39 = OpIAdd %6 %36 %38 OpReturnValue %39 OpFunctionEnd %24 = OpFunction %6 None %8 %23 = OpFunctionParameter %7 %25 = OpLabel %44 = OpVariable %7 Function %46 = OpVariable %13 Function %51 = OpVariable %7 Function %52 = OpVariable %13 Function %42 = OpLoad %6 %23 %43 = OpConvertSToF %12 %42 %103 = OpFunctionCall %6 %10 %23 %45 = OpLoad %6 %23 OpStore %44 %45 OpStore %46 %43 %47 = OpFunctionCall %6 %17 %44 %46 %48 = OpLoad %6 %23 %49 = OpIAdd %6 %48 %27 OpStore %51 %49 OpStore %52 %50 %53 = OpFunctionCall %6 %17 %51 %52 %54 = OpIAdd %6 %47 %53 OpReturnValue %54 OpFunctionEnd %200 = OpFunction %6 None %14 %201 = OpFunctionParameter %7 %202 = OpFunctionParameter %13 %203 = OpLabel OpSelectionMerge %206 None OpBranchConditional %58 %205 %206 %205 = OpLabel %104 = OpFunctionCall %6 %10 %201 OpBranch %206 %206 = OpLabel OpReturnValue %204 OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationFunctionCallTest, DoNotInvokeEntryPoint) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %10 = OpFunction %2 None %3 %11 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactBlockIsDead(11); // 4 is an entry point, so it is not legal for it to be the target of a call. ASSERT_FALSE( TransformationFunctionCall( 100, 4, {}, MakeInstructionDescriptor(11, spv::Op::OpReturn, 0)) .IsApplicable(context.get(), transformation_context)); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_inline_function_test.cpp000066400000000000000000001155441475742701700305740ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_inline_function.h" #include "gtest/gtest.h" #include "source/fuzz/counter_overflow_id_source.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationInlineFunctionTest, IsApplicable) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %52 "main" OpExecutionMode %52 OriginUpperLeft OpName %56 "function_with_void_return" ; Types %2 = OpTypeBool %3 = OpTypeFloat 32 %4 = OpTypeVector %3 4 %5 = OpTypePointer Function %4 %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeFunction %3 %5 %5 ; Constant scalars %9 = OpConstant %3 1 %10 = OpConstant %3 2 %11 = OpConstant %3 3 %12 = OpConstant %3 4 %13 = OpConstant %3 5 %14 = OpConstant %3 6 %15 = OpConstant %3 7 %16 = OpConstant %3 8 %17 = OpConstantTrue %2 ; Constant vectors %18 = OpConstantComposite %4 %9 %10 %11 %12 %19 = OpConstantComposite %4 %13 %14 %15 %16 ; function with void return %20 = OpFunction %6 None %7 %21 = OpLabel OpReturn OpFunctionEnd ; function with early return %22 = OpFunction %6 None %7 %23 = OpLabel OpSelectionMerge %26 None OpBranchConditional %17 %24 %25 %24 = OpLabel OpReturn %25 = OpLabel OpBranch %26 %26 = OpLabel OpReturn OpFunctionEnd ; function containing an OpKill instruction %27 = OpFunction %6 None %7 %28 = OpLabel OpKill OpFunctionEnd ; function containing an OpUnreachable instruction %29 = OpFunction %6 None %7 %30 = OpLabel OpUnreachable OpFunctionEnd ; dot product function %31 = OpFunction %3 None %8 %32 = OpFunctionParameter %5 %33 = OpFunctionParameter %5 %34 = OpLabel %35 = OpLoad %4 %32 %36 = OpLoad %4 %33 %37 = OpCompositeExtract %3 %35 0 %38 = OpCompositeExtract %3 %36 0 %39 = OpFMul %3 %37 %38 %40 = OpCompositeExtract %3 %35 1 %41 = OpCompositeExtract %3 %36 1 %42 = OpFMul %3 %40 %41 %43 = OpCompositeExtract %3 %35 2 %44 = OpCompositeExtract %3 %36 2 %45 = OpFMul %3 %43 %44 %46 = OpCompositeExtract %3 %35 3 %47 = OpCompositeExtract %3 %36 3 %48 = OpFMul %3 %46 %47 %49 = OpFAdd %3 %39 %42 %50 = OpFAdd %3 %45 %49 %51 = OpFAdd %3 %48 %50 OpReturnValue %51 OpFunctionEnd ; main function %52 = OpFunction %6 None %7 %53 = OpLabel %54 = OpVariable %5 Function %55 = OpVariable %5 Function %56 = OpFunctionCall %6 %20 ; function with void return OpBranch %57 %57 = OpLabel %59 = OpFunctionCall %6 %22 ; function with early return OpBranch %60 %60 = OpLabel %61 = OpFunctionCall %6 %27 ; function containing OpKill OpBranch %62 %62 = OpLabel %63 = OpFunctionCall %6 %29 ; function containing OpUnreachable OpBranch %64 %64 = OpLabel OpStore %54 %18 OpStore %55 %19 %65 = OpFunctionCall %3 %31 %54 %55 ; dot product function OpBranch %66 %66 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Tests undefined OpFunctionCall instruction. auto transformation = TransformationInlineFunction(67, {}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests false OpFunctionCall instruction. transformation = TransformationInlineFunction(42, {}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests use of called function with void return. transformation = TransformationInlineFunction(56, {}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests called function having an early return. transformation = TransformationInlineFunction(59, {{24, 67}, {25, 68}, {26, 69}}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests called function containing an OpKill instruction. transformation = TransformationInlineFunction(61, {}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests called function containing an OpUnreachable instruction. transformation = TransformationInlineFunction(63, {}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests applicable transformation. transformation = TransformationInlineFunction(65, {{35, 67}, {36, 68}, {37, 69}, {38, 70}, {39, 71}, {40, 72}, {41, 73}, {42, 74}, {43, 75}, {44, 76}, {45, 77}, {46, 78}, {47, 79}, {48, 80}, {49, 81}, {50, 82}, {51, 83}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationInlineFunctionTest, Apply) { std::string reference_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %39 "main" ; Types %2 = OpTypeFloat 32 %3 = OpTypeVector %2 4 %4 = OpTypePointer Function %3 %5 = OpTypeVoid %6 = OpTypeFunction %5 %7 = OpTypeFunction %2 %4 %4 ; Constant scalars %8 = OpConstant %2 1 %9 = OpConstant %2 2 %10 = OpConstant %2 3 %11 = OpConstant %2 4 %12 = OpConstant %2 5 %13 = OpConstant %2 6 %14 = OpConstant %2 7 %15 = OpConstant %2 8 ; Constant vectors %16 = OpConstantComposite %3 %8 %9 %10 %11 %17 = OpConstantComposite %3 %12 %13 %14 %15 ; dot product function %18 = OpFunction %2 None %7 %19 = OpFunctionParameter %4 %20 = OpFunctionParameter %4 %21 = OpLabel %22 = OpLoad %3 %19 %23 = OpLoad %3 %20 %24 = OpCompositeExtract %2 %22 0 %25 = OpCompositeExtract %2 %23 0 %26 = OpFMul %2 %24 %25 %27 = OpCompositeExtract %2 %22 1 %28 = OpCompositeExtract %2 %23 1 %29 = OpFMul %2 %27 %28 %30 = OpCompositeExtract %2 %22 2 %31 = OpCompositeExtract %2 %23 2 %32 = OpFMul %2 %30 %31 %33 = OpCompositeExtract %2 %22 3 %34 = OpCompositeExtract %2 %23 3 %35 = OpFMul %2 %33 %34 %36 = OpFAdd %2 %26 %29 %37 = OpFAdd %2 %32 %36 %38 = OpFAdd %2 %35 %37 OpReturnValue %38 OpFunctionEnd ; main function %39 = OpFunction %5 None %6 %40 = OpLabel %41 = OpVariable %4 Function %42 = OpVariable %4 Function OpStore %41 %16 OpStore %42 %17 %43 = OpFunctionCall %2 %18 %41 %42 ; dot product function call OpBranch %44 %44 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto transformation = TransformationInlineFunction(43, {{22, 45}, {23, 46}, {24, 47}, {25, 48}, {26, 49}, {27, 50}, {28, 51}, {29, 52}, {30, 53}, {31, 54}, {32, 55}, {33, 56}, {34, 57}, {35, 58}, {36, 59}, {37, 60}, {38, 61}}); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); std::string variant_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %39 "main" ; Types %2 = OpTypeFloat 32 %3 = OpTypeVector %2 4 %4 = OpTypePointer Function %3 %5 = OpTypeVoid %6 = OpTypeFunction %5 %7 = OpTypeFunction %2 %4 %4 ; Constant scalars %8 = OpConstant %2 1 %9 = OpConstant %2 2 %10 = OpConstant %2 3 %11 = OpConstant %2 4 %12 = OpConstant %2 5 %13 = OpConstant %2 6 %14 = OpConstant %2 7 %15 = OpConstant %2 8 ; Constant vectors %16 = OpConstantComposite %3 %8 %9 %10 %11 %17 = OpConstantComposite %3 %12 %13 %14 %15 ; dot product function %18 = OpFunction %2 None %7 %19 = OpFunctionParameter %4 %20 = OpFunctionParameter %4 %21 = OpLabel %22 = OpLoad %3 %19 %23 = OpLoad %3 %20 %24 = OpCompositeExtract %2 %22 0 %25 = OpCompositeExtract %2 %23 0 %26 = OpFMul %2 %24 %25 %27 = OpCompositeExtract %2 %22 1 %28 = OpCompositeExtract %2 %23 1 %29 = OpFMul %2 %27 %28 %30 = OpCompositeExtract %2 %22 2 %31 = OpCompositeExtract %2 %23 2 %32 = OpFMul %2 %30 %31 %33 = OpCompositeExtract %2 %22 3 %34 = OpCompositeExtract %2 %23 3 %35 = OpFMul %2 %33 %34 %36 = OpFAdd %2 %26 %29 %37 = OpFAdd %2 %32 %36 %38 = OpFAdd %2 %35 %37 OpReturnValue %38 OpFunctionEnd ; main function %39 = OpFunction %5 None %6 %40 = OpLabel %41 = OpVariable %4 Function %42 = OpVariable %4 Function OpStore %41 %16 OpStore %42 %17 %45 = OpLoad %3 %41 %46 = OpLoad %3 %42 %47 = OpCompositeExtract %2 %45 0 %48 = OpCompositeExtract %2 %46 0 %49 = OpFMul %2 %47 %48 %50 = OpCompositeExtract %2 %45 1 %51 = OpCompositeExtract %2 %46 1 %52 = OpFMul %2 %50 %51 %53 = OpCompositeExtract %2 %45 2 %54 = OpCompositeExtract %2 %46 2 %55 = OpFMul %2 %53 %54 %56 = OpCompositeExtract %2 %45 3 %57 = OpCompositeExtract %2 %46 3 %58 = OpFMul %2 %56 %57 %59 = OpFAdd %2 %49 %52 %60 = OpFAdd %2 %55 %59 %61 = OpFAdd %2 %58 %60 %43 = OpCopyObject %2 %61 OpBranch %44 %44 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(IsEqual(env, variant_shader, context.get())); } TEST(TransformationInlineFunctionTest, ApplyToMultipleFunctions) { std::string reference_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %15 "main" ; Types %2 = OpTypeInt 32 1 %3 = OpTypeBool %4 = OpTypePointer Private %2 %5 = OpTypePointer Function %2 %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeFunction %2 %5 %9 = OpTypeFunction %2 %2 ; Constants %10 = OpConstant %2 0 %11 = OpConstant %2 1 %12 = OpConstant %2 2 %13 = OpConstant %2 3 ; Global variable %14 = OpVariable %4 Private ; main function %15 = OpFunction %6 None %7 %16 = OpLabel %17 = OpVariable %5 Function %18 = OpVariable %5 Function %19 = OpVariable %5 Function OpStore %17 %13 %20 = OpLoad %2 %17 OpStore %18 %20 %21 = OpFunctionCall %2 %36 %18 OpBranch %22 %22 = OpLabel %23 = OpFunctionCall %2 %36 %18 OpStore %17 %21 %24 = OpLoad %2 %17 %25 = OpFunctionCall %2 %54 %24 OpBranch %26 %26 = OpLabel %27 = OpFunctionCall %2 %54 %24 %28 = OpLoad %2 %17 %29 = OpIAdd %2 %28 %25 OpStore %17 %29 %30 = OpFunctionCall %6 %67 OpBranch %31 %31 = OpLabel %32 = OpFunctionCall %6 %67 %33 = OpLoad %2 %14 %34 = OpLoad %2 %17 %35 = OpIAdd %2 %34 %33 OpStore %17 %35 OpReturn OpFunctionEnd ; Function %36 %36 = OpFunction %2 None %8 %37 = OpFunctionParameter %5 %38 = OpLabel %39 = OpVariable %5 Function %40 = OpVariable %5 Function OpStore %39 %10 OpBranch %41 %41 = OpLabel OpLoopMerge %52 %49 None OpBranch %42 %42 = OpLabel %43 = OpLoad %2 %39 %44 = OpLoad %2 %37 %45 = OpSLessThan %3 %43 %44 OpBranchConditional %45 %46 %52 %46 = OpLabel %47 = OpLoad %2 %40 %48 = OpIAdd %2 %47 %11 OpStore %40 %48 OpBranch %49 %49 = OpLabel %50 = OpLoad %2 %39 %51 = OpIAdd %2 %50 %12 OpStore %39 %51 OpBranch %41 %52 = OpLabel %53 = OpLoad %2 %40 OpReturnValue %53 OpFunctionEnd ; Function %54 %54 = OpFunction %2 None %9 %55 = OpFunctionParameter %2 %56 = OpLabel %57 = OpVariable %5 Function OpStore %57 %10 %58 = OpSGreaterThan %3 %55 %10 OpSelectionMerge %62 None OpBranchConditional %58 %64 %59 %59 = OpLabel %60 = OpLoad %2 %57 %61 = OpISub %2 %60 %12 OpStore %57 %61 OpBranch %62 %62 = OpLabel %63 = OpLoad %2 %57 OpReturnValue %63 %64 = OpLabel %65 = OpLoad %2 %57 %66 = OpIAdd %2 %65 %11 OpStore %57 %66 OpBranch %62 OpFunctionEnd ; Function %67 %67 = OpFunction %6 None %7 %68 = OpLabel OpStore %14 %12 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto transformation = TransformationInlineFunction(30, {}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); // Tests a parameter included in the id map. transformation = TransformationInlineFunction(25, {{55, 69}, {56, 70}, {57, 71}, {58, 72}, {59, 73}, {60, 74}, {61, 75}, {62, 76}, {63, 77}, {64, 78}, {65, 79}, {66, 80}}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); #ifndef NDEBUG // Tests the id of the returned value not included in the id map. transformation = TransformationInlineFunction(25, {{56, 69}, {57, 70}, {58, 71}, {59, 72}, {60, 73}, {61, 74}, {62, 75}, {64, 76}, {65, 77}, {66, 78}}); ASSERT_DEATH( transformation.IsApplicable(context.get(), transformation_context), "Bad attempt to query whether overflow ids are available."); #endif transformation = TransformationInlineFunction(25, {{57, 69}, {58, 70}, {59, 71}, {60, 72}, {61, 73}, {62, 74}, {63, 75}, {64, 76}, {65, 77}, {66, 78}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); transformation = TransformationInlineFunction(21, {{39, 79}, {40, 80}, {41, 81}, {42, 82}, {43, 83}, {44, 84}, {45, 85}, {46, 86}, {47, 87}, {48, 88}, {49, 89}, {50, 90}, {51, 91}, {52, 92}, {53, 93}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); std::string variant_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %15 "main" ; Types %2 = OpTypeInt 32 1 %3 = OpTypeBool %4 = OpTypePointer Private %2 %5 = OpTypePointer Function %2 %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeFunction %2 %5 %9 = OpTypeFunction %2 %2 ; Constants %10 = OpConstant %2 0 %11 = OpConstant %2 1 %12 = OpConstant %2 2 %13 = OpConstant %2 3 ; Global variable %14 = OpVariable %4 Private ; main function %15 = OpFunction %6 None %7 %16 = OpLabel %80 = OpVariable %5 Function %79 = OpVariable %5 Function %69 = OpVariable %5 Function %17 = OpVariable %5 Function %18 = OpVariable %5 Function %19 = OpVariable %5 Function OpStore %17 %13 %20 = OpLoad %2 %17 OpStore %18 %20 OpStore %79 %10 OpBranch %81 %81 = OpLabel OpLoopMerge %92 %89 None OpBranch %82 %82 = OpLabel %83 = OpLoad %2 %79 %84 = OpLoad %2 %18 %85 = OpSLessThan %3 %83 %84 OpBranchConditional %85 %86 %92 %86 = OpLabel %87 = OpLoad %2 %80 %88 = OpIAdd %2 %87 %11 OpStore %80 %88 OpBranch %89 %89 = OpLabel %90 = OpLoad %2 %79 %91 = OpIAdd %2 %90 %12 OpStore %79 %91 OpBranch %81 %92 = OpLabel %93 = OpLoad %2 %80 %21 = OpCopyObject %2 %93 OpBranch %22 %22 = OpLabel %23 = OpFunctionCall %2 %36 %18 OpStore %17 %21 %24 = OpLoad %2 %17 OpStore %69 %10 %70 = OpSGreaterThan %3 %24 %10 OpSelectionMerge %74 None OpBranchConditional %70 %76 %71 %71 = OpLabel %72 = OpLoad %2 %69 %73 = OpISub %2 %72 %12 OpStore %69 %73 OpBranch %74 %74 = OpLabel %75 = OpLoad %2 %69 %25 = OpCopyObject %2 %75 OpBranch %26 %76 = OpLabel %77 = OpLoad %2 %69 %78 = OpIAdd %2 %77 %11 OpStore %69 %78 OpBranch %74 %26 = OpLabel %27 = OpFunctionCall %2 %54 %24 %28 = OpLoad %2 %17 %29 = OpIAdd %2 %28 %25 OpStore %17 %29 OpStore %14 %12 OpBranch %31 %31 = OpLabel %32 = OpFunctionCall %6 %67 %33 = OpLoad %2 %14 %34 = OpLoad %2 %17 %35 = OpIAdd %2 %34 %33 OpStore %17 %35 OpReturn OpFunctionEnd ; Function %36 %36 = OpFunction %2 None %8 %37 = OpFunctionParameter %5 %38 = OpLabel %39 = OpVariable %5 Function %40 = OpVariable %5 Function OpStore %39 %10 OpBranch %41 %41 = OpLabel OpLoopMerge %52 %49 None OpBranch %42 %42 = OpLabel %43 = OpLoad %2 %39 %44 = OpLoad %2 %37 %45 = OpSLessThan %3 %43 %44 OpBranchConditional %45 %46 %52 %46 = OpLabel %47 = OpLoad %2 %40 %48 = OpIAdd %2 %47 %11 OpStore %40 %48 OpBranch %49 %49 = OpLabel %50 = OpLoad %2 %39 %51 = OpIAdd %2 %50 %12 OpStore %39 %51 OpBranch %41 %52 = OpLabel %53 = OpLoad %2 %40 OpReturnValue %53 OpFunctionEnd ; Function %54 %54 = OpFunction %2 None %9 %55 = OpFunctionParameter %2 %56 = OpLabel %57 = OpVariable %5 Function OpStore %57 %10 %58 = OpSGreaterThan %3 %55 %10 OpSelectionMerge %62 None OpBranchConditional %58 %64 %59 %59 = OpLabel %60 = OpLoad %2 %57 %61 = OpISub %2 %60 %12 OpStore %57 %61 OpBranch %62 %62 = OpLabel %63 = OpLoad %2 %57 OpReturnValue %63 %64 = OpLabel %65 = OpLoad %2 %57 %66 = OpIAdd %2 %65 %11 OpStore %57 %66 OpBranch %62 OpFunctionEnd ; Function %67 %67 = OpFunction %6 None %7 %68 = OpLabel OpStore %14 %12 OpReturn OpFunctionEnd )"; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(IsEqual(env, variant_shader, context.get())); } TEST(TransformationInlineFunctionTest, HandlesOpPhisInTheSecondBlock) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeInt 32 0 %11 = OpUndef %10 %4 = OpFunction %2 None %3 %5 = OpLabel %6 = OpFunctionCall %2 %7 OpBranch %14 %14 = OpLabel OpReturn OpFunctionEnd %7 = OpFunction %2 None %3 %8 = OpLabel OpBranch %13 %13 = OpLabel %12 = OpPhi %10 %11 %8 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationInlineFunction transformation(6, {{{8, 20}, {13, 21}, {12, 22}}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeInt 32 0 %11 = OpUndef %10 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %21 %21 = OpLabel %22 = OpPhi %10 %11 %5 OpBranch %14 %14 = OpLabel OpReturn OpFunctionEnd %7 = OpFunction %2 None %3 %8 = OpLabel OpBranch %13 %13 = OpLabel %12 = OpPhi %10 %11 %8 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationInlineFunctionTest, OverflowIds) { std::string reference_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %39 "main" ; Types %2 = OpTypeFloat 32 %3 = OpTypeVector %2 4 %4 = OpTypePointer Function %3 %5 = OpTypeVoid %6 = OpTypeFunction %5 %7 = OpTypeFunction %2 %4 %4 ; Constant scalars %8 = OpConstant %2 1 %9 = OpConstant %2 2 %10 = OpConstant %2 3 %11 = OpConstant %2 4 %12 = OpConstant %2 5 %13 = OpConstant %2 6 %14 = OpConstant %2 7 %15 = OpConstant %2 8 ; Constant vectors %16 = OpConstantComposite %3 %8 %9 %10 %11 %17 = OpConstantComposite %3 %12 %13 %14 %15 ; dot product function %18 = OpFunction %2 None %7 %19 = OpFunctionParameter %4 %20 = OpFunctionParameter %4 %21 = OpLabel %22 = OpLoad %3 %19 %23 = OpLoad %3 %20 %24 = OpCompositeExtract %2 %22 0 %25 = OpCompositeExtract %2 %23 0 %26 = OpFMul %2 %24 %25 %27 = OpCompositeExtract %2 %22 1 %28 = OpCompositeExtract %2 %23 1 %29 = OpFMul %2 %27 %28 OpBranch %100 %100 = OpLabel %30 = OpCompositeExtract %2 %22 2 %31 = OpCompositeExtract %2 %23 2 %32 = OpFMul %2 %30 %31 %33 = OpCompositeExtract %2 %22 3 %34 = OpCompositeExtract %2 %23 3 %35 = OpFMul %2 %33 %34 %36 = OpFAdd %2 %26 %29 %37 = OpFAdd %2 %32 %36 %38 = OpFAdd %2 %35 %37 OpReturnValue %38 OpFunctionEnd ; main function %39 = OpFunction %5 None %6 %40 = OpLabel %41 = OpVariable %4 Function %42 = OpVariable %4 Function OpStore %41 %16 OpStore %42 %17 %43 = OpFunctionCall %2 %18 %41 %42 ; dot product function call OpBranch %44 %44 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); auto overflow_ids_unique_ptr = MakeUnique(1000); auto overflow_ids_ptr = overflow_ids_unique_ptr.get(); TransformationContext transformation_context( MakeUnique(context.get()), validator_options, std::move(overflow_ids_unique_ptr)); auto transformation = TransformationInlineFunction(43, {{22, 45}, {23, 46}, {24, 47}, {25, 48}, {26, 49}, {27, 50}, {28, 51}, {29, 52}}); // The following ids are left un-mapped; overflow ids will be required for // them: 30, 31, 32, 33, 34, 35, 36, 37, 38, 100 ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context, overflow_ids_ptr->GetIssuedOverflowIds()); std::string variant_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %39 "main" ; Types %2 = OpTypeFloat 32 %3 = OpTypeVector %2 4 %4 = OpTypePointer Function %3 %5 = OpTypeVoid %6 = OpTypeFunction %5 %7 = OpTypeFunction %2 %4 %4 ; Constant scalars %8 = OpConstant %2 1 %9 = OpConstant %2 2 %10 = OpConstant %2 3 %11 = OpConstant %2 4 %12 = OpConstant %2 5 %13 = OpConstant %2 6 %14 = OpConstant %2 7 %15 = OpConstant %2 8 ; Constant vectors %16 = OpConstantComposite %3 %8 %9 %10 %11 %17 = OpConstantComposite %3 %12 %13 %14 %15 ; dot product function %18 = OpFunction %2 None %7 %19 = OpFunctionParameter %4 %20 = OpFunctionParameter %4 %21 = OpLabel %22 = OpLoad %3 %19 %23 = OpLoad %3 %20 %24 = OpCompositeExtract %2 %22 0 %25 = OpCompositeExtract %2 %23 0 %26 = OpFMul %2 %24 %25 %27 = OpCompositeExtract %2 %22 1 %28 = OpCompositeExtract %2 %23 1 %29 = OpFMul %2 %27 %28 OpBranch %100 %100 = OpLabel %30 = OpCompositeExtract %2 %22 2 %31 = OpCompositeExtract %2 %23 2 %32 = OpFMul %2 %30 %31 %33 = OpCompositeExtract %2 %22 3 %34 = OpCompositeExtract %2 %23 3 %35 = OpFMul %2 %33 %34 %36 = OpFAdd %2 %26 %29 %37 = OpFAdd %2 %32 %36 %38 = OpFAdd %2 %35 %37 OpReturnValue %38 OpFunctionEnd ; main function %39 = OpFunction %5 None %6 %40 = OpLabel %41 = OpVariable %4 Function %42 = OpVariable %4 Function OpStore %41 %16 OpStore %42 %17 %45 = OpLoad %3 %41 %46 = OpLoad %3 %42 %47 = OpCompositeExtract %2 %45 0 %48 = OpCompositeExtract %2 %46 0 %49 = OpFMul %2 %47 %48 %50 = OpCompositeExtract %2 %45 1 %51 = OpCompositeExtract %2 %46 1 %52 = OpFMul %2 %50 %51 OpBranch %1000 %1000 = OpLabel %1001 = OpCompositeExtract %2 %45 2 %1002 = OpCompositeExtract %2 %46 2 %1003 = OpFMul %2 %1001 %1002 %1004 = OpCompositeExtract %2 %45 3 %1005 = OpCompositeExtract %2 %46 3 %1006 = OpFMul %2 %1004 %1005 %1007 = OpFAdd %2 %49 %52 %1008 = OpFAdd %2 %1003 %1007 %1009 = OpFAdd %2 %1006 %1008 %43 = OpCopyObject %2 %1009 OpBranch %44 %44 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(IsEqual(env, variant_shader, context.get())); } TEST(TransformationInlineFunctionTest, OpPhiInBlockFollowingCall) { // This test checks that if the block after the inlined function call has an // OpPhi instruction and the called function contains multiple blocks then the // OpPhi instruction gets updated to refer to the return block of the inlined // function, since the block containing the call will no longer be a // predecessor. std::string reference_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %13 = OpTypeBool %14 = OpConstantTrue %13 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %10 %10 = OpLabel %8 = OpFunctionCall %2 %6 OpBranch %11 %11 = OpLabel %12 = OpPhi %13 %14 %10 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel OpBranch %20 %20 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto transformation = TransformationInlineFunction(8, {{7, 100}, {20, 101}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string variant_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %13 = OpTypeBool %14 = OpConstantTrue %13 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %10 %10 = OpLabel OpBranch %101 %101 = OpLabel OpBranch %11 %11 = OpLabel %12 = OpPhi %13 %14 %101 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel OpBranch %20 %20 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(IsEqual(env, variant_shader, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_invert_comparison_operator_test.cpp000066400000000000000000000115171475742701700330600ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_invert_comparison_operator.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationInvertComparisonOperatorTest, BasicTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeInt 32 0 %8 = OpTypeBool %9 = OpConstant %6 3 %10 = OpConstant %6 4 %11 = OpConstant %7 3 %12 = OpConstant %7 4 %4 = OpFunction %2 None %3 %5 = OpLabel %13 = OpSLessThan %8 %9 %10 %14 = OpSLessThanEqual %8 %9 %10 %15 = OpSGreaterThan %8 %9 %10 %16 = OpSGreaterThanEqual %8 %9 %10 %17 = OpULessThan %8 %11 %12 %18 = OpULessThanEqual %8 %11 %12 %19 = OpUGreaterThan %8 %11 %12 %20 = OpUGreaterThanEqual %8 %11 %12 %21 = OpIEqual %8 %9 %10 %22 = OpINotEqual %8 %9 %10 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Operator id is not valid. ASSERT_FALSE(TransformationInvertComparisonOperator(23, 23).IsApplicable( context.get(), transformation_context)); // Operator instruction is not supported. ASSERT_FALSE(TransformationInvertComparisonOperator(5, 23).IsApplicable( context.get(), transformation_context)); // Fresh id is not fresh. ASSERT_FALSE(TransformationInvertComparisonOperator(13, 22).IsApplicable( context.get(), transformation_context)); for (uint32_t fresh_id = 23, operator_id = 13; operator_id <= 22; ++fresh_id, ++operator_id) { TransformationInvertComparisonOperator transformation(operator_id, fresh_id); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } std::string expected = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeInt 32 0 %8 = OpTypeBool %9 = OpConstant %6 3 %10 = OpConstant %6 4 %11 = OpConstant %7 3 %12 = OpConstant %7 4 %4 = OpFunction %2 None %3 %5 = OpLabel %23 = OpSGreaterThanEqual %8 %9 %10 %13 = OpLogicalNot %8 %23 %24 = OpSGreaterThan %8 %9 %10 %14 = OpLogicalNot %8 %24 %25 = OpSLessThanEqual %8 %9 %10 %15 = OpLogicalNot %8 %25 %26 = OpSLessThan %8 %9 %10 %16 = OpLogicalNot %8 %26 %27 = OpUGreaterThanEqual %8 %11 %12 %17 = OpLogicalNot %8 %27 %28 = OpUGreaterThan %8 %11 %12 %18 = OpLogicalNot %8 %28 %29 = OpULessThanEqual %8 %11 %12 %19 = OpLogicalNot %8 %29 %30 = OpULessThan %8 %11 %12 %20 = OpLogicalNot %8 %30 %31 = OpINotEqual %8 %9 %10 %21 = OpLogicalNot %8 %31 %32 = OpIEqual %8 %9 %10 %22 = OpLogicalNot %8 %32 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected, context.get())); } } // namespace } // namespace fuzz } // namespace spvtoolsKhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_load_test.cpp000066400000000000000000000547521475742701700263330ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_load.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationLoadTest, BasicTest) { std::string shader = R"( OpCapability Shader OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeFloat 32 %8 = OpTypeStruct %6 %7 %9 = OpTypePointer Function %8 %10 = OpTypeFunction %6 %9 %14 = OpConstant %6 0 %15 = OpTypePointer Function %6 %51 = OpTypePointer Private %6 %21 = OpConstant %6 2 %23 = OpConstant %6 1 %24 = OpConstant %7 1 %25 = OpTypePointer Function %7 %50 = OpTypePointer Private %7 %34 = OpTypeBool %35 = OpConstantFalse %34 %60 = OpConstantNull %50 %52 = OpVariable %50 Private %53 = OpVariable %51 Private %4 = OpFunction %2 None %3 %5 = OpLabel %20 = OpVariable %9 Function %27 = OpVariable %9 Function ; irrelevant %22 = OpAccessChain %15 %20 %14 %44 = OpCopyObject %9 %20 %26 = OpAccessChain %25 %20 %23 %29 = OpFunctionCall %6 %12 %27 %30 = OpAccessChain %15 %20 %14 %45 = OpCopyObject %15 %30 %33 = OpAccessChain %15 %20 %14 OpSelectionMerge %37 None OpBranchConditional %35 %36 %37 %36 = OpLabel %38 = OpAccessChain %15 %20 %14 %40 = OpAccessChain %15 %20 %14 %43 = OpAccessChain %15 %20 %14 OpBranch %37 %37 = OpLabel OpReturn OpFunctionEnd %12 = OpFunction %6 None %10 %11 = OpFunctionParameter %9 ; irrelevant %13 = OpLabel %46 = OpCopyObject %9 %11 ; irrelevant %16 = OpAccessChain %15 %11 %14 ; irrelevant OpReturnValue %21 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactValueOfPointeeIsIrrelevant( 27); transformation_context.GetFactManager()->AddFactValueOfPointeeIsIrrelevant( 11); transformation_context.GetFactManager()->AddFactValueOfPointeeIsIrrelevant( 46); transformation_context.GetFactManager()->AddFactValueOfPointeeIsIrrelevant( 16); transformation_context.GetFactManager()->AddFactValueOfPointeeIsIrrelevant( 52); transformation_context.GetFactManager()->AddFactBlockIsDead(36); // Variables with pointee types: // 52 - ptr_to(7) // 53 - ptr_to(6) // 20 - ptr_to(8) // 27 - ptr_to(8) - irrelevant // Access chains with pointee type: // 22 - ptr_to(6) // 26 - ptr_to(6) // 30 - ptr_to(6) // 33 - ptr_to(6) // 38 - ptr_to(6) // 40 - ptr_to(6) // 43 - ptr_to(6) // 16 - ptr_to(6) - irrelevant // Copied object with pointee type: // 44 - ptr_to(8) // 45 - ptr_to(6) // 46 - ptr_to(8) - irrelevant // Function parameters with pointee type: // 11 - ptr_to(8) - irrelevant // Pointers that cannot be used: // 60 - null // Bad: id is not fresh ASSERT_FALSE(TransformationLoad( 33, 33, false, 0, 0, MakeInstructionDescriptor(38, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: attempt to load from 11 from outside its function ASSERT_FALSE(TransformationLoad( 100, 11, false, 0, 0, MakeInstructionDescriptor(38, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: pointer is not available ASSERT_FALSE(TransformationLoad( 100, 33, false, 0, 0, MakeInstructionDescriptor(45, spv::Op::OpCopyObject, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: attempt to insert before OpVariable ASSERT_FALSE( TransformationLoad(100, 27, false, 0, 0, MakeInstructionDescriptor(27, spv::Op::OpVariable, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: pointer id does not exist ASSERT_FALSE(TransformationLoad( 100, 1000, false, 0, 0, MakeInstructionDescriptor(38, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: pointer id exists but does not have a type ASSERT_FALSE(TransformationLoad( 100, 5, false, 0, 0, MakeInstructionDescriptor(38, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: pointer id exists and has a type, but is not a pointer ASSERT_FALSE(TransformationLoad( 100, 24, false, 0, 0, MakeInstructionDescriptor(38, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: attempt to load from null pointer ASSERT_FALSE(TransformationLoad( 100, 60, false, 0, 0, MakeInstructionDescriptor(38, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: %40 is not available at the program point ASSERT_FALSE( TransformationLoad(100, 40, false, 0, 0, MakeInstructionDescriptor(37, spv::Op::OpReturn, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: The described instruction does not exist ASSERT_FALSE( TransformationLoad(100, 33, false, 0, 0, MakeInstructionDescriptor(1000, spv::Op::OpReturn, 0)) .IsApplicable(context.get(), transformation_context)); { TransformationLoad transformation( 100, 33, false, 0, 0, MakeInstructionDescriptor(38, spv::Op::OpAccessChain, 0)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } { TransformationLoad transformation( 101, 46, false, 0, 0, MakeInstructionDescriptor(16, spv::Op::OpReturnValue, 0)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } { TransformationLoad transformation( 102, 16, false, 0, 0, MakeInstructionDescriptor(16, spv::Op::OpReturnValue, 0)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } { TransformationLoad transformation( 103, 40, false, 0, 0, MakeInstructionDescriptor(43, spv::Op::OpAccessChain, 0)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } std::string after_transformation = R"( OpCapability Shader OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeFloat 32 %8 = OpTypeStruct %6 %7 %9 = OpTypePointer Function %8 %10 = OpTypeFunction %6 %9 %14 = OpConstant %6 0 %15 = OpTypePointer Function %6 %51 = OpTypePointer Private %6 %21 = OpConstant %6 2 %23 = OpConstant %6 1 %24 = OpConstant %7 1 %25 = OpTypePointer Function %7 %50 = OpTypePointer Private %7 %34 = OpTypeBool %35 = OpConstantFalse %34 %60 = OpConstantNull %50 %52 = OpVariable %50 Private %53 = OpVariable %51 Private %4 = OpFunction %2 None %3 %5 = OpLabel %20 = OpVariable %9 Function %27 = OpVariable %9 Function ; irrelevant %22 = OpAccessChain %15 %20 %14 %44 = OpCopyObject %9 %20 %26 = OpAccessChain %25 %20 %23 %29 = OpFunctionCall %6 %12 %27 %30 = OpAccessChain %15 %20 %14 %45 = OpCopyObject %15 %30 %33 = OpAccessChain %15 %20 %14 OpSelectionMerge %37 None OpBranchConditional %35 %36 %37 %36 = OpLabel %100 = OpLoad %6 %33 %38 = OpAccessChain %15 %20 %14 %40 = OpAccessChain %15 %20 %14 %103 = OpLoad %6 %40 %43 = OpAccessChain %15 %20 %14 OpBranch %37 %37 = OpLabel OpReturn OpFunctionEnd %12 = OpFunction %6 None %10 %11 = OpFunctionParameter %9 ; irrelevant %13 = OpLabel %46 = OpCopyObject %9 %11 ; irrelevant %16 = OpAccessChain %15 %11 %14 ; irrelevant %101 = OpLoad %8 %46 %102 = OpLoad %6 %16 OpReturnValue %21 OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationLoadTest, AtomicLoadTestCase) { const std::string shader = R"( OpCapability Shader OpCapability Int8 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeInt 8 1 %9 = OpTypeInt 32 0 %26 = OpTypeFloat 32 %8 = OpTypeStruct %6 %10 = OpTypePointer StorageBuffer %8 %11 = OpVariable %10 StorageBuffer %19 = OpConstant %26 0 %18 = OpConstant %9 1 %12 = OpConstant %6 0 %13 = OpTypePointer StorageBuffer %6 %15 = OpConstant %6 4 %16 = OpConstant %6 7 %17 = OpConstant %7 4 %20 = OpConstant %9 64 %4 = OpFunction %2 None %3 %5 = OpLabel %14 = OpAccessChain %13 %11 %12 %24 = OpAccessChain %13 %11 %12 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Bad: id is not fresh. ASSERT_FALSE(TransformationLoad( 14, 14, true, 15, 20, MakeInstructionDescriptor(24, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: id 100 of memory scope instruction does not exist. ASSERT_FALSE(TransformationLoad( 21, 14, true, 100, 20, MakeInstructionDescriptor(24, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: id 100 of memory semantics instruction does not exist. ASSERT_FALSE(TransformationLoad( 21, 14, true, 15, 100, MakeInstructionDescriptor(24, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: memory scope should be |OpConstant| opcode. ASSERT_FALSE(TransformationLoad( 21, 14, true, 5, 20, MakeInstructionDescriptor(24, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: memory semantics should be |OpConstant| opcode. ASSERT_FALSE(TransformationLoad( 21, 14, true, 15, 5, MakeInstructionDescriptor(24, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: The memory scope instruction must have an Integer operand. ASSERT_FALSE(TransformationLoad( 21, 14, true, 15, 19, MakeInstructionDescriptor(24, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: The memory memory semantics instruction must have an Integer operand. ASSERT_FALSE(TransformationLoad( 21, 14, true, 19, 20, MakeInstructionDescriptor(24, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: Integer size of the memory scope must be equal to 32 bits. ASSERT_FALSE(TransformationLoad( 21, 14, true, 17, 20, MakeInstructionDescriptor(24, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: Integer size of memory semantics must be equal to 32 bits. ASSERT_FALSE(TransformationLoad( 21, 14, true, 15, 17, MakeInstructionDescriptor(24, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: memory scope value must be 4 (spv::Scope::Invocation). ASSERT_FALSE(TransformationLoad( 21, 14, true, 16, 20, MakeInstructionDescriptor(24, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: memory semantics value must be either: // 64 (SpvMemorySemanticsUniformMemoryMask) // 256 (SpvMemorySemanticsWorkgroupMemoryMask) ASSERT_FALSE(TransformationLoad( 21, 14, true, 15, 16, MakeInstructionDescriptor(24, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: The described instruction does not exist ASSERT_FALSE(TransformationLoad( 21, 14, false, 15, 20, MakeInstructionDescriptor(150, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Successful transformations. { TransformationLoad transformation( 21, 14, true, 15, 20, MakeInstructionDescriptor(24, spv::Op::OpAccessChain, 0)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } const std::string after_transformation = R"( OpCapability Shader OpCapability Int8 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeInt 8 1 %9 = OpTypeInt 32 0 %26 = OpTypeFloat 32 %8 = OpTypeStruct %6 %10 = OpTypePointer StorageBuffer %8 %11 = OpVariable %10 StorageBuffer %19 = OpConstant %26 0 %18 = OpConstant %9 1 %12 = OpConstant %6 0 %13 = OpTypePointer StorageBuffer %6 %15 = OpConstant %6 4 %16 = OpConstant %6 7 %17 = OpConstant %7 4 %20 = OpConstant %9 64 %4 = OpFunction %2 None %3 %5 = OpLabel %14 = OpAccessChain %13 %11 %12 %21 = OpAtomicLoad %6 %14 %15 %20 %24 = OpAccessChain %13 %11 %12 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationLoadTest, AtomicLoadTestCaseForWorkgroupMemory) { std::string shader = R"( OpCapability Shader OpCapability Int8 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %26 = OpTypeFloat 32 %27 = OpTypeInt 8 1 %7 = OpTypeInt 32 0 ; 0 means unsigned %8 = OpConstant %7 0 %17 = OpConstant %27 4 %19 = OpConstant %26 0 %9 = OpTypePointer Function %6 %13 = OpTypeStruct %6 %12 = OpTypePointer Workgroup %13 %11 = OpVariable %12 Workgroup %14 = OpConstant %6 0 %15 = OpTypePointer Function %6 %51 = OpTypePointer Private %6 %21 = OpConstant %6 4 %23 = OpConstant %6 256 %25 = OpTypePointer Function %7 %50 = OpTypePointer Workgroup %6 %34 = OpTypeBool %35 = OpConstantFalse %34 %53 = OpVariable %51 Private %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %37 None OpBranchConditional %35 %36 %37 %36 = OpLabel %38 = OpAccessChain %50 %11 %14 %40 = OpAccessChain %50 %11 %14 OpBranch %37 %37 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Bad: Can't insert OpAccessChain before the id 23 of memory scope. ASSERT_FALSE(TransformationLoad( 60, 38, true, 21, 23, MakeInstructionDescriptor(23, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: Can't insert OpAccessChain before the id 23 of memory semantics. ASSERT_FALSE(TransformationLoad( 60, 38, true, 21, 23, MakeInstructionDescriptor(21, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Successful transformations. { TransformationLoad transformation( 60, 38, true, 21, 23, MakeInstructionDescriptor(40, spv::Op::OpAccessChain, 0)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } std::string after_transformation = R"( OpCapability Shader OpCapability Int8 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %26 = OpTypeFloat 32 %27 = OpTypeInt 8 1 %7 = OpTypeInt 32 0 ; 0 means unsigned %8 = OpConstant %7 0 %17 = OpConstant %27 4 %19 = OpConstant %26 0 %9 = OpTypePointer Function %6 %13 = OpTypeStruct %6 %12 = OpTypePointer Workgroup %13 %11 = OpVariable %12 Workgroup %14 = OpConstant %6 0 %15 = OpTypePointer Function %6 %51 = OpTypePointer Private %6 %21 = OpConstant %6 4 %23 = OpConstant %6 256 %25 = OpTypePointer Function %7 %50 = OpTypePointer Workgroup %6 %34 = OpTypeBool %35 = OpConstantFalse %34 %53 = OpVariable %51 Private %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %37 None OpBranchConditional %35 %36 %37 %36 = OpLabel %38 = OpAccessChain %50 %11 %14 %60 = OpAtomicLoad %6 %38 %21 %23 %40 = OpAccessChain %50 %11 %14 OpBranch %37 %37 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_make_vector_operation_dynamic_test.cpp000066400000000000000000000340561475742701700334720ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_make_vector_operation_dynamic.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationMakeVectorOperationDynamicTest, IsApplicable) { std::string reference_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %22 "main" ; Types %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeInt 32 0 %5 = OpTypeFloat 32 %6 = OpTypeVector %5 2 %7 = OpTypeVector %5 3 %8 = OpTypeVector %5 4 %9 = OpTypeMatrix %6 2 ; Constant scalars %10 = OpConstant %4 0 %11 = OpConstant %4 1 %12 = OpConstant %4 2 %13 = OpConstant %5 0 %14 = OpConstant %5 1 %15 = OpConstant %5 2 %16 = OpConstant %5 3 ; Constant composites %17 = OpConstantComposite %6 %13 %14 %18 = OpConstantComposite %6 %15 %16 %19 = OpConstantComposite %7 %13 %14 %15 %20 = OpConstantComposite %8 %13 %14 %15 %16 %21 = OpConstantComposite %9 %17 %18 ; main function %22 = OpFunction %2 None %3 %23 = OpLabel %24 = OpCompositeExtract %5 %17 0 %25 = OpCompositeExtract %5 %17 1 %26 = OpCompositeExtract %5 %18 0 %27 = OpCompositeExtract %5 %18 1 %28 = OpCompositeExtract %5 %19 0 %29 = OpCompositeExtract %5 %19 1 %30 = OpCompositeExtract %5 %19 2 %31 = OpCompositeExtract %5 %20 0 %32 = OpCompositeExtract %5 %20 1 %33 = OpCompositeExtract %5 %20 2 %34 = OpCompositeExtract %5 %20 3 %35 = OpCompositeExtract %6 %21 0 %36 = OpCompositeExtract %6 %21 1 %37 = OpCompositeInsert %6 %15 %17 0 %38 = OpCompositeInsert %6 %16 %17 1 %39 = OpCompositeInsert %6 %13 %18 0 %40 = OpCompositeInsert %6 %14 %18 1 %41 = OpCompositeInsert %7 %13 %19 0 %42 = OpCompositeInsert %7 %14 %19 1 %43 = OpCompositeInsert %7 %15 %19 2 %44 = OpCompositeInsert %8 %13 %20 0 %45 = OpCompositeInsert %8 %14 %20 1 %46 = OpCompositeInsert %8 %15 %20 2 %47 = OpCompositeInsert %8 %16 %20 3 %48 = OpCompositeInsert %9 %17 %21 0 %49 = OpCompositeInsert %9 %18 %21 1 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Tests undefined instruction. auto transformation = TransformationMakeVectorOperationDynamic(50, 10); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests non-composite instruction. transformation = TransformationMakeVectorOperationDynamic(23, 11); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests composite being a matrix. transformation = TransformationMakeVectorOperationDynamic(48, 12); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests literal not defined as constant. transformation = TransformationMakeVectorOperationDynamic(34, 51); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests applicable instructions. transformation = TransformationMakeVectorOperationDynamic(24, 10); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); transformation = TransformationMakeVectorOperationDynamic(25, 11); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); transformation = TransformationMakeVectorOperationDynamic(26, 10); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); transformation = TransformationMakeVectorOperationDynamic(37, 10); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); transformation = TransformationMakeVectorOperationDynamic(38, 11); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); transformation = TransformationMakeVectorOperationDynamic(39, 10); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationMakeVectorOperationDynamicTest, Apply) { std::string reference_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %20 "main" ; Types %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeInt 32 0 %5 = OpTypeFloat 32 %6 = OpTypeVector %5 2 %7 = OpTypeVector %5 3 %8 = OpTypeVector %5 4 ; Constant scalars %9 = OpConstant %4 0 %10 = OpConstant %4 1 %11 = OpConstant %4 2 %12 = OpConstant %4 3 %13 = OpConstant %5 0 %14 = OpConstant %5 1 %15 = OpConstant %5 2 %16 = OpConstant %5 3 ; Constant vectors %17 = OpConstantComposite %6 %13 %14 %18 = OpConstantComposite %7 %13 %14 %15 %19 = OpConstantComposite %8 %13 %14 %15 %16 ; main function %20 = OpFunction %2 None %3 %21 = OpLabel %22 = OpCompositeExtract %5 %17 0 %23 = OpCompositeExtract %5 %17 1 %24 = OpCompositeExtract %5 %18 0 %25 = OpCompositeExtract %5 %18 1 %26 = OpCompositeExtract %5 %18 2 %27 = OpCompositeExtract %5 %19 0 %28 = OpCompositeExtract %5 %19 1 %29 = OpCompositeExtract %5 %19 2 %30 = OpCompositeExtract %5 %19 3 %31 = OpCompositeInsert %6 %13 %17 0 %32 = OpCompositeInsert %6 %14 %17 1 %33 = OpCompositeInsert %7 %13 %18 0 %34 = OpCompositeInsert %7 %14 %18 1 %35 = OpCompositeInsert %7 %15 %18 2 %36 = OpCompositeInsert %8 %13 %19 0 %37 = OpCompositeInsert %8 %14 %19 1 %38 = OpCompositeInsert %8 %15 %19 2 %39 = OpCompositeInsert %8 %16 %19 3 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto transformation = TransformationMakeVectorOperationDynamic(22, 9); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); transformation = TransformationMakeVectorOperationDynamic(23, 10); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); transformation = TransformationMakeVectorOperationDynamic(24, 9); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); transformation = TransformationMakeVectorOperationDynamic(25, 10); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); transformation = TransformationMakeVectorOperationDynamic(26, 11); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); transformation = TransformationMakeVectorOperationDynamic(27, 9); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); transformation = TransformationMakeVectorOperationDynamic(28, 10); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); transformation = TransformationMakeVectorOperationDynamic(29, 11); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); transformation = TransformationMakeVectorOperationDynamic(30, 12); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); transformation = TransformationMakeVectorOperationDynamic(31, 9); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); transformation = TransformationMakeVectorOperationDynamic(32, 10); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); transformation = TransformationMakeVectorOperationDynamic(33, 9); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); transformation = TransformationMakeVectorOperationDynamic(34, 10); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); transformation = TransformationMakeVectorOperationDynamic(35, 11); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); transformation = TransformationMakeVectorOperationDynamic(36, 9); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); transformation = TransformationMakeVectorOperationDynamic(37, 10); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); transformation = TransformationMakeVectorOperationDynamic(38, 11); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); transformation = TransformationMakeVectorOperationDynamic(39, 12); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); std::string variant_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %20 "main" ; Types %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeInt 32 0 %5 = OpTypeFloat 32 %6 = OpTypeVector %5 2 %7 = OpTypeVector %5 3 %8 = OpTypeVector %5 4 ; Constant scalars %9 = OpConstant %4 0 %10 = OpConstant %4 1 %11 = OpConstant %4 2 %12 = OpConstant %4 3 %13 = OpConstant %5 0 %14 = OpConstant %5 1 %15 = OpConstant %5 2 %16 = OpConstant %5 3 ; Constant vectors %17 = OpConstantComposite %6 %13 %14 %18 = OpConstantComposite %7 %13 %14 %15 %19 = OpConstantComposite %8 %13 %14 %15 %16 ; main function %20 = OpFunction %2 None %3 %21 = OpLabel %22 = OpVectorExtractDynamic %5 %17 %9 %23 = OpVectorExtractDynamic %5 %17 %10 %24 = OpVectorExtractDynamic %5 %18 %9 %25 = OpVectorExtractDynamic %5 %18 %10 %26 = OpVectorExtractDynamic %5 %18 %11 %27 = OpVectorExtractDynamic %5 %19 %9 %28 = OpVectorExtractDynamic %5 %19 %10 %29 = OpVectorExtractDynamic %5 %19 %11 %30 = OpVectorExtractDynamic %5 %19 %12 %31 = OpVectorInsertDynamic %6 %17 %13 %9 %32 = OpVectorInsertDynamic %6 %17 %14 %10 %33 = OpVectorInsertDynamic %7 %18 %13 %9 %34 = OpVectorInsertDynamic %7 %18 %14 %10 %35 = OpVectorInsertDynamic %7 %18 %15 %11 %36 = OpVectorInsertDynamic %8 %19 %13 %9 %37 = OpVectorInsertDynamic %8 %19 %14 %10 %38 = OpVectorInsertDynamic %8 %19 %15 %11 %39 = OpVectorInsertDynamic %8 %19 %16 %12 OpReturn OpFunctionEnd )"; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(IsEqual(env, variant_shader, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_merge_blocks_test.cpp000066400000000000000000000612121475742701700300350ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_merge_blocks.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationMergeBlocksTest, BlockDoesNotExist) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %6 %6 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_FALSE(TransformationMergeBlocks(3).IsApplicable( context.get(), transformation_context)); ASSERT_FALSE(TransformationMergeBlocks(7).IsApplicable( context.get(), transformation_context)); } TEST(TransformationMergeBlocksTest, DoNotMergeFirstBlockHasMultipleSuccessors) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %7 = OpTypeBool %8 = OpConstantTrue %7 %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %10 None OpBranchConditional %8 %6 %9 %6 = OpLabel OpBranch %10 %9 = OpLabel OpBranch %10 %10 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_FALSE(TransformationMergeBlocks(6).IsApplicable( context.get(), transformation_context)); } TEST(TransformationMergeBlocksTest, DoNotMergeSecondBlockHasMultiplePredecessors) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %7 = OpTypeBool %8 = OpConstantTrue %7 %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %10 None OpBranchConditional %8 %6 %9 %6 = OpLabel OpBranch %10 %9 = OpLabel OpBranch %10 %10 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_FALSE(TransformationMergeBlocks(10).IsApplicable( context.get(), transformation_context)); } TEST(TransformationMergeBlocksTest, MergeWhenSecondBlockIsSelectionMerge) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %7 = OpTypeBool %8 = OpConstantTrue %7 %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %10 None OpBranchConditional %8 %6 %9 %6 = OpLabel OpBranch %11 %9 = OpLabel OpBranch %11 %11 = OpLabel OpBranch %10 %10 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationMergeBlocks transformation(10); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %7 = OpTypeBool %8 = OpConstantTrue %7 %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %11 None OpBranchConditional %8 %6 %9 %6 = OpLabel OpBranch %11 %9 = OpLabel OpBranch %11 %11 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationMergeBlocksTest, MergeWhenSecondBlockIsLoopMerge) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %7 = OpTypeBool %8 = OpConstantTrue %7 %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %12 = OpLabel OpBranch %5 %5 = OpLabel OpLoopMerge %10 %11 None OpBranch %6 %6 = OpLabel OpBranchConditional %8 %9 %11 %9 = OpLabel OpBranch %10 %11 = OpLabel OpBranch %5 %10 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationMergeBlocks transformation(10); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %7 = OpTypeBool %8 = OpConstantTrue %7 %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %12 = OpLabel OpBranch %5 %5 = OpLabel OpLoopMerge %9 %11 None OpBranch %6 %6 = OpLabel OpBranchConditional %8 %9 %11 %9 = OpLabel OpReturn %11 = OpLabel OpBranch %5 OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationMergeBlocksTest, MergeWhenSecondBlockIsLoopContinue) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %7 = OpTypeBool %8 = OpConstantTrue %7 %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %13 = OpLabel OpBranch %5 %5 = OpLabel OpLoopMerge %10 %11 None OpBranch %6 %6 = OpLabel OpSelectionMerge %9 None OpBranchConditional %8 %9 %12 %12 = OpLabel OpBranch %11 %11 = OpLabel OpBranch %5 %9 = OpLabel OpBranch %10 %10 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationMergeBlocks transformation(11); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %7 = OpTypeBool %8 = OpConstantTrue %7 %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %13 = OpLabel OpBranch %5 %5 = OpLabel OpLoopMerge %10 %12 None OpBranch %6 %6 = OpLabel OpSelectionMerge %9 None OpBranchConditional %8 %9 %12 %12 = OpLabel OpBranch %5 %9 = OpLabel OpBranch %10 %10 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationMergeBlocksTest, MergeWhenSecondBlockStartsWithOpPhi) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %7 = OpTypeBool %8 = OpUndef %7 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %6 %6 = OpLabel %9 = OpPhi %7 %8 %5 %10 = OpCopyObject %7 %9 OpBranch %11 %11 = OpLabel %12 = OpCopyObject %7 %9 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationMergeBlocks transformation(6); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %7 = OpTypeBool %8 = OpUndef %7 %4 = OpFunction %2 None %3 %5 = OpLabel %10 = OpCopyObject %7 %8 OpBranch %11 %11 = OpLabel %12 = OpCopyObject %7 %8 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationMergeBlocksTest, BasicMerge) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 2 %11 = OpConstant %6 3 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function OpStore %8 %9 OpBranch %100 %100 = OpLabel OpStore %10 %11 %12 = OpLoad %6 %10 %13 = OpLoad %6 %8 OpBranch %101 %101 = OpLabel %14 = OpIAdd %6 %13 %12 OpStore %8 %14 %15 = OpLoad %6 %8 OpBranch %102 %102 = OpLabel %16 = OpLoad %6 %10 %17 = OpIMul %6 %16 %15 OpBranch %103 %103 = OpLabel OpStore %10 %17 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); for (auto& transformation : {TransformationMergeBlocks(100), TransformationMergeBlocks(101), TransformationMergeBlocks(102), TransformationMergeBlocks(103)}) { ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 2 %11 = OpConstant %6 3 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function OpStore %8 %9 OpStore %10 %11 %12 = OpLoad %6 %10 %13 = OpLoad %6 %8 %14 = OpIAdd %6 %13 %12 OpStore %8 %14 %15 = OpLoad %6 %8 %16 = OpLoad %6 %10 %17 = OpIMul %6 %16 %15 OpStore %10 %17 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationMergeBlocksTest, MergeWhenSecondBlockIsSelectionHeader) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 2 %11 = OpConstant %6 3 %50 = OpTypeBool %51 = OpConstantTrue %50 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function OpStore %8 %9 OpBranch %100 %100 = OpLabel OpStore %10 %11 %12 = OpLoad %6 %10 %13 = OpLoad %6 %8 OpBranch %101 %101 = OpLabel OpSelectionMerge %103 None OpBranchConditional %51 %102 %103 %102 = OpLabel %14 = OpIAdd %6 %13 %12 OpStore %8 %14 OpBranch %103 %103 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); for (auto& transformation : {TransformationMergeBlocks(101), TransformationMergeBlocks(100)}) { ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 2 %11 = OpConstant %6 3 %50 = OpTypeBool %51 = OpConstantTrue %50 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function OpStore %8 %9 OpStore %10 %11 %12 = OpLoad %6 %10 %13 = OpLoad %6 %8 OpSelectionMerge %103 None OpBranchConditional %51 %102 %103 %102 = OpLabel %14 = OpIAdd %6 %13 %12 OpStore %8 %14 OpBranch %103 %103 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationMergeBlocksTest, MergeWhenFirstBlockIsLoopMergeFollowedByUnconditionalBranch) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 2 %11 = OpConstant %6 3 %50 = OpTypeBool %51 = OpConstantTrue %50 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function OpStore %8 %9 OpBranch %100 %100 = OpLabel OpLoopMerge %102 %103 None OpBranch %101 %101 = OpLabel %200 = OpCopyObject %6 %9 OpBranchConditional %51 %102 %103 %103 = OpLabel OpBranch %100 %102 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationMergeBlocks transformation(101); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 2 %11 = OpConstant %6 3 %50 = OpTypeBool %51 = OpConstantTrue %50 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function OpStore %8 %9 OpBranch %100 %100 = OpLabel %200 = OpCopyObject %6 %9 OpLoopMerge %102 %103 None OpBranchConditional %51 %102 %103 %103 = OpLabel OpBranch %100 %102 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_merge_function_returns_test.cpp000066400000000000000000002057251475742701700322000ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_merge_function_returns.h" #include "gtest/gtest.h" #include "source/fuzz/counter_overflow_id_source.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { protobufs::ReturnMergingInfo MakeReturnMergingInfo( uint32_t merge_block_id, uint32_t is_returning_id, uint32_t maybe_return_val_id, const std::map& opphi_to_suitable_id) { protobufs::ReturnMergingInfo result; result.set_merge_block_id(merge_block_id); result.set_is_returning_id(is_returning_id); result.set_maybe_return_val_id(maybe_return_val_id); *result.mutable_opphi_to_suitable_id() = fuzzerutil::MapToRepeatedUInt32Pair(opphi_to_suitable_id); return result; } TEST(TransformationMergeFunctionReturnsTest, SimpleInapplicable) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypeFunction %5 %7 = OpTypeFloat 32 %8 = OpTypeFunction %7 %9 = OpTypeBool %10 = OpConstantTrue %9 %11 = OpConstantFalse %9 %12 = OpConstant %5 0 %13 = OpConstant %5 1 %2 = OpFunction %3 None %4 %14 = OpLabel %15 = OpFunctionCall %3 %16 %17 = OpFunctionCall %3 %18 %19 = OpFunctionCall %3 %20 %21 = OpFunctionCall %7 %22 OpReturn OpFunctionEnd %16 = OpFunction %3 None %4 %23 = OpLabel OpSelectionMerge %24 None OpBranchConditional %10 %25 %26 %25 = OpLabel OpReturn %26 = OpLabel OpReturn %24 = OpLabel OpUnreachable OpFunctionEnd %18 = OpFunction %3 None %4 %27 = OpLabel OpBranch %28 %28 = OpLabel OpLoopMerge %29 %30 None OpBranch %31 %31 = OpLabel OpBranchConditional %10 %32 %29 %32 = OpLabel OpReturn %30 = OpLabel OpBranch %28 %29 = OpLabel OpReturn OpFunctionEnd %20 = OpFunction %3 None %4 %33 = OpLabel OpBranch %34 %34 = OpLabel OpLoopMerge %35 %36 None OpBranch %37 %37 = OpLabel OpBranchConditional %10 %38 %35 %38 = OpLabel OpReturn %36 = OpLabel OpBranch %34 %35 = OpLabel %39 = OpFunctionCall %3 %18 OpReturn OpFunctionEnd %22 = OpFunction %7 None %8 %40 = OpLabel OpBranch %51 %51 = OpLabel OpLoopMerge %41 %53 None OpBranchConditional %10 %42 %41 %42 = OpLabel %43 = OpConvertSToF %7 %12 OpReturnValue %43 %41 = OpLabel %44 = OpConvertSToF %7 %13 OpReturnValue %44 %53 = OpLabel OpBranch %51 OpFunctionEnd %45 = OpFunction %5 None %6 %46 = OpLabel OpBranch %52 %52 = OpLabel %47 = OpConvertSToF %7 %13 OpLoopMerge %48 %54 None OpBranchConditional %10 %49 %48 %49 = OpLabel OpReturnValue %12 %48 = OpLabel %50 = OpCopyObject %5 %12 OpReturnValue %13 %54 = OpLabel OpBranch %52 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Function %1 does not exist. ASSERT_FALSE(TransformationMergeFunctionReturns(1, 100, 200, 101, 0, 0, {{}}) .IsApplicable(context.get(), transformation_context)); // The entry block (%22) of function %15 does not branch unconditionally to // the following block. ASSERT_FALSE(TransformationMergeFunctionReturns(16, 100, 200, 101, 0, 0, {{}}) .IsApplicable(context.get(), transformation_context)); // Block %28 is the merge block of a loop containing a return instruction, but // it contains an OpReturn instruction (so, it contains instructions that are // not OpLabel, OpPhi or OpBranch). ASSERT_FALSE( TransformationMergeFunctionReturns( 18, 100, 200, 101, 0, 0, {{MakeReturnMergingInfo(29, 102, 0, {{}})}}) .IsApplicable(context.get(), transformation_context)); // Block %34 is the merge block of a loop containing a return instruction, but // it contains an OpFunctionCall instruction (so, it contains instructions // that are not OpLabel, OpPhi or OpBranch). ASSERT_FALSE( TransformationMergeFunctionReturns( 20, 100, 200, 101, 0, 0, {{MakeReturnMergingInfo(35, 102, 0, {{}})}}) .IsApplicable(context.get(), transformation_context)); // Id %1000 cannot be found in the module and there is no id of the correct // type (float) available at the end of the entry block of function %21. ASSERT_FALSE( TransformationMergeFunctionReturns(22, 100, 200, 101, 102, 1000, {{}}) .IsApplicable(context.get(), transformation_context)); // Id %47 is of type float, while function %45 has return type int. ASSERT_FALSE( TransformationMergeFunctionReturns(45, 100, 200, 101, 102, 47, {{}}) .IsApplicable(context.get(), transformation_context)); // Id %50 is not available at the end of the entry block of function %45. ASSERT_FALSE( TransformationMergeFunctionReturns(45, 100, 200, 101, 102, 50, {{}}) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationMergeFunctionReturnsTest, MissingBooleans) { { // OpConstantTrue is missing. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" OpName %3 "A(" OpDecorate %3 RelaxedPrecision OpDecorate %4 RelaxedPrecision %5 = OpTypeVoid %6 = OpTypeFunction %5 %7 = OpTypeInt 32 1 %8 = OpTypeFunction %7 %9 = OpTypeBool %10 = OpConstantFalse %9 %11 = OpConstant %7 1 %12 = OpConstant %7 2 %2 = OpFunction %5 None %6 %13 = OpLabel %4 = OpFunctionCall %7 %3 OpReturn OpFunctionEnd %3 = OpFunction %7 None %8 %14 = OpLabel OpBranch %15 %15 = OpLabel OpSelectionMerge %16 None OpBranchConditional %10 %17 %16 %17 = OpLabel OpReturnValue %11 %16 = OpLabel OpReturnValue %12 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_FALSE( TransformationMergeFunctionReturns(3, 100, 200, 101, 0, 0, {{}}) .IsApplicable(context.get(), transformation_context)); } { // OpConstantFalse is missing. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" OpName %3 "A(" OpDecorate %3 RelaxedPrecision OpDecorate %4 RelaxedPrecision %5 = OpTypeVoid %6 = OpTypeFunction %5 %7 = OpTypeInt 32 1 %8 = OpTypeFunction %7 %9 = OpTypeBool %10 = OpConstantTrue %9 %11 = OpConstant %7 1 %12 = OpConstant %7 2 %2 = OpFunction %5 None %6 %13 = OpLabel %4 = OpFunctionCall %7 %3 OpReturn OpFunctionEnd %3 = OpFunction %7 None %8 %14 = OpLabel OpBranch %15 %15 = OpLabel OpSelectionMerge %16 None OpBranchConditional %10 %17 %16 %17 = OpLabel OpReturnValue %11 %16 = OpLabel OpReturnValue %12 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_FALSE( TransformationMergeFunctionReturns(3, 100, 200, 101, 0, 0, {{}}) .IsApplicable(context.get(), transformation_context)); } } TEST(TransformationMergeFunctionReturnsTest, InvalidIds) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypeFunction %5 %42 = OpTypeFloat 32 %7 = OpTypeBool %8 = OpConstantTrue %7 %9 = OpConstantFalse %7 %10 = OpConstant %5 0 %11 = OpConstant %5 1 %2 = OpFunction %3 None %4 %12 = OpLabel %13 = OpFunctionCall %5 %14 %15 = OpFunctionCall %3 %16 OpReturn OpFunctionEnd %17 = OpFunction %3 None %4 %18 = OpLabel OpBranch %19 %19 = OpLabel OpLoopMerge %20 %21 None OpBranch %22 %22 = OpLabel OpBranchConditional %8 %23 %20 %23 = OpLabel OpReturn %21 = OpLabel OpBranch %19 %20 = OpLabel OpBranch %24 %24 = OpLabel OpReturn OpFunctionEnd %14 = OpFunction %5 None %6 %25 = OpLabel OpBranch %26 %26 = OpLabel OpLoopMerge %27 %28 None OpBranch %29 %29 = OpLabel OpBranchConditional %8 %30 %27 %30 = OpLabel OpReturnValue %10 %28 = OpLabel OpBranch %26 %27 = OpLabel OpBranch %33 %33 = OpLabel OpReturnValue %11 OpFunctionEnd %16 = OpFunction %3 None %4 %34 = OpLabel OpBranch %35 %35 = OpLabel OpLoopMerge %36 %37 None OpBranch %38 %38 = OpLabel %43 = OpConvertSToF %42 %10 OpBranchConditional %8 %39 %36 %39 = OpLabel OpReturn %37 = OpLabel %44 = OpConvertSToF %42 %10 OpBranch %35 %36 = OpLabel %31 = OpPhi %42 %43 %38 %32 = OpPhi %5 %11 %38 OpBranch %40 %40 = OpLabel %41 = OpFunctionCall %3 %17 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Fresh id %100 is used twice. ASSERT_FALSE( TransformationMergeFunctionReturns( 17, 100, 200, 100, 0, 0, {{MakeReturnMergingInfo(20, 101, 0, {{}})}}) .IsApplicable(context.get(), transformation_context)); // Fresh id %100 is used twice. ASSERT_FALSE( TransformationMergeFunctionReturns( 17, 100, 200, 101, 0, 0, {{MakeReturnMergingInfo(20, 100, 0, {{}})}}) .IsApplicable(context.get(), transformation_context)); // %0 cannot be a fresh id for the new merge block. ASSERT_FALSE( TransformationMergeFunctionReturns( 17, 100, 200, 0, 0, 0, {{MakeReturnMergingInfo(20, 101, 0, {{}})}}) .IsApplicable(context.get(), transformation_context)); // %0 cannot be a fresh id for the new continue block. ASSERT_FALSE( TransformationMergeFunctionReturns( 17, 100, 0, 200, 0, 0, {{MakeReturnMergingInfo(20, 101, 0, {{}})}}) .IsApplicable(context.get(), transformation_context)); // %0 cannot be a fresh id for the new header block. ASSERT_FALSE( TransformationMergeFunctionReturns( 17, 0, 200, 100, 0, 0, {{MakeReturnMergingInfo(20, 101, 0, {{}})}}) .IsApplicable(context.get(), transformation_context)); // %0 cannot be a fresh id for the new |is_returning| instruction in an // existing merge block. ASSERT_FALSE( TransformationMergeFunctionReturns( 17, 100, 200, 101, 0, 0, {{MakeReturnMergingInfo(20, 0, 0, {{}})}}) .IsApplicable(context.get(), transformation_context)); // %0 cannot be a fresh id for the new |return_val| instruction in the new // return block. ASSERT_FALSE(TransformationMergeFunctionReturns( 14, 100, 200, 101, 0, 10, {{MakeReturnMergingInfo(27, 102, 103, {{}})}}) .IsApplicable(context.get(), transformation_context)); // %0 cannot be a fresh id for the new |maybe_return_val| instruction in an // existing merge block, inside a non-void function. ASSERT_FALSE(TransformationMergeFunctionReturns( 14, 100, 200, 101, 102, 10, {{MakeReturnMergingInfo(27, 103, 0, {{}})}}) .IsApplicable(context.get(), transformation_context)); // Fresh id %102 is repeated. ASSERT_FALSE(TransformationMergeFunctionReturns( 14, 100, 200, 101, 102, 10, {{MakeReturnMergingInfo(27, 102, 104, {{}})}}) .IsApplicable(context.get(), transformation_context)); // Id %11 (type int) does not have the correct type (float) for OpPhi // instruction %31. ASSERT_FALSE( TransformationMergeFunctionReturns( 16, 100, 200, 101, 0, 0, {{MakeReturnMergingInfo(36, 103, 104, {{{31, 11}, {32, 11}}})}}) .IsApplicable(context.get(), transformation_context)); // Id %11 (type int) does not have the correct type (float) for OpPhi // instruction %31. ASSERT_FALSE( TransformationMergeFunctionReturns( 16, 100, 200, 101, 0, 0, {{MakeReturnMergingInfo(36, 102, 0, {{{31, 11}, {32, 11}}})}}) .IsApplicable(context.get(), transformation_context)); // Id %43 is not available at the end of the entry block. ASSERT_FALSE( TransformationMergeFunctionReturns( 16, 100, 200, 101, 0, 0, {{MakeReturnMergingInfo(36, 102, 0, {{{31, 44}, {32, 11}}})}}) .IsApplicable(context.get(), transformation_context)); // There is not a mapping for id %31 (float OpPhi instruction in a loop merge // block) and no suitable id is available at the end of the entry block. ASSERT_FALSE(TransformationMergeFunctionReturns( 16, 100, 200, 101, 0, 0, {{MakeReturnMergingInfo(36, 102, 0, {{{32, 11}}})}}) .IsApplicable(context.get(), transformation_context)); // Id %1000 cannot be found in the module and no suitable id for OpPhi %31 is // available at the end of the entry block. ASSERT_FALSE( TransformationMergeFunctionReturns( 16, 100, 200, 101, 0, 0, {{MakeReturnMergingInfo(36, 102, 0, {{{31, 1000}, {32, 11}}})}}) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationMergeFunctionReturnsTest, Simple) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypeFunction %5 %7 = OpTypeFloat 32 %8 = OpTypeFunction %7 %7 %9 = OpTypeFunction %7 %10 = OpTypeBool %11 = OpConstantTrue %10 %40 = OpConstantFalse %10 %12 = OpConstant %5 1 %2 = OpFunction %3 None %4 %13 = OpLabel OpReturn OpFunctionEnd %14 = OpFunction %3 None %4 %15 = OpLabel OpBranch %16 %16 = OpLabel OpSelectionMerge %17 None OpBranchConditional %11 %18 %17 %18 = OpLabel OpReturn %17 = OpLabel OpReturn OpFunctionEnd %19 = OpFunction %5 None %6 %20 = OpLabel OpBranch %21 %21 = OpLabel OpSelectionMerge %22 None OpBranchConditional %11 %23 %24 %23 = OpLabel OpReturnValue %12 %24 = OpLabel %25 = OpIAdd %5 %12 %12 OpReturnValue %25 %22 = OpLabel OpUnreachable OpFunctionEnd %26 = OpFunction %7 None %8 %27 = OpFunctionParameter %7 %28 = OpLabel OpBranch %29 %29 = OpLabel OpSelectionMerge %30 None OpBranchConditional %11 %31 %30 %31 = OpLabel %32 = OpFAdd %7 %27 %27 OpReturnValue %32 %30 = OpLabel OpReturnValue %27 OpFunctionEnd %33 = OpFunction %7 None %9 %34 = OpLabel %35 = OpConvertSToF %7 %12 OpBranch %36 %36 = OpLabel OpSelectionMerge %37 None OpBranchConditional %11 %38 %37 %38 = OpLabel %39 = OpFAdd %7 %35 %35 OpReturnValue %39 %37 = OpLabel OpReturnValue %35 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // The 0s are allowed because the function's return type is void. auto transformation1 = TransformationMergeFunctionReturns(14, 100, 200, 101, 0, 0, {{}}); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // %12 is available at the end of the entry block of %19 (it is a global // variable). ASSERT_TRUE( TransformationMergeFunctionReturns(19, 110, 210, 111, 112, 12, {{}}) .IsApplicable(context.get(), transformation_context)); // %1000 cannot be found in the module, but there is a suitable id available // at the end of the entry block (%12). auto transformation2 = TransformationMergeFunctionReturns(19, 110, 210, 111, 112, 1000, {{}}); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // %27 is available at the end of the entry block of %26 (it is a function // parameter). ASSERT_TRUE( TransformationMergeFunctionReturns(26, 120, 220, 121, 122, 27, {{}}) .IsApplicable(context.get(), transformation_context)); // %1000 cannot be found in the module, but there is a suitable id available // at the end of the entry block (%27). auto transformation3 = TransformationMergeFunctionReturns(26, 120, 220, 121, 122, 1000, {{}}); ASSERT_TRUE( transformation3.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation3, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // %35 is available at the end of the entry block of %33 (it is in the entry // block). ASSERT_TRUE( TransformationMergeFunctionReturns(26, 130, 230, 131, 132, 27, {{}}) .IsApplicable(context.get(), transformation_context)); // %1000 cannot be found in the module, but there is a suitable id available // at the end of the entry block (%35). auto transformation4 = TransformationMergeFunctionReturns(33, 130, 230, 131, 132, 1000, {{}}); ASSERT_TRUE( transformation4.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation4, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformations = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypeFunction %5 %7 = OpTypeFloat 32 %8 = OpTypeFunction %7 %7 %9 = OpTypeFunction %7 %10 = OpTypeBool %11 = OpConstantTrue %10 %40 = OpConstantFalse %10 %12 = OpConstant %5 1 %2 = OpFunction %3 None %4 %13 = OpLabel OpReturn OpFunctionEnd %14 = OpFunction %3 None %4 %15 = OpLabel OpBranch %100 %100 = OpLabel OpLoopMerge %101 %200 None OpBranch %16 %16 = OpLabel OpSelectionMerge %17 None OpBranchConditional %11 %18 %17 %18 = OpLabel OpBranch %101 %17 = OpLabel OpBranch %101 %101 = OpLabel OpReturn %200 = OpLabel OpBranch %100 OpFunctionEnd %19 = OpFunction %5 None %6 %20 = OpLabel OpBranch %110 %110 = OpLabel OpLoopMerge %111 %210 None OpBranch %21 %21 = OpLabel OpSelectionMerge %22 None OpBranchConditional %11 %23 %24 %23 = OpLabel OpBranch %111 %24 = OpLabel %25 = OpIAdd %5 %12 %12 OpBranch %111 %22 = OpLabel OpUnreachable %111 = OpLabel %112 = OpPhi %5 %12 %23 %25 %24 OpReturnValue %112 %210 = OpLabel OpBranch %110 OpFunctionEnd %26 = OpFunction %7 None %8 %27 = OpFunctionParameter %7 %28 = OpLabel OpBranch %120 %120 = OpLabel OpLoopMerge %121 %220 None OpBranch %29 %29 = OpLabel OpSelectionMerge %30 None OpBranchConditional %11 %31 %30 %31 = OpLabel %32 = OpFAdd %7 %27 %27 OpBranch %121 %30 = OpLabel OpBranch %121 %121 = OpLabel %122 = OpPhi %7 %27 %30 %32 %31 OpReturnValue %122 %220 = OpLabel OpBranch %120 OpFunctionEnd %33 = OpFunction %7 None %9 %34 = OpLabel %35 = OpConvertSToF %7 %12 OpBranch %130 %130 = OpLabel OpLoopMerge %131 %230 None OpBranch %36 %36 = OpLabel OpSelectionMerge %37 None OpBranchConditional %11 %38 %37 %38 = OpLabel %39 = OpFAdd %7 %35 %35 OpBranch %131 %37 = OpLabel OpBranch %131 %131 = OpLabel %132 = OpPhi %7 %35 %37 %39 %38 OpReturnValue %132 %230 = OpLabel OpBranch %130 OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformations, context.get())); } TEST(TransformationMergeFunctionReturnsTest, NestedLoops) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypeFunction %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %9 = OpConstantFalse %7 %10 = OpConstant %5 2 %11 = OpConstant %5 1 %12 = OpConstant %5 3 %2 = OpFunction %3 None %4 %13 = OpLabel OpReturn OpFunctionEnd %14 = OpFunction %5 None %6 %15 = OpLabel OpBranch %16 %16 = OpLabel OpLoopMerge %17 %916 None OpBranch %18 %18 = OpLabel OpLoopMerge %19 %20 None OpBranchConditional %8 %19 %21 %19 = OpLabel OpBranch %17 %21 = OpLabel OpReturnValue %12 %17 = OpLabel OpBranch %22 %20 = OpLabel OpBranch %18 %22 = OpLabel OpLoopMerge %23 %24 None OpBranch %25 %25 = OpLabel OpBranchConditional %8 %26 %23 %26 = OpLabel OpSelectionMerge %27 None OpBranchConditional %9 %28 %27 %28 = OpLabel OpBranch %29 %29 = OpLabel OpLoopMerge %30 %929 None OpBranch %30 %30 = OpLabel OpLoopMerge %31 %32 None OpBranch %33 %33 = OpLabel OpBranchConditional %9 %34 %31 %34 = OpLabel OpReturnValue %10 %32 = OpLabel OpBranch %30 %31 = OpLabel %35 = OpPhi %5 %11 %33 %36 = OpPhi %5 %10 %33 OpBranch %37 %37 = OpLabel OpReturnValue %35 %27 = OpLabel OpBranch %24 %24 = OpLabel OpBranch %22 %23 = OpLabel OpBranch %38 %38 = OpLabel OpReturnValue %12 %916 = OpLabel OpBranch %16 %929 = OpLabel OpBranch %29 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto transformation = TransformationMergeFunctionReturns( 14, 100, 200, 101, 102, 11, {{MakeReturnMergingInfo(19, 103, 104, {{}}), MakeReturnMergingInfo(17, 105, 106, {{}}), MakeReturnMergingInfo(31, 107, 108, {{{35, 10}, {36, 12}}}), MakeReturnMergingInfo(23, 109, 110, {})}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypeFunction %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %9 = OpConstantFalse %7 %10 = OpConstant %5 2 %11 = OpConstant %5 1 %12 = OpConstant %5 3 %2 = OpFunction %3 None %4 %13 = OpLabel OpReturn OpFunctionEnd %14 = OpFunction %5 None %6 %15 = OpLabel OpBranch %100 %100 = OpLabel OpLoopMerge %101 %200 None OpBranch %16 %16 = OpLabel OpLoopMerge %17 %916 None OpBranch %18 %18 = OpLabel OpLoopMerge %19 %20 None OpBranchConditional %8 %19 %21 %19 = OpLabel %103 = OpPhi %7 %8 %21 %9 %18 %104 = OpPhi %5 %12 %21 %11 %18 OpBranch %17 %21 = OpLabel OpBranch %19 %17 = OpLabel %105 = OpPhi %7 %103 %19 %106 = OpPhi %5 %104 %19 OpBranchConditional %105 %101 %22 %20 = OpLabel OpBranch %18 %22 = OpLabel OpLoopMerge %23 %24 None OpBranch %25 %25 = OpLabel OpBranchConditional %8 %26 %23 %26 = OpLabel OpSelectionMerge %27 None OpBranchConditional %9 %28 %27 %28 = OpLabel OpBranch %29 %29 = OpLabel OpLoopMerge %30 %929 None OpBranch %30 %30 = OpLabel OpLoopMerge %31 %32 None OpBranch %33 %33 = OpLabel OpBranchConditional %9 %34 %31 %34 = OpLabel OpBranch %31 %32 = OpLabel OpBranch %30 %31 = OpLabel %107 = OpPhi %7 %8 %34 %9 %33 %108 = OpPhi %5 %10 %34 %11 %33 %35 = OpPhi %5 %11 %33 %10 %34 %36 = OpPhi %5 %10 %33 %12 %34 OpBranchConditional %107 %23 %37 %37 = OpLabel OpBranch %23 %27 = OpLabel OpBranch %24 %24 = OpLabel OpBranch %22 %23 = OpLabel %109 = OpPhi %7 %107 %31 %8 %37 %9 %25 %110 = OpPhi %5 %108 %31 %35 %37 %11 %25 OpBranchConditional %109 %101 %38 %38 = OpLabel OpBranch %101 %916 = OpLabel OpBranch %16 %929 = OpLabel OpBranch %29 %101 = OpLabel %102 = OpPhi %5 %106 %17 %110 %23 %12 %38 OpReturnValue %102 %200 = OpLabel OpBranch %100 OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationMergeFunctionReturnsTest, OverflowIds) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypeFunction %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %9 = OpConstantFalse %7 %10 = OpConstant %5 1 %2 = OpFunction %3 None %4 %11 = OpLabel OpReturn OpFunctionEnd %12 = OpFunction %5 None %6 %13 = OpLabel OpBranch %14 %14 = OpLabel %15 = OpIAdd %5 %10 %10 OpLoopMerge %16 %17 None OpBranch %18 %18 = OpLabel OpBranchConditional %8 %19 %16 %19 = OpLabel OpSelectionMerge %20 None OpBranchConditional %9 %21 %20 %21 = OpLabel OpReturnValue %10 %20 = OpLabel OpBranch %17 %17 = OpLabel OpBranchConditional %8 %14 %16 %16 = OpLabel %22 = OpPhi %5 %15 %17 %10 %18 OpBranch %23 %23 = OpLabel OpReturnValue %22 OpFunctionEnd %24 = OpFunction %3 None %4 %25 = OpLabel OpBranch %26 %26 = OpLabel OpLoopMerge %27 %28 None OpBranch %29 %29 = OpLabel OpBranchConditional %8 %30 %27 %30 = OpLabel OpSelectionMerge %31 None OpBranchConditional %9 %32 %31 %32 = OpLabel OpReturn %31 = OpLabel OpBranch %28 %28 = OpLabel OpBranch %26 %27 = OpLabel %33 = OpPhi %5 %10 %29 OpBranch %34 %34 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto overflow_ids_unique_ptr = MakeUnique(1000); auto overflow_ids_ptr = overflow_ids_unique_ptr.get(); TransformationContext transformation_context_with_overflow_ids( MakeUnique(context.get()), validator_options, std::move(overflow_ids_unique_ptr)); // No mapping from merge block %16 to fresh ids is given, so overflow ids are // needed. auto transformation1 = TransformationMergeFunctionReturns(12, 100, 200, 101, 102, 10, {{}}); #ifndef NDEBUG ASSERT_DEATH( transformation1.IsApplicable(context.get(), transformation_context), "Bad attempt to query whether overflow ids are available."); #endif ASSERT_TRUE(transformation1.IsApplicable( context.get(), transformation_context_with_overflow_ids)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context_with_overflow_ids, overflow_ids_ptr->GetIssuedOverflowIds()); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // No mapping from merge block %27 to fresh ids is given, so overflow ids are // needed. auto transformation2 = TransformationMergeFunctionReturns(24, 110, 210, 111, 0, 0, {{}}); #ifndef NDEBUG ASSERT_DEATH( transformation2.IsApplicable(context.get(), transformation_context), "Bad attempt to query whether overflow ids are available."); #endif ASSERT_TRUE(transformation2.IsApplicable( context.get(), transformation_context_with_overflow_ids)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context_with_overflow_ids, {1002}); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformations = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypeFunction %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %9 = OpConstantFalse %7 %10 = OpConstant %5 1 %2 = OpFunction %3 None %4 %11 = OpLabel OpReturn OpFunctionEnd %12 = OpFunction %5 None %6 %13 = OpLabel OpBranch %100 %100 = OpLabel OpLoopMerge %101 %200 None OpBranch %14 %14 = OpLabel %15 = OpIAdd %5 %10 %10 OpLoopMerge %16 %17 None OpBranch %18 %18 = OpLabel OpBranchConditional %8 %19 %16 %19 = OpLabel OpSelectionMerge %20 None OpBranchConditional %9 %21 %20 %21 = OpLabel OpBranch %16 %20 = OpLabel OpBranch %17 %17 = OpLabel OpBranchConditional %8 %14 %16 %16 = OpLabel %1000 = OpPhi %7 %8 %21 %9 %17 %9 %18 %1001 = OpPhi %5 %10 %21 %10 %17 %10 %18 %22 = OpPhi %5 %15 %17 %10 %18 %10 %21 OpBranchConditional %1000 %101 %23 %23 = OpLabel OpBranch %101 %101 = OpLabel %102 = OpPhi %5 %1001 %16 %22 %23 OpReturnValue %102 %200 = OpLabel OpBranch %100 OpFunctionEnd %24 = OpFunction %3 None %4 %25 = OpLabel OpBranch %110 %110 = OpLabel OpLoopMerge %111 %210 None OpBranch %26 %26 = OpLabel OpLoopMerge %27 %28 None OpBranch %29 %29 = OpLabel OpBranchConditional %8 %30 %27 %30 = OpLabel OpSelectionMerge %31 None OpBranchConditional %9 %32 %31 %32 = OpLabel OpBranch %27 %31 = OpLabel OpBranch %28 %28 = OpLabel OpBranch %26 %27 = OpLabel %1002 = OpPhi %7 %8 %32 %9 %29 %33 = OpPhi %5 %10 %29 %10 %32 OpBranchConditional %1002 %111 %34 %34 = OpLabel OpBranch %111 %111 = OpLabel OpReturn %210 = OpLabel OpBranch %110 OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformations, context.get())); } TEST(TransformationMergeFunctionReturnsTest, MissingIdsForOpPhi) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpConstantFalse %5 %8 = OpTypeInt 32 1 %9 = OpTypeFunction %3 %8 %10 = OpTypeFloat 32 %2 = OpFunction %3 None %4 %11 = OpLabel OpReturn OpFunctionEnd %12 = OpFunction %3 None %9 %13 = OpFunctionParameter %8 %14 = OpLabel %15 = OpConvertSToF %10 %13 OpBranch %16 %16 = OpLabel OpLoopMerge %17 %18 None OpBranch %19 %19 = OpLabel OpBranchConditional %6 %20 %17 %20 = OpLabel OpSelectionMerge %21 None OpBranchConditional %7 %22 %21 %22 = OpLabel OpReturn %21 = OpLabel OpBranch %18 %18 = OpLabel OpBranch %16 %17 = OpLabel %23 = OpPhi %8 %13 %19 %24 = OpPhi %10 %15 %19 %25 = OpPhi %5 %6 %19 OpBranch %26 %26 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // This test checks whether the transformation is able to find suitable ids // to use in existing OpPhi instructions if they are not provided in the // corresponding mapping. auto transformation = TransformationMergeFunctionReturns( 12, 101, 200, 102, 0, 0, {{MakeReturnMergingInfo(17, 103, 0, {{{25, 7}, {35, 8}}})}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpConstantFalse %5 %8 = OpTypeInt 32 1 %9 = OpTypeFunction %3 %8 %10 = OpTypeFloat 32 %2 = OpFunction %3 None %4 %11 = OpLabel OpReturn OpFunctionEnd %12 = OpFunction %3 None %9 %13 = OpFunctionParameter %8 %14 = OpLabel %15 = OpConvertSToF %10 %13 OpBranch %101 %101 = OpLabel OpLoopMerge %102 %200 None OpBranch %16 %16 = OpLabel OpLoopMerge %17 %18 None OpBranch %19 %19 = OpLabel OpBranchConditional %6 %20 %17 %20 = OpLabel OpSelectionMerge %21 None OpBranchConditional %7 %22 %21 %22 = OpLabel OpBranch %17 %21 = OpLabel OpBranch %18 %18 = OpLabel OpBranch %16 %17 = OpLabel %103 = OpPhi %5 %6 %22 %7 %19 %23 = OpPhi %8 %13 %19 %13 %22 %24 = OpPhi %10 %15 %19 %15 %22 %25 = OpPhi %5 %6 %19 %7 %22 OpBranchConditional %103 %102 %26 %26 = OpLabel OpBranch %102 %102 = OpLabel OpReturn %200 = OpLabel OpBranch %101 OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationMergeFunctionReturnsTest, RespectDominanceRules1) { // An id defined in a loop is used in the corresponding merge block. After the // transformation, the id will not dominate the merge block anymore. This is // only OK if the use is inside an OpPhi instruction. (Note that there is also // another condition for this transformation that forbids non-OpPhi // instructions in relevant merge blocks, but that case is also considered // here for completeness). std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpConstantFalse %5 %2 = OpFunction %3 None %4 %8 = OpLabel OpBranch %9 %9 = OpLabel OpLoopMerge %10 %11 None OpBranch %12 %12 = OpLabel OpSelectionMerge %13 None OpBranchConditional %7 %13 %14 %14 = OpLabel OpReturn %13 = OpLabel %15 = OpCopyObject %5 %7 OpBranch %11 %11 = OpLabel OpBranchConditional %7 %9 %10 %10 = OpLabel %16 = OpCopyObject %5 %15 OpBranch %17 %17 = OpLabel OpReturn OpFunctionEnd %18 = OpFunction %3 None %4 %19 = OpLabel OpBranch %20 %20 = OpLabel OpLoopMerge %21 %22 None OpBranch %23 %23 = OpLabel OpSelectionMerge %24 None OpBranchConditional %7 %24 %25 %25 = OpLabel OpReturn %24 = OpLabel %26 = OpCopyObject %5 %7 OpBranch %22 %22 = OpLabel OpBranchConditional %7 %20 %21 %21 = OpLabel %27 = OpPhi %5 %26 %22 OpBranch %28 %28 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // In function %2, the definition of id %15 will not dominate its use in // instruction %16 (inside merge block %10) after a new branch from return // block %14 is added. ASSERT_FALSE( TransformationMergeFunctionReturns( 2, 100, 200, 101, 0, 0, {{MakeReturnMergingInfo(10, 102, 103, {{}})}}) .IsApplicable(context.get(), transformation_context)); // In function %18, The definition of id %26 will still dominate its use in // instruction %27 (inside merge block %21), because %27 is an OpPhi // instruction. auto transformation = TransformationMergeFunctionReturns( 18, 100, 200, 101, 0, 0, {{MakeReturnMergingInfo(21, 102, 103, {{}})}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpConstantFalse %5 %2 = OpFunction %3 None %4 %8 = OpLabel OpBranch %9 %9 = OpLabel OpLoopMerge %10 %11 None OpBranch %12 %12 = OpLabel OpSelectionMerge %13 None OpBranchConditional %7 %13 %14 %14 = OpLabel OpReturn %13 = OpLabel %15 = OpCopyObject %5 %7 OpBranch %11 %11 = OpLabel OpBranchConditional %7 %9 %10 %10 = OpLabel %16 = OpCopyObject %5 %15 OpBranch %17 %17 = OpLabel OpReturn OpFunctionEnd %18 = OpFunction %3 None %4 %19 = OpLabel OpBranch %100 %100 = OpLabel OpLoopMerge %101 %200 None OpBranch %20 %20 = OpLabel OpLoopMerge %21 %22 None OpBranch %23 %23 = OpLabel OpSelectionMerge %24 None OpBranchConditional %7 %24 %25 %25 = OpLabel OpBranch %21 %24 = OpLabel %26 = OpCopyObject %5 %7 OpBranch %22 %22 = OpLabel OpBranchConditional %7 %20 %21 %21 = OpLabel %102 = OpPhi %5 %6 %25 %7 %22 %27 = OpPhi %5 %26 %22 %6 %25 OpBranchConditional %102 %101 %28 %28 = OpLabel OpBranch %101 %101 = OpLabel OpReturn %200 = OpLabel OpBranch %100 OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationMergeFunctionReturnsTest, RespectDominanceRules2) { // An id defined in a loop is used after the corresponding merge block. After // the transformation, the id will not dominate its use anymore, regardless of // the kind of instruction in which it is used. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpConstantFalse %5 %2 = OpFunction %3 None %4 %8 = OpLabel OpBranch %9 %9 = OpLabel OpLoopMerge %10 %11 None OpBranch %12 %12 = OpLabel OpSelectionMerge %13 None OpBranchConditional %7 %13 %14 %14 = OpLabel OpReturn %13 = OpLabel %15 = OpCopyObject %5 %7 OpBranch %11 %11 = OpLabel OpBranchConditional %7 %9 %10 %10 = OpLabel OpBranch %16 %16 = OpLabel %17 = OpCopyObject %5 %15 OpReturn OpFunctionEnd %18 = OpFunction %3 None %4 %19 = OpLabel OpBranch %20 %20 = OpLabel OpLoopMerge %21 %22 None OpBranch %23 %23 = OpLabel OpSelectionMerge %24 None OpBranchConditional %7 %24 %25 %25 = OpLabel OpReturn %24 = OpLabel %26 = OpCopyObject %5 %7 OpBranch %22 %22 = OpLabel OpBranchConditional %7 %20 %21 %21 = OpLabel OpBranch %27 %27 = OpLabel %28 = OpPhi %5 %26 %21 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // In function %2, the definition of id %15 will not dominate its use in // instruction %17 (inside block %16) after a new branch from return // block %14 to merge block %10 is added. ASSERT_FALSE( TransformationMergeFunctionReturns( 2, 100, 200, 101, 0, 0, {{MakeReturnMergingInfo(10, 102, 103, {{}})}}) .IsApplicable(context.get(), transformation_context)); // In function %18, the definition of id %26 will not dominate its use in // instruction %28 (inside block %27) after a new branch from return // block %25 to merge block %21 is added. ASSERT_FALSE( TransformationMergeFunctionReturns( 2, 100, 200, 101, 0, 0, {{MakeReturnMergingInfo(10, 102, 0, {{}}), MakeReturnMergingInfo(21, 103, 0, {{}})}}) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationMergeFunctionReturnsTest, RespectDominanceRules3) { // An id defined in a loop is used inside the loop. // Changes to the predecessors of the merge block do not affect the validity // of the uses of such id. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpConstantFalse %5 %2 = OpFunction %3 None %4 %8 = OpLabel OpBranch %9 %9 = OpLabel OpLoopMerge %10 %11 None OpBranch %12 %12 = OpLabel OpSelectionMerge %13 None OpBranchConditional %7 %13 %14 %14 = OpLabel OpReturn %13 = OpLabel %15 = OpCopyObject %5 %7 OpSelectionMerge %16 None OpBranchConditional %7 %16 %17 %17 = OpLabel %18 = OpPhi %5 %15 %13 %19 = OpCopyObject %5 %15 OpBranch %16 %16 = OpLabel OpBranch %11 %11 = OpLabel OpBranchConditional %7 %9 %10 %10 = OpLabel OpBranch %20 %20 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // In function %2, the definition of id %15 will still dominate its use in // instructions %18 and %19 after the transformation is applied, because the // fact that the id definition dominates the uses does not depend on it // dominating the merge block. auto transformation = TransformationMergeFunctionReturns( 2, 100, 200, 101, 0, 0, {{MakeReturnMergingInfo(10, 102, 103, {{}})}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpConstantFalse %5 %2 = OpFunction %3 None %4 %8 = OpLabel OpBranch %100 %100 = OpLabel OpLoopMerge %101 %200 None OpBranch %9 %9 = OpLabel OpLoopMerge %10 %11 None OpBranch %12 %12 = OpLabel OpSelectionMerge %13 None OpBranchConditional %7 %13 %14 %14 = OpLabel OpBranch %10 %13 = OpLabel %15 = OpCopyObject %5 %7 OpSelectionMerge %16 None OpBranchConditional %7 %16 %17 %17 = OpLabel %18 = OpPhi %5 %15 %13 %19 = OpCopyObject %5 %15 OpBranch %16 %16 = OpLabel OpBranch %11 %11 = OpLabel OpBranchConditional %7 %9 %10 %10 = OpLabel %102 = OpPhi %5 %6 %14 %7 %11 OpBranchConditional %102 %101 %20 %20 = OpLabel OpBranch %101 %101 = OpLabel OpReturn %200 = OpLabel OpBranch %100 OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationMergeFunctionReturnsTest, RespectDominanceRules4) { // An id defined in a loop, which contain 2 return statements, is used after // the loop. We can only apply the transformation if the id dominates all of // the return blocks. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpConstantFalse %5 %2 = OpFunction %3 None %4 %8 = OpLabel OpBranch %9 %9 = OpLabel OpLoopMerge %10 %11 None OpBranch %12 %12 = OpLabel %13 = OpCopyObject %5 %7 OpSelectionMerge %14 None OpBranchConditional %7 %14 %15 %15 = OpLabel OpReturn %14 = OpLabel OpSelectionMerge %16 None OpBranchConditional %7 %16 %17 %17 = OpLabel OpReturn %16 = OpLabel OpBranch %11 %11 = OpLabel OpBranchConditional %7 %9 %10 %10 = OpLabel OpBranch %18 %18 = OpLabel %19 = OpCopyObject %5 %13 OpReturn OpFunctionEnd %20 = OpFunction %3 None %4 %21 = OpLabel OpBranch %22 %22 = OpLabel OpLoopMerge %23 %24 None OpBranch %25 %25 = OpLabel OpSelectionMerge %26 None OpBranchConditional %7 %26 %27 %27 = OpLabel OpReturn %26 = OpLabel %28 = OpCopyObject %5 %7 OpSelectionMerge %29 None OpBranchConditional %7 %29 %30 %30 = OpLabel OpReturn %29 = OpLabel OpBranch %24 %24 = OpLabel OpBranchConditional %7 %22 %23 %23 = OpLabel OpBranch %31 %31 = OpLabel %32 = OpCopyObject %5 %28 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // In function %2, the definition of id %13 will still dominate its use in // instruction %19 after the transformation is applied, because %13 dominates // all of the return blocks. auto transformation = TransformationMergeFunctionReturns( 2, 100, 200, 101, 0, 0, {{MakeReturnMergingInfo(10, 102, 103, {{}})}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // In function %20, the definition of id %28 will not dominate its use in // instruction %32 after the transformation is applied, because %28 dominates // only one of the return blocks. ASSERT_FALSE(TransformationMergeFunctionReturns( 20, 100, 200, 101, 0, 0, {{MakeReturnMergingInfo(23, 102, 103, {{}})}}) .IsApplicable(context.get(), transformation_context)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpConstantFalse %5 %2 = OpFunction %3 None %4 %8 = OpLabel OpBranch %100 %100 = OpLabel OpLoopMerge %101 %200 None OpBranch %9 %9 = OpLabel OpLoopMerge %10 %11 None OpBranch %12 %12 = OpLabel %13 = OpCopyObject %5 %7 OpSelectionMerge %14 None OpBranchConditional %7 %14 %15 %15 = OpLabel OpBranch %10 %14 = OpLabel OpSelectionMerge %16 None OpBranchConditional %7 %16 %17 %17 = OpLabel OpBranch %10 %16 = OpLabel OpBranch %11 %11 = OpLabel OpBranchConditional %7 %9 %10 %10 = OpLabel %102 = OpPhi %5 %6 %15 %6 %17 %7 %11 OpBranchConditional %102 %101 %18 %18 = OpLabel %19 = OpCopyObject %5 %13 OpBranch %101 %101 = OpLabel OpReturn %200 = OpLabel OpBranch %100 OpFunctionEnd %20 = OpFunction %3 None %4 %21 = OpLabel OpBranch %22 %22 = OpLabel OpLoopMerge %23 %24 None OpBranch %25 %25 = OpLabel OpSelectionMerge %26 None OpBranchConditional %7 %26 %27 %27 = OpLabel OpReturn %26 = OpLabel %28 = OpCopyObject %5 %7 OpSelectionMerge %29 None OpBranchConditional %7 %29 %30 %30 = OpLabel OpReturn %29 = OpLabel OpBranch %24 %24 = OpLabel OpBranchConditional %7 %22 %23 %23 = OpLabel OpBranch %31 %31 = OpLabel %32 = OpCopyObject %5 %28 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationMergeFunctionReturnsTest, OpPhiAfterFirstBlock) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpConstantFalse %5 %2 = OpFunction %3 None %4 %8 = OpLabel OpBranch %9 %9 = OpLabel %10 = OpPhi %5 %6 %8 OpSelectionMerge %11 None OpBranchConditional %6 %12 %11 %12 = OpLabel OpReturn %11 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto transformation = TransformationMergeFunctionReturns(2, 100, 200, 101, 0, 0, {}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Ensure that all input operands of OpBranchConditional instructions have // the right operand type. context->module()->ForEachInst([](opt::Instruction* inst) { if (inst->opcode() == spv::Op::OpBranchConditional) { ASSERT_EQ(inst->GetInOperand(0).type, SPV_OPERAND_TYPE_ID); ASSERT_EQ(inst->GetInOperand(1).type, SPV_OPERAND_TYPE_ID); ASSERT_EQ(inst->GetInOperand(2).type, SPV_OPERAND_TYPE_ID); } }); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpConstantFalse %5 %2 = OpFunction %3 None %4 %8 = OpLabel OpBranch %100 %100 = OpLabel OpLoopMerge %101 %200 None OpBranch %9 %9 = OpLabel %10 = OpPhi %5 %6 %100 OpSelectionMerge %11 None OpBranchConditional %6 %12 %11 %12 = OpLabel OpBranch %101 %11 = OpLabel OpBranch %101 %101 = OpLabel OpReturn %200 = OpLabel OpBranch %100 OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } // namespace } // namespace fuzz } // namespace spvtoolsKhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_move_block_down_test.cpp000066400000000000000000000731561475742701700305620ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_move_block_down.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationMoveBlockDownTest, NoMovePossible1) { // Block 11 cannot be moved down as it dominates block 12. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %8 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %10 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpBranch %11 %11 = OpLabel OpStore %8 %9 OpBranch %12 %12 = OpLabel OpStore %8 %10 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto transformation = TransformationMoveBlockDown(11); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationMoveBlockDownTest, NoMovePossible2) { // Block 5 cannot be moved down as it is the entry block. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %8 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %10 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpStore %8 %9 OpStore %8 %10 OpReturn %11 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto transformation = TransformationMoveBlockDown(5); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationMoveBlockDownTest, NoMovePossible3) { // Block 100 does not exist, so cannot be moved down. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %8 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %10 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpBranch %11 %11 = OpLabel OpStore %8 %9 OpBranch %12 %12 = OpLabel OpStore %8 %10 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto transformation = TransformationMoveBlockDown(100); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationMoveBlockDownTest, NoMovePossible4) { // Block 12 is the last block in its function, so cannot be moved down. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %8 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %10 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpBranch %11 %11 = OpLabel OpStore %8 %9 OpBranch %12 %12 = OpLabel OpStore %8 %10 OpReturn OpFunctionEnd %13 = OpFunction %2 None %3 %14 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto transformation = TransformationMoveBlockDown(12); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationMoveBlockDownTest, ManyMovesPossible) { // The SPIR-V arising from this shader has lots of opportunities for moving // blocks around. // // void main() { // int x; // int y; // if (x < y) { // x = 1; // if (y == x) { // x = 3; // } else { // x = 4; // } // } else { // if (y < x) { // x = 5; // } else { // x = 6; // } // } // } std::string before_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "x" OpName %10 "y" OpDecorate %8 RelaxedPrecision OpDecorate %9 RelaxedPrecision OpDecorate %10 RelaxedPrecision OpDecorate %11 RelaxedPrecision OpDecorate %17 RelaxedPrecision OpDecorate %18 RelaxedPrecision OpDecorate %26 RelaxedPrecision OpDecorate %27 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %12 = OpTypeBool %16 = OpConstant %6 1 %22 = OpConstant %6 3 %24 = OpConstant %6 4 %31 = OpConstant %6 5 %33 = OpConstant %6 6 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %9 = OpLoad %6 %8 %11 = OpLoad %6 %10 %13 = OpSLessThan %12 %9 %11 OpSelectionMerge %15 None OpBranchConditional %13 %14 %25 %14 = OpLabel OpStore %8 %16 %17 = OpLoad %6 %10 %18 = OpLoad %6 %8 %19 = OpIEqual %12 %17 %18 OpSelectionMerge %21 None OpBranchConditional %19 %20 %23 %20 = OpLabel OpStore %8 %22 OpBranch %21 %23 = OpLabel OpStore %8 %24 OpBranch %21 %21 = OpLabel OpBranch %15 %25 = OpLabel %26 = OpLoad %6 %10 %27 = OpLoad %6 %8 %28 = OpSLessThan %12 %26 %27 OpSelectionMerge %30 None OpBranchConditional %28 %29 %32 %29 = OpLabel OpStore %8 %31 OpBranch %30 %32 = OpLabel OpStore %8 %33 OpBranch %30 %30 = OpLabel OpBranch %15 %15 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, before_transformation, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // The block ids are: 5 14 20 23 21 25 29 32 30 15 // We make a transformation to move each of them down, plus a transformation // to move a non-block, 27, down. auto move_down_5 = TransformationMoveBlockDown(5); auto move_down_14 = TransformationMoveBlockDown(14); auto move_down_20 = TransformationMoveBlockDown(20); auto move_down_23 = TransformationMoveBlockDown(23); auto move_down_21 = TransformationMoveBlockDown(21); auto move_down_25 = TransformationMoveBlockDown(25); auto move_down_29 = TransformationMoveBlockDown(29); auto move_down_32 = TransformationMoveBlockDown(32); auto move_down_30 = TransformationMoveBlockDown(30); auto move_down_15 = TransformationMoveBlockDown(15); auto move_down_27 = TransformationMoveBlockDown(27); // Dominance is as follows: // 5 dominates everything else // 14 dominates 20, 23, 21 // 20 dominates nothing // 23 dominates nothing // 21 dominates nothing // 25 dominates 29, 32, 30 // 29 dominates nothing // 32 dominates nothing // 30 dominates nothing // 15 dominates nothing // Current ordering: 5 14 20 23 21 25 29 32 30 15 ASSERT_FALSE(move_down_5.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( move_down_14.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_20.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_23.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_21.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( move_down_25.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_29.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_32.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_30.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( move_down_15.IsApplicable(context.get(), transformation_context)); // Let's bubble 20 all the way down. ApplyAndCheckFreshIds(move_down_20, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Current ordering: 5 14 23 20 21 25 29 32 30 15 ASSERT_FALSE(move_down_5.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( move_down_14.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_23.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_20.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_21.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( move_down_25.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_29.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_32.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_30.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( move_down_15.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(move_down_20, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Current ordering: 5 14 23 21 20 25 29 32 30 15 ASSERT_FALSE(move_down_5.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( move_down_14.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_23.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_21.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_20.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( move_down_25.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_29.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_32.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_30.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( move_down_15.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(move_down_20, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Current ordering: 5 14 23 21 25 20 29 32 30 15 ASSERT_FALSE(move_down_5.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( move_down_14.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_23.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_21.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_25.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_20.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_29.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_32.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_30.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( move_down_15.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(move_down_20, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Current ordering: 5 14 23 21 25 29 20 32 30 15 ASSERT_FALSE(move_down_5.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( move_down_14.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_23.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_21.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( move_down_25.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_29.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_20.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_32.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_30.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( move_down_15.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(move_down_20, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Current ordering: 5 14 23 21 25 29 32 20 30 15 ASSERT_FALSE(move_down_5.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( move_down_14.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_23.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_21.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( move_down_25.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_29.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_32.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_20.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_30.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( move_down_15.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(move_down_20, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Current ordering: 5 14 23 21 25 29 32 30 20 15 ASSERT_FALSE(move_down_5.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( move_down_14.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_23.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_21.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( move_down_25.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_29.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_32.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_30.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_20.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( move_down_15.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(move_down_20, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_bubbling_20_down = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "x" OpName %10 "y" OpDecorate %8 RelaxedPrecision OpDecorate %9 RelaxedPrecision OpDecorate %10 RelaxedPrecision OpDecorate %11 RelaxedPrecision OpDecorate %17 RelaxedPrecision OpDecorate %18 RelaxedPrecision OpDecorate %26 RelaxedPrecision OpDecorate %27 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %12 = OpTypeBool %16 = OpConstant %6 1 %22 = OpConstant %6 3 %24 = OpConstant %6 4 %31 = OpConstant %6 5 %33 = OpConstant %6 6 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %9 = OpLoad %6 %8 %11 = OpLoad %6 %10 %13 = OpSLessThan %12 %9 %11 OpSelectionMerge %15 None OpBranchConditional %13 %14 %25 %14 = OpLabel OpStore %8 %16 %17 = OpLoad %6 %10 %18 = OpLoad %6 %8 %19 = OpIEqual %12 %17 %18 OpSelectionMerge %21 None OpBranchConditional %19 %20 %23 %23 = OpLabel OpStore %8 %24 OpBranch %21 %21 = OpLabel OpBranch %15 %25 = OpLabel %26 = OpLoad %6 %10 %27 = OpLoad %6 %8 %28 = OpSLessThan %12 %26 %27 OpSelectionMerge %30 None OpBranchConditional %28 %29 %32 %29 = OpLabel OpStore %8 %31 OpBranch %30 %32 = OpLabel OpStore %8 %33 OpBranch %30 %30 = OpLabel OpBranch %15 %15 = OpLabel OpReturn %20 = OpLabel OpStore %8 %22 OpBranch %21 OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_bubbling_20_down, context.get())); // Current ordering: 5 14 23 21 25 29 32 30 15 20 ASSERT_FALSE(move_down_5.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( move_down_14.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_23.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_21.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( move_down_25.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_29.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_32.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_30.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_15.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( move_down_20.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(move_down_23, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Current ordering: 5 14 21 23 25 29 32 30 15 20 ASSERT_FALSE(move_down_5.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( move_down_14.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_21.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_23.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( move_down_25.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_29.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_32.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_30.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_15.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( move_down_20.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(move_down_23, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Current ordering: 5 14 21 25 23 29 32 30 15 20 ASSERT_FALSE(move_down_5.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( move_down_14.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_21.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_25.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_23.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_29.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_32.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_30.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_15.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( move_down_20.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(move_down_21, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Current ordering: 5 14 25 21 23 29 32 30 15 20 ASSERT_FALSE(move_down_5.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_14.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_21.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_25.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_23.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_29.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_32.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_30.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_15.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( move_down_20.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(move_down_14, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_more_shuffling = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "x" OpName %10 "y" OpDecorate %8 RelaxedPrecision OpDecorate %9 RelaxedPrecision OpDecorate %10 RelaxedPrecision OpDecorate %11 RelaxedPrecision OpDecorate %17 RelaxedPrecision OpDecorate %18 RelaxedPrecision OpDecorate %26 RelaxedPrecision OpDecorate %27 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %12 = OpTypeBool %16 = OpConstant %6 1 %22 = OpConstant %6 3 %24 = OpConstant %6 4 %31 = OpConstant %6 5 %33 = OpConstant %6 6 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %9 = OpLoad %6 %8 %11 = OpLoad %6 %10 %13 = OpSLessThan %12 %9 %11 OpSelectionMerge %15 None OpBranchConditional %13 %14 %25 %25 = OpLabel %26 = OpLoad %6 %10 %27 = OpLoad %6 %8 %28 = OpSLessThan %12 %26 %27 OpSelectionMerge %30 None OpBranchConditional %28 %29 %32 %14 = OpLabel OpStore %8 %16 %17 = OpLoad %6 %10 %18 = OpLoad %6 %8 %19 = OpIEqual %12 %17 %18 OpSelectionMerge %21 None OpBranchConditional %19 %20 %23 %21 = OpLabel OpBranch %15 %23 = OpLabel OpStore %8 %24 OpBranch %21 %29 = OpLabel OpStore %8 %31 OpBranch %30 %32 = OpLabel OpStore %8 %33 OpBranch %30 %30 = OpLabel OpBranch %15 %15 = OpLabel OpReturn %20 = OpLabel OpStore %8 %22 OpBranch %21 OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_more_shuffling, context.get())); // Final ordering: 5 25 14 21 23 29 32 30 15 20 ASSERT_FALSE(move_down_5.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_25.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( move_down_14.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_21.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_23.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_29.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_32.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_30.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(move_down_15.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( move_down_20.IsApplicable(context.get(), transformation_context)); } TEST(TransformationMoveBlockDownTest, DoNotMoveUnreachable) { // Block 6 is unreachable, so cannot be moved down. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeInt 32 1 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn %6 = OpLabel %7 = OpUndef %10 OpBranch %8 %8 = OpLabel %9 = OpCopyObject %10 %7 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto transformation = TransformationMoveBlockDown(6); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_move_instruction_down_test.cpp000066400000000000000000000622171475742701700320450ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_move_instruction_down.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationMoveInstructionDownTest, BasicTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %9 = OpConstant %6 0 %16 = OpTypeBool %17 = OpConstantFalse %16 %20 = OpUndef %6 %13 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %5 = OpLabel %12 = OpVariable %13 Function %10 = OpIAdd %6 %9 %9 %11 = OpISub %6 %9 %10 OpStore %12 %10 %14 = OpLoad %6 %12 %15 = OpIMul %6 %9 %14 OpSelectionMerge %19 None OpBranchConditional %17 %18 %19 %18 = OpLabel OpBranch %19 %19 = OpLabel %42 = OpFunctionCall %2 %40 %22 = OpIAdd %6 %15 %15 %21 = OpIAdd %6 %15 %15 OpReturn OpFunctionEnd %40 = OpFunction %2 None %3 %41 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Instruction descriptor is invalid. ASSERT_FALSE(TransformationMoveInstructionDown( MakeInstructionDescriptor(30, spv::Op::OpNop, 0)) .IsApplicable(context.get(), transformation_context)); // Opcode is not supported. ASSERT_FALSE(TransformationMoveInstructionDown( MakeInstructionDescriptor(5, spv::Op::OpLabel, 0)) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationMoveInstructionDown( MakeInstructionDescriptor(12, spv::Op::OpVariable, 0)) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationMoveInstructionDown( MakeInstructionDescriptor(42, spv::Op::OpFunctionCall, 0)) .IsApplicable(context.get(), transformation_context)); // Can't move the last instruction in the block. ASSERT_FALSE( TransformationMoveInstructionDown( MakeInstructionDescriptor(15, spv::Op::OpBranchConditional, 0)) .IsApplicable(context.get(), transformation_context)); // Can't move the instruction if the next instruction is the last one in the // block. ASSERT_FALSE(TransformationMoveInstructionDown( MakeInstructionDescriptor(21, spv::Op::OpIAdd, 0)) .IsApplicable(context.get(), transformation_context)); // Can't insert instruction's opcode after its successor. ASSERT_FALSE(TransformationMoveInstructionDown( MakeInstructionDescriptor(15, spv::Op::OpIMul, 0)) .IsApplicable(context.get(), transformation_context)); // Instruction's successor depends on the instruction. ASSERT_FALSE(TransformationMoveInstructionDown( MakeInstructionDescriptor(10, spv::Op::OpIAdd, 0)) .IsApplicable(context.get(), transformation_context)); { TransformationMoveInstructionDown transformation( MakeInstructionDescriptor(11, spv::Op::OpISub, 0)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } { TransformationMoveInstructionDown transformation( MakeInstructionDescriptor(22, spv::Op::OpIAdd, 0)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %9 = OpConstant %6 0 %16 = OpTypeBool %17 = OpConstantFalse %16 %20 = OpUndef %6 %13 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %5 = OpLabel %12 = OpVariable %13 Function %10 = OpIAdd %6 %9 %9 OpStore %12 %10 %11 = OpISub %6 %9 %10 %14 = OpLoad %6 %12 %15 = OpIMul %6 %9 %14 OpSelectionMerge %19 None OpBranchConditional %17 %18 %19 %18 = OpLabel OpBranch %19 %19 = OpLabel %42 = OpFunctionCall %2 %40 %21 = OpIAdd %6 %15 %15 %22 = OpIAdd %6 %15 %15 OpReturn OpFunctionEnd %40 = OpFunction %2 None %3 %41 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationMoveInstructionDownTest, HandlesUnsupportedInstructions) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 16 1 1 OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpConstant %6 2 %20 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %5 = OpLabel %21 = OpVariable %20 Function %7 ; can swap simple and not supported instructions %8 = OpCopyObject %6 %7 %9 = OpFunctionCall %2 %12 ; cannot swap memory and not supported instruction %22 = OpLoad %6 %21 %23 = OpFunctionCall %2 %12 ; cannot swap barrier and not supported instruction OpMemoryBarrier %7 %7 %24 = OpFunctionCall %2 %12 OpReturn OpFunctionEnd %12 = OpFunction %2 None %3 %13 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Swap memory instruction with an unsupported one. ASSERT_FALSE(TransformationMoveInstructionDown( MakeInstructionDescriptor(22, spv::Op::OpLoad, 0)) .IsApplicable(context.get(), transformation_context)); // Swap memory barrier with an unsupported one. ASSERT_FALSE(TransformationMoveInstructionDown( MakeInstructionDescriptor(23, spv::Op::OpMemoryBarrier, 0)) .IsApplicable(context.get(), transformation_context)); // Swap simple instruction with an unsupported one. TransformationMoveInstructionDown transformation( MakeInstructionDescriptor(8, spv::Op::OpCopyObject, 0)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 16 1 1 OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpConstant %6 2 %20 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %5 = OpLabel %21 = OpVariable %20 Function %7 ; can swap simple and not supported instructions %9 = OpFunctionCall %2 %12 %8 = OpCopyObject %6 %7 ; cannot swap memory and not supported instruction %22 = OpLoad %6 %21 %23 = OpFunctionCall %2 %12 ; cannot swap barrier and not supported instruction OpMemoryBarrier %7 %7 %24 = OpFunctionCall %2 %12 OpReturn OpFunctionEnd %12 = OpFunction %2 None %3 %13 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationMoveInstructionDownTest, HandlesBarrierInstructions) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 16 1 1 OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpConstant %6 2 %20 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %5 = OpLabel %21 = OpVariable %20 Function %7 ; cannot swap two barrier instructions OpMemoryBarrier %7 %7 OpMemoryBarrier %7 %7 ; cannot swap barrier and memory instructions OpMemoryBarrier %7 %7 %22 = OpLoad %6 %21 OpMemoryBarrier %7 %7 ; can swap barrier and simple instructions %23 = OpCopyObject %6 %7 OpMemoryBarrier %7 %7 OpReturn OpFunctionEnd %12 = OpFunction %2 None %3 %13 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Swap two barrier instructions. ASSERT_FALSE(TransformationMoveInstructionDown( MakeInstructionDescriptor(21, spv::Op::OpMemoryBarrier, 0)) .IsApplicable(context.get(), transformation_context)); // Swap barrier and memory instructions. ASSERT_FALSE(TransformationMoveInstructionDown( MakeInstructionDescriptor(21, spv::Op::OpMemoryBarrier, 2)) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationMoveInstructionDown( MakeInstructionDescriptor(22, spv::Op::OpLoad, 0)) .IsApplicable(context.get(), transformation_context)); // Swap barrier and simple instructions. { TransformationMoveInstructionDown transformation( MakeInstructionDescriptor(23, spv::Op::OpCopyObject, 0)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } { TransformationMoveInstructionDown transformation( MakeInstructionDescriptor(22, spv::Op::OpMemoryBarrier, 1)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } ASSERT_TRUE(IsEqual(env, shader, context.get())); } TEST(TransformationMoveInstructionDownTest, HandlesSimpleInstructions) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 16 1 1 OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpConstant %6 2 %20 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %5 = OpLabel %21 = OpVariable %20 Function %7 ; can swap simple and barrier instructions %40 = OpCopyObject %6 %7 OpMemoryBarrier %7 %7 ; can swap simple and memory instructions %41 = OpCopyObject %6 %7 %22 = OpLoad %6 %21 ; can swap two simple instructions %23 = OpCopyObject %6 %7 %42 = OpCopyObject %6 %7 OpReturn OpFunctionEnd %12 = OpFunction %2 None %3 %13 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Swap simple and barrier instructions. { TransformationMoveInstructionDown transformation( MakeInstructionDescriptor(40, spv::Op::OpCopyObject, 0)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } { TransformationMoveInstructionDown transformation( MakeInstructionDescriptor(21, spv::Op::OpMemoryBarrier, 0)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } // Swap simple and memory instructions. { TransformationMoveInstructionDown transformation( MakeInstructionDescriptor(41, spv::Op::OpCopyObject, 0)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } { TransformationMoveInstructionDown transformation( MakeInstructionDescriptor(22, spv::Op::OpLoad, 0)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } // Swap two simple instructions. { TransformationMoveInstructionDown transformation( MakeInstructionDescriptor(23, spv::Op::OpCopyObject, 0)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 16 1 1 OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpConstant %6 2 %20 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %5 = OpLabel %21 = OpVariable %20 Function %7 ; can swap simple and barrier instructions %40 = OpCopyObject %6 %7 OpMemoryBarrier %7 %7 ; can swap simple and memory instructions %41 = OpCopyObject %6 %7 %22 = OpLoad %6 %21 ; can swap two simple instructions %42 = OpCopyObject %6 %7 %23 = OpCopyObject %6 %7 OpReturn OpFunctionEnd %12 = OpFunction %2 None %3 %13 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationMoveInstructionDownTest, HandlesMemoryInstructions) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 16 1 1 OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpConstant %6 2 %20 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %5 = OpLabel %21 = OpVariable %20 Function %7 %22 = OpVariable %20 Function %7 ; swap R and R instructions %23 = OpLoad %6 %21 %24 = OpLoad %6 %22 ; swap R and RW instructions ; can't swap %25 = OpLoad %6 %21 OpCopyMemory %21 %22 ; can swap %26 = OpLoad %6 %21 OpCopyMemory %22 %21 %27 = OpLoad %6 %22 OpCopyMemory %21 %22 %28 = OpLoad %6 %22 OpCopyMemory %22 %21 ; swap R and W instructions ; can't swap %29 = OpLoad %6 %21 OpStore %21 %7 ; can swap %30 = OpLoad %6 %22 OpStore %21 %7 %31 = OpLoad %6 %21 OpStore %22 %7 %32 = OpLoad %6 %22 OpStore %22 %7 ; swap RW and RW instructions ; can't swap OpCopyMemory %21 %21 OpCopyMemory %21 %21 OpCopyMemory %21 %22 OpCopyMemory %21 %21 OpCopyMemory %21 %21 OpCopyMemory %21 %22 ; can swap OpCopyMemory %22 %21 OpCopyMemory %21 %22 OpCopyMemory %22 %21 OpCopyMemory %22 %21 OpCopyMemory %21 %22 OpCopyMemory %21 %22 ; swap RW and W instructions ; can't swap OpCopyMemory %21 %21 OpStore %21 %7 OpStore %21 %7 OpCopyMemory %21 %21 ; can swap OpCopyMemory %22 %21 OpStore %21 %7 OpCopyMemory %21 %22 OpStore %21 %7 OpCopyMemory %21 %21 OpStore %22 %7 ; swap W and W instructions ; can't swap OpStore %21 %7 OpStore %21 %7 ; can swap OpStore %22 %7 OpStore %21 %7 OpStore %22 %7 OpStore %22 %7 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactValueOfPointeeIsIrrelevant( 22); // Invalid swaps. protobufs::InstructionDescriptor invalid_swaps[] = { // R and RW MakeInstructionDescriptor(25, spv::Op::OpLoad, 0), // R and W MakeInstructionDescriptor(29, spv::Op::OpLoad, 0), // RW and RW MakeInstructionDescriptor(32, spv::Op::OpCopyMemory, 0), MakeInstructionDescriptor(32, spv::Op::OpCopyMemory, 2), MakeInstructionDescriptor(32, spv::Op::OpCopyMemory, 4), // RW and W MakeInstructionDescriptor(32, spv::Op::OpCopyMemory, 12), MakeInstructionDescriptor(32, spv::Op::OpStore, 1), // W and W MakeInstructionDescriptor(32, spv::Op::OpStore, 6), }; for (const auto& descriptor : invalid_swaps) { ASSERT_FALSE(TransformationMoveInstructionDown(descriptor) .IsApplicable(context.get(), transformation_context)); } // Valid swaps. protobufs::InstructionDescriptor valid_swaps[] = { // R and R MakeInstructionDescriptor(23, spv::Op::OpLoad, 0), MakeInstructionDescriptor(24, spv::Op::OpLoad, 0), // R and RW MakeInstructionDescriptor(26, spv::Op::OpLoad, 0), MakeInstructionDescriptor(25, spv::Op::OpCopyMemory, 1), MakeInstructionDescriptor(27, spv::Op::OpLoad, 0), MakeInstructionDescriptor(26, spv::Op::OpCopyMemory, 1), MakeInstructionDescriptor(28, spv::Op::OpLoad, 0), MakeInstructionDescriptor(27, spv::Op::OpCopyMemory, 1), // R and W MakeInstructionDescriptor(30, spv::Op::OpLoad, 0), MakeInstructionDescriptor(29, spv::Op::OpStore, 1), MakeInstructionDescriptor(31, spv::Op::OpLoad, 0), MakeInstructionDescriptor(30, spv::Op::OpStore, 1), MakeInstructionDescriptor(32, spv::Op::OpLoad, 0), MakeInstructionDescriptor(31, spv::Op::OpStore, 1), // RW and RW MakeInstructionDescriptor(32, spv::Op::OpCopyMemory, 6), MakeInstructionDescriptor(32, spv::Op::OpCopyMemory, 6), MakeInstructionDescriptor(32, spv::Op::OpCopyMemory, 8), MakeInstructionDescriptor(32, spv::Op::OpCopyMemory, 8), MakeInstructionDescriptor(32, spv::Op::OpCopyMemory, 10), MakeInstructionDescriptor(32, spv::Op::OpCopyMemory, 10), // RW and W MakeInstructionDescriptor(32, spv::Op::OpCopyMemory, 14), MakeInstructionDescriptor(32, spv::Op::OpStore, 3), MakeInstructionDescriptor(32, spv::Op::OpCopyMemory, 15), MakeInstructionDescriptor(32, spv::Op::OpStore, 4), MakeInstructionDescriptor(32, spv::Op::OpCopyMemory, 16), MakeInstructionDescriptor(32, spv::Op::OpStore, 5), // W and W MakeInstructionDescriptor(32, spv::Op::OpStore, 8), MakeInstructionDescriptor(32, spv::Op::OpStore, 8), MakeInstructionDescriptor(32, spv::Op::OpStore, 10), MakeInstructionDescriptor(32, spv::Op::OpStore, 10), }; for (const auto& descriptor : valid_swaps) { TransformationMoveInstructionDown transformation(descriptor); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } ASSERT_TRUE(IsEqual(env, shader, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_mutate_pointer_test.cpp000066400000000000000000000274241475742701700304470ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_mutate_pointer.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationMutatePointerTest, BasicTest) { std::string shader = R"( OpCapability Shader OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeFloat 32 %34 = OpConstant %7 0 %36 = OpConstant %6 0 %14 = OpTypeVector %7 3 %35 = OpConstantComposite %14 %34 %34 %34 %15 = OpTypeMatrix %14 2 %8 = OpConstant %6 5 %9 = OpTypeArray %7 %8 %37 = OpConstantComposite %9 %34 %34 %34 %34 %34 %11 = OpTypeStruct %38 = OpConstantComposite %11 %39 = OpConstantComposite %15 %35 %35 %31 = OpTypePointer Function %14 %10 = OpTypeStruct %7 %6 %9 %11 %15 %14 %40 = OpConstantComposite %10 %34 %36 %37 %38 %39 %35 %13 = OpTypePointer Function %10 %16 = OpTypePointer Private %10 %17 = OpTypePointer Workgroup %10 %18 = OpTypeStruct %16 %19 = OpTypePointer Private %18 %20 = OpVariable %16 Private %21 = OpVariable %17 Workgroup %22 = OpVariable %19 Private %23 = OpTypePointer Output %6 %24 = OpVariable %23 Output %27 = OpTypeFunction %2 %13 %33 = OpConstantNull %16 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %28 = OpFunction %2 None %27 %29 = OpFunctionParameter %13 %30 = OpLabel %25 = OpVariable %13 Function %26 = OpAccessChain %31 %25 %8 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactIdIsIrrelevant(35); transformation_context.GetFactManager()->AddFactIdIsIrrelevant(39); const auto insert_before = MakeInstructionDescriptor(26, spv::Op::OpReturn, 0); // 20 is not a fresh id. ASSERT_FALSE(TransformationMutatePointer(20, 20, insert_before) .IsApplicable(context.get(), transformation_context)); // |insert_before| instruction descriptor is invalid. ASSERT_FALSE(TransformationMutatePointer( 20, 70, MakeInstructionDescriptor(26, spv::Op::OpStore, 0)) .IsApplicable(context.get(), transformation_context)); // Can't insert OpLoad before OpVariable. ASSERT_FALSE( TransformationMutatePointer( 20, 70, MakeInstructionDescriptor(26, spv::Op::OpVariable, 0)) .IsApplicable(context.get(), transformation_context)); // |pointer_id| doesn't exist in the module. ASSERT_FALSE(TransformationMutatePointer(70, 70, insert_before) .IsApplicable(context.get(), transformation_context)); // |pointer_id| doesn't have a type id. ASSERT_FALSE(TransformationMutatePointer(11, 70, insert_before) .IsApplicable(context.get(), transformation_context)); // |pointer_id| is a result id of OpConstantNull. ASSERT_FALSE(TransformationMutatePointer(33, 70, insert_before) .IsApplicable(context.get(), transformation_context)); // |pointer_id| is not a pointer instruction. ASSERT_FALSE(TransformationMutatePointer(8, 70, insert_before) .IsApplicable(context.get(), transformation_context)); // |pointer_id| has invalid storage class ASSERT_FALSE(TransformationMutatePointer(24, 70, insert_before) .IsApplicable(context.get(), transformation_context)); // |pointer_id|'s pointee contains non-scalar and non-composite constituents. ASSERT_FALSE(TransformationMutatePointer(22, 70, insert_before) .IsApplicable(context.get(), transformation_context)); // There is no irrelevant zero constant to insert into the |pointer_id|. ASSERT_FALSE(TransformationMutatePointer(20, 70, insert_before) .IsApplicable(context.get(), transformation_context)); // |pointer_id| is not available before |insert_before|. ASSERT_FALSE( TransformationMutatePointer( 26, 70, MakeInstructionDescriptor(26, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); transformation_context.GetFactManager()->AddFactIdIsIrrelevant(40); uint32_t fresh_id = 70; uint32_t pointer_ids[] = { 20, // Mutate Private variable. 21, // Mutate Workgroup variable. 25, // Mutate Function variable. 29, // Mutate function parameter. 26, // Mutate OpAccessChain. }; for (auto pointer_id : pointer_ids) { TransformationMutatePointer transformation(pointer_id, fresh_id++, insert_before); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } std::string after_transformation = R"( OpCapability Shader OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeFloat 32 %34 = OpConstant %7 0 %36 = OpConstant %6 0 %14 = OpTypeVector %7 3 %35 = OpConstantComposite %14 %34 %34 %34 %15 = OpTypeMatrix %14 2 %8 = OpConstant %6 5 %9 = OpTypeArray %7 %8 %37 = OpConstantComposite %9 %34 %34 %34 %34 %34 %11 = OpTypeStruct %38 = OpConstantComposite %11 %39 = OpConstantComposite %15 %35 %35 %31 = OpTypePointer Function %14 %10 = OpTypeStruct %7 %6 %9 %11 %15 %14 %40 = OpConstantComposite %10 %34 %36 %37 %38 %39 %35 %13 = OpTypePointer Function %10 %16 = OpTypePointer Private %10 %17 = OpTypePointer Workgroup %10 %18 = OpTypeStruct %16 %19 = OpTypePointer Private %18 %20 = OpVariable %16 Private %21 = OpVariable %17 Workgroup %22 = OpVariable %19 Private %23 = OpTypePointer Output %6 %24 = OpVariable %23 Output %27 = OpTypeFunction %2 %13 %33 = OpConstantNull %16 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %28 = OpFunction %2 None %27 %29 = OpFunctionParameter %13 %30 = OpLabel %25 = OpVariable %13 Function %26 = OpAccessChain %31 %25 %8 ; modified Private variable %70 = OpLoad %10 %20 OpStore %20 %40 OpStore %20 %70 ; modified Workgroup variable %71 = OpLoad %10 %21 OpStore %21 %40 OpStore %21 %71 ; modified Function variable %72 = OpLoad %10 %25 OpStore %25 %40 OpStore %25 %72 ; modified function parameter %73 = OpLoad %10 %29 OpStore %29 %40 OpStore %29 %73 ; modified OpAccessChain %74 = OpLoad %14 %26 OpStore %26 %35 OpStore %26 %74 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationMutatePointerTest, HandlesUnreachableBlocks) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpConstant %6 0 %8 = OpTypePointer Function %6 %11 = OpTypePointer Private %6 %12 = OpVariable %11 Private %4 = OpFunction %2 None %3 %5 = OpLabel %9 = OpVariable %8 Function OpReturn %10 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactIdIsIrrelevant(7); ASSERT_FALSE( context->GetDominatorAnalysis(context->GetFunction(4))->IsReachable(10)); const auto insert_before = MakeInstructionDescriptor(10, spv::Op::OpReturn, 0); // Can mutate a global variable in an unreachable block. TransformationMutatePointer transformation(12, 50, insert_before); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpConstant %6 0 %8 = OpTypePointer Function %6 %11 = OpTypePointer Private %6 %12 = OpVariable %11 Private %4 = OpFunction %2 None %3 %5 = OpLabel %9 = OpVariable %8 Function OpReturn %10 = OpLabel %50 = OpLoad %6 %12 OpStore %12 %7 OpStore %12 %50 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_outline_function_test.cpp000066400000000000000000003546741475742701700310060ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_outline_function.h" #include "gtest/gtest.h" #include "source/fuzz/counter_overflow_id_source.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationOutlineFunctionTest, TrivialOutline) { // This tests outlining of a single, empty basic block. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationOutlineFunction transformation(5, 5, /* not relevant */ 200, 100, 101, 102, 103, /* not relevant */ 201, {}, {}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel %103 = OpFunctionCall %2 %101 OpReturn OpFunctionEnd %101 = OpFunction %2 None %3 %102 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationOutlineFunctionTest, DoNotOutlineIfRegionStartsWithOpVariable) { // This checks that we do not outline the first block of a function if it // contains OpVariable. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %7 = OpTypeBool %8 = OpTypePointer Function %7 %4 = OpFunction %2 None %3 %5 = OpLabel %6 = OpVariable %8 Function OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationOutlineFunction transformation(5, 5, /* not relevant */ 200, 100, 101, 102, 103, /* not relevant */ 201, {}, {}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationOutlineFunctionTest, OutlineInterestingControlFlowNoState) { // This tests outlining of some non-trivial control flow, but such that the // basic blocks in the control flow do not actually do anything. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %20 = OpTypeBool %21 = OpConstantTrue %20 %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %6 %6 = OpLabel OpBranch %7 %7 = OpLabel OpSelectionMerge %9 None OpBranchConditional %21 %8 %9 %8 = OpLabel OpBranch %9 %9 = OpLabel OpLoopMerge %12 %11 None OpBranch %10 %10 = OpLabel OpBranchConditional %21 %11 %12 %11 = OpLabel OpBranch %9 %12 = OpLabel OpBranch %13 %13 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationOutlineFunction transformation(6, 13, /* not relevant */ 200, 100, 101, 102, 103, /* not relevant */ 201, {}, {}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %20 = OpTypeBool %21 = OpConstantTrue %20 %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %6 %6 = OpLabel %103 = OpFunctionCall %2 %101 OpReturn OpFunctionEnd %101 = OpFunction %2 None %3 %102 = OpLabel OpBranch %7 %7 = OpLabel OpSelectionMerge %9 None OpBranchConditional %21 %8 %9 %8 = OpLabel OpBranch %9 %9 = OpLabel OpLoopMerge %12 %11 None OpBranch %10 %10 = OpLabel OpBranchConditional %21 %11 %12 %11 = OpLabel OpBranch %9 %12 = OpLabel OpBranch %13 %13 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationOutlineFunctionTest, OutlineCodeThatGeneratesUnusedIds) { // This tests outlining of a single basic block that does some computation, // but that does not use nor generate ids required outside of the outlined // region. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %20 = OpTypeInt 32 1 %21 = OpConstant %20 5 %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %6 %6 = OpLabel %7 = OpCopyObject %20 %21 %8 = OpCopyObject %20 %21 %9 = OpIAdd %20 %7 %8 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationOutlineFunction transformation(6, 6, /* not relevant */ 200, 100, 101, 102, 103, /* not relevant */ 201, {}, {}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %20 = OpTypeInt 32 1 %21 = OpConstant %20 5 %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %6 %6 = OpLabel %103 = OpFunctionCall %2 %101 OpReturn OpFunctionEnd %101 = OpFunction %2 None %3 %102 = OpLabel %7 = OpCopyObject %20 %21 %8 = OpCopyObject %20 %21 %9 = OpIAdd %20 %7 %8 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationOutlineFunctionTest, OutlineCodeThatGeneratesSingleUsedId) { // This tests outlining of a block that generates an id that is used in a // later block. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %20 = OpTypeInt 32 1 %21 = OpConstant %20 5 %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %6 %6 = OpLabel %7 = OpCopyObject %20 %21 %8 = OpCopyObject %20 %21 %9 = OpIAdd %20 %7 %8 OpBranch %10 %10 = OpLabel %11 = OpCopyObject %20 %9 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationOutlineFunction transformation(6, 6, 99, 100, 101, 102, 103, 105, {}, {{9, 104}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %20 = OpTypeInt 32 1 %21 = OpConstant %20 5 %3 = OpTypeFunction %2 %99 = OpTypeStruct %20 %100 = OpTypeFunction %99 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %6 %6 = OpLabel %103 = OpFunctionCall %99 %101 %9 = OpCompositeExtract %20 %103 0 OpBranch %10 %10 = OpLabel %11 = OpCopyObject %20 %9 OpReturn OpFunctionEnd %101 = OpFunction %99 None %100 %102 = OpLabel %7 = OpCopyObject %20 %21 %8 = OpCopyObject %20 %21 %104 = OpIAdd %20 %7 %8 %105 = OpCompositeConstruct %99 %104 OpReturnValue %105 OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationOutlineFunctionTest, OutlineDiamondThatGeneratesSeveralIds) { // This tests outlining of several blocks that generate a number of ids that // are used in later blocks. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %20 = OpTypeInt 32 1 %21 = OpConstant %20 5 %22 = OpTypeBool %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %6 %6 = OpLabel %7 = OpCopyObject %20 %21 %8 = OpCopyObject %20 %21 %9 = OpSLessThan %22 %7 %8 OpSelectionMerge %12 None OpBranchConditional %9 %10 %11 %10 = OpLabel %13 = OpIAdd %20 %7 %8 OpBranch %12 %11 = OpLabel %14 = OpIAdd %20 %7 %7 OpBranch %12 %12 = OpLabel %15 = OpPhi %20 %13 %10 %14 %11 OpBranch %80 %80 = OpLabel OpBranch %16 %16 = OpLabel %17 = OpCopyObject %20 %15 %18 = OpCopyObject %22 %9 %19 = OpIAdd %20 %7 %8 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationOutlineFunction transformation( 6, 80, 100, 101, 102, 103, 104, 105, {}, {{15, 106}, {9, 107}, {7, 108}, {8, 109}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %20 = OpTypeInt 32 1 %21 = OpConstant %20 5 %22 = OpTypeBool %3 = OpTypeFunction %2 %100 = OpTypeStruct %20 %20 %22 %20 %101 = OpTypeFunction %100 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %6 %6 = OpLabel %104 = OpFunctionCall %100 %102 %7 = OpCompositeExtract %20 %104 0 %8 = OpCompositeExtract %20 %104 1 %9 = OpCompositeExtract %22 %104 2 %15 = OpCompositeExtract %20 %104 3 OpBranch %16 %16 = OpLabel %17 = OpCopyObject %20 %15 %18 = OpCopyObject %22 %9 %19 = OpIAdd %20 %7 %8 OpReturn OpFunctionEnd %102 = OpFunction %100 None %101 %103 = OpLabel %108 = OpCopyObject %20 %21 %109 = OpCopyObject %20 %21 %107 = OpSLessThan %22 %108 %109 OpSelectionMerge %12 None OpBranchConditional %107 %10 %11 %10 = OpLabel %13 = OpIAdd %20 %108 %109 OpBranch %12 %11 = OpLabel %14 = OpIAdd %20 %108 %108 OpBranch %12 %12 = OpLabel %106 = OpPhi %20 %13 %10 %14 %11 OpBranch %80 %80 = OpLabel %105 = OpCompositeConstruct %100 %108 %109 %107 %106 OpReturnValue %105 OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationOutlineFunctionTest, OutlineCodeThatUsesASingleId) { // This tests outlining of a block that uses an id defined earlier. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %20 = OpTypeInt 32 1 %21 = OpConstant %20 5 %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel %7 = OpCopyObject %20 %21 OpBranch %6 %6 = OpLabel %8 = OpCopyObject %20 %7 OpBranch %10 %10 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationOutlineFunction transformation(6, 6, 100, 101, 102, 103, 104, 105, {{7, 106}}, {}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %20 = OpTypeInt 32 1 %21 = OpConstant %20 5 %3 = OpTypeFunction %2 %101 = OpTypeFunction %2 %20 %4 = OpFunction %2 None %3 %5 = OpLabel %7 = OpCopyObject %20 %21 OpBranch %6 %6 = OpLabel %104 = OpFunctionCall %2 %102 %7 OpBranch %10 %10 = OpLabel OpReturn OpFunctionEnd %102 = OpFunction %2 None %101 %106 = OpFunctionParameter %20 %103 = OpLabel %8 = OpCopyObject %20 %106 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationOutlineFunctionTest, OutlineCodeThatUsesAVariable) { // This tests outlining of a block that uses a variable. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %20 = OpTypeInt 32 1 %21 = OpConstant %20 5 %3 = OpTypeFunction %2 %12 = OpTypePointer Function %20 %4 = OpFunction %2 None %3 %5 = OpLabel %13 = OpVariable %12 Function OpBranch %6 %6 = OpLabel %8 = OpLoad %20 %13 OpBranch %10 %10 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationOutlineFunction transformation(6, 6, 100, 101, 102, 103, 104, 105, {{13, 106}}, {}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %20 = OpTypeInt 32 1 %21 = OpConstant %20 5 %3 = OpTypeFunction %2 %12 = OpTypePointer Function %20 %101 = OpTypeFunction %2 %12 %4 = OpFunction %2 None %3 %5 = OpLabel %13 = OpVariable %12 Function OpBranch %6 %6 = OpLabel %104 = OpFunctionCall %2 %102 %13 OpBranch %10 %10 = OpLabel OpReturn OpFunctionEnd %102 = OpFunction %2 None %101 %106 = OpFunctionParameter %12 %103 = OpLabel %8 = OpLoad %20 %106 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationOutlineFunctionTest, OutlineCodeThatUsesAParameter) { // This tests outlining of a block that uses a function parameter. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %10 "foo(i1;" OpName %9 "x" OpName %18 "param" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %6 %7 %13 = OpConstant %6 1 %17 = OpConstant %6 3 %4 = OpFunction %2 None %3 %5 = OpLabel %18 = OpVariable %7 Function OpStore %18 %17 %19 = OpFunctionCall %6 %10 %18 OpReturn OpFunctionEnd %10 = OpFunction %6 None %8 %9 = OpFunctionParameter %7 %11 = OpLabel %12 = OpLoad %6 %9 %14 = OpIAdd %6 %12 %13 OpReturnValue %14 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationOutlineFunction transformation(11, 11, 100, 101, 102, 103, 104, 105, {{9, 106}}, {{14, 107}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %10 "foo(i1;" OpName %9 "x" OpName %18 "param" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %6 %7 %13 = OpConstant %6 1 %17 = OpConstant %6 3 %100 = OpTypeStruct %6 %101 = OpTypeFunction %100 %7 %4 = OpFunction %2 None %3 %5 = OpLabel %18 = OpVariable %7 Function OpStore %18 %17 %19 = OpFunctionCall %6 %10 %18 OpReturn OpFunctionEnd %10 = OpFunction %6 None %8 %9 = OpFunctionParameter %7 %11 = OpLabel %104 = OpFunctionCall %100 %102 %9 %14 = OpCompositeExtract %6 %104 0 OpReturnValue %14 OpFunctionEnd %102 = OpFunction %100 None %101 %106 = OpFunctionParameter %7 %103 = OpLabel %12 = OpLoad %6 %106 %107 = OpIAdd %6 %12 %13 %105 = OpCompositeConstruct %100 %107 OpReturnValue %105 OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationOutlineFunctionTest, DoNotOutlineIfLoopMergeIsOutsideRegion) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %9 = OpTypeBool %10 = OpConstantTrue %9 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %6 %6 = OpLabel OpLoopMerge %7 %8 None OpBranch %8 %8 = OpLabel OpBranchConditional %10 %6 %7 %7 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationOutlineFunction transformation(6, 8, 100, 101, 102, 103, 104, 105, {}, {}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationOutlineFunctionTest, DoNotOutlineIfRegionInvolvesReturn) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %20 = OpTypeBool %21 = OpConstantTrue %20 %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %6 %6 = OpLabel OpBranch %7 %7 = OpLabel OpSelectionMerge %10 None OpBranchConditional %21 %8 %9 %8 = OpLabel OpReturn %9 = OpLabel OpBranch %10 %10 = OpLabel OpBranch %11 %11 = OpLabel OpBranch %12 %12 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationOutlineFunction transformation(6, 11, /* not relevant */ 200, 100, 101, 102, 103, /* not relevant */ 201, {}, {}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationOutlineFunctionTest, DoNotOutlineIfRegionInvolvesKill) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %20 = OpTypeBool %21 = OpConstantTrue %20 %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %6 %6 = OpLabel OpBranch %7 %7 = OpLabel OpSelectionMerge %10 None OpBranchConditional %21 %8 %9 %8 = OpLabel OpKill %9 = OpLabel OpBranch %10 %10 = OpLabel OpBranch %11 %11 = OpLabel OpBranch %12 %12 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationOutlineFunction transformation(6, 11, /* not relevant */ 200, 100, 101, 102, 103, /* not relevant */ 201, {}, {}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationOutlineFunctionTest, DoNotOutlineIfRegionInvolvesUnreachable) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %20 = OpTypeBool %21 = OpConstantTrue %20 %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %6 %6 = OpLabel OpBranch %7 %7 = OpLabel OpSelectionMerge %10 None OpBranchConditional %21 %8 %9 %8 = OpLabel OpBranch %10 %9 = OpLabel OpUnreachable %10 = OpLabel OpBranch %11 %11 = OpLabel OpBranch %12 %12 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationOutlineFunction transformation(6, 11, /* not relevant */ 200, 100, 101, 102, 103, /* not relevant */ 201, {}, {}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationOutlineFunctionTest, DoNotOutlineIfSelectionMergeIsOutsideRegion) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %9 = OpTypeBool %10 = OpConstantTrue %9 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %6 %6 = OpLabel OpSelectionMerge %7 None OpBranchConditional %10 %8 %7 %8 = OpLabel OpBranch %7 %7 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationOutlineFunction transformation(6, 8, 100, 101, 102, 103, 104, 105, {}, {}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationOutlineFunctionTest, DoNotOutlineIfLoopHeadIsOutsideRegion) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %9 = OpTypeBool %10 = OpConstantTrue %9 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %6 %6 = OpLabel OpLoopMerge %8 %11 None OpBranch %7 %7 = OpLabel OpBranchConditional %10 %11 %8 %11 = OpLabel OpBranch %6 %8 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationOutlineFunction transformation(7, 8, 100, 101, 102, 103, 104, 105, {}, {}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationOutlineFunctionTest, DoNotOutlineIfLoopContinueIsOutsideRegion) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %9 = OpTypeBool %10 = OpConstantTrue %9 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %6 %6 = OpLabel OpLoopMerge %7 %8 None OpBranch %7 %8 = OpLabel OpBranch %6 %7 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationOutlineFunction transformation(6, 7, 100, 101, 102, 103, 104, 105, {}, {}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationOutlineFunctionTest, DoNotOutlineWithLoopCarriedPhiDependence) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %9 = OpTypeBool %10 = OpConstantTrue %9 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %6 %6 = OpLabel %12 = OpPhi %9 %10 %5 %13 %8 OpLoopMerge %7 %8 None OpBranch %8 %8 = OpLabel %13 = OpCopyObject %9 %10 OpBranchConditional %10 %6 %7 %7 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationOutlineFunction transformation(6, 7, 100, 101, 102, 103, 104, 105, {}, {}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationOutlineFunctionTest, DoNotOutlineSelectionHeaderNotInRegion) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantTrue %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %10 None OpBranchConditional %7 %8 %8 %8 = OpLabel OpBranch %9 %9 = OpLabel OpBranch %10 %10 = OpLabel OpBranch %11 %11 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationOutlineFunction transformation(8, 11, 100, 101, 102, 103, 104, 105, {}, {}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationOutlineFunctionTest, OutlineRegionEndingWithReturnVoid) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %20 = OpTypeInt 32 0 %21 = OpConstant %20 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel %22 = OpCopyObject %20 %21 OpBranch %54 %54 = OpLabel OpBranch %57 %57 = OpLabel %23 = OpCopyObject %20 %22 OpBranch %58 %58 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationOutlineFunction transformation( /*entry_block*/ 54, /*exit_block*/ 58, /*new_function_struct_return_type_id*/ 200, /*new_function_type_id*/ 201, /*new_function_id*/ 202, /*new_function_region_entry_block*/ 203, /*new_caller_result_id*/ 204, /*new_callee_result_id*/ 205, /*input_id_to_fresh_id*/ {{22, 206}}, /*output_id_to_fresh_id*/ {}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %20 = OpTypeInt 32 0 %21 = OpConstant %20 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %201 = OpTypeFunction %2 %20 %4 = OpFunction %2 None %3 %5 = OpLabel %22 = OpCopyObject %20 %21 OpBranch %54 %54 = OpLabel %204 = OpFunctionCall %2 %202 %22 OpReturn OpFunctionEnd %202 = OpFunction %2 None %201 %206 = OpFunctionParameter %20 %203 = OpLabel OpBranch %57 %57 = OpLabel %23 = OpCopyObject %20 %206 OpBranch %58 %58 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationOutlineFunctionTest, OutlineRegionEndingWithReturnValue) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %20 = OpTypeInt 32 0 %21 = OpConstant %20 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %30 = OpTypeFunction %20 %4 = OpFunction %2 None %3 %5 = OpLabel %6 = OpFunctionCall %20 %100 OpReturn OpFunctionEnd %100 = OpFunction %20 None %30 %8 = OpLabel %31 = OpCopyObject %20 %21 OpBranch %9 %9 = OpLabel %32 = OpCopyObject %20 %31 OpBranch %10 %10 = OpLabel OpReturnValue %32 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationOutlineFunction transformation( /*entry_block*/ 9, /*exit_block*/ 10, /*new_function_struct_return_type_id*/ 200, /*new_function_type_id*/ 201, /*new_function_id*/ 202, /*new_function_region_entry_block*/ 203, /*new_caller_result_id*/ 204, /*new_callee_result_id*/ 205, /*input_id_to_fresh_id*/ {{31, 206}}, /*output_id_to_fresh_id*/ {{32, 207}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %20 = OpTypeInt 32 0 %21 = OpConstant %20 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %30 = OpTypeFunction %20 %200 = OpTypeStruct %20 %201 = OpTypeFunction %200 %20 %4 = OpFunction %2 None %3 %5 = OpLabel %6 = OpFunctionCall %20 %100 OpReturn OpFunctionEnd %100 = OpFunction %20 None %30 %8 = OpLabel %31 = OpCopyObject %20 %21 OpBranch %9 %9 = OpLabel %204 = OpFunctionCall %200 %202 %31 %32 = OpCompositeExtract %20 %204 0 OpReturnValue %32 OpFunctionEnd %202 = OpFunction %200 None %201 %206 = OpFunctionParameter %20 %203 = OpLabel %207 = OpCopyObject %20 %206 OpBranch %10 %10 = OpLabel %205 = OpCompositeConstruct %200 %207 OpReturnValue %205 OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationOutlineFunctionTest, OutlineRegionEndingWithConditionalBranch) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %20 = OpTypeBool %21 = OpConstantTrue %20 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %54 %54 = OpLabel %6 = OpCopyObject %20 %21 OpSelectionMerge %8 None OpBranchConditional %6 %7 %8 %7 = OpLabel OpBranch %8 %8 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationOutlineFunction transformation( /*entry_block*/ 54, /*exit_block*/ 54, /*new_function_struct_return_type_id*/ 200, /*new_function_type_id*/ 201, /*new_function_id*/ 202, /*new_function_region_entry_block*/ 203, /*new_caller_result_id*/ 204, /*new_callee_result_id*/ 205, /*input_id_to_fresh_id*/ {{}}, /*output_id_to_fresh_id*/ {{6, 206}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %20 = OpTypeBool %21 = OpConstantTrue %20 %2 = OpTypeVoid %3 = OpTypeFunction %2 %200 = OpTypeStruct %20 %201 = OpTypeFunction %200 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %54 %54 = OpLabel %204 = OpFunctionCall %200 %202 %6 = OpCompositeExtract %20 %204 0 OpSelectionMerge %8 None OpBranchConditional %6 %7 %8 %7 = OpLabel OpBranch %8 %8 = OpLabel OpReturn OpFunctionEnd %202 = OpFunction %200 None %201 %203 = OpLabel %206 = OpCopyObject %20 %21 %205 = OpCompositeConstruct %200 %206 OpReturnValue %205 OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationOutlineFunctionTest, OutlineRegionEndingWithConditionalBranch2) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %20 = OpTypeBool %21 = OpConstantTrue %20 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel %6 = OpCopyObject %20 %21 OpBranch %54 %54 = OpLabel OpSelectionMerge %8 None OpBranchConditional %6 %7 %8 %7 = OpLabel OpBranch %8 %8 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationOutlineFunction transformation( /*entry_block*/ 54, /*exit_block*/ 54, /*new_function_struct_return_type_id*/ 200, /*new_function_type_id*/ 201, /*new_function_id*/ 202, /*new_function_region_entry_block*/ 203, /*new_caller_result_id*/ 204, /*new_callee_result_id*/ 205, /*input_id_to_fresh_id*/ {}, /*output_id_to_fresh_id*/ {}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %20 = OpTypeBool %21 = OpConstantTrue %20 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel %6 = OpCopyObject %20 %21 OpBranch %54 %54 = OpLabel %204 = OpFunctionCall %2 %202 OpSelectionMerge %8 None OpBranchConditional %6 %7 %8 %7 = OpLabel OpBranch %8 %8 = OpLabel OpReturn OpFunctionEnd %202 = OpFunction %2 None %3 %203 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationOutlineFunctionTest, DoNotOutlineRegionThatStartsWithOpPhi) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantTrue %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %21 %21 = OpLabel %22 = OpPhi %6 %7 %5 %23 = OpCopyObject %6 %22 OpBranch %24 %24 = OpLabel %25 = OpCopyObject %6 %23 %26 = OpCopyObject %6 %22 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationOutlineFunction transformation( /*entry_block*/ 21, /*exit_block*/ 21, /*new_function_struct_return_type_id*/ 200, /*new_function_type_id*/ 201, /*new_function_id*/ 202, /*new_function_region_entry_block*/ 204, /*new_caller_result_id*/ 205, /*new_callee_result_id*/ 206, /*input_id_to_fresh_id*/ {{22, 207}}, /*output_id_to_fresh_id*/ {{23, 208}}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationOutlineFunctionTest, DoNotOutlineRegionThatStartsWithLoopHeader) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantTrue %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %21 %21 = OpLabel OpLoopMerge %22 %23 None OpBranch %24 %24 = OpLabel OpBranchConditional %7 %22 %23 %23 = OpLabel OpBranch %21 %22 = OpLabel OpBranch %25 %25 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationOutlineFunction transformation( /*entry_block*/ 21, /*exit_block*/ 24, /*new_function_struct_return_type_id*/ 200, /*new_function_type_id*/ 201, /*new_function_id*/ 202, /*new_function_region_entry_block*/ 204, /*new_caller_result_id*/ 205, /*new_callee_result_id*/ 206, /*input_id_to_fresh_id*/ {}, /*output_id_to_fresh_id*/ {}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationOutlineFunctionTest, DoNotOutlineRegionThatEndsWithLoopMerge) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantTrue %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %21 %21 = OpLabel OpLoopMerge %22 %23 None OpBranch %24 %24 = OpLabel OpBranchConditional %7 %22 %23 %23 = OpLabel OpBranch %21 %22 = OpLabel OpBranch %25 %25 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationOutlineFunction transformation( /*entry_block*/ 5, /*exit_block*/ 22, /*new_function_struct_return_type_id*/ 200, /*new_function_type_id*/ 201, /*new_function_id*/ 202, /*new_function_region_entry_block*/ 204, /*new_caller_result_id*/ 205, /*new_callee_result_id*/ 206, /*input_id_to_fresh_id*/ {}, /*output_id_to_fresh_id*/ {}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationOutlineFunctionTest, DoNotOutlineRegionThatUsesAccessChain) { // An access chain result is a pointer, but it cannot be passed as a function // parameter, as it is not a memory object. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypePointer Function %7 %9 = OpTypePointer Function %6 %18 = OpTypeInt 32 0 %19 = OpConstant %18 0 %4 = OpFunction %2 None %3 %5 = OpLabel %10 = OpVariable %8 Function OpBranch %11 %11 = OpLabel %12 = OpAccessChain %9 %10 %19 OpBranch %13 %13 = OpLabel %14 = OpLoad %6 %12 OpBranch %15 %15 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationOutlineFunction transformation( /*entry_block*/ 13, /*exit_block*/ 15, /*new_function_struct_return_type_id*/ 200, /*new_function_type_id*/ 201, /*new_function_id*/ 202, /*new_function_region_entry_block*/ 204, /*new_caller_result_id*/ 205, /*new_callee_result_id*/ 206, /*input_id_to_fresh_id*/ {{12, 207}}, /*output_id_to_fresh_id*/ {}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationOutlineFunctionTest, DoNotOutlineRegionThatUsesCopiedObject) { // Copying a variable leads to a pointer, but one that cannot be passed as a // function parameter, as it is not a memory object. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypePointer Function %7 %9 = OpTypePointer Function %6 %18 = OpTypeInt 32 0 %19 = OpConstant %18 0 %4 = OpFunction %2 None %3 %5 = OpLabel %10 = OpVariable %8 Function OpBranch %11 %11 = OpLabel %20 = OpCopyObject %8 %10 OpBranch %13 %13 = OpLabel %12 = OpAccessChain %9 %20 %19 %14 = OpLoad %6 %12 OpBranch %15 %15 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationOutlineFunction transformation( /*entry_block*/ 13, /*exit_block*/ 15, /*new_function_struct_return_type_id*/ 200, /*new_function_type_id*/ 201, /*new_function_id*/ 202, /*new_function_region_entry_block*/ 204, /*new_caller_result_id*/ 205, /*new_callee_result_id*/ 206, /*input_id_to_fresh_id*/ {{20, 207}}, /*output_id_to_fresh_id*/ {}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationOutlineFunctionTest, DoOutlineRegionThatUsesPointerParameter) { // The region being outlined reads from a function parameter of pointer type. // This is OK: the function parameter can itself be passed on as a function // parameter. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %2 %7 %13 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %15 = OpVariable %7 Function %16 = OpVariable %7 Function %17 = OpLoad %6 %15 OpStore %16 %17 %18 = OpFunctionCall %2 %10 %16 %19 = OpLoad %6 %16 OpStore %15 %19 OpReturn OpFunctionEnd %10 = OpFunction %2 None %8 %9 = OpFunctionParameter %7 %11 = OpLabel %12 = OpLoad %6 %9 %14 = OpIAdd %6 %12 %13 OpBranch %20 %20 = OpLabel OpStore %9 %14 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationOutlineFunction transformation( /*entry_block*/ 11, /*exit_block*/ 11, /*new_function_struct_return_type_id*/ 200, /*new_function_type_id*/ 201, /*new_function_id*/ 202, /*new_function_region_entry_block*/ 204, /*new_caller_result_id*/ 205, /*new_callee_result_id*/ 206, /*input_id_to_fresh_id*/ {{9, 207}}, /*output_id_to_fresh_id*/ {{14, 208}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %2 %7 %13 = OpConstant %6 2 %200 = OpTypeStruct %6 %201 = OpTypeFunction %200 %7 %4 = OpFunction %2 None %3 %5 = OpLabel %15 = OpVariable %7 Function %16 = OpVariable %7 Function %17 = OpLoad %6 %15 OpStore %16 %17 %18 = OpFunctionCall %2 %10 %16 %19 = OpLoad %6 %16 OpStore %15 %19 OpReturn OpFunctionEnd %10 = OpFunction %2 None %8 %9 = OpFunctionParameter %7 %11 = OpLabel %205 = OpFunctionCall %200 %202 %9 %14 = OpCompositeExtract %6 %205 0 OpBranch %20 %20 = OpLabel OpStore %9 %14 OpReturn OpFunctionEnd %202 = OpFunction %200 None %201 %207 = OpFunctionParameter %7 %204 = OpLabel %12 = OpLoad %6 %207 %208 = OpIAdd %6 %12 %13 %206 = OpCompositeConstruct %200 %208 OpReturnValue %206 OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationOutlineFunctionTest, OutlineLivesafe) { // In the following, %30 is a livesafe function, with irrelevant parameter // %200 and irrelevant local variable %201. Variable %100 is a loop limiter, // which is not irrelevant. The test checks that the outlined function is // livesafe, and that the parameters corresponding to %200 and %201 have the // irrelevant fact associated with them. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpTypePointer Function %6 %199 = OpTypeFunction %2 %7 %8 = OpConstant %6 0 %9 = OpConstant %6 1 %10 = OpConstant %6 5 %11 = OpTypeBool %12 = OpConstantTrue %11 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %30 = OpFunction %2 None %199 %200 = OpFunctionParameter %7 %31 = OpLabel %100 = OpVariable %7 Function %8 %201 = OpVariable %7 Function %8 OpBranch %198 %198 = OpLabel OpBranch %20 %20 = OpLabel %101 = OpLoad %6 %100 %102 = OpIAdd %6 %101 %9 %202 = OpLoad %6 %200 OpStore %201 %202 OpStore %100 %102 %103 = OpUGreaterThanEqual %11 %101 %10 OpLoopMerge %21 %22 None OpBranchConditional %103 %21 %104 %104 = OpLabel OpBranchConditional %12 %23 %21 %23 = OpLabel %105 = OpLoad %6 %100 %106 = OpIAdd %6 %105 %9 OpStore %100 %106 %107 = OpUGreaterThanEqual %11 %105 %10 OpLoopMerge %25 %26 None OpBranchConditional %107 %25 %108 %108 = OpLabel OpBranch %28 %28 = OpLabel OpBranchConditional %12 %26 %25 %26 = OpLabel OpBranch %23 %25 = OpLabel %109 = OpLoad %6 %100 %110 = OpIAdd %6 %109 %9 OpStore %100 %110 %111 = OpUGreaterThanEqual %11 %109 %10 OpLoopMerge %24 %27 None OpBranchConditional %111 %24 %112 %112 = OpLabel OpBranchConditional %12 %24 %27 %27 = OpLabel OpBranch %25 %24 = OpLabel OpBranch %22 %22 = OpLabel OpBranch %20 %21 = OpLabel OpBranch %197 %197 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactFunctionIsLivesafe(30); transformation_context.GetFactManager()->AddFactValueOfPointeeIsIrrelevant( 200); transformation_context.GetFactManager()->AddFactValueOfPointeeIsIrrelevant( 201); TransformationOutlineFunction transformation( /*entry_block*/ 198, /*exit_block*/ 197, /*new_function_struct_return_type_id*/ 400, /*new_function_type_id*/ 401, /*new_function_id*/ 402, /*new_function_region_entry_block*/ 404, /*new_caller_result_id*/ 405, /*new_callee_result_id*/ 406, /*input_id_to_fresh_id*/ {{100, 407}, {200, 408}, {201, 409}}, /*output_id_to_fresh_id*/ {}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // The original function should still be livesafe. ASSERT_TRUE(transformation_context.GetFactManager()->FunctionIsLivesafe(30)); // The outlined function should be livesafe. ASSERT_TRUE(transformation_context.GetFactManager()->FunctionIsLivesafe(402)); // The variable and parameter that were originally irrelevant should still be. ASSERT_TRUE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(200)); ASSERT_TRUE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(201)); // The loop limiter should still be non-irrelevant. ASSERT_FALSE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(100)); // The parameters for the original irrelevant variables should be irrelevant. ASSERT_TRUE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(408)); ASSERT_TRUE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(409)); // The parameter for the loop limiter should not be irrelevant. ASSERT_FALSE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(407)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpTypePointer Function %6 %199 = OpTypeFunction %2 %7 %8 = OpConstant %6 0 %9 = OpConstant %6 1 %10 = OpConstant %6 5 %11 = OpTypeBool %12 = OpConstantTrue %11 %401 = OpTypeFunction %2 %7 %7 %7 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %30 = OpFunction %2 None %199 %200 = OpFunctionParameter %7 %31 = OpLabel %100 = OpVariable %7 Function %8 %201 = OpVariable %7 Function %8 OpBranch %198 %198 = OpLabel %405 = OpFunctionCall %2 %402 %200 %100 %201 OpReturn OpFunctionEnd %402 = OpFunction %2 None %401 %408 = OpFunctionParameter %7 %407 = OpFunctionParameter %7 %409 = OpFunctionParameter %7 %404 = OpLabel OpBranch %20 %20 = OpLabel %101 = OpLoad %6 %407 %102 = OpIAdd %6 %101 %9 %202 = OpLoad %6 %408 OpStore %409 %202 OpStore %407 %102 %103 = OpUGreaterThanEqual %11 %101 %10 OpLoopMerge %21 %22 None OpBranchConditional %103 %21 %104 %104 = OpLabel OpBranchConditional %12 %23 %21 %23 = OpLabel %105 = OpLoad %6 %407 %106 = OpIAdd %6 %105 %9 OpStore %407 %106 %107 = OpUGreaterThanEqual %11 %105 %10 OpLoopMerge %25 %26 None OpBranchConditional %107 %25 %108 %108 = OpLabel OpBranch %28 %28 = OpLabel OpBranchConditional %12 %26 %25 %26 = OpLabel OpBranch %23 %25 = OpLabel %109 = OpLoad %6 %407 %110 = OpIAdd %6 %109 %9 OpStore %407 %110 %111 = OpUGreaterThanEqual %11 %109 %10 OpLoopMerge %24 %27 None OpBranchConditional %111 %24 %112 %112 = OpLabel OpBranchConditional %12 %24 %27 %27 = OpLabel OpBranch %25 %24 = OpLabel OpBranch %22 %22 = OpLabel OpBranch %20 %21 = OpLabel OpBranch %197 %197 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationOutlineFunctionTest, OutlineWithDeadBlocks1) { // This checks that if all blocks in the region being outlined were dead, all // blocks in the outlined function will be dead. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %10 "foo(i1;" OpName %9 "x" OpName %12 "y" OpName %21 "i" OpName %46 "param" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %2 %7 %13 = OpConstant %6 2 %14 = OpTypeBool %15 = OpConstantFalse %14 %22 = OpConstant %6 0 %29 = OpConstant %6 10 %41 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %46 = OpVariable %7 Function OpStore %46 %13 %47 = OpFunctionCall %2 %10 %46 OpReturn OpFunctionEnd %10 = OpFunction %2 None %8 %9 = OpFunctionParameter %7 %11 = OpLabel %12 = OpVariable %7 Function %21 = OpVariable %7 Function OpStore %12 %13 OpSelectionMerge %17 None OpBranchConditional %15 %16 %17 %16 = OpLabel %18 = OpLoad %6 %9 OpStore %12 %18 %19 = OpLoad %6 %9 %20 = OpIAdd %6 %19 %13 OpStore %9 %20 OpStore %21 %22 OpBranch %23 %23 = OpLabel OpLoopMerge %25 %26 None OpBranch %27 %27 = OpLabel %28 = OpLoad %6 %21 %30 = OpSLessThan %14 %28 %29 OpBranchConditional %30 %24 %25 %24 = OpLabel %31 = OpLoad %6 %9 %32 = OpLoad %6 %21 %33 = OpSGreaterThan %14 %31 %32 OpSelectionMerge %35 None OpBranchConditional %33 %34 %35 %34 = OpLabel OpBranch %26 %35 = OpLabel %37 = OpLoad %6 %9 %38 = OpLoad %6 %12 %39 = OpIAdd %6 %38 %37 OpStore %12 %39 OpBranch %26 %26 = OpLabel %40 = OpLoad %6 %21 %42 = OpIAdd %6 %40 %41 OpStore %21 %42 OpBranch %23 %25 = OpLabel OpBranch %50 %50 = OpLabel OpBranch %17 %17 = OpLabel %43 = OpLoad %6 %9 %44 = OpLoad %6 %12 %45 = OpIAdd %6 %44 %43 OpStore %12 %45 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); for (uint32_t block_id : {16u, 23u, 24u, 26u, 27u, 34u, 35u, 50u}) { transformation_context.GetFactManager()->AddFactBlockIsDead(block_id); } TransformationOutlineFunction transformation( /*entry_block*/ 16, /*exit_block*/ 50, /*new_function_struct_return_type_id*/ 200, /*new_function_type_id*/ 201, /*new_function_id*/ 202, /*new_function_region_entry_block*/ 203, /*new_caller_result_id*/ 204, /*new_callee_result_id*/ 205, /*input_id_to_fresh_id*/ {{9, 206}, {12, 207}, {21, 208}}, /*output_id_to_fresh_id*/ {}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // All the original blocks, plus the new function entry block, should be dead. for (uint32_t block_id : {16u, 23u, 24u, 26u, 27u, 34u, 35u, 50u, 203u}) { ASSERT_TRUE(transformation_context.GetFactManager()->BlockIsDead(block_id)); } } TEST(TransformationOutlineFunctionTest, OutlineWithDeadBlocks2) { // This checks that if some, but not all, blocks in the outlined region are // dead, those (but not others) will be dead in the outlined function. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %8 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpTypePointer Private %6 %8 = OpVariable %7 Private %9 = OpConstantFalse %6 %10 = OpTypePointer Function %6 %12 = OpConstantTrue %6 %4 = OpFunction %2 None %3 %5 = OpLabel %11 = OpVariable %10 Function OpBranch %30 %30 = OpLabel OpStore %8 %9 OpBranch %31 %31 = OpLabel OpStore %11 %12 OpSelectionMerge %36 None OpBranchConditional %9 %32 %33 %32 = OpLabel OpBranch %34 %33 = OpLabel OpBranch %36 %34 = OpLabel OpBranch %35 %35 = OpLabel OpBranch %36 %36 = OpLabel OpBranch %37 %37 = OpLabel %13 = OpLoad %6 %8 OpStore %11 %13 %14 = OpLoad %6 %11 OpStore %8 %14 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); for (uint32_t block_id : {32u, 34u, 35u}) { transformation_context.GetFactManager()->AddFactBlockIsDead(block_id); } TransformationOutlineFunction transformation( /*entry_block*/ 30, /*exit_block*/ 37, /*new_function_struct_return_type_id*/ 200, /*new_function_type_id*/ 201, /*new_function_id*/ 202, /*new_function_region_entry_block*/ 203, /*new_caller_result_id*/ 204, /*new_callee_result_id*/ 205, /*input_id_to_fresh_id*/ {{11, 206}}, /*output_id_to_fresh_id*/ {}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // The blocks that were originally dead, but not others, should be dead. for (uint32_t block_id : {32u, 34u, 35u}) { ASSERT_TRUE(transformation_context.GetFactManager()->BlockIsDead(block_id)); } for (uint32_t block_id : {5u, 30u, 31u, 33u, 36u, 37u, 203u}) { ASSERT_FALSE( transformation_context.GetFactManager()->BlockIsDead(block_id)); } } TEST(TransformationOutlineFunctionTest, OutlineWithIrrelevantVariablesAndParameters) { // This checks that if the outlined region uses a mixture of irrelevant and // non-irrelevant variables and parameters, these properties are preserved // during outlining. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %2 %7 %7 %13 = OpConstant %6 2 %15 = OpConstant %6 3 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %11 = OpFunction %2 None %8 %9 = OpFunctionParameter %7 %10 = OpFunctionParameter %7 %12 = OpLabel %14 = OpVariable %7 Function %20 = OpVariable %7 Function OpBranch %50 %50 = OpLabel OpStore %9 %13 OpStore %14 %15 %16 = OpLoad %6 %14 OpStore %10 %16 %17 = OpLoad %6 %9 %18 = OpLoad %6 %10 %19 = OpIAdd %6 %17 %18 OpStore %14 %19 %21 = OpLoad %6 %9 OpStore %20 %21 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactValueOfPointeeIsIrrelevant(9); transformation_context.GetFactManager()->AddFactValueOfPointeeIsIrrelevant( 14); TransformationOutlineFunction transformation( /*entry_block*/ 50, /*exit_block*/ 50, /*new_function_struct_return_type_id*/ 200, /*new_function_type_id*/ 201, /*new_function_id*/ 202, /*new_function_region_entry_block*/ 203, /*new_caller_result_id*/ 204, /*new_callee_result_id*/ 205, /*input_id_to_fresh_id*/ {{9, 206}, {10, 207}, {14, 208}, {20, 209}}, /*output_id_to_fresh_id*/ {}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // The variables that were originally irrelevant, plus input parameters // corresponding to them, should be irrelevant. The rest should not be. for (uint32_t variable_id : {9u, 14u, 206u, 208u}) { ASSERT_TRUE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant( variable_id)); } for (uint32_t variable_id : {10u, 20u, 207u, 209u}) { ASSERT_FALSE( transformation_context.GetFactManager()->BlockIsDead(variable_id)); } } TEST(TransformationOutlineFunctionTest, DoNotOutlineCodeThatProducesUsedPointer) { // This checks that we cannot outline a region of code if it produces a // pointer result id that gets used outside the region. This avoids creating // a struct with a pointer member. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %6 "main" OpExecutionMode %6 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %21 = OpTypeBool %100 = OpTypeInt 32 0 %99 = OpConstant %100 0 %101 = OpTypeVector %100 2 %102 = OpTypePointer Function %100 %103 = OpTypePointer Function %101 %6 = OpFunction %2 None %3 %7 = OpLabel %104 = OpVariable %103 Function OpBranch %80 %80 = OpLabel %105 = OpAccessChain %102 %104 %99 OpBranch %106 %106 = OpLabel OpStore %105 %99 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationOutlineFunction transformation( /*entry_block*/ 80, /*exit_block*/ 80, /*new_function_struct_return_type_id*/ 300, /*new_function_type_id*/ 301, /*new_function_id*/ 302, /*new_function_region_entry_block*/ 304, /*new_caller_result_id*/ 305, /*new_callee_result_id*/ 306, /*input_id_to_fresh_id*/ {{104, 307}}, /*output_id_to_fresh_id*/ {{105, 308}}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationOutlineFunctionTest, ExitBlockHeadsLoop) { // This checks that it is not possible outline a region that ends in a loop // head. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %15 = OpTypeInt 32 1 %35 = OpTypeBool %39 = OpConstant %15 1 %40 = OpConstantTrue %35 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %22 %22 = OpLabel OpBranch %23 %23 = OpLabel %24 = OpPhi %15 %39 %22 %39 %25 OpLoopMerge %26 %25 None OpBranchConditional %40 %25 %26 %25 = OpLabel OpBranch %23 %26 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationOutlineFunction transformation( /*entry_block*/ 22, /*exit_block*/ 23, /*new_function_struct_return_type_id*/ 200, /*new_function_type_id*/ 201, /*new_function_id*/ 202, /*new_function_region_entry_block*/ 203, /*new_caller_result_id*/ 204, /*new_callee_result_id*/ 205, /*input_id_to_fresh_id*/ {}, /*output_id_to_fresh_id*/ {}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } TEST(TransformationOutlineFunctionTest, Miscellaneous1) { // This tests outlining of some non-trivial code, and also tests the way // overflow ids are used by the transformation. std::string reference_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %85 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %28 "buf" OpMemberName %28 0 "u1" OpMemberName %28 1 "u2" OpName %30 "" OpName %85 "color" OpMemberDecorate %28 0 Offset 0 OpMemberDecorate %28 1 Offset 4 OpDecorate %28 Block OpDecorate %30 DescriptorSet 0 OpDecorate %30 Binding 0 OpDecorate %85 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %10 = OpConstant %6 1 %11 = OpConstant %6 2 %12 = OpConstant %6 3 %13 = OpConstant %6 4 %14 = OpConstantComposite %7 %10 %11 %12 %13 %15 = OpTypeInt 32 1 %18 = OpConstant %15 0 %28 = OpTypeStruct %6 %6 %29 = OpTypePointer Uniform %28 %30 = OpVariable %29 Uniform %31 = OpTypePointer Uniform %6 %35 = OpTypeBool %39 = OpConstant %15 1 %84 = OpTypePointer Output %7 %85 = OpVariable %84 Output %114 = OpConstant %15 8 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %22 %22 = OpLabel %103 = OpPhi %15 %18 %5 %106 %43 %102 = OpPhi %7 %14 %5 %107 %43 %101 = OpPhi %15 %18 %5 %40 %43 %32 = OpAccessChain %31 %30 %18 %33 = OpLoad %6 %32 %34 = OpConvertFToS %15 %33 %36 = OpSLessThan %35 %101 %34 OpLoopMerge %24 %43 None OpBranchConditional %36 %23 %24 %23 = OpLabel %40 = OpIAdd %15 %101 %39 OpBranch %150 %150 = OpLabel OpBranch %41 %41 = OpLabel %107 = OpPhi %7 %102 %150 %111 %65 %106 = OpPhi %15 %103 %150 %110 %65 %104 = OpPhi %15 %40 %150 %81 %65 %47 = OpAccessChain %31 %30 %39 %48 = OpLoad %6 %47 %49 = OpConvertFToS %15 %48 %50 = OpSLessThan %35 %104 %49 OpLoopMerge %1000 %65 None OpBranchConditional %50 %42 %1000 %42 = OpLabel %60 = OpIAdd %15 %106 %114 %63 = OpSGreaterThan %35 %104 %60 OpBranchConditional %63 %64 %65 %64 = OpLabel %71 = OpCompositeExtract %6 %107 0 %72 = OpFAdd %6 %71 %11 %97 = OpCompositeInsert %7 %72 %107 0 %76 = OpCompositeExtract %6 %107 3 %77 = OpConvertFToS %15 %76 %79 = OpIAdd %15 %60 %77 OpBranch %65 %65 = OpLabel %111 = OpPhi %7 %107 %42 %97 %64 %110 = OpPhi %15 %60 %42 %79 %64 %81 = OpIAdd %15 %104 %39 OpBranch %41 %1000 = OpLabel OpBranch %1001 %1001 = OpLabel OpBranch %43 %43 = OpLabel OpBranch %22 %24 = OpLabel %87 = OpCompositeExtract %6 %102 0 %91 = OpConvertSToF %6 %103 %92 = OpCompositeConstruct %7 %87 %11 %91 %10 OpStore %85 %92 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; TransformationOutlineFunction transformation( /*entry_block*/ 150, /*exit_block*/ 1001, /*new_function_struct_return_type_id*/ 200, /*new_function_type_id*/ 201, /*new_function_id*/ 202, /*new_function_region_entry_block*/ 203, /*new_caller_result_id*/ 204, /*new_callee_result_id*/ 205, /*input_id_to_fresh_id*/ {{102, 300}, {103, 301}, {40, 302}}, /*output_id_to_fresh_id*/ {{106, 400}, {107, 401}}); TransformationOutlineFunction transformation_with_missing_input_id( /*entry_block*/ 150, /*exit_block*/ 1001, /*new_function_struct_return_type_id*/ 200, /*new_function_type_id*/ 201, /*new_function_id*/ 202, /*new_function_region_entry_block*/ 203, /*new_caller_result_id*/ 204, /*new_callee_result_id*/ 205, /*input_id_to_fresh_id*/ {{102, 300}, {40, 302}}, /*output_id_to_fresh_id*/ {{106, 400}, {107, 401}}); TransformationOutlineFunction transformation_with_missing_output_id( /*entry_block*/ 150, /*exit_block*/ 1001, /*new_function_struct_return_type_id*/ 200, /*new_function_type_id*/ 201, /*new_function_id*/ 202, /*new_function_region_entry_block*/ 203, /*new_caller_result_id*/ 204, /*new_callee_result_id*/ 205, /*input_id_to_fresh_id*/ {{102, 300}, {103, 301}, {40, 302}}, /*output_id_to_fresh_id*/ {{106, 400}}); TransformationOutlineFunction transformation_with_missing_input_and_output_ids( /*entry_block*/ 150, /*exit_block*/ 1001, /*new_function_struct_return_type_id*/ 200, /*new_function_type_id*/ 201, /*new_function_id*/ 202, /*new_function_region_entry_block*/ 203, /*new_caller_result_id*/ 204, /*new_callee_result_id*/ 205, /*input_id_to_fresh_id*/ {{102, 300}, {40, 302}}, /*output_id_to_fresh_id*/ {{106, 400}}); { const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); #ifndef NDEBUG // We expect the following applicability checks to lead to assertion // failures since the transformations are missing input or output ids, and // the transformation context does not have a source of overflow ids. ASSERT_DEATH(transformation_with_missing_input_id.IsApplicable( context.get(), transformation_context), "Bad attempt to query whether overflow ids are available."); ASSERT_DEATH(transformation_with_missing_output_id.IsApplicable( context.get(), transformation_context), "Bad attempt to query whether overflow ids are available."); ASSERT_DEATH(transformation_with_missing_input_and_output_ids.IsApplicable( context.get(), transformation_context), "Bad attempt to query whether overflow ids are available."); #endif ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); std::string variant_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %85 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %28 "buf" OpMemberName %28 0 "u1" OpMemberName %28 1 "u2" OpName %30 "" OpName %85 "color" OpMemberDecorate %28 0 Offset 0 OpMemberDecorate %28 1 Offset 4 OpDecorate %28 Block OpDecorate %30 DescriptorSet 0 OpDecorate %30 Binding 0 OpDecorate %85 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %10 = OpConstant %6 1 %11 = OpConstant %6 2 %12 = OpConstant %6 3 %13 = OpConstant %6 4 %14 = OpConstantComposite %7 %10 %11 %12 %13 %15 = OpTypeInt 32 1 %18 = OpConstant %15 0 %28 = OpTypeStruct %6 %6 %29 = OpTypePointer Uniform %28 %30 = OpVariable %29 Uniform %31 = OpTypePointer Uniform %6 %35 = OpTypeBool %39 = OpConstant %15 1 %84 = OpTypePointer Output %7 %85 = OpVariable %84 Output %114 = OpConstant %15 8 %200 = OpTypeStruct %7 %15 %201 = OpTypeFunction %200 %15 %7 %15 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %22 %22 = OpLabel %103 = OpPhi %15 %18 %5 %106 %43 %102 = OpPhi %7 %14 %5 %107 %43 %101 = OpPhi %15 %18 %5 %40 %43 %32 = OpAccessChain %31 %30 %18 %33 = OpLoad %6 %32 %34 = OpConvertFToS %15 %33 %36 = OpSLessThan %35 %101 %34 OpLoopMerge %24 %43 None OpBranchConditional %36 %23 %24 %23 = OpLabel %40 = OpIAdd %15 %101 %39 OpBranch %150 %150 = OpLabel %204 = OpFunctionCall %200 %202 %103 %102 %40 %107 = OpCompositeExtract %7 %204 0 %106 = OpCompositeExtract %15 %204 1 OpBranch %43 %43 = OpLabel OpBranch %22 %24 = OpLabel %87 = OpCompositeExtract %6 %102 0 %91 = OpConvertSToF %6 %103 %92 = OpCompositeConstruct %7 %87 %11 %91 %10 OpStore %85 %92 OpReturn OpFunctionEnd %202 = OpFunction %200 None %201 %301 = OpFunctionParameter %15 %300 = OpFunctionParameter %7 %302 = OpFunctionParameter %15 %203 = OpLabel OpBranch %41 %41 = OpLabel %401 = OpPhi %7 %300 %203 %111 %65 %400 = OpPhi %15 %301 %203 %110 %65 %104 = OpPhi %15 %302 %203 %81 %65 %47 = OpAccessChain %31 %30 %39 %48 = OpLoad %6 %47 %49 = OpConvertFToS %15 %48 %50 = OpSLessThan %35 %104 %49 OpLoopMerge %1000 %65 None OpBranchConditional %50 %42 %1000 %42 = OpLabel %60 = OpIAdd %15 %400 %114 %63 = OpSGreaterThan %35 %104 %60 OpBranchConditional %63 %64 %65 %64 = OpLabel %71 = OpCompositeExtract %6 %401 0 %72 = OpFAdd %6 %71 %11 %97 = OpCompositeInsert %7 %72 %401 0 %76 = OpCompositeExtract %6 %401 3 %77 = OpConvertFToS %15 %76 %79 = OpIAdd %15 %60 %77 OpBranch %65 %65 = OpLabel %111 = OpPhi %7 %401 %42 %97 %64 %110 = OpPhi %15 %60 %42 %79 %64 %81 = OpIAdd %15 %104 %39 OpBranch %41 %1000 = OpLabel OpBranch %1001 %1001 = OpLabel %205 = OpCompositeConstruct %200 %401 %400 OpReturnValue %205 OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, variant_shader, context.get())); } { const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); auto overflow_ids_unique_ptr = MakeUnique(2000); auto overflow_ids_ptr = overflow_ids_unique_ptr.get(); TransformationContext new_transformation_context( MakeUnique(context.get()), validator_options, std::move(overflow_ids_unique_ptr)); ASSERT_TRUE(transformation_with_missing_input_id.IsApplicable( context.get(), new_transformation_context)); ASSERT_TRUE(transformation_with_missing_output_id.IsApplicable( context.get(), new_transformation_context)); ASSERT_TRUE(transformation_with_missing_input_and_output_ids.IsApplicable( context.get(), new_transformation_context)); ApplyAndCheckFreshIds(transformation_with_missing_input_and_output_ids, context.get(), &new_transformation_context, overflow_ids_ptr->GetIssuedOverflowIds()); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); std::string variant_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %85 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %28 "buf" OpMemberName %28 0 "u1" OpMemberName %28 1 "u2" OpName %30 "" OpName %85 "color" OpMemberDecorate %28 0 Offset 0 OpMemberDecorate %28 1 Offset 4 OpDecorate %28 Block OpDecorate %30 DescriptorSet 0 OpDecorate %30 Binding 0 OpDecorate %85 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %10 = OpConstant %6 1 %11 = OpConstant %6 2 %12 = OpConstant %6 3 %13 = OpConstant %6 4 %14 = OpConstantComposite %7 %10 %11 %12 %13 %15 = OpTypeInt 32 1 %18 = OpConstant %15 0 %28 = OpTypeStruct %6 %6 %29 = OpTypePointer Uniform %28 %30 = OpVariable %29 Uniform %31 = OpTypePointer Uniform %6 %35 = OpTypeBool %39 = OpConstant %15 1 %84 = OpTypePointer Output %7 %85 = OpVariable %84 Output %114 = OpConstant %15 8 %200 = OpTypeStruct %7 %15 %201 = OpTypeFunction %200 %15 %7 %15 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %22 %22 = OpLabel %103 = OpPhi %15 %18 %5 %106 %43 %102 = OpPhi %7 %14 %5 %107 %43 %101 = OpPhi %15 %18 %5 %40 %43 %32 = OpAccessChain %31 %30 %18 %33 = OpLoad %6 %32 %34 = OpConvertFToS %15 %33 %36 = OpSLessThan %35 %101 %34 OpLoopMerge %24 %43 None OpBranchConditional %36 %23 %24 %23 = OpLabel %40 = OpIAdd %15 %101 %39 OpBranch %150 %150 = OpLabel %204 = OpFunctionCall %200 %202 %103 %102 %40 %107 = OpCompositeExtract %7 %204 0 %106 = OpCompositeExtract %15 %204 1 OpBranch %43 %43 = OpLabel OpBranch %22 %24 = OpLabel %87 = OpCompositeExtract %6 %102 0 %91 = OpConvertSToF %6 %103 %92 = OpCompositeConstruct %7 %87 %11 %91 %10 OpStore %85 %92 OpReturn OpFunctionEnd %202 = OpFunction %200 None %201 %2000 = OpFunctionParameter %15 %300 = OpFunctionParameter %7 %302 = OpFunctionParameter %15 %203 = OpLabel OpBranch %41 %41 = OpLabel %2001 = OpPhi %7 %300 %203 %111 %65 %400 = OpPhi %15 %2000 %203 %110 %65 %104 = OpPhi %15 %302 %203 %81 %65 %47 = OpAccessChain %31 %30 %39 %48 = OpLoad %6 %47 %49 = OpConvertFToS %15 %48 %50 = OpSLessThan %35 %104 %49 OpLoopMerge %1000 %65 None OpBranchConditional %50 %42 %1000 %42 = OpLabel %60 = OpIAdd %15 %400 %114 %63 = OpSGreaterThan %35 %104 %60 OpBranchConditional %63 %64 %65 %64 = OpLabel %71 = OpCompositeExtract %6 %2001 0 %72 = OpFAdd %6 %71 %11 %97 = OpCompositeInsert %7 %72 %2001 0 %76 = OpCompositeExtract %6 %2001 3 %77 = OpConvertFToS %15 %76 %79 = OpIAdd %15 %60 %77 OpBranch %65 %65 = OpLabel %111 = OpPhi %7 %2001 %42 %97 %64 %110 = OpPhi %15 %60 %42 %79 %64 %81 = OpIAdd %15 %104 %39 OpBranch %41 %1000 = OpLabel OpBranch %1001 %1001 = OpLabel %205 = OpCompositeConstruct %200 %2001 %400 OpReturnValue %205 OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, variant_shader, context.get())); } } TEST(TransformationOutlineFunctionTest, Miscellaneous2) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %21 = OpTypeBool %167 = OpConstantTrue %21 %168 = OpConstantFalse %21 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %34 %34 = OpLabel OpLoopMerge %36 %37 None OpBranchConditional %168 %37 %38 %38 = OpLabel OpBranchConditional %168 %37 %36 %37 = OpLabel OpBranch %34 %36 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationOutlineFunction transformation( /*entry_block*/ 38, /*exit_block*/ 36, /*new_function_struct_return_type_id*/ 200, /*new_function_type_id*/ 201, /*new_function_id*/ 202, /*new_function_region_entry_block*/ 203, /*new_caller_result_id*/ 204, /*new_callee_result_id*/ 205, /*input_id_to_fresh_id*/ {}, /*output_id_to_fresh_id*/ {}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationOutlineFunctionTest, Miscellaneous3) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %6 "main" OpExecutionMode %6 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %21 = OpTypeBool %167 = OpConstantTrue %21 %6 = OpFunction %2 None %3 %7 = OpLabel OpBranch %80 %80 = OpLabel OpBranch %14 %14 = OpLabel OpLoopMerge %16 %17 None OpBranch %18 %18 = OpLabel OpBranchConditional %167 %15 %16 %15 = OpLabel OpBranch %17 %16 = OpLabel OpBranch %81 %81 = OpLabel OpReturn %17 = OpLabel OpBranch %14 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationOutlineFunction transformation( /*entry_block*/ 80, /*exit_block*/ 81, /*new_function_struct_return_type_id*/ 300, /*new_function_type_id*/ 301, /*new_function_id*/ 302, /*new_function_region_entry_block*/ 304, /*new_caller_result_id*/ 305, /*new_callee_result_id*/ 306, /*input_id_to_fresh_id*/ {}, /*output_id_to_fresh_id*/ {}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %6 "main" OpExecutionMode %6 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %21 = OpTypeBool %167 = OpConstantTrue %21 %6 = OpFunction %2 None %3 %7 = OpLabel OpBranch %80 %80 = OpLabel %305 = OpFunctionCall %2 %302 OpReturn OpFunctionEnd %302 = OpFunction %2 None %3 %304 = OpLabel OpBranch %14 %14 = OpLabel OpLoopMerge %16 %17 None OpBranch %18 %18 = OpLabel OpBranchConditional %167 %15 %16 %15 = OpLabel OpBranch %17 %16 = OpLabel OpBranch %81 %81 = OpLabel OpReturn %17 = OpLabel OpBranch %14 OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationOutlineFunctionTest, Miscellaneous4) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %6 "main" OpExecutionMode %6 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %21 = OpTypeBool %100 = OpTypeInt 32 0 %101 = OpTypePointer Function %100 %102 = OpTypePointer Function %100 %103 = OpTypeFunction %2 %101 %6 = OpFunction %2 None %3 %7 = OpLabel %104 = OpVariable %102 Function OpBranch %80 %80 = OpLabel %105 = OpLoad %100 %104 OpBranch %106 %106 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationOutlineFunction transformation( /*entry_block*/ 80, /*exit_block*/ 106, /*new_function_struct_return_type_id*/ 300, /*new_function_type_id*/ 301, /*new_function_id*/ 302, /*new_function_region_entry_block*/ 304, /*new_caller_result_id*/ 305, /*new_callee_result_id*/ 306, /*input_id_to_fresh_id*/ {{104, 307}}, /*output_id_to_fresh_id*/ {}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %6 "main" OpExecutionMode %6 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %21 = OpTypeBool %100 = OpTypeInt 32 0 %101 = OpTypePointer Function %100 %102 = OpTypePointer Function %100 %103 = OpTypeFunction %2 %101 %301 = OpTypeFunction %2 %102 %6 = OpFunction %2 None %3 %7 = OpLabel %104 = OpVariable %102 Function OpBranch %80 %80 = OpLabel %305 = OpFunctionCall %2 %302 %104 OpReturn OpFunctionEnd %302 = OpFunction %2 None %301 %307 = OpFunctionParameter %102 %304 = OpLabel %105 = OpLoad %100 %307 OpBranch %106 %106 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationOutlineFunctionTest, NoOutlineWithUnreachableBlocks) { // This checks that outlining will not be performed if a node in the region // has an unreachable predecessor. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %7 = OpLabel OpBranch %5 %5 = OpLabel OpReturn %6 = OpLabel OpBranch %5 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationOutlineFunction transformation(5, 5, /* not relevant */ 200, 100, 101, 102, 103, /* not relevant */ 201, {}, {}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_permute_function_parameters_test.cpp000066400000000000000000000472431475742701700332220ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_permute_function_parameters.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationPermuteFunctionParametersTest, BasicTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %72 %74 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %12 "g(f1;f1;" OpName %10 "x" OpName %11 "y" OpName %22 "f(f1;i1;vf2;" OpName %19 "x" OpName %20 "y" OpName %21 "z" OpName %28 "cond(i1;f1;" OpName %26 "a" OpName %27 "b" OpName %53 "param" OpName %54 "param" OpName %66 "param" OpName %67 "param" OpName %72 "color" OpName %74 "gl_FragCoord" OpName %75 "param" OpName %79 "param" OpName %85 "param" OpName %86 "param" OpName %91 "param" OpName %92 "param" OpName %93 "param" OpName %99 "param" OpName %100 "param" OpName %101 "param" OpDecorate %20 RelaxedPrecision OpDecorate %26 RelaxedPrecision OpDecorate %47 RelaxedPrecision OpDecorate %58 RelaxedPrecision OpDecorate %72 Location 0 OpDecorate %74 BuiltIn FragCoord %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %8 = OpTypeVector %6 4 %9 = OpTypeFunction %8 %7 %7 %14 = OpTypeInt 32 1 %15 = OpTypePointer Function %14 %16 = OpTypeVector %6 2 %17 = OpTypePointer Function %16 %18 = OpTypeFunction %8 %7 %15 %17 %24 = OpTypeBool %25 = OpTypeFunction %24 %15 %7 %31 = OpConstant %6 255 %33 = OpConstant %6 0 %34 = OpConstant %6 1 %42 = OpTypeInt 32 0 %43 = OpConstant %42 0 %49 = OpConstant %42 1 %64 = OpConstant %14 4 %65 = OpConstant %6 5 %71 = OpTypePointer Output %8 %72 = OpVariable %71 Output %73 = OpTypePointer Input %8 %74 = OpVariable %73 Input %76 = OpTypePointer Input %6 %84 = OpConstant %14 5 %90 = OpConstant %6 3 %98 = OpConstant %6 4 %206 = OpTypeFunction %2 %14 %16 %223 = OpTypeFunction %2 %6 %8 %224 = OpTypeFunction %2 %8 %6 %233 = OpTypeFunction %2 %42 %24 %234 = OpTypeFunction %2 %24 %42 %4 = OpFunction %2 None %3 %5 = OpLabel %66 = OpVariable %15 Function %67 = OpVariable %7 Function %75 = OpVariable %7 Function %79 = OpVariable %7 Function %85 = OpVariable %15 Function %86 = OpVariable %7 Function %91 = OpVariable %7 Function %92 = OpVariable %15 Function %93 = OpVariable %17 Function %99 = OpVariable %7 Function %100 = OpVariable %15 Function %101 = OpVariable %17 Function OpStore %66 %64 OpStore %67 %65 %68 = OpFunctionCall %24 %28 %66 %67 OpSelectionMerge %70 None OpBranchConditional %68 %69 %83 %69 = OpLabel %77 = OpAccessChain %76 %74 %43 %78 = OpLoad %6 %77 OpStore %75 %78 %80 = OpAccessChain %76 %74 %49 %81 = OpLoad %6 %80 OpStore %79 %81 %82 = OpFunctionCall %8 %12 %75 %79 OpStore %72 %82 OpBranch %70 %83 = OpLabel OpStore %85 %84 OpStore %86 %65 %87 = OpFunctionCall %24 %28 %85 %86 OpSelectionMerge %89 None OpBranchConditional %87 %88 %97 %88 = OpLabel OpStore %91 %90 OpStore %92 %64 %94 = OpLoad %8 %74 %95 = OpVectorShuffle %16 %94 %94 0 1 OpStore %93 %95 %96 = OpFunctionCall %8 %22 %91 %92 %93 OpStore %72 %96 OpBranch %89 %97 = OpLabel OpStore %99 %98 OpStore %100 %84 %102 = OpLoad %8 %74 %103 = OpVectorShuffle %16 %102 %102 0 1 OpStore %101 %103 %104 = OpFunctionCall %8 %22 %99 %100 %101 OpStore %72 %104 OpBranch %89 %89 = OpLabel OpBranch %70 %70 = OpLabel OpReturn OpFunctionEnd ; adjust type of the function in-place %12 = OpFunction %8 None %9 %10 = OpFunctionParameter %7 %11 = OpFunctionParameter %7 %13 = OpLabel %30 = OpLoad %6 %10 %32 = OpFDiv %6 %30 %31 %35 = OpLoad %6 %11 %36 = OpFDiv %6 %35 %31 %37 = OpFSub %6 %34 %36 %38 = OpCompositeConstruct %8 %32 %33 %37 %34 OpReturnValue %38 OpFunctionEnd %22 = OpFunction %8 None %18 %19 = OpFunctionParameter %7 %20 = OpFunctionParameter %15 %21 = OpFunctionParameter %17 %23 = OpLabel %53 = OpVariable %7 Function %54 = OpVariable %7 Function %41 = OpLoad %6 %19 %44 = OpAccessChain %7 %21 %43 %45 = OpLoad %6 %44 %46 = OpFAdd %6 %41 %45 %47 = OpLoad %14 %20 %48 = OpConvertSToF %6 %47 %50 = OpAccessChain %7 %21 %49 %51 = OpLoad %6 %50 %52 = OpFAdd %6 %48 %51 OpStore %53 %46 OpStore %54 %52 %55 = OpFunctionCall %8 %12 %53 %54 OpReturnValue %55 OpFunctionEnd %28 = OpFunction %24 None %25 %26 = OpFunctionParameter %15 %27 = OpFunctionParameter %7 %29 = OpLabel %58 = OpLoad %14 %26 %59 = OpConvertSToF %6 %58 %60 = OpLoad %6 %27 %61 = OpFOrdLessThan %24 %59 %60 OpReturnValue %61 OpFunctionEnd ; create a new function type %200 = OpFunction %2 None %206 %207 = OpFunctionParameter %14 %208 = OpFunctionParameter %16 %202 = OpLabel OpReturn OpFunctionEnd %203 = OpFunction %2 None %206 %209 = OpFunctionParameter %14 %210 = OpFunctionParameter %16 %205 = OpLabel OpReturn OpFunctionEnd ; reuse an existing function type %211 = OpFunction %2 None %223 %212 = OpFunctionParameter %6 %213 = OpFunctionParameter %8 %214 = OpLabel OpReturn OpFunctionEnd %215 = OpFunction %2 None %224 %216 = OpFunctionParameter %8 %217 = OpFunctionParameter %6 %218 = OpLabel OpReturn OpFunctionEnd %219 = OpFunction %2 None %224 %220 = OpFunctionParameter %8 %221 = OpFunctionParameter %6 %222 = OpLabel OpReturn OpFunctionEnd ; don't adjust the type of the function if it creates a duplicate %225 = OpFunction %2 None %233 %226 = OpFunctionParameter %42 %227 = OpFunctionParameter %24 %228 = OpLabel OpReturn OpFunctionEnd %229 = OpFunction %2 None %234 %230 = OpFunctionParameter %24 %231 = OpFunctionParameter %42 %232 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Can't permute main function ASSERT_FALSE(TransformationPermuteFunctionParameters(4, 105, {}) .IsApplicable(context.get(), transformation_context)); // Can't permute invalid instruction ASSERT_FALSE(TransformationPermuteFunctionParameters(101, 105, {}) .IsApplicable(context.get(), transformation_context)); // Permutation has too many values ASSERT_FALSE(TransformationPermuteFunctionParameters(22, 105, {2, 1, 0, 3}) .IsApplicable(context.get(), transformation_context)); // Permutation has too few values ASSERT_FALSE(TransformationPermuteFunctionParameters(22, 105, {0, 1}) .IsApplicable(context.get(), transformation_context)); // Permutation has invalid values 1 ASSERT_FALSE(TransformationPermuteFunctionParameters(22, 105, {3, 1, 0}) .IsApplicable(context.get(), transformation_context)); #ifndef NDEBUG // Permutation has invalid values 2 ASSERT_DEATH(TransformationPermuteFunctionParameters(22, 105, {2, 2, 1}) .IsApplicable(context.get(), transformation_context), "Permutation has duplicates"); #endif // Result id for new function type is not fresh. ASSERT_FALSE(TransformationPermuteFunctionParameters(22, 42, {2, 1, 0}) .IsApplicable(context.get(), transformation_context)); // Successful transformations { TransformationPermuteFunctionParameters transformation(12, 105, {1, 0}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } { TransformationPermuteFunctionParameters transformation(28, 106, {1, 0}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } { TransformationPermuteFunctionParameters transformation(200, 107, {1, 0}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } { TransformationPermuteFunctionParameters transformation(219, 108, {1, 0}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } { TransformationPermuteFunctionParameters transformation(229, 109, {1, 0}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %72 %74 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %12 "g(f1;f1;" OpName %10 "x" OpName %11 "y" OpName %22 "f(f1;i1;vf2;" OpName %19 "x" OpName %20 "y" OpName %21 "z" OpName %28 "cond(i1;f1;" OpName %26 "a" OpName %27 "b" OpName %53 "param" OpName %54 "param" OpName %66 "param" OpName %67 "param" OpName %72 "color" OpName %74 "gl_FragCoord" OpName %75 "param" OpName %79 "param" OpName %85 "param" OpName %86 "param" OpName %91 "param" OpName %92 "param" OpName %93 "param" OpName %99 "param" OpName %100 "param" OpName %101 "param" OpDecorate %20 RelaxedPrecision OpDecorate %26 RelaxedPrecision OpDecorate %47 RelaxedPrecision OpDecorate %58 RelaxedPrecision OpDecorate %72 Location 0 OpDecorate %74 BuiltIn FragCoord %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %8 = OpTypeVector %6 4 %9 = OpTypeFunction %8 %7 %7 %14 = OpTypeInt 32 1 %15 = OpTypePointer Function %14 %16 = OpTypeVector %6 2 %17 = OpTypePointer Function %16 %18 = OpTypeFunction %8 %7 %15 %17 %24 = OpTypeBool %31 = OpConstant %6 255 %33 = OpConstant %6 0 %34 = OpConstant %6 1 %42 = OpTypeInt 32 0 %43 = OpConstant %42 0 %49 = OpConstant %42 1 %64 = OpConstant %14 4 %65 = OpConstant %6 5 %71 = OpTypePointer Output %8 %72 = OpVariable %71 Output %73 = OpTypePointer Input %8 %74 = OpVariable %73 Input %76 = OpTypePointer Input %6 %84 = OpConstant %14 5 %90 = OpConstant %6 3 %98 = OpConstant %6 4 %206 = OpTypeFunction %2 %14 %16 %223 = OpTypeFunction %2 %6 %8 %224 = OpTypeFunction %2 %8 %6 %233 = OpTypeFunction %2 %42 %24 %25 = OpTypeFunction %24 %7 %15 %107 = OpTypeFunction %2 %16 %14 %4 = OpFunction %2 None %3 %5 = OpLabel %66 = OpVariable %15 Function %67 = OpVariable %7 Function %75 = OpVariable %7 Function %79 = OpVariable %7 Function %85 = OpVariable %15 Function %86 = OpVariable %7 Function %91 = OpVariable %7 Function %92 = OpVariable %15 Function %93 = OpVariable %17 Function %99 = OpVariable %7 Function %100 = OpVariable %15 Function %101 = OpVariable %17 Function OpStore %66 %64 OpStore %67 %65 %68 = OpFunctionCall %24 %28 %67 %66 OpSelectionMerge %70 None OpBranchConditional %68 %69 %83 %69 = OpLabel %77 = OpAccessChain %76 %74 %43 %78 = OpLoad %6 %77 OpStore %75 %78 %80 = OpAccessChain %76 %74 %49 %81 = OpLoad %6 %80 OpStore %79 %81 %82 = OpFunctionCall %8 %12 %79 %75 OpStore %72 %82 OpBranch %70 %83 = OpLabel OpStore %85 %84 OpStore %86 %65 %87 = OpFunctionCall %24 %28 %86 %85 OpSelectionMerge %89 None OpBranchConditional %87 %88 %97 %88 = OpLabel OpStore %91 %90 OpStore %92 %64 %94 = OpLoad %8 %74 %95 = OpVectorShuffle %16 %94 %94 0 1 OpStore %93 %95 %96 = OpFunctionCall %8 %22 %91 %92 %93 OpStore %72 %96 OpBranch %89 %97 = OpLabel OpStore %99 %98 OpStore %100 %84 %102 = OpLoad %8 %74 %103 = OpVectorShuffle %16 %102 %102 0 1 OpStore %101 %103 %104 = OpFunctionCall %8 %22 %99 %100 %101 OpStore %72 %104 OpBranch %89 %89 = OpLabel OpBranch %70 %70 = OpLabel OpReturn OpFunctionEnd %12 = OpFunction %8 None %9 %11 = OpFunctionParameter %7 %10 = OpFunctionParameter %7 %13 = OpLabel %30 = OpLoad %6 %10 %32 = OpFDiv %6 %30 %31 %35 = OpLoad %6 %11 %36 = OpFDiv %6 %35 %31 %37 = OpFSub %6 %34 %36 %38 = OpCompositeConstruct %8 %32 %33 %37 %34 OpReturnValue %38 OpFunctionEnd %22 = OpFunction %8 None %18 %19 = OpFunctionParameter %7 %20 = OpFunctionParameter %15 %21 = OpFunctionParameter %17 %23 = OpLabel %53 = OpVariable %7 Function %54 = OpVariable %7 Function %41 = OpLoad %6 %19 %44 = OpAccessChain %7 %21 %43 %45 = OpLoad %6 %44 %46 = OpFAdd %6 %41 %45 %47 = OpLoad %14 %20 %48 = OpConvertSToF %6 %47 %50 = OpAccessChain %7 %21 %49 %51 = OpLoad %6 %50 %52 = OpFAdd %6 %48 %51 OpStore %53 %46 OpStore %54 %52 %55 = OpFunctionCall %8 %12 %54 %53 OpReturnValue %55 OpFunctionEnd %28 = OpFunction %24 None %25 %27 = OpFunctionParameter %7 %26 = OpFunctionParameter %15 %29 = OpLabel %58 = OpLoad %14 %26 %59 = OpConvertSToF %6 %58 %60 = OpLoad %6 %27 %61 = OpFOrdLessThan %24 %59 %60 OpReturnValue %61 OpFunctionEnd %200 = OpFunction %2 None %107 %208 = OpFunctionParameter %16 %207 = OpFunctionParameter %14 %202 = OpLabel OpReturn OpFunctionEnd %203 = OpFunction %2 None %206 %209 = OpFunctionParameter %14 %210 = OpFunctionParameter %16 %205 = OpLabel OpReturn OpFunctionEnd %211 = OpFunction %2 None %223 %212 = OpFunctionParameter %6 %213 = OpFunctionParameter %8 %214 = OpLabel OpReturn OpFunctionEnd %215 = OpFunction %2 None %224 %216 = OpFunctionParameter %8 %217 = OpFunctionParameter %6 %218 = OpLabel OpReturn OpFunctionEnd %219 = OpFunction %2 None %223 %221 = OpFunctionParameter %6 %220 = OpFunctionParameter %8 %222 = OpLabel OpReturn OpFunctionEnd %225 = OpFunction %2 None %233 %226 = OpFunctionParameter %42 %227 = OpFunctionParameter %24 %228 = OpLabel OpReturn OpFunctionEnd %229 = OpFunction %2 None %233 %231 = OpFunctionParameter %42 %230 = OpFunctionParameter %24 %232 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_permute_phi_operands_test.cpp000066400000000000000000000155441475742701700316240ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_permute_phi_operands.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationPermutePhiOperandsTest, BasicTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %11 = OpConstant %6 1 %14 = OpTypeBool %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function OpStore %8 %9 OpStore %10 %11 %12 = OpLoad %6 %8 %13 = OpLoad %6 %10 %15 = OpSLessThan %14 %12 %13 OpSelectionMerge %17 None OpBranchConditional %15 %16 %21 %16 = OpLabel %18 = OpLoad %6 %10 %19 = OpLoad %6 %8 %20 = OpIAdd %6 %19 %18 OpBranch %17 %21 = OpLabel %22 = OpLoad %6 %10 %23 = OpLoad %6 %8 %24 = OpISub %6 %23 %22 OpBranch %17 %17 = OpLabel %25 = OpPhi %6 %20 %16 %24 %21 %30 = OpIAdd %6 %25 %25 OpStore %8 %25 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Result id is invalid. ASSERT_FALSE(TransformationPermutePhiOperands(26, {}).IsApplicable( context.get(), transformation_context)); // Result id is not of an OpPhi instruction. ASSERT_FALSE(TransformationPermutePhiOperands(24, {}).IsApplicable( context.get(), transformation_context)); // Result id is not of an OpPhi instruction. ASSERT_FALSE(TransformationPermutePhiOperands(24, {}).IsApplicable( context.get(), transformation_context)); // Permutation has invalid size. ASSERT_FALSE(TransformationPermutePhiOperands(25, {0, 1, 2}) .IsApplicable(context.get(), transformation_context)); #ifndef NDEBUG // Permutation has duplicates. ASSERT_DEATH(TransformationPermutePhiOperands(25, {0, 0}) .IsApplicable(context.get(), transformation_context), "Permutation has duplicates"); #endif // Permutation's values are not in range. ASSERT_FALSE(TransformationPermutePhiOperands(25, {1, 2}) .IsApplicable(context.get(), transformation_context)); TransformationPermutePhiOperands transformation(25, {1, 0}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); // Check that the def-use manager knows that the phi instruction's ids have // been permuted. std::vector> phi_operand_to_new_operand_index = {{20, 4}, {16, 5}, {24, 2}, {21, 3}}; for (std::pair& entry : phi_operand_to_new_operand_index) { context->get_def_use_mgr()->WhileEachUse( entry.first, [&entry](opt::Instruction* inst, uint32_t operand_index) -> bool { if (inst->result_id() == 25) { EXPECT_EQ(entry.second, operand_index); return false; } return true; }); } bool found_use_in_store = false; bool found_use_in_add_lhs = false; bool found_use_in_add_rhs = false; context->get_def_use_mgr()->ForEachUse( 25, [&found_use_in_store, &found_use_in_add_lhs, &found_use_in_add_rhs]( opt::Instruction* inst, uint32_t operand_index) { if (inst->opcode() == spv::Op::OpStore) { ASSERT_FALSE(found_use_in_store); found_use_in_store = true; } else { ASSERT_EQ(spv::Op::OpIAdd, inst->opcode()); if (operand_index == 2) { ASSERT_FALSE(found_use_in_add_lhs); found_use_in_add_lhs = true; } else { ASSERT_EQ(3, operand_index); ASSERT_FALSE(found_use_in_add_rhs); found_use_in_add_rhs = true; } } }); ASSERT_TRUE(found_use_in_store); ASSERT_TRUE(found_use_in_add_lhs); ASSERT_TRUE(found_use_in_add_rhs); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %11 = OpConstant %6 1 %14 = OpTypeBool %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function OpStore %8 %9 OpStore %10 %11 %12 = OpLoad %6 %8 %13 = OpLoad %6 %10 %15 = OpSLessThan %14 %12 %13 OpSelectionMerge %17 None OpBranchConditional %15 %16 %21 %16 = OpLabel %18 = OpLoad %6 %10 %19 = OpLoad %6 %8 %20 = OpIAdd %6 %19 %18 OpBranch %17 %21 = OpLabel %22 = OpLoad %6 %10 %23 = OpLoad %6 %8 %24 = OpISub %6 %23 %22 OpBranch %17 %17 = OpLabel %25 = OpPhi %6 %24 %21 %20 %16 %30 = OpIAdd %6 %25 %25 OpStore %8 %25 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_propagate_instruction_down_test.cpp000066400000000000000000001203111475742701700330470ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_propagate_instruction_down.h" #include "gtest/gtest.h" #include "source/fuzz/counter_overflow_id_source.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationPropagateInstructionDownTest, BasicTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpConstant %6 1 %12 = OpTypeBool %13 = OpConstantTrue %12 %9 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 ; Has no instruction to propagate %5 = OpLabel %10 = OpVariable %9 Function %8 = OpCopyObject %6 %7 OpStore %10 %8 OpBranch %11 ; Unreachable block %100 = OpLabel %101 = OpCopyObject %6 %7 OpBranch %11 ; Selection header ; ; One of acceptable successors has an OpPhi that uses propagated ; instruction's id %11 = OpLabel %19 = OpCopyObject %6 %7 OpSelectionMerge %18 None OpBranchConditional %13 %14 %18 ; %16 has no acceptable successors %14 = OpLabel %20 = OpPhi %6 %19 %11 %15 = OpCopyObject %6 %7 ; dependency OpBranch %16 %16 = OpLabel %17 = OpCopyObject %6 %15 OpBranch %18 ; Can be applied %18 = OpLabel %21 = OpCopyObject %6 %7 OpSelectionMerge %24 None OpBranchConditional %13 %22 %23 %22 = OpLabel %29 = OpPhi %6 %7 %18 OpStore %10 %21 OpBranch %24 %23 = OpLabel OpStore %10 %21 OpBranch %24 %24 = OpLabel OpStore %10 %21 OpBranch %32 ; Can't replace all uses of the propagated instruction: %30 is ; propagated into %27. %32 = OpLabel OpLoopMerge %28 %27 None OpBranchConditional %13 %26 %28 %26 = OpLabel %25 = OpCopyObject %6 %7 %30 = OpCopyObject %6 %25 OpBranchConditional %13 %27 %28 %27 = OpLabel OpBranch %32 %28 = OpLabel %31 = OpPhi %6 %30 %26 %7 %32 ; Can't replace this use OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Invalid block id. ASSERT_FALSE(TransformationPropagateInstructionDown(200, 200, {{}}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationPropagateInstructionDown(101, 200, {{}}) .IsApplicable(context.get(), transformation_context)); // The block is unreachable. ASSERT_FALSE(TransformationPropagateInstructionDown(100, 200, {{}}) .IsApplicable(context.get(), transformation_context)); // The block has no instruction to propagate. ASSERT_FALSE(TransformationPropagateInstructionDown(5, 200, {{{11, 201}}}) .IsApplicable(context.get(), transformation_context)); // The block has no acceptable successors. ASSERT_FALSE(TransformationPropagateInstructionDown(16, 200, {{{18, 201}}}) .IsApplicable(context.get(), transformation_context)); // One of acceptable successors has an OpPhi that uses propagated // instruction's id. ASSERT_FALSE( TransformationPropagateInstructionDown(11, 200, {{{14, 201}, {18, 202}}}) .IsApplicable(context.get(), transformation_context)); #ifndef NDEBUG // Not all fresh ids are provided. ASSERT_DEATH( TransformationPropagateInstructionDown(18, 200, {{{22, 201}, {202, 203}}}) .IsApplicable(context.get(), transformation_context), "Bad attempt to query whether overflow ids are available."); #endif // Not all fresh ids are fresh. ASSERT_FALSE(TransformationPropagateInstructionDown( 18, 18, {{{22, 201}, {23, 202}, {202, 203}}}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationPropagateInstructionDown( 18, 200, {{{22, 22}, {23, 202}, {202, 203}}}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationPropagateInstructionDown( 18, 18, {{{22, 22}, {23, 202}, {202, 203}}}) .IsApplicable(context.get(), transformation_context)); // Not all fresh ids are unique. ASSERT_FALSE(TransformationPropagateInstructionDown( 18, 200, {{{22, 200}, {23, 202}, {202, 200}}}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationPropagateInstructionDown( 18, 200, {{{22, 201}, {23, 202}, {202, 200}}}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationPropagateInstructionDown( 18, 200, {{{22, 201}, {23, 201}, {202, 203}}}) .IsApplicable(context.get(), transformation_context)); // Can't replace all uses of the propagated instruction: %30 is propagated // into %27. ASSERT_FALSE(TransformationPropagateInstructionDown(26, 200, {{{27, 201}}}) .IsApplicable(context.get(), transformation_context)); { TransformationPropagateInstructionDown transformation( 18, 200, {{{22, 201}, {23, 202}, {202, 203}}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(201, {}), MakeDataDescriptor(202, {}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(201, {}), MakeDataDescriptor(200, {}))); } std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpConstant %6 1 %12 = OpTypeBool %13 = OpConstantTrue %12 %9 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 ; Has no instruction to propagate %5 = OpLabel %10 = OpVariable %9 Function %8 = OpCopyObject %6 %7 OpStore %10 %8 OpBranch %11 ; Unreachable block %100 = OpLabel %101 = OpCopyObject %6 %7 OpBranch %11 ; Selection header ; ; One of acceptable successors has an OpPhi that uses propagated ; instruction's id %11 = OpLabel %19 = OpCopyObject %6 %7 OpSelectionMerge %18 None OpBranchConditional %13 %14 %18 ; %16 has no acceptable successors %14 = OpLabel %20 = OpPhi %6 %19 %11 %15 = OpCopyObject %6 %7 ; dependency OpBranch %16 %16 = OpLabel %17 = OpCopyObject %6 %15 OpBranch %18 ; Can be applied %18 = OpLabel OpSelectionMerge %24 None OpBranchConditional %13 %22 %23 %22 = OpLabel %29 = OpPhi %6 %7 %18 %201 = OpCopyObject %6 %7 OpStore %10 %201 OpBranch %24 %23 = OpLabel %202 = OpCopyObject %6 %7 OpStore %10 %202 OpBranch %24 %24 = OpLabel %200 = OpPhi %6 %201 %22 %202 %23 OpStore %10 %200 OpBranch %32 ; Can't replace all uses of the propagated instruction: %30 is ; propagated into %27. %32 = OpLabel OpLoopMerge %28 %27 None OpBranchConditional %13 %26 %28 %26 = OpLabel %25 = OpCopyObject %6 %7 %30 = OpCopyObject %6 %25 OpBranchConditional %13 %27 %28 %27 = OpLabel OpBranch %32 %28 = OpLabel %31 = OpPhi %6 %30 %26 %7 %32 ; Can't replace this use OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationPropagateInstructionDownTest, CantCreateOpPhiTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpConstant %6 1 %12 = OpTypeBool %13 = OpConstantTrue %12 %4 = OpFunction %2 None %3 ; %5 doesn't belong to any construct %5 = OpLabel %15 = OpCopyObject %6 %7 OpBranch %16 ; The merge block (%19) is unreachable %16 = OpLabel %17 = OpCopyObject %6 %7 OpSelectionMerge %19 None OpBranchConditional %13 %18 %18 ; %21 doesn't dominate the merge block - %20 %18 = OpLabel OpSelectionMerge %20 None OpBranchConditional %13 %20 %21 %21 = OpLabel %22 = OpCopyObject %6 %7 OpBranch %20 ; The merge block (%24) is an acceptable successor of the propagated ; instruction's block %20 = OpLabel %23 = OpCopyObject %6 %7 OpSelectionMerge %24 None OpBranchConditional %13 %24 %30 %30 = OpLabel OpBranch %24 ; One of the predecessors of the merge block is not dominated by any ; successor of the propagated instruction's block %24 = OpLabel %26 = OpCopyObject %6 %7 OpLoopMerge %29 %25 None OpBranch %25 %25 = OpLabel OpBranchConditional %13 %24 %29 %28 = OpLabel ; unreachable predecessor of %29 OpBranch %29 %29 = OpLabel OpReturn %19 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationPropagateInstructionDown transformations[] = { // %5 doesn't belong to any construct. {5, 200, {{{16, 201}}}}, // The merge block (%19) is unreachable. {16, 200, {{{18, 202}}}}, // %21 doesn't dominate the merge block - %20. {21, 200, {{{20, 203}}}}, // The merge block (%24) is an acceptable successor of the propagated // instruction's block. {20, 200, {{{24, 204}, {30, 205}}}}, // One of the predecessors of the merge block is not dominated by any // successor of the propagated instruction's block. {24, 200, {{{25, 206}}}}, }; for (const auto& transformation : transformations) { ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } // No transformation has introduced an OpPhi instruction. ASSERT_FALSE(context->get_def_use_mgr()->GetDef(200)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpConstant %6 1 %12 = OpTypeBool %13 = OpConstantTrue %12 %4 = OpFunction %2 None %3 ; %5 doesn't belong to any construct %5 = OpLabel OpBranch %16 ; The merge block (%19) is unreachable %16 = OpLabel %201 = OpCopyObject %6 %7 OpSelectionMerge %19 None OpBranchConditional %13 %18 %18 ; %21 doesn't dominate the merge block - %20 %18 = OpLabel %202 = OpCopyObject %6 %7 OpSelectionMerge %20 None OpBranchConditional %13 %20 %21 %21 = OpLabel OpBranch %20 ; The merge block (%24) is an acceptable successor of the propagated ; instruction's block %20 = OpLabel %203 = OpCopyObject %6 %7 OpSelectionMerge %24 None OpBranchConditional %13 %24 %30 %30 = OpLabel %205 = OpCopyObject %6 %7 OpBranch %24 ; One of the predecessors of the merge block is not dominated by any ; successor of the propagated instruction's block %24 = OpLabel %204 = OpCopyObject %6 %7 OpLoopMerge %29 %25 None OpBranch %25 %25 = OpLabel %206 = OpCopyObject %6 %7 OpBranchConditional %13 %24 %29 %28 = OpLabel ; unreachable predecessor of %29 OpBranch %29 %29 = OpLabel OpReturn %19 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationPropagateInstructionDownTest, VariablePointersCapability) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpConstant %6 1 %12 = OpTypeBool %13 = OpConstantTrue %12 %10 = OpTypePointer Workgroup %6 %11 = OpVariable %10 Workgroup %4 = OpFunction %2 None %3 %5 = OpLabel %18 = OpCopyObject %10 %11 %14 = OpCopyObject %10 %11 OpSelectionMerge %17 None OpBranchConditional %13 %15 %16 %15 = OpLabel OpBranch %17 %16 = OpLabel OpBranch %17 %17 = OpLabel OpStore %18 %7 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); { // Can propagate a pointer only if we don't have to create an OpPhi. TransformationPropagateInstructionDown transformation( 5, 200, {{{15, 201}, {16, 202}}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_FALSE(context->get_def_use_mgr()->GetDef(200)); } { // Can't propagate a pointer if there is no VariablePointersStorageBuffer // capability and we need to create an OpPhi. TransformationPropagateInstructionDown transformation( 5, 200, {{{15, 203}, {16, 204}}}); ASSERT_FALSE(context->get_feature_mgr()->HasCapability( spv::Capability::VariablePointersStorageBuffer)); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); context->AddCapability(spv::Capability::VariablePointers); ASSERT_TRUE(context->get_feature_mgr()->HasCapability( spv::Capability::VariablePointersStorageBuffer)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } std::string after_transformation = R"( OpCapability Shader OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpConstant %6 1 %12 = OpTypeBool %13 = OpConstantTrue %12 %10 = OpTypePointer Workgroup %6 %11 = OpVariable %10 Workgroup %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %17 None OpBranchConditional %13 %15 %16 %15 = OpLabel %203 = OpCopyObject %10 %11 %201 = OpCopyObject %10 %11 OpBranch %17 %16 = OpLabel %204 = OpCopyObject %10 %11 %202 = OpCopyObject %10 %11 OpBranch %17 %17 = OpLabel %200 = OpPhi %10 %203 %15 %204 %16 OpStore %200 %7 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationPropagateInstructionDownTest, UseOverflowIdsTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpConstant %6 1 %12 = OpTypeBool %13 = OpConstantTrue %12 %10 = OpTypePointer Private %6 %11 = OpVariable %10 Private %4 = OpFunction %2 None %3 %5 = OpLabel %20 = OpCopyObject %6 %7 OpSelectionMerge %23 None OpBranchConditional %13 %21 %22 %21 = OpLabel OpStore %11 %20 OpBranch %23 %22 = OpLabel OpStore %11 %20 OpBranch %23 %23 = OpLabel OpStore %11 %20 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options, MakeUnique(300)); TransformationPropagateInstructionDown transformation(5, 200, {{{21, 201}}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context, {300}); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpConstant %6 1 %12 = OpTypeBool %13 = OpConstantTrue %12 %10 = OpTypePointer Private %6 %11 = OpVariable %10 Private %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %23 None OpBranchConditional %13 %21 %22 %21 = OpLabel %201 = OpCopyObject %6 %7 OpStore %11 %201 OpBranch %23 %22 = OpLabel %300 = OpCopyObject %6 %7 OpStore %11 %300 OpBranch %23 %23 = OpLabel %200 = OpPhi %6 %201 %21 %300 %22 OpStore %11 %200 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationPropagateInstructionDownTest, TestCreatedFacts) { std::string shader = R"( OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpConstant %6 1 %12 = OpTypeBool %13 = OpConstantTrue %12 %10 = OpTypePointer Private %6 %11 = OpVariable %10 Private %4 = OpFunction %2 None %3 %5 = OpLabel %20 = OpCopyObject %6 %7 %24 = OpCopyObject %6 %7 ; Irrelevant id %25 = OpCopyObject %10 %11 ; Pointee is irrelevant OpSelectionMerge %23 None OpBranchConditional %13 %21 %22 %21 = OpLabel OpStore %25 %20 OpBranch %23 %22 = OpLabel ; Dead block OpStore %25 %20 OpBranch %23 %23 = OpLabel OpStore %25 %20 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactBlockIsDead(22); transformation_context.GetFactManager()->AddFactIdIsIrrelevant(24); transformation_context.GetFactManager()->AddFactValueOfPointeeIsIrrelevant( 25); { // Propagate pointer with PointeeIsIrrelevant fact. TransformationPropagateInstructionDown transformation( 5, 200, {{{21, 201}, {22, 202}}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_FALSE(transformation_context.GetFactManager()->IdIsIrrelevant(201)); ASSERT_FALSE(transformation_context.GetFactManager()->IdIsIrrelevant(202)); ASSERT_FALSE(transformation_context.GetFactManager()->IdIsIrrelevant(200)); ASSERT_TRUE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(201)); ASSERT_TRUE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(202)); ASSERT_TRUE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(200)); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(201, {}), MakeDataDescriptor(202, {}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(201, {}), MakeDataDescriptor(200, {}))); } { // Propagate an irrelevant id. TransformationPropagateInstructionDown transformation( 5, 203, {{{21, 204}, {22, 205}}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IdIsIrrelevant(203)); ASSERT_TRUE(transformation_context.GetFactManager()->IdIsIrrelevant(204)); ASSERT_TRUE(transformation_context.GetFactManager()->IdIsIrrelevant(205)); ASSERT_FALSE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(203)); ASSERT_FALSE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(204)); ASSERT_FALSE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(205)); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(204, {}), MakeDataDescriptor(205, {}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(204, {}), MakeDataDescriptor(203, {}))); } { // Propagate a regular id. TransformationPropagateInstructionDown transformation( 5, 206, {{{21, 207}, {22, 208}}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_FALSE(transformation_context.GetFactManager()->IdIsIrrelevant(206)); ASSERT_FALSE(transformation_context.GetFactManager()->IdIsIrrelevant(207)); ASSERT_TRUE(transformation_context.GetFactManager()->IdIsIrrelevant(208)); ASSERT_FALSE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(206)); ASSERT_FALSE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(207)); ASSERT_FALSE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(208)); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(206, {}), MakeDataDescriptor(207, {}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(206, {}), MakeDataDescriptor(208, {}))); } std::string after_transformation = R"( OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpConstant %6 1 %12 = OpTypeBool %13 = OpConstantTrue %12 %10 = OpTypePointer Private %6 %11 = OpVariable %10 Private %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %23 None OpBranchConditional %13 %21 %22 %21 = OpLabel %207 = OpCopyObject %6 %7 %204 = OpCopyObject %6 %7 ; Irrelevant id %201 = OpCopyObject %10 %11 ; Pointee is irrelevant OpStore %201 %207 OpBranch %23 %22 = OpLabel ; Dead block %208 = OpCopyObject %6 %7 %205 = OpCopyObject %6 %7 ; Irrelevant id %202 = OpCopyObject %10 %11 ; Pointee is irrelevant OpStore %202 %208 OpBranch %23 %23 = OpLabel %206 = OpPhi %6 %207 %21 %208 %22 %203 = OpPhi %6 %204 %21 %205 %22 ; Irrelevant id %200 = OpPhi %10 %201 %21 %202 %22 ; Pointee is irrelevant OpStore %200 %206 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationPropagateInstructionDownTest, TestLoops1) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpConstant %6 1 %12 = OpTypeBool %13 = OpConstantTrue %12 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %20 %20 = OpLabel OpLoopMerge %26 %25 None OpBranch %21 %21 = OpLabel %22 = OpCopyObject %6 %7 %31 = OpCopyObject %6 %7 OpSelectionMerge %35 None OpBranchConditional %13 %23 %24 %23 = OpLabel %27 = OpCopyObject %6 %22 %32 = OpCopyObject %6 %31 OpBranch %26 %24 = OpLabel %28 = OpCopyObject %6 %22 %33 = OpCopyObject %6 %31 OpBranchConditional %13 %26 %25 %35 = OpLabel OpBranch %25 %25 = OpLabel %29 = OpCopyObject %6 %22 %34 = OpCopyObject %6 %31 OpBranch %20 %26 = OpLabel %30 = OpCopyObject %6 %22 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); { TransformationPropagateInstructionDown transformation( 21, 200, {{{23, 201}, {24, 202}}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } // Can't replace usage of %22 in %26. ASSERT_FALSE( TransformationPropagateInstructionDown(21, 200, {{{23, 201}, {24, 202}}}) .IsApplicable(context.get(), transformation_context)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpConstant %6 1 %12 = OpTypeBool %13 = OpConstantTrue %12 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %20 %20 = OpLabel OpLoopMerge %26 %25 None OpBranch %21 %21 = OpLabel %22 = OpCopyObject %6 %7 OpSelectionMerge %35 None OpBranchConditional %13 %23 %24 %23 = OpLabel %201 = OpCopyObject %6 %7 %27 = OpCopyObject %6 %22 %32 = OpCopyObject %6 %201 OpBranch %26 %24 = OpLabel %202 = OpCopyObject %6 %7 %28 = OpCopyObject %6 %22 %33 = OpCopyObject %6 %202 OpBranchConditional %13 %26 %25 %35 = OpLabel OpBranch %25 %25 = OpLabel %29 = OpCopyObject %6 %22 %34 = OpCopyObject %6 %202 OpBranch %20 %26 = OpLabel %30 = OpCopyObject %6 %22 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationPropagateInstructionDownTest, TestLoops2) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpConstant %6 1 %12 = OpTypeBool %13 = OpConstantTrue %12 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %20 %20 = OpLabel %23 = OpPhi %6 %7 %5 %24 %21 OpLoopMerge %22 %21 None OpBranch %21 %21 = OpLabel %24 = OpCopyObject %6 %23 %25 = OpCopyObject %6 %7 OpBranchConditional %13 %22 %20 %22 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); { // Can propagate %25 from %21 into %20. TransformationPropagateInstructionDown transformation( 21, 200, {{{20, 201}, {22, 202}}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } { // Can propagate %201 from %20 into %21. TransformationPropagateInstructionDown transformation(20, 200, {{{21, 203}}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } // Can't propagate %24 from %21 into %20. ASSERT_FALSE( TransformationPropagateInstructionDown(21, 200, {{{20, 204}, {22, 205}}}) .IsApplicable(context.get(), transformation_context)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpConstant %6 1 %12 = OpTypeBool %13 = OpConstantTrue %12 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %20 %20 = OpLabel %23 = OpPhi %6 %7 %5 %24 %21 OpLoopMerge %22 %21 None OpBranch %21 %21 = OpLabel %203 = OpCopyObject %6 %7 %24 = OpCopyObject %6 %23 OpBranchConditional %13 %22 %20 %22 = OpLabel %200 = OpPhi %6 %203 %21 %202 = OpCopyObject %6 %7 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationPropagateInstructionDownTest, TestLoops3) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpConstant %6 1 %12 = OpTypeBool %13 = OpConstantTrue %12 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %20 %20 = OpLabel %27 = OpPhi %6 %7 %5 %26 %20 %25 = OpCopyObject %6 %7 %26 = OpCopyObject %6 %7 OpLoopMerge %22 %20 None OpBranchConditional %13 %20 %22 %22 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); { // Propagate %25 into %20 and %22. Not that we are skipping %26 since not // all of its users are in different blocks (%27).h TransformationPropagateInstructionDown transformation( 20, 200, {{{20, 201}, {22, 202}}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpConstant %6 1 %12 = OpTypeBool %13 = OpConstantTrue %12 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %20 %20 = OpLabel %27 = OpPhi %6 %7 %5 %26 %20 %201 = OpCopyObject %6 %7 %26 = OpCopyObject %6 %7 OpLoopMerge %22 %20 None OpBranchConditional %13 %20 %22 %22 = OpLabel %202 = OpCopyObject %6 %7 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_propagate_instruction_up_test.cpp000066400000000000000000000773301475742701700325400ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_propagate_instruction_up.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationPropagateInstructionUpTest, BasicTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %9 = OpConstant %6 3.5 %11 = OpConstant %6 3.4000001 %12 = OpTypeBool %17 = OpConstant %6 4 %20 = OpConstant %6 45 %27 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %5 = OpLabel %26 = OpVariable %27 Function %13 = OpFOrdEqual %12 %9 %11 OpSelectionMerge %15 None OpBranchConditional %13 %14 %19 %14 = OpLabel %18 = OpFMod %6 %9 %17 OpBranch %15 %19 = OpLabel %22 = OpFAdd %6 %11 %20 OpBranch %15 %15 = OpLabel %21 = OpPhi %6 %18 %14 %22 %19 %23 = OpFMul %6 %21 %21 %24 = OpFDiv %6 %21 %23 OpBranch %25 %25 = OpLabel %28 = OpPhi %6 %20 %15 OpStore %26 %28 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // |block_id| is invalid. ASSERT_FALSE(TransformationPropagateInstructionUp(40, {{}}).IsApplicable( context.get(), transformation_context)); ASSERT_FALSE(TransformationPropagateInstructionUp(26, {{}}).IsApplicable( context.get(), transformation_context)); // |block_id| has no predecessors. ASSERT_FALSE(TransformationPropagateInstructionUp(5, {{}}).IsApplicable( context.get(), transformation_context)); // |block_id| has no valid instructions to propagate. ASSERT_FALSE(TransformationPropagateInstructionUp(25, {{{15, 40}}}) .IsApplicable(context.get(), transformation_context)); // Not all predecessors have fresh ids. ASSERT_FALSE(TransformationPropagateInstructionUp(15, {{{19, 40}, {40, 41}}}) .IsApplicable(context.get(), transformation_context)); // Not all ids are fresh. ASSERT_FALSE( TransformationPropagateInstructionUp(15, {{{19, 40}, {14, 14}, {40, 42}}}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( TransformationPropagateInstructionUp(15, {{{19, 19}, {14, 40}, {40, 42}}}) .IsApplicable(context.get(), transformation_context)); // Fresh ids have duplicates. ASSERT_FALSE( TransformationPropagateInstructionUp(15, {{{19, 40}, {14, 40}, {19, 41}}}) .IsApplicable(context.get(), transformation_context)); // Valid transformations. { TransformationPropagateInstructionUp transformation(14, {{{5, 40}}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } { TransformationPropagateInstructionUp transformation(19, {{{5, 41}}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %9 = OpConstant %6 3.5 %11 = OpConstant %6 3.4000001 %12 = OpTypeBool %17 = OpConstant %6 4 %20 = OpConstant %6 45 %27 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %5 = OpLabel %26 = OpVariable %27 Function %13 = OpFOrdEqual %12 %9 %11 %40 = OpFMod %6 %9 %17 ; propagated from %14 %41 = OpFAdd %6 %11 %20 ; propagated from %19 OpSelectionMerge %15 None OpBranchConditional %13 %14 %19 %14 = OpLabel %18 = OpPhi %6 %40 %5 ; propagated into %5 OpBranch %15 %19 = OpLabel %22 = OpPhi %6 %41 %5 ; propagated into %5 OpBranch %15 %15 = OpLabel %21 = OpPhi %6 %18 %14 %22 %19 %23 = OpFMul %6 %21 %21 %24 = OpFDiv %6 %21 %23 OpBranch %25 %25 = OpLabel %28 = OpPhi %6 %20 %15 OpStore %26 %28 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); { TransformationPropagateInstructionUp transformation(15, {{{14, 43}, {19, 44}}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %9 = OpConstant %6 3.5 %11 = OpConstant %6 3.4000001 %12 = OpTypeBool %17 = OpConstant %6 4 %20 = OpConstant %6 45 %27 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %5 = OpLabel %26 = OpVariable %27 Function %13 = OpFOrdEqual %12 %9 %11 %40 = OpFMod %6 %9 %17 %41 = OpFAdd %6 %11 %20 OpSelectionMerge %15 None OpBranchConditional %13 %14 %19 %14 = OpLabel %18 = OpPhi %6 %40 %5 %43 = OpFMul %6 %18 %18 ; propagated from %15 OpBranch %15 %19 = OpLabel %22 = OpPhi %6 %41 %5 %44 = OpFMul %6 %22 %22 ; propagated from %15 OpBranch %15 %15 = OpLabel %23 = OpPhi %6 %43 %14 %44 %19 ; propagated into %14 and %19 %21 = OpPhi %6 %18 %14 %22 %19 %24 = OpFDiv %6 %21 %23 OpBranch %25 %25 = OpLabel %28 = OpPhi %6 %20 %15 OpStore %26 %28 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); { TransformationPropagateInstructionUp transformation(15, {{{14, 45}, {19, 46}}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %9 = OpConstant %6 3.5 %11 = OpConstant %6 3.4000001 %12 = OpTypeBool %17 = OpConstant %6 4 %20 = OpConstant %6 45 %27 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %5 = OpLabel %26 = OpVariable %27 Function %13 = OpFOrdEqual %12 %9 %11 %40 = OpFMod %6 %9 %17 %41 = OpFAdd %6 %11 %20 OpSelectionMerge %15 None OpBranchConditional %13 %14 %19 %14 = OpLabel %18 = OpPhi %6 %40 %5 %43 = OpFMul %6 %18 %18 %45 = OpFDiv %6 %18 %43 ; propagated from %15 OpBranch %15 %19 = OpLabel %22 = OpPhi %6 %41 %5 %44 = OpFMul %6 %22 %22 %46 = OpFDiv %6 %22 %44 ; propagated from %15 OpBranch %15 %15 = OpLabel %24 = OpPhi %6 %45 %14 %46 %19 ; propagated into %14 and %19 %23 = OpPhi %6 %43 %14 %44 %19 %21 = OpPhi %6 %18 %14 %22 %19 OpBranch %25 %25 = OpLabel %28 = OpPhi %6 %20 %15 OpStore %26 %28 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationPropagateInstructionUpTest, BlockDominatesPredecessor1) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %9 = OpConstant %6 3.5 %11 = OpConstant %6 3.4000001 %12 = OpTypeBool %17 = OpConstant %6 4 %20 = OpConstant %6 45 %4 = OpFunction %2 None %3 %5 = OpLabel %13 = OpFOrdEqual %12 %9 %11 OpSelectionMerge %15 None OpBranchConditional %13 %14 %19 %14 = OpLabel %18 = OpFMod %6 %9 %17 OpBranch %15 %19 = OpLabel %22 = OpFAdd %6 %11 %20 OpBranch %15 %15 = OpLabel ; dominates %26 %21 = OpPhi %6 %18 %14 %22 %19 %28 %26 %23 = OpFMul %6 %21 %21 %24 = OpFDiv %6 %21 %23 OpLoopMerge %27 %26 None OpBranch %26 %26 = OpLabel %28 = OpFAdd %6 %24 %23 OpBranch %15 %27 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationPropagateInstructionUp transformation( 15, {{{14, 40}, {19, 41}, {26, 42}}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %9 = OpConstant %6 3.5 %11 = OpConstant %6 3.4000001 %12 = OpTypeBool %17 = OpConstant %6 4 %20 = OpConstant %6 45 %4 = OpFunction %2 None %3 %5 = OpLabel %13 = OpFOrdEqual %12 %9 %11 OpSelectionMerge %15 None OpBranchConditional %13 %14 %19 %14 = OpLabel %18 = OpFMod %6 %9 %17 %40 = OpFMul %6 %18 %18 ; propagated from %15 OpBranch %15 %19 = OpLabel %22 = OpFAdd %6 %11 %20 %41 = OpFMul %6 %22 %22 ; propagated from %15 OpBranch %15 %15 = OpLabel %23 = OpPhi %6 %40 %14 %41 %19 %42 %26 ; propagated into %14, %19, %26 %21 = OpPhi %6 %18 %14 %22 %19 %28 %26 %24 = OpFDiv %6 %21 %23 OpLoopMerge %27 %26 None OpBranch %26 %26 = OpLabel %28 = OpFAdd %6 %24 %23 %42 = OpFMul %6 %28 %28 ; propagated from %15 OpBranch %15 %27 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationPropagateInstructionUpTest, BlockDominatesPredecessor2) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %9 = OpConstant %6 3.5 %11 = OpConstant %6 3.4000001 %12 = OpTypeBool %17 = OpConstant %6 4 %20 = OpConstant %6 45 %4 = OpFunction %2 None %3 %5 = OpLabel %13 = OpFOrdEqual %12 %9 %11 OpSelectionMerge %15 None OpBranchConditional %13 %14 %19 %14 = OpLabel %18 = OpFMod %6 %9 %17 OpBranch %15 %19 = OpLabel %22 = OpFAdd %6 %11 %20 OpBranch %15 %15 = OpLabel ; doesn't dominate %26 %21 = OpPhi %6 %18 %14 %22 %19 %20 %26 %23 = OpFMul %6 %21 %21 %24 = OpFDiv %6 %21 %23 OpLoopMerge %27 %26 None OpBranch %27 %26 = OpLabel OpBranch %15 %27 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationPropagateInstructionUp transformation( 15, {{{14, 40}, {19, 41}, {26, 42}}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %9 = OpConstant %6 3.5 %11 = OpConstant %6 3.4000001 %12 = OpTypeBool %17 = OpConstant %6 4 %20 = OpConstant %6 45 %4 = OpFunction %2 None %3 %5 = OpLabel %13 = OpFOrdEqual %12 %9 %11 OpSelectionMerge %15 None OpBranchConditional %13 %14 %19 %14 = OpLabel %18 = OpFMod %6 %9 %17 %40 = OpFMul %6 %18 %18 ; propagated from %15 OpBranch %15 %19 = OpLabel %22 = OpFAdd %6 %11 %20 %41 = OpFMul %6 %22 %22 ; propagated from %15 OpBranch %15 %15 = OpLabel %23 = OpPhi %6 %40 %14 %41 %19 %42 %26 ; propagated into %14, %19, %26 %21 = OpPhi %6 %18 %14 %22 %19 %20 %26 %24 = OpFDiv %6 %21 %23 OpLoopMerge %27 %26 None OpBranch %27 %26 = OpLabel %42 = OpFMul %6 %20 %20 ; propagated from %15 OpBranch %15 %27 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationPropagateInstructionUpTest, BlockDominatesPredecessor3) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %9 = OpConstant %6 3.5 %11 = OpConstant %6 3.4000001 %12 = OpTypeBool %17 = OpConstant %6 4 %20 = OpConstant %6 45 %4 = OpFunction %2 None %3 %5 = OpLabel %13 = OpFOrdEqual %12 %9 %11 OpSelectionMerge %15 None OpBranchConditional %13 %14 %19 %14 = OpLabel %18 = OpFMod %6 %9 %17 OpBranch %15 %19 = OpLabel %22 = OpFAdd %6 %11 %20 OpBranch %15 %15 = OpLabel ; branches to itself %21 = OpPhi %6 %18 %14 %22 %19 %24 %15 %23 = OpFMul %6 %21 %21 %24 = OpFDiv %6 %21 %23 OpLoopMerge %27 %15 None OpBranch %15 %27 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationPropagateInstructionUp transformation( 15, {{{14, 40}, {19, 41}, {15, 42}}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %9 = OpConstant %6 3.5 %11 = OpConstant %6 3.4000001 %12 = OpTypeBool %17 = OpConstant %6 4 %20 = OpConstant %6 45 %4 = OpFunction %2 None %3 %5 = OpLabel %13 = OpFOrdEqual %12 %9 %11 OpSelectionMerge %15 None OpBranchConditional %13 %14 %19 %14 = OpLabel %18 = OpFMod %6 %9 %17 %40 = OpFMul %6 %18 %18 ; propagated from %15 OpBranch %15 %19 = OpLabel %22 = OpFAdd %6 %11 %20 %41 = OpFMul %6 %22 %22 ; propagated from %15 OpBranch %15 %15 = OpLabel %23 = OpPhi %6 %40 %14 %41 %19 %42 %15 ; propagated into %14, %19, %15 %21 = OpPhi %6 %18 %14 %22 %19 %24 %15 %24 = OpFDiv %6 %21 %23 %42 = OpFMul %6 %24 %24 ; propagated from %15 OpLoopMerge %27 %15 None OpBranch %15 %27 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationPropagateInstructionUpTest, HandlesVariablePointersCapability) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %11 = OpConstant %6 23 %7 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpBranch %9 %9 = OpLabel %10 = OpCopyObject %7 %8 OpStore %10 %11 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Required capabilities haven't yet been specified. TransformationPropagateInstructionUp transformation(9, {{{5, 40}}}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); context->AddCapability(spv::Capability::VariablePointers); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %11 = OpConstant %6 23 %7 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %40 = OpCopyObject %7 %8 ; propagated from %9 OpBranch %9 %9 = OpLabel %10 = OpPhi %7 %40 %5 ; propagated into %5 OpStore %10 %11 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationPropagateInstructionUpTest, HandlesVariablePointersStorageBufferCapability) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %11 = OpConstant %6 23 %7 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpBranch %9 %9 = OpLabel %10 = OpCopyObject %7 %8 OpStore %10 %11 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Required capabilities haven't yet been specified TransformationPropagateInstructionUp transformation(9, {{{5, 40}}}); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); context->AddCapability(spv::Capability::VariablePointersStorageBuffer); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader OpCapability VariablePointersStorageBuffer %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %11 = OpConstant %6 23 %7 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %40 = OpCopyObject %7 %8 ; propagated from %9 OpBranch %9 %9 = OpLabel %10 = OpPhi %7 %40 %5 ; propagated into %5 OpStore %10 %11 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationPropagateInstructionUpTest, MultipleIdenticalPredecessors) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %11 = OpConstant %6 23 %12 = OpTypeBool %13 = OpConstantTrue %12 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %9 None OpBranchConditional %13 %9 %9 %9 = OpLabel %14 = OpPhi %6 %11 %5 %10 = OpCopyObject %6 %14 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationPropagateInstructionUp transformation(9, {{{5, 40}}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %11 = OpConstant %6 23 %12 = OpTypeBool %13 = OpConstantTrue %12 %4 = OpFunction %2 None %3 %5 = OpLabel %40 = OpCopyObject %6 %11 OpSelectionMerge %9 None OpBranchConditional %13 %9 %9 %9 = OpLabel %10 = OpPhi %6 %40 %5 %14 = OpPhi %6 %11 %5 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationPropagateInstructionUpTest, InapplicableDueToOpTypeSampledImage) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %10 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpDecorate %10 RelaxedPrecision OpDecorate %10 DescriptorSet 0 OpDecorate %10 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeImage %6 2D 0 0 0 1 Unknown %8 = OpTypeSampledImage %7 %9 = OpTypePointer UniformConstant %8 %10 = OpVariable %9 UniformConstant %12 = OpTypeVector %6 2 %13 = OpConstant %6 0 %14 = OpConstantComposite %12 %13 %13 %15 = OpTypeVector %6 4 %30 = OpTypeBool %31 = OpConstantTrue %30 %4 = OpFunction %2 None %3 %5 = OpLabel %11 = OpLoad %8 %10 OpSelectionMerge %20 None OpBranchConditional %31 %40 %41 %40 = OpLabel OpBranch %20 %41 = OpLabel OpBranch %20 %20 = OpLabel %50 = OpCopyObject %8 %11 %16 = OpImageSampleImplicitLod %15 %50 %14 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_FALSE( TransformationPropagateInstructionUp(20, {{{40, 100}, {41, 101}}}) .IsApplicable(context.get(), transformation_context)); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_push_id_through_variable_test.cpp000066400000000000000000000751421475742701700324500ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_push_id_through_variable.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationPushIdThroughVariableTest, IsApplicable) { std::string reference_shader = R"( OpCapability Shader OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %92 %52 %53 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %92 BuiltIn FragCoord %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeFloat 32 %8 = OpTypeStruct %6 %7 %9 = OpTypePointer Function %8 %10 = OpTypeFunction %6 %9 %14 = OpConstant %6 0 %15 = OpTypePointer Function %6 %51 = OpTypePointer Private %6 %21 = OpConstant %6 2 %23 = OpConstant %6 1 %24 = OpConstant %7 1 %25 = OpTypePointer Function %7 %50 = OpTypePointer Private %7 %34 = OpTypeBool %35 = OpConstantFalse %34 %60 = OpConstantNull %50 %52 = OpVariable %50 Private %53 = OpVariable %51 Private %80 = OpConstantComposite %8 %21 %24 %90 = OpTypeVector %7 4 %91 = OpTypePointer Input %90 %92 = OpVariable %91 Input %93 = OpConstantComposite %90 %24 %24 %24 %24 %4 = OpFunction %2 None %3 %5 = OpLabel %20 = OpVariable %9 Function %27 = OpVariable %9 Function %22 = OpAccessChain %15 %20 %14 %44 = OpCopyObject %9 %20 %26 = OpAccessChain %25 %20 %23 %29 = OpFunctionCall %6 %12 %27 %30 = OpAccessChain %15 %20 %14 %45 = OpCopyObject %15 %30 %81 = OpCopyObject %9 %27 %33 = OpAccessChain %15 %20 %14 OpSelectionMerge %37 None OpBranchConditional %35 %36 %37 %36 = OpLabel %38 = OpAccessChain %15 %20 %14 %40 = OpAccessChain %15 %20 %14 %43 = OpAccessChain %15 %20 %14 %82 = OpCopyObject %9 %27 OpBranch %37 %37 = OpLabel OpReturn OpFunctionEnd %12 = OpFunction %6 None %10 %11 = OpFunctionParameter %9 %13 = OpLabel %46 = OpCopyObject %9 %11 %16 = OpAccessChain %15 %11 %14 %95 = OpCopyObject %8 %80 OpReturnValue %21 %100 = OpLabel OpUnreachable OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Tests the reference shader validity. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Tests |value_synonym_id| and |variable_id| are fresh ids. uint32_t value_id = 21; uint32_t value_synonym_id = 62; uint32_t variable_id = 63; uint32_t initializer_id = 23; uint32_t variable_storage_class = (uint32_t)spv::StorageClass::Private; auto instruction_descriptor = MakeInstructionDescriptor(95, spv::Op::OpReturnValue, 0); auto transformation = TransformationPushIdThroughVariable( value_id, value_synonym_id, variable_id, variable_storage_class, initializer_id, instruction_descriptor); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); // Tests |value_synonym_id| and |variable_id| are non-fresh ids. value_id = 80; value_synonym_id = 60; variable_id = 61; initializer_id = 80; variable_storage_class = (uint32_t)spv::StorageClass::Function; instruction_descriptor = MakeInstructionDescriptor(38, spv::Op::OpAccessChain, 0); transformation = TransformationPushIdThroughVariable( value_id, value_synonym_id, variable_id, variable_storage_class, initializer_id, instruction_descriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // The instruction to insert before is not defined. value_id = 80; value_synonym_id = 62; variable_id = 63; initializer_id = 80; variable_storage_class = (uint32_t)spv::StorageClass::Function; instruction_descriptor = MakeInstructionDescriptor(64, spv::Op::OpAccessChain, 0); transformation = TransformationPushIdThroughVariable( value_id, value_synonym_id, variable_id, variable_storage_class, initializer_id, instruction_descriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Attempting to insert the store and load instructions // before an OpVariable instruction. value_id = 24; value_synonym_id = 62; variable_id = 63; initializer_id = 24; variable_storage_class = (uint32_t)spv::StorageClass::Function; instruction_descriptor = MakeInstructionDescriptor(27, spv::Op::OpVariable, 0); transformation = TransformationPushIdThroughVariable( value_id, value_synonym_id, variable_id, variable_storage_class, initializer_id, instruction_descriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // The block containing instruction descriptor must be reachable. value_id = 80; value_synonym_id = 62; variable_id = 63; initializer_id = 80; variable_storage_class = (uint32_t)spv::StorageClass::Function; instruction_descriptor = MakeInstructionDescriptor(100, spv::Op::OpUnreachable, 0); transformation = TransformationPushIdThroughVariable( value_id, value_synonym_id, variable_id, variable_storage_class, initializer_id, instruction_descriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests value instruction not available. value_id = 64; value_synonym_id = 62; variable_id = 63; initializer_id = 23; variable_storage_class = (uint32_t)spv::StorageClass::Function; instruction_descriptor = MakeInstructionDescriptor(95, spv::Op::OpReturnValue, 0); transformation = TransformationPushIdThroughVariable( value_id, value_synonym_id, variable_id, variable_storage_class, initializer_id, instruction_descriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests pointer type not available. value_id = 80; value_synonym_id = 62; variable_id = 63; initializer_id = 80; variable_storage_class = (uint32_t)spv::StorageClass::Private; instruction_descriptor = MakeInstructionDescriptor(95, spv::Op::OpReturnValue, 0); transformation = TransformationPushIdThroughVariable( value_id, value_synonym_id, variable_id, variable_storage_class, initializer_id, instruction_descriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests not a private nor function storage class. value_id = 93; value_synonym_id = 62; variable_id = 63; initializer_id = 93; variable_storage_class = (uint32_t)spv::StorageClass::Input; instruction_descriptor = MakeInstructionDescriptor(95, spv::Op::OpReturnValue, 0); transformation = TransformationPushIdThroughVariable( value_id, value_synonym_id, variable_id, variable_storage_class, initializer_id, instruction_descriptor); #ifndef NDEBUG ASSERT_DEATH( transformation.IsApplicable(context.get(), transformation_context), "The variable storage class must be private or function"); #endif // Tests value instruction not available before instruction. value_id = 95; value_synonym_id = 62; variable_id = 63; initializer_id = 80; variable_storage_class = (uint32_t)spv::StorageClass::Function; instruction_descriptor = MakeInstructionDescriptor(40, spv::Op::OpAccessChain, 0); transformation = TransformationPushIdThroughVariable( value_id, value_synonym_id, variable_id, variable_storage_class, initializer_id, instruction_descriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Variable initializer is not constant. value_id = 95; value_synonym_id = 62; variable_id = 63; initializer_id = 95; variable_storage_class = (uint32_t)spv::StorageClass::Function; instruction_descriptor = MakeInstructionDescriptor(40, spv::Op::OpAccessChain, 0); transformation = TransformationPushIdThroughVariable( value_id, value_synonym_id, variable_id, variable_storage_class, initializer_id, instruction_descriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Variable initializer has wrong type. value_id = 95; value_synonym_id = 62; variable_id = 63; initializer_id = 93; variable_storage_class = (uint32_t)spv::StorageClass::Function; instruction_descriptor = MakeInstructionDescriptor(40, spv::Op::OpAccessChain, 0); transformation = TransformationPushIdThroughVariable( value_id, value_synonym_id, variable_id, variable_storage_class, initializer_id, instruction_descriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationPushIdThroughVariableTest, Apply) { std::string reference_shader = R"( OpCapability Shader OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %92 %52 %53 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %92 BuiltIn FragCoord %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeFloat 32 %8 = OpTypeStruct %6 %7 %9 = OpTypePointer Function %8 %10 = OpTypeFunction %6 %9 %14 = OpConstant %6 0 %15 = OpTypePointer Function %6 %51 = OpTypePointer Private %6 %21 = OpConstant %6 2 %23 = OpConstant %6 1 %24 = OpConstant %7 1 %25 = OpTypePointer Function %7 %50 = OpTypePointer Private %7 %34 = OpTypeBool %35 = OpConstantFalse %34 %60 = OpConstantNull %50 %52 = OpVariable %50 Private %53 = OpVariable %51 Private %80 = OpConstantComposite %8 %21 %24 %90 = OpTypeVector %7 4 %91 = OpTypePointer Input %90 %92 = OpVariable %91 Input %93 = OpConstantComposite %90 %24 %24 %24 %24 %4 = OpFunction %2 None %3 %5 = OpLabel %20 = OpVariable %9 Function %27 = OpVariable %9 Function OpStore %53 %21 %22 = OpAccessChain %15 %20 %14 %44 = OpCopyObject %9 %20 %26 = OpAccessChain %25 %20 %23 %29 = OpFunctionCall %6 %12 %27 %30 = OpAccessChain %15 %20 %14 %45 = OpCopyObject %15 %30 %81 = OpCopyObject %9 %27 %33 = OpAccessChain %15 %20 %14 OpSelectionMerge %37 None OpBranchConditional %35 %36 %37 %36 = OpLabel %38 = OpAccessChain %15 %20 %14 %40 = OpAccessChain %15 %20 %14 %43 = OpAccessChain %15 %20 %14 %82 = OpCopyObject %9 %27 OpBranch %37 %37 = OpLabel OpReturn OpFunctionEnd %12 = OpFunction %6 None %10 %11 = OpFunctionParameter %9 %13 = OpLabel %46 = OpCopyObject %9 %11 %16 = OpAccessChain %15 %11 %14 %95 = OpCopyObject %8 %80 OpReturnValue %21 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); uint32_t value_id = 80; uint32_t value_synonym_id = 100; uint32_t variable_id = 101; uint32_t initializer_id = 80; uint32_t variable_storage_class = (uint32_t)spv::StorageClass::Function; auto instruction_descriptor = MakeInstructionDescriptor(38, spv::Op::OpAccessChain, 0); auto transformation = TransformationPushIdThroughVariable( value_id, value_synonym_id, variable_id, variable_storage_class, initializer_id, instruction_descriptor); ASSERT_EQ(nullptr, context->get_def_use_mgr()->GetDef(value_synonym_id)); ASSERT_EQ(nullptr, context->get_instr_block(value_synonym_id)); ASSERT_EQ(nullptr, context->get_def_use_mgr()->GetDef(variable_id)); ASSERT_EQ(nullptr, context->get_instr_block(variable_id)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_EQ(spv::Op::OpLoad, context->get_def_use_mgr()->GetDef(value_synonym_id)->opcode()); ASSERT_EQ(36, context->get_instr_block(value_synonym_id)->id()); ASSERT_EQ(spv::Op::OpVariable, context->get_def_use_mgr()->GetDef(variable_id)->opcode()); ASSERT_EQ(5, context->get_instr_block(variable_id)->id()); uint32_t variable_use_count = 0; context->get_def_use_mgr()->ForEachUse( variable_id, [&variable_use_count](opt::Instruction* inst, uint32_t /*unused*/) { ASSERT_TRUE(inst->opcode() == spv::Op::OpLoad || inst->opcode() == spv::Op::OpStore); variable_use_count++; }); ASSERT_EQ(2, variable_use_count); value_id = 21; value_synonym_id = 102; variable_id = 103; initializer_id = 21; variable_storage_class = (uint32_t)spv::StorageClass::Function; instruction_descriptor = MakeInstructionDescriptor(38, spv::Op::OpAccessChain, 0); transformation = TransformationPushIdThroughVariable( value_id, value_synonym_id, variable_id, variable_storage_class, initializer_id, instruction_descriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); value_id = 95; value_synonym_id = 104; variable_id = 105; initializer_id = 80; variable_storage_class = (uint32_t)spv::StorageClass::Function; instruction_descriptor = MakeInstructionDescriptor(95, spv::Op::OpReturnValue, 0); transformation = TransformationPushIdThroughVariable( value_id, value_synonym_id, variable_id, variable_storage_class, initializer_id, instruction_descriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); value_id = 80; value_synonym_id = 106; variable_id = 107; initializer_id = 80; variable_storage_class = (uint32_t)spv::StorageClass::Function; instruction_descriptor = MakeInstructionDescriptor(95, spv::Op::OpReturnValue, 0); transformation = TransformationPushIdThroughVariable( value_id, value_synonym_id, variable_id, variable_storage_class, initializer_id, instruction_descriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); value_id = 21; value_synonym_id = 108; variable_id = 109; initializer_id = 21; variable_storage_class = (uint32_t)spv::StorageClass::Private; instruction_descriptor = MakeInstructionDescriptor(95, spv::Op::OpReturnValue, 0); transformation = TransformationPushIdThroughVariable( value_id, value_synonym_id, variable_id, variable_storage_class, initializer_id, instruction_descriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); value_id = 23; value_synonym_id = 110; variable_id = 111; initializer_id = 21; variable_storage_class = (uint32_t)spv::StorageClass::Private; instruction_descriptor = MakeInstructionDescriptor(27, spv::Op::OpStore, 0); transformation = TransformationPushIdThroughVariable( value_id, value_synonym_id, variable_id, variable_storage_class, initializer_id, instruction_descriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); std::string variant_shader = R"( OpCapability Shader OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %92 %52 %53 %109 %111 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %92 BuiltIn FragCoord %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeFloat 32 %8 = OpTypeStruct %6 %7 %9 = OpTypePointer Function %8 %10 = OpTypeFunction %6 %9 %14 = OpConstant %6 0 %15 = OpTypePointer Function %6 %51 = OpTypePointer Private %6 %21 = OpConstant %6 2 %23 = OpConstant %6 1 %24 = OpConstant %7 1 %25 = OpTypePointer Function %7 %50 = OpTypePointer Private %7 %34 = OpTypeBool %35 = OpConstantFalse %34 %60 = OpConstantNull %50 %52 = OpVariable %50 Private %53 = OpVariable %51 Private %80 = OpConstantComposite %8 %21 %24 %90 = OpTypeVector %7 4 %91 = OpTypePointer Input %90 %92 = OpVariable %91 Input %93 = OpConstantComposite %90 %24 %24 %24 %24 %109 = OpVariable %51 Private %21 %111 = OpVariable %51 Private %21 %4 = OpFunction %2 None %3 %5 = OpLabel %103 = OpVariable %15 Function %21 %101 = OpVariable %9 Function %80 %20 = OpVariable %9 Function %27 = OpVariable %9 Function OpStore %111 %23 %110 = OpLoad %6 %111 OpStore %53 %21 %22 = OpAccessChain %15 %20 %14 %44 = OpCopyObject %9 %20 %26 = OpAccessChain %25 %20 %23 %29 = OpFunctionCall %6 %12 %27 %30 = OpAccessChain %15 %20 %14 %45 = OpCopyObject %15 %30 %81 = OpCopyObject %9 %27 %33 = OpAccessChain %15 %20 %14 OpSelectionMerge %37 None OpBranchConditional %35 %36 %37 %36 = OpLabel OpStore %101 %80 %100 = OpLoad %8 %101 OpStore %103 %21 %102 = OpLoad %6 %103 %38 = OpAccessChain %15 %20 %14 %40 = OpAccessChain %15 %20 %14 %43 = OpAccessChain %15 %20 %14 %82 = OpCopyObject %9 %27 OpBranch %37 %37 = OpLabel OpReturn OpFunctionEnd %12 = OpFunction %6 None %10 %11 = OpFunctionParameter %9 %13 = OpLabel %107 = OpVariable %9 Function %80 %105 = OpVariable %9 Function %80 %46 = OpCopyObject %9 %11 %16 = OpAccessChain %15 %11 %14 %95 = OpCopyObject %8 %80 OpStore %105 %95 %104 = OpLoad %8 %105 OpStore %107 %80 %106 = OpLoad %8 %107 OpStore %109 %21 %108 = OpLoad %6 %109 OpReturnValue %21 OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, variant_shader, context.get())); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(80, {}), MakeDataDescriptor(100, {}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(21, {}), MakeDataDescriptor(102, {}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(95, {}), MakeDataDescriptor(104, {}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(80, {}), MakeDataDescriptor(106, {}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(21, {}), MakeDataDescriptor(108, {}))); } TEST(TransformationPushIdThroughVariableTest, AddSynonymsForRelevantIds) { std::string reference_shader = R"( OpCapability Shader OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %92 %52 %53 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %92 BuiltIn FragCoord %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeFloat 32 %8 = OpTypeStruct %6 %7 %9 = OpTypePointer Function %8 %10 = OpTypeFunction %6 %9 %14 = OpConstant %6 0 %15 = OpTypePointer Function %6 %51 = OpTypePointer Private %6 %21 = OpConstant %6 2 %23 = OpConstant %6 1 %24 = OpConstant %7 1 %25 = OpTypePointer Function %7 %50 = OpTypePointer Private %7 %34 = OpTypeBool %35 = OpConstantFalse %34 %60 = OpConstantNull %50 %52 = OpVariable %50 Private %53 = OpVariable %51 Private %80 = OpConstantComposite %8 %21 %24 %90 = OpTypeVector %7 4 %91 = OpTypePointer Input %90 %92 = OpVariable %91 Input %93 = OpConstantComposite %90 %24 %24 %24 %24 %4 = OpFunction %2 None %3 %5 = OpLabel %20 = OpVariable %9 Function %27 = OpVariable %9 Function %22 = OpAccessChain %15 %20 %14 %44 = OpCopyObject %9 %20 %26 = OpAccessChain %25 %20 %23 %29 = OpFunctionCall %6 %12 %27 %30 = OpAccessChain %15 %20 %14 %45 = OpCopyObject %15 %30 %81 = OpCopyObject %9 %27 %33 = OpAccessChain %15 %20 %14 OpSelectionMerge %37 None OpBranchConditional %35 %36 %37 %36 = OpLabel %38 = OpAccessChain %15 %20 %14 %40 = OpAccessChain %15 %20 %14 %43 = OpAccessChain %15 %20 %14 %82 = OpCopyObject %9 %27 OpBranch %37 %37 = OpLabel OpReturn OpFunctionEnd %12 = OpFunction %6 None %10 %11 = OpFunctionParameter %9 %13 = OpLabel %46 = OpCopyObject %9 %11 %16 = OpAccessChain %15 %11 %14 %95 = OpCopyObject %8 %80 OpReturnValue %21 %100 = OpLabel OpUnreachable OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Tests the reference shader validity. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); uint32_t value_id = 21; uint32_t value_synonym_id = 62; uint32_t variable_id = 63; uint32_t initializer_id = 23; uint32_t variable_storage_class = (uint32_t)spv::StorageClass::Private; auto instruction_descriptor = MakeInstructionDescriptor(95, spv::Op::OpReturnValue, 0); auto transformation = TransformationPushIdThroughVariable( value_id, value_synonym_id, variable_id, variable_storage_class, initializer_id, instruction_descriptor); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(21, {}), MakeDataDescriptor(62, {}))); } TEST(TransformationPushIdThroughVariableTest, DontAddSynonymsForIrrelevantIds) { std::string reference_shader = R"( OpCapability Shader OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %92 %52 %53 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %92 BuiltIn FragCoord %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeFloat 32 %8 = OpTypeStruct %6 %7 %9 = OpTypePointer Function %8 %10 = OpTypeFunction %6 %9 %14 = OpConstant %6 0 %15 = OpTypePointer Function %6 %51 = OpTypePointer Private %6 %21 = OpConstant %6 2 %23 = OpConstant %6 1 %24 = OpConstant %7 1 %25 = OpTypePointer Function %7 %50 = OpTypePointer Private %7 %34 = OpTypeBool %35 = OpConstantFalse %34 %60 = OpConstantNull %50 %52 = OpVariable %50 Private %53 = OpVariable %51 Private %80 = OpConstantComposite %8 %21 %24 %90 = OpTypeVector %7 4 %91 = OpTypePointer Input %90 %92 = OpVariable %91 Input %93 = OpConstantComposite %90 %24 %24 %24 %24 %4 = OpFunction %2 None %3 %5 = OpLabel %20 = OpVariable %9 Function %27 = OpVariable %9 Function %22 = OpAccessChain %15 %20 %14 %44 = OpCopyObject %9 %20 %26 = OpAccessChain %25 %20 %23 %29 = OpFunctionCall %6 %12 %27 %30 = OpAccessChain %15 %20 %14 %45 = OpCopyObject %15 %30 %81 = OpCopyObject %9 %27 %33 = OpAccessChain %15 %20 %14 OpSelectionMerge %37 None OpBranchConditional %35 %36 %37 %36 = OpLabel %38 = OpAccessChain %15 %20 %14 %40 = OpAccessChain %15 %20 %14 %43 = OpAccessChain %15 %20 %14 %82 = OpCopyObject %9 %27 OpBranch %37 %37 = OpLabel OpReturn OpFunctionEnd %12 = OpFunction %6 None %10 %11 = OpFunctionParameter %9 %13 = OpLabel %46 = OpCopyObject %9 %11 %16 = OpAccessChain %15 %11 %14 %95 = OpCopyObject %8 %80 OpReturnValue %21 %100 = OpLabel OpUnreachable OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Tests the reference shader validity. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); transformation_context.GetFactManager()->AddFactIdIsIrrelevant(21); uint32_t value_id = 21; uint32_t value_synonym_id = 62; uint32_t variable_id = 63; uint32_t initializer_id = 23; uint32_t variable_storage_class = (uint32_t)spv::StorageClass::Private; auto instruction_descriptor = MakeInstructionDescriptor(95, spv::Op::OpReturnValue, 0); auto transformation = TransformationPushIdThroughVariable( value_id, value_synonym_id, variable_id, variable_storage_class, initializer_id, instruction_descriptor); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(21, {}), MakeDataDescriptor(62, {}))); } TEST(TransformationPushIdThroughVariableTest, DontAddSynonymsInDeadBlocks) { std::string reference_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeVector %6 2 %8 = OpTypePointer Function %7 %10 = OpConstant %6 0 %11 = OpConstant %6 1 %12 = OpConstantComposite %7 %10 %11 %13 = OpTypeBool %50 = OpTypePointer Function %13 %14 = OpConstantFalse %13 %4 = OpFunction %2 None %3 %5 = OpLabel %9 = OpVariable %8 Function OpStore %9 %12 OpSelectionMerge %16 None OpBranchConditional %14 %15 %16 %15 = OpLabel OpBranch %16 %16 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Tests the reference shader validity. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); transformation_context.GetFactManager()->AddFactBlockIsDead(15); auto transformation = TransformationPushIdThroughVariable( 14, 100, 101, uint32_t(spv::StorageClass::Function), 14, MakeInstructionDescriptor(15, spv::Op::OpBranch, 0)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(14, {}), MakeDataDescriptor(100, {}))); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_record_synonymous_constants_test.cpp000066400000000000000000001045031475742701700332770ustar00rootroot00000000000000// Copyright (c) 2020 Stefano Milizia // Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_record_synonymous_constants.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { // Apply the TransformationRecordSynonymousConstants defined by the given // constant1_id and constant2_id and check that the fact that the two // constants are synonym is recorded. void ApplyTransformationAndCheckFactManager( uint32_t constant1_id, uint32_t constant2_id, opt::IRContext* ir_context, TransformationContext* transformation_context) { ApplyAndCheckFreshIds( TransformationRecordSynonymousConstants(constant1_id, constant2_id), ir_context, transformation_context); ASSERT_TRUE(transformation_context->GetFactManager()->IsSynonymous( MakeDataDescriptor(constant1_id, {}), MakeDataDescriptor(constant2_id, {}))); } TEST(TransformationRecordSynonymousConstantsTest, IntConstants) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %17 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "a" OpName %10 "b" OpName %12 "c" OpName %17 "color" OpDecorate %8 RelaxedPrecision OpDecorate %10 RelaxedPrecision OpDecorate %12 RelaxedPrecision OpDecorate %17 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %19 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %18 = OpConstant %6 0 %11 = OpConstantNull %6 %13 = OpConstant %6 1 %20 = OpConstant %19 1 %21 = OpConstant %19 -1 %22 = OpConstant %6 1 %14 = OpTypeFloat 32 %15 = OpTypeVector %14 4 %16 = OpTypePointer Output %15 %17 = OpVariable %16 Output %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %12 = OpVariable %7 Function OpStore %8 %9 OpStore %10 %11 OpStore %12 %13 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // %3 is not a constant declaration ASSERT_FALSE(TransformationRecordSynonymousConstants(3, 9).IsApplicable( context.get(), transformation_context)); ASSERT_FALSE(TransformationRecordSynonymousConstants(9, 3).IsApplicable( context.get(), transformation_context)); // The two constants must be different ASSERT_FALSE(TransformationRecordSynonymousConstants(9, 9).IsApplicable( context.get(), transformation_context)); // %9 and %13 are not equivalent ASSERT_FALSE(TransformationRecordSynonymousConstants(9, 13).IsApplicable( context.get(), transformation_context)); // Swapping the ids gives the same result ASSERT_FALSE(TransformationRecordSynonymousConstants(13, 9).IsApplicable( context.get(), transformation_context)); // %11 and %13 are not equivalent ASSERT_FALSE(TransformationRecordSynonymousConstants(11, 13).IsApplicable( context.get(), transformation_context)); // Swapping the ids gives the same result ASSERT_FALSE(TransformationRecordSynonymousConstants(13, 11).IsApplicable( context.get(), transformation_context)); // %20 and %21 have different values ASSERT_FALSE(TransformationRecordSynonymousConstants(20, 21).IsApplicable( context.get(), transformation_context)); // %13 and %22 are equal and thus equivalent (having the same value and type) ASSERT_TRUE(TransformationRecordSynonymousConstants(13, 22).IsApplicable( context.get(), transformation_context)); ApplyTransformationAndCheckFactManager(13, 22, context.get(), &transformation_context); // %13 and %20 are equal even if %13 is signed and %20 is unsigned ASSERT_TRUE(TransformationRecordSynonymousConstants(13, 20).IsApplicable( context.get(), transformation_context)); ApplyTransformationAndCheckFactManager(13, 20, context.get(), &transformation_context); // %9 and %11 are equivalent (OpConstant with value 0 and OpConstantNull) ASSERT_TRUE(TransformationRecordSynonymousConstants(9, 11).IsApplicable( context.get(), transformation_context)); ApplyTransformationAndCheckFactManager(9, 11, context.get(), &transformation_context); // Swapping the ids gives the same result ASSERT_TRUE(TransformationRecordSynonymousConstants(11, 9).IsApplicable( context.get(), transformation_context)); ApplyTransformationAndCheckFactManager(11, 9, context.get(), &transformation_context); } TEST(TransformationRecordSynonymousConstantsTest, BoolConstants) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %19 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "b" OpName %19 "color" OpDecorate %19 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpTypePointer Function %6 %9 = OpConstantFalse %6 %20 = OpConstantNull %6 %11 = OpConstantTrue %6 %21 = OpConstantFalse %6 %22 = OpConstantTrue %6 %16 = OpTypeFloat 32 %17 = OpTypeVector %16 4 %18 = OpTypePointer Output %17 %19 = OpVariable %18 Output %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpStore %8 %9 %10 = OpLoad %6 %8 %12 = OpLogicalEqual %6 %10 %11 OpSelectionMerge %14 None OpBranchConditional %12 %13 %14 %13 = OpLabel OpReturn %14 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // %9 and %11 are not equivalent ASSERT_FALSE(TransformationRecordSynonymousConstants(9, 11).IsApplicable( context.get(), transformation_context)); // %20 and %11 are not equivalent ASSERT_FALSE(TransformationRecordSynonymousConstants(20, 11).IsApplicable( context.get(), transformation_context)); // %9 and %21 are equivalent (both OpConstantFalse) ASSERT_TRUE(TransformationRecordSynonymousConstants(9, 21).IsApplicable( context.get(), transformation_context)); ApplyTransformationAndCheckFactManager(9, 21, context.get(), &transformation_context); // %11 and %22 are equivalent (both OpConstantTrue) ASSERT_TRUE(TransformationRecordSynonymousConstants(11, 22).IsApplicable( context.get(), transformation_context)); ApplyTransformationAndCheckFactManager(11, 22, context.get(), &transformation_context); // %9 and %20 are equivalent (OpConstantFalse and boolean OpConstantNull) ASSERT_TRUE(TransformationRecordSynonymousConstants(9, 20).IsApplicable( context.get(), transformation_context)); ApplyTransformationAndCheckFactManager(9, 20, context.get(), &transformation_context); } TEST(TransformationRecordSynonymousConstantsTest, FloatConstants) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %22 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "a" OpName %10 "b" OpName %12 "c" OpName %22 "color" OpDecorate %22 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %11 = OpConstantNull %6 %13 = OpConstant %6 2 %26 = OpConstant %6 2 %16 = OpTypeBool %20 = OpTypeVector %6 4 %21 = OpTypePointer Output %20 %22 = OpVariable %21 Output %23 = OpConstantComposite %20 %9 %11 %9 %11 %25 = OpConstantComposite %20 %11 %9 %9 %11 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %12 = OpVariable %7 Function OpStore %8 %9 OpStore %10 %11 OpStore %12 %13 %14 = OpLoad %6 %8 %15 = OpLoad %6 %10 %17 = OpFOrdEqual %16 %14 %15 OpSelectionMerge %19 None OpBranchConditional %17 %18 %24 %18 = OpLabel OpStore %22 %23 OpBranch %19 %24 = OpLabel OpStore %22 %25 OpBranch %19 %19 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // %9 and %13 are not equivalent ASSERT_FALSE(TransformationRecordSynonymousConstants(9, 13).IsApplicable( context.get(), transformation_context)); // %11 and %13 are not equivalent ASSERT_FALSE(TransformationRecordSynonymousConstants(11, 13).IsApplicable( context.get(), transformation_context)); // %13 and %23 are not equivalent ASSERT_FALSE(TransformationRecordSynonymousConstants(13, 23).IsApplicable( context.get(), transformation_context)); // %13 and %26 are identical float constants ASSERT_TRUE(TransformationRecordSynonymousConstants(13, 26).IsApplicable( context.get(), transformation_context)); ApplyTransformationAndCheckFactManager(13, 26, context.get(), &transformation_context); // %9 and %11 are equivalent () ASSERT_TRUE(TransformationRecordSynonymousConstants(9, 11).IsApplicable( context.get(), transformation_context)); ApplyTransformationAndCheckFactManager(9, 11, context.get(), &transformation_context); } TEST(TransformationRecordSynonymousConstantsTest, VectorAndMatrixCompositeConstants) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %24 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "a" OpName %12 "d" OpName %16 "e" OpName %24 "color" OpDecorate %12 RelaxedPrecision OpDecorate %18 RelaxedPrecision OpDecorate %24 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %28 = OpConstant %6 0 %30 = OpConstant %6 1 %10 = OpTypeInt 32 1 %11 = OpTypePointer Function %10 %13 = OpConstant %10 0 %14 = OpTypeBool %15 = OpTypePointer Function %14 %17 = OpConstantFalse %14 %22 = OpTypeVector %6 4 %37 = OpTypeVector %6 3 %32 = OpTypeMatrix %22 2 %39 = OpTypeMatrix %22 3 %23 = OpTypePointer Output %22 %24 = OpVariable %23 Output %25 = OpConstantComposite %22 %9 %9 %9 %9 %27 = OpConstantNull %22 %29 = OpConstantComposite %22 %9 %28 %28 %9 %31 = OpConstantComposite %22 %30 %9 %9 %9 %38 = OpConstantComposite %37 %9 %9 %9 %33 = OpConstantComposite %32 %25 %29 %34 = OpConstantComposite %32 %27 %25 %35 = OpConstantNull %32 %36 = OpConstantComposite %32 %31 %25 %40 = OpConstantComposite %39 %25 %25 %25 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %12 = OpVariable %11 Function %16 = OpVariable %15 Function OpStore %8 %9 OpStore %12 %13 OpStore %16 %17 %18 = OpLoad %10 %12 %19 = OpIEqual %14 %18 %13 OpSelectionMerge %21 None OpBranchConditional %19 %20 %26 %20 = OpLabel OpStore %24 %25 OpBranch %21 %26 = OpLabel OpStore %24 %25 OpBranch %21 %21 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // %25 and %27 are equivalent (25 is zero-like, 27 is null) ASSERT_TRUE(TransformationRecordSynonymousConstants(25, 27).IsApplicable( context.get(), transformation_context)); ApplyTransformationAndCheckFactManager(25, 27, context.get(), &transformation_context); // %25 and %29 are equivalent (same type and value) ASSERT_TRUE(TransformationRecordSynonymousConstants(25, 29).IsApplicable( context.get(), transformation_context)); ApplyTransformationAndCheckFactManager(25, 29, context.get(), &transformation_context); // %27 and %29 are equivalent (27 is null, 29 is zero-like) ASSERT_TRUE(TransformationRecordSynonymousConstants(27, 29).IsApplicable( context.get(), transformation_context)); ApplyTransformationAndCheckFactManager(27, 29, context.get(), &transformation_context); // %25 and %31 are not equivalent (they have different values) ASSERT_FALSE(TransformationRecordSynonymousConstants(25, 31).IsApplicable( context.get(), transformation_context)); // %27 and %31 are not equivalent (27 is null, 31 is not zero-like) ASSERT_FALSE(TransformationRecordSynonymousConstants(27, 31).IsApplicable( context.get(), transformation_context)); // %25 and %38 are not equivalent (they have different sizes) ASSERT_FALSE(TransformationRecordSynonymousConstants(25, 38).IsApplicable( context.get(), transformation_context)); // %35 and %36 are not equivalent (35 is null, 36 has non-zero components) ASSERT_FALSE(TransformationRecordSynonymousConstants(35, 36).IsApplicable( context.get(), transformation_context)); // %33 and %36 are not equivalent (not all components are equivalent) ASSERT_FALSE(TransformationRecordSynonymousConstants(33, 36).IsApplicable( context.get(), transformation_context)); // %33 and %40 are not equivalent (they have different sizes) ASSERT_FALSE(TransformationRecordSynonymousConstants(33, 40).IsApplicable( context.get(), transformation_context)); // %33 and %34 are equivalent (same type, equivalent components) ASSERT_TRUE(TransformationRecordSynonymousConstants(33, 34).IsApplicable( context.get(), transformation_context)); ApplyTransformationAndCheckFactManager(33, 34, context.get(), &transformation_context); // %33 and %35 are equivalent (33 has zero-valued components, 35 is null) ASSERT_TRUE(TransformationRecordSynonymousConstants(33, 35).IsApplicable( context.get(), transformation_context)); ApplyTransformationAndCheckFactManager(33, 35, context.get(), &transformation_context); } TEST(TransformationRecordSynonymousConstantsTest, StructCompositeConstants) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %24 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "a" OpName %12 "d" OpName %16 "e" OpName %24 "color" OpDecorate %12 RelaxedPrecision OpDecorate %18 RelaxedPrecision OpDecorate %24 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %28 = OpConstant %6 0 %30 = OpConstant %6 1 %10 = OpTypeInt 32 1 %11 = OpTypePointer Function %10 %13 = OpConstant %10 0 %33 = OpConstantNull %10 %14 = OpTypeBool %15 = OpTypePointer Function %14 %17 = OpConstantFalse %14 %34 = OpConstantNull %14 %22 = OpTypeVector %6 4 %32 = OpTypeStruct %22 %10 %14 %6 %38 = OpTypeStruct %6 %6 %6 %6 %23 = OpTypePointer Output %22 %24 = OpVariable %23 Output %25 = OpConstantComposite %22 %9 %9 %9 %9 %27 = OpConstantNull %22 %29 = OpConstantComposite %22 %9 %28 %28 %9 %31 = OpConstantComposite %22 %30 %9 %9 %9 %35 = OpConstantComposite %32 %25 %13 %17 %9 %36 = OpConstantComposite %32 %27 %33 %34 %28 %37 = OpConstantComposite %32 %31 %13 %17 %9 %39 = OpConstantComposite %38 %9 %9 %9 %9 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %12 = OpVariable %11 Function %16 = OpVariable %15 Function OpStore %8 %9 OpStore %12 %13 OpStore %16 %17 %18 = OpLoad %10 %12 %19 = OpIEqual %14 %18 %13 OpSelectionMerge %21 None OpBranchConditional %19 %20 %26 %20 = OpLabel OpStore %24 %25 OpBranch %21 %26 = OpLabel OpStore %24 %25 OpBranch %21 %21 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // %29 and %35 are not equivalent (they have different types) ASSERT_FALSE(TransformationRecordSynonymousConstants(29, 35).IsApplicable( context.get(), transformation_context)); // %35 and %37 are not equivalent (their first components are not equivalent) ASSERT_FALSE(TransformationRecordSynonymousConstants(35, 37).IsApplicable( context.get(), transformation_context)); // %35 and %36 are equivalent (all their components are equivalent) ASSERT_TRUE(TransformationRecordSynonymousConstants(35, 36).IsApplicable( context.get(), transformation_context)); ApplyTransformationAndCheckFactManager(35, 36, context.get(), &transformation_context); // %25 and %39 are not equivalent (they have different types) ASSERT_FALSE(TransformationRecordSynonymousConstants(25, 39).IsApplicable( context.get(), transformation_context)); } TEST(TransformationRecordSynonymousConstantsTest, ArrayCompositeConstants) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %24 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "a" OpName %12 "d" OpName %16 "e" OpName %24 "color" OpDecorate %12 RelaxedPrecision OpDecorate %18 RelaxedPrecision OpDecorate %24 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %38 = OpConstant %6 1 %10 = OpTypeInt 32 1 %11 = OpTypePointer Function %10 %13 = OpConstant %10 0 %27 = OpConstant %10 4 %39 = OpConstant %10 2 %14 = OpTypeBool %15 = OpTypePointer Function %14 %17 = OpConstantFalse %14 %22 = OpTypeVector %6 4 %28 = OpTypeArray %6 %27 %29 = OpTypeArray %28 %27 %40 = OpTypeArray %6 %39 %23 = OpTypePointer Output %22 %24 = OpVariable %23 Output %25 = OpConstantComposite %22 %9 %9 %9 %9 %31 = OpConstantComposite %28 %9 %9 %9 %9 %41 = OpConstantComposite %40 %9 %9 %32 = OpConstantComposite %28 %38 %9 %9 %9 %33 = OpConstantNull %28 %34 = OpConstantComposite %29 %31 %33 %31 %33 %35 = OpConstantComposite %29 %33 %31 %33 %31 %36 = OpConstantNull %29 %37 = OpConstantComposite %29 %32 %33 %31 %33 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %12 = OpVariable %11 Function %16 = OpVariable %15 Function OpStore %8 %9 OpStore %12 %13 OpStore %16 %17 %18 = OpLoad %10 %12 %19 = OpIEqual %14 %18 %13 OpSelectionMerge %21 None OpBranchConditional %19 %20 %26 %20 = OpLabel OpStore %24 %25 OpBranch %21 %26 = OpLabel OpStore %24 %25 OpBranch %21 %21 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // %25 and %31 are not equivalent (they have different types) ASSERT_FALSE(TransformationRecordSynonymousConstants(25, 31).IsApplicable( context.get(), transformation_context)); // %25 and %41 are not equivalent (they have different sizes) ASSERT_FALSE(TransformationRecordSynonymousConstants(25, 41).IsApplicable( context.get(), transformation_context)); // %31 and %32 are not equivalent (their components are not pairwise // equivalent) ASSERT_FALSE(TransformationRecordSynonymousConstants(31, 32).IsApplicable( context.get(), transformation_context)); // %31 and %33 are equivalent (%31 has zero-valued components, 32 is null) ASSERT_TRUE(TransformationRecordSynonymousConstants(31, 33).IsApplicable( context.get(), transformation_context)); ApplyTransformationAndCheckFactManager(31, 33, context.get(), &transformation_context); // %34 and %35 are equivalent (same type, equivalent components) ASSERT_TRUE(TransformationRecordSynonymousConstants(34, 35).IsApplicable( context.get(), transformation_context)); ApplyTransformationAndCheckFactManager(34, 35, context.get(), &transformation_context); // %35 and %36 are equivalent (%36 is null, %35 has zero-valued components) ASSERT_TRUE(TransformationRecordSynonymousConstants(35, 36).IsApplicable( context.get(), transformation_context)); ApplyTransformationAndCheckFactManager(35, 36, context.get(), &transformation_context); // %34 and %37 are not equivalent (they have non-equivalent components) ASSERT_FALSE(TransformationRecordSynonymousConstants(34, 37).IsApplicable( context.get(), transformation_context)); // %36 and %37 are not equivalent (36 is null, 37 does not have all-zero // components) ASSERT_FALSE(TransformationRecordSynonymousConstants(36, 37).IsApplicable( context.get(), transformation_context)); } TEST(TransformationRecordSynonymousConstantsTest, IntVectors) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpDecorate %3 Location 0 %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeInt 32 1 %7 = OpTypeInt 32 0 %8 = OpTypeVector %6 4 %9 = OpTypeVector %7 4 %10 = OpTypePointer Function %8 %11 = OpTypePointer Function %8 %12 = OpConstant %6 0 %13 = OpConstant %7 0 %14 = OpConstant %6 1 %25 = OpConstant %7 1 %15 = OpConstantComposite %8 %12 %12 %12 %12 %16 = OpConstantComposite %9 %13 %13 %13 %13 %17 = OpConstantComposite %8 %14 %12 %12 %14 %18 = OpConstantComposite %9 %25 %13 %13 %25 %19 = OpConstantNull %8 %20 = OpConstantNull %9 %21 = OpTypeFloat 32 %22 = OpTypeVector %21 4 %23 = OpTypePointer Output %22 %3 = OpVariable %23 Output %2 = OpFunction %4 None %5 %24 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // %15 and %17 are not equivalent (having non-equivalent components) ASSERT_FALSE(TransformationRecordSynonymousConstants(15, 17).IsApplicable( context.get(), transformation_context)); // %17 and %19 are not equivalent (%19 is null, %17 is non-zero) ASSERT_FALSE(TransformationRecordSynonymousConstants(17, 19).IsApplicable( context.get(), transformation_context)); // %17 and %20 are not equivalent (%19 is null, %20 is non-zero) ASSERT_FALSE(TransformationRecordSynonymousConstants(17, 20).IsApplicable( context.get(), transformation_context)); // %15 and %16 are equivalent (having pairwise equivalent components) ASSERT_TRUE(TransformationRecordSynonymousConstants(15, 16).IsApplicable( context.get(), transformation_context)); ApplyTransformationAndCheckFactManager(15, 16, context.get(), &transformation_context); // %17 and %18 are equivalent (having pairwise equivalent components) ASSERT_TRUE(TransformationRecordSynonymousConstants(17, 18).IsApplicable( context.get(), transformation_context)); ApplyTransformationAndCheckFactManager(17, 18, context.get(), &transformation_context); // %19 and %20 are equivalent (both null vectors with compatible types) ASSERT_TRUE(TransformationRecordSynonymousConstants(19, 20).IsApplicable( context.get(), transformation_context)); ApplyTransformationAndCheckFactManager(19, 20, context.get(), &transformation_context); // %15 and %19 are equivalent (they have compatible types, %15 is zero-like // and %19 is null) ASSERT_TRUE(TransformationRecordSynonymousConstants(15, 19).IsApplicable( context.get(), transformation_context)); ApplyTransformationAndCheckFactManager(15, 19, context.get(), &transformation_context); // %15 and %20 are equivalent (they have compatible types, %15 is zero-like // and %20 is null) ASSERT_TRUE(TransformationRecordSynonymousConstants(15, 20).IsApplicable( context.get(), transformation_context)); ApplyTransformationAndCheckFactManager(15, 20, context.get(), &transformation_context); } TEST(TransformationRecordSynonymousConstantsTest, FirstIrrelevantConstant) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpConstant %6 23 %8 = OpConstant %6 23 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_TRUE(TransformationRecordSynonymousConstants(7, 8).IsApplicable( context.get(), transformation_context)); transformation_context.GetFactManager()->AddFactIdIsIrrelevant(7); ASSERT_FALSE(TransformationRecordSynonymousConstants(7, 8).IsApplicable( context.get(), transformation_context)); } TEST(TransformationRecordSynonymousConstantsTest, SecondIrrelevantConstant) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpConstant %6 23 %8 = OpConstant %6 23 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_TRUE(TransformationRecordSynonymousConstants(7, 8).IsApplicable( context.get(), transformation_context)); transformation_context.GetFactManager()->AddFactIdIsIrrelevant(8); ASSERT_FALSE(TransformationRecordSynonymousConstants(7, 8).IsApplicable( context.get(), transformation_context)); } TEST(TransformationRecordSynonymousConstantsTest, InvalidIds) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpConstant %6 23 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_FALSE(TransformationRecordSynonymousConstants(7, 8).IsApplicable( context.get(), transformation_context)); ASSERT_FALSE(TransformationRecordSynonymousConstants(8, 7).IsApplicable( context.get(), transformation_context)); } } // namespace } // namespace fuzz } // namespace spvtools transformation_replace_add_sub_mul_with_carrying_extended_test.cpp000066400000000000000000000564411475742701700361140ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/fuzz// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_replace_add_sub_mul_with_carrying_extended.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationReplaceAddSubMulWithCarryingExtendedTest, NotApplicableBasicChecks) { // First conditions in IsApplicable() are checked. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "i1" OpName %10 "i2" OpName %12 "i3" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 2 %11 = OpConstant %6 3 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %12 = OpVariable %7 Function OpStore %8 %9 OpStore %10 %11 %13 = OpLoad %6 %10 %14 = OpLoad %6 %8 %15 = OpSDiv %6 %13 %14 OpStore %12 %15 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Bad: |struct_fresh_id| must be fresh. auto transformation_bad_1 = TransformationReplaceAddSubMulWithCarryingExtended(14, 15); ASSERT_FALSE( transformation_bad_1.IsApplicable(context.get(), transformation_context)); // Bad: The transformation cannot be applied to an instruction OpSDiv. auto transformation_bad_2 = TransformationReplaceAddSubMulWithCarryingExtended(20, 15); ASSERT_FALSE( transformation_bad_2.IsApplicable(context.get(), transformation_context)); // Bad: The transformation cannot be applied to an nonexistent instruction. auto transformation_bad_3 = TransformationReplaceAddSubMulWithCarryingExtended(20, 21); ASSERT_FALSE( transformation_bad_3.IsApplicable(context.get(), transformation_context)); } TEST(TransformationReplaceAddSubMulWithCarryingExtendedTest, NotApplicableDifferingSignedTypes) { // Operand types and result types do not match. Not applicable to an operation // on vectors with signed integers and operation on signed integers. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "i1" OpName %10 "i2" OpName %16 "v1" OpName %20 "v2" OpName %25 "v3" OpName %31 "u1" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %14 = OpTypeVector %6 3 %15 = OpTypePointer Function %14 %17 = OpConstant %6 0 %18 = OpConstant %6 2 %19 = OpConstantComposite %14 %17 %9 %18 %21 = OpConstant %6 3 %22 = OpConstant %6 4 %23 = OpConstant %6 5 %24 = OpConstantComposite %14 %21 %22 %23 %29 = OpTypeInt 32 0 %30 = OpTypePointer Function %29 %32 = OpConstant %29 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %16 = OpVariable %15 Function %20 = OpVariable %15 Function %25 = OpVariable %15 Function %31 = OpVariable %30 Function OpStore %8 %9 %11 = OpLoad %6 %8 %12 = OpLoad %6 %8 %13 = OpISub %6 %11 %12 OpStore %10 %13 OpStore %16 %19 OpStore %20 %24 %26 = OpLoad %14 %16 %27 = OpLoad %14 %20 %28 = OpIAdd %14 %26 %27 OpStore %25 %28 OpStore %31 %32 %40 = OpIMul %6 %32 %18 %41 = OpIAdd %6 %32 %32 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Bad: The transformation cannot be applied to an instruction OpIMul that has // different signedness of the types of operands. auto transformation_bad_1 = TransformationReplaceAddSubMulWithCarryingExtended(50, 40); ASSERT_FALSE( transformation_bad_1.IsApplicable(context.get(), transformation_context)); // Bad: The transformation cannot be applied to an instruction OpIAdd that has // different signedness of the result type than the signedness of the types of // the operands. auto transformation_bad_2 = TransformationReplaceAddSubMulWithCarryingExtended(50, 41); ASSERT_FALSE( transformation_bad_2.IsApplicable(context.get(), transformation_context)); // Bad: The transformation cannot be applied to the instruction OpIAdd of two // vectors that have signed components. auto transformation_bad_3 = TransformationReplaceAddSubMulWithCarryingExtended(50, 28); ASSERT_FALSE( transformation_bad_3.IsApplicable(context.get(), transformation_context)); // Bad: The transformation cannot be applied to the instruction OpISub of two // signed integers auto transformation_bad_4 = TransformationReplaceAddSubMulWithCarryingExtended(50, 13); ASSERT_FALSE( transformation_bad_4.IsApplicable(context.get(), transformation_context)); } TEST(TransformationReplaceAddSubMulWithCarryingExtendedTest, NotApplicableMissingStructTypes) { // In all cases the required struct types are missing. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "u1" OpName %10 "u2" OpName %12 "u3" OpName %24 "i1" OpName %26 "i2" OpName %28 "i3" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %11 = OpConstant %6 2 %22 = OpTypeInt 32 1 %23 = OpTypePointer Function %22 %25 = OpConstant %22 1 %27 = OpConstant %22 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %12 = OpVariable %7 Function %24 = OpVariable %23 Function %26 = OpVariable %23 Function %28 = OpVariable %23 Function OpStore %8 %9 OpStore %10 %11 %13 = OpLoad %6 %8 %14 = OpLoad %6 %10 %15 = OpIAdd %6 %13 %14 OpStore %12 %15 %16 = OpLoad %6 %8 %17 = OpLoad %6 %10 %18 = OpISub %6 %16 %17 OpStore %12 %18 %19 = OpLoad %6 %8 %20 = OpLoad %6 %10 %21 = OpIMul %6 %19 %20 OpStore %12 %21 OpStore %24 %25 OpStore %26 %27 %29 = OpLoad %22 %24 %30 = OpLoad %22 %26 %31 = OpIMul %22 %29 %30 OpStore %28 %31 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto transformation_bad_1 = TransformationReplaceAddSubMulWithCarryingExtended(50, 15); ASSERT_FALSE( transformation_bad_1.IsApplicable(context.get(), transformation_context)); auto transformation_bad_2 = TransformationReplaceAddSubMulWithCarryingExtended(50, 18); ASSERT_FALSE( transformation_bad_2.IsApplicable(context.get(), transformation_context)); // Bad: The transformation cannot be applied to the instruction OpIAdd of two // vectors that have signed components. auto transformation_bad_3 = TransformationReplaceAddSubMulWithCarryingExtended(50, 21); ASSERT_FALSE( transformation_bad_3.IsApplicable(context.get(), transformation_context)); // Bad: The transformation cannot be applied to the instruction OpISub of two // signed integers auto transformation_bad_4 = TransformationReplaceAddSubMulWithCarryingExtended(50, 31); ASSERT_FALSE( transformation_bad_4.IsApplicable(context.get(), transformation_context)); } TEST(TransformationReplaceAddSubMulWithCarryingExtendedTest, ApplicableScenarios) { // In this test all of the transformations can be applied. The required struct // types are provided. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "u1" OpName %10 "u2" OpName %12 "u3" OpName %24 "i1" OpName %26 "i2" OpName %28 "i3" OpName %34 "uv1" OpName %36 "uv2" OpName %39 "uv3" OpName %51 "v1" OpName %53 "v2" OpName %56 "v3" OpName %60 "pair_uint" OpMemberName %60 0 "u_1" OpMemberName %60 1 "u_2" OpName %62 "p_uint" OpName %63 "pair_uvec2" OpMemberName %63 0 "uv_1" OpMemberName %63 1 "uv_2" OpName %65 "p_uvec2" OpName %66 "pair_ivec2" OpMemberName %66 0 "v_1" OpMemberName %66 1 "v_2" OpName %68 "p_ivec2" OpName %69 "pair_int" OpMemberName %69 0 "i_1" OpMemberName %69 1 "i_2" OpName %71 "p_int" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %11 = OpConstant %6 2 %22 = OpTypeInt 32 1 %23 = OpTypePointer Function %22 %25 = OpConstant %22 1 %27 = OpConstant %22 2 %32 = OpTypeVector %6 2 %33 = OpTypePointer Function %32 %35 = OpConstantComposite %32 %9 %11 %37 = OpConstant %6 3 %38 = OpConstantComposite %32 %11 %37 %49 = OpTypeVector %22 2 %50 = OpTypePointer Function %49 %52 = OpConstantComposite %49 %25 %27 %54 = OpConstant %22 3 %55 = OpConstantComposite %49 %27 %54 %60 = OpTypeStruct %6 %6 %61 = OpTypePointer Private %60 %62 = OpVariable %61 Private %63 = OpTypeStruct %32 %32 %64 = OpTypePointer Private %63 %65 = OpVariable %64 Private %66 = OpTypeStruct %49 %49 %67 = OpTypePointer Private %66 %68 = OpVariable %67 Private %69 = OpTypeStruct %22 %22 %70 = OpTypePointer Private %69 %71 = OpVariable %70 Private %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %12 = OpVariable %7 Function %24 = OpVariable %23 Function %26 = OpVariable %23 Function %28 = OpVariable %23 Function %34 = OpVariable %33 Function %36 = OpVariable %33 Function %39 = OpVariable %33 Function %51 = OpVariable %50 Function %53 = OpVariable %50 Function %56 = OpVariable %50 Function OpStore %8 %9 OpStore %10 %11 %13 = OpLoad %6 %8 %14 = OpLoad %6 %10 %15 = OpIAdd %6 %13 %14 OpStore %12 %15 %16 = OpLoad %6 %8 %17 = OpLoad %6 %10 %18 = OpISub %6 %16 %17 OpStore %12 %18 %19 = OpLoad %6 %8 %20 = OpLoad %6 %10 %21 = OpIMul %6 %19 %20 OpStore %12 %21 OpStore %24 %25 OpStore %26 %27 %29 = OpLoad %22 %24 %30 = OpLoad %22 %26 %31 = OpIMul %22 %29 %30 OpStore %28 %31 OpStore %34 %35 OpStore %36 %38 %40 = OpLoad %32 %34 %41 = OpLoad %32 %36 %42 = OpIAdd %32 %40 %41 OpStore %39 %42 %43 = OpLoad %32 %34 %44 = OpLoad %32 %36 %45 = OpISub %32 %43 %44 OpStore %39 %45 %46 = OpLoad %32 %34 %47 = OpLoad %32 %36 %48 = OpIMul %32 %46 %47 OpStore %39 %48 OpStore %51 %52 OpStore %53 %55 %57 = OpLoad %49 %51 %58 = OpLoad %49 %53 %59 = OpIMul %49 %57 %58 OpStore %56 %59 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto transformation_good_1 = TransformationReplaceAddSubMulWithCarryingExtended(80, 15); ASSERT_TRUE(transformation_good_1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); auto transformation_good_2 = TransformationReplaceAddSubMulWithCarryingExtended(81, 18); ASSERT_TRUE(transformation_good_2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); auto transformation_good_3 = TransformationReplaceAddSubMulWithCarryingExtended(82, 21); ASSERT_TRUE(transformation_good_3.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_3, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); auto transformation_good_4 = TransformationReplaceAddSubMulWithCarryingExtended(83, 31); ASSERT_TRUE(transformation_good_4.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_4, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); auto transformation_good_5 = TransformationReplaceAddSubMulWithCarryingExtended(84, 42); ASSERT_TRUE(transformation_good_5.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_5, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); auto transformation_good_6 = TransformationReplaceAddSubMulWithCarryingExtended(85, 45); ASSERT_TRUE(transformation_good_6.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_6, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); auto transformation_good_7 = TransformationReplaceAddSubMulWithCarryingExtended(86, 48); ASSERT_TRUE(transformation_good_7.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_7, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); auto transformation_good_8 = TransformationReplaceAddSubMulWithCarryingExtended(87, 59); ASSERT_TRUE(transformation_good_8.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_8, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "u1" OpName %10 "u2" OpName %12 "u3" OpName %24 "i1" OpName %26 "i2" OpName %28 "i3" OpName %34 "uv1" OpName %36 "uv2" OpName %39 "uv3" OpName %51 "v1" OpName %53 "v2" OpName %56 "v3" OpName %60 "pair_uint" OpMemberName %60 0 "u_1" OpMemberName %60 1 "u_2" OpName %62 "p_uint" OpName %63 "pair_uvec2" OpMemberName %63 0 "uv_1" OpMemberName %63 1 "uv_2" OpName %65 "p_uvec2" OpName %66 "pair_ivec2" OpMemberName %66 0 "v_1" OpMemberName %66 1 "v_2" OpName %68 "p_ivec2" OpName %69 "pair_int" OpMemberName %69 0 "i_1" OpMemberName %69 1 "i_2" OpName %71 "p_int" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %11 = OpConstant %6 2 %22 = OpTypeInt 32 1 %23 = OpTypePointer Function %22 %25 = OpConstant %22 1 %27 = OpConstant %22 2 %32 = OpTypeVector %6 2 %33 = OpTypePointer Function %32 %35 = OpConstantComposite %32 %9 %11 %37 = OpConstant %6 3 %38 = OpConstantComposite %32 %11 %37 %49 = OpTypeVector %22 2 %50 = OpTypePointer Function %49 %52 = OpConstantComposite %49 %25 %27 %54 = OpConstant %22 3 %55 = OpConstantComposite %49 %27 %54 %60 = OpTypeStruct %6 %6 %61 = OpTypePointer Private %60 %62 = OpVariable %61 Private %63 = OpTypeStruct %32 %32 %64 = OpTypePointer Private %63 %65 = OpVariable %64 Private %66 = OpTypeStruct %49 %49 %67 = OpTypePointer Private %66 %68 = OpVariable %67 Private %69 = OpTypeStruct %22 %22 %70 = OpTypePointer Private %69 %71 = OpVariable %70 Private %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %12 = OpVariable %7 Function %24 = OpVariable %23 Function %26 = OpVariable %23 Function %28 = OpVariable %23 Function %34 = OpVariable %33 Function %36 = OpVariable %33 Function %39 = OpVariable %33 Function %51 = OpVariable %50 Function %53 = OpVariable %50 Function %56 = OpVariable %50 Function OpStore %8 %9 OpStore %10 %11 %13 = OpLoad %6 %8 %14 = OpLoad %6 %10 %80 = OpIAddCarry %60 %13 %14 %15 = OpCompositeExtract %6 %80 0 OpStore %12 %15 %16 = OpLoad %6 %8 %17 = OpLoad %6 %10 %81 = OpISubBorrow %60 %16 %17 %18 = OpCompositeExtract %6 %81 0 OpStore %12 %18 %19 = OpLoad %6 %8 %20 = OpLoad %6 %10 %82 = OpUMulExtended %60 %19 %20 %21 = OpCompositeExtract %6 %82 0 OpStore %12 %21 OpStore %24 %25 OpStore %26 %27 %29 = OpLoad %22 %24 %30 = OpLoad %22 %26 %83 = OpSMulExtended %69 %29 %30 %31 = OpCompositeExtract %22 %83 0 OpStore %28 %31 OpStore %34 %35 OpStore %36 %38 %40 = OpLoad %32 %34 %41 = OpLoad %32 %36 %84 = OpIAddCarry %63 %40 %41 %42 = OpCompositeExtract %32 %84 0 OpStore %39 %42 %43 = OpLoad %32 %34 %44 = OpLoad %32 %36 %85 = OpISubBorrow %63 %43 %44 %45 = OpCompositeExtract %32 %85 0 OpStore %39 %45 %46 = OpLoad %32 %34 %47 = OpLoad %32 %36 %86 = OpUMulExtended %63 %46 %47 %48 = OpCompositeExtract %32 %86 0 OpStore %39 %48 OpStore %51 %52 OpStore %53 %55 %57 = OpLoad %49 %51 %58 = OpLoad %49 %53 %87 = OpSMulExtended %66 %57 %58 %59 = OpCompositeExtract %49 %87 0 OpStore %56 %59 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools transformation_replace_boolean_constant_with_constant_binary_test.cpp000066400000000000000000000720111475742701700366540ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/fuzz// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_replace_boolean_constant_with_constant_binary.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/id_use_descriptor.h" #include "source/fuzz/instruction_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationReplaceBooleanConstantWithConstantBinaryTest, BasicReplacements) { // The test came from the following pseudo-GLSL, where int64 and uint64 denote // 64-bit integer types (they were replaced with int and uint during // translation to SPIR-V, and the generated SPIR-V has been doctored to // accommodate them). // // #version 450 // // void main() { // double d1, d2; // d1 = 1.0; // d2 = 2.0; // float f1, f2; // f1 = 4.0; // f2 = 8.0; // int i1, i2; // i1 = 100; // i2 = 200; // // uint u1, u2; // u1 = 300u; // u2 = 400u; // // int64 i64_1, i64_2; // i64_1 = 500; // i64_2 = 600; // // uint64 u64_1, u64_2; // u64_1 = 700u; // u64_2 = 800u; // // bool b, c, d, e; // b = true; // c = false; // d = true || c; // c = c && false; // } std::string shader = R"( OpCapability Shader OpCapability Float64 OpCapability Int64 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 450 OpName %4 "main" OpName %8 "d1" OpName %10 "d2" OpName %14 "f1" OpName %16 "f2" OpName %20 "i1" OpName %22 "i2" OpName %26 "u1" OpName %28 "u2" OpName %30 "i64_1" OpName %32 "i64_2" OpName %34 "u64_1" OpName %36 "u64_2" OpName %40 "b" OpName %42 "c" OpName %44 "d" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 64 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %11 = OpConstant %6 2 %12 = OpTypeFloat 32 %13 = OpTypePointer Function %12 %15 = OpConstant %12 4 %17 = OpConstant %12 8 %18 = OpTypeInt 32 1 %60 = OpTypeInt 64 1 %61 = OpTypePointer Function %60 %19 = OpTypePointer Function %18 %21 = OpConstant %18 -100 %23 = OpConstant %18 200 %24 = OpTypeInt 32 0 %62 = OpTypeInt 64 0 %63 = OpTypePointer Function %62 %25 = OpTypePointer Function %24 %27 = OpConstant %24 300 %29 = OpConstant %24 400 %31 = OpConstant %60 -600 %33 = OpConstant %60 -500 %35 = OpConstant %62 700 %37 = OpConstant %62 800 %38 = OpTypeBool %39 = OpTypePointer Function %38 %41 = OpConstantTrue %38 %43 = OpConstantFalse %38 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %14 = OpVariable %13 Function %16 = OpVariable %13 Function %20 = OpVariable %19 Function %22 = OpVariable %19 Function %26 = OpVariable %25 Function %28 = OpVariable %25 Function %30 = OpVariable %61 Function %32 = OpVariable %61 Function %34 = OpVariable %63 Function %36 = OpVariable %63 Function %40 = OpVariable %39 Function %42 = OpVariable %39 Function %44 = OpVariable %39 Function OpStore %8 %9 OpStore %10 %11 OpStore %14 %15 OpStore %16 %17 OpStore %20 %21 OpStore %22 %23 OpStore %26 %27 OpStore %28 %29 OpStore %30 %31 OpStore %32 %33 OpStore %34 %35 OpStore %36 %37 OpStore %40 %41 OpStore %42 %43 %45 = OpLoad %38 %42 %46 = OpLogicalOr %38 %41 %45 OpStore %44 %46 %47 = OpLoad %38 %42 %48 = OpLogicalAnd %38 %47 %43 OpStore %42 %48 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); std::vector uses_of_true = { MakeIdUseDescriptor( 41, MakeInstructionDescriptor(44, spv::Op::OpStore, 12), 1), MakeIdUseDescriptor( 41, MakeInstructionDescriptor(46, spv::Op::OpLogicalOr, 0), 0)}; std::vector uses_of_false = { MakeIdUseDescriptor( 43, MakeInstructionDescriptor(44, spv::Op::OpStore, 13), 1), MakeIdUseDescriptor( 43, MakeInstructionDescriptor(48, spv::Op::OpLogicalAnd, 0), 1)}; const uint32_t fresh_id = 100; std::vector fp_gt_opcodes = { spv::Op::OpFOrdGreaterThan, spv::Op::OpFOrdGreaterThanEqual, spv::Op::OpFUnordGreaterThan, spv::Op::OpFUnordGreaterThanEqual}; std::vector fp_lt_opcodes = { spv::Op::OpFOrdLessThan, spv::Op::OpFOrdLessThanEqual, spv::Op::OpFUnordLessThan, spv::Op::OpFUnordLessThanEqual}; std::vector int_gt_opcodes = {spv::Op::OpSGreaterThan, spv::Op::OpSGreaterThanEqual}; std::vector int_lt_opcodes = {spv::Op::OpSLessThan, spv::Op::OpSLessThanEqual}; std::vector uint_gt_opcodes = {spv::Op::OpUGreaterThan, spv::Op::OpUGreaterThanEqual}; std::vector uint_lt_opcodes = {spv::Op::OpULessThan, spv::Op::OpULessThanEqual}; #define CHECK_OPERATOR(USE_DESCRIPTOR, LHS_ID, RHS_ID, OPCODE, FRESH_ID) \ ASSERT_TRUE(TransformationReplaceBooleanConstantWithConstantBinary( \ USE_DESCRIPTOR, LHS_ID, RHS_ID, OPCODE, FRESH_ID) \ .IsApplicable(context.get(), transformation_context)); \ ASSERT_FALSE(TransformationReplaceBooleanConstantWithConstantBinary( \ USE_DESCRIPTOR, RHS_ID, LHS_ID, OPCODE, FRESH_ID) \ .IsApplicable(context.get(), transformation_context)); #define CHECK_TRANSFORMATION_APPLICABILITY(GT_OPCODES, LT_OPCODES, SMALL_ID, \ LARGE_ID) \ for (auto gt_opcode : GT_OPCODES) { \ for (auto& true_use : uses_of_true) { \ CHECK_OPERATOR(true_use, LARGE_ID, SMALL_ID, gt_opcode, fresh_id); \ } \ for (auto& false_use : uses_of_false) { \ CHECK_OPERATOR(false_use, SMALL_ID, LARGE_ID, gt_opcode, fresh_id); \ } \ } \ for (auto lt_opcode : LT_OPCODES) { \ for (auto& true_use : uses_of_true) { \ CHECK_OPERATOR(true_use, SMALL_ID, LARGE_ID, lt_opcode, fresh_id); \ } \ for (auto& false_use : uses_of_false) { \ CHECK_OPERATOR(false_use, LARGE_ID, SMALL_ID, lt_opcode, fresh_id); \ } \ } // Float { CHECK_TRANSFORMATION_APPLICABILITY(fp_gt_opcodes, fp_lt_opcodes, 15, 17); } // Double { CHECK_TRANSFORMATION_APPLICABILITY(fp_gt_opcodes, fp_lt_opcodes, 9, 11); } // Int32 { CHECK_TRANSFORMATION_APPLICABILITY(int_gt_opcodes, int_lt_opcodes, 21, 23); } // Int64 { CHECK_TRANSFORMATION_APPLICABILITY(int_gt_opcodes, int_lt_opcodes, 31, 33); } // Uint32 { CHECK_TRANSFORMATION_APPLICABILITY(uint_gt_opcodes, uint_lt_opcodes, 27, 29); } // Uint64 { CHECK_TRANSFORMATION_APPLICABILITY(uint_gt_opcodes, uint_lt_opcodes, 35, 37); } // Target id is not fresh ASSERT_FALSE(TransformationReplaceBooleanConstantWithConstantBinary( uses_of_true[0], 15, 17, spv::Op::OpFOrdLessThan, 15) .IsApplicable(context.get(), transformation_context)); // LHS id does not exist ASSERT_FALSE(TransformationReplaceBooleanConstantWithConstantBinary( uses_of_true[0], 300, 17, spv::Op::OpFOrdLessThan, 200) .IsApplicable(context.get(), transformation_context)); // RHS id does not exist ASSERT_FALSE(TransformationReplaceBooleanConstantWithConstantBinary( uses_of_true[0], 15, 300, spv::Op::OpFOrdLessThan, 200) .IsApplicable(context.get(), transformation_context)); // LHS and RHS ids do not match type ASSERT_FALSE(TransformationReplaceBooleanConstantWithConstantBinary( uses_of_true[0], 11, 17, spv::Op::OpFOrdLessThan, 200) .IsApplicable(context.get(), transformation_context)); // Opcode not appropriate ASSERT_FALSE(TransformationReplaceBooleanConstantWithConstantBinary( uses_of_true[0], 15, 17, spv::Op::OpFDiv, 200) .IsApplicable(context.get(), transformation_context)); auto replace_true_with_double_comparison = TransformationReplaceBooleanConstantWithConstantBinary( uses_of_true[0], 11, 9, spv::Op::OpFUnordGreaterThan, 100); auto replace_true_with_uint32_comparison = TransformationReplaceBooleanConstantWithConstantBinary( uses_of_true[1], 27, 29, spv::Op::OpULessThanEqual, 101); auto replace_false_with_float_comparison = TransformationReplaceBooleanConstantWithConstantBinary( uses_of_false[0], 17, 15, spv::Op::OpFOrdLessThan, 102); auto replace_false_with_sint64_comparison = TransformationReplaceBooleanConstantWithConstantBinary( uses_of_false[1], 33, 31, spv::Op::OpSLessThan, 103); ASSERT_TRUE(replace_true_with_double_comparison.IsApplicable( context.get(), transformation_context)); ApplyAndCheckFreshIds(replace_true_with_double_comparison, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(replace_true_with_uint32_comparison.IsApplicable( context.get(), transformation_context)); ApplyAndCheckFreshIds(replace_true_with_uint32_comparison, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(replace_false_with_float_comparison.IsApplicable( context.get(), transformation_context)); ApplyAndCheckFreshIds(replace_false_with_float_comparison, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(replace_false_with_sint64_comparison.IsApplicable( context.get(), transformation_context)); ApplyAndCheckFreshIds(replace_false_with_sint64_comparison, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after = R"( OpCapability Shader OpCapability Float64 OpCapability Int64 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 450 OpName %4 "main" OpName %8 "d1" OpName %10 "d2" OpName %14 "f1" OpName %16 "f2" OpName %20 "i1" OpName %22 "i2" OpName %26 "u1" OpName %28 "u2" OpName %30 "i64_1" OpName %32 "i64_2" OpName %34 "u64_1" OpName %36 "u64_2" OpName %40 "b" OpName %42 "c" OpName %44 "d" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 64 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %11 = OpConstant %6 2 %12 = OpTypeFloat 32 %13 = OpTypePointer Function %12 %15 = OpConstant %12 4 %17 = OpConstant %12 8 %18 = OpTypeInt 32 1 %60 = OpTypeInt 64 1 %61 = OpTypePointer Function %60 %19 = OpTypePointer Function %18 %21 = OpConstant %18 -100 %23 = OpConstant %18 200 %24 = OpTypeInt 32 0 %62 = OpTypeInt 64 0 %63 = OpTypePointer Function %62 %25 = OpTypePointer Function %24 %27 = OpConstant %24 300 %29 = OpConstant %24 400 %31 = OpConstant %60 -600 %33 = OpConstant %60 -500 %35 = OpConstant %62 700 %37 = OpConstant %62 800 %38 = OpTypeBool %39 = OpTypePointer Function %38 %41 = OpConstantTrue %38 %43 = OpConstantFalse %38 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %14 = OpVariable %13 Function %16 = OpVariable %13 Function %20 = OpVariable %19 Function %22 = OpVariable %19 Function %26 = OpVariable %25 Function %28 = OpVariable %25 Function %30 = OpVariable %61 Function %32 = OpVariable %61 Function %34 = OpVariable %63 Function %36 = OpVariable %63 Function %40 = OpVariable %39 Function %42 = OpVariable %39 Function %44 = OpVariable %39 Function OpStore %8 %9 OpStore %10 %11 OpStore %14 %15 OpStore %16 %17 OpStore %20 %21 OpStore %22 %23 OpStore %26 %27 OpStore %28 %29 OpStore %30 %31 OpStore %32 %33 OpStore %34 %35 OpStore %36 %37 %100 = OpFUnordGreaterThan %38 %11 %9 OpStore %40 %100 %102 = OpFOrdLessThan %38 %17 %15 OpStore %42 %102 %45 = OpLoad %38 %42 %101 = OpULessThanEqual %38 %27 %29 %46 = OpLogicalOr %38 %101 %45 OpStore %44 %46 %47 = OpLoad %38 %42 %103 = OpSLessThan %38 %33 %31 %48 = OpLogicalAnd %38 %47 %103 OpStore %42 %48 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after, context.get())); if (std::numeric_limits::has_quiet_NaN) { double quiet_nan_double = std::numeric_limits::quiet_NaN(); uint32_t words[2]; memcpy(words, &quiet_nan_double, sizeof(double)); opt::Instruction::OperandList operands = { {SPV_OPERAND_TYPE_LITERAL_INTEGER, {words[0]}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {words[1]}}}; context->module()->AddGlobalValue(MakeUnique( context.get(), spv::Op::OpConstant, 6, 200, operands)); fuzzerutil::UpdateModuleIdBound(context.get(), 200); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); // The transformation is not applicable because %200 is NaN. ASSERT_FALSE(TransformationReplaceBooleanConstantWithConstantBinary( uses_of_true[0], 11, 200, spv::Op::OpFOrdLessThan, 300) .IsApplicable(context.get(), transformation_context)); } if (std::numeric_limits::has_infinity) { double positive_infinity_double = std::numeric_limits::infinity(); uint32_t words[2]; memcpy(words, &positive_infinity_double, sizeof(double)); opt::Instruction::OperandList operands = { {SPV_OPERAND_TYPE_LITERAL_INTEGER, {words[0]}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {words[1]}}}; context->module()->AddGlobalValue(MakeUnique( context.get(), spv::Op::OpConstant, 6, 201, operands)); fuzzerutil::UpdateModuleIdBound(context.get(), 201); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); // Even though the double constant %11 is less than the infinity %201, the // transformation is restricted to only apply to finite values. ASSERT_FALSE(TransformationReplaceBooleanConstantWithConstantBinary( uses_of_true[0], 11, 201, spv::Op::OpFOrdLessThan, 300) .IsApplicable(context.get(), transformation_context)); } if (std::numeric_limits::has_infinity) { float positive_infinity_float = std::numeric_limits::infinity(); float negative_infinity_float = -1 * positive_infinity_float; uint32_t words_positive_infinity[1]; uint32_t words_negative_infinity[1]; memcpy(words_positive_infinity, &positive_infinity_float, sizeof(float)); memcpy(words_negative_infinity, &negative_infinity_float, sizeof(float)); opt::Instruction::OperandList operands_positive_infinity = { {SPV_OPERAND_TYPE_LITERAL_INTEGER, {words_positive_infinity[0]}}}; context->module()->AddGlobalValue( MakeUnique(context.get(), spv::Op::OpConstant, 12, 202, operands_positive_infinity)); fuzzerutil::UpdateModuleIdBound(context.get(), 202); opt::Instruction::OperandList operands = { {SPV_OPERAND_TYPE_LITERAL_INTEGER, {words_negative_infinity[0]}}}; context->module()->AddGlobalValue(MakeUnique( context.get(), spv::Op::OpConstant, 12, 203, operands)); fuzzerutil::UpdateModuleIdBound(context.get(), 203); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); // Even though the negative infinity at %203 is less than the positive // infinity %202, the transformation is restricted to only apply to finite // values. ASSERT_FALSE(TransformationReplaceBooleanConstantWithConstantBinary( uses_of_true[0], 203, 202, spv::Op::OpFOrdLessThan, 300) .IsApplicable(context.get(), transformation_context)); } } TEST(TransformationReplaceBooleanConstantWithConstantBinaryTest, MergeInstructions) { // The test came from the following GLSL: // // void main() { // int x = 1; // int y = 2; // if (true) { // x = 2; // } // while(false) { // y = 2; // } // } std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 450 OpName %4 "main" OpName %8 "x" OpName %10 "y" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %11 = OpConstant %6 2 %12 = OpTypeBool %13 = OpConstantTrue %12 %21 = OpConstantFalse %12 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function OpStore %8 %9 OpStore %10 %11 OpSelectionMerge %15 None OpBranchConditional %13 %14 %15 %14 = OpLabel OpStore %8 %11 OpBranch %15 %15 = OpLabel OpBranch %16 %16 = OpLabel OpLoopMerge %18 %19 None OpBranchConditional %21 %17 %18 %17 = OpLabel OpStore %10 %11 OpBranch %19 %19 = OpLabel OpBranch %16 %18 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto use_of_true_in_if = MakeIdUseDescriptor( 13, MakeInstructionDescriptor(10, spv::Op::OpBranchConditional, 0), 0); auto use_of_false_in_while = MakeIdUseDescriptor( 21, MakeInstructionDescriptor(16, spv::Op::OpBranchConditional, 0), 0); auto replacement_1 = TransformationReplaceBooleanConstantWithConstantBinary( use_of_true_in_if, 9, 11, spv::Op::OpSLessThan, 100); auto replacement_2 = TransformationReplaceBooleanConstantWithConstantBinary( use_of_false_in_while, 9, 11, spv::Op::OpSGreaterThanEqual, 101); ASSERT_TRUE( replacement_1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(replacement_1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE( replacement_2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(replacement_2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 450 OpName %4 "main" OpName %8 "x" OpName %10 "y" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %11 = OpConstant %6 2 %12 = OpTypeBool %13 = OpConstantTrue %12 %21 = OpConstantFalse %12 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function OpStore %8 %9 OpStore %10 %11 %100 = OpSLessThan %12 %9 %11 OpSelectionMerge %15 None OpBranchConditional %100 %14 %15 %14 = OpLabel OpStore %8 %11 OpBranch %15 %15 = OpLabel OpBranch %16 %16 = OpLabel %101 = OpSGreaterThanEqual %12 %9 %11 OpLoopMerge %18 %19 None OpBranchConditional %101 %17 %18 %17 = OpLabel OpStore %10 %11 OpBranch %19 %19 = OpLabel OpBranch %16 %18 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after, context.get())); } TEST(TransformationReplaceBooleanConstantWithConstantBinaryTest, OpPhi) { // Hand-written SPIR-V to check applicability of the transformation on an // OpPhi argument. std::string reference_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %10 "main" ; Types %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeInt 32 0 %5 = OpTypeBool ; Constants %6 = OpConstant %4 0 %7 = OpConstant %4 1 %8 = OpConstantTrue %5 %9 = OpConstantFalse %5 ; main function %10 = OpFunction %2 None %3 %11 = OpLabel OpSelectionMerge %13 None OpBranchConditional %8 %12 %13 %12 = OpLabel OpBranch %13 %13 = OpLabel %14 = OpPhi %5 %8 %11 %9 %12 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto instruction_descriptor = MakeInstructionDescriptor(14, spv::Op::OpPhi, 0); auto id_use_descriptor = MakeIdUseDescriptor(8, instruction_descriptor, 0); auto transformation = TransformationReplaceBooleanConstantWithConstantBinary( id_use_descriptor, 6, 7, spv::Op::OpULessThan, 15); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); std::string variant_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %10 "main" ; Types %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeInt 32 0 %5 = OpTypeBool ; Constants %6 = OpConstant %4 0 %7 = OpConstant %4 1 %8 = OpConstantTrue %5 %9 = OpConstantFalse %5 ; main function %10 = OpFunction %2 None %3 %11 = OpLabel %15 = OpULessThan %5 %6 %7 OpSelectionMerge %13 None OpBranchConditional %8 %12 %13 %12 = OpLabel OpBranch %13 %13 = OpLabel %14 = OpPhi %5 %15 %11 %9 %12 OpReturn OpFunctionEnd )"; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(IsEqual(env, variant_shader, context.get())); } TEST(TransformationReplaceBooleanConstantWithConstantBinaryTest, DoNotReplaceVariableInitializer) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpTypePointer Function %6 %9 = OpConstantTrue %6 %10 = OpTypeInt 32 1 %13 = OpConstant %10 0 %15 = OpConstant %10 1 %4 = OpFunction %2 None %3 %5 = OpLabel %50 = OpVariable %7 Function %9 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_FALSE( TransformationReplaceBooleanConstantWithConstantBinary( MakeIdUseDescriptor( 9, MakeInstructionDescriptor(50, spv::Op::OpVariable, 0), 1), 13, 15, spv::Op::OpSLessThan, 100) .IsApplicable(context.get(), transformation_context)); } } // namespace } // namespace fuzz } // namespace spvtools transformation_replace_branch_from_dead_block_with_exit_test.cpp000066400000000000000000000750601475742701700355160ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/fuzz// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_replace_branch_from_dead_block_with_exit.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationReplaceBranchFromDeadBlockWithExitTest, BasicTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantFalse %6 %12 = OpTypeInt 32 1 %13 = OpTypePointer Function %12 %15 = OpConstant %12 1 %17 = OpConstant %12 2 %4 = OpFunction %2 None %3 %5 = OpLabel %14 = OpVariable %13 Function OpSelectionMerge %9 None OpBranchConditional %7 %8 %21 %8 = OpLabel OpSelectionMerge %11 None OpBranchConditional %7 %10 %16 %10 = OpLabel OpStore %14 %15 OpBranch %20 %20 = OpLabel OpBranch %11 %16 = OpLabel OpStore %14 %17 OpBranch %11 %11 = OpLabel OpBranch %9 %21 = OpLabel OpBranch %9 %9 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactBlockIsDead(8); transformation_context.GetFactManager()->AddFactBlockIsDead(10); transformation_context.GetFactManager()->AddFactBlockIsDead(11); transformation_context.GetFactManager()->AddFactBlockIsDead(16); transformation_context.GetFactManager()->AddFactBlockIsDead(20); // Bad: 4 is not a block ASSERT_FALSE( TransformationReplaceBranchFromDeadBlockWithExit(4, spv::Op::OpKill, 0) .IsApplicable(context.get(), transformation_context)); // Bad: 200 does not exist ASSERT_FALSE( TransformationReplaceBranchFromDeadBlockWithExit(200, spv::Op::OpKill, 0) .IsApplicable(context.get(), transformation_context)); // Bad: 21 is not a dead block ASSERT_FALSE( TransformationReplaceBranchFromDeadBlockWithExit(21, spv::Op::OpKill, 0) .IsApplicable(context.get(), transformation_context)); // Bad: terminator of 8 is not OpBranch ASSERT_FALSE( TransformationReplaceBranchFromDeadBlockWithExit(8, spv::Op::OpKill, 0) .IsApplicable(context.get(), transformation_context)); // Bad: 10's successor only has 10 as a predecessor ASSERT_FALSE( TransformationReplaceBranchFromDeadBlockWithExit(10, spv::Op::OpKill, 0) .IsApplicable(context.get(), transformation_context)); #ifndef NDEBUG ASSERT_DEATH( TransformationReplaceBranchFromDeadBlockWithExit(20, spv::Op::OpSwitch, 0) .IsApplicable(context.get(), transformation_context), "Invalid early exit opcode."); #endif auto transformation1 = TransformationReplaceBranchFromDeadBlockWithExit(20, spv::Op::OpKill, 0); auto transformation2 = TransformationReplaceBranchFromDeadBlockWithExit(16, spv::Op::OpKill, 0); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); // Applying transformation 1 should disable transformation 2 ASSERT_FALSE( transformation2.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantFalse %6 %12 = OpTypeInt 32 1 %13 = OpTypePointer Function %12 %15 = OpConstant %12 1 %17 = OpConstant %12 2 %4 = OpFunction %2 None %3 %5 = OpLabel %14 = OpVariable %13 Function OpSelectionMerge %9 None OpBranchConditional %7 %8 %21 %8 = OpLabel OpSelectionMerge %11 None OpBranchConditional %7 %10 %16 %10 = OpLabel OpStore %14 %15 OpBranch %20 %20 = OpLabel OpKill %16 = OpLabel OpStore %14 %17 OpBranch %11 %11 = OpLabel OpBranch %9 %21 = OpLabel OpBranch %9 %9 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationReplaceBranchFromDeadBlockWithExitTest, VertexShaderWithLoopInContinueConstruct) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %4 "main" OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeFunction %6 %12 = OpTypePointer Function %6 %14 = OpConstant %6 0 %22 = OpConstant %6 10 %23 = OpTypeBool %26 = OpConstant %6 1 %40 = OpConstant %6 100 %48 = OpConstantFalse %23 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %50 None OpBranchConditional %48 %49 %50 %49 = OpLabel %51 = OpFunctionCall %6 %10 OpBranch %50 %50 = OpLabel OpReturn OpFunctionEnd %10 = OpFunction %6 None %7 %11 = OpLabel %13 = OpVariable %12 Function %15 = OpVariable %12 Function %33 = OpVariable %12 Function OpStore %33 %14 OpBranch %34 %34 = OpLabel OpLoopMerge %36 %37 None OpBranch %38 %38 = OpLabel %39 = OpLoad %6 %33 %41 = OpSLessThan %23 %39 %40 OpBranchConditional %41 %35 %36 %35 = OpLabel OpSelectionMerge %202 None OpBranchConditional %48 %200 %201 %200 = OpLabel OpBranch %202 %201 = OpLabel %400 = OpCopyObject %6 %14 OpBranch %202 %202 = OpLabel OpBranch %37 %37 = OpLabel OpStore %13 %14 OpStore %15 %14 OpBranch %16 %16 = OpLabel OpLoopMerge %18 %19 None OpBranch %20 %20 = OpLabel OpSelectionMerge %102 None OpBranchConditional %48 %100 %101 %100 = OpLabel OpBranch %102 %101 = OpLabel OpBranch %102 %102 = OpLabel %21 = OpLoad %6 %15 %24 = OpSLessThan %23 %21 %22 OpBranchConditional %24 %17 %18 %17 = OpLabel OpSelectionMerge %302 None OpBranchConditional %48 %300 %301 %300 = OpLabel OpBranch %302 %301 = OpLabel OpBranch %302 %302 = OpLabel %25 = OpLoad %6 %13 %27 = OpIAdd %6 %25 %26 OpStore %13 %27 OpBranch %19 %19 = OpLabel %28 = OpLoad %6 %15 %29 = OpIAdd %6 %28 %26 OpStore %15 %29 OpBranch %16 %18 = OpLabel %30 = OpLoad %6 %13 %42 = OpCopyObject %6 %30 %43 = OpLoad %6 %33 %44 = OpIAdd %6 %43 %42 OpStore %33 %44 OpBranch %34 %36 = OpLabel %45 = OpLoad %6 %33 OpReturnValue %45 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); for (auto block : {16, 17, 18, 19, 20, 34, 35, 36, 37, 38, 49, 100, 101, 102, 200, 201, 202, 300, 301, 302}) { transformation_context.GetFactManager()->AddFactBlockIsDead(block); } // Bad: OpKill not allowed in vertex shader ASSERT_FALSE( TransformationReplaceBranchFromDeadBlockWithExit(201, spv::Op::OpKill, 0) .IsApplicable(context.get(), transformation_context)); // Bad: OpReturn is not allowed in function that expects a returned value. ASSERT_FALSE(TransformationReplaceBranchFromDeadBlockWithExit( 200, spv::Op::OpReturn, 0) .IsApplicable(context.get(), transformation_context)); // Bad: Return value id does not exist ASSERT_FALSE(TransformationReplaceBranchFromDeadBlockWithExit( 201, spv::Op::OpReturnValue, 1000) .IsApplicable(context.get(), transformation_context)); // Bad: Return value id does not have a type ASSERT_FALSE(TransformationReplaceBranchFromDeadBlockWithExit( 200, spv::Op::OpReturnValue, 6) .IsApplicable(context.get(), transformation_context)); // Bad: Return value id does not have the right type ASSERT_FALSE(TransformationReplaceBranchFromDeadBlockWithExit( 201, spv::Op::OpReturnValue, 48) .IsApplicable(context.get(), transformation_context)); // Bad: Return value id is not available ASSERT_FALSE(TransformationReplaceBranchFromDeadBlockWithExit( 200, spv::Op::OpReturnValue, 400) .IsApplicable(context.get(), transformation_context)); // Bad: Early exit now allowed in continue construct ASSERT_FALSE(TransformationReplaceBranchFromDeadBlockWithExit( 101, spv::Op::OpUnreachable, 0) .IsApplicable(context.get(), transformation_context)); // Bad: Early exit now allowed in continue construct (again) ASSERT_FALSE(TransformationReplaceBranchFromDeadBlockWithExit( 300, spv::Op::OpReturnValue, 14) .IsApplicable(context.get(), transformation_context)); auto transformation1 = TransformationReplaceBranchFromDeadBlockWithExit( 200, spv::Op::OpUnreachable, 0); auto transformation2 = TransformationReplaceBranchFromDeadBlockWithExit( 201, spv::Op::OpReturnValue, 400); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); ASSERT_FALSE( transformation1.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); opt::Instruction* return_value_inst = context->get_instr_block(201)->terminator(); ASSERT_EQ(spv::Op::OpReturnValue, return_value_inst->opcode()); ASSERT_EQ(SPV_OPERAND_TYPE_ID, return_value_inst->GetInOperand(0).type); ASSERT_EQ(400, return_value_inst->GetSingleWordInOperand(0)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %4 "main" OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeFunction %6 %12 = OpTypePointer Function %6 %14 = OpConstant %6 0 %22 = OpConstant %6 10 %23 = OpTypeBool %26 = OpConstant %6 1 %40 = OpConstant %6 100 %48 = OpConstantFalse %23 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %50 None OpBranchConditional %48 %49 %50 %49 = OpLabel %51 = OpFunctionCall %6 %10 OpBranch %50 %50 = OpLabel OpReturn OpFunctionEnd %10 = OpFunction %6 None %7 %11 = OpLabel %13 = OpVariable %12 Function %15 = OpVariable %12 Function %33 = OpVariable %12 Function OpStore %33 %14 OpBranch %34 %34 = OpLabel OpLoopMerge %36 %37 None OpBranch %38 %38 = OpLabel %39 = OpLoad %6 %33 %41 = OpSLessThan %23 %39 %40 OpBranchConditional %41 %35 %36 %35 = OpLabel OpSelectionMerge %202 None OpBranchConditional %48 %200 %201 %200 = OpLabel OpBranch %202 %201 = OpLabel %400 = OpCopyObject %6 %14 OpReturnValue %400 %202 = OpLabel OpBranch %37 %37 = OpLabel OpStore %13 %14 OpStore %15 %14 OpBranch %16 %16 = OpLabel OpLoopMerge %18 %19 None OpBranch %20 %20 = OpLabel OpSelectionMerge %102 None OpBranchConditional %48 %100 %101 %100 = OpLabel OpBranch %102 %101 = OpLabel OpBranch %102 %102 = OpLabel %21 = OpLoad %6 %15 %24 = OpSLessThan %23 %21 %22 OpBranchConditional %24 %17 %18 %17 = OpLabel OpSelectionMerge %302 None OpBranchConditional %48 %300 %301 %300 = OpLabel OpBranch %302 %301 = OpLabel OpBranch %302 %302 = OpLabel %25 = OpLoad %6 %13 %27 = OpIAdd %6 %25 %26 OpStore %13 %27 OpBranch %19 %19 = OpLabel %28 = OpLoad %6 %15 %29 = OpIAdd %6 %28 %26 OpStore %15 %29 OpBranch %16 %18 = OpLabel %30 = OpLoad %6 %13 %42 = OpCopyObject %6 %30 %43 = OpLoad %6 %33 %44 = OpIAdd %6 %43 %42 OpStore %33 %44 OpBranch %34 %36 = OpLabel %45 = OpLoad %6 %33 OpReturnValue %45 OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationReplaceBranchFromDeadBlockWithExitTest, OpPhi) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantFalse %6 %12 = OpTypeInt 32 1 %13 = OpTypePointer Function %12 %15 = OpConstant %12 1 %17 = OpConstant %12 2 %4 = OpFunction %2 None %3 %5 = OpLabel %14 = OpVariable %13 Function OpSelectionMerge %9 None OpBranchConditional %7 %8 %21 %8 = OpLabel OpSelectionMerge %11 None OpBranchConditional %7 %10 %16 %10 = OpLabel OpStore %14 %15 OpBranch %20 %20 = OpLabel %48 = OpCopyObject %12 %15 OpBranch %11 %16 = OpLabel OpStore %14 %17 %49 = OpCopyObject %12 %17 OpBranch %11 %11 = OpLabel %50 = OpPhi %12 %48 %20 %49 %16 OpBranch %9 %21 = OpLabel OpBranch %9 %9 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactBlockIsDead(8); transformation_context.GetFactManager()->AddFactBlockIsDead(10); transformation_context.GetFactManager()->AddFactBlockIsDead(11); transformation_context.GetFactManager()->AddFactBlockIsDead(16); transformation_context.GetFactManager()->AddFactBlockIsDead(20); auto transformation1 = TransformationReplaceBranchFromDeadBlockWithExit(20, spv::Op::OpKill, 0); auto transformation2 = TransformationReplaceBranchFromDeadBlockWithExit(16, spv::Op::OpKill, 0); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); // Applying transformation 1 should disable transformation 2 ASSERT_FALSE( transformation2.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantFalse %6 %12 = OpTypeInt 32 1 %13 = OpTypePointer Function %12 %15 = OpConstant %12 1 %17 = OpConstant %12 2 %4 = OpFunction %2 None %3 %5 = OpLabel %14 = OpVariable %13 Function OpSelectionMerge %9 None OpBranchConditional %7 %8 %21 %8 = OpLabel OpSelectionMerge %11 None OpBranchConditional %7 %10 %16 %10 = OpLabel OpStore %14 %15 OpBranch %20 %20 = OpLabel %48 = OpCopyObject %12 %15 OpKill %16 = OpLabel OpStore %14 %17 %49 = OpCopyObject %12 %17 OpBranch %11 %11 = OpLabel %50 = OpPhi %12 %49 %16 OpBranch %9 %21 = OpLabel OpBranch %9 %9 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationReplaceBranchFromDeadBlockWithExitTest, DominatorAfterDeadBlockSuccessor) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantFalse %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %8 None OpBranchConditional %7 %9 %10 %9 = OpLabel OpBranch %11 %11 = OpLabel %12 = OpCopyObject %6 %7 OpBranch %8 %10 = OpLabel OpBranch %13 %8 = OpLabel OpReturn %13 = OpLabel OpBranch %8 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactBlockIsDead(9); transformation_context.GetFactManager()->AddFactBlockIsDead(11); ASSERT_FALSE(TransformationReplaceBranchFromDeadBlockWithExit( 11, spv::Op::OpUnreachable, 0) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationReplaceBranchFromDeadBlockWithExitTest, UnreachableSuccessor) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantFalse %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %8 None OpBranchConditional %7 %9 %10 %9 = OpLabel OpBranch %11 %11 = OpLabel %12 = OpCopyObject %6 %7 OpBranch %8 %10 = OpLabel OpReturn %8 = OpLabel OpReturn %13 = OpLabel OpBranch %8 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactBlockIsDead(9); transformation_context.GetFactManager()->AddFactBlockIsDead(11); TransformationReplaceBranchFromDeadBlockWithExit transformation( 11, spv::Op::OpUnreachable, 0); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); transformation.Apply(context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantFalse %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %8 None OpBranchConditional %7 %9 %10 %9 = OpLabel OpBranch %11 %11 = OpLabel %12 = OpCopyObject %6 %7 OpUnreachable %10 = OpLabel OpReturn %8 = OpLabel OpReturn %13 = OpLabel OpBranch %8 OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationReplaceBranchFromDeadBlockWithExitTest, DeadBlockAfterItsSuccessor) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantTrue %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %8 None OpBranchConditional %7 %9 %10 %9 = OpLabel OpBranch %11 %11 = OpLabel %12 = OpCopyObject %6 %7 OpBranch %8 %10 = OpLabel OpBranch %13 %8 = OpLabel OpReturn %13 = OpLabel OpBranch %8 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactBlockIsDead(10); transformation_context.GetFactManager()->AddFactBlockIsDead(13); TransformationReplaceBranchFromDeadBlockWithExit transformation( 13, spv::Op::OpUnreachable, 0); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); transformation.Apply(context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantTrue %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %8 None OpBranchConditional %7 %9 %10 %9 = OpLabel OpBranch %11 %11 = OpLabel %12 = OpCopyObject %6 %7 OpBranch %8 %10 = OpLabel OpBranch %13 %8 = OpLabel OpReturn %13 = OpLabel OpUnreachable OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationReplaceBranchFromDeadBlockWithExitTest, BranchToOuterMergeBlock) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantTrue %6 %15 = OpTypeInt 32 0 %14 = OpUndef %15 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %8 None OpSwitch %14 %9 1 %8 %9 = OpLabel OpSelectionMerge %10 None OpBranchConditional %7 %11 %10 %8 = OpLabel OpReturn %11 = OpLabel OpBranch %8 %10 = OpLabel OpBranch %8 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactBlockIsDead(10); TransformationReplaceBranchFromDeadBlockWithExit transformation( 10, spv::Op::OpUnreachable, 0); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); transformation.Apply(context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantTrue %6 %15 = OpTypeInt 32 0 %14 = OpUndef %15 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %8 None OpSwitch %14 %9 1 %8 %9 = OpLabel OpSelectionMerge %10 None OpBranchConditional %7 %11 %10 %8 = OpLabel OpReturn %11 = OpLabel OpBranch %8 %10 = OpLabel OpUnreachable OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_replace_constant_with_uniform_test.cpp000066400000000000000000001756551475742701700335400ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_replace_constant_with_uniform.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "source/fuzz/uniform_buffer_element_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { bool AddFactHelper( TransformationContext* transformation_context, uint32_t word, const protobufs::UniformBufferElementDescriptor& descriptor) { protobufs::FactConstantUniform constant_uniform_fact; constant_uniform_fact.add_constant_word(word); *constant_uniform_fact.mutable_uniform_buffer_element_descriptor() = descriptor; protobufs::Fact fact; *fact.mutable_constant_uniform_fact() = constant_uniform_fact; return transformation_context->GetFactManager()->MaybeAddFact(fact); } TEST(TransformationReplaceConstantWithUniformTest, BasicReplacements) { // This test came from the following GLSL: // // #version 450 // // uniform blockname { // int a; // int b; // int c; // }; // // void main() // { // int x; // x = 1; // x = x + 2; // x = 3 + x; // } std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 450 OpName %4 "main" OpName %8 "x" OpName %16 "blockname" OpMemberName %16 0 "a" OpMemberName %16 1 "b" OpMemberName %16 2 "c" OpName %18 "" OpMemberDecorate %16 0 Offset 0 OpMemberDecorate %16 1 Offset 4 OpMemberDecorate %16 2 Offset 8 OpDecorate %16 Block OpDecorate %18 DescriptorSet 0 OpDecorate %18 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %50 = OpConstant %6 0 %9 = OpConstant %6 1 %11 = OpConstant %6 2 %14 = OpConstant %6 3 %16 = OpTypeStruct %6 %6 %6 %17 = OpTypePointer Uniform %16 %51 = OpTypePointer Uniform %6 %18 = OpVariable %17 Uniform %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpStore %8 %9 %10 = OpLoad %6 %8 %12 = OpIAdd %6 %10 %11 OpStore %8 %12 %13 = OpLoad %6 %8 %15 = OpIAdd %6 %14 %13 OpStore %8 %15 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); protobufs::UniformBufferElementDescriptor blockname_a = MakeUniformBufferElementDescriptor(0, 0, {0}); protobufs::UniformBufferElementDescriptor blockname_b = MakeUniformBufferElementDescriptor(0, 0, {1}); protobufs::UniformBufferElementDescriptor blockname_c = MakeUniformBufferElementDescriptor(0, 0, {2}); ASSERT_TRUE(AddFactHelper(&transformation_context, 1, blockname_a)); ASSERT_TRUE(AddFactHelper(&transformation_context, 2, blockname_b)); ASSERT_TRUE(AddFactHelper(&transformation_context, 3, blockname_c)); // The constant ids are 9, 11 and 14, for 1, 2 and 3 respectively. protobufs::IdUseDescriptor use_of_9_in_store = MakeIdUseDescriptor( 9, MakeInstructionDescriptor(8, spv::Op::OpStore, 0), 1); protobufs::IdUseDescriptor use_of_11_in_add = MakeIdUseDescriptor( 11, MakeInstructionDescriptor(12, spv::Op::OpIAdd, 0), 1); protobufs::IdUseDescriptor use_of_14_in_add = MakeIdUseDescriptor( 14, MakeInstructionDescriptor(15, spv::Op::OpIAdd, 0), 0); // These transformations work: they match the facts. auto transformation_use_of_9_in_store = TransformationReplaceConstantWithUniform(use_of_9_in_store, blockname_a, 100, 101); ASSERT_TRUE(transformation_use_of_9_in_store.IsApplicable( context.get(), transformation_context)); auto transformation_use_of_11_in_add = TransformationReplaceConstantWithUniform(use_of_11_in_add, blockname_b, 102, 103); ASSERT_TRUE(transformation_use_of_11_in_add.IsApplicable( context.get(), transformation_context)); auto transformation_use_of_14_in_add = TransformationReplaceConstantWithUniform(use_of_14_in_add, blockname_c, 104, 105); ASSERT_TRUE(transformation_use_of_14_in_add.IsApplicable( context.get(), transformation_context)); // The transformations are not applicable if we change which uniforms are // applied to which constants. ASSERT_FALSE(TransformationReplaceConstantWithUniform(use_of_9_in_store, blockname_b, 101, 102) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationReplaceConstantWithUniform(use_of_11_in_add, blockname_c, 101, 102) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationReplaceConstantWithUniform(use_of_14_in_add, blockname_a, 101, 102) .IsApplicable(context.get(), transformation_context)); // The following transformations do not apply because the uniform descriptors // are not sensible. protobufs::UniformBufferElementDescriptor nonsense_uniform_descriptor1 = MakeUniformBufferElementDescriptor(1, 2, {0}); protobufs::UniformBufferElementDescriptor nonsense_uniform_descriptor2 = MakeUniformBufferElementDescriptor(0, 0, {5}); ASSERT_FALSE(TransformationReplaceConstantWithUniform( use_of_9_in_store, nonsense_uniform_descriptor1, 101, 102) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationReplaceConstantWithUniform( use_of_9_in_store, nonsense_uniform_descriptor2, 101, 102) .IsApplicable(context.get(), transformation_context)); // The following transformation does not apply because the id descriptor is // not sensible. protobufs::IdUseDescriptor nonsense_id_use_descriptor = MakeIdUseDescriptor( 9, MakeInstructionDescriptor(15, spv::Op::OpIAdd, 0), 0); ASSERT_FALSE(TransformationReplaceConstantWithUniform( nonsense_id_use_descriptor, blockname_a, 101, 102) .IsApplicable(context.get(), transformation_context)); // The following transformations do not apply because the ids are not fresh. ASSERT_FALSE(TransformationReplaceConstantWithUniform(use_of_11_in_add, blockname_b, 15, 103) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationReplaceConstantWithUniform(use_of_11_in_add, blockname_b, 102, 15) .IsApplicable(context.get(), transformation_context)); // Apply the use of 9 in a store. ApplyAndCheckFreshIds(transformation_use_of_9_in_store, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_replacing_use_of_9_in_store = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 450 OpName %4 "main" OpName %8 "x" OpName %16 "blockname" OpMemberName %16 0 "a" OpMemberName %16 1 "b" OpMemberName %16 2 "c" OpName %18 "" OpMemberDecorate %16 0 Offset 0 OpMemberDecorate %16 1 Offset 4 OpMemberDecorate %16 2 Offset 8 OpDecorate %16 Block OpDecorate %18 DescriptorSet 0 OpDecorate %18 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %50 = OpConstant %6 0 %9 = OpConstant %6 1 %11 = OpConstant %6 2 %14 = OpConstant %6 3 %16 = OpTypeStruct %6 %6 %6 %17 = OpTypePointer Uniform %16 %51 = OpTypePointer Uniform %6 %18 = OpVariable %17 Uniform %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %100 = OpAccessChain %51 %18 %50 %101 = OpLoad %6 %100 OpStore %8 %101 %10 = OpLoad %6 %8 %12 = OpIAdd %6 %10 %11 OpStore %8 %12 %13 = OpLoad %6 %8 %15 = OpIAdd %6 %14 %13 OpStore %8 %15 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_replacing_use_of_9_in_store, context.get())); ASSERT_TRUE(transformation_use_of_11_in_add.IsApplicable( context.get(), transformation_context)); // Apply the use of 11 in an add. ApplyAndCheckFreshIds(transformation_use_of_11_in_add, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_replacing_use_of_11_in_add = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 450 OpName %4 "main" OpName %8 "x" OpName %16 "blockname" OpMemberName %16 0 "a" OpMemberName %16 1 "b" OpMemberName %16 2 "c" OpName %18 "" OpMemberDecorate %16 0 Offset 0 OpMemberDecorate %16 1 Offset 4 OpMemberDecorate %16 2 Offset 8 OpDecorate %16 Block OpDecorate %18 DescriptorSet 0 OpDecorate %18 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %50 = OpConstant %6 0 %9 = OpConstant %6 1 %11 = OpConstant %6 2 %14 = OpConstant %6 3 %16 = OpTypeStruct %6 %6 %6 %17 = OpTypePointer Uniform %16 %51 = OpTypePointer Uniform %6 %18 = OpVariable %17 Uniform %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %100 = OpAccessChain %51 %18 %50 %101 = OpLoad %6 %100 OpStore %8 %101 %10 = OpLoad %6 %8 %102 = OpAccessChain %51 %18 %9 %103 = OpLoad %6 %102 %12 = OpIAdd %6 %10 %103 OpStore %8 %12 %13 = OpLoad %6 %8 %15 = OpIAdd %6 %14 %13 OpStore %8 %15 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_replacing_use_of_11_in_add, context.get())); ASSERT_TRUE(transformation_use_of_14_in_add.IsApplicable( context.get(), transformation_context)); // Apply the use of 15 in an add. ApplyAndCheckFreshIds(transformation_use_of_14_in_add, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_replacing_use_of_14_in_add = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 450 OpName %4 "main" OpName %8 "x" OpName %16 "blockname" OpMemberName %16 0 "a" OpMemberName %16 1 "b" OpMemberName %16 2 "c" OpName %18 "" OpMemberDecorate %16 0 Offset 0 OpMemberDecorate %16 1 Offset 4 OpMemberDecorate %16 2 Offset 8 OpDecorate %16 Block OpDecorate %18 DescriptorSet 0 OpDecorate %18 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %50 = OpConstant %6 0 %9 = OpConstant %6 1 %11 = OpConstant %6 2 %14 = OpConstant %6 3 %16 = OpTypeStruct %6 %6 %6 %17 = OpTypePointer Uniform %16 %51 = OpTypePointer Uniform %6 %18 = OpVariable %17 Uniform %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %100 = OpAccessChain %51 %18 %50 %101 = OpLoad %6 %100 OpStore %8 %101 %10 = OpLoad %6 %8 %102 = OpAccessChain %51 %18 %9 %103 = OpLoad %6 %102 %12 = OpIAdd %6 %10 %103 OpStore %8 %12 %13 = OpLoad %6 %8 %104 = OpAccessChain %51 %18 %11 %105 = OpLoad %6 %104 %15 = OpIAdd %6 %105 %13 OpStore %8 %15 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_replacing_use_of_14_in_add, context.get())); } TEST(TransformationReplaceConstantWithUniformTest, NestedStruct) { // This test came from the following GLSL: // // #version 450 // // struct U { // int x; // == 4 // }; // // struct T { // int x; // == 3 // U y; // }; // // struct S { // T x; // int y; // == 2 // }; // // uniform blockname { // int x; // == 1 // S y; // }; // // void foo(int a) { } // // void main() // { // int x; // x = 1; // x = x + 2; // x = 3 + x; // foo(4); // } std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 450 OpName %4 "main" OpName %10 "foo(i1;" OpName %9 "a" OpName %12 "x" OpName %21 "param" OpName %23 "U" OpMemberName %23 0 "x" OpName %24 "T" OpMemberName %24 0 "x" OpMemberName %24 1 "y" OpName %25 "S" OpMemberName %25 0 "x" OpMemberName %25 1 "y" OpName %26 "blockname" OpMemberName %26 0 "x" OpMemberName %26 1 "y" OpName %28 "" OpMemberDecorate %23 0 Offset 0 OpMemberDecorate %24 0 Offset 0 OpMemberDecorate %24 1 Offset 16 OpMemberDecorate %25 0 Offset 0 OpMemberDecorate %25 1 Offset 32 OpMemberDecorate %26 0 Offset 0 OpMemberDecorate %26 1 Offset 16 OpDecorate %26 Block OpDecorate %28 DescriptorSet 0 OpDecorate %28 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %2 %7 %50 = OpConstant %6 0 %13 = OpConstant %6 1 %15 = OpConstant %6 2 %17 = OpConstant %6 3 %20 = OpConstant %6 4 %23 = OpTypeStruct %6 %24 = OpTypeStruct %6 %23 %25 = OpTypeStruct %24 %6 %26 = OpTypeStruct %6 %25 %27 = OpTypePointer Uniform %26 %51 = OpTypePointer Uniform %6 %28 = OpVariable %27 Uniform %4 = OpFunction %2 None %3 %5 = OpLabel %12 = OpVariable %7 Function %21 = OpVariable %7 Function OpStore %12 %13 %14 = OpLoad %6 %12 %16 = OpIAdd %6 %14 %15 OpStore %12 %16 %18 = OpLoad %6 %12 %19 = OpIAdd %6 %17 %18 OpStore %12 %19 OpStore %21 %20 %22 = OpFunctionCall %2 %10 %21 OpReturn OpFunctionEnd %10 = OpFunction %2 None %8 %9 = OpFunctionParameter %7 %11 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); protobufs::UniformBufferElementDescriptor blockname_1 = MakeUniformBufferElementDescriptor(0, 0, {0}); protobufs::UniformBufferElementDescriptor blockname_2 = MakeUniformBufferElementDescriptor(0, 0, {1, 1}); protobufs::UniformBufferElementDescriptor blockname_3 = MakeUniformBufferElementDescriptor(0, 0, {1, 0, 0}); protobufs::UniformBufferElementDescriptor blockname_4 = MakeUniformBufferElementDescriptor(0, 0, {1, 0, 1, 0}); ASSERT_TRUE(AddFactHelper(&transformation_context, 1, blockname_1)); ASSERT_TRUE(AddFactHelper(&transformation_context, 2, blockname_2)); ASSERT_TRUE(AddFactHelper(&transformation_context, 3, blockname_3)); ASSERT_TRUE(AddFactHelper(&transformation_context, 4, blockname_4)); // The constant ids are 13, 15, 17 and 20, for 1, 2, 3 and 4 respectively. protobufs::IdUseDescriptor use_of_13_in_store = MakeIdUseDescriptor( 13, MakeInstructionDescriptor(21, spv::Op::OpStore, 0), 1); protobufs::IdUseDescriptor use_of_15_in_add = MakeIdUseDescriptor( 15, MakeInstructionDescriptor(16, spv::Op::OpIAdd, 0), 1); protobufs::IdUseDescriptor use_of_17_in_add = MakeIdUseDescriptor( 17, MakeInstructionDescriptor(19, spv::Op::OpIAdd, 0), 0); protobufs::IdUseDescriptor use_of_20_in_store = MakeIdUseDescriptor( 20, MakeInstructionDescriptor(19, spv::Op::OpStore, 1), 1); // These transformations work: they match the facts. auto transformation_use_of_13_in_store = TransformationReplaceConstantWithUniform(use_of_13_in_store, blockname_1, 100, 101); ASSERT_TRUE(transformation_use_of_13_in_store.IsApplicable( context.get(), transformation_context)); auto transformation_use_of_15_in_add = TransformationReplaceConstantWithUniform(use_of_15_in_add, blockname_2, 102, 103); ASSERT_TRUE(transformation_use_of_15_in_add.IsApplicable( context.get(), transformation_context)); auto transformation_use_of_17_in_add = TransformationReplaceConstantWithUniform(use_of_17_in_add, blockname_3, 104, 105); ASSERT_TRUE(transformation_use_of_17_in_add.IsApplicable( context.get(), transformation_context)); auto transformation_use_of_20_in_store = TransformationReplaceConstantWithUniform(use_of_20_in_store, blockname_4, 106, 107); ASSERT_TRUE(transformation_use_of_20_in_store.IsApplicable( context.get(), transformation_context)); ASSERT_TRUE(transformation_use_of_13_in_store.IsApplicable( context.get(), transformation_context)); ASSERT_TRUE(transformation_use_of_15_in_add.IsApplicable( context.get(), transformation_context)); ASSERT_TRUE(transformation_use_of_17_in_add.IsApplicable( context.get(), transformation_context)); ASSERT_TRUE(transformation_use_of_20_in_store.IsApplicable( context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_use_of_13_in_store, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_FALSE(transformation_use_of_13_in_store.IsApplicable( context.get(), transformation_context)); ASSERT_TRUE(transformation_use_of_15_in_add.IsApplicable( context.get(), transformation_context)); ASSERT_TRUE(transformation_use_of_17_in_add.IsApplicable( context.get(), transformation_context)); ASSERT_TRUE(transformation_use_of_20_in_store.IsApplicable( context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_use_of_15_in_add, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_FALSE(transformation_use_of_13_in_store.IsApplicable( context.get(), transformation_context)); ASSERT_FALSE(transformation_use_of_15_in_add.IsApplicable( context.get(), transformation_context)); ASSERT_TRUE(transformation_use_of_17_in_add.IsApplicable( context.get(), transformation_context)); ASSERT_TRUE(transformation_use_of_20_in_store.IsApplicable( context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_use_of_17_in_add, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_FALSE(transformation_use_of_13_in_store.IsApplicable( context.get(), transformation_context)); ASSERT_FALSE(transformation_use_of_15_in_add.IsApplicable( context.get(), transformation_context)); ASSERT_FALSE(transformation_use_of_17_in_add.IsApplicable( context.get(), transformation_context)); ASSERT_TRUE(transformation_use_of_20_in_store.IsApplicable( context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_use_of_20_in_store, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_FALSE(transformation_use_of_13_in_store.IsApplicable( context.get(), transformation_context)); ASSERT_FALSE(transformation_use_of_15_in_add.IsApplicable( context.get(), transformation_context)); ASSERT_FALSE(transformation_use_of_17_in_add.IsApplicable( context.get(), transformation_context)); ASSERT_FALSE(transformation_use_of_20_in_store.IsApplicable( context.get(), transformation_context)); std::string after = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 450 OpName %4 "main" OpName %10 "foo(i1;" OpName %9 "a" OpName %12 "x" OpName %21 "param" OpName %23 "U" OpMemberName %23 0 "x" OpName %24 "T" OpMemberName %24 0 "x" OpMemberName %24 1 "y" OpName %25 "S" OpMemberName %25 0 "x" OpMemberName %25 1 "y" OpName %26 "blockname" OpMemberName %26 0 "x" OpMemberName %26 1 "y" OpName %28 "" OpMemberDecorate %23 0 Offset 0 OpMemberDecorate %24 0 Offset 0 OpMemberDecorate %24 1 Offset 16 OpMemberDecorate %25 0 Offset 0 OpMemberDecorate %25 1 Offset 32 OpMemberDecorate %26 0 Offset 0 OpMemberDecorate %26 1 Offset 16 OpDecorate %26 Block OpDecorate %28 DescriptorSet 0 OpDecorate %28 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %2 %7 %50 = OpConstant %6 0 %13 = OpConstant %6 1 %15 = OpConstant %6 2 %17 = OpConstant %6 3 %20 = OpConstant %6 4 %23 = OpTypeStruct %6 %24 = OpTypeStruct %6 %23 %25 = OpTypeStruct %24 %6 %26 = OpTypeStruct %6 %25 %27 = OpTypePointer Uniform %26 %51 = OpTypePointer Uniform %6 %28 = OpVariable %27 Uniform %4 = OpFunction %2 None %3 %5 = OpLabel %12 = OpVariable %7 Function %21 = OpVariable %7 Function %100 = OpAccessChain %51 %28 %50 %101 = OpLoad %6 %100 OpStore %12 %101 %14 = OpLoad %6 %12 %102 = OpAccessChain %51 %28 %13 %13 %103 = OpLoad %6 %102 %16 = OpIAdd %6 %14 %103 OpStore %12 %16 %18 = OpLoad %6 %12 %104 = OpAccessChain %51 %28 %13 %50 %50 %105 = OpLoad %6 %104 %19 = OpIAdd %6 %105 %18 OpStore %12 %19 %106 = OpAccessChain %51 %28 %13 %50 %13 %50 %107 = OpLoad %6 %106 OpStore %21 %107 %22 = OpFunctionCall %2 %10 %21 OpReturn OpFunctionEnd %10 = OpFunction %2 None %8 %9 = OpFunctionParameter %7 %11 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after, context.get())); } TEST(TransformationReplaceConstantWithUniformTest, NoUniformIntPointerPresent) { // This test came from the following GLSL: // // #version 450 // // uniform blockname { // int x; // == 0 // }; // // void main() // { // int a; // a = 0; // } std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 450 OpName %4 "main" OpName %8 "a" OpName %10 "blockname" OpMemberName %10 0 "x" OpName %12 "" OpMemberDecorate %10 0 Offset 0 OpDecorate %10 Block OpDecorate %12 DescriptorSet 0 OpDecorate %12 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %10 = OpTypeStruct %6 %11 = OpTypePointer Uniform %10 %12 = OpVariable %11 Uniform %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpStore %8 %9 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); protobufs::UniformBufferElementDescriptor blockname_0 = MakeUniformBufferElementDescriptor(0, 0, {0}); ASSERT_TRUE(AddFactHelper(&transformation_context, 0, blockname_0)); // The constant id is 9 for 0. protobufs::IdUseDescriptor use_of_9_in_store = MakeIdUseDescriptor( 9, MakeInstructionDescriptor(8, spv::Op::OpStore, 0), 1); // This transformation is not available because no uniform pointer to integer // type is present: ASSERT_FALSE(TransformationReplaceConstantWithUniform(use_of_9_in_store, blockname_0, 100, 101) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationReplaceConstantWithUniformTest, NoConstantPresentForIndex) { // This test came from the following GLSL: // // #version 450 // // uniform blockname { // int x; // == 0 // int y; // == 9 // }; // // void main() // { // int a; // a = 9; // } std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 450 OpName %4 "main" OpName %8 "a" OpName %10 "blockname" OpMemberName %10 0 "x" OpMemberName %10 1 "y" OpName %12 "" OpMemberDecorate %10 0 Offset 0 OpMemberDecorate %10 1 Offset 4 OpDecorate %10 Block OpDecorate %12 DescriptorSet 0 OpDecorate %12 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 9 %10 = OpTypeStruct %6 %6 %11 = OpTypePointer Uniform %10 %50 = OpTypePointer Uniform %6 %12 = OpVariable %11 Uniform %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpStore %8 %9 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); protobufs::UniformBufferElementDescriptor blockname_0 = MakeUniformBufferElementDescriptor(0, 0, {0}); protobufs::UniformBufferElementDescriptor blockname_9 = MakeUniformBufferElementDescriptor(0, 0, {1}); ASSERT_TRUE(AddFactHelper(&transformation_context, 9, blockname_9)); // The constant id is 9 for 9. protobufs::IdUseDescriptor use_of_9_in_store = MakeIdUseDescriptor( 9, MakeInstructionDescriptor(8, spv::Op::OpStore, 0), 1); // This transformation is not available because no constant is present for the // index 1 required to index into the uniform buffer: ASSERT_FALSE(TransformationReplaceConstantWithUniform(use_of_9_in_store, blockname_9, 100, 101) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationReplaceConstantWithUniformTest, NoIntTypePresentToEnableIndexing) { // This test came from the following GLSL: // // #version 450 // // uniform blockname { // float f; // == 9 // }; // // void main() // { // float a; // a = 3.0; // } std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 450 OpName %4 "main" OpName %8 "a" OpName %10 "blockname" OpMemberName %10 0 "f" OpName %12 "" OpMemberDecorate %10 0 Offset 0 OpDecorate %10 Block OpDecorate %12 DescriptorSet 0 OpDecorate %12 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %9 = OpConstant %6 3 %10 = OpTypeStruct %6 %11 = OpTypePointer Uniform %10 %12 = OpVariable %11 Uniform %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpStore %8 %9 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); protobufs::UniformBufferElementDescriptor blockname_3 = MakeUniformBufferElementDescriptor(0, 0, {0}); uint32_t float_data[1]; float temp = 3.0; memcpy(&float_data[0], &temp, sizeof(float)); ASSERT_TRUE( AddFactHelper(&transformation_context, float_data[0], blockname_3)); // The constant id is 9 for 3.0. protobufs::IdUseDescriptor use_of_9_in_store = MakeIdUseDescriptor( 9, MakeInstructionDescriptor(8, spv::Op::OpStore, 0), 1); // This transformation is not available because no integer type is present to // allow a constant index to be expressed: ASSERT_FALSE(TransformationReplaceConstantWithUniform(use_of_9_in_store, blockname_3, 100, 101) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationReplaceConstantWithUniformTest, UniformFactsDoNotMatchConstants) { // This test came from the following GLSL: // // #version 450 // // uniform blockname { // int x; // == 9 // int y; // == 10 // }; // // void main() // { // int a; // int b; // a = 9; // b = 10; // } std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 450 OpName %4 "main" OpName %8 "a" OpName %10 "b" OpName %12 "blockname" OpMemberName %12 0 "x" OpMemberName %12 1 "y" OpName %14 "" OpMemberDecorate %12 0 Offset 0 OpMemberDecorate %12 1 Offset 4 OpDecorate %12 Block OpDecorate %14 DescriptorSet 0 OpDecorate %14 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 9 %11 = OpConstant %6 10 %50 = OpConstant %6 0 %51 = OpConstant %6 1 %12 = OpTypeStruct %6 %6 %13 = OpTypePointer Uniform %12 %52 = OpTypePointer Uniform %6 %14 = OpVariable %13 Uniform %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function OpStore %8 %9 OpStore %10 %11 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); protobufs::UniformBufferElementDescriptor blockname_9 = MakeUniformBufferElementDescriptor(0, 0, {0}); protobufs::UniformBufferElementDescriptor blockname_10 = MakeUniformBufferElementDescriptor(0, 0, {1}); ASSERT_TRUE(AddFactHelper(&transformation_context, 9, blockname_9)); ASSERT_TRUE(AddFactHelper(&transformation_context, 10, blockname_10)); // The constant ids for 9 and 10 are 9 and 11 respectively protobufs::IdUseDescriptor use_of_9_in_store = MakeIdUseDescriptor( 9, MakeInstructionDescriptor(10, spv::Op::OpStore, 0), 1); protobufs::IdUseDescriptor use_of_11_in_store = MakeIdUseDescriptor( 11, MakeInstructionDescriptor(10, spv::Op::OpStore, 1), 1); // These are right: ASSERT_TRUE(TransformationReplaceConstantWithUniform(use_of_9_in_store, blockname_9, 100, 101) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationReplaceConstantWithUniform(use_of_11_in_store, blockname_10, 102, 103) .IsApplicable(context.get(), transformation_context)); // These are wrong because the constants do not match the facts about // uniforms. ASSERT_FALSE(TransformationReplaceConstantWithUniform(use_of_11_in_store, blockname_9, 100, 101) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationReplaceConstantWithUniform(use_of_9_in_store, blockname_10, 102, 103) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationReplaceConstantWithUniformTest, ComplexReplacements) { // The following GLSL was the basis for this test: // #version 450 // // struct T { // float a[5]; // [1.0, 1.5, 1.75, 1.875, 1.9375] // ivec4 b; // (1, 2, 3, 4) // vec3 c; // (2.0, 2.5, 2.75) // uint d; // 42u // bool e; // Not used in test // }; // // uniform block { // T f; // int g; // 22 // uvec2 h; // (100u, 200u) // }; // // void main() // { // T myT; // // myT.a[0] = 1.9375; // myT.a[1] = 1.875; // myT.a[2] = 1.75; // myT.a[3] = 1.5; // myT.a[4] = 1.0; // // myT.b.x = 4; // myT.b.y = 3; // myT.b.z = 2; // myT.b.w = 1; // // myT.b.r = 22; // // myT.c[0] = 2.75; // myT.c[0] = 2.5; // myT.c[0] = 2.0; // // myT.d = 42u; // myT.d = 100u; // myT.d = 200u; // // myT.e = true; // No attempt to replace 'true' by a uniform value // // } std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 450 OpName %4 "main" OpName %14 "T" OpMemberName %14 0 "a" OpMemberName %14 1 "b" OpMemberName %14 2 "c" OpMemberName %14 3 "d" OpMemberName %14 4 "e" OpName %16 "myT" OpName %61 "T" OpMemberName %61 0 "a" OpMemberName %61 1 "b" OpMemberName %61 2 "c" OpMemberName %61 3 "d" OpMemberName %61 4 "e" OpName %63 "block" OpMemberName %63 0 "f" OpMemberName %63 1 "g" OpMemberName %63 2 "h" OpName %65 "" OpDecorate %60 ArrayStride 16 OpMemberDecorate %61 0 Offset 0 OpMemberDecorate %61 1 Offset 80 OpMemberDecorate %61 2 Offset 96 OpMemberDecorate %61 3 Offset 108 OpMemberDecorate %61 4 Offset 112 OpMemberDecorate %63 0 Offset 0 OpMemberDecorate %63 1 Offset 128 OpMemberDecorate %63 2 Offset 136 OpDecorate %63 Block OpDecorate %65 DescriptorSet 0 OpDecorate %65 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeInt 32 0 %8 = OpConstant %7 5 %9 = OpTypeArray %6 %8 %10 = OpTypeInt 32 1 %11 = OpTypeVector %10 4 %12 = OpTypeVector %6 3 %13 = OpTypeBool %14 = OpTypeStruct %9 %11 %12 %7 %13 %15 = OpTypePointer Function %14 %17 = OpConstant %10 0 %18 = OpConstant %6 1.9375 %19 = OpTypePointer Function %6 %21 = OpConstant %10 1 %22 = OpConstant %6 1.875 %24 = OpConstant %10 2 %25 = OpConstant %6 1.75 %27 = OpConstant %10 3 %28 = OpConstant %6 1.5 %30 = OpConstant %10 4 %31 = OpConstant %6 1 %33 = OpConstant %7 0 %34 = OpTypePointer Function %10 %36 = OpConstant %7 1 %38 = OpConstant %7 2 %40 = OpConstant %7 3 %42 = OpConstant %10 22 %44 = OpConstant %6 2.75 %46 = OpConstant %6 2.5 %48 = OpConstant %6 2 %50 = OpConstant %7 42 %51 = OpTypePointer Function %7 %53 = OpConstant %7 100 %55 = OpConstant %7 200 %57 = OpConstantTrue %13 %58 = OpTypePointer Function %13 %60 = OpTypeArray %6 %8 %61 = OpTypeStruct %60 %11 %12 %7 %7 %62 = OpTypeVector %7 2 %63 = OpTypeStruct %61 %10 %62 %64 = OpTypePointer Uniform %63 %100 = OpTypePointer Uniform %10 %101 = OpTypePointer Uniform %7 %102 = OpTypePointer Uniform %6 %103 = OpTypePointer Uniform %13 %65 = OpVariable %64 Uniform %4 = OpFunction %2 None %3 %5 = OpLabel %16 = OpVariable %15 Function %20 = OpAccessChain %19 %16 %17 %17 OpStore %20 %18 %23 = OpAccessChain %19 %16 %17 %21 OpStore %23 %22 %26 = OpAccessChain %19 %16 %17 %24 OpStore %26 %25 %29 = OpAccessChain %19 %16 %17 %27 OpStore %29 %28 %32 = OpAccessChain %19 %16 %17 %30 OpStore %32 %31 %35 = OpAccessChain %34 %16 %21 %33 OpStore %35 %30 %37 = OpAccessChain %34 %16 %21 %36 OpStore %37 %27 %39 = OpAccessChain %34 %16 %21 %38 OpStore %39 %24 %41 = OpAccessChain %34 %16 %21 %40 OpStore %41 %21 %43 = OpAccessChain %34 %16 %21 %33 OpStore %43 %42 %45 = OpAccessChain %19 %16 %24 %33 OpStore %45 %44 %47 = OpAccessChain %19 %16 %24 %33 OpStore %47 %46 %49 = OpAccessChain %19 %16 %24 %33 OpStore %49 %48 %52 = OpAccessChain %51 %16 %27 OpStore %52 %50 %54 = OpAccessChain %51 %16 %27 OpStore %54 %53 %56 = OpAccessChain %51 %16 %27 OpStore %56 %55 %59 = OpAccessChain %58 %16 %30 OpStore %59 %57 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); const float float_array_values[5] = {1.0, 1.5, 1.75, 1.875, 1.9375}; uint32_t float_array_data[5]; memcpy(&float_array_data, &float_array_values, sizeof(float_array_values)); const float float_vector_values[3] = {2.0, 2.5, 2.75}; uint32_t float_vector_data[3]; memcpy(&float_vector_data, &float_vector_values, sizeof(float_vector_values)); protobufs::UniformBufferElementDescriptor uniform_f_a_0 = MakeUniformBufferElementDescriptor(0, 0, {0, 0, 0}); protobufs::UniformBufferElementDescriptor uniform_f_a_1 = MakeUniformBufferElementDescriptor(0, 0, {0, 0, 1}); protobufs::UniformBufferElementDescriptor uniform_f_a_2 = MakeUniformBufferElementDescriptor(0, 0, {0, 0, 2}); protobufs::UniformBufferElementDescriptor uniform_f_a_3 = MakeUniformBufferElementDescriptor(0, 0, {0, 0, 3}); protobufs::UniformBufferElementDescriptor uniform_f_a_4 = MakeUniformBufferElementDescriptor(0, 0, {0, 0, 4}); protobufs::UniformBufferElementDescriptor uniform_f_b_x = MakeUniformBufferElementDescriptor(0, 0, {0, 1, 0}); protobufs::UniformBufferElementDescriptor uniform_f_b_y = MakeUniformBufferElementDescriptor(0, 0, {0, 1, 1}); protobufs::UniformBufferElementDescriptor uniform_f_b_z = MakeUniformBufferElementDescriptor(0, 0, {0, 1, 2}); protobufs::UniformBufferElementDescriptor uniform_f_b_w = MakeUniformBufferElementDescriptor(0, 0, {0, 1, 3}); protobufs::UniformBufferElementDescriptor uniform_f_c_x = MakeUniformBufferElementDescriptor(0, 0, {0, 2, 0}); protobufs::UniformBufferElementDescriptor uniform_f_c_y = MakeUniformBufferElementDescriptor(0, 0, {0, 2, 1}); protobufs::UniformBufferElementDescriptor uniform_f_c_z = MakeUniformBufferElementDescriptor(0, 0, {0, 2, 2}); protobufs::UniformBufferElementDescriptor uniform_f_d = MakeUniformBufferElementDescriptor(0, 0, {0, 3}); protobufs::UniformBufferElementDescriptor uniform_g = MakeUniformBufferElementDescriptor(0, 0, {1}); protobufs::UniformBufferElementDescriptor uniform_h_x = MakeUniformBufferElementDescriptor(0, 0, {2, 0}); protobufs::UniformBufferElementDescriptor uniform_h_y = MakeUniformBufferElementDescriptor(0, 0, {2, 1}); ASSERT_TRUE(AddFactHelper(&transformation_context, float_array_data[0], uniform_f_a_0)); ASSERT_TRUE(AddFactHelper(&transformation_context, float_array_data[1], uniform_f_a_1)); ASSERT_TRUE(AddFactHelper(&transformation_context, float_array_data[2], uniform_f_a_2)); ASSERT_TRUE(AddFactHelper(&transformation_context, float_array_data[3], uniform_f_a_3)); ASSERT_TRUE(AddFactHelper(&transformation_context, float_array_data[4], uniform_f_a_4)); ASSERT_TRUE(AddFactHelper(&transformation_context, 1, uniform_f_b_x)); ASSERT_TRUE(AddFactHelper(&transformation_context, 2, uniform_f_b_y)); ASSERT_TRUE(AddFactHelper(&transformation_context, 3, uniform_f_b_z)); ASSERT_TRUE(AddFactHelper(&transformation_context, 4, uniform_f_b_w)); ASSERT_TRUE(AddFactHelper(&transformation_context, float_vector_data[0], uniform_f_c_x)); ASSERT_TRUE(AddFactHelper(&transformation_context, float_vector_data[1], uniform_f_c_y)); ASSERT_TRUE(AddFactHelper(&transformation_context, float_vector_data[2], uniform_f_c_z)); ASSERT_TRUE(AddFactHelper(&transformation_context, 42, uniform_f_d)); ASSERT_TRUE(AddFactHelper(&transformation_context, 22, uniform_g)); ASSERT_TRUE(AddFactHelper(&transformation_context, 100, uniform_h_x)); ASSERT_TRUE(AddFactHelper(&transformation_context, 200, uniform_h_y)); std::vector transformations; transformations.emplace_back(TransformationReplaceConstantWithUniform( MakeIdUseDescriptor( 18, MakeInstructionDescriptor(20, spv::Op::OpStore, 0), 1), uniform_f_a_4, 200, 201)); transformations.emplace_back(TransformationReplaceConstantWithUniform( MakeIdUseDescriptor( 22, MakeInstructionDescriptor(23, spv::Op::OpStore, 0), 1), uniform_f_a_3, 202, 203)); transformations.emplace_back(TransformationReplaceConstantWithUniform( MakeIdUseDescriptor( 25, MakeInstructionDescriptor(26, spv::Op::OpStore, 0), 1), uniform_f_a_2, 204, 205)); transformations.emplace_back(TransformationReplaceConstantWithUniform( MakeIdUseDescriptor( 28, MakeInstructionDescriptor(29, spv::Op::OpStore, 0), 1), uniform_f_a_1, 206, 207)); transformations.emplace_back(TransformationReplaceConstantWithUniform( MakeIdUseDescriptor( 31, MakeInstructionDescriptor(32, spv::Op::OpStore, 0), 1), uniform_f_a_0, 208, 209)); transformations.emplace_back(TransformationReplaceConstantWithUniform( MakeIdUseDescriptor( 30, MakeInstructionDescriptor(35, spv::Op::OpStore, 0), 1), uniform_f_b_w, 210, 211)); transformations.emplace_back(TransformationReplaceConstantWithUniform( MakeIdUseDescriptor( 27, MakeInstructionDescriptor(37, spv::Op::OpStore, 0), 1), uniform_f_b_z, 212, 213)); transformations.emplace_back(TransformationReplaceConstantWithUniform( MakeIdUseDescriptor( 24, MakeInstructionDescriptor(39, spv::Op::OpStore, 0), 1), uniform_f_b_y, 214, 215)); transformations.emplace_back(TransformationReplaceConstantWithUniform( MakeIdUseDescriptor( 21, MakeInstructionDescriptor(41, spv::Op::OpStore, 0), 1), uniform_f_b_x, 216, 217)); transformations.emplace_back(TransformationReplaceConstantWithUniform( MakeIdUseDescriptor( 44, MakeInstructionDescriptor(45, spv::Op::OpStore, 0), 1), uniform_f_c_z, 220, 221)); transformations.emplace_back(TransformationReplaceConstantWithUniform( MakeIdUseDescriptor( 46, MakeInstructionDescriptor(47, spv::Op::OpStore, 0), 1), uniform_f_c_y, 222, 223)); transformations.emplace_back(TransformationReplaceConstantWithUniform( MakeIdUseDescriptor( 48, MakeInstructionDescriptor(49, spv::Op::OpStore, 0), 1), uniform_f_c_x, 224, 225)); transformations.emplace_back(TransformationReplaceConstantWithUniform( MakeIdUseDescriptor( 50, MakeInstructionDescriptor(52, spv::Op::OpStore, 0), 1), uniform_f_d, 226, 227)); transformations.emplace_back(TransformationReplaceConstantWithUniform( MakeIdUseDescriptor( 53, MakeInstructionDescriptor(54, spv::Op::OpStore, 0), 1), uniform_h_x, 228, 229)); transformations.emplace_back(TransformationReplaceConstantWithUniform( MakeIdUseDescriptor( 55, MakeInstructionDescriptor(56, spv::Op::OpStore, 0), 1), uniform_h_y, 230, 231)); transformations.emplace_back(TransformationReplaceConstantWithUniform( MakeIdUseDescriptor( 42, MakeInstructionDescriptor(43, spv::Op::OpStore, 0), 1), uniform_g, 218, 219)); for (auto& transformation : transformations) { ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } std::string after = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 450 OpName %4 "main" OpName %14 "T" OpMemberName %14 0 "a" OpMemberName %14 1 "b" OpMemberName %14 2 "c" OpMemberName %14 3 "d" OpMemberName %14 4 "e" OpName %16 "myT" OpName %61 "T" OpMemberName %61 0 "a" OpMemberName %61 1 "b" OpMemberName %61 2 "c" OpMemberName %61 3 "d" OpMemberName %61 4 "e" OpName %63 "block" OpMemberName %63 0 "f" OpMemberName %63 1 "g" OpMemberName %63 2 "h" OpName %65 "" OpDecorate %60 ArrayStride 16 OpMemberDecorate %61 0 Offset 0 OpMemberDecorate %61 1 Offset 80 OpMemberDecorate %61 2 Offset 96 OpMemberDecorate %61 3 Offset 108 OpMemberDecorate %61 4 Offset 112 OpMemberDecorate %63 0 Offset 0 OpMemberDecorate %63 1 Offset 128 OpMemberDecorate %63 2 Offset 136 OpDecorate %63 Block OpDecorate %65 DescriptorSet 0 OpDecorate %65 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeInt 32 0 %8 = OpConstant %7 5 %9 = OpTypeArray %6 %8 %10 = OpTypeInt 32 1 %11 = OpTypeVector %10 4 %12 = OpTypeVector %6 3 %13 = OpTypeBool %14 = OpTypeStruct %9 %11 %12 %7 %13 %15 = OpTypePointer Function %14 %17 = OpConstant %10 0 %18 = OpConstant %6 1.9375 %19 = OpTypePointer Function %6 %21 = OpConstant %10 1 %22 = OpConstant %6 1.875 %24 = OpConstant %10 2 %25 = OpConstant %6 1.75 %27 = OpConstant %10 3 %28 = OpConstant %6 1.5 %30 = OpConstant %10 4 %31 = OpConstant %6 1 %33 = OpConstant %7 0 %34 = OpTypePointer Function %10 %36 = OpConstant %7 1 %38 = OpConstant %7 2 %40 = OpConstant %7 3 %42 = OpConstant %10 22 %44 = OpConstant %6 2.75 %46 = OpConstant %6 2.5 %48 = OpConstant %6 2 %50 = OpConstant %7 42 %51 = OpTypePointer Function %7 %53 = OpConstant %7 100 %55 = OpConstant %7 200 %57 = OpConstantTrue %13 %58 = OpTypePointer Function %13 %60 = OpTypeArray %6 %8 %61 = OpTypeStruct %60 %11 %12 %7 %7 %62 = OpTypeVector %7 2 %63 = OpTypeStruct %61 %10 %62 %64 = OpTypePointer Uniform %63 %100 = OpTypePointer Uniform %10 %101 = OpTypePointer Uniform %7 %102 = OpTypePointer Uniform %6 %103 = OpTypePointer Uniform %13 %65 = OpVariable %64 Uniform %4 = OpFunction %2 None %3 %5 = OpLabel %16 = OpVariable %15 Function %20 = OpAccessChain %19 %16 %17 %17 %200 = OpAccessChain %102 %65 %17 %17 %30 %201 = OpLoad %6 %200 OpStore %20 %201 %23 = OpAccessChain %19 %16 %17 %21 %202 = OpAccessChain %102 %65 %17 %17 %27 %203 = OpLoad %6 %202 OpStore %23 %203 %26 = OpAccessChain %19 %16 %17 %24 %204 = OpAccessChain %102 %65 %17 %17 %24 %205 = OpLoad %6 %204 OpStore %26 %205 %29 = OpAccessChain %19 %16 %17 %27 %206 = OpAccessChain %102 %65 %17 %17 %21 %207 = OpLoad %6 %206 OpStore %29 %207 %32 = OpAccessChain %19 %16 %17 %30 %208 = OpAccessChain %102 %65 %17 %17 %17 %209 = OpLoad %6 %208 OpStore %32 %209 %35 = OpAccessChain %34 %16 %21 %33 %210 = OpAccessChain %100 %65 %17 %21 %27 %211 = OpLoad %10 %210 OpStore %35 %211 %37 = OpAccessChain %34 %16 %21 %36 %212 = OpAccessChain %100 %65 %17 %21 %24 %213 = OpLoad %10 %212 OpStore %37 %213 %39 = OpAccessChain %34 %16 %21 %38 %214 = OpAccessChain %100 %65 %17 %21 %21 %215 = OpLoad %10 %214 OpStore %39 %215 %41 = OpAccessChain %34 %16 %21 %40 %216 = OpAccessChain %100 %65 %17 %21 %17 %217 = OpLoad %10 %216 OpStore %41 %217 %43 = OpAccessChain %34 %16 %21 %33 %218 = OpAccessChain %100 %65 %21 %219 = OpLoad %10 %218 OpStore %43 %219 %45 = OpAccessChain %19 %16 %24 %33 %220 = OpAccessChain %102 %65 %17 %24 %24 %221 = OpLoad %6 %220 OpStore %45 %221 %47 = OpAccessChain %19 %16 %24 %33 %222 = OpAccessChain %102 %65 %17 %24 %21 %223 = OpLoad %6 %222 OpStore %47 %223 %49 = OpAccessChain %19 %16 %24 %33 %224 = OpAccessChain %102 %65 %17 %24 %17 %225 = OpLoad %6 %224 OpStore %49 %225 %52 = OpAccessChain %51 %16 %27 %226 = OpAccessChain %101 %65 %17 %27 %227 = OpLoad %7 %226 OpStore %52 %227 %54 = OpAccessChain %51 %16 %27 %228 = OpAccessChain %101 %65 %24 %17 %229 = OpLoad %7 %228 OpStore %54 %229 %56 = OpAccessChain %51 %16 %27 %230 = OpAccessChain %101 %65 %24 %21 %231 = OpLoad %7 %230 OpStore %56 %231 %59 = OpAccessChain %58 %16 %30 OpStore %59 %57 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after, context.get())); } TEST(TransformationReplaceConstantWithUniformTest, DoNotReplaceVariableInitializer) { // If a local variable has a constant initializer, this cannot be replaced // by a uniform. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 450 OpMemberDecorate %16 0 Offset 0 OpDecorate %16 Block OpDecorate %18 DescriptorSet 0 OpDecorate %18 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %50 = OpConstant %6 0 %16 = OpTypeStruct %6 %17 = OpTypePointer Uniform %16 %51 = OpTypePointer Uniform %6 %18 = OpVariable %17 Uniform %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %50 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); protobufs::UniformBufferElementDescriptor blockname_a = MakeUniformBufferElementDescriptor(0, 0, {0}); ASSERT_TRUE(AddFactHelper(&transformation_context, 0, blockname_a)); ASSERT_FALSE( TransformationReplaceConstantWithUniform( MakeIdUseDescriptor( 50, MakeInstructionDescriptor(8, spv::Op::OpVariable, 0), 1), blockname_a, 100, 101) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationReplaceConstantWithUniformTest, ReplaceOpPhiOperand) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpDecorate %32 DescriptorSet 0 OpDecorate %32 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpConstant %6 2 %13 = OpConstant %6 4 %21 = OpConstant %6 1 %34 = OpConstant %6 0 %10 = OpTypeBool %30 = OpTypeStruct %6 %31 = OpTypePointer Uniform %30 %32 = OpVariable %31 Uniform %33 = OpTypePointer Uniform %6 %4 = OpFunction %2 None %3 %11 = OpLabel OpBranch %5 %5 = OpLabel %23 = OpPhi %6 %7 %11 %20 %15 %9 = OpSLessThan %10 %23 %13 OpLoopMerge %8 %15 None OpBranchConditional %9 %15 %8 %15 = OpLabel %20 = OpIAdd %6 %23 %21 OpBranch %5 %8 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto int_descriptor = MakeUniformBufferElementDescriptor(0, 0, {0}); ASSERT_TRUE(AddFactHelper(&transformation_context, 2, int_descriptor)); { TransformationReplaceConstantWithUniform transformation( MakeIdUseDescriptor(7, MakeInstructionDescriptor(23, spv::Op::OpPhi, 0), 0), int_descriptor, 50, 51); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpDecorate %32 DescriptorSet 0 OpDecorate %32 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpConstant %6 2 %13 = OpConstant %6 4 %21 = OpConstant %6 1 %34 = OpConstant %6 0 %10 = OpTypeBool %30 = OpTypeStruct %6 %31 = OpTypePointer Uniform %30 %32 = OpVariable %31 Uniform %33 = OpTypePointer Uniform %6 %4 = OpFunction %2 None %3 %11 = OpLabel %50 = OpAccessChain %33 %32 %34 %51 = OpLoad %6 %50 OpBranch %5 %5 = OpLabel %23 = OpPhi %6 %51 %11 %20 %15 %9 = OpSLessThan %10 %23 %13 OpLoopMerge %8 %15 None OpBranchConditional %9 %15 %8 %15 = OpLabel %20 = OpIAdd %6 %23 %21 OpBranch %5 %8 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools transformation_replace_copy_memory_with_load_store_test.cpp000066400000000000000000000140451475742701700346270ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/fuzz// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_replace_copy_memory_with_load_store.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationReplaceCopyMemoryWithLoadStoreTest, BasicScenarios) { // This is a simple transformation and this test handles the main cases. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "a" OpName %10 "b" OpName %14 "c" OpName %16 "d" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 2 %11 = OpConstant %6 3 %12 = OpTypeFloat 32 %13 = OpTypePointer Function %12 %15 = OpConstant %12 2 %17 = OpConstant %12 3 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %14 = OpVariable %13 Function %16 = OpVariable %13 Function OpStore %8 %9 OpStore %10 %11 OpStore %14 %15 OpStore %16 %17 OpCopyMemory %8 %10 OpCopyMemory %16 %14 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); auto instruction_descriptor_invalid_1 = MakeInstructionDescriptor(5, spv::Op::OpStore, 0); auto instruction_descriptor_valid_1 = MakeInstructionDescriptor(5, spv::Op::OpCopyMemory, 0); auto instruction_descriptor_valid_2 = MakeInstructionDescriptor(5, spv::Op::OpCopyMemory, 0); // Invalid: |source_id| is not a fresh id. auto transformation_invalid_1 = TransformationReplaceCopyMemoryWithLoadStore( 15, instruction_descriptor_valid_1); ASSERT_FALSE(transformation_invalid_1.IsApplicable(context.get(), transformation_context)); // Invalid: |instruction_descriptor_invalid| refers to an instruction OpStore. auto transformation_invalid_2 = TransformationReplaceCopyMemoryWithLoadStore( 20, instruction_descriptor_invalid_1); ASSERT_FALSE(transformation_invalid_2.IsApplicable(context.get(), transformation_context)); auto transformation_valid_1 = TransformationReplaceCopyMemoryWithLoadStore( 20, instruction_descriptor_valid_1); ASSERT_TRUE(transformation_valid_1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_valid_1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); auto transformation_valid_2 = TransformationReplaceCopyMemoryWithLoadStore( 21, instruction_descriptor_valid_2); ASSERT_TRUE(transformation_valid_2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_valid_2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "a" OpName %10 "b" OpName %14 "c" OpName %16 "d" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 2 %11 = OpConstant %6 3 %12 = OpTypeFloat 32 %13 = OpTypePointer Function %12 %15 = OpConstant %12 2 %17 = OpConstant %12 3 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %14 = OpVariable %13 Function %16 = OpVariable %13 Function OpStore %8 %9 OpStore %10 %11 OpStore %14 %15 OpStore %16 %17 %20 = OpLoad %6 %10 OpStore %8 %20 %21 = OpLoad %12 %14 OpStore %16 %21 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools transformation_replace_copy_object_with_store_load_test.cpp000066400000000000000000000251651475742701700345720ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/fuzz// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_replace_copy_object_with_store_load.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationReplaceCopyObjectWithStoreLoad, BasicScenarios) { std::string reference_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %23 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "a" OpName %10 "b" OpName %14 "c" OpName %16 "d" OpName %18 "e" OpName %23 "f" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 2 %11 = OpConstant %6 3 %12 = OpTypeFloat 32 %13 = OpTypePointer Function %12 %15 = OpConstant %12 2 %17 = OpConstant %12 3 %22 = OpTypePointer Private %12 %23 = OpVariable %22 Private %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %14 = OpVariable %13 Function %16 = OpVariable %13 Function %18 = OpVariable %7 Function OpStore %8 %9 OpStore %10 %11 OpStore %14 %15 OpStore %16 %17 %19 = OpLoad %6 %8 %20 = OpLoad %6 %10 %21 = OpIAdd %6 %19 %20 OpStore %18 %21 %24 = OpLoad %12 %14 %25 = OpLoad %12 %16 %26 = OpFMul %12 %24 %25 OpStore %23 %26 %27 = OpCopyObject %6 %21 %28 = OpCopyObject %12 %26 %40 = OpCopyObject %13 %14 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Invalid: fresh_variable_id=10 is not fresh. auto transformation_invalid_1 = TransformationReplaceCopyObjectWithStoreLoad( 27, 10, (uint32_t)spv::StorageClass::Function, 9); ASSERT_FALSE(transformation_invalid_1.IsApplicable(context.get(), transformation_context)); // Invalid: copy_object_result_id=26 is not a CopyObject instruction. auto transformation_invalid_2 = TransformationReplaceCopyObjectWithStoreLoad( 26, 30, (uint32_t)spv::StorageClass::Function, 9); ASSERT_FALSE(transformation_invalid_2.IsApplicable(context.get(), transformation_context)); // Invalid: copy_object_result_id=40 is of type pointer. auto transformation_invalid_3 = TransformationReplaceCopyObjectWithStoreLoad( 40, 30, (uint32_t)spv::StorageClass::Function, 9); ASSERT_FALSE(transformation_invalid_3.IsApplicable(context.get(), transformation_context)); // Invalid: Pointer type instruction in this storage class pointing to the // value type is not defined. auto transformation_invalid_4 = TransformationReplaceCopyObjectWithStoreLoad( 40, 30, (uint32_t)spv::StorageClass::Private, 9); ASSERT_FALSE(transformation_invalid_4.IsApplicable(context.get(), transformation_context)); // Invalid: initializer_id=15 has the wrong type relative to the OpCopyObject // instruction. auto transformation_invalid_5 = TransformationReplaceCopyObjectWithStoreLoad( 27, 30, (uint32_t)spv::StorageClass::Function, 15); ASSERT_FALSE(transformation_invalid_5.IsApplicable(context.get(), transformation_context)); // Invalid: spv::StorageClass::Uniform is not applicable to the // transformation. auto transformation_invalid_6 = TransformationReplaceCopyObjectWithStoreLoad( 27, 30, (uint32_t)spv::StorageClass::Uniform, 9); ASSERT_FALSE(transformation_invalid_6.IsApplicable(context.get(), transformation_context)); auto transformation_valid_1 = TransformationReplaceCopyObjectWithStoreLoad( 27, 30, (uint32_t)spv::StorageClass::Function, 9); ASSERT_TRUE(transformation_valid_1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_valid_1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); auto transformation_valid_2 = TransformationReplaceCopyObjectWithStoreLoad( 28, 32, (uint32_t)spv::StorageClass::Private, 15); ASSERT_TRUE(transformation_valid_2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_valid_2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %23 %32 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "a" OpName %10 "b" OpName %14 "c" OpName %16 "d" OpName %18 "e" OpName %23 "f" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 2 %11 = OpConstant %6 3 %12 = OpTypeFloat 32 %13 = OpTypePointer Function %12 %15 = OpConstant %12 2 %17 = OpConstant %12 3 %22 = OpTypePointer Private %12 %23 = OpVariable %22 Private %32 = OpVariable %22 Private %15 %4 = OpFunction %2 None %3 %5 = OpLabel %30 = OpVariable %7 Function %9 %8 = OpVariable %7 Function %10 = OpVariable %7 Function %14 = OpVariable %13 Function %16 = OpVariable %13 Function %18 = OpVariable %7 Function OpStore %8 %9 OpStore %10 %11 OpStore %14 %15 OpStore %16 %17 %19 = OpLoad %6 %8 %20 = OpLoad %6 %10 %21 = OpIAdd %6 %19 %20 OpStore %18 %21 %24 = OpLoad %12 %14 %25 = OpLoad %12 %16 %26 = OpFMul %12 %24 %25 OpStore %23 %26 OpStore %30 %21 %27 = OpLoad %6 %30 OpStore %32 %26 %28 = OpLoad %12 %32 %40 = OpCopyObject %13 %14 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationReplaceCopyObjectWithStoreLoad, IrrelevantIdsAndDeadBlocks) { std::string reference_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %30 = OpTypePointer Function %6 %10 = OpConstant %6 0 %11 = OpConstant %6 1 %13 = OpTypeBool %14 = OpConstantFalse %13 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %16 None OpBranchConditional %14 %15 %16 %15 = OpLabel %50 = OpCopyObject %6 %10 OpBranch %16 %16 = OpLabel %51 = OpCopyObject %6 %11 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); transformation_context.GetFactManager()->AddFactBlockIsDead(15); transformation_context.GetFactManager()->AddFactIdIsIrrelevant(11); auto transformation_1 = TransformationReplaceCopyObjectWithStoreLoad( 50, 100, (uint32_t)spv::StorageClass::Function, 10); ASSERT_TRUE( transformation_1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_1, context.get(), &transformation_context); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(100, {}), MakeDataDescriptor(50, {}))); auto transformation_2 = TransformationReplaceCopyObjectWithStoreLoad( 51, 101, (uint32_t)spv::StorageClass::Function, 10); ASSERT_TRUE( transformation_2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_2, context.get(), &transformation_context); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(101, {}), MakeDataDescriptor(51, {}))); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_replace_id_with_synonym_test.cpp000066400000000000000000002527251475742701700323320ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_replace_id_with_synonym.h" #include "gtest/gtest.h" #include "source/fuzz/data_descriptor.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/id_use_descriptor.h" #include "source/fuzz/instruction_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { // The following shader was obtained from this GLSL, which was then optimized // with spirv-opt -O and manually edited to include some uses of OpCopyObject // (to introduce id synonyms). // // #version 310 es // // precision highp int; // precision highp float; // // layout(set = 0, binding = 0) uniform buf { // int a; // int b; // int c; // }; // // layout(location = 0) out vec4 color; // // void main() { // int x = a; // float f = 0.0; // while (x < b) { // switch(x % 4) { // case 0: // color[0] = f; // break; // case 1: // color[1] = f; // break; // case 2: // color[2] = f; // break; // case 3: // color[3] = f; // break; // default: // break; // } // if (x > c) { // x++; // } else { // x += 2; // } // } // color[0] += color[1] + float(x); // } const std::string kComplexShader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %42 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %9 "buf" OpMemberName %9 0 "a" OpMemberName %9 1 "b" OpMemberName %9 2 "c" OpName %11 "" OpName %42 "color" OpMemberDecorate %9 0 Offset 0 OpMemberDecorate %9 1 Offset 4 OpMemberDecorate %9 2 Offset 8 OpDecorate %9 Block OpDecorate %11 DescriptorSet 0 OpDecorate %11 Binding 0 OpDecorate %42 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %9 = OpTypeStruct %6 %6 %6 %10 = OpTypePointer Uniform %9 %11 = OpVariable %10 Uniform %12 = OpConstant %6 0 %13 = OpTypePointer Uniform %6 %16 = OpTypeFloat 32 %19 = OpConstant %16 0 %26 = OpConstant %6 1 %29 = OpTypeBool %32 = OpConstant %6 4 %40 = OpTypeVector %16 4 %41 = OpTypePointer Output %40 %42 = OpVariable %41 Output %44 = OpTypeInt 32 0 %45 = OpConstant %44 0 %46 = OpTypePointer Output %16 %50 = OpConstant %44 1 %54 = OpConstant %44 2 %58 = OpConstant %44 3 %64 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %209 = OpCopyObject %6 %12 %14 = OpAccessChain %13 %11 %12 %15 = OpLoad %6 %14 %200 = OpCopyObject %6 %15 OpBranch %20 %20 = OpLabel %84 = OpPhi %6 %15 %5 %86 %69 %27 = OpAccessChain %13 %11 %26 %28 = OpLoad %6 %27 %207 = OpCopyObject %6 %84 %201 = OpCopyObject %6 %15 %30 = OpSLessThan %29 %84 %28 OpLoopMerge %22 %69 None OpBranchConditional %30 %21 %22 %21 = OpLabel %33 = OpSMod %6 %84 %32 %208 = OpCopyObject %6 %33 OpSelectionMerge %39 None OpSwitch %33 %38 0 %34 1 %35 2 %36 3 %37 %38 = OpLabel %202 = OpCopyObject %6 %15 OpBranch %39 %34 = OpLabel %210 = OpCopyObject %16 %19 %47 = OpAccessChain %46 %42 %45 OpStore %47 %19 OpBranch %39 %35 = OpLabel %51 = OpAccessChain %46 %42 %50 OpStore %51 %19 OpBranch %39 %36 = OpLabel %204 = OpCopyObject %44 %54 %55 = OpAccessChain %46 %42 %54 %203 = OpCopyObject %46 %55 OpStore %55 %19 OpBranch %39 %37 = OpLabel %59 = OpAccessChain %46 %42 %58 OpStore %59 %19 OpBranch %39 %39 = OpLabel %300 = OpIAdd %6 %15 %15 %65 = OpAccessChain %13 %11 %64 %66 = OpLoad %6 %65 %67 = OpSGreaterThan %29 %84 %66 OpSelectionMerge %1000 None OpBranchConditional %67 %68 %72 %68 = OpLabel %71 = OpIAdd %6 %84 %26 OpBranch %1000 %72 = OpLabel %74 = OpIAdd %6 %84 %64 %205 = OpCopyObject %6 %74 OpBranch %1000 %1000 = OpLabel %86 = OpPhi %6 %71 %68 %74 %72 %301 = OpPhi %6 %71 %68 %15 %72 OpBranch %69 %69 = OpLabel OpBranch %20 %22 = OpLabel %75 = OpAccessChain %46 %42 %50 %76 = OpLoad %16 %75 %78 = OpConvertSToF %16 %84 %80 = OpAccessChain %46 %42 %45 %206 = OpCopyObject %16 %78 %81 = OpLoad %16 %80 %79 = OpFAdd %16 %76 %78 %82 = OpFAdd %16 %81 %79 OpStore %80 %82 OpReturn OpFunctionEnd )"; protobufs::Fact MakeSynonymFact(uint32_t first, uint32_t second) { protobufs::FactDataSynonym data_synonym_fact; *data_synonym_fact.mutable_data1() = MakeDataDescriptor(first, {}); *data_synonym_fact.mutable_data2() = MakeDataDescriptor(second, {}); protobufs::Fact result; *result.mutable_data_synonym_fact() = data_synonym_fact; return result; } // Equips the fact manager with synonym facts for the above shader. void SetUpIdSynonyms(FactManager* fact_manager) { fact_manager->MaybeAddFact(MakeSynonymFact(15, 200)); fact_manager->MaybeAddFact(MakeSynonymFact(15, 201)); fact_manager->MaybeAddFact(MakeSynonymFact(15, 202)); fact_manager->MaybeAddFact(MakeSynonymFact(55, 203)); fact_manager->MaybeAddFact(MakeSynonymFact(54, 204)); fact_manager->MaybeAddFact(MakeSynonymFact(74, 205)); fact_manager->MaybeAddFact(MakeSynonymFact(78, 206)); fact_manager->MaybeAddFact(MakeSynonymFact(84, 207)); fact_manager->MaybeAddFact(MakeSynonymFact(33, 208)); fact_manager->MaybeAddFact(MakeSynonymFact(12, 209)); fact_manager->MaybeAddFact(MakeSynonymFact(19, 210)); } TEST(TransformationReplaceIdWithSynonymTest, IllegalTransformations) { const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, kComplexShader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); SetUpIdSynonyms(transformation_context.GetFactManager()); // %202 cannot replace %15 as in-operand 0 of %300, since %202 does not // dominate %300. auto synonym_does_not_dominate_use = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 15, MakeInstructionDescriptor(300, spv::Op::OpIAdd, 0), 0), 202); ASSERT_FALSE(synonym_does_not_dominate_use.IsApplicable( context.get(), transformation_context)); // %202 cannot replace %15 as in-operand 2 of %301, since this is the OpPhi's // incoming value for block %72, and %202 does not dominate %72. auto synonym_does_not_dominate_use_op_phi = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 15, MakeInstructionDescriptor(301, spv::Op::OpPhi, 0), 2), 202); ASSERT_FALSE(synonym_does_not_dominate_use_op_phi.IsApplicable( context.get(), transformation_context)); // %200 is not a synonym for %84 auto id_in_use_is_not_synonymous = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 84, MakeInstructionDescriptor(67, spv::Op::OpSGreaterThan, 0), 0), 200); ASSERT_FALSE(id_in_use_is_not_synonymous.IsApplicable( context.get(), transformation_context)); // %86 is not a synonym for anything (and in particular not for %74) auto id_has_no_synonyms = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor(86, MakeInstructionDescriptor(84, spv::Op::OpPhi, 0), 2), 74); ASSERT_FALSE( id_has_no_synonyms.IsApplicable(context.get(), transformation_context)); // This would lead to %207 = 'OpCopyObject %type %207' if it were allowed auto synonym_use_is_in_synonym_definition = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 84, MakeInstructionDescriptor(207, spv::Op::OpCopyObject, 0), 0), 207); ASSERT_FALSE(synonym_use_is_in_synonym_definition.IsApplicable( context.get(), transformation_context)); // The id use descriptor does not lead to a use (%84 is not used in the // definition of %207) auto bad_id_use_descriptor = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 84, MakeInstructionDescriptor(200, spv::Op::OpCopyObject, 0), 0), 207); ASSERT_FALSE(bad_id_use_descriptor.IsApplicable(context.get(), transformation_context)); // This replacement would lead to an access chain into a struct using a // non-constant index. auto bad_access_chain = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 12, MakeInstructionDescriptor(14, spv::Op::OpAccessChain, 0), 1), 209); ASSERT_FALSE( bad_access_chain.IsApplicable(context.get(), transformation_context)); } TEST(TransformationReplaceIdWithSynonymTest, LegalTransformations) { const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, kComplexShader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); SetUpIdSynonyms(transformation_context.GetFactManager()); auto global_constant_synonym = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 19, MakeInstructionDescriptor(47, spv::Op::OpStore, 0), 1), 210); uint32_t num_uses_of_original_id_before_replacement = context->get_def_use_mgr()->NumUses(19); uint32_t num_uses_of_synonym_before_replacement = context->get_def_use_mgr()->NumUses(210); ASSERT_TRUE(global_constant_synonym.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(global_constant_synonym, context.get(), &transformation_context); ASSERT_EQ(num_uses_of_original_id_before_replacement - 1, context->get_def_use_mgr()->NumUses(19)); ASSERT_EQ(num_uses_of_synonym_before_replacement + 1, context->get_def_use_mgr()->NumUses(210)); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); auto replace_vector_access_chain_index = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 54, MakeInstructionDescriptor(55, spv::Op::OpAccessChain, 0), 1), 204); ASSERT_TRUE(replace_vector_access_chain_index.IsApplicable( context.get(), transformation_context)); ApplyAndCheckFreshIds(replace_vector_access_chain_index, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // This is an interesting case because it replaces something that is being // copied with something that is already a synonym. auto regular_replacement = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 15, MakeInstructionDescriptor(202, spv::Op::OpCopyObject, 0), 0), 201); ASSERT_TRUE( regular_replacement.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(regular_replacement, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); auto regular_replacement2 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 55, MakeInstructionDescriptor(203, spv::Op::OpStore, 0), 0), 203); ASSERT_TRUE( regular_replacement2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(regular_replacement2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); auto good_op_phi = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor(74, MakeInstructionDescriptor(86, spv::Op::OpPhi, 0), 2), 205); ASSERT_TRUE(good_op_phi.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(good_op_phi, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); const std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %42 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %9 "buf" OpMemberName %9 0 "a" OpMemberName %9 1 "b" OpMemberName %9 2 "c" OpName %11 "" OpName %42 "color" OpMemberDecorate %9 0 Offset 0 OpMemberDecorate %9 1 Offset 4 OpMemberDecorate %9 2 Offset 8 OpDecorate %9 Block OpDecorate %11 DescriptorSet 0 OpDecorate %11 Binding 0 OpDecorate %42 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %9 = OpTypeStruct %6 %6 %6 %10 = OpTypePointer Uniform %9 %11 = OpVariable %10 Uniform %12 = OpConstant %6 0 %13 = OpTypePointer Uniform %6 %16 = OpTypeFloat 32 %19 = OpConstant %16 0 %26 = OpConstant %6 1 %29 = OpTypeBool %32 = OpConstant %6 4 %40 = OpTypeVector %16 4 %41 = OpTypePointer Output %40 %42 = OpVariable %41 Output %44 = OpTypeInt 32 0 %45 = OpConstant %44 0 %46 = OpTypePointer Output %16 %50 = OpConstant %44 1 %54 = OpConstant %44 2 %58 = OpConstant %44 3 %64 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %209 = OpCopyObject %6 %12 %14 = OpAccessChain %13 %11 %12 %15 = OpLoad %6 %14 %200 = OpCopyObject %6 %15 OpBranch %20 %20 = OpLabel %84 = OpPhi %6 %15 %5 %86 %69 %27 = OpAccessChain %13 %11 %26 %28 = OpLoad %6 %27 %207 = OpCopyObject %6 %84 %201 = OpCopyObject %6 %15 %30 = OpSLessThan %29 %84 %28 OpLoopMerge %22 %69 None OpBranchConditional %30 %21 %22 %21 = OpLabel %33 = OpSMod %6 %84 %32 %208 = OpCopyObject %6 %33 OpSelectionMerge %39 None OpSwitch %33 %38 0 %34 1 %35 2 %36 3 %37 %38 = OpLabel %202 = OpCopyObject %6 %201 OpBranch %39 %34 = OpLabel %210 = OpCopyObject %16 %19 %47 = OpAccessChain %46 %42 %45 OpStore %47 %210 OpBranch %39 %35 = OpLabel %51 = OpAccessChain %46 %42 %50 OpStore %51 %19 OpBranch %39 %36 = OpLabel %204 = OpCopyObject %44 %54 %55 = OpAccessChain %46 %42 %204 %203 = OpCopyObject %46 %55 OpStore %203 %19 OpBranch %39 %37 = OpLabel %59 = OpAccessChain %46 %42 %58 OpStore %59 %19 OpBranch %39 %39 = OpLabel %300 = OpIAdd %6 %15 %15 %65 = OpAccessChain %13 %11 %64 %66 = OpLoad %6 %65 %67 = OpSGreaterThan %29 %84 %66 OpSelectionMerge %1000 None OpBranchConditional %67 %68 %72 %68 = OpLabel %71 = OpIAdd %6 %84 %26 OpBranch %1000 %72 = OpLabel %74 = OpIAdd %6 %84 %64 %205 = OpCopyObject %6 %74 OpBranch %1000 %1000 = OpLabel %86 = OpPhi %6 %71 %68 %205 %72 %301 = OpPhi %6 %71 %68 %15 %72 OpBranch %69 %69 = OpLabel OpBranch %20 %22 = OpLabel %75 = OpAccessChain %46 %42 %50 %76 = OpLoad %16 %75 %78 = OpConvertSToF %16 %84 %80 = OpAccessChain %46 %42 %45 %206 = OpCopyObject %16 %78 %81 = OpLoad %16 %80 %79 = OpFAdd %16 %76 %78 %82 = OpFAdd %16 %81 %79 OpStore %80 %82 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationReplaceIdWithSynonymTest, SynonymsOfVariables) { // The following SPIR-V comes from this GLSL, with object copies added: // // #version 310 es // // precision highp int; // // int g; // // void main() { // int l; // l = g; // g = l; // } const std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "l" OpName %10 "g" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpTypePointer Private %6 %10 = OpVariable %9 Private %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %100 = OpCopyObject %9 %10 %101 = OpCopyObject %7 %8 %11 = OpLoad %6 %10 OpStore %8 %11 %12 = OpLoad %6 %8 OpStore %10 %12 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(10, 100)); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(8, 101)); // Replace %10 with %100 in: // %11 = OpLoad %6 %10 auto replacement1 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor(10, MakeInstructionDescriptor(11, spv::Op::OpLoad, 0), 0), 100); ASSERT_TRUE(replacement1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(replacement1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Replace %8 with %101 in: // OpStore %8 %11 auto replacement2 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor(8, MakeInstructionDescriptor(11, spv::Op::OpStore, 0), 0), 101); ASSERT_TRUE(replacement2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(replacement2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Replace %8 with %101 in: // %12 = OpLoad %6 %8 auto replacement3 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor(8, MakeInstructionDescriptor(12, spv::Op::OpLoad, 0), 0), 101); ASSERT_TRUE(replacement3.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(replacement3, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Replace %10 with %100 in: // OpStore %10 %12 auto replacement4 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 10, MakeInstructionDescriptor(12, spv::Op::OpStore, 0), 0), 100); ASSERT_TRUE(replacement4.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(replacement4, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); const std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "l" OpName %10 "g" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpTypePointer Private %6 %10 = OpVariable %9 Private %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %100 = OpCopyObject %9 %10 %101 = OpCopyObject %7 %8 %11 = OpLoad %6 %100 OpStore %101 %11 %12 = OpLoad %6 %101 OpStore %100 %12 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationReplaceIdWithSynonymTest, SynonymOfVariableNoGoodInFunctionCall) { // The following SPIR-V comes from this GLSL, with an object copy added: // // #version 310 es // // precision highp int; // // void foo(int x) { } // // void main() { // int a; // a = 2; // foo(a); // } const std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %10 "foo(i1;" OpName %9 "x" OpName %12 "a" OpName %14 "param" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %2 %7 %13 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %12 = OpVariable %7 Function %14 = OpVariable %7 Function OpStore %12 %13 %15 = OpLoad %6 %12 OpStore %14 %15 %100 = OpCopyObject %7 %14 %16 = OpFunctionCall %2 %10 %14 OpReturn OpFunctionEnd %10 = OpFunction %2 None %8 %9 = OpFunctionParameter %7 %11 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(14, 100)); // Replace %14 with %100 in: // %16 = OpFunctionCall %2 %10 %14 auto replacement = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 14, MakeInstructionDescriptor(16, spv::Op::OpFunctionCall, 0), 1), 100); ASSERT_FALSE(replacement.IsApplicable(context.get(), transformation_context)); } TEST(TransformationReplaceIdWithSynonymTest, SynonymsOfAccessChainIndices) { // The following SPIR-V comes from this GLSL, with object copies added: // // #version 310 es // // precision highp float; // precision highp int; // // struct S { // int[3] a; // vec4 b; // bool c; // } d; // // float[20] e; // // struct T { // float f; // S g; // } h; // // T[4] i; // // void main() { // d.a[2] = 10; // d.b[3] = 11.0; // d.c = false; // e[17] = 12.0; // h.f = 13.0; // h.g.a[1] = 14; // h.g.b[0] = 15.0; // h.g.c = true; // i[0].f = 16.0; // i[1].g.a[0] = 17; // i[2].g.b[1] = 18.0; // i[3].g.c = true; // } const std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %13 "S" OpMemberName %13 0 "a" OpMemberName %13 1 "b" OpMemberName %13 2 "c" OpName %15 "d" OpName %31 "e" OpName %35 "T" OpMemberName %35 0 "f" OpMemberName %35 1 "g" OpName %37 "h" OpName %50 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeInt 32 0 %8 = OpConstant %7 3 %9 = OpTypeArray %6 %8 %10 = OpTypeFloat 32 %11 = OpTypeVector %10 4 %12 = OpTypeBool %13 = OpTypeStruct %9 %11 %12 %14 = OpTypePointer Private %13 %15 = OpVariable %14 Private %16 = OpConstant %6 0 %17 = OpConstant %6 2 %18 = OpConstant %6 10 %19 = OpTypePointer Private %6 %21 = OpConstant %6 1 %22 = OpConstant %10 11 %23 = OpTypePointer Private %10 %25 = OpConstantFalse %12 %26 = OpTypePointer Private %12 %28 = OpConstant %7 20 %29 = OpTypeArray %10 %28 %30 = OpTypePointer Private %29 %31 = OpVariable %30 Private %32 = OpConstant %6 17 %33 = OpConstant %10 12 %35 = OpTypeStruct %10 %13 %36 = OpTypePointer Private %35 %37 = OpVariable %36 Private %38 = OpConstant %10 13 %40 = OpConstant %6 14 %42 = OpConstant %10 15 %43 = OpConstant %7 0 %45 = OpConstantTrue %12 %47 = OpConstant %7 4 %48 = OpTypeArray %35 %47 %49 = OpTypePointer Private %48 %50 = OpVariable %49 Private %51 = OpConstant %10 16 %54 = OpConstant %10 18 %55 = OpConstant %7 1 %57 = OpConstant %6 3 %4 = OpFunction %2 None %3 %5 = OpLabel %100 = OpCopyObject %6 %16 ; 0 %101 = OpCopyObject %6 %21 ; 1 %102 = OpCopyObject %6 %17 ; 2 %103 = OpCopyObject %6 %57 ; 3 %104 = OpCopyObject %6 %18 ; 10 %105 = OpCopyObject %6 %40 ; 14 %106 = OpCopyObject %6 %32 ; 17 %107 = OpCopyObject %7 %43 ; 0 %108 = OpCopyObject %7 %55 ; 1 %109 = OpCopyObject %7 %8 ; 3 %110 = OpCopyObject %7 %47 ; 4 %111 = OpCopyObject %7 %28 ; 20 %112 = OpCopyObject %12 %45 ; true %20 = OpAccessChain %19 %15 %16 %17 OpStore %20 %18 %24 = OpAccessChain %23 %15 %21 %8 OpStore %24 %22 %27 = OpAccessChain %26 %15 %17 OpStore %27 %25 %34 = OpAccessChain %23 %31 %32 OpStore %34 %33 %39 = OpAccessChain %23 %37 %16 OpStore %39 %38 %41 = OpAccessChain %19 %37 %21 %16 %21 OpStore %41 %40 %44 = OpAccessChain %23 %37 %21 %21 %43 OpStore %44 %42 %46 = OpAccessChain %26 %37 %21 %17 OpStore %46 %45 %52 = OpAccessChain %23 %50 %16 %16 OpStore %52 %51 %53 = OpAccessChain %19 %50 %21 %21 %16 %16 OpStore %53 %32 %56 = OpAccessChain %23 %50 %17 %21 %21 %55 OpStore %56 %54 %58 = OpInBoundsAccessChain %26 %50 %57 %21 %17 OpStore %58 %45 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Add synonym facts corresponding to the OpCopyObject operations that have // been applied to all constants in the module. transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(16, 100)); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(21, 101)); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(17, 102)); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(57, 103)); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(18, 104)); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(40, 105)); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(32, 106)); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(43, 107)); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(55, 108)); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(8, 109)); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(47, 110)); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(28, 111)); transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(45, 112)); // Replacements of the form %16 -> %100 // %20 = OpAccessChain %19 %15 *%16* %17 // Corresponds to d.*a*[2] // The index %16 used for a cannot be replaced auto replacement1 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 16, MakeInstructionDescriptor(20, spv::Op::OpAccessChain, 0), 1), 100); ASSERT_FALSE( replacement1.IsApplicable(context.get(), transformation_context)); // %39 = OpAccessChain %23 %37 *%16* // Corresponds to h.*f* // The index %16 used for f cannot be replaced auto replacement2 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 16, MakeInstructionDescriptor(39, spv::Op::OpAccessChain, 0), 1), 100); ASSERT_FALSE( replacement2.IsApplicable(context.get(), transformation_context)); // %41 = OpAccessChain %19 %37 %21 *%16* %21 // Corresponds to h.g.*a*[1] // The index %16 used for a cannot be replaced auto replacement3 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 16, MakeInstructionDescriptor(41, spv::Op::OpAccessChain, 0), 2), 100); ASSERT_FALSE( replacement3.IsApplicable(context.get(), transformation_context)); // %52 = OpAccessChain %23 %50 *%16* %16 // Corresponds to i[*0*].f // The index %16 used for 0 *can* be replaced auto replacement4 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 16, MakeInstructionDescriptor(52, spv::Op::OpAccessChain, 0), 1), 100); ASSERT_TRUE(replacement4.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(replacement4, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // %52 = OpAccessChain %23 %50 %16 *%16* // Corresponds to i[0].*f* // The index %16 used for f cannot be replaced auto replacement5 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 16, MakeInstructionDescriptor(52, spv::Op::OpAccessChain, 0), 2), 100); ASSERT_FALSE( replacement5.IsApplicable(context.get(), transformation_context)); // %53 = OpAccessChain %19 %50 %21 %21 *%16* %16 // Corresponds to i[1].g.*a*[0] // The index %16 used for a cannot be replaced auto replacement6 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 16, MakeInstructionDescriptor(53, spv::Op::OpAccessChain, 0), 3), 100); ASSERT_FALSE( replacement6.IsApplicable(context.get(), transformation_context)); // %53 = OpAccessChain %19 %50 %21 %21 %16 *%16* // Corresponds to i[1].g.a[*0*] // The index %16 used for 0 *can* be replaced auto replacement7 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 16, MakeInstructionDescriptor(53, spv::Op::OpAccessChain, 0), 4), 100); ASSERT_TRUE(replacement7.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(replacement7, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Replacements of the form %21 -> %101 // %24 = OpAccessChain %23 %15 *%21* %8 // Corresponds to d.*b*[3] // The index %24 used for b cannot be replaced auto replacement8 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 21, MakeInstructionDescriptor(24, spv::Op::OpAccessChain, 0), 1), 101); ASSERT_FALSE( replacement8.IsApplicable(context.get(), transformation_context)); // %41 = OpAccessChain %19 %37 *%21* %16 %21 // Corresponds to h.*g*.a[1] // The index %24 used for g cannot be replaced auto replacement9 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 21, MakeInstructionDescriptor(41, spv::Op::OpAccessChain, 0), 1), 101); ASSERT_FALSE( replacement9.IsApplicable(context.get(), transformation_context)); // %41 = OpAccessChain %19 %37 %21 %16 *%21* // Corresponds to h.g.a[*1*] // The index %24 used for 1 *can* be replaced auto replacement10 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 21, MakeInstructionDescriptor(41, spv::Op::OpAccessChain, 0), 3), 101); ASSERT_TRUE( replacement10.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(replacement10, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // %44 = OpAccessChain %23 %37 *%21* %21 %43 // Corresponds to h.*g*.b[0] // The index %24 used for g cannot be replaced auto replacement11 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 21, MakeInstructionDescriptor(44, spv::Op::OpAccessChain, 0), 1), 101); ASSERT_FALSE( replacement11.IsApplicable(context.get(), transformation_context)); // %44 = OpAccessChain %23 %37 %21 *%21* %43 // Corresponds to h.g.*b*[0] // The index %24 used for b cannot be replaced auto replacement12 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 21, MakeInstructionDescriptor(44, spv::Op::OpAccessChain, 0), 2), 101); ASSERT_FALSE( replacement12.IsApplicable(context.get(), transformation_context)); // %46 = OpAccessChain %26 %37 *%21* %17 // Corresponds to h.*g*.c // The index %24 used for g cannot be replaced auto replacement13 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 21, MakeInstructionDescriptor(46, spv::Op::OpAccessChain, 0), 1), 101); ASSERT_FALSE( replacement13.IsApplicable(context.get(), transformation_context)); // %53 = OpAccessChain %19 %50 *%21* %21 %16 %16 // Corresponds to i[*1*].g.a[0] // The index %24 used for 1 *can* be replaced auto replacement14 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 21, MakeInstructionDescriptor(53, spv::Op::OpAccessChain, 0), 1), 101); ASSERT_TRUE( replacement14.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(replacement14, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // %53 = OpAccessChain %19 %50 %21 *%21* %16 %16 // Corresponds to i[1].*g*.a[0] // The index %24 used for g cannot be replaced auto replacement15 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 21, MakeInstructionDescriptor(53, spv::Op::OpAccessChain, 0), 2), 101); ASSERT_FALSE( replacement15.IsApplicable(context.get(), transformation_context)); // %56 = OpAccessChain %23 %50 %17 *%21* %21 %55 // Corresponds to i[2].*g*.b[1] // The index %24 used for g cannot be replaced auto replacement16 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 21, MakeInstructionDescriptor(56, spv::Op::OpAccessChain, 0), 2), 101); ASSERT_FALSE( replacement16.IsApplicable(context.get(), transformation_context)); // %56 = OpAccessChain %23 %50 %17 %21 *%21* %55 // Corresponds to i[2].g.*b*[1] // The index %24 used for b cannot be replaced auto replacement17 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 21, MakeInstructionDescriptor(56, spv::Op::OpAccessChain, 0), 3), 101); ASSERT_FALSE( replacement17.IsApplicable(context.get(), transformation_context)); // %58 = OpInBoundsAccessChain %26 %50 %57 *%21* %17 // Corresponds to i[3].*g*.c // The index %24 used for g cannot be replaced auto replacement18 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 21, MakeInstructionDescriptor(58, spv::Op::OpInBoundsAccessChain, 0), 2), 101); ASSERT_FALSE( replacement18.IsApplicable(context.get(), transformation_context)); // Replacements of the form %17 -> %102 // %20 = OpAccessChain %19 %15 %16 %17 // Corresponds to d.a[*2*] // The index %17 used for 2 *can* be replaced auto replacement19 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 17, MakeInstructionDescriptor(20, spv::Op::OpAccessChain, 0), 2), 102); ASSERT_TRUE( replacement19.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(replacement19, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // %27 = OpAccessChain %26 %15 %17 // Corresponds to d.c // The index %17 used for c cannot be replaced auto replacement20 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 17, MakeInstructionDescriptor(27, spv::Op::OpAccessChain, 0), 1), 102); ASSERT_FALSE( replacement20.IsApplicable(context.get(), transformation_context)); // %46 = OpAccessChain %26 %37 %21 %17 // Corresponds to h.g.*c* // The index %17 used for c cannot be replaced auto replacement21 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 17, MakeInstructionDescriptor(46, spv::Op::OpAccessChain, 0), 2), 102); ASSERT_FALSE( replacement21.IsApplicable(context.get(), transformation_context)); // %56 = OpAccessChain %23 %50 %17 %21 %21 %55 // Corresponds to i[*2*].g.b[1] // The index %17 used for 2 *can* be replaced auto replacement22 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 17, MakeInstructionDescriptor(56, spv::Op::OpAccessChain, 0), 1), 102); ASSERT_TRUE( replacement22.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(replacement22, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // %58 = OpInBoundsAccessChain %26 %50 %57 %21 %17 // Corresponds to i[3].g.*c* // The index %17 used for c cannot be replaced auto replacement23 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 17, MakeInstructionDescriptor(58, spv::Op::OpInBoundsAccessChain, 0), 3), 102); ASSERT_FALSE( replacement23.IsApplicable(context.get(), transformation_context)); // Replacements of the form %57 -> %103 // %58 = OpInBoundsAccessChain %26 %50 *%57* %21 %17 // Corresponds to i[*3*].g.c // The index %57 used for 3 *can* be replaced auto replacement24 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 57, MakeInstructionDescriptor(58, spv::Op::OpInBoundsAccessChain, 0), 1), 103); ASSERT_TRUE( replacement24.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(replacement24, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Replacements of the form %32 -> %106 // %34 = OpAccessChain %23 %31 *%32* // Corresponds to e[*17*] // The index %32 used for 17 *can* be replaced auto replacement25 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 32, MakeInstructionDescriptor(34, spv::Op::OpAccessChain, 0), 1), 106); ASSERT_TRUE( replacement25.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(replacement25, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Replacements of the form %43 -> %107 // %44 = OpAccessChain %23 %37 %21 %21 *%43* // Corresponds to h.g.b[*0*] // The index %43 used for 0 *can* be replaced auto replacement26 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 43, MakeInstructionDescriptor(44, spv::Op::OpAccessChain, 0), 3), 107); ASSERT_TRUE( replacement26.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(replacement26, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Replacements of the form %55 -> %108 // %56 = OpAccessChain %23 %50 %17 %21 %21 *%55* // Corresponds to i[2].g.b[*1*] // The index %55 used for 1 *can* be replaced auto replacement27 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 55, MakeInstructionDescriptor(56, spv::Op::OpAccessChain, 0), 4), 108); ASSERT_TRUE( replacement27.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(replacement27, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Replacements of the form %8 -> %109 // %24 = OpAccessChain %23 %15 %21 *%8* // Corresponds to d.b[*3*] // The index %8 used for 3 *can* be replaced auto replacement28 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 8, MakeInstructionDescriptor(24, spv::Op::OpAccessChain, 0), 2), 109); ASSERT_TRUE( replacement28.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(replacement28, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); const std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %13 "S" OpMemberName %13 0 "a" OpMemberName %13 1 "b" OpMemberName %13 2 "c" OpName %15 "d" OpName %31 "e" OpName %35 "T" OpMemberName %35 0 "f" OpMemberName %35 1 "g" OpName %37 "h" OpName %50 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeInt 32 0 %8 = OpConstant %7 3 %9 = OpTypeArray %6 %8 %10 = OpTypeFloat 32 %11 = OpTypeVector %10 4 %12 = OpTypeBool %13 = OpTypeStruct %9 %11 %12 %14 = OpTypePointer Private %13 %15 = OpVariable %14 Private %16 = OpConstant %6 0 %17 = OpConstant %6 2 %18 = OpConstant %6 10 %19 = OpTypePointer Private %6 %21 = OpConstant %6 1 %22 = OpConstant %10 11 %23 = OpTypePointer Private %10 %25 = OpConstantFalse %12 %26 = OpTypePointer Private %12 %28 = OpConstant %7 20 %29 = OpTypeArray %10 %28 %30 = OpTypePointer Private %29 %31 = OpVariable %30 Private %32 = OpConstant %6 17 %33 = OpConstant %10 12 %35 = OpTypeStruct %10 %13 %36 = OpTypePointer Private %35 %37 = OpVariable %36 Private %38 = OpConstant %10 13 %40 = OpConstant %6 14 %42 = OpConstant %10 15 %43 = OpConstant %7 0 %45 = OpConstantTrue %12 %47 = OpConstant %7 4 %48 = OpTypeArray %35 %47 %49 = OpTypePointer Private %48 %50 = OpVariable %49 Private %51 = OpConstant %10 16 %54 = OpConstant %10 18 %55 = OpConstant %7 1 %57 = OpConstant %6 3 %4 = OpFunction %2 None %3 %5 = OpLabel %100 = OpCopyObject %6 %16 ; 0 %101 = OpCopyObject %6 %21 ; 1 %102 = OpCopyObject %6 %17 ; 2 %103 = OpCopyObject %6 %57 ; 3 %104 = OpCopyObject %6 %18 ; 10 %105 = OpCopyObject %6 %40 ; 14 %106 = OpCopyObject %6 %32 ; 17 %107 = OpCopyObject %7 %43 ; 0 %108 = OpCopyObject %7 %55 ; 1 %109 = OpCopyObject %7 %8 ; 3 %110 = OpCopyObject %7 %47 ; 4 %111 = OpCopyObject %7 %28 ; 20 %112 = OpCopyObject %12 %45 ; true %20 = OpAccessChain %19 %15 %16 %102 OpStore %20 %18 %24 = OpAccessChain %23 %15 %21 %109 OpStore %24 %22 %27 = OpAccessChain %26 %15 %17 OpStore %27 %25 %34 = OpAccessChain %23 %31 %106 OpStore %34 %33 %39 = OpAccessChain %23 %37 %16 OpStore %39 %38 %41 = OpAccessChain %19 %37 %21 %16 %101 OpStore %41 %40 %44 = OpAccessChain %23 %37 %21 %21 %107 OpStore %44 %42 %46 = OpAccessChain %26 %37 %21 %17 OpStore %46 %45 %52 = OpAccessChain %23 %50 %100 %16 OpStore %52 %51 %53 = OpAccessChain %19 %50 %101 %21 %16 %100 OpStore %53 %32 %56 = OpAccessChain %23 %50 %102 %21 %21 %108 OpStore %56 %54 %58 = OpInBoundsAccessChain %26 %50 %103 %21 %17 OpStore %58 %45 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationReplaceIdWithSynonymTest, RuntimeArrayTest) { // This checks that OpRuntimeArray is correctly handled. const std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %8 ArrayStride 8 OpMemberDecorate %9 0 Offset 0 OpDecorate %9 BufferBlock OpDecorate %11 DescriptorSet 0 OpDecorate %11 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeVector %6 2 %8 = OpTypeRuntimeArray %7 %9 = OpTypeStruct %8 %10 = OpTypePointer Uniform %9 %11 = OpVariable %10 Uniform %12 = OpConstant %6 0 %13 = OpTypeInt 32 0 %14 = OpConstant %13 0 %15 = OpTypePointer Uniform %6 %4 = OpFunction %2 None %3 %5 = OpLabel %50 = OpCopyObject %6 %12 %51 = OpCopyObject %13 %14 %16 = OpAccessChain %15 %11 %12 %12 %14 OpStore %16 %12 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Add synonym fact relating %50 and %12. transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(50, 12)); // Add synonym fact relating %51 and %14. transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(51, 14)); // Not legal because the index being replaced is a struct index. ASSERT_FALSE( TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 12, MakeInstructionDescriptor(16, spv::Op::OpAccessChain, 0), 1), 50) .IsApplicable(context.get(), transformation_context)); // Fine to replace an index into a runtime array. auto replacement1 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 12, MakeInstructionDescriptor(16, spv::Op::OpAccessChain, 0), 2), 50); ASSERT_TRUE(replacement1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(replacement1, context.get(), &transformation_context); // Fine to replace an index into a vector inside the runtime array. auto replacement2 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 14, MakeInstructionDescriptor(16, spv::Op::OpAccessChain, 0), 3), 51); ASSERT_TRUE(replacement2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(replacement2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); const std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %8 ArrayStride 8 OpMemberDecorate %9 0 Offset 0 OpDecorate %9 BufferBlock OpDecorate %11 DescriptorSet 0 OpDecorate %11 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeVector %6 2 %8 = OpTypeRuntimeArray %7 %9 = OpTypeStruct %8 %10 = OpTypePointer Uniform %9 %11 = OpVariable %10 Uniform %12 = OpConstant %6 0 %13 = OpTypeInt 32 0 %14 = OpConstant %13 0 %15 = OpTypePointer Uniform %6 %4 = OpFunction %2 None %3 %5 = OpLabel %50 = OpCopyObject %6 %12 %51 = OpCopyObject %13 %14 %16 = OpAccessChain %15 %11 %12 %50 %51 OpStore %16 %12 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationReplaceIdWithSynonymTest, DoNotReplaceSampleParameterOfOpImageTexelPointer) { const std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpConstant %6 2 %9 = OpConstant %6 0 %10 = OpConstant %6 10 %11 = OpTypeBool %12 = OpConstant %6 1 %13 = OpTypeFloat 32 %14 = OpTypePointer Image %13 %15 = OpTypeImage %13 2D 0 0 0 0 Rgba8 %16 = OpTypePointer Private %15 %3 = OpVariable %16 Private %17 = OpTypeVector %6 2 %18 = OpConstantComposite %17 %9 %9 %2 = OpFunction %4 None %5 %19 = OpLabel %100 = OpCopyObject %6 %9 %20 = OpImageTexelPointer %14 %3 %18 %9 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Add synonym fact relating %100 and %9. transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(100, 9)); // Not legal the Sample argument of OpImageTexelPointer needs to be a zero // constant. ASSERT_FALSE( TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 9, MakeInstructionDescriptor(20, spv::Op::OpImageTexelPointer, 0), 2), 100) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationReplaceIdWithSynonymTest, EquivalentIntegerConstants) { // This checks that replacing an integer constant with an equivalent one with // different signedness is allowed only when valid. const std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" OpName %3 "a" OpDecorate %3 RelaxedPrecision %4 = OpTypeVoid %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpTypeFunction %4 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %10 = OpConstant %8 1 %11 = OpTypeInt 32 0 %12 = OpTypePointer Function %11 %13 = OpConstant %11 1 %2 = OpFunction %4 None %7 %14 = OpLabel %3 = OpVariable %9 Function %15 = OpSNegate %8 %10 %16 = OpIAdd %8 %10 %10 %17 = OpSDiv %8 %10 %10 %18 = OpUDiv %11 %13 %13 %19 = OpBitwiseAnd %8 %10 %10 %20 = OpSelect %8 %6 %10 %17 %21 = OpIEqual %5 %10 %10 OpStore %3 %10 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Add synonym fact relating %10 and %13 (equivalent integer constant with // different signedness). transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(10, 13)); // Legal because OpSNegate always considers the integer as signed auto replacement1 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 10, MakeInstructionDescriptor(15, spv::Op::OpSNegate, 0), 0), 13); ASSERT_TRUE(replacement1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(replacement1, context.get(), &transformation_context); // Legal because OpIAdd does not care about the signedness of the operands auto replacement2 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor(10, MakeInstructionDescriptor(16, spv::Op::OpIAdd, 0), 0), 13); ASSERT_TRUE(replacement2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(replacement2, context.get(), &transformation_context); // Legal because OpSDiv does not care about the signedness of the operands auto replacement3 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor(10, MakeInstructionDescriptor(17, spv::Op::OpSDiv, 0), 0), 13); ASSERT_TRUE(replacement3.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(replacement3, context.get(), &transformation_context); // Not legal because OpUDiv requires unsigned integers ASSERT_FALSE( TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 13, MakeInstructionDescriptor(18, spv::Op::OpUDiv, 0), 0), 10) .IsApplicable(context.get(), transformation_context)); // Legal because OpSDiv does not care about the signedness of the operands auto replacement4 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 10, MakeInstructionDescriptor(19, spv::Op::OpBitwiseAnd, 0), 0), 13); ASSERT_TRUE(replacement4.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(replacement4, context.get(), &transformation_context); // Not legal because OpSelect requires both operands to have the same type as // the result type ASSERT_FALSE( TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 10, MakeInstructionDescriptor(20, spv::Op::OpUDiv, 0), 1), 13) .IsApplicable(context.get(), transformation_context)); // Not legal because OpStore requires the object to match the type pointed // to by the pointer. ASSERT_FALSE( TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 10, MakeInstructionDescriptor(21, spv::Op::OpStore, 0), 1), 13) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); const std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" OpName %3 "a" OpDecorate %3 RelaxedPrecision %4 = OpTypeVoid %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpTypeFunction %4 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %10 = OpConstant %8 1 %11 = OpTypeInt 32 0 %12 = OpTypePointer Function %11 %13 = OpConstant %11 1 %2 = OpFunction %4 None %7 %14 = OpLabel %3 = OpVariable %9 Function %15 = OpSNegate %8 %13 %16 = OpIAdd %8 %13 %10 %17 = OpSDiv %8 %13 %10 %18 = OpUDiv %11 %13 %13 %19 = OpBitwiseAnd %8 %13 %10 %20 = OpSelect %8 %6 %10 %17 %21 = OpIEqual %5 %10 %10 OpStore %3 %10 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationReplaceIdWithSynonymTest, EquivalentIntegerVectorConstants) { // This checks that replacing an integer constant with an equivalent one with // different signedness is allowed only when valid. const std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" OpName %3 "a" OpDecorate %3 RelaxedPrecision OpDecorate %4 RelaxedPrecision %5 = OpTypeVoid %6 = OpTypeFunction %5 %7 = OpTypeInt 32 1 %8 = OpTypeInt 32 0 %9 = OpTypeVector %7 4 %10 = OpTypeVector %8 4 %11 = OpTypePointer Function %9 %12 = OpConstant %7 1 %13 = OpConstant %8 1 %14 = OpConstantComposite %9 %12 %12 %12 %12 %15 = OpConstantComposite %10 %13 %13 %13 %13 %16 = OpTypePointer Function %7 %2 = OpFunction %5 None %6 %17 = OpLabel %3 = OpVariable %11 Function %18 = OpIAdd %9 %14 %14 OpStore %3 %14 %19 = OpAccessChain %16 %3 %13 %4 = OpLoad %7 %19 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Add synonym fact relating %10 and %13 (equivalent integer vectors with // different signedness). transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(14, 15)); // Legal because OpIAdd does not consider the signedness of the operands auto replacement1 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor(14, MakeInstructionDescriptor(18, spv::Op::OpIAdd, 0), 0), 15); ASSERT_TRUE(replacement1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(replacement1, context.get(), &transformation_context); // Not legal because OpStore requires the object to match the type pointed // to by the pointer. ASSERT_FALSE( TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 14, MakeInstructionDescriptor(18, spv::Op::OpStore, 0), 1), 15) .IsApplicable(context.get(), transformation_context)); // Add synonym fact relating %12 and %13 (equivalent integer constants with // different signedness). transformation_context.GetFactManager()->MaybeAddFact( MakeSynonymFact(12, 13)); // Legal because the indices of OpAccessChain are always treated as signed auto replacement2 = TransformationReplaceIdWithSynonym( MakeIdUseDescriptor( 13, MakeInstructionDescriptor(19, spv::Op::OpAccessChain, 0), 1), 12); ASSERT_TRUE(replacement2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(replacement2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); const std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" OpName %3 "a" OpDecorate %3 RelaxedPrecision OpDecorate %4 RelaxedPrecision %5 = OpTypeVoid %6 = OpTypeFunction %5 %7 = OpTypeInt 32 1 %8 = OpTypeInt 32 0 %9 = OpTypeVector %7 4 %10 = OpTypeVector %8 4 %11 = OpTypePointer Function %9 %12 = OpConstant %7 1 %13 = OpConstant %8 1 %14 = OpConstantComposite %9 %12 %12 %12 %12 %15 = OpConstantComposite %10 %13 %13 %13 %13 %16 = OpTypePointer Function %7 %2 = OpFunction %5 None %6 %17 = OpLabel %3 = OpVariable %11 Function %18 = OpIAdd %9 %15 %14 OpStore %3 %14 %19 = OpAccessChain %16 %3 %12 %4 = OpLoad %7 %19 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationReplaceIdWithSynonymTest, IncompatibleTypes) { const std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %5 = OpTypeVoid %6 = OpTypeFunction %5 %7 = OpTypeInt 32 1 %8 = OpTypeInt 32 0 %9 = OpTypeFloat 32 %12 = OpConstant %7 1 %13 = OpConstant %8 1 %10 = OpConstant %9 1 %2 = OpFunction %5 None %6 %17 = OpLabel %18 = OpIAdd %7 %12 %13 %19 = OpFAdd %9 %10 %10 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto* op_i_add = context->get_def_use_mgr()->GetDef(18); ASSERT_TRUE(op_i_add); auto* op_f_add = context->get_def_use_mgr()->GetDef(19); ASSERT_TRUE(op_f_add); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(12, {}), MakeDataDescriptor(13, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(12, {}), MakeDataDescriptor(10, {})); // Synonym differs only in signedness for OpIAdd. ASSERT_TRUE(TransformationReplaceIdWithSynonym( MakeIdUseDescriptorFromUse(context.get(), op_i_add, 0), 13) .IsApplicable(context.get(), transformation_context)); // Synonym has wrong type for OpIAdd. ASSERT_FALSE(TransformationReplaceIdWithSynonym( MakeIdUseDescriptorFromUse(context.get(), op_i_add, 0), 10) .IsApplicable(context.get(), transformation_context)); // Synonym has wrong type for OpFAdd. ASSERT_FALSE(TransformationReplaceIdWithSynonym( MakeIdUseDescriptorFromUse(context.get(), op_f_add, 0), 12) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationReplaceIdWithSynonym( MakeIdUseDescriptorFromUse(context.get(), op_f_add, 0), 13) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationReplaceIdWithSynonymTest, AtomicScopeAndMemorySemanticsMustBeConstant) { const std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 320 OpSourceExtension "GL_KHR_memory_scope_semantics" OpMemberDecorate %9 0 Offset 0 OpDecorate %9 Block OpDecorate %11 DescriptorSet 0 OpDecorate %11 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %17 = OpTypeInt 32 0 %7 = OpTypePointer Function %6 %9 = OpTypeStruct %6 %10 = OpTypePointer StorageBuffer %9 %11 = OpVariable %10 StorageBuffer %86 = OpTypeStruct %17 %87 = OpTypePointer Workgroup %86 %88 = OpVariable %87 Workgroup %12 = OpConstant %6 0 %13 = OpTypePointer StorageBuffer %6 %15 = OpConstant %6 2 %16 = OpConstant %6 64 %89 = OpTypePointer Workgroup %17 %18 = OpConstant %17 1 %19 = OpConstant %17 0 %20 = OpConstant %17 64 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %100 = OpCopyObject %6 %15 ; A non-constant version of %15 %101 = OpCopyObject %17 %20 ; A non-constant version of %20 %14 = OpAccessChain %13 %11 %12 %90 = OpAccessChain %89 %88 %19 %21 = OpAtomicLoad %6 %14 %15 %20 %22 = OpAtomicExchange %6 %14 %15 %20 %16 %23 = OpAtomicCompareExchange %6 %14 %15 %20 %12 %16 %15 %24 = OpAtomicIIncrement %6 %14 %15 %20 %25 = OpAtomicIDecrement %6 %14 %15 %20 %26 = OpAtomicIAdd %6 %14 %15 %20 %16 %27 = OpAtomicISub %6 %14 %15 %20 %16 %28 = OpAtomicSMin %6 %14 %15 %20 %16 %29 = OpAtomicUMin %17 %90 %15 %20 %18 %30 = OpAtomicSMax %6 %14 %15 %20 %15 %31 = OpAtomicUMax %17 %90 %15 %20 %18 %32 = OpAtomicAnd %6 %14 %15 %20 %16 %33 = OpAtomicOr %6 %14 %15 %20 %16 %34 = OpAtomicXor %6 %14 %15 %20 %16 OpStore %8 %21 OpAtomicStore %14 %15 %20 %12 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Tell the fact manager that %100 and %15 are synonymous transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(100, {}), MakeDataDescriptor(15, {})); // Tell the fact manager that %101 and %20 are synonymous transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(101, {}), MakeDataDescriptor(20, {})); // OpAtomicLoad const auto& scope_operand = MakeIdUseDescriptorFromUse( context.get(), context->get_def_use_mgr()->GetDef(21), 1); ASSERT_FALSE(TransformationReplaceIdWithSynonym(scope_operand, 100) .IsApplicable(context.get(), transformation_context)); const auto& semantics_operand = MakeIdUseDescriptorFromUse( context.get(), context->get_def_use_mgr()->GetDef(21), 2); ASSERT_FALSE(TransformationReplaceIdWithSynonym(semantics_operand, 101) .IsApplicable(context.get(), transformation_context)); // OpAtomicExchange. const auto& scope_operand2 = MakeIdUseDescriptorFromUse( context.get(), context->get_def_use_mgr()->GetDef(22), 1); ASSERT_FALSE(TransformationReplaceIdWithSynonym(scope_operand2, 100) .IsApplicable(context.get(), transformation_context)); const auto& semantics_operand2 = MakeIdUseDescriptorFromUse( context.get(), context->get_def_use_mgr()->GetDef(22), 2); ASSERT_FALSE(TransformationReplaceIdWithSynonym(semantics_operand2, 101) .IsApplicable(context.get(), transformation_context)); // OpAtomicCompareExchange. const auto& scope_operand3 = MakeIdUseDescriptorFromUse( context.get(), context->get_def_use_mgr()->GetDef(23), 1); ASSERT_FALSE(TransformationReplaceIdWithSynonym(scope_operand3, 100) .IsApplicable(context.get(), transformation_context)); const auto& semantics_equal_operand3 = MakeIdUseDescriptorFromUse( context.get(), context->get_def_use_mgr()->GetDef(23), 2); ASSERT_FALSE(TransformationReplaceIdWithSynonym(semantics_equal_operand3, 101) .IsApplicable(context.get(), transformation_context)); const auto& semantics_unequal_operand3 = MakeIdUseDescriptorFromUse( context.get(), context->get_def_use_mgr()->GetDef(23), 3); ASSERT_FALSE( TransformationReplaceIdWithSynonym(semantics_unequal_operand3, 101) .IsApplicable(context.get(), transformation_context)); // OpAtomicIIncrement. const auto& scope_operand4 = MakeIdUseDescriptorFromUse( context.get(), context->get_def_use_mgr()->GetDef(24), 1); ASSERT_FALSE(TransformationReplaceIdWithSynonym(scope_operand4, 100) .IsApplicable(context.get(), transformation_context)); const auto& semantics_operand4 = MakeIdUseDescriptorFromUse( context.get(), context->get_def_use_mgr()->GetDef(24), 2); ASSERT_FALSE(TransformationReplaceIdWithSynonym(semantics_operand4, 101) .IsApplicable(context.get(), transformation_context)); // OpAtomicIDecrement. const auto& scope_operand5 = MakeIdUseDescriptorFromUse( context.get(), context->get_def_use_mgr()->GetDef(25), 1); ASSERT_FALSE(TransformationReplaceIdWithSynonym(scope_operand5, 100) .IsApplicable(context.get(), transformation_context)); const auto& semantics_operand5 = MakeIdUseDescriptorFromUse( context.get(), context->get_def_use_mgr()->GetDef(25), 2); ASSERT_FALSE(TransformationReplaceIdWithSynonym(semantics_operand5, 101) .IsApplicable(context.get(), transformation_context)); // OpAtomicIAdd. const auto& scope_operand6 = MakeIdUseDescriptorFromUse( context.get(), context->get_def_use_mgr()->GetDef(26), 1); ASSERT_FALSE(TransformationReplaceIdWithSynonym(scope_operand6, 100) .IsApplicable(context.get(), transformation_context)); const auto& semantics_operand6 = MakeIdUseDescriptorFromUse( context.get(), context->get_def_use_mgr()->GetDef(26), 2); ASSERT_FALSE(TransformationReplaceIdWithSynonym(semantics_operand6, 101) .IsApplicable(context.get(), transformation_context)); // OpAtomicISub const auto& scope_operand8 = MakeIdUseDescriptorFromUse( context.get(), context->get_def_use_mgr()->GetDef(27), 1); ASSERT_FALSE(TransformationReplaceIdWithSynonym(scope_operand8, 100) .IsApplicable(context.get(), transformation_context)); const auto& semantics_operand8 = MakeIdUseDescriptorFromUse( context.get(), context->get_def_use_mgr()->GetDef(27), 2); ASSERT_FALSE(TransformationReplaceIdWithSynonym(semantics_operand8, 101) .IsApplicable(context.get(), transformation_context)); // OpAtomicSMin const auto& scope_operand9 = MakeIdUseDescriptorFromUse( context.get(), context->get_def_use_mgr()->GetDef(28), 1); ASSERT_FALSE(TransformationReplaceIdWithSynonym(scope_operand9, 100) .IsApplicable(context.get(), transformation_context)); const auto& semantics_operand9 = MakeIdUseDescriptorFromUse( context.get(), context->get_def_use_mgr()->GetDef(28), 2); ASSERT_FALSE(TransformationReplaceIdWithSynonym(semantics_operand9, 101) .IsApplicable(context.get(), transformation_context)); // OpAtomicUMin const auto& scope_operand10 = MakeIdUseDescriptorFromUse( context.get(), context->get_def_use_mgr()->GetDef(29), 1); ASSERT_FALSE(TransformationReplaceIdWithSynonym(scope_operand10, 100) .IsApplicable(context.get(), transformation_context)); const auto& semantics_operand10 = MakeIdUseDescriptorFromUse( context.get(), context->get_def_use_mgr()->GetDef(29), 2); ASSERT_FALSE(TransformationReplaceIdWithSynonym(semantics_operand10, 101) .IsApplicable(context.get(), transformation_context)); // OpAtomicSMax const auto& scope_operand11 = MakeIdUseDescriptorFromUse( context.get(), context->get_def_use_mgr()->GetDef(30), 1); ASSERT_FALSE(TransformationReplaceIdWithSynonym(scope_operand11, 100) .IsApplicable(context.get(), transformation_context)); const auto& semantics_operand11 = MakeIdUseDescriptorFromUse( context.get(), context->get_def_use_mgr()->GetDef(30), 2); ASSERT_FALSE(TransformationReplaceIdWithSynonym(semantics_operand11, 101) .IsApplicable(context.get(), transformation_context)); // OpAtomicUMax const auto& scope_operand12 = MakeIdUseDescriptorFromUse( context.get(), context->get_def_use_mgr()->GetDef(31), 1); ASSERT_FALSE(TransformationReplaceIdWithSynonym(scope_operand12, 100) .IsApplicable(context.get(), transformation_context)); const auto& semantics_operand12 = MakeIdUseDescriptorFromUse( context.get(), context->get_def_use_mgr()->GetDef(31), 2); ASSERT_FALSE(TransformationReplaceIdWithSynonym(semantics_operand12, 101) .IsApplicable(context.get(), transformation_context)); // OpAtomicAnd const auto& scope_operand13 = MakeIdUseDescriptorFromUse( context.get(), context->get_def_use_mgr()->GetDef(32), 1); ASSERT_FALSE(TransformationReplaceIdWithSynonym(scope_operand13, 100) .IsApplicable(context.get(), transformation_context)); const auto& semantics_operand13 = MakeIdUseDescriptorFromUse( context.get(), context->get_def_use_mgr()->GetDef(32), 2); ASSERT_FALSE(TransformationReplaceIdWithSynonym(semantics_operand13, 101) .IsApplicable(context.get(), transformation_context)); // OpAtomicOr const auto& scope_operand14 = MakeIdUseDescriptorFromUse( context.get(), context->get_def_use_mgr()->GetDef(33), 1); ASSERT_FALSE(TransformationReplaceIdWithSynonym(scope_operand14, 100) .IsApplicable(context.get(), transformation_context)); const auto& semantics_operand14 = MakeIdUseDescriptorFromUse( context.get(), context->get_def_use_mgr()->GetDef(33), 2); ASSERT_FALSE(TransformationReplaceIdWithSynonym(semantics_operand14, 101) .IsApplicable(context.get(), transformation_context)); // OpAtomicXor const auto& scope_operand15 = MakeIdUseDescriptorFromUse( context.get(), context->get_def_use_mgr()->GetDef(34), 1); ASSERT_FALSE(TransformationReplaceIdWithSynonym(scope_operand15, 100) .IsApplicable(context.get(), transformation_context)); const auto& semantics_operand15 = MakeIdUseDescriptorFromUse( context.get(), context->get_def_use_mgr()->GetDef(34), 2); ASSERT_FALSE(TransformationReplaceIdWithSynonym(semantics_operand15, 101) .IsApplicable(context.get(), transformation_context)); } // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/4345): Improve this // test so that it covers more atomic operations, and enable the test once the // issue is fixed. TEST(TransformationReplaceIdWithSynonymTest, DISABLED_SignOfAtomicScopeAndMemorySemanticsDoesNotMatter) { // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/4345): both the // GLSL comment and the corresponding SPIR-V should be updated to cover a // larger number of atomic operations. // The following SPIR-V came from this GLSL, edited to add some synonyms: // // #version 320 es // // #extension GL_KHR_memory_scope_semantics : enable // // layout(set = 0, binding = 0) buffer Buf { // int x; // }; // // void main() { // int tmp = atomicLoad(x, // gl_ScopeWorkgroup, // gl_StorageSemanticsBuffer, // gl_SemanticsRelaxed); // } const std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 320 OpSourceExtension "GL_KHR_memory_scope_semantics" OpMemberDecorate %9 0 Offset 0 OpDecorate %9 Block OpDecorate %11 DescriptorSet 0 OpDecorate %11 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpTypeStruct %6 %10 = OpTypePointer StorageBuffer %9 %11 = OpVariable %10 StorageBuffer %12 = OpConstant %6 0 %13 = OpTypePointer StorageBuffer %6 %15 = OpConstant %6 2 %16 = OpConstant %6 64 %17 = OpTypeInt 32 0 %100 = OpConstant %17 2 ; The same as %15, but with unsigned int type %18 = OpConstant %17 1 %19 = OpConstant %17 0 %20 = OpConstant %17 64 %101 = OpConstant %6 64 ; The same as %20, but with signed int type %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %14 = OpAccessChain %13 %11 %12 %21 = OpAtomicLoad %6 %14 %15 %20 OpStore %8 %21 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Tell the fact manager that %100 and %15 are synonymous transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(100, {}), MakeDataDescriptor(15, {})); // Tell the fact manager that %101 and %20 are synonymous transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(101, {}), MakeDataDescriptor(20, {})); { const auto& scope_operand = MakeIdUseDescriptorFromUse( context.get(), context->get_def_use_mgr()->GetDef(21), 1); TransformationReplaceIdWithSynonym replace_scope(scope_operand, 100); ASSERT_TRUE( replace_scope.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(replace_scope, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } { const auto& semantics_operand = MakeIdUseDescriptorFromUse( context.get(), context->get_def_use_mgr()->GetDef(21), 2); TransformationReplaceIdWithSynonym replace_semantics(semantics_operand, 101); ASSERT_TRUE( replace_semantics.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(replace_semantics, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } const std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 320 OpSourceExtension "GL_KHR_memory_scope_semantics" OpMemberDecorate %9 0 Offset 0 OpDecorate %9 Block OpDecorate %11 DescriptorSet 0 OpDecorate %11 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpTypeStruct %6 %10 = OpTypePointer StorageBuffer %9 %11 = OpVariable %10 StorageBuffer %12 = OpConstant %6 0 %13 = OpTypePointer StorageBuffer %6 %15 = OpConstant %6 2 %16 = OpConstant %6 64 %17 = OpTypeInt 32 0 %100 = OpConstant %17 2 %18 = OpConstant %17 1 %19 = OpConstant %17 0 %20 = OpConstant %17 64 %101 = OpConstant %6 64 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %14 = OpAccessChain %13 %11 %12 %21 = OpAtomicLoad %6 %14 %100 %101 OpStore %8 %21 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_replace_irrelevant_id_test.cpp000066400000000000000000000316221475742701700317250ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_replace_irrelevant_id.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/id_use_descriptor.h" #include "source/fuzz/instruction_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { const std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" OpName %3 "a" OpName %4 "b" %5 = OpTypeVoid %6 = OpTypeFunction %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %9 = OpTypeInt 32 1 %10 = OpTypePointer Function %9 %11 = OpConstant %9 2 %12 = OpTypeStruct %9 %13 = OpTypeInt 32 0 %14 = OpConstant %13 3 %15 = OpTypeArray %12 %14 %16 = OpTypePointer Function %15 %17 = OpConstant %9 0 %2 = OpFunction %5 None %6 %18 = OpLabel %3 = OpVariable %10 Function %4 = OpVariable %10 Function %19 = OpVariable %16 Function OpStore %3 %11 %20 = OpLoad %9 %3 %21 = OpAccessChain %10 %19 %20 %17 %22 = OpLoad %9 %21 OpStore %4 %22 %23 = OpLoad %9 %4 %24 = OpIAdd %9 %20 %23 %25 = OpISub %9 %23 %20 OpReturn OpFunctionEnd )"; void SetUpIrrelevantIdFacts(FactManager* fact_manager) { fact_manager->AddFactIdIsIrrelevant(17); fact_manager->AddFactIdIsIrrelevant(23); fact_manager->AddFactIdIsIrrelevant(24); fact_manager->AddFactIdIsIrrelevant(25); } TEST(TransformationReplaceIrrelevantIdTest, Inapplicable) { const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); SetUpIrrelevantIdFacts(transformation_context.GetFactManager()); auto instruction_21_descriptor = MakeInstructionDescriptor(21, spv::Op::OpAccessChain, 0); auto instruction_24_descriptor = MakeInstructionDescriptor(24, spv::Op::OpIAdd, 0); // %20 has not been declared as irrelevant. ASSERT_FALSE(TransformationReplaceIrrelevantId( MakeIdUseDescriptor(20, instruction_24_descriptor, 0), 23) .IsApplicable(context.get(), transformation_context)); // %22 is not used in %24. ASSERT_FALSE(TransformationReplaceIrrelevantId( MakeIdUseDescriptor(22, instruction_24_descriptor, 1), 20) .IsApplicable(context.get(), transformation_context)); // Replacement id %50 does not exist. ASSERT_FALSE(TransformationReplaceIrrelevantId( MakeIdUseDescriptor(23, instruction_24_descriptor, 1), 50) .IsApplicable(context.get(), transformation_context)); // %25 is not available to use at %24. ASSERT_FALSE(TransformationReplaceIrrelevantId( MakeIdUseDescriptor(23, instruction_24_descriptor, 1), 25) .IsApplicable(context.get(), transformation_context)); // %24 is not available to use at %24. ASSERT_FALSE(TransformationReplaceIrrelevantId( MakeIdUseDescriptor(23, instruction_24_descriptor, 1), 24) .IsApplicable(context.get(), transformation_context)); // %8 has not the same type as %23. ASSERT_FALSE(TransformationReplaceIrrelevantId( MakeIdUseDescriptor(23, instruction_24_descriptor, 1), 8) .IsApplicable(context.get(), transformation_context)); // %17 is an index to a struct in an access chain, so it can't be replaced. ASSERT_FALSE(TransformationReplaceIrrelevantId( MakeIdUseDescriptor(17, instruction_21_descriptor, 2), 20) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationReplaceIrrelevantIdTest, Apply) { const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); SetUpIrrelevantIdFacts(transformation_context.GetFactManager()); auto instruction_24_descriptor = MakeInstructionDescriptor(24, spv::Op::OpIAdd, 0); // Replace the use of %23 in %24 with %22. auto transformation = TransformationReplaceIrrelevantId( MakeIdUseDescriptor(23, instruction_24_descriptor, 1), 22); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" OpName %3 "a" OpName %4 "b" %5 = OpTypeVoid %6 = OpTypeFunction %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %9 = OpTypeInt 32 1 %10 = OpTypePointer Function %9 %11 = OpConstant %9 2 %12 = OpTypeStruct %9 %13 = OpTypeInt 32 0 %14 = OpConstant %13 3 %15 = OpTypeArray %12 %14 %16 = OpTypePointer Function %15 %17 = OpConstant %9 0 %2 = OpFunction %5 None %6 %18 = OpLabel %3 = OpVariable %10 Function %4 = OpVariable %10 Function %19 = OpVariable %16 Function OpStore %3 %11 %20 = OpLoad %9 %3 %21 = OpAccessChain %10 %19 %20 %17 %22 = OpLoad %9 %21 OpStore %4 %22 %23 = OpLoad %9 %4 %24 = OpIAdd %9 %20 %22 %25 = OpISub %9 %23 %20 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationReplaceIrrelevantIdTest, DoNotReplaceVariableInitializerWithNonConstant) { // Checks that it is not possible to replace the initializer of a variable // with a non-constant id (such as a function parameter). const std::string reference_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %2 %6 %13 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %10 = OpFunction %2 None %8 %9 = OpFunctionParameter %6 %11 = OpLabel %12 = OpVariable %7 Function %13 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactIdIsIrrelevant(13); // We cannot replace the use of %13 in the initializer of %12 with %9 because // %9 is not a constant. ASSERT_FALSE( TransformationReplaceIrrelevantId( MakeIdUseDescriptor( 13, MakeInstructionDescriptor(12, spv::Op::OpVariable, 0), 1), 9) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationReplaceIrrelevantIdTest, DoNotReplaceIrrelevantIdWithOpFunction) { // Checks that an OpFunction result id is not allowed to be used to replace an // irrelevant id. const std::string reference_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeFunction %6 %13 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %20 = OpCopyObject %6 %13 %21 = OpCopyObject %6 %20 OpReturn OpFunctionEnd %10 = OpFunction %6 None %7 %11 = OpLabel OpReturnValue %13 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactIdIsIrrelevant(20); // We cannot replace the use of %20 in by %21 with %10 because %10 is an // OpFunction instruction. ASSERT_FALSE( TransformationReplaceIrrelevantId( MakeIdUseDescriptor( 20, MakeInstructionDescriptor(21, spv::Op::OpCopyObject, 0), 0), 10) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationReplaceIrrelevantIdTest, OpAccessChainIrrelevantIndex) { // Checks that we can't replace irrelevant index operands in OpAccessChain. const std::string reference_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeVector %6 2 %8 = OpTypePointer Function %7 %10 = OpConstant %6 0 %11 = OpConstant %6 2 %13 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %5 = OpLabel %9 = OpVariable %8 Function %12 = OpAccessChain %13 %9 %10 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactIdIsIrrelevant(10); // We cannot replace the use of %10 in %12 with %11 because %10 is an // irrelevant id. ASSERT_FALSE( TransformationReplaceIrrelevantId( MakeIdUseDescriptor( 10, MakeInstructionDescriptor(12, spv::Op::OpAccessChain, 0), 1), 11) .IsApplicable(context.get(), transformation_context)); } } // namespace } // namespace fuzz } // namespace spvtools transformation_replace_linear_algebra_instruction_test.cpp000066400000000000000000002750751475742701700344230ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/fuzz// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_replace_linear_algebra_instruction.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationReplaceLinearAlgebraInstructionTest, IsApplicable) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %22 "main" OpExecutionMode %22 OriginUpperLeft OpSource ESSL 310 OpName %22 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeFloat 32 %5 = OpTypeVector %4 2 %6 = OpTypeVector %4 3 %7 = OpTypeVector %4 4 %8 = OpConstant %4 1 %9 = OpConstant %4 2 %10 = OpConstant %4 3 %11 = OpConstant %4 4 %12 = OpConstant %4 5 %13 = OpConstant %4 6 %14 = OpConstant %4 7 %15 = OpConstant %4 8 %16 = OpConstantComposite %5 %8 %9 %17 = OpConstantComposite %5 %10 %11 %18 = OpConstantComposite %6 %8 %9 %10 %19 = OpConstantComposite %6 %11 %12 %13 %20 = OpConstantComposite %7 %8 %9 %10 %11 %21 = OpConstantComposite %7 %12 %13 %14 %15 %22 = OpFunction %2 None %3 %23 = OpLabel %24 = OpDot %4 %16 %17 %25 = OpDot %4 %18 %19 %26 = OpDot %4 %20 %21 %27 = OpVectorTimesScalar %5 %16 %8 %28 = OpVectorTimesScalar %6 %18 %9 %29 = OpVectorTimesScalar %7 %20 %10 %30 = OpCopyObject %4 %24 %31 = OpFAdd %4 %8 %9 %32 = OpFMul %4 %10 %11 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Tests linear algebra instructions. auto instruction_descriptor = MakeInstructionDescriptor(24, spv::Op::OpDot, 0); auto transformation = TransformationReplaceLinearAlgebraInstruction( {33, 34, 35, 36, 37, 38}, instruction_descriptor); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); instruction_descriptor = MakeInstructionDescriptor(27, spv::Op::OpVectorTimesScalar, 0); transformation = TransformationReplaceLinearAlgebraInstruction( {33, 34, 35, 36}, instruction_descriptor); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); // Tests non-linear algebra instructions. instruction_descriptor = MakeInstructionDescriptor(30, spv::Op::OpCopyObject, 0); transformation = TransformationReplaceLinearAlgebraInstruction( {33, 34, 35, 36, 37, 38}, instruction_descriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); instruction_descriptor = MakeInstructionDescriptor(31, spv::Op::OpFAdd, 0); transformation = TransformationReplaceLinearAlgebraInstruction( {33, 34, 35, 36, 37}, instruction_descriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); instruction_descriptor = MakeInstructionDescriptor(32, spv::Op::OpFMul, 0); transformation = TransformationReplaceLinearAlgebraInstruction( {33, 34, 35, 36}, instruction_descriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests number of fresh ids is different than necessary. instruction_descriptor = MakeInstructionDescriptor(25, spv::Op::OpDot, 0); transformation = TransformationReplaceLinearAlgebraInstruction( {33, 34, 35, 36}, instruction_descriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); instruction_descriptor = MakeInstructionDescriptor(28, spv::Op::OpVectorTimesScalar, 0); transformation = TransformationReplaceLinearAlgebraInstruction( {33, 34, 35, 36, 37, 38, 39}, instruction_descriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests non-fresh ids. instruction_descriptor = MakeInstructionDescriptor(26, spv::Op::OpDot, 0); transformation = TransformationReplaceLinearAlgebraInstruction( {33, 34, 5, 36, 37, 8, 39, 40, 1, 42, 3, 44, 45, 46}, instruction_descriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); instruction_descriptor = MakeInstructionDescriptor(29, spv::Op::OpVectorTimesScalar, 0); transformation = TransformationReplaceLinearAlgebraInstruction( {33, 34, 35, 36, 7, 38, 9, 40}, instruction_descriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationReplaceLinearAlgebraInstructionTest, ReplaceOpTranspose) { std::string reference_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %54 "main" ; Types %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeFloat 32 %5 = OpTypeVector %4 2 %6 = OpTypeVector %4 3 %7 = OpTypeVector %4 4 %8 = OpTypeMatrix %5 2 %9 = OpTypeMatrix %5 3 %10 = OpTypeMatrix %5 4 %11 = OpTypeMatrix %6 2 %12 = OpTypeMatrix %6 3 %13 = OpTypeMatrix %6 4 %14 = OpTypeMatrix %7 2 %15 = OpTypeMatrix %7 3 %16 = OpTypeMatrix %7 4 ; Constant scalars %17 = OpConstant %4 1 %18 = OpConstant %4 2 %19 = OpConstant %4 3 %20 = OpConstant %4 4 %21 = OpConstant %4 5 %22 = OpConstant %4 6 %23 = OpConstant %4 7 %24 = OpConstant %4 8 %25 = OpConstant %4 9 %26 = OpConstant %4 10 %27 = OpConstant %4 11 %28 = OpConstant %4 12 %29 = OpConstant %4 13 %30 = OpConstant %4 14 %31 = OpConstant %4 15 %32 = OpConstant %4 16 ; Constant vectors %33 = OpConstantComposite %5 %17 %18 %34 = OpConstantComposite %5 %19 %20 %35 = OpConstantComposite %5 %21 %22 %36 = OpConstantComposite %5 %23 %24 %37 = OpConstantComposite %6 %17 %18 %19 %38 = OpConstantComposite %6 %20 %21 %22 %39 = OpConstantComposite %6 %23 %24 %25 %40 = OpConstantComposite %6 %26 %27 %28 %41 = OpConstantComposite %7 %17 %18 %19 %20 %42 = OpConstantComposite %7 %21 %22 %23 %24 %43 = OpConstantComposite %7 %25 %26 %27 %28 %44 = OpConstantComposite %7 %29 %30 %31 %32 ; Constant matrices %45 = OpConstantComposite %8 %33 %34 %46 = OpConstantComposite %9 %33 %34 %35 %47 = OpConstantComposite %10 %33 %34 %35 %36 %48 = OpConstantComposite %11 %37 %38 %49 = OpConstantComposite %12 %37 %38 %39 %50 = OpConstantComposite %13 %37 %38 %39 %40 %51 = OpConstantComposite %14 %41 %42 %52 = OpConstantComposite %15 %41 %42 %43 %53 = OpConstantComposite %16 %41 %42 %43 %44 ; main function %54 = OpFunction %2 None %3 %55 = OpLabel ; Transposing a 2x2 matrix %56 = OpTranspose %8 %45 ; Transposing a 2x3 matrix %57 = OpTranspose %11 %46 ; Transposing a 2x4 matrix %58 = OpTranspose %14 %47 ; Transposing a 3x2 matrix %59 = OpTranspose %9 %48 ; Transposing a 3x3 matrix %60 = OpTranspose %12 %49 ; Transposing a 3x4 matrix %61 = OpTranspose %15 %50 ; Transposing a 4x2 matrix %62 = OpTranspose %10 %51 ; Transposing a 4x3 matrix %63 = OpTranspose %13 %52 ; Transposing a 4x4 matrix %64 = OpTranspose %16 %53 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto instruction_descriptor = MakeInstructionDescriptor(56, spv::Op::OpTranspose, 0); auto transformation = TransformationReplaceLinearAlgebraInstruction( {65, 66, 67, 68, 69, 70, 71, 72, 73, 74}, instruction_descriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); instruction_descriptor = MakeInstructionDescriptor(57, spv::Op::OpTranspose, 0); transformation = TransformationReplaceLinearAlgebraInstruction( {75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88}, instruction_descriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); instruction_descriptor = MakeInstructionDescriptor(58, spv::Op::OpTranspose, 0); transformation = TransformationReplaceLinearAlgebraInstruction( {89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106}, instruction_descriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); instruction_descriptor = MakeInstructionDescriptor(59, spv::Op::OpTranspose, 0); transformation = TransformationReplaceLinearAlgebraInstruction( {107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121}, instruction_descriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); instruction_descriptor = MakeInstructionDescriptor(60, spv::Op::OpTranspose, 0); transformation = TransformationReplaceLinearAlgebraInstruction( {122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142}, instruction_descriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); std::string variant_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %54 "main" ; Types %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeFloat 32 %5 = OpTypeVector %4 2 %6 = OpTypeVector %4 3 %7 = OpTypeVector %4 4 %8 = OpTypeMatrix %5 2 %9 = OpTypeMatrix %5 3 %10 = OpTypeMatrix %5 4 %11 = OpTypeMatrix %6 2 %12 = OpTypeMatrix %6 3 %13 = OpTypeMatrix %6 4 %14 = OpTypeMatrix %7 2 %15 = OpTypeMatrix %7 3 %16 = OpTypeMatrix %7 4 ; Constant scalars %17 = OpConstant %4 1 %18 = OpConstant %4 2 %19 = OpConstant %4 3 %20 = OpConstant %4 4 %21 = OpConstant %4 5 %22 = OpConstant %4 6 %23 = OpConstant %4 7 %24 = OpConstant %4 8 %25 = OpConstant %4 9 %26 = OpConstant %4 10 %27 = OpConstant %4 11 %28 = OpConstant %4 12 %29 = OpConstant %4 13 %30 = OpConstant %4 14 %31 = OpConstant %4 15 %32 = OpConstant %4 16 ; Constant vectors %33 = OpConstantComposite %5 %17 %18 %34 = OpConstantComposite %5 %19 %20 %35 = OpConstantComposite %5 %21 %22 %36 = OpConstantComposite %5 %23 %24 %37 = OpConstantComposite %6 %17 %18 %19 %38 = OpConstantComposite %6 %20 %21 %22 %39 = OpConstantComposite %6 %23 %24 %25 %40 = OpConstantComposite %6 %26 %27 %28 %41 = OpConstantComposite %7 %17 %18 %19 %20 %42 = OpConstantComposite %7 %21 %22 %23 %24 %43 = OpConstantComposite %7 %25 %26 %27 %28 %44 = OpConstantComposite %7 %29 %30 %31 %32 ; Constant matrices %45 = OpConstantComposite %8 %33 %34 %46 = OpConstantComposite %9 %33 %34 %35 %47 = OpConstantComposite %10 %33 %34 %35 %36 %48 = OpConstantComposite %11 %37 %38 %49 = OpConstantComposite %12 %37 %38 %39 %50 = OpConstantComposite %13 %37 %38 %39 %40 %51 = OpConstantComposite %14 %41 %42 %52 = OpConstantComposite %15 %41 %42 %43 %53 = OpConstantComposite %16 %41 %42 %43 %44 ; main function %54 = OpFunction %2 None %3 %55 = OpLabel ; Transposing a 2x2 matrix %65 = OpCompositeExtract %5 %45 0 %66 = OpCompositeExtract %4 %65 0 %67 = OpCompositeExtract %5 %45 1 %68 = OpCompositeExtract %4 %67 0 %69 = OpCompositeConstruct %5 %66 %68 %70 = OpCompositeExtract %5 %45 0 %71 = OpCompositeExtract %4 %70 1 %72 = OpCompositeExtract %5 %45 1 %73 = OpCompositeExtract %4 %72 1 %74 = OpCompositeConstruct %5 %71 %73 %56 = OpCompositeConstruct %8 %69 %74 ; Transposing a 2x3 matrix %75 = OpCompositeExtract %5 %46 0 %76 = OpCompositeExtract %4 %75 0 %77 = OpCompositeExtract %5 %46 1 %78 = OpCompositeExtract %4 %77 0 %79 = OpCompositeExtract %5 %46 2 %80 = OpCompositeExtract %4 %79 0 %81 = OpCompositeConstruct %6 %76 %78 %80 %82 = OpCompositeExtract %5 %46 0 %83 = OpCompositeExtract %4 %82 1 %84 = OpCompositeExtract %5 %46 1 %85 = OpCompositeExtract %4 %84 1 %86 = OpCompositeExtract %5 %46 2 %87 = OpCompositeExtract %4 %86 1 %88 = OpCompositeConstruct %6 %83 %85 %87 %57 = OpCompositeConstruct %11 %81 %88 ; Transposing a 2x4 matrix %89 = OpCompositeExtract %5 %47 0 %90 = OpCompositeExtract %4 %89 0 %91 = OpCompositeExtract %5 %47 1 %92 = OpCompositeExtract %4 %91 0 %93 = OpCompositeExtract %5 %47 2 %94 = OpCompositeExtract %4 %93 0 %95 = OpCompositeExtract %5 %47 3 %96 = OpCompositeExtract %4 %95 0 %97 = OpCompositeConstruct %7 %90 %92 %94 %96 %98 = OpCompositeExtract %5 %47 0 %99 = OpCompositeExtract %4 %98 1 %100 = OpCompositeExtract %5 %47 1 %101 = OpCompositeExtract %4 %100 1 %102 = OpCompositeExtract %5 %47 2 %103 = OpCompositeExtract %4 %102 1 %104 = OpCompositeExtract %5 %47 3 %105 = OpCompositeExtract %4 %104 1 %106 = OpCompositeConstruct %7 %99 %101 %103 %105 %58 = OpCompositeConstruct %14 %97 %106 ; Transposing a 3x2 matrix %107 = OpCompositeExtract %6 %48 0 %108 = OpCompositeExtract %4 %107 0 %109 = OpCompositeExtract %6 %48 1 %110 = OpCompositeExtract %4 %109 0 %111 = OpCompositeConstruct %5 %108 %110 %112 = OpCompositeExtract %6 %48 0 %113 = OpCompositeExtract %4 %112 1 %114 = OpCompositeExtract %6 %48 1 %115 = OpCompositeExtract %4 %114 1 %116 = OpCompositeConstruct %5 %113 %115 %117 = OpCompositeExtract %6 %48 0 %118 = OpCompositeExtract %4 %117 2 %119 = OpCompositeExtract %6 %48 1 %120 = OpCompositeExtract %4 %119 2 %121 = OpCompositeConstruct %5 %118 %120 %59 = OpCompositeConstruct %9 %111 %116 %121 ; Transposing a 3x3 matrix %122 = OpCompositeExtract %6 %49 0 %123 = OpCompositeExtract %4 %122 0 %124 = OpCompositeExtract %6 %49 1 %125 = OpCompositeExtract %4 %124 0 %126 = OpCompositeExtract %6 %49 2 %127 = OpCompositeExtract %4 %126 0 %128 = OpCompositeConstruct %6 %123 %125 %127 %129 = OpCompositeExtract %6 %49 0 %130 = OpCompositeExtract %4 %129 1 %131 = OpCompositeExtract %6 %49 1 %132 = OpCompositeExtract %4 %131 1 %133 = OpCompositeExtract %6 %49 2 %134 = OpCompositeExtract %4 %133 1 %135 = OpCompositeConstruct %6 %130 %132 %134 %136 = OpCompositeExtract %6 %49 0 %137 = OpCompositeExtract %4 %136 2 %138 = OpCompositeExtract %6 %49 1 %139 = OpCompositeExtract %4 %138 2 %140 = OpCompositeExtract %6 %49 2 %141 = OpCompositeExtract %4 %140 2 %142 = OpCompositeConstruct %6 %137 %139 %141 %60 = OpCompositeConstruct %12 %128 %135 %142 ; Transposing a 3x4 matrix %61 = OpTranspose %15 %50 ; Transposing a 4x2 matrix %62 = OpTranspose %10 %51 ; Transposing a 4x3 matrix %63 = OpTranspose %13 %52 ; Transposing a 4x4 matrix %64 = OpTranspose %16 %53 OpReturn OpFunctionEnd )"; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(IsEqual(env, variant_shader, context.get())); } TEST(TransformationReplaceLinearAlgebraInstructionTest, ReplaceOpVectorTimesScalar) { std::string reference_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %15 "main" OpExecutionMode %15 OriginUpperLeft OpSource ESSL 310 OpName %15 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeFloat 32 %5 = OpTypeVector %4 2 %6 = OpTypeVector %4 3 %7 = OpTypeVector %4 4 %8 = OpConstant %4 1 %9 = OpConstant %4 2 %10 = OpConstant %4 3 %11 = OpConstant %4 4 %12 = OpConstantComposite %5 %8 %9 %13 = OpConstantComposite %6 %8 %9 %10 %14 = OpConstantComposite %7 %8 %9 %10 %11 %15 = OpFunction %2 None %3 %16 = OpLabel %17 = OpVectorTimesScalar %5 %12 %8 %18 = OpVectorTimesScalar %6 %13 %9 %19 = OpVectorTimesScalar %7 %14 %10 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto instruction_descriptor = MakeInstructionDescriptor(17, spv::Op::OpVectorTimesScalar, 0); auto transformation = TransformationReplaceLinearAlgebraInstruction( {20, 21, 22, 23}, instruction_descriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); instruction_descriptor = MakeInstructionDescriptor(18, spv::Op::OpVectorTimesScalar, 0); transformation = TransformationReplaceLinearAlgebraInstruction( {24, 25, 26, 27, 28, 29}, instruction_descriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); instruction_descriptor = MakeInstructionDescriptor(19, spv::Op::OpVectorTimesScalar, 0); transformation = TransformationReplaceLinearAlgebraInstruction( {30, 31, 32, 33, 34, 35, 36, 37}, instruction_descriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); std::string variant_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %15 "main" OpExecutionMode %15 OriginUpperLeft OpSource ESSL 310 OpName %15 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeFloat 32 %5 = OpTypeVector %4 2 %6 = OpTypeVector %4 3 %7 = OpTypeVector %4 4 %8 = OpConstant %4 1 %9 = OpConstant %4 2 %10 = OpConstant %4 3 %11 = OpConstant %4 4 %12 = OpConstantComposite %5 %8 %9 %13 = OpConstantComposite %6 %8 %9 %10 %14 = OpConstantComposite %7 %8 %9 %10 %11 %15 = OpFunction %2 None %3 %16 = OpLabel %20 = OpCompositeExtract %4 %12 0 %21 = OpFMul %4 %20 %8 %22 = OpCompositeExtract %4 %12 1 %23 = OpFMul %4 %22 %8 %17 = OpCompositeConstruct %5 %21 %23 %24 = OpCompositeExtract %4 %13 0 %25 = OpFMul %4 %24 %9 %26 = OpCompositeExtract %4 %13 1 %27 = OpFMul %4 %26 %9 %28 = OpCompositeExtract %4 %13 2 %29 = OpFMul %4 %28 %9 %18 = OpCompositeConstruct %6 %25 %27 %29 %30 = OpCompositeExtract %4 %14 0 %31 = OpFMul %4 %30 %10 %32 = OpCompositeExtract %4 %14 1 %33 = OpFMul %4 %32 %10 %34 = OpCompositeExtract %4 %14 2 %35 = OpFMul %4 %34 %10 %36 = OpCompositeExtract %4 %14 3 %37 = OpFMul %4 %36 %10 %19 = OpCompositeConstruct %7 %31 %33 %35 %37 OpReturn OpFunctionEnd )"; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(IsEqual(env, variant_shader, context.get())); } TEST(TransformationReplaceLinearAlgebraInstructionTest, ReplaceOpMatrixTimesScalar) { std::string reference_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %54 "main" OpExecutionMode %54 OriginUpperLeft ; Types %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeFloat 32 %5 = OpTypeVector %4 2 %6 = OpTypeVector %4 3 %7 = OpTypeVector %4 4 %8 = OpTypeMatrix %5 2 %9 = OpTypeMatrix %5 3 %10 = OpTypeMatrix %5 4 %11 = OpTypeMatrix %6 2 %12 = OpTypeMatrix %6 3 %13 = OpTypeMatrix %6 4 %14 = OpTypeMatrix %7 2 %15 = OpTypeMatrix %7 3 %16 = OpTypeMatrix %7 4 ; Constant scalars %17 = OpConstant %4 1 %18 = OpConstant %4 2 %19 = OpConstant %4 3 %20 = OpConstant %4 4 %21 = OpConstant %4 5 %22 = OpConstant %4 6 %23 = OpConstant %4 7 %24 = OpConstant %4 8 %25 = OpConstant %4 9 %26 = OpConstant %4 10 %27 = OpConstant %4 11 %28 = OpConstant %4 12 %29 = OpConstant %4 13 %30 = OpConstant %4 14 %31 = OpConstant %4 15 %32 = OpConstant %4 16 ; Constant vectors %33 = OpConstantComposite %5 %17 %18 %34 = OpConstantComposite %5 %19 %20 %35 = OpConstantComposite %5 %21 %22 %36 = OpConstantComposite %5 %23 %24 %37 = OpConstantComposite %6 %17 %18 %19 %38 = OpConstantComposite %6 %20 %21 %22 %39 = OpConstantComposite %6 %23 %24 %25 %40 = OpConstantComposite %6 %26 %27 %28 %41 = OpConstantComposite %7 %17 %18 %19 %20 %42 = OpConstantComposite %7 %21 %22 %23 %24 %43 = OpConstantComposite %7 %25 %26 %27 %28 %44 = OpConstantComposite %7 %29 %30 %31 %32 ; Constant matrices %45 = OpConstantComposite %8 %33 %34 %46 = OpConstantComposite %9 %33 %34 %35 %47 = OpConstantComposite %10 %33 %34 %35 %36 %48 = OpConstantComposite %11 %37 %38 %49 = OpConstantComposite %12 %37 %38 %39 %50 = OpConstantComposite %13 %37 %38 %39 %40 %51 = OpConstantComposite %14 %41 %42 %52 = OpConstantComposite %15 %41 %42 %43 %53 = OpConstantComposite %16 %41 %42 %43 %44 ; main function %54 = OpFunction %2 None %3 %55 = OpLabel ; Multiplying 2-row matrices by scalar %56 = OpMatrixTimesScalar %8 %45 %17 %57 = OpMatrixTimesScalar %9 %46 %18 %58 = OpMatrixTimesScalar %10 %47 %19 ; Multiplying 3-row matrices by scalar %59 = OpMatrixTimesScalar %11 %48 %21 %60 = OpMatrixTimesScalar %12 %49 %22 %61 = OpMatrixTimesScalar %13 %50 %23 ; Multiplying 4-row matrices by scalar %62 = OpMatrixTimesScalar %14 %51 %24 %63 = OpMatrixTimesScalar %15 %52 %25 %64 = OpMatrixTimesScalar %16 %53 %26 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto instruction_descriptor = MakeInstructionDescriptor(56, spv::Op::OpMatrixTimesScalar, 0); auto transformation = TransformationReplaceLinearAlgebraInstruction( {65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76}, instruction_descriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); instruction_descriptor = MakeInstructionDescriptor(57, spv::Op::OpMatrixTimesScalar, 0); transformation = TransformationReplaceLinearAlgebraInstruction( {77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94}, instruction_descriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); instruction_descriptor = MakeInstructionDescriptor(58, spv::Op::OpMatrixTimesScalar, 0); transformation = TransformationReplaceLinearAlgebraInstruction( {95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118}, instruction_descriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); std::string variant_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %54 "main" OpExecutionMode %54 OriginUpperLeft ; Types %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeFloat 32 %5 = OpTypeVector %4 2 %6 = OpTypeVector %4 3 %7 = OpTypeVector %4 4 %8 = OpTypeMatrix %5 2 %9 = OpTypeMatrix %5 3 %10 = OpTypeMatrix %5 4 %11 = OpTypeMatrix %6 2 %12 = OpTypeMatrix %6 3 %13 = OpTypeMatrix %6 4 %14 = OpTypeMatrix %7 2 %15 = OpTypeMatrix %7 3 %16 = OpTypeMatrix %7 4 ; Constant scalars %17 = OpConstant %4 1 %18 = OpConstant %4 2 %19 = OpConstant %4 3 %20 = OpConstant %4 4 %21 = OpConstant %4 5 %22 = OpConstant %4 6 %23 = OpConstant %4 7 %24 = OpConstant %4 8 %25 = OpConstant %4 9 %26 = OpConstant %4 10 %27 = OpConstant %4 11 %28 = OpConstant %4 12 %29 = OpConstant %4 13 %30 = OpConstant %4 14 %31 = OpConstant %4 15 %32 = OpConstant %4 16 ; Constant vectors %33 = OpConstantComposite %5 %17 %18 %34 = OpConstantComposite %5 %19 %20 %35 = OpConstantComposite %5 %21 %22 %36 = OpConstantComposite %5 %23 %24 %37 = OpConstantComposite %6 %17 %18 %19 %38 = OpConstantComposite %6 %20 %21 %22 %39 = OpConstantComposite %6 %23 %24 %25 %40 = OpConstantComposite %6 %26 %27 %28 %41 = OpConstantComposite %7 %17 %18 %19 %20 %42 = OpConstantComposite %7 %21 %22 %23 %24 %43 = OpConstantComposite %7 %25 %26 %27 %28 %44 = OpConstantComposite %7 %29 %30 %31 %32 ; Constant matrices %45 = OpConstantComposite %8 %33 %34 %46 = OpConstantComposite %9 %33 %34 %35 %47 = OpConstantComposite %10 %33 %34 %35 %36 %48 = OpConstantComposite %11 %37 %38 %49 = OpConstantComposite %12 %37 %38 %39 %50 = OpConstantComposite %13 %37 %38 %39 %40 %51 = OpConstantComposite %14 %41 %42 %52 = OpConstantComposite %15 %41 %42 %43 %53 = OpConstantComposite %16 %41 %42 %43 %44 ; main function %54 = OpFunction %2 None %3 %55 = OpLabel ; Multiplying 2x2 matrix by scalar %65 = OpCompositeExtract %5 %45 0 %66 = OpCompositeExtract %4 %65 0 %67 = OpFMul %4 %66 %17 %68 = OpCompositeExtract %4 %65 1 %69 = OpFMul %4 %68 %17 %70 = OpCompositeConstruct %5 %67 %69 %71 = OpCompositeExtract %5 %45 1 %72 = OpCompositeExtract %4 %71 0 %73 = OpFMul %4 %72 %17 %74 = OpCompositeExtract %4 %71 1 %75 = OpFMul %4 %74 %17 %76 = OpCompositeConstruct %5 %73 %75 %56 = OpCompositeConstruct %8 %70 %76 ; Multiplying 2x3 matrix by scalar %77 = OpCompositeExtract %5 %46 0 %78 = OpCompositeExtract %4 %77 0 %79 = OpFMul %4 %78 %18 %80 = OpCompositeExtract %4 %77 1 %81 = OpFMul %4 %80 %18 %82 = OpCompositeConstruct %5 %79 %81 %83 = OpCompositeExtract %5 %46 1 %84 = OpCompositeExtract %4 %83 0 %85 = OpFMul %4 %84 %18 %86 = OpCompositeExtract %4 %83 1 %87 = OpFMul %4 %86 %18 %88 = OpCompositeConstruct %5 %85 %87 %89 = OpCompositeExtract %5 %46 2 %90 = OpCompositeExtract %4 %89 0 %91 = OpFMul %4 %90 %18 %92 = OpCompositeExtract %4 %89 1 %93 = OpFMul %4 %92 %18 %94 = OpCompositeConstruct %5 %91 %93 %57 = OpCompositeConstruct %9 %82 %88 %94 ; Multiplying 2x4 matrix by scalar %95 = OpCompositeExtract %5 %47 0 %96 = OpCompositeExtract %4 %95 0 %97 = OpFMul %4 %96 %19 %98 = OpCompositeExtract %4 %95 1 %99 = OpFMul %4 %98 %19 %100 = OpCompositeConstruct %5 %97 %99 %101 = OpCompositeExtract %5 %47 1 %102 = OpCompositeExtract %4 %101 0 %103 = OpFMul %4 %102 %19 %104 = OpCompositeExtract %4 %101 1 %105 = OpFMul %4 %104 %19 %106 = OpCompositeConstruct %5 %103 %105 %107 = OpCompositeExtract %5 %47 2 %108 = OpCompositeExtract %4 %107 0 %109 = OpFMul %4 %108 %19 %110 = OpCompositeExtract %4 %107 1 %111 = OpFMul %4 %110 %19 %112 = OpCompositeConstruct %5 %109 %111 %113 = OpCompositeExtract %5 %47 3 %114 = OpCompositeExtract %4 %113 0 %115 = OpFMul %4 %114 %19 %116 = OpCompositeExtract %4 %113 1 %117 = OpFMul %4 %116 %19 %118 = OpCompositeConstruct %5 %115 %117 %58 = OpCompositeConstruct %10 %100 %106 %112 %118 ; Multiplying 3-row matrices by scalar %59 = OpMatrixTimesScalar %11 %48 %21 %60 = OpMatrixTimesScalar %12 %49 %22 %61 = OpMatrixTimesScalar %13 %50 %23 ; Multiplying 4-row matrices by scalar %62 = OpMatrixTimesScalar %14 %51 %24 %63 = OpMatrixTimesScalar %15 %52 %25 %64 = OpMatrixTimesScalar %16 %53 %26 OpReturn OpFunctionEnd )"; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(IsEqual(env, variant_shader, context.get())); } TEST(TransformationReplaceLinearAlgebraInstructionTest, ReplaceOpVectorTimesMatrix) { std::string reference_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %54 "main" OpExecutionMode %54 OriginUpperLeft OpSource ESSL 310 OpName %54 "main" ; Types %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeFloat 32 %5 = OpTypeVector %4 2 %6 = OpTypeVector %4 3 %7 = OpTypeVector %4 4 %8 = OpTypeMatrix %5 2 %9 = OpTypeMatrix %5 3 %10 = OpTypeMatrix %5 4 %11 = OpTypeMatrix %6 2 %12 = OpTypeMatrix %6 3 %13 = OpTypeMatrix %6 4 %14 = OpTypeMatrix %7 2 %15 = OpTypeMatrix %7 3 %16 = OpTypeMatrix %7 4 ; Constant scalars %17 = OpConstant %4 1 %18 = OpConstant %4 2 %19 = OpConstant %4 3 %20 = OpConstant %4 4 %21 = OpConstant %4 5 %22 = OpConstant %4 6 %23 = OpConstant %4 7 %24 = OpConstant %4 8 %25 = OpConstant %4 9 %26 = OpConstant %4 10 %27 = OpConstant %4 11 %28 = OpConstant %4 12 %29 = OpConstant %4 13 %30 = OpConstant %4 14 %31 = OpConstant %4 15 %32 = OpConstant %4 16 ; Constant vectors %33 = OpConstantComposite %5 %17 %18 %34 = OpConstantComposite %5 %19 %20 %35 = OpConstantComposite %5 %21 %22 %36 = OpConstantComposite %5 %23 %24 %37 = OpConstantComposite %6 %17 %18 %19 %38 = OpConstantComposite %6 %20 %21 %22 %39 = OpConstantComposite %6 %23 %24 %25 %40 = OpConstantComposite %6 %26 %27 %28 %41 = OpConstantComposite %7 %17 %18 %19 %20 %42 = OpConstantComposite %7 %21 %22 %23 %24 %43 = OpConstantComposite %7 %25 %26 %27 %28 %44 = OpConstantComposite %7 %29 %30 %31 %32 ; Constant matrices %45 = OpConstantComposite %8 %33 %34 %46 = OpConstantComposite %9 %33 %34 %35 %47 = OpConstantComposite %10 %33 %34 %35 %36 %48 = OpConstantComposite %11 %37 %38 %49 = OpConstantComposite %12 %37 %38 %39 %50 = OpConstantComposite %13 %37 %38 %39 %40 %51 = OpConstantComposite %14 %41 %42 %52 = OpConstantComposite %15 %41 %42 %43 %53 = OpConstantComposite %16 %41 %42 %43 %44 ; main function %54 = OpFunction %2 None %3 %55 = OpLabel ; Multiplying 2-dimensional vector by 2x2 matrix %56 = OpVectorTimesMatrix %5 %33 %45 ; Multiplying 2-dimensional vector by 2x3 matrix %57 = OpVectorTimesMatrix %6 %34 %46 ; Multiplying 2-dimensional vector by 2x4 matrix %58 = OpVectorTimesMatrix %7 %35 %47 ; Multiplying 3-dimensional vector by 3x2 matrix %59 = OpVectorTimesMatrix %5 %37 %48 ; Multiplying 3-dimensional vector by 3x3 matrix %60 = OpVectorTimesMatrix %6 %38 %49 ; Multiplying 3-dimensional vector by 3x4 matrix %61 = OpVectorTimesMatrix %7 %39 %50 ; Multiplying 4-dimensional vector by 4x2 matrix %62 = OpVectorTimesMatrix %5 %41 %51 ; Multiplying 4-dimensional vector by 4x3 matrix %63 = OpVectorTimesMatrix %6 %42 %52 ; Multiplying 4-dimensional vector by 4x4 matrix %64 = OpVectorTimesMatrix %7 %43 %53 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto instruction_descriptor = MakeInstructionDescriptor(56, spv::Op::OpVectorTimesMatrix, 0); auto transformation = TransformationReplaceLinearAlgebraInstruction( {65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78}, instruction_descriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); instruction_descriptor = MakeInstructionDescriptor(57, spv::Op::OpVectorTimesMatrix, 0); transformation = TransformationReplaceLinearAlgebraInstruction( {79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98}, instruction_descriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); instruction_descriptor = MakeInstructionDescriptor(58, spv::Op::OpVectorTimesMatrix, 0); transformation = TransformationReplaceLinearAlgebraInstruction( {99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124}, instruction_descriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); instruction_descriptor = MakeInstructionDescriptor(59, spv::Op::OpVectorTimesMatrix, 0); transformation = TransformationReplaceLinearAlgebraInstruction( {125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145}, instruction_descriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); std::string variant_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %54 "main" OpExecutionMode %54 OriginUpperLeft OpSource ESSL 310 OpName %54 "main" ; Types %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeFloat 32 %5 = OpTypeVector %4 2 %6 = OpTypeVector %4 3 %7 = OpTypeVector %4 4 %8 = OpTypeMatrix %5 2 %9 = OpTypeMatrix %5 3 %10 = OpTypeMatrix %5 4 %11 = OpTypeMatrix %6 2 %12 = OpTypeMatrix %6 3 %13 = OpTypeMatrix %6 4 %14 = OpTypeMatrix %7 2 %15 = OpTypeMatrix %7 3 %16 = OpTypeMatrix %7 4 ; Constant scalars %17 = OpConstant %4 1 %18 = OpConstant %4 2 %19 = OpConstant %4 3 %20 = OpConstant %4 4 %21 = OpConstant %4 5 %22 = OpConstant %4 6 %23 = OpConstant %4 7 %24 = OpConstant %4 8 %25 = OpConstant %4 9 %26 = OpConstant %4 10 %27 = OpConstant %4 11 %28 = OpConstant %4 12 %29 = OpConstant %4 13 %30 = OpConstant %4 14 %31 = OpConstant %4 15 %32 = OpConstant %4 16 ; Constant vectors %33 = OpConstantComposite %5 %17 %18 %34 = OpConstantComposite %5 %19 %20 %35 = OpConstantComposite %5 %21 %22 %36 = OpConstantComposite %5 %23 %24 %37 = OpConstantComposite %6 %17 %18 %19 %38 = OpConstantComposite %6 %20 %21 %22 %39 = OpConstantComposite %6 %23 %24 %25 %40 = OpConstantComposite %6 %26 %27 %28 %41 = OpConstantComposite %7 %17 %18 %19 %20 %42 = OpConstantComposite %7 %21 %22 %23 %24 %43 = OpConstantComposite %7 %25 %26 %27 %28 %44 = OpConstantComposite %7 %29 %30 %31 %32 ; Constant matrices %45 = OpConstantComposite %8 %33 %34 %46 = OpConstantComposite %9 %33 %34 %35 %47 = OpConstantComposite %10 %33 %34 %35 %36 %48 = OpConstantComposite %11 %37 %38 %49 = OpConstantComposite %12 %37 %38 %39 %50 = OpConstantComposite %13 %37 %38 %39 %40 %51 = OpConstantComposite %14 %41 %42 %52 = OpConstantComposite %15 %41 %42 %43 %53 = OpConstantComposite %16 %41 %42 %43 %44 ; main function %54 = OpFunction %2 None %3 %55 = OpLabel ; Multiplying 2-dimensional vector by 2x2 matrix %65 = OpCompositeExtract %4 %33 0 %66 = OpCompositeExtract %4 %33 1 %67 = OpCompositeExtract %5 %45 0 %68 = OpCompositeExtract %4 %67 0 %69 = OpFMul %4 %65 %68 %70 = OpCompositeExtract %4 %67 1 %71 = OpFMul %4 %66 %70 %72 = OpFAdd %4 %69 %71 %73 = OpCompositeExtract %5 %45 1 %74 = OpCompositeExtract %4 %73 0 %75 = OpFMul %4 %65 %74 %76 = OpCompositeExtract %4 %73 1 %77 = OpFMul %4 %66 %76 %78 = OpFAdd %4 %75 %77 %56 = OpCompositeConstruct %5 %72 %78 ; Multiplying 2-dimensional vector by 2x3 matrix %79 = OpCompositeExtract %4 %34 0 %80 = OpCompositeExtract %4 %34 1 %81 = OpCompositeExtract %5 %46 0 %82 = OpCompositeExtract %4 %81 0 %83 = OpFMul %4 %79 %82 %84 = OpCompositeExtract %4 %81 1 %85 = OpFMul %4 %80 %84 %86 = OpFAdd %4 %83 %85 %87 = OpCompositeExtract %5 %46 1 %88 = OpCompositeExtract %4 %87 0 %89 = OpFMul %4 %79 %88 %90 = OpCompositeExtract %4 %87 1 %91 = OpFMul %4 %80 %90 %92 = OpFAdd %4 %89 %91 %93 = OpCompositeExtract %5 %46 2 %94 = OpCompositeExtract %4 %93 0 %95 = OpFMul %4 %79 %94 %96 = OpCompositeExtract %4 %93 1 %97 = OpFMul %4 %80 %96 %98 = OpFAdd %4 %95 %97 %57 = OpCompositeConstruct %6 %86 %92 %98 ; Multiplying 2-dimensional vector by 2x4 matrix %99 = OpCompositeExtract %4 %35 0 %100 = OpCompositeExtract %4 %35 1 %101 = OpCompositeExtract %5 %47 0 %102 = OpCompositeExtract %4 %101 0 %103 = OpFMul %4 %99 %102 %104 = OpCompositeExtract %4 %101 1 %105 = OpFMul %4 %100 %104 %106 = OpFAdd %4 %103 %105 %107 = OpCompositeExtract %5 %47 1 %108 = OpCompositeExtract %4 %107 0 %109 = OpFMul %4 %99 %108 %110 = OpCompositeExtract %4 %107 1 %111 = OpFMul %4 %100 %110 %112 = OpFAdd %4 %109 %111 %113 = OpCompositeExtract %5 %47 2 %114 = OpCompositeExtract %4 %113 0 %115 = OpFMul %4 %99 %114 %116 = OpCompositeExtract %4 %113 1 %117 = OpFMul %4 %100 %116 %118 = OpFAdd %4 %115 %117 %119 = OpCompositeExtract %5 %47 3 %120 = OpCompositeExtract %4 %119 0 %121 = OpFMul %4 %99 %120 %122 = OpCompositeExtract %4 %119 1 %123 = OpFMul %4 %100 %122 %124 = OpFAdd %4 %121 %123 %58 = OpCompositeConstruct %7 %106 %112 %118 %124 ; Multiplying 3-dimensional vector by 3x2 matrix %125 = OpCompositeExtract %4 %37 0 %126 = OpCompositeExtract %4 %37 1 %127 = OpCompositeExtract %4 %37 2 %128 = OpCompositeExtract %6 %48 0 %129 = OpCompositeExtract %4 %128 0 %130 = OpFMul %4 %125 %129 %131 = OpCompositeExtract %4 %128 1 %132 = OpFMul %4 %126 %131 %133 = OpCompositeExtract %4 %128 2 %134 = OpFMul %4 %127 %133 %135 = OpFAdd %4 %130 %132 %136 = OpFAdd %4 %134 %135 %137 = OpCompositeExtract %6 %48 1 %138 = OpCompositeExtract %4 %137 0 %139 = OpFMul %4 %125 %138 %140 = OpCompositeExtract %4 %137 1 %141 = OpFMul %4 %126 %140 %142 = OpCompositeExtract %4 %137 2 %143 = OpFMul %4 %127 %142 %144 = OpFAdd %4 %139 %141 %145 = OpFAdd %4 %143 %144 %59 = OpCompositeConstruct %5 %136 %145 ; Multiplying 3-dimensional vector by 3x3 matrix %60 = OpVectorTimesMatrix %6 %38 %49 ; Multiplying 3-dimensional vector by 3x4 matrix %61 = OpVectorTimesMatrix %7 %39 %50 ; Multiplying 4-dimensional vector by 4x2 matrix %62 = OpVectorTimesMatrix %5 %41 %51 ; Multiplying 4-dimensional vector by 4x3 matrix %63 = OpVectorTimesMatrix %6 %42 %52 ; Multiplying 4-dimensional vector by 4x4 matrix %64 = OpVectorTimesMatrix %7 %43 %53 OpReturn OpFunctionEnd )"; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(IsEqual(env, variant_shader, context.get())); } TEST(TransformationReplaceLinearAlgebraInstructionTest, ReplaceOpMatrixTimesVector) { std::string reference_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %54 "main" OpExecutionMode %54 OriginUpperLeft OpSource ESSL 310 OpName %54 "main" ; Types %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeFloat 32 %5 = OpTypeVector %4 2 %6 = OpTypeVector %4 3 %7 = OpTypeVector %4 4 %8 = OpTypeMatrix %5 2 %9 = OpTypeMatrix %5 3 %10 = OpTypeMatrix %5 4 %11 = OpTypeMatrix %6 2 %12 = OpTypeMatrix %6 3 %13 = OpTypeMatrix %6 4 %14 = OpTypeMatrix %7 2 %15 = OpTypeMatrix %7 3 %16 = OpTypeMatrix %7 4 ; Constant scalars %17 = OpConstant %4 1 %18 = OpConstant %4 2 %19 = OpConstant %4 3 %20 = OpConstant %4 4 %21 = OpConstant %4 5 %22 = OpConstant %4 6 %23 = OpConstant %4 7 %24 = OpConstant %4 8 %25 = OpConstant %4 9 %26 = OpConstant %4 10 %27 = OpConstant %4 11 %28 = OpConstant %4 12 %29 = OpConstant %4 13 %30 = OpConstant %4 14 %31 = OpConstant %4 15 %32 = OpConstant %4 16 ; Constant vectors %33 = OpConstantComposite %5 %17 %18 %34 = OpConstantComposite %5 %19 %20 %35 = OpConstantComposite %5 %21 %22 %36 = OpConstantComposite %5 %23 %24 %37 = OpConstantComposite %6 %17 %18 %19 %38 = OpConstantComposite %6 %20 %21 %22 %39 = OpConstantComposite %6 %23 %24 %25 %40 = OpConstantComposite %6 %26 %27 %28 %41 = OpConstantComposite %7 %17 %18 %19 %20 %42 = OpConstantComposite %7 %21 %22 %23 %24 %43 = OpConstantComposite %7 %25 %26 %27 %28 %44 = OpConstantComposite %7 %29 %30 %31 %32 ; Constant matrices %45 = OpConstantComposite %8 %33 %34 %46 = OpConstantComposite %9 %33 %34 %35 %47 = OpConstantComposite %10 %33 %34 %35 %36 %48 = OpConstantComposite %11 %37 %38 %49 = OpConstantComposite %12 %37 %38 %39 %50 = OpConstantComposite %13 %37 %38 %39 %40 %51 = OpConstantComposite %14 %41 %42 %52 = OpConstantComposite %15 %41 %42 %43 %53 = OpConstantComposite %16 %41 %42 %43 %44 ; main function %54 = OpFunction %2 None %3 %55 = OpLabel ; Multiplying 2x2 matrix by 2-dimensional vector %56 = OpMatrixTimesVector %5 %45 %33 ; Multiplying 3x2 matrix by 2-dimensional vector %57 = OpMatrixTimesVector %6 %48 %34 ; Multiplying 4x2 matrix by 2-dimensional vector %58 = OpMatrixTimesVector %7 %51 %35 ; Multiplying 2x3 matrix by 3-dimensional vector %59 = OpMatrixTimesVector %5 %46 %37 ; Multiplying 3x3 matrix by 3-dimensional vector %60 = OpMatrixTimesVector %6 %49 %38 ; Multiplying 4x3 matrix by 3-dimensional vector %61 = OpMatrixTimesVector %7 %52 %39 ; Multiplying 2x4 matrix by 4-dimensional vector %62 = OpMatrixTimesVector %5 %47 %41 ; Multiplying 3x4 matrix by 4-dimensional vector %63 = OpMatrixTimesVector %6 %50 %42 ; Multiplying 4x4 matrix by 4-dimensional vector %64 = OpMatrixTimesVector %7 %53 %43 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto instruction_descriptor = MakeInstructionDescriptor(56, spv::Op::OpMatrixTimesVector, 0); auto transformation = TransformationReplaceLinearAlgebraInstruction( {65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78}, instruction_descriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); instruction_descriptor = MakeInstructionDescriptor(57, spv::Op::OpMatrixTimesVector, 0); transformation = TransformationReplaceLinearAlgebraInstruction( {79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97}, instruction_descriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); instruction_descriptor = MakeInstructionDescriptor(58, spv::Op::OpMatrixTimesVector, 0); transformation = TransformationReplaceLinearAlgebraInstruction( {98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121}, instruction_descriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); instruction_descriptor = MakeInstructionDescriptor(59, spv::Op::OpMatrixTimesVector, 0); transformation = TransformationReplaceLinearAlgebraInstruction( {122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143}, instruction_descriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); std::string variant_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %54 "main" OpExecutionMode %54 OriginUpperLeft OpSource ESSL 310 OpName %54 "main" ; Types %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeFloat 32 %5 = OpTypeVector %4 2 %6 = OpTypeVector %4 3 %7 = OpTypeVector %4 4 %8 = OpTypeMatrix %5 2 %9 = OpTypeMatrix %5 3 %10 = OpTypeMatrix %5 4 %11 = OpTypeMatrix %6 2 %12 = OpTypeMatrix %6 3 %13 = OpTypeMatrix %6 4 %14 = OpTypeMatrix %7 2 %15 = OpTypeMatrix %7 3 %16 = OpTypeMatrix %7 4 ; Constant scalars %17 = OpConstant %4 1 %18 = OpConstant %4 2 %19 = OpConstant %4 3 %20 = OpConstant %4 4 %21 = OpConstant %4 5 %22 = OpConstant %4 6 %23 = OpConstant %4 7 %24 = OpConstant %4 8 %25 = OpConstant %4 9 %26 = OpConstant %4 10 %27 = OpConstant %4 11 %28 = OpConstant %4 12 %29 = OpConstant %4 13 %30 = OpConstant %4 14 %31 = OpConstant %4 15 %32 = OpConstant %4 16 ; Constant vectors %33 = OpConstantComposite %5 %17 %18 %34 = OpConstantComposite %5 %19 %20 %35 = OpConstantComposite %5 %21 %22 %36 = OpConstantComposite %5 %23 %24 %37 = OpConstantComposite %6 %17 %18 %19 %38 = OpConstantComposite %6 %20 %21 %22 %39 = OpConstantComposite %6 %23 %24 %25 %40 = OpConstantComposite %6 %26 %27 %28 %41 = OpConstantComposite %7 %17 %18 %19 %20 %42 = OpConstantComposite %7 %21 %22 %23 %24 %43 = OpConstantComposite %7 %25 %26 %27 %28 %44 = OpConstantComposite %7 %29 %30 %31 %32 ; Constant matrices %45 = OpConstantComposite %8 %33 %34 %46 = OpConstantComposite %9 %33 %34 %35 %47 = OpConstantComposite %10 %33 %34 %35 %36 %48 = OpConstantComposite %11 %37 %38 %49 = OpConstantComposite %12 %37 %38 %39 %50 = OpConstantComposite %13 %37 %38 %39 %40 %51 = OpConstantComposite %14 %41 %42 %52 = OpConstantComposite %15 %41 %42 %43 %53 = OpConstantComposite %16 %41 %42 %43 %44 ; main function %54 = OpFunction %2 None %3 %55 = OpLabel ; Multiplying 2x2 matrix by 2-dimensional vector %65 = OpCompositeExtract %5 %45 0 %66 = OpCompositeExtract %5 %45 1 %67 = OpCompositeExtract %4 %33 0 %68 = OpCompositeExtract %4 %33 1 %69 = OpCompositeExtract %4 %65 0 %70 = OpFMul %4 %69 %67 %71 = OpCompositeExtract %4 %66 0 %72 = OpFMul %4 %71 %68 %73 = OpFAdd %4 %70 %72 %74 = OpCompositeExtract %4 %65 1 %75 = OpFMul %4 %74 %67 %76 = OpCompositeExtract %4 %66 1 %77 = OpFMul %4 %76 %68 %78 = OpFAdd %4 %75 %77 %56 = OpCompositeConstruct %5 %73 %78 ; Multiplying 3x2 matrix by 2-dimensional vector %79 = OpCompositeExtract %6 %48 0 %80 = OpCompositeExtract %6 %48 1 %81 = OpCompositeExtract %4 %34 0 %82 = OpCompositeExtract %4 %34 1 %83 = OpCompositeExtract %4 %79 0 %84 = OpFMul %4 %83 %81 %85 = OpCompositeExtract %4 %80 0 %86 = OpFMul %4 %85 %82 %87 = OpFAdd %4 %84 %86 %88 = OpCompositeExtract %4 %79 1 %89 = OpFMul %4 %88 %81 %90 = OpCompositeExtract %4 %80 1 %91 = OpFMul %4 %90 %82 %92 = OpFAdd %4 %89 %91 %93 = OpCompositeExtract %4 %79 2 %94 = OpFMul %4 %93 %81 %95 = OpCompositeExtract %4 %80 2 %96 = OpFMul %4 %95 %82 %97 = OpFAdd %4 %94 %96 %57 = OpCompositeConstruct %6 %87 %92 %97 ; Multiplying 4x2 matrix by 2-dimensional vector %98 = OpCompositeExtract %7 %51 0 %99 = OpCompositeExtract %7 %51 1 %100 = OpCompositeExtract %4 %35 0 %101 = OpCompositeExtract %4 %35 1 %102 = OpCompositeExtract %4 %98 0 %103 = OpFMul %4 %102 %100 %104 = OpCompositeExtract %4 %99 0 %105 = OpFMul %4 %104 %101 %106 = OpFAdd %4 %103 %105 %107 = OpCompositeExtract %4 %98 1 %108 = OpFMul %4 %107 %100 %109 = OpCompositeExtract %4 %99 1 %110 = OpFMul %4 %109 %101 %111 = OpFAdd %4 %108 %110 %112 = OpCompositeExtract %4 %98 2 %113 = OpFMul %4 %112 %100 %114 = OpCompositeExtract %4 %99 2 %115 = OpFMul %4 %114 %101 %116 = OpFAdd %4 %113 %115 %117 = OpCompositeExtract %4 %98 3 %118 = OpFMul %4 %117 %100 %119 = OpCompositeExtract %4 %99 3 %120 = OpFMul %4 %119 %101 %121 = OpFAdd %4 %118 %120 %58 = OpCompositeConstruct %7 %106 %111 %116 %121 ; Multiplying 2x3 matrix by 3-dimensional vector %122 = OpCompositeExtract %5 %46 0 %123 = OpCompositeExtract %5 %46 1 %124 = OpCompositeExtract %5 %46 2 %125 = OpCompositeExtract %4 %37 0 %126 = OpCompositeExtract %4 %37 1 %127 = OpCompositeExtract %4 %37 2 %128 = OpCompositeExtract %4 %122 0 %129 = OpFMul %4 %128 %125 %130 = OpCompositeExtract %4 %123 0 %131 = OpFMul %4 %130 %126 %132 = OpCompositeExtract %4 %124 0 %133 = OpFMul %4 %132 %127 %134 = OpFAdd %4 %129 %131 %135 = OpFAdd %4 %133 %134 %136 = OpCompositeExtract %4 %122 1 %137 = OpFMul %4 %136 %125 %138 = OpCompositeExtract %4 %123 1 %139 = OpFMul %4 %138 %126 %140 = OpCompositeExtract %4 %124 1 %141 = OpFMul %4 %140 %127 %142 = OpFAdd %4 %137 %139 %143 = OpFAdd %4 %141 %142 %59 = OpCompositeConstruct %5 %135 %143 ; Multiplying 3x3 matrix by 3-dimensional vector %60 = OpMatrixTimesVector %6 %49 %38 ; Multiplying 4x3 matrix by 3-dimensional vector %61 = OpMatrixTimesVector %7 %52 %39 ; Multiplying 2x4 matrix by 4-dimensional vector %62 = OpMatrixTimesVector %5 %47 %41 ; Multiplying 3x4 matrix by 4-dimensional vector %63 = OpMatrixTimesVector %6 %50 %42 ; Multiplying 4x4 matrix by 4-dimensional vector %64 = OpMatrixTimesVector %7 %53 %43 OpReturn OpFunctionEnd )"; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(IsEqual(env, variant_shader, context.get())); } TEST(TransformationReplaceLinearAlgebraInstructionTest, ReplaceOpMatrixTimesMatrix) { std::string reference_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %54 "main" OpExecutionMode %54 OriginUpperLeft OpSource ESSL 310 OpName %54 "main" ; Types %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeFloat 32 %5 = OpTypeVector %4 2 %6 = OpTypeVector %4 3 %7 = OpTypeVector %4 4 %8 = OpTypeMatrix %5 2 %9 = OpTypeMatrix %5 3 %10 = OpTypeMatrix %5 4 %11 = OpTypeMatrix %6 2 %12 = OpTypeMatrix %6 3 %13 = OpTypeMatrix %6 4 %14 = OpTypeMatrix %7 2 %15 = OpTypeMatrix %7 3 %16 = OpTypeMatrix %7 4 ; Constant scalars %17 = OpConstant %4 1 %18 = OpConstant %4 2 %19 = OpConstant %4 3 %20 = OpConstant %4 4 %21 = OpConstant %4 5 %22 = OpConstant %4 6 %23 = OpConstant %4 7 %24 = OpConstant %4 8 %25 = OpConstant %4 9 %26 = OpConstant %4 10 %27 = OpConstant %4 11 %28 = OpConstant %4 12 %29 = OpConstant %4 13 %30 = OpConstant %4 14 %31 = OpConstant %4 15 %32 = OpConstant %4 16 ; Constant vectors %33 = OpConstantComposite %5 %17 %18 %34 = OpConstantComposite %5 %19 %20 %35 = OpConstantComposite %5 %21 %22 %36 = OpConstantComposite %5 %23 %24 %37 = OpConstantComposite %6 %17 %18 %19 %38 = OpConstantComposite %6 %20 %21 %22 %39 = OpConstantComposite %6 %23 %24 %25 %40 = OpConstantComposite %6 %26 %27 %28 %41 = OpConstantComposite %7 %17 %18 %19 %20 %42 = OpConstantComposite %7 %21 %22 %23 %24 %43 = OpConstantComposite %7 %25 %26 %27 %28 %44 = OpConstantComposite %7 %29 %30 %31 %32 ; Constant matrices %45 = OpConstantComposite %8 %33 %34 %46 = OpConstantComposite %9 %33 %34 %35 %47 = OpConstantComposite %10 %33 %34 %35 %36 %48 = OpConstantComposite %11 %37 %38 %49 = OpConstantComposite %12 %37 %38 %39 %50 = OpConstantComposite %13 %37 %38 %39 %40 %51 = OpConstantComposite %14 %41 %42 %52 = OpConstantComposite %15 %41 %42 %43 %53 = OpConstantComposite %16 %41 %42 %43 %44 ; main function %54 = OpFunction %2 None %3 %55 = OpLabel ; Multiplying 2x2 matrix by 2x2 matrix %56 = OpMatrixTimesMatrix %8 %45 %45 ; Multiplying 2x2 matrix by 2x3 matrix %57 = OpMatrixTimesMatrix %9 %45 %46 ; Multiplying 2x2 matrix by 2x4 matrix %58 = OpMatrixTimesMatrix %10 %45 %47 ; Multiplying 2x3 matrix by 3x2 matrix %59 = OpMatrixTimesMatrix %8 %46 %48 ; Multiplying 2x3 matrix by 3x3 matrix %60 = OpMatrixTimesMatrix %9 %46 %49 ; Multiplying 2x3 matrix by 3x4 matrix %61 = OpMatrixTimesMatrix %10 %46 %50 ; Multiplying 2x4 matrix by 4x2 matrix %62 = OpMatrixTimesMatrix %8 %47 %51 ; Multiplying 2x4 matrix by 4x3 matrix %63 = OpMatrixTimesMatrix %9 %47 %52 ; Multiplying 2x4 matrix by 4x4 matrix %64 = OpMatrixTimesMatrix %10 %47 %53 ; Multiplying 3x2 matrix by 2x2 matrix %65 = OpMatrixTimesMatrix %11 %48 %45 ; Multiplying 3x2 matrix by 2x3 matrix %66 = OpMatrixTimesMatrix %12 %48 %46 ; Multiplying 3x2 matrix by 2x4 matrix %67 = OpMatrixTimesMatrix %13 %48 %47 ; Multiplying 3x3 matrix by 3x2 matrix %68 = OpMatrixTimesMatrix %11 %49 %48 ; Multiplying 3x3 matrix by 3x3 matrix %69 = OpMatrixTimesMatrix %12 %49 %49 ; Multiplying 3x3 matrix by 3x4 matrix %70 = OpMatrixTimesMatrix %13 %49 %50 ; Multiplying 3x4 matrix by 4x2 matrix %71 = OpMatrixTimesMatrix %11 %50 %51 ; Multiplying 3x4 matrix by 4x3 matrix %72 = OpMatrixTimesMatrix %12 %50 %52 ; Multiplying 3x4 matrix by 4x4 matrix %73 = OpMatrixTimesMatrix %13 %50 %53 ; Multiplying 4x2 matrix by 2x2 matrix %74 = OpMatrixTimesMatrix %14 %51 %45 ; Multiplying 4x2 matrix by 2x3 matrix %75 = OpMatrixTimesMatrix %15 %51 %46 ; Multiplying 4x2 matrix by 2x4 matrix %76 = OpMatrixTimesMatrix %16 %51 %47 ; Multiplying 4x3 matrix by 3x2 matrix %77 = OpMatrixTimesMatrix %14 %52 %48 ; Multiplying 4x3 matrix by 3x3 matrix %78 = OpMatrixTimesMatrix %15 %52 %49 ; Multiplying 4x3 matrix by 3x4 matrix %79 = OpMatrixTimesMatrix %16 %52 %50 ; Multiplying 4x4 matrix by 4x2 matrix %80 = OpMatrixTimesMatrix %14 %53 %51 ; Multiplying 4x4 matrix by 4x3 matrix %81 = OpMatrixTimesMatrix %15 %53 %52 ; Multiplying 4x4 matrix by 4x4 matrix %82 = OpMatrixTimesMatrix %16 %53 %53 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto instruction_descriptor = MakeInstructionDescriptor(56, spv::Op::OpMatrixTimesMatrix, 0); auto transformation = TransformationReplaceLinearAlgebraInstruction( {83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122}, instruction_descriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); instruction_descriptor = MakeInstructionDescriptor(57, spv::Op::OpMatrixTimesMatrix, 0); transformation = TransformationReplaceLinearAlgebraInstruction( {123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182}, instruction_descriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); instruction_descriptor = MakeInstructionDescriptor(58, spv::Op::OpMatrixTimesMatrix, 0); transformation = TransformationReplaceLinearAlgebraInstruction( {183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262}, instruction_descriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); std::string variant_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %54 "main" OpExecutionMode %54 OriginUpperLeft OpSource ESSL 310 OpName %54 "main" ; Types %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeFloat 32 %5 = OpTypeVector %4 2 %6 = OpTypeVector %4 3 %7 = OpTypeVector %4 4 %8 = OpTypeMatrix %5 2 %9 = OpTypeMatrix %5 3 %10 = OpTypeMatrix %5 4 %11 = OpTypeMatrix %6 2 %12 = OpTypeMatrix %6 3 %13 = OpTypeMatrix %6 4 %14 = OpTypeMatrix %7 2 %15 = OpTypeMatrix %7 3 %16 = OpTypeMatrix %7 4 ; Constant scalars %17 = OpConstant %4 1 %18 = OpConstant %4 2 %19 = OpConstant %4 3 %20 = OpConstant %4 4 %21 = OpConstant %4 5 %22 = OpConstant %4 6 %23 = OpConstant %4 7 %24 = OpConstant %4 8 %25 = OpConstant %4 9 %26 = OpConstant %4 10 %27 = OpConstant %4 11 %28 = OpConstant %4 12 %29 = OpConstant %4 13 %30 = OpConstant %4 14 %31 = OpConstant %4 15 %32 = OpConstant %4 16 ; Constant vectors %33 = OpConstantComposite %5 %17 %18 %34 = OpConstantComposite %5 %19 %20 %35 = OpConstantComposite %5 %21 %22 %36 = OpConstantComposite %5 %23 %24 %37 = OpConstantComposite %6 %17 %18 %19 %38 = OpConstantComposite %6 %20 %21 %22 %39 = OpConstantComposite %6 %23 %24 %25 %40 = OpConstantComposite %6 %26 %27 %28 %41 = OpConstantComposite %7 %17 %18 %19 %20 %42 = OpConstantComposite %7 %21 %22 %23 %24 %43 = OpConstantComposite %7 %25 %26 %27 %28 %44 = OpConstantComposite %7 %29 %30 %31 %32 ; Constant matrices %45 = OpConstantComposite %8 %33 %34 %46 = OpConstantComposite %9 %33 %34 %35 %47 = OpConstantComposite %10 %33 %34 %35 %36 %48 = OpConstantComposite %11 %37 %38 %49 = OpConstantComposite %12 %37 %38 %39 %50 = OpConstantComposite %13 %37 %38 %39 %40 %51 = OpConstantComposite %14 %41 %42 %52 = OpConstantComposite %15 %41 %42 %43 %53 = OpConstantComposite %16 %41 %42 %43 %44 ; main function %54 = OpFunction %2 None %3 %55 = OpLabel ; Multiplying 2x2 matrix by 2x2 matrix %83 = OpCompositeExtract %5 %45 0 ; matrix 2 column 0 %84 = OpCompositeExtract %5 %45 0 ; matrix 1 column 0 %85 = OpCompositeExtract %4 %84 0 ; matrix 1 row 0 column 0 %86 = OpCompositeExtract %4 %83 0 ; matrix 2 row 0 column 0 %87 = OpFMul %4 %85 %86 %88 = OpCompositeExtract %5 %45 1 ; matrix 1 column 1 %89 = OpCompositeExtract %4 %88 0 ; matrix 1 row 0 column 1 %90 = OpCompositeExtract %4 %83 1 ; matrix 2 row 1 column 0 %91 = OpFMul %4 %89 %90 %92 = OpFAdd %4 %87 %91 %93 = OpCompositeExtract %5 %45 0 ; matrix 1 column 0 %94 = OpCompositeExtract %4 %93 1 ; matrix 1 row 1 column 0 %95 = OpCompositeExtract %4 %83 0 ; matrix 2 row 0 column 0 %96 = OpFMul %4 %94 %95 %97 = OpCompositeExtract %5 %45 1 ; matrix 1 column 1 %98 = OpCompositeExtract %4 %97 1 ; matrix 1 row 1 column 1 %99 = OpCompositeExtract %4 %83 1 ; matrix 2 row 1 column 0 %100 = OpFMul %4 %98 %99 %101 = OpFAdd %4 %96 %100 %102 = OpCompositeConstruct %5 %92 %101 ; resulting matrix column 0 %103 = OpCompositeExtract %5 %45 1 ; matrix 2 column 1 %104 = OpCompositeExtract %5 %45 0 ; matrix 1 column 0 %105 = OpCompositeExtract %4 %104 0 ; matrix 1 row 0 column 0 %106 = OpCompositeExtract %4 %103 0 ; matrix 2 row 0 column 1 %107 = OpFMul %4 %105 %106 %108 = OpCompositeExtract %5 %45 1 ; matrix 1 column 1 %109 = OpCompositeExtract %4 %108 0 ; matrix 1 row 0 column 1 %110 = OpCompositeExtract %4 %103 1 ; matrix 2 row 1 column 1 %111 = OpFMul %4 %109 %110 %112 = OpFAdd %4 %107 %111 %113 = OpCompositeExtract %5 %45 0 ; matrix 1 column 0 %114 = OpCompositeExtract %4 %113 1 ; matrix 1 row 1 column 0 %115 = OpCompositeExtract %4 %103 0 ; matrix 2 row 0 column 1 %116 = OpFMul %4 %114 %115 %117 = OpCompositeExtract %5 %45 1 ; matrix 1 column 1 %118 = OpCompositeExtract %4 %117 1 ; matrix 1 row 1 column 1 %119 = OpCompositeExtract %4 %103 1 ; matrix 2 row 1 column 1 %120 = OpFMul %4 %118 %119 %121 = OpFAdd %4 %116 %120 %122 = OpCompositeConstruct %5 %112 %121 ; resulting matrix column 1 %56 = OpCompositeConstruct %8 %102 %122 ; resulting matrix ; Multiplying 2x2 matrix by 2x3 matrix %123 = OpCompositeExtract %5 %46 0 ; matrix 2 column 0 %124 = OpCompositeExtract %5 %45 0 ; matrix 1 column 0 %125 = OpCompositeExtract %4 %124 0 ; matrix 1 row 0 column 0 %126 = OpCompositeExtract %4 %123 0 ; matrix 2 row 0 column 0 %127 = OpFMul %4 %125 %126 %128 = OpCompositeExtract %5 %45 1 ; matrix 1 column 1 %129 = OpCompositeExtract %4 %128 0 ; matrix 1 row 0 column 1 %130 = OpCompositeExtract %4 %123 1 ; matrix 2 row 1 column 0 %131 = OpFMul %4 %129 %130 %132 = OpFAdd %4 %127 %131 %133 = OpCompositeExtract %5 %45 0 ; matrix 1 column 0 %134 = OpCompositeExtract %4 %133 1 ; matrix 1 row 1 column 0 %135 = OpCompositeExtract %4 %123 0 ; matrix 2 row 0 column 0 %136 = OpFMul %4 %134 %135 %137 = OpCompositeExtract %5 %45 1 ; matrix 1 column 1 %138 = OpCompositeExtract %4 %137 1 ; matrix 1 row 1 column 1 %139 = OpCompositeExtract %4 %123 1 ; matrix 2 row 1 column 0 %140 = OpFMul %4 %138 %139 %141 = OpFAdd %4 %136 %140 %142 = OpCompositeConstruct %5 %132 %141 ; resulting matrix column 0 %143 = OpCompositeExtract %5 %46 1 ; matrix 2 column 1 %144 = OpCompositeExtract %5 %45 0 ; matrix 1 column 0 %145 = OpCompositeExtract %4 %144 0 ; matrix 1 row 0 column 0 %146 = OpCompositeExtract %4 %143 0 ; matrix 2 row 0 column 1 %147 = OpFMul %4 %145 %146 %148 = OpCompositeExtract %5 %45 1 ; matrix 1 column 1 %149 = OpCompositeExtract %4 %148 0 ; matrix 1 row 0 column 1 %150 = OpCompositeExtract %4 %143 1 ; matrix 2 row 1 column 1 %151 = OpFMul %4 %149 %150 %152 = OpFAdd %4 %147 %151 %153 = OpCompositeExtract %5 %45 0 ; matrix 1 column 0 %154 = OpCompositeExtract %4 %153 1 ; matrix 1 row 1 column 0 %155 = OpCompositeExtract %4 %143 0 ; matrix 2 row 0 column 1 %156 = OpFMul %4 %154 %155 %157 = OpCompositeExtract %5 %45 1 ; matrix 1 column 1 %158 = OpCompositeExtract %4 %157 1 ; matrix 1 row 1 column 1 %159 = OpCompositeExtract %4 %143 1 ; matrix 2 row 1 column 1 %160 = OpFMul %4 %158 %159 %161 = OpFAdd %4 %156 %160 %162 = OpCompositeConstruct %5 %152 %161 ; resulting matrix column 1 %163 = OpCompositeExtract %5 %46 2 ; matrix 2 column 2 %164 = OpCompositeExtract %5 %45 0 ; matrix 1 column 0 %165 = OpCompositeExtract %4 %164 0 ; matrix 1 row 0 column 0 %166 = OpCompositeExtract %4 %163 0 ; matrix 2 row 0 column 2 %167 = OpFMul %4 %165 %166 %168 = OpCompositeExtract %5 %45 1 ; matrix 1 column 1 %169 = OpCompositeExtract %4 %168 0 ; matrix 1 row 0 column 1 %170 = OpCompositeExtract %4 %163 1 ; matrix 2 row 1 column 2 %171 = OpFMul %4 %169 %170 %172 = OpFAdd %4 %167 %171 %173 = OpCompositeExtract %5 %45 0 ; matrix 1 column 0 %174 = OpCompositeExtract %4 %173 1 ; matrix 1 row 1 column 0 %175 = OpCompositeExtract %4 %163 0 ; matrix 2 row 0 column 2 %176 = OpFMul %4 %174 %175 %177 = OpCompositeExtract %5 %45 1 ; matrix 1 column 1 %178 = OpCompositeExtract %4 %177 1 ; matrix 1 row 1 column 1 %179 = OpCompositeExtract %4 %163 1 ; matrix 2 row 1 column 2 %180 = OpFMul %4 %178 %179 %181 = OpFAdd %4 %176 %180 %182 = OpCompositeConstruct %5 %172 %181 ; resulting matrix column 2 %57 = OpCompositeConstruct %9 %142 %162 %182 ; Multiplying 2x2 matrix by 2x4 matrix %183 = OpCompositeExtract %5 %47 0 ; matrix 2 column 0 %184 = OpCompositeExtract %5 %45 0 ; matrix 1 column 0 %185 = OpCompositeExtract %4 %184 0 ; matrix 1 row 0 column 0 %186 = OpCompositeExtract %4 %183 0 ; matrix 2 row 0 column 0 %187 = OpFMul %4 %185 %186 %188 = OpCompositeExtract %5 %45 1 ; matrix 1 column 1 %189 = OpCompositeExtract %4 %188 0 ; matrix 1 row 0 column 1 %190 = OpCompositeExtract %4 %183 1 ; matrix 2 row 1 column 0 %191 = OpFMul %4 %189 %190 %192 = OpFAdd %4 %187 %191 %193 = OpCompositeExtract %5 %45 0 ; matrix 1 column 0 %194 = OpCompositeExtract %4 %193 1 ; matrix 1 row 1 column 0 %195 = OpCompositeExtract %4 %183 0 ; matrix 2 row 0 column 0 %196 = OpFMul %4 %194 %195 %197 = OpCompositeExtract %5 %45 1 ; matrix 1 column 1 %198 = OpCompositeExtract %4 %197 1 ; matrix 1 row 1 column 1 %199 = OpCompositeExtract %4 %183 1 ; matrix 2 row 1 column 0 %200 = OpFMul %4 %198 %199 %201 = OpFAdd %4 %196 %200 %202 = OpCompositeConstruct %5 %192 %201 ; resulting matrix column 0 %203 = OpCompositeExtract %5 %47 1 ; matrix 2 column 1 %204 = OpCompositeExtract %5 %45 0 ; matrix 1 column 0 %205 = OpCompositeExtract %4 %204 0 ; matrix 1 row 0 column 0 %206 = OpCompositeExtract %4 %203 0 ; matrix 2 row 0 column 1 %207 = OpFMul %4 %205 %206 %208 = OpCompositeExtract %5 %45 1 ; matrix 1 column 1 %209 = OpCompositeExtract %4 %208 0 ; matrix 1 row 0 column 1 %210 = OpCompositeExtract %4 %203 1 ; matrix 2 row 1 column 1 %211 = OpFMul %4 %209 %210 %212 = OpFAdd %4 %207 %211 %213 = OpCompositeExtract %5 %45 0 ; matrix 1 column 0 %214 = OpCompositeExtract %4 %213 1 ; matrix 1 row 1 column 0 %215 = OpCompositeExtract %4 %203 0 ; matrix 2 row 0 column 1 %216 = OpFMul %4 %214 %215 %217 = OpCompositeExtract %5 %45 1 ; matrix 1 column 1 %218 = OpCompositeExtract %4 %217 1 ; matrix 1 row 1 column 1 %219 = OpCompositeExtract %4 %203 1 ; matrix 2 row 1 column 1 %220 = OpFMul %4 %218 %219 %221 = OpFAdd %4 %216 %220 %222 = OpCompositeConstruct %5 %212 %221 ; resulting matrix column 1 %223 = OpCompositeExtract %5 %47 2 ; matrix 2 column 2 %224 = OpCompositeExtract %5 %45 0 ; matrix 1 column 0 %225 = OpCompositeExtract %4 %224 0 ; matrix 1 row 0 column 0 %226 = OpCompositeExtract %4 %223 0 ; matrix 2 row 0 column 2 %227 = OpFMul %4 %225 %226 %228 = OpCompositeExtract %5 %45 1 ; matrix 1 column 1 %229 = OpCompositeExtract %4 %228 0 ; matrix 1 row 0 column 1 %230 = OpCompositeExtract %4 %223 1 ; matrix 2 row 1 column 2 %231 = OpFMul %4 %229 %230 %232 = OpFAdd %4 %227 %231 %233 = OpCompositeExtract %5 %45 0 ; matrix 1 column 0 %234 = OpCompositeExtract %4 %233 1 ; matrix 1 row 1 column 0 %235 = OpCompositeExtract %4 %223 0 ; matrix 2 row 0 column 2 %236 = OpFMul %4 %234 %235 %237 = OpCompositeExtract %5 %45 1 ; matrix 1 column 1 %238 = OpCompositeExtract %4 %237 1 ; matrix 1 row 1 column 1 %239 = OpCompositeExtract %4 %223 1 ; matrix 2 row 1 column 2 %240 = OpFMul %4 %238 %239 %241 = OpFAdd %4 %236 %240 %242 = OpCompositeConstruct %5 %232 %241 ; resulting matrix column 2 %243 = OpCompositeExtract %5 %47 3 ; matrix 2 column 3 %244 = OpCompositeExtract %5 %45 0 ; matrix 1 column 0 %245 = OpCompositeExtract %4 %244 0 ; matrix 1 row 0 column 0 %246 = OpCompositeExtract %4 %243 0 ; matrix 2 row 0 column 3 %247 = OpFMul %4 %245 %246 %248 = OpCompositeExtract %5 %45 1 ; matrix 1 column 1 %249 = OpCompositeExtract %4 %248 0 ; matrix 1 row 0 column 1 %250 = OpCompositeExtract %4 %243 1 ; matrix 2 row 1 column 3 %251 = OpFMul %4 %249 %250 %252 = OpFAdd %4 %247 %251 %253 = OpCompositeExtract %5 %45 0 ; matrix 1 column 0 %254 = OpCompositeExtract %4 %253 1 ; matrix 1 row 1 column 0 %255 = OpCompositeExtract %4 %243 0 ; matrix 2 row 0 column 3 %256 = OpFMul %4 %254 %255 %257 = OpCompositeExtract %5 %45 1 ; matrix 1 column 1 %258 = OpCompositeExtract %4 %257 1 ; matrix 1 row 1 column 1 %259 = OpCompositeExtract %4 %243 1 ; matrix 2 row 1 column 3 %260 = OpFMul %4 %258 %259 %261 = OpFAdd %4 %256 %260 %262 = OpCompositeConstruct %5 %252 %261 ; resulting matrix column 3 %58 = OpCompositeConstruct %10 %202 %222 %242 %262 ; Multiplying 2x3 matrix by 3x2 matrix %59 = OpMatrixTimesMatrix %8 %46 %48 ; Multiplying 2x3 matrix by 3x3 matrix %60 = OpMatrixTimesMatrix %9 %46 %49 ; Multiplying 2x3 matrix by 3x4 matrix %61 = OpMatrixTimesMatrix %10 %46 %50 ; Multiplying 2x4 matrix by 4x2 matrix %62 = OpMatrixTimesMatrix %8 %47 %51 ; Multiplying 2x4 matrix by 4x3 matrix %63 = OpMatrixTimesMatrix %9 %47 %52 ; Multiplying 2x4 matrix by 4x4 matrix %64 = OpMatrixTimesMatrix %10 %47 %53 ; Multiplying 3x2 matrix by 2x2 matrix %65 = OpMatrixTimesMatrix %11 %48 %45 ; Multiplying 3x2 matrix by 2x3 matrix %66 = OpMatrixTimesMatrix %12 %48 %46 ; Multiplying 3x2 matrix by 2x4 matrix %67 = OpMatrixTimesMatrix %13 %48 %47 ; Multiplying 3x3 matrix by 3x2 matrix %68 = OpMatrixTimesMatrix %11 %49 %48 ; Multiplying 3x3 matrix by 3x3 matrix %69 = OpMatrixTimesMatrix %12 %49 %49 ; Multiplying 3x3 matrix by 3x4 matrix %70 = OpMatrixTimesMatrix %13 %49 %50 ; Multiplying 3x4 matrix by 4x2 matrix %71 = OpMatrixTimesMatrix %11 %50 %51 ; Multiplying 3x4 matrix by 4x3 matrix %72 = OpMatrixTimesMatrix %12 %50 %52 ; Multiplying 3x4 matrix by 4x4 matrix %73 = OpMatrixTimesMatrix %13 %50 %53 ; Multiplying 4x2 matrix by 2x2 matrix %74 = OpMatrixTimesMatrix %14 %51 %45 ; Multiplying 4x2 matrix by 2x3 matrix %75 = OpMatrixTimesMatrix %15 %51 %46 ; Multiplying 4x2 matrix by 2x4 matrix %76 = OpMatrixTimesMatrix %16 %51 %47 ; Multiplying 4x3 matrix by 3x2 matrix %77 = OpMatrixTimesMatrix %14 %52 %48 ; Multiplying 4x3 matrix by 3x3 matrix %78 = OpMatrixTimesMatrix %15 %52 %49 ; Multiplying 4x3 matrix by 3x4 matrix %79 = OpMatrixTimesMatrix %16 %52 %50 ; Multiplying 4x4 matrix by 4x2 matrix %80 = OpMatrixTimesMatrix %14 %53 %51 ; Multiplying 4x4 matrix by 4x3 matrix %81 = OpMatrixTimesMatrix %15 %53 %52 ; Multiplying 4x4 matrix by 4x4 matrix %82 = OpMatrixTimesMatrix %16 %53 %53 OpReturn OpFunctionEnd )"; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(IsEqual(env, variant_shader, context.get())); } TEST(TransformationReplaceLinearAlgebraInstructionTest, ReplaceOpOuterProduct) { std::string reference_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %45 "main" ; Types %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeFloat 32 %5 = OpTypeVector %4 2 %6 = OpTypeVector %4 3 %7 = OpTypeVector %4 4 %8 = OpTypeMatrix %5 2 %9 = OpTypeMatrix %5 3 %10 = OpTypeMatrix %5 4 %11 = OpTypeMatrix %6 2 %12 = OpTypeMatrix %6 3 %13 = OpTypeMatrix %6 4 %14 = OpTypeMatrix %7 2 %15 = OpTypeMatrix %7 3 %16 = OpTypeMatrix %7 4 ; Constant scalars %17 = OpConstant %4 1 %18 = OpConstant %4 2 %19 = OpConstant %4 3 %20 = OpConstant %4 4 %21 = OpConstant %4 5 %22 = OpConstant %4 6 %23 = OpConstant %4 7 %24 = OpConstant %4 8 %25 = OpConstant %4 9 %26 = OpConstant %4 10 %27 = OpConstant %4 11 %28 = OpConstant %4 12 %29 = OpConstant %4 13 %30 = OpConstant %4 14 %31 = OpConstant %4 15 %32 = OpConstant %4 16 ; Constant vectors %33 = OpConstantComposite %5 %17 %18 %34 = OpConstantComposite %5 %19 %20 %35 = OpConstantComposite %5 %21 %22 %36 = OpConstantComposite %5 %23 %24 %37 = OpConstantComposite %6 %17 %18 %19 %38 = OpConstantComposite %6 %20 %21 %22 %39 = OpConstantComposite %6 %23 %24 %25 %40 = OpConstantComposite %6 %26 %27 %28 %41 = OpConstantComposite %7 %17 %18 %19 %20 %42 = OpConstantComposite %7 %21 %22 %23 %24 %43 = OpConstantComposite %7 %25 %26 %27 %28 %44 = OpConstantComposite %7 %29 %30 %31 %32 ; main function %45 = OpFunction %2 None %3 %46 = OpLabel ; Multiplying 2-dimensional vector by 2-dimensional vector %47 = OpOuterProduct %8 %33 %34 ; Multiplying 2-dimensional vector by 3-dimensional vector %48 = OpOuterProduct %9 %35 %37 ; Multiplying 2-dimensional vector by 4-dimensional vector %49 = OpOuterProduct %10 %36 %41 ; Multiplying 3-dimensional vector by 2-dimensional vector %50 = OpOuterProduct %11 %37 %33 ; Multiplying 3-dimensional vector by 3-dimensional vector %51 = OpOuterProduct %12 %38 %39 ; Multiplying 3-dimensional vector by 4-dimensional vector %52 = OpOuterProduct %13 %40 %41 ; Multiplying 4-dimensional vector by 2-dimensional vector %53 = OpOuterProduct %14 %41 %33 ; Multiplying 4-dimensional vector by 3-dimensional vector %54 = OpOuterProduct %15 %42 %37 ; Multiplying 4-dimensional vector by 4-dimensional vector %55 = OpOuterProduct %16 %43 %44 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto instruction_descriptor = MakeInstructionDescriptor(47, spv::Op::OpOuterProduct, 0); auto transformation = TransformationReplaceLinearAlgebraInstruction( {56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67}, instruction_descriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); instruction_descriptor = MakeInstructionDescriptor(48, spv::Op::OpOuterProduct, 0); transformation = TransformationReplaceLinearAlgebraInstruction( {68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85}, instruction_descriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); instruction_descriptor = MakeInstructionDescriptor(49, spv::Op::OpOuterProduct, 0); transformation = TransformationReplaceLinearAlgebraInstruction( {86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109}, instruction_descriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); instruction_descriptor = MakeInstructionDescriptor(50, spv::Op::OpOuterProduct, 0); transformation = TransformationReplaceLinearAlgebraInstruction( {110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125}, instruction_descriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); std::string variant_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %45 "main" ; Types %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeFloat 32 %5 = OpTypeVector %4 2 %6 = OpTypeVector %4 3 %7 = OpTypeVector %4 4 %8 = OpTypeMatrix %5 2 %9 = OpTypeMatrix %5 3 %10 = OpTypeMatrix %5 4 %11 = OpTypeMatrix %6 2 %12 = OpTypeMatrix %6 3 %13 = OpTypeMatrix %6 4 %14 = OpTypeMatrix %7 2 %15 = OpTypeMatrix %7 3 %16 = OpTypeMatrix %7 4 ; Constant scalars %17 = OpConstant %4 1 %18 = OpConstant %4 2 %19 = OpConstant %4 3 %20 = OpConstant %4 4 %21 = OpConstant %4 5 %22 = OpConstant %4 6 %23 = OpConstant %4 7 %24 = OpConstant %4 8 %25 = OpConstant %4 9 %26 = OpConstant %4 10 %27 = OpConstant %4 11 %28 = OpConstant %4 12 %29 = OpConstant %4 13 %30 = OpConstant %4 14 %31 = OpConstant %4 15 %32 = OpConstant %4 16 ; Constant vectors %33 = OpConstantComposite %5 %17 %18 %34 = OpConstantComposite %5 %19 %20 %35 = OpConstantComposite %5 %21 %22 %36 = OpConstantComposite %5 %23 %24 %37 = OpConstantComposite %6 %17 %18 %19 %38 = OpConstantComposite %6 %20 %21 %22 %39 = OpConstantComposite %6 %23 %24 %25 %40 = OpConstantComposite %6 %26 %27 %28 %41 = OpConstantComposite %7 %17 %18 %19 %20 %42 = OpConstantComposite %7 %21 %22 %23 %24 %43 = OpConstantComposite %7 %25 %26 %27 %28 %44 = OpConstantComposite %7 %29 %30 %31 %32 ; main function %45 = OpFunction %2 None %3 %46 = OpLabel ; Multiplying 2-dimensional vector by 2-dimensional vector %56 = OpCompositeExtract %4 %34 0 %57 = OpCompositeExtract %4 %33 0 %58 = OpFMul %4 %56 %57 %59 = OpCompositeExtract %4 %33 1 %60 = OpFMul %4 %56 %59 %61 = OpCompositeConstruct %5 %58 %60 %62 = OpCompositeExtract %4 %34 1 %63 = OpCompositeExtract %4 %33 0 %64 = OpFMul %4 %62 %63 %65 = OpCompositeExtract %4 %33 1 %66 = OpFMul %4 %62 %65 %67 = OpCompositeConstruct %5 %64 %66 %47 = OpCompositeConstruct %8 %61 %67 ; Multiplying 2-dimensional vector by 3-dimensional vector %68 = OpCompositeExtract %4 %37 0 %69 = OpCompositeExtract %4 %35 0 %70 = OpFMul %4 %68 %69 %71 = OpCompositeExtract %4 %35 1 %72 = OpFMul %4 %68 %71 %73 = OpCompositeConstruct %5 %70 %72 %74 = OpCompositeExtract %4 %37 1 %75 = OpCompositeExtract %4 %35 0 %76 = OpFMul %4 %74 %75 %77 = OpCompositeExtract %4 %35 1 %78 = OpFMul %4 %74 %77 %79 = OpCompositeConstruct %5 %76 %78 %80 = OpCompositeExtract %4 %37 2 %81 = OpCompositeExtract %4 %35 0 %82 = OpFMul %4 %80 %81 %83 = OpCompositeExtract %4 %35 1 %84 = OpFMul %4 %80 %83 %85 = OpCompositeConstruct %5 %82 %84 %48 = OpCompositeConstruct %9 %73 %79 %85 ; Multiplying 2-dimensional vector by 4-dimensional vector %86 = OpCompositeExtract %4 %41 0 %87 = OpCompositeExtract %4 %36 0 %88 = OpFMul %4 %86 %87 %89 = OpCompositeExtract %4 %36 1 %90 = OpFMul %4 %86 %89 %91 = OpCompositeConstruct %5 %88 %90 %92 = OpCompositeExtract %4 %41 1 %93 = OpCompositeExtract %4 %36 0 %94 = OpFMul %4 %92 %93 %95 = OpCompositeExtract %4 %36 1 %96 = OpFMul %4 %92 %95 %97 = OpCompositeConstruct %5 %94 %96 %98 = OpCompositeExtract %4 %41 2 %99 = OpCompositeExtract %4 %36 0 %100 = OpFMul %4 %98 %99 %101 = OpCompositeExtract %4 %36 1 %102 = OpFMul %4 %98 %101 %103 = OpCompositeConstruct %5 %100 %102 %104 = OpCompositeExtract %4 %41 3 %105 = OpCompositeExtract %4 %36 0 %106 = OpFMul %4 %104 %105 %107 = OpCompositeExtract %4 %36 1 %108 = OpFMul %4 %104 %107 %109 = OpCompositeConstruct %5 %106 %108 %49 = OpCompositeConstruct %10 %91 %97 %103 %109 ; Multiplying 3-dimensional vector by 2-dimensional vector %110 = OpCompositeExtract %4 %33 0 %111 = OpCompositeExtract %4 %37 0 %112 = OpFMul %4 %110 %111 %113 = OpCompositeExtract %4 %37 1 %114 = OpFMul %4 %110 %113 %115 = OpCompositeExtract %4 %37 2 %116 = OpFMul %4 %110 %115 %117 = OpCompositeConstruct %6 %112 %114 %116 %118 = OpCompositeExtract %4 %33 1 %119 = OpCompositeExtract %4 %37 0 %120 = OpFMul %4 %118 %119 %121 = OpCompositeExtract %4 %37 1 %122 = OpFMul %4 %118 %121 %123 = OpCompositeExtract %4 %37 2 %124 = OpFMul %4 %118 %123 %125 = OpCompositeConstruct %6 %120 %122 %124 %50 = OpCompositeConstruct %11 %117 %125 ; Multiplying 3-dimensional vector by 3-dimensional vector %51 = OpOuterProduct %12 %38 %39 ; Multiplying 3-dimensional vector by 4-dimensional vector %52 = OpOuterProduct %13 %40 %41 ; Multiplying 4-dimensional vector by 2-dimensional vector %53 = OpOuterProduct %14 %41 %33 ; Multiplying 4-dimensional vector by 3-dimensional vector %54 = OpOuterProduct %15 %42 %37 ; Multiplying 4-dimensional vector by 4-dimensional vector %55 = OpOuterProduct %16 %43 %44 OpReturn OpFunctionEnd )"; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(IsEqual(env, variant_shader, context.get())); } TEST(TransformationReplaceLinearAlgebraInstructionTest, ReplaceOpDot) { std::string reference_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %22 "main" OpExecutionMode %22 OriginUpperLeft OpSource ESSL 310 OpName %22 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeFloat 32 %5 = OpTypeVector %4 2 %6 = OpTypeVector %4 3 %7 = OpTypeVector %4 4 %8 = OpConstant %4 1 %9 = OpConstant %4 2 %10 = OpConstant %4 3 %11 = OpConstant %4 4 %12 = OpConstant %4 5 %13 = OpConstant %4 6 %14 = OpConstant %4 7 %15 = OpConstant %4 8 %16 = OpConstantComposite %5 %8 %9 %17 = OpConstantComposite %5 %10 %11 %18 = OpConstantComposite %6 %8 %9 %10 %19 = OpConstantComposite %6 %11 %12 %13 %20 = OpConstantComposite %7 %8 %9 %10 %11 %21 = OpConstantComposite %7 %12 %13 %14 %15 %22 = OpFunction %2 None %3 %23 = OpLabel %24 = OpDot %4 %16 %17 %25 = OpDot %4 %18 %19 %26 = OpDot %4 %20 %21 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, reference_shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto instruction_descriptor = MakeInstructionDescriptor(24, spv::Op::OpDot, 0); auto transformation = TransformationReplaceLinearAlgebraInstruction( {27, 28, 29, 30, 31, 32}, instruction_descriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); instruction_descriptor = MakeInstructionDescriptor(25, spv::Op::OpDot, 0); transformation = TransformationReplaceLinearAlgebraInstruction( {33, 34, 35, 36, 37, 38, 39, 40, 41, 42}, instruction_descriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); instruction_descriptor = MakeInstructionDescriptor(26, spv::Op::OpDot, 0); transformation = TransformationReplaceLinearAlgebraInstruction( {43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56}, instruction_descriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); std::string variant_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %22 "main" OpExecutionMode %22 OriginUpperLeft OpSource ESSL 310 OpName %22 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeFloat 32 %5 = OpTypeVector %4 2 %6 = OpTypeVector %4 3 %7 = OpTypeVector %4 4 %8 = OpConstant %4 1 %9 = OpConstant %4 2 %10 = OpConstant %4 3 %11 = OpConstant %4 4 %12 = OpConstant %4 5 %13 = OpConstant %4 6 %14 = OpConstant %4 7 %15 = OpConstant %4 8 %16 = OpConstantComposite %5 %8 %9 %17 = OpConstantComposite %5 %10 %11 %18 = OpConstantComposite %6 %8 %9 %10 %19 = OpConstantComposite %6 %11 %12 %13 %20 = OpConstantComposite %7 %8 %9 %10 %11 %21 = OpConstantComposite %7 %12 %13 %14 %15 %22 = OpFunction %2 None %3 %23 = OpLabel %27 = OpCompositeExtract %4 %16 0 %28 = OpCompositeExtract %4 %17 0 %29 = OpFMul %4 %27 %28 %30 = OpCompositeExtract %4 %16 1 %31 = OpCompositeExtract %4 %17 1 %32 = OpFMul %4 %30 %31 %24 = OpFAdd %4 %29 %32 %33 = OpCompositeExtract %4 %18 0 %34 = OpCompositeExtract %4 %19 0 %35 = OpFMul %4 %33 %34 %36 = OpCompositeExtract %4 %18 1 %37 = OpCompositeExtract %4 %19 1 %38 = OpFMul %4 %36 %37 %39 = OpCompositeExtract %4 %18 2 %40 = OpCompositeExtract %4 %19 2 %41 = OpFMul %4 %39 %40 %42 = OpFAdd %4 %35 %38 %25 = OpFAdd %4 %41 %42 %43 = OpCompositeExtract %4 %20 0 %44 = OpCompositeExtract %4 %21 0 %45 = OpFMul %4 %43 %44 %46 = OpCompositeExtract %4 %20 1 %47 = OpCompositeExtract %4 %21 1 %48 = OpFMul %4 %46 %47 %49 = OpCompositeExtract %4 %20 2 %50 = OpCompositeExtract %4 %21 2 %51 = OpFMul %4 %49 %50 %52 = OpCompositeExtract %4 %20 3 %53 = OpCompositeExtract %4 %21 3 %54 = OpFMul %4 %52 %53 %55 = OpFAdd %4 %45 %48 %56 = OpFAdd %4 %51 %55 %26 = OpFAdd %4 %54 %56 OpReturn OpFunctionEnd )"; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(IsEqual(env, variant_shader, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools transformation_replace_load_store_with_copy_memory_test.cpp000066400000000000000000000255511475742701700346330ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/fuzz// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_replace_load_store_with_copy_memory.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationReplaceLoadStoreWithCopyMemoryTest, BasicScenarios) { // This is a simple transformation and this test handles the main cases. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %26 %28 %31 %33 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "a" OpName %10 "b" OpName %12 "c" OpName %14 "d" OpName %18 "e" OpName %20 "f" OpName %26 "i1" OpName %28 "i2" OpName %31 "g1" OpName %33 "g2" OpDecorate %26 Location 0 OpDecorate %28 Location 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 2 %11 = OpConstant %6 3 %13 = OpConstant %6 4 %15 = OpConstant %6 5 %16 = OpTypeFloat 32 %17 = OpTypePointer Function %16 %19 = OpConstant %16 2 %21 = OpConstant %16 3 %25 = OpTypePointer Output %6 %26 = OpVariable %25 Output %27 = OpConstant %6 1 %28 = OpVariable %25 Output %30 = OpTypePointer Private %6 %31 = OpVariable %30 Private %32 = OpConstant %6 0 %33 = OpVariable %30 Private %35 = OpTypeBool %36 = OpConstantTrue %35 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %12 = OpVariable %7 Function %14 = OpVariable %7 Function %18 = OpVariable %17 Function %20 = OpVariable %17 Function OpStore %8 %9 OpStore %10 %11 OpStore %12 %13 OpStore %14 %15 OpStore %18 %19 OpStore %20 %21 %22 = OpLoad %6 %8 OpCopyMemory %10 %8 OpStore %10 %22 %23 = OpLoad %6 %12 OpStore %14 %23 %24 = OpLoad %16 %18 OpStore %20 %24 OpStore %26 %27 OpStore %28 %27 %29 = OpLoad %6 %26 OpMemoryBarrier %32 %32 OpStore %28 %29 OpStore %31 %32 OpStore %33 %32 %34 = OpLoad %6 %33 OpSelectionMerge %38 None OpBranchConditional %36 %37 %38 %37 = OpLabel OpStore %31 %34 OpBranch %38 %38 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); auto bad_instruction_descriptor_1 = MakeInstructionDescriptor(11, spv::Op::OpConstant, 0); auto load_instruction_descriptor_1 = MakeInstructionDescriptor(22, spv::Op::OpLoad, 0); auto load_instruction_descriptor_2 = MakeInstructionDescriptor(23, spv::Op::OpLoad, 0); auto load_instruction_descriptor_3 = MakeInstructionDescriptor(24, spv::Op::OpLoad, 0); auto load_instruction_descriptor_other_block = MakeInstructionDescriptor(34, spv::Op::OpLoad, 0); auto load_instruction_descriptor_unsafe = MakeInstructionDescriptor(29, spv::Op::OpLoad, 0); auto store_instruction_descriptor_1 = MakeInstructionDescriptor(22, spv::Op::OpStore, 0); auto store_instruction_descriptor_2 = MakeInstructionDescriptor(23, spv::Op::OpStore, 0); auto store_instruction_descriptor_3 = MakeInstructionDescriptor(24, spv::Op::OpStore, 0); auto store_instruction_descriptor_other_block = MakeInstructionDescriptor(37, spv::Op::OpStore, 0); auto store_instruction_descriptor_unsafe = MakeInstructionDescriptor(29, spv::Op::OpStore, 0); // Bad: |load_instruction_descriptor| is incorrect. auto transformation_bad_1 = TransformationReplaceLoadStoreWithCopyMemory( bad_instruction_descriptor_1, store_instruction_descriptor_1); ASSERT_FALSE( transformation_bad_1.IsApplicable(context.get(), transformation_context)); // Bad: |store_instruction_descriptor| is incorrect. auto transformation_bad_2 = TransformationReplaceLoadStoreWithCopyMemory( load_instruction_descriptor_1, bad_instruction_descriptor_1); ASSERT_FALSE( transformation_bad_2.IsApplicable(context.get(), transformation_context)); // Bad: Intermediate values of the OpLoad and the OpStore don't match. auto transformation_bad_3 = TransformationReplaceLoadStoreWithCopyMemory( load_instruction_descriptor_1, store_instruction_descriptor_2); ASSERT_FALSE( transformation_bad_3.IsApplicable(context.get(), transformation_context)); // Bad: There is an interfering OpCopyMemory instruction between the OpLoad // and the OpStore. auto transformation_bad_4 = TransformationReplaceLoadStoreWithCopyMemory( load_instruction_descriptor_1, store_instruction_descriptor_1); ASSERT_FALSE( transformation_bad_4.IsApplicable(context.get(), transformation_context)); // Bad: There is an interfering OpMemoryBarrier instruction between the OpLoad // and the OpStore. auto transformation_bad_5 = TransformationReplaceLoadStoreWithCopyMemory( load_instruction_descriptor_unsafe, store_instruction_descriptor_unsafe); ASSERT_FALSE( transformation_bad_5.IsApplicable(context.get(), transformation_context)); // Bad: OpLoad and OpStore instructions are in different blocks. auto transformation_bad_6 = TransformationReplaceLoadStoreWithCopyMemory( load_instruction_descriptor_other_block, store_instruction_descriptor_other_block); ASSERT_FALSE( transformation_bad_6.IsApplicable(context.get(), transformation_context)); auto transformation_good_1 = TransformationReplaceLoadStoreWithCopyMemory( load_instruction_descriptor_2, store_instruction_descriptor_2); ASSERT_TRUE(transformation_good_1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); auto transformation_good_2 = TransformationReplaceLoadStoreWithCopyMemory( load_instruction_descriptor_3, store_instruction_descriptor_3); ASSERT_TRUE(transformation_good_2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation_good_2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformations = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %26 %28 %31 %33 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "a" OpName %10 "b" OpName %12 "c" OpName %14 "d" OpName %18 "e" OpName %20 "f" OpName %26 "i1" OpName %28 "i2" OpName %31 "g1" OpName %33 "g2" OpDecorate %26 Location 0 OpDecorate %28 Location 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 2 %11 = OpConstant %6 3 %13 = OpConstant %6 4 %15 = OpConstant %6 5 %16 = OpTypeFloat 32 %17 = OpTypePointer Function %16 %19 = OpConstant %16 2 %21 = OpConstant %16 3 %25 = OpTypePointer Output %6 %26 = OpVariable %25 Output %27 = OpConstant %6 1 %28 = OpVariable %25 Output %30 = OpTypePointer Private %6 %31 = OpVariable %30 Private %32 = OpConstant %6 0 %33 = OpVariable %30 Private %35 = OpTypeBool %36 = OpConstantTrue %35 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %12 = OpVariable %7 Function %14 = OpVariable %7 Function %18 = OpVariable %17 Function %20 = OpVariable %17 Function OpStore %8 %9 OpStore %10 %11 OpStore %12 %13 OpStore %14 %15 OpStore %18 %19 OpStore %20 %21 %22 = OpLoad %6 %8 OpCopyMemory %10 %8 OpStore %10 %22 %23 = OpLoad %6 %12 OpCopyMemory %14 %12 %24 = OpLoad %16 %18 OpCopyMemory %20 %18 OpStore %26 %27 OpStore %28 %27 %29 = OpLoad %6 %26 OpMemoryBarrier %32 %32 OpStore %28 %29 OpStore %31 %32 OpStore %33 %32 %34 = OpLoad %6 %33 OpSelectionMerge %38 None OpBranchConditional %36 %37 %38 %37 = OpLabel OpStore %31 %34 OpBranch %38 %38 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformations, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools transformation_replace_opphi_id_from_dead_predecessor_test.cpp000066400000000000000000000173031475742701700352100ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/fuzz// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_replace_opphi_id_from_dead_predecessor.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpConstantFalse %5 %8 = OpTypeInt 32 1 %9 = OpConstant %8 2 %10 = OpConstant %8 3 %11 = OpConstant %8 4 %12 = OpConstant %8 5 %13 = OpConstant %8 6 %2 = OpFunction %3 None %4 %14 = OpLabel OpSelectionMerge %15 None OpBranchConditional %6 %16 %17 %16 = OpLabel %18 = OpCopyObject %8 %9 OpSelectionMerge %19 None OpBranchConditional %7 %20 %21 %20 = OpLabel %22 = OpCopyObject %8 %10 %23 = OpCopyObject %8 %12 OpBranch %19 %21 = OpLabel %24 = OpCopyObject %8 %9 OpBranch %19 %19 = OpLabel %25 = OpPhi %8 %22 %20 %24 %21 OpBranch %15 %17 = OpLabel %26 = OpCopyObject %8 %12 %27 = OpCopyObject %8 %13 OpBranch %28 %28 = OpLabel %29 = OpPhi %8 %27 %17 OpBranch %15 %15 = OpLabel %30 = OpPhi %8 %25 %19 %26 %28 OpReturn OpFunctionEnd )"; TEST(TransformationReplaceOpPhiIdFromDeadPredecessorTest, Inapplicable) { const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Record the fact that blocks 20, 17, 28 are dead. transformation_context.GetFactManager()->AddFactBlockIsDead(20); transformation_context.GetFactManager()->AddFactBlockIsDead(17); transformation_context.GetFactManager()->AddFactBlockIsDead(28); // %26 is not an OpPhi instruction. ASSERT_FALSE(TransformationReplaceOpPhiIdFromDeadPredecessor(26, 14, 10) .IsApplicable(context.get(), transformation_context)); // %25 is not a block label. ASSERT_FALSE(TransformationReplaceOpPhiIdFromDeadPredecessor(30, 25, 10) .IsApplicable(context.get(), transformation_context)); // %14 is not a predecessor of %28 (which contains %29). ASSERT_FALSE(TransformationReplaceOpPhiIdFromDeadPredecessor(29, 14, 10) .IsApplicable(context.get(), transformation_context)); // %19 is not a dead block. ASSERT_FALSE(TransformationReplaceOpPhiIdFromDeadPredecessor(30, 19, 10) .IsApplicable(context.get(), transformation_context)); // %7 does not have the same type id as %25. ASSERT_FALSE( TransformationReplaceOpPhiIdFromDeadPredecessor(25, 20, 7).IsApplicable( context.get(), transformation_context)); // %29 is not available at the end of %20. ASSERT_FALSE(TransformationReplaceOpPhiIdFromDeadPredecessor(25, 20, 29) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationReplaceOpPhiIdFromDeadPredecessorTest, Apply) { const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Record the fact that blocks 20, 17, 28 are dead. transformation_context.GetFactManager()->AddFactBlockIsDead(20); transformation_context.GetFactManager()->AddFactBlockIsDead(17); transformation_context.GetFactManager()->AddFactBlockIsDead(28); auto transformation1 = TransformationReplaceOpPhiIdFromDeadPredecessor(25, 20, 18); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); auto transformation2 = TransformationReplaceOpPhiIdFromDeadPredecessor(30, 28, 29); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); auto transformation3 = TransformationReplaceOpPhiIdFromDeadPredecessor(29, 17, 10); ASSERT_TRUE( transformation3.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation3, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformations = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpConstantFalse %5 %8 = OpTypeInt 32 1 %9 = OpConstant %8 2 %10 = OpConstant %8 3 %11 = OpConstant %8 4 %12 = OpConstant %8 5 %13 = OpConstant %8 6 %2 = OpFunction %3 None %4 %14 = OpLabel OpSelectionMerge %15 None OpBranchConditional %6 %16 %17 %16 = OpLabel %18 = OpCopyObject %8 %9 OpSelectionMerge %19 None OpBranchConditional %7 %20 %21 %20 = OpLabel %22 = OpCopyObject %8 %10 %23 = OpCopyObject %8 %12 OpBranch %19 %21 = OpLabel %24 = OpCopyObject %8 %9 OpBranch %19 %19 = OpLabel %25 = OpPhi %8 %18 %20 %24 %21 OpBranch %15 %17 = OpLabel %26 = OpCopyObject %8 %12 %27 = OpCopyObject %8 %13 OpBranch %28 %28 = OpLabel %29 = OpPhi %8 %10 %17 OpBranch %15 %15 = OpLabel %30 = OpPhi %8 %25 %19 %29 %28 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformations, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools transformation_replace_opselect_with_conditional_branch_test.cpp000066400000000000000000000245631475742701700355760ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/fuzz// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_replace_opselect_with_conditional_branch.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationReplaceOpSelectWithConditionalBranchTest, Inapplicable) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpConstant %5 1 %7 = OpConstant %5 2 %8 = OpTypeVector %5 4 %9 = OpConstantNull %8 %10 = OpConstantComposite %8 %6 %6 %7 %7 %11 = OpTypeBool %12 = OpTypeVector %11 4 %13 = OpConstantTrue %11 %14 = OpConstantFalse %11 %15 = OpConstantComposite %12 %13 %14 %14 %13 %2 = OpFunction %3 None %4 %16 = OpLabel %17 = OpCopyObject %5 %6 %18 = OpCopyObject %5 %7 OpBranch %19 %19 = OpLabel %20 = OpCopyObject %5 %17 %21 = OpSelect %5 %13 %17 %18 OpBranch %22 %22 = OpLabel %23 = OpSelect %8 %15 %9 %10 OpBranch %24 %24 = OpLabel OpSelectionMerge %25 None OpBranchConditional %13 %26 %27 %26 = OpLabel %28 = OpSelect %5 %13 %17 %18 OpBranch %27 %27 = OpLabel %29 = OpSelect %5 %13 %17 %18 OpBranch %25 %25 = OpLabel %30 = OpSelect %5 %13 %17 %18 OpBranch %31 %31 = OpLabel OpLoopMerge %32 %33 None OpBranch %33 %33 = OpLabel %34 = OpSelect %5 %13 %17 %18 OpBranchConditional %13 %31 %32 %32 = OpLabel %35 = OpSelect %5 %13 %17 %18 OpBranch %36 %36 = OpLabel %37 = OpSelect %5 %13 %17 %18 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // %20 is not an OpSelect instruction. ASSERT_FALSE(TransformationReplaceOpSelectWithConditionalBranch(20, 100, 101) .IsApplicable(context.get(), transformation_context)); // %21 is not the first instruction in its block. ASSERT_FALSE(TransformationReplaceOpSelectWithConditionalBranch(21, 100, 101) .IsApplicable(context.get(), transformation_context)); // The condition for %23 is not a scalar, but a vector of booleans. ASSERT_FALSE(TransformationReplaceOpSelectWithConditionalBranch(23, 100, 101) .IsApplicable(context.get(), transformation_context)); // The predecessor (%24) of the block containing %28 is the header of a // selection construct and does not branch unconditionally. ASSERT_FALSE(TransformationReplaceOpSelectWithConditionalBranch(24, 100, 101) .IsApplicable(context.get(), transformation_context)); // The block containing %29 has two predecessors (%24 and %26). ASSERT_FALSE(TransformationReplaceOpSelectWithConditionalBranch(29, 100, 101) .IsApplicable(context.get(), transformation_context)); // The block containing %30 is the merge block for a selection construct. ASSERT_FALSE(TransformationReplaceOpSelectWithConditionalBranch(30, 100, 101) .IsApplicable(context.get(), transformation_context)); // The predecessor (%31) of the block containing %34 is a loop header. ASSERT_FALSE(TransformationReplaceOpSelectWithConditionalBranch(31, 100, 101) .IsApplicable(context.get(), transformation_context)); // The block containing %35 is the merge block for a loop construct. ASSERT_FALSE(TransformationReplaceOpSelectWithConditionalBranch(35, 100, 101) .IsApplicable(context.get(), transformation_context)); #ifndef NDEBUG // |true_block_id| and |false_block_id| are both 0. ASSERT_DEATH( TransformationReplaceOpSelectWithConditionalBranch(37, 0, 0).IsApplicable( context.get(), transformation_context), "At least one of the ids must be non-zero."); #endif // The fresh ids are not distinct. ASSERT_FALSE(TransformationReplaceOpSelectWithConditionalBranch(37, 100, 100) .IsApplicable(context.get(), transformation_context)); // One of the ids is not fresh. ASSERT_FALSE(TransformationReplaceOpSelectWithConditionalBranch(37, 100, 10) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationReplaceOpSelectWithConditionalBranchTest, Simple) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpConstant %5 1 %7 = OpConstant %5 2 %8 = OpTypeVector %5 4 %9 = OpConstantNull %8 %10 = OpConstantComposite %8 %6 %6 %7 %7 %11 = OpTypeBool %12 = OpTypeVector %11 4 %13 = OpConstantTrue %11 %14 = OpConstantFalse %11 %15 = OpConstantComposite %12 %13 %14 %14 %13 %2 = OpFunction %3 None %4 %16 = OpLabel %17 = OpCopyObject %5 %6 %18 = OpCopyObject %5 %7 OpBranch %19 %19 = OpLabel %20 = OpSelect %5 %13 %17 %18 OpSelectionMerge %21 None OpBranchConditional %13 %22 %21 %22 = OpLabel OpBranch %23 %23 = OpLabel %24 = OpSelect %8 %13 %9 %10 OpBranch %21 %21 = OpLabel OpBranch %25 %25 = OpLabel %26 = OpSelect %5 %13 %17 %18 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto transformation = TransformationReplaceOpSelectWithConditionalBranch(20, 100, 101); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); auto transformation2 = TransformationReplaceOpSelectWithConditionalBranch(24, 0, 102); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); auto transformation3 = TransformationReplaceOpSelectWithConditionalBranch(26, 103, 0); ASSERT_TRUE( transformation3.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation3, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpConstant %5 1 %7 = OpConstant %5 2 %8 = OpTypeVector %5 4 %9 = OpConstantNull %8 %10 = OpConstantComposite %8 %6 %6 %7 %7 %11 = OpTypeBool %12 = OpTypeVector %11 4 %13 = OpConstantTrue %11 %14 = OpConstantFalse %11 %15 = OpConstantComposite %12 %13 %14 %14 %13 %2 = OpFunction %3 None %4 %16 = OpLabel %17 = OpCopyObject %5 %6 %18 = OpCopyObject %5 %7 OpSelectionMerge %19 None OpBranchConditional %13 %100 %101 %100 = OpLabel OpBranch %19 %101 = OpLabel OpBranch %19 %19 = OpLabel %20 = OpPhi %5 %17 %100 %18 %101 OpSelectionMerge %21 None OpBranchConditional %13 %22 %21 %22 = OpLabel OpSelectionMerge %23 None OpBranchConditional %13 %23 %102 %102 = OpLabel OpBranch %23 %23 = OpLabel %24 = OpPhi %8 %9 %22 %10 %102 OpBranch %21 %21 = OpLabel OpSelectionMerge %25 None OpBranchConditional %13 %103 %25 %103 = OpLabel OpBranch %25 %25 = OpLabel %26 = OpPhi %5 %17 %103 %18 %21 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_replace_parameter_with_global_test.cpp000066400000000000000000000323051475742701700334300ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_replace_parameter_with_global.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationReplaceParameterWithGlobalTest, BasicTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpMemberDecorate %13 0 RelaxedPrecision OpDecorate %16 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Private %6 %8 = OpTypeFloat 32 %9 = OpTypePointer Private %8 %10 = OpTypeVector %8 2 %11 = OpTypePointer Private %10 %12 = OpTypeBool %71 = OpTypeFunction %2 %6 %83 = OpTypeFunction %2 %6 %12 %93 = OpTypeFunction %2 %10 %94 = OpTypeFunction %2 %8 %10 %40 = OpTypePointer Function %12 %13 = OpTypeStruct %6 %8 %14 = OpTypePointer Private %13 %15 = OpTypeFunction %2 %6 %8 %10 %13 %40 %12 %22 = OpConstant %6 0 %23 = OpConstant %8 0 %26 = OpConstantComposite %10 %23 %23 %27 = OpConstantTrue %12 %28 = OpConstantComposite %13 %22 %23 %4 = OpFunction %2 None %3 %5 = OpLabel %41 = OpVariable %40 Function %27 %33 = OpFunctionCall %2 %20 %22 %23 %26 %28 %41 %27 OpReturn OpFunctionEnd ; adjust type of the function in-place %20 = OpFunction %2 None %15 %16 = OpFunctionParameter %6 %17 = OpFunctionParameter %8 %18 = OpFunctionParameter %10 %19 = OpFunctionParameter %13 %42 = OpFunctionParameter %40 %43 = OpFunctionParameter %12 %21 = OpLabel OpReturn OpFunctionEnd ; reuse an existing function type %70 = OpFunction %2 None %71 %72 = OpFunctionParameter %6 %73 = OpLabel OpReturn OpFunctionEnd %74 = OpFunction %2 None %71 %75 = OpFunctionParameter %6 %76 = OpLabel OpReturn OpFunctionEnd ; create a new function type %77 = OpFunction %2 None %83 %78 = OpFunctionParameter %6 %84 = OpFunctionParameter %12 %79 = OpLabel OpReturn OpFunctionEnd %80 = OpFunction %2 None %83 %81 = OpFunctionParameter %6 %85 = OpFunctionParameter %12 %82 = OpLabel OpReturn OpFunctionEnd ; don't adjust the type of the function if it creates a duplicate %86 = OpFunction %2 None %93 %87 = OpFunctionParameter %10 %89 = OpLabel OpReturn OpFunctionEnd %90 = OpFunction %2 None %94 %91 = OpFunctionParameter %8 %95 = OpFunctionParameter %10 %92 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Parameter id is invalid. ASSERT_FALSE(TransformationReplaceParameterWithGlobal(50, 50, 51) .IsApplicable(context.get(), transformation_context)); // Parameter id is not a result id of an OpFunctionParameter instruction. ASSERT_FALSE(TransformationReplaceParameterWithGlobal(50, 21, 51) .IsApplicable(context.get(), transformation_context)); // Parameter has unsupported type. ASSERT_FALSE(TransformationReplaceParameterWithGlobal(50, 42, 51) .IsApplicable(context.get(), transformation_context)); // Initializer for a global variable doesn't exist in the module. ASSERT_FALSE(TransformationReplaceParameterWithGlobal(50, 43, 51) .IsApplicable(context.get(), transformation_context)); // Pointer type for a global variable doesn't exist in the module. ASSERT_FALSE(TransformationReplaceParameterWithGlobal(50, 43, 51) .IsApplicable(context.get(), transformation_context)); // Function type id is not fresh. ASSERT_FALSE(TransformationReplaceParameterWithGlobal(16, 16, 51) .IsApplicable(context.get(), transformation_context)); // Global variable id is not fresh. ASSERT_FALSE(TransformationReplaceParameterWithGlobal(50, 16, 16) .IsApplicable(context.get(), transformation_context)); // Function type fresh id and global variable fresh id are equal. ASSERT_FALSE(TransformationReplaceParameterWithGlobal(50, 16, 50) .IsApplicable(context.get(), transformation_context)); { TransformationReplaceParameterWithGlobal transformation(50, 16, 51); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } { TransformationReplaceParameterWithGlobal transformation(52, 17, 53); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } { TransformationReplaceParameterWithGlobal transformation(54, 18, 55); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } { TransformationReplaceParameterWithGlobal transformation(56, 19, 57); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } { TransformationReplaceParameterWithGlobal transformation(58, 75, 59); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } { TransformationReplaceParameterWithGlobal transformation(60, 81, 61); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } { TransformationReplaceParameterWithGlobal transformation(62, 91, 63); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string expected_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpMemberDecorate %13 0 RelaxedPrecision OpDecorate %16 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Private %6 %8 = OpTypeFloat 32 %9 = OpTypePointer Private %8 %10 = OpTypeVector %8 2 %11 = OpTypePointer Private %10 %12 = OpTypeBool %71 = OpTypeFunction %2 %6 %83 = OpTypeFunction %2 %6 %12 %93 = OpTypeFunction %2 %10 %40 = OpTypePointer Function %12 %13 = OpTypeStruct %6 %8 %14 = OpTypePointer Private %13 %22 = OpConstant %6 0 %23 = OpConstant %8 0 %26 = OpConstantComposite %10 %23 %23 %27 = OpConstantTrue %12 %28 = OpConstantComposite %13 %22 %23 %51 = OpVariable %7 Private %22 %53 = OpVariable %9 Private %23 %55 = OpVariable %11 Private %26 %57 = OpVariable %14 Private %28 %15 = OpTypeFunction %2 %40 %12 %59 = OpVariable %7 Private %22 %61 = OpVariable %7 Private %22 %60 = OpTypeFunction %2 %12 %63 = OpVariable %9 Private %23 %4 = OpFunction %2 None %3 %5 = OpLabel %41 = OpVariable %40 Function %27 OpStore %51 %22 OpStore %53 %23 OpStore %55 %26 OpStore %57 %28 %33 = OpFunctionCall %2 %20 %41 %27 OpReturn OpFunctionEnd %20 = OpFunction %2 None %15 %42 = OpFunctionParameter %40 %43 = OpFunctionParameter %12 %21 = OpLabel %19 = OpLoad %13 %57 %18 = OpLoad %10 %55 %17 = OpLoad %8 %53 %16 = OpLoad %6 %51 OpReturn OpFunctionEnd %70 = OpFunction %2 None %71 %72 = OpFunctionParameter %6 %73 = OpLabel OpReturn OpFunctionEnd %74 = OpFunction %2 None %3 %76 = OpLabel %75 = OpLoad %6 %59 OpReturn OpFunctionEnd %77 = OpFunction %2 None %83 %78 = OpFunctionParameter %6 %84 = OpFunctionParameter %12 %79 = OpLabel OpReturn OpFunctionEnd %80 = OpFunction %2 None %60 %85 = OpFunctionParameter %12 %82 = OpLabel %81 = OpLoad %6 %61 OpReturn OpFunctionEnd %86 = OpFunction %2 None %93 %87 = OpFunctionParameter %10 %89 = OpLabel OpReturn OpFunctionEnd %90 = OpFunction %2 None %93 %95 = OpFunctionParameter %10 %92 = OpLabel %91 = OpLoad %8 %63 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected_shader, context.get())); } TEST(TransformationReplaceParameterWithGlobalTest, HandlesIrrelevantParameters) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %9 = OpTypeInt 32 1 %3 = OpTypeFunction %2 %7 = OpTypeFunction %2 %9 %9 %12 = OpTypePointer Private %9 %13 = OpConstant %9 0 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %6 = OpFunction %2 None %7 %10 = OpFunctionParameter %9 %11 = OpFunctionParameter %9 %8 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactIdIsIrrelevant(10); { TransformationReplaceParameterWithGlobal transformation(20, 10, 21); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(21)); } { TransformationReplaceParameterWithGlobal transformation(22, 11, 23); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_FALSE( transformation_context.GetFactManager()->PointeeValueIsIrrelevant(23)); } } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_replace_params_with_struct_test.cpp000066400000000000000000000477501475742701700330310ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_replace_params_with_struct.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationReplaceParamsWithStructTest, BasicTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpMemberDecorate %13 0 RelaxedPrecision OpDecorate %16 RelaxedPrecision %2 = OpTypeVoid %6 = OpTypeInt 32 1 %3 = OpTypeFunction %2 %7 = OpTypePointer Private %6 %8 = OpTypeFloat 32 %9 = OpTypePointer Private %8 %10 = OpTypeVector %8 2 %11 = OpTypePointer Private %10 %12 = OpTypeBool %51 = OpTypeFunction %2 %12 %64 = OpTypeStruct %6 %63 = OpTypeFunction %2 %64 %65 = OpTypeFunction %2 %6 %75 = OpTypeStruct %8 %76 = OpTypeFunction %2 %75 %77 = OpTypeFunction %2 %8 %40 = OpTypePointer Function %12 %13 = OpTypeStruct %6 %8 %45 = OpTypeStruct %6 %10 %13 %46 = OpTypeStruct %12 %47 = OpTypeStruct %8 %45 %46 %14 = OpTypePointer Private %13 %15 = OpTypeFunction %2 %6 %8 %10 %13 %40 %12 %22 = OpConstant %6 0 %23 = OpConstant %8 0 %26 = OpConstantComposite %10 %23 %23 %27 = OpConstantTrue %12 %28 = OpConstantComposite %13 %22 %23 %4 = OpFunction %2 None %3 %5 = OpLabel %41 = OpVariable %40 Function %27 %33 = OpFunctionCall %2 %20 %22 %23 %26 %28 %41 %27 OpReturn OpFunctionEnd ; adjust type of the function in-place %20 = OpFunction %2 None %15 %16 = OpFunctionParameter %6 %17 = OpFunctionParameter %8 %18 = OpFunctionParameter %10 %19 = OpFunctionParameter %13 %42 = OpFunctionParameter %40 %43 = OpFunctionParameter %12 %21 = OpLabel OpReturn OpFunctionEnd ; create a new function type %50 = OpFunction %2 None %51 %52 = OpFunctionParameter %12 %53 = OpLabel OpReturn OpFunctionEnd %54 = OpFunction %2 None %51 %55 = OpFunctionParameter %12 %56 = OpLabel OpReturn OpFunctionEnd ; reuse an existing function type %57 = OpFunction %2 None %63 %58 = OpFunctionParameter %64 %59 = OpLabel OpReturn OpFunctionEnd %60 = OpFunction %2 None %65 %61 = OpFunctionParameter %6 %62 = OpLabel OpReturn OpFunctionEnd %66 = OpFunction %2 None %65 %67 = OpFunctionParameter %6 %68 = OpLabel OpReturn OpFunctionEnd ; don't adjust the type of the function if it creates a duplicate %69 = OpFunction %2 None %76 %70 = OpFunctionParameter %75 %71 = OpLabel OpReturn OpFunctionEnd %72 = OpFunction %2 None %77 %73 = OpFunctionParameter %8 %74 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // |parameter_id| is empty. ASSERT_FALSE( TransformationReplaceParamsWithStruct({}, 90, 91, {{33, 92}, {90, 93}}) .IsApplicable(context.get(), transformation_context)); // |parameter_id| has duplicates. ASSERT_FALSE(TransformationReplaceParamsWithStruct({16, 16, 17}, 90, 91, {{33, 92}, {90, 93}}) .IsApplicable(context.get(), transformation_context)); // |parameter_id| has invalid values. ASSERT_FALSE(TransformationReplaceParamsWithStruct({21, 16, 17}, 90, 91, {{33, 92}, {90, 93}}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationReplaceParamsWithStruct({16, 90, 17}, 90, 91, {{33, 92}, {90, 93}}) .IsApplicable(context.get(), transformation_context)); // Parameter's belong to different functions. ASSERT_FALSE(TransformationReplaceParamsWithStruct({16, 17, 52}, 90, 91, {{33, 92}, {90, 93}}) .IsApplicable(context.get(), transformation_context)); // Parameter has unsupported type. ASSERT_FALSE(TransformationReplaceParamsWithStruct({16, 17, 42, 43}, 90, 91, {{33, 92}, {90, 93}}) .IsApplicable(context.get(), transformation_context)); // OpTypeStruct does not exist in the module. ASSERT_FALSE(TransformationReplaceParamsWithStruct({16, 43}, 90, 91, {{33, 92}, {90, 93}}) .IsApplicable(context.get(), transformation_context)); // |caller_id_to_fresh_composite_id| misses values. ASSERT_FALSE( TransformationReplaceParamsWithStruct({16, 17}, 90, 91, {{90, 93}}) .IsApplicable(context.get(), transformation_context)); // All fresh ids must be unique. ASSERT_FALSE(TransformationReplaceParamsWithStruct({16, 17}, 90, 90, {{33, 92}, {90, 93}}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationReplaceParamsWithStruct({16, 17}, 90, 91, {{33, 90}, {90, 93}}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationReplaceParamsWithStruct({16, 17}, 90, 91, {{33, 92}, {90, 92}}) .IsApplicable(context.get(), transformation_context)); // All 'fresh' ids must be fresh. ASSERT_FALSE(TransformationReplaceParamsWithStruct({16, 17}, 90, 91, {{33, 33}, {90, 93}}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationReplaceParamsWithStruct({16, 17}, 33, 91, {{33, 92}, {90, 93}}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationReplaceParamsWithStruct({16, 17}, 90, 33, {{33, 92}, {90, 93}}) .IsApplicable(context.get(), transformation_context)); { TransformationReplaceParamsWithStruct transformation({16, 18, 19}, 90, 91, {{33, 92}, {90, 93}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } { TransformationReplaceParamsWithStruct transformation({43}, 93, 94, {{33, 95}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } { TransformationReplaceParamsWithStruct transformation({17, 91, 94}, 96, 97, {{33, 98}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } { TransformationReplaceParamsWithStruct transformation({55}, 99, 100, {{}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } { TransformationReplaceParamsWithStruct transformation({61}, 101, 102, {{}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } { TransformationReplaceParamsWithStruct transformation({73}, 103, 104, {{}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string expected_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpMemberDecorate %13 0 RelaxedPrecision OpDecorate %16 RelaxedPrecision %2 = OpTypeVoid %6 = OpTypeInt 32 1 %3 = OpTypeFunction %2 %7 = OpTypePointer Private %6 %8 = OpTypeFloat 32 %9 = OpTypePointer Private %8 %10 = OpTypeVector %8 2 %11 = OpTypePointer Private %10 %12 = OpTypeBool %51 = OpTypeFunction %2 %12 %64 = OpTypeStruct %6 %63 = OpTypeFunction %2 %64 %65 = OpTypeFunction %2 %6 %75 = OpTypeStruct %8 %76 = OpTypeFunction %2 %75 %40 = OpTypePointer Function %12 %13 = OpTypeStruct %6 %8 %45 = OpTypeStruct %6 %10 %13 %46 = OpTypeStruct %12 %47 = OpTypeStruct %8 %45 %46 %14 = OpTypePointer Private %13 %22 = OpConstant %6 0 %23 = OpConstant %8 0 %26 = OpConstantComposite %10 %23 %23 %27 = OpConstantTrue %12 %28 = OpConstantComposite %13 %22 %23 %15 = OpTypeFunction %2 %40 %47 %99 = OpTypeFunction %2 %46 %4 = OpFunction %2 None %3 %5 = OpLabel %41 = OpVariable %40 Function %27 %92 = OpCompositeConstruct %45 %22 %26 %28 %95 = OpCompositeConstruct %46 %27 %98 = OpCompositeConstruct %47 %23 %92 %95 %33 = OpFunctionCall %2 %20 %41 %98 OpReturn OpFunctionEnd %20 = OpFunction %2 None %15 %42 = OpFunctionParameter %40 %97 = OpFunctionParameter %47 %21 = OpLabel %94 = OpCompositeExtract %46 %97 2 %91 = OpCompositeExtract %45 %97 1 %17 = OpCompositeExtract %8 %97 0 %43 = OpCompositeExtract %12 %94 0 %19 = OpCompositeExtract %13 %91 2 %18 = OpCompositeExtract %10 %91 1 %16 = OpCompositeExtract %6 %91 0 OpReturn OpFunctionEnd %50 = OpFunction %2 None %51 %52 = OpFunctionParameter %12 %53 = OpLabel OpReturn OpFunctionEnd %54 = OpFunction %2 None %99 %100 = OpFunctionParameter %46 %56 = OpLabel %55 = OpCompositeExtract %12 %100 0 OpReturn OpFunctionEnd %57 = OpFunction %2 None %63 %58 = OpFunctionParameter %64 %59 = OpLabel OpReturn OpFunctionEnd %60 = OpFunction %2 None %63 %102 = OpFunctionParameter %64 %62 = OpLabel %61 = OpCompositeExtract %6 %102 0 OpReturn OpFunctionEnd %66 = OpFunction %2 None %65 %67 = OpFunctionParameter %6 %68 = OpLabel OpReturn OpFunctionEnd %69 = OpFunction %2 None %76 %70 = OpFunctionParameter %75 %71 = OpLabel OpReturn OpFunctionEnd %72 = OpFunction %2 None %76 %104 = OpFunctionParameter %75 %74 = OpLabel %73 = OpCompositeExtract %8 %104 0 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, expected_shader, context.get())); } TEST(TransformationReplaceParamsWithStructTest, ParametersRemainValid) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %6 = OpTypeInt 32 1 %3 = OpTypeFunction %2 %8 = OpTypeFloat 32 %10 = OpTypeVector %8 2 %12 = OpTypeBool %40 = OpTypePointer Function %12 %13 = OpTypeStruct %6 %8 %45 = OpTypeStruct %6 %8 %13 %47 = OpTypeStruct %45 %12 %10 %15 = OpTypeFunction %2 %6 %8 %10 %13 %40 %12 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %20 = OpFunction %2 None %15 %16 = OpFunctionParameter %6 %17 = OpFunctionParameter %8 %18 = OpFunctionParameter %10 %19 = OpFunctionParameter %13 %42 = OpFunctionParameter %40 %43 = OpFunctionParameter %12 %21 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); { // Try to replace parameters in "increasing" order of their declaration. TransformationReplaceParamsWithStruct transformation({16, 17, 19}, 70, 71, {{}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %6 = OpTypeInt 32 1 %3 = OpTypeFunction %2 %8 = OpTypeFloat 32 %10 = OpTypeVector %8 2 %12 = OpTypeBool %40 = OpTypePointer Function %12 %13 = OpTypeStruct %6 %8 %45 = OpTypeStruct %6 %8 %13 %47 = OpTypeStruct %45 %12 %10 %15 = OpTypeFunction %2 %10 %40 %12 %45 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %20 = OpFunction %2 None %15 %18 = OpFunctionParameter %10 %42 = OpFunctionParameter %40 %43 = OpFunctionParameter %12 %71 = OpFunctionParameter %45 %21 = OpLabel %19 = OpCompositeExtract %13 %71 2 %17 = OpCompositeExtract %8 %71 1 %16 = OpCompositeExtract %6 %71 0 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); { // Try to replace parameters in "decreasing" order of their declaration. TransformationReplaceParamsWithStruct transformation({71, 43, 18}, 72, 73, {{}}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %6 = OpTypeInt 32 1 %3 = OpTypeFunction %2 %8 = OpTypeFloat 32 %10 = OpTypeVector %8 2 %12 = OpTypeBool %40 = OpTypePointer Function %12 %13 = OpTypeStruct %6 %8 %45 = OpTypeStruct %6 %8 %13 %47 = OpTypeStruct %45 %12 %10 %15 = OpTypeFunction %2 %40 %47 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %20 = OpFunction %2 None %15 %42 = OpFunctionParameter %40 %73 = OpFunctionParameter %47 %21 = OpLabel %18 = OpCompositeExtract %10 %73 2 %43 = OpCompositeExtract %12 %73 1 %71 = OpCompositeExtract %45 %73 0 %19 = OpCompositeExtract %13 %71 2 %17 = OpCompositeExtract %8 %71 1 %16 = OpCompositeExtract %6 %71 0 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationReplaceParamsWithStructTest, IsomorphicStructs) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %16 "main" OpExecutionMode %16 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %6 = OpTypeInt 32 1 %7 = OpTypeStruct %6 %8 = OpTypeStruct %6 %9 = OpTypeStruct %8 %10 = OpTypeFunction %2 %7 %15 = OpTypeFunction %2 %16 = OpFunction %2 None %15 %17 = OpLabel OpReturn OpFunctionEnd %11 = OpFunction %2 None %10 %12 = OpFunctionParameter %7 %13 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_FALSE(TransformationReplaceParamsWithStruct({12}, 100, 101, {{}}) .IsApplicable(context.get(), transformation_context)); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_set_function_control_test.cpp000066400000000000000000000225661475742701700316520ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_set_function_control.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationSetFunctionControlTest, VariousScenarios) { // This is a simple transformation; this test captures the important things // to check for. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %54 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %11 "foo(i1;i1;" OpName %9 "a" OpName %10 "b" OpName %13 "bar(" OpName %17 "baz(i1;" OpName %16 "x" OpName %21 "boo(i1;i1;" OpName %19 "a" OpName %20 "b" OpName %29 "g" OpName %42 "param" OpName %44 "param" OpName %45 "param" OpName %48 "param" OpName %49 "param" OpName %54 "color" OpDecorate %54 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %6 %7 %7 %15 = OpTypeFunction %6 %7 %28 = OpTypePointer Private %6 %29 = OpVariable %28 Private %30 = OpConstant %6 2 %31 = OpConstant %6 5 %51 = OpTypeFloat 32 %52 = OpTypeVector %51 4 %53 = OpTypePointer Output %52 %54 = OpVariable %53 Output %4 = OpFunction %2 None %3 %5 = OpLabel %42 = OpVariable %7 Function %44 = OpVariable %7 Function %45 = OpVariable %7 Function %48 = OpVariable %7 Function %49 = OpVariable %7 Function %41 = OpFunctionCall %2 %13 OpStore %42 %30 %43 = OpFunctionCall %6 %17 %42 OpStore %44 %31 %46 = OpLoad %6 %29 OpStore %45 %46 %47 = OpFunctionCall %6 %21 %44 %45 OpStore %48 %43 OpStore %49 %47 %50 = OpFunctionCall %6 %11 %48 %49 OpReturn OpFunctionEnd %11 = OpFunction %6 Const %8 %9 = OpFunctionParameter %7 %10 = OpFunctionParameter %7 %12 = OpLabel %23 = OpLoad %6 %9 %24 = OpLoad %6 %10 %25 = OpIAdd %6 %23 %24 OpReturnValue %25 OpFunctionEnd %13 = OpFunction %2 Inline %3 %14 = OpLabel OpStore %29 %30 OpReturn OpFunctionEnd %17 = OpFunction %6 Pure|DontInline %15 %16 = OpFunctionParameter %7 %18 = OpLabel %32 = OpLoad %6 %16 %33 = OpIAdd %6 %31 %32 OpReturnValue %33 OpFunctionEnd %21 = OpFunction %6 DontInline %8 %19 = OpFunctionParameter %7 %20 = OpFunctionParameter %7 %22 = OpLabel %36 = OpLoad %6 %19 %37 = OpLoad %6 %20 %38 = OpIMul %6 %36 %37 OpReturnValue %38 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // %36 is not a function ASSERT_FALSE(TransformationSetFunctionControl( 36, uint32_t(spv::FunctionControlMask::MaskNone)) .IsApplicable(context.get(), transformation_context)); // Cannot add the Pure function control to %4 as it did not already have it ASSERT_FALSE(TransformationSetFunctionControl( 4, uint32_t(spv::FunctionControlMask::Pure)) .IsApplicable(context.get(), transformation_context)); // Cannot add the Const function control to %21 as it did not already // have it ASSERT_FALSE(TransformationSetFunctionControl( 21, uint32_t(spv::FunctionControlMask::Const)) .IsApplicable(context.get(), transformation_context)); // Set to None, removing Const TransformationSetFunctionControl transformation1( 11, uint32_t(spv::FunctionControlMask::MaskNone)); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); // Set to Inline; silly to do it on an entry point, but it is allowed TransformationSetFunctionControl transformation2( 4, uint32_t(spv::FunctionControlMask::Inline)); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); // Set to Pure, removing DontInline TransformationSetFunctionControl transformation3( 17, uint32_t(spv::FunctionControlMask::Pure)); ASSERT_TRUE( transformation3.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation3, context.get(), &transformation_context); // Change from Inline to DontInline TransformationSetFunctionControl transformation4( 13, uint32_t(spv::FunctionControlMask::DontInline)); ASSERT_TRUE( transformation4.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation4, context.get(), &transformation_context); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %54 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %11 "foo(i1;i1;" OpName %9 "a" OpName %10 "b" OpName %13 "bar(" OpName %17 "baz(i1;" OpName %16 "x" OpName %21 "boo(i1;i1;" OpName %19 "a" OpName %20 "b" OpName %29 "g" OpName %42 "param" OpName %44 "param" OpName %45 "param" OpName %48 "param" OpName %49 "param" OpName %54 "color" OpDecorate %54 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %6 %7 %7 %15 = OpTypeFunction %6 %7 %28 = OpTypePointer Private %6 %29 = OpVariable %28 Private %30 = OpConstant %6 2 %31 = OpConstant %6 5 %51 = OpTypeFloat 32 %52 = OpTypeVector %51 4 %53 = OpTypePointer Output %52 %54 = OpVariable %53 Output %4 = OpFunction %2 Inline %3 %5 = OpLabel %42 = OpVariable %7 Function %44 = OpVariable %7 Function %45 = OpVariable %7 Function %48 = OpVariable %7 Function %49 = OpVariable %7 Function %41 = OpFunctionCall %2 %13 OpStore %42 %30 %43 = OpFunctionCall %6 %17 %42 OpStore %44 %31 %46 = OpLoad %6 %29 OpStore %45 %46 %47 = OpFunctionCall %6 %21 %44 %45 OpStore %48 %43 OpStore %49 %47 %50 = OpFunctionCall %6 %11 %48 %49 OpReturn OpFunctionEnd %11 = OpFunction %6 None %8 %9 = OpFunctionParameter %7 %10 = OpFunctionParameter %7 %12 = OpLabel %23 = OpLoad %6 %9 %24 = OpLoad %6 %10 %25 = OpIAdd %6 %23 %24 OpReturnValue %25 OpFunctionEnd %13 = OpFunction %2 DontInline %3 %14 = OpLabel OpStore %29 %30 OpReturn OpFunctionEnd %17 = OpFunction %6 Pure %15 %16 = OpFunctionParameter %7 %18 = OpLabel %32 = OpLoad %6 %16 %33 = OpIAdd %6 %31 %32 OpReturnValue %33 OpFunctionEnd %21 = OpFunction %6 DontInline %8 %19 = OpFunctionParameter %7 %20 = OpFunctionParameter %7 %22 = OpLabel %36 = OpLoad %6 %19 %37 = OpLoad %6 %20 %38 = OpIMul %6 %36 %37 OpReturnValue %38 OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_set_loop_control_test.cpp000066400000000000000000001273321475742701700307730ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_set_loop_control.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationSetLoopControlTest, VariousScenarios) { // This test features loops with various different controls, and goes through // a number of acceptable and unacceptable transformations to those controls. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 100 %17 = OpTypeBool %20 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %22 = OpVariable %7 Function %32 = OpVariable %7 Function %42 = OpVariable %7 Function %52 = OpVariable %7 Function %62 = OpVariable %7 Function %72 = OpVariable %7 Function %82 = OpVariable %7 Function %92 = OpVariable %7 Function %102 = OpVariable %7 Function %112 = OpVariable %7 Function %122 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %132 = OpPhi %6 %9 %5 %21 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %132 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel OpBranch %13 %13 = OpLabel %21 = OpIAdd %6 %132 %20 OpStore %8 %21 OpBranch %10 %12 = OpLabel OpStore %22 %9 OpBranch %23 %23 = OpLabel %133 = OpPhi %6 %9 %12 %31 %26 OpLoopMerge %25 %26 Unroll OpBranch %27 %27 = OpLabel %29 = OpSLessThan %17 %133 %16 OpBranchConditional %29 %24 %25 %24 = OpLabel OpBranch %26 %26 = OpLabel %31 = OpIAdd %6 %133 %20 OpStore %22 %31 OpBranch %23 %25 = OpLabel OpStore %32 %9 OpBranch %33 %33 = OpLabel %134 = OpPhi %6 %9 %25 %41 %36 OpLoopMerge %35 %36 DontUnroll OpBranch %37 %37 = OpLabel %39 = OpSLessThan %17 %134 %16 OpBranchConditional %39 %34 %35 %34 = OpLabel OpBranch %36 %36 = OpLabel %41 = OpIAdd %6 %134 %20 OpStore %32 %41 OpBranch %33 %35 = OpLabel OpStore %42 %9 OpBranch %43 %43 = OpLabel %135 = OpPhi %6 %9 %35 %51 %46 OpLoopMerge %45 %46 DependencyInfinite OpBranch %47 %47 = OpLabel %49 = OpSLessThan %17 %135 %16 OpBranchConditional %49 %44 %45 %44 = OpLabel OpBranch %46 %46 = OpLabel %51 = OpIAdd %6 %135 %20 OpStore %42 %51 OpBranch %43 %45 = OpLabel OpStore %52 %9 OpBranch %53 %53 = OpLabel %136 = OpPhi %6 %9 %45 %61 %56 OpLoopMerge %55 %56 DependencyLength 3 OpBranch %57 %57 = OpLabel %59 = OpSLessThan %17 %136 %16 OpBranchConditional %59 %54 %55 %54 = OpLabel OpBranch %56 %56 = OpLabel %61 = OpIAdd %6 %136 %20 OpStore %52 %61 OpBranch %53 %55 = OpLabel OpStore %62 %9 OpBranch %63 %63 = OpLabel %137 = OpPhi %6 %9 %55 %71 %66 OpLoopMerge %65 %66 MinIterations 10 OpBranch %67 %67 = OpLabel %69 = OpSLessThan %17 %137 %16 OpBranchConditional %69 %64 %65 %64 = OpLabel OpBranch %66 %66 = OpLabel %71 = OpIAdd %6 %137 %20 OpStore %62 %71 OpBranch %63 %65 = OpLabel OpStore %72 %9 OpBranch %73 %73 = OpLabel %138 = OpPhi %6 %9 %65 %81 %76 OpLoopMerge %75 %76 MaxIterations 50 OpBranch %77 %77 = OpLabel %79 = OpSLessThan %17 %138 %16 OpBranchConditional %79 %74 %75 %74 = OpLabel OpBranch %76 %76 = OpLabel %81 = OpIAdd %6 %138 %20 OpStore %72 %81 OpBranch %73 %75 = OpLabel OpStore %82 %9 OpBranch %83 %83 = OpLabel %139 = OpPhi %6 %9 %75 %91 %86 OpLoopMerge %85 %86 IterationMultiple 4 OpBranch %87 %87 = OpLabel %89 = OpSLessThan %17 %139 %16 OpBranchConditional %89 %84 %85 %84 = OpLabel OpBranch %86 %86 = OpLabel %91 = OpIAdd %6 %139 %20 OpStore %82 %91 OpBranch %83 %85 = OpLabel OpStore %92 %9 OpBranch %93 %93 = OpLabel %140 = OpPhi %6 %9 %85 %101 %96 OpLoopMerge %95 %96 PeelCount 2 OpBranch %97 %97 = OpLabel %99 = OpSLessThan %17 %140 %16 OpBranchConditional %99 %94 %95 %94 = OpLabel OpBranch %96 %96 = OpLabel %101 = OpIAdd %6 %140 %20 OpStore %92 %101 OpBranch %93 %95 = OpLabel OpStore %102 %9 OpBranch %103 %103 = OpLabel %141 = OpPhi %6 %9 %95 %111 %106 OpLoopMerge %105 %106 PartialCount 3 OpBranch %107 %107 = OpLabel %109 = OpSLessThan %17 %141 %16 OpBranchConditional %109 %104 %105 %104 = OpLabel OpBranch %106 %106 = OpLabel %111 = OpIAdd %6 %141 %20 OpStore %102 %111 OpBranch %103 %105 = OpLabel OpStore %112 %9 OpBranch %113 %113 = OpLabel %142 = OpPhi %6 %9 %105 %121 %116 OpLoopMerge %115 %116 Unroll|PeelCount|PartialCount 3 4 OpBranch %117 %117 = OpLabel %119 = OpSLessThan %17 %142 %16 OpBranchConditional %119 %114 %115 %114 = OpLabel OpBranch %116 %116 = OpLabel %121 = OpIAdd %6 %142 %20 OpStore %112 %121 OpBranch %113 %115 = OpLabel OpStore %122 %9 OpBranch %123 %123 = OpLabel %143 = OpPhi %6 %9 %115 %131 %126 OpLoopMerge %125 %126 DependencyLength|MinIterations|MaxIterations|IterationMultiple|PeelCount|PartialCount 2 5 90 4 7 14 OpBranch %127 %127 = OpLabel %129 = OpSLessThan %17 %143 %16 OpBranchConditional %129 %124 %125 %124 = OpLabel OpBranch %126 %126 = OpLabel %131 = OpIAdd %6 %143 %20 OpStore %122 %131 OpBranch %123 %125 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // These are the loop headers together with the selection controls of their // merge instructions: // %10 None // %23 Unroll // %33 DontUnroll // %43 DependencyInfinite // %53 DependencyLength 3 // %63 MinIterations 10 // %73 MaxIterations 50 // %83 IterationMultiple 4 // %93 PeelCount 2 // %103 PartialCount 3 // %113 Unroll|PeelCount|PartialCount 3 4 // %123 // DependencyLength|MinIterations|MaxIterations|IterationMultiple|PeelCount|PartialCount // 2 5 90 4 7 14 ASSERT_TRUE(TransformationSetLoopControl( 10, (uint32_t)spv::LoopControlMask::MaskNone, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 10, (uint32_t)spv::LoopControlMask::Unroll, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 10, (uint32_t)spv::LoopControlMask::DontUnroll, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationSetLoopControl( 10, (uint32_t)spv::LoopControlMask::DependencyInfinite, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationSetLoopControl( 10, (uint32_t)spv::LoopControlMask::DependencyLength, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationSetLoopControl( 10, (uint32_t)spv::LoopControlMask::MinIterations, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationSetLoopControl( 10, (uint32_t)spv::LoopControlMask::MaxIterations, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationSetLoopControl( 10, (uint32_t)spv::LoopControlMask::IterationMultiple, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 10, (uint32_t)spv::LoopControlMask::PeelCount, 3, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationSetLoopControl( 10, (uint32_t)spv::LoopControlMask::PeelCount, 3, 3) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 10, (uint32_t)spv::LoopControlMask::PartialCount, 0, 3) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationSetLoopControl( 10, (uint32_t)spv::LoopControlMask::PartialCount, 3, 3) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 10, (uint32_t)spv::LoopControlMask::PeelCount | (uint32_t)spv::LoopControlMask::PartialCount, 3, 3) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 10, (uint32_t)spv::LoopControlMask::Unroll | (uint32_t)spv::LoopControlMask::PeelCount | (uint32_t)spv::LoopControlMask::PartialCount, 3, 3) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationSetLoopControl( 10, (uint32_t)spv::LoopControlMask::DontUnroll | (uint32_t)spv::LoopControlMask::PeelCount | (uint32_t)spv::LoopControlMask::PartialCount, 3, 3) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 23, (uint32_t)spv::LoopControlMask::MaskNone, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 23, (uint32_t)spv::LoopControlMask::Unroll, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 23, (uint32_t)spv::LoopControlMask::DontUnroll, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 23, (uint32_t)spv::LoopControlMask::PeelCount | (uint32_t)spv::LoopControlMask::PartialCount, 3, 3) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationSetLoopControl( 23, (uint32_t)spv::LoopControlMask::MaxIterations, 2, 3) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 33, (uint32_t)spv::LoopControlMask::MaskNone, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 33, (uint32_t)spv::LoopControlMask::Unroll, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 33, (uint32_t)spv::LoopControlMask::DontUnroll, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationSetLoopControl( 33, (uint32_t)spv::LoopControlMask::MinIterations, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 33, (uint32_t)spv::LoopControlMask::Unroll | (uint32_t)spv::LoopControlMask::PeelCount, 5, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationSetLoopControl( 33, (uint32_t)spv::LoopControlMask::DontUnroll | (uint32_t)spv::LoopControlMask::PartialCount, 0, 10) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 43, (uint32_t)spv::LoopControlMask::MaskNone, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 43, (uint32_t)spv::LoopControlMask::Unroll, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 43, (uint32_t)spv::LoopControlMask::DontUnroll, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 43, (uint32_t)spv::LoopControlMask::MaskNone | (uint32_t)spv::LoopControlMask::DependencyInfinite, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 43, (uint32_t)spv::LoopControlMask::Unroll | (uint32_t)spv::LoopControlMask::DependencyInfinite, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 43, (uint32_t)spv::LoopControlMask::DontUnroll | (uint32_t)spv::LoopControlMask::DependencyInfinite, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationSetLoopControl( 43, (uint32_t)spv::LoopControlMask::DependencyInfinite | (uint32_t)spv::LoopControlMask::DependencyLength, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 43, (uint32_t)spv::LoopControlMask::Unroll | (uint32_t)spv::LoopControlMask::PeelCount, 5, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 53, (uint32_t)spv::LoopControlMask::MaskNone, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 53, (uint32_t)spv::LoopControlMask::Unroll, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 53, (uint32_t)spv::LoopControlMask::DontUnroll, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationSetLoopControl( 53, (uint32_t)spv::LoopControlMask::MaxIterations, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 53, (uint32_t)spv::LoopControlMask::MaskNone | (uint32_t)spv::LoopControlMask::DependencyLength, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationSetLoopControl( 53, (uint32_t)spv::LoopControlMask::Unroll | (uint32_t)spv::LoopControlMask::DependencyInfinite, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 53, (uint32_t)spv::LoopControlMask::DontUnroll | (uint32_t)spv::LoopControlMask::DependencyLength, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationSetLoopControl( 53, (uint32_t)spv::LoopControlMask::DependencyInfinite | (uint32_t)spv::LoopControlMask::DependencyLength, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 53, (uint32_t)spv::LoopControlMask::Unroll | (uint32_t)spv::LoopControlMask::DependencyLength | (uint32_t)spv::LoopControlMask::PeelCount | (uint32_t)spv::LoopControlMask::PartialCount, 5, 3) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 63, (uint32_t)spv::LoopControlMask::MaskNone, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 63, (uint32_t)spv::LoopControlMask::Unroll, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 63, (uint32_t)spv::LoopControlMask::DontUnroll, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 63, (uint32_t)spv::LoopControlMask::Unroll | (uint32_t)spv::LoopControlMask::MinIterations | (uint32_t)spv::LoopControlMask::PeelCount | (uint32_t)spv::LoopControlMask::PartialCount, 5, 3) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 63, (uint32_t)spv::LoopControlMask::Unroll | (uint32_t)spv::LoopControlMask::MinIterations | (uint32_t)spv::LoopControlMask::PeelCount, 23, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationSetLoopControl( 63, (uint32_t)spv::LoopControlMask::Unroll | (uint32_t)spv::LoopControlMask::MinIterations | (uint32_t)spv::LoopControlMask::PeelCount, 2, 23) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 73, (uint32_t)spv::LoopControlMask::MaskNone, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 73, (uint32_t)spv::LoopControlMask::Unroll, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 73, (uint32_t)spv::LoopControlMask::DontUnroll, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationSetLoopControl( 73, (uint32_t)spv::LoopControlMask::Unroll | (uint32_t)spv::LoopControlMask::MinIterations | (uint32_t)spv::LoopControlMask::PeelCount | (uint32_t)spv::LoopControlMask::PartialCount, 5, 3) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 73, (uint32_t)spv::LoopControlMask::Unroll | (uint32_t)spv::LoopControlMask::MaxIterations | (uint32_t)spv::LoopControlMask::PeelCount, 23, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationSetLoopControl( 73, (uint32_t)spv::LoopControlMask::Unroll | (uint32_t)spv::LoopControlMask::MaxIterations | (uint32_t)spv::LoopControlMask::PeelCount, 2, 23) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 83, (uint32_t)spv::LoopControlMask::MaskNone, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 83, (uint32_t)spv::LoopControlMask::Unroll, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 83, (uint32_t)spv::LoopControlMask::DontUnroll, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationSetLoopControl( 83, (uint32_t)spv::LoopControlMask::Unroll | (uint32_t)spv::LoopControlMask::MinIterations | (uint32_t)spv::LoopControlMask::PeelCount | (uint32_t)spv::LoopControlMask::PartialCount, 5, 3) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 83, (uint32_t)spv::LoopControlMask::Unroll | (uint32_t)spv::LoopControlMask::IterationMultiple | (uint32_t)spv::LoopControlMask::PeelCount, 23, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationSetLoopControl( 83, (uint32_t)spv::LoopControlMask::Unroll | (uint32_t)spv::LoopControlMask::IterationMultiple | (uint32_t)spv::LoopControlMask::PeelCount, 2, 23) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 93, (uint32_t)spv::LoopControlMask::MaskNone, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 93, (uint32_t)spv::LoopControlMask::Unroll, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 93, (uint32_t)spv::LoopControlMask::DontUnroll, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 93, (uint32_t)spv::LoopControlMask::PeelCount, 8, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationSetLoopControl( 93, (uint32_t)spv::LoopControlMask::PeelCount, 8, 8) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 93, (uint32_t)spv::LoopControlMask::PartialCount, 0, 8) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 93, (uint32_t)spv::LoopControlMask::PeelCount | (uint32_t)spv::LoopControlMask::PartialCount, 16, 8) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 103, (uint32_t)spv::LoopControlMask::MaskNone, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 103, (uint32_t)spv::LoopControlMask::Unroll, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 103, (uint32_t)spv::LoopControlMask::DontUnroll, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 103, (uint32_t)spv::LoopControlMask::PartialCount, 0, 60) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationSetLoopControl( 103, (uint32_t)spv::LoopControlMask::DontUnroll | (uint32_t)spv::LoopControlMask::PartialCount, 0, 60) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 113, (uint32_t)spv::LoopControlMask::MaskNone, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 113, (uint32_t)spv::LoopControlMask::Unroll, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 113, (uint32_t)spv::LoopControlMask::DontUnroll, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 113, (uint32_t)spv::LoopControlMask::PeelCount, 12, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationSetLoopControl( 113, (uint32_t)spv::LoopControlMask::IterationMultiple | (uint32_t)spv::LoopControlMask::PeelCount, 12, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 123, (uint32_t)spv::LoopControlMask::MaskNone, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 123, (uint32_t)spv::LoopControlMask::Unroll, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 123, (uint32_t)spv::LoopControlMask::DontUnroll, 0, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 123, (uint32_t)spv::LoopControlMask::MinIterations | (uint32_t)spv::LoopControlMask::MaxIterations | (uint32_t)spv::LoopControlMask::IterationMultiple | (uint32_t)spv::LoopControlMask::PeelCount | (uint32_t)spv::LoopControlMask::PartialCount, 7, 8) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE(TransformationSetLoopControl( 123, (uint32_t)spv::LoopControlMask::Unroll | (uint32_t)spv::LoopControlMask::MinIterations | (uint32_t)spv::LoopControlMask::MaxIterations | (uint32_t)spv::LoopControlMask::PartialCount, 0, 9) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationSetLoopControl( 123, (uint32_t)spv::LoopControlMask::Unroll | (uint32_t)spv::LoopControlMask::MinIterations | (uint32_t)spv::LoopControlMask::MaxIterations | (uint32_t)spv::LoopControlMask::PartialCount, 7, 9) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationSetLoopControl( 123, (uint32_t)spv::LoopControlMask::DontUnroll | (uint32_t)spv::LoopControlMask::MinIterations | (uint32_t)spv::LoopControlMask::MaxIterations | (uint32_t)spv::LoopControlMask::PartialCount, 7, 9) .IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(TransformationSetLoopControl( 10, (uint32_t)spv::LoopControlMask::Unroll | (uint32_t)spv::LoopControlMask::PeelCount | (uint32_t)spv::LoopControlMask::PartialCount, 3, 3), context.get(), &transformation_context); ApplyAndCheckFreshIds( TransformationSetLoopControl( 23, (uint32_t)spv::LoopControlMask::DontUnroll, 0, 0), context.get(), &transformation_context); ApplyAndCheckFreshIds(TransformationSetLoopControl( 33, (uint32_t)spv::LoopControlMask::Unroll, 0, 0), context.get(), &transformation_context); ApplyAndCheckFreshIds( TransformationSetLoopControl( 43, (uint32_t)spv::LoopControlMask::DontUnroll | (uint32_t)spv::LoopControlMask::DependencyInfinite, 0, 0), context.get(), &transformation_context); ApplyAndCheckFreshIds(TransformationSetLoopControl( 53, (uint32_t)spv::LoopControlMask::MaskNone, 0, 0), context.get(), &transformation_context); ApplyAndCheckFreshIds(TransformationSetLoopControl( 63, (uint32_t)spv::LoopControlMask::Unroll | (uint32_t)spv::LoopControlMask::MinIterations | (uint32_t)spv::LoopControlMask::PeelCount, 23, 0), context.get(), &transformation_context); ApplyAndCheckFreshIds(TransformationSetLoopControl( 73, (uint32_t)spv::LoopControlMask::Unroll | (uint32_t)spv::LoopControlMask::MaxIterations | (uint32_t)spv::LoopControlMask::PeelCount, 23, 0), context.get(), &transformation_context); ApplyAndCheckFreshIds( TransformationSetLoopControl( 83, (uint32_t)spv::LoopControlMask::DontUnroll, 0, 0), context.get(), &transformation_context); ApplyAndCheckFreshIds(TransformationSetLoopControl( 93, (uint32_t)spv::LoopControlMask::PeelCount | (uint32_t)spv::LoopControlMask::PartialCount, 16, 8), context.get(), &transformation_context); ApplyAndCheckFreshIds( TransformationSetLoopControl( 103, (uint32_t)spv::LoopControlMask::PartialCount, 0, 60), context.get(), &transformation_context); ApplyAndCheckFreshIds( TransformationSetLoopControl( 113, (uint32_t)spv::LoopControlMask::PeelCount, 12, 0), context.get(), &transformation_context); ApplyAndCheckFreshIds(TransformationSetLoopControl( 123, (uint32_t)spv::LoopControlMask::Unroll | (uint32_t)spv::LoopControlMask::MinIterations | (uint32_t)spv::LoopControlMask::MaxIterations | (uint32_t)spv::LoopControlMask::PartialCount, 0, 9), context.get(), &transformation_context); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 100 %17 = OpTypeBool %20 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %22 = OpVariable %7 Function %32 = OpVariable %7 Function %42 = OpVariable %7 Function %52 = OpVariable %7 Function %62 = OpVariable %7 Function %72 = OpVariable %7 Function %82 = OpVariable %7 Function %92 = OpVariable %7 Function %102 = OpVariable %7 Function %112 = OpVariable %7 Function %122 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %132 = OpPhi %6 %9 %5 %21 %13 OpLoopMerge %12 %13 Unroll|PeelCount|PartialCount 3 3 OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %132 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel OpBranch %13 %13 = OpLabel %21 = OpIAdd %6 %132 %20 OpStore %8 %21 OpBranch %10 %12 = OpLabel OpStore %22 %9 OpBranch %23 %23 = OpLabel %133 = OpPhi %6 %9 %12 %31 %26 OpLoopMerge %25 %26 DontUnroll OpBranch %27 %27 = OpLabel %29 = OpSLessThan %17 %133 %16 OpBranchConditional %29 %24 %25 %24 = OpLabel OpBranch %26 %26 = OpLabel %31 = OpIAdd %6 %133 %20 OpStore %22 %31 OpBranch %23 %25 = OpLabel OpStore %32 %9 OpBranch %33 %33 = OpLabel %134 = OpPhi %6 %9 %25 %41 %36 OpLoopMerge %35 %36 Unroll OpBranch %37 %37 = OpLabel %39 = OpSLessThan %17 %134 %16 OpBranchConditional %39 %34 %35 %34 = OpLabel OpBranch %36 %36 = OpLabel %41 = OpIAdd %6 %134 %20 OpStore %32 %41 OpBranch %33 %35 = OpLabel OpStore %42 %9 OpBranch %43 %43 = OpLabel %135 = OpPhi %6 %9 %35 %51 %46 OpLoopMerge %45 %46 DontUnroll|DependencyInfinite OpBranch %47 %47 = OpLabel %49 = OpSLessThan %17 %135 %16 OpBranchConditional %49 %44 %45 %44 = OpLabel OpBranch %46 %46 = OpLabel %51 = OpIAdd %6 %135 %20 OpStore %42 %51 OpBranch %43 %45 = OpLabel OpStore %52 %9 OpBranch %53 %53 = OpLabel %136 = OpPhi %6 %9 %45 %61 %56 OpLoopMerge %55 %56 None OpBranch %57 %57 = OpLabel %59 = OpSLessThan %17 %136 %16 OpBranchConditional %59 %54 %55 %54 = OpLabel OpBranch %56 %56 = OpLabel %61 = OpIAdd %6 %136 %20 OpStore %52 %61 OpBranch %53 %55 = OpLabel OpStore %62 %9 OpBranch %63 %63 = OpLabel %137 = OpPhi %6 %9 %55 %71 %66 OpLoopMerge %65 %66 Unroll|MinIterations|PeelCount 10 23 OpBranch %67 %67 = OpLabel %69 = OpSLessThan %17 %137 %16 OpBranchConditional %69 %64 %65 %64 = OpLabel OpBranch %66 %66 = OpLabel %71 = OpIAdd %6 %137 %20 OpStore %62 %71 OpBranch %63 %65 = OpLabel OpStore %72 %9 OpBranch %73 %73 = OpLabel %138 = OpPhi %6 %9 %65 %81 %76 OpLoopMerge %75 %76 Unroll|MaxIterations|PeelCount 50 23 OpBranch %77 %77 = OpLabel %79 = OpSLessThan %17 %138 %16 OpBranchConditional %79 %74 %75 %74 = OpLabel OpBranch %76 %76 = OpLabel %81 = OpIAdd %6 %138 %20 OpStore %72 %81 OpBranch %73 %75 = OpLabel OpStore %82 %9 OpBranch %83 %83 = OpLabel %139 = OpPhi %6 %9 %75 %91 %86 OpLoopMerge %85 %86 DontUnroll OpBranch %87 %87 = OpLabel %89 = OpSLessThan %17 %139 %16 OpBranchConditional %89 %84 %85 %84 = OpLabel OpBranch %86 %86 = OpLabel %91 = OpIAdd %6 %139 %20 OpStore %82 %91 OpBranch %83 %85 = OpLabel OpStore %92 %9 OpBranch %93 %93 = OpLabel %140 = OpPhi %6 %9 %85 %101 %96 OpLoopMerge %95 %96 PeelCount|PartialCount 16 8 OpBranch %97 %97 = OpLabel %99 = OpSLessThan %17 %140 %16 OpBranchConditional %99 %94 %95 %94 = OpLabel OpBranch %96 %96 = OpLabel %101 = OpIAdd %6 %140 %20 OpStore %92 %101 OpBranch %93 %95 = OpLabel OpStore %102 %9 OpBranch %103 %103 = OpLabel %141 = OpPhi %6 %9 %95 %111 %106 OpLoopMerge %105 %106 PartialCount 60 OpBranch %107 %107 = OpLabel %109 = OpSLessThan %17 %141 %16 OpBranchConditional %109 %104 %105 %104 = OpLabel OpBranch %106 %106 = OpLabel %111 = OpIAdd %6 %141 %20 OpStore %102 %111 OpBranch %103 %105 = OpLabel OpStore %112 %9 OpBranch %113 %113 = OpLabel %142 = OpPhi %6 %9 %105 %121 %116 OpLoopMerge %115 %116 PeelCount 12 OpBranch %117 %117 = OpLabel %119 = OpSLessThan %17 %142 %16 OpBranchConditional %119 %114 %115 %114 = OpLabel OpBranch %116 %116 = OpLabel %121 = OpIAdd %6 %142 %20 OpStore %112 %121 OpBranch %113 %115 = OpLabel OpStore %122 %9 OpBranch %123 %123 = OpLabel %143 = OpPhi %6 %9 %115 %131 %126 OpLoopMerge %125 %126 Unroll|MinIterations|MaxIterations|PartialCount 5 90 9 OpBranch %127 %127 = OpLabel %129 = OpSLessThan %17 %143 %16 OpBranchConditional %129 %124 %125 %124 = OpLabel OpBranch %126 %126 = OpLabel %131 = OpIAdd %6 %143 %20 OpStore %122 %131 OpBranch %123 %125 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationSetLoopControlTest, CheckSPIRVVersionsRespected) { // This test checks that we do not allow introducing PeelCount and // PartialCount loop controls if the SPIR-V version being used does not // support them. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %20 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %15 = OpLoad %6 %8 %18 = OpSLessThan %17 %15 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel OpBranch %13 %13 = OpLabel %19 = OpLoad %6 %8 %21 = OpIAdd %6 %19 %20 OpStore %8 %21 OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; for (auto env : {SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1, SPV_ENV_UNIVERSAL_1_2, SPV_ENV_UNIVERSAL_1_3, SPV_ENV_UNIVERSAL_1_4, SPV_ENV_UNIVERSAL_1_5, SPV_ENV_VULKAN_1_0, SPV_ENV_VULKAN_1_1, SPV_ENV_VULKAN_1_1_SPIRV_1_4, SPV_ENV_VULKAN_1_2}) { const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationSetLoopControl peel_count( 10, (uint32_t)spv::LoopControlMask::PeelCount, 4, 0); TransformationSetLoopControl partial_count( 10, (uint32_t)spv::LoopControlMask::PartialCount, 0, 4); switch (env) { case SPV_ENV_UNIVERSAL_1_0: case SPV_ENV_UNIVERSAL_1_1: case SPV_ENV_UNIVERSAL_1_2: case SPV_ENV_UNIVERSAL_1_3: case SPV_ENV_VULKAN_1_0: case SPV_ENV_VULKAN_1_1: // PeelCount and PartialCount were introduced in SPIRV 1.4, so are not // valid in the context of older versions. ASSERT_FALSE( peel_count.IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( partial_count.IsApplicable(context.get(), transformation_context)); break; case SPV_ENV_UNIVERSAL_1_4: case SPV_ENV_UNIVERSAL_1_5: case SPV_ENV_VULKAN_1_1_SPIRV_1_4: case SPV_ENV_VULKAN_1_2: ASSERT_TRUE( peel_count.IsApplicable(context.get(), transformation_context)); ASSERT_TRUE( partial_count.IsApplicable(context.get(), transformation_context)); break; default: assert(false && "Unhandled environment"); break; } } } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_set_memory_operands_mask_test.cpp000066400000000000000000000556051475742701700325030ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_set_memory_operands_mask.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationSetMemoryOperandsMaskTest, PreSpirv14) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %7 "Point3D" OpMemberName %7 0 "x" OpMemberName %7 1 "y" OpMemberName %7 2 "z" OpName %12 "global_points" OpName %15 "block" OpMemberName %15 0 "in_points" OpMemberName %15 1 "in_point" OpName %17 "" OpName %133 "local_points" OpMemberDecorate %7 0 Offset 0 OpMemberDecorate %7 1 Offset 4 OpMemberDecorate %7 2 Offset 8 OpDecorate %10 ArrayStride 16 OpMemberDecorate %15 0 Offset 0 OpMemberDecorate %15 1 Offset 192 OpDecorate %15 Block OpDecorate %17 DescriptorSet 0 OpDecorate %17 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeStruct %6 %6 %6 %8 = OpTypeInt 32 0 %9 = OpConstant %8 12 %10 = OpTypeArray %7 %9 %11 = OpTypePointer Private %10 %12 = OpVariable %11 Private %15 = OpTypeStruct %10 %7 %16 = OpTypePointer Uniform %15 %17 = OpVariable %16 Uniform %18 = OpTypeInt 32 1 %19 = OpConstant %18 0 %20 = OpTypePointer Uniform %10 %24 = OpTypePointer Private %7 %27 = OpTypePointer Private %6 %30 = OpConstant %18 1 %132 = OpTypePointer Function %10 %135 = OpTypePointer Uniform %7 %145 = OpTypePointer Function %7 %4 = OpFunction %2 None %3 %5 = OpLabel %133 = OpVariable %132 Function %21 = OpAccessChain %20 %17 %19 OpCopyMemory %12 %21 Aligned 16 OpCopyMemory %133 %12 Volatile OpCopyMemory %133 %12 %136 = OpAccessChain %135 %17 %30 %138 = OpAccessChain %24 %12 %19 OpCopyMemory %138 %136 None %146 = OpAccessChain %145 %133 %30 %147 = OpLoad %7 %146 Volatile|Nontemporal|Aligned 16 %148 = OpAccessChain %24 %12 %19 OpStore %148 %147 Nontemporal OpReturn OpFunctionEnd )"; for (auto env : {SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1, SPV_ENV_UNIVERSAL_1_2, SPV_ENV_UNIVERSAL_1_3, SPV_ENV_VULKAN_1_0, SPV_ENV_VULKAN_1_1}) { const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); #ifndef NDEBUG { // Not OK: multiple operands are not supported pre SPIR-V 1.4. TransformationSetMemoryOperandsMask transformation( MakeInstructionDescriptor(21, spv::Op::OpCopyMemory, 3), (uint32_t)spv::MemoryAccessMask::Nontemporal | (uint32_t)spv::MemoryAccessMask::Volatile, 1); ASSERT_DEATH( transformation.IsApplicable(context.get(), transformation_context), "Multiple memory operand masks are not supported"); } #endif // Not OK: the instruction is not a memory access. ASSERT_FALSE(TransformationSetMemoryOperandsMask( MakeInstructionDescriptor(21, spv::Op::OpAccessChain, 0), (uint32_t)spv::MemoryAccessMask::MaskNone, 0) .IsApplicable(context.get(), transformation_context)); // Not OK to remove Aligned ASSERT_FALSE(TransformationSetMemoryOperandsMask( MakeInstructionDescriptor(147, spv::Op::OpLoad, 0), (uint32_t)spv::MemoryAccessMask::Volatile | (uint32_t)spv::MemoryAccessMask::Nontemporal, 0) .IsApplicable(context.get(), transformation_context)); { TransformationSetMemoryOperandsMask transformation( MakeInstructionDescriptor(147, spv::Op::OpLoad, 0), (uint32_t)spv::MemoryAccessMask::Aligned | (uint32_t)spv::MemoryAccessMask::Volatile, 0); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } // Not OK to remove Aligned ASSERT_FALSE(TransformationSetMemoryOperandsMask( MakeInstructionDescriptor(21, spv::Op::OpCopyMemory, 0), (uint32_t)spv::MemoryAccessMask::MaskNone, 0) .IsApplicable(context.get(), transformation_context)); // OK: leaves the mask as is ASSERT_TRUE(TransformationSetMemoryOperandsMask( MakeInstructionDescriptor(21, spv::Op::OpCopyMemory, 0), (uint32_t)spv::MemoryAccessMask::Aligned, 0) .IsApplicable(context.get(), transformation_context)); { // OK: adds Nontemporal and Volatile TransformationSetMemoryOperandsMask transformation( MakeInstructionDescriptor(21, spv::Op::OpCopyMemory, 0), (uint32_t)spv::MemoryAccessMask::Aligned | (uint32_t)spv::MemoryAccessMask::Nontemporal | (uint32_t)spv::MemoryAccessMask::Volatile, 0); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } // Not OK to remove Volatile ASSERT_FALSE(TransformationSetMemoryOperandsMask( MakeInstructionDescriptor(21, spv::Op::OpCopyMemory, 1), (uint32_t)spv::MemoryAccessMask::Nontemporal, 0) .IsApplicable(context.get(), transformation_context)); // Not OK to add Aligned ASSERT_FALSE(TransformationSetMemoryOperandsMask( MakeInstructionDescriptor(21, spv::Op::OpCopyMemory, 1), (uint32_t)spv::MemoryAccessMask::Aligned | (uint32_t)spv::MemoryAccessMask::Volatile, 0) .IsApplicable(context.get(), transformation_context)); { // OK: adds Nontemporal TransformationSetMemoryOperandsMask transformation( MakeInstructionDescriptor(21, spv::Op::OpCopyMemory, 1), (uint32_t)spv::MemoryAccessMask::Nontemporal | (uint32_t)spv::MemoryAccessMask::Volatile, 0); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } { // OK: adds Nontemporal (creates new operand) TransformationSetMemoryOperandsMask transformation( MakeInstructionDescriptor(21, spv::Op::OpCopyMemory, 2), (uint32_t)spv::MemoryAccessMask::Nontemporal | (uint32_t)spv::MemoryAccessMask::Volatile, 0); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } { // OK: adds Nontemporal and Volatile TransformationSetMemoryOperandsMask transformation( MakeInstructionDescriptor(138, spv::Op::OpCopyMemory, 0), (uint32_t)spv::MemoryAccessMask::Nontemporal | (uint32_t)spv::MemoryAccessMask::Volatile, 0); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } { // OK: removes Nontemporal, adds Volatile TransformationSetMemoryOperandsMask transformation( MakeInstructionDescriptor(148, spv::Op::OpStore, 0), (uint32_t)spv::MemoryAccessMask::Volatile, 0); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %7 "Point3D" OpMemberName %7 0 "x" OpMemberName %7 1 "y" OpMemberName %7 2 "z" OpName %12 "global_points" OpName %15 "block" OpMemberName %15 0 "in_points" OpMemberName %15 1 "in_point" OpName %17 "" OpName %133 "local_points" OpMemberDecorate %7 0 Offset 0 OpMemberDecorate %7 1 Offset 4 OpMemberDecorate %7 2 Offset 8 OpDecorate %10 ArrayStride 16 OpMemberDecorate %15 0 Offset 0 OpMemberDecorate %15 1 Offset 192 OpDecorate %15 Block OpDecorate %17 DescriptorSet 0 OpDecorate %17 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeStruct %6 %6 %6 %8 = OpTypeInt 32 0 %9 = OpConstant %8 12 %10 = OpTypeArray %7 %9 %11 = OpTypePointer Private %10 %12 = OpVariable %11 Private %15 = OpTypeStruct %10 %7 %16 = OpTypePointer Uniform %15 %17 = OpVariable %16 Uniform %18 = OpTypeInt 32 1 %19 = OpConstant %18 0 %20 = OpTypePointer Uniform %10 %24 = OpTypePointer Private %7 %27 = OpTypePointer Private %6 %30 = OpConstant %18 1 %132 = OpTypePointer Function %10 %135 = OpTypePointer Uniform %7 %145 = OpTypePointer Function %7 %4 = OpFunction %2 None %3 %5 = OpLabel %133 = OpVariable %132 Function %21 = OpAccessChain %20 %17 %19 OpCopyMemory %12 %21 Aligned|Nontemporal|Volatile 16 OpCopyMemory %133 %12 Nontemporal|Volatile OpCopyMemory %133 %12 Nontemporal|Volatile %136 = OpAccessChain %135 %17 %30 %138 = OpAccessChain %24 %12 %19 OpCopyMemory %138 %136 Nontemporal|Volatile %146 = OpAccessChain %145 %133 %30 %147 = OpLoad %7 %146 Aligned|Volatile 16 %148 = OpAccessChain %24 %12 %19 OpStore %148 %147 Volatile OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } TEST(TransformationSetMemoryOperandsMaskTest, Spirv14OrHigher) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %12 %17 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %7 "Point3D" OpMemberName %7 0 "x" OpMemberName %7 1 "y" OpMemberName %7 2 "z" OpName %12 "global_points" OpName %15 "block" OpMemberName %15 0 "in_points" OpMemberName %15 1 "in_point" OpName %17 "" OpName %133 "local_points" OpMemberDecorate %7 0 Offset 0 OpMemberDecorate %7 1 Offset 4 OpMemberDecorate %7 2 Offset 8 OpDecorate %10 ArrayStride 16 OpMemberDecorate %15 0 Offset 0 OpMemberDecorate %15 1 Offset 192 OpDecorate %15 Block OpDecorate %17 DescriptorSet 0 OpDecorate %17 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeStruct %6 %6 %6 %8 = OpTypeInt 32 0 %9 = OpConstant %8 12 %10 = OpTypeArray %7 %9 %11 = OpTypePointer Private %10 %12 = OpVariable %11 Private %15 = OpTypeStruct %10 %7 %16 = OpTypePointer Uniform %15 %17 = OpVariable %16 Uniform %18 = OpTypeInt 32 1 %19 = OpConstant %18 0 %20 = OpTypePointer Uniform %10 %24 = OpTypePointer Private %7 %27 = OpTypePointer Private %6 %30 = OpConstant %18 1 %132 = OpTypePointer Function %10 %135 = OpTypePointer Uniform %7 %145 = OpTypePointer Function %7 %4 = OpFunction %2 None %3 %5 = OpLabel %133 = OpVariable %132 Function %21 = OpAccessChain %20 %17 %19 OpCopyMemory %12 %21 Aligned 16 Nontemporal|Aligned 16 OpCopyMemory %133 %12 Volatile OpCopyMemory %133 %12 OpCopyMemory %133 %12 %136 = OpAccessChain %135 %17 %30 %138 = OpAccessChain %24 %12 %19 OpCopyMemory %138 %136 None Aligned 16 OpCopyMemory %138 %136 Aligned 16 %146 = OpAccessChain %145 %133 %30 %147 = OpLoad %7 %146 Volatile|Nontemporal|Aligned 16 %148 = OpAccessChain %24 %12 %19 OpStore %148 %147 Nontemporal OpReturn OpFunctionEnd )"; for (auto env : {SPV_ENV_UNIVERSAL_1_4, SPV_ENV_UNIVERSAL_1_5, SPV_ENV_VULKAN_1_1_SPIRV_1_4, SPV_ENV_VULKAN_1_2}) { const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); { TransformationSetMemoryOperandsMask transformation( MakeInstructionDescriptor(21, spv::Op::OpCopyMemory, 0), (uint32_t)spv::MemoryAccessMask::Aligned | (uint32_t)spv::MemoryAccessMask::Volatile, 1); // Bad: cannot remove aligned ASSERT_FALSE(TransformationSetMemoryOperandsMask( MakeInstructionDescriptor(21, spv::Op::OpCopyMemory, 0), (uint32_t)spv::MemoryAccessMask::Volatile, 1) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } { TransformationSetMemoryOperandsMask transformation( MakeInstructionDescriptor(21, spv::Op::OpCopyMemory, 1), (uint32_t)spv::MemoryAccessMask::Nontemporal | (uint32_t)spv::MemoryAccessMask::Volatile, 1); // Bad: cannot remove volatile ASSERT_FALSE(TransformationSetMemoryOperandsMask( MakeInstructionDescriptor(21, spv::Op::OpCopyMemory, 1), (uint32_t)spv::MemoryAccessMask::Nontemporal, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } { // Creates the first operand. TransformationSetMemoryOperandsMask transformation( MakeInstructionDescriptor(21, spv::Op::OpCopyMemory, 2), (uint32_t)spv::MemoryAccessMask::Nontemporal | (uint32_t)spv::MemoryAccessMask::Volatile, 0); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } { // Creates both operands. TransformationSetMemoryOperandsMask transformation( MakeInstructionDescriptor(21, spv::Op::OpCopyMemory, 3), (uint32_t)spv::MemoryAccessMask::Nontemporal | (uint32_t)spv::MemoryAccessMask::Volatile, 1); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } { TransformationSetMemoryOperandsMask transformation( MakeInstructionDescriptor(138, spv::Op::OpCopyMemory, 0), (uint32_t)spv::MemoryAccessMask::Aligned | (uint32_t)spv::MemoryAccessMask::Nontemporal, 1); // Bad: the first mask is None, so Aligned cannot be added to it. ASSERT_FALSE(TransformationSetMemoryOperandsMask( MakeInstructionDescriptor(138, spv::Op::OpCopyMemory, 0), (uint32_t)spv::MemoryAccessMask::Aligned | (uint32_t)spv::MemoryAccessMask::Nontemporal, 0) .IsApplicable(context.get(), transformation_context)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } { TransformationSetMemoryOperandsMask transformation( MakeInstructionDescriptor(138, spv::Op::OpCopyMemory, 1), (uint32_t)spv::MemoryAccessMask::Volatile, 1); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } { TransformationSetMemoryOperandsMask transformation( MakeInstructionDescriptor(147, spv::Op::OpLoad, 0), (uint32_t)spv::MemoryAccessMask::Volatile | (uint32_t)spv::MemoryAccessMask::Aligned, 0); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } { TransformationSetMemoryOperandsMask transformation( MakeInstructionDescriptor(148, spv::Op::OpStore, 0), (uint32_t)spv::MemoryAccessMask::MaskNone, 0); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %12 %17 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %7 "Point3D" OpMemberName %7 0 "x" OpMemberName %7 1 "y" OpMemberName %7 2 "z" OpName %12 "global_points" OpName %15 "block" OpMemberName %15 0 "in_points" OpMemberName %15 1 "in_point" OpName %17 "" OpName %133 "local_points" OpMemberDecorate %7 0 Offset 0 OpMemberDecorate %7 1 Offset 4 OpMemberDecorate %7 2 Offset 8 OpDecorate %10 ArrayStride 16 OpMemberDecorate %15 0 Offset 0 OpMemberDecorate %15 1 Offset 192 OpDecorate %15 Block OpDecorate %17 DescriptorSet 0 OpDecorate %17 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeStruct %6 %6 %6 %8 = OpTypeInt 32 0 %9 = OpConstant %8 12 %10 = OpTypeArray %7 %9 %11 = OpTypePointer Private %10 %12 = OpVariable %11 Private %15 = OpTypeStruct %10 %7 %16 = OpTypePointer Uniform %15 %17 = OpVariable %16 Uniform %18 = OpTypeInt 32 1 %19 = OpConstant %18 0 %20 = OpTypePointer Uniform %10 %24 = OpTypePointer Private %7 %27 = OpTypePointer Private %6 %30 = OpConstant %18 1 %132 = OpTypePointer Function %10 %135 = OpTypePointer Uniform %7 %145 = OpTypePointer Function %7 %4 = OpFunction %2 None %3 %5 = OpLabel %133 = OpVariable %132 Function %21 = OpAccessChain %20 %17 %19 OpCopyMemory %12 %21 Aligned 16 Aligned|Volatile 16 OpCopyMemory %133 %12 Volatile Nontemporal|Volatile OpCopyMemory %133 %12 Nontemporal|Volatile OpCopyMemory %133 %12 None Nontemporal|Volatile %136 = OpAccessChain %135 %17 %30 %138 = OpAccessChain %24 %12 %19 OpCopyMemory %138 %136 None Aligned|Nontemporal 16 OpCopyMemory %138 %136 Aligned 16 Volatile %146 = OpAccessChain %145 %133 %30 %147 = OpLoad %7 %146 Volatile|Aligned 16 %148 = OpAccessChain %24 %12 %19 OpStore %148 %147 None OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_set_selection_control_test.cpp000066400000000000000000000175201475742701700320040ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_set_selection_control.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationSetSelectionControlTest, VariousScenarios) { // This is a simple transformation; this test captures the important things // to check for. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %20 = OpConstant %6 3 %25 = OpConstant %6 1 %28 = OpConstant %6 2 %38 = OpConstant %6 4 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %15 = OpLoad %6 %8 %18 = OpSLessThan %17 %15 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %19 = OpLoad %6 %8 %21 = OpSGreaterThan %17 %19 %20 OpSelectionMerge %23 Flatten OpBranchConditional %21 %22 %23 %22 = OpLabel %24 = OpLoad %6 %8 %26 = OpIAdd %6 %24 %25 OpStore %8 %26 OpBranch %23 %23 = OpLabel %27 = OpLoad %6 %8 %29 = OpSLessThan %17 %27 %28 OpSelectionMerge %31 DontFlatten OpBranchConditional %29 %30 %31 %30 = OpLabel %32 = OpLoad %6 %8 %33 = OpISub %6 %32 %25 OpStore %8 %33 OpBranch %31 %31 = OpLabel %34 = OpLoad %6 %8 OpSelectionMerge %37 None OpSwitch %34 %36 0 %35 %36 = OpLabel OpBranch %37 %35 = OpLabel %39 = OpLoad %6 %8 %40 = OpIAdd %6 %39 %38 OpStore %8 %40 OpBranch %36 %37 = OpLabel OpBranch %13 %13 = OpLabel %43 = OpLoad %6 %8 %44 = OpIAdd %6 %43 %25 OpStore %8 %44 OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // %44 is not a block ASSERT_FALSE(TransformationSetSelectionControl( 44, uint32_t(spv::SelectionControlMask::Flatten)) .IsApplicable(context.get(), transformation_context)); // %13 does not end with OpSelectionMerge ASSERT_FALSE(TransformationSetSelectionControl( 13, uint32_t(spv::SelectionControlMask::MaskNone)) .IsApplicable(context.get(), transformation_context)); // %10 ends in OpLoopMerge, not OpSelectionMerge ASSERT_FALSE(TransformationSetSelectionControl( 10, uint32_t(spv::SelectionControlMask::MaskNone)) .IsApplicable(context.get(), transformation_context)); TransformationSetSelectionControl transformation1( 11, uint32_t(spv::SelectionControlMask::DontFlatten)); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); TransformationSetSelectionControl transformation2( 23, uint32_t(spv::SelectionControlMask::Flatten)); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); TransformationSetSelectionControl transformation3( 31, uint32_t(spv::SelectionControlMask::MaskNone)); ASSERT_TRUE( transformation3.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation3, context.get(), &transformation_context); TransformationSetSelectionControl transformation4( 31, uint32_t(spv::SelectionControlMask::Flatten)); ASSERT_TRUE( transformation4.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation4, context.get(), &transformation_context); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %20 = OpConstant %6 3 %25 = OpConstant %6 1 %28 = OpConstant %6 2 %38 = OpConstant %6 4 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %15 = OpLoad %6 %8 %18 = OpSLessThan %17 %15 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %19 = OpLoad %6 %8 %21 = OpSGreaterThan %17 %19 %20 OpSelectionMerge %23 DontFlatten OpBranchConditional %21 %22 %23 %22 = OpLabel %24 = OpLoad %6 %8 %26 = OpIAdd %6 %24 %25 OpStore %8 %26 OpBranch %23 %23 = OpLabel %27 = OpLoad %6 %8 %29 = OpSLessThan %17 %27 %28 OpSelectionMerge %31 Flatten OpBranchConditional %29 %30 %31 %30 = OpLabel %32 = OpLoad %6 %8 %33 = OpISub %6 %32 %25 OpStore %8 %33 OpBranch %31 %31 = OpLabel %34 = OpLoad %6 %8 OpSelectionMerge %37 Flatten OpSwitch %34 %36 0 %35 %36 = OpLabel OpBranch %37 %35 = OpLabel %39 = OpLoad %6 %8 %40 = OpIAdd %6 %39 %38 OpStore %8 %40 OpBranch %36 %37 = OpLabel OpBranch %13 %13 = OpLabel %43 = OpLoad %6 %8 %44 = OpIAdd %6 %43 %25 OpStore %8 %44 OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_split_block_test.cpp000066400000000000000000001013151475742701700277050ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_split_block.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationSplitBlockTest, NotApplicable) { // The SPIR-V in this test came from the following fragment shader, with // local store elimination applied to get some OpPhi instructions. // // void main() { // int x; // int i; // for (i = 0; i < 100; i++) { // x += i; // } // } std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "i" OpName %19 "x" OpDecorate %8 RelaxedPrecision OpDecorate %19 RelaxedPrecision OpDecorate %22 RelaxedPrecision OpDecorate %25 RelaxedPrecision OpDecorate %26 RelaxedPrecision OpDecorate %27 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 100 %17 = OpTypeBool %24 = OpConstant %6 1 %28 = OpUndef %6 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %19 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %27 = OpPhi %6 %28 %5 %22 %13 %26 = OpPhi %6 %9 %5 %25 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %26 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %22 = OpIAdd %6 %27 %26 OpStore %19 %22 OpBranch %13 %13 = OpLabel %25 = OpIAdd %6 %26 %24 OpStore %8 %25 OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // No split before OpVariable ASSERT_FALSE(TransformationSplitBlock( MakeInstructionDescriptor(8, spv::Op::OpVariable, 0), 100) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationSplitBlock( MakeInstructionDescriptor(8, spv::Op::OpVariable, 1), 100) .IsApplicable(context.get(), transformation_context)); // No split before OpLabel ASSERT_FALSE(TransformationSplitBlock( MakeInstructionDescriptor(14, spv::Op::OpLabel, 0), 100) .IsApplicable(context.get(), transformation_context)); // No split if base instruction is outside a function ASSERT_FALSE(TransformationSplitBlock( MakeInstructionDescriptor(1, spv::Op::OpLabel, 0), 100) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( TransformationSplitBlock( MakeInstructionDescriptor(1, spv::Op::OpExecutionMode, 0), 100) .IsApplicable(context.get(), transformation_context)); // No split if block is loop header ASSERT_FALSE(TransformationSplitBlock( MakeInstructionDescriptor(27, spv::Op::OpPhi, 0), 100) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationSplitBlock( MakeInstructionDescriptor(27, spv::Op::OpPhi, 1), 100) .IsApplicable(context.get(), transformation_context)); // No split if base instruction does not exist ASSERT_FALSE(TransformationSplitBlock( MakeInstructionDescriptor(88, spv::Op::OpIAdd, 0), 100) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationSplitBlock( MakeInstructionDescriptor(88, spv::Op::OpIMul, 22), 100) .IsApplicable(context.get(), transformation_context)); // No split if too many instructions with the desired opcode are skipped ASSERT_FALSE( TransformationSplitBlock( MakeInstructionDescriptor(18, spv::Op::OpBranchConditional, 1), 100) .IsApplicable(context.get(), transformation_context)); // No split if id in use ASSERT_FALSE(TransformationSplitBlock( MakeInstructionDescriptor(18, spv::Op::OpSLessThan, 0), 27) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationSplitBlock( MakeInstructionDescriptor(18, spv::Op::OpSLessThan, 0), 14) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationSplitBlockTest, SplitBlockSeveralTimes) { // The SPIR-V in this test came from the following fragment shader: // // void main() { // int a; // int b; // a = 1; // b = a; // a = b; // b = 2; // b++; // } std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "a" OpName %10 "b" OpDecorate %8 RelaxedPrecision OpDecorate %10 RelaxedPrecision OpDecorate %11 RelaxedPrecision OpDecorate %12 RelaxedPrecision OpDecorate %14 RelaxedPrecision OpDecorate %15 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %13 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function OpStore %8 %9 %11 = OpLoad %6 %8 OpStore %10 %11 %12 = OpLoad %6 %10 OpStore %8 %12 OpStore %10 %13 %14 = OpLoad %6 %10 %15 = OpIAdd %6 %14 %9 OpStore %10 %15 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto split_1 = TransformationSplitBlock( MakeInstructionDescriptor(5, spv::Op::OpStore, 0), 100); ASSERT_TRUE(split_1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(split_1, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_split_1 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "a" OpName %10 "b" OpDecorate %8 RelaxedPrecision OpDecorate %10 RelaxedPrecision OpDecorate %11 RelaxedPrecision OpDecorate %12 RelaxedPrecision OpDecorate %14 RelaxedPrecision OpDecorate %15 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %13 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function OpBranch %100 %100 = OpLabel OpStore %8 %9 %11 = OpLoad %6 %8 OpStore %10 %11 %12 = OpLoad %6 %10 OpStore %8 %12 OpStore %10 %13 %14 = OpLoad %6 %10 %15 = OpIAdd %6 %14 %9 OpStore %10 %15 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_split_1, context.get())); auto split_2 = TransformationSplitBlock( MakeInstructionDescriptor(11, spv::Op::OpStore, 0), 101); ASSERT_TRUE(split_2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(split_2, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_split_2 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "a" OpName %10 "b" OpDecorate %8 RelaxedPrecision OpDecorate %10 RelaxedPrecision OpDecorate %11 RelaxedPrecision OpDecorate %12 RelaxedPrecision OpDecorate %14 RelaxedPrecision OpDecorate %15 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %13 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function OpBranch %100 %100 = OpLabel OpStore %8 %9 %11 = OpLoad %6 %8 OpBranch %101 %101 = OpLabel OpStore %10 %11 %12 = OpLoad %6 %10 OpStore %8 %12 OpStore %10 %13 %14 = OpLoad %6 %10 %15 = OpIAdd %6 %14 %9 OpStore %10 %15 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_split_2, context.get())); auto split_3 = TransformationSplitBlock( MakeInstructionDescriptor(14, spv::Op::OpLoad, 0), 102); ASSERT_TRUE(split_3.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(split_3, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_split_3 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "a" OpName %10 "b" OpDecorate %8 RelaxedPrecision OpDecorate %10 RelaxedPrecision OpDecorate %11 RelaxedPrecision OpDecorate %12 RelaxedPrecision OpDecorate %14 RelaxedPrecision OpDecorate %15 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %13 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function OpBranch %100 %100 = OpLabel OpStore %8 %9 %11 = OpLoad %6 %8 OpBranch %101 %101 = OpLabel OpStore %10 %11 %12 = OpLoad %6 %10 OpStore %8 %12 OpStore %10 %13 OpBranch %102 %102 = OpLabel %14 = OpLoad %6 %10 %15 = OpIAdd %6 %14 %9 OpStore %10 %15 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_split_3, context.get())); } TEST(TransformationSplitBlockTest, SplitBlockBeforeSelectBranch) { // The SPIR-V in this test came from the following fragment shader: // // void main() { // int x, y; // x = 2; // if (x < y) { // y = 3; // } else { // y = 4; // } // } std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "x" OpName %11 "y" OpDecorate %8 RelaxedPrecision OpDecorate %10 RelaxedPrecision OpDecorate %11 RelaxedPrecision OpDecorate %12 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 2 %13 = OpTypeBool %17 = OpConstant %6 3 %19 = OpConstant %6 4 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %11 = OpVariable %7 Function OpStore %8 %9 %10 = OpLoad %6 %8 %12 = OpLoad %6 %11 %14 = OpSLessThan %13 %10 %12 OpSelectionMerge %16 None OpBranchConditional %14 %15 %18 %15 = OpLabel OpStore %11 %17 OpBranch %16 %18 = OpLabel OpStore %11 %19 OpBranch %16 %16 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Illegal to split between the merge and the conditional branch. ASSERT_FALSE( TransformationSplitBlock( MakeInstructionDescriptor(14, spv::Op::OpBranchConditional, 0), 100) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( TransformationSplitBlock( MakeInstructionDescriptor(12, spv::Op::OpBranchConditional, 0), 100) .IsApplicable(context.get(), transformation_context)); auto split = TransformationSplitBlock( MakeInstructionDescriptor(14, spv::Op::OpSelectionMerge, 0), 100); ASSERT_TRUE(split.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(split, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_split = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "x" OpName %11 "y" OpDecorate %8 RelaxedPrecision OpDecorate %10 RelaxedPrecision OpDecorate %11 RelaxedPrecision OpDecorate %12 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 2 %13 = OpTypeBool %17 = OpConstant %6 3 %19 = OpConstant %6 4 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %11 = OpVariable %7 Function OpStore %8 %9 %10 = OpLoad %6 %8 %12 = OpLoad %6 %11 %14 = OpSLessThan %13 %10 %12 OpBranch %100 %100 = OpLabel OpSelectionMerge %16 None OpBranchConditional %14 %15 %18 %15 = OpLabel OpStore %11 %17 OpBranch %16 %18 = OpLabel OpStore %11 %19 OpBranch %16 %16 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_split, context.get())); } TEST(TransformationSplitBlockTest, SplitBlockBeforeSwitchBranch) { // The SPIR-V in this test came from the following fragment shader: // // void main() { // int x, y; // switch (y) { // case 1: // x = 2; // case 2: // break; // case 3: // x = 4; // default: // x = 6; // } // } std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "y" OpName %15 "x" OpDecorate %8 RelaxedPrecision OpDecorate %9 RelaxedPrecision OpDecorate %15 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %16 = OpConstant %6 2 %18 = OpConstant %6 4 %19 = OpConstant %6 6 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %15 = OpVariable %7 Function %9 = OpLoad %6 %8 OpSelectionMerge %14 None OpSwitch %9 %13 1 %10 2 %11 3 %12 %13 = OpLabel OpStore %15 %19 OpBranch %14 %10 = OpLabel OpStore %15 %16 OpBranch %11 %11 = OpLabel OpBranch %14 %12 = OpLabel OpStore %15 %18 OpBranch %13 %14 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Illegal to split between the merge and the conditional branch. ASSERT_FALSE(TransformationSplitBlock( MakeInstructionDescriptor(9, spv::Op::OpSwitch, 0), 100) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationSplitBlock( MakeInstructionDescriptor(15, spv::Op::OpSwitch, 0), 100) .IsApplicable(context.get(), transformation_context)); auto split = TransformationSplitBlock( MakeInstructionDescriptor(9, spv::Op::OpSelectionMerge, 0), 100); ASSERT_TRUE(split.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(split, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_split = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "y" OpName %15 "x" OpDecorate %8 RelaxedPrecision OpDecorate %9 RelaxedPrecision OpDecorate %15 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %16 = OpConstant %6 2 %18 = OpConstant %6 4 %19 = OpConstant %6 6 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %15 = OpVariable %7 Function %9 = OpLoad %6 %8 OpBranch %100 %100 = OpLabel OpSelectionMerge %14 None OpSwitch %9 %13 1 %10 2 %11 3 %12 %13 = OpLabel OpStore %15 %19 OpBranch %14 %10 = OpLabel OpStore %15 %16 OpBranch %11 %11 = OpLabel OpBranch %14 %12 = OpLabel OpStore %15 %18 OpBranch %13 %14 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_split, context.get())); } TEST(TransformationSplitBlockTest, NoSplitDuringOpPhis) { // The SPIR-V in this test came from the following fragment shader, with // local store elimination applied to get some OpPhi instructions. // // void main() { // int x; // int i; // for (i = 0; i < 100; i++) { // x += i; // } // } std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "i" OpName %19 "x" OpDecorate %8 RelaxedPrecision OpDecorate %19 RelaxedPrecision OpDecorate %22 RelaxedPrecision OpDecorate %25 RelaxedPrecision OpDecorate %26 RelaxedPrecision OpDecorate %27 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 100 %17 = OpTypeBool %24 = OpConstant %6 1 %28 = OpUndef %6 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %19 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %27 = OpPhi %6 %28 %5 %22 %13 %26 = OpPhi %6 %9 %5 %25 %13 OpBranch %50 %50 = OpLabel OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %26 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %22 = OpIAdd %6 %27 %26 OpStore %19 %22 OpBranch %13 %13 = OpLabel %25 = OpIAdd %6 %26 %24 OpStore %8 %25 OpBranch %50 %12 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // We cannot split before OpPhi instructions, since the number of incoming // blocks may not appropriately match after splitting. ASSERT_FALSE(TransformationSplitBlock( MakeInstructionDescriptor(26, spv::Op::OpPhi, 0), 100) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationSplitBlock( MakeInstructionDescriptor(27, spv::Op::OpPhi, 0), 100) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationSplitBlock( MakeInstructionDescriptor(27, spv::Op::OpPhi, 1), 100) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationSplitBlockTest, SplitOpPhiWithSinglePredecessor) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "x" OpName %10 "y" OpDecorate %8 RelaxedPrecision OpDecorate %10 RelaxedPrecision OpDecorate %11 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function OpStore %8 %9 %11 = OpLoad %6 %8 OpBranch %20 %20 = OpLabel %21 = OpPhi %6 %11 %5 OpStore %10 %21 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); ASSERT_TRUE(TransformationSplitBlock( MakeInstructionDescriptor(21, spv::Op::OpPhi, 0), 100) .IsApplicable(context.get(), transformation_context)); // An equivalent transformation to the above, just described with respect to a // different base instruction. auto split = TransformationSplitBlock( MakeInstructionDescriptor(20, spv::Op::OpPhi, 0), 100); ASSERT_TRUE(split.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(split, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_split = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "x" OpName %10 "y" OpDecorate %8 RelaxedPrecision OpDecorate %10 RelaxedPrecision OpDecorate %11 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function OpStore %8 %9 %11 = OpLoad %6 %8 OpBranch %20 %20 = OpLabel OpBranch %100 %100 = OpLabel %21 = OpPhi %6 %11 %20 OpStore %10 %21 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_split, context.get())); } TEST(TransformationSplitBlockTest, DeadBlockShouldSplitToTwoDeadBlocks) { // This checks that if a block B is marked as dead, it should split into a // pair of dead blocks. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantFalse %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %9 None OpBranchConditional %7 %8 %9 %8 = OpLabel OpBranch %9 %9 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Record the fact that block 8 is dead. transformation_context.GetFactManager()->AddFactBlockIsDead(8); auto split = TransformationSplitBlock( MakeInstructionDescriptor(8, spv::Op::OpBranch, 0), 100); ASSERT_TRUE(split.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(split, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->BlockIsDead(8)); ASSERT_TRUE(transformation_context.GetFactManager()->BlockIsDead(100)); std::string after_split = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantFalse %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %9 None OpBranchConditional %7 %8 %9 %8 = OpLabel OpBranch %100 %100 = OpLabel OpBranch %9 %9 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_split, context.get())); } TEST(TransformationSplitBlockTest, DoNotSplitUseOfOpSampledImage) { // This checks that we cannot split the definition of an OpSampledImage // from its use. std::string shader = R"( OpCapability Shader OpCapability SampledBuffer OpCapability ImageBuffer %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %40 %41 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 450 OpDecorate %40 DescriptorSet 0 OpDecorate %40 Binding 69 OpDecorate %41 DescriptorSet 0 OpDecorate %41 Binding 1 %54 = OpTypeFloat 32 %76 = OpTypeVector %54 4 %55 = OpConstant %54 0 %56 = OpTypeVector %54 3 %94 = OpTypeVector %54 2 %112 = OpConstantComposite %94 %55 %55 %57 = OpConstantComposite %56 %55 %55 %55 %15 = OpTypeImage %54 2D 2 0 0 1 Unknown %114 = OpTypePointer UniformConstant %15 %38 = OpTypeSampler %125 = OpTypePointer UniformConstant %38 %132 = OpTypeVoid %133 = OpTypeFunction %132 %45 = OpTypeSampledImage %15 %40 = OpVariable %114 UniformConstant %41 = OpVariable %125 UniformConstant %2 = OpFunction %132 None %133 %164 = OpLabel %184 = OpLoad %15 %40 %213 = OpLoad %38 %41 %216 = OpSampledImage %45 %184 %213 %217 = OpImageSampleImplicitLod %76 %216 %112 Bias %55 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto split = TransformationSplitBlock( MakeInstructionDescriptor(217, spv::Op::OpImageSampleImplicitLod, 0), 500); ASSERT_FALSE(split.IsApplicable(context.get(), transformation_context)); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_store_test.cpp000066400000000000000000000610241475742701700265360ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_store.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationStoreTest, BasicTest) { std::string shader = R"( OpCapability Shader OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %92 %52 %53 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %92 BuiltIn FragCoord %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeFloat 32 %8 = OpTypeStruct %6 %7 %9 = OpTypePointer Function %8 %10 = OpTypeFunction %6 %9 %14 = OpConstant %6 0 %15 = OpTypePointer Function %6 %51 = OpTypePointer Private %6 %21 = OpConstant %6 2 %23 = OpConstant %6 1 %24 = OpConstant %7 1 %25 = OpTypePointer Function %7 %50 = OpTypePointer Private %7 %34 = OpTypeBool %35 = OpConstantFalse %34 %60 = OpConstantNull %50 %52 = OpVariable %50 Private %53 = OpVariable %51 Private %80 = OpConstantComposite %8 %21 %24 %90 = OpTypeVector %7 4 %91 = OpTypePointer Input %90 %92 = OpVariable %91 Input %93 = OpConstantComposite %90 %24 %24 %24 %24 %4 = OpFunction %2 None %3 %5 = OpLabel %20 = OpVariable %9 Function %27 = OpVariable %9 Function ; irrelevant %22 = OpAccessChain %15 %20 %14 %44 = OpCopyObject %9 %20 %26 = OpAccessChain %25 %20 %23 %29 = OpFunctionCall %6 %12 %27 %30 = OpAccessChain %15 %20 %14 %45 = OpCopyObject %15 %30 %81 = OpCopyObject %9 %27 ; irrelevant %33 = OpAccessChain %15 %20 %14 OpSelectionMerge %37 None OpBranchConditional %35 %36 %37 %36 = OpLabel %38 = OpAccessChain %15 %20 %14 %40 = OpAccessChain %15 %20 %14 %43 = OpAccessChain %15 %20 %14 %82 = OpCopyObject %9 %27 ; irrelevant OpBranch %37 %37 = OpLabel OpReturn OpFunctionEnd %12 = OpFunction %6 None %10 %11 = OpFunctionParameter %9 ; irrelevant %13 = OpLabel %46 = OpCopyObject %9 %11 ; irrelevant %16 = OpAccessChain %15 %11 %14 ; irrelevant %95 = OpCopyObject %8 %80 OpReturnValue %21 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactValueOfPointeeIsIrrelevant( 27); transformation_context.GetFactManager()->AddFactValueOfPointeeIsIrrelevant( 11); transformation_context.GetFactManager()->AddFactValueOfPointeeIsIrrelevant( 46); transformation_context.GetFactManager()->AddFactValueOfPointeeIsIrrelevant( 16); transformation_context.GetFactManager()->AddFactValueOfPointeeIsIrrelevant( 52); transformation_context.GetFactManager()->AddFactValueOfPointeeIsIrrelevant( 81); transformation_context.GetFactManager()->AddFactValueOfPointeeIsIrrelevant( 82); transformation_context.GetFactManager()->AddFactBlockIsDead(36); // Variables with pointee types: // 52 - ptr_to(7) // 53 - ptr_to(6) // 20 - ptr_to(8) // 27 - ptr_to(8) - irrelevant // 92 - ptr_to(90) - read only // Access chains with pointee type: // 22 - ptr_to(6) // 26 - ptr_to(6) // 30 - ptr_to(6) // 33 - ptr_to(6) // 38 - ptr_to(6) // 40 - ptr_to(6) // 43 - ptr_to(6) // 16 - ptr_to(6) - irrelevant // Copied object with pointee type: // 44 - ptr_to(8) // 45 - ptr_to(6) // 46 - ptr_to(8) - irrelevant // 81 - ptr_to(8) - irrelevant // 82 - ptr_to(8) - irrelevant // Function parameters with pointee type: // 11 - ptr_to(8) - irrelevant // Pointers that cannot be used: // 60 - null // 61 - undefined // Bad: attempt to store to 11 from outside its function ASSERT_FALSE(TransformationStore( 11, false, 0, 0, 80, MakeInstructionDescriptor(38, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: pointer is not available ASSERT_FALSE(TransformationStore( 81, false, 0, 0, 80, MakeInstructionDescriptor(45, spv::Op::OpCopyObject, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: attempt to insert before OpVariable ASSERT_FALSE( TransformationStore(52, false, 0, 0, 24, MakeInstructionDescriptor(27, spv::Op::OpVariable, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: pointer id does not exist ASSERT_FALSE(TransformationStore( 1000, false, 0, 0, 24, MakeInstructionDescriptor(38, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: pointer id exists but does not have a type ASSERT_FALSE(TransformationStore( 5, false, 0, 0, 24, MakeInstructionDescriptor(38, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: pointer id exists and has a type, but is not a pointer ASSERT_FALSE(TransformationStore( 24, false, 0, 0, 24, MakeInstructionDescriptor(38, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: attempt to store to a null pointer ASSERT_FALSE(TransformationStore( 60, false, 0, 0, 24, MakeInstructionDescriptor(38, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: attempt to store to an undefined pointer ASSERT_FALSE(TransformationStore( 61, false, 0, 0, 21, MakeInstructionDescriptor(38, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: %82 is not available at the program point ASSERT_FALSE( TransformationStore(82, false, 0, 0, 80, MakeInstructionDescriptor(37, spv::Op::OpReturn, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: value id does not exist ASSERT_FALSE(TransformationStore( 27, false, 0, 0, 1000, MakeInstructionDescriptor(38, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: value id exists but does not have a type ASSERT_FALSE(TransformationStore( 27, false, 0, 0, 15, MakeInstructionDescriptor(38, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: value id exists but has the wrong type ASSERT_FALSE(TransformationStore( 27, false, 0, 0, 14, MakeInstructionDescriptor(38, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: attempt to store to read-only variable ASSERT_FALSE(TransformationStore( 92, false, 0, 0, 93, MakeInstructionDescriptor(40, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: value is not available ASSERT_FALSE(TransformationStore( 27, false, 0, 0, 95, MakeInstructionDescriptor(40, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: variable being stored to does not have an irrelevant pointee value, // and the store is not in a dead block. ASSERT_FALSE(TransformationStore( 20, false, 0, 0, 95, MakeInstructionDescriptor(45, spv::Op::OpCopyObject, 0)) .IsApplicable(context.get(), transformation_context)); // The described instruction does not exist. ASSERT_FALSE(TransformationStore( 27, false, 0, 0, 80, MakeInstructionDescriptor(1000, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); { // Store to irrelevant variable from dead block. TransformationStore transformation( 27, false, 0, 0, 80, MakeInstructionDescriptor(38, spv::Op::OpAccessChain, 0)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } { // Store to irrelevant variable from live block. TransformationStore transformation( 11, false, 0, 0, 95, MakeInstructionDescriptor(95, spv::Op::OpReturnValue, 0)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } { // Store to irrelevant variable from live block. TransformationStore transformation( 46, false, 0, 0, 80, MakeInstructionDescriptor(95, spv::Op::OpReturnValue, 0)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } { // Store to irrelevant variable from live block. TransformationStore transformation( 16, false, 0, 0, 21, MakeInstructionDescriptor(95, spv::Op::OpReturnValue, 0)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } { // Store to non-irrelevant variable from dead block. TransformationStore transformation( 53, false, 0, 0, 21, MakeInstructionDescriptor(38, spv::Op::OpAccessChain, 0)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } std::string after_transformation = R"( OpCapability Shader OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %92 %52 %53 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %92 BuiltIn FragCoord %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeFloat 32 %8 = OpTypeStruct %6 %7 %9 = OpTypePointer Function %8 %10 = OpTypeFunction %6 %9 %14 = OpConstant %6 0 %15 = OpTypePointer Function %6 %51 = OpTypePointer Private %6 %21 = OpConstant %6 2 %23 = OpConstant %6 1 %24 = OpConstant %7 1 %25 = OpTypePointer Function %7 %50 = OpTypePointer Private %7 %34 = OpTypeBool %35 = OpConstantFalse %34 %60 = OpConstantNull %50 %52 = OpVariable %50 Private %53 = OpVariable %51 Private %80 = OpConstantComposite %8 %21 %24 %90 = OpTypeVector %7 4 %91 = OpTypePointer Input %90 %92 = OpVariable %91 Input %93 = OpConstantComposite %90 %24 %24 %24 %24 %4 = OpFunction %2 None %3 %5 = OpLabel %20 = OpVariable %9 Function %27 = OpVariable %9 Function ; irrelevant %22 = OpAccessChain %15 %20 %14 %44 = OpCopyObject %9 %20 %26 = OpAccessChain %25 %20 %23 %29 = OpFunctionCall %6 %12 %27 %30 = OpAccessChain %15 %20 %14 %45 = OpCopyObject %15 %30 %81 = OpCopyObject %9 %27 ; irrelevant %33 = OpAccessChain %15 %20 %14 OpSelectionMerge %37 None OpBranchConditional %35 %36 %37 %36 = OpLabel OpStore %27 %80 OpStore %53 %21 %38 = OpAccessChain %15 %20 %14 %40 = OpAccessChain %15 %20 %14 %43 = OpAccessChain %15 %20 %14 %82 = OpCopyObject %9 %27 ; irrelevant OpBranch %37 %37 = OpLabel OpReturn OpFunctionEnd %12 = OpFunction %6 None %10 %11 = OpFunctionParameter %9 ; irrelevant %13 = OpLabel %46 = OpCopyObject %9 %11 ; irrelevant %16 = OpAccessChain %15 %11 %14 ; irrelevant %95 = OpCopyObject %8 %80 OpStore %11 %95 OpStore %46 %80 OpStore %16 %21 OpReturnValue %21 OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationStoreTest, DoNotAllowStoresToReadOnlyMemory) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpMemberDecorate %10 0 Offset 0 OpMemberDecorate %10 1 Offset 4 OpDecorate %10 Block OpMemberDecorate %23 0 Offset 0 OpDecorate %23 Block OpDecorate %25 DescriptorSet 0 OpDecorate %25 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpTypeFloat 32 %10 = OpTypeStruct %6 %9 %11 = OpTypePointer PushConstant %10 %12 = OpVariable %11 PushConstant %13 = OpConstant %6 0 %14 = OpTypePointer PushConstant %6 %17 = OpConstant %6 1 %18 = OpTypePointer PushConstant %9 %23 = OpTypeStruct %9 %24 = OpTypePointer UniformConstant %23 %25 = OpVariable %24 UniformConstant %26 = OpTypePointer UniformConstant %9 %50 = OpConstant %9 0 %4 = OpFunction %2 None %3 %5 = OpLabel %15 = OpAccessChain %14 %12 %13 %19 = OpAccessChain %18 %12 %17 %27 = OpAccessChain %26 %25 %13 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactBlockIsDead(5); ASSERT_FALSE( TransformationStore(15, false, 0, 0, 13, MakeInstructionDescriptor(27, spv::Op::OpReturn, 0)) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( TransformationStore(19, false, 0, 0, 50, MakeInstructionDescriptor(27, spv::Op::OpReturn, 0)) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( TransformationStore(27, false, 0, 0, 50, MakeInstructionDescriptor(27, spv::Op::OpReturn, 0)) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationStoreTest, SupportAtomicStore) { const std::string shader = R"( OpCapability Shader OpCapability Int8 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeInt 8 1 %9 = OpTypeInt 32 0 %26 = OpTypeFloat 32 %8 = OpTypeStruct %6 %10 = OpTypePointer StorageBuffer %8 %11 = OpVariable %10 StorageBuffer %19 = OpConstant %26 0 %18 = OpConstant %9 1 %12 = OpConstant %6 0 %13 = OpTypePointer StorageBuffer %6 %15 = OpConstant %6 4 %16 = OpConstant %6 7 %17 = OpConstant %7 4 %20 = OpConstant %9 64 %21 = OpConstant %6 15 %4 = OpFunction %2 None %3 %5 = OpLabel %14 = OpAccessChain %13 %11 %12 %24 = OpAccessChain %13 %11 %12 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactValueOfPointeeIsIrrelevant( 14); // Bad: id 100 of memory scope instruction does not exist. ASSERT_FALSE(TransformationStore( 14, true, 100, 20, 21, MakeInstructionDescriptor(24, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: id 100 of memory semantics instruction does not exist. ASSERT_FALSE(TransformationStore( 14, true, 15, 100, 21, MakeInstructionDescriptor(24, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: memory scope should be |OpConstant| opcode. ASSERT_FALSE(TransformationStore( 14, true, 5, 20, 21, MakeInstructionDescriptor(24, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: memory semantics should be |OpConstant| opcode. ASSERT_FALSE(TransformationStore( 14, true, 15, 5, 21, MakeInstructionDescriptor(24, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: The memory scope instruction must have an Integer operand. ASSERT_FALSE(TransformationStore( 14, true, 15, 19, 21, MakeInstructionDescriptor(24, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: The memory memory semantics instruction must have an Integer operand. ASSERT_FALSE(TransformationStore( 14, true, 19, 20, 21, MakeInstructionDescriptor(24, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: Integer size of the memory scope must be equal to 32 bits. ASSERT_FALSE(TransformationStore( 14, true, 17, 20, 21, MakeInstructionDescriptor(24, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: Integer size of memory semantics must be equal to 32 bits. ASSERT_FALSE(TransformationStore( 14, true, 15, 17, 21, MakeInstructionDescriptor(24, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: memory scope value must be 4 (spv::Scope::Invocation). ASSERT_FALSE(TransformationStore( 14, true, 16, 20, 21, MakeInstructionDescriptor(24, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: memory semantics value must be either: // 64 (SpvMemorySemanticsUniformMemoryMask) // 256 (SpvMemorySemanticsWorkgroupMemoryMask) ASSERT_FALSE(TransformationStore( 14, true, 15, 16, 21, MakeInstructionDescriptor(24, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: The described instruction does not exist ASSERT_FALSE(TransformationStore( 14, true, 15, 20, 21, MakeInstructionDescriptor(150, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: Can't insert OpAccessChain before the id 15 of memory scope. ASSERT_FALSE(TransformationStore( 14, true, 15, 20, 21, MakeInstructionDescriptor(15, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Bad: Can't insert OpAccessChain before the id 20 of memory semantics. ASSERT_FALSE(TransformationStore( 14, true, 15, 20, 21, MakeInstructionDescriptor(20, spv::Op::OpAccessChain, 0)) .IsApplicable(context.get(), transformation_context)); // Successful transformations. { TransformationStore transformation( 14, true, 15, 20, 21, MakeInstructionDescriptor(24, spv::Op::OpReturn, 0)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } const std::string after_transformation = R"( OpCapability Shader OpCapability Int8 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeInt 8 1 %9 = OpTypeInt 32 0 %26 = OpTypeFloat 32 %8 = OpTypeStruct %6 %10 = OpTypePointer StorageBuffer %8 %11 = OpVariable %10 StorageBuffer %19 = OpConstant %26 0 %18 = OpConstant %9 1 %12 = OpConstant %6 0 %13 = OpTypePointer StorageBuffer %6 %15 = OpConstant %6 4 %16 = OpConstant %6 7 %17 = OpConstant %7 4 %20 = OpConstant %9 64 %21 = OpConstant %6 15 %4 = OpFunction %2 None %3 %5 = OpLabel %14 = OpAccessChain %13 %11 %12 %24 = OpAccessChain %13 %11 %12 OpAtomicStore %14 %15 %20 %21 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_swap_commutable_operands_test.cpp000066400000000000000000000443531475742701700324650ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_swap_commutable_operands.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationSwapCommutableOperandsTest, IsApplicableTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeInt 32 0 %8 = OpConstant %7 2 %9 = OpTypeArray %6 %8 %10 = OpTypePointer Function %9 %12 = OpConstant %6 1 %13 = OpConstant %6 2 %14 = OpConstantComposite %9 %12 %13 %15 = OpTypePointer Function %6 %17 = OpConstant %6 0 %29 = OpTypeFloat 32 %30 = OpTypeArray %29 %8 %31 = OpTypePointer Function %30 %33 = OpConstant %29 1 %34 = OpConstant %29 2 %35 = OpConstantComposite %30 %33 %34 %36 = OpTypePointer Function %29 %49 = OpTypeVector %29 3 %50 = OpTypeArray %49 %8 %51 = OpTypePointer Function %50 %53 = OpConstant %29 3 %54 = OpConstantComposite %49 %33 %34 %53 %55 = OpConstant %29 4 %56 = OpConstant %29 5 %57 = OpConstant %29 6 %58 = OpConstantComposite %49 %55 %56 %57 %59 = OpConstantComposite %50 %54 %58 %61 = OpTypePointer Function %49 %4 = OpFunction %2 None %3 %5 = OpLabel %11 = OpVariable %10 Function %16 = OpVariable %15 Function %23 = OpVariable %15 Function %32 = OpVariable %31 Function %37 = OpVariable %36 Function %43 = OpVariable %36 Function %52 = OpVariable %51 Function %60 = OpVariable %36 Function OpStore %11 %14 %18 = OpAccessChain %15 %11 %17 %19 = OpLoad %6 %18 %20 = OpAccessChain %15 %11 %12 %21 = OpLoad %6 %20 %22 = OpIAdd %6 %19 %21 OpStore %16 %22 %24 = OpAccessChain %15 %11 %17 %25 = OpLoad %6 %24 %26 = OpAccessChain %15 %11 %12 %27 = OpLoad %6 %26 %28 = OpIMul %6 %25 %27 OpStore %23 %28 OpStore %32 %35 %38 = OpAccessChain %36 %32 %17 %39 = OpLoad %29 %38 %40 = OpAccessChain %36 %32 %12 %41 = OpLoad %29 %40 %42 = OpFAdd %29 %39 %41 OpStore %37 %42 %44 = OpAccessChain %36 %32 %17 %45 = OpLoad %29 %44 %46 = OpAccessChain %36 %32 %12 %47 = OpLoad %29 %46 %48 = OpFMul %29 %45 %47 OpStore %43 %48 OpStore %52 %59 %62 = OpAccessChain %61 %52 %17 %63 = OpLoad %49 %62 %64 = OpAccessChain %61 %52 %12 %65 = OpLoad %49 %64 %66 = OpDot %29 %63 %65 OpStore %60 %66 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Tests existing commutative instructions auto instructionDescriptor = MakeInstructionDescriptor(22, spv::Op::OpIAdd, 0); auto transformation = TransformationSwapCommutableOperands(instructionDescriptor); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); instructionDescriptor = MakeInstructionDescriptor(28, spv::Op::OpIMul, 0); transformation = TransformationSwapCommutableOperands(instructionDescriptor); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); instructionDescriptor = MakeInstructionDescriptor(42, spv::Op::OpFAdd, 0); transformation = TransformationSwapCommutableOperands(instructionDescriptor); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); instructionDescriptor = MakeInstructionDescriptor(48, spv::Op::OpFMul, 0); transformation = TransformationSwapCommutableOperands(instructionDescriptor); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); instructionDescriptor = MakeInstructionDescriptor(66, spv::Op::OpDot, 0); transformation = TransformationSwapCommutableOperands(instructionDescriptor); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); // Tests existing non-commutative instructions instructionDescriptor = MakeInstructionDescriptor(1, spv::Op::OpExtInstImport, 0); transformation = TransformationSwapCommutableOperands(instructionDescriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); instructionDescriptor = MakeInstructionDescriptor(5, spv::Op::OpLabel, 0); transformation = TransformationSwapCommutableOperands(instructionDescriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); instructionDescriptor = MakeInstructionDescriptor(8, spv::Op::OpConstant, 0); transformation = TransformationSwapCommutableOperands(instructionDescriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); instructionDescriptor = MakeInstructionDescriptor(11, spv::Op::OpVariable, 0); transformation = TransformationSwapCommutableOperands(instructionDescriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); instructionDescriptor = MakeInstructionDescriptor(14, spv::Op::OpConstantComposite, 0); transformation = TransformationSwapCommutableOperands(instructionDescriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests the base instruction id not existing instructionDescriptor = MakeInstructionDescriptor(67, spv::Op::OpIAddCarry, 0); transformation = TransformationSwapCommutableOperands(instructionDescriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); instructionDescriptor = MakeInstructionDescriptor(68, spv::Op::OpIEqual, 0); transformation = TransformationSwapCommutableOperands(instructionDescriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); instructionDescriptor = MakeInstructionDescriptor(69, spv::Op::OpINotEqual, 0); transformation = TransformationSwapCommutableOperands(instructionDescriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); instructionDescriptor = MakeInstructionDescriptor(70, spv::Op::OpFOrdEqual, 0); transformation = TransformationSwapCommutableOperands(instructionDescriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); instructionDescriptor = MakeInstructionDescriptor(71, spv::Op::OpPtrEqual, 0); transformation = TransformationSwapCommutableOperands(instructionDescriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests there being no instruction with the desired opcode after the base // instruction id instructionDescriptor = MakeInstructionDescriptor(24, spv::Op::OpIAdd, 0); transformation = TransformationSwapCommutableOperands(instructionDescriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); instructionDescriptor = MakeInstructionDescriptor(38, spv::Op::OpIMul, 0); transformation = TransformationSwapCommutableOperands(instructionDescriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); instructionDescriptor = MakeInstructionDescriptor(45, spv::Op::OpFAdd, 0); transformation = TransformationSwapCommutableOperands(instructionDescriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); instructionDescriptor = MakeInstructionDescriptor(66, spv::Op::OpFMul, 0); transformation = TransformationSwapCommutableOperands(instructionDescriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests there being an instruction with the desired opcode after the base // instruction id, but the skip count associated with the instruction // descriptor being so high. instructionDescriptor = MakeInstructionDescriptor(11, spv::Op::OpIAdd, 100); transformation = TransformationSwapCommutableOperands(instructionDescriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); instructionDescriptor = MakeInstructionDescriptor(16, spv::Op::OpIMul, 100); transformation = TransformationSwapCommutableOperands(instructionDescriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); instructionDescriptor = MakeInstructionDescriptor(23, spv::Op::OpFAdd, 100); transformation = TransformationSwapCommutableOperands(instructionDescriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); instructionDescriptor = MakeInstructionDescriptor(32, spv::Op::OpFMul, 100); transformation = TransformationSwapCommutableOperands(instructionDescriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); instructionDescriptor = MakeInstructionDescriptor(37, spv::Op::OpDot, 100); transformation = TransformationSwapCommutableOperands(instructionDescriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationSwapCommutableOperandsTest, ApplyTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeInt 32 0 %8 = OpConstant %7 2 %9 = OpTypeArray %6 %8 %10 = OpTypePointer Function %9 %12 = OpConstant %6 1 %13 = OpConstant %6 2 %14 = OpConstantComposite %9 %12 %13 %15 = OpTypePointer Function %6 %17 = OpConstant %6 0 %29 = OpTypeFloat 32 %30 = OpTypeArray %29 %8 %31 = OpTypePointer Function %30 %33 = OpConstant %29 1 %34 = OpConstant %29 2 %35 = OpConstantComposite %30 %33 %34 %36 = OpTypePointer Function %29 %49 = OpTypeVector %29 3 %50 = OpTypeArray %49 %8 %51 = OpTypePointer Function %50 %53 = OpConstant %29 3 %54 = OpConstantComposite %49 %33 %34 %53 %55 = OpConstant %29 4 %56 = OpConstant %29 5 %57 = OpConstant %29 6 %58 = OpConstantComposite %49 %55 %56 %57 %59 = OpConstantComposite %50 %54 %58 %61 = OpTypePointer Function %49 %4 = OpFunction %2 None %3 %5 = OpLabel %11 = OpVariable %10 Function %16 = OpVariable %15 Function %23 = OpVariable %15 Function %32 = OpVariable %31 Function %37 = OpVariable %36 Function %43 = OpVariable %36 Function %52 = OpVariable %51 Function %60 = OpVariable %36 Function OpStore %11 %14 %18 = OpAccessChain %15 %11 %17 %19 = OpLoad %6 %18 %20 = OpAccessChain %15 %11 %12 %21 = OpLoad %6 %20 %22 = OpIAdd %6 %19 %21 OpStore %16 %22 %24 = OpAccessChain %15 %11 %17 %25 = OpLoad %6 %24 %26 = OpAccessChain %15 %11 %12 %27 = OpLoad %6 %26 %28 = OpIMul %6 %25 %27 OpStore %23 %28 OpStore %32 %35 %38 = OpAccessChain %36 %32 %17 %39 = OpLoad %29 %38 %40 = OpAccessChain %36 %32 %12 %41 = OpLoad %29 %40 %42 = OpFAdd %29 %39 %41 OpStore %37 %42 %44 = OpAccessChain %36 %32 %17 %45 = OpLoad %29 %44 %46 = OpAccessChain %36 %32 %12 %47 = OpLoad %29 %46 %48 = OpFMul %29 %45 %47 OpStore %43 %48 OpStore %52 %59 %62 = OpAccessChain %61 %52 %17 %63 = OpLoad %49 %62 %64 = OpAccessChain %61 %52 %12 %65 = OpLoad %49 %64 %66 = OpDot %29 %63 %65 OpStore %60 %66 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto instructionDescriptor = MakeInstructionDescriptor(22, spv::Op::OpIAdd, 0); auto transformation = TransformationSwapCommutableOperands(instructionDescriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); instructionDescriptor = MakeInstructionDescriptor(28, spv::Op::OpIMul, 0); transformation = TransformationSwapCommutableOperands(instructionDescriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); instructionDescriptor = MakeInstructionDescriptor(42, spv::Op::OpFAdd, 0); transformation = TransformationSwapCommutableOperands(instructionDescriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); instructionDescriptor = MakeInstructionDescriptor(48, spv::Op::OpFMul, 0); transformation = TransformationSwapCommutableOperands(instructionDescriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); instructionDescriptor = MakeInstructionDescriptor(66, spv::Op::OpDot, 0); transformation = TransformationSwapCommutableOperands(instructionDescriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); std::string variantShader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeInt 32 0 %8 = OpConstant %7 2 %9 = OpTypeArray %6 %8 %10 = OpTypePointer Function %9 %12 = OpConstant %6 1 %13 = OpConstant %6 2 %14 = OpConstantComposite %9 %12 %13 %15 = OpTypePointer Function %6 %17 = OpConstant %6 0 %29 = OpTypeFloat 32 %30 = OpTypeArray %29 %8 %31 = OpTypePointer Function %30 %33 = OpConstant %29 1 %34 = OpConstant %29 2 %35 = OpConstantComposite %30 %33 %34 %36 = OpTypePointer Function %29 %49 = OpTypeVector %29 3 %50 = OpTypeArray %49 %8 %51 = OpTypePointer Function %50 %53 = OpConstant %29 3 %54 = OpConstantComposite %49 %33 %34 %53 %55 = OpConstant %29 4 %56 = OpConstant %29 5 %57 = OpConstant %29 6 %58 = OpConstantComposite %49 %55 %56 %57 %59 = OpConstantComposite %50 %54 %58 %61 = OpTypePointer Function %49 %4 = OpFunction %2 None %3 %5 = OpLabel %11 = OpVariable %10 Function %16 = OpVariable %15 Function %23 = OpVariable %15 Function %32 = OpVariable %31 Function %37 = OpVariable %36 Function %43 = OpVariable %36 Function %52 = OpVariable %51 Function %60 = OpVariable %36 Function OpStore %11 %14 %18 = OpAccessChain %15 %11 %17 %19 = OpLoad %6 %18 %20 = OpAccessChain %15 %11 %12 %21 = OpLoad %6 %20 %22 = OpIAdd %6 %21 %19 OpStore %16 %22 %24 = OpAccessChain %15 %11 %17 %25 = OpLoad %6 %24 %26 = OpAccessChain %15 %11 %12 %27 = OpLoad %6 %26 %28 = OpIMul %6 %27 %25 OpStore %23 %28 OpStore %32 %35 %38 = OpAccessChain %36 %32 %17 %39 = OpLoad %29 %38 %40 = OpAccessChain %36 %32 %12 %41 = OpLoad %29 %40 %42 = OpFAdd %29 %41 %39 OpStore %37 %42 %44 = OpAccessChain %36 %32 %17 %45 = OpLoad %29 %44 %46 = OpAccessChain %36 %32 %12 %47 = OpLoad %29 %46 %48 = OpFMul %29 %47 %45 OpStore %43 %48 OpStore %52 %59 %62 = OpAccessChain %61 %52 %17 %63 = OpLoad %49 %62 %64 = OpAccessChain %61 %52 %12 %65 = OpLoad %49 %64 %66 = OpDot %29 %65 %63 OpStore %60 %66 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, variantShader, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_swap_conditional_branch_operands_test.cpp000066400000000000000000000141261475742701700341500ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_swap_conditional_branch_operands.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationSwapConditionalBranchOperandsTest, BasicTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %11 = OpConstant %6 1 %14 = OpTypeBool %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function OpStore %8 %9 OpStore %10 %11 %12 = OpLoad %6 %8 %13 = OpLoad %6 %10 %15 = OpSLessThan %14 %12 %13 OpSelectionMerge %17 None OpBranchConditional %15 %16 %21 10 20 %16 = OpLabel %18 = OpLoad %6 %10 %19 = OpLoad %6 %8 %20 = OpIAdd %6 %19 %18 OpBranch %17 %21 = OpLabel %22 = OpLoad %6 %10 %23 = OpLoad %6 %8 %24 = OpISub %6 %23 %22 OpBranch %17 %17 = OpLabel %25 = OpPhi %6 %20 %16 %24 %21 OpStore %8 %25 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Invalid instruction descriptor. ASSERT_FALSE(TransformationSwapConditionalBranchOperands( MakeInstructionDescriptor(26, spv::Op::OpPhi, 0), 26) .IsApplicable(context.get(), transformation_context)); // Descriptor for a wrong instruction. ASSERT_FALSE(TransformationSwapConditionalBranchOperands( MakeInstructionDescriptor(25, spv::Op::OpPhi, 0), 26) .IsApplicable(context.get(), transformation_context)); // Fresh id is not fresh. ASSERT_FALSE( TransformationSwapConditionalBranchOperands( MakeInstructionDescriptor(15, spv::Op::OpBranchConditional, 0), 25) .IsApplicable(context.get(), transformation_context)); TransformationSwapConditionalBranchOperands transformation( MakeInstructionDescriptor(15, spv::Op::OpBranchConditional, 0), 26); ASSERT_EQ(nullptr, context->get_def_use_mgr()->GetDef(26)); ASSERT_EQ(nullptr, context->get_instr_block(26)); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_EQ(spv::Op::OpLogicalNot, context->get_def_use_mgr()->GetDef(26)->opcode()); ASSERT_EQ(5, context->get_instr_block(26)->id()); ASSERT_EQ(1, context->get_def_use_mgr()->NumUses(26)); // Check that the def-use manager knows that the conditional branch operands // have been swapped. std::vector> phi_operand_to_new_operand_index = {{16, 2}, {21, 1}}; for (std::pair& entry : phi_operand_to_new_operand_index) { context->get_def_use_mgr()->WhileEachUse( entry.first, [&entry](opt::Instruction* inst, uint32_t operand_index) -> bool { if (inst->opcode() == spv::Op::OpBranchConditional) { EXPECT_EQ(entry.second, operand_index); return false; } return true; }); } std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %11 = OpConstant %6 1 %14 = OpTypeBool %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function OpStore %8 %9 OpStore %10 %11 %12 = OpLoad %6 %8 %13 = OpLoad %6 %10 %15 = OpSLessThan %14 %12 %13 %26 = OpLogicalNot %14 %15 OpSelectionMerge %17 None OpBranchConditional %26 %21 %16 20 10 %16 = OpLabel %18 = OpLoad %6 %10 %19 = OpLoad %6 %8 %20 = OpIAdd %6 %19 %18 OpBranch %17 %21 = OpLabel %22 = OpLoad %6 %10 %23 = OpLoad %6 %8 %24 = OpISub %6 %23 %22 OpBranch %17 %17 = OpLabel %25 = OpPhi %6 %20 %16 %24 %21 OpStore %8 %25 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_swap_function_variables_test.cpp000066400000000000000000000245561475742701700323220ustar00rootroot00000000000000// Copyright (c) 2021 Mostafa Ashraf // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_swap_function_variables.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationSwapFunctionVariables, NotApplicable) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFloat 32 %9 = OpTypePointer Function %8 %10 = OpTypeVector %8 2 %11 = OpTypePointer Function %10 %12 = OpTypeVector %8 3 %13 = OpTypeMatrix %12 3 %14 = OpTypePointer Function %13 %15 = OpTypeFunction %2 %7 %9 %11 %14 %7 %7 %4 = OpFunction %2 None %3 %5 = OpLabel %24 = OpVariable %7 Function %25 = OpVariable %9 Function %26 = OpVariable %11 Function %27 = OpVariable %14 Function %28 = OpVariable %7 Function %29 = OpVariable %7 Function %30 = OpVariable %7 Function %32 = OpVariable %9 Function %34 = OpVariable %11 Function %36 = OpVariable %14 Function %38 = OpVariable %7 Function %40 = OpVariable %7 Function %31 = OpLoad %6 %24 OpStore %30 %31 %33 = OpLoad %8 %25 OpStore %32 %33 %35 = OpLoad %10 %26 OpStore %34 %35 %37 = OpLoad %13 %27 OpStore %36 %37 %39 = OpLoad %6 %28 OpStore %38 %39 %41 = OpLoad %6 %29 OpStore %40 %41 %42 = OpFunctionCall %2 %22 %30 %32 %34 %36 %38 %40 OpReturn OpFunctionEnd %22 = OpFunction %2 None %15 %16 = OpFunctionParameter %7 %17 = OpFunctionParameter %9 %18 = OpFunctionParameter %11 %19 = OpFunctionParameter %14 %20 = OpFunctionParameter %7 %21 = OpFunctionParameter %7 %23 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); #ifndef NDEBUG // Can't swap variable with itself. ASSERT_DEATH(TransformationSwapFunctionVariables(7, 7).IsApplicable( context.get(), transformation_context), "Two results ids are equal"); #endif // Invalid because 200 is not the id of an instruction. ASSERT_FALSE(TransformationSwapFunctionVariables(1, 200).IsApplicable( context.get(), transformation_context)); // Invalid because 5 is not the id of an instruction. ASSERT_FALSE(TransformationSwapFunctionVariables(5, 24).IsApplicable( context.get(), transformation_context)); // Can't swap two instructions from two different blocks. ASSERT_FALSE(TransformationSwapFunctionVariables(16, 26).IsApplicable( context.get(), transformation_context)); } TEST(TransformationSwapFunctionVariables, IsApplicable) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFloat 32 %9 = OpTypePointer Function %8 %10 = OpTypeVector %8 2 %11 = OpTypePointer Function %10 %12 = OpTypeVector %8 3 %13 = OpTypeMatrix %12 3 %14 = OpTypePointer Function %13 %15 = OpTypeFunction %2 %7 %9 %11 %14 %7 %7 %4 = OpFunction %2 None %3 %5 = OpLabel %24 = OpVariable %7 Function %25 = OpVariable %9 Function %26 = OpVariable %11 Function %27 = OpVariable %14 Function %28 = OpVariable %7 Function %29 = OpVariable %7 Function %30 = OpVariable %7 Function %32 = OpVariable %9 Function %34 = OpVariable %11 Function %36 = OpVariable %14 Function %38 = OpVariable %7 Function %40 = OpVariable %7 Function %31 = OpLoad %6 %24 OpStore %30 %31 %33 = OpLoad %8 %25 OpStore %32 %33 %35 = OpLoad %10 %26 OpStore %34 %35 %37 = OpLoad %13 %27 OpStore %36 %37 %39 = OpLoad %6 %28 OpStore %38 %39 %41 = OpLoad %6 %29 OpStore %40 %41 %42 = OpFunctionCall %2 %22 %30 %32 %34 %36 %38 %40 OpReturn OpFunctionEnd %22 = OpFunction %2 None %15 %16 = OpFunctionParameter %7 %17 = OpFunctionParameter %9 %18 = OpFunctionParameter %11 %19 = OpFunctionParameter %14 %20 = OpFunctionParameter %7 %21 = OpFunctionParameter %7 %23 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; // Get Unique pointer of IRContext. const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Successful transformations { auto first_instruction = context->get_def_use_mgr()->GetDef(24); auto second_instruction = context->get_def_use_mgr()->GetDef(28); // Swap two OpVariable instructions in the same function. TransformationSwapFunctionVariables transformation(24, 28); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_EQ(first_instruction, context->get_def_use_mgr()->GetDef(24)); ASSERT_EQ(second_instruction, context->get_def_use_mgr()->GetDef(28)); } { auto first_instruction = context->get_def_use_mgr()->GetDef(38); auto second_instruction = context->get_def_use_mgr()->GetDef(40); // Swap two OpVariable instructions in the same function. TransformationSwapFunctionVariables transformation(38, 40); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_EQ(first_instruction, context->get_def_use_mgr()->GetDef(38)); ASSERT_EQ(second_instruction, context->get_def_use_mgr()->GetDef(40)); } std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFloat 32 %9 = OpTypePointer Function %8 %10 = OpTypeVector %8 2 %11 = OpTypePointer Function %10 %12 = OpTypeVector %8 3 %13 = OpTypeMatrix %12 3 %14 = OpTypePointer Function %13 %15 = OpTypeFunction %2 %7 %9 %11 %14 %7 %7 %4 = OpFunction %2 None %3 %5 = OpLabel %28 = OpVariable %7 Function %25 = OpVariable %9 Function %26 = OpVariable %11 Function %27 = OpVariable %14 Function %24 = OpVariable %7 Function %29 = OpVariable %7 Function %30 = OpVariable %7 Function %32 = OpVariable %9 Function %34 = OpVariable %11 Function %36 = OpVariable %14 Function %40 = OpVariable %7 Function %38 = OpVariable %7 Function %31 = OpLoad %6 %24 OpStore %30 %31 %33 = OpLoad %8 %25 OpStore %32 %33 %35 = OpLoad %10 %26 OpStore %34 %35 %37 = OpLoad %13 %27 OpStore %36 %37 %39 = OpLoad %6 %28 OpStore %38 %39 %41 = OpLoad %6 %29 OpStore %40 %41 %42 = OpFunctionCall %2 %22 %30 %32 %34 %36 %38 %40 OpReturn OpFunctionEnd %22 = OpFunction %2 None %15 %16 = OpFunctionParameter %7 %17 = OpFunctionParameter %9 %18 = OpFunctionParameter %11 %19 = OpFunctionParameter %14 %20 = OpFunctionParameter %7 %21 = OpFunctionParameter %7 %23 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_swap_two_functions_test.cpp000066400000000000000000000214241475742701700313350ustar00rootroot00000000000000// Copyright (c) 2021 Shiyu Liu // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_swap_two_functions.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationSwapTwoFunctionsTest, SimpleTest) { // float multiplyBy2(in float value) { // return value*2.0; // } // float multiplyBy4(in float value) { // return multiplyBy2(value)*2.0; // } // float multiplyBy8(in float value) { // return multiplyBy2(value)*multiplyBy4(value); // } // layout(location=0) in float value; // void main() { //4 // multiplyBy2(3.7); //10 // multiplyBy4(3.9); //13 // multiplyBy8(5.0); //16 // } std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %48 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %10 "multiplyBy2(f1;" OpName %9 "value" OpName %13 "multiplyBy4(f1;" OpName %12 "value" OpName %16 "multiplyBy8(f1;" OpName %15 "value" OpName %23 "param" OpName %29 "param" OpName %32 "param" OpName %39 "param" OpName %42 "param" OpName %45 "param" OpName %48 "value" OpDecorate %48 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %6 %7 %19 = OpConstant %6 2 %38 = OpConstant %6 3.70000005 %41 = OpConstant %6 3.9000001 %44 = OpConstant %6 5 %47 = OpTypePointer Input %6 %48 = OpVariable %47 Input %4 = OpFunction %2 None %3 %5 = OpLabel %39 = OpVariable %7 Function %42 = OpVariable %7 Function %45 = OpVariable %7 Function OpStore %39 %38 %40 = OpFunctionCall %6 %10 %39 OpStore %42 %41 %43 = OpFunctionCall %6 %13 %42 OpStore %45 %44 %46 = OpFunctionCall %6 %16 %45 OpReturn OpFunctionEnd %10 = OpFunction %6 None %8 %9 = OpFunctionParameter %7 %11 = OpLabel %18 = OpLoad %6 %9 %20 = OpFMul %6 %18 %19 OpReturnValue %20 OpFunctionEnd %13 = OpFunction %6 None %8 %12 = OpFunctionParameter %7 %14 = OpLabel %23 = OpVariable %7 Function %24 = OpLoad %6 %12 OpStore %23 %24 %25 = OpFunctionCall %6 %10 %23 %26 = OpFMul %6 %25 %19 OpReturnValue %26 OpFunctionEnd %16 = OpFunction %6 None %8 %15 = OpFunctionParameter %7 %17 = OpLabel %29 = OpVariable %7 Function %32 = OpVariable %7 Function %30 = OpLoad %6 %15 OpStore %29 %30 %31 = OpFunctionCall %6 %10 %29 %33 = OpLoad %6 %15 OpStore %32 %33 %34 = OpFunctionCall %6 %13 %32 %35 = OpFMul %6 %31 %34 OpReturnValue %35 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; // Check context validity. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); #ifndef NDEBUG // Function should not swap with itself. ASSERT_DEATH(TransformationSwapTwoFunctions(4, 4).IsApplicable( context.get(), transformation_context), "The two function ids cannot be the same."); #endif // Function with id 29 does not exist. ASSERT_FALSE(TransformationSwapTwoFunctions(10, 29).IsApplicable( context.get(), transformation_context)); // Function with id 30 does not exist. ASSERT_FALSE(TransformationSwapTwoFunctions(30, 13).IsApplicable( context.get(), transformation_context)); // Both functions with id 5 and 6 do not exist. ASSERT_FALSE(TransformationSwapTwoFunctions(5, 6).IsApplicable( context.get(), transformation_context)); // Function with result_id 10 and 13 should swap successfully. auto swap_test5 = TransformationSwapTwoFunctions(10, 13); ASSERT_TRUE(swap_test5.IsApplicable(context.get(), transformation_context)); // Get the definitions of functions 10 and 13, as recorded by the def-use // manager. auto def_use_manager = context->get_def_use_mgr(); auto function_10_inst = def_use_manager->GetDef(10); auto function_13_inst = def_use_manager->GetDef(13); ApplyAndCheckFreshIds(swap_test5, context.get(), &transformation_context); // Check that def-use information for functions 10 and 13 has been preserved // by the transformation. ASSERT_EQ(function_10_inst, def_use_manager->GetDef(10)); ASSERT_EQ(function_13_inst, def_use_manager->GetDef(13)); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %48 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %10 "multiplyBy2(f1;" OpName %9 "value" OpName %13 "multiplyBy4(f1;" OpName %12 "value" OpName %16 "multiplyBy8(f1;" OpName %15 "value" OpName %23 "param" OpName %29 "param" OpName %32 "param" OpName %39 "param" OpName %42 "param" OpName %45 "param" OpName %48 "value" OpDecorate %48 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %6 %7 %19 = OpConstant %6 2 %38 = OpConstant %6 3.70000005 %41 = OpConstant %6 3.9000001 %44 = OpConstant %6 5 %47 = OpTypePointer Input %6 %48 = OpVariable %47 Input %4 = OpFunction %2 None %3 %5 = OpLabel %39 = OpVariable %7 Function %42 = OpVariable %7 Function %45 = OpVariable %7 Function OpStore %39 %38 %40 = OpFunctionCall %6 %10 %39 OpStore %42 %41 %43 = OpFunctionCall %6 %13 %42 OpStore %45 %44 %46 = OpFunctionCall %6 %16 %45 OpReturn OpFunctionEnd %13 = OpFunction %6 None %8 %12 = OpFunctionParameter %7 %14 = OpLabel %23 = OpVariable %7 Function %24 = OpLoad %6 %12 OpStore %23 %24 %25 = OpFunctionCall %6 %10 %23 %26 = OpFMul %6 %25 %19 OpReturnValue %26 OpFunctionEnd %10 = OpFunction %6 None %8 %9 = OpFunctionParameter %7 %11 = OpLabel %18 = OpLoad %6 %9 %20 = OpFMul %6 %18 %19 OpReturnValue %20 OpFunctionEnd %16 = OpFunction %6 None %8 %15 = OpFunctionParameter %7 %17 = OpLabel %29 = OpVariable %7 Function %32 = OpVariable %7 Function %30 = OpLoad %6 %15 OpStore %29 %30 %31 = OpFunctionCall %6 %10 %29 %33 = OpLoad %6 %15 OpStore %32 %33 %34 = OpFunctionCall %6 %13 %32 %35 = OpFMul %6 %31 %34 OpReturnValue %35 OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_toggle_access_chain_instruction_test.cpp000066400000000000000000000404421475742701700340100ustar00rootroot00000000000000// Copyright (c) 2020 André Perez Maselco // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_toggle_access_chain_instruction.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationToggleAccessChainInstructionTest, IsApplicableTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeInt 32 0 %8 = OpConstant %7 2 %9 = OpTypeArray %6 %8 %10 = OpTypePointer Function %9 %12 = OpConstant %6 1 %13 = OpConstant %6 2 %14 = OpConstantComposite %9 %12 %13 %15 = OpTypePointer Function %6 %17 = OpConstant %6 0 %29 = OpTypeFloat 32 %30 = OpTypeArray %29 %8 %31 = OpTypePointer Function %30 %33 = OpConstant %29 1 %34 = OpConstant %29 2 %35 = OpConstantComposite %30 %33 %34 %36 = OpTypePointer Function %29 %49 = OpTypeVector %29 3 %50 = OpTypeArray %49 %8 %51 = OpTypePointer Function %50 %53 = OpConstant %29 3 %54 = OpConstantComposite %49 %33 %34 %53 %55 = OpConstant %29 4 %56 = OpConstant %29 5 %57 = OpConstant %29 6 %58 = OpConstantComposite %49 %55 %56 %57 %59 = OpConstantComposite %50 %54 %58 %61 = OpTypePointer Function %49 %4 = OpFunction %2 None %3 %5 = OpLabel %11 = OpVariable %10 Function %16 = OpVariable %15 Function %23 = OpVariable %15 Function %32 = OpVariable %31 Function %37 = OpVariable %36 Function %43 = OpVariable %36 Function %52 = OpVariable %51 Function %60 = OpVariable %36 Function OpStore %11 %14 %18 = OpAccessChain %15 %11 %17 %19 = OpLoad %6 %18 %20 = OpInBoundsAccessChain %15 %11 %12 %21 = OpLoad %6 %20 %22 = OpIAdd %6 %19 %21 OpStore %16 %22 %24 = OpAccessChain %15 %11 %17 %25 = OpLoad %6 %24 %26 = OpInBoundsAccessChain %15 %11 %12 %27 = OpLoad %6 %26 %28 = OpIMul %6 %25 %27 OpStore %23 %28 OpStore %32 %35 %38 = OpAccessChain %36 %32 %17 %39 = OpLoad %29 %38 %40 = OpAccessChain %36 %32 %12 %41 = OpLoad %29 %40 %42 = OpFAdd %29 %39 %41 OpStore %37 %42 %44 = OpAccessChain %36 %32 %17 %45 = OpLoad %29 %44 %46 = OpAccessChain %36 %32 %12 %47 = OpLoad %29 %46 %48 = OpFMul %29 %45 %47 OpStore %43 %48 OpStore %52 %59 %62 = OpAccessChain %61 %52 %17 %63 = OpLoad %49 %62 %64 = OpAccessChain %61 %52 %12 %65 = OpLoad %49 %64 %66 = OpDot %29 %63 %65 OpStore %60 %66 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Tests existing access chain instructions auto instructionDescriptor = MakeInstructionDescriptor(18, spv::Op::OpAccessChain, 0); auto transformation = TransformationToggleAccessChainInstruction(instructionDescriptor); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); instructionDescriptor = MakeInstructionDescriptor(20, spv::Op::OpInBoundsAccessChain, 0); transformation = TransformationToggleAccessChainInstruction(instructionDescriptor); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); instructionDescriptor = MakeInstructionDescriptor(24, spv::Op::OpAccessChain, 0); transformation = TransformationToggleAccessChainInstruction(instructionDescriptor); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); instructionDescriptor = MakeInstructionDescriptor(26, spv::Op::OpInBoundsAccessChain, 0); transformation = TransformationToggleAccessChainInstruction(instructionDescriptor); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); // Tests existing non-access chain instructions instructionDescriptor = MakeInstructionDescriptor(1, spv::Op::OpExtInstImport, 0); transformation = TransformationToggleAccessChainInstruction(instructionDescriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); instructionDescriptor = MakeInstructionDescriptor(5, spv::Op::OpLabel, 0); transformation = TransformationToggleAccessChainInstruction(instructionDescriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); instructionDescriptor = MakeInstructionDescriptor(14, spv::Op::OpConstantComposite, 0); transformation = TransformationToggleAccessChainInstruction(instructionDescriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests the base instruction id not existing instructionDescriptor = MakeInstructionDescriptor(67, spv::Op::OpAccessChain, 0); transformation = TransformationToggleAccessChainInstruction(instructionDescriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); instructionDescriptor = MakeInstructionDescriptor(68, spv::Op::OpAccessChain, 0); transformation = TransformationToggleAccessChainInstruction(instructionDescriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); instructionDescriptor = MakeInstructionDescriptor(69, spv::Op::OpInBoundsAccessChain, 0); transformation = TransformationToggleAccessChainInstruction(instructionDescriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests there being no instruction with the desired opcode after the base // instruction id instructionDescriptor = MakeInstructionDescriptor(65, spv::Op::OpAccessChain, 0); transformation = TransformationToggleAccessChainInstruction(instructionDescriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); instructionDescriptor = MakeInstructionDescriptor(66, spv::Op::OpInBoundsAccessChain, 0); transformation = TransformationToggleAccessChainInstruction(instructionDescriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); // Tests there being an instruction with the desired opcode after the base // instruction id, but the skip count associated with the instruction // descriptor being so high. instructionDescriptor = MakeInstructionDescriptor(11, spv::Op::OpAccessChain, 100); transformation = TransformationToggleAccessChainInstruction(instructionDescriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); instructionDescriptor = MakeInstructionDescriptor(16, spv::Op::OpInBoundsAccessChain, 100); transformation = TransformationToggleAccessChainInstruction(instructionDescriptor); ASSERT_FALSE( transformation.IsApplicable(context.get(), transformation_context)); } TEST(TransformationToggleAccessChainInstructionTest, ApplyTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeInt 32 0 %8 = OpConstant %7 2 %9 = OpTypeArray %6 %8 %10 = OpTypePointer Function %9 %12 = OpConstant %6 1 %13 = OpConstant %6 2 %14 = OpConstantComposite %9 %12 %13 %15 = OpTypePointer Function %6 %17 = OpConstant %6 0 %29 = OpTypeFloat 32 %30 = OpTypeArray %29 %8 %31 = OpTypePointer Function %30 %33 = OpConstant %29 1 %34 = OpConstant %29 2 %35 = OpConstantComposite %30 %33 %34 %36 = OpTypePointer Function %29 %49 = OpTypeVector %29 3 %50 = OpTypeArray %49 %8 %51 = OpTypePointer Function %50 %53 = OpConstant %29 3 %54 = OpConstantComposite %49 %33 %34 %53 %55 = OpConstant %29 4 %56 = OpConstant %29 5 %57 = OpConstant %29 6 %58 = OpConstantComposite %49 %55 %56 %57 %59 = OpConstantComposite %50 %54 %58 %61 = OpTypePointer Function %49 %4 = OpFunction %2 None %3 %5 = OpLabel %11 = OpVariable %10 Function %16 = OpVariable %15 Function %23 = OpVariable %15 Function %32 = OpVariable %31 Function %37 = OpVariable %36 Function %43 = OpVariable %36 Function %52 = OpVariable %51 Function %60 = OpVariable %36 Function OpStore %11 %14 %18 = OpAccessChain %15 %11 %17 %19 = OpLoad %6 %18 %20 = OpInBoundsAccessChain %15 %11 %12 %21 = OpLoad %6 %20 %22 = OpIAdd %6 %19 %21 OpStore %16 %22 %24 = OpAccessChain %15 %11 %17 %25 = OpLoad %6 %24 %26 = OpInBoundsAccessChain %15 %11 %12 %27 = OpLoad %6 %26 %28 = OpIMul %6 %25 %27 OpStore %23 %28 OpStore %32 %35 %38 = OpAccessChain %36 %32 %17 %39 = OpLoad %29 %38 %40 = OpAccessChain %36 %32 %12 %41 = OpLoad %29 %40 %42 = OpFAdd %29 %39 %41 OpStore %37 %42 %44 = OpAccessChain %36 %32 %17 %45 = OpLoad %29 %44 %46 = OpAccessChain %36 %32 %12 %47 = OpLoad %29 %46 %48 = OpFMul %29 %45 %47 OpStore %43 %48 OpStore %52 %59 %62 = OpAccessChain %61 %52 %17 %63 = OpLoad %49 %62 %64 = OpAccessChain %61 %52 %12 %65 = OpLoad %49 %64 %66 = OpDot %29 %63 %65 OpStore %60 %66 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); auto instructionDescriptor = MakeInstructionDescriptor(18, spv::Op::OpAccessChain, 0); auto transformation = TransformationToggleAccessChainInstruction(instructionDescriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); instructionDescriptor = MakeInstructionDescriptor(20, spv::Op::OpInBoundsAccessChain, 0); transformation = TransformationToggleAccessChainInstruction(instructionDescriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); instructionDescriptor = MakeInstructionDescriptor(24, spv::Op::OpAccessChain, 0); transformation = TransformationToggleAccessChainInstruction(instructionDescriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); instructionDescriptor = MakeInstructionDescriptor(26, spv::Op::OpInBoundsAccessChain, 0); transformation = TransformationToggleAccessChainInstruction(instructionDescriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); instructionDescriptor = MakeInstructionDescriptor(38, spv::Op::OpAccessChain, 0); transformation = TransformationToggleAccessChainInstruction(instructionDescriptor); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); std::string variantShader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeInt 32 0 %8 = OpConstant %7 2 %9 = OpTypeArray %6 %8 %10 = OpTypePointer Function %9 %12 = OpConstant %6 1 %13 = OpConstant %6 2 %14 = OpConstantComposite %9 %12 %13 %15 = OpTypePointer Function %6 %17 = OpConstant %6 0 %29 = OpTypeFloat 32 %30 = OpTypeArray %29 %8 %31 = OpTypePointer Function %30 %33 = OpConstant %29 1 %34 = OpConstant %29 2 %35 = OpConstantComposite %30 %33 %34 %36 = OpTypePointer Function %29 %49 = OpTypeVector %29 3 %50 = OpTypeArray %49 %8 %51 = OpTypePointer Function %50 %53 = OpConstant %29 3 %54 = OpConstantComposite %49 %33 %34 %53 %55 = OpConstant %29 4 %56 = OpConstant %29 5 %57 = OpConstant %29 6 %58 = OpConstantComposite %49 %55 %56 %57 %59 = OpConstantComposite %50 %54 %58 %61 = OpTypePointer Function %49 %4 = OpFunction %2 None %3 %5 = OpLabel %11 = OpVariable %10 Function %16 = OpVariable %15 Function %23 = OpVariable %15 Function %32 = OpVariable %31 Function %37 = OpVariable %36 Function %43 = OpVariable %36 Function %52 = OpVariable %51 Function %60 = OpVariable %36 Function OpStore %11 %14 %18 = OpInBoundsAccessChain %15 %11 %17 %19 = OpLoad %6 %18 %20 = OpAccessChain %15 %11 %12 %21 = OpLoad %6 %20 %22 = OpIAdd %6 %19 %21 OpStore %16 %22 %24 = OpInBoundsAccessChain %15 %11 %17 %25 = OpLoad %6 %24 %26 = OpAccessChain %15 %11 %12 %27 = OpLoad %6 %26 %28 = OpIMul %6 %25 %27 OpStore %23 %28 OpStore %32 %35 %38 = OpInBoundsAccessChain %36 %32 %17 %39 = OpLoad %29 %38 %40 = OpAccessChain %36 %32 %12 %41 = OpLoad %29 %40 %42 = OpFAdd %29 %39 %41 OpStore %37 %42 %44 = OpAccessChain %36 %32 %17 %45 = OpLoad %29 %44 %46 = OpAccessChain %36 %32 %12 %47 = OpLoad %29 %46 %48 = OpFMul %29 %45 %47 OpStore %43 %48 OpStore %52 %59 %62 = OpAccessChain %61 %52 %17 %63 = OpLoad %49 %62 %64 = OpAccessChain %61 %52 %12 %65 = OpLoad %49 %64 %66 = OpDot %29 %63 %65 OpStore %60 %66 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, variantShader, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_vector_shuffle_test.cpp000066400000000000000000001052271475742701700304240ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_vector_shuffle.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationVectorShuffleTest, BasicTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpTypeVector %6 2 %10 = OpConstantTrue %6 %11 = OpConstantFalse %6 %12 = OpConstantComposite %7 %10 %11 %112 = OpUndef %7 %13 = OpTypeVector %6 3 %16 = OpConstantComposite %13 %10 %11 %10 %17 = OpTypeVector %6 4 %20 = OpConstantComposite %17 %10 %11 %10 %11 %21 = OpTypeInt 32 1 %22 = OpTypeVector %21 2 %25 = OpConstant %21 1 %26 = OpConstant %21 0 %27 = OpConstantComposite %22 %25 %26 %28 = OpTypeVector %21 3 %31 = OpConstantComposite %28 %25 %26 %25 %32 = OpTypeVector %21 4 %33 = OpTypePointer Function %32 %35 = OpConstantComposite %32 %25 %26 %25 %26 %36 = OpTypeInt 32 0 %37 = OpTypeVector %36 2 %40 = OpConstant %36 1 %41 = OpConstant %36 0 %42 = OpConstantComposite %37 %40 %41 %43 = OpTypeVector %36 3 %46 = OpConstantComposite %43 %40 %41 %40 %47 = OpTypeVector %36 4 %50 = OpConstantComposite %47 %40 %41 %40 %41 %51 = OpTypeFloat 32 %55 = OpConstant %51 1 %56 = OpConstant %51 0 %58 = OpTypeVector %51 3 %61 = OpConstantComposite %58 %55 %56 %55 %62 = OpTypeVector %51 4 %65 = OpConstantComposite %62 %55 %56 %55 %56 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %100 None OpBranchConditional %10 %101 %102 %101 = OpLabel %103 = OpCompositeConstruct %62 %55 %55 %55 %56 OpBranch %100 %102 = OpLabel OpBranch %100 %100 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(10, {}), MakeDataDescriptor(12, {0})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(11, {}), MakeDataDescriptor(12, {1})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(10, {}), MakeDataDescriptor(16, {0})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(11, {}), MakeDataDescriptor(16, {1})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(10, {}), MakeDataDescriptor(16, {2})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(10, {}), MakeDataDescriptor(20, {0})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(11, {}), MakeDataDescriptor(20, {1})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(10, {}), MakeDataDescriptor(20, {2})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(11, {}), MakeDataDescriptor(20, {3})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(25, {}), MakeDataDescriptor(27, {0})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(26, {}), MakeDataDescriptor(27, {1})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(25, {}), MakeDataDescriptor(31, {0})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(26, {}), MakeDataDescriptor(31, {1})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(25, {}), MakeDataDescriptor(31, {2})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(25, {}), MakeDataDescriptor(35, {0})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(26, {}), MakeDataDescriptor(35, {1})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(25, {}), MakeDataDescriptor(35, {2})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(26, {}), MakeDataDescriptor(35, {3})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(40, {}), MakeDataDescriptor(42, {0})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(41, {}), MakeDataDescriptor(42, {1})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(40, {}), MakeDataDescriptor(46, {0})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(41, {}), MakeDataDescriptor(46, {1})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(40, {}), MakeDataDescriptor(46, {2})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(40, {}), MakeDataDescriptor(50, {0})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(41, {}), MakeDataDescriptor(50, {1})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(40, {}), MakeDataDescriptor(50, {2})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(41, {}), MakeDataDescriptor(50, {3})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(55, {}), MakeDataDescriptor(61, {0})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(56, {}), MakeDataDescriptor(61, {1})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(55, {}), MakeDataDescriptor(61, {2})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(55, {}), MakeDataDescriptor(65, {0})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(56, {}), MakeDataDescriptor(65, {1})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(55, {}), MakeDataDescriptor(65, {2})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(56, {}), MakeDataDescriptor(65, {3})); // %103 does not dominate the return instruction. ASSERT_FALSE(TransformationVectorShuffle( MakeInstructionDescriptor(100, spv::Op::OpReturn, 0), 200, 103, 65, {3, 5, 7}) .IsApplicable(context.get(), transformation_context)); // Illegal to shuffle a bvec2 and a vec3 ASSERT_FALSE(TransformationVectorShuffle( MakeInstructionDescriptor(100, spv::Op::OpReturn, 0), 200, 112, 61, {0, 2, 4}) .IsApplicable(context.get(), transformation_context)); // Illegal to shuffle an ivec2 and a uvec4 ASSERT_FALSE(TransformationVectorShuffle( MakeInstructionDescriptor(100, spv::Op::OpReturn, 0), 200, 27, 50, {1, 3, 5}) .IsApplicable(context.get(), transformation_context)); // Vector 1 does not exist ASSERT_FALSE(TransformationVectorShuffle( MakeInstructionDescriptor(100, spv::Op::OpReturn, 0), 200, 300, 50, {1, 3, 5}) .IsApplicable(context.get(), transformation_context)); // Vector 2 does not exist ASSERT_FALSE(TransformationVectorShuffle( MakeInstructionDescriptor(100, spv::Op::OpReturn, 0), 200, 27, 300, {1, 3, 5}) .IsApplicable(context.get(), transformation_context)); // Index out of range ASSERT_FALSE(TransformationVectorShuffle( MakeInstructionDescriptor(100, spv::Op::OpReturn, 0), 200, 12, 112, {0, 20}) .IsApplicable(context.get(), transformation_context)); // Too many indices ASSERT_FALSE(TransformationVectorShuffle( MakeInstructionDescriptor(100, spv::Op::OpReturn, 0), 200, 12, 112, {0, 1, 0, 1, 0, 1, 0, 1}) .IsApplicable(context.get(), transformation_context)); // Too few indices ASSERT_FALSE(TransformationVectorShuffle( MakeInstructionDescriptor(100, spv::Op::OpReturn, 0), 200, 12, 112, {}) .IsApplicable(context.get(), transformation_context)); // Too few indices again ASSERT_FALSE(TransformationVectorShuffle( MakeInstructionDescriptor(100, spv::Op::OpReturn, 0), 200, 12, 112, {0}) .IsApplicable(context.get(), transformation_context)); // Indices define unknown type: we do not have vec2 ASSERT_FALSE(TransformationVectorShuffle( MakeInstructionDescriptor(100, spv::Op::OpReturn, 0), 200, 65, 65, {0, 1}) .IsApplicable(context.get(), transformation_context)); // The instruction to insert before does not exist ASSERT_FALSE( TransformationVectorShuffle( MakeInstructionDescriptor(100, spv::Op::OpCompositeConstruct, 1), 201, 20, 12, {0xFFFFFFFF, 3, 5}) .IsApplicable(context.get(), transformation_context)); // The 'fresh' id is already in use ASSERT_FALSE( TransformationVectorShuffle( MakeInstructionDescriptor(100, spv::Op::OpReturn, 0), 12, 12, 112, {}) .IsApplicable(context.get(), transformation_context)); protobufs::DataDescriptor temp_dd; TransformationVectorShuffle transformation1( MakeInstructionDescriptor(100, spv::Op::OpReturn, 0), 200, 12, 112, {1, 0}); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); temp_dd = MakeDataDescriptor(200, {0}); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(11, {}), temp_dd)); temp_dd = MakeDataDescriptor(200, {1}); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(10, {}), temp_dd)); TransformationVectorShuffle transformation2( MakeInstructionDescriptor(100, spv::Op::OpReturn, 0), 201, 20, 12, {0xFFFFFFFF, 3, 5}); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); temp_dd = MakeDataDescriptor(201, {1}); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(11, {}), temp_dd)); temp_dd = MakeDataDescriptor(201, {2}); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(11, {}), temp_dd)); TransformationVectorShuffle transformation3( MakeInstructionDescriptor(100, spv::Op::OpReturn, 0), 202, 27, 35, {5, 4, 1}); ASSERT_TRUE( transformation3.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation3, context.get(), &transformation_context); temp_dd = MakeDataDescriptor(202, {0}); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(26, {}), temp_dd)); temp_dd = MakeDataDescriptor(202, {1}); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(25, {}), temp_dd)); temp_dd = MakeDataDescriptor(202, {2}); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(26, {}), temp_dd)); TransformationVectorShuffle transformation4( MakeInstructionDescriptor(100, spv::Op::OpReturn, 0), 203, 42, 46, {0, 1}); ASSERT_TRUE( transformation4.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation4, context.get(), &transformation_context); temp_dd = MakeDataDescriptor(203, {0}); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(40, {}), temp_dd)); temp_dd = MakeDataDescriptor(203, {1}); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(41, {}), temp_dd)); TransformationVectorShuffle transformation5( MakeInstructionDescriptor(100, spv::Op::OpReturn, 0), 204, 42, 46, {2, 3, 4}); ASSERT_TRUE( transformation5.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation5, context.get(), &transformation_context); temp_dd = MakeDataDescriptor(204, {0}); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(40, {}), temp_dd)); temp_dd = MakeDataDescriptor(204, {1}); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(41, {}), temp_dd)); temp_dd = MakeDataDescriptor(204, {2}); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(40, {}), temp_dd)); TransformationVectorShuffle transformation6( MakeInstructionDescriptor(100, spv::Op::OpReturn, 0), 205, 42, 42, {0, 1, 2, 3}); ASSERT_TRUE( transformation6.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation6, context.get(), &transformation_context); temp_dd = MakeDataDescriptor(205, {0}); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(40, {}), temp_dd)); temp_dd = MakeDataDescriptor(205, {1}); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(41, {}), temp_dd)); temp_dd = MakeDataDescriptor(205, {2}); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(40, {}), temp_dd)); temp_dd = MakeDataDescriptor(205, {3}); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(41, {}), temp_dd)); // swizzle vec4 from vec4 and vec4 using some undefs TransformationVectorShuffle transformation7( MakeInstructionDescriptor(100, spv::Op::OpReturn, 0), 206, 65, 65, {0xFFFFFFFF, 3, 6, 0xFFFFFFFF}); ASSERT_TRUE( transformation7.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation7, context.get(), &transformation_context); temp_dd = MakeDataDescriptor(206, {1}); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(56, {}), temp_dd)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpTypeVector %6 2 %10 = OpConstantTrue %6 %11 = OpConstantFalse %6 %12 = OpConstantComposite %7 %10 %11 %112 = OpUndef %7 %13 = OpTypeVector %6 3 %16 = OpConstantComposite %13 %10 %11 %10 %17 = OpTypeVector %6 4 %20 = OpConstantComposite %17 %10 %11 %10 %11 %21 = OpTypeInt 32 1 %22 = OpTypeVector %21 2 %25 = OpConstant %21 1 %26 = OpConstant %21 0 %27 = OpConstantComposite %22 %25 %26 %28 = OpTypeVector %21 3 %31 = OpConstantComposite %28 %25 %26 %25 %32 = OpTypeVector %21 4 %33 = OpTypePointer Function %32 %35 = OpConstantComposite %32 %25 %26 %25 %26 %36 = OpTypeInt 32 0 %37 = OpTypeVector %36 2 %40 = OpConstant %36 1 %41 = OpConstant %36 0 %42 = OpConstantComposite %37 %40 %41 %43 = OpTypeVector %36 3 %46 = OpConstantComposite %43 %40 %41 %40 %47 = OpTypeVector %36 4 %50 = OpConstantComposite %47 %40 %41 %40 %41 %51 = OpTypeFloat 32 %55 = OpConstant %51 1 %56 = OpConstant %51 0 %58 = OpTypeVector %51 3 %61 = OpConstantComposite %58 %55 %56 %55 %62 = OpTypeVector %51 4 %65 = OpConstantComposite %62 %55 %56 %55 %56 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %100 None OpBranchConditional %10 %101 %102 %101 = OpLabel %103 = OpCompositeConstruct %62 %55 %55 %55 %56 OpBranch %100 %102 = OpLabel OpBranch %100 %100 = OpLabel %200 = OpVectorShuffle %7 %12 %112 1 0 %201 = OpVectorShuffle %13 %20 %12 0xFFFFFFFF 3 5 %202 = OpVectorShuffle %28 %27 %35 5 4 1 %203 = OpVectorShuffle %37 %42 %46 0 1 %204 = OpVectorShuffle %43 %42 %46 2 3 4 %205 = OpVectorShuffle %47 %42 %42 0 1 2 3 %206 = OpVectorShuffle %62 %65 %65 0xFFFFFFFF 3 6 0xFFFFFFFF OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationVectorShuffleTest, IllegalInsertionPoints) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %51 %27 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %25 "buf" OpMemberName %25 0 "value" OpName %27 "" OpName %51 "color" OpMemberDecorate %25 0 Offset 0 OpDecorate %25 Block OpDecorate %27 DescriptorSet 0 OpDecorate %27 Binding 0 OpDecorate %51 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %150 = OpTypeVector %6 2 %10 = OpConstant %6 0.300000012 %11 = OpConstant %6 0.400000006 %12 = OpConstant %6 0.5 %13 = OpConstant %6 1 %14 = OpConstantComposite %7 %10 %11 %12 %13 %15 = OpTypeInt 32 1 %18 = OpConstant %15 0 %25 = OpTypeStruct %6 %26 = OpTypePointer Uniform %25 %27 = OpVariable %26 Uniform %28 = OpTypePointer Uniform %6 %32 = OpTypeBool %103 = OpConstantTrue %32 %34 = OpConstant %6 0.100000001 %48 = OpConstant %15 1 %50 = OpTypePointer Output %7 %51 = OpVariable %50 Output %100 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %5 = OpLabel %101 = OpVariable %100 Function %102 = OpVariable %100 Function OpBranch %19 %19 = OpLabel %60 = OpPhi %7 %14 %5 %58 %20 %59 = OpPhi %15 %18 %5 %49 %20 %29 = OpAccessChain %28 %27 %18 %30 = OpLoad %6 %29 %31 = OpConvertFToS %15 %30 %33 = OpSLessThan %32 %59 %31 OpLoopMerge %21 %20 None OpBranchConditional %33 %20 %21 %20 = OpLabel %39 = OpCompositeExtract %6 %60 0 %40 = OpFAdd %6 %39 %34 %55 = OpCompositeInsert %7 %40 %60 0 %44 = OpCompositeExtract %6 %60 1 %45 = OpFSub %6 %44 %34 %58 = OpCompositeInsert %7 %45 %55 1 %49 = OpIAdd %15 %59 %48 OpBranch %19 %21 = OpLabel OpStore %51 %60 OpSelectionMerge %105 None OpBranchConditional %103 %104 %105 %104 = OpLabel OpBranch %105 %105 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Cannot insert before the OpVariables of a function. ASSERT_FALSE(TransformationVectorShuffle( MakeInstructionDescriptor(101, spv::Op::OpVariable, 0), 200, 14, 14, {0, 1}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationVectorShuffle( MakeInstructionDescriptor(101, spv::Op::OpVariable, 1), 200, 14, 14, {1, 2}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationVectorShuffle( MakeInstructionDescriptor(102, spv::Op::OpVariable, 0), 200, 14, 14, {1, 2}) .IsApplicable(context.get(), transformation_context)); // OK to insert right after the OpVariables. ASSERT_FALSE(TransformationVectorShuffle( MakeInstructionDescriptor(102, spv::Op::OpBranch, 1), 200, 14, 14, {1, 1}) .IsApplicable(context.get(), transformation_context)); // Cannot insert before the OpPhis of a block. ASSERT_FALSE( TransformationVectorShuffle( MakeInstructionDescriptor(60, spv::Op::OpPhi, 0), 200, 14, 14, {2, 0}) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE( TransformationVectorShuffle( MakeInstructionDescriptor(59, spv::Op::OpPhi, 0), 200, 14, 14, {3, 0}) .IsApplicable(context.get(), transformation_context)); // OK to insert after the OpPhis. ASSERT_TRUE(TransformationVectorShuffle( MakeInstructionDescriptor(59, spv::Op::OpAccessChain, 0), 200, 14, 14, {3, 4}) .IsApplicable(context.get(), transformation_context)); // Cannot insert before OpLoopMerge ASSERT_FALSE( TransformationVectorShuffle( MakeInstructionDescriptor(33, spv::Op::OpBranchConditional, 0), 200, 14, 14, {3}) .IsApplicable(context.get(), transformation_context)); // Cannot insert before OpSelectionMerge ASSERT_FALSE( TransformationVectorShuffle( MakeInstructionDescriptor(21, spv::Op::OpBranchConditional, 0), 200, 14, 14, {2}) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationVectorShuffleTest, HandlesIrrelevantIds1) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpTypeVector %6 2 %10 = OpConstantTrue %6 %11 = OpConstantFalse %6 %12 = OpConstantComposite %7 %10 %11 %112 = OpConstantComposite %7 %11 %10 %13 = OpTypeVector %6 3 %16 = OpConstantComposite %13 %10 %11 %10 %17 = OpTypeVector %6 4 %20 = OpConstantComposite %17 %10 %11 %10 %11 %21 = OpTypeInt 32 1 %22 = OpTypeVector %21 2 %25 = OpConstant %21 1 %26 = OpConstant %21 0 %27 = OpConstantComposite %22 %25 %26 %28 = OpTypeVector %21 3 %31 = OpConstantComposite %28 %25 %26 %25 %32 = OpTypeVector %21 4 %33 = OpTypePointer Function %32 %35 = OpConstantComposite %32 %25 %26 %25 %26 %36 = OpTypeInt 32 0 %37 = OpTypeVector %36 2 %40 = OpConstant %36 1 %41 = OpConstant %36 0 %42 = OpConstantComposite %37 %40 %41 %43 = OpTypeVector %36 3 %46 = OpConstantComposite %43 %40 %41 %40 %47 = OpTypeVector %36 4 %50 = OpConstantComposite %47 %40 %41 %40 %41 %51 = OpTypeFloat 32 %55 = OpConstant %51 1 %56 = OpConstant %51 0 %58 = OpTypeVector %51 3 %61 = OpConstantComposite %58 %55 %56 %55 %62 = OpTypeVector %51 4 %65 = OpConstantComposite %62 %55 %56 %55 %56 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %100 None OpBranchConditional %10 %101 %102 %101 = OpLabel %103 = OpCompositeConstruct %62 %55 %55 %55 %56 OpBranch %100 %102 = OpLabel OpBranch %100 %100 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); TransformationVectorShuffle transformation( MakeInstructionDescriptor(100, spv::Op::OpReturn, 0), 200, 12, 112, {2, 0}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(12, {0}), MakeDataDescriptor(200, {1}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(112, {0}), MakeDataDescriptor(200, {0}))); } TEST(TransformationVectorShuffleTest, HandlesIrrelevantIds2) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpTypeVector %6 2 %10 = OpConstantTrue %6 %11 = OpConstantFalse %6 %12 = OpConstantComposite %7 %10 %11 %112 = OpConstantComposite %7 %11 %10 %13 = OpTypeVector %6 3 %16 = OpConstantComposite %13 %10 %11 %10 %17 = OpTypeVector %6 4 %20 = OpConstantComposite %17 %10 %11 %10 %11 %21 = OpTypeInt 32 1 %22 = OpTypeVector %21 2 %25 = OpConstant %21 1 %26 = OpConstant %21 0 %27 = OpConstantComposite %22 %25 %26 %28 = OpTypeVector %21 3 %31 = OpConstantComposite %28 %25 %26 %25 %32 = OpTypeVector %21 4 %33 = OpTypePointer Function %32 %35 = OpConstantComposite %32 %25 %26 %25 %26 %36 = OpTypeInt 32 0 %37 = OpTypeVector %36 2 %40 = OpConstant %36 1 %41 = OpConstant %36 0 %42 = OpConstantComposite %37 %40 %41 %43 = OpTypeVector %36 3 %46 = OpConstantComposite %43 %40 %41 %40 %47 = OpTypeVector %36 4 %50 = OpConstantComposite %47 %40 %41 %40 %41 %51 = OpTypeFloat 32 %55 = OpConstant %51 1 %56 = OpConstant %51 0 %58 = OpTypeVector %51 3 %61 = OpConstantComposite %58 %55 %56 %55 %62 = OpTypeVector %51 4 %65 = OpConstantComposite %62 %55 %56 %55 %56 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %100 None OpBranchConditional %10 %101 %102 %101 = OpLabel %103 = OpCompositeConstruct %62 %55 %55 %55 %56 OpBranch %100 %102 = OpLabel OpBranch %100 %100 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactIdIsIrrelevant(112); TransformationVectorShuffle transformation( MakeInstructionDescriptor(100, spv::Op::OpReturn, 0), 200, 12, 112, {2, 0}); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); // Because %12 is not irrelevant, we get a synonym between it and %200[1]. ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(12, {0}), MakeDataDescriptor(200, {1}))); // Because %112 is irrelevant, we do not get a synonym between it and %200[0]. ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(112, {0}), MakeDataDescriptor(200, {0}))); } TEST(TransformationVectorShuffleTest, HandlesIrrelevantIds3) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeVector %6 2 %8 = OpTypePointer Function %7 %10 = OpConstant %6 0 %11 = OpConstant %6 1 %12 = OpConstantComposite %7 %10 %11 %40 = OpConstantComposite %7 %10 %11 %13 = OpTypeBool %14 = OpConstantFalse %13 %4 = OpFunction %2 None %3 %5 = OpLabel %9 = OpVariable %8 Function OpStore %9 %12 OpSelectionMerge %16 None OpBranchConditional %14 %15 %16 %15 = OpLabel OpBranch %16 %16 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactIdIsIrrelevant(40); transformation_context.GetFactManager()->AddFactBlockIsDead(15); TransformationVectorShuffle transformation1( MakeInstructionDescriptor(15, spv::Op::OpBranch, 0), 200, 12, 12, {0, 3}); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(200, {0}), MakeDataDescriptor(12, {0}))); ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(200, {1}), MakeDataDescriptor(12, {1}))); TransformationVectorShuffle transformation2( MakeInstructionDescriptor(16, spv::Op::OpReturn, 0), 201, 12, 40, {0, 1}); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(201, {0}), MakeDataDescriptor(12, {0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(201, {1}), MakeDataDescriptor(12, {1}))); TransformationVectorShuffle transformation3( MakeInstructionDescriptor(16, spv::Op::OpReturn, 0), 202, 40, 12, {2, 3}); ASSERT_TRUE( transformation3.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation3, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(202, {0}), MakeDataDescriptor(12, {0}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(202, {1}), MakeDataDescriptor(12, {1}))); TransformationVectorShuffle transformation4( MakeInstructionDescriptor(16, spv::Op::OpReturn, 0), 203, 40, 12, {0, 3}); ASSERT_TRUE( transformation4.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation4, context.get(), &transformation_context); // Because %40 is irrelevant we do not get a synonym between it and %203[0]. ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(203, {0}), MakeDataDescriptor(40, {0}))); // Because %12 is *not* irrelevant we do get a synonym between it and %203[1]. ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(203, {1}), MakeDataDescriptor(12, {1}))); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_wrap_early_terminator_in_function_test.cpp000066400000000000000000000256301475742701700344110ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_wrap_early_terminator_in_function.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationWrapEarlyTerminatorInFunctionTest, IsApplicable) { std::string shader = R"( OpCapability Shader OpExtension "SPV_KHR_terminate_invocation" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpConstant %6 0 %90 = OpTypeBool %91 = OpConstantFalse %90 %20 = OpTypeFunction %2 %6 %21 = OpTypeFunction %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %11 None OpSwitch %7 %11 0 %8 1 %9 2 %10 %8 = OpLabel OpKill %9 = OpLabel OpUnreachable %10 = OpLabel OpTerminateInvocation %11 = OpLabel OpReturn OpFunctionEnd %30 = OpFunction %2 None %3 %31 = OpLabel OpKill OpFunctionEnd %50 = OpFunction %2 None %3 %51 = OpLabel OpTerminateInvocation OpFunctionEnd %60 = OpFunction %6 None %21 %61 = OpLabel OpBranch %62 %62 = OpLabel OpKill OpFunctionEnd %70 = OpFunction %6 None %21 %71 = OpLabel OpUnreachable OpFunctionEnd %80 = OpFunction %2 None %20 %81 = OpFunctionParameter %6 %82 = OpLabel OpTerminateInvocation OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Bad: id is not fresh ASSERT_FALSE(TransformationWrapEarlyTerminatorInFunction( 61, MakeInstructionDescriptor(8, spv::Op::OpKill, 0), 0) .IsApplicable(context.get(), transformation_context)); // Bad: early terminator instruction descriptor does not exist ASSERT_FALSE(TransformationWrapEarlyTerminatorInFunction( 100, MakeInstructionDescriptor(82, spv::Op::OpKill, 0), 0) .IsApplicable(context.get(), transformation_context)); // Bad: early terminator instruction does not identify an early terminator ASSERT_FALSE( TransformationWrapEarlyTerminatorInFunction( 100, MakeInstructionDescriptor(5, spv::Op::OpSelectionMerge, 0), 0) .IsApplicable(context.get(), transformation_context)); // Bad: no wrapper function is available ASSERT_FALSE( TransformationWrapEarlyTerminatorInFunction( 100, MakeInstructionDescriptor(9, spv::Op::OpUnreachable, 0), 0) .IsApplicable(context.get(), transformation_context)); // Bad: returned value does not exist ASSERT_FALSE(TransformationWrapEarlyTerminatorInFunction( 100, MakeInstructionDescriptor(62, spv::Op::OpKill, 0), 1000) .IsApplicable(context.get(), transformation_context)); // Bad: returned value does not have a type ASSERT_FALSE(TransformationWrapEarlyTerminatorInFunction( 100, MakeInstructionDescriptor(62, spv::Op::OpKill, 0), 61) .IsApplicable(context.get(), transformation_context)); // Bad: returned value type does not match ASSERT_FALSE(TransformationWrapEarlyTerminatorInFunction( 100, MakeInstructionDescriptor(62, spv::Op::OpKill, 0), 91) .IsApplicable(context.get(), transformation_context)); // Bad: returned value is not available ASSERT_FALSE(TransformationWrapEarlyTerminatorInFunction( 100, MakeInstructionDescriptor(62, spv::Op::OpKill, 0), 81) .IsApplicable(context.get(), transformation_context)); // Bad: the OpKill being targeted is in the only available wrapper; we cannot // have the wrapper call itself. ASSERT_FALSE(TransformationWrapEarlyTerminatorInFunction( 100, MakeInstructionDescriptor(31, spv::Op::OpKill, 0), 0) .IsApplicable(context.get(), transformation_context)); } TEST(TransformationWrapEarlyTerminatorInFunctionTest, Apply) { std::string shader = R"( OpCapability Shader OpExtension "SPV_KHR_terminate_invocation" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpConstant %6 0 %20 = OpTypeFunction %2 %6 %21 = OpTypeFunction %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %11 None OpSwitch %7 %11 0 %8 1 %9 2 %10 %8 = OpLabel OpKill %9 = OpLabel OpUnreachable %10 = OpLabel OpTerminateInvocation %11 = OpLabel OpReturn OpFunctionEnd %30 = OpFunction %2 None %3 %31 = OpLabel OpKill OpFunctionEnd %40 = OpFunction %2 None %3 %41 = OpLabel OpUnreachable OpFunctionEnd %50 = OpFunction %2 None %3 %51 = OpLabel OpTerminateInvocation OpFunctionEnd %60 = OpFunction %2 None %3 %61 = OpLabel OpBranch %62 %62 = OpLabel OpKill OpFunctionEnd %70 = OpFunction %6 None %21 %71 = OpLabel OpUnreachable OpFunctionEnd %80 = OpFunction %2 None %20 %81 = OpFunctionParameter %6 %82 = OpLabel OpTerminateInvocation OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_4; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); for (auto& transformation : {TransformationWrapEarlyTerminatorInFunction( 100, MakeInstructionDescriptor(8, spv::Op::OpKill, 0), 0), TransformationWrapEarlyTerminatorInFunction( 101, MakeInstructionDescriptor(9, spv::Op::OpUnreachable, 0), 0), TransformationWrapEarlyTerminatorInFunction( 102, MakeInstructionDescriptor(10, spv::Op::OpTerminateInvocation, 0), 0), TransformationWrapEarlyTerminatorInFunction( 103, MakeInstructionDescriptor(62, spv::Op::OpKill, 0), 0), TransformationWrapEarlyTerminatorInFunction( 104, MakeInstructionDescriptor(71, spv::Op::OpUnreachable, 0), 7), TransformationWrapEarlyTerminatorInFunction( 105, MakeInstructionDescriptor(82, spv::Op::OpTerminateInvocation, 0), 0)}) { ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); } ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader OpExtension "SPV_KHR_terminate_invocation" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpConstant %6 0 %20 = OpTypeFunction %2 %6 %21 = OpTypeFunction %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %11 None OpSwitch %7 %11 0 %8 1 %9 2 %10 %8 = OpLabel %100 = OpFunctionCall %2 %30 OpReturn %9 = OpLabel %101 = OpFunctionCall %2 %40 OpReturn %10 = OpLabel %102 = OpFunctionCall %2 %50 OpReturn %11 = OpLabel OpReturn OpFunctionEnd %30 = OpFunction %2 None %3 %31 = OpLabel OpKill OpFunctionEnd %40 = OpFunction %2 None %3 %41 = OpLabel OpUnreachable OpFunctionEnd %50 = OpFunction %2 None %3 %51 = OpLabel OpTerminateInvocation OpFunctionEnd %60 = OpFunction %2 None %3 %61 = OpLabel OpBranch %62 %62 = OpLabel %103 = OpFunctionCall %2 %30 OpReturn OpFunctionEnd %70 = OpFunction %6 None %21 %71 = OpLabel %104 = OpFunctionCall %2 %40 OpReturnValue %7 OpFunctionEnd %80 = OpFunction %2 None %20 %81 = OpFunctionParameter %6 %82 = OpLabel %105 = OpFunctionCall %2 %50 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_wrap_region_in_selection_test.cpp000066400000000000000000000222701475742701700324510ustar00rootroot00000000000000// Copyright (c) 2020 Vasyl Teliman // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_wrap_region_in_selection.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationWrapRegionInSelectionTest, BasicTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %7 = OpTypeBool %8 = OpConstantTrue %7 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %6 %6 = OpLabel OpSelectionMerge %12 None OpBranchConditional %8 %11 %12 %11 = OpLabel OpReturn %12 = OpLabel OpSelectionMerge %15 None OpBranchConditional %8 %13 %14 %13 = OpLabel OpBranch %15 %14 = OpLabel OpBranch %15 %15 = OpLabel OpBranch %16 %16 = OpLabel OpReturn OpFunctionEnd %9 = OpFunction %2 None %3 %10 = OpLabel OpBranch %20 %20 = OpLabel OpLoopMerge %23 %22 None OpBranch %21 %21 = OpLabel OpBranchConditional %8 %24 %23 %24 = OpLabel OpBranch %22 ; continue target %22 = OpLabel OpLoopMerge %25 %28 None OpBranchConditional %8 %27 %25 %27 = OpLabel OpBranch %28 %28 = OpLabel OpBranch %22 %25 = OpLabel OpBranch %20 ; merge block %23 = OpLabel OpBranch %26 %26 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Boolean constant does not exist. ASSERT_FALSE(TransformationWrapRegionInSelection(5, 6, false) .IsApplicable(context.get(), transformation_context)); // Irrelevant constant does not exist. ASSERT_FALSE(TransformationWrapRegionInSelection(5, 6, true) .IsApplicable(context.get(), transformation_context)); transformation_context.GetFactManager()->AddFactIdIsIrrelevant(8); // Block ids are invalid. ASSERT_FALSE(TransformationWrapRegionInSelection(100, 6, true) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationWrapRegionInSelection(5, 100, true) .IsApplicable(context.get(), transformation_context)); // Blocks are from different functions. ASSERT_FALSE(TransformationWrapRegionInSelection(5, 10, true) .IsApplicable(context.get(), transformation_context)); // Header block candidate does not dominate merge block candidate. ASSERT_FALSE(TransformationWrapRegionInSelection(13, 16, true) .IsApplicable(context.get(), transformation_context)); // Header block candidate does not *strictly* dominate merge block candidate. ASSERT_FALSE(TransformationWrapRegionInSelection(5, 5, true) .IsApplicable(context.get(), transformation_context)); // Merge block candidate does not postdominate header block candidate. ASSERT_FALSE(TransformationWrapRegionInSelection(5, 16, true) .IsApplicable(context.get(), transformation_context)); // Header block candidate is already a header block of some other construct. ASSERT_FALSE(TransformationWrapRegionInSelection(12, 16, true) .IsApplicable(context.get(), transformation_context)); // Header block's terminator is not an OpBranch. ASSERT_FALSE(TransformationWrapRegionInSelection(21, 24, true) .IsApplicable(context.get(), transformation_context)); // Merge block candidate is already a merge block of some other construct. ASSERT_FALSE(TransformationWrapRegionInSelection(5, 15, true) .IsApplicable(context.get(), transformation_context)); // Header block candidate and merge block candidate are in different // constructs. ASSERT_FALSE(TransformationWrapRegionInSelection(10, 21, true) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationWrapRegionInSelection(24, 25, true) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationWrapRegionInSelection(24, 22, true) .IsApplicable(context.get(), transformation_context)); ASSERT_FALSE(TransformationWrapRegionInSelection(24, 27, true) .IsApplicable(context.get(), transformation_context)); { // Header block candidate can be a merge block of some existing construct. TransformationWrapRegionInSelection transformation(15, 16, true); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } { // Merge block candidate can be a header block of some existing construct. TransformationWrapRegionInSelection transformation(5, 6, true); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } { // Wrap a loop construct. TransformationWrapRegionInSelection transformation(10, 26, true); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( context.get(), validator_options, kConsoleMessageConsumer)); } std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %7 = OpTypeBool %8 = OpConstantTrue %7 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %6 None OpBranchConditional %8 %6 %6 %6 = OpLabel OpSelectionMerge %12 None OpBranchConditional %8 %11 %12 %11 = OpLabel OpReturn %12 = OpLabel OpSelectionMerge %15 None OpBranchConditional %8 %13 %14 %13 = OpLabel OpBranch %15 %14 = OpLabel OpBranch %15 %15 = OpLabel OpSelectionMerge %16 None OpBranchConditional %8 %16 %16 %16 = OpLabel OpReturn OpFunctionEnd %9 = OpFunction %2 None %3 %10 = OpLabel OpSelectionMerge %26 None OpBranchConditional %8 %20 %20 %20 = OpLabel OpLoopMerge %23 %22 None OpBranch %21 %21 = OpLabel OpBranchConditional %8 %24 %23 %24 = OpLabel OpBranch %22 ; continue target %22 = OpLabel OpLoopMerge %25 %28 None OpBranchConditional %8 %27 %25 %27 = OpLabel OpBranch %28 %28 = OpLabel OpBranch %22 %25 = OpLabel OpBranch %20 ; merge block %23 = OpLabel OpBranch %26 %26 = OpLabel OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/transformation_wrap_vector_synonym_test.cpp000066400000000000000000001632361475742701700315410ustar00rootroot00000000000000// Copyright (c) 2021 Shiyu Liu // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/transformation_wrap_vector_synonym.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/instruction_descriptor.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(TransformationWrapVectorSynonym, BasicTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %97 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 10 %11 = OpConstant %6 -5 %12 = OpTypeVector %6 2 %13 = OpTypePointer Function %12 %18 = OpTypeInt 32 0 %19 = OpTypePointer Function %18 %21 = OpConstant %18 8 %23 = OpConstant %18 2 %24 = OpTypeVector %18 3 %25 = OpTypePointer Function %24 %31 = OpTypeFloat 32 %32 = OpTypePointer Function %31 %34 = OpConstant %31 3.29999995 %36 = OpConstant %31 1.10000002 %37 = OpTypeVector %31 4 %38 = OpTypePointer Function %37 %96 = OpTypePointer Input %31 %97 = OpVariable %96 Input %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %14 = OpVariable %13 Function %20 = OpVariable %19 Function %22 = OpVariable %19 Function %26 = OpVariable %25 Function %33 = OpVariable %32 Function %35 = OpVariable %32 Function %39 = OpVariable %38 Function %47 = OpVariable %7 Function %51 = OpVariable %7 Function %55 = OpVariable %7 Function %59 = OpVariable %7 Function %63 = OpVariable %19 Function %67 = OpVariable %19 Function %71 = OpVariable %19 Function %75 = OpVariable %19 Function %79 = OpVariable %32 Function %83 = OpVariable %32 Function %87 = OpVariable %32 Function %91 = OpVariable %32 Function OpStore %8 %9 OpStore %10 %11 %15 = OpLoad %6 %8 %16 = OpLoad %6 %10 %17 = OpCompositeConstruct %12 %15 %16 OpStore %14 %17 OpStore %20 %21 OpStore %22 %23 %27 = OpLoad %18 %20 %28 = OpLoad %18 %20 %29 = OpLoad %18 %22 %30 = OpCompositeConstruct %24 %27 %28 %29 OpStore %26 %30 OpStore %33 %34 OpStore %35 %36 %40 = OpLoad %31 %33 %41 = OpLoad %31 %33 %42 = OpLoad %31 %35 %43 = OpLoad %31 %35 %44 = OpCompositeConstruct %37 %40 %41 %42 %43 %45 = OpLoad %37 %39 %46 = OpVectorShuffle %37 %45 %44 5 6 7 4 OpStore %39 %46 %48 = OpLoad %6 %8 %49 = OpLoad %6 %10 %100 = OpCompositeConstruct %12 %48 %48 %101 = OpCompositeConstruct %12 %49 %49 %50 = OpIAdd %6 %48 %49 OpStore %47 %50 %52 = OpLoad %6 %8 %53 = OpLoad %6 %10 %54 = OpISub %6 %52 %53 OpStore %51 %54 %56 = OpLoad %6 %8 %57 = OpLoad %6 %10 %58 = OpIMul %6 %56 %57 OpStore %55 %58 %60 = OpLoad %6 %8 %61 = OpLoad %6 %10 %62 = OpSDiv %6 %60 %61 OpStore %59 %62 %64 = OpLoad %18 %20 %65 = OpLoad %18 %22 %66 = OpIAdd %18 %64 %65 OpStore %63 %66 %68 = OpLoad %18 %20 %69 = OpLoad %18 %22 %70 = OpISub %18 %68 %69 OpStore %67 %70 %72 = OpLoad %18 %20 %73 = OpLoad %18 %22 %74 = OpIMul %18 %72 %73 OpStore %71 %74 %76 = OpLoad %18 %20 %77 = OpLoad %18 %22 %78 = OpUDiv %18 %76 %77 OpStore %75 %78 %80 = OpLoad %31 %33 %81 = OpLoad %31 %35 %82 = OpFAdd %31 %80 %81 OpStore %79 %82 %84 = OpLoad %31 %33 %85 = OpLoad %31 %35 %86 = OpFSub %31 %84 %85 OpStore %83 %86 %88 = OpLoad %31 %33 %89 = OpLoad %31 %35 %90 = OpFMul %31 %88 %89 OpStore %87 %90 %92 = OpLoad %31 %33 %93 = OpLoad %31 %35 %94 = OpFDiv %31 %92 %93 OpStore %91 %94 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; // Check context validity. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Vec Type Id | Vector Type | Element Type id | Element Type | // ------------+----------------+------------------+-----------------+ // 12 | vec2 | 6 | int32 | // 24 | vec3 | 18 | uint32 | // 37 | vec4 | 31 | float | // Instruction Id | Opcode | Type Id | constant id 1 | constant id 2 | // ---------------+---------+---------+---------------+---------------+ // 50 | OpIAdd | 6 | 48 | 49 | // 54 | OpISub | 6 | 52 | 53 | // 58 | OpIMul | 6 | 56 | 57 | // 62 | OpSDiv | 6 | 60 | 61 | // 66 | OpIAdd | 18 | 64 | 65 | // 70 | OpISub | 18 | 68 | 69 | // 74 | OpIMul | 18 | 72 | 73 | // 78 | OpUDiv | 18 | 76 | 77 | // 82 | OpFAdd | 31 | 80 | 81 | // 86 | OpFSub | 31 | 84 | 85 | // 90 | OpFMul | 31 | 88 | 89 | // 94 | OpFDiv | 31 | 92 | 93 | // Assert that the target scalar instruction result id is relevant. ASSERT_FALSE(transformation_context.GetFactManager()->IdIsIrrelevant(50)); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(100, {1}), MakeDataDescriptor(48, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(101, {1}), MakeDataDescriptor(49, {})); // The following are all invalid use. { // Bad: Instruction id does not exist. TransformationWrapVectorSynonym wrap_add_int_bad1(103, 100, 101, 102, 1); ASSERT_FALSE( wrap_add_int_bad1.IsApplicable(context.get(), transformation_context)); // Bad: Instruction id given is not of a valid arithmetic operation typed // instruction. TransformationWrapVectorSynonym wrap_add_int_bad2(80, 100, 101, 102, 1); ASSERT_FALSE( wrap_add_int_bad1.IsApplicable(context.get(), transformation_context)); // Bad: the id for the first vector does not exist. TransformationWrapVectorSynonym wrap_add_int_bad3(50, 105, 101, 102, 1); ASSERT_FALSE( wrap_add_int_bad3.IsApplicable(context.get(), transformation_context)); // Bad: the id for the second vector does not exist. TransformationWrapVectorSynonym wrap_add_int_bad4(50, 100, 105, 102, 1); ASSERT_FALSE( wrap_add_int_bad4.IsApplicable(context.get(), transformation_context)); // Bad: vector id is not fresh. TransformationWrapVectorSynonym wrap_add_int_bad6(50, 100, 101, 94, 1); ASSERT_FALSE( wrap_add_int_bad6.IsApplicable(context.get(), transformation_context)); // Bad: The position goes out of bound for the given vector type. TransformationWrapVectorSynonym wrap_add_int_bad8(50, 100, 101, 102, 2); ASSERT_FALSE( wrap_add_int_bad8.IsApplicable(context.get(), transformation_context)); // Bad: The original instruction is not a valid scalar operation // instruction. TransformationWrapVectorSynonym wrap_add_int(27, 100, 101, 102, 1); ASSERT_FALSE( wrap_add_int.IsApplicable(context.get(), transformation_context)); } // Good: The following transformation should be applicable. TransformationWrapVectorSynonym wrap_add_int(50, 100, 101, 102, 1); ASSERT_TRUE(wrap_add_int.IsApplicable(context.get(), transformation_context)); // Insert an arithmetic instruction of the same type to add two vectors. ApplyAndCheckFreshIds(wrap_add_int, context.get(), &transformation_context); // |instruction_id| and id at |scalar_position of the result vector should be // synonyms. ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(102, {1}), MakeDataDescriptor(50, {}))); // After applying transformations, the instruction: // // %102 = OpIAdd %12 %100 %101 // // should be added before: // // %50 = OpIAdd %6 %48 %49 std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %97 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 10 %11 = OpConstant %6 -5 %12 = OpTypeVector %6 2 %13 = OpTypePointer Function %12 %18 = OpTypeInt 32 0 %19 = OpTypePointer Function %18 %21 = OpConstant %18 8 %23 = OpConstant %18 2 %24 = OpTypeVector %18 3 %25 = OpTypePointer Function %24 %31 = OpTypeFloat 32 %32 = OpTypePointer Function %31 %34 = OpConstant %31 3.29999995 %36 = OpConstant %31 1.10000002 %37 = OpTypeVector %31 4 %38 = OpTypePointer Function %37 %96 = OpTypePointer Input %31 %97 = OpVariable %96 Input %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %14 = OpVariable %13 Function %20 = OpVariable %19 Function %22 = OpVariable %19 Function %26 = OpVariable %25 Function %33 = OpVariable %32 Function %35 = OpVariable %32 Function %39 = OpVariable %38 Function %47 = OpVariable %7 Function %51 = OpVariable %7 Function %55 = OpVariable %7 Function %59 = OpVariable %7 Function %63 = OpVariable %19 Function %67 = OpVariable %19 Function %71 = OpVariable %19 Function %75 = OpVariable %19 Function %79 = OpVariable %32 Function %83 = OpVariable %32 Function %87 = OpVariable %32 Function %91 = OpVariable %32 Function OpStore %8 %9 OpStore %10 %11 %15 = OpLoad %6 %8 %16 = OpLoad %6 %10 %17 = OpCompositeConstruct %12 %15 %16 OpStore %14 %17 OpStore %20 %21 OpStore %22 %23 %27 = OpLoad %18 %20 %28 = OpLoad %18 %20 %29 = OpLoad %18 %22 %30 = OpCompositeConstruct %24 %27 %28 %29 OpStore %26 %30 OpStore %33 %34 OpStore %35 %36 %40 = OpLoad %31 %33 %41 = OpLoad %31 %33 %42 = OpLoad %31 %35 %43 = OpLoad %31 %35 %44 = OpCompositeConstruct %37 %40 %41 %42 %43 %45 = OpLoad %37 %39 %46 = OpVectorShuffle %37 %45 %44 5 6 7 4 OpStore %39 %46 %48 = OpLoad %6 %8 %49 = OpLoad %6 %10 %100 = OpCompositeConstruct %12 %48 %48 %101 = OpCompositeConstruct %12 %49 %49 %102 = OpIAdd %12 %100 %101 %50 = OpIAdd %6 %48 %49 OpStore %47 %50 %52 = OpLoad %6 %8 %53 = OpLoad %6 %10 %54 = OpISub %6 %52 %53 OpStore %51 %54 %56 = OpLoad %6 %8 %57 = OpLoad %6 %10 %58 = OpIMul %6 %56 %57 OpStore %55 %58 %60 = OpLoad %6 %8 %61 = OpLoad %6 %10 %62 = OpSDiv %6 %60 %61 OpStore %59 %62 %64 = OpLoad %18 %20 %65 = OpLoad %18 %22 %66 = OpIAdd %18 %64 %65 OpStore %63 %66 %68 = OpLoad %18 %20 %69 = OpLoad %18 %22 %70 = OpISub %18 %68 %69 OpStore %67 %70 %72 = OpLoad %18 %20 %73 = OpLoad %18 %22 %74 = OpIMul %18 %72 %73 OpStore %71 %74 %76 = OpLoad %18 %20 %77 = OpLoad %18 %22 %78 = OpUDiv %18 %76 %77 OpStore %75 %78 %80 = OpLoad %31 %33 %81 = OpLoad %31 %35 %82 = OpFAdd %31 %80 %81 OpStore %79 %82 %84 = OpLoad %31 %33 %85 = OpLoad %31 %35 %86 = OpFSub %31 %84 %85 OpStore %83 %86 %88 = OpLoad %31 %33 %89 = OpLoad %31 %35 %90 = OpFMul %31 %88 %89 OpStore %87 %90 %92 = OpLoad %31 %33 %93 = OpLoad %31 %35 %94 = OpFDiv %31 %92 %93 OpStore %91 %94 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationWrapVectorSynonym, OperationSupportTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %97 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 10 %11 = OpConstant %6 -5 %12 = OpTypeVector %6 2 %13 = OpTypePointer Function %12 %18 = OpTypeInt 32 0 %19 = OpTypePointer Function %18 %21 = OpConstant %18 8 %23 = OpConstant %18 2 %24 = OpTypeVector %18 3 %25 = OpTypePointer Function %24 %31 = OpTypeFloat 32 %32 = OpTypePointer Function %31 %34 = OpConstant %31 3.29999995 %36 = OpConstant %31 1.10000002 %37 = OpTypeVector %31 4 %38 = OpTypePointer Function %37 %96 = OpTypePointer Input %31 %97 = OpVariable %96 Input %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %14 = OpVariable %13 Function %20 = OpVariable %19 Function %22 = OpVariable %19 Function %26 = OpVariable %25 Function %33 = OpVariable %32 Function %35 = OpVariable %32 Function %39 = OpVariable %38 Function %47 = OpVariable %7 Function %51 = OpVariable %7 Function %55 = OpVariable %7 Function %59 = OpVariable %7 Function %63 = OpVariable %19 Function %67 = OpVariable %19 Function %71 = OpVariable %19 Function %75 = OpVariable %19 Function %79 = OpVariable %32 Function %83 = OpVariable %32 Function %87 = OpVariable %32 Function %91 = OpVariable %32 Function OpStore %8 %9 OpStore %10 %11 %15 = OpLoad %6 %8 %16 = OpLoad %6 %10 %17 = OpCompositeConstruct %12 %15 %16 OpStore %14 %17 OpStore %20 %21 OpStore %22 %23 %27 = OpLoad %18 %20 %28 = OpLoad %18 %20 %29 = OpLoad %18 %22 %30 = OpCompositeConstruct %24 %27 %28 %29 OpStore %26 %30 OpStore %33 %34 OpStore %35 %36 %40 = OpLoad %31 %33 %41 = OpLoad %31 %33 %42 = OpLoad %31 %35 %43 = OpLoad %31 %35 %44 = OpCompositeConstruct %37 %40 %41 %42 %43 %45 = OpLoad %37 %39 %46 = OpVectorShuffle %37 %45 %44 5 6 7 4 OpStore %39 %46 %48 = OpLoad %6 %8 %49 = OpLoad %6 %10 %50 = OpIAdd %6 %48 %49 OpStore %47 %50 %52 = OpLoad %6 %8 %53 = OpLoad %6 %10 %100 = OpCompositeConstruct %12 %52 %52 %101 = OpCompositeConstruct %12 %53 %53 %54 = OpISub %6 %52 %53 OpStore %51 %54 %56 = OpLoad %6 %8 %57 = OpLoad %6 %10 %103 = OpCompositeConstruct %12 %56 %56 %104 = OpCompositeConstruct %12 %57 %57 %58 = OpIMul %6 %56 %57 OpStore %55 %58 %60 = OpLoad %6 %8 %61 = OpLoad %6 %10 %62 = OpSDiv %6 %60 %61 OpStore %59 %62 %64 = OpLoad %18 %20 %65 = OpLoad %18 %22 %106 = OpCompositeConstruct %24 %64 %64 %64 %107 = OpCompositeConstruct %24 %65 %65 %65 %66 = OpIAdd %18 %64 %65 OpStore %63 %66 %68 = OpLoad %18 %20 %69 = OpLoad %18 %22 %109 = OpCompositeConstruct %24 %68 %68 %68 %110 = OpCompositeConstruct %24 %69 %69 %69 %70 = OpISub %18 %68 %69 OpStore %67 %70 %72 = OpLoad %18 %20 %73 = OpLoad %18 %22 %112 = OpCompositeConstruct %24 %72 %72 %72 %113 = OpCompositeConstruct %24 %73 %73 %73 %74 = OpIMul %18 %72 %73 OpStore %71 %74 %76 = OpLoad %18 %20 %77 = OpLoad %18 %22 %78 = OpUDiv %18 %76 %77 OpStore %75 %78 %80 = OpLoad %31 %33 %81 = OpLoad %31 %35 %115 = OpCompositeConstruct %37 %80 %80 %80 %80 %116 = OpCompositeConstruct %37 %81 %81 %81 %81 %82 = OpFAdd %31 %80 %81 OpStore %79 %82 %84 = OpLoad %31 %33 %85 = OpLoad %31 %35 %118 = OpCompositeConstruct %37 %84 %84 %84 %84 %119 = OpCompositeConstruct %37 %85 %85 %85 %85 %86 = OpFSub %31 %84 %85 OpStore %83 %86 %88 = OpLoad %31 %33 %89 = OpLoad %31 %35 %121 = OpCompositeConstruct %37 %88 %88 %88 %88 %122 = OpCompositeConstruct %37 %89 %89 %89 %89 %90 = OpFMul %31 %88 %89 OpStore %87 %90 %92 = OpLoad %31 %33 %93 = OpLoad %31 %35 %94 = OpFDiv %31 %92 %93 OpStore %91 %94 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); { // Add synonym facts between the vector operands at pos and the operands to // the scalar instruction. transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(100, {1}), MakeDataDescriptor(52, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(101, {1}), MakeDataDescriptor(53, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(103, {0}), MakeDataDescriptor(56, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(104, {0}), MakeDataDescriptor(57, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(106, {2}), MakeDataDescriptor(64, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(107, {2}), MakeDataDescriptor(65, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(109, {2}), MakeDataDescriptor(68, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(110, {2}), MakeDataDescriptor(69, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(112, {1}), MakeDataDescriptor(72, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(113, {1}), MakeDataDescriptor(73, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(115, {2}), MakeDataDescriptor(80, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(116, {2}), MakeDataDescriptor(81, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(118, {3}), MakeDataDescriptor(84, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(119, {3}), MakeDataDescriptor(85, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(121, {1}), MakeDataDescriptor(88, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(122, {1}), MakeDataDescriptor(89, {})); } // Test OpISub for signed integer. { // Good: The following transformation should be applicable. TransformationWrapVectorSynonym wrap_sub_int(54, 100, 101, 102, 1); ASSERT_TRUE( wrap_sub_int.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(wrap_sub_int, context.get(), &transformation_context); // |instruction_id| and id at |scalar_position of the result vector should // be synonyms. ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(102, {1}), MakeDataDescriptor(54, {}))); } // Test OpIMul for signed integer. { // Good: The following transformation should be applicable. TransformationWrapVectorSynonym wrap_mul_int(58, 103, 104, 105, 0); ASSERT_TRUE( wrap_mul_int.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(wrap_mul_int, context.get(), &transformation_context); // |instruction_id| and id at |scalar_position of the result vector should // be synonyms. ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(105, {0}), MakeDataDescriptor(58, {}))); } // Test OpIAdd for unsigned integer. { // Good: The following transformation should be applicable. TransformationWrapVectorSynonym wrap_add_uint(66, 106, 107, 108, 2); ASSERT_TRUE( wrap_add_uint.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(wrap_add_uint, context.get(), &transformation_context); // |instruction_id| and id at |scalar_position of the result vector should // be synonyms. ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(108, {2}), MakeDataDescriptor(66, {}))); } // Test OpISub for signed integer. { // Good: The following transformation should be applicable. TransformationWrapVectorSynonym wrap_sub_uint(70, 109, 110, 111, 2); ASSERT_TRUE( wrap_sub_uint.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(wrap_sub_uint, context.get(), &transformation_context); // |instruction_id| and id at |scalar_position of the result vector should // be synonyms. ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(111, {2}), MakeDataDescriptor(70, {}))); } // Test OpIMul for signed integer. { // Good: The following transformation should be applicable. TransformationWrapVectorSynonym wrap_mul_uint(74, 112, 113, 114, 1); ASSERT_TRUE( wrap_mul_uint.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(wrap_mul_uint, context.get(), &transformation_context); // |instruction_id| and id at |scalar_position of the result vector should // be synonyms. ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(114, {1}), MakeDataDescriptor(74, {}))); } // Test OpFAdd for float. { // Good: The following transformation should be applicable. TransformationWrapVectorSynonym wrap_add_float(82, 115, 116, 117, 2); ASSERT_TRUE( wrap_add_float.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(wrap_add_float, context.get(), &transformation_context); // |instruction_id| and id at |scalar_position of the result vector should // be synonyms. ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(117, {2}), MakeDataDescriptor(82, {}))); } // Test OpFSub for float. { // Good: The following transformation should be applicable. TransformationWrapVectorSynonym wrap_add_float(86, 118, 119, 120, 3); ASSERT_TRUE( wrap_add_float.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(wrap_add_float, context.get(), &transformation_context); // |instruction_id| and id at |scalar_position of the result vector should // be synonyms. ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(120, {3}), MakeDataDescriptor(86, {}))); } // Test OpFMul for float. { // Good: The following transformation should be applicable. TransformationWrapVectorSynonym wrap_mul_float(90, 121, 122, 123, 1); ASSERT_TRUE( wrap_mul_float.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(wrap_mul_float, context.get(), &transformation_context); // |instruction_id| and id at |scalar_position of the result vector should // be synonyms. ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(123, {1}), MakeDataDescriptor(90, {}))); } std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %97 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 10 %11 = OpConstant %6 -5 %12 = OpTypeVector %6 2 %13 = OpTypePointer Function %12 %18 = OpTypeInt 32 0 %19 = OpTypePointer Function %18 %21 = OpConstant %18 8 %23 = OpConstant %18 2 %24 = OpTypeVector %18 3 %25 = OpTypePointer Function %24 %31 = OpTypeFloat 32 %32 = OpTypePointer Function %31 %34 = OpConstant %31 3.29999995 %36 = OpConstant %31 1.10000002 %37 = OpTypeVector %31 4 %38 = OpTypePointer Function %37 %96 = OpTypePointer Input %31 %97 = OpVariable %96 Input %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %14 = OpVariable %13 Function %20 = OpVariable %19 Function %22 = OpVariable %19 Function %26 = OpVariable %25 Function %33 = OpVariable %32 Function %35 = OpVariable %32 Function %39 = OpVariable %38 Function %47 = OpVariable %7 Function %51 = OpVariable %7 Function %55 = OpVariable %7 Function %59 = OpVariable %7 Function %63 = OpVariable %19 Function %67 = OpVariable %19 Function %71 = OpVariable %19 Function %75 = OpVariable %19 Function %79 = OpVariable %32 Function %83 = OpVariable %32 Function %87 = OpVariable %32 Function %91 = OpVariable %32 Function OpStore %8 %9 OpStore %10 %11 %15 = OpLoad %6 %8 %16 = OpLoad %6 %10 %17 = OpCompositeConstruct %12 %15 %16 OpStore %14 %17 OpStore %20 %21 OpStore %22 %23 %27 = OpLoad %18 %20 %28 = OpLoad %18 %20 %29 = OpLoad %18 %22 %30 = OpCompositeConstruct %24 %27 %28 %29 OpStore %26 %30 OpStore %33 %34 OpStore %35 %36 %40 = OpLoad %31 %33 %41 = OpLoad %31 %33 %42 = OpLoad %31 %35 %43 = OpLoad %31 %35 %44 = OpCompositeConstruct %37 %40 %41 %42 %43 %45 = OpLoad %37 %39 %46 = OpVectorShuffle %37 %45 %44 5 6 7 4 OpStore %39 %46 %48 = OpLoad %6 %8 %49 = OpLoad %6 %10 %50 = OpIAdd %6 %48 %49 OpStore %47 %50 %52 = OpLoad %6 %8 %53 = OpLoad %6 %10 %100 = OpCompositeConstruct %12 %52 %52 %101 = OpCompositeConstruct %12 %53 %53 %102 = OpISub %12 %100 %101 %54 = OpISub %6 %52 %53 OpStore %51 %54 %56 = OpLoad %6 %8 %57 = OpLoad %6 %10 %103 = OpCompositeConstruct %12 %56 %56 %104 = OpCompositeConstruct %12 %57 %57 %105 = OpIMul %12 %103 %104 %58 = OpIMul %6 %56 %57 OpStore %55 %58 %60 = OpLoad %6 %8 %61 = OpLoad %6 %10 %62 = OpSDiv %6 %60 %61 OpStore %59 %62 %64 = OpLoad %18 %20 %65 = OpLoad %18 %22 %106 = OpCompositeConstruct %24 %64 %64 %64 %107 = OpCompositeConstruct %24 %65 %65 %65 %108 = OpIAdd %24 %106 %107 %66 = OpIAdd %18 %64 %65 OpStore %63 %66 %68 = OpLoad %18 %20 %69 = OpLoad %18 %22 %109 = OpCompositeConstruct %24 %68 %68 %68 %110 = OpCompositeConstruct %24 %69 %69 %69 %111 = OpISub %24 %109 %110 %70 = OpISub %18 %68 %69 OpStore %67 %70 %72 = OpLoad %18 %20 %73 = OpLoad %18 %22 %112 = OpCompositeConstruct %24 %72 %72 %72 %113 = OpCompositeConstruct %24 %73 %73 %73 %114 = OpIMul %24 %112 %113 %74 = OpIMul %18 %72 %73 OpStore %71 %74 %76 = OpLoad %18 %20 %77 = OpLoad %18 %22 %78 = OpUDiv %18 %76 %77 OpStore %75 %78 %80 = OpLoad %31 %33 %81 = OpLoad %31 %35 %115 = OpCompositeConstruct %37 %80 %80 %80 %80 %116 = OpCompositeConstruct %37 %81 %81 %81 %81 %117 = OpFAdd %37 %115 %116 %82 = OpFAdd %31 %80 %81 OpStore %79 %82 %84 = OpLoad %31 %33 %85 = OpLoad %31 %35 %118 = OpCompositeConstruct %37 %84 %84 %84 %84 %119 = OpCompositeConstruct %37 %85 %85 %85 %85 %120 = OpFSub %37 %118 %119 %86 = OpFSub %31 %84 %85 OpStore %83 %86 %88 = OpLoad %31 %33 %89 = OpLoad %31 %35 %121 = OpCompositeConstruct %37 %88 %88 %88 %88 %122 = OpCompositeConstruct %37 %89 %89 %89 %89 %123 = OpFMul %37 %121 %122 %90 = OpFMul %31 %88 %89 OpStore %87 %90 %92 = OpLoad %31 %33 %93 = OpLoad %31 %35 %94 = OpFDiv %31 %92 %93 OpStore %91 %94 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationWrapVectorSynonym, DivSupportTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %97 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 10 %11 = OpConstant %6 -5 %12 = OpTypeVector %6 2 %13 = OpTypePointer Function %12 %18 = OpTypeInt 32 0 %19 = OpTypePointer Function %18 %21 = OpConstant %18 8 %23 = OpConstant %18 2 %24 = OpTypeVector %18 3 %25 = OpTypePointer Function %24 %31 = OpTypeFloat 32 %32 = OpTypePointer Function %31 %34 = OpConstant %31 3.29999995 %36 = OpConstant %31 1.10000002 %37 = OpTypeVector %31 4 %38 = OpTypePointer Function %37 %96 = OpTypePointer Input %31 %97 = OpVariable %96 Input %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %14 = OpVariable %13 Function %20 = OpVariable %19 Function %22 = OpVariable %19 Function %26 = OpVariable %25 Function %33 = OpVariable %32 Function %35 = OpVariable %32 Function %39 = OpVariable %38 Function %47 = OpVariable %7 Function %51 = OpVariable %7 Function %55 = OpVariable %7 Function %59 = OpVariable %7 Function %63 = OpVariable %19 Function %67 = OpVariable %19 Function %71 = OpVariable %19 Function %75 = OpVariable %19 Function %79 = OpVariable %32 Function %83 = OpVariable %32 Function %87 = OpVariable %32 Function %91 = OpVariable %32 Function OpStore %8 %9 OpStore %10 %11 %15 = OpLoad %6 %8 %16 = OpLoad %6 %10 %17 = OpCompositeConstruct %12 %15 %16 OpStore %14 %17 OpStore %20 %21 OpStore %22 %23 %27 = OpLoad %18 %20 %28 = OpLoad %18 %20 %29 = OpLoad %18 %22 %30 = OpCompositeConstruct %24 %27 %28 %29 OpStore %26 %30 OpStore %33 %34 OpStore %35 %36 %40 = OpLoad %31 %33 %41 = OpLoad %31 %33 %42 = OpLoad %31 %35 %43 = OpLoad %31 %35 %44 = OpCompositeConstruct %37 %40 %41 %42 %43 %45 = OpLoad %37 %39 %46 = OpVectorShuffle %37 %45 %44 5 6 7 4 OpStore %39 %46 %48 = OpLoad %6 %8 %49 = OpLoad %6 %10 %50 = OpIAdd %6 %48 %49 OpStore %47 %50 %52 = OpLoad %6 %8 %53 = OpLoad %6 %10 %54 = OpISub %6 %52 %53 OpStore %51 %54 %56 = OpLoad %6 %8 %57 = OpLoad %6 %10 %58 = OpIMul %6 %56 %57 OpStore %55 %58 %60 = OpLoad %6 %8 %61 = OpLoad %6 %10 %100 = OpCompositeConstruct %12 %60 %60 %101 = OpCompositeConstruct %12 %61 %61 %62 = OpSDiv %6 %60 %61 OpStore %59 %62 %64 = OpLoad %18 %20 %65 = OpLoad %18 %22 %66 = OpIAdd %18 %64 %65 OpStore %63 %66 %68 = OpLoad %18 %20 %69 = OpLoad %18 %22 %70 = OpISub %18 %68 %69 OpStore %67 %70 %72 = OpLoad %18 %20 %73 = OpLoad %18 %22 %74 = OpIMul %18 %72 %73 OpStore %71 %74 %76 = OpLoad %18 %20 %77 = OpLoad %18 %22 %102 = OpCompositeConstruct %24 %76 %76 %76 %103 = OpCompositeConstruct %24 %77 %77 %77 %78 = OpUDiv %18 %76 %77 OpStore %75 %78 %80 = OpLoad %31 %33 %81 = OpLoad %31 %35 %82 = OpFAdd %31 %80 %81 OpStore %79 %82 %84 = OpLoad %31 %33 %85 = OpLoad %31 %35 %86 = OpFSub %31 %84 %85 OpStore %83 %86 %88 = OpLoad %31 %33 %89 = OpLoad %31 %35 %90 = OpFMul %31 %88 %89 OpStore %87 %90 %92 = OpLoad %31 %33 %93 = OpLoad %31 %35 %104 = OpCompositeConstruct %37 %92 %92 %92 %92 %105 = OpCompositeConstruct %37 %93 %93 %93 %93 %94 = OpFDiv %31 %92 %93 OpStore %91 %94 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(100, {1}), MakeDataDescriptor(60, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(101, {1}), MakeDataDescriptor(61, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(102, {1}), MakeDataDescriptor(76, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(103, {1}), MakeDataDescriptor(77, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(104, {1}), MakeDataDescriptor(92, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(105, {1}), MakeDataDescriptor(93, {})); // Div operations are not currently supported. { TransformationWrapVectorSynonym wrap_div_bad1(62, 100, 101, 106, 1); ASSERT_FALSE( wrap_div_bad1.IsApplicable(context.get(), transformation_context)); TransformationWrapVectorSynonym wrap_div_bad2(78, 102, 103, 106, 1); ASSERT_FALSE( wrap_div_bad2.IsApplicable(context.get(), transformation_context)); TransformationWrapVectorSynonym wrap_div_bad3(94, 104, 105, 106, 1); ASSERT_FALSE( wrap_div_bad3.IsApplicable(context.get(), transformation_context)); } } TEST(TransformationWrapVectorSynonym, AdditionalWidthSupportTest) { std::string shader = R"( OpCapability Shader OpCapability Int64 OpCapability Float64 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %97 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 64 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 10 %11 = OpConstant %6 -5 %12 = OpTypeVector %6 2 %13 = OpTypePointer Function %12 %18 = OpTypeInt 64 0 %19 = OpTypePointer Function %18 %21 = OpConstant %18 8 %23 = OpConstant %18 2 %24 = OpTypeVector %18 3 %25 = OpTypePointer Function %24 %31 = OpTypeFloat 64 %32 = OpTypePointer Function %31 %34 = OpConstant %31 3.29999995 %36 = OpConstant %31 1.10000002 %37 = OpTypeVector %31 4 %38 = OpTypePointer Function %37 %96 = OpTypePointer Input %31 %97 = OpVariable %96 Input %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %14 = OpVariable %13 Function %20 = OpVariable %19 Function %22 = OpVariable %19 Function %26 = OpVariable %25 Function %33 = OpVariable %32 Function %35 = OpVariable %32 Function %39 = OpVariable %38 Function %47 = OpVariable %7 Function %51 = OpVariable %7 Function %55 = OpVariable %7 Function %59 = OpVariable %7 Function %63 = OpVariable %19 Function %67 = OpVariable %19 Function %71 = OpVariable %19 Function %75 = OpVariable %19 Function %79 = OpVariable %32 Function %83 = OpVariable %32 Function %87 = OpVariable %32 Function %91 = OpVariable %32 Function OpStore %8 %9 OpStore %10 %11 %15 = OpLoad %6 %8 %16 = OpLoad %6 %10 %17 = OpCompositeConstruct %12 %15 %16 OpStore %14 %17 OpStore %20 %21 OpStore %22 %23 %27 = OpLoad %18 %20 %28 = OpLoad %18 %20 %29 = OpLoad %18 %22 %30 = OpCompositeConstruct %24 %27 %28 %29 OpStore %26 %30 OpStore %33 %34 OpStore %35 %36 %40 = OpLoad %31 %33 %41 = OpLoad %31 %33 %42 = OpLoad %31 %35 %43 = OpLoad %31 %35 %44 = OpCompositeConstruct %37 %40 %41 %42 %43 %45 = OpLoad %37 %39 %46 = OpVectorShuffle %37 %45 %44 5 6 7 4 OpStore %39 %46 %48 = OpLoad %6 %8 %49 = OpLoad %6 %10 %100 = OpCompositeConstruct %12 %48 %48 %101 = OpCompositeConstruct %12 %49 %49 %50 = OpIAdd %6 %48 %49 OpStore %47 %50 %52 = OpLoad %6 %8 %53 = OpLoad %6 %10 %54 = OpISub %6 %52 %53 OpStore %51 %54 %56 = OpLoad %6 %8 %57 = OpLoad %6 %10 %58 = OpIMul %6 %56 %57 OpStore %55 %58 %60 = OpLoad %6 %8 %61 = OpLoad %6 %10 %62 = OpSDiv %6 %60 %61 OpStore %59 %62 %64 = OpLoad %18 %20 %65 = OpLoad %18 %22 %66 = OpIAdd %18 %64 %65 OpStore %63 %66 %68 = OpLoad %18 %20 %69 = OpLoad %18 %22 %103 = OpCompositeConstruct %24 %68 %68 %68 %104 = OpCompositeConstruct %24 %69 %69 %69 %70 = OpISub %18 %68 %69 OpStore %67 %70 %72 = OpLoad %18 %20 %73 = OpLoad %18 %22 %74 = OpIMul %18 %72 %73 OpStore %71 %74 %76 = OpLoad %18 %20 %77 = OpLoad %18 %22 %78 = OpUDiv %18 %76 %77 OpStore %75 %78 %80 = OpLoad %31 %33 %81 = OpLoad %31 %35 %82 = OpFAdd %31 %80 %81 OpStore %79 %82 %84 = OpLoad %31 %33 %85 = OpLoad %31 %35 %86 = OpFSub %31 %84 %85 OpStore %83 %86 %88 = OpLoad %31 %33 %89 = OpLoad %31 %35 %106 = OpCompositeConstruct %37 %88 %88 %88 %88 %107 = OpCompositeConstruct %37 %89 %89 %89 %89 %90 = OpFMul %31 %88 %89 OpStore %87 %90 %92 = OpLoad %31 %33 %93 = OpLoad %31 %35 %94 = OpFDiv %31 %92 %93 OpStore %91 %94 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; // Check context validity. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Vec Type Id | Vector Type | Element Type id | Element Type | // ------------+----------------+------------------+-----------------+ // 12 | vec2 | 6 | int64 | // 24 | vec3 | 18 | uint64 | // 37 | vec4 | 31 | float64 | // Test support for 64-bit signed int. { // Assert that the target scalar instruction result id is relevant. ASSERT_FALSE(transformation_context.GetFactManager()->IdIsIrrelevant(50)); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(100, {1}), MakeDataDescriptor(48, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(101, {1}), MakeDataDescriptor(49, {})); // Good: The following transformation should be applicable. TransformationWrapVectorSynonym wrap_add_int64(50, 100, 101, 102, 1); ASSERT_TRUE( wrap_add_int64.IsApplicable(context.get(), transformation_context)); // Insert an arithmetic instruction of the same type to add two vectors. ApplyAndCheckFreshIds(wrap_add_int64, context.get(), &transformation_context); // |instruction_id| and id at |scalar_position of the result vector should // be synonyms. ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(102, {1}), MakeDataDescriptor(50, {}))); } // Test support for 64-bit unsigned int. { ASSERT_FALSE(transformation_context.GetFactManager()->IdIsIrrelevant(70)); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(103, {2}), MakeDataDescriptor(68, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(104, {2}), MakeDataDescriptor(69, {})); // Good: The following transformation should be applicable. TransformationWrapVectorSynonym wrap_sub_uint64(70, 103, 104, 105, 2); ASSERT_TRUE( wrap_sub_uint64.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(wrap_sub_uint64, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(105, {2}), MakeDataDescriptor(70, {}))); } // Test support for 64-bit float. { ASSERT_FALSE(transformation_context.GetFactManager()->IdIsIrrelevant(90)); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(106, {3}), MakeDataDescriptor(88, {})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(107, {3}), MakeDataDescriptor(89, {})); // Good: The following transformation should be applicable. TransformationWrapVectorSynonym wrap_mul_float64(90, 106, 107, 108, 3); ASSERT_TRUE( wrap_mul_float64.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(wrap_mul_float64, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(108, {3}), MakeDataDescriptor(90, {}))); } std::string after_transformation = R"( OpCapability Shader OpCapability Int64 OpCapability Float64 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %97 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 64 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 10 %11 = OpConstant %6 -5 %12 = OpTypeVector %6 2 %13 = OpTypePointer Function %12 %18 = OpTypeInt 64 0 %19 = OpTypePointer Function %18 %21 = OpConstant %18 8 %23 = OpConstant %18 2 %24 = OpTypeVector %18 3 %25 = OpTypePointer Function %24 %31 = OpTypeFloat 64 %32 = OpTypePointer Function %31 %34 = OpConstant %31 3.29999995 %36 = OpConstant %31 1.10000002 %37 = OpTypeVector %31 4 %38 = OpTypePointer Function %37 %96 = OpTypePointer Input %31 %97 = OpVariable %96 Input %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %14 = OpVariable %13 Function %20 = OpVariable %19 Function %22 = OpVariable %19 Function %26 = OpVariable %25 Function %33 = OpVariable %32 Function %35 = OpVariable %32 Function %39 = OpVariable %38 Function %47 = OpVariable %7 Function %51 = OpVariable %7 Function %55 = OpVariable %7 Function %59 = OpVariable %7 Function %63 = OpVariable %19 Function %67 = OpVariable %19 Function %71 = OpVariable %19 Function %75 = OpVariable %19 Function %79 = OpVariable %32 Function %83 = OpVariable %32 Function %87 = OpVariable %32 Function %91 = OpVariable %32 Function OpStore %8 %9 OpStore %10 %11 %15 = OpLoad %6 %8 %16 = OpLoad %6 %10 %17 = OpCompositeConstruct %12 %15 %16 OpStore %14 %17 OpStore %20 %21 OpStore %22 %23 %27 = OpLoad %18 %20 %28 = OpLoad %18 %20 %29 = OpLoad %18 %22 %30 = OpCompositeConstruct %24 %27 %28 %29 OpStore %26 %30 OpStore %33 %34 OpStore %35 %36 %40 = OpLoad %31 %33 %41 = OpLoad %31 %33 %42 = OpLoad %31 %35 %43 = OpLoad %31 %35 %44 = OpCompositeConstruct %37 %40 %41 %42 %43 %45 = OpLoad %37 %39 %46 = OpVectorShuffle %37 %45 %44 5 6 7 4 OpStore %39 %46 %48 = OpLoad %6 %8 %49 = OpLoad %6 %10 %100 = OpCompositeConstruct %12 %48 %48 %101 = OpCompositeConstruct %12 %49 %49 %102 = OpIAdd %12 %100 %101 %50 = OpIAdd %6 %48 %49 OpStore %47 %50 %52 = OpLoad %6 %8 %53 = OpLoad %6 %10 %54 = OpISub %6 %52 %53 OpStore %51 %54 %56 = OpLoad %6 %8 %57 = OpLoad %6 %10 %58 = OpIMul %6 %56 %57 OpStore %55 %58 %60 = OpLoad %6 %8 %61 = OpLoad %6 %10 %62 = OpSDiv %6 %60 %61 OpStore %59 %62 %64 = OpLoad %18 %20 %65 = OpLoad %18 %22 %66 = OpIAdd %18 %64 %65 OpStore %63 %66 %68 = OpLoad %18 %20 %69 = OpLoad %18 %22 %103 = OpCompositeConstruct %24 %68 %68 %68 %104 = OpCompositeConstruct %24 %69 %69 %69 %105 = OpISub %24 %103 %104 %70 = OpISub %18 %68 %69 OpStore %67 %70 %72 = OpLoad %18 %20 %73 = OpLoad %18 %22 %74 = OpIMul %18 %72 %73 OpStore %71 %74 %76 = OpLoad %18 %20 %77 = OpLoad %18 %22 %78 = OpUDiv %18 %76 %77 OpStore %75 %78 %80 = OpLoad %31 %33 %81 = OpLoad %31 %35 %82 = OpFAdd %31 %80 %81 OpStore %79 %82 %84 = OpLoad %31 %33 %85 = OpLoad %31 %35 %86 = OpFSub %31 %84 %85 OpStore %83 %86 %88 = OpLoad %31 %33 %89 = OpLoad %31 %35 %106 = OpCompositeConstruct %37 %88 %88 %88 %88 %107 = OpCompositeConstruct %37 %89 %89 %89 %89 %108 = OpFMul %37 %106 %107 %90 = OpFMul %31 %88 %89 OpStore %87 %90 %92 = OpLoad %31 %33 %93 = OpLoad %31 %35 %94 = OpFDiv %31 %92 %93 OpStore %91 %94 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationWrapVectorSynonym, DifferentVectorSignedness) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeVector %6 2 %8 = OpTypePointer Function %7 %10 = OpConstant %6 1 %11 = OpConstant %6 0 %12 = OpConstantComposite %7 %10 %11 %14 = OpTypeInt 32 0 %15 = OpTypeVector %14 2 %18 = OpConstant %14 3 %19 = OpConstant %14 0 %20 = OpConstantComposite %15 %18 %19 %21 = OpConstantComposite %15 %19 %18 %4 = OpFunction %2 None %3 %5 = OpLabel %100 = OpIAdd %14 %10 %18 %101 = OpIAdd %6 %10 %18 %102 = OpIAdd %6 %18 %19 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; // Check context validity. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(10, {}), MakeDataDescriptor(12, {0})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(18, {}), MakeDataDescriptor(20, {0})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(19, {}), MakeDataDescriptor(21, {0})); { TransformationWrapVectorSynonym transformation1(100, 12, 20, 200, 0); ASSERT_TRUE( transformation1.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation1, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(200, {0}), MakeDataDescriptor(100, {}))); } { TransformationWrapVectorSynonym transformation2(101, 12, 20, 201, 0); ASSERT_TRUE( transformation2.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation2, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(201, {0}), MakeDataDescriptor(101, {}))); } { TransformationWrapVectorSynonym transformation3(102, 20, 21, 202, 0); ASSERT_TRUE( transformation3.IsApplicable(context.get(), transformation_context)); ApplyAndCheckFreshIds(transformation3, context.get(), &transformation_context); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(202, {0}), MakeDataDescriptor(102, {}))); } std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeVector %6 2 %8 = OpTypePointer Function %7 %10 = OpConstant %6 1 %11 = OpConstant %6 0 %12 = OpConstantComposite %7 %10 %11 %14 = OpTypeInt 32 0 %15 = OpTypeVector %14 2 %18 = OpConstant %14 3 %19 = OpConstant %14 0 %20 = OpConstantComposite %15 %18 %19 %21 = OpConstantComposite %15 %19 %18 %4 = OpFunction %2 None %3 %5 = OpLabel %200 = OpIAdd %15 %12 %20 %100 = OpIAdd %14 %10 %18 %201 = OpIAdd %7 %12 %20 %101 = OpIAdd %6 %10 %18 %202 = OpIAdd %7 %20 %21 %102 = OpIAdd %6 %18 %19 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, context.get())); } TEST(TransformationWrapVectorSynonym, SignednessDoesNotMatchResultType) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeVector %6 2 %8 = OpTypePointer Function %7 %10 = OpConstant %6 1 %11 = OpConstant %6 0 %12 = OpConstantComposite %7 %10 %11 %13 = OpConstantComposite %7 %11 %10 %14 = OpTypeInt 32 0 %4 = OpFunction %2 None %3 %5 = OpLabel %100 = OpIAdd %14 %10 %11 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; // Check context validity. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(10, {}), MakeDataDescriptor(12, {0})); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(11, {}), MakeDataDescriptor(13, {0})); ASSERT_FALSE(TransformationWrapVectorSynonym(100, 12, 13, 200, 0) .IsApplicable(context.get(), transformation_context)); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzz/uniform_buffer_element_descriptor_test.cpp000066400000000000000000000063451475742701700312400ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/uniform_buffer_element_descriptor.h" #include "gtest/gtest.h" namespace spvtools { namespace fuzz { namespace { TEST(UniformBufferElementDescriptorTest, TestEquality) { // Test that equality works as expected for various buffer element // descriptors. protobufs::UniformBufferElementDescriptor descriptor1 = MakeUniformBufferElementDescriptor(0, 0, {1, 2, 3}); protobufs::UniformBufferElementDescriptor descriptor2 = MakeUniformBufferElementDescriptor(0, 0, {1, 2, 3}); protobufs::UniformBufferElementDescriptor descriptor3 = MakeUniformBufferElementDescriptor(0, 1, {1, 2, 3}); protobufs::UniformBufferElementDescriptor descriptor4 = MakeUniformBufferElementDescriptor(1, 0, {1, 2, 3}); protobufs::UniformBufferElementDescriptor descriptor5 = MakeUniformBufferElementDescriptor(1, 1, {1, 2, 3}); protobufs::UniformBufferElementDescriptor descriptor6 = MakeUniformBufferElementDescriptor(0, 0, {1, 2, 4}); protobufs::UniformBufferElementDescriptor descriptor7 = MakeUniformBufferElementDescriptor(0, 0, {1, 2}); ASSERT_TRUE( UniformBufferElementDescriptorEquals()(&descriptor1, &descriptor1)); ASSERT_TRUE( UniformBufferElementDescriptorEquals()(&descriptor1, &descriptor2)); ASSERT_TRUE( UniformBufferElementDescriptorEquals()(&descriptor3, &descriptor3)); ASSERT_TRUE( UniformBufferElementDescriptorEquals()(&descriptor4, &descriptor4)); ASSERT_TRUE( UniformBufferElementDescriptorEquals()(&descriptor5, &descriptor5)); ASSERT_TRUE( UniformBufferElementDescriptorEquals()(&descriptor6, &descriptor6)); ASSERT_TRUE( UniformBufferElementDescriptorEquals()(&descriptor7, &descriptor7)); ASSERT_FALSE( UniformBufferElementDescriptorEquals()(&descriptor1, &descriptor3)); ASSERT_FALSE( UniformBufferElementDescriptorEquals()(&descriptor3, &descriptor1)); ASSERT_FALSE( UniformBufferElementDescriptorEquals()(&descriptor1, &descriptor4)); ASSERT_FALSE( UniformBufferElementDescriptorEquals()(&descriptor4, &descriptor1)); ASSERT_FALSE( UniformBufferElementDescriptorEquals()(&descriptor1, &descriptor5)); ASSERT_FALSE( UniformBufferElementDescriptorEquals()(&descriptor5, &descriptor1)); ASSERT_FALSE( UniformBufferElementDescriptorEquals()(&descriptor1, &descriptor6)); ASSERT_FALSE( UniformBufferElementDescriptorEquals()(&descriptor6, &descriptor1)); ASSERT_FALSE( UniformBufferElementDescriptorEquals()(&descriptor1, &descriptor7)); ASSERT_FALSE( UniformBufferElementDescriptorEquals()(&descriptor7, &descriptor1)); } } // namespace } // namespace fuzz } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/000077500000000000000000000000001475742701700212205ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/BUILD.gn000066400000000000000000000076701475742701700224170ustar00rootroot00000000000000# Copyright 2018 Google Inc. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import("//testing/libfuzzer/fuzzer_test.gni") import("//testing/test.gni") config("fuzzer_config") { configs = [ "../..:spvtools_internal_config" ] } group("fuzzers") { testonly = true deps = [] if (!build_with_chromium || use_fuzzing_engine) { deps += [ ":fuzzers_bin" ] } } if (!build_with_chromium || use_fuzzing_engine) { group("fuzzers_bin") { testonly = true deps = [ ":spvtools_as_fuzzer", ":spvtools_binary_parser_fuzzer", ":spvtools_dis_fuzzer", ":spvtools_opt_legalization_fuzzer", ":spvtools_opt_performance_fuzzer", ":spvtools_opt_size_fuzzer", ":spvtools_val_fuzzer", ] } } template("spvtools_fuzzer") { source_set(target_name) { testonly = true sources = invoker.sources sources += [ "random_generator.cpp" ] deps = [ "../..:spvtools", "../..:spvtools_opt", "../..:spvtools_val", ] if (defined(invoker.deps)) { deps += invoker.deps } configs -= [ "//build/config/compiler:chromium_code" ] configs += [ "//build/config/compiler:no_chromium_code", ":fuzzer_config", ] } } spvtools_fuzzer("spvtools_as_fuzzer_src") { sources = [ "spvtools_as_fuzzer.cpp", ] } spvtools_fuzzer("spvtools_binary_parser_fuzzer_src") { sources = [ "spvtools_binary_parser_fuzzer.cpp", ] } spvtools_fuzzer("spvtools_dis_fuzzer_src") { sources = [ "spvtools_dis_fuzzer.cpp", ] } spvtools_fuzzer("spvtools_opt_performance_fuzzer_src") { sources = [ "spvtools_opt_performance_fuzzer.cpp", "spvtools_opt_fuzzer_common.cpp", ] } spvtools_fuzzer("spvtools_opt_legalization_fuzzer_src") { sources = [ "spvtools_opt_legalization_fuzzer.cpp", "spvtools_opt_fuzzer_common.cpp", ] } spvtools_fuzzer("spvtools_opt_size_fuzzer_src") { sources = [ "spvtools_opt_size_fuzzer.cpp", "spvtools_opt_fuzzer_common.cpp", ] } spvtools_fuzzer("spvtools_val_fuzzer_src") { sources = [ "spvtools_val_fuzzer.cpp", ] } if (!build_with_chromium || use_fuzzing_engine) { fuzzer_test("spvtools_as_fuzzer") { sources = [] deps = [ ":spvtools_as_fuzzer_src", ] # Intentionally doesn't use the seed corpus, because it consumes # part of the input as not part of the file. } fuzzer_test("spvtools_binary_parser_fuzzer") { sources = [] deps = [ ":spvtools_binary_parser_fuzzer_src", ] # Intentionally doesn't use the seed corpus, because it consumes # part of the input as not part of the file. } fuzzer_test("spvtools_dis_fuzzer") { sources = [] deps = [ ":spvtools_dis_fuzzer_src", ] # Intentionally doesn't use the seed corpus, because it consumes # part of the input as not part of the file. } fuzzer_test("spvtools_opt_performance_fuzzer") { sources = [] deps = [ ":spvtools_opt_performance_fuzzer_src", ] seed_corpus = "corpora/spv" } fuzzer_test("spvtools_opt_legalization_fuzzer") { sources = [] deps = [ ":spvtools_opt_legalization_fuzzer_src", ] seed_corpus = "corpora/spv" } fuzzer_test("spvtools_opt_size_fuzzer") { sources = [] deps = [ ":spvtools_opt_size_fuzzer_src", ] seed_corpus = "corpora/spv" } fuzzer_test("spvtools_val_fuzzer") { sources = [] deps = [ ":spvtools_val_fuzzer_src", ] seed_corpus = "corpora/spv" } } KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/CMakeLists.txt000066400000000000000000000066261475742701700237720ustar00rootroot00000000000000# Copyright (c) 2021 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. function(add_spvtools_libfuzzer_target) set(one_value_args TARGET) set(multi_value_args SRCS LIBS) cmake_parse_arguments( ARG "" "${one_value_args}" "${multi_value_args}" ${ARGN}) add_executable(${ARG_TARGET} ${ARG_SRCS}) spvtools_default_compile_options(${ARG_TARGET}) target_link_libraries(${ARG_TARGET} PRIVATE ${ARG_LIBS}) target_include_directories(${ARG_TARGET} PRIVATE ${spirv-tools_SOURCE_DIR} ${spirv-tools_BINARY_DIR} ) set_property(TARGET ${ARG_TARGET} PROPERTY FOLDER "SPIRV-Tools libFuzzer targets") if(NOT ${SPIRV_LIB_FUZZING_ENGINE_LINK_OPTIONS} STREQUAL "") # This is set when the fuzzers are being built by OSS-Fuzz. In this case the # variable provides the necessary linker flags, and OSS-Fuzz will take care # of passing suitable compiler flags. target_link_options(${ARG_TARGET} PRIVATE ${SPIRV_LIB_FUZZING_ENGINE_LINK_OPTIONS}) else() # When the fuzzers are being built outside of OSS-Fuzz, standard libFuzzer # arguments to enable fuzzing are used. target_compile_options(${ARG_TARGET} PRIVATE "-fsanitize=fuzzer") target_link_options(${ARG_TARGET} PRIVATE "-fsanitize=fuzzer") endif() endfunction() if (${SPIRV_BUILD_LIBFUZZER_TARGETS}) if(NOT "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") message(FATAL_ERROR "The libFuzzer targets are only supported with the Clang compiler. Compiler '${CMAKE_CXX_COMPILER_ID}' is not supported!") endif() add_spvtools_libfuzzer_target(TARGET spvtools_as_fuzzer SRCS spvtools_as_fuzzer.cpp random_generator.cpp LIBS ${SPIRV_TOOLS_FULL_VISIBILITY}) add_spvtools_libfuzzer_target(TARGET spvtools_binary_parser_fuzzer SRCS spvtools_binary_parser_fuzzer.cpp random_generator.cpp LIBS ${SPIRV_TOOLS_FULL_VISIBILITY}) add_spvtools_libfuzzer_target(TARGET spvtools_dis_fuzzer SRCS spvtools_dis_fuzzer.cpp random_generator.cpp LIBS ${SPIRV_TOOLS_FULL_VISIBILITY}) add_spvtools_libfuzzer_target(TARGET spvtools_opt_legalization_fuzzer SRCS spvtools_opt_legalization_fuzzer.cpp spvtools_opt_fuzzer_common.cpp random_generator.cpp LIBS SPIRV-Tools-opt ${SPIRV_TOOLS_FULL_VISIBILITY}) add_spvtools_libfuzzer_target(TARGET spvtools_opt_performance_fuzzer SRCS spvtools_opt_performance_fuzzer.cpp spvtools_opt_fuzzer_common.cpp random_generator.cpp LIBS SPIRV-Tools-opt ${SPIRV_TOOLS_FULL_VISIBILITY}) add_spvtools_libfuzzer_target(TARGET spvtools_opt_size_fuzzer SRCS spvtools_opt_size_fuzzer.cpp spvtools_opt_fuzzer_common.cpp random_generator.cpp LIBS SPIRV-Tools-opt ${SPIRV_TOOLS_FULL_VISIBILITY}) add_spvtools_libfuzzer_target(TARGET spvtools_val_fuzzer SRCS spvtools_val_fuzzer.cpp random_generator.cpp LIBS ${SPIRV_TOOLS_FULL_VISIBILITY}) if (${SPIRV_BUILD_FUZZER}) add_spvtools_libfuzzer_target(TARGET spvtools_fuzz_fuzzer SRCS spvtools_fuzz_fuzzer.cpp random_generator.cpp LIBS SPIRV-Tools-fuzz ${SPIRV_TOOLS_FULL_VISIBILITY}) endif() endif() KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/000077500000000000000000000000001475742701700226655ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/000077500000000000000000000000001475742701700234755ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_000.spv000066400000000000000000000174401475742701700273330ustar00rootroot00000000000000#m GLSL.std.450main@mainmerge(i1;i1;i1;frommidto mergeSort( k i j datatempilowhighmifrommidtoparamparamparamibuf0injectionSwitchjgl_FragCoordgrey_GLF_colorH#GG"G!G G! !  "!!#"""+!$%& +&' (!' )(;)  *!;)+!+ +!,+!- +!./ 0/0 1;1+&2 3/+!4+!5+!6+!7+!8+!9+!:;/ <;;<+&= >/+!? @/+/A?+/B A+!C<+!DZ+!Ex+!F+!G+!H+!I+!J+!K+!L+!M+!N O;;OP/+/Q?6 R;";";@A3S,2=/TSn!UT>UVVWXYY=!Z[Z[\]^_`abcd e\=!fA*g f>g4[]=!hA*i h>i5[^=!jA*k j>k.[_=!lA*m l>m$[`=!nA*o n>o,[a=!pA*q p>q6[b=!rA*s r>s7[c=!tA*u t>u8[d=!vA*w v>w9[e=!xA*y x>y:[[=!z!{z$>{XX=!|%}|+}VWW>,~~=!%+=!=!A* =!A*>=!!$>~9 A>==/n!%?A* ,=!o//B/A>A>==/n!%CA* $=!o//B/A>A>==/n!%DA* .=!o//B/A>A>==/n!%EA* 5=!o//B/A>A>==/n!%FA>==/n!%GA* H=!o//B/A>A>==/n!%IA* J=!o//B/A>A>==/n!%KA* L=!o//B/A>A>==/n!%MA* N=!o//B/A>=/PPQ/Q/Q/P;Q>86#7"7"7";" ;" ;" ;"=!> =!> =!!$> =! =!%=! =!%%    =!  A*  =!  =! A* =!% =! !$> =! !$> A* =!A*>=! !$> =! !$> A*  =!! A*">"!##$%&&=!' %('+=!) =!*%+)*%,(+,-$-=!. !/.$> /=!0 !10$> 1A*2 0=!32A*4.>43%%#$=!5>5667899=!:=!;%<:;<=7==!>=!?A*@?=!A@A*B >>BA88=!C!DC$>D6786 E;";";";";";";";";";">,>->$FFGHII=!J=!K%LJKLMGM=!N>NOOPQRR=!S=!T%USTUVPV=!W>W=!X=!Y!ZXY![Z$>[=!\=!]!^.]!_\^!`_$=!a !b'`a>b=!c>c=!d>d=!e>e9fQQ=!g!h.g=!i!jih>jOPHH=!k!l.k>lFG8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_001.spv000066400000000000000000000046241475742701700273340ustar00rootroot00000000000000#h GLSL.std.450main@maincoordgl_FragCoordresitex_GLF_colorG GG G G GG"G!G G !    ;+; +>,+@  ++ +  +!?+" #$# %$;% &;&'6 (;;;=)O*))+*>+>=,-,>->../011= 2 32434A 5=6576!338217498:9;:;A <"==<>=!::?83>;?@/@A A=BACB!DCEDEA F=GFHG!A I>IHDDA J"=KJLK!MLNMNA O"=POQP!A R">RQMM=STS>T=  > 00./A U=VUWV!XWYXYA Z"=[Z\[!XX]W/\Y^]_^_=$ =`Wa `>a^^=bO'cbbQdcQecQfcPgdef!>g8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_002.spv000066400000000000000000000040141475742701700273260ustar00rootroot00000000000000#T GLSL.std.450main@maingl_FragCoordbuf0resolution_GLF_colorindexableG H#GG"G!G!  + +  + +   ; ; +A +  ;+++?,+?, ,!,",#,$,%,&,',(,),*,+,,,-,. !"#$%&'()*+,-+ / 0 16 2;0=3O433A5 =6574687 98Q:9n ;: <;Q=9n >= ?<>@@ A 2BC D?2EC FD GCFHGH ID  JI KJLML ND ON KM PDKK EOLPM BA CC@G QA/>.A1RQ=SR>S8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_003.spv000066400000000000000000000320301475742701700273260ustar00rootroot00000000000000#U GLSL.std.450main@mainbuf0timebuf1resolutiongl_FragCoord_GLF_colorH#GG"G!H#GG"G!G GG G G G G G! +?+@++>+*?,+@@ +++?  ; ! +!" #$,% &;& '( )(;),*+!+#+, #<+!-+.=+/>,0/// 1(;1,2,3+4>+5<66A#7"=87 9 8:9. ; : <:=<P>;=P?<;P@>?A'A"=BAA#C"=DCA#E"=FE G%DFPHGGIBH=(JOKJJLKBMLIN*IOM@PN@QQR%6ST! +6 T$U "VTUWVWoX YX.ZY8 [ Z\[4P]\^P]_X, ` _a,`bccQdOedaQf^$gef$hgihjijbikda$lkf$mlnmonobnQpOqpaQr^$sqr$tsutvuvbuwpa$xwr$yxzy{z{bz|d`$}|f$~}~X5  9P 2 3 +%3QQQpdpd $Pbd`$f$X5  9P 2 3 +%3QQQpdpd $Pbp`$r$X5  9P 2 3 +%3QQQpdpd $Pbp`$r$X5  9P 2 3 +%3QQQpdpd $Pbbb%j%o%v%{% B$TTTSR! -QV@@MN%V! +V $ "o .8  4P  ,    ,  Q Q $$  $$ Q Q $$ ! !  " $#"$$#%$&%& %' $('$)(*)+*+,5 - ,.9/.P0---1021 32432 54653 7+6%387/Q98Q:8Q;8<=:<>?9>@ A@$BACB;PD?=C *E $FE$GFHGIHIJ5 K JL9MLPNKKKONPO QPRQ2 SRTS3 U+T%3VUMQWVQXVQYVZ[XZ\]W\^ _^$`_a`YPb][a Hc $dc$edfegfgh5 i hj9kjPliiimlnm onpo2 qprq3 s+r%3tskQutQvtQwtxyvxz{uz| }|$~}~wP{y f $$5  9P 2 3 +%3QQQ $P   %%%!%&D+bIg% B$! -@MN%!+ $"o.8  4P,  ,QQ$$$$QQ$$$$$$5  9P 2 3 +%3QQQ $P$$5  9P 2 3 +%3QQQ    $    P  $$5  9P 2 3 +%3Q Q!Q"#$!#%& %' ('$)(*)"P+&$*,$-,$.-/.0/015 2 13943P52226576 87982 :9;:3 <+;%3=<4Q>=Q?=Q@=AB?ACD>CE FE$GFHG@PIDBH/J%%%% +I0%/ KBJ$LKMLNMNMNJM! - O.R0 P.O0QQPQRPQSPP(TQRS>T8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_004.spv000066400000000000000000000301201475742701700273250ustar00rootroot00000000000000# GLSL.std.450main@maindoConvert(computeColor(f1;vf2;cposition defaultColor( drawShape(vf2;vf2;vf3; pos square settingcomputePoint(mf22;rotationMatrixmsb8tempb_bs_gh_rbuf1resolutionmsb8buf0timemsb8c1c2c3c4c5 param!param"c6#param$param%c7&param'param(c8)param*param+msb8,aspect-positiongl_FragCoord.center/result0i1d2param3param4param5msb86angle7rotationMatrix8point19param:rotationMatrix2;point2<param=rotationMatrix3>point3?param@mixed_GLF_colorGGAGBGCGDGEGFGGGHH#GG"G!GIGGJGKH#GG"G!GLGMGNGOGPGQGRGSGGTGUGVGWG+G G0GXGYGZG[G\G]G^G_G`GaGbGcGdGeGfG5GGgGhi!jik lkmk nmok!poln!qo ro!sonnrtm ut!vouw  xw+wy zk;z;z+k{@;z+w|+k}@+k~@@m ; + k+++k?k ; +k@ mk ;,m+k,o+w#+k A+k@+k #<+kB+w+k=+k?+k>,o ;6ij;x5;l6;u7;r8;u9;u:;r;;u<;u=;r>;u?;r@>5yA|=k k k>6=k6 k =k6 kk=k6 k=k6 k PmPmPt>7=t7>99o9>8=t7=t7t>:=t:><9o<>;=t7=t7t=t7t>==t=>?9o?>>=o8=o; o.>@=o@=o> o.>@=o@=wg5whgokhQkQkQkP>86ij;x;r>y=k=wAwBAokB=kkk=k=k=wCwDCokD=kkkk=kw|ok=wEwFEokFPo}Po~~~oPooo{ oPo~~~o o=wGwHGokHPooA|=knww||okA|=knwwIokIPoPo o+oPoo>Al=k>Al=k>Al=k>86op7l7n;x>y=k k >=wJwKJokK>A|=k k kkk>9i=wLwMLokMAl=kk=kk > =wNwONok OAl =k  k   =kk >Al=kAl=kk kA|=knww||ok=wPwQPokQ=k=wRwSRok Sk! k"!~ k#+">#=k$=k%=k&Po'$%&'86o q(A)|=k*)nw+*w,+||ok-,Po.---.86o s7n 7n 7r /;x;;;;;;l ;n!;";l#;n$;%;l&;n';(;l);n*>yAl0 =k10Al2 =k32k413Al5 =k65746>7=898:9;:;9o< <:Al= =k>=Al? =k@?kA>@AlB =kCBDAC>D=EFEGFHGH9oI IGAlJ =kKJAlL =kMLkNKMAlO =kPOQNP>Q=RSRTSUTU9oV VTAlW =kXWAlY =kZYk[XZAl\ =k]\^[]>^=_`_a`bab9oc caAld =kedAlf =kgfAlh =kihkjgikkejAll =kmlnkm>n=opoqprqrAls =kts=wT wuJTokvukwvkxtw> x=my >!y9oz !zqAl{ =k|{Al} =k~}Al =kk~k|Al =k>"="Al =k=wU wJUokkk>#=m >$9o#$Al =kAl =kAl =kkkAl =k>%=%Al =k=wV wJVokkk>&=m >'9o&'Al =kAl =kAl =kkkAl =k>(=(Al =k=wW wJWokkk>)=m >*9o)*9o 86ov7u;x+;n,;n-;n.;r/;x0;r1;n2;n3;r4>+yA|=mA|=kA|=k k%Pmm>,=OmA|=mm=m,m>-=m,m>.=t=m-m>-=t=m.m>.>/A|=knwXwYX||wZ||Y>0Z=w[0A|=knww||w[=m.=w\0ok\=w]+w^]ok^kkA|=kk k k=w_+w`_ok`kA|=knww||okPmm=wa0okak=wb+wcbokck k k=wd0okdPo=m->2>3>49o 234>1=o1 kBA|=knww ||ok          =o1QkQkQkPo>/=we0wfe>0f=o/8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_005.spv000066400000000000000000000045601475742701700273370ustar00rootroot00000000000000#g GLSL.std.450main@mainbuf0polynomialbuf1initial_xvalues_GLF_colorH#GG"G!H#GG"G!G!     ;  +  +  + @++ ;+ + }&+ @+ fff+ ̌  ;+ ?,, 6 !A"= #"A$= %$A&= '&(( )'!*+ *%!,+ ,#!-+ .,*  /.0/1+0+1+ 2), 3*,A4= 54  6) 756A8= 98 :9) ;7:A<= =< >;=  ?, @5? A9, B@A CB= D>C  E* F5E G9* HFG IH= JIC K3D L2J MKL  N2 ON3  P3 QP2 ROQ SMR TSN UDT VU2 WC  XV  YV ZS [ZC \Y[  ]\ ^X] _V^ `W_ -,`(1a,b,cabdcefe>df> dd8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_006.spv000066400000000000000000000052501475742701700273350ustar00rootroot00000000000000#v GLSL.std.450main@maingl_FragCoordbuf1resolutiondatabuf0injectionSwitch _GLF_colorG H#GG"G!H#GG "G !G !      ; +    ; +  + +    ; ++ + !;!+"+ #?+ $?+ %=6  &;''(&)*+(,*+*,*-(o .-A/ = 0/ 1.0A 2(>21)(',334,5674867989::;9<=>;?=>@?@A4B;ACBDCD=CA E4= FEA G;= HGAI= JIAK= LK ML$NJMONPQPRFHOQSFHOOTRPSQUTVUV= WE= XG>EX>GWUU==<;:?665438AY = ZYA[ = \[ ]\$^Z]_^`a`A b= cb dc%A e"= fe gf%A h= ih ji%Pkdgj#>k_aA l"= ml nm%A o= po qp%A r= sr ts%Punqt#>u__8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_007.spv000066400000000000000000000051541475742701700273410ustar00rootroot00000000000000#p GLSL.std.450main@maingl_FragCoordbuf0resolution_GLF_colorGGG G G H#GG"G!GG G G GGG! + +?+  + +@+++ !" #";#! $;$ %!&+' (+) *";*++ , -+.o:6/;-0;-1223/45 /56 756575A81 >8343 2799:7;< 7<= ><=<><A?0 >?:;: 9>@@ > AB CABDCD EE DF D FG HFGFHFAI0=JIAK0=LKMJLM EHAN0=ONAP0 =QP>NQ>POAA@C="RO!SRRA%T=!UT!VSUO&WVVO&XVV &YWXA(Z'=[Z\[. ]\n^]A_1^=`_A(a)=bacb. dcnedAf0e=gfQhV ihP&j`gi&kYj &lk="mO "nml>nA,o+>o8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_008.spv000066400000000000000000000546741475742701700273550ustar00rootroot00000000000000# GLSL.std.450main@mainicoordgl_FragCoordABC D E F G HIJres_GLF_colorG G!  +,  ;  +++ !+"+#+$+%+&+' (;(+)+*?+6,;;;;; ; ; ; ; ;;;=-O.--n/.0/>0A1=2132!43 54 ">5A6=7687#!98 :9 ">:A;=<;=<$!>= ?> ">?A@=A@BA%!CB DC "> DAE=FEGF&!HG IH "> IAJ'=KJLK!ML NM "> NAO'=POQP#!RQ SR "> SAT'=UTVU$!WV XW "> XAY'=ZY[Z%!\[ ]\ ">]A^'=_^`_&!a` ba ">b=c=dedfce=g hgifh=j kjlik=m nlm=o pno=q rpq=stsurt=vwvxuw=y=z{z|y{=} ~}|~= = = = ==x=== = = = ===== = = = ==>==== = = = = ===== = = = = ===== = = = ===== = = =    =    =   =>==== = =  =! " !=#$"#=%&%'$&=()(=*+)*=, -+,=. /.0-/=1 21302=4 534=6756=898:79;':=<=<=>?>@=?=ABAC@B=D EDFCE=G HFG=I JIKHJ=L MKL=NOMN=PQPROQS;R=T=UVUWTV=X YWX=Z [Z\Y[=] ^\]=_ `^_=ab`a=cdcebdfSe=ghgf>h=iji=kljk=mnmoln=p qop=r srtqs=u vtu=w xvw=yzxy={|{}z|=~=~= = = = ==}=== = = = = ===== = = = = ===>==== = = = = ====== = = = = ====== = = = ===   > =   =    = = = = === ! ="#"$!#=% &%'$&=( )'(=* +*,)+=- .-/,.=0102/1=342354=6=7 87968=: ;9:=< =<>;==? @?A>@=BCBDAC=EFDEG5F=HIHG>I=J=KLJK=MNLM=O POQNP=R SQR=T UTVSU=W XWYVX=Z[Z\Y[=]^\]=_=`a_`=b cab=d edfce=g hfg=i jikhj=l mlnkm=opoqnp=rsqrt^s=uvut>v=w=xyxzwy={ |z{=} ~|}= ~= = ===== = = = = ==>==== = = = = ===>==== = = = ===>== = = = = ===>=== = = = = ===>==== =  =     =     = ==== = = =  ! =" #!"=$%$&#%='(&')(=*+*)>+=,-,=./-.=01/0=2 312=4 534=6 756=898:79=;<:;===>?=>=@ A?@=B CAB=D ECD=F GFHEG=I JHI=KLKMJL=NOMNP<O=Q=RSQR=TUST=V WVXUW=Y ZXY=[ \Z[=] ^\]=_ `^_=abac`b=decdfPe=ghgf>h=i=jkjlik=mnlm=o pno=q rpq=s trs=u vtu=w xvw=yzy{xz=|}{|=~~= = = = = ==}==== = = ===>== = = = = ===== = = = ===== = = = = ===>=== = = = = ======    =     =    ==== = = =  =! " !=#$"#=%&%'$&('=)*)(>*=+,+=-.,-=/0./=1 201=3 423=5 645=7 87968=:;:<9;==><==?@?=AB@A=C DBC=E FDE=G HGIFH=J KIJ=LMLNKM=OPNOQ>P=RSRQ>S=T=UVTU=WXWYVX=Z [Z\Y[=] ^]_\^=` a`b_a=c dcebd=fgef=hihjgi=klkj>l=mnm=opoqnp=r srtqs=u vuwtv=x ywx=z {z|y{=}~|}=~=>==== = = = ===>=== = = = = ====== = = = ===== = = = = ===>=! )*P+QQQP*>8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_009.spv000066400000000000000000000072201475742701700273370ustar00rootroot00000000000000# GLSL.std.450main@mainfx(f1;xbuf0polynomialx2 buf1 initial_xvalues  x1 x0 tempABCh0h1k0paramparamk1paramparamparam_GLF_colorH#GG"G!H #G G "G !G! !  ; ! +!"# +#$ %+&@+#'+#(  ) ;) +*++}&,+-@+.fff+/̌0 10;1+2?,032**2,04*2*265;; ; ; ;;;;;;;;;;;;A%6 "$=76>7A%8 "'=98> 9A%: "(=;:> ;> *>*>*>*<<=>??=@=A B@A CB,DC+DE=E=F =GHFG>H=I =JKIJ>K=L >L9M=N>N9OPMO>P=Q >Q9R=S>S9TURT>U=V> V=W=XYWX=Z=[\Z[]Y\=^ _^&=`a_`=b cb&=decdfaeg]f>g=h=i=j kj&likmhl=nomn>o=p>p9q>q=r=st&s=u=v wv=x yx&=z{-z=|}{|~y} ~wutr>= > = > >><==,.=,/,>3>4867A%"$== &A%"'==A%"(=8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_010.spv000066400000000000000000000063201475742701700273270ustar00rootroot00000000000000# GLSL.std.450main@mainnb_mod(f1;f1;limitrefs i c ref buf0 resolution gl_FragCoordparamparamparamparami_GLF_colorG GGGGGH #G G "G !G GGGGGGGGG! ! "!!#!""+!$%  &%+%'+%( )+!* #<+!+L>,! -,+!.?,,/$$$.0! 0 1 ;1 +%23 +34 5!+!6A 7,;7 8!+39+3:+%; <,;<6 =;- ;" ;";";";";&> /A5> 24=!?>!@?6 !A@> AA8B4=!CB>C=!D >D9!EA"F 4>FEA8G9=!HG>H=!I >I9!JA"K 9>KJA"L 4=!MLA"N 9=!ON!PMOA"Q :>QP>2RRSTUU=%)V;VWSW=%A"X =!YX)ZY.[Z\[\=%=%A"] =!^]=%A"_ =!`_!a^`A"b >ba[[TT=%%'>RSA"c 4=!dc!ed.A"f 4>feA"g 9=!hg!ih.A"j 9>jiA"k :=!lk!ml.A"n :>nm=,o >o86!#7"7"p;";& >$> 'qqrstt=% )u(uvrv=% o!w=!x!ywx)zy*{z|{|=!}!~}+>~{{=% o!=!)=!ss=% %'> qr=!8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_011.spv000066400000000000000000000125001475742701700273250ustar00rootroot00000000000000# GLSL.std.450main@mainbuf0resolutionAgl_FragCoord_GLF_colorH#GG"G!GG G G G G GG G! ++  ; + ++2  + +!2" #";# $+% &";&+'+(?+)(+*++ +,<+- +.+/P+0+1+2d+3+4x+5+6+7+8+9"+:+;#+<'+=+>,+?-+@16A;BB A CD ECDFEFAG=HGnIHJ IKJLKLEK  M NMONOoP AQ>QPNNCC BERRE ST!USTVUVA$W=XWnYXZY[Z\[\U[]^]_^_  A` =a`Ab=cbdca>bd^^SS  RUA$e=fengfhg%ihjkjAl=mlAn=onpmoAq=rqAs'=tsurtP"vpu((>vikwg)xwyzyA{*=|{A}=~}|~A+=A'=P"((>xzg,A-=A=A.=A'=P"((>g/A0=A=A1=A'=P"((>g2A%=A=A3=A'=P"((>g4A5=A=A6=A'=P"((>g7A8=A=A9=A'=P"((>g:A;=A=A<=A'=P"((>g=A)=A=A>=A'=P"((>A?=A=A@=A'=P"((>xxii8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_012.spv000066400000000000000000000071541475742701700273370ustar00rootroot00000000000000# GLSL.std.450main@maincheckSwap(f1;f1;abgl_FragCoordbuf1resolution  i data buf0 injectionSwitch ijdoSwapparamparamtemp_GLF_colorG H#GG "G !H #G G "G !G! ! ; +   ; ! +!" #+$@ % &!+!' +( )( *)  + ;+ +!,+!- +. /;/+0 A+!1+2?63;& ;* ;&;&;%;;;> "445677=!8 98'9:5:=!; =!< !='<o>=A#? "=@?A>@AB ;>BA66=!C !DC,> D45>"EEFGHH=!IJI-JKFK>"LLMNOO=!PQP'QRMR=!S=!T!UT,VSUWVXWXNW=!Y=!ZA[ Y=\[>\A] Z=^]>^9_>_=`a`bab=!cAd c=ed>e=!f=!gAh g=ihAj f>ji=!k=lAm k>mlaaNN=!n!on,>oLMGG=!p!qp,>qEFAr.=srA#t ".=utvu$wsvxwyzyA{ "=|{}|0A~ 1=~0A -=0P}2>xzA 1=0A -=0A "=0P2>xx8677;%A=A# "=$==>==>=8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_013.spv000066400000000000000000000054541475742701700273410ustar00rootroot00000000000000#y GLSL.std.450main@maingl_FragCoordbuf0resolution_GLF_colorindexableG H#GG"G!G!    + + +   ; ; +A+ +  + + d+ +  ;+  +!+"?,#!!!"+$?,%$!!",&!$!",'$$!",(!!$",)$!$",*!$$",+$$$",,"!!",-!"!",.""!",/!!"",0"!"",1!""",2"""", 3#%&'()*+#,-./012 4 56 6;4=7O877A9 =:9;8:Q<;=<n >=Q?;@?n A@ B> CA DBC EA F> GEF HD IHGP JI KK LJ6MN O 6PNQORNQSRSQ TLUT VUWVWQ XL YXR ZYLVV [LSZWQ \[]\ ^]_^_Q `[ a`R ba[^^ c[Vb_Q dc edQ fc gfeR MgcNN POKRQ hLih jikjk~ lhR mlLjj nLRmkoo pnjqrQ sptsurtrur vsR qvpou>3A5ws=xw>x8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_014.spv000066400000000000000000000033541475742701700273370ustar00rootroot00000000000000#K GLSL.std.450main@mainicoordgl_FragCoordtexeltex_GLF_colorGG GG"G!G G G G G G!  +   ;+;   ; + + +!+"?#+$+%C+& ';'6(;;;>=)O*))+*>+= =,W- ,>-../011A2=32A4 =54635A7!=87968#:9"= #; $#<:;<=/==>O?>>=@OA@@B?A>B=CDC% EDPF%%GEF>G= =HWI H>I=  &> 00./=J>J8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_015.spv000066400000000000000000000165001475742701700273350ustar00rootroot00000000000000#6 GLSL.std.450main@mainbuf0injectionSwitchgl_FragCoordbuf1resolution_GLF_colorH#GG"G!G G G G G G H#GG"G!GGGGGGGGGGGGGGGGGGG G!G"G#G$G%G&G'G(GG)G*G+G,G-G.G/G0G1G2G3G4G5G6G7G8G9G:G;G<G=G>G?G@GAGBGCGDGEGFGGH!IHJ  KJL MLNLOP +PQ RJQ+JS+JT+JU VR+LWHA+LX@@,NYWX+LZЄE+L[ ף<+L\?+L]=N ^;^+P_ `L+Ja +Pb+LcA,NdcceL fe;fN g;g hN+Ji+Lj=+Lkfff?+Jl+LmL?+Ln>+Lo333?+Lp>+LqL>,Mr\\\+Ls?+Jt+Lu,Mvuuu+Jw+Lx@?,Mymmm+Jz {L |e;|+L}?+J~6HI;V=;V)A`S_=LnJ J?  O?aJ a?A`Sb=LnJ J AK=?> J ?TAK)S>SAK)T>UJAT@OASJ*ATAK)A=J+J,AwAK)*=J-AK=+=J2J3-TJG3FJE-7J4+TOE4AK=E=J5O52J6GTAK=6=J9=J:>:>9JFG6J7ETJ8GTAK=8=J;=J<><>;OG-J.A~AK).>->GJ>A,J/GwO/+J0>TAK)0>/J1>wAK)1>+J@>1=eONAhS=NNAK=i=JoLLjPMAK=l=JoLLjPMkmA`Sb=LPM MPMnoMMMM M. M QLOpJB M=JoLLjPM\q=JoLLjPMsMMMrM M. M MJBTnJAK==JO=JJoLAK=t=JJoLPNNdMO\JC M=JoLLjPMnJAK==JoLLjPMAK=w=JoLLj=JoLLjPMMMM M. M MJCTAK=T=JOnJJoLJ  oL PNNNMOxJD #MnJAK==J!oL!LjPMnJ AK = =J" oL "L  jPM s M My  M.v M MJ#DTAK=w=J$O#$AK=z=J%J&#%oL&=J'J(#'oL(PNNMNA{_=LA`S_=LA{ b=L! L"!PN#"N$# N%$QL&QL'QL(Pe)&'(L*%Y L+ *L,+ZL-,[ L. -L/.\ L0/O10]O21L32}uPe43333e5)4>58KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_016.spv000066400000000000000000000077141475742701700273450ustar00rootroot00000000000000# GLSL.std.450main@mainodd_indexodd_numberObjodd_numberseven_numbersobj even_index even_number i index jsmaller_numberuvgl_FragCoordbuf0resolutioncol_GLF_colorGGGGGG GGGGG GG GG GGGG G!G"G#G$G%G&G'G(G)G*G H#GG"G!G+!,+-  .-+-/0 10+02?+-3 45 +56 70677 8+09@+-:+0;+-< =0 >=?0 @?;@= A;A B=C0 DC+5E F0+0GzD+5H I?;I+5J K06+,L;.;1;8;. ;1 ;. ;. ;. ;1;>;D>/>2MMNOPP=-4Q3QRNR=-=0SA1T/>TS=0U0VU9>V=--:>OOMN> 3> ;WWXYZZ=- 4[/[\X\=- =0] A1^:>^]=0_ 0`_9> `=- -:> YYWX> /aabcdd=- 4e3efbf=- > =- -:> gghijj=- 4k<klhl=- A1m: =0nm=-! A1o:!=0po4qnprqsrs=-" > "rrii=-# -$#:> $gh=-% A1t:%=0ut>u=-& =-' A1v:'=0wvA1x:&>xw=-( =0yA1z:(>zycc=-) -*):> *ab=?{O=|{{AB}/==~}=|~>==OC==OC CAFE=00G 0n-A1/=0AFH=00G 0n-A1:=0A1E=0 0PCC C>=C=?O ?>AKJ>28KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_017.spv000066400000000000000000000340301475742701700273350ustar00rootroot00000000000000#T GLSL.std.450main@mainmerge(i1;i1;i1;frommidto mergeSort( k i j datatempilowhighmifrommidtoparamparamparamibuf0injectionSwitchjposvecCoorgl_FragCoord buf1 resolution!"color_GLF_colorGGGG G#G G$G G%G&G'G(G)G*G G+G,G-G.GG/G0G1G2G3G4G5G6G7G8G9G:G;G<G=G>G?G@GGAGBGCGDGEGFGGGHGGGGIGJGGKGLGMGGNGGOGPGQGRGGSGTGUGVGWGXGYGZG[G\G]G^G_G`GaGbGH#GG"G!GcGdGeGfGgGhGiGjGkGlGmGnGoGpGqGGrGsGtGuGvGwG H #G G!"G!!GxGyGzG{G|G}G~GGGGGG!  !+ +  ;  ;+ ++ +  ;+ +++++++ +@+++?++L>++?+A  ;  ;!  +  +<+Z+x+zD+++++++ ;6;;;;;";;A=nc>c=dd =eA e>=fA f>=gA g>=hA h>=iA i>=jA j>=kA k>=lA l>=mA m>=nA n>=opo>p=qq>=rr=s=tA t=uAs>u=vwv>w9 A=noP 5A=noP 5A=noPA= 5QQQQQQQQQPP P P   > = = O  A!=OQQP  >A=n !"!=#O$##A% =x%o&x '&P('')$( * ) + *>"+A,=-,.-A/">/."A0=10n213243565=7O877A9 =y9o:y ;:P<;;=8< > = ? >>"?A@=A@=B"OCBB=DOEDD FFACEQGF HGAI"=JIKJHAL">LK6AM=NMnONPOQPRSR=TOUTTAV =zVoWz XWPYXXZUY [ Z \ [>"\A]"=^] _^A`=a` bac_b=d"Ae=fe=gOhgg i1dfhQjikcjAl"=mlnmkAo">onSAp=qpnrqsrtsuvu=wOxwwAy ={yoz{ {zP|{{}x|P~P +}~   >"A=A= >A= >=A"=A">vA=nA=n=OA =|o| P    >"A=A"==}~~} 5~ A"=A">A=n=OA =o P    >"A"= A"= A"=A">A=n=OA =o P   >"=oA= >A= >=A"=A">A=n=OA =o P    >"= E="A"=  QQP   E A =  P     .  QA"=A">tQ4 ="A= QQPA=QQQP > 86777!; ; ; ;=#> #=$> $=%&%> &""#$%%=' =(&'(=) =*')*(&'()#)=+ A* +=,*=- A+ -=.+,,.-,./.=/ 0/> 0=1 21> 2A0 1=30A1/>13-/=4 54> 5=6 76> 7A2 6=82A34>38--$$"#445677=9 89=: =;9:;:89:;5;=< =<> ==> ?>> ?A< >=@<A=<>=@6645=A>A>>?@AA=B=CBBCBC?C=D=EADE=FDAE D>EF@@=GHG>H>?86 F;;;;;;;;;;>>>GGHIJJ=I=JKIJKLHL=K>KMMNOPP=L=MQLMQRNR=N>N=O=PQOPRQ>R=S=TUTVSUWV=X Y'WX>Y=Z>Z=[>[=\>\9SOO=]^]=_`_^>`MNII=aba>bGH8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_018.spv000066400000000000000000000402141475742701700273370ustar00rootroot00000000000000#{ GLSL.std.450main@maincrm22buf0one  c r m23 crm24crm32crm33crm34crm42crm43c r!m44"sums#c$r%c&r'c(r)c*r+c,r-c.r/c0r1c2r3c4r5region_xgl_FragCoord6buf16resolution78region_y9overall_region_GLF_colorGG:GG;G<G=H#GG "G !G>G?G@GAG GBG GCGDGEGFGGGHGIG GJGGKGLGMGNGOGPGQGGRGGSGTGUGVGWGXGYGGZGG[G\G]G^G_G`GaGGbGGcGdGeGfGgGhGiGGjGGkGlGmGnGoGpGqGGrGGsGtGuGvGwGxGyGGzG G{G|G}G~GGGG#GG$GGGGGGGG%GG&GGGGGGGG'GG(GGGGGGGG)GG*GGGGGGGG+GG,GGGGGGGG-GG.GGGGGGGG/GG0GGGGGGGG1GG2GGGGGGGG3GG4GGGGGGGG5G H6#G6G7"G7!GG8GG9GGGGGGGG!  ++  ; ;   ++ ; + ; ; ; ; ; ; ;! +  + +A++++ ;+ 6 6;7+@@++ ;+ ?,  6 ;;; ; ; ;;;;;;;;;;;;; ;";#;$;%;&;';(;);*;+;,;-;.;/;0;1;2;3;4;5;8;9>   =:: >=;;=<==A =A<=>=>?>>?=@A@>A  > =B B  > !!"#$$=C %C%&"&=D =E A' =('A) DE>)(##=F GF> G!"=H IH> I> **+,--=J .J./+/>001233=K4K4515=L =MA6 =76A8LM>8722=NON>O01,,=P QP> Q*+>99:;<<=R=R=>:>>??@ABB=SCSCD@D=T=UAE =FEAGTU>GFAA=VWV>W?@;;=XYX>Y9:>HHIJKK=ZLZLMIM>NNOPQQ=[R[RSOS=\=]AT =UTAV\]>VUPP=^_^>_NOJJ=`a`>aHI>WWXYZZ=b[b[\X\>]]^_``=cacab^b=d=eAc =dcAede>ed__=fgf>g]^YY=hih>iWX>ffghii=jjjjkgk>llmnoo=kpkpqmq=l=mAr =srAtlm>tsnn=non>olmhh=pqp>qfg>uuvwxx=ryryzvz>{{|}~~=ss|=t=uA =Atu>}}=vwv>w{|ww=xyx>yuv>=zz> ={ {=|=} A =A!|}>=~ ~> =>A">>#=#>$=$=#=$A=A"=A">=$>$=#>#A"=A">A">>%=%>&=&=%=&A =A"=A">=&>&=%>%A"=A">A">>'='>(=(='=(A=A"=A">=(>(='>'A"=A">A">>)=)>*=*=)=*A=A"=A">=*>*=)>)A"=A">A">>+=+>,=,=+=,A=A"=A">=,>,=+>+A"=A">A">>-   =-    >.  =.=-=.A=A"=A">=.>.   =->-A"=A">A">>/ !!=/""##>0$$%&''=0(()%)=/=0A*=+*A,"=-,.-+A/">/.&&=0>0$%  =/>/A0"=1021A3">32A4">4>1556788=199:6:>2;;<=>>=2??@<@=1=2AA=BAAC"=DCEDBAF">FE===2>2;<77=1>156AG"=HGIHAJ">JIAK">K>3LLMNOO=3PPQMQ>4RRSTUU=4VVWSW=3=4AX!=YXAZ"=[Z\[YA]">]\TT=4>4RSNN=3>3LMA^"=_^`_Aa">a`Ab=cbAd7=edfegcfng>5Ah=ihAj7=kjlkmilnm>8=8=5>9=9n=9opnoqprsr=9At"=utPvuuuQwvQxvQyvPzwxy >zqs> qq8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_019.spv000066400000000000000000000244701475742701700273460ustar00rootroot00000000000000# GLSL.std.450main@mainm22buf0onem23 m24 m32 m33 m34 m42m43m44sumsgl_FragCoordbuf1resolution_GLF_colorH#GG"G!GGGGGGGGGGGGGG G!G"G#G$G%G&G'G(G)G*G+G,G-G.G/G0G1G2G3G4G5G6G H#GG"G!G7G8G9G:GG;G<G=G>G?G@GAGBGCGDGEGFGGGHGIGJGKGLGMGNGOGPGQGRGSGTGUGVGWGXGYGZG[G\G]G^_!`_a +ab+acde fegfe h;h ie+aj+akleml+anoepoqfrlsotfulvow +wx yex zy+e{ |e+a}+a~+a+a o;+w ef ;+w+a o;+e?,o{{{ g m p q r s t u v+e=+e>6_`;;; ; ; ; ; ;;;za;bd;ca^bd^cAib=eA|;^>a^ja;ja<bd<ca]bd]kAib=eA|<]>a]ja<ja=bd=ca\bd\nAib=eA| =\>a\ja=ja>bd>ka[bd[cAib=eA| >[>a[ja>ja?bd?kaZbdZkAib=eA| ?Z>aZja?ja@bd@kaYbdYnAib=eA| @Y>aYja@jaAb dAnaXbdXcAib=eA| AX>aXja AjaBb"dBnaWb!dWkAib=eA|BW>a!Wja"BjaCb$dCnaVb#dVnAib=eA|CV>a#Vja$CjA|b>{aDb&dDcaUb% d Uc      A| DU=e  =ee >a%Uj a&Dj=ee>A|j>{aEb(dEcaTb'dTkA|ET=e=ee>a'Tja(Ej=e e! >!A|"c>"{##aFb*$d%Fc&$%'&'((aSb'))d*Sn+)*)+)A|, FS=e-,=e."e/.->"/a)Sj(+$$a*Fj#&=e0"e10>"1A|2k>2{33aGb&,4d5Gk64576788aRb7+9d:Rc;9:9;9A|< GR=e=<=e>2e?>=>2?a+Rj8;44a,Gj36=e@2eA@>2AA|Bn>B{CCaHb6.DdEHkFDEGFGHHaQbG-IdJQkKIJIKIA|L HQ=eML=eNBeONM>BOa-QjHKDDa.HjCF=ePBeQP>BQA|R}>R{SSaIbF0TdUIkVTUWVWXXaPbW/YdZPn[YZY[YA|\ IP=e]\=e^Re_^]>R_a/PjX[TTa0IjSV=e`Rea`>RaA|b~>b{ccaJbV2ddeJnfdegfghhaObg1idjOckijikiA|l JO=eml=enbeonm>boa1Ojhkdda2Jjcf=epbeqp>bqA|r>r{ssaKbf4tduKnvtuwvwxxaNbw3ydzNk{yzy{yA||KN=e}|=e~re~}>ra3Njx{tta4Kjsv=ere>rA|>{aLbv6dLnaMb5dMnA|LM=e=ee>a5Mja6Lj=ee>A=eAib=eeena7A=eena8a98ka:97d:bd:dA|:=ePo>>8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_020.spv000066400000000000000000000231101475742701700273240ustar00rootroot00000000000000# GLSL.std.450main@maindoConvert(computeColor(f1;vf2;cposition defaultColor( drawShape(vf2;vf2;vf3; pos square settingcomputePoint(mf22;rotationMatrixtempb_bs_gh_rbuf0timec1c2c3c4c5paramparamc6paramparam c7!param"param#c8$param%param&aspect'buf1'resolution()positiongl_FragCoord*center+result,i-d.param/param0param1angle2rotationMatrix3point14param5rotationMatrix26point27param8rotationMatrix39point3:param;mixed_GLF_colorH#GG"G!H'#G'G("G(!G G,G<G=G>G?G@GAGB!CBD EDFD GFHD!IHEG!JH KH!LHGGKMF NM!OHN PD;P+DQ?;P+DR@;P+DS+DT>+DU*?,HVSTU+DW@@X +XY+XZ+X[+D\?D ];]^ +^_ `Da,HbSSS ca+Dd B'F e';e( fFgD hg;h,Fi\\ j^+^k#+Dl A+Dm@+Dn #<+DoB+^p+Dq=+Dr>,Hsrrr tg;t6BCu;E1;N2;K3;N4;N5;K6;N7;N8;K9;N:;K;A`v_=Dwv Dx wDyxq>1y=Dz1 D{ z=D|1 D}|D~}=D1 D=D1 D PF{~PFPM>2=M2>49H4>3=M2=M2M>5=M5>79H7>6=M2=M2M=M2M>8=M8>:9H:>9=H3=H6 H.s>;=H;=H9 H.s>;=H;QDQDQDPgQ>86BC;K=D=DDQD=D=D=DDQDD=DPHHVHR HPHWWWH HPHQQQHPHSSSPHQQQ H+HPHH>AEY=D>AEZ=D>AE[=D>86HI7E7G=D D >>QA`_=D D D\D\D\>9BAEZ=DDQ=DD>AEY=DDQ=DD>AEZ=DAEY=DD Da\=DDW D+SQ>=D=D=DPH86H Jb86H L7G 7G 7K ;c;c;c;c;c;E;G;c;E;G;c ;E!;G";c#;E$;G%AE Y=DAE Y=DDAE Y=Da>=aa9H AE Y=DAE Y=DDAE Y=Da>=aa9H AE Z=DAE Y=DDAE Z=Da>=aa      9H    AE  Z=D AE Y=DDAE Z=Da>=aa9H AE Y=DAE Y=DAE Z=DD D! AE" Y=D#"a$!#>$=a%a&%'&('(AE) [=D*)D+*d>+=F, >,9H--'AE. Y=D/.AE0 Y=D10AE2 Z=D32D413D5/4AE6 Y=D76a857>8=a9a:9;:<;<AE= [=D>=D?>d>?=F@ >@9HAA;AEB Z=DCBAED Y=DEDAEF Z=DGFDHEGDICHAEJ Z=DKJaLIK> L=aM aNMONPOPAEQ [=DRQDSRd>!S=FT >"T9HU!"UOAEV Z=DWVAEX Y=DYXAEZ Z=D[ZD\Y[D]W\AE^ Z=D_^a`]_>#`=aa#abacbdcdAEe [=DfeDgfd>$g=Fh >%h9Hi$%ic9Hj j86HO7Nk;G&;G);G*;K+;j,;K-;G.;G/;K0Afl(_=FmlA`n(_Y=DonA`p(_Z=Dqp Dr%oqPFsrrFtms>&t=guOFvuuAfw(_=FxwFyvx=Fz&F{yz>){=F|&F}i|>*}=M~=F)F~>)=M=F*F>*>+b>,k=^<,a<_=F*=^=,oD=DlA`_=DD D DmPFSF=^>,oD>Do D Dn=^?,oD?PHn=F)>.>/>09H ./0>-=H- DBaS=H-QDQDQDPH>+=^@,^A@p>,A=H+8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_021.spv000066400000000000000000000036201475742701700273310ustar00rootroot00000000000000#T GLSL.std.450main@maingl_FragCoord_GLF_colortexG GGG"G!G!  + >+ o: +  ++ Qx?+ \B>+ ?+ ?,   ;+ ;+ C ;   ;, 6= O !  "! #"  $B#%&& '$ (')()%(  *#Q +*Q ,* -+,.-/0/ 1,+.0 2+,.. 31/20 43 543 65 763 87  9+,:9;:; <8:: =8.<;Q ># ?>@?A@A B=@@ C=:BAQ D# EDFEGFG HCFF IC@HG%% J)IFP K$J LK  ML NM=WONQ POQ QOQ ROPSPQR>S8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_022.spv000066400000000000000000000223341475742701700273350ustar00rootroot00000000000000# GLSL.std.450main@mainBSTdataleftIndexrightIndextree_GLF_colorG!     + + + + + + ++ ++++++ +  ;+ ?+!," !! ,#!! +$*%)& '(,) ,* ,+ +,,- +.,/ ,0 ,1 ,2 ,3 ,4 65;'A 6 >6)7$8899: 8;<=: ><=?>?A @: =A@BACBDEEA F:=GFHG IHJKK=LF<J>F A M >M*>IDA N: =ONPO QPRSS=TN<R>N A U >U*>QC<;TSLK9> V%9&R&JWV7WW77X$YYZZ[ Y\]^[_]^`_`A a[ =bacbdceffA g[=hgih jikll=mg]k>gA n>n+_jeA o[ =poqp rqstt=uo]s>oA v>v+_rd]\utmlZ_ w%Z&s&kxwXxxXXy$zz{{| z}~|,~A | =A |= =~>,A ,>-A | = =~>,A ,>-~}{ %{&&yyy$ .A  =A = =>.A .>/A  = =>.A .>/ %&&$ A  =A = =>A >0A  = =>A >0 %&&$ A  =A = =>A >1A  = =>A >1 %&&$ A  =    A =    = > A >2 A  = =>A >2  %&&$  ! "#$!%#$&%&A '! =(')(*)+,,A -!=.-/. 0/122=3-#1>-A 4>43%0+A 5! =6576 879::=;5#9>5A <><3%8*#";:32 % =% &9&1>=>>?$@@AAB @CDEBFDEGFGA HB =IHJIKJLMMA NB=ONPO QPRSS=TNDR>NA U>U4FQLA VB =WVXW YXZ[[=\VDZ>VA ]>]4FYKDC\[TSAF ^%A&Z&R_^?__??``a(?bcd ?ecf ?gchfichjijk$llmmn lopqn rpqsrsA tn=utQvuQwuQxuyvfzy{z{rz|fvo|xwppmr}amf{~%m&{~kkkb}r f   bfd db d deccgf `id>#>"8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_023.spv000066400000000000000000000036241475742701700273370ustar00rootroot00000000000000#O GLSL.std.450main@maingl_FragCoordbuf0resolution_GLF_colorindexableG H#GG"G!G!       ;  ; +   +  A+ +d+++  ;+ + + ?, + ?, ! , " , # , $ , %  , & , ' , (, ), *, +, ,, -, .,/!"#$%&'()*+,-.+0 1 2 6 3;1= 4O 544A6= 76 857Q 98 :9n;:Q <8 =<n>=?>@;?AAB3CDE3FDGE@HDGDHDIBJBKIJCKFEAHLB0>/A2ML= NM>N8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_024.spv000066400000000000000000000220501475742701700273320ustar00rootroot00000000000000# GLSL.std.450main@maingl_FragCoord_GLF_colorG G! + ,      ;  +++++++  ;+ + ?6= On Q ! "!#$#%$&'&(')*)+*,-,.-Q/0/10213/43546/76879/:9;:</=<>=?(@"?A+B@AC.DBCED2FE5GF8H;IGHJ>KIJL%?MLANMCON2PO5QP8RQHSRJTKSU"VU(WVAXWCYX2Z8[YZ\[;]\J^T]_%`"_a`AbaCcb5dcZed;feJg^fh"%ih?ji+kjClk2ml5nmZon;poJq2rNqs5trsut8vu;wvJxpwy"(zyA{zC|{s}|8~};~Jx{q8;Jgks8;JV+Cs8;JU_?A.s8;J`+C58;JU%?+C58;Ja.58;JB.258;JW.258;J(ACqsZH>`(+CqsZH>(+CsZH>?A.qsZH>U?A.sZH>%A.qZH>h(A.sZH>%(+C2sZH>@+.2sZH> L+  .  2  s  Z >+.2sZH>iA.5ZH> _+! ."!q#"5$#Z%$H&%>'&(_()(A*).+*2,+5-,Z.-H/.>0'/1+21.32243554H65>7_?87+98.:9q;:s<;8=<H>=>?6>@0?A.BA8CBHDC>E.FE2GFsHG8IHHJI>KDJL2ML5NM8ONHPO>QKPR@QS.TS2UT5VU8WVHXW>Y"sZYZ[Z;\[>]X\^C_^s`_Za`;baJc]bdRceUAfeCgfqhg5ihZji;kjJlhCmlqnmson8po;qpJrkqs(+tsCut2vuswv8xw;yxJzry{dz|7A}|.~}2~s8;J58;J?+Cq58;J{.25ZH>+.s8H>CqZ;JCq5Z;J`?+CqZ;J CqsZ;J1C2Z;J8C2sZ;J P >8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_025.spv000066400000000000000000000174301475742701700273410ustar00rootroot00000000000000#j GLSL.std.450main@mainmsb9msb10msb14msb15 msb19 msb20 msb24 msb25 msb29msb30ibuf0resolutionAgl_FragCoorduselessOutVariableResType_GLF_colorH#GG"G!GGGG GG!  +++@+ +!+"+#+$+% +&@+'( )() *;*+ ++, -(.+/++021(0 21 3(+4+56( 76;7 8(++9 :++++;2 <6;<+(=?+>(+? +@<+AP+Bd+Cx+D+E"+F+G#+H'+I+J,+K-+L16M;;;;; ; ; ; ; ;;;2;:>>>> > !> "> #> $> %>&N'''>NOOPQRR=SA-T',=(UTnVU.WSVXWYXYPX I/=Z [J/\Z[]\=^._]^`_a`a=b I/cb=do(edA3fc>fe``=ghg4>hQQ=ij5'''.kijkOPP I'>llmnoo=pA8q,=(rqnsr.tpsutvuvmu=w xJ'.ywxzy{z{=|=}|+~}~9Q+>Q+|A3=(A3|=((A3|>zz=4>nn=;'''.lmmA8,=(n= I.'A3=(A-',=(( J/A3=(A-'9=((P6==>A8,=(n>'''. I?A3=(A-',=((= JA3=(A-'9=((P6==>A8,=(n@'''.= JA3=(A-',=((= IA3=(A-'9=((P6==>A8,=(nA'''.= IA3=(A-',=((= JA3=(A-'9=((P6==>A8,=(nB'''.= JA3=(A-',=((= IA3=(A-'9=((P6==>A8,=(nC'''.= IA3=( A- ',=(  (   =  J A3=(A-'9=((P6 ==>A8,=(nD'''.= JA3=( A-!',=("!(# "$E'''A3%$=(&%A-''9=(('()&(P6*#)==>*A8+,=(,+n-,.F'''./-.0/1213G'''A343=(54A-6',=(76(8579H'''A3:9=(;:A-<'9=(=<(>;=P6?8>==>?02A8@,=(A@nBACI'''.DBCEDFGFH>'''A3IH=(JIA-K',=(LK(MJLNJ'''A3ON=(POA-Q'9=(RQ(SPRP6TMS==>TEGA8U,=(VUnWVXI'''.YWXZY[\[]K'''A3^]=(_^A-`',=(a`(b_acL'''A3dc=(edA-f'9=(gf(hegP6ibh==>iZ\ZEE008KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_026.spv000066400000000000000000000227201475742701700273400ustar00rootroot00000000000000#\ GLSL.std.450main@mainBSTdataleftIndexrightIndex makeTreeNode(struct-BST-i1-i1-i11;i1;treedata insert(i1;i1; treeIndex data search(i1; targethueColor(f1;anglemakeFrame(f1;vbaseIndextreeparamparamparamparamindexcurrentNodenodeDataparamcolorparamparamparam param!treeIndex"param#param$param%param&param'param(param)param*param+param,param-param.param/param0param1param2param3param4param5param6zgl_FragCoord7buf07resolution89x:param;y<param=sum>target?result@paramAa_GLF_colorBparamHHHGG G G G GCGGDGEGFGGGHGIGJGKGLGMGNGOGPGQGRGSGTGUGVGWGXGGYGZG[G\G]G^G_G`GaGbGcGdGeGfGgG!GhGiGjGkGlGmGnGoGpGqGrGsGtGuGvGwGxGyGzG{G|G}G~GGGGG H7#G7G8"G8!G=G>GG?GGGGGGGGGGGGG!   !!! !!++++ +  ;  + +?+@++++@+?+d+@++ A+ ++ ++++   ;7 7;8 +++ ;6;!;";#;$;%;&;';(;);*;+;,;-;.;/;0;1;2;3;4;5;6;9;:;;;<;=;>;?;@;A;B>!A=>">#9"#="A>=h!ih>!i=j!>$j>%9 $%=k!lk>!l=m!>&m>'9 &'=n!on>!o=p!>(p>)9 ()=q!rq>!r=s!>*s>+9 *+=t!ut>!u=v!>,v>-9 ,-=w!xw>!x=y!>.y>/9 ./=z!{z>!{=|!>0|>19 01=}!~}>!~=!>2>39 23=!>!=!>4>59 45=OA8=>6A6=>:9:>9A6=><9<>;>=>>=>=>>@9 @>?=?=?==>==?==>==>>>=9=;==o >A=A>B9BQQQP>8677=CA>CA>A>86 7 7 ;;;;;>=D=E DE=F =GAG=HFH=IA I=J  J     =K=L AK>L=M AM=>=N >N9=AM> =OAO=P>P =QAQ=RR=S=T AS>T=U AU=>=V >V9=AU>=WA W=X >X86 7 !;;;">##$%&&=Y'Y'($(=ZA)Z=*)>*A+=[+=\ ,[\-,.-.=] ]-=^ A/=_/0^_10232A4=`4>"`13A5=a5>"a11=b">b%%#$8676;;;;>9c o7c>7=8=9P:9;:8 < ;P=P> ?+<=>>?>9d o@dA@BA CBAD=EDFECAG>GF=HH867I;;; =JKJ>K=LMLNMONO>9e oPePN=QRQSRTSTS=U>9f oVfWUVXWYXYX> 9g oZg[Z[8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_027.spv000066400000000000000000000223301475742701700273360ustar00rootroot00000000000000# GLSL.std.450main@maindatatempbuf0injectionSwitchgl_FragCoord buf1 resolution _GLF_colorGGH#GG"G!G G G GG H #G G "G !GGGGGGGGGGGGGGGGGGG G!G"G#G$G%G&G'G(G)G*G+G,G-G.G G/G0G1G2G3G4G5G6G78!98:  ;:+:<=> +>? @:?+: +:A+:B +:CD EDE F;F+>G HD+:I+:J+:K+:L+:M+:N+:OPDQP+DR@+DS+>T+DU?+DV+DWL>+:X+DY?+DZA[D \[;\ E ] ;]  ^E _D+:`+:a<+:bZ+:cx+DdzD+:e+:f+:g+:h+:i+:j+:k l[;l m@,EnYY,Eodd689p;m;mAHqAG=Drqn: rss:, p tutvvw,wxyz{|}~ A;,>OwA;,>NwA;,>Mw~A;,>Lw}A;,>Kw|A;,>Aw{A;,><wzA;,>CwyA;,>JwxA;,>Iww: ,<tt= suu:-Au=-A;-=: A;-> :-<:.<=.B:/A=/B:/.:<:C.:/:< :'B:6/":32:1/0=1=3=A;1=: A;3=:!= !:"6<:%3<=:&A;6>&:#1<=:$A;6>$:23%:0#1:76':41(=4=4=:'7<:(4<A;4=:)A;7>):5/+=5A;5=:*A;5>*:+5<:C.AHAT=Dn:oDPPRS D5UCPPPSV D5WXPPPYZ D5APPQ=[OEA^ A=EOEEQDQDPPYP PA_T=Dn:=`=a=b=c=e=f=g=h=jOEA;k=:oD DPEE E  E  PEQD D QD PP   P E PP rrr P .  QD D REOEA;i=:oD DPEE E E oD = DA_G=D  D! D"!QD#D$#"RE%$OE&A;'X=:'oD( D)(PE*))E+&* E, + E- ,QD.- D/.QD0- D10D2/1D302RE43-OE5A;6I=:6oD7 D87PE988E:59 E; : E< ;QD=<:K, D>5=D?> D@?DA=@REBA<OECA;DJ=:DoDE DFEPEGFFEHCG EI+Hno EJI EK JA_LG=DML=NMONPQQ DROP DSMOODTSPRQQDUKDVUTREWVKOEXA;YC=:YoDZ D[ZPE\[[E]X\ E^ ] E_ ^QD`_ Da` DbDcabA^dA=EedOEf Eg1_efQDhgDichDj`iREkj_OElA;m<=:moDn DonPEpooEqlp Er q Es rA^tA=EutOEvss EwFuvlQDxw DyxQDzsD{zyRE|{sOE}A;~A=:~oD DPEE} E  E DREE|kWOB4% DQDQDP[>8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_028.spv000066400000000000000000000077741475742701700273560ustar00rootroot00000000000000# GLSL.std.450main@mainbuf0injectionSwitchgl_FragCoordbuf1resolution_GLF_colorH#GG"G!G H#GG"G!G !     ;  + +  + fff+ ?+  ; ; + + >+ A+ @?+ L?+ 333? !;!+ "?+ #=+ $>,%$"+ &>6  '())=*O +**A,= -,P .-- /+.Q 0/1021323Q 4/ 540 65  76A8= 98A:= ;:<9;=<>?> @7 A@9=? B7 CB9== DA>C? E7D  F1EPG4PH 4PIFFF J.GHIQ KJQ LJQ MJPNKLM>N(2O0"P1QPORQSRSQ T/ UT0 VU  WVAX= YXAZ= [Z\Y[]\^_^ `W a`Y]_ bW cbY]] da^c_ eWd  f1ePg"T#Phfff i.g%hQ jiQ kiQ liPmjkl>m(Rn0oOpPoqpnrqsrsQ t/ ut0 vu  wvAx= yxAz= {z|y{}|~~ w y} w y}} ~ w  1  tP tP&"tP .Q Q Q P>(r0npQ / 0   A= A=        1PP0P .Q Q Q P>(((8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_029.spv000066400000000000000000000045441475742701700273470ustar00rootroot00000000000000#a GLSL.std.450main@maincoordgl_FragCoorduvstepresi j tex indexable_GLF_colorG GG G G G G "G !GGGGGGGGGGGGGG!    ! ;!+"; # $ +%, &%%%%'  ('+')+'*+ ,-, .-;. +'/0 +01 21+3?+4?+5+6+7, 28345436567 92 : ;:;6<;;#;$;(;( ;9 = =O>==?>">?>">&>)@@ABCC=' +D *DEAE> )FFGHII=' +J *JKGK=- =L=''/oM=NOMN=' '/oP=QRPQPSORTLSW UT=''*=' '> 8A#V =WV XUW= Y ZYX>ZHH=' '/> FGBB=''/>@A= [O;\[[Q]\Q^\Q_\P `]^_3>`8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_030.spv000066400000000000000000000050101475742701700273240ustar00rootroot00000000000000#j GLSL.std.450main@maincollatz(i1;vcountlingl_FragCoord buf0 resolution  v_GLF_color param indexableG H #G G "G !G!  !++++   ;   ;  +A + ! "+#+ $ %;%+ &'&+(+)?,*((()++?,,+((),-(+(),.++(),/((+),0+(+),1(++),2+++),3)((),4()(),5))(),6(()),7)()),8())),9)))),':*,-./012*3456789+; <' =6>;; ; ;< =?O@??AA =BAC@B>C=DED FE>FA"G!=HGnIHJI#A"K$=LKnMLNJM> N=O > O9P QP;> :A=R Q=SR>S867T;>UUVWXX=YZYZ[V[=\]\^]_^`a`=bcbdc>d_a=efe>f__=ghg>hWWUV=ii8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_031.spv000066400000000000000000000137041475742701700273360ustar00rootroot00000000000000#  GLSL.std.450main@maintrace(vi2;posindexableindexable p indexable posgl_FragCoord buf0 resolution ipos_GLF_colorparamG H #G G "G !G!   ! + ++++ s+!+"+#+$+%+&+'+(+)+*+++,+-+.+/+0~+1x+2t+3r+4u+5y+6+7+8+9+:+;+<+=+>+?|+@q+Ag+B^+CW+DR+EO+FP+GT+H[+Ie+J+K+L+M+N+O+P+Q+R+S+T+U+V+W+X+Y+Z+[+\+]+^+_+`+a+b+c+d+e}+fi+ga+h]+ib+jj+k+l+m+n+o+p+q+r+s+t+u+v+w+x+y+z+{+|+}+~++++v+D+:+1+++(+)+,+3+=+I+w++++h+V+Q+M+L+Y+f+\+S+>+2+&+++++++ ++!+0+@++{+p+d+Z+A+C+F+K+_+X+E+/+$++ +++ +-+<, !"#$%&'()*+,-./01233456/789:;,<=>./?@ABCDEFGHI3JK#LMNOPQRRSTUVWX&Y+Z,<;#[\]^&_``'aYb<cde3fghHhij4Jk<l_mnopTqrstuvw*[x87yz{zy|.}>9~~KjhFCA/c;*a*\#-72BFGBiii37>x<<x/CgIAEB  +pA+?++,  ;  ;  +C ;6; ;;=OA => A =nA =nP>=>9>867;;; ; A=A=A=>A=A=A=>A=A=A=> A =o > = = = P  A =    >  8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_032.spv000066400000000000000000000261641475742701700273430ustar00rootroot00000000000000# GLSL.std.450main@mainbuf0injectionSwitchgl_FragCoordbuf1resolution_GLF_colorH#GG"G!G G H#GG"G!G G G G GGGGGGGGGGGGGGGGGGGG G!G"G#G$G%G&G'G(G)G*G+G,G-G.G/G0G1G2G3G4G5G6G7G8G9G:G;G<G=G>G?G@GAGBGCGDGEGFGGGHGIGJGKGLGMGNGOGPGQGRGSGTGUGVGWGXY!ZY[ \[] ^ +^_ `]_ a]+]b\ c;c+]d+^e f[+^g+]hi+]jk[ lk;l m[+]n+[off>,\poo+[q@+]r +]s+]t +]u+]v+]w +]x +]y+]z+]{+]|+]}+]~\ ;+[?+[@[ k;*i)i `[]+[.h?\6YZ;5;4;3;2;1;0]@d i@ti@dAa0@>ni@hAa0@>ji@nAa0@>ui@jAa0@>vi@bAa0@>wi@uAa0@>xi@yAa0@>zi@vAa0@>{i@|Aa0@>}i@rAa0@>~] @h=kO\Afdg=[P\\Afde=[[P\\\]Ab\Afde=[Q[ [0Q[[R\ [ [ ]JA [5[[R\]AhAfdg=[n]i]Bj\Q[ [0o[[Q[[R\iAme=[ [Amg=[ [[[R\]Bhi]Cn\Q[ [0[o[[Q[[ R\  [  i     ]J  ]J  ] [5[R\ ]Chi]Dh\Q[ [0[[o[[Q[[ R\ ]Dhi!"!"" \# $g%% \&1pp#Am'e=[('[)(qn]*)+ *+,-./0,Q[1& [21 [3.21o+-Q[4# [54Q[6& [7.56o+./Q[8# [98 [:.98o+0Q[;& [<;Q[=& [>.<=o++ [?%3,7-:/>0 i@%,-/0A@$AA[B$$[C?+BAPDCCC[EiF(EGFHIH=`J0>1JAaK0b=] KLgMMNN]LrMKO]JdMIOiPJLQOPRQR]JL]nAaS1=]SiT UTVUVQU=]SiW XWYZY]hXZ]hXX]KLYZ]IYJZOONQ]8NVi[NV\[L\\LL]98Qs\n]]~]^]i_9^`_a`a=`b0>2bAac0d=] cdgeeff]PreOg]NdeMgihNPighjij]NP]nAak2=]kil mlnmnim=]kio poqrq]hpr]hpp]OPqr]MqNrggfi]:fnisfntsdttdd];:istn]u~]vuiw;v``ix_Lwdyxz{z=`|0>3|=] K}g~~]Tr~S]Rd~QiRT]RT]nAa3=] i =]!i! ]"h]#h]ST#]Q"R]<i}}}]=<so[==`0>4Aa0d=] g]XrW]VdUiVX]$VX]%$nAa4%=]&i& =]'i' ](%h])%h]WX)]U(V]>%i]?>so[?[O\DDP\\ODy{yGI=`0>5g]HrG]FdEiFH]*FH]+*nAa5+=],i,h=]-i-h].+h]/+h]GH/]E.F]6+i]76si7sO\DD\ODGGyQ[Q[Q[Pk>8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_033.spv000066400000000000000000000160141475742701700273350ustar00rootroot00000000000000#9 GLSL.std.450main@maingl_FragCoordbuf0resolutionmap_GLF_colorG H#GG"G!G!       ;  ; +   ++ A +++,)+++ *!+" # ;#+ $?, %$$$$+ &, '&&&$ (+) 6 *;(+,,= -O .--A/= 0/ 1.0Q 21 32n43Q 51 65n76889,:;<9=;<;=;A>9>>:98=??@=ABC=DBE=FBGBHHIEQJ@KJLKMLMNJQO@POQNPARQ=SRTSLLUKHTMVUQW@XWYXZYZ[W\[]J\A^]=_^`_YYaXL`ZbacbcdVbbeVYdcfJ gfhghiJjWkijAlk=mlnmggofbnhpoqpqreppsegrqtW utvuvwWxwyJxAzy={z|{uu}tp|v~}~s~~su@!"")A=RRQQA>IIKJWA=WJA>JA>JA>R@@QQQA=QQA>A>A>RQ QQA=QQA>A> A  > R     Q  Q Q A=  Q! Q" #"$!#A%$>%&"'&(!'A)(>)*"+*,!+A-,>-R.* / . A/FIDC07104A21=324354656>%G5BBD?GG76!B87+88>'++8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_034.spv000066400000000000000000000025141475742701700273360ustar00rootroot00000000000000#7 GLSL.std.450main@maingl_FragCoordtex_GLF_colorG GG"G!GGGG G GG  !  + +;,+< ;  ;+ + ;+=+?6   =!O"!!#"=W$#Q$%#&W'%Q'(()% *+  +,& -+. +/.,0 1/02+1+2+*)-,W3*Q 3 (2o4 54P6555>68KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_035.spv000066400000000000000000000012101475742701700273270ustar00rootroot00000000000000# GLSL.std.450main@main_GLF_colortexgl_FragCoordGGG"G!GG !     ;    ;  ; + ;6= = OW >8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_036.spv000066400000000000000000000054701475742701700273440ustar00rootroot00000000000000#z GLSL.std.450main@maingl_FragCoordbuf0resolution_GLF_colorindexableG H#GG"G!G!    + + +   ; ; +A+ +  + + d+ +  ;+  +!+"?,#!!!"+$?,%$!!",&!$!",'$$!",(!!$",)$!$",*!$$",+$$$",,"!!",-!"!",.""!",/!!"",0"!"",1!""",2"""", 3#%&'()*+#,-./012 4 5 66 7;4=8O988A: =;:<9;Q=<>=n ?>Q@<A@n BA C? DB ECD FB G? HFG IE JIHP KJ LL MK7NO P 7QORPSORTSTQ UMVU WVXWXQ YM ZYR [ZMWW \MT[XQ ]\^] _^`_`Q a\ baR cb\__ d\Wc`Q ed feQ gd hgfR NhdOO QPLSQ iMji kjlkl~ miR nm6kk oMSnlpp qokrsQ tqutvsusvs wtR rw6pv>3A5xt=yx>y8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_037.spv000066400000000000000000000141601475742701700273410ustar00rootroot00000000000000# GLSL.std.450main@mainBSTdataleftIndexrightIndex makeTreeNode(struct-BST-i1-i1-i11;i1;treedatainsert(i1;i1; treeIndex data search(i1; target baseIndextreeparamparamparamparamindexcurrentNodetreeIndexparamparamparamparamparamparamparamparamparamparam param!param"param#param$param%param&param'param(param)param*count+i,result-param_GLF_colorG.!/.0 000 1 20!3.12!4.22!502+06+07+08+09:; +;< =< >=;> ?0 @+0A +0B+0C +0D+0E+0F+0G+0H+0I +0JK LK ML;M+KN?+KO,LPNOON,LQOONN6./R;2;1;2;2;2;2;2;2;2;2;2;2 ;2!;2";2#;2$;2%;2&;2';2(;2);2*;2+;2,;2->6A@S6=TS>T>A9.U=VA@W6>WV=0X0YX7>Y=0Z>Z>B9.[=0\0]\7>]=0^>^>C9._=0`0a`7>a=0b>b>D9.c=0d0ed7>e=0f>f>E9.g=0h0ih7>i=0j> j>!F9.k !=0l0ml7>m=0n>"n>#99.o"#=0p0qp7>q=0r>$r>%G9.s$%=0t0ut7>u=0v>&v>'H9.w&'=0x0yx7>y=0z>(z>)I9.{()>*6>+6||}~=0+:J}=0+>-90 ->,=0+   =0,:8=0*07>*=0,=0+:=0*07>*~~=0+07>+|}=0*:J>P>Q86.37172=0A26>A27>8A29>886.472 72 ;2 ;1;2;1;2> 6=0 =0 :=0 =0 A?6=0:=0 A?7=0:8=0 =0 A?7>=0 A@=>=0 >9.=A@>=0 A?7=0> =0 A?9=0:8=0 =0 A?9>=0 A@=>=0 >9.=A@>=0 A?9=0> 860 572 ;2;1;2>6=0:8=0A@=>A26=0=0 :=0 =0 A26=0:A29=0>A27=0>=0>88KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_038.spv000066400000000000000000000071001475742701700273360ustar00rootroot00000000000000# GLSL.std.450main@mainnb_mod(f1;f1;limitrefmsb8 msb8 s buf0 resolution  imsb8crefgl_FragCoordparamparamparamparami_GLF_colorH #G G "G !G G! !  ;+     ; +!" +"# $+% &+' #<+(L>+)* +*+, -*;- .+"/+"0+1? 2*;263;;+;;;;;;>>4!!!o54=676o87P*95,,8>9A$: !#=;:=< =I<o>=?;> @?>@A.A#=BA>B=C>C9DAE#>EDA.F/=GF>G=H>H9IAJ/>JIAK#=LKAM/=NMOLNAP0>POQ!!!RQ>RSSTUVV=WAXW=YX&ZY1[Z\[\=]=^A_^=`_=aAba=cbd`cAe]>ed[[=fgf)>gUU=h=i jIi kJj&lhklSTTAm#=nmon1Ap#>poAq/=rqsr1At/>tsAu0=vuwv1Ax0>xw=*y>y8677z; ; ; > A${ !#=|{n}|~}!!o~> = > = = %!!&= o=&'= (> = o=&= = )> = 8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_039.spv000066400000000000000000000065441475742701700273520ustar00rootroot00000000000000# GLSL.std.450main@maincbuf0resolutiongl_FragCoord_GLF_colorH#GG"G!G G!    +  + +  +  + + >+  #<+ B  + @+ A+ A,  ; +   !  "!;" # +$+%+ &+ '? (!;(*))* ++ ,>6 -;>A .= /. 0/,  10A#2= 3245566 7 589 :5;9<:=9<>=> ?:@?A@BCB D7ACo E:  F1 GEFHGIHJIJ K7II L7CKJAA 8DBLIo M:NM3ONPOP=O99 ;:6= Q+68P R768PS)6*PTS4TT44 UQ=RTA V>VUA#W$= XWYZZ[[ \ Z]^ _Z`^a_b^acbc d_edfeghg i\fho j_  k1 ljkmlnmono p\nn q\hpoff ]igqno r_srXtsutubt^^ `_[b v+[]u w\[]ux)[*uyxYyyYY zvbwyA {$>{z= |V= }{ ~|}A %>~ Y&A = '= =  > =  EQ Q Q P!'>8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_040.spv000066400000000000000000000063241475742701700273360ustar00rootroot00000000000000# GLSL.std.450main@maincompute_value(f1;f1;limitthirty_tworesult i c thirty_two buf0 resolution gl_FragCoordparamparamparamparami_GLF_colorH #G G "G !G G! !+  ++ + ++ >+! #<+"B# $#+%@+&A+'A,#(%&') ) * ;* + ++, -. /.;/ 0++1++2+3+4? 5.;566;$ ; ;;;;;> (A-7 ,=8798& :9> :A0;,=<;><== >=9>A? ,>?>A0@1=A@>A=B >B9CAD 1>DCAE ,=FEAG 1=HGIFHAJ 2>JI>KKLMNN=OPO3PQLQ=RAS R=TSUT4VUWVW=X=YAZ Y=[Z=\A] \=^]_[^A` X>`_VVMM=aba>bKL=#c #dc #eEdQfeQgeQheP.ifgh4>i8677j;; >> kklmnn=o popqlq=r srtsutvwv=xyx >yuw=z o{z=| }|~{}~!=">uu= o==mm= > kl=8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_041.spv000066400000000000000000000064401475742701700273360ustar00rootroot00000000000000# GLSL.std.450main@mainbuf0resolutiondatagl_FragCoord_GLF_colorH#GG"G!GG G G G G G GGGGGGGGG!   ;+ +  +!+"=+#?+$>+%@+&@+'+()+*+++,-, .-/ 0/;0 1 2,3'''+4 5/;5+6?+7=,8777+9?+:L@+; ף<+<<+=;6>;.??> @)A+B@ACBCDDC E)F+GEFHGH+ A1I!=JI *oK LJKA1M=NM *oO PNOQ!RRA S=TSA U!=VUWL"XV#YWXZP"[T$\Z[]V9^Y]_^:`_Va`$bT9c\bdc:edVffRgh'Rigj'RkgRg)l(mglnmnojjphhqop)rq&srtstmsuopkuav%jwvhiwe*gg*fm)x(yxz{{|LV}PTP~|'}Qzo;<=PQyQz~{A2 >EE *DG@@ *?B3BB)4A2=*8QQQP/6>8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_042.spv000066400000000000000000000144701475742701700273410ustar00rootroot00000000000000#+ GLSL.std.450main@mainibuf0resolutionA igl_FragCoord_GLF_colorGG G H#GG"G!G G GGGGGGGG GGG GGGGGGG!   +!+"#$ %$% &;&' +'( )$+*+'+2,$+ -, .$+/+021$ 21;2 3$+4 51;5+'6+$7?+8(+9+: +;<+< +=+>P+?+@+Ad+B+Cx+D+E+F+G+H"+I+J#+K'+L+M,+N-+O16P; ;-; >!QQRSTT= #U "UVRV= A)W!(=$XWnYX#Z Y[Z\[\R[=  ** =#]^]_^_=*=o$`A.a>a`^^SS=/>QR> !bbcdee= #f0fgcg= A3h(=$ihnji#kjlkmlmcl= #n!onpop= = /A.q=$rqA.s=$ts$utrA.v>vuoodd= /> bcA3w(=$xwnyx#zy4{z|}|A.~!=$~A)!(=$$A.*=$A)!6=$$P177>{}A3(=$n#8A.9=$A)!(=$$A.:=$A)!6=$$P177>A3(=$n#;A.<=$A)!(=$$A.==$A)!6=$$P177>A3(=$n#>A.?=$A)!(=$$A.@=$A)!6=$$P177>A3(=$n#AA.4=$A)!(=$$A.B=$A)!6=$$P177>A3(=$n#CA.D=$A)!(=$$A.E=$A)!6=$$P177>A3(=$n#FA.G=$A)!(=$$A.H=$A)!6=$$P177>A3(=$n#IA.J=$A)!(=$$A.K=$A)!6=$$P177>A3(=$n #  L     A.8=$A)!(=$$A.M=$A)!6=$$P177>  A3(=$n#LA. N=$! A)"!(=$#"$$!#A.%O=$&%A)'!6=$('$)&(P1*$)77>*  {{8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_043.spv000066400000000000000000000040441475742701700273360ustar00rootroot00000000000000#\ GLSL.std.450main@maingl_FragCoordbuf0resolution_GLF_colorG H#GG"G!G!    + + + +   ; ;  + 333?+ >+ ?+ fff?+ =+ > ;+ ?,,+ L+ !?+ "̾+ #+ $̽6%=&O '&&A(= )( *')+ ,,Q -* .-Q /* 0/ 1.! 2 0 312 4- 5/ 64# 7"5 86793:8;9:<;=<>=>?3@8A?@==B;,A>CBDCEDE+D F- G/ HF$ I!G JHIKJL9KMLNMONOP3QJRPQNNSLDROTSUTVUV+U++ WEVUXWYXZ[Z>Y[>YY8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_044.spv000066400000000000000000000050441475742701700273400ustar00rootroot00000000000000# GLSL.std.450main@maingl_FragCoord_GLF_colorG G!     ; + ; + +>+ +? +,+ @+UU?,+C+ + +   ;+? , ,!+"+#+$ +% +& ,'+(+) +*++ +,6-= .Q/.Q0.P1/021 Q324354676Q8298:9;<;=2>=?>m@?Q A@Q B@ CAB DA ECD FE GCD HG IHJI  KJ  LFML  NM  OKNpPOP QPPP>Q:<R2 SR!TSnUTQVUWV"XW#QYUZY$[Z"\X[]YY^]%_^#`VYa`&ba#cb_odce_\ofegb\ohgP idfh>i::57j2kj'lknmlQnmQompnoqporq%sr#ts(uq)vu*wv(xq+yx,zy({t|w}zP ~{|}>~558KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_045.spv000066400000000000000000000111101475742701700273300ustar00rootroot00000000000000# GLSL.std.450main@maingl_FragCoordbuf0resolution_GLF_colorG H#GG"G!G!     +  + + +   +    ; ; +?+@+@@,+>+ ?+ !+"@?+ #+ $+ %+ &+ '+ ( );)+ *6+;,;-.. /+012/312131 4/A 5,/>54= 65= 75 867>58 0/.3A 9->9A :->:;; <3=>?<@>?A@A B<A C-<= DC E<!A F-B= GFA H,D= IH JGKK LJAMN OGAPN QDROQSNRTSTA U,O= VUWVIXWYXY ZLA [,Z= \[= ]U>[]>U\XX MLTZYNN POKS ^LA _,^= `_= aH>_a>H`bLGcbdcd e<*A f-e>fG>CLcc gb<E hL!ihDjikjk lgA m-l>mh ng!A o-n>oDjj =gcnk>>;@=pOqppAr=srtqsA u,= vuowvxwRyxQzt{z|{}|}A ~,= ~oxRy||y@}z A ,!= oQR|z"A ,#= oQRA ,$= oQRQtA ,%= oQR A ,&= oQR"A ,'= oQRA ,(= oQRz A ,= oQR EQQQP>8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_046.spv000066400000000000000000000132701475742701700273420ustar00rootroot00000000000000# GLSL.std.450main@mainm22buf0onem23 m24 m32 m33 m34 m42m43m44sumsgl_FragCoordbuf1resolution_GLF_colorH#GG"G!GGGGGGGGGGG H#GG"G!GGGG GG!G"G#G$G%G&G'G(G)G*G+G,-!.-/ +/01 +12+134+156 76876 9;9 :6;6<;=6>=?7@;A=B7C;D=+1E+/F+/G H6G IH+6J K6 L=;L M67 N;N+1O+1P Q=;Q+6R?,=SJJJR T8 U< V> W? X@ YA ZB [C \D+6]>+6^=6-._;\;[;Z ;Y ;X ;W ;V ;U;T;I``1#2_a/"0_+a4b#3cabdcdee/+"df1)2df4g)3hfgihijj1*5ik4l*#mklnmnoo1,5np4q,)rpqsrst+tuvwxyz{|}uA:~5=6~AK*,>tvA:5=6AK*,>twA:5=6AK *,>txA:5=6AK *,>tyA:5=6AK *,>tzA:5=6AK *,>t{A:5=6AK *,>t|A:5=6AK*,>t}A:5=6AK*,>ttpp1,Eorkk1*Ejm/+Fff1)Eehaa1#E`c1$2c1!5c&4$31&!1%24%3AK&>J1'54'$1(54(%&AK'(=6=66>AK'(=6=66>AK '(=6=66>AK '(=6=66>AK '(=6=66>AK '(=6=66>AK '(=6=66>AK'(=6=66>AK'(=6=66>1(E1'E=66^>1&E1%E1$EAM0=6A:50=66]6n1AMF=66n11O1 4 54 P4AK =6P=R>>S8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_047.spv000066400000000000000000000062201475742701700273400ustar00rootroot00000000000000# GLSL.std.450main@main ReallyApproxNormalizedAtan2(vf2;vpolarize(vf2;coord pi2 a z th centerdistangleparamcoordgl_FragCoordparam_GLF_colortexG GGG"G!GG!  !! +>+o: +!" +"#+"$+%Qx?+&\B>+'?+(?,)''* +*;++,;+-C .*;. /0/ 10;1263;;=*4O54465,>6=7>798>8=9:9- ;:P<--=;<>==0=>W*?>O2??Q@QAQBP*C@AB(>C867D; ; ; ; > =E FBE GFHGIHI!H=J KJ> KAL #=MLAN $=ON PMOQPRSRAT $=UTAV #=WVXUW> XQSAY #=ZYA[ $=\[]Z\> ]QQ=^ _&^=` a_`b%a=c dbc=e fde> fAg #=hgAi $=ji khjlkmlm=n o'n> ollAp$=qp rq!srtst=u v(u> vssAw#=xw yx!zy{z{=| }|> }zz=~ ~867; ;;;=)> = B>= >9>==P8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_048.spv000066400000000000000000000110441475742701700273410ustar00rootroot00000000000000# GLSL.std.450main@maincheckSwap(f1;f1;abgl_FragCoordbuf1resolution  msb10 msb9 i buf0 injectionSwitchdatauselessOutVariableResTypeijdoSwapparamparamtemp_GLF_colorG H#GG "G !H #G G"G!GGGG! ! ! "!;"# +#$ %&& ';' ( +() *++@ , -(+(.+(/ & 0 ;0+#1+#2 32 43 5###+(6 7!;7+8 A+(9 +:?6;;- ;- ;- ;4;5;-;-;,;;;> .> /A*<)1==<n(>=(?>> ?@@ABCC=(D =(E (FJEGDFGHAH=(I =(J |#KJL2KQ#ML>MQ#NLpONA*P)$=QPROQASI>SRBB=(T (UT6> U@AA*V)1=WVn(XW()A*Y)1=ZYn([Z(\X[>\]]^_``A*a)1=ban(cb(dc))>deefghh=(i=(j (kIjliklmfm=(n|#on=(p|#qprq$Q#sr>sQ#truotvuwvwgv=(x=(yAzx={z>{A|y=}|>}9~>~==(A=>=(=(A=A>=(=A>gg=((6>ef=((6>__=(=( (J]^^A%1=A* )1=+ (J6A=8 (I9A=8=( (JA=8P!:> (I9A=8=( (JA=8 (J6A=8P!:>86 77;,A%$=A* )$=+==>==>=8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_049.spv000066400000000000000000000164141475742701700273500ustar00rootroot00000000000000#I GLSL.std.450main@mainswap(i1;i1;ijperformPartition(i1;i1; l h quicksort( temp QuicksortObject numbersobjpivotijparamparamparamparamlhtopstackpparamparamiuvgl_FragCoordbuf0resolution !color_GLF_colorG H#GG "G !G"!#"$  %$!&"%%!'$%%( +() *$) * + ;++$, -$+$./+$0 +$1 2*+$3 4 54 6574 87;85 9;9  :5;4 <;+4=?+4>@+4?@@,;@=>?+(A B4+4C>+4D?+$E+(F+4G@?+$H+(I+$J+$K+$L+$M+$N O7;O6"#P;%;6;<!>,QQRSTT=$U/VU3VWRW=$X=$Y$Z3YA-[,X>[Z=$\=$]A-^,]=$_^=$`A-a,`=$ba$c_bA-d,\>dcSS=$e$fe.>fQR9"g =7hO5ihhA:j ,=5kj5lik>l>!@A-m,,=$nmo4onABp!A=4qp4rqoABs!A>srABtA=4ut/vuCwvxwxA-y,.=$zyo4{zAB|!A=4}|4~}{AB!A>~wwABA=4/DA-,E=$o4AB!F=44AB!F>ABA=4/GA-,H=$o4AB!I=44AB!I>A-,J=$o4AB!F=44AB!F>ABF=4/CA-,K=$o4AB!A=44AB!A>ABF=4/DA-,L=$o4AB!F=44AB!F>ABF=4/GA-,M=$o4AB!I=44AB!I>A-,N=$o4AB!I=44AB!I>ABA=4ABF=44 4/CA-,0=$o4AB!A=44AB!A>=;! ;EQ4Q4Q4P7=>86"&7%7%;% =$A-,=$> =$=$A-,=$A-,>=$=$ A-,>86$'7% 7% ;%;%;%;%;%;%;%=$ A-,=$>=$ $.>=$ >=$=$ $./=$A-,=$=$/=$$.>=$>=$>9"=$$ .> =$ $  .> =$ > =$  > 9"=$86" #;%;%;%;2;%;%;%>,>0>1=$$.>=$A%>=$$.>=$A%>=$/,=$ $! .>!A%" =$#">#=$$$%$.>%A%&$=$'&>'=$(>(=$)>)9$*>*=$+$,+.=$-/.,-/.0/0=$1$21.>2=$3A%42>43=$5$65.>6=$7$87.A%96>98//=$:$;:.=$</=;<>=?>?=$@$A@.>A=$B$CB.A%DA>DC=$E$FE.>F=$GA%HF>HG>>8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_050.spv000066400000000000000000000100741475742701700273340ustar00rootroot00000000000000# GLSL.std.450main@maincoordgl_FragCoordicoordres1res2 res_GLF_color icoord res3 res2 res1icoordvres1res2res3G G!   ;+; + +>+ +!?" #"+$,%$+& @+'UU?,(&'+)C *+++,+- .;.+/?0 10 21,3!,4&& 50+06+07+08 +09 +0: ,;'/ <+0=+0> +0?+0@ +0A6B;;#;*;*; ;2 ;5 ;5 ;5 ;2;5;<;<;<=CODCCQEDQFDPGEFHG>HAI=JIKJLKMNMAO =POQP!RQSTS=UVU%WV(XW)m"YX>YA*Z=A*\ =]\^[]A*_=`_a`+b^acb,>cA*d=edA*f =gfhegA*i=jikj+lhkml,>m=non-poqp =rsr tsut vqupwv> w=x =y =z P{xyz/>{RT=|}|3~}4~)n1> A5 =00607A5 =008060> A5 =0A5 =000907> A5 =0A5 =000:07> =0 =0 0o=0 =0 0o=0 =0 0oP/>RRLN=%;)n1>A5=0A5 =00A5 =00>=00907=>=00>0?=>=00@0A=>=/$=/$=/$P/>LL8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_051.spv000066400000000000000000000062001475742701700273310ustar00rootroot00000000000000# GLSL.std.450main@mainbuf0resolutioncgl_FragCoord_GLF_colorH#GG"G!G G!     +   ;+  +  +  +  #<+ L>+   +  ;  +++ ? !;!*")# $6 %; &o '& ( o )(P*')>*A+= ,+  -I o .- /,.  0/A1= 21344n 5, 65o 7688 974:; <(4=; ><?<>@;?A@Ao B< CB0DCEDFEF G9EE :9AGFHB2IHJIJ@I =<;;8@ K$8:J L98:JM"8#JNM3NN33 OK@LNA P>POAQ= RQSTTUU V7TWX Y(TZX [Y\Y[]X\^]^o _Y `_0a`bacbc dVbb WV^dce_Rfegfg]f ZYXXU] h$UWg iVUWgj"U#gkjSkkSS lh]ikA m>ml= nP= om pnoA q>qp r&ss trSuvwvxxA yt= zy{z |{}|}= ~y= y ~>y|| utvv  J-usww= P >P= m >m= q >q=>8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_052.spv000066400000000000000000000127041475742701700273400ustar00rootroot00000000000000# GLSL.std.450main@maingl_FragCoordbuf0resolution_GLF_colorG H#GG"G!G!      + + +  + s+ + + + + + + + + + + + + !+ "+ #+ $~+ %x+ &t+ 'r+ (u+ )y+ *+ ++ ,+ -+ .+ /+ 0+ 1+ 2+ 3|+ 4q+ 5g+ 6^+ 7W+ 8R+ 9O+ :P+ ;T+ <[+ =e+ >+ ?+ @+ A+ B+ C+ D+ E+ F+ G+ H+ I+ J+ K+ L+ M+ N+ O+ P+ Q+ R+ S+ T+ U+ V+ W+ X+ Y}+ Zi+ [a+ \]+ ]b+ ^j+ _+ `+ a+ b+ c+ d+ e+ f+ g+ h+ i+ j+ k+ l+ m+ n+ o+ p+ q+ r+ s+ t+ u+ vv+ wD+ x:+ y1+ z++ {(+ |)+ },+ ~3+ =+ I+ w+ + + + h+ V+ Q+ M+ L+ Y+ f+ \+ S+ >+ 2+ &+ + + + + + + + + !+ 0+ @+ + {+ p+ d+ Z+ A+ C+ F+ K+ _+ X+ E+ /+ $+ + + + + + -+ <, !"#$%&''()*#+,-./ 012"#3456789:;<='>?@ABCDEFFGHIJKLMN 0/OPQRSTTUMV0WXY'Z[\<\]^(>_0`SabcdHefghijkOl,+mnonmp"q2-rrs?tuv^\:wxyz{|}~75#W/UP!+&6:;6]]]'u+2l00ls#w7[=59x6 + pA+ ?+ + ,    ; ; + C  ;*) + =6;;;= OA=Q  n Q  n P  Q Q >A=  >A=  >A=  o    P  R   >8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_053.spv000066400000000000000000000075401475742701700273430ustar00rootroot00000000000000# GLSL.std.450main@maingl_FragCoord_GLF_colortexG GGG"G!G!  + >+ o: +  ++ Qx?+ \B>+ ?+ ?,   ;+ ;+ C ;   ;+ ؾ+ P, + !<+ ", #!", $6%=&O '&& (' )(  *B)+,, -* .-/./+.  0)Q 10Q 20 31243565 72146 81244 97586 :9 ;:9 <; =<9 >=  ?12@?A@A B>@@ C>4BAQ D) EDFEGFG HCFF IC@HGQ J) KJLKMLM NILL OIFNM++ P/OLP Q*P R(#  SBRTUU VS WVXWXTW  YRQ ZYQ [Y \Z[]\^_^ `[Z]_ aZ[]] b`^a_ cb dcb ed feb gf  hZ[ihjij kgii lg]kjQ mR nmonpop qloo rliqpQ sR tsutvuv wruu xrowvTT yXxuP zSy {(  |B{}~~ | }  {Q Q             Q {   Q {   }} P | Qz     $=WQ Q Q P>8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_054.spv000066400000000000000000000057201475742701700273420ustar00rootroot00000000000000#~ GLSL.std.450main@maincbuf0resolutiongl_FragCoord_GLF_colorH#GG"G!G GGG G G G G ! + ++ + #<+L> +?, ;+ + ! " #;# $+ %+ &+' (;(*))*++,>6-;>A".!=/.0/, 10A$2!=324!55667589 5 9: ;9:<;<o= >=1?>@?A@AB7@@87<BAC=3DCEDE;D99 6;F+68EG768EH)6*EIH4II44JF;GIAK!>KJA$L%=MLN!OOPPQORS O ST USTVUVoW XW1YXZY[Z[\QZZRQV\[]WM^]_^_U^SS PU`+PR_aQPR_b)P*_cbNccNNd`UacAe%>ed=fK=gehfgAi&>ihjj Nkl 'mklnmnAo =poqprqsrs=to=uovtu>ovrrkk jm=wKxw>Kx=yezy>ez={i|{>i|=}>}8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_055.spv000066400000000000000000000023041475742701700273360ustar00rootroot00000000000000#0 GLSL.std.450main@maintexeltexgl_FragCoordreuse_GLF_colorGG"G!GG G GG  !       ;  ; + ; + ?+ >,+ C ;6  ;;==O W! O !!> ="O#""=$O%$$&#%'&('>(=)*) +*P,-+,>-= =.W/ .>/8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_056.spv000066400000000000000000000167541475742701700273550ustar00rootroot00000000000000#  GLSL.std.450main@mainMATRIX_Nmatrix_abuf0matrix_a_uni matrix_bgl_FragCoord matrix_u magnitudeX alpha1 alpha2alpha3betakxujaabbij_GLF_colorGHH#HGG"G!G GGGGGGGGG G!G"G#G$G%G&G'G(G)GG*G+G,G-G.G/G0GG1G2G3GG4G5G6G7G8G9G:G;G<GG=G>G?G@GAGBGCGDGEGFGGGHGIGGJGKGLGMGNGOGPGQGGRGSGTGUGVGWGXGYGZG[G\GG]G^G_GG`GaGbGcGdGeGfGgGhGiGjGkGlGmGnGoGp!qpr  sr;s+rtu vuwv xww y;y+rz {w |v }v;}+u~,v~~~~ u r+r+u@ v;+u? + u6pq;x;| ;| ; ; ; ;;;;;;;;;;;;>tA{z=wQvQvQvQvPw>=vO v> > > ~> ~> ~>~>~>z=r=rr=rr>=r=r  =r!=r"A!"=u u=u u> =r#=r$=r%A$%=uA #>=r&r'&>'=u u> =r(=r)A )=u u=u uA (=uuA (>=r*r+*>+=r,=r-,-=r.A .=u u=u u> =r/r0/>0=u u> =r1>1=r2=r323=r4r54>5=r6=r767=r8A 8=u=r9=r:A9:=uu=uu>=r;r<;><=u =uu>=r=r>=>>=r?=r@?@=rA=rB=rC=rDACD=u=u=rEA E=uuuAAB>=rFrGF>G>~>~=rHrIH>I=rJrKJ>K=rL=rMLM=rNA N=u=rOA O=uu=uu>=rPrQP>Q=u =uu>=rRrSR>S=rT=rUTU=rV=rWA W=u=u=rXA X=uuuA V>=rYrZY>Z> ~> ~> ~>~>~=r[r\[>\=r]r^]>^=r__z=r`ra`>a    =rb=rcrdc bd    =re=rf=rgAfg=u=rhA h=uuA e=uuA e>  =rirji>j =rk=rl=rmAlm=uA k=uuA k>=rnron>o=v v>A>8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_057.spv000066400000000000000000000215241475742701700273450ustar00rootroot00000000000000#c GLSL.std.450main@mainmatrix_numbercolsrowsc r m22 buf0 one  m23m24m32m33m34m42m43m44sum_indexcolsrowssumscrregion_xgl_FragCoordbuf1resolutionregion_yoverall_region_GLF_colorGGG GG!GG"G#G G$G%G&G'G(H #G G "G !G)G*G+G,G-G.G/G0G1G2G3G4G5G6G7G8G9G:G;G<G=G>G?G@GAGBGGGCGGDGEGGFGGGGHGIGJGKGLGMGNGOGPGQGRGSGTGUGVGWGXGYGZG[G\G]G^G_G`GaGbGcGdGeGfGgGhGiGjGkGlGmGnGoGpGG H#GG"G!GqGGrGGsGtGuGvGwGxGGyz!{z| }|+|~  +++  ;   ;    ;  ; ; ; ; ; ; ;++|+|  + +A ;  ;+@@++ ;+?,6z{;};;;; ;;;;;;;;;>~>=  >=!!>="=#"#> =$ =%$%=|&&='=( A =A '(>=)=* A =A )*>=+=, A =A+,>=-=. A =A-.>=/=0 A =A/0>=1=2 A =A12>=3=4 A =A34>=5=6 A =A56>=7=8 A =A78>=9 :9> :=;<;><=|=|>=>>=?@?>@=ABA>B>>=CC>=DD=EAE>>=F=GFG>=H=IHI=JJ     =K=L=MA LM=AK=AK>=N=O=PA OP=AN=AN> =Q=R=SARS=AQ= A!Q>!  =T=U=VA"UV=#"A$T=%$&%#A'T>'& =W=X=YA(XY=)(A*W=+*,+)A-W>-, =Z=[=\A.[\=/.A0Z=1021/A3Z>32 =]=^=_A4^_=54A6]=76875A9]>98=`=a=bA:ab=;:A<`==<>=;A?`>?>=c=d=eA@de=A@ABc=CBDCAAEc>ED=fgf>g=hih>i=jAFj=GFHGAIj>IH=klk>l=mnm>n=opo>pAJ~=KJAL~=MLNMOKNnqO>qAP=QPAR~=SRTSUQTnrU>r=sts=uvtu>v=wVw=xWxXVWYXZ[Z=yA\y=]\P^]]]Q_^Q`^Qa^Pb_`a>bY[>YY8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_058.spv000066400000000000000000000061441475742701700273470ustar00rootroot00000000000000# GLSL.std.450main@maingl_FragCoordbuf1resolutionbuf0injectionSwitch data ResType_GLF_colorG H#GG"G!H#GG"G!G GG G !  ; +  ; + ++ ;+ +! "! #" +$ %;%+& +'?+(?+)=6*;# A+ =,+n-,.-//0.*12 3J403524252|60 7!6Q87p98A:=;:<9;A= 0>=<10$/5 >- -??@>5ABC-DBEEFC?GH IIJFIKHJLKL|MF|N@ ONQPOQMPRQSRSHRAT @=UTAV F=WVAX=YXAZ=[Z\[(]Y\^]_`_aUW^`bUW^^ca_b`dcede=fT=gV>Tg>VfddHHGF$EKA@$BB hJiAhi?DDAj =kjAl =mlnm(oknpoqrq sJ$At s=utvu)  I&Aw =xwyx)Az h={z|{)P}vy|'>}pr  I&A~ =~)A h=) J$A =)P'>pp8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_059.spv000066400000000000000000000134641475742701700273530ustar00rootroot00000000000000#  GLSL.std.450main@mainbuf0resolutionAgl_FragCoordResType_GLF_colorH#GG"G!G G G GG  !  +++@++++++ +@+  ; +  +!+"2#" $# %+&+'( )(;) *+++,2 -(;-+.?+/(+0 +1<+2P+3d+4x+5+6"+7+8#+9'+:+;,+<-+=16  >;$?@@A?>BCDCEEAF=GFnHG IAHJIKJKDJ  I! LJ!MALN M ONAPOQPQRA oSAA%TR>TSPPBA&CCU' VBUV@DD  IWWX DYZ[Z\\A*]=^]n_^ `X_a`bab[a cJ dXcedfef|gXhg+Qih|jiA%kj=lkA%mX=nmonl>moeeYX&ZZp, qYpqW[[ rI s_rtsuvuwA%xw=yxzyG {J!A%|{=}|A~+=~}P(z..>tv/ _  I0A% =G JA%=A+=P(..>1 _ JA%=G IA%=A+=P(..>2 _ IA%=G JA%=A+=P(..>3 _ JA%=G IA%=A+=P(..>4 _ IA%=G JA%=A+=P(..>5 _ JA%=G6A%=A+=P(..>7 _8A%=G9A%=A+=P(..>: _A%=G;A%=A+=P(..><A%=G=A%=A +=    P(  ..> tt8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_060.spv000066400000000000000000000301441475742701700273350ustar00rootroot00000000000000# GLSL.std.450main@mainbrick(vf2;uvpatternize(vf2;uv BinarySearchObject prime_numbers binarySearch(struct-BinarySearchObject-i1[10]1;i1; obj x abuf0injectionSwitchbgl_FragCoordcdsizestlrmiobjuvbuf1resolutionbparamcolor param!param"param#param$param%param&param'param(param)param*param_GLF_colorH G G G H#GG"G!G+G,G-G.GG/G G0G1G2GG3G4G5G6G7G8G9G:GG;G<G=G>G?G@GGGAGBGGCGDGEGFGGGHGIGJGKGLGMGNGOGPGQGGRGSGTGUGVGWGXGYGZG[G\G]G^G_G`GaGbGcGdGeGfGgGhH#GG"G!GiGjGkGlGmGnGoGpGqGr!srt ut vu!wuv!xtvy z +z{ |y{ | } ~y!y}~+yu ;+y+z t+z t+y+yt ; t+y+tff>,u+t@+y +y+y +y+y+y +y +y+y+y+y+y+yu ;+t?+t@t +ť? ;6rs;~;};v;v;v;;v ;}!;~";}#;~$;}%;~&;}';~(;});~*>=yRR=ySS=yTA~T>=yUU=yVA~V>=yWW=yXA~X>=yYY=yZA~Z>=y[[=y\A~\>=y]]=y^A~^>=y__=y`A~`>=yaa=ybA~b>=ycc=ydA~d>=yee=yfA~f>=ygyhg>h=OuA=tPuuA=tA=ttPuu>=uu>9u>=u> 9t P>A=tA=tt= >!A~=yi>"i9yj !"A=tny~yj= >#A~=yk>$k9yl #$A=tny~yl      = >% A~=ym>&m9yn %&otn= >'A~=yo>(o9yp '(otpt=OuPuu=O>   = >)>*9yq )*q=Ou =!Ou"!!u#" =$O%$#>%=&A'=t('Qt)&Qt*&Qt+&P,)*+(>,86uw7v-;~ ;~;.;~;~/;~> 001233A4=t54A6=t76 t8057A9=t:9t;:8A<><;A==t>= t?> t@ ?AA=tBA=y+ yCJ+ tD5BCtE@DAF=tGFtHGEAI>IH=y, y-,> -22=y. AJ=tKJnyLKM.LM011>NNOPQQAR=tSRAT=tUT tV0SU=y/ otW/tXVWAY=tZYt[ZXA\>\[A]=t^]_^`_abaAc=tdc ted>.e`bAf=tgf thg>.h``=ti.Aj=tkjtlkiAm>ml=y0y10>1PP=y2An=tonnypoq2pqNOO>rrstuuAv=twvAx=tyx tz0wy=y3 ot{3t|z{=y4ot}4t~|}A=tt~A>A=tA=tA=tt=y5 yJ5>/=y6 yJ6>/=y7/ t57A=ttA>=y8y98>9tt=y:A=tny:rss>A=tA=t t0=y; ot;t=y<ot<t=y=ot=tA=ttA>=y>y?>>?=y@A=tny@=u u 86tx7v;v;v>=u=u=u u1>A=ttny A=tA=t tA=tA=t t.A=tA=t tA=tA=t t.A=tA=t tA=tA=t t.A=tA=t tA=tA=t t.t86y 7} 7~ ;~;~;~>>=yA=yBAB=yC=yDyECDyFE>F=yGA~ G=yH=yI HI=yJJ=yKA~ K=yL=yM LM=yNyON>O=yPyQP>Q8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_061.spv000066400000000000000000000225341475742701700273420ustar00rootroot00000000000000# GLSL.std.450main@mainposgl_FragCoordbuf0resolutionipos i map p canwalk vdirectionsjd_GLF_colorG H#GG"G!G!   ; ; +   +  +!A+" #+$%+&'& (';(  )+*,+ ,%)%-+.+/+0*%1+2 3;3+4?,54444+6,7666468;;;# ; ;, ;# ;#;#;#=9O:99A;=<;=:<>=A >=?>@?!nA@A B"=CBDC!nEDPFAE>F> GGHIJJ=K %LK$LMHM=N A)O N>OII=P QP*> QGH> +> -> RRSTUU=V WV*> W>A#X =YX%ZY[Z\[\A#] =^]_^.A#` "=a`ba/c_bA)d c=ed%fe[[%gZUf\hgihi=jkj*>khhA#l "=ml%nmonpopA#q =rqA#s "=tsut.vu/wrvA)x w=yx%zyoo%{nhzp|{}|}=~~*>||A# =%0A# =.A# "=/A) =%%|=*>A# "=%0A# =A# "=./A) =%%=*>=%> 1> = %2>=%2=.= ./A) =%=.A# >= .A# ">> -=*>= *> A# =A# "=/A) >*= =>== > =%A# =%%A# =.A# "=/A) =%%=*>A# =A# "=/A) >*A# =*A# "=/A) >*A# =.A# "=   /  A)  > *A#  = .A# >=%A# "=%%A# =A# "=. /! A)" !=#"%$#%%$&%'&'=()(*>)A#* =+*A#, "=-,.-//+.A)0 />0*A#1 =21A#3 "=4354*65/726A)8 7>8*A#9 =:9A#; "=<;=<.>=/?:>A)@ ?>@*A#A "=BACB.A#D ">DC&&=E%FEGFHGHA#I =JI%KJ0GG%LF&KHMLNMNA#O =POQP.A#R "=SRTS/UQTA)V U=WV%XWMM%YLGXNZY[Z[=\]\*>]A#^ =_^A#` "=a`ba/c_bA)d c>d*A#e =fegf*A#h "=ihji/kgjA)l k>l*A#m =nmon.A#p "=qprq/sorA)t s>t*A#u =vuwv.A#x >xwZZ=y%zy{z|{|A#} "=~}%~0{{%zZ|A# =A# "=./A) =%%{=*>A# =A# "=/A) >*A# =A# "=*/A) >*A# =A# "=./A) >*A# "=.A# ">A#"=/A#=A) =%*>5TT=% RSS>78KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_062.spv000066400000000000000000000034401475742701700273360ustar00rootroot00000000000000#K GLSL.std.450main@maingl_FragCoordtexindexable_GLF_colorG GG"G!GGG G G G G GGG!  ;+; +, ++   ; +!" +"# $#+%?+&?+'+(+), $*%&'&%('() +$ ,;,6-;+=.O/..0/112-34- 45645767883279:7 :;<:;:<:=!o=>= !o? @?PA>@B0AWCB  >*AD =EDFCE93F !8<44 !16QG2QH2QI2PJGHI%>J8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_063.spv000066400000000000000000000315401475742701700273410ustar00rootroot00000000000000# GLSL.std.450main@mainswap(i1;i1;ijperformPartition(i1;i1; l h quicksort( palette(vf3;vf3;vf3;vf3; abcdrandomize(vf2;copuzzlelize(vf2;postempQuicksortObjectnumbersobjpivotijparamparamparamparaml h!top"stack#p$param%param&param'i(buf0(injectionSwitch)*grid+uvgl_FragCoord,buf1,resolution-.color/param0param1param2param3count4param5param6param7param8count9param:param;param<param=count>param?param@paramAparamBposition_GLF_colorCparamGGGG G GHGDGEGFGGGHGIGJGGKGLGGMGNGGOGPGQGRGSGTGUGVGWGXGYGZG[G\G]G^G_G`GG G!G"GaGbGcGdGeGfGgGhGiGjGkGlGmG#GnGoGpGqGrGsGtGuGvGwGxGyGzG{G|G}G~GGGGGGG'H(#G(G)"G)!GGGGGGGGGG H,#G,G-"G-!GGG3GGGGGGGGGGGGGG8GGGGGGGGGGGGGGGG=GGGGGGGGGGGGGG!  !!  ! !! +  ;+ ++ + +HA+@@,+ЄE+ ף<+?+=( (;)+ + ++A, ;, ,;- ++=+fff?++L?+>+333? +>+L>,+?++,++@?,+  ;+?6;';*;+;.;/;0;1;2;3;4;5;6;7;8;9;:;;;<;=;>;?;@;A;B;CA)=n>'='='='A)=nA>='>'9 >*=OA -=    >+ A = o  PA=oPA)=P A)=P>/>0>1>29 /012>.A+=  A!)="!n">3##$%&&A'='o()(P*)A+)=,+P-,,, .-A/=/o010A2)=32P413>4*>5>6.>7495 4567=6.765>.7=3>3%%=3A8)=98n:9A;:=;<<#$$=3A===o>=3A?=?o@PA>@>*AAB+=CBDCEDFEFAG)=HGnH>8IIJKLLAM=MoNONPPOOOAQ)=RQnSRATS=ToUVUPWVVVAX)=YXAZ=Zo[\[A]=]o^_^P`Y\_>9P>:>;W><`9a 9:;<=b.cba>.c=8>8KK=8Ad=deeIJJ=8Af)=gfngoh=8Ai)=jinjokPlhk=m*nml>*nEEAo+=poqprqsrsAt)=utnu>=vvwxyyAz)={zn|{A}|=}o~~PA)=A)=nA=oP>>>?>@>A9 >?@A=.>.==>=xx==A=vww==A=o==A=oP=*>*rrA=A-=A=P>B=B=* >B=.A)=QQQP=B>C9CP>8677;=DAD=E>E=F=GAG=HAF>H=I=JAI>J867 7 ;;;;;;;=K AK=L>L=M NM>N=O >O=P=Q RQPR=SAS=T=UTU=VWV>W=X>X=Y>Y9=Z[Z>[=\]\>]=^ >^9=_`_`86 ;; ;!;";#;$;%>> >!=a!ba>!b=cA"b>c=d!ed>!e=f A"e>f=g!g=h!ih>!iA"h=j> j=k!lk>!lA"k=m>m=n>$n=o >%o9p$%>#p=q#rq=srs=t!ut>!u=vA"u>v=w!xw>!x=y#zyA"x>z={#|{=} |}=~!~>!=#A">=!>!= A">86 7 777== = ==== .  867=     867;&=>&9&8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_064.spv000066400000000000000000000142141475742701700273410ustar00rootroot00000000000000# GLSL.std.450main@mainpickColor(i1;imand(f1;f1;xCoord yCoord height buf0 resolution  widthxposyposc_rec_imxyiterationkiterationCapx_newparammsb16ijdatauselessOutVariableResTypegl_FragCoordparam param!sum"i_GLF_colorH #G G "G !G#G$G G%G&G'!(')  *)+ ,+!-,* .+!/,..++0HB++1B++2 C3+ 3 4 ;4 +)56 +67 8++69++:=++;?++<>++=L?++>@++?@++@A++B?+)C+)D++EC+)F+)G+6HI,H JI+)K L666M+ NM;N O+ P,,,Q@@@++RA,,SRRR TM;T6'(U;*;*;*;J;L;.;. ;P!;*">F>5VVWXYY=)Z )[JGA\Z[\]W]>5^^_`aa=)b )$IGAcb$cd_d=)e)fKe|6gf=)h|6ihjgiQ6kj>kQ6ljAOm9=+nm=)o)%D)po%o+qp+rnqAOs7=+ts=)u)&D)vu&o+wv+xtw>r> x9,y APzl>zy``=){)|{D>|^_XX=)})~}D>~VW>!Q)5>"=)"=) )JA=)"AP=,=,!,>!=)")D>"=,!,S>!=,!Q+Q+Q+PMB>86,-7*=)o++0=)o++1=)o++2P,86,/7.7. ;. ;. ;.;.;.;.;.;.;*;*;*;.;*A8 57=+> A8 59=+> =++:A8 59=++;+>=+ +:A8 57=++<+>=+=+ +>++=+?=+ ++<>=+=+ +>++=+?=+ +>>@>@A8 59=+A@>B>B=+n))>=+n)=+n))#=+n))#>>C=+=++=+=+++A?=+=++=+=+++=++>=++>=++=++>=+>=))D>=))D>=)=)A8 57=+AE)D5))555AA8 57=+A@=))D>=)=))555A    =) > 9,   =+A8 59=++=+ A8 57=++P,@ 8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_065.spv000066400000000000000000000160201475742701700273370ustar00rootroot00000000000000#A GLSL.std.450main@mainbuf0injectionSwitchgl_FragCoordbuf1resolution A_GLF_colorH#GG"G!G H#GG"G!G G G G GGGGGGGGGG! +?, +  ; +!" +"# $%+&L>+"' (+)* +*;+ ,;,+-+.+"/20/ 10+22 3+4M>sA+5+6?+7HB+8A+9(+: +;<+<+=P+>'+?d+@x+A+B+C+D,+E1 F*;F,G666,H&&6I;1 =*JOKJJA$L!#=MLPNMMOKNPP!I Q%R-SQRTSTA$U!'=VUnWV%XWYXZYZSY . . %[ \[]\]o^A(_ >_^\\QQ )PS``!Sa%b2cabdcdA3e'=fengf%hgihjijci%k!lkmlm )A(n =onA(p =qprqo>prllaa)`csO4 tsuuvcwxcxA$y!#=zyn{z%|{}x|~}~wv~~%{ooP .tHA$!'=Qw%)%!) QQPw)xx)u}QvQvA3#=n%5A$!'=A( .=7P8P G%9A$!'=A( :=7P8P G%;A$!'=A( <=7P8P G%=A$!'=A( >=7P8P G%?A$!'=A( >=7P8P G%@A$!'=A( >=7P8P G%AA$!'=A( >=7P8P G%B    A$ !'=  A( >= 7P 8P G  %CA$!'=A( D= 7P! 8P"#"! $#%G$%&-'&'('A$)!'=*)A(+ E=,+-,*.-7P/*.8P010/ 213G2(4%3'  5 465 768798:9;:<;Q=<Q><Q?<P*@=>?>@8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_066.spv000066400000000000000000000073241475742701700273470ustar00rootroot00000000000000# GLSL.std.450main@mainiter(vi2;pposgl_FragCoordbuf0resolution  ipos v w piparam_GLF_colorindexableG H#GG "G !G!  ! + ++++   ! " #";# $;$  % &+'A+(+) +*++d+,+- .";.+/0"/+1+2?,"31112+4?,"54112,"61412,"74412,"81142,"94142,":1442,";4442,"<2112,"=1212,">2212,"?1122,"@2122,"A1222,"B2222,0C356789:;3<=>?@AB D0 E"6F;!; ; ; ; ;;;D="GO HGGA%I = JI KHJ>KA&L=MLNM'nONA&P=QPRQ'nSRPTOS> TAU =VUWV(AX =YXZY)[WZ> [A\ =]\^](A_ =`_a`)b^a> b=c dc*=e fdePgf> g>hhijkk=lml+mnin=o >o9p> pjj=qrq>rhiAs =tsutvuwvwAx =yx~zyA{ >{zvv||}~A =,}A =-A >~~|}A =>CAE=">867A=A=>A=A=>A=A=A>=8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_067.spv000066400000000000000000000072041475742701700273450ustar00rootroot00000000000000# GLSL.std.450main@mainbuf0resolutiondatagl_FragCoord_GLF_colorH#GG"G!GG G G G G G GGGGGGGGGGGGGGGGGGGG G!G"G#G$G%G&G'G(G)G*G+G,G-G.G/G0G1G23!435 6 76+58969 :;:+5;< +<= >6+<?+5@+5A3+5Bf+5CD+5E+5F+6G+6H?,7IGGH+5J+<KL7K MLN6 ON;O P6 Q7,7RGGG+5S TN;T+6U?+6V=,7WVVV+6X ף<+6Y<+6Z;634[;M\\5,;[ ]D^,J_]^`_`aa5.;` bDc.Jdbcede5J.5 ,APf?=6gf5 ,Fo6h 6ighAPj==6kj5 .Fo6l 6mkln?oon5i58n5m58A>p;==6qpn5q58A>r;?=6srn5s585@55A55B5@55A5tt52;o*u51;o)u50;o%u5/;o+uDv/Cwuvxwx5 005!115" !Dy"Ezy{z{wz5# !5$#85%$5&@05'&15('85)(5*2Fuu5+/FtwD|2C}|~n~o626X6Y6ZP7n}n7~IAQ >bb5 .Fad]]5 ,F\_7R_5-;_D-SAQ-=775-F7WQ6Q6Q6PNU>8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_068.spv000066400000000000000000000036441475742701700273520ustar00rootroot00000000000000#Q GLSL.std.450main@maingl_FragCoordtex_GLF_colorG GGG"G!GGG !      ;+ ;+ >, + @ +++ ?   ;  ;6  = O   !! " #$$%$&&'(')()Q *"+*((,'&+)-,.-/./Q 0"10..2,(1/23%3Q 4"5465767 84R 98"66 :"397Q ;:<;=<>=> ?;R @?:== A:6@> #A$$!%Q B"CBDCEDEQ F"GFDDHC%GEIHJIJ=W K"II LDKJQ MLQ NLQ OLP PMNO>P8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_069.spv000066400000000000000000000072341475742701700273520ustar00rootroot00000000000000# GLSL.std.450main@main ReallyApproxNormalizedAtan2(vf2;vpolarize(vf2;coord pi2 a z th centerdistangleparamcoordgl_FragCoordcoord1paramcoord2paramcoord3param_GLF_colortexG GGG"G!GG!  ! !! "+#>+$o:%+&' +'(+')+*Qx?++\B>+,?+-?,.,,/ 0/;0+1;+2=+3,423+5p+6 >,756+8C 9/;9 :;: <;;<=6>;;;;;;;=/?O@??A@1>A=BCB4>C9D>D=EFE7>F9G>G=H>H9I>I=J=KLJK=MNLM>N=OPO8 QPPR88SQR>S=;=TW/UTO=UUQVQWQXP/YVWX->Y86 7Z;" ; ;" ;" > #=[ \B[%]\$^]_^_&^=` a`> aA"b (=cbA"d )=ed%fcegfhihA"j )=kjA"l (=mlnkm> ngiA"o (=poA"q )=rqspr> sgg=t u+t=v wuvx*w=y zxy={ |z{> |A"} (=~}A" )=%~= ,> A")=%&= -> A"(=%&= > = 86!7; ;";";=.> = B>= >9>==P8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_070.spv000066400000000000000000000136101475742701700273350ustar00rootroot00000000000000# GLSL.std.450main@mainpickColor(i1;imand(f1;f1;xCoord yCoord xpos ypos height buf0 resolutionwidthc_rec_imxyiterationkx_newparamijdatagl_FragCoordparamparamsumi_GLF_colorGGG G!G G"G#G G$G%G H #G G"G!G&G'GG(G)GG*G+G,G-G.G/G0G1GG2G3G4G5G6G7G8GGGGG9G:G;G<G=G>G?G@GGAGBGCGDGEGFGGGHGIGJGKGLGMGNGOGPGQGRGSGTGUGVGWGXGGYGGZG[G\G]G^G G_G`GaGbGcGdGeGfGGgGhGiGjGk!lkm  nmo po!qpn ro!sprr+otHB+ouB+ov C+mwxo x y ;y+mz{ +{| }o+{~+m+m3+mf+m+m+m+o+o?,p+m+{p o ; o p,p+m+oA,p ;+o?6kl;n;n;;r;r;;n>z=mYY>z=mZZ=m[m\[=m]m^\]A~=o=m_m`_oo`oA|=o=mambaoobo>>9pA^>=mcmdc>d=memfe>f>>z=mgg=mhAh=p=pp>=mimji>j=pp>=pQoQoQoP>86pq7n=mooot=m oo ou=m!oo!ovPp86ps7r7r ;n ;n ;n ;n;n;n;n;n;n;n;n;n=onm"m#"w> #=o nm$m%$w> %A}z|=onm&m'&w> 'A}z~=onm(m)(w>)=m* =m+m,+m-*,m.-=m/m0./m10>1=m2 =m3 m43m524m65=m7m867>8>z>z>z>z=m99=m:=m;m<:;=m==m>m?=>m@<?@=mA=mBmCAB=mD=mEmFDEmGCFmHGw=mImJHI>J=mKmLK=mMmNLMmONw=mPmQOP>Q=mR>R=mSmTS>T=mUmVU>V=mWW=mX>X9p8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_071.spv000066400000000000000000000017041475742701700273370ustar00rootroot00000000000000#' GLSL.std.450main@maintexgl_FragCoord_GLF_colorGG"G!GG G!     ;   ; + ;+ ?+ >,+ C ;. ,6= =OWOO ! "!#" $#%$W&%>&8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_072.spv000066400000000000000000000506641475742701700273510ustar00rootroot00000000000000# GLSL.std.450main@mainbuf1resolutionbuf0timegl_FragCoord_GLF_colorH#GG"G!H#GG"G!G GG G G G G GGGGGGGGGGGGGGGGGGG G!"!#"$ %$&$'%( +()+$*@+(++$,@+$-@@% .;./ +/0 1$+/2+$3?$ 4;45+$6@ 7%8$ 98;9,%:33+$;,&<;;;+(=#+$> A+$? #<+(@+$A=+$B>,&CBBB D8;D,&E---+$F>+$G?+$H>,&IHHH6"#JA1K+=$LK $M L$NMA $O N $PN$QPP%ROQP%SPOP'TRSA7U+=%VUA1W+0=$XWA1Y+2=$ZY $[%XZP%\[[%]V\=8^O%_^^%`_V%a`]%b:]%caT%dbTn( X( ++( =++ ee&f<Jgh( Jhn(iX(ji++(kj5lkmhlnmno$o( )o$p $qp>$roq$srL $t s$utF$vupo$wjP%xvw%ydx$zo?${zp $| {$}?|~0Q$c$}Q$y55n(Z(++o$P&~$}55n(Z(++o$P&~Q$c$}Q$y55n(Z(++o$P&~$}55n(Z(++o$P&~$|55 (J)o$$6$o $ $M3$G$pp$$(+o$P&p,&IP&&&* &&E &P&ppp&(io$P&wwwP& &+&P&&Q$Q$Q$$p$$p$$ $53$p$- $+wp$P&~$|55 (J)o$$6$o $ $M3$G$pp$$(+o$P&p,&IP&&&* &&E &P&ppp&(io$P&wwwP& &+&P&&Q$Q$Q$$p$$p$$ $53$ p$  - $ +wp $  P&  ~$|55 (J)o$$6$o $ $M3$G$pp$$(+o$P&p,& IP&!&"! &#"* &$#&%$E &&%P&'ppp&(&'(io$)P&*wwwP&+))) &,+(*+&-,P&.&/.-Q$0/Q$1/Q$2/$3p$413$5p$605$7 $875983:9;:;$<2p$=<- $>+wp=::$?2>;P&@64?~$A|5BA5CBDCEDE (FJ)o$GF$H6G$IoH $J I$KM3$LKG$Mpp$NLM$OLN(P+o$QPP&RQp,&SRIP&TJJJ&UTS&VU* &WV&XWE &YXP&Zppp&[YZ(io$\P&]wwwP&^\\\ &_+[]^&`_OP&aNNN&ba`Q$cbQ$dbQ$eb$fp$gdf$hp$ich$j $kj5lk3mlnmn$oep$po- $q+wppmm$reEqnP&sigr~Dn(tZ(ut++o$vuP&wvvv~~&x @:smwD $yBx5zyw{z|{|h{hh&gf|x{(@em'}TT%~a}%b}&<m( m5 ko$ ()o$$>$$L $ $F$o$jP%%$?$ $ $?0Q$~$Q$55n(Z(++o$P&$55n(Z(++o$P&Q$~$Q$55n(Z(++o$P&$55n(Z(++o$P&$55 (J)o$$6$ $ $M3$G$$$(+o$P&,&IP&&&* &&E &P&&(io$P&P& &+&P&&Q$Q$Q$$$$$$ $53$$- $+$P&$55 (J)o$$6$ $ $M3$G$$$(+o$P&,&IP&&&* & &  E &  P& &   (io$P&P& &+ &P&&Q$Q$Q$$$$$$ $53  $!$"!- $#+"$$# P&%$$&5'&5(')(*)* (+J)o$,+$-6,$.- $/ .$0M3$10G$2$312$413(5+o$65P&76,&87IP&9///&:98&;:* &<;&=<E &>=P&?&@>?(io$AP&BP&CAAA &D+@BC&ED4P&F333&GFEQ$HGQ$IGQ$JG$K$LIK$M$NHM$O $PO5QP3RQSRS$TJ$UT- $V+URR$WJ*VSP&XNLW)$Y5ZY5[Z\[]\] (^J)o$_^$`6_$a` $b a$cM3$dcG$e$fde$gdf(h+o$ihP&ji,&kjIP&lbbb&mlk&nm* &on&poE &qpP&r&sqr(io$tP&uP&vttt &w+suv&xwgP&yfff&zyxQ${zQ$|zQ$}z$~$|~$${$ $53$}$- $+$}]P&\n(Z(++o$P&&%XR\ $B5&( @'}T%a%b&<(! 5!ko$!()o$$>$$L $ $F$o$jP%%$?$ $ $?0Q$$Q$55n(Z(++o$P&$55n(Z(++o$P&Q$$Q$55n(Z(++o$P&$55n(Z(++o$P&$55 (J)o$$6$ $ $M3$G$$$(+o$P&,&IP&&&* &&E &P&&(io$P&P& &+&P&&Q$Q$Q$$$$$$ $53$$- $+$ P&  $ 5  5    (J)o$$6$ $ $M3$G$$$(+o$P&,&IP&&& * &! &"!E &#"P&$&%#$(io$&P&'P&(&&& &)+%'(&*)P&+&,+*Q$-,Q$.,Q$/,$0$1.0$2$3-2$4 $54565376878$9/$:9- $;+:77$</;8P&=31<$>5?>5@?A@BAB (CJ)o$DC$E6D$FE $G F$HM3$IHG$J$KIJ$LIK(M+o$NMP&ON,&POIP&QGGG&RQP&SR* &TS&UTE &VUP&W&XVW(io$YP&ZP&[YYY &\+XZ[&]\LP&^KKK&_^]Q$`_Q$a_Q$b_$c$dac$e$f`e$g $hg5ih3jikjk$lb$ml- $n+mjj$obBnkP&pfdoA$q5rq5srtsutu (vJ)o$wv$x6w$yx $z y${M3$|{G$}$~|}$|~(+o$P&,&IP&zzz&&* &&E &P&&(io$P&P& &+&P&~~~&Q$Q$Q$$$$$$ $53$$- $+$uP&tn(Z(++o$P&& =7pjt $B5&(!@ &.fC &.C( )o$ Q$Q$Q$P8>8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_073.spv000066400000000000000000000235741475742701700273520ustar00rootroot00000000000000# GLSL.std.450main@mainpattern(vf2;xnm j buf0 injectionSwitch  i gokuvgl_FragCoordbuf1resolutioniAicparamcol_GLF_colorG GH #G G "G !G GGGGGGGG G!G"G#G H#GG"G!GG$G%G&G'G(G)G*G+G,G-G.GG/G0G1G2G3G4G5G6G7!879 :9 ;:!<:;=9 >=+9??,=@???A  BA+AC : D ;D +AEF +FG H9I+9JL>+FK L9+AM+FNO9 PO;P: Q;Q+AR+AS+FT2U9T VU+AW2 X9+9YM>sA+AZ+9[?+9\HB+9]A+A^(+A_ +A`<+Aa+AbP+Ac'+Add+Aex+Af+Ag+Ah+Ai,+Aj1 kO;k678l;;;B;V;B;;;;;>=OmO:nmmAHoEG=9poP:qpp:rnq>r>Esstuvv=A$Iw$Rwxtx=A%AHyEK=9zynA{zI|%{}|~}~t}=A&A'&SA(S'=A)I()=A*A+*S=A,o9,AL+>uu=A-A.-M>.st>E=A/I/W=A0AXK=9nAI0=A1I1E=A2=A3A43MAL4=9AL2=99AL2>=A5A65M>6=::Y>9:>AXG=9nAIZALG=9AHEK=9ALS=9AHEK=999\P=]P== =P=[[[=>AXG=9nAI^ALG=9AHEK=9AL_=9AHEK=999\P=]P== =P=[[[=>AXG=9nAI`ALG=9AHEK=9ALa=9AHEK=999\P=]P== =P=[[[=>AXG=9nAIbALG=9AHEK=9ALc=9AHEK=999\P=]P== =P=[[[=>AXG=9nAIdALG=9AHEK=9ALc=9AHEK=999\P= ]P= =    =  P= [[[=  >AXG=9nAIeALG=9AHEK=9ALc=9AHEK=999\P= ]P=!="!  =#"P=$[[[=%$#>%AX&G=9'&nA('I)(f*)+,+AL-G=9.-AH/EK=90/AL1c=921AH3EK=9439524965\P=706]P=8...=987 =:9P=;[[[=<;:><*,AX=G=9>=nA?>I@?gA@BCBALDG=9EDAHFEK=9GFALHc=9IHAHJEK=9KJ9LIK9ML\P=NGM]P=OEEE=PON =QPP=R[[[=SRQ>SACAXTG=9UTnAVUIWVhXWYZYAL[G=9\[AH]EK=9^]AL_i=9`_AHaEK=9ba9c`b9dc\P=e^d]P=f\\\=gfe =hgP=i[[[=jih>jXZAXkG=9lknAmlInmRonpqpALrG=9srAHtEK=9utALvj=9wvAHxEK=9yx9zwy9{z\P=|u{]P=}sss=~}| =~P=[[[=>oqoXXAA**==Q9Q9Q9PO?>86:<7;;;;>;B ;B ;; ;;;B=: :>>@> C=A AH EG=9nAI> C=A AH EG=9nAI=A o9=A o9P:> =:=: P:JJ :.>AH EK=9ALK=9I>M=AIE=:=::>=AAM>AH EK=9=: :Q9Q9P=>=A A! M> !=A" A#"M> #ALK=9ALG=9ALN=99P:8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_074.spv000066400000000000000000000125441475742701700273460ustar00rootroot00000000000000# GLSL.std.450main@main compute_derivative_x(f1;v compute_derivative_y(f1;v compute_stripe(f1; v buf0 injectionSwitch  paramparamuvgl_FragCoordbuf1resolutioncolc1stripeparam_GLF_colorc2stripeparamc3stripeparamc4stripeparamH #G G "G !G H#GG"G!G! ! "!!#!"$! $ % ;% & +&'( +() *!+!+fff+!,?+(-. /$0! 10;1$ 2;23! 43+!5,36555 7.+!8>+!9A+!:@?+!;L?+!<333? =0;=+!>?+!?=+!@>,3A@5>+!B>6 C;/;4;7;";";7;";";7;";";7;";"=0DO$EDDA*F'-=!GFP$HGG$IEH>I>6A"J)=!KJ.LK8>L=.MNMONOA"P-=!QPA"R)=!SR!TQS!UT9 !VU>V9!W >WA"X-=!YXP3ZY5:A"[-=!\[P3];<\=!^P3_^^^ 3`.Z]_>`=3aQ!baQ!caQ!daP0ebcd,>eNA"f)=!gf.hg>>h=.i.ji=.k.ljkmlnmnA"o-=!poA"q)=!rq!spr!ts9 !ut>u9!v >vA"w-=!xwP3y>x?=!zP3{zzz 3|.yA{>|=3}Q!~}Q!}Q!}P0~,>mA")=!.:>=..=...=..A"-=!A")=!!!9 !>9! >A"-=! !A"-=!P3<A"-=!P3B>=!P3 3.>=3Q!Q!Q!P0,>A")=!.:>=..=...=...=..A"-=!A")=!!!9 !>9! >A"-=!P3;5A")=!P3,5=!P3 3.>=3Q!Q!Q!P0,>86!#7"=!!A* ')=!!86!#7"=!!A* ')=!!86! #7" ;";" ;"=! A* ')=!A* '-=!.=! > 9! >=! >9!>=!! !1+,8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_075.spv000066400000000000000000000023601475742701700273420ustar00rootroot00000000000000#4 GLSL.std.450main@maingl_FragCoordtex_GLF_colorG GG"G!GGGG !  +     ;+ ;   ;+ ?+ + C+  ;,6  =O=W !!  "# $"Q %#Q &# '%&Q (# )'(*)+,*+-","-"O.##O/##0./10 2132W$3 !->#8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_076.spv000066400000000000000000000072741475742701700273540ustar00rootroot00000000000000# GLSL.std.450main@mainbuf0resolutiondataResTypegl_FragCoord_GLF_colorH#GG"G!G G G GG  !    ;+ + ++=+?+>+@+@++?+ +!+"C+#+$+%&% '&+() *);* + ,,- .);.+/+0=,1000+2?+3L@+4 ף<+5<+6;6  7;'8897:; <J$=9<>;=?>?@@A?BC  I$DA ECDFEFG(A|HG|I9JHIQKJA+L=ML !N9 oONPMOA+Q=RQSA oTSURTVWWAX=YXAZ=[Z\P][^\]_U`Ya_`b[2c^bdc3ed[fegY2hagih3ji[k[lknmlnm mom mppqoWrstnWusvlWwsxlWyszs{{|xx}vv~|}~z|}yfxvwjut!rq!ss"Y! rpzztusY/ P[UYPVo456PVVA,K>CCBA!@E;;:9!8>->> J#A,=!1QQQP)>8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_077.spv000066400000000000000000000102641475742701700273460ustar00rootroot00000000000000# GLSL.std.450main@maincollision(vf2;vf4;posquadmatch(vf2; pos res i param paramindexableindexableindexableindexablelingl_FragCoordbuf0resolution_GLF_colorparamindexstateG H#GG"G!G!   ! !!" +"# $*%+"&+"'+"())+*?++?,,**++-  .-+-/+-0+"121+3@+4A,53343,63334,73443+8A,94338+:@+;@,<8:3;+=@A,>;=;3+?A,@?;33+AA,B=A33, 2C5679<>@B D2+"EFE+G,HGGG+,I*GG+,JG*G+,K**G+,LGG*+,M*G*+,NG**+,O***+,P+GG+,QG+G+,R++G+,SGG++,T+G++,UG+++,V++++,FWHIJKLMNOHPQRSTUV+-X +-Y +-Z [F+-\ ];] ^;^ _+`B a;a b-;bc-E dc;d6e;;=fOgffA_h/=ihjgi>j=klk` ml>m=n>n9o>o86 77pA$q#=rqA$s#=tsurtvuwvw%vA$x&=yxA$z&={z|y{}|~}~%}A$#=A$#=A$'=%A$&=A$&=A$(=%)86!7 ; ;. ; ; ;D;D;D;[> ,> /=- 0=- = > >CA=> 9 =- >CA$#=n-=- >CA$&=n--=- -X--Y-Z>WA=> =- -\> = 8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_078.spv000066400000000000000000000157401475742701700273530ustar00rootroot00000000000000#8 GLSL.std.450main@maingl_FragCoordbuf0resolutionmap_GLF_colorG H#GG"G!G!       ;  ; +   ++ A +++,)+++ *!+" # ;#+ $?, %$$$$+ &, '&&&$ (+) *6 +;(,--= .O /..A0= 10 2/1Q 32 43n54Q 62 76n8799:-;<=:><=<><A?:>?;:9>@@A>BCD>ECF>GCHCIIJFQKDLKMLNMNOKQPDQPROQASR=TSUTMMVLIUNWVQXDYXZY[Z[\X]\^K]A_^=`_a`ZZbYMa[cbdcdeWccfWZedgK hgihijKkXljkAml=nmonhhpgcoiqprqrsfqqtfhsruX vuwvwxXyxzKyA{z=|{}|vv~uq}w~ttv!D"")A=R*RQQA>JJLKXA=XKA>KA>KA>RDDQQQA=QQA>A>A>RQ QQA=QQA>A>A > R       Q   Q Q A=Q  Q! "!# "A$#>$%!&%' &A('>()!*)+ *A,+>,R-) . -E.GJBA/80/5A10=213243545>%H4CCB@HH65!C76,77>',,8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_079.spv000066400000000000000000000126541475742701700273550ustar00rootroot00000000000000# GLSL.std.450main@mainpickColor(i1;imand(f1;f1;xCoord yCoord height buf0 resolution  widthxposyposc_rec_imxyiterationkx_newparamijdatagl_FragCoordparamparamsumi_GLF_colorGGG G!H #G G "G !GGG"G#G$G%G&G'G(GG)GG*G+G,G-G.G G/G0G1G2G3G4G5G6GG7G8G9G:G;!<;=  >=? @?!A@> B?!C@BB+?DHB+?EB+?F CG? G H ;H +=IJ +JK L?+JM+?N=+?O?+?P>+?QL?+?R@+?S@+?T+=UV+=W+=X+JYZ@Y [Z\? ]\;] ^? _@,@`TTT+=a+?bA,@cbbb d\;d+?e?6;<f;>;>;[;B;B;_;>>Igghijj==)Vk)Xklhl>Immnopp==*Vq*Xqrnr==+=,X+==-=.,-A^sM=?ts==/=0/Wo?u0?vtuA^wK=?xw==1=21Wo?y2?zxy>v>z9@{A_|.>|{oo==3=43W>4mnii==5=65W>6gh>`>I}}~==7V7a~==8A_8=@=@@>==9=:9W>:}~=@@c>=@Q?Q?Q?P\e>86@A7>==o??D== o? ?E==!o?!?FP@86@C7B7B ;B ;B ;B;B;B;B;B;B;>;>;B;>AL IK=?> AL IM=?> =??NAL IM=??O?>=? ?NAL IK=??P?>=?=? ?R??Q?S=? ??P>=?=? ?R??Q?S=? ?>>T>T>I>I=="V"U=?=??=?=???VS=?=??=?=???=??>=??R=??=??>=?>==#=$#W>$==%=&%W>&=='V'U==(>(9@=?AL IM=??=? AL IK=??P@T8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_080.spv000066400000000000000000000126541475742701700273450ustar00rootroot00000000000000# GLSL.std.450main@maindatatempbuf0injectionSwitchgl_FragCoord_GLF_colorH#GG"G!G G !     +  +  +  + +  +   ;+ + + + + + + + !" #";#+$ %+ &+'?+ (<+ )Z+ *x+ ++ ,+ -+ .+ /+ 0+ 1+ 2+ 3 4";4+5? 6+7=6  8;6;6A9=:9n ;:<< =;8>?@?AAB=BCDEFGHIJK LCA M=>MBDA N=>NBEA O=>OBFA P=>P BGA Q=>QBHA R=>RBIA S=>SBJA T=>TBKA U=>U BLA V=>V!BB >= ??W>W<@@XX Y@Z[\Y][\[][A ^Y= _^A `Y>`_ ZY X]aa b ]cdebfdegfghh igjklimklnmn oib po  qb jiq rj  s'rtt uinvw xonyw zin{w|zp}xs~|}w~A z= A x=  vu  z = A u> x = A u> yx {zwwt u zp  A = A > isA = A > kkhmdd cbafA%$=n &A = o7'(A  = o7')A = o7'*A = o7'+,A -= o7'.A /= o7'0A 1= o7'2A 3= o7'P"5>8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_081.spv000066400000000000000000000062201475742701700273360ustar00rootroot00000000000000# GLSL.std.450main@maingl_FragCoordbuf0resolution_GLF_colorG H#GG"G!G!        +  * +) + ?+ ?,  +++ + @+ A, , , + !A, "!+ #@+ $@, %!#$+ &@A, '$&$+ (A, )($+ *A, +&*, , "%')+ -+./ .+ 0, 1000, 200, 300, 40, 500, 60, 70, 8, 900, :00, ;0, <00, =0, >0, ?,/@1234567819:;<=>?+A +B +C D/+E F ;F G;G H + IB J ;J6K;-L;-M;-N;DO= PO QPPAHR= SR TQS UTI  VUWW XKYZ[K\Z ][^Z]_^_>L,A `L[= a`bccQ dVQ ea fdegfhghbgQ iVQ ja kijlkmlmblQ na oen pdoqprqrbqQ sa tjs uitvuwvwbvbb xhmrwvyxzyz>M,A{M[= |{n}|>N,A~N[= ~n}[ABC>O@A O= yy YXbzZZ\[EW^>X8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_082.spv000066400000000000000000000377641475742701700273600ustar00rootroot00000000000000# GLSL.std.450main@mainBSTdataleftIndexrightIndextreegl_FragCoordbuf0resolution_GLF_colorHHHG H#GG"G!G G G GG G GGGGGGGGGGGGGGGGGGG G!G"G#G$G%G&G'G(G)G*G+G,G-G.G/G0G1G2G3G4G5G6G7G8G9G:G;G<G=G>G?G@GAGBGCGDGEGFGGGHGIGJGKGLGMGNGOGPGQGRGSGTGUGVGWGXGYGZG[G\G]G^G_G`GaGbGcGdGeGfGgGhGiGjk!lkm mmm n omp qp+mr+ms+mt+muvw +wx yx+mz+p{?+p|@+p}+m~+w+p@+p?+md+p@+m+p A+m +m+m +m+m+m+m pp ; ; +m+m ;*v)v ym,tt,tt,tt+m,ztt+m,tt,tt,utt,tt,tt,tt,q}}},q{{{6kl;Anr>mLrKvLsAoLr=m v AoLu=mvt=m>sAns>AoLs=m v t=m>sAns>mK vmNrMvNuAoNr=mvAoNu=mvt=m>uAnu>AoNs=mvt=m>uAnu>mM vmPrOvPAoPr=mvzAoPu=mvt=m>An>AoPs=mvt=m>An>mO vmRrQvRAoRr=mvAoRu=mvt  =m>An > Ao Rs=m v t  =m > An> mQ  vmTrSvTAoTr=m v AoTu=m#v #t! "##=m$">An$>$!Ao%Ts=m!%v&!t'&())=m"%(>%An*>*'mS")$# v+(",+,,-..//mVr.U0v1V201323Ao4Vr=m%4v5u%65788Ao9Vu=m(9v:(t;:<===m)90<>9An>>>2;7Ao?Vs=m&?v@&tA@BCC=m'?0B>?AnD>D2A60mU'C)=/2 vE/B<FE-FF--GHHIImXrHWJvKXLJKMLMAoNXr=m*NvO*POQRRAoSXu=m-SvT-tUTVWW=m.SJV>SAnX>XLUQAoYXs=m+YvZ+t[Z\]]=m,YJ\>YAn^>^L[PJmW,].WIL v_I\V`_G``GGabbccmZrbYdveZfdegfgAohZr=m/hvi/jikllAomZu=m2mvn2tonpqq=m3mdp>mAnr>rfokAosZs=m0svt0tutvww=m1sdv>sAnx>xfujdmY1w3qcf vycvpzyazzaa{||}}m\r|[~v\~Ao\r=m4v4Ao\u=m7v7t=m8~>An>Ao\s=m5v5t=m6~>An>~m[68} v}{{{=OAr=Qppvm_rv_tAn_=QmQmQmvvmm=vm>=top>vm]rv]tAn]=QmQmQmvvmm9vm:9top:vm^rv^tAn^=QmQmQmv~v~mm;~vm<;top<p p}{QppvmbrvbtAnb=QmQmQmvvmmCvmDCtopDvm`rv`t    An `=  Qm  Qm Qm v  v m m?vm@? top@vmarvat ! !An"a=#"Qm$#Qm%#Qm&#v'$~(')() (v*~$m*&% mA~)v+),+,,mBA t,op-Bp.- p/}{.00mhg1meF1mcr 1v2c31243456677mdr689v:dt;9:<;<An=d=>=Qm?>Qm@>QmA>vB?cCBDCD;CvEc?m8EA@997;mEe7cDvF7DGF5GG55mFE;tGvHFrIHJKKLFLMNN3Mm hsLLmfhK MIJm hFIImg JfL11m cs03vO0NPOPPopQhpR/QpSR pTSUVVWWmirVXYvZit[YZ\[\An]i=^]Qm_^Qm`^Qma^vb_zcbdcd[cvez_mXea`YYW[mGWzdvfWdgfUggUUmHG[tgophHPqi{|hqjiT qk j ql+kmnnoomjrnpqvrjtsqrtstAnuj=vuQmwvQmxvQmyvvzw~{z|{|s{v}~wmp}yxqqosmIo~|v~o|~mmmmJIstopJvp}{ pQplpQplQplP{>8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_083.spv000066400000000000000000000103501475742701700273370ustar00rootroot00000000000000# GLSL.std.450main@maincross2d(vf2;vf2;ab pointInTriangle(vf2;vf2;vf2;vf2; p a b c pabparamparampbcparamparampcaparamparamposgl_FragCoordbuf0resolutionparamparamparamparam_GLF_colorG H#GG"G!G!   ! !"!!# !$#!!!!% +%& '+%()+*+#++#,- .-;. /;/ 0 +1333?+2>, 312+4?+5fff?, 645+7=+8>, 978 :-;:+;?,-<;**;,-=***;6>;!;!;!;!;!=-?O @??A0A+= BA C@B>C= D>D>3>6>99#E)FE,GFHIH><GI>=GG86"7!7!JA'K&=LKA'M(=NMOLNA'P&=QPA'R(=SRTQSUOTU86#$7! 7! 7! 7! V;' ;!;!;';!;!;';!;!A'W &=XWA'Y &=ZY[XZA'\ (=]\A'^ (=_^`]_P a[`A'b &=cbA'd &=edfceA'g (=hgA'i (=jikhjP lfk>a>l9m> mA'n &=onA'p &=qproqA's (=tsA'u (=vuwtvP xrwA'y &=zyA'{ &=|{}z|A'~ (=~A' (=P }>x>9>= )*=)*))= )*=)*))V)+A' &=A' &=A' (=A' (=P A' &=A' &=A' (=A' (=P >>9>= )*=)*))= )*=)*)))+,8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_084.spv000066400000000000000000000101241475742701700273370ustar00rootroot00000000000000# GLSL.std.450main@mainmatrix_abuf0matrix_a_unimatrix_bgl_FragCoord matrix_u_GLF_colorHH#HGG"G!G G G G G GGGGGGGGGGGGGGGGGG! ! +!"# $#%$ &%% ';'+!( )% *$ +$;++#,,$-,,,, .#+!/0+#1@ 2$;2+#3?4 +45 6#+!76 8;&;*;* A)9(=%:9>:=$;O $<;;><> -==!(8>0?7@>?A@ABB#C,ADE!7A E0FGEFEGEA.H=#IH #JI1#DCJ=#KHA.L >LK! /BG #MCA.N =#ON #PO#QPM=#RN#SRQ>NSTT#U,GVW!7G W0XYWXWYWA.Z =#[Z #\[1#VU\! /TY#]1U^^!Y_0`"a_`babcc#d,bef!7b f0ghfgfhfA.i =#jiA.k=#lk#mjl#edm! /ch#n]doo!7h p0qrpqprpA.s=#tsA.u =#vu#wnv#xtw>sx! /or__!/^ayy#z,a{|!7a|0}~|}|~|A. =#A.=###{z!/y~#]z!7~0A.=#A. =###>!/>>!/=@!7@0(!7!/0A.=#A.=##A.=##>!/A.=#A.=##>!/=$ $>A65>38KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_085.spv000066400000000000000000000041241475742701700273430ustar00rootroot00000000000000#W GLSL.std.450main@mainiuvstepslopecoordgl_FragCoord refh tex h_GLF_colorGG G G "G !G G GGGGGGGGG!  +  +;,  +!<" #";# $%$ &%;& ' +'()+* ++ ,";,+-=.+/?60;;; ;; ; >>>!="1O21132>3=% =4W"5 4Q 5> =6=7876>8=9=: ;:9> ;=% =<W"=<Q=> >>?@AA=B =C )DBC=)E*)FDEFG?G=H=IJIH>J=K=L MLK> M=% =NW"ONQO> =+>@@>?=oPQP-P.RQQQQSRQTRQURP"VSTU/>V8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/graphicsfuzz_086.spv000066400000000000000000000046541475742701700273540ustar00rootroot00000000000000#h GLSL.std.450main@mainposgl_FragCoordbuf0resolutionlin iters v i_GLF_color indexableG H#GG"G!G !    ; ; +   + + A+ + +!d"+#+$+% &;&+'('+)+*?,+)))*+,?,-,))*,.),)*,/,,)*,0)),*,1,),*,2),,*,3,,,*,4*))*,5)*)*,6**)*,7))**,8*)**,9)***,:****,(;+-./0123+456789:+< =( >6 ?;;; ; ; ;= =@OA@@AB=CBDAC>DAE=FEGFnHGAI=JIKJnLKPMHL>MAN=ONAP=QPRQ SOR> S> !> TTUVWW=X =Y "ZXYZ[U[=\ ]#\=^ _$^`]_a`$> aVV=b cb%> cTU=d ed<> ;A>f e=gf>g8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/corpora/spv/simple.spv000066400000000000000000000013301475742701700255150ustar00rootroot00000000000000#PSMain Xbb.entrysrc.PSMainPSMainPSInputcolor param.var.input in.var.COLORout.var.SV_TARGETinputG G!      !  + ; ;6; = P > 9 >867 A=8KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/random_generator.cpp000066400000000000000000000114611475742701700252550ustar00rootroot00000000000000// Copyright (c) 2021 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "test/fuzzers/random_generator.h" #include #include #include namespace spvtools { namespace fuzzers { namespace { /// Generate integer from uniform distribution /// @tparam I - integer type /// @param engine - random number engine to use /// @param lower - Lower bound of integer generated /// @param upper - Upper bound of integer generated /// @returns i, where lower <= i < upper template I RandomUInt(std::mt19937_64* engine, I lower, I upper) { assert(lower < upper && "|lower| must be stictly less than |upper|"); return std::uniform_int_distribution(lower, upper - 1)(*engine); } /// Helper for obtaining a seed bias value for HashCombine with a bit-width /// dependent on the size of size_t. template struct HashCombineOffset {}; /// Specialization of HashCombineOffset for size_t == 4. template <> struct HashCombineOffset<4> { /// @returns the seed bias value for HashCombine() static constexpr inline uint32_t value() { return 0x9e3779b9; // Fractional portion of Golden Ratio, suggested by // Linux Kernel and Knuth's Art of Computer Programming } }; /// Specialization of HashCombineOffset for size_t == 8. template <> struct HashCombineOffset<8> { /// @returns the seed bias value for HashCombine() static constexpr inline uint64_t value() { return 0x9e3779b97f4a7c16; // Fractional portion of Golden Ratio, suggested // by Linux Kernel and Knuth's Art of Computer // Programming } }; /// HashCombine "hashes" together an existing hash and hashable values. template void HashCombine(size_t* hash, const T& value) { constexpr size_t offset = HashCombineOffset::value(); *hash ^= std::hash()(value) + offset + (*hash << 6) + (*hash >> 2); } /// Calculate the hash for the contents of a C-style data buffer /// @param data - pointer to buffer to be hashed /// @param size - number of elements in buffer /// @returns hash of the data in the buffer size_t HashBuffer(const uint8_t* data, const size_t size) { size_t hash = static_cast(0xCA8945571519E991); // seed with an arbitrary prime HashCombine(&hash, size); for (size_t i = 0; i < size; i++) { HashCombine(&hash, data[i]); } return hash; } } // namespace RandomGenerator::RandomGenerator(uint64_t seed) : engine_(seed) {} RandomGenerator::RandomGenerator(const uint8_t* data, size_t size) { RandomGenerator(RandomGenerator::CalculateSeed(data, size)); } spv_target_env RandomGenerator::GetTargetEnv() { spv_target_env result; // Need to check that the generated value isn't for a deprecated target env. do { result = static_cast( RandomUInt(&engine_, 0u, static_cast(SPV_ENV_MAX))); } while (!spvIsValidEnv(result)); return result; } uint32_t RandomGenerator::GetUInt32(uint32_t lower, uint32_t upper) { return RandomUInt(&engine_, lower, upper); } uint32_t RandomGenerator::GetUInt32(uint32_t bound) { assert(bound > 0 && "|bound| must be greater than 0"); return RandomUInt(&engine_, 0u, bound); } uint64_t RandomGenerator::CalculateSeed(const uint8_t* data, size_t size) { assert(data != nullptr && "|data| must be !nullptr"); // Number of bytes we want to skip at the start of data for the hash. // Fewer bytes may be skipped when `size` is small. // Has lower precedence than kHashDesiredMinBytes. static const int64_t kHashDesiredLeadingSkipBytes = 5; // Minimum number of bytes we want to use in the hash. // Used for short buffers. static const int64_t kHashDesiredMinBytes = 4; // Maximum number of bytes we want to use in the hash. static const int64_t kHashDesiredMaxBytes = 32; int64_t size_i64 = static_cast(size); int64_t hash_begin_i64 = std::min(kHashDesiredLeadingSkipBytes, std::max(size_i64 - kHashDesiredMinBytes, 0)); int64_t hash_end_i64 = std::min(hash_begin_i64 + kHashDesiredMaxBytes, size_i64); size_t hash_begin = static_cast(hash_begin_i64); size_t hash_size = static_cast(hash_end_i64) - hash_begin; return HashBuffer(data + hash_begin, hash_size); } } // namespace fuzzers } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/random_generator.h000066400000000000000000000043401475742701700247200ustar00rootroot00000000000000// Copyright (c) 2021 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef TEST_FUZZERS_RANDOM_GENERATOR_H_ #define TEST_FUZZERS_RANDOM_GENERATOR_H_ #include #include #include "source/spirv_target_env.h" namespace spvtools { namespace fuzzers { /// Pseudo random generator utility class for fuzzing class RandomGenerator { public: /// @brief Initializes the internal engine /// @param seed - seed value passed to engine explicit RandomGenerator(uint64_t seed); /// @brief Initializes the internal engine /// @param data - data to calculate the seed from /// @param size - size of the data explicit RandomGenerator(const uint8_t* data, size_t size); ~RandomGenerator() {} /// Calculate a seed value based on a blob of data. /// Currently hashes bytes near the front of the buffer, after skipping N /// bytes. /// @param data - pointer to data to base calculation off of, must be !nullptr /// @param size - number of elements in |data|, must be > 0 static uint64_t CalculateSeed(const uint8_t* data, size_t size); /// Get random valid target env. spv_target_env GetTargetEnv(); /// Get uint32_t value from uniform distribution. /// @param lower - lower bound of integer generated /// @param upper - upper bound of integer generated /// @returns i, where lower <= i < upper uint32_t GetUInt32(uint32_t lower, uint32_t upper); /// Get uint32_t value from uniform distribution. /// @param bound - Upper bound of integer generated /// @returns i, where 0 <= i < bound uint32_t GetUInt32(uint32_t bound); private: std::mt19937_64 engine_; }; // class RandomGenerator } // namespace fuzzers } // namespace spvtools #endif // TEST_FUZZERS_RANDOM_GENERATOR_UTILS_H_ KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/spvtools_as_fuzzer.cpp000066400000000000000000000041261475742701700257100ustar00rootroot00000000000000// Copyright (c) 2019 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include // memcpy #include #include "source/spirv_target_env.h" #include "spirv-tools/libspirv.hpp" #include "test/fuzzers/random_generator.h" extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { spv_target_env target_env = SPV_ENV_UNIVERSAL_1_0; if (size > 0) { spvtools::fuzzers::RandomGenerator random_gen(data, size); target_env = random_gen.GetTargetEnv(); } const spv_context context = spvContextCreate(target_env); if (context == nullptr) { return 0; } std::vector contents; contents.resize(size); memcpy(contents.data(), data, size); spv_binary binary = nullptr; spv_diagnostic diagnostic = nullptr; spvTextToBinaryWithOptions(context, contents.data(), contents.size(), SPV_TEXT_TO_BINARY_OPTION_NONE, &binary, &diagnostic); if (diagnostic) { spvDiagnosticPrint(diagnostic); spvDiagnosticDestroy(diagnostic); diagnostic = nullptr; } if (binary) { spvBinaryDestroy(binary); binary = nullptr; } spvTextToBinaryWithOptions(context, contents.data(), contents.size(), SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS, &binary, &diagnostic); if (diagnostic) { spvDiagnosticPrint(diagnostic); spvDiagnosticDestroy(diagnostic); diagnostic = nullptr; } if (binary) { spvBinaryDestroy(binary); binary = nullptr; } spvContextDestroy(context); return 0; } KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/spvtools_binary_parser_fuzzer.cpp000066400000000000000000000025751475742701700301530ustar00rootroot00000000000000// Copyright (c) 2018 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "spirv-tools/libspirv.hpp" #include "test/fuzzers/random_generator.h" extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { if (size < 1) { return 0; } spvtools::fuzzers::RandomGenerator random_gen(data, size); const spv_context context = spvContextCreate(random_gen.GetTargetEnv()); if (context == nullptr) { return 0; } std::vector input; input.resize(size >> 2); size_t count = 0; for (size_t i = 0; (i + 3) < size; i += 4) { input[count++] = data[i] | (data[i + 1] << 8) | (data[i + 2] << 16) | (data[i + 3]) << 24; } spvBinaryParse(context, nullptr, input.data(), input.size(), nullptr, nullptr, nullptr); spvContextDestroy(context); return 0; } KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/spvtools_dis_fuzzer.cpp000066400000000000000000000045051475742701700260650ustar00rootroot00000000000000// Copyright (c) 2019 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include // memcpy #include #include "source/spirv_target_env.h" #include "spirv-tools/libspirv.hpp" #include "test/fuzzers/random_generator.h" extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { if (size < 4) { // There are not enough bytes to constitute a binary that can be // disassembled. return 0; } spvtools::fuzzers::RandomGenerator random_gen(data, size); const spv_context context = spvContextCreate(random_gen.GetTargetEnv()); if (context == nullptr) { return 0; } std::vector input; input.resize(size >> 2); size_t count = 0; for (size_t i = 0; (i + 3) < size; i += 4) { input[count++] = data[i] | (data[i + 1] << 8) | (data[i + 2] << 16) | (data[i + 3]) << 24; } std::vector input_str; size_t char_count = input.size() * sizeof(uint32_t) / sizeof(char); input_str.resize(char_count); memcpy(input_str.data(), input.data(), input.size() * sizeof(uint32_t)); spv_text text = nullptr; spv_diagnostic diagnostic = nullptr; for (uint32_t options = SPV_BINARY_TO_TEXT_OPTION_NONE; options < (SPV_BINARY_TO_TEXT_OPTION_PRINT | SPV_BINARY_TO_TEXT_OPTION_COLOR | SPV_BINARY_TO_TEXT_OPTION_INDENT | SPV_BINARY_TO_TEXT_OPTION_SHOW_BYTE_OFFSET | SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); options++) { spvBinaryToText(context, input.data(), input.size(), options, &text, &diagnostic); if (diagnostic) { spvDiagnosticDestroy(diagnostic); diagnostic = nullptr; } if (text) { spvTextDestroy(text); text = nullptr; } } spvContextDestroy(context); return 0; } KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/spvtools_fuzz_fuzzer.cpp000066400000000000000000000061771475742701700263130ustar00rootroot00000000000000// Copyright (c) 2021 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "source/fuzz/fuzzer.h" #include "source/fuzz/pseudo_random_generator.h" #include "spirv-tools/libspirv.hpp" #include "test/fuzzers/random_generator.h" extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { if (size == 0 || (size % sizeof(uint32_t)) != 0) { // An empty binary, or a binary whose size is not a multiple of word-size, // cannot be valid, so can be rejected immediately. return 0; } std::vector initial_binary(size / sizeof(uint32_t)); memcpy(initial_binary.data(), data, size); spvtools::ValidatorOptions validator_options; spvtools::MessageConsumer message_consumer = [](spv_message_level_t, const char*, const spv_position_t&, const char*) { }; spvtools::fuzzers::RandomGenerator random_gen(data, size); auto target_env = random_gen.GetTargetEnv(); std::unique_ptr ir_context; if (!spvtools::fuzz::fuzzerutil::BuildIRContext( target_env, message_consumer, initial_binary, validator_options, &ir_context)) { // The input is invalid - give up. return 0; } std::vector donor_suppliers = { [&initial_binary, message_consumer, target_env, &validator_options]() -> std::unique_ptr { std::unique_ptr result; if (!spvtools::fuzz::fuzzerutil::BuildIRContext( target_env, message_consumer, initial_binary, validator_options, &result)) { // The input was successfully parsed and validated first time around, // so something is wrong if it is now invalid. abort(); } return result; }}; uint32_t seed = random_gen.GetUInt32(std::numeric_limits::max()); auto fuzzer_context = spvtools::MakeUnique( spvtools::MakeUnique(seed), spvtools::fuzz::FuzzerContext::GetMinFreshId(ir_context.get()), false); auto transformation_context = spvtools::MakeUnique( spvtools::MakeUnique(ir_context.get()), validator_options); spvtools::fuzz::Fuzzer fuzzer( std::move(ir_context), std::move(transformation_context), std::move(fuzzer_context), message_consumer, donor_suppliers, false, spvtools::fuzz::RepeatedPassStrategy::kLoopedWithRecommendations, true, validator_options); fuzzer.Run(0); return 0; } KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/spvtools_opt_fuzzer_common.cpp000066400000000000000000000061251475742701700274600ustar00rootroot00000000000000// Copyright (c) 2021 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "test/fuzzers/spvtools_opt_fuzzer_common.h" #include "source/opt/build_module.h" #include "test/fuzzers/random_generator.h" namespace spvtools { namespace fuzzers { int OptFuzzerTestOneInput( const uint8_t* data, size_t size, const std::function& register_passes) { if (size < 1) { return 0; } spvtools::fuzzers::RandomGenerator random_gen(data, size); auto target_env = random_gen.GetTargetEnv(); spvtools::Optimizer optimizer(target_env); optimizer.SetMessageConsumer([](spv_message_level_t, const char*, const spv_position_t&, const char*) {}); std::vector input; input.resize(size >> 2); size_t count = 0; for (size_t i = 0; (i + 3) < size; i += 4) { input[count++] = data[i] | (data[i + 1] << 8) | (data[i + 2] << 16) | (data[i + 3]) << 24; } // The largest possible id bound is used when running the optimizer, to avoid // the problem of id overflows. const size_t kFinalIdLimit = UINT32_MAX; // The input is scanned to check that it does not already use an id too close // to this limit. This still gives the optimizer a large set of ids to // consume. It is thus very unlikely that id overflow will occur during // fuzzing. If it does, then the initial id limit should be decreased. const size_t kInitialIdLimit = kFinalIdLimit - 1000000U; // Build the module and scan it to check that all used ids are below the // initial limit. auto ir_context = spvtools::BuildModule(target_env, nullptr, input.data(), input.size()); if (ir_context == nullptr) { // It was not possible to build a valid module; that's OK - skip this input. return 0; } if (ir_context->module()->id_bound() >= kInitialIdLimit) { // The input already has a very large id bound. The input is thus abandoned, // to avoid the possibility of ending up hitting the id bound limit. return 0; } // Set the optimizer and its validator up with the largest possible id bound // limit. spvtools::ValidatorOptions validator_options; spvtools::OptimizerOptions optimizer_options; optimizer_options.set_max_id_bound(kFinalIdLimit); validator_options.SetUniversalLimit(spv_validator_limit_max_id_bound, kFinalIdLimit); optimizer_options.set_validator_options(validator_options); register_passes(optimizer); optimizer.Run(input.data(), input.size(), &input, optimizer_options); return 0; } } // namespace fuzzers } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/spvtools_opt_fuzzer_common.h000066400000000000000000000022101475742701700271140ustar00rootroot00000000000000// Copyright (c) 2021 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef TEST_FUZZERS_SPVTOOLS_OPT_FUZZER_COMMON_H_ #define TEST_FUZZERS_SPVTOOLS_OPT_FUZZER_COMMON_H_ #include #include #include #include "spirv-tools/optimizer.hpp" namespace spvtools { namespace fuzzers { // Helper function capturing the common logic for the various optimizer fuzzers. int OptFuzzerTestOneInput( const uint8_t* data, size_t size, const std::function& register_passes); } // namespace fuzzers } // namespace spvtools #endif // TEST_FUZZERS_SPVTOOLS_OPT_FUZZER_COMMON_H_ KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/spvtools_opt_legalization_fuzzer.cpp000066400000000000000000000017431475742701700306530ustar00rootroot00000000000000// Copyright (c) 2018 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include "spirv-tools/optimizer.hpp" #include "test/fuzzers/spvtools_opt_fuzzer_common.h" extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { return spvtools::fuzzers::OptFuzzerTestOneInput( data, size, [](spvtools::Optimizer& optimizer) -> void { optimizer.RegisterLegalizationPasses(); }); } KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/spvtools_opt_performance_fuzzer.cpp000066400000000000000000000017421475742701700304710ustar00rootroot00000000000000// Copyright (c) 2018 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include "spirv-tools/optimizer.hpp" #include "test/fuzzers/spvtools_opt_fuzzer_common.h" extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { return spvtools::fuzzers::OptFuzzerTestOneInput( data, size, [](spvtools::Optimizer& optimizer) -> void { optimizer.RegisterPerformancePasses(); }); } KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/spvtools_opt_size_fuzzer.cpp000066400000000000000000000017331475742701700271420ustar00rootroot00000000000000// Copyright (c) 2018 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include "spirv-tools/optimizer.hpp" #include "test/fuzzers/spvtools_opt_fuzzer_common.h" extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { return spvtools::fuzzers::OptFuzzerTestOneInput( data, size, [](spvtools::Optimizer& optimizer) -> void { optimizer.RegisterSizePasses(); }); } KhronosGroup-SPIRV-Tools-f289d04/test/fuzzers/spvtools_val_fuzzer.cpp000066400000000000000000000025221475742701700260650ustar00rootroot00000000000000// Copyright (c) 2018 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "spirv-tools/libspirv.hpp" #include "test/fuzzers/random_generator.h" extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { if (size < 1) { return 0; } spvtools::fuzzers::RandomGenerator random_gen(data, size); spvtools::SpirvTools tools(random_gen.GetTargetEnv()); tools.SetMessageConsumer([](spv_message_level_t, const char*, const spv_position_t&, const char*) {}); std::vector input; input.resize(size >> 2); size_t count = 0; for (size_t i = 0; (i + 3) < size; i += 4) { input[count++] = data[i] | (data[i + 1] << 8) | (data[i + 2] << 16) | (data[i + 3]) << 24; } tools.Validate(input); return 0; } KhronosGroup-SPIRV-Tools-f289d04/test/generator_magic_number_test.cpp000066400000000000000000000040731475742701700257550ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include #include "gmock/gmock.h" #include "source/opcode.h" #include "test/unit_spirv.h" namespace spvtools { namespace { using ::spvtest::EnumCase; using ::testing::Eq; using GeneratorMagicNumberTest = ::testing::TestWithParam>; TEST_P(GeneratorMagicNumberTest, Single) { EXPECT_THAT(std::string(spvGeneratorStr(GetParam().value())), GetParam().name()); } INSTANTIATE_TEST_SUITE_P( Registered, GeneratorMagicNumberTest, ::testing::ValuesIn(std::vector>{ {SPV_GENERATOR_KHRONOS, "Khronos"}, {SPV_GENERATOR_LUNARG, "LunarG"}, {SPV_GENERATOR_VALVE, "Valve"}, {SPV_GENERATOR_CODEPLAY, "Codeplay"}, {SPV_GENERATOR_NVIDIA, "NVIDIA"}, {SPV_GENERATOR_ARM, "ARM"}, {SPV_GENERATOR_KHRONOS_LLVM_TRANSLATOR, "Khronos LLVM/SPIR-V Translator"}, {SPV_GENERATOR_KHRONOS_ASSEMBLER, "Khronos SPIR-V Tools Assembler"}, {SPV_GENERATOR_KHRONOS_GLSLANG, "Khronos Glslang Reference Front End"}, })); INSTANTIATE_TEST_SUITE_P( Unregistered, GeneratorMagicNumberTest, ::testing::ValuesIn(std::vector>{ // We read registered entries from the SPIR-V XML Registry file // which can change over time. {spv_generator_t(1000), "Unknown"}, {spv_generator_t(9999), "Unknown"}, })); } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/hex_float_test.cpp000066400000000000000000002017251475742701700232330ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include #include #include #include #include #include #include "gmock/gmock.h" #include "source/util/hex_float.h" #include "test/unit_spirv.h" namespace spvtools { namespace utils { namespace { using ::testing::Eq; // In this file "encode" means converting a number into a string, // and "decode" means converting a string into a number. using HexFloatTest = ::testing::TestWithParam, std::string>>; using DecodeHexFloatTest = ::testing::TestWithParam>>; using HexDoubleTest = ::testing::TestWithParam, std::string>>; using DecodeHexDoubleTest = ::testing::TestWithParam>>; using RoundTripFloatTest = ::testing::TestWithParam; using RoundTripDoubleTest = ::testing::TestWithParam; // Hex-encodes a float value. template std::string EncodeViaHexFloat(const T& value) { std::stringstream ss; ss << HexFloat(value); return ss.str(); } // The following two tests can't be DRY because they take different parameter // types. TEST_P(HexFloatTest, EncodeCorrectly) { EXPECT_THAT(EncodeViaHexFloat(GetParam().first), Eq(GetParam().second)); } TEST_P(HexDoubleTest, EncodeCorrectly) { EXPECT_THAT(EncodeViaHexFloat(GetParam().first), Eq(GetParam().second)); } // Decodes a hex-float string. template FloatProxy Decode(const std::string& str) { HexFloat> decoded(0.f); EXPECT_TRUE((std::stringstream(str) >> decoded).eof()); return decoded.value(); } TEST_P(HexFloatTest, DecodeCorrectly) { EXPECT_THAT(Decode(GetParam().second), Eq(GetParam().first)); } TEST_P(HexDoubleTest, DecodeCorrectly) { EXPECT_THAT(Decode(GetParam().second), Eq(GetParam().first)); } INSTANTIATE_TEST_SUITE_P( Float32Tests, HexFloatTest, ::testing::ValuesIn(std::vector, std::string>>({ {0.f, "0x0p+0"}, {1.f, "0x1p+0"}, {2.f, "0x1p+1"}, {3.f, "0x1.8p+1"}, {0.5f, "0x1p-1"}, {0.25f, "0x1p-2"}, {0.75f, "0x1.8p-1"}, {-0.f, "-0x0p+0"}, {-1.f, "-0x1p+0"}, {-0.5f, "-0x1p-1"}, {-0.25f, "-0x1p-2"}, {-0.75f, "-0x1.8p-1"}, // Larger numbers {512.f, "0x1p+9"}, {-512.f, "-0x1p+9"}, {1024.f, "0x1p+10"}, {-1024.f, "-0x1p+10"}, {1024.f + 8.f, "0x1.02p+10"}, {-1024.f - 8.f, "-0x1.02p+10"}, // Small numbers {1.0f / 512.f, "0x1p-9"}, {1.0f / -512.f, "-0x1p-9"}, {1.0f / 1024.f, "0x1p-10"}, {1.0f / -1024.f, "-0x1p-10"}, {1.0f / 1024.f + 1.0f / 8.f, "0x1.02p-3"}, {1.0f / -1024.f - 1.0f / 8.f, "-0x1.02p-3"}, // lowest non-denorm {float(ldexp(1.0f, -126)), "0x1p-126"}, {float(ldexp(-1.0f, -126)), "-0x1p-126"}, // Denormalized values {float(ldexp(1.0f, -127)), "0x1p-127"}, {float(ldexp(1.0f, -127) / 2.0f), "0x1p-128"}, {float(ldexp(1.0f, -127) / 4.0f), "0x1p-129"}, {float(ldexp(1.0f, -127) / 8.0f), "0x1p-130"}, {float(ldexp(-1.0f, -127)), "-0x1p-127"}, {float(ldexp(-1.0f, -127) / 2.0f), "-0x1p-128"}, {float(ldexp(-1.0f, -127) / 4.0f), "-0x1p-129"}, {float(ldexp(-1.0f, -127) / 8.0f), "-0x1p-130"}, {float(ldexp(1.0, -127) + (ldexp(1.0, -127) / 2.0f)), "0x1.8p-127"}, {float(ldexp(1.0, -127) / 2.0 + (ldexp(1.0, -127) / 4.0f)), "0x1.8p-128"}, }))); INSTANTIATE_TEST_SUITE_P( Float32NanTests, HexFloatTest, ::testing::ValuesIn(std::vector, std::string>>({ // Various NAN and INF cases {uint32_t(0xFF800000), "-0x1p+128"}, // -inf {uint32_t(0x7F800000), "0x1p+128"}, // inf {uint32_t(0xFFC00000), "-0x1.8p+128"}, // -nan {uint32_t(0xFF800100), "-0x1.0002p+128"}, // -nan {uint32_t(0xFF800c00), "-0x1.0018p+128"}, // -nan {uint32_t(0xFF80F000), "-0x1.01ep+128"}, // -nan {uint32_t(0xFFFFFFFF), "-0x1.fffffep+128"}, // -nan {uint32_t(0x7FC00000), "0x1.8p+128"}, // +nan {uint32_t(0x7F800100), "0x1.0002p+128"}, // +nan {uint32_t(0x7f800c00), "0x1.0018p+128"}, // +nan {uint32_t(0x7F80F000), "0x1.01ep+128"}, // +nan {uint32_t(0x7FFFFFFF), "0x1.fffffep+128"}, // +nan }))); INSTANTIATE_TEST_SUITE_P( Float64Tests, HexDoubleTest, ::testing::ValuesIn( std::vector, std::string>>({ {0., "0x0p+0"}, {1., "0x1p+0"}, {2., "0x1p+1"}, {3., "0x1.8p+1"}, {0.5, "0x1p-1"}, {0.25, "0x1p-2"}, {0.75, "0x1.8p-1"}, {-0., "-0x0p+0"}, {-1., "-0x1p+0"}, {-0.5, "-0x1p-1"}, {-0.25, "-0x1p-2"}, {-0.75, "-0x1.8p-1"}, // Larger numbers {512., "0x1p+9"}, {-512., "-0x1p+9"}, {1024., "0x1p+10"}, {-1024., "-0x1p+10"}, {1024. + 8., "0x1.02p+10"}, {-1024. - 8., "-0x1.02p+10"}, // Large outside the range of normal floats {ldexp(1.0, 128), "0x1p+128"}, {ldexp(1.0, 129), "0x1p+129"}, {ldexp(-1.0, 128), "-0x1p+128"}, {ldexp(-1.0, 129), "-0x1p+129"}, {ldexp(1.0, 128) + ldexp(1.0, 90), "0x1.0000000004p+128"}, {ldexp(1.0, 129) + ldexp(1.0, 120), "0x1.008p+129"}, {ldexp(-1.0, 128) + ldexp(1.0, 90), "-0x1.fffffffff8p+127"}, {ldexp(-1.0, 129) + ldexp(1.0, 120), "-0x1.ffp+128"}, // Small numbers {1.0 / 512., "0x1p-9"}, {1.0 / -512., "-0x1p-9"}, {1.0 / 1024., "0x1p-10"}, {1.0 / -1024., "-0x1p-10"}, {1.0 / 1024. + 1.0 / 8., "0x1.02p-3"}, {1.0 / -1024. - 1.0 / 8., "-0x1.02p-3"}, // Small outside the range of normal floats {ldexp(1.0, -128), "0x1p-128"}, {ldexp(1.0, -129), "0x1p-129"}, {ldexp(-1.0, -128), "-0x1p-128"}, {ldexp(-1.0, -129), "-0x1p-129"}, {ldexp(1.0, -128) + ldexp(1.0, -90), "0x1.0000000004p-90"}, {ldexp(1.0, -129) + ldexp(1.0, -120), "0x1.008p-120"}, {ldexp(-1.0, -128) + ldexp(1.0, -90), "0x1.fffffffff8p-91"}, {ldexp(-1.0, -129) + ldexp(1.0, -120), "0x1.ffp-121"}, // lowest non-denorm {ldexp(1.0, -1022), "0x1p-1022"}, {ldexp(-1.0, -1022), "-0x1p-1022"}, // Denormalized values {ldexp(1.0, -1023), "0x1p-1023"}, {ldexp(1.0, -1023) / 2.0, "0x1p-1024"}, {ldexp(1.0, -1023) / 4.0, "0x1p-1025"}, {ldexp(1.0, -1023) / 8.0, "0x1p-1026"}, {ldexp(-1.0, -1024), "-0x1p-1024"}, {ldexp(-1.0, -1024) / 2.0, "-0x1p-1025"}, {ldexp(-1.0, -1024) / 4.0, "-0x1p-1026"}, {ldexp(-1.0, -1024) / 8.0, "-0x1p-1027"}, {ldexp(1.0, -1023) + (ldexp(1.0, -1023) / 2.0), "0x1.8p-1023"}, {ldexp(1.0, -1023) / 2.0 + (ldexp(1.0, -1023) / 4.0), "0x1.8p-1024"}, }))); INSTANTIATE_TEST_SUITE_P( Float64NanTests, HexDoubleTest, ::testing::ValuesIn(std::vector< std::pair, std::string>>({ // Various NAN and INF cases {uint64_t(0xFFF0000000000000LL), "-0x1p+1024"}, // -inf {uint64_t(0x7FF0000000000000LL), "0x1p+1024"}, // +inf {uint64_t(0xFFF8000000000000LL), "-0x1.8p+1024"}, // -nan {uint64_t(0xFFF0F00000000000LL), "-0x1.0fp+1024"}, // -nan {uint64_t(0xFFF0000000000001LL), "-0x1.0000000000001p+1024"}, // -nan {uint64_t(0xFFF0000300000000LL), "-0x1.00003p+1024"}, // -nan {uint64_t(0xFFFFFFFFFFFFFFFFLL), "-0x1.fffffffffffffp+1024"}, // -nan {uint64_t(0x7FF8000000000000LL), "0x1.8p+1024"}, // +nan {uint64_t(0x7FF0F00000000000LL), "0x1.0fp+1024"}, // +nan {uint64_t(0x7FF0000000000001LL), "0x1.0000000000001p+1024"}, // -nan {uint64_t(0x7FF0000300000000LL), "0x1.00003p+1024"}, // -nan {uint64_t(0x7FFFFFFFFFFFFFFFLL), "0x1.fffffffffffffp+1024"}, // -nan }))); // Tests that encoding a value and decoding it again restores // the same value. TEST_P(RoundTripFloatTest, CanStoreAccurately) { std::stringstream ss; ss << FloatProxy(GetParam()); ss.seekg(0); FloatProxy res; ss >> res; EXPECT_THAT(GetParam(), Eq(res.getAsFloat())); } TEST_P(RoundTripDoubleTest, CanStoreAccurately) { std::stringstream ss; ss << FloatProxy(GetParam()); ss.seekg(0); FloatProxy res; ss >> res; EXPECT_THAT(GetParam(), Eq(res.getAsFloat())); } INSTANTIATE_TEST_SUITE_P( Float32StoreTests, RoundTripFloatTest, ::testing::ValuesIn(std::vector( {// Value requiring more than 6 digits of precision to be // represented accurately. 3.0000002f}))); INSTANTIATE_TEST_SUITE_P( Float64StoreTests, RoundTripDoubleTest, ::testing::ValuesIn(std::vector( {// Value requiring more than 15 digits of precision to be // represented accurately. 1.5000000000000002}))); TEST(HexFloatStreamTest, OperatorLeftShiftPreservesFloatAndFill) { std::stringstream s; s << std::setw(4) << std::oct << std::setfill('x') << 8 << " " << FloatProxy(uint32_t(0xFF800100)) << " " << std::setw(4) << 9; EXPECT_THAT(s.str(), Eq(std::string("xx10 -0x1.0002p+128 xx11"))); } TEST(HexDoubleStreamTest, OperatorLeftShiftPreservesFloatAndFill) { std::stringstream s; s << std::setw(4) << std::oct << std::setfill('x') << 8 << " " << FloatProxy(uint64_t(0x7FF0F00000000000LL)) << " " << std::setw(4) << 9; EXPECT_THAT(s.str(), Eq(std::string("xx10 0x1.0fp+1024 xx11"))); } TEST_P(DecodeHexFloatTest, DecodeCorrectly) { EXPECT_THAT(Decode(GetParam().first), Eq(GetParam().second)); } TEST_P(DecodeHexDoubleTest, DecodeCorrectly) { EXPECT_THAT(Decode(GetParam().first), Eq(GetParam().second)); } INSTANTIATE_TEST_SUITE_P( Float32DecodeTests, DecodeHexFloatTest, ::testing::ValuesIn(std::vector>>({ {"0x0p+000", 0.f}, {"0x0p0", 0.f}, {"0x0p-0", 0.f}, // flush to zero cases {"0x1p-500", 0.f}, // Exponent underflows. {"-0x1p-500", -0.f}, {"0x0.00000000001p-126", 0.f}, // Fraction causes underflow. {"-0x0.0000000001p-127", -0.f}, {"-0x0.01p-142", -0.f}, // Fraction causes additional underflow. {"0x0.01p-142", 0.f}, // Some floats that do not encode the same way as they decode. {"0x2p+0", 2.f}, {"0xFFp+0", 255.f}, {"0x0.8p+0", 0.5f}, {"0x0.4p+0", 0.25f}, }))); INSTANTIATE_TEST_SUITE_P( Float32DecodeInfTests, DecodeHexFloatTest, ::testing::ValuesIn(std::vector>>({ // inf cases {"-0x1p+128", uint32_t(0xFF800000)}, // -inf {"0x32p+127", uint32_t(0x7F800000)}, // inf {"0x32p+500", uint32_t(0x7F800000)}, // inf {"-0x32p+127", uint32_t(0xFF800000)}, // -inf }))); INSTANTIATE_TEST_SUITE_P( Float64DecodeTests, DecodeHexDoubleTest, ::testing::ValuesIn( std::vector>>({ {"0x0p+000", 0.}, {"0x0p0", 0.}, {"0x0p-0", 0.}, // flush to zero cases {"0x1p-5000", 0.}, // Exponent underflows. {"-0x1p-5000", -0.}, {"0x0.0000000000000001p-1023", 0.}, // Fraction causes underflow. {"-0x0.000000000000001p-1024", -0.}, {"-0x0.01p-1090", -0.f}, // Fraction causes additional underflow. {"0x0.01p-1090", 0.}, // Some floats that do not encode the same way as they decode. {"0x2p+0", 2.}, {"0xFFp+0", 255.}, {"0x0.8p+0", 0.5}, {"0x0.4p+0", 0.25}, }))); INSTANTIATE_TEST_SUITE_P( Float64DecodeInfTests, DecodeHexDoubleTest, ::testing::ValuesIn( std::vector>>({ // inf cases {"-0x1p+1024", uint64_t(0xFFF0000000000000)}, // -inf {"0x32p+1023", uint64_t(0x7FF0000000000000)}, // inf {"0x32p+5000", uint64_t(0x7FF0000000000000)}, // inf {"-0x32p+1023", uint64_t(0xFFF0000000000000)}, // -inf }))); TEST(FloatProxy, ValidConversion) { EXPECT_THAT(FloatProxy(1.f).getAsFloat(), Eq(1.0f)); EXPECT_THAT(FloatProxy(32.f).getAsFloat(), Eq(32.0f)); EXPECT_THAT(FloatProxy(-1.f).getAsFloat(), Eq(-1.0f)); EXPECT_THAT(FloatProxy(0.f).getAsFloat(), Eq(0.0f)); EXPECT_THAT(FloatProxy(-0.f).getAsFloat(), Eq(-0.0f)); EXPECT_THAT(FloatProxy(1.2e32f).getAsFloat(), Eq(1.2e32f)); EXPECT_TRUE(std::isinf(FloatProxy(uint32_t(0xFF800000)).getAsFloat())); EXPECT_TRUE(std::isinf(FloatProxy(uint32_t(0x7F800000)).getAsFloat())); EXPECT_TRUE(std::isnan(FloatProxy(uint32_t(0xFFC00000)).getAsFloat())); EXPECT_TRUE(std::isnan(FloatProxy(uint32_t(0xFF800100)).getAsFloat())); EXPECT_TRUE(std::isnan(FloatProxy(uint32_t(0xFF800c00)).getAsFloat())); EXPECT_TRUE(std::isnan(FloatProxy(uint32_t(0xFF80F000)).getAsFloat())); EXPECT_TRUE(std::isnan(FloatProxy(uint32_t(0xFFFFFFFF)).getAsFloat())); EXPECT_TRUE(std::isnan(FloatProxy(uint32_t(0x7FC00000)).getAsFloat())); EXPECT_TRUE(std::isnan(FloatProxy(uint32_t(0x7F800100)).getAsFloat())); EXPECT_TRUE(std::isnan(FloatProxy(uint32_t(0x7f800c00)).getAsFloat())); EXPECT_TRUE(std::isnan(FloatProxy(uint32_t(0x7F80F000)).getAsFloat())); EXPECT_TRUE(std::isnan(FloatProxy(uint32_t(0x7FFFFFFF)).getAsFloat())); EXPECT_THAT(FloatProxy(uint32_t(0xFF800000)).data(), Eq(0xFF800000u)); EXPECT_THAT(FloatProxy(uint32_t(0x7F800000)).data(), Eq(0x7F800000u)); EXPECT_THAT(FloatProxy(uint32_t(0xFFC00000)).data(), Eq(0xFFC00000u)); EXPECT_THAT(FloatProxy(uint32_t(0xFF800100)).data(), Eq(0xFF800100u)); EXPECT_THAT(FloatProxy(uint32_t(0xFF800c00)).data(), Eq(0xFF800c00u)); EXPECT_THAT(FloatProxy(uint32_t(0xFF80F000)).data(), Eq(0xFF80F000u)); EXPECT_THAT(FloatProxy(uint32_t(0xFFFFFFFF)).data(), Eq(0xFFFFFFFFu)); EXPECT_THAT(FloatProxy(uint32_t(0x7FC00000)).data(), Eq(0x7FC00000u)); EXPECT_THAT(FloatProxy(uint32_t(0x7F800100)).data(), Eq(0x7F800100u)); EXPECT_THAT(FloatProxy(uint32_t(0x7f800c00)).data(), Eq(0x7f800c00u)); EXPECT_THAT(FloatProxy(uint32_t(0x7F80F000)).data(), Eq(0x7F80F000u)); EXPECT_THAT(FloatProxy(uint32_t(0x7FFFFFFF)).data(), Eq(0x7FFFFFFFu)); } TEST(FloatProxy, Nan) { EXPECT_TRUE(FloatProxy(uint32_t(0xFFC00000)).isNan()); EXPECT_TRUE(FloatProxy(uint32_t(0xFF800100)).isNan()); EXPECT_TRUE(FloatProxy(uint32_t(0xFF800c00)).isNan()); EXPECT_TRUE(FloatProxy(uint32_t(0xFF80F000)).isNan()); EXPECT_TRUE(FloatProxy(uint32_t(0xFFFFFFFF)).isNan()); EXPECT_TRUE(FloatProxy(uint32_t(0x7FC00000)).isNan()); EXPECT_TRUE(FloatProxy(uint32_t(0x7F800100)).isNan()); EXPECT_TRUE(FloatProxy(uint32_t(0x7f800c00)).isNan()); EXPECT_TRUE(FloatProxy(uint32_t(0x7F80F000)).isNan()); EXPECT_TRUE(FloatProxy(uint32_t(0x7FFFFFFF)).isNan()); } TEST(FloatProxy, Negation) { EXPECT_THAT((-FloatProxy(1.f)).getAsFloat(), Eq(-1.0f)); EXPECT_THAT((-FloatProxy(0.f)).getAsFloat(), Eq(-0.0f)); EXPECT_THAT((-FloatProxy(-1.f)).getAsFloat(), Eq(1.0f)); EXPECT_THAT((-FloatProxy(-0.f)).getAsFloat(), Eq(0.0f)); EXPECT_THAT((-FloatProxy(32.f)).getAsFloat(), Eq(-32.0f)); EXPECT_THAT((-FloatProxy(-32.f)).getAsFloat(), Eq(32.0f)); EXPECT_THAT((-FloatProxy(1.2e32f)).getAsFloat(), Eq(-1.2e32f)); EXPECT_THAT((-FloatProxy(-1.2e32f)).getAsFloat(), Eq(1.2e32f)); EXPECT_THAT( (-FloatProxy(std::numeric_limits::infinity())).getAsFloat(), Eq(-std::numeric_limits::infinity())); EXPECT_THAT((-FloatProxy(-std::numeric_limits::infinity())) .getAsFloat(), Eq(std::numeric_limits::infinity())); } // Test conversion of FloatProxy values to strings. // // In previous cases, we always wrapped the FloatProxy value in a HexFloat // before conversion to a string. In the following cases, the FloatProxy // decides for itself whether to print as a regular number or as a hex float. using FloatProxyFloatTest = ::testing::TestWithParam, std::string>>; using FloatProxyDoubleTest = ::testing::TestWithParam, std::string>>; // Converts a float value to a string via a FloatProxy. template std::string EncodeViaFloatProxy(const T& value) { std::stringstream ss; ss << value; return ss.str(); } // Converts a floating point string so that the exponent prefix // is 'e', and the exponent value does not have leading zeros. // The Microsoft runtime library likes to write things like "2.5E+010". // Convert that to "2.5e+10". // We don't care what happens to strings that are not floating point // strings. std::string NormalizeExponentInFloatString(std::string in) { std::string result; // Reserve one spot for the terminating null, even when the sscanf fails. std::vector prefix(in.size() + 1); char e; char plus_or_minus; int exponent; // in base 10 if ((4 == std::sscanf(in.c_str(), "%[-+.0123456789]%c%c%d", prefix.data(), &e, &plus_or_minus, &exponent)) && (e == 'e' || e == 'E') && (plus_or_minus == '-' || plus_or_minus == '+')) { // It looks like a floating point value with exponent. std::stringstream out; out << prefix.data() << 'e' << plus_or_minus << exponent; result = out.str(); } else { result = in; } return result; } TEST(NormalizeFloat, Sample) { EXPECT_THAT(NormalizeExponentInFloatString(""), Eq("")); EXPECT_THAT(NormalizeExponentInFloatString("1e-12"), Eq("1e-12")); EXPECT_THAT(NormalizeExponentInFloatString("1E+14"), Eq("1e+14")); EXPECT_THAT(NormalizeExponentInFloatString("1e-0012"), Eq("1e-12")); EXPECT_THAT(NormalizeExponentInFloatString("1.263E+014"), Eq("1.263e+14")); } // The following two tests can't be DRY because they take different parameter // types. TEST_P(FloatProxyFloatTest, EncodeCorrectly) { EXPECT_THAT( NormalizeExponentInFloatString(EncodeViaFloatProxy(GetParam().first)), Eq(GetParam().second)); } TEST_P(FloatProxyDoubleTest, EncodeCorrectly) { EXPECT_THAT( NormalizeExponentInFloatString(EncodeViaFloatProxy(GetParam().first)), Eq(GetParam().second)); } INSTANTIATE_TEST_SUITE_P( Float32Tests, FloatProxyFloatTest, ::testing::ValuesIn(std::vector, std::string>>({ // Zero {0.f, "0"}, // Normal numbers {1.f, "1"}, {-0.25f, "-0.25"}, {1000.0f, "1000"}, // Still normal numbers, but with large magnitude exponents. {float(ldexp(1.f, 126)), "8.50705917e+37"}, {float(ldexp(-1.f, -126)), "-1.17549435e-38"}, // denormalized values are printed as hex floats. {float(ldexp(1.0f, -127)), "0x1p-127"}, {float(ldexp(1.5f, -128)), "0x1.8p-128"}, {float(ldexp(1.25, -129)), "0x1.4p-129"}, {float(ldexp(1.125, -130)), "0x1.2p-130"}, {float(ldexp(-1.0f, -127)), "-0x1p-127"}, {float(ldexp(-1.0f, -128)), "-0x1p-128"}, {float(ldexp(-1.0f, -129)), "-0x1p-129"}, {float(ldexp(-1.5f, -130)), "-0x1.8p-130"}, // NaNs {FloatProxy(uint32_t(0xFFC00000)), "-0x1.8p+128"}, {FloatProxy(uint32_t(0xFF800100)), "-0x1.0002p+128"}, {std::numeric_limits::infinity(), "0x1p+128"}, {-std::numeric_limits::infinity(), "-0x1p+128"}, }))); INSTANTIATE_TEST_SUITE_P( Float64Tests, FloatProxyDoubleTest, ::testing::ValuesIn( std::vector, std::string>>({ {0., "0"}, {1., "1"}, {-0.25, "-0.25"}, {1000.0, "1000"}, // Large outside the range of normal floats {ldexp(1.0, 128), "3.4028236692093846e+38"}, {ldexp(1.5, 129), "1.0208471007628154e+39"}, {ldexp(-1.0, 128), "-3.4028236692093846e+38"}, {ldexp(-1.5, 129), "-1.0208471007628154e+39"}, // Small outside the range of normal floats {ldexp(1.5, -129), "2.2040519077917891e-39"}, {ldexp(-1.5, -129), "-2.2040519077917891e-39"}, // lowest non-denorm {ldexp(1.0, -1022), "2.2250738585072014e-308"}, {ldexp(-1.0, -1022), "-2.2250738585072014e-308"}, // Denormalized values {ldexp(1.125, -1023), "0x1.2p-1023"}, {ldexp(-1.375, -1024), "-0x1.6p-1024"}, // NaNs {uint64_t(0x7FF8000000000000LL), "0x1.8p+1024"}, {uint64_t(0xFFF0F00000000000LL), "-0x1.0fp+1024"}, // Infinity {std::numeric_limits::infinity(), "0x1p+1024"}, {-std::numeric_limits::infinity(), "-0x1p+1024"}, }))); // double is used so that unbiased_exponent can be used with the output // of ldexp directly. int32_t unbiased_exponent(double f) { return HexFloat>(static_cast(f)) .getUnbiasedNormalizedExponent(); } int16_t unbiased_half_exponent(uint16_t f) { return HexFloat>(f).getUnbiasedNormalizedExponent(); } TEST(HexFloatOperationTest, UnbiasedExponent) { // Float cases EXPECT_EQ(0, unbiased_exponent(ldexp(1.0f, 0))); EXPECT_EQ(-32, unbiased_exponent(ldexp(1.0f, -32))); EXPECT_EQ(42, unbiased_exponent(ldexp(1.0f, 42))); EXPECT_EQ(125, unbiased_exponent(ldexp(1.0f, 125))); EXPECT_EQ(128, HexFloat>(std::numeric_limits::infinity()) .getUnbiasedNormalizedExponent()); EXPECT_EQ(-100, unbiased_exponent(ldexp(1.0f, -100))); EXPECT_EQ(-127, unbiased_exponent(ldexp(1.0f, -127))); // First denorm EXPECT_EQ(-128, unbiased_exponent(ldexp(1.0f, -128))); EXPECT_EQ(-129, unbiased_exponent(ldexp(1.0f, -129))); EXPECT_EQ(-140, unbiased_exponent(ldexp(1.0f, -140))); // Smallest representable number EXPECT_EQ(-126 - 23, unbiased_exponent(ldexp(1.0f, -126 - 23))); // Should get rounded to 0 first. EXPECT_EQ(0, unbiased_exponent(ldexp(1.0f, -127 - 23))); // Float16 cases // The exponent is represented in the bits 0x7C00 // The offset is -15 EXPECT_EQ(0, unbiased_half_exponent(0x3C00)); EXPECT_EQ(3, unbiased_half_exponent(0x4800)); EXPECT_EQ(-1, unbiased_half_exponent(0x3800)); EXPECT_EQ(-14, unbiased_half_exponent(0x0400)); EXPECT_EQ(16, unbiased_half_exponent(0x7C00)); EXPECT_EQ(10, unbiased_half_exponent(0x6400)); // Smallest representable number EXPECT_EQ(-24, unbiased_half_exponent(0x0001)); } // Creates a float that is the sum of 1/(2 ^ fractions[i]) for i in factions float float_fractions(const std::vector& fractions) { float f = 0; for (int32_t i : fractions) { f += std::ldexp(1.0f, -i); } return f; } // Returns the normalized significand of a HexFloat> // that was created by calling float_fractions with the input fractions, // raised to the power of exp. uint32_t normalized_significand(const std::vector& fractions, uint32_t exp) { return HexFloat>( static_cast(ldexp(float_fractions(fractions), exp))) .getNormalizedSignificand(); } // Sets the bits from MSB to LSB of the significand part of a float. // For example 0 would set the bit 23 (counting from LSB to MSB), // and 1 would set the 22nd bit. uint32_t bits_set(const std::vector& bits) { const uint32_t top_bit = 1u << 22u; uint32_t val = 0; for (uint32_t i : bits) { val |= top_bit >> i; } return val; } // The same as bits_set but for a Float16 value instead of 32-bit floating // point. uint16_t half_bits_set(const std::vector& bits) { const uint32_t top_bit = 1u << 9u; uint32_t val = 0; for (uint32_t i : bits) { val |= top_bit >> i; } return static_cast(val); } TEST(HexFloatOperationTest, NormalizedSignificand) { // For normalized numbers (the following) it should be a simple matter // of getting rid of the top implicit bit EXPECT_EQ(bits_set({}), normalized_significand({0}, 0)); EXPECT_EQ(bits_set({0}), normalized_significand({0, 1}, 0)); EXPECT_EQ(bits_set({0, 1}), normalized_significand({0, 1, 2}, 0)); EXPECT_EQ(bits_set({1}), normalized_significand({0, 2}, 0)); EXPECT_EQ(bits_set({1}), normalized_significand({0, 2}, 32)); EXPECT_EQ(bits_set({1}), normalized_significand({0, 2}, 126)); // For denormalized numbers we expect the normalized significand to // shift as if it were normalized. This means, in practice that the // top_most set bit will be cut off. Looks very similar to above (on purpose) EXPECT_EQ(bits_set({}), normalized_significand({0}, static_cast(-127))); EXPECT_EQ(bits_set({3}), normalized_significand({0, 4}, static_cast(-128))); EXPECT_EQ(bits_set({3}), normalized_significand({0, 4}, static_cast(-127))); EXPECT_EQ(bits_set({}), normalized_significand({22}, static_cast(-127))); EXPECT_EQ(bits_set({0}), normalized_significand({21, 22}, static_cast(-127))); } // Returns the 32-bit floating point value created by // calling setFromSignUnbiasedExponentAndNormalizedSignificand // on a HexFloat> float set_from_sign(bool negative, int32_t unbiased_exponent, uint32_t significand, bool round_denorm_up) { HexFloat> f(0.f); f.setFromSignUnbiasedExponentAndNormalizedSignificand( negative, unbiased_exponent, significand, round_denorm_up); return f.value().getAsFloat(); } TEST(HexFloatOperationTests, SetFromSignUnbiasedExponentAndNormalizedSignificand) { EXPECT_EQ(1.f, set_from_sign(false, 0, 0, false)); // Tests insertion of various denormalized numbers with and without round up. EXPECT_EQ(static_cast(ldexp(1.f, -149)), set_from_sign(false, -149, 0, false)); EXPECT_EQ(static_cast(ldexp(1.f, -149)), set_from_sign(false, -149, 0, true)); EXPECT_EQ(0.f, set_from_sign(false, -150, 1, false)); EXPECT_EQ(static_cast(ldexp(1.f, -149)), set_from_sign(false, -150, 1, true)); EXPECT_EQ(ldexp(1.0f, -127), set_from_sign(false, -127, 0, false)); EXPECT_EQ(ldexp(1.0f, -128), set_from_sign(false, -128, 0, false)); EXPECT_EQ(float_fractions({0, 1, 2, 5}), set_from_sign(false, 0, bits_set({0, 1, 4}), false)); EXPECT_EQ(ldexp(float_fractions({0, 1, 2, 5}), -32), set_from_sign(false, -32, bits_set({0, 1, 4}), false)); EXPECT_EQ(ldexp(float_fractions({0, 1, 2, 5}), -128), set_from_sign(false, -128, bits_set({0, 1, 4}), false)); // The negative cases from above. EXPECT_EQ(-1.f, set_from_sign(true, 0, 0, false)); EXPECT_EQ(-ldexp(1.0, -127), set_from_sign(true, -127, 0, false)); EXPECT_EQ(-ldexp(1.0, -128), set_from_sign(true, -128, 0, false)); EXPECT_EQ(-float_fractions({0, 1, 2, 5}), set_from_sign(true, 0, bits_set({0, 1, 4}), false)); EXPECT_EQ(-ldexp(float_fractions({0, 1, 2, 5}), -32), set_from_sign(true, -32, bits_set({0, 1, 4}), false)); EXPECT_EQ(-ldexp(float_fractions({0, 1, 2, 5}), -128), set_from_sign(true, -128, bits_set({0, 1, 4}), false)); } TEST(HexFloatOperationTests, NonRounding) { // Rounding from 32-bit hex-float to 32-bit hex-float should be trivial, // except in the denorm case which is a bit more complex. using HF = HexFloat>; bool carry_bit = false; round_direction rounding[] = {round_direction::kToZero, round_direction::kToNearestEven, round_direction::kToPositiveInfinity, round_direction::kToNegativeInfinity}; // Everything fits, so this should be straight-forward for (round_direction round : rounding) { EXPECT_EQ(bits_set({}), HF(0.f).getRoundedNormalizedSignificand(round, &carry_bit)); EXPECT_FALSE(carry_bit); EXPECT_EQ(bits_set({0}), HF(float_fractions({0, 1})) .getRoundedNormalizedSignificand(round, &carry_bit)); EXPECT_FALSE(carry_bit); EXPECT_EQ(bits_set({1, 3}), HF(float_fractions({0, 2, 4})) .getRoundedNormalizedSignificand(round, &carry_bit)); EXPECT_FALSE(carry_bit); EXPECT_EQ( bits_set({0, 1, 4}), HF(static_cast(-ldexp(float_fractions({0, 1, 2, 5}), -128))) .getRoundedNormalizedSignificand(round, &carry_bit)); EXPECT_FALSE(carry_bit); EXPECT_EQ(bits_set({0, 1, 4, 22}), HF(static_cast(float_fractions({0, 1, 2, 5, 23}))) .getRoundedNormalizedSignificand(round, &carry_bit)); EXPECT_FALSE(carry_bit); } } using RD = round_direction; struct RoundSignificandCase { float source_float; std::pair expected_results; round_direction round; }; using HexFloatRoundTest = ::testing::TestWithParam; TEST_P(HexFloatRoundTest, RoundDownToFP16) { using HF = HexFloat>; using HF16 = HexFloat>; HF input_value(GetParam().source_float); bool carry_bit = false; EXPECT_EQ(GetParam().expected_results.first, input_value.getRoundedNormalizedSignificand(GetParam().round, &carry_bit)); EXPECT_EQ(carry_bit, GetParam().expected_results.second); } // clang-format off INSTANTIATE_TEST_SUITE_P(F32ToF16, HexFloatRoundTest, ::testing::ValuesIn(std::vector( { {float_fractions({0}), std::make_pair(half_bits_set({}), false), RD::kToZero}, {float_fractions({0}), std::make_pair(half_bits_set({}), false), RD::kToNearestEven}, {float_fractions({0}), std::make_pair(half_bits_set({}), false), RD::kToPositiveInfinity}, {float_fractions({0}), std::make_pair(half_bits_set({}), false), RD::kToNegativeInfinity}, {float_fractions({0, 1}), std::make_pair(half_bits_set({0}), false), RD::kToZero}, {float_fractions({0, 1, 11}), std::make_pair(half_bits_set({0}), false), RD::kToZero}, {float_fractions({0, 1, 11}), std::make_pair(half_bits_set({0, 9}), false), RD::kToPositiveInfinity}, {float_fractions({0, 1, 11}), std::make_pair(half_bits_set({0}), false), RD::kToNegativeInfinity}, {float_fractions({0, 1, 11}), std::make_pair(half_bits_set({0}), false), RD::kToNearestEven}, {float_fractions({0, 1, 10, 11}), std::make_pair(half_bits_set({0, 9}), false), RD::kToZero}, {float_fractions({0, 1, 10, 11}), std::make_pair(half_bits_set({0, 8}), false), RD::kToPositiveInfinity}, {float_fractions({0, 1, 10, 11}), std::make_pair(half_bits_set({0, 9}), false), RD::kToNegativeInfinity}, {float_fractions({0, 1, 10, 11}), std::make_pair(half_bits_set({0, 8}), false), RD::kToNearestEven}, {float_fractions({0, 1, 11, 12}), std::make_pair(half_bits_set({0}), false), RD::kToZero}, {float_fractions({0, 1, 11, 12}), std::make_pair(half_bits_set({0, 9}), false), RD::kToPositiveInfinity}, {float_fractions({0, 1, 11, 12}), std::make_pair(half_bits_set({0}), false), RD::kToNegativeInfinity}, {float_fractions({0, 1, 11, 12}), std::make_pair(half_bits_set({0, 9}), false), RD::kToNearestEven}, {-float_fractions({0, 1, 11, 12}), std::make_pair(half_bits_set({0}), false), RD::kToZero}, {-float_fractions({0, 1, 11, 12}), std::make_pair(half_bits_set({0}), false), RD::kToPositiveInfinity}, {-float_fractions({0, 1, 11, 12}), std::make_pair(half_bits_set({0, 9}), false), RD::kToNegativeInfinity}, {-float_fractions({0, 1, 11, 12}), std::make_pair(half_bits_set({0, 9}), false), RD::kToNearestEven}, {float_fractions({0, 1, 11, 22}), std::make_pair(half_bits_set({0}), false), RD::kToZero}, {float_fractions({0, 1, 11, 22}), std::make_pair(half_bits_set({0, 9}), false), RD::kToPositiveInfinity}, {float_fractions({0, 1, 11, 22}), std::make_pair(half_bits_set({0}), false), RD::kToNegativeInfinity}, {float_fractions({0, 1, 11, 22}), std::make_pair(half_bits_set({0, 9}), false), RD::kToNearestEven}, // Carries {float_fractions({0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}), std::make_pair(half_bits_set({0, 1, 2, 3, 4, 5, 6, 7, 8, 9}), false), RD::kToZero}, {float_fractions({0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}), std::make_pair(half_bits_set({}), true), RD::kToPositiveInfinity}, {float_fractions({0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}), std::make_pair(half_bits_set({0, 1, 2, 3, 4, 5, 6, 7, 8, 9}), false), RD::kToNegativeInfinity}, {float_fractions({0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}), std::make_pair(half_bits_set({}), true), RD::kToNearestEven}, // Cases where original number was denorm. Note: this should have no effect // the number is pre-normalized. {static_cast(ldexp(float_fractions({0, 1, 11, 13}), -128)), std::make_pair(half_bits_set({0}), false), RD::kToZero}, {static_cast(ldexp(float_fractions({0, 1, 11, 13}), -129)), std::make_pair(half_bits_set({0, 9}), false), RD::kToPositiveInfinity}, {static_cast(ldexp(float_fractions({0, 1, 11, 13}), -131)), std::make_pair(half_bits_set({0}), false), RD::kToNegativeInfinity}, {static_cast(ldexp(float_fractions({0, 1, 11, 13}), -130)), std::make_pair(half_bits_set({0, 9}), false), RD::kToNearestEven}, }))); // clang-format on struct UpCastSignificandCase { uint16_t source_half; uint32_t expected_result; }; using HexFloatRoundUpSignificandTest = ::testing::TestWithParam; TEST_P(HexFloatRoundUpSignificandTest, Widening) { using HF = HexFloat>; using HF16 = HexFloat>; bool carry_bit = false; round_direction rounding[] = {round_direction::kToZero, round_direction::kToNearestEven, round_direction::kToPositiveInfinity, round_direction::kToNegativeInfinity}; // Everything fits, so everything should just be bit-shifts. for (round_direction round : rounding) { carry_bit = false; HF16 input_value(GetParam().source_half); EXPECT_EQ( GetParam().expected_result, input_value.getRoundedNormalizedSignificand(round, &carry_bit)) << std::hex << "0x" << input_value.getRoundedNormalizedSignificand(round, &carry_bit) << " 0x" << GetParam().expected_result; EXPECT_FALSE(carry_bit); } } INSTANTIATE_TEST_SUITE_P( F16toF32, HexFloatRoundUpSignificandTest, // 0xFC00 of the source 16-bit hex value cover the sign and the exponent. // They are ignored for this test. ::testing::ValuesIn(std::vector({ {0x3F00, 0x600000}, {0x0F00, 0x600000}, {0x0F01, 0x602000}, {0x0FFF, 0x7FE000}, }))); struct DownCastTest { float source_float; uint16_t expected_half; std::vector directions; }; std::string get_round_text(round_direction direction) { #define CASE(round_direction) \ case round_direction: \ return #round_direction switch (direction) { CASE(round_direction::kToZero); CASE(round_direction::kToPositiveInfinity); CASE(round_direction::kToNegativeInfinity); CASE(round_direction::kToNearestEven); } #undef CASE return ""; } using HexFloatFP32To16Tests = ::testing::TestWithParam; TEST_P(HexFloatFP32To16Tests, NarrowingCasts) { using HF = HexFloat>; using HF16 = HexFloat>; HF f(GetParam().source_float); for (auto round : GetParam().directions) { HF16 half(0); f.castTo(half, round); EXPECT_EQ(GetParam().expected_half, half.value().getAsFloat().get_value()) << get_round_text(round) << " " << std::hex << BitwiseCast(GetParam().source_float) << " cast to: " << half.value().getAsFloat().get_value(); } } const uint16_t positive_infinity = 0x7C00; const uint16_t negative_infinity = 0xFC00; INSTANTIATE_TEST_SUITE_P( F32ToF16, HexFloatFP32To16Tests, ::testing::ValuesIn(std::vector({ // Exactly representable as half. {0.f, 0x0, {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity, RD::kToNearestEven}}, {-0.f, 0x8000, {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity, RD::kToNearestEven}}, {1.0f, 0x3C00, {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity, RD::kToNearestEven}}, {-1.0f, 0xBC00, {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity, RD::kToNearestEven}}, {float_fractions({0, 1, 10}), 0x3E01, {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity, RD::kToNearestEven}}, {-float_fractions({0, 1, 10}), 0xBE01, {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity, RD::kToNearestEven}}, {static_cast(ldexp(float_fractions({0, 1, 10}), 3)), 0x4A01, {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity, RD::kToNearestEven}}, {static_cast(-ldexp(float_fractions({0, 1, 10}), 3)), 0xCA01, {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity, RD::kToNearestEven}}, // Underflow {static_cast(ldexp(1.0f, -25)), 0x0, {RD::kToZero, RD::kToNegativeInfinity, RD::kToNearestEven}}, {static_cast(ldexp(1.0f, -25)), 0x1, {RD::kToPositiveInfinity}}, {static_cast(-ldexp(1.0f, -25)), 0x8000, {RD::kToZero, RD::kToPositiveInfinity, RD::kToNearestEven}}, {static_cast(-ldexp(1.0f, -25)), 0x8001, {RD::kToNegativeInfinity}}, {static_cast(ldexp(1.0f, -24)), 0x1, {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity, RD::kToNearestEven}}, // Overflow {static_cast(ldexp(1.0f, 16)), positive_infinity, {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity, RD::kToNearestEven}}, {static_cast(ldexp(1.0f, 18)), positive_infinity, {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity, RD::kToNearestEven}}, {static_cast(ldexp(1.3f, 16)), positive_infinity, {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity, RD::kToNearestEven}}, {static_cast(-ldexp(1.0f, 16)), negative_infinity, {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity, RD::kToNearestEven}}, {static_cast(-ldexp(1.0f, 18)), negative_infinity, {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity, RD::kToNearestEven}}, {static_cast(-ldexp(1.3f, 16)), negative_infinity, {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity, RD::kToNearestEven}}, // Transfer of Infinities {std::numeric_limits::infinity(), positive_infinity, {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity, RD::kToNearestEven}}, {-std::numeric_limits::infinity(), negative_infinity, {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity, RD::kToNearestEven}}, // Nans are below because we cannot test for equality. }))); struct UpCastCase { uint16_t source_half; float expected_float; }; using HexFloatFP16To32Tests = ::testing::TestWithParam; TEST_P(HexFloatFP16To32Tests, WideningCasts) { using HF = HexFloat>; using HF16 = HexFloat>; HF16 f(GetParam().source_half); round_direction rounding[] = {round_direction::kToZero, round_direction::kToNearestEven, round_direction::kToPositiveInfinity, round_direction::kToNegativeInfinity}; // Everything fits, so everything should just be bit-shifts. for (round_direction round : rounding) { HF flt(0.f); f.castTo(flt, round); EXPECT_EQ(GetParam().expected_float, flt.value().getAsFloat()) << get_round_text(round) << " " << std::hex << BitwiseCast(GetParam().source_half) << " cast to: " << flt.value().getAsFloat(); } } INSTANTIATE_TEST_SUITE_P( F16ToF32, HexFloatFP16To32Tests, ::testing::ValuesIn(std::vector({ {0x0000, 0.f}, {0x8000, -0.f}, {0x3C00, 1.0f}, {0xBC00, -1.0f}, {0x3F00, float_fractions({0, 1, 2})}, {0xBF00, -float_fractions({0, 1, 2})}, {0x3F01, float_fractions({0, 1, 2, 10})}, {0xBF01, -float_fractions({0, 1, 2, 10})}, // denorm {0x0001, static_cast(ldexp(1.0, -24))}, {0x0002, static_cast(ldexp(1.0, -23))}, {0x8001, static_cast(-ldexp(1.0, -24))}, {0x8011, static_cast(-ldexp(1.0, -20) + -ldexp(1.0, -24))}, // inf {0x7C00, std::numeric_limits::infinity()}, {0xFC00, -std::numeric_limits::infinity()}, }))); TEST(HexFloatOperationTests, NanTests) { using HF = HexFloat>; using HF16 = HexFloat>; round_direction rounding[] = {round_direction::kToZero, round_direction::kToNearestEven, round_direction::kToPositiveInfinity, round_direction::kToNegativeInfinity}; // Everything fits, so everything should just be bit-shifts. for (round_direction round : rounding) { HF16 f16(0); HF f(0.f); HF(std::numeric_limits::quiet_NaN()).castTo(f16, round); EXPECT_TRUE(f16.value().isNan()); HF(std::numeric_limits::signaling_NaN()).castTo(f16, round); EXPECT_TRUE(f16.value().isNan()); HF16(0x7C01).castTo(f, round); EXPECT_TRUE(f.value().isNan()); HF16(0x7C11).castTo(f, round); EXPECT_TRUE(f.value().isNan()); HF16(0xFC01).castTo(f, round); EXPECT_TRUE(f.value().isNan()); HF16(0x7C10).castTo(f, round); EXPECT_TRUE(f.value().isNan()); HF16(0xFF00).castTo(f, round); EXPECT_TRUE(f.value().isNan()); } } // A test case for parsing good and bad HexFloat> literals. template struct FloatParseCase { std::string literal; bool negate_value; bool expect_success; HexFloat> expected_value; }; using ParseNormalFloatTest = ::testing::TestWithParam>; TEST_P(ParseNormalFloatTest, Samples) { std::stringstream input(GetParam().literal); HexFloat> parsed_value(0.0f); ParseNormalFloat(input, GetParam().negate_value, parsed_value); EXPECT_NE(GetParam().expect_success, input.fail()) << " literal: " << GetParam().literal << " negate: " << GetParam().negate_value; if (GetParam().expect_success) { EXPECT_THAT(parsed_value.value(), Eq(GetParam().expected_value.value())) << " literal: " << GetParam().literal << " negate: " << GetParam().negate_value; } } // Returns a FloatParseCase with expected failure. template FloatParseCase BadFloatParseCase(std::string literal, bool negate_value, T expected_value) { HexFloat> proxy_expected_value(expected_value); return FloatParseCase{literal, negate_value, false, proxy_expected_value}; } // Returns a FloatParseCase that should successfully parse to a given value. template FloatParseCase GoodFloatParseCase(std::string literal, bool negate_value, T expected_value) { HexFloat> proxy_expected_value(expected_value); return FloatParseCase{literal, negate_value, true, proxy_expected_value}; } INSTANTIATE_TEST_SUITE_P( FloatParse, ParseNormalFloatTest, ::testing::ValuesIn(std::vector>{ // Failing cases due to trivially incorrect syntax. BadFloatParseCase("abc", false, 0.0f), BadFloatParseCase("abc", true, 0.0f), // Valid cases. GoodFloatParseCase("0", false, 0.0f), GoodFloatParseCase("0.0", false, 0.0f), GoodFloatParseCase("-0.0", false, -0.0f), GoodFloatParseCase("2.0", false, 2.0f), GoodFloatParseCase("-2.0", false, -2.0f), GoodFloatParseCase("+2.0", false, 2.0f), // Cases with negate_value being true. GoodFloatParseCase("0.0", true, -0.0f), GoodFloatParseCase("2.0", true, -2.0f), // When negate_value is true, we should not accept a // leading minus or plus. BadFloatParseCase("-0.0", true, 0.0f), BadFloatParseCase("-2.0", true, 0.0f), BadFloatParseCase("+0.0", true, 0.0f), BadFloatParseCase("+2.0", true, 0.0f), // Overflow is an error for 32-bit float parsing. BadFloatParseCase("1e40", false, FLT_MAX), BadFloatParseCase("1e40", true, -FLT_MAX), BadFloatParseCase("-1e40", false, -FLT_MAX), // We can't have -1e40 and negate_value == true since // that represents an original case of "--1e40" which // is invalid. })); using ParseNormalFloat16Test = ::testing::TestWithParam>; TEST_P(ParseNormalFloat16Test, Samples) { std::stringstream input(GetParam().literal); HexFloat> parsed_value(0); ParseNormalFloat(input, GetParam().negate_value, parsed_value); EXPECT_NE(GetParam().expect_success, input.fail()) << " literal: " << GetParam().literal << " negate: " << GetParam().negate_value; if (GetParam().expect_success) { EXPECT_THAT(parsed_value.value(), Eq(GetParam().expected_value.value())) << " literal: " << GetParam().literal << " negate: " << GetParam().negate_value; } } INSTANTIATE_TEST_SUITE_P( Float16Parse, ParseNormalFloat16Test, ::testing::ValuesIn(std::vector>{ // Failing cases due to trivially incorrect syntax. BadFloatParseCase("abc", false, uint16_t{0}), BadFloatParseCase("abc", true, uint16_t{0}), // Valid cases. GoodFloatParseCase("0", false, uint16_t{0}), GoodFloatParseCase("0.0", false, uint16_t{0}), GoodFloatParseCase("-0.0", false, uint16_t{0x8000}), GoodFloatParseCase("2.0", false, uint16_t{0x4000}), GoodFloatParseCase("-2.0", false, uint16_t{0xc000}), GoodFloatParseCase("+2.0", false, uint16_t{0x4000}), // Cases with negate_value being true. GoodFloatParseCase("0.0", true, uint16_t{0x8000}), GoodFloatParseCase("2.0", true, uint16_t{0xc000}), // When negate_value is true, we should not accept a leading minus or // plus. BadFloatParseCase("-0.0", true, uint16_t{0}), BadFloatParseCase("-2.0", true, uint16_t{0}), BadFloatParseCase("+0.0", true, uint16_t{0}), BadFloatParseCase("+2.0", true, uint16_t{0}), })); // A test case for detecting infinities. template struct OverflowParseCase { std::string input; bool expect_success; T expected_value; }; using FloatProxyParseOverflowFloatTest = ::testing::TestWithParam>; TEST_P(FloatProxyParseOverflowFloatTest, Sample) { std::istringstream input(GetParam().input); HexFloat> value(0.0f); input >> value; EXPECT_NE(GetParam().expect_success, input.fail()); if (GetParam().expect_success) { EXPECT_THAT(value.value().getAsFloat(), GetParam().expected_value); } } INSTANTIATE_TEST_SUITE_P( FloatOverflow, FloatProxyParseOverflowFloatTest, ::testing::ValuesIn(std::vector>({ {"0", true, 0.0f}, {"0.0", true, 0.0f}, {"1.0", true, 1.0f}, {"1e38", true, 1e38f}, {"-1e38", true, -1e38f}, {"1e40", false, FLT_MAX}, {"-1e40", false, -FLT_MAX}, {"1e400", false, FLT_MAX}, {"-1e400", false, -FLT_MAX}, }))); using FloatProxyParseOverflowDoubleTest = ::testing::TestWithParam>; TEST_P(FloatProxyParseOverflowDoubleTest, Sample) { std::istringstream input(GetParam().input); HexFloat> value(0.0); input >> value; EXPECT_NE(GetParam().expect_success, input.fail()); if (GetParam().expect_success) { EXPECT_THAT(value.value().getAsFloat(), Eq(GetParam().expected_value)); } } INSTANTIATE_TEST_SUITE_P( DoubleOverflow, FloatProxyParseOverflowDoubleTest, ::testing::ValuesIn(std::vector>({ {"0", true, 0.0}, {"0.0", true, 0.0}, {"1.0", true, 1.0}, {"1e38", true, 1e38}, {"-1e38", true, -1e38}, {"1e40", true, 1e40}, {"-1e40", true, -1e40}, {"1e400", false, DBL_MAX}, {"-1e400", false, -DBL_MAX}, }))); using FloatProxyParseOverflowFloat16Test = ::testing::TestWithParam>; TEST_P(FloatProxyParseOverflowFloat16Test, Sample) { std::istringstream input(GetParam().input); HexFloat> value(0); input >> value; EXPECT_NE(GetParam().expect_success, input.fail()) << " literal: " << GetParam().input; if (GetParam().expect_success) { EXPECT_THAT(value.value().data(), Eq(GetParam().expected_value)) << " literal: " << GetParam().input; } } INSTANTIATE_TEST_SUITE_P( Float16Overflow, FloatProxyParseOverflowFloat16Test, ::testing::ValuesIn(std::vector>({ {"0", true, uint16_t{0}}, {"0.0", true, uint16_t{0}}, {"1.0", true, uint16_t{0x3c00}}, // Overflow for 16-bit float is an error, and returns max or // lowest value. {"1e38", false, uint16_t{0x7bff}}, {"1e40", false, uint16_t{0x7bff}}, {"1e400", false, uint16_t{0x7bff}}, {"-1e38", false, uint16_t{0xfbff}}, {"-1e40", false, uint16_t{0xfbff}}, {"-1e400", false, uint16_t{0xfbff}}, }))); TEST(FloatProxy, Max) { EXPECT_THAT(FloatProxy::max().getAsFloat().get_value(), Eq(uint16_t{0x7bff})); EXPECT_THAT(FloatProxy::max().getAsFloat(), Eq(std::numeric_limits::max())); EXPECT_THAT(FloatProxy::max().getAsFloat(), Eq(std::numeric_limits::max())); } TEST(FloatProxy, Lowest) { EXPECT_THAT(FloatProxy::lowest().getAsFloat().get_value(), Eq(uint16_t{0xfbff})); EXPECT_THAT(FloatProxy::lowest().getAsFloat(), Eq(std::numeric_limits::lowest())); EXPECT_THAT(FloatProxy::lowest().getAsFloat(), Eq(std::numeric_limits::lowest())); } template struct StreamParseCase { StreamParseCase(const std::string& lit, bool succ, const std::string& suffix, T value) : literal(lit), expect_success(succ), expected_suffix(suffix), expected_value(HexFloat>(value)) {} std::string literal; bool expect_success; std::string expected_suffix; HexFloat> expected_value; }; template std::ostream& operator<<(std::ostream& os, const StreamParseCase& fspc) { os << "StreamParseCase(" << fspc.literal << ", expect_success:" << int(fspc.expect_success) << "," << fspc.expected_suffix << "," << fspc.expected_value << ")"; return os; } using Float32StreamParseTest = ::testing::TestWithParam>; using Float16StreamParseTest = ::testing::TestWithParam>; TEST_P(Float32StreamParseTest, Samples) { std::stringstream input(GetParam().literal); HexFloat> parsed_value(0.0f); // Hex floats must be read with the stream input operator. input >> parsed_value; if (GetParam().expect_success) { EXPECT_FALSE(input.fail()); std::string suffix; input >> suffix; // EXPECT_EQ(suffix, GetParam().expected_suffix); EXPECT_EQ(parsed_value.value().getAsFloat(), GetParam().expected_value.value().getAsFloat()); } else { EXPECT_TRUE(input.fail()); } } // Returns a Float16 constructed from its sign bit, unbiased exponent, and // mantissa. Float16 makeF16(int sign_bit, int unbiased_exp, int mantissa) { EXPECT_LE(0, sign_bit); EXPECT_LE(sign_bit, 1); // Exponent is 5 bits, with bias of 15. EXPECT_LE(-15, unbiased_exp); // -15 means zero or subnormal EXPECT_LE(unbiased_exp, 16); // 16 means infinity or NaN EXPECT_LE(0, mantissa); EXPECT_LE(mantissa, 0x3ff); const unsigned biased_exp = 15 + unbiased_exp; const uint32_t as_bits = sign_bit << 15 | (biased_exp << 10) | mantissa; EXPECT_LE(as_bits, 0xffffu); return Float16(static_cast(as_bits)); } TEST_P(Float16StreamParseTest, Samples) { std::stringstream input(GetParam().literal); HexFloat> parsed_value(makeF16(0, 0, 0)); // Hex floats must be read with the stream input operator. input >> parsed_value; if (GetParam().expect_success) { EXPECT_FALSE(input.fail()); std::string suffix; input >> suffix; const auto got = parsed_value.value(); const auto expected = GetParam().expected_value.value(); EXPECT_EQ(got.data(), expected.data()) << "got: " << got << " expected: " << expected; } else { EXPECT_TRUE(input.fail()); } } INSTANTIATE_TEST_SUITE_P( HexFloat32FillSignificantDigits, Float32StreamParseTest, ::testing::ValuesIn(std::vector>{ {"0x123456p0", true, "", ldexpf(0x123456, 0)}, // Patterns that fill all mantissa bits {"0x1.fffffep+23", true, "", ldexpf(0x1fffffe, -1)}, {"0x1f.ffffep+19", true, "", ldexpf(0x1fffffe, -1)}, {"0x1ff.fffep+15", true, "", ldexpf(0x1fffffe, -1)}, {"0x1fff.ffep+11", true, "", ldexpf(0x1fffffe, -1)}, {"0x1ffff.fep+7", true, "", ldexpf(0x1fffffe, -1)}, {"0x1fffff.ep+3", true, "", ldexpf(0x1fffffe, -1)}, {"0x1fffffe.p-1", true, "", ldexpf(0x1fffffe, -1)}, {"0xffffff.p+0", true, "", ldexpf(0x1fffffe, -1)}, {"0xffffff.p+0", true, "", ldexpf(0xffffff, 0)}, // Now drop some bits in the middle {"0xa5a5a5.p+0", true, "", ldexpf(0xa5a5a5, 0)}, {"0x5a5a5a.p+0", true, "", ldexpf(0x5a5a5a, 0)}})); INSTANTIATE_TEST_SUITE_P( HexFloat32ExcessSignificantDigits, Float32StreamParseTest, ::testing::ValuesIn(std::vector>{ // Base cases {"0x1.fffffep0", true, "", ldexpf(0xffffff, -23)}, {"0xa5a5a5p0", true, "", ldexpf(0xa5a5a5, 0)}, {"0xa.5a5a5p+9", true, "", ldexpf(0xa5a5a5, -11)}, {"0x5a5a5ap0", true, "", ldexpf(0x5a5a5a, 0)}, {"0x5.a5a5ap+9", true, "", ldexpf(0x5a5a5a, -11)}, // Truncate extra bits: zeroes {"0x1.fffffe0p0", true, "", ldexpf(0xffffff, -23)}, {"0xa5a5a5000p0", true, "", ldexpf(0xa5a5a5, 12)}, {"0xa.5a5a5000p+9", true, "", ldexpf(0xa5a5a5, -11)}, {"0x5a5a5a000p0", true, "", ldexpf(0x5a5a5a, 12)}, {"0x5.a5a5a000p+9", true, "", ldexpf(0x5a5a5a, -11)}, // Truncate extra bits: ones {"0x1.ffffffp0", // Extra bits in the last nibble true, "", ldexpf(0xffffff, -23)}, {"0x1.fffffffp0", true, "", ldexpf(0xffffff, -23)}, {"0xa5a5a5fffp0", true, "", ldexpf(0xa5a5a5, 12)}, {"0xa.5a5a5fffp+9", true, "", ldexpf(0xa5a5a5, -11)}, {"0x5a5a5afffp0", // The 5 nibble (0101), leads with 0, so the result can fit a leading // 1 bit , yielding 8 (1000). true, "", ldexpf(0x5a5a5a8, 8)}, {"0x5.a5a5afffp+9", true, "", ldexpf(0x5a5a5a8, 8 - 32 + 9)}})); INSTANTIATE_TEST_SUITE_P( HexFloat32ExponentMissingDigits, Float32StreamParseTest, ::testing::ValuesIn(std::vector>{ {"0x1.0p1", true, "", 2.0f}, {"0x1.0p1a", true, "a", 2.0f}, {"-0x1.0p1f", true, "f", -2.0f}, {"0x1.0p", false, "", 0.0f}, {"0x1.0pa", false, "", 0.0f}, {"0x1.0p!", false, "", 0.0f}, {"0x1.0p+", false, "", 0.0f}, {"0x1.0p+a", false, "", 0.0f}, {"0x1.0p+!", false, "", 0.0f}, {"0x1.0p-", false, "", 0.0f}, {"0x1.0p-a", false, "", 0.0f}, {"0x1.0p-!", false, "", 0.0f}, {"0x1.0p++", false, "", 0.0f}, {"0x1.0p+-", false, "", 0.0f}, {"0x1.0p-+", false, "", 0.0f}, {"0x1.0p--", false, "", 0.0f}})); INSTANTIATE_TEST_SUITE_P( HexFloat32ExponentTrailingSign, Float32StreamParseTest, ::testing::ValuesIn(std::vector>{ // Don't consume a sign after the binary exponent digits. {"0x1.0p1", true, "", 2.0f}, {"0x1.0p1+", true, "+", 2.0f}, {"0x1.0p1-", true, "-", 2.0f}})); INSTANTIATE_TEST_SUITE_P( HexFloat32PositiveExponentOverflow, Float32StreamParseTest, ::testing::ValuesIn(std::vector>{ // Positive exponents {"0x1.0p1", true, "", 2.0f}, // fine, a normal number {"0x1.0p15", true, "", 32768.0f}, // fine, a normal number {"0x1.0p127", true, "", float(ldexp(1.0f, 127))}, // good large number {"0x0.8p128", true, "", float(ldexp(1.0f, 127))}, // good large number {"0x0.1p131", true, "", float(ldexp(1.0f, 127))}, // good large number {"0x0.01p135", true, "", float(ldexp(1.0f, 127))}, // good large number {"0x1.0p128", true, "", float(ldexp(1.0f, 128))}, // infinity {"0x1.0p4294967295", true, "", float(ldexp(1.0f, 128))}, // infinity {"0x1.0p5000000000", true, "", float(ldexp(1.0f, 128))}, // infinity {"0x0.0p5000000000", true, "", 0.0f}, // zero mantissa, zero result })); INSTANTIATE_TEST_SUITE_P( HexFloat32NegativeExponentOverflow, Float32StreamParseTest, ::testing::ValuesIn(std::vector>{ // Positive results, digits before '.' {"0x1.0p-126", true, "", float(ldexp(1.0f, -126))}, // fine, a small normal number {"0x1.0p-127", true, "", float(ldexp(1.0f, -127))}, // denorm number {"0x1.0p-149", true, "", float(ldexp(1.0f, -149))}, // smallest positive denormal {"0x0.8p-148", true, "", float(ldexp(1.0f, -149))}, // smallest positive denormal {"0x0.1p-145", true, "", float(ldexp(1.0f, -149))}, // smallest positive denormal {"0x0.01p-141", true, "", float(ldexp(1.0f, -149))}, // smallest positive denormal // underflow rounds down to zero {"0x1.0p-150", true, "", 0.0f}, {"0x1.0p-4294967296", true, "", 0.0f}, // avoid exponent overflow in parser {"0x1.0p-5000000000", true, "", 0.0f}, // avoid exponent overflow in parser {"0x0.0p-5000000000", true, "", 0.0f}, // zero mantissa, zero result })); INSTANTIATE_TEST_SUITE_P( HexFloat16ExcessSignificantDigits, Float16StreamParseTest, ::testing::ValuesIn(std::vector>{ // Zero {"0x1.c00p0", true, "", makeF16(0, 0, 0x300)}, {"0x0p0", true, "", makeF16(0, -15, 0x0)}, {"0x000.0000p0", true, "", makeF16(0, -15, 0x0)}, // All leading 1s {"0x1p0", true, "", makeF16(0, 0, 0x0)}, {"0x1.8p0", true, "", makeF16(0, 0, 0x200)}, {"0x1.cp0", true, "", makeF16(0, 0, 0x300)}, {"0x1.ep0", true, "", makeF16(0, 0, 0x380)}, {"0x1.fp0", true, "", makeF16(0, 0, 0x3c0)}, {"0x1.f8p0", true, "", makeF16(0, 0, 0x3e0)}, {"0x1.fcp0", true, "", makeF16(0, 0, 0x3f0)}, {"0x1.fep0", true, "", makeF16(0, 0, 0x3f8)}, {"0x1.ffp0", true, "", makeF16(0, 0, 0x3fc)}, // Fill trailing zeros to all significant places // that might be used for significant digits. {"0x1.ff8p0", true, "", makeF16(0, 0, 0x3fe)}, {"0x1.ffcp0", true, "", makeF16(0, 0, 0x3ff)}, {"0x1.800p0", true, "", makeF16(0, 0, 0x200)}, {"0x1.c00p0", true, "", makeF16(0, 0, 0x300)}, {"0x1.e00p0", true, "", makeF16(0, 0, 0x380)}, {"0x1.f00p0", true, "", makeF16(0, 0, 0x3c0)}, {"0x1.f80p0", true, "", makeF16(0, 0, 0x3e0)}, {"0x1.fc0p0", true, "", makeF16(0, 0, 0x3f0)}, {"0x1.fe0p0", true, "", makeF16(0, 0, 0x3f8)}, {"0x1.ff0p0", true, "", makeF16(0, 0, 0x3fc)}, {"0x1.ff8p0", true, "", makeF16(0, 0, 0x3fe)}, {"0x1.ffcp0", true, "", makeF16(0, 0, 0x3ff)}, // Add several trailing zeros {"0x1.c00000p0", true, "", makeF16(0, 0, 0x300)}, {"0x1.e00000p0", true, "", makeF16(0, 0, 0x380)}, {"0x1.f00000p0", true, "", makeF16(0, 0, 0x3c0)}, {"0x1.f80000p0", true, "", makeF16(0, 0, 0x3e0)}, {"0x1.fc0000p0", true, "", makeF16(0, 0, 0x3f0)}, {"0x1.fe0000p0", true, "", makeF16(0, 0, 0x3f8)}, {"0x1.ff0000p0", true, "", makeF16(0, 0, 0x3fc)}, {"0x1.ff8000p0", true, "", makeF16(0, 0, 0x3fe)}, {"0x1.ffcp0000", true, "", makeF16(0, 0, 0x3ff)}, // Samples that drop out bits in the middle. // 5 = 0101 4 = 0100 // a = 1010 8 = 1000 {"0x1.5a4p0", true, "", makeF16(0, 0, 0x169)}, {"0x1.a58p0", true, "", makeF16(0, 0, 0x296)}, // Samples that drop out bits *and* truncate significant bits // that can't be represented. {"0x1.5a40000p0", true, "", makeF16(0, 0, 0x169)}, {"0x1.5a7ffffp0", true, "", makeF16(0, 0, 0x169)}, {"0x1.a580000p0", true, "", makeF16(0, 0, 0x296)}, {"0x1.a5bffffp0", true, "", makeF16(0, 0, 0x296)}, // Try some negations. {"-0x0p0", true, "", makeF16(1, -15, 0x0)}, {"-0x000.0000p0", true, "", makeF16(1, -15, 0x0)}, {"-0x1.5a40000p0", true, "", makeF16(1, 0, 0x169)}, {"-0x1.5a7ffffp0", true, "", makeF16(1, 0, 0x169)}, {"-0x1.a580000p0", true, "", makeF16(1, 0, 0x296)}, {"-0x1.a5bffffp0", true, "", makeF16(1, 0, 0x296)}})); INSTANTIATE_TEST_SUITE_P( HexFloat16IncreasingExponentsAndMantissa, Float16StreamParseTest, ::testing::ValuesIn(std::vector>{ // Zero {"0x0p0", true, "", makeF16(0, -15, 0x0)}, {"0x0p5000000000000", true, "", makeF16(0, -15, 0x0)}, {"-0x0p5000000000000", true, "", makeF16(1, -15, 0x0)}, // Leading 1 {"0x1p0", true, "", makeF16(0, 0, 0x0)}, {"0x1p1", true, "", makeF16(0, 1, 0x0)}, {"0x1p16", true, "", makeF16(0, 16, 0x0)}, {"0x1p-1", true, "", makeF16(0, -1, 0x0)}, {"0x1p-14", true, "", makeF16(0, -14, 0x0)}, // Leading 2 {"0x2p0", true, "", makeF16(0, 1, 0x0)}, {"0x2p1", true, "", makeF16(0, 2, 0x0)}, {"0x2p15", true, "", makeF16(0, 16, 0x0)}, {"0x2p-1", true, "", makeF16(0, 0, 0x0)}, {"0x2p-15", true, "", makeF16(0, -14, 0x0)}, // Leading 8 {"0x8p0", true, "", makeF16(0, 3, 0x0)}, {"0x8p1", true, "", makeF16(0, 4, 0x0)}, {"0x8p13", true, "", makeF16(0, 16, 0x0)}, {"0x8p-3", true, "", makeF16(0, 0, 0x0)}, {"0x8p-17", true, "", makeF16(0, -14, 0x0)}, // Leading 10 {"0x10.0p0", true, "", makeF16(0, 4, 0x0)}, {"0x10.0p1", true, "", makeF16(0, 5, 0x0)}, {"0x10.0p12", true, "", makeF16(0, 16, 0x0)}, {"0x10.0p-5", true, "", makeF16(0, -1, 0x0)}, {"0x10.0p-18", true, "", makeF16(0, -14, 0x0)}, // Samples that drop out bits *and* truncate significant bits // that can't be represented. // Progressively increase the leading digit. {"0x1.5a40000p0", true, "", makeF16(0, 0, 0x169)}, {"0x1.5a7ffffp0", true, "", makeF16(0, 0, 0x169)}, {"0x2.5a40000p0", true, "", makeF16(0, 1, 0x0b4)}, {"0x2.5a7ffffp0", true, "", makeF16(0, 1, 0x0b4)}, {"0x4.5a40000p0", true, "", makeF16(0, 2, 0x05a)}, {"0x4.5a7ffffp0", true, "", makeF16(0, 2, 0x05a)}, {"0x8.5a40000p0", true, "", makeF16(0, 3, 0x02d)}, {"0x8.5a7ffffp0", true, "", makeF16(0, 3, 0x02d)}})); } // namespace } // namespace utils } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/hex_to_text_test.cpp000066400000000000000000000400421475742701700236050ustar00rootroot00000000000000// Copyright (c) 2024 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gmock/gmock.h" #include "test/test_fixture.h" #include "tools/io.h" namespace spvtools { namespace { using spvtest::ScopedContext; class HexToText : public ::testing::Test { public: void VerifyDisassembly(const char* hex_stream, const char* expected_disassembly) { std::vector stream(hex_stream, hex_stream + strlen(hex_stream)); std::vector binary; // Convert hext to binary first. EXPECT_TRUE(ConvertHexToBinary(stream, &binary)); // Then disassemble it. spv_diagnostic diagnostic = nullptr; spv_text disassembly = nullptr; EXPECT_EQ(spvBinaryToText(ScopedContext().context, binary.data(), binary.size(), SPV_BINARY_TO_TEXT_OPTION_NONE, &disassembly, &diagnostic), SPV_SUCCESS); EXPECT_EQ(diagnostic, nullptr); // Verify disassembly is as expected and clean up. EXPECT_STREQ(disassembly->str, expected_disassembly); spvDiagnosticDestroy(diagnostic); spvTextDestroy(disassembly); } void EnsureError(const char* hex_stream) { std::vector stream(hex_stream, hex_stream + strlen(hex_stream)); std::vector binary; // Make sure there is a parse error EXPECT_FALSE(ConvertHexToBinary(stream, &binary)); } }; // The actual assembly doesn't matter, just the hex parsing. All the tests use // the following SPIR-V. constexpr char kDisassembly[] = R"(; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 11 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "main" %2 %3 OpName %2 "fancy_attribute" OpName %3 "useful_output" OpDecorate %2 Location 4 OpDecorate %3 Location 2 %4 = OpTypeFloat 32 %5 = OpTypePointer Input %4 %2 = OpVariable %5 Input %6 = OpTypePointer Output %4 %3 = OpVariable %6 Output %7 = OpTypeVoid %8 = OpTypeFunction %7 %1 = OpFunction %7 None %8 %9 = OpLabel %10 = OpLoad %4 %2 OpStore %3 %10 OpReturn OpFunctionEnd )"; TEST_F(HexToText, Words) { constexpr char kHex[] = R"(0x07230203, 0x00010600, 0x00070000, 0x0000000b 0x00000000, 0x00020011, 0x00000001, 0x0003000e 0x00000000, 0x00000001, 0x0007000f, 0x00000000 0x00000001, 0x6e69616d, 0x00000000, 0x00000002 0x00000003, 0x00060005, 0x00000002, 0x636e6166 0x74615f79, 0x62697274, 0x00657475, 0x00060005 0x00000003, 0x66657375, 0x6f5f6c75, 0x75707475 0x00000074, 0x00040047, 0x00000002, 0x0000001e 0x00000004, 0x00040047, 0x00000003, 0x0000001e 0x00000002, 0x00030016, 0x00000004, 0x00000020 0x00040020, 0x00000005, 0x00000001, 0x00000004 0x0004003b, 0x00000005, 0x00000002, 0x00000001 0x00040020, 0x00000006, 0x00000003, 0x00000004 0x0004003b, 0x00000006, 0x00000003, 0x00000003 0x00020013, 0x00000007, 0x00030021, 0x00000008 0x00000007, 0x00050036, 0x00000007, 0x00000001 0x00000000, 0x00000008, 0x000200f8, 0x00000009 0x0004003d, 0x00000004, 0x0000000a, 0x00000002 0x0003003e, 0x00000003, 0x0000000a, 0x000100fd 0x00010038)"; VerifyDisassembly(kHex, kDisassembly); } TEST_F(HexToText, WordsLeadingSpace) { constexpr char kHex[] = R"( x07230203, x00010600, x00070000, x0000000b x00000000, x00020011, x00000001, x0003000e x00000000, x00000001, x0007000f, x00000000 x00000001, x6e69616d, x00000000, x00000002 x00000003, x00060005, x00000002, x636e6166 x74615f79, x62697274, x00657475, x00060005 x00000003, x66657375, x6f5f6c75, x75707475 x00000074, x00040047, x00000002, x0000001e x00000004, x00040047, x00000003, x0000001e x00000002, x00030016, x00000004, x00000020 x00040020, x00000005, x00000001, x00000004 x0004003b, x00000005, x00000002, x00000001 x00040020, x00000006, x00000003, x00000004 x0004003b, x00000006, x00000003, x00000003 x00020013, x00000007, x00030021, x00000008 x00000007, x00050036, x00000007, x00000001 x00000000, x00000008, x000200f8, x00000009 x0004003d, x00000004, x0000000a, x00000002 x0003003e, x00000003, x0000000a, x000100fd x00010038)"; VerifyDisassembly(kHex, kDisassembly); } TEST_F(HexToText, WordsTrailingSpace) { constexpr char kHex[] = R"(0X7230203, 0X10600, 0X70000, 0XB 0X0, 0X20011, 0X1, 0X3000E 0X0, 0X1, 0X7000F, 0X0 0X1, X6E69616D, 0X0, 0X2 0X3, 0X60005, 0X2, X636E6166 X74615F79, X62697274, 0X657475, 0X60005 0X3, X66657375, X6F5F6C75, X75707475 0X74, 0X40047, 0X2, 0X1E 0X4, 0X40047, 0X3, 0X1E 0X2, 0X30016, 0X4, 0X20 0X40020, 0X5, 0X1, 0X4 0X4003B, 0X5, 0X2, 0X1 0X40020, 0X6, 0X3, 0X4 0X4003B, 0X6, 0X3, 0X3 0X20013, 0X7, 0X30021, 0X8 0X7, 0X50036, 0X7, 0X1 0X0, 0X8, 0X200F8, 0X9 0X4003D, 0X4, 0XA, 0X2 0X3003E, 0X3, 0XA, 0X100FD 0X10038 )"; VerifyDisassembly(kHex, kDisassembly); } TEST_F(HexToText, BytesLittleEndian) { constexpr char kHex[] = R"( 0x03 0x02 0x23 0x07 0x00 0x06 0x01 0x00 0x00 0x00 0x07 0x00 0x0b 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x11 0x00 0x02 0x00 0x01 0x00 0x00 0x00 0x0e 0x00 0x03 0x00 0x00 0x00 0x00 0x00 0x01 0x00 0x00 0x00 0x0f 0x00 0x07 0x00 0x00 0x00 0x00 0x00 0x01 0x00 0x00 0x00 0x6d 0x61 0x69 0x6e 0x00 0x00 0x00 0x00 0x02 0x00 0x00 0x00 0x03 0x00 0x00 0x00 0x05 0x00 0x06 0x00 0x02 0x00 0x00 0x00 0x66 0x61 0x6e 0x63 0x79 0x5f 0x61 0x74 0x74 0x72 0x69 0x62 0x75 0x74 0x65 0x00 0x05 0x00 0x06 0x00 0x03 0x00 0x00 0x00 0x75 0x73 0x65 0x66 0x75 0x6c 0x5f 0x6f 0x75 0x74 0x70 0x75 0x74 0x00 0x00 0x00 0x47 0x00 0x04 0x00 0x02 0x00 0x00 0x00 0x1e 0x00 0x00 0x00 0x04 0x00 0x00 0x00 0x47 0x00 0x04 0x00 0x03 0x00 0x00 0x00 0x1e 0x00 0x00 0x00 0x02 0x00 0x00 0x00 0x16 0x00 0x03 0x00 0x04 0x00 0x00 0x00 0x20 0x00 0x00 0x00 0x20 0x00 0x04 0x00 0x05 0x00 0x00 0x00 0x01 0x00 0x00 0x00 0x04 0x00 0x00 0x00 0x3b 0x00 0x04 0x00 0x05 0x00 0x00 0x00 0x02 0x00 0x00 0x00 0x01 0x00 0x00 0x00 0x20 0x00 0x04 0x00 0x06 0x00 0x00 0x00 0x03 0x00 0x00 0x00 0x04 0x00 0x00 0x00 0x3b 0x00 0x04 0x00 0x06 0x00 0x00 0x00 0x03 0x00 0x00 0x00 0x03 0x00 0x00 0x00 0x13 0x00 0x02 0x00 0x07 0x00 0x00 0x00 0x21 0x00 0x03 0x00 0x08 0x00 0x00 0x00 0x07 0x00 0x00 0x00 0x36 0x00 0x05 0x00 0x07 0x00 0x00 0x00 0x01 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x08 0x00 0x00 0x00 0xf8 0x00 0x02 0x00 0x09 0x00 0x00 0x00 0x3d 0x00 0x04 0x00 0x04 0x00 0x00 0x00 0x0a 0x00 0x00 0x00 0x02 0x00 0x00 0x00 0x3e 0x00 0x03 0x00 0x03 0x00 0x00 0x00 0x0a 0x00 0x00 0x00 0xfd 0x00 0x01 0x00 0x38 0x00 0x01 0x00 )"; VerifyDisassembly(kHex, kDisassembly); } TEST_F(HexToText, BytesBigEndian) { constexpr char kHex[] = R"( X07,X23,X02,X03, X00,X01,X06,X00, X00,X07,X00,X00, X00,X00,X00,X0B X00,X00,X00,X00, X00,X02,X00,X11, X00,X00,X00,X01, X00,X03,X00,X0E X00,X00,X00,X00, X00,X00,X00,X01, X00,X07,X00,X0F, X00,X00,X00,X00 X00,X00,X00,X01, X6E,X69,X61,X6D, X00,X00,X00,X00, X00,X00,X00,X02 X00,X00,X00,X03, X00,X06,X00,X05, X00,X00,X00,X02, X63,X6E,X61,X66 X74,X61,X5F,X79, X62,X69,X72,X74, X00,X65,X74,X75, X00,X06,X00,X05 X00,X00,X00,X03, X66,X65,X73,X75, X6F,X5F,X6C,X75, X75,X70,X74,X75 X00,X00,X00,X74, X00,X04,X00,X47, X00,X00,X00,X02, X00,X00,X00,X1E X00,X00,X00,X04, X00,X04,X00,X47, X00,X00,X00,X03, X00,X00,X00,X1E X00,X00,X00,X02, X00,X03,X00,X16, X00,X00,X00,X04, X00,X00,X00,X20 X00,X04,X00,X20, X00,X00,X00,X05, X00,X00,X00,X01, X00,X00,X00,X04 X00,X04,X00,X3B, X00,X00,X00,X05, X00,X00,X00,X02, X00,X00,X00,X01 X00,X04,X00,X20, X00,X00,X00,X06, X00,X00,X00,X03, X00,X00,X00,X04 X00,X04,X00,X3B, X00,X00,X00,X06, X00,X00,X00,X03, X00,X00,X00,X03 X00,X02,X00,X13, X00,X00,X00,X07, X00,X03,X00,X21, X00,X00,X00,X08 X00,X00,X00,X07, X00,X05,X00,X36, X00,X00,X00,X07, X00,X00,X00,X01 X00,X00,X00,X00, X00,X00,X00,X08, X00,X02,X00,XF8, X00,X00,X00,X09 X00,X04,X00,X3D, X00,X00,X00,X04, X00,X00,X00,X0A, X00,X00,X00,X02 X00,X03,X00,X3E, X00,X00,X00,X03, X00,X00,X00,X0A, X00,X01,X00,XFD X00,X01,X00,X38, )"; VerifyDisassembly(kHex, kDisassembly); } TEST_F(HexToText, StreamLittleEndian) { constexpr char kHex[] = R"( 03 02 23 07 00 06 01 00 00 00 07 00 0b 00 00 00 00 00 00 00 11 00 02 00 01 00 00 00 0e 00 03 00 00 00 00 00 01 00 00 00 0f 00 07 00 00 00 00 00 01 00 00 00 6d 61 69 6e 00 00 00 00 02 00 00 00 03 00 00 00 05 00 06 00 02 00 00 00 66 61 6e 63 79 5f 61 74 74 72 69 62 75 74 65 00 05 00 06 00 03 00 00 00 75 73 65 66 75 6c 5f 6f 75 74 70 75 74 00 00 00 47 00 04 00 02 00 00 00 1e 00 00 00 04 00 00 00 47 00 04 00 03 00 00 00 1e 00 00 00 02 00 00 00 16 00 03 00 04 00 00 00 20 00 00 00 20 00 04 00 05 00 00 00 01 00 00 00 04 00 00 00 3b 00 04 00 05 00 00 00 02 00 00 00 01 00 00 00 20 00 04 00 06 00 00 00 03 00 00 00 04 00 00 00 3b 00 04 00 06 00 00 00 03 00 00 00 03 00 00 00 13 00 02 00 07 00 00 00 21 00 03 00 08 00 00 00 07 00 00 00 36 00 05 00 07 00 00 00 01 00 00 00 00 00 00 00 08 00 00 00 f8 00 02 00 09 00 00 00 3d 00 04 00 04 00 00 00 0a 00 00 00 02 00 00 00 3e 00 03 00 03 00 00 00 0a 00 00 00 fd 00 01 00 38 00 01 00 )"; VerifyDisassembly(kHex, kDisassembly); } TEST_F(HexToText, StreamLittleEndianNoDelim) { constexpr char kHex[] = R"( 0302230700060100000007000B000000 0000000011000200010000000E000300 00000000010000000F00070000000000 010000006D61696E0000000002000000 03000000050006000200000066616E63 795F6174747269627574650005000600 0300000075736566756C5F6F75747075 7400000047000400020000001E000000 0400000047000400030000001E000000 02000000160003000400000020000000 20000400050000000100000004000000 3B000400050000000200000001000000 20000400060000000300000004000000 3B000400060000000300000003000000 13000200070000002100030008000000 07000000360005000700000001000000 0000000008000000F800020009000000 3D000400040000000A00000002000000 3E000300030000000A000000FD000100 38000100 )"; VerifyDisassembly(kHex, kDisassembly); } TEST_F(HexToText, StreamBigEndian) { constexpr char kHex[] = R"( 07230203, 00010600, 00070000, 0000000b 00000000, 00020011, 00000001, 0003000e 00000000, 00000001, 0007000f, 00000000 00000001, 6e69616d, 00000000, 00000002 00000003, 00060005, 00000002, 636e6166 74615f79, 62697274, 00657475, 00060005 00000003, 66657375, 6f5f6c75, 75707475 00000074, 00040047, 00000002, 0000001e 00000004, 00040047, 00000003, 0000001e 00000002, 00030016, 00000004, 00000020 00040020, 00000005, 00000001, 00000004 0004003b, 00000005, 00000002, 00000001 00040020, 00000006, 00000003, 00000004 0004003b, 00000006, 00000003, 00000003 00020013, 00000007, 00030021, 00000008 00000007, 00050036, 00000007, 00000001 00000000, 00000008, 000200f8, 00000009 0004003d, 00000004, 0000000a, 00000002 0003003e, 00000003, 0000000a, 000100fd 00010038, )"; VerifyDisassembly(kHex, kDisassembly); } TEST_F(HexToText, WordsNoDelimieter) { constexpr char kHex[] = R"(0x07230203 0x00010600 0x00070000 0x0000000b 0x00000000 0x00020011 0x00000001 0x0003000e 0x00000000 0x00000001 0x0007000f 0x00000000 0x00000001 0x6e69616d 0x00000000 0x00000002 0x00000003 0x00060005 0x00000002 0x636e6166 0x74615f79 0x62697274 0x00657475 0x00060005 0x00000003 0x666573750x6f5f6c75 0x75707475 0x00000074 0x00040047 0x00000002 0x0000001e 0x00000004 0x00040047 0x00000003 0x0000001e 0x00000002 0x00030016 0x00000004 0x00000020 0x00040020 0x00000005 0x00000001 0x00000004 0x0004003b 0x00000005 0x00000002 0x00000001 0x00040020 0x00000006 0x00000003 0x00000004 0x0004003b 0x00000006 0x00000003 0x00000003 0x00020013 0x00000007 0x00030021 0x00000008 0x00000007 0x00050036 0x00000007 0x00000001 0x00000000 0x00000008 0x000200f8 0x00000009 0x0004003d 0x00000004 0x0000000a 0x00000002 0x0003003e 0x00000003 0x0000000a 0x000100fd 0x00010038)"; EnsureError(kHex); } TEST_F(HexToText, InvalidFirstToken) { constexpr char kHex[] = R"(0x17230203, 0x00010600, 0x00070000, 0x0000000b 0x00000000, 0x00020011, 0x00000001, 0x0003000e 0x00000000, 0x00000001, 0x0007000f, 0x00000000 0x00000001, 0x6e69616d, 0x00000000, 0x00000002 0x00000003, 0x00060005, 0x00000002, 0x636e6166 0x74615f79, 0x62697274, 0x00657475, 0x00060005 0x00000003, 0x66657375, 0x6f5f6c75, 0x75707475 0x00000074, 0x00040047, 0x00000002, 0x0000001e 0x00000004, 0x00040047, 0x00000003, 0x0000001e 0x00000002, 0x00030016, 0x00000004, 0x00000020 0x00040020, 0x00000005, 0x00000001, 0x00000004 0x0004003b, 0x00000005, 0x00000002, 0x00000001 0x00040020, 0x00000006, 0x00000003, 0x00000004 0x0004003b, 0x00000006, 0x00000003, 0x00000003 0x00020013, 0x00000007, 0x00030021, 0x00000008 0x00000007, 0x00050036, 0x00000007, 0x00000001 0x00000000, 0x00000008, 0x000200f8, 0x00000009 0x0004003d, 0x00000004, 0x0000000a, 0x00000002 0x0003003e, 0x00000003, 0x0000000a, 0x000100fd 0x00010038)"; EnsureError(kHex); } TEST_F(HexToText, NonHexCharacter) { // Note: a 6 is replaced with G in this stream constexpr char kHex[] = R"(0x07230203, 0x00010600, 0x00070000, 0x0000000b 0x00000000, 0x00020011, 0x00000001, 0x0003000e 0x00000000, 0x00000001, 0x0007000f, 0x00000000 0x00000001, 0x6e69616d, 0x00000000, 0x00000002 0x00000003, 0x00060005, 0x00000002, 0x636e6166 0x74615f79, 0x62697274, 0x00657475, 0x00060005 0x00000003, 0x66657375, 0x6f5f6c75, 0x75707475 0x00000074, 0x00040047, 0x00000002, 0x0000001e 0x00000004, 0x00040047, 0x00000003, 0x0000001e 0x00000002, 0x0003001G, 0x00000004, 0x00000020 0x00040020, 0x00000005, 0x00000001, 0x00000004 0x0004003b, 0x00000005, 0x00000002, 0x00000001 0x00040020, 0x00000006, 0x00000003, 0x00000004 0x0004003b, 0x00000006, 0x00000003, 0x00000003 0x00020013, 0x00000007, 0x00030021, 0x00000008 0x00000007, 0x00050036, 0x00000007, 0x00000001 0x00000000, 0x00000008, 0x000200f8, 0x00000009 0x0004003d, 0x00000004, 0x0000000a, 0x00000002 0x0003003e, 0x00000003, 0x0000000a, 0x000100fd 0x00010038)"; EnsureError(kHex); } TEST_F(HexToText, MissingExpectedPrefix) { constexpr char kHex[] = R"(0x07230203, 0x00010600, 0x00070000, 0x0000000b 0x00000000, 0x00020011, 0x00000001, 0x0003000e 0x00000000, 0x00000001, 0x0007000f, 0x00000000 0x00000001, 0x6e69616d, 0x00000000, 0x00000002 0x00000003, 0x00060005, 0x00000002, 0x636e6166 0x74615f79, 0x62697274, 0x00657475, 0x00060005 0x00000003, 0x66657375, 0x6f5f6c75, 0x75707475 0x00000074, 0x00040047, 0x00000002, 0x0000001e 0x00000004, 0x00040047, 0x00000003, 0x0000001e 0x00000002, 0x00030016, 0x00000004, 0x00000020 0x00040020, 0x00000005, 00000001, 0x00000004 0x0004003b, 0x00000005, 0x00000002, 0x00000001 0x00040020, 0x00000006, 0x00000003, 0x00000004 0x0004003b, 0x00000006, 0x00000003, 0x00000003 0x00020013, 0x00000007, 0x00030021, 0x00000008 0x00000007, 0x00050036, 0x00000007, 0x00000001 0x00000000, 0x00000008, 0x000200f8, 0x00000009 0x0004003d, 0x00000004, 0x0000000a, 0x00000002 0x0003003e, 0x00000003, 0x0000000a, 0x000100fd 0x00010038)"; EnsureError(kHex); } TEST_F(HexToText, UnexpectedPrefix) { constexpr char kHex[] = R"(07230203, 00010600, 00070000, 0000000b 00000000, 00020011, 00000001, 0003000e 00000000, 00000001, 0007000f, 00000000 00000001, 6e69616d, 00000000, 00000002 00000003, 00060005, 00000002, 636e6166 74615f79, 62697274, 00657475, 00060005 00000003, 66657375, 6f5f6c75, 75707475 00000074, 00040047, 00000002, 0000001e 00000004, 00040047, 00000003, 0000001e 00000002, 00030016, 00000004, 00000020 00040020, 00000005, 0x00000001, 00000004 0004003b, 00000005, 00000002, 00000001 00040020, 00000006, 00000003, 00000004 0004003b, 00000006, 00000003, 00000003 00020013, 00000007, 00030021, 00000008 00000007, 00050036, 00000007, 00000001 00000000, 00000008, 000200f8, 00000009 0004003d, 00000004, 0000000a, 00000002 0003003e, 00000003, 0000000a, 000100fd 00010038)"; EnsureError(kHex); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/immediate_int_test.cpp000066400000000000000000000301061475742701700240630ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include "gmock/gmock.h" #include "source/util/bitutils.h" #include "test/test_fixture.h" namespace spvtools { namespace utils { namespace { using spvtest::Concatenate; using spvtest::MakeInstruction; using spvtest::ScopedContext; using spvtest::TextToBinaryTest; using ::testing::ElementsAre; using ::testing::Eq; using ::testing::HasSubstr; using ::testing::StrEq; TEST_F(TextToBinaryTest, ImmediateIntOpCode) { SetText("!0x00FF00FF"); ASSERT_EQ(SPV_SUCCESS, spvTextToBinary(ScopedContext().context, text.str, text.length, &binary, &diagnostic)); EXPECT_EQ(0x00FF00FFu, binary->code[5]); if (diagnostic) { spvDiagnosticPrint(diagnostic); } } TEST_F(TextToBinaryTest, ImmediateIntOperand) { SetText("OpCapability !0x00FF00FF"); EXPECT_EQ(SPV_SUCCESS, spvTextToBinary(ScopedContext().context, text.str, text.length, &binary, &diagnostic)); EXPECT_EQ(0x00FF00FFu, binary->code[6]); if (diagnostic) { spvDiagnosticPrint(diagnostic); } } using ImmediateIntTest = TextToBinaryTest; TEST_F(ImmediateIntTest, AnyWordInSimpleStatement) { EXPECT_THAT(CompiledInstructions("!0x00040018 %a %b %123"), Eq(MakeInstruction(spv::Op::OpTypeMatrix, {1, 2, 3}))); EXPECT_THAT(CompiledInstructions("!0x00040018 !1 %b %123"), Eq(MakeInstruction(spv::Op::OpTypeMatrix, {1, 1, 2}))); EXPECT_THAT(CompiledInstructions("%a = OpTypeMatrix !2 %123"), Eq(MakeInstruction(spv::Op::OpTypeMatrix, {1, 2, 2}))); EXPECT_THAT(CompiledInstructions("%a = OpTypeMatrix %b !123"), Eq(MakeInstruction(spv::Op::OpTypeMatrix, {1, 2, 123}))); EXPECT_THAT(CompiledInstructions("!0x00040018 %a !2 %123"), Eq(MakeInstruction(spv::Op::OpTypeMatrix, {1, 2, 2}))); EXPECT_THAT(CompiledInstructions("!0x00040018 !1 %b !123"), Eq(MakeInstruction(spv::Op::OpTypeMatrix, {1, 1, 123}))); EXPECT_THAT(CompiledInstructions("!0x00040018 !1 !2 !123"), Eq(MakeInstruction(spv::Op::OpTypeMatrix, {1, 2, 123}))); } TEST_F(ImmediateIntTest, AnyWordAfterEqualsAndOpCode) { EXPECT_THAT(CompiledInstructions("%a = OpArrayLength !2 %c 123"), Eq(MakeInstruction(spv::Op::OpArrayLength, {2, 1, 2, 123}))); EXPECT_THAT(CompiledInstructions("%a = OpArrayLength %b !3 123"), Eq(MakeInstruction(spv::Op::OpArrayLength, {1, 2, 3, 123}))); EXPECT_THAT(CompiledInstructions("%a = OpArrayLength %b %c !123"), Eq(MakeInstruction(spv::Op::OpArrayLength, {1, 2, 3, 123}))); EXPECT_THAT(CompiledInstructions("%a = OpArrayLength %b !3 !123"), Eq(MakeInstruction(spv::Op::OpArrayLength, {1, 2, 3, 123}))); EXPECT_THAT(CompiledInstructions("%a = OpArrayLength !2 !3 123"), Eq(MakeInstruction(spv::Op::OpArrayLength, {2, 1, 3, 123}))); EXPECT_THAT(CompiledInstructions("%a = OpArrayLength !2 !3 !123"), Eq(MakeInstruction(spv::Op::OpArrayLength, {2, 1, 3, 123}))); } TEST_F(ImmediateIntTest, ResultIdInAssignment) { EXPECT_EQ("!2 not allowed before =.", CompileFailure("!2 = OpArrayLength %12 %1 123")); EXPECT_EQ("!2 not allowed before =.", CompileFailure("!2 = !0x00040044 %12 %1 123")); } TEST_F(ImmediateIntTest, OpCodeInAssignment) { EXPECT_EQ("Invalid Opcode prefix '!0x00040044'.", CompileFailure("%2 = !0x00040044 %12 %1 123")); } // Literal integers after ! are handled correctly. TEST_F(ImmediateIntTest, IntegerFollowingImmediate) { const SpirvVector original = CompiledInstructions("%1 = OpTypeInt 8 1"); EXPECT_EQ(original, CompiledInstructions("!0x00040015 1 8 1")); EXPECT_EQ(original, CompiledInstructions("!0x00040015 !1 8 1")); // With !, we can (and can only) accept 32-bit number literals, // even when we declare the return type is 64-bit. EXPECT_EQ(Concatenate({ MakeInstruction(spv::Op::OpTypeInt, {1, 64, 0}), MakeInstruction(spv::Op::OpConstant, {1, 2, 4294967295}), }), CompiledInstructions("%i64 = OpTypeInt 64 0\n" "!0x0004002b %i64 !2 4294967295")); // 64-bit integer literal. EXPECT_EQ("Invalid word following !: 5000000000", CompileFailure("%2 = OpConstant !1 5000000000")); EXPECT_EQ("Invalid word following !: 5000000000", CompileFailure("%i64 = OpTypeInt 64 0\n" "!0x0005002b %i64 !2 5000000000")); // Negative integer. EXPECT_EQ(CompiledInstructions("%i64 = OpTypeInt 32 1\n" "%2 = OpConstant %i64 -123"), CompiledInstructions("%i64 = OpTypeInt 32 1\n" "!0x0004002b %i64 !2 -123")); // TODO(deki): uncomment assertions below and make them pass. // Hex value(s). // EXPECT_EQ(CompileSuccessfully("%1 = OpConstant %10 0x12345678"), // CompileSuccessfully("OpConstant %10 !1 0x12345678", kCAF)); // EXPECT_EQ( // CompileSuccessfully("%1 = OpConstant %10 0x12345678 0x87654321"), // CompileSuccessfully("OpConstant %10 !1 0x12345678 0x87654321", kCAF)); } // Literal floats after ! are handled correctly. // Insert OpNop to avoid reading the immediate value as the extra FP encoding // operand to OpTypeFloat. TEST_F(ImmediateIntTest, FloatFollowingImmediate) { EXPECT_EQ(CompiledInstructions( "%1 = OpTypeFloat 32\nOpNop %2 = OpConstant %1 0.123"), CompiledInstructions( "%1 = OpTypeFloat 32\nOpNop !0x0004002b %1 !2 0.123")); EXPECT_EQ(CompiledInstructions( "%1 = OpTypeFloat 32\nOpNop %2 = OpConstant %1 -0.5"), CompiledInstructions( "%1 = OpTypeFloat 32\nOpNop !0x0004002b %1 !2 -0.5")); EXPECT_EQ(CompiledInstructions( "%1 = OpTypeFloat 32\nOpNop %2 = OpConstant %1 0.123"), CompiledInstructions( "%1 = OpTypeFloat 32\nOpNop !0x0004002b %1 %2 0.123")); EXPECT_EQ(CompiledInstructions( "%1 = OpTypeFloat 32\nOpNop %2 = OpConstant %1 -0.5"), CompiledInstructions( "%1 = OpTypeFloat 32\nOpNop !0x0004002b %1 %2 -0.5")); EXPECT_EQ(Concatenate({ MakeInstruction(spv::Op::OpTypeInt, {1, 64, 0}), MakeInstruction(spv::Op::OpConstant, {1, 2, 0xb, 0xa}), MakeInstruction(spv::Op::OpSwitch, {2, 1234, BitwiseCast(2.5f), 3}), }), CompiledInstructions("%i64 = OpTypeInt 64 0\n" "%big = OpConstant %i64 0xa0000000b\n" "OpSwitch %big !1234 2.5 %target\n")); } // Literal strings after ! are handled correctly. TEST_F(ImmediateIntTest, StringFollowingImmediate) { // Try a variety of strings, including empty and single-character. for (std::string name : {"", "s", "longish", "really looooooooooooooooong"}) { const SpirvVector original = CompiledInstructions("OpMemberName %10 4 \"" + name + "\""); EXPECT_EQ(original, CompiledInstructions("OpMemberName %10 !4 \"" + name + "\"")) << name; EXPECT_EQ(original, CompiledInstructions("OpMemberName !1 !4 \"" + name + "\"")) << name; const uint16_t wordCount = static_cast(4 + name.size() / 4); const uint32_t firstWord = spvOpcodeMake(wordCount, spv::Op::OpMemberName); EXPECT_EQ(original, CompiledInstructions("!" + std::to_string(firstWord) + " %10 !4 \"" + name + "\"")) << name; } } // IDs after ! are handled correctly. TEST_F(ImmediateIntTest, IdFollowingImmediate) { EXPECT_EQ(CompileSuccessfully("%123 = OpDecorationGroup"), CompileSuccessfully("!0x00020049 %123")); EXPECT_EQ(CompileSuccessfully("%group = OpDecorationGroup"), CompileSuccessfully("!0x00020049 %group")); } // ! after ! is handled correctly. TEST_F(ImmediateIntTest, ImmediateFollowingImmediate) { const SpirvVector original = CompiledInstructions("%a = OpTypeMatrix %b 7"); EXPECT_EQ(original, CompiledInstructions("%a = OpTypeMatrix !2 !7")); EXPECT_EQ(original, CompiledInstructions("!0x00040018 %a !2 !7")); } TEST_F(ImmediateIntTest, InvalidStatement) { EXPECT_THAT(Subvector(CompileSuccessfully("!4 !3 !2 !1"), kFirstInstruction), ElementsAre(4, 3, 2, 1)); } TEST_F(ImmediateIntTest, InvalidStatementBetweenValidOnes) { EXPECT_THAT(Subvector(CompileSuccessfully( "%10 = OpTypeInt 32 0 !5 !6 !7 OpEmitVertex"), kFirstInstruction), ElementsAre(spvOpcodeMake(4, spv::Op::OpTypeInt), 1, 32, 0, 5, 6, 7, spvOpcodeMake(1, spv::Op::OpEmitVertex))); } TEST_F(ImmediateIntTest, NextOpcodeRecognized) { const SpirvVector original = CompileSuccessfully(R"( %1 = OpLoad %10 %2 Volatile %4 = OpCompositeInsert %11 %1 %3 0 1 2 )"); const SpirvVector alternate = CompileSuccessfully(R"( %1 = OpLoad %10 %2 !1 %4 = OpCompositeInsert %11 %1 %3 0 1 2 )"); EXPECT_EQ(original, alternate); } TEST_F(ImmediateIntTest, WrongLengthButNextOpcodeStillRecognized) { const SpirvVector original = CompileSuccessfully(R"( %1 = OpLoad %10 %2 Volatile OpCopyMemorySized %3 %4 %1 )"); const SpirvVector alternate = CompileSuccessfully(R"( !0x0002003D %10 %1 %2 !1 OpCopyMemorySized %3 %4 %1 )"); EXPECT_EQ(0x0002003Du, alternate[kFirstInstruction]); EXPECT_EQ(Subvector(original, kFirstInstruction + 1), Subvector(alternate, kFirstInstruction + 1)); } // Like NextOpcodeRecognized, but next statement is in assignment form. TEST_F(ImmediateIntTest, NextAssignmentRecognized) { const SpirvVector original = CompileSuccessfully(R"( %1 = OpLoad %10 %2 None %4 = OpFunctionCall %10 %3 %123 )"); const SpirvVector alternate = CompileSuccessfully(R"( %1 = OpLoad %10 %2 !0 %4 = OpFunctionCall %10 %3 %123 )"); EXPECT_EQ(original, alternate); } // Two instructions in a row each have ! opcode. TEST_F(ImmediateIntTest, ConsecutiveImmediateOpcodes) { const SpirvVector original = CompileSuccessfully(R"( %1 = OpConstantSampler %10 Clamp 78 Linear %4 = OpFRem %11 %3 %2 %5 = OpIsValidEvent %12 %2 )"); const SpirvVector alternate = CompileSuccessfully(R"( !0x0006002D %10 %1 !2 78 !1 !0x0005008C %11 %4 %3 %2 %5 = OpIsValidEvent %12 %2 )"); EXPECT_EQ(original, alternate); } // ! followed by, eg, an enum or '=' or a random bareword. TEST_F(ImmediateIntTest, ForbiddenOperands) { EXPECT_THAT(CompileFailure("OpMemoryModel !0 OpenCL"), HasSubstr("OpenCL")); EXPECT_THAT(CompileFailure("!1 %0 = !2"), HasSubstr("=")); EXPECT_THAT(CompileFailure("OpMemoryModel !0 random_bareword"), HasSubstr("random_bareword")); // Immediate integers longer than one 32-bit word. EXPECT_THAT(CompileFailure("!5000000000"), HasSubstr("5000000000")); EXPECT_THAT(CompileFailure("!999999999999999999"), HasSubstr("999999999999999999")); EXPECT_THAT(CompileFailure("!0x00020049 !5000000000"), HasSubstr("5000000000")); // Negative numbers. EXPECT_THAT(CompileFailure("!0x00020049 !-123"), HasSubstr("-123")); } TEST_F(ImmediateIntTest, NotInteger) { EXPECT_THAT(CompileFailure("!abc"), StrEq("Invalid immediate integer: !abc")); EXPECT_THAT(CompileFailure("!12.3"), StrEq("Invalid immediate integer: !12.3")); EXPECT_THAT(CompileFailure("!12K"), StrEq("Invalid immediate integer: !12K")); } } // namespace } // namespace utils } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/libspirv_macros_test.cpp000066400000000000000000000015321475742701700244520ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "test/unit_spirv.h" namespace spvtools { namespace { TEST(Macros, BitShiftInnerParens) { ASSERT_EQ(65536, SPV_BIT(2 << 3)); } TEST(Macros, BitShiftOuterParens) { ASSERT_EQ(15, SPV_BIT(4) - 1); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/link/000077500000000000000000000000001475742701700204455ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/link/CMakeLists.txt000066400000000000000000000016641475742701700232140ustar00rootroot00000000000000# Copyright (c) 2017 Pierre Moreau # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. add_spvtools_unittest(TARGET link SRCS binary_version_test.cpp entry_points_test.cpp global_values_amount_test.cpp ids_limit_test.cpp matching_imports_to_exports_test.cpp memory_model_test.cpp partial_linkage_test.cpp unique_ids_test.cpp type_match_test.cpp LIBS SPIRV-Tools-opt SPIRV-Tools-link ) KhronosGroup-SPIRV-Tools-f289d04/test/link/binary_version_test.cpp000066400000000000000000000057021475742701700252450ustar00rootroot00000000000000// Copyright (c) 2017 Pierre Moreau // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gmock/gmock.h" #include "test/link/linker_fixture.h" namespace spvtools { namespace { using ::testing::HasSubstr; using BinaryVersion = spvtest::LinkerTest; spvtest::Binary CreateBinary(uint32_t version) { return { // clang-format off // Header static_cast(spv::MagicNumber), version, SPV_GENERATOR_WORD(SPV_GENERATOR_KHRONOS, 0), 1u, // NOTE: Bound 0u, // NOTE: Schema; reserved // OpCapability Shader static_cast(spv::Op::OpCapability) | 2u << spv::WordCountShift, static_cast(spv::Capability::Shader), // OpMemoryModel Logical Simple static_cast(spv::Op::OpMemoryModel) | 3u << spv::WordCountShift, static_cast(spv::AddressingModel::Logical), static_cast(spv::MemoryModel::Simple) // clang-format on }; } TEST_F(BinaryVersion, Match) { // clang-format off spvtest::Binaries binaries = { CreateBinary(SPV_SPIRV_VERSION_WORD(1, 3)), CreateBinary(SPV_SPIRV_VERSION_WORD(1, 3)), }; // clang-format on spvtest::Binary linked_binary; ASSERT_EQ(SPV_SUCCESS, Link(binaries, &linked_binary)) << GetErrorMessage(); EXPECT_THAT(GetErrorMessage(), std::string()); EXPECT_EQ(SPV_SPIRV_VERSION_WORD(1, 3), linked_binary[1]); } TEST_F(BinaryVersion, Mismatch) { // clang-format off spvtest::Binaries binaries = { CreateBinary(SPV_SPIRV_VERSION_WORD(1, 3)), CreateBinary(SPV_SPIRV_VERSION_WORD(1, 5)), }; // clang-format on spvtest::Binary linked_binary; ASSERT_EQ(SPV_ERROR_INTERNAL, Link(binaries, &linked_binary)) << GetErrorMessage(); EXPECT_THAT(GetErrorMessage(), HasSubstr("Conflicting SPIR-V versions: 1.3 (input modules 1 " "through 1) vs 1.5 (input module 2).")); } TEST_F(BinaryVersion, UseHighest) { // clang-format off spvtest::Binaries binaries = { CreateBinary(SPV_SPIRV_VERSION_WORD(1, 3)), CreateBinary(SPV_SPIRV_VERSION_WORD(1, 5)), }; // clang-format on LinkerOptions options; options.SetUseHighestVersion(true); spvtest::Binary linked_binary; ASSERT_EQ(SPV_SUCCESS, Link(binaries, &linked_binary, options)) << GetErrorMessage(); EXPECT_THAT(GetErrorMessage(), std::string()); EXPECT_EQ(SPV_SPIRV_VERSION_WORD(1, 5), linked_binary[1]); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/link/entry_points_test.cpp000066400000000000000000000074551475742701700247600ustar00rootroot00000000000000// Copyright (c) 2017 Pierre Moreau // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gmock/gmock.h" #include "test/link/linker_fixture.h" namespace spvtools { namespace { using ::testing::HasSubstr; class EntryPoints : public spvtest::LinkerTest {}; TEST_F(EntryPoints, SameModelDifferentName) { const std::string body1 = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %3 "foo" %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpFunction %1 None %2 OpFunctionEnd )"; const std::string body2 = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %3 "bar" %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpFunction %1 None %2 OpFunctionEnd )"; spvtest::Binary linked_binary; ASSERT_EQ(SPV_SUCCESS, AssembleAndLink({body1, body2}, &linked_binary)) << GetErrorMessage(); EXPECT_THAT(GetErrorMessage(), std::string()); } TEST_F(EntryPoints, DifferentModelSameName) { const std::string body1 = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %3 "foo" %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpFunction %1 None %2 OpFunctionEnd )"; const std::string body2 = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %3 "foo" %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpFunction %1 None %2 OpFunctionEnd )"; spvtest::Binary linked_binary; ASSERT_EQ(SPV_SUCCESS, AssembleAndLink({body1, body2}, &linked_binary)) << GetErrorMessage(); EXPECT_THAT(GetErrorMessage(), std::string()); } TEST_F(EntryPoints, SameModelAndName) { const std::string body1 = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %3 "foo" %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpFunction %1 None %2 OpFunctionEnd )"; const std::string body2 = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %3 "foo" %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpFunction %1 None %2 OpFunctionEnd )"; spvtest::Binary linked_binary; EXPECT_EQ(SPV_ERROR_INTERNAL, AssembleAndLink({body1, body2}, &linked_binary)); EXPECT_THAT(GetErrorMessage(), HasSubstr("The entry point \"foo\", with execution model " "GLCompute, was already defined.")); } TEST_F(EntryPoints, LinkedVariables) { const std::string body1 = R"( OpCapability Addresses OpCapability Linkage OpCapability Kernel OpMemoryModel Physical64 OpenCL OpDecorate %7 LinkageAttributes "foo" Export %1 = OpTypeInt 32 0 %2 = OpTypeVector %1 3 %3 = OpTypePointer Input %2 %4 = OpVariable %3 Input %5 = OpTypeVoid %6 = OpTypeFunction %5 %7 = OpFunction %5 None %6 %8 = OpLabel %9 = OpLoad %2 %4 Aligned 32 OpReturn OpFunctionEnd )"; const std::string body2 = R"( OpCapability Linkage OpCapability Kernel OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %4 "bar" OpDecorate %3 LinkageAttributes "foo" Import %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpFunction %1 None %2 OpFunctionEnd %4 = OpFunction %1 None %2 %5 = OpLabel %6 = OpFunctionCall %1 %3 OpReturn OpFunctionEnd )"; spvtest::Binary linked_binary; EXPECT_EQ(SPV_SUCCESS, AssembleAndLink({body1, body2}, &linked_binary)); EXPECT_THAT(GetErrorMessage(), std::string()); EXPECT_TRUE(Validate(linked_binary)); EXPECT_THAT(GetErrorMessage(), std::string()); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/link/global_values_amount_test.cpp000066400000000000000000000113511475742701700264130ustar00rootroot00000000000000// Copyright (c) 2017 Pierre Moreau // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gmock/gmock.h" #include "test/link/linker_fixture.h" namespace spvtools { namespace { using ::testing::HasSubstr; const uint32_t binary_count = 2u; class EntryPointsAmountTest : public spvtest::LinkerTest { public: EntryPointsAmountTest() { binaries.reserve(binary_count + 1u); } void SetUp() override { const uint32_t global_variable_count_per_binary = (SPV_LIMIT_GLOBAL_VARIABLES_MAX - 1u) / binary_count; spvtest::Binary common_binary = { // clang-format off static_cast(spv::MagicNumber), static_cast(spv::Version), SPV_GENERATOR_WORD(SPV_GENERATOR_KHRONOS, 0), 3u + global_variable_count_per_binary, // NOTE: Bound 0u, // NOTE: Schema; reserved static_cast(spv::Op::OpCapability) | 2u << spv::WordCountShift, static_cast(spv::Capability::Shader), static_cast(spv::Op::OpMemoryModel) | 3u << spv::WordCountShift, static_cast(spv::AddressingModel::Logical), static_cast(spv::MemoryModel::Simple), static_cast(spv::Op::OpTypeFloat) | 3u << spv::WordCountShift, 1u, // NOTE: Result ID 32u, // NOTE: Width static_cast(spv::Op::OpTypePointer) | 4u << spv::WordCountShift, 2u, // NOTE: Result ID static_cast(spv::StorageClass::Input), 1u // NOTE: Type ID // clang-format on }; binaries.push_back({}); spvtest::Binary& binary = binaries.back(); binary.reserve(common_binary.size() + global_variable_count_per_binary * 4); binary.insert(binary.end(), common_binary.cbegin(), common_binary.cend()); for (uint32_t i = 0u; i < global_variable_count_per_binary; ++i) { binary.push_back(static_cast(spv::Op::OpVariable) | 4u << spv::WordCountShift); binary.push_back(2u); // NOTE: Type ID binary.push_back(3u + i); // NOTE: Result ID binary.push_back(static_cast(spv::StorageClass::Input)); } for (uint32_t i = 0u; i < binary_count - 1u; ++i) { binaries.push_back(binaries.back()); } } void TearDown() override { binaries.clear(); } spvtest::Binaries binaries; }; TEST_F(EntryPointsAmountTest, UnderLimit) { spvtest::Binary linked_binary; ASSERT_EQ(SPV_SUCCESS, Link(binaries, &linked_binary)) << GetErrorMessage(); EXPECT_THAT(GetErrorMessage(), std::string()); } TEST_F(EntryPointsAmountTest, OverLimit) { binaries.push_back({ // clang-format off static_cast(spv::MagicNumber), static_cast(spv::Version), SPV_GENERATOR_WORD(SPV_GENERATOR_KHRONOS, 0), 5u, // NOTE: Bound 0u, // NOTE: Schema; reserved static_cast(spv::Op::OpCapability) | 2u << spv::WordCountShift, static_cast(spv::Capability::Shader), static_cast(spv::Op::OpMemoryModel) | 3u << spv::WordCountShift, static_cast(spv::AddressingModel::Logical), static_cast(spv::MemoryModel::Simple), static_cast(spv::Op::OpTypeFloat) | 3u << spv::WordCountShift, 1u, // NOTE: Result ID 32u, // NOTE: Width static_cast(spv::Op::OpTypePointer) | 4u << spv::WordCountShift, 2u, // NOTE: Result ID static_cast(spv::StorageClass::Input), 1u, // NOTE: Type ID static_cast(spv::Op::OpVariable) | 4u << spv::WordCountShift, 2u, // NOTE: Type ID 3u, // NOTE: Result ID static_cast(spv::StorageClass::Input), static_cast(spv::Op::OpVariable) | 4u << spv::WordCountShift, 2u, // NOTE: Type ID 4u, // NOTE: Result ID static_cast(spv::StorageClass::Input) // clang-format on }); spvtest::Binary linked_binary; ASSERT_EQ(SPV_SUCCESS, Link(binaries, &linked_binary)) << GetErrorMessage(); EXPECT_THAT( GetErrorMessage(), HasSubstr("The minimum limit of global values, 65535, was exceeded; " "65536 global values were found.")); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/link/ids_limit_test.cpp000066400000000000000000000110311475742701700241610ustar00rootroot00000000000000// Copyright (c) 2017 Pierre Moreau // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gmock/gmock.h" #include "test/link/linker_fixture.h" namespace spvtools { namespace { using ::testing::HasSubstr; class IdsLimit : public spvtest::LinkerTest { public: IdsLimit() { binaries.reserve(2u); } void SetUp() override { const uint32_t id_bound = SPV_LIMIT_RESULT_ID_BOUND - 1u; const uint32_t constant_count = id_bound - 2u; // One ID is used for TypeBool, and (constant_count + 1) < id_bound // This is needed, as otherwise the ID bound will get reset to 1 while // running the RemoveDuplicates pass. spvtest::Binary common_binary = { // clang-format off spv::MagicNumber, spv::Version, SPV_GENERATOR_WORD(SPV_GENERATOR_KHRONOS, 0), id_bound, // NOTE: Bound 0u, // NOTE: Schema; reserved static_cast(spv::Op::OpCapability) | 2u << spv::WordCountShift, static_cast(spv::Capability::Shader), static_cast(spv::Op::OpMemoryModel) | 3u << spv::WordCountShift, static_cast(spv::AddressingModel::Logical), static_cast(spv::MemoryModel::Simple), static_cast(spv::Op::OpTypeBool) | 2u << spv::WordCountShift, 1u // NOTE: Result ID // clang-format on }; binaries.push_back({}); spvtest::Binary& binary = binaries.back(); binary.reserve(common_binary.size() + constant_count * 3u); binary.insert(binary.end(), common_binary.cbegin(), common_binary.cend()); for (uint32_t i = 0u; i < constant_count; ++i) { binary.push_back(static_cast(spv::Op::OpConstantTrue) | 3u << spv::WordCountShift); binary.push_back(1u); // NOTE: Type ID binary.push_back(2u + i); // NOTE: Result ID } } void TearDown() override { binaries.clear(); } spvtest::Binaries binaries; }; spvtest::Binary CreateBinary(uint32_t id_bound) { return { // clang-format off // Header spv::MagicNumber, spv::Version, SPV_GENERATOR_WORD(SPV_GENERATOR_KHRONOS, 0), id_bound, // NOTE: Bound 0u, // NOTE: Schema; reserved // OpCapability Shader static_cast(spv::Op::OpCapability) | 2u << spv::WordCountShift, static_cast(spv::Capability::Shader), // OpMemoryModel Logical Simple static_cast(spv::Op::OpMemoryModel) | 3u << spv::WordCountShift, static_cast(spv::AddressingModel::Logical), static_cast(spv::MemoryModel::Simple) // clang-format on }; } TEST_F(IdsLimit, DISABLED_UnderLimit) { spvtest::Binary linked_binary; ASSERT_EQ(SPV_SUCCESS, Link(binaries, &linked_binary)) << GetErrorMessage(); EXPECT_THAT(GetErrorMessage(), std::string()); EXPECT_EQ(0x3FFFFFu, linked_binary[3]); } TEST_F(IdsLimit, DISABLED_OverLimit) { spvtest::Binary& binary = binaries.back(); const uint32_t id_bound = binary[3]; binary[3] = id_bound + 1u; binary.push_back(static_cast(spv::Op::OpConstantFalse) | 3u << spv::WordCountShift); binary.push_back(1u); // NOTE: Type ID binary.push_back(id_bound); // NOTE: Result ID spvtest::Binary linked_binary; ASSERT_EQ(SPV_SUCCESS, Link(binaries, &linked_binary)) << GetErrorMessage(); EXPECT_THAT( GetErrorMessage(), HasSubstr("The minimum limit of IDs, 4194303, was exceeded: 4194304 is " "the current ID bound.")); EXPECT_EQ(0x400000u, linked_binary[3]); } TEST_F(IdsLimit, DISABLED_Overflow) { spvtest::Binaries binaries = {CreateBinary(0xFFFFFFFFu), CreateBinary(0x00000002u)}; spvtest::Binary linked_binary; EXPECT_EQ(SPV_ERROR_INVALID_DATA, Link(binaries, &linked_binary)); EXPECT_THAT( GetErrorMessage(), HasSubstr("Too many IDs (4294967296): combining all modules would " "overflow the 32-bit word of the SPIR-V header.")); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/link/linker_fixture.h000066400000000000000000000210461475742701700236530ustar00rootroot00000000000000// Copyright (c) 2017 Pierre Moreau // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef TEST_LINK_LINKER_FIXTURE_H_ #define TEST_LINK_LINKER_FIXTURE_H_ #include #include #include #include "effcee/effcee.h" #include "re2/re2.h" #include "source/spirv_constant.h" #include "spirv-tools/linker.hpp" #include "test/unit_spirv.h" namespace spvtest { using Binary = std::vector; using Binaries = std::vector; class LinkerTest : public ::testing::Test { public: LinkerTest() : context_(SPV_ENV_UNIVERSAL_1_2), tools_(SPV_ENV_UNIVERSAL_1_2), assemble_options_(spvtools::SpirvTools::kDefaultAssembleOption), disassemble_options_(spvtools::SpirvTools::kDefaultDisassembleOption) { const auto consumer = [this](spv_message_level_t level, const char*, const spv_position_t& position, const char* message) { if (!error_message_.empty()) error_message_ += "\n"; switch (level) { case SPV_MSG_FATAL: case SPV_MSG_INTERNAL_ERROR: case SPV_MSG_ERROR: error_message_ += "ERROR"; break; case SPV_MSG_WARNING: error_message_ += "WARNING"; break; case SPV_MSG_INFO: error_message_ += "INFO"; break; case SPV_MSG_DEBUG: error_message_ += "DEBUG"; break; } error_message_ += ": " + std::to_string(position.index) + ": " + message; }; context_.SetMessageConsumer(consumer); tools_.SetMessageConsumer(consumer); } void TearDown() override { error_message_.clear(); } // Assembles each of the given strings into SPIR-V binaries before linking // them together. SPV_ERROR_INVALID_TEXT is returned if the assembling failed // for any of the input strings, and SPV_ERROR_INVALID_POINTER if // |linked_binary| is a null pointer. spv_result_t AssembleAndLink( const std::vector& bodies, spvtest::Binary* linked_binary, spvtools::LinkerOptions options = spvtools::LinkerOptions()) { if (!linked_binary) return SPV_ERROR_INVALID_POINTER; spvtest::Binaries binaries(bodies.size()); for (size_t i = 0u; i < bodies.size(); ++i) if (!tools_.Assemble(bodies[i], binaries.data() + i, assemble_options_)) return SPV_ERROR_INVALID_TEXT; return spvtools::Link(context_, binaries, linked_binary, options); } // Assembles and links a vector of SPIR-V bodies based on the |templateBody|. // Template arguments to be replaced are written as {a,b,...}. // SPV_ERROR_INVALID_TEXT is returned if the assembling failed for any of the // resulting bodies (or errors in the template), and SPV_ERROR_INVALID_POINTER // if |linked_binary| is a null pointer. spv_result_t ExpandAndLink( const std::string& templateBody, spvtest::Binary* linked_binary, spvtools::LinkerOptions options = spvtools::LinkerOptions()) { if (!linked_binary) return SPV_ERROR_INVALID_POINTER; // Find out how many template arguments there are, we assume they all have // the same number. We'll error later if they don't. re2::StringPiece temp(templateBody); re2::StringPiece x; int cnt = 0; if (!RE2::FindAndConsume(&temp, "{")) return SPV_ERROR_INVALID_TEXT; while (RE2::FindAndConsume(&temp, "([,}])", &x) && x[0] == ',') cnt++; cnt++; if (cnt <= 1) return SPV_ERROR_INVALID_TEXT; // Construct a regex for a single common strip and template expansion. std::string regex("([^{]*){"); for (int i = 0; i < cnt; i++) regex += (i > 0) ? ",([^,]*)" : "([^,]*)"; regex += "}"; RE2 pattern(regex); // Prepare the RE2::Args for processing. re2::StringPiece common; std::vector variants(cnt); std::vector args(cnt + 1); args[0] = RE2::Arg(&common); std::vector pargs(cnt + 1); pargs[0] = &args[0]; for (int i = 0; i < cnt; i++) { args[i + 1] = RE2::Arg(&variants[i]); pargs[i + 1] = &args[i + 1]; } // Reset and construct the bodies bit by bit. std::vector bodies(cnt); re2::StringPiece temp2(templateBody); while (RE2::ConsumeN(&temp2, pattern, pargs.data(), cnt + 1)) { for (int i = 0; i < cnt; i++) { bodies[i].append(common.begin(), common.end()); bodies[i].append(variants[i].begin(), variants[i].end()); } } RE2::Consume(&temp2, "([^{]*)", &common); for (int i = 0; i < cnt; i++) bodies[i].append(common.begin(), common.end()); // Run through the assemble and link stages of the process. return AssembleAndLink(bodies, linked_binary, options); } // Expand the |templateBody| and link the results as with ExpandAndLink, // then disassemble and test that the result matches the |expected|. void ExpandAndCheck( const std::string& templateBody, const std::string& expected, const spvtools::LinkerOptions options = spvtools::LinkerOptions()) { spvtest::Binary linked_binary; spv_result_t res = ExpandAndLink(templateBody, &linked_binary, options); EXPECT_EQ(SPV_SUCCESS, res) << GetErrorMessage() << "\nExpanded from:\n" << templateBody; if (res == SPV_SUCCESS) { std::string result; EXPECT_TRUE( tools_.Disassemble(linked_binary, &result, disassemble_options_)) << GetErrorMessage(); EXPECT_EQ(expected, result); } } void Match(const std::string& templateBody, const spvtest::Binary& linked_binary) { std::string result; EXPECT_TRUE( tools_.Disassemble(linked_binary, &result, disassemble_options_)) << GetErrorMessage(); auto match_res = effcee::Match(result, templateBody); EXPECT_EQ(effcee::Result::Status::Ok, match_res.status()) << match_res.message() << "\nExpanded from:\n" << templateBody << "\nChecking result:\n" << result; } // An alternative to ExpandAndCheck, which uses the |templateBody| as the // match pattern for the disassembled linked result. void ExpandAndMatch( const std::string& templateBody, const spvtools::LinkerOptions options = spvtools::LinkerOptions()) { spvtest::Binary linked_binary; spv_result_t res = ExpandAndLink(templateBody, &linked_binary, options); EXPECT_EQ(SPV_SUCCESS, res) << GetErrorMessage() << "\nExpanded from:\n" << templateBody; if (res == SPV_SUCCESS) { Match(templateBody, linked_binary); } } // Links the given SPIR-V binaries together; SPV_ERROR_INVALID_POINTER is // returned if |linked_binary| is a null pointer. spv_result_t Link( const spvtest::Binaries& binaries, spvtest::Binary* linked_binary, spvtools::LinkerOptions options = spvtools::LinkerOptions()) { if (!linked_binary) return SPV_ERROR_INVALID_POINTER; return spvtools::Link(context_, binaries, linked_binary, options); } // Disassembles |binary| and outputs the result in |text|. If |text| is a // null pointer, SPV_ERROR_INVALID_POINTER is returned. spv_result_t Disassemble(const spvtest::Binary& binary, std::string* text) { if (!text) return SPV_ERROR_INVALID_POINTER; return tools_.Disassemble(binary, text, disassemble_options_) ? SPV_SUCCESS : SPV_ERROR_INVALID_BINARY; } // Sets the options for the assembler. void SetAssembleOptions(uint32_t assemble_options) { assemble_options_ = assemble_options; } // Sets the options used by the disassembler. void SetDisassembleOptions(uint32_t disassemble_options) { disassemble_options_ = disassemble_options; } // Returns the accumulated error messages for the test. std::string GetErrorMessage() const { return error_message_; } bool Validate(const spvtest::Binary& binary) { return tools_.Validate(binary); } private: spvtools::Context context_; spvtools::SpirvTools tools_; // An instance for calling SPIRV-Tools functionalities. uint32_t assemble_options_; uint32_t disassemble_options_; std::string error_message_; }; } // namespace spvtest #endif // TEST_LINK_LINKER_FIXTURE_H_ KhronosGroup-SPIRV-Tools-f289d04/test/link/matching_imports_to_exports_test.cpp000066400000000000000000000646141475742701700300600ustar00rootroot00000000000000// Copyright (c) 2017 Pierre Moreau // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gmock/gmock.h" #include "gtest/gtest.h" #include "test/link/linker_fixture.h" namespace spvtools { namespace { using ::testing::HasSubstr; using MatchingImportsToExports = spvtest::LinkerTest; TEST_F(MatchingImportsToExports, Default) { const std::string body1 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpDecorate %1 LinkageAttributes "foo" Import %2 = OpTypeFloat 32 %1 = OpVariable %2 Uniform %3 = OpVariable %2 Input )"; const std::string body2 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpDecorate %1 LinkageAttributes "foo" Export %2 = OpTypeFloat 32 %3 = OpConstant %2 42 %1 = OpVariable %2 Uniform %3 )"; spvtest::Binary linked_binary; ASSERT_EQ(SPV_SUCCESS, AssembleAndLink({body1, body2}, &linked_binary)) << GetErrorMessage(); const std::string expected_res = R"(OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpModuleProcessed "Linked by SPIR-V Tools Linker" %1 = OpTypeFloat 32 %2 = OpVariable %1 Input %3 = OpConstant %1 42 %4 = OpVariable %1 Uniform %3 )"; std::string res_body; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); ASSERT_EQ(SPV_SUCCESS, Disassemble(linked_binary, &res_body)) << GetErrorMessage(); EXPECT_EQ(expected_res, res_body); } TEST_F(MatchingImportsToExports, NotALibraryExtraExports) { const std::string body = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpDecorate %1 LinkageAttributes "foo" Export %2 = OpTypeFloat 32 %1 = OpVariable %2 Uniform )"; spvtest::Binary linked_binary; ASSERT_EQ(SPV_SUCCESS, AssembleAndLink({body}, &linked_binary)) << GetErrorMessage(); const std::string expected_res = R"(OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpModuleProcessed "Linked by SPIR-V Tools Linker" %1 = OpTypeFloat 32 %2 = OpVariable %1 Uniform )"; std::string res_body; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); ASSERT_EQ(SPV_SUCCESS, Disassemble(linked_binary, &res_body)) << GetErrorMessage(); EXPECT_EQ(expected_res, res_body); } TEST_F(MatchingImportsToExports, LibraryExtraExports) { const std::string body = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpDecorate %1 LinkageAttributes "foo" Export %2 = OpTypeFloat 32 %1 = OpVariable %2 Uniform )"; spvtest::Binary linked_binary; LinkerOptions options; options.SetCreateLibrary(true); ASSERT_EQ(SPV_SUCCESS, AssembleAndLink({body}, &linked_binary, options)) << GetErrorMessage(); const std::string expected_res = R"(OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpModuleProcessed "Linked by SPIR-V Tools Linker" OpDecorate %1 LinkageAttributes "foo" Export %2 = OpTypeFloat 32 %1 = OpVariable %2 Uniform )"; std::string res_body; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); ASSERT_EQ(SPV_SUCCESS, Disassemble(linked_binary, &res_body)) << GetErrorMessage(); EXPECT_EQ(expected_res, res_body); } TEST_F(MatchingImportsToExports, UnresolvedImports) { const std::string body1 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpDecorate %1 LinkageAttributes "foo" Import %2 = OpTypeFloat 32 %1 = OpVariable %2 Uniform )"; const std::string body2 = R"( OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL )"; spvtest::Binary linked_binary; EXPECT_EQ(SPV_ERROR_INVALID_BINARY, AssembleAndLink({body1, body2}, &linked_binary)); EXPECT_THAT(GetErrorMessage(), HasSubstr("Unresolved external reference to \"foo\".")); } TEST_F(MatchingImportsToExports, TypeMismatch) { const std::string body1 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpDecorate %1 LinkageAttributes "foo" Import %2 = OpTypeFloat 32 %1 = OpVariable %2 Uniform %3 = OpVariable %2 Input )"; const std::string body2 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpDecorate %1 LinkageAttributes "foo" Export %2 = OpTypeInt 32 0 %3 = OpConstant %2 42 %1 = OpVariable %2 Uniform %3 )"; LinkerOptions options; for (int i = 0; i < 2; i++) { spvtest::Binary linked_binary; options.SetAllowPtrTypeMismatch(i == 1); EXPECT_EQ(SPV_ERROR_INVALID_BINARY, AssembleAndLink({body1, body2}, &linked_binary)) << GetErrorMessage(); EXPECT_THAT( GetErrorMessage(), HasSubstr("Type mismatch on symbol \"foo\" between imported " "variable/function %1 and exported variable/function %4")); } } TEST_F(MatchingImportsToExports, MultipleDefinitions) { const std::string body1 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpDecorate %1 LinkageAttributes "foo" Import %2 = OpTypeFloat 32 %1 = OpVariable %2 Uniform %3 = OpVariable %2 Input )"; const std::string body2 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpDecorate %1 LinkageAttributes "foo" Export %2 = OpTypeFloat 32 %3 = OpConstant %2 42 %1 = OpVariable %2 Uniform %3 )"; const std::string body3 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpDecorate %1 LinkageAttributes "foo" Export %2 = OpTypeFloat 32 %3 = OpConstant %2 -1 %1 = OpVariable %2 Uniform %3 )"; LinkerOptions options; for (int i = 0; i < 2; i++) { spvtest::Binary linked_binary; options.SetAllowPtrTypeMismatch(i == 1); EXPECT_EQ(SPV_ERROR_INVALID_BINARY, AssembleAndLink({body1, body2, body3}, &linked_binary)) << GetErrorMessage(); EXPECT_THAT(GetErrorMessage(), HasSubstr("Too many external references, 2, were found " "for \"foo\".")); } } TEST_F(MatchingImportsToExports, SameNameDifferentTypes) { const std::string body1 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpDecorate %1 LinkageAttributes "foo" Import %2 = OpTypeFloat 32 %1 = OpVariable %2 Uniform %3 = OpVariable %2 Input )"; const std::string body2 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpDecorate %1 LinkageAttributes "foo" Export %2 = OpTypeInt 32 0 %3 = OpConstant %2 42 %1 = OpVariable %2 Uniform %3 )"; const std::string body3 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpDecorate %1 LinkageAttributes "foo" Export %2 = OpTypeFloat 32 %3 = OpConstant %2 12 %1 = OpVariable %2 Uniform %3 )"; spvtest::Binary linked_binary; EXPECT_EQ(SPV_ERROR_INVALID_BINARY, AssembleAndLink({body1, body2, body3}, &linked_binary)) << GetErrorMessage(); EXPECT_THAT(GetErrorMessage(), HasSubstr("Too many external references, 2, were found " "for \"foo\".")); } TEST_F(MatchingImportsToExports, DecorationMismatch) { const std::string body1 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpDecorate %1 LinkageAttributes "foo" Import OpDecorate %2 Constant %2 = OpTypeFloat 32 %1 = OpVariable %2 Uniform %3 = OpVariable %2 Input )"; const std::string body2 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpDecorate %1 LinkageAttributes "foo" Export %2 = OpTypeFloat 32 %3 = OpConstant %2 42 %1 = OpVariable %2 Uniform %3 )"; LinkerOptions options; for (int i = 0; i < 2; i++) { spvtest::Binary linked_binary; options.SetAllowPtrTypeMismatch(i == 1); EXPECT_EQ(SPV_ERROR_INVALID_BINARY, AssembleAndLink({body1, body2}, &linked_binary)) << GetErrorMessage(); EXPECT_THAT( GetErrorMessage(), HasSubstr("Type mismatch on symbol \"foo\" between imported " "variable/function %1 and exported variable/function %4")); } } TEST_F(MatchingImportsToExports, FuncParamAttrDifferButStillMatchExportToImport) { const std::string body1 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpDecorate %1 LinkageAttributes "foo" Import OpDecorate %2 FuncParamAttr Zext %3 = OpTypeVoid %4 = OpTypeInt 32 0 %5 = OpTypeFunction %3 %4 %1 = OpFunction %3 None %5 %2 = OpFunctionParameter %4 OpFunctionEnd )"; const std::string body2 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpDecorate %1 LinkageAttributes "foo" Export OpDecorate %2 FuncParamAttr Sext %3 = OpTypeVoid %4 = OpTypeInt 32 0 %5 = OpTypeFunction %3 %4 %1 = OpFunction %3 None %5 %2 = OpFunctionParameter %4 %6 = OpLabel OpReturn OpFunctionEnd )"; spvtest::Binary linked_binary; ASSERT_EQ(SPV_SUCCESS, AssembleAndLink({body1, body2}, &linked_binary)) << GetErrorMessage(); const std::string expected_res = R"(OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpModuleProcessed "Linked by SPIR-V Tools Linker" OpDecorate %1 FuncParamAttr Sext %2 = OpTypeVoid %3 = OpTypeInt 32 0 %4 = OpTypeFunction %2 %3 %5 = OpFunction %2 None %4 %1 = OpFunctionParameter %3 %6 = OpLabel OpReturn OpFunctionEnd )"; std::string res_body; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); ASSERT_EQ(SPV_SUCCESS, Disassemble(linked_binary, &res_body)) << GetErrorMessage(); EXPECT_EQ(expected_res, res_body); } TEST_F(MatchingImportsToExports, FunctionCtrl) { const std::string body1 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpDecorate %1 LinkageAttributes "foo" Import %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeFloat 32 %5 = OpVariable %4 Uniform %1 = OpFunction %2 None %3 OpFunctionEnd )"; const std::string body2 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpDecorate %1 LinkageAttributes "foo" Export %2 = OpTypeVoid %3 = OpTypeFunction %2 %1 = OpFunction %2 Inline %3 %4 = OpLabel OpReturn OpFunctionEnd )"; spvtest::Binary linked_binary; ASSERT_EQ(SPV_SUCCESS, AssembleAndLink({body1, body2}, &linked_binary)) << GetErrorMessage(); const std::string expected_res = R"(OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpModuleProcessed "Linked by SPIR-V Tools Linker" %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpTypeFloat 32 %4 = OpVariable %3 Uniform %5 = OpFunction %1 Inline %2 %6 = OpLabel OpReturn OpFunctionEnd )"; std::string res_body; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); ASSERT_EQ(SPV_SUCCESS, Disassemble(linked_binary, &res_body)) << GetErrorMessage(); EXPECT_EQ(expected_res, res_body); } TEST_F(MatchingImportsToExports, UseExportedFuncParamAttr) { const std::string body1 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpDecorate %1 LinkageAttributes "foo" Import OpDecorate %2 FuncParamAttr Zext %2 = OpDecorationGroup OpGroupDecorate %2 %3 %4 %5 = OpTypeVoid %6 = OpTypeInt 32 0 %7 = OpTypeFunction %5 %6 %1 = OpFunction %5 None %7 %3 = OpFunctionParameter %6 OpFunctionEnd %8 = OpFunction %5 None %7 %4 = OpFunctionParameter %6 OpFunctionEnd )"; const std::string body2 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpDecorate %1 LinkageAttributes "foo" Export OpDecorate %2 FuncParamAttr Sext %3 = OpTypeVoid %4 = OpTypeInt 32 0 %5 = OpTypeFunction %3 %4 %1 = OpFunction %3 None %5 %2 = OpFunctionParameter %4 %6 = OpLabel OpReturn OpFunctionEnd )"; spvtest::Binary linked_binary; ASSERT_EQ(SPV_SUCCESS, AssembleAndLink({body1, body2}, &linked_binary)) << GetErrorMessage(); const std::string expected_res = R"(OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpModuleProcessed "Linked by SPIR-V Tools Linker" OpDecorate %1 FuncParamAttr Zext %1 = OpDecorationGroup OpGroupDecorate %1 %2 OpDecorate %3 FuncParamAttr Sext %4 = OpTypeVoid %5 = OpTypeInt 32 0 %6 = OpTypeFunction %4 %5 %7 = OpFunction %4 None %6 %2 = OpFunctionParameter %5 OpFunctionEnd %8 = OpFunction %4 None %6 %3 = OpFunctionParameter %5 %9 = OpLabel OpReturn OpFunctionEnd )"; std::string res_body; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); ASSERT_EQ(SPV_SUCCESS, Disassemble(linked_binary, &res_body)) << GetErrorMessage(); EXPECT_EQ(expected_res, res_body); } TEST_F(MatchingImportsToExports, NamesAndDecorations) { const std::string body1 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpName %1 "foo" OpName %3 "param" OpDecorate %1 LinkageAttributes "foo" Import OpDecorate %2 Restrict OpDecorate %4 NonWritable %2 = OpDecorationGroup OpGroupDecorate %2 %3 %4 %5 = OpTypeVoid %6 = OpTypeInt 32 0 %9 = OpTypePointer Function %6 %7 = OpTypeFunction %5 %9 %1 = OpFunction %5 None %7 %3 = OpFunctionParameter %9 OpFunctionEnd %8 = OpFunction %5 None %7 %4 = OpFunctionParameter %9 OpFunctionEnd )"; const std::string body2 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpName %1 "foo" OpName %2 "param" OpDecorate %1 LinkageAttributes "foo" Export OpDecorate %2 Restrict %3 = OpTypeVoid %4 = OpTypeInt 32 0 %7 = OpTypePointer Function %4 %5 = OpTypeFunction %3 %7 %1 = OpFunction %3 None %5 %2 = OpFunctionParameter %7 %6 = OpLabel OpReturn OpFunctionEnd )"; spvtest::Binary linked_binary; ASSERT_EQ(SPV_SUCCESS, AssembleAndLink({body1, body2}, &linked_binary)) << GetErrorMessage(); const std::string expected_res = R"(OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpName %1 "foo" OpName %2 "param" OpModuleProcessed "Linked by SPIR-V Tools Linker" OpDecorate %3 Restrict OpDecorate %4 NonWritable %3 = OpDecorationGroup OpGroupDecorate %3 %4 OpDecorate %2 Restrict %5 = OpTypeVoid %6 = OpTypeInt 32 0 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %5 %7 %9 = OpFunction %5 None %8 %4 = OpFunctionParameter %7 OpFunctionEnd %1 = OpFunction %5 None %8 %2 = OpFunctionParameter %7 %10 = OpLabel OpReturn OpFunctionEnd )"; std::string res_body; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); ASSERT_EQ(SPV_SUCCESS, Disassemble(linked_binary, &res_body)) << GetErrorMessage(); EXPECT_EQ(expected_res, res_body); } TEST_F(MatchingImportsToExports, FunctionCall) { const std::string body1 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpName %1 "foo" OpName %3 "param" OpDecorate %1 LinkageAttributes "foo" Import %5 = OpTypeVoid %6 = OpTypeInt 32 0 %9 = OpTypePointer Function %6 %7 = OpTypeFunction %5 %9 %1 = OpFunction %5 None %7 %3 = OpFunctionParameter %9 OpFunctionEnd %8 = OpFunction %5 None %7 %4 = OpFunctionParameter %9 %10 = OpLabel %11 = OpFunctionCall %5 %1 %4 OpReturn OpFunctionEnd )"; const std::string body2 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpName %1 "foo" OpName %2 "param" OpDecorate %1 LinkageAttributes "foo" Export %3 = OpTypeVoid %4 = OpTypeInt 32 0 %7 = OpTypePointer Function %4 %5 = OpTypeFunction %3 %7 %1 = OpFunction %3 None %5 %2 = OpFunctionParameter %7 %6 = OpLabel OpReturn OpFunctionEnd )"; LinkerOptions options; for (int i = 0; i < 2; i++) { spvtest::Binary linked_binary; options.SetAllowPtrTypeMismatch(i == 1); ASSERT_EQ(SPV_SUCCESS, AssembleAndLink({body1, body2}, &linked_binary, options)) << GetErrorMessage(); const std::string expected_res = R"(OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpName %1 "foo" OpName %2 "param" OpModuleProcessed "Linked by SPIR-V Tools Linker" %3 = OpTypeVoid %4 = OpTypeInt 32 0 %5 = OpTypePointer Function %4 %6 = OpTypeFunction %3 %5 %7 = OpFunction %3 None %6 %8 = OpFunctionParameter %5 %9 = OpLabel %10 = OpFunctionCall %3 %1 %8 OpReturn OpFunctionEnd %1 = OpFunction %3 None %6 %2 = OpFunctionParameter %5 %11 = OpLabel OpReturn OpFunctionEnd )"; std::string res_body; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); ASSERT_EQ(SPV_SUCCESS, Disassemble(linked_binary, &res_body)) << GetErrorMessage(); EXPECT_EQ(expected_res, res_body); } } TEST_F(MatchingImportsToExports, FunctionSignatureMismatchPointer) { const std::string body1 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpName %1 "foo" OpName %3 "param" OpDecorate %1 LinkageAttributes "foo" Import %5 = OpTypeVoid %6 = OpTypeInt 8 0 %9 = OpTypePointer Function %6 %7 = OpTypeFunction %5 %9 %1 = OpFunction %5 None %7 %3 = OpFunctionParameter %9 OpFunctionEnd %8 = OpFunction %5 None %7 %4 = OpFunctionParameter %9 %10 = OpLabel %11 = OpFunctionCall %5 %1 %4 OpReturn OpFunctionEnd )"; const std::string body2 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpName %1 "foo" OpName %2 "param" OpDecorate %1 LinkageAttributes "foo" Export %3 = OpTypeVoid %4 = OpTypeInt 32 0 %7 = OpTypePointer Function %4 %5 = OpTypeFunction %3 %7 %1 = OpFunction %3 None %5 %2 = OpFunctionParameter %7 %6 = OpLabel OpReturn OpFunctionEnd )"; spvtest::Binary linked_binary; ASSERT_EQ(SPV_ERROR_INVALID_BINARY, AssembleAndLink({body1, body2}, &linked_binary)) << GetErrorMessage(); EXPECT_THAT( GetErrorMessage(), HasSubstr("Type mismatch on symbol \"foo\" between imported " "variable/function %1 and exported variable/function %11")); LinkerOptions options; options.SetAllowPtrTypeMismatch(true); ASSERT_EQ(SPV_SUCCESS, AssembleAndLink({body1, body2}, &linked_binary, options)) << GetErrorMessage(); const std::string expected_res = R"(OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpName %1 "foo" OpName %2 "param" OpModuleProcessed "Linked by SPIR-V Tools Linker" %3 = OpTypeVoid %4 = OpTypeInt 8 0 %5 = OpTypePointer Function %4 %6 = OpTypeFunction %3 %5 %7 = OpTypeInt 32 0 %8 = OpTypePointer Function %7 %9 = OpTypeFunction %3 %8 %10 = OpFunction %3 None %6 %11 = OpFunctionParameter %5 %12 = OpLabel %13 = OpBitcast %8 %11 %14 = OpFunctionCall %3 %1 %13 OpReturn OpFunctionEnd %1 = OpFunction %3 None %9 %2 = OpFunctionParameter %8 %15 = OpLabel OpReturn OpFunctionEnd )"; std::string res_body; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); ASSERT_EQ(SPV_SUCCESS, Disassemble(linked_binary, &res_body)) << GetErrorMessage(); EXPECT_EQ(expected_res, res_body); } TEST_F(MatchingImportsToExports, FunctionSignatureMismatchValue) { const std::string body1 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpName %1 "foo" OpName %3 "param" OpDecorate %1 LinkageAttributes "foo" Import %5 = OpTypeVoid %6 = OpTypeInt 8 0 %7 = OpTypeFunction %5 %6 %1 = OpFunction %5 None %7 %3 = OpFunctionParameter %6 OpFunctionEnd %8 = OpFunction %5 None %7 %4 = OpFunctionParameter %6 %10 = OpLabel %11 = OpFunctionCall %5 %1 %4 OpReturn OpFunctionEnd )"; const std::string body2 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpName %1 "foo" OpName %2 "param" OpDecorate %1 LinkageAttributes "foo" Export %3 = OpTypeVoid %4 = OpTypeInt 32 0 %5 = OpTypeFunction %3 %4 %1 = OpFunction %3 None %5 %2 = OpFunctionParameter %4 %6 = OpLabel OpReturn OpFunctionEnd )"; LinkerOptions options; for (int i = 0; i < 2; i++) { spvtest::Binary linked_binary; options.SetAllowPtrTypeMismatch(i == 1); ASSERT_EQ(SPV_ERROR_INVALID_BINARY, AssembleAndLink({body1, body2}, &linked_binary)) << GetErrorMessage(); EXPECT_THAT( GetErrorMessage(), HasSubstr("Type mismatch on symbol \"foo\" between imported " "variable/function %1 and exported variable/function %10")); } } TEST_F(MatchingImportsToExports, FunctionSignatureMismatchTypePointerInt) { const std::string body1 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpName %1 "foo" OpName %3 "param" OpDecorate %1 LinkageAttributes "foo" Import %5 = OpTypeVoid %6 = OpTypeInt 64 0 %7 = OpTypeFunction %5 %6 %1 = OpFunction %5 None %7 %3 = OpFunctionParameter %6 OpFunctionEnd %8 = OpFunction %5 None %7 %4 = OpFunctionParameter %6 %10 = OpLabel %11 = OpFunctionCall %5 %1 %4 OpReturn OpFunctionEnd )"; const std::string body2 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpName %1 "foo" OpName %2 "param" OpDecorate %1 LinkageAttributes "foo" Export %3 = OpTypeVoid %4 = OpTypeInt 64 0 %7 = OpTypePointer Function %4 %5 = OpTypeFunction %3 %7 %1 = OpFunction %3 None %5 %2 = OpFunctionParameter %7 %6 = OpLabel OpReturn OpFunctionEnd )"; LinkerOptions options; for (int i = 0; i < 2; i++) { spvtest::Binary linked_binary; options.SetAllowPtrTypeMismatch(i == 1); ASSERT_EQ(SPV_ERROR_INVALID_BINARY, AssembleAndLink({body1, body2}, &linked_binary)) << GetErrorMessage(); EXPECT_THAT( GetErrorMessage(), HasSubstr("Type mismatch on symbol \"foo\" between imported " "variable/function %1 and exported variable/function %10")); } } TEST_F(MatchingImportsToExports, FunctionSignatureMismatchTypeIntPointer) { const std::string body1 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpName %1 "foo" OpName %3 "param" OpDecorate %1 LinkageAttributes "foo" Import %5 = OpTypeVoid %6 = OpTypeInt 64 0 %9 = OpTypePointer Function %6 %7 = OpTypeFunction %5 %9 %1 = OpFunction %5 None %7 %3 = OpFunctionParameter %9 OpFunctionEnd %8 = OpFunction %5 None %7 %4 = OpFunctionParameter %9 %10 = OpLabel %11 = OpFunctionCall %5 %1 %4 OpReturn OpFunctionEnd )"; const std::string body2 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpName %1 "foo" OpName %2 "param" OpDecorate %1 LinkageAttributes "foo" Export %3 = OpTypeVoid %4 = OpTypeInt 64 0 %5 = OpTypeFunction %3 %4 %1 = OpFunction %3 None %5 %2 = OpFunctionParameter %4 %6 = OpLabel OpReturn OpFunctionEnd )"; LinkerOptions options; for (int i = 0; i < 2; i++) { spvtest::Binary linked_binary; options.SetAllowPtrTypeMismatch(i == 1); ASSERT_EQ(SPV_ERROR_INVALID_BINARY, AssembleAndLink({body1, body2}, &linked_binary)) << GetErrorMessage(); EXPECT_THAT( GetErrorMessage(), HasSubstr("Type mismatch on symbol \"foo\" between imported " "variable/function %1 and exported variable/function %11")); } } TEST_F(MatchingImportsToExports, LinkOnceODRLinkageVarSingle) { const std::string body1 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpExtension "SPV_KHR_linkonce_odr" OpMemoryModel Physical64 OpenCL OpDecorate %1 LinkageAttributes "foo" LinkOnceODR %2 = OpTypeFloat 32 %3 = OpConstant %2 3.1415 %1 = OpVariable %2 Uniform %3 )"; const std::string body2 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpExtension "SPV_KHR_linkonce_odr" OpMemoryModel Physical64 OpenCL OpDecorate %1 LinkageAttributes "foo" Import %2 = OpTypeFloat 32 %1 = OpVariable %2 Uniform )"; const std::string matchTemplate = R"( ; CHECK-NOT: OpDecorate {{.*}} Import ; CHECK-NOT: OpDecorate {{.*}} LinkOnceODR )"; spvtest::Binary linked_binary; EXPECT_EQ(SPV_SUCCESS, AssembleAndLink({body1, body2}, &linked_binary)) << GetErrorMessage(); Match(matchTemplate, linked_binary); } TEST_F(MatchingImportsToExports, LinkOnceODRLinkageFunMultiple) { const std::string body1 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpExtension "SPV_KHR_linkonce_odr" OpMemoryModel Physical64 OpenCL OpDecorate %1 LinkageAttributes "foo" LinkOnceODR %2 = OpTypeVoid %3 = OpTypeFunction %2 %1 = OpFunction %2 Inline %3 %4 = OpLabel OpReturn OpFunctionEnd )"; const std::string body2 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpExtension "SPV_KHR_linkonce_odr" OpMemoryModel Physical64 OpenCL OpDecorate %1 LinkageAttributes "foo" Import %2 = OpTypeVoid %3 = OpTypeFunction %2 %1 = OpFunction %2 None %3 OpFunctionEnd )"; const std::string matchTemplate = R"( ; CHECK-NOT: OpDecorate {{.*}} Import ; CHECK-NOT: OpDecorate {{.*}} LinkOnceODR )"; spvtest::Binary linked_binary; EXPECT_EQ(SPV_SUCCESS, AssembleAndLink({body1, body1, body2}, &linked_binary)) << GetErrorMessage(); Match(matchTemplate, linked_binary); } TEST_F(MatchingImportsToExports, LinkOnceODRAndExport) { const std::string body1 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpExtension "SPV_KHR_linkonce_odr" OpMemoryModel Physical64 OpenCL OpDecorate %1 LinkageAttributes "foo" LinkOnceODR %2 = OpTypeFloat 32 %3 = OpConstant %2 3.1415 %1 = OpVariable %2 Uniform %3 )"; const std::string body2 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpExtension "SPV_KHR_linkonce_odr" OpMemoryModel Physical64 OpenCL OpDecorate %1 LinkageAttributes "foo" Export %2 = OpTypeFloat 32 %3 = OpConstant %2 2.7183 %1 = OpVariable %2 Uniform %3 )"; const std::string body3 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpExtension "SPV_KHR_linkonce_odr" OpMemoryModel Physical64 OpenCL OpDecorate %1 LinkageAttributes "foo" Import %2 = OpTypeFloat 32 %1 = OpVariable %2 Uniform )"; spvtest::Binary linked_binary; ASSERT_EQ(SPV_ERROR_INVALID_BINARY, AssembleAndLink({body1, body2, body3}, &linked_binary)) << GetErrorMessage(); EXPECT_THAT( GetErrorMessage(), HasSubstr("Combination of Export and LinkOnceODR is not allowed, found " "for \"foo\"")); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/link/memory_model_test.cpp000066400000000000000000000060721475742701700247050ustar00rootroot00000000000000// Copyright (c) 2017 Pierre Moreau // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gmock/gmock.h" #include "test/link/linker_fixture.h" namespace spvtools { namespace { using ::testing::HasSubstr; using MemoryModel = spvtest::LinkerTest; TEST_F(MemoryModel, Default) { const std::string body1 = R"( OpMemoryModel Logical Simple )"; const std::string body2 = R"( OpMemoryModel Logical Simple )"; spvtest::Binary linked_binary; ASSERT_EQ(SPV_SUCCESS, AssembleAndLink({body1, body2}, &linked_binary)); EXPECT_THAT(GetErrorMessage(), std::string()); EXPECT_EQ(spv::AddressingModel::Logical, static_cast(linked_binary[6])); EXPECT_EQ(spv::MemoryModel::Simple, static_cast(linked_binary[7])); } TEST_F(MemoryModel, AddressingMismatch) { const std::string body1 = R"( OpMemoryModel Logical Simple )"; const std::string body2 = R"( OpMemoryModel Physical32 Simple )"; spvtest::Binary linked_binary; EXPECT_EQ(SPV_ERROR_INTERNAL, AssembleAndLink({body1, body2}, &linked_binary)); EXPECT_THAT(GetErrorMessage(), HasSubstr("Conflicting addressing models: Logical (input modules " "1 through 1) vs Physical32 (input module 2).")); } TEST_F(MemoryModel, MemoryMismatch) { const std::string body1 = R"( OpMemoryModel Logical Simple )"; const std::string body2 = R"( OpMemoryModel Logical GLSL450 )"; spvtest::Binary linked_binary; EXPECT_EQ(SPV_ERROR_INTERNAL, AssembleAndLink({body1, body2}, &linked_binary)); EXPECT_THAT(GetErrorMessage(), HasSubstr("Conflicting memory models: Simple (input modules 1 " "through 1) vs GLSL450 (input module 2).")); } TEST_F(MemoryModel, FirstLackMemoryModel) { const std::string body1 = R"( )"; const std::string body2 = R"( OpMemoryModel Logical GLSL450 )"; spvtest::Binary linked_binary; EXPECT_EQ(SPV_ERROR_INVALID_BINARY, AssembleAndLink({body1, body2}, &linked_binary)); EXPECT_THAT( GetErrorMessage(), HasSubstr("Input module 1 is lacking an OpMemoryModel instruction.")); } TEST_F(MemoryModel, SecondLackMemoryModel) { const std::string body1 = R"( OpMemoryModel Logical GLSL450 )"; const std::string body2 = R"( )"; spvtest::Binary linked_binary; EXPECT_EQ(SPV_ERROR_INVALID_BINARY, AssembleAndLink({body1, body2}, &linked_binary)); EXPECT_THAT( GetErrorMessage(), HasSubstr("Input module 2 is lacking an OpMemoryModel instruction.")); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/link/partial_linkage_test.cpp000066400000000000000000000057321475742701700253450ustar00rootroot00000000000000// Copyright (c) 2018 Pierre Moreau // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gmock/gmock.h" #include "test/link/linker_fixture.h" namespace spvtools { namespace { using ::testing::HasSubstr; using PartialLinkage = spvtest::LinkerTest; TEST_F(PartialLinkage, Allowed) { const std::string body1 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpDecorate %1 LinkageAttributes "foo" Import OpDecorate %2 LinkageAttributes "bar" Import %3 = OpTypeFloat 32 %1 = OpVariable %3 Uniform %2 = OpVariable %3 Uniform )"; const std::string body2 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpDecorate %1 LinkageAttributes "bar" Export %2 = OpTypeFloat 32 %3 = OpConstant %2 3.1415 %1 = OpVariable %2 Uniform %3 )"; spvtest::Binary linked_binary; LinkerOptions linker_options; linker_options.SetAllowPartialLinkage(true); ASSERT_EQ(SPV_SUCCESS, AssembleAndLink({body1, body2}, &linked_binary, linker_options)) << GetErrorMessage(); const std::string expected_res = R"(OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpModuleProcessed "Linked by SPIR-V Tools Linker" OpDecorate %1 LinkageAttributes "foo" Import %2 = OpTypeFloat 32 %1 = OpVariable %2 Uniform %3 = OpConstant %2 3.1415 %4 = OpVariable %2 Uniform %3 )"; std::string res_body; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); ASSERT_EQ(SPV_SUCCESS, Disassemble(linked_binary, &res_body)) << GetErrorMessage(); EXPECT_EQ(expected_res, res_body); } TEST_F(PartialLinkage, Disallowed) { const std::string body1 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpDecorate %1 LinkageAttributes "foo" Import OpDecorate %2 LinkageAttributes "bar" Import %3 = OpTypeFloat 32 %1 = OpVariable %3 Uniform %2 = OpVariable %3 Uniform )"; const std::string body2 = R"( OpCapability Linkage OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpDecorate %1 LinkageAttributes "bar" Export %2 = OpTypeFloat 32 %3 = OpConstant %2 3.1415 %1 = OpVariable %2 Uniform %3 )"; spvtest::Binary linked_binary; EXPECT_EQ(SPV_ERROR_INVALID_BINARY, AssembleAndLink({body1, body2}, &linked_binary)); EXPECT_THAT(GetErrorMessage(), HasSubstr("Unresolved external reference to \"foo\".")); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/link/type_match_test.cpp000066400000000000000000000133401475742701700243460ustar00rootroot00000000000000// Copyright (c) 2019 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "gmock/gmock.h" #include "test/link/linker_fixture.h" namespace spvtools { namespace { using TypeMatch = spvtest::LinkerTest; // Basic types #define PartInt(D, N) D(N) " = OpTypeInt 32 0" #define PartFloat(D, N) D(N) " = OpTypeFloat 32" #define PartOpaque(D, N) D(N) " = OpTypeOpaque \"bar\"" #define PartSampler(D, N) D(N) " = OpTypeSampler" #define PartEvent(D, N) D(N) " = OpTypeEvent" #define PartDeviceEvent(D, N) D(N) " = OpTypeDeviceEvent" #define PartReserveId(D, N) D(N) " = OpTypeReserveId" #define PartQueue(D, N) D(N) " = OpTypeQueue" #define PartPipe(D, N) D(N) " = OpTypePipe ReadWrite" #define PartPipeStorage(D, N) D(N) " = OpTypePipeStorage" #define PartNamedBarrier(D, N) D(N) " = OpTypeNamedBarrier" // Compound types #define PartVector(DR, DA, N, T) DR(N) " = OpTypeVector " DA(T) " 3" #define PartMatrix(DR, DA, N, T) DR(N) " = OpTypeMatrix " DA(T) " 4" #define PartImage(DR, DA, N, T) \ DR(N) " = OpTypeImage " DA(T) " 2D 0 0 0 0 Rgba32f" #define PartSampledImage(DR, DA, N, T) DR(N) " = OpTypeSampledImage " DA(T) #define PartArray(DR, DA, N, T) DR(N) " = OpTypeArray " DA(T) " " DA(const) #define PartRuntimeArray(DR, DA, N, T) DR(N) " = OpTypeRuntimeArray " DA(T) #define PartStruct(DR, DA, N, T) DR(N) " = OpTypeStruct " DA(T) " " DA(T) #define PartPointer(DR, DA, N, T) DR(N) " = OpTypePointer Workgroup " DA(T) #define PartFunction(DR, DA, N, T) DR(N) " = OpTypeFunction " DA(T) " " DA(T) #define CheckDecoRes(S) "[[" #S ":%\\w+]]" #define CheckDecoArg(S) "[[" #S "]]" #define InstDeco(S) "%" #S #define MatchPart1(F, N) \ "; CHECK: " Part##F(CheckDecoRes, N) "\n" Part##F(InstDeco, N) "\n" #define MatchPart2(F, N, T) \ "; CHECK: " Part##F(CheckDecoRes, CheckDecoArg, N, T) "\n" Part##F( \ InstDeco, InstDeco, N, T) "\n" #define MatchF(N, CODE) \ TEST_F(TypeMatch, N) { \ const std::string base = \ "OpCapability Linkage\n" \ "OpCapability NamedBarrier\n" \ "OpCapability PipeStorage\n" \ "OpCapability Pipes\n" \ "OpCapability DeviceEnqueue\n" \ "OpCapability Kernel\n" \ "OpCapability Shader\n" \ "OpCapability Addresses\n" \ "OpMemoryModel Physical64 OpenCL\n" \ "OpDecorate %var LinkageAttributes \"foo\" " \ "{Import,Export}\n" \ "; CHECK: [[baseint:%\\w+]] = OpTypeInt 32 1\n" \ "%baseint = OpTypeInt 32 1\n" \ "; CHECK: [[const:%\\w+]] = OpConstant [[baseint]] 3\n" \ "%const = OpConstant %baseint 3\n" CODE \ "; CHECK: OpVariable [[type]] Uniform\n" \ "%var = OpVariable %type Uniform"; \ ExpandAndMatch(base); \ } #define Match1(T) MatchF(Type##T, MatchPart1(T, type)) #define Match2(T, A) \ MatchF(T##OfType##A, MatchPart1(A, a) MatchPart2(T, type, a)) #define Match3(T, A, B) \ MatchF(T##Of##A##Of##B, \ MatchPart1(B, b) MatchPart2(A, a, b) MatchPart2(T, type, a)) // clang-format off // Basic types Match1(Int) Match1(Float) Match1(Opaque) Match1(Sampler) Match1(Event) Match1(DeviceEvent) Match1(ReserveId) Match1(Queue) Match1(Pipe) Match1(PipeStorage) Match1(NamedBarrier) // Simpler (restricted) compound types Match2(Vector, Float) Match3(Matrix, Vector, Float) Match2(Image, Float) // Unrestricted compound types #define MatchCompounds1(A) \ Match2(RuntimeArray, A) \ Match2(Struct, A) \ Match2(Pointer, A) \ Match2(Function, A) \ Match2(Array, A) #define MatchCompounds2(A, B) \ Match3(RuntimeArray, A, B) \ Match3(Struct, A, B) \ Match3(Pointer, A, B) \ Match3(Function, A, B) \ Match3(Array, A, B) MatchCompounds1(Float) MatchCompounds2(Array, Float) MatchCompounds2(RuntimeArray, Float) MatchCompounds2(Struct, Float) MatchCompounds2(Pointer, Float) MatchCompounds2(Function, Float) // clang-format on // ForwardPointer tests, which don't fit into the previous mold #define MatchFpF(N, CODE) \ MatchF(N, \ "; CHECK: OpTypeForwardPointer [[type:%\\w+]] Workgroup\n" \ "OpTypeForwardPointer %type Workgroup\n" CODE \ "; CHECK: [[type]] = OpTypePointer Workgroup [[realtype]]\n" \ "%type = OpTypePointer Workgroup %realtype\n") #define MatchFp1(T) MatchFpF(ForwardPointerOf##T, MatchPart1(T, realtype)) #define MatchFp2(T, A) \ MatchFpF(ForwardPointerOf##T, MatchPart1(A, a) MatchPart2(T, realtype, a)) // clang-format off MatchFp1(Float) MatchFp2(Array, Float) MatchFp2(RuntimeArray, Float) MatchFp2(Struct, Float) MatchFp2(Function, Float) // clang-format on } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/link/unique_ids_test.cpp000066400000000000000000000124111475742701700243540ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gmock/gmock.h" #include "test/link/linker_fixture.h" namespace spvtools { namespace { using UniqueIds = spvtest::LinkerTest; TEST_F(UniqueIds, UniquelyMerged) { std::vector bodies(2); bodies[0] = // clang-format off "OpCapability Shader\n" "%1 = OpExtInstImport \"GLSL.std.450\"\n" "OpMemoryModel Logical GLSL450\n" "OpEntryPoint Vertex %main \"main\"\n" "OpSource ESSL 310\n" "OpName %main \"main\"\n" "OpName %f_ \"f(\"\n" "OpName %gv1 \"gv1\"\n" "OpName %gv2 \"gv2\"\n" "OpName %lv1 \"lv1\"\n" "OpName %lv2 \"lv2\"\n" "OpName %lv1_0 \"lv1\"\n" "%void = OpTypeVoid\n" "%10 = OpTypeFunction %void\n" "%float = OpTypeFloat 32\n" "%12 = OpTypeFunction %float\n" "%_ptr_Private_float = OpTypePointer Private %float\n" "%gv1 = OpVariable %_ptr_Private_float Private\n" "%float_10 = OpConstant %float 10\n" "%gv2 = OpVariable %_ptr_Private_float Private\n" "%float_100 = OpConstant %float 100\n" "%_ptr_Function_float = OpTypePointer Function %float\n" "%main = OpFunction %void None %10\n" "%17 = OpLabel\n" "%lv1_0 = OpVariable %_ptr_Function_float Function\n" "OpStore %gv1 %float_10\n" "OpStore %gv2 %float_100\n" "%18 = OpLoad %float %gv1\n" "%19 = OpLoad %float %gv2\n" "%20 = OpFSub %float %18 %19\n" "OpStore %lv1_0 %20\n" "OpReturn\n" "OpFunctionEnd\n" "%f_ = OpFunction %float None %12\n" "%21 = OpLabel\n" "%lv1 = OpVariable %_ptr_Function_float Function\n" "%lv2 = OpVariable %_ptr_Function_float Function\n" "%22 = OpLoad %float %gv1\n" "%23 = OpLoad %float %gv2\n" "%24 = OpFAdd %float %22 %23\n" "OpStore %lv1 %24\n" "%25 = OpLoad %float %gv1\n" "%26 = OpLoad %float %gv2\n" "%27 = OpFMul %float %25 %26\n" "OpStore %lv2 %27\n" "%28 = OpLoad %float %lv1\n" "%29 = OpLoad %float %lv2\n" "%30 = OpFDiv %float %28 %29\n" "OpReturnValue %30\n" "OpFunctionEnd\n"; // clang-format on bodies[1] = // clang-format off "OpCapability Shader\n" "%1 = OpExtInstImport \"GLSL.std.450\"\n" "OpMemoryModel Logical GLSL450\n" "OpSource ESSL 310\n" "OpName %main \"main2\"\n" "OpName %f_ \"f(\"\n" "OpName %gv1 \"gv12\"\n" "OpName %gv2 \"gv22\"\n" "OpName %lv1 \"lv12\"\n" "OpName %lv2 \"lv22\"\n" "OpName %lv1_0 \"lv12\"\n" "%void = OpTypeVoid\n" "%10 = OpTypeFunction %void\n" "%float = OpTypeFloat 32\n" "%12 = OpTypeFunction %float\n" "%_ptr_Private_float = OpTypePointer Private %float\n" "%gv1 = OpVariable %_ptr_Private_float Private\n" "%float_10 = OpConstant %float 10\n" "%gv2 = OpVariable %_ptr_Private_float Private\n" "%float_100 = OpConstant %float 100\n" "%_ptr_Function_float = OpTypePointer Function %float\n" "%main = OpFunction %void None %10\n" "%17 = OpLabel\n" "%lv1_0 = OpVariable %_ptr_Function_float Function\n" "OpStore %gv1 %float_10\n" "OpStore %gv2 %float_100\n" "%18 = OpLoad %float %gv1\n" "%19 = OpLoad %float %gv2\n" "%20 = OpFSub %float %18 %19\n" "OpStore %lv1_0 %20\n" "OpReturn\n" "OpFunctionEnd\n" "%f_ = OpFunction %float None %12\n" "%21 = OpLabel\n" "%lv1 = OpVariable %_ptr_Function_float Function\n" "%lv2 = OpVariable %_ptr_Function_float Function\n" "%22 = OpLoad %float %gv1\n" "%23 = OpLoad %float %gv2\n" "%24 = OpFAdd %float %22 %23\n" "OpStore %lv1 %24\n" "%25 = OpLoad %float %gv1\n" "%26 = OpLoad %float %gv2\n" "%27 = OpFMul %float %25 %26\n" "OpStore %lv2 %27\n" "%28 = OpLoad %float %lv1\n" "%29 = OpLoad %float %lv2\n" "%30 = OpFDiv %float %28 %29\n" "OpReturnValue %30\n" "OpFunctionEnd\n"; // clang-format on spvtest::Binary linked_binary; LinkerOptions options; options.SetVerifyIds(true); spv_result_t res = AssembleAndLink(bodies, &linked_binary, options); ASSERT_EQ(SPV_SUCCESS, res) << GetErrorMessage(); EXPECT_THAT(GetErrorMessage(), std::string()); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/lint/000077500000000000000000000000001475742701700204565ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/lint/CMakeLists.txt000066400000000000000000000012641475742701700232210ustar00rootroot00000000000000# Copyright (c) 2021 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. add_spvtools_unittest(TARGET lint SRCS divergence_analysis_test.cpp LIBS SPIRV-Tools-lint SPIRV-Tools-opt ) KhronosGroup-SPIRV-Tools-f289d04/test/lint/divergence_analysis_test.cpp000066400000000000000000000554351475742701700262530ustar00rootroot00000000000000// Copyright (c) 2021 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/lint/divergence_analysis.h" #include #include "gtest/gtest.h" #include "source/opt/build_module.h" #include "source/opt/ir_context.h" #include "source/opt/module.h" #include "spirv-tools/libspirv.h" namespace spvtools { namespace lint { namespace { void CLIMessageConsumer(spv_message_level_t level, const char*, const spv_position_t& position, const char* message) { switch (level) { case SPV_MSG_FATAL: case SPV_MSG_INTERNAL_ERROR: case SPV_MSG_ERROR: std::cerr << "error: line " << position.index << ": " << message << std::endl; break; case SPV_MSG_WARNING: std::cout << "warning: line " << position.index << ": " << message << std::endl; break; case SPV_MSG_INFO: std::cout << "info: line " << position.index << ": " << message << std::endl; break; default: break; } } class DivergenceTest : public ::testing::Test { protected: std::unique_ptr context_; std::unique_ptr divergence_; void Build(std::string text, uint32_t function_id = 1) { context_ = BuildModule(SPV_ENV_UNIVERSAL_1_0, CLIMessageConsumer, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); ASSERT_NE(nullptr, context_.get()); opt::Module* module = context_->module(); ASSERT_NE(nullptr, module); // First function should have the given ID. ASSERT_NE(module->begin(), module->end()); opt::Function* function = &*module->begin(); ASSERT_EQ(function->result_id(), function_id); divergence_.reset(new DivergenceAnalysis(*context_)); divergence_->Run(function); } }; // Makes assertions a bit shorter. using Level = DivergenceAnalysis::DivergenceLevel; namespace { std::string Preamble() { return R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" %x %y OpExecutionMode %1 OriginLowerLeft OpDecorate %y Flat %void = OpTypeVoid %void_f = OpTypeFunction %void %bool = OpTypeBool %float = OpTypeFloat 32 %false = OpConstantFalse %bool %true = OpConstantTrue %bool %zero = OpConstant %float 0 %one = OpConstant %float 1 %x_t = OpTypePointer Input %float %x = OpVariable %x_t Input %y = OpVariable %x_t Input %1 = OpFunction %void None %void_f )"; } } // namespace TEST_F(DivergenceTest, SimpleTest) { // pseudocode: // %10: // %11 = load x // if (%12 = (%11 < 0)) { // %13: // // do nothing // } // %14: // return ASSERT_NO_FATAL_FAILURE(Build(Preamble() + R"( %10 = OpLabel %11 = OpLoad %float %x %12 = OpFOrdLessThan %bool %11 %zero OpSelectionMerge %14 None OpBranchConditional %12 %13 %14 %13 = OpLabel OpBranch %14 %14 = OpLabel OpReturn OpFunctionEnd )")); // Control flow divergence. EXPECT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(10)); EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(13)); EXPECT_EQ(12, divergence_->GetDivergenceSource(13)); EXPECT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(14)); // Value divergence. EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(11)); EXPECT_EQ(0, divergence_->GetDivergenceSource(11)); EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(12)); EXPECT_EQ(11, divergence_->GetDivergenceSource(12)); } TEST_F(DivergenceTest, FlowTypesTest) { // pseudocode: // %10: // %11 = load x // %12 = x < 0 // data -> data // if (%12) { // %13: // data -> control // if (true) { // %14: // control -> control // } // %15: // %16 = 1 // } else { // %17: // %18 = 2 // } // %19: // %19 = phi(%16 from %15, %18 from %17) // control -> data // return ASSERT_NO_FATAL_FAILURE(Build(Preamble() + R"( %10 = OpLabel %11 = OpLoad %float %x %12 = OpFOrdLessThan %bool %11 %zero OpSelectionMerge %19 None OpBranchConditional %12 %13 %17 %13 = OpLabel OpSelectionMerge %15 None OpBranchConditional %true %14 %15 %14 = OpLabel OpBranch %15 %15 = OpLabel %16 = OpFAdd %float %zero %zero OpBranch %19 %17 = OpLabel %18 = OpFAdd %float %zero %one OpBranch %19 %19 = OpLabel %20 = OpPhi %float %16 %15 %18 %17 OpReturn OpFunctionEnd )")); EXPECT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(10)); EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(11)); EXPECT_EQ(0, divergence_->GetDivergenceSource(11)); EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(12)); EXPECT_EQ(11, divergence_->GetDivergenceSource(12)); EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(13)); EXPECT_EQ(12, divergence_->GetDivergenceSource(13)); EXPECT_EQ(10, divergence_->GetDivergenceDependenceSource(13)); EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(14)); EXPECT_EQ(13, divergence_->GetDivergenceSource(14)); EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(15)); EXPECT_EQ(12, divergence_->GetDivergenceSource(15)); EXPECT_EQ(10, divergence_->GetDivergenceDependenceSource(15)); EXPECT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(16)); EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(17)); EXPECT_EQ(12, divergence_->GetDivergenceSource(17)); EXPECT_EQ(10, divergence_->GetDivergenceDependenceSource(17)); EXPECT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(18)); EXPECT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(19)); EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(20)); EXPECT_TRUE(divergence_->GetDivergenceSource(20) == 15 || divergence_->GetDivergenceDependenceSource(20) == 17) << "Got: " << divergence_->GetDivergenceDependenceSource(20); } TEST_F(DivergenceTest, ExitDependenceTest) { // pseudocode: // %10: // %11 = load x // %12 = %11 < 0 // %13: // do { // %14: // if (%12) { // %15: // continue; // } // %16: // %17: // continue; // } %18: while(false); // %19: // return ASSERT_NO_FATAL_FAILURE(Build(Preamble() + R"( %10 = OpLabel %11 = OpLoad %float %x %12 = OpFOrdLessThan %bool %11 %zero ; data -> data OpBranch %13 %13 = OpLabel OpLoopMerge %19 %18 None OpBranch %14 %14 = OpLabel OpSelectionMerge %16 None OpBranchConditional %12 %15 %16 %15 = OpLabel OpBranch %18 ; continue %16 = OpLabel OpBranch %17 %17 = OpLabel OpBranch %18 ; continue %18 = OpLabel OpBranchConditional %false %13 %19 %19 = OpLabel OpReturn OpFunctionEnd )")); EXPECT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(10)); EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(11)); EXPECT_EQ(0, divergence_->GetDivergenceSource(11)); EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(12)); EXPECT_EQ(11, divergence_->GetDivergenceSource(12)); // Since both branches continue, there's no divergent control dependence // to 13. EXPECT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(13)); EXPECT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(14)); EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(15)); EXPECT_EQ(12, divergence_->GetDivergenceSource(15)); EXPECT_EQ(14, divergence_->GetDivergenceDependenceSource(15)); // These two blocks are outside the if but are still control dependent. EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(16)); EXPECT_EQ(12, divergence_->GetDivergenceSource(16)); EXPECT_EQ(14, divergence_->GetDivergenceDependenceSource(16)); EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(17)); EXPECT_EQ(12, divergence_->GetDivergenceSource(17)); EXPECT_EQ(14, divergence_->GetDivergenceDependenceSource(17)); EXPECT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(18)); EXPECT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(19)); } TEST_F(DivergenceTest, ReconvergencePromotionTest) { // pseudocode: // %10: // %11 = load y // %12 = %11 < 0 // if (%12) { // %13: // %14: // %15: // if (true) { // %16: // } // // Reconvergence *not* guaranteed as // // control is not uniform on the IG level // // at %15. // %17: // %18: // %19: // %20 = load x // } // %21: // %22 = phi(%11, %20) // return ASSERT_NO_FATAL_FAILURE(Build(Preamble() + R"( %10 = OpLabel %11 = OpLoad %float %y %12 = OpFOrdLessThan %bool %11 %zero OpSelectionMerge %21 None OpBranchConditional %12 %13 %21 %13 = OpLabel OpBranch %14 %14 = OpLabel OpBranch %15 %15 = OpLabel OpSelectionMerge %17 None OpBranchConditional %true %16 %17 %16 = OpLabel OpBranch %17 %17 = OpLabel OpBranch %18 %18 = OpLabel OpBranch %19 %19 = OpLabel %20 = OpLoad %float %y OpBranch %21 %21 = OpLabel %22 = OpPhi %float %11 %10 %20 %19 OpReturn OpFunctionEnd )")); ASSERT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(10)); ASSERT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(21)); ASSERT_EQ(Level::kPartiallyUniform, divergence_->GetDivergenceLevel(11)); ASSERT_EQ(0, divergence_->GetDivergenceSource(11)); ASSERT_EQ(Level::kPartiallyUniform, divergence_->GetDivergenceLevel(12)); ASSERT_EQ(11, divergence_->GetDivergenceSource(12)); ASSERT_EQ(Level::kPartiallyUniform, divergence_->GetDivergenceLevel(13)); ASSERT_EQ(12, divergence_->GetDivergenceSource(13)); ASSERT_EQ(10, divergence_->GetDivergenceDependenceSource(13)); ASSERT_EQ(Level::kPartiallyUniform, divergence_->GetDivergenceLevel(14)); ASSERT_EQ(12, divergence_->GetDivergenceSource(14)); ASSERT_EQ(10, divergence_->GetDivergenceDependenceSource(14)); ASSERT_EQ(Level::kPartiallyUniform, divergence_->GetDivergenceLevel(15)); ASSERT_EQ(12, divergence_->GetDivergenceSource(15)); ASSERT_EQ(10, divergence_->GetDivergenceDependenceSource(15)); ASSERT_EQ(Level::kPartiallyUniform, divergence_->GetDivergenceLevel(16)); ASSERT_EQ(15, divergence_->GetDivergenceSource(16)); ASSERT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(17)); ASSERT_EQ(12, divergence_->GetDivergenceSource(17)); ASSERT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(18)); ASSERT_EQ(12, divergence_->GetDivergenceSource(18)); ASSERT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(19)); ASSERT_EQ(12, divergence_->GetDivergenceSource(19)); ASSERT_EQ(Level::kPartiallyUniform, divergence_->GetDivergenceLevel(20)); ASSERT_EQ(0, divergence_->GetDivergenceSource(20)); ASSERT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(22)); ASSERT_EQ(19, divergence_->GetDivergenceSource(22)); ASSERT_EQ(10, divergence_->GetDivergenceDependenceSource(15)); } TEST_F(DivergenceTest, FunctionCallTest) { // pseudocode: // %2() { // %20: // %21 = load x // %22 = %21 < 0 // if (%22) { // %23: // return // } // %24: // return // } // // main() { // %10: // %11 = %2(); // // Reconvergence *not* guaranteed. // %12: // return // } ASSERT_NO_FATAL_FAILURE(Build(Preamble() + R"( %10 = OpLabel %11 = OpFunctionCall %void %2 OpBranch %12 %12 = OpLabel OpReturn OpFunctionEnd %2 = OpFunction %void None %void_f %20 = OpLabel %21 = OpLoad %float %x %22 = OpFOrdLessThan %bool %21 %zero OpSelectionMerge %24 None OpBranchConditional %22 %23 %24 %23 = OpLabel OpReturn %24 = OpLabel OpReturn OpFunctionEnd )")); EXPECT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(10)); // Conservatively assume function return value is uniform. EXPECT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(11)); // TODO(dongja): blocks reachable from diverging function calls should be // divergent. // EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(12)); EXPECT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(12)); // Wrong! } TEST_F(DivergenceTest, LateMergeTest) { // pseudocode: // %10: // %11 = load y // %12 = %11 < 0 // [merge: %15] // if (%12) { // %13: // } // %14: // Reconvergence hasn't happened by here. // %15: // return ASSERT_NO_FATAL_FAILURE(Build(Preamble() + R"( %10 = OpLabel %11 = OpLoad %float %x %12 = OpFOrdLessThan %bool %11 %zero OpSelectionMerge %15 None OpBranchConditional %12 %13 %14 %13 = OpLabel OpBranch %14 %14 = OpLabel OpBranch %15 %15 = OpLabel OpReturn OpFunctionEnd )")); EXPECT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(10)); EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(11)); EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(12)); EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(13)); // TODO(dongja): // EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(14)); EXPECT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(14)); // Wrong! EXPECT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(15)); } // The following series of tests makes sure that we find the least fixpoint. TEST_F(DivergenceTest, UniformFixpointTest) { // pseudocode: // %10: // %20 = load x // %21 = load y // do { // %11: // %12: // %13 = phi(%zero from %11, %14 from %16) // %14 = %13 + 1 // %15 = %13 < 1 // } %16: while (%15) // %17: ASSERT_NO_FATAL_FAILURE(Build(Preamble() + R"( %10 = OpLabel %20 = OpLoad %float %x %21 = OpLoad %float %y OpBranch %11 %11 = OpLabel %13 = OpPhi %float %zero %10 %14 %16 OpLoopMerge %17 %16 None OpBranch %12 %12 = OpLabel %14 = OpFAdd %float %13 %one %15 = OpFOrdLessThan %bool %13 %one OpBranch %16 %16 = OpLabel OpBranchConditional %15 %11 %17 %17 = OpLabel OpReturn OpFunctionEnd )")); EXPECT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(10)); EXPECT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(11)); EXPECT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(12)); EXPECT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(13)); EXPECT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(14)); EXPECT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(15)); EXPECT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(16)); EXPECT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(17)); } TEST_F(DivergenceTest, PartiallyUniformFixpointTest) { // pseudocode: // %10: // %20 = load x // %21 = load y // do { // %11: // %12: // %13 = phi(%zero from %11, %14 from %16) // %14 = %13 + 1 // %15 = %13 < %21 // } %16: while (%15) // %17: ASSERT_NO_FATAL_FAILURE(Build(Preamble() + R"( %10 = OpLabel %20 = OpLoad %float %x %21 = OpLoad %float %y OpBranch %11 %11 = OpLabel %13 = OpPhi %float %zero %10 %14 %16 OpLoopMerge %17 %16 None OpBranch %12 %12 = OpLabel %14 = OpFAdd %float %13 %one %15 = OpFOrdLessThan %bool %13 %21 OpBranch %16 %16 = OpLabel OpBranchConditional %15 %11 %17 %17 = OpLabel OpReturn OpFunctionEnd )")); EXPECT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(10)); EXPECT_EQ(Level::kPartiallyUniform, divergence_->GetDivergenceLevel(11)); EXPECT_EQ(Level::kPartiallyUniform, divergence_->GetDivergenceLevel(12)); EXPECT_EQ(Level::kPartiallyUniform, divergence_->GetDivergenceLevel(13)); EXPECT_EQ(Level::kPartiallyUniform, divergence_->GetDivergenceLevel(14)); EXPECT_EQ(Level::kPartiallyUniform, divergence_->GetDivergenceLevel(15)); EXPECT_EQ(Level::kPartiallyUniform, divergence_->GetDivergenceLevel(16)); EXPECT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(17)); } TEST_F(DivergenceTest, DivergentFixpointTest) { // pseudocode: // %10: // %20 = load x // %21 = load y // do { // %11: // %12: // %13 = phi(%zero from %11, %14 from %16) // %14 = %13 + 1 // %15 = %13 < %20 // } %16: while (%15) // %17: ASSERT_NO_FATAL_FAILURE(Build(Preamble() + R"( %10 = OpLabel %20 = OpLoad %float %x %21 = OpLoad %float %y OpBranch %11 %11 = OpLabel %13 = OpPhi %float %zero %10 %14 %16 OpLoopMerge %17 %16 None OpBranch %12 %12 = OpLabel %14 = OpFAdd %float %13 %one %15 = OpFOrdLessThan %bool %13 %20 OpBranch %16 %16 = OpLabel OpBranchConditional %15 %11 %17 %17 = OpLabel OpReturn OpFunctionEnd )")); EXPECT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(10)); EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(11)); EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(12)); EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(13)); EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(14)); EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(15)); EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(16)); EXPECT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(17)); } TEST_F(DivergenceTest, DivergentOverridesPartiallyUniformTest) { // pseudocode: // %10: // %20 = load x // %21 = load y // %11: // do { // %12: // %13 = phi(%21 from %11, %14 from %16) // %14 = %13 + 1 // %15 = %13 < %20 // } %16: while (%15) // %17: ASSERT_NO_FATAL_FAILURE(Build(Preamble() + R"( %10 = OpLabel %20 = OpLoad %float %x %21 = OpLoad %float %y OpBranch %11 %11 = OpLabel %13 = OpPhi %float %zero %10 %14 %16 OpLoopMerge %17 %16 None OpBranch %12 %12 = OpLabel %14 = OpFAdd %float %13 %one %15 = OpFOrdLessThan %bool %13 %20 OpBranch %16 %16 = OpLabel OpBranchConditional %15 %11 %17 %17 = OpLabel OpReturn OpFunctionEnd )")); EXPECT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(10)); EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(11)); EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(12)); EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(13)); EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(14)); EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(15)); EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(16)); EXPECT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(17)); } TEST_F(DivergenceTest, NestedFixpointTest) { // pseudocode: // %10: // %20 = load x // %21 = load y // do { // %22: // %23: // %24 = phi(%zero from %22, %25 from %26) // %11: // do { // %12: // %13 = phi(%zero from %11, %14 from %16) // %14 = %13 + 1 // %15 = %13 < %24 // } %16: while (%15) // %17: // %25 = load x // } %26: while (false) // %27: // return ASSERT_NO_FATAL_FAILURE(Build(Preamble() + R"( %10 = OpLabel %20 = OpLoad %float %x %21 = OpLoad %float %y OpBranch %22 %22 = OpLabel %24 = OpPhi %float %zero %10 %25 %26 OpLoopMerge %27 %26 None OpBranch %23 %23 = OpLabel OpBranch %11 %11 = OpLabel %13 = OpPhi %float %zero %23 %14 %16 OpLoopMerge %17 %16 None OpBranch %12 %12 = OpLabel %14 = OpFAdd %float %13 %one %15 = OpFOrdLessThan %bool %13 %24 OpBranch %16 %16 = OpLabel OpBranchConditional %15 %11 %17 %17 = OpLabel %25 = OpLoad %float %x OpBranch %26 %26 = OpLabel OpBranchConditional %false %22 %27 %27 = OpLabel OpReturn OpFunctionEnd )")); // This test makes sure that divergent values flowing upward can influence the // fixpoint of a loop. EXPECT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(10)); EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(11)); EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(12)); EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(13)); EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(14)); EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(15)); EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(16)); // Control of the outer loop is still uniform. EXPECT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(17)); EXPECT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(22)); EXPECT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(23)); // Seed divergent values. EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(24)); EXPECT_EQ(Level::kDivergent, divergence_->GetDivergenceLevel(25)); // Outer loop control. EXPECT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(26)); // Merged. EXPECT_EQ(Level::kUniform, divergence_->GetDivergenceLevel(27)); } } // namespace } // namespace lint } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/name_mapper_test.cpp000066400000000000000000000365421475742701700235510ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gmock/gmock.h" #include "source/name_mapper.h" #include "test/test_fixture.h" #include "test/unit_spirv.h" namespace spvtools { namespace { using spvtest::ScopedContext; using ::testing::Eq; TEST(TrivialNameTest, Samples) { auto mapper = GetTrivialNameMapper(); EXPECT_EQ(mapper(1), "1"); EXPECT_EQ(mapper(1999), "1999"); EXPECT_EQ(mapper(1024), "1024"); } // A test case for the name mappers that actually look at an assembled module. struct NameIdCase { std::string assembly; // Input assembly text uint32_t id; std::string expected_name; }; using FriendlyNameTest = spvtest::TextToBinaryTestBase<::testing::TestWithParam>; TEST_P(FriendlyNameTest, SingleMapping) { ScopedContext context(SPV_ENV_UNIVERSAL_1_1); auto words = CompileSuccessfully(GetParam().assembly, SPV_ENV_UNIVERSAL_1_1); auto friendly_mapper = FriendlyNameMapper(context.context, words.data(), words.size()); NameMapper mapper = friendly_mapper.GetNameMapper(); EXPECT_THAT(mapper(GetParam().id), Eq(GetParam().expected_name)) << GetParam().assembly << std::endl << " for id " << GetParam().id; } INSTANTIATE_TEST_SUITE_P(ScalarType, FriendlyNameTest, ::testing::ValuesIn(std::vector{ {"%1 = OpTypeVoid", 1, "void"}, {"%1 = OpTypeBool", 1, "bool"}, {"%1 = OpTypeInt 8 0", 1, "uchar"}, {"%1 = OpTypeInt 8 1", 1, "char"}, {"%1 = OpTypeInt 16 0", 1, "ushort"}, {"%1 = OpTypeInt 16 1", 1, "short"}, {"%1 = OpTypeInt 32 0", 1, "uint"}, {"%1 = OpTypeInt 32 1", 1, "int"}, {"%1 = OpTypeInt 64 0", 1, "ulong"}, {"%1 = OpTypeInt 64 1", 1, "long"}, {"%1 = OpTypeInt 1 0", 1, "u1"}, {"%1 = OpTypeInt 1 1", 1, "i1"}, {"%1 = OpTypeInt 33 0", 1, "u33"}, {"%1 = OpTypeInt 33 1", 1, "i33"}, {"%1 = OpTypeFloat 16", 1, "half"}, {"%1 = OpTypeFloat 32", 1, "float"}, {"%1 = OpTypeFloat 64", 1, "double"}, {"%1 = OpTypeFloat 10", 1, "fp10"}, {"%1 = OpTypeFloat 55", 1, "fp55"}, })); INSTANTIATE_TEST_SUITE_P( VectorType, FriendlyNameTest, ::testing::ValuesIn(std::vector{ {"%1 = OpTypeBool %2 = OpTypeVector %1 1", 2, "v1bool"}, {"%1 = OpTypeBool %2 = OpTypeVector %1 2", 2, "v2bool"}, {"%1 = OpTypeBool %2 = OpTypeVector %1 3", 2, "v3bool"}, {"%1 = OpTypeBool %2 = OpTypeVector %1 4", 2, "v4bool"}, {"%1 = OpTypeInt 8 0 %2 = OpTypeVector %1 2", 2, "v2uchar"}, {"%1 = OpTypeInt 16 1 %2 = OpTypeVector %1 3", 2, "v3short"}, {"%1 = OpTypeInt 32 0 %2 = OpTypeVector %1 4", 2, "v4uint"}, {"%1 = OpTypeInt 64 1 %2 = OpTypeVector %1 3", 2, "v3long"}, {"%1 = OpTypeInt 20 0 %2 = OpTypeVector %1 4", 2, "v4u20"}, {"%1 = OpTypeInt 21 1 %2 = OpTypeVector %1 3", 2, "v3i21"}, {"%1 = OpTypeFloat 32 %2 = OpTypeVector %1 2", 2, "v2float"}, // OpName overrides the element name. {"OpName %1 \"time\" %1 = OpTypeFloat 32 %2 = OpTypeVector %1 2", 2, "v2time"}, })); INSTANTIATE_TEST_SUITE_P( MatrixType, FriendlyNameTest, ::testing::ValuesIn(std::vector{ {"%1 = OpTypeBool %2 = OpTypeVector %1 2 %3 = OpTypeMatrix %2 2", 3, "mat2v2bool"}, {"%1 = OpTypeFloat 32 %2 = OpTypeVector %1 2 %3 = OpTypeMatrix %2 3", 3, "mat3v2float"}, {"%1 = OpTypeFloat 32 %2 = OpTypeVector %1 2 %3 = OpTypeMatrix %2 4", 3, "mat4v2float"}, {"OpName %1 \"time\" %1 = OpTypeFloat 32 %2 = OpTypeVector %1 2 %3 = " "OpTypeMatrix %2 4", 3, "mat4v2time"}, {"OpName %2 \"lat_long\" %1 = OpTypeFloat 32 %2 = OpTypeVector %1 2 %3 " "= OpTypeMatrix %2 4", 3, "mat4lat_long"}, })); INSTANTIATE_TEST_SUITE_P( OpName, FriendlyNameTest, ::testing::ValuesIn(std::vector{ {"OpName %1 \"abcdefg\"", 1, "abcdefg"}, {"OpName %1 \"Hello world!\"", 1, "Hello_world_"}, {"OpName %1 \"0123456789\"", 1, "0123456789"}, {"OpName %1 \"_\"", 1, "_"}, // An empty string is not valid for SPIR-V assembly IDs. {"OpName %1 \"\"", 1, "_"}, // Test uniqueness when presented with things mapping to "_" {"OpName %1 \"\" OpName %2 \"\"", 1, "_"}, {"OpName %1 \"\" OpName %2 \"\"", 2, "__0"}, {"OpName %1 \"\" OpName %2 \"\" OpName %3 \"_\"", 3, "__1"}, // Test uniqueness of names that are forced to be // numbers. {"OpName %1 \"2\" OpName %2 \"2\"", 1, "2"}, {"OpName %1 \"2\" OpName %2 \"2\"", 2, "2_0"}, // Test uniqueness in the face of forward references // for Ids that don't already have friendly names. // In particular, the first OpDecorate assigns the name, and // the second one can't override it. {"OpDecorate %1 Volatile OpDecorate %1 Restrict", 1, "1"}, // But a forced name can override the name that // would have been assigned via the OpDecorate // forward reference. {"OpName %1 \"mememe\" OpDecorate %1 Volatile OpDecorate %1 Restrict", 1, "mememe"}, // OpName can override other inferences. We assume valid instruction // ordering, where OpName precedes type definitions. {"OpName %1 \"myfloat\" %1 = OpTypeFloat 32", 1, "myfloat"}, })); INSTANTIATE_TEST_SUITE_P( UniquenessHeuristic, FriendlyNameTest, ::testing::ValuesIn(std::vector{ {"%1 = OpTypeVoid %2 = OpTypeVoid %3 = OpTypeVoid", 1, "void"}, {"%1 = OpTypeVoid %2 = OpTypeVoid %3 = OpTypeVoid", 2, "void_0"}, {"%1 = OpTypeVoid %2 = OpTypeVoid %3 = OpTypeVoid", 3, "void_1"}, })); INSTANTIATE_TEST_SUITE_P(Arrays, FriendlyNameTest, ::testing::ValuesIn(std::vector{ {"OpName %2 \"FortyTwo\" %1 = OpTypeFloat 32 " "%2 = OpConstant %1 42 %3 = OpTypeArray %1 %2", 3, "_arr_float_FortyTwo"}, {"%1 = OpTypeInt 32 0 " "%2 = OpTypeRuntimeArray %1", 2, "_runtimearr_uint"}, })); INSTANTIATE_TEST_SUITE_P(Structs, FriendlyNameTest, ::testing::ValuesIn(std::vector{ {"%1 = OpTypeBool " "%2 = OpTypeStruct %1 %1 %1", 2, "_struct_2"}, {"%1 = OpTypeBool " "%2 = OpTypeStruct %1 %1 %1 " "%3 = OpTypeStruct %2 %2", 3, "_struct_3"}, })); INSTANTIATE_TEST_SUITE_P( Pointer, FriendlyNameTest, ::testing::ValuesIn(std::vector{ {"%1 = OpTypeFloat 32 %2 = OpTypePointer Workgroup %1", 2, "_ptr_Workgroup_float"}, {"%1 = OpTypeBool %2 = OpTypePointer Private %1", 2, "_ptr_Private_bool"}, // OpTypeForwardPointer doesn't force generation of the name for its // target type. {"%1 = OpTypeBool OpTypeForwardPointer %2 Private %2 = OpTypePointer " "Private %1", 2, "_ptr_Private_bool"}, })); INSTANTIATE_TEST_SUITE_P(ExoticTypes, FriendlyNameTest, ::testing::ValuesIn(std::vector{ {"%1 = OpTypeEvent", 1, "Event"}, {"%1 = OpTypeDeviceEvent", 1, "DeviceEvent"}, {"%1 = OpTypeReserveId", 1, "ReserveId"}, {"%1 = OpTypeQueue", 1, "Queue"}, {"%1 = OpTypeOpaque \"hello world!\"", 1, "Opaque_hello_world_"}, {"%1 = OpTypePipe ReadOnly", 1, "PipeReadOnly"}, {"%1 = OpTypePipe WriteOnly", 1, "PipeWriteOnly"}, {"%1 = OpTypePipe ReadWrite", 1, "PipeReadWrite"}, {"%1 = OpTypePipeStorage", 1, "PipeStorage"}, {"%1 = OpTypeNamedBarrier", 1, "NamedBarrier"}, })); // Makes a test case for a BuiltIn variable declaration. NameIdCase BuiltInCase(std::string assembly_name, std::string expected) { return NameIdCase{std::string("OpDecorate %1 BuiltIn ") + assembly_name + " %1 = OpVariable %2 Input", 1, expected}; } // Makes a test case for a BuiltIn variable declaration. In this overload, // the expected result is the same as the assembly name. NameIdCase BuiltInCase(std::string assembly_name) { return BuiltInCase(assembly_name, assembly_name); } // Makes a test case for a BuiltIn variable declaration. In this overload, // the expected result is the same as the assembly name, but with a "gl_" // prefix. NameIdCase BuiltInGLCase(std::string assembly_name) { return BuiltInCase(assembly_name, std::string("gl_") + assembly_name); } INSTANTIATE_TEST_SUITE_P( BuiltIns, FriendlyNameTest, ::testing::ValuesIn(std::vector{ BuiltInGLCase("Position"), BuiltInGLCase("PointSize"), BuiltInGLCase("ClipDistance"), BuiltInGLCase("CullDistance"), BuiltInCase("VertexId", "gl_VertexID"), BuiltInCase("InstanceId", "gl_InstanceID"), BuiltInCase("PrimitiveId", "gl_PrimitiveID"), BuiltInCase("InvocationId", "gl_InvocationID"), BuiltInGLCase("Layer"), BuiltInGLCase("ViewportIndex"), BuiltInGLCase("TessLevelOuter"), BuiltInGLCase("TessLevelInner"), BuiltInGLCase("TessCoord"), BuiltInGLCase("PatchVertices"), BuiltInGLCase("FragCoord"), BuiltInGLCase("PointCoord"), BuiltInGLCase("FrontFacing"), BuiltInCase("SampleId", "gl_SampleID"), BuiltInGLCase("SamplePosition"), BuiltInGLCase("SampleMask"), BuiltInGLCase("FragDepth"), BuiltInGLCase("HelperInvocation"), BuiltInCase("NumWorkgroups", "gl_NumWorkGroups"), BuiltInCase("WorkgroupSize", "gl_WorkGroupSize"), BuiltInCase("WorkgroupId", "gl_WorkGroupID"), BuiltInCase("LocalInvocationId", "gl_LocalInvocationID"), BuiltInCase("GlobalInvocationId", "gl_GlobalInvocationID"), BuiltInGLCase("LocalInvocationIndex"), BuiltInCase("WorkDim"), BuiltInCase("GlobalSize"), BuiltInCase("EnqueuedWorkgroupSize"), BuiltInCase("GlobalOffset"), BuiltInCase("GlobalLinearId"), BuiltInCase("SubgroupSize"), BuiltInCase("SubgroupMaxSize"), BuiltInCase("NumSubgroups"), BuiltInCase("NumEnqueuedSubgroups"), BuiltInCase("SubgroupId"), BuiltInCase("SubgroupLocalInvocationId"), BuiltInGLCase("VertexIndex"), BuiltInGLCase("InstanceIndex"), BuiltInGLCase("BaseInstance"), BuiltInCase("SubgroupEqMaskKHR"), BuiltInCase("SubgroupGeMaskKHR"), BuiltInCase("SubgroupGtMaskKHR"), BuiltInCase("SubgroupLeMaskKHR"), BuiltInCase("SubgroupLtMaskKHR"), })); INSTANTIATE_TEST_SUITE_P(DebugNameOverridesBuiltin, FriendlyNameTest, ::testing::ValuesIn(std::vector{ {"OpName %1 \"foo\" OpDecorate %1 BuiltIn WorkDim " "%1 = OpVariable %2 Input", 1, "foo"}})); INSTANTIATE_TEST_SUITE_P( SimpleIntegralConstants, FriendlyNameTest, ::testing::ValuesIn(std::vector{ {"%1 = OpTypeInt 32 0 %2 = OpConstant %1 0", 2, "uint_0"}, {"%1 = OpTypeInt 32 0 %2 = OpConstant %1 1", 2, "uint_1"}, {"%1 = OpTypeInt 32 0 %2 = OpConstant %1 2", 2, "uint_2"}, {"%1 = OpTypeInt 32 0 %2 = OpConstant %1 9", 2, "uint_9"}, {"%1 = OpTypeInt 32 0 %2 = OpConstant %1 42", 2, "uint_42"}, {"%1 = OpTypeInt 32 1 %2 = OpConstant %1 0", 2, "int_0"}, {"%1 = OpTypeInt 32 1 %2 = OpConstant %1 1", 2, "int_1"}, {"%1 = OpTypeInt 32 1 %2 = OpConstant %1 2", 2, "int_2"}, {"%1 = OpTypeInt 32 1 %2 = OpConstant %1 9", 2, "int_9"}, {"%1 = OpTypeInt 32 1 %2 = OpConstant %1 42", 2, "int_42"}, {"%1 = OpTypeInt 32 1 %2 = OpConstant %1 -42", 2, "int_n42"}, // Exotic bit widths {"%1 = OpTypeInt 33 0 %2 = OpConstant %1 0", 2, "u33_0"}, {"%1 = OpTypeInt 33 1 %2 = OpConstant %1 10", 2, "i33_10"}, {"%1 = OpTypeInt 33 1 %2 = OpConstant %1 -19", 2, "i33_n19"}, })); INSTANTIATE_TEST_SUITE_P( SimpleFloatConstants, FriendlyNameTest, ::testing::ValuesIn(std::vector{ {"%1 = OpTypeFloat 16\n%2 = OpConstant %1 0x1.ff4p+16", 2, "half_0x1_ff4p_16"}, {"%1 = OpTypeFloat 16\n%2 = OpConstant %1 -0x1.d2cp-10", 2, "half_n0x1_d2cpn10"}, // 32-bit floats {"%1 = OpTypeFloat 32\n%2 = OpConstant %1 -3.125", 2, "float_n3_125"}, {"%1 = OpTypeFloat 32\n%2 = OpConstant %1 0x1.8p+128", 2, "float_0x1_8p_128"}, // NaN {"%1 = OpTypeFloat 32\n%2 = OpConstant %1 -0x1.0002p+128", 2, "float_n0x1_0002p_128"}, // NaN {"%1 = OpTypeFloat 32\n%2 = OpConstant %1 0x1p+128", 2, "float_0x1p_128"}, // Inf {"%1 = OpTypeFloat 32\n%2 = OpConstant %1 -0x1p+128", 2, "float_n0x1p_128"}, // -Inf // 64-bit floats {"%1 = OpTypeFloat 64\n%2 = OpConstant %1 -3.125", 2, "double_n3_125"}, {"%1 = OpTypeFloat 64\n%2 = OpConstant %1 0x1.ffffffffffffap-1023", 2, "double_0x1_ffffffffffffapn1023"}, // small normal {"%1 = OpTypeFloat 64\n%2 = OpConstant %1 -0x1.ffffffffffffap-1023", 2, "double_n0x1_ffffffffffffapn1023"}, {"%1 = OpTypeFloat 64\n%2 = OpConstant %1 0x1.8p+1024", 2, "double_0x1_8p_1024"}, // NaN {"%1 = OpTypeFloat 64\n%2 = OpConstant %1 -0x1.0002p+1024", 2, "double_n0x1_0002p_1024"}, // NaN {"%1 = OpTypeFloat 64\n%2 = OpConstant %1 0x1p+1024", 2, "double_0x1p_1024"}, // Inf {"%1 = OpTypeFloat 64\n%2 = OpConstant %1 -0x1p+1024", 2, "double_n0x1p_1024"}, // -Inf })); INSTANTIATE_TEST_SUITE_P( BooleanConstants, FriendlyNameTest, ::testing::ValuesIn(std::vector{ {"%1 = OpTypeBool\n%2 = OpConstantTrue %1", 2, "true"}, {"%1 = OpTypeBool\n%2 = OpConstantFalse %1", 2, "false"}, })); } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/named_id_test.cpp000066400000000000000000000052401475742701700230140ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "test/test_fixture.h" #include "test/unit_spirv.h" namespace spvtools { namespace { using NamedIdTest = spvtest::TextToBinaryTest; TEST_F(NamedIdTest, Default) { const std::string input = R"( OpCapability Shader OpMemoryModel Logical Simple OpEntryPoint Vertex %main "foo" %void = OpTypeVoid %fnMain = OpTypeFunction %void %main = OpFunction %void None %fnMain %lbMain = OpLabel OpReturn OpFunctionEnd)"; const std::string output = "OpCapability Shader\n" "OpMemoryModel Logical Simple\n" "OpEntryPoint Vertex %1 \"foo\"\n" "%2 = OpTypeVoid\n" "%3 = OpTypeFunction %2\n" "%1 = OpFunction %2 None %3\n" "%4 = OpLabel\n" "OpReturn\n" "OpFunctionEnd\n"; EXPECT_EQ(output, EncodeAndDecodeSuccessfully(input)); } struct IdCheckCase { std::string id; bool valid; }; using IdValidityTest = spvtest::TextToBinaryTestBase<::testing::TestWithParam>; TEST_P(IdValidityTest, IdTypes) { const std::string input = GetParam().id + " = OpTypeVoid"; SetText(input); if (GetParam().valid) { CompileSuccessfully(input); } else { CompileFailure(input); } } INSTANTIATE_TEST_SUITE_P( ValidAndInvalidIds, IdValidityTest, ::testing::ValuesIn(std::vector( {{"%1", true}, {"%2abc", true}, {"%3Def", true}, {"%4GHI", true}, {"%5_j_k", true}, {"%6J_M", true}, {"%n", true}, {"%O", true}, {"%p7", true}, {"%Q8", true}, {"%R_S", true}, {"%T_10_U", true}, {"%V_11", true}, {"%W_X_13", true}, {"%_A", true}, {"%_", true}, {"%__", true}, {"%A_", true}, {"%_A_", true}, {"%@", false}, {"%!", false}, {"%ABC!", false}, {"%__A__@", false}, {"%%", false}, {"%-", false}, {"%foo_@_bar", false}, {"%", false}, {"5", false}, {"32", false}, {"foo", false}, {"a%bar", false}}))); } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opcode_make_test.cpp000066400000000000000000000031261475742701700235230ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "test/unit_spirv.h" namespace spvtools { namespace { // A sampling of word counts. Covers extreme points well, and all bit // positions, and some combinations of bit positions. const uint16_t kSampleWordCounts[] = { 0, 1, 2, 3, 4, 8, 16, 32, 64, 127, 128, 256, 511, 512, 1024, 2048, 4096, 8192, 16384, 32768, 0xfffe, 0xffff}; // A sampling of opcode values. Covers the lower values well, a few samples // around the number of core instructions (as of this writing), and some // higher values. const uint16_t kSampleOpcodes[] = {0, 1, 2, 3, 4, 100, 300, 305, 1023, 0xfffe, 0xffff}; TEST(OpcodeMake, Samples) { for (auto wordCount : kSampleWordCounts) { for (auto opcode : kSampleOpcodes) { uint32_t word = 0; word |= uint32_t(opcode); word |= uint32_t(wordCount) << 16; EXPECT_EQ(word, spvOpcodeMake(wordCount, spv::Op(opcode))); } } } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opcode_require_capabilities_test.cpp000066400000000000000000000113601475742701700267720ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "test/unit_spirv.h" #include "source/enum_set.h" namespace spvtools { namespace { using spvtest::ElementsIn; // Capabilities required by an Opcode. struct ExpectedOpCodeCapabilities { spv::Op opcode; CapabilitySet capabilities; }; using OpcodeTableCapabilitiesTest = ::testing::TestWithParam; TEST_P(OpcodeTableCapabilitiesTest, TableEntryMatchesExpectedCapabilities) { auto env = SPV_ENV_UNIVERSAL_1_1; spv_opcode_table opcodeTable; ASSERT_EQ(SPV_SUCCESS, spvOpcodeTableGet(&opcodeTable, env)); spv_opcode_desc entry; ASSERT_EQ(SPV_SUCCESS, spvOpcodeTableValueLookup(env, opcodeTable, GetParam().opcode, &entry)); EXPECT_EQ( ElementsIn(GetParam().capabilities), ElementsIn(CapabilitySet(entry->numCapabilities, entry->capabilities))); } INSTANTIATE_TEST_SUITE_P( TableRowTest, OpcodeTableCapabilitiesTest, // Spot-check a few opcodes. ::testing::Values( ExpectedOpCodeCapabilities{spv::Op::OpImageQuerySize, CapabilitySet{spv::Capability::Kernel, spv::Capability::ImageQuery}}, ExpectedOpCodeCapabilities{spv::Op::OpImageQuerySizeLod, CapabilitySet{spv::Capability::Kernel, spv::Capability::ImageQuery}}, ExpectedOpCodeCapabilities{spv::Op::OpImageQueryLevels, CapabilitySet{spv::Capability::Kernel, spv::Capability::ImageQuery}}, ExpectedOpCodeCapabilities{spv::Op::OpImageQuerySamples, CapabilitySet{spv::Capability::Kernel, spv::Capability::ImageQuery}}, ExpectedOpCodeCapabilities{ spv::Op::OpImageSparseSampleImplicitLod, CapabilitySet{spv::Capability::SparseResidency}}, ExpectedOpCodeCapabilities{ spv::Op::OpCopyMemorySized, CapabilitySet{spv::Capability::Addresses, spv::Capability::UntypedPointersKHR}}, ExpectedOpCodeCapabilities{spv::Op::OpArrayLength, CapabilitySet{spv::Capability::Shader}}, ExpectedOpCodeCapabilities{spv::Op::OpFunction, CapabilitySet()}, ExpectedOpCodeCapabilities{spv::Op::OpConvertFToS, CapabilitySet()}, ExpectedOpCodeCapabilities{ spv::Op::OpEmitStreamVertex, CapabilitySet{spv::Capability::GeometryStreams}}, ExpectedOpCodeCapabilities{ spv::Op::OpTypeNamedBarrier, CapabilitySet{spv::Capability::NamedBarrier}}, ExpectedOpCodeCapabilities{ spv::Op::OpGetKernelMaxNumSubgroups, CapabilitySet{spv::Capability::SubgroupDispatch}}, ExpectedOpCodeCapabilities{spv::Op::OpImageQuerySamples, CapabilitySet{spv::Capability::Kernel, spv::Capability::ImageQuery}}, ExpectedOpCodeCapabilities{ spv::Op::OpImageSparseSampleImplicitLod, CapabilitySet{spv::Capability::SparseResidency}}, ExpectedOpCodeCapabilities{ spv::Op::OpCopyMemorySized, CapabilitySet{spv::Capability::Addresses, spv::Capability::UntypedPointersKHR}}, ExpectedOpCodeCapabilities{spv::Op::OpArrayLength, CapabilitySet{spv::Capability::Shader}}, ExpectedOpCodeCapabilities{spv::Op::OpFunction, CapabilitySet()}, ExpectedOpCodeCapabilities{spv::Op::OpConvertFToS, CapabilitySet()}, ExpectedOpCodeCapabilities{ spv::Op::OpEmitStreamVertex, CapabilitySet{spv::Capability::GeometryStreams}}, ExpectedOpCodeCapabilities{ spv::Op::OpTypeNamedBarrier, CapabilitySet{spv::Capability::NamedBarrier}}, ExpectedOpCodeCapabilities{ spv::Op::OpGetKernelMaxNumSubgroups, CapabilitySet{spv::Capability::SubgroupDispatch}})); } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opcode_split_test.cpp000066400000000000000000000016531475742701700237440ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "test/unit_spirv.h" namespace spvtools { namespace { TEST(OpcodeSplit, Default) { uint32_t word = spvOpcodeMake(42, (spv::Op)23); uint16_t wordCount = 0; uint16_t opcode; spvOpcodeSplit(word, &wordCount, &opcode); ASSERT_EQ(42, wordCount); ASSERT_EQ(23, opcode); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opcode_table_get_test.cpp000066400000000000000000000025011475742701700245300ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "gmock/gmock.h" #include "test/unit_spirv.h" namespace spvtools { namespace { using GetTargetOpcodeTableGetTest = ::testing::TestWithParam; using ::testing::ValuesIn; TEST_P(GetTargetOpcodeTableGetTest, IntegrityCheck) { spv_opcode_table table; ASSERT_EQ(SPV_SUCCESS, spvOpcodeTableGet(&table, GetParam())); ASSERT_NE(0u, table->count); ASSERT_NE(nullptr, table->entries); } TEST_P(GetTargetOpcodeTableGetTest, InvalidPointerTable) { ASSERT_EQ(SPV_ERROR_INVALID_POINTER, spvOpcodeTableGet(nullptr, GetParam())); } INSTANTIATE_TEST_SUITE_P(OpcodeTableGet, GetTargetOpcodeTableGetTest, ValuesIn(spvtest::AllTargetEnvironments())); } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/operand-class-test-coverage.csv000066400000000000000000000076311475742701700255350ustar00rootroot00000000000000Operand class,Example instruction,Notes,example unit test,negative-enum coverage location " OperandNone,",UNUSED,not in grammar,,not enum " OperandId,",many,ID,too many to count,not enum " OperandOptionalId,","Source, Variable",OPTIONAL_ID,OpSourceAcceptsOptionalFileId,not enum " OperandOptionalImage,",ImageFetch,,ImageOperandsTest,"TEST_F(ImageOperandsTest, WrongOperand)" " OperandVariableIds,",ExtInst,,,not enum " OperandOptionalLiteral,",ExecutionMode,,AnyExecutionMode,not enum " OperandOptionalLiteralString,",Source,,OpSourceAcceptsOptionalSourceText,not enum " OperandVariableLiterals,",Decorate,,OpDecorateSimpleTest,not enum " OperandVariableIdLiteral,",GroupMemberDecorate,,GroupMemberDecorate*,not enum " OperandVariableLiteralId,",Switch,,Switch*,not enum " OperandLiteralNumber,","Source, Switch, ...",,Switch*,not enum " OperandLiteralString,",SourceContinued,,OpSourceContinued,not enum " OperandSource,",Source,,OpSource,not enum " OperandExecutionModel,",EntryPoint,,OpEntryPointTest,"TEST_F(OpEntryPointTest, WrongModel)" " OperandAddressing,",OpMemoryModel,,OpMemoryModelTest,"TEST_F(OpMemoryModelTest, WrongModel)" " OperandMemory,",OpMemoryModel,,OpMemoryModelTest,"TEST_F(OpMemoryModelTest, WrongModel)" " OperandExecutionMode,",OpExecutionMode,,OpExecutionModeTest,"TEST_F(OpExecutionModeTest, WrongMode)" " OperandStorage,","TypePointer, TypeForwardPointer, Variable",,StorageClassTest,"TEST_F(OpTypeForwardPointerTest, WrongClass)" " OperandDimensionality,",TypeImage,,DimTest/AnyDim,"TEST_F(DimTest, WrongDim)" " OperandSamplerAddressingMode,",ConstantSampler,,SamplerAddressingModeTest,"TEST_F(SamplerAddressingModeTest, WrongMode)" " OperandSamplerFilterMode,",ConstantSampler,,AnySamplerFilterMode,"TEST_F(SamplerFilterModeTest, WrongMode)" " OperandSamplerImageFormat,",TypeImage,SAMPLER_IMAGE_FORMAT,ImageFormatTest,"TEST_F(ImageFormatTest, WrongFormat)" " OperandImageChannelOrder,",UNUSED,returned as result value only,, " OperandImageChannelDataType,",UNUSED,returned as result value only,, " OperandImageOperands,",UNUSED,used to make a spec section,,see OperandOptionalImage " OperandFPFastMath,",OpDecorate,,CombinedFPFastMathMask,"TEST_F(OpDecorateEnumTest, WrongFPFastMathMode)" " OperandFPRoundingMode,",OpDecorate,,,"TEST_F(OpDecorateEnumTest, WrongFPRoundingMode)" " OperandLinkageType,",OpDecorate,,OpDecorateLinkageTest,"TEST_F(OpDecorateLinkageTest, WrongType)" " OperandAccessQualifier,",OpTypePipe,,AnyAccessQualifier,"TEST_F(OpTypePipeTest, WrongAccessQualifier)" " OperandFuncParamAttr,",OpDecorate,,TextToBinaryDecorateFuncParamAttr,"TEST_F(OpDecorateEnumTest, WrongFuncParamAttr)" " OperandDecoration,",OpDecorate,,AnyAccessQualifier,"TEST_F(OpTypePipeTest, WrongAccessQualifier)" " OperandBuiltIn,",OpDecorate,,TextToBinaryDecorateBultIn,"TEST_F(OpDecorateEnumTest, WrongBuiltIn)" " OperandSelect,",SelectionMerge,,TextToBinarySelectionMerge,"TEST_F(OpSelectionMergeTest, WrongSelectionControl)" " OperandLoop,",LoopMerge,,CombinedLoopControlMask,"TEST_F(OpLoopMergeTest, WrongLoopControl)" " OperandFunction,",Function,,AnySingleFunctionControlMask,"TEST_F(OpFunctionControlTest, WrongFunctionControl)" " OperandMemorySemantics,",OpMemoryBarrier,"it's an ID, not in grammar",OpMemoryBarrier*,not enum " OperandMemoryAccess,",UNUSED,"should be on opstore, but hacked in opcode.cpp",,not enum " OperandScope,",MemoryBarrier,"it's an ID, not in grammar",OpMemoryBarrier*,not enum " OperandGroupOperation,",GroupIAdd,,GroupOperationTest,"TEST_F(GroupOperationTest, WrongGroupOperation)" " OperandKernelEnqueueFlags,",OpEnqueueKernel,"it's an ID, not in grammar",should not have one,not enum " OperandKernelProfilingInfo,",OpCaptureEventProfilingInfo,"it's an ID, not in grammar",should not have one,not enum " OperandCapability,",Capability,,OpCapabilityTest,"TEST_F(TextToBinaryCapability, BadInvalidCapability)" KhronosGroup-SPIRV-Tools-f289d04/test/operand_capabilities_test.cpp000066400000000000000000001223261475742701700254220ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Test capability dependencies for enums. #include #include #include "gmock/gmock.h" #include "source/assembly_grammar.h" #include "source/enum_set.h" #include "source/operand.h" #include "source/spirv_target_env.h" #include "source/table.h" #include "spirv-tools/libspirv.h" #include "test/unit_spirv.h" namespace spvtools { namespace { using spvtest::ElementsIn; using ::testing::Combine; using ::testing::Eq; using ::testing::TestWithParam; using ::testing::Values; using ::testing::ValuesIn; // Emits a CapabilitySet to the given ostream, returning the ostream. inline std::ostream& operator<<(std::ostream& out, const CapabilitySet& cs) { out << "CapabilitySet{"; auto ctx = spvContextCreate(SPV_ENV_UNIVERSAL_1_0); spvtools::AssemblyGrammar grammar(ctx); bool first = true; for (auto c : cs) { if (!first) { out << " "; first = false; } out << grammar.lookupOperandName(SPV_OPERAND_TYPE_CAPABILITY, uint32_t(c)) << "(" << uint32_t(c) << ")"; } spvContextDestroy(ctx); out << "}"; return out; } // A test case for mapping an enum to a capability mask. struct EnumCapabilityCase { spv_operand_type_t type; uint32_t value; CapabilitySet expected_capabilities; }; // Emits an EnumCapabilityCase to the given output stream. This is used // to emit failure cases when they occur, which helps debug tests. inline std::ostream& operator<<(std::ostream& out, EnumCapabilityCase e) { out << "{" << spvOperandTypeStr(e.type) << " " << e.value << " " << e.expected_capabilities << " }"; return out; } using EnvEnumCapabilityCase = std::tuple; // Test fixture for testing EnumCapabilityCases. using EnumCapabilityTest = TestWithParam>; TEST_P(EnumCapabilityTest, Sample) { const auto env = std::get<0>(GetParam()); const auto context = spvContextCreate(env); const AssemblyGrammar grammar(context); spv_operand_desc entry; ASSERT_EQ(SPV_SUCCESS, grammar.lookupOperand(std::get<1>(GetParam()).type, std::get<1>(GetParam()).value, &entry)); const auto cap_set = grammar.filterCapsAgainstTargetEnv( entry->capabilities, entry->numCapabilities); EXPECT_THAT(ElementsIn(cap_set), Eq(ElementsIn(std::get<1>(GetParam()).expected_capabilities))) << " enum value " << std::get<1>(GetParam()).value; spvContextDestroy(context); } #define CASE0(TYPE, VALUE) \ { \ SPV_OPERAND_TYPE_##TYPE, uint32_t(spv::VALUE), {} \ } #define CASE1(TYPE, VALUE, CAP) \ { \ SPV_OPERAND_TYPE_##TYPE, uint32_t(spv::VALUE), CapabilitySet { \ spv::Capability::CAP \ } \ } #define CASE2(TYPE, VALUE, CAP1, CAP2) \ { \ SPV_OPERAND_TYPE_##TYPE, uint32_t(spv::VALUE), CapabilitySet { \ spv::Capability::CAP1, spv::Capability::CAP2 \ } \ } #define CASE3(TYPE, VALUE, CAP1, CAP2, CAP3) \ { \ SPV_OPERAND_TYPE_##TYPE, uint32_t(spv::VALUE), CapabilitySet { \ spv::Capability::CAP1, spv::Capability::CAP2, spv::Capability::CAP3 \ } \ } #define CASE4(TYPE, VALUE, CAP1, CAP2, CAP3, CAP4) \ { \ SPV_OPERAND_TYPE_##TYPE, uint32_t(spv::VALUE), CapabilitySet { \ spv::Capability::CAP1, spv::Capability::CAP2, spv::Capability::CAP3, \ spv::Capability::CAP4 \ } \ } #define CASE5(TYPE, VALUE, CAP1, CAP2, CAP3, CAP4, CAP5) \ { \ SPV_OPERAND_TYPE_##TYPE, uint32_t(spv::VALUE), CapabilitySet { \ spv::Capability::CAP1, spv::Capability::CAP2, spv::Capability::CAP3, \ spv::Capability::CAP4, spv::Capability::CAP5 \ } \ } #define CASE6(TYPE, VALUE, CAP1, CAP2, CAP3, CAP4, CAP5, CAP6) \ { \ SPV_OPERAND_TYPE_##TYPE, uint32_t(spv::VALUE), CapabilitySet { \ spv::Capability::CAP1, spv::Capability::CAP2, spv::Capability::CAP3, \ spv::Capability::CAP4, spv::Capability::CAP5, spv::Capability::CAP6 \ } \ } // See SPIR-V Section 3.3 Execution Model INSTANTIATE_TEST_SUITE_P( ExecutionModel, EnumCapabilityTest, Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), ValuesIn(std::vector{ CASE1(EXECUTION_MODEL, ExecutionModel::Vertex, Shader), CASE1(EXECUTION_MODEL, ExecutionModel::TessellationControl, Tessellation), CASE1(EXECUTION_MODEL, ExecutionModel::TessellationEvaluation, Tessellation), CASE1(EXECUTION_MODEL, ExecutionModel::Geometry, Geometry), CASE1(EXECUTION_MODEL, ExecutionModel::Fragment, Shader), CASE1(EXECUTION_MODEL, ExecutionModel::GLCompute, Shader), CASE1(EXECUTION_MODEL, ExecutionModel::Kernel, Kernel), }))); // See SPIR-V Section 3.4 Addressing Model INSTANTIATE_TEST_SUITE_P( AddressingModel, EnumCapabilityTest, Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), ValuesIn(std::vector{ CASE0(ADDRESSING_MODEL, AddressingModel::Logical), CASE1(ADDRESSING_MODEL, AddressingModel::Physical32, Addresses), CASE1(ADDRESSING_MODEL, AddressingModel::Physical64, Addresses), }))); // See SPIR-V Section 3.5 Memory Model INSTANTIATE_TEST_SUITE_P( MemoryModel, EnumCapabilityTest, Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), ValuesIn(std::vector{ CASE1(MEMORY_MODEL, MemoryModel::Simple, Shader), CASE1(MEMORY_MODEL, MemoryModel::GLSL450, Shader), CASE1(MEMORY_MODEL, MemoryModel::OpenCL, Kernel), }))); // See SPIR-V Section 3.6 Execution Mode INSTANTIATE_TEST_SUITE_P( ExecutionMode, EnumCapabilityTest, Combine( Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), ValuesIn(std::vector{ CASE1(EXECUTION_MODE, ExecutionMode::Invocations, Geometry), CASE1(EXECUTION_MODE, ExecutionMode::SpacingEqual, Tessellation), CASE1(EXECUTION_MODE, ExecutionMode::SpacingFractionalEven, Tessellation), CASE1(EXECUTION_MODE, ExecutionMode::SpacingFractionalOdd, Tessellation), CASE1(EXECUTION_MODE, ExecutionMode::VertexOrderCw, Tessellation), CASE1(EXECUTION_MODE, ExecutionMode::VertexOrderCcw, Tessellation), CASE1(EXECUTION_MODE, ExecutionMode::PixelCenterInteger, Shader), CASE1(EXECUTION_MODE, ExecutionMode::OriginUpperLeft, Shader), CASE1(EXECUTION_MODE, ExecutionMode::OriginLowerLeft, Shader), CASE1(EXECUTION_MODE, ExecutionMode::EarlyFragmentTests, Shader), CASE1(EXECUTION_MODE, ExecutionMode::PointMode, Tessellation), CASE1(EXECUTION_MODE, ExecutionMode::Xfb, TransformFeedback), CASE1(EXECUTION_MODE, ExecutionMode::DepthReplacing, Shader), CASE1(EXECUTION_MODE, ExecutionMode::DepthGreater, Shader), CASE1(EXECUTION_MODE, ExecutionMode::DepthLess, Shader), CASE1(EXECUTION_MODE, ExecutionMode::DepthUnchanged, Shader), CASE0(EXECUTION_MODE, ExecutionMode::LocalSize), CASE1(EXECUTION_MODE, ExecutionMode::LocalSizeHint, Kernel), CASE1(EXECUTION_MODE, ExecutionMode::InputPoints, Geometry), CASE1(EXECUTION_MODE, ExecutionMode::InputLines, Geometry), CASE1(EXECUTION_MODE, ExecutionMode::InputLinesAdjacency, Geometry), CASE2(EXECUTION_MODE, ExecutionMode::Triangles, Geometry, Tessellation), CASE1(EXECUTION_MODE, ExecutionMode::InputTrianglesAdjacency, Geometry), CASE1(EXECUTION_MODE, ExecutionMode::Quads, Tessellation), CASE1(EXECUTION_MODE, ExecutionMode::Isolines, Tessellation), CASE4(EXECUTION_MODE, ExecutionMode::OutputVertices, Geometry, Tessellation, MeshShadingNV, MeshShadingEXT), CASE3(EXECUTION_MODE, ExecutionMode::OutputPoints, Geometry, MeshShadingNV, MeshShadingEXT), CASE1(EXECUTION_MODE, ExecutionMode::OutputLineStrip, Geometry), CASE1(EXECUTION_MODE, ExecutionMode::OutputTriangleStrip, Geometry), CASE1(EXECUTION_MODE, ExecutionMode::VecTypeHint, Kernel), CASE1(EXECUTION_MODE, ExecutionMode::ContractionOff, Kernel), }))); INSTANTIATE_TEST_SUITE_P( ExecutionModeV11, EnumCapabilityTest, Combine(Values(SPV_ENV_UNIVERSAL_1_1), ValuesIn(std::vector{ CASE1(EXECUTION_MODE, ExecutionMode::Initializer, Kernel), CASE1(EXECUTION_MODE, ExecutionMode::Finalizer, Kernel), CASE1(EXECUTION_MODE, ExecutionMode::SubgroupSize, SubgroupDispatch), CASE1(EXECUTION_MODE, ExecutionMode::SubgroupsPerWorkgroup, SubgroupDispatch)}))); // See SPIR-V Section 3.7 Storage Class INSTANTIATE_TEST_SUITE_P( StorageClass, EnumCapabilityTest, Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), ValuesIn(std::vector{ CASE0(STORAGE_CLASS, StorageClass::UniformConstant), CASE1(STORAGE_CLASS, StorageClass::Uniform, Shader), CASE1(STORAGE_CLASS, StorageClass::Output, Shader), CASE0(STORAGE_CLASS, StorageClass::Workgroup), CASE0(STORAGE_CLASS, StorageClass::CrossWorkgroup), CASE2(STORAGE_CLASS, StorageClass::Private, Shader, VectorComputeINTEL), CASE0(STORAGE_CLASS, StorageClass::Function), CASE1(STORAGE_CLASS, StorageClass::Generic, GenericPointer), // Bug 14287 CASE1(STORAGE_CLASS, StorageClass::PushConstant, Shader), CASE1(STORAGE_CLASS, StorageClass::AtomicCounter, AtomicStorage), CASE0(STORAGE_CLASS, StorageClass::Image), }))); // See SPIR-V Section 3.8 Dim INSTANTIATE_TEST_SUITE_P( Dim, EnumCapabilityTest, Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), ValuesIn(std::vector{ CASE1(DIMENSIONALITY, Dim::Dim1D, Sampled1D), CASE0(DIMENSIONALITY, Dim::Dim2D), CASE0(DIMENSIONALITY, Dim::Dim3D), CASE1(DIMENSIONALITY, Dim::Cube, Shader), CASE1(DIMENSIONALITY, Dim::Rect, SampledRect), CASE1(DIMENSIONALITY, Dim::Buffer, SampledBuffer), CASE1(DIMENSIONALITY, Dim::SubpassData, InputAttachment), }))); // See SPIR-V Section 3.9 Sampler Addressing Mode INSTANTIATE_TEST_SUITE_P( SamplerAddressingMode, EnumCapabilityTest, Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), ValuesIn(std::vector{ CASE0(SAMPLER_ADDRESSING_MODE, SamplerAddressingMode::None), CASE0(SAMPLER_ADDRESSING_MODE, SamplerAddressingMode::ClampToEdge), CASE0(SAMPLER_ADDRESSING_MODE, SamplerAddressingMode::Clamp), CASE0(SAMPLER_ADDRESSING_MODE, SamplerAddressingMode::Repeat), CASE0(SAMPLER_ADDRESSING_MODE, SamplerAddressingMode::RepeatMirrored)}))); // See SPIR-V Section 3.10 Sampler Filter Mode INSTANTIATE_TEST_SUITE_P( SamplerFilterMode, EnumCapabilityTest, Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), ValuesIn(std::vector{ CASE0(SAMPLER_FILTER_MODE, SamplerFilterMode::Nearest), CASE0(SAMPLER_FILTER_MODE, SamplerFilterMode::Linear), }))); // See SPIR-V Section 3.11 Image Format INSTANTIATE_TEST_SUITE_P( ImageFormat, EnumCapabilityTest, Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), ValuesIn(std::vector{ // clang-format off CASE0(SAMPLER_IMAGE_FORMAT, ImageFormat::Unknown), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba32f, Shader), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba16f, Shader), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::R32f, Shader), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba8, Shader), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba8Snorm, Shader), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rg32f, StorageImageExtendedFormats), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rg16f, StorageImageExtendedFormats), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::R11fG11fB10f, StorageImageExtendedFormats), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::R16f, StorageImageExtendedFormats), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba16, StorageImageExtendedFormats), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgb10A2, StorageImageExtendedFormats), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rg16, StorageImageExtendedFormats), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rg8, StorageImageExtendedFormats), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::R16, StorageImageExtendedFormats), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::R8, StorageImageExtendedFormats), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba16Snorm, StorageImageExtendedFormats), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rg16Snorm, StorageImageExtendedFormats), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rg8Snorm, StorageImageExtendedFormats), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::R16Snorm, StorageImageExtendedFormats), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::R8Snorm, StorageImageExtendedFormats), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba32i, Shader), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba16i, Shader), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba8i, Shader), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::R32i, Shader), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rg32i, StorageImageExtendedFormats), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rg16i, StorageImageExtendedFormats), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rg8i, StorageImageExtendedFormats), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::R16i, StorageImageExtendedFormats), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::R8i, StorageImageExtendedFormats), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba32ui, Shader), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba16ui, Shader), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba8ui, Shader), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba8ui, Shader), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgb10a2ui, StorageImageExtendedFormats), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rg32ui, StorageImageExtendedFormats), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rg16ui, StorageImageExtendedFormats), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rg8ui, StorageImageExtendedFormats), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::R16ui, StorageImageExtendedFormats), CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::R8ui, StorageImageExtendedFormats), // clang-format on }))); // See SPIR-V Section 3.12 Image Channel Order INSTANTIATE_TEST_SUITE_P( ImageChannelOrder, EnumCapabilityTest, Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), ValuesIn(std::vector{ CASE0(IMAGE_CHANNEL_ORDER, ImageChannelOrder::R), CASE0(IMAGE_CHANNEL_ORDER, ImageChannelOrder::A), CASE0(IMAGE_CHANNEL_ORDER, ImageChannelOrder::RG), CASE0(IMAGE_CHANNEL_ORDER, ImageChannelOrder::RA), CASE0(IMAGE_CHANNEL_ORDER, ImageChannelOrder::RGB), CASE0(IMAGE_CHANNEL_ORDER, ImageChannelOrder::RGBA), CASE0(IMAGE_CHANNEL_ORDER, ImageChannelOrder::BGRA), CASE0(IMAGE_CHANNEL_ORDER, ImageChannelOrder::ARGB), CASE0(IMAGE_CHANNEL_ORDER, ImageChannelOrder::Intensity), CASE0(IMAGE_CHANNEL_ORDER, ImageChannelOrder::Luminance), CASE0(IMAGE_CHANNEL_ORDER, ImageChannelOrder::Rx), CASE0(IMAGE_CHANNEL_ORDER, ImageChannelOrder::RGx), CASE0(IMAGE_CHANNEL_ORDER, ImageChannelOrder::RGBx), CASE0(IMAGE_CHANNEL_ORDER, ImageChannelOrder::Depth), CASE0(IMAGE_CHANNEL_ORDER, ImageChannelOrder::DepthStencil), CASE0(IMAGE_CHANNEL_ORDER, ImageChannelOrder::sRGB), CASE0(IMAGE_CHANNEL_ORDER, ImageChannelOrder::sRGBx), CASE0(IMAGE_CHANNEL_ORDER, ImageChannelOrder::sRGBA), CASE0(IMAGE_CHANNEL_ORDER, ImageChannelOrder::sBGRA), CASE0(IMAGE_CHANNEL_ORDER, ImageChannelOrder::ABGR), }))); // See SPIR-V Section 3.13 Image Channel Data Type INSTANTIATE_TEST_SUITE_P( ImageChannelDataType, EnumCapabilityTest, Combine( Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), ValuesIn(std::vector{ // clang-format off CASE0(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::SnormInt8), CASE0(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::SnormInt16), CASE0(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::UnormInt8), CASE0(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::UnormInt16), CASE0(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::UnormShort565), CASE0(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::UnormShort555), CASE0(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::UnormInt101010), CASE0(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::SignedInt8), CASE0(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::SignedInt16), CASE0(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::SignedInt32), CASE0(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::UnsignedInt8), CASE0(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::UnsignedInt16), CASE0(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::UnsignedInt32), CASE0(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::HalfFloat), CASE0(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::Float), CASE0(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::UnormInt24), CASE0(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::UnormInt101010_2), // clang-format on }))); // See SPIR-V Section 3.14 Image Operands INSTANTIATE_TEST_SUITE_P( ImageOperands, EnumCapabilityTest, Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), ValuesIn(std::vector{ // clang-format off CASE0(OPTIONAL_IMAGE, ImageOperandsMask::MaskNone), CASE1(OPTIONAL_IMAGE, ImageOperandsMask::Bias, Shader), CASE0(OPTIONAL_IMAGE, ImageOperandsMask::Lod), CASE0(OPTIONAL_IMAGE, ImageOperandsMask::Grad), CASE0(OPTIONAL_IMAGE, ImageOperandsMask::ConstOffset), CASE1(OPTIONAL_IMAGE, ImageOperandsMask::Offset, ImageGatherExtended), CASE1(OPTIONAL_IMAGE, ImageOperandsMask::ConstOffsets, ImageGatherExtended), CASE0(OPTIONAL_IMAGE, ImageOperandsMask::Sample), CASE1(OPTIONAL_IMAGE, ImageOperandsMask::MinLod, MinLod), // clang-format on }))); // See SPIR-V Section 3.17 Linkage Type INSTANTIATE_TEST_SUITE_P( LinkageType, EnumCapabilityTest, Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), ValuesIn(std::vector{ CASE1(LINKAGE_TYPE, LinkageType::Export, Linkage), CASE1(LINKAGE_TYPE, LinkageType::Import, Linkage), }))); // See SPIR-V Section 3.18 Access Qualifier INSTANTIATE_TEST_SUITE_P( AccessQualifier, EnumCapabilityTest, Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), ValuesIn(std::vector{ CASE1(ACCESS_QUALIFIER, AccessQualifier::ReadOnly, Kernel), CASE1(ACCESS_QUALIFIER, AccessQualifier::WriteOnly, Kernel), CASE1(ACCESS_QUALIFIER, AccessQualifier::ReadWrite, Kernel), }))); // See SPIR-V Section 3.19 Function Parameter Attribute INSTANTIATE_TEST_SUITE_P( FunctionParameterAttribute, EnumCapabilityTest, Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), ValuesIn(std::vector{ // clang-format off CASE1(FUNCTION_PARAMETER_ATTRIBUTE, FunctionParameterAttribute::Zext, Kernel), CASE1(FUNCTION_PARAMETER_ATTRIBUTE, FunctionParameterAttribute::Sext, Kernel), CASE1(FUNCTION_PARAMETER_ATTRIBUTE, FunctionParameterAttribute::ByVal, Kernel), CASE1(FUNCTION_PARAMETER_ATTRIBUTE, FunctionParameterAttribute::Sret, Kernel), CASE1(FUNCTION_PARAMETER_ATTRIBUTE, FunctionParameterAttribute::NoAlias, Kernel), CASE1(FUNCTION_PARAMETER_ATTRIBUTE, FunctionParameterAttribute::NoCapture, Kernel), CASE1(FUNCTION_PARAMETER_ATTRIBUTE, FunctionParameterAttribute::NoWrite, Kernel), CASE1(FUNCTION_PARAMETER_ATTRIBUTE, FunctionParameterAttribute::NoReadWrite, Kernel), // clang-format on }))); // See SPIR-V Section 3.20 Decoration INSTANTIATE_TEST_SUITE_P( Decoration_1_1, EnumCapabilityTest, Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), ValuesIn(std::vector{ CASE1(DECORATION, Decoration::RelaxedPrecision, Shader), // DecorationSpecId handled below. CASE1(DECORATION, Decoration::Block, Shader), CASE1(DECORATION, Decoration::BufferBlock, Shader), CASE1(DECORATION, Decoration::RowMajor, Matrix), CASE1(DECORATION, Decoration::ColMajor, Matrix), CASE1(DECORATION, Decoration::ArrayStride, Shader), CASE1(DECORATION, Decoration::MatrixStride, Matrix), // Bug 15234 CASE1(DECORATION, Decoration::GLSLShared, Shader), CASE1(DECORATION, Decoration::GLSLPacked, Shader), CASE1(DECORATION, Decoration::CPacked, Kernel), CASE0(DECORATION, Decoration::BuiltIn), // Bug 15248 // Value 12 placeholder CASE1(DECORATION, Decoration::NoPerspective, Shader), CASE1(DECORATION, Decoration::Flat, Shader), CASE1(DECORATION, Decoration::Patch, Tessellation), CASE1(DECORATION, Decoration::Centroid, Shader), CASE1(DECORATION, Decoration::Sample, SampleRateShading), // Bug 15234 CASE1(DECORATION, Decoration::Invariant, Shader), CASE0(DECORATION, Decoration::Restrict), CASE0(DECORATION, Decoration::Aliased), CASE0(DECORATION, Decoration::Volatile), CASE1(DECORATION, Decoration::Constant, Kernel), CASE0(DECORATION, Decoration::Coherent), CASE0(DECORATION, Decoration::NonWritable), CASE0(DECORATION, Decoration::NonReadable), CASE1(DECORATION, Decoration::Uniform, Shader), // Value 27 is an intentional gap in the spec numbering. CASE1(DECORATION, Decoration::SaturatedConversion, Kernel), CASE1(DECORATION, Decoration::Stream, GeometryStreams), CASE1(DECORATION, Decoration::Location, Shader), CASE1(DECORATION, Decoration::Component, Shader), CASE1(DECORATION, Decoration::Index, Shader), CASE1(DECORATION, Decoration::Binding, Shader), CASE1(DECORATION, Decoration::DescriptorSet, Shader), CASE1(DECORATION, Decoration::Offset, Shader), // Bug 15268 CASE1(DECORATION, Decoration::XfbBuffer, TransformFeedback), CASE1(DECORATION, Decoration::XfbStride, TransformFeedback), CASE1(DECORATION, Decoration::FuncParamAttr, Kernel), CASE2(DECORATION, Decoration::FPFastMathMode, Kernel, FloatControls2), CASE1(DECORATION, Decoration::LinkageAttributes, Linkage), CASE1(DECORATION, Decoration::NoContraction, Shader), CASE1(DECORATION, Decoration::InputAttachmentIndex, InputAttachment), CASE1(DECORATION, Decoration::Alignment, Kernel), }))); // See SPIR-V Section 3.20 Decoration INSTANTIATE_TEST_SUITE_P(Decoration_1_6, EnumCapabilityTest, Combine(Values(SPV_ENV_UNIVERSAL_1_6), ValuesIn(std::vector{ CASE2(DECORATION, Decoration::Uniform, Shader, UniformDecoration)}))); #if 0 // SpecId has different requirements in v1.0 and v1.1: INSTANTIATE_TEST_SUITE_P(DecorationSpecIdV10, EnumCapabilityTest, Combine(Values(SPV_ENV_UNIVERSAL_1_0), ValuesIn(std::vector{CASE1( DECORATION, DecorationSpecId, Shader)}))); #endif INSTANTIATE_TEST_SUITE_P( DecorationV11, EnumCapabilityTest, Combine(Values(SPV_ENV_UNIVERSAL_1_1), ValuesIn(std::vector{ CASE2(DECORATION, Decoration::SpecId, Shader, Kernel), CASE1(DECORATION, Decoration::MaxByteOffset, Addresses)}))); // See SPIR-V Section 3.21 BuiltIn INSTANTIATE_TEST_SUITE_P( BuiltIn, EnumCapabilityTest, Combine( Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), ValuesIn(std::vector{ // clang-format off CASE1(BUILT_IN, BuiltIn::Position, Shader), CASE1(BUILT_IN, BuiltIn::PointSize, Shader), // 2 is an intentional gap in the spec numbering. CASE1(BUILT_IN, BuiltIn::ClipDistance, ClipDistance), // Bug 1407, 15234 CASE1(BUILT_IN, BuiltIn::CullDistance, CullDistance), // Bug 1407, 15234 CASE1(BUILT_IN, BuiltIn::VertexId, Shader), CASE1(BUILT_IN, BuiltIn::InstanceId, Shader), CASE6(BUILT_IN, BuiltIn::PrimitiveId, Geometry, Tessellation, RayTracingNV, RayTracingKHR, MeshShadingNV, MeshShadingEXT), CASE2(BUILT_IN, BuiltIn::InvocationId, Geometry, Tessellation), CASE4(BUILT_IN, BuiltIn::Layer, Geometry, ShaderViewportIndexLayerEXT, MeshShadingNV, MeshShadingEXT), CASE4(BUILT_IN, BuiltIn::ViewportIndex, MultiViewport, ShaderViewportIndexLayerEXT, MeshShadingNV, MeshShadingEXT), // Bug 15234 CASE1(BUILT_IN, BuiltIn::TessLevelOuter, Tessellation), CASE1(BUILT_IN, BuiltIn::TessLevelInner, Tessellation), CASE1(BUILT_IN, BuiltIn::TessCoord, Tessellation), CASE1(BUILT_IN, BuiltIn::PatchVertices, Tessellation), CASE1(BUILT_IN, BuiltIn::FragCoord, Shader), CASE1(BUILT_IN, BuiltIn::PointCoord, Shader), CASE1(BUILT_IN, BuiltIn::FrontFacing, Shader), CASE1(BUILT_IN, BuiltIn::SampleId, SampleRateShading), // Bug 15234 CASE1(BUILT_IN, BuiltIn::SamplePosition, SampleRateShading), // Bug 15234 CASE1(BUILT_IN, BuiltIn::SampleMask, Shader), // Bug 15234, Issue 182 // Value 21 intentionally missing CASE1(BUILT_IN, BuiltIn::FragDepth, Shader), CASE1(BUILT_IN, BuiltIn::HelperInvocation, Shader), CASE0(BUILT_IN, BuiltIn::NumWorkgroups), CASE0(BUILT_IN, BuiltIn::WorkgroupSize), CASE0(BUILT_IN, BuiltIn::WorkgroupId), CASE0(BUILT_IN, BuiltIn::LocalInvocationId), CASE0(BUILT_IN, BuiltIn::GlobalInvocationId), CASE0(BUILT_IN, BuiltIn::LocalInvocationIndex), CASE1(BUILT_IN, BuiltIn::WorkDim, Kernel), CASE1(BUILT_IN, BuiltIn::GlobalSize, Kernel), CASE1(BUILT_IN, BuiltIn::EnqueuedWorkgroupSize, Kernel), CASE1(BUILT_IN, BuiltIn::GlobalOffset, Kernel), CASE1(BUILT_IN, BuiltIn::GlobalLinearId, Kernel), // Value 35 intentionally missing CASE2(BUILT_IN, BuiltIn::SubgroupSize, Kernel, SubgroupBallotKHR), CASE1(BUILT_IN, BuiltIn::SubgroupMaxSize, Kernel), CASE1(BUILT_IN, BuiltIn::NumSubgroups, Kernel), CASE1(BUILT_IN, BuiltIn::NumEnqueuedSubgroups, Kernel), CASE1(BUILT_IN, BuiltIn::SubgroupId, Kernel), CASE2(BUILT_IN, BuiltIn::SubgroupLocalInvocationId, Kernel, SubgroupBallotKHR), CASE1(BUILT_IN, BuiltIn::VertexIndex, Shader), CASE1(BUILT_IN, BuiltIn::InstanceIndex, Shader), // clang-format on }))); INSTANTIATE_TEST_SUITE_P( BuiltInV1_5, EnumCapabilityTest, Combine( Values(SPV_ENV_UNIVERSAL_1_5), ValuesIn(std::vector{ // SPIR-V 1.5 adds new capabilities to enable these two builtins. CASE5(BUILT_IN, BuiltIn::Layer, Geometry, ShaderLayer, ShaderViewportIndexLayerEXT, MeshShadingNV, MeshShadingEXT), CASE5(BUILT_IN, BuiltIn::ViewportIndex, MultiViewport, ShaderViewportIndex, ShaderViewportIndexLayerEXT, MeshShadingNV, MeshShadingEXT), }))); // See SPIR-V Section 3.22 Selection Control INSTANTIATE_TEST_SUITE_P( SelectionControl, EnumCapabilityTest, Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), ValuesIn(std::vector{ CASE0(SELECTION_CONTROL, SelectionControlMask::MaskNone), CASE0(SELECTION_CONTROL, SelectionControlMask::Flatten), CASE0(SELECTION_CONTROL, SelectionControlMask::DontFlatten), }))); // See SPIR-V Section 3.23 Loop Control INSTANTIATE_TEST_SUITE_P( LoopControl, EnumCapabilityTest, Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), ValuesIn(std::vector{ CASE0(LOOP_CONTROL, LoopControlMask::MaskNone), CASE0(LOOP_CONTROL, LoopControlMask::Unroll), CASE0(LOOP_CONTROL, LoopControlMask::DontUnroll), }))); INSTANTIATE_TEST_SUITE_P( LoopControlV11, EnumCapabilityTest, Combine(Values(SPV_ENV_UNIVERSAL_1_1), ValuesIn(std::vector{ CASE0(LOOP_CONTROL, LoopControlMask::DependencyInfinite), CASE0(LOOP_CONTROL, LoopControlMask::DependencyLength), }))); // See SPIR-V Section 3.24 Function Control INSTANTIATE_TEST_SUITE_P( FunctionControl, EnumCapabilityTest, Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), ValuesIn(std::vector{ CASE0(FUNCTION_CONTROL, FunctionControlMask::MaskNone), CASE0(FUNCTION_CONTROL, FunctionControlMask::Inline), CASE0(FUNCTION_CONTROL, FunctionControlMask::DontInline), CASE0(FUNCTION_CONTROL, FunctionControlMask::Pure), CASE0(FUNCTION_CONTROL, FunctionControlMask::Const), }))); // See SPIR-V Section 3.25 Memory Semantics INSTANTIATE_TEST_SUITE_P( MemorySemantics, EnumCapabilityTest, Combine( Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), ValuesIn(std::vector{ CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsMask::MaskNone), CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsMask::Acquire), CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsMask::Release), CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsMask::AcquireRelease), CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsMask::SequentiallyConsistent), CASE1(MEMORY_SEMANTICS_ID, MemorySemanticsMask::UniformMemory, Shader), CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsMask::SubgroupMemory), CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsMask::WorkgroupMemory), CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsMask::CrossWorkgroupMemory), CASE1(MEMORY_SEMANTICS_ID, MemorySemanticsMask::AtomicCounterMemory, AtomicStorage), // Bug 15234 CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsMask::ImageMemory), }))); // See SPIR-V Section 3.26 Memory Access INSTANTIATE_TEST_SUITE_P( MemoryAccess, EnumCapabilityTest, Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), ValuesIn(std::vector{ CASE0(OPTIONAL_MEMORY_ACCESS, MemoryAccessMask::MaskNone), CASE0(OPTIONAL_MEMORY_ACCESS, MemoryAccessMask::Volatile), CASE0(OPTIONAL_MEMORY_ACCESS, MemoryAccessMask::Aligned), CASE0(OPTIONAL_MEMORY_ACCESS, MemoryAccessMask::Nontemporal), }))); // See SPIR-V Section 3.27 Scope INSTANTIATE_TEST_SUITE_P( Scope, EnumCapabilityTest, Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1, SPV_ENV_UNIVERSAL_1_2, SPV_ENV_UNIVERSAL_1_3), ValuesIn(std::vector{ CASE0(SCOPE_ID, Scope::CrossDevice), CASE0(SCOPE_ID, Scope::Device), CASE0(SCOPE_ID, Scope::Workgroup), CASE0(SCOPE_ID, Scope::Subgroup), CASE0(SCOPE_ID, Scope::Invocation), CASE1(SCOPE_ID, Scope::QueueFamilyKHR, VulkanMemoryModelKHR), }))); // See SPIR-V Section 3.28 Group Operation INSTANTIATE_TEST_SUITE_P( GroupOperation, EnumCapabilityTest, Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), ValuesIn(std::vector{ CASE3(GROUP_OPERATION, GroupOperation::Reduce, Kernel, GroupNonUniformArithmetic, GroupNonUniformBallot), CASE3(GROUP_OPERATION, GroupOperation::InclusiveScan, Kernel, GroupNonUniformArithmetic, GroupNonUniformBallot), CASE3(GROUP_OPERATION, GroupOperation::ExclusiveScan, Kernel, GroupNonUniformArithmetic, GroupNonUniformBallot), }))); // See SPIR-V Section 3.29 Kernel Enqueue Flags INSTANTIATE_TEST_SUITE_P( KernelEnqueueFlags, EnumCapabilityTest, Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), ValuesIn(std::vector{ CASE1(KERNEL_ENQ_FLAGS, KernelEnqueueFlags::NoWait, Kernel), CASE1(KERNEL_ENQ_FLAGS, KernelEnqueueFlags::WaitKernel, Kernel), CASE1(KERNEL_ENQ_FLAGS, KernelEnqueueFlags::WaitWorkGroup, Kernel), }))); // See SPIR-V Section 3.30 Kernel Profiling Info INSTANTIATE_TEST_SUITE_P( KernelProfilingInfo, EnumCapabilityTest, Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), ValuesIn(std::vector{ CASE0(KERNEL_PROFILING_INFO, KernelProfilingInfoMask::MaskNone), CASE1(KERNEL_PROFILING_INFO, KernelProfilingInfoMask::CmdExecTime, Kernel), }))); // See SPIR-V Section 3.31 Capability INSTANTIATE_TEST_SUITE_P( CapabilityDependsOn, EnumCapabilityTest, Combine( Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), ValuesIn(std::vector{ // clang-format off CASE0(CAPABILITY, Capability::Matrix), CASE1(CAPABILITY, Capability::Shader, Matrix), CASE1(CAPABILITY, Capability::Geometry, Shader), CASE1(CAPABILITY, Capability::Tessellation, Shader), CASE0(CAPABILITY, Capability::Addresses), CASE0(CAPABILITY, Capability::Linkage), CASE0(CAPABILITY, Capability::Kernel), CASE1(CAPABILITY, Capability::Vector16, Kernel), CASE1(CAPABILITY, Capability::Float16Buffer, Kernel), CASE0(CAPABILITY, Capability::Float16), // Bug 15234 CASE0(CAPABILITY, Capability::Float64), CASE0(CAPABILITY, Capability::Int64), CASE1(CAPABILITY, Capability::Int64Atomics, Int64), CASE1(CAPABILITY, Capability::ImageBasic, Kernel), CASE1(CAPABILITY, Capability::ImageReadWrite, ImageBasic), CASE1(CAPABILITY, Capability::ImageMipmap, ImageBasic), // Value 16 intentionally missing. CASE1(CAPABILITY, Capability::Pipes, Kernel), CASE0(CAPABILITY, Capability::Groups), CASE1(CAPABILITY, Capability::DeviceEnqueue, Kernel), CASE1(CAPABILITY, Capability::LiteralSampler, Kernel), CASE1(CAPABILITY, Capability::AtomicStorage, Shader), CASE0(CAPABILITY, Capability::Int16), CASE1(CAPABILITY, Capability::TessellationPointSize, Tessellation), CASE1(CAPABILITY, Capability::GeometryPointSize, Geometry), CASE1(CAPABILITY, Capability::ImageGatherExtended, Shader), // Value 26 intentionally missing. CASE1(CAPABILITY, Capability::StorageImageMultisample, Shader), CASE1(CAPABILITY, Capability::UniformBufferArrayDynamicIndexing, Shader), CASE1(CAPABILITY, Capability::SampledImageArrayDynamicIndexing, Shader), CASE1(CAPABILITY, Capability::StorageBufferArrayDynamicIndexing, Shader), CASE1(CAPABILITY, Capability::StorageImageArrayDynamicIndexing, Shader), CASE1(CAPABILITY, Capability::ClipDistance, Shader), CASE1(CAPABILITY, Capability::CullDistance, Shader), CASE1(CAPABILITY, Capability::ImageCubeArray, SampledCubeArray), CASE1(CAPABILITY, Capability::SampleRateShading, Shader), CASE1(CAPABILITY, Capability::ImageRect, SampledRect), CASE1(CAPABILITY, Capability::SampledRect, Shader), CASE1(CAPABILITY, Capability::GenericPointer, Addresses), CASE0(CAPABILITY, Capability::Int8), CASE1(CAPABILITY, Capability::InputAttachment, Shader), CASE1(CAPABILITY, Capability::SparseResidency, Shader), CASE1(CAPABILITY, Capability::MinLod, Shader), CASE1(CAPABILITY, Capability::Image1D, Sampled1D), CASE1(CAPABILITY, Capability::SampledCubeArray, Shader), CASE1(CAPABILITY, Capability::ImageBuffer, SampledBuffer), CASE1(CAPABILITY, Capability::ImageMSArray, Shader), CASE1(CAPABILITY, Capability::StorageImageExtendedFormats, Shader), CASE1(CAPABILITY, Capability::ImageQuery, Shader), CASE1(CAPABILITY, Capability::DerivativeControl, Shader), CASE1(CAPABILITY, Capability::InterpolationFunction, Shader), CASE1(CAPABILITY, Capability::TransformFeedback, Shader), CASE1(CAPABILITY, Capability::GeometryStreams, Geometry), CASE1(CAPABILITY, Capability::StorageImageReadWithoutFormat, Shader), CASE1(CAPABILITY, Capability::StorageImageWriteWithoutFormat, Shader), CASE1(CAPABILITY, Capability::MultiViewport, Geometry), // clang-format on }))); INSTANTIATE_TEST_SUITE_P( CapabilityDependsOnV11, EnumCapabilityTest, Combine(Values(SPV_ENV_UNIVERSAL_1_1), ValuesIn(std::vector{ CASE1(CAPABILITY, Capability::SubgroupDispatch, DeviceEnqueue), CASE1(CAPABILITY, Capability::NamedBarrier, Kernel), CASE1(CAPABILITY, Capability::PipeStorage, Pipes), }))); #undef CASE0 #undef CASE1 #undef CASE2 } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/operand_pattern_test.cpp000066400000000000000000000264101475742701700244430ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gmock/gmock.h" #include "source/operand.h" #include "test/unit_spirv.h" namespace spvtools { namespace { using ::testing::Eq; TEST(OperandPattern, InitiallyEmpty) { spv_operand_pattern_t empty; EXPECT_THAT(empty, Eq(spv_operand_pattern_t{})); EXPECT_EQ(0u, empty.size()); EXPECT_TRUE(empty.empty()); } TEST(OperandPattern, PushBacksAreOnTheRight) { spv_operand_pattern_t pattern; pattern.push_back(SPV_OPERAND_TYPE_ID); EXPECT_THAT(pattern, Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_ID})); EXPECT_EQ(1u, pattern.size()); EXPECT_TRUE(!pattern.empty()); EXPECT_EQ(SPV_OPERAND_TYPE_ID, pattern.back()); pattern.push_back(SPV_OPERAND_TYPE_NONE); EXPECT_THAT(pattern, Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_NONE})); EXPECT_EQ(2u, pattern.size()); EXPECT_TRUE(!pattern.empty()); EXPECT_EQ(SPV_OPERAND_TYPE_NONE, pattern.back()); } TEST(OperandPattern, PopBacksAreOnTheRight) { spv_operand_pattern_t pattern{SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_LITERAL_INTEGER}; pattern.pop_back(); EXPECT_THAT(pattern, Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_ID})); pattern.pop_back(); EXPECT_THAT(pattern, Eq(spv_operand_pattern_t{})); } // A test case for typed mask expansion struct MaskExpansionCase { spv_operand_type_t type; uint32_t mask; spv_operand_pattern_t initial; spv_operand_pattern_t expected; }; using MaskExpansionTest = ::testing::TestWithParam; TEST_P(MaskExpansionTest, Sample) { spv_operand_table operandTable = nullptr; auto env = SPV_ENV_UNIVERSAL_1_0; ASSERT_EQ(SPV_SUCCESS, spvOperandTableGet(&operandTable, env)); spv_operand_pattern_t pattern(GetParam().initial); spvPushOperandTypesForMask(env, operandTable, GetParam().type, GetParam().mask, &pattern); EXPECT_THAT(pattern, Eq(GetParam().expected)); } // These macros let us write non-trivial examples without too much text. #define PREFIX0 SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_NONE #define PREFIX1 \ SPV_OPERAND_TYPE_STORAGE_CLASS, SPV_OPERAND_TYPE_SAMPLER_FILTER_MODE, \ SPV_OPERAND_TYPE_ID INSTANTIATE_TEST_SUITE_P( OperandPattern, MaskExpansionTest, ::testing::ValuesIn(std::vector{ // No bits means no change. {SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS, 0, {PREFIX0}, {PREFIX0}}, // Unknown bits means no change. Use all bits that aren't in the // grammar. // The used mask bits are: // 1 through... // 0x20 SpvMemoryAccessNonPrivatePointerMask // also // 0x10000 SpvMemoryAccessAliasScopeINTELMaskShift // 0x20000 SpvMemoryAccessNoAliasINTELMaskMask {SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS, 0xffffffc0 ^ (0x10000) ^ (0x20000), {PREFIX1}, {PREFIX1}}, // Volatile has no operands. {SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS, uint32_t(spv::MemoryAccessMask::Volatile), {PREFIX0}, {PREFIX0}}, // Aligned has one literal number operand. {SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS, uint32_t(spv::MemoryAccessMask::Aligned), {PREFIX1}, {PREFIX1, SPV_OPERAND_TYPE_LITERAL_INTEGER}}, // Volatile with Aligned still has just one literal number operand. {SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS, uint32_t(spv::MemoryAccessMask::Volatile | spv::MemoryAccessMask::Aligned), {PREFIX1}, {PREFIX1, SPV_OPERAND_TYPE_LITERAL_INTEGER}}, // Newer masks are not tested })); #undef PREFIX0 #undef PREFIX1 // Returns a vector of all operand types that can be used in a pattern. std::vector allOperandTypes() { std::vector result; for (int i = 0; i < SPV_OPERAND_TYPE_NUM_OPERAND_TYPES; i++) { result.push_back(spv_operand_type_t(i)); } return result; } using MatchableOperandExpansionTest = ::testing::TestWithParam; TEST_P(MatchableOperandExpansionTest, MatchableOperandsDontExpand) { const spv_operand_type_t type = GetParam(); if (!spvOperandIsVariable(type)) { spv_operand_pattern_t pattern; const bool did_expand = spvExpandOperandSequenceOnce(type, &pattern); EXPECT_FALSE(did_expand); EXPECT_THAT(pattern, Eq(spv_operand_pattern_t{})); } } INSTANTIATE_TEST_SUITE_P(MatchableOperandExpansion, MatchableOperandExpansionTest, ::testing::ValuesIn(allOperandTypes())); using VariableOperandExpansionTest = ::testing::TestWithParam; TEST_P(VariableOperandExpansionTest, NonMatchableOperandsExpand) { const spv_operand_type_t type = GetParam(); if (spvOperandIsVariable(type)) { spv_operand_pattern_t pattern; const bool did_expand = spvExpandOperandSequenceOnce(type, &pattern); EXPECT_TRUE(did_expand); EXPECT_FALSE(pattern.empty()); // For the existing rules, the first expansion of a zero-or-more operand // type yields a matchable operand type. This isn't strictly necessary. EXPECT_FALSE(spvOperandIsVariable(pattern.back())); } } INSTANTIATE_TEST_SUITE_P(NonMatchableOperandExpansion, VariableOperandExpansionTest, ::testing::ValuesIn(allOperandTypes())); TEST(AlternatePatternFollowingImmediate, Empty) { EXPECT_THAT(spvAlternatePatternFollowingImmediate({}), Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_OPTIONAL_CIV})); } TEST(AlternatePatternFollowingImmediate, SingleElement) { // Spot-check a random selection of types. EXPECT_THAT(spvAlternatePatternFollowingImmediate( {SPV_OPERAND_TYPE_VARIABLE_ID_LITERAL_INTEGER}), Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_OPTIONAL_CIV})); EXPECT_THAT( spvAlternatePatternFollowingImmediate({SPV_OPERAND_TYPE_CAPABILITY}), Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_OPTIONAL_CIV})); EXPECT_THAT( spvAlternatePatternFollowingImmediate({SPV_OPERAND_TYPE_LOOP_CONTROL}), Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_OPTIONAL_CIV})); EXPECT_THAT(spvAlternatePatternFollowingImmediate( {SPV_OPERAND_TYPE_OPTIONAL_LITERAL_INTEGER}), Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_OPTIONAL_CIV})); EXPECT_THAT(spvAlternatePatternFollowingImmediate({SPV_OPERAND_TYPE_ID}), Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_OPTIONAL_CIV})); } TEST(AlternatePatternFollowingImmediate, SingleResultId) { EXPECT_THAT( spvAlternatePatternFollowingImmediate({SPV_OPERAND_TYPE_RESULT_ID}), Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_OPTIONAL_CIV, SPV_OPERAND_TYPE_RESULT_ID})); } TEST(AlternatePatternFollowingImmediate, MultipleNonResultIds) { EXPECT_THAT( spvAlternatePatternFollowingImmediate( {SPV_OPERAND_TYPE_VARIABLE_ID_LITERAL_INTEGER, SPV_OPERAND_TYPE_CAPABILITY, SPV_OPERAND_TYPE_LOOP_CONTROL, SPV_OPERAND_TYPE_OPTIONAL_LITERAL_INTEGER, SPV_OPERAND_TYPE_ID}), Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_OPTIONAL_CIV})); } TEST(AlternatePatternFollowingImmediate, ResultIdFront) { EXPECT_THAT(spvAlternatePatternFollowingImmediate( {SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_ID}), Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_OPTIONAL_CIV, SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_OPTIONAL_CIV})); EXPECT_THAT( spvAlternatePatternFollowingImmediate({SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_FP_ROUNDING_MODE, SPV_OPERAND_TYPE_ID}), Eq(spv_operand_pattern_t{ SPV_OPERAND_TYPE_OPTIONAL_CIV, SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_OPTIONAL_CIV, SPV_OPERAND_TYPE_OPTIONAL_CIV})); EXPECT_THAT( spvAlternatePatternFollowingImmediate( {SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_DIMENSIONALITY, SPV_OPERAND_TYPE_LINKAGE_TYPE, SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE, SPV_OPERAND_TYPE_FP_ROUNDING_MODE, SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_VARIABLE_ID}), Eq(spv_operand_pattern_t{ SPV_OPERAND_TYPE_OPTIONAL_CIV, SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_OPTIONAL_CIV, SPV_OPERAND_TYPE_OPTIONAL_CIV, SPV_OPERAND_TYPE_OPTIONAL_CIV, SPV_OPERAND_TYPE_OPTIONAL_CIV, SPV_OPERAND_TYPE_OPTIONAL_CIV, SPV_OPERAND_TYPE_OPTIONAL_CIV})); } TEST(AlternatePatternFollowingImmediate, ResultIdMiddle) { EXPECT_THAT(spvAlternatePatternFollowingImmediate( {SPV_OPERAND_TYPE_FP_ROUNDING_MODE, SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_ID}), Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_OPTIONAL_CIV, SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_OPTIONAL_CIV})); EXPECT_THAT( spvAlternatePatternFollowingImmediate( {SPV_OPERAND_TYPE_DIMENSIONALITY, SPV_OPERAND_TYPE_LINKAGE_TYPE, SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE, SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_FP_ROUNDING_MODE, SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_VARIABLE_ID}), Eq(spv_operand_pattern_t{ SPV_OPERAND_TYPE_OPTIONAL_CIV, SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_OPTIONAL_CIV, SPV_OPERAND_TYPE_OPTIONAL_CIV, SPV_OPERAND_TYPE_OPTIONAL_CIV})); } TEST(AlternatePatternFollowingImmediate, ResultIdBack) { EXPECT_THAT(spvAlternatePatternFollowingImmediate( {SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_RESULT_ID}), Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_OPTIONAL_CIV, SPV_OPERAND_TYPE_RESULT_ID})); EXPECT_THAT(spvAlternatePatternFollowingImmediate( {SPV_OPERAND_TYPE_FP_ROUNDING_MODE, SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_RESULT_ID}), Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_OPTIONAL_CIV, SPV_OPERAND_TYPE_RESULT_ID})); EXPECT_THAT( spvAlternatePatternFollowingImmediate( {SPV_OPERAND_TYPE_DIMENSIONALITY, SPV_OPERAND_TYPE_LINKAGE_TYPE, SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE, SPV_OPERAND_TYPE_FP_ROUNDING_MODE, SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_VARIABLE_ID, SPV_OPERAND_TYPE_RESULT_ID}), Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_OPTIONAL_CIV, SPV_OPERAND_TYPE_RESULT_ID})); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/operand_test.cpp000066400000000000000000000116371475742701700227130ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "test/unit_spirv.h" namespace spvtools { namespace { using GetTargetTest = ::testing::TestWithParam; using ::testing::ValuesIn; TEST_P(GetTargetTest, Default) { spv_operand_table table; ASSERT_EQ(SPV_SUCCESS, spvOperandTableGet(&table, GetParam())); ASSERT_NE(0u, table->count); ASSERT_NE(nullptr, table->types); } TEST_P(GetTargetTest, InvalidPointerTable) { ASSERT_EQ(SPV_ERROR_INVALID_POINTER, spvOperandTableGet(nullptr, GetParam())); } INSTANTIATE_TEST_SUITE_P(OperandTableGet, GetTargetTest, ValuesIn(std::vector{ SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1, SPV_ENV_VULKAN_1_0})); TEST(OperandString, AllAreDefinedExceptVariable) { // None has no string, so don't test it. EXPECT_EQ(0u, SPV_OPERAND_TYPE_NONE); // Start testing at enum with value 1, skipping None. for (int i = 1; i < int(SPV_OPERAND_TYPE_NUM_OPERAND_TYPES); i++) { const auto type = static_cast(i); if (spvOperandIsVariable(type)) { EXPECT_STREQ("unknown", spvOperandTypeStr(type)) << " variable type " << i << " has a name '" << spvOperandTypeStr(type) << "'when it should not"; } else { EXPECT_STRNE("unknown", spvOperandTypeStr(type)) << " operand type " << i << " has no name when it should"; } } } TEST(OperandIsConcreteMask, Sample) { // Check a few operand types preceding the concrete mask types. EXPECT_FALSE(spvOperandIsConcreteMask(SPV_OPERAND_TYPE_NONE)); EXPECT_FALSE(spvOperandIsConcreteMask(SPV_OPERAND_TYPE_ID)); EXPECT_FALSE(spvOperandIsConcreteMask(SPV_OPERAND_TYPE_LITERAL_INTEGER)); EXPECT_FALSE(spvOperandIsConcreteMask(SPV_OPERAND_TYPE_CAPABILITY)); // Check all the concrete mask operand types. EXPECT_TRUE(spvOperandIsConcreteMask(SPV_OPERAND_TYPE_IMAGE)); EXPECT_TRUE(spvOperandIsConcreteMask(SPV_OPERAND_TYPE_FP_FAST_MATH_MODE)); EXPECT_TRUE(spvOperandIsConcreteMask(SPV_OPERAND_TYPE_SELECTION_CONTROL)); EXPECT_TRUE(spvOperandIsConcreteMask(SPV_OPERAND_TYPE_LOOP_CONTROL)); EXPECT_TRUE(spvOperandIsConcreteMask(SPV_OPERAND_TYPE_FUNCTION_CONTROL)); EXPECT_TRUE(spvOperandIsConcreteMask(SPV_OPERAND_TYPE_MEMORY_ACCESS)); // Check a few operand types after the concrete mask types, including the // optional forms for Image and MemoryAccess. EXPECT_FALSE(spvOperandIsConcreteMask(SPV_OPERAND_TYPE_OPTIONAL_ID)); EXPECT_FALSE(spvOperandIsConcreteMask(SPV_OPERAND_TYPE_OPTIONAL_IMAGE)); EXPECT_FALSE( spvOperandIsConcreteMask(SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS)); } TEST(OperandType, NoneTypeClassification) { EXPECT_FALSE(spvOperandIsConcrete(SPV_OPERAND_TYPE_NONE)); EXPECT_FALSE(spvOperandIsOptional(SPV_OPERAND_TYPE_NONE)); EXPECT_FALSE(spvOperandIsVariable(SPV_OPERAND_TYPE_NONE)); } TEST(OperandType, EndSentinelTypeClassification) { EXPECT_FALSE(spvOperandIsConcrete(SPV_OPERAND_TYPE_NUM_OPERAND_TYPES)); EXPECT_FALSE(spvOperandIsOptional(SPV_OPERAND_TYPE_NUM_OPERAND_TYPES)); EXPECT_FALSE(spvOperandIsVariable(SPV_OPERAND_TYPE_NUM_OPERAND_TYPES)); } TEST(OperandType, WidthForcingTypeClassification) { EXPECT_FALSE(spvOperandIsConcrete(SPV_FORCE_32BIT_spv_operand_type_t)); EXPECT_FALSE(spvOperandIsOptional(SPV_FORCE_32BIT_spv_operand_type_t)); EXPECT_FALSE(spvOperandIsVariable(SPV_FORCE_32BIT_spv_operand_type_t)); } TEST(OperandType, EachTypeIsEitherConcreteOrOptionalNotBoth) { EXPECT_EQ(0u, SPV_OPERAND_TYPE_NONE); // Start testing at enum with value 1, skipping None. for (int i = 1; i < int(SPV_OPERAND_TYPE_NUM_OPERAND_TYPES); i++) { const auto type = static_cast(i); EXPECT_NE(spvOperandIsConcrete(type), spvOperandIsOptional(type)) << " operand type " << int(type) << " concrete? " << int(spvOperandIsConcrete(type)) << " optional? " << int(spvOperandIsOptional(type)); } } TEST(OperandType, EachVariableTypeIsOptional) { EXPECT_EQ(0u, SPV_OPERAND_TYPE_NONE); // Start testing at enum with value 1, skipping None. for (int i = 1; i < int(SPV_OPERAND_TYPE_NUM_OPERAND_TYPES); i++) { const auto type = static_cast(i); if (spvOperandIsVariable(type)) { EXPECT_TRUE(spvOperandIsOptional(type)) << " variable type " << int(type); } } } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/000077500000000000000000000000001475742701700203125ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/opt/CMakeLists.txt000066400000000000000000000103431475742701700230530ustar00rootroot00000000000000# Copyright (c) 2016 Google Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. add_subdirectory(dominator_tree) add_subdirectory(loop_optimizations) add_spvtools_unittest(TARGET opt SRCS aggressive_dead_code_elim_test.cpp amd_ext_to_khr.cpp analyze_live_input_test.cpp assembly_builder_test.cpp block_merge_test.cpp c_interface_test.cpp ccp_test.cpp cfg_cleanup_test.cpp cfg_test.cpp code_sink_test.cpp combine_access_chains_test.cpp compact_ids_test.cpp constants_test.cpp constant_manager_test.cpp control_dependence.cpp convert_relaxed_to_half_test.cpp convert_to_sampled_image_test.cpp copy_prop_array_test.cpp dataflow.cpp dead_branch_elim_test.cpp dead_insert_elim_test.cpp dead_variable_elim_test.cpp debug_info_manager_test.cpp decoration_manager_test.cpp def_use_test.cpp desc_sroa_test.cpp eliminate_dead_const_test.cpp eliminate_dead_functions_test.cpp eliminate_dead_io_components_test.cpp eliminate_dead_member_test.cpp eliminate_dead_output_stores_test.cpp feature_manager_test.cpp fix_func_call_arguments_test.cpp fix_storage_class_test.cpp flatten_decoration_test.cpp fold_spec_const_op_composite_test.cpp fold_test.cpp freeze_spec_const_test.cpp function_test.cpp graphics_robust_access_test.cpp if_conversion_test.cpp inline_opaque_test.cpp inline_test.cpp insert_extract_elim_test.cpp instruction_list_test.cpp instruction_test.cpp interface_var_sroa_test.cpp invocation_interlock_placement_test.cpp interp_fixup_test.cpp ir_builder.cpp ir_context_test.cpp ir_loader_test.cpp iterator_test.cpp line_debug_info_test.cpp local_access_chain_convert_test.cpp local_redundancy_elimination_test.cpp local_single_block_elim.cpp local_single_store_elim_test.cpp local_ssa_elim_test.cpp modify_maximal_reconvergence_test.cpp module_test.cpp module_utils.h opextinst_forward_ref_fixup_pass_test.cpp optimizer_test.cpp pass_manager_test.cpp pass_merge_return_test.cpp pass_remove_duplicates_test.cpp pass_utils.cpp private_to_local_test.cpp propagator_test.cpp reduce_load_size_test.cpp redundancy_elimination_test.cpp remove_dontinline_test.cpp remove_unused_interface_variables_test.cpp register_liveness.cpp relax_float_ops_test.cpp replace_desc_array_access_using_var_index_test.cpp replace_invalid_opc_test.cpp scalar_analysis.cpp scalar_replacement_test.cpp set_spec_const_default_value_test.cpp simplification_test.cpp spread_volatile_semantics_test.cpp strength_reduction_test.cpp strip_debug_info_test.cpp strip_nonsemantic_info_test.cpp struct_cfg_analysis_test.cpp struct_packing_test.cpp switch_descriptorset_test.cpp trim_capabilities_pass_test.cpp type_manager_test.cpp types_test.cpp unify_const_test.cpp upgrade_memory_model_test.cpp utils_test.cpp pass_utils.cpp value_table_test.cpp vector_dce_test.cpp workaround1209_test.cpp wrap_opkill_test.cpp LIBS SPIRV-Tools-opt PCH_FILE pch_test_opt ) if (NOT "${SPIRV_SKIP_TESTS}" AND TARGET gmock_main) if (MSVC) if (${MSVC_VERSION} LESS 1920) # The VS 2017 debug build requires /bigobj on test_opt # https://github.com/KhronosGroup/SPIRV-Tools/issues/5335 target_compile_options(test_opt PRIVATE /bigobj) endif() endif() endif() KhronosGroup-SPIRV-Tools-f289d04/test/opt/aggressive_dead_code_elim_test.cpp000066400000000000000000010356241475742701700272040ustar00rootroot00000000000000// Copyright (c) 2017 Valve Corporation // Copyright (c) 2017 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gmock/gmock.h" #include "test/opt/assembly_builder.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using AggressiveDCETest = PassTest<::testing::Test>; using ::testing::HasSubstr; TEST_F(AggressiveDCETest, EliminateExtendedInst) { // #version 140 // // in vec4 BaseColor; // in vec4 Dead; // // void main() // { // vec4 v = BaseColor; // vec4 dv = sqrt(Dead); // gl_FragColor = v; // } const std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 ; CHECK: OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor OpEntryPoint Fragment %main "main" %BaseColor %Dead %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" ; CHECK-NOT: OpName %dv "dv" OpName %dv "dv" ; CHECK-NOT: OpName %Dead "Dead" OpName %Dead "Dead" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %9 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input ; CHECK-NOT: %Dead = OpVariable %Dead = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %9 %15 = OpLabel %v = OpVariable %_ptr_Function_v4float Function ; CHECK-NOT: %dv = OpVariable %dv = OpVariable %_ptr_Function_v4float Function %16 = OpLoad %v4float %BaseColor OpStore %v %16 ; CHECK-NOT: OpLoad %v4float %Dead %17 = OpLoad %v4float %Dead ; CHECK-NOT: OpExtInst %v4float %1 Sqrt %18 = OpExtInst %v4float %1 Sqrt %17 ; CHECK-NOT: OpStore %dv OpStore %dv %18 %19 = OpLoad %v4float %v OpStore %gl_FragColor %19 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(spirv, true); } TEST_F(AggressiveDCETest, NoEliminateFrexp) { // Note: SPIR-V hand-edited to utilize Frexp // // #version 450 // // in vec4 BaseColor; // in vec4 Dead; // out vec4 Color; // out ivec4 iv2; // // void main() // { // vec4 v = BaseColor; // vec4 dv = frexp(Dead, iv2); // Color = v; // } const std::string predefs1 = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %Dead %iv2 %Color OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 )"; const std::string names_before = R"(OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" OpName %dv "dv" OpName %Dead "Dead" OpName %iv2 "iv2" OpName %ResType "ResType" OpName %Color "Color" )"; const std::string names_after = R"(OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" OpName %Dead "Dead" OpName %iv2 "iv2" OpName %Color "Color" )"; const std::string predefs2_before = R"(%void = OpTypeVoid %11 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %Dead = OpVariable %_ptr_Input_v4float Input %int = OpTypeInt 32 1 %v4int = OpTypeVector %int 4 %_ptr_Output_v4int = OpTypePointer Output %v4int %iv2 = OpVariable %_ptr_Output_v4int Output %ResType = OpTypeStruct %v4float %v4int %_ptr_Output_v4float = OpTypePointer Output %v4float %Color = OpVariable %_ptr_Output_v4float Output )"; const std::string predefs2_after = R"(%void = OpTypeVoid %11 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %Dead = OpVariable %_ptr_Input_v4float Input %int = OpTypeInt 32 1 %v4int = OpTypeVector %int 4 %_ptr_Output_v4int = OpTypePointer Output %v4int %iv2 = OpVariable %_ptr_Output_v4int Output %_ptr_Output_v4float = OpTypePointer Output %v4float %Color = OpVariable %_ptr_Output_v4float Output )"; const std::string func_before = R"(%main = OpFunction %void None %11 %20 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %dv = OpVariable %_ptr_Function_v4float Function %21 = OpLoad %v4float %BaseColor OpStore %v %21 %22 = OpLoad %v4float %Dead %23 = OpExtInst %v4float %1 Frexp %22 %iv2 OpStore %dv %23 %24 = OpLoad %v4float %v OpStore %Color %24 OpReturn OpFunctionEnd )"; const std::string func_after = R"(%main = OpFunction %void None %11 %20 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %21 = OpLoad %v4float %BaseColor OpStore %v %21 %22 = OpLoad %v4float %Dead %23 = OpExtInst %v4float %1 Frexp %22 %iv2 %24 = OpLoad %v4float %v OpStore %Color %24 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck( predefs1 + names_before + predefs2_before + func_before, predefs1 + names_after + predefs2_after + func_after, true, true); } TEST_F(AggressiveDCETest, EliminateDecorate) { // Note: The SPIR-V was hand-edited to add the OpDecorate // // #version 140 // // in vec4 BaseColor; // in vec4 Dead; // // void main() // { // vec4 v = BaseColor; // vec4 dv = Dead * 0.5; // gl_FragColor = v; // } const std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %Dead %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" OpName %dv "dv" OpName %Dead "Dead" OpName %gl_FragColor "gl_FragColor" ; CHECK-NOT: OpDecorate OpDecorate %8 RelaxedPrecision %void = OpTypeVoid %10 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %Dead = OpVariable %_ptr_Input_v4float Input %float_0_5 = OpConstant %float 0.5 %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %10 %17 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %dv = OpVariable %_ptr_Function_v4float Function %18 = OpLoad %v4float %BaseColor OpStore %v %18 %19 = OpLoad %v4float %Dead ; CHECK-NOT: OpVectorTimesScalar %8 = OpVectorTimesScalar %v4float %19 %float_0_5 OpStore %dv %8 %20 = OpLoad %v4float %v OpStore %gl_FragColor %20 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(spirv, true); } TEST_F(AggressiveDCETest, Simple) { // #version 140 // // in vec4 BaseColor; // in vec4 Dead; // // void main() // { // vec4 v = BaseColor; // vec4 dv = Dead; // gl_FragColor = v; // } const std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 ; CHECK: OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor OpEntryPoint Fragment %main "main" %BaseColor %Dead %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" ; CHECK-NOT: OpName %dv "dv" OpName %dv "dv" ; CHECK-NOT: OpName %Dead "Dead" OpName %Dead "Dead" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %9 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input ; CHECK-NOT: %Dead = OpVariable %Dead = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %9 %15 = OpLabel %v = OpVariable %_ptr_Function_v4float Function ; CHECK-NOT: %dv = OpVariable %dv = OpVariable %_ptr_Function_v4float Function %16 = OpLoad %v4float %BaseColor OpStore %v %16 ; CHECK-NOT: OpLoad %v4float %Dead %17 = OpLoad %v4float %Dead ; CHECK-NOT: OpStore %dv OpStore %dv %17 %18 = OpLoad %v4float %v OpStore %gl_FragColor %18 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(spirv, true); } TEST_F(AggressiveDCETest, OptAllowListExtension) { // #version 140 // // in vec4 BaseColor; // in vec4 Dead; // // void main() // { // vec4 v = BaseColor; // vec4 dv = Dead; // gl_FragColor = v; // } const std::string spirv = R"(OpCapability Shader OpExtension "SPV_AMD_gpu_shader_int16" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 ; CHECK: OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor OpEntryPoint Fragment %main "main" %BaseColor %Dead %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" OpName %dv "dv" OpName %Dead "Dead" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %9 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %Dead = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %9 %15 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %dv = OpVariable %_ptr_Function_v4float Function %16 = OpLoad %v4float %BaseColor OpStore %v %16 %17 = OpLoad %v4float %Dead OpStore %dv %17 %18 = OpLoad %v4float %v OpStore %gl_FragColor %18 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(spirv, true); } TEST_F(AggressiveDCETest, NoOptDenyListExtension) { // #version 140 // // in vec4 BaseColor; // in vec4 Dead; // // void main() // { // vec4 v = BaseColor; // vec4 dv = Dead; // gl_FragColor = v; // } const std::string assembly = R"(OpCapability Shader OpExtension "SPV_KHR_variable_pointers" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %Dead %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" OpName %dv "dv" OpName %Dead "Dead" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %9 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %Dead = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %9 %15 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %dv = OpVariable %_ptr_Function_v4float Function %16 = OpLoad %v4float %BaseColor OpStore %v %16 %17 = OpLoad %v4float %Dead OpStore %dv %17 %18 = OpLoad %v4float %v OpStore %gl_FragColor %18 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(assembly, assembly, true, true); } TEST_F(AggressiveDCETest, ElimWithCall) { // This demonstrates that "dead" function calls are not eliminated. // Also demonstrates that DCE will happen in presence of function call. // #version 140 // in vec4 i1; // in vec4 i2; // // void nothing(vec4 v) // { // } // // void main() // { // vec4 v1 = i1; // vec4 v2 = i2; // nothing(v1); // gl_FragColor = vec4(0.0); // } const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %i1 %i2 %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %nothing_vf4_ "nothing(vf4;" OpName %v "v" OpName %v1 "v1" OpName %i1 "i1" OpName %v2 "v2" OpName %i2 "i2" OpName %param "param" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %12 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %16 = OpTypeFunction %void %_ptr_Function_v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %i1 = OpVariable %_ptr_Input_v4float Input %i2 = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output %float_0 = OpConstant %float 0 %20 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %main = OpFunction %void None %12 %21 = OpLabel %v1 = OpVariable %_ptr_Function_v4float Function %v2 = OpVariable %_ptr_Function_v4float Function %param = OpVariable %_ptr_Function_v4float Function %22 = OpLoad %v4float %i1 OpStore %v1 %22 ; CHECK-NOT: OpLoad %v4float %i2 %23 = OpLoad %v4float %i2 ; CHECK-NOT: OpStore %v2 OpStore %v2 %23 %24 = OpLoad %v4float %v1 OpStore %param %24 ; CHECK: OpFunctionCall %void %nothing_vf4_ %25 = OpFunctionCall %void %nothing_vf4_ %param OpStore %gl_FragColor %20 OpReturn OpFunctionEnd ; CHECK: %nothing_vf4_ = OpFunction %nothing_vf4_ = OpFunction %void None %16 %v = OpFunctionParameter %_ptr_Function_v4float %26 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(AggressiveDCETest, NoParamElim) { // This demonstrates that unused parameters are not eliminated, but // dead uses of them are. // #version 140 // // in vec4 BaseColor; // // vec4 foo(vec4 v1, vec4 v2) // { // vec4 t = -v1; // return v2; // } // // void main() // { // vec4 dead; // gl_FragColor = foo(dead, BaseColor); // } const std::string defs_before = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragColor %BaseColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %foo_vf4_vf4_ "foo(vf4;vf4;" OpName %v1 "v1" OpName %v2 "v2" OpName %t "t" OpName %gl_FragColor "gl_FragColor" OpName %dead "dead" OpName %BaseColor "BaseColor" OpName %param "param" OpName %param_0 "param" %void = OpTypeVoid %13 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %17 = OpTypeFunction %v4float %_ptr_Function_v4float %_ptr_Function_v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %main = OpFunction %void None %13 %20 = OpLabel %dead = OpVariable %_ptr_Function_v4float Function %param = OpVariable %_ptr_Function_v4float Function %param_0 = OpVariable %_ptr_Function_v4float Function %21 = OpLoad %v4float %dead OpStore %param %21 %22 = OpLoad %v4float %BaseColor OpStore %param_0 %22 %23 = OpFunctionCall %v4float %foo_vf4_vf4_ %param %param_0 OpStore %gl_FragColor %23 OpReturn OpFunctionEnd )"; const std::string defs_after = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragColor %BaseColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %foo_vf4_vf4_ "foo(vf4;vf4;" OpName %v1 "v1" OpName %v2 "v2" OpName %gl_FragColor "gl_FragColor" OpName %dead "dead" OpName %BaseColor "BaseColor" OpName %param "param" OpName %param_0 "param" %void = OpTypeVoid %13 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %17 = OpTypeFunction %v4float %_ptr_Function_v4float %_ptr_Function_v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %main = OpFunction %void None %13 %20 = OpLabel %dead = OpVariable %_ptr_Function_v4float Function %param = OpVariable %_ptr_Function_v4float Function %param_0 = OpVariable %_ptr_Function_v4float Function %21 = OpLoad %v4float %dead OpStore %param %21 %22 = OpLoad %v4float %BaseColor OpStore %param_0 %22 %23 = OpFunctionCall %v4float %foo_vf4_vf4_ %param %param_0 OpStore %gl_FragColor %23 OpReturn OpFunctionEnd )"; const std::string func_before = R"(%foo_vf4_vf4_ = OpFunction %v4float None %17 %v1 = OpFunctionParameter %_ptr_Function_v4float %v2 = OpFunctionParameter %_ptr_Function_v4float %24 = OpLabel %t = OpVariable %_ptr_Function_v4float Function %25 = OpLoad %v4float %v1 %26 = OpFNegate %v4float %25 OpStore %t %26 %27 = OpLoad %v4float %v2 OpReturnValue %27 OpFunctionEnd )"; const std::string func_after = R"(%foo_vf4_vf4_ = OpFunction %v4float None %17 %v1 = OpFunctionParameter %_ptr_Function_v4float %v2 = OpFunctionParameter %_ptr_Function_v4float %24 = OpLabel %27 = OpLoad %v4float %v2 OpReturnValue %27 OpFunctionEnd )"; SinglePassRunAndCheck(defs_before + func_before, defs_after + func_after, true, true); } TEST_F(AggressiveDCETest, ElimOpaque) { // SPIR-V not representable from GLSL; not generatable from HLSL // for the moment. const std::string defs_before = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %outColor %texCoords OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %S_t "S_t" OpMemberName %S_t 0 "v0" OpMemberName %S_t 1 "v1" OpMemberName %S_t 2 "smp" OpName %outColor "outColor" OpName %sampler15 "sampler15" OpName %s0 "s0" OpName %texCoords "texCoords" OpDecorate %sampler15 DescriptorSet 0 %void = OpTypeVoid %9 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %outColor = OpVariable %_ptr_Output_v4float Output %14 = OpTypeImage %float 2D 0 0 0 1 Unknown %15 = OpTypeSampledImage %14 %S_t = OpTypeStruct %v2float %v2float %15 %_ptr_Function_S_t = OpTypePointer Function %S_t %17 = OpTypeFunction %void %_ptr_Function_S_t %_ptr_UniformConstant_15 = OpTypePointer UniformConstant %15 %_ptr_Function_15 = OpTypePointer Function %15 %sampler15 = OpVariable %_ptr_UniformConstant_15 UniformConstant %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_2 = OpConstant %int 2 %_ptr_Function_v2float = OpTypePointer Function %v2float %_ptr_Input_v2float = OpTypePointer Input %v2float %texCoords = OpVariable %_ptr_Input_v2float Input )"; const std::string defs_after = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %outColor %texCoords OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %outColor "outColor" OpName %sampler15 "sampler15" OpName %texCoords "texCoords" OpDecorate %sampler15 DescriptorSet 0 %void = OpTypeVoid %9 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %outColor = OpVariable %_ptr_Output_v4float Output %14 = OpTypeImage %float 2D 0 0 0 1 Unknown %15 = OpTypeSampledImage %14 %_ptr_UniformConstant_15 = OpTypePointer UniformConstant %15 %sampler15 = OpVariable %_ptr_UniformConstant_15 UniformConstant %_ptr_Input_v2float = OpTypePointer Input %v2float %texCoords = OpVariable %_ptr_Input_v2float Input )"; const std::string func_before = R"(%main = OpFunction %void None %9 %25 = OpLabel %s0 = OpVariable %_ptr_Function_S_t Function %26 = OpLoad %v2float %texCoords %27 = OpLoad %S_t %s0 %28 = OpCompositeInsert %S_t %26 %27 0 %29 = OpLoad %15 %sampler15 %30 = OpCompositeInsert %S_t %29 %28 2 OpStore %s0 %30 %31 = OpImageSampleImplicitLod %v4float %29 %26 OpStore %outColor %31 OpReturn OpFunctionEnd )"; const std::string func_after = R"(%main = OpFunction %void None %9 %25 = OpLabel %26 = OpLoad %v2float %texCoords %29 = OpLoad %15 %sampler15 %31 = OpImageSampleImplicitLod %v4float %29 %26 OpStore %outColor %31 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(defs_before + func_before, defs_after + func_after, true, true); } TEST_F(AggressiveDCETest, NoParamStoreElim) { // Should not eliminate stores to params // // #version 450 // // layout(location = 0) in vec4 BaseColor; // layout(location = 0) out vec4 OutColor; // // void foo(in vec4 v1, out vec4 v2) // { // v2 = -v1; // } // // void main() // { // foo(BaseColor, OutColor); // } const std::string assembly = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %foo_vf4_vf4_ "foo(vf4;vf4;" OpName %v1 "v1" OpName %v2 "v2" OpName %BaseColor "BaseColor" OpName %OutColor "OutColor" OpName %param "param" OpName %param_0 "param" OpDecorate %BaseColor Location 0 OpDecorate %OutColor Location 0 %void = OpTypeVoid %11 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %15 = OpTypeFunction %void %_ptr_Function_v4float %_ptr_Function_v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %11 %18 = OpLabel %param = OpVariable %_ptr_Function_v4float Function %param_0 = OpVariable %_ptr_Function_v4float Function %19 = OpLoad %v4float %BaseColor OpStore %param %19 %20 = OpFunctionCall %void %foo_vf4_vf4_ %param %param_0 %21 = OpLoad %v4float %param_0 OpStore %OutColor %21 OpReturn OpFunctionEnd %foo_vf4_vf4_ = OpFunction %void None %15 %v1 = OpFunctionParameter %_ptr_Function_v4float %v2 = OpFunctionParameter %_ptr_Function_v4float %22 = OpLabel %23 = OpLoad %v4float %v1 %24 = OpFNegate %v4float %23 OpStore %v2 %24 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(assembly, assembly, true, true); } TEST_F(AggressiveDCETest, PrivateStoreElimInEntryNoCalls) { // Eliminate stores to private in entry point with no calls // Note: Not legal GLSL // // layout(location = 0) in vec4 BaseColor; // layout(location = 1) in vec4 Dead; // layout(location = 0) out vec4 OutColor; // // private vec4 dv; // // void main() // { // vec4 v = BaseColor; // dv = Dead; // OutColor = v; // } const std::string spirv = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %Dead %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" ; CHECK-NOT: OpName %dv "dv" OpName %dv "dv" OpName %Dead "Dead" OpName %OutColor "OutColor" OpDecorate %BaseColor Location 0 OpDecorate %Dead Location 1 OpDecorate %OutColor Location 0 %void = OpTypeVoid %9 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float ; CHECK-NOT: OpTypePointer Private %_ptr_Private_v4float = OpTypePointer Private %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %Dead = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float ; CHECK-NOT: %dv = OpVariable %dv = OpVariable %_ptr_Private_v4float Private %OutColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %9 %16 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %17 = OpLoad %v4float %BaseColor OpStore %v %17 %18 = OpLoad %v4float %Dead ; CHECK-NOT: OpStore %dv OpStore %dv %18 %19 = OpLoad %v4float %v %20 = OpFNegate %v4float %19 OpStore %OutColor %20 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(spirv, true); } TEST_F(AggressiveDCETest, NoPrivateStoreElimIfLoad) { // Should not eliminate stores to private when there is a load // Note: Not legal GLSL // // #version 450 // // layout(location = 0) in vec4 BaseColor; // layout(location = 0) out vec4 OutColor; // // private vec4 pv; // // void main() // { // pv = BaseColor; // OutColor = pv; // } const std::string assembly = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %pv "pv" OpName %BaseColor "BaseColor" OpName %OutColor "OutColor" OpDecorate %BaseColor Location 0 OpDecorate %OutColor Location 0 %void = OpTypeVoid %7 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Private_v4float = OpTypePointer Private %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %pv = OpVariable %_ptr_Private_v4float Private %main = OpFunction %void None %7 %13 = OpLabel %14 = OpLoad %v4float %BaseColor OpStore %pv %14 %15 = OpLoad %v4float %pv %16 = OpFNegate %v4float %15 OpStore %OutColor %16 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(assembly, assembly, true, true); } TEST_F(AggressiveDCETest, NoPrivateStoreElimWithCall) { // Should not eliminate stores to private when function contains call // Note: Not legal GLSL // // #version 450 // // layout(location = 0) in vec4 BaseColor; // layout(location = 0) out vec4 OutColor; // // private vec4 v1; // // void foo() // { // OutColor = -v1; // } // // void main() // { // v1 = BaseColor; // foo(); // } const std::string assembly = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %OutColor %BaseColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %foo_ "foo(" OpName %OutColor "OutColor" OpName %v1 "v1" OpName %BaseColor "BaseColor" OpDecorate %OutColor Location 0 OpDecorate %BaseColor Location 0 %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %_ptr_Private_v4float = OpTypePointer Private %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %v1 = OpVariable %_ptr_Private_v4float Private %BaseColor = OpVariable %_ptr_Input_v4float Input %main = OpFunction %void None %8 %14 = OpLabel %15 = OpLoad %v4float %BaseColor OpStore %v1 %15 %16 = OpFunctionCall %void %foo_ OpReturn OpFunctionEnd %foo_ = OpFunction %void None %8 %17 = OpLabel %18 = OpLoad %v4float %v1 %19 = OpFNegate %v4float %18 OpStore %OutColor %19 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(assembly, assembly, true, true); } TEST_F(AggressiveDCETest, NoPrivateStoreElimInNonEntry) { // Should not eliminate stores to private when function is not entry point // Note: Not legal GLSL // // #version 450 // // layout(location = 0) in vec4 BaseColor; // layout(location = 0) out vec4 OutColor; // // private vec4 v1; // // void foo() // { // v1 = BaseColor; // } // // void main() // { // foo(); // OutColor = -v1; // } const std::string assembly = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %foo_ "foo(" OpName %v1 "v1" OpName %BaseColor "BaseColor" OpName %OutColor "OutColor" OpDecorate %BaseColor Location 0 OpDecorate %OutColor Location 0 %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Private_v4float = OpTypePointer Private %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %v1 = OpVariable %_ptr_Private_v4float Private %OutColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %8 %14 = OpLabel %15 = OpFunctionCall %void %foo_ %16 = OpLoad %v4float %v1 %17 = OpFNegate %v4float %16 OpStore %OutColor %17 OpReturn OpFunctionEnd %foo_ = OpFunction %void None %8 %18 = OpLabel %19 = OpLoad %v4float %BaseColor OpStore %v1 %19 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(assembly, assembly, true, true); } TEST_F(AggressiveDCETest, WorkgroupStoreElimInEntryNoCalls) { // Eliminate stores to private in entry point with no calls // Note: Not legal GLSL // // layout(location = 0) in vec4 BaseColor; // layout(location = 1) in vec4 Dead; // layout(location = 0) out vec4 OutColor; // // workgroup vec4 dv; // // void main() // { // vec4 v = BaseColor; // dv = Dead; // OutColor = v; // } const std::string spirv = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %Dead %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" ; CHECK-NOT: OpName %dv "dv" OpName %dv "dv" OpName %Dead "Dead" OpName %OutColor "OutColor" OpDecorate %BaseColor Location 0 OpDecorate %Dead Location 1 OpDecorate %OutColor Location 0 %void = OpTypeVoid %9 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float ; CHECK-NOT: OpTypePointer Workgroup %_ptr_Workgroup_v4float = OpTypePointer Workgroup %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %Dead = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float ; CHECK-NOT: %dv = OpVariable %dv = OpVariable %_ptr_Workgroup_v4float Workgroup %OutColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %9 %16 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %17 = OpLoad %v4float %BaseColor OpStore %v %17 %18 = OpLoad %v4float %Dead ; CHECK-NOT: OpStore %dv OpStore %dv %18 %19 = OpLoad %v4float %v %20 = OpFNegate %v4float %19 OpStore %OutColor %20 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(spirv, true); } TEST_F(AggressiveDCETest, EliminateDeadIfThenElse) { // #version 450 // // layout(location = 0) in vec4 BaseColor; // layout(location = 0) out vec4 OutColor; // // void main() // { // float d; // if (BaseColor.x == 0) // d = BaseColor.y; // else // d = BaseColor.z; // OutColor = vec4(1.0,1.0,1.0,1.0); // } const std::string spirv = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %BaseColor "BaseColor" OpName %d "d" OpName %OutColor "OutColor" OpDecorate %BaseColor Location 0 OpDecorate %OutColor Location 0 %void = OpTypeVoid %7 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %float_0 = OpConstant %float 0 %bool = OpTypeBool %_ptr_Function_float = OpTypePointer Function %float %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %float_1 = OpConstant %float 1 %21 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 ; CHECK: = OpFunction %void ; CHECK-NEXT: %22 = OpLabel ; CHECK-NEXT: OpBranch %26 ; CHECK-NEXT: %26 = OpLabel %main = OpFunction %void None %7 %22 = OpLabel %d = OpVariable %_ptr_Function_float Function %23 = OpAccessChain %_ptr_Input_float %BaseColor %uint_0 %24 = OpLoad %float %23 %25 = OpFOrdEqual %bool %24 %float_0 OpSelectionMerge %26 None OpBranchConditional %25 %27 %28 %27 = OpLabel %29 = OpAccessChain %_ptr_Input_float %BaseColor %uint_1 %30 = OpLoad %float %29 OpStore %d %30 OpBranch %26 %28 = OpLabel %31 = OpAccessChain %_ptr_Input_float %BaseColor %uint_2 %32 = OpLoad %float %31 OpStore %d %32 OpBranch %26 %26 = OpLabel OpStore %OutColor %21 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(spirv, true); } TEST_F(AggressiveDCETest, EliminateDeadIfThen) { // #version 450 // // layout(location = 0) in vec4 BaseColor; // layout(location = 0) out vec4 OutColor; // // void main() // { // float d; // if (BaseColor.x == 0) // d = BaseColor.y; // OutColor = vec4(1.0,1.0,1.0,1.0); // } const std::string spirv = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %BaseColor "BaseColor" OpName %d "d" OpName %OutColor "OutColor" OpDecorate %BaseColor Location 0 OpDecorate %OutColor Location 0 %void = OpTypeVoid %7 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %float_0 = OpConstant %float 0 %bool = OpTypeBool %_ptr_Function_float = OpTypePointer Function %float %uint_1 = OpConstant %uint 1 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %float_1 = OpConstant %float 1 %20 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 ; CHECK: = OpFunction ; CHECK-NEXT: %21 = OpLabel ; CHECK-NEXT: OpBranch [[target:%\w+]] ; CHECK-NEXT: [[target]] = OpLabel %main = OpFunction %void None %7 %21 = OpLabel %d = OpVariable %_ptr_Function_float Function %22 = OpAccessChain %_ptr_Input_float %BaseColor %uint_0 %23 = OpLoad %float %22 %24 = OpFOrdEqual %bool %23 %float_0 OpSelectionMerge %25 None OpBranchConditional %24 %26 %25 %26 = OpLabel %27 = OpAccessChain %_ptr_Input_float %BaseColor %uint_1 %28 = OpLoad %float %27 OpStore %d %28 OpBranch %25 %25 = OpLabel OpStore %OutColor %20 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(spirv, true); } TEST_F(AggressiveDCETest, EliminateDeadSwitch) { // #version 450 // // layout(location = 0) in vec4 BaseColor; // layout(location = 1) in flat int x; // layout(location = 0) out vec4 OutColor; // // void main() // { // float d; // switch (x) { // case 0: // d = BaseColor.y; // } // OutColor = vec4(1.0,1.0,1.0,1.0); // } const std::string spirv = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %x %BaseColor %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %x "x" OpName %d "d" OpName %BaseColor "BaseColor" OpName %OutColor "OutColor" OpDecorate %x Flat OpDecorate %x Location 1 OpDecorate %BaseColor Location 0 OpDecorate %OutColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %x = OpVariable %_ptr_Input_int Input %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_ptr_Input_float = OpTypePointer Input %float %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %float_1 = OpConstant %float 1 %27 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 ; CHECK: = OpFunction ; CHECK-NEXT: = OpLabel ; CHECK-NEXT: OpBranch [[target:%\w+]] ; CHECK-NEXT: [[target]] = OpLabel %main = OpFunction %void None %3 %5 = OpLabel %d = OpVariable %_ptr_Function_float Function %9 = OpLoad %int %x OpSelectionMerge %11 None OpSwitch %9 %11 0 %10 %10 = OpLabel %21 = OpAccessChain %_ptr_Input_float %BaseColor %uint_1 %22 = OpLoad %float %21 OpStore %d %22 OpBranch %11 %11 = OpLabel OpStore %OutColor %27 OpReturn OpFunctionEnd)"; SinglePassRunAndMatch(spirv, true); } TEST_F(AggressiveDCETest, EliminateDeadIfThenElseNested) { // #version 450 // // layout(location = 0) in vec4 BaseColor; // layout(location = 0) out vec4 OutColor; // // void main() // { // float d; // if (BaseColor.x == 0) // if (BaseColor.y == 0) // d = 0.0; // else // d = 0.25; // else // if (BaseColor.y == 0) // d = 0.5; // else // d = 0.75; // OutColor = vec4(1.0,1.0,1.0,1.0); // } const std::string spirv = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %BaseColor "BaseColor" OpName %d "d" OpName %OutColor "OutColor" OpDecorate %BaseColor Location 0 OpDecorate %OutColor Location 0 %void = OpTypeVoid %7 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %float_0 = OpConstant %float 0 %bool = OpTypeBool %uint_1 = OpConstant %uint 1 %_ptr_Function_float = OpTypePointer Function %float %float_0_25 = OpConstant %float 0.25 %float_0_5 = OpConstant %float 0.5 %float_0_75 = OpConstant %float 0.75 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %float_1 = OpConstant %float 1 %23 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 ; CHECK: = OpFunction ; CHECK-NEXT: = OpLabel ; CHECK-NEXT: OpBranch [[target:%\w+]] ; CHECK-NEXT: [[target]] = OpLabel ; CHECK-NOT: OpLabel %main = OpFunction %void None %7 %24 = OpLabel %d = OpVariable %_ptr_Function_float Function %25 = OpAccessChain %_ptr_Input_float %BaseColor %uint_0 %26 = OpLoad %float %25 %27 = OpFOrdEqual %bool %26 %float_0 OpSelectionMerge %28 None OpBranchConditional %27 %29 %30 %29 = OpLabel %31 = OpAccessChain %_ptr_Input_float %BaseColor %uint_1 %32 = OpLoad %float %31 %33 = OpFOrdEqual %bool %32 %float_0 OpSelectionMerge %34 None OpBranchConditional %33 %35 %36 %35 = OpLabel OpStore %d %float_0 OpBranch %34 %36 = OpLabel OpStore %d %float_0_25 OpBranch %34 %34 = OpLabel OpBranch %28 %30 = OpLabel %37 = OpAccessChain %_ptr_Input_float %BaseColor %uint_1 %38 = OpLoad %float %37 %39 = OpFOrdEqual %bool %38 %float_0 OpSelectionMerge %40 None OpBranchConditional %39 %41 %42 %41 = OpLabel OpStore %d %float_0_5 OpBranch %40 %42 = OpLabel OpStore %d %float_0_75 OpBranch %40 %40 = OpLabel OpBranch %28 %28 = OpLabel OpStore %OutColor %23 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(spirv, true); } TEST_F(AggressiveDCETest, NoEliminateLiveIfThenElse) { // #version 450 // // layout(location = 0) in vec4 BaseColor; // layout(location = 0) out vec4 OutColor; // // void main() // { // float t; // if (BaseColor.x == 0) // t = BaseColor.y; // else // t = BaseColor.z; // OutColor = vec4(t); // } const std::string assembly = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %BaseColor "BaseColor" OpName %t "t" OpName %OutColor "OutColor" OpDecorate %BaseColor Location 0 OpDecorate %OutColor Location 0 %void = OpTypeVoid %7 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %float_0 = OpConstant %float 0 %bool = OpTypeBool %_ptr_Function_float = OpTypePointer Function %float %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %7 %20 = OpLabel %t = OpVariable %_ptr_Function_float Function %21 = OpAccessChain %_ptr_Input_float %BaseColor %uint_0 %22 = OpLoad %float %21 %23 = OpFOrdEqual %bool %22 %float_0 OpSelectionMerge %24 None OpBranchConditional %23 %25 %26 %25 = OpLabel %27 = OpAccessChain %_ptr_Input_float %BaseColor %uint_1 %28 = OpLoad %float %27 OpStore %t %28 OpBranch %24 %26 = OpLabel %29 = OpAccessChain %_ptr_Input_float %BaseColor %uint_2 %30 = OpLoad %float %29 OpStore %t %30 OpBranch %24 %24 = OpLabel %31 = OpLoad %float %t %32 = OpCompositeConstruct %v4float %31 %31 %31 %31 OpStore %OutColor %32 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(assembly, assembly, true, true); } TEST_F(AggressiveDCETest, NoEliminateLiveIfThenElseNested) { // #version 450 // // layout(location = 0) in vec4 BaseColor; // layout(location = 0) out vec4 OutColor; // // void main() // { // float t; // if (BaseColor.x == 0) // if (BaseColor.y == 0) // t = 0.0; // else // t = 0.25; // else // if (BaseColor.y == 0) // t = 0.5; // else // t = 0.75; // OutColor = vec4(t); // } const std::string assembly = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %BaseColor "BaseColor" OpName %t "t" OpName %OutColor "OutColor" OpDecorate %BaseColor Location 0 OpDecorate %OutColor Location 0 %void = OpTypeVoid %7 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %float_0 = OpConstant %float 0 %bool = OpTypeBool %uint_1 = OpConstant %uint 1 %_ptr_Function_float = OpTypePointer Function %float %float_0_25 = OpConstant %float 0.25 %float_0_5 = OpConstant %float 0.5 %float_0_75 = OpConstant %float 0.75 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %7 %22 = OpLabel %t = OpVariable %_ptr_Function_float Function %23 = OpAccessChain %_ptr_Input_float %BaseColor %uint_0 %24 = OpLoad %float %23 %25 = OpFOrdEqual %bool %24 %float_0 OpSelectionMerge %26 None OpBranchConditional %25 %27 %28 %27 = OpLabel %29 = OpAccessChain %_ptr_Input_float %BaseColor %uint_1 %30 = OpLoad %float %29 %31 = OpFOrdEqual %bool %30 %float_0 OpSelectionMerge %32 None OpBranchConditional %31 %33 %34 %33 = OpLabel OpStore %t %float_0 OpBranch %32 %34 = OpLabel OpStore %t %float_0_25 OpBranch %32 %32 = OpLabel OpBranch %26 %28 = OpLabel %35 = OpAccessChain %_ptr_Input_float %BaseColor %uint_1 %36 = OpLoad %float %35 %37 = OpFOrdEqual %bool %36 %float_0 OpSelectionMerge %38 None OpBranchConditional %37 %39 %40 %39 = OpLabel OpStore %t %float_0_5 OpBranch %38 %40 = OpLabel OpStore %t %float_0_75 OpBranch %38 %38 = OpLabel OpBranch %26 %26 = OpLabel %41 = OpLoad %float %t %42 = OpCompositeConstruct %v4float %41 %41 %41 %41 OpStore %OutColor %42 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(assembly, assembly, true, true); } TEST_F(AggressiveDCETest, NoEliminateIfWithPhi) { // Note: Assembly hand-optimized from GLSL // // #version 450 // // layout(location = 0) in vec4 BaseColor; // layout(location = 0) out vec4 OutColor; // // void main() // { // float t; // if (BaseColor.x == 0) // t = 0.0; // else // t = 1.0; // OutColor = vec4(t); // } const std::string assembly = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %BaseColor "BaseColor" OpName %OutColor "OutColor" OpDecorate %BaseColor Location 0 OpDecorate %OutColor Location 0 %void = OpTypeVoid %6 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %float_0 = OpConstant %float 0 %bool = OpTypeBool %float_1 = OpConstant %float 1 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %6 %17 = OpLabel %18 = OpAccessChain %_ptr_Input_float %BaseColor %uint_0 %19 = OpLoad %float %18 %20 = OpFOrdEqual %bool %19 %float_0 OpSelectionMerge %21 None OpBranchConditional %20 %22 %23 %22 = OpLabel OpBranch %21 %23 = OpLabel OpBranch %21 %21 = OpLabel %24 = OpPhi %float %float_0 %22 %float_1 %23 %25 = OpCompositeConstruct %v4float %24 %24 %24 %24 OpStore %OutColor %25 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(assembly, assembly, true, true); } TEST_F(AggressiveDCETest, NoEliminateIfBreak) { // Note: Assembly optimized from GLSL // // #version 450 // // layout(location=0) in vec4 InColor; // layout(location=0) out vec4 OutColor; // // void main() // { // float f = 0.0; // for (;;) { // f += 2.0; // if (f > 20.0) // break; // } // // OutColor = InColor / f; // } const std::string assembly = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %OutColor %InColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %f "f" OpName %OutColor "OutColor" OpName %InColor "InColor" OpDecorate %OutColor Location 0 OpDecorate %InColor Location 0 %void = OpTypeVoid %7 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %float_2 = OpConstant %float 2 %float_20 = OpConstant %float 20 %bool = OpTypeBool %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %_ptr_Input_v4float = OpTypePointer Input %v4float %InColor = OpVariable %_ptr_Input_v4float Input %main = OpFunction %void None %7 %17 = OpLabel %f = OpVariable %_ptr_Function_float Function OpStore %f %float_0 OpBranch %18 %18 = OpLabel OpLoopMerge %19 %20 None OpBranch %21 %21 = OpLabel %22 = OpLoad %float %f %23 = OpFAdd %float %22 %float_2 OpStore %f %23 %24 = OpLoad %float %f %25 = OpFOrdGreaterThan %bool %24 %float_20 OpSelectionMerge %26 None OpBranchConditional %25 %27 %26 %27 = OpLabel OpBranch %19 %26 = OpLabel OpBranch %20 %20 = OpLabel OpBranch %18 %19 = OpLabel %28 = OpLoad %v4float %InColor %29 = OpLoad %float %f %30 = OpCompositeConstruct %v4float %29 %29 %29 %29 %31 = OpFDiv %v4float %28 %30 OpStore %OutColor %31 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(assembly, assembly, true, true); } TEST_F(AggressiveDCETest, NoEliminateIfBreak2) { // Do not eliminate break as conditional branch with merge instruction // Note: SPIR-V edited to add merge instruction before break. // // #version 430 // // layout(std430) buffer U_t // { // float g_F[10]; // }; // // layout(location = 0)out float o; // // void main(void) // { // float s = 0.0; // for (int i=0; i<10; i++) // s += g_F[i]; // o = s; // } const std::string assembly = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %o OpExecutionMode %main OriginUpperLeft OpSource GLSL 430 OpName %main "main" OpName %s "s" OpName %i "i" OpName %U_t "U_t" OpMemberName %U_t 0 "g_F" OpName %_ "" OpName %o "o" OpDecorate %_arr_float_uint_10 ArrayStride 4 OpMemberDecorate %U_t 0 Offset 0 OpDecorate %U_t BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %o Location 0 %void = OpTypeVoid %10 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %bool = OpTypeBool %uint = OpTypeInt 32 0 %uint_10 = OpConstant %uint 10 %_arr_float_uint_10 = OpTypeArray %float %uint_10 %U_t = OpTypeStruct %_arr_float_uint_10 %_ptr_Uniform_U_t = OpTypePointer Uniform %U_t %_ = OpVariable %_ptr_Uniform_U_t Uniform %_ptr_Uniform_float = OpTypePointer Uniform %float %int_1 = OpConstant %int 1 %_ptr_Output_float = OpTypePointer Output %float %o = OpVariable %_ptr_Output_float Output %main = OpFunction %void None %10 %25 = OpLabel %s = OpVariable %_ptr_Function_float Function %i = OpVariable %_ptr_Function_int Function OpStore %s %float_0 OpStore %i %int_0 OpBranch %26 %26 = OpLabel OpLoopMerge %27 %28 None OpBranch %29 %29 = OpLabel %30 = OpLoad %int %i %31 = OpSLessThan %bool %30 %int_10 OpSelectionMerge %32 None OpBranchConditional %31 %32 %27 %32 = OpLabel %33 = OpLoad %int %i %34 = OpAccessChain %_ptr_Uniform_float %_ %int_0 %33 %35 = OpLoad %float %34 %36 = OpLoad %float %s %37 = OpFAdd %float %36 %35 OpStore %s %37 OpBranch %28 %28 = OpLabel %38 = OpLoad %int %i %39 = OpIAdd %int %38 %int_1 OpStore %i %39 OpBranch %26 %27 = OpLabel %40 = OpLoad %float %s OpStore %o %40 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(assembly, assembly, true, true); } TEST_F(AggressiveDCETest, EliminateEntireUselessLoop) { // #version 140 // in vec4 BaseColor; // // layout(std140) uniform U_t // { // int g_I ; // } ; // // void main() // { // vec4 v = BaseColor; // float df = 0.0; // int i = 0; // while (i < g_I) { // df = df * 0.5; // i = i + 1; // } // gl_FragColor = v; // } const std::string predefs1 = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 )"; const std::string names_before = R"(OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" OpName %df "df" OpName %i "i" OpName %U_t "U_t" OpMemberName %U_t 0 "g_I" OpName %_ "" OpName %gl_FragColor "gl_FragColor" )"; const std::string names_after = R"(OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" OpName %gl_FragColor "gl_FragColor" )"; const std::string predefs2_before = R"(OpMemberDecorate %U_t 0 Offset 0 OpDecorate %U_t Block OpDecorate %_ DescriptorSet 0 %void = OpTypeVoid %11 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %U_t = OpTypeStruct %int %_ptr_Uniform_U_t = OpTypePointer Uniform %U_t %_ = OpVariable %_ptr_Uniform_U_t Uniform %_ptr_Uniform_int = OpTypePointer Uniform %int %bool = OpTypeBool %float_0_5 = OpConstant %float 0.5 %int_1 = OpConstant %int 1 %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output )"; const std::string predefs2_after = R"(%void = OpTypeVoid %11 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output )"; const std::string func_before = R"(%main = OpFunction %void None %11 %27 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %df = OpVariable %_ptr_Function_float Function %i = OpVariable %_ptr_Function_int Function %28 = OpLoad %v4float %BaseColor OpStore %v %28 OpStore %df %float_0 OpStore %i %int_0 OpBranch %29 %29 = OpLabel OpLoopMerge %30 %31 None OpBranch %32 %32 = OpLabel %33 = OpLoad %int %i %34 = OpAccessChain %_ptr_Uniform_int %_ %int_0 %35 = OpLoad %int %34 %36 = OpSLessThan %bool %33 %35 OpBranchConditional %36 %37 %30 %37 = OpLabel %38 = OpLoad %float %df %39 = OpFMul %float %38 %float_0_5 OpStore %df %39 %40 = OpLoad %int %i %41 = OpIAdd %int %40 %int_1 OpStore %i %41 OpBranch %31 %31 = OpLabel OpBranch %29 %30 = OpLabel %42 = OpLoad %v4float %v OpStore %gl_FragColor %42 OpReturn OpFunctionEnd )"; const std::string func_after = R"(%main = OpFunction %void None %11 %27 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %28 = OpLoad %v4float %BaseColor OpStore %v %28 OpBranch %29 %29 = OpLabel OpBranch %30 %30 = OpLabel %42 = OpLoad %v4float %v OpStore %gl_FragColor %42 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck( predefs1 + names_before + predefs2_before + func_before, predefs1 + names_after + predefs2_after + func_after, true, true); } TEST_F(AggressiveDCETest, NoEliminateBusyLoop) { // Note: SPIR-V edited to replace AtomicAdd(i,0) with AtomicLoad(i) // // #version 450 // // layout(std430) buffer I_t // { // int g_I; // int g_I2; // }; // // layout(location = 0) out int o; // // void main(void) // { // while (atomicAdd(g_I, 0) == 0) {} // o = g_I2; // } const std::string assembly = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %o OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %I_t "I_t" OpMemberName %I_t 0 "g_I" OpMemberName %I_t 1 "g_I2" OpName %_ "" OpName %o "o" OpMemberDecorate %I_t 0 Offset 0 OpMemberDecorate %I_t 1 Offset 4 OpDecorate %I_t BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %o Location 0 %void = OpTypeVoid %7 = OpTypeFunction %void %int = OpTypeInt 32 1 %I_t = OpTypeStruct %int %int %_ptr_Uniform_I_t = OpTypePointer Uniform %I_t %_ = OpVariable %_ptr_Uniform_I_t Uniform %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %_ptr_Uniform_int = OpTypePointer Uniform %int %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %uint_0 = OpConstant %uint 0 %bool = OpTypeBool %_ptr_Output_int = OpTypePointer Output %int %o = OpVariable %_ptr_Output_int Output %main = OpFunction %void None %7 %18 = OpLabel OpBranch %19 %19 = OpLabel OpLoopMerge %20 %21 None OpBranch %22 %22 = OpLabel %23 = OpAccessChain %_ptr_Uniform_int %_ %int_0 %24 = OpAtomicLoad %int %23 %uint_1 %uint_0 %25 = OpIEqual %bool %24 %int_0 OpBranchConditional %25 %26 %20 %26 = OpLabel OpBranch %21 %21 = OpLabel OpBranch %19 %20 = OpLabel %27 = OpAccessChain %_ptr_Uniform_int %_ %int_1 %28 = OpLoad %int %27 OpStore %o %28 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(assembly, assembly, true, true); } TEST_F(AggressiveDCETest, NoEliminateLiveLoop) { // Note: SPIR-V optimized // // #version 430 // // layout(std430) buffer U_t // { // float g_F[10]; // }; // // layout(location = 0)out float o; // // void main(void) // { // float s = 0.0; // for (int i=0; i<10; i++) // s += g_F[i]; // o = s; // } const std::string assembly = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %o OpExecutionMode %main OriginUpperLeft OpSource GLSL 430 OpName %main "main" OpName %U_t "U_t" OpMemberName %U_t 0 "g_F" OpName %_ "" OpName %o "o" OpDecorate %_arr_float_uint_10 ArrayStride 4 OpMemberDecorate %U_t 0 Offset 0 OpDecorate %U_t BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %o Location 0 %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %bool = OpTypeBool %uint = OpTypeInt 32 0 %uint_10 = OpConstant %uint 10 %_arr_float_uint_10 = OpTypeArray %float %uint_10 %U_t = OpTypeStruct %_arr_float_uint_10 %_ptr_Uniform_U_t = OpTypePointer Uniform %U_t %_ = OpVariable %_ptr_Uniform_U_t Uniform %_ptr_Uniform_float = OpTypePointer Uniform %float %int_1 = OpConstant %int 1 %_ptr_Output_float = OpTypePointer Output %float %o = OpVariable %_ptr_Output_float Output %main = OpFunction %void None %8 %21 = OpLabel OpBranch %22 %22 = OpLabel %23 = OpPhi %float %float_0 %21 %24 %25 %26 = OpPhi %int %int_0 %21 %27 %25 OpLoopMerge %28 %25 None OpBranch %29 %29 = OpLabel %30 = OpSLessThan %bool %26 %int_10 OpBranchConditional %30 %31 %28 %31 = OpLabel %32 = OpAccessChain %_ptr_Uniform_float %_ %int_0 %26 %33 = OpLoad %float %32 %24 = OpFAdd %float %23 %33 OpBranch %25 %25 = OpLabel %27 = OpIAdd %int %26 %int_1 OpBranch %22 %28 = OpLabel OpStore %o %23 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(assembly, assembly, true, true); } TEST_F(AggressiveDCETest, EliminateEntireFunctionBody) { // #version 450 // // layout(location = 0) in vec4 BaseColor; // layout(location = 0) out vec4 OutColor; // // void main() // { // float d; // if (BaseColor.x == 0) // d = BaseColor.y; // else // d = BaseColor.z; // } const std::string spirv = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %BaseColor "BaseColor" OpName %d "d" OpName %OutColor "OutColor" OpDecorate %BaseColor Location 0 OpDecorate %OutColor Location 0 %void = OpTypeVoid %7 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %float_0 = OpConstant %float 0 %bool = OpTypeBool %_ptr_Function_float = OpTypePointer Function %float %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output ; CHECK: = OpFunction ; CHECK-NEXT: = OpLabel ; CHECK-NEXT: OpBranch [[target:%\w+]] ; CHECK-NEXT: [[target]] = OpLabel ; CHECK-NEXT: OpReturn ; CHECK-NEXT: OpFunctionEnd %main = OpFunction %void None %7 %20 = OpLabel %d = OpVariable %_ptr_Function_float Function %21 = OpAccessChain %_ptr_Input_float %BaseColor %uint_0 %22 = OpLoad %float %21 %23 = OpFOrdEqual %bool %22 %float_0 OpSelectionMerge %24 None OpBranchConditional %23 %25 %26 %25 = OpLabel %27 = OpAccessChain %_ptr_Input_float %BaseColor %uint_1 %28 = OpLoad %float %27 OpStore %d %28 OpBranch %24 %26 = OpLabel %29 = OpAccessChain %_ptr_Input_float %BaseColor %uint_2 %30 = OpLoad %float %29 OpStore %d %30 OpBranch %24 %24 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(spirv, true); } TEST_F(AggressiveDCETest, EliminateUselessInnerLoop) { // #version 430 // // layout(std430) buffer U_t // { // float g_F[10]; // }; // // layout(location = 0)out float o; // // void main(void) // { // float s = 0.0; // for (int i=0; i<10; i++) { // for (int j=0; j<10; j++) { // } // s += g_F[i]; // } // o = s; // } const std::string predefs_before = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %o OpExecutionMode %main OriginUpperLeft OpSource GLSL 430 OpName %main "main" OpName %s "s" OpName %i "i" OpName %j "j" OpName %U_t "U_t" OpMemberName %U_t 0 "g_F" OpName %_ "" OpName %o "o" OpDecorate %_arr_float_uint_10 ArrayStride 4 OpMemberDecorate %U_t 0 Offset 0 OpDecorate %U_t BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %o Location 0 %void = OpTypeVoid %11 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %bool = OpTypeBool %int_1 = OpConstant %int 1 %uint = OpTypeInt 32 0 %uint_10 = OpConstant %uint 10 %_arr_float_uint_10 = OpTypeArray %float %uint_10 %U_t = OpTypeStruct %_arr_float_uint_10 %_ptr_Uniform_U_t = OpTypePointer Uniform %U_t %_ = OpVariable %_ptr_Uniform_U_t Uniform %_ptr_Uniform_float = OpTypePointer Uniform %float %_ptr_Output_float = OpTypePointer Output %float %o = OpVariable %_ptr_Output_float Output )"; const std::string predefs_after = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %o OpExecutionMode %main OriginUpperLeft OpSource GLSL 430 OpName %main "main" OpName %s "s" OpName %i "i" OpName %U_t "U_t" OpMemberName %U_t 0 "g_F" OpName %_ "" OpName %o "o" OpDecorate %_arr_float_uint_10 ArrayStride 4 OpMemberDecorate %U_t 0 Offset 0 OpDecorate %U_t BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %o Location 0 %void = OpTypeVoid %11 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %bool = OpTypeBool %int_1 = OpConstant %int 1 %uint = OpTypeInt 32 0 %uint_10 = OpConstant %uint 10 %_arr_float_uint_10 = OpTypeArray %float %uint_10 %U_t = OpTypeStruct %_arr_float_uint_10 %_ptr_Uniform_U_t = OpTypePointer Uniform %U_t %_ = OpVariable %_ptr_Uniform_U_t Uniform %_ptr_Uniform_float = OpTypePointer Uniform %float %_ptr_Output_float = OpTypePointer Output %float %o = OpVariable %_ptr_Output_float Output )"; const std::string func_before = R"(%main = OpFunction %void None %11 %26 = OpLabel %s = OpVariable %_ptr_Function_float Function %i = OpVariable %_ptr_Function_int Function %j = OpVariable %_ptr_Function_int Function OpStore %s %float_0 OpStore %i %int_0 OpBranch %27 %27 = OpLabel OpLoopMerge %28 %29 None OpBranch %30 %30 = OpLabel %31 = OpLoad %int %i %32 = OpSLessThan %bool %31 %int_10 OpBranchConditional %32 %33 %28 %33 = OpLabel OpStore %j %int_0 OpBranch %34 %34 = OpLabel OpLoopMerge %35 %36 None OpBranch %37 %37 = OpLabel %38 = OpLoad %int %j %39 = OpSLessThan %bool %38 %int_10 OpBranchConditional %39 %40 %35 %40 = OpLabel OpBranch %36 %36 = OpLabel %41 = OpLoad %int %j %42 = OpIAdd %int %41 %int_1 OpStore %j %42 OpBranch %34 %35 = OpLabel %43 = OpLoad %int %i %44 = OpAccessChain %_ptr_Uniform_float %_ %int_0 %43 %45 = OpLoad %float %44 %46 = OpLoad %float %s %47 = OpFAdd %float %46 %45 OpStore %s %47 OpBranch %29 %29 = OpLabel %48 = OpLoad %int %i %49 = OpIAdd %int %48 %int_1 OpStore %i %49 OpBranch %27 %28 = OpLabel %50 = OpLoad %float %s OpStore %o %50 OpReturn OpFunctionEnd )"; const std::string func_after = R"(%main = OpFunction %void None %11 %26 = OpLabel %s = OpVariable %_ptr_Function_float Function %i = OpVariable %_ptr_Function_int Function OpStore %s %float_0 OpStore %i %int_0 OpBranch %27 %27 = OpLabel OpLoopMerge %28 %29 None OpBranch %30 %30 = OpLabel %31 = OpLoad %int %i %32 = OpSLessThan %bool %31 %int_10 OpBranchConditional %32 %33 %28 %33 = OpLabel OpBranch %34 %34 = OpLabel OpBranch %35 %35 = OpLabel %43 = OpLoad %int %i %44 = OpAccessChain %_ptr_Uniform_float %_ %int_0 %43 %45 = OpLoad %float %44 %46 = OpLoad %float %s %47 = OpFAdd %float %46 %45 OpStore %s %47 OpBranch %29 %29 = OpLabel %48 = OpLoad %int %i %49 = OpIAdd %int %48 %int_1 OpStore %i %49 OpBranch %27 %28 = OpLabel %50 = OpLoad %float %s OpStore %o %50 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck( predefs_before + func_before, predefs_after + func_after, true, true); } TEST_F(AggressiveDCETest, EliminateUselessNestedLoopWithIf) { // #version 430 // // layout(std430) buffer U_t // { // float g_F[10][10]; // }; // // layout(location = 0)out float o; // // void main(void) // { // float s = 0.0; // for (int i=0; i<10; i++) { // for (int j=0; j<10; j++) { // float t = g_F[i][j]; // if (t > 0.0) // s += t; // } // } // o = 0.0; // } const std::string predefs_before = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %o OpExecutionMode %main OriginUpperLeft OpSource GLSL 430 OpName %main "main" OpName %s "s" OpName %i "i" OpName %j "j" OpName %U_t "U_t" OpMemberName %U_t 0 "g_F" OpName %_ "" OpName %o "o" OpDecorate %_arr_float_uint_10 ArrayStride 4 OpDecorate %_arr__arr_float_uint_10_uint_10 ArrayStride 40 OpMemberDecorate %U_t 0 Offset 0 OpDecorate %U_t BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %o Location 0 %void = OpTypeVoid %12 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %bool = OpTypeBool %uint = OpTypeInt 32 0 %uint_10 = OpConstant %uint 10 %_arr_float_uint_10 = OpTypeArray %float %uint_10 %_arr__arr_float_uint_10_uint_10 = OpTypeArray %_arr_float_uint_10 %uint_10 %U_t = OpTypeStruct %_arr__arr_float_uint_10_uint_10 %_ptr_Uniform_U_t = OpTypePointer Uniform %U_t %_ = OpVariable %_ptr_Uniform_U_t Uniform %_ptr_Uniform_float = OpTypePointer Uniform %float %int_1 = OpConstant %int 1 %_ptr_Output_float = OpTypePointer Output %float %o = OpVariable %_ptr_Output_float Output )"; const std::string predefs_after = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %o OpExecutionMode %main OriginUpperLeft OpSource GLSL 430 OpName %main "main" OpName %o "o" OpDecorate %o Location 0 %void = OpTypeVoid %12 = OpTypeFunction %void %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %_ptr_Output_float = OpTypePointer Output %float %o = OpVariable %_ptr_Output_float Output )"; const std::string func_before = R"(%main = OpFunction %void None %12 %27 = OpLabel %s = OpVariable %_ptr_Function_float Function %i = OpVariable %_ptr_Function_int Function %j = OpVariable %_ptr_Function_int Function OpStore %s %float_0 OpStore %i %int_0 OpBranch %28 %28 = OpLabel OpLoopMerge %29 %30 None OpBranch %31 %31 = OpLabel %32 = OpLoad %int %i %33 = OpSLessThan %bool %32 %int_10 OpBranchConditional %33 %34 %29 %34 = OpLabel OpStore %j %int_0 OpBranch %35 %35 = OpLabel OpLoopMerge %36 %37 None OpBranch %38 %38 = OpLabel %39 = OpLoad %int %j %40 = OpSLessThan %bool %39 %int_10 OpBranchConditional %40 %41 %36 %41 = OpLabel %42 = OpLoad %int %i %43 = OpLoad %int %j %44 = OpAccessChain %_ptr_Uniform_float %_ %int_0 %42 %43 %45 = OpLoad %float %44 %46 = OpFOrdGreaterThan %bool %45 %float_0 OpSelectionMerge %47 None OpBranchConditional %46 %48 %47 %48 = OpLabel %49 = OpLoad %float %s %50 = OpFAdd %float %49 %45 OpStore %s %50 OpBranch %47 %47 = OpLabel OpBranch %37 %37 = OpLabel %51 = OpLoad %int %j %52 = OpIAdd %int %51 %int_1 OpStore %j %52 OpBranch %35 %36 = OpLabel OpBranch %30 %30 = OpLabel %53 = OpLoad %int %i %54 = OpIAdd %int %53 %int_1 OpStore %i %54 OpBranch %28 %29 = OpLabel OpStore %o %float_0 OpReturn OpFunctionEnd )"; const std::string func_after = R"(%main = OpFunction %void None %12 %27 = OpLabel OpBranch %28 %28 = OpLabel OpBranch %29 %29 = OpLabel OpStore %o %float_0 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck( predefs_before + func_before, predefs_after + func_after, true, true); } TEST_F(AggressiveDCETest, EliminateEmptyIfBeforeContinue) { // #version 430 // // layout(location = 0)out float o; // // void main(void) // { // float s = 0.0; // for (int i=0; i<10; i++) { // s += 1.0; // if (i > s) {} // } // o = s; // } const std::string predefs_before = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %3 OpExecutionMode %main OriginUpperLeft OpSource GLSL 430 OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpName %main "main" OpDecorate %3 Location 0 %void = OpTypeVoid %5 = OpTypeFunction %void %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %bool = OpTypeBool %float_1 = OpConstant %float 1 %int_1 = OpConstant %int 1 %_ptr_Output_float = OpTypePointer Output %float %3 = OpVariable %_ptr_Output_float Output )"; const std::string predefs_after = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %3 OpExecutionMode %main OriginUpperLeft OpSource GLSL 430 OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpName %main "main" OpDecorate %3 Location 0 %void = OpTypeVoid %5 = OpTypeFunction %void %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %bool = OpTypeBool %float_1 = OpConstant %float 1 %int_1 = OpConstant %int 1 %_ptr_Output_float = OpTypePointer Output %float %3 = OpVariable %_ptr_Output_float Output )"; const std::string func_before = R"(%main = OpFunction %void None %5 %16 = OpLabel OpBranch %17 %17 = OpLabel %18 = OpPhi %float %float_0 %16 %19 %20 %21 = OpPhi %int %int_0 %16 %22 %20 OpLoopMerge %23 %20 None OpBranch %24 %24 = OpLabel %25 = OpSLessThan %bool %21 %int_10 OpBranchConditional %25 %26 %23 %26 = OpLabel %19 = OpFAdd %float %18 %float_1 %27 = OpConvertFToS %int %19 %28 = OpSGreaterThan %bool %21 %27 OpSelectionMerge %20 None OpBranchConditional %28 %29 %20 %29 = OpLabel OpBranch %20 %20 = OpLabel %22 = OpIAdd %int %21 %int_1 OpBranch %17 %23 = OpLabel OpStore %3 %18 OpReturn OpFunctionEnd )"; const std::string func_after = R"(%main = OpFunction %void None %5 %16 = OpLabel OpBranch %17 %17 = OpLabel %18 = OpPhi %float %float_0 %16 %19 %20 %21 = OpPhi %int %int_0 %16 %22 %20 OpLoopMerge %23 %20 None OpBranch %24 %24 = OpLabel %25 = OpSLessThan %bool %21 %int_10 OpBranchConditional %25 %26 %23 %26 = OpLabel %19 = OpFAdd %float %18 %float_1 OpBranch %20 %20 = OpLabel %22 = OpIAdd %int %21 %int_1 OpBranch %17 %23 = OpLabel OpStore %3 %18 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck( predefs_before + func_before, predefs_after + func_after, true, true); } TEST_F(AggressiveDCETest, NoEliminateLiveNestedLoopWithIf) { // Note: SPIR-V optimized // // #version 430 // // layout(std430) buffer U_t // { // float g_F[10][10]; // }; // // layout(location = 0)out float o; // // void main(void) // { // float s = 0.0; // for (int i=0; i<10; i++) { // for (int j=0; j<10; j++) { // float t = g_F[i][j]; // if (t > 0.0) // s += t; // } // } // o = s; // } const std::string assembly = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %o OpExecutionMode %main OriginUpperLeft OpSource GLSL 430 OpName %main "main" OpName %s "s" OpName %i "i" OpName %j "j" OpName %U_t "U_t" OpMemberName %U_t 0 "g_F" OpName %_ "" OpName %o "o" OpDecorate %_arr_float_uint_10 ArrayStride 4 OpDecorate %_arr__arr_float_uint_10_uint_10 ArrayStride 40 OpMemberDecorate %U_t 0 Offset 0 OpDecorate %U_t BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %o Location 0 %void = OpTypeVoid %12 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %bool = OpTypeBool %uint = OpTypeInt 32 0 %uint_10 = OpConstant %uint 10 %_arr_float_uint_10 = OpTypeArray %float %uint_10 %_arr__arr_float_uint_10_uint_10 = OpTypeArray %_arr_float_uint_10 %uint_10 %U_t = OpTypeStruct %_arr__arr_float_uint_10_uint_10 %_ptr_Uniform_U_t = OpTypePointer Uniform %U_t %_ = OpVariable %_ptr_Uniform_U_t Uniform %_ptr_Uniform_float = OpTypePointer Uniform %float %int_1 = OpConstant %int 1 %_ptr_Output_float = OpTypePointer Output %float %o = OpVariable %_ptr_Output_float Output %main = OpFunction %void None %12 %27 = OpLabel %s = OpVariable %_ptr_Function_float Function %i = OpVariable %_ptr_Function_int Function %j = OpVariable %_ptr_Function_int Function OpStore %s %float_0 OpStore %i %int_0 OpBranch %28 %28 = OpLabel OpLoopMerge %29 %30 None OpBranch %31 %31 = OpLabel %32 = OpLoad %int %i %33 = OpSLessThan %bool %32 %int_10 OpBranchConditional %33 %34 %29 %34 = OpLabel OpStore %j %int_0 OpBranch %35 %35 = OpLabel OpLoopMerge %36 %37 None OpBranch %38 %38 = OpLabel %39 = OpLoad %int %j %40 = OpSLessThan %bool %39 %int_10 OpBranchConditional %40 %41 %36 %41 = OpLabel %42 = OpLoad %int %i %43 = OpLoad %int %j %44 = OpAccessChain %_ptr_Uniform_float %_ %int_0 %42 %43 %45 = OpLoad %float %44 %46 = OpFOrdGreaterThan %bool %45 %float_0 OpSelectionMerge %47 None OpBranchConditional %46 %48 %47 %48 = OpLabel %49 = OpLoad %float %s %50 = OpFAdd %float %49 %45 OpStore %s %50 OpBranch %47 %47 = OpLabel OpBranch %37 %37 = OpLabel %51 = OpLoad %int %j %52 = OpIAdd %int %51 %int_1 OpStore %j %52 OpBranch %35 %36 = OpLabel OpBranch %30 %30 = OpLabel %53 = OpLoad %int %i %54 = OpIAdd %int %53 %int_1 OpStore %i %54 OpBranch %28 %29 = OpLabel %55 = OpLoad %float %s OpStore %o %55 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(assembly, assembly, true, true); } TEST_F(AggressiveDCETest, NoEliminateIfContinue) { // Do not eliminate continue embedded in if construct // // #version 430 // // layout(std430) buffer U_t // { // float g_F[10]; // }; // // layout(location = 0)out float o; // // void main(void) // { // float s = 0.0; // for (int i=0; i<10; i++) { // if (i % 2 == 0) continue; // s += g_F[i]; // } // o = s; // } const std::string assembly = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %o OpExecutionMode %main OriginUpperLeft OpSource GLSL 430 OpName %main "main" OpName %s "s" OpName %i "i" OpName %U_t "U_t" OpMemberName %U_t 0 "g_F" OpName %_ "" OpName %o "o" OpDecorate %_arr_float_uint_10 ArrayStride 4 OpMemberDecorate %U_t 0 Offset 0 OpDecorate %U_t BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %o Location 0 %void = OpTypeVoid %10 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %bool = OpTypeBool %int_2 = OpConstant %int 2 %uint = OpTypeInt 32 0 %uint_10 = OpConstant %uint 10 %_arr_float_uint_10 = OpTypeArray %float %uint_10 %U_t = OpTypeStruct %_arr_float_uint_10 %_ptr_Uniform_U_t = OpTypePointer Uniform %U_t %_ = OpVariable %_ptr_Uniform_U_t Uniform %_ptr_Uniform_float = OpTypePointer Uniform %float %int_1 = OpConstant %int 1 %_ptr_Output_float = OpTypePointer Output %float %o = OpVariable %_ptr_Output_float Output %main = OpFunction %void None %10 %26 = OpLabel %s = OpVariable %_ptr_Function_float Function %i = OpVariable %_ptr_Function_int Function OpStore %s %float_0 OpStore %i %int_0 OpBranch %27 %27 = OpLabel OpLoopMerge %28 %29 None OpBranch %30 %30 = OpLabel %31 = OpLoad %int %i %32 = OpSLessThan %bool %31 %int_10 OpBranchConditional %32 %33 %28 %33 = OpLabel %34 = OpLoad %int %i %35 = OpSMod %int %34 %int_2 %36 = OpIEqual %bool %35 %int_0 OpSelectionMerge %37 None OpBranchConditional %36 %38 %37 %38 = OpLabel OpBranch %29 %37 = OpLabel %39 = OpLoad %int %i %40 = OpAccessChain %_ptr_Uniform_float %_ %int_0 %39 %41 = OpLoad %float %40 %42 = OpLoad %float %s %43 = OpFAdd %float %42 %41 OpStore %s %43 OpBranch %29 %29 = OpLabel %44 = OpLoad %int %i %45 = OpIAdd %int %44 %int_1 OpStore %i %45 OpBranch %27 %28 = OpLabel %46 = OpLoad %float %s OpStore %o %46 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(assembly, assembly, true, true); } TEST_F(AggressiveDCETest, NoEliminateIfContinue2) { // Do not eliminate continue not embedded in if construct // // #version 430 // // layout(std430) buffer U_t // { // float g_F[10]; // }; // // layout(location = 0)out float o; // // void main(void) // { // float s = 0.0; // for (int i=0; i<10; i++) { // if (i % 2 == 0) continue; // s += g_F[i]; // } // o = s; // } const std::string assembly = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %o OpExecutionMode %main OriginUpperLeft OpSource GLSL 430 OpName %main "main" OpName %s "s" OpName %i "i" OpName %U_t "U_t" OpMemberName %U_t 0 "g_F" OpName %_ "" OpName %o "o" OpDecorate %_arr_float_uint_10 ArrayStride 4 OpMemberDecorate %U_t 0 Offset 0 OpDecorate %U_t BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %o Location 0 %void = OpTypeVoid %10 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %bool = OpTypeBool %int_2 = OpConstant %int 2 %uint = OpTypeInt 32 0 %uint_10 = OpConstant %uint 10 %_arr_float_uint_10 = OpTypeArray %float %uint_10 %U_t = OpTypeStruct %_arr_float_uint_10 %_ptr_Uniform_U_t = OpTypePointer Uniform %U_t %_ = OpVariable %_ptr_Uniform_U_t Uniform %_ptr_Uniform_float = OpTypePointer Uniform %float %int_1 = OpConstant %int 1 %_ptr_Output_float = OpTypePointer Output %float %o = OpVariable %_ptr_Output_float Output %main = OpFunction %void None %10 %26 = OpLabel %s = OpVariable %_ptr_Function_float Function %i = OpVariable %_ptr_Function_int Function OpStore %s %float_0 OpStore %i %int_0 OpBranch %27 %27 = OpLabel OpLoopMerge %28 %29 None OpBranch %30 %30 = OpLabel %31 = OpLoad %int %i %32 = OpSLessThan %bool %31 %int_10 OpBranchConditional %32 %33 %28 %33 = OpLabel %34 = OpLoad %int %i %35 = OpSMod %int %34 %int_2 %36 = OpIEqual %bool %35 %int_0 OpBranchConditional %36 %29 %37 %37 = OpLabel %38 = OpLoad %int %i %39 = OpAccessChain %_ptr_Uniform_float %_ %int_0 %38 %40 = OpLoad %float %39 %41 = OpLoad %float %s %42 = OpFAdd %float %41 %40 OpStore %s %42 OpBranch %29 %29 = OpLabel %43 = OpLoad %int %i %44 = OpIAdd %int %43 %int_1 OpStore %i %44 OpBranch %27 %28 = OpLabel %45 = OpLoad %float %s OpStore %o %45 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(assembly, assembly, true, true); } TEST_F(AggressiveDCETest, NoEliminateIfContinue3) { // Do not eliminate continue as conditional branch with merge instruction // Note: SPIR-V edited to add merge instruction before continue. // // #version 430 // // layout(std430) buffer U_t // { // float g_F[10]; // }; // // layout(location = 0)out float o; // // void main(void) // { // float s = 0.0; // for (int i=0; i<10; i++) { // if (i % 2 == 0) continue; // s += g_F[i]; // } // o = s; // } const std::string assembly = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %o OpExecutionMode %main OriginUpperLeft OpSource GLSL 430 OpName %main "main" OpName %s "s" OpName %i "i" OpName %U_t "U_t" OpMemberName %U_t 0 "g_F" OpName %_ "" OpName %o "o" OpDecorate %_arr_float_uint_10 ArrayStride 4 OpMemberDecorate %U_t 0 Offset 0 OpDecorate %U_t BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %o Location 0 %void = OpTypeVoid %10 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %bool = OpTypeBool %int_2 = OpConstant %int 2 %uint = OpTypeInt 32 0 %uint_10 = OpConstant %uint 10 %_arr_float_uint_10 = OpTypeArray %float %uint_10 %U_t = OpTypeStruct %_arr_float_uint_10 %_ptr_Uniform_U_t = OpTypePointer Uniform %U_t %_ = OpVariable %_ptr_Uniform_U_t Uniform %_ptr_Uniform_float = OpTypePointer Uniform %float %int_1 = OpConstant %int 1 %_ptr_Output_float = OpTypePointer Output %float %o = OpVariable %_ptr_Output_float Output %main = OpFunction %void None %10 %26 = OpLabel %s = OpVariable %_ptr_Function_float Function %i = OpVariable %_ptr_Function_int Function OpStore %s %float_0 OpStore %i %int_0 OpBranch %27 %27 = OpLabel OpLoopMerge %28 %29 None OpBranch %30 %30 = OpLabel %31 = OpLoad %int %i %32 = OpSLessThan %bool %31 %int_10 OpBranchConditional %32 %33 %28 %33 = OpLabel %34 = OpLoad %int %i %35 = OpSMod %int %34 %int_2 %36 = OpIEqual %bool %35 %int_0 OpSelectionMerge %37 None OpBranchConditional %36 %29 %37 %37 = OpLabel %38 = OpLoad %int %i %39 = OpAccessChain %_ptr_Uniform_float %_ %int_0 %38 %40 = OpLoad %float %39 %41 = OpLoad %float %s %42 = OpFAdd %float %41 %40 OpStore %s %42 OpBranch %29 %29 = OpLabel %43 = OpLoad %int %i %44 = OpIAdd %int %43 %int_1 OpStore %i %44 OpBranch %27 %28 = OpLabel %45 = OpLoad %float %s OpStore %o %45 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(assembly, assembly, true, true); } // This is not valid input and ADCE does not support variable pointers and only // supports shaders. TEST_F(AggressiveDCETest, PointerVariable) { // ADCE is able to handle code that contains a load whose base address // comes from a load and not an OpVariable. I want to see an instruction // removed to be sure that ADCE is not exiting early. const std::string before = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" %2 OpExecutionMode %1 OriginUpperLeft OpMemberDecorate %_struct_3 0 Offset 0 OpDecorate %_runtimearr__struct_3 ArrayStride 16 OpMemberDecorate %_struct_5 0 Offset 0 OpDecorate %_struct_5 BufferBlock OpMemberDecorate %_struct_6 0 Offset 0 OpDecorate %_struct_6 BufferBlock OpDecorate %2 Location 0 OpDecorate %7 DescriptorSet 0 OpDecorate %7 Binding 0 OpDecorate %8 DescriptorSet 0 OpDecorate %8 Binding 1 %void = OpTypeVoid %10 = OpTypeFunction %void %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %_struct_3 = OpTypeStruct %v4float %_runtimearr__struct_3 = OpTypeRuntimeArray %_struct_3 %_struct_5 = OpTypeStruct %_runtimearr__struct_3 %_ptr_Uniform__struct_5 = OpTypePointer Uniform %_struct_5 %_struct_6 = OpTypeStruct %int %_ptr_Uniform__struct_6 = OpTypePointer Uniform %_struct_6 %_ptr_Function__ptr_Uniform__struct_5 = OpTypePointer Function %_ptr_Uniform__struct_5 %_ptr_Function__ptr_Uniform__struct_6 = OpTypePointer Function %_ptr_Uniform__struct_6 %int_0 = OpConstant %int 0 %uint_0 = OpConstant %uint 0 %2 = OpVariable %_ptr_Output_v4float Output %7 = OpVariable %_ptr_Uniform__struct_5 Uniform %8 = OpVariable %_ptr_Uniform__struct_6 Uniform %1 = OpFunction %void None %10 %23 = OpLabel %24 = OpVariable %_ptr_Function__ptr_Uniform__struct_5 Function OpStore %24 %7 %26 = OpLoad %_ptr_Uniform__struct_5 %24 %27 = OpAccessChain %_ptr_Uniform_v4float %26 %int_0 %uint_0 %int_0 %28 = OpLoad %v4float %27 %29 = OpCopyObject %v4float %28 OpStore %2 %28 OpReturn OpFunctionEnd )"; const std::string after = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" %2 OpExecutionMode %1 OriginUpperLeft OpMemberDecorate %_struct_3 0 Offset 0 OpDecorate %_runtimearr__struct_3 ArrayStride 16 OpMemberDecorate %_struct_5 0 Offset 0 OpDecorate %_struct_5 BufferBlock OpDecorate %2 Location 0 OpDecorate %7 DescriptorSet 0 OpDecorate %7 Binding 0 %void = OpTypeVoid %10 = OpTypeFunction %void %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %_struct_3 = OpTypeStruct %v4float %_runtimearr__struct_3 = OpTypeRuntimeArray %_struct_3 %_struct_5 = OpTypeStruct %_runtimearr__struct_3 %_ptr_Uniform__struct_5 = OpTypePointer Uniform %_struct_5 %_ptr_Function__ptr_Uniform__struct_5 = OpTypePointer Function %_ptr_Uniform__struct_5 %int_0 = OpConstant %int 0 %uint_0 = OpConstant %uint 0 %2 = OpVariable %_ptr_Output_v4float Output %7 = OpVariable %_ptr_Uniform__struct_5 Uniform %1 = OpFunction %void None %10 %23 = OpLabel %24 = OpVariable %_ptr_Function__ptr_Uniform__struct_5 Function OpStore %24 %7 %25 = OpLoad %_ptr_Uniform__struct_5 %24 %26 = OpAccessChain %_ptr_Uniform_v4float %25 %int_0 %uint_0 %int_0 %27 = OpLoad %v4float %26 OpStore %2 %27 OpReturn OpFunctionEnd )"; // The input is not valid and ADCE only supports shaders, but not variable // pointers. Workaround this by enabling relaxed logical pointers in the // validator. ValidatorOptions()->relax_logical_pointer = true; SinglePassRunAndCheck(before, after, true, true); } // %dead is unused. Make sure we remove it along with its name. TEST_F(AggressiveDCETest, RemoveUnreferenced) { const std::string before = R"(OpCapability Shader OpCapability Linkage %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 150 OpName %main "main" OpName %dead "dead" %void = OpTypeVoid %5 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Private_float = OpTypePointer Private %float %dead = OpVariable %_ptr_Private_float Private %main = OpFunction %void None %5 %8 = OpLabel OpReturn OpFunctionEnd )"; const std::string after = R"(OpCapability Shader OpCapability Linkage %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 150 OpName %main "main" %void = OpTypeVoid %5 = OpTypeFunction %void %main = OpFunction %void None %5 %8 = OpLabel OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(before, after, true, true); } // Delete %dead because it is unreferenced. Then %initializer becomes // unreferenced, so remove it as well. TEST_F(AggressiveDCETest, RemoveUnreferencedWithInit1) { const std::string before = R"(OpCapability Shader OpCapability Linkage %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 150 OpName %main "main" OpName %dead "dead" OpName %initializer "initializer" %void = OpTypeVoid %6 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Private_float = OpTypePointer Private %float %initializer = OpVariable %_ptr_Private_float Private %dead = OpVariable %_ptr_Private_float Private %initializer %main = OpFunction %void None %6 %9 = OpLabel OpReturn OpFunctionEnd )"; const std::string after = R"(OpCapability Shader OpCapability Linkage %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 150 OpName %main "main" %void = OpTypeVoid %6 = OpTypeFunction %void %main = OpFunction %void None %6 %9 = OpLabel OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(before, after, true, true); } // Keep %live because it is used, and its initializer. TEST_F(AggressiveDCETest, KeepReferenced) { const std::string before = R"(OpCapability Shader OpCapability Linkage %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %output OpExecutionMode %main OriginUpperLeft OpSource GLSL 150 OpName %main "main" OpName %live "live" OpName %initializer "initializer" OpName %output "output" %void = OpTypeVoid %6 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Private_float = OpTypePointer Private %float %initializer = OpConstant %float 0 %live = OpVariable %_ptr_Private_float Private %initializer %_ptr_Output_float = OpTypePointer Output %float %output = OpVariable %_ptr_Output_float Output %main = OpFunction %void None %6 %9 = OpLabel %10 = OpLoad %float %live OpStore %output %10 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(before, before, true, true); } // This test that the decoration associated with a variable are removed when the // variable is removed. TEST_F(AggressiveDCETest, RemoveVariableAndDecorations) { const std::string before = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpName %main "main" OpName %B "B" OpMemberName %B 0 "a" OpName %Bdat "Bdat" OpMemberDecorate %B 0 Offset 0 OpDecorate %B BufferBlock OpDecorate %Bdat DescriptorSet 0 OpDecorate %Bdat Binding 0 %void = OpTypeVoid %6 = OpTypeFunction %void %uint = OpTypeInt 32 0 %B = OpTypeStruct %uint %_ptr_Uniform_B = OpTypePointer Uniform %B %Bdat = OpVariable %_ptr_Uniform_B Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint_1 = OpConstant %uint 1 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %main = OpFunction %void None %6 %13 = OpLabel OpReturn OpFunctionEnd )"; const std::string after = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpName %main "main" %void = OpTypeVoid %6 = OpTypeFunction %void %main = OpFunction %void None %6 %13 = OpLabel OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(before, after, true, true); } TEST_F(AggressiveDCETest, DeadNestedSwitch) { const std::string text = R"( ; CHECK: OpLabel ; CHECK: OpBranch [[block:%\w+]] ; CHECK-NOT: OpSwitch ; CHECK-NEXT: [[block]] = OpLabel ; CHECK: OpBranch [[block:%\w+]] ; CHECK-NOT: OpSwitch ; CHECK-NEXT: [[block]] = OpLabel ; CHECK-NEXT: OpStore OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" %x OpExecutionMode %func OriginUpperLeft OpName %func "func" %void = OpTypeVoid %1 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_ptr_Output = OpTypePointer Output %uint %uint_ptr_Input = OpTypePointer Input %uint %x = OpVariable %uint_ptr_Output Output %a = OpVariable %uint_ptr_Input Input %func = OpFunction %void None %1 %entry = OpLabel OpBranch %header %header = OpLabel %ld = OpLoad %uint %a OpLoopMerge %merge %continue None OpBranch %postheader %postheader = OpLabel ; This switch doesn't require an OpSelectionMerge and is nested in the dead loop. OpSwitch %ld %merge 0 %extra 1 %continue %extra = OpLabel OpBranch %continue %continue = OpLabel OpBranch %header %merge = OpLabel OpStore %x %uint_0 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(AggressiveDCETest, LiveNestedSwitch) { const std::string text = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" %3 %10 OpExecutionMode %func OriginUpperLeft OpName %func "func" %void = OpTypeVoid %1 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %_ptr_Output_uint = OpTypePointer Output %uint %_ptr_Input_uint = OpTypePointer Input %uint %3 = OpVariable %_ptr_Output_uint Output %10 = OpVariable %_ptr_Input_uint Input %func = OpFunction %void None %1 %11 = OpLabel OpBranch %12 %12 = OpLabel %13 = OpLoad %uint %10 OpLoopMerge %14 %15 None OpBranch %16 %16 = OpLabel OpSelectionMerge %18 None OpSwitch %13 %18 0 %17 1 %19 %17 = OpLabel OpStore %3 %uint_1 OpBranch %19 %19 = OpLabel OpBranch %15 %15 = OpLabel OpBranch %12 %18 = OpLabel OpBranch %14 %14 = OpLabel OpStore %3 %uint_0 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(text, text, false, true); } TEST_F(AggressiveDCETest, BasicDeleteDeadFunction) { // The function Dead should be removed because it is never called. const std::vector common_code = { // clang-format off "OpCapability Shader", "OpMemoryModel Logical GLSL450", "OpEntryPoint Fragment %main \"main\"", "OpName %main \"main\"", "OpName %Live \"Live\"", "%void = OpTypeVoid", "%7 = OpTypeFunction %void", "%main = OpFunction %void None %7", "%15 = OpLabel", "%16 = OpFunctionCall %void %Live", "%17 = OpFunctionCall %void %Live", "OpReturn", "OpFunctionEnd", "%Live = OpFunction %void None %7", "%20 = OpLabel", "OpReturn", "OpFunctionEnd" // clang-format on }; const std::vector dead_function = { // clang-format off "%Dead = OpFunction %void None %7", "%19 = OpLabel", "OpReturn", "OpFunctionEnd", // clang-format on }; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck( JoinAllInsts(Concat(common_code, dead_function)), JoinAllInsts(common_code), /* skip_nop = */ true); } TEST_F(AggressiveDCETest, BasicKeepLiveFunction) { // Everything is reachable from an entry point, so no functions should be // deleted. const std::vector text = { // clang-format off "OpCapability Shader", "OpMemoryModel Logical GLSL450", "OpEntryPoint Fragment %main \"main\"", "OpName %main \"main\"", "OpName %Live1 \"Live1\"", "OpName %Live2 \"Live2\"", "%void = OpTypeVoid", "%7 = OpTypeFunction %void", "%main = OpFunction %void None %7", "%15 = OpLabel", "%16 = OpFunctionCall %void %Live2", "%17 = OpFunctionCall %void %Live1", "OpReturn", "OpFunctionEnd", "%Live1 = OpFunction %void None %7", "%19 = OpLabel", "OpReturn", "OpFunctionEnd", "%Live2 = OpFunction %void None %7", "%20 = OpLabel", "OpReturn", "OpFunctionEnd" // clang-format on }; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); std::string assembly = JoinAllInsts(text); auto result = SinglePassRunAndDisassemble( assembly, /* skip_nop = */ true, /* do_validation = */ false); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); EXPECT_EQ(assembly, std::get<0>(result)); } TEST_F(AggressiveDCETest, BasicRemoveDecorationsAndNames) { // We want to remove the names and decorations associated with results that // are removed. This test will check for that. const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpName %main "main" OpName %Dead "Dead" OpName %x "x" OpName %y "y" OpName %z "z" OpDecorate %x RelaxedPrecision OpDecorate %y RelaxedPrecision OpDecorate %z RelaxedPrecision OpDecorate %6 RelaxedPrecision OpDecorate %7 RelaxedPrecision OpDecorate %8 RelaxedPrecision %void = OpTypeVoid %10 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_1 = OpConstant %float 1 %main = OpFunction %void None %10 %14 = OpLabel OpReturn OpFunctionEnd %Dead = OpFunction %void None %10 %15 = OpLabel %x = OpVariable %_ptr_Function_float Function %y = OpVariable %_ptr_Function_float Function %z = OpVariable %_ptr_Function_float Function OpStore %x %float_1 OpStore %y %float_1 %6 = OpLoad %float %x %7 = OpLoad %float %y %8 = OpFAdd %float %6 %7 OpStore %z %8 OpReturn OpFunctionEnd)"; const std::string expected_output = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpName %main "main" %void = OpTypeVoid %10 = OpTypeFunction %void %main = OpFunction %void None %10 %14 = OpLabel OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(text, expected_output, /* skip_nop = */ true); } TEST_F(AggressiveDCETest, BasicAllDeadConstants) { const std::string text = R"( ; CHECK-NOT: OpConstant OpCapability Shader OpCapability Float64 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpName %main "main" %void = OpTypeVoid %4 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %false = OpConstantFalse %bool %int = OpTypeInt 32 1 %9 = OpConstant %int 1 %uint = OpTypeInt 32 0 %11 = OpConstant %uint 2 %float = OpTypeFloat 32 %13 = OpConstant %float 3.1415 %double = OpTypeFloat 64 %15 = OpConstant %double 3.14159265358979 %main = OpFunction %void None %4 %16 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(AggressiveDCETest, BasicNoneDeadConstants) { const std::vector text = { // clang-format off "OpCapability Shader", "OpCapability Float64", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Vertex %main \"main\" %btv %bfv %iv %uv %fv %dv", "OpName %main \"main\"", "OpName %btv \"btv\"", "OpName %bfv \"bfv\"", "OpName %iv \"iv\"", "OpName %uv \"uv\"", "OpName %fv \"fv\"", "OpName %dv \"dv\"", "%void = OpTypeVoid", "%10 = OpTypeFunction %void", "%bool = OpTypeBool", "%_ptr_Output_bool = OpTypePointer Output %bool", "%true = OpConstantTrue %bool", "%false = OpConstantFalse %bool", "%int = OpTypeInt 32 1", "%_ptr_Output_int = OpTypePointer Output %int", "%int_1 = OpConstant %int 1", "%uint = OpTypeInt 32 0", "%_ptr_Output_uint = OpTypePointer Output %uint", "%uint_2 = OpConstant %uint 2", "%float = OpTypeFloat 32", "%_ptr_Output_float = OpTypePointer Output %float", "%float_3_1415 = OpConstant %float 3.1415", "%double = OpTypeFloat 64", "%_ptr_Output_double = OpTypePointer Output %double", "%double_3_14159265358979 = OpConstant %double 3.14159265358979", "%btv = OpVariable %_ptr_Output_bool Output", "%bfv = OpVariable %_ptr_Output_bool Output", "%iv = OpVariable %_ptr_Output_int Output", "%uv = OpVariable %_ptr_Output_uint Output", "%fv = OpVariable %_ptr_Output_float Output", "%dv = OpVariable %_ptr_Output_double Output", "%main = OpFunction %void None %10", "%27 = OpLabel", "OpStore %btv %true", "OpStore %bfv %false", "OpStore %iv %int_1", "OpStore %uv %uint_2", "OpStore %fv %float_3_1415", "OpStore %dv %double_3_14159265358979", "OpReturn", "OpFunctionEnd", // clang-format on }; // All constants are used, so none of them should be eliminated. SinglePassRunAndCheck( JoinAllInsts(text), JoinAllInsts(text), /* skip_nop = */ true); } struct AggressiveEliminateDeadConstantTestCase { // Type declarations and constants that should be kept. std::vector used_consts; // Instructions that refer to constants, this is added to create uses for // some constants so they won't be treated as dead constants. std::vector main_insts; // Dead constants that should be removed. std::vector dead_consts; // Expectations std::vector checks; }; // All types that are potentially required in // AggressiveEliminateDeadConstantTest. const std::vector CommonTypes = { // clang-format off // scalar types "%bool = OpTypeBool", "%uint = OpTypeInt 32 0", "%int = OpTypeInt 32 1", "%float = OpTypeFloat 32", "%double = OpTypeFloat 64", // vector types "%v2bool = OpTypeVector %bool 2", "%v2uint = OpTypeVector %uint 2", "%v2int = OpTypeVector %int 2", "%v3int = OpTypeVector %int 3", "%v4int = OpTypeVector %int 4", "%v2float = OpTypeVector %float 2", "%v3float = OpTypeVector %float 3", "%v2double = OpTypeVector %double 2", // variable pointer types "%_pf_bool = OpTypePointer Output %bool", "%_pf_uint = OpTypePointer Output %uint", "%_pf_int = OpTypePointer Output %int", "%_pf_float = OpTypePointer Output %float", "%_pf_double = OpTypePointer Output %double", "%_pf_v2int = OpTypePointer Output %v2int", "%_pf_v3int = OpTypePointer Output %v3int", "%_pf_v2float = OpTypePointer Output %v2float", "%_pf_v3float = OpTypePointer Output %v3float", "%_pf_v2double = OpTypePointer Output %v2double", // struct types "%inner_struct = OpTypeStruct %bool %int %float %double", "%outer_struct = OpTypeStruct %inner_struct %int %double", "%flat_struct = OpTypeStruct %bool %int %float %double", // clang-format on }; using AggressiveEliminateDeadConstantTest = PassTest<::testing::TestWithParam>; TEST_P(AggressiveEliminateDeadConstantTest, Custom) { auto& tc = GetParam(); AssemblyBuilder builder; builder.AppendTypesConstantsGlobals(CommonTypes) .AppendTypesConstantsGlobals(tc.used_consts) .AppendInMain(tc.main_insts); const std::string expected = builder.GetCode(); builder.AppendTypesConstantsGlobals(tc.dead_consts); builder.PrependPreamble(tc.checks); const std::string assembly_with_dead_const = builder.GetCode(); // Do not enable validation. As the input code is invalid from the base // tests (ported from other passes). SinglePassRunAndMatch(assembly_with_dead_const, false); } INSTANTIATE_TEST_SUITE_P( ScalarTypeConstants, AggressiveEliminateDeadConstantTest, ::testing::ValuesIn(std::vector({ // clang-format off // Scalar type constants, one dead constant and one used constant. { /* .used_consts = */ { "%used_const_int = OpConstant %int 1", }, /* .main_insts = */ { "%int_var = OpVariable %_pf_int Output", "OpStore %int_var %used_const_int", }, /* .dead_consts = */ { "%dead_const_int = OpConstant %int 1", }, /* .checks = */ { "; CHECK: [[const:%\\w+]] = OpConstant %int 1", "; CHECK-NOT: OpConstant", "; CHECK: OpStore {{%\\w+}} [[const]]", }, }, { /* .used_consts = */ { "%used_const_uint = OpConstant %uint 1", }, /* .main_insts = */ { "%uint_var = OpVariable %_pf_uint Output", "OpStore %uint_var %used_const_uint", }, /* .dead_consts = */ { "%dead_const_uint = OpConstant %uint 1", }, /* .checks = */ { "; CHECK: [[const:%\\w+]] = OpConstant %uint 1", "; CHECK-NOT: OpConstant", "; CHECK: OpStore {{%\\w+}} [[const]]", }, }, { /* .used_consts = */ { "%used_const_float = OpConstant %float 3.1415", }, /* .main_insts = */ { "%float_var = OpVariable %_pf_float Output", "OpStore %float_var %used_const_float", }, /* .dead_consts = */ { "%dead_const_float = OpConstant %float 3.1415", }, /* .checks = */ { "; CHECK: [[const:%\\w+]] = OpConstant %float 3.1415", "; CHECK-NOT: OpConstant", "; CHECK: OpStore {{%\\w+}} [[const]]", }, }, { /* .used_consts = */ { "%used_const_double = OpConstant %double 3.14", }, /* .main_insts = */ { "%double_var = OpVariable %_pf_double Output", "OpStore %double_var %used_const_double", }, /* .dead_consts = */ { "%dead_const_double = OpConstant %double 3.14", }, /* .checks = */ { "; CHECK: [[const:%\\w+]] = OpConstant %double 3.14", "; CHECK-NOT: OpConstant", "; CHECK: OpStore {{%\\w+}} [[const]]", }, }, // clang-format on }))); INSTANTIATE_TEST_SUITE_P( VectorTypeConstants, AggressiveEliminateDeadConstantTest, ::testing::ValuesIn(std::vector({ // clang-format off // Tests eliminating dead constant type ivec2. One dead constant vector // and one used constant vector, each built from its own group of // scalar constants. { /* .used_consts = */ { "%used_int_x = OpConstant %int 1", "%used_int_y = OpConstant %int 2", "%used_v2int = OpConstantComposite %v2int %used_int_x %used_int_y", }, /* .main_insts = */ { "%v2int_var = OpVariable %_pf_v2int Output", "OpStore %v2int_var %used_v2int", }, /* .dead_consts = */ { "%dead_int_x = OpConstant %int 1", "%dead_int_y = OpConstant %int 2", "%dead_v2int = OpConstantComposite %v2int %dead_int_x %dead_int_y", }, /* .checks = */ { "; CHECK: [[constx:%\\w+]] = OpConstant %int 1", "; CHECK: [[consty:%\\w+]] = OpConstant %int 2", "; CHECK: [[const:%\\w+]] = OpConstantComposite %v2int [[constx]] [[consty]]", "; CHECK-NOT: OpConstant", "; CHECK: OpStore {{%\\w+}} [[const]]", }, }, // Tests eliminating dead constant ivec3. One dead constant vector and // one used constant vector. But both built from a same group of // scalar constants. { /* .used_consts = */ { "%used_int_x = OpConstant %int 1", "%used_int_y = OpConstant %int 2", "%used_int_z = OpConstant %int 3", "%used_v3int = OpConstantComposite %v3int %used_int_x %used_int_y %used_int_z", }, /* .main_insts = */ { "%v3int_var = OpVariable %_pf_v3int Output", "OpStore %v3int_var %used_v3int", }, /* .dead_consts = */ { "%dead_v3int = OpConstantComposite %v3int %used_int_x %used_int_y %used_int_z", }, /* .checks = */ { "; CHECK: [[constx:%\\w+]] = OpConstant %int 1", "; CHECK: [[consty:%\\w+]] = OpConstant %int 2", "; CHECK: [[constz:%\\w+]] = OpConstant %int 3", "; CHECK: [[const:%\\w+]] = OpConstantComposite %v3int [[constx]] [[consty]] [[constz]]", "; CHECK-NOT: OpConstant", "; CHECK: OpStore {{%\\w+}} [[const]]", }, }, // Tests eliminating dead constant vec2. One dead constant vector and // one used constant vector. Each built from its own group of scalar // constants. { /* .used_consts = */ { "%used_float_x = OpConstant %float 3.1415", "%used_float_y = OpConstant %float 4.13", "%used_v2float = OpConstantComposite %v2float %used_float_x %used_float_y", }, /* .main_insts = */ { "%v2float_var = OpVariable %_pf_v2float Output", "OpStore %v2float_var %used_v2float", }, /* .dead_consts = */ { "%dead_float_x = OpConstant %float 3.1415", "%dead_float_y = OpConstant %float 4.13", "%dead_v2float = OpConstantComposite %v2float %dead_float_x %dead_float_y", }, /* .checks = */ { "; CHECK: [[constx:%\\w+]] = OpConstant %float 3.1415", "; CHECK: [[consty:%\\w+]] = OpConstant %float 4.13", "; CHECK: [[const:%\\w+]] = OpConstantComposite %v2float [[constx]] [[consty]]", "; CHECK-NOT: OpConstant", "; CHECK: OpStore {{%\\w+}} [[const]]", }, }, // Tests eliminating dead constant vec3. One dead constant vector and // one used constant vector. Both built from a same group of scalar // constants. { /* .used_consts = */ { "%used_float_x = OpConstant %float 3.1415", "%used_float_y = OpConstant %float 4.25", "%used_float_z = OpConstant %float 4.75", "%used_v3float = OpConstantComposite %v3float %used_float_x %used_float_y %used_float_z", }, /* .main_insts = */ { "%v3float_var = OpVariable %_pf_v3float Output", "OpStore %v3float_var %used_v3float", }, /* .dead_consts = */ { "%dead_v3float = OpConstantComposite %v3float %used_float_x %used_float_y %used_float_z", }, /* .checks = */ { "; CHECK: [[constx:%\\w+]] = OpConstant %float 3.1415", "; CHECK: [[consty:%\\w+]] = OpConstant %float 4.25", "; CHECK: [[constz:%\\w+]] = OpConstant %float 4.75", "; CHECK: [[const:%\\w+]] = OpConstantComposite %v3float [[constx]] [[consty]]", "; CHECK-NOT: OpConstant", "; CHECK: OpStore {{%\\w+}} [[const]]", }, }, // clang-format on }))); INSTANTIATE_TEST_SUITE_P( StructTypeConstants, AggressiveEliminateDeadConstantTest, ::testing::ValuesIn(std::vector({ // clang-format off // A plain struct type dead constants. All of its components are dead // constants too. { /* .used_consts = */ {}, /* .main_insts = */ {}, /* .dead_consts = */ { "%dead_bool = OpConstantTrue %bool", "%dead_int = OpConstant %int 1", "%dead_float = OpConstant %float 2.5", "%dead_double = OpConstant %double 3.14159265358979", "%dead_struct = OpConstantComposite %flat_struct %dead_bool %dead_int %dead_float %dead_double", }, /* .checks = */ { "; CHECK-NOT: OpConstant", }, }, // A plain struct type dead constants. Some of its components are dead // constants while others are not. { /* .used_consts = */ { "%used_int = OpConstant %int 1", "%used_double = OpConstant %double 3.14159265358979", }, /* .main_insts = */ { "%int_var = OpVariable %_pf_int Output", "OpStore %int_var %used_int", "%double_var = OpVariable %_pf_double Output", "OpStore %double_var %used_double", }, /* .dead_consts = */ { "%dead_bool = OpConstantTrue %bool", "%dead_float = OpConstant %float 2.5", "%dead_struct = OpConstantComposite %flat_struct %dead_bool %used_int %dead_float %used_double", }, /* .checks = */ { "; CHECK: [[int:%\\w+]] = OpConstant %int 1", "; CHECK: [[double:%\\w+]] = OpConstant %double 3.14159265358979", "; CHECK-NOT: OpConstant", "; CHECK: OpStore {{%\\w+}} [[int]]", "; CHECK: OpStore {{%\\w+}} [[double]]", }, }, // A nesting struct type dead constants. All components of both outer // and inner structs are dead and should be removed after dead constant // elimination. { /* .used_consts = */ {}, /* .main_insts = */ {}, /* .dead_consts = */ { "%dead_bool = OpConstantTrue %bool", "%dead_int = OpConstant %int 1", "%dead_float = OpConstant %float 2.5", "%dead_double = OpConstant %double 3.1415926535", "%dead_inner_struct = OpConstantComposite %inner_struct %dead_bool %dead_int %dead_float %dead_double", "%dead_int2 = OpConstant %int 2", "%dead_double2 = OpConstant %double 1.428571428514", "%dead_outer_struct = OpConstantComposite %outer_struct %dead_inner_struct %dead_int2 %dead_double2", }, /* .checks = */ { "; CHECK-NOT: OpConstant", }, }, // A nesting struct type dead constants. Some of its components are // dead constants while others are not. { /* .used_consts = */ { "%used_int = OpConstant %int 1", "%used_double = OpConstant %double 3.14159265358979", }, /* .main_insts = */ { "%int_var = OpVariable %_pf_int Output", "OpStore %int_var %used_int", "%double_var = OpVariable %_pf_double Output", "OpStore %double_var %used_double", }, /* .dead_consts = */ { "%dead_bool = OpConstantTrue %bool", "%dead_float = OpConstant %float 2.5", "%dead_inner_struct = OpConstantComposite %inner_struct %dead_bool %used_int %dead_float %used_double", "%dead_int = OpConstant %int 2", "%dead_outer_struct = OpConstantComposite %outer_struct %dead_inner_struct %dead_int %used_double", }, /* .checks = */ { "; CHECK: [[int:%\\w+]] = OpConstant %int 1", "; CHECK: [[double:%\\w+]] = OpConstant %double 3.14159265358979", "; CHECK-NOT: OpConstant", "; CHECK: OpStore {{%\\w+}} [[int]]", "; CHECK: OpStore {{%\\w+}} [[double]]", }, }, // A nesting struct case. The inner struct is used while the outer struct is not { /* .used_const = */ { "%used_bool = OpConstantTrue %bool", "%used_int = OpConstant %int 1", "%used_float = OpConstant %float 1.23", "%used_double = OpConstant %double 1.2345678901234", "%used_inner_struct = OpConstantComposite %inner_struct %used_bool %used_int %used_float %used_double", }, /* .main_insts = */ { "%bool_var = OpVariable %_pf_bool Output", "%bool_from_inner_struct = OpCompositeExtract %bool %used_inner_struct 0", "OpStore %bool_var %bool_from_inner_struct", }, /* .dead_consts = */ { "%dead_int = OpConstant %int 2", "%dead_outer_struct = OpConstantComposite %outer_struct %used_inner_struct %dead_int %used_double" }, /* .checks = */ { "; CHECK: [[bool:%\\w+]] = OpConstantTrue", "; CHECK: [[int:%\\w+]] = OpConstant %int 1", "; CHECK: [[float:%\\w+]] = OpConstant %float 1.23", "; CHECK: [[double:%\\w+]] = OpConstant %double 1.2345678901234", "; CHECK: [[struct:%\\w+]] = OpConstantComposite %inner_struct [[bool]] [[int]] [[float]] [[double]]", "; CHECK-NOT: OpConstant", "; CHECK: OpCompositeExtract %bool [[struct]]", } }, // A nesting struct case. The outer struct is used, so the inner struct should not // be removed even though it is not used anywhere. { /* .used_const = */ { "%used_bool = OpConstantTrue %bool", "%used_int = OpConstant %int 1", "%used_float = OpConstant %float 1.23", "%used_double = OpConstant %double 1.2345678901234", "%used_inner_struct = OpConstantComposite %inner_struct %used_bool %used_int %used_float %used_double", "%used_outer_struct = OpConstantComposite %outer_struct %used_inner_struct %used_int %used_double" }, /* .main_insts = */ { "%int_var = OpVariable %_pf_int Output", "%int_from_outer_struct = OpCompositeExtract %int %used_outer_struct 1", "OpStore %int_var %int_from_outer_struct", }, /* .dead_consts = */ {}, /* .checks = */ { "; CHECK: [[bool:%\\w+]] = OpConstantTrue %bool", "; CHECK: [[int:%\\w+]] = OpConstant %int 1", "; CHECK: [[float:%\\w+]] = OpConstant %float 1.23", "; CHECK: [[double:%\\w+]] = OpConstant %double 1.2345678901234", "; CHECK: [[inner_struct:%\\w+]] = OpConstantComposite %inner_struct %used_bool %used_int %used_float %used_double", "; CHECK: [[outer_struct:%\\w+]] = OpConstantComposite %outer_struct %used_inner_struct %used_int %used_double", "; CHECK: OpCompositeExtract %int [[outer_struct]]", }, }, // clang-format on }))); INSTANTIATE_TEST_SUITE_P( ScalarTypeSpecConstants, AggressiveEliminateDeadConstantTest, ::testing::ValuesIn(std::vector({ // clang-format off // All scalar type spec constants. { /* .used_consts = */ { "%used_bool = OpSpecConstantTrue %bool", "%used_uint = OpSpecConstant %uint 2", "%used_int = OpSpecConstant %int 2", "%used_float = OpSpecConstant %float 2.5", "%used_double = OpSpecConstant %double 1.428571428514", }, /* .main_insts = */ { "%bool_var = OpVariable %_pf_bool Output", "%uint_var = OpVariable %_pf_uint Output", "%int_var = OpVariable %_pf_int Output", "%float_var = OpVariable %_pf_float Output", "%double_var = OpVariable %_pf_double Output", "OpStore %bool_var %used_bool", "OpStore %uint_var %used_uint", "OpStore %int_var %used_int", "OpStore %float_var %used_float", "OpStore %double_var %used_double", }, /* .dead_consts = */ { "%dead_bool = OpSpecConstantTrue %bool", "%dead_uint = OpSpecConstant %uint 2", "%dead_int = OpSpecConstant %int 2", "%dead_float = OpSpecConstant %float 2.5", "%dead_double = OpSpecConstant %double 1.428571428514", }, /* .checks = */ { "; CHECK: [[bool:%\\w+]] = OpSpecConstantTrue %bool", "; CHECK: [[uint:%\\w+]] = OpSpecConstant %uint 2", "; CHECK: [[int:%\\w+]] = OpSpecConstant %int 2", "; CHECK: [[float:%\\w+]] = OpSpecConstant %float 2.5", "; CHECK: [[double:%\\w+]] = OpSpecConstant %double 1.428571428514", "; CHECK-NOT: OpSpecConstant", "; CHECK: OpStore {{%\\w+}} [[bool]]", "; CHECK: OpStore {{%\\w+}} [[uint]]", "; CHECK: OpStore {{%\\w+}} [[int]]", "; CHECK: OpStore {{%\\w+}} [[float]]", "; CHECK: OpStore {{%\\w+}} [[double]]", }, }, // clang-format on }))); INSTANTIATE_TEST_SUITE_P( VectorTypeSpecConstants, AggressiveEliminateDeadConstantTest, ::testing::ValuesIn(std::vector({ // clang-format off // Bool vector type spec constants. One vector has all component dead, // another vector has one dead boolean and one used boolean. { /* .used_consts = */ { "%used_bool = OpSpecConstantTrue %bool", }, /* .main_insts = */ { "%bool_var = OpVariable %_pf_bool Output", "OpStore %bool_var %used_bool", }, /* .dead_consts = */ { "%dead_bool = OpSpecConstantFalse %bool", "%dead_bool_vec1 = OpSpecConstantComposite %v2bool %dead_bool %dead_bool", "%dead_bool_vec2 = OpSpecConstantComposite %v2bool %dead_bool %used_bool", }, /* .checks = */ { "; CHECK: [[bool:%\\w+]] = OpSpecConstantTrue %bool", "; CHECK-NOT: OpSpecConstant", "; CHECK: OpStore {{%\\w+}} [[bool]]", }, }, // Uint vector type spec constants. One vector has all component dead, // another vector has one dead unsigned integer and one used unsigned // integer. { /* .used_consts = */ { "%used_uint = OpSpecConstant %uint 3", }, /* .main_insts = */ { "%uint_var = OpVariable %_pf_uint Output", "OpStore %uint_var %used_uint", }, /* .dead_consts = */ { "%dead_uint = OpSpecConstant %uint 1", "%dead_uint_vec1 = OpSpecConstantComposite %v2uint %dead_uint %dead_uint", "%dead_uint_vec2 = OpSpecConstantComposite %v2uint %dead_uint %used_uint", }, /* .checks = */ { "; CHECK: [[uint:%\\w+]] = OpSpecConstant %uint 3", "; CHECK-NOT: OpSpecConstant", "; CHECK: OpStore {{%\\w+}} [[uint]]", }, }, // Int vector type spec constants. One vector has all component dead, // another vector has one dead integer and one used integer. { /* .used_consts = */ { "%used_int = OpSpecConstant %int 3", }, /* .main_insts = */ { "%int_var = OpVariable %_pf_int Output", "OpStore %int_var %used_int", }, /* .dead_consts = */ { "%dead_int = OpSpecConstant %int 1", "%dead_int_vec1 = OpSpecConstantComposite %v2int %dead_int %dead_int", "%dead_int_vec2 = OpSpecConstantComposite %v2int %dead_int %used_int", }, /* .checks = */ { "; CHECK: [[int:%\\w+]] = OpSpecConstant %int 3", "; CHECK-NOT: OpSpecConstant", "; CHECK: OpStore {{%\\w+}} [[int]]", }, }, // Int vector type spec constants built with both spec constants and // front-end constants. { /* .used_consts = */ { "%used_spec_int = OpSpecConstant %int 3", "%used_front_end_int = OpConstant %int 3", }, /* .main_insts = */ { "%int_var1 = OpVariable %_pf_int Output", "OpStore %int_var1 %used_spec_int", "%int_var2 = OpVariable %_pf_int Output", "OpStore %int_var2 %used_front_end_int", }, /* .dead_consts = */ { "%dead_spec_int = OpSpecConstant %int 1", "%dead_front_end_int = OpConstant %int 1", // Dead front-end and dead spec constants "%dead_int_vec1 = OpSpecConstantComposite %v2int %dead_spec_int %dead_front_end_int", // Used front-end and dead spec constants "%dead_int_vec2 = OpSpecConstantComposite %v2int %dead_spec_int %used_front_end_int", // Dead front-end and used spec constants "%dead_int_vec3 = OpSpecConstantComposite %v2int %dead_front_end_int %used_spec_int", }, /* .checks = */ { "; CHECK: [[int1:%\\w+]] = OpSpecConstant %int 3", "; CHECK: [[int2:%\\w+]] = OpConstant %int 3", "; CHECK-NOT: OpSpecConstant", "; CHECK-NOT: OpConstant", "; CHECK: OpStore {{%\\w+}} [[int1]]", "; CHECK: OpStore {{%\\w+}} [[int2]]", }, }, // clang-format on }))); INSTANTIATE_TEST_SUITE_P( SpecConstantOp, AggressiveEliminateDeadConstantTest, ::testing::ValuesIn(std::vector({ // clang-format off // Cast operations: uint <-> int <-> bool { /* .used_consts = */ {}, /* .main_insts = */ {}, /* .dead_consts = */ { // Assistant constants, only used in dead spec constant // operations. "%signed_zero = OpConstant %int 0", "%signed_zero_vec = OpConstantComposite %v2int %signed_zero %signed_zero", "%unsigned_zero = OpConstant %uint 0", "%unsigned_zero_vec = OpConstantComposite %v2uint %unsigned_zero %unsigned_zero", "%signed_one = OpConstant %int 1", "%signed_one_vec = OpConstantComposite %v2int %signed_one %signed_one", "%unsigned_one = OpConstant %uint 1", "%unsigned_one_vec = OpConstantComposite %v2uint %unsigned_one %unsigned_one", // Spec constants that support casting to each other. "%dead_bool = OpSpecConstantTrue %bool", "%dead_uint = OpSpecConstant %uint 1", "%dead_int = OpSpecConstant %int 2", "%dead_bool_vec = OpSpecConstantComposite %v2bool %dead_bool %dead_bool", "%dead_uint_vec = OpSpecConstantComposite %v2uint %dead_uint %dead_uint", "%dead_int_vec = OpSpecConstantComposite %v2int %dead_int %dead_int", // Scalar cast to boolean spec constant. "%int_to_bool = OpSpecConstantOp %bool INotEqual %dead_int %signed_zero", "%uint_to_bool = OpSpecConstantOp %bool INotEqual %dead_uint %unsigned_zero", // Vector cast to boolean spec constant. "%int_to_bool_vec = OpSpecConstantOp %v2bool INotEqual %dead_int_vec %signed_zero_vec", "%uint_to_bool_vec = OpSpecConstantOp %v2bool INotEqual %dead_uint_vec %unsigned_zero_vec", // Scalar cast to int spec constant. "%bool_to_int = OpSpecConstantOp %int Select %dead_bool %signed_one %signed_zero", "%uint_to_int = OpSpecConstantOp %uint IAdd %dead_uint %unsigned_zero", // Vector cast to int spec constant. "%bool_to_int_vec = OpSpecConstantOp %v2int Select %dead_bool_vec %signed_one_vec %signed_zero_vec", "%uint_to_int_vec = OpSpecConstantOp %v2uint IAdd %dead_uint_vec %unsigned_zero_vec", // Scalar cast to uint spec constant. "%bool_to_uint = OpSpecConstantOp %uint Select %dead_bool %unsigned_one %unsigned_zero", "%int_to_uint_vec = OpSpecConstantOp %uint IAdd %dead_int %signed_zero", // Vector cast to uint spec constant. "%bool_to_uint_vec = OpSpecConstantOp %v2uint Select %dead_bool_vec %unsigned_one_vec %unsigned_zero_vec", "%int_to_uint = OpSpecConstantOp %v2uint IAdd %dead_int_vec %signed_zero_vec", }, /* .checks = */ { "; CHECK-NOT: OpConstant", "; CHECK-NOT: OpSpecConstant", }, }, // Add, sub, mul, div, rem. { /* .used_consts = */ {}, /* .main_insts = */ {}, /* .dead_consts = */ { "%dead_spec_int_a = OpSpecConstant %int 1", "%dead_spec_int_a_vec = OpSpecConstantComposite %v2int %dead_spec_int_a %dead_spec_int_a", "%dead_spec_int_b = OpSpecConstant %int 2", "%dead_spec_int_b_vec = OpSpecConstantComposite %v2int %dead_spec_int_b %dead_spec_int_b", "%dead_const_int_c = OpConstant %int 3", "%dead_const_int_c_vec = OpConstantComposite %v2int %dead_const_int_c %dead_const_int_c", // Add "%add_a_b = OpSpecConstantOp %int IAdd %dead_spec_int_a %dead_spec_int_b", "%add_a_b_vec = OpSpecConstantOp %v2int IAdd %dead_spec_int_a_vec %dead_spec_int_b_vec", // Sub "%sub_a_b = OpSpecConstantOp %int ISub %dead_spec_int_a %dead_spec_int_b", "%sub_a_b_vec = OpSpecConstantOp %v2int ISub %dead_spec_int_a_vec %dead_spec_int_b_vec", // Mul "%mul_a_b = OpSpecConstantOp %int IMul %dead_spec_int_a %dead_spec_int_b", "%mul_a_b_vec = OpSpecConstantOp %v2int IMul %dead_spec_int_a_vec %dead_spec_int_b_vec", // Div "%div_a_b = OpSpecConstantOp %int SDiv %dead_spec_int_a %dead_spec_int_b", "%div_a_b_vec = OpSpecConstantOp %v2int SDiv %dead_spec_int_a_vec %dead_spec_int_b_vec", // Bitwise Xor "%xor_a_b = OpSpecConstantOp %int BitwiseXor %dead_spec_int_a %dead_spec_int_b", "%xor_a_b_vec = OpSpecConstantOp %v2int BitwiseXor %dead_spec_int_a_vec %dead_spec_int_b_vec", // Scalar Comparison "%less_a_b = OpSpecConstantOp %bool SLessThan %dead_spec_int_a %dead_spec_int_b", }, /* .checks = */ { "; CHECK-NOT: OpConstant", "; CHECK-NOT: OpSpecConstant", }, }, // Vectors without used swizzles should be removed. { /* .used_consts = */ { "%used_int = OpConstant %int 3", }, /* .main_insts = */ { "%int_var = OpVariable %_pf_int Output", "OpStore %int_var %used_int", }, /* .dead_consts = */ { "%dead_int = OpConstant %int 3", "%dead_spec_int_a = OpSpecConstant %int 1", "%vec_a = OpSpecConstantComposite %v4int %dead_spec_int_a %dead_spec_int_a %dead_int %dead_int", "%dead_spec_int_b = OpSpecConstant %int 2", "%vec_b = OpSpecConstantComposite %v4int %dead_spec_int_b %dead_spec_int_b %used_int %used_int", // Extract scalar "%a_x = OpSpecConstantOp %int CompositeExtract %vec_a 0", "%b_x = OpSpecConstantOp %int CompositeExtract %vec_b 0", // Extract vector "%a_xy = OpSpecConstantOp %v2int VectorShuffle %vec_a %vec_a 0 1", "%b_xy = OpSpecConstantOp %v2int VectorShuffle %vec_b %vec_b 0 1", }, /* .checks = */ { "; CHECK: [[int:%\\w+]] = OpConstant %int 3", "; CHECK-NOT: OpConstant", "; CHECK-NOT: OpSpecConstant", "; CHECK: OpStore {{%\\w+}} [[int]]", }, }, // Vectors with used swizzles should not be removed. { /* .used_consts = */ { "%used_int = OpConstant %int 3", "%used_spec_int_a = OpSpecConstant %int 1", "%used_spec_int_b = OpSpecConstant %int 2", // Create vectors "%vec_a = OpSpecConstantComposite %v4int %used_spec_int_a %used_spec_int_a %used_int %used_int", "%vec_b = OpSpecConstantComposite %v4int %used_spec_int_b %used_spec_int_b %used_int %used_int", // Extract vector "%a_xy = OpSpecConstantOp %v2int VectorShuffle %vec_a %vec_a 0 1", "%b_xy = OpSpecConstantOp %v2int VectorShuffle %vec_b %vec_b 0 1", }, /* .main_insts = */ { "%v2int_var_a = OpVariable %_pf_v2int Output", "%v2int_var_b = OpVariable %_pf_v2int Output", "OpStore %v2int_var_a %a_xy", "OpStore %v2int_var_b %b_xy", }, /* .dead_consts = */ {}, /* .checks = */ { "; CHECK: [[int:%\\w+]] = OpConstant %int 3", "; CHECK: [[a:%\\w+]] = OpSpecConstant %int 1", "; CHECK: [[b:%\\w+]] = OpSpecConstant %int 2", "; CHECK: [[veca:%\\w+]] = OpSpecConstantComposite %v4int [[a]] [[a]] [[int]] [[int]]", "; CHECK: [[vecb:%\\w+]] = OpSpecConstantComposite %v4int [[b]] [[b]] [[int]] [[int]]", "; CHECK: [[exa:%\\w+]] = OpSpecConstantOp %v2int VectorShuffle [[veca]] [[veca]] 0 1", "; CHECK: [[exb:%\\w+]] = OpSpecConstantOp %v2int VectorShuffle [[vecb]] [[vecb]] 0 1", "; CHECK-NOT: OpConstant", "; CHECK-NOT: OpSpecConstant", "; CHECK: OpStore {{%\\w+}} [[exa]]", "; CHECK: OpStore {{%\\w+}} [[exb]]", }, }, // clang-format on }))); INSTANTIATE_TEST_SUITE_P( LongDefUseChain, AggressiveEliminateDeadConstantTest, ::testing::ValuesIn(std::vector({ // clang-format off // Long Def-Use chain with binary operations. { /* .used_consts = */ { "%array_size = OpConstant %int 4", "%type_arr_int_4 = OpTypeArray %int %array_size", "%used_int_0 = OpConstant %int 100", "%used_int_1 = OpConstant %int 1", "%used_int_2 = OpSpecConstantOp %int IAdd %used_int_0 %used_int_1", "%used_int_3 = OpSpecConstantOp %int ISub %used_int_0 %used_int_2", "%used_int_4 = OpSpecConstantOp %int IAdd %used_int_0 %used_int_3", "%used_int_5 = OpSpecConstantOp %int ISub %used_int_0 %used_int_4", "%used_int_6 = OpSpecConstantOp %int IAdd %used_int_0 %used_int_5", "%used_int_7 = OpSpecConstantOp %int ISub %used_int_0 %used_int_6", "%used_int_8 = OpSpecConstantOp %int IAdd %used_int_0 %used_int_7", "%used_int_9 = OpSpecConstantOp %int ISub %used_int_0 %used_int_8", "%used_int_10 = OpSpecConstantOp %int IAdd %used_int_0 %used_int_9", "%used_int_11 = OpSpecConstantOp %int ISub %used_int_0 %used_int_10", "%used_int_12 = OpSpecConstantOp %int IAdd %used_int_0 %used_int_11", "%used_int_13 = OpSpecConstantOp %int ISub %used_int_0 %used_int_12", "%used_int_14 = OpSpecConstantOp %int IAdd %used_int_0 %used_int_13", "%used_int_15 = OpSpecConstantOp %int ISub %used_int_0 %used_int_14", "%used_int_16 = OpSpecConstantOp %int ISub %used_int_0 %used_int_15", "%used_int_17 = OpSpecConstantOp %int IAdd %used_int_0 %used_int_16", "%used_int_18 = OpSpecConstantOp %int ISub %used_int_0 %used_int_17", "%used_int_19 = OpSpecConstantOp %int IAdd %used_int_0 %used_int_18", "%used_int_20 = OpSpecConstantOp %int ISub %used_int_0 %used_int_19", "%used_vec_a = OpSpecConstantComposite %v2int %used_int_18 %used_int_19", "%used_vec_b = OpSpecConstantOp %v2int IMul %used_vec_a %used_vec_a", "%used_int_21 = OpSpecConstantOp %int CompositeExtract %used_vec_b 0", "%used_array = OpConstantComposite %type_arr_int_4 %used_int_20 %used_int_20 %used_int_21 %used_int_21", }, /* .main_insts = */ { "%int_var = OpVariable %_pf_int Output", "%used_array_2 = OpCompositeExtract %int %used_array 2", "OpStore %int_var %used_array_2", }, /* .dead_consts = */ { "%dead_int_1 = OpConstant %int 2", "%dead_int_2 = OpSpecConstantOp %int IAdd %used_int_0 %dead_int_1", "%dead_int_3 = OpSpecConstantOp %int ISub %used_int_0 %dead_int_2", "%dead_int_4 = OpSpecConstantOp %int IAdd %used_int_0 %dead_int_3", "%dead_int_5 = OpSpecConstantOp %int ISub %used_int_0 %dead_int_4", "%dead_int_6 = OpSpecConstantOp %int IAdd %used_int_0 %dead_int_5", "%dead_int_7 = OpSpecConstantOp %int ISub %used_int_0 %dead_int_6", "%dead_int_8 = OpSpecConstantOp %int IAdd %used_int_0 %dead_int_7", "%dead_int_9 = OpSpecConstantOp %int ISub %used_int_0 %dead_int_8", "%dead_int_10 = OpSpecConstantOp %int IAdd %used_int_0 %dead_int_9", "%dead_int_11 = OpSpecConstantOp %int ISub %used_int_0 %dead_int_10", "%dead_int_12 = OpSpecConstantOp %int IAdd %used_int_0 %dead_int_11", "%dead_int_13 = OpSpecConstantOp %int ISub %used_int_0 %dead_int_12", "%dead_int_14 = OpSpecConstantOp %int IAdd %used_int_0 %dead_int_13", "%dead_int_15 = OpSpecConstantOp %int ISub %used_int_0 %dead_int_14", "%dead_int_16 = OpSpecConstantOp %int ISub %used_int_0 %dead_int_15", "%dead_int_17 = OpSpecConstantOp %int IAdd %used_int_0 %dead_int_16", "%dead_int_18 = OpSpecConstantOp %int ISub %used_int_0 %dead_int_17", "%dead_int_19 = OpSpecConstantOp %int IAdd %used_int_0 %dead_int_18", "%dead_int_20 = OpSpecConstantOp %int ISub %used_int_0 %dead_int_19", "%dead_vec_a = OpSpecConstantComposite %v2int %dead_int_18 %dead_int_19", "%dead_vec_b = OpSpecConstantOp %v2int IMul %dead_vec_a %dead_vec_a", "%dead_int_21 = OpSpecConstantOp %int CompositeExtract %dead_vec_b 0", "%dead_array = OpConstantComposite %type_arr_int_4 %dead_int_20 %used_int_20 %dead_int_19 %used_int_19", }, /* .checks = */ { "; CHECK: OpConstant %int 4", "; CHECK: [[array:%\\w+]] = OpConstantComposite %type_arr_int_4 %used_int_20 %used_int_20 %used_int_21 %used_int_21", "; CHECK-NOT: OpConstant", "; CHECK-NOT: OpSpecConstant", "; CHECK: OpStore {{%\\w+}} [[array]]", }, }, // Long Def-Use chain with swizzle // clang-format on }))); TEST_F(AggressiveDCETest, DeadDecorationGroup) { // The decoration group should be eliminated because the target of group // decorate is dead. const std::string text = R"( ; CHECK-NOT: OpDecorat ; CHECK-NOT: OpGroupDecorate OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpDecorate %1 Restrict OpDecorate %1 Aliased %1 = OpDecorationGroup OpGroupDecorate %1 %var %void = OpTypeVoid %func = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_ptr = OpTypePointer Function %uint %main = OpFunction %void None %func %2 = OpLabel %var = OpVariable %uint_ptr Function OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(AggressiveDCETest, DeadDecorationGroupAndValidDecorationMgr) { // The decoration group should be eliminated because the target of group // decorate is dead. const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpDecorate %1 Restrict OpDecorate %1 Aliased %1 = OpDecorationGroup OpGroupDecorate %1 %var %void = OpTypeVoid %func = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_ptr = OpTypePointer Function %uint %main = OpFunction %void None %func %2 = OpLabel %var = OpVariable %uint_ptr Function OpReturn OpFunctionEnd )"; auto pass = MakeUnique(); auto consumer = [](spv_message_level_t, const char*, const spv_position_t&, const char* message) { std::cerr << message << std::endl; }; auto context = BuildModule(SPV_ENV_UNIVERSAL_1_1, consumer, text); // Build the decoration manager before the pass. context->get_decoration_mgr(); const auto status = pass->Run(context.get()); EXPECT_EQ(status, Pass::Status::SuccessWithChange); } TEST_F(AggressiveDCETest, ParitallyDeadDecorationGroup) { const std::string text = R"( ; CHECK: OpDecorate [[grp:%\w+]] Restrict ; CHECK: [[grp]] = OpDecorationGroup ; CHECK: OpGroupDecorate [[grp]] [[output:%\w+]] ; CHECK: [[output]] = OpVariable {{%\w+}} Output ; CHECK-NOT: OpVariable {{%\w+}} Function OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %output OpExecutionMode %main OriginUpperLeft OpDecorate %1 Restrict %1 = OpDecorationGroup OpGroupDecorate %1 %var %output %void = OpTypeVoid %func = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_ptr_Function = OpTypePointer Function %uint %uint_ptr_Output = OpTypePointer Output %uint %uint_0 = OpConstant %uint 0 %output = OpVariable %uint_ptr_Output Output %main = OpFunction %void None %func %2 = OpLabel %var = OpVariable %uint_ptr_Function Function OpStore %output %uint_0 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(AggressiveDCETest, ParitallyDeadDecorationGroupDifferentGroupDecorate) { const std::string text = R"( ; CHECK: OpDecorate [[grp:%\w+]] Restrict ; CHECK: [[grp]] = OpDecorationGroup ; CHECK: OpGroupDecorate [[grp]] [[output:%\w+]] ; CHECK-NOT: OpGroupDecorate ; CHECK: [[output]] = OpVariable {{%\w+}} Output ; CHECK-NOT: OpVariable {{%\w+}} Function OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %output OpExecutionMode %main OriginUpperLeft OpDecorate %1 Restrict %1 = OpDecorationGroup OpGroupDecorate %1 %output OpGroupDecorate %1 %var %void = OpTypeVoid %func = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_ptr_Function = OpTypePointer Function %uint %uint_ptr_Output = OpTypePointer Output %uint %uint_0 = OpConstant %uint 0 %output = OpVariable %uint_ptr_Output Output %main = OpFunction %void None %func %2 = OpLabel %var = OpVariable %uint_ptr_Function Function OpStore %output %uint_0 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(AggressiveDCETest, DeadGroupMemberDecorate) { const std::string text = R"( ; CHECK-NOT: OpDec ; CHECK-NOT: OpGroup OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpDecorate %1 Offset 0 OpDecorate %1 Uniform %1 = OpDecorationGroup OpGroupMemberDecorate %1 %var 0 %void = OpTypeVoid %func = OpTypeFunction %void %uint = OpTypeInt 32 0 %struct = OpTypeStruct %uint %uint %struct_ptr = OpTypePointer Function %struct %main = OpFunction %void None %func %2 = OpLabel %var = OpVariable %struct_ptr Function OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(AggressiveDCETest, PartiallyDeadGroupMemberDecorate) { const std::string text = R"( ; CHECK: OpDecorate [[grp:%\w+]] Offset 0 ; CHECK: OpDecorate [[grp]] RelaxedPrecision ; CHECK: [[grp]] = OpDecorationGroup ; CHECK: OpGroupMemberDecorate [[grp]] [[output:%\w+]] 1 ; CHECK: [[output]] = OpTypeStruct ; CHECK-NOT: OpTypeStruct OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %output OpExecutionMode %main OriginUpperLeft OpDecorate %1 Offset 0 OpDecorate %1 RelaxedPrecision %1 = OpDecorationGroup OpGroupMemberDecorate %1 %var_struct 0 %output_struct 1 %void = OpTypeVoid %func = OpTypeFunction %void %uint = OpTypeInt 32 0 %var_struct = OpTypeStruct %uint %uint %output_struct = OpTypeStruct %uint %uint %struct_ptr_Function = OpTypePointer Function %var_struct %struct_ptr_Output = OpTypePointer Output %output_struct %uint_ptr_Output = OpTypePointer Output %uint %output = OpVariable %struct_ptr_Output Output %uint_0 = OpConstant %uint 0 %main = OpFunction %void None %func %2 = OpLabel %var = OpVariable %struct_ptr_Function Function %3 = OpAccessChain %uint_ptr_Output %output %uint_0 OpStore %3 %uint_0 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(AggressiveDCETest, PartiallyDeadGroupMemberDecorateDifferentGroupDecorate) { const std::string text = R"( ; CHECK: OpDecorate [[grp:%\w+]] Offset 0 ; CHECK: OpDecorate [[grp]] RelaxedPrecision ; CHECK: [[grp]] = OpDecorationGroup ; CHECK: OpGroupMemberDecorate [[grp]] [[output:%\w+]] 1 ; CHECK-NOT: OpGroupMemberDecorate ; CHECK: [[output]] = OpTypeStruct ; CHECK-NOT: OpTypeStruct OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %output OpExecutionMode %main OriginUpperLeft OpDecorate %1 Offset 0 OpDecorate %1 RelaxedPrecision %1 = OpDecorationGroup OpGroupMemberDecorate %1 %var_struct 0 OpGroupMemberDecorate %1 %output_struct 1 %void = OpTypeVoid %func = OpTypeFunction %void %uint = OpTypeInt 32 0 %var_struct = OpTypeStruct %uint %uint %output_struct = OpTypeStruct %uint %uint %struct_ptr_Function = OpTypePointer Function %var_struct %struct_ptr_Output = OpTypePointer Output %output_struct %uint_ptr_Output = OpTypePointer Output %uint %output = OpVariable %struct_ptr_Output Output %uint_0 = OpConstant %uint 0 %main = OpFunction %void None %func %2 = OpLabel %var = OpVariable %struct_ptr_Function Function %3 = OpAccessChain %uint_ptr_Output %output %uint_0 OpStore %3 %uint_0 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } // Test for #1404 TEST_F(AggressiveDCETest, DontRemoveWorkgroupSize) { const std::string text = R"( ; CHECK: OpDecorate [[wgs:%\w+]] BuiltIn WorkgroupSize ; CHECK: [[wgs]] = OpSpecConstantComposite OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %func "func" OpExecutionMode %func LocalSize 1 1 1 OpDecorate %1 BuiltIn WorkgroupSize %void = OpTypeVoid %int = OpTypeInt 32 0 %functy = OpTypeFunction %void %v3int = OpTypeVector %int 3 %2 = OpSpecConstant %int 1 %1 = OpSpecConstantComposite %v3int %2 %2 %2 %func = OpFunction %void None %functy %3 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } // Test for #1214 TEST_F(AggressiveDCETest, LoopHeaderIsAlsoAnotherLoopMerge) { const std::string text = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" %2 OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %uint = OpTypeInt 32 0 %_ptr_Output_uint = OpTypePointer Output %uint %2 = OpVariable %_ptr_Output_uint Output %uint_0 = OpConstant %uint 0 %9 = OpTypeFunction %void %1 = OpFunction %void None %9 %10 = OpLabel OpBranch %11 %11 = OpLabel OpLoopMerge %12 %13 None OpBranchConditional %true %14 %13 %14 = OpLabel OpStore %2 %uint_0 OpLoopMerge %15 %16 None OpBranchConditional %true %15 %16 %16 = OpLabel OpBranch %14 %15 = OpLabel OpBranchConditional %true %12 %13 %13 = OpLabel OpBranch %11 %12 = OpLabel %17 = OpPhi %uint %uint_0 %15 %uint_0 %18 OpStore %2 %17 OpLoopMerge %19 %18 None OpBranchConditional %true %19 %18 %18 = OpLabel OpBranch %12 %19 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(text, text, true, true); } TEST_F(AggressiveDCETest, BreaksDontVisitPhis) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" %var OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %int = OpTypeInt 32 0 %int_ptr_Output = OpTypePointer Output %int %var = OpVariable %int_ptr_Output Output %int0 = OpConstant %int 0 %functy = OpTypeFunction %void %func = OpFunction %void None %functy %entry = OpLabel OpBranch %outer_header %outer_header = OpLabel OpLoopMerge %outer_merge %outer_continue None OpBranchConditional %true %inner_header %outer_continue %inner_header = OpLabel %phi = OpPhi %int %int0 %outer_header %int0 %inner_continue OpStore %var %phi OpLoopMerge %inner_merge %inner_continue None OpBranchConditional %true %inner_merge %inner_continue %inner_continue = OpLabel OpBranch %inner_header %inner_merge = OpLabel OpBranch %outer_continue %outer_continue = OpLabel %p = OpPhi %int %int0 %outer_header %int0 %inner_merge OpStore %var %p OpBranch %outer_header %outer_merge = OpLabel OpReturn OpFunctionEnd )"; EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(SinglePassRunAndDisassemble( text, false, true))); } // Test for #1212 TEST_F(AggressiveDCETest, ConstStoreInnerLoop) { const std::string text = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "main" %2 %void = OpTypeVoid %4 = OpTypeFunction %void %float = OpTypeFloat 32 %bool = OpTypeBool %true = OpConstantTrue %bool %_ptr_Output_float = OpTypePointer Output %float %2 = OpVariable %_ptr_Output_float Output %float_3 = OpConstant %float 3 %1 = OpFunction %void None %4 %13 = OpLabel OpBranch %14 %14 = OpLabel OpLoopMerge %15 %16 None OpBranchConditional %true %17 %15 %17 = OpLabel OpStore %2 %float_3 OpLoopMerge %18 %17 None OpBranchConditional %true %18 %17 %18 = OpLabel OpBranch %15 %16 = OpLabel OpBranch %14 %15 = OpLabel OpBranch %20 %20 = OpLabel OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(text, text, true, true); } // Test for #1212 TEST_F(AggressiveDCETest, InnerLoopCopy) { const std::string text = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "main" %2 %3 %void = OpTypeVoid %5 = OpTypeFunction %void %float = OpTypeFloat 32 %bool = OpTypeBool %true = OpConstantTrue %bool %_ptr_Output_float = OpTypePointer Output %float %_ptr_Input_float = OpTypePointer Input %float %2 = OpVariable %_ptr_Output_float Output %3 = OpVariable %_ptr_Input_float Input %1 = OpFunction %void None %5 %14 = OpLabel OpBranch %15 %15 = OpLabel OpLoopMerge %16 %17 None OpBranchConditional %true %18 %16 %18 = OpLabel %19 = OpLoad %float %3 OpStore %2 %19 OpLoopMerge %20 %18 None OpBranchConditional %true %20 %18 %20 = OpLabel OpBranch %16 %17 = OpLabel OpBranch %15 %16 = OpLabel OpBranch %22 %22 = OpLabel OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(text, text, true, true); } TEST_F(AggressiveDCETest, AtomicAdd) { const std::string text = R"(OpCapability SampledBuffer OpCapability StorageImageExtendedFormats OpCapability ImageBuffer OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "min" OpExecutionMode %2 LocalSize 64 1 1 OpSource HLSL 600 OpDecorate %4 DescriptorSet 4 OpDecorate %4 Binding 70 %uint = OpTypeInt 32 0 %6 = OpTypeImage %uint Buffer 0 0 0 2 R32ui %_ptr_UniformConstant_6 = OpTypePointer UniformConstant %6 %_ptr_Private_6 = OpTypePointer Private %6 %void = OpTypeVoid %10 = OpTypeFunction %void %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %_ptr_Image_uint = OpTypePointer Image %uint %4 = OpVariable %_ptr_UniformConstant_6 UniformConstant %16 = OpVariable %_ptr_Private_6 Private %2 = OpFunction %void None %10 %17 = OpLabel %18 = OpLoad %6 %4 OpStore %16 %18 %19 = OpImageTexelPointer %_ptr_Image_uint %16 %uint_0 %uint_0 %20 = OpAtomicIAdd %uint %19 %uint_1 %uint_0 %uint_1 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(text, text, true, true); } TEST_F(AggressiveDCETest, SafelyRemoveDecorateString) { const std::string preamble = R"(OpCapability Shader OpExtension "SPV_GOOGLE_hlsl_functionality1" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft )"; const std::string body_before = R"(OpDecorateStringGOOGLE %2 HlslSemanticGOOGLE "FOOBAR" %void = OpTypeVoid %4 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_ptr_StorageBuffer_uint = OpTypePointer StorageBuffer %uint %2 = OpVariable %_ptr_StorageBuffer_uint StorageBuffer %1 = OpFunction %void None %4 %7 = OpLabel OpReturn OpFunctionEnd )"; const std::string body_after = R"(%void = OpTypeVoid %4 = OpTypeFunction %void %1 = OpFunction %void None %4 %7 = OpLabel OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(preamble + body_before, preamble + body_after, true, true); } TEST_F(AggressiveDCETest, CopyMemoryToGlobal) { // |local| is loaded in an OpCopyMemory instruction. So the store must be // kept alive. const std::string test = R"(OpCapability Geometry %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Geometry %main "main" %global OpExecutionMode %main Triangles OpExecutionMode %main Invocations 1 OpExecutionMode %main OutputTriangleStrip OpExecutionMode %main OutputVertices 5 OpSource GLSL 440 OpName %main "main" OpName %local "local" OpName %global "global" %void = OpTypeVoid %7 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %12 = OpConstantNull %v4float %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %global = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %7 %19 = OpLabel %local = OpVariable %_ptr_Function_v4float Function OpStore %local %12 OpCopyMemory %global %local OpEndPrimitive OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(test, test, true, true); } TEST_F(AggressiveDCETest, CopyMemoryToLocal) { // Make sure the store to |local2| using OpCopyMemory is kept and keeps // |local1| alive. const std::string test = R"(OpCapability Geometry %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Geometry %main "main" %global OpExecutionMode %main Triangles OpExecutionMode %main Invocations 1 OpExecutionMode %main OutputTriangleStrip OpExecutionMode %main OutputVertices 5 OpSource GLSL 440 OpName %main "main" OpName %local1 "local1" OpName %local2 "local2" OpName %global "global" %void = OpTypeVoid %7 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %12 = OpConstantNull %v4float %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %global = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %7 %19 = OpLabel %local1 = OpVariable %_ptr_Function_v4float Function %local2 = OpVariable %_ptr_Function_v4float Function OpStore %local1 %12 OpCopyMemory %local2 %local1 OpCopyMemory %global %local2 OpEndPrimitive OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(test, test, true, true); } TEST_F(AggressiveDCETest, RemoveCopyMemoryToLocal) { // Test that we remove function scope variables that are stored to using // OpCopyMemory, but are never loaded. We can remove both |local1| and // |local2|. const std::string test = R"(OpCapability Geometry %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Geometry %main "main" %global OpExecutionMode %main Triangles OpExecutionMode %main Invocations 1 OpExecutionMode %main OutputTriangleStrip OpExecutionMode %main OutputVertices 5 OpSource GLSL 440 OpName %main "main" OpName %local1 "local1" OpName %local2 "local2" OpName %global "global" %void = OpTypeVoid %7 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %12 = OpConstantNull %v4float %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %global = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %7 %19 = OpLabel %local1 = OpVariable %_ptr_Function_v4float Function %local2 = OpVariable %_ptr_Function_v4float Function OpStore %local1 %12 OpCopyMemory %local2 %local1 OpEndPrimitive OpReturn OpFunctionEnd )"; const std::string result = R"(OpCapability Geometry %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Geometry %main "main" %global OpExecutionMode %main Triangles OpExecutionMode %main Invocations 1 OpExecutionMode %main OutputTriangleStrip OpExecutionMode %main OutputVertices 5 OpSource GLSL 440 OpName %main "main" OpName %global "global" %void = OpTypeVoid %7 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %global = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %7 %19 = OpLabel OpEndPrimitive OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(test, result, true, true); } TEST_F(AggressiveDCETest, RemoveCopyMemoryToLocal2) { // We are able to remove "local2" because it is not loaded, but have to keep // the stores to "local1". const std::string test = R"(OpCapability Geometry %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Geometry %main "main" %global OpExecutionMode %main Triangles OpExecutionMode %main Invocations 1 OpExecutionMode %main OutputTriangleStrip OpExecutionMode %main OutputVertices 5 OpSource GLSL 440 OpName %main "main" OpName %local1 "local1" OpName %local2 "local2" OpName %global "global" %void = OpTypeVoid %7 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %12 = OpConstantNull %v4float %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %global = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %7 %19 = OpLabel %local1 = OpVariable %_ptr_Function_v4float Function %local2 = OpVariable %_ptr_Function_v4float Function OpStore %local1 %12 OpCopyMemory %local2 %local1 OpCopyMemory %global %local1 OpEndPrimitive OpReturn OpFunctionEnd )"; const std::string result = R"(OpCapability Geometry %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Geometry %main "main" %global OpExecutionMode %main Triangles OpExecutionMode %main Invocations 1 OpExecutionMode %main OutputTriangleStrip OpExecutionMode %main OutputVertices 5 OpSource GLSL 440 OpName %main "main" OpName %local1 "local1" OpName %global "global" %void = OpTypeVoid %7 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %12 = OpConstantNull %v4float %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %global = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %7 %19 = OpLabel %local1 = OpVariable %_ptr_Function_v4float Function OpStore %local1 %12 OpCopyMemory %global %local1 OpEndPrimitive OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(test, result, true, true); } TEST_F(AggressiveDCETest, StructuredIfWithConditionalExit) { // We are able to remove "local2" because it is not loaded, but have to keep // the stores to "local1". const std::string test = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpName %main "main" OpName %a "a" %void = OpTypeVoid %5 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Uniform_int = OpTypePointer Uniform %int %int_0 = OpConstant %int 0 %bool = OpTypeBool %int_100 = OpConstant %int 100 %int_1 = OpConstant %int 1 %a = OpVariable %_ptr_Uniform_int Uniform %main = OpFunction %void None %5 %12 = OpLabel %13 = OpLoad %int %a %14 = OpSGreaterThan %bool %13 %int_0 OpSelectionMerge %15 None OpBranchConditional %14 %16 %15 %16 = OpLabel %17 = OpLoad %int %a %18 = OpSLessThan %bool %17 %int_100 OpBranchConditional %18 %19 %15 %19 = OpLabel OpStore %a %int_1 OpBranch %15 %15 = OpLabel OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(test, test, true, true); } TEST_F(AggressiveDCETest, CountingLoopNotEliminated) { // #version 310 es // // precision highp float; // precision highp int; // // layout(location = 0) out vec4 _GLF_color; // // void main() // { // float data[1]; // for (int c = 0; c < 1; c++) { // if (true) { // do { // for (int i = 0; i < 1; i++) { // data[i] = 1.0; // } // } while (false); // } // } // _GLF_color = vec4(data[0], 0.0, 0.0, 1.0); // } const std::string test = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %_GLF_color OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %c "c" OpName %i "i" OpName %data "data" OpName %_GLF_color "_GLF_color" OpDecorate %_GLF_color Location 0 %void = OpTypeVoid %8 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %bool = OpTypeBool %float = OpTypeFloat 32 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %_ptr_Function__arr_float_uint_1 = OpTypePointer Function %_arr_float_uint_1 %float_1 = OpConstant %float 1 %_ptr_Function_float = OpTypePointer Function %float %false = OpConstantFalse %bool %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %_GLF_color = OpVariable %_ptr_Output_v4float Output %float_0 = OpConstant %float 0 %main = OpFunction %void None %8 %26 = OpLabel %c = OpVariable %_ptr_Function_int Function %i = OpVariable %_ptr_Function_int Function %data = OpVariable %_ptr_Function__arr_float_uint_1 Function OpStore %c %int_0 OpBranch %27 %27 = OpLabel OpLoopMerge %28 %29 None OpBranch %30 %30 = OpLabel %31 = OpLoad %int %c %32 = OpSLessThan %bool %31 %int_1 OpBranchConditional %32 %33 %28 %33 = OpLabel OpBranch %34 %34 = OpLabel OpBranch %35 %35 = OpLabel OpLoopMerge %36 %37 None OpBranch %38 %38 = OpLabel OpStore %i %int_0 OpBranch %39 %39 = OpLabel OpLoopMerge %40 %41 None OpBranch %42 %42 = OpLabel %43 = OpLoad %int %i %44 = OpSLessThan %bool %43 %int_1 OpBranchConditional %44 %46 %40 %46 = OpLabel %47 = OpLoad %int %i %48 = OpAccessChain %_ptr_Function_float %data %47 OpStore %48 %float_1 OpBranch %41 %41 = OpLabel %49 = OpLoad %int %i %50 = OpIAdd %int %49 %int_1 OpStore %i %50 OpBranch %39 %40 = OpLabel OpBranch %37 %37 = OpLabel OpBranchConditional %false %35 %36 %36 = OpLabel OpBranch %45 %45 = OpLabel OpBranch %29 %29 = OpLabel %51 = OpLoad %int %c %52 = OpIAdd %int %51 %int_1 OpStore %c %52 OpBranch %27 %28 = OpLabel %53 = OpAccessChain %_ptr_Function_float %data %int_0 %54 = OpLoad %float %53 %55 = OpCompositeConstruct %v4float %54 %float_0 %float_0 %float_1 OpStore %_GLF_color %55 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(test, test, true, true); } TEST_F(AggressiveDCETest, EliminateLoopWithUnreachable) { // #version 430 // // layout(std430) buffer U_t // { // float g_F[10]; // float g_S; // }; // // layout(location = 0)out float o; // // void main(void) // { // // Useless loop // for (int i = 0; i<10; i++) { // if (g_F[i] == 0.0) // break; // else // break; // // Unreachable merge block created here. // // Need to edit SPIR-V to change to OpUnreachable // } // o = g_S; // } const std::string before = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %o OpExecutionMode %main OriginUpperLeft OpSource GLSL 430 OpName %main "main" OpName %i "i" OpName %U_t "U_t" OpMemberName %U_t 0 "g_F" OpMemberName %U_t 1 "g_S" OpName %_ "" OpName %o "o" OpDecorate %_arr_float_uint_10 ArrayStride 4 OpMemberDecorate %U_t 0 Offset 0 OpMemberDecorate %U_t 1 Offset 40 OpDecorate %U_t BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %o Location 0 %void = OpTypeVoid %9 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %bool = OpTypeBool %float = OpTypeFloat 32 %uint = OpTypeInt 32 0 %uint_10 = OpConstant %uint 10 %_arr_float_uint_10 = OpTypeArray %float %uint_10 %U_t = OpTypeStruct %_arr_float_uint_10 %float %_ptr_Uniform_U_t = OpTypePointer Uniform %U_t %_ = OpVariable %_ptr_Uniform_U_t Uniform %_ptr_Uniform_float = OpTypePointer Uniform %float %float_0 = OpConstant %float 0 %int_1 = OpConstant %int 1 %_ptr_Output_float = OpTypePointer Output %float %o = OpVariable %_ptr_Output_float Output %main = OpFunction %void None %9 %23 = OpLabel %i = OpVariable %_ptr_Function_int Function OpStore %i %int_0 OpBranch %24 %24 = OpLabel OpLoopMerge %25 %26 None OpBranch %27 %27 = OpLabel %28 = OpLoad %int %i %29 = OpSLessThan %bool %28 %int_10 OpBranchConditional %29 %30 %25 %30 = OpLabel %31 = OpLoad %int %i %32 = OpAccessChain %_ptr_Uniform_float %_ %int_0 %31 %33 = OpLoad %float %32 %34 = OpFOrdEqual %bool %33 %float_0 OpSelectionMerge %35 None OpBranchConditional %34 %36 %37 %36 = OpLabel OpBranch %25 %37 = OpLabel OpBranch %25 %35 = OpLabel OpUnreachable %26 = OpLabel %38 = OpLoad %int %i %39 = OpIAdd %int %38 %int_1 OpStore %i %39 OpBranch %24 %25 = OpLabel %40 = OpAccessChain %_ptr_Uniform_float %_ %int_1 %41 = OpLoad %float %40 OpStore %o %41 OpReturn OpFunctionEnd )"; const std::string after = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %o OpExecutionMode %main OriginUpperLeft OpSource GLSL 430 OpName %main "main" OpName %U_t "U_t" OpMemberName %U_t 0 "g_F" OpMemberName %U_t 1 "g_S" OpName %_ "" OpName %o "o" OpDecorate %_arr_float_uint_10 ArrayStride 4 OpMemberDecorate %U_t 0 Offset 0 OpMemberDecorate %U_t 1 Offset 40 OpDecorate %U_t BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %o Location 0 %void = OpTypeVoid %9 = OpTypeFunction %void %int = OpTypeInt 32 1 %float = OpTypeFloat 32 %uint = OpTypeInt 32 0 %uint_10 = OpConstant %uint 10 %_arr_float_uint_10 = OpTypeArray %float %uint_10 %U_t = OpTypeStruct %_arr_float_uint_10 %float %_ptr_Uniform_U_t = OpTypePointer Uniform %U_t %_ = OpVariable %_ptr_Uniform_U_t Uniform %_ptr_Uniform_float = OpTypePointer Uniform %float %int_1 = OpConstant %int 1 %_ptr_Output_float = OpTypePointer Output %float %o = OpVariable %_ptr_Output_float Output %main = OpFunction %void None %9 %23 = OpLabel OpBranch %24 %24 = OpLabel OpBranch %25 %25 = OpLabel %40 = OpAccessChain %_ptr_Uniform_float %_ %int_1 %41 = OpLoad %float %40 OpStore %o %41 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(before, after, true, true); } TEST_F(AggressiveDCETest, DeadHlslCounterBufferGOOGLE) { // We are able to remove "local2" because it is not loaded, but have to keep // the stores to "local1". const std::string test = R"( ; CHECK-NOT: OpDecorateId ; CHECK: [[var:%\w+]] = OpVariable ; CHECK-NOT: OpVariable ; CHECK: [[ac:%\w+]] = OpAccessChain {{%\w+}} [[var]] ; CHECK: OpStore [[ac]] OpCapability Shader OpExtension "SPV_GOOGLE_hlsl_functionality1" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 32 1 1 OpSource HLSL 600 OpDecorate %_runtimearr_v2float ArrayStride 8 OpMemberDecorate %_struct_3 0 Offset 0 OpDecorate %_struct_3 BufferBlock OpMemberDecorate %_struct_4 0 Offset 0 OpDecorate %_struct_4 BufferBlock OpDecorateId %5 HlslCounterBufferGOOGLE %6 OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 0 OpDecorate %6 DescriptorSet 0 OpDecorate %6 Binding 1 %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %_runtimearr_v2float = OpTypeRuntimeArray %v2float %_struct_3 = OpTypeStruct %_runtimearr_v2float %_ptr_Uniform__struct_3 = OpTypePointer Uniform %_struct_3 %int = OpTypeInt 32 1 %_struct_4 = OpTypeStruct %int %_ptr_Uniform__struct_4 = OpTypePointer Uniform %_struct_4 %void = OpTypeVoid %13 = OpTypeFunction %void %19 = OpConstantNull %v2float %int_0 = OpConstant %int 0 %_ptr_Uniform_v2float = OpTypePointer Uniform %v2float %5 = OpVariable %_ptr_Uniform__struct_3 Uniform %6 = OpVariable %_ptr_Uniform__struct_4 Uniform %1 = OpFunction %void None %13 %22 = OpLabel %23 = OpAccessChain %_ptr_Uniform_v2float %5 %int_0 %int_0 OpStore %23 %19 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(test, true); } TEST_F(AggressiveDCETest, Dead) { // We are able to remove "local2" because it is not loaded, but have to keep // the stores to "local1". const std::string test = R"( ; CHECK: OpCapability ; CHECK-NOT: OpMemberDecorateStringGOOGLE ; CHECK: OpFunctionEnd OpCapability Shader OpExtension "SPV_GOOGLE_hlsl_functionality1" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %VSMain "VSMain" OpSource HLSL 500 OpName %VSMain "VSMain" OpName %PSInput "PSInput" OpMemberName %PSInput 0 "Pos" OpMemberName %PSInput 1 "uv" OpMemberDecorateStringGOOGLE %PSInput 0 HlslSemanticGOOGLE "SV_POSITION" OpMemberDecorateStringGOOGLE %PSInput 1 HlslSemanticGOOGLE "TEX_COORD" %void = OpTypeVoid %5 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %v4float = OpTypeVector %float 4 %PSInput = OpTypeStruct %v4float %v2float %VSMain = OpFunction %void None %5 %9 = OpLabel OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(test, true); } TEST_F(AggressiveDCETest, DeadInfiniteLoop) { const std::string test = R"( ; CHECK: OpSwitch {{%\w+}} {{%\w+}} {{\w+}} {{%\w+}} {{\w+}} [[block:%\w+]] ; CHECK: [[block]] = OpLabel ; CHECK-NEXT: OpBranch [[block:%\w+]] ; CHECK: [[block]] = OpLabel ; CHECK-NEXT: OpBranch [[block:%\w+]] ; CHECK: [[block]] = OpLabel ; CHECK-NEXT: OpReturn OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeFloat 32 %9 = OpTypeVector %8 3 %10 = OpTypeFunction %9 %11 = OpConstant %8 1 %12 = OpConstantComposite %9 %11 %11 %11 %13 = OpTypeInt 32 1 %32 = OpUndef %13 %2 = OpFunction %6 None %7 %33 = OpLabel OpBranch %34 %34 = OpLabel OpLoopMerge %35 %36 None OpBranch %37 %37 = OpLabel %38 = OpFunctionCall %9 %39 OpSelectionMerge %40 None OpSwitch %32 %40 14 %41 58 %42 %42 = OpLabel OpBranch %43 %43 = OpLabel OpLoopMerge %44 %45 None OpBranch %45 %45 = OpLabel OpBranch %43 %44 = OpLabel OpUnreachable %41 = OpLabel OpBranch %36 %40 = OpLabel OpBranch %36 %36 = OpLabel OpBranch %34 %35 = OpLabel OpReturn OpFunctionEnd %39 = OpFunction %9 None %10 %46 = OpLabel OpReturnValue %12 OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(test, true); } TEST_F(AggressiveDCETest, DeadInfiniteLoopReturnValue) { const std::string test = R"( ; CHECK: [[vec3:%\w+]] = OpTypeVector ; CHECK: [[undef:%\w+]] = OpUndef [[vec3]] ; CHECK: OpSwitch {{%\w+}} {{%\w+}} {{\w+}} {{%\w+}} {{\w+}} [[block:%\w+]] ; CHECK: [[block]] = OpLabel ; CHECK-NEXT: OpBranch [[block:%\w+]] ; CHECK: [[block]] = OpLabel ; CHECK-NEXT: OpBranch [[block:%\w+]] ; CHECK: [[block]] = OpLabel ; CHECK-NEXT: OpReturnValue [[undef]] OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeFloat 32 %9 = OpTypeVector %8 3 %10 = OpTypeFunction %9 %11 = OpConstant %8 1 %12 = OpConstantComposite %9 %11 %11 %11 %13 = OpTypeInt 32 1 %32 = OpUndef %13 %2 = OpFunction %6 None %7 %entry = OpLabel %call = OpFunctionCall %9 %func OpReturn OpFunctionEnd %func = OpFunction %9 None %10 %33 = OpLabel OpBranch %34 %34 = OpLabel OpLoopMerge %35 %36 None OpBranch %37 %37 = OpLabel %38 = OpFunctionCall %9 %39 OpSelectionMerge %40 None OpSwitch %32 %40 14 %41 58 %42 %42 = OpLabel OpBranch %43 %43 = OpLabel OpLoopMerge %44 %45 None OpBranch %45 %45 = OpLabel OpBranch %43 %44 = OpLabel OpUnreachable %41 = OpLabel OpBranch %36 %40 = OpLabel OpBranch %36 %36 = OpLabel OpBranch %34 %35 = OpLabel OpReturnValue %12 OpFunctionEnd %39 = OpFunction %9 None %10 %46 = OpLabel OpReturnValue %12 OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(test, true); } TEST_F(AggressiveDCETest, TestVariablePointer) { const std::string before = R"(OpCapability Shader OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" OpExecutionMode %2 LocalSize 1 1 1 OpSource GLSL 450 OpMemberDecorate %_struct_3 0 Offset 0 OpDecorate %_struct_3 Block OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 0 OpDecorate %_ptr_StorageBuffer_int ArrayStride 4 OpDecorate %_arr_int_int_128 ArrayStride 4 %void = OpTypeVoid %8 = OpTypeFunction %void %int = OpTypeInt 32 1 %int_128 = OpConstant %int 128 %_arr_int_int_128 = OpTypeArray %int %int_128 %_struct_3 = OpTypeStruct %_arr_int_int_128 %_ptr_StorageBuffer__struct_3 = OpTypePointer StorageBuffer %_struct_3 %4 = OpVariable %_ptr_StorageBuffer__struct_3 StorageBuffer %bool = OpTypeBool %true = OpConstantTrue %bool %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %_ptr_StorageBuffer_int = OpTypePointer StorageBuffer %int %2 = OpFunction %void None %8 %16 = OpLabel %17 = OpAccessChain %_ptr_StorageBuffer_int %4 %int_0 %int_0 OpBranch %18 %18 = OpLabel %19 = OpPhi %_ptr_StorageBuffer_int %17 %16 %20 %21 OpLoopMerge %22 %21 None OpBranchConditional %true %23 %22 %23 = OpLabel OpStore %19 %int_0 OpBranch %21 %21 = OpLabel %20 = OpPtrAccessChain %_ptr_StorageBuffer_int %19 %int_1 OpBranch %18 %22 = OpLabel OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(before, before, true, true); } TEST_F(AggressiveDCETest, DeadInputInterfaceV13) { const std::string spirv = R"( ; CHECK: OpEntryPoint GLCompute %main "main" ; CHECK-NOT: OpVariable OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %dead OpExecutionMode %main LocalSize 1 1 1 OpName %main "main" %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr_input_int = OpTypePointer Input %int %dead = OpVariable %ptr_input_int Input %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_UNIVERSAL_1_3); SinglePassRunAndMatch(spirv, true); } TEST_F(AggressiveDCETest, DeadInputInterfaceV14) { const std::string spirv = R"( ; CHECK: OpEntryPoint GLCompute %main "main" ; CHECK-NOT: OpVariable OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %dead OpExecutionMode %main LocalSize 1 1 1 OpName %main "main" %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr_input_int = OpTypePointer Input %int %dead = OpVariable %ptr_input_int Input %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_UNIVERSAL_1_4); SinglePassRunAndMatch(spirv, true); } TEST_F(AggressiveDCETest, DeadInterfaceV14) { const std::string spirv = R"( ; CHECK-NOT: OpEntryPoint GLCompute %main "main" % ; CHECK: OpEntryPoint GLCompute %main "main" ; CHECK-NOT: OpVariable OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %dead OpExecutionMode %main LocalSize 1 1 1 OpName %main "main" %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr_private_int = OpTypePointer Private %int %dead = OpVariable %ptr_private_int Private %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_UNIVERSAL_1_4); SinglePassRunAndMatch(spirv, true); } TEST_F(AggressiveDCETest, DeadInterfacesV14) { const std::string spirv = R"( ; CHECK: OpEntryPoint GLCompute %main "main" %live1 %live2 ; CHECK-NOT: %dead OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %live1 %dead1 %dead2 %live2 OpExecutionMode %main LocalSize 1 1 1 OpName %main "main" OpName %live1 "live1" OpName %live2 "live2" OpName %dead1 "dead1" OpName %dead2 "dead2" %void = OpTypeVoid %int = OpTypeInt 32 0 %int0 = OpConstant %int 0 %ptr_ssbo_int = OpTypePointer StorageBuffer %int %live1 = OpVariable %ptr_ssbo_int StorageBuffer %live2 = OpVariable %ptr_ssbo_int StorageBuffer %dead1 = OpVariable %ptr_ssbo_int StorageBuffer %dead2 = OpVariable %ptr_ssbo_int StorageBuffer %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpStore %live1 %int0 OpStore %live2 %int0 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_UNIVERSAL_1_4); SinglePassRunAndMatch(spirv, true); } TEST_F(AggressiveDCETest, PreserveBindings) { const std::string spirv = R"( ; CHECK: OpDecorate %unusedSampler DescriptorSet 0 ; CHECK: OpDecorate %unusedSampler Binding 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 430 OpName %main "main" OpName %unusedSampler "unusedSampler" OpDecorate %unusedSampler DescriptorSet 0 OpDecorate %unusedSampler Binding 0 %void = OpTypeVoid %5 = OpTypeFunction %void %float = OpTypeFloat 32 %7 = OpTypeImage %float 2D 0 0 0 1 Unknown %8 = OpTypeSampledImage %7 %_ptr_UniformConstant_8 = OpTypePointer UniformConstant %8 %unusedSampler = OpVariable %_ptr_UniformConstant_8 UniformConstant %main = OpFunction %void None %5 %10 = OpLabel OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_UNIVERSAL_1_4); OptimizerOptions()->preserve_bindings_ = true; SinglePassRunAndMatch(spirv, true); } TEST_F(AggressiveDCETest, PreserveSpecConstants) { const std::string spirv = R"( ; CHECK: OpName %specConstant "specConstant" ; CHECK: %specConstant = OpSpecConstant %int 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 430 OpName %main "main" OpName %specConstant "specConstant" OpDecorate %specConstant SpecId 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %specConstant = OpSpecConstant %int 0 %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_UNIVERSAL_1_4); OptimizerOptions()->preserve_spec_constants_ = true; SinglePassRunAndMatch(spirv, true); } TEST_F(AggressiveDCETest, LiveDecorateId) { const std::string spirv = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %2 OpExecutionMode %1 LocalSize 8 1 1 OpDecorate %2 DescriptorSet 0 OpDecorate %2 Binding 0 OpDecorateId %3 UniformId %uint_2 %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_ptr_StorageBuffer_uint = OpTypePointer StorageBuffer %uint %2 = OpVariable %_ptr_StorageBuffer_uint StorageBuffer %8 = OpTypeFunction %void %1 = OpFunction %void None %8 %9 = OpLabel %3 = OpLoad %uint %2 OpStore %2 %3 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_UNIVERSAL_1_4); OptimizerOptions()->preserve_spec_constants_ = true; SinglePassRunAndCheck(spirv, spirv, true); } TEST_F(AggressiveDCETest, LiveDecorateIdOnGroup) { const std::string spirv = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %2 OpExecutionMode %1 LocalSize 8 1 1 OpDecorate %2 DescriptorSet 0 OpDecorate %2 Binding 0 OpDecorateId %3 UniformId %uint_2 %3 = OpDecorationGroup OpGroupDecorate %3 %5 %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_ptr_StorageBuffer_uint = OpTypePointer StorageBuffer %uint %2 = OpVariable %_ptr_StorageBuffer_uint StorageBuffer %9 = OpTypeFunction %void %1 = OpFunction %void None %9 %10 = OpLabel %5 = OpLoad %uint %2 OpStore %2 %5 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_UNIVERSAL_1_4); OptimizerOptions()->preserve_spec_constants_ = true; SinglePassRunAndCheck(spirv, spirv, true); } TEST_F(AggressiveDCETest, NoEliminateForwardPointer) { // clang-format off // // #version 450 // #extension GL_EXT_buffer_reference : enable // // // forward reference // layout(buffer_reference) buffer blockType; // // layout(buffer_reference, std430, buffer_reference_align = 16) buffer blockType { // int x; // blockType next; // }; // // layout(std430) buffer rootBlock { // blockType root; // } r; // // void main() // { // blockType b = r.root; // b = b.next; // b.x = 531; // } // // clang-format on const std::string predefs1 = R"(OpCapability Shader OpCapability PhysicalStorageBufferAddresses OpExtension "SPV_EXT_physical_storage_buffer" OpExtension "SPV_KHR_storage_buffer_storage_class" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpSourceExtension "GL_EXT_buffer_reference" )"; const std::string names_before = R"(OpName %main "main" OpName %blockType "blockType" OpMemberName %blockType 0 "x" OpMemberName %blockType 1 "next" OpName %b "b" OpName %rootBlock "rootBlock" OpMemberName %rootBlock 0 "root" OpName %r "r" OpMemberDecorate %blockType 0 Offset 0 OpMemberDecorate %blockType 1 Offset 8 OpDecorate %blockType Block OpDecorate %b AliasedPointer OpMemberDecorate %rootBlock 0 Offset 0 OpDecorate %rootBlock Block OpDecorate %r DescriptorSet 0 OpDecorate %r Binding 0 )"; const std::string names_after = R"(OpName %main "main" OpName %blockType "blockType" OpMemberName %blockType 0 "x" OpMemberName %blockType 1 "next" OpName %rootBlock "rootBlock" OpMemberName %rootBlock 0 "root" OpName %r "r" OpMemberDecorate %blockType 0 Offset 0 OpMemberDecorate %blockType 1 Offset 8 OpDecorate %blockType Block OpMemberDecorate %rootBlock 0 Offset 0 OpDecorate %rootBlock Block OpDecorate %r DescriptorSet 0 OpDecorate %r Binding 0 )"; const std::string predefs2_before = R"(%void = OpTypeVoid %3 = OpTypeFunction %void OpTypeForwardPointer %_ptr_PhysicalStorageBuffer_blockType PhysicalStorageBuffer %int = OpTypeInt 32 1 %blockType = OpTypeStruct %int %_ptr_PhysicalStorageBuffer_blockType %_ptr_PhysicalStorageBuffer_blockType = OpTypePointer PhysicalStorageBuffer %blockType %_ptr_Function__ptr_PhysicalStorageBuffer_blockType = OpTypePointer Function %_ptr_PhysicalStorageBuffer_blockType %rootBlock = OpTypeStruct %_ptr_PhysicalStorageBuffer_blockType %_ptr_StorageBuffer_rootBlock = OpTypePointer StorageBuffer %rootBlock %r = OpVariable %_ptr_StorageBuffer_rootBlock StorageBuffer %int_0 = OpConstant %int 0 %_ptr_StorageBuffer__ptr_PhysicalStorageBuffer_blockType = OpTypePointer StorageBuffer %_ptr_PhysicalStorageBuffer_blockType %int_1 = OpConstant %int 1 %_ptr_PhysicalStorageBuffer__ptr_PhysicalStorageBuffer_blockType = OpTypePointer PhysicalStorageBuffer %_ptr_PhysicalStorageBuffer_blockType %int_531 = OpConstant %int 531 %_ptr_PhysicalStorageBuffer_int = OpTypePointer PhysicalStorageBuffer %int )"; const std::string predefs2_after = R"(%void = OpTypeVoid %8 = OpTypeFunction %void OpTypeForwardPointer %_ptr_PhysicalStorageBuffer_blockType PhysicalStorageBuffer %int = OpTypeInt 32 1 %blockType = OpTypeStruct %int %_ptr_PhysicalStorageBuffer_blockType %_ptr_PhysicalStorageBuffer_blockType = OpTypePointer PhysicalStorageBuffer %blockType %rootBlock = OpTypeStruct %_ptr_PhysicalStorageBuffer_blockType %_ptr_StorageBuffer_rootBlock = OpTypePointer StorageBuffer %rootBlock %r = OpVariable %_ptr_StorageBuffer_rootBlock StorageBuffer %int_0 = OpConstant %int 0 %_ptr_StorageBuffer__ptr_PhysicalStorageBuffer_blockType = OpTypePointer StorageBuffer %_ptr_PhysicalStorageBuffer_blockType %int_1 = OpConstant %int 1 %_ptr_PhysicalStorageBuffer__ptr_PhysicalStorageBuffer_blockType = OpTypePointer PhysicalStorageBuffer %_ptr_PhysicalStorageBuffer_blockType %int_531 = OpConstant %int 531 %_ptr_PhysicalStorageBuffer_int = OpTypePointer PhysicalStorageBuffer %int )"; const std::string func_before = R"(%main = OpFunction %void None %3 %5 = OpLabel %b = OpVariable %_ptr_Function__ptr_PhysicalStorageBuffer_blockType Function %16 = OpAccessChain %_ptr_StorageBuffer__ptr_PhysicalStorageBuffer_blockType %r %int_0 %17 = OpLoad %_ptr_PhysicalStorageBuffer_blockType %16 %21 = OpAccessChain %_ptr_PhysicalStorageBuffer__ptr_PhysicalStorageBuffer_blockType %17 %int_1 %22 = OpLoad %_ptr_PhysicalStorageBuffer_blockType %21 Aligned 8 OpStore %b %22 %26 = OpAccessChain %_ptr_PhysicalStorageBuffer_int %22 %int_0 OpStore %26 %int_531 Aligned 16 OpReturn OpFunctionEnd )"; const std::string func_after = R"(%main = OpFunction %void None %8 %19 = OpLabel %20 = OpAccessChain %_ptr_StorageBuffer__ptr_PhysicalStorageBuffer_blockType %r %int_0 %21 = OpLoad %_ptr_PhysicalStorageBuffer_blockType %20 %22 = OpAccessChain %_ptr_PhysicalStorageBuffer__ptr_PhysicalStorageBuffer_blockType %21 %int_1 %23 = OpLoad %_ptr_PhysicalStorageBuffer_blockType %22 Aligned 8 %24 = OpAccessChain %_ptr_PhysicalStorageBuffer_int %23 %int_0 OpStore %24 %int_531 Aligned 16 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck( predefs1 + names_before + predefs2_before + func_before, predefs1 + names_after + predefs2_after + func_after, true, true); } TEST_F(AggressiveDCETest, MultipleFunctionProcessIndependently) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %entryHistogram "entryHistogram" %gl_GlobalInvocationID %gl_LocalInvocationIndex OpEntryPoint GLCompute %entryAverage "entryAverage" %gl_GlobalInvocationID %gl_LocalInvocationIndex OpExecutionMode %entryHistogram LocalSize 16 16 1 OpExecutionMode %entryAverage LocalSize 256 1 1 OpSource HLSL 640 OpName %type_RWStructuredBuffer_uint "type.RWStructuredBuffer.uint" OpName %uHistogram "uHistogram" OpName %type_ACSBuffer_counter "type.ACSBuffer.counter" OpMemberName %type_ACSBuffer_counter 0 "counter" OpName %counter_var_uHistogram "counter.var.uHistogram" OpName %sharedHistogram "sharedHistogram" OpName %entryHistogram "entryHistogram" OpName %param_var_id "param.var.id" OpName %param_var_idx "param.var.idx" OpName %entryAverage "entryAverage" OpName %param_var_id_0 "param.var.id" OpName %param_var_idx_0 "param.var.idx" OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId OpDecorate %gl_LocalInvocationIndex BuiltIn LocalInvocationIndex OpDecorate %uHistogram DescriptorSet 0 OpDecorate %uHistogram Binding 0 OpDecorate %counter_var_uHistogram DescriptorSet 0 OpDecorate %counter_var_uHistogram Binding 1 OpDecorate %_runtimearr_uint ArrayStride 4 OpMemberDecorate %type_RWStructuredBuffer_uint 0 Offset 0 OpDecorate %type_RWStructuredBuffer_uint BufferBlock OpMemberDecorate %type_ACSBuffer_counter 0 Offset 0 OpDecorate %type_ACSBuffer_counter BufferBlock %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %uint_4 = OpConstant %uint 4 %uint_8 = OpConstant %uint 8 %uint_16 = OpConstant %uint 16 %uint_32 = OpConstant %uint 32 %uint_64 = OpConstant %uint 64 %uint_128 = OpConstant %uint 128 %uint_256 = OpConstant %uint 256 %uint_512 = OpConstant %uint 512 %uint_254 = OpConstant %uint 254 %uint_255 = OpConstant %uint 255 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_runtimearr_uint = OpTypeRuntimeArray %uint %type_RWStructuredBuffer_uint = OpTypeStruct %_runtimearr_uint %_ptr_Uniform_type_RWStructuredBuffer_uint = OpTypePointer Uniform %type_RWStructuredBuffer_uint %type_ACSBuffer_counter = OpTypeStruct %int %_ptr_Uniform_type_ACSBuffer_counter = OpTypePointer Uniform %type_ACSBuffer_counter %_arr_uint_uint_256 = OpTypeArray %uint %uint_256 %_ptr_Workgroup__arr_uint_uint_256 = OpTypePointer Workgroup %_arr_uint_uint_256 %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %_ptr_Input_uint = OpTypePointer Input %uint %void = OpTypeVoid %49 = OpTypeFunction %void %_ptr_Function_v3uint = OpTypePointer Function %v3uint %_ptr_Function_uint = OpTypePointer Function %uint %52 = OpTypeFunction %void %_ptr_Function_v3uint %_ptr_Function_uint %_ptr_Workgroup_uint = OpTypePointer Workgroup %uint %uint_264 = OpConstant %uint 264 %bool = OpTypeBool %_ptr_Uniform_uint = OpTypePointer Uniform %uint %uHistogram = OpVariable %_ptr_Uniform_type_RWStructuredBuffer_uint Uniform %counter_var_uHistogram = OpVariable %_ptr_Uniform_type_ACSBuffer_counter Uniform %sharedHistogram = OpVariable %_ptr_Workgroup__arr_uint_uint_256 Workgroup %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %gl_LocalInvocationIndex = OpVariable %_ptr_Input_uint Input %entryHistogram = OpFunction %void None %49 %57 = OpLabel %param_var_id = OpVariable %_ptr_Function_v3uint Function %param_var_idx = OpVariable %_ptr_Function_uint Function %58 = OpLoad %v3uint %gl_GlobalInvocationID %59 = OpLoad %uint %gl_LocalInvocationIndex %79 = OpAccessChain %_ptr_Workgroup_uint %sharedHistogram %int_0 %80 = OpAtomicIAdd %uint %79 %uint_1 %uint_0 %uint_1 OpReturn OpFunctionEnd %entryAverage = OpFunction %void None %49 %63 = OpLabel %param_var_id_0 = OpVariable %_ptr_Function_v3uint Function %param_var_idx_0 = OpVariable %_ptr_Function_uint Function %64 = OpLoad %v3uint %gl_GlobalInvocationID %65 = OpLoad %uint %gl_LocalInvocationIndex OpStore %param_var_idx_0 %65 %83 = OpAccessChain %_ptr_Workgroup_uint %sharedHistogram %65 OpStore %83 %uint_0 ; CHECK: [[ieq:%\w+]] = OpIEqual ; CHECK-NEXT: OpSelectionMerge [[merge:%\w+]] ; CHECK-NEXT: OpBranchConditional [[ieq]] [[not_elim:%\w+]] [[merge]] ; CHECK-NEXT: [[not_elim]] = OpLabel ; CHECK: [[merge]] = OpLabel OpControlBarrier %uint_2 %uint_2 %uint_264 %85 = OpIEqual %bool %65 %uint_0 OpSelectionMerge %89 None OpBranchConditional %85 %86 %89 %86 = OpLabel %88 = OpAccessChain %_ptr_Workgroup_uint %sharedHistogram %65 OpStore %88 %uint_1 OpBranch %89 %89 = OpLabel OpControlBarrier %uint_2 %uint_2 %uint_264 %91 = OpAccessChain %_ptr_Workgroup_uint %sharedHistogram %65 %92 = OpLoad %uint %91 %94 = OpAccessChain %_ptr_Uniform_uint %uHistogram %int_0 %65 OpStore %94 %92 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_UNIVERSAL_1_3); SinglePassRunAndMatch(spirv, true); } TEST_F(AggressiveDCETest, DebugInfoKeepInFunctionElimStoreVar) { // Verify that dead local variable tc and store eliminated but all // in-function debuginfo kept. // // The SPIR-V has been inlined and local single store eliminated // // Texture2D g_tColor; // SamplerState g_sAniso; // // struct PS_INPUT { // float2 vTextureCoords : TEXCOORD2; // }; // // struct PS_OUTPUT { // float4 vColor : SV_Target0; // }; // // PS_OUTPUT MainPs(PS_INPUT i) { // PS_OUTPUT ps_output; // float2 tc = i.vTextureCoords.xy; // ps_output.vColor = g_tColor.Sample(g_sAniso, tc); // return ps_output; // } const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %MainPs "MainPs" %g_tColor %g_sAniso %in_var_TEXCOORD2 %out_var_SV_Target0 OpExecutionMode %MainPs OriginUpperLeft %7 = OpString "foo.frag" %8 = OpString "PS_OUTPUT" %9 = OpString "float" %10 = OpString "vColor" %11 = OpString "PS_INPUT" %12 = OpString "vTextureCoords" %13 = OpString "@type.2d.image" %14 = OpString "type.2d.image" %15 = OpString "Texture2D.TemplateParam" %16 = OpString "src.MainPs" %17 = OpString "tc" %18 = OpString "ps_output" %19 = OpString "i" %20 = OpString "@type.sampler" %21 = OpString "type.sampler" %22 = OpString "g_sAniso" %23 = OpString "g_tColor" OpName %type_2d_image "type.2d.image" OpName %g_tColor "g_tColor" OpName %type_sampler "type.sampler" OpName %g_sAniso "g_sAniso" OpName %in_var_TEXCOORD2 "in.var.TEXCOORD2" OpName %out_var_SV_Target0 "out.var.SV_Target0" OpName %MainPs "MainPs" OpName %PS_INPUT "PS_INPUT" OpMemberName %PS_INPUT 0 "vTextureCoords" OpName %param_var_i "param.var.i" OpName %PS_OUTPUT "PS_OUTPUT" OpMemberName %PS_OUTPUT 0 "vColor" OpName %type_sampled_image "type.sampled.image" OpDecorate %in_var_TEXCOORD2 Location 0 OpDecorate %out_var_SV_Target0 Location 0 OpDecorate %g_tColor DescriptorSet 0 OpDecorate %g_tColor Binding 0 OpDecorate %g_sAniso DescriptorSet 0 OpDecorate %g_sAniso Binding 1 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %float = OpTypeFloat 32 %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %type_sampler = OpTypeSampler %_ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %type_sampler %v2float = OpTypeVector %float 2 %_ptr_Input_v2float = OpTypePointer Input %v2float %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %uint_128 = OpConstant %uint 128 %uint_0 = OpConstant %uint 0 %uint_64 = OpConstant %uint 64 %45 = OpTypeFunction %void %PS_INPUT = OpTypeStruct %v2float %_ptr_Function_PS_INPUT = OpTypePointer Function %PS_INPUT %PS_OUTPUT = OpTypeStruct %v4float %47 = OpTypeFunction %PS_OUTPUT %_ptr_Function_PS_INPUT %_ptr_Function_PS_OUTPUT = OpTypePointer Function %PS_OUTPUT %_ptr_Function_v2float = OpTypePointer Function %v2float %type_sampled_image = OpTypeSampledImage %type_2d_image %_ptr_Function_v4float = OpTypePointer Function %v4float %g_tColor = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %g_sAniso = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %in_var_TEXCOORD2 = OpVariable %_ptr_Input_v2float Input %out_var_SV_Target0 = OpVariable %_ptr_Output_v4float Output %51 = OpExtInst %void %1 DebugInfoNone %52 = OpExtInst %void %1 DebugExpression %53 = OpExtInst %void %1 DebugOperation Deref %54 = OpExtInst %void %1 DebugExpression %53 %55 = OpExtInst %void %1 DebugSource %7 %56 = OpExtInst %void %1 DebugCompilationUnit 1 4 %55 HLSL %57 = OpExtInst %void %1 DebugTypeComposite %8 Structure %55 10 1 %56 %8 %uint_128 FlagIsProtected|FlagIsPrivate %58 %59 = OpExtInst %void %1 DebugTypeBasic %9 %uint_32 Float %60 = OpExtInst %void %1 DebugTypeVector %59 4 %58 = OpExtInst %void %1 DebugTypeMember %10 %60 %55 12 5 %57 %uint_0 %uint_128 FlagIsProtected|FlagIsPrivate %61 = OpExtInst %void %1 DebugTypeComposite %11 Structure %55 5 1 %56 %11 %uint_64 FlagIsProtected|FlagIsPrivate %62 %63 = OpExtInst %void %1 DebugTypeVector %59 2 %62 = OpExtInst %void %1 DebugTypeMember %12 %63 %55 7 5 %61 %uint_0 %uint_64 FlagIsProtected|FlagIsPrivate %64 = OpExtInst %void %1 DebugTypeComposite %13 Class %55 0 0 %56 %14 %51 FlagIsProtected|FlagIsPrivate %65 = OpExtInst %void %1 DebugTypeTemplateParameter %15 %59 %51 %55 0 0 %66 = OpExtInst %void %1 DebugTypeTemplate %64 %65 %67 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %57 %61 %68 = OpExtInst %void %1 DebugFunction %16 %67 %55 15 1 %56 %16 FlagIsProtected|FlagIsPrivate 16 %51 %69 = OpExtInst %void %1 DebugLexicalBlock %55 16 1 %68 %70 = OpExtInst %void %1 DebugLocalVariable %17 %63 %55 19 12 %69 FlagIsLocal %71 = OpExtInst %void %1 DebugLocalVariable %18 %57 %55 17 15 %69 FlagIsLocal %72 = OpExtInst %void %1 DebugLocalVariable %19 %61 %55 15 29 %68 FlagIsLocal 1 %73 = OpExtInst %void %1 DebugTypeComposite %20 Structure %55 0 0 %56 %21 %51 FlagIsProtected|FlagIsPrivate %74 = OpExtInst %void %1 DebugGlobalVariable %22 %73 %55 3 14 %56 %22 %g_sAniso FlagIsDefinition %75 = OpExtInst %void %1 DebugGlobalVariable %23 %64 %55 1 11 %56 %23 %g_tColor FlagIsDefinition %MainPs = OpFunction %void None %45 %76 = OpLabel %107 = OpExtInst %void %1 DebugScope %69 ;CHECK: {{%\w+}} = OpExtInst %void %1 DebugScope %69 %78 = OpVariable %_ptr_Function_PS_OUTPUT Function %79 = OpVariable %_ptr_Function_v2float Function %108 = OpExtInst %void %1 DebugNoScope ;CHECK: {{%\w+}} = OpExtInst %void %1 DebugNoScope %81 = OpVariable %_ptr_Function_PS_OUTPUT Function %param_var_i = OpVariable %_ptr_Function_PS_INPUT Function %82 = OpLoad %v2float %in_var_TEXCOORD2 %83 = OpCompositeConstruct %PS_INPUT %82 OpStore %param_var_i %83 %109 = OpExtInst %void %1 DebugScope %68 %85 = OpExtInst %void %1 DebugDeclare %72 %param_var_i %52 %110 = OpExtInst %void %1 DebugScope %69 %87 = OpExtInst %void %1 DebugDeclare %71 %78 %52 ;CHECK: {{%\w+}} = OpExtInst %void %1 DebugScope %68 ;CHECK: {{%\w+}} = OpExtInst %void %1 DebugDeclare %72 %param_var_i %52 ;CHECK: {{%\w+}} = OpExtInst %void %1 DebugScope %69 ;CHECK: {{%\w+}} = OpExtInst %void %1 DebugDeclare %71 %78 %52 OpLine %7 19 17 %88 = OpAccessChain %_ptr_Function_v2float %param_var_i %int_0 %89 = OpLoad %v2float %88 OpLine %7 19 12 OpStore %79 %89 ;CHECK-NOT: OpStore %79 %89 OpLine %7 19 12 %106 = OpExtInst %void %1 DebugValue %70 %89 %52 ;CHECK: {{%\w+}} = OpExtInst %void %1 DebugValue %70 %89 %52 OpLine %7 20 26 %91 = OpLoad %type_2d_image %g_tColor OpLine %7 20 46 %92 = OpLoad %type_sampler %g_sAniso OpLine %7 20 26 %94 = OpSampledImage %type_sampled_image %91 %92 %95 = OpImageSampleImplicitLod %v4float %94 %89 None OpLine %7 20 5 %96 = OpAccessChain %_ptr_Function_v4float %78 %int_0 OpStore %96 %95 OpLine %7 21 12 %97 = OpLoad %PS_OUTPUT %78 OpLine %7 21 5 OpStore %81 %97 %111 = OpExtInst %void %1 DebugNoScope ;CHECK: {{%\w+}} = OpExtInst %void %1 DebugNoScope %100 = OpCompositeExtract %v4float %97 0 OpStore %out_var_SV_Target0 %100 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_2); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(text, true); } TEST_F(AggressiveDCETest, ShaderDebugInfoKeepInFunctionElimStoreVar) { // Verify that dead local variable tc and store eliminated but all // in-function NonSemantic Shader debuginfo kept. const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %1 = OpExtInstImport "NonSemantic.Shader.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %MainPs "MainPs" %g_tColor %g_sAniso %in_var_TEXCOORD2 %out_var_SV_Target0 OpExecutionMode %MainPs OriginUpperLeft %7 = OpString "foo.frag" %8 = OpString "PS_OUTPUT" %9 = OpString "float" %10 = OpString "vColor" %11 = OpString "PS_INPUT" %12 = OpString "vTextureCoords" %13 = OpString "@type.2d.image" %14 = OpString "type.2d.image" %15 = OpString "Texture2D.TemplateParam" %16 = OpString "src.MainPs" %17 = OpString "tc" %18 = OpString "ps_output" %19 = OpString "i" %20 = OpString "@type.sampler" %21 = OpString "type.sampler" %22 = OpString "g_sAniso" %23 = OpString "g_tColor" OpName %type_2d_image "type.2d.image" OpName %g_tColor "g_tColor" OpName %type_sampler "type.sampler" OpName %g_sAniso "g_sAniso" OpName %in_var_TEXCOORD2 "in.var.TEXCOORD2" OpName %out_var_SV_Target0 "out.var.SV_Target0" OpName %MainPs "MainPs" OpName %PS_INPUT "PS_INPUT" OpMemberName %PS_INPUT 0 "vTextureCoords" OpName %param_var_i "param.var.i" OpName %PS_OUTPUT "PS_OUTPUT" OpMemberName %PS_OUTPUT 0 "vColor" OpName %type_sampled_image "type.sampled.image" OpDecorate %in_var_TEXCOORD2 Location 0 OpDecorate %out_var_SV_Target0 Location 0 OpDecorate %g_tColor DescriptorSet 0 OpDecorate %g_tColor Binding 0 OpDecorate %g_sAniso DescriptorSet 0 OpDecorate %g_sAniso Binding 1 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %float = OpTypeFloat 32 %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %type_sampler = OpTypeSampler %_ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %type_sampler %v2float = OpTypeVector %float 2 %_ptr_Input_v2float = OpTypePointer Input %v2float %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %uint_128 = OpConstant %uint 128 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %uint_3 = OpConstant %uint 3 %uint_4 = OpConstant %uint 4 %uint_5 = OpConstant %uint 5 %uint_7 = OpConstant %uint 7 %uint_8 = OpConstant %uint 8 %uint_10 = OpConstant %uint 10 %uint_11 = OpConstant %uint 11 %uint_12 = OpConstant %uint 12 %uint_14 = OpConstant %uint 14 %uint_15 = OpConstant %uint 15 %uint_16 = OpConstant %uint 16 %uint_17 = OpConstant %uint 17 %uint_19 = OpConstant %uint 19 %uint_20 = OpConstant %uint 20 %uint_21 = OpConstant %uint 21 %uint_25 = OpConstant %uint 25 %uint_29 = OpConstant %uint 29 %uint_30 = OpConstant %uint 30 %uint_35 = OpConstant %uint 35 %uint_41 = OpConstant %uint 41 %uint_48 = OpConstant %uint 48 %uint_53 = OpConstant %uint 53 %uint_64 = OpConstant %uint 64 %45 = OpTypeFunction %void %PS_INPUT = OpTypeStruct %v2float %_ptr_Function_PS_INPUT = OpTypePointer Function %PS_INPUT %PS_OUTPUT = OpTypeStruct %v4float %47 = OpTypeFunction %PS_OUTPUT %_ptr_Function_PS_INPUT %_ptr_Function_PS_OUTPUT = OpTypePointer Function %PS_OUTPUT %_ptr_Function_v2float = OpTypePointer Function %v2float %type_sampled_image = OpTypeSampledImage %type_2d_image %_ptr_Function_v4float = OpTypePointer Function %v4float %g_tColor = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %g_sAniso = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %in_var_TEXCOORD2 = OpVariable %_ptr_Input_v2float Input %out_var_SV_Target0 = OpVariable %_ptr_Output_v4float Output %51 = OpExtInst %void %1 DebugInfoNone %52 = OpExtInst %void %1 DebugExpression %53 = OpExtInst %void %1 DebugOperation %uint_0 %54 = OpExtInst %void %1 DebugExpression %53 %55 = OpExtInst %void %1 DebugSource %7 %56 = OpExtInst %void %1 DebugCompilationUnit %uint_1 %uint_4 %55 %uint_5 %59 = OpExtInst %void %1 DebugTypeBasic %9 %uint_32 %uint_3 %uint_0 %60 = OpExtInst %void %1 DebugTypeVector %59 %uint_4 %58 = OpExtInst %void %1 DebugTypeMember %10 %60 %55 %uint_12 %uint_5 %uint_0 %uint_128 %uint_3 %57 = OpExtInst %void %1 DebugTypeComposite %8 %uint_1 %55 %uint_10 %uint_1 %56 %8 %uint_128 %uint_3 %58 %63 = OpExtInst %void %1 DebugTypeVector %59 %uint_2 %62 = OpExtInst %void %1 DebugTypeMember %12 %63 %55 %uint_7 %uint_5 %uint_0 %uint_64 %uint_3 %61 = OpExtInst %void %1 DebugTypeComposite %11 %uint_1 %55 %uint_5 %uint_1 %56 %11 %uint_64 %uint_3 %62 %64 = OpExtInst %void %1 DebugTypeComposite %13 %uint_0 %55 %uint_0 %uint_0 %56 %14 %51 %uint_3 %67 = OpExtInst %void %1 DebugTypeFunction %uint_3 %57 %61 %68 = OpExtInst %void %1 DebugFunction %16 %67 %55 %uint_15 %uint_1 %56 %16 %uint_3 %uint_16 %69 = OpExtInst %void %1 DebugLexicalBlock %55 %uint_16 %uint_1 %68 %70 = OpExtInst %void %1 DebugLocalVariable %17 %63 %55 %uint_19 %uint_12 %69 %uint_4 %71 = OpExtInst %void %1 DebugLocalVariable %18 %57 %55 %uint_17 %uint_15 %69 %uint_4 %72 = OpExtInst %void %1 DebugLocalVariable %19 %61 %55 %uint_15 %uint_29 %68 %uint_4 %uint_1 %73 = OpExtInst %void %1 DebugTypeComposite %20 %uint_1 %55 %uint_0 %uint_0 %56 %21 %51 %uint_3 %74 = OpExtInst %void %1 DebugGlobalVariable %22 %73 %55 %uint_3 %uint_14 %56 %22 %g_sAniso %uint_8 %75 = OpExtInst %void %1 DebugGlobalVariable %23 %64 %55 %uint_1 %uint_11 %56 %23 %g_tColor %uint_8 %MainPs = OpFunction %void None %45 %76 = OpLabel %78 = OpVariable %_ptr_Function_PS_OUTPUT Function %79 = OpVariable %_ptr_Function_v2float Function %81 = OpVariable %_ptr_Function_PS_OUTPUT Function %param_var_i = OpVariable %_ptr_Function_PS_INPUT Function %82 = OpLoad %v2float %in_var_TEXCOORD2 %83 = OpCompositeConstruct %PS_INPUT %82 OpStore %param_var_i %83 %112 = OpExtInst %void %1 DebugFunctionDefinition %68 %MainPs %109 = OpExtInst %void %1 DebugScope %68 %85 = OpExtInst %void %1 DebugDeclare %72 %param_var_i %52 %110 = OpExtInst %void %1 DebugScope %69 %87 = OpExtInst %void %1 DebugDeclare %71 %78 %52 ;CHECK: {{%\w+}} = OpExtInst %void %1 DebugFunctionDefinition %68 %MainPs ;CHECK: {{%\w+}} = OpExtInst %void %1 DebugScope %68 ;CHECK: {{%\w+}} = OpExtInst %void %1 DebugDeclare %72 %param_var_i %52 ;CHECK: {{%\w+}} = OpExtInst %void %1 DebugScope %69 ;CHECK: {{%\w+}} = OpExtInst %void %1 DebugDeclare %71 %78 %52 %300 = OpExtInst %void %1 DebugLine %55 %uint_19 %uint_19 %uint_17 %uint_30 ;CHECK: {{%\w+}} = OpExtInst %void %1 DebugLine %55 %uint_19 %uint_19 %uint_17 %uint_30 %88 = OpAccessChain %_ptr_Function_v2float %param_var_i %int_0 %89 = OpLoad %v2float %88 %301 = OpExtInst %void %1 DebugLine %55 %uint_19 %uint_19 %uint_12 %uint_35 OpStore %79 %89 ;CHECK-NOT: OpStore %79 %89 %302 = OpExtInst %void %1 DebugLine %55 %uint_19 %uint_19 %uint_12 %uint_35 ;CHECK: {{%\w+}} = OpExtInst %void %1 DebugLine %55 %uint_19 %uint_19 %uint_12 %uint_35 %106 = OpExtInst %void %1 DebugValue %70 %89 %52 ;CHECK: {{%\w+}} = OpExtInst %void %1 DebugValue %70 %89 %52 %303 = OpExtInst %void %1 DebugLine %55 %uint_20 %uint_20 %uint_25 %uint_32 %91 = OpLoad %type_2d_image %g_tColor %304 = OpExtInst %void %1 DebugLine %55 %uint_20 %uint_20 %uint_41 %uint_48 %92 = OpLoad %type_sampler %g_sAniso %305 = OpExtInst %void %1 DebugLine %55 %uint_20 %uint_20 %uint_25 %uint_53 %94 = OpSampledImage %type_sampled_image %91 %92 %95 = OpImageSampleImplicitLod %v4float %94 %89 None %306 = OpExtInst %void %1 DebugLine %55 %uint_20 %uint_20 %uint_5 %uint_53 %96 = OpAccessChain %_ptr_Function_v4float %78 %int_0 OpStore %96 %95 %307 = OpExtInst %void %1 DebugLine %55 %uint_21 %uint_21 %uint_12 %uint_20 %97 = OpLoad %PS_OUTPUT %78 %308 = OpExtInst %void %1 DebugLine %55 %uint_21 %uint_21 %uint_5 %uint_20 OpStore %81 %97 %309 = OpExtInst %void %1 DebugNoLine ;CHECK: {{%\w+}} = OpExtInst %void %1 DebugNoLine %111 = OpExtInst %void %1 DebugNoScope ;CHECK: {{%\w+}} = OpExtInst %void %1 DebugNoScope %100 = OpCompositeExtract %v4float %97 0 OpStore %out_var_SV_Target0 %100 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_2); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(text, true); } TEST_F(AggressiveDCETest, ShaderDebugInfoGlobalDCE) { // Verify that DebugGlobalVariable for eliminated private variable has // variable operand replaced with DebugInfoNone. const std::string text = R"(OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %1 = OpExtInstImport "NonSemantic.Shader.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %MainPs "MainPs" %out_var_SV_Target0 %a OpExecutionMode %MainPs OriginUpperLeft %5 = OpString "source2.hlsl" %24 = OpString "float" %29 = OpString "vColor" %33 = OpString "PS_OUTPUT" %37 = OpString "MainPs" %38 = OpString "" %42 = OpString "ps_output" %46 = OpString "a" OpName %a "a" OpName %out_var_SV_Target0 "out.var.SV_Target0" OpName %MainPs "MainPs" OpName %PS_OUTPUT "PS_OUTPUT" OpMemberName %PS_OUTPUT 0 "vColor" OpDecorate %out_var_SV_Target0 Location 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %8 = OpConstantNull %v4float %float_0 = OpConstant %float 0 %10 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %_ptr_Private_v4float = OpTypePointer Private %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %uint_1 = OpConstant %uint 1 %uint_4 = OpConstant %uint 4 %uint_5 = OpConstant %uint 5 %uint_3 = OpConstant %uint 3 %uint_0 = OpConstant %uint 0 %uint_128 = OpConstant %uint 128 %uint_12 = OpConstant %uint 12 %uint_8 = OpConstant %uint 8 %uint_9 = OpConstant %uint 9 %uint_10 = OpConstant %uint 10 %uint_15 = OpConstant %uint 15 %48 = OpTypeFunction %void %PS_OUTPUT = OpTypeStruct %v4float %54 = OpTypeFunction %PS_OUTPUT %_ptr_Function_PS_OUTPUT = OpTypePointer Function %PS_OUTPUT %_ptr_Function_v4float = OpTypePointer Function %v4float %a = OpVariable %_ptr_Private_v4float Private ;CHECK-NOT: %a = OpVariable %_ptr_Private_v4float Private %out_var_SV_Target0 = OpVariable %_ptr_Output_v4float Output ;CHECK: [[dbg_none:%\w+]] = OpExtInst %void %1 DebugInfoNone %18 = OpExtInst %void %1 DebugExpression %19 = OpExtInst %void %1 DebugSource %5 %20 = OpExtInst %void %1 DebugCompilationUnit %uint_1 %uint_4 %19 %uint_5 %25 = OpExtInst %void %1 DebugTypeBasic %24 %uint_32 %uint_3 %uint_0 %28 = OpExtInst %void %1 DebugTypeVector %25 %uint_4 %31 = OpExtInst %void %1 DebugTypeMember %29 %28 %19 %uint_5 %uint_12 %uint_0 %uint_128 %uint_3 %34 = OpExtInst %void %1 DebugTypeComposite %33 %uint_1 %19 %uint_3 %uint_8 %20 %33 %uint_128 %uint_3 %31 %36 = OpExtInst %void %1 DebugTypeFunction %uint_3 %34 %39 = OpExtInst %void %1 DebugFunction %37 %36 %19 %uint_8 %uint_1 %20 %38 %uint_3 %uint_9 %41 = OpExtInst %void %1 DebugLexicalBlock %19 %uint_9 %uint_1 %39 %43 = OpExtInst %void %1 DebugLocalVariable %42 %34 %19 %uint_10 %uint_15 %41 %uint_4 %47 = OpExtInst %void %1 DebugGlobalVariable %46 %28 %19 %uint_1 %uint_15 %20 %46 %a %uint_8 ;CHECK: %47 = OpExtInst %void %1 DebugGlobalVariable %46 %28 %19 %uint_1 %uint_15 %20 %46 [[dbg_none]] %uint_8 %MainPs = OpFunction %void None %48 %49 = OpLabel %65 = OpVariable %_ptr_Function_PS_OUTPUT Function %66 = OpVariable %_ptr_Function_PS_OUTPUT Function OpStore %a %8 %72 = OpExtInst %void %1 DebugScope %41 %69 = OpExtInst %void %1 DebugDeclare %43 %65 %18 OpLine %5 11 5 %70 = OpAccessChain %_ptr_Function_v4float %65 %int_0 OpStore %70 %10 OpLine %5 12 12 %71 = OpLoad %PS_OUTPUT %65 OpLine %5 12 5 OpStore %66 %71 %73 = OpExtInst %void %1 DebugNoLine %74 = OpExtInst %void %1 DebugNoScope %51 = OpLoad %PS_OUTPUT %66 %53 = OpCompositeExtract %v4float %51 0 OpStore %out_var_SV_Target0 %53 OpLine %5 13 1 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_2); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(text, true); } TEST_F(AggressiveDCETest, DebugInfoDeclareKeepsStore) { // Verify that local variable tc and its store are kept by DebugDeclare. // // Same shader source as DebugInfoInFunctionKeepStoreVarElim. The SPIR-V // has just been inlined. const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %MainPs "MainPs" %g_tColor %g_sAniso %in_var_TEXCOORD2 %out_var_SV_Target0 OpExecutionMode %MainPs OriginUpperLeft %20 = OpString "foo.frag" %24 = OpString "PS_OUTPUT" %28 = OpString "float" %31 = OpString "vColor" %33 = OpString "PS_INPUT" %38 = OpString "vTextureCoords" %40 = OpString "@type.2d.image" %41 = OpString "type.2d.image" %43 = OpString "Texture2D.TemplateParam" %47 = OpString "src.MainPs" %51 = OpString "tc" %53 = OpString "ps_output" %56 = OpString "i" %58 = OpString "@type.sampler" %59 = OpString "type.sampler" %61 = OpString "g_sAniso" %63 = OpString "g_tColor" OpName %type_2d_image "type.2d.image" OpName %g_tColor "g_tColor" OpName %type_sampler "type.sampler" OpName %g_sAniso "g_sAniso" OpName %in_var_TEXCOORD2 "in.var.TEXCOORD2" OpName %out_var_SV_Target0 "out.var.SV_Target0" OpName %MainPs "MainPs" OpName %PS_INPUT "PS_INPUT" OpMemberName %PS_INPUT 0 "vTextureCoords" OpName %param_var_i "param.var.i" OpName %PS_OUTPUT "PS_OUTPUT" OpMemberName %PS_OUTPUT 0 "vColor" OpName %type_sampled_image "type.sampled.image" OpDecorate %in_var_TEXCOORD2 Location 0 OpDecorate %out_var_SV_Target0 Location 0 OpDecorate %g_tColor DescriptorSet 0 OpDecorate %g_tColor Binding 0 OpDecorate %g_sAniso DescriptorSet 0 OpDecorate %g_sAniso Binding 1 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %float = OpTypeFloat 32 %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %type_sampler = OpTypeSampler %_ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %type_sampler %v2float = OpTypeVector %float 2 %_ptr_Input_v2float = OpTypePointer Input %v2float %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %uint_128 = OpConstant %uint 128 %uint_0 = OpConstant %uint 0 %uint_64 = OpConstant %uint 64 %65 = OpTypeFunction %void %PS_INPUT = OpTypeStruct %v2float %_ptr_Function_PS_INPUT = OpTypePointer Function %PS_INPUT %PS_OUTPUT = OpTypeStruct %v4float %75 = OpTypeFunction %PS_OUTPUT %_ptr_Function_PS_INPUT %_ptr_Function_PS_OUTPUT = OpTypePointer Function %PS_OUTPUT %_ptr_Function_v2float = OpTypePointer Function %v2float %type_sampled_image = OpTypeSampledImage %type_2d_image %_ptr_Function_v4float = OpTypePointer Function %v4float %g_tColor = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %g_sAniso = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %in_var_TEXCOORD2 = OpVariable %_ptr_Input_v2float Input %out_var_SV_Target0 = OpVariable %_ptr_Output_v4float Output %39 = OpExtInst %void %1 DebugInfoNone %55 = OpExtInst %void %1 DebugExpression %22 = OpExtInst %void %1 DebugSource %20 %23 = OpExtInst %void %1 DebugCompilationUnit 1 4 %22 HLSL %26 = OpExtInst %void %1 DebugTypeComposite %24 Structure %22 10 1 %23 %24 %uint_128 FlagIsProtected|FlagIsPrivate %27 %29 = OpExtInst %void %1 DebugTypeBasic %28 %uint_32 Float %30 = OpExtInst %void %1 DebugTypeVector %29 4 %27 = OpExtInst %void %1 DebugTypeMember %31 %30 %22 12 5 %26 %uint_0 %uint_128 FlagIsProtected|FlagIsPrivate %35 = OpExtInst %void %1 DebugTypeComposite %33 Structure %22 5 1 %23 %33 %uint_64 FlagIsProtected|FlagIsPrivate %36 %37 = OpExtInst %void %1 DebugTypeVector %29 2 %36 = OpExtInst %void %1 DebugTypeMember %38 %37 %22 7 5 %35 %uint_0 %uint_64 FlagIsProtected|FlagIsPrivate %42 = OpExtInst %void %1 DebugTypeComposite %40 Class %22 0 0 %23 %41 %39 FlagIsProtected|FlagIsPrivate %44 = OpExtInst %void %1 DebugTypeTemplateParameter %43 %29 %39 %22 0 0 %45 = OpExtInst %void %1 DebugTypeTemplate %42 %44 %46 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %26 %35 %48 = OpExtInst %void %1 DebugFunction %47 %46 %22 15 1 %23 %47 FlagIsProtected|FlagIsPrivate 16 %39 %50 = OpExtInst %void %1 DebugLexicalBlock %22 16 1 %48 %52 = OpExtInst %void %1 DebugLocalVariable %51 %37 %22 19 12 %50 FlagIsLocal %54 = OpExtInst %void %1 DebugLocalVariable %53 %26 %22 17 15 %50 FlagIsLocal %57 = OpExtInst %void %1 DebugLocalVariable %56 %35 %22 15 29 %48 FlagIsLocal 1 %60 = OpExtInst %void %1 DebugTypeComposite %58 Structure %22 0 0 %23 %59 %39 FlagIsProtected|FlagIsPrivate %62 = OpExtInst %void %1 DebugGlobalVariable %61 %60 %22 3 14 %23 %61 %g_sAniso FlagIsDefinition %64 = OpExtInst %void %1 DebugGlobalVariable %63 %42 %22 1 11 %23 %63 %g_tColor FlagIsDefinition %MainPs = OpFunction %void None %65 %66 = OpLabel %114 = OpExtInst %void %1 DebugScope %50 %98 = OpVariable %_ptr_Function_PS_OUTPUT Function %99 = OpVariable %_ptr_Function_v2float Function %115 = OpExtInst %void %1 DebugNoScope %100 = OpVariable %_ptr_Function_PS_OUTPUT Function %param_var_i = OpVariable %_ptr_Function_PS_INPUT Function %70 = OpLoad %v2float %in_var_TEXCOORD2 %71 = OpCompositeConstruct %PS_INPUT %70 OpStore %param_var_i %71 %116 = OpExtInst %void %1 DebugScope %48 %102 = OpExtInst %void %1 DebugDeclare %57 %param_var_i %55 %117 = OpExtInst %void %1 DebugScope %50 %103 = OpExtInst %void %1 DebugDeclare %54 %98 %55 OpLine %20 19 17 %104 = OpAccessChain %_ptr_Function_v2float %param_var_i %int_0 %105 = OpLoad %v2float %104 OpLine %20 19 12 OpStore %99 %105 ;CHECK: OpStore %99 %105 %106 = OpExtInst %void %1 DebugDeclare %52 %99 %55 OpLine %20 20 26 %107 = OpLoad %type_2d_image %g_tColor OpLine %20 20 46 %108 = OpLoad %type_sampler %g_sAniso OpLine %20 20 26 %110 = OpSampledImage %type_sampled_image %107 %108 %111 = OpImageSampleImplicitLod %v4float %110 %105 None OpLine %20 20 5 %112 = OpAccessChain %_ptr_Function_v4float %98 %int_0 OpStore %112 %111 OpLine %20 21 12 %113 = OpLoad %PS_OUTPUT %98 OpLine %20 21 5 OpStore %100 %113 %118 = OpExtInst %void %1 DebugNoScope %73 = OpLoad %PS_OUTPUT %100 %74 = OpCompositeExtract %v4float %73 0 OpStore %out_var_SV_Target0 %74 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_2); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(text, true); } TEST_F(AggressiveDCETest, DebugInfoValueDerefKeepsStore) { // Verify that local variable tc and its store are kept by DebugValue with // Deref. // // Same shader source as DebugInfoInFunctionKeepStoreVarElim. The SPIR-V // has just been inlined and edited to replace the DebugDeclare with the // DebugValue/Deref. const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %MainPs "MainPs" %g_tColor %g_sAniso %in_var_TEXCOORD2 %out_var_SV_Target0 OpExecutionMode %MainPs OriginUpperLeft %7 = OpString "foo.frag" %8 = OpString "PS_OUTPUT" %9 = OpString "float" %10 = OpString "vColor" %11 = OpString "PS_INPUT" %12 = OpString "vTextureCoords" %13 = OpString "@type.2d.image" %14 = OpString "type.2d.image" %15 = OpString "Texture2D.TemplateParam" %16 = OpString "src.MainPs" %17 = OpString "tc" %18 = OpString "ps_output" %19 = OpString "i" %20 = OpString "@type.sampler" %21 = OpString "type.sampler" %22 = OpString "g_sAniso" %23 = OpString "g_tColor" OpName %type_2d_image "type.2d.image" OpName %g_tColor "g_tColor" OpName %type_sampler "type.sampler" OpName %g_sAniso "g_sAniso" OpName %in_var_TEXCOORD2 "in.var.TEXCOORD2" OpName %out_var_SV_Target0 "out.var.SV_Target0" OpName %MainPs "MainPs" OpName %PS_INPUT "PS_INPUT" OpMemberName %PS_INPUT 0 "vTextureCoords" OpName %param_var_i "param.var.i" OpName %PS_OUTPUT "PS_OUTPUT" OpMemberName %PS_OUTPUT 0 "vColor" OpName %type_sampled_image "type.sampled.image" OpDecorate %in_var_TEXCOORD2 Location 0 OpDecorate %out_var_SV_Target0 Location 0 OpDecorate %g_tColor DescriptorSet 0 OpDecorate %g_tColor Binding 0 OpDecorate %g_sAniso DescriptorSet 0 OpDecorate %g_sAniso Binding 1 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %float = OpTypeFloat 32 %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %type_sampler = OpTypeSampler %_ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %type_sampler %v2float = OpTypeVector %float 2 %_ptr_Input_v2float = OpTypePointer Input %v2float %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %uint_128 = OpConstant %uint 128 %uint_0 = OpConstant %uint 0 %uint_64 = OpConstant %uint 64 %45 = OpTypeFunction %void %PS_INPUT = OpTypeStruct %v2float %_ptr_Function_PS_INPUT = OpTypePointer Function %PS_INPUT %PS_OUTPUT = OpTypeStruct %v4float %47 = OpTypeFunction %PS_OUTPUT %_ptr_Function_PS_INPUT %_ptr_Function_PS_OUTPUT = OpTypePointer Function %PS_OUTPUT %_ptr_Function_v2float = OpTypePointer Function %v2float %type_sampled_image = OpTypeSampledImage %type_2d_image %_ptr_Function_v4float = OpTypePointer Function %v4float %g_tColor = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %g_sAniso = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %in_var_TEXCOORD2 = OpVariable %_ptr_Input_v2float Input %out_var_SV_Target0 = OpVariable %_ptr_Output_v4float Output %51 = OpExtInst %void %1 DebugInfoNone %52 = OpExtInst %void %1 DebugExpression %53 = OpExtInst %void %1 DebugOperation Deref %54 = OpExtInst %void %1 DebugExpression %53 %55 = OpExtInst %void %1 DebugSource %7 %56 = OpExtInst %void %1 DebugCompilationUnit 1 4 %55 HLSL %57 = OpExtInst %void %1 DebugTypeComposite %8 Structure %55 10 1 %56 %8 %uint_128 FlagIsProtected|FlagIsPrivate %58 %59 = OpExtInst %void %1 DebugTypeBasic %9 %uint_32 Float %60 = OpExtInst %void %1 DebugTypeVector %59 4 %58 = OpExtInst %void %1 DebugTypeMember %10 %60 %55 12 5 %57 %uint_0 %uint_128 FlagIsProtected|FlagIsPrivate %61 = OpExtInst %void %1 DebugTypeComposite %11 Structure %55 5 1 %56 %11 %uint_64 FlagIsProtected|FlagIsPrivate %62 %63 = OpExtInst %void %1 DebugTypeVector %59 2 %62 = OpExtInst %void %1 DebugTypeMember %12 %63 %55 7 5 %61 %uint_0 %uint_64 FlagIsProtected|FlagIsPrivate %64 = OpExtInst %void %1 DebugTypeComposite %13 Class %55 0 0 %56 %14 %51 FlagIsProtected|FlagIsPrivate %65 = OpExtInst %void %1 DebugTypeTemplateParameter %15 %59 %51 %55 0 0 %66 = OpExtInst %void %1 DebugTypeTemplate %64 %65 %67 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %57 %61 %68 = OpExtInst %void %1 DebugFunction %16 %67 %55 15 1 %56 %16 FlagIsProtected|FlagIsPrivate 16 %51 %69 = OpExtInst %void %1 DebugLexicalBlock %55 16 1 %68 %70 = OpExtInst %void %1 DebugLocalVariable %17 %63 %55 19 12 %69 FlagIsLocal %71 = OpExtInst %void %1 DebugLocalVariable %18 %57 %55 17 15 %69 FlagIsLocal %72 = OpExtInst %void %1 DebugLocalVariable %19 %61 %55 15 29 %68 FlagIsLocal 1 %73 = OpExtInst %void %1 DebugTypeComposite %20 Structure %55 0 0 %56 %21 %51 FlagIsProtected|FlagIsPrivate %74 = OpExtInst %void %1 DebugGlobalVariable %22 %73 %55 3 14 %56 %22 %g_sAniso FlagIsDefinition %75 = OpExtInst %void %1 DebugGlobalVariable %23 %64 %55 1 11 %56 %23 %g_tColor FlagIsDefinition %MainPs = OpFunction %void None %45 %76 = OpLabel %101 = OpExtInst %void %1 DebugScope %69 %78 = OpVariable %_ptr_Function_PS_OUTPUT Function %79 = OpVariable %_ptr_Function_v2float Function %102 = OpExtInst %void %1 DebugNoScope %81 = OpVariable %_ptr_Function_PS_OUTPUT Function %param_var_i = OpVariable %_ptr_Function_PS_INPUT Function %82 = OpLoad %v2float %in_var_TEXCOORD2 %83 = OpCompositeConstruct %PS_INPUT %82 OpStore %param_var_i %83 %103 = OpExtInst %void %1 DebugScope %68 %85 = OpExtInst %void %1 DebugDeclare %72 %param_var_i %52 %104 = OpExtInst %void %1 DebugScope %69 %87 = OpExtInst %void %1 DebugDeclare %71 %78 %52 OpLine %7 19 17 %88 = OpAccessChain %_ptr_Function_v2float %param_var_i %int_0 %89 = OpLoad %v2float %88 OpLine %7 19 12 OpStore %79 %89 ;CHECK: OpStore %79 %89 %90 = OpExtInst %void %1 DebugValue %70 %79 %54 OpLine %7 20 26 %91 = OpLoad %type_2d_image %g_tColor OpLine %7 20 46 %92 = OpLoad %type_sampler %g_sAniso OpLine %7 20 26 %94 = OpSampledImage %type_sampled_image %91 %92 %95 = OpImageSampleImplicitLod %v4float %94 %89 None OpLine %7 20 5 %96 = OpAccessChain %_ptr_Function_v4float %78 %int_0 OpStore %96 %95 OpLine %7 21 12 %97 = OpLoad %PS_OUTPUT %78 OpLine %7 21 5 OpStore %81 %97 %105 = OpExtInst %void %1 DebugNoScope %99 = OpLoad %PS_OUTPUT %81 %100 = OpCompositeExtract %v4float %99 0 OpStore %out_var_SV_Target0 %100 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_2); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(text, true); } TEST_F(AggressiveDCETest, DebugInfoElimUnusedTextureKeepGlobalVariable) { // Verify that unused texture g_tColor2 is eliminated but its // DebugGlobalVariable is retained but with DebugInfoNone for its Variable. // // Same shader source as DebugInfoInFunctionKeepStoreVarElim but with unused // g_tColor2 added. const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %MainPs "MainPs" %g_tColor %g_tColor2 %g_sAniso %in_var_TEXCOORD2 %out_var_SV_Target0 OpExecutionMode %MainPs OriginUpperLeft %21 = OpString "foo6.frag" %25 = OpString "PS_OUTPUT" %29 = OpString "float" %32 = OpString "vColor" %34 = OpString "PS_INPUT" %39 = OpString "vTextureCoords" %41 = OpString "@type.2d.image" %42 = OpString "type.2d.image" %44 = OpString "Texture2D.TemplateParam" %48 = OpString "src.MainPs" %52 = OpString "tc" %54 = OpString "ps_output" %57 = OpString "i" %59 = OpString "@type.sampler" %60 = OpString "type.sampler" %62 = OpString "g_sAniso" %64 = OpString "g_tColor2" %66 = OpString "g_tColor" OpName %type_2d_image "type.2d.image" OpName %g_tColor "g_tColor" OpName %g_tColor2 "g_tColor2" OpName %type_sampler "type.sampler" OpName %g_sAniso "g_sAniso" OpName %in_var_TEXCOORD2 "in.var.TEXCOORD2" OpName %out_var_SV_Target0 "out.var.SV_Target0" OpName %MainPs "MainPs" OpName %PS_INPUT "PS_INPUT" OpMemberName %PS_INPUT 0 "vTextureCoords" OpName %param_var_i "param.var.i" OpName %PS_OUTPUT "PS_OUTPUT" OpMemberName %PS_OUTPUT 0 "vColor" OpName %type_sampled_image "type.sampled.image" OpDecorate %in_var_TEXCOORD2 Location 0 OpDecorate %out_var_SV_Target0 Location 0 OpDecorate %g_tColor DescriptorSet 0 OpDecorate %g_tColor Binding 0 OpDecorate %g_tColor2 DescriptorSet 0 OpDecorate %g_tColor2 Binding 1 OpDecorate %g_sAniso DescriptorSet 0 OpDecorate %g_sAniso Binding 2 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %float = OpTypeFloat 32 %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %type_sampler = OpTypeSampler %_ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %type_sampler %v2float = OpTypeVector %float 2 %_ptr_Input_v2float = OpTypePointer Input %v2float %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %uint_128 = OpConstant %uint 128 %uint_0 = OpConstant %uint 0 %uint_64 = OpConstant %uint 64 %68 = OpTypeFunction %void %PS_INPUT = OpTypeStruct %v2float %_ptr_Function_PS_INPUT = OpTypePointer Function %PS_INPUT %PS_OUTPUT = OpTypeStruct %v4float %78 = OpTypeFunction %PS_OUTPUT %_ptr_Function_PS_INPUT %_ptr_Function_PS_OUTPUT = OpTypePointer Function %PS_OUTPUT %_ptr_Function_v2float = OpTypePointer Function %v2float %type_sampled_image = OpTypeSampledImage %type_2d_image %_ptr_Function_v4float = OpTypePointer Function %v4float %g_tColor = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %g_tColor2 = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant ;CHECK-NOT: %g_tColor2 = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %g_sAniso = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %in_var_TEXCOORD2 = OpVariable %_ptr_Input_v2float Input %out_var_SV_Target0 = OpVariable %_ptr_Output_v4float Output %40 = OpExtInst %void %1 DebugInfoNone %56 = OpExtInst %void %1 DebugExpression %23 = OpExtInst %void %1 DebugSource %21 %24 = OpExtInst %void %1 DebugCompilationUnit 1 4 %23 HLSL %27 = OpExtInst %void %1 DebugTypeComposite %25 Structure %23 11 1 %24 %25 %uint_128 FlagIsProtected|FlagIsPrivate %28 %30 = OpExtInst %void %1 DebugTypeBasic %29 %uint_32 Float %31 = OpExtInst %void %1 DebugTypeVector %30 4 %28 = OpExtInst %void %1 DebugTypeMember %32 %31 %23 13 5 %27 %uint_0 %uint_128 FlagIsProtected|FlagIsPrivate %36 = OpExtInst %void %1 DebugTypeComposite %34 Structure %23 6 1 %24 %34 %uint_64 FlagIsProtected|FlagIsPrivate %37 %38 = OpExtInst %void %1 DebugTypeVector %30 2 %37 = OpExtInst %void %1 DebugTypeMember %39 %38 %23 8 5 %36 %uint_0 %uint_64 FlagIsProtected|FlagIsPrivate %43 = OpExtInst %void %1 DebugTypeComposite %41 Class %23 0 0 %24 %42 %40 FlagIsProtected|FlagIsPrivate %45 = OpExtInst %void %1 DebugTypeTemplateParameter %44 %30 %40 %23 0 0 %46 = OpExtInst %void %1 DebugTypeTemplate %43 %45 %47 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %27 %36 %49 = OpExtInst %void %1 DebugFunction %48 %47 %23 16 1 %24 %48 FlagIsProtected|FlagIsPrivate 17 %40 %51 = OpExtInst %void %1 DebugLexicalBlock %23 17 1 %49 %53 = OpExtInst %void %1 DebugLocalVariable %52 %38 %23 20 12 %51 FlagIsLocal %55 = OpExtInst %void %1 DebugLocalVariable %54 %27 %23 18 15 %51 FlagIsLocal %58 = OpExtInst %void %1 DebugLocalVariable %57 %36 %23 16 29 %49 FlagIsLocal 1 %61 = OpExtInst %void %1 DebugTypeComposite %59 Structure %23 0 0 %24 %60 %40 FlagIsProtected|FlagIsPrivate %63 = OpExtInst %void %1 DebugGlobalVariable %62 %61 %23 4 14 %24 %62 %g_sAniso FlagIsDefinition %65 = OpExtInst %void %1 DebugGlobalVariable %64 %43 %23 2 11 %24 %64 %g_tColor2 FlagIsDefinition ;CHECK-NOT: %65 = OpExtInst %void %1 DebugGlobalVariable %64 %43 %23 2 11 %24 %64 %g_tColor2 FlagIsDefinition ;CHECK: %65 = OpExtInst %void %1 DebugGlobalVariable %64 %43 %23 2 11 %24 %64 %40 FlagIsDefinition %67 = OpExtInst %void %1 DebugGlobalVariable %66 %43 %23 1 11 %24 %66 %g_tColor FlagIsDefinition %MainPs = OpFunction %void None %68 %69 = OpLabel %117 = OpExtInst %void %1 DebugScope %51 %101 = OpVariable %_ptr_Function_PS_OUTPUT Function %102 = OpVariable %_ptr_Function_v2float Function %118 = OpExtInst %void %1 DebugNoScope %103 = OpVariable %_ptr_Function_PS_OUTPUT Function %param_var_i = OpVariable %_ptr_Function_PS_INPUT Function %73 = OpLoad %v2float %in_var_TEXCOORD2 %74 = OpCompositeConstruct %PS_INPUT %73 OpStore %param_var_i %74 %119 = OpExtInst %void %1 DebugScope %49 %105 = OpExtInst %void %1 DebugDeclare %58 %param_var_i %56 %120 = OpExtInst %void %1 DebugScope %51 %106 = OpExtInst %void %1 DebugDeclare %55 %101 %56 OpLine %21 20 17 %107 = OpAccessChain %_ptr_Function_v2float %param_var_i %int_0 %108 = OpLoad %v2float %107 OpLine %21 20 12 OpStore %102 %108 %109 = OpExtInst %void %1 DebugDeclare %53 %102 %56 OpLine %21 21 26 %110 = OpLoad %type_2d_image %g_tColor OpLine %21 21 46 %111 = OpLoad %type_sampler %g_sAniso OpLine %21 21 57 %112 = OpLoad %v2float %102 OpLine %21 21 26 %113 = OpSampledImage %type_sampled_image %110 %111 %114 = OpImageSampleImplicitLod %v4float %113 %112 None OpLine %21 21 5 %115 = OpAccessChain %_ptr_Function_v4float %101 %int_0 OpStore %115 %114 OpLine %21 22 12 %116 = OpLoad %PS_OUTPUT %101 OpLine %21 22 5 OpStore %103 %116 %121 = OpExtInst %void %1 DebugNoScope %76 = OpLoad %PS_OUTPUT %103 %77 = OpCompositeExtract %v4float %76 0 OpStore %out_var_SV_Target0 %77 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_2); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(text, true); } TEST_F(AggressiveDCETest, KeepDebugScopeParent) { // Verify that local variable tc and its store are kept by DebugDeclare. // // Same shader source as DebugInfoInFunctionKeepStoreVarElim. The SPIR-V // has just been inlined. const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %out_var_SV_TARGET0 OpExecutionMode %main OriginUpperLeft %11 = OpString "float" %16 = OpString "t.hlsl" %19 = OpString "src.main" OpName %out_var_SV_TARGET0 "out.var.SV_TARGET0" OpName %main "main" OpDecorate %out_var_SV_TARGET0 Location 0 %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %v4float = OpTypeVector %float 4 %7 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %23 = OpTypeFunction %void %26 = OpTypeFunction %v4float %out_var_SV_TARGET0 = OpVariable %_ptr_Output_v4float Output %_ptr_Function_v4float = OpTypePointer Function %v4float %33 = OpExtInst %void %1 DebugInfoNone %13 = OpExtInst %void %1 DebugTypeBasic %11 %uint_32 Float %14 = OpExtInst %void %1 DebugTypeVector %13 4 %15 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %14 %17 = OpExtInst %void %1 DebugSource %16 %18 = OpExtInst %void %1 DebugCompilationUnit 1 4 %17 HLSL %20 = OpExtInst %void %1 DebugFunction %19 %15 %17 1 1 %18 %19 FlagIsProtected|FlagIsPrivate 2 %33 %22 = OpExtInst %void %1 DebugLexicalBlock %17 2 1 %20 %main = OpFunction %void None %23 %24 = OpLabel %31 = OpVariable %_ptr_Function_v4float Function ; CHECK: [[block:%\w+]] = OpExtInst %void %1 DebugLexicalBlock ; CHECK: DebugScope [[block]] %34 = OpExtInst %void %1 DebugScope %22 OpLine %16 3 5 OpStore %31 %7 OpStore %out_var_SV_TARGET0 %7 %35 = OpExtInst %void %1 DebugNoScope OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(text, true); } TEST_F(AggressiveDCETest, KeepExportFunctions) { // All functions are reachable. In particular, ExportedFunc and Constant are // reachable because ExportedFunc is exported. Nothing should be removed. const std::vector text = { // clang-format off "OpCapability Shader", "OpCapability Linkage", "OpMemoryModel Logical GLSL450", "OpEntryPoint Fragment %main \"main\"", "OpName %main \"main\"", "OpName %ExportedFunc \"ExportedFunc\"", "OpName %Live \"Live\"", "OpDecorate %ExportedFunc LinkageAttributes \"ExportedFunc\" Export", "%void = OpTypeVoid", "%7 = OpTypeFunction %void", "%main = OpFunction %void None %7", "%15 = OpLabel", "OpReturn", "OpFunctionEnd", "%ExportedFunc = OpFunction %void None %7", "%19 = OpLabel", "%16 = OpFunctionCall %void %Live", "OpReturn", "OpFunctionEnd", "%Live = OpFunction %void None %7", "%20 = OpLabel", "OpReturn", "OpFunctionEnd" // clang-format on }; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); std::string assembly = JoinAllInsts(text); auto result = SinglePassRunAndDisassemble( assembly, /* skip_nop = */ true, /* do_validation = */ false); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); EXPECT_EQ(assembly, std::get<0>(result)); } TEST_F(AggressiveDCETest, KeepPrivateVarInExportFunctions) { // The loads and stores from the private variable should not be removed // because the functions are exported and could be called. const std::string text = R"(OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpSource HLSL 630 OpName %privateVar "privateVar" OpName %ReadPrivate "ReadPrivate" OpName %WritePrivate "WritePrivate" OpName %value "value" OpDecorate %ReadPrivate LinkageAttributes "ReadPrivate" Export OpDecorate %WritePrivate LinkageAttributes "WritePrivate" Export %int = OpTypeInt 32 1 %_ptr_Private_int = OpTypePointer Private %int %6 = OpTypeFunction %int %void = OpTypeVoid %_ptr_Function_int = OpTypePointer Function %int %10 = OpTypeFunction %void %_ptr_Function_int %privateVar = OpVariable %_ptr_Private_int Private %ReadPrivate = OpFunction %int None %6 %12 = OpLabel %8 = OpLoad %int %privateVar OpReturnValue %8 OpFunctionEnd %WritePrivate = OpFunction %void None %10 %value = OpFunctionParameter %_ptr_Function_int %13 = OpLabel %14 = OpLoad %int %value OpStore %privateVar %14 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ false); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); EXPECT_EQ(text, std::get<0>(result)); } TEST_F(AggressiveDCETest, KeepLableNames) { const std::string text = R"(OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpSource HLSL 630 OpName %WritePrivate "WritePrivate" OpName %entry "entry" OpName %target "target" OpDecorate %WritePrivate LinkageAttributes "WritePrivate" Export %void = OpTypeVoid %3 = OpTypeFunction %void %WritePrivate = OpFunction %void None %3 %entry = OpLabel OpBranch %target %target = OpLabel OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ false); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); EXPECT_EQ(text, std::get<0>(result)); } TEST_F(AggressiveDCETest, PreserveInterface) { // Set preserve_interface to true. Verify that unused uniform // constant in entry point interface is not eliminated. const std::string text = R"(OpCapability RayTracingKHR OpExtension "SPV_KHR_ray_tracing" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint RayGenerationKHR %2 "main" %3 %4 OpDecorate %3 Location 0 OpDecorate %4 DescriptorSet 2 OpDecorate %4 Binding 0 %void = OpTypeVoid %6 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %float = OpTypeFloat 32 %_ptr_CallableDataKHR_float = OpTypePointer CallableDataKHR %float %3 = OpVariable %_ptr_CallableDataKHR_float CallableDataKHR %13 = OpTypeAccelerationStructureKHR %_ptr_UniformConstant_13 = OpTypePointer UniformConstant %13 %4 = OpVariable %_ptr_UniformConstant_13 UniformConstant %2 = OpFunction %void None %6 %15 = OpLabel OpExecuteCallableKHR %uint_0 %3 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_2); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ false, /* preserve_interface */ true); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); EXPECT_EQ(text, std::get<0>(result)); } TEST_F(AggressiveDCETest, EmptyContinueWithConditionalBranch) { const std::string text = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft %void = OpTypeVoid %4 = OpTypeFunction %void %bool = OpTypeBool %false = OpConstantFalse %bool %2 = OpFunction %void None %4 %9 = OpLabel OpBranch %10 %10 = OpLabel OpLoopMerge %11 %12 None OpBranch %13 %13 = OpLabel OpKill %12 = OpLabel OpBranchConditional %false %10 %10 %11 = OpLabel OpUnreachable OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_2); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(text, text, false); } TEST_F(AggressiveDCETest, FunctionBecomesUnreachableAfterDCE) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 320 %void = OpTypeVoid %4 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %7 = OpTypeFunction %int %int_n1 = OpConstant %int -1 %2 = OpFunction %void None %4 %9 = OpLabel OpKill %10 = OpLabel %11 = OpFunctionCall %int %12 OpReturn OpFunctionEnd ; CHECK: {{%\w+}} = OpFunction %int DontInline|Pure %12 = OpFunction %int DontInline|Pure %7 ; CHECK-NEXT: {{%\w+}} = OpLabel %13 = OpLabel %14 = OpVariable %_ptr_Function_int Function ; CHECK-NEXT: OpBranch [[header:%\w+]] OpBranch %15 ; CHECK-NEXT: [[header]] = OpLabel ; CHECK-NEXT: OpBranch [[merge:%\w+]] %15 = OpLabel OpLoopMerge %16 %17 None OpBranch %18 %18 = OpLabel %19 = OpLoad %int %14 OpBranch %17 %17 = OpLabel OpBranch %15 ; CHECK-NEXT: [[merge]] = OpLabel %16 = OpLabel ; CHECK-NEXT: OpReturnValue %int_n1 OpReturnValue %int_n1 ; CHECK-NEXT: OpFunctionEnd OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(AggressiveDCETest, KeepTopLevelDebugInfo) { // Don't eliminate DebugCompilationUnit, DebugSourceContinued, and // DebugEntryPoint const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %1 = OpExtInstImport "NonSemantic.Shader.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %MainPs "MainPs" %out_var_SV_Target0 OpExecutionMode %MainPs OriginUpperLeft %4 = OpString "foo2.frag" %5 = OpString " struct PS_OUTPUT { float4 vColor : SV_Target0 ; } ; " %6 = OpString " PS_OUTPUT MainPs ( ) { PS_OUTPUT ps_output ; ps_output . vColor = float4( 1.0, 0.0, 0.0, 0.0 ); return ps_output ; } " %7 = OpString "float" %8 = OpString "vColor" %9 = OpString "PS_OUTPUT" %10 = OpString "MainPs" %11 = OpString "" %12 = OpString "ps_output" %13 = OpString "97a939fb" %14 = OpString " foo2.frag -E MainPs -T ps_6_1 -spirv -fspv-target-env=vulkan1.2 -fspv-debug=vulkan-with-source -fcgl -Fo foo2.frag.nopt.spv -Qembed_debug" OpName %out_var_SV_Target0 "out.var.SV_Target0" OpName %MainPs "MainPs" OpDecorate %out_var_SV_Target0 Location 0 %float = OpTypeFloat 32 %float_1 = OpConstant %float 1 %float_0 = OpConstant %float 0 %v4float = OpTypeVector %float 4 %23 = OpConstantComposite %v4float %float_1 %float_0 %float_0 %float_0 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %uint_1 = OpConstant %uint 1 %uint_4 = OpConstant %uint 4 %uint_5 = OpConstant %uint 5 %uint_3 = OpConstant %uint 3 %uint_0 = OpConstant %uint 0 %uint_128 = OpConstant %uint 128 %uint_12 = OpConstant %uint 12 %uint_2 = OpConstant %uint 2 %uint_8 = OpConstant %uint 8 %uint_7 = OpConstant %uint 7 %uint_9 = OpConstant %uint 9 %uint_15 = OpConstant %uint 15 %42 = OpTypeFunction %void %uint_10 = OpConstant %uint 10 %uint_53 = OpConstant %uint 53 %out_var_SV_Target0 = OpVariable %_ptr_Output_v4float Output %49 = OpExtInst %void %1 DebugExpression %50 = OpExtInst %void %1 DebugSource %4 %5 %51 = OpExtInst %void %1 DebugSourceContinued %6 ; CHECK: %51 = OpExtInst %void %1 DebugSourceContinued %6 %52 = OpExtInst %void %1 DebugCompilationUnit %uint_1 %uint_4 %50 %uint_5 ; CHECK: %52 = OpExtInst %void %1 DebugCompilationUnit %uint_1 %uint_4 %50 %uint_5 %53 = OpExtInst %void %1 DebugTypeBasic %7 %uint_32 %uint_3 %uint_0 %54 = OpExtInst %void %1 DebugTypeVector %53 %uint_4 %55 = OpExtInst %void %1 DebugTypeMember %8 %54 %50 %uint_4 %uint_12 %uint_0 %uint_128 %uint_3 %56 = OpExtInst %void %1 DebugTypeComposite %9 %uint_1 %50 %uint_2 %uint_8 %52 %9 %uint_128 %uint_3 %55 %57 = OpExtInst %void %1 DebugTypeFunction %uint_3 %56 %58 = OpExtInst %void %1 DebugFunction %10 %57 %50 %uint_7 %uint_1 %52 %11 %uint_3 %uint_8 %59 = OpExtInst %void %1 DebugLexicalBlock %50 %uint_8 %uint_1 %58 %60 = OpExtInst %void %1 DebugLocalVariable %12 %56 %50 %uint_9 %uint_15 %59 %uint_4 %61 = OpExtInst %void %1 DebugEntryPoint %58 %52 %13 %14 ; CHECK: %61 = OpExtInst %void %1 DebugEntryPoint %58 %52 %13 %14 %MainPs = OpFunction %void None %42 %62 = OpLabel %63 = OpExtInst %void %1 DebugFunctionDefinition %58 %MainPs %112 = OpExtInst %void %1 DebugScope %59 %111 = OpExtInst %void %1 DebugLine %50 %uint_10 %uint_10 %uint_5 %uint_53 %110 = OpExtInst %void %1 DebugValue %60 %23 %49 %int_0 %113 = OpExtInst %void %1 DebugNoLine %114 = OpExtInst %void %1 DebugNoScope OpStore %out_var_SV_Target0 %23 %66 = OpExtInst %void %1 DebugLine %50 %uint_12 %uint_12 %uint_1 %uint_1 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_2); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(text, true); } TEST_F(AggressiveDCETest, RemoveOutputTrue) { // Remove dead n_out output variable from module const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %c_out %c_in %n_out ;CHECK: OpEntryPoint Vertex %main "main" %c_out %c_in OpSource GLSL 450 OpName %main "main" OpName %c_out "c_out" OpName %c_in "c_in" OpName %n_out "n_out" OpDecorate %c_out Location 0 OpDecorate %c_in Location 0 OpDecorate %n_out Location 1 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %c_out = OpVariable %_ptr_Output_v4float Output %_ptr_Input_v4float = OpTypePointer Input %v4float %c_in = OpVariable %_ptr_Input_v4float Input %v3float = OpTypeVector %float 3 %_ptr_Output_v3float = OpTypePointer Output %v3float %n_out = OpVariable %_ptr_Output_v3float Output %main = OpFunction %void None %3 %5 = OpLabel %12 = OpLoad %v4float %c_in OpStore %c_out %12 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(text, true, false, true); } TEST_F(AggressiveDCETest, RemoveOutputFalse) { // Remove dead n_out output variable from module const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %c_out %c_in %n_out ;CHECK: OpEntryPoint Vertex %main "main" %c_out %c_in %n_out OpSource GLSL 450 OpName %main "main" OpName %c_out "c_out" OpName %c_in "c_in" OpName %n_out "n_out" OpDecorate %c_out Location 0 OpDecorate %c_in Location 0 OpDecorate %n_out Location 1 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %c_out = OpVariable %_ptr_Output_v4float Output %_ptr_Input_v4float = OpTypePointer Input %v4float %c_in = OpVariable %_ptr_Input_v4float Input %v3float = OpTypeVector %float 3 %_ptr_Output_v3float = OpTypePointer Output %v3float %n_out = OpVariable %_ptr_Output_v3float Output %main = OpFunction %void None %3 %5 = OpLabel %12 = OpLoad %v4float %c_in OpStore %c_out %12 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(text, true, false, false); } TEST_F(AggressiveDCETest, RemoveWhenUsingPrintfExtension) { // Remove dead n_out output variable from module const std::string text = R"( ; CHECK: OpExtInstImport "NonSemantic.DebugPrintf" ; CHECK-NOT: OpVariable OpCapability Shader %1 = OpExtInstImport "NonSemantic.DebugPrintf" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 8 8 1 OpSource HLSL 660 OpName %main "main" %uint = OpTypeInt 32 0 %void = OpTypeVoid %5 = OpTypeFunction %void %_ptr_Function_uint = OpTypePointer Function %uint %main = OpFunction %void None %5 %7 = OpLabel %8 = OpVariable %_ptr_Function_uint Function OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SinglePassRunAndMatch(text, true); } TEST_F(AggressiveDCETest, FunctionReturnPointer) { // Run DCE when a function returning a pointer to a reference is present const std::string text = R"( OpCapability Shader OpCapability PhysicalStorageBufferAddresses %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint Vertex %2 "main" %3 %4 OpSource GLSL 450 OpSourceExtension "GL_EXT_buffer_reference" OpSourceExtension "GL_EXT_scalar_block_layout" OpName %4 "color" OpMemberDecorate %5 0 Offset 0 OpDecorate %5 Block OpMemberDecorate %7 0 Offset 0 OpDecorate %7 Block OpDecorate %8 AliasedPointer OpDecorate %4 Location 0 %9 = OpTypeVoid %10 = OpTypeFunction %9 OpTypeForwardPointer %11 PhysicalStorageBuffer %12 = OpTypeInt 32 0 %5 = OpTypeStruct %12 %11 = OpTypePointer PhysicalStorageBuffer %5 ;CHECK: [[pt:%\w+]] = OpTypePointer PhysicalStorageBuffer {{%\w+}} %13 = OpTypeFunction %11 ;CHECK: [[pt_fn:%\w+]] = OpTypeFunction [[pt]] %7 = OpTypeStruct %11 %14 = OpTypePointer PushConstant %7 %3 = OpVariable %14 PushConstant %15 = OpTypeInt 32 1 %16 = OpConstant %15 0 %17 = OpTypePointer PushConstant %11 %18 = OpTypePointer Function %11 %19 = OpTypeFloat 32 %20 = OpTypeVector %19 4 %21 = OpTypePointer Output %20 %4 = OpVariable %21 Output %22 = OpConstant %19 1 %23 = OpConstant %19 0 %24 = OpConstantComposite %20 %22 %23 %22 %22 %6 = OpFunction %11 None %13 ;CHECK: [[fn:%\w+]] = OpFunction [[pt]] None [[pt_fn]] %27 = OpLabel %28 = OpAccessChain %17 %3 %16 %29 = OpLoad %11 %28 OpReturnValue %29 OpFunctionEnd %2 = OpFunction %9 None %10 %25 = OpLabel %8 = OpVariable %18 Function %26 = OpFunctionCall %11 %6 ;CHECK: {{%\w+}} = OpFunctionCall [[pt]] [[fn]] OpStore %8 %26 OpStore %4 %24 OpReturn OpFunctionEnd )"; // For physical storage buffer support SetTargetEnv(SPV_ENV_VULKAN_1_2); SinglePassRunAndMatch(text, true); } TEST_F(AggressiveDCETest, KeepBeginEndInvocationInterlock) { // OpBeginInvocationInterlockEXT and OpEndInvocationInterlockEXT delimit a // critical section. As such, they should be treated as if they have side // effects and should not be removed. const std::string test = R"(OpCapability Shader OpCapability FragmentShaderSampleInterlockEXT OpExtension "SPV_EXT_fragment_shader_interlock" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" %gl_FragCoord OpExecutionMode %1 OriginUpperLeft OpExecutionMode %1 SampleInterlockOrderedEXT OpDecorate %gl_FragCoord BuiltIn FragCoord %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %void = OpTypeVoid %8 = OpTypeFunction %void %bool = OpTypeBool %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %1 = OpFunction %void None %8 %10 = OpLabel %11 = OpLoad %v4float %gl_FragCoord %12 = OpCompositeExtract %float %11 0 %13 = OpFOrdGreaterThan %bool %12 %float_0 OpSelectionMerge %14 None OpBranchConditional %13 %15 %16 %15 = OpLabel OpBeginInvocationInterlockEXT OpBranch %14 %16 = OpLabel OpBeginInvocationInterlockEXT OpBranch %14 %14 = OpLabel OpEndInvocationInterlockEXT OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(test, test, true, true); } TEST_F(AggressiveDCETest, StoringAPointer) { // A store that stores a pointer should not be kept live because the value // being stored is eventually loaded from. const std::string text = R"( OpCapability CooperativeMatrixKHR OpCapability Shader OpExtension "SPV_KHR_cooperative_matrix" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %2 OpExecutionMode %1 LocalSize 64 1 1 OpSource HLSL 600 OpDecorate %2 DescriptorSet 0 OpDecorate %2 Binding 0 OpDecorate %_runtimearr_int ArrayStride 4 OpMemberDecorate %_struct_4 0 Offset 0 OpDecorate %_struct_4 Block %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_64 = OpConstant %uint 64 %uint_3 = OpConstant %uint 3 %uint_16 = OpConstant %uint 16 %uint_4 = OpConstant %uint 4 %coop_stride = OpConstant %int 42 %_runtimearr_int = OpTypeRuntimeArray %int %_struct_4 = OpTypeStruct %_runtimearr_int %_ptr_StorageBuffer__struct_4 = OpTypePointer StorageBuffer %_struct_4 %void = OpTypeVoid %16 = OpTypeFunction %void ; CHECK: [[mat:%\w+]] = OpTypeCooperativeMatrixKHR %int %uint_3 %uint_16 %uint_4 %uint_0 %17 = OpTypeCooperativeMatrixKHR %int %uint_3 %uint_16 %uint_4 %uint_0 ; CHECK: [[struct:%\w+]] = OpTypeStruct [[mat]] %_struct_18 = OpTypeStruct %17 ; CHECK: [[ptr:%\w+]] = OpTypePointer Function [[struct]] %_ptr_Function__struct_18 = OpTypePointer Function %_struct_18 %_ptr_StorageBuffer_int = OpTypePointer StorageBuffer %int %_ptr_Function_17 = OpTypePointer Function %17 %_ptr_Function_int = OpTypePointer Function %int %_ptr_Function__ptr_Function_int = OpTypePointer Function %_ptr_Function_int %2 = OpVariable %_ptr_StorageBuffer__struct_4 StorageBuffer ; The stored to the fist two variables should be removed and the variables ; as well. The only function scope variable should be the cooperative matrix. ; CHECK: OpFunction ; CHECK-NOT: OpVariable %_ptr_Function__ptr_Function_int Function ; CHECK: OpVariable [[ptr]] Function ; CHECK-NOT: OpVariable %1 = OpFunction %void None %16 %24 = OpLabel %25 = OpVariable %_ptr_Function__ptr_Function_int Function %26 = OpVariable %_ptr_Function__ptr_Function_int Function %27 = OpVariable %_ptr_Function__struct_18 Function %28 = OpAccessChain %_ptr_StorageBuffer_int %2 %int_0 %uint_0 %29 = OpCooperativeMatrixLoadKHR %17 %28 %int_1 %coop_stride %30 = OpCompositeConstruct %_struct_18 %29 OpStore %27 %30 %31 = OpAccessChain %_ptr_Function_17 %27 %int_0 %32 = OpAccessChain %_ptr_Function_int %27 %int_0 %uint_0 OpStore %26 %32 %33 = OpLoad %int %32 %34 = OpIAdd %int %33 %int_1 OpStore %25 %32 OpStore %32 %34 %35 = OpAccessChain %_ptr_StorageBuffer_int %2 %int_0 %uint_64 %36 = OpLoad %17 %31 OpCooperativeMatrixStoreKHR %35 %36 %int_0 %coop_stride OpReturn OpFunctionEnd )"; // For physical storage buffer support SetTargetEnv(SPV_ENV_VULKAN_1_2); SinglePassRunAndMatch(text, true); } TEST_F(AggressiveDCETest, FunctionDeclaration) { // Ensure the optimizer can handle traversing over a function declaration // 'myfunc' which has no blocks const std::string text = R"(OpCapability Linkage OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %PSMain "main" %entryPointParam_PSMain OpExecutionMode %PSMain OriginUpperLeft OpSource Slang 1 OpName %myfunc "myfunc" OpName %entryPointParam_PSMain "entryPointParam_PSMain" OpName %PSMain "PSMain" OpDecorate %myfunc LinkageAttributes "_S6myfuncp0pv4f" Import OpDecorate %entryPointParam_PSMain Location 0 %void = OpTypeVoid %5 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %8 = OpTypeFunction %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %entryPointParam_PSMain = OpVariable %_ptr_Output_v4float Output %myfunc = OpFunction %v4float None %8 OpFunctionEnd %PSMain = OpFunction %void None %5 %10 = OpLabel %11 = OpFunctionCall %v4float %myfunc OpStore %entryPointParam_PSMain %11 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(text, text, true, true); } TEST_F(AggressiveDCETest, MarkCentroidInterpolantLive) { const std::string spirv = R"(OpCapability InterpolationFunction OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_COLOR %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpSource HLSL 680 OpName %in_var_COLOR "in.var.COLOR" OpName %out_var_SV_Target "out.var.SV_Target" OpName %main "main" OpName %param_var_p1 "param.var.p1" OpDecorate %in_var_COLOR Location 0 OpDecorate %out_var_SV_Target Location 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %11 = OpTypeFunction %void %_ptr_Function_v4float = OpTypePointer Function %v4float %in_var_COLOR = OpVariable %_ptr_Input_v4float Input %out_var_SV_Target = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %11 %13 = OpLabel %14 = OpVariable %_ptr_Function_v4float Function %param_var_p1 = OpVariable %_ptr_Function_v4float Function %15 = OpLoad %v4float %in_var_COLOR OpStore %param_var_p1 %15 %16 = OpExtInst %v4float %1 InterpolateAtCentroid %param_var_p1 OpStore %14 %16 %17 = OpLoad %v4float %14 OpStore %out_var_SV_Target %17 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(spirv, spirv, true, false); } TEST_F(AggressiveDCETest, MarkSampleInterpolantLive) { const std::string spirv = R"(OpCapability InterpolationFunction OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_COLOR %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpSource HLSL 680 OpName %in_var_COLOR "in.var.COLOR" OpName %out_var_SV_Target "out.var.SV_Target" OpName %main "main" OpName %param_var_p1 "param.var.p1" OpDecorate %in_var_COLOR Location 0 OpDecorate %out_var_SV_Target Location 0 %float = OpTypeFloat 32 %int = OpTypeInt 32 1 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %12 = OpTypeFunction %void %_ptr_Function_v4float = OpTypePointer Function %v4float %in_var_COLOR = OpVariable %_ptr_Input_v4float Input %out_var_SV_Target = OpVariable %_ptr_Output_v4float Output %int_123 = OpConstant %int 123 %main = OpFunction %void None %12 %15 = OpLabel %16 = OpVariable %_ptr_Function_v4float Function %param_var_p1 = OpVariable %_ptr_Function_v4float Function %17 = OpLoad %v4float %in_var_COLOR OpStore %param_var_p1 %17 %18 = OpExtInst %v4float %1 InterpolateAtSample %param_var_p1 %int_123 OpStore %16 %18 %19 = OpLoad %v4float %16 OpStore %out_var_SV_Target %19 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(spirv, spirv, true, false); } TEST_F(AggressiveDCETest, MarkOffsetInterpolantLive) { const std::string spirv = R"(OpCapability InterpolationFunction OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_COLOR %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpSource HLSL 680 OpName %in_var_COLOR "in.var.COLOR" OpName %out_var_SV_Target "out.var.SV_Target" OpName %main "main" OpName %param_var_p1 "param.var.p1" OpDecorate %in_var_COLOR Location 0 OpDecorate %out_var_SV_Target Location 0 %float = OpTypeFloat 32 %int = OpTypeInt 32 1 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %12 = OpTypeFunction %void %_ptr_Function_v4float = OpTypePointer Function %v4float %in_var_COLOR = OpVariable %_ptr_Input_v4float Input %out_var_SV_Target = OpVariable %_ptr_Output_v4float Output %int_123 = OpConstant %int 123 %main = OpFunction %void None %12 %15 = OpLabel %16 = OpVariable %_ptr_Function_v4float Function %param_var_p1 = OpVariable %_ptr_Function_v4float Function %17 = OpLoad %v4float %in_var_COLOR OpStore %param_var_p1 %17 %18 = OpExtInst %v4float %1 InterpolateAtOffset %param_var_p1 %int_123 OpStore %16 %18 %19 = OpLoad %v4float %16 OpStore %out_var_SV_Target %19 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(spirv, spirv, true, false); } TEST_F(AggressiveDCETest, NoEliminateOpSource) { // Should not eliminate OpSource const std::string text = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_COLOR %out_var_SV_TARGET OpExecutionMode %main OriginUpperLeft %4 = OpString "D:\\directxshadercompiler\\tools\\clang\\test\\CodeGenSPIRV\\spirv.debug.opsource.include.hlsl" %5 = OpString "D:\\directxshadercompiler\\tools\\clang\\test\\CodeGenSPIRV/spirv.debug.opsource.include-file.hlsli" OpSource HLSL 600 %4 "// RUN: %dxc -T ps_6_0 -E main -Zi %s -spirv | FileCheck %s #include \"spirv.debug.opsource.include-file.hlsli\" struct ColorType { float4 position : SV_POSITION; float4 color : COLOR; }; float4 main(UBER_TYPE(Color) input) : SV_TARGET { return input.color; } " OpSource HLSL 600 %5 "#define UBER_TYPE(x) x ## Type " OpName %in_var_COLOR "in.var.COLOR" OpName %out_var_SV_TARGET "out.var.SV_TARGET" OpName %main "main" OpDecorate %in_var_COLOR Location 0 OpDecorate %out_var_SV_TARGET Location 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %11 = OpTypeFunction %void %in_var_COLOR = OpVariable %_ptr_Input_v4float Input %out_var_SV_TARGET = OpVariable %_ptr_Output_v4float Output OpLine %4 22 1 %main = OpFunction %void None %11 OpNoLine %12 = OpLabel OpLine %4 22 1 %13 = OpLoad %v4float %in_var_COLOR OpStore %out_var_SV_TARGET %13 OpLine %4 25 1 OpReturn OpFunctionEnd )"; auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* skip_validation = */ false); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); const std::string& output = std::get<0>(result); EXPECT_THAT( output, HasSubstr("OpSource HLSL 600 %5 \"#define UBER_TYPE(x) x ## Type")); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/amd_ext_to_khr.cpp000066400000000000000000001065071475742701700240160ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gmock/gmock.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using AmdExtToKhrTest = PassTest<::testing::Test>; using ::testing::HasSubstr; std::string GetTest(std::string op_code, std::string new_op_code, bool is_float = false) { const std::string text = R"( ; CHECK: OpCapability Shader ; CHECK-NOT: OpExtension "SPV_AMD_shader_ballot" ; CHECK: OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: [[undef:%\w+]] = OpUndef % ; CHECK-NEXT: )" + new_op_code + " %" + (is_float ? "float" : "uint") + R"( %uint_3 Reduce [[undef]] OpCapability Shader OpCapability Groups OpExtension "SPV_AMD_shader_ballot" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %float = OpTypeFloat 32 %uint_3 = OpConstant %uint 3 %1 = OpFunction %void None %3 %6 = OpLabel %7 = OpUndef %)" + (is_float ? "float" : "uint") + R"( %8 = )" + op_code + " %" + (is_float ? "float" : "uint") + R"( %uint_3 Reduce %7 OpReturn OpFunctionEnd )"; return text; } TEST_F(AmdExtToKhrTest, ReplaceGroupIAddNonUniformAMD) { std::string text = GetTest("OpGroupIAddNonUniformAMD", "OpGroupNonUniformIAdd"); SinglePassRunAndMatch(text, true); } TEST_F(AmdExtToKhrTest, ReplaceGroupFAddNonUniformAMD) { std::string text = GetTest("OpGroupFAddNonUniformAMD", "OpGroupNonUniformFAdd", true); SinglePassRunAndMatch(text, true); } TEST_F(AmdExtToKhrTest, ReplaceGroupUMinNonUniformAMD) { std::string text = GetTest("OpGroupUMinNonUniformAMD", "OpGroupNonUniformUMin"); SinglePassRunAndMatch(text, true); } TEST_F(AmdExtToKhrTest, ReplaceGroupSMinNonUniformAMD) { std::string text = GetTest("OpGroupSMinNonUniformAMD", "OpGroupNonUniformSMin"); SinglePassRunAndMatch(text, true); } TEST_F(AmdExtToKhrTest, ReplaceGroupFMinNonUniformAMD) { std::string text = GetTest("OpGroupFMinNonUniformAMD", "OpGroupNonUniformFMin", true); SinglePassRunAndMatch(text, true); } TEST_F(AmdExtToKhrTest, ReplaceGroupUMaxNonUniformAMD) { std::string text = GetTest("OpGroupUMaxNonUniformAMD", "OpGroupNonUniformUMax"); SinglePassRunAndMatch(text, true); } TEST_F(AmdExtToKhrTest, ReplaceGroupSMaxNonUniformAMD) { std::string text = GetTest("OpGroupSMaxNonUniformAMD", "OpGroupNonUniformSMax"); SinglePassRunAndMatch(text, true); } TEST_F(AmdExtToKhrTest, ReplaceGroupFMaxNonUniformAMD) { std::string text = GetTest("OpGroupFMaxNonUniformAMD", "OpGroupNonUniformFMax", true); SinglePassRunAndMatch(text, true); } TEST_F(AmdExtToKhrTest, ReplaceMbcntAMD) { const std::string text = R"( ; CHECK: OpCapability Shader ; CHECK-NOT: OpExtension "SPV_AMD_shader_ballot" ; CHECK-NOT: OpExtInstImport "SPV_AMD_shader_ballot" ; CHECK: OpDecorate [[var:%\w+]] BuiltIn SubgroupLtMask ; CHECK: [[var]] = OpVariable %_ptr_Input_v4uint Input ; CHECK: OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: [[ld:%\w+]] = OpLoad %v4uint [[var]] ; CHECK-NEXT: [[shuffle:%\w+]] = OpVectorShuffle %v2uint [[ld]] [[ld]] 0 1 ; CHECK-NEXT: [[bitcast:%\w+]] = OpBitcast %ulong [[shuffle]] ; CHECK-NEXT: [[and:%\w+]] = OpBitwiseAnd %ulong [[bitcast]] %ulong_0 ; CHECK-NEXT: [[result:%\w+]] = OpBitCount %uint [[and]] OpCapability Shader OpCapability Int64 OpExtension "SPV_AMD_shader_ballot" %1 = OpExtInstImport "SPV_AMD_shader_ballot" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "func" OpExecutionMode %2 OriginUpperLeft %void = OpTypeVoid %4 = OpTypeFunction %void %uint = OpTypeInt 32 0 %ulong = OpTypeInt 64 0 %ulong_0 = OpConstant %ulong 0 %2 = OpFunction %void None %4 %8 = OpLabel %9 = OpExtInst %uint %1 MbcntAMD %ulong_0 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(AmdExtToKhrTest, ReplaceSwizzleInvocationsAMD) { const std::string text = R"( ; CHECK: OpCapability Shader ; CHECK-NOT: OpExtension "SPV_AMD_shader_ballot" ; CHECK-NOT: OpExtInstImport "SPV_AMD_shader_ballot" ; CHECK: OpDecorate [[var:%\w+]] BuiltIn SubgroupLocalInvocationId ; CHECK: [[subgroup:%\w+]] = OpConstant %uint 3 ; CHECK: [[offset:%\w+]] = OpConstantComposite %v4uint ; CHECK: [[var]] = OpVariable %_ptr_Input_uint Input ; CHECK: [[uint_max:%\w+]] = OpConstant %uint 4294967295 ; CHECK: [[ballot_value:%\w+]] = OpConstantComposite %v4uint [[uint_max]] [[uint_max]] [[uint_max]] [[uint_max]] ; CHECK: [[null:%\w+]] = OpConstantNull [[type:%\w+]] ; CHECK: OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: [[data:%\w+]] = OpUndef [[type]] ; CHECK-NEXT: [[id:%\w+]] = OpLoad %uint [[var]] ; CHECK-NEXT: [[quad_idx:%\w+]] = OpBitwiseAnd %uint [[id]] %uint_3 ; CHECK-NEXT: [[quad_ldr:%\w+]] = OpBitwiseXor %uint [[id]] [[quad_idx]] ; CHECK-NEXT: [[my_offset:%\w+]] = OpVectorExtractDynamic %uint [[offset]] [[quad_idx]] ; CHECK-NEXT: [[target_inv:%\w+]] = OpIAdd %uint [[quad_ldr]] [[my_offset]] ; CHECK-NEXT: [[is_active:%\w+]] = OpGroupNonUniformBallotBitExtract %bool [[subgroup]] [[ballot_value]] [[target_inv]] ; CHECK-NEXT: [[shuffle:%\w+]] = OpGroupNonUniformShuffle [[type]] [[subgroup]] [[data]] [[target_inv]] ; CHECK-NEXT: [[result:%\w+]] = OpSelect [[type]] [[is_active]] [[shuffle]] [[null]] OpCapability Shader OpExtension "SPV_AMD_shader_ballot" %ext = OpExtInstImport "SPV_AMD_shader_ballot" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_x = OpConstant %uint 1 %uint_y = OpConstant %uint 2 %uint_z = OpConstant %uint 3 %uint_w = OpConstant %uint 0 %v4uint = OpTypeVector %uint 4 %offset = OpConstantComposite %v4uint %uint_x %uint_y %uint_z %uint_x %1 = OpFunction %void None %3 %6 = OpLabel %data = OpUndef %uint %9 = OpExtInst %uint %ext SwizzleInvocationsAMD %data %offset OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(AmdExtToKhrTest, ReplaceSwizzleInvocationsMaskedAMD) { const std::string text = R"( ; CHECK: OpCapability Shader ; CHECK-NOT: OpExtension "SPV_AMD_shader_ballot" ; CHECK-NOT: OpExtInstImport "SPV_AMD_shader_ballot" ; CHECK: OpDecorate [[var:%\w+]] BuiltIn SubgroupLocalInvocationId ; CHECK: [[x:%\w+]] = OpConstant %uint 19 ; CHECK: [[y:%\w+]] = OpConstant %uint 12 ; CHECK: [[z:%\w+]] = OpConstant %uint 16 ; CHECK: [[var]] = OpVariable %_ptr_Input_uint Input ; CHECK: [[mask_extend:%\w+]] = OpConstant %uint 4294967264 ; CHECK: [[uint_max:%\w+]] = OpConstant %uint 4294967295 ; CHECK: [[subgroup:%\w+]] = OpConstant %uint 3 ; CHECK: [[ballot_value:%\w+]] = OpConstantComposite %v4uint [[uint_max]] [[uint_max]] [[uint_max]] [[uint_max]] ; CHECK: [[null:%\w+]] = OpConstantNull [[type:%\w+]] ; CHECK: OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: [[data:%\w+]] = OpUndef [[type]] ; CHECK-NEXT: [[id:%\w+]] = OpLoad %uint [[var]] ; CHECK-NEXT: [[and_mask:%\w+]] = OpBitwiseOr %uint [[x]] [[mask_extend]] ; CHECK-NEXT: [[and:%\w+]] = OpBitwiseAnd %uint [[id]] [[and_mask]] ; CHECK-NEXT: [[or:%\w+]] = OpBitwiseOr %uint [[and]] [[y]] ; CHECK-NEXT: [[target_inv:%\w+]] = OpBitwiseXor %uint [[or]] [[z]] ; CHECK-NEXT: [[is_active:%\w+]] = OpGroupNonUniformBallotBitExtract %bool [[subgroup]] [[ballot_value]] [[target_inv]] ; CHECK-NEXT: [[shuffle:%\w+]] = OpGroupNonUniformShuffle [[type]] [[subgroup]] [[data]] [[target_inv]] ; CHECK-NEXT: [[result:%\w+]] = OpSelect [[type]] [[is_active]] [[shuffle]] [[null]] OpCapability Shader OpExtension "SPV_AMD_shader_ballot" %ext = OpExtInstImport "SPV_AMD_shader_ballot" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_x = OpConstant %uint 19 %uint_y = OpConstant %uint 12 %uint_z = OpConstant %uint 16 %v3uint = OpTypeVector %uint 3 %mask = OpConstantComposite %v3uint %uint_x %uint_y %uint_z %1 = OpFunction %void None %3 %6 = OpLabel %data = OpUndef %uint %9 = OpExtInst %uint %ext SwizzleInvocationsMaskedAMD %data %mask OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(AmdExtToKhrTest, ReplaceWriteInvocationAMD) { const std::string text = R"( ; CHECK: OpCapability Shader ; CHECK-NOT: OpExtension "SPV_AMD_shader_ballot" ; CHECK-NOT: OpExtInstImport "SPV_AMD_shader_ballot" ; CHECK: OpDecorate [[var:%\w+]] BuiltIn SubgroupLocalInvocationId ; CHECK: [[var]] = OpVariable %_ptr_Input_uint Input ; CHECK: OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: [[input_val:%\w+]] = OpUndef %uint ; CHECK-NEXT: [[write_val:%\w+]] = OpUndef %uint ; CHECK-NEXT: [[ld:%\w+]] = OpLoad %uint [[var]] ; CHECK-NEXT: [[cmp:%\w+]] = OpIEqual %bool [[ld]] %uint_3 ; CHECK-NEXT: [[result:%\w+]] = OpSelect %uint [[cmp]] [[write_val]] [[input_val]] OpCapability Shader OpExtension "SPV_AMD_shader_ballot" %ext = OpExtInstImport "SPV_AMD_shader_ballot" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_3 = OpConstant %uint 3 %1 = OpFunction %void None %3 %6 = OpLabel %7 = OpUndef %uint %8 = OpUndef %uint %9 = OpExtInst %uint %ext WriteInvocationAMD %7 %8 %uint_3 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(AmdExtToKhrTest, ReplaceFMin3AMD) { const std::string text = R"( ; CHECK: OpCapability Shader ; CHECK-NOT: OpExtension "SPV_AMD_shader_trinary_minmax" ; CHECK-NOT: OpExtInstImport "SPV_AMD_shader_trinary_minmax" ; CHECK: [[ext:%\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK: [[type:%\w+]] = OpTypeFloat 32 ; CHECK: OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: [[x:%\w+]] = OpUndef [[type]] ; CHECK-NEXT: [[y:%\w+]] = OpUndef [[type]] ; CHECK-NEXT: [[z:%\w+]] = OpUndef [[type]] ; CHECK-NEXT: [[temp:%\w+]] = OpExtInst [[type]] [[ext]] FMin [[x]] [[y]] ; CHECK-NEXT: [[result:%\w+]] = OpExtInst [[type]] [[ext]] FMin [[temp]] [[z]] OpCapability Shader OpExtension "SPV_AMD_shader_trinary_minmax" %ext = OpExtInstImport "SPV_AMD_shader_trinary_minmax" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %float = OpTypeFloat 32 %uint_3 = OpConstant %uint 3 %1 = OpFunction %void None %3 %6 = OpLabel %7 = OpUndef %float %8 = OpUndef %float %9 = OpUndef %float %10 = OpExtInst %float %ext FMin3AMD %7 %8 %9 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(AmdExtToKhrTest, ReplaceSMin3AMD) { const std::string text = R"( ; CHECK: OpCapability Shader ; CHECK-NOT: OpExtension "SPV_AMD_shader_trinary_minmax" ; CHECK-NOT: OpExtInstImport "SPV_AMD_shader_trinary_minmax" ; CHECK: [[ext:%\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK: [[type:%\w+]] = OpTypeInt 32 1 ; CHECK: OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: [[x:%\w+]] = OpUndef [[type]] ; CHECK-NEXT: [[y:%\w+]] = OpUndef [[type]] ; CHECK-NEXT: [[z:%\w+]] = OpUndef [[type]] ; CHECK-NEXT: [[temp:%\w+]] = OpExtInst [[type]] [[ext]] SMin [[x]] [[y]] ; CHECK-NEXT: [[result:%\w+]] = OpExtInst [[type]] [[ext]] SMin [[temp]] [[z]] OpCapability Shader OpExtension "SPV_AMD_shader_trinary_minmax" %ext = OpExtInstImport "SPV_AMD_shader_trinary_minmax" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %int = OpTypeInt 32 1 %float = OpTypeFloat 32 %uint_3 = OpConstant %uint 3 %1 = OpFunction %void None %3 %6 = OpLabel %7 = OpUndef %int %8 = OpUndef %int %9 = OpUndef %int %10 = OpExtInst %int %ext SMin3AMD %7 %8 %9 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(AmdExtToKhrTest, ReplaceUMin3AMD) { const std::string text = R"( ; CHECK: OpCapability Shader ; CHECK-NOT: OpExtension "SPV_AMD_shader_trinary_minmax" ; CHECK-NOT: OpExtInstImport "SPV_AMD_shader_trinary_minmax" ; CHECK: [[ext:%\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK: [[type:%\w+]] = OpTypeInt 32 0 ; CHECK: OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: [[x:%\w+]] = OpUndef [[type]] ; CHECK-NEXT: [[y:%\w+]] = OpUndef [[type]] ; CHECK-NEXT: [[z:%\w+]] = OpUndef [[type]] ; CHECK-NEXT: [[temp:%\w+]] = OpExtInst [[type]] [[ext]] UMin [[x]] [[y]] ; CHECK-NEXT: [[result:%\w+]] = OpExtInst [[type]] [[ext]] UMin [[temp]] [[z]] OpCapability Shader OpExtension "SPV_AMD_shader_trinary_minmax" %ext = OpExtInstImport "SPV_AMD_shader_trinary_minmax" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %int = OpTypeInt 32 1 %float = OpTypeFloat 32 %uint_3 = OpConstant %uint 3 %1 = OpFunction %void None %3 %6 = OpLabel %7 = OpUndef %uint %8 = OpUndef %uint %9 = OpUndef %uint %10 = OpExtInst %uint %ext UMin3AMD %7 %8 %9 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(AmdExtToKhrTest, ReplaceFMax3AMD) { const std::string text = R"( ; CHECK: OpCapability Shader ; CHECK-NOT: OpExtension "SPV_AMD_shader_trinary_minmax" ; CHECK-NOT: OpExtInstImport "SPV_AMD_shader_trinary_minmax" ; CHECK: [[ext:%\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK: [[type:%\w+]] = OpTypeFloat 32 ; CHECK: OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: [[x:%\w+]] = OpUndef [[type]] ; CHECK-NEXT: [[y:%\w+]] = OpUndef [[type]] ; CHECK-NEXT: [[z:%\w+]] = OpUndef [[type]] ; CHECK-NEXT: [[temp:%\w+]] = OpExtInst [[type]] [[ext]] FMax [[x]] [[y]] ; CHECK-NEXT: [[result:%\w+]] = OpExtInst [[type]] [[ext]] FMax [[temp]] [[z]] OpCapability Shader OpExtension "SPV_AMD_shader_trinary_minmax" %ext = OpExtInstImport "SPV_AMD_shader_trinary_minmax" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %float = OpTypeFloat 32 %uint_3 = OpConstant %uint 3 %1 = OpFunction %void None %3 %6 = OpLabel %7 = OpUndef %float %8 = OpUndef %float %9 = OpUndef %float %10 = OpExtInst %float %ext FMax3AMD %7 %8 %9 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(AmdExtToKhrTest, ReplaceSMax3AMD) { const std::string text = R"( ; CHECK: OpCapability Shader ; CHECK-NOT: OpExtension "SPV_AMD_shader_trinary_minmax" ; CHECK-NOT: OpExtInstImport "SPV_AMD_shader_trinary_minmax" ; CHECK: [[ext:%\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK: [[type:%\w+]] = OpTypeInt 32 1 ; CHECK: OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: [[x:%\w+]] = OpUndef [[type]] ; CHECK-NEXT: [[y:%\w+]] = OpUndef [[type]] ; CHECK-NEXT: [[z:%\w+]] = OpUndef [[type]] ; CHECK-NEXT: [[temp:%\w+]] = OpExtInst [[type]] [[ext]] SMax [[x]] [[y]] ; CHECK-NEXT: [[result:%\w+]] = OpExtInst [[type]] [[ext]] SMax [[temp]] [[z]] OpCapability Shader OpExtension "SPV_AMD_shader_trinary_minmax" %ext = OpExtInstImport "SPV_AMD_shader_trinary_minmax" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %int = OpTypeInt 32 1 %float = OpTypeFloat 32 %uint_3 = OpConstant %uint 3 %1 = OpFunction %void None %3 %6 = OpLabel %7 = OpUndef %int %8 = OpUndef %int %9 = OpUndef %int %10 = OpExtInst %int %ext SMax3AMD %7 %8 %9 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(AmdExtToKhrTest, ReplaceUMax3AMD) { const std::string text = R"( ; CHECK: OpCapability Shader ; CHECK-NOT: OpExtension "SPV_AMD_shader_trinary_minmax" ; CHECK-NOT: OpExtInstImport "SPV_AMD_shader_trinary_minmax" ; CHECK: [[ext:%\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK: [[type:%\w+]] = OpTypeInt 32 0 ; CHECK: OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: [[x:%\w+]] = OpUndef [[type]] ; CHECK-NEXT: [[y:%\w+]] = OpUndef [[type]] ; CHECK-NEXT: [[z:%\w+]] = OpUndef [[type]] ; CHECK-NEXT: [[temp:%\w+]] = OpExtInst [[type]] [[ext]] UMax [[x]] [[y]] ; CHECK-NEXT: [[result:%\w+]] = OpExtInst [[type]] [[ext]] UMax [[temp]] [[z]] OpCapability Shader OpExtension "SPV_AMD_shader_trinary_minmax" %ext = OpExtInstImport "SPV_AMD_shader_trinary_minmax" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %int = OpTypeInt 32 1 %float = OpTypeFloat 32 %uint_3 = OpConstant %uint 3 %1 = OpFunction %void None %3 %6 = OpLabel %7 = OpUndef %uint %8 = OpUndef %uint %9 = OpUndef %uint %10 = OpExtInst %uint %ext UMax3AMD %7 %8 %9 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(AmdExtToKhrTest, ReplaceVecUMax3AMD) { const std::string text = R"( ; CHECK: OpCapability Shader ; CHECK-NOT: OpExtension "SPV_AMD_shader_trinary_minmax" ; CHECK-NOT: OpExtInstImport "SPV_AMD_shader_trinary_minmax" ; CHECK: [[ext:%\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK: [[type:%\w+]] = OpTypeVector ; CHECK: OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: [[x:%\w+]] = OpUndef [[type]] ; CHECK-NEXT: [[y:%\w+]] = OpUndef [[type]] ; CHECK-NEXT: [[z:%\w+]] = OpUndef [[type]] ; CHECK-NEXT: [[temp:%\w+]] = OpExtInst [[type]] [[ext]] UMax [[x]] [[y]] ; CHECK-NEXT: [[result:%\w+]] = OpExtInst [[type]] [[ext]] UMax [[temp]] [[z]] OpCapability Shader OpExtension "SPV_AMD_shader_trinary_minmax" %ext = OpExtInstImport "SPV_AMD_shader_trinary_minmax" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %vec = OpTypeVector %uint 4 %int = OpTypeInt 32 1 %float = OpTypeFloat 32 %uint_3 = OpConstant %uint 3 %1 = OpFunction %void None %3 %6 = OpLabel %7 = OpUndef %vec %8 = OpUndef %vec %9 = OpUndef %vec %10 = OpExtInst %vec %ext UMax3AMD %7 %8 %9 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(AmdExtToKhrTest, ReplaceFMid3AMD) { const std::string text = R"( ; CHECK: OpCapability Shader ; CHECK-NOT: OpExtension "SPV_AMD_shader_trinary_minmax" ; CHECK-NOT: OpExtInstImport "SPV_AMD_shader_trinary_minmax" ; CHECK: [[ext:%\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK: [[type:%\w+]] = OpTypeFloat 32 ; CHECK: OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: [[x:%\w+]] = OpUndef [[type]] ; CHECK-NEXT: [[y:%\w+]] = OpUndef [[type]] ; CHECK-NEXT: [[z:%\w+]] = OpUndef [[type]] ; CHECK-NEXT: [[min:%\w+]] = OpExtInst [[type]] [[ext]] FMin [[y]] [[z]] ; CHECK-NEXT: [[max:%\w+]] = OpExtInst [[type]] [[ext]] FMax [[y]] [[z]] ; CHECK-NEXT: [[result:%\w+]] = OpExtInst [[type]] [[ext]] FClamp [[x]] [[min]] [[max]] OpCapability Shader OpExtension "SPV_AMD_shader_trinary_minmax" %ext = OpExtInstImport "SPV_AMD_shader_trinary_minmax" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %float = OpTypeFloat 32 %uint_3 = OpConstant %uint 3 %1 = OpFunction %void None %3 %6 = OpLabel %7 = OpUndef %float %8 = OpUndef %float %9 = OpUndef %float %10 = OpExtInst %float %ext FMid3AMD %7 %8 %9 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(AmdExtToKhrTest, ReplaceSMid3AMD) { const std::string text = R"( ; CHECK: OpCapability Shader ; CHECK-NOT: OpExtension "SPV_AMD_shader_trinary_minmax" ; CHECK-NOT: OpExtInstImport "SPV_AMD_shader_trinary_minmax" ; CHECK: [[ext:%\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK: [[type:%\w+]] = OpTypeInt 32 1 ; CHECK: OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: [[x:%\w+]] = OpUndef [[type]] ; CHECK-NEXT: [[y:%\w+]] = OpUndef [[type]] ; CHECK-NEXT: [[z:%\w+]] = OpUndef [[type]] ; CHECK-NEXT: [[min:%\w+]] = OpExtInst [[type]] [[ext]] SMin [[y]] [[z]] ; CHECK-NEXT: [[max:%\w+]] = OpExtInst [[type]] [[ext]] SMax [[y]] [[z]] ; CHECK-NEXT: [[result:%\w+]] = OpExtInst [[type]] [[ext]] SClamp [[x]] [[min]] [[max]] OpCapability Shader OpExtension "SPV_AMD_shader_trinary_minmax" %ext = OpExtInstImport "SPV_AMD_shader_trinary_minmax" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %int = OpTypeInt 32 1 %float = OpTypeFloat 32 %uint_3 = OpConstant %uint 3 %1 = OpFunction %void None %3 %6 = OpLabel %7 = OpUndef %int %8 = OpUndef %int %9 = OpUndef %int %10 = OpExtInst %int %ext SMid3AMD %7 %8 %9 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(AmdExtToKhrTest, ReplaceUMid3AMD) { const std::string text = R"( ; CHECK: OpCapability Shader ; CHECK-NOT: OpExtension "SPV_AMD_shader_trinary_minmax" ; CHECK-NOT: OpExtInstImport "SPV_AMD_shader_trinary_minmax" ; CHECK: [[ext:%\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK: [[type:%\w+]] = OpTypeInt 32 0 ; CHECK: OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: [[x:%\w+]] = OpUndef [[type]] ; CHECK-NEXT: [[y:%\w+]] = OpUndef [[type]] ; CHECK-NEXT: [[z:%\w+]] = OpUndef [[type]] ; CHECK-NEXT: [[min:%\w+]] = OpExtInst [[type]] [[ext]] UMin [[y]] [[z]] ; CHECK-NEXT: [[max:%\w+]] = OpExtInst [[type]] [[ext]] UMax [[y]] [[z]] ; CHECK-NEXT: [[result:%\w+]] = OpExtInst [[type]] [[ext]] UClamp [[x]] [[min]] [[max]] OpCapability Shader OpExtension "SPV_AMD_shader_trinary_minmax" %ext = OpExtInstImport "SPV_AMD_shader_trinary_minmax" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %int = OpTypeInt 32 1 %float = OpTypeFloat 32 %uint_3 = OpConstant %uint 3 %1 = OpFunction %void None %3 %6 = OpLabel %7 = OpUndef %uint %8 = OpUndef %uint %9 = OpUndef %uint %10 = OpExtInst %uint %ext UMid3AMD %7 %8 %9 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(AmdExtToKhrTest, ReplaceVecUMid3AMD) { const std::string text = R"( ; CHECK: OpCapability Shader ; CHECK-NOT: OpExtension "SPV_AMD_shader_trinary_minmax" ; CHECK-NOT: OpExtInstImport "SPV_AMD_shader_trinary_minmax" ; CHECK: [[ext:%\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK: [[type:%\w+]] = OpTypeVector ; CHECK: OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: [[x:%\w+]] = OpUndef [[type]] ; CHECK-NEXT: [[y:%\w+]] = OpUndef [[type]] ; CHECK-NEXT: [[z:%\w+]] = OpUndef [[type]] ; CHECK-NEXT: [[min:%\w+]] = OpExtInst [[type]] [[ext]] UMin [[y]] [[z]] ; CHECK-NEXT: [[max:%\w+]] = OpExtInst [[type]] [[ext]] UMax [[y]] [[z]] ; CHECK-NEXT: [[result:%\w+]] = OpExtInst [[type]] [[ext]] UClamp [[x]] [[min]] [[max]] OpCapability Shader OpExtension "SPV_AMD_shader_trinary_minmax" %ext = OpExtInstImport "SPV_AMD_shader_trinary_minmax" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %vec = OpTypeVector %uint 3 %int = OpTypeInt 32 1 %float = OpTypeFloat 32 %uint_3 = OpConstant %uint 3 %1 = OpFunction %void None %3 %6 = OpLabel %7 = OpUndef %vec %8 = OpUndef %vec %9 = OpUndef %vec %10 = OpExtInst %vec %ext UMid3AMD %7 %8 %9 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(AmdExtToKhrTest, ReplaceCubeFaceCoordAMD) { // Sorry for the Check test. The code sequence is so long, I do not think // that a match test would be anymore legible. This tests the replacement of // the CubeFaceCoordAMD instruction. const std::string before = R"( OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_AMD_gcn_shader" %1 = OpExtInstImport "SPV_AMD_gcn_shader" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" OpExecutionMode %2 LocalSize 1 1 1 %void = OpTypeVoid %4 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %v3float = OpTypeVector %float 3 %2 = OpFunction %void None %4 %8 = OpLabel %9 = OpUndef %v3float %10 = OpExtInst %v2float %1 CubeFaceCoordAMD %9 OpReturn OpFunctionEnd )"; const std::string after = R"(OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" %12 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" OpExecutionMode %2 LocalSize 1 1 1 %void = OpTypeVoid %4 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %v3float = OpTypeVector %float 3 %bool = OpTypeBool %float_0 = OpConstant %float 0 %float_2 = OpConstant %float 2 %float_0_5 = OpConstant %float 0.5 %16 = OpConstantComposite %v2float %float_0_5 %float_0_5 %2 = OpFunction %void None %4 %8 = OpLabel %9 = OpUndef %v3float %17 = OpCompositeExtract %float %9 0 %18 = OpCompositeExtract %float %9 1 %19 = OpCompositeExtract %float %9 2 %20 = OpFNegate %float %17 %21 = OpFNegate %float %18 %22 = OpFNegate %float %19 %23 = OpExtInst %float %12 FAbs %17 %24 = OpExtInst %float %12 FAbs %18 %25 = OpExtInst %float %12 FAbs %19 %26 = OpFOrdLessThan %bool %19 %float_0 %27 = OpFOrdLessThan %bool %18 %float_0 %28 = OpFOrdLessThan %bool %17 %float_0 %29 = OpExtInst %float %12 FMax %23 %24 %30 = OpExtInst %float %12 FMax %25 %29 %31 = OpFMul %float %float_2 %30 %32 = OpFOrdGreaterThanEqual %bool %25 %29 %33 = OpLogicalNot %bool %32 %34 = OpFOrdGreaterThanEqual %bool %24 %23 %35 = OpLogicalAnd %bool %33 %34 %36 = OpSelect %float %26 %20 %17 %37 = OpSelect %float %28 %19 %22 %38 = OpSelect %float %35 %17 %37 %39 = OpSelect %float %32 %36 %38 %40 = OpSelect %float %27 %22 %19 %41 = OpSelect %float %35 %40 %21 %42 = OpCompositeConstruct %v2float %39 %41 %43 = OpCompositeConstruct %v2float %31 %31 %44 = OpFDiv %v2float %42 %43 %10 = OpFAdd %v2float %44 %16 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(before, after, true); } TEST_F(AmdExtToKhrTest, ReplaceCubeFaceIndexAMD) { // Sorry for the Check test. The code sequence is so long, I do not think // that a match test would be anymore legible. This tests the replacement of // the CubeFaceIndexAMD instruction. const std::string before = R"(OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_AMD_gcn_shader" %1 = OpExtInstImport "SPV_AMD_gcn_shader" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" OpExecutionMode %2 LocalSize 1 1 1 %void = OpTypeVoid %4 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %2 = OpFunction %void None %4 %7 = OpLabel %8 = OpUndef %v3float %9 = OpExtInst %float %1 CubeFaceIndexAMD %8 OpReturn OpFunctionEnd )"; const std::string after = R"(OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" %11 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" OpExecutionMode %2 LocalSize 1 1 1 %void = OpTypeVoid %4 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %bool = OpTypeBool %float_0 = OpConstant %float 0 %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %float_3 = OpConstant %float 3 %float_4 = OpConstant %float 4 %float_5 = OpConstant %float 5 %2 = OpFunction %void None %4 %7 = OpLabel %8 = OpUndef %v3float %18 = OpCompositeExtract %float %8 0 %19 = OpCompositeExtract %float %8 1 %20 = OpCompositeExtract %float %8 2 %21 = OpExtInst %float %11 FAbs %18 %22 = OpExtInst %float %11 FAbs %19 %23 = OpExtInst %float %11 FAbs %20 %24 = OpFOrdLessThan %bool %20 %float_0 %25 = OpFOrdLessThan %bool %19 %float_0 %26 = OpFOrdLessThan %bool %18 %float_0 %27 = OpExtInst %float %11 FMax %21 %22 %28 = OpFOrdGreaterThanEqual %bool %23 %27 %29 = OpFOrdGreaterThanEqual %bool %22 %21 %30 = OpSelect %float %24 %float_5 %float_4 %31 = OpSelect %float %25 %float_3 %float_2 %32 = OpSelect %float %26 %float_1 %float_0 %33 = OpSelect %float %29 %31 %32 %9 = OpSelect %float %28 %30 %33 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(before, after, true); } TEST_F(AmdExtToKhrTest, SetVersion) { const std::string text = R"( OpCapability Shader OpCapability Int64 OpExtension "SPV_AMD_shader_ballot" %1 = OpExtInstImport "SPV_AMD_shader_ballot" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "func" OpExecutionMode %2 OriginUpperLeft %void = OpTypeVoid %4 = OpTypeFunction %void %uint = OpTypeInt 32 0 %ulong = OpTypeInt 64 0 %ulong_0 = OpConstant %ulong 0 %2 = OpFunction %void None %4 %8 = OpLabel %9 = OpExtInst %uint %1 MbcntAMD %ulong_0 OpReturn OpFunctionEnd )"; // Set the version to 1.1 and make sure it is upgraded to 1.3. SetTargetEnv(SPV_ENV_UNIVERSAL_1_1); SetDisassembleOptions(0); auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* skip_validation = */ false); EXPECT_EQ(Pass::Status::SuccessWithChange, std::get<1>(result)); const std::string& output = std::get<0>(result); EXPECT_THAT(output, HasSubstr("Version: 1.3")); } TEST_F(AmdExtToKhrTest, SetVersion1) { const std::string text = R"( OpCapability Shader OpCapability Int64 OpExtension "SPV_AMD_shader_ballot" %1 = OpExtInstImport "SPV_AMD_shader_ballot" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "func" OpExecutionMode %2 OriginUpperLeft %void = OpTypeVoid %4 = OpTypeFunction %void %uint = OpTypeInt 32 0 %ulong = OpTypeInt 64 0 %ulong_0 = OpConstant %ulong 0 %2 = OpFunction %void None %4 %8 = OpLabel %9 = OpExtInst %uint %1 MbcntAMD %ulong_0 OpReturn OpFunctionEnd )"; // Set the version to 1.4 and make sure it is stays the same. SetTargetEnv(SPV_ENV_UNIVERSAL_1_4); SetDisassembleOptions(0); auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* skip_validation = */ false); EXPECT_EQ(Pass::Status::SuccessWithChange, std::get<1>(result)); const std::string& output = std::get<0>(result); EXPECT_THAT(output, HasSubstr("Version: 1.4")); } TEST_F(AmdExtToKhrTest, TimeAMD) { const std::string text = R"( OpCapability Shader OpCapability Int64 OpExtension "SPV_AMD_gcn_shader" ; CHECK-NOT: OpExtension "SPV_AMD_gcn_shader" ; CHECK: OpExtension "SPV_KHR_shader_clock" %1 = OpExtInstImport "GLSL.std.450" %2 = OpExtInstImport "SPV_AMD_gcn_shader" ; CHECK-NOT: OpExtInstImport "SPV_AMD_gcn_shader" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpSourceExtension "GL_AMD_gcn_shader" OpSourceExtension "GL_ARB_gpu_shader_int64" OpName %main "main" OpName %time "time" %void = OpTypeVoid %6 = OpTypeFunction %void %ulong = OpTypeInt 64 0 %_ptr_Function_ulong = OpTypePointer Function %ulong %main = OpFunction %void None %6 %9 = OpLabel %time = OpVariable %_ptr_Function_ulong Function ; CHECK: [[uint:%\w+]] = OpTypeInt 32 0 ; CHECK: [[uint_3:%\w+]] = OpConstant [[uint]] 3 %10 = OpExtInst %ulong %2 TimeAMD ; CHECK: %10 = OpReadClockKHR %ulong [[uint_3]] OpStore %time %10 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/analyze_live_input_test.cpp000066400000000000000000001015421475742701700257610ustar00rootroot00000000000000// Copyright (c) 2022 The Khronos Group Inc. // Copyright (c) 2022 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using AnalyzeLiveInputTest = PassTest<::testing::Test>; TEST_F(AnalyzeLiveInputTest, FragMultipleLocations) { // Should report locations {2, 5} // // #version 450 // // layout(location = 2) in Vertex // { // vec4 color0; // vec4 color1; // vec4 color2[3]; // } iVert; // // layout(location = 0) out vec4 oFragColor; // // void main() // { // oFragColor = iVert.color0 + iVert.color2[1]; // } const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %oFragColor %iVert OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %oFragColor "oFragColor" OpName %Vertex "Vertex" OpMemberName %Vertex 0 "color0" OpMemberName %Vertex 1 "color1" OpMemberName %Vertex 2 "color2" OpName %iVert "iVert" OpDecorate %oFragColor Location 0 OpDecorate %Vertex Block OpDecorate %iVert Location 2 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %oFragColor = OpVariable %_ptr_Output_v4float Output %uint = OpTypeInt 32 0 %uint_3 = OpConstant %uint 3 %_arr_v4float_uint_3 = OpTypeArray %v4float %uint_3 %Vertex = OpTypeStruct %v4float %v4float %_arr_v4float_uint_3 %_ptr_Input_Vertex = OpTypePointer Input %Vertex %iVert = OpVariable %_ptr_Input_Vertex Input %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Input_v4float = OpTypePointer Input %v4float %int_2 = OpConstant %int 2 %int_1 = OpConstant %int 1 %main = OpFunction %void None %3 %5 = OpLabel %19 = OpAccessChain %_ptr_Input_v4float %iVert %int_0 %20 = OpLoad %v4float %19 %23 = OpAccessChain %_ptr_Input_v4float %iVert %int_2 %int_1 %24 = OpLoad %v4float %23 %25 = OpFAdd %v4float %20 %24 OpStore %oFragColor %25 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); std::unordered_set live_inputs; std::unordered_set live_builtins; auto result = SinglePassRunToBinary( text, true, &live_inputs, &live_builtins); auto itr0 = live_inputs.find(0); auto itr1 = live_inputs.find(1); auto itr2 = live_inputs.find(2); auto itr3 = live_inputs.find(3); auto itr4 = live_inputs.find(4); auto itr5 = live_inputs.find(5); auto itr6 = live_inputs.find(6); // Expect live_inputs == {2, 5} EXPECT_TRUE(itr0 == live_inputs.end()); EXPECT_TRUE(itr1 == live_inputs.end()); EXPECT_TRUE(itr2 != live_inputs.end()); EXPECT_TRUE(itr3 == live_inputs.end()); EXPECT_TRUE(itr4 == live_inputs.end()); EXPECT_TRUE(itr5 != live_inputs.end()); EXPECT_TRUE(itr6 == live_inputs.end()); } TEST_F(AnalyzeLiveInputTest, FragMatrix) { // Should report locations {2, 8, 9, 10, 11} // // #version 450 // // uniform ui_name { // int i; // } ui_inst; // // layout(location = 2) in Vertex // { // vec4 color0; // vec4 color1; // mat4 color2; // mat4 color3; // mat4 color4; // } iVert; // // // Output variable for the color // layout(location = 0) out vec4 oFragColor; // // void main() // { // oFragColor = iVert.color0 + iVert.color3[ui_inst.i]; // } const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %oFragColor %iVert %ui_inst OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %oFragColor "oFragColor" OpName %Vertex "Vertex" OpMemberName %Vertex 0 "color0" OpMemberName %Vertex 1 "color1" OpMemberName %Vertex 2 "color2" OpMemberName %Vertex 3 "color3" OpMemberName %Vertex 4 "color4" OpName %iVert "iVert" OpName %ui_name "ui_name" OpMemberName %ui_name 0 "i" OpName %ui_inst "ui_inst" OpDecorate %oFragColor Location 0 OpDecorate %Vertex Block OpDecorate %iVert Location 2 OpMemberDecorate %ui_name 0 Offset 0 OpDecorate %ui_name Block OpDecorate %ui_inst DescriptorSet 0 OpDecorate %ui_inst Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %oFragColor = OpVariable %_ptr_Output_v4float Output %mat4v4float = OpTypeMatrix %v4float 4 %Vertex = OpTypeStruct %v4float %v4float %mat4v4float %mat4v4float %mat4v4float %_ptr_Input_Vertex = OpTypePointer Input %Vertex %iVert = OpVariable %_ptr_Input_Vertex Input %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Input_v4float = OpTypePointer Input %v4float %int_3 = OpConstant %int 3 %ui_name = OpTypeStruct %int %_ptr_Uniform_ui_name = OpTypePointer Uniform %ui_name %ui_inst = OpVariable %_ptr_Uniform_ui_name Uniform %_ptr_Uniform_int = OpTypePointer Uniform %int %main = OpFunction %void None %3 %5 = OpLabel %17 = OpAccessChain %_ptr_Input_v4float %iVert %int_0 %18 = OpLoad %v4float %17 %24 = OpAccessChain %_ptr_Uniform_int %ui_inst %int_0 %25 = OpLoad %int %24 %26 = OpAccessChain %_ptr_Input_v4float %iVert %int_3 %25 %27 = OpLoad %v4float %26 %28 = OpFAdd %v4float %18 %27 OpStore %oFragColor %28 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); std::unordered_set live_inputs; std::unordered_set live_builtins; auto result = SinglePassRunToBinary( text, true, &live_inputs, &live_builtins); auto itr0 = live_inputs.find(0); auto itr1 = live_inputs.find(1); auto itr2 = live_inputs.find(2); auto itr3 = live_inputs.find(3); auto itr4 = live_inputs.find(4); auto itr5 = live_inputs.find(5); auto itr6 = live_inputs.find(6); auto itr7 = live_inputs.find(7); auto itr8 = live_inputs.find(8); auto itr9 = live_inputs.find(9); auto itr10 = live_inputs.find(10); auto itr11 = live_inputs.find(11); auto itr12 = live_inputs.find(12); auto itr13 = live_inputs.find(13); auto itr14 = live_inputs.find(14); auto itr15 = live_inputs.find(15); // Expect live_inputs == {2, 8, 9, 10, 11} EXPECT_TRUE(itr0 == live_inputs.end()); EXPECT_TRUE(itr1 == live_inputs.end()); EXPECT_TRUE(itr2 != live_inputs.end()); EXPECT_TRUE(itr3 == live_inputs.end()); EXPECT_TRUE(itr4 == live_inputs.end()); EXPECT_TRUE(itr5 == live_inputs.end()); EXPECT_TRUE(itr6 == live_inputs.end()); EXPECT_TRUE(itr7 == live_inputs.end()); EXPECT_TRUE(itr8 != live_inputs.end()); EXPECT_TRUE(itr9 != live_inputs.end()); EXPECT_TRUE(itr10 != live_inputs.end()); EXPECT_TRUE(itr11 != live_inputs.end()); EXPECT_TRUE(itr12 == live_inputs.end()); EXPECT_TRUE(itr13 == live_inputs.end()); EXPECT_TRUE(itr14 == live_inputs.end()); EXPECT_TRUE(itr15 == live_inputs.end()); } TEST_F(AnalyzeLiveInputTest, FragMemberLocs) { // Should report location {1} // // #version 450 // // in Vertex // { // layout (location = 1) vec4 Cd; // layout (location = 0) vec2 uv; // } iVert; // // layout (location = 0) out vec4 fragColor; // // void main() // { // vec4 color = vec4(iVert.Cd); // fragColor = color; // } const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %iVert %fragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %color "color" OpName %Vertex "Vertex" OpMemberName %Vertex 0 "Cd" OpMemberName %Vertex 1 "uv" OpName %iVert "iVert" OpName %fragColor "fragColor" OpMemberDecorate %Vertex 0 Location 1 OpMemberDecorate %Vertex 1 Location 0 OpDecorate %Vertex Block OpDecorate %fragColor Location 0 OpDecorate %_struct_27 Block OpMemberDecorate %_struct_27 0 Location 1 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %v2float = OpTypeVector %float 2 %Vertex = OpTypeStruct %v4float %v2float %_ptr_Input_Vertex = OpTypePointer Input %Vertex %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %fragColor = OpVariable %_ptr_Output_v4float Output %_struct_27 = OpTypeStruct %v4float %_ptr_Input__struct_27 = OpTypePointer Input %_struct_27 %iVert = OpVariable %_ptr_Input__struct_27 Input %main = OpFunction %void None %3 %5 = OpLabel %color = OpVariable %_ptr_Function_v4float Function %17 = OpAccessChain %_ptr_Input_v4float %iVert %int_0 %18 = OpLoad %v4float %17 %19 = OpCompositeExtract %float %18 0 %20 = OpCompositeExtract %float %18 1 %21 = OpCompositeExtract %float %18 2 %22 = OpCompositeExtract %float %18 3 %23 = OpCompositeConstruct %v4float %19 %20 %21 %22 OpStore %color %23 %26 = OpLoad %v4float %color OpStore %fragColor %26 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); std::unordered_set live_inputs; std::unordered_set live_builtins; auto result = SinglePassRunToBinary( text, true, &live_inputs, &live_builtins); auto itr0 = live_inputs.find(0); auto itr1 = live_inputs.find(1); // Expect live_inputs == {2, 5} EXPECT_TRUE(itr0 == live_inputs.end()); EXPECT_TRUE(itr1 != live_inputs.end()); } TEST_F(AnalyzeLiveInputTest, ArrayedInput) { // Tests handling of arrayed input seen in Tesc, Tese and Geom shaders. // // Should report location {1, 10}. // // #version 450 // // layout (vertices = 4) out; // // layout (location = 1) in Vertex // { // vec4 p; // vec3 n; // vec4 f[100]; // } iVert[]; // // layout (location = 0) out vec4 position[4]; // // void main() // { // vec4 pos = iVert[gl_InvocationID].p * // iVert[gl_InvocationID].f[7]; // position[gl_InvocationID] = pos; // } const std::string text = R"( OpCapability Tessellation %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %main "main" %iVert %gl_InvocationID %position OpExecutionMode %main OutputVertices 4 OpSource GLSL 450 OpName %main "main" OpName %Vertex "Vertex" OpMemberName %Vertex 0 "p" OpMemberName %Vertex 1 "n" OpMemberName %Vertex 2 "f" OpName %iVert "iVert" OpName %gl_InvocationID "gl_InvocationID" OpName %position "position" OpDecorate %Vertex Block OpDecorate %iVert Location 1 OpDecorate %gl_InvocationID BuiltIn InvocationId OpDecorate %position Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %v3float = OpTypeVector %float 3 %uint = OpTypeInt 32 0 %uint_100 = OpConstant %uint 100 %_arr_v4float_uint_100 = OpTypeArray %v4float %uint_100 %Vertex = OpTypeStruct %v4float %v3float %_arr_v4float_uint_100 %uint_32 = OpConstant %uint 32 %_arr_Vertex_uint_32 = OpTypeArray %Vertex %uint_32 %_ptr_Input__arr_Vertex_uint_32 = OpTypePointer Input %_arr_Vertex_uint_32 %iVert = OpVariable %_ptr_Input__arr_Vertex_uint_32 Input %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %gl_InvocationID = OpVariable %_ptr_Input_int Input %int_0 = OpConstant %int 0 %_ptr_Input_v4float = OpTypePointer Input %v4float %int_2 = OpConstant %int 2 %int_7 = OpConstant %int 7 %uint_4 = OpConstant %uint 4 %_arr_v4float_uint_4 = OpTypeArray %v4float %uint_4 %_ptr_Output__arr_v4float_uint_4 = OpTypePointer Output %_arr_v4float_uint_4 %position = OpVariable %_ptr_Output__arr_v4float_uint_4 Output %_ptr_Output_v4float = OpTypePointer Output %v4float %main = OpFunction %void None %3 %5 = OpLabel %22 = OpLoad %int %gl_InvocationID %25 = OpAccessChain %_ptr_Input_v4float %iVert %22 %int_0 %26 = OpLoad %v4float %25 %30 = OpAccessChain %_ptr_Input_v4float %iVert %22 %int_2 %int_7 %31 = OpLoad %v4float %30 %32 = OpFMul %v4float %26 %31 %40 = OpAccessChain %_ptr_Output_v4float %position %22 OpStore %40 %32 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); std::unordered_set live_inputs; std::unordered_set live_builtins; auto result = SinglePassRunToBinary( text, true, &live_inputs, &live_builtins); auto itr0 = live_inputs.find(0); auto itr1 = live_inputs.find(1); auto itr2 = live_inputs.find(2); auto itr3 = live_inputs.find(3); auto itr4 = live_inputs.find(4); auto itr5 = live_inputs.find(5); auto itr6 = live_inputs.find(6); auto itr7 = live_inputs.find(7); auto itr8 = live_inputs.find(8); auto itr9 = live_inputs.find(9); auto itr10 = live_inputs.find(10); auto itr11 = live_inputs.find(11); // Expect live_inputs == {1, 10} EXPECT_TRUE(itr0 == live_inputs.end()); EXPECT_TRUE(itr1 != live_inputs.end()); EXPECT_TRUE(itr2 == live_inputs.end()); EXPECT_TRUE(itr3 == live_inputs.end()); EXPECT_TRUE(itr4 == live_inputs.end()); EXPECT_TRUE(itr5 == live_inputs.end()); EXPECT_TRUE(itr6 == live_inputs.end()); EXPECT_TRUE(itr7 == live_inputs.end()); EXPECT_TRUE(itr8 == live_inputs.end()); EXPECT_TRUE(itr9 == live_inputs.end()); EXPECT_TRUE(itr10 != live_inputs.end()); EXPECT_TRUE(itr11 == live_inputs.end()); } TEST_F(AnalyzeLiveInputTest, ArrayedInputMemberLocs) { // Tests handling of member locs with arrayed input seen in Tesc, Tese // and Geom shaders. // // Should report location {1, 12}. // // #version 450 // // layout (vertices = 4) out; // // in Vertex // { // layout (location = 1) vec4 p; // layout (location = 3) vec3 n; // layout (location = 5) vec4 f[100]; // } iVert[]; // // layout (location = 0) out vec4 position[4]; // // void main() // { // vec4 pos = iVert[gl_InvocationID].p * // iVert[gl_InvocationID].f[7]; // position[gl_InvocationID] = pos; // } const std::string text = R"( OpCapability Tessellation %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %main "main" %iVert %gl_InvocationID %position OpExecutionMode %main OutputVertices 4 OpSource GLSL 450 OpName %main "main" OpName %Vertex "Vertex" OpMemberName %Vertex 0 "p" OpMemberName %Vertex 1 "n" OpMemberName %Vertex 2 "f" OpName %iVert "iVert" OpName %gl_InvocationID "gl_InvocationID" OpName %position "position" OpMemberDecorate %Vertex 0 Location 1 OpMemberDecorate %Vertex 1 Location 3 OpMemberDecorate %Vertex 2 Location 5 OpDecorate %Vertex Block OpDecorate %gl_InvocationID BuiltIn InvocationId OpDecorate %position Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %v3float = OpTypeVector %float 3 %uint = OpTypeInt 32 0 %uint_100 = OpConstant %uint 100 %_arr_v4float_uint_100 = OpTypeArray %v4float %uint_100 %Vertex = OpTypeStruct %v4float %v3float %_arr_v4float_uint_100 %uint_32 = OpConstant %uint 32 %_arr_Vertex_uint_32 = OpTypeArray %Vertex %uint_32 %_ptr_Input__arr_Vertex_uint_32 = OpTypePointer Input %_arr_Vertex_uint_32 %iVert = OpVariable %_ptr_Input__arr_Vertex_uint_32 Input %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %gl_InvocationID = OpVariable %_ptr_Input_int Input %int_0 = OpConstant %int 0 %_ptr_Input_v4float = OpTypePointer Input %v4float %int_2 = OpConstant %int 2 %int_7 = OpConstant %int 7 %uint_4 = OpConstant %uint 4 %_arr_v4float_uint_4 = OpTypeArray %v4float %uint_4 %_ptr_Output__arr_v4float_uint_4 = OpTypePointer Output %_arr_v4float_uint_4 %position = OpVariable %_ptr_Output__arr_v4float_uint_4 Output %_ptr_Output_v4float = OpTypePointer Output %v4float %main = OpFunction %void None %3 %5 = OpLabel %22 = OpLoad %int %gl_InvocationID %25 = OpAccessChain %_ptr_Input_v4float %iVert %22 %int_0 %26 = OpLoad %v4float %25 %30 = OpAccessChain %_ptr_Input_v4float %iVert %22 %int_2 %int_7 %31 = OpLoad %v4float %30 %32 = OpFMul %v4float %26 %31 %40 = OpAccessChain %_ptr_Output_v4float %position %22 OpStore %40 %32 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); std::unordered_set live_inputs; std::unordered_set live_builtins; auto result = SinglePassRunToBinary( text, true, &live_inputs, &live_builtins); auto itr0 = live_inputs.find(0); auto itr1 = live_inputs.find(1); auto itr2 = live_inputs.find(2); auto itr3 = live_inputs.find(3); auto itr4 = live_inputs.find(4); auto itr5 = live_inputs.find(5); auto itr6 = live_inputs.find(6); auto itr7 = live_inputs.find(7); auto itr8 = live_inputs.find(8); auto itr9 = live_inputs.find(9); auto itr10 = live_inputs.find(10); auto itr11 = live_inputs.find(11); auto itr12 = live_inputs.find(12); auto itr13 = live_inputs.find(13); // Expect live_inputs == {1, 12} EXPECT_TRUE(itr0 == live_inputs.end()); EXPECT_TRUE(itr1 != live_inputs.end()); EXPECT_TRUE(itr2 == live_inputs.end()); EXPECT_TRUE(itr3 == live_inputs.end()); EXPECT_TRUE(itr4 == live_inputs.end()); EXPECT_TRUE(itr5 == live_inputs.end()); EXPECT_TRUE(itr6 == live_inputs.end()); EXPECT_TRUE(itr7 == live_inputs.end()); EXPECT_TRUE(itr8 == live_inputs.end()); EXPECT_TRUE(itr9 == live_inputs.end()); EXPECT_TRUE(itr10 == live_inputs.end()); EXPECT_TRUE(itr11 == live_inputs.end()); EXPECT_TRUE(itr12 != live_inputs.end()); EXPECT_TRUE(itr13 == live_inputs.end()); } TEST_F(AnalyzeLiveInputTest, Builtins) { // Tests handling of builtin input seen in Tesc, Tese and Geom shaders. // // Should report builtin gl_PointSize only. // // #version 460 // // layout(triangle_strip, max_vertices = 3) out; // layout(triangles) in; // // void main() // { // for (int i = 0; i < 3; i++) // { // gl_Position = gl_in[i].gl_Position; // gl_PointSize = gl_in[i].gl_PointSize; // // EmitVertex(); // } // // EndPrimitive(); // } const std::string text = R"( OpCapability Geometry OpCapability GeometryPointSize %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Geometry %main "main" %_ %gl_in OpExecutionMode %main Triangles OpExecutionMode %main Invocations 1 OpExecutionMode %main OutputTriangleStrip OpExecutionMode %main OutputVertices 3 OpSource GLSL 460 OpName %main "main" OpName %i "i" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpMemberName %gl_PerVertex 1 "gl_PointSize" OpMemberName %gl_PerVertex 2 "gl_ClipDistance" OpMemberName %gl_PerVertex 3 "gl_CullDistance" OpName %_ "" OpName %gl_PerVertex_0 "gl_PerVertex" OpMemberName %gl_PerVertex_0 0 "gl_Position" OpMemberName %gl_PerVertex_0 1 "gl_PointSize" OpMemberName %gl_PerVertex_0 2 "gl_ClipDistance" OpMemberName %gl_PerVertex_0 3 "gl_CullDistance" OpName %gl_in "gl_in" OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex 3 BuiltIn CullDistance OpDecorate %gl_PerVertex Block OpMemberDecorate %gl_PerVertex_0 0 BuiltIn Position OpMemberDecorate %gl_PerVertex_0 1 BuiltIn PointSize OpDecorate %gl_PerVertex_0 Block %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_3 = OpConstant %int 3 %bool = OpTypeBool %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex %_ = OpVariable %_ptr_Output_gl_PerVertex Output %gl_PerVertex_0 = OpTypeStruct %v4float %float %uint_3 = OpConstant %uint 3 %_arr_gl_PerVertex_0_uint_3 = OpTypeArray %gl_PerVertex_0 %uint_3 %_ptr_Input__arr_gl_PerVertex_0_uint_3 = OpTypePointer Input %_arr_gl_PerVertex_0_uint_3 %gl_in = OpVariable %_ptr_Input__arr_gl_PerVertex_0_uint_3 Input %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %int_1 = OpConstant %int 1 %_ptr_Input_float = OpTypePointer Input %float %_ptr_Output_float = OpTypePointer Output %float %main = OpFunction %void None %3 %5 = OpLabel %i = OpVariable %_ptr_Function_int Function OpStore %i %int_0 OpBranch %10 %10 = OpLabel OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %15 = OpLoad %int %i %18 = OpSLessThan %bool %15 %int_3 OpBranchConditional %18 %11 %12 %11 = OpLabel %32 = OpLoad %int %i %34 = OpAccessChain %_ptr_Input_v4float %gl_in %32 %int_0 %35 = OpLoad %v4float %34 %37 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %37 %35 %39 = OpLoad %int %i %41 = OpAccessChain %_ptr_Input_float %gl_in %39 %int_1 %42 = OpLoad %float %41 %44 = OpAccessChain %_ptr_Output_float %_ %int_1 OpStore %44 %42 OpEmitVertex OpBranch %13 %13 = OpLabel %45 = OpLoad %int %i %46 = OpIAdd %int %45 %int_1 OpStore %i %46 OpBranch %10 %12 = OpLabel OpEndPrimitive OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); std::unordered_set live_inputs; std::unordered_set live_builtins; auto result = SinglePassRunToBinary( text, true, &live_inputs, &live_builtins); auto itr0 = live_builtins.find((uint32_t)spv::BuiltIn::PointSize); auto itr1 = live_builtins.find((uint32_t)spv::BuiltIn::ClipDistance); auto itr2 = live_builtins.find((uint32_t)spv::BuiltIn::CullDistance); // Expect live_builtins == { spv::BuiltIn::PointSize } EXPECT_TRUE(itr0 != live_builtins.end()); EXPECT_TRUE(itr1 == live_builtins.end()); EXPECT_TRUE(itr2 == live_builtins.end()); } TEST_F(AnalyzeLiveInputTest, ArrayedInputPatchLocs) { // Tests handling of locs with arrayed input patch seen in Tese // // Should report location {3}. // // #version 450 core // // layout(triangles, ccw) in; // // layout(fractional_odd_spacing) in; // // layout(point_mode) in; // // layout(location=2) patch in float patchIn1[2]; // // void main() // { // vec4 p = gl_in[1].gl_Position; // gl_Position = p * patchIn1[1]; // } const std::string text = R"( OpCapability Tessellation %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint TessellationEvaluation %main "main" %gl_in %_ %patchIn1 OpExecutionMode %main Triangles OpExecutionMode %main SpacingFractionalOdd OpExecutionMode %main VertexOrderCcw OpExecutionMode %main PointMode OpSource GLSL 450 OpName %main "main" OpName %p "p" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpName %gl_in "gl_in" OpName %gl_PerVertex_0 "gl_PerVertex" OpMemberName %gl_PerVertex_0 0 "gl_Position" OpName %_ "" OpName %patchIn1 "patchIn1" OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpDecorate %gl_PerVertex Block OpMemberDecorate %gl_PerVertex_0 0 BuiltIn Position OpDecorate %gl_PerVertex_0 Block OpDecorate %patchIn1 Patch OpDecorate %patchIn1 Location 2 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %uint_32 = OpConstant %uint 32 %_arr_gl_PerVertex_uint_32 = OpTypeArray %gl_PerVertex %uint_32 %_ptr_Input__arr_gl_PerVertex_uint_32 = OpTypePointer Input %_arr_gl_PerVertex_uint_32 %gl_in = OpVariable %_ptr_Input__arr_gl_PerVertex_uint_32 Input %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %int_0 = OpConstant %int 0 %_ptr_Input_v4float = OpTypePointer Input %v4float %gl_PerVertex_0 = OpTypeStruct %v4float %_ptr_Output_gl_PerVertex_0 = OpTypePointer Output %gl_PerVertex_0 %_ = OpVariable %_ptr_Output_gl_PerVertex_0 Output %uint_2 = OpConstant %uint 2 %_arr_float_uint_2 = OpTypeArray %float %uint_2 %_ptr_Input__arr_float_uint_2 = OpTypePointer Input %_arr_float_uint_2 %patchIn1 = OpVariable %_ptr_Input__arr_float_uint_2 Input %_ptr_Input_float = OpTypePointer Input %float %_ptr_Output_v4float = OpTypePointer Output %v4float %main = OpFunction %void None %3 %5 = OpLabel %p = OpVariable %_ptr_Function_v4float Function %22 = OpAccessChain %_ptr_Input_v4float %gl_in %int_1 %int_0 %23 = OpLoad %v4float %22 OpStore %p %23 %27 = OpLoad %v4float %p %33 = OpAccessChain %_ptr_Input_float %patchIn1 %int_1 %34 = OpLoad %float %33 %35 = OpVectorTimesScalar %v4float %27 %34 %37 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %37 %35 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); std::unordered_set live_inputs; std::unordered_set live_builtins; auto result = SinglePassRunToBinary( text, true, &live_inputs, &live_builtins); auto itr0 = live_inputs.find(0); auto itr1 = live_inputs.find(1); auto itr2 = live_inputs.find(2); auto itr3 = live_inputs.find(3); // Expect live_inputs == {3} EXPECT_TRUE(itr0 == live_inputs.end()); EXPECT_TRUE(itr1 == live_inputs.end()); EXPECT_TRUE(itr2 == live_inputs.end()); EXPECT_TRUE(itr3 != live_inputs.end()); } TEST_F(AnalyzeLiveInputTest, FragMultipleLocationsF16) { // Should report locations {2, 5} // // #version 450 // // layout(location = 2) in Vertex // { // f16vec4 color0; // f16vec4 color1; // f16vec4 color2[3]; // } iVert; // // layout(location = 0) out f16vec4 oFragColor; // // void main() // { // oFragColor = iVert.color0 + iVert.color2[1]; // } const std::string text = R"( OpCapability Shader OpCapability Float16 OpCapability StorageInputOutput16 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %oFragColor %iVert OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %oFragColor "oFragColor" OpName %Vertex "Vertex" OpMemberName %Vertex 0 "color0" OpMemberName %Vertex 1 "color1" OpMemberName %Vertex 2 "color2" OpName %iVert "iVert" OpDecorate %oFragColor Location 0 OpDecorate %Vertex Block OpDecorate %iVert Location 2 %void = OpTypeVoid %3 = OpTypeFunction %void %half = OpTypeFloat 16 %v4half = OpTypeVector %half 4 %_ptr_Output_v4half = OpTypePointer Output %v4half %oFragColor = OpVariable %_ptr_Output_v4half Output %uint = OpTypeInt 32 0 %uint_3 = OpConstant %uint 3 %_arr_v4half_uint_3 = OpTypeArray %v4half %uint_3 %Vertex = OpTypeStruct %v4half %v4half %_arr_v4half_uint_3 %_ptr_Input_Vertex = OpTypePointer Input %Vertex %iVert = OpVariable %_ptr_Input_Vertex Input %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Input_v4half = OpTypePointer Input %v4half %int_2 = OpConstant %int 2 %int_1 = OpConstant %int 1 %main = OpFunction %void None %3 %5 = OpLabel %19 = OpAccessChain %_ptr_Input_v4half %iVert %int_0 %20 = OpLoad %v4half %19 %23 = OpAccessChain %_ptr_Input_v4half %iVert %int_2 %int_1 %24 = OpLoad %v4half %23 %25 = OpFAdd %v4half %20 %24 OpStore %oFragColor %25 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); std::unordered_set live_inputs; std::unordered_set live_builtins; auto result = SinglePassRunToBinary( text, true, &live_inputs, &live_builtins); auto itr0 = live_inputs.find(0); auto itr1 = live_inputs.find(1); auto itr2 = live_inputs.find(2); auto itr3 = live_inputs.find(3); auto itr4 = live_inputs.find(4); auto itr5 = live_inputs.find(5); auto itr6 = live_inputs.find(6); // Expect live_inputs == {2, 5} EXPECT_TRUE(itr0 == live_inputs.end()); EXPECT_TRUE(itr1 == live_inputs.end()); EXPECT_TRUE(itr2 != live_inputs.end()); EXPECT_TRUE(itr3 == live_inputs.end()); EXPECT_TRUE(itr4 == live_inputs.end()); EXPECT_TRUE(itr5 != live_inputs.end()); EXPECT_TRUE(itr6 == live_inputs.end()); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/assembly_builder.h000066400000000000000000000237271475742701700240230ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef TEST_OPT_ASSEMBLY_BUILDER_H_ #define TEST_OPT_ASSEMBLY_BUILDER_H_ #include #include #include #include #include #include namespace spvtools { namespace opt { // A simple SPIR-V assembly code builder for test uses. It builds an SPIR-V // assembly module from vectors of assembly strings. It allows users to add // instructions to the main function and the type-constants-globals section // directly. It relies on OpName instructions and friendly-name disassembling // to keep the ID names unchanged after assembling. // // An assembly module is divided into several sections, matching with the // SPIR-V Logical Layout: // Global Preamble: // OpCapability instructions; // OpExtension instructions and OpExtInstImport instructions; // OpMemoryModel instruction; // OpEntryPoint and OpExecutionMode instruction; // OpString, OpSourceExtension, OpSource and OpSourceContinued instructions. // Names: // OpName instructions. // Annotations: // OpDecorate, OpMemberDecorate, OpGroupDecorate, OpGroupMemberDecorate and // OpDecorationGroup. // Types, Constants and Global variables: // Types, constants and global variables declaration instructions. // Main Function: // Main function instructions. // Main Function Postamble: // The return and function end instructions. // // The assembly code is built by concatenating all the strings in the above // sections. // // Users define the contents in section // and
. The section is to hold the names for IDs to // keep them unchanged before and after assembling. All defined IDs to be added // to this code builder will be assigned with a global name through OpName // instruction. The name is extracted from the definition instruction. // E.g. adding instruction: %var_a = OpConstant %int 2, will also add an // instruction: OpName %var_a, "var_a". // // Note that the name must not be used on more than one defined IDs and // friendly-name disassembling must be enabled so that OpName instructions will // be respected. class AssemblyBuilder { // The base ID value for spec constants. static const uint32_t SPEC_ID_BASE = 200; public: // Initialize a minimal SPIR-V assembly code as the template. The minimal // module contains an empty main function and some predefined names for the // main function. AssemblyBuilder() : spec_id_counter_(SPEC_ID_BASE), global_preamble_({ // clang-format off "OpCapability Shader", "OpCapability Float64", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Vertex %main \"main\"", // clang-format on }), names_(), annotations_(), types_consts_globals_(), main_func_(), main_func_postamble_({ "OpReturn", "OpFunctionEnd", }) { AppendTypesConstantsGlobals({ "%void = OpTypeVoid", "%main_func_type = OpTypeFunction %void", }); AppendInMain({ "%main = OpFunction %void None %main_func_type", "%main_func_entry_block = OpLabel", }); } // Appends OpName instructions to this builder. Instruction strings that do // not start with 'OpName ' will be skipped. Returns the references of this // assembly builder. AssemblyBuilder& AppendNames(const std::vector& vec_asm_code) { for (auto& inst_str : vec_asm_code) { if (inst_str.find("OpName ") == 0) { names_.push_back(inst_str); } } return *this; } // Appends instructions to the types-constants-globals section and returns // the reference of this assembly builder. IDs defined in the given code will // be added to the Names section and then be registered with OpName // instruction. Corresponding decoration instruction will be added for spec // constants defined with opcode: 'OpSpecConstant'. AssemblyBuilder& AppendTypesConstantsGlobals( const std::vector& vec_asm_code) { AddNamesForResultIDsIn(vec_asm_code); // Check spec constants defined with OpSpecConstant. for (auto& inst_str : vec_asm_code) { if (inst_str.find("= OpSpecConstant ") != std::string::npos || inst_str.find("= OpSpecConstantTrue ") != std::string::npos || inst_str.find("= OpSpecConstantFalse ") != std::string::npos) { AddSpecIDFor(GetResultIDName(inst_str)); } } types_consts_globals_.insert(types_consts_globals_.end(), vec_asm_code.begin(), vec_asm_code.end()); return *this; } // Appends instructions to the main function block, which is already labelled // with "main_func_entry_block". Returns the reference of this assembly // builder. IDs defined in the given code will be added to the Names section // and then be registered with OpName instruction. AssemblyBuilder& AppendInMain(const std::vector& vec_asm_code) { AddNamesForResultIDsIn(vec_asm_code); main_func_.insert(main_func_.end(), vec_asm_code.begin(), vec_asm_code.end()); return *this; } // Appends annotation instructions to the annotation section, and returns the // reference of this assembly builder. AssemblyBuilder& AppendAnnotations( const std::vector& vec_annotations) { annotations_.insert(annotations_.end(), vec_annotations.begin(), vec_annotations.end()); return *this; } // Pre-pends string to the preamble of the module. Useful for EFFCEE checks. AssemblyBuilder& PrependPreamble(const std::vector& preamble) { preamble_.insert(preamble_.end(), preamble.begin(), preamble.end()); return *this; } // Get the SPIR-V assembly code as string. std::string GetCode() const { std::ostringstream ss; for (const auto& line : preamble_) { ss << line << std::endl; } for (const auto& line : global_preamble_) { ss << line << std::endl; } for (const auto& line : names_) { ss << line << std::endl; } for (const auto& line : annotations_) { ss << line << std::endl; } for (const auto& line : types_consts_globals_) { ss << line << std::endl; } for (const auto& line : main_func_) { ss << line << std::endl; } for (const auto& line : main_func_postamble_) { ss << line << std::endl; } return ss.str(); } private: // Adds a given name to the Name section with OpName. If the given name has // been added before, does nothing. void AddOpNameIfNotExist(const std::string& id_name) { if (!used_names_.count(id_name)) { std::stringstream opname_inst; opname_inst << "OpName " << "%" << id_name << " \"" << id_name << "\""; names_.emplace_back(opname_inst.str()); used_names_.insert(id_name); } } // Adds the names in a vector of assembly code strings to the Names section. // If a '=' sign is found in an instruction, this instruction will be treated // as an ID defining instruction. The ID name used in the instruction will be // extracted and added to the Names section. void AddNamesForResultIDsIn(const std::vector& vec_asm_code) { for (const auto& line : vec_asm_code) { std::string name = GetResultIDName(line); if (!name.empty()) { AddOpNameIfNotExist(name); } } } // Adds an OpDecorate SpecId instruction for the given ID name. void AddSpecIDFor(const std::string& id_name) { std::stringstream decorate_inst; decorate_inst << "OpDecorate " << "%" << id_name << " SpecId " << spec_id_counter_; spec_id_counter_ += 1; annotations_.emplace_back(decorate_inst.str()); } // Extracts the ID name from a SPIR-V assembly instruction string. If the // instruction is an ID-defining instruction (has result ID), returns the // name of the result ID in string. If the instruction does not have result // ID, returns an empty string. std::string GetResultIDName(const std::string inst_str) { std::string name; if (inst_str.find('=') != std::string::npos) { size_t assign_sign = inst_str.find('='); name = inst_str.substr(0, assign_sign); name.erase(remove_if(name.begin(), name.end(), [](char c) { return c == ' ' || c == '%'; }), name.end()); } return name; } uint32_t spec_id_counter_; // User-defined preamble. std::vector preamble_; // The vector that contains common preambles shared across all test SPIR-V // code. std::vector global_preamble_; // The vector that contains OpName instructions. std::vector names_; // The vector that contains annotation instructions. std::vector annotations_; // The vector that contains the code to declare types, constants and global // variables (aka. the Types-Constants-Globals section). std::vector types_consts_globals_; // The vector that contains the code in main function's entry block. std::vector main_func_; // The vector that contains the postamble of main function body. std::vector main_func_postamble_; // All of the defined variable names. std::unordered_set used_names_; }; } // namespace opt } // namespace spvtools #endif // TEST_OPT_ASSEMBLY_BUILDER_H_ KhronosGroup-SPIRV-Tools-f289d04/test/opt/assembly_builder_test.cpp000066400000000000000000000263041475742701700254070ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "test/opt/assembly_builder.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using AssemblyBuilderTest = PassTest<::testing::Test>; TEST_F(AssemblyBuilderTest, MinimalShader) { AssemblyBuilder builder; std::vector expected = { // clang-format off "OpCapability Shader", "OpCapability Float64", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Vertex %main \"main\"", "OpName %void \"void\"", "OpName %main_func_type \"main_func_type\"", "OpName %main \"main\"", "OpName %main_func_entry_block \"main_func_entry_block\"", "%void = OpTypeVoid", "%main_func_type = OpTypeFunction %void", "%main = OpFunction %void None %main_func_type", "%main_func_entry_block = OpLabel", "OpReturn", "OpFunctionEnd", // clang-format on }; SinglePassRunAndCheck(builder.GetCode(), JoinAllInsts(expected), /* skip_nop = */ false); } TEST_F(AssemblyBuilderTest, ShaderWithConstants) { AssemblyBuilder builder; builder .AppendTypesConstantsGlobals({ // clang-format off "%bool = OpTypeBool", "%_PF_bool = OpTypePointer Function %bool", "%bt = OpConstantTrue %bool", "%bf = OpConstantFalse %bool", "%int = OpTypeInt 32 1", "%_PF_int = OpTypePointer Function %int", "%si = OpConstant %int 1", "%uint = OpTypeInt 32 0", "%_PF_uint = OpTypePointer Function %uint", "%ui = OpConstant %uint 2", "%float = OpTypeFloat 32", "%_PF_float = OpTypePointer Function %float", "%f = OpConstant %float 3.1415", "%double = OpTypeFloat 64", "%_PF_double = OpTypePointer Function %double", "%d = OpConstant %double 3.14159265358979", // clang-format on }) .AppendInMain({ // clang-format off "%btv = OpVariable %_PF_bool Function", "%bfv = OpVariable %_PF_bool Function", "%iv = OpVariable %_PF_int Function", "%uv = OpVariable %_PF_uint Function", "%fv = OpVariable %_PF_float Function", "%dv = OpVariable %_PF_double Function", "OpStore %btv %bt", "OpStore %bfv %bf", "OpStore %iv %si", "OpStore %uv %ui", "OpStore %fv %f", "OpStore %dv %d", // clang-format on }); std::vector expected = { // clang-format off "OpCapability Shader", "OpCapability Float64", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Vertex %main \"main\"", "OpName %void \"void\"", "OpName %main_func_type \"main_func_type\"", "OpName %main \"main\"", "OpName %main_func_entry_block \"main_func_entry_block\"", "OpName %bool \"bool\"", "OpName %_PF_bool \"_PF_bool\"", "OpName %bt \"bt\"", "OpName %bf \"bf\"", "OpName %int \"int\"", "OpName %_PF_int \"_PF_int\"", "OpName %si \"si\"", "OpName %uint \"uint\"", "OpName %_PF_uint \"_PF_uint\"", "OpName %ui \"ui\"", "OpName %float \"float\"", "OpName %_PF_float \"_PF_float\"", "OpName %f \"f\"", "OpName %double \"double\"", "OpName %_PF_double \"_PF_double\"", "OpName %d \"d\"", "OpName %btv \"btv\"", "OpName %bfv \"bfv\"", "OpName %iv \"iv\"", "OpName %uv \"uv\"", "OpName %fv \"fv\"", "OpName %dv \"dv\"", "%void = OpTypeVoid", "%main_func_type = OpTypeFunction %void", "%bool = OpTypeBool", "%_PF_bool = OpTypePointer Function %bool", "%bt = OpConstantTrue %bool", "%bf = OpConstantFalse %bool", "%int = OpTypeInt 32 1", "%_PF_int = OpTypePointer Function %int", "%si = OpConstant %int 1", "%uint = OpTypeInt 32 0", "%_PF_uint = OpTypePointer Function %uint", "%ui = OpConstant %uint 2", "%float = OpTypeFloat 32", "%_PF_float = OpTypePointer Function %float", "%f = OpConstant %float 3.1415", "%double = OpTypeFloat 64", "%_PF_double = OpTypePointer Function %double", "%d = OpConstant %double 3.14159265358979", "%main = OpFunction %void None %main_func_type", "%main_func_entry_block = OpLabel", "%btv = OpVariable %_PF_bool Function", "%bfv = OpVariable %_PF_bool Function", "%iv = OpVariable %_PF_int Function", "%uv = OpVariable %_PF_uint Function", "%fv = OpVariable %_PF_float Function", "%dv = OpVariable %_PF_double Function", "OpStore %btv %bt", "OpStore %bfv %bf", "OpStore %iv %si", "OpStore %uv %ui", "OpStore %fv %f", "OpStore %dv %d", "OpReturn", "OpFunctionEnd", // clang-format on }; SinglePassRunAndCheck(builder.GetCode(), JoinAllInsts(expected), /* skip_nop = */ false); } TEST_F(AssemblyBuilderTest, SpecConstants) { AssemblyBuilder builder; builder.AppendTypesConstantsGlobals({ "%bool = OpTypeBool", "%uint = OpTypeInt 32 0", "%int = OpTypeInt 32 1", "%float = OpTypeFloat 32", "%double = OpTypeFloat 64", "%v2int = OpTypeVector %int 2", "%spec_true = OpSpecConstantTrue %bool", "%spec_false = OpSpecConstantFalse %bool", "%spec_uint = OpSpecConstant %uint 1", "%spec_int = OpSpecConstant %int 1", "%spec_float = OpSpecConstant %float 1.25", "%spec_double = OpSpecConstant %double 1.2345678", // Spec constants defined below should not have SpecID. "%spec_add_op = OpSpecConstantOp %int IAdd %spec_int %spec_int", "%spec_vec = OpSpecConstantComposite %v2int %spec_int %spec_int", "%spec_vec_x = OpSpecConstantOp %int CompositeExtract %spec_vec 0", }); std::vector expected = { // clang-format off "OpCapability Shader", "OpCapability Float64", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Vertex %main \"main\"", "OpName %void \"void\"", "OpName %main_func_type \"main_func_type\"", "OpName %main \"main\"", "OpName %main_func_entry_block \"main_func_entry_block\"", "OpName %bool \"bool\"", "OpName %uint \"uint\"", "OpName %int \"int\"", "OpName %float \"float\"", "OpName %double \"double\"", "OpName %v2int \"v2int\"", "OpName %spec_true \"spec_true\"", "OpName %spec_false \"spec_false\"", "OpName %spec_uint \"spec_uint\"", "OpName %spec_int \"spec_int\"", "OpName %spec_float \"spec_float\"", "OpName %spec_double \"spec_double\"", "OpName %spec_add_op \"spec_add_op\"", "OpName %spec_vec \"spec_vec\"", "OpName %spec_vec_x \"spec_vec_x\"", "OpDecorate %spec_true SpecId 200", "OpDecorate %spec_false SpecId 201", "OpDecorate %spec_uint SpecId 202", "OpDecorate %spec_int SpecId 203", "OpDecorate %spec_float SpecId 204", "OpDecorate %spec_double SpecId 205", "%void = OpTypeVoid", "%main_func_type = OpTypeFunction %void", "%bool = OpTypeBool", "%uint = OpTypeInt 32 0", "%int = OpTypeInt 32 1", "%float = OpTypeFloat 32", "%double = OpTypeFloat 64", "%v2int = OpTypeVector %int 2", "%spec_true = OpSpecConstantTrue %bool", "%spec_false = OpSpecConstantFalse %bool", "%spec_uint = OpSpecConstant %uint 1", "%spec_int = OpSpecConstant %int 1", "%spec_float = OpSpecConstant %float 1.25", "%spec_double = OpSpecConstant %double 1.2345678", "%spec_add_op = OpSpecConstantOp %int IAdd %spec_int %spec_int", "%spec_vec = OpSpecConstantComposite %v2int %spec_int %spec_int", "%spec_vec_x = OpSpecConstantOp %int CompositeExtract %spec_vec 0", "%main = OpFunction %void None %main_func_type", "%main_func_entry_block = OpLabel", "OpReturn", "OpFunctionEnd", // clang-format on }; SinglePassRunAndCheck(builder.GetCode(), JoinAllInsts(expected), /* skip_nop = */ false); } TEST_F(AssemblyBuilderTest, AppendNames) { AssemblyBuilder builder; builder.AppendNames({ "OpName %void \"another_name_for_void\"", "I am an invalid OpName instruction and should not be added", "OpName %main \"another name for main\"", }); std::vector expected = { // clang-format off "OpCapability Shader", "OpCapability Float64", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Vertex %main \"main\"", "OpName %void \"void\"", "OpName %main_func_type \"main_func_type\"", "OpName %main \"main\"", "OpName %main_func_entry_block \"main_func_entry_block\"", "OpName %void \"another_name_for_void\"", "OpName %main \"another name for main\"", "%void = OpTypeVoid", "%main_func_type = OpTypeFunction %void", "%main = OpFunction %void None %main_func_type", "%main_func_entry_block = OpLabel", "OpReturn", "OpFunctionEnd", // clang-format on }; SinglePassRunAndCheck(builder.GetCode(), JoinAllInsts(expected), /* skip_nop = */ false); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/block_merge_test.cpp000066400000000000000000001232231475742701700243310ustar00rootroot00000000000000// Copyright (c) 2017 Valve Corporation // Copyright (c) 2017 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using BlockMergeTest = PassTest<::testing::Test>; TEST_F(BlockMergeTest, Simple) { // Note: SPIR-V hand edited to insert block boundary // between two statements in main. // // #version 140 // // in vec4 BaseColor; // // void main() // { // vec4 v = BaseColor; // gl_FragColor = v; // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %7 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output )"; const std::string before = R"(%main = OpFunction %void None %7 %13 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %14 = OpLoad %v4float %BaseColor OpStore %v %14 OpBranch %15 %15 = OpLabel %16 = OpLoad %v4float %v OpStore %gl_FragColor %16 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %7 %13 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %14 = OpLoad %v4float %BaseColor OpStore %v %14 %16 = OpLoad %v4float %v OpStore %gl_FragColor %16 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before, predefs + after, true, true); } TEST_F(BlockMergeTest, BlockMergeForLinkage) { const std::string before = R"(OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpSource HLSL 630 OpName %main "main" OpName %BaseColor "BaseColor" OpName %bb_entry "bb.entry" OpName %v "v" OpDecorate %main LinkageAttributes "main" Export %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %8 = OpTypeFunction %v4float %_ptr_Function_v4float %main = OpFunction %v4float None %8 %BaseColor = OpFunctionParameter %_ptr_Function_v4float %bb_entry = OpLabel %v = OpVariable %_ptr_Function_v4float Function %9 = OpLoad %v4float %BaseColor OpStore %v %9 OpBranch %10 %10 = OpLabel %11 = OpLoad %v4float %v OpBranch %12 %12 = OpLabel OpReturnValue %11 OpFunctionEnd )"; const std::string after = R"(OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpSource HLSL 630 OpName %main "main" OpName %BaseColor "BaseColor" OpName %bb_entry "bb.entry" OpName %v "v" OpDecorate %main LinkageAttributes "main" Export %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %8 = OpTypeFunction %v4float %_ptr_Function_v4float %main = OpFunction %v4float None %8 %BaseColor = OpFunctionParameter %_ptr_Function_v4float %bb_entry = OpLabel %v = OpVariable %_ptr_Function_v4float Function %9 = OpLoad %v4float %BaseColor OpStore %v %9 %11 = OpLoad %v4float %v OpReturnValue %11 OpFunctionEnd )"; SinglePassRunAndCheck(before, after, true, true); } TEST_F(BlockMergeTest, EmptyBlock) { // Note: SPIR-V hand edited to insert empty block // after two statements in main. // // #version 140 // // in vec4 BaseColor; // // void main() // { // vec4 v = BaseColor; // gl_FragColor = v; // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %7 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output )"; const std::string before = R"(%main = OpFunction %void None %7 %13 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %14 = OpLoad %v4float %BaseColor OpStore %v %14 OpBranch %15 %15 = OpLabel %16 = OpLoad %v4float %v OpStore %gl_FragColor %16 OpBranch %17 %17 = OpLabel OpBranch %18 %18 = OpLabel OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %7 %13 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %14 = OpLoad %v4float %BaseColor OpStore %v %14 %16 = OpLoad %v4float %v OpStore %gl_FragColor %16 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before, predefs + after, true, true); } TEST_F(BlockMergeTest, NestedInControlFlow) { // Note: SPIR-V hand edited to insert block boundary // between OpFMul and OpStore in then-part. // // #version 140 // in vec4 BaseColor; // // layout(std140) uniform U_t // { // bool g_B ; // } ; // // void main() // { // vec4 v = BaseColor; // if (g_B) // vec4 v = v * 0.25; // gl_FragColor = v; // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" OpName %U_t "U_t" OpMemberName %U_t 0 "g_B" OpName %_ "" OpName %v_0 "v" OpName %gl_FragColor "gl_FragColor" OpMemberDecorate %U_t 0 Offset 0 OpDecorate %U_t Block OpDecorate %_ DescriptorSet 0 %void = OpTypeVoid %10 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %uint = OpTypeInt 32 0 %U_t = OpTypeStruct %uint %_ptr_Uniform_U_t = OpTypePointer Uniform %U_t %_ = OpVariable %_ptr_Uniform_U_t Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %bool = OpTypeBool %uint_0 = OpConstant %uint 0 %float_0_25 = OpConstant %float 0.25 %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output )"; const std::string before = R"(%main = OpFunction %void None %10 %24 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %v_0 = OpVariable %_ptr_Function_v4float Function %25 = OpLoad %v4float %BaseColor OpStore %v %25 %26 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %27 = OpLoad %uint %26 %28 = OpINotEqual %bool %27 %uint_0 OpSelectionMerge %29 None OpBranchConditional %28 %30 %29 %30 = OpLabel %31 = OpLoad %v4float %v %32 = OpVectorTimesScalar %v4float %31 %float_0_25 OpBranch %33 %33 = OpLabel OpStore %v_0 %32 OpBranch %29 %29 = OpLabel %34 = OpLoad %v4float %v OpStore %gl_FragColor %34 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %10 %24 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %v_0 = OpVariable %_ptr_Function_v4float Function %25 = OpLoad %v4float %BaseColor OpStore %v %25 %26 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %27 = OpLoad %uint %26 %28 = OpINotEqual %bool %27 %uint_0 OpSelectionMerge %29 None OpBranchConditional %28 %30 %29 %30 = OpLabel %31 = OpLoad %v4float %v %32 = OpVectorTimesScalar %v4float %31 %float_0_25 OpStore %v_0 %32 OpBranch %29 %29 = OpLabel %34 = OpLoad %v4float %v OpStore %gl_FragColor %34 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before, predefs + after, true, true); } TEST_F(BlockMergeTest, PhiInSuccessorOfMergedBlock) { const std::string text = R"( ; CHECK: OpSelectionMerge [[merge:%\w+]] None ; CHECK-NEXT: OpBranchConditional {{%\w+}} [[then:%\w+]] [[else:%\w+]] ; CHECK: [[then]] = OpLabel ; CHECK-NEXT: OpBranch [[merge]] ; CHECK: [[else]] = OpLabel ; CHECK-NEXT: OpBranch [[merge]] ; CHECK: [[merge]] = OpLabel ; CHECK-NEXT: OpPhi {{%\w+}} %true [[then]] %false [[else]] OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %false = OpConstantFalse %bool %functy = OpTypeFunction %void %func = OpFunction %void None %functy %entry = OpLabel OpSelectionMerge %merge None OpBranchConditional %true %then %else %then = OpLabel OpBranch %then_next %then_next = OpLabel OpBranch %merge %else = OpLabel OpBranch %merge %merge = OpLabel %phi = OpPhi %bool %true %then_next %false %else OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(BlockMergeTest, UpdateMergeInstruction) { const std::string text = R"( ; CHECK: OpSelectionMerge [[merge:%\w+]] None ; CHECK-NEXT: OpBranchConditional {{%\w+}} [[then:%\w+]] [[else:%\w+]] ; CHECK: [[then]] = OpLabel ; CHECK-NEXT: OpBranch [[merge]] ; CHECK: [[else]] = OpLabel ; CHECK-NEXT: OpBranch [[merge]] ; CHECK: [[merge]] = OpLabel ; CHECK-NEXT: OpReturn OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %false = OpConstantFalse %bool %functy = OpTypeFunction %void %func = OpFunction %void None %functy %entry = OpLabel OpSelectionMerge %real_merge None OpBranchConditional %true %then %else %then = OpLabel OpBranch %merge %else = OpLabel OpBranch %merge %merge = OpLabel OpBranch %real_merge %real_merge = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(BlockMergeTest, TwoMergeBlocksCannotBeMerged) { const std::string text = R"( ; CHECK: OpSelectionMerge [[outer_merge:%\w+]] None ; CHECK: OpSelectionMerge [[inner_merge:%\w+]] None ; CHECK: [[inner_merge]] = OpLabel ; CHECK-NEXT: OpBranch [[outer_merge]] ; CHECK: [[outer_merge]] = OpLabel ; CHECK-NEXT: OpReturn OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %false = OpConstantFalse %bool %functy = OpTypeFunction %void %func = OpFunction %void None %functy %entry = OpLabel OpSelectionMerge %outer_merge None OpBranchConditional %true %then %else %then = OpLabel OpBranch %inner_header %else = OpLabel OpBranch %inner_header %inner_header = OpLabel OpSelectionMerge %inner_merge None OpBranchConditional %true %inner_then %inner_else %inner_then = OpLabel OpBranch %inner_merge %inner_else = OpLabel OpBranch %inner_merge %inner_merge = OpLabel OpBranch %outer_merge %outer_merge = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(BlockMergeTest, MergeContinue) { const std::string text = R"( ; CHECK: OpBranch [[header:%\w+]] ; CHECK: [[header]] = OpLabel ; CHECK-NEXT: OpLogicalAnd ; CHECK-NEXT: OpLoopMerge {{%\w+}} [[header]] None ; CHECK-NEXT: OpBranch [[header]] OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %false = OpConstantFalse %bool %functy = OpTypeFunction %void %func = OpFunction %void None %functy %entry = OpLabel OpBranch %header %header = OpLabel OpLoopMerge %merge %continue None OpBranch %continue %continue = OpLabel %op = OpLogicalAnd %bool %true %false OpBranch %header %merge = OpLabel OpUnreachable OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(BlockMergeTest, MergeContinueWithOpLine) { const std::string text = R"( ; CHECK: OpBranch [[header:%\w+]] ; CHECK: [[header]] = OpLabel ; CHECK-NEXT: OpLogicalAnd ; CHECK-NEXT: OpLine {{%\w+}} 1 1 ; CHECK-NEXT: OpLoopMerge {{%\w+}} [[header]] None ; CHECK-NEXT: OpBranch [[header]] OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %src = OpString "test.shader" %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %false = OpConstantFalse %bool %functy = OpTypeFunction %void %func = OpFunction %void None %functy %entry = OpLabel OpBranch %header %header = OpLabel OpLoopMerge %merge %continue None OpBranch %continue %continue = OpLabel %op = OpLogicalAnd %bool %true %false OpLine %src 1 1 OpBranch %header %merge = OpLabel OpUnreachable OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(BlockMergeTest, TwoHeadersCannotBeMerged) { const std::string text = R"( ; CHECK: OpBranch [[loop_header:%\w+]] ; CHECK: [[loop_header]] = OpLabel ; CHECK-NEXT: OpLoopMerge ; CHECK-NEXT: OpBranch [[if_header:%\w+]] ; CHECK: [[if_header]] = OpLabel ; CHECK-NEXT: OpSelectionMerge OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %false = OpConstantFalse %bool %functy = OpTypeFunction %void %func = OpFunction %void None %functy %entry = OpLabel OpBranch %header %header = OpLabel OpLoopMerge %merge %continue None OpBranch %inner_header %inner_header = OpLabel OpSelectionMerge %if_merge None OpBranchConditional %true %then %if_merge %then = OpLabel OpBranch %continue %if_merge = OpLabel OpBranch %continue %continue = OpLabel OpBranchConditional %false %merge %header %merge = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(BlockMergeTest, CannotMergeContinue) { const std::string text = R"( ; CHECK: OpBranch [[loop_header:%\w+]] ; CHECK: [[loop_header]] = OpLabel ; CHECK-NEXT: OpLoopMerge {{%\w+}} [[continue:%\w+]] ; CHECK-NEXT: OpBranchConditional {{%\w+}} [[if_header:%\w+]] ; CHECK: [[if_header]] = OpLabel ; CHECK-NEXT: OpSelectionMerge ; CHECK: [[continue]] = OpLabel OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %false = OpConstantFalse %bool %functy = OpTypeFunction %void %func = OpFunction %void None %functy %entry = OpLabel OpBranch %header %header = OpLabel OpLoopMerge %merge %continue None OpBranchConditional %true %inner_header %merge %inner_header = OpLabel OpSelectionMerge %if_merge None OpBranchConditional %true %then %if_merge %then = OpLabel OpBranch %continue %if_merge = OpLabel OpBranch %continue %continue = OpLabel OpBranchConditional %false %merge %header %merge = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(BlockMergeTest, RemoveStructuredDeclaration) { // Note: SPIR-V hand edited remove dead branch and add block // before continue block // // #version 140 // in vec4 BaseColor; // // void main() // { // while (true) { // break; // } // gl_FragColor = BaseColor; // } const std::string assembly = R"( ; CHECK: OpLabel ; CHECK: [[header:%\w+]] = OpLabel ; CHECK-NOT: OpLoopMerge ; CHECK: OpReturn ; CHECK: [[continue:%\w+]] = OpLabel ; CHECK-NEXT: OpBranch [[block:%\w+]] ; CHECK: [[block]] = OpLabel ; CHECK-NEXT: OpBranch [[header]] OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragColor %BaseColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %gl_FragColor "gl_FragColor" OpName %BaseColor "BaseColor" %void = OpTypeVoid %6 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %main = OpFunction %void None %6 %13 = OpLabel OpBranch %14 %14 = OpLabel OpLoopMerge %15 %16 None OpBranch %17 %17 = OpLabel OpBranch %15 %18 = OpLabel OpBranch %16 %16 = OpLabel OpBranch %14 %15 = OpLabel %19 = OpLoad %v4float %BaseColor OpStore %gl_FragColor %19 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(assembly, true); } TEST_F(BlockMergeTest, DontMergeKill) { const std::string text = R"( ; CHECK: OpLoopMerge [[merge:%\w+]] [[cont:%\w+]] None ; CHECK-NEXT: OpBranch [[ret:%\w+]] ; CHECK: [[ret:%\w+]] = OpLabel ; CHECK-NEXT: OpKill ; CHECK-DAG: [[cont]] = OpLabel ; CHECK-DAG: [[merge]] = OpLabel OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %bool = OpTypeBool %functy = OpTypeFunction %void %func = OpFunction %void None %functy %1 = OpLabel OpBranch %2 %2 = OpLabel OpLoopMerge %3 %4 None OpBranch %5 %5 = OpLabel OpKill %4 = OpLabel OpBranch %2 %3 = OpLabel OpUnreachable OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(BlockMergeTest, DontMergeTerminateInvocation) { const std::string text = R"( ; CHECK: OpLoopMerge [[merge:%\w+]] [[cont:%\w+]] None ; CHECK-NEXT: OpBranch [[ret:%\w+]] ; CHECK: [[ret:%\w+]] = OpLabel ; CHECK-NEXT: OpTerminateInvocation ; CHECK-DAG: [[cont]] = OpLabel ; CHECK-DAG: [[merge]] = OpLabel OpCapability Shader OpExtension "SPV_KHR_terminate_invocation" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %bool = OpTypeBool %functy = OpTypeFunction %void %func = OpFunction %void None %functy %1 = OpLabel OpBranch %2 %2 = OpLabel OpLoopMerge %3 %4 None OpBranch %5 %5 = OpLabel OpTerminateInvocation %4 = OpLabel OpBranch %2 %3 = OpLabel OpUnreachable OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(BlockMergeTest, DontMergeUnreachable) { const std::string text = R"( ; CHECK: OpLoopMerge [[merge:%\w+]] [[cont:%\w+]] None ; CHECK-NEXT: OpBranch [[ret:%\w+]] ; CHECK: [[ret:%\w+]] = OpLabel ; CHECK-NEXT: OpUnreachable ; CHECK-DAG: [[cont]] = OpLabel ; CHECK-DAG: [[merge]] = OpLabel OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %bool = OpTypeBool %functy = OpTypeFunction %void %func = OpFunction %void None %functy %1 = OpLabel OpBranch %2 %2 = OpLabel OpLoopMerge %3 %4 None OpBranch %5 %5 = OpLabel OpUnreachable %4 = OpLabel OpBranch %2 %3 = OpLabel OpUnreachable OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(BlockMergeTest, DontMergeReturn) { const std::string text = R"( ; CHECK: OpLoopMerge [[merge:%\w+]] [[cont:%\w+]] None ; CHECK-NEXT: OpBranch [[ret:%\w+]] ; CHECK: [[ret:%\w+]] = OpLabel ; CHECK-NEXT: OpReturn ; CHECK-DAG: [[cont]] = OpLabel ; CHECK-DAG: [[merge]] = OpLabel OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %bool = OpTypeBool %functy = OpTypeFunction %void %func = OpFunction %void None %functy %1 = OpLabel OpBranch %2 %2 = OpLabel OpLoopMerge %3 %4 None OpBranch %5 %5 = OpLabel OpReturn %4 = OpLabel OpBranch %2 %3 = OpLabel OpUnreachable OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(BlockMergeTest, DontMergeSwitch) { const std::string text = R"( ; CHECK: OpLoopMerge [[merge:%\w+]] [[cont:%\w+]] None ; CHECK-NEXT: OpBranch [[ret:%\w+]] ; CHECK: [[ret:%\w+]] = OpLabel ; CHECK-NEXT: OpSelectionMerge ; CHECK-NEXT: OpSwitch ; CHECK-DAG: [[cont]] = OpLabel ; CHECK-DAG: [[merge]] = OpLabel OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %bool = OpTypeBool %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %functy = OpTypeFunction %void %func = OpFunction %void None %functy %1 = OpLabel OpBranch %2 %2 = OpLabel OpLoopMerge %3 %4 None OpBranch %5 %5 = OpLabel OpSelectionMerge %6 None OpSwitch %int_0 %6 %6 = OpLabel OpReturn %4 = OpLabel OpBranch %2 %3 = OpLabel OpUnreachable OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(BlockMergeTest, DontMergeReturnValue) { const std::string text = R"( ; CHECK: OpLoopMerge [[merge:%\w+]] [[cont:%\w+]] None ; CHECK-NEXT: OpBranch [[ret:%\w+]] ; CHECK: [[ret:%\w+]] = OpLabel ; CHECK-NEXT: OpReturn ; CHECK-DAG: [[cont]] = OpLabel ; CHECK-DAG: [[merge]] = OpLabel OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %bool = OpTypeBool %functy = OpTypeFunction %void %otherfuncty = OpTypeFunction %bool %true = OpConstantTrue %bool %func = OpFunction %void None %functy %1 = OpLabel %2 = OpFunctionCall %bool %3 OpReturn OpFunctionEnd %3 = OpFunction %bool None %otherfuncty %4 = OpLabel OpBranch %5 %5 = OpLabel OpLoopMerge %6 %7 None OpBranch %8 %8 = OpLabel OpReturnValue %true %7 = OpLabel OpBranch %5 %6 = OpLabel OpUnreachable OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(BlockMergeTest, MergeHeaders) { // Merge two headers when the second is the merge block of the first. const std::string text = R"( ; CHECK: OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpBranch [[header:%\w+]] ; CHECK-NEXT: [[header]] = OpLabel ; CHECK-NEXT: OpSelectionMerge [[merge:%\w+]] ; CHECK: [[merge]] = OpLabel ; CHECK: OpReturn OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %bool = OpTypeBool %functy = OpTypeFunction %void %otherfuncty = OpTypeFunction %bool %true = OpConstantTrue %bool %func = OpFunction %void None %functy %1 = OpLabel OpBranch %5 %5 = OpLabel OpLoopMerge %8 %7 None OpBranch %8 %7 = OpLabel OpBranch %5 %8 = OpLabel OpSelectionMerge %m None OpBranchConditional %true %a %m %a = OpLabel OpBranch %m %m = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(BlockMergeTest, OpPhiInSuccessor) { // Checks that when merging blocks A and B, the OpPhi at the start of B is // removed and uses of its definition are replaced appropriately. const std::string prefix = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %x "x" OpName %y "y" %void = OpTypeVoid %6 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_1 = OpConstant %int 1 %main = OpFunction %void None %6 %10 = OpLabel %x = OpVariable %_ptr_Function_int Function %y = OpVariable %_ptr_Function_int Function OpStore %x %int_1 %11 = OpLoad %int %x )"; const std::string suffix_before = R"(OpBranch %12 %12 = OpLabel %13 = OpPhi %int %11 %10 OpStore %y %13 OpReturn OpFunctionEnd )"; const std::string suffix_after = R"(OpStore %y %11 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(prefix + suffix_before, prefix + suffix_after, true, true); } TEST_F(BlockMergeTest, MultipleOpPhisInSuccessor) { // Checks that when merging blocks A and B, the OpPhis at the start of B are // removed and uses of their definitions are replaced appropriately. const std::string prefix = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %S "S" OpMemberName %S 0 "x" OpMemberName %S 1 "f" OpName %s "s" OpName %g "g" OpName %y "y" OpName %t "t" OpName %z "z" %void = OpTypeVoid %10 = OpTypeFunction %void %int = OpTypeInt 32 1 %float = OpTypeFloat 32 %S = OpTypeStruct %int %float %_ptr_Function_S = OpTypePointer Function %S %int_1 = OpConstant %int 1 %float_2 = OpConstant %float 2 %16 = OpConstantComposite %S %int_1 %float_2 %_ptr_Function_float = OpTypePointer Function %float %_ptr_Function_int = OpTypePointer Function %int %int_3 = OpConstant %int 3 %int_0 = OpConstant %int 0 %main = OpFunction %void None %10 %21 = OpLabel %s = OpVariable %_ptr_Function_S Function %g = OpVariable %_ptr_Function_float Function %y = OpVariable %_ptr_Function_int Function %t = OpVariable %_ptr_Function_S Function %z = OpVariable %_ptr_Function_float Function OpStore %s %16 OpStore %g %float_2 OpStore %y %int_3 %22 = OpLoad %S %s OpStore %t %22 %23 = OpAccessChain %_ptr_Function_float %s %int_1 %24 = OpLoad %float %23 %25 = OpLoad %float %g )"; const std::string suffix_before = R"(OpBranch %26 %26 = OpLabel %27 = OpPhi %float %24 %21 %28 = OpPhi %float %25 %21 %29 = OpFAdd %float %27 %28 %30 = OpAccessChain %_ptr_Function_int %s %int_0 %31 = OpLoad %int %30 OpBranch %32 %32 = OpLabel %33 = OpPhi %float %29 %26 %34 = OpPhi %int %31 %26 %35 = OpConvertSToF %float %34 OpBranch %36 %36 = OpLabel %37 = OpPhi %float %35 %32 %38 = OpFSub %float %33 %37 %39 = OpLoad %int %y OpBranch %40 %40 = OpLabel %41 = OpPhi %float %38 %36 %42 = OpPhi %int %39 %36 %43 = OpConvertSToF %float %42 %44 = OpFAdd %float %41 %43 OpStore %z %44 OpReturn OpFunctionEnd )"; const std::string suffix_after = R"(%29 = OpFAdd %float %24 %25 %30 = OpAccessChain %_ptr_Function_int %s %int_0 %31 = OpLoad %int %30 %35 = OpConvertSToF %float %31 %38 = OpFSub %float %29 %35 %39 = OpLoad %int %y %43 = OpConvertSToF %float %39 %44 = OpFAdd %float %38 %43 OpStore %z %44 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(prefix + suffix_before, prefix + suffix_after, true, true); } TEST_F(BlockMergeTest, UnreachableLoop) { const std::string spirv = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" %void = OpTypeVoid %4 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %bool = OpTypeBool %false = OpConstantFalse %bool %main = OpFunction %void None %4 %9 = OpLabel OpBranch %10 %11 = OpLabel OpLoopMerge %12 %13 None OpBranchConditional %false %13 %14 %13 = OpLabel OpSelectionMerge %15 None OpBranchConditional %false %16 %17 %16 = OpLabel OpBranch %15 %17 = OpLabel OpBranch %15 %15 = OpLabel OpBranch %11 %14 = OpLabel OpReturn %12 = OpLabel OpBranch %10 %10 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(spirv, spirv, true, true); } TEST_F(BlockMergeTest, DebugMerge) { // Verify merge can be done completely, cleanly and validly in presence of // NonSemantic.Shader.DebugInfo.100 instructions const std::string text = R"( ; CHECK: OpLoopMerge ; CHECK-NEXT: OpBranch ; CHECK-NOT: OpBranch OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %1 = OpExtInstImport "NonSemantic.Shader.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_COLOR %out_var_SV_TARGET OpExecutionMode %main OriginUpperLeft %5 = OpString "lexblock.hlsl" %20 = OpString "float" %32 = OpString "main" %33 = OpString "" %46 = OpString "b" %49 = OpString "a" %58 = OpString "c" %63 = OpString "color" OpName %in_var_COLOR "in.var.COLOR" OpName %out_var_SV_TARGET "out.var.SV_TARGET" OpName %main "main" OpDecorate %in_var_COLOR Location 0 OpDecorate %out_var_SV_TARGET Location 0 %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %v4float = OpTypeVector %float 4 %9 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %float_1 = OpConstant %float 1 %13 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %uint_3 = OpConstant %uint 3 %uint_0 = OpConstant %uint 0 %uint_4 = OpConstant %uint 4 %uint_1 = OpConstant %uint 1 %uint_5 = OpConstant %uint 5 %uint_12 = OpConstant %uint 12 %uint_13 = OpConstant %uint 13 %uint_20 = OpConstant %uint 20 %uint_15 = OpConstant %uint 15 %uint_17 = OpConstant %uint 17 %uint_16 = OpConstant %uint 16 %uint_14 = OpConstant %uint 14 %uint_10 = OpConstant %uint 10 %65 = OpTypeFunction %void %in_var_COLOR = OpVariable %_ptr_Input_v4float Input %out_var_SV_TARGET = OpVariable %_ptr_Output_v4float Output %62 = OpExtInst %void %1 DebugExpression %22 = OpExtInst %void %1 DebugTypeBasic %20 %uint_32 %uint_3 %uint_0 %25 = OpExtInst %void %1 DebugTypeVector %22 %uint_4 %27 = OpExtInst %void %1 DebugTypeFunction %uint_3 %25 %25 %28 = OpExtInst %void %1 DebugSource %5 %29 = OpExtInst %void %1 DebugCompilationUnit %uint_1 %uint_4 %28 %uint_5 %34 = OpExtInst %void %1 DebugFunction %32 %27 %28 %uint_12 %uint_1 %29 %33 %uint_3 %uint_13 %37 = OpExtInst %void %1 DebugLexicalBlock %28 %uint_13 %uint_1 %34 %52 = OpExtInst %void %1 DebugLexicalBlock %28 %uint_15 %uint_12 %37 %54 = OpExtInst %void %1 DebugLocalVariable %46 %25 %28 %uint_17 %uint_12 %52 %uint_4 %56 = OpExtInst %void %1 DebugLocalVariable %49 %25 %28 %uint_16 %uint_12 %52 %uint_4 %59 = OpExtInst %void %1 DebugLocalVariable %58 %25 %28 %uint_14 %uint_10 %37 %uint_4 %64 = OpExtInst %void %1 DebugLocalVariable %63 %25 %28 %uint_12 %uint_20 %34 %uint_4 %uint_1 %main = OpFunction %void None %65 %66 = OpLabel %69 = OpLoad %v4float %in_var_COLOR %168 = OpExtInst %void %1 DebugValue %64 %69 %62 %169 = OpExtInst %void %1 DebugScope %37 OpLine %5 14 10 %164 = OpExtInst %void %1 DebugValue %59 %9 %62 OpLine %5 15 3 OpBranch %150 %150 = OpLabel %165 = OpPhi %v4float %9 %66 %158 %159 %167 = OpExtInst %void %1 DebugValue %59 %165 %62 %170 = OpExtInst %void %1 DebugScope %37 OpLine %5 15 12 %171 = OpExtInst %void %1 DebugNoScope OpLoopMerge %160 %159 None OpBranch %151 %151 = OpLabel OpLine %5 16 12 %162 = OpExtInst %void %1 DebugValue %56 %9 %62 OpLine %5 17 12 %163 = OpExtInst %void %1 DebugValue %54 %13 %62 OpLine %5 18 15 %158 = OpFAdd %v4float %165 %13 OpLine %5 18 5 %166 = OpExtInst %void %1 DebugValue %59 %158 %62 %172 = OpExtInst %void %1 DebugScope %37 OpLine %5 19 3 OpBranch %159 %159 = OpLabel OpLine %5 19 3 OpBranch %150 %160 = OpLabel OpUnreachable OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(BlockMergeTest, DontLoseCaseConstruct) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %func "func" OpExecutionMode %func LocalSize 1 1 1 OpName %entry "entry"; OpName %loop "loop" OpName %loop_merge "loop_merge" OpName %loop_cont "loop_cont" OpName %switch "switch" OpName %switch_merge "switch_merge" %void = OpTypeVoid %bool = OpTypeBool %int = OpTypeInt 32 0 %void_fn = OpTypeFunction %void %bool_undef = OpUndef %bool %int_undef = OpUndef %int %func = OpFunction %void None %void_fn %entry = OpLabel OpBranch %loop %loop = OpLabel OpLoopMerge %loop_merge %loop_cont None OpBranch %switch %switch = OpLabel OpSelectionMerge %switch_merge None OpSwitch %int_undef %switch_merge 0 %break 1 %break %break = OpLabel OpBranch %loop_merge %switch_merge = OpLabel OpBranch %loop_cont %loop_cont = OpLabel OpBranch %loop %loop_merge = OpLabel OpReturn OpFunctionEnd )"; auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ true); EXPECT_EQ(opt::Pass::Status::SuccessWithoutChange, std::get<1>(result)); } TEST_F(BlockMergeTest, DontLoseDefaultCaseConstruct) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %func "func" OpExecutionMode %func LocalSize 1 1 1 OpName %entry "entry"; OpName %loop "loop" OpName %loop_merge "loop_merge" OpName %loop_cont "loop_cont" OpName %switch "switch" OpName %switch_merge "switch_merge" %void = OpTypeVoid %bool = OpTypeBool %int = OpTypeInt 32 0 %void_fn = OpTypeFunction %void %bool_undef = OpUndef %bool %int_undef = OpUndef %int %func = OpFunction %void None %void_fn %entry = OpLabel OpBranch %loop %loop = OpLabel OpLoopMerge %loop_merge %loop_cont None OpBranch %switch %switch = OpLabel OpSelectionMerge %switch_merge None OpSwitch %int_undef %cont 0 %switch_merge 1 %switch_merge %cont = OpLabel OpBranch %loop_cont %switch_merge = OpLabel OpBranch %loop_merge %loop_cont = OpLabel OpBranch %loop %loop_merge = OpLabel OpReturn OpFunctionEnd )"; auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ true); EXPECT_EQ(opt::Pass::Status::SuccessWithoutChange, std::get<1>(result)); } TEST_F(BlockMergeTest, RebuildStructuredCFG) { const std::string text = R"( ; CHECK: = OpFunction ; CHECK-NEXT: [[entry:%\w+]] = OpLabel ; CHECK-NEXT: OpSelectionMerge [[merge:%\w+]] None ; CHECK-NEXT: OpSwitch {{%\w+}} [[merge]] 0 [[other:%\w+]] ; CHECK [[other]] = OpLabel ; CHECK: OpBranch [[merge]] ; CHECK [[merge]] = OpLabel OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_1 = OpConstant %int 1 %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpBranch %switch %switch = OpLabel OpSelectionMerge %merge None OpSwitch %int_1 %merge 0 %other %other = OpLabel OpBranch %merge %merge = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(BlockMergeTest, MaximalReconvergenceNoMeldToMerge) { const std::string text = R"( OpCapability Shader OpCapability GroupNonUniformBallot OpCapability GroupNonUniformArithmetic OpExtension "SPV_KHR_maximal_reconvergence" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %gl_GlobalInvocationID %output OpExecutionMode %main LocalSize 1 1 1 OpExecutionMode %main MaximallyReconvergesKHR OpSource HLSL 660 OpName %type_RWStructuredBuffer_uint "type.RWStructuredBuffer.uint" OpName %output "output" OpName %main "main" OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId OpDecorate %output DescriptorSet 0 OpDecorate %output Binding 0 OpDecorate %_runtimearr_uint ArrayStride 4 OpMemberDecorate %type_RWStructuredBuffer_uint 0 Offset 0 OpDecorate %type_RWStructuredBuffer_uint Block %uint = OpTypeInt 32 0 %bool = OpTypeBool %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %_runtimearr_uint = OpTypeRuntimeArray %uint %type_RWStructuredBuffer_uint = OpTypeStruct %_runtimearr_uint %_ptr_StorageBuffer_type_RWStructuredBuffer_uint = OpTypePointer StorageBuffer %type_RWStructuredBuffer_uint %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %void = OpTypeVoid %15 = OpTypeFunction %void %uint_3 = OpConstant %uint 3 %_ptr_StorageBuffer_uint = OpTypePointer StorageBuffer %uint %output = OpVariable %_ptr_StorageBuffer_type_RWStructuredBuffer_uint StorageBuffer %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %main = OpFunction %void None %15 %18 = OpLabel %19 = OpLoad %v3uint %gl_GlobalInvocationID OpBranch %20 %20 = OpLabel OpLoopMerge %21 %22 None ; CHECK: OpLoopMerge [[merge:%\w+]] [[continue:%\w+]] OpBranch %23 %23 = OpLabel %24 = OpCompositeExtract %uint %19 0 %25 = OpGroupNonUniformBroadcastFirst %uint %uint_3 %24 %26 = OpIEqual %bool %24 %25 OpSelectionMerge %27 None OpBranchConditional %26 %28 %27 %28 = OpLabel %29 = OpGroupNonUniformIAdd %int %uint_3 Reduce %int_1 %30 = OpBitcast %uint %29 OpBranch %21 ; CHECK: [[t1:%\w+]] = OpGroupNonUniformIAdd %int %uint_3 Reduce %int_1 ; CHECK-NEXT: [[t2:%\w+]] = OpBitcast %uint [[t1]] ; CHECK-NEXT: OpBranch [[merge]] %27 = OpLabel OpBranch %22 %22 = OpLabel OpBranch %20 %21 = OpLabel %31 = OpAccessChain %_ptr_StorageBuffer_uint %output %int_0 %24 OpStore %31 %30 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SinglePassRunAndMatch(text, true); } TEST_F(BlockMergeTest, NoMaximalReconvergenceMeldToMerge) { const std::string text = R"( OpCapability Shader OpCapability GroupNonUniformBallot OpCapability GroupNonUniformArithmetic OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %gl_GlobalInvocationID %output OpExecutionMode %main LocalSize 1 1 1 OpSource HLSL 660 OpName %type_RWStructuredBuffer_uint "type.RWStructuredBuffer.uint" OpName %output "output" OpName %main "main" OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId OpDecorate %output DescriptorSet 0 OpDecorate %output Binding 0 OpDecorate %_runtimearr_uint ArrayStride 4 OpMemberDecorate %type_RWStructuredBuffer_uint 0 Offset 0 OpDecorate %type_RWStructuredBuffer_uint Block %uint = OpTypeInt 32 0 %bool = OpTypeBool %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %_runtimearr_uint = OpTypeRuntimeArray %uint %type_RWStructuredBuffer_uint = OpTypeStruct %_runtimearr_uint %_ptr_StorageBuffer_type_RWStructuredBuffer_uint = OpTypePointer StorageBuffer %type_RWStructuredBuffer_uint %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %void = OpTypeVoid %15 = OpTypeFunction %void %uint_3 = OpConstant %uint 3 %_ptr_StorageBuffer_uint = OpTypePointer StorageBuffer %uint %output = OpVariable %_ptr_StorageBuffer_type_RWStructuredBuffer_uint StorageBuffer %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %main = OpFunction %void None %15 %18 = OpLabel %19 = OpLoad %v3uint %gl_GlobalInvocationID OpBranch %20 %20 = OpLabel OpLoopMerge %21 %22 None ; CHECK: OpLoopMerge [[merge:%\w+]] [[continue:%\w+]] OpBranch %23 %23 = OpLabel %24 = OpCompositeExtract %uint %19 0 %25 = OpGroupNonUniformBroadcastFirst %uint %uint_3 %24 %26 = OpIEqual %bool %24 %25 OpSelectionMerge %27 None OpBranchConditional %26 %28 %27 %28 = OpLabel %29 = OpGroupNonUniformIAdd %int %uint_3 Reduce %int_1 %30 = OpBitcast %uint %29 OpBranch %21 ; CHECK: [[merge]] = OpLabel ; CHECK-NEXT: [[t1:%\w+]] = OpGroupNonUniformIAdd %int %uint_3 Reduce %int_1 ; CHECK-NEXT: [[t2:%\w+]] = OpBitcast %uint [[t1]] %27 = OpLabel OpBranch %22 %22 = OpLabel OpBranch %20 %21 = OpLabel %31 = OpAccessChain %_ptr_StorageBuffer_uint %output %int_0 %24 OpStore %31 %30 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SinglePassRunAndMatch(text, true); } // TODO(greg-lunarg): Add tests to verify handling of these cases: // // More complex control flow // Others? } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/c_interface_test.cpp000066400000000000000000000371431475742701700243270ustar00rootroot00000000000000// Copyright (c) 2023 Nintendo // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gtest/gtest.h" #include "spirv-tools/libspirv.h" namespace spvtools { namespace { TEST(OptimizerCInterface, DefaultConsumerWithValidationNoPassesForInvalidInput) { const uint32_t spirv[] = { 0xDEADFEED, // Invalid Magic 0x00010100, // Version 1.1 0x00000000, // No Generator 0x01000000, // Bound 0x00000000, // Schema 0x00020011, // OpCapability 0x00000001, // Shader 0x00020011, // OpCapability 0x00000005, // Linkage 0x0003000E, // OpMemoryModel 0x00000000, // Logical 0x00000001 // GLSL450 }; auto optimizer = spvOptimizerCreate(SPV_ENV_UNIVERSAL_1_1); ASSERT_NE(optimizer, nullptr); // Do not register any passes auto options = spvOptimizerOptionsCreate(); ASSERT_NE(options, nullptr); spvOptimizerOptionsSetRunValidator(options, true); spv_binary binary = nullptr; EXPECT_NE(SPV_SUCCESS, spvOptimizerRun(optimizer, spirv, sizeof(spirv) / sizeof(uint32_t), &binary, options)); ASSERT_EQ(binary, nullptr); spvOptimizerOptionsDestroy(options); spvOptimizerDestroy(optimizer); } TEST(OptimizerCInterface, SpecifyConsumerWithValidationNoPassesForInvalidInput) { const uint32_t spirv[] = { 0xDEADFEED, // Invalid Magic 0x00010100, // Version 1.1 0x00000000, // No Generator 0x01000000, // Bound 0x00000000, // Schema 0x00020011, // OpCapability 0x00000001, // Shader 0x00020011, // OpCapability 0x00000005, // Linkage 0x0003000E, // OpMemoryModel 0x00000000, // Logical 0x00000001 // GLSL450 }; auto optimizer = spvOptimizerCreate(SPV_ENV_UNIVERSAL_1_1); ASSERT_NE(optimizer, nullptr); spvOptimizerSetMessageConsumer( optimizer, [](spv_message_level_t, const char*, const spv_position_t*, const char* message) { std::cout << message << std::endl; }); // Do not register any passes auto options = spvOptimizerOptionsCreate(); ASSERT_NE(options, nullptr); spvOptimizerOptionsSetRunValidator(options, true); testing::internal::CaptureStdout(); spv_binary binary = nullptr; EXPECT_NE(SPV_SUCCESS, spvOptimizerRun(optimizer, spirv, sizeof(spirv) / sizeof(uint32_t), &binary, options)); ASSERT_EQ(binary, nullptr); auto output = testing::internal::GetCapturedStdout(); EXPECT_STRNE(output.c_str(), ""); spvOptimizerOptionsDestroy(options); spvOptimizerDestroy(optimizer); } TEST(OptimizerCInterface, DefaultConsumerWithValidationNoPassesForValidInput) { const uint32_t spirv[] = { 0x07230203, // Magic 0x00010100, // Version 1.1 0x00000000, // No Generator 0x00000001, // Bound 0x00000000, // Schema 0x00020011, // OpCapability 0x00000001, // Shader 0x00020011, // OpCapability 0x00000005, // Linkage 0x0003000E, // OpMemoryModel 0x00000000, // Logical 0x00000001 // GLSL450 }; auto optimizer = spvOptimizerCreate(SPV_ENV_UNIVERSAL_1_1); ASSERT_NE(optimizer, nullptr); // Do not register any passes auto options = spvOptimizerOptionsCreate(); ASSERT_NE(options, nullptr); spvOptimizerOptionsSetRunValidator(options, true); spv_binary binary = nullptr; EXPECT_EQ(SPV_SUCCESS, spvOptimizerRun(optimizer, spirv, sizeof(spirv) / sizeof(uint32_t), &binary, options)); ASSERT_NE(binary, nullptr); spvOptimizerOptionsDestroy(options); // Should remain unchanged EXPECT_EQ(binary->wordCount, sizeof(spirv) / sizeof(uint32_t)); EXPECT_EQ(memcmp(binary->code, spirv, sizeof(spirv) / sizeof(uint32_t)), 0); spvBinaryDestroy(binary); spvOptimizerDestroy(optimizer); } TEST(OptimizerCInterface, DefaultConsumerNoPassesForValidInput) { const uint32_t spirv[] = { 0x07230203, // Magic 0x00010100, // Version 1.1 0x00000000, // No Generator 0x00000003, // Bound 0x00000000, // Schema 0x00020011, // OpCapability 0x00000001, // Shader 0x00020011, // OpCapability 0x00000005, // Linkage 0x0003000E, // OpMemoryModel 0x00000000, // Logical 0x00000001, // GLSL450 0x00040015, // OpTypeInt 0x00000001, // %1 0x00000020, // 32 Bits 0x00000000, // Unsigned 0x0004002B, // OpConstant 0x00000001, // %1 0x00000002, // %2 0x00000001 // 1 }; auto optimizer = spvOptimizerCreate(SPV_ENV_UNIVERSAL_1_1); ASSERT_NE(optimizer, nullptr); // Do not register any passes auto options = spvOptimizerOptionsCreate(); ASSERT_NE(options, nullptr); spvOptimizerOptionsSetRunValidator(options, true); spv_binary binary = nullptr; EXPECT_EQ(SPV_SUCCESS, spvOptimizerRun(optimizer, spirv, sizeof(spirv) / sizeof(uint32_t), &binary, options)); ASSERT_NE(binary, nullptr); spvOptimizerOptionsDestroy(options); // Should remain unchanged EXPECT_EQ(binary->wordCount, sizeof(spirv) / sizeof(uint32_t)); EXPECT_EQ(memcmp(binary->code, spirv, sizeof(spirv) / sizeof(uint32_t)), 0); spvBinaryDestroy(binary); spvOptimizerDestroy(optimizer); } TEST(OptimizerCInterface, DefaultConsumerLegalizationPassesForValidInput) { const uint32_t spirv[] = { 0x07230203, // Magic 0x00010100, // Version 1.1 0x00000000, // No Generator 0x00000003, // Bound 0x00000000, // Schema 0x00020011, // OpCapability 0x00000001, // Shader 0x00020011, // OpCapability 0x00000005, // Linkage 0x0003000E, // OpMemoryModel 0x00000000, // Logical 0x00000001, // GLSL450 0x00040015, // OpTypeInt 0x00000001, // %1 0x00000020, // 32 Bits 0x00000000, // Unsigned 0x0004002B, // OpConstant 0x00000001, // %1 0x00000002, // %2 0x00000001 // 1 }; auto optimizer = spvOptimizerCreate(SPV_ENV_UNIVERSAL_1_1); ASSERT_NE(optimizer, nullptr); spvOptimizerRegisterLegalizationPasses(optimizer); auto options = spvOptimizerOptionsCreate(); ASSERT_NE(options, nullptr); spvOptimizerOptionsSetRunValidator(options, false); spv_binary binary = nullptr; EXPECT_EQ(SPV_SUCCESS, spvOptimizerRun(optimizer, spirv, sizeof(spirv) / sizeof(uint32_t), &binary, options)); ASSERT_NE(binary, nullptr); spvOptimizerOptionsDestroy(options); // Only check that SPV_SUCCESS is returned, do not verify output spvBinaryDestroy(binary); spvOptimizerDestroy(optimizer); } TEST(OptimizerCInterface, DefaultConsumerPerformancePassesForValidInput) { const uint32_t spirv[] = { 0x07230203, // Magic 0x00010100, // Version 1.1 0x00000000, // No Generator 0x00000003, // Bound 0x00000000, // Schema 0x00020011, // OpCapability 0x00000001, // Shader 0x00020011, // OpCapability 0x00000005, // Linkage 0x0003000E, // OpMemoryModel 0x00000000, // Logical 0x00000001, // GLSL450 0x00040015, // OpTypeInt 0x00000001, // %1 0x00000020, // 32 Bits 0x00000000, // Unsigned 0x0004002B, // OpConstant 0x00000001, // %1 0x00000002, // %2 0x00000001 // 1 }; const uint32_t expected_spirv[] = { 0x07230203, // Magic 0x00010100, // Version 1.1 0x00000000, // No Generator 0x00000001, // Bound 0x00000000, // Schema 0x00020011, // OpCapability 0x00000001, // Shader 0x00020011, // OpCapability 0x00000005, // Linkage 0x0003000E, // OpMemoryModel 0x00000000, // Logical 0x00000001 // GLSL450 }; auto optimizer = spvOptimizerCreate(SPV_ENV_UNIVERSAL_1_1); ASSERT_NE(optimizer, nullptr); spvOptimizerRegisterPerformancePasses(optimizer); auto options = spvOptimizerOptionsCreate(); ASSERT_NE(options, nullptr); spvOptimizerOptionsSetRunValidator(options, false); spv_binary binary = nullptr; EXPECT_EQ(SPV_SUCCESS, spvOptimizerRun(optimizer, spirv, sizeof(spirv) / sizeof(uint32_t), &binary, options)); ASSERT_NE(binary, nullptr); spvOptimizerOptionsDestroy(options); // Unreferenced OpTypeInt and OpConstant should be removed EXPECT_EQ(binary->wordCount, sizeof(expected_spirv) / sizeof(uint32_t)); EXPECT_EQ(memcmp(binary->code, expected_spirv, sizeof(expected_spirv) / sizeof(uint32_t)), 0); spvBinaryDestroy(binary); spvOptimizerDestroy(optimizer); } TEST(OptimizerCInterface, DefaultConsumerSizePassesForValidInput) { const uint32_t spirv[] = { 0x07230203, // Magic 0x00010100, // Version 1.1 0x00000000, // No Generator 0x00000003, // Bound 0x00000000, // Schema 0x00020011, // OpCapability 0x00000001, // Shader 0x00020011, // OpCapability 0x00000005, // Linkage 0x0003000E, // OpMemoryModel 0x00000000, // Logical 0x00000001, // GLSL450 0x00040015, // OpTypeInt 0x00000001, // %1 0x00000020, // 32 Bits 0x00000000, // Unsigned 0x0004002B, // OpConstant 0x00000001, // %1 0x00000002, // %2 0x00000001 // 1 }; const uint32_t expected_spirv[] = { 0x07230203, // Magic 0x00010100, // Version 1.1 0x00000000, // No Generator 0x00000001, // Bound 0x00000000, // Schema 0x00020011, // OpCapability 0x00000001, // Shader 0x00020011, // OpCapability 0x00000005, // Linkage 0x0003000E, // OpMemoryModel 0x00000000, // Logical 0x00000001 // GLSL450 }; auto optimizer = spvOptimizerCreate(SPV_ENV_UNIVERSAL_1_1); ASSERT_NE(optimizer, nullptr); spvOptimizerRegisterSizePasses(optimizer); auto options = spvOptimizerOptionsCreate(); ASSERT_NE(options, nullptr); spvOptimizerOptionsSetRunValidator(options, false); spv_binary binary = nullptr; EXPECT_EQ(SPV_SUCCESS, spvOptimizerRun(optimizer, spirv, sizeof(spirv) / sizeof(uint32_t), &binary, options)); ASSERT_NE(binary, nullptr); spvOptimizerOptionsDestroy(options); // Unreferenced OpTypeInt and OpConstant should be removed EXPECT_EQ(binary->wordCount, sizeof(expected_spirv) / sizeof(uint32_t)); EXPECT_EQ(memcmp(binary->code, expected_spirv, sizeof(expected_spirv) / sizeof(uint32_t)), 0); spvBinaryDestroy(binary); spvOptimizerDestroy(optimizer); } TEST(OptimizerCInterface, DefaultConsumerPassFromFlagForValidInput) { const uint32_t spirv[] = { 0x07230203, // Magic 0x00010100, // Version 1.1 0x00000000, // No Generator 0x00000003, // Bound 0x00000000, // Schema 0x00020011, // OpCapability 0x00000001, // Shader 0x00020011, // OpCapability 0x00000005, // Linkage 0x0003000E, // OpMemoryModel 0x00000000, // Logical 0x00000001, // GLSL450 0x00040015, // OpTypeInt 0x00000001, // %1 0x00000020, // 32 Bits 0x00000000, // Unsigned 0x0004002B, // OpConstant 0x00000001, // %1 0x00000002, // %2 0x00000001 // 1 }; const uint32_t expected_spirv[] = { 0x07230203, // Magic 0x00010100, // Version 1.1 0x00000000, // No Generator 0x00000001, // Bound 0x00000000, // Schema 0x00020011, // OpCapability 0x00000001, // Shader 0x00020011, // OpCapability 0x00000005, // Linkage 0x0003000E, // OpMemoryModel 0x00000000, // Logical 0x00000001 // GLSL450 }; auto optimizer = spvOptimizerCreate(SPV_ENV_UNIVERSAL_1_1); ASSERT_NE(optimizer, nullptr); EXPECT_TRUE(spvOptimizerRegisterPassFromFlag( optimizer, "--eliminate-dead-code-aggressive")); auto options = spvOptimizerOptionsCreate(); ASSERT_NE(options, nullptr); spvOptimizerOptionsSetRunValidator(options, false); spv_binary binary = nullptr; EXPECT_EQ(SPV_SUCCESS, spvOptimizerRun(optimizer, spirv, sizeof(spirv) / sizeof(uint32_t), &binary, options)); ASSERT_NE(binary, nullptr); spvOptimizerOptionsDestroy(options); // Unreferenced OpTypeInt and OpConstant should be removed EXPECT_EQ(binary->wordCount, sizeof(expected_spirv) / sizeof(uint32_t)); EXPECT_EQ(memcmp(binary->code, expected_spirv, sizeof(expected_spirv) / sizeof(uint32_t)), 0); spvBinaryDestroy(binary); spvOptimizerDestroy(optimizer); } TEST(OptimizerCInterface, DefaultConsumerPassesFromFlagsForValidInput) { const uint32_t spirv[] = { 0x07230203, // Magic 0x00010100, // Version 1.1 0x00000000, // No Generator 0x00000003, // Bound 0x00000000, // Schema 0x00020011, // OpCapability 0x00000001, // Shader 0x00020011, // OpCapability 0x00000005, // Linkage 0x0003000E, // OpMemoryModel 0x00000000, // Logical 0x00000001, // GLSL450 0x00040015, // OpTypeInt 0x00000001, // %1 0x00000020, // 32 Bits 0x00000000, // Unsigned 0x0004002B, // OpConstant 0x00000001, // %1 0x00000002, // %2 0x00000001 // 1 }; const uint32_t expected_spirv[] = { 0x07230203, // Magic 0x00010100, // Version 1.1 0x00000000, // No Generator 0x00000001, // Bound 0x00000000, // Schema 0x00020011, // OpCapability 0x00000001, // Shader 0x00020011, // OpCapability 0x00000005, // Linkage 0x0003000E, // OpMemoryModel 0x00000000, // Logical 0x00000001 // GLSL450 }; auto optimizer = spvOptimizerCreate(SPV_ENV_UNIVERSAL_1_1); ASSERT_NE(optimizer, nullptr); const char* flags[2] = { "--eliminate-dead-const", "--eliminate-dead-code-aggressive" }; EXPECT_TRUE(spvOptimizerRegisterPassesFromFlags( optimizer, flags, sizeof(flags) / sizeof(const char*))); auto options = spvOptimizerOptionsCreate(); ASSERT_NE(options, nullptr); spvOptimizerOptionsSetRunValidator(options, false); spv_binary binary = nullptr; EXPECT_EQ(SPV_SUCCESS, spvOptimizerRun(optimizer, spirv, sizeof(spirv) / sizeof(uint32_t), &binary, options)); ASSERT_NE(binary, nullptr); spvOptimizerOptionsDestroy(options); // Unreferenced OpTypeInt and OpConstant should be removed EXPECT_EQ(binary->wordCount, sizeof(expected_spirv) / sizeof(uint32_t)); EXPECT_EQ(memcmp(binary->code, expected_spirv, sizeof(expected_spirv) / sizeof(uint32_t)), 0); spvBinaryDestroy(binary); spvOptimizerDestroy(optimizer); } TEST(OptimizerCInterface, DefaultConsumerInvalidPassFromFlag) { auto optimizer = spvOptimizerCreate(SPV_ENV_UNIVERSAL_1_1); ASSERT_NE(optimizer, nullptr); EXPECT_FALSE(spvOptimizerRegisterPassFromFlag( optimizer, "--this-is-not-a-valid-pass")); spvOptimizerDestroy(optimizer); } TEST(OptimizerCInterface, DefaultConsumerInvalidPassesFromFlags) { auto optimizer = spvOptimizerCreate(SPV_ENV_UNIVERSAL_1_1); ASSERT_NE(optimizer, nullptr); const char* flags[2] = { "--eliminate-dead-const", "--this-is-not-a-valid-pass" }; EXPECT_FALSE(spvOptimizerRegisterPassesFromFlags( optimizer, flags, sizeof(flags) / sizeof(const char*))); spvOptimizerDestroy(optimizer); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/ccp_test.cpp000066400000000000000000001321671475742701700226340ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gtest/gtest.h" #include "source/opt/ccp_pass.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using CCPTest = PassTest<::testing::Test>; TEST_F(CCPTest, PropagateThroughPhis) { const std::string spv_asm = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %x %outparm OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %x "x" OpName %outparm "outparm" OpDecorate %x Flat OpDecorate %x Location 0 OpDecorate %outparm Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %bool = OpTypeBool %_ptr_Function_int = OpTypePointer Function %int %int_4 = OpConstant %int 4 %int_3 = OpConstant %int 3 %int_1 = OpConstant %int 1 %_ptr_Input_int = OpTypePointer Input %int %x = OpVariable %_ptr_Input_int Input %_ptr_Output_int = OpTypePointer Output %int %outparm = OpVariable %_ptr_Output_int Output %main = OpFunction %void None %3 %4 = OpLabel %5 = OpLoad %int %x %9 = OpIAdd %int %int_1 %int_3 %6 = OpSGreaterThan %bool %5 %int_3 OpSelectionMerge %25 None OpBranchConditional %6 %22 %23 %22 = OpLabel ; CHECK: OpCopyObject %int %int_4 %7 = OpCopyObject %int %9 OpBranch %25 %23 = OpLabel %8 = OpCopyObject %int %int_4 OpBranch %25 %25 = OpLabel ; %int_4 should have propagated to both OpPhi operands. ; CHECK: OpPhi %int %int_4 {{%\d+}} %int_4 {{%\d+}} %35 = OpPhi %int %7 %22 %8 %23 ; This function always returns 4. DCE should get rid of everything else. ; CHECK OpStore %outparm %int_4 OpStore %outparm %35 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(spv_asm, true); } TEST_F(CCPTest, SimplifyConditionals) { const std::string spv_asm = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %outparm OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %outparm "outparm" OpDecorate %outparm Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %bool = OpTypeBool %_ptr_Function_int = OpTypePointer Function %int %int_4 = OpConstant %int 4 %int_3 = OpConstant %int 3 %int_1 = OpConstant %int 1 %_ptr_Output_int = OpTypePointer Output %int %outparm = OpVariable %_ptr_Output_int Output %main = OpFunction %void None %3 %4 = OpLabel %9 = OpIAdd %int %int_4 %int_3 %6 = OpSGreaterThan %bool %9 %int_3 OpSelectionMerge %25 None ; CHECK: OpBranchConditional %true [[bb_taken:%\d+]] [[bb_not_taken:%\d+]] OpBranchConditional %6 %22 %23 ; CHECK: [[bb_taken]] = OpLabel %22 = OpLabel ; CHECK: OpCopyObject %int %int_7 %7 = OpCopyObject %int %9 OpBranch %25 ; CHECK: [[bb_not_taken]] = OpLabel %23 = OpLabel ; CHECK: [[id_not_evaluated:%\d+]] = OpCopyObject %int %int_4 %8 = OpCopyObject %int %int_4 OpBranch %25 %25 = OpLabel ; %int_7 should have propagated to the first OpPhi operand. But the else branch ; is not executable (conditional is always true), so no values should be ; propagated there and the value of the OpPhi should always be %int_7. ; CHECK: OpPhi %int %int_7 [[bb_taken]] [[id_not_evaluated]] [[bb_not_taken]] %35 = OpPhi %int %7 %22 %8 %23 ; Only the true path of the conditional is ever executed. The output of this ; function is always %int_7. ; CHECK: OpStore %outparm %int_7 OpStore %outparm %35 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(spv_asm, true); } TEST_F(CCPTest, SimplifySwitches) { const std::string spv_asm = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %outparm OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %outparm "outparm" OpDecorate %outparm Location 0 %void = OpTypeVoid %6 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_23 = OpConstant %int 23 %int_42 = OpConstant %int 42 %int_14 = OpConstant %int 14 %int_15 = OpConstant %int 15 %int_4 = OpConstant %int 4 %_ptr_Output_int = OpTypePointer Output %int %outparm = OpVariable %_ptr_Output_int Output %main = OpFunction %void None %6 %15 = OpLabel OpSelectionMerge %17 None OpSwitch %int_23 %17 10 %18 13 %19 23 %20 %18 = OpLabel OpBranch %17 %19 = OpLabel OpBranch %17 %20 = OpLabel OpBranch %17 %17 = OpLabel %24 = OpPhi %int %int_23 %15 %int_42 %18 %int_14 %19 %int_15 %20 ; The switch will always jump to label %20, which carries the value %int_15. ; CHECK: OpIAdd %int %int_15 %int_4 %22 = OpIAdd %int %24 %int_4 ; Consequently, the return value will always be %int_19. ; CHECK: OpStore %outparm %int_19 OpStore %outparm %22 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(spv_asm, true); } TEST_F(CCPTest, SimplifySwitchesDefaultBranch) { const std::string spv_asm = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %outparm OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %outparm "outparm" OpDecorate %outparm Location 0 %void = OpTypeVoid %6 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_42 = OpConstant %int 42 %int_4 = OpConstant %int 4 %int_1 = OpConstant %int 1 %_ptr_Output_int = OpTypePointer Output %int %outparm = OpVariable %_ptr_Output_int Output %main = OpFunction %void None %6 %13 = OpLabel %15 = OpIAdd %int %int_42 %int_4 OpSelectionMerge %16 None ; CHECK: OpSwitch %int_46 {{%\d+}} 10 {{%\d+}} OpSwitch %15 %17 10 %18 %18 = OpLabel OpBranch %16 %17 = OpLabel OpBranch %16 %16 = OpLabel %22 = OpPhi %int %int_42 %18 %int_1 %17 ; The switch will always jump to the default label %17. This carries the value ; %int_1. ; CHECK: OpIAdd %int %int_1 %int_4 %20 = OpIAdd %int %22 %int_4 ; Resulting in a return value of %int_5. ; CHECK: OpStore %outparm %int_5 OpStore %outparm %20 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(spv_asm, true); } TEST_F(CCPTest, SimplifyIntVector) { const std::string spv_asm = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %v "v" OpName %OutColor "OutColor" OpDecorate %OutColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %v4int = OpTypeVector %int 4 %_ptr_Function_v4int = OpTypePointer Function %v4int %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %int_3 = OpConstant %int 3 %int_4 = OpConstant %int 4 %14 = OpConstantComposite %v4int %int_1 %int_2 %int_3 %int_4 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Function_int = OpTypePointer Function %int %_ptr_Output_v4int = OpTypePointer Output %v4int %OutColor = OpVariable %_ptr_Output_v4int Output %main = OpFunction %void None %3 %5 = OpLabel %v = OpVariable %_ptr_Function_v4int Function OpStore %v %14 %18 = OpAccessChain %_ptr_Function_int %v %uint_0 %19 = OpLoad %int %18 ; The constant folder does not see through access chains. To get this, the ; vector would have to be scalarized. ; CHECK: [[result_id:%\d+]] = OpIAdd %int {{%\d+}} %int_1 %20 = OpIAdd %int %19 %int_1 %21 = OpAccessChain %_ptr_Function_int %v %uint_0 ; CHECK: OpStore {{%\d+}} [[result_id]] OpStore %21 %20 %24 = OpLoad %v4int %v OpStore %OutColor %24 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(spv_asm, true); } TEST_F(CCPTest, BadSimplifyFloatVector) { const std::string spv_asm = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %v "v" OpName %OutColor "OutColor" OpDecorate %OutColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %float_3 = OpConstant %float 3 %float_4 = OpConstant %float 4 %14 = OpConstantComposite %v4float %float_1 %float_2 %float_3 %float_4 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Function_float = OpTypePointer Function %float %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %3 %5 = OpLabel %v = OpVariable %_ptr_Function_v4float Function OpStore %v %14 %18 = OpAccessChain %_ptr_Function_float %v %uint_0 %19 = OpLoad %float %18 ; NOTE: This test should start failing once floating point folding is ; implemented (https://github.com/KhronosGroup/SPIRV-Tools/issues/943). ; This should be checking that we are adding %float_1 + %float_1. ; CHECK: [[result_id:%\d+]] = OpFAdd %float {{%\d+}} %float_1 %20 = OpFAdd %float %19 %float_1 %21 = OpAccessChain %_ptr_Function_float %v %uint_0 ; This should be checkint that we are storing %float_2 instead of result_it. ; CHECK: OpStore {{%\d+}} [[result_id]] OpStore %21 %20 %24 = OpLoad %v4float %v OpStore %OutColor %24 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(spv_asm, true); } TEST_F(CCPTest, NoLoadStorePropagation) { const std::string spv_asm = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %outparm OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %x "x" OpName %outparm "outparm" OpDecorate %outparm Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_23 = OpConstant %int 23 %_ptr_Output_int = OpTypePointer Output %int %outparm = OpVariable %_ptr_Output_int Output %main = OpFunction %void None %3 %5 = OpLabel %x = OpVariable %_ptr_Function_int Function OpStore %x %int_23 ; int_23 should not propagate into this load. ; CHECK: [[load_id:%\d+]] = OpLoad %int %x %12 = OpLoad %int %x ; Nor into this copy operation. ; CHECK: [[copy_id:%\d+]] = OpCopyObject %int [[load_id]] %13 = OpCopyObject %int %12 ; Likewise here. ; CHECK: OpStore %outparm [[copy_id]] OpStore %outparm %13 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(spv_asm, true); } TEST_F(CCPTest, HandleAbortInstructions) { const std::string spv_asm = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource HLSL 500 OpName %main "main" %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %bool = OpTypeBool ; CHECK: %true = OpConstantTrue %bool %int_3 = OpConstant %int 3 %int_1 = OpConstant %int 1 %main = OpFunction %void None %3 %4 = OpLabel %9 = OpIAdd %int %int_3 %int_1 %6 = OpSGreaterThan %bool %9 %int_3 OpSelectionMerge %23 None ; CHECK: OpBranchConditional %true {{%\d+}} {{%\d+}} OpBranchConditional %6 %22 %23 %22 = OpLabel OpKill %23 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(spv_asm, true); } TEST_F(CCPTest, SSAWebCycles) { // Test reduced from https://github.com/KhronosGroup/SPIRV-Tools/issues/1159 // When there is a cycle in the SSA def-use web, the propagator was getting // into an infinite loop. SSA edges for Phi instructions should not be // added to the edges to simulate. const std::string spv_asm = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_4 = OpConstant %int 4 %bool = OpTypeBool %int_1 = OpConstant %int 1 %_ptr_Output_int = OpTypePointer Output %int %main = OpFunction %void None %3 %5 = OpLabel OpBranch %11 %11 = OpLabel %29 = OpPhi %int %int_0 %5 %22 %14 %30 = OpPhi %int %int_0 %5 %25 %14 OpLoopMerge %13 %14 None OpBranch %15 %15 = OpLabel %19 = OpSLessThan %bool %30 %int_4 ; CHECK: OpBranchConditional %true {{%\d+}} {{%\d+}} OpBranchConditional %19 %12 %13 %12 = OpLabel ; CHECK: OpIAdd %int %int_0 %int_0 %22 = OpIAdd %int %29 %30 OpBranch %14 %14 = OpLabel ; CHECK: OpPhi %int %int_0 {{%\d+}} %25 = OpPhi %int %30 %12 OpBranch %11 %13 = OpLabel OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(spv_asm, true); } TEST_F(CCPTest, LoopInductionVariables) { // Test reduced from https://github.com/KhronosGroup/SPIRV-Tools/issues/1143 // We are failing to properly consider the induction variable for this loop // as Varying. const std::string spv_asm = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 430 OpName %main "main" %void = OpTypeVoid %5 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %bool = OpTypeBool %int_1 = OpConstant %int 1 %main = OpFunction %void None %5 %12 = OpLabel OpBranch %13 %13 = OpLabel ; This Phi should not have all constant arguments: ; CHECK: [[phi_id:%\d+]] = OpPhi %int %int_0 {{%\d+}} {{%\d+}} {{%\d+}} %22 = OpPhi %int %int_0 %12 %21 %15 OpLoopMerge %14 %15 None OpBranch %16 %16 = OpLabel ; The Phi should never be considered to have the value %int_0. ; CHECK: [[branch_selector:%\d+]] = OpSLessThan %bool [[phi_id]] %int_10 %18 = OpSLessThan %bool %22 %int_10 ; This conditional was wrongly converted into an always-true jump due to the ; bad meet evaluation of %22. ; CHECK: OpBranchConditional [[branch_selector]] {{%\d+}} {{%\d+}} OpBranchConditional %18 %19 %14 %19 = OpLabel OpBranch %15 %15 = OpLabel ; CHECK: OpIAdd %int [[phi_id]] %int_1 %21 = OpIAdd %int %22 %int_1 OpBranch %13 %14 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(spv_asm, true); } TEST_F(CCPTest, HandleCompositeWithUndef) { // Check to make sure that CCP does not crash when given a "constant" struct // with an undef. If at a later time CCP is enhanced to optimize this case, // it is not wrong. const std::string spv_asm = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource HLSL 500 OpName %main "main" %void = OpTypeVoid %4 = OpTypeFunction %void %int = OpTypeInt 32 1 %bool = OpTypeBool %_struct_7 = OpTypeStruct %int %int %int_1 = OpConstant %int 1 %9 = OpUndef %int %10 = OpConstantComposite %_struct_7 %int_1 %9 %main = OpFunction %void None %4 %11 = OpLabel %12 = OpCompositeExtract %int %10 0 %13 = OpCopyObject %int %12 OpReturn OpFunctionEnd )"; auto res = SinglePassRunToBinary(spv_asm, true); EXPECT_EQ(std::get<1>(res), Pass::Status::SuccessWithoutChange); } TEST_F(CCPTest, SkipSpecConstantInstrucitons) { const std::string spv_asm = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource HLSL 500 OpName %main "main" %void = OpTypeVoid %4 = OpTypeFunction %void %bool = OpTypeBool %10 = OpSpecConstantFalse %bool %main = OpFunction %void None %4 %11 = OpLabel OpBranchConditional %10 %L1 %L2 %L1 = OpLabel OpReturn %L2 = OpLabel OpReturn OpFunctionEnd )"; auto res = SinglePassRunToBinary(spv_asm, true); EXPECT_EQ(std::get<1>(res), Pass::Status::SuccessWithoutChange); } TEST_F(CCPTest, FoldConstantCompositeInstrucitonsWithSpecConst) { const std::string spv_asm = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %4 = OpTypeFunction %void %bool = OpTypeBool %v3bool = OpTypeVector %bool 3 %_struct_8 = OpTypeStruct %v3bool %true = OpConstantTrue %bool ; CHECK: [[spec_const:%\w+]] = OpSpecConstantComposite %v3bool %11 = OpSpecConstantComposite %v3bool %true %true %true %12 = OpConstantComposite %_struct_8 %11 ; CHECK: OpFunction %1 = OpFunction %void None %4 %29 = OpLabel %31 = OpCompositeExtract %v3bool %12 0 ; CHECK: OpCompositeExtract %bool [[spec_const]] 0 %32 = OpCompositeExtract %bool %31 0 OpReturn OpFunctionEnd )"; auto result = SinglePassRunAndMatch(spv_asm, true); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(CCPTest, UpdateSubsequentPhisToVarying) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" %in OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %bool = OpTypeBool %int = OpTypeInt 32 1 %false = OpConstantFalse %bool %int0 = OpConstant %int 0 %int1 = OpConstant %int 1 %int6 = OpConstant %int 6 %int_ptr_Input = OpTypePointer Input %int %in = OpVariable %int_ptr_Input Input %undef = OpUndef %int ; Although no constants are propagated in this function, the propagator ; generates a new %true value while visiting conditional statements. ; CHECK: %true = OpConstantTrue %bool %functy = OpTypeFunction %void %func = OpFunction %void None %functy %1 = OpLabel OpBranch %2 %2 = OpLabel %outer_phi = OpPhi %int %int0 %1 %outer_add %15 %cond1 = OpSLessThanEqual %bool %outer_phi %int6 OpLoopMerge %3 %15 None OpBranchConditional %cond1 %4 %3 %4 = OpLabel %ld = OpLoad %int %in %cond2 = OpSGreaterThanEqual %bool %int1 %ld OpSelectionMerge %10 None OpBranchConditional %cond2 %8 %9 %8 = OpLabel OpBranch %10 %9 = OpLabel OpBranch %10 %10 = OpLabel %extra_phi = OpPhi %int %outer_phi %8 %outer_phi %9 OpBranch %11 %11 = OpLabel %inner_phi = OpPhi %int %int0 %10 %inner_add %13 %cond3 = OpSLessThanEqual %bool %inner_phi %int6 OpLoopMerge %14 %13 None OpBranchConditional %cond3 %12 %14 %12 = OpLabel OpBranch %13 %13 = OpLabel %inner_add = OpIAdd %int %inner_phi %int1 OpBranch %11 %14 = OpLabel OpBranch %15 %15 = OpLabel %outer_add = OpIAdd %int %extra_phi %int1 OpBranch %2 %3 = OpLabel OpReturn OpFunctionEnd )"; auto result = SinglePassRunAndMatch(text, true); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(CCPTest, UndefInPhi) { const std::string text = R"( ; CHECK: [[uint1:%\w+]] = OpConstant {{%\w+}} 1 ; CHECK: [[phi:%\w+]] = OpPhi ; CHECK: OpIAdd {{%\w+}} [[phi]] [[uint1]] OpCapability Kernel OpCapability Linkage OpMemoryModel Logical OpenCL OpDecorate %1 LinkageAttributes "func" Export %void = OpTypeVoid %bool = OpTypeBool %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %7 = OpUndef %uint %8 = OpTypeFunction %void %bool %1 = OpFunction %void None %8 %9 = OpFunctionParameter %bool %10 = OpLabel OpBranchConditional %9 %11 %12 %11 = OpLabel OpBranch %13 %12 = OpLabel OpBranch %14 %14 = OpLabel OpBranchConditional %9 %13 %15 %15 = OpLabel OpBranch %13 %13 = OpLabel %16 = OpPhi %uint %uint_0 %11 %7 %14 %uint_1 %15 %17 = OpIAdd %uint %16 %uint_1 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } // Just test to make sure the constant fold rules are being used. Will rely on // the folding test for specific testing of specific rules. TEST_F(CCPTest, UseConstantFoldingRules) { const std::string text = R"( ; CHECK: [[float1:%\w+]] = OpConstant {{%\w+}} 1 ; CHECK: OpReturnValue [[float1]] OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 LinkageAttributes "func" Export %void = OpTypeVoid %bool = OpTypeBool %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %float_1 = OpConstant %float 1 %8 = OpTypeFunction %float %1 = OpFunction %float None %8 %10 = OpLabel %17 = OpFAdd %float %float_0 %float_1 OpReturnValue %17 OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } // Test for #1300. Previously value for %5 would not settle during simulation. TEST_F(CCPTest, SettlePhiLatticeValue) { const std::string text = R"( OpCapability Kernel OpCapability Linkage OpMemoryModel Logical OpenCL OpDecorate %func LinkageAttributes "func" Export %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %false = OpConstantFalse %bool %functy = OpTypeFunction %void %func = OpFunction %void None %functy %1 = OpLabel OpBranchConditional %true %2 %3 %3 = OpLabel OpBranch %2 %2 = OpLabel %5 = OpPhi %bool %true %1 %false %3 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunToBinary(text, true); } TEST_F(CCPTest, NullBranchCondition) { const std::string text = R"( ; CHECK: [[int1:%\w+]] = OpConstant {{%\w+}} 1 ; CHECK: [[int2:%\w+]] = OpConstant {{%\w+}} 2 ; CHECK: OpIAdd {{%\w+}} [[int1]] [[int2]] OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %bool = OpTypeBool %int = OpTypeInt 32 1 %null = OpConstantNull %bool %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %functy = OpTypeFunction %void %func = OpFunction %void None %functy %1 = OpLabel OpSelectionMerge %2 None OpBranchConditional %null %2 %3 %3 = OpLabel OpBranch %2 %2 = OpLabel %phi = OpPhi %int %int_1 %1 %int_2 %3 %add = OpIAdd %int %int_1 %phi OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(CCPTest, UndefBranchCondition) { const std::string text = R"( ; CHECK: [[int1:%\w+]] = OpConstant {{%\w+}} 1 ; CHECK: [[phi:%\w+]] = OpPhi ; CHECK: OpIAdd {{%\w+}} [[int1]] [[phi]] OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %bool = OpTypeBool %int = OpTypeInt 32 1 %undef = OpUndef %bool %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %functy = OpTypeFunction %void %func = OpFunction %void None %functy %1 = OpLabel OpSelectionMerge %2 None OpBranchConditional %undef %2 %3 %3 = OpLabel OpBranch %2 %2 = OpLabel %phi = OpPhi %int %int_1 %1 %int_2 %3 %add = OpIAdd %int %int_1 %phi OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(CCPTest, NullSwitchCondition) { const std::string text = R"( ; CHECK: [[int1:%\w+]] = OpConstant {{%\w+}} 1 ; CHECK: [[int2:%\w+]] = OpConstant {{%\w+}} 2 ; CHECK: OpIAdd {{%\w+}} [[int1]] [[int2]] OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %int = OpTypeInt 32 1 %null = OpConstantNull %int %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %functy = OpTypeFunction %void %func = OpFunction %void None %functy %1 = OpLabel OpSelectionMerge %2 None OpSwitch %null %2 0 %3 %3 = OpLabel OpBranch %2 %2 = OpLabel %phi = OpPhi %int %int_1 %1 %int_2 %3 %add = OpIAdd %int %int_1 %phi OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(CCPTest, UndefSwitchCondition) { const std::string text = R"( ; CHECK: [[int1:%\w+]] = OpConstant {{%\w+}} 1 ; CHECK: [[phi:%\w+]] = OpPhi ; CHECK: OpIAdd {{%\w+}} [[int1]] [[phi]] OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %int = OpTypeInt 32 1 %undef = OpUndef %int %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %functy = OpTypeFunction %void %func = OpFunction %void None %functy %1 = OpLabel OpSelectionMerge %2 None OpSwitch %undef %2 0 %3 %3 = OpLabel OpBranch %2 %2 = OpLabel %phi = OpPhi %int %int_1 %1 %int_2 %3 %add = OpIAdd %int %int_1 %phi OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } // Test for #1361. TEST_F(CCPTest, CompositeConstructOfGlobalValue) { const std::string text = R"( ; CHECK: [[phi:%\w+]] = OpPhi ; CHECK-NEXT: OpCompositeExtract {{%\w+}} [[phi]] 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" %in OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %int = OpTypeInt 32 1 %bool = OpTypeBool %functy = OpTypeFunction %void %ptr_int_Input = OpTypePointer Input %int %in = OpVariable %ptr_int_Input Input %struct = OpTypeStruct %ptr_int_Input %ptr_int_Input %struct_null = OpConstantNull %struct %func = OpFunction %void None %functy %1 = OpLabel OpBranch %2 %2 = OpLabel %phi = OpPhi %struct %struct_null %1 %5 %4 %extract = OpCompositeExtract %ptr_int_Input %phi 0 OpLoopMerge %3 %4 None OpBranch %4 %4 = OpLabel %5 = OpCompositeConstruct %struct %in %in OpBranch %2 %3 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(CCPTest, FoldWithDecoration) { const std::string text = R"( ; CHECK: OpCapability ; CHECK-NOT: OpDecorate ; CHECK: OpFunctionEnd OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpDecorate %3 RelaxedPrecision %void = OpTypeVoid %5 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %float_0 = OpConstant %float 0 %v4float = OpTypeVector %float 4 %10 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %2 = OpFunction %void None %5 %11 = OpLabel %3 = OpVectorShuffle %v3float %10 %10 0 1 2 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(CCPTest, DebugSimpleFoldConstant) { const std::string text = R"( OpCapability Shader OpCapability Linkage %ext = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 %file_name = OpString "test" %float_name = OpString "float" %main_name = OpString "main" %f_name = OpString "f" OpDecorate %1 LinkageAttributes "func" Export %void = OpTypeVoid %bool = OpTypeBool %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 ; CHECK: [[float1:%\w+]] = OpConstant {{%\w+}} 1 %float_1 = OpConstant %float 1 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %8 = OpTypeFunction %float %null_expr = OpExtInst %void %ext DebugExpression %src = OpExtInst %void %ext DebugSource %file_name %cu = OpExtInst %void %ext DebugCompilationUnit 1 4 %src HLSL %dbg_tf = OpExtInst %void %ext DebugTypeBasic %float_name %uint_32 Float %main_ty = OpExtInst %void %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %dbg_tf %dbg_main = OpExtInst %void %ext DebugFunction %main_name %main_ty %src 0 0 %cu %main_name FlagIsProtected|FlagIsPrivate 10 %1 %dbg_f = OpExtInst %void %ext DebugLocalVariable %f_name %dbg_tf %src 0 0 %dbg_main FlagIsLocal %1 = OpFunction %float None %8 %10 = OpLabel ; CHECK: OpExtInst %void [[ext:%\w+]] DebugScope ; CHECK: OpLine [[file:%\w+]] 1 0 ; CHECK: OpExtInst %void [[ext]] DebugValue {{%\w+}} %float_1 %s0 = OpExtInst %void %ext DebugScope %dbg_main OpLine %file_name 1 0 %17 = OpFAdd %float %float_0 %float_1 %val = OpExtInst %void %ext DebugValue %dbg_f %17 %null_expr ; CHECK: OpLine [[file]] 2 0 ; CHECK: OpReturnValue [[float1]] OpLine %file_name 2 0 OpReturnValue %17 OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(CCPTest, DebugFoldMultipleForSingleConstant) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" %ext = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %outparm OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 %file_name = OpString "test" %float_name = OpString "float" %main_name = OpString "main" %f_name = OpString "f" OpName %main "main" OpName %outparm "outparm" OpDecorate %outparm Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %bool = OpTypeBool %_ptr_Function_int = OpTypePointer Function %int %int_4 = OpConstant %int 4 %int_3 = OpConstant %int 3 %int_1 = OpConstant %int 1 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %_ptr_Output_int = OpTypePointer Output %int %outparm = OpVariable %_ptr_Output_int Output %null_expr = OpExtInst %void %ext DebugExpression %src = OpExtInst %void %ext DebugSource %file_name %cu = OpExtInst %void %ext DebugCompilationUnit 1 4 %src HLSL %dbg_tf = OpExtInst %void %ext DebugTypeBasic %float_name %uint_32 Float %main_ty = OpExtInst %void %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %dbg_tf %dbg_main = OpExtInst %void %ext DebugFunction %main_name %main_ty %src 0 0 %cu %main_name FlagIsProtected|FlagIsPrivate 10 %main %bb0 = OpExtInst %void %ext DebugLexicalBlock %src 0 0 %dbg_main %bb1 = OpExtInst %void %ext DebugLexicalBlock %src 1 0 %dbg_main %bb2 = OpExtInst %void %ext DebugLexicalBlock %src 2 0 %dbg_main %bb3 = OpExtInst %void %ext DebugLexicalBlock %src 3 0 %dbg_main %dbg_f0 = OpExtInst %void %ext DebugLocalVariable %f_name %dbg_tf %src 0 0 %dbg_main FlagIsLocal %dbg_f1 = OpExtInst %void %ext DebugLocalVariable %f_name %dbg_tf %src 1 0 %dbg_main FlagIsLocal %dbg_f2 = OpExtInst %void %ext DebugLocalVariable %f_name %dbg_tf %src 2 0 %dbg_main FlagIsLocal %main = OpFunction %void None %3 %4 = OpLabel ; CHECK: OpExtInst %void [[ext:%\w+]] DebugScope ; CHECK: OpLine [[file:%\w+]] 1 0 ; CHECK: OpIAdd %int %int_4 %int_3 ; CHECK: OpExtInst %void [[ext]] DebugValue {{%\w+}} %int_7 %s0 = OpExtInst %void %ext DebugScope %bb0 OpLine %file_name 1 0 %9 = OpIAdd %int %int_4 %int_3 %val0 = OpExtInst %void %ext DebugValue %dbg_f0 %9 %null_expr ; CHECK: OpLine [[file]] 2 0 ; CHECK: OpSGreaterThan %bool %int_7 %int_3 ; CHECK: OpExtInst %void [[ext]] DebugValue {{%\w+}} %true OpLine %file_name 2 0 %6 = OpSGreaterThan %bool %9 %int_3 %val1 = OpExtInst %void %ext DebugValue %dbg_f1 %6 %null_expr OpSelectionMerge %25 None OpBranchConditional %6 %22 %23 %22 = OpLabel %s1 = OpExtInst %void %ext DebugScope %bb1 %7 = OpCopyObject %int %9 %val2 = OpExtInst %void %ext DebugValue %dbg_f2 %7 %null_expr OpBranch %25 %23 = OpLabel %s2 = OpExtInst %void %ext DebugScope %bb2 %8 = OpCopyObject %int %int_4 OpBranch %25 %25 = OpLabel %s3 = OpExtInst %void %ext DebugScope %bb3 %35 = OpPhi %int %7 %22 %8 %23 OpStore %outparm %35 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } // Test from https://github.com/KhronosGroup/SPIRV-Tools/issues/3636 TEST_F(CCPTest, CCPNoChangeFailure) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpConstant %6 2 %13 = OpConstant %6 4 %21 = OpConstant %6 1 %10 = OpTypeBool %17 = OpTypePointer Function %6 ; CCP is generating two new constants during propagation that end up being ; dead because they cannot be replaced anywhere in the IR. CCP was wrongly ; considering the IR to be unmodified because of this. ; CHECK: %true = OpConstantTrue %bool ; CHECK: %int_3 = OpConstant %int 3 %4 = OpFunction %2 None %3 %11 = OpLabel OpBranch %5 %5 = OpLabel %23 = OpPhi %6 %7 %11 %20 %15 %9 = OpSLessThan %10 %23 %13 OpLoopMerge %8 %15 None OpBranchConditional %9 %15 %8 %15 = OpLabel %20 = OpIAdd %6 %23 %21 OpBranch %5 %8 = OpLabel OpReturn OpFunctionEnd )"; auto result = SinglePassRunAndMatch(text, true); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } // Test from https://github.com/KhronosGroup/SPIRV-Tools/issues/3738 // Similar to the previous one but more than one constant is generated in a // single call to the instruction folder. TEST_F(CCPTest, CCPNoChangeFailureSeveralConstantsDuringFolding) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft %void = OpTypeVoid %4 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %bool = OpTypeBool %v3bool = OpTypeVector %bool 3 %float_0 = OpConstant %float 0 %12 = OpConstantComposite %v3float %float_0 %float_0 %float_0 %float_0_300000012 = OpConstant %float 0.300000012 %14 = OpConstantComposite %v3float %float_0_300000012 %float_0_300000012 %float_0_300000012 ; CCP is generating several constants during a single instruction evaluation. ; When folding %19, it generates the constants %true and %24. They are dead ; because they cannot be replaced anywhere in the IR. CCP was wrongly ; considering the IR to be unmodified because of this. ; ; CHECK: %true = OpConstantTrue %bool ; CHECK: %24 = OpConstantComposite %v3bool %true %true %true ; CHECK: %float_1 = OpConstant %float 1 ; CHECK: %float_0_699999988 = OpConstant %float 0.699999988 %2 = OpFunction %void None %4 %15 = OpLabel OpBranch %16 %16 = OpLabel %17 = OpPhi %v3float %12 %15 %14 %18 %19 = OpFOrdLessThan %v3bool %17 %14 %20 = OpAll %bool %19 OpLoopMerge %21 %18 None OpBranchConditional %20 %18 %21 %18 = OpLabel OpBranch %16 %21 = OpLabel %22 = OpExtInst %v3float %1 FMix %12 %17 %14 OpReturn OpFunctionEnd )"; auto result = SinglePassRunAndMatch(text, true); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } // Test from https://github.com/KhronosGroup/SPIRV-Tools/issues/3991 // Similar to the previous one but constants are created even when no // instruction are ever folded during propagation. TEST_F(CCPTest, CCPNoChangeFailureWithUnfoldableInstr) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft %void = OpTypeVoid %4 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %bool = OpTypeBool %float_0 = OpConstant %float 0 %11 = OpConstantComposite %v3float %float_0 %float_0 %float_0 %float_0_300000012 = OpConstant %float 0.300000012 %13 = OpConstantComposite %v3float %float_0_300000012 %float_0_300000012 %float_0_300000012 ; CCP generates two constants when trying to fold an instruction, which it ; ultimately fails to fold. The instruction folder in CCP was only ; checking for newly added constants if the instruction folds successfully. ; ; CHECK: %float_1 = OpConstant %float 1 ; CHECK: %float_0_699999988 = OpConstant %float 0.69999998 %2 = OpFunction %void None %4 %14 = OpLabel %15 = OpBitcast %uint %float_0_300000012 %16 = OpUGreaterThan %bool %15 %uint_0 OpBranch %17 %17 = OpLabel %18 = OpPhi %v3float %11 %14 %13 %19 OpLoopMerge %20 %19 None OpBranchConditional %16 %19 %20 %19 = OpLabel OpBranch %17 %20 = OpLabel %21 = OpExtInst %v3float %1 FMix %11 %18 %13 OpReturn OpFunctionEnd )"; auto result = SinglePassRunAndMatch(text, true); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(CCPTest, FunctionDeclaration) { // Make sure the pass works with a function declaration that is called. const std::string text = R"(OpCapability Addresses OpCapability Linkage OpCapability Kernel OpCapability Int8 %1 = OpExtInstImport "OpenCL.std" OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %2 "_Z23julia__1166_kernel_77094Bool" OpExecutionMode %2 ContractionOff OpSource Unknown 0 OpDecorate %3 LinkageAttributes "julia_error_7712" Import %void = OpTypeVoid %5 = OpTypeFunction %void %3 = OpFunction %void None %5 OpFunctionEnd %2 = OpFunction %void None %5 %6 = OpLabel %7 = OpFunctionCall %void %3 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(text, text, false); } // Test from https://github.com/KhronosGroup/SPIRV-Tools/issues/4462. // The test was causing a lateral movement in the constant lattice, which was // not being detected as varying by CCP. In this test, FClamp is evaluated // twice. On the first evaluation, if computes FClamp(0.5, 0.5, -1) which // returns -1. On the second evaluation, it computes FClamp(0.5, 0.5, VARYING) // which returns 0.5. // // Both fold() computations are correct given the semantics of FClamp() but // this causes a lateral transition in the constant lattice which was not being // considered VARYING by CCP. TEST_F(CCPTest, LateralLatticeTransition) { const std::string text = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragCoord %outColor OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %gl_FragCoord "gl_FragCoord" OpName %outColor "outColor" OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorate %outColor Location 0 %void = OpTypeVoid %6 = OpTypeFunction %void %float = OpTypeFloat 32 %float_0_5 = OpConstant %float 0.5 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %float_0 = OpConstant %float 0 %bool = OpTypeBool %float_n1 = OpConstant %float -1 %float_1 = OpConstant %float 1 %_ptr_Output_v4float = OpTypePointer Output %v4float %outColor = OpVariable %_ptr_Output_v4float Output ; This constant is created during the first evaluation of the CompositeConstruct ; CHECK: [[new_constant:%\d+]] = OpConstantComposite %v4float %float_n1 %float_0_5 %float_0 %float_1 %main = OpFunction %void None %6 %19 = OpLabel %20 = OpAccessChain %_ptr_Input_float %gl_FragCoord %uint_0 %21 = OpLoad %float %20 %22 = OpFOrdLessThan %bool %21 %float_0 OpSelectionMerge %23 None OpBranchConditional %22 %24 %25 %24 = OpLabel OpBranch %23 %25 = OpLabel OpBranch %26 %26 = OpLabel OpBranch %23 %23 = OpLabel %27 = OpPhi %float %float_n1 %24 %float_0_5 %26 %28 = OpExtInst %float %1 FClamp %float_0_5 %float_0_5 %27 ; On first evaluation, the result from FClamp will return 0.5. ; But on second evaluation, FClamp should return VARYING. Check ; that CCP is not keeping the first result. ; CHECK-NOT: %29 = OpCompositeConstruct %v4float %float_0_5 %float_0_5 %float_0 %float_1 %29 = OpCompositeConstruct %v4float %28 %float_0_5 %float_0 %float_1 ; CHECK-NOT: OpCopyObject %v4float [[new_constant]] %42 = OpCopyObject %v4float %29 ; CHECK-NOT: OpStore %outColor [[new_constant]] OpStore %outColor %42 OpReturn OpFunctionEnd )"; auto result = SinglePassRunAndMatch(text, true); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/cfg_cleanup_test.cpp000066400000000000000000000327101475742701700243260ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using CFGCleanupTest = PassTest<::testing::Test>; TEST_F(CFGCleanupTest, RemoveUnreachableBlocks) { const std::string declarations = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %inf %outf4 OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %inf "inf" OpName %outf4 "outf4" OpDecorate %inf Location 0 OpDecorate %outf4 Location 0 %void = OpTypeVoid %6 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Input_float = OpTypePointer Input %float %inf = OpVariable %_ptr_Input_float Input %float_2 = OpConstant %float 2 %bool = OpTypeBool %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %outf4 = OpVariable %_ptr_Output_v4float Output %float_n0_5 = OpConstant %float -0.5 )"; const std::string body_before = R"(%main = OpFunction %void None %6 %14 = OpLabel OpBranch %18 %19 = OpLabel %20 = OpLoad %float %inf %21 = OpCompositeConstruct %v4float %20 %20 %20 %20 OpStore %outf4 %21 OpBranch %17 %18 = OpLabel %22 = OpLoad %float %inf %23 = OpFAdd %float %22 %float_n0_5 %24 = OpCompositeConstruct %v4float %23 %23 %23 %23 OpStore %outf4 %24 OpBranch %17 %17 = OpLabel OpReturn OpFunctionEnd )"; const std::string body_after = R"(%main = OpFunction %void None %6 %14 = OpLabel OpBranch %15 %15 = OpLabel %20 = OpLoad %float %inf %21 = OpFAdd %float %20 %float_n0_5 %22 = OpCompositeConstruct %v4float %21 %21 %21 %21 OpStore %outf4 %22 OpBranch %19 %19 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(declarations + body_before, declarations + body_after, true, true); } TEST_F(CFGCleanupTest, RemoveDecorations) { const std::string before = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpName %main "main" OpName %x "x" OpName %dead "dead" OpDecorate %x RelaxedPrecision OpDecorate %dead RelaxedPrecision %void = OpTypeVoid %6 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_2 = OpConstant %float 2 %float_4 = OpConstant %float 4 %main = OpFunction %void None %6 %14 = OpLabel %x = OpVariable %_ptr_Function_float Function OpBranch %18 %19 = OpLabel %dead = OpVariable %_ptr_Function_float Function OpStore %dead %float_2 OpBranch %17 %18 = OpLabel OpStore %x %float_4 OpBranch %17 %17 = OpLabel OpReturn OpFunctionEnd )"; const std::string after = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpName %main "main" OpName %x "x" OpDecorate %x RelaxedPrecision %void = OpTypeVoid %6 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_2 = OpConstant %float 2 %float_4 = OpConstant %float 4 %main = OpFunction %void None %6 %11 = OpLabel %x = OpVariable %_ptr_Function_float Function OpBranch %12 %12 = OpLabel OpStore %x %float_4 OpBranch %14 %14 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(before, after, true, true); } TEST_F(CFGCleanupTest, UpdatePhis) { const std::string before = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %y %outparm OpExecutionMode %main OriginUpperLeft OpName %main "main" OpName %y "y" OpName %outparm "outparm" OpDecorate %y Flat OpDecorate %y Location 0 OpDecorate %outparm Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %_ptr_Input_int = OpTypePointer Input %int %y = OpVariable %_ptr_Input_int Input %int_10 = OpConstant %int 10 %bool = OpTypeBool %int_42 = OpConstant %int 42 %int_23 = OpConstant %int 23 %int_5 = OpConstant %int 5 %_ptr_Output_int = OpTypePointer Output %int %outparm = OpVariable %_ptr_Output_int Output %main = OpFunction %void None %3 %5 = OpLabel %11 = OpLoad %int %y OpBranch %21 %16 = OpLabel %20 = OpIAdd %int %11 %int_42 OpBranch %17 %21 = OpLabel %24 = OpISub %int %11 %int_23 OpBranch %17 %17 = OpLabel %31 = OpPhi %int %20 %16 %24 %21 %27 = OpIAdd %int %31 %int_5 OpStore %outparm %27 OpReturn OpFunctionEnd )"; const std::string after = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %y %outparm OpExecutionMode %main OriginUpperLeft OpName %main "main" OpName %y "y" OpName %outparm "outparm" OpDecorate %y Flat OpDecorate %y Location 0 OpDecorate %outparm Location 0 %void = OpTypeVoid %6 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %_ptr_Input_int = OpTypePointer Input %int %y = OpVariable %_ptr_Input_int Input %int_10 = OpConstant %int 10 %bool = OpTypeBool %int_42 = OpConstant %int 42 %int_23 = OpConstant %int 23 %int_5 = OpConstant %int 5 %_ptr_Output_int = OpTypePointer Output %int %outparm = OpVariable %_ptr_Output_int Output %main = OpFunction %void None %6 %16 = OpLabel %17 = OpLoad %int %y OpBranch %18 %18 = OpLabel %22 = OpISub %int %17 %int_23 OpBranch %21 %21 = OpLabel %23 = OpPhi %int %22 %18 %24 = OpIAdd %int %23 %int_5 OpStore %outparm %24 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(before, after, true, true); } TEST_F(CFGCleanupTest, RemoveNamedLabels) { const std::string before = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 430 OpName %main "main" OpName %dead "dead" %void = OpTypeVoid %5 = OpTypeFunction %void %main = OpFunction %void None %5 %6 = OpLabel OpReturn %dead = OpLabel OpReturn OpFunctionEnd)"; const std::string after = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 430 OpName %main "main" %void = OpTypeVoid %5 = OpTypeFunction %void %main = OpFunction %void None %5 %6 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(before, after, true, true); } TEST_F(CFGCleanupTest, RemovePhiArgsFromFarBlocks) { const std::string before = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %y %outparm OpExecutionMode %main OriginUpperLeft OpName %main "main" OpName %y "y" OpName %outparm "outparm" OpDecorate %y Flat OpDecorate %y Location 0 OpDecorate %outparm Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %_ptr_Input_int = OpTypePointer Input %int %y = OpVariable %_ptr_Input_int Input %int_42 = OpConstant %int 42 %_ptr_Output_int = OpTypePointer Output %int %outparm = OpVariable %_ptr_Output_int Output %int_14 = OpConstant %int 14 %int_15 = OpConstant %int 15 %int_5 = OpConstant %int 5 %main = OpFunction %void None %3 %5 = OpLabel OpBranch %40 %41 = OpLabel %11 = OpLoad %int %y OpBranch %40 %40 = OpLabel %12 = OpLoad %int %y OpSelectionMerge %16 None OpSwitch %12 %16 10 %13 13 %14 18 %15 %13 = OpLabel OpBranch %16 %14 = OpLabel OpStore %outparm %int_14 OpBranch %16 %15 = OpLabel OpStore %outparm %int_15 OpBranch %16 %16 = OpLabel %30 = OpPhi %int %11 %40 %int_42 %13 %11 %14 %11 %15 %28 = OpIAdd %int %30 %int_5 OpStore %outparm %28 OpReturn OpFunctionEnd)"; const std::string after = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %y %outparm OpExecutionMode %main OriginUpperLeft OpName %main "main" OpName %y "y" OpName %outparm "outparm" OpDecorate %y Flat OpDecorate %y Location 0 OpDecorate %outparm Location 0 %void = OpTypeVoid %6 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %_ptr_Input_int = OpTypePointer Input %int %y = OpVariable %_ptr_Input_int Input %int_42 = OpConstant %int 42 %_ptr_Output_int = OpTypePointer Output %int %outparm = OpVariable %_ptr_Output_int Output %int_14 = OpConstant %int 14 %int_15 = OpConstant %int 15 %int_5 = OpConstant %int 5 %26 = OpUndef %int %main = OpFunction %void None %6 %15 = OpLabel OpBranch %16 %16 = OpLabel %19 = OpLoad %int %y OpSelectionMerge %20 None OpSwitch %19 %20 10 %21 13 %22 18 %23 %21 = OpLabel OpBranch %20 %22 = OpLabel OpStore %outparm %int_14 OpBranch %20 %23 = OpLabel OpStore %outparm %int_15 OpBranch %20 %20 = OpLabel %24 = OpPhi %int %26 %16 %int_42 %21 %26 %22 %26 %23 %25 = OpIAdd %int %24 %int_5 OpStore %outparm %25 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(before, after, true, true); } TEST_F(CFGCleanupTest, RemovePhiConstantArgs) { const std::string before = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %y %outparm OpExecutionMode %main OriginUpperLeft OpName %main "main" OpName %y "y" OpName %outparm "outparm" OpDecorate %y Flat OpDecorate %y Location 0 OpDecorate %outparm Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %y = OpVariable %_ptr_Input_int Input %int_10 = OpConstant %int 10 %bool = OpTypeBool %_ptr_Function_int = OpTypePointer Function %int %int_23 = OpConstant %int 23 %int_5 = OpConstant %int 5 %_ptr_Output_int = OpTypePointer Output %int %outparm = OpVariable %_ptr_Output_int Output %24 = OpUndef %int %main = OpFunction %void None %3 %5 = OpLabel OpBranch %14 %40 = OpLabel %9 = OpLoad %int %y %12 = OpSGreaterThan %bool %9 %int_10 OpSelectionMerge %14 None OpBranchConditional %12 %13 %14 %13 = OpLabel OpBranch %14 %14 = OpLabel %25 = OpPhi %int %24 %5 %int_23 %13 %20 = OpIAdd %int %25 %int_5 OpStore %outparm %20 OpReturn OpFunctionEnd)"; const std::string after = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %y %outparm OpExecutionMode %main OriginUpperLeft OpName %main "main" OpName %y "y" OpName %outparm "outparm" OpDecorate %y Flat OpDecorate %y Location 0 OpDecorate %outparm Location 0 %void = OpTypeVoid %6 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %y = OpVariable %_ptr_Input_int Input %int_10 = OpConstant %int 10 %bool = OpTypeBool %_ptr_Function_int = OpTypePointer Function %int %int_23 = OpConstant %int 23 %int_5 = OpConstant %int 5 %_ptr_Output_int = OpTypePointer Output %int %outparm = OpVariable %_ptr_Output_int Output %15 = OpUndef %int %main = OpFunction %void None %6 %16 = OpLabel OpBranch %17 %17 = OpLabel %22 = OpPhi %int %15 %16 %23 = OpIAdd %int %22 %int_5 OpStore %outparm %23 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(before, after, true, true); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/cfg_test.cpp000066400000000000000000000216511475742701700226210ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gmock/gmock.h" #include "gtest/gtest.h" #include "source/opt/ir_context.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using ::testing::ContainerEq; using CFGTest = PassTest<::testing::Test>; TEST_F(CFGTest, ForEachBlockInPostOrderIf) { const std::string test = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpName %main "main" %bool = OpTypeBool %true = OpConstantTrue %bool %void = OpTypeVoid %4 = OpTypeFunction %void %uint = OpTypeInt 32 0 %5 = OpConstant %uint 5 %main = OpFunction %void None %4 %8 = OpLabel OpSelectionMerge %10 None OpBranchConditional %true %9 %10 %9 = OpLabel OpBranch %10 %10 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, test, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); ASSERT_NE(nullptr, context); CFG* cfg = context->cfg(); Module* module = context->module(); Function* function = &*module->begin(); std::vector order; cfg->ForEachBlockInPostOrder(&*function->begin(), [&order](BasicBlock* bb) { order.push_back(bb->id()); }); std::vector expected_result = {10, 9, 8}; EXPECT_THAT(order, ContainerEq(expected_result)); } TEST_F(CFGTest, ForEachBlockInPostOrderLoop) { const std::string test = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpName %main "main" %bool = OpTypeBool %true = OpConstantTrue %bool %void = OpTypeVoid %4 = OpTypeFunction %void %uint = OpTypeInt 32 0 %5 = OpConstant %uint 5 %main = OpFunction %void None %4 %8 = OpLabel OpBranch %9 %9 = OpLabel OpLoopMerge %11 %10 None OpBranchConditional %true %11 %10 %10 = OpLabel OpBranch %9 %11 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, test, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); ASSERT_NE(nullptr, context); CFG* cfg = context->cfg(); Module* module = context->module(); Function* function = &*module->begin(); std::vector order; cfg->ForEachBlockInPostOrder(&*function->begin(), [&order](BasicBlock* bb) { order.push_back(bb->id()); }); std::vector expected_result1 = {10, 11, 9, 8}; std::vector expected_result2 = {11, 10, 9, 8}; EXPECT_THAT(order, AnyOf(ContainerEq(expected_result1), ContainerEq(expected_result2))); } TEST_F(CFGTest, ForEachBlockInReversePostOrderIf) { const std::string test = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpName %main "main" %bool = OpTypeBool %true = OpConstantTrue %bool %void = OpTypeVoid %4 = OpTypeFunction %void %uint = OpTypeInt 32 0 %5 = OpConstant %uint 5 %main = OpFunction %void None %4 %8 = OpLabel OpSelectionMerge %10 None OpBranchConditional %true %9 %10 %9 = OpLabel OpBranch %10 %10 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, test, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); ASSERT_NE(nullptr, context); CFG* cfg = context->cfg(); Module* module = context->module(); Function* function = &*module->begin(); std::vector order; cfg->ForEachBlockInReversePostOrder( &*function->begin(), [&order](BasicBlock* bb) { order.push_back(bb->id()); }); std::vector expected_result = {8, 9, 10}; EXPECT_THAT(order, ContainerEq(expected_result)); } TEST_F(CFGTest, ForEachBlockInReversePostOrderLoop) { const std::string test = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpName %main "main" %bool = OpTypeBool %true = OpConstantTrue %bool %void = OpTypeVoid %4 = OpTypeFunction %void %uint = OpTypeInt 32 0 %5 = OpConstant %uint 5 %main = OpFunction %void None %4 %8 = OpLabel OpBranch %9 %9 = OpLabel OpLoopMerge %11 %10 None OpBranchConditional %true %11 %10 %10 = OpLabel OpBranch %9 %11 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, test, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); ASSERT_NE(nullptr, context); CFG* cfg = context->cfg(); Module* module = context->module(); Function* function = &*module->begin(); std::vector order; cfg->ForEachBlockInReversePostOrder( &*function->begin(), [&order](BasicBlock* bb) { order.push_back(bb->id()); }); std::vector expected_result1 = {8, 9, 10, 11}; std::vector expected_result2 = {8, 9, 11, 10}; EXPECT_THAT(order, AnyOf(ContainerEq(expected_result1), ContainerEq(expected_result2))); } TEST_F(CFGTest, SplitLoopHeaderForSingleBlockLoop) { const std::string test = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %6 = OpTypeFunction %void %2 = OpFunction %void None %6 %7 = OpLabel OpBranch %8 %8 = OpLabel %9 = OpPhi %uint %uint_0 %7 %9 %8 OpLoopMerge %10 %8 None OpBranch %8 %10 = OpLabel OpUnreachable OpFunctionEnd )"; const std::string expected_result = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %6 = OpTypeFunction %void %2 = OpFunction %void None %6 %7 = OpLabel OpBranch %8 %8 = OpLabel OpBranch %11 %11 = OpLabel %9 = OpPhi %uint %9 %11 %uint_0 %8 OpLoopMerge %10 %11 None OpBranch %11 %10 = OpLabel OpUnreachable OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, test, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); ASSERT_NE(nullptr, context); BasicBlock* loop_header = context->get_instr_block(8); ASSERT_TRUE(loop_header->GetLoopMergeInst() != nullptr); CFG* cfg = context->cfg(); cfg->SplitLoopHeader(loop_header); std::vector binary; bool skip_nop = false; context->module()->ToBinary(&binary, skip_nop); std::string optimized_asm; SpirvTools tools(SPV_ENV_UNIVERSAL_1_1); EXPECT_TRUE(tools.Disassemble(binary, &optimized_asm, SpirvTools::kDefaultDisassembleOption)) << "Disassembling failed for shader\n" << std::endl; EXPECT_EQ(optimized_asm, expected_result); } TEST_F(CFGTest, ComputeStructedOrderForLoop) { const std::string test = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpName %main "main" %bool = OpTypeBool %true = OpConstantTrue %bool %void = OpTypeVoid %4 = OpTypeFunction %void %uint = OpTypeInt 32 0 %5 = OpConstant %uint 5 %main = OpFunction %void None %4 %8 = OpLabel OpBranch %9 %9 = OpLabel OpLoopMerge %11 %10 None OpBranchConditional %true %11 %10 %10 = OpLabel OpBranch %9 %11 = OpLabel OpBranch %12 %12 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, test, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); ASSERT_NE(nullptr, context); CFG* cfg = context->cfg(); Module* module = context->module(); Function* function = &*module->begin(); std::list order; cfg->ComputeStructuredOrder(function, context->get_instr_block(9), context->get_instr_block(11), &order); // Order should contain the loop header, the continue target, and the merge // node. std::list expected_result = {context->get_instr_block(9), context->get_instr_block(10), context->get_instr_block(11)}; EXPECT_THAT(order, ContainerEq(expected_result)); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/code_sink_test.cpp000066400000000000000000000466361475742701700240320ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "test/opt/assembly_builder.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using CodeSinkTest = PassTest<::testing::Test>; TEST_F(CodeSinkTest, MoveToNextBlock) { const std::string text = R"( ;CHECK: OpFunction ;CHECK: OpLabel ;CHECK: OpLabel ;CHECK: [[ac:%\w+]] = OpAccessChain ;CHECK: [[ld:%\w+]] = OpLoad %uint [[ac]] ;CHECK: OpCopyObject %uint [[ld]] OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_4 = OpConstant %uint 4 %_arr_uint_uint_4 = OpTypeArray %uint %uint_4 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_ptr_Uniform__arr_uint_uint_4 = OpTypePointer Uniform %_arr_uint_uint_4 %9 = OpVariable %_ptr_Uniform__arr_uint_uint_4 Uniform %10 = OpTypeFunction %void %1 = OpFunction %void None %10 %11 = OpLabel %12 = OpAccessChain %_ptr_Uniform_uint %9 %uint_0 %13 = OpLoad %uint %12 OpBranch %14 %14 = OpLabel %15 = OpCopyObject %uint %13 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(CodeSinkTest, MovePastSelection) { const std::string text = R"( ;CHECK: OpFunction ;CHECK: OpLabel ;CHECK: OpSelectionMerge [[merge_bb:%\w+]] ;CHECK: [[merge_bb]] = OpLabel ;CHECK: [[ac:%\w+]] = OpAccessChain ;CHECK: [[ld:%\w+]] = OpLoad %uint [[ac]] ;CHECK: OpCopyObject %uint [[ld]] OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_4 = OpConstant %uint 4 %_arr_uint_uint_4 = OpTypeArray %uint %uint_4 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_ptr_Uniform__arr_uint_uint_4 = OpTypePointer Uniform %_arr_uint_uint_4 %11 = OpVariable %_ptr_Uniform__arr_uint_uint_4 Uniform %12 = OpTypeFunction %void %1 = OpFunction %void None %12 %13 = OpLabel %14 = OpAccessChain %_ptr_Uniform_uint %11 %uint_0 %15 = OpLoad %uint %14 OpSelectionMerge %16 None OpBranchConditional %true %17 %16 %17 = OpLabel OpBranch %16 %16 = OpLabel %18 = OpCopyObject %uint %15 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(CodeSinkTest, MoveIntoSelection) { const std::string text = R"( ;CHECK: OpFunction ;CHECK: OpLabel ;CHECK: OpSelectionMerge [[merge_bb:%\w+]] ;CHECK-NEXT: OpBranchConditional %true [[bb:%\w+]] [[merge_bb]] ;CHECK: [[bb]] = OpLabel ;CHECK-NEXT: [[ac:%\w+]] = OpAccessChain ;CHECK-NEXT: [[ld:%\w+]] = OpLoad %uint [[ac]] ;CHECK-NEXT: OpCopyObject %uint [[ld]] OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_4 = OpConstant %uint 4 %_arr_uint_uint_4 = OpTypeArray %uint %uint_4 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_ptr_Uniform__arr_uint_uint_4 = OpTypePointer Uniform %_arr_uint_uint_4 %11 = OpVariable %_ptr_Uniform__arr_uint_uint_4 Uniform %12 = OpTypeFunction %void %1 = OpFunction %void None %12 %13 = OpLabel %14 = OpAccessChain %_ptr_Uniform_uint %11 %uint_0 %15 = OpLoad %uint %14 OpSelectionMerge %16 None OpBranchConditional %true %17 %16 %17 = OpLabel %18 = OpCopyObject %uint %15 OpBranch %16 %16 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(CodeSinkTest, LeaveBeforeSelection) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_4 = OpConstant %uint 4 %_arr_uint_uint_4 = OpTypeArray %uint %uint_4 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_ptr_Uniform__arr_uint_uint_4 = OpTypePointer Uniform %_arr_uint_uint_4 %11 = OpVariable %_ptr_Uniform__arr_uint_uint_4 Uniform %12 = OpTypeFunction %void %1 = OpFunction %void None %12 %13 = OpLabel %14 = OpAccessChain %_ptr_Uniform_uint %11 %uint_0 %15 = OpLoad %uint %14 OpSelectionMerge %16 None OpBranchConditional %true %17 %20 %20 = OpLabel OpBranch %16 %17 = OpLabel %18 = OpCopyObject %uint %15 OpBranch %16 %16 = OpLabel %19 = OpCopyObject %uint %15 OpReturn OpFunctionEnd )"; auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ true); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } TEST_F(CodeSinkTest, LeaveAloneUseInSameBlock) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_4 = OpConstant %uint 4 %_arr_uint_uint_4 = OpTypeArray %uint %uint_4 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_ptr_Uniform__arr_uint_uint_4 = OpTypePointer Uniform %_arr_uint_uint_4 %11 = OpVariable %_ptr_Uniform__arr_uint_uint_4 Uniform %12 = OpTypeFunction %void %1 = OpFunction %void None %12 %13 = OpLabel %14 = OpAccessChain %_ptr_Uniform_uint %11 %uint_0 %15 = OpLoad %uint %14 %cond = OpIEqual %bool %15 %uint_0 OpSelectionMerge %16 None OpBranchConditional %cond %17 %16 %17 = OpLabel OpBranch %16 %16 = OpLabel %19 = OpCopyObject %uint %15 OpReturn OpFunctionEnd )"; auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ true); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } TEST_F(CodeSinkTest, DontMoveIntoLoop) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_4 = OpConstant %uint 4 %_arr_uint_uint_4 = OpTypeArray %uint %uint_4 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_ptr_Uniform__arr_uint_uint_4 = OpTypePointer Uniform %_arr_uint_uint_4 %11 = OpVariable %_ptr_Uniform__arr_uint_uint_4 Uniform %12 = OpTypeFunction %void %1 = OpFunction %void None %12 %13 = OpLabel %14 = OpAccessChain %_ptr_Uniform_uint %11 %uint_0 %15 = OpLoad %uint %14 OpBranch %17 %17 = OpLabel OpLoopMerge %merge %cont None OpBranch %cont %cont = OpLabel %cond = OpIEqual %bool %15 %uint_0 OpBranchConditional %cond %merge %17 %merge = OpLabel OpReturn OpFunctionEnd )"; auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ true); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } TEST_F(CodeSinkTest, DontMoveIntoLoop2) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_4 = OpConstant %uint 4 %_arr_uint_uint_4 = OpTypeArray %uint %uint_4 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_ptr_Uniform__arr_uint_uint_4 = OpTypePointer Uniform %_arr_uint_uint_4 %11 = OpVariable %_ptr_Uniform__arr_uint_uint_4 Uniform %12 = OpTypeFunction %void %1 = OpFunction %void None %12 %13 = OpLabel %14 = OpAccessChain %_ptr_Uniform_uint %11 %uint_0 %15 = OpLoad %uint %14 OpSelectionMerge %16 None OpBranchConditional %true %17 %16 %17 = OpLabel OpLoopMerge %merge %cont None OpBranch %cont %cont = OpLabel %cond = OpIEqual %bool %15 %uint_0 OpBranchConditional %cond %merge %17 %merge = OpLabel OpBranch %16 %16 = OpLabel OpReturn OpFunctionEnd )"; auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ true); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } TEST_F(CodeSinkTest, DontMoveSelectionUsedInBothSides) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_4 = OpConstant %uint 4 %_arr_uint_uint_4 = OpTypeArray %uint %uint_4 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_ptr_Uniform__arr_uint_uint_4 = OpTypePointer Uniform %_arr_uint_uint_4 %11 = OpVariable %_ptr_Uniform__arr_uint_uint_4 Uniform %12 = OpTypeFunction %void %1 = OpFunction %void None %12 %13 = OpLabel %14 = OpAccessChain %_ptr_Uniform_uint %11 %uint_0 %15 = OpLoad %uint %14 OpSelectionMerge %16 None OpBranchConditional %true %17 %20 %20 = OpLabel %19 = OpCopyObject %uint %15 OpBranch %16 %17 = OpLabel %18 = OpCopyObject %uint %15 OpBranch %16 %16 = OpLabel OpReturn OpFunctionEnd )"; auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ true); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } TEST_F(CodeSinkTest, DontMoveBecauseOfStore) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_4 = OpConstant %uint 4 %_arr_uint_uint_4 = OpTypeArray %uint %uint_4 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_ptr_Uniform__arr_uint_uint_4 = OpTypePointer Uniform %_arr_uint_uint_4 %11 = OpVariable %_ptr_Uniform__arr_uint_uint_4 Uniform %12 = OpTypeFunction %void %1 = OpFunction %void None %12 %13 = OpLabel %14 = OpAccessChain %_ptr_Uniform_uint %11 %uint_0 %15 = OpLoad %uint %14 OpStore %14 %15 OpSelectionMerge %16 None OpBranchConditional %true %17 %20 %20 = OpLabel OpBranch %16 %17 = OpLabel %18 = OpCopyObject %uint %15 OpBranch %16 %16 = OpLabel OpReturn OpFunctionEnd )"; auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ true); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } TEST_F(CodeSinkTest, MoveReadOnlyLoadWithSync) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_4 = OpConstant %uint 4 %mem_semantics = OpConstant %uint 0x42 ; Uniform memory arquire %_arr_uint_uint_4 = OpTypeArray %uint %uint_4 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_ptr_Uniform__arr_uint_uint_4 = OpTypePointer Uniform %_arr_uint_uint_4 %11 = OpVariable %_ptr_Uniform__arr_uint_uint_4 Uniform %12 = OpTypeFunction %void %1 = OpFunction %void None %12 %13 = OpLabel %14 = OpAccessChain %_ptr_Uniform_uint %11 %uint_0 %15 = OpLoad %uint %14 OpMemoryBarrier %uint_4 %mem_semantics OpSelectionMerge %16 None OpBranchConditional %true %17 %20 %20 = OpLabel OpBranch %16 %17 = OpLabel %18 = OpCopyObject %uint %15 OpBranch %16 %16 = OpLabel OpReturn OpFunctionEnd )"; auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ true); EXPECT_EQ(Pass::Status::SuccessWithChange, std::get<1>(result)); } TEST_F(CodeSinkTest, DontMoveBecauseOfSync) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpDecorate %_arr_uint_uint_4 BufferBlock OpMemberDecorate %_arr_uint_uint_4 0 Offset 0 %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_4 = OpConstant %uint 4 %mem_semantics = OpConstant %uint 0x42 ; Uniform memory arquire %_arr_uint_uint_4 = OpTypeStruct %uint %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_ptr_Uniform__arr_uint_uint_4 = OpTypePointer Uniform %_arr_uint_uint_4 %11 = OpVariable %_ptr_Uniform__arr_uint_uint_4 Uniform %12 = OpTypeFunction %void %1 = OpFunction %void None %12 %13 = OpLabel %14 = OpAccessChain %_ptr_Uniform_uint %11 %uint_0 %15 = OpLoad %uint %14 OpMemoryBarrier %uint_4 %mem_semantics OpSelectionMerge %16 None OpBranchConditional %true %17 %20 %20 = OpLabel OpBranch %16 %17 = OpLabel %18 = OpCopyObject %uint %15 OpBranch %16 %16 = OpLabel OpReturn OpFunctionEnd )"; auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ true); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } TEST_F(CodeSinkTest, DontMoveBecauseOfAtomicWithSync) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpDecorate %_arr_uint_uint_4 BufferBlock OpMemberDecorate %_arr_uint_uint_4 0 Offset 0 %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_4 = OpConstant %uint 4 %mem_semantics = OpConstant %uint 0x42 ; Uniform memory arquire %_arr_uint_uint_4 = OpTypeStruct %uint %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_ptr_Uniform__arr_uint_uint_4 = OpTypePointer Uniform %_arr_uint_uint_4 %11 = OpVariable %_ptr_Uniform__arr_uint_uint_4 Uniform %12 = OpTypeFunction %void %1 = OpFunction %void None %12 %13 = OpLabel %14 = OpAccessChain %_ptr_Uniform_uint %11 %uint_0 %15 = OpLoad %uint %14 %al = OpAtomicLoad %uint %14 %uint_4 %mem_semantics OpSelectionMerge %16 None OpBranchConditional %true %17 %20 %20 = OpLabel OpBranch %16 %17 = OpLabel %18 = OpCopyObject %uint %15 OpBranch %16 %16 = OpLabel OpReturn OpFunctionEnd )"; auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ true); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } TEST_F(CodeSinkTest, MoveWithAtomicWithoutSync) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpDecorate %_arr_uint_uint_4 BufferBlock OpMemberDecorate %_arr_uint_uint_4 0 Offset 0 %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_4 = OpConstant %uint 4 %_arr_uint_uint_4 = OpTypeStruct %uint %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_ptr_Uniform__arr_uint_uint_4 = OpTypePointer Uniform %_arr_uint_uint_4 %11 = OpVariable %_ptr_Uniform__arr_uint_uint_4 Uniform %12 = OpTypeFunction %void %1 = OpFunction %void None %12 %13 = OpLabel %14 = OpAccessChain %_ptr_Uniform_uint %11 %uint_0 %15 = OpLoad %uint %14 %al = OpAtomicLoad %uint %14 %uint_4 %uint_0 OpSelectionMerge %16 None OpBranchConditional %true %17 %20 %20 = OpLabel OpBranch %16 %17 = OpLabel %18 = OpCopyObject %uint %15 OpBranch %16 %16 = OpLabel OpReturn OpFunctionEnd )"; auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ true); EXPECT_EQ(Pass::Status::SuccessWithChange, std::get<1>(result)); } TEST_F(CodeSinkTest, DecorationOnLoad) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %2 OpDecorate %3 RelaxedPrecision %void = OpTypeVoid %5 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Input_float = OpTypePointer Input %float %2 = OpVariable %_ptr_Input_float Input %1 = OpFunction %void None %5 %8 = OpLabel %3 = OpLoad %float %2 OpReturn OpFunctionEnd )"; // We just want to make sure the code does not crash. auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ true); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/combine_access_chains_test.cpp000066400000000000000000000667331475742701700263560ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using CombineAccessChainsTest = PassTest<::testing::Test>; TEST_F(CombineAccessChainsTest, PtrAccessChainFromAccessChainConstant) { const std::string text = R"( ; CHECK: [[int:%\w+]] = OpTypeInt 32 0 ; CHECK: [[int3:%\w+]] = OpConstant [[int]] 3 ; CHECK: [[ptr_int:%\w+]] = OpTypePointer Workgroup [[int]] ; CHECK: [[var:%\w+]] = OpVariable {{%\w+}} Workgroup ; CHECK: OpAccessChain [[ptr_int]] [[var]] [[int3]] OpCapability Shader OpCapability VariablePointers OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_3 = OpConstant %uint 3 %uint_4 = OpConstant %uint 4 %uint_array_4 = OpTypeArray %uint %uint_4 %ptr_Workgroup_uint = OpTypePointer Workgroup %uint %ptr_Workgroup_uint_array_4 = OpTypePointer Workgroup %uint_array_4 %var = OpVariable %ptr_Workgroup_uint_array_4 Workgroup %void_func = OpTypeFunction %void %main = OpFunction %void None %void_func %main_lab = OpLabel %gep = OpAccessChain %ptr_Workgroup_uint %var %uint_0 %ptr_gep = OpPtrAccessChain %ptr_Workgroup_uint %gep %uint_3 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(CombineAccessChainsTest, PtrAccessChainFromInBoundsAccessChainConstant) { const std::string text = R"( ; CHECK: [[int:%\w+]] = OpTypeInt 32 0 ; CHECK: [[int3:%\w+]] = OpConstant [[int]] 3 ; CHECK: [[ptr_int:%\w+]] = OpTypePointer Workgroup [[int]] ; CHECK: [[var:%\w+]] = OpVariable {{%\w+}} Workgroup ; CHECK: OpAccessChain [[ptr_int]] [[var]] [[int3]] OpCapability Shader OpCapability VariablePointers OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_3 = OpConstant %uint 3 %uint_4 = OpConstant %uint 4 %uint_array_4 = OpTypeArray %uint %uint_4 %ptr_Workgroup_uint = OpTypePointer Workgroup %uint %ptr_Workgroup_uint_array_4 = OpTypePointer Workgroup %uint_array_4 %var = OpVariable %ptr_Workgroup_uint_array_4 Workgroup %void_func = OpTypeFunction %void %main = OpFunction %void None %void_func %main_lab = OpLabel %gep = OpInBoundsAccessChain %ptr_Workgroup_uint %var %uint_0 %ptr_gep = OpPtrAccessChain %ptr_Workgroup_uint %gep %uint_3 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(CombineAccessChainsTest, PtrAccessChainFromAccessChainCombineConstant) { const std::string text = R"( ; CHECK: [[int:%\w+]] = OpTypeInt 32 0 ; CHECK: [[ptr_int:%\w+]] = OpTypePointer Workgroup [[int]] ; CHECK: [[var:%\w+]] = OpVariable {{%\w+}} Workgroup ; CHECK: [[int2:%\w+]] = OpConstant [[int]] 2 ; CHECK: OpAccessChain [[ptr_int]] [[var]] [[int2]] OpCapability Shader OpCapability VariablePointers OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_4 = OpConstant %uint 4 %uint_array_4 = OpTypeArray %uint %uint_4 %ptr_Workgroup_uint = OpTypePointer Workgroup %uint %ptr_Workgroup_uint_array_4 = OpTypePointer Workgroup %uint_array_4 %var = OpVariable %ptr_Workgroup_uint_array_4 Workgroup %void_func = OpTypeFunction %void %main = OpFunction %void None %void_func %main_lab = OpLabel %gep = OpAccessChain %ptr_Workgroup_uint %var %uint_1 %ptr_gep = OpPtrAccessChain %ptr_Workgroup_uint %gep %uint_1 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(CombineAccessChainsTest, PtrAccessChainFromAccessChainNonConstant) { const std::string text = R"( ; CHECK: [[int:%\w+]] = OpTypeInt 32 0 ; CHECK: [[ptr_int:%\w+]] = OpTypePointer Workgroup [[int]] ; CHECK: [[var:%\w+]] = OpVariable {{%\w+}} Workgroup ; CHECK: [[ld1:%\w+]] = OpLoad ; CHECK: [[ld2:%\w+]] = OpLoad ; CHECK: [[add:%\w+]] = OpIAdd [[int]] [[ld1]] [[ld2]] ; CHECK: OpAccessChain [[ptr_int]] [[var]] [[add]] OpCapability Shader OpCapability VariablePointers OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_4 = OpConstant %uint 4 %uint_array_4 = OpTypeArray %uint %uint_4 %ptr_Workgroup_uint = OpTypePointer Workgroup %uint %ptr_Function_uint = OpTypePointer Function %uint %ptr_Workgroup_uint_array_4 = OpTypePointer Workgroup %uint_array_4 %var = OpVariable %ptr_Workgroup_uint_array_4 Workgroup %void_func = OpTypeFunction %void %main = OpFunction %void None %void_func %main_lab = OpLabel %local_var = OpVariable %ptr_Function_uint Function %ld1 = OpLoad %uint %local_var %gep = OpAccessChain %ptr_Workgroup_uint %var %ld1 %ld2 = OpLoad %uint %local_var %ptr_gep = OpPtrAccessChain %ptr_Workgroup_uint %gep %ld2 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(CombineAccessChainsTest, PtrAccessChainFromAccessChainExtraIndices) { const std::string text = R"( ; CHECK: [[int:%\w+]] = OpTypeInt 32 0 ; CHECK: [[int1:%\w+]] = OpConstant [[int]] 1 ; CHECK: [[int2:%\w+]] = OpConstant [[int]] 2 ; CHECK: [[int3:%\w+]] = OpConstant [[int]] 3 ; CHECK: [[ptr_int:%\w+]] = OpTypePointer Workgroup [[int]] ; CHECK: [[var:%\w+]] = OpVariable {{%\w+}} Workgroup ; CHECK: OpAccessChain [[ptr_int]] [[var]] [[int1]] [[int2]] [[int3]] OpCapability Shader OpCapability VariablePointers OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %uint_3 = OpConstant %uint 3 %uint_4 = OpConstant %uint 4 %uint_array_4 = OpTypeArray %uint %uint_4 %uint_array_4_array_4 = OpTypeArray %uint_array_4 %uint_4 %uint_array_4_array_4_array_4 = OpTypeArray %uint_array_4_array_4 %uint_4 %ptr_Workgroup_uint = OpTypePointer Workgroup %uint %ptr_Function_uint = OpTypePointer Function %uint %ptr_Workgroup_uint_array_4 = OpTypePointer Workgroup %uint_array_4 %ptr_Workgroup_uint_array_4_array_4 = OpTypePointer Workgroup %uint_array_4_array_4 %ptr_Workgroup_uint_array_4_array_4_array_4 = OpTypePointer Workgroup %uint_array_4_array_4_array_4 %var = OpVariable %ptr_Workgroup_uint_array_4_array_4_array_4 Workgroup %void_func = OpTypeFunction %void %main = OpFunction %void None %void_func %main_lab = OpLabel %gep = OpAccessChain %ptr_Workgroup_uint_array_4 %var %uint_1 %uint_0 %ptr_gep = OpPtrAccessChain %ptr_Workgroup_uint %gep %uint_2 %uint_3 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(CombineAccessChainsTest, PtrAccessChainFromPtrAccessChainCombineElementOperand) { const std::string text = R"( ; CHECK: [[int:%\w+]] = OpTypeInt 32 0 ; CHECK: [[int3:%\w+]] = OpConstant [[int]] 3 ; CHECK: [[ptr_int:%\w+]] = OpTypePointer Workgroup [[int]] ; CHECK: [[var:%\w+]] = OpVariable {{%\w+}} Workgroup ; CHECK: [[int6:%\w+]] = OpConstant [[int]] 6 ; CHECK: OpPtrAccessChain [[ptr_int]] [[var]] [[int6]] [[int3]] OpCapability Shader OpCapability VariablePointers OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_3 = OpConstant %uint 3 %uint_4 = OpConstant %uint 4 %uint_array_4 = OpTypeArray %uint %uint_4 %ptr_Workgroup_uint = OpTypePointer Workgroup %uint %ptr_Workgroup_uint_array_4 = OpTypePointer Workgroup %uint_array_4 %var = OpVariable %ptr_Workgroup_uint_array_4 Workgroup %void_func = OpTypeFunction %void %main = OpFunction %void None %void_func %main_lab = OpLabel %gep = OpPtrAccessChain %ptr_Workgroup_uint_array_4 %var %uint_3 %ptr_gep = OpPtrAccessChain %ptr_Workgroup_uint %gep %uint_3 %uint_3 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(CombineAccessChainsTest, PtrAccessChainFromPtrAccessChainOnlyElementOperand) { const std::string text = R"( ; CHECK: [[int:%\w+]] = OpTypeInt 32 0 ; CHECK: [[int4:%\w+]] = OpConstant [[int]] 4 ; CHECK: [[array:%\w+]] = OpTypeArray [[int]] [[int4]] ; CHECK: [[ptr_array:%\w+]] = OpTypePointer Workgroup [[array]] ; CHECK: [[var:%\w+]] = OpVariable {{%\w+}} Workgroup ; CHECK: [[int6:%\w+]] = OpConstant [[int]] 6 ; CHECK: OpPtrAccessChain [[ptr_array]] [[var]] [[int6]] OpCapability Shader OpCapability VariablePointers OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_3 = OpConstant %uint 3 %uint_4 = OpConstant %uint 4 %uint_array_4 = OpTypeArray %uint %uint_4 %ptr_Workgroup_uint = OpTypePointer Workgroup %uint %ptr_Workgroup_uint_array_4 = OpTypePointer Workgroup %uint_array_4 %var = OpVariable %ptr_Workgroup_uint_array_4 Workgroup %void_func = OpTypeFunction %void %main = OpFunction %void None %void_func %main_lab = OpLabel %gep = OpPtrAccessChain %ptr_Workgroup_uint_array_4 %var %uint_3 %ptr_gep = OpPtrAccessChain %ptr_Workgroup_uint_array_4 %gep %uint_3 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(CombineAccessChainsTest, PtrAccessChainFromPtrAccessCombineNonElementIndex) { const std::string text = R"( ; CHECK: [[int:%\w+]] = OpTypeInt 32 0 ; CHECK: [[int3:%\w+]] = OpConstant [[int]] 3 ; CHECK: [[ptr_int:%\w+]] = OpTypePointer Workgroup [[int]] ; CHECK: [[var:%\w+]] = OpVariable {{%\w+}} Workgroup ; CHECK: OpPtrAccessChain [[ptr_int]] [[var]] [[int3]] [[int3]] [[int3]] OpCapability Shader OpCapability VariablePointers OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_3 = OpConstant %uint 3 %uint_4 = OpConstant %uint 4 %uint_array_4 = OpTypeArray %uint %uint_4 %uint_array_4_array_4 = OpTypeArray %uint_array_4 %uint_4 %ptr_Workgroup_uint = OpTypePointer Workgroup %uint %ptr_Function_uint = OpTypePointer Function %uint %ptr_Workgroup_uint_array_4 = OpTypePointer Workgroup %uint_array_4 %ptr_Workgroup_uint_array_4_array_4 = OpTypePointer Workgroup %uint_array_4_array_4 %var = OpVariable %ptr_Workgroup_uint_array_4_array_4 Workgroup %void_func = OpTypeFunction %void %main = OpFunction %void None %void_func %main_lab = OpLabel %gep = OpPtrAccessChain %ptr_Workgroup_uint_array_4 %var %uint_3 %uint_0 %ptr_gep = OpPtrAccessChain %ptr_Workgroup_uint %gep %uint_3 %uint_3 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(CombineAccessChainsTest, AccessChainFromPtrAccessChainOnlyElementOperand) { const std::string text = R"( ; CHECK: [[int:%\w+]] = OpTypeInt 32 0 ; CHECK: [[int3:%\w+]] = OpConstant [[int]] 3 ; CHECK: [[ptr_int:%\w+]] = OpTypePointer Workgroup [[int]] ; CHECK: [[var:%\w+]] = OpVariable {{%\w+}} Workgroup ; CHECK: OpPtrAccessChain [[ptr_int]] [[var]] [[int3]] [[int3]] OpCapability Shader OpCapability VariablePointers OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_3 = OpConstant %uint 3 %uint_4 = OpConstant %uint 4 %uint_array_4 = OpTypeArray %uint %uint_4 %ptr_Workgroup_uint = OpTypePointer Workgroup %uint %ptr_Workgroup_uint_array_4 = OpTypePointer Workgroup %uint_array_4 %var = OpVariable %ptr_Workgroup_uint_array_4 Workgroup %void_func = OpTypeFunction %void %main = OpFunction %void None %void_func %main_lab = OpLabel %ptr_gep = OpPtrAccessChain %ptr_Workgroup_uint_array_4 %var %uint_3 %gep = OpAccessChain %ptr_Workgroup_uint %ptr_gep %uint_3 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(CombineAccessChainsTest, AccessChainFromPtrAccessChainAppend) { const std::string text = R"( ; CHECK: [[int:%\w+]] = OpTypeInt 32 0 ; CHECK: [[int1:%\w+]] = OpConstant [[int]] 1 ; CHECK: [[int2:%\w+]] = OpConstant [[int]] 2 ; CHECK: [[int3:%\w+]] = OpConstant [[int]] 3 ; CHECK: [[ptr_int:%\w+]] = OpTypePointer Workgroup [[int]] ; CHECK: [[var:%\w+]] = OpVariable {{%\w+}} Workgroup ; CHECK: OpPtrAccessChain [[ptr_int]] [[var]] [[int1]] [[int2]] [[int3]] OpCapability Shader OpCapability VariablePointers OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %uint_3 = OpConstant %uint 3 %uint_4 = OpConstant %uint 4 %uint_array_4 = OpTypeArray %uint %uint_4 %uint_array_4_array_4 = OpTypeArray %uint_array_4 %uint_4 %ptr_Workgroup_uint = OpTypePointer Workgroup %uint %ptr_Workgroup_uint_array_4 = OpTypePointer Workgroup %uint_array_4 %ptr_Workgroup_uint_array_4_array_4 = OpTypePointer Workgroup %uint_array_4_array_4 %var = OpVariable %ptr_Workgroup_uint_array_4_array_4 Workgroup %void_func = OpTypeFunction %void %main = OpFunction %void None %void_func %main_lab = OpLabel %ptr_gep = OpPtrAccessChain %ptr_Workgroup_uint_array_4 %var %uint_1 %uint_2 %gep = OpAccessChain %ptr_Workgroup_uint %ptr_gep %uint_3 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(CombineAccessChainsTest, AccessChainFromAccessChainAppend) { const std::string text = R"( ; CHECK: [[int:%\w+]] = OpTypeInt 32 0 ; CHECK: [[int1:%\w+]] = OpConstant [[int]] 1 ; CHECK: [[int2:%\w+]] = OpConstant [[int]] 2 ; CHECK: [[ptr_int:%\w+]] = OpTypePointer Workgroup [[int]] ; CHECK: [[var:%\w+]] = OpVariable {{%\w+}} Workgroup ; CHECK: OpAccessChain [[ptr_int]] [[var]] [[int1]] [[int2]] OpCapability Shader OpCapability VariablePointers OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %uint_3 = OpConstant %uint 3 %uint_4 = OpConstant %uint 4 %uint_array_4 = OpTypeArray %uint %uint_4 %uint_array_4_array_4 = OpTypeArray %uint_array_4 %uint_4 %ptr_Workgroup_uint = OpTypePointer Workgroup %uint %ptr_Workgroup_uint_array_4 = OpTypePointer Workgroup %uint_array_4 %ptr_Workgroup_uint_array_4_array_4 = OpTypePointer Workgroup %uint_array_4_array_4 %var = OpVariable %ptr_Workgroup_uint_array_4_array_4 Workgroup %void_func = OpTypeFunction %void %main = OpFunction %void None %void_func %main_lab = OpLabel %ptr_gep = OpAccessChain %ptr_Workgroup_uint_array_4 %var %uint_1 %gep = OpAccessChain %ptr_Workgroup_uint %ptr_gep %uint_2 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(CombineAccessChainsTest, NonConstantStructSlide) { const std::string text = R"( ; CHECK: [[int0:%\w+]] = OpConstant {{%\w+}} 0 ; CHECK: [[var:%\w+]] = OpVariable {{%\w+}} Workgroup ; CHECK: [[ld:%\w+]] = OpLoad ; CHECK: OpPtrAccessChain {{%\w+}} [[var]] [[ld]] [[int0]] OpCapability Shader OpCapability VariablePointers OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %struct = OpTypeStruct %uint %uint %ptr_Workgroup_struct = OpTypePointer Workgroup %struct %ptr_Workgroup_uint = OpTypePointer Workgroup %uint %ptr_Function_uint = OpTypePointer Function %uint %wg_var = OpVariable %ptr_Workgroup_struct Workgroup %void_func = OpTypeFunction %void %main = OpFunction %void None %void_func %1 = OpLabel %func_var = OpVariable %ptr_Function_uint Function %ld = OpLoad %uint %func_var %ptr_gep = OpPtrAccessChain %ptr_Workgroup_struct %wg_var %ld %gep = OpAccessChain %ptr_Workgroup_uint %ptr_gep %uint_0 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(CombineAccessChainsTest, DontCombineNonConstantStructSlide) { const std::string text = R"( ; CHECK: [[int0:%\w+]] = OpConstant {{%\w+}} 0 ; CHECK: [[ld:%\w+]] = OpLoad ; CHECK: [[gep:%\w+]] = OpAccessChain ; CHECK: OpPtrAccessChain {{%\w+}} [[gep]] [[ld]] [[int0]] OpCapability Shader OpCapability VariablePointers OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_4 = OpConstant %uint 4 %struct = OpTypeStruct %uint %uint %struct_array_4 = OpTypeArray %struct %uint_4 %ptr_Workgroup_uint = OpTypePointer Workgroup %uint %ptr_Function_uint = OpTypePointer Function %uint %ptr_Workgroup_struct = OpTypePointer Workgroup %struct %ptr_Workgroup_struct_array_4 = OpTypePointer Workgroup %struct_array_4 %wg_var = OpVariable %ptr_Workgroup_struct_array_4 Workgroup %void_func = OpTypeFunction %void %main = OpFunction %void None %void_func %1 = OpLabel %func_var = OpVariable %ptr_Function_uint Function %ld = OpLoad %uint %func_var %gep = OpAccessChain %ptr_Workgroup_struct %wg_var %uint_0 %ptr_gep = OpPtrAccessChain %ptr_Workgroup_uint %gep %ld %uint_0 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(CombineAccessChainsTest, CombineNonConstantStructSlideElement) { const std::string text = R"( ; CHECK: [[int0:%\w+]] = OpConstant {{%\w+}} 0 ; CHECK: [[var:%\w+]] = OpVariable {{%\w+}} Workgroup ; CHECK: [[ld:%\w+]] = OpLoad ; CHECK: [[add:%\w+]] = OpIAdd {{%\w+}} [[ld]] [[ld]] ; CHECK: OpPtrAccessChain {{%\w+}} [[var]] [[add]] [[int0]] OpCapability Shader OpCapability VariablePointers OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_4 = OpConstant %uint 4 %struct = OpTypeStruct %uint %uint %ptr_Workgroup_uint = OpTypePointer Workgroup %uint %ptr_Function_uint = OpTypePointer Function %uint %ptr_Workgroup_struct = OpTypePointer Workgroup %struct %wg_var = OpVariable %ptr_Workgroup_struct Workgroup %void_func = OpTypeFunction %void %main = OpFunction %void None %void_func %1 = OpLabel %func_var = OpVariable %ptr_Function_uint Function %ld = OpLoad %uint %func_var %gep = OpPtrAccessChain %ptr_Workgroup_struct %wg_var %ld %ptr_gep = OpPtrAccessChain %ptr_Workgroup_uint %gep %ld %uint_0 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(CombineAccessChainsTest, PtrAccessChainFromInBoundsPtrAccessChain) { const std::string text = R"( ; CHECK: [[int:%\w+]] = OpTypeInt 32 0 ; CHECK: [[int4:%\w+]] = OpConstant [[int]] 4 ; CHECK: [[array:%\w+]] = OpTypeArray [[int]] [[int4]] ; CHECK: [[ptr_array:%\w+]] = OpTypePointer Workgroup [[array]] ; CHECK: [[var:%\w+]] = OpVariable {{%\w+}} Workgroup ; CHECK: [[int6:%\w+]] = OpConstant [[int]] 6 ; CHECK: OpPtrAccessChain [[ptr_array]] [[var]] [[int6]] OpCapability Shader OpCapability VariablePointers OpCapability Addresses OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_3 = OpConstant %uint 3 %uint_4 = OpConstant %uint 4 %uint_array_4 = OpTypeArray %uint %uint_4 %ptr_Workgroup_uint = OpTypePointer Workgroup %uint %ptr_Workgroup_uint_array_4 = OpTypePointer Workgroup %uint_array_4 %var = OpVariable %ptr_Workgroup_uint_array_4 Workgroup %void_func = OpTypeFunction %void %main = OpFunction %void None %void_func %main_lab = OpLabel %gep = OpInBoundsPtrAccessChain %ptr_Workgroup_uint_array_4 %var %uint_3 %ptr_gep = OpPtrAccessChain %ptr_Workgroup_uint_array_4 %gep %uint_3 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(CombineAccessChainsTest, InBoundsPtrAccessChainFromPtrAccessChain) { const std::string text = R"( ; CHECK: [[int:%\w+]] = OpTypeInt 32 0 ; CHECK: [[int4:%\w+]] = OpConstant [[int]] 4 ; CHECK: [[array:%\w+]] = OpTypeArray [[int]] [[int4]] ; CHECK: [[ptr_array:%\w+]] = OpTypePointer Workgroup [[array]] ; CHECK: [[var:%\w+]] = OpVariable {{%\w+}} Workgroup ; CHECK: [[int6:%\w+]] = OpConstant [[int]] 6 ; CHECK: OpPtrAccessChain [[ptr_array]] [[var]] [[int6]] OpCapability Shader OpCapability VariablePointers OpCapability Addresses OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_3 = OpConstant %uint 3 %uint_4 = OpConstant %uint 4 %uint_array_4 = OpTypeArray %uint %uint_4 %ptr_Workgroup_uint = OpTypePointer Workgroup %uint %ptr_Workgroup_uint_array_4 = OpTypePointer Workgroup %uint_array_4 %var = OpVariable %ptr_Workgroup_uint_array_4 Workgroup %void_func = OpTypeFunction %void %main = OpFunction %void None %void_func %main_lab = OpLabel %gep = OpPtrAccessChain %ptr_Workgroup_uint_array_4 %var %uint_3 %ptr_gep = OpInBoundsPtrAccessChain %ptr_Workgroup_uint_array_4 %gep %uint_3 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(CombineAccessChainsTest, InBoundsPtrAccessChainFromInBoundsPtrAccessChain) { const std::string text = R"( ; CHECK: [[int:%\w+]] = OpTypeInt 32 0 ; CHECK: [[int4:%\w+]] = OpConstant [[int]] 4 ; CHECK: [[array:%\w+]] = OpTypeArray [[int]] [[int4]] ; CHECK: [[ptr_array:%\w+]] = OpTypePointer Workgroup [[array]] ; CHECK: [[var:%\w+]] = OpVariable {{%\w+}} Workgroup ; CHECK: [[int6:%\w+]] = OpConstant [[int]] 6 ; CHECK: OpInBoundsPtrAccessChain [[ptr_array]] [[var]] [[int6]] OpCapability Shader OpCapability VariablePointers OpCapability Addresses OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_3 = OpConstant %uint 3 %uint_4 = OpConstant %uint 4 %uint_array_4 = OpTypeArray %uint %uint_4 %ptr_Workgroup_uint = OpTypePointer Workgroup %uint %ptr_Workgroup_uint_array_4 = OpTypePointer Workgroup %uint_array_4 %var = OpVariable %ptr_Workgroup_uint_array_4 Workgroup %void_func = OpTypeFunction %void %main = OpFunction %void None %void_func %main_lab = OpLabel %gep = OpInBoundsPtrAccessChain %ptr_Workgroup_uint_array_4 %var %uint_3 %ptr_gep = OpInBoundsPtrAccessChain %ptr_Workgroup_uint_array_4 %gep %uint_3 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(CombineAccessChainsTest, NoIndexAccessChains) { const std::string text = R"( ; CHECK: [[var:%\w+]] = OpVariable ; CHECK-NOT: OpConstant ; CHECK: [[gep:%\w+]] = OpAccessChain {{%\w+}} [[var]] ; CHECK: OpAccessChain {{%\w+}} [[var]] OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %uint = OpTypeInt 32 0 %ptr_Workgroup_uint = OpTypePointer Workgroup %uint %var = OpVariable %ptr_Workgroup_uint Workgroup %void_func = OpTypeFunction %void %func = OpFunction %void None %void_func %1 = OpLabel %gep1 = OpAccessChain %ptr_Workgroup_uint %var %gep2 = OpAccessChain %ptr_Workgroup_uint %gep1 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(CombineAccessChainsTest, NoIndexPtrAccessChains) { const std::string text = R"( ; CHECK: [[int0:%\w+]] = OpConstant {{%\w+}} 0 ; CHECK: [[var:%\w+]] = OpVariable ; CHECK: [[gep:%\w+]] = OpPtrAccessChain {{%\w+}} [[var]] [[int0]] ; CHECK: OpCopyObject {{%\w+}} [[gep]] OpCapability Shader OpCapability VariablePointers OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %ptr_Workgroup_uint = OpTypePointer Workgroup %uint %var = OpVariable %ptr_Workgroup_uint Workgroup %void_func = OpTypeFunction %void %func = OpFunction %void None %void_func %1 = OpLabel %gep1 = OpPtrAccessChain %ptr_Workgroup_uint %var %uint_0 %gep2 = OpAccessChain %ptr_Workgroup_uint %gep1 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(CombineAccessChainsTest, NoIndexPtrAccessChains2) { const std::string text = R"( ; CHECK: [[int0:%\w+]] = OpConstant {{%\w+}} 0 ; CHECK: [[var:%\w+]] = OpVariable ; CHECK: OpPtrAccessChain {{%\w+}} [[var]] [[int0]] OpCapability Shader OpCapability VariablePointers OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %ptr_Workgroup_uint = OpTypePointer Workgroup %uint %var = OpVariable %ptr_Workgroup_uint Workgroup %void_func = OpTypeFunction %void %func = OpFunction %void None %void_func %1 = OpLabel %gep1 = OpAccessChain %ptr_Workgroup_uint %var %gep2 = OpPtrAccessChain %ptr_Workgroup_uint %gep1 %uint_0 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(CombineAccessChainsTest, CombineMixedSign) { const std::string text = R"( ; CHECK: [[uint:%\w+]] = OpTypeInt 32 0 ; CHECK: [[var:%\w+]] = OpVariable ; CHECK: [[uint2:%\w+]] = OpConstant [[uint]] 2 ; CHECK: OpInBoundsPtrAccessChain {{%\w+}} [[var]] [[uint2]] OpCapability Shader OpCapability VariablePointers OpCapability Addresses OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %uint = OpTypeInt 32 0 %int = OpTypeInt 32 1 %uint_1 = OpConstant %uint 1 %int_1 = OpConstant %int 1 %ptr_Workgroup_uint = OpTypePointer Workgroup %uint %var = OpVariable %ptr_Workgroup_uint Workgroup %void_func = OpTypeFunction %void %func = OpFunction %void None %void_func %1 = OpLabel %gep1 = OpInBoundsPtrAccessChain %ptr_Workgroup_uint %var %uint_1 %gep2 = OpInBoundsPtrAccessChain %ptr_Workgroup_uint %gep1 %int_1 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(CombineAccessChainsTest, FunctionDeclaration) { // Make sure the pass works with a function declaration that is called. const std::string text = R"(OpCapability Addresses OpCapability Linkage OpCapability Kernel OpCapability Int8 %1 = OpExtInstImport "OpenCL.std" OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %2 "_Z23julia__1166_kernel_77094Bool" OpExecutionMode %2 ContractionOff OpSource Unknown 0 OpDecorate %3 LinkageAttributes "julia_error_7712" Import %void = OpTypeVoid %5 = OpTypeFunction %void %3 = OpFunction %void None %5 OpFunctionEnd %2 = OpFunction %void None %5 %6 = OpLabel %7 = OpFunctionCall %void %3 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(text, text, false); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/compact_ids_test.cpp000066400000000000000000000241751475742701700243530ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gmock/gmock.h" #include "spirv-tools/libspirv.hpp" #include "spirv-tools/optimizer.hpp" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using CompactIdsTest = PassTest<::testing::Test>; TEST_F(CompactIdsTest, PassOff) { const std::string before = R"(OpCapability Addresses OpCapability Kernel OpCapability GenericPointer OpCapability Linkage OpMemoryModel Physical32 OpenCL %99 = OpTypeInt 32 0 %10 = OpTypeVector %99 2 %20 = OpConstant %99 2 %30 = OpTypeArray %99 %20 )"; const std::string after = before; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(before, after, false, false); } TEST_F(CompactIdsTest, PassOn) { const std::string before = R"(OpCapability Addresses OpCapability Kernel OpCapability GenericPointer OpCapability Linkage OpMemoryModel Physical32 OpenCL OpEntryPoint Kernel %3 "simple_kernel" %99 = OpTypeInt 32 0 %10 = OpTypeVector %99 2 %20 = OpConstant %99 2 %30 = OpTypeArray %99 %20 %40 = OpTypeVoid %50 = OpTypeFunction %40 %3 = OpFunction %40 None %50 %70 = OpLabel OpReturn OpFunctionEnd )"; const std::string after = R"(OpCapability Addresses OpCapability Kernel OpCapability GenericPointer OpCapability Linkage OpMemoryModel Physical32 OpenCL OpEntryPoint Kernel %1 "simple_kernel" %2 = OpTypeInt 32 0 %3 = OpTypeVector %2 2 %4 = OpConstant %2 2 %5 = OpTypeArray %2 %4 %6 = OpTypeVoid %7 = OpTypeFunction %6 %1 = OpFunction %6 None %7 %8 = OpLabel OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(before, after, false, false); } TEST_F(CompactIdsTest, DebugScope) { const std::string text = R"(OpCapability Addresses OpCapability Kernel OpCapability GenericPointer OpCapability Linkage %5 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Physical32 OpenCL OpEntryPoint Kernel %3 "simple_kernel" %2 = OpString "test" %99 = OpTypeInt 32 0 %10 = OpTypeVector %99 2 %20 = OpConstant %99 2 %30 = OpTypeArray %99 %20 %40 = OpTypeVoid %50 = OpTypeFunction %40 %11 = OpExtInst %40 %5 DebugSource %2 %12 = OpExtInst %40 %5 DebugCompilationUnit 1 4 %11 HLSL %13 = OpExtInst %40 %5 DebugTypeFunction FlagIsProtected|FlagIsPrivate %40 ; CHECK: [[fn:%\w+]] = OpExtInst {{%\w+}} {{%\w+}} DebugFunction %14 = OpExtInst %40 %5 DebugFunction %2 %13 %11 0 0 %12 %2 FlagIsProtected|FlagIsPrivate 0 %3 %3 = OpFunction %40 None %50 %70 = OpLabel ; CHECK: DebugScope [[fn]] %19 = OpExtInst %40 %5 DebugScope %14 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndMatch(text, true); } TEST(CompactIds, InstructionResultIsUpdated) { // For https://github.com/KhronosGroup/SPIRV-Tools/issues/827 // In that bug, the compact Ids pass was directly updating the result Id // word for an OpFunction instruction, but not updating the cached // result_id_ in that Instruction object. // // This test is a bit cheesy. We don't expose internal interfaces enough // to see the inconsistency. So reproduce the original scenario, with // compact ids followed by a pass that trips up on the inconsistency. const std::string input(R"(OpCapability Shader OpMemoryModel Logical Simple OpEntryPoint GLCompute %100 "main" %200 = OpTypeVoid %300 = OpTypeFunction %200 %100 = OpFunction %200 None %300 %400 = OpLabel OpReturn OpFunctionEnd )"); std::vector binary; const spv_target_env env = SPV_ENV_UNIVERSAL_1_0; spvtools::SpirvTools tools(env); auto assembled = tools.Assemble( input, &binary, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); EXPECT_TRUE(assembled); spvtools::Optimizer optimizer(env); optimizer.RegisterPass(CreateCompactIdsPass()); // The exhaustive inliner will use the result_id optimizer.RegisterPass(CreateInlineExhaustivePass()); // This should not crash! optimizer.Run(binary.data(), binary.size(), &binary); std::string disassembly; tools.Disassemble(binary, &disassembly, SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); const std::string expected(R"(OpCapability Shader OpMemoryModel Logical Simple OpEntryPoint GLCompute %1 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %1 = OpFunction %2 None %3 %4 = OpLabel OpReturn OpFunctionEnd )"); EXPECT_THAT(disassembly, ::testing::Eq(expected)); } TEST(CompactIds, HeaderIsUpdated) { const std::string input(R"(OpCapability Shader OpMemoryModel Logical Simple OpEntryPoint GLCompute %100 "main" %200 = OpTypeVoid %300 = OpTypeFunction %200 %100 = OpFunction %200 None %300 %400 = OpLabel OpReturn OpFunctionEnd )"); std::vector binary; const spv_target_env env = SPV_ENV_UNIVERSAL_1_0; spvtools::SpirvTools tools(env); auto assembled = tools.Assemble( input, &binary, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); EXPECT_TRUE(assembled); spvtools::Optimizer optimizer(env); optimizer.RegisterPass(CreateCompactIdsPass()); // The exhaustive inliner will use the result_id optimizer.RegisterPass(CreateInlineExhaustivePass()); // This should not crash! optimizer.Run(binary.data(), binary.size(), &binary); std::string disassembly; tools.Disassemble(binary, &disassembly, SPV_BINARY_TO_TEXT_OPTION_NONE); const std::string expected(R"(; SPIR-V ; Version: 1.0 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 5 ; Schema: 0 OpCapability Shader OpMemoryModel Logical Simple OpEntryPoint GLCompute %1 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %1 = OpFunction %2 None %3 %4 = OpLabel OpReturn OpFunctionEnd )"); EXPECT_THAT(disassembly, ::testing::Eq(expected)); } // Test context consistency check after invalidating // CFG and others by compact IDs Pass. // Uses a GLSL shader with named labels for variety TEST(CompactIds, ConsistentCheck) { const std::string input(R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_A %out_var_SV_TARGET OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %main "main" OpName %in_var_A "in.var.A" OpName %out_var_SV_TARGET "out.var.SV_TARGET" OpDecorate %in_var_A Location 0 OpDecorate %out_var_SV_TARGET Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %in_var_A = OpVariable %_ptr_Input_v4float Input %out_var_SV_TARGET = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %3 %5 = OpLabel %12 = OpLoad %v4float %in_var_A %23 = OpVectorShuffle %v4float %12 %12 0 0 0 1 OpStore %out_var_SV_TARGET %23 OpReturn OpFunctionEnd )"); spvtools::SpirvTools tools(SPV_ENV_UNIVERSAL_1_1); std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, input, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); ASSERT_NE(context, nullptr); CompactIdsPass compact_id_pass; context->BuildInvalidAnalyses(compact_id_pass.GetPreservedAnalyses()); const auto status = compact_id_pass.Run(context.get()); ASSERT_NE(status, Pass::Status::Failure); EXPECT_TRUE(context->IsConsistent()); // Test output just in case std::vector binary; context->module()->ToBinary(&binary, false); std::string disassembly; tools.Disassemble(binary, &disassembly, SpirvTools::kDefaultDisassembleOption); const std::string expected(R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_A %out_var_SV_TARGET OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %main "main" OpName %in_var_A "in.var.A" OpName %out_var_SV_TARGET "out.var.SV_TARGET" OpDecorate %in_var_A Location 0 OpDecorate %out_var_SV_TARGET Location 0 %void = OpTypeVoid %5 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %in_var_A = OpVariable %_ptr_Input_v4float Input %out_var_SV_TARGET = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %5 %10 = OpLabel %11 = OpLoad %v4float %in_var_A %12 = OpVectorShuffle %v4float %11 %11 0 0 0 1 OpStore %out_var_SV_TARGET %12 OpReturn OpFunctionEnd )"); EXPECT_THAT(disassembly, ::testing::Eq(expected)); } TEST(CompactIds, ResetIdBound) { const std::string input(R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %3 = OpTypeFunction %void %1 = OpFunction %void None %3 %4 = OpLabel OpReturn OpFunctionEnd )"); spvtools::SpirvTools tools(SPV_ENV_UNIVERSAL_1_1); std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, input, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); ASSERT_NE(context, nullptr); CompactIdsPass compact_id_pass; context->module()->SetIdBound(20000); const auto status = compact_id_pass.Run(context.get()); EXPECT_EQ(status, Pass::Status::SuccessWithChange); EXPECT_EQ(context->module()->id_bound(), 5); // Test output just in case std::vector binary; context->module()->ToBinary(&binary, false); std::string disassembly; tools.Disassemble(binary, &disassembly, SpirvTools::kDefaultDisassembleOption); EXPECT_THAT(disassembly, ::testing::Eq(input)); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/constant_manager_test.cpp000066400000000000000000000070311475742701700254010ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gtest/gtest.h" #include "source/opt/build_module.h" #include "source/opt/constants.h" #include "source/opt/ir_context.h" namespace spvtools { namespace opt { namespace analysis { namespace { using ConstantManagerTest = ::testing::Test; TEST_F(ConstantManagerTest, GetDefiningInstruction) { const std::string text = R"( %int = OpTypeInt 32 0 %1 = OpTypeStruct %int %2 = OpTypeStruct %int )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); ASSERT_NE(context, nullptr); Type* struct_type_1 = context->get_type_mgr()->GetType(1); StructConstant struct_const_1(struct_type_1->AsStruct()); Instruction* const_inst_1 = context->get_constant_mgr()->GetDefiningInstruction(&struct_const_1, 1); EXPECT_EQ(const_inst_1->type_id(), 1); Type* struct_type_2 = context->get_type_mgr()->GetType(2); StructConstant struct_const_2(struct_type_2->AsStruct()); Instruction* const_inst_2 = context->get_constant_mgr()->GetDefiningInstruction(&struct_const_2, 2); EXPECT_EQ(const_inst_2->type_id(), 2); } TEST_F(ConstantManagerTest, GetDefiningInstruction2) { const std::string text = R"( %int = OpTypeInt 32 0 %1 = OpTypeStruct %int %2 = OpTypeStruct %int %3 = OpConstantNull %1 %4 = OpConstantNull %2 )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); ASSERT_NE(context, nullptr); Type* struct_type_1 = context->get_type_mgr()->GetType(1); NullConstant struct_const_1(struct_type_1->AsStruct()); Instruction* const_inst_1 = context->get_constant_mgr()->GetDefiningInstruction(&struct_const_1, 1); EXPECT_EQ(const_inst_1->type_id(), 1); EXPECT_EQ(const_inst_1->result_id(), 3); Type* struct_type_2 = context->get_type_mgr()->GetType(2); NullConstant struct_const_2(struct_type_2->AsStruct()); Instruction* const_inst_2 = context->get_constant_mgr()->GetDefiningInstruction(&struct_const_2, 2); EXPECT_EQ(const_inst_2->type_id(), 2); EXPECT_EQ(const_inst_2->result_id(), 4); } TEST_F(ConstantManagerTest, GetDefiningInstructionIdOverflow) { const std::string text = R"( %1 = OpTypeInt 32 0 %3 = OpConstant %1 1 %4 = OpConstant %1 2 )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); ASSERT_NE(context, nullptr); // Set the id bound to the max, so the new constant cannot be generated. context->module()->SetIdBound(context->max_id_bound()); Type* int_type = context->get_type_mgr()->GetType(1); IntConstant int_constant(int_type->AsInteger(), {3}); Instruction* inst = context->get_constant_mgr()->GetDefiningInstruction(&int_constant, 1); EXPECT_EQ(inst, nullptr); } } // namespace } // namespace analysis } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/constants_test.cpp000066400000000000000000000162431475742701700240770ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/constants.h" #include #include "gtest/gtest.h" #include "source/opt/types.h" namespace spvtools { namespace opt { namespace analysis { namespace { using ConstantTest = ::testing::Test; using ::testing::ValuesIn; template struct GetExtendedValueCase { bool is_signed; int width; std::vector words; T expected_value; }; using GetSignExtendedValueCase = GetExtendedValueCase; using GetZeroExtendedValueCase = GetExtendedValueCase; using GetSignExtendedValueTest = ::testing::TestWithParam; using GetZeroExtendedValueTest = ::testing::TestWithParam; TEST_P(GetSignExtendedValueTest, Case) { Integer type(GetParam().width, GetParam().is_signed); IntConstant value(&type, GetParam().words); EXPECT_EQ(GetParam().expected_value, value.GetSignExtendedValue()); } TEST_P(GetZeroExtendedValueTest, Case) { Integer type(GetParam().width, GetParam().is_signed); IntConstant value(&type, GetParam().words); EXPECT_EQ(GetParam().expected_value, value.GetZeroExtendedValue()); } const uint32_t k32ones = ~uint32_t(0); const uint64_t k64ones = ~uint64_t(0); const int64_t kSBillion = 1000 * 1000 * 1000; const uint64_t kUBillion = 1000 * 1000 * 1000; INSTANTIATE_TEST_SUITE_P(AtMost32Bits, GetSignExtendedValueTest, ValuesIn(std::vector{ // 4 bits {false, 4, {0}, 0}, {false, 4, {7}, 7}, {false, 4, {15}, 15}, {true, 4, {0}, 0}, {true, 4, {7}, 7}, {true, 4, {0xfffffff8}, -8}, {true, 4, {k32ones}, -1}, // 16 bits {false, 16, {0}, 0}, {false, 16, {32767}, 32767}, {false, 16, {32768}, 32768}, {false, 16, {65000}, 65000}, {true, 16, {0}, 0}, {true, 16, {32767}, 32767}, {true, 16, {0xfffffff8}, -8}, {true, 16, {k32ones}, -1}, // 32 bits {false, 32, {0}, 0}, {false, 32, {1000000}, 1000000}, {true, 32, {0xfffffff8}, -8}, {true, 32, {k32ones}, -1}, })); INSTANTIATE_TEST_SUITE_P(AtMost64Bits, GetSignExtendedValueTest, ValuesIn(std::vector{ // 48 bits {false, 48, {0, 0}, 0}, {false, 48, {5, 0}, 5}, {false, 48, {0xfffffff8, k32ones}, -8}, {false, 48, {k32ones, k32ones}, -1}, {false, 48, {0xdcd65000, 1}, 8 * kSBillion}, {true, 48, {0xfffffff8, k32ones}, -8}, {true, 48, {k32ones, k32ones}, -1}, {true, 48, {0xdcd65000, 1}, 8 * kSBillion}, // 64 bits {false, 64, {12, 0}, 12}, {false, 64, {0xdcd65000, 1}, 8 * kSBillion}, {false, 48, {0xfffffff8, k32ones}, -8}, {false, 64, {k32ones, k32ones}, -1}, {true, 64, {12, 0}, 12}, {true, 64, {0xdcd65000, 1}, 8 * kSBillion}, {true, 48, {0xfffffff8, k32ones}, -8}, {true, 64, {k32ones, k32ones}, -1}, })); INSTANTIATE_TEST_SUITE_P(AtMost32Bits, GetZeroExtendedValueTest, ValuesIn(std::vector{ // 4 bits {false, 4, {0}, 0}, {false, 4, {7}, 7}, {false, 4, {15}, 15}, {true, 4, {0}, 0}, {true, 4, {7}, 7}, {true, 4, {0xfffffff8}, 0xfffffff8}, {true, 4, {k32ones}, k32ones}, // 16 bits {false, 16, {0}, 0}, {false, 16, {32767}, 32767}, {false, 16, {32768}, 32768}, {false, 16, {65000}, 65000}, {true, 16, {0}, 0}, {true, 16, {32767}, 32767}, {true, 16, {0xfffffff8}, 0xfffffff8}, {true, 16, {k32ones}, k32ones}, // 32 bits {false, 32, {0}, 0}, {false, 32, {1000000}, 1000000}, {true, 32, {0xfffffff8}, 0xfffffff8}, {true, 32, {k32ones}, k32ones}, })); INSTANTIATE_TEST_SUITE_P(AtMost64Bits, GetZeroExtendedValueTest, ValuesIn(std::vector{ // 48 bits {false, 48, {0, 0}, 0}, {false, 48, {5, 0}, 5}, {false, 48, {0xfffffff8, k32ones}, uint64_t(-8)}, {false, 48, {k32ones, k32ones}, uint64_t(-1)}, {false, 48, {0xdcd65000, 1}, 8 * kUBillion}, {true, 48, {0xfffffff8, k32ones}, uint64_t(-8)}, {true, 48, {k32ones, k32ones}, uint64_t(-1)}, {true, 48, {0xdcd65000, 1}, 8 * kUBillion}, // 64 bits {false, 64, {12, 0}, 12}, {false, 64, {0xdcd65000, 1}, 8 * kUBillion}, {false, 48, {0xfffffff8, k32ones}, uint64_t(-8)}, {false, 64, {k32ones, k32ones}, k64ones}, {true, 64, {12, 0}, 12}, {true, 64, {0xdcd65000, 1}, 8 * kUBillion}, {true, 48, {0xfffffff8, k32ones}, uint64_t(-8)}, {true, 64, {k32ones, k32ones}, k64ones}, })); } // namespace } // namespace analysis } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/control_dependence.cpp000066400000000000000000000235441475742701700246600ustar00rootroot00000000000000// Copyright (c) 2021 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/control_dependence.h" #include #include #include "gmock/gmock-matchers.h" #include "gtest/gtest.h" #include "source/opt/build_module.h" #include "source/opt/cfg.h" #include "test/opt/function_utils.h" namespace spvtools { namespace opt { namespace { void GatherEdges(const ControlDependenceAnalysis& cdg, std::vector& ret) { cdg.ForEachBlockLabel([&](uint32_t label) { ret.reserve(ret.size() + cdg.GetDependenceTargets(label).size()); ret.insert(ret.end(), cdg.GetDependenceTargets(label).begin(), cdg.GetDependenceTargets(label).end()); }); std::sort(ret.begin(), ret.end()); // Verify that reverse graph is the same. std::vector reverse_edges; reverse_edges.reserve(ret.size()); cdg.ForEachBlockLabel([&](uint32_t label) { reverse_edges.insert(reverse_edges.end(), cdg.GetDependenceSources(label).begin(), cdg.GetDependenceSources(label).end()); }); std::sort(reverse_edges.begin(), reverse_edges.end()); ASSERT_THAT(reverse_edges, testing::ElementsAreArray(ret)); } using ControlDependenceTest = ::testing::Test; TEST(ControlDependenceTest, DependenceSimpleCFG) { const std::string text = R"( OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %1 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeBool %5 = OpTypeInt 32 0 %6 = OpConstant %5 0 %7 = OpConstantFalse %4 %8 = OpConstantTrue %4 %9 = OpConstant %5 1 %1 = OpFunction %2 None %3 %10 = OpLabel OpBranch %11 %11 = OpLabel OpSwitch %6 %12 1 %13 %12 = OpLabel OpBranch %14 %13 = OpLabel OpBranch %14 %14 = OpLabel OpBranchConditional %8 %15 %16 %15 = OpLabel OpBranch %19 %16 = OpLabel OpBranchConditional %8 %17 %18 %17 = OpLabel OpBranch %18 %18 = OpLabel OpBranch %19 %19 = OpLabel OpReturn OpFunctionEnd )"; // CFG: (all edges pointing downward) // %10 // | // %11 // / \ (R: %6 == 1, L: default) // %12 %13 // \ / // %14 // T/ \F // %15 %16 // | T/ |F // | %17| // | \ | // | %18 // | / // %19 std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_0, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* fn = spvtest::GetFunction(module, 1); const BasicBlock* entry = spvtest::GetBasicBlock(fn, 10); EXPECT_EQ(entry, fn->entry().get()) << "The entry node is not the expected one"; { PostDominatorAnalysis pdom; const CFG& cfg = *context->cfg(); pdom.InitializeTree(cfg, fn); ControlDependenceAnalysis cdg; cdg.ComputeControlDependenceGraph(cfg, pdom); // Test HasBlock. for (uint32_t id = 10; id <= 19; id++) { EXPECT_TRUE(cdg.HasBlock(id)); } EXPECT_TRUE(cdg.HasBlock(ControlDependenceAnalysis::kPseudoEntryBlock)); // Check blocks before/after valid range. EXPECT_FALSE(cdg.HasBlock(5)); EXPECT_FALSE(cdg.HasBlock(25)); EXPECT_FALSE(cdg.HasBlock(UINT32_MAX)); // Test ForEachBlockLabel. std::set block_labels; cdg.ForEachBlockLabel([&block_labels](uint32_t id) { bool inserted = block_labels.insert(id).second; EXPECT_TRUE(inserted); // Should have no duplicates. }); EXPECT_THAT(block_labels, testing::ElementsAre(0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19)); { // Test WhileEachBlockLabel. uint32_t iters = 0; EXPECT_TRUE(cdg.WhileEachBlockLabel([&iters](uint32_t) { ++iters; return true; })); EXPECT_EQ((uint32_t)block_labels.size(), iters); iters = 0; EXPECT_FALSE(cdg.WhileEachBlockLabel([&iters](uint32_t) { ++iters; return false; })); EXPECT_EQ(1, iters); } // Test IsDependent. EXPECT_TRUE(cdg.IsDependent(12, 11)); EXPECT_TRUE(cdg.IsDependent(13, 11)); EXPECT_TRUE(cdg.IsDependent(15, 14)); EXPECT_TRUE(cdg.IsDependent(16, 14)); EXPECT_TRUE(cdg.IsDependent(18, 14)); EXPECT_TRUE(cdg.IsDependent(17, 16)); EXPECT_TRUE(cdg.IsDependent(10, 0)); EXPECT_TRUE(cdg.IsDependent(11, 0)); EXPECT_TRUE(cdg.IsDependent(14, 0)); EXPECT_TRUE(cdg.IsDependent(19, 0)); EXPECT_FALSE(cdg.IsDependent(14, 11)); EXPECT_FALSE(cdg.IsDependent(17, 14)); EXPECT_FALSE(cdg.IsDependent(19, 14)); EXPECT_FALSE(cdg.IsDependent(12, 0)); // Test GetDependenceSources/Targets. std::vector edges; GatherEdges(cdg, edges); EXPECT_THAT(edges, testing::ElementsAre( ControlDependence(0, 10), ControlDependence(0, 11, 10), ControlDependence(0, 14, 10), ControlDependence(0, 19, 10), ControlDependence(11, 12), ControlDependence(11, 13), ControlDependence(14, 15), ControlDependence(14, 16), ControlDependence(14, 18, 16), ControlDependence(16, 17))); const uint32_t expected_condition_ids[] = { 0, 0, 0, 0, 6, 6, 8, 8, 8, 8, }; for (uint32_t i = 0; i < edges.size(); i++) { EXPECT_EQ(expected_condition_ids[i], edges[i].GetConditionID(cfg)); } } } TEST(ControlDependenceTest, DependencePaperCFG) { const std::string text = R"( OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %101 "main" %102 = OpTypeVoid %103 = OpTypeFunction %102 %104 = OpTypeBool %108 = OpConstantTrue %104 %101 = OpFunction %102 None %103 %1 = OpLabel OpBranch %2 %2 = OpLabel OpBranchConditional %108 %3 %7 %3 = OpLabel OpBranchConditional %108 %4 %5 %4 = OpLabel OpBranch %6 %5 = OpLabel OpBranch %6 %6 = OpLabel OpBranch %8 %7 = OpLabel OpBranch %8 %8 = OpLabel OpBranch %9 %9 = OpLabel OpBranchConditional %108 %10 %11 %10 = OpLabel OpBranch %11 %11 = OpLabel OpBranchConditional %108 %12 %9 %12 = OpLabel OpBranchConditional %108 %13 %2 %13 = OpLabel OpReturn OpFunctionEnd )"; // CFG: (edges pointing downward if no arrow) // %1 // | // %2 <----+ // T/ \F | // %3 \ | // T/ \F \ | // %4 %5 %7 | // \ / / | // %6 / | // \ / | // %8 | // | | // %9 <-+ | // T/ | | | // %10 | | | // \ | | | // %11-F+ | // T| | // %12-F---+ // T| // %13 std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_0, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* fn = spvtest::GetFunction(module, 101); const BasicBlock* entry = spvtest::GetBasicBlock(fn, 1); EXPECT_EQ(entry, fn->entry().get()) << "The entry node is not the expected one"; { PostDominatorAnalysis pdom; const CFG& cfg = *context->cfg(); pdom.InitializeTree(cfg, fn); ControlDependenceAnalysis cdg; cdg.ComputeControlDependenceGraph(cfg, pdom); std::vector edges; GatherEdges(cdg, edges); EXPECT_THAT( edges, testing::ElementsAre( ControlDependence(0, 1), ControlDependence(0, 2, 1), ControlDependence(0, 8, 1), ControlDependence(0, 9, 1), ControlDependence(0, 11, 1), ControlDependence(0, 12, 1), ControlDependence(0, 13, 1), ControlDependence(2, 3), ControlDependence(2, 6, 3), ControlDependence(2, 7), ControlDependence(3, 4), ControlDependence(3, 5), ControlDependence(9, 10), ControlDependence(11, 9), ControlDependence(11, 11, 9), ControlDependence(12, 2), ControlDependence(12, 8, 2), ControlDependence(12, 9, 2), ControlDependence(12, 11, 2), ControlDependence(12, 12, 2))); const uint32_t expected_condition_ids[] = { 0, 0, 0, 0, 0, 0, 0, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, }; for (uint32_t i = 0; i < edges.size(); i++) { EXPECT_EQ(expected_condition_ids[i], edges[i].GetConditionID(cfg)); } } } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/convert_relaxed_to_half_test.cpp000066400000000000000000001624661475742701700267540ustar00rootroot00000000000000// Copyright (c) 2019 Valve Corporation // Copyright (c) 2019 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Convert Relaxed to Half tests #include #include #include "test/opt/assembly_builder.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using ConvertToHalfTest = PassTest<::testing::Test>; TEST_F(ConvertToHalfTest, ConvertToHalfBasic) { // The resulting SPIR-V was processed with --relax-float-ops. // // clang-format off // // SamplerState g_sSamp : register(s0); // uniform Texture1D g_tTex1df4 : register(t0); // // struct PS_INPUT // { // float Tex0 : TEXCOORD0; // }; // // struct PS_OUTPUT // { // float4 Color : SV_Target0; // }; // // cbuffer cbuff{ // float c; // } // // PS_OUTPUT main(PS_INPUT i) // { // PS_OUTPUT psout; // psout.Color = g_tTex1df4.Sample(g_sSamp, i.Tex0) * c; // return psout; // } // // clang-format on const std::string defs_before = R"(OpCapability Shader OpCapability Sampled1D %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %i_Tex0 %_entryPointOutput_Color OpExecutionMode %main OriginUpperLeft OpSource HLSL 500 OpName %main "main" OpName %g_tTex1df4 "g_tTex1df4" OpName %g_sSamp "g_sSamp" OpName %cbuff "cbuff" OpMemberName %cbuff 0 "c" OpName %_ "" OpName %i_Tex0 "i.Tex0" OpName %_entryPointOutput_Color "@entryPointOutput.Color" OpDecorate %g_tTex1df4 DescriptorSet 0 OpDecorate %g_tTex1df4 Binding 0 OpDecorate %g_sSamp DescriptorSet 0 OpDecorate %g_sSamp Binding 0 OpMemberDecorate %cbuff 0 Offset 0 OpDecorate %cbuff Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 1 OpDecorate %i_Tex0 Location 0 OpDecorate %_entryPointOutput_Color Location 0 OpDecorate %48 RelaxedPrecision OpDecorate %63 RelaxedPrecision OpDecorate %65 RelaxedPrecision OpDecorate %66 RelaxedPrecision %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %19 = OpTypeImage %float 1D 0 0 0 1 Unknown %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %g_tTex1df4 = OpVariable %_ptr_UniformConstant_19 UniformConstant %23 = OpTypeSampler %_ptr_UniformConstant_23 = OpTypePointer UniformConstant %23 %g_sSamp = OpVariable %_ptr_UniformConstant_23 UniformConstant %27 = OpTypeSampledImage %19 %cbuff = OpTypeStruct %float %_ptr_Uniform_cbuff = OpTypePointer Uniform %cbuff %_ = OpVariable %_ptr_Uniform_cbuff Uniform %_ptr_Uniform_float = OpTypePointer Uniform %float %_ptr_Input_float = OpTypePointer Input %float %i_Tex0 = OpVariable %_ptr_Input_float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput_Color = OpVariable %_ptr_Output_v4float Output )"; const std::string defs_after = R"(OpCapability Shader OpCapability Sampled1D OpCapability Float16 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %i_Tex0 %_entryPointOutput_Color OpExecutionMode %main OriginUpperLeft OpSource HLSL 500 OpName %main "main" OpName %g_tTex1df4 "g_tTex1df4" OpName %g_sSamp "g_sSamp" OpName %cbuff "cbuff" OpMemberName %cbuff 0 "c" OpName %_ "" OpName %i_Tex0 "i.Tex0" OpName %_entryPointOutput_Color "@entryPointOutput.Color" OpDecorate %g_tTex1df4 DescriptorSet 0 OpDecorate %g_tTex1df4 Binding 0 OpDecorate %g_sSamp DescriptorSet 0 OpDecorate %g_sSamp Binding 0 OpMemberDecorate %cbuff 0 Offset 0 OpDecorate %cbuff Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 1 OpDecorate %i_Tex0 Location 0 OpDecorate %_entryPointOutput_Color Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %19 = OpTypeImage %float 1D 0 0 0 1 Unknown %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %g_tTex1df4 = OpVariable %_ptr_UniformConstant_19 UniformConstant %23 = OpTypeSampler %_ptr_UniformConstant_23 = OpTypePointer UniformConstant %23 %g_sSamp = OpVariable %_ptr_UniformConstant_23 UniformConstant %27 = OpTypeSampledImage %19 %cbuff = OpTypeStruct %float %_ptr_Uniform_cbuff = OpTypePointer Uniform %cbuff %_ = OpVariable %_ptr_Uniform_cbuff Uniform %_ptr_Uniform_float = OpTypePointer Uniform %float %_ptr_Input_float = OpTypePointer Input %float %i_Tex0 = OpVariable %_ptr_Input_float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput_Color = OpVariable %_ptr_Output_v4float Output %half = OpTypeFloat 16 %v4half = OpTypeVector %half 4 )"; const std::string func_before = R"(%main = OpFunction %void None %3 %5 = OpLabel %48 = OpLoad %float %i_Tex0 %58 = OpLoad %19 %g_tTex1df4 %59 = OpLoad %23 %g_sSamp %60 = OpSampledImage %27 %58 %59 %63 = OpImageSampleImplicitLod %v4float %60 %48 %64 = OpAccessChain %_ptr_Uniform_float %_ %int_0 %65 = OpLoad %float %64 %66 = OpVectorTimesScalar %v4float %63 %65 OpStore %_entryPointOutput_Color %66 OpReturn OpFunctionEnd )"; const std::string func_after = R"(%main = OpFunction %void None %3 %5 = OpLabel %48 = OpLoad %float %i_Tex0 %58 = OpLoad %19 %g_tTex1df4 %59 = OpLoad %23 %g_sSamp %60 = OpSampledImage %27 %58 %59 %63 = OpImageSampleImplicitLod %v4float %60 %48 %64 = OpAccessChain %_ptr_Uniform_float %_ %int_0 %65 = OpLoad %float %64 %69 = OpFConvert %v4half %63 %70 = OpFConvert %half %65 %66 = OpVectorTimesScalar %v4half %69 %70 %71 = OpFConvert %v4float %66 OpStore %_entryPointOutput_Color %71 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(defs_before + func_before, defs_after + func_after, true, true); } TEST_F(ConvertToHalfTest, ConvertToHalfForLinkage) { const std::string before = R"(OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpSource HLSL 630 OpName %type_cbuff "type.cbuff" OpMemberName %type_cbuff 0 "c" OpName %cbuff "cbuff" OpName %main "main" OpName %BaseColor "BaseColor" OpName %bb_entry "bb.entry" OpName %v "v" OpDecorate %main LinkageAttributes "main" Export OpDecorate %cbuff DescriptorSet 0 OpDecorate %cbuff Binding 0 OpMemberDecorate %type_cbuff 0 Offset 0 OpDecorate %type_cbuff Block OpDecorate %18 RelaxedPrecision %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %type_cbuff = OpTypeStruct %float %_ptr_Uniform_type_cbuff = OpTypePointer Uniform %type_cbuff %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %9 = OpTypeFunction %v4float %_ptr_Function_v4float %_ptr_Uniform_float = OpTypePointer Uniform %float %cbuff = OpVariable %_ptr_Uniform_type_cbuff Uniform %main = OpFunction %v4float None %9 %BaseColor = OpFunctionParameter %_ptr_Function_v4float %bb_entry = OpLabel %v = OpVariable %_ptr_Function_v4float Function %14 = OpLoad %v4float %BaseColor %16 = OpAccessChain %_ptr_Uniform_float %cbuff %int_0 %17 = OpLoad %float %16 %18 = OpVectorTimesScalar %v4float %14 %17 OpStore %v %18 %19 = OpLoad %v4float %v OpReturnValue %19 OpFunctionEnd )"; const std::string after = R"(OpCapability Shader OpCapability Linkage OpCapability Float16 OpMemoryModel Logical GLSL450 OpSource HLSL 630 OpName %type_cbuff "type.cbuff" OpMemberName %type_cbuff 0 "c" OpName %cbuff "cbuff" OpName %main "main" OpName %BaseColor "BaseColor" OpName %bb_entry "bb.entry" OpName %v "v" OpDecorate %main LinkageAttributes "main" Export OpDecorate %cbuff DescriptorSet 0 OpDecorate %cbuff Binding 0 OpMemberDecorate %type_cbuff 0 Offset 0 OpDecorate %type_cbuff Block %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %type_cbuff = OpTypeStruct %float %_ptr_Uniform_type_cbuff = OpTypePointer Uniform %type_cbuff %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %14 = OpTypeFunction %v4float %_ptr_Function_v4float %_ptr_Uniform_float = OpTypePointer Uniform %float %cbuff = OpVariable %_ptr_Uniform_type_cbuff Uniform %half = OpTypeFloat 16 %v4half = OpTypeVector %half 4 %main = OpFunction %v4float None %14 %BaseColor = OpFunctionParameter %_ptr_Function_v4float %bb_entry = OpLabel %v = OpVariable %_ptr_Function_v4float Function %16 = OpLoad %v4float %BaseColor %17 = OpAccessChain %_ptr_Uniform_float %cbuff %int_0 %18 = OpLoad %float %17 %22 = OpFConvert %v4half %16 %23 = OpFConvert %half %18 %7 = OpVectorTimesScalar %v4half %22 %23 %24 = OpFConvert %v4float %7 OpStore %v %24 %19 = OpLoad %v4float %v OpReturnValue %19 OpFunctionEnd )"; SinglePassRunAndCheck(before, after, true, true); } TEST_F(ConvertToHalfTest, ConvertToHalfWithDrefSample) { // The resulting SPIR-V was processed with --relax-float-ops. // // clang-format off // // SamplerComparisonState g_sSamp : register(s0); // uniform Texture1D g_tTex1df4 : register(t0); // // cbuffer cbuff{ // float c1; // float c2; // }; // // struct PS_INPUT // { // float Tex0 : TEXCOORD0; // float Tex1 : TEXCOORD1; // }; // // struct PS_OUTPUT // { // float Color : SV_Target0; // }; // // PS_OUTPUT main(PS_INPUT i) // { // PS_OUTPUT psout; // float txval10 = g_tTex1df4.SampleCmp(g_sSamp, i.Tex0 * 0.1, c1 + 0.1); // float txval11 = g_tTex1df4.SampleCmp(g_sSamp, i.Tex1 * 0.2, c2 + 0.2); // float t = txval10 + txval11; // float t2 = t / 2.0; // psout.Color = t2; // return psout; // } // // clang-format on const std::string defs_before = R"(OpCapability Shader OpCapability Sampled1D %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %i_Tex0 %i_Tex1 %_entryPointOutput_Color OpExecutionMode %main OriginUpperLeft OpSource HLSL 500 OpName %main "main" OpName %g_tTex1df4 "g_tTex1df4" OpName %g_sSamp "g_sSamp" OpName %cbuff "cbuff" OpMemberName %cbuff 0 "c1" OpMemberName %cbuff 1 "c2" OpName %_ "" OpName %i_Tex0 "i.Tex0" OpName %i_Tex1 "i.Tex1" OpName %_entryPointOutput_Color "@entryPointOutput.Color" OpDecorate %g_tTex1df4 DescriptorSet 0 OpDecorate %g_tTex1df4 Binding 0 OpDecorate %g_sSamp DescriptorSet 0 OpDecorate %g_sSamp Binding 0 OpMemberDecorate %cbuff 0 Offset 0 OpMemberDecorate %cbuff 1 Offset 4 OpDecorate %cbuff Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 1 OpDecorate %i_Tex0 Location 0 OpDecorate %i_Tex1 Location 1 OpDecorate %_entryPointOutput_Color Location 0 OpDecorate %100 RelaxedPrecision OpDecorate %76 RelaxedPrecision OpDecorate %79 RelaxedPrecision OpDecorate %98 RelaxedPrecision OpDecorate %101 RelaxedPrecision OpDecorate %110 RelaxedPrecision OpDecorate %102 RelaxedPrecision OpDecorate %112 RelaxedPrecision OpDecorate %104 RelaxedPrecision OpDecorate %113 RelaxedPrecision OpDecorate %114 RelaxedPrecision OpDecorate %116 RelaxedPrecision OpDecorate %119 RelaxedPrecision OpDecorate %121 RelaxedPrecision %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %16 = OpTypeImage %float 1D 1 0 0 1 Unknown %_ptr_UniformConstant_16 = OpTypePointer UniformConstant %16 %g_tTex1df4 = OpVariable %_ptr_UniformConstant_16 UniformConstant %20 = OpTypeSampler %_ptr_UniformConstant_20 = OpTypePointer UniformConstant %20 %g_sSamp = OpVariable %_ptr_UniformConstant_20 UniformConstant %24 = OpTypeSampledImage %16 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float_0_100000001 = OpConstant %float 0.100000001 %cbuff = OpTypeStruct %float %float %_ptr_Uniform_cbuff = OpTypePointer Uniform %cbuff %_ = OpVariable %_ptr_Uniform_cbuff Uniform %_ptr_Uniform_float = OpTypePointer Uniform %float %v2float = OpTypeVector %float 2 %int_1 = OpConstant %int 1 %float_0_200000003 = OpConstant %float 0.200000003 %_ptr_Input_float = OpTypePointer Input %float %i_Tex0 = OpVariable %_ptr_Input_float Input %i_Tex1 = OpVariable %_ptr_Input_float Input %_ptr_Output_float = OpTypePointer Output %float %_entryPointOutput_Color = OpVariable %_ptr_Output_float Output %float_0_5 = OpConstant %float 0.5 )"; const std::string defs_after = R"(OpCapability Shader OpCapability Sampled1D OpCapability Float16 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %i_Tex0 %i_Tex1 %_entryPointOutput_Color OpExecutionMode %main OriginUpperLeft OpSource HLSL 500 OpName %main "main" OpName %g_tTex1df4 "g_tTex1df4" OpName %g_sSamp "g_sSamp" OpName %cbuff "cbuff" OpMemberName %cbuff 0 "c1" OpMemberName %cbuff 1 "c2" OpName %_ "" OpName %i_Tex0 "i.Tex0" OpName %i_Tex1 "i.Tex1" OpName %_entryPointOutput_Color "@entryPointOutput.Color" OpDecorate %g_tTex1df4 DescriptorSet 0 OpDecorate %g_tTex1df4 Binding 0 OpDecorate %g_sSamp DescriptorSet 0 OpDecorate %g_sSamp Binding 0 OpMemberDecorate %cbuff 0 Offset 0 OpMemberDecorate %cbuff 1 Offset 4 OpDecorate %cbuff Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 1 OpDecorate %i_Tex0 Location 0 OpDecorate %i_Tex1 Location 1 OpDecorate %_entryPointOutput_Color Location 0 %void = OpTypeVoid %25 = OpTypeFunction %void %float = OpTypeFloat 32 %27 = OpTypeImage %float 1D 1 0 0 1 Unknown %_ptr_UniformConstant_27 = OpTypePointer UniformConstant %27 %g_tTex1df4 = OpVariable %_ptr_UniformConstant_27 UniformConstant %29 = OpTypeSampler %_ptr_UniformConstant_29 = OpTypePointer UniformConstant %29 %g_sSamp = OpVariable %_ptr_UniformConstant_29 UniformConstant %31 = OpTypeSampledImage %27 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float_0_100000001 = OpConstant %float 0.100000001 %cbuff = OpTypeStruct %float %float %_ptr_Uniform_cbuff = OpTypePointer Uniform %cbuff %_ = OpVariable %_ptr_Uniform_cbuff Uniform %_ptr_Uniform_float = OpTypePointer Uniform %float %v2float = OpTypeVector %float 2 %int_1 = OpConstant %int 1 %float_0_200000003 = OpConstant %float 0.200000003 %_ptr_Input_float = OpTypePointer Input %float %i_Tex0 = OpVariable %_ptr_Input_float Input %i_Tex1 = OpVariable %_ptr_Input_float Input %_ptr_Output_float = OpTypePointer Output %float %_entryPointOutput_Color = OpVariable %_ptr_Output_float Output %float_0_5 = OpConstant %float 0.5 %half = OpTypeFloat 16 %v2half = OpTypeVector %half 2 )"; const std::string func_before = R"(%main = OpFunction %void None %3 %5 = OpLabel %76 = OpLoad %float %i_Tex0 %79 = OpLoad %float %i_Tex1 %93 = OpLoad %16 %g_tTex1df4 %94 = OpLoad %20 %g_sSamp %95 = OpSampledImage %24 %93 %94 %98 = OpFMul %float %76 %float_0_100000001 %99 = OpAccessChain %_ptr_Uniform_float %_ %int_0 %100 = OpLoad %float %99 %101 = OpFAdd %float %100 %float_0_100000001 %102 = OpCompositeConstruct %v2float %98 %101 %104 = OpImageSampleDrefImplicitLod %float %95 %102 %101 %105 = OpLoad %16 %g_tTex1df4 %106 = OpLoad %20 %g_sSamp %107 = OpSampledImage %24 %105 %106 %110 = OpFMul %float %79 %float_0_200000003 %111 = OpAccessChain %_ptr_Uniform_float %_ %int_1 %112 = OpLoad %float %111 %113 = OpFAdd %float %112 %float_0_200000003 %114 = OpCompositeConstruct %v2float %110 %113 %116 = OpImageSampleDrefImplicitLod %float %107 %114 %113 %119 = OpFAdd %float %104 %116 %121 = OpFMul %float %119 %float_0_5 OpStore %_entryPointOutput_Color %121 OpReturn OpFunctionEnd )"; const std::string func_after = R"(%main = OpFunction %void None %25 %43 = OpLabel %11 = OpLoad %float %i_Tex0 %12 = OpLoad %float %i_Tex1 %44 = OpLoad %27 %g_tTex1df4 %45 = OpLoad %29 %g_sSamp %46 = OpSampledImage %31 %44 %45 %53 = OpFConvert %half %11 %54 = OpFConvert %half %float_0_100000001 %13 = OpFMul %half %53 %54 %47 = OpAccessChain %_ptr_Uniform_float %_ %int_0 %10 = OpLoad %float %47 %55 = OpFConvert %half %10 %56 = OpFConvert %half %float_0_100000001 %14 = OpFAdd %half %55 %56 %16 = OpCompositeConstruct %v2half %13 %14 %58 = OpFConvert %float %14 %18 = OpImageSampleDrefImplicitLod %float %46 %16 %58 %48 = OpLoad %27 %g_tTex1df4 %49 = OpLoad %29 %g_sSamp %50 = OpSampledImage %31 %48 %49 %59 = OpFConvert %half %12 %60 = OpFConvert %half %float_0_200000003 %15 = OpFMul %half %59 %60 %51 = OpAccessChain %_ptr_Uniform_float %_ %int_1 %17 = OpLoad %float %51 %61 = OpFConvert %half %17 %62 = OpFConvert %half %float_0_200000003 %19 = OpFAdd %half %61 %62 %20 = OpCompositeConstruct %v2half %15 %19 %63 = OpFConvert %float %19 %21 = OpImageSampleDrefImplicitLod %float %50 %20 %63 %64 = OpFConvert %half %18 %65 = OpFConvert %half %21 %22 = OpFAdd %half %64 %65 %66 = OpFConvert %half %float_0_5 %23 = OpFMul %half %22 %66 %67 = OpFConvert %float %23 OpStore %_entryPointOutput_Color %67 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(defs_before + func_before, defs_after + func_after, true, true); } TEST_F(ConvertToHalfTest, ConvertToHalfWithVectorMatrixMult) { // The resulting SPIR-V was processed with --relax-float-ops. // // clang-format off // // SamplerState g_sSamp : register(s0); // uniform Texture1D g_tTex1df4 : register(t0); // // struct PS_OUTPUT // { // float4 Color : SV_Target0; // }; // // cbuffer cbuff{ // float4x4 M; // } // // PS_OUTPUT main() // { // PS_OUTPUT psout; // float4 txval10 = g_tTex1df4.Sample(g_sSamp, 0.1); // float4 t = mul(txval10, M); // psout.Color = t; // return psout; //} // // clang-format on const std::string defs_before = R"(OpCapability Shader OpCapability Sampled1D %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %_entryPointOutput_Color OpExecutionMode %main OriginUpperLeft OpSource HLSL 500 OpName %main "main" OpName %g_tTex1df4 "g_tTex1df4" OpName %g_sSamp "g_sSamp" OpName %cbuff "cbuff" OpMemberName %cbuff 0 "M" OpName %_ "" OpName %_entryPointOutput_Color "@entryPointOutput.Color" OpDecorate %g_tTex1df4 DescriptorSet 0 OpDecorate %g_tTex1df4 Binding 0 OpDecorate %g_sSamp DescriptorSet 0 OpDecorate %g_sSamp Binding 0 OpMemberDecorate %cbuff 0 RowMajor OpMemberDecorate %cbuff 0 Offset 0 OpMemberDecorate %cbuff 0 MatrixStride 16 OpDecorate %cbuff Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 1 OpDecorate %_entryPointOutput_Color Location 0 OpDecorate %56 RelaxedPrecision OpDecorate %58 RelaxedPrecision OpDecorate %60 RelaxedPrecision %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %14 = OpTypeImage %float 1D 0 0 0 1 Unknown %_ptr_UniformConstant_14 = OpTypePointer UniformConstant %14 %g_tTex1df4 = OpVariable %_ptr_UniformConstant_14 UniformConstant %18 = OpTypeSampler %_ptr_UniformConstant_18 = OpTypePointer UniformConstant %18 %g_sSamp = OpVariable %_ptr_UniformConstant_18 UniformConstant %22 = OpTypeSampledImage %14 %float_0_100000001 = OpConstant %float 0.100000001 %mat4v4float = OpTypeMatrix %v4float 4 %cbuff = OpTypeStruct %mat4v4float %_ptr_Uniform_cbuff = OpTypePointer Uniform %cbuff %_ = OpVariable %_ptr_Uniform_cbuff Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_mat4v4float = OpTypePointer Uniform %mat4v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput_Color = OpVariable %_ptr_Output_v4float Output )"; const std::string defs_after = R"(OpCapability Shader OpCapability Sampled1D OpCapability Float16 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %_entryPointOutput_Color OpExecutionMode %main OriginUpperLeft OpSource HLSL 500 OpName %main "main" OpName %g_tTex1df4 "g_tTex1df4" OpName %g_sSamp "g_sSamp" OpName %cbuff "cbuff" OpMemberName %cbuff 0 "M" OpName %_ "" OpName %_entryPointOutput_Color "@entryPointOutput.Color" OpDecorate %g_tTex1df4 DescriptorSet 0 OpDecorate %g_tTex1df4 Binding 0 OpDecorate %g_sSamp DescriptorSet 0 OpDecorate %g_sSamp Binding 0 OpMemberDecorate %cbuff 0 RowMajor OpMemberDecorate %cbuff 0 Offset 0 OpMemberDecorate %cbuff 0 MatrixStride 16 OpDecorate %cbuff Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 1 OpDecorate %_entryPointOutput_Color Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %14 = OpTypeImage %float 1D 0 0 0 1 Unknown %_ptr_UniformConstant_14 = OpTypePointer UniformConstant %14 %g_tTex1df4 = OpVariable %_ptr_UniformConstant_14 UniformConstant %18 = OpTypeSampler %_ptr_UniformConstant_18 = OpTypePointer UniformConstant %18 %g_sSamp = OpVariable %_ptr_UniformConstant_18 UniformConstant %22 = OpTypeSampledImage %14 %float_0_100000001 = OpConstant %float 0.100000001 %mat4v4float = OpTypeMatrix %v4float 4 %cbuff = OpTypeStruct %mat4v4float %_ptr_Uniform_cbuff = OpTypePointer Uniform %cbuff %_ = OpVariable %_ptr_Uniform_cbuff Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_mat4v4float = OpTypePointer Uniform %mat4v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput_Color = OpVariable %_ptr_Output_v4float Output %half = OpTypeFloat 16 %v4half = OpTypeVector %half 4 %mat4v4half = OpTypeMatrix %v4half 4 )"; const std::string func_before = R"(%main = OpFunction %void None %3 %5 = OpLabel %53 = OpLoad %14 %g_tTex1df4 %54 = OpLoad %18 %g_sSamp %55 = OpSampledImage %22 %53 %54 %56 = OpImageSampleImplicitLod %v4float %55 %float_0_100000001 %57 = OpAccessChain %_ptr_Uniform_mat4v4float %_ %int_0 %58 = OpLoad %mat4v4float %57 %60 = OpMatrixTimesVector %v4float %58 %56 OpStore %_entryPointOutput_Color %60 OpReturn OpFunctionEnd )"; const std::string func_after = R"(%main = OpFunction %void None %3 %5 = OpLabel %53 = OpLoad %14 %g_tTex1df4 %54 = OpLoad %18 %g_sSamp %55 = OpSampledImage %22 %53 %54 %56 = OpImageSampleImplicitLod %v4float %55 %float_0_100000001 %57 = OpAccessChain %_ptr_Uniform_mat4v4float %_ %int_0 %58 = OpLoad %mat4v4float %57 %67 = OpCompositeExtract %v4float %58 0 %68 = OpFConvert %v4half %67 %69 = OpCompositeExtract %v4float %58 1 %70 = OpFConvert %v4half %69 %71 = OpCompositeExtract %v4float %58 2 %72 = OpFConvert %v4half %71 %73 = OpCompositeExtract %v4float %58 3 %74 = OpFConvert %v4half %73 %75 = OpCompositeConstruct %mat4v4half %68 %70 %72 %74 %64 = OpCopyObject %mat4v4float %58 %65 = OpFConvert %v4half %56 %60 = OpMatrixTimesVector %v4half %75 %65 %66 = OpFConvert %v4float %60 OpStore %_entryPointOutput_Color %66 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(defs_before + func_before, defs_after + func_after, true, true); } TEST_F(ConvertToHalfTest, ConvertToHalfWithPhi) { // The resulting SPIR-V was processed with --relax-float-ops. // // clang-format off // // SamplerState g_sSamp : register(s0); // uniform Texture1D g_tTex1df4 : register(t0); // // struct PS_OUTPUT // { // float4 Color : SV_Target0; // }; // // cbuffer cbuff{ // bool b; // float4x4 M; // } // // PS_OUTPUT main() // { // PS_OUTPUT psout; // float4 t; // // if (b) // t = g_tTex1df4.Sample(g_sSamp, 0.1); // else // t = float4(0.0, 0.0, 0.0, 0.0); // // float4 t2 = t * 2.0; // psout.Color = t2; // return psout; // } // // clang-format on const std::string defs_before = R"(OpCapability Shader OpCapability Sampled1D %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %_entryPointOutput_Color OpExecutionMode %main OriginUpperLeft OpSource HLSL 500 OpName %main "main" OpName %cbuff "cbuff" OpMemberName %cbuff 0 "b" OpMemberName %cbuff 1 "M" OpName %_ "" OpName %g_tTex1df4 "g_tTex1df4" OpName %g_sSamp "g_sSamp" OpName %_entryPointOutput_Color "@entryPointOutput.Color" OpMemberDecorate %cbuff 0 Offset 0 OpMemberDecorate %cbuff 1 RowMajor OpMemberDecorate %cbuff 1 Offset 16 OpMemberDecorate %cbuff 1 MatrixStride 16 OpDecorate %cbuff Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 1 OpDecorate %g_tTex1df4 DescriptorSet 0 OpDecorate %g_tTex1df4 Binding 0 OpDecorate %g_sSamp DescriptorSet 0 OpDecorate %g_sSamp Binding 0 OpDecorate %_entryPointOutput_Color Location 0 OpDecorate %72 RelaxedPrecision OpDecorate %85 RelaxedPrecision OpDecorate %74 RelaxedPrecision %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %mat4v4float = OpTypeMatrix %v4float 4 %cbuff = OpTypeStruct %uint %mat4v4float %_ptr_Uniform_cbuff = OpTypePointer Uniform %cbuff %_ = OpVariable %_ptr_Uniform_cbuff Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %bool = OpTypeBool %uint_0 = OpConstant %uint 0 %29 = OpTypeImage %float 1D 0 0 0 1 Unknown %_ptr_UniformConstant_29 = OpTypePointer UniformConstant %29 %g_tTex1df4 = OpVariable %_ptr_UniformConstant_29 UniformConstant %33 = OpTypeSampler %_ptr_UniformConstant_33 = OpTypePointer UniformConstant %33 %g_sSamp = OpVariable %_ptr_UniformConstant_33 UniformConstant %37 = OpTypeSampledImage %29 %float_0_100000001 = OpConstant %float 0.100000001 %float_0 = OpConstant %float 0 %43 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %float_2 = OpConstant %float 2 %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput_Color = OpVariable %_ptr_Output_v4float Output )"; const std::string defs_after = R"(OpCapability Shader OpCapability Sampled1D OpCapability Float16 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %_entryPointOutput_Color OpExecutionMode %main OriginUpperLeft OpSource HLSL 500 OpName %main "main" OpName %cbuff "cbuff" OpMemberName %cbuff 0 "b" OpMemberName %cbuff 1 "M" OpName %_ "" OpName %g_tTex1df4 "g_tTex1df4" OpName %g_sSamp "g_sSamp" OpName %_entryPointOutput_Color "@entryPointOutput.Color" OpMemberDecorate %cbuff 0 Offset 0 OpMemberDecorate %cbuff 1 RowMajor OpMemberDecorate %cbuff 1 Offset 16 OpMemberDecorate %cbuff 1 MatrixStride 16 OpDecorate %cbuff Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 1 OpDecorate %g_tTex1df4 DescriptorSet 0 OpDecorate %g_tTex1df4 Binding 0 OpDecorate %g_sSamp DescriptorSet 0 OpDecorate %g_sSamp Binding 0 OpDecorate %_entryPointOutput_Color Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %mat4v4float = OpTypeMatrix %v4float 4 %cbuff = OpTypeStruct %uint %mat4v4float %_ptr_Uniform_cbuff = OpTypePointer Uniform %cbuff %_ = OpVariable %_ptr_Uniform_cbuff Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %bool = OpTypeBool %uint_0 = OpConstant %uint 0 %29 = OpTypeImage %float 1D 0 0 0 1 Unknown %_ptr_UniformConstant_29 = OpTypePointer UniformConstant %29 %g_tTex1df4 = OpVariable %_ptr_UniformConstant_29 UniformConstant %33 = OpTypeSampler %_ptr_UniformConstant_33 = OpTypePointer UniformConstant %33 %g_sSamp = OpVariable %_ptr_UniformConstant_33 UniformConstant %37 = OpTypeSampledImage %29 %float_0_100000001 = OpConstant %float 0.100000001 %float_0 = OpConstant %float 0 %43 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %float_2 = OpConstant %float 2 %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput_Color = OpVariable %_ptr_Output_v4float Output %half = OpTypeFloat 16 %v4half = OpTypeVector %half 4 )"; const std::string func_before = R"(%main = OpFunction %void None %3 %5 = OpLabel %63 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %64 = OpLoad %uint %63 %65 = OpINotEqual %bool %64 %uint_0 OpSelectionMerge %66 None OpBranchConditional %65 %67 %68 %67 = OpLabel %69 = OpLoad %29 %g_tTex1df4 %70 = OpLoad %33 %g_sSamp %71 = OpSampledImage %37 %69 %70 %72 = OpImageSampleImplicitLod %v4float %71 %float_0_100000001 OpBranch %66 %68 = OpLabel OpBranch %66 %66 = OpLabel %85 = OpPhi %v4float %72 %67 %43 %68 %74 = OpVectorTimesScalar %v4float %85 %float_2 OpStore %_entryPointOutput_Color %74 OpReturn OpFunctionEnd )"; const std::string func_after = R"(%main = OpFunction %void None %3 %5 = OpLabel %63 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %64 = OpLoad %uint %63 %65 = OpINotEqual %bool %64 %uint_0 OpSelectionMerge %66 None OpBranchConditional %65 %67 %68 %67 = OpLabel %69 = OpLoad %29 %g_tTex1df4 %70 = OpLoad %33 %g_sSamp %71 = OpSampledImage %37 %69 %70 %72 = OpImageSampleImplicitLod %v4float %71 %float_0_100000001 %88 = OpFConvert %v4half %72 OpBranch %66 %68 = OpLabel %89 = OpFConvert %v4half %43 OpBranch %66 %66 = OpLabel %85 = OpPhi %v4half %88 %67 %89 %68 %90 = OpFConvert %half %float_2 %74 = OpVectorTimesScalar %v4half %85 %90 %91 = OpFConvert %v4float %74 OpStore %_entryPointOutput_Color %91 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(defs_before + func_before, defs_after + func_after, true, true); } TEST_F(ConvertToHalfTest, ConvertToHalfWithLoopAndFConvert) { // The resulting SPIR-V was processed with --relax-float-ops. // // The loop causes an FConvert to be generated at the bottom of the loop // for the Phi. The FConvert is later processed and turned into a (dead) // copy. // // clang-format off // // struct PS_OUTPUT // { // float4 Color : SV_Target0; // }; // // cbuffer cbuff{ // float4 a[10]; // } // // PS_OUTPUT main() // { // PS_OUTPUT psout; // float4 t = 0.0;; // // for (int i = 0; i<10; ++i) // t = t + a[i]; // // float4 t2 = t / 10.0; // psout.Color = t2; // return psout; // } // // clang-format on const std::string defs_before = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %_entryPointOutput_Color OpExecutionMode %main OriginUpperLeft OpSource HLSL 500 OpName %main "main" OpName %cbuff "cbuff" OpMemberName %cbuff 0 "a" OpName %_ "" OpName %_entryPointOutput_Color "@entryPointOutput.Color" OpDecorate %_arr_v4float_uint_10 ArrayStride 16 OpMemberDecorate %cbuff 0 Offset 0 OpDecorate %cbuff Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %_entryPointOutput_Color Location 0 OpDecorate %96 RelaxedPrecision OpDecorate %81 RelaxedPrecision OpDecorate %75 RelaxedPrecision OpDecorate %76 RelaxedPrecision %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %float_0 = OpConstant %float 0 %15 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %bool = OpTypeBool %uint = OpTypeInt 32 0 %uint_10 = OpConstant %uint 10 %_arr_v4float_uint_10 = OpTypeArray %v4float %uint_10 %cbuff = OpTypeStruct %_arr_v4float_uint_10 %_ptr_Uniform_cbuff = OpTypePointer Uniform %cbuff %_ = OpVariable %_ptr_Uniform_cbuff Uniform %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %int_1 = OpConstant %int 1 %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput_Color = OpVariable %_ptr_Output_v4float Output %float_0_100000001 = OpConstant %float 0.100000001 %94 = OpConstantComposite %v4float %float_0_100000001 %float_0_100000001 %float_0_100000001 %float_0_100000001 )"; const std::string defs_after = R"(OpCapability Shader OpCapability Float16 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %_entryPointOutput_Color OpExecutionMode %main OriginUpperLeft OpSource HLSL 500 OpName %main "main" OpName %cbuff "cbuff" OpMemberName %cbuff 0 "a" OpName %_ "" OpName %_entryPointOutput_Color "@entryPointOutput.Color" OpDecorate %_arr_v4float_uint_10 ArrayStride 16 OpMemberDecorate %cbuff 0 Offset 0 OpDecorate %cbuff Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %_entryPointOutput_Color Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %float_0 = OpConstant %float 0 %15 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %bool = OpTypeBool %uint = OpTypeInt 32 0 %uint_10 = OpConstant %uint 10 %_arr_v4float_uint_10 = OpTypeArray %v4float %uint_10 %cbuff = OpTypeStruct %_arr_v4float_uint_10 %_ptr_Uniform_cbuff = OpTypePointer Uniform %cbuff %_ = OpVariable %_ptr_Uniform_cbuff Uniform %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %int_1 = OpConstant %int 1 %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput_Color = OpVariable %_ptr_Output_v4float Output %float_0_100000001 = OpConstant %float 0.100000001 %94 = OpConstantComposite %v4float %float_0_100000001 %float_0_100000001 %float_0_100000001 %float_0_100000001 %half = OpTypeFloat 16 %v4half = OpTypeVector %half 4 )"; const std::string func_before = R"(%main = OpFunction %void None %3 %5 = OpLabel OpBranch %65 %65 = OpLabel %96 = OpPhi %v4float %15 %5 %76 %71 %95 = OpPhi %int %int_0 %5 %78 %71 %70 = OpSLessThan %bool %95 %int_10 OpLoopMerge %66 %71 None OpBranchConditional %70 %71 %66 %71 = OpLabel %74 = OpAccessChain %_ptr_Uniform_v4float %_ %int_0 %95 %75 = OpLoad %v4float %74 %76 = OpFAdd %v4float %96 %75 %78 = OpIAdd %int %95 %int_1 OpBranch %65 %66 = OpLabel %81 = OpFMul %v4float %96 %94 OpStore %_entryPointOutput_Color %81 OpReturn OpFunctionEnd )"; const std::string func_after = R"(%main = OpFunction %void None %3 %5 = OpLabel %99 = OpFConvert %v4half %15 OpBranch %65 %65 = OpLabel %96 = OpPhi %v4half %99 %5 %100 %71 %95 = OpPhi %int %int_0 %5 %78 %71 %70 = OpSLessThan %bool %95 %int_10 OpLoopMerge %66 %71 None OpBranchConditional %70 %71 %66 %71 = OpLabel %74 = OpAccessChain %_ptr_Uniform_v4float %_ %int_0 %95 %75 = OpLoad %v4float %74 %103 = OpFConvert %v4half %75 %76 = OpFAdd %v4half %96 %103 %78 = OpIAdd %int %95 %int_1 %100 = OpCopyObject %v4half %76 OpBranch %65 %66 = OpLabel %101 = OpFConvert %v4half %94 %81 = OpFMul %v4half %96 %101 %102 = OpFConvert %v4float %81 OpStore %_entryPointOutput_Color %102 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(defs_before + func_before, defs_after + func_after, true, true); } TEST_F(ConvertToHalfTest, ConvertToHalfWithExtracts) { // The resulting SPIR-V was processed with --relax-float-ops. // // The extra converts in the func_after can be DCE'd. // // clang-format off // // SamplerState g_sSamp : register(s0); // uniform Texture1D g_tTex1df4 : register(t0); // // struct PS_INPUT // { // float Tex0 : TEXCOORD0; // }; // // struct PS_OUTPUT // { // float4 Color : SV_Target0; // }; // // cbuffer cbuff{ // float c; // } // // PS_OUTPUT main(PS_INPUT i) // { // PS_OUTPUT psout; // float4 tx = g_tTex1df4.Sample(g_sSamp, i.Tex0); // float4 t = float4(tx.y, tx.z, tx.x, tx.w) * c; // psout.Color = t; // return psout; // } // // clang-format on const std::string defs_before = R"(OpCapability Shader OpCapability Sampled1D %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %i_Tex0 %_entryPointOutput_Color OpExecutionMode %main OriginUpperLeft OpSource HLSL 500 OpName %main "main" OpName %g_tTex1df4 "g_tTex1df4" OpName %g_sSamp "g_sSamp" OpName %cbuff "cbuff" OpMemberName %cbuff 0 "c" OpName %_ "" OpName %i_Tex0 "i.Tex0" OpName %_entryPointOutput_Color "@entryPointOutput.Color" OpDecorate %g_tTex1df4 DescriptorSet 0 OpDecorate %g_tTex1df4 Binding 0 OpDecorate %g_sSamp DescriptorSet 0 OpDecorate %g_sSamp Binding 0 OpMemberDecorate %cbuff 0 Offset 0 OpDecorate %cbuff Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 1 OpDecorate %i_Tex0 Location 0 OpDecorate %_entryPointOutput_Color Location 0 OpDecorate %65 RelaxedPrecision OpDecorate %82 RelaxedPrecision OpDecorate %84 RelaxedPrecision OpDecorate %86 RelaxedPrecision OpDecorate %88 RelaxedPrecision OpDecorate %90 RelaxedPrecision OpDecorate %91 RelaxedPrecision OpDecorate %93 RelaxedPrecision OpDecorate %94 RelaxedPrecision %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %17 = OpTypeImage %float 1D 0 0 0 1 Unknown %_ptr_UniformConstant_17 = OpTypePointer UniformConstant %17 %g_tTex1df4 = OpVariable %_ptr_UniformConstant_17 UniformConstant %21 = OpTypeSampler %_ptr_UniformConstant_21 = OpTypePointer UniformConstant %21 %g_sSamp = OpVariable %_ptr_UniformConstant_21 UniformConstant %25 = OpTypeSampledImage %17 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %cbuff = OpTypeStruct %float %_ptr_Uniform_cbuff = OpTypePointer Uniform %cbuff %_ = OpVariable %_ptr_Uniform_cbuff Uniform %_ptr_Uniform_float = OpTypePointer Uniform %float %_ptr_Input_float = OpTypePointer Input %float %i_Tex0 = OpVariable %_ptr_Input_float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput_Color = OpVariable %_ptr_Output_v4float Output )"; const std::string defs_after = R"(OpCapability Shader OpCapability Sampled1D OpCapability Float16 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %i_Tex0 %_entryPointOutput_Color OpExecutionMode %main OriginUpperLeft OpSource HLSL 500 OpName %main "main" OpName %g_tTex1df4 "g_tTex1df4" OpName %g_sSamp "g_sSamp" OpName %cbuff "cbuff" OpMemberName %cbuff 0 "c" OpName %_ "" OpName %i_Tex0 "i.Tex0" OpName %_entryPointOutput_Color "@entryPointOutput.Color" OpDecorate %g_tTex1df4 DescriptorSet 0 OpDecorate %g_tTex1df4 Binding 0 OpDecorate %g_sSamp DescriptorSet 0 OpDecorate %g_sSamp Binding 0 OpMemberDecorate %cbuff 0 Offset 0 OpDecorate %cbuff Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 1 OpDecorate %i_Tex0 Location 0 OpDecorate %_entryPointOutput_Color Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %17 = OpTypeImage %float 1D 0 0 0 1 Unknown %_ptr_UniformConstant_17 = OpTypePointer UniformConstant %17 %g_tTex1df4 = OpVariable %_ptr_UniformConstant_17 UniformConstant %21 = OpTypeSampler %_ptr_UniformConstant_21 = OpTypePointer UniformConstant %21 %g_sSamp = OpVariable %_ptr_UniformConstant_21 UniformConstant %25 = OpTypeSampledImage %17 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %cbuff = OpTypeStruct %float %_ptr_Uniform_cbuff = OpTypePointer Uniform %cbuff %_ = OpVariable %_ptr_Uniform_cbuff Uniform %_ptr_Uniform_float = OpTypePointer Uniform %float %_ptr_Input_float = OpTypePointer Input %float %i_Tex0 = OpVariable %_ptr_Input_float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput_Color = OpVariable %_ptr_Output_v4float Output %half = OpTypeFloat 16 %v4half = OpTypeVector %half 4 )"; const std::string func_before = R"(%main = OpFunction %void None %3 %5 = OpLabel %65 = OpLoad %float %i_Tex0 %77 = OpLoad %17 %g_tTex1df4 %78 = OpLoad %21 %g_sSamp %79 = OpSampledImage %25 %77 %78 %82 = OpImageSampleImplicitLod %v4float %79 %65 %84 = OpCompositeExtract %float %82 1 %86 = OpCompositeExtract %float %82 2 %88 = OpCompositeExtract %float %82 0 %90 = OpCompositeExtract %float %82 3 %91 = OpCompositeConstruct %v4float %84 %86 %88 %90 %92 = OpAccessChain %_ptr_Uniform_float %_ %int_0 %93 = OpLoad %float %92 %94 = OpVectorTimesScalar %v4float %91 %93 OpStore %_entryPointOutput_Color %94 OpReturn OpFunctionEnd )"; const std::string func_after = R"(%main = OpFunction %void None %3 %5 = OpLabel %65 = OpLoad %float %i_Tex0 %77 = OpLoad %17 %g_tTex1df4 %78 = OpLoad %21 %g_sSamp %79 = OpSampledImage %25 %77 %78 %82 = OpImageSampleImplicitLod %v4float %79 %65 %97 = OpFConvert %v4half %82 %84 = OpCompositeExtract %half %97 1 %98 = OpFConvert %v4half %82 %86 = OpCompositeExtract %half %98 2 %99 = OpFConvert %v4half %82 %88 = OpCompositeExtract %half %99 0 %100 = OpFConvert %v4half %82 %90 = OpCompositeExtract %half %100 3 %91 = OpCompositeConstruct %v4half %84 %86 %88 %90 %92 = OpAccessChain %_ptr_Uniform_float %_ %int_0 %93 = OpLoad %float %92 %101 = OpFConvert %half %93 %94 = OpVectorTimesScalar %v4half %91 %101 %102 = OpFConvert %v4float %94 OpStore %_entryPointOutput_Color %102 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(defs_before + func_before, defs_after + func_after, true, true); } TEST_F(ConvertToHalfTest, ConvertToHalfWithClosure) { // Include as many contiguous composite instructions as possible into // half-precision computations // // Compiled with glslang -V -Os // // clang-format off // // #version 410 core // // precision mediump float; // // layout(location = 1) in vec3 foo; // layout(location = 2) in mat2 bar; // layout(location = 1) out vec3 res; // // vec3 func(vec3 tap, mat2 M) { // return vec3(M * tap.xy, 1.0); // } // // void main() { // res = func(foo, bar); // } // // clang-format on const std::string defs = R"(OpCapability Shader ; CHECK: OpCapability Float16 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %res %foo %bar OpExecutionMode %main OriginUpperLeft OpSource GLSL 410 OpName %main "main" OpName %res "res" OpName %foo "foo" OpName %bar "bar" OpDecorate %res RelaxedPrecision ; CHECK-NOT: OpDecorate %res RelaxedPrecision OpDecorate %res Location 1 OpDecorate %foo RelaxedPrecision ; CHECK-NOT: OpDecorate %foo RelaxedPrecision OpDecorate %foo Location 1 OpDecorate %bar RelaxedPrecision ; CHECK-NOT: OpDecorate %bar RelaxedPrecision OpDecorate %bar Location 2 OpDecorate %34 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %41 RelaxedPrecision OpDecorate %42 RelaxedPrecision ; CHECK-NOT: OpDecorate %34 RelaxedPrecision ; CHECK-NOT: OpDecorate %36 RelaxedPrecision ; CHECK-NOT: OpDecorate %41 RelaxedPrecision ; CHECK-NOT: OpDecorate %42 RelaxedPrecision %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %v2float = OpTypeVector %float 2 %mat2v2float = OpTypeMatrix %v2float 2 %float_1 = OpConstant %float 1 %_ptr_Output_v3float = OpTypePointer Output %v3float %res = OpVariable %_ptr_Output_v3float Output %_ptr_Input_v3float = OpTypePointer Input %v3float %foo = OpVariable %_ptr_Input_v3float Input %_ptr_Input_mat2v2float = OpTypePointer Input %mat2v2float %bar = OpVariable %_ptr_Input_mat2v2float Input )"; const std::string func = R"(%main = OpFunction %void None %3 %5 = OpLabel %34 = OpLoad %v3float %foo %36 = OpLoad %mat2v2float %bar ; CHECK: %48 = OpFConvert %v3half %34 ; CHECK: %49 = OpFConvert %v3half %34 %41 = OpVectorShuffle %v2float %34 %34 0 1 ; CHECK-NOT: %41 = OpVectorShuffle %v2float %34 %34 0 1 ; CHECK: %41 = OpVectorShuffle %v2half %48 %49 0 1 %42 = OpMatrixTimesVector %v2float %36 %41 ; CHECK-NOT: %42 = OpMatrixTimesVector %v2float %36 %41 ; CHECK: %55 = OpCompositeExtract %v2float %36 0 ; CHECK: %56 = OpFConvert %v2half %55 ; CHECK: %57 = OpCompositeExtract %v2float %36 1 ; CHECK: %58 = OpFConvert %v2half %57 ; CHECK: %59 = OpCompositeConstruct %mat2v2half %56 %58 ; CHECK: %52 = OpCopyObject %mat2v2float %36 ; CHECK: %42 = OpMatrixTimesVector %v2half %59 %41 %43 = OpCompositeExtract %float %42 0 %44 = OpCompositeExtract %float %42 1 ; CHECK-NOT: %43 = OpCompositeExtract %float %42 0 ; CHECK-NOT: %44 = OpCompositeExtract %float %42 1 ; CHECK: %43 = OpCompositeExtract %half %42 0 ; CHECK: %44 = OpCompositeExtract %half %42 1 %45 = OpCompositeConstruct %v3float %43 %44 %float_1 ; CHECK-NOT: %45 = OpCompositeConstruct %v3float %43 %44 %float_1 ; CHECK: %53 = OpFConvert %float %43 ; CHECK: %54 = OpFConvert %float %44 ; CHECK: %45 = OpCompositeConstruct %v3float %53 %54 %float_1 OpStore %res %45 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(defs + func, true); } TEST_F(ConvertToHalfTest, RemoveRelaxDec) { // See https://github.com/KhronosGroup/SPIRV-Tools/issues/4117 // This test is a case where the relax precision decorations need to be // removed, but the body of the function does not change because there are not // arithmetic operations. So, there is not need for the Float16 capability. const std::string test = R"( ; CHECK-NOT: OpCapability Float16 ; GLSL seems to generate this decoration on the load of a texture, which seems odd to me. ; This pass does not currently remove it, and I'm not sure what we should do with it, so I will leave it. ; CHECK: OpDecorate [[tex:%\w+]] RelaxedPrecision ; CHECK-NOT: OpDecorate {{%\w+}} RelaxedPrecision ; CHECK: OpLabel ; CHECK: [[tex]] = OpLoad {{%\w+}} %sTexture ; CHECK: [[coord:%\w+]] = OpLoad %v2float ; CHECK: [[retval:%\w+]] = OpImageSampleImplicitLod %v4float {{%\w+}} [[coord]] ; CHECK: OpStore %outFragColor [[retval]] OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %outFragColor %v_texcoord OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %outFragColor "outFragColor" OpName %sTexture "sTexture" OpName %v_texcoord "v_texcoord" OpDecorate %outFragColor RelaxedPrecision OpDecorate %outFragColor Location 0 OpDecorate %sTexture RelaxedPrecision OpDecorate %sTexture DescriptorSet 0 OpDecorate %sTexture Binding 0 OpDecorate %14 RelaxedPrecision OpDecorate %v_texcoord RelaxedPrecision OpDecorate %v_texcoord Location 0 OpDecorate %18 RelaxedPrecision OpDecorate %19 RelaxedPrecision %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %outFragColor = OpVariable %_ptr_Output_v4float Output %10 = OpTypeImage %float 2D 0 0 0 1 Unknown %11 = OpTypeSampledImage %10 %_ptr_UniformConstant_11 = OpTypePointer UniformConstant %11 %sTexture = OpVariable %_ptr_UniformConstant_11 UniformConstant %v2float = OpTypeVector %float 2 %_ptr_Input_v2float = OpTypePointer Input %v2float %v_texcoord = OpVariable %_ptr_Input_v2float Input %main = OpFunction %void None %3 %5 = OpLabel %14 = OpLoad %11 %sTexture %18 = OpLoad %v2float %v_texcoord %19 = OpImageSampleImplicitLod %v4float %14 %18 OpStore %outFragColor %19 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); auto result = SinglePassRunAndMatch(test, true); EXPECT_EQ(Pass::Status::SuccessWithChange, std::get<1>(result)); } TEST_F(ConvertToHalfTest, HandleNonRelaxedPhi) { // See https://github.com/KhronosGroup/SPIRV-Tools/issues/4452 // This test is a case with a non-relaxed phi with a relaxed operand. // A convert must be inserted at the end of the block associated with // the operand. const std::string test = R"( ; CHECK: [[fcvt:%\w+]] = OpFConvert %v3float {{%\w+}} ; CHECK-NEXT: OpSelectionMerge {{%\w+}} None ; CHECK: {{%\w+}} = OpPhi %v3float [[fcvt]] {{%\w+}} {{%\w+}} {{%\w+}} OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %output_color OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %MaterialParams "MaterialParams" OpMemberName %MaterialParams 0 "foo" OpName %materialParams "materialParams" OpName %output_color "output_color" OpMemberDecorate %MaterialParams 0 Offset 0 OpDecorate %MaterialParams Block OpDecorate %materialParams DescriptorSet 0 OpDecorate %materialParams Binding 5 OpDecorate %output_color Location 0 OpDecorate %57 RelaxedPrecision %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %MaterialParams = OpTypeStruct %float %_ptr_Uniform_MaterialParams = OpTypePointer Uniform %MaterialParams %materialParams = OpVariable %_ptr_Uniform_MaterialParams Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_float = OpTypePointer Uniform %float %float_0 = OpConstant %float 0 %bool = OpTypeBool %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %output_color = OpVariable %_ptr_Output_v4float Output %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Output_float = OpTypePointer Output %float %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %float_0_5 = OpConstant %float 0.5 %61 = OpConstantComposite %v3float %float_0_5 %float_0_5 %float_0_5 %main = OpFunction %void None %3 %5 = OpLabel %55 = OpAccessChain %_ptr_Uniform_float %materialParams %int_0 %56 = OpLoad %float %55 %57 = OpCompositeConstruct %v3float %56 %56 %56 %31 = OpFOrdGreaterThan %bool %56 %float_0 OpSelectionMerge %33 None OpBranchConditional %31 %32 %33 %32 = OpLabel %37 = OpFMul %v3float %57 %61 OpBranch %33 %33 = OpLabel %58 = OpPhi %v3float %57 %5 %37 %32 %45 = OpAccessChain %_ptr_Output_float %output_color %uint_0 %46 = OpCompositeExtract %float %58 0 OpStore %45 %46 %48 = OpAccessChain %_ptr_Output_float %output_color %uint_1 %49 = OpCompositeExtract %float %58 1 OpStore %48 %49 %51 = OpAccessChain %_ptr_Output_float %output_color %uint_2 %52 = OpCompositeExtract %float %58 2 OpStore %51 %52 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); auto result = SinglePassRunAndMatch(test, true); EXPECT_EQ(Pass::Status::SuccessWithChange, std::get<1>(result)); } TEST_F(ConvertToHalfTest, DoNotReplaceStructMember) { // See https://github.com/KhronosGroup/SPIRV-Tools/issues/4814 // This test is a case with a non-relaxed phi with a relaxed operand. // A convert must be inserted at the end of the block associated with // the operand. const std::string test = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %PSMain "PSMain" %out_var_SV_TARGET %MyConstants OpExecutionMode %PSMain OriginUpperLeft OpSource HLSL 600 OpName %type_ConstantBuffer_myStruct "type.ConstantBuffer.myStruct" OpMemberName %type_ConstantBuffer_myStruct 0 "f" OpName %MyConstants "MyConstants" OpName %out_var_SV_TARGET "out.var.SV_TARGET" OpName %PSMain "PSMain" OpDecorate %out_var_SV_TARGET Location 0 OpDecorate %MyConstants DescriptorSet 1 OpDecorate %MyConstants Binding 2 OpMemberDecorate %type_ConstantBuffer_myStruct 0 Offset 0 OpDecorate %type_ConstantBuffer_myStruct Block %float = OpTypeFloat 32 %type_ConstantBuffer_myStruct = OpTypeStruct %float %_ptr_Uniform_type_ConstantBuffer_myStruct = OpTypePointer Uniform %type_ConstantBuffer_myStruct %_ptr_Output_float = OpTypePointer Output %float %void = OpTypeVoid %9 = OpTypeFunction %void %MyConstants = OpVariable %_ptr_Uniform_type_ConstantBuffer_myStruct Uniform %out_var_SV_TARGET = OpVariable %_ptr_Output_float Output %PSMain = OpFunction %void None %9 %10 = OpLabel %11 = OpLoad %type_ConstantBuffer_myStruct %MyConstants %12 = OpCompositeExtract %float %11 0 OpStore %out_var_SV_TARGET %12 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(test, test, true); } TEST_F(ConvertToHalfTest, PreserveImageOperandPrecision) { // Ensure that a non-relaxed texture coordinate does not get relaxed nor // converted to half precision if the image instruction is marked relaxed. // Also ensure that a relaxed local variable does get converted to half // precision before being passed to an image opeartor. // #version 310 es // // precision mediump float; // // layout(location = 10) in highp vec4 vertex_uv01; // layout(binding = 0, set = 3) uniform sampler2D materialParams_baseColorMap; // // layout(location = 0) out vec4 fragColor; // // void main() { // vec4 uv = vec4(2.0); // fragColor = texture(materialParams_baseColorMap, uv.xy); // fragColor = texture(materialParams_baseColorMap, vertex_uv01.xy); // } const std::string test = R"( OpCapability Shader OpCapability Float16 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %13 %25 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %9 RelaxedPrecision ;CHECK: OpDecorate [[uv:%\w+]] RelaxedPrecision OpDecorate %13 Location 0 OpDecorate %17 DescriptorSet 3 OpDecorate %17 Binding 0 OpDecorate %18 RelaxedPrecision OpDecorate %23 RelaxedPrecision OpDecorate %25 Location 10 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 ;CHECK: [[float32_t:%\w+]] = OpTypeFloat 32 %7 = OpTypeVector %6 4 ;CHECK: [[vec4_t:%\w+]] = OpTypeVector [[float32_t]] 4 %8 = OpTypePointer Function %7 %10 = OpConstant %6 2 %11 = OpConstantComposite %7 %10 %10 %10 %10 %12 = OpTypePointer Output %7 ;CHECK: [[output_ptr_t:%\w+]] = OpTypePointer Output [[vec4_t]] %13 = OpVariable %12 Output ;CHECK: [[output:%\w+]] = OpVariable [[output_ptr_t]] Output %14 = OpTypeImage %6 2D 0 0 0 1 Unknown %15 = OpTypeSampledImage %14 %16 = OpTypePointer UniformConstant %15 %17 = OpVariable %16 UniformConstant %19 = OpTypeVector %6 2 ;CHECK: [[vec2_t:%\w+]] = OpTypeVector [[float32_t]] 2 %24 = OpTypePointer Input %7 ;CHECK: [[input_ptr_t:%\w+]] = OpTypePointer Input [[vec4_t]] %25 = OpVariable %24 Input %29 = OpTypeFloat 16 ;CHECK: [[float16_t:%\w+]] = OpTypeFloat 16 %30 = OpTypeVector %29 4 %33 = OpTypeVector %29 2 ;CHECK: [[vec2_16b_t:%\w+]] = OpTypeVector [[float16_t]] 2 %4 = OpFunction %2 None %3 %5 = OpLabel ; The only Function storage variable is marked as relaxed %9 = OpVariable %8 Function ;CHECK: [[uv]] = OpVariable {{%\w+}} Function OpStore %9 %11 %18 = OpLoad %15 %17 %20 = OpLoad %7 %9 %31 = OpFConvert %30 %20 %32 = OpFConvert %30 %20 ; The first sample op should get a 16b coordinate %21 = OpVectorShuffle %33 %31 %32 0 1 ;CHECK: [[uv_16b:%\w+]] = OpVectorShuffle [[vec2_16b_t]] %22 = OpImageSampleImplicitLod %7 %18 %21 ;CHECK: OpImageSampleImplicitLod [[vec4_t]] {{%\w+}} [[uv_16b]] OpStore %13 %22 %23 = OpLoad %15 %17 %26 = OpLoad %7 %25 ; The second sample op should get a 32b coordinate %27 = OpVectorShuffle %19 %26 %26 0 1 ;CHECK: [[uv_32b:%\w+]] = OpVectorShuffle [[vec2_t]] %28 = OpImageSampleImplicitLod %7 %23 %27 ;CHECK: OpImageSampleImplicitLod [[vec4_t]] {{%\w+}} [[uv_32b]] OpStore %13 %28 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(test, true); } TEST_F(ConvertToHalfTest, DontRelaxDecoratedOpCompositeExtract) { // This test checks that a OpCompositeExtract with a Struct operand won't be // relaxed, even if it is explicitly decorated with RelaxedPrecision. const std::string test = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpDecorate %9 RelaxedPrecision %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_struct_6 = OpTypeStruct %v4float %7 = OpUndef %_struct_6 %1 = OpFunction %void None %3 %8 = OpLabel %9 = OpCompositeExtract %float %7 0 3 OpReturn OpFunctionEnd )"; const std::string expected = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_struct_6 = OpTypeStruct %v4float %7 = OpUndef %_struct_6 %1 = OpFunction %void None %3 %8 = OpLabel %9 = OpCompositeExtract %float %7 0 3 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(test, expected, true); } TEST_F(ConvertToHalfTest, DontRelaxOpCompositeExtract) { // This test checks that a OpCompositeExtract with a Struct operand won't be // relaxed, even if its result has no uses. const std::string test = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_struct_6 = OpTypeStruct %v4float %7 = OpUndef %_struct_6 %1 = OpFunction %void None %3 %8 = OpLabel %9 = OpCompositeExtract %float %7 0 3 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(test, test, true); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/convert_to_sampled_image_test.cpp000066400000000000000000000346111475742701700271130ustar00rootroot00000000000000// Copyright (c) 2021 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gmock/gmock.h" #include "source/opt/convert_to_sampled_image_pass.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using testing::Eq; using VectorOfDescriptorSetAndBindingPairs = std::vector; struct DescriptorSetAndBindingStringParsingTestCase { const char* descriptor_set_binding_str; bool expect_success; VectorOfDescriptorSetAndBindingPairs expected_descriptor_set_binding_pairs; }; using DescriptorSetAndBindingStringParsingTest = ::testing::TestWithParam; TEST_P(DescriptorSetAndBindingStringParsingTest, TestCase) { const auto& tc = GetParam(); auto actual_descriptor_set_binding_pairs = ConvertToSampledImagePass::ParseDescriptorSetBindingPairsString( tc.descriptor_set_binding_str); if (tc.expect_success) { EXPECT_NE(nullptr, actual_descriptor_set_binding_pairs); if (actual_descriptor_set_binding_pairs) { EXPECT_THAT(*actual_descriptor_set_binding_pairs, Eq(tc.expected_descriptor_set_binding_pairs)); } } else { EXPECT_EQ(nullptr, actual_descriptor_set_binding_pairs); } } INSTANTIATE_TEST_SUITE_P( ValidString, DescriptorSetAndBindingStringParsingTest, ::testing::ValuesIn(std::vector< DescriptorSetAndBindingStringParsingTestCase>{ // 0. empty vector {"", true, VectorOfDescriptorSetAndBindingPairs({})}, // 1. one pair {"100:1024", true, VectorOfDescriptorSetAndBindingPairs({DescriptorSetAndBinding{100, 1024}})}, // 2. two pairs {"100:1024 200:2048", true, VectorOfDescriptorSetAndBindingPairs( {DescriptorSetAndBinding{100, 1024}, DescriptorSetAndBinding{200, 2048}})}, // 3. spaces between entries {"100:1024 \n \r \t \v \f 200:2048", true, VectorOfDescriptorSetAndBindingPairs( {DescriptorSetAndBinding{100, 1024}, DescriptorSetAndBinding{200, 2048}})}, // 4. \t, \n, \r and spaces before spec id {" \n \r\t \t \v \f 100:1024", true, VectorOfDescriptorSetAndBindingPairs({DescriptorSetAndBinding{100, 1024}})}, // 5. \t, \n, \r and spaces after value string {"100:1024 \n \r\t \t \v \f ", true, VectorOfDescriptorSetAndBindingPairs({DescriptorSetAndBinding{100, 1024}})}, // 6. maximum spec id {"4294967295:0", true, VectorOfDescriptorSetAndBindingPairs({DescriptorSetAndBinding{ 4294967295, 0}})}, // 7. minimum spec id {"0:100", true, VectorOfDescriptorSetAndBindingPairs({DescriptorSetAndBinding{0, 100}})}, // 8. multiple entries {"101:1 102:2 103:3 104:4 200:201 9999:1000", true, VectorOfDescriptorSetAndBindingPairs( {DescriptorSetAndBinding{101, 1}, DescriptorSetAndBinding{102, 2}, DescriptorSetAndBinding{103, 3}, DescriptorSetAndBinding{104, 4}, DescriptorSetAndBinding{200, 201}, DescriptorSetAndBinding{9999, 1000}})}, })); INSTANTIATE_TEST_SUITE_P( InvalidString, DescriptorSetAndBindingStringParsingTest, ::testing::ValuesIn( std::vector{ // 0. missing default value {"100:", false, VectorOfDescriptorSetAndBindingPairs{}}, // 1. descriptor set is not an integer {"100.0:200", false, VectorOfDescriptorSetAndBindingPairs{}}, // 2. descriptor set is not a number {"something_not_a_number:1", false, VectorOfDescriptorSetAndBindingPairs{}}, // 3. only descriptor set number {"100", false, VectorOfDescriptorSetAndBindingPairs{}}, // 4. empty descriptor set {":3", false, VectorOfDescriptorSetAndBindingPairs{}}, // 5. only colon {":", false, VectorOfDescriptorSetAndBindingPairs{}}, // 6. descriptor set overflow {"4294967296:200", false, VectorOfDescriptorSetAndBindingPairs{}}, // 7. descriptor set less than 0 {"-1:200", false, VectorOfDescriptorSetAndBindingPairs{}}, // 8. nullptr {nullptr, false, VectorOfDescriptorSetAndBindingPairs{}}, // 9. only a number is invalid {"1234", false, VectorOfDescriptorSetAndBindingPairs{}}, // 10. invalid entry separator {"12:34;23:14", false, VectorOfDescriptorSetAndBindingPairs{}}, // 11. invalid descriptor set and default value separator {"12@34", false, VectorOfDescriptorSetAndBindingPairs{}}, // 12. spaces before colon {"100 :1024", false, VectorOfDescriptorSetAndBindingPairs{}}, // 13. spaces after colon {"100: 1024", false, VectorOfDescriptorSetAndBindingPairs{}}, // 14. descriptor set represented in hex float format is invalid {"0x3p10:200", false, VectorOfDescriptorSetAndBindingPairs{}}, })); std::string BuildShader(const char* shader_decorate_instructions, const char* shader_image_and_sampler_variables, const char* shader_body) { // Base HLSL code: // // SamplerState sam : register(s2); // Texture2D texture : register(t5); // // float4 main() : SV_TARGET { // return texture.SampleLevel(sam, float2(1, 2), 10, 2); // } std::stringstream ss; ss << R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %out_var_SV_TARGET OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %type_sampler "type.sampler" OpName %type_2d_image "type.2d.image" OpName %out_var_SV_TARGET "out.var.SV_TARGET" OpName %main "main" OpName %type_sampled_image "type.sampled.image" OpDecorate %out_var_SV_TARGET Location 0 )"; ss << shader_decorate_instructions; ss << R"( %float = OpTypeFloat 32 %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %v2float = OpTypeVector %float 2 %12 = OpConstantComposite %v2float %float_1 %float_2 %float_10 = OpConstant %float 10 %int = OpTypeInt 32 1 %int_2 = OpConstant %int 2 %v2int = OpTypeVector %int 2 %17 = OpConstantComposite %v2int %int_2 %int_2 %type_sampler = OpTypeSampler %_ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %type_sampler %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %23 = OpTypeFunction %void %type_sampled_image = OpTypeSampledImage %type_2d_image )"; ss << shader_image_and_sampler_variables; ss << R"( %out_var_SV_TARGET = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %23 %24 = OpLabel )"; ss << shader_body; ss << R"( OpReturn OpFunctionEnd )"; return ss.str(); } using ConvertToSampledImageTest = PassTest<::testing::Test>; TEST_F(ConvertToSampledImageTest, Texture2DAndSamplerToSampledImage) { const std::string shader = BuildShader( R"( OpDecorate %sam DescriptorSet 0 OpDecorate %sam Binding 5 OpDecorate %texture DescriptorSet 0 OpDecorate %texture Binding 5 )", R"( ; CHECK-NOT: OpVariable %_ptr_UniformConstant_type_2d_image ; CHECK: [[tex:%\w+]] = OpVariable %_ptr_UniformConstant_type_sampled_image UniformConstant %sam = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %texture = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant )", R"( ; CHECK: [[load:%\w+]] = OpLoad %type_sampled_image [[tex]] ; CHECK: OpImageSampleExplicitLod %v4float [[load]] %25 = OpLoad %type_2d_image %texture %26 = OpLoad %type_sampler %sam %27 = OpSampledImage %type_sampled_image %25 %26 %28 = OpImageSampleExplicitLod %v4float %27 %12 Lod|ConstOffset %float_10 %17 OpStore %out_var_SV_TARGET %28 )"); auto result = SinglePassRunAndMatch( shader, /* do_validate = */ true, VectorOfDescriptorSetAndBindingPairs{DescriptorSetAndBinding{0, 5}}); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(ConvertToSampledImageTest, Texture2DToSampledImage) { const std::string shader = BuildShader( R"( OpDecorate %sam DescriptorSet 0 OpDecorate %sam Binding 2 OpDecorate %texture DescriptorSet 0 OpDecorate %texture Binding 5 )", R"( ; CHECK: [[tex:%\w+]] = OpVariable %_ptr_UniformConstant_type_sampled_image UniformConstant %sam = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %texture = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant )", R"( ; CHECK: [[load:%\w+]] = OpLoad %type_sampled_image [[tex]] ; CHECK: [[image_extraction:%\w+]] = OpImage %type_2d_image [[load]] ; CHECK: OpSampledImage %type_sampled_image [[image_extraction]] %25 = OpLoad %type_2d_image %texture %26 = OpLoad %type_sampler %sam %27 = OpSampledImage %type_sampled_image %25 %26 %28 = OpImageSampleExplicitLod %v4float %27 %12 Lod|ConstOffset %float_10 %17 OpStore %out_var_SV_TARGET %28 )"); auto result = SinglePassRunAndMatch( shader, /* do_validate = */ true, VectorOfDescriptorSetAndBindingPairs{DescriptorSetAndBinding{0, 5}}); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(ConvertToSampledImageTest, SamplerToSampledImage) { const std::string shader = BuildShader( R"( OpDecorate %sam DescriptorSet 0 OpDecorate %sam Binding 2 OpDecorate %texture DescriptorSet 0 OpDecorate %texture Binding 5 )", R"( %sam = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %texture = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant )", R"( %25 = OpLoad %type_2d_image %texture %26 = OpLoad %type_sampler %sam %27 = OpSampledImage %type_sampled_image %25 %26 %28 = OpImageSampleExplicitLod %v4float %27 %12 Lod|ConstOffset %float_10 %17 OpStore %out_var_SV_TARGET %28 )"); auto result = SinglePassRunToBinary( shader, /* skip_nop = */ false, VectorOfDescriptorSetAndBindingPairs{DescriptorSetAndBinding{0, 2}}); EXPECT_EQ(std::get<1>(result), Pass::Status::Failure); } TEST_F(ConvertToSampledImageTest, TwoImagesWithDuplicatedDescriptorSetBinding) { const std::string shader = BuildShader( R"( OpDecorate %sam DescriptorSet 0 OpDecorate %sam Binding 2 OpDecorate %texture0 DescriptorSet 0 OpDecorate %texture0 Binding 5 OpDecorate %texture1 DescriptorSet 0 OpDecorate %texture1 Binding 5 )", R"( %sam = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %texture0 = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %texture1 = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant )", R"( %25 = OpLoad %type_2d_image %texture0 %26 = OpLoad %type_sampler %sam %27 = OpSampledImage %type_sampled_image %25 %26 %28 = OpImageSampleExplicitLod %v4float %27 %12 Lod|ConstOffset %float_10 %17 OpStore %out_var_SV_TARGET %28 )"); auto result = SinglePassRunToBinary( shader, /* skip_nop = */ false, VectorOfDescriptorSetAndBindingPairs{DescriptorSetAndBinding{0, 5}}); EXPECT_EQ(std::get<1>(result), Pass::Status::Failure); } TEST_F(ConvertToSampledImageTest, TwoSamplersWithDuplicatedDescriptorSetBinding) { const std::string shader = BuildShader( R"( OpDecorate %sam0 DescriptorSet 0 OpDecorate %sam0 Binding 2 OpDecorate %sam1 DescriptorSet 0 OpDecorate %sam1 Binding 2 OpDecorate %texture DescriptorSet 0 OpDecorate %texture Binding 5 )", R"( %sam0 = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %sam1 = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %texture = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant )", R"( %25 = OpLoad %type_2d_image %texture %26 = OpLoad %type_sampler %sam0 %27 = OpSampledImage %type_sampled_image %25 %26 %28 = OpImageSampleExplicitLod %v4float %27 %12 Lod|ConstOffset %float_10 %17 OpStore %out_var_SV_TARGET %28 )"); auto result = SinglePassRunToBinary( shader, /* skip_nop = */ false, VectorOfDescriptorSetAndBindingPairs{DescriptorSetAndBinding{0, 2}}); EXPECT_EQ(std::get<1>(result), Pass::Status::Failure); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/copy_prop_array_test.cpp000066400000000000000000002532051475742701700252740ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gmock/gmock.h" #include "test/opt/assembly_builder.h" #include "test/opt/pass_fixture.h" namespace spvtools { namespace opt { namespace { using CopyPropArrayPassTest = PassTest<::testing::Test>; TEST_F(CopyPropArrayPassTest, BasicPropagateArray) { const std::string before = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_INDEX %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %type_MyCBuffer "type.MyCBuffer" OpMemberName %type_MyCBuffer 0 "Data" OpName %MyCBuffer "MyCBuffer" OpName %main "main" OpName %in_var_INDEX "in.var.INDEX" OpName %out_var_SV_Target "out.var.SV_Target" OpDecorate %_arr_v4float_uint_8 ArrayStride 16 OpMemberDecorate %type_MyCBuffer 0 Offset 0 OpDecorate %type_MyCBuffer Block OpDecorate %in_var_INDEX Flat OpDecorate %in_var_INDEX Location 0 OpDecorate %out_var_SV_Target Location 0 OpDecorate %MyCBuffer DescriptorSet 0 OpDecorate %MyCBuffer Binding 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_8 = OpConstant %uint 8 %_arr_v4float_uint_8 = OpTypeArray %v4float %uint_8 %type_MyCBuffer = OpTypeStruct %_arr_v4float_uint_8 %_ptr_Uniform_type_MyCBuffer = OpTypePointer Uniform %type_MyCBuffer %void = OpTypeVoid %13 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %_ptr_Output_v4float = OpTypePointer Output %v4float %_arr_v4float_uint_8_0 = OpTypeArray %v4float %uint_8 %_ptr_Function__arr_v4float_uint_8_0 = OpTypePointer Function %_arr_v4float_uint_8_0 %int_0 = OpConstant %int 0 %_ptr_Uniform__arr_v4float_uint_8 = OpTypePointer Uniform %_arr_v4float_uint_8 %_ptr_Function_v4float = OpTypePointer Function %v4float %MyCBuffer = OpVariable %_ptr_Uniform_type_MyCBuffer Uniform %in_var_INDEX = OpVariable %_ptr_Input_int Input %out_var_SV_Target = OpVariable %_ptr_Output_v4float Output ; CHECK: OpFunction ; CHECK: OpLabel ; CHECK: OpVariable ; CHECK: OpAccessChain ; CHECK: [[new_address:%\w+]] = OpAccessChain %_ptr_Uniform__arr_v4float_uint_8 %MyCBuffer %int_0 ; CHECK: [[element_ptr:%\w+]] = OpAccessChain %_ptr_Uniform_v4float [[new_address]] %24 ; CHECK: [[load:%\w+]] = OpLoad %v4float [[element_ptr]] ; CHECK: OpStore %out_var_SV_Target [[load]] %main = OpFunction %void None %13 %22 = OpLabel %23 = OpVariable %_ptr_Function__arr_v4float_uint_8_0 Function %24 = OpLoad %int %in_var_INDEX %25 = OpAccessChain %_ptr_Uniform__arr_v4float_uint_8 %MyCBuffer %int_0 %26 = OpLoad %_arr_v4float_uint_8 %25 %27 = OpCompositeExtract %v4float %26 0 %28 = OpCompositeExtract %v4float %26 1 %29 = OpCompositeExtract %v4float %26 2 %30 = OpCompositeExtract %v4float %26 3 %31 = OpCompositeExtract %v4float %26 4 %32 = OpCompositeExtract %v4float %26 5 %33 = OpCompositeExtract %v4float %26 6 %34 = OpCompositeExtract %v4float %26 7 %35 = OpCompositeConstruct %_arr_v4float_uint_8_0 %27 %28 %29 %30 %31 %32 %33 %34 OpStore %23 %35 %36 = OpAccessChain %_ptr_Function_v4float %23 %24 %37 = OpLoad %v4float %36 OpStore %out_var_SV_Target %37 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); SinglePassRunAndMatch(before, false); } TEST_F(CopyPropArrayPassTest, BasicPropagateArrayWithName) { const std::string before = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_INDEX %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %type_MyCBuffer "type.MyCBuffer" OpMemberName %type_MyCBuffer 0 "Data" OpName %MyCBuffer "MyCBuffer" OpName %main "main" OpName %local "local" OpName %in_var_INDEX "in.var.INDEX" OpName %out_var_SV_Target "out.var.SV_Target" OpDecorate %_arr_v4float_uint_8 ArrayStride 16 OpMemberDecorate %type_MyCBuffer 0 Offset 0 OpDecorate %type_MyCBuffer Block OpDecorate %in_var_INDEX Flat OpDecorate %in_var_INDEX Location 0 OpDecorate %out_var_SV_Target Location 0 OpDecorate %MyCBuffer DescriptorSet 0 OpDecorate %MyCBuffer Binding 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_8 = OpConstant %uint 8 %_arr_v4float_uint_8 = OpTypeArray %v4float %uint_8 %type_MyCBuffer = OpTypeStruct %_arr_v4float_uint_8 %_ptr_Uniform_type_MyCBuffer = OpTypePointer Uniform %type_MyCBuffer %void = OpTypeVoid %13 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %_ptr_Output_v4float = OpTypePointer Output %v4float %_arr_v4float_uint_8_0 = OpTypeArray %v4float %uint_8 %_ptr_Function__arr_v4float_uint_8_0 = OpTypePointer Function %_arr_v4float_uint_8_0 %int_0 = OpConstant %int 0 %_ptr_Uniform__arr_v4float_uint_8 = OpTypePointer Uniform %_arr_v4float_uint_8 %_ptr_Function_v4float = OpTypePointer Function %v4float %MyCBuffer = OpVariable %_ptr_Uniform_type_MyCBuffer Uniform %in_var_INDEX = OpVariable %_ptr_Input_int Input %out_var_SV_Target = OpVariable %_ptr_Output_v4float Output ; CHECK: OpFunction ; CHECK: OpLabel ; CHECK: OpVariable ; CHECK: OpAccessChain ; CHECK: [[new_address:%\w+]] = OpAccessChain %_ptr_Uniform__arr_v4float_uint_8 %MyCBuffer %int_0 ; CHECK: [[element_ptr:%\w+]] = OpAccessChain %_ptr_Uniform_v4float [[new_address]] %24 ; CHECK: [[load:%\w+]] = OpLoad %v4float [[element_ptr]] ; CHECK: OpStore %out_var_SV_Target [[load]] %main = OpFunction %void None %13 %22 = OpLabel %local = OpVariable %_ptr_Function__arr_v4float_uint_8_0 Function %24 = OpLoad %int %in_var_INDEX %25 = OpAccessChain %_ptr_Uniform__arr_v4float_uint_8 %MyCBuffer %int_0 %26 = OpLoad %_arr_v4float_uint_8 %25 %27 = OpCompositeExtract %v4float %26 0 %28 = OpCompositeExtract %v4float %26 1 %29 = OpCompositeExtract %v4float %26 2 %30 = OpCompositeExtract %v4float %26 3 %31 = OpCompositeExtract %v4float %26 4 %32 = OpCompositeExtract %v4float %26 5 %33 = OpCompositeExtract %v4float %26 6 %34 = OpCompositeExtract %v4float %26 7 %35 = OpCompositeConstruct %_arr_v4float_uint_8_0 %27 %28 %29 %30 %31 %32 %33 %34 OpStore %local %35 %36 = OpAccessChain %_ptr_Function_v4float %local %24 %37 = OpLoad %v4float %36 OpStore %out_var_SV_Target %37 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); SinglePassRunAndMatch(before, false); } // Propagate 2d array. This test identifying a copy through multiple levels. // Also has to traverse multiple OpAccessChains. TEST_F(CopyPropArrayPassTest, Propagate2DArray) { const std::string text = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_INDEX %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %type_MyCBuffer "type.MyCBuffer" OpMemberName %type_MyCBuffer 0 "Data" OpName %MyCBuffer "MyCBuffer" OpName %main "main" OpName %in_var_INDEX "in.var.INDEX" OpName %out_var_SV_Target "out.var.SV_Target" OpDecorate %_arr_v4float_uint_2 ArrayStride 16 OpDecorate %_arr__arr_v4float_uint_2_uint_2 ArrayStride 32 OpMemberDecorate %type_MyCBuffer 0 Offset 0 OpDecorate %type_MyCBuffer Block OpDecorate %in_var_INDEX Flat OpDecorate %in_var_INDEX Location 0 OpDecorate %out_var_SV_Target Location 0 OpDecorate %MyCBuffer DescriptorSet 0 OpDecorate %MyCBuffer Binding 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_arr_v4float_uint_2 = OpTypeArray %v4float %uint_2 %_arr__arr_v4float_uint_2_uint_2 = OpTypeArray %_arr_v4float_uint_2 %uint_2 %type_MyCBuffer = OpTypeStruct %_arr__arr_v4float_uint_2_uint_2 %_ptr_Uniform_type_MyCBuffer = OpTypePointer Uniform %type_MyCBuffer %void = OpTypeVoid %14 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %_ptr_Output_v4float = OpTypePointer Output %v4float %_arr_v4float_uint_2_0 = OpTypeArray %v4float %uint_2 %_arr__arr_v4float_uint_2_0_uint_2 = OpTypeArray %_arr_v4float_uint_2_0 %uint_2 %_ptr_Function__arr__arr_v4float_uint_2_0_uint_2 = OpTypePointer Function %_arr__arr_v4float_uint_2_0_uint_2 %int_0 = OpConstant %int 0 %_ptr_Uniform__arr__arr_v4float_uint_2_uint_2 = OpTypePointer Uniform %_arr__arr_v4float_uint_2_uint_2 %_ptr_Function__arr_v4float_uint_2_0 = OpTypePointer Function %_arr_v4float_uint_2_0 %_ptr_Function_v4float = OpTypePointer Function %v4float %MyCBuffer = OpVariable %_ptr_Uniform_type_MyCBuffer Uniform %in_var_INDEX = OpVariable %_ptr_Input_int Input %out_var_SV_Target = OpVariable %_ptr_Output_v4float Output ; CHECK: OpFunction ; CHECK: OpLabel ; CHECK: OpVariable ; CHECK: OpVariable ; CHECK: OpAccessChain ; CHECK: [[new_address:%\w+]] = OpAccessChain %_ptr_Uniform__arr__arr_v4float_uint_2_uint_2 %MyCBuffer %int_0 %main = OpFunction %void None %14 %25 = OpLabel %26 = OpVariable %_ptr_Function__arr_v4float_uint_2_0 Function %27 = OpVariable %_ptr_Function__arr__arr_v4float_uint_2_0_uint_2 Function %28 = OpLoad %int %in_var_INDEX %29 = OpAccessChain %_ptr_Uniform__arr__arr_v4float_uint_2_uint_2 %MyCBuffer %int_0 %30 = OpLoad %_arr__arr_v4float_uint_2_uint_2 %29 %31 = OpCompositeExtract %_arr_v4float_uint_2 %30 0 %32 = OpCompositeExtract %v4float %31 0 %33 = OpCompositeExtract %v4float %31 1 %34 = OpCompositeConstruct %_arr_v4float_uint_2_0 %32 %33 %35 = OpCompositeExtract %_arr_v4float_uint_2 %30 1 %36 = OpCompositeExtract %v4float %35 0 %37 = OpCompositeExtract %v4float %35 1 %38 = OpCompositeConstruct %_arr_v4float_uint_2_0 %36 %37 %39 = OpCompositeConstruct %_arr__arr_v4float_uint_2_0_uint_2 %34 %38 ; CHECK: OpStore OpStore %27 %39 %40 = OpAccessChain %_ptr_Function__arr_v4float_uint_2_0 %27 %28 %42 = OpAccessChain %_ptr_Function_v4float %40 %28 %43 = OpLoad %v4float %42 ; CHECK: [[ac1:%\w+]] = OpAccessChain %_ptr_Uniform__arr_v4float_uint_2 [[new_address]] %28 ; CHECK: [[ac2:%\w+]] = OpAccessChain %_ptr_Uniform_v4float [[ac1]] %28 ; CHECK: [[load:%\w+]] = OpLoad %v4float [[ac2]] ; CHECK: OpStore %out_var_SV_Target [[load]] OpStore %out_var_SV_Target %43 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); SinglePassRunAndMatch(text, false); } // Propagate 2d array. This test identifying a copy through multiple levels. // Also has to traverse multiple OpAccessChains. TEST_F(CopyPropArrayPassTest, Propagate2DArrayWithMultiLevelExtract) { const std::string text = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_INDEX %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %type_MyCBuffer "type.MyCBuffer" OpMemberName %type_MyCBuffer 0 "Data" OpName %MyCBuffer "MyCBuffer" OpName %main "main" OpName %in_var_INDEX "in.var.INDEX" OpName %out_var_SV_Target "out.var.SV_Target" OpDecorate %_arr_v4float_uint_2 ArrayStride 16 OpDecorate %_arr__arr_v4float_uint_2_uint_2 ArrayStride 32 OpMemberDecorate %type_MyCBuffer 0 Offset 0 OpDecorate %type_MyCBuffer Block OpDecorate %in_var_INDEX Flat OpDecorate %in_var_INDEX Location 0 OpDecorate %out_var_SV_Target Location 0 OpDecorate %MyCBuffer DescriptorSet 0 OpDecorate %MyCBuffer Binding 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_arr_v4float_uint_2 = OpTypeArray %v4float %uint_2 %_arr__arr_v4float_uint_2_uint_2 = OpTypeArray %_arr_v4float_uint_2 %uint_2 %type_MyCBuffer = OpTypeStruct %_arr__arr_v4float_uint_2_uint_2 %_ptr_Uniform_type_MyCBuffer = OpTypePointer Uniform %type_MyCBuffer %void = OpTypeVoid %14 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %_ptr_Output_v4float = OpTypePointer Output %v4float %_arr_v4float_uint_2_0 = OpTypeArray %v4float %uint_2 %_arr__arr_v4float_uint_2_0_uint_2 = OpTypeArray %_arr_v4float_uint_2_0 %uint_2 %_ptr_Function__arr__arr_v4float_uint_2_0_uint_2 = OpTypePointer Function %_arr__arr_v4float_uint_2_0_uint_2 %int_0 = OpConstant %int 0 %_ptr_Uniform__arr__arr_v4float_uint_2_uint_2 = OpTypePointer Uniform %_arr__arr_v4float_uint_2_uint_2 %_ptr_Function__arr_v4float_uint_2_0 = OpTypePointer Function %_arr_v4float_uint_2_0 %_ptr_Function_v4float = OpTypePointer Function %v4float %MyCBuffer = OpVariable %_ptr_Uniform_type_MyCBuffer Uniform %in_var_INDEX = OpVariable %_ptr_Input_int Input %out_var_SV_Target = OpVariable %_ptr_Output_v4float Output ; CHECK: OpFunction ; CHECK: OpLabel ; CHECK: OpVariable ; CHECK: OpVariable ; CHECK: OpAccessChain ; CHECK: [[new_address:%\w+]] = OpAccessChain %_ptr_Uniform__arr__arr_v4float_uint_2_uint_2 %MyCBuffer %int_0 %main = OpFunction %void None %14 %25 = OpLabel %26 = OpVariable %_ptr_Function__arr_v4float_uint_2_0 Function %27 = OpVariable %_ptr_Function__arr__arr_v4float_uint_2_0_uint_2 Function %28 = OpLoad %int %in_var_INDEX %29 = OpAccessChain %_ptr_Uniform__arr__arr_v4float_uint_2_uint_2 %MyCBuffer %int_0 %30 = OpLoad %_arr__arr_v4float_uint_2_uint_2 %29 %32 = OpCompositeExtract %v4float %30 0 0 %33 = OpCompositeExtract %v4float %30 0 1 %34 = OpCompositeConstruct %_arr_v4float_uint_2_0 %32 %33 %36 = OpCompositeExtract %v4float %30 1 0 %37 = OpCompositeExtract %v4float %30 1 1 %38 = OpCompositeConstruct %_arr_v4float_uint_2_0 %36 %37 %39 = OpCompositeConstruct %_arr__arr_v4float_uint_2_0_uint_2 %34 %38 ; CHECK: OpStore OpStore %27 %39 %40 = OpAccessChain %_ptr_Function__arr_v4float_uint_2_0 %27 %28 %42 = OpAccessChain %_ptr_Function_v4float %40 %28 %43 = OpLoad %v4float %42 ; CHECK: [[ac1:%\w+]] = OpAccessChain %_ptr_Uniform__arr_v4float_uint_2 [[new_address]] %28 ; CHECK: [[ac2:%\w+]] = OpAccessChain %_ptr_Uniform_v4float [[ac1]] %28 ; CHECK: [[load:%\w+]] = OpLoad %v4float [[ac2]] ; CHECK: OpStore %out_var_SV_Target [[load]] OpStore %out_var_SV_Target %43 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); SinglePassRunAndMatch(text, false); } // Test decomposing an object when we need to "rewrite" a store. TEST_F(CopyPropArrayPassTest, DecomposeObjectForArrayStore) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_INDEX %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %type_MyCBuffer "type.MyCBuffer" OpMemberName %type_MyCBuffer 0 "Data" OpName %MyCBuffer "MyCBuffer" OpName %main "main" OpName %in_var_INDEX "in.var.INDEX" OpName %out_var_SV_Target "out.var.SV_Target" OpDecorate %_arr_v4float_uint_2 ArrayStride 16 OpDecorate %_arr__arr_v4float_uint_2_uint_2 ArrayStride 32 OpMemberDecorate %type_MyCBuffer 0 Offset 0 OpDecorate %type_MyCBuffer Block OpDecorate %in_var_INDEX Flat OpDecorate %in_var_INDEX Location 0 OpDecorate %out_var_SV_Target Location 0 OpDecorate %MyCBuffer DescriptorSet 0 OpDecorate %MyCBuffer Binding 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_arr_v4float_uint_2 = OpTypeArray %v4float %uint_2 %_arr__arr_v4float_uint_2_uint_2 = OpTypeArray %_arr_v4float_uint_2 %uint_2 %type_MyCBuffer = OpTypeStruct %_arr__arr_v4float_uint_2_uint_2 %_ptr_Uniform_type_MyCBuffer = OpTypePointer Uniform %type_MyCBuffer %void = OpTypeVoid %14 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %_ptr_Output_v4float = OpTypePointer Output %v4float %_arr_v4float_uint_2_0 = OpTypeArray %v4float %uint_2 %_arr__arr_v4float_uint_2_0_uint_2 = OpTypeArray %_arr_v4float_uint_2_0 %uint_2 %_ptr_Function__arr__arr_v4float_uint_2_0_uint_2 = OpTypePointer Function %_arr__arr_v4float_uint_2_0_uint_2 %int_0 = OpConstant %int 0 %_ptr_Uniform__arr__arr_v4float_uint_2_uint_2 = OpTypePointer Uniform %_arr__arr_v4float_uint_2_uint_2 %_ptr_Function__arr_v4float_uint_2_0 = OpTypePointer Function %_arr_v4float_uint_2_0 %_ptr_Function_v4float = OpTypePointer Function %v4float %MyCBuffer = OpVariable %_ptr_Uniform_type_MyCBuffer Uniform %in_var_INDEX = OpVariable %_ptr_Input_int Input %out_var_SV_Target = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %14 %25 = OpLabel %26 = OpVariable %_ptr_Function__arr_v4float_uint_2_0 Function %27 = OpVariable %_ptr_Function__arr__arr_v4float_uint_2_0_uint_2 Function %28 = OpLoad %int %in_var_INDEX %29 = OpAccessChain %_ptr_Uniform__arr__arr_v4float_uint_2_uint_2 %MyCBuffer %int_0 %30 = OpLoad %_arr__arr_v4float_uint_2_uint_2 %29 %31 = OpCompositeExtract %_arr_v4float_uint_2 %30 0 %32 = OpCompositeExtract %v4float %31 0 %33 = OpCompositeExtract %v4float %31 1 %34 = OpCompositeConstruct %_arr_v4float_uint_2_0 %32 %33 %35 = OpCompositeExtract %_arr_v4float_uint_2 %30 1 %36 = OpCompositeExtract %v4float %35 0 %37 = OpCompositeExtract %v4float %35 1 %38 = OpCompositeConstruct %_arr_v4float_uint_2_0 %36 %37 %39 = OpCompositeConstruct %_arr__arr_v4float_uint_2_0_uint_2 %34 %38 OpStore %27 %39 ; CHECK: [[access_chain:%\w+]] = OpAccessChain %_ptr_Uniform__arr_v4float_uint_2 %40 = OpAccessChain %_ptr_Function__arr_v4float_uint_2_0 %27 %28 ; CHECK: [[load:%\w+]] = OpLoad %_arr_v4float_uint_2 [[access_chain]] %41 = OpLoad %_arr_v4float_uint_2_0 %40 ; CHECK: [[extract1:%\w+]] = OpCompositeExtract %v4float [[load]] 0 ; CHECK: [[extract2:%\w+]] = OpCompositeExtract %v4float [[load]] 1 ; CHECK: [[construct:%\w+]] = OpCompositeConstruct %_arr_v4float_uint_2_0 [[extract1]] [[extract2]] ; CHECK: OpStore %26 [[construct]] OpStore %26 %41 %42 = OpAccessChain %_ptr_Function_v4float %26 %28 %43 = OpLoad %v4float %42 OpStore %out_var_SV_Target %43 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); SinglePassRunAndMatch(text, false); } // Test decomposing an object when we need to "rewrite" a store. TEST_F(CopyPropArrayPassTest, DecomposeObjectForStructStore) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_INDEX %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %type_MyCBuffer "type.MyCBuffer" OpMemberName %type_MyCBuffer 0 "Data" OpName %MyCBuffer "MyCBuffer" OpName %main "main" OpName %in_var_INDEX "in.var.INDEX" OpName %out_var_SV_Target "out.var.SV_Target" OpMemberDecorate %type_MyCBuffer 0 Offset 0 OpDecorate %type_MyCBuffer Block OpDecorate %in_var_INDEX Flat OpDecorate %in_var_INDEX Location 0 OpDecorate %out_var_SV_Target Location 0 OpDecorate %MyCBuffer DescriptorSet 0 OpDecorate %MyCBuffer Binding 0 ; CHECK: OpDecorate [[decorated_type:%\w+]] GLSLPacked OpDecorate %struct GLSLPacked %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 ; CHECK: [[decorated_type]] = OpTypeStruct %struct = OpTypeStruct %float %uint %_arr_struct_uint_2 = OpTypeArray %struct %uint_2 %type_MyCBuffer = OpTypeStruct %_arr_struct_uint_2 %_ptr_Uniform_type_MyCBuffer = OpTypePointer Uniform %type_MyCBuffer %void = OpTypeVoid %14 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %_ptr_Output_v4float = OpTypePointer Output %v4float ; CHECK: [[struct:%\w+]] = OpTypeStruct %float %uint %struct_0 = OpTypeStruct %float %uint %_arr_struct_0_uint_2 = OpTypeArray %struct_0 %uint_2 %_ptr_Function__arr_struct_0_uint_2 = OpTypePointer Function %_arr_struct_0_uint_2 %int_0 = OpConstant %int 0 %_ptr_Uniform__arr_struct_uint_2 = OpTypePointer Uniform %_arr_struct_uint_2 ; CHECK: [[decorated_ptr:%\w+]] = OpTypePointer Uniform [[decorated_type]] %_ptr_Function_struct_0 = OpTypePointer Function %struct_0 %_ptr_Function_v4float = OpTypePointer Function %v4float %MyCBuffer = OpVariable %_ptr_Uniform_type_MyCBuffer Uniform %in_var_INDEX = OpVariable %_ptr_Input_int Input %out_var_SV_Target = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %14 %25 = OpLabel %26 = OpVariable %_ptr_Function_struct_0 Function %27 = OpVariable %_ptr_Function__arr_struct_0_uint_2 Function %28 = OpLoad %int %in_var_INDEX %29 = OpAccessChain %_ptr_Uniform__arr_struct_uint_2 %MyCBuffer %int_0 %30 = OpLoad %_arr_struct_uint_2 %29 %31 = OpCompositeExtract %struct %30 0 %32 = OpCompositeExtract %v4float %31 0 %33 = OpCompositeExtract %v4float %31 1 %34 = OpCompositeConstruct %struct_0 %32 %33 %35 = OpCompositeExtract %struct %30 1 %36 = OpCompositeExtract %float %35 0 %37 = OpCompositeExtract %uint %35 1 %38 = OpCompositeConstruct %struct_0 %36 %37 %39 = OpCompositeConstruct %_arr_struct_0_uint_2 %34 %38 OpStore %27 %39 ; CHECK: [[access_chain:%\w+]] = OpAccessChain [[decorated_ptr]] %40 = OpAccessChain %_ptr_Function_struct_0 %27 %28 ; CHECK: [[load:%\w+]] = OpLoad [[decorated_type]] [[access_chain]] %41 = OpLoad %struct_0 %40 ; CHECK: [[extract1:%\w+]] = OpCompositeExtract %float [[load]] 0 ; CHECK: [[extract2:%\w+]] = OpCompositeExtract %uint [[load]] 1 ; CHECK: [[construct:%\w+]] = OpCompositeConstruct [[struct]] [[extract1]] [[extract2]] ; CHECK: OpStore %26 [[construct]] OpStore %26 %41 %42 = OpAccessChain %_ptr_Function_v4float %26 %28 %43 = OpLoad %v4float %42 OpStore %out_var_SV_Target %43 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); SinglePassRunAndMatch(text, false); } TEST_F(CopyPropArrayPassTest, CopyViaInserts) { const std::string before = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_INDEX %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %type_MyCBuffer "type.MyCBuffer" OpMemberName %type_MyCBuffer 0 "Data" OpName %MyCBuffer "MyCBuffer" OpName %main "main" OpName %in_var_INDEX "in.var.INDEX" OpName %out_var_SV_Target "out.var.SV_Target" OpDecorate %_arr_v4float_uint_8 ArrayStride 16 OpMemberDecorate %type_MyCBuffer 0 Offset 0 OpDecorate %type_MyCBuffer Block OpDecorate %in_var_INDEX Flat OpDecorate %in_var_INDEX Location 0 OpDecorate %out_var_SV_Target Location 0 OpDecorate %MyCBuffer DescriptorSet 0 OpDecorate %MyCBuffer Binding 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_8 = OpConstant %uint 8 %_arr_v4float_uint_8 = OpTypeArray %v4float %uint_8 %type_MyCBuffer = OpTypeStruct %_arr_v4float_uint_8 %_ptr_Uniform_type_MyCBuffer = OpTypePointer Uniform %type_MyCBuffer %void = OpTypeVoid %13 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %_ptr_Output_v4float = OpTypePointer Output %v4float %_arr_v4float_uint_8_0 = OpTypeArray %v4float %uint_8 %_ptr_Function__arr_v4float_uint_8_0 = OpTypePointer Function %_arr_v4float_uint_8_0 %int_0 = OpConstant %int 0 %_ptr_Uniform__arr_v4float_uint_8 = OpTypePointer Uniform %_arr_v4float_uint_8 %_ptr_Function_v4float = OpTypePointer Function %v4float %MyCBuffer = OpVariable %_ptr_Uniform_type_MyCBuffer Uniform %in_var_INDEX = OpVariable %_ptr_Input_int Input %out_var_SV_Target = OpVariable %_ptr_Output_v4float Output ; CHECK: OpFunction ; CHECK: OpLabel ; CHECK: OpVariable ; CHECK: OpAccessChain ; CHECK: [[new_address:%\w+]] = OpAccessChain %_ptr_Uniform__arr_v4float_uint_8 %MyCBuffer %int_0 ; CHECK: [[element_ptr:%\w+]] = OpAccessChain %_ptr_Uniform_v4float [[new_address]] %24 ; CHECK: [[load:%\w+]] = OpLoad %v4float [[element_ptr]] ; CHECK: OpStore %out_var_SV_Target [[load]] %main = OpFunction %void None %13 %22 = OpLabel %23 = OpVariable %_ptr_Function__arr_v4float_uint_8_0 Function %undef = OpUndef %_arr_v4float_uint_8_0 %24 = OpLoad %int %in_var_INDEX %25 = OpAccessChain %_ptr_Uniform__arr_v4float_uint_8 %MyCBuffer %int_0 %26 = OpLoad %_arr_v4float_uint_8 %25 %27 = OpCompositeExtract %v4float %26 0 %i0 = OpCompositeInsert %_arr_v4float_uint_8_0 %27 %undef 0 %28 = OpCompositeExtract %v4float %26 1 %i1 = OpCompositeInsert %_arr_v4float_uint_8_0 %28 %i0 1 %29 = OpCompositeExtract %v4float %26 2 %i2 = OpCompositeInsert %_arr_v4float_uint_8_0 %29 %i1 2 %30 = OpCompositeExtract %v4float %26 3 %i3 = OpCompositeInsert %_arr_v4float_uint_8_0 %30 %i2 3 %31 = OpCompositeExtract %v4float %26 4 %i4 = OpCompositeInsert %_arr_v4float_uint_8_0 %31 %i3 4 %32 = OpCompositeExtract %v4float %26 5 %i5 = OpCompositeInsert %_arr_v4float_uint_8_0 %32 %i4 5 %33 = OpCompositeExtract %v4float %26 6 %i6 = OpCompositeInsert %_arr_v4float_uint_8_0 %33 %i5 6 %34 = OpCompositeExtract %v4float %26 7 %i7 = OpCompositeInsert %_arr_v4float_uint_8_0 %34 %i6 7 OpStore %23 %i7 %36 = OpAccessChain %_ptr_Function_v4float %23 %24 %37 = OpLoad %v4float %36 OpStore %out_var_SV_Target %37 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); SinglePassRunAndMatch(before, false); } TEST_F(CopyPropArrayPassTest, IsomorphicTypes1) { const std::string before = R"( ; CHECK: [[int:%\w+]] = OpTypeInt 32 0 ; CHECK: [[s1:%\w+]] = OpTypeStruct [[int]] ; CHECK: [[s2:%\w+]] = OpTypeStruct [[s1]] ; CHECK: [[a1:%\w+]] = OpTypeArray [[s2]] ; CHECK: [[s3:%\w+]] = OpTypeStruct [[a1]] ; CHECK: [[p_s3:%\w+]] = OpTypePointer Uniform [[s3]] ; CHECK: [[global_var:%\w+]] = OpVariable [[p_s3]] Uniform ; CHECK: [[p_a1:%\w+]] = OpTypePointer Uniform [[a1]] ; CHECK: [[p_s2:%\w+]] = OpTypePointer Uniform [[s2]] ; CHECK: [[ac1:%\w+]] = OpAccessChain [[p_a1]] [[global_var]] %uint_0 ; CHECK: [[ac2:%\w+]] = OpAccessChain [[p_s2]] [[ac1]] %uint_0 ; CHECK: [[ld:%\w+]] = OpLoad [[s2]] [[ac2]] ; CHECK: [[ex:%\w+]] = OpCompositeExtract [[s1]] [[ld]] OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "PS_main" OpExecutionMode %2 OriginUpperLeft OpSource HLSL 600 OpDecorate %3 DescriptorSet 0 OpDecorate %3 Binding 101 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %s1 = OpTypeStruct %uint %s2 = OpTypeStruct %s1 %a1 = OpTypeArray %s2 %uint_1 %s3 = OpTypeStruct %a1 %s1_1 = OpTypeStruct %uint %_ptr_Uniform_uint = OpTypePointer Uniform %uint %void = OpTypeVoid %13 = OpTypeFunction %void %uint_0 = OpConstant %uint 0 %s1_0 = OpTypeStruct %uint %s2_0 = OpTypeStruct %s1_0 %a1_0 = OpTypeArray %s2_0 %uint_1 %s3_0 = OpTypeStruct %a1_0 %p_s3 = OpTypePointer Uniform %s3 %p_s3_0 = OpTypePointer Function %s3_0 %3 = OpVariable %p_s3 Uniform %p_a1_0 = OpTypePointer Function %a1_0 %p_s2_0 = OpTypePointer Function %s2_0 %2 = OpFunction %void None %13 %20 = OpLabel %21 = OpVariable %p_a1_0 Function %22 = OpLoad %s3 %3 %23 = OpCompositeExtract %a1 %22 0 %24 = OpCompositeExtract %s2 %23 0 %25 = OpCompositeExtract %s1 %24 0 %26 = OpCompositeExtract %uint %25 0 %27 = OpCompositeConstruct %s1_0 %26 %32 = OpCompositeConstruct %s2_0 %27 %28 = OpCompositeConstruct %a1_0 %32 OpStore %21 %28 %29 = OpAccessChain %p_s2_0 %21 %uint_0 %30 = OpLoad %s2 %29 %31 = OpCompositeExtract %s1 %30 0 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); SinglePassRunAndMatch(before, false); } TEST_F(CopyPropArrayPassTest, IsomorphicTypes2) { const std::string before = R"( ; CHECK: [[int:%\w+]] = OpTypeInt 32 0 ; CHECK: [[s1:%\w+]] = OpTypeStruct [[int]] ; CHECK: [[s2:%\w+]] = OpTypeStruct [[s1]] ; CHECK: [[a1:%\w+]] = OpTypeArray [[s2]] ; CHECK: [[s3:%\w+]] = OpTypeStruct [[a1]] ; CHECK: [[p_s3:%\w+]] = OpTypePointer Uniform [[s3]] ; CHECK: [[global_var:%\w+]] = OpVariable [[p_s3]] Uniform ; CHECK: [[p_s2:%\w+]] = OpTypePointer Uniform [[s2]] ; CHECK: [[p_s1:%\w+]] = OpTypePointer Uniform [[s1]] ; CHECK: [[ac1:%\w+]] = OpAccessChain [[p_s2]] [[global_var]] %uint_0 %uint_0 ; CHECK: [[ac2:%\w+]] = OpAccessChain [[p_s1]] [[ac1]] %uint_0 ; CHECK: [[ld:%\w+]] = OpLoad [[s1]] [[ac2]] ; CHECK: [[ex:%\w+]] = OpCompositeExtract [[int]] [[ld]] OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "PS_main" OpExecutionMode %2 OriginUpperLeft OpSource HLSL 600 OpDecorate %3 DescriptorSet 0 OpDecorate %3 Binding 101 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_struct_6 = OpTypeStruct %uint %_struct_7 = OpTypeStruct %_struct_6 %_arr__struct_7_uint_1 = OpTypeArray %_struct_7 %uint_1 %_struct_9 = OpTypeStruct %_arr__struct_7_uint_1 %_struct_10 = OpTypeStruct %uint %_ptr_Uniform_uint = OpTypePointer Uniform %uint %void = OpTypeVoid %13 = OpTypeFunction %void %uint_0 = OpConstant %uint 0 %_struct_15 = OpTypeStruct %uint %_arr__struct_15_uint_1 = OpTypeArray %_struct_15 %uint_1 %_ptr_Uniform__struct_9 = OpTypePointer Uniform %_struct_9 %_ptr_Function__struct_15 = OpTypePointer Function %_struct_15 %3 = OpVariable %_ptr_Uniform__struct_9 Uniform %_ptr_Function__arr__struct_15_uint_1 = OpTypePointer Function %_arr__struct_15_uint_1 %2 = OpFunction %void None %13 %20 = OpLabel %21 = OpVariable %_ptr_Function__arr__struct_15_uint_1 Function %22 = OpLoad %_struct_9 %3 %23 = OpCompositeExtract %_arr__struct_7_uint_1 %22 0 %24 = OpCompositeExtract %_struct_7 %23 0 %25 = OpCompositeExtract %_struct_6 %24 0 %26 = OpCompositeExtract %uint %25 0 %27 = OpCompositeConstruct %_struct_15 %26 %28 = OpCompositeConstruct %_arr__struct_15_uint_1 %27 OpStore %21 %28 %29 = OpAccessChain %_ptr_Function__struct_15 %21 %uint_0 %30 = OpLoad %_struct_15 %29 %31 = OpCompositeExtract %uint %30 0 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); SinglePassRunAndMatch(before, false); } TEST_F(CopyPropArrayPassTest, IsomorphicTypes3) { const std::string before = R"( ; CHECK: [[int:%\w+]] = OpTypeInt 32 0 ; CHECK: [[s1:%\w+]] = OpTypeStruct [[int]] ; CHECK: [[s2:%\w+]] = OpTypeStruct [[s1]] ; CHECK: [[a1:%\w+]] = OpTypeArray [[s2]] ; CHECK: [[s3:%\w+]] = OpTypeStruct [[a1]] ; CHECK: [[s1_1:%\w+]] = OpTypeStruct [[int]] ; CHECK: [[p_s3:%\w+]] = OpTypePointer Uniform [[s3]] ; CHECK: [[p_s1_1:%\w+]] = OpTypePointer Function [[s1_1]] ; CHECK: [[global_var:%\w+]] = OpVariable [[p_s3]] Uniform ; CHECK: [[p_s2:%\w+]] = OpTypePointer Uniform [[s2]] ; CHECK: [[p_s1:%\w+]] = OpTypePointer Uniform [[s1]] ; CHECK: [[var:%\w+]] = OpVariable [[p_s1_1]] Function ; CHECK: [[ac1:%\w+]] = OpAccessChain [[p_s2]] [[global_var]] %uint_0 %uint_0 ; CHECK: [[ac2:%\w+]] = OpAccessChain [[p_s1]] [[ac1]] %uint_0 ; CHECK: [[ld:%\w+]] = OpLoad [[s1]] [[ac2]] ; CHECK: [[ex:%\w+]] = OpCompositeExtract [[int]] [[ld]] ; CHECK: [[copy:%\w+]] = OpCompositeConstruct [[s1_1]] [[ex]] ; CHECK: OpStore [[var]] [[copy]] OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "PS_main" OpExecutionMode %2 OriginUpperLeft OpSource HLSL 600 OpDecorate %3 DescriptorSet 0 OpDecorate %3 Binding 101 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_struct_6 = OpTypeStruct %uint %_struct_7 = OpTypeStruct %_struct_6 %_arr__struct_7_uint_1 = OpTypeArray %_struct_7 %uint_1 %_struct_9 = OpTypeStruct %_arr__struct_7_uint_1 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %void = OpTypeVoid %13 = OpTypeFunction %void %uint_0 = OpConstant %uint 0 %_struct_15 = OpTypeStruct %uint %_struct_10 = OpTypeStruct %uint %_arr__struct_15_uint_1 = OpTypeArray %_struct_15 %uint_1 %_ptr_Uniform__struct_9 = OpTypePointer Uniform %_struct_9 %_ptr_Function__struct_15 = OpTypePointer Function %_struct_15 %3 = OpVariable %_ptr_Uniform__struct_9 Uniform %_ptr_Function__arr__struct_15_uint_1 = OpTypePointer Function %_arr__struct_15_uint_1 %2 = OpFunction %void None %13 %20 = OpLabel %21 = OpVariable %_ptr_Function__arr__struct_15_uint_1 Function %var = OpVariable %_ptr_Function__struct_15 Function %22 = OpLoad %_struct_9 %3 %23 = OpCompositeExtract %_arr__struct_7_uint_1 %22 0 %24 = OpCompositeExtract %_struct_7 %23 0 %25 = OpCompositeExtract %_struct_6 %24 0 %26 = OpCompositeExtract %uint %25 0 %27 = OpCompositeConstruct %_struct_15 %26 %28 = OpCompositeConstruct %_arr__struct_15_uint_1 %27 OpStore %21 %28 %29 = OpAccessChain %_ptr_Function__struct_15 %21 %uint_0 %30 = OpLoad %_struct_15 %29 OpStore %var %30 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); SinglePassRunAndMatch(before, false); } TEST_F(CopyPropArrayPassTest, BadMergingTwoObjects) { // The second element in the |OpCompositeConstruct| is from a different // object. const std::string text = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpName %type_ConstBuf "type.ConstBuf" OpMemberName %type_ConstBuf 0 "TexSizeU" OpMemberName %type_ConstBuf 1 "TexSizeV" OpName %ConstBuf "ConstBuf" OpName %main "main" OpMemberDecorate %type_ConstBuf 0 Offset 0 OpMemberDecorate %type_ConstBuf 1 Offset 8 OpDecorate %type_ConstBuf Block OpDecorate %ConstBuf DescriptorSet 0 OpDecorate %ConstBuf Binding 2 %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %type_ConstBuf = OpTypeStruct %v2float %v2float %_ptr_Uniform_type_ConstBuf = OpTypePointer Uniform %type_ConstBuf %void = OpTypeVoid %9 = OpTypeFunction %void %uint = OpTypeInt 32 0 %int_0 = OpConstant %uint 0 %uint_2 = OpConstant %uint 2 %_arr_v2float_uint_2 = OpTypeArray %v2float %uint_2 %_ptr_Function__arr_v2float_uint_2 = OpTypePointer Function %_arr_v2float_uint_2 %_ptr_Uniform_v2float = OpTypePointer Uniform %v2float %ConstBuf = OpVariable %_ptr_Uniform_type_ConstBuf Uniform %main = OpFunction %void None %9 %24 = OpLabel %25 = OpVariable %_ptr_Function__arr_v2float_uint_2 Function %27 = OpAccessChain %_ptr_Uniform_v2float %ConstBuf %int_0 %28 = OpLoad %v2float %27 %29 = OpAccessChain %_ptr_Uniform_v2float %ConstBuf %int_0 %30 = OpLoad %v2float %29 %31 = OpFNegate %v2float %30 %37 = OpCompositeConstruct %_arr_v2float_uint_2 %28 %31 OpStore %25 %37 OpReturn OpFunctionEnd )"; auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ false); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } TEST_F(CopyPropArrayPassTest, SecondElementNotContained) { // The second element in the |OpCompositeConstruct| is not a memory object. // Make sure no change happends. const std::string text = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpName %type_ConstBuf "type.ConstBuf" OpMemberName %type_ConstBuf 0 "TexSizeU" OpMemberName %type_ConstBuf 1 "TexSizeV" OpName %ConstBuf "ConstBuf" OpName %main "main" OpMemberDecorate %type_ConstBuf 0 Offset 0 OpMemberDecorate %type_ConstBuf 1 Offset 8 OpDecorate %type_ConstBuf Block OpDecorate %ConstBuf DescriptorSet 0 OpDecorate %ConstBuf Binding 2 OpDecorate %ConstBuf2 DescriptorSet 1 OpDecorate %ConstBuf2 Binding 2 %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %type_ConstBuf = OpTypeStruct %v2float %v2float %_ptr_Uniform_type_ConstBuf = OpTypePointer Uniform %type_ConstBuf %void = OpTypeVoid %9 = OpTypeFunction %void %uint = OpTypeInt 32 0 %int_0 = OpConstant %uint 0 %int_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %_arr_v2float_uint_2 = OpTypeArray %v2float %uint_2 %_ptr_Function__arr_v2float_uint_2 = OpTypePointer Function %_arr_v2float_uint_2 %_ptr_Uniform_v2float = OpTypePointer Uniform %v2float %ConstBuf = OpVariable %_ptr_Uniform_type_ConstBuf Uniform %ConstBuf2 = OpVariable %_ptr_Uniform_type_ConstBuf Uniform %main = OpFunction %void None %9 %24 = OpLabel %25 = OpVariable %_ptr_Function__arr_v2float_uint_2 Function %27 = OpAccessChain %_ptr_Uniform_v2float %ConstBuf %int_0 %28 = OpLoad %v2float %27 %29 = OpAccessChain %_ptr_Uniform_v2float %ConstBuf2 %int_1 %30 = OpLoad %v2float %29 %37 = OpCompositeConstruct %_arr_v2float_uint_2 %28 %30 OpStore %25 %37 OpReturn OpFunctionEnd )"; auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ false); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } // This test will place a load before the store. We cannot propagate in this // case. TEST_F(CopyPropArrayPassTest, LoadBeforeStore) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_INDEX %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %type_MyCBuffer "type.MyCBuffer" OpMemberName %type_MyCBuffer 0 "Data" OpName %MyCBuffer "MyCBuffer" OpName %main "main" OpName %in_var_INDEX "in.var.INDEX" OpName %out_var_SV_Target "out.var.SV_Target" OpDecorate %_arr_v4float_uint_8 ArrayStride 16 OpMemberDecorate %type_MyCBuffer 0 Offset 0 OpDecorate %type_MyCBuffer Block OpDecorate %in_var_INDEX Flat OpDecorate %in_var_INDEX Location 0 OpDecorate %out_var_SV_Target Location 0 OpDecorate %MyCBuffer DescriptorSet 0 OpDecorate %MyCBuffer Binding 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_8 = OpConstant %uint 8 %_arr_v4float_uint_8 = OpTypeArray %v4float %uint_8 %type_MyCBuffer = OpTypeStruct %_arr_v4float_uint_8 %_ptr_Uniform_type_MyCBuffer = OpTypePointer Uniform %type_MyCBuffer %void = OpTypeVoid %13 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %_ptr_Output_v4float = OpTypePointer Output %v4float %_arr_v4float_uint_8_0 = OpTypeArray %v4float %uint_8 %_ptr_Function__arr_v4float_uint_8_0 = OpTypePointer Function %_arr_v4float_uint_8_0 %int_0 = OpConstant %int 0 %_ptr_Uniform__arr_v4float_uint_8 = OpTypePointer Uniform %_arr_v4float_uint_8 %_ptr_Function_v4float = OpTypePointer Function %v4float %MyCBuffer = OpVariable %_ptr_Uniform_type_MyCBuffer Uniform %in_var_INDEX = OpVariable %_ptr_Input_int Input %out_var_SV_Target = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %13 %22 = OpLabel %23 = OpVariable %_ptr_Function__arr_v4float_uint_8_0 Function %38 = OpAccessChain %_ptr_Function_v4float %23 %24 %39 = OpLoad %v4float %36 %24 = OpLoad %int %in_var_INDEX %25 = OpAccessChain %_ptr_Uniform__arr_v4float_uint_8 %MyCBuffer %int_0 %26 = OpLoad %_arr_v4float_uint_8 %25 %27 = OpCompositeExtract %v4float %26 0 %28 = OpCompositeExtract %v4float %26 1 %29 = OpCompositeExtract %v4float %26 2 %30 = OpCompositeExtract %v4float %26 3 %31 = OpCompositeExtract %v4float %26 4 %32 = OpCompositeExtract %v4float %26 5 %33 = OpCompositeExtract %v4float %26 6 %34 = OpCompositeExtract %v4float %26 7 %35 = OpCompositeConstruct %_arr_v4float_uint_8_0 %27 %28 %29 %30 %31 %32 %33 %34 OpStore %23 %35 %36 = OpAccessChain %_ptr_Function_v4float %23 %24 %37 = OpLoad %v4float %36 OpStore %out_var_SV_Target %37 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ false); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } // This test will place a load where it is not dominated by the store. We // cannot propagate in this case. TEST_F(CopyPropArrayPassTest, LoadNotDominated) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_INDEX %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %type_MyCBuffer "type.MyCBuffer" OpMemberName %type_MyCBuffer 0 "Data" OpName %MyCBuffer "MyCBuffer" OpName %main "main" OpName %in_var_INDEX "in.var.INDEX" OpName %out_var_SV_Target "out.var.SV_Target" OpDecorate %_arr_v4float_uint_8 ArrayStride 16 OpMemberDecorate %type_MyCBuffer 0 Offset 0 OpDecorate %type_MyCBuffer Block OpDecorate %in_var_INDEX Flat OpDecorate %in_var_INDEX Location 0 OpDecorate %out_var_SV_Target Location 0 OpDecorate %MyCBuffer DescriptorSet 0 OpDecorate %MyCBuffer Binding 0 %bool = OpTypeBool %true = OpConstantTrue %bool %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_8 = OpConstant %uint 8 %_arr_v4float_uint_8 = OpTypeArray %v4float %uint_8 %type_MyCBuffer = OpTypeStruct %_arr_v4float_uint_8 %_ptr_Uniform_type_MyCBuffer = OpTypePointer Uniform %type_MyCBuffer %void = OpTypeVoid %13 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %_ptr_Output_v4float = OpTypePointer Output %v4float %_arr_v4float_uint_8_0 = OpTypeArray %v4float %uint_8 %_ptr_Function__arr_v4float_uint_8_0 = OpTypePointer Function %_arr_v4float_uint_8_0 %int_0 = OpConstant %int 0 %_ptr_Uniform__arr_v4float_uint_8 = OpTypePointer Uniform %_arr_v4float_uint_8 %_ptr_Function_v4float = OpTypePointer Function %v4float %MyCBuffer = OpVariable %_ptr_Uniform_type_MyCBuffer Uniform %in_var_INDEX = OpVariable %_ptr_Input_int Input %out_var_SV_Target = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %13 %22 = OpLabel %23 = OpVariable %_ptr_Function__arr_v4float_uint_8_0 Function OpSelectionMerge %merge None OpBranchConditional %true %if %else %if = OpLabel %24 = OpLoad %int %in_var_INDEX %25 = OpAccessChain %_ptr_Uniform__arr_v4float_uint_8 %MyCBuffer %int_0 %26 = OpLoad %_arr_v4float_uint_8 %25 %27 = OpCompositeExtract %v4float %26 0 %28 = OpCompositeExtract %v4float %26 1 %29 = OpCompositeExtract %v4float %26 2 %30 = OpCompositeExtract %v4float %26 3 %31 = OpCompositeExtract %v4float %26 4 %32 = OpCompositeExtract %v4float %26 5 %33 = OpCompositeExtract %v4float %26 6 %34 = OpCompositeExtract %v4float %26 7 %35 = OpCompositeConstruct %_arr_v4float_uint_8_0 %27 %28 %29 %30 %31 %32 %33 %34 OpStore %23 %35 %38 = OpAccessChain %_ptr_Function_v4float %23 %24 %39 = OpLoad %v4float %36 OpBranch %merge %else = OpLabel %36 = OpAccessChain %_ptr_Function_v4float %23 %24 %37 = OpLoad %v4float %36 OpBranch %merge %merge = OpLabel %phi = OpPhi %out_var_SV_Target %39 %if %37 %else OpStore %out_var_SV_Target %phi OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ false); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } // This test has a partial store to the variable. We cannot propagate in this // case. TEST_F(CopyPropArrayPassTest, PartialStore) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_INDEX %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %type_MyCBuffer "type.MyCBuffer" OpMemberName %type_MyCBuffer 0 "Data" OpName %MyCBuffer "MyCBuffer" OpName %main "main" OpName %in_var_INDEX "in.var.INDEX" OpName %out_var_SV_Target "out.var.SV_Target" OpDecorate %_arr_v4float_uint_8 ArrayStride 16 OpMemberDecorate %type_MyCBuffer 0 Offset 0 OpDecorate %type_MyCBuffer Block OpDecorate %in_var_INDEX Flat OpDecorate %in_var_INDEX Location 0 OpDecorate %out_var_SV_Target Location 0 OpDecorate %MyCBuffer DescriptorSet 0 OpDecorate %MyCBuffer Binding 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_8 = OpConstant %uint 8 %_arr_v4float_uint_8 = OpTypeArray %v4float %uint_8 %type_MyCBuffer = OpTypeStruct %_arr_v4float_uint_8 %_ptr_Uniform_type_MyCBuffer = OpTypePointer Uniform %type_MyCBuffer %void = OpTypeVoid %13 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %_ptr_Output_v4float = OpTypePointer Output %v4float %_arr_v4float_uint_8_0 = OpTypeArray %v4float %uint_8 %_ptr_Function__arr_v4float_uint_8_0 = OpTypePointer Function %_arr_v4float_uint_8_0 %int_0 = OpConstant %int 0 %f0 = OpConstant %float 0 %v4const = OpConstantComposite %v4float %f0 %f0 %f0 %f0 %_ptr_Uniform__arr_v4float_uint_8 = OpTypePointer Uniform %_arr_v4float_uint_8 %_ptr_Function_v4float = OpTypePointer Function %v4float %MyCBuffer = OpVariable %_ptr_Uniform_type_MyCBuffer Uniform %in_var_INDEX = OpVariable %_ptr_Input_int Input %out_var_SV_Target = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %13 %22 = OpLabel %23 = OpVariable %_ptr_Function__arr_v4float_uint_8_0 Function %24 = OpLoad %int %in_var_INDEX %25 = OpAccessChain %_ptr_Uniform__arr_v4float_uint_8 %MyCBuffer %int_0 %26 = OpLoad %_arr_v4float_uint_8 %25 %27 = OpCompositeExtract %v4float %26 0 %28 = OpCompositeExtract %v4float %26 1 %29 = OpCompositeExtract %v4float %26 2 %30 = OpCompositeExtract %v4float %26 3 %31 = OpCompositeExtract %v4float %26 4 %32 = OpCompositeExtract %v4float %26 5 %33 = OpCompositeExtract %v4float %26 6 %34 = OpCompositeExtract %v4float %26 7 %35 = OpCompositeConstruct %_arr_v4float_uint_8_0 %27 %28 %29 %30 %31 %32 %33 %34 OpStore %23 %35 %36 = OpAccessChain %_ptr_Function_v4float %23 %24 %37 = OpLoad %v4float %36 OpStore %36 %v4const OpStore %out_var_SV_Target %37 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ false); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } // This test does not have a proper copy of an object. We cannot propagate in // this case. TEST_F(CopyPropArrayPassTest, NotACopy) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_INDEX %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %type_MyCBuffer "type.MyCBuffer" OpMemberName %type_MyCBuffer 0 "Data" OpName %MyCBuffer "MyCBuffer" OpName %main "main" OpName %in_var_INDEX "in.var.INDEX" OpName %out_var_SV_Target "out.var.SV_Target" OpDecorate %_arr_v4float_uint_8 ArrayStride 16 OpMemberDecorate %type_MyCBuffer 0 Offset 0 OpDecorate %type_MyCBuffer Block OpDecorate %in_var_INDEX Flat OpDecorate %in_var_INDEX Location 0 OpDecorate %out_var_SV_Target Location 0 OpDecorate %MyCBuffer DescriptorSet 0 OpDecorate %MyCBuffer Binding 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_8 = OpConstant %uint 8 %_arr_v4float_uint_8 = OpTypeArray %v4float %uint_8 %type_MyCBuffer = OpTypeStruct %_arr_v4float_uint_8 %_ptr_Uniform_type_MyCBuffer = OpTypePointer Uniform %type_MyCBuffer %void = OpTypeVoid %13 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %_ptr_Output_v4float = OpTypePointer Output %v4float %_arr_v4float_uint_8_0 = OpTypeArray %v4float %uint_8 %_ptr_Function__arr_v4float_uint_8_0 = OpTypePointer Function %_arr_v4float_uint_8_0 %int_0 = OpConstant %int 0 %f0 = OpConstant %float 0 %v4const = OpConstantComposite %v4float %f0 %f0 %f0 %f0 %_ptr_Uniform__arr_v4float_uint_8 = OpTypePointer Uniform %_arr_v4float_uint_8 %_ptr_Function_v4float = OpTypePointer Function %v4float %MyCBuffer = OpVariable %_ptr_Uniform_type_MyCBuffer Uniform %in_var_INDEX = OpVariable %_ptr_Input_int Input %out_var_SV_Target = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %13 %22 = OpLabel %23 = OpVariable %_ptr_Function__arr_v4float_uint_8_0 Function %24 = OpLoad %int %in_var_INDEX %25 = OpAccessChain %_ptr_Uniform__arr_v4float_uint_8 %MyCBuffer %int_0 %26 = OpLoad %_arr_v4float_uint_8 %25 %27 = OpCompositeExtract %v4float %26 0 %28 = OpCompositeExtract %v4float %26 0 %29 = OpCompositeExtract %v4float %26 2 %30 = OpCompositeExtract %v4float %26 3 %31 = OpCompositeExtract %v4float %26 4 %32 = OpCompositeExtract %v4float %26 5 %33 = OpCompositeExtract %v4float %26 6 %34 = OpCompositeExtract %v4float %26 7 %35 = OpCompositeConstruct %_arr_v4float_uint_8_0 %27 %28 %29 %30 %31 %32 %33 %34 OpStore %23 %35 %36 = OpAccessChain %_ptr_Function_v4float %23 %24 %37 = OpLoad %v4float %36 OpStore %out_var_SV_Target %37 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ false); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } TEST_F(CopyPropArrayPassTest, BadCopyViaInserts1) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_INDEX %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %type_MyCBuffer "type.MyCBuffer" OpMemberName %type_MyCBuffer 0 "Data" OpName %MyCBuffer "MyCBuffer" OpName %main "main" OpName %in_var_INDEX "in.var.INDEX" OpName %out_var_SV_Target "out.var.SV_Target" OpDecorate %_arr_v4float_uint_8 ArrayStride 16 OpMemberDecorate %type_MyCBuffer 0 Offset 0 OpDecorate %type_MyCBuffer Block OpDecorate %in_var_INDEX Flat OpDecorate %in_var_INDEX Location 0 OpDecorate %out_var_SV_Target Location 0 OpDecorate %MyCBuffer DescriptorSet 0 OpDecorate %MyCBuffer Binding 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_8 = OpConstant %uint 8 %_arr_v4float_uint_8 = OpTypeArray %v4float %uint_8 %type_MyCBuffer = OpTypeStruct %_arr_v4float_uint_8 %_ptr_Uniform_type_MyCBuffer = OpTypePointer Uniform %type_MyCBuffer %void = OpTypeVoid %13 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %_ptr_Output_v4float = OpTypePointer Output %v4float %_arr_v4float_uint_8_0 = OpTypeArray %v4float %uint_8 %_ptr_Function__arr_v4float_uint_8_0 = OpTypePointer Function %_arr_v4float_uint_8_0 %int_0 = OpConstant %int 0 %_ptr_Uniform__arr_v4float_uint_8 = OpTypePointer Uniform %_arr_v4float_uint_8 %_ptr_Function_v4float = OpTypePointer Function %v4float %MyCBuffer = OpVariable %_ptr_Uniform_type_MyCBuffer Uniform %in_var_INDEX = OpVariable %_ptr_Input_int Input %out_var_SV_Target = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %13 %22 = OpLabel %23 = OpVariable %_ptr_Function__arr_v4float_uint_8_0 Function %undef = OpUndef %_arr_v4float_uint_8_0 %24 = OpLoad %int %in_var_INDEX %25 = OpAccessChain %_ptr_Uniform__arr_v4float_uint_8 %MyCBuffer %int_0 %26 = OpLoad %_arr_v4float_uint_8 %25 %27 = OpCompositeExtract %v4float %26 0 %i0 = OpCompositeInsert %_arr_v4float_uint_8_0 %27 %undef 0 %28 = OpCompositeExtract %v4float %26 1 %i1 = OpCompositeInsert %_arr_v4float_uint_8_0 %28 %i0 1 %29 = OpCompositeExtract %v4float %26 2 %i2 = OpCompositeInsert %_arr_v4float_uint_8_0 %29 %i1 3 %30 = OpCompositeExtract %v4float %26 3 %i3 = OpCompositeInsert %_arr_v4float_uint_8_0 %30 %i2 3 %31 = OpCompositeExtract %v4float %26 4 %i4 = OpCompositeInsert %_arr_v4float_uint_8_0 %31 %i3 4 %32 = OpCompositeExtract %v4float %26 5 %i5 = OpCompositeInsert %_arr_v4float_uint_8_0 %32 %i4 5 %33 = OpCompositeExtract %v4float %26 6 %i6 = OpCompositeInsert %_arr_v4float_uint_8_0 %33 %i5 6 %34 = OpCompositeExtract %v4float %26 7 %i7 = OpCompositeInsert %_arr_v4float_uint_8_0 %34 %i6 7 OpStore %23 %i7 %36 = OpAccessChain %_ptr_Function_v4float %23 %24 %37 = OpLoad %v4float %36 OpStore %out_var_SV_Target %37 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ false); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } TEST_F(CopyPropArrayPassTest, BadCopyViaInserts2) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_INDEX %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %type_MyCBuffer "type.MyCBuffer" OpMemberName %type_MyCBuffer 0 "Data" OpName %MyCBuffer "MyCBuffer" OpName %main "main" OpName %in_var_INDEX "in.var.INDEX" OpName %out_var_SV_Target "out.var.SV_Target" OpDecorate %_arr_v4float_uint_8 ArrayStride 16 OpMemberDecorate %type_MyCBuffer 0 Offset 0 OpDecorate %type_MyCBuffer Block OpDecorate %in_var_INDEX Flat OpDecorate %in_var_INDEX Location 0 OpDecorate %out_var_SV_Target Location 0 OpDecorate %MyCBuffer DescriptorSet 0 OpDecorate %MyCBuffer Binding 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_8 = OpConstant %uint 8 %_arr_v4float_uint_8 = OpTypeArray %v4float %uint_8 %type_MyCBuffer = OpTypeStruct %_arr_v4float_uint_8 %_ptr_Uniform_type_MyCBuffer = OpTypePointer Uniform %type_MyCBuffer %void = OpTypeVoid %13 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %_ptr_Output_v4float = OpTypePointer Output %v4float %_arr_v4float_uint_8_0 = OpTypeArray %v4float %uint_8 %_ptr_Function__arr_v4float_uint_8_0 = OpTypePointer Function %_arr_v4float_uint_8_0 %int_0 = OpConstant %int 0 %_ptr_Uniform__arr_v4float_uint_8 = OpTypePointer Uniform %_arr_v4float_uint_8 %_ptr_Function_v4float = OpTypePointer Function %v4float %MyCBuffer = OpVariable %_ptr_Uniform_type_MyCBuffer Uniform %in_var_INDEX = OpVariable %_ptr_Input_int Input %out_var_SV_Target = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %13 %22 = OpLabel %23 = OpVariable %_ptr_Function__arr_v4float_uint_8_0 Function %undef = OpUndef %_arr_v4float_uint_8_0 %24 = OpLoad %int %in_var_INDEX %25 = OpAccessChain %_ptr_Uniform__arr_v4float_uint_8 %MyCBuffer %int_0 %26 = OpLoad %_arr_v4float_uint_8 %25 %27 = OpCompositeExtract %v4float %26 0 %i0 = OpCompositeInsert %_arr_v4float_uint_8_0 %27 %undef 0 %28 = OpCompositeExtract %v4float %26 1 %i1 = OpCompositeInsert %_arr_v4float_uint_8_0 %28 %i0 1 %29 = OpCompositeExtract %v4float %26 3 %i2 = OpCompositeInsert %_arr_v4float_uint_8_0 %29 %i1 2 %30 = OpCompositeExtract %v4float %26 3 %i3 = OpCompositeInsert %_arr_v4float_uint_8_0 %30 %i2 3 %31 = OpCompositeExtract %v4float %26 4 %i4 = OpCompositeInsert %_arr_v4float_uint_8_0 %31 %i3 4 %32 = OpCompositeExtract %v4float %26 5 %i5 = OpCompositeInsert %_arr_v4float_uint_8_0 %32 %i4 5 %33 = OpCompositeExtract %v4float %26 6 %i6 = OpCompositeInsert %_arr_v4float_uint_8_0 %33 %i5 6 %34 = OpCompositeExtract %v4float %26 7 %i7 = OpCompositeInsert %_arr_v4float_uint_8_0 %34 %i6 7 OpStore %23 %i7 %36 = OpAccessChain %_ptr_Function_v4float %23 %24 %37 = OpLoad %v4float %36 OpStore %out_var_SV_Target %37 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ false); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } TEST_F(CopyPropArrayPassTest, BadCopyViaInserts3) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_INDEX %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %type_MyCBuffer "type.MyCBuffer" OpMemberName %type_MyCBuffer 0 "Data" OpName %MyCBuffer "MyCBuffer" OpName %main "main" OpName %in_var_INDEX "in.var.INDEX" OpName %out_var_SV_Target "out.var.SV_Target" OpDecorate %_arr_v4float_uint_8 ArrayStride 16 OpMemberDecorate %type_MyCBuffer 0 Offset 0 OpDecorate %type_MyCBuffer Block OpDecorate %in_var_INDEX Flat OpDecorate %in_var_INDEX Location 0 OpDecorate %out_var_SV_Target Location 0 OpDecorate %MyCBuffer DescriptorSet 0 OpDecorate %MyCBuffer Binding 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_8 = OpConstant %uint 8 %_arr_v4float_uint_8 = OpTypeArray %v4float %uint_8 %type_MyCBuffer = OpTypeStruct %_arr_v4float_uint_8 %_ptr_Uniform_type_MyCBuffer = OpTypePointer Uniform %type_MyCBuffer %void = OpTypeVoid %13 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %_ptr_Output_v4float = OpTypePointer Output %v4float %_arr_v4float_uint_8_0 = OpTypeArray %v4float %uint_8 %_ptr_Function__arr_v4float_uint_8_0 = OpTypePointer Function %_arr_v4float_uint_8_0 %int_0 = OpConstant %int 0 %_ptr_Uniform__arr_v4float_uint_8 = OpTypePointer Uniform %_arr_v4float_uint_8 %_ptr_Function_v4float = OpTypePointer Function %v4float %MyCBuffer = OpVariable %_ptr_Uniform_type_MyCBuffer Uniform %in_var_INDEX = OpVariable %_ptr_Input_int Input %out_var_SV_Target = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %13 %22 = OpLabel %23 = OpVariable %_ptr_Function__arr_v4float_uint_8_0 Function %undef = OpUndef %_arr_v4float_uint_8_0 %24 = OpLoad %int %in_var_INDEX %25 = OpAccessChain %_ptr_Uniform__arr_v4float_uint_8 %MyCBuffer %int_0 %26 = OpLoad %_arr_v4float_uint_8 %25 %28 = OpCompositeExtract %v4float %26 1 %i1 = OpCompositeInsert %_arr_v4float_uint_8_0 %28 %undef 1 %29 = OpCompositeExtract %v4float %26 2 %i2 = OpCompositeInsert %_arr_v4float_uint_8_0 %29 %i1 2 %30 = OpCompositeExtract %v4float %26 3 %i3 = OpCompositeInsert %_arr_v4float_uint_8_0 %30 %i2 3 %31 = OpCompositeExtract %v4float %26 4 %i4 = OpCompositeInsert %_arr_v4float_uint_8_0 %31 %i3 4 %32 = OpCompositeExtract %v4float %26 5 %i5 = OpCompositeInsert %_arr_v4float_uint_8_0 %32 %i4 5 %33 = OpCompositeExtract %v4float %26 6 %i6 = OpCompositeInsert %_arr_v4float_uint_8_0 %33 %i5 6 %34 = OpCompositeExtract %v4float %26 7 %i7 = OpCompositeInsert %_arr_v4float_uint_8_0 %34 %i6 7 OpStore %23 %i7 %36 = OpAccessChain %_ptr_Function_v4float %23 %24 %37 = OpLoad %v4float %36 OpStore %out_var_SV_Target %37 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ false); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } TEST_F(CopyPropArrayPassTest, AtomicAdd) { const std::string before = R"(OpCapability SampledBuffer OpCapability StorageImageExtendedFormats OpCapability ImageBuffer OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "min" %gl_GlobalInvocationID OpExecutionMode %2 LocalSize 64 1 1 OpSource HLSL 600 OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId OpDecorate %4 DescriptorSet 4 OpDecorate %4 Binding 70 %uint = OpTypeInt 32 0 %6 = OpTypeImage %uint Buffer 0 0 0 2 R32ui %_ptr_UniformConstant_6 = OpTypePointer UniformConstant %6 %_ptr_Function_6 = OpTypePointer Function %6 %void = OpTypeVoid %10 = OpTypeFunction %void %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %_ptr_Image_uint = OpTypePointer Image %uint %4 = OpVariable %_ptr_UniformConstant_6 UniformConstant %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %2 = OpFunction %void None %10 %17 = OpLabel %16 = OpVariable %_ptr_Function_6 Function %18 = OpLoad %6 %4 OpStore %16 %18 %19 = OpImageTexelPointer %_ptr_Image_uint %16 %uint_0 %uint_0 %20 = OpAtomicIAdd %uint %19 %uint_1 %uint_0 %uint_1 OpReturn OpFunctionEnd )"; const std::string after = R"(OpCapability SampledBuffer OpCapability StorageImageExtendedFormats OpCapability ImageBuffer OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "min" %gl_GlobalInvocationID OpExecutionMode %2 LocalSize 64 1 1 OpSource HLSL 600 OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId OpDecorate %4 DescriptorSet 4 OpDecorate %4 Binding 70 %uint = OpTypeInt 32 0 %6 = OpTypeImage %uint Buffer 0 0 0 2 R32ui %_ptr_UniformConstant_6 = OpTypePointer UniformConstant %6 %_ptr_Function_6 = OpTypePointer Function %6 %void = OpTypeVoid %10 = OpTypeFunction %void %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %_ptr_Image_uint = OpTypePointer Image %uint %4 = OpVariable %_ptr_UniformConstant_6 UniformConstant %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %2 = OpFunction %void None %10 %17 = OpLabel %16 = OpVariable %_ptr_Function_6 Function %18 = OpLoad %6 %4 OpStore %16 %18 %19 = OpImageTexelPointer %_ptr_Image_uint %4 %uint_0 %uint_0 %20 = OpAtomicIAdd %uint %19 %uint_1 %uint_0 %uint_1 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(before, after, true, true); } TEST_F(CopyPropArrayPassTest, IndexIsNullConstnat) { const std::string text = R"( ; CHECK: [[var:%\w+]] = OpVariable {{%\w+}} Uniform ; CHECK: [[null:%\w+]] = OpConstantNull %uint ; CHECK: [[ac1:%\w+]] = OpAccessChain %_ptr_Uniform__arr_uint_uint_1 [[var]] %uint_0 %uint_0 ; CHECK: OpAccessChain %_ptr_Uniform_uint [[ac1]] [[null]] ; CHECK-NEXT: OpReturn OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpDecorate %myCBuffer DescriptorSet 0 OpDecorate %myCBuffer Binding 0 OpDecorate %_arr_v4float_uint_1 ArrayStride 16 OpMemberDecorate %MyConstantBuffer 0 Offset 0 OpMemberDecorate %type_myCBuffer 0 Offset 0 OpDecorate %type_myCBuffer Block %uint = OpTypeInt 32 0 %int_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %_arr_v4float_uint_1 = OpTypeArray %uint %uint_1 %MyConstantBuffer = OpTypeStruct %_arr_v4float_uint_1 %type_myCBuffer = OpTypeStruct %MyConstantBuffer %_ptr_Uniform_type_myCBuffer = OpTypePointer Uniform %type_myCBuffer %_arr_v4float_uint_1_0 = OpTypeArray %uint %uint_1 %void = OpTypeVoid %19 = OpTypeFunction %void %_ptr_Function_v4float = OpTypePointer Function %uint %_ptr_Uniform_MyConstantBuffer = OpTypePointer Uniform %MyConstantBuffer %myCBuffer = OpVariable %_ptr_Uniform_type_myCBuffer Uniform %_ptr_Function__arr_v4float_uint_1_0 = OpTypePointer Function %_arr_v4float_uint_1_0 %23 = OpConstantNull %uint %main = OpFunction %void None %19 %24 = OpLabel %25 = OpVariable %_ptr_Function__arr_v4float_uint_1_0 Function %26 = OpAccessChain %_ptr_Uniform_MyConstantBuffer %myCBuffer %int_0 %27 = OpLoad %MyConstantBuffer %26 %28 = OpCompositeExtract %_arr_v4float_uint_1 %27 0 %29 = OpCompositeExtract %uint %28 0 %30 = OpCompositeConstruct %_arr_v4float_uint_1_0 %29 OpStore %25 %30 %31 = OpAccessChain %_ptr_Function_v4float %25 %23 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(text, true); } TEST_F(CopyPropArrayPassTest, DebugDeclare) { const std::string before = R"(OpCapability Shader %ext = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_INDEX %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 %file_name = OpString "test" %float_name = OpString "float" %main_name = OpString "main" %f_name = OpString "f" OpName %type_MyCBuffer "type.MyCBuffer" OpMemberName %type_MyCBuffer 0 "Data" OpName %MyCBuffer "MyCBuffer" OpName %main "main" OpName %in_var_INDEX "in.var.INDEX" OpName %out_var_SV_Target "out.var.SV_Target" OpDecorate %_arr_v4float_uint_8 ArrayStride 16 OpMemberDecorate %type_MyCBuffer 0 Offset 0 OpDecorate %type_MyCBuffer Block OpDecorate %in_var_INDEX Flat OpDecorate %in_var_INDEX Location 0 OpDecorate %out_var_SV_Target Location 0 OpDecorate %MyCBuffer DescriptorSet 0 OpDecorate %MyCBuffer Binding 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_8 = OpConstant %uint 8 %uint_32 = OpConstant %uint 32 %_arr_v4float_uint_8 = OpTypeArray %v4float %uint_8 %type_MyCBuffer = OpTypeStruct %_arr_v4float_uint_8 %_ptr_Uniform_type_MyCBuffer = OpTypePointer Uniform %type_MyCBuffer %void = OpTypeVoid %13 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %_ptr_Output_v4float = OpTypePointer Output %v4float %_arr_v4float_uint_8_0 = OpTypeArray %v4float %uint_8 %_ptr_Function__arr_v4float_uint_8_0 = OpTypePointer Function %_arr_v4float_uint_8_0 %int_0 = OpConstant %int 0 %_ptr_Uniform__arr_v4float_uint_8 = OpTypePointer Uniform %_arr_v4float_uint_8 %_ptr_Function_v4float = OpTypePointer Function %v4float %MyCBuffer = OpVariable %_ptr_Uniform_type_MyCBuffer Uniform %in_var_INDEX = OpVariable %_ptr_Input_int Input %out_var_SV_Target = OpVariable %_ptr_Output_v4float Output %null_expr = OpExtInst %void %ext DebugExpression %src = OpExtInst %void %ext DebugSource %file_name %cu = OpExtInst %void %ext DebugCompilationUnit 1 4 %src HLSL %dbg_tf = OpExtInst %void %ext DebugTypeBasic %float_name %uint_32 Float %main_ty = OpExtInst %void %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %dbg_tf %dbg_main = OpExtInst %void %ext DebugFunction %main_name %main_ty %src 0 0 %cu %main_name FlagIsProtected|FlagIsPrivate 10 %main ; CHECK: [[deref:%\w+]] = OpExtInst %void [[ext:%\w+]] DebugOperation Deref ; CHECK: [[dbg_f:%\w+]] = OpExtInst %void [[ext]] DebugLocalVariable %dbg_f = OpExtInst %void %ext DebugLocalVariable %f_name %dbg_tf %src 0 0 %dbg_main FlagIsLocal ; CHECK: [[deref_expr:%\w+]] = OpExtInst %void [[ext]] DebugExpression [[deref]] ; CHECK: OpAccessChain ; CHECK: [[newptr:%\w+]] = OpAccessChain %_ptr_Uniform__arr_v4float_uint_8 %MyCBuffer %int_0 ; CHECK: OpExtInst %void [[ext]] DebugValue [[dbg_f]] [[newptr]] [[deref_expr]] ; CHECK: [[element_ptr:%\w+]] = OpAccessChain %_ptr_Uniform_v4float [[newptr]] %24 ; CHECK: [[load:%\w+]] = OpLoad %v4float [[element_ptr]] ; CHECK: OpStore %out_var_SV_Target [[load]] %main = OpFunction %void None %13 %22 = OpLabel %23 = OpVariable %_ptr_Function__arr_v4float_uint_8_0 Function %24 = OpLoad %int %in_var_INDEX %25 = OpAccessChain %_ptr_Uniform__arr_v4float_uint_8 %MyCBuffer %int_0 %26 = OpLoad %_arr_v4float_uint_8 %25 %27 = OpCompositeExtract %v4float %26 0 %28 = OpCompositeExtract %v4float %26 1 %29 = OpCompositeExtract %v4float %26 2 %30 = OpCompositeExtract %v4float %26 3 %31 = OpCompositeExtract %v4float %26 4 %32 = OpCompositeExtract %v4float %26 5 %33 = OpCompositeExtract %v4float %26 6 %34 = OpCompositeExtract %v4float %26 7 %35 = OpCompositeConstruct %_arr_v4float_uint_8_0 %27 %28 %29 %30 %31 %32 %33 %34 OpStore %23 %35 %decl = OpExtInst %void %ext DebugDeclare %dbg_f %23 %null_expr %36 = OpAccessChain %_ptr_Function_v4float %23 %24 %37 = OpLoad %v4float %36 OpStore %out_var_SV_Target %37 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); SinglePassRunAndMatch(before, false); } TEST_F(CopyPropArrayPassTest, DebugValue) { const std::string before = R"(OpCapability Shader %ext = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_INDEX %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 %file_name = OpString "test" %float_name = OpString "float" %main_name = OpString "main" %f_name = OpString "f" OpName %type_MyCBuffer "type.MyCBuffer" OpMemberName %type_MyCBuffer 0 "Data" OpName %MyCBuffer "MyCBuffer" OpName %main "main" OpName %in_var_INDEX "in.var.INDEX" OpName %out_var_SV_Target "out.var.SV_Target" OpDecorate %_arr_v4float_uint_8 ArrayStride 16 OpMemberDecorate %type_MyCBuffer 0 Offset 0 OpDecorate %type_MyCBuffer Block OpDecorate %in_var_INDEX Flat OpDecorate %in_var_INDEX Location 0 OpDecorate %out_var_SV_Target Location 0 OpDecorate %MyCBuffer DescriptorSet 0 OpDecorate %MyCBuffer Binding 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_8 = OpConstant %uint 8 %uint_32 = OpConstant %uint 32 %_arr_v4float_uint_8 = OpTypeArray %v4float %uint_8 %type_MyCBuffer = OpTypeStruct %_arr_v4float_uint_8 %_ptr_Uniform_type_MyCBuffer = OpTypePointer Uniform %type_MyCBuffer %void = OpTypeVoid %13 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %_ptr_Output_v4float = OpTypePointer Output %v4float %_arr_v4float_uint_8_0 = OpTypeArray %v4float %uint_8 %_ptr_Function__arr_v4float_uint_8_0 = OpTypePointer Function %_arr_v4float_uint_8_0 %int_0 = OpConstant %int 0 %_ptr_Uniform__arr_v4float_uint_8 = OpTypePointer Uniform %_arr_v4float_uint_8 %_ptr_Function_v4float = OpTypePointer Function %v4float %MyCBuffer = OpVariable %_ptr_Uniform_type_MyCBuffer Uniform %in_var_INDEX = OpVariable %_ptr_Input_int Input %out_var_SV_Target = OpVariable %_ptr_Output_v4float Output ; CHECK: [[deref:%\w+]] = OpExtInst %void [[ext:%\w+]] DebugOperation Deref ; CHECK: [[deref_expr:%\w+]] = OpExtInst %void [[ext]] DebugExpression [[deref]] %deref = OpExtInst %void %ext DebugOperation Deref %expr = OpExtInst %void %ext DebugExpression %deref %src = OpExtInst %void %ext DebugSource %file_name %cu = OpExtInst %void %ext DebugCompilationUnit 1 4 %src HLSL %dbg_tf = OpExtInst %void %ext DebugTypeBasic %float_name %uint_32 Float %main_ty = OpExtInst %void %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %dbg_tf %dbg_main = OpExtInst %void %ext DebugFunction %main_name %main_ty %src 0 0 %cu %main_name FlagIsProtected|FlagIsPrivate 10 %main ; CHECK: [[dbg_f:%\w+]] = OpExtInst %void [[ext]] DebugLocalVariable %dbg_f = OpExtInst %void %ext DebugLocalVariable %f_name %dbg_tf %src 0 0 %dbg_main FlagIsLocal %main = OpFunction %void None %13 %22 = OpLabel %23 = OpVariable %_ptr_Function__arr_v4float_uint_8_0 Function %24 = OpLoad %int %in_var_INDEX %25 = OpAccessChain %_ptr_Uniform__arr_v4float_uint_8 %MyCBuffer %int_0 %26 = OpLoad %_arr_v4float_uint_8 %25 %27 = OpCompositeExtract %v4float %26 0 %28 = OpCompositeExtract %v4float %26 1 %29 = OpCompositeExtract %v4float %26 2 %30 = OpCompositeExtract %v4float %26 3 %31 = OpCompositeExtract %v4float %26 4 %32 = OpCompositeExtract %v4float %26 5 %33 = OpCompositeExtract %v4float %26 6 %34 = OpCompositeExtract %v4float %26 7 %35 = OpCompositeConstruct %_arr_v4float_uint_8_0 %27 %28 %29 %30 %31 %32 %33 %34 OpStore %23 %35 ; CHECK: OpAccessChain ; CHECK: [[newptr:%\w+]] = OpAccessChain %_ptr_Uniform__arr_v4float_uint_8 %MyCBuffer %int_0 ; CHECK: OpExtInst %void [[ext]] DebugValue [[dbg_f]] [[newptr]] [[deref_expr]] ; CHECK: [[element_ptr:%\w+]] = OpAccessChain %_ptr_Uniform_v4float [[newptr]] %24 ; CHECK: [[load:%\w+]] = OpLoad %v4float [[element_ptr]] ; CHECK: OpStore %out_var_SV_Target [[load]] %decl = OpExtInst %void %ext DebugValue %dbg_f %23 %expr %36 = OpAccessChain %_ptr_Function_v4float %23 %24 %37 = OpLoad %v4float %36 OpStore %out_var_SV_Target %37 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); SinglePassRunAndMatch(before, false); } TEST_F(CopyPropArrayPassTest, FunctionDeclaration) { // Make sure the pass works with a function declaration that is called. const std::string text = R"(OpCapability Addresses OpCapability Linkage OpCapability Kernel OpCapability Int8 %1 = OpExtInstImport "OpenCL.std" OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %2 "_Z23julia__1166_kernel_77094Bool" OpExecutionMode %2 ContractionOff OpSource Unknown 0 OpDecorate %3 LinkageAttributes "julia_error_7712" Import %void = OpTypeVoid %5 = OpTypeFunction %void %3 = OpFunction %void None %5 OpFunctionEnd %2 = OpFunction %void None %5 %6 = OpLabel %7 = OpFunctionCall %void %3 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(text, text, false); } // Since Spir-V 1.4, resources that are used by a shader must be on the // OpEntryPoint instruction with the inputs and outputs. This test ensures that // this does not stop the pass from working. TEST_F(CopyPropArrayPassTest, EntryPointUser) { const std::string before = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %g_rwTexture3d OpExecutionMode %main LocalSize 256 1 1 OpSource HLSL 660 OpName %type_3d_image "type.3d.image" OpName %g_rwTexture3d "g_rwTexture3d" OpName %main "main" OpDecorate %g_rwTexture3d DescriptorSet 0 OpDecorate %g_rwTexture3d Binding 0 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %uint_3 = OpConstant %uint 3 %v3uint = OpTypeVector %uint 3 %10 = OpConstantComposite %v3uint %uint_1 %uint_2 %uint_3 %type_3d_image = OpTypeImage %uint 3D 2 0 0 2 R32ui %_ptr_UniformConstant_type_3d_image = OpTypePointer UniformConstant %type_3d_image %void = OpTypeVoid %13 = OpTypeFunction %void %_ptr_Function_type_3d_image = OpTypePointer Function %type_3d_image %_ptr_Image_uint = OpTypePointer Image %uint %g_rwTexture3d = OpVariable %_ptr_UniformConstant_type_3d_image UniformConstant %main = OpFunction %void None %13 %16 = OpLabel %17 = OpVariable %_ptr_Function_type_3d_image Function %18 = OpLoad %type_3d_image %g_rwTexture3d OpStore %17 %18 ; CHECK: %19 = OpImageTexelPointer %_ptr_Image_uint %g_rwTexture3d %10 %uint_0 %19 = OpImageTexelPointer %_ptr_Image_uint %17 %10 %uint_0 %20 = OpAtomicIAdd %uint %19 %uint_1 %uint_0 %uint_1 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetTargetEnv(SPV_ENV_UNIVERSAL_1_4); SinglePassRunAndMatch(before, false); } // As per SPIRV spec, struct cannot be indexed with non-constant indices // through OpAccessChain, only arrays. // The copy-propagate-array pass tries to remove superfluous copies when the // original array could be indexed instead of the copy. // // This test verifies we handle this case: // struct SRC { int field1; ...; int fieldN } // int tmp_arr[N] = { SRC.field1, ..., SRC.fieldN } // return tmp_arr[index]; // // In such case, we cannot optimize the access: this array was added to allow // dynamic indexing in the struct. TEST_F(CopyPropArrayPassTest, StructIndexCannotBecomeDynamic) { const std::string text = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "main" OpDecorate %2 DescriptorSet 0 OpDecorate %2 Binding 0 OpMemberDecorate %_struct_3 0 Offset 0 OpDecorate %_struct_3 Block %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_struct_3 = OpTypeStruct %v4float %_ptr_Uniform__struct_3 = OpTypePointer Uniform %_struct_3 %uint = OpTypeInt 32 0 %void = OpTypeVoid %11 = OpTypeFunction %void %_ptr_Function_uint = OpTypePointer Function %uint %13 = OpTypeFunction %v4float %_ptr_Function_uint %uint_1 = OpConstant %uint 1 %_arr_v4float_uint_1 = OpTypeArray %v4float %uint_1 %_ptr_Function__arr_v4float_uint_1 = OpTypePointer Function %_arr_v4float_uint_1 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %2 = OpVariable %_ptr_Uniform__struct_3 Uniform %19 = OpUndef %v4float %1 = OpFunction %void None %11 %20 = OpLabel OpReturn OpFunctionEnd %21 = OpFunction %v4float None %13 %22 = OpFunctionParameter %_ptr_Function_uint %23 = OpLabel %24 = OpVariable %_ptr_Function__arr_v4float_uint_1 Function %25 = OpAccessChain %_ptr_Uniform_v4float %2 %int_0 %26 = OpLoad %v4float %25 %27 = OpCompositeConstruct %_arr_v4float_uint_1 %26 OpStore %24 %27 %28 = OpLoad %uint %22 %29 = OpAccessChain %_ptr_Function_v4float %24 %28 OpReturnValue %19 OpFunctionEnd )"; SinglePassRunAndCheck(text, text, false); } // If the size of an array used in an OpCompositeInsert is not known at compile // time, then we should not propagate the array, because we do not have a single // array that represents the final value. TEST_F(CopyPropArrayPassTest, SpecConstSizedArray) { const std::string text = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft %void = OpTypeVoid %4 = OpTypeFunction %void %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %7 = OpSpecConstant %uint 32 %_arr_int_7 = OpTypeArray %int %7 %int_63 = OpConstant %int 63 %uint_0 = OpConstant %uint 0 %bool = OpTypeBool %int_0 = OpConstant %int 0 %int_587202566 = OpConstant %int 587202566 %false = OpConstantFalse %bool %_ptr_Function__arr_int_7 = OpTypePointer Function %_arr_int_7 %16 = OpUndef %_arr_int_7 %2 = OpFunction %void None %4 %17 = OpLabel %18 = OpVariable %_ptr_Function__arr_int_7 Function %19 = OpCompositeInsert %_arr_int_7 %int_0 %16 0 OpStore %18 %19 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(text, text, false); } TEST_F(CopyPropArrayPassTest, InterpolateFunctions) { const std::string before = R"(OpCapability InterpolationFunction OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_COLOR OpExecutionMode %main OriginUpperLeft OpSource HLSL 680 OpName %in_var_COLOR "in.var.COLOR" OpName %main "main" OpName %offset "offset" OpDecorate %in_var_COLOR Location 0 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %v2float = OpTypeVector %float 2 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %void = OpTypeVoid %19 = OpTypeFunction %void %_ptr_Function_v4float = OpTypePointer Function %v4float %in_var_COLOR = OpVariable %_ptr_Input_v4float Input %main = OpFunction %void None %19 %20 = OpLabel %45 = OpVariable %_ptr_Function_v4float Function %25 = OpLoad %v4float %in_var_COLOR OpStore %45 %25 ; CHECK: OpExtInst %v4float %1 InterpolateAtCentroid %in_var_COLOR %52 = OpExtInst %v4float %1 InterpolateAtCentroid %45 ; CHECK: OpExtInst %v4float %1 InterpolateAtSample %in_var_COLOR %int_0 %54 = OpExtInst %v4float %1 InterpolateAtSample %45 %int_0 %offset = OpCompositeConstruct %v2float %float_0 %float_0 ; CHECK: OpExtInst %v4float %1 InterpolateAtOffset %in_var_COLOR %offset %56 = OpExtInst %v4float %1 InterpolateAtOffset %45 %offset OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); SinglePassRunAndMatch(before, false); } TEST_F(CopyPropArrayPassTest, InterpolateMultiPropagation) { const std::string before = R"(OpCapability InterpolationFunction OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_COLOR OpExecutionMode %main OriginUpperLeft OpSource HLSL 680 OpName %in_var_COLOR "in.var.COLOR" OpName %main "main" OpName %param_var_color "param.var.color" OpDecorate %in_var_COLOR Location 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %void = OpTypeVoid %19 = OpTypeFunction %void %_ptr_Function_v4float = OpTypePointer Function %v4float %in_var_COLOR = OpVariable %_ptr_Input_v4float Input %main = OpFunction %void None %19 %20 = OpLabel %45 = OpVariable %_ptr_Function_v4float Function %param_var_color = OpVariable %_ptr_Function_v4float Function %25 = OpLoad %v4float %in_var_COLOR OpStore %param_var_color %25 ; CHECK: OpExtInst %v4float %1 InterpolateAtCentroid %in_var_COLOR %52 = OpExtInst %v4float %1 InterpolateAtCentroid %param_var_color %49 = OpLoad %v4float %param_var_color OpStore %45 %49 ; CHECK: OpExtInst %v4float %1 InterpolateAtCentroid %in_var_COLOR %54 = OpExtInst %v4float %1 InterpolateAtCentroid %45 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); SinglePassRunAndMatch(before, false); } TEST_F(CopyPropArrayPassTest, PropagateScalar) { const std::string before = R"(OpCapability InterpolationFunction OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_SV_InstanceID OpExecutionMode %main OriginUpperLeft OpSource HLSL 680 OpName %in_var_SV_InstanceID "in.var.SV_InstanceID" OpName %main "main" OpDecorate %in_var_SV_InstanceID Location 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_float = OpTypePointer Input %float %void = OpTypeVoid %19 = OpTypeFunction %void %_ptr_Function_float = OpTypePointer Function %float %in_var_SV_InstanceID = OpVariable %_ptr_Input_float Input %main = OpFunction %void None %19 %20 = OpLabel %45 = OpVariable %_ptr_Function_float Function %25 = OpLoad %v4float %in_var_SV_InstanceID OpStore %45 %25 ; CHECK: OpExtInst %v4float %1 InterpolateAtCentroid %in_var_SV_InstanceID %52 = OpExtInst %v4float %1 InterpolateAtCentroid %45 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); SinglePassRunAndMatch(before, false); } TEST_F(CopyPropArrayPassTest, StoreToAccessChain) { const std::string before = R"(OpCapability InterpolationFunction OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %1 "main" %2 %3 OpExecutionMode %1 LocalSize 128 1 1 OpExecutionMode %1 OutputTrianglesEXT OpExecutionMode %1 OutputVertices 64 OpExecutionMode %1 OutputPrimitivesEXT 126 OpDecorate %3 Flat OpDecorate %3 Location 2 %uint = OpTypeInt 32 0 %uint_4 = OpConstant %uint 4 %uint_32 = OpConstant %uint 32 %_arr_uint_uint_32 = OpTypeArray %uint %uint_32 %_struct_8 = OpTypeStruct %_arr_uint_uint_32 %_ptr_TaskPayloadWorkgroupEXT__struct_8 = OpTypePointer TaskPayloadWorkgroupEXT %_struct_8 %uint_64 = OpConstant %uint 64 %_arr_uint_uint_64 = OpTypeArray %uint %uint_64 %_ptr_Output__arr_uint_uint_64 = OpTypePointer Output %_arr_uint_uint_64 %void = OpTypeVoid %14 = OpTypeFunction %void %_ptr_Function_uint = OpTypePointer Function %uint %_ptr_Function__arr_uint_uint_32 = OpTypePointer Function %_arr_uint_uint_32 %_ptr_Output_uint = OpTypePointer Output %uint %2 = OpVariable %_ptr_TaskPayloadWorkgroupEXT__struct_8 TaskPayloadWorkgroupEXT %3 = OpVariable %_ptr_Output__arr_uint_uint_64 Output %1 = OpFunction %void None %14 %18 = OpLabel %19 = OpVariable %_ptr_Function__arr_uint_uint_32 Function %20 = OpLoad %_struct_8 %2 %21 = OpCompositeExtract %_arr_uint_uint_32 %20 0 ; CHECK: %28 = OpAccessChain %_ptr_TaskPayloadWorkgroupEXT__arr_uint_uint_32 %2 %uint_0 OpStore %19 %21 ; CHECK: %22 = OpAccessChain %_ptr_TaskPayloadWorkgroupEXT_uint %28 %uint_4 %22 = OpAccessChain %_ptr_Function_uint %19 %uint_4 %23 = OpLoad %uint %22 %24 = OpAccessChain %_ptr_Output_uint %3 %uint_4 OpStore %24 %23 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_UNIVERSAL_1_4); SinglePassRunAndMatch(before, true); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/dataflow.cpp000066400000000000000000000156541475742701700226320ustar00rootroot00000000000000// Copyright (c) 2021 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/dataflow.h" #include #include #include "gtest/gtest.h" #include "opt/function_utils.h" #include "source/opt/build_module.h" namespace spvtools { namespace opt { namespace { using DataFlowTest = ::testing::Test; // Simple analyses for testing: // Stores the result IDs of visited instructions in visit order. struct VisitOrder : public ForwardDataFlowAnalysis { std::vector visited_result_ids; VisitOrder(IRContext& context, LabelPosition label_position) : ForwardDataFlowAnalysis(context, label_position) {} VisitResult Visit(Instruction* inst) override { if (inst->HasResultId()) { visited_result_ids.push_back(inst->result_id()); } return DataFlowAnalysis::VisitResult::kResultFixed; } }; // For each block, stores the set of blocks it can be preceded by. // For example, with the following CFG: // V-----------. // -> 11 -> 12 -> 13 -> 15 // \-> 14 ---^ // // The answer is: // 11: 11, 12, 13 // 12: 11, 12, 13 // 13: 11, 12, 13 // 14: 11, 12, 13 // 15: 11, 12, 13, 14 struct BackwardReachability : public ForwardDataFlowAnalysis { std::map> reachable_from; BackwardReachability(IRContext& context) : ForwardDataFlowAnalysis( context, ForwardDataFlowAnalysis::LabelPosition::kLabelsOnly) {} VisitResult Visit(Instruction* inst) override { // Conditional branches can be enqueued from labels, so skip them. if (inst->opcode() != spv::Op::OpLabel) return DataFlowAnalysis::VisitResult::kResultFixed; uint32_t id = inst->result_id(); VisitResult ret = DataFlowAnalysis::VisitResult::kResultFixed; std::set& precedents = reachable_from[id]; for (uint32_t pred : context().cfg()->preds(id)) { bool pred_inserted = precedents.insert(pred).second; if (pred_inserted) { ret = DataFlowAnalysis::VisitResult::kResultChanged; } for (uint32_t block : reachable_from[pred]) { bool inserted = precedents.insert(block).second; if (inserted) { ret = DataFlowAnalysis::VisitResult::kResultChanged; } } } return ret; } void InitializeWorklist(Function* function, bool is_first_iteration) override { // Since successor function is exact, only need one pass. if (is_first_iteration) { ForwardDataFlowAnalysis::InitializeWorklist(function, true); } } }; TEST_F(DataFlowTest, ReversePostOrder) { // Note: labels and IDs are intentionally out of order. // // CFG: (order of branches is from bottom to top) // V-----------. // -> 50 -> 40 -> 20 -> 60 -> 70 // \-> 30 ---^ // DFS tree with RPO numbering: // -> 50[0] -> 40[1] -> 20[2] 60[4] -> 70[5] // \-> 30[3] ---^ const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 %6 = OpTypeBool %5 = OpConstantTrue %6 %2 = OpFunction %3 None %4 %50 = OpLabel %51 = OpUndef %6 %52 = OpUndef %6 OpBranch %40 %70 = OpLabel %69 = OpUndef %6 OpReturn %60 = OpLabel %61 = OpUndef %6 OpBranchConditional %5 %70 %40 %30 = OpLabel %29 = OpUndef %6 OpBranch %60 %20 = OpLabel %21 = OpUndef %6 OpBranch %60 %40 = OpLabel %39 = OpUndef %6 OpBranchConditional %5 %30 %20 OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); ASSERT_NE(context, nullptr); Function* function = spvtest::GetFunction(context->module(), 2); std::map> expected_order; expected_order[ForwardDataFlowAnalysis::LabelPosition::kLabelsOnly] = { 50, 40, 20, 30, 60, 70, }; expected_order[ForwardDataFlowAnalysis::LabelPosition::kLabelsAtBeginning] = { 50, 51, 52, 40, 39, 20, 21, 30, 29, 60, 61, 70, 69, }; expected_order[ForwardDataFlowAnalysis::LabelPosition::kLabelsAtEnd] = { 51, 52, 50, 39, 40, 21, 20, 29, 30, 61, 60, 69, 70, }; expected_order[ForwardDataFlowAnalysis::LabelPosition::kNoLabels] = { 51, 52, 39, 21, 29, 61, 69, }; for (const auto& test_case : expected_order) { VisitOrder analysis(*context, test_case.first); analysis.Run(function); EXPECT_EQ(test_case.second, analysis.visited_result_ids); } } TEST_F(DataFlowTest, BackwardReachability) { // CFG: // V-----------. // -> 11 -> 12 -> 13 -> 15 // \-> 14 ---^ const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 %6 = OpTypeBool %5 = OpConstantTrue %6 %2 = OpFunction %3 None %4 %11 = OpLabel OpBranch %12 %12 = OpLabel OpBranchConditional %5 %14 %13 %13 = OpLabel OpBranchConditional %5 %15 %11 %14 = OpLabel OpBranch %15 %15 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); ASSERT_NE(context, nullptr); Function* function = spvtest::GetFunction(context->module(), 2); BackwardReachability analysis(*context); analysis.Run(function); std::map> expected_result; expected_result[11] = {11, 12, 13}; expected_result[12] = {11, 12, 13}; expected_result[13] = {11, 12, 13}; expected_result[14] = {11, 12, 13}; expected_result[15] = {11, 12, 13, 14}; EXPECT_EQ(expected_result, analysis.reachable_from); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/dead_branch_elim_test.cpp000066400000000000000000002621061475742701700253040ustar00rootroot00000000000000// Copyright (c) 2017 Valve Corporation // Copyright (c) 2017 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using DeadBranchElimTest = PassTest<::testing::Test>; TEST_F(DeadBranchElimTest, IfThenElseTrue) { // #version 140 // // in vec4 BaseColor; // // void main() // { // vec4 v; // if (true) // v = vec4(0.0,0.0,0.0,0.0); // else // v = vec4(1.0,1.0,1.0,1.0); // gl_FragColor = v; // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragColor %BaseColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %v "v" OpName %gl_FragColor "gl_FragColor" OpName %BaseColor "BaseColor" %void = OpTypeVoid %7 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %float_0 = OpConstant %float 0 %14 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %float_1 = OpConstant %float 1 %16 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input )"; const std::string before = R"(%main = OpFunction %void None %7 %19 = OpLabel %v = OpVariable %_ptr_Function_v4float Function OpSelectionMerge %20 None OpBranchConditional %true %21 %22 %21 = OpLabel OpStore %v %14 OpBranch %20 %22 = OpLabel OpStore %v %16 OpBranch %20 %20 = OpLabel %23 = OpLoad %v4float %v OpStore %gl_FragColor %23 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %7 %19 = OpLabel %v = OpVariable %_ptr_Function_v4float Function OpBranch %21 %21 = OpLabel OpStore %v %14 OpBranch %20 %20 = OpLabel %23 = OpLoad %v4float %v OpStore %gl_FragColor %23 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before, predefs + after, true, true); } TEST_F(DeadBranchElimTest, IfThenElseFalse) { // #version 140 // // in vec4 BaseColor; // // void main() // { // vec4 v; // if (false) // v = vec4(0.0,0.0,0.0,0.0); // else // v = vec4(1.0,1.0,1.0,1.0); // gl_FragColor = v; // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragColor %BaseColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %v "v" OpName %gl_FragColor "gl_FragColor" OpName %BaseColor "BaseColor" %void = OpTypeVoid %7 = OpTypeFunction %void %bool = OpTypeBool %false = OpConstantFalse %bool %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %float_0 = OpConstant %float 0 %14 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %float_1 = OpConstant %float 1 %16 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input )"; const std::string before = R"(%main = OpFunction %void None %7 %19 = OpLabel %v = OpVariable %_ptr_Function_v4float Function OpSelectionMerge %20 None OpBranchConditional %false %21 %22 %21 = OpLabel OpStore %v %14 OpBranch %20 %22 = OpLabel OpStore %v %16 OpBranch %20 %20 = OpLabel %23 = OpLoad %v4float %v OpStore %gl_FragColor %23 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %7 %19 = OpLabel %v = OpVariable %_ptr_Function_v4float Function OpBranch %22 %22 = OpLabel OpStore %v %16 OpBranch %20 %20 = OpLabel %23 = OpLoad %v4float %v OpStore %gl_FragColor %23 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before, predefs + after, true, true); } TEST_F(DeadBranchElimTest, IfThenElseNull) { // For booleans OpConstantNull should be treated similar to OpConstantFalse. // // From the SPIR-V spec: // OpConstantNull: Declares a new null constant value. // The null value is type dependent, defined as follows: // - Scalar Boolean: false // ... const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragColor %BaseColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %v "v" OpName %gl_FragColor "gl_FragColor" OpName %BaseColor "BaseColor" %void = OpTypeVoid %7 = OpTypeFunction %void %bool = OpTypeBool %9 = OpConstantNull %bool %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %float_0 = OpConstant %float 0 %14 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %float_1 = OpConstant %float 1 %16 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input )"; const std::string before = R"(%main = OpFunction %void None %7 %19 = OpLabel %v = OpVariable %_ptr_Function_v4float Function OpSelectionMerge %20 None OpBranchConditional %9 %21 %22 %21 = OpLabel OpStore %v %14 OpBranch %20 %22 = OpLabel OpStore %v %16 OpBranch %20 %20 = OpLabel %23 = OpLoad %v4float %v OpStore %gl_FragColor %23 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %7 %19 = OpLabel %v = OpVariable %_ptr_Function_v4float Function OpBranch %22 %22 = OpLabel OpStore %v %16 OpBranch %20 %20 = OpLabel %23 = OpLoad %v4float %v OpStore %gl_FragColor %23 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before, predefs + after, true, true); } TEST_F(DeadBranchElimTest, IfThenTrue) { // #version 140 // // in vec4 BaseColor; // // void main() // { // vec4 v = BaseColor; // if (true) // v = v * vec4(0.5,0.5,0.5,0.5); // gl_FragColor = v; // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %7 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %bool = OpTypeBool %true = OpConstantTrue %bool %float_0_5 = OpConstant %float 0.5 %15 = OpConstantComposite %v4float %float_0_5 %float_0_5 %float_0_5 %float_0_5 %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output )"; const std::string before = R"(%main = OpFunction %void None %7 %17 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %18 = OpLoad %v4float %BaseColor OpStore %v %18 OpSelectionMerge %19 None OpBranchConditional %true %20 %19 %20 = OpLabel %21 = OpLoad %v4float %v %22 = OpFMul %v4float %21 %15 OpStore %v %22 OpBranch %19 %19 = OpLabel %23 = OpLoad %v4float %v OpStore %gl_FragColor %23 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %7 %17 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %18 = OpLoad %v4float %BaseColor OpStore %v %18 OpBranch %20 %20 = OpLabel %21 = OpLoad %v4float %v %22 = OpFMul %v4float %21 %15 OpStore %v %22 OpBranch %19 %19 = OpLabel %23 = OpLoad %v4float %v OpStore %gl_FragColor %23 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before, predefs + after, true, true); } TEST_F(DeadBranchElimTest, IfThenFalse) { // #version 140 // // in vec4 BaseColor; // // void main() // { // vec4 v = BaseColor; // if (false) // v = v * vec4(0.5,0.5,0.5,0.5); // gl_FragColor = v; // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %7 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %bool = OpTypeBool %false = OpConstantFalse %bool %float_0_5 = OpConstant %float 0.5 %15 = OpConstantComposite %v4float %float_0_5 %float_0_5 %float_0_5 %float_0_5 %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output )"; const std::string before = R"(%main = OpFunction %void None %7 %17 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %18 = OpLoad %v4float %BaseColor OpStore %v %18 OpSelectionMerge %19 None OpBranchConditional %false %20 %19 %20 = OpLabel %21 = OpLoad %v4float %v %22 = OpFMul %v4float %21 %15 OpStore %v %22 OpBranch %19 %19 = OpLabel %23 = OpLoad %v4float %v OpStore %gl_FragColor %23 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %7 %17 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %18 = OpLoad %v4float %BaseColor OpStore %v %18 OpBranch %19 %19 = OpLabel %23 = OpLoad %v4float %v OpStore %gl_FragColor %23 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before, predefs + after, true, true); } TEST_F(DeadBranchElimTest, IfThenElsePhiTrue) { // Test handling of phi in merge block after dead branch elimination. // Note: The SPIR-V has had store/load elimination and phi insertion // // #version 140 // // void main() // { // vec4 v; // if (true) // v = vec4(0.0,0.0,0.0,0.0); // else // v = vec4(1.0,1.0,1.0,1.0); // gl_FragColor = v; // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %5 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %float_0 = OpConstant %float 0 %12 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %float_1 = OpConstant %float 1 %14 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output %_ptr_Input_v4float = OpTypePointer Input %v4float )"; const std::string before = R"(%main = OpFunction %void None %5 %17 = OpLabel OpSelectionMerge %18 None OpBranchConditional %true %19 %20 %19 = OpLabel OpBranch %18 %20 = OpLabel OpBranch %18 %18 = OpLabel %21 = OpPhi %v4float %12 %19 %14 %20 OpStore %gl_FragColor %21 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %5 %17 = OpLabel OpBranch %19 %19 = OpLabel OpBranch %18 %18 = OpLabel OpStore %gl_FragColor %12 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before, predefs + after, true, true); } TEST_F(DeadBranchElimTest, IfThenElsePhiFalse) { // Test handling of phi in merge block after dead branch elimination. // Note: The SPIR-V has had store/load elimination and phi insertion // // #version 140 // // void main() // { // vec4 v; // if (true) // v = vec4(0.0,0.0,0.0,0.0); // else // v = vec4(1.0,1.0,1.0,1.0); // gl_FragColor = v; // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %5 = OpTypeFunction %void %bool = OpTypeBool %false = OpConstantFalse %bool %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %float_0 = OpConstant %float 0 %12 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %float_1 = OpConstant %float 1 %14 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output %_ptr_Input_v4float = OpTypePointer Input %v4float )"; const std::string before = R"(%main = OpFunction %void None %5 %17 = OpLabel OpSelectionMerge %18 None OpBranchConditional %false %19 %20 %19 = OpLabel OpBranch %18 %20 = OpLabel OpBranch %18 %18 = OpLabel %21 = OpPhi %v4float %12 %19 %14 %20 OpStore %gl_FragColor %21 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %5 %17 = OpLabel OpBranch %20 %20 = OpLabel OpBranch %18 %18 = OpLabel OpStore %gl_FragColor %14 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before, predefs + after, true, true); } TEST_F(DeadBranchElimTest, CompoundIfThenElseFalse) { // #version 140 // // layout(std140) uniform U_t // { // bool g_B ; // } ; // // void main() // { // vec4 v; // if (false) { // if (g_B) // v = vec4(0.0,0.0,0.0,0.0); // else // v = vec4(1.0,1.0,1.0,1.0); // } else { // if (g_B) // v = vec4(1.0,1.0,1.0,1.0); // else // v = vec4(0.0,0.0,0.0,0.0); // } // gl_FragColor = v; // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %U_t "U_t" OpMemberName %U_t 0 "g_B" OpName %_ "" OpName %v "v" OpName %gl_FragColor "gl_FragColor" OpMemberDecorate %U_t 0 Offset 0 OpDecorate %U_t Block OpDecorate %_ DescriptorSet 0 %void = OpTypeVoid %8 = OpTypeFunction %void %bool = OpTypeBool %false = OpConstantFalse %bool %uint = OpTypeInt 32 0 %U_t = OpTypeStruct %uint %_ptr_Uniform_U_t = OpTypePointer Uniform %U_t %_ = OpVariable %_ptr_Uniform_U_t Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %uint_0 = OpConstant %uint 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %float_0 = OpConstant %float 0 %21 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %float_1 = OpConstant %float 1 %23 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output )"; const std::string before = R"(%main = OpFunction %void None %8 %25 = OpLabel %v = OpVariable %_ptr_Function_v4float Function OpSelectionMerge %26 None OpBranchConditional %false %27 %28 %27 = OpLabel %29 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %30 = OpLoad %uint %29 %31 = OpINotEqual %bool %30 %uint_0 OpSelectionMerge %32 None OpBranchConditional %31 %33 %34 %33 = OpLabel OpStore %v %21 OpBranch %32 %34 = OpLabel OpStore %v %23 OpBranch %32 %32 = OpLabel OpBranch %26 %28 = OpLabel %35 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %36 = OpLoad %uint %35 %37 = OpINotEqual %bool %36 %uint_0 OpSelectionMerge %38 None OpBranchConditional %37 %39 %40 %39 = OpLabel OpStore %v %23 OpBranch %38 %40 = OpLabel OpStore %v %21 OpBranch %38 %38 = OpLabel OpBranch %26 %26 = OpLabel %41 = OpLoad %v4float %v OpStore %gl_FragColor %41 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %8 %25 = OpLabel %v = OpVariable %_ptr_Function_v4float Function OpBranch %28 %28 = OpLabel %35 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %36 = OpLoad %uint %35 %37 = OpINotEqual %bool %36 %uint_0 OpSelectionMerge %38 None OpBranchConditional %37 %39 %40 %40 = OpLabel OpStore %v %21 OpBranch %38 %39 = OpLabel OpStore %v %23 OpBranch %38 %38 = OpLabel OpBranch %26 %26 = OpLabel %41 = OpLoad %v4float %v OpStore %gl_FragColor %41 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before, predefs + after, true, true); } TEST_F(DeadBranchElimTest, PreventOrphanMerge) { const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %7 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %bool = OpTypeBool %true = OpConstantTrue %bool %float_0_5 = OpConstant %float 0.5 %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output )"; const std::string before = R"(%main = OpFunction %void None %7 %16 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %17 = OpLoad %v4float %BaseColor OpStore %v %17 OpSelectionMerge %18 None OpBranchConditional %true %19 %20 %19 = OpLabel OpKill %20 = OpLabel %21 = OpLoad %v4float %v %22 = OpVectorTimesScalar %v4float %21 %float_0_5 OpStore %v %22 OpBranch %18 %18 = OpLabel %23 = OpLoad %v4float %v OpStore %gl_FragColor %23 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %7 %16 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %17 = OpLoad %v4float %BaseColor OpStore %v %17 OpBranch %19 %19 = OpLabel OpKill OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before, predefs + after, true, true); } TEST_F(DeadBranchElimTest, HandleOrphanMerge) { const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %foo_ "foo(" OpName %gl_FragColor "gl_FragColor" OpDecorate %gl_FragColor Location 0 %void = OpTypeVoid %6 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %9 = OpTypeFunction %v4float %bool = OpTypeBool %true = OpConstantTrue %bool %float_0 = OpConstant %float 0 %13 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %float_1 = OpConstant %float 1 %15 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %6 %17 = OpLabel %18 = OpFunctionCall %v4float %foo_ OpStore %gl_FragColor %18 OpReturn OpFunctionEnd )"; const std::string before = R"(%foo_ = OpFunction %v4float None %9 %19 = OpLabel OpSelectionMerge %20 None OpBranchConditional %true %21 %22 %21 = OpLabel OpReturnValue %13 %22 = OpLabel OpReturnValue %15 %20 = OpLabel %23 = OpUndef %v4float OpReturnValue %23 OpFunctionEnd )"; const std::string after = R"(%foo_ = OpFunction %v4float None %9 %19 = OpLabel OpBranch %21 %21 = OpLabel OpReturnValue %13 OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before, predefs + after, true, true); } TEST_F(DeadBranchElimTest, KeepContinueTargetWhenKillAfterMerge) { // #version 450 // void main() { // bool c; // bool d; // while(c) { // if(d) { // continue; // } // if(false) { // continue; // } // discard; // } // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %c "c" OpName %d "d" %void = OpTypeVoid %6 = OpTypeFunction %void %bool = OpTypeBool %_ptr_Function_bool = OpTypePointer Function %bool %false = OpConstantFalse %bool )"; const std::string before = R"(%main = OpFunction %void None %6 %10 = OpLabel %c = OpVariable %_ptr_Function_bool Function %d = OpVariable %_ptr_Function_bool Function OpBranch %11 %11 = OpLabel OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %15 = OpLoad %bool %c OpBranchConditional %15 %16 %12 %16 = OpLabel %17 = OpLoad %bool %d OpSelectionMerge %18 None OpBranchConditional %17 %19 %18 %19 = OpLabel OpBranch %13 %18 = OpLabel OpSelectionMerge %20 None OpBranchConditional %false %21 %20 %21 = OpLabel OpBranch %13 %20 = OpLabel OpKill %13 = OpLabel OpBranch %11 %12 = OpLabel OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %6 %10 = OpLabel %c = OpVariable %_ptr_Function_bool Function %d = OpVariable %_ptr_Function_bool Function OpBranch %11 %11 = OpLabel OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %15 = OpLoad %bool %c OpBranchConditional %15 %16 %12 %16 = OpLabel %17 = OpLoad %bool %d OpSelectionMerge %18 None OpBranchConditional %17 %19 %18 %19 = OpLabel OpBranch %13 %18 = OpLabel OpBranch %20 %20 = OpLabel OpKill %13 = OpLabel OpBranch %11 %12 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before, predefs + after, true, true); } TEST_F(DeadBranchElimTest, DecorateDeleted) { // Note: SPIR-V hand-edited to add decoration // #version 140 // // in vec4 BaseColor; // // void main() // { // vec4 v = BaseColor; // if (false) // v = v * vec4(0.5,0.5,0.5,0.5); // gl_FragColor = v; // } const std::string predefs_before = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" OpName %gl_FragColor "gl_FragColor" OpDecorate %22 RelaxedPrecision %void = OpTypeVoid %7 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %bool = OpTypeBool %false = OpConstantFalse %bool %float_0_5 = OpConstant %float 0.5 %15 = OpConstantComposite %v4float %float_0_5 %float_0_5 %float_0_5 %float_0_5 %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output )"; const std::string predefs_after = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %bool = OpTypeBool %false = OpConstantFalse %bool %float_0_5 = OpConstant %float 0.5 %16 = OpConstantComposite %v4float %float_0_5 %float_0_5 %float_0_5 %float_0_5 %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output )"; const std::string before = R"(%main = OpFunction %void None %7 %17 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %18 = OpLoad %v4float %BaseColor OpStore %v %18 OpSelectionMerge %19 None OpBranchConditional %false %20 %19 %20 = OpLabel %21 = OpLoad %v4float %v %22 = OpFMul %v4float %21 %15 OpStore %v %22 OpBranch %19 %19 = OpLabel %23 = OpLoad %v4float %v OpStore %gl_FragColor %23 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %8 %18 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %19 = OpLoad %v4float %BaseColor OpStore %v %19 OpBranch %20 %20 = OpLabel %23 = OpLoad %v4float %v OpStore %gl_FragColor %23 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs_before + before, predefs_after + after, true, true); } TEST_F(DeadBranchElimTest, LoopInDeadBranch) { // #version 450 // // layout(location = 0) in vec4 BaseColor; // layout(location = 0) out vec4 OutColor; // // void main() // { // vec4 v = BaseColor; // if (false) // for (int i=0; i<3; i++) // v = v * 0.5; // OutColor = v; // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" OpName %i "i" OpName %OutColor "OutColor" OpDecorate %BaseColor Location 0 OpDecorate %OutColor Location 0 %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %bool = OpTypeBool %false = OpConstantFalse %bool %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_3 = OpConstant %int 3 %float_0_5 = OpConstant %float 0.5 %int_1 = OpConstant %int 1 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output )"; const std::string before = R"(%main = OpFunction %void None %8 %22 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %i = OpVariable %_ptr_Function_int Function %23 = OpLoad %v4float %BaseColor OpStore %v %23 OpSelectionMerge %24 None OpBranchConditional %false %25 %24 %25 = OpLabel OpStore %i %int_0 OpBranch %26 %26 = OpLabel OpLoopMerge %27 %28 None OpBranch %29 %29 = OpLabel %30 = OpLoad %int %i %31 = OpSLessThan %bool %30 %int_3 OpBranchConditional %31 %32 %27 %32 = OpLabel %33 = OpLoad %v4float %v %34 = OpVectorTimesScalar %v4float %33 %float_0_5 OpStore %v %34 OpBranch %28 %28 = OpLabel %35 = OpLoad %int %i %36 = OpIAdd %int %35 %int_1 OpStore %i %36 OpBranch %26 %27 = OpLabel OpBranch %24 %24 = OpLabel %37 = OpLoad %v4float %v OpStore %OutColor %37 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %8 %22 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %i = OpVariable %_ptr_Function_int Function %23 = OpLoad %v4float %BaseColor OpStore %v %23 OpBranch %24 %24 = OpLabel %37 = OpLoad %v4float %v OpStore %OutColor %37 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before, predefs + after, true, true); } TEST_F(DeadBranchElimTest, SwitchLiveCase) { // #version 450 // // layout (location=0) in vec4 BaseColor; // layout (location=0) out vec4 OutColor; // // void main() // { // switch (1) { // case 0: // OutColor = vec4(0.0,0.0,0.0,0.0); // break; // case 1: // OutColor = vec4(0.125,0.125,0.125,0.125); // break; // case 2: // OutColor = vec4(0.25,0.25,0.25,0.25); // break; // default: // OutColor = vec4(1.0,1.0,1.0,1.0); // } // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %OutColor %BaseColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %OutColor "OutColor" OpName %BaseColor "BaseColor" OpDecorate %OutColor Location 0 OpDecorate %BaseColor Location 0 %void = OpTypeVoid %6 = OpTypeFunction %void %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %float_0 = OpConstant %float 0 %13 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %float_0_125 = OpConstant %float 0.125 %15 = OpConstantComposite %v4float %float_0_125 %float_0_125 %float_0_125 %float_0_125 %float_0_25 = OpConstant %float 0.25 %17 = OpConstantComposite %v4float %float_0_25 %float_0_25 %float_0_25 %float_0_25 %float_1 = OpConstant %float 1 %19 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input )"; const std::string before = R"(%main = OpFunction %void None %6 %21 = OpLabel OpSelectionMerge %22 None OpSwitch %int_1 %23 0 %24 1 %25 2 %26 %23 = OpLabel OpStore %OutColor %19 OpBranch %22 %24 = OpLabel OpStore %OutColor %13 OpBranch %22 %25 = OpLabel OpStore %OutColor %15 OpBranch %22 %26 = OpLabel OpStore %OutColor %17 OpBranch %22 %22 = OpLabel OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %6 %21 = OpLabel OpBranch %25 %25 = OpLabel OpStore %OutColor %15 OpBranch %22 %22 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before, predefs + after, true, true); } TEST_F(DeadBranchElimTest, SwitchLiveDefault) { // #version 450 // // layout (location=0) in vec4 BaseColor; // layout (location=0) out vec4 OutColor; // // void main() // { // switch (7) { // case 0: // OutColor = vec4(0.0,0.0,0.0,0.0); // break; // case 1: // OutColor = vec4(0.125,0.125,0.125,0.125); // break; // case 2: // OutColor = vec4(0.25,0.25,0.25,0.25); // break; // default: // OutColor = vec4(1.0,1.0,1.0,1.0); // } // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %OutColor %BaseColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %OutColor "OutColor" OpName %BaseColor "BaseColor" OpDecorate %OutColor Location 0 OpDecorate %BaseColor Location 0 %void = OpTypeVoid %6 = OpTypeFunction %void %int = OpTypeInt 32 1 %int_7 = OpConstant %int 7 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %float_0 = OpConstant %float 0 %13 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %float_0_125 = OpConstant %float 0.125 %15 = OpConstantComposite %v4float %float_0_125 %float_0_125 %float_0_125 %float_0_125 %float_0_25 = OpConstant %float 0.25 %17 = OpConstantComposite %v4float %float_0_25 %float_0_25 %float_0_25 %float_0_25 %float_1 = OpConstant %float 1 %19 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input )"; const std::string before = R"(%main = OpFunction %void None %6 %21 = OpLabel OpSelectionMerge %22 None OpSwitch %int_7 %23 0 %24 1 %25 2 %26 %23 = OpLabel OpStore %OutColor %19 OpBranch %22 %24 = OpLabel OpStore %OutColor %13 OpBranch %22 %25 = OpLabel OpStore %OutColor %15 OpBranch %22 %26 = OpLabel OpStore %OutColor %17 OpBranch %22 %22 = OpLabel OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %6 %21 = OpLabel OpBranch %23 %23 = OpLabel OpStore %OutColor %19 OpBranch %22 %22 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before, predefs + after, true, true); } TEST_F(DeadBranchElimTest, SwitchLiveCaseBreakFromLoop) { // This sample does not directly translate to GLSL/HLSL as // direct breaks from a loop cannot be made from a switch. // This construct is currently formed by inlining a function // containing early returns from the cases of a switch. The // function is wrapped in a one-trip loop and returns are // translated to branches to the loop's merge block. const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %OutColor %BaseColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %oc "oc" OpName %OutColor "OutColor" OpName %BaseColor "BaseColor" OpDecorate %OutColor Location 0 OpDecorate %BaseColor Location 0 %void = OpTypeVoid %7 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %false = OpConstantFalse %bool %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %float_0 = OpConstant %float 0 %17 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %float_0_125 = OpConstant %float 0.125 %19 = OpConstantComposite %v4float %float_0_125 %float_0_125 %float_0_125 %float_0_125 %float_0_25 = OpConstant %float 0.25 %21 = OpConstantComposite %v4float %float_0_25 %float_0_25 %float_0_25 %float_0_25 %float_1 = OpConstant %float 1 %23 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input )"; const std::string before = R"(%main = OpFunction %void None %7 %26 = OpLabel %oc = OpVariable %_ptr_Function_v4float Function OpBranch %27 %27 = OpLabel OpLoopMerge %28 %29 None OpBranch %30 %30 = OpLabel OpSelectionMerge %31 None OpSwitch %int_1 %31 0 %32 1 %33 2 %34 %32 = OpLabel OpStore %oc %17 OpBranch %28 %33 = OpLabel OpStore %oc %19 OpBranch %28 %34 = OpLabel OpStore %oc %21 OpBranch %28 %31 = OpLabel OpStore %oc %23 OpBranch %28 %29 = OpLabel OpBranchConditional %false %27 %28 %28 = OpLabel %35 = OpLoad %v4float %oc OpStore %OutColor %35 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %7 %26 = OpLabel %oc = OpVariable %_ptr_Function_v4float Function OpBranch %27 %27 = OpLabel OpLoopMerge %28 %29 None OpBranch %30 %30 = OpLabel OpBranch %33 %33 = OpLabel OpStore %oc %19 OpBranch %28 %29 = OpLabel OpBranch %27 %28 = OpLabel %35 = OpLoad %v4float %oc OpStore %OutColor %35 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before, predefs + after, true, true); } TEST_F(DeadBranchElimTest, LeaveContinueBackedge) { const std::string text = R"( ; CHECK: OpLoopMerge [[merge:%\w+]] [[continue:%\w+]] None ; CHECK: [[continue]] = OpLabel ; CHECK-NEXT: OpBranchConditional {{%\w+}} {{%\w+}} [[merge]] ; CHECK-NEXT: [[merge]] = OpLabel ; CHECK-NEXT: OpReturn OpCapability Kernel OpCapability Linkage OpMemoryModel Logical OpenCL %bool = OpTypeBool %false = OpConstantFalse %bool %void = OpTypeVoid %funcTy = OpTypeFunction %void %func = OpFunction %void None %funcTy %1 = OpLabel OpBranch %2 %2 = OpLabel OpLoopMerge %3 %4 None OpBranch %4 %4 = OpLabel ; Be careful we don't remove the backedge to %2 despite never taking it. OpBranchConditional %false %2 %3 %3 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(DeadBranchElimTest, LeaveContinueBackedgeExtraBlock) { const std::string text = R"( ; CHECK: OpBranch [[header:%\w+]] ; CHECK: OpLoopMerge [[merge:%\w+]] [[continue:%\w+]] None ; CHECK-NEXT: OpBranch [[continue]] ; CHECK-NEXT: [[continue]] = OpLabel ; CHECK-NEXT: OpBranchConditional {{%\w+}} [[extra:%\w+]] [[merge]] ; CHECK-NEXT: [[extra]] = OpLabel ; CHECK-NEXT: OpBranch [[header]] ; CHECK-NEXT: [[merge]] = OpLabel ; CHECK-NEXT: OpReturn OpCapability Kernel OpCapability Linkage OpMemoryModel Logical OpenCL %bool = OpTypeBool %false = OpConstantFalse %bool %void = OpTypeVoid %funcTy = OpTypeFunction %void %func = OpFunction %void None %funcTy %1 = OpLabel OpBranch %2 %2 = OpLabel OpLoopMerge %3 %4 None OpBranch %4 %4 = OpLabel ; Be careful we don't remove the backedge to %2 despite never taking it. OpBranchConditional %false %5 %3 ; This block remains live despite being unreachable. %5 = OpLabel OpBranch %2 %3 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(DeadBranchElimTest, RemovePhiWithUnreachableContinue) { const std::string text = R"( ; CHECK: [[entry:%\w+]] = OpLabel ; CHECK-NEXT: OpBranch [[header:%\w+]] ; CHECK: OpLoopMerge [[merge:%\w+]] [[continue:%\w+]] None ; CHECK-NEXT: OpBranch [[ret:%\w+]] ; CHECK-NEXT: [[ret]] = OpLabel ; CHECK-NEXT: OpReturn ; CHECK: [[continue]] = OpLabel ; CHECK-NEXT: OpBranch [[header]] ; CHECK: [[merge]] = OpLabel ; CHECK-NEXT: OpUnreachable OpCapability Kernel OpCapability Linkage OpMemoryModel Logical OpenCL OpName %func "func" OpDecorate %func LinkageAttributes "func" Export %bool = OpTypeBool %false = OpConstantFalse %bool %true = OpConstantTrue %bool %void = OpTypeVoid %funcTy = OpTypeFunction %void %func = OpFunction %void None %funcTy %1 = OpLabel OpBranch %2 %2 = OpLabel %phi = OpPhi %bool %false %1 %true %continue OpLoopMerge %merge %continue None OpBranch %3 %3 = OpLabel OpReturn %continue = OpLabel OpBranch %2 %merge = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(DeadBranchElimTest, UnreachableLoopMergeAndContinueTargets) { const std::string text = R"( ; CHECK: [[undef:%\w+]] = OpUndef %bool ; CHECK: OpSelectionMerge [[header:%\w+]] ; CHECK-NEXT: OpBranchConditional {{%\w+}} [[if_lab:%\w+]] [[else_lab:%\w+]] ; CHECK: OpPhi %bool %false [[if_lab]] %false [[else_lab]] [[undef]] [[continue:%\w+]] ; CHECK-NEXT: OpLoopMerge [[merge:%\w+]] [[continue]] None ; CHECK-NEXT: OpBranch [[ret:%\w+]] ; CHECK-NEXT: [[ret]] = OpLabel ; CHECK-NEXT: OpReturn ; CHECK: [[continue]] = OpLabel ; CHECK-NEXT: OpBranch [[header]] ; CHECK: [[merge]] = OpLabel ; CHECK-NEXT: OpUnreachable OpCapability Kernel OpCapability Linkage OpMemoryModel Logical OpenCL OpName %func "func" OpDecorate %func LinkageAttributes "func" Export %bool = OpTypeBool %false = OpConstantFalse %bool %true = OpConstantTrue %bool %void = OpTypeVoid %funcTy = OpTypeFunction %void %func = OpFunction %void None %funcTy %1 = OpLabel %c = OpUndef %bool OpSelectionMerge %2 None OpBranchConditional %c %if %else %if = OpLabel OpBranch %2 %else = OpLabel OpBranch %2 %2 = OpLabel %phi = OpPhi %bool %false %if %false %else %true %continue OpLoopMerge %merge %continue None OpBranch %3 %3 = OpLabel OpReturn %continue = OpLabel OpBranch %2 %merge = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(DeadBranchElimTest, EarlyReconvergence) { const std::string text = R"( ; CHECK-NOT: OpBranchConditional ; CHECK: [[logical:%\w+]] = OpLogicalOr ; CHECK-NOT: OpPhi ; CHECK: OpLogicalAnd {{%\w+}} {{%\w+}} [[logical]] OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %bool = OpTypeBool %false = OpConstantFalse %bool %true = OpConstantTrue %bool %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel OpSelectionMerge %2 None OpBranchConditional %false %3 %4 %3 = OpLabel %12 = OpLogicalNot %bool %true OpBranch %2 %4 = OpLabel OpSelectionMerge %14 None OpBranchConditional %false %5 %6 %5 = OpLabel %10 = OpLogicalAnd %bool %true %false OpBranch %7 %6 = OpLabel %11 = OpLogicalOr %bool %true %false OpBranch %7 %7 = OpLabel ; This phi is in a block preceding the merge %14! %8 = OpPhi %bool %10 %5 %11 %6 OpBranch %14 %14 = OpLabel OpBranch %2 %2 = OpLabel %9 = OpPhi %bool %12 %3 %8 %14 %13 = OpLogicalAnd %bool %true %9 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(DeadBranchElimTest, RemoveUnreachableBlocksFloating) { const std::string text = R"( ; CHECK: OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpReturn ; CHECK-NEXT: OpFunctionEnd OpCapability Kernel OpCapability Linkage OpMemoryModel Logical OpenCL OpName %func "func" OpDecorate %func LinkageAttributes "func" Export %void = OpTypeVoid %1 = OpTypeFunction %void %func = OpFunction %void None %1 %2 = OpLabel OpReturn %3 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(DeadBranchElimTest, RemoveUnreachableBlocksFloatingJoin) { const std::string text = R"( ; CHECK: OpFunction ; CHECK-NEXT: OpFunctionParameter ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpReturn ; CHECK-NEXT: OpFunctionEnd OpCapability Kernel OpCapability Linkage OpMemoryModel Logical OpenCL OpName %func "func" OpDecorate %func LinkageAttributes "func" Export %void = OpTypeVoid %bool = OpTypeBool %false = OpConstantFalse %bool %true = OpConstantTrue %bool %1 = OpTypeFunction %void %bool %func = OpFunction %void None %1 %bool_param = OpFunctionParameter %bool %2 = OpLabel OpReturn %3 = OpLabel OpSelectionMerge %6 None OpBranchConditional %bool_param %4 %5 %4 = OpLabel OpBranch %6 %5 = OpLabel OpBranch %6 %6 = OpLabel %7 = OpPhi %bool %true %4 %false %6 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(DeadBranchElimTest, RemoveUnreachableBlocksDeadPhi) { const std::string text = R"( ; CHECK: OpFunction ; CHECK-NEXT: OpFunctionParameter ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpBranch [[label:%\w+]] ; CHECK-NEXT: [[label]] = OpLabel ; CHECK-NEXT: OpLogicalNot %bool %true ; CHECK-NEXT: OpReturn ; CHECK-NEXT: OpFunctionEnd OpCapability Kernel OpCapability Linkage OpMemoryModel Logical OpenCL OpName %func "func" OpDecorate %func LinkageAttributes "func" Export %void = OpTypeVoid %bool = OpTypeBool %false = OpConstantFalse %bool %true = OpConstantTrue %bool %1 = OpTypeFunction %void %bool %func = OpFunction %void None %1 %bool_param = OpFunctionParameter %bool %2 = OpLabel OpBranch %3 %4 = OpLabel OpBranch %3 %3 = OpLabel %5 = OpPhi %bool %true %2 %false %4 %6 = OpLogicalNot %bool %5 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(DeadBranchElimTest, RemoveUnreachableBlocksPartiallyDeadPhi) { const std::string text = R"( ; CHECK: OpFunction ; CHECK-NEXT: [[param:%\w+]] = OpFunctionParameter ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpBranchConditional [[param]] [[merge:%\w+]] [[br:%\w+]] ; CHECK-NEXT: [[merge]] = OpLabel ; CHECK-NEXT: [[phi:%\w+]] = OpPhi %bool %true %2 %false [[br]] ; CHECK-NEXT: OpLogicalNot %bool [[phi]] ; CHECK-NEXT: OpReturn ; CHECK-NEXT: [[br]] = OpLabel ; CHECK-NEXT: OpBranch [[merge]] ; CHECK-NEXT: OpFunctionEnd OpCapability Kernel OpCapability Linkage OpMemoryModel Logical OpenCL OpName %func "func" OpDecorate %func LinkageAttributes "func" Export %void = OpTypeVoid %bool = OpTypeBool %false = OpConstantFalse %bool %true = OpConstantTrue %bool %1 = OpTypeFunction %void %bool %func = OpFunction %void None %1 %bool_param = OpFunctionParameter %bool %2 = OpLabel OpBranchConditional %bool_param %3 %7 %7 = OpLabel OpBranch %3 %4 = OpLabel OpBranch %3 %3 = OpLabel %5 = OpPhi %bool %true %2 %false %7 %false %4 %6 = OpLogicalNot %bool %5 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(text, true); } TEST_F(DeadBranchElimTest, LiveHeaderDeadPhi) { const std::string text = R"( ; CHECK: OpLabel ; CHECK-NOT: OpBranchConditional ; CHECK-NOT: OpPhi ; CHECK: OpLogicalNot %bool %false OpCapability Kernel OpCapability Linkage OpMemoryModel Logical OpenCL OpName %func "func" OpDecorate %func LinkageAttributes "func" Export %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %false = OpConstantFalse %bool %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel OpSelectionMerge %3 None OpBranchConditional %true %2 %3 %2 = OpLabel OpBranch %3 %3 = OpLabel %5 = OpPhi %bool %true %3 %false %2 %6 = OpLogicalNot %bool %5 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(DeadBranchElimTest, ExtraBackedgeBlocksLive) { const std::string text = R"( ; CHECK: [[entry:%\w+]] = OpLabel ; CHECK-NOT: OpSelectionMerge ; CHECK: OpBranch [[header:%\w+]] ; CHECK-NEXT: [[header]] = OpLabel ; CHECK-NEXT: OpPhi %bool %true [[entry]] %false [[backedge:%\w+]] ; CHECK-NEXT: OpLoopMerge OpCapability Kernel OpCapability Linkage OpMemoryModel Logical OpenCL OpName %func "func" OpDecorate %func LinkageAttributes "func" Export %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %false = OpConstantFalse %bool %func_ty = OpTypeFunction %void %bool %func = OpFunction %void None %func_ty %param = OpFunctionParameter %bool %entry = OpLabel OpSelectionMerge %if_merge None ; This dead branch is included to ensure the pass does work. OpBranchConditional %false %if_merge %loop_header %loop_header = OpLabel ; Both incoming edges are live, so the phi should be untouched. %phi = OpPhi %bool %true %entry %false %backedge OpLoopMerge %loop_merge %continue None OpBranchConditional %param %loop_merge %continue %continue = OpLabel OpBranch %backedge %backedge = OpLabel OpBranch %loop_header %loop_merge = OpLabel OpBranch %if_merge %if_merge = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(DeadBranchElimTest, ExtraBackedgeBlocksUnreachable) { const std::string text = R"( ; CHECK: [[entry:%\w+]] = OpLabel ; CHECK-NEXT: OpBranch [[header:%\w+]] ; CHECK-NEXT: [[header]] = OpLabel ; CHECK-NEXT: OpLoopMerge [[merge:%\w+]] [[continue:%\w+]] None ; CHECK-NEXT: OpBranch [[merge]] ; CHECK-NEXT: [[merge]] = OpLabel ; CHECK-NEXT: OpReturn ; CHECK-NEXT: [[continue]] = OpLabel ; CHECK-NEXT: OpBranch [[header]] OpCapability Kernel OpCapability Linkage OpMemoryModel Logical OpenCL OpName %func "func" OpDecorate %func LinkageAttributes "func" Export %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %false = OpConstantFalse %bool %func_ty = OpTypeFunction %void %bool %func = OpFunction %void None %func_ty %param = OpFunctionParameter %bool %entry = OpLabel OpBranch %loop_header %loop_header = OpLabel ; Since the continue is unreachable, %backedge will be removed. The phi will ; instead require an edge from %continue. %phi = OpPhi %bool %true %entry %false %backedge OpLoopMerge %merge %continue None OpBranch %merge %continue = OpLabel OpBranch %backedge %backedge = OpLabel OpBranch %loop_header %merge = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(DeadBranchElimTest, NoUnnecessaryChanges) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %undef = OpUndef %bool %functy = OpTypeFunction %void %func = OpFunction %void None %functy %1 = OpLabel OpBranch %2 %2 = OpLabel OpLoopMerge %4 %5 None OpBranch %6 %6 = OpLabel OpReturn %5 = OpLabel OpBranch %2 %4 = OpLabel OpUnreachable OpFunctionEnd )"; auto result = SinglePassRunToBinary(text, true); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(DeadBranchElimTest, ExtraBackedgePartiallyDead) { const std::string text = R"( ; CHECK: OpLabel ; CHECK: [[header:%\w+]] = OpLabel ; CHECK: OpLoopMerge [[merge:%\w+]] [[continue:%\w+]] None ; CHECK: [[merge]] = OpLabel ; CHECK: [[continue]] = OpLabel ; CHECK: OpBranch [[extra:%\w+]] ; CHECK: [[extra]] = OpLabel ; CHECK-NOT: OpSelectionMerge ; CHECK-NEXT: OpBranch [[else:%\w+]] ; CHECK-NEXT: [[else]] = OpLabel ; CHECK-NEXT: OpLogicalOr ; CHECK-NEXT: OpBranch [[backedge:%\w+]] ; CHECK-NEXT: [[backedge:%\w+]] = OpLabel ; CHECK-NEXT: OpBranch [[header]] OpCapability Kernel OpCapability Linkage OpMemoryModel Logical OpenCL OpName %func "func" OpDecorate %func LinkageAttributes "func" Export %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %false = OpConstantFalse %bool %func_ty = OpTypeFunction %void %bool %func = OpFunction %void None %func_ty %param = OpFunctionParameter %bool %entry = OpLabel OpBranch %loop_header %loop_header = OpLabel OpLoopMerge %loop_merge %continue None OpBranchConditional %param %loop_merge %continue %continue = OpLabel OpBranch %extra %extra = OpLabel OpSelectionMerge %backedge None OpBranchConditional %false %then %else %then = OpLabel %and = OpLogicalAnd %bool %true %false OpBranch %backedge %else = OpLabel %or = OpLogicalOr %bool %true %false OpBranch %backedge %backedge = OpLabel OpBranch %loop_header %loop_merge = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(DeadBranchElimTest, UnreachableContinuePhiInMerge) { const std::string text = R"( ; CHECK: [[entry:%\w+]] = OpLabel ; CHECK-NEXT: OpBranch [[header:%\w+]] ; CHECK-NEXT: [[header]] = OpLabel ; CHECK-NEXT: OpLoopMerge [[merge:%\w+]] [[continue:%\w+]] None ; CHECK-NEXT: OpBranch [[label:%\w+]] ; CHECK-NEXT: [[label]] = OpLabel ; CHECK-NEXT: [[fadd:%\w+]] = OpFAdd ; CHECK-NEXT: OpBranch [[label:%\w+]] ; CHECK-NEXT: [[label]] = OpLabel ; CHECK-NEXT: OpBranch [[merge]] ; CHECK-NEXT: [[continue]] = OpLabel ; CHECK-NEXT: OpBranch [[header]] ; CHECK-NEXT: [[merge]] = OpLabel ; CHECK-NEXT: OpStore {{%\w+}} [[fadd]] OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %o OpExecutionMode %main OriginUpperLeft OpSource GLSL 430 OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpName %main "main" OpName %o "o" OpName %S "S" OpMemberName %S 0 "a" OpName %U_t "U_t" OpMemberName %U_t 0 "g_F" OpMemberName %U_t 1 "g_F2" OpDecorate %o Location 0 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %U_t 0 Volatile OpMemberDecorate %U_t 0 Offset 0 OpMemberDecorate %U_t 1 Offset 4 OpDecorate %U_t BufferBlock %void = OpTypeVoid %7 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %bool = OpTypeBool %true = OpConstantTrue %bool %float_1 = OpConstant %float 1 %float_5 = OpConstant %float 5 %int_1 = OpConstant %int 1 %_ptr_Output_float = OpTypePointer Output %float %o = OpVariable %_ptr_Output_float Output %S = OpTypeStruct %float %U_t = OpTypeStruct %S %S %_ptr_Uniform_U_t = OpTypePointer Uniform %U_t %main = OpFunction %void None %7 %22 = OpLabel OpBranch %23 %23 = OpLabel %24 = OpPhi %float %float_0 %22 %25 %26 %27 = OpPhi %int %int_0 %22 %28 %26 OpLoopMerge %29 %26 None OpBranch %40 %40 = OpLabel %25 = OpFAdd %float %24 %float_1 OpSelectionMerge %30 None OpBranchConditional %true %31 %30 %31 = OpLabel OpBranch %29 %30 = OpLabel OpBranch %26 %26 = OpLabel %28 = OpIAdd %int %27 %int_1 %32 = OpSLessThan %bool %27 %int_10 ; continue block branches to the header or another none dead block. OpBranchConditional %32 %23 %29 %29 = OpLabel %33 = OpPhi %float %24 %26 %25 %31 OpStore %o %33 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(DeadBranchElimTest, NonStructuredIf) { const std::string text = R"( ; CHECK-NOT: OpBranchConditional OpCapability Kernel OpCapability Linkage OpMemoryModel Logical OpenCL OpDecorate %func LinkageAttributes "func" Export %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %functy = OpTypeFunction %void %func = OpFunction %void None %functy %entry = OpLabel OpBranchConditional %true %then %else %then = OpLabel OpBranch %final %else = OpLabel OpBranch %final %final = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(DeadBranchElimTest, ReorderBlocks) { const std::string text = R"( ; CHECK: OpLabel ; CHECK: OpBranch [[label:%\w+]] ; CHECK: [[label:%\w+]] = OpLabel ; CHECK-NEXT: OpLogicalNot ; CHECK-NEXT: OpBranch [[label:%\w+]] ; CHECK: [[label]] = OpLabel ; CHECK-NEXT: OpReturn OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel OpSelectionMerge %3 None OpBranchConditional %true %2 %3 %3 = OpLabel OpReturn %2 = OpLabel %not = OpLogicalNot %bool %true OpBranch %3 OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(DeadBranchElimTest, ReorderBlocksMultiple) { // Checks are not important. The validation post optimization is the // important part. const std::string text = R"( ; CHECK: OpLabel OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel OpSelectionMerge %3 None OpBranchConditional %true %2 %3 %3 = OpLabel OpReturn %2 = OpLabel OpBranch %4 %4 = OpLabel OpBranch %3 OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(DeadBranchElimTest, ReorderBlocksMultiple2) { // Checks are not important. The validation post optimization is the // important part. const std::string text = R"( ; CHECK: OpLabel OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel OpSelectionMerge %3 None OpBranchConditional %true %2 %3 %3 = OpLabel OpBranch %5 %5 = OpLabel OpReturn %2 = OpLabel OpBranch %4 %4 = OpLabel OpBranch %3 OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(DeadBranchElimTest, SelectionMergeWithEarlyExit1) { // Checks that if a selection merge construct contains a conditional branch // to the merge node, then the OpSelectionMerge instruction is positioned // correctly. const std::string predefs = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 %void = OpTypeVoid %func_type = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %undef_bool = OpUndef %bool )"; const std::string body = R"( ; CHECK: OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpBranch [[taken_branch:%\w+]] ; CHECK-NEXT: [[taken_branch]] = OpLabel ; CHECK-NEXT: OpSelectionMerge [[merge:%\w+]] ; CHECK-NEXT: OpBranchConditional {{%\w+}} [[merge]] {{%\w+}} %main = OpFunction %void None %func_type %entry_bb = OpLabel OpSelectionMerge %outer_merge None OpBranchConditional %true %bb1 %bb3 %bb1 = OpLabel OpBranchConditional %undef_bool %outer_merge %bb2 %bb2 = OpLabel OpBranch %outer_merge %bb3 = OpLabel OpBranch %outer_merge %outer_merge = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(predefs + body, true); } TEST_F(DeadBranchElimTest, SelectionMergeWithEarlyExit2) { // Checks that if a selection merge construct contains a conditional branch // to the merge node, then the OpSelectionMerge instruction is positioned // correctly. const std::string predefs = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 %void = OpTypeVoid %func_type = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %undef_bool = OpUndef %bool )"; const std::string body = R"( ; CHECK: OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpBranch [[bb1:%\w+]] ; CHECK-NEXT: [[bb1]] = OpLabel ; CHECK-NEXT: OpSelectionMerge [[inner_merge:%\w+]] ; CHECK: [[inner_merge]] = OpLabel ; CHECK-NEXT: OpSelectionMerge [[outer_merge:%\w+]] ; CHECK-NEXT: OpBranchConditional {{%\w+}} [[outer_merge]:%\w+]] {{%\w+}} ; CHECK: [[outer_merge]] = OpLabel ; CHECK-NEXT: OpReturn %main = OpFunction %void None %func_type %entry_bb = OpLabel OpSelectionMerge %outer_merge None OpBranchConditional %true %bb1 %bb5 %bb1 = OpLabel OpSelectionMerge %inner_merge None OpBranchConditional %undef_bool %bb2 %bb3 %bb2 = OpLabel OpBranch %inner_merge %bb3 = OpLabel OpBranch %inner_merge %inner_merge = OpLabel OpBranchConditional %undef_bool %outer_merge %bb4 %bb4 = OpLabel OpBranch %outer_merge %bb5 = OpLabel OpBranch %outer_merge %outer_merge = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(predefs + body, true); } TEST_F(DeadBranchElimTest, SelectionMergeWithConditionalExit) { // Checks that if a selection merge construct contains a conditional branch // to the merge node, then we keep the OpSelectionMerge on that branch. const std::string predefs = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 %void = OpTypeVoid %func_type = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %uint = OpTypeInt 32 0 %undef_int = OpUndef %uint )"; const std::string body = R"( ; CHECK: OpLoopMerge [[loop_merge:%\w+]] ; CHECK-NEXT: OpBranch [[bb1:%\w+]] ; CHECK: [[bb1]] = OpLabel ; CHECK-NEXT: OpBranch [[bb2:%\w+]] ; CHECK: [[bb2]] = OpLabel ; CHECK-NEXT: OpSelectionMerge [[sel_merge:%\w+]] None ; CHECK-NEXT: OpSwitch {{%\w+}} [[sel_merge]] 1 [[bb3:%\w+]] ; CHECK: [[bb3]] = OpLabel ; CHECK-NEXT: OpBranch [[sel_merge]] ; CHECK: [[sel_merge]] = OpLabel ; CHECK-NEXT: OpBranch [[loop_merge]] ; CHECK: [[loop_merge]] = OpLabel ; CHECK-NEXT: OpReturn %main = OpFunction %void None %func_type %entry_bb = OpLabel OpBranch %loop_header %loop_header = OpLabel OpLoopMerge %loop_merge %cont None OpBranch %bb1 %bb1 = OpLabel OpSelectionMerge %sel_merge None OpBranchConditional %true %bb2 %bb4 %bb2 = OpLabel OpSwitch %undef_int %sel_merge 1 %bb3 %bb3 = OpLabel OpBranch %sel_merge %bb4 = OpLabel OpBranch %sel_merge %sel_merge = OpLabel OpBranch %loop_merge %cont = OpLabel OpBranch %loop_header %loop_merge = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(predefs + body, true); } TEST_F(DeadBranchElimTest, SelectionMergeWithExitToLoop) { // Checks that if a selection merge construct contains a conditional branch // to a loop surrounding the selection merge, then we do not keep the // OpSelectionMerge instruction. const std::string predefs = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 %void = OpTypeVoid %func_type = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %undef_bool = OpUndef %bool )"; const std::string body = R"( ; CHECK: OpLoopMerge [[loop_merge:%\w+]] ; CHECK-NEXT: OpBranch [[bb1:%\w+]] ; CHECK: [[bb1]] = OpLabel ; CHECK-NEXT: OpBranch [[bb2:%\w+]] ; CHECK: [[bb2]] = OpLabel ; CHECK-NEXT: OpBranchConditional {{%\w+}} [[bb3:%\w+]] [[loop_merge]] ; CHECK: [[bb3]] = OpLabel ; CHECK-NEXT: OpBranch [[sel_merge:%\w+]] ; CHECK: [[sel_merge]] = OpLabel ; CHECK-NEXT: OpBranch [[loop_merge]] ; CHECK: [[loop_merge]] = OpLabel ; CHECK-NEXT: OpReturn %main = OpFunction %void None %func_type %entry_bb = OpLabel OpBranch %loop_header %loop_header = OpLabel OpLoopMerge %loop_merge %cont None OpBranch %bb1 %bb1 = OpLabel OpSelectionMerge %sel_merge None OpBranchConditional %true %bb2 %bb4 %bb2 = OpLabel OpBranchConditional %undef_bool %bb3 %loop_merge %bb3 = OpLabel OpBranch %sel_merge %bb4 = OpLabel OpBranch %sel_merge %sel_merge = OpLabel OpBranch %loop_merge %cont = OpLabel OpBranch %loop_header %loop_merge = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(predefs + body, true); } TEST_F(DeadBranchElimTest, SelectionMergeWithExitToLoopContinue) { // Checks that if a selection merge construct contains a conditional branch // to continue of a loop surrounding the selection merge, then we do not keep // the OpSelectionMerge instruction. const std::string predefs = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 %void = OpTypeVoid %func_type = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %undef_bool = OpUndef %bool )"; const std::string body = R"(; ; CHECK: OpLabel ; CHECK: [[loop_header:%\w+]] = OpLabel ; CHECK: OpLoopMerge [[loop_merge:%\w+]] [[loop_cont:%\w+]] ; CHECK-NEXT: OpBranch [[bb1:%\w+]] ; CHECK: [[bb1]] = OpLabel ; CHECK-NEXT: OpBranch [[bb2:%\w+]] ; CHECK: [[bb2]] = OpLabel ; CHECK-NEXT: OpBranchConditional {{%\w+}} [[bb3:%\w+]] [[loop_cont]] ; CHECK: [[bb3]] = OpLabel ; CHECK-NEXT: OpBranch [[sel_merge:%\w+]] ; CHECK: [[sel_merge]] = OpLabel ; CHECK-NEXT: OpBranch [[loop_merge]] ; CHECK: [[loop_cont]] = OpLabel ; CHECK-NEXT: OpBranch [[loop_header]] ; CHECK: [[loop_merge]] = OpLabel ; CHECK-NEXT: OpReturn %main = OpFunction %void None %func_type %entry_bb = OpLabel OpBranch %loop_header %loop_header = OpLabel OpLoopMerge %loop_merge %cont None OpBranch %bb1 %bb1 = OpLabel OpSelectionMerge %sel_merge None OpBranchConditional %true %bb2 %bb4 %bb2 = OpLabel OpBranchConditional %undef_bool %bb3 %cont %bb3 = OpLabel OpBranch %sel_merge %bb4 = OpLabel OpBranch %sel_merge %sel_merge = OpLabel OpBranch %loop_merge %cont = OpLabel OpBranch %loop_header %loop_merge = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(predefs + body, true); } TEST_F(DeadBranchElimTest, SelectionMergeWithExitToLoop2) { // Same as |SelectionMergeWithExitToLoop|, except the switch goes to the loop // merge or the selection merge. In this case, we do not need an // OpSelectionMerge either. const std::string predefs = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 %void = OpTypeVoid %func_type = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %undef_bool = OpUndef %bool )"; const std::string body = R"( ; CHECK: OpLoopMerge [[loop_merge:%\w+]] ; CHECK-NEXT: OpBranch [[bb1:%\w+]] ; CHECK: [[bb1]] = OpLabel ; CHECK-NEXT: OpBranch [[bb2:%\w+]] ; CHECK: [[bb2]] = OpLabel ; CHECK-NEXT: OpBranchConditional {{%\w+}} [[sel_merge:%\w+]] [[loop_merge]] ; CHECK: [[sel_merge]] = OpLabel ; CHECK-NEXT: OpBranch [[loop_merge]] ; CHECK: [[loop_merge]] = OpLabel ; CHECK-NEXT: OpReturn %main = OpFunction %void None %func_type %entry_bb = OpLabel OpBranch %loop_header %loop_header = OpLabel OpLoopMerge %loop_merge %cont None OpBranch %bb1 %bb1 = OpLabel OpSelectionMerge %sel_merge None OpBranchConditional %true %bb2 %bb4 %bb2 = OpLabel OpBranchConditional %undef_bool %sel_merge %loop_merge %bb4 = OpLabel OpBranch %sel_merge %sel_merge = OpLabel OpBranch %loop_merge %cont = OpLabel OpBranch %loop_header %loop_merge = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(predefs + body, true); } TEST_F(DeadBranchElimTest, SelectionMergeWithExitToLoopContinue2) { // Same as |SelectionMergeWithExitToLoopContinue|, except the branch goes to // the loop continue or the selection merge. In this case, we do not need an // OpSelectionMerge either. const std::string predefs = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 %void = OpTypeVoid %func_type = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %undef_bool = OpUndef %bool )"; const std::string body = R"( ; CHECK: OpLabel ; CHECK: [[loop_header:%\w+]] = OpLabel ; CHECK: OpLoopMerge [[loop_merge:%\w+]] [[loop_cont:%\w+]] ; CHECK-NEXT: OpBranch [[bb1:%\w+]] ; CHECK: [[bb1]] = OpLabel ; CHECK-NEXT: OpBranch [[bb2:%\w+]] ; CHECK: [[bb2]] = OpLabel ; CHECK-NEXT: OpBranchConditional {{%\w+}} [[sel_merge:%\w+]] [[loop_cont]] ; CHECK: [[sel_merge]] = OpLabel ; CHECK-NEXT: OpBranch [[loop_merge]] ; CHECK: [[loop_cont]] = OpLabel ; CHECK: OpBranch [[loop_header]] ; CHECK: [[loop_merge]] = OpLabel ; CHECK-NEXT: OpReturn %main = OpFunction %void None %func_type %entry_bb = OpLabel OpBranch %loop_header %loop_header = OpLabel OpLoopMerge %loop_merge %cont None OpBranch %bb1 %bb1 = OpLabel OpSelectionMerge %sel_merge None OpBranchConditional %true %bb2 %bb4 %bb2 = OpLabel OpBranchConditional %undef_bool %sel_merge %cont %bb4 = OpLabel OpBranch %sel_merge %sel_merge = OpLabel OpBranch %loop_merge %cont = OpLabel OpBranch %loop_header %loop_merge = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(predefs + body, true); } TEST_F(DeadBranchElimTest, SelectionMergeWithExitToLoop3) { // Checks that if a selection merge construct contains a conditional branch // to the selection merge, and another block inside the selection merge, // then we must keep the OpSelectionMerge instruction on that branch. const std::string predefs = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 %void = OpTypeVoid %func_type = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %uint = OpTypeInt 32 0 %undef_int = OpUndef %uint %undef_bool = OpUndef %bool )"; const std::string body = R"( ; CHECK: OpLoopMerge [[loop_merge:%\w+]] ; CHECK-NEXT: OpBranch [[bb1:%\w+]] ; CHECK: [[bb1]] = OpLabel ; CHECK-NEXT: OpBranch [[bb2:%\w+]] ; CHECK: [[bb2]] = OpLabel ; CHECK-NEXT: OpSelectionMerge [[sel_merge:%\w+]] None ; CHECK-NEXT: OpBranchConditional {{%\w+}} [[sel_merge]] [[bb3:%\w+]] ; CHECK: [[bb3]] = OpLabel ; CHECK-NEXT: OpBranch [[sel_merge]] ; CHECK: [[sel_merge]] = OpLabel ; CHECK-NEXT: OpBranch [[loop_merge]] ; CHECK: [[loop_merge]] = OpLabel ; CHECK-NEXT: OpReturn %main = OpFunction %void None %func_type %entry_bb = OpLabel OpBranch %loop_header %loop_header = OpLabel OpLoopMerge %loop_merge %cont None OpBranch %bb1 %bb1 = OpLabel OpSelectionMerge %sel_merge None OpBranchConditional %true %bb2 %bb4 %bb2 = OpLabel ;OpSwitch %undef_int %sel_merge 0 %loop_merge 1 %bb3 OpBranchConditional %undef_bool %sel_merge %bb3 %bb3 = OpLabel OpBranch %sel_merge %bb4 = OpLabel OpBranch %sel_merge %sel_merge = OpLabel OpBranch %loop_merge %cont = OpLabel OpBranch %loop_header %loop_merge = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(predefs + body, true); } TEST_F(DeadBranchElimTest, SelectionMergeWithExitToLoopContinue3) { // Checks that if a selection merge construct contains a conditional branch // the selection merge, and another block inside the selection merge, then we // must keep the OpSelectionMerge instruction on that branch. const std::string predefs = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 %void = OpTypeVoid %func_type = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %uint = OpTypeInt 32 0 %undef_int = OpUndef %uint %undef_bool = OpUndef %bool )"; const std::string body = R"( ; CHECK: OpLabel ; CHECK: [[loop_header:%\w+]] = OpLabel ; CHECK: OpLoopMerge [[loop_merge:%\w+]] [[loop_continue:%\w+]] ; CHECK-NEXT: OpBranch [[bb1:%\w+]] ; CHECK: [[bb1]] = OpLabel ; CHECK-NEXT: OpBranch [[bb2:%\w+]] ; CHECK: [[bb2]] = OpLabel ; CHECK-NEXT: OpSelectionMerge [[sel_merge:%\w+]] None ; CHECK-NEXT: OpBranchConditional {{%\w+}} [[sel_merge]] [[bb3:%\w+]] ; CHECK: [[bb3]] = OpLabel ; CHECK-NEXT: OpBranch [[sel_merge]] ; CHECK: [[sel_merge]] = OpLabel ; CHECK-NEXT: OpBranch [[loop_merge]] ; CHECK: [[loop_continue]] = OpLabel ; CHECK-NEXT: OpBranch [[loop_header]] ; CHECK: [[loop_merge]] = OpLabel ; CHECK-NEXT: OpReturn %main = OpFunction %void None %func_type %entry_bb = OpLabel OpBranch %loop_header %loop_header = OpLabel OpLoopMerge %loop_merge %cont None OpBranch %bb1 %bb1 = OpLabel OpSelectionMerge %sel_merge None OpBranchConditional %true %bb2 %bb4 %bb2 = OpLabel OpBranchConditional %undef_bool %sel_merge %bb3 %bb3 = OpLabel OpBranch %sel_merge %bb4 = OpLabel OpBranch %sel_merge %sel_merge = OpLabel OpBranch %loop_merge %cont = OpLabel OpBranch %loop_header %loop_merge = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(predefs + body, true); } TEST_F(DeadBranchElimTest, SelectionMergeSameAsLoopContinue) { // Same as |SelectionMergeWithExitToLoopContinue|, except the branch in the // selection construct is an |OpSwitch| instead of an |OpConditionalBranch|. // The OpSelectionMerge instruction is not needed in this case either. const std::string predefs = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 %void = OpTypeVoid %func_type = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %uint = OpTypeInt 32 0 %undef_bool = OpUndef %bool )"; const std::string body = R"( ; CHECK: OpLabel ; CHECK: [[loop_header:%\w+]] = OpLabel ; CHECK: OpLoopMerge [[loop_merge:%\w+]] [[loop_cont:%\w+]] ; CHECK-NEXT: OpBranch [[bb1:%\w+]] ; CHECK: [[bb1]] = OpLabel ; CHECK-NEXT: OpBranch [[bb2:%\w+]] ; CHECK: [[bb2]] = OpLabel ; CHECK-NEXT: OpSelectionMerge [[loop_cont]] ; CHECK-NEXT: OpBranchConditional {{%\w+}} [[bb3:%\w+]] [[loop_cont]] ; CHECK: [[bb3]] = OpLabel ; CHECK-NEXT: OpBranch [[loop_cont]] ; CHECK: [[loop_cont]] = OpLabel ; CHECK-NEXT: OpBranchConditional {{%\w+}} [[loop_header]] [[loop_merge]] ; CHECK: [[loop_merge]] = OpLabel ; CHECK-NEXT: OpReturn %main = OpFunction %void None %func_type %entry_bb = OpLabel OpBranch %loop_header %loop_header = OpLabel OpLoopMerge %loop_merge %cont None OpBranch %bb1 %bb1 = OpLabel OpSelectionMerge %cont None OpBranchConditional %true %bb2 %bb4 %bb2 = OpLabel OpBranchConditional %undef_bool %bb3 %cont %bb3 = OpLabel OpBranch %cont %bb4 = OpLabel OpBranch %cont %cont = OpLabel OpBranchConditional %undef_bool %loop_header %loop_merge %loop_merge = OpLabel OpReturn OpFunctionEnd )"; // The selection merge in the loop naming the continue target as merge is // invalid, but handled by this pass so validation is disabled. SinglePassRunAndMatch(predefs + body, false); } TEST_F(DeadBranchElimTest, SelectionMergeWithNestedLoop) { const std::string body = R"( ; CHECK: OpSelectionMerge [[merge1:%\w+]] ; CHECK: [[merge1]] = OpLabel ; CHECK-NEXT: OpBranch [[preheader:%\w+]] ; CHECK: [[preheader]] = OpLabel ; CHECK-NOT: OpLabel ; CHECK: OpBranch [[header:%\w+]] ; CHECK: [[header]] = OpLabel ; CHECK-NOT: OpLabel ; CHECK: OpLoopMerge [[merge2:%\w+]] ; CHECK: [[merge2]] = OpLabel ; CHECK-NEXT: OpUnreachable OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %h "h" OpName %i "i" %void = OpTypeVoid %3 = OpTypeFunction %void %bool = OpTypeBool %_ptr_Function_bool = OpTypePointer Function %bool %true = OpConstantTrue %bool %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_1 = OpConstant %int 1 %int_0 = OpConstant %int 0 %27 = OpUndef %bool %main = OpFunction %void None %3 %5 = OpLabel %h = OpVariable %_ptr_Function_bool Function %i = OpVariable %_ptr_Function_int Function OpSelectionMerge %11 None OpBranchConditional %27 %10 %11 %10 = OpLabel OpBranch %11 %11 = OpLabel OpSelectionMerge %14 None OpBranchConditional %true %13 %14 %13 = OpLabel OpStore %i %int_1 OpBranch %19 %19 = OpLabel OpLoopMerge %21 %22 None OpBranch %23 %23 = OpLabel %26 = OpSGreaterThan %bool %int_1 %int_0 OpBranchConditional %true %20 %21 %20 = OpLabel OpBranch %22 %22 = OpLabel OpBranch %19 %21 = OpLabel OpBranch %14 %14 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(body, true); } TEST_F(DeadBranchElimTest, DontFoldBackedge) { const std::string body = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft %void = OpTypeVoid %4 = OpTypeFunction %void %bool = OpTypeBool %false = OpConstantFalse %bool %2 = OpFunction %void None %4 %7 = OpLabel OpBranch %8 %8 = OpLabel OpLoopMerge %9 %10 None OpBranch %11 %11 = OpLabel %12 = OpUndef %bool OpSelectionMerge %10 None OpBranchConditional %12 %13 %10 %13 = OpLabel OpBranch %9 %10 = OpLabel OpBranch %14 %14 = OpLabel OpBranchConditional %false %8 %9 %9 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(body, body, true); } TEST_F(DeadBranchElimTest, FoldBackedgeToHeader) { const std::string body = R"( ; CHECK: OpLabel ; CHECK: [[header:%\w+]] = OpLabel ; CHECK-NEXT: OpLoopMerge {{%\w+}} [[cont:%\w+]] ; CHECK: [[cont]] = OpLabel ; This branch may not be in the continue block, but must come after it. ; CHECK: OpBranch [[header]] OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft %void = OpTypeVoid %4 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %2 = OpFunction %void None %4 %7 = OpLabel OpBranch %8 %8 = OpLabel OpLoopMerge %9 %10 None OpBranch %11 %11 = OpLabel %12 = OpUndef %bool OpSelectionMerge %10 None OpBranchConditional %12 %13 %10 %13 = OpLabel OpBranch %9 %10 = OpLabel OpBranch %14 %14 = OpLabel OpBranchConditional %true %8 %9 %9 = OpLabel OpReturn OpFunctionEnd )"; // The selection merge in the loop naming the continue target as merge is // invalid, but handled by this pass so validation is disabled. SinglePassRunAndMatch(body, false); } TEST_F(DeadBranchElimTest, UnreachableMergeAndContinueSameBlock) { const std::string spirv = R"( ; CHECK: OpLabel ; CHECK: [[outer:%\w+]] = OpLabel ; CHECK-NEXT: OpLoopMerge [[outer_merge:%\w+]] [[outer_cont:%\w+]] None ; CHECK-NEXT: OpBranch [[inner:%\w+]] ; CHECK: [[inner]] = OpLabel ; CHECK: OpLoopMerge [[inner_merge:%\w+]] [[inner_cont:%\w+]] None ; CHECK: [[inner_cont]] = OpLabel ; CHECK-NEXT: OpBranch [[inner]] ; CHECK: [[inner_merge]] = OpLabel ; CHECK-NEXT: OpUnreachable ; CHECK: [[outer_cont]] = OpLabel ; CHECK-NEXT: OpBranch [[outer]] ; CHECK: [[outer_merge]] = OpLabel ; CHECK-NEXT: OpUnreachable OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpBranch %outer_loop %outer_loop = OpLabel OpLoopMerge %outer_merge %outer_continue None OpBranch %inner_loop %inner_loop = OpLabel OpLoopMerge %inner_merge %inner_continue None OpBranch %inner_body %inner_body = OpLabel OpSelectionMerge %inner_continue None OpBranchConditional %true %ret %inner_continue %ret = OpLabel OpReturn %inner_continue = OpLabel OpBranchConditional %true %inner_merge %inner_loop %inner_merge = OpLabel OpBranch %outer_continue %outer_continue = OpLabel OpBranchConditional %true %outer_merge %outer_loop %outer_merge = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(spirv, true); } // Fold a switch with a nested break. The only case should be the default. TEST_F(DeadBranchElimTest, FoldSwitchWithNestedBreak) { const std::string spirv = R"( ; CHECK: OpSwitch %int_3 [[case_bb:%\w+]]{{[[:space:]]}} ; CHECK: [[case_bb]] = OpLabel ; CHECK-NEXT: OpUndef ; CHECK-NEXT: OpSelectionMerge OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %2 "main" OpSource GLSL 450 %void = OpTypeVoid %4 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_3 = OpConstant %int 3 %int_1 = OpConstant %int 1 %bool = OpTypeBool %2 = OpFunction %void None %4 %10 = OpLabel OpSelectionMerge %11 None OpSwitch %int_3 %12 3 %13 %12 = OpLabel OpBranch %11 %13 = OpLabel %14 = OpUndef %bool OpSelectionMerge %15 None OpBranchConditional %14 %16 %15 %16 = OpLabel OpBranch %11 %15 = OpLabel OpBranch %11 %11 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(spirv, true); } TEST_F(DeadBranchElimTest, FoldBranchWithBreakToSwitch) { const std::string spirv = R"( ; CHECK: OpSelectionMerge [[sel_merge:%\w+]] ; CHECK-NEXT: OpSwitch {{%\w+}} {{%\w+}} 3 [[bb:%\w+]] ; CHECK: [[bb]] = OpLabel ; CHECK-NEXT: OpBranch [[bb2:%\w+]] ; CHECK: [[bb2]] = OpLabel ; CHECK-NOT: OpSelectionMerge ; CHECK: OpFunctionEnd OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %2 "main" OpSource GLSL 450 %void = OpTypeVoid %4 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_3 = OpConstant %int 3 %int_1 = OpConstant %int 1 %bool = OpTypeBool %true = OpConstantTrue %bool %2 = OpFunction %void None %4 %10 = OpLabel %undef_int = OpUndef %int OpSelectionMerge %11 None OpSwitch %undef_int %12 3 %13 %12 = OpLabel OpBranch %11 %13 = OpLabel OpSelectionMerge %15 None OpBranchConditional %true %16 %15 %16 = OpLabel %14 = OpUndef %bool OpBranchConditional %14 %11 %17 %17 = OpLabel OpBranch %15 %15 = OpLabel OpBranch %11 %11 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(spirv, true); } TEST_F(DeadBranchElimTest, IfInSwitch) { // #version 310 es // // void main() // { // switch(0) // { // case 0: // if(false) // { // } // else // { // } // } // } const std::string before = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %bool = OpTypeBool %false = OpConstantFalse %bool %main = OpFunction %void None %3 %5 = OpLabel OpSelectionMerge %9 None OpSwitch %int_0 %9 0 %8 %8 = OpLabel OpSelectionMerge %13 None OpBranchConditional %false %12 %13 %12 = OpLabel OpBranch %13 %13 = OpLabel OpBranch %9 %9 = OpLabel OpReturn OpFunctionEnd )"; const std::string after = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" %void = OpTypeVoid %4 = OpTypeFunction %void %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %bool = OpTypeBool %false = OpConstantFalse %bool %main = OpFunction %void None %4 %9 = OpLabel OpBranch %11 %11 = OpLabel OpBranch %12 %12 = OpLabel OpBranch %10 %10 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(before, after, true, true); } TEST_F(DeadBranchElimTest, BreakInNestedHeaderWithSingleCase) { const std::string text = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" %void = OpTypeVoid %4 = OpTypeFunction %void %bool = OpTypeBool %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %8 = OpUndef %bool %main = OpFunction %void None %4 %9 = OpLabel OpSelectionMerge %10 None OpSwitch %uint_0 %11 %11 = OpLabel OpSelectionMerge %12 None OpBranchConditional %8 %10 %12 %12 = OpLabel OpBranch %10 %10 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(text, text, true, true); } TEST_F(DeadBranchElimTest, BreakInNestedHeaderWithTwoCases) { const std::string text = R"( ; CHECK: OpSelectionMerge [[merge:%\w+]] None ; CHECK-NEXT: OpSwitch %uint_0 [[bb:%\w+\n]] OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" %void = OpTypeVoid %4 = OpTypeFunction %void %bool = OpTypeBool %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %8 = OpUndef %bool %main = OpFunction %void None %4 %9 = OpLabel OpSelectionMerge %10 None OpSwitch %uint_0 %11 1 %12 %11 = OpLabel OpSelectionMerge %13 None OpBranchConditional %8 %10 %13 %13 = OpLabel OpBranch %10 %12 = OpLabel OpBranch %10 %10 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(DeadBranchElimTest, DebugInformation) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" %ext = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 %name = OpString "test" OpName %main "main" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %5 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %float_0 = OpConstant %float 0 ; CHECK: [[value:%\w+]] = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %12 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %float_1 = OpConstant %float 1 %14 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output %_ptr_Input_v4float = OpTypePointer Input %v4float %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %null_expr = OpExtInst %void %ext DebugExpression %src = OpExtInst %void %ext DebugSource %name %cu = OpExtInst %void %ext DebugCompilationUnit 1 4 %src HLSL %ty = OpExtInst %void %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %void %dbg_main = OpExtInst %void %ext DebugFunction %name %ty %src 0 0 %cu %name FlagIsProtected|FlagIsPrivate 0 %main ; CHECK: [[bb1:%\w+]] = OpExtInst %void [[ext:%\w+]] DebugLexicalBlock [[src:%\w+]] 1 0 [[dbg_main:%\w+]] ; CHECK: [[bb2:%\w+]] = OpExtInst %void [[ext]] DebugLexicalBlock [[src]] 2 0 [[dbg_main]] ; CHECK: [[bb3:%\w+]] = OpExtInst %void [[ext]] DebugLexicalBlock [[src]] 3 0 [[dbg_main]] %bb1 = OpExtInst %void %ext DebugLexicalBlock %src 1 0 %dbg_main %bb2 = OpExtInst %void %ext DebugLexicalBlock %src 2 0 %dbg_main %bb3 = OpExtInst %void %ext DebugLexicalBlock %src 3 0 %dbg_main %dbg_f = OpExtInst %void %ext DebugTypeBasic %name %uint_32 Float ; CHECK: [[dbg_foo:%\w+]] = OpExtInst %void [[ext]] DebugLocalVariable {{%\w+}} [[ty:%\w+]] [[src]] 0 0 [[dbg_main]] %dbg_foo = OpExtInst %void %ext DebugLocalVariable %name %dbg_f %src 0 0 %dbg_main FlagIsLocal ; CHECK: [[dbg_bar:%\w+]] = OpExtInst %void [[ext]] DebugLocalVariable {{%\w+}} [[ty]] [[src]] 1 0 [[bb3]] %dbg_bar = OpExtInst %void %ext DebugLocalVariable %name %dbg_f %src 1 0 %bb3 FlagIsLocal %main = OpFunction %void None %5 %17 = OpLabel ; CHECK-NOT: DebugScope [[dbg_main]] ; CHECK-NOT: OpLine {{%\w+}} 0 0 %scope0 = OpExtInst %void %ext DebugScope %dbg_main OpLine %name 0 0 OpSelectionMerge %18 None OpBranchConditional %true %19 %20 %19 = OpLabel ; CHECK: DebugScope [[bb1]] ; CHECK: OpLine {{%\w+}} 1 0 %scope1 = OpExtInst %void %ext DebugScope %bb1 OpLine %name 1 0 OpBranch %18 %20 = OpLabel ; CHECK-NOT: DebugScope [[bb2]] ; CHECK-NOT: OpLine {{%\w+}} 2 0 %scope2 = OpExtInst %void %ext DebugScope %bb2 OpLine %name 2 0 OpBranch %18 %18 = OpLabel ; CHECK: DebugScope [[bb3]] ; CHECK: OpLine {{%\w+}} 3 0 ; CHECK: DebugValue [[dbg_foo]] [[value]] ; CHECK: OpLine {{%\w+}} 4 0 ; CHECK: OpStore %gl_FragColor [[value]] ; CHECK: DebugDeclare [[dbg_bar]] %gl_FragColor ; CHECK: DebugValue [[dbg_bar]] [[value]] %scope3 = OpExtInst %void %ext DebugScope %bb3 OpLine %name 3 0 %21 = OpPhi %v4float %12 %19 %14 %20 %decl0 = OpExtInst %void %ext DebugValue %dbg_foo %21 %null_expr OpLine %name 4 0 OpStore %gl_FragColor %21 %decl1 = OpExtInst %void %ext DebugDeclare %dbg_bar %gl_FragColor %null_expr %decl2 = OpExtInst %void %ext DebugValue %dbg_bar %21 %null_expr OpLine %name 5 0 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(DeadBranchElimTest, DontTransferDecorations) { // When replacing %4 with %14, we don't want %14 to inherit %4's decorations. const std::string text = R"( ; CHECK-NOT: OpDecorate {{%\w+}} RelaxedPrecision ; CHECK: [[div:%\w+]] = OpFDiv ; CHECK: {{%\w+}} = OpCopyObject %float [[div]] OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft %3 = OpString "STEVEN" OpDecorate %4 RelaxedPrecision %float = OpTypeFloat 32 %uint = OpTypeInt 32 0 %void = OpTypeVoid %float_1 = OpConstant %float 1 %uint_0 = OpConstant %uint 0 %10 = OpTypeFunction %void %2 = OpFunction %void None %10 %11 = OpLabel OpSelectionMerge %12 None OpSwitch %uint_0 %13 %13 = OpLabel %14 = OpFDiv %float %float_1 %float_1 OpLine %3 0 0 OpBranch %12 %15 = OpLabel OpBranch %12 %12 = OpLabel %4 = OpPhi %float %float_1 %15 %14 %13 %16 = OpCopyObject %float %4 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(DeadBranchElimTest, FunctionDeclaration) { // Make sure the pass works with a function declaration that is called. const std::string text = R"(OpCapability Addresses OpCapability Linkage OpCapability Kernel OpCapability Int8 %1 = OpExtInstImport "OpenCL.std" OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %2 "_Z23julia__1166_kernel_77094Bool" OpExecutionMode %2 ContractionOff OpSource Unknown 0 OpDecorate %3 LinkageAttributes "julia_error_7712" Import %void = OpTypeVoid %5 = OpTypeFunction %void %3 = OpFunction %void None %5 OpFunctionEnd %2 = OpFunction %void None %5 %6 = OpLabel %7 = OpFunctionCall %void %3 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(text, text, false); } // TODO(greg-lunarg): Add tests to verify handling of these cases: // // More complex control flow // Others? } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/dead_insert_elim_test.cpp000066400000000000000000000636721475742701700253620ustar00rootroot00000000000000// Copyright (c) 2017 Valve Corporation // Copyright (c) 2017 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using DeadInsertElimTest = PassTest<::testing::Test>; TEST_F(DeadInsertElimTest, InsertAfterInsertElim) { // With two insertions to the same offset, the first is dead. // // Note: The SPIR-V assembly has had store/load elimination // performed to allow the inserts and extracts to directly // reference each other. // // #version 450 // // layout (location=0) in float In0; // layout (location=1) in float In1; // layout (location=2) in vec2 In2; // layout (location=0) out vec4 OutColor; // // void main() // { // vec2 v = In2; // v.x = In0 + In1; // dead // v.x = 0.0; // OutColor = v.xyxy; // } const std::string before_predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %In2 %In0 %In1 %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %In2 "In2" OpName %In0 "In0" OpName %In1 "In1" OpName %OutColor "OutColor" OpName %_Globals_ "_Globals_" OpMemberName %_Globals_ 0 "g_b" OpMemberName %_Globals_ 1 "g_n" OpName %_ "" OpDecorate %In2 Location 2 OpDecorate %In0 Location 0 OpDecorate %In1 Location 1 OpDecorate %OutColor Location 0 OpMemberDecorate %_Globals_ 0 Offset 0 OpMemberDecorate %_Globals_ 1 Offset 4 OpDecorate %_Globals_ Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %11 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %_ptr_Function_v2float = OpTypePointer Function %v2float %_ptr_Input_v2float = OpTypePointer Input %v2float %In2 = OpVariable %_ptr_Input_v2float Input %_ptr_Input_float = OpTypePointer Input %float %In0 = OpVariable %_ptr_Input_float Input %In1 = OpVariable %_ptr_Input_float Input %uint = OpTypeInt 32 0 %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %int = OpTypeInt 32 1 %_Globals_ = OpTypeStruct %uint %int %_ptr_Uniform__Globals_ = OpTypePointer Uniform %_Globals_ %_ = OpVariable %_ptr_Uniform__Globals_ Uniform )"; const std::string after_predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %In2 %In0 %In1 %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %In2 "In2" OpName %In0 "In0" OpName %In1 "In1" OpName %OutColor "OutColor" OpName %_Globals_ "_Globals_" OpMemberName %_Globals_ 0 "g_b" OpMemberName %_Globals_ 1 "g_n" OpName %_ "" OpDecorate %In2 Location 2 OpDecorate %In0 Location 0 OpDecorate %In1 Location 1 OpDecorate %OutColor Location 0 OpMemberDecorate %_Globals_ 0 Offset 0 OpMemberDecorate %_Globals_ 1 Offset 4 OpDecorate %_Globals_ Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %10 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %_ptr_Function_v2float = OpTypePointer Function %v2float %_ptr_Input_v2float = OpTypePointer Input %v2float %In2 = OpVariable %_ptr_Input_v2float Input %_ptr_Input_float = OpTypePointer Input %float %In0 = OpVariable %_ptr_Input_float Input %In1 = OpVariable %_ptr_Input_float Input %uint = OpTypeInt 32 0 %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %int = OpTypeInt 32 1 %_Globals_ = OpTypeStruct %uint %int %_ptr_Uniform__Globals_ = OpTypePointer Uniform %_Globals_ %_ = OpVariable %_ptr_Uniform__Globals_ Uniform )"; const std::string before = R"(%main = OpFunction %void None %11 %25 = OpLabel %26 = OpLoad %v2float %In2 %27 = OpLoad %float %In0 %28 = OpLoad %float %In1 %29 = OpFAdd %float %27 %28 %35 = OpCompositeInsert %v2float %29 %26 0 %37 = OpCompositeInsert %v2float %float_0 %35 0 %33 = OpVectorShuffle %v4float %37 %37 0 1 0 1 OpStore %OutColor %33 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %10 %23 = OpLabel %24 = OpLoad %v2float %In2 %29 = OpCompositeInsert %v2float %float_0 %24 0 %30 = OpVectorShuffle %v4float %29 %29 0 1 0 1 OpStore %OutColor %30 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(before_predefs + before, after_predefs + after, true, true); } TEST_F(DeadInsertElimTest, DeadInsertForLinkage) { const std::string before = R"(OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpSource HLSL 630 OpName %main "main" OpName %BaseColor "BaseColor" OpName %bb_entry "bb.entry" OpName %v "v" OpDecorate %main LinkageAttributes "main" Export %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %v2float = OpTypeVector %float 2 %_ptr_Function_v2float = OpTypePointer Function %v2float %14 = OpTypeFunction %v2float %_ptr_Function_v2float %_ptr_Function_float = OpTypePointer Function %float %main = OpFunction %v2float None %14 %BaseColor = OpFunctionParameter %_ptr_Function_v2float %bb_entry = OpLabel %v = OpVariable %_ptr_Function_v2float Function %16 = OpLoad %v2float %v %17 = OpAccessChain %_ptr_Function_float %BaseColor %int_1 %18 = OpLoad %float %17 %19 = OpCompositeInsert %v2float %18 %16 0 %20 = OpCompositeInsert %v2float %float_0 %19 0 OpReturnValue %20 OpFunctionEnd )"; const std::string after = R"(OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpSource HLSL 630 OpName %main "main" OpName %BaseColor "BaseColor" OpName %bb_entry "bb.entry" OpName %v "v" OpDecorate %main LinkageAttributes "main" Export %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %v2float = OpTypeVector %float 2 %_ptr_Function_v2float = OpTypePointer Function %v2float %14 = OpTypeFunction %v2float %_ptr_Function_v2float %_ptr_Function_float = OpTypePointer Function %float %main = OpFunction %v2float None %14 %BaseColor = OpFunctionParameter %_ptr_Function_v2float %bb_entry = OpLabel %v = OpVariable %_ptr_Function_v2float Function %16 = OpLoad %v2float %v %20 = OpCompositeInsert %v2float %float_0 %16 0 OpReturnValue %20 OpFunctionEnd )"; SinglePassRunAndCheck(before, after, true, true); } TEST_F(DeadInsertElimTest, DeadInsertInChainWithPhi) { // Dead insert eliminated with phi in insertion chain. // // Note: The SPIR-V assembly has had store/load elimination // performed to allow the inserts and extracts to directly // reference each other. // // #version 450 // // layout (location=0) in vec4 In0; // layout (location=1) in float In1; // layout (location=2) in float In2; // layout (location=0) out vec4 OutColor; // // layout(std140, binding = 0 ) uniform _Globals_ // { // bool g_b; // }; // // void main() // { // vec4 v = In0; // v.z = In1 + In2; // if (g_b) v.w = 1.0; // OutColor = vec4(v.x,v.y,0.0,v.w); // } const std::string before_predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %In0 %In1 %In2 %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %In0 "In0" OpName %In1 "In1" OpName %In2 "In2" OpName %_Globals_ "_Globals_" OpMemberName %_Globals_ 0 "g_b" OpName %_ "" OpName %OutColor "OutColor" OpDecorate %In0 Location 0 OpDecorate %In1 Location 1 OpDecorate %In2 Location 2 OpMemberDecorate %_Globals_ 0 Offset 0 OpDecorate %_Globals_ Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %OutColor Location 0 %void = OpTypeVoid %11 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %In0 = OpVariable %_ptr_Input_v4float Input %_ptr_Input_float = OpTypePointer Input %float %In1 = OpVariable %_ptr_Input_float Input %In2 = OpVariable %_ptr_Input_float Input %uint = OpTypeInt 32 0 %_ptr_Function_float = OpTypePointer Function %float %_Globals_ = OpTypeStruct %uint %_ptr_Uniform__Globals_ = OpTypePointer Uniform %_Globals_ %_ = OpVariable %_ptr_Uniform__Globals_ Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %bool = OpTypeBool %uint_0 = OpConstant %uint 0 %float_1 = OpConstant %float 1 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %float_0 = OpConstant %float 0 )"; const std::string after_predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %In0 %In1 %In2 %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %In0 "In0" OpName %In1 "In1" OpName %In2 "In2" OpName %_Globals_ "_Globals_" OpMemberName %_Globals_ 0 "g_b" OpName %_ "" OpName %OutColor "OutColor" OpDecorate %In0 Location 0 OpDecorate %In1 Location 1 OpDecorate %In2 Location 2 OpMemberDecorate %_Globals_ 0 Offset 0 OpDecorate %_Globals_ Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %OutColor Location 0 %void = OpTypeVoid %10 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %In0 = OpVariable %_ptr_Input_v4float Input %_ptr_Input_float = OpTypePointer Input %float %In1 = OpVariable %_ptr_Input_float Input %In2 = OpVariable %_ptr_Input_float Input %uint = OpTypeInt 32 0 %_ptr_Function_float = OpTypePointer Function %float %_Globals_ = OpTypeStruct %uint %_ptr_Uniform__Globals_ = OpTypePointer Uniform %_Globals_ %_ = OpVariable %_ptr_Uniform__Globals_ Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %bool = OpTypeBool %uint_0 = OpConstant %uint 0 %float_1 = OpConstant %float 1 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %float_0 = OpConstant %float 0 )"; const std::string before = R"(%main = OpFunction %void None %11 %31 = OpLabel %32 = OpLoad %v4float %In0 %33 = OpLoad %float %In1 %34 = OpLoad %float %In2 %35 = OpFAdd %float %33 %34 %51 = OpCompositeInsert %v4float %35 %32 2 %37 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %38 = OpLoad %uint %37 %39 = OpINotEqual %bool %38 %uint_0 OpSelectionMerge %40 None OpBranchConditional %39 %41 %40 %41 = OpLabel %53 = OpCompositeInsert %v4float %float_1 %51 3 OpBranch %40 %40 = OpLabel %60 = OpPhi %v4float %51 %31 %53 %41 %55 = OpCompositeExtract %float %60 0 %57 = OpCompositeExtract %float %60 1 %59 = OpCompositeExtract %float %60 3 %49 = OpCompositeConstruct %v4float %55 %57 %float_0 %59 OpStore %OutColor %49 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %10 %27 = OpLabel %28 = OpLoad %v4float %In0 %33 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %34 = OpLoad %uint %33 %35 = OpINotEqual %bool %34 %uint_0 OpSelectionMerge %36 None OpBranchConditional %35 %37 %36 %37 = OpLabel %38 = OpCompositeInsert %v4float %float_1 %28 3 OpBranch %36 %36 = OpLabel %39 = OpPhi %v4float %28 %27 %38 %37 %40 = OpCompositeExtract %float %39 0 %41 = OpCompositeExtract %float %39 1 %42 = OpCompositeExtract %float %39 3 %43 = OpCompositeConstruct %v4float %40 %41 %float_0 %42 OpStore %OutColor %43 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(before_predefs + before, after_predefs + after, true, true); } TEST_F(DeadInsertElimTest, DeadInsertTwoPasses) { // Dead insert which requires two passes to eliminate // // Note: The SPIR-V assembly has had store/load elimination // performed to allow the inserts and extracts to directly // reference each other. // // #version 450 // // layout (location=0) in vec4 In0; // layout (location=1) in float In1; // layout (location=2) in float In2; // layout (location=0) out vec4 OutColor; // // layout(std140, binding = 0 ) uniform _Globals_ // { // bool g_b; // bool g_b2; // }; // // void main() // { // vec4 v1, v2; // v1 = In0; // v1.y = In1 + In2; // dead, second pass // if (g_b) v1.x = 1.0; // v2.x = v1.x; // v2.y = v1.y; // dead, first pass // if (g_b2) v2.x = 0.0; // OutColor = vec4(v2.x,v2.x,0.0,1.0); // } const std::string before_predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %In0 %In1 %In2 %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %In0 "In0" OpName %In1 "In1" OpName %In2 "In2" OpName %_Globals_ "_Globals_" OpMemberName %_Globals_ 0 "g_b" OpMemberName %_Globals_ 1 "g_b2" OpName %_ "" OpName %OutColor "OutColor" OpDecorate %In0 Location 0 OpDecorate %In1 Location 1 OpDecorate %In2 Location 2 OpMemberDecorate %_Globals_ 0 Offset 0 OpMemberDecorate %_Globals_ 1 Offset 4 OpDecorate %_Globals_ Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %OutColor Location 0 %void = OpTypeVoid %10 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %In0 = OpVariable %_ptr_Input_v4float Input %_ptr_Input_float = OpTypePointer Input %float %In1 = OpVariable %_ptr_Input_float Input %In2 = OpVariable %_ptr_Input_float Input %uint = OpTypeInt 32 0 %_Globals_ = OpTypeStruct %uint %uint %_ptr_Uniform__Globals_ = OpTypePointer Uniform %_Globals_ %_ = OpVariable %_ptr_Uniform__Globals_ Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %bool = OpTypeBool %uint_0 = OpConstant %uint 0 %float_1 = OpConstant %float 1 %int_1 = OpConstant %int 1 %float_0 = OpConstant %float 0 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %27 = OpUndef %v4float )"; const std::string after_predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %In0 %In1 %In2 %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %In0 "In0" OpName %In1 "In1" OpName %In2 "In2" OpName %_Globals_ "_Globals_" OpMemberName %_Globals_ 0 "g_b" OpMemberName %_Globals_ 1 "g_b2" OpName %_ "" OpName %OutColor "OutColor" OpDecorate %In0 Location 0 OpDecorate %In1 Location 1 OpDecorate %In2 Location 2 OpMemberDecorate %_Globals_ 0 Offset 0 OpMemberDecorate %_Globals_ 1 Offset 4 OpDecorate %_Globals_ Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %OutColor Location 0 %void = OpTypeVoid %10 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %In0 = OpVariable %_ptr_Input_v4float Input %_ptr_Input_float = OpTypePointer Input %float %In1 = OpVariable %_ptr_Input_float Input %In2 = OpVariable %_ptr_Input_float Input %uint = OpTypeInt 32 0 %_Globals_ = OpTypeStruct %uint %uint %_ptr_Uniform__Globals_ = OpTypePointer Uniform %_Globals_ %_ = OpVariable %_ptr_Uniform__Globals_ Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %bool = OpTypeBool %uint_0 = OpConstant %uint 0 %float_1 = OpConstant %float 1 %int_1 = OpConstant %int 1 %float_0 = OpConstant %float 0 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %27 = OpUndef %v4float )"; const std::string before = R"(%main = OpFunction %void None %10 %28 = OpLabel %29 = OpLoad %v4float %In0 %30 = OpLoad %float %In1 %31 = OpLoad %float %In2 %32 = OpFAdd %float %30 %31 %33 = OpCompositeInsert %v4float %32 %29 1 %34 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %35 = OpLoad %uint %34 %36 = OpINotEqual %bool %35 %uint_0 OpSelectionMerge %37 None OpBranchConditional %36 %38 %37 %38 = OpLabel %39 = OpCompositeInsert %v4float %float_1 %33 0 OpBranch %37 %37 = OpLabel %40 = OpPhi %v4float %33 %28 %39 %38 %41 = OpCompositeExtract %float %40 0 %42 = OpCompositeInsert %v4float %41 %27 0 %43 = OpCompositeExtract %float %40 1 %44 = OpCompositeInsert %v4float %43 %42 1 %45 = OpAccessChain %_ptr_Uniform_uint %_ %int_1 %46 = OpLoad %uint %45 %47 = OpINotEqual %bool %46 %uint_0 OpSelectionMerge %48 None OpBranchConditional %47 %49 %48 %49 = OpLabel %50 = OpCompositeInsert %v4float %float_0 %44 0 OpBranch %48 %48 = OpLabel %51 = OpPhi %v4float %44 %37 %50 %49 %52 = OpCompositeExtract %float %51 0 %53 = OpCompositeExtract %float %51 0 %54 = OpCompositeConstruct %v4float %52 %53 %float_0 %float_1 OpStore %OutColor %54 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %10 %28 = OpLabel %29 = OpLoad %v4float %In0 %34 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %35 = OpLoad %uint %34 %36 = OpINotEqual %bool %35 %uint_0 OpSelectionMerge %37 None OpBranchConditional %36 %38 %37 %38 = OpLabel %39 = OpCompositeInsert %v4float %float_1 %29 0 OpBranch %37 %37 = OpLabel %40 = OpPhi %v4float %29 %28 %39 %38 %41 = OpCompositeExtract %float %40 0 %42 = OpCompositeInsert %v4float %41 %27 0 %45 = OpAccessChain %_ptr_Uniform_uint %_ %int_1 %46 = OpLoad %uint %45 %47 = OpINotEqual %bool %46 %uint_0 OpSelectionMerge %48 None OpBranchConditional %47 %49 %48 %49 = OpLabel %50 = OpCompositeInsert %v4float %float_0 %42 0 OpBranch %48 %48 = OpLabel %51 = OpPhi %v4float %42 %37 %50 %49 %52 = OpCompositeExtract %float %51 0 %53 = OpCompositeExtract %float %51 0 %54 = OpCompositeConstruct %v4float %52 %53 %float_0 %float_1 OpStore %OutColor %54 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(before_predefs + before, after_predefs + after, true, true); } TEST_F(DeadInsertElimTest, DebugInsertAfterInsertElim) { // With two insertions to the same offset, the first is dead. // // Note: The SPIR-V assembly has had store/load elimination // performed to allow the inserts and extracts to directly // reference each other. // // #version 450 // // layout (location=0) in float In0; // layout (location=1) in float In1; // layout (location=2) in vec2 In2; // layout (location=0) out vec4 OutColor; // // void main() // { // vec2 v = In2; // v.x = In0 + In1; // dead // v.x = 0.0; // OutColor = v.xyxy; // } const std::string text = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" %ext = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %In2 %In0 %In1 %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 %file_name = OpString "test" %float_name = OpString "float" %main_name = OpString "main" %f_name = OpString "f" OpName %main "main" OpName %In2 "In2" OpName %In0 "In0" OpName %In1 "In1" OpName %OutColor "OutColor" OpName %_Globals_ "_Globals_" OpMemberName %_Globals_ 0 "g_b" OpMemberName %_Globals_ 1 "g_n" OpName %_ "" OpDecorate %In2 Location 2 OpDecorate %In0 Location 0 OpDecorate %In1 Location 1 OpDecorate %OutColor Location 0 OpMemberDecorate %_Globals_ 0 Offset 0 OpMemberDecorate %_Globals_ 1 Offset 4 OpDecorate %_Globals_ Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %11 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %_ptr_Function_v2float = OpTypePointer Function %v2float %_ptr_Input_v2float = OpTypePointer Input %v2float %In2 = OpVariable %_ptr_Input_v2float Input %_ptr_Input_float = OpTypePointer Input %float %In0 = OpVariable %_ptr_Input_float Input %In1 = OpVariable %_ptr_Input_float Input %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %int = OpTypeInt 32 1 %_Globals_ = OpTypeStruct %uint %int %_ptr_Uniform__Globals_ = OpTypePointer Uniform %_Globals_ %_ = OpVariable %_ptr_Uniform__Globals_ Uniform %nullexpr = OpExtInst %void %ext DebugExpression %src = OpExtInst %void %ext DebugSource %file_name %cu = OpExtInst %void %ext DebugCompilationUnit 1 4 %src HLSL %dbg_tf = OpExtInst %void %ext DebugTypeBasic %float_name %uint_32 Float %dbg_v2f = OpExtInst %void %ext DebugTypeVector %dbg_tf 2 %main_ty = OpExtInst %void %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %void %dbg_main = OpExtInst %void %ext DebugFunction %main_name %main_ty %src 0 0 %cu %main_name FlagIsProtected|FlagIsPrivate 0 %main %dbg_foo = OpExtInst %void %ext DebugLocalVariable %f_name %dbg_v2f %src 0 0 %dbg_main FlagIsLocal %main = OpFunction %void None %11 %25 = OpLabel %26 = OpLoad %v2float %In2 %27 = OpLoad %float %In0 %28 = OpLoad %float %In1 %29 = OpFAdd %float %27 %28 ; CHECK: [[repl:%\w+]] = OpLoad %v2float %In2 ; CHECK-NOT: OpCompositeInsert ; CHECK: DebugValue {{%\w+}} [[repl:%\w+]] ; CHECK-NEXT: OpCompositeInsert %v2float %float_0 [[repl]] 0 %35 = OpCompositeInsert %v2float %29 %26 0 %value = OpExtInst %void %ext DebugValue %dbg_foo %35 %nullexpr %37 = OpCompositeInsert %v2float %float_0 %35 0 %33 = OpVectorShuffle %v4float %37 %37 0 1 0 1 OpStore %OutColor %33 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(DeadInsertElimTest, PhiOverEmptyStruct) { // Reproducer for nullptr access error in MarkInsertChain // that occurs when processing a phi operation with an // empty struct result type. // // Note: Disassembly created from HLSL source with // dxc -T cs_6_6 -spirv -Oconfig= // --eliminate-dead-branches,--merge-return,--ssa-rewrite // // RWBuffer buf; // // struct S { }; // // S fn() { // S s = (S)0; // if (buf[0] > 0) { // return s; // } // return s; // } // // [numthreads(1,1,1)] // void main() { // fn(); // } const std::string disassembly = R"(OpCapability Shader OpCapability SampledBuffer OpCapability ImageBuffer OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource HLSL 660 OpName %S "S" OpName %type_buffer_image "type.buffer.image" OpName %buf "buf" OpName %main "main" OpName %src_main "src.main" OpName %bb_entry "bb.entry" OpName %fn "fn" OpName %bb_entry_0 "bb.entry" OpName %s "s" OpName %if_true "if.true" OpName %if_merge "if.merge" OpDecorate %buf DescriptorSet 0 OpDecorate %buf Binding 0 %S = OpTypeStruct %4 = OpConstantNull %S %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %type_buffer_image = OpTypeImage %float Buffer 2 0 0 2 R32f %_ptr_UniformConstant_type_buffer_image = OpTypePointer UniformConstant %type_buffer_image %void = OpTypeVoid %12 = OpTypeFunction %void %19 = OpTypeFunction %S %_ptr_Function_S = OpTypePointer Function %S %v4float = OpTypeVector %float 4 %bool = OpTypeBool %buf = OpVariable %_ptr_UniformConstant_type_buffer_image UniformConstant %false = OpConstantFalse %bool %_ptr_Function_bool = OpTypePointer Function %bool %true = OpConstantTrue %bool %main = OpFunction %void None %12 %13 = OpLabel %14 = OpFunctionCall %void %src_main OpReturn OpFunctionEnd %src_main = OpFunction %void None %12 %bb_entry = OpLabel %17 = OpFunctionCall %S %fn OpReturn OpFunctionEnd %fn = OpFunction %S None %19 %bb_entry_0 = OpLabel %39 = OpVariable %_ptr_Function_bool Function %false %34 = OpVariable %_ptr_Function_S Function %s = OpVariable %_ptr_Function_S Function OpSelectionMerge %33 None OpSwitch %uint_0 %36 %36 = OpLabel OpStore %s %4 %23 = OpLoad %type_buffer_image %buf %25 = OpImageRead %v4float %23 %uint_0 None %26 = OpCompositeExtract %float %25 0 %28 = OpFOrdGreaterThan %bool %26 %float_0 OpSelectionMerge %if_merge None OpBranchConditional %28 %if_true %if_merge %if_true = OpLabel OpStore %39 %true OpStore %34 %4 OpBranch %33 %if_merge = OpLabel OpStore %39 %true OpStore %34 %4 OpBranch %33 %33 = OpLabel %41 = OpPhi %S %4 %if_true %4 %if_merge OpReturnValue %41 OpFunctionEnd )"; // Used to crash with a nullptr access violation when processing %41 SinglePassRunToBinary(disassembly, true); } // TODO(greg-lunarg): Add tests to verify handling of these cases: // } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/dead_variable_elim_test.cpp000066400000000000000000000204001475742701700256210ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using DeadVariableElimTest = PassTest<::testing::Test>; // %dead is unused. Make sure we remove it along with its name. TEST_F(DeadVariableElimTest, RemoveUnreferenced) { const std::string before = R"(OpCapability Shader OpCapability Linkage %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 150 OpName %main "main" OpName %dead "dead" %void = OpTypeVoid %5 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Private_float = OpTypePointer Private %float %dead = OpVariable %_ptr_Private_float Private %main = OpFunction %void None %5 %8 = OpLabel OpReturn OpFunctionEnd )"; const std::string after = R"(OpCapability Shader OpCapability Linkage %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 150 OpName %main "main" %void = OpTypeVoid %5 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Private_float = OpTypePointer Private %float %main = OpFunction %void None %5 %8 = OpLabel OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(before, after, true, true); } // Since %dead is exported, make sure we keep it. It could be referenced // somewhere else. TEST_F(DeadVariableElimTest, KeepExported) { const std::string before = R"(OpCapability Shader OpCapability Linkage %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 150 OpName %main "main" OpName %dead "dead" OpDecorate %dead LinkageAttributes "dead" Export %void = OpTypeVoid %5 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Private_float = OpTypePointer Private %float %dead = OpVariable %_ptr_Private_float Private %main = OpFunction %void None %5 %8 = OpLabel OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(before, before, true, true); } // Delete %dead because it is unreferenced. Then %initializer becomes // unreferenced, so remove it as well. TEST_F(DeadVariableElimTest, RemoveUnreferencedWithInit1) { const std::string before = R"(OpCapability Shader OpCapability Linkage %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 150 OpName %main "main" OpName %dead "dead" OpName %initializer "initializer" %void = OpTypeVoid %6 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Private_float = OpTypePointer Private %float %initializer = OpVariable %_ptr_Private_float Private %dead = OpVariable %_ptr_Private_float Private %initializer %main = OpFunction %void None %6 %9 = OpLabel OpReturn OpFunctionEnd )"; const std::string after = R"(OpCapability Shader OpCapability Linkage %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 150 OpName %main "main" %void = OpTypeVoid %6 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Private_float = OpTypePointer Private %float %main = OpFunction %void None %6 %9 = OpLabel OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(before, after, true, true); } // Delete %dead because it is unreferenced. In this case, the initialized has // another reference, and should not be removed. TEST_F(DeadVariableElimTest, RemoveUnreferencedWithInit2) { const std::string before = R"(OpCapability Shader OpCapability Linkage %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 150 OpName %main "main" OpName %dead "dead" OpName %initializer "initializer" %void = OpTypeVoid %6 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Private_float = OpTypePointer Private %float %initializer = OpVariable %_ptr_Private_float Private %dead = OpVariable %_ptr_Private_float Private %initializer %main = OpFunction %void None %6 %9 = OpLabel %10 = OpLoad %float %initializer OpReturn OpFunctionEnd )"; const std::string after = R"(OpCapability Shader OpCapability Linkage %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 150 OpName %main "main" OpName %initializer "initializer" %void = OpTypeVoid %6 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Private_float = OpTypePointer Private %float %initializer = OpVariable %_ptr_Private_float Private %main = OpFunction %void None %6 %9 = OpLabel %10 = OpLoad %float %initializer OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(before, after, true, true); } // Keep %live because it is used, and its initializer. TEST_F(DeadVariableElimTest, KeepReferenced) { const std::string before = R"(OpCapability Shader OpCapability Linkage %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 150 OpName %main "main" OpName %live "live" OpName %initializer "initializer" %void = OpTypeVoid %6 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Private_float = OpTypePointer Private %float %initializer = OpConstant %float 0 %live = OpVariable %_ptr_Private_float Private %initializer %main = OpFunction %void None %6 %9 = OpLabel %10 = OpLoad %float %live OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(before, before, true, true); } // This test that the decoration associated with a variable are removed when the // variable is removed. TEST_F(DeadVariableElimTest, RemoveVariableAndDecorations) { const std::string before = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpName %main "main" OpName %B "B" OpMemberName %B 0 "a" OpName %Bdat "Bdat" OpMemberDecorate %B 0 Offset 0 OpDecorate %B BufferBlock OpDecorate %Bdat DescriptorSet 0 OpDecorate %Bdat Binding 0 %void = OpTypeVoid %6 = OpTypeFunction %void %uint = OpTypeInt 32 0 %B = OpTypeStruct %uint %_ptr_Uniform_B = OpTypePointer Uniform %B %Bdat = OpVariable %_ptr_Uniform_B Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint_1 = OpConstant %uint 1 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %main = OpFunction %void None %6 %13 = OpLabel OpReturn OpFunctionEnd )"; const std::string after = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpName %main "main" OpName %B "B" OpMemberName %B 0 "a" OpMemberDecorate %B 0 Offset 0 OpDecorate %B BufferBlock %void = OpTypeVoid %6 = OpTypeFunction %void %uint = OpTypeInt 32 0 %B = OpTypeStruct %uint %_ptr_Uniform_B = OpTypePointer Uniform %B %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint_1 = OpConstant %uint 1 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %main = OpFunction %void None %6 %13 = OpLabel OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(before, after, true, true); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/debug_info_manager_test.cpp000066400000000000000000001054151475742701700256560ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/debug_info_manager.h" #include #include #include "gtest/gtest.h" #include "source/opt/build_module.h" #include "source/opt/instruction.h" #include "spirv-tools/libspirv.hpp" // Constants for OpenCL.DebugInfo.100 extension instructions. static const uint32_t kDebugFunctionOperandFunctionIndex = 13; static const uint32_t kDebugInlinedAtOperandLineIndex = 4; static const uint32_t kDebugInlinedAtOperandScopeIndex = 5; static const uint32_t kDebugInlinedAtOperandInlinedIndex = 6; static const uint32_t kOpLineInOperandFileIndex = 0; static const uint32_t kOpLineInOperandLineIndex = 1; static const uint32_t kOpLineInOperandColumnIndex = 2; namespace spvtools { namespace opt { namespace analysis { namespace { TEST(DebugInfoManager, GetDebugInlinedAt) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_COLOR OpExecutionMode %main OriginUpperLeft %5 = OpString "ps.hlsl" %14 = OpString "#line 1 \"ps.hlsl\" void main(float in_var_color : COLOR) { float color = in_var_color; } " %17 = OpString "float" %21 = OpString "main" %24 = OpString "color" OpName %in_var_COLOR "in.var.COLOR" OpName %main "main" OpDecorate %in_var_COLOR Location 0 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %float = OpTypeFloat 32 %_ptr_Input_float = OpTypePointer Input %float %void = OpTypeVoid %27 = OpTypeFunction %void %_ptr_Function_float = OpTypePointer Function %float %in_var_COLOR = OpVariable %_ptr_Input_float Input %13 = OpExtInst %void %1 DebugExpression %15 = OpExtInst %void %1 DebugSource %5 %14 %16 = OpExtInst %void %1 DebugCompilationUnit 1 4 %15 HLSL %18 = OpExtInst %void %1 DebugTypeBasic %17 %uint_32 Float %20 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %18 %18 %22 = OpExtInst %void %1 DebugFunction %21 %20 %15 1 1 %16 %21 FlagIsProtected|FlagIsPrivate 1 %main %100 = OpExtInst %void %1 DebugInlinedAt 7 %22 %main = OpFunction %void None %27 %28 = OpLabel %31 = OpLoad %float %in_var_COLOR OpStore %100 %31 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); DebugInfoManager manager(context.get()); EXPECT_EQ(manager.GetDebugInlinedAt(150), nullptr); EXPECT_EQ(manager.GetDebugInlinedAt(31), nullptr); EXPECT_EQ(manager.GetDebugInlinedAt(22), nullptr); auto* inst = manager.GetDebugInlinedAt(100); EXPECT_EQ(inst->GetSingleWordOperand(kDebugInlinedAtOperandLineIndex), 7); EXPECT_EQ(inst->GetSingleWordOperand(kDebugInlinedAtOperandScopeIndex), 22); } TEST(DebugInfoManager, CreateDebugInlinedAt) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_COLOR OpExecutionMode %main OriginUpperLeft %5 = OpString "ps.hlsl" %14 = OpString "#line 1 \"ps.hlsl\" void main(float in_var_color : COLOR) { float color = in_var_color; } " %17 = OpString "float" %21 = OpString "main" %24 = OpString "color" OpName %in_var_COLOR "in.var.COLOR" OpName %main "main" OpDecorate %in_var_COLOR Location 0 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %float = OpTypeFloat 32 %_ptr_Input_float = OpTypePointer Input %float %void = OpTypeVoid %27 = OpTypeFunction %void %_ptr_Function_float = OpTypePointer Function %float %in_var_COLOR = OpVariable %_ptr_Input_float Input %13 = OpExtInst %void %1 DebugExpression %15 = OpExtInst %void %1 DebugSource %5 %14 %16 = OpExtInst %void %1 DebugCompilationUnit 1 4 %15 HLSL %18 = OpExtInst %void %1 DebugTypeBasic %17 %uint_32 Float %20 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %18 %18 %22 = OpExtInst %void %1 DebugFunction %21 %20 %15 1 1 %16 %21 FlagIsProtected|FlagIsPrivate 1 %main %100 = OpExtInst %void %1 DebugInlinedAt 7 %22 %main = OpFunction %void None %27 %28 = OpLabel %31 = OpLoad %float %in_var_COLOR OpStore %100 %31 OpReturn OpFunctionEnd )"; DebugScope scope(22U, 0U); std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); DebugInfoManager manager(context.get()); uint32_t inlined_at_id = manager.CreateDebugInlinedAt(nullptr, scope); auto* inlined_at = manager.GetDebugInlinedAt(inlined_at_id); EXPECT_NE(inlined_at, nullptr); EXPECT_EQ(inlined_at->GetSingleWordOperand(kDebugInlinedAtOperandLineIndex), 1); EXPECT_EQ(inlined_at->GetSingleWordOperand(kDebugInlinedAtOperandScopeIndex), 22); EXPECT_EQ(inlined_at->NumOperands(), kDebugInlinedAtOperandScopeIndex + 1); const uint32_t line_number = 77U; Instruction line(context.get(), spv::Op::OpLine); line.SetInOperands({ {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {5U}}, {spv_operand_type_t::SPV_OPERAND_TYPE_LITERAL_INTEGER, {line_number}}, {spv_operand_type_t::SPV_OPERAND_TYPE_LITERAL_INTEGER, {0U}}, }); inlined_at_id = manager.CreateDebugInlinedAt(&line, scope); inlined_at = manager.GetDebugInlinedAt(inlined_at_id); EXPECT_NE(inlined_at, nullptr); EXPECT_EQ(inlined_at->GetSingleWordOperand(kDebugInlinedAtOperandLineIndex), line_number); EXPECT_EQ(inlined_at->GetSingleWordOperand(kDebugInlinedAtOperandScopeIndex), 22); EXPECT_EQ(inlined_at->NumOperands(), kDebugInlinedAtOperandScopeIndex + 1); scope.SetInlinedAt(100U); inlined_at_id = manager.CreateDebugInlinedAt(&line, scope); inlined_at = manager.GetDebugInlinedAt(inlined_at_id); EXPECT_NE(inlined_at, nullptr); EXPECT_EQ(inlined_at->GetSingleWordOperand(kDebugInlinedAtOperandLineIndex), line_number); EXPECT_EQ(inlined_at->GetSingleWordOperand(kDebugInlinedAtOperandScopeIndex), 22); EXPECT_EQ(inlined_at->NumOperands(), kDebugInlinedAtOperandInlinedIndex + 1); EXPECT_EQ( inlined_at->GetSingleWordOperand(kDebugInlinedAtOperandInlinedIndex), 100U); } TEST(DebugInfoManager, CreateDebugInlinedAtWithConstantManager) { // Show that CreateDebugInlinedAt will use the Constant manager to generate // its line operand if the Constant and DefUse managers are valid. This is // proven by checking that the id for the line operand 7 is the same as the // existing constant 7. // // int function1() { // return 1; // } // // void main() { // function1(); // } const std::string text = R"(OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %1 = OpExtInstImport "NonSemantic.Shader.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %3 = OpString "parent3.hlsl" %8 = OpString "int" %19 = OpString "function1" %20 = OpString "" %26 = OpString "main" OpName %main "main" OpName %src_main "src.main" OpName %bb_entry "bb.entry" OpName %function1 "function1" OpName %bb_entry_0 "bb.entry" %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %void = OpTypeVoid %uint_4 = OpConstant %uint 4 %uint_0 = OpConstant %uint 0 %uint_3 = OpConstant %uint 3 %uint_1 = OpConstant %uint 1 %uint_5 = OpConstant %uint 5 %uint_2 = OpConstant %uint 2 %uint_17 = OpConstant %uint 17 %uint_6 = OpConstant %uint 6 %uint_13 = OpConstant %uint 13 %100 = OpConstant %uint 7 %31 = OpTypeFunction %void %42 = OpTypeFunction %int %10 = OpExtInst %void %1 DebugTypeBasic %8 %uint_32 %uint_4 %uint_0 %13 = OpExtInst %void %1 DebugTypeFunction %uint_3 %10 %15 = OpExtInst %void %1 DebugSource %3 %16 = OpExtInst %void %1 DebugCompilationUnit %uint_1 %uint_4 %15 %uint_5 %21 = OpExtInst %void %1 DebugFunction %19 %13 %15 %uint_2 %uint_1 %16 %20 %uint_3 %uint_2 %23 = OpExtInst %void %1 DebugLexicalBlock %15 %uint_2 %uint_17 %21 %25 = OpExtInst %void %1 DebugTypeFunction %uint_3 %void %27 = OpExtInst %void %1 DebugFunction %26 %25 %15 %uint_6 %uint_1 %16 %20 %uint_3 %uint_6 %29 = OpExtInst %void %1 DebugLexicalBlock %15 %uint_6 %uint_13 %27 %main = OpFunction %void None %31 %32 = OpLabel %33 = OpFunctionCall %void %src_main OpLine %3 8 1 OpReturn OpFunctionEnd OpLine %3 6 1 %src_main = OpFunction %void None %31 OpNoLine %bb_entry = OpLabel %47 = OpExtInst %void %1 DebugScope %27 %37 = OpExtInst %void %1 DebugFunctionDefinition %27 %src_main %48 = OpExtInst %void %1 DebugScope %29 OpLine %3 7 3 %39 = OpFunctionCall %int %function1 %49 = OpExtInst %void %1 DebugScope %27 OpLine %3 8 1 OpReturn %50 = OpExtInst %void %1 DebugNoScope OpFunctionEnd OpLine %3 2 1 %function1 = OpFunction %int None %42 OpNoLine %bb_entry_0 = OpLabel %51 = OpExtInst %void %1 DebugScope %21 %45 = OpExtInst %void %1 DebugFunctionDefinition %21 %function1 %52 = OpExtInst %void %1 DebugScope %23 OpLine %3 3 3 OpReturnValue %int_1 %53 = OpExtInst %void %1 DebugNoScope OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); const uint32_t line_number = 7U; Instruction line(context.get(), spv::Op::OpLine); line.SetInOperands({ {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {5U}}, {spv_operand_type_t::SPV_OPERAND_TYPE_LITERAL_INTEGER, {line_number}}, {spv_operand_type_t::SPV_OPERAND_TYPE_LITERAL_INTEGER, {0U}}, }); DebugScope scope(29U, 0U); auto db_manager = context.get()->get_debug_info_mgr(); auto du_manager = context.get()->get_def_use_mgr(); auto c_manager = context.get()->get_constant_mgr(); (void)du_manager; (void)c_manager; uint32_t inlined_at_id = db_manager->CreateDebugInlinedAt(&line, scope); auto* inlined_at = db_manager->GetDebugInlinedAt(inlined_at_id); EXPECT_NE(inlined_at, nullptr); EXPECT_EQ(inlined_at->GetSingleWordOperand(kDebugInlinedAtOperandLineIndex), 100); } TEST(DebugInfoManager, GetDebugInfoNone) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_COLOR OpExecutionMode %main OriginUpperLeft %5 = OpString "ps.hlsl" %14 = OpString "#line 1 \"ps.hlsl\" void main(float in_var_color : COLOR) { float color = in_var_color; } " %17 = OpString "float" %21 = OpString "main" %24 = OpString "color" OpName %in_var_COLOR "in.var.COLOR" OpName %main "main" OpDecorate %in_var_COLOR Location 0 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %float = OpTypeFloat 32 %_ptr_Input_float = OpTypePointer Input %float %void = OpTypeVoid %27 = OpTypeFunction %void %_ptr_Function_float = OpTypePointer Function %float %in_var_COLOR = OpVariable %_ptr_Input_float Input %13 = OpExtInst %void %1 DebugExpression %15 = OpExtInst %void %1 DebugSource %5 %14 %16 = OpExtInst %void %1 DebugCompilationUnit 1 4 %15 HLSL %18 = OpExtInst %void %1 DebugTypeBasic %17 %uint_32 Float %20 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %18 %18 %22 = OpExtInst %void %1 DebugFunction %21 %20 %15 1 1 %16 %21 FlagIsProtected|FlagIsPrivate 1 %main %12 = OpExtInst %void %1 DebugInfoNone %25 = OpExtInst %void %1 DebugLocalVariable %24 %18 %15 1 20 %22 FlagIsLocal 0 %main = OpFunction %void None %27 %28 = OpLabel %100 = OpVariable %_ptr_Function_float Function %31 = OpLoad %float %in_var_COLOR OpStore %100 %31 %36 = OpExtInst %void %1 DebugDeclare %25 %100 %13 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); DebugInfoManager manager(context.get()); Instruction* debug_info_none_inst = manager.GetDebugInfoNone(); EXPECT_NE(debug_info_none_inst, nullptr); EXPECT_EQ(debug_info_none_inst->GetOpenCL100DebugOpcode(), OpenCLDebugInfo100DebugInfoNone); EXPECT_EQ(debug_info_none_inst->PreviousNode(), nullptr); } TEST(DebugInfoManager, CreateDebugInfoNone) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_COLOR OpExecutionMode %main OriginUpperLeft %5 = OpString "ps.hlsl" %14 = OpString "#line 1 \"ps.hlsl\" void main(float in_var_color : COLOR) { float color = in_var_color; } " %17 = OpString "float" %21 = OpString "main" %24 = OpString "color" OpName %in_var_COLOR "in.var.COLOR" OpName %main "main" OpDecorate %in_var_COLOR Location 0 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %float = OpTypeFloat 32 %_ptr_Input_float = OpTypePointer Input %float %void = OpTypeVoid %27 = OpTypeFunction %void %_ptr_Function_float = OpTypePointer Function %float %in_var_COLOR = OpVariable %_ptr_Input_float Input %13 = OpExtInst %void %1 DebugExpression %15 = OpExtInst %void %1 DebugSource %5 %14 %16 = OpExtInst %void %1 DebugCompilationUnit 1 4 %15 HLSL %18 = OpExtInst %void %1 DebugTypeBasic %17 %uint_32 Float %20 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %18 %18 %22 = OpExtInst %void %1 DebugFunction %21 %20 %15 1 1 %16 %21 FlagIsProtected|FlagIsPrivate 1 %main %25 = OpExtInst %void %1 DebugLocalVariable %24 %18 %15 1 20 %22 FlagIsLocal 0 %main = OpFunction %void None %27 %28 = OpLabel %100 = OpVariable %_ptr_Function_float Function %31 = OpLoad %float %in_var_COLOR OpStore %100 %31 %36 = OpExtInst %void %1 DebugDeclare %25 %100 %13 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); DebugInfoManager manager(context.get()); Instruction* debug_info_none_inst = manager.GetDebugInfoNone(); EXPECT_NE(debug_info_none_inst, nullptr); EXPECT_EQ(debug_info_none_inst->GetOpenCL100DebugOpcode(), OpenCLDebugInfo100DebugInfoNone); EXPECT_EQ(debug_info_none_inst->PreviousNode(), nullptr); } TEST(DebugInfoManager, GetDebugFunction) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %200 "200" %in_var_COLOR OpExecutionMode %200 OriginUpperLeft %5 = OpString "ps.hlsl" %14 = OpString "#line 1 \"ps.hlsl\" void 200(float in_var_color : COLOR) { float color = in_var_color; } " %17 = OpString "float" %21 = OpString "200" %24 = OpString "color" OpName %in_var_COLOR "in.var.COLOR" OpName %200 "200" OpDecorate %in_var_COLOR Location 0 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %float = OpTypeFloat 32 %_ptr_Input_float = OpTypePointer Input %float %void = OpTypeVoid %27 = OpTypeFunction %void %_ptr_Function_float = OpTypePointer Function %float %in_var_COLOR = OpVariable %_ptr_Input_float Input %13 = OpExtInst %void %1 DebugExpression %15 = OpExtInst %void %1 DebugSource %5 %14 %16 = OpExtInst %void %1 DebugCompilationUnit 1 4 %15 HLSL %18 = OpExtInst %void %1 DebugTypeBasic %17 %uint_32 Float %20 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %18 %18 %22 = OpExtInst %void %1 DebugFunction %21 %20 %15 1 1 %16 %21 FlagIsProtected|FlagIsPrivate 1 %200 %25 = OpExtInst %void %1 DebugLocalVariable %24 %18 %15 1 20 %22 FlagIsLocal 0 %200 = OpFunction %void None %27 %28 = OpLabel %100 = OpVariable %_ptr_Function_float Function %31 = OpLoad %float %in_var_COLOR OpStore %100 %31 %36 = OpExtInst %void %1 DebugDeclare %25 %100 %13 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); DebugInfoManager manager(context.get()); EXPECT_EQ(manager.GetDebugFunction(100), nullptr); EXPECT_EQ(manager.GetDebugFunction(150), nullptr); Instruction* dbg_fn = manager.GetDebugFunction(200); EXPECT_EQ(dbg_fn->GetOpenCL100DebugOpcode(), OpenCLDebugInfo100DebugFunction); EXPECT_EQ(dbg_fn->GetSingleWordOperand(kDebugFunctionOperandFunctionIndex), 200); } TEST(DebugInfoManager, GetDebugFunction_InlinedAway) { // struct PS_INPUT // { // float4 iColor : COLOR; // }; // // struct PS_OUTPUT // { // float4 oColor : SV_Target0; // }; // // float4 foo(float4 ic) // { // float4 c = ic / 2.0; // return c; // } // // PS_OUTPUT MainPs(PS_INPUT i) // { // PS_OUTPUT ps_output; // float4 ic = i.iColor; // ps_output.oColor = foo(ic); // return ps_output; // } const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %MainPs "MainPs" %in_var_COLOR %out_var_SV_Target0 OpExecutionMode %MainPs OriginUpperLeft %15 = OpString "foo2.frag" %19 = OpString "PS_OUTPUT" %23 = OpString "float" %26 = OpString "oColor" %28 = OpString "PS_INPUT" %31 = OpString "iColor" %33 = OpString "foo" %37 = OpString "c" %39 = OpString "ic" %42 = OpString "src.MainPs" %47 = OpString "ps_output" %50 = OpString "i" OpName %in_var_COLOR "in.var.COLOR" OpName %out_var_SV_Target0 "out.var.SV_Target0" OpName %MainPs "MainPs" OpDecorate %in_var_COLOR Location 0 OpDecorate %out_var_SV_Target0 Location 0 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %uint_128 = OpConstant %uint 128 %uint_0 = OpConstant %uint 0 %52 = OpTypeFunction %void %in_var_COLOR = OpVariable %_ptr_Input_v4float Input %out_var_SV_Target0 = OpVariable %_ptr_Output_v4float Output %float_0_5 = OpConstant %float 0.5 %130 = OpConstantComposite %v4float %float_0_5 %float_0_5 %float_0_5 %float_0_5 %115 = OpExtInst %void %1 DebugInfoNone %49 = OpExtInst %void %1 DebugExpression %17 = OpExtInst %void %1 DebugSource %15 %18 = OpExtInst %void %1 DebugCompilationUnit 1 4 %17 HLSL %21 = OpExtInst %void %1 DebugTypeComposite %19 Structure %17 6 1 %18 %19 %uint_128 FlagIsProtected|FlagIsPrivate %22 %24 = OpExtInst %void %1 DebugTypeBasic %23 %uint_32 Float %25 = OpExtInst %void %1 DebugTypeVector %24 4 %22 = OpExtInst %void %1 DebugTypeMember %26 %25 %17 8 5 %21 %uint_0 %uint_128 FlagIsProtected|FlagIsPrivate %29 = OpExtInst %void %1 DebugTypeComposite %28 Structure %17 1 1 %18 %28 %uint_128 FlagIsProtected|FlagIsPrivate %30 %30 = OpExtInst %void %1 DebugTypeMember %31 %25 %17 3 5 %29 %uint_0 %uint_128 FlagIsProtected|FlagIsPrivate %32 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %25 %25 %34 = OpExtInst %void %1 DebugFunction %33 %32 %17 11 1 %18 %33 FlagIsProtected|FlagIsPrivate 12 %115 %36 = OpExtInst %void %1 DebugLexicalBlock %17 12 1 %34 %38 = OpExtInst %void %1 DebugLocalVariable %37 %25 %17 13 12 %36 FlagIsLocal %41 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %21 %29 %43 = OpExtInst %void %1 DebugFunction %42 %41 %17 17 1 %18 %42 FlagIsProtected|FlagIsPrivate 18 %115 %45 = OpExtInst %void %1 DebugLexicalBlock %17 18 1 %43 %46 = OpExtInst %void %1 DebugLocalVariable %39 %25 %17 20 12 %45 FlagIsLocal %48 = OpExtInst %void %1 DebugLocalVariable %47 %21 %17 19 15 %45 FlagIsLocal %107 = OpExtInst %void %1 DebugInlinedAt 21 %45 %MainPs = OpFunction %void None %52 %53 = OpLabel %57 = OpLoad %v4float %in_var_COLOR %131 = OpExtInst %void %1 DebugScope %45 OpLine %15 20 12 %117 = OpExtInst %void %1 DebugValue %46 %57 %49 %132 = OpExtInst %void %1 DebugScope %36 %107 OpLine %15 13 19 %112 = OpFMul %v4float %57 %130 OpLine %15 13 12 %116 = OpExtInst %void %1 DebugValue %38 %112 %49 %133 = OpExtInst %void %1 DebugScope %45 %128 = OpExtInst %void %1 DebugValue %48 %112 %49 %int_0 %134 = OpExtInst %void %1 DebugNoScope OpStore %out_var_SV_Target0 %112 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); DebugInfoManager manager(context.get()); EXPECT_EQ(manager.GetDebugFunction(115), nullptr); } TEST(DebugInfoManager, CloneDebugInlinedAt) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_COLOR OpExecutionMode %main OriginUpperLeft %5 = OpString "ps.hlsl" %14 = OpString "#line 1 \"ps.hlsl\" void main(float in_var_color : COLOR) { float color = in_var_color; } " %17 = OpString "float" %21 = OpString "main" %24 = OpString "color" OpName %in_var_COLOR "in.var.COLOR" OpName %main "main" OpDecorate %in_var_COLOR Location 0 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %float = OpTypeFloat 32 %_ptr_Input_float = OpTypePointer Input %float %void = OpTypeVoid %27 = OpTypeFunction %void %_ptr_Function_float = OpTypePointer Function %float %in_var_COLOR = OpVariable %_ptr_Input_float Input %13 = OpExtInst %void %1 DebugExpression %15 = OpExtInst %void %1 DebugSource %5 %14 %16 = OpExtInst %void %1 DebugCompilationUnit 1 4 %15 HLSL %18 = OpExtInst %void %1 DebugTypeBasic %17 %uint_32 Float %20 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %18 %18 %22 = OpExtInst %void %1 DebugFunction %21 %20 %15 1 1 %16 %21 FlagIsProtected|FlagIsPrivate 1 %main %100 = OpExtInst %void %1 DebugInlinedAt 7 %22 %main = OpFunction %void None %27 %28 = OpLabel %31 = OpLoad %float %in_var_COLOR OpStore %100 %31 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); DebugInfoManager manager(context.get()); EXPECT_EQ(manager.CloneDebugInlinedAt(150), nullptr); EXPECT_EQ(manager.CloneDebugInlinedAt(22), nullptr); auto* inst = manager.CloneDebugInlinedAt(100); EXPECT_EQ(inst->GetSingleWordOperand(kDebugInlinedAtOperandLineIndex), 7); EXPECT_EQ(inst->GetSingleWordOperand(kDebugInlinedAtOperandScopeIndex), 22); EXPECT_EQ(inst->NumOperands(), kDebugInlinedAtOperandScopeIndex + 1); Instruction* before_100 = nullptr; for (auto it = context->module()->ext_inst_debuginfo_begin(); it != context->module()->ext_inst_debuginfo_end(); ++it) { if (it->result_id() == 100) break; before_100 = &*it; } EXPECT_NE(inst, before_100); inst = manager.CloneDebugInlinedAt(100, manager.GetDebugInlinedAt(100)); EXPECT_EQ(inst->GetSingleWordOperand(kDebugInlinedAtOperandLineIndex), 7); EXPECT_EQ(inst->GetSingleWordOperand(kDebugInlinedAtOperandScopeIndex), 22); EXPECT_EQ(inst->NumOperands(), kDebugInlinedAtOperandScopeIndex + 1); before_100 = nullptr; for (auto it = context->module()->ext_inst_debuginfo_begin(); it != context->module()->ext_inst_debuginfo_end(); ++it) { if (it->result_id() == 100) break; before_100 = &*it; } EXPECT_EQ(inst, before_100); } TEST(DebugInfoManager, KillDebugDeclares) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_COLOR OpExecutionMode %main OriginUpperLeft %5 = OpString "ps.hlsl" %14 = OpString "#line 1 \"ps.hlsl\" void main(float in_var_color : COLOR) { float color = in_var_color; } " %17 = OpString "float" %21 = OpString "main" %24 = OpString "color" OpName %in_var_COLOR "in.var.COLOR" OpName %main "main" OpDecorate %in_var_COLOR Location 0 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %float = OpTypeFloat 32 %_ptr_Input_float = OpTypePointer Input %float %void = OpTypeVoid %27 = OpTypeFunction %void %_ptr_Function_float = OpTypePointer Function %float %in_var_COLOR = OpVariable %_ptr_Input_float Input %13 = OpExtInst %void %1 DebugExpression %15 = OpExtInst %void %1 DebugSource %5 %14 %16 = OpExtInst %void %1 DebugCompilationUnit 1 4 %15 HLSL %18 = OpExtInst %void %1 DebugTypeBasic %17 %uint_32 Float %20 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %18 %18 %22 = OpExtInst %void %1 DebugFunction %21 %20 %15 1 1 %16 %21 FlagIsProtected|FlagIsPrivate 1 %main %12 = OpExtInst %void %1 DebugInfoNone %25 = OpExtInst %void %1 DebugLocalVariable %24 %18 %15 1 20 %22 FlagIsLocal 0 %main = OpFunction %void None %27 %28 = OpLabel %100 = OpVariable %_ptr_Function_float Function %31 = OpLoad %float %in_var_COLOR OpStore %100 %31 %36 = OpExtInst %void %1 DebugDeclare %25 %100 %13 %37 = OpExtInst %void %1 DebugDeclare %25 %100 %13 %38 = OpExtInst %void %1 DebugDeclare %25 %100 %13 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); auto* dbg_info_mgr = context->get_debug_info_mgr(); auto* def_use_mgr = context->get_def_use_mgr(); EXPECT_TRUE(dbg_info_mgr->IsVariableDebugDeclared(100)); EXPECT_EQ(def_use_mgr->GetDef(36)->GetOpenCL100DebugOpcode(), OpenCLDebugInfo100DebugDeclare); EXPECT_EQ(def_use_mgr->GetDef(37)->GetOpenCL100DebugOpcode(), OpenCLDebugInfo100DebugDeclare); EXPECT_EQ(def_use_mgr->GetDef(38)->GetOpenCL100DebugOpcode(), OpenCLDebugInfo100DebugDeclare); dbg_info_mgr->KillDebugDeclares(100); EXPECT_EQ(def_use_mgr->GetDef(36), nullptr); EXPECT_EQ(def_use_mgr->GetDef(37), nullptr); EXPECT_EQ(def_use_mgr->GetDef(38), nullptr); EXPECT_FALSE(dbg_info_mgr->IsVariableDebugDeclared(100)); } TEST(DebugInfoManager, AddDebugValueForDecl) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_COLOR OpExecutionMode %main OriginUpperLeft %5 = OpString "ps.hlsl" %14 = OpString "#line 1 \"ps.hlsl\" void main(float in_var_color : COLOR) { float color = in_var_color; } " %17 = OpString "float" %21 = OpString "main" %24 = OpString "color" OpName %in_var_COLOR "in.var.COLOR" OpName %main "main" OpDecorate %in_var_COLOR Location 0 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %float = OpTypeFloat 32 %_ptr_Input_float = OpTypePointer Input %float %void = OpTypeVoid %27 = OpTypeFunction %void %_ptr_Function_float = OpTypePointer Function %float %in_var_COLOR = OpVariable %_ptr_Input_float Input %13 = OpExtInst %void %1 DebugExpression %15 = OpExtInst %void %1 DebugSource %5 %14 %16 = OpExtInst %void %1 DebugCompilationUnit 1 4 %15 HLSL %18 = OpExtInst %void %1 DebugTypeBasic %17 %uint_32 Float %20 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %18 %18 %22 = OpExtInst %void %1 DebugFunction %21 %20 %15 1 1 %16 %21 FlagIsProtected|FlagIsPrivate 1 %main %12 = OpExtInst %void %1 DebugInfoNone %25 = OpExtInst %void %1 DebugLocalVariable %24 %18 %15 1 20 %22 FlagIsLocal 0 %main = OpFunction %void None %27 %28 = OpLabel %100 = OpVariable %_ptr_Function_float Function %31 = OpLoad %float %in_var_COLOR %101 = OpExtInst %void %1 DebugScope %22 OpLine %5 13 7 OpStore %100 %31 OpNoLine %102 = OpExtInst %void %1 DebugNoScope %36 = OpExtInst %void %1 DebugDeclare %25 %100 %13 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); auto* def_use_mgr = context->get_def_use_mgr(); auto* dbg_decl = def_use_mgr->GetDef(36); EXPECT_EQ(dbg_decl->GetOpenCL100DebugOpcode(), OpenCLDebugInfo100DebugDeclare); auto* dbg_info_mgr = context->get_debug_info_mgr(); Instruction* store = dbg_decl->PreviousNode(); auto* dbg_value = dbg_info_mgr->AddDebugValueForDecl(dbg_decl, 100, dbg_decl, store); EXPECT_EQ(dbg_value->GetOpenCL100DebugOpcode(), OpenCLDebugInfo100DebugValue); EXPECT_EQ(dbg_value->dbg_line_inst()->GetSingleWordInOperand( kOpLineInOperandFileIndex), 5); EXPECT_EQ(dbg_value->dbg_line_inst()->GetSingleWordInOperand( kOpLineInOperandLineIndex), 13); EXPECT_EQ(dbg_value->dbg_line_inst()->GetSingleWordInOperand( kOpLineInOperandColumnIndex), 7); } TEST(DebugInfoManager, ConvertGlobalToLocal) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "NonSemantic.Shader.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "PSMain" %3 OpExecutionMode %2 OriginUpperLeft %4 = OpString "C:\\local\\Temp\\2528091a-6811-4e62-9ed5-02f1547c2016.hlsl" %5 = OpString "float" %6 = OpString "Pi" %float = OpTypeFloat 32 %float_3_1415 = OpConstant %float 3.1415 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %_ptr_Private_float = OpTypePointer Private %float %_ptr_Function_float = OpTypePointer Function %float %void = OpTypeVoid %uint_3 = OpConstant %uint 3 %uint_0 = OpConstant %uint 0 %uint_4 = OpConstant %uint 4 %uint_1 = OpConstant %uint 1 %uint_5 = OpConstant %uint 5 %uint_8 = OpConstant %uint 8 %uint_6 = OpConstant %uint 6 %uint_20 = OpConstant %uint 20 %25 = OpTypeFunction %void %uint_11 = OpConstant %uint 11 %3 = OpVariable %_ptr_Private_float Private %8 = OpExtInst %void %1 DebugTypeBasic %5 %uint_32 %uint_3 %uint_0 %12 = OpExtInst %void %1 DebugSource %4 %13 = OpExtInst %void %1 DebugCompilationUnit %uint_1 %uint_4 %12 %uint_5 %17 = OpExtInst %void %1 DebugGlobalVariable %6 %8 %12 %uint_6 %uint_20 %13 %6 %3 %uint_8 %2 = OpFunction %void None %25 %27 = OpLabel %29 = OpVariable %_ptr_Function_float Function OpStore %3 %float_3_1415 %28 = OpExtInst %void %1 DebugLine %12 %uint_11 %uint_11 %uint_1 %uint_1 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); auto* def_use_mgr = context->get_def_use_mgr(); auto* dbg_var = def_use_mgr->GetDef(17); EXPECT_EQ(dbg_var->GetCommonDebugOpcode(), OpenCLDebugInfo100DebugGlobalVariable); EXPECT_EQ(dbg_var->NumInOperands(), 11); std::vector originalOperands; for (uint32_t i = 0; i < dbg_var->NumInOperands(); ++i) { originalOperands.emplace_back(dbg_var->GetInOperand((i))); } auto* local_var = def_use_mgr->GetDef(29); auto* dbg_info_mgr = context->get_debug_info_mgr(); dbg_info_mgr->ConvertDebugGlobalToLocalVariable(dbg_var, local_var); EXPECT_EQ(dbg_var->NumInOperands(), 9); // This checks that the first two inoperands are correct. EXPECT_EQ(dbg_var->GetCommonDebugOpcode(), OpenCLDebugInfo100DebugLocalVariable); // Then next 6 operands should be the same as the original instruction. EXPECT_EQ(dbg_var->GetInOperand(2), originalOperands[2]); EXPECT_EQ(dbg_var->GetInOperand(3), originalOperands[3]); EXPECT_EQ(dbg_var->GetInOperand(4), originalOperands[4]); EXPECT_EQ(dbg_var->GetInOperand(5), originalOperands[5]); EXPECT_EQ(dbg_var->GetInOperand(6), originalOperands[6]); EXPECT_EQ(dbg_var->GetInOperand(7), originalOperands[7]); // The flags operand should have shifted because operand 8 and 9 in the global // instruction are not relevant. EXPECT_EQ(dbg_var->GetInOperand(8), originalOperands[10]); } } // namespace } // namespace analysis } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/decoration_manager_test.cpp000066400000000000000000001430651475742701700257070ustar00rootroot00000000000000// Copyright (c) 2017 Pierre Moreau // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include "gmock/gmock.h" #include "source/opt/build_module.h" #include "source/opt/decoration_manager.h" #include "source/opt/ir_context.h" #include "source/spirv_constant.h" #include "source/util/string_utils.h" #include "test/unit_spirv.h" namespace spvtools { namespace opt { namespace analysis { namespace { using utils::MakeVector; class DecorationManagerTest : public ::testing::Test { public: DecorationManagerTest() : tools_(SPV_ENV_UNIVERSAL_1_2), context_(), consumer_([this](spv_message_level_t level, const char*, const spv_position_t& position, const char* message) { if (!error_message_.empty()) error_message_ += "\n"; switch (level) { case SPV_MSG_FATAL: case SPV_MSG_INTERNAL_ERROR: case SPV_MSG_ERROR: error_message_ += "ERROR"; break; case SPV_MSG_WARNING: error_message_ += "WARNING"; break; case SPV_MSG_INFO: error_message_ += "INFO"; break; case SPV_MSG_DEBUG: error_message_ += "DEBUG"; break; } error_message_ += ": " + std::to_string(position.index) + ": " + message; }), disassemble_options_(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER), error_message_() { tools_.SetMessageConsumer(consumer_); } void TearDown() override { error_message_.clear(); } DecorationManager* GetDecorationManager(const std::string& text) { context_ = BuildModule(SPV_ENV_UNIVERSAL_1_2, consumer_, text); if (context_.get()) return context_->get_decoration_mgr(); else return nullptr; } // Disassembles |binary| and outputs the result in |text|. If |text| is a // null pointer, SPV_ERROR_INVALID_POINTER is returned. spv_result_t Disassemble(const std::vector& binary, std::string* text) { if (!text) return SPV_ERROR_INVALID_POINTER; return tools_.Disassemble(binary, text, disassemble_options_) ? SPV_SUCCESS : SPV_ERROR_INVALID_BINARY; } // Returns the accumulated error messages for the test. std::string GetErrorMessage() const { return error_message_; } std::string ToText(const std::vector& inst) { std::vector binary = {spv::MagicNumber, 0x10200, 0u, 2u, 0u}; for (const Instruction* i : inst) i->ToBinaryWithoutAttachedDebugInsts(&binary); std::string text; Disassemble(binary, &text); return text; } std::string ModuleToText() { std::vector binary; context_->module()->ToBinary(&binary, false); std::string text; Disassemble(binary, &text); return text; } spvtools::MessageConsumer GetConsumer() { return consumer_; } private: // An instance for calling SPIRV-Tools functionalities. spvtools::SpirvTools tools_; std::unique_ptr context_; spvtools::MessageConsumer consumer_; uint32_t disassemble_options_; std::string error_message_; }; TEST_F(DecorationManagerTest, ComparingDecorationsWithDiffOpcodesDecorateDecorateId) { IRContext ir_context(SPV_ENV_UNIVERSAL_1_2, GetConsumer()); // This parameter can be interpreted both as { spv::Decoration::Constant } // and also as a list of IDs: { 22 } const std::vector param{ static_cast(spv::Decoration::Constant)}; // OpDecorate %1 Constant Instruction inst1( &ir_context, spv::Op::OpDecorate, 0u, 0u, {{SPV_OPERAND_TYPE_ID, {1u}}, {SPV_OPERAND_TYPE_DECORATION, param}}); // OpDecorateId %1 %22 ; 'Constant' is decoration number 22 Instruction inst2( &ir_context, spv::Op::OpDecorateId, 0u, 0u, {{SPV_OPERAND_TYPE_ID, {1u}}, {SPV_OPERAND_TYPE_ID, param}}); DecorationManager* decoManager = ir_context.get_decoration_mgr(); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_FALSE(decoManager->AreDecorationsTheSame(&inst1, &inst2, true)); } TEST_F(DecorationManagerTest, ComparingDecorationsWithDiffOpcodesDecorateDecorateString) { IRContext ir_context(SPV_ENV_UNIVERSAL_1_2, GetConsumer()); // This parameter can be interpreted both as { spv::Decoration::Constant } // and also as a null-terminated string with a single character with value 22. const std::vector param{ static_cast(spv::Decoration::Constant)}; // OpDecorate %1 Constant Instruction inst1( &ir_context, spv::Op::OpDecorate, 0u, 0u, {{SPV_OPERAND_TYPE_ID, {1u}}, {SPV_OPERAND_TYPE_DECORATION, param}}); // OpDecorateStringGOOGLE %1 !22 Instruction inst2( &ir_context, spv::Op::OpDecorateStringGOOGLE, 0u, 0u, {{SPV_OPERAND_TYPE_ID, {1u}}, {SPV_OPERAND_TYPE_LITERAL_STRING, param}}); DecorationManager* decoManager = ir_context.get_decoration_mgr(); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_FALSE(decoManager->AreDecorationsTheSame(&inst1, &inst2, true)); } TEST_F(DecorationManagerTest, ComparingDecorationsWithDiffDecorateParam) { IRContext ir_context(SPV_ENV_UNIVERSAL_1_2, GetConsumer()); // OpDecorate %1 Constant Instruction inst1( &ir_context, spv::Op::OpDecorate, 0u, 0u, {{SPV_OPERAND_TYPE_ID, {1u}}, {SPV_OPERAND_TYPE_DECORATION, {uint32_t(spv::Decoration::Constant)}}}); // OpDecorate %1 Restrict Instruction inst2( &ir_context, spv::Op::OpDecorate, 0u, 0u, {{SPV_OPERAND_TYPE_ID, {1u}}, {SPV_OPERAND_TYPE_DECORATION, {uint32_t(spv::Decoration::Restrict)}}}); DecorationManager* decoManager = ir_context.get_decoration_mgr(); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_FALSE(decoManager->AreDecorationsTheSame(&inst1, &inst2, true)); } TEST_F(DecorationManagerTest, ComparingDecorationsWithDiffDecorateIdParam) { IRContext ir_context(SPV_ENV_UNIVERSAL_1_2, GetConsumer()); // OpDecorate %1 Constant Instruction inst1( &ir_context, spv::Op::OpDecorateId, 0u, 0u, {{SPV_OPERAND_TYPE_ID, {1u}}, {SPV_OPERAND_TYPE_ID, {555}}}); // OpDecorate %1 Restrict Instruction inst2( &ir_context, spv::Op::OpDecorateId, 0u, 0u, {{SPV_OPERAND_TYPE_ID, {1u}}, {SPV_OPERAND_TYPE_ID, {666}}}); DecorationManager* decoManager = ir_context.get_decoration_mgr(); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_FALSE(decoManager->AreDecorationsTheSame(&inst1, &inst2, true)); } TEST_F(DecorationManagerTest, ComparingDecorationsWithDiffDecorateStringParam) { IRContext ir_context(SPV_ENV_UNIVERSAL_1_2, GetConsumer()); // OpDecorate %1 Constant Instruction inst1(&ir_context, spv::Op::OpDecorateStringGOOGLE, 0u, 0u, {{SPV_OPERAND_TYPE_ID, {1u}}, {SPV_OPERAND_TYPE_LITERAL_STRING, MakeVector("Hello!")}}); // OpDecorate %1 Restrict Instruction inst2(&ir_context, spv::Op::OpDecorateStringGOOGLE, 0u, 0u, {{SPV_OPERAND_TYPE_ID, {1u}}, {SPV_OPERAND_TYPE_LITERAL_STRING, MakeVector("Hellx")}}); DecorationManager* decoManager = ir_context.get_decoration_mgr(); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_FALSE(decoManager->AreDecorationsTheSame(&inst1, &inst2, true)); } TEST_F(DecorationManagerTest, ComparingSameDecorationsOnDiffTargetAllowed) { IRContext ir_context(SPV_ENV_UNIVERSAL_1_2, GetConsumer()); // OpDecorate %1 Constant Instruction inst1( &ir_context, spv::Op::OpDecorate, 0u, 0u, {{SPV_OPERAND_TYPE_ID, {1u}}, {SPV_OPERAND_TYPE_DECORATION, {uint32_t(spv::Decoration::Constant)}}}); // OpDecorate %2 Constant Instruction inst2( &ir_context, spv::Op::OpDecorate, 0u, 0u, {{SPV_OPERAND_TYPE_ID, {2u}}, {SPV_OPERAND_TYPE_DECORATION, {uint32_t(spv::Decoration::Constant)}}}); DecorationManager* decoManager = ir_context.get_decoration_mgr(); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_TRUE(decoManager->AreDecorationsTheSame(&inst1, &inst2, true)); } TEST_F(DecorationManagerTest, ComparingSameDecorationIdsOnDiffTargetAllowed) { IRContext ir_context(SPV_ENV_UNIVERSAL_1_2, GetConsumer()); Instruction inst1( &ir_context, spv::Op::OpDecorateId, 0u, 0u, {{SPV_OPERAND_TYPE_ID, {1u}}, {SPV_OPERAND_TYPE_DECORATION, {44}}}); Instruction inst2( &ir_context, spv::Op::OpDecorateId, 0u, 0u, {{SPV_OPERAND_TYPE_ID, {2u}}, {SPV_OPERAND_TYPE_DECORATION, {44}}}); DecorationManager* decoManager = ir_context.get_decoration_mgr(); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_TRUE(decoManager->AreDecorationsTheSame(&inst1, &inst2, true)); } TEST_F(DecorationManagerTest, ComparingSameDecorationStringsOnDiffTargetAllowed) { IRContext ir_context(SPV_ENV_UNIVERSAL_1_2, GetConsumer()); Instruction inst1(&ir_context, spv::Op::OpDecorateStringGOOGLE, 0u, 0u, {{SPV_OPERAND_TYPE_ID, {1u}}, {SPV_OPERAND_TYPE_LITERAL_STRING, MakeVector("hello")}}); Instruction inst2(&ir_context, spv::Op::OpDecorateStringGOOGLE, 0u, 0u, {{SPV_OPERAND_TYPE_ID, {2u}}, {SPV_OPERAND_TYPE_LITERAL_STRING, MakeVector("hello")}}); DecorationManager* decoManager = ir_context.get_decoration_mgr(); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_TRUE(decoManager->AreDecorationsTheSame(&inst1, &inst2, true)); } TEST_F(DecorationManagerTest, ComparingSameDecorationsOnDiffTargetDisallowed) { IRContext ir_context(SPV_ENV_UNIVERSAL_1_2, GetConsumer()); // OpDecorate %1 Constant Instruction inst1( &ir_context, spv::Op::OpDecorate, 0u, 0u, {{SPV_OPERAND_TYPE_ID, {1u}}, {SPV_OPERAND_TYPE_DECORATION, {uint32_t(spv::Decoration::Constant)}}}); // OpDecorate %2 Constant Instruction inst2( &ir_context, spv::Op::OpDecorate, 0u, 0u, {{SPV_OPERAND_TYPE_ID, {2u}}, {SPV_OPERAND_TYPE_DECORATION, {uint32_t(spv::Decoration::Constant)}}}); DecorationManager* decoManager = ir_context.get_decoration_mgr(); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_FALSE(decoManager->AreDecorationsTheSame(&inst1, &inst2, false)); } TEST_F(DecorationManagerTest, ComparingMemberDecorationsOnSameTypeDiffMember) { IRContext ir_context(SPV_ENV_UNIVERSAL_1_2, GetConsumer()); // OpMemberDecorate %1 0 Constant Instruction inst1( &ir_context, spv::Op::OpMemberDecorate, 0u, 0u, {{SPV_OPERAND_TYPE_ID, {1u}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {0u}}, {SPV_OPERAND_TYPE_DECORATION, {uint32_t(spv::Decoration::Constant)}}}); // OpMemberDecorate %1 1 Constant Instruction inst2( &ir_context, spv::Op::OpMemberDecorate, 0u, 0u, {{SPV_OPERAND_TYPE_ID, {1u}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {1u}}, {SPV_OPERAND_TYPE_DECORATION, {uint32_t(spv::Decoration::Constant)}}}); DecorationManager* decoManager = ir_context.get_decoration_mgr(); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_FALSE(decoManager->AreDecorationsTheSame(&inst1, &inst2, true)); } TEST_F(DecorationManagerTest, ComparingSameMemberDecorationsOnDiffTargetAllowed) { IRContext ir_context(SPV_ENV_UNIVERSAL_1_2, GetConsumer()); // OpMemberDecorate %1 0 Constant Instruction inst1( &ir_context, spv::Op::OpMemberDecorate, 0u, 0u, {{SPV_OPERAND_TYPE_ID, {1u}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {0u}}, {SPV_OPERAND_TYPE_DECORATION, {uint32_t(spv::Decoration::Constant)}}}); // OpMemberDecorate %2 0 Constant Instruction inst2( &ir_context, spv::Op::OpMemberDecorate, 0u, 0u, {{SPV_OPERAND_TYPE_ID, {2u}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {0u}}, {SPV_OPERAND_TYPE_DECORATION, {uint32_t(spv::Decoration::Constant)}}}); DecorationManager* decoManager = ir_context.get_decoration_mgr(); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_TRUE(decoManager->AreDecorationsTheSame(&inst1, &inst2, true)); } TEST_F(DecorationManagerTest, ComparingSameMemberDecorationsOnDiffTargetDisallowed) { IRContext ir_context(SPV_ENV_UNIVERSAL_1_2, GetConsumer()); // OpMemberDecorate %1 0 Constant Instruction inst1( &ir_context, spv::Op::OpMemberDecorate, 0u, 0u, {{SPV_OPERAND_TYPE_ID, {1u}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {0u}}, {SPV_OPERAND_TYPE_DECORATION, {uint32_t(spv::Decoration::Constant)}}}); // OpMemberDecorate %2 0 Constant Instruction inst2( &ir_context, spv::Op::OpMemberDecorate, 0u, 0u, {{SPV_OPERAND_TYPE_ID, {2u}}, {SPV_OPERAND_TYPE_LITERAL_INTEGER, {0u}}, {SPV_OPERAND_TYPE_DECORATION, {uint32_t(spv::Decoration::Constant)}}}); DecorationManager* decoManager = ir_context.get_decoration_mgr(); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_FALSE(decoManager->AreDecorationsTheSame(&inst1, &inst2, false)); } TEST_F(DecorationManagerTest, RemoveDecorationFromVariable) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 Constant OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 %4 = OpTypeInt 32 0 %1 = OpVariable %4 Uniform %3 = OpVariable %4 Uniform )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); decoManager->RemoveDecorationsFrom(1u); auto decorations = decoManager->GetDecorationsFor(1u, false); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_TRUE(decorations.empty()); decorations = decoManager->GetDecorationsFor(3u, false); EXPECT_THAT(GetErrorMessage(), ""); const std::string expected_decorations = R"(OpDecorate %2 Restrict )"; EXPECT_THAT(ToText(decorations), expected_decorations); const std::string expected_binary = R"(OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %3 %4 = OpTypeInt 32 0 %1 = OpVariable %4 Uniform %3 = OpVariable %4 Uniform )"; EXPECT_THAT(ModuleToText(), expected_binary); } TEST_F(DecorationManagerTest, RemoveDecorationStringFromVariable) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpExtension "SPV_GOOGLE_hlsl_functionality1" OpExtension "SPV_GOOGLE_decorate_string" OpMemoryModel Logical GLSL450 OpDecorateStringGOOGLE %1 HlslSemanticGOOGLE "hello world" OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 %4 = OpTypeInt 32 0 %1 = OpVariable %4 Uniform %3 = OpVariable %4 Uniform )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); decoManager->RemoveDecorationsFrom(1u); auto decorations = decoManager->GetDecorationsFor(1u, false); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_TRUE(decorations.empty()); decorations = decoManager->GetDecorationsFor(3u, false); EXPECT_THAT(GetErrorMessage(), ""); const std::string expected_decorations = R"(OpDecorate %2 Restrict )"; EXPECT_THAT(ToText(decorations), expected_decorations); const std::string expected_binary = R"(OpCapability Shader OpCapability Linkage OpExtension "SPV_GOOGLE_hlsl_functionality1" OpExtension "SPV_GOOGLE_decorate_string" OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %3 %4 = OpTypeInt 32 0 %1 = OpVariable %4 Uniform %3 = OpVariable %4 Uniform )"; EXPECT_THAT(ModuleToText(), expected_binary); } TEST_F(DecorationManagerTest, RemoveDecorationFromDecorationGroup) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 Constant OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 %4 = OpTypeInt 32 0 %1 = OpVariable %4 Uniform %3 = OpVariable %4 Uniform )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); decoManager->RemoveDecorationsFrom(2u); auto decorations = decoManager->GetDecorationsFor(2u, false); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_TRUE(decorations.empty()); decorations = decoManager->GetDecorationsFor(1u, false); EXPECT_THAT(GetErrorMessage(), ""); const std::string expected_decorations = R"(OpDecorate %1 Constant )"; EXPECT_THAT(ToText(decorations), expected_decorations); decorations = decoManager->GetDecorationsFor(3u, false); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_THAT(ToText(decorations), ""); const std::string expected_binary = R"(OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 Constant %2 = OpDecorationGroup %4 = OpTypeInt 32 0 %1 = OpVariable %4 Uniform %3 = OpVariable %4 Uniform )"; EXPECT_THAT(ModuleToText(), expected_binary); } TEST_F(DecorationManagerTest, RemoveDecorationFromDecorationGroupKeepDeadDecorations) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 Constant OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 = OpTypeInt 32 0 %1 = OpVariable %3 Uniform )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); decoManager->RemoveDecorationsFrom(1u); auto decorations = decoManager->GetDecorationsFor(1u, false); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_TRUE(decorations.empty()); decorations = decoManager->GetDecorationsFor(2u, false); EXPECT_THAT(GetErrorMessage(), ""); const std::string expected_decorations = R"(OpDecorate %2 Restrict )"; EXPECT_THAT(ToText(decorations), expected_decorations); const std::string expected_binary = R"(OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup %3 = OpTypeInt 32 0 %1 = OpVariable %3 Uniform )"; EXPECT_THAT(ModuleToText(), expected_binary); } TEST_F(DecorationManagerTest, RemoveAllDecorationsAppliedByGroup) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 Constant OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 OpDecorate %3 BuiltIn VertexId %3 = OpDecorationGroup OpGroupDecorate %3 %1 %4 = OpTypeInt 32 0 %1 = OpVariable %4 Input )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); decoManager->RemoveDecorationsFrom(1u, [](const Instruction& inst) { return inst.opcode() == spv::Op::OpDecorate && inst.GetSingleWordInOperand(0u) == 3u; }); auto decorations = decoManager->GetDecorationsFor(1u, false); EXPECT_THAT(GetErrorMessage(), ""); std::string expected_decorations = R"(OpDecorate %1 Constant OpDecorate %2 Restrict )"; EXPECT_THAT(ToText(decorations), expected_decorations); decorations = decoManager->GetDecorationsFor(2u, false); EXPECT_THAT(GetErrorMessage(), ""); expected_decorations = R"(OpDecorate %2 Restrict )"; EXPECT_THAT(ToText(decorations), expected_decorations); const std::string expected_binary = R"(OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 Constant OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 OpDecorate %3 BuiltIn VertexId %3 = OpDecorationGroup %4 = OpTypeInt 32 0 %1 = OpVariable %4 Input )"; EXPECT_THAT(ModuleToText(), expected_binary); } TEST_F(DecorationManagerTest, RemoveSomeDecorationsAppliedByGroup) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 Constant OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 OpDecorate %3 BuiltIn VertexId OpDecorate %3 Invariant %3 = OpDecorationGroup OpGroupDecorate %3 %1 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Input )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); decoManager->RemoveDecorationsFrom(1u, [](const Instruction& inst) { return inst.opcode() == spv::Op::OpDecorate && inst.GetSingleWordInOperand(0u) == 3u && spv::Decoration(inst.GetSingleWordInOperand(1u)) == spv::Decoration::BuiltIn; }); auto decorations = decoManager->GetDecorationsFor(1u, false); EXPECT_THAT(GetErrorMessage(), ""); std::string expected_decorations = R"(OpDecorate %1 Constant OpDecorate %1 Invariant OpDecorate %2 Restrict )"; EXPECT_THAT(ToText(decorations), expected_decorations); decorations = decoManager->GetDecorationsFor(2u, false); EXPECT_THAT(GetErrorMessage(), ""); expected_decorations = R"(OpDecorate %2 Restrict )"; EXPECT_THAT(ToText(decorations), expected_decorations); const std::string expected_binary = R"(OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 Constant OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 OpDecorate %3 BuiltIn VertexId OpDecorate %3 Invariant %3 = OpDecorationGroup OpDecorate %1 Invariant %4 = OpTypeInt 32 0 %1 = OpVariable %4 Input )"; EXPECT_THAT(ModuleToText(), expected_binary); } TEST_F(DecorationManagerTest, RemoveDecorationDecorate) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 Constant OpDecorate %1 Restrict %2 = OpTypeInt 32 0 %1 = OpVariable %2 Uniform )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); auto decorations = decoManager->GetDecorationsFor(1u, false); decoManager->RemoveDecoration(decorations.front()); decorations = decoManager->GetDecorationsFor(1u, false); EXPECT_THAT(GetErrorMessage(), ""); const std::string expected_decorations = R"(OpDecorate %1 Restrict )"; EXPECT_THAT(ToText(decorations), expected_decorations); } TEST_F(DecorationManagerTest, RemoveDecorationStringDecorate) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpExtension "SPV_GOOGLE_hlsl_functionality1" OpExtension "SPV_GOOGLE_decorate_string" OpMemoryModel Logical GLSL450 OpDecorateStringGOOGLE %1 HlslSemanticGOOGLE "foobar" OpDecorate %1 Restrict %2 = OpTypeInt 32 0 %1 = OpVariable %2 Uniform )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); auto decorations = decoManager->GetDecorationsFor(1u, false); decoManager->RemoveDecoration(decorations.front()); decorations = decoManager->GetDecorationsFor(1u, false); EXPECT_THAT(GetErrorMessage(), ""); const std::string expected_decorations = R"(OpDecorate %1 Restrict )"; EXPECT_THAT(ToText(decorations), expected_decorations); } TEST_F(DecorationManagerTest, CloneDecorations) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 Constant OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 OpDecorate %3 BuiltIn VertexId OpDecorate %3 Invariant %3 = OpDecorationGroup OpGroupDecorate %3 %1 %4 = OpTypeInt 32 0 %1 = OpVariable %4 Input %5 = OpVariable %4 Input )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); // Check cloning OpDecorate including group decorations. auto decorations = decoManager->GetDecorationsFor(5u, false); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_TRUE(decorations.empty()); decoManager->CloneDecorations(1u, 5u); decorations = decoManager->GetDecorationsFor(5u, false); EXPECT_THAT(GetErrorMessage(), ""); std::string expected_decorations = R"(OpDecorate %5 Constant OpDecorate %2 Restrict OpDecorate %3 BuiltIn VertexId OpDecorate %3 Invariant )"; EXPECT_THAT(ToText(decorations), expected_decorations); // Check that bookkeeping for ID 2 remains the same. decorations = decoManager->GetDecorationsFor(2u, false); EXPECT_THAT(GetErrorMessage(), ""); expected_decorations = R"(OpDecorate %2 Restrict )"; EXPECT_THAT(ToText(decorations), expected_decorations); const std::string expected_binary = R"(OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 Constant OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %5 OpDecorate %3 BuiltIn VertexId OpDecorate %3 Invariant %3 = OpDecorationGroup OpGroupDecorate %3 %1 %5 OpDecorate %5 Constant %4 = OpTypeInt 32 0 %1 = OpVariable %4 Input %5 = OpVariable %4 Input )"; EXPECT_THAT(ModuleToText(), expected_binary); } TEST_F(DecorationManagerTest, CloneDecorationsStringAndId) { const std::string spirv = R"(OpCapability Shader OpCapability Linkage OpExtension "SPV_GOOGLE_hlsl_functionality1" OpExtension "SPV_GOOGLE_decorate_string" OpMemoryModel Logical GLSL450 OpDecorateStringGOOGLE %1 HlslSemanticGOOGLE "blah" OpDecorateId %1 HlslCounterBufferGOOGLE %2 OpDecorate %1 Aliased %3 = OpTypeInt 32 0 %4 = OpTypePointer Uniform %3 %1 = OpVariable %4 Uniform %2 = OpVariable %4 Uniform %5 = OpVariable %4 Uniform )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); // Check cloning OpDecorate including group decorations. auto decorations = decoManager->GetDecorationsFor(5u, false); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_TRUE(decorations.empty()); decoManager->CloneDecorations(1u, 5u); decorations = decoManager->GetDecorationsFor(5u, false); EXPECT_THAT(GetErrorMessage(), ""); std::string expected_decorations = R"(OpDecorateString %5 UserSemantic "blah" OpDecorateId %5 CounterBuffer %2 OpDecorate %5 Aliased )"; EXPECT_THAT(ToText(decorations), expected_decorations); const std::string expected_binary = R"(OpCapability Shader OpCapability Linkage OpExtension "SPV_GOOGLE_hlsl_functionality1" OpExtension "SPV_GOOGLE_decorate_string" OpMemoryModel Logical GLSL450 OpDecorateString %1 UserSemantic "blah" OpDecorateId %1 CounterBuffer %2 OpDecorate %1 Aliased OpDecorateString %5 UserSemantic "blah" OpDecorateId %5 CounterBuffer %2 OpDecorate %5 Aliased %3 = OpTypeInt 32 0 %4 = OpTypePointer Uniform %3 %1 = OpVariable %4 Uniform %2 = OpVariable %4 Uniform %5 = OpVariable %4 Uniform )"; EXPECT_THAT(ModuleToText(), expected_binary); } TEST_F(DecorationManagerTest, CloneSomeDecorations) { const std::string spirv = R"(OpCapability Shader OpCapability Linkage OpExtension "SPV_GOOGLE_hlsl_functionality1" OpExtension "SPV_GOOGLE_decorate_string" OpMemoryModel Logical GLSL450 OpDecorate %1 RelaxedPrecision OpDecorate %1 Restrict %2 = OpTypeInt 32 0 %3 = OpTypePointer Function %2 %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpFunction %4 None %5 %7 = OpLabel %1 = OpVariable %3 Function %8 = OpUndef %2 OpReturn OpFunctionEnd )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_EQ(GetErrorMessage(), ""); // Check cloning OpDecorate including group decorations. auto decorations = decoManager->GetDecorationsFor(8u, false); EXPECT_EQ(GetErrorMessage(), ""); EXPECT_TRUE(decorations.empty()); decoManager->CloneDecorations(1u, 8u, {spv::Decoration::RelaxedPrecision}); decorations = decoManager->GetDecorationsFor(8u, false); EXPECT_THAT(GetErrorMessage(), ""); std::string expected_decorations = R"(OpDecorate %8 RelaxedPrecision )"; EXPECT_EQ(ToText(decorations), expected_decorations); const std::string expected_binary = R"(OpCapability Shader OpCapability Linkage OpExtension "SPV_GOOGLE_hlsl_functionality1" OpExtension "SPV_GOOGLE_decorate_string" OpMemoryModel Logical GLSL450 OpDecorate %1 RelaxedPrecision OpDecorate %1 Restrict OpDecorate %8 RelaxedPrecision %2 = OpTypeInt 32 0 %3 = OpTypePointer Function %2 %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpFunction %4 None %5 %7 = OpLabel %1 = OpVariable %3 Function %8 = OpUndef %2 OpReturn OpFunctionEnd )"; EXPECT_EQ(ModuleToText(), expected_binary); } // Test cloning decoration for an id that is decorated via a group decoration. TEST_F(DecorationManagerTest, CloneSomeGroupDecorations) { const std::string spirv = R"(OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 RelaxedPrecision OpDecorate %1 Restrict %1 = OpDecorationGroup OpGroupDecorate %1 %2 %3 = OpTypeInt 32 0 %4 = OpTypePointer Function %3 %5 = OpTypeVoid %6 = OpTypeFunction %5 %7 = OpFunction %5 None %6 %8 = OpLabel %2 = OpVariable %4 Function %9 = OpUndef %3 OpReturn OpFunctionEnd )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_EQ(GetErrorMessage(), ""); // Check cloning OpDecorate including group decorations. auto decorations = decoManager->GetDecorationsFor(9u, false); EXPECT_EQ(GetErrorMessage(), ""); EXPECT_TRUE(decorations.empty()); decoManager->CloneDecorations(2u, 9u, {spv::Decoration::RelaxedPrecision}); decorations = decoManager->GetDecorationsFor(9u, false); EXPECT_THAT(GetErrorMessage(), ""); std::string expected_decorations = R"(OpDecorate %9 RelaxedPrecision )"; EXPECT_EQ(ToText(decorations), expected_decorations); const std::string expected_binary = R"(OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 RelaxedPrecision OpDecorate %1 Restrict %1 = OpDecorationGroup OpGroupDecorate %1 %2 OpDecorate %9 RelaxedPrecision %3 = OpTypeInt 32 0 %4 = OpTypePointer Function %3 %5 = OpTypeVoid %6 = OpTypeFunction %5 %7 = OpFunction %5 None %6 %8 = OpLabel %2 = OpVariable %4 Function %9 = OpUndef %3 OpReturn OpFunctionEnd )"; EXPECT_EQ(ModuleToText(), expected_binary); } TEST_F(DecorationManagerTest, HaveTheSameDecorationsWithoutGroupsTrue) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 Restrict OpDecorate %2 Constant OpDecorate %2 Restrict OpDecorate %1 Constant %u32 = OpTypeInt 32 0 %1 = OpVariable %u32 Uniform %2 = OpVariable %u32 Uniform )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_TRUE(decoManager->HaveTheSameDecorations(1u, 2u)); } TEST_F(DecorationManagerTest, HaveTheSameDecorationsWithoutGroupsFalse) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 Restrict OpDecorate %2 Constant OpDecorate %2 Restrict %u32 = OpTypeInt 32 0 %1 = OpVariable %u32 Uniform %2 = OpVariable %u32 Uniform )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_FALSE(decoManager->HaveTheSameDecorations(1u, 2u)); } TEST_F(DecorationManagerTest, HaveTheSameDecorationsIdWithoutGroupsTrue) { const std::string spirv = R"( OpCapability Kernel OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorateId %1 AlignmentId %nine OpDecorateId %3 MaxByteOffsetId %nine OpDecorateId %3 AlignmentId %nine OpDecorateId %1 MaxByteOffsetId %nine %u32 = OpTypeInt 32 0 %nine = OpConstant %u32 9 %1 = OpVariable %u32 Uniform %3 = OpVariable %u32 Uniform )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_TRUE(decoManager->HaveTheSameDecorations(1u, 3u)); } TEST_F(DecorationManagerTest, HaveTheSameDecorationsIdWithoutGroupsFalse) { const std::string spirv = R"( OpCapability Kernel OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorateId %1 AlignmentId %nine OpDecorateId %2 MaxByteOffsetId %nine OpDecorateId %2 AlignmentId %nine %u32 = OpTypeInt 32 0 %nine = OpConstant %u32 9 %1 = OpVariable %u32 Uniform %2 = OpVariable %u32 Uniform )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_FALSE(decoManager->HaveTheSameDecorations(1u, 2u)); } TEST_F(DecorationManagerTest, HaveTheSameDecorationsStringWithoutGroupsTrue) { const std::string spirv = R"( OpCapability Kernel OpCapability Linkage OpExtension "SPV_GOOGLE_hlsl_functionality1" OpExtension "SPV_GOOGLE_decorate_string" OpMemoryModel Logical GLSL450 OpDecorateStringGOOGLE %1 HlslSemanticGOOGLE "hello" OpDecorateStringGOOGLE %2 HlslSemanticGOOGLE "world" OpDecorateStringGOOGLE %2 HlslSemanticGOOGLE "hello" OpDecorateStringGOOGLE %1 HlslSemanticGOOGLE "world" %u32 = OpTypeInt 32 0 %1 = OpVariable %u32 Uniform %2 = OpVariable %u32 Uniform )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_TRUE(decoManager->HaveTheSameDecorations(1u, 2u)); } TEST_F(DecorationManagerTest, HaveTheSameDecorationsStringWithoutGroupsFalse) { const std::string spirv = R"( OpCapability Kernel OpCapability Linkage OpExtension "SPV_GOOGLE_hlsl_functionality1" OpExtension "SPV_GOOGLE_decorate_string" OpMemoryModel Logical GLSL450 OpDecorateStringGOOGLE %1 HlslSemanticGOOGLE "hello" OpDecorateStringGOOGLE %2 HlslSemanticGOOGLE "world" OpDecorateStringGOOGLE %2 HlslSemanticGOOGLE "hello" %u32 = OpTypeInt 32 0 %1 = OpVariable %u32 Uniform %2 = OpVariable %u32 Uniform )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_FALSE(decoManager->HaveTheSameDecorations(1u, 2u)); } TEST_F(DecorationManagerTest, HaveTheSameDecorationsWithGroupsTrue) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 Restrict OpDecorate %2 Constant OpDecorate %1 Constant OpDecorate %3 Restrict %3 = OpDecorationGroup OpGroupDecorate %3 %2 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %1 %2 %u32 = OpTypeInt 32 0 %1 = OpVariable %u32 Uniform %2 = OpVariable %u32 Uniform )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_TRUE(decoManager->HaveTheSameDecorations(1u, 2u)); } TEST_F(DecorationManagerTest, HaveTheSameDecorationsWithGroupsFalse) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 Restrict OpDecorate %2 Constant OpDecorate %1 Constant OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %1 %2 %u32 = OpTypeInt 32 0 %1 = OpVariable %u32 Uniform %2 = OpVariable %u32 Uniform )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_FALSE(decoManager->HaveTheSameDecorations(1u, 2u)); } TEST_F(DecorationManagerTest, HaveTheSameDecorationsDuplicateDecorations) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 Constant OpDecorate %2 Constant OpDecorate %2 Constant %u32 = OpTypeInt 32 0 %1 = OpVariable %u32 Uniform %2 = OpVariable %u32 Uniform )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_TRUE(decoManager->HaveTheSameDecorations(1u, 2u)); } TEST_F(DecorationManagerTest, HaveTheSameDecorationsDifferentVariations) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 Location 0 OpDecorate %2 Location 1 %u32 = OpTypeInt 32 0 %1 = OpVariable %u32 Uniform %2 = OpVariable %u32 Uniform )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_FALSE(decoManager->HaveTheSameDecorations(1u, 2u)); } TEST_F(DecorationManagerTest, HaveTheSameDecorationsDuplicateMemberDecorations) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpMemberDecorate %1 0 Location 0 OpMemberDecorate %2 0 Location 0 OpMemberDecorate %2 0 Location 0 %u32 = OpTypeInt 32 0 %1 = OpTypeStruct %u32 %u32 %2 = OpTypeStruct %u32 %u32 )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_TRUE(decoManager->HaveTheSameDecorations(1u, 2u)); } TEST_F(DecorationManagerTest, HaveTheSameDecorationsDifferentMemberSameDecoration) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpMemberDecorate %1 0 Location 0 OpMemberDecorate %2 1 Location 0 %u32 = OpTypeInt 32 0 %1 = OpTypeStruct %u32 %u32 %2 = OpTypeStruct %u32 %u32 )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_FALSE(decoManager->HaveTheSameDecorations(1u, 2u)); } TEST_F(DecorationManagerTest, HaveTheSameDecorationsDifferentMemberVariations) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpMemberDecorate %1 0 Location 0 OpMemberDecorate %2 0 Location 1 %u32 = OpTypeInt 32 0 %1 = OpTypeStruct %u32 %u32 %2 = OpTypeStruct %u32 %u32 )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_FALSE(decoManager->HaveTheSameDecorations(1u, 2u)); } TEST_F(DecorationManagerTest, HaveTheSameDecorationsDuplicateIdDecorations) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorateId %1 AlignmentId %2 OpDecorateId %3 AlignmentId %2 OpDecorateId %3 AlignmentId %2 %u32 = OpTypeInt 32 0 %1 = OpVariable %u32 Uniform %3 = OpVariable %u32 Uniform %2 = OpSpecConstant %u32 0 )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_TRUE(decoManager->HaveTheSameDecorations(1u, 3u)); } TEST_F(DecorationManagerTest, HaveTheSameDecorationsDuplicateStringDecorations) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpExtension "SPV_GOOGLE_hlsl_functionality1" OpExtension "SPV_GOOGLE_decorate_string" OpMemoryModel Logical GLSL450 OpDecorateStringGOOGLE %1 HlslSemanticGOOGLE "hello" OpDecorateStringGOOGLE %2 HlslSemanticGOOGLE "hello" OpDecorateStringGOOGLE %2 HlslSemanticGOOGLE "hello" %u32 = OpTypeInt 32 0 %1 = OpVariable %u32 Uniform %2 = OpVariable %u32 Uniform )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_TRUE(decoManager->HaveTheSameDecorations(1u, 2u)); } TEST_F(DecorationManagerTest, HaveTheSameDecorationsDifferentIdVariations) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorateId %1 AlignmentId %2 OpDecorateId %3 AlignmentId %4 %u32 = OpTypeInt 32 0 %1 = OpVariable %u32 Uniform %3 = OpVariable %u32 Uniform %2 = OpSpecConstant %u32 0 %4 = OpSpecConstant %u32 0 )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_FALSE(decoManager->HaveTheSameDecorations(1u, 2u)); } TEST_F(DecorationManagerTest, HaveTheSameDecorationsDifferentStringVariations) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpExtension "SPV_GOOGLE_hlsl_functionality1" OpExtension "SPV_GOOGLE_decorate_string" OpMemoryModel Logical GLSL450 OpDecorateStringGOOGLE %1 HlslSemanticGOOGLE "hello" OpDecorateStringGOOGLE %2 HlslSemanticGOOGLE "world" )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_FALSE(decoManager->HaveTheSameDecorations(1u, 2u)); } TEST_F(DecorationManagerTest, HaveTheSameDecorationsLeftSymmetry) { // Left being a subset of right is not enough. const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 Constant OpDecorate %1 Constant OpDecorate %2 Constant OpDecorate %2 Restrict %u32 = OpTypeInt 32 0 %1 = OpVariable %u32 Uniform %2 = OpVariable %u32 Uniform )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_FALSE(decoManager->HaveTheSameDecorations(1u, 2u)); } TEST_F(DecorationManagerTest, HaveTheSameDecorationsRightSymmetry) { // Right being a subset of left is not enough. const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 Constant OpDecorate %1 Restrict OpDecorate %2 Constant OpDecorate %2 Constant %u32 = OpTypeInt 32 0 %1 = OpVariable %u32 Uniform %2 = OpVariable %u32 Uniform )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_FALSE(decoManager->HaveTheSameDecorations(1u, 2u)); } TEST_F(DecorationManagerTest, HaveTheSameDecorationIdsLeftSymmetry) { const std::string spirv = R"( OpCapability Kernel OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorateId %1 AlignmentId %nine OpDecorateId %1 AlignmentId %nine OpDecorateId %2 AlignmentId %nine OpDecorateId %2 MaxByteOffsetId %nine %u32 = OpTypeInt 32 0 %nine = OpConstant %u32 9 %1 = OpVariable %u32 Uniform %2 = OpVariable %u32 Uniform )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_FALSE(decoManager->HaveTheSameDecorations(1u, 2u)); } TEST_F(DecorationManagerTest, HaveTheSameDecorationIdsRightSymmetry) { const std::string spirv = R"( OpCapability Kernel OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorateId %1 AlignmentId %nine OpDecorateId %1 MaxByteOffsetId %nine OpDecorateId %2 AlignmentId %nine OpDecorateId %2 AlignmentId %nine %u32 = OpTypeInt 32 0 %nine = OpConstant %u32 9 %1 = OpVariable %u32 Uniform %2 = OpVariable %u32 Uniform )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_FALSE(decoManager->HaveTheSameDecorations(1u, 2u)); } TEST_F(DecorationManagerTest, HaveTheSameDecorationStringsLeftSymmetry) { const std::string spirv = R"( OpCapability Kernel OpCapability Linkage OpExtension "SPV_GOOGLE_hlsl_functionality1" OpExtension "SPV_GOOGLE_decorate_string" OpMemoryModel Logical GLSL450 OpDecorateStringGOOGLE %1 HlslSemanticGOOGLE "hello" OpDecorateStringGOOGLE %1 HlslSemanticGOOGLE "hello" OpDecorateStringGOOGLE %2 HlslSemanticGOOGLE "hello" OpDecorateStringGOOGLE %2 HlslSemanticGOOGLE "world" %u32 = OpTypeInt 32 0 %1 = OpVariable %u32 Uniform %2 = OpVariable %u32 Uniform )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_FALSE(decoManager->HaveTheSameDecorations(1u, 2u)); } TEST_F(DecorationManagerTest, HaveTheSameDecorationStringsRightSymmetry) { const std::string spirv = R"( OpCapability Kernel OpCapability Linkage OpExtension "SPV_GOOGLE_hlsl_functionality1" OpExtension "SPV_GOOGLE_decorate_string" OpMemoryModel Logical GLSL450 OpDecorateStringGOOGLE %1 HlslSemanticGOOGLE "hello" OpDecorateStringGOOGLE %1 HlslSemanticGOOGLE "world" OpDecorateStringGOOGLE %2 HlslSemanticGOOGLE "hello" OpDecorateStringGOOGLE %2 HlslSemanticGOOGLE "hello" %u32 = OpTypeInt 32 0 %1 = OpVariable %u32 Uniform %2 = OpVariable %u32 Uniform )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_FALSE(decoManager->HaveTheSameDecorations(1u, 2u)); } TEST_F(DecorationManagerTest, SubSetTestOpDecorate1) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 Restrict OpDecorate %2 Constant OpDecorate %2 Restrict OpDecorate %1 Constant %u32 = OpTypeInt 32 0 %1 = OpVariable %u32 Uniform %2 = OpVariable %u32 Uniform )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_TRUE(decoManager->HaveSubsetOfDecorations(1u, 2u)); } TEST_F(DecorationManagerTest, SubSetTestOpDecorate2) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 Restrict OpDecorate %2 Constant OpDecorate %2 Restrict %u32 = OpTypeInt 32 0 %1 = OpVariable %u32 Uniform %2 = OpVariable %u32 Uniform )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_TRUE(decoManager->HaveSubsetOfDecorations(1u, 2u)); } TEST_F(DecorationManagerTest, SubSetTestOpDecorate3) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 Constant OpDecorate %2 Constant OpDecorate %2 Restrict %u32 = OpTypeInt 32 0 %1 = OpVariable %u32 Uniform %2 = OpVariable %u32 Uniform )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_TRUE(decoManager->HaveSubsetOfDecorations(1u, 2u)); } TEST_F(DecorationManagerTest, SubSetTestOpDecorate4) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 Restrict OpDecorate %2 Constant OpDecorate %2 Restrict OpDecorate %1 Constant %u32 = OpTypeInt 32 0 %1 = OpVariable %u32 Uniform %2 = OpVariable %u32 Uniform )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_TRUE(decoManager->HaveSubsetOfDecorations(2u, 1u)); } TEST_F(DecorationManagerTest, SubSetTestOpDecorate5) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 Restrict OpDecorate %2 Constant OpDecorate %2 Restrict %u32 = OpTypeInt 32 0 %1 = OpVariable %u32 Uniform %2 = OpVariable %u32 Uniform )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_FALSE(decoManager->HaveSubsetOfDecorations(2u, 1u)); } TEST_F(DecorationManagerTest, SubSetTestOpDecorate6) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 Constant OpDecorate %2 Constant OpDecorate %2 Restrict %u32 = OpTypeInt 32 0 %1 = OpVariable %u32 Uniform %2 = OpVariable %u32 Uniform )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_FALSE(decoManager->HaveSubsetOfDecorations(2u, 1u)); } TEST_F(DecorationManagerTest, SubSetTestOpDecorate7) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 Constant OpDecorate %2 Constant OpDecorate %2 Restrict OpDecorate %1 Invariant %u32 = OpTypeInt 32 0 %1 = OpVariable %u32 Uniform %2 = OpVariable %u32 Uniform )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_FALSE(decoManager->HaveSubsetOfDecorations(2u, 1u)); EXPECT_FALSE(decoManager->HaveSubsetOfDecorations(1u, 2u)); } TEST_F(DecorationManagerTest, SubSetTestOpMemberDecorate1) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpMemberDecorate %1 0 Offset 0 OpMemberDecorate %1 0 Offset 4 OpMemberDecorate %2 0 Offset 0 OpMemberDecorate %2 0 Offset 4 %u32 = OpTypeInt 32 0 %1 = OpTypeStruct %u32 %u32 %u32 %2 = OpTypeStruct %u32 %u32 %u32 )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_TRUE(decoManager->HaveSubsetOfDecorations(1u, 2u)); EXPECT_TRUE(decoManager->HaveSubsetOfDecorations(2u, 1u)); } TEST_F(DecorationManagerTest, SubSetTestOpMemberDecorate2) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpMemberDecorate %1 0 Offset 0 OpMemberDecorate %2 0 Offset 0 OpMemberDecorate %2 0 Offset 4 %u32 = OpTypeInt 32 0 %1 = OpTypeStruct %u32 %u32 %u32 %2 = OpTypeStruct %u32 %u32 %u32 )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_TRUE(decoManager->HaveSubsetOfDecorations(1u, 2u)); EXPECT_FALSE(decoManager->HaveSubsetOfDecorations(2u, 1u)); } TEST_F(DecorationManagerTest, SubSetTestOpDecorateId1) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorateId %1 AlignmentId %2 %u32 = OpTypeInt 32 0 %1 = OpVariable %u32 Uniform %3 = OpVariable %u32 Uniform %2 = OpSpecConstant %u32 0 )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_FALSE(decoManager->HaveSubsetOfDecorations(1u, 3u)); EXPECT_TRUE(decoManager->HaveSubsetOfDecorations(3u, 1u)); } TEST_F(DecorationManagerTest, SubSetTestOpDecorateId2) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorateId %1 AlignmentId %2 OpDecorateId %3 AlignmentId %4 %u32 = OpTypeInt 32 0 %1 = OpVariable %u32 Uniform %3 = OpVariable %u32 Uniform %2 = OpSpecConstant %u32 0 %4 = OpSpecConstant %u32 1 )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_FALSE(decoManager->HaveSubsetOfDecorations(1u, 3u)); EXPECT_FALSE(decoManager->HaveSubsetOfDecorations(3u, 1u)); } TEST_F(DecorationManagerTest, SubSetTestOpDecorateString1) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpExtension "SPV_GOOGLE_hlsl_functionality1" OpExtension "SPV_GOOGLE_decorate_string" OpMemoryModel Logical GLSL450 OpDecorateString %1 HlslSemanticGOOGLE "hello" OpDecorateString %2 HlslSemanticGOOGLE "world" )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_FALSE(decoManager->HaveSubsetOfDecorations(1u, 2u)); EXPECT_FALSE(decoManager->HaveSubsetOfDecorations(2u, 1u)); } TEST_F(DecorationManagerTest, SubSetTestOpDecorateString2) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpExtension "SPV_GOOGLE_hlsl_functionality1" OpExtension "SPV_GOOGLE_decorate_string" OpMemoryModel Logical GLSL450 OpDecorateString %1 HlslSemanticGOOGLE "hello" )"; DecorationManager* decoManager = GetDecorationManager(spirv); EXPECT_THAT(GetErrorMessage(), ""); EXPECT_FALSE(decoManager->HaveSubsetOfDecorations(1u, 2u)); EXPECT_TRUE(decoManager->HaveSubsetOfDecorations(2u, 1u)); } } // namespace } // namespace analysis } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/def_use_test.cpp000066400000000000000000001455131475742701700235000ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include #include #include "gmock/gmock.h" #include "gtest/gtest.h" #include "source/opt/build_module.h" #include "source/opt/def_use_manager.h" #include "source/opt/ir_context.h" #include "source/opt/module.h" #include "spirv-tools/libspirv.hpp" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace analysis { namespace { using ::testing::Contains; using ::testing::UnorderedElementsAre; using ::testing::UnorderedElementsAreArray; // Returns the number of uses of |id|. uint32_t NumUses(const std::unique_ptr& context, uint32_t id) { uint32_t count = 0; context->get_def_use_mgr()->ForEachUse( id, [&count](Instruction*, uint32_t) { ++count; }); return count; } // Returns the opcode of each use of |id|. // // If |id| is used multiple times in a single instruction, that instruction's // opcode will appear a corresponding number of times. std::vector GetUseOpcodes(const std::unique_ptr& context, uint32_t id) { std::vector opcodes; context->get_def_use_mgr()->ForEachUse( id, [&opcodes](Instruction* user, uint32_t) { opcodes.push_back(user->opcode()); }); return opcodes; } // Disassembles the given |inst| and returns the disassembly. std::string DisassembleInst(Instruction* inst) { SpirvTools tools(SPV_ENV_UNIVERSAL_1_1); std::vector binary; // We need this to generate the necessary header in the binary. tools.Assemble("", &binary); inst->ToBinaryWithoutAttachedDebugInsts(&binary); std::string text; // We'll need to check the underlying id numbers. // So turn off friendly names for ids. tools.Disassemble(binary, &text, SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); while (!text.empty() && text.back() == '\n') text.pop_back(); return text; } // A struct for holding expected id defs and uses. struct InstDefUse { using IdInstPair = std::pair; using IdInstsPair = std::pair>; // Ids and their corresponding def instructions. std::vector defs; // Ids and their corresponding use instructions. std::vector uses; }; // Checks that the |actual_defs| and |actual_uses| are in accord with // |expected_defs_uses|. void CheckDef(const InstDefUse& expected_defs_uses, const DefUseManager::IdToDefMap& actual_defs) { // Check defs. ASSERT_EQ(expected_defs_uses.defs.size(), actual_defs.size()); for (uint32_t i = 0; i < expected_defs_uses.defs.size(); ++i) { const auto id = expected_defs_uses.defs[i].first; const auto expected_def = expected_defs_uses.defs[i].second; ASSERT_EQ(1u, actual_defs.count(id)) << "expected to def id [" << id << "]"; auto def = actual_defs.at(id); if (def->opcode() != spv::Op::OpConstant) { // Constants don't disassemble properly without a full context. EXPECT_EQ(expected_def, DisassembleInst(actual_defs.at(id))); } } } using UserMap = std::unordered_map>; // Creates a mapping of all definitions to their users (except OpConstant). // // OpConstants are skipped because they cannot be disassembled in isolation. UserMap BuildAllUsers(const DefUseManager* mgr, uint32_t idBound) { UserMap userMap; for (uint32_t id = 0; id != idBound; ++id) { if (mgr->GetDef(id)) { mgr->ForEachUser(id, [id, &userMap](Instruction* user) { if (user->opcode() != spv::Op::OpConstant) { userMap[id].push_back(user); } }); } } return userMap; } // Constants don't disassemble properly without a full context, so skip them as // checks. void CheckUse(const InstDefUse& expected_defs_uses, const DefUseManager* mgr, uint32_t idBound) { UserMap actual_uses = BuildAllUsers(mgr, idBound); // Check uses. ASSERT_EQ(expected_defs_uses.uses.size(), actual_uses.size()); for (uint32_t i = 0; i < expected_defs_uses.uses.size(); ++i) { const auto id = expected_defs_uses.uses[i].first; const auto& expected_uses = expected_defs_uses.uses[i].second; ASSERT_EQ(1u, actual_uses.count(id)) << "expected to use id [" << id << "]"; const auto& uses = actual_uses.at(id); ASSERT_EQ(expected_uses.size(), uses.size()) << "id [" << id << "] # uses: expected: " << expected_uses.size() << " actual: " << uses.size(); std::vector actual_uses_disassembled; for (const auto actual_use : uses) { actual_uses_disassembled.emplace_back(DisassembleInst(actual_use)); } EXPECT_THAT(actual_uses_disassembled, UnorderedElementsAreArray(expected_uses)); } } // The following test case mimics how LLVM handles induction variables. // But, yeah, it's not very readable. However, we only care about the id // defs and uses. So, no need to make sure this is valid OpPhi construct. const char kOpPhiTestFunction[] = " %1 = OpTypeVoid " " %6 = OpTypeInt 32 0 " "%10 = OpTypeFloat 32 " "%16 = OpTypeBool " " %3 = OpTypeFunction %1 " " %8 = OpConstant %6 0 " "%18 = OpConstant %6 1 " "%12 = OpConstant %10 1.0 " " %2 = OpFunction %1 None %3 " " %4 = OpLabel " " OpBranch %5 " " %5 = OpLabel " " %7 = OpPhi %6 %8 %4 %9 %5 " "%11 = OpPhi %10 %12 %4 %13 %5 " " %9 = OpIAdd %6 %7 %8 " "%13 = OpFAdd %10 %11 %12 " "%17 = OpSLessThan %16 %7 %18 " " OpLoopMerge %19 %5 None " " OpBranchConditional %17 %5 %19 " "%19 = OpLabel " " OpReturn " " OpFunctionEnd"; struct ParseDefUseCase { const char* text; InstDefUse du; }; using ParseDefUseTest = ::testing::TestWithParam; TEST_P(ParseDefUseTest, Case) { const auto& tc = GetParam(); // Build module. const std::vector text = {tc.text}; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, JoinAllInsts(text), SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); ASSERT_NE(nullptr, context); // Analyze def and use. DefUseManager manager(context->module()); CheckDef(tc.du, manager.id_to_defs()); CheckUse(tc.du, &manager, context->module()->IdBound()); } // clang-format off INSTANTIATE_TEST_SUITE_P( TestCase, ParseDefUseTest, ::testing::ValuesIn(std::vector{ {"", {{}, {}}}, // no instruction {"OpMemoryModel Logical GLSL450", {{}, {}}}, // no def and use { // single def, no use "%1 = OpString \"wow\"", { {{1, "%1 = OpString \"wow\""}}, // defs {} // uses } }, { // multiple def, no use "%1 = OpString \"hello\" " "%2 = OpString \"world\" " "%3 = OpTypeVoid", { { // defs {1, "%1 = OpString \"hello\""}, {2, "%2 = OpString \"world\""}, {3, "%3 = OpTypeVoid"}, }, {} // uses } }, { // multiple def, multiple use "%1 = OpTypeBool " "%2 = OpTypeVector %1 3 " "%3 = OpTypeMatrix %2 3", { { // defs {1, "%1 = OpTypeBool"}, {2, "%2 = OpTypeVector %1 3"}, {3, "%3 = OpTypeMatrix %2 3"}, }, { // uses {1, {"%2 = OpTypeVector %1 3"}}, {2, {"%3 = OpTypeMatrix %2 3"}}, } } }, { // multiple use of the same id "%1 = OpTypeBool " "%2 = OpTypeVector %1 2 " "%3 = OpTypeVector %1 3 " "%4 = OpTypeVector %1 4", { { // defs {1, "%1 = OpTypeBool"}, {2, "%2 = OpTypeVector %1 2"}, {3, "%3 = OpTypeVector %1 3"}, {4, "%4 = OpTypeVector %1 4"}, }, { // uses {1, { "%2 = OpTypeVector %1 2", "%3 = OpTypeVector %1 3", "%4 = OpTypeVector %1 4", } }, } } }, { // labels "%1 = OpTypeVoid " "%2 = OpTypeBool " "%3 = OpTypeFunction %1 " "%4 = OpConstantTrue %2 " "%5 = OpFunction %1 None %3 " "%6 = OpLabel " "OpBranchConditional %4 %7 %8 " "%7 = OpLabel " "OpBranch %7 " "%8 = OpLabel " "OpReturn " "OpFunctionEnd", { { // defs {1, "%1 = OpTypeVoid"}, {2, "%2 = OpTypeBool"}, {3, "%3 = OpTypeFunction %1"}, {4, "%4 = OpConstantTrue %2"}, {5, "%5 = OpFunction %1 None %3"}, {6, "%6 = OpLabel"}, {7, "%7 = OpLabel"}, {8, "%8 = OpLabel"}, }, { // uses {1, { "%3 = OpTypeFunction %1", "%5 = OpFunction %1 None %3", } }, {2, {"%4 = OpConstantTrue %2"}}, {3, {"%5 = OpFunction %1 None %3"}}, {4, {"OpBranchConditional %4 %7 %8"}}, {7, { "OpBranchConditional %4 %7 %8", "OpBranch %7", } }, {8, {"OpBranchConditional %4 %7 %8"}}, } } }, { // cross function "%1 = OpTypeBool " "%3 = OpTypeFunction %1 " "%2 = OpFunction %1 None %3 " "%4 = OpLabel " "%5 = OpVariable %1 Function " "%6 = OpFunctionCall %1 %2 %5 " "OpReturnValue %6 " "OpFunctionEnd", { { // defs {1, "%1 = OpTypeBool"}, {2, "%2 = OpFunction %1 None %3"}, {3, "%3 = OpTypeFunction %1"}, {4, "%4 = OpLabel"}, {5, "%5 = OpVariable %1 Function"}, {6, "%6 = OpFunctionCall %1 %2 %5"}, }, { // uses {1, { "%2 = OpFunction %1 None %3", "%3 = OpTypeFunction %1", "%5 = OpVariable %1 Function", "%6 = OpFunctionCall %1 %2 %5", } }, {2, {"%6 = OpFunctionCall %1 %2 %5"}}, {3, {"%2 = OpFunction %1 None %3"}}, {5, {"%6 = OpFunctionCall %1 %2 %5"}}, {6, {"OpReturnValue %6"}}, } } }, { // selection merge and loop merge "%1 = OpTypeVoid " "%3 = OpTypeFunction %1 " "%10 = OpTypeBool " "%8 = OpConstantTrue %10 " "%2 = OpFunction %1 None %3 " "%4 = OpLabel " "OpLoopMerge %5 %4 None " "OpBranch %6 " "%5 = OpLabel " "OpReturn " "%6 = OpLabel " "OpSelectionMerge %7 None " "OpBranchConditional %8 %9 %7 " "%7 = OpLabel " "OpReturn " "%9 = OpLabel " "OpReturn " "OpFunctionEnd", { { // defs {1, "%1 = OpTypeVoid"}, {2, "%2 = OpFunction %1 None %3"}, {3, "%3 = OpTypeFunction %1"}, {4, "%4 = OpLabel"}, {5, "%5 = OpLabel"}, {6, "%6 = OpLabel"}, {7, "%7 = OpLabel"}, {8, "%8 = OpConstantTrue %10"}, {9, "%9 = OpLabel"}, {10, "%10 = OpTypeBool"}, }, { // uses {1, { "%2 = OpFunction %1 None %3", "%3 = OpTypeFunction %1", } }, {3, {"%2 = OpFunction %1 None %3"}}, {4, {"OpLoopMerge %5 %4 None"}}, {5, {"OpLoopMerge %5 %4 None"}}, {6, {"OpBranch %6"}}, {7, { "OpSelectionMerge %7 None", "OpBranchConditional %8 %9 %7", } }, {8, {"OpBranchConditional %8 %9 %7"}}, {9, {"OpBranchConditional %8 %9 %7"}}, {10, {"%8 = OpConstantTrue %10"}}, } } }, { // Forward reference "OpDecorate %1 Block " "OpTypeForwardPointer %2 Input " "%3 = OpTypeInt 32 0 " "%1 = OpTypeStruct %3 " "%2 = OpTypePointer Input %3", { { // defs {1, "%1 = OpTypeStruct %3"}, {2, "%2 = OpTypePointer Input %3"}, {3, "%3 = OpTypeInt 32 0"}, }, { // uses {1, {"OpDecorate %1 Block"}}, {2, {"OpTypeForwardPointer %2 Input"}}, {3, { "%1 = OpTypeStruct %3", "%2 = OpTypePointer Input %3", } } }, }, }, { // OpPhi kOpPhiTestFunction, { { // defs {1, "%1 = OpTypeVoid"}, {2, "%2 = OpFunction %1 None %3"}, {3, "%3 = OpTypeFunction %1"}, {4, "%4 = OpLabel"}, {5, "%5 = OpLabel"}, {6, "%6 = OpTypeInt 32 0"}, {7, "%7 = OpPhi %6 %8 %4 %9 %5"}, {8, "%8 = OpConstant %6 0"}, {9, "%9 = OpIAdd %6 %7 %8"}, {10, "%10 = OpTypeFloat 32"}, {11, "%11 = OpPhi %10 %12 %4 %13 %5"}, {12, "%12 = OpConstant %10 1.0"}, {13, "%13 = OpFAdd %10 %11 %12"}, {16, "%16 = OpTypeBool"}, {17, "%17 = OpSLessThan %16 %7 %18"}, {18, "%18 = OpConstant %6 1"}, {19, "%19 = OpLabel"}, }, { // uses {1, { "%2 = OpFunction %1 None %3", "%3 = OpTypeFunction %1", } }, {3, {"%2 = OpFunction %1 None %3"}}, {4, { "%7 = OpPhi %6 %8 %4 %9 %5", "%11 = OpPhi %10 %12 %4 %13 %5", } }, {5, { "OpBranch %5", "%7 = OpPhi %6 %8 %4 %9 %5", "%11 = OpPhi %10 %12 %4 %13 %5", "OpLoopMerge %19 %5 None", "OpBranchConditional %17 %5 %19", } }, {6, { // Can't check constants properly // "%8 = OpConstant %6 0", // "%18 = OpConstant %6 1", "%7 = OpPhi %6 %8 %4 %9 %5", "%9 = OpIAdd %6 %7 %8", } }, {7, { "%9 = OpIAdd %6 %7 %8", "%17 = OpSLessThan %16 %7 %18", } }, {8, { "%7 = OpPhi %6 %8 %4 %9 %5", "%9 = OpIAdd %6 %7 %8", } }, {9, {"%7 = OpPhi %6 %8 %4 %9 %5"}}, {10, { // "%12 = OpConstant %10 1.0", "%11 = OpPhi %10 %12 %4 %13 %5", "%13 = OpFAdd %10 %11 %12", } }, {11, {"%13 = OpFAdd %10 %11 %12"}}, {12, { "%11 = OpPhi %10 %12 %4 %13 %5", "%13 = OpFAdd %10 %11 %12", } }, {13, {"%11 = OpPhi %10 %12 %4 %13 %5"}}, {16, {"%17 = OpSLessThan %16 %7 %18"}}, {17, {"OpBranchConditional %17 %5 %19"}}, {18, {"%17 = OpSLessThan %16 %7 %18"}}, {19, { "OpLoopMerge %19 %5 None", "OpBranchConditional %17 %5 %19", } }, }, }, }, { // OpPhi defining and referencing the same id. "%1 = OpTypeBool " "%3 = OpTypeFunction %1 " "%2 = OpConstantTrue %1 " "%4 = OpFunction %1 None %3 " "%6 = OpLabel " " OpBranch %7 " "%7 = OpLabel " "%8 = OpPhi %1 %8 %7 %2 %6 " // both defines and uses %8 " OpBranch %7 " " OpFunctionEnd", { { // defs {1, "%1 = OpTypeBool"}, {2, "%2 = OpConstantTrue %1"}, {3, "%3 = OpTypeFunction %1"}, {4, "%4 = OpFunction %1 None %3"}, {6, "%6 = OpLabel"}, {7, "%7 = OpLabel"}, {8, "%8 = OpPhi %1 %8 %7 %2 %6"}, }, { // uses {1, { "%2 = OpConstantTrue %1", "%3 = OpTypeFunction %1", "%4 = OpFunction %1 None %3", "%8 = OpPhi %1 %8 %7 %2 %6", } }, {2, {"%8 = OpPhi %1 %8 %7 %2 %6"}}, {3, {"%4 = OpFunction %1 None %3"}}, {6, {"%8 = OpPhi %1 %8 %7 %2 %6"}}, {7, { "OpBranch %7", "%8 = OpPhi %1 %8 %7 %2 %6", "OpBranch %7", } }, {8, {"%8 = OpPhi %1 %8 %7 %2 %6"}}, }, }, }, }) ); // clang-format on struct ReplaceUseCase { const char* before; std::vector> candidates; const char* after; InstDefUse du; }; using ReplaceUseTest = ::testing::TestWithParam; // Disassembles the given |module| and returns the disassembly. std::string DisassembleModule(Module* module) { SpirvTools tools(SPV_ENV_UNIVERSAL_1_1); std::vector binary; module->ToBinary(&binary, /* skip_nop = */ false); std::string text; // We'll need to check the underlying id numbers. // So turn off friendly names for ids. tools.Disassemble(binary, &text, SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); while (!text.empty() && text.back() == '\n') text.pop_back(); return text; } TEST_P(ReplaceUseTest, Case) { const auto& tc = GetParam(); // Build module. const std::vector text = {tc.before}; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, JoinAllInsts(text), SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); ASSERT_NE(nullptr, context); // Force a re-build of def-use manager. context->InvalidateAnalyses(IRContext::Analysis::kAnalysisDefUse); (void)context->get_def_use_mgr(); // Do the substitution. for (const auto& candidate : tc.candidates) { context->ReplaceAllUsesWith(candidate.first, candidate.second); } EXPECT_EQ(tc.after, DisassembleModule(context->module())); CheckDef(tc.du, context->get_def_use_mgr()->id_to_defs()); CheckUse(tc.du, context->get_def_use_mgr(), context->module()->IdBound()); } // clang-format off INSTANTIATE_TEST_SUITE_P( TestCase, ReplaceUseTest, ::testing::ValuesIn(std::vector{ { // no use, no replace request "", {}, "", {}, }, { // replace one use "%1 = OpTypeBool " "%2 = OpTypeVector %1 3 " "%3 = OpTypeInt 32 0 ", {{1, 3}}, "%1 = OpTypeBool\n" "%2 = OpTypeVector %3 3\n" "%3 = OpTypeInt 32 0", { { // defs {1, "%1 = OpTypeBool"}, {2, "%2 = OpTypeVector %3 3"}, {3, "%3 = OpTypeInt 32 0"}, }, { // uses {3, {"%2 = OpTypeVector %3 3"}}, }, }, }, { // replace and then replace back "%1 = OpTypeBool " "%2 = OpTypeVector %1 3 " "%3 = OpTypeInt 32 0", {{1, 3}, {3, 1}}, "%1 = OpTypeBool\n" "%2 = OpTypeVector %1 3\n" "%3 = OpTypeInt 32 0", { { // defs {1, "%1 = OpTypeBool"}, {2, "%2 = OpTypeVector %1 3"}, {3, "%3 = OpTypeInt 32 0"}, }, { // uses {1, {"%2 = OpTypeVector %1 3"}}, }, }, }, { // replace with the same id "%1 = OpTypeBool " "%2 = OpTypeVector %1 3", {{1, 1}, {2, 2}, {3, 3}}, "%1 = OpTypeBool\n" "%2 = OpTypeVector %1 3", { { // defs {1, "%1 = OpTypeBool"}, {2, "%2 = OpTypeVector %1 3"}, }, { // uses {1, {"%2 = OpTypeVector %1 3"}}, }, }, }, { // replace in sequence "%1 = OpTypeBool " "%2 = OpTypeVector %1 3 " "%3 = OpTypeInt 32 0 " "%4 = OpTypeInt 32 1 ", {{1, 3}, {3, 4}}, "%1 = OpTypeBool\n" "%2 = OpTypeVector %4 3\n" "%3 = OpTypeInt 32 0\n" "%4 = OpTypeInt 32 1", { { // defs {1, "%1 = OpTypeBool"}, {2, "%2 = OpTypeVector %4 3"}, {3, "%3 = OpTypeInt 32 0"}, {4, "%4 = OpTypeInt 32 1"}, }, { // uses {4, {"%2 = OpTypeVector %4 3"}}, }, }, }, { // replace multiple uses "%1 = OpTypeBool " "%2 = OpTypeVector %1 2 " "%3 = OpTypeVector %1 3 " "%4 = OpTypeVector %1 4 " "%5 = OpTypeMatrix %2 2 " "%6 = OpTypeMatrix %3 3 " "%7 = OpTypeMatrix %4 4 " "%8 = OpTypeInt 32 0 " "%9 = OpTypeInt 32 1 " "%10 = OpTypeInt 64 0", {{1, 8}, {2, 9}, {4, 10}}, "%1 = OpTypeBool\n" "%2 = OpTypeVector %8 2\n" "%3 = OpTypeVector %8 3\n" "%4 = OpTypeVector %8 4\n" "%5 = OpTypeMatrix %9 2\n" "%6 = OpTypeMatrix %3 3\n" "%7 = OpTypeMatrix %10 4\n" "%8 = OpTypeInt 32 0\n" "%9 = OpTypeInt 32 1\n" "%10 = OpTypeInt 64 0", { { // defs {1, "%1 = OpTypeBool"}, {2, "%2 = OpTypeVector %8 2"}, {3, "%3 = OpTypeVector %8 3"}, {4, "%4 = OpTypeVector %8 4"}, {5, "%5 = OpTypeMatrix %9 2"}, {6, "%6 = OpTypeMatrix %3 3"}, {7, "%7 = OpTypeMatrix %10 4"}, {8, "%8 = OpTypeInt 32 0"}, {9, "%9 = OpTypeInt 32 1"}, {10, "%10 = OpTypeInt 64 0"}, }, { // uses {8, { "%2 = OpTypeVector %8 2", "%3 = OpTypeVector %8 3", "%4 = OpTypeVector %8 4", } }, {9, {"%5 = OpTypeMatrix %9 2"}}, {3, {"%6 = OpTypeMatrix %3 3"}}, {10, {"%7 = OpTypeMatrix %10 4"}}, }, }, }, { // OpPhi. kOpPhiTestFunction, // replace one id used by OpPhi, replace one id generated by OpPhi {{9, 13}, {11, 9}}, "%1 = OpTypeVoid\n" "%6 = OpTypeInt 32 0\n" "%10 = OpTypeFloat 32\n" "%16 = OpTypeBool\n" "%3 = OpTypeFunction %1\n" "%8 = OpConstant %6 0\n" "%18 = OpConstant %6 1\n" "%12 = OpConstant %10 1\n" "%2 = OpFunction %1 None %3\n" "%4 = OpLabel\n" "OpBranch %5\n" "%5 = OpLabel\n" "%7 = OpPhi %6 %8 %4 %13 %5\n" // %9 -> %13 "%11 = OpPhi %10 %12 %4 %13 %5\n" "%9 = OpIAdd %6 %7 %8\n" "%13 = OpFAdd %10 %9 %12\n" // %11 -> %9 "%17 = OpSLessThan %16 %7 %18\n" "OpLoopMerge %19 %5 None\n" "OpBranchConditional %17 %5 %19\n" "%19 = OpLabel\n" "OpReturn\n" "OpFunctionEnd", { { // defs. {1, "%1 = OpTypeVoid"}, {2, "%2 = OpFunction %1 None %3"}, {3, "%3 = OpTypeFunction %1"}, {4, "%4 = OpLabel"}, {5, "%5 = OpLabel"}, {6, "%6 = OpTypeInt 32 0"}, {7, "%7 = OpPhi %6 %8 %4 %13 %5"}, {8, "%8 = OpConstant %6 0"}, {9, "%9 = OpIAdd %6 %7 %8"}, {10, "%10 = OpTypeFloat 32"}, {11, "%11 = OpPhi %10 %12 %4 %13 %5"}, {12, "%12 = OpConstant %10 1.0"}, {13, "%13 = OpFAdd %10 %9 %12"}, {16, "%16 = OpTypeBool"}, {17, "%17 = OpSLessThan %16 %7 %18"}, {18, "%18 = OpConstant %6 1"}, {19, "%19 = OpLabel"}, }, { // uses {1, { "%2 = OpFunction %1 None %3", "%3 = OpTypeFunction %1", } }, {3, {"%2 = OpFunction %1 None %3"}}, {4, { "%7 = OpPhi %6 %8 %4 %13 %5", "%11 = OpPhi %10 %12 %4 %13 %5", } }, {5, { "OpBranch %5", "%7 = OpPhi %6 %8 %4 %13 %5", "%11 = OpPhi %10 %12 %4 %13 %5", "OpLoopMerge %19 %5 None", "OpBranchConditional %17 %5 %19", } }, {6, { // Can't properly check constants // "%8 = OpConstant %6 0", // "%18 = OpConstant %6 1", "%7 = OpPhi %6 %8 %4 %13 %5", "%9 = OpIAdd %6 %7 %8" } }, {7, { "%9 = OpIAdd %6 %7 %8", "%17 = OpSLessThan %16 %7 %18", } }, {8, { "%7 = OpPhi %6 %8 %4 %13 %5", "%9 = OpIAdd %6 %7 %8", } }, {9, {"%13 = OpFAdd %10 %9 %12"}}, // uses of %9 changed from %7 to %13 {10, { "%11 = OpPhi %10 %12 %4 %13 %5", // "%12 = OpConstant %10 1", "%13 = OpFAdd %10 %9 %12" } }, // no more uses of %11 {12, { "%11 = OpPhi %10 %12 %4 %13 %5", "%13 = OpFAdd %10 %9 %12" } }, {13, { "%7 = OpPhi %6 %8 %4 %13 %5", "%11 = OpPhi %10 %12 %4 %13 %5", } }, {16, {"%17 = OpSLessThan %16 %7 %18"}}, {17, {"OpBranchConditional %17 %5 %19"}}, {18, {"%17 = OpSLessThan %16 %7 %18"}}, {19, { "OpLoopMerge %19 %5 None", "OpBranchConditional %17 %5 %19", } }, }, }, }, { // OpPhi defining and referencing the same id. "%1 = OpTypeBool " "%3 = OpTypeFunction %1 " "%2 = OpConstantTrue %1 " "%4 = OpFunction %3 None %1 " "%6 = OpLabel " " OpBranch %7 " "%7 = OpLabel " "%8 = OpPhi %1 %8 %7 %2 %6 " // both defines and uses %8 " OpBranch %7 " " OpFunctionEnd", {{8, 2}}, "%1 = OpTypeBool\n" "%3 = OpTypeFunction %1\n" "%2 = OpConstantTrue %1\n" "%4 = OpFunction %3 None %1\n" "%6 = OpLabel\n" "OpBranch %7\n" "%7 = OpLabel\n" "%8 = OpPhi %1 %2 %7 %2 %6\n" // use of %8 changed to %2 "OpBranch %7\n" "OpFunctionEnd", { { // defs {1, "%1 = OpTypeBool"}, {2, "%2 = OpConstantTrue %1"}, {3, "%3 = OpTypeFunction %1"}, {4, "%4 = OpFunction %3 None %1"}, {6, "%6 = OpLabel"}, {7, "%7 = OpLabel"}, {8, "%8 = OpPhi %1 %2 %7 %2 %6"}, }, { // uses {1, { "%2 = OpConstantTrue %1", "%3 = OpTypeFunction %1", "%4 = OpFunction %3 None %1", "%8 = OpPhi %1 %2 %7 %2 %6", } }, {2, { // Only checking users "%8 = OpPhi %1 %2 %7 %2 %6", } }, {3, {"%4 = OpFunction %3 None %1"}}, {6, {"%8 = OpPhi %1 %2 %7 %2 %6"}}, {7, { "OpBranch %7", "%8 = OpPhi %1 %2 %7 %2 %6", "OpBranch %7", } }, // {8, {"%8 = OpPhi %1 %8 %7 %2 %6"}}, }, }, }, }) ); // clang-format on struct KillDefCase { const char* before; std::vector ids_to_kill; const char* after; InstDefUse du; }; using KillDefTest = ::testing::TestWithParam; TEST_P(KillDefTest, Case) { const auto& tc = GetParam(); // Build module. const std::vector text = {tc.before}; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, JoinAllInsts(text), SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); ASSERT_NE(nullptr, context); // Analyze def and use. DefUseManager manager(context->module()); // Do the substitution. for (const auto id : tc.ids_to_kill) context->KillDef(id); EXPECT_EQ(tc.after, DisassembleModule(context->module())); CheckDef(tc.du, context->get_def_use_mgr()->id_to_defs()); CheckUse(tc.du, context->get_def_use_mgr(), context->module()->IdBound()); } // clang-format off INSTANTIATE_TEST_SUITE_P( TestCase, KillDefTest, ::testing::ValuesIn(std::vector{ { // no def, no use, no kill "", {}, "", {} }, { // kill nothing "%1 = OpTypeBool " "%2 = OpTypeVector %1 2 " "%3 = OpTypeVector %1 3 ", {}, "%1 = OpTypeBool\n" "%2 = OpTypeVector %1 2\n" "%3 = OpTypeVector %1 3", { { // defs {1, "%1 = OpTypeBool"}, {2, "%2 = OpTypeVector %1 2"}, {3, "%3 = OpTypeVector %1 3"}, }, { // uses {1, { "%2 = OpTypeVector %1 2", "%3 = OpTypeVector %1 3", } }, }, }, }, { // kill id used, kill id not used, kill id not defined "%1 = OpTypeBool " "%2 = OpTypeVector %1 2 " "%3 = OpTypeVector %1 3 " "%4 = OpTypeVector %1 4 " "%5 = OpTypeMatrix %3 3 " "%6 = OpTypeMatrix %2 3", {1, 3, 5, 10}, // ids to kill "%2 = OpTypeVector %1 2\n" "%4 = OpTypeVector %1 4\n" "%6 = OpTypeMatrix %2 3", { { // defs {2, "%2 = OpTypeVector %1 2"}, {4, "%4 = OpTypeVector %1 4"}, {6, "%6 = OpTypeMatrix %2 3"}, }, { // uses. %1 and %3 are both killed, so no uses // recorded for them anymore. {2, {"%6 = OpTypeMatrix %2 3"}}, } }, }, { // OpPhi. kOpPhiTestFunction, {9, 11}, // kill one id used by OpPhi, kill one id generated by OpPhi "%1 = OpTypeVoid\n" "%6 = OpTypeInt 32 0\n" "%10 = OpTypeFloat 32\n" "%16 = OpTypeBool\n" "%3 = OpTypeFunction %1\n" "%8 = OpConstant %6 0\n" "%18 = OpConstant %6 1\n" "%12 = OpConstant %10 1\n" "%2 = OpFunction %1 None %3\n" "%4 = OpLabel\n" "OpBranch %5\n" "%5 = OpLabel\n" "%7 = OpPhi %6 %8 %4 %9 %5\n" "%13 = OpFAdd %10 %11 %12\n" "%17 = OpSLessThan %16 %7 %18\n" "OpLoopMerge %19 %5 None\n" "OpBranchConditional %17 %5 %19\n" "%19 = OpLabel\n" "OpReturn\n" "OpFunctionEnd", { { // defs. %9 & %11 are killed. {1, "%1 = OpTypeVoid"}, {2, "%2 = OpFunction %1 None %3"}, {3, "%3 = OpTypeFunction %1"}, {4, "%4 = OpLabel"}, {5, "%5 = OpLabel"}, {6, "%6 = OpTypeInt 32 0"}, {7, "%7 = OpPhi %6 %8 %4 %9 %5"}, {8, "%8 = OpConstant %6 0"}, {10, "%10 = OpTypeFloat 32"}, {12, "%12 = OpConstant %10 1.0"}, {13, "%13 = OpFAdd %10 %11 %12"}, {16, "%16 = OpTypeBool"}, {17, "%17 = OpSLessThan %16 %7 %18"}, {18, "%18 = OpConstant %6 1"}, {19, "%19 = OpLabel"}, }, { // uses {1, { "%2 = OpFunction %1 None %3", "%3 = OpTypeFunction %1", } }, {3, {"%2 = OpFunction %1 None %3"}}, {4, { "%7 = OpPhi %6 %8 %4 %9 %5", // "%11 = OpPhi %10 %12 %4 %13 %5", } }, {5, { "OpBranch %5", "%7 = OpPhi %6 %8 %4 %9 %5", // "%11 = OpPhi %10 %12 %4 %13 %5", "OpLoopMerge %19 %5 None", "OpBranchConditional %17 %5 %19", } }, {6, { // Can't properly check constants // "%8 = OpConstant %6 0", // "%18 = OpConstant %6 1", "%7 = OpPhi %6 %8 %4 %9 %5", // "%9 = OpIAdd %6 %7 %8" } }, {7, {"%17 = OpSLessThan %16 %7 %18"}}, {8, { "%7 = OpPhi %6 %8 %4 %9 %5", // "%9 = OpIAdd %6 %7 %8", } }, // {9, {"%7 = OpPhi %6 %8 %4 %13 %5"}}, {10, { // "%11 = OpPhi %10 %12 %4 %13 %5", // "%12 = OpConstant %10 1", "%13 = OpFAdd %10 %11 %12" } }, // {11, {"%13 = OpFAdd %10 %11 %12"}}, {12, { // "%11 = OpPhi %10 %12 %4 %13 %5", "%13 = OpFAdd %10 %11 %12" } }, // {13, {"%11 = OpPhi %10 %12 %4 %13 %5"}}, {16, {"%17 = OpSLessThan %16 %7 %18"}}, {17, {"OpBranchConditional %17 %5 %19"}}, {18, {"%17 = OpSLessThan %16 %7 %18"}}, {19, { "OpLoopMerge %19 %5 None", "OpBranchConditional %17 %5 %19", } }, }, }, }, { // OpPhi defining and referencing the same id. "%1 = OpTypeBool " "%3 = OpTypeFunction %1 " "%2 = OpConstantTrue %1 " "%4 = OpFunction %3 None %1 " "%6 = OpLabel " " OpBranch %7 " "%7 = OpLabel " "%8 = OpPhi %1 %8 %7 %2 %6 " // both defines and uses %8 " OpBranch %7 " " OpFunctionEnd", {8}, "%1 = OpTypeBool\n" "%3 = OpTypeFunction %1\n" "%2 = OpConstantTrue %1\n" "%4 = OpFunction %3 None %1\n" "%6 = OpLabel\n" "OpBranch %7\n" "%7 = OpLabel\n" "OpBranch %7\n" "OpFunctionEnd", { { // defs {1, "%1 = OpTypeBool"}, {2, "%2 = OpConstantTrue %1"}, {3, "%3 = OpTypeFunction %1"}, {4, "%4 = OpFunction %3 None %1"}, {6, "%6 = OpLabel"}, {7, "%7 = OpLabel"}, // {8, "%8 = OpPhi %1 %8 %7 %2 %6"}, }, { // uses {1, { "%2 = OpConstantTrue %1", "%3 = OpTypeFunction %1", "%4 = OpFunction %3 None %1", // "%8 = OpPhi %1 %8 %7 %2 %6", } }, // {2, {"%8 = OpPhi %1 %8 %7 %2 %6"}}, {3, {"%4 = OpFunction %3 None %1"}}, // {6, {"%8 = OpPhi %1 %8 %7 %2 %6"}}, {7, { "OpBranch %7", // "%8 = OpPhi %1 %8 %7 %2 %6", "OpBranch %7", } }, // {8, {"%8 = OpPhi %1 %8 %7 %2 %6"}}, }, }, }, }) ); // clang-format on TEST(DefUseTest, OpSwitch) { // Because disassembler has basic type check for OpSwitch's selector, we // cannot use the DisassembleInst() in the above. Thus, this special spotcheck // test case. const char original_text[] = // int64 f(int64 v) { // switch (v) { // case 1: break; // case -4294967296: break; // case 9223372036854775807: break; // default: break; // } // return v; // } " %1 = OpTypeInt 64 1 " " %3 = OpTypePointer Input %1 " " %2 = OpFunction %1 None %3 " // %3 is int64(int64)* " %4 = OpFunctionParameter %1 " " %5 = OpLabel " " %6 = OpLoad %1 %4 " // selector value " OpSelectionMerge %7 None " " OpSwitch %6 %8 " " 1 %9 " // 1 " -4294967296 %10 " // -2^32 " 9223372036854775807 %11 " // 2^63-1 " %8 = OpLabel " // default " OpBranch %7 " " %9 = OpLabel " " OpBranch %7 " "%10 = OpLabel " " OpBranch %7 " "%11 = OpLabel " " OpBranch %7 " " %7 = OpLabel " " OpReturnValue %6 " " OpFunctionEnd"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, original_text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); ASSERT_NE(nullptr, context); // Force a re-build of def-use manager. context->InvalidateAnalyses(IRContext::Analysis::kAnalysisDefUse); (void)context->get_def_use_mgr(); // Do a bunch replacements. context->ReplaceAllUsesWith(11, 7); // to existing id context->ReplaceAllUsesWith(10, 11); // to existing id context->ReplaceAllUsesWith(9, 10); // to existing id // clang-format off const char modified_text[] = "%1 = OpTypeInt 64 1\n" "%3 = OpTypePointer Input %1\n" "%2 = OpFunction %1 None %3\n" // %3 is int64(int64)* "%4 = OpFunctionParameter %1\n" "%5 = OpLabel\n" "%6 = OpLoad %1 %4\n" // selector value "OpSelectionMerge %7 None\n" "OpSwitch %6 %8 1 %10 -4294967296 %11 9223372036854775807 %7\n" // changed! "%8 = OpLabel\n" // default "OpBranch %7\n" "%9 = OpLabel\n" "OpBranch %7\n" "%10 = OpLabel\n" "OpBranch %7\n" "%11 = OpLabel\n" "OpBranch %7\n" "%7 = OpLabel\n" "OpReturnValue %6\n" "OpFunctionEnd"; // clang-format on EXPECT_EQ(modified_text, DisassembleModule(context->module())); InstDefUse def_uses = {}; def_uses.defs = { {1, "%1 = OpTypeInt 64 1"}, {2, "%2 = OpFunction %1 None %3"}, {3, "%3 = OpTypePointer Input %1"}, {4, "%4 = OpFunctionParameter %1"}, {5, "%5 = OpLabel"}, {6, "%6 = OpLoad %1 %4"}, {7, "%7 = OpLabel"}, {8, "%8 = OpLabel"}, {9, "%9 = OpLabel"}, {10, "%10 = OpLabel"}, {11, "%11 = OpLabel"}, }; CheckDef(def_uses, context->get_def_use_mgr()->id_to_defs()); { EXPECT_EQ(2u, NumUses(context, 6)); std::vector opcodes = GetUseOpcodes(context, 6u); EXPECT_THAT(opcodes, UnorderedElementsAre(spv::Op::OpSwitch, spv::Op::OpReturnValue)); } { EXPECT_EQ(6u, NumUses(context, 7)); std::vector opcodes = GetUseOpcodes(context, 7u); // OpSwitch is now a user of %7. EXPECT_THAT(opcodes, UnorderedElementsAre( spv::Op::OpSelectionMerge, spv::Op::OpBranch, spv::Op::OpBranch, spv::Op::OpBranch, spv::Op::OpBranch, spv::Op::OpSwitch)); } // Check all ids only used by OpSwitch after replacement. for (const auto id : {8u, 10u, 11u}) { EXPECT_EQ(1u, NumUses(context, id)); EXPECT_EQ(spv::Op::OpSwitch, GetUseOpcodes(context, id).back()); } } // Test case for analyzing individual instructions. struct AnalyzeInstDefUseTestCase { const char* module_text; InstDefUse expected_define_use; }; using AnalyzeInstDefUseTest = ::testing::TestWithParam; // Test the analyzing result for individual instructions. TEST_P(AnalyzeInstDefUseTest, Case) { auto tc = GetParam(); // Build module. std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, tc.module_text); ASSERT_NE(nullptr, context); // Analyze the instructions. DefUseManager manager(context->module()); CheckDef(tc.expected_define_use, manager.id_to_defs()); CheckUse(tc.expected_define_use, &manager, context->module()->IdBound()); // CheckUse(tc.expected_define_use, manager.id_to_uses()); } // clang-format off INSTANTIATE_TEST_SUITE_P( TestCase, AnalyzeInstDefUseTest, ::testing::ValuesIn(std::vector{ { // A type declaring instruction. "%1 = OpTypeInt 32 1", { // defs {{1, "%1 = OpTypeInt 32 1"}}, {}, // no uses }, }, { // A type declaring instruction and a constant value. "%1 = OpTypeBool " "%2 = OpConstantTrue %1", { { // defs {1, "%1 = OpTypeBool"}, {2, "%2 = OpConstantTrue %1"}, }, { // uses {1, {"%2 = OpConstantTrue %1"}}, }, }, }, })); // clang-format on using AnalyzeInstDefUse = ::testing::Test; TEST(AnalyzeInstDefUse, UseWithNoResultId) { IRContext context(SPV_ENV_UNIVERSAL_1_2, nullptr); // Analyze the instructions. DefUseManager manager(context.module()); Instruction label(&context, spv::Op::OpLabel, 0, 2, {}); manager.AnalyzeInstDefUse(&label); Instruction branch(&context, spv::Op::OpBranch, 0, 0, {{SPV_OPERAND_TYPE_ID, {2}}}); manager.AnalyzeInstDefUse(&branch); context.module()->SetIdBound(3); InstDefUse expected = { // defs { {2, "%2 = OpLabel"}, }, // uses {{2, {"OpBranch %2"}}}, }; CheckDef(expected, manager.id_to_defs()); CheckUse(expected, &manager, context.module()->IdBound()); } TEST(AnalyzeInstDefUse, AddNewInstruction) { const std::string input = "%1 = OpTypeBool"; // Build module. std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, input); ASSERT_NE(nullptr, context); // Analyze the instructions. DefUseManager manager(context->module()); Instruction newInst(context.get(), spv::Op::OpConstantTrue, 1, 2, {}); manager.AnalyzeInstDefUse(&newInst); InstDefUse expected = { { // defs {1, "%1 = OpTypeBool"}, {2, "%2 = OpConstantTrue %1"}, }, { // uses {1, {"%2 = OpConstantTrue %1"}}, }, }; CheckDef(expected, manager.id_to_defs()); CheckUse(expected, &manager, context->module()->IdBound()); } struct KillInstTestCase { const char* before; std::unordered_set indices_for_inst_to_kill; const char* after; InstDefUse expected_define_use; }; using KillInstTest = ::testing::TestWithParam; TEST_P(KillInstTest, Case) { auto tc = GetParam(); // Build module. std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, tc.before, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); ASSERT_NE(nullptr, context); // Force a re-build of the def-use manager. context->InvalidateAnalyses(IRContext::Analysis::kAnalysisDefUse); (void)context->get_def_use_mgr(); // KillInst context->module()->ForEachInst([&tc, &context](Instruction* inst) { if (tc.indices_for_inst_to_kill.count(inst->result_id())) { context->KillInst(inst); } }); EXPECT_EQ(tc.after, DisassembleModule(context->module())); CheckDef(tc.expected_define_use, context->get_def_use_mgr()->id_to_defs()); CheckUse(tc.expected_define_use, context->get_def_use_mgr(), context->module()->IdBound()); } // clang-format off INSTANTIATE_TEST_SUITE_P( TestCase, KillInstTest, ::testing::ValuesIn(std::vector{ // Kill id defining instructions. { "%3 = OpTypeVoid " "%1 = OpTypeFunction %3 " "%2 = OpFunction %1 None %3 " "%4 = OpLabel " " OpBranch %5 " "%5 = OpLabel " " OpBranch %6 " "%6 = OpLabel " " OpBranch %4 " "%7 = OpLabel " " OpReturn " " OpFunctionEnd", {3, 5, 7}, "%1 = OpTypeFunction %3\n" "%2 = OpFunction %1 None %3\n" "%4 = OpLabel\n" "OpBranch %5\n" "OpNop\n" "OpBranch %6\n" "%6 = OpLabel\n" "OpBranch %4\n" "OpNop\n" "OpReturn\n" "OpFunctionEnd", { // defs { {1, "%1 = OpTypeFunction %3"}, {2, "%2 = OpFunction %1 None %3"}, {4, "%4 = OpLabel"}, {6, "%6 = OpLabel"}, }, // uses { {1, {"%2 = OpFunction %1 None %3"}}, {4, {"OpBranch %4"}}, {6, {"OpBranch %6"}}, } } }, // Kill instructions that do not have result ids. { "%3 = OpTypeVoid " "%1 = OpTypeFunction %3 " "%2 = OpFunction %1 None %3 " "%4 = OpLabel " " OpBranch %5 " "%5 = OpLabel " " OpBranch %6 " "%6 = OpLabel " " OpBranch %4 " "%7 = OpLabel " " OpReturn " " OpFunctionEnd", {2, 4}, "%3 = OpTypeVoid\n" "%1 = OpTypeFunction %3\n" "OpNop\n" "OpNop\n" "OpBranch %5\n" "%5 = OpLabel\n" "OpBranch %6\n" "%6 = OpLabel\n" "OpBranch %4\n" "%7 = OpLabel\n" "OpReturn\n" "OpFunctionEnd", { // defs { {1, "%1 = OpTypeFunction %3"}, {3, "%3 = OpTypeVoid"}, {5, "%5 = OpLabel"}, {6, "%6 = OpLabel"}, {7, "%7 = OpLabel"}, }, // uses { {3, {"%1 = OpTypeFunction %3"}}, {5, {"OpBranch %5"}}, {6, {"OpBranch %6"}}, } } }, })); // clang-format on struct GetAnnotationsTestCase { const char* code; uint32_t id; std::vector annotations; }; using GetAnnotationsTest = ::testing::TestWithParam; TEST_P(GetAnnotationsTest, Case) { const GetAnnotationsTestCase& tc = GetParam(); // Build module. std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, tc.code); ASSERT_NE(nullptr, context); // Get annotations DefUseManager manager(context->module()); auto insts = manager.GetAnnotations(tc.id); // Check ASSERT_EQ(tc.annotations.size(), insts.size()) << "wrong number of annotation instructions"; auto inst_iter = insts.begin(); for (const std::string& expected_anno_inst : tc.annotations) { EXPECT_EQ(expected_anno_inst, DisassembleInst(*inst_iter)) << "annotation instruction mismatch"; inst_iter++; } } // clang-format off INSTANTIATE_TEST_SUITE_P( TestCase, GetAnnotationsTest, ::testing::ValuesIn(std::vector{ // empty {"", 0, {}}, // basic { // code "OpDecorate %1 Block " "OpDecorate %1 RelaxedPrecision " "%3 = OpTypeInt 32 0 " "%1 = OpTypeStruct %3", // id 1, // annotations { "OpDecorate %1 Block", "OpDecorate %1 RelaxedPrecision", }, }, // with debug instructions { // code "OpName %1 \"struct_type\" " "OpName %3 \"int_type\" " "OpDecorate %1 Block " "OpDecorate %1 RelaxedPrecision " "%3 = OpTypeInt 32 0 " "%1 = OpTypeStruct %3", // id 1, // annotations { "OpDecorate %1 Block", "OpDecorate %1 RelaxedPrecision", }, }, // no annotations { // code "OpName %1 \"struct_type\" " "OpName %3 \"int_type\" " "OpDecorate %1 Block " "OpDecorate %1 RelaxedPrecision " "%3 = OpTypeInt 32 0 " "%1 = OpTypeStruct %3", // id 3, // annotations {}, }, // decoration group { // code "OpDecorate %1 Block " "OpDecorate %1 RelaxedPrecision " "%1 = OpDecorationGroup " "OpGroupDecorate %1 %2 %3 " "%4 = OpTypeInt 32 0 " "%2 = OpTypeStruct %4 " "%3 = OpTypeStruct %4 %4", // id 3, // annotations { "OpGroupDecorate %1 %2 %3", }, }, // member decorate { // code "OpMemberDecorate %1 0 RelaxedPrecision " "%2 = OpTypeInt 32 0 " "%1 = OpTypeStruct %2 %2", // id 1, // annotations { "OpMemberDecorate %1 0 RelaxedPrecision", }, }, })); using UpdateUsesTest = PassTest<::testing::Test>; TEST_F(UpdateUsesTest, KeepOldUses) { const std::vector text = { // clang-format off "OpCapability Shader", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Vertex %main \"main\"", "OpName %main \"main\"", "%void = OpTypeVoid", "%4 = OpTypeFunction %void", "%uint = OpTypeInt 32 0", "%uint_5 = OpConstant %uint 5", "%25 = OpConstant %uint 25", "%main = OpFunction %void None %4", "%8 = OpLabel", "%9 = OpIMul %uint %uint_5 %uint_5", "%10 = OpIMul %uint %9 %uint_5", "OpReturn", "OpFunctionEnd" // clang-format on }; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, JoinAllInsts(text), SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); ASSERT_NE(nullptr, context); DefUseManager* def_use_mgr = context->get_def_use_mgr(); Instruction* def = def_use_mgr->GetDef(9); Instruction* use = def_use_mgr->GetDef(10); def->SetOpcode(spv::Op::OpCopyObject); def->SetInOperands({{SPV_OPERAND_TYPE_ID, {25}}}); context->UpdateDefUse(def); auto scanUser = [&](Instruction* user) { return user != use; }; bool userFound = !def_use_mgr->WhileEachUser(def, scanUser); EXPECT_TRUE(userFound); } // clang-format on } // namespace } // namespace analysis } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/desc_sroa_test.cpp000066400000000000000000001507221475742701700240260ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using DescriptorScalarReplacementTest = PassTest<::testing::Test>; std::string GetStructureArrayTestSpirv() { // The SPIR-V for the following high-level shader: // Flattening structures and arrays should result in the following binding // numbers. Only the ones that are actually used in the shader should be in // the final SPIR-V. // // globalS[0][0].t[0] 0 (used) // globalS[0][0].t[1] 1 // globalS[0][0].s[0] 2 (used) // globalS[0][0].s[1] 3 // globalS[0][1].t[0] 4 // globalS[0][1].t[1] 5 // globalS[0][1].s[0] 6 // globalS[0][1].s[1] 7 // globalS[1][0].t[0] 8 // globalS[1][0].t[1] 9 // globalS[1][0].s[0] 10 // globalS[1][0].s[1] 11 // globalS[1][1].t[0] 12 // globalS[1][1].t[1] 13 (used) // globalS[1][1].s[0] 14 // globalS[1][1].s[1] 15 (used) /* struct S { Texture2D t[2]; SamplerState s[2]; }; S globalS[2][2]; float4 main() : SV_Target { return globalS[0][0].t[0].Sample(globalS[0][0].s[0], float2(0,0)) + globalS[1][1].t[1].Sample(globalS[1][1].s[1], float2(0,0)); } */ return R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpName %S "S" OpMemberName %S 0 "t" OpMemberName %S 1 "s" OpName %type_2d_image "type.2d.image" OpName %type_sampler "type.sampler" OpName %globalS "globalS" OpName %out_var_SV_Target "out.var.SV_Target" OpName %main "main" OpName %src_main "src.main" OpName %bb_entry "bb.entry" OpName %type_sampled_image "type.sampled.image" OpDecorate %out_var_SV_Target Location 0 OpDecorate %globalS DescriptorSet 0 OpDecorate %globalS Binding 0 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %v2float = OpTypeVector %float 2 %10 = OpConstantComposite %v2float %float_0 %float_0 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %_arr_type_2d_image_uint_2 = OpTypeArray %type_2d_image %uint_2 %type_sampler = OpTypeSampler %_arr_type_sampler_uint_2 = OpTypeArray %type_sampler %uint_2 %S = OpTypeStruct %_arr_type_2d_image_uint_2 %_arr_type_sampler_uint_2 %_arr_S_uint_2 = OpTypeArray %S %uint_2 %_arr__arr_S_uint_2_uint_2 = OpTypeArray %_arr_S_uint_2 %uint_2 %_ptr_UniformConstant__arr__arr_S_uint_2_uint_2 = OpTypePointer UniformConstant %_arr__arr_S_uint_2_uint_2 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %24 = OpTypeFunction %void %28 = OpTypeFunction %v4float %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %_ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %type_sampler %type_sampled_image = OpTypeSampledImage %type_2d_image %globalS = OpVariable %_ptr_UniformConstant__arr__arr_S_uint_2_uint_2 UniformConstant %out_var_SV_Target = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %24 %25 = OpLabel %26 = OpFunctionCall %v4float %src_main OpStore %out_var_SV_Target %26 OpReturn OpFunctionEnd %src_main = OpFunction %v4float None %28 %bb_entry = OpLabel %31 = OpAccessChain %_ptr_UniformConstant_type_2d_image %globalS %int_0 %int_0 %int_0 %int_0 %32 = OpLoad %type_2d_image %31 %34 = OpAccessChain %_ptr_UniformConstant_type_sampler %globalS %int_0 %int_0 %int_1 %int_0 %35 = OpLoad %type_sampler %34 %37 = OpSampledImage %type_sampled_image %32 %35 %38 = OpImageSampleImplicitLod %v4float %37 %10 None %39 = OpAccessChain %_ptr_UniformConstant_type_2d_image %globalS %int_1 %int_1 %int_0 %int_1 %40 = OpLoad %type_2d_image %39 %41 = OpAccessChain %_ptr_UniformConstant_type_sampler %globalS %int_1 %int_1 %int_1 %int_1 %42 = OpLoad %type_sampler %41 %43 = OpSampledImage %type_sampled_image %40 %42 %44 = OpImageSampleImplicitLod %v4float %43 %10 None %45 = OpFAdd %v4float %38 %44 OpReturnValue %45 OpFunctionEnd )"; } TEST_F(DescriptorScalarReplacementTest, ExpandArrayOfTextures) { const std::string text = R"( ; CHECK: OpDecorate [[var1:%\w+]] DescriptorSet 0 ; CHECK: OpDecorate [[var1]] Binding 0 ; CHECK: OpDecorate [[var2:%\w+]] DescriptorSet 0 ; CHECK: OpDecorate [[var2]] Binding 1 ; CHECK: OpDecorate [[var3:%\w+]] DescriptorSet 0 ; CHECK: OpDecorate [[var3]] Binding 2 ; CHECK: OpDecorate [[var4:%\w+]] DescriptorSet 0 ; CHECK: OpDecorate [[var4]] Binding 3 ; CHECK: OpDecorate [[var5:%\w+]] DescriptorSet 0 ; CHECK: OpDecorate [[var5]] Binding 4 ; CHECK: [[image_type:%\w+]] = OpTypeImage ; CHECK: [[ptr_type:%\w+]] = OpTypePointer UniformConstant [[image_type]] ; CHECK: [[var1]] = OpVariable [[ptr_type]] UniformConstant ; CHECK: [[var2]] = OpVariable [[ptr_type]] UniformConstant ; CHECK: [[var3]] = OpVariable [[ptr_type]] UniformConstant ; CHECK: [[var4]] = OpVariable [[ptr_type]] UniformConstant ; CHECK: [[var5]] = OpVariable [[ptr_type]] UniformConstant ; CHECK: OpLoad [[image_type]] [[var1]] ; CHECK: OpLoad [[image_type]] [[var2]] ; CHECK: OpLoad [[image_type]] [[var3]] ; CHECK: OpLoad [[image_type]] [[var4]] ; CHECK: OpLoad [[image_type]] [[var5]] OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpDecorate %MyTextures DescriptorSet 0 OpDecorate %MyTextures Binding 0 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %int_3 = OpConstant %int 3 %int_4 = OpConstant %int 4 %uint = OpTypeInt 32 0 %uint_5 = OpConstant %uint 5 %float = OpTypeFloat 32 %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %_arr_type_2d_image_uint_5 = OpTypeArray %type_2d_image %uint_5 %_ptr_UniformConstant__arr_type_2d_image_uint_5 = OpTypePointer UniformConstant %_arr_type_2d_image_uint_5 %v2float = OpTypeVector %float 2 %void = OpTypeVoid %26 = OpTypeFunction %void %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %MyTextures = OpVariable %_ptr_UniformConstant__arr_type_2d_image_uint_5 UniformConstant %main = OpFunction %void None %26 %28 = OpLabel %29 = OpUndef %v2float %30 = OpAccessChain %_ptr_UniformConstant_type_2d_image %MyTextures %int_0 %31 = OpLoad %type_2d_image %30 %35 = OpAccessChain %_ptr_UniformConstant_type_2d_image %MyTextures %int_1 %36 = OpLoad %type_2d_image %35 %40 = OpAccessChain %_ptr_UniformConstant_type_2d_image %MyTextures %int_2 %41 = OpLoad %type_2d_image %40 %45 = OpAccessChain %_ptr_UniformConstant_type_2d_image %MyTextures %int_3 %46 = OpLoad %type_2d_image %45 %50 = OpAccessChain %_ptr_UniformConstant_type_2d_image %MyTextures %int_4 %51 = OpLoad %type_2d_image %50 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch( text, true, /* flatten_composites=*/true, /* flatten_arrays=*/true); } TEST_F(DescriptorScalarReplacementTest, ExpandArrayOfSamplers) { const std::string text = R"( ; CHECK: OpDecorate [[var1:%\w+]] DescriptorSet 0 ; CHECK: OpDecorate [[var1]] Binding 1 ; CHECK: OpDecorate [[var2:%\w+]] DescriptorSet 0 ; CHECK: OpDecorate [[var2]] Binding 2 ; CHECK: OpDecorate [[var3:%\w+]] DescriptorSet 0 ; CHECK: OpDecorate [[var3]] Binding 3 ; CHECK: [[sampler_type:%\w+]] = OpTypeSampler ; CHECK: [[ptr_type:%\w+]] = OpTypePointer UniformConstant [[sampler_type]] ; CHECK: [[var1]] = OpVariable [[ptr_type]] UniformConstant ; CHECK: [[var2]] = OpVariable [[ptr_type]] UniformConstant ; CHECK: [[var3]] = OpVariable [[ptr_type]] UniformConstant ; CHECK: OpLoad [[sampler_type]] [[var1]] ; CHECK: OpLoad [[sampler_type]] [[var2]] ; CHECK: OpLoad [[sampler_type]] [[var3]] OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpDecorate %MySampler DescriptorSet 0 OpDecorate %MySampler Binding 1 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %uint = OpTypeInt 32 0 %uint_3 = OpConstant %uint 3 %type_sampler = OpTypeSampler %_arr_type_sampler_uint_3 = OpTypeArray %type_sampler %uint_3 %_ptr_UniformConstant__arr_type_sampler_uint_3 = OpTypePointer UniformConstant %_arr_type_sampler_uint_3 %void = OpTypeVoid %26 = OpTypeFunction %void %_ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %type_sampler %MySampler = OpVariable %_ptr_UniformConstant__arr_type_sampler_uint_3 UniformConstant %main = OpFunction %void None %26 %28 = OpLabel %31 = OpAccessChain %_ptr_UniformConstant_type_sampler %MySampler %int_0 %32 = OpLoad %type_sampler %31 %35 = OpAccessChain %_ptr_UniformConstant_type_sampler %MySampler %int_1 %36 = OpLoad %type_sampler %35 %40 = OpAccessChain %_ptr_UniformConstant_type_sampler %MySampler %int_2 %41 = OpLoad %type_sampler %40 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch( text, true, /* flatten_composites=*/true, /* flatten_arrays=*/true); } TEST_F(DescriptorScalarReplacementTest, ExpandArrayOfSSBOs) { // Tests the expansion of an SSBO. Also check that an access chain with more // than 1 index is correctly handled. const std::string text = R"( ; CHECK: OpDecorate [[var1:%\w+]] DescriptorSet 0 ; CHECK: OpDecorate [[var1]] Binding 0 ; CHECK: OpDecorate [[var2:%\w+]] DescriptorSet 0 ; CHECK: OpDecorate [[var2]] Binding 1 ; CHECK: OpTypeStruct ; CHECK: [[struct_type:%\w+]] = OpTypeStruct ; CHECK: [[ptr_type:%\w+]] = OpTypePointer Uniform [[struct_type]] ; CHECK: [[var1]] = OpVariable [[ptr_type]] Uniform ; CHECK: [[var2]] = OpVariable [[ptr_type]] Uniform ; CHECK: [[ac1:%\w+]] = OpAccessChain %_ptr_Uniform_v4float [[var1]] %uint_0 %uint_0 %uint_0 ; CHECK: OpLoad %v4float [[ac1]] ; CHECK: [[ac2:%\w+]] = OpAccessChain %_ptr_Uniform_v4float [[var2]] %uint_0 %uint_0 %uint_0 ; CHECK: OpLoad %v4float [[ac2]] OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpDecorate %buffers DescriptorSet 0 OpDecorate %buffers Binding 0 OpMemberDecorate %S 0 Offset 0 OpDecorate %_runtimearr_S ArrayStride 16 OpMemberDecorate %type_StructuredBuffer_S 0 Offset 0 OpMemberDecorate %type_StructuredBuffer_S 0 NonWritable OpDecorate %type_StructuredBuffer_S BufferBlock %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %S = OpTypeStruct %v4float %_runtimearr_S = OpTypeRuntimeArray %S %type_StructuredBuffer_S = OpTypeStruct %_runtimearr_S %_arr_type_StructuredBuffer_S_uint_2 = OpTypeArray %type_StructuredBuffer_S %uint_2 %_ptr_Uniform__arr_type_StructuredBuffer_S_uint_2 = OpTypePointer Uniform %_arr_type_StructuredBuffer_S_uint_2 %_ptr_Uniform_type_StructuredBuffer_S = OpTypePointer Uniform %type_StructuredBuffer_S %void = OpTypeVoid %19 = OpTypeFunction %void %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %buffers = OpVariable %_ptr_Uniform__arr_type_StructuredBuffer_S_uint_2 Uniform %main = OpFunction %void None %19 %21 = OpLabel %22 = OpAccessChain %_ptr_Uniform_v4float %buffers %uint_0 %uint_0 %uint_0 %uint_0 %23 = OpLoad %v4float %22 %24 = OpAccessChain %_ptr_Uniform_type_StructuredBuffer_S %buffers %uint_1 %25 = OpAccessChain %_ptr_Uniform_v4float %24 %uint_0 %uint_0 %uint_0 %26 = OpLoad %v4float %25 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch( text, true, /* flatten_composites=*/true, /* flatten_arrays=*/true); } TEST_F(DescriptorScalarReplacementTest, NameNewVariables) { // Checks that if the original variable has a name, then the new variables // will have a name derived from that name. const std::string text = R"( ; CHECK: OpName [[var1:%\w+]] "SSBO[0]" ; CHECK: OpName [[var2:%\w+]] "SSBO[1]" ; CHECK: OpDecorate [[var1]] DescriptorSet 0 ; CHECK: OpDecorate [[var1]] Binding 0 ; CHECK: OpDecorate [[var2]] DescriptorSet 0 ; CHECK: OpDecorate [[var2]] Binding 1 ; CHECK: OpTypeStruct ; CHECK: [[struct_type:%\w+]] = OpTypeStruct ; CHECK: [[ptr_type:%\w+]] = OpTypePointer Uniform [[struct_type]] ; CHECK: [[var1]] = OpVariable [[ptr_type]] Uniform ; CHECK: [[var2]] = OpVariable [[ptr_type]] Uniform ; CHECK: [[ac1:%\w+]] = OpAccessChain %_ptr_Uniform_v4float [[var1]] %uint_0 %uint_0 %uint_0 ; CHECK: OpLoad %v4float [[ac1]] ; CHECK: [[ac2:%\w+]] = OpAccessChain %_ptr_Uniform_v4float [[var2]] %uint_0 %uint_0 %uint_0 ; CHECK: OpLoad %v4float [[ac2]] OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %buffers "SSBO" OpDecorate %buffers DescriptorSet 0 OpDecorate %buffers Binding 0 OpMemberDecorate %S 0 Offset 0 OpDecorate %_runtimearr_S ArrayStride 16 OpMemberDecorate %type_StructuredBuffer_S 0 Offset 0 OpMemberDecorate %type_StructuredBuffer_S 0 NonWritable OpDecorate %type_StructuredBuffer_S BufferBlock %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %S = OpTypeStruct %v4float %_runtimearr_S = OpTypeRuntimeArray %S %type_StructuredBuffer_S = OpTypeStruct %_runtimearr_S %_arr_type_StructuredBuffer_S_uint_2 = OpTypeArray %type_StructuredBuffer_S %uint_2 %_ptr_Uniform__arr_type_StructuredBuffer_S_uint_2 = OpTypePointer Uniform %_arr_type_StructuredBuffer_S_uint_2 %_ptr_Uniform_type_StructuredBuffer_S = OpTypePointer Uniform %type_StructuredBuffer_S %void = OpTypeVoid %19 = OpTypeFunction %void %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %buffers = OpVariable %_ptr_Uniform__arr_type_StructuredBuffer_S_uint_2 Uniform %main = OpFunction %void None %19 %21 = OpLabel %22 = OpAccessChain %_ptr_Uniform_v4float %buffers %uint_0 %uint_0 %uint_0 %uint_0 %23 = OpLoad %v4float %22 %24 = OpAccessChain %_ptr_Uniform_type_StructuredBuffer_S %buffers %uint_1 %25 = OpAccessChain %_ptr_Uniform_v4float %24 %uint_0 %uint_0 %uint_0 %26 = OpLoad %v4float %25 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch( text, true, /* flatten_composites=*/true, /* flatten_arrays=*/true); } TEST_F(DescriptorScalarReplacementTest, DontExpandCBuffers) { // Checks that constant buffers are not expanded. // Constant buffers are represented as global structures, but they should not // be replaced with new variables for their elements. /* cbuffer MyCbuffer : register(b1) { float2 a; float2 b; }; float main() : A { return a.x + b.y; } */ const std::string text = R"( ; CHECK: OpAccessChain %_ptr_Uniform_float %MyCbuffer %int_0 %int_0 ; CHECK: OpAccessChain %_ptr_Uniform_float %MyCbuffer %int_1 %int_1 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %out_var_A OpSource HLSL 600 OpName %type_MyCbuffer "type.MyCbuffer" OpMemberName %type_MyCbuffer 0 "a" OpMemberName %type_MyCbuffer 1 "b" OpName %MyCbuffer "MyCbuffer" OpName %out_var_A "out.var.A" OpName %main "main" OpDecorate %out_var_A Location 0 OpDecorate %MyCbuffer DescriptorSet 0 OpDecorate %MyCbuffer Binding 1 OpMemberDecorate %type_MyCbuffer 0 Offset 0 OpMemberDecorate %type_MyCbuffer 1 Offset 8 OpDecorate %type_MyCbuffer Block %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %type_MyCbuffer = OpTypeStruct %v2float %v2float %_ptr_Uniform_type_MyCbuffer = OpTypePointer Uniform %type_MyCbuffer %_ptr_Output_float = OpTypePointer Output %float %void = OpTypeVoid %13 = OpTypeFunction %void %_ptr_Uniform_float = OpTypePointer Uniform %float %MyCbuffer = OpVariable %_ptr_Uniform_type_MyCbuffer Uniform %out_var_A = OpVariable %_ptr_Output_float Output %main = OpFunction %void None %13 %15 = OpLabel %16 = OpAccessChain %_ptr_Uniform_float %MyCbuffer %int_0 %int_0 %17 = OpLoad %float %16 %18 = OpAccessChain %_ptr_Uniform_float %MyCbuffer %int_1 %int_1 %19 = OpLoad %float %18 %20 = OpFAdd %float %17 %19 OpStore %out_var_A %20 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch( text, true, /* flatten_composites=*/true, /* flatten_arrays=*/true); } TEST_F(DescriptorScalarReplacementTest, DontExpandStructuredBuffers) { // Checks that structured buffers are not expanded. // Structured buffers are represented as global structures, that have one // member which is a runtime array. /* struct S { float2 a; float2 b; }; RWStructuredBuffer sb; float main() : A { return sb[0].a.x + sb[0].b.x; } */ const std::string text = R"( ; CHECK: OpAccessChain %_ptr_Uniform_float %sb %int_0 %uint_0 %int_0 %int_0 ; CHECK: OpAccessChain %_ptr_Uniform_float %sb %int_0 %uint_0 %int_1 %int_0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %out_var_A OpName %type_RWStructuredBuffer_S "type.RWStructuredBuffer.S" OpName %S "S" OpMemberName %S 0 "a" OpMemberName %S 1 "b" OpName %sb "sb" OpName %out_var_A "out.var.A" OpName %main "main" OpDecorate %out_var_A Location 0 OpDecorate %sb DescriptorSet 0 OpDecorate %sb Binding 0 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %S 1 Offset 8 OpDecorate %_runtimearr_S ArrayStride 16 OpMemberDecorate %type_RWStructuredBuffer_S 0 Offset 0 OpDecorate %type_RWStructuredBuffer_S BufferBlock %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %int_1 = OpConstant %int 1 %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %S = OpTypeStruct %v2float %v2float %_runtimearr_S = OpTypeRuntimeArray %S %type_RWStructuredBuffer_S = OpTypeStruct %_runtimearr_S %_ptr_Uniform_type_RWStructuredBuffer_S = OpTypePointer Uniform %type_RWStructuredBuffer_S %_ptr_Output_float = OpTypePointer Output %float %void = OpTypeVoid %17 = OpTypeFunction %void %_ptr_Uniform_float = OpTypePointer Uniform %float %sb = OpVariable %_ptr_Uniform_type_RWStructuredBuffer_S Uniform %out_var_A = OpVariable %_ptr_Output_float Output %main = OpFunction %void None %17 %19 = OpLabel %20 = OpAccessChain %_ptr_Uniform_float %sb %int_0 %uint_0 %int_0 %int_0 %21 = OpLoad %float %20 %22 = OpAccessChain %_ptr_Uniform_float %sb %int_0 %uint_0 %int_1 %int_0 %23 = OpLoad %float %22 %24 = OpFAdd %float %21 %23 OpStore %out_var_A %24 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch( text, true, /* flatten_composites=*/true, /* flatten_arrays=*/true); } TEST_F(DescriptorScalarReplacementTest, StructureArrayNames) { // Checks that names are properly generated for multi-dimension arrays and // structure members. const std::string checks = R"( ; CHECK: OpName %globalS_0__0__t_0_ "globalS[0][0].t[0]" ; CHECK: OpName %globalS_0__0__s_0_ "globalS[0][0].s[0]" ; CHECK: OpName %globalS_1__1__t_1_ "globalS[1][1].t[1]" ; CHECK: OpName %globalS_1__1__s_1_ "globalS[1][1].s[1]" )"; const std::string text = checks + GetStructureArrayTestSpirv(); SinglePassRunAndMatch( text, true, /* flatten_composites=*/true, /* flatten_arrays=*/true); } TEST_F(DescriptorScalarReplacementTest, FlattensArraysOfStructsButNoResourceArrays) { // Check that only the composite array is flattenned, but internal resource // arrays are left as-is. const std::string checks = R"( ; CHECK: OpName %globalS_0__0__t "globalS[0][0].t" ; CHECK: OpName %globalS_0__0__s "globalS[0][0].s" ; CHECK: OpName %globalS_1__1__t "globalS[1][1].t" ; CHECK: OpName %globalS_1__1__s "globalS[1][1].s" ; CHECK-NOT: OpName %globalS_1__1__t_0_ ; CHECK-NOT: OpName %globalS_1__1__s_0_ )"; const std::string text = checks + GetStructureArrayTestSpirv(); SinglePassRunAndMatch( text, true, /* flatten_composites=*/true, /* flatten_arrays=*/false); } TEST_F(DescriptorScalarReplacementTest, FlattenNothingIfAskedTo) { // Not useful, but checks what happens if both are set to false. // In such case, nothing happens. const std::string checks = R"( ; CHECK: OpName %globalS ; CHECK-NOT: OpName %globalS_ )"; const std::string text = checks + GetStructureArrayTestSpirv(); SinglePassRunAndMatch( text, true, /* flatten_composites=*/false, /* flatten_arrays=*/false); } TEST_F(DescriptorScalarReplacementTest, StructureArrayBindings) { // Checks that flattening structures and arrays results in correct binding // numbers. const std::string checks = R"( ; CHECK: OpDecorate %globalS_0__0__t_0_ Binding 0 ; CHECK: OpDecorate %globalS_0__0__s_0_ Binding 2 ; CHECK: OpDecorate %globalS_1__1__t_1_ Binding 13 ; CHECK: OpDecorate %globalS_1__1__s_1_ Binding 15 )"; const std::string text = checks + GetStructureArrayTestSpirv(); SinglePassRunAndMatch( text, true, /* flatten_composites=*/true, /* flatten_arrays=*/true); } TEST_F(DescriptorScalarReplacementTest, StructureArrayReplacements) { // Checks that all access chains indexing into structures and/or arrays are // replaced with direct access to replacement variables. const std::string checks = R"( ; CHECK-NOT: OpAccessChain ; CHECK: OpLoad %type_2d_image %globalS_0__0__t_0_ ; CHECK: OpLoad %type_sampler %globalS_0__0__s_0_ ; CHECK: OpLoad %type_2d_image %globalS_1__1__t_1_ ; CHECK: OpLoad %type_sampler %globalS_1__1__s_1_ )"; const std::string text = checks + GetStructureArrayTestSpirv(); SinglePassRunAndMatch( text, true, /* flatten_composites=*/true, /* flatten_arrays=*/true); } TEST_F(DescriptorScalarReplacementTest, ResourceStructAsFunctionParam) { // Checks that a mix of OpAccessChain, OpLoad, and OpCompositeExtract patterns // can be properly replaced with replacement variables. // This pattern can be seen when a global structure of resources is passed to // a function. /* High-level source: // globalS[0].t[0] binding: 0 (used) // globalS[0].t[1] binding: 1 (used) // globalS[0].tt[0].s[0] binding: 2 // globalS[0].tt[0].s[1] binding: 3 (used) // globalS[0].tt[0].s[2] binding: 4 // globalS[0].tt[1].s[0] binding: 5 // globalS[0].tt[1].s[1] binding: 6 // globalS[0].tt[1].s[2] binding: 7 (used) // globalS[1].t[0] binding: 8 (used) // globalS[1].t[1] binding: 9 (used) // globalS[1].tt[0].s[0] binding: 10 // globalS[1].tt[0].s[1] binding: 11 (used) // globalS[1].tt[0].s[2] binding: 12 // globalS[1].tt[1].s[0] binding: 13 // globalS[1].tt[1].s[1] binding: 14 // globalS[1].tt[1].s[2] binding: 15 (used) struct T { SamplerState s[3]; }; struct S { Texture2D t[2]; T tt[2]; }; float4 tex2D(S x, float2 v) { return x.t[0].Sample(x.tt[0].s[1], v) + x.t[1].Sample(x.tt[1].s[2], v); } S globalS[2]; float4 main() : SV_Target { return tex2D(globalS[0], float2(0,0)) + tex2D(globalS[1], float2(0,0)) ; } */ const std::string shader = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpName %S "S" OpMemberName %S 0 "t" OpMemberName %S 1 "tt" OpName %type_2d_image "type.2d.image" OpName %T "T" OpMemberName %T 0 "s" OpName %type_sampler "type.sampler" OpName %globalS "globalS" OpName %out_var_SV_Target "out.var.SV_Target" OpName %main "main" OpName %type_sampled_image "type.sampled.image" OpDecorate %out_var_SV_Target Location 0 OpDecorate %globalS DescriptorSet 0 OpDecorate %globalS Binding 0 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %v2float = OpTypeVector %float 2 %14 = OpConstantComposite %v2float %float_0 %float_0 %int_1 = OpConstant %int 1 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %_arr_type_2d_image_uint_2 = OpTypeArray %type_2d_image %uint_2 %uint_3 = OpConstant %uint 3 %type_sampler = OpTypeSampler %_arr_type_sampler_uint_3 = OpTypeArray %type_sampler %uint_3 %T = OpTypeStruct %_arr_type_sampler_uint_3 %_arr_T_uint_2 = OpTypeArray %T %uint_2 %S = OpTypeStruct %_arr_type_2d_image_uint_2 %_arr_T_uint_2 %_arr_S_uint_2 = OpTypeArray %S %uint_2 %_ptr_UniformConstant__arr_S_uint_2 = OpTypePointer UniformConstant %_arr_S_uint_2 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %27 = OpTypeFunction %void %_ptr_UniformConstant_S = OpTypePointer UniformConstant %S %type_sampled_image = OpTypeSampledImage %type_2d_image %globalS = OpVariable %_ptr_UniformConstant__arr_S_uint_2 UniformConstant %out_var_SV_Target = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %27 %29 = OpLabel %30 = OpAccessChain %_ptr_UniformConstant_S %globalS %int_0 %31 = OpLoad %S %30 %32 = OpCompositeExtract %_arr_type_2d_image_uint_2 %31 0 %33 = OpCompositeExtract %type_2d_image %32 0 %34 = OpCompositeExtract %type_2d_image %32 1 %35 = OpCompositeExtract %_arr_T_uint_2 %31 1 %36 = OpCompositeExtract %T %35 0 %37 = OpCompositeExtract %_arr_type_sampler_uint_3 %36 0 %38 = OpCompositeExtract %type_sampler %37 1 %39 = OpCompositeExtract %T %35 1 %40 = OpCompositeExtract %_arr_type_sampler_uint_3 %39 0 %41 = OpCompositeExtract %type_sampler %40 2 %42 = OpSampledImage %type_sampled_image %33 %38 %43 = OpImageSampleImplicitLod %v4float %42 %14 None %44 = OpSampledImage %type_sampled_image %34 %41 %45 = OpImageSampleImplicitLod %v4float %44 %14 None %46 = OpFAdd %v4float %43 %45 %47 = OpAccessChain %_ptr_UniformConstant_S %globalS %int_1 %48 = OpLoad %S %47 %49 = OpCompositeExtract %_arr_type_2d_image_uint_2 %48 0 %50 = OpCompositeExtract %type_2d_image %49 0 %51 = OpCompositeExtract %type_2d_image %49 1 %52 = OpCompositeExtract %_arr_T_uint_2 %48 1 %53 = OpCompositeExtract %T %52 0 %54 = OpCompositeExtract %_arr_type_sampler_uint_3 %53 0 %55 = OpCompositeExtract %type_sampler %54 1 %56 = OpCompositeExtract %T %52 1 %57 = OpCompositeExtract %_arr_type_sampler_uint_3 %56 0 %58 = OpCompositeExtract %type_sampler %57 2 %59 = OpSampledImage %type_sampled_image %50 %55 %60 = OpImageSampleImplicitLod %v4float %59 %14 None %61 = OpSampledImage %type_sampled_image %51 %58 %62 = OpImageSampleImplicitLod %v4float %61 %14 None %63 = OpFAdd %v4float %60 %62 %64 = OpFAdd %v4float %46 %63 OpStore %out_var_SV_Target %64 OpReturn OpFunctionEnd )"; const std::string checks = R"( ; CHECK: OpName %globalS_0__t_0_ "globalS[0].t[0]" ; CHECK: OpName %globalS_0__t_1_ "globalS[0].t[1]" ; CHECK: OpName %globalS_1__t_0_ "globalS[1].t[0]" ; CHECK: OpName %globalS_1__t_1_ "globalS[1].t[1]" ; CHECK: OpName %globalS_0__tt_0__s_1_ "globalS[0].tt[0].s[1]" ; CHECK: OpName %globalS_0__tt_1__s_2_ "globalS[0].tt[1].s[2]" ; CHECK: OpName %globalS_1__tt_0__s_1_ "globalS[1].tt[0].s[1]" ; CHECK: OpName %globalS_1__tt_1__s_2_ "globalS[1].tt[1].s[2]" ; CHECK: OpDecorate %globalS_0__t_0_ Binding 0 ; CHECK: OpDecorate %globalS_0__t_1_ Binding 1 ; CHECK: OpDecorate %globalS_1__t_0_ Binding 8 ; CHECK: OpDecorate %globalS_1__t_1_ Binding 9 ; CHECK: OpDecorate %globalS_0__tt_0__s_1_ Binding 3 ; CHECK: OpDecorate %globalS_0__tt_1__s_2_ Binding 7 ; CHECK: OpDecorate %globalS_1__tt_0__s_1_ Binding 11 ; CHECK: OpDecorate %globalS_1__tt_1__s_2_ Binding 15 ; CHECK: %globalS_0__t_0_ = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant ; CHECK: %globalS_0__t_1_ = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant ; CHECK: %globalS_1__t_0_ = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant ; CHECK: %globalS_1__t_1_ = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant ; CHECK: %globalS_0__tt_0__s_1_ = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant ; CHECK: %globalS_0__tt_1__s_2_ = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant ; CHECK: %globalS_1__tt_0__s_1_ = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant ; CHECK: %globalS_1__tt_1__s_2_ = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant ; CHECK: [[img_1:%\w+]] = OpLoad %type_2d_image %globalS_0__t_0_ ; CHECK: [[img_2:%\w+]] = OpLoad %type_2d_image %globalS_0__t_1_ ; CHECK: [[sampler_1:%\w+]] = OpLoad %type_sampler %globalS_0__tt_0__s_1_ ; CHECK: [[sampler_2:%\w+]] = OpLoad %type_sampler %globalS_0__tt_1__s_2_ ; CHECK: [[sampled_img_1:%\w+]] = OpSampledImage %type_sampled_image [[img_1]] [[sampler_1]] ; CHECK: [[sample_1:%\w+]] = OpImageSampleImplicitLod %v4float [[sampled_img_1]] ; CHECK: [[sampled_img_2:%\w+]] = OpSampledImage %type_sampled_image [[img_2]] [[sampler_2]] ; CHECK: [[sample_2:%\w+]] = OpImageSampleImplicitLod %v4float [[sampled_img_2]] ; CHECK: OpFAdd %v4float [[sample_1]] [[sample_2]] ; CHECK: [[img_3:%\w+]] = OpLoad %type_2d_image %globalS_1__t_0_ ; CHECK: [[img_4:%\w+]] = OpLoad %type_2d_image %globalS_1__t_1_ ; CHECK: [[sampler_3:%\w+]] = OpLoad %type_sampler %globalS_1__tt_0__s_1_ ; CHECK: [[sampler_4:%\w+]] = OpLoad %type_sampler %globalS_1__tt_1__s_2_ ; CHECK: [[sampled_img_3:%\w+]] = OpSampledImage %type_sampled_image [[img_3]] [[sampler_3]] ; CHECK: [[sample_3:%\w+]] = OpImageSampleImplicitLod %v4float [[sampled_img_3]] ; CHECK: [[sampled_img_4:%\w+]] = OpSampledImage %type_sampled_image [[img_4]] [[sampler_4]] ; CHECK: [[sample_4:%\w+]] = OpImageSampleImplicitLod %v4float [[sampled_img_4]] ; CHECK: OpFAdd %v4float [[sample_3]] [[sample_4]] )"; SinglePassRunAndMatch( checks + shader, true, /* flatten_composites=*/true, /* flatten_arrays=*/true); } TEST_F(DescriptorScalarReplacementTest, BindingForResourceArrayOfStructs) { // Check that correct binding numbers are given to an array of descriptors // to structs. const std::string shader = R"( ; CHECK: OpDecorate {{%\w+}} Binding 0 ; CHECK: OpDecorate {{%\w+}} Binding 1 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "psmain" OpExecutionMode %2 OriginUpperLeft OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 0 OpMemberDecorate %_struct_4 0 Offset 0 OpMemberDecorate %_struct_4 1 Offset 4 OpDecorate %_struct_4 Block %float = OpTypeFloat 32 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_struct_4 = OpTypeStruct %float %int %_arr__struct_4_uint_2 = OpTypeArray %_struct_4 %uint_2 %_ptr_Uniform__arr__struct_4_uint_2 = OpTypePointer Uniform %_arr__struct_4_uint_2 %void = OpTypeVoid %25 = OpTypeFunction %void %_ptr_Uniform_int = OpTypePointer Uniform %int %5 = OpVariable %_ptr_Uniform__arr__struct_4_uint_2 Uniform %2 = OpFunction %void None %25 %29 = OpLabel %40 = OpAccessChain %_ptr_Uniform_int %5 %int_0 %int_1 %41 = OpAccessChain %_ptr_Uniform_int %5 %int_1 %int_1 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch( shader, true, /* flatten_composites=*/true, /* flatten_arrays=*/true); } TEST_F(DescriptorScalarReplacementTest, MemberDecorationForResourceStruct) { // Check that an OpMemberDecorate instruction is correctly converted to a // OpDecorate instruction. const std::string shader = R"( ; CHECK: OpDecorate [[t:%\w+]] DescriptorSet 0 ; CHECK: OpDecorate [[t]] Binding 0 ; CHECK: OpDecorate [[t]] RelaxedPrecision ; CHECK: OpDecorate [[s:%\w+]] DescriptorSet 0 ; CHECK: OpDecorate [[s]] Binding 1 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %PSMain "PSMain" %in_var_TEXCOORD %out_var_SV_Target OpExecutionMode %PSMain OriginUpperLeft OpSource HLSL 600 OpName %sampler2D_h "sampler2D_h" OpMemberName %sampler2D_h 0 "t" OpMemberName %sampler2D_h 1 "s" OpName %type_2d_image "type.2d.image" OpName %type_sampler "type.sampler" OpName %_MainTex "_MainTex" OpName %in_var_TEXCOORD "in.var.TEXCOORD" OpName %out_var_SV_Target "out.var.SV_Target" OpName %PSMain "PSMain" OpName %type_sampled_image "type.sampled.image" OpDecorate %in_var_TEXCOORD Location 0 OpDecorate %out_var_SV_Target Location 0 OpDecorate %_MainTex DescriptorSet 0 OpDecorate %_MainTex Binding 0 OpMemberDecorate %sampler2D_h 0 RelaxedPrecision OpDecorate %out_var_SV_Target RelaxedPrecision OpDecorate %69 RelaxedPrecision %float = OpTypeFloat 32 %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %type_sampler = OpTypeSampler %sampler2D_h = OpTypeStruct %type_2d_image %type_sampler %_ptr_UniformConstant_sampler2D_h = OpTypePointer UniformConstant %sampler2D_h %v2float = OpTypeVector %float 2 %_ptr_Input_v2float = OpTypePointer Input %v2float %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %35 = OpTypeFunction %void %type_sampled_image = OpTypeSampledImage %type_2d_image %_MainTex = OpVariable %_ptr_UniformConstant_sampler2D_h UniformConstant %in_var_TEXCOORD = OpVariable %_ptr_Input_v2float Input %out_var_SV_Target = OpVariable %_ptr_Output_v4float Output %PSMain = OpFunction %void None %35 %43 = OpLabel %44 = OpLoad %v2float %in_var_TEXCOORD %57 = OpLoad %sampler2D_h %_MainTex %72 = OpCompositeExtract %type_2d_image %57 0 %73 = OpCompositeExtract %type_sampler %57 1 %68 = OpSampledImage %type_sampled_image %72 %73 %69 = OpImageSampleImplicitLod %v4float %68 %44 None OpStore %out_var_SV_Target %69 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch( shader, true, /* flatten_composites=*/true, /* flatten_arrays=*/true); } TEST_F(DescriptorScalarReplacementTest, DecorateStringForReflect) { // Check that an OpDecorateString instruction is correctly cloned to new // variable. const std::string shader = R"( ; CHECK: OpName %g_testTextures_0_ "g_testTextures[0]" ; CHECK: OpDecorate %g_testTextures_0_ DescriptorSet 0 ; CHECK: OpDecorate %g_testTextures_0_ Binding 0 ; CHECK: OpDecorateString %g_testTextures_0_ UserTypeGOOGLE "texture2d" OpCapability Shader OpExtension "SPV_GOOGLE_hlsl_functionality1" OpExtension "SPV_GOOGLE_user_type" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragCoord %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %type_2d_image "type.2d.image" OpName %g_testTextures "g_testTextures" OpName %out_var_SV_Target "out.var.SV_Target" OpName %main "main" OpName %param_var_vPixelPos "param.var.vPixelPos" OpName %src_main "src.main" OpName %vPixelPos "vPixelPos" OpName %bb_entry "bb.entry" OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorateString %gl_FragCoord UserSemantic "SV_Position" OpDecorateString %out_var_SV_Target UserSemantic "SV_Target" OpDecorate %out_var_SV_Target Location 0 OpDecorate %g_testTextures DescriptorSet 0 OpDecorate %g_testTextures Binding 0 OpDecorateString %g_testTextures UserTypeGOOGLE "texture2d" %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint_2 = OpConstant %uint 2 %float = OpTypeFloat 32 %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %_arr_type_2d_image_uint_2 = OpTypeArray %type_2d_image %uint_2 %_ptr_UniformConstant__arr_type_2d_image_uint_2 = OpTypePointer UniformConstant %_arr_type_2d_image_uint_2 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %18 = OpTypeFunction %void %_ptr_Function_v4float = OpTypePointer Function %v4float %25 = OpTypeFunction %v4float %_ptr_Function_v4float %v2float = OpTypeVector %float 2 %v3uint = OpTypeVector %uint 3 %v3int = OpTypeVector %int 3 %v2int = OpTypeVector %int 2 %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %g_testTextures = OpVariable %_ptr_UniformConstant__arr_type_2d_image_uint_2 UniformConstant %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %out_var_SV_Target = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %18 %19 = OpLabel %param_var_vPixelPos = OpVariable %_ptr_Function_v4float Function %22 = OpLoad %v4float %gl_FragCoord OpStore %param_var_vPixelPos %22 %23 = OpFunctionCall %v4float %src_main %param_var_vPixelPos OpStore %out_var_SV_Target %23 OpReturn OpFunctionEnd %src_main = OpFunction %v4float None %25 %vPixelPos = OpFunctionParameter %_ptr_Function_v4float %bb_entry = OpLabel %28 = OpLoad %v4float %vPixelPos %30 = OpVectorShuffle %v2float %28 %28 0 1 %31 = OpCompositeExtract %float %30 0 %32 = OpCompositeExtract %float %30 1 %33 = OpConvertFToU %uint %31 %34 = OpConvertFToU %uint %32 %36 = OpCompositeConstruct %v3uint %33 %34 %uint_0 %38 = OpBitcast %v3int %36 %40 = OpVectorShuffle %v2int %38 %38 0 1 %41 = OpCompositeExtract %int %38 2 %43 = OpAccessChain %_ptr_UniformConstant_type_2d_image %g_testTextures %int_0 %44 = OpLoad %type_2d_image %43 %45 = OpImageFetch %v4float %44 %40 Lod %41 OpReturnValue %45 OpFunctionEnd )"; SinglePassRunAndMatch( shader, true, /* flatten_composites=*/true, /* flatten_arrays=*/true); } TEST_F(DescriptorScalarReplacementTest, ExpandArrayInOpEntryPoint) { const std::string text = R"(; SPIR-V ; Version: 1.6 ; Bound: 31 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 ; CHECK: OpEntryPoint GLCompute %main "main" %output_0_ %output_1_ OpEntryPoint GLCompute %main "main" %output OpExecutionMode %main LocalSize 1 1 1 OpSource HLSL 670 OpName %type_RWByteAddressBuffer "type.RWByteAddressBuffer" OpName %output "output" OpName %main "main" OpName %src_main "src.main" OpName %bb_entry "bb.entry" ; CHECK: OpDecorate %output_1_ DescriptorSet 0 ; CHECK: OpDecorate %output_1_ Binding 1 ; CHECK: OpDecorate %output_0_ DescriptorSet 0 ; CHECK: OpDecorate %output_0_ Binding 0 OpDecorate %output DescriptorSet 0 OpDecorate %output Binding 0 OpDecorate %_runtimearr_uint ArrayStride 4 OpMemberDecorate %type_RWByteAddressBuffer 0 Offset 0 OpDecorate %type_RWByteAddressBuffer Block %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_2 = OpConstant %uint 2 %uint_32 = OpConstant %uint 32 %_runtimearr_uint = OpTypeRuntimeArray %uint %type_RWByteAddressBuffer = OpTypeStruct %_runtimearr_uint %_arr_type_RWByteAddressBuffer_uint_2 = OpTypeArray %type_RWByteAddressBuffer %uint_2 %_ptr_StorageBuffer__arr_type_RWByteAddressBuffer_uint_2 = OpTypePointer StorageBuffer %_arr_type_RWByteAddressBuffer_uint_2 %void = OpTypeVoid %23 = OpTypeFunction %void %_ptr_StorageBuffer_type_RWByteAddressBuffer = OpTypePointer StorageBuffer %type_RWByteAddressBuffer %_ptr_StorageBuffer_uint = OpTypePointer StorageBuffer %uint ; CHECK: %output_1_ = OpVariable %_ptr_StorageBuffer_type_RWByteAddressBuffer StorageBuffer ; CHECK: %output_0_ = OpVariable %_ptr_StorageBuffer_type_RWByteAddressBuffer StorageBuffer %output = OpVariable %_ptr_StorageBuffer__arr_type_RWByteAddressBuffer_uint_2 StorageBuffer %main = OpFunction %void None %23 %26 = OpLabel %27 = OpFunctionCall %void %src_main OpReturn OpFunctionEnd %src_main = OpFunction %void None %23 %bb_entry = OpLabel %28 = OpAccessChain %_ptr_StorageBuffer_type_RWByteAddressBuffer %output %int_1 %29 = OpShiftRightLogical %uint %uint_0 %uint_2 %30 = OpAccessChain %_ptr_StorageBuffer_uint %28 %uint_0 %29 OpStore %30 %uint_32 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch( text, false, /* flatten_composites=*/true, /* flatten_arrays=*/true); } TEST_F(DescriptorScalarReplacementTest, ExpandArrayWhenCompositeExpensionIsOff) { const std::string text = R"(; SPIR-V ; Version: 1.6 ; Bound: 31 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 ; CHECK: OpEntryPoint GLCompute %main "main" %output_0_ %output_1_ OpEntryPoint GLCompute %main "main" %output OpExecutionMode %main LocalSize 1 1 1 OpSource HLSL 670 OpName %type_RWByteAddressBuffer "type.RWByteAddressBuffer" OpName %output "output" OpName %main "main" OpName %src_main "src.main" OpName %bb_entry "bb.entry" ; CHECK: OpDecorate %output_1_ DescriptorSet 0 ; CHECK: OpDecorate %output_1_ Binding 1 ; CHECK: OpDecorate %output_0_ DescriptorSet 0 ; CHECK: OpDecorate %output_0_ Binding 0 OpDecorate %output DescriptorSet 0 OpDecorate %output Binding 0 OpDecorate %_runtimearr_uint ArrayStride 4 OpMemberDecorate %type_RWByteAddressBuffer 0 Offset 0 OpDecorate %type_RWByteAddressBuffer Block %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_2 = OpConstant %uint 2 %uint_32 = OpConstant %uint 32 %_runtimearr_uint = OpTypeRuntimeArray %uint %type_RWByteAddressBuffer = OpTypeStruct %_runtimearr_uint %_arr_type_RWByteAddressBuffer_uint_2 = OpTypeArray %type_RWByteAddressBuffer %uint_2 %_ptr_StorageBuffer__arr_type_RWByteAddressBuffer_uint_2 = OpTypePointer StorageBuffer %_arr_type_RWByteAddressBuffer_uint_2 %void = OpTypeVoid %23 = OpTypeFunction %void %_ptr_StorageBuffer_type_RWByteAddressBuffer = OpTypePointer StorageBuffer %type_RWByteAddressBuffer %_ptr_StorageBuffer_uint = OpTypePointer StorageBuffer %uint ; CHECK: %output_1_ = OpVariable %_ptr_StorageBuffer_type_RWByteAddressBuffer StorageBuffer ; CHECK: %output_0_ = OpVariable %_ptr_StorageBuffer_type_RWByteAddressBuffer StorageBuffer %output = OpVariable %_ptr_StorageBuffer__arr_type_RWByteAddressBuffer_uint_2 StorageBuffer %main = OpFunction %void None %23 %26 = OpLabel %27 = OpFunctionCall %void %src_main OpReturn OpFunctionEnd %src_main = OpFunction %void None %23 %bb_entry = OpLabel %28 = OpAccessChain %_ptr_StorageBuffer_type_RWByteAddressBuffer %output %int_1 %29 = OpShiftRightLogical %uint %uint_0 %uint_2 %30 = OpAccessChain %_ptr_StorageBuffer_uint %28 %uint_0 %29 OpStore %30 %uint_32 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch( text, false, /* flatten_composites=*/false, /* flatten_arrays=*/true); } TEST_F(DescriptorScalarReplacementTest, ExpandStructButNotArray) { const std::string text = R"(; SPIR-V ; Version: 1.6 ; Generator: Khronos SPIR-V Tools Assembler; 0 ; Bound: 41 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpSource HLSL 660 OpName %type_2d_image "type.2d.image" OpName %Textures "Textures" OpName %type_sampler "type.sampler" OpName %out_var_SV_Target "out.var.SV_Target" OpName %main "main" OpName %type_sampled_image "type.sampled.image" OpName %TheStruct "TheStruct" OpMemberName %StructOfResources 0 "Texture" OpMemberName %StructOfResources 1 "Sampler" ; CHECK: OpName %TheStruct_Sampler "TheStruct.Sampler" ; CHECK: OpName %TheStruct_Texture "TheStruct.Texture" OpDecorate %out_var_SV_Target Location 0 OpDecorate %Textures DescriptorSet 0 OpDecorate %Textures Binding 0 OpDecorate %TheStruct DescriptorSet 0 OpDecorate %TheStruct Binding 10 ; CHECK: OpDecorate %TheStruct_Sampler DescriptorSet 0 ; CHECK: OpDecorate %TheStruct_Sampler Binding 11 ; CHECK: OpDecorate %TheStruct_Texture DescriptorSet 0 ; CHECK: OpDecorate %TheStruct_Texture Binding 10 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %v2float = OpTypeVector %float 2 %13 = OpConstantComposite %v2float %float_0 %float_0 %uint = OpTypeInt 32 0 %uint_10 = OpConstant %uint 10 %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %_arr_type_2d_image_uint_10 = OpTypeArray %type_2d_image %uint_10 %_ptr_UniformConstant__arr_type_2d_image_uint_10 = OpTypePointer UniformConstant %_arr_type_2d_image_uint_10 %type_sampler = OpTypeSampler %StructOfResources = OpTypeStruct %type_2d_image %type_sampler %_ptr_UniformConstant__struct_18 = OpTypePointer UniformConstant %StructOfResources %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %23 = OpTypeFunction %void %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %_ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %type_sampler %type_sampled_image = OpTypeSampledImage %type_2d_image %Textures = OpVariable %_ptr_UniformConstant__arr_type_2d_image_uint_10 UniformConstant %out_var_SV_Target = OpVariable %_ptr_Output_v4float Output %TheStruct = OpVariable %_ptr_UniformConstant__struct_18 UniformConstant %main = OpFunction %void None %23 %26 = OpLabel %27 = OpAccessChain %_ptr_UniformConstant_type_2d_image %Textures %int_0 %28 = OpLoad %type_2d_image %27 %29 = OpAccessChain %_ptr_UniformConstant_type_sampler %TheStruct %int_1 %31 = OpLoad %type_sampler %29 ; CHECK: %31 = OpLoad %type_sampler %TheStruct_Sampler %32 = OpSampledImage %type_sampled_image %28 %31 %33 = OpImageSampleImplicitLod %v4float %32 %13 None %34 = OpAccessChain %_ptr_UniformConstant_type_2d_image %TheStruct %int_0 %35 = OpLoad %type_2d_image %34 ; CHECK: %35 = OpLoad %type_2d_image %TheStruct_Texture %36 = OpAccessChain %_ptr_UniformConstant_type_sampler %TheStruct %int_1 %37 = OpLoad %type_sampler %36 ; CHECK: %37 = OpLoad %type_sampler %TheStruct_Sampler %38 = OpSampledImage %type_sampled_image %35 %37 %39 = OpImageSampleImplicitLod %v4float %38 %13 None %40 = OpFAdd %v4float %33 %39 OpStore %out_var_SV_Target %40 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch( text, false, /* flatten_composites=*/true, /* flatten_arrays=*/false); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/dominator_tree/000077500000000000000000000000001475742701700233255ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/opt/dominator_tree/CMakeLists.txt000066400000000000000000000017521475742701700260720ustar00rootroot00000000000000# Copyright (c) 2017 Google Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. add_spvtools_unittest(TARGET dominator_analysis SRCS ../function_utils.h common_dominators.cpp generated.cpp nested_ifs.cpp nested_ifs_post.cpp nested_loops.cpp nested_loops_with_unreachables.cpp post.cpp simple.cpp switch_case_fallthrough.cpp unreachable_for.cpp unreachable_for_post.cpp LIBS SPIRV-Tools-opt PCH_FILE pch_test_opt_dom ) KhronosGroup-SPIRV-Tools-f289d04/test/opt/dominator_tree/common_dominators.cpp000066400000000000000000000106271475742701700275660ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gtest/gtest.h" #include "source/opt/build_module.h" #include "source/opt/ir_context.h" namespace spvtools { namespace opt { namespace { using CommonDominatorsTest = ::testing::Test; const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %functy = OpTypeFunction %void %func = OpFunction %void None %functy %1 = OpLabel OpBranch %2 %2 = OpLabel OpLoopMerge %3 %4 None OpBranch %5 %5 = OpLabel OpBranchConditional %true %3 %4 %4 = OpLabel OpBranch %2 %3 = OpLabel OpSelectionMerge %6 None OpBranchConditional %true %7 %8 %7 = OpLabel OpBranch %6 %8 = OpLabel OpBranch %9 %9 = OpLabel OpBranch %6 %6 = OpLabel OpBranch %10 %11 = OpLabel OpBranch %10 %10 = OpLabel OpReturn OpFunctionEnd )"; BasicBlock* GetBlock(uint32_t id, std::unique_ptr& context) { return context->get_instr_block(context->get_def_use_mgr()->GetDef(id)); } TEST(CommonDominatorsTest, SameBlock) { std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); EXPECT_NE(nullptr, context); DominatorAnalysis* analysis = context->GetDominatorAnalysis(&*context->module()->begin()); for (auto& block : *context->module()->begin()) { EXPECT_EQ(&block, analysis->CommonDominator(&block, &block)); } } TEST(CommonDominatorsTest, ParentAndChild) { std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); EXPECT_NE(nullptr, context); DominatorAnalysis* analysis = context->GetDominatorAnalysis(&*context->module()->begin()); EXPECT_EQ( GetBlock(1u, context), analysis->CommonDominator(GetBlock(1u, context), GetBlock(2u, context))); EXPECT_EQ( GetBlock(2u, context), analysis->CommonDominator(GetBlock(2u, context), GetBlock(5u, context))); EXPECT_EQ( GetBlock(1u, context), analysis->CommonDominator(GetBlock(1u, context), GetBlock(5u, context))); } TEST(CommonDominatorsTest, BranchSplit) { std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); EXPECT_NE(nullptr, context); DominatorAnalysis* analysis = context->GetDominatorAnalysis(&*context->module()->begin()); EXPECT_EQ( GetBlock(3u, context), analysis->CommonDominator(GetBlock(7u, context), GetBlock(8u, context))); EXPECT_EQ( GetBlock(3u, context), analysis->CommonDominator(GetBlock(7u, context), GetBlock(9u, context))); } TEST(CommonDominatorsTest, LoopContinueAndMerge) { std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); EXPECT_NE(nullptr, context); DominatorAnalysis* analysis = context->GetDominatorAnalysis(&*context->module()->begin()); EXPECT_EQ( GetBlock(5u, context), analysis->CommonDominator(GetBlock(3u, context), GetBlock(4u, context))); } TEST(CommonDominatorsTest, NoCommonDominator) { std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); EXPECT_NE(nullptr, context); DominatorAnalysis* analysis = context->GetDominatorAnalysis(&*context->module()->begin()); EXPECT_EQ(nullptr, analysis->CommonDominator(GetBlock(10u, context), GetBlock(11u, context))); EXPECT_EQ(nullptr, analysis->CommonDominator(GetBlock(11u, context), GetBlock(6u, context))); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/dominator_tree/generated.cpp000066400000000000000000001122561475742701700257760ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include #include "gmock/gmock.h" #include "source/opt/dominator_analysis.h" #include "source/opt/iterator.h" #include "source/opt/pass.h" #include "test/opt/assembly_builder.h" #include "test/opt/function_utils.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using ::testing::UnorderedElementsAre; using PassClassTest = PassTest<::testing::Test>; // Check that x dominates y, and // if x != y then // x strictly dominates y and // y does not dominate x and // y does not strictly dominate x // if x == x then // x does not strictly dominate itself void check_dominance(const DominatorAnalysisBase& dom_tree, const Function* fn, uint32_t x, uint32_t y) { SCOPED_TRACE("Check dominance properties for Basic Block " + std::to_string(x) + " and " + std::to_string(y)); EXPECT_TRUE(dom_tree.Dominates(spvtest::GetBasicBlock(fn, x), spvtest::GetBasicBlock(fn, y))); EXPECT_TRUE(dom_tree.Dominates(x, y)); if (x == y) { EXPECT_FALSE(dom_tree.StrictlyDominates(x, x)); } else { EXPECT_TRUE(dom_tree.StrictlyDominates(x, y)); EXPECT_FALSE(dom_tree.Dominates(y, x)); EXPECT_FALSE(dom_tree.StrictlyDominates(y, x)); } } // Check that x does not dominates y and vice versa void check_no_dominance(const DominatorAnalysisBase& dom_tree, const Function* fn, uint32_t x, uint32_t y) { SCOPED_TRACE("Check no domination for Basic Block " + std::to_string(x) + " and " + std::to_string(y)); EXPECT_FALSE(dom_tree.Dominates(spvtest::GetBasicBlock(fn, x), spvtest::GetBasicBlock(fn, y))); EXPECT_FALSE(dom_tree.Dominates(x, y)); EXPECT_FALSE(dom_tree.StrictlyDominates(spvtest::GetBasicBlock(fn, x), spvtest::GetBasicBlock(fn, y))); EXPECT_FALSE(dom_tree.StrictlyDominates(x, y)); EXPECT_FALSE(dom_tree.Dominates(spvtest::GetBasicBlock(fn, y), spvtest::GetBasicBlock(fn, x))); EXPECT_FALSE(dom_tree.Dominates(y, x)); EXPECT_FALSE(dom_tree.StrictlyDominates(spvtest::GetBasicBlock(fn, y), spvtest::GetBasicBlock(fn, x))); EXPECT_FALSE(dom_tree.StrictlyDominates(y, x)); } TEST_F(PassClassTest, DominatorSimpleCFG) { const std::string text = R"( OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %1 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeBool %5 = OpTypeInt 32 0 %6 = OpConstant %5 0 %7 = OpConstantFalse %4 %8 = OpConstantTrue %4 %9 = OpConstant %5 1 %1 = OpFunction %2 None %3 %10 = OpLabel OpBranch %11 %11 = OpLabel OpSwitch %6 %12 1 %13 %12 = OpLabel OpBranch %14 %13 = OpLabel OpBranch %14 %14 = OpLabel OpBranchConditional %8 %11 %15 %15 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_0, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* fn = spvtest::GetFunction(module, 1); const BasicBlock* entry = spvtest::GetBasicBlock(fn, 10); EXPECT_EQ(entry, fn->entry().get()) << "The entry node is not the expected one"; // Test normal dominator tree { DominatorAnalysis dom_tree; const CFG& cfg = *context->cfg(); dom_tree.InitializeTree(cfg, fn); // Inspect the actual tree DominatorTree& tree = dom_tree.GetDomTree(); EXPECT_EQ(tree.GetRoot()->bb_, cfg.pseudo_entry_block()); EXPECT_TRUE( dom_tree.Dominates(cfg.pseudo_entry_block()->id(), entry->id())); // (strict) dominance checks for (uint32_t id : {10, 11, 12, 13, 14, 15}) check_dominance(dom_tree, fn, id, id); check_dominance(dom_tree, fn, 10, 11); check_dominance(dom_tree, fn, 10, 12); check_dominance(dom_tree, fn, 10, 13); check_dominance(dom_tree, fn, 10, 14); check_dominance(dom_tree, fn, 10, 15); check_dominance(dom_tree, fn, 11, 12); check_dominance(dom_tree, fn, 11, 13); check_dominance(dom_tree, fn, 11, 14); check_dominance(dom_tree, fn, 11, 15); check_dominance(dom_tree, fn, 14, 15); check_no_dominance(dom_tree, fn, 12, 13); check_no_dominance(dom_tree, fn, 12, 14); check_no_dominance(dom_tree, fn, 13, 14); // check with some invalid inputs EXPECT_FALSE(dom_tree.Dominates(nullptr, entry)); EXPECT_FALSE(dom_tree.Dominates(entry, nullptr)); EXPECT_FALSE(dom_tree.Dominates(static_cast(nullptr), static_cast(nullptr))); EXPECT_FALSE(dom_tree.Dominates(10, 1)); EXPECT_FALSE(dom_tree.Dominates(1, 10)); EXPECT_FALSE(dom_tree.Dominates(1, 1)); EXPECT_FALSE(dom_tree.StrictlyDominates(nullptr, entry)); EXPECT_FALSE(dom_tree.StrictlyDominates(entry, nullptr)); EXPECT_FALSE(dom_tree.StrictlyDominates(nullptr, nullptr)); EXPECT_FALSE(dom_tree.StrictlyDominates(10, 1)); EXPECT_FALSE(dom_tree.StrictlyDominates(1, 10)); EXPECT_FALSE(dom_tree.StrictlyDominates(1, 1)); EXPECT_EQ(dom_tree.ImmediateDominator(cfg.pseudo_entry_block()), nullptr); EXPECT_EQ(dom_tree.ImmediateDominator(entry), cfg.pseudo_entry_block()); EXPECT_EQ(dom_tree.ImmediateDominator(nullptr), nullptr); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 11)), spvtest::GetBasicBlock(fn, 10)); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 12)), spvtest::GetBasicBlock(fn, 11)); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 13)), spvtest::GetBasicBlock(fn, 11)); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 14)), spvtest::GetBasicBlock(fn, 11)); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 15)), spvtest::GetBasicBlock(fn, 14)); } // Test post dominator tree { PostDominatorAnalysis dom_tree; const CFG& cfg = *context->cfg(); dom_tree.InitializeTree(cfg, fn); // Inspect the actual tree DominatorTree& tree = dom_tree.GetDomTree(); EXPECT_EQ(tree.GetRoot()->bb_, cfg.pseudo_exit_block()); EXPECT_TRUE(dom_tree.Dominates(cfg.pseudo_exit_block()->id(), 15)); // (strict) dominance checks for (uint32_t id : {10, 11, 12, 13, 14, 15}) check_dominance(dom_tree, fn, id, id); check_dominance(dom_tree, fn, 14, 10); check_dominance(dom_tree, fn, 14, 11); check_dominance(dom_tree, fn, 14, 12); check_dominance(dom_tree, fn, 14, 13); check_dominance(dom_tree, fn, 15, 10); check_dominance(dom_tree, fn, 15, 11); check_dominance(dom_tree, fn, 15, 12); check_dominance(dom_tree, fn, 15, 13); check_dominance(dom_tree, fn, 15, 14); check_no_dominance(dom_tree, fn, 13, 12); check_no_dominance(dom_tree, fn, 12, 11); check_no_dominance(dom_tree, fn, 13, 11); // check with some invalid inputs EXPECT_FALSE(dom_tree.Dominates(nullptr, entry)); EXPECT_FALSE(dom_tree.Dominates(entry, nullptr)); EXPECT_FALSE(dom_tree.Dominates(static_cast(nullptr), static_cast(nullptr))); EXPECT_FALSE(dom_tree.Dominates(10, 1)); EXPECT_FALSE(dom_tree.Dominates(1, 10)); EXPECT_FALSE(dom_tree.Dominates(1, 1)); EXPECT_FALSE(dom_tree.StrictlyDominates(nullptr, entry)); EXPECT_FALSE(dom_tree.StrictlyDominates(entry, nullptr)); EXPECT_FALSE(dom_tree.StrictlyDominates(nullptr, nullptr)); EXPECT_FALSE(dom_tree.StrictlyDominates(10, 1)); EXPECT_FALSE(dom_tree.StrictlyDominates(1, 10)); EXPECT_FALSE(dom_tree.StrictlyDominates(1, 1)); EXPECT_EQ(dom_tree.ImmediateDominator(nullptr), nullptr); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 11)), spvtest::GetBasicBlock(fn, 14)); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 12)), spvtest::GetBasicBlock(fn, 14)); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 13)), spvtest::GetBasicBlock(fn, 14)); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 14)), spvtest::GetBasicBlock(fn, 15)); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 15)), cfg.pseudo_exit_block()); EXPECT_EQ(dom_tree.ImmediateDominator(cfg.pseudo_exit_block()), nullptr); } } TEST_F(PassClassTest, DominatorIrreducibleCFG) { const std::string text = R"( OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %1 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeBool %5 = OpTypeInt 32 0 %6 = OpConstantFalse %4 %7 = OpConstantTrue %4 %1 = OpFunction %2 None %3 %8 = OpLabel OpBranch %9 %9 = OpLabel OpBranchConditional %7 %10 %11 %10 = OpLabel OpBranch %11 %11 = OpLabel OpBranchConditional %7 %10 %12 %12 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_0, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* fn = spvtest::GetFunction(module, 1); const BasicBlock* entry = spvtest::GetBasicBlock(fn, 8); EXPECT_EQ(entry, fn->entry().get()) << "The entry node is not the expected one"; // Check normal dominator tree { DominatorAnalysis dom_tree; const CFG& cfg = *context->cfg(); dom_tree.InitializeTree(cfg, fn); // Inspect the actual tree DominatorTree& tree = dom_tree.GetDomTree(); EXPECT_EQ(tree.GetRoot()->bb_, cfg.pseudo_entry_block()); EXPECT_TRUE( dom_tree.Dominates(cfg.pseudo_entry_block()->id(), entry->id())); // (strict) dominance checks for (uint32_t id : {8, 9, 10, 11, 12}) check_dominance(dom_tree, fn, id, id); check_dominance(dom_tree, fn, 8, 9); check_dominance(dom_tree, fn, 8, 10); check_dominance(dom_tree, fn, 8, 11); check_dominance(dom_tree, fn, 8, 12); check_dominance(dom_tree, fn, 9, 10); check_dominance(dom_tree, fn, 9, 11); check_dominance(dom_tree, fn, 9, 12); check_dominance(dom_tree, fn, 11, 12); check_no_dominance(dom_tree, fn, 10, 11); EXPECT_EQ(dom_tree.ImmediateDominator(cfg.pseudo_entry_block()), nullptr); EXPECT_EQ(dom_tree.ImmediateDominator(entry), cfg.pseudo_entry_block()); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 9)), spvtest::GetBasicBlock(fn, 8)); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 10)), spvtest::GetBasicBlock(fn, 9)); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 11)), spvtest::GetBasicBlock(fn, 9)); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 12)), spvtest::GetBasicBlock(fn, 11)); } // Check post dominator tree { PostDominatorAnalysis dom_tree; const CFG& cfg = *context->cfg(); dom_tree.InitializeTree(cfg, fn); // Inspect the actual tree DominatorTree& tree = dom_tree.GetDomTree(); EXPECT_EQ(tree.GetRoot()->bb_, cfg.pseudo_exit_block()); EXPECT_TRUE(dom_tree.Dominates(cfg.pseudo_exit_block()->id(), 12)); // (strict) dominance checks for (uint32_t id : {8, 9, 10, 11, 12}) check_dominance(dom_tree, fn, id, id); check_dominance(dom_tree, fn, 12, 8); check_dominance(dom_tree, fn, 12, 10); check_dominance(dom_tree, fn, 12, 11); check_dominance(dom_tree, fn, 12, 12); check_dominance(dom_tree, fn, 11, 8); check_dominance(dom_tree, fn, 11, 9); check_dominance(dom_tree, fn, 11, 10); check_dominance(dom_tree, fn, 9, 8); EXPECT_EQ(dom_tree.ImmediateDominator(entry), spvtest::GetBasicBlock(fn, 9)); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 9)), spvtest::GetBasicBlock(fn, 11)); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 10)), spvtest::GetBasicBlock(fn, 11)); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 11)), spvtest::GetBasicBlock(fn, 12)); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 12)), cfg.pseudo_exit_block()); EXPECT_EQ(dom_tree.ImmediateDominator(cfg.pseudo_exit_block()), nullptr); } } TEST_F(PassClassTest, DominatorLoopToSelf) { const std::string text = R"( OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %1 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeBool %5 = OpTypeInt 32 0 %6 = OpConstant %5 0 %7 = OpConstantFalse %4 %8 = OpConstantTrue %4 %9 = OpConstant %5 1 %1 = OpFunction %2 None %3 %10 = OpLabel OpBranch %11 %11 = OpLabel OpSwitch %6 %12 1 %11 %12 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_0, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* fn = spvtest::GetFunction(module, 1); const BasicBlock* entry = spvtest::GetBasicBlock(fn, 10); EXPECT_EQ(entry, fn->entry().get()) << "The entry node is not the expected one"; // Check normal dominator tree { DominatorAnalysis dom_tree; const CFG& cfg = *context->cfg(); dom_tree.InitializeTree(cfg, fn); // Inspect the actual tree DominatorTree& tree = dom_tree.GetDomTree(); EXPECT_EQ(tree.GetRoot()->bb_, cfg.pseudo_entry_block()); EXPECT_TRUE( dom_tree.Dominates(cfg.pseudo_entry_block()->id(), entry->id())); // (strict) dominance checks for (uint32_t id : {10, 11, 12}) check_dominance(dom_tree, fn, id, id); check_dominance(dom_tree, fn, 10, 11); check_dominance(dom_tree, fn, 10, 12); check_dominance(dom_tree, fn, 11, 12); EXPECT_EQ(dom_tree.ImmediateDominator(cfg.pseudo_entry_block()), nullptr); EXPECT_EQ(dom_tree.ImmediateDominator(entry), cfg.pseudo_entry_block()); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 11)), spvtest::GetBasicBlock(fn, 10)); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 12)), spvtest::GetBasicBlock(fn, 11)); std::array node_order = {{10, 11, 12}}; { // Test dominator tree iteration order. DominatorTree::iterator node_it = dom_tree.GetDomTree().begin(); DominatorTree::iterator node_end = dom_tree.GetDomTree().end(); for (uint32_t id : node_order) { EXPECT_NE(node_it, node_end); EXPECT_EQ(node_it->id(), id); node_it++; } EXPECT_EQ(node_it, node_end); } { // Same as above, but with const iterators. DominatorTree::const_iterator node_it = dom_tree.GetDomTree().cbegin(); DominatorTree::const_iterator node_end = dom_tree.GetDomTree().cend(); for (uint32_t id : node_order) { EXPECT_NE(node_it, node_end); EXPECT_EQ(node_it->id(), id); node_it++; } EXPECT_EQ(node_it, node_end); } { // Test dominator tree iteration order. DominatorTree::post_iterator node_it = dom_tree.GetDomTree().post_begin(); DominatorTree::post_iterator node_end = dom_tree.GetDomTree().post_end(); for (uint32_t id : make_range(node_order.rbegin(), node_order.rend())) { EXPECT_NE(node_it, node_end); EXPECT_EQ(node_it->id(), id); node_it++; } EXPECT_EQ(node_it, node_end); } { // Same as above, but with const iterators. DominatorTree::const_post_iterator node_it = dom_tree.GetDomTree().post_cbegin(); DominatorTree::const_post_iterator node_end = dom_tree.GetDomTree().post_cend(); for (uint32_t id : make_range(node_order.rbegin(), node_order.rend())) { EXPECT_NE(node_it, node_end); EXPECT_EQ(node_it->id(), id); node_it++; } EXPECT_EQ(node_it, node_end); } } // Check post dominator tree { PostDominatorAnalysis dom_tree; const CFG& cfg = *context->cfg(); dom_tree.InitializeTree(cfg, fn); // Inspect the actual tree DominatorTree& tree = dom_tree.GetDomTree(); EXPECT_EQ(tree.GetRoot()->bb_, cfg.pseudo_exit_block()); EXPECT_TRUE(dom_tree.Dominates(cfg.pseudo_exit_block()->id(), 12)); // (strict) dominance checks for (uint32_t id : {10, 11, 12}) check_dominance(dom_tree, fn, id, id); check_dominance(dom_tree, fn, 12, 10); check_dominance(dom_tree, fn, 12, 11); check_dominance(dom_tree, fn, 12, 12); EXPECT_EQ(dom_tree.ImmediateDominator(entry), spvtest::GetBasicBlock(fn, 11)); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 11)), spvtest::GetBasicBlock(fn, 12)); EXPECT_EQ(dom_tree.ImmediateDominator(cfg.pseudo_exit_block()), nullptr); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 12)), cfg.pseudo_exit_block()); std::array node_order = {{12, 11, 10}}; { // Test dominator tree iteration order. DominatorTree::iterator node_it = tree.begin(); DominatorTree::iterator node_end = tree.end(); for (uint32_t id : node_order) { EXPECT_NE(node_it, node_end); EXPECT_EQ(node_it->id(), id); node_it++; } EXPECT_EQ(node_it, node_end); } { // Same as above, but with const iterators. DominatorTree::const_iterator node_it = tree.cbegin(); DominatorTree::const_iterator node_end = tree.cend(); for (uint32_t id : node_order) { EXPECT_NE(node_it, node_end); EXPECT_EQ(node_it->id(), id); node_it++; } EXPECT_EQ(node_it, node_end); } { // Test dominator tree iteration order. DominatorTree::post_iterator node_it = dom_tree.GetDomTree().post_begin(); DominatorTree::post_iterator node_end = dom_tree.GetDomTree().post_end(); for (uint32_t id : make_range(node_order.rbegin(), node_order.rend())) { EXPECT_NE(node_it, node_end); EXPECT_EQ(node_it->id(), id); node_it++; } EXPECT_EQ(node_it, node_end); } { // Same as above, but with const iterators. DominatorTree::const_post_iterator node_it = dom_tree.GetDomTree().post_cbegin(); DominatorTree::const_post_iterator node_end = dom_tree.GetDomTree().post_cend(); for (uint32_t id : make_range(node_order.rbegin(), node_order.rend())) { EXPECT_NE(node_it, node_end); EXPECT_EQ(node_it->id(), id); node_it++; } EXPECT_EQ(node_it, node_end); } } } TEST_F(PassClassTest, DominatorUnreachableInLoop) { const std::string text = R"( OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %1 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeBool %5 = OpTypeInt 32 0 %6 = OpConstant %5 0 %7 = OpConstantFalse %4 %8 = OpConstantTrue %4 %9 = OpConstant %5 1 %1 = OpFunction %2 None %3 %10 = OpLabel OpBranch %11 %11 = OpLabel OpSwitch %6 %12 1 %13 %12 = OpLabel OpBranch %14 %13 = OpLabel OpUnreachable %14 = OpLabel OpBranchConditional %8 %11 %15 %15 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_0, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* fn = spvtest::GetFunction(module, 1); const BasicBlock* entry = spvtest::GetBasicBlock(fn, 10); EXPECT_EQ(entry, fn->entry().get()) << "The entry node is not the expected one"; // Check normal dominator tree { DominatorAnalysis dom_tree; const CFG& cfg = *context->cfg(); dom_tree.InitializeTree(cfg, fn); // Inspect the actual tree DominatorTree& tree = dom_tree.GetDomTree(); EXPECT_EQ(tree.GetRoot()->bb_, cfg.pseudo_entry_block()); EXPECT_TRUE( dom_tree.Dominates(cfg.pseudo_entry_block()->id(), entry->id())); // (strict) dominance checks for (uint32_t id : {10, 11, 12, 13, 14, 15}) check_dominance(dom_tree, fn, id, id); check_dominance(dom_tree, fn, 10, 11); check_dominance(dom_tree, fn, 10, 13); check_dominance(dom_tree, fn, 10, 12); check_dominance(dom_tree, fn, 10, 14); check_dominance(dom_tree, fn, 10, 15); check_dominance(dom_tree, fn, 11, 12); check_dominance(dom_tree, fn, 11, 13); check_dominance(dom_tree, fn, 11, 14); check_dominance(dom_tree, fn, 11, 15); check_dominance(dom_tree, fn, 12, 14); check_dominance(dom_tree, fn, 12, 15); check_dominance(dom_tree, fn, 14, 15); check_no_dominance(dom_tree, fn, 13, 12); check_no_dominance(dom_tree, fn, 13, 14); check_no_dominance(dom_tree, fn, 13, 15); EXPECT_EQ(dom_tree.ImmediateDominator(cfg.pseudo_entry_block()), nullptr); EXPECT_EQ(dom_tree.ImmediateDominator(entry), cfg.pseudo_entry_block()); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 11)), spvtest::GetBasicBlock(fn, 10)); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 12)), spvtest::GetBasicBlock(fn, 11)); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 13)), spvtest::GetBasicBlock(fn, 11)); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 14)), spvtest::GetBasicBlock(fn, 12)); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 15)), spvtest::GetBasicBlock(fn, 14)); } // Check post dominator tree. { PostDominatorAnalysis dom_tree; const CFG& cfg = *context->cfg(); dom_tree.InitializeTree(cfg, fn); // (strict) dominance checks. for (uint32_t id : {10, 11, 12, 13, 14, 15}) check_dominance(dom_tree, fn, id, id); check_no_dominance(dom_tree, fn, 15, 10); check_no_dominance(dom_tree, fn, 15, 11); check_no_dominance(dom_tree, fn, 15, 12); check_no_dominance(dom_tree, fn, 15, 13); check_no_dominance(dom_tree, fn, 15, 14); check_dominance(dom_tree, fn, 14, 12); check_no_dominance(dom_tree, fn, 13, 10); check_no_dominance(dom_tree, fn, 13, 11); check_no_dominance(dom_tree, fn, 13, 12); check_no_dominance(dom_tree, fn, 13, 14); check_no_dominance(dom_tree, fn, 13, 15); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 10)), spvtest::GetBasicBlock(fn, 11)); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 12)), spvtest::GetBasicBlock(fn, 14)); EXPECT_EQ(dom_tree.ImmediateDominator(cfg.pseudo_exit_block()), nullptr); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 15)), cfg.pseudo_exit_block()); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 13)), cfg.pseudo_exit_block()); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 14)), cfg.pseudo_exit_block()); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 11)), cfg.pseudo_exit_block()); } } TEST_F(PassClassTest, DominatorInfinitLoop) { const std::string text = R"( OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %1 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeBool %5 = OpTypeInt 32 0 %6 = OpConstant %5 0 %7 = OpConstantFalse %4 %8 = OpConstantTrue %4 %9 = OpConstant %5 1 %1 = OpFunction %2 None %3 %10 = OpLabel OpBranch %11 %11 = OpLabel OpSwitch %6 %12 1 %13 %12 = OpLabel OpReturn %13 = OpLabel OpBranch %13 OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_0, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* fn = spvtest::GetFunction(module, 1); const BasicBlock* entry = spvtest::GetBasicBlock(fn, 10); EXPECT_EQ(entry, fn->entry().get()) << "The entry node is not the expected one"; // Check normal dominator tree { DominatorAnalysis dom_tree; const CFG& cfg = *context->cfg(); dom_tree.InitializeTree(cfg, fn); // Inspect the actual tree DominatorTree& tree = dom_tree.GetDomTree(); EXPECT_EQ(tree.GetRoot()->bb_, cfg.pseudo_entry_block()); EXPECT_TRUE( dom_tree.Dominates(cfg.pseudo_entry_block()->id(), entry->id())); // (strict) dominance checks for (uint32_t id : {10, 11, 12, 13}) check_dominance(dom_tree, fn, id, id); check_dominance(dom_tree, fn, 10, 11); check_dominance(dom_tree, fn, 10, 12); check_dominance(dom_tree, fn, 10, 13); check_dominance(dom_tree, fn, 11, 12); check_dominance(dom_tree, fn, 11, 13); check_no_dominance(dom_tree, fn, 13, 12); EXPECT_EQ(dom_tree.ImmediateDominator(cfg.pseudo_entry_block()), nullptr); EXPECT_EQ(dom_tree.ImmediateDominator(entry), cfg.pseudo_entry_block()); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 11)), spvtest::GetBasicBlock(fn, 10)); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 12)), spvtest::GetBasicBlock(fn, 11)); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 13)), spvtest::GetBasicBlock(fn, 11)); } // Check post dominator tree { PostDominatorAnalysis dom_tree; const CFG& cfg = *context->cfg(); dom_tree.InitializeTree(cfg, fn); // Inspect the actual tree DominatorTree& tree = dom_tree.GetDomTree(); EXPECT_EQ(tree.GetRoot()->bb_, cfg.pseudo_exit_block()); EXPECT_TRUE(dom_tree.Dominates(cfg.pseudo_exit_block()->id(), 12)); // (strict) dominance checks for (uint32_t id : {10, 11, 12}) check_dominance(dom_tree, fn, id, id); check_dominance(dom_tree, fn, 12, 11); check_dominance(dom_tree, fn, 12, 10); // 13 should be completely out of tree as it's unreachable from exit nodes check_no_dominance(dom_tree, fn, 12, 13); check_no_dominance(dom_tree, fn, 11, 13); check_no_dominance(dom_tree, fn, 10, 13); EXPECT_EQ(dom_tree.ImmediateDominator(cfg.pseudo_exit_block()), nullptr); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 12)), cfg.pseudo_exit_block()); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 10)), spvtest::GetBasicBlock(fn, 11)); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 11)), spvtest::GetBasicBlock(fn, 12)); } } TEST_F(PassClassTest, DominatorUnreachableFromEntry) { const std::string text = R"( OpCapability Addresses OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %1 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeBool %5 = OpTypeInt 32 0 %6 = OpConstantFalse %4 %7 = OpConstantTrue %4 %1 = OpFunction %2 None %3 %8 = OpLabel OpBranch %9 %9 = OpLabel OpReturn %10 = OpLabel OpBranch %9 OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_0, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* fn = spvtest::GetFunction(module, 1); const BasicBlock* entry = spvtest::GetBasicBlock(fn, 8); EXPECT_EQ(entry, fn->entry().get()) << "The entry node is not the expected one"; // Check dominator tree { DominatorAnalysis dom_tree; const CFG& cfg = *context->cfg(); dom_tree.InitializeTree(cfg, fn); // Inspect the actual tree DominatorTree& tree = dom_tree.GetDomTree(); EXPECT_EQ(tree.GetRoot()->bb_, cfg.pseudo_entry_block()); EXPECT_TRUE( dom_tree.Dominates(cfg.pseudo_entry_block()->id(), entry->id())); // (strict) dominance checks for (uint32_t id : {8, 9}) check_dominance(dom_tree, fn, id, id); check_dominance(dom_tree, fn, 8, 9); check_no_dominance(dom_tree, fn, 10, 8); check_no_dominance(dom_tree, fn, 10, 9); EXPECT_EQ(dom_tree.ImmediateDominator(cfg.pseudo_entry_block()), nullptr); EXPECT_EQ(dom_tree.ImmediateDominator(entry), cfg.pseudo_entry_block()); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 9)), spvtest::GetBasicBlock(fn, 8)); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 10)), nullptr); } // Check post dominator tree { PostDominatorAnalysis dom_tree; const CFG& cfg = *context->cfg(); dom_tree.InitializeTree(cfg, fn); // Inspect the actual tree DominatorTree& tree = dom_tree.GetDomTree(); EXPECT_EQ(tree.GetRoot()->bb_, cfg.pseudo_exit_block()); EXPECT_TRUE(dom_tree.Dominates(cfg.pseudo_exit_block()->id(), 9)); // (strict) dominance checks for (uint32_t id : {8, 9, 10}) check_dominance(dom_tree, fn, id, id); check_dominance(dom_tree, fn, 9, 8); check_dominance(dom_tree, fn, 9, 10); EXPECT_EQ(dom_tree.ImmediateDominator(entry), spvtest::GetBasicBlock(fn, 9)); EXPECT_EQ(dom_tree.ImmediateDominator(cfg.pseudo_exit_block()), nullptr); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 9)), cfg.pseudo_exit_block()); EXPECT_EQ(dom_tree.ImmediateDominator(spvtest::GetBasicBlock(fn, 10)), spvtest::GetBasicBlock(fn, 9)); } } TEST_F(PassClassTest, DominationForInstructions) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeBool %8 = OpConstantTrue %7 %9 = OpConstant %6 37 %10 = OpConstant %6 3 %13 = OpConstant %6 5 %4 = OpFunction %2 None %3 %5 = OpLabel %12 = OpIAdd %6 %9 %10 %15 = OpISub %6 %12 %13 OpSelectionMerge %18 None OpBranchConditional %8 %16 %17 %16 = OpLabel %20 = OpISub %6 %12 %13 OpBranch %18 %17 = OpLabel %21 = OpISub %6 %12 %13 OpBranch %18 %18 = OpLabel %22 = OpISub %6 %12 %13 OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_0, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); EXPECT_NE(nullptr, context->module()) << "Assembling failed for shader:\n" << text << std::endl; { const DominatorAnalysis* dominator_analysis = context->GetDominatorAnalysis( spvtest::GetFunction(context->module(), 4)); EXPECT_TRUE( dominator_analysis->Dominates(context->get_def_use_mgr()->GetDef(12), context->get_def_use_mgr()->GetDef(15))); EXPECT_FALSE( dominator_analysis->Dominates(context->get_def_use_mgr()->GetDef(15), context->get_def_use_mgr()->GetDef(12))); EXPECT_TRUE( dominator_analysis->Dominates(context->get_def_use_mgr()->GetDef(5), context->get_def_use_mgr()->GetDef(12))); EXPECT_FALSE( dominator_analysis->Dominates(context->get_def_use_mgr()->GetDef(12), context->get_def_use_mgr()->GetDef(5))); EXPECT_TRUE( dominator_analysis->Dominates(context->get_def_use_mgr()->GetDef(15), context->get_def_use_mgr()->GetDef(16))); EXPECT_TRUE( dominator_analysis->Dominates(context->get_def_use_mgr()->GetDef(15), context->get_def_use_mgr()->GetDef(21))); EXPECT_TRUE( dominator_analysis->Dominates(context->get_def_use_mgr()->GetDef(15), context->get_def_use_mgr()->GetDef(18))); EXPECT_TRUE( dominator_analysis->Dominates(context->get_def_use_mgr()->GetDef(15), context->get_def_use_mgr()->GetDef(22))); EXPECT_FALSE( dominator_analysis->Dominates(context->get_def_use_mgr()->GetDef(20), context->get_def_use_mgr()->GetDef(22))); EXPECT_FALSE( dominator_analysis->Dominates(context->get_def_use_mgr()->GetDef(21), context->get_def_use_mgr()->GetDef(22))); EXPECT_TRUE( dominator_analysis->Dominates(context->get_def_use_mgr()->GetDef(15), context->get_def_use_mgr()->GetDef(15))); } { const PostDominatorAnalysis* post_dominator_analysis = context->GetPostDominatorAnalysis( spvtest::GetFunction(context->module(), 4)); EXPECT_TRUE(post_dominator_analysis->Dominates( context->get_def_use_mgr()->GetDef(15), context->get_def_use_mgr()->GetDef(12))); EXPECT_FALSE(post_dominator_analysis->Dominates( context->get_def_use_mgr()->GetDef(12), context->get_def_use_mgr()->GetDef(15))); EXPECT_TRUE(post_dominator_analysis->Dominates( context->get_def_use_mgr()->GetDef(12), context->get_def_use_mgr()->GetDef(5))); EXPECT_FALSE(post_dominator_analysis->Dominates( context->get_def_use_mgr()->GetDef(5), context->get_def_use_mgr()->GetDef(12))); EXPECT_FALSE(post_dominator_analysis->Dominates( context->get_def_use_mgr()->GetDef(16), context->get_def_use_mgr()->GetDef(15))); EXPECT_FALSE(post_dominator_analysis->Dominates( context->get_def_use_mgr()->GetDef(21), context->get_def_use_mgr()->GetDef(15))); EXPECT_TRUE(post_dominator_analysis->Dominates( context->get_def_use_mgr()->GetDef(18), context->get_def_use_mgr()->GetDef(15))); EXPECT_TRUE(post_dominator_analysis->Dominates( context->get_def_use_mgr()->GetDef(22), context->get_def_use_mgr()->GetDef(15))); EXPECT_TRUE(post_dominator_analysis->Dominates( context->get_def_use_mgr()->GetDef(22), context->get_def_use_mgr()->GetDef(20))); EXPECT_TRUE(post_dominator_analysis->Dominates( context->get_def_use_mgr()->GetDef(22), context->get_def_use_mgr()->GetDef(21))); EXPECT_TRUE(post_dominator_analysis->Dominates( context->get_def_use_mgr()->GetDef(15), context->get_def_use_mgr()->GetDef(15))); } } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/dominator_tree/nested_ifs.cpp000066400000000000000000000112261475742701700261560ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gmock/gmock.h" #include "source/opt/dominator_analysis.h" #include "source/opt/pass.h" #include "test/opt/assembly_builder.h" #include "test/opt/function_utils.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using ::testing::UnorderedElementsAre; using PassClassTest = PassTest<::testing::Test>; /* Generated from the following GLSL #version 330 core layout(location = 0) out vec4 v; void main(){ if (true) { if (true) { v = vec4(1,1,1,1); } else { v = vec4(2,2,2,2); } } else { if (true) { v = vec4(3,3,3,3); } else { v = vec4(4,4,4,4); } } } */ TEST_F(PassClassTest, UnreachableNestedIfs) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %15 OpExecutionMode %4 OriginUpperLeft OpSource GLSL 330 OpName %4 "main" OpName %15 "v" OpDecorate %15 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantTrue %6 %12 = OpTypeFloat 32 %13 = OpTypeVector %12 4 %14 = OpTypePointer Output %13 %15 = OpVariable %14 Output %16 = OpConstant %12 1 %17 = OpConstantComposite %13 %16 %16 %16 %16 %19 = OpConstant %12 2 %20 = OpConstantComposite %13 %19 %19 %19 %19 %24 = OpConstant %12 3 %25 = OpConstantComposite %13 %24 %24 %24 %24 %27 = OpConstant %12 4 %28 = OpConstantComposite %13 %27 %27 %27 %27 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %9 None OpBranchConditional %7 %8 %21 %8 = OpLabel OpSelectionMerge %11 None OpBranchConditional %7 %10 %18 %10 = OpLabel OpStore %15 %17 OpBranch %11 %18 = OpLabel OpStore %15 %20 OpBranch %11 %11 = OpLabel OpBranch %9 %21 = OpLabel OpSelectionMerge %23 None OpBranchConditional %7 %22 %26 %22 = OpLabel OpStore %15 %25 OpBranch %23 %26 = OpLabel OpStore %15 %28 OpBranch %23 %23 = OpLabel OpBranch %9 %9 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 4); DominatorAnalysis* analysis = context->GetDominatorAnalysis(f); EXPECT_TRUE(analysis->Dominates(5, 8)); EXPECT_TRUE(analysis->Dominates(5, 9)); EXPECT_TRUE(analysis->Dominates(5, 21)); EXPECT_TRUE(analysis->Dominates(5, 18)); EXPECT_TRUE(analysis->Dominates(5, 10)); EXPECT_TRUE(analysis->Dominates(5, 11)); EXPECT_TRUE(analysis->Dominates(5, 23)); EXPECT_TRUE(analysis->Dominates(5, 22)); EXPECT_TRUE(analysis->Dominates(5, 26)); EXPECT_TRUE(analysis->Dominates(8, 18)); EXPECT_TRUE(analysis->Dominates(8, 10)); EXPECT_TRUE(analysis->Dominates(8, 11)); EXPECT_TRUE(analysis->Dominates(21, 23)); EXPECT_TRUE(analysis->Dominates(21, 22)); EXPECT_TRUE(analysis->Dominates(21, 26)); EXPECT_TRUE(analysis->StrictlyDominates(5, 8)); EXPECT_TRUE(analysis->StrictlyDominates(5, 9)); EXPECT_TRUE(analysis->StrictlyDominates(5, 21)); EXPECT_TRUE(analysis->StrictlyDominates(8, 18)); EXPECT_TRUE(analysis->StrictlyDominates(8, 10)); EXPECT_TRUE(analysis->StrictlyDominates(8, 11)); EXPECT_TRUE(analysis->StrictlyDominates(21, 23)); EXPECT_TRUE(analysis->StrictlyDominates(21, 22)); EXPECT_TRUE(analysis->StrictlyDominates(21, 26)); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/dominator_tree/nested_ifs_post.cpp000066400000000000000000000115241475742701700272240ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gmock/gmock.h" #include "source/opt/dominator_analysis.h" #include "source/opt/pass.h" #include "test/opt/assembly_builder.h" #include "test/opt/function_utils.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using ::testing::UnorderedElementsAre; using PassClassTest = PassTest<::testing::Test>; /* Generated from the following GLSL #version 330 core layout(location = 0) out vec4 v; void main(){ if (true) { if (true) { v = vec4(1,1,1,1); } else { v = vec4(2,2,2,2); } } else { if (true) { v = vec4(3,3,3,3); } else { v = vec4(4,4,4,4); } } } */ TEST_F(PassClassTest, UnreachableNestedIfs) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %15 OpExecutionMode %4 OriginUpperLeft OpSource GLSL 330 OpName %4 "main" OpName %15 "v" OpDecorate %15 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantTrue %6 %12 = OpTypeFloat 32 %13 = OpTypeVector %12 4 %14 = OpTypePointer Output %13 %15 = OpVariable %14 Output %16 = OpConstant %12 1 %17 = OpConstantComposite %13 %16 %16 %16 %16 %19 = OpConstant %12 2 %20 = OpConstantComposite %13 %19 %19 %19 %19 %24 = OpConstant %12 3 %25 = OpConstantComposite %13 %24 %24 %24 %24 %27 = OpConstant %12 4 %28 = OpConstantComposite %13 %27 %27 %27 %27 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %9 None OpBranchConditional %7 %8 %21 %8 = OpLabel OpSelectionMerge %11 None OpBranchConditional %7 %10 %18 %10 = OpLabel OpStore %15 %17 OpBranch %11 %18 = OpLabel OpStore %15 %20 OpBranch %11 %11 = OpLabel OpBranch %9 %21 = OpLabel OpSelectionMerge %23 None OpBranchConditional %7 %22 %26 %22 = OpLabel OpStore %15 %25 OpBranch %23 %26 = OpLabel OpStore %15 %28 OpBranch %23 %23 = OpLabel OpBranch %9 %9 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 4); PostDominatorAnalysis* analysis = context->GetPostDominatorAnalysis(f); EXPECT_TRUE(analysis->Dominates(5, 5)); EXPECT_TRUE(analysis->Dominates(8, 8)); EXPECT_TRUE(analysis->Dominates(9, 9)); EXPECT_TRUE(analysis->Dominates(10, 10)); EXPECT_TRUE(analysis->Dominates(11, 11)); EXPECT_TRUE(analysis->Dominates(18, 18)); EXPECT_TRUE(analysis->Dominates(21, 21)); EXPECT_TRUE(analysis->Dominates(22, 22)); EXPECT_TRUE(analysis->Dominates(23, 23)); EXPECT_TRUE(analysis->Dominates(26, 26)); EXPECT_TRUE(analysis->Dominates(9, 5)); EXPECT_TRUE(analysis->Dominates(9, 11)); EXPECT_TRUE(analysis->Dominates(9, 23)); EXPECT_TRUE(analysis->Dominates(11, 10)); EXPECT_TRUE(analysis->Dominates(11, 18)); EXPECT_TRUE(analysis->Dominates(11, 8)); EXPECT_TRUE(analysis->Dominates(23, 22)); EXPECT_TRUE(analysis->Dominates(23, 26)); EXPECT_TRUE(analysis->Dominates(23, 21)); EXPECT_TRUE(analysis->StrictlyDominates(9, 5)); EXPECT_TRUE(analysis->StrictlyDominates(9, 11)); EXPECT_TRUE(analysis->StrictlyDominates(9, 23)); EXPECT_TRUE(analysis->StrictlyDominates(11, 10)); EXPECT_TRUE(analysis->StrictlyDominates(11, 18)); EXPECT_TRUE(analysis->StrictlyDominates(11, 8)); EXPECT_TRUE(analysis->StrictlyDominates(23, 22)); EXPECT_TRUE(analysis->StrictlyDominates(23, 26)); EXPECT_TRUE(analysis->StrictlyDominates(23, 21)); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/dominator_tree/nested_loops.cpp000066400000000000000000000275641475742701700265450ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gmock/gmock.h" #include "source/opt/dominator_analysis.h" #include "source/opt/pass.h" #include "test/opt/assembly_builder.h" #include "test/opt/function_utils.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using ::testing::UnorderedElementsAre; using PassClassTest = PassTest<::testing::Test>; /* Generated from the following GLSL #version 440 core layout(location = 0) out vec4 v; layout(location = 1) in vec4 in_val; void main() { for (int i = 0; i < in_val.x; ++i) { for (int j = 0; j < in_val.y; j++) { } } for (int i = 0; i < in_val.x; ++i) { for (int j = 0; j < in_val.y; j++) { } if (in_val.z == in_val.w) { break; } } int i = 0; while (i < in_val.x) { ++i; for (int j = 0; j < 1; j++) { for (int k = 0; k < 1; k++) { } } } i = 0; while (i < in_val.x) { ++i; if (in_val.z == in_val.w) { continue; } for (int j = 0; j < 1; j++) { for (int k = 0; k < 1; k++) { } if (in_val.z == in_val.w) { break; } } } v = vec4(1,1,1,1); } */ TEST_F(PassClassTest, BasicVisitFromEntryPoint) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %20 %163 OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %20 "in_val" OpName %28 "j" OpName %45 "i" OpName %56 "j" OpName %81 "i" OpName %94 "j" OpName %102 "k" OpName %134 "j" OpName %142 "k" OpName %163 "v" OpDecorate %20 Location 1 OpDecorate %163 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpTypeFloat 32 %18 = OpTypeVector %16 4 %19 = OpTypePointer Input %18 %20 = OpVariable %19 Input %21 = OpTypeInt 32 0 %22 = OpConstant %21 0 %23 = OpTypePointer Input %16 %26 = OpTypeBool %36 = OpConstant %21 1 %41 = OpConstant %6 1 %69 = OpConstant %21 2 %72 = OpConstant %21 3 %162 = OpTypePointer Output %18 %163 = OpVariable %162 Output %164 = OpConstant %16 1 %165 = OpConstantComposite %18 %164 %164 %164 %164 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %28 = OpVariable %7 Function %45 = OpVariable %7 Function %56 = OpVariable %7 Function %81 = OpVariable %7 Function %94 = OpVariable %7 Function %102 = OpVariable %7 Function %134 = OpVariable %7 Function %142 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %15 = OpLoad %6 %8 %17 = OpConvertSToF %16 %15 %24 = OpAccessChain %23 %20 %22 %25 = OpLoad %16 %24 %27 = OpFOrdLessThan %26 %17 %25 OpBranchConditional %27 %11 %12 %11 = OpLabel OpStore %28 %9 OpBranch %29 %29 = OpLabel OpLoopMerge %31 %32 None OpBranch %33 %33 = OpLabel %34 = OpLoad %6 %28 %35 = OpConvertSToF %16 %34 %37 = OpAccessChain %23 %20 %36 %38 = OpLoad %16 %37 %39 = OpFOrdLessThan %26 %35 %38 OpBranchConditional %39 %30 %31 %30 = OpLabel OpBranch %32 %32 = OpLabel %40 = OpLoad %6 %28 %42 = OpIAdd %6 %40 %41 OpStore %28 %42 OpBranch %29 %31 = OpLabel OpBranch %13 %13 = OpLabel %43 = OpLoad %6 %8 %44 = OpIAdd %6 %43 %41 OpStore %8 %44 OpBranch %10 %12 = OpLabel OpStore %45 %9 OpBranch %46 %46 = OpLabel OpLoopMerge %48 %49 None OpBranch %50 %50 = OpLabel %51 = OpLoad %6 %45 %52 = OpConvertSToF %16 %51 %53 = OpAccessChain %23 %20 %22 %54 = OpLoad %16 %53 %55 = OpFOrdLessThan %26 %52 %54 OpBranchConditional %55 %47 %48 %47 = OpLabel OpStore %56 %9 OpBranch %57 %57 = OpLabel OpLoopMerge %59 %60 None OpBranch %61 %61 = OpLabel %62 = OpLoad %6 %56 %63 = OpConvertSToF %16 %62 %64 = OpAccessChain %23 %20 %36 %65 = OpLoad %16 %64 %66 = OpFOrdLessThan %26 %63 %65 OpBranchConditional %66 %58 %59 %58 = OpLabel OpBranch %60 %60 = OpLabel %67 = OpLoad %6 %56 %68 = OpIAdd %6 %67 %41 OpStore %56 %68 OpBranch %57 %59 = OpLabel %70 = OpAccessChain %23 %20 %69 %71 = OpLoad %16 %70 %73 = OpAccessChain %23 %20 %72 %74 = OpLoad %16 %73 %75 = OpFOrdEqual %26 %71 %74 OpSelectionMerge %77 None OpBranchConditional %75 %76 %77 %76 = OpLabel OpBranch %48 %77 = OpLabel OpBranch %49 %49 = OpLabel %79 = OpLoad %6 %45 %80 = OpIAdd %6 %79 %41 OpStore %45 %80 OpBranch %46 %48 = OpLabel OpStore %81 %9 OpBranch %82 %82 = OpLabel OpLoopMerge %84 %85 None OpBranch %86 %86 = OpLabel %87 = OpLoad %6 %81 %88 = OpConvertSToF %16 %87 %89 = OpAccessChain %23 %20 %22 %90 = OpLoad %16 %89 %91 = OpFOrdLessThan %26 %88 %90 OpBranchConditional %91 %83 %84 %83 = OpLabel %92 = OpLoad %6 %81 %93 = OpIAdd %6 %92 %41 OpStore %81 %93 OpStore %94 %9 OpBranch %95 %95 = OpLabel OpLoopMerge %97 %98 None OpBranch %99 %99 = OpLabel %100 = OpLoad %6 %94 %101 = OpSLessThan %26 %100 %41 OpBranchConditional %101 %96 %97 %96 = OpLabel OpStore %102 %9 OpBranch %103 %103 = OpLabel OpLoopMerge %105 %106 None OpBranch %107 %107 = OpLabel %108 = OpLoad %6 %102 %109 = OpSLessThan %26 %108 %41 OpBranchConditional %109 %104 %105 %104 = OpLabel OpBranch %106 %106 = OpLabel %110 = OpLoad %6 %102 %111 = OpIAdd %6 %110 %41 OpStore %102 %111 OpBranch %103 %105 = OpLabel OpBranch %98 %98 = OpLabel %112 = OpLoad %6 %94 %113 = OpIAdd %6 %112 %41 OpStore %94 %113 OpBranch %95 %97 = OpLabel OpBranch %85 %85 = OpLabel OpBranch %82 %84 = OpLabel OpStore %81 %9 OpBranch %114 %114 = OpLabel OpLoopMerge %116 %117 None OpBranch %118 %118 = OpLabel %119 = OpLoad %6 %81 %120 = OpConvertSToF %16 %119 %121 = OpAccessChain %23 %20 %22 %122 = OpLoad %16 %121 %123 = OpFOrdLessThan %26 %120 %122 OpBranchConditional %123 %115 %116 %115 = OpLabel %124 = OpLoad %6 %81 %125 = OpIAdd %6 %124 %41 OpStore %81 %125 %126 = OpAccessChain %23 %20 %69 %127 = OpLoad %16 %126 %128 = OpAccessChain %23 %20 %72 %129 = OpLoad %16 %128 %130 = OpFOrdEqual %26 %127 %129 OpSelectionMerge %132 None OpBranchConditional %130 %131 %132 %131 = OpLabel OpBranch %117 %132 = OpLabel OpStore %134 %9 OpBranch %135 %135 = OpLabel OpLoopMerge %137 %138 None OpBranch %139 %139 = OpLabel %140 = OpLoad %6 %134 %141 = OpSLessThan %26 %140 %41 OpBranchConditional %141 %136 %137 %136 = OpLabel OpStore %142 %9 OpBranch %143 %143 = OpLabel OpLoopMerge %145 %146 None OpBranch %147 %147 = OpLabel %148 = OpLoad %6 %142 %149 = OpSLessThan %26 %148 %41 OpBranchConditional %149 %144 %145 %144 = OpLabel OpBranch %146 %146 = OpLabel %150 = OpLoad %6 %142 %151 = OpIAdd %6 %150 %41 OpStore %142 %151 OpBranch %143 %145 = OpLabel %152 = OpAccessChain %23 %20 %69 %153 = OpLoad %16 %152 %154 = OpAccessChain %23 %20 %72 %155 = OpLoad %16 %154 %156 = OpFOrdEqual %26 %153 %155 OpSelectionMerge %158 None OpBranchConditional %156 %157 %158 %157 = OpLabel OpBranch %137 %158 = OpLabel OpBranch %138 %138 = OpLabel %160 = OpLoad %6 %134 %161 = OpIAdd %6 %160 %41 OpStore %134 %161 OpBranch %135 %137 = OpLabel OpBranch %117 %117 = OpLabel OpBranch %114 %116 = OpLabel OpStore %163 %165 OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 4); DominatorAnalysis* analysis = context->GetDominatorAnalysis(f); EXPECT_TRUE(analysis->Dominates(5, 10)); EXPECT_TRUE(analysis->Dominates(5, 46)); EXPECT_TRUE(analysis->Dominates(5, 82)); EXPECT_TRUE(analysis->Dominates(5, 114)); EXPECT_TRUE(analysis->Dominates(5, 116)); EXPECT_TRUE(analysis->Dominates(10, 14)); EXPECT_TRUE(analysis->Dominates(10, 11)); EXPECT_TRUE(analysis->Dominates(10, 29)); EXPECT_TRUE(analysis->Dominates(10, 33)); EXPECT_TRUE(analysis->Dominates(10, 30)); EXPECT_TRUE(analysis->Dominates(10, 32)); EXPECT_TRUE(analysis->Dominates(10, 31)); EXPECT_TRUE(analysis->Dominates(10, 13)); EXPECT_TRUE(analysis->Dominates(10, 12)); EXPECT_TRUE(analysis->Dominates(12, 46)); EXPECT_TRUE(analysis->Dominates(46, 50)); EXPECT_TRUE(analysis->Dominates(46, 47)); EXPECT_TRUE(analysis->Dominates(46, 57)); EXPECT_TRUE(analysis->Dominates(46, 61)); EXPECT_TRUE(analysis->Dominates(46, 58)); EXPECT_TRUE(analysis->Dominates(46, 60)); EXPECT_TRUE(analysis->Dominates(46, 59)); EXPECT_TRUE(analysis->Dominates(46, 77)); EXPECT_TRUE(analysis->Dominates(46, 49)); EXPECT_TRUE(analysis->Dominates(46, 76)); EXPECT_TRUE(analysis->Dominates(46, 48)); EXPECT_TRUE(analysis->Dominates(48, 82)); EXPECT_TRUE(analysis->Dominates(82, 86)); EXPECT_TRUE(analysis->Dominates(82, 83)); EXPECT_TRUE(analysis->Dominates(82, 95)); EXPECT_TRUE(analysis->Dominates(82, 99)); EXPECT_TRUE(analysis->Dominates(82, 96)); EXPECT_TRUE(analysis->Dominates(82, 103)); EXPECT_TRUE(analysis->Dominates(82, 107)); EXPECT_TRUE(analysis->Dominates(82, 104)); EXPECT_TRUE(analysis->Dominates(82, 106)); EXPECT_TRUE(analysis->Dominates(82, 105)); EXPECT_TRUE(analysis->Dominates(82, 98)); EXPECT_TRUE(analysis->Dominates(82, 97)); EXPECT_TRUE(analysis->Dominates(82, 85)); EXPECT_TRUE(analysis->Dominates(82, 84)); EXPECT_TRUE(analysis->Dominates(84, 114)); EXPECT_TRUE(analysis->Dominates(114, 118)); EXPECT_TRUE(analysis->Dominates(114, 116)); EXPECT_TRUE(analysis->Dominates(114, 115)); EXPECT_TRUE(analysis->Dominates(114, 132)); EXPECT_TRUE(analysis->Dominates(114, 135)); EXPECT_TRUE(analysis->Dominates(114, 139)); EXPECT_TRUE(analysis->Dominates(114, 136)); EXPECT_TRUE(analysis->Dominates(114, 143)); EXPECT_TRUE(analysis->Dominates(114, 147)); EXPECT_TRUE(analysis->Dominates(114, 144)); EXPECT_TRUE(analysis->Dominates(114, 146)); EXPECT_TRUE(analysis->Dominates(114, 145)); EXPECT_TRUE(analysis->Dominates(114, 158)); EXPECT_TRUE(analysis->Dominates(114, 138)); EXPECT_TRUE(analysis->Dominates(114, 137)); EXPECT_TRUE(analysis->Dominates(114, 131)); EXPECT_TRUE(analysis->Dominates(114, 117)); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/dominator_tree/nested_loops_with_unreachables.cpp000066400000000000000000000762041475742701700323070ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gmock/gmock.h" #include "source/opt/dominator_analysis.h" #include "source/opt/pass.h" #include "test/opt/assembly_builder.h" #include "test/opt/function_utils.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using ::testing::UnorderedElementsAre; using PassClassTest = PassTest<::testing::Test>; /* Generated from the following GLSL #version 440 core layout(location = 0) out vec4 v; layout(location = 1) in vec4 in_val; void main() { for (int i = 0; i < in_val.x; ++i) { for (int j = 0; j < in_val.y; j++) { } } for (int i = 0; i < in_val.x; ++i) { for (int j = 0; j < in_val.y; j++) { } break; } int i = 0; while (i < in_val.x) { ++i; for (int j = 0; j < 1; j++) { for (int k = 0; k < 1; k++) { } break; } } i = 0; while (i < in_val.x) { ++i; continue; for (int j = 0; j < 1; j++) { for (int k = 0; k < 1; k++) { } break; } } v = vec4(1,1,1,1); } */ TEST_F(PassClassTest, BasicVisitFromEntryPoint) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %20 %141 OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %20 "in_val" OpName %28 "j" OpName %45 "i" OpName %56 "j" OpName %72 "i" OpName %85 "j" OpName %93 "k" OpName %119 "j" OpName %127 "k" OpName %141 "v" OpDecorate %20 Location 1 OpDecorate %141 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpTypeFloat 32 %18 = OpTypeVector %16 4 %19 = OpTypePointer Input %18 %20 = OpVariable %19 Input %21 = OpTypeInt 32 0 %22 = OpConstant %21 0 %23 = OpTypePointer Input %16 %26 = OpTypeBool %36 = OpConstant %21 1 %41 = OpConstant %6 1 %140 = OpTypePointer Output %18 %141 = OpVariable %140 Output %142 = OpConstant %16 1 %143 = OpConstantComposite %18 %142 %142 %142 %142 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %28 = OpVariable %7 Function %45 = OpVariable %7 Function %56 = OpVariable %7 Function %72 = OpVariable %7 Function %85 = OpVariable %7 Function %93 = OpVariable %7 Function %119 = OpVariable %7 Function %127 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %15 = OpLoad %6 %8 %17 = OpConvertSToF %16 %15 %24 = OpAccessChain %23 %20 %22 %25 = OpLoad %16 %24 %27 = OpFOrdLessThan %26 %17 %25 OpBranchConditional %27 %11 %12 %11 = OpLabel OpStore %28 %9 OpBranch %29 %29 = OpLabel OpLoopMerge %31 %32 None OpBranch %33 %33 = OpLabel %34 = OpLoad %6 %28 %35 = OpConvertSToF %16 %34 %37 = OpAccessChain %23 %20 %36 %38 = OpLoad %16 %37 %39 = OpFOrdLessThan %26 %35 %38 OpBranchConditional %39 %30 %31 %30 = OpLabel OpBranch %32 %32 = OpLabel %40 = OpLoad %6 %28 %42 = OpIAdd %6 %40 %41 OpStore %28 %42 OpBranch %29 %31 = OpLabel OpBranch %13 %13 = OpLabel %43 = OpLoad %6 %8 %44 = OpIAdd %6 %43 %41 OpStore %8 %44 OpBranch %10 %12 = OpLabel OpStore %45 %9 OpBranch %46 %46 = OpLabel OpLoopMerge %48 %49 None OpBranch %50 %50 = OpLabel %51 = OpLoad %6 %45 %52 = OpConvertSToF %16 %51 %53 = OpAccessChain %23 %20 %22 %54 = OpLoad %16 %53 %55 = OpFOrdLessThan %26 %52 %54 OpBranchConditional %55 %47 %48 %47 = OpLabel OpStore %56 %9 OpBranch %57 %57 = OpLabel OpLoopMerge %59 %60 None OpBranch %61 %61 = OpLabel %62 = OpLoad %6 %56 %63 = OpConvertSToF %16 %62 %64 = OpAccessChain %23 %20 %36 %65 = OpLoad %16 %64 %66 = OpFOrdLessThan %26 %63 %65 OpBranchConditional %66 %58 %59 %58 = OpLabel OpBranch %60 %60 = OpLabel %67 = OpLoad %6 %56 %68 = OpIAdd %6 %67 %41 OpStore %56 %68 OpBranch %57 %59 = OpLabel OpBranch %48 %49 = OpLabel %70 = OpLoad %6 %45 %71 = OpIAdd %6 %70 %41 OpStore %45 %71 OpBranch %46 %48 = OpLabel OpStore %72 %9 OpBranch %73 %73 = OpLabel OpLoopMerge %75 %76 None OpBranch %77 %77 = OpLabel %78 = OpLoad %6 %72 %79 = OpConvertSToF %16 %78 %80 = OpAccessChain %23 %20 %22 %81 = OpLoad %16 %80 %82 = OpFOrdLessThan %26 %79 %81 OpBranchConditional %82 %74 %75 %74 = OpLabel %83 = OpLoad %6 %72 %84 = OpIAdd %6 %83 %41 OpStore %72 %84 OpStore %85 %9 OpBranch %86 %86 = OpLabel OpLoopMerge %88 %89 None OpBranch %90 %90 = OpLabel %91 = OpLoad %6 %85 %92 = OpSLessThan %26 %91 %41 OpBranchConditional %92 %87 %88 %87 = OpLabel OpStore %93 %9 OpBranch %94 %94 = OpLabel OpLoopMerge %96 %97 None OpBranch %98 %98 = OpLabel %99 = OpLoad %6 %93 %100 = OpSLessThan %26 %99 %41 OpBranchConditional %100 %95 %96 %95 = OpLabel OpBranch %97 %97 = OpLabel %101 = OpLoad %6 %93 %102 = OpIAdd %6 %101 %41 OpStore %93 %102 OpBranch %94 %96 = OpLabel OpBranch %88 %89 = OpLabel %104 = OpLoad %6 %85 %105 = OpIAdd %6 %104 %41 OpStore %85 %105 OpBranch %86 %88 = OpLabel OpBranch %76 %76 = OpLabel OpBranch %73 %75 = OpLabel OpStore %72 %9 OpBranch %106 %106 = OpLabel OpLoopMerge %108 %109 None OpBranch %110 %110 = OpLabel %111 = OpLoad %6 %72 %112 = OpConvertSToF %16 %111 %113 = OpAccessChain %23 %20 %22 %114 = OpLoad %16 %113 %115 = OpFOrdLessThan %26 %112 %114 OpBranchConditional %115 %107 %108 %107 = OpLabel %116 = OpLoad %6 %72 %117 = OpIAdd %6 %116 %41 OpStore %72 %117 OpBranch %109 %109 = OpLabel OpBranch %106 %108 = OpLabel OpStore %141 %143 OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 4); DominatorAnalysis* analysis = context->GetDominatorAnalysis(f); EXPECT_TRUE(analysis->Dominates(5, 10)); EXPECT_TRUE(analysis->Dominates(5, 14)); EXPECT_TRUE(analysis->Dominates(5, 11)); EXPECT_TRUE(analysis->Dominates(5, 29)); EXPECT_TRUE(analysis->Dominates(5, 33)); EXPECT_TRUE(analysis->Dominates(5, 30)); EXPECT_TRUE(analysis->Dominates(5, 32)); EXPECT_TRUE(analysis->Dominates(5, 31)); EXPECT_TRUE(analysis->Dominates(5, 13)); EXPECT_TRUE(analysis->Dominates(5, 12)); EXPECT_TRUE(analysis->Dominates(5, 46)); EXPECT_TRUE(analysis->Dominates(5, 50)); EXPECT_TRUE(analysis->Dominates(5, 47)); EXPECT_TRUE(analysis->Dominates(5, 57)); EXPECT_TRUE(analysis->Dominates(5, 61)); EXPECT_TRUE(analysis->Dominates(5, 59)); EXPECT_TRUE(analysis->Dominates(5, 58)); EXPECT_TRUE(analysis->Dominates(5, 60)); EXPECT_TRUE(analysis->Dominates(5, 48)); EXPECT_TRUE(analysis->Dominates(5, 73)); EXPECT_TRUE(analysis->Dominates(5, 77)); EXPECT_TRUE(analysis->Dominates(5, 75)); EXPECT_TRUE(analysis->Dominates(5, 106)); EXPECT_TRUE(analysis->Dominates(5, 110)); EXPECT_TRUE(analysis->Dominates(5, 107)); EXPECT_TRUE(analysis->Dominates(5, 108)); EXPECT_TRUE(analysis->Dominates(5, 109)); EXPECT_TRUE(analysis->Dominates(5, 74)); EXPECT_TRUE(analysis->Dominates(5, 86)); EXPECT_TRUE(analysis->Dominates(5, 90)); EXPECT_TRUE(analysis->Dominates(5, 87)); EXPECT_TRUE(analysis->Dominates(5, 94)); EXPECT_TRUE(analysis->Dominates(5, 98)); EXPECT_TRUE(analysis->Dominates(5, 95)); EXPECT_TRUE(analysis->Dominates(5, 97)); EXPECT_TRUE(analysis->Dominates(5, 96)); EXPECT_TRUE(analysis->Dominates(5, 88)); EXPECT_TRUE(analysis->Dominates(5, 76)); EXPECT_TRUE(analysis->Dominates(10, 14)); EXPECT_TRUE(analysis->Dominates(10, 11)); EXPECT_TRUE(analysis->Dominates(10, 29)); EXPECT_TRUE(analysis->Dominates(10, 33)); EXPECT_TRUE(analysis->Dominates(10, 30)); EXPECT_TRUE(analysis->Dominates(10, 32)); EXPECT_TRUE(analysis->Dominates(10, 31)); EXPECT_TRUE(analysis->Dominates(10, 13)); EXPECT_TRUE(analysis->Dominates(10, 12)); EXPECT_TRUE(analysis->Dominates(10, 46)); EXPECT_TRUE(analysis->Dominates(10, 50)); EXPECT_TRUE(analysis->Dominates(10, 47)); EXPECT_TRUE(analysis->Dominates(10, 57)); EXPECT_TRUE(analysis->Dominates(10, 61)); EXPECT_TRUE(analysis->Dominates(10, 59)); EXPECT_TRUE(analysis->Dominates(10, 58)); EXPECT_TRUE(analysis->Dominates(10, 60)); EXPECT_TRUE(analysis->Dominates(10, 48)); EXPECT_TRUE(analysis->Dominates(10, 73)); EXPECT_TRUE(analysis->Dominates(10, 77)); EXPECT_TRUE(analysis->Dominates(10, 75)); EXPECT_TRUE(analysis->Dominates(10, 106)); EXPECT_TRUE(analysis->Dominates(10, 110)); EXPECT_TRUE(analysis->Dominates(10, 107)); EXPECT_TRUE(analysis->Dominates(10, 108)); EXPECT_TRUE(analysis->Dominates(10, 109)); EXPECT_TRUE(analysis->Dominates(10, 74)); EXPECT_TRUE(analysis->Dominates(10, 86)); EXPECT_TRUE(analysis->Dominates(10, 90)); EXPECT_TRUE(analysis->Dominates(10, 87)); EXPECT_TRUE(analysis->Dominates(10, 94)); EXPECT_TRUE(analysis->Dominates(10, 98)); EXPECT_TRUE(analysis->Dominates(10, 95)); EXPECT_TRUE(analysis->Dominates(10, 97)); EXPECT_TRUE(analysis->Dominates(10, 96)); EXPECT_TRUE(analysis->Dominates(10, 88)); EXPECT_TRUE(analysis->Dominates(10, 76)); EXPECT_TRUE(analysis->Dominates(14, 11)); EXPECT_TRUE(analysis->Dominates(14, 29)); EXPECT_TRUE(analysis->Dominates(14, 33)); EXPECT_TRUE(analysis->Dominates(14, 30)); EXPECT_TRUE(analysis->Dominates(14, 32)); EXPECT_TRUE(analysis->Dominates(14, 31)); EXPECT_TRUE(analysis->Dominates(11, 29)); EXPECT_TRUE(analysis->Dominates(11, 33)); EXPECT_TRUE(analysis->Dominates(11, 30)); EXPECT_TRUE(analysis->Dominates(11, 32)); EXPECT_TRUE(analysis->Dominates(11, 31)); EXPECT_TRUE(analysis->Dominates(29, 33)); EXPECT_TRUE(analysis->Dominates(29, 30)); EXPECT_TRUE(analysis->Dominates(29, 32)); EXPECT_TRUE(analysis->Dominates(29, 31)); EXPECT_TRUE(analysis->Dominates(33, 30)); EXPECT_TRUE(analysis->Dominates(12, 46)); EXPECT_TRUE(analysis->Dominates(12, 50)); EXPECT_TRUE(analysis->Dominates(12, 47)); EXPECT_TRUE(analysis->Dominates(12, 57)); EXPECT_TRUE(analysis->Dominates(12, 61)); EXPECT_TRUE(analysis->Dominates(12, 59)); EXPECT_TRUE(analysis->Dominates(12, 58)); EXPECT_TRUE(analysis->Dominates(12, 60)); EXPECT_TRUE(analysis->Dominates(12, 48)); EXPECT_TRUE(analysis->Dominates(12, 73)); EXPECT_TRUE(analysis->Dominates(12, 77)); EXPECT_TRUE(analysis->Dominates(12, 75)); EXPECT_TRUE(analysis->Dominates(12, 106)); EXPECT_TRUE(analysis->Dominates(12, 110)); EXPECT_TRUE(analysis->Dominates(12, 107)); EXPECT_TRUE(analysis->Dominates(12, 108)); EXPECT_TRUE(analysis->Dominates(12, 109)); EXPECT_TRUE(analysis->Dominates(12, 74)); EXPECT_TRUE(analysis->Dominates(12, 86)); EXPECT_TRUE(analysis->Dominates(12, 90)); EXPECT_TRUE(analysis->Dominates(12, 87)); EXPECT_TRUE(analysis->Dominates(12, 94)); EXPECT_TRUE(analysis->Dominates(12, 98)); EXPECT_TRUE(analysis->Dominates(12, 95)); EXPECT_TRUE(analysis->Dominates(12, 97)); EXPECT_TRUE(analysis->Dominates(12, 96)); EXPECT_TRUE(analysis->Dominates(12, 88)); EXPECT_TRUE(analysis->Dominates(12, 76)); EXPECT_TRUE(analysis->Dominates(46, 50)); EXPECT_TRUE(analysis->Dominates(46, 47)); EXPECT_TRUE(analysis->Dominates(46, 57)); EXPECT_TRUE(analysis->Dominates(46, 61)); EXPECT_TRUE(analysis->Dominates(46, 59)); EXPECT_TRUE(analysis->Dominates(46, 58)); EXPECT_TRUE(analysis->Dominates(46, 60)); EXPECT_TRUE(analysis->Dominates(46, 48)); EXPECT_TRUE(analysis->Dominates(46, 73)); EXPECT_TRUE(analysis->Dominates(46, 77)); EXPECT_TRUE(analysis->Dominates(46, 75)); EXPECT_TRUE(analysis->Dominates(46, 106)); EXPECT_TRUE(analysis->Dominates(46, 110)); EXPECT_TRUE(analysis->Dominates(46, 107)); EXPECT_TRUE(analysis->Dominates(46, 108)); EXPECT_TRUE(analysis->Dominates(46, 109)); EXPECT_TRUE(analysis->Dominates(46, 74)); EXPECT_TRUE(analysis->Dominates(46, 86)); EXPECT_TRUE(analysis->Dominates(46, 90)); EXPECT_TRUE(analysis->Dominates(46, 87)); EXPECT_TRUE(analysis->Dominates(46, 94)); EXPECT_TRUE(analysis->Dominates(46, 98)); EXPECT_TRUE(analysis->Dominates(46, 95)); EXPECT_TRUE(analysis->Dominates(46, 97)); EXPECT_TRUE(analysis->Dominates(46, 96)); EXPECT_TRUE(analysis->Dominates(46, 88)); EXPECT_TRUE(analysis->Dominates(46, 76)); EXPECT_TRUE(analysis->Dominates(50, 47)); EXPECT_TRUE(analysis->Dominates(50, 57)); EXPECT_TRUE(analysis->Dominates(50, 61)); EXPECT_TRUE(analysis->Dominates(50, 59)); EXPECT_TRUE(analysis->Dominates(50, 58)); EXPECT_TRUE(analysis->Dominates(50, 60)); EXPECT_TRUE(analysis->Dominates(47, 57)); EXPECT_TRUE(analysis->Dominates(47, 61)); EXPECT_TRUE(analysis->Dominates(47, 59)); EXPECT_TRUE(analysis->Dominates(47, 58)); EXPECT_TRUE(analysis->Dominates(47, 60)); EXPECT_TRUE(analysis->Dominates(57, 61)); EXPECT_TRUE(analysis->Dominates(57, 59)); EXPECT_TRUE(analysis->Dominates(57, 58)); EXPECT_TRUE(analysis->Dominates(57, 60)); EXPECT_TRUE(analysis->Dominates(61, 59)); EXPECT_TRUE(analysis->Dominates(48, 73)); EXPECT_TRUE(analysis->Dominates(48, 77)); EXPECT_TRUE(analysis->Dominates(48, 75)); EXPECT_TRUE(analysis->Dominates(48, 106)); EXPECT_TRUE(analysis->Dominates(48, 110)); EXPECT_TRUE(analysis->Dominates(48, 107)); EXPECT_TRUE(analysis->Dominates(48, 108)); EXPECT_TRUE(analysis->Dominates(48, 109)); EXPECT_TRUE(analysis->Dominates(48, 74)); EXPECT_TRUE(analysis->Dominates(48, 86)); EXPECT_TRUE(analysis->Dominates(48, 90)); EXPECT_TRUE(analysis->Dominates(48, 87)); EXPECT_TRUE(analysis->Dominates(48, 94)); EXPECT_TRUE(analysis->Dominates(48, 98)); EXPECT_TRUE(analysis->Dominates(48, 95)); EXPECT_TRUE(analysis->Dominates(48, 97)); EXPECT_TRUE(analysis->Dominates(48, 96)); EXPECT_TRUE(analysis->Dominates(48, 88)); EXPECT_TRUE(analysis->Dominates(48, 76)); EXPECT_TRUE(analysis->Dominates(73, 77)); EXPECT_TRUE(analysis->Dominates(73, 75)); EXPECT_TRUE(analysis->Dominates(73, 106)); EXPECT_TRUE(analysis->Dominates(73, 110)); EXPECT_TRUE(analysis->Dominates(73, 107)); EXPECT_TRUE(analysis->Dominates(73, 108)); EXPECT_TRUE(analysis->Dominates(73, 109)); EXPECT_TRUE(analysis->Dominates(73, 74)); EXPECT_TRUE(analysis->Dominates(73, 86)); EXPECT_TRUE(analysis->Dominates(73, 90)); EXPECT_TRUE(analysis->Dominates(73, 87)); EXPECT_TRUE(analysis->Dominates(73, 94)); EXPECT_TRUE(analysis->Dominates(73, 98)); EXPECT_TRUE(analysis->Dominates(73, 95)); EXPECT_TRUE(analysis->Dominates(73, 97)); EXPECT_TRUE(analysis->Dominates(73, 96)); EXPECT_TRUE(analysis->Dominates(73, 88)); EXPECT_TRUE(analysis->Dominates(73, 76)); EXPECT_TRUE(analysis->Dominates(75, 106)); EXPECT_TRUE(analysis->Dominates(75, 110)); EXPECT_TRUE(analysis->Dominates(75, 107)); EXPECT_TRUE(analysis->Dominates(75, 108)); EXPECT_TRUE(analysis->Dominates(75, 109)); EXPECT_TRUE(analysis->Dominates(106, 110)); EXPECT_TRUE(analysis->Dominates(106, 107)); EXPECT_TRUE(analysis->Dominates(106, 108)); EXPECT_TRUE(analysis->Dominates(106, 109)); EXPECT_TRUE(analysis->Dominates(110, 107)); EXPECT_TRUE(analysis->Dominates(77, 74)); EXPECT_TRUE(analysis->Dominates(77, 86)); EXPECT_TRUE(analysis->Dominates(77, 90)); EXPECT_TRUE(analysis->Dominates(77, 87)); EXPECT_TRUE(analysis->Dominates(77, 94)); EXPECT_TRUE(analysis->Dominates(77, 98)); EXPECT_TRUE(analysis->Dominates(77, 95)); EXPECT_TRUE(analysis->Dominates(77, 97)); EXPECT_TRUE(analysis->Dominates(77, 96)); EXPECT_TRUE(analysis->Dominates(77, 88)); EXPECT_TRUE(analysis->Dominates(74, 86)); EXPECT_TRUE(analysis->Dominates(74, 90)); EXPECT_TRUE(analysis->Dominates(74, 87)); EXPECT_TRUE(analysis->Dominates(74, 94)); EXPECT_TRUE(analysis->Dominates(74, 98)); EXPECT_TRUE(analysis->Dominates(74, 95)); EXPECT_TRUE(analysis->Dominates(74, 97)); EXPECT_TRUE(analysis->Dominates(74, 96)); EXPECT_TRUE(analysis->Dominates(74, 88)); EXPECT_TRUE(analysis->Dominates(86, 90)); EXPECT_TRUE(analysis->Dominates(86, 87)); EXPECT_TRUE(analysis->Dominates(86, 94)); EXPECT_TRUE(analysis->Dominates(86, 98)); EXPECT_TRUE(analysis->Dominates(86, 95)); EXPECT_TRUE(analysis->Dominates(86, 97)); EXPECT_TRUE(analysis->Dominates(86, 96)); EXPECT_TRUE(analysis->Dominates(86, 88)); EXPECT_TRUE(analysis->Dominates(90, 87)); EXPECT_TRUE(analysis->Dominates(90, 94)); EXPECT_TRUE(analysis->Dominates(90, 98)); EXPECT_TRUE(analysis->Dominates(90, 95)); EXPECT_TRUE(analysis->Dominates(90, 97)); EXPECT_TRUE(analysis->Dominates(90, 96)); EXPECT_TRUE(analysis->Dominates(87, 94)); EXPECT_TRUE(analysis->Dominates(87, 98)); EXPECT_TRUE(analysis->Dominates(87, 95)); EXPECT_TRUE(analysis->Dominates(87, 97)); EXPECT_TRUE(analysis->Dominates(87, 96)); EXPECT_TRUE(analysis->Dominates(94, 98)); EXPECT_TRUE(analysis->Dominates(94, 95)); EXPECT_TRUE(analysis->Dominates(94, 97)); EXPECT_TRUE(analysis->Dominates(94, 96)); EXPECT_TRUE(analysis->Dominates(98, 95)); EXPECT_TRUE(analysis->StrictlyDominates(5, 10)); EXPECT_TRUE(analysis->StrictlyDominates(5, 14)); EXPECT_TRUE(analysis->StrictlyDominates(5, 11)); EXPECT_TRUE(analysis->StrictlyDominates(5, 29)); EXPECT_TRUE(analysis->StrictlyDominates(5, 33)); EXPECT_TRUE(analysis->StrictlyDominates(5, 30)); EXPECT_TRUE(analysis->StrictlyDominates(5, 32)); EXPECT_TRUE(analysis->StrictlyDominates(5, 31)); EXPECT_TRUE(analysis->StrictlyDominates(5, 13)); EXPECT_TRUE(analysis->StrictlyDominates(5, 12)); EXPECT_TRUE(analysis->StrictlyDominates(5, 46)); EXPECT_TRUE(analysis->StrictlyDominates(5, 50)); EXPECT_TRUE(analysis->StrictlyDominates(5, 47)); EXPECT_TRUE(analysis->StrictlyDominates(5, 57)); EXPECT_TRUE(analysis->StrictlyDominates(5, 61)); EXPECT_TRUE(analysis->StrictlyDominates(5, 59)); EXPECT_TRUE(analysis->StrictlyDominates(5, 58)); EXPECT_TRUE(analysis->StrictlyDominates(5, 60)); EXPECT_TRUE(analysis->StrictlyDominates(5, 48)); EXPECT_TRUE(analysis->StrictlyDominates(5, 73)); EXPECT_TRUE(analysis->StrictlyDominates(5, 77)); EXPECT_TRUE(analysis->StrictlyDominates(5, 75)); EXPECT_TRUE(analysis->StrictlyDominates(5, 106)); EXPECT_TRUE(analysis->StrictlyDominates(5, 110)); EXPECT_TRUE(analysis->StrictlyDominates(5, 107)); EXPECT_TRUE(analysis->StrictlyDominates(5, 108)); EXPECT_TRUE(analysis->StrictlyDominates(5, 109)); EXPECT_TRUE(analysis->StrictlyDominates(5, 74)); EXPECT_TRUE(analysis->StrictlyDominates(5, 86)); EXPECT_TRUE(analysis->StrictlyDominates(5, 90)); EXPECT_TRUE(analysis->StrictlyDominates(5, 87)); EXPECT_TRUE(analysis->StrictlyDominates(5, 94)); EXPECT_TRUE(analysis->StrictlyDominates(5, 98)); EXPECT_TRUE(analysis->StrictlyDominates(5, 95)); EXPECT_TRUE(analysis->StrictlyDominates(5, 97)); EXPECT_TRUE(analysis->StrictlyDominates(5, 96)); EXPECT_TRUE(analysis->StrictlyDominates(5, 88)); EXPECT_TRUE(analysis->StrictlyDominates(5, 76)); EXPECT_TRUE(analysis->StrictlyDominates(10, 14)); EXPECT_TRUE(analysis->StrictlyDominates(10, 11)); EXPECT_TRUE(analysis->StrictlyDominates(10, 29)); EXPECT_TRUE(analysis->StrictlyDominates(10, 33)); EXPECT_TRUE(analysis->StrictlyDominates(10, 30)); EXPECT_TRUE(analysis->StrictlyDominates(10, 32)); EXPECT_TRUE(analysis->StrictlyDominates(10, 31)); EXPECT_TRUE(analysis->StrictlyDominates(10, 13)); EXPECT_TRUE(analysis->StrictlyDominates(10, 12)); EXPECT_TRUE(analysis->StrictlyDominates(10, 46)); EXPECT_TRUE(analysis->StrictlyDominates(10, 50)); EXPECT_TRUE(analysis->StrictlyDominates(10, 47)); EXPECT_TRUE(analysis->StrictlyDominates(10, 57)); EXPECT_TRUE(analysis->StrictlyDominates(10, 61)); EXPECT_TRUE(analysis->StrictlyDominates(10, 59)); EXPECT_TRUE(analysis->StrictlyDominates(10, 58)); EXPECT_TRUE(analysis->StrictlyDominates(10, 60)); EXPECT_TRUE(analysis->StrictlyDominates(10, 48)); EXPECT_TRUE(analysis->StrictlyDominates(10, 73)); EXPECT_TRUE(analysis->StrictlyDominates(10, 77)); EXPECT_TRUE(analysis->StrictlyDominates(10, 75)); EXPECT_TRUE(analysis->StrictlyDominates(10, 106)); EXPECT_TRUE(analysis->StrictlyDominates(10, 110)); EXPECT_TRUE(analysis->StrictlyDominates(10, 107)); EXPECT_TRUE(analysis->StrictlyDominates(10, 108)); EXPECT_TRUE(analysis->StrictlyDominates(10, 109)); EXPECT_TRUE(analysis->StrictlyDominates(10, 74)); EXPECT_TRUE(analysis->StrictlyDominates(10, 86)); EXPECT_TRUE(analysis->StrictlyDominates(10, 90)); EXPECT_TRUE(analysis->StrictlyDominates(10, 87)); EXPECT_TRUE(analysis->StrictlyDominates(10, 94)); EXPECT_TRUE(analysis->StrictlyDominates(10, 98)); EXPECT_TRUE(analysis->StrictlyDominates(10, 95)); EXPECT_TRUE(analysis->StrictlyDominates(10, 97)); EXPECT_TRUE(analysis->StrictlyDominates(10, 96)); EXPECT_TRUE(analysis->StrictlyDominates(10, 88)); EXPECT_TRUE(analysis->StrictlyDominates(10, 76)); EXPECT_TRUE(analysis->StrictlyDominates(14, 11)); EXPECT_TRUE(analysis->StrictlyDominates(14, 29)); EXPECT_TRUE(analysis->StrictlyDominates(14, 33)); EXPECT_TRUE(analysis->StrictlyDominates(14, 30)); EXPECT_TRUE(analysis->StrictlyDominates(14, 32)); EXPECT_TRUE(analysis->StrictlyDominates(14, 31)); EXPECT_TRUE(analysis->StrictlyDominates(11, 29)); EXPECT_TRUE(analysis->StrictlyDominates(11, 33)); EXPECT_TRUE(analysis->StrictlyDominates(11, 30)); EXPECT_TRUE(analysis->StrictlyDominates(11, 32)); EXPECT_TRUE(analysis->StrictlyDominates(11, 31)); EXPECT_TRUE(analysis->StrictlyDominates(29, 33)); EXPECT_TRUE(analysis->StrictlyDominates(29, 30)); EXPECT_TRUE(analysis->StrictlyDominates(29, 32)); EXPECT_TRUE(analysis->StrictlyDominates(29, 31)); EXPECT_TRUE(analysis->StrictlyDominates(33, 30)); EXPECT_TRUE(analysis->StrictlyDominates(12, 46)); EXPECT_TRUE(analysis->StrictlyDominates(12, 50)); EXPECT_TRUE(analysis->StrictlyDominates(12, 47)); EXPECT_TRUE(analysis->StrictlyDominates(12, 57)); EXPECT_TRUE(analysis->StrictlyDominates(12, 61)); EXPECT_TRUE(analysis->StrictlyDominates(12, 59)); EXPECT_TRUE(analysis->StrictlyDominates(12, 58)); EXPECT_TRUE(analysis->StrictlyDominates(12, 60)); EXPECT_TRUE(analysis->StrictlyDominates(12, 48)); EXPECT_TRUE(analysis->StrictlyDominates(12, 73)); EXPECT_TRUE(analysis->StrictlyDominates(12, 77)); EXPECT_TRUE(analysis->StrictlyDominates(12, 75)); EXPECT_TRUE(analysis->StrictlyDominates(12, 106)); EXPECT_TRUE(analysis->StrictlyDominates(12, 110)); EXPECT_TRUE(analysis->StrictlyDominates(12, 107)); EXPECT_TRUE(analysis->StrictlyDominates(12, 108)); EXPECT_TRUE(analysis->StrictlyDominates(12, 109)); EXPECT_TRUE(analysis->StrictlyDominates(12, 74)); EXPECT_TRUE(analysis->StrictlyDominates(12, 86)); EXPECT_TRUE(analysis->StrictlyDominates(12, 90)); EXPECT_TRUE(analysis->StrictlyDominates(12, 87)); EXPECT_TRUE(analysis->StrictlyDominates(12, 94)); EXPECT_TRUE(analysis->StrictlyDominates(12, 98)); EXPECT_TRUE(analysis->StrictlyDominates(12, 95)); EXPECT_TRUE(analysis->StrictlyDominates(12, 97)); EXPECT_TRUE(analysis->StrictlyDominates(12, 96)); EXPECT_TRUE(analysis->StrictlyDominates(12, 88)); EXPECT_TRUE(analysis->StrictlyDominates(12, 76)); EXPECT_TRUE(analysis->StrictlyDominates(46, 50)); EXPECT_TRUE(analysis->StrictlyDominates(46, 47)); EXPECT_TRUE(analysis->StrictlyDominates(46, 57)); EXPECT_TRUE(analysis->StrictlyDominates(46, 61)); EXPECT_TRUE(analysis->StrictlyDominates(46, 59)); EXPECT_TRUE(analysis->StrictlyDominates(46, 58)); EXPECT_TRUE(analysis->StrictlyDominates(46, 60)); EXPECT_TRUE(analysis->StrictlyDominates(46, 48)); EXPECT_TRUE(analysis->StrictlyDominates(46, 73)); EXPECT_TRUE(analysis->StrictlyDominates(46, 77)); EXPECT_TRUE(analysis->StrictlyDominates(46, 75)); EXPECT_TRUE(analysis->StrictlyDominates(46, 106)); EXPECT_TRUE(analysis->StrictlyDominates(46, 110)); EXPECT_TRUE(analysis->StrictlyDominates(46, 107)); EXPECT_TRUE(analysis->StrictlyDominates(46, 108)); EXPECT_TRUE(analysis->StrictlyDominates(46, 109)); EXPECT_TRUE(analysis->StrictlyDominates(46, 74)); EXPECT_TRUE(analysis->StrictlyDominates(46, 86)); EXPECT_TRUE(analysis->StrictlyDominates(46, 90)); EXPECT_TRUE(analysis->StrictlyDominates(46, 87)); EXPECT_TRUE(analysis->StrictlyDominates(46, 94)); EXPECT_TRUE(analysis->StrictlyDominates(46, 98)); EXPECT_TRUE(analysis->StrictlyDominates(46, 95)); EXPECT_TRUE(analysis->StrictlyDominates(46, 97)); EXPECT_TRUE(analysis->StrictlyDominates(46, 96)); EXPECT_TRUE(analysis->StrictlyDominates(46, 88)); EXPECT_TRUE(analysis->StrictlyDominates(46, 76)); EXPECT_TRUE(analysis->StrictlyDominates(50, 47)); EXPECT_TRUE(analysis->StrictlyDominates(50, 57)); EXPECT_TRUE(analysis->StrictlyDominates(50, 61)); EXPECT_TRUE(analysis->StrictlyDominates(50, 59)); EXPECT_TRUE(analysis->StrictlyDominates(50, 58)); EXPECT_TRUE(analysis->StrictlyDominates(50, 60)); EXPECT_TRUE(analysis->StrictlyDominates(47, 57)); EXPECT_TRUE(analysis->StrictlyDominates(47, 61)); EXPECT_TRUE(analysis->StrictlyDominates(47, 59)); EXPECT_TRUE(analysis->StrictlyDominates(47, 58)); EXPECT_TRUE(analysis->StrictlyDominates(47, 60)); EXPECT_TRUE(analysis->StrictlyDominates(57, 61)); EXPECT_TRUE(analysis->StrictlyDominates(57, 59)); EXPECT_TRUE(analysis->StrictlyDominates(57, 58)); EXPECT_TRUE(analysis->StrictlyDominates(57, 60)); EXPECT_TRUE(analysis->StrictlyDominates(61, 59)); EXPECT_TRUE(analysis->StrictlyDominates(48, 73)); EXPECT_TRUE(analysis->StrictlyDominates(48, 77)); EXPECT_TRUE(analysis->StrictlyDominates(48, 75)); EXPECT_TRUE(analysis->StrictlyDominates(48, 106)); EXPECT_TRUE(analysis->StrictlyDominates(48, 110)); EXPECT_TRUE(analysis->StrictlyDominates(48, 107)); EXPECT_TRUE(analysis->StrictlyDominates(48, 108)); EXPECT_TRUE(analysis->StrictlyDominates(48, 109)); EXPECT_TRUE(analysis->StrictlyDominates(48, 74)); EXPECT_TRUE(analysis->StrictlyDominates(48, 86)); EXPECT_TRUE(analysis->StrictlyDominates(48, 90)); EXPECT_TRUE(analysis->StrictlyDominates(48, 87)); EXPECT_TRUE(analysis->StrictlyDominates(48, 94)); EXPECT_TRUE(analysis->StrictlyDominates(48, 98)); EXPECT_TRUE(analysis->StrictlyDominates(48, 95)); EXPECT_TRUE(analysis->StrictlyDominates(48, 97)); EXPECT_TRUE(analysis->StrictlyDominates(48, 96)); EXPECT_TRUE(analysis->StrictlyDominates(48, 88)); EXPECT_TRUE(analysis->StrictlyDominates(48, 76)); EXPECT_TRUE(analysis->StrictlyDominates(73, 77)); EXPECT_TRUE(analysis->StrictlyDominates(73, 75)); EXPECT_TRUE(analysis->StrictlyDominates(73, 106)); EXPECT_TRUE(analysis->StrictlyDominates(73, 110)); EXPECT_TRUE(analysis->StrictlyDominates(73, 107)); EXPECT_TRUE(analysis->StrictlyDominates(73, 108)); EXPECT_TRUE(analysis->StrictlyDominates(73, 109)); EXPECT_TRUE(analysis->StrictlyDominates(73, 74)); EXPECT_TRUE(analysis->StrictlyDominates(73, 86)); EXPECT_TRUE(analysis->StrictlyDominates(73, 90)); EXPECT_TRUE(analysis->StrictlyDominates(73, 87)); EXPECT_TRUE(analysis->StrictlyDominates(73, 94)); EXPECT_TRUE(analysis->StrictlyDominates(73, 98)); EXPECT_TRUE(analysis->StrictlyDominates(73, 95)); EXPECT_TRUE(analysis->StrictlyDominates(73, 97)); EXPECT_TRUE(analysis->StrictlyDominates(73, 96)); EXPECT_TRUE(analysis->StrictlyDominates(73, 88)); EXPECT_TRUE(analysis->StrictlyDominates(73, 76)); EXPECT_TRUE(analysis->StrictlyDominates(75, 106)); EXPECT_TRUE(analysis->StrictlyDominates(75, 110)); EXPECT_TRUE(analysis->StrictlyDominates(75, 107)); EXPECT_TRUE(analysis->StrictlyDominates(75, 108)); EXPECT_TRUE(analysis->StrictlyDominates(75, 109)); EXPECT_TRUE(analysis->StrictlyDominates(106, 110)); EXPECT_TRUE(analysis->StrictlyDominates(106, 107)); EXPECT_TRUE(analysis->StrictlyDominates(106, 108)); EXPECT_TRUE(analysis->StrictlyDominates(106, 109)); EXPECT_TRUE(analysis->StrictlyDominates(110, 107)); EXPECT_TRUE(analysis->StrictlyDominates(77, 74)); EXPECT_TRUE(analysis->StrictlyDominates(77, 86)); EXPECT_TRUE(analysis->StrictlyDominates(77, 90)); EXPECT_TRUE(analysis->StrictlyDominates(77, 87)); EXPECT_TRUE(analysis->StrictlyDominates(77, 94)); EXPECT_TRUE(analysis->StrictlyDominates(77, 98)); EXPECT_TRUE(analysis->StrictlyDominates(77, 95)); EXPECT_TRUE(analysis->StrictlyDominates(77, 97)); EXPECT_TRUE(analysis->StrictlyDominates(77, 96)); EXPECT_TRUE(analysis->StrictlyDominates(77, 88)); EXPECT_TRUE(analysis->StrictlyDominates(74, 86)); EXPECT_TRUE(analysis->StrictlyDominates(74, 90)); EXPECT_TRUE(analysis->StrictlyDominates(74, 87)); EXPECT_TRUE(analysis->StrictlyDominates(74, 94)); EXPECT_TRUE(analysis->StrictlyDominates(74, 98)); EXPECT_TRUE(analysis->StrictlyDominates(74, 95)); EXPECT_TRUE(analysis->StrictlyDominates(74, 97)); EXPECT_TRUE(analysis->StrictlyDominates(74, 96)); EXPECT_TRUE(analysis->StrictlyDominates(74, 88)); EXPECT_TRUE(analysis->StrictlyDominates(86, 90)); EXPECT_TRUE(analysis->StrictlyDominates(86, 87)); EXPECT_TRUE(analysis->StrictlyDominates(86, 94)); EXPECT_TRUE(analysis->StrictlyDominates(86, 98)); EXPECT_TRUE(analysis->StrictlyDominates(86, 95)); EXPECT_TRUE(analysis->StrictlyDominates(86, 97)); EXPECT_TRUE(analysis->StrictlyDominates(86, 96)); EXPECT_TRUE(analysis->StrictlyDominates(86, 88)); EXPECT_TRUE(analysis->StrictlyDominates(90, 87)); EXPECT_TRUE(analysis->StrictlyDominates(90, 94)); EXPECT_TRUE(analysis->StrictlyDominates(90, 98)); EXPECT_TRUE(analysis->StrictlyDominates(90, 95)); EXPECT_TRUE(analysis->StrictlyDominates(90, 97)); EXPECT_TRUE(analysis->StrictlyDominates(90, 96)); EXPECT_TRUE(analysis->StrictlyDominates(87, 94)); EXPECT_TRUE(analysis->StrictlyDominates(87, 98)); EXPECT_TRUE(analysis->StrictlyDominates(87, 95)); EXPECT_TRUE(analysis->StrictlyDominates(87, 97)); EXPECT_TRUE(analysis->StrictlyDominates(87, 96)); EXPECT_TRUE(analysis->StrictlyDominates(94, 98)); EXPECT_TRUE(analysis->StrictlyDominates(94, 95)); EXPECT_TRUE(analysis->StrictlyDominates(94, 97)); EXPECT_TRUE(analysis->StrictlyDominates(94, 96)); EXPECT_TRUE(analysis->StrictlyDominates(98, 95)); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/dominator_tree/pch_test_opt_dom.cpp000066400000000000000000000011721475742701700273640ustar00rootroot00000000000000// Copyright (c) 2018 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "pch_test_opt_dom.h" KhronosGroup-SPIRV-Tools-f289d04/test/opt/dominator_tree/pch_test_opt_dom.h000066400000000000000000000017411475742701700270330ustar00rootroot00000000000000// Copyright (c) 2018 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "gmock/gmock.h" #include "source/opt/iterator.h" #include "source/opt/loop_dependence.h" #include "source/opt/loop_descriptor.h" #include "source/opt/pass.h" #include "source/opt/scalar_analysis.h" #include "source/opt/tree_iterator.h" #include "test/opt/assembly_builder.h" #include "test/opt/function_utils.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" KhronosGroup-SPIRV-Tools-f289d04/test/opt/dominator_tree/post.cpp000066400000000000000000000154601475742701700250240ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gmock/gmock.h" #include "source/opt/dominator_analysis.h" #include "source/opt/pass.h" #include "test/opt/assembly_builder.h" #include "test/opt/function_utils.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using ::testing::UnorderedElementsAre; using PassClassTest = PassTest<::testing::Test>; /* Generated from the following GLSL #version 440 core layout(location = 0) out vec4 c; layout(location = 1)in vec4 in_val; void main(){ if ( in_val.x < 10) { int z = 0; int i = 0; for (i = 0; i < in_val.y; ++i) { z += i; } c = vec4(i,i,i,i); } else { c = vec4(1,1,1,1); } } */ TEST_F(PassClassTest, BasicVisitFromEntryPoint) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %9 %43 OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %9 "in_val" OpName %22 "z" OpName %24 "i" OpName %43 "c" OpDecorate %9 Location 1 OpDecorate %43 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypePointer Input %7 %9 = OpVariable %8 Input %10 = OpTypeInt 32 0 %11 = OpConstant %10 0 %12 = OpTypePointer Input %6 %15 = OpConstant %6 10 %16 = OpTypeBool %20 = OpTypeInt 32 1 %21 = OpTypePointer Function %20 %23 = OpConstant %20 0 %32 = OpConstant %10 1 %40 = OpConstant %20 1 %42 = OpTypePointer Output %7 %43 = OpVariable %42 Output %54 = OpConstant %6 1 %55 = OpConstantComposite %7 %54 %54 %54 %54 %4 = OpFunction %2 None %3 %5 = OpLabel %22 = OpVariable %21 Function %24 = OpVariable %21 Function %13 = OpAccessChain %12 %9 %11 %14 = OpLoad %6 %13 %17 = OpFOrdLessThan %16 %14 %15 OpSelectionMerge %19 None OpBranchConditional %17 %18 %53 %18 = OpLabel OpStore %22 %23 OpStore %24 %23 OpStore %24 %23 OpBranch %25 %25 = OpLabel OpLoopMerge %27 %28 None OpBranch %29 %29 = OpLabel %30 = OpLoad %20 %24 %31 = OpConvertSToF %6 %30 %33 = OpAccessChain %12 %9 %32 %34 = OpLoad %6 %33 %35 = OpFOrdLessThan %16 %31 %34 OpBranchConditional %35 %26 %27 %26 = OpLabel %36 = OpLoad %20 %24 %37 = OpLoad %20 %22 %38 = OpIAdd %20 %37 %36 OpStore %22 %38 OpBranch %28 %28 = OpLabel %39 = OpLoad %20 %24 %41 = OpIAdd %20 %39 %40 OpStore %24 %41 OpBranch %25 %27 = OpLabel %44 = OpLoad %20 %24 %45 = OpConvertSToF %6 %44 %46 = OpLoad %20 %24 %47 = OpConvertSToF %6 %46 %48 = OpLoad %20 %24 %49 = OpConvertSToF %6 %48 %50 = OpLoad %20 %24 %51 = OpConvertSToF %6 %50 %52 = OpCompositeConstruct %7 %45 %47 %49 %51 OpStore %43 %52 OpBranch %19 %53 = OpLabel OpStore %43 %55 OpBranch %19 %19 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 4); CFG cfg(module); PostDominatorAnalysis* analysis = context->GetPostDominatorAnalysis(f); EXPECT_TRUE(analysis->Dominates(19, 18)); EXPECT_TRUE(analysis->Dominates(19, 5)); EXPECT_TRUE(analysis->Dominates(19, 53)); EXPECT_TRUE(analysis->Dominates(19, 19)); EXPECT_TRUE(analysis->Dominates(19, 25)); EXPECT_TRUE(analysis->Dominates(19, 29)); EXPECT_TRUE(analysis->Dominates(19, 27)); EXPECT_TRUE(analysis->Dominates(19, 26)); EXPECT_TRUE(analysis->Dominates(19, 28)); EXPECT_TRUE(analysis->Dominates(27, 18)); EXPECT_TRUE(analysis->Dominates(27, 25)); EXPECT_TRUE(analysis->Dominates(27, 29)); EXPECT_TRUE(analysis->Dominates(27, 27)); EXPECT_TRUE(analysis->Dominates(27, 26)); EXPECT_TRUE(analysis->Dominates(27, 28)); EXPECT_FALSE(analysis->Dominates(27, 19)); EXPECT_FALSE(analysis->Dominates(27, 5)); EXPECT_FALSE(analysis->Dominates(27, 53)); EXPECT_FALSE(analysis->StrictlyDominates(19, 19)); EXPECT_TRUE(analysis->StrictlyDominates(19, 18)); EXPECT_TRUE(analysis->StrictlyDominates(19, 5)); EXPECT_TRUE(analysis->StrictlyDominates(19, 53)); EXPECT_TRUE(analysis->StrictlyDominates(19, 25)); EXPECT_TRUE(analysis->StrictlyDominates(19, 29)); EXPECT_TRUE(analysis->StrictlyDominates(19, 27)); EXPECT_TRUE(analysis->StrictlyDominates(19, 26)); EXPECT_TRUE(analysis->StrictlyDominates(19, 28)); // These would be expected true for a normal, non post, dominator tree EXPECT_FALSE(analysis->Dominates(5, 18)); EXPECT_FALSE(analysis->Dominates(5, 53)); EXPECT_FALSE(analysis->Dominates(5, 19)); EXPECT_FALSE(analysis->Dominates(5, 25)); EXPECT_FALSE(analysis->Dominates(5, 29)); EXPECT_FALSE(analysis->Dominates(5, 27)); EXPECT_FALSE(analysis->Dominates(5, 26)); EXPECT_FALSE(analysis->Dominates(5, 28)); EXPECT_FALSE(analysis->StrictlyDominates(5, 18)); EXPECT_FALSE(analysis->StrictlyDominates(5, 53)); EXPECT_FALSE(analysis->StrictlyDominates(5, 19)); EXPECT_FALSE(analysis->StrictlyDominates(5, 25)); EXPECT_FALSE(analysis->StrictlyDominates(5, 29)); EXPECT_FALSE(analysis->StrictlyDominates(5, 27)); EXPECT_FALSE(analysis->StrictlyDominates(5, 26)); EXPECT_FALSE(analysis->StrictlyDominates(5, 28)); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/dominator_tree/simple.cpp000066400000000000000000000131311475742701700253210ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gmock/gmock.h" #include "source/opt/dominator_analysis.h" #include "source/opt/pass.h" #include "test/opt/assembly_builder.h" #include "test/opt/function_utils.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using ::testing::UnorderedElementsAre; using PassClassTest = PassTest<::testing::Test>; /* Generated from the following GLSL #version 440 core layout(location = 0) out vec4 c; layout(location = 1)in vec4 in_val; void main(){ if ( in_val.x < 10) { int z = 0; int i = 0; for (i = 0; i < in_val.y; ++i) { z += i; } c = vec4(i,i,i,i); } else { c = vec4(1,1,1,1); } } */ TEST_F(PassClassTest, BasicVisitFromEntryPoint) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %9 %43 OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %9 "in_val" OpName %22 "z" OpName %24 "i" OpName %43 "c" OpDecorate %9 Location 1 OpDecorate %43 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypePointer Input %7 %9 = OpVariable %8 Input %10 = OpTypeInt 32 0 %11 = OpConstant %10 0 %12 = OpTypePointer Input %6 %15 = OpConstant %6 10 %16 = OpTypeBool %20 = OpTypeInt 32 1 %21 = OpTypePointer Function %20 %23 = OpConstant %20 0 %32 = OpConstant %10 1 %40 = OpConstant %20 1 %42 = OpTypePointer Output %7 %43 = OpVariable %42 Output %54 = OpConstant %6 1 %55 = OpConstantComposite %7 %54 %54 %54 %54 %4 = OpFunction %2 None %3 %5 = OpLabel %22 = OpVariable %21 Function %24 = OpVariable %21 Function %13 = OpAccessChain %12 %9 %11 %14 = OpLoad %6 %13 %17 = OpFOrdLessThan %16 %14 %15 OpSelectionMerge %19 None OpBranchConditional %17 %18 %53 %18 = OpLabel OpStore %22 %23 OpStore %24 %23 OpStore %24 %23 OpBranch %25 %25 = OpLabel OpLoopMerge %27 %28 None OpBranch %29 %29 = OpLabel %30 = OpLoad %20 %24 %31 = OpConvertSToF %6 %30 %33 = OpAccessChain %12 %9 %32 %34 = OpLoad %6 %33 %35 = OpFOrdLessThan %16 %31 %34 OpBranchConditional %35 %26 %27 %26 = OpLabel %36 = OpLoad %20 %24 %37 = OpLoad %20 %22 %38 = OpIAdd %20 %37 %36 OpStore %22 %38 OpBranch %28 %28 = OpLabel %39 = OpLoad %20 %24 %41 = OpIAdd %20 %39 %40 OpStore %24 %41 OpBranch %25 %27 = OpLabel %44 = OpLoad %20 %24 %45 = OpConvertSToF %6 %44 %46 = OpLoad %20 %24 %47 = OpConvertSToF %6 %46 %48 = OpLoad %20 %24 %49 = OpConvertSToF %6 %48 %50 = OpLoad %20 %24 %51 = OpConvertSToF %6 %50 %52 = OpCompositeConstruct %7 %45 %47 %49 %51 OpStore %43 %52 OpBranch %19 %53 = OpLabel OpStore %43 %55 OpBranch %19 %19 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 4); DominatorAnalysis* analysis = context->GetDominatorAnalysis(f); const CFG& cfg = *context->cfg(); DominatorTree& tree = analysis->GetDomTree(); EXPECT_EQ(tree.GetRoot()->bb_, cfg.pseudo_entry_block()); EXPECT_TRUE(analysis->Dominates(5, 18)); EXPECT_TRUE(analysis->Dominates(5, 53)); EXPECT_TRUE(analysis->Dominates(5, 19)); EXPECT_TRUE(analysis->Dominates(5, 25)); EXPECT_TRUE(analysis->Dominates(5, 29)); EXPECT_TRUE(analysis->Dominates(5, 27)); EXPECT_TRUE(analysis->Dominates(5, 26)); EXPECT_TRUE(analysis->Dominates(5, 28)); EXPECT_TRUE(analysis->StrictlyDominates(5, 18)); EXPECT_TRUE(analysis->StrictlyDominates(5, 53)); EXPECT_TRUE(analysis->StrictlyDominates(5, 19)); EXPECT_TRUE(analysis->StrictlyDominates(5, 25)); EXPECT_TRUE(analysis->StrictlyDominates(5, 29)); EXPECT_TRUE(analysis->StrictlyDominates(5, 27)); EXPECT_TRUE(analysis->StrictlyDominates(5, 26)); EXPECT_TRUE(analysis->StrictlyDominates(5, 28)); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/dominator_tree/switch_case_fallthrough.cpp000066400000000000000000000107501475742701700307270ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gmock/gmock.h" #include "source/opt/dominator_analysis.h" #include "source/opt/pass.h" #include "test/opt/assembly_builder.h" #include "test/opt/function_utils.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using ::testing::UnorderedElementsAre; using PassClassTest = PassTest<::testing::Test>; /* Generated from the following GLSL #version 440 core layout(location = 0) out vec4 v; layout(location = 1) in vec4 in_val; void main() { int i; switch (int(in_val.x)) { case 0: i = 0; case 1: i = 1; break; case 2: i = 2; case 3: i = 3; case 4: i = 4; break; default: i = 0; } v = vec4(i, i, i, i); } */ TEST_F(PassClassTest, UnreachableNestedIfs) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %9 %35 OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %9 "in_val" OpName %25 "i" OpName %35 "v" OpDecorate %9 Location 1 OpDecorate %35 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypePointer Input %7 %9 = OpVariable %8 Input %10 = OpTypeInt 32 0 %11 = OpConstant %10 0 %12 = OpTypePointer Input %6 %15 = OpTypeInt 32 1 %24 = OpTypePointer Function %15 %26 = OpConstant %15 0 %27 = OpConstant %15 1 %29 = OpConstant %15 2 %30 = OpConstant %15 3 %31 = OpConstant %15 4 %34 = OpTypePointer Output %7 %35 = OpVariable %34 Output %4 = OpFunction %2 None %3 %5 = OpLabel %25 = OpVariable %24 Function %13 = OpAccessChain %12 %9 %11 %14 = OpLoad %6 %13 %16 = OpConvertFToS %15 %14 OpSelectionMerge %23 None OpSwitch %16 %22 0 %17 1 %18 2 %19 3 %20 4 %21 %22 = OpLabel OpStore %25 %26 OpBranch %23 %17 = OpLabel OpStore %25 %26 OpBranch %18 %18 = OpLabel OpStore %25 %27 OpBranch %23 %19 = OpLabel OpStore %25 %29 OpBranch %20 %20 = OpLabel OpStore %25 %30 OpBranch %21 %21 = OpLabel OpStore %25 %31 OpBranch %23 %23 = OpLabel %36 = OpLoad %15 %25 %37 = OpConvertSToF %6 %36 %38 = OpLoad %15 %25 %39 = OpConvertSToF %6 %38 %40 = OpLoad %15 %25 %41 = OpConvertSToF %6 %40 %42 = OpLoad %15 %25 %43 = OpConvertSToF %6 %42 %44 = OpCompositeConstruct %7 %37 %39 %41 %43 OpStore %35 %44 OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 4); DominatorAnalysis* analysis = context->GetDominatorAnalysis(f); EXPECT_TRUE(analysis->Dominates(5, 5)); EXPECT_TRUE(analysis->Dominates(5, 17)); EXPECT_TRUE(analysis->Dominates(5, 18)); EXPECT_TRUE(analysis->Dominates(5, 19)); EXPECT_TRUE(analysis->Dominates(5, 20)); EXPECT_TRUE(analysis->Dominates(5, 21)); EXPECT_TRUE(analysis->Dominates(5, 22)); EXPECT_TRUE(analysis->Dominates(5, 23)); EXPECT_TRUE(analysis->StrictlyDominates(5, 17)); EXPECT_TRUE(analysis->StrictlyDominates(5, 18)); EXPECT_TRUE(analysis->StrictlyDominates(5, 19)); EXPECT_TRUE(analysis->StrictlyDominates(5, 20)); EXPECT_TRUE(analysis->StrictlyDominates(5, 21)); EXPECT_TRUE(analysis->StrictlyDominates(5, 22)); EXPECT_TRUE(analysis->StrictlyDominates(5, 23)); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/dominator_tree/unreachable_for.cpp000066400000000000000000000072761475742701700271640ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gmock/gmock.h" #include "source/opt/dominator_analysis.h" #include "source/opt/pass.h" #include "test/opt/assembly_builder.h" #include "test/opt/function_utils.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using ::testing::UnorderedElementsAre; using PassClassTest = PassTest<::testing::Test>; /* Generated from the following GLSL #version 440 core void main() { for (int i = 0; i < 1; i++) { break; } } */ TEST_F(PassClassTest, UnreachableNestedIfs) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 1 %17 = OpTypeBool %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %15 = OpLoad %6 %8 %18 = OpSLessThan %17 %15 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel OpBranch %12 %13 = OpLabel %20 = OpLoad %6 %8 %21 = OpIAdd %6 %20 %16 OpStore %8 %21 OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 4); DominatorAnalysis* analysis = context->GetDominatorAnalysis(f); EXPECT_TRUE(analysis->Dominates(5, 5)); EXPECT_TRUE(analysis->Dominates(5, 10)); EXPECT_TRUE(analysis->Dominates(5, 14)); EXPECT_TRUE(analysis->Dominates(5, 11)); EXPECT_TRUE(analysis->Dominates(5, 12)); EXPECT_TRUE(analysis->Dominates(10, 10)); EXPECT_TRUE(analysis->Dominates(10, 14)); EXPECT_TRUE(analysis->Dominates(10, 11)); EXPECT_TRUE(analysis->Dominates(10, 12)); EXPECT_TRUE(analysis->Dominates(14, 14)); EXPECT_TRUE(analysis->Dominates(14, 11)); EXPECT_TRUE(analysis->Dominates(14, 12)); EXPECT_TRUE(analysis->Dominates(11, 11)); EXPECT_TRUE(analysis->Dominates(12, 12)); EXPECT_TRUE(analysis->StrictlyDominates(5, 10)); EXPECT_TRUE(analysis->StrictlyDominates(5, 14)); EXPECT_TRUE(analysis->StrictlyDominates(5, 11)); EXPECT_TRUE(analysis->StrictlyDominates(5, 12)); EXPECT_TRUE(analysis->StrictlyDominates(10, 14)); EXPECT_TRUE(analysis->StrictlyDominates(10, 11)); EXPECT_TRUE(analysis->StrictlyDominates(10, 12)); EXPECT_TRUE(analysis->StrictlyDominates(14, 11)); EXPECT_TRUE(analysis->StrictlyDominates(14, 12)); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/dominator_tree/unreachable_for_post.cpp000066400000000000000000000067361475742701700302310ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gmock/gmock.h" #include "source/opt/dominator_analysis.h" #include "source/opt/pass.h" #include "test/opt/assembly_builder.h" #include "test/opt/function_utils.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using ::testing::UnorderedElementsAre; using PassClassTest = PassTest<::testing::Test>; /* Generated from the following GLSL #version 440 core void main() { for (int i = 0; i < 1; i++) { break; } } */ TEST_F(PassClassTest, UnreachableNestedIfs) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 1 %17 = OpTypeBool %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %15 = OpLoad %6 %8 %18 = OpSLessThan %17 %15 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel OpBranch %12 %13 = OpLabel %20 = OpLoad %6 %8 %21 = OpIAdd %6 %20 %16 OpStore %8 %21 OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 4); PostDominatorAnalysis* analysis = context->GetPostDominatorAnalysis(f); EXPECT_TRUE(analysis->Dominates(12, 12)); EXPECT_TRUE(analysis->Dominates(12, 14)); EXPECT_TRUE(analysis->Dominates(12, 11)); EXPECT_TRUE(analysis->Dominates(12, 10)); EXPECT_TRUE(analysis->Dominates(12, 5)); EXPECT_TRUE(analysis->Dominates(14, 14)); EXPECT_TRUE(analysis->Dominates(14, 10)); EXPECT_TRUE(analysis->Dominates(14, 5)); EXPECT_TRUE(analysis->Dominates(10, 10)); EXPECT_TRUE(analysis->Dominates(10, 5)); EXPECT_TRUE(analysis->Dominates(5, 5)); EXPECT_TRUE(analysis->StrictlyDominates(12, 14)); EXPECT_TRUE(analysis->StrictlyDominates(12, 11)); EXPECT_TRUE(analysis->StrictlyDominates(12, 10)); EXPECT_TRUE(analysis->StrictlyDominates(12, 5)); EXPECT_TRUE(analysis->StrictlyDominates(14, 10)); EXPECT_TRUE(analysis->StrictlyDominates(14, 5)); EXPECT_TRUE(analysis->StrictlyDominates(10, 5)); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/eliminate_dead_const_test.cpp000066400000000000000000001073671475742701700262250ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include #include "test/opt/assembly_builder.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using EliminateDeadConstantBasicTest = PassTest<::testing::Test>; TEST_F(EliminateDeadConstantBasicTest, BasicAllDeadConstants) { const std::vector text = { // clang-format off "OpCapability Shader", "OpCapability Float64", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Vertex %main \"main\"", "OpName %main \"main\"", "%void = OpTypeVoid", "%4 = OpTypeFunction %void", "%bool = OpTypeBool", "%true = OpConstantTrue %bool", "%false = OpConstantFalse %bool", "%int = OpTypeInt 32 1", "%9 = OpConstant %int 1", "%uint = OpTypeInt 32 0", "%11 = OpConstant %uint 2", "%float = OpTypeFloat 32", "%13 = OpConstant %float 3.1415", "%double = OpTypeFloat 64", "%15 = OpConstant %double 3.14159265358979", "%main = OpFunction %void None %4", "%16 = OpLabel", "OpReturn", "OpFunctionEnd", // clang-format on }; // None of the above constants is ever used, so all of them should be // eliminated. const char* const_decl_opcodes[] = { " OpConstantTrue ", " OpConstantFalse ", " OpConstant ", }; // Skip lines that have any one of const_decl_opcodes. const std::string expected_disassembly = SelectiveJoin(text, [&const_decl_opcodes](const char* line) { return std::any_of( std::begin(const_decl_opcodes), std::end(const_decl_opcodes), [&line](const char* const_decl_op) { return std::string(line).find(const_decl_op) != std::string::npos; }); }); SinglePassRunAndCheck( JoinAllInsts(text), expected_disassembly, /* skip_nop = */ true); } TEST_F(EliminateDeadConstantBasicTest, BasicNoneDeadConstants) { const std::vector text = { // clang-format off "OpCapability Shader", "OpCapability Float64", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Vertex %main \"main\"", "OpName %main \"main\"", "OpName %btv \"btv\"", "OpName %bfv \"bfv\"", "OpName %iv \"iv\"", "OpName %uv \"uv\"", "OpName %fv \"fv\"", "OpName %dv \"dv\"", "%void = OpTypeVoid", "%10 = OpTypeFunction %void", "%bool = OpTypeBool", "%_ptr_Function_bool = OpTypePointer Function %bool", "%true = OpConstantTrue %bool", "%false = OpConstantFalse %bool", "%int = OpTypeInt 32 1", "%_ptr_Function_int = OpTypePointer Function %int", "%int_1 = OpConstant %int 1", "%uint = OpTypeInt 32 0", "%_ptr_Function_uint = OpTypePointer Function %uint", "%uint_2 = OpConstant %uint 2", "%float = OpTypeFloat 32", "%_ptr_Function_float = OpTypePointer Function %float", "%float_3_1415 = OpConstant %float 3.1415", "%double = OpTypeFloat 64", "%_ptr_Function_double = OpTypePointer Function %double", "%double_3_14159265358979 = OpConstant %double 3.14159265358979", "%main = OpFunction %void None %10", "%27 = OpLabel", "%btv = OpVariable %_ptr_Function_bool Function", "%bfv = OpVariable %_ptr_Function_bool Function", "%iv = OpVariable %_ptr_Function_int Function", "%uv = OpVariable %_ptr_Function_uint Function", "%fv = OpVariable %_ptr_Function_float Function", "%dv = OpVariable %_ptr_Function_double Function", "OpStore %btv %true", "OpStore %bfv %false", "OpStore %iv %int_1", "OpStore %uv %uint_2", "OpStore %fv %float_3_1415", "OpStore %dv %double_3_14159265358979", "OpReturn", "OpFunctionEnd", // clang-format on }; // All constants are used, so none of them should be eliminated. SinglePassRunAndCheck( JoinAllInsts(text), JoinAllInsts(text), /* skip_nop = */ true); } struct EliminateDeadConstantTestCase { // Type declarations and constants that should be kept. std::vector used_consts; // Instructions that refer to constants, this is added to create uses for // some constants so they won't be treated as dead constants. std::vector main_insts; // Dead constants that should be removed. std::vector dead_consts; }; // All types that are potentially required in EliminateDeadConstantTest. const std::vector CommonTypes = { // clang-format off // scalar types "%bool = OpTypeBool", "%uint = OpTypeInt 32 0", "%int = OpTypeInt 32 1", "%float = OpTypeFloat 32", "%double = OpTypeFloat 64", // vector types "%v2bool = OpTypeVector %bool 2", "%v2uint = OpTypeVector %uint 2", "%v2int = OpTypeVector %int 2", "%v3int = OpTypeVector %int 3", "%v4int = OpTypeVector %int 4", "%v2float = OpTypeVector %float 2", "%v3float = OpTypeVector %float 3", "%v2double = OpTypeVector %double 2", // variable pointer types "%_pf_bool = OpTypePointer Function %bool", "%_pf_uint = OpTypePointer Function %uint", "%_pf_int = OpTypePointer Function %int", "%_pf_float = OpTypePointer Function %float", "%_pf_double = OpTypePointer Function %double", "%_pf_v2int = OpTypePointer Function %v2int", "%_pf_v3int = OpTypePointer Function %v3int", "%_pf_v2float = OpTypePointer Function %v2float", "%_pf_v3float = OpTypePointer Function %v3float", "%_pf_v2double = OpTypePointer Function %v2double", // struct types "%inner_struct = OpTypeStruct %bool %int %float %double", "%outer_struct = OpTypeStruct %inner_struct %int %double", "%flat_struct = OpTypeStruct %bool %int %float %double", // clang-format on }; using EliminateDeadConstantTest = PassTest<::testing::TestWithParam>; TEST_P(EliminateDeadConstantTest, Custom) { auto& tc = GetParam(); AssemblyBuilder builder; builder.AppendTypesConstantsGlobals(CommonTypes) .AppendTypesConstantsGlobals(tc.used_consts) .AppendInMain(tc.main_insts); const std::string expected = builder.GetCode(); builder.AppendTypesConstantsGlobals(tc.dead_consts); const std::string assembly_with_dead_const = builder.GetCode(); SinglePassRunAndCheck( assembly_with_dead_const, expected, /* skip_nop = */ true); } INSTANTIATE_TEST_SUITE_P( ScalarTypeConstants, EliminateDeadConstantTest, ::testing::ValuesIn(std::vector({ // clang-format off // Scalar type constants, one dead constant and one used constant. { /* .used_consts = */ { "%used_const_int = OpConstant %int 1", }, /* .main_insts = */ { "%int_var = OpVariable %_pf_int Function", "OpStore %int_var %used_const_int", }, /* .dead_consts = */ { "%dead_const_int = OpConstant %int 1", }, }, { /* .used_consts = */ { "%used_const_uint = OpConstant %uint 1", }, /* .main_insts = */ { "%uint_var = OpVariable %_pf_uint Function", "OpStore %uint_var %used_const_uint", }, /* .dead_consts = */ { "%dead_const_uint = OpConstant %uint 1", }, }, { /* .used_consts = */ { "%used_const_float = OpConstant %float 3.1415", }, /* .main_insts = */ { "%float_var = OpVariable %_pf_float Function", "OpStore %float_var %used_const_float", }, /* .dead_consts = */ { "%dead_const_float = OpConstant %float 3.1415", }, }, { /* .used_consts = */ { "%used_const_double = OpConstant %double 3.141592653", }, /* .main_insts = */ { "%double_var = OpVariable %_pf_double Function", "OpStore %double_var %used_const_double", }, /* .dead_consts = */ { "%dead_const_double = OpConstant %double 3.141592653", }, }, // clang-format on }))); INSTANTIATE_TEST_SUITE_P( VectorTypeConstants, EliminateDeadConstantTest, ::testing::ValuesIn(std::vector({ // clang-format off // Tests eliminating dead constant type ivec2. One dead constant vector // and one used constant vector, each built from its own group of // scalar constants. { /* .used_consts = */ { "%used_int_x = OpConstant %int 1", "%used_int_y = OpConstant %int 2", "%used_v2int = OpConstantComposite %v2int %used_int_x %used_int_y", }, /* .main_insts = */ { "%v2int_var = OpVariable %_pf_v2int Function", "OpStore %v2int_var %used_v2int", }, /* .dead_consts = */ { "%dead_int_x = OpConstant %int 1", "%dead_int_y = OpConstant %int 2", "%dead_v2int = OpConstantComposite %v2int %dead_int_x %dead_int_y", }, }, // Tests eliminating dead constant ivec2. One dead constant vector and // one used constant vector. But both built from a same group of // scalar constants. { /* .used_consts = */ { "%used_int_x = OpConstant %int 1", "%used_int_y = OpConstant %int 2", "%used_int_z = OpConstant %int 3", "%used_v3int = OpConstantComposite %v3int %used_int_x %used_int_y %used_int_z", }, /* .main_insts = */ { "%v3int_var = OpVariable %_pf_v3int Function", "OpStore %v3int_var %used_v3int", }, /* .dead_consts = */ { "%dead_v3int = OpConstantComposite %v3int %used_int_x %used_int_y %used_int_z", }, }, // Tests eliminating dead cosntant vec2. One dead constant vector and // one used constant vector. Each built from its own group of scalar // constants. { /* .used_consts = */ { "%used_float_x = OpConstant %float 3.1415", "%used_float_y = OpConstant %float 4.25", "%used_v2float = OpConstantComposite %v2float %used_float_x %used_float_y", }, /* .main_insts = */ { "%v2float_var = OpVariable %_pf_v2float Function", "OpStore %v2float_var %used_v2float", }, /* .dead_consts = */ { "%dead_float_x = OpConstant %float 3.1415", "%dead_float_y = OpConstant %float 4.25", "%dead_v2float = OpConstantComposite %v2float %dead_float_x %dead_float_y", }, }, // Tests eliminating dead cosntant vec2. One dead constant vector and // one used constant vector. Both built from a same group of scalar // constants. { /* .used_consts = */ { "%used_float_x = OpConstant %float 3.1415", "%used_float_y = OpConstant %float 4.25", "%used_float_z = OpConstant %float 4.75", "%used_v3float = OpConstantComposite %v3float %used_float_x %used_float_y %used_float_z", }, /* .main_insts = */ { "%v3float_var = OpVariable %_pf_v3float Function", "OpStore %v3float_var %used_v3float", }, /* .dead_consts = */ { "%dead_v3float = OpConstantComposite %v3float %used_float_x %used_float_y %used_float_z", }, }, // clang-format on }))); INSTANTIATE_TEST_SUITE_P( StructTypeConstants, EliminateDeadConstantTest, ::testing::ValuesIn(std::vector({ // clang-format off // A plain struct type dead constants. All of its components are dead // constants too. { /* .used_consts = */ {}, /* .main_insts = */ {}, /* .dead_consts = */ { "%dead_bool = OpConstantTrue %bool", "%dead_int = OpConstant %int 1", "%dead_float = OpConstant %float 2.5", "%dead_double = OpConstant %double 3.14159265358979", "%dead_struct = OpConstantComposite %flat_struct %dead_bool %dead_int %dead_float %dead_double", }, }, // A plain struct type dead constants. Some of its components are dead // constants while others are not. { /* .used_consts = */ { "%used_int = OpConstant %int 1", "%used_double = OpConstant %double 3.14159265358979", }, /* .main_insts = */ { "%int_var = OpVariable %_pf_int Function", "OpStore %int_var %used_int", "%double_var = OpVariable %_pf_double Function", "OpStore %double_var %used_double", }, /* .dead_consts = */ { "%dead_bool = OpConstantTrue %bool", "%dead_float = OpConstant %float 2.5", "%dead_struct = OpConstantComposite %flat_struct %dead_bool %used_int %dead_float %used_double", }, }, // A nesting struct type dead constants. All components of both outer // and inner structs are dead and should be removed after dead constant // elimination. { /* .used_consts = */ {}, /* .main_insts = */ {}, /* .dead_consts = */ { "%dead_bool = OpConstantTrue %bool", "%dead_int = OpConstant %int 1", "%dead_float = OpConstant %float 2.5", "%dead_double = OpConstant %double 3.1415926535", "%dead_inner_struct = OpConstantComposite %inner_struct %dead_bool %dead_int %dead_float %dead_double", "%dead_int2 = OpConstant %int 2", "%dead_double2 = OpConstant %double 1.428571428514", "%dead_outer_struct = OpConstantComposite %outer_struct %dead_inner_struct %dead_int2 %dead_double2", }, }, // A nesting struct type dead constants. Some of its components are // dead constants while others are not. { /* .used_consts = */ { "%used_int = OpConstant %int 1", "%used_double = OpConstant %double 3.14159265358979", }, /* .main_insts = */ { "%int_var = OpVariable %_pf_int Function", "OpStore %int_var %used_int", "%double_var = OpVariable %_pf_double Function", "OpStore %double_var %used_double", }, /* .dead_consts = */ { "%dead_bool = OpConstantTrue %bool", "%dead_float = OpConstant %float 2.5", "%dead_inner_struct = OpConstantComposite %inner_struct %dead_bool %used_int %dead_float %used_double", "%dead_int = OpConstant %int 2", "%dead_outer_struct = OpConstantComposite %outer_struct %dead_inner_struct %dead_int %used_double", }, }, // A nesting struct case. The inner struct is used while the outer struct is not { /* .used_const = */ { "%used_bool = OpConstantTrue %bool", "%used_int = OpConstant %int 1", "%used_float = OpConstant %float 1.25", "%used_double = OpConstant %double 1.23456789012345", "%used_inner_struct = OpConstantComposite %inner_struct %used_bool %used_int %used_float %used_double", }, /* .main_insts = */ { "%bool_var = OpVariable %_pf_bool Function", "%bool_from_inner_struct = OpCompositeExtract %bool %used_inner_struct 0", "OpStore %bool_var %bool_from_inner_struct", }, /* .dead_consts = */ { "%dead_int = OpConstant %int 2", "%dead_outer_struct = OpConstantComposite %outer_struct %used_inner_struct %dead_int %used_double" }, }, // A nesting struct case. The outer struct is used, so the inner struct should not // be removed even though it is not used anywhere. { /* .used_const = */ { "%used_bool = OpConstantTrue %bool", "%used_int = OpConstant %int 1", "%used_float = OpConstant %float 1.25", "%used_double = OpConstant %double 1.23456789012345", "%used_inner_struct = OpConstantComposite %inner_struct %used_bool %used_int %used_float %used_double", "%used_outer_struct = OpConstantComposite %outer_struct %used_inner_struct %used_int %used_double" }, /* .main_insts = */ { "%int_var = OpVariable %_pf_int Function", "%int_from_outer_struct = OpCompositeExtract %int %used_outer_struct 1", "OpStore %int_var %int_from_outer_struct", }, /* .dead_consts = */ {}, }, // clang-format on }))); INSTANTIATE_TEST_SUITE_P( ScalarTypeSpecConstants, EliminateDeadConstantTest, ::testing::ValuesIn(std::vector({ // clang-format off // All scalar type spec constants. { /* .used_consts = */ { "%used_bool = OpSpecConstantTrue %bool", "%used_uint = OpSpecConstant %uint 2", "%used_int = OpSpecConstant %int 2", "%used_float = OpSpecConstant %float 2.5", "%used_double = OpSpecConstant %double 1.42857142851", }, /* .main_insts = */ { "%bool_var = OpVariable %_pf_bool Function", "%uint_var = OpVariable %_pf_uint Function", "%int_var = OpVariable %_pf_int Function", "%float_var = OpVariable %_pf_float Function", "%double_var = OpVariable %_pf_double Function", "OpStore %bool_var %used_bool", "OpStore %uint_var %used_uint", "OpStore %int_var %used_int", "OpStore %float_var %used_float", "OpStore %double_var %used_double", }, /* .dead_consts = */ { "%dead_bool = OpSpecConstantTrue %bool", "%dead_uint = OpSpecConstant %uint 2", "%dead_int = OpSpecConstant %int 2", "%dead_float = OpSpecConstant %float 2.5", "%dead_double = OpSpecConstant %double 1.42857142851", }, }, // clang-format on }))); INSTANTIATE_TEST_SUITE_P( VectorTypeSpecConstants, EliminateDeadConstantTest, ::testing::ValuesIn(std::vector({ // clang-format off // Bool vector type spec constants. One vector has all component dead, // another vector has one dead boolean and one used boolean. { /* .used_consts = */ { "%used_bool = OpSpecConstantTrue %bool", }, /* .main_insts = */ { "%bool_var = OpVariable %_pf_bool Function", "OpStore %bool_var %used_bool", }, /* .dead_consts = */ { "%dead_bool = OpSpecConstantFalse %bool", "%dead_bool_vec1 = OpSpecConstantComposite %v2bool %dead_bool %dead_bool", "%dead_bool_vec2 = OpSpecConstantComposite %v2bool %dead_bool %used_bool", }, }, // Uint vector type spec constants. One vector has all component dead, // another vector has one dead unsigned integer and one used unsigned // integer. { /* .used_consts = */ { "%used_uint = OpSpecConstant %uint 3", }, /* .main_insts = */ { "%uint_var = OpVariable %_pf_uint Function", "OpStore %uint_var %used_uint", }, /* .dead_consts = */ { "%dead_uint = OpSpecConstant %uint 1", "%dead_uint_vec1 = OpSpecConstantComposite %v2uint %dead_uint %dead_uint", "%dead_uint_vec2 = OpSpecConstantComposite %v2uint %dead_uint %used_uint", }, }, // Int vector type spec constants. One vector has all component dead, // another vector has one dead integer and one used integer. { /* .used_consts = */ { "%used_int = OpSpecConstant %int 3", }, /* .main_insts = */ { "%int_var = OpVariable %_pf_int Function", "OpStore %int_var %used_int", }, /* .dead_consts = */ { "%dead_int = OpSpecConstant %int 1", "%dead_int_vec1 = OpSpecConstantComposite %v2int %dead_int %dead_int", "%dead_int_vec2 = OpSpecConstantComposite %v2int %dead_int %used_int", }, }, // Int vector type spec constants built with both spec constants and // front-end constants. { /* .used_consts = */ { "%used_spec_int = OpSpecConstant %int 3", "%used_front_end_int = OpConstant %int 3", }, /* .main_insts = */ { "%int_var1 = OpVariable %_pf_int Function", "OpStore %int_var1 %used_spec_int", "%int_var2 = OpVariable %_pf_int Function", "OpStore %int_var2 %used_front_end_int", }, /* .dead_consts = */ { "%dead_spec_int = OpSpecConstant %int 1", "%dead_front_end_int = OpConstant %int 1", // Dead front-end and dead spec constants "%dead_int_vec1 = OpSpecConstantComposite %v2int %dead_spec_int %dead_front_end_int", // Used front-end and dead spec constants "%dead_int_vec2 = OpSpecConstantComposite %v2int %dead_spec_int %used_front_end_int", // Dead front-end and used spec constants "%dead_int_vec3 = OpSpecConstantComposite %v2int %dead_front_end_int %used_spec_int", }, }, // clang-format on }))); INSTANTIATE_TEST_SUITE_P( SpecConstantOp, EliminateDeadConstantTest, ::testing::ValuesIn(std::vector({ // clang-format off // Cast operations: uint <-> int <-> bool { /* .used_consts = */ {}, /* .main_insts = */ {}, /* .dead_consts = */ { // Assistant constants, only used in dead spec constant // operations. "%signed_zero = OpConstant %int 0", "%signed_zero_vec = OpConstantComposite %v2int %signed_zero %signed_zero", "%unsigned_zero = OpConstant %uint 0", "%unsigned_zero_vec = OpConstantComposite %v2uint %unsigned_zero %unsigned_zero", "%signed_one = OpConstant %int 1", "%signed_one_vec = OpConstantComposite %v2int %signed_one %signed_one", "%unsigned_one = OpConstant %uint 1", "%unsigned_one_vec = OpConstantComposite %v2uint %unsigned_one %unsigned_one", // Spec constants that support casting to each other. "%dead_bool = OpSpecConstantTrue %bool", "%dead_uint = OpSpecConstant %uint 1", "%dead_int = OpSpecConstant %int 2", "%dead_bool_vec = OpSpecConstantComposite %v2bool %dead_bool %dead_bool", "%dead_uint_vec = OpSpecConstantComposite %v2uint %dead_uint %dead_uint", "%dead_int_vec = OpSpecConstantComposite %v2int %dead_int %dead_int", // Scalar cast to boolean spec constant. "%int_to_bool = OpSpecConstantOp %bool INotEqual %dead_int %signed_zero", "%uint_to_bool = OpSpecConstantOp %bool INotEqual %dead_uint %unsigned_zero", // Vector cast to boolean spec constant. "%int_to_bool_vec = OpSpecConstantOp %v2bool INotEqual %dead_int_vec %signed_zero_vec", "%uint_to_bool_vec = OpSpecConstantOp %v2bool INotEqual %dead_uint_vec %unsigned_zero_vec", // Scalar cast to int spec constant. "%bool_to_int = OpSpecConstantOp %int Select %dead_bool %signed_one %signed_zero", "%uint_to_int = OpSpecConstantOp %uint IAdd %dead_uint %unsigned_zero", // Vector cast to int spec constant. "%bool_to_int_vec = OpSpecConstantOp %v2int Select %dead_bool_vec %signed_one_vec %signed_zero_vec", "%uint_to_int_vec = OpSpecConstantOp %v2uint IAdd %dead_uint_vec %unsigned_zero_vec", // Scalar cast to uint spec constant. "%bool_to_uint = OpSpecConstantOp %uint Select %dead_bool %unsigned_one %unsigned_zero", "%int_to_uint_vec = OpSpecConstantOp %uint IAdd %dead_int %signed_zero", // Vector cast to uint spec constant. "%bool_to_uint_vec = OpSpecConstantOp %v2uint Select %dead_bool_vec %unsigned_one_vec %unsigned_zero_vec", "%int_to_uint = OpSpecConstantOp %v2uint IAdd %dead_int_vec %signed_zero_vec", }, }, // Add, sub, mul, div, rem. { /* .used_consts = */ {}, /* .main_insts = */ {}, /* .dead_consts = */ { "%dead_spec_int_a = OpSpecConstant %int 1", "%dead_spec_int_a_vec = OpSpecConstantComposite %v2int %dead_spec_int_a %dead_spec_int_a", "%dead_spec_int_b = OpSpecConstant %int 2", "%dead_spec_int_b_vec = OpSpecConstantComposite %v2int %dead_spec_int_b %dead_spec_int_b", "%dead_const_int_c = OpConstant %int 3", "%dead_const_int_c_vec = OpConstantComposite %v2int %dead_const_int_c %dead_const_int_c", // Add "%add_a_b = OpSpecConstantOp %int IAdd %dead_spec_int_a %dead_spec_int_b", "%add_a_b_vec = OpSpecConstantOp %v2int IAdd %dead_spec_int_a_vec %dead_spec_int_b_vec", // Sub "%sub_a_b = OpSpecConstantOp %int ISub %dead_spec_int_a %dead_spec_int_b", "%sub_a_b_vec = OpSpecConstantOp %v2int ISub %dead_spec_int_a_vec %dead_spec_int_b_vec", // Mul "%mul_a_b = OpSpecConstantOp %int IMul %dead_spec_int_a %dead_spec_int_b", "%mul_a_b_vec = OpSpecConstantOp %v2int IMul %dead_spec_int_a_vec %dead_spec_int_b_vec", // Div "%div_a_b = OpSpecConstantOp %int SDiv %dead_spec_int_a %dead_spec_int_b", "%div_a_b_vec = OpSpecConstantOp %v2int SDiv %dead_spec_int_a_vec %dead_spec_int_b_vec", // Bitwise Xor "%xor_a_b = OpSpecConstantOp %int BitwiseXor %dead_spec_int_a %dead_spec_int_b", "%xor_a_b_vec = OpSpecConstantOp %v2int BitwiseXor %dead_spec_int_a_vec %dead_spec_int_b_vec", // Scalar Comparison "%less_a_b = OpSpecConstantOp %bool SLessThan %dead_spec_int_a %dead_spec_int_b", }, }, // Vectors without used swizzles should be removed. { /* .used_consts = */ { "%used_int = OpConstant %int 3", }, /* .main_insts = */ { "%int_var = OpVariable %_pf_int Function", "OpStore %int_var %used_int", }, /* .dead_consts = */ { "%dead_int = OpConstant %int 3", "%dead_spec_int_a = OpSpecConstant %int 1", "%vec_a = OpSpecConstantComposite %v4int %dead_spec_int_a %dead_spec_int_a %dead_int %dead_int", "%dead_spec_int_b = OpSpecConstant %int 2", "%vec_b = OpSpecConstantComposite %v4int %dead_spec_int_b %dead_spec_int_b %used_int %used_int", // Extract scalar "%a_x = OpSpecConstantOp %int CompositeExtract %vec_a 0", "%b_x = OpSpecConstantOp %int CompositeExtract %vec_b 0", // Extract vector "%a_xy = OpSpecConstantOp %v2int VectorShuffle %vec_a %vec_a 0 1", "%b_xy = OpSpecConstantOp %v2int VectorShuffle %vec_b %vec_b 0 1", }, }, // Vectors with used swizzles should not be removed. { /* .used_consts = */ { "%used_int = OpConstant %int 3", "%used_spec_int_a = OpSpecConstant %int 1", "%used_spec_int_b = OpSpecConstant %int 2", // Create vectors "%vec_a = OpSpecConstantComposite %v4int %used_spec_int_a %used_spec_int_a %used_int %used_int", "%vec_b = OpSpecConstantComposite %v4int %used_spec_int_b %used_spec_int_b %used_int %used_int", // Extract vector "%a_xy = OpSpecConstantOp %v2int VectorShuffle %vec_a %vec_a 0 1", "%b_xy = OpSpecConstantOp %v2int VectorShuffle %vec_b %vec_b 0 1", }, /* .main_insts = */ { "%v2int_var_a = OpVariable %_pf_v2int Function", "%v2int_var_b = OpVariable %_pf_v2int Function", "OpStore %v2int_var_a %a_xy", "OpStore %v2int_var_b %b_xy", }, /* .dead_consts = */ {}, }, // clang-format on }))); INSTANTIATE_TEST_SUITE_P( LongDefUseChain, EliminateDeadConstantTest, ::testing::ValuesIn(std::vector({ // clang-format off // Long Def-Use chain with binary operations. { /* .used_consts = */ { "%array_size = OpConstant %int 4", "%type_arr_int_4 = OpTypeArray %int %array_size", "%used_int_0 = OpConstant %int 100", "%used_int_1 = OpConstant %int 1", "%used_int_2 = OpSpecConstantOp %int IAdd %used_int_0 %used_int_1", "%used_int_3 = OpSpecConstantOp %int ISub %used_int_0 %used_int_2", "%used_int_4 = OpSpecConstantOp %int IAdd %used_int_0 %used_int_3", "%used_int_5 = OpSpecConstantOp %int ISub %used_int_0 %used_int_4", "%used_int_6 = OpSpecConstantOp %int IAdd %used_int_0 %used_int_5", "%used_int_7 = OpSpecConstantOp %int ISub %used_int_0 %used_int_6", "%used_int_8 = OpSpecConstantOp %int IAdd %used_int_0 %used_int_7", "%used_int_9 = OpSpecConstantOp %int ISub %used_int_0 %used_int_8", "%used_int_10 = OpSpecConstantOp %int IAdd %used_int_0 %used_int_9", "%used_int_11 = OpSpecConstantOp %int ISub %used_int_0 %used_int_10", "%used_int_12 = OpSpecConstantOp %int IAdd %used_int_0 %used_int_11", "%used_int_13 = OpSpecConstantOp %int ISub %used_int_0 %used_int_12", "%used_int_14 = OpSpecConstantOp %int IAdd %used_int_0 %used_int_13", "%used_int_15 = OpSpecConstantOp %int ISub %used_int_0 %used_int_14", "%used_int_16 = OpSpecConstantOp %int ISub %used_int_0 %used_int_15", "%used_int_17 = OpSpecConstantOp %int IAdd %used_int_0 %used_int_16", "%used_int_18 = OpSpecConstantOp %int ISub %used_int_0 %used_int_17", "%used_int_19 = OpSpecConstantOp %int IAdd %used_int_0 %used_int_18", "%used_int_20 = OpSpecConstantOp %int ISub %used_int_0 %used_int_19", "%used_vec_a = OpSpecConstantComposite %v2int %used_int_18 %used_int_19", "%used_vec_b = OpSpecConstantOp %v2int IMul %used_vec_a %used_vec_a", "%used_int_21 = OpSpecConstantOp %int CompositeExtract %used_vec_b 0", "%used_array = OpConstantComposite %type_arr_int_4 %used_int_20 %used_int_20 %used_int_21 %used_int_21", }, /* .main_insts = */ { "%int_var = OpVariable %_pf_int Function", "%used_array_2 = OpCompositeExtract %int %used_array 2", "OpStore %int_var %used_array_2", }, /* .dead_consts = */ { "%dead_int_1 = OpConstant %int 2", "%dead_int_2 = OpSpecConstantOp %int IAdd %used_int_0 %dead_int_1", "%dead_int_3 = OpSpecConstantOp %int ISub %used_int_0 %dead_int_2", "%dead_int_4 = OpSpecConstantOp %int IAdd %used_int_0 %dead_int_3", "%dead_int_5 = OpSpecConstantOp %int ISub %used_int_0 %dead_int_4", "%dead_int_6 = OpSpecConstantOp %int IAdd %used_int_0 %dead_int_5", "%dead_int_7 = OpSpecConstantOp %int ISub %used_int_0 %dead_int_6", "%dead_int_8 = OpSpecConstantOp %int IAdd %used_int_0 %dead_int_7", "%dead_int_9 = OpSpecConstantOp %int ISub %used_int_0 %dead_int_8", "%dead_int_10 = OpSpecConstantOp %int IAdd %used_int_0 %dead_int_9", "%dead_int_11 = OpSpecConstantOp %int ISub %used_int_0 %dead_int_10", "%dead_int_12 = OpSpecConstantOp %int IAdd %used_int_0 %dead_int_11", "%dead_int_13 = OpSpecConstantOp %int ISub %used_int_0 %dead_int_12", "%dead_int_14 = OpSpecConstantOp %int IAdd %used_int_0 %dead_int_13", "%dead_int_15 = OpSpecConstantOp %int ISub %used_int_0 %dead_int_14", "%dead_int_16 = OpSpecConstantOp %int ISub %used_int_0 %dead_int_15", "%dead_int_17 = OpSpecConstantOp %int IAdd %used_int_0 %dead_int_16", "%dead_int_18 = OpSpecConstantOp %int ISub %used_int_0 %dead_int_17", "%dead_int_19 = OpSpecConstantOp %int IAdd %used_int_0 %dead_int_18", "%dead_int_20 = OpSpecConstantOp %int ISub %used_int_0 %dead_int_19", "%dead_vec_a = OpSpecConstantComposite %v2int %dead_int_18 %dead_int_19", "%dead_vec_b = OpSpecConstantOp %v2int IMul %dead_vec_a %dead_vec_a", "%dead_int_21 = OpSpecConstantOp %int CompositeExtract %dead_vec_b 0", "%dead_array = OpConstantComposite %type_arr_int_4 %dead_int_20 %used_int_20 %dead_int_19 %used_int_19", }, }, // Long Def-Use chain with swizzle // clang-format on }))); } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/eliminate_dead_functions_test.cpp000066400000000000000000000457031475742701700271020ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gmock/gmock.h" #include "test/opt/assembly_builder.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using ::testing::HasSubstr; using EliminateDeadFunctionsBasicTest = PassTest<::testing::Test>; TEST_F(EliminateDeadFunctionsBasicTest, BasicDeleteDeadFunction) { // The function Dead should be removed because it is never called. const std::vector common_code = { // clang-format off "OpCapability Shader", "OpMemoryModel Logical GLSL450", "OpEntryPoint Fragment %main \"main\"", "OpName %main \"main\"", "OpName %Live \"Live\"", "%void = OpTypeVoid", "%7 = OpTypeFunction %void", "%main = OpFunction %void None %7", "%15 = OpLabel", "%16 = OpFunctionCall %void %Live", "%17 = OpFunctionCall %void %Live", "OpReturn", "OpFunctionEnd", "%Live = OpFunction %void None %7", "%20 = OpLabel", "OpReturn", "OpFunctionEnd" // clang-format on }; const std::vector dead_function = { // clang-format off "%Dead = OpFunction %void None %7", "%19 = OpLabel", "OpReturn", "OpFunctionEnd", // clang-format on }; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck( JoinAllInsts(Concat(common_code, dead_function)), JoinAllInsts(common_code), /* skip_nop = */ true); } TEST_F(EliminateDeadFunctionsBasicTest, BasicKeepLiveFunction) { // Everything is reachable from an entry point, so no functions should be // deleted. const std::vector text = { // clang-format off "OpCapability Shader", "OpMemoryModel Logical GLSL450", "OpEntryPoint Fragment %main \"main\"", "OpName %main \"main\"", "OpName %Live1 \"Live1\"", "OpName %Live2 \"Live2\"", "%void = OpTypeVoid", "%7 = OpTypeFunction %void", "%main = OpFunction %void None %7", "%15 = OpLabel", "%16 = OpFunctionCall %void %Live2", "%17 = OpFunctionCall %void %Live1", "OpReturn", "OpFunctionEnd", "%Live1 = OpFunction %void None %7", "%19 = OpLabel", "OpReturn", "OpFunctionEnd", "%Live2 = OpFunction %void None %7", "%20 = OpLabel", "OpReturn", "OpFunctionEnd" // clang-format on }; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); std::string assembly = JoinAllInsts(text); auto result = SinglePassRunAndDisassemble( assembly, /* skip_nop = */ true, /* do_validation = */ false); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); EXPECT_EQ(assembly, std::get<0>(result)); } TEST_F(EliminateDeadFunctionsBasicTest, BasicKeepExportFunctions) { // All functions are reachable. In particular, ExportedFunc and Constant are // reachable because ExportedFunc is exported. Nothing should be removed. const std::vector text = { // clang-format off "OpCapability Shader", "OpCapability Linkage", "OpMemoryModel Logical GLSL450", "OpEntryPoint Fragment %main \"main\"", "OpName %main \"main\"", "OpName %ExportedFunc \"ExportedFunc\"", "OpName %Live \"Live\"", "OpDecorate %ExportedFunc LinkageAttributes \"ExportedFunc\" Export", "%void = OpTypeVoid", "%7 = OpTypeFunction %void", "%main = OpFunction %void None %7", "%15 = OpLabel", "OpReturn", "OpFunctionEnd", "%ExportedFunc = OpFunction %void None %7", "%19 = OpLabel", "%16 = OpFunctionCall %void %Live", "OpReturn", "OpFunctionEnd", "%Live = OpFunction %void None %7", "%20 = OpLabel", "OpReturn", "OpFunctionEnd" // clang-format on }; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); std::string assembly = JoinAllInsts(text); auto result = SinglePassRunAndDisassemble( assembly, /* skip_nop = */ true, /* do_validation = */ false); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); EXPECT_EQ(assembly, std::get<0>(result)); } TEST_F(EliminateDeadFunctionsBasicTest, BasicRemoveDecorationsAndNames) { // We want to remove the names and decorations associated with results that // are removed. This test will check for that. const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpName %main "main" OpName %Dead "Dead" OpName %x "x" OpName %y "y" OpName %z "z" OpDecorate %x RelaxedPrecision OpDecorate %y RelaxedPrecision OpDecorate %z RelaxedPrecision OpDecorate %6 RelaxedPrecision OpDecorate %7 RelaxedPrecision OpDecorate %8 RelaxedPrecision %void = OpTypeVoid %10 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_1 = OpConstant %float 1 %main = OpFunction %void None %10 %14 = OpLabel OpReturn OpFunctionEnd %Dead = OpFunction %void None %10 %15 = OpLabel %x = OpVariable %_ptr_Function_float Function %y = OpVariable %_ptr_Function_float Function %z = OpVariable %_ptr_Function_float Function OpStore %x %float_1 OpStore %y %float_1 %6 = OpLoad %float %x %7 = OpLoad %float %y %8 = OpFAdd %float %6 %7 OpStore %z %8 OpReturn OpFunctionEnd)"; const std::string expected_output = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpName %main "main" %void = OpTypeVoid %10 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_1 = OpConstant %float 1 %main = OpFunction %void None %10 %14 = OpLabel OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(text, expected_output, /* skip_nop = */ true); } TEST_F(EliminateDeadFunctionsBasicTest, DebugRemoveFunctionFromDebugFunction) { // We want to remove id of OpFunction from DebugFunction. const std::string text = R"(OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 OpExecutionMode %2 OriginUpperLeft %5 = OpString "ps.hlsl" OpSource HLSL 600 %5 "float4 foo() { return 1; } float4 main(float4 color : COLOR) : SV_TARGET { return foo() + color; } " %6 = OpString "float" %7 = OpString "main" %8 = OpString "foo" ; CHECK: [[foo:%\d+]] = OpString "foo" OpDecorate %3 Location 0 OpDecorate %4 Location 0 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %float = OpTypeFloat 32 %float_1 = OpConstant %float 1 %v4float = OpTypeVector %float 4 %14 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %18 = OpTypeFunction %void %19 = OpTypeFunction %v4float %3 = OpVariable %_ptr_Input_v4float Input %4 = OpVariable %_ptr_Output_v4float Output %_ptr_Function_v4float = OpTypePointer Function %v4float ; CHECK: [[info_none:%\d+]] = OpExtInst %void %1 DebugInfoNone %20 = OpExtInst %void %1 DebugSource %5 %21 = OpExtInst %void %1 DebugCompilationUnit 1 4 %20 HLSL %22 = OpExtInst %void %1 DebugTypeBasic %6 %uint_32 Float %23 = OpExtInst %void %1 DebugTypeVector %22 4 %24 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %23 %23 %25 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %23 %26 = OpExtInst %void %1 DebugFunction %7 %24 %20 4 1 %21 %7 FlagIsProtected|FlagIsPrivate 4 %2 %27 = OpExtInst %void %1 DebugFunction %8 %25 %20 1 1 %21 %8 FlagIsProtected|FlagIsPrivate 1 %28 ; CHECK: {{%\d+}} = OpExtInst %void %1 DebugFunction [[foo]] {{%\d+}} {{%\d+}} 1 1 {{%\d+}} {{%\d+}} FlagIsProtected|FlagIsPrivate 1 [[info_none]] %29 = OpExtInst %void %1 DebugLexicalBlock %20 1 14 %27 %40 = OpExtInst %void %1 DebugInlinedAt 4 %26 %2 = OpFunction %void None %18 %30 = OpLabel %39 = OpVariable %_ptr_Function_v4float Function %41 = OpExtInst %void %1 DebugScope %27 %40 OpStore %39 %14 %32 = OpLoad %v4float %39 %42 = OpExtInst %void %1 DebugScope %26 %33 = OpLoad %v4float %3 %34 = OpFAdd %v4float %32 %33 OpStore %4 %34 %43 = OpExtInst %void %1 DebugNoScope OpReturn OpFunctionEnd %28 = OpFunction %v4float None %19 %36 = OpLabel OpReturnValue %14 OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(EliminateDeadFunctionsBasicTest, DebugRemoveFunctionUsingExistingDebugInfoNone) { // We want to remove id of OpFunction from DebugFunction. const std::string text = R"(OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 OpExecutionMode %2 OriginUpperLeft %5 = OpString "ps.hlsl" OpSource HLSL 600 %5 "float4 foo() { return 1; } float4 main(float4 color : COLOR) : SV_TARGET { return foo() + color; } " %6 = OpString "float" %7 = OpString "main" %8 = OpString "foo" ; CHECK: [[foo:%\d+]] = OpString "foo" OpDecorate %3 Location 0 OpDecorate %4 Location 0 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %float = OpTypeFloat 32 %float_1 = OpConstant %float 1 %v4float = OpTypeVector %float 4 %14 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %18 = OpTypeFunction %void %19 = OpTypeFunction %v4float %3 = OpVariable %_ptr_Input_v4float Input %4 = OpVariable %_ptr_Output_v4float Output %_ptr_Function_v4float = OpTypePointer Function %v4float ; CHECK: [[info_none:%\d+]] = OpExtInst %void %1 DebugInfoNone %20 = OpExtInst %void %1 DebugSource %5 %21 = OpExtInst %void %1 DebugCompilationUnit 1 4 %20 HLSL %22 = OpExtInst %void %1 DebugTypeBasic %6 %uint_32 Float %23 = OpExtInst %void %1 DebugTypeVector %22 4 %24 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %23 %23 %25 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %23 %26 = OpExtInst %void %1 DebugFunction %7 %24 %20 4 1 %21 %7 FlagIsProtected|FlagIsPrivate 4 %2 %27 = OpExtInst %void %1 DebugFunction %8 %25 %20 1 1 %21 %8 FlagIsProtected|FlagIsPrivate 1 %28 ; CHECK: {{%\d+}} = OpExtInst %void %1 DebugFunction [[foo]] {{%\d+}} {{%\d+}} 1 1 {{%\d+}} {{%\d+}} FlagIsProtected|FlagIsPrivate 1 [[info_none]] %29 = OpExtInst %void %1 DebugLexicalBlock %20 1 14 %27 %35 = OpExtInst %void %1 DebugInfoNone %40 = OpExtInst %void %1 DebugInlinedAt 4 %26 %2 = OpFunction %void None %18 %30 = OpLabel %39 = OpVariable %_ptr_Function_v4float Function %41 = OpExtInst %void %1 DebugScope %27 %40 OpStore %39 %14 %32 = OpLoad %v4float %39 %42 = OpExtInst %void %1 DebugScope %26 %33 = OpLoad %v4float %3 %34 = OpFAdd %v4float %32 %33 OpStore %4 %34 %43 = OpExtInst %void %1 DebugNoScope OpReturn OpFunctionEnd %28 = OpFunction %v4float None %19 %36 = OpLabel OpReturnValue %14 OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(EliminateDeadFunctionsBasicTest, NonSemanticInfoPersists) { const std::string text = R"( ; CHECK: [[import:%\w+]] = OpExtInstImport ; CHECK: [[void:%\w+]] = OpTypeVoid ; CHECK-NOT: OpExtInst [[void]] [[import]] 1 ; CHECK: OpExtInst [[void]] [[import]] 2 OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %ext = OpExtInstImport "NonSemantic.Test" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd %foo = OpFunction %void None %void_fn %foo_entry = OpLabel %non_semantic1 = OpExtInst %void %ext 1 OpReturn OpFunctionEnd %non_semantic2 = OpExtInst %void %ext 2 )"; SinglePassRunAndMatch(text, true); } TEST_F(EliminateDeadFunctionsBasicTest, NonSemanticInfoRemoveDependent) { const std::string text = R"( ; CHECK: [[import:%\w+]] = OpExtInstImport ; CHECK: [[void:%\w+]] = OpTypeVoid ; CHECK-NOT: OpExtInst [[void]] [[import]] 1 ; CHECK-NOT: OpExtInst [[void]] [[import]] 2 ; CHECK: OpExtInst [[void]] [[import]] 3 OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %ext = OpExtInstImport "NonSemantic.Test" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd %foo = OpFunction %void None %void_fn %foo_entry = OpLabel %non_semantic1 = OpExtInst %void %ext 1 OpReturn OpFunctionEnd %non_semantic2 = OpExtInst %void %ext 2 %foo %non_semantic3 = OpExtInst %void %ext 3 )"; SinglePassRunAndMatch(text, true); } TEST_F(EliminateDeadFunctionsBasicTest, NonSemanticInfoRemoveDependentTree) { const std::string text = R"( ; CHECK: [[import:%\w+]] = OpExtInstImport ; CHECK: [[void:%\w+]] = OpTypeVoid ; CHECK-NOT: OpExtInst [[void]] [[import]] 1 ; CHECK-NOT: OpExtInst [[void]] [[import]] 2 ; CHECK: OpExtInst [[void]] [[import]] 3 ; CHECK-NOT: OpExtInst [[void]] [[import]] 4 ; CHECK-NOT: OpExtInst [[void]] [[import]] 5 OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %ext = OpExtInstImport "NonSemantic.Test" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd %foo = OpFunction %void None %void_fn %foo_entry = OpLabel %non_semantic1 = OpExtInst %void %ext 1 OpReturn OpFunctionEnd %non_semantic2 = OpExtInst %void %ext 2 %foo %non_semantic3 = OpExtInst %void %ext 3 %non_semantic4 = OpExtInst %void %ext 4 %non_semantic2 %non_semantic5 = OpExtInst %void %ext 5 %non_semantic4 )"; SinglePassRunAndMatch(text, true); } TEST_F(EliminateDeadFunctionsBasicTest, NonSemanticInfoRemoveDebugPrintf) { const std::string text = R"( ; CHECK-NOT: %foo_ = OpFunction %void None % 3 ; CHECK-NOT: % 7 = OpLabel ; CHECK-NOT: %c = OpVariable %_ptr_Function_v4float Function ; CHECK-NOT: % 22 = OpAccessChain %_ptr_UniformConstant_13 %samplers %int_0 ; CHECK-NOT: % 23 = OpLoad % 13 % 22 ; CHECK-NOT: % 27 = OpImageSampleExplicitLod %v4float % 23 % 26 Lod %float_0 ; CHECK-NOT: OpStore %c % 27 ; CHECK-NOT: % 31 = OpAccessChain %_ptr_Function_float %c %uint_0 ; CHECK-NOT: % 32 = OpLoad %float %31 ; CHECK-NOT: % 34 = OpExtInst %void %33 1 % 28 % 32 OpCapability RayTracingKHR OpExtension "SPV_KHR_non_semantic_info" OpExtension "SPV_KHR_ray_tracing" %1 = OpExtInstImport "GLSL.std.450" %33 = OpExtInstImport "NonSemantic.DebugPrintf" OpMemoryModel Logical GLSL450 OpEntryPoint ClosestHitNV %main "main" %samplers %28 = OpString "%f" OpSource GLSL 460 OpSourceExtension "GL_EXT_debug_printf" OpName %main "main" OpName %foo_ "foo(" OpName %c "c" OpName %samplers "samplers" OpDecorate %samplers DescriptorSet 0 OpDecorate %samplers Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %12 = OpTypeImage %float 3D 0 0 0 1 Unknown %13 = OpTypeSampledImage %12 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_13_uint_1 = OpTypeArray %13 %uint_1 %_ptr_UniformConstant__arr_13_uint_1 = OpTypePointer UniformConstant %_arr_13_uint_1 %samplers = OpVariable %_ptr_UniformConstant__arr_13_uint_1 UniformConstant %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_UniformConstant_13 = OpTypePointer UniformConstant %13 %v3float = OpTypeVector %float 3 %float_0 = OpConstant %float 0 %26 = OpConstantComposite %v3float %float_0 %float_0 %float_0 %uint_0 = OpConstant %uint 0 %_ptr_Function_float = OpTypePointer Function %float %main = OpFunction %void None %3 %5 = OpLabel %36 = OpVariable %_ptr_Function_v4float Function %38 = OpAccessChain %_ptr_UniformConstant_13 %samplers %int_0 %39 = OpLoad %13 %38 %40 = OpImageSampleExplicitLod %v4float %39 %26 Lod %float_0 OpStore %36 %40 %41 = OpAccessChain %_ptr_Function_float %36 %uint_0 %42 = OpLoad %float %41 %43 = OpExtInst %void %33 1 %28 %42 OpReturn OpFunctionEnd %foo_ = OpFunction %void None %3 %7 = OpLabel %c = OpVariable %_ptr_Function_v4float Function %22 = OpAccessChain %_ptr_UniformConstant_13 %samplers %int_0 %23 = OpLoad %13 %22 %27 = OpImageSampleExplicitLod %v4float %23 %26 Lod %float_0 OpStore %c %27 %31 = OpAccessChain %_ptr_Function_float %c %uint_0 %32 = OpLoad %float %31 %34 = OpExtInst %void %33 1 %28 %32 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_2); SinglePassRunAndMatch(text, true); } TEST_F(EliminateDeadFunctionsBasicTest, DependentNonSemanticChain) { const std::string text = R"( ; CHECK: OpEntryPoint GLCompute [[main:%\w+]] ; CHECK: [[main]] = OpFunction ; CHECK-NOT: = OpFunction ; CHECK: [[ext1:%\w+]] = OpExtInst %void {{%\w+}} 1 [[main]] ; CHECK: [[ext2:%\w+]] = OpExtInst %void {{%\w+}} 2 [[ext1]] ; CHECK: [[ext3:%\w+]] = OpExtInst %void {{%\w+}} 3 [[ext1]] [[ext2]] OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %1 = OpExtInstImport "NonSemantic.Test" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %main_entry = OpLabel OpReturn OpFunctionEnd %dead = OpFunction %void None %void_fn %dead_entry = OpLabel OpReturn OpFunctionEnd %2 = OpExtInst %void %1 1 %main %3 = OpExtInst %void %1 2 %2 %4 = OpExtInst %void %1 3 %2 %3 )"; SetTargetEnv(SPV_ENV_VULKAN_1_0); SinglePassRunAndMatch(text, true); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/eliminate_dead_io_components_test.cpp000066400000000000000000001400161475742701700277370ustar00rootroot00000000000000// Copyright (c) 2022 The Khronos Group Inc. // Copyright (c) 2022 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using ElimDeadIOComponentsTest = PassTest<::testing::Test>; TEST_F(ElimDeadIOComponentsTest, ElimOneConstantIndex) { // Should reduce to uv[2] // // #version 450 // // layout(location = 0) in vec4 uv[8]; // // out gl_PerVertex { // vec4 gl_Position; // }; // // void main() // { // gl_Position = uv[1]; // } const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %_ %uv OpSource GLSL 450 OpName %main "main" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpName %_ "" OpName %uv "uv" OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpDecorate %gl_PerVertex Block OpDecorate %uv Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %gl_PerVertex = OpTypeStruct %v4float %_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex %_ = OpVariable %_ptr_Output_gl_PerVertex Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %uint_8 = OpConstant %uint 8 %_arr_v4float_uint_8 = OpTypeArray %v4float %uint_8 %_ptr_Input__arr_v4float_uint_8 = OpTypePointer Input %_arr_v4float_uint_8 %uv = OpVariable %_ptr_Input__arr_v4float_uint_8 Input %int_1 = OpConstant %int 1 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float ;CHECK-NOT: %uv = OpVariable %_ptr_Input__arr_v4float_uint_8 Input ;CHECK: %uv = OpVariable %_ptr_Input__arr_v4float_uint_2 Input %main = OpFunction %void None %3 %5 = OpLabel %20 = OpAccessChain %_ptr_Input_v4float %uv %int_1 %21 = OpLoad %v4float %20 %23 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %23 %21 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch( text, true, spv::StorageClass::Input, false); } TEST_F(ElimDeadIOComponentsTest, ElimOneConstantIndexInBounds) { // Same as ElimOneConstantIndex but with OpInBoundsAccessChain const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %_ %uv OpSource GLSL 450 OpName %main "main" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpName %_ "" OpName %uv "uv" OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpDecorate %gl_PerVertex Block OpDecorate %uv Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %gl_PerVertex = OpTypeStruct %v4float %_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex %_ = OpVariable %_ptr_Output_gl_PerVertex Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %uint_8 = OpConstant %uint 8 %_arr_v4float_uint_8 = OpTypeArray %v4float %uint_8 %_ptr_Input__arr_v4float_uint_8 = OpTypePointer Input %_arr_v4float_uint_8 %uv = OpVariable %_ptr_Input__arr_v4float_uint_8 Input %int_1 = OpConstant %int 1 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float ;CHECK-NOT: %uv = OpVariable %_ptr_Input__arr_v4float_uint_8 Input ;CHECK: %uv = OpVariable %_ptr_Input__arr_v4float_uint_2 Input %main = OpFunction %void None %3 %5 = OpLabel %20 = OpInBoundsAccessChain %_ptr_Input_v4float %uv %int_1 %21 = OpLoad %v4float %20 %23 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %23 %21 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch( text, true, spv::StorageClass::Input, false); } TEST_F(ElimDeadIOComponentsTest, ElimTwoConstantIndices) { // Should reduce to uv[4] // // #version 450 // // layout(location = 0) in vec4 uv[8]; // // out gl_PerVertex { // vec4 gl_Position; // }; // // void main() // { // gl_Position = uv[1] + uv[3]; // } const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %_ %uv OpSource GLSL 450 OpName %main "main" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpName %_ "" OpName %uv "uv" OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpDecorate %gl_PerVertex Block OpDecorate %uv Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %gl_PerVertex = OpTypeStruct %v4float %_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex %_ = OpVariable %_ptr_Output_gl_PerVertex Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %uint_8 = OpConstant %uint 8 %_arr_v4float_uint_8 = OpTypeArray %v4float %uint_8 %_ptr_Input__arr_v4float_uint_8 = OpTypePointer Input %_arr_v4float_uint_8 %uv = OpVariable %_ptr_Input__arr_v4float_uint_8 Input %int_1 = OpConstant %int 1 %_ptr_Input_v4float = OpTypePointer Input %v4float %int_3 = OpConstant %int 3 %_ptr_Output_v4float = OpTypePointer Output %v4float ;CHECK-NOT: %uv = OpVariable %_ptr_Input__arr_v4float_uint_8 Input ;CHECK: %uv = OpVariable %_ptr_Input__arr_v4float_uint_4 Input %main = OpFunction %void None %3 %5 = OpLabel %20 = OpAccessChain %_ptr_Input_v4float %uv %int_1 %21 = OpLoad %v4float %20 %23 = OpAccessChain %_ptr_Input_v4float %uv %int_3 %24 = OpLoad %v4float %23 %25 = OpFAdd %v4float %21 %24 %27 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %27 %25 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch( text, true, spv::StorageClass::Input, false); } TEST_F(ElimDeadIOComponentsTest, NoElimMaxConstantIndex) { // Should not reduce uv[8] because of max index of 7 // // #version 450 // // layout(location = 0) in vec4 uv[8]; // // out gl_PerVertex { // vec4 gl_Position; // }; // // void main() // { // gl_Position = uv[1] + uv[7]; // } const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %_ %uv OpSource GLSL 450 OpName %main "main" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpName %_ "" OpName %uv "uv" OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpDecorate %gl_PerVertex Block OpDecorate %uv Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %gl_PerVertex = OpTypeStruct %v4float %_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex %_ = OpVariable %_ptr_Output_gl_PerVertex Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %uint_8 = OpConstant %uint 8 %_arr_v4float_uint_8 = OpTypeArray %v4float %uint_8 %_ptr_Input__arr_v4float_uint_8 = OpTypePointer Input %_arr_v4float_uint_8 %uv = OpVariable %_ptr_Input__arr_v4float_uint_8 Input %int_1 = OpConstant %int 1 %_ptr_Input_v4float = OpTypePointer Input %v4float %int_7 = OpConstant %int 7 %_ptr_Output_v4float = OpTypePointer Output %v4float ;CHECK: %uv = OpVariable %_ptr_Input__arr_v4float_uint_8 Input %main = OpFunction %void None %3 %5 = OpLabel %20 = OpAccessChain %_ptr_Input_v4float %uv %int_1 %21 = OpLoad %v4float %20 %23 = OpAccessChain %_ptr_Input_v4float %uv %int_7 %24 = OpLoad %v4float %23 %25 = OpFAdd %v4float %21 %24 %27 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %27 %25 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch( text, true, spv::StorageClass::Input, false); } TEST_F(ElimDeadIOComponentsTest, NoElimNonConstantIndex) { // Should not reduce uv[8] because of non-constant index of ui // // #version 450 // // layout(location = 0) in vec4 uv[8]; // // out gl_PerVertex { // vec4 gl_Position; // }; // // uniform ubname { // int ui; // } ubinst; // // void main() // { // gl_Position = uv[1] + uv[ubinst.ui]; // } const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %_ %uv %ubinst OpSource GLSL 450 OpName %main "main" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpName %_ "" OpName %uv "uv" OpName %ubname "ubname" OpMemberName %ubname 0 "ui" OpName %ubinst "ubinst" OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpDecorate %gl_PerVertex Block OpDecorate %uv Location 0 OpMemberDecorate %ubname 0 Offset 0 OpDecorate %ubname Block OpDecorate %ubinst DescriptorSet 0 OpDecorate %ubinst Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %gl_PerVertex = OpTypeStruct %v4float %_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex %_ = OpVariable %_ptr_Output_gl_PerVertex Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %uint_8 = OpConstant %uint 8 %_arr_v4float_uint_8 = OpTypeArray %v4float %uint_8 %_ptr_Input__arr_v4float_uint_8 = OpTypePointer Input %_arr_v4float_uint_8 %uv = OpVariable %_ptr_Input__arr_v4float_uint_8 Input %int_1 = OpConstant %int 1 %_ptr_Input_v4float = OpTypePointer Input %v4float %ubname = OpTypeStruct %int %_ptr_Uniform_ubname = OpTypePointer Uniform %ubname %ubinst = OpVariable %_ptr_Uniform_ubname Uniform %_ptr_Uniform_int = OpTypePointer Uniform %int %_ptr_Output_v4float = OpTypePointer Output %v4float ;CHECK: %uv = OpVariable %_ptr_Input__arr_v4float_uint_8 Input %main = OpFunction %void None %3 %5 = OpLabel %20 = OpAccessChain %_ptr_Input_v4float %uv %int_1 %21 = OpLoad %v4float %20 %26 = OpAccessChain %_ptr_Uniform_int %ubinst %int_0 %27 = OpLoad %int %26 %28 = OpAccessChain %_ptr_Input_v4float %uv %27 %29 = OpLoad %v4float %28 %30 = OpFAdd %v4float %21 %29 %32 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %32 %30 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch( text, true, spv::StorageClass::Input, false); } TEST_F(ElimDeadIOComponentsTest, NoElimNonIndexedAccessChain) { // Should not change due to non-indexed access chain const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %_ %uv OpSource GLSL 450 OpName %main "main" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpName %_ "" OpName %uv "uv" OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpDecorate %gl_PerVertex Block OpDecorate %uv Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %gl_PerVertex = OpTypeStruct %v4float %_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex %_ = OpVariable %_ptr_Output_gl_PerVertex Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %uint_8 = OpConstant %uint 8 %_arr_v4float_uint_8 = OpTypeArray %v4float %uint_8 %_ptr_Input__arr_v4float_uint_8 = OpTypePointer Input %_arr_v4float_uint_8 %uv = OpVariable %_ptr_Input__arr_v4float_uint_8 Input %int_1 = OpConstant %int 1 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float ;CHECK: %uv = OpVariable %_ptr_Input__arr_v4float_uint_8 Input %main = OpFunction %void None %3 %5 = OpLabel %20 = OpAccessChain %_ptr_Input__arr_v4float_uint_8 %uv OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch( text, true, spv::StorageClass::Input, false); } TEST_F(ElimDeadIOComponentsTest, ElimStructMember) { // Should eliminate uv // // #version 450 // // in Vertex { // vec4 Cd; // vec2 uv; // } iVert; // // out vec4 fragColor; // // void main() // { // vec4 color = vec4(iVert.Cd); // fragColor = color; // } const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %iVert %fragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %Vertex "Vertex" OpMemberName %Vertex 0 "Cd" OpMemberName %Vertex 1 "uv" OpName %iVert "iVert" OpName %fragColor "fragColor" OpDecorate %Vertex Block OpDecorate %iVert Location 0 OpDecorate %fragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %v2float = OpTypeVector %float 2 %Vertex = OpTypeStruct %v4float %v2float ; CHECK: %Vertex = OpTypeStruct %v4float %v2float ; CHECK: %Vertex_0 = OpTypeStruct %v4float %_ptr_Input_Vertex = OpTypePointer Input %Vertex ; CHECK: [[pty:%\w+]] = OpTypePointer Input %Vertex_0 %iVert = OpVariable %_ptr_Input_Vertex Input ; CHECK: %iVert = OpVariable [[pty]] Input %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %fragColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %3 %5 = OpLabel %17 = OpAccessChain %_ptr_Input_v4float %iVert %int_0 %18 = OpLoad %v4float %17 OpStore %fragColor %18 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch( text, true, spv::StorageClass::Input, false); } TEST_F(ElimDeadIOComponentsTest, ElimOutputStructMember) { // Should eliminate uv from Vertex and all but gl_Position from gl_PerVertex // // #version 450 // // out Vertex { // vec4 Cd; // vec2 uv; // } oVert; // // in vec3 P; // // void main() // { // vec4 worldSpacePos = vec4(P, 1); // oVert.Cd = vec4(1, 0.5, 0, 1); // gl_Position = worldSpacePos; // } const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %P %oVert %_ OpSource GLSL 450 OpName %main "main" OpName %P "P" OpName %Vertex "Vertex" OpMemberName %Vertex 0 "Cd" OpMemberName %Vertex 1 "uv" OpName %oVert "oVert" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpMemberName %gl_PerVertex 1 "gl_PointSize" OpMemberName %gl_PerVertex 2 "gl_ClipDistance" OpMemberName %gl_PerVertex 3 "gl_CullDistance" OpName %_ "" OpDecorate %P Location 0 OpDecorate %Vertex Block OpDecorate %oVert Location 0 OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex 3 BuiltIn CullDistance OpDecorate %gl_PerVertex Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %v3float = OpTypeVector %float 3 %_ptr_Input_v3float = OpTypePointer Input %v3float %P = OpVariable %_ptr_Input_v3float Input %float_1 = OpConstant %float 1 %v2float = OpTypeVector %float 2 %Vertex = OpTypeStruct %v4float %v2float %_ptr_Output_Vertex = OpTypePointer Output %Vertex %oVert = OpVariable %_ptr_Output_Vertex Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float_0_5 = OpConstant %float 0.5 %float_0 = OpConstant %float 0 %27 = OpConstantComposite %v4float %float_1 %float_0_5 %float_0 %float_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex %_ = OpVariable %_ptr_Output_gl_PerVertex Output ; CHECK: %Vertex = OpTypeStruct %v4float %v2float ; CHECK: %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 ; CHECK: %_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex ; CHECK: [[sty:%\w+]] = OpTypeStruct %v4float ; CHECK: [[pty:%\w+]] = OpTypePointer Output [[sty]] ; CHECK: %oVert = OpVariable [[pty]] Output ; CHECK: [[sty2:%\w+]] = OpTypeStruct %v4float ; CHECK: [[pty2:%\w+]] = OpTypePointer Output [[sty2]] ; CHECK: %_ = OpVariable [[pty2]] Output %main = OpFunction %void None %3 %5 = OpLabel %13 = OpLoad %v3float %P %15 = OpCompositeExtract %float %13 0 %16 = OpCompositeExtract %float %13 1 %17 = OpCompositeExtract %float %13 2 %18 = OpCompositeConstruct %v4float %15 %16 %17 %float_1 %29 = OpAccessChain %_ptr_Output_v4float %oVert %int_0 OpStore %29 %27 %37 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %37 %18 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch( text, true, spv::StorageClass::Output, false); } TEST_F(ElimDeadIOComponentsTest, ElimOutputArrayMembers) { // Should reduce to uv[2] // // #version 450 // // layout(location = 0) out vec2 uv[8]; // // void main() // { // uv[1] = vec2(1, 0.5); // } const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %uv OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %uv "uv" OpDecorate %uv Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %uint = OpTypeInt 32 0 %uint_8 = OpConstant %uint 8 %_arr_v2float_uint_8 = OpTypeArray %v2float %uint_8 %_ptr_Output__arr_v2float_uint_8 = OpTypePointer Output %_arr_v2float_uint_8 %uv = OpVariable %_ptr_Output__arr_v2float_uint_8 Output ;CHECK-NOT: %uv = OpVariable %_ptr_Output__arr_v2float_uint_8 Output ;CHECK: %uv = OpVariable %_ptr_Output__arr_v2float_uint_2 Output %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %float_1 = OpConstant %float 1 %float_0_5 = OpConstant %float 0.5 %17 = OpConstantComposite %v2float %float_1 %float_0_5 %_ptr_Output_v2float = OpTypePointer Output %v2float %main = OpFunction %void None %3 %5 = OpLabel %19 = OpAccessChain %_ptr_Output_v2float %uv %int_1 OpStore %19 %17 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch( text, true, spv::StorageClass::Output, false); } TEST_F(ElimDeadIOComponentsTest, VertexOnly) { // Should NOT eliminate uv // // #version 450 // // in Vertex { // vec4 Cd; // vec2 uv; // } iVert; // // out vec4 fragColor; // // void main() // { // vec4 color = vec4(iVert.Cd); // fragColor = color; // } const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %iVert %fragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %Vertex "Vertex" OpMemberName %Vertex 0 "Cd" OpMemberName %Vertex 1 "uv" OpName %iVert "iVert" OpName %fragColor "fragColor" OpDecorate %Vertex Block OpDecorate %iVert Location 0 OpDecorate %fragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %v2float = OpTypeVector %float 2 %Vertex = OpTypeStruct %v4float %v2float ; CHECK: %Vertex = OpTypeStruct %v4float %v2float %_ptr_Input_Vertex = OpTypePointer Input %Vertex ; CHECK: %_ptr_Input_Vertex = OpTypePointer Input %Vertex %iVert = OpVariable %_ptr_Input_Vertex Input ; CHECK: %iVert = OpVariable %_ptr_Input_Vertex Input %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %fragColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %3 %5 = OpLabel %17 = OpAccessChain %_ptr_Input_v4float %iVert %int_0 %18 = OpLoad %v4float %17 OpStore %fragColor %18 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch( text, true, spv::StorageClass::Input, true); } TEST_F(ElimDeadIOComponentsTest, TescInput) { // Eliminate PointSize, ClipDistance, CullDistance from gl_in[] // // #version 450 // // layout (vertices = 4) out; // // void main() // { // vec4 pos = gl_in[gl_InvocationID].gl_Position; // gl_out[gl_InvocationID].gl_Position = pos; // } const std::string text = R"( OpCapability Tessellation %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %main "main" %gl_in %gl_InvocationID %gl_out OpExecutionMode %main OutputVertices 4 OpSource GLSL 450 OpName %main "main" OpName %pos "pos" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpMemberName %gl_PerVertex 1 "gl_PointSize" OpMemberName %gl_PerVertex 2 "gl_ClipDistance" OpMemberName %gl_PerVertex 3 "gl_CullDistance" OpName %gl_in "gl_in" OpName %gl_InvocationID "gl_InvocationID" OpName %gl_PerVertex_0 "gl_PerVertex" OpMemberName %gl_PerVertex_0 0 "gl_Position" OpName %gl_out "gl_out" OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex 3 BuiltIn CullDistance OpDecorate %gl_PerVertex Block OpDecorate %gl_InvocationID BuiltIn InvocationId OpMemberDecorate %gl_PerVertex_0 0 BuiltIn Position OpDecorate %gl_PerVertex_0 Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %uint_32 = OpConstant %uint 32 %_arr_gl_PerVertex_uint_32 = OpTypeArray %gl_PerVertex %uint_32 %_ptr_Input__arr_gl_PerVertex_uint_32 = OpTypePointer Input %_arr_gl_PerVertex_uint_32 %gl_in = OpVariable %_ptr_Input__arr_gl_PerVertex_uint_32 Input %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %gl_InvocationID = OpVariable %_ptr_Input_int Input %int_0 = OpConstant %int 0 %_ptr_Input_v4float = OpTypePointer Input %v4float %gl_PerVertex_0 = OpTypeStruct %v4float %uint_4 = OpConstant %uint 4 %_arr_gl_PerVertex_0_uint_4 = OpTypeArray %gl_PerVertex_0 %uint_4 %_ptr_Output__arr_gl_PerVertex_0_uint_4 = OpTypePointer Output %_arr_gl_PerVertex_0_uint_4 %gl_out = OpVariable %_ptr_Output__arr_gl_PerVertex_0_uint_4 Output %_ptr_Output_v4float = OpTypePointer Output %v4float ; CHECK: %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 ; CHECK: [[sty:%\w+]] = OpTypeStruct %v4float ; CHECK: [[asty:%\w+]] = OpTypeArray [[sty]] %uint_32 ; CHECK: [[pasty:%\w+]] = OpTypePointer Input [[asty]] ; CHECK: %gl_in = OpVariable [[pasty]] Input %main = OpFunction %void None %3 %5 = OpLabel %pos = OpVariable %_ptr_Function_v4float Function %21 = OpLoad %int %gl_InvocationID %24 = OpAccessChain %_ptr_Input_v4float %gl_in %21 %int_0 %25 = OpLoad %v4float %24 OpStore %pos %25 %31 = OpLoad %int %gl_InvocationID %32 = OpLoad %v4float %pos %34 = OpAccessChain %_ptr_Output_v4float %gl_out %31 %int_0 OpStore %34 %32 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch( text, true, spv::StorageClass::Input, false); } TEST_F(ElimDeadIOComponentsTest, TescOutput) { // Eliminate PointSize, ClipDistance, CullDistance from gl_out[] // // #version 450 // // layout (vertices = 4) out; // // void main() // { // vec4 pos = gl_in[gl_InvocationID].gl_Position; // gl_out[gl_InvocationID].gl_Position = pos; // } const std::string text = R"( OpCapability Tessellation %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %main "main" %gl_in %gl_InvocationID %gl_out OpExecutionMode %main OutputVertices 4 OpSource GLSL 450 OpName %main "main" OpName %pos "pos" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpName %gl_in "gl_in" OpName %gl_InvocationID "gl_InvocationID" OpName %gl_PerVertex_0 "gl_PerVertex" OpMemberName %gl_PerVertex_0 0 "gl_Position" OpMemberName %gl_PerVertex_0 1 "gl_PointSize" OpMemberName %gl_PerVertex_0 2 "gl_ClipDistance" OpMemberName %gl_PerVertex_0 3 "gl_CullDistance" OpName %gl_out "gl_out" OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpDecorate %gl_PerVertex Block OpDecorate %gl_InvocationID BuiltIn InvocationId OpMemberDecorate %gl_PerVertex_0 0 BuiltIn Position OpMemberDecorate %gl_PerVertex_0 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex_0 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex_0 3 BuiltIn CullDistance OpDecorate %gl_PerVertex_0 Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %uint_32 = OpConstant %uint 32 %_arr_gl_PerVertex_uint_32 = OpTypeArray %gl_PerVertex %uint_32 %_ptr_Input__arr_gl_PerVertex_uint_32 = OpTypePointer Input %_arr_gl_PerVertex_uint_32 %gl_in = OpVariable %_ptr_Input__arr_gl_PerVertex_uint_32 Input %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %gl_InvocationID = OpVariable %_ptr_Input_int Input %int_0 = OpConstant %int 0 %_ptr_Input_v4float = OpTypePointer Input %v4float %gl_PerVertex_0 = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %uint_4 = OpConstant %uint 4 %_arr_gl_PerVertex_0_uint_4 = OpTypeArray %gl_PerVertex_0 %uint_4 %_ptr_Output__arr_gl_PerVertex_0_uint_4 = OpTypePointer Output %_arr_gl_PerVertex_0_uint_4 %gl_out = OpVariable %_ptr_Output__arr_gl_PerVertex_0_uint_4 Output %_ptr_Output_v4float = OpTypePointer Output %v4float ; CHECK: [[sty:%\w+]] = OpTypeStruct %v4float ; CHECK: [[asty:%\w+]] = OpTypeArray [[sty]] %uint_4 ; CHECK: [[pasty:%\w+]] = OpTypePointer Output [[asty]] ; CHECK: %gl_out = OpVariable [[pasty]] Output %main = OpFunction %void None %3 %5 = OpLabel %pos = OpVariable %_ptr_Function_v4float Function %21 = OpLoad %int %gl_InvocationID %24 = OpAccessChain %_ptr_Input_v4float %gl_in %21 %int_0 %25 = OpLoad %v4float %24 OpStore %pos %25 %31 = OpLoad %int %gl_InvocationID %32 = OpLoad %v4float %pos %34 = OpAccessChain %_ptr_Output_v4float %gl_out %31 %int_0 OpStore %34 %32 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch( text, true, spv::StorageClass::Output, false); } TEST_F(ElimDeadIOComponentsTest, TeseInput) { // Eliminate PointSize, ClipDistance, CullDistance from gl_in[] // // #version 450 // // layout(triangles, ccw) in; // layout(fractional_odd_spacing) in; // layout(point_mode) in; // // void main() // { // vec4 p = gl_in[1].gl_Position; // gl_Position = p; // } const std::string text = R"( OpCapability Tessellation %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint TessellationEvaluation %main "main" %gl_in %_ OpExecutionMode %main Triangles OpExecutionMode %main SpacingFractionalOdd OpExecutionMode %main VertexOrderCcw OpExecutionMode %main PointMode OpSource GLSL 450 OpName %main "main" OpName %p "p" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpMemberName %gl_PerVertex 1 "gl_PointSize" OpMemberName %gl_PerVertex 2 "gl_ClipDistance" OpMemberName %gl_PerVertex 3 "gl_CullDistance" OpName %gl_in "gl_in" OpName %gl_PerVertex_0 "gl_PerVertex" OpMemberName %gl_PerVertex_0 0 "gl_Position" OpName %_ "" OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex 3 BuiltIn CullDistance OpDecorate %gl_PerVertex Block OpMemberDecorate %gl_PerVertex_0 0 BuiltIn Position OpDecorate %gl_PerVertex_0 Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %uint_32 = OpConstant %uint 32 %_arr_gl_PerVertex_uint_32 = OpTypeArray %gl_PerVertex %uint_32 %_ptr_Input__arr_gl_PerVertex_uint_32 = OpTypePointer Input %_arr_gl_PerVertex_uint_32 %gl_in = OpVariable %_ptr_Input__arr_gl_PerVertex_uint_32 Input %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %int_0 = OpConstant %int 0 %_ptr_Input_v4float = OpTypePointer Input %v4float %gl_PerVertex_0 = OpTypeStruct %v4float %_ptr_Output_gl_PerVertex_0 = OpTypePointer Output %gl_PerVertex_0 %_ = OpVariable %_ptr_Output_gl_PerVertex_0 Output %_ptr_Output_v4float = OpTypePointer Output %v4float ; CHECK: %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 ; CHECK: [[sty:%\w+]] = OpTypeStruct %v4float ; CHECK: [[asty:%\w+]] = OpTypeArray [[sty]] %uint_32 ; CHECK: [[pasty:%\w+]] = OpTypePointer Input [[asty]] ; CHECK: %gl_in = OpVariable [[pasty]] Input %main = OpFunction %void None %3 %5 = OpLabel %p = OpVariable %_ptr_Function_v4float Function %22 = OpAccessChain %_ptr_Input_v4float %gl_in %int_1 %int_0 %23 = OpLoad %v4float %22 OpStore %p %23 %27 = OpLoad %v4float %p %29 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %29 %27 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch( text, true, spv::StorageClass::Input, false); } TEST_F(ElimDeadIOComponentsTest, TeseOutput) { // Eliminate PointSize, ClipDistance, CullDistance from gl_out // // #version 450 // // layout(triangles, ccw) in; // layout(fractional_odd_spacing) in; // layout(point_mode) in; // // void main() // { // vec4 p = gl_in[1].gl_Position; // gl_Position = p; // } const std::string text = R"( OpCapability Tessellation %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint TessellationEvaluation %main "main" %gl_in %_ OpExecutionMode %main Triangles OpExecutionMode %main SpacingFractionalOdd OpExecutionMode %main VertexOrderCcw OpExecutionMode %main PointMode OpSource GLSL 450 OpName %main "main" OpName %p "p" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpName %gl_in "gl_in" OpName %gl_PerVertex_0 "gl_PerVertex" OpMemberName %gl_PerVertex_0 0 "gl_Position" OpMemberName %gl_PerVertex_0 1 "gl_PointSize" OpMemberName %gl_PerVertex_0 2 "gl_ClipDistance" OpMemberName %gl_PerVertex_0 3 "gl_CullDistance" OpName %_ "" OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpDecorate %gl_PerVertex Block OpMemberDecorate %gl_PerVertex_0 0 BuiltIn Position OpMemberDecorate %gl_PerVertex_0 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex_0 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex_0 3 BuiltIn CullDistance OpDecorate %gl_PerVertex_0 Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %uint_32 = OpConstant %uint 32 %_arr_gl_PerVertex_uint_32 = OpTypeArray %gl_PerVertex %uint_32 %_ptr_Input__arr_gl_PerVertex_uint_32 = OpTypePointer Input %_arr_gl_PerVertex_uint_32 %gl_in = OpVariable %_ptr_Input__arr_gl_PerVertex_uint_32 Input %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %int_0 = OpConstant %int 0 %_ptr_Input_v4float = OpTypePointer Input %v4float %gl_PerVertex_0 = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %_ptr_Output_gl_PerVertex_0 = OpTypePointer Output %gl_PerVertex_0 %_ = OpVariable %_ptr_Output_gl_PerVertex_0 Output %_ptr_Output_v4float = OpTypePointer Output %v4float ; CHECK: %_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex ; CHECK: %_ = OpVariable %_ptr_Output_gl_PerVertex Output %main = OpFunction %void None %3 %5 = OpLabel %p = OpVariable %_ptr_Function_v4float Function %22 = OpAccessChain %_ptr_Input_v4float %gl_in %int_1 %int_0 %23 = OpLoad %v4float %22 OpStore %p %23 %27 = OpLoad %v4float %p %29 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %29 %27 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch( text, true, spv::StorageClass::Output, false); } TEST_F(ElimDeadIOComponentsTest, GeomInput) { // Eliminate PointSize, ClipDistance, CullDistance from gl_in[] // // #version 450 // // layout(triangle_strip, max_vertices = 3) out; // layout(triangles) in; // // void main() // { // for (int i = 0; i < 3; i++) // { // gl_Position = gl_in[i].gl_Position; // EmitVertex(); // } // EndPrimitive(); // } const std::string text = R"( OpCapability Geometry %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Geometry %main "main" %_ %gl_in OpExecutionMode %main Triangles OpExecutionMode %main Invocations 1 OpExecutionMode %main OutputTriangleStrip OpExecutionMode %main OutputVertices 3 OpSource GLSL 460 OpName %main "main" OpName %i "i" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpName %_ "" OpName %gl_PerVertex_0 "gl_PerVertex" OpMemberName %gl_PerVertex_0 0 "gl_Position" OpMemberName %gl_PerVertex_0 1 "gl_PointSize" OpMemberName %gl_PerVertex_0 2 "gl_ClipDistance" OpMemberName %gl_PerVertex_0 3 "gl_CullDistance" OpName %gl_in "gl_in" OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpDecorate %gl_PerVertex Block OpMemberDecorate %gl_PerVertex_0 0 BuiltIn Position OpMemberDecorate %gl_PerVertex_0 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex_0 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex_0 3 BuiltIn CullDistance OpDecorate %gl_PerVertex_0 Block %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_3 = OpConstant %int 3 %bool = OpTypeBool %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex %_ = OpVariable %_ptr_Output_gl_PerVertex Output %gl_PerVertex_0 = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %uint_3 = OpConstant %uint 3 %_arr_gl_PerVertex_0_uint_3 = OpTypeArray %gl_PerVertex_0 %uint_3 %_ptr_Input__arr_gl_PerVertex_0_uint_3 = OpTypePointer Input %_arr_gl_PerVertex_0_uint_3 %gl_in = OpVariable %_ptr_Input__arr_gl_PerVertex_0_uint_3 Input %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %int_1 = OpConstant %int 1 ; CHECK: [[asty:%\w+]] = OpTypeArray %gl_PerVertex %uint_3 ; CHECK: [[pasty:%\w+]] = OpTypePointer Input [[asty]] ; CHECK: %gl_in = OpVariable [[pasty]] Input %main = OpFunction %void None %3 %5 = OpLabel %i = OpVariable %_ptr_Function_int Function OpStore %i %int_0 OpBranch %10 %10 = OpLabel OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %15 = OpLoad %int %i %18 = OpSLessThan %bool %15 %int_3 OpBranchConditional %18 %11 %12 %11 = OpLabel %32 = OpLoad %int %i %34 = OpAccessChain %_ptr_Input_v4float %gl_in %32 %int_0 %35 = OpLoad %v4float %34 %37 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %37 %35 OpEmitVertex OpBranch %13 %13 = OpLabel %38 = OpLoad %int %i %40 = OpIAdd %int %38 %int_1 OpStore %i %40 OpBranch %10 %12 = OpLabel OpEndPrimitive OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch( text, true, spv::StorageClass::Input, false); } TEST_F(ElimDeadIOComponentsTest, GeomOutput) { // Eliminate PointSize, ClipDistance, CullDistance from gl_out // // #version 450 // // layout(triangle_strip, max_vertices = 3) out; // layout(triangles) in; // // void main() // { // for (int i = 0; i < 3; i++) // { // gl_Position = gl_in[i].gl_Position; // EmitVertex(); // } // EndPrimitive(); // } const std::string text = R"( OpCapability Geometry %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Geometry %main "main" %_ %gl_in OpExecutionMode %main Triangles OpExecutionMode %main Invocations 1 OpExecutionMode %main OutputTriangleStrip OpExecutionMode %main OutputVertices 3 OpSource GLSL 460 OpName %main "main" OpName %i "i" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpMemberName %gl_PerVertex 1 "gl_PointSize" OpMemberName %gl_PerVertex 2 "gl_ClipDistance" OpMemberName %gl_PerVertex 3 "gl_CullDistance" OpName %_ "" OpName %gl_PerVertex_0 "gl_PerVertex" OpMemberName %gl_PerVertex_0 0 "gl_Position" OpName %gl_in "gl_in" OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex 3 BuiltIn CullDistance OpDecorate %gl_PerVertex Block OpMemberDecorate %gl_PerVertex_0 0 BuiltIn Position OpDecorate %gl_PerVertex_0 Block %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_3 = OpConstant %int 3 %bool = OpTypeBool %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex %_ = OpVariable %_ptr_Output_gl_PerVertex Output %gl_PerVertex_0 = OpTypeStruct %v4float %uint_3 = OpConstant %uint 3 %_arr_gl_PerVertex_0_uint_3 = OpTypeArray %gl_PerVertex_0 %uint_3 %_ptr_Input__arr_gl_PerVertex_0_uint_3 = OpTypePointer Input %_arr_gl_PerVertex_0_uint_3 %gl_in = OpVariable %_ptr_Input__arr_gl_PerVertex_0_uint_3 Input %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %int_1 = OpConstant %int 1 ; CHECK: %_ptr_Output_gl_PerVertex_0 = OpTypePointer Output %gl_PerVertex_0 ; CHECK: %_ = OpVariable %_ptr_Output_gl_PerVertex_0 Output %main = OpFunction %void None %3 %5 = OpLabel %i = OpVariable %_ptr_Function_int Function OpStore %i %int_0 OpBranch %10 %10 = OpLabel OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %15 = OpLoad %int %i %18 = OpSLessThan %bool %15 %int_3 OpBranchConditional %18 %11 %12 %11 = OpLabel %32 = OpLoad %int %i %34 = OpAccessChain %_ptr_Input_v4float %gl_in %32 %int_0 %35 = OpLoad %v4float %34 %37 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %37 %35 OpEmitVertex OpBranch %13 %13 = OpLabel %38 = OpLoad %int %i %40 = OpIAdd %int %38 %int_1 OpStore %i %40 OpBranch %10 %12 = OpLabel OpEndPrimitive OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch( text, true, spv::StorageClass::Output, false); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/eliminate_dead_member_test.cpp000066400000000000000000001570561475742701700263460ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "assembly_builder.h" #include "pass_fixture.h" #include "pass_utils.h" namespace { using namespace spvtools; using EliminateDeadMemberTest = opt::PassTest<::testing::Test>; TEST_F(EliminateDeadMemberTest, RemoveMember1) { // Test that the member "y" is removed. // Update OpMemberName for |y| and |z|. // Update OpMemberDecorate for |y| and |z|. // Update OpAccessChain for access to |z|. const std::string text = R"( ; CHECK: OpName ; CHECK-NEXT: OpMemberName %type__Globals 0 "x" ; CHECK-NEXT: OpMemberName %type__Globals 1 "z" ; CHECK-NOT: OpMemberName ; CHECK: OpMemberDecorate %type__Globals 0 Offset 0 ; CHECK: OpMemberDecorate %type__Globals 1 Offset 8 ; CHECK: %type__Globals = OpTypeStruct %float %float ; CHECK: OpAccessChain %_ptr_Uniform_float %_Globals %int_0 ; CHECK: OpAccessChain %_ptr_Uniform_float %_Globals %uint_1 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %in_var_Position %gl_Position OpSource HLSL 600 OpName %type__Globals "type.$Globals" OpMemberName %type__Globals 0 "x" OpMemberName %type__Globals 1 "y" OpMemberName %type__Globals 2 "z" OpName %_Globals "$Globals" OpName %in_var_Position "in.var.Position" OpName %main "main" OpDecorate %gl_Position BuiltIn Position OpDecorate %in_var_Position Location 0 OpDecorate %_Globals DescriptorSet 0 OpDecorate %_Globals Binding 0 OpMemberDecorate %type__Globals 0 Offset 0 OpMemberDecorate %type__Globals 1 Offset 4 OpMemberDecorate %type__Globals 2 Offset 8 OpDecorate %type__Globals Block %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %int_2 = OpConstant %int 2 %type__Globals = OpTypeStruct %float %float %float %_ptr_Uniform_type__Globals = OpTypePointer Uniform %type__Globals %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %15 = OpTypeFunction %void %_ptr_Uniform_float = OpTypePointer Uniform %float %_Globals = OpVariable %_ptr_Uniform_type__Globals Uniform %in_var_Position = OpVariable %_ptr_Input_v4float Input %gl_Position = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %15 %17 = OpLabel %18 = OpLoad %v4float %in_var_Position %19 = OpAccessChain %_ptr_Uniform_float %_Globals %int_0 %20 = OpLoad %float %19 %21 = OpCompositeExtract %float %18 0 %22 = OpFAdd %float %21 %20 %23 = OpCompositeInsert %v4float %22 %18 0 %24 = OpCompositeExtract %float %18 1 %25 = OpCompositeInsert %v4float %24 %23 1 %26 = OpAccessChain %_ptr_Uniform_float %_Globals %int_2 %27 = OpLoad %float %26 %28 = OpCompositeExtract %float %18 2 %29 = OpFAdd %float %28 %27 %30 = OpCompositeInsert %v4float %29 %25 2 OpStore %gl_Position %30 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(EliminateDeadMemberTest, RemoveMemberWithGroupDecorations) { // Test that the member "y" is removed. // Update OpGroupMemberDecorate for %type__Globals member 1 and 2. // Update OpAccessChain for access to %type__Globals member 2. const std::string text = R"( ; CHECK: OpDecorate [[gr1:%\w+]] Offset 0 ; CHECK: OpDecorate [[gr2:%\w+]] Offset 4 ; CHECK: OpDecorate [[gr3:%\w+]] Offset 8 ; CHECK: [[gr1]] = OpDecorationGroup ; CHECK: [[gr2]] = OpDecorationGroup ; CHECK: [[gr3]] = OpDecorationGroup ; CHECK: OpGroupMemberDecorate [[gr1]] %type__Globals 0 ; CHECK-NOT: OpGroupMemberDecorate [[gr2]] ; CHECK: OpGroupMemberDecorate [[gr3]] %type__Globals 1 ; CHECK: %type__Globals = OpTypeStruct %float %float ; CHECK: OpAccessChain %_ptr_Uniform_float %_Globals %int_0 ; CHECK: OpAccessChain %_ptr_Uniform_float %_Globals %uint_1 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %in_var_Position %gl_Position OpSource HLSL 600 OpName %type__Globals "type.$Globals" OpName %_Globals "$Globals" OpDecorate %gl_Position BuiltIn Position OpDecorate %in_var_Position Location 0 OpDecorate %_Globals DescriptorSet 0 OpDecorate %_Globals Binding 0 OpDecorate %gr1 Offset 0 OpDecorate %gr2 Offset 4 OpDecorate %gr3 Offset 8 OpDecorate %type__Globals Block %gr1 = OpDecorationGroup %gr2 = OpDecorationGroup %gr3 = OpDecorationGroup OpGroupMemberDecorate %gr1 %type__Globals 0 OpGroupMemberDecorate %gr2 %type__Globals 1 OpGroupMemberDecorate %gr3 %type__Globals 2 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %int_2 = OpConstant %int 2 %type__Globals = OpTypeStruct %float %float %float %_ptr_Uniform_type__Globals = OpTypePointer Uniform %type__Globals %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %15 = OpTypeFunction %void %_ptr_Uniform_float = OpTypePointer Uniform %float %_Globals = OpVariable %_ptr_Uniform_type__Globals Uniform %in_var_Position = OpVariable %_ptr_Input_v4float Input %gl_Position = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %15 %17 = OpLabel %18 = OpLoad %v4float %in_var_Position %19 = OpAccessChain %_ptr_Uniform_float %_Globals %int_0 %20 = OpLoad %float %19 %21 = OpCompositeExtract %float %18 0 %22 = OpFAdd %float %21 %20 %23 = OpCompositeInsert %v4float %22 %18 0 %24 = OpCompositeExtract %float %18 1 %25 = OpCompositeInsert %v4float %24 %23 1 %26 = OpAccessChain %_ptr_Uniform_float %_Globals %int_2 %27 = OpLoad %float %26 %28 = OpCompositeExtract %float %18 2 %29 = OpFAdd %float %28 %27 %30 = OpCompositeInsert %v4float %29 %25 2 OpStore %gl_Position %30 OpReturn OpFunctionEnd )"; // Skipping validation because of a bug in the validator. See issue #2376. SinglePassRunAndMatch(text, false); } TEST_F(EliminateDeadMemberTest, RemoveMemberUpdateConstant) { // Test that the member "x" is removed. // Update the OpConstantComposite instruction. const std::string text = R"( ; CHECK: OpName ; CHECK-NEXT: OpMemberName %type__Globals 0 "y" ; CHECK-NEXT: OpMemberName %type__Globals 1 "z" ; CHECK-NOT: OpMemberName ; CHECK: OpMemberDecorate %type__Globals 0 Offset 4 ; CHECK: OpMemberDecorate %type__Globals 1 Offset 8 ; CHECK: %type__Globals = OpTypeStruct %float %float ; CHECK: OpConstantComposite %type__Globals %float_1 %float_2 ; CHECK: OpAccessChain %_ptr_Uniform_float %_Globals %uint_0 ; CHECK: OpAccessChain %_ptr_Uniform_float %_Globals %uint_1 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %in_var_Position %gl_Position OpSource HLSL 600 OpName %type__Globals "type.$Globals" OpMemberName %type__Globals 0 "x" OpMemberName %type__Globals 1 "y" OpMemberName %type__Globals 2 "z" OpName %_Globals "$Globals" OpName %in_var_Position "in.var.Position" OpName %main "main" OpDecorate %gl_Position BuiltIn Position OpDecorate %in_var_Position Location 0 OpDecorate %_Globals DescriptorSet 0 OpDecorate %_Globals Binding 0 OpMemberDecorate %type__Globals 0 Offset 0 OpMemberDecorate %type__Globals 1 Offset 4 OpMemberDecorate %type__Globals 2 Offset 8 OpDecorate %type__Globals Block %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %int_2 = OpConstant %int 2 %type__Globals = OpTypeStruct %float %float %float %13 = OpConstantComposite %type__Globals %float_0 %float_1 %float_2 %_ptr_Uniform_type__Globals = OpTypePointer Uniform %type__Globals %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %19 = OpTypeFunction %void %_ptr_Uniform_float = OpTypePointer Uniform %float %_Globals = OpVariable %_ptr_Uniform_type__Globals Uniform %in_var_Position = OpVariable %_ptr_Input_v4float Input %gl_Position = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %19 %21 = OpLabel %22 = OpLoad %v4float %in_var_Position %23 = OpAccessChain %_ptr_Uniform_float %_Globals %int_1 %24 = OpLoad %float %23 %25 = OpCompositeExtract %float %22 0 %26 = OpFAdd %float %25 %24 %27 = OpCompositeInsert %v4float %26 %22 0 %28 = OpCompositeExtract %float %22 1 %29 = OpCompositeInsert %v4float %28 %27 1 %30 = OpAccessChain %_ptr_Uniform_float %_Globals %int_2 %31 = OpLoad %float %30 %32 = OpCompositeExtract %float %22 2 %33 = OpFAdd %float %32 %31 %34 = OpCompositeInsert %v4float %33 %29 2 OpStore %gl_Position %34 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(EliminateDeadMemberTest, RemoveMemberUpdateCompositeConstruct) { // Test that the member "x" is removed. // Update the OpConstantComposite instruction. const std::string text = R"( ; CHECK: OpName ; CHECK-NEXT: OpMemberName %type__Globals 0 "y" ; CHECK-NEXT: OpMemberName %type__Globals 1 "z" ; CHECK-NOT: OpMemberName ; CHECK: OpMemberDecorate %type__Globals 0 Offset 4 ; CHECK: OpMemberDecorate %type__Globals 1 Offset 8 ; CHECK: %type__Globals = OpTypeStruct %float %float ; CHECK: OpCompositeConstruct %type__Globals %float_1 %float_2 ; CHECK: OpAccessChain %_ptr_Uniform_float %_Globals %uint_0 ; CHECK: OpAccessChain %_ptr_Uniform_float %_Globals %uint_1 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %in_var_Position %gl_Position OpSource HLSL 600 OpName %type__Globals "type.$Globals" OpMemberName %type__Globals 0 "x" OpMemberName %type__Globals 1 "y" OpMemberName %type__Globals 2 "z" OpName %_Globals "$Globals" OpName %in_var_Position "in.var.Position" OpName %main "main" OpDecorate %gl_Position BuiltIn Position OpDecorate %in_var_Position Location 0 OpDecorate %_Globals DescriptorSet 0 OpDecorate %_Globals Binding 0 OpMemberDecorate %type__Globals 0 Offset 0 OpMemberDecorate %type__Globals 1 Offset 4 OpMemberDecorate %type__Globals 2 Offset 8 OpDecorate %type__Globals Block %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %int_2 = OpConstant %int 2 %type__Globals = OpTypeStruct %float %float %float %_ptr_Uniform_type__Globals = OpTypePointer Uniform %type__Globals %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %19 = OpTypeFunction %void %_ptr_Uniform_float = OpTypePointer Uniform %float %_Globals = OpVariable %_ptr_Uniform_type__Globals Uniform %in_var_Position = OpVariable %_ptr_Input_v4float Input %gl_Position = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %19 %21 = OpLabel %13 = OpCompositeConstruct %type__Globals %float_0 %float_1 %float_2 %22 = OpLoad %v4float %in_var_Position %23 = OpAccessChain %_ptr_Uniform_float %_Globals %int_1 %24 = OpLoad %float %23 %25 = OpCompositeExtract %float %22 0 %26 = OpFAdd %float %25 %24 %27 = OpCompositeInsert %v4float %26 %22 0 %28 = OpCompositeExtract %float %22 1 %29 = OpCompositeInsert %v4float %28 %27 1 %30 = OpAccessChain %_ptr_Uniform_float %_Globals %int_2 %31 = OpLoad %float %30 %32 = OpCompositeExtract %float %22 2 %33 = OpFAdd %float %32 %31 %34 = OpCompositeInsert %v4float %33 %29 2 OpStore %gl_Position %34 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(EliminateDeadMemberTest, RemoveMembersUpdateInserExtract1) { // Test that the members "x" and "z" are removed. // Update the OpCompositeExtract instruction. // Remove the OpCompositeInsert instruction since the member being inserted is // dead. const std::string text = R"( ; CHECK: OpName ; CHECK-NEXT: OpMemberName %type__Globals 0 "y" ; CHECK-NOT: OpMemberName ; CHECK: OpMemberDecorate %type__Globals 0 Offset 4 ; CHECK-NOT: OpMemberDecorate %type__Globals 1 Offset ; CHECK: %type__Globals = OpTypeStruct %float ; CHECK: [[ld:%\w+]] = OpLoad %type__Globals %_Globals ; CHECK: OpCompositeExtract %float [[ld]] 0 ; CHECK-NOT: OpCompositeInsert ; CHECK: OpReturn OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource HLSL 600 OpName %type__Globals "type.$Globals" OpMemberName %type__Globals 0 "x" OpMemberName %type__Globals 1 "y" OpMemberName %type__Globals 2 "z" OpName %_Globals "$Globals" OpName %main "main" OpDecorate %_Globals DescriptorSet 0 OpDecorate %_Globals Binding 0 OpMemberDecorate %type__Globals 0 Offset 0 OpMemberDecorate %type__Globals 1 Offset 4 OpMemberDecorate %type__Globals 2 Offset 8 OpDecorate %type__Globals Block %float = OpTypeFloat 32 %type__Globals = OpTypeStruct %float %float %float %_ptr_Uniform_type__Globals = OpTypePointer Uniform %type__Globals %void = OpTypeVoid %7 = OpTypeFunction %void %_Globals = OpVariable %_ptr_Uniform_type__Globals Uniform %main = OpFunction %void None %7 %8 = OpLabel %9 = OpLoad %type__Globals %_Globals %10 = OpCompositeExtract %float %9 1 %11 = OpCompositeInsert %type__Globals %10 %9 2 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(EliminateDeadMemberTest, RemoveMembersUpdateInserExtract2) { // Test that the members "x" and "z" are removed. // Update the OpCompositeExtract instruction. // Update the OpCompositeInsert instruction. const std::string text = R"( ; CHECK: OpName ; CHECK-NEXT: OpMemberName %type__Globals 0 "y" ; CHECK-NOT: OpMemberName ; CHECK: OpMemberDecorate %type__Globals 0 Offset 4 ; CHECK-NOT: OpMemberDecorate %type__Globals 1 Offset ; CHECK: %type__Globals = OpTypeStruct %float ; CHECK: [[ld:%\w+]] = OpLoad %type__Globals %_Globals ; CHECK: [[ex:%\w+]] = OpCompositeExtract %float [[ld]] 0 ; CHECK: OpCompositeInsert %type__Globals [[ex]] [[ld]] 0 ; CHECK: OpReturn OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource HLSL 600 OpName %type__Globals "type.$Globals" OpMemberName %type__Globals 0 "x" OpMemberName %type__Globals 1 "y" OpMemberName %type__Globals 2 "z" OpName %_Globals "$Globals" OpName %main "main" OpDecorate %_Globals DescriptorSet 0 OpDecorate %_Globals Binding 0 OpMemberDecorate %type__Globals 0 Offset 0 OpMemberDecorate %type__Globals 1 Offset 4 OpMemberDecorate %type__Globals 2 Offset 8 OpDecorate %type__Globals Block %float = OpTypeFloat 32 %type__Globals = OpTypeStruct %float %float %float %_ptr_Uniform_type__Globals = OpTypePointer Uniform %type__Globals %void = OpTypeVoid %7 = OpTypeFunction %void %_Globals = OpVariable %_ptr_Uniform_type__Globals Uniform %main = OpFunction %void None %7 %8 = OpLabel %9 = OpLoad %type__Globals %_Globals %10 = OpCompositeExtract %float %9 1 %11 = OpCompositeInsert %type__Globals %10 %9 1 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(EliminateDeadMemberTest, RemoveMembersUpdateInserExtract3) { // Test that the members "x" and "z" are removed, and one member from the // substruct. Update the OpCompositeExtract instruction. Update the // OpCompositeInsert instruction. const std::string text = R"( ; CHECK: OpName ; CHECK-NEXT: OpMemberName %type__Globals 0 "y" ; CHECK-NOT: OpMemberName ; CHECK: OpMemberDecorate %type__Globals 0 Offset 16 ; CHECK-NOT: OpMemberDecorate %type__Globals 1 Offset ; CHECK: OpMemberDecorate [[struct:%\w+]] 0 Offset 4 ; CHECK: [[struct:%\w+]] = OpTypeStruct %float ; CHECK: %type__Globals = OpTypeStruct [[struct]] ; CHECK: [[ld:%\w+]] = OpLoad %type__Globals %_Globals ; CHECK: [[ex:%\w+]] = OpCompositeExtract %float [[ld]] 0 0 ; CHECK: OpCompositeInsert %type__Globals [[ex]] [[ld]] 0 0 ; CHECK: OpReturn OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource HLSL 600 OpName %type__Globals "type.$Globals" OpMemberName %type__Globals 0 "x" OpMemberName %type__Globals 1 "y" OpMemberName %type__Globals 2 "z" OpName %_Globals "$Globals" OpName %main "main" OpDecorate %_Globals DescriptorSet 0 OpDecorate %_Globals Binding 0 OpMemberDecorate %type__Globals 0 Offset 0 OpMemberDecorate %type__Globals 1 Offset 16 OpMemberDecorate %type__Globals 2 Offset 24 OpMemberDecorate %_struct_6 0 Offset 0 OpMemberDecorate %_struct_6 1 Offset 4 OpDecorate %type__Globals Block %float = OpTypeFloat 32 %_struct_6 = OpTypeStruct %float %float %type__Globals = OpTypeStruct %float %_struct_6 %float %_ptr_Uniform_type__Globals = OpTypePointer Uniform %type__Globals %void = OpTypeVoid %7 = OpTypeFunction %void %_Globals = OpVariable %_ptr_Uniform_type__Globals Uniform %main = OpFunction %void None %7 %8 = OpLabel %9 = OpLoad %type__Globals %_Globals %10 = OpCompositeExtract %float %9 1 1 %11 = OpCompositeInsert %type__Globals %10 %9 1 1 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(EliminateDeadMemberTest, RemoveMembersUpdateInserExtract4) { // Test that the members "x" and "z" are removed, and one member from the // substruct. Update the OpCompositeExtract instruction. Update the // OpCompositeInsert instruction. const std::string text = R"( ; CHECK: OpName ; CHECK-NEXT: OpMemberName %type__Globals 0 "y" ; CHECK-NOT: OpMemberName ; CHECK: OpMemberDecorate %type__Globals 0 Offset 16 ; CHECK-NOT: OpMemberDecorate %type__Globals 1 Offset ; CHECK: OpMemberDecorate [[struct:%\w+]] 0 Offset 4 ; CHECK: [[struct:%\w+]] = OpTypeStruct %float ; CHECK: [[array:%\w+]] = OpTypeArray [[struct]] ; CHECK: %type__Globals = OpTypeStruct [[array]] ; CHECK: [[ld:%\w+]] = OpLoad %type__Globals %_Globals ; CHECK: [[ex:%\w+]] = OpCompositeExtract %float [[ld]] 0 1 0 ; CHECK: OpCompositeInsert %type__Globals [[ex]] [[ld]] 0 1 0 ; CHECK: OpReturn OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource HLSL 600 OpName %type__Globals "type.$Globals" OpMemberName %type__Globals 0 "x" OpMemberName %type__Globals 1 "y" OpMemberName %type__Globals 2 "z" OpName %_Globals "$Globals" OpName %main "main" OpDecorate %_Globals DescriptorSet 0 OpDecorate %_Globals Binding 0 OpMemberDecorate %type__Globals 0 Offset 0 OpMemberDecorate %type__Globals 1 Offset 16 OpMemberDecorate %type__Globals 2 Offset 80 OpMemberDecorate %_struct_6 0 Offset 0 OpMemberDecorate %_struct_6 1 Offset 4 OpDecorate %array ArrayStride 16 OpDecorate %type__Globals Block %uint = OpTypeInt 32 0 ; 32-bit int, sign-less %uint_4 = OpConstant %uint 4 %float = OpTypeFloat 32 %_struct_6 = OpTypeStruct %float %float %array = OpTypeArray %_struct_6 %uint_4 %type__Globals = OpTypeStruct %float %array %float %_ptr_Uniform_type__Globals = OpTypePointer Uniform %type__Globals %void = OpTypeVoid %7 = OpTypeFunction %void %_Globals = OpVariable %_ptr_Uniform_type__Globals Uniform %main = OpFunction %void None %7 %8 = OpLabel %9 = OpLoad %type__Globals %_Globals %10 = OpCompositeExtract %float %9 1 1 1 %11 = OpCompositeInsert %type__Globals %10 %9 1 1 1 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(EliminateDeadMemberTest, RemoveMembersUpdateArrayLength) { // Test that the members "x" and "y" are removed. // Member "z" is live because of the OpArrayLength instruction. // Update the OpArrayLength instruction. const std::string text = R"( ; CHECK: OpName ; CHECK-NEXT: OpMemberName %type__Globals 0 "z" ; CHECK-NOT: OpMemberName ; CHECK: OpMemberDecorate %type__Globals 0 Offset 16 ; CHECK-NOT: OpMemberDecorate %type__Globals 1 Offset ; CHECK: %type__Globals = OpTypeStruct %_runtimearr_float ; CHECK: OpArrayLength %uint %_Globals 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource HLSL 600 OpName %type__Globals "type.$Globals" OpMemberName %type__Globals 0 "x" OpMemberName %type__Globals 1 "y" OpMemberName %type__Globals 2 "z" OpName %_Globals "$Globals" OpName %main "main" OpDecorate %_Globals DescriptorSet 0 OpDecorate %_Globals Binding 0 OpDecorate %_runtimearr_float ArrayStride 16 OpMemberDecorate %type__Globals 0 Offset 0 OpMemberDecorate %type__Globals 1 Offset 4 OpMemberDecorate %type__Globals 2 Offset 16 OpDecorate %type__Globals Block %uint = OpTypeInt 32 0 %float = OpTypeFloat 32 %_runtimearr_float = OpTypeRuntimeArray %float %type__Globals = OpTypeStruct %float %float %_runtimearr_float %_ptr_Uniform_type__Globals = OpTypePointer Uniform %type__Globals %void = OpTypeVoid %9 = OpTypeFunction %void %_Globals = OpVariable %_ptr_Uniform_type__Globals Uniform %main = OpFunction %void None %9 %10 = OpLabel %12 = OpArrayLength %uint %_Globals 2 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(EliminateDeadMemberTest, KeepMembersOpStore) { // Test that all members are kept because of an OpStore. // No change expected. const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource HLSL 600 OpName %type__Globals "type.$Globals" OpMemberName %type__Globals 0 "x" OpMemberName %type__Globals 1 "y" OpMemberName %type__Globals 2 "z" OpName %_Globals "$Globals" OpName %_Globals "$Globals2" OpName %main "main" OpDecorate %_Globals DescriptorSet 0 OpDecorate %_Globals Binding 0 OpMemberDecorate %type__Globals 0 Offset 0 OpMemberDecorate %type__Globals 1 Offset 4 OpMemberDecorate %type__Globals 2 Offset 16 OpDecorate %type__Globals Block %uint = OpTypeInt 32 0 %float = OpTypeFloat 32 %type__Globals = OpTypeStruct %float %float %float %_ptr_Uniform_type__Globals = OpTypePointer Uniform %type__Globals %void = OpTypeVoid %9 = OpTypeFunction %void %_Globals = OpVariable %_ptr_Uniform_type__Globals Uniform %_Globals2 = OpVariable %_ptr_Uniform_type__Globals Uniform %main = OpFunction %void None %9 %10 = OpLabel %11 = OpLoad %type__Globals %_Globals OpStore %_Globals2 %11 OpReturn OpFunctionEnd )"; auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ true); EXPECT_EQ(opt::Pass::Status::SuccessWithoutChange, std::get<1>(result)); } TEST_F(EliminateDeadMemberTest, KeepStorageBufferMembers) { // Test that all members of the storage buffer struct %S are kept. // No change expected. const std::string text = R"( OpCapability Shader OpExtension "SPV_GOOGLE_hlsl_functionality1" OpExtension "SPV_GOOGLE_user_type" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %PSMain "PSMain" %out_var_SV_TARGET OpExecutionMode %PSMain OriginUpperLeft OpSource HLSL 600 OpName %type_StructuredBuffer_S "type.StructuredBuffer.S" OpName %S "S" OpMemberName %S 0 "A" OpMemberName %S 1 "B" OpName %Buf "Buf" OpName %out_var_SV_TARGET "out.var.SV_TARGET" OpName %PSMain "PSMain" OpDecorateString %out_var_SV_TARGET UserSemantic "SV_TARGET" OpDecorate %out_var_SV_TARGET Location 0 OpDecorate %Buf DescriptorSet 0 OpDecorate %Buf Binding 0 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %S 1 Offset 16 OpDecorate %_runtimearr_S ArrayStride 32 OpMemberDecorate %type_StructuredBuffer_S 0 Offset 0 OpMemberDecorate %type_StructuredBuffer_S 0 NonWritable OpDecorate %type_StructuredBuffer_S BufferBlock OpDecorateString %Buf UserTypeGOOGLE "structuredbuffer" %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %int_1 = OpConstant %int 1 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %S = OpTypeStruct %v4float %v4float %_runtimearr_S = OpTypeRuntimeArray %S %type_StructuredBuffer_S = OpTypeStruct %_runtimearr_S %_ptr_Uniform_type_StructuredBuffer_S = OpTypePointer Uniform %type_StructuredBuffer_S %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %18 = OpTypeFunction %void %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %Buf = OpVariable %_ptr_Uniform_type_StructuredBuffer_S Uniform %out_var_SV_TARGET = OpVariable %_ptr_Output_v4float Output %PSMain = OpFunction %void None %18 %20 = OpLabel %21 = OpAccessChain %_ptr_Uniform_v4float %Buf %int_0 %uint_0 %int_1 %22 = OpLoad %v4float %21 OpStore %out_var_SV_TARGET %22 OpReturn OpFunctionEnd )"; auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ true); EXPECT_EQ(opt::Pass::Status::SuccessWithoutChange, std::get<1>(result)); } TEST_F(EliminateDeadMemberTest, KeepMembersOpCopyMemory) { // Test that all members are kept because of an OpCopyMemory. // No change expected. const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource HLSL 600 OpName %type__Globals "type.$Globals" OpMemberName %type__Globals 0 "x" OpMemberName %type__Globals 1 "y" OpMemberName %type__Globals 2 "z" OpName %_Globals "$Globals" OpName %_Globals "$Globals2" OpName %main "main" OpDecorate %_Globals DescriptorSet 0 OpDecorate %_Globals Binding 0 OpMemberDecorate %type__Globals 0 Offset 0 OpMemberDecorate %type__Globals 1 Offset 4 OpMemberDecorate %type__Globals 2 Offset 16 OpDecorate %type__Globals Block %uint = OpTypeInt 32 0 %float = OpTypeFloat 32 %type__Globals = OpTypeStruct %float %float %float %_ptr_Uniform_type__Globals = OpTypePointer Uniform %type__Globals %void = OpTypeVoid %9 = OpTypeFunction %void %_Globals = OpVariable %_ptr_Uniform_type__Globals Uniform %_Globals2 = OpVariable %_ptr_Uniform_type__Globals Uniform %main = OpFunction %void None %9 %10 = OpLabel OpCopyMemory %_Globals2 %_Globals OpReturn OpFunctionEnd )"; auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ true); EXPECT_EQ(opt::Pass::Status::SuccessWithoutChange, std::get<1>(result)); } TEST_F(EliminateDeadMemberTest, KeepMembersOpCopyMemorySized) { // Test that all members are kept because of an OpCopyMemorySized. // No change expected. const std::string text = R"( OpCapability Shader OpCapability Addresses OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource HLSL 600 OpName %type__Globals "type.$Globals" OpMemberName %type__Globals 0 "x" OpMemberName %type__Globals 1 "y" OpMemberName %type__Globals 2 "z" OpName %_Globals "$Globals" OpName %_Globals "$Globals2" OpName %main "main" OpDecorate %_Globals DescriptorSet 0 OpDecorate %_Globals Binding 0 OpMemberDecorate %type__Globals 0 Offset 0 OpMemberDecorate %type__Globals 1 Offset 4 OpMemberDecorate %type__Globals 2 Offset 16 OpDecorate %type__Globals Block %uint = OpTypeInt 32 0 %uint_20 = OpConstant %uint 20 %float = OpTypeFloat 32 %type__Globals = OpTypeStruct %float %float %float %_ptr_Uniform_type__Globals = OpTypePointer Uniform %type__Globals %void = OpTypeVoid %9 = OpTypeFunction %void %_Globals = OpVariable %_ptr_Uniform_type__Globals Uniform %_Globals2 = OpVariable %_ptr_Uniform_type__Globals Uniform %main = OpFunction %void None %9 %10 = OpLabel OpCopyMemorySized %_Globals2 %_Globals %uint_20 OpReturn OpFunctionEnd )"; auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ true); EXPECT_EQ(opt::Pass::Status::SuccessWithoutChange, std::get<1>(result)); } TEST_F(EliminateDeadMemberTest, KeepMembersOpReturnValue) { // Test that all members are kept because of an OpCopyMemorySized. // No change expected. const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpSource HLSL 600 OpName %type__Globals "type.$Globals" OpMemberName %type__Globals 0 "x" OpMemberName %type__Globals 1 "y" OpMemberName %type__Globals 2 "z" OpName %_Globals "$Globals" OpName %_Globals "$Globals2" OpName %main "main" OpDecorate %_Globals DescriptorSet 0 OpDecorate %_Globals Binding 0 OpMemberDecorate %type__Globals 0 Offset 0 OpMemberDecorate %type__Globals 1 Offset 4 OpMemberDecorate %type__Globals 2 Offset 16 OpDecorate %type__Globals Block %uint = OpTypeInt 32 0 %uint_20 = OpConstant %uint 20 %float = OpTypeFloat 32 %type__Globals = OpTypeStruct %float %float %float %_ptr_Uniform_type__Globals = OpTypePointer Uniform %type__Globals %void = OpTypeVoid %9 = OpTypeFunction %type__Globals %_Globals = OpVariable %_ptr_Uniform_type__Globals Uniform %_Globals2 = OpVariable %_ptr_Uniform_type__Globals Uniform %main = OpFunction %type__Globals None %9 %10 = OpLabel %11 = OpLoad %type__Globals %_Globals OpReturnValue %11 OpFunctionEnd )"; auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ true); EXPECT_EQ(opt::Pass::Status::SuccessWithoutChange, std::get<1>(result)); } TEST_F(EliminateDeadMemberTest, RemoveMemberAccessChainWithArrays) { // Leave only 1 member in each of the structs. // Update OpMemberName, OpMemberDecorate, and OpAccessChain. const std::string text = R"( ; CHECK: OpName ; CHECK-NEXT: OpMemberName %type__Globals 0 "y" ; CHECK-NOT: OpMemberName ; CHECK: OpMemberDecorate %type__Globals 0 Offset 16 ; CHECK: OpMemberDecorate [[struct:%\w+]] 0 Offset 4 ; CHECK: [[struct]] = OpTypeStruct %float ; CHECK: [[array:%\w+]] = OpTypeArray [[struct]] ; CHECK: %type__Globals = OpTypeStruct [[array]] ; CHECK: [[undef:%\w+]] = OpUndef %uint ; CHECK: OpAccessChain %_ptr_Uniform_float %_Globals [[undef]] %uint_0 [[undef]] %uint_0 OpCapability Shader OpCapability VariablePointersStorageBuffer OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource HLSL 600 OpName %type__Globals "type.$Globals" OpMemberName %type__Globals 0 "x" OpMemberName %type__Globals 1 "y" OpMemberName %type__Globals 2 "z" OpName %_Globals "$Globals" OpName %main "main" OpDecorate %_Globals DescriptorSet 0 OpDecorate %_Globals Binding 0 OpMemberDecorate %type__Globals 0 Offset 0 OpMemberDecorate %type__Globals 1 Offset 16 OpMemberDecorate %type__Globals 2 Offset 48 OpMemberDecorate %_struct_4 0 Offset 0 OpMemberDecorate %_struct_4 1 Offset 4 OpDecorate %_arr__struct_4_uint_2 ArrayStride 16 OpDecorate %type__Globals Block %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %uint_3 = OpConstant %uint 3 %float = OpTypeFloat 32 %_struct_4 = OpTypeStruct %float %float %_arr__struct_4_uint_2 = OpTypeArray %_struct_4 %uint_2 %type__Globals = OpTypeStruct %float %_arr__struct_4_uint_2 %float %_arr_type__Globals_uint_3 = OpTypeArray %type__Globals %uint_3 %_ptr_Uniform__arr_type__Globals_uint_3 = OpTypePointer Uniform %_arr_type__Globals_uint_3 %void = OpTypeVoid %15 = OpTypeFunction %void %_ptr_Uniform_float = OpTypePointer Uniform %float %_Globals = OpVariable %_ptr_Uniform__arr_type__Globals_uint_3 Uniform %main = OpFunction %void None %15 %17 = OpLabel %18 = OpUndef %uint %19 = OpAccessChain %_ptr_Uniform_float %_Globals %18 %uint_1 %18 %uint_1 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(EliminateDeadMemberTest, RemoveMemberInboundsAccessChain) { // Test that the member "y" is removed. // Update OpMemberName for |y| and |z|. // Update OpMemberDecorate for |y| and |z|. // Update OpInboundsAccessChain for access to |z|. const std::string text = R"( ; CHECK: OpName ; CHECK-NEXT: OpMemberName %type__Globals 0 "x" ; CHECK-NEXT: OpMemberName %type__Globals 1 "z" ; CHECK-NOT: OpMemberName ; CHECK: OpMemberDecorate %type__Globals 0 Offset 0 ; CHECK: OpMemberDecorate %type__Globals 1 Offset 8 ; CHECK: %type__Globals = OpTypeStruct %float %float ; CHECK: OpInBoundsAccessChain %_ptr_Uniform_float %_Globals %int_0 ; CHECK: OpInBoundsAccessChain %_ptr_Uniform_float %_Globals %uint_1 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %in_var_Position %gl_Position OpSource HLSL 600 OpName %type__Globals "type.$Globals" OpMemberName %type__Globals 0 "x" OpMemberName %type__Globals 1 "y" OpMemberName %type__Globals 2 "z" OpName %_Globals "$Globals" OpName %in_var_Position "in.var.Position" OpName %main "main" OpDecorate %gl_Position BuiltIn Position OpDecorate %in_var_Position Location 0 OpDecorate %_Globals DescriptorSet 0 OpDecorate %_Globals Binding 0 OpMemberDecorate %type__Globals 0 Offset 0 OpMemberDecorate %type__Globals 1 Offset 4 OpMemberDecorate %type__Globals 2 Offset 8 OpDecorate %type__Globals Block %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %int_2 = OpConstant %int 2 %type__Globals = OpTypeStruct %float %float %float %_ptr_Uniform_type__Globals = OpTypePointer Uniform %type__Globals %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %15 = OpTypeFunction %void %_ptr_Uniform_float = OpTypePointer Uniform %float %_Globals = OpVariable %_ptr_Uniform_type__Globals Uniform %in_var_Position = OpVariable %_ptr_Input_v4float Input %gl_Position = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %15 %17 = OpLabel %18 = OpLoad %v4float %in_var_Position %19 = OpInBoundsAccessChain %_ptr_Uniform_float %_Globals %int_0 %20 = OpLoad %float %19 %21 = OpCompositeExtract %float %18 0 %22 = OpFAdd %float %21 %20 %23 = OpCompositeInsert %v4float %22 %18 0 %24 = OpCompositeExtract %float %18 1 %25 = OpCompositeInsert %v4float %24 %23 1 %26 = OpInBoundsAccessChain %_ptr_Uniform_float %_Globals %int_2 %27 = OpLoad %float %26 %28 = OpCompositeExtract %float %18 2 %29 = OpFAdd %float %28 %27 %30 = OpCompositeInsert %v4float %29 %25 2 OpStore %gl_Position %30 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(EliminateDeadMemberTest, RemoveMemberPtrAccessChain) { // Test that the member "y" is removed. // Update OpMemberName for |y| and |z|. // Update OpMemberDecorate for |y| and |z|. // Update OpInboundsAccessChain for access to |z|. const std::string text = R"( ; CHECK: OpName ; CHECK-NEXT: OpMemberName %type__Globals 0 "x" ; CHECK-NEXT: OpMemberName %type__Globals 1 "z" ; CHECK-NOT: OpMemberName ; CHECK: OpMemberDecorate %type__Globals 0 Offset 0 ; CHECK: OpMemberDecorate %type__Globals 1 Offset 16 ; CHECK: %type__Globals = OpTypeStruct %float %float ; CHECK: [[ac:%\w+]] = OpAccessChain %_ptr_Uniform_type__Globals %_Globals %uint_0 ; CHECK: OpPtrAccessChain %_ptr_Uniform_float [[ac]] %uint_1 %uint_0 ; CHECK: OpPtrAccessChain %_ptr_Uniform_float [[ac]] %uint_0 %uint_1 OpCapability Shader OpCapability VariablePointersStorageBuffer OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource HLSL 600 OpName %type__Globals "type.$Globals" OpMemberName %type__Globals 0 "x" OpMemberName %type__Globals 1 "y" OpMemberName %type__Globals 2 "z" OpName %_Globals "$Globals" OpName %main "main" OpDecorate %_Globals DescriptorSet 0 OpDecorate %_Globals Binding 0 OpMemberDecorate %type__Globals 0 Offset 0 OpMemberDecorate %type__Globals 1 Offset 4 OpMemberDecorate %type__Globals 2 Offset 16 OpDecorate %type__Globals Block OpDecorate %_ptr_Uniform_type__Globals ArrayStride 8 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %uint_3 = OpConstant %uint 3 %float = OpTypeFloat 32 %type__Globals = OpTypeStruct %float %float %float %_arr_type__Globals_uint_3 = OpTypeArray %type__Globals %uint_3 %_ptr_Uniform_type__Globals = OpTypePointer Uniform %type__Globals %_ptr_Uniform__arr_type__Globals_uint_3 = OpTypePointer Uniform %_arr_type__Globals_uint_3 %void = OpTypeVoid %14 = OpTypeFunction %void %_ptr_Uniform_float = OpTypePointer Uniform %float %_Globals = OpVariable %_ptr_Uniform__arr_type__Globals_uint_3 Uniform %main = OpFunction %void None %14 %16 = OpLabel %17 = OpAccessChain %_ptr_Uniform_type__Globals %_Globals %uint_0 %18 = OpPtrAccessChain %_ptr_Uniform_float %17 %uint_1 %uint_0 %19 = OpPtrAccessChain %_ptr_Uniform_float %17 %uint_0 %uint_2 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(EliminateDeadMemberTest, RemoveMemberInBoundsPtrAccessChain) { // Test that the member "y" is removed. // Update OpMemberName for |y| and |z|. // Update OpMemberDecorate for |y| and |z|. // Update OpInboundsAccessChain for access to |z|. const std::string text = R"( ; CHECK: OpName ; CHECK-NEXT: OpMemberName %type__Globals 0 "x" ; CHECK-NEXT: OpMemberName %type__Globals 1 "z" ; CHECK-NOT: OpMemberName ; CHECK: OpMemberDecorate %type__Globals 0 Offset 0 ; CHECK: OpMemberDecorate %type__Globals 1 Offset 16 ; CHECK: %type__Globals = OpTypeStruct %float %float ; CHECK: [[ac:%\w+]] = OpAccessChain %_ptr_Uniform_type__Globals %_Globals %uint_0 ; CHECK: OpInBoundsPtrAccessChain %_ptr_Uniform_float [[ac]] %uint_1 %uint_0 ; CHECK: OpInBoundsPtrAccessChain %_ptr_Uniform_float [[ac]] %uint_0 %uint_1 OpCapability Shader OpCapability Addresses OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource HLSL 600 OpName %type__Globals "type.$Globals" OpMemberName %type__Globals 0 "x" OpMemberName %type__Globals 1 "y" OpMemberName %type__Globals 2 "z" OpName %_Globals "$Globals" OpName %main "main" OpDecorate %_Globals DescriptorSet 0 OpDecorate %_Globals Binding 0 OpMemberDecorate %type__Globals 0 Offset 0 OpMemberDecorate %type__Globals 1 Offset 4 OpMemberDecorate %type__Globals 2 Offset 16 OpDecorate %type__Globals Block %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %uint_3 = OpConstant %uint 3 %float = OpTypeFloat 32 %type__Globals = OpTypeStruct %float %float %float %_arr_type__Globals_uint_3 = OpTypeArray %type__Globals %uint_3 %_ptr_Uniform_type__Globals = OpTypePointer Uniform %type__Globals %_ptr_Uniform__arr_type__Globals_uint_3 = OpTypePointer Uniform %_arr_type__Globals_uint_3 %void = OpTypeVoid %14 = OpTypeFunction %void %_ptr_Uniform_float = OpTypePointer Uniform %float %_Globals = OpVariable %_ptr_Uniform__arr_type__Globals_uint_3 Uniform %main = OpFunction %void None %14 %16 = OpLabel %17 = OpAccessChain %_ptr_Uniform_type__Globals %_Globals %uint_0 %18 = OpInBoundsPtrAccessChain %_ptr_Uniform_float %17 %uint_1 %uint_0 %19 = OpInBoundsPtrAccessChain %_ptr_Uniform_float %17 %uint_0 %uint_2 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(EliminateDeadMemberTest, DontRemoveModfStructResultTypeMembers) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 %float = OpTypeFloat 32 %void = OpTypeVoid %21 = OpTypeFunction %void %ModfStructType = OpTypeStruct %float %float %main = OpFunction %void None %21 %22 = OpLabel %23 = OpUndef %float %24 = OpExtInst %ModfStructType %1 ModfStruct %23 %25 = OpCompositeExtract %float %24 1 OpReturn OpFunctionEnd )"; auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ true); EXPECT_EQ(opt::Pass::Status::SuccessWithoutChange, std::get<1>(result)); } TEST_F(EliminateDeadMemberTest, DontChangeInputStructs) { // The input for a shader has to match the type of the output from the // previous shader in the pipeline. Because of that, we cannot change the // types of input variables. const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %input_var OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 %float = OpTypeFloat 32 %void = OpTypeVoid %21 = OpTypeFunction %void %in_var_type = OpTypeStruct %float %float %in_ptr_type = OpTypePointer Input %in_var_type %input_var = OpVariable %in_ptr_type Input %main = OpFunction %void None %21 %22 = OpLabel OpReturn OpFunctionEnd )"; auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ true); EXPECT_EQ(opt::Pass::Status::SuccessWithoutChange, std::get<1>(result)); } TEST_F(EliminateDeadMemberTest, DontChangeOutputStructs) { // The output for a shader has to match the type of the output from the // previous shader in the pipeline. Because of that, we cannot change the // types of output variables. const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %output_var OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 %float = OpTypeFloat 32 %void = OpTypeVoid %21 = OpTypeFunction %void %out_var_type = OpTypeStruct %float %float %out_ptr_type = OpTypePointer Output %out_var_type %output_var = OpVariable %out_ptr_type Output %main = OpFunction %void None %21 %22 = OpLabel OpReturn OpFunctionEnd )"; auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ true); EXPECT_EQ(opt::Pass::Status::SuccessWithoutChange, std::get<1>(result)); } TEST_F(EliminateDeadMemberTest, UpdateSpecConstOpExtract) { // Test that an extract in an OpSpecConstantOp is correctly updated. const std::string text = R"( ; CHECK: OpName ; CHECK-NEXT: OpMemberName %type__Globals 0 "y" ; CHECK-NOT: OpMemberName ; CHECK: OpDecorate [[spec_const:%\w+]] SpecId 1 ; CHECK: OpMemberDecorate %type__Globals 0 Offset 4 ; CHECK: %type__Globals = OpTypeStruct %uint ; CHECK: [[struct:%\w+]] = OpSpecConstantComposite %type__Globals [[spec_const]] ; CHECK: OpSpecConstantOp %uint CompositeExtract [[struct]] 0 OpCapability Shader OpCapability Addresses OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource HLSL 600 OpName %type__Globals "type.$Globals" OpMemberName %type__Globals 0 "x" OpMemberName %type__Globals 1 "y" OpMemberName %type__Globals 2 "z" OpName %main "main" OpDecorate %c_0 SpecId 0 OpDecorate %c_1 SpecId 1 OpDecorate %c_2 SpecId 2 OpMemberDecorate %type__Globals 0 Offset 0 OpMemberDecorate %type__Globals 1 Offset 4 OpMemberDecorate %type__Globals 2 Offset 16 %uint = OpTypeInt 32 0 %c_0 = OpSpecConstant %uint 0 %c_1 = OpSpecConstant %uint 1 %c_2 = OpSpecConstant %uint 2 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %uint_3 = OpConstant %uint 3 %type__Globals = OpTypeStruct %uint %uint %uint %spec_const_global = OpSpecConstantComposite %type__Globals %c_0 %c_1 %c_2 %extract = OpSpecConstantOp %uint CompositeExtract %spec_const_global 1 %void = OpTypeVoid %14 = OpTypeFunction %void %main = OpFunction %void None %14 %16 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(EliminateDeadMemberTest, UpdateSpecConstOpInsert) { // Test that an insert in an OpSpecConstantOp is correctly updated. const std::string text = R"( ; CHECK: OpName ; CHECK-NEXT: OpMemberName %type__Globals 0 "y" ; CHECK-NOT: OpMemberName ; CHECK: OpDecorate [[spec_const:%\w+]] SpecId 1 ; CHECK: OpMemberDecorate %type__Globals 0 Offset 4 ; CHECK: %type__Globals = OpTypeStruct %uint ; CHECK: [[struct:%\w+]] = OpSpecConstantComposite %type__Globals [[spec_const]] ; CHECK: OpSpecConstantOp %type__Globals CompositeInsert %uint_3 [[struct]] 0 OpCapability Shader OpCapability Addresses OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource HLSL 600 OpName %type__Globals "type.$Globals" OpMemberName %type__Globals 0 "x" OpMemberName %type__Globals 1 "y" OpMemberName %type__Globals 2 "z" OpName %main "main" OpDecorate %c_0 SpecId 0 OpDecorate %c_1 SpecId 1 OpDecorate %c_2 SpecId 2 OpMemberDecorate %type__Globals 0 Offset 0 OpMemberDecorate %type__Globals 1 Offset 4 OpMemberDecorate %type__Globals 2 Offset 16 %uint = OpTypeInt 32 0 %c_0 = OpSpecConstant %uint 0 %c_1 = OpSpecConstant %uint 1 %c_2 = OpSpecConstant %uint 2 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %uint_3 = OpConstant %uint 3 %type__Globals = OpTypeStruct %uint %uint %uint %spec_const_global = OpSpecConstantComposite %type__Globals %c_0 %c_1 %c_2 %insert = OpSpecConstantOp %type__Globals CompositeInsert %uint_3 %spec_const_global 1 %extract = OpSpecConstantOp %uint CompositeExtract %insert 1 %void = OpTypeVoid %14 = OpTypeFunction %void %main = OpFunction %void None %14 %16 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(EliminateDeadMemberTest, 8BitIndexNoChange) { // Test that the pass does not crash when an 8 bit index is used in an // OpAccessChain. No change is expected. const std::string text = R"( OpCapability ImageQuery OpCapability Int8 OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "OpnSeman/" %2 OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %4 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_struct_7 = OpTypeStruct %v4float %_ptr_Function__struct_7 = OpTypePointer Function %_struct_7 %_ptr_Output_v4float = OpTypePointer Output %v4float %10 = OpTypeFunction %v4float %_ptr_Function__struct_7 %char = OpTypeInt 8 1 %char_0 = OpConstant %char 0 %_ptr_Function_v4float = OpTypePointer Function %v4float %2 = OpVariable %_ptr_Output_v4float Output %1 = OpFunction %void None %4 %14 = OpLabel %15 = OpVariable %_ptr_Function__struct_7 Function %16 = OpFunctionCall %v4float %17 %15 OpReturn OpFunctionEnd %17 = OpFunction %v4float DontInline %10 %18 = OpFunctionParameter %_ptr_Function__struct_7 %19 = OpLabel %20 = OpAccessChain %_ptr_Function_v4float %18 %char_0 %21 = OpLoad %v4float %20 OpReturnValue %21 OpFunctionEnd )"; auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ true); EXPECT_EQ(opt::Pass::Status::SuccessWithoutChange, std::get<1>(result)); } TEST_F(EliminateDeadMemberTest, 8BitIndexWithChange) { // Test that the pass does not crash when an 8 bit index is used in an // OpAccessChain. The index in the access change should be changed to 0. const std::string text = R"( OpCapability ImageQuery OpCapability Int8 OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "OpnSeman/" %2 OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %4 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_struct_7 = OpTypeStruct %v4float %v4float %_ptr_Function__struct_7 = OpTypePointer Function %_struct_7 %_ptr_Output_v4float = OpTypePointer Output %v4float %10 = OpTypeFunction %v4float %_ptr_Function__struct_7 %char = OpTypeInt 8 1 %char_1 = OpConstant %char 1 %_ptr_Function_v4float = OpTypePointer Function %v4float %2 = OpVariable %_ptr_Output_v4float Output %1 = OpFunction %void None %4 %14 = OpLabel %15 = OpVariable %_ptr_Function__struct_7 Function %16 = OpFunctionCall %v4float %17 %15 OpReturn OpFunctionEnd %17 = OpFunction %v4float DontInline %10 ; CHECK: [[param:%\w+]] = OpFunctionParameter %18 = OpFunctionParameter %_ptr_Function__struct_7 %19 = OpLabel ; CHECK: OpAccessChain %_ptr_Function_v4float [[param]] %uint_0 %20 = OpAccessChain %_ptr_Function_v4float %18 %char_1 %21 = OpLoad %v4float %20 OpReturnValue %21 OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } } // namespace KhronosGroup-SPIRV-Tools-f289d04/test/opt/eliminate_dead_output_stores_test.cpp000066400000000000000000001135211475742701700300230ustar00rootroot00000000000000// Copyright (c) 2022 The Khronos Group Inc. // Copyright (c) 2022 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using ElimDeadOutputStoresTest = PassTest<::testing::Test>; TEST_F(ElimDeadOutputStoresTest, VertMultipleLocations) { // #version 450 // // layout(location = 2) out Vertex // { // vec4 color0; // vec4 color1; // vec4 color2[3]; // } oVert; // // void main() // { // oVert.color0 = vec4(0.0,0.0,0.0,0.0); // oVert.color1 = vec4(0.1,0.0,0.0,0.0); // oVert.color2[0] = vec4(0.2,0.0,0.0,0.0); // oVert.color2[1] = vec4(0.3,0.0,0.0,0.0); // oVert.color2[2] = vec4(0.4,0.0,0.0,0.0); // } const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %oVert OpSource GLSL 450 OpName %main "main" OpName %Vertex "Vertex" OpMemberName %Vertex 0 "color0" OpMemberName %Vertex 1 "color1" OpMemberName %Vertex 2 "color2" OpName %oVert "oVert" OpDecorate %Vertex Block OpDecorate %oVert Location 2 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_3 = OpConstant %uint 3 %_arr_v4float_uint_3 = OpTypeArray %v4float %uint_3 %Vertex = OpTypeStruct %v4float %v4float %_arr_v4float_uint_3 %_ptr_Output_Vertex = OpTypePointer Output %Vertex %oVert = OpVariable %_ptr_Output_Vertex Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float_0 = OpConstant %float 0 %17 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %_ptr_Output_v4float = OpTypePointer Output %v4float %int_1 = OpConstant %int 1 %float_0_100000001 = OpConstant %float 0.100000001 %22 = OpConstantComposite %v4float %float_0_100000001 %float_0 %float_0 %float_0 %int_2 = OpConstant %int 2 %float_0_200000003 = OpConstant %float 0.200000003 %26 = OpConstantComposite %v4float %float_0_200000003 %float_0 %float_0 %float_0 %float_0_300000012 = OpConstant %float 0.300000012 %29 = OpConstantComposite %v4float %float_0_300000012 %float_0 %float_0 %float_0 %float_0_400000006 = OpConstant %float 0.400000006 %32 = OpConstantComposite %v4float %float_0_400000006 %float_0 %float_0 %float_0 %main = OpFunction %void None %3 %5 = OpLabel %19 = OpAccessChain %_ptr_Output_v4float %oVert %int_0 OpStore %19 %17 ;CHECK: OpStore %19 %17 %23 = OpAccessChain %_ptr_Output_v4float %oVert %int_1 OpStore %23 %22 ;CHECK-NOT: OpStore %23 %22 %27 = OpAccessChain %_ptr_Output_v4float %oVert %int_2 %int_0 OpStore %27 %26 ;CHECK-NOT: OpStore %27 %26 %30 = OpAccessChain %_ptr_Output_v4float %oVert %int_2 %int_1 OpStore %30 %29 ;CHECK: OpStore %30 %29 %33 = OpAccessChain %_ptr_Output_v4float %oVert %int_2 %int_2 OpStore %33 %32 ;CHECK-NOT: OpStore %33 %32 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); std::unordered_set live_inputs; std::unordered_set live_builtins; live_inputs.insert(2); live_inputs.insert(5); SinglePassRunAndMatch(text, true, &live_inputs, &live_builtins); } TEST_F(ElimDeadOutputStoresTest, VertMatrix) { // #version 450 // // layout(location = 2) out Vertex // { // vec4 color0; // vec4 color1; // mat4 color2; // mat4 color3; // mat4 color4; // } oVert; // // void main() // { // oVert.color0 = vec4(0.0,0.0,0.0,0.0); // oVert.color1 = vec4(0.1,0.0,0.0,0.0); // oVert.color2[2] = vec4(0.2,0.0,0.0,0.0); // oVert.color3[1] = vec4(0.3,0.0,0.0,0.0); // oVert.color4[0] = vec4(0.4,0.0,0.0,0.0); // } const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %oVert OpSource GLSL 450 OpName %main "main" OpName %Vertex "Vertex" OpMemberName %Vertex 0 "color0" OpMemberName %Vertex 1 "color1" OpMemberName %Vertex 2 "color2" OpMemberName %Vertex 3 "color3" OpMemberName %Vertex 4 "color4" OpName %oVert "oVert" OpDecorate %Vertex Block OpDecorate %oVert Location 2 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %mat4v4float = OpTypeMatrix %v4float 4 %Vertex = OpTypeStruct %v4float %v4float %mat4v4float %mat4v4float %mat4v4float %_ptr_Output_Vertex = OpTypePointer Output %Vertex %oVert = OpVariable %_ptr_Output_Vertex Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float_0 = OpConstant %float 0 %15 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %_ptr_Output_v4float = OpTypePointer Output %v4float %int_1 = OpConstant %int 1 %float_0_100000001 = OpConstant %float 0.100000001 %20 = OpConstantComposite %v4float %float_0_100000001 %float_0 %float_0 %float_0 %int_2 = OpConstant %int 2 %float_0_200000003 = OpConstant %float 0.200000003 %24 = OpConstantComposite %v4float %float_0_200000003 %float_0 %float_0 %float_0 %int_3 = OpConstant %int 3 %float_0_300000012 = OpConstant %float 0.300000012 %28 = OpConstantComposite %v4float %float_0_300000012 %float_0 %float_0 %float_0 %int_4 = OpConstant %int 4 %float_0_400000006 = OpConstant %float 0.400000006 %32 = OpConstantComposite %v4float %float_0_400000006 %float_0 %float_0 %float_0 %main = OpFunction %void None %3 %5 = OpLabel %17 = OpAccessChain %_ptr_Output_v4float %oVert %int_0 OpStore %17 %15 ; CHECK: OpStore %17 %15 %21 = OpAccessChain %_ptr_Output_v4float %oVert %int_1 OpStore %21 %20 ; CHECK-NOT: OpStore %21 %20 %25 = OpAccessChain %_ptr_Output_v4float %oVert %int_2 %int_2 OpStore %25 %24 ; CHECK-NOT: OpStore %25 %24 %29 = OpAccessChain %_ptr_Output_v4float %oVert %int_3 %int_1 OpStore %29 %28 ; CHECK: OpStore %29 %28 %33 = OpAccessChain %_ptr_Output_v4float %oVert %int_4 %int_0 OpStore %33 %32 ; CHECK-NOT: OpStore %33 %32 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); std::unordered_set live_inputs; std::unordered_set live_builtins; live_inputs.insert(2); live_inputs.insert(8); live_inputs.insert(9); live_inputs.insert(10); live_inputs.insert(11); SinglePassRunAndMatch(text, true, &live_inputs, &live_builtins); } TEST_F(ElimDeadOutputStoresTest, VertMemberLocs) { // #version 450 // // out Vertex // { // layout (location = 1) vec4 Cd; // layout (location = 0) vec2 uv; // } oVert; // // layout (location = 0) in vec3 P; // // void main() // { // oVert.uv = vec2(0.1, 0.7); // oVert.Cd = vec4(1, 0.5, 0, 1); // gl_Position = vec4(P, 1); // } const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %oVert %_ %P OpSource GLSL 450 OpName %main "main" OpName %Vertex "Vertex" OpMemberName %Vertex 0 "Cd" OpMemberName %Vertex 1 "uv" OpName %oVert "oVert" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpMemberName %gl_PerVertex 1 "gl_PointSize" OpMemberName %gl_PerVertex 2 "gl_ClipDistance" OpMemberName %gl_PerVertex 3 "gl_CullDistance" OpName %_ "" OpName %P "P" OpMemberDecorate %Vertex 0 Location 1 OpMemberDecorate %Vertex 1 Location 0 OpDecorate %Vertex Block OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex 3 BuiltIn CullDistance OpDecorate %gl_PerVertex Block OpDecorate %P Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %v2float = OpTypeVector %float 2 %Vertex = OpTypeStruct %v4float %v2float %_ptr_Output_Vertex = OpTypePointer Output %Vertex %oVert = OpVariable %_ptr_Output_Vertex Output %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %float_0_100000001 = OpConstant %float 0.100000001 %float_0_699999988 = OpConstant %float 0.699999988 %16 = OpConstantComposite %v2float %float_0_100000001 %float_0_699999988 %_ptr_Output_v2float = OpTypePointer Output %v2float %int_0 = OpConstant %int 0 %float_1 = OpConstant %float 1 %float_0_5 = OpConstant %float 0.5 %float_0 = OpConstant %float 0 %23 = OpConstantComposite %v4float %float_1 %float_0_5 %float_0 %float_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex %_ = OpVariable %_ptr_Output_gl_PerVertex Output %v3float = OpTypeVector %float 3 %_ptr_Input_v3float = OpTypePointer Input %v3float %P = OpVariable %_ptr_Input_v3float Input %main = OpFunction %void None %3 %5 = OpLabel %18 = OpAccessChain %_ptr_Output_v2float %oVert %int_1 OpStore %18 %16 ; CHECK-NOT: OpStore %18 %16 %25 = OpAccessChain %_ptr_Output_v4float %oVert %int_0 OpStore %25 %23 ; CHECK: OpStore %25 %23 %35 = OpLoad %v3float %P %36 = OpCompositeExtract %float %35 0 %37 = OpCompositeExtract %float %35 1 %38 = OpCompositeExtract %float %35 2 %39 = OpCompositeConstruct %v4float %36 %37 %38 %float_1 %40 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %40 %39 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); std::unordered_set live_inputs; std::unordered_set live_builtins; live_inputs.insert(1); SinglePassRunAndMatch(text, true, &live_inputs, &live_builtins); } TEST_F(ElimDeadOutputStoresTest, ArrayedOutput) { // Tests elimination of arrayed output as seen in Tesc shaders. // // #version 450 // // layout (vertices = 4) out; // // layout (location = 0) in vec3 N[]; // layout (location = 1) in vec3 P[]; // // layout (location = 5) out Vertex // { // vec4 c; // vec3 n; // vec3 f[10]; // } oVert[]; // // void main() // { // oVert[gl_InvocationID].c = vec4(1, 0, 0, 1); // oVert[gl_InvocationID].n = N[gl_InvocationID]; // oVert[gl_InvocationID].f[3] = vec3(0, 1, 0); // vec4 worldSpacePos = vec4(P[gl_InvocationID], 1); // gl_out[gl_InvocationID].gl_Position = worldSpacePos; // } const std::string text = R"( OpCapability Tessellation %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %main "main" %oVert %gl_InvocationID %N %P %gl_out OpExecutionMode %main OutputVertices 4 OpSource GLSL 450 OpName %main "main" OpName %Vertex "Vertex" OpMemberName %Vertex 0 "c" OpMemberName %Vertex 1 "n" OpMemberName %Vertex 2 "f" OpName %oVert "oVert" OpName %gl_InvocationID "gl_InvocationID" OpName %N "N" OpName %P "P" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpMemberName %gl_PerVertex 1 "gl_PointSize" OpMemberName %gl_PerVertex 2 "gl_ClipDistance" OpMemberName %gl_PerVertex 3 "gl_CullDistance" OpName %gl_out "gl_out" OpDecorate %Vertex Block OpDecorate %oVert Location 5 OpDecorate %gl_InvocationID BuiltIn InvocationId OpDecorate %N Location 0 OpDecorate %P Location 1 OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex 3 BuiltIn CullDistance OpDecorate %gl_PerVertex Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %v3float = OpTypeVector %float 3 %uint = OpTypeInt 32 0 %uint_10 = OpConstant %uint 10 %_arr_v3float_uint_10 = OpTypeArray %v3float %uint_10 %Vertex = OpTypeStruct %v4float %v3float %_arr_v3float_uint_10 %uint_4 = OpConstant %uint 4 %_arr_Vertex_uint_4 = OpTypeArray %Vertex %uint_4 %_ptr_Output__arr_Vertex_uint_4 = OpTypePointer Output %_arr_Vertex_uint_4 %oVert = OpVariable %_ptr_Output__arr_Vertex_uint_4 Output %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %gl_InvocationID = OpVariable %_ptr_Input_int Input %int_0 = OpConstant %int 0 %float_1 = OpConstant %float 1 %float_0 = OpConstant %float 0 %24 = OpConstantComposite %v4float %float_1 %float_0 %float_0 %float_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %int_1 = OpConstant %int 1 %uint_32 = OpConstant %uint 32 %_arr_v3float_uint_32 = OpTypeArray %v3float %uint_32 %_ptr_Input__arr_v3float_uint_32 = OpTypePointer Input %_arr_v3float_uint_32 %N = OpVariable %_ptr_Input__arr_v3float_uint_32 Input %_ptr_Input_v3float = OpTypePointer Input %v3float %_ptr_Output_v3float = OpTypePointer Output %v3float %int_2 = OpConstant %int 2 %int_3 = OpConstant %int 3 %42 = OpConstantComposite %v3float %float_0 %float_1 %float_0 %P = OpVariable %_ptr_Input__arr_v3float_uint_32 Input %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %_arr_gl_PerVertex_uint_4 = OpTypeArray %gl_PerVertex %uint_4 %_ptr_Output__arr_gl_PerVertex_uint_4 = OpTypePointer Output %_arr_gl_PerVertex_uint_4 %gl_out = OpVariable %_ptr_Output__arr_gl_PerVertex_uint_4 Output %main = OpFunction %void None %3 %5 = OpLabel %20 = OpLoad %int %gl_InvocationID %26 = OpAccessChain %_ptr_Output_v4float %oVert %20 %int_0 OpStore %26 %24 ; CHECK: OpStore %26 %24 %35 = OpAccessChain %_ptr_Input_v3float %N %20 %36 = OpLoad %v3float %35 %38 = OpAccessChain %_ptr_Output_v3float %oVert %20 %int_1 OpStore %38 %36 ; CHECK-NOT: OpStore %38 %36 %43 = OpAccessChain %_ptr_Output_v3float %oVert %20 %int_2 %int_3 OpStore %43 %42 ; CHECK: OpStore %43 %42 %48 = OpAccessChain %_ptr_Input_v3float %P %20 %49 = OpLoad %v3float %48 %50 = OpCompositeExtract %float %49 0 %51 = OpCompositeExtract %float %49 1 %52 = OpCompositeExtract %float %49 2 %53 = OpCompositeConstruct %v4float %50 %51 %52 %float_1 %62 = OpAccessChain %_ptr_Output_v4float %gl_out %20 %int_0 OpStore %62 %53 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); std::unordered_set live_inputs; std::unordered_set live_builtins; live_inputs.insert(5); live_inputs.insert(10); SinglePassRunAndMatch(text, true, &live_inputs, &live_builtins); } TEST_F(ElimDeadOutputStoresTest, ArrayedOutputMemberLocs) { // Tests elimination of member location with arrayed output as seen in // Tesc shaders. // // #version 450 // // layout (vertices = 4) out; // // layout (location = 0) in vec3 N[]; // layout (location = 1) in vec3 P[]; // // out Vertex // { // layout (location = 1) vec4 c; // layout (location = 3) vec3 n; // layout (location = 5) vec3 f[10]; // } oVert[]; // // void main() // { // oVert[gl_InvocationID].c = vec4(1, 0, 0, 1); // oVert[gl_InvocationID].n = N[gl_InvocationID]; // oVert[gl_InvocationID].f[3] = vec3(0, 1, 0); // vec4 worldSpacePos = vec4(P[gl_InvocationID], 1); // gl_out[gl_InvocationID].gl_Position = worldSpacePos; // } const std::string text = R"( OpCapability Tessellation %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %main "main" %oVert %gl_InvocationID %N %P %gl_out OpExecutionMode %main OutputVertices 4 OpSource GLSL 450 OpName %main "main" OpName %Vertex "Vertex" OpMemberName %Vertex 0 "c" OpMemberName %Vertex 1 "n" OpMemberName %Vertex 2 "f" OpName %oVert "oVert" OpName %gl_InvocationID "gl_InvocationID" OpName %N "N" OpName %P "P" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpMemberName %gl_PerVertex 1 "gl_PointSize" OpMemberName %gl_PerVertex 2 "gl_ClipDistance" OpMemberName %gl_PerVertex 3 "gl_CullDistance" OpName %gl_out "gl_out" OpMemberDecorate %Vertex 0 Location 1 OpMemberDecorate %Vertex 1 Location 3 OpMemberDecorate %Vertex 2 Location 5 OpDecorate %Vertex Block OpDecorate %gl_InvocationID BuiltIn InvocationId OpDecorate %N Location 0 OpDecorate %P Location 1 OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex 3 BuiltIn CullDistance OpDecorate %gl_PerVertex Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %v3float = OpTypeVector %float 3 %uint = OpTypeInt 32 0 %uint_10 = OpConstant %uint 10 %_arr_v3float_uint_10 = OpTypeArray %v3float %uint_10 %Vertex = OpTypeStruct %v4float %v3float %_arr_v3float_uint_10 %uint_4 = OpConstant %uint 4 %_arr_Vertex_uint_4 = OpTypeArray %Vertex %uint_4 %_ptr_Output__arr_Vertex_uint_4 = OpTypePointer Output %_arr_Vertex_uint_4 %oVert = OpVariable %_ptr_Output__arr_Vertex_uint_4 Output %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %gl_InvocationID = OpVariable %_ptr_Input_int Input %int_0 = OpConstant %int 0 %float_1 = OpConstant %float 1 %float_0 = OpConstant %float 0 %24 = OpConstantComposite %v4float %float_1 %float_0 %float_0 %float_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %int_1 = OpConstant %int 1 %uint_32 = OpConstant %uint 32 %_arr_v3float_uint_32 = OpTypeArray %v3float %uint_32 %_ptr_Input__arr_v3float_uint_32 = OpTypePointer Input %_arr_v3float_uint_32 %N = OpVariable %_ptr_Input__arr_v3float_uint_32 Input %_ptr_Input_v3float = OpTypePointer Input %v3float %_ptr_Output_v3float = OpTypePointer Output %v3float %int_2 = OpConstant %int 2 %int_3 = OpConstant %int 3 %42 = OpConstantComposite %v3float %float_0 %float_1 %float_0 %P = OpVariable %_ptr_Input__arr_v3float_uint_32 Input %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %_arr_gl_PerVertex_uint_4 = OpTypeArray %gl_PerVertex %uint_4 %_ptr_Output__arr_gl_PerVertex_uint_4 = OpTypePointer Output %_arr_gl_PerVertex_uint_4 %gl_out = OpVariable %_ptr_Output__arr_gl_PerVertex_uint_4 Output %main = OpFunction %void None %3 %5 = OpLabel %20 = OpLoad %int %gl_InvocationID %26 = OpAccessChain %_ptr_Output_v4float %oVert %20 %int_0 OpStore %26 %24 ;CHECK: OpStore %26 %24 %35 = OpAccessChain %_ptr_Input_v3float %N %20 %36 = OpLoad %v3float %35 %38 = OpAccessChain %_ptr_Output_v3float %oVert %20 %int_1 OpStore %38 %36 ;CHECK-NOT: OpStore %38 %36 %43 = OpAccessChain %_ptr_Output_v3float %oVert %20 %int_2 %int_3 OpStore %43 %42 ;CHECK: OpStore %43 %42 %48 = OpAccessChain %_ptr_Input_v3float %P %20 %49 = OpLoad %v3float %48 %50 = OpCompositeExtract %float %49 0 %51 = OpCompositeExtract %float %49 1 %52 = OpCompositeExtract %float %49 2 %53 = OpCompositeConstruct %v4float %50 %51 %52 %float_1 %62 = OpAccessChain %_ptr_Output_v4float %gl_out %20 %int_0 OpStore %62 %53 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); std::unordered_set live_inputs; std::unordered_set live_builtins; live_inputs.insert(1); live_inputs.insert(8); SinglePassRunAndMatch(text, true, &live_inputs, &live_builtins); } TEST_F(ElimDeadOutputStoresTest, ScalarBuiltins) { // Tests elimination of scalar builtins as seen in vert shaders. // // #version 460 // // layout (location = 0) in vec3 P; // // void main() // { // gl_Position = vec4(P, 1.0); // gl_PointSize = 1.0; // } const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %_ %P OpSource GLSL 460 OpName %main "main" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpMemberName %gl_PerVertex 1 "gl_PointSize" OpMemberName %gl_PerVertex 2 "gl_ClipDistance" OpMemberName %gl_PerVertex 3 "gl_CullDistance" OpName %_ "" OpName %P "P" OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex 3 BuiltIn CullDistance OpDecorate %gl_PerVertex Block OpDecorate %P Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex %_ = OpVariable %_ptr_Output_gl_PerVertex Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %v3float = OpTypeVector %float 3 %_ptr_Input_v3float = OpTypePointer Input %v3float %P = OpVariable %_ptr_Input_v3float Input %float_1 = OpConstant %float 1 %_ptr_Output_v4float = OpTypePointer Output %v4float %int_1 = OpConstant %int 1 %_ptr_Output_float = OpTypePointer Output %float %main = OpFunction %void None %3 %5 = OpLabel %19 = OpLoad %v3float %P %21 = OpCompositeExtract %float %19 0 %22 = OpCompositeExtract %float %19 1 %23 = OpCompositeExtract %float %19 2 %24 = OpCompositeConstruct %v4float %21 %22 %23 %float_1 %26 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %26 %24 ;CHECK: OpStore %26 %24 %29 = OpAccessChain %_ptr_Output_float %_ %int_1 OpStore %29 %float_1 ;CHECK-NOT: OpStore %29 %float_1 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); std::unordered_set live_inputs; std::unordered_set live_builtins; // Omit spv::BuiltIn::PointSize live_builtins.insert((uint32_t)spv::BuiltIn::ClipDistance); live_builtins.insert((uint32_t)spv::BuiltIn::CullDistance); SinglePassRunAndMatch(text, true, &live_inputs, &live_builtins); } TEST_F(ElimDeadOutputStoresTest, ArrayedBuiltins) { // Tests elimination of arrayed builtins as seen in geom, tesc, and tese // shaders. // // #version 460 // // layout(triangle_strip, max_vertices = 3) out; // layout(triangles) in; // // void main() // { // for (int i = 0; i < 3; i++) // { // gl_Position = gl_in[i].gl_Position; // gl_PointSize = gl_in[i].gl_PointSize; // // EmitVertex(); // } // // EndPrimitive(); // } const std::string text = R"( OpCapability Geometry OpCapability GeometryPointSize %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Geometry %main "main" %_ %gl_in OpExecutionMode %main Triangles OpExecutionMode %main Invocations 1 OpExecutionMode %main OutputTriangleStrip OpExecutionMode %main OutputVertices 3 OpSource GLSL 460 OpName %main "main" OpName %i "i" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpMemberName %gl_PerVertex 1 "gl_PointSize" OpMemberName %gl_PerVertex 2 "gl_ClipDistance" OpMemberName %gl_PerVertex 3 "gl_CullDistance" OpName %_ "" OpName %gl_PerVertex_0 "gl_PerVertex" OpMemberName %gl_PerVertex_0 0 "gl_Position" OpMemberName %gl_PerVertex_0 1 "gl_PointSize" OpMemberName %gl_PerVertex_0 2 "gl_ClipDistance" OpMemberName %gl_PerVertex_0 3 "gl_CullDistance" OpName %gl_in "gl_in" OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex 3 BuiltIn CullDistance OpDecorate %gl_PerVertex Block OpMemberDecorate %gl_PerVertex_0 0 BuiltIn Position OpMemberDecorate %gl_PerVertex_0 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex_0 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex_0 3 BuiltIn CullDistance OpDecorate %gl_PerVertex_0 Block %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_3 = OpConstant %int 3 %bool = OpTypeBool %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex %_ = OpVariable %_ptr_Output_gl_PerVertex Output %gl_PerVertex_0 = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %uint_3 = OpConstant %uint 3 %_arr_gl_PerVertex_0_uint_3 = OpTypeArray %gl_PerVertex_0 %uint_3 %_ptr_Input__arr_gl_PerVertex_0_uint_3 = OpTypePointer Input %_arr_gl_PerVertex_0_uint_3 %gl_in = OpVariable %_ptr_Input__arr_gl_PerVertex_0_uint_3 Input %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %int_1 = OpConstant %int 1 %_ptr_Input_float = OpTypePointer Input %float %_ptr_Output_float = OpTypePointer Output %float %main = OpFunction %void None %3 %5 = OpLabel %i = OpVariable %_ptr_Function_int Function OpStore %i %int_0 OpBranch %10 %10 = OpLabel OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %15 = OpLoad %int %i %18 = OpSLessThan %bool %15 %int_3 OpBranchConditional %18 %11 %12 %11 = OpLabel %32 = OpLoad %int %i %34 = OpAccessChain %_ptr_Input_v4float %gl_in %32 %int_0 %35 = OpLoad %v4float %34 %37 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %37 %35 ;CHECK: OpStore %37 %35 %39 = OpLoad %int %i %41 = OpAccessChain %_ptr_Input_float %gl_in %39 %int_1 %42 = OpLoad %float %41 %44 = OpAccessChain %_ptr_Output_float %_ %int_1 OpStore %44 %42 ;CHECK-NOT: OpStore %44 %42 OpEmitVertex OpBranch %13 %13 = OpLabel %45 = OpLoad %int %i %46 = OpIAdd %int %45 %int_1 OpStore %i %46 OpBranch %10 %12 = OpLabel OpEndPrimitive OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); std::unordered_set live_inputs; std::unordered_set live_builtins; // Omit spv::BuiltIn::PointSize live_builtins.insert((uint32_t)spv::BuiltIn::ClipDistance); live_builtins.insert((uint32_t)spv::BuiltIn::CullDistance); SinglePassRunAndMatch(text, true, &live_inputs, &live_builtins); } TEST_F(ElimDeadOutputStoresTest, ArrayedOutputPatchLocs) { // Tests elimination of location with arrayed patch output as seen in // Tesc shaders. // // #version 450 core // // layout(vertices = 4) out; // // layout(location=0) patch out float patchOut0[2]; // layout(location=2) patch out float patchOut1[2]; // // void main() // { // patchOut0[1] = 0.0; // Dead loc 1 // patchOut1[1] = 1.0; // Live loc 3 // } const std::string text = R"( OpCapability Tessellation %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %main "main" %patchOut0 %patchOut1 OpExecutionMode %main OutputVertices 4 OpSource GLSL 450 OpName %main "main" OpName %patchOut0 "patchOut0" OpName %patchOut1 "patchOut1" OpDecorate %patchOut0 Patch OpDecorate %patchOut0 Location 0 OpDecorate %patchOut1 Patch OpDecorate %patchOut1 Location 2 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_arr_float_uint_2 = OpTypeArray %float %uint_2 %_ptr_Output__arr_float_uint_2 = OpTypePointer Output %_arr_float_uint_2 %patchOut0 = OpVariable %_ptr_Output__arr_float_uint_2 Output %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %float_0 = OpConstant %float 0 %_ptr_Output_float = OpTypePointer Output %float %patchOut1 = OpVariable %_ptr_Output__arr_float_uint_2 Output %float_1 = OpConstant %float 1 %main = OpFunction %void None %3 %5 = OpLabel %16 = OpAccessChain %_ptr_Output_float %patchOut0 %int_1 OpStore %16 %float_0 ;CHECK-NOT: OpStore %16 %float_0 %19 = OpAccessChain %_ptr_Output_float %patchOut1 %int_1 OpStore %19 %float_1 ;CHECK: OpStore %19 %float_1 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); std::unordered_set live_inputs; std::unordered_set live_builtins; live_inputs.insert(3); SinglePassRunAndMatch(text, true, &live_inputs, &live_builtins); } TEST_F(ElimDeadOutputStoresTest, VertMultipleLocationsF16) { // #version 450 // // layout(location = 2) out Vertex // { // f16vec4 color0; // f16vec4 color1; // f16vec4 color2[3]; // } oVert; // // void main() // { // oVert.color0 = f16vec4(0.0,0.0,0.0,0.0); // oVert.color1 = f16vec4(0.1,0.0,0.0,0.0); // oVert.color2[0] = f16vec4(0.2,0.0,0.0,0.0); // oVert.color2[1] = f16vec4(0.3,0.0,0.0,0.0); // oVert.color2[2] = f16vec4(0.4,0.0,0.0,0.0); // } const std::string text = R"( OpCapability Shader OpCapability Float16 OpCapability StorageInputOutput16 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %oVert OpSource GLSL 450 OpName %main "main" OpName %Vertex "Vertex" OpMemberName %Vertex 0 "color0" OpMemberName %Vertex 1 "color1" OpMemberName %Vertex 2 "color2" OpName %oVert "oVert" OpDecorate %Vertex Block OpDecorate %oVert Location 2 %void = OpTypeVoid %3 = OpTypeFunction %void %half = OpTypeFloat 32 %v4half = OpTypeVector %half 4 %uint = OpTypeInt 32 0 %uint_3 = OpConstant %uint 3 %_arr_v4half_uint_3 = OpTypeArray %v4half %uint_3 %Vertex = OpTypeStruct %v4half %v4half %_arr_v4half_uint_3 %_ptr_Output_Vertex = OpTypePointer Output %Vertex %oVert = OpVariable %_ptr_Output_Vertex Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %half_0 = OpConstant %half 0 %17 = OpConstantComposite %v4half %half_0 %half_0 %half_0 %half_0 %_ptr_Output_v4half = OpTypePointer Output %v4half %int_1 = OpConstant %int 1 %half_0_100000001 = OpConstant %half 0.100000001 %22 = OpConstantComposite %v4half %half_0_100000001 %half_0 %half_0 %half_0 %int_2 = OpConstant %int 2 %half_0_200000003 = OpConstant %half 0.200000003 %26 = OpConstantComposite %v4half %half_0_200000003 %half_0 %half_0 %half_0 %half_0_300000012 = OpConstant %half 0.300000012 %29 = OpConstantComposite %v4half %half_0_300000012 %half_0 %half_0 %half_0 %half_0_400000006 = OpConstant %half 0.400000006 %32 = OpConstantComposite %v4half %half_0_400000006 %half_0 %half_0 %half_0 %main = OpFunction %void None %3 %5 = OpLabel %19 = OpAccessChain %_ptr_Output_v4half %oVert %int_0 OpStore %19 %17 ;CHECK: OpStore %19 %17 %23 = OpAccessChain %_ptr_Output_v4half %oVert %int_1 OpStore %23 %22 ;CHECK-NOT: OpStore %23 %22 %27 = OpAccessChain %_ptr_Output_v4half %oVert %int_2 %int_0 OpStore %27 %26 ;CHECK-NOT: OpStore %27 %26 %30 = OpAccessChain %_ptr_Output_v4half %oVert %int_2 %int_1 OpStore %30 %29 ;CHECK: OpStore %30 %29 %33 = OpAccessChain %_ptr_Output_v4half %oVert %int_2 %int_2 OpStore %33 %32 ;CHECK-NOT: OpStore %33 %32 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); std::unordered_set live_inputs; std::unordered_set live_builtins; live_inputs.insert(2); live_inputs.insert(5); SinglePassRunAndMatch(text, true, &live_inputs, &live_builtins); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/feature_manager_test.cpp000066400000000000000000000130001475742701700251740ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gtest/gtest.h" #include "source/opt/build_module.h" #include "source/opt/ir_context.h" namespace spvtools { namespace opt { namespace { using FeatureManagerTest = ::testing::Test; TEST_F(FeatureManagerTest, MissingExtension) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); ASSERT_NE(context, nullptr); EXPECT_FALSE(context->get_feature_mgr()->HasExtension( Extension::kSPV_KHR_variable_pointers)); } TEST_F(FeatureManagerTest, OneExtension) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpExtension "SPV_KHR_variable_pointers" )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); ASSERT_NE(context, nullptr); EXPECT_TRUE(context->get_feature_mgr()->HasExtension( Extension::kSPV_KHR_variable_pointers)); } TEST_F(FeatureManagerTest, NotADifferentExtension) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpExtension "SPV_KHR_variable_pointers" )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); ASSERT_NE(context, nullptr); EXPECT_FALSE(context->get_feature_mgr()->HasExtension( Extension::kSPV_KHR_storage_buffer_storage_class)); } TEST_F(FeatureManagerTest, TwoExtensions) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpExtension "SPV_KHR_variable_pointers" OpExtension "SPV_KHR_storage_buffer_storage_class" )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); ASSERT_NE(context, nullptr); EXPECT_TRUE(context->get_feature_mgr()->HasExtension( Extension::kSPV_KHR_variable_pointers)); EXPECT_TRUE(context->get_feature_mgr()->HasExtension( Extension::kSPV_KHR_storage_buffer_storage_class)); } TEST_F(FeatureManagerTest, GetExtensionsReturnsExtensions) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpExtension "SPV_KHR_variable_pointers" OpExtension "SPV_KHR_storage_buffer_storage_class" )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); ASSERT_NE(context, nullptr); const auto& extensions = context->get_feature_mgr()->GetExtensions(); EXPECT_EQ(extensions.size(), 2); EXPECT_TRUE(extensions.contains(Extension::kSPV_KHR_variable_pointers)); EXPECT_TRUE( extensions.contains(Extension::kSPV_KHR_storage_buffer_storage_class)); } // Test capability checks. TEST_F(FeatureManagerTest, ExplicitlyPresent1) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); ASSERT_NE(context, nullptr); EXPECT_TRUE( context->get_feature_mgr()->HasCapability(spv::Capability::Shader)); EXPECT_FALSE( context->get_feature_mgr()->HasCapability(spv::Capability::Kernel)); } TEST_F(FeatureManagerTest, ExplicitlyPresent2) { const std::string text = R"( OpCapability Kernel OpMemoryModel Logical GLSL450 )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); ASSERT_NE(context, nullptr); EXPECT_FALSE( context->get_feature_mgr()->HasCapability(spv::Capability::Shader)); EXPECT_TRUE( context->get_feature_mgr()->HasCapability(spv::Capability::Kernel)); } TEST_F(FeatureManagerTest, ImplicitlyPresent) { const std::string text = R"( OpCapability Tessellation OpMemoryModel Logical GLSL450 )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); ASSERT_NE(context, nullptr); // Check multiple levels of indirection. Tessellation implies Shader, which // implies Matrix. EXPECT_TRUE( context->get_feature_mgr()->HasCapability(spv::Capability::Tessellation)); EXPECT_TRUE( context->get_feature_mgr()->HasCapability(spv::Capability::Shader)); EXPECT_TRUE( context->get_feature_mgr()->HasCapability(spv::Capability::Matrix)); EXPECT_FALSE( context->get_feature_mgr()->HasCapability(spv::Capability::Kernel)); } TEST_F(FeatureManagerTest, GetCapabilitiesReturnsImplicitCapabilities) { const std::string text = R"( OpCapability Tessellation OpMemoryModel Logical GLSL450 )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); ASSERT_NE(context, nullptr); const auto& capabilities = context->get_feature_mgr()->GetCapabilities(); // Tesselation implies Shader, which implies Matrix. EXPECT_EQ(capabilities.size(), 3); EXPECT_TRUE(capabilities.contains(spv::Capability::Tessellation)); EXPECT_TRUE(capabilities.contains(spv::Capability::Shader)); EXPECT_TRUE(capabilities.contains(spv::Capability::Matrix)); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/fix_func_call_arguments_test.cpp000066400000000000000000000120421475742701700267350ustar00rootroot00000000000000// Copyright (c) 2022 Advanced Micro Devices, Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using FixFuncCallArgumentsTest = PassTest<::testing::Test>; TEST_F(FixFuncCallArgumentsTest, Simple) { const std::string text = R"( ; ; CHECK: [[v0:%\w+]] = OpVariable %_ptr_Function_float Function ; CHECK: [[v1:%\w+]] = OpVariable %_ptr_Function_float Function ; CHECK: [[v2:%\w+]] = OpVariable %_ptr_Function_T Function ; CHECK: [[ac0:%\w+]] = OpAccessChain %_ptr_Function_float %t %int_0 ; CHECK: [[ac1:%\w+]] = OpAccessChain %_ptr_Uniform_float %r1 %int_0 %uint_0 ; CHECK: [[ld0:%\w+]] = OpLoad %float [[ac0]] ; CHECK: OpStore [[v1]] [[ld0]] ; CHECK: [[ld1:%\w+]] = OpLoad %float [[ac1]] ; CHECK: OpStore [[v0]] [[ld1]] ; CHECK: [[func:%\w+]] = OpFunctionCall %void %fn [[v1]] [[v0]] ; CHECK: [[ld2:%\w+]] = OpLoad %float [[v0]] ; CHECK: OpStore [[ac1]] [[ld2]] ; CHECK: [[ld3:%\w+]] = OpLoad %float [[v1]] ; CHECK: OpStore [[ac0]] [[ld3]] ; OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpSource HLSL 630 OpName %type_RWStructuredBuffer_float "type.RWStructuredBuffer.float" OpName %r1 "r1" OpName %type_ACSBuffer_counter "type.ACSBuffer.counter" OpMemberName %type_ACSBuffer_counter 0 "counter" OpName %counter_var_r1 "counter.var.r1" OpName %main "main" OpName %bb_entry "bb.entry" OpName %T "T" OpMemberName %T 0 "t0" OpName %t "t" OpName %fn "fn" OpName %p0 "p0" OpName %p2 "p2" OpName %bb_entry_0 "bb.entry" OpDecorate %main LinkageAttributes "main" Export OpDecorate %r1 DescriptorSet 0 OpDecorate %r1 Binding 0 OpDecorate %counter_var_r1 DescriptorSet 0 OpDecorate %counter_var_r1 Binding 1 OpDecorate %_runtimearr_float ArrayStride 4 OpMemberDecorate %type_RWStructuredBuffer_float 0 Offset 0 OpDecorate %type_RWStructuredBuffer_float BufferBlock OpMemberDecorate %type_ACSBuffer_counter 0 Offset 0 OpDecorate %type_ACSBuffer_counter BufferBlock %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %int_1 = OpConstant %int 1 %float = OpTypeFloat 32 %_runtimearr_float = OpTypeRuntimeArray %float %type_RWStructuredBuffer_float = OpTypeStruct %_runtimearr_float %_ptr_Uniform_type_RWStructuredBuffer_float = OpTypePointer Uniform %type_RWStructuredBuffer_float %type_ACSBuffer_counter = OpTypeStruct %int %_ptr_Uniform_type_ACSBuffer_counter = OpTypePointer Uniform %type_ACSBuffer_counter %15 = OpTypeFunction %int %T = OpTypeStruct %float %_ptr_Function_T = OpTypePointer Function %T %_ptr_Function_float = OpTypePointer Function %float %_ptr_Uniform_float = OpTypePointer Uniform %float %void = OpTypeVoid %27 = OpTypeFunction %void %_ptr_Function_float %_ptr_Function_float %r1 = OpVariable %_ptr_Uniform_type_RWStructuredBuffer_float Uniform %counter_var_r1 = OpVariable %_ptr_Uniform_type_ACSBuffer_counter Uniform %main = OpFunction %int None %15 %bb_entry = OpLabel %t = OpVariable %_ptr_Function_T Function %21 = OpAccessChain %_ptr_Function_float %t %int_0 %23 = OpAccessChain %_ptr_Uniform_float %r1 %int_0 %uint_0 %25 = OpFunctionCall %void %fn %21 %23 OpReturnValue %int_1 OpFunctionEnd %fn = OpFunction %void DontInline %27 %p0 = OpFunctionParameter %_ptr_Function_float %p2 = OpFunctionParameter %_ptr_Function_float %bb_entry_0 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(FixFuncCallArgumentsTest, NotAccessChainInput) { const std::string text = R"( ; ; CHECK: [[o:%\w+]] = OpCopyObject %_ptr_Function_float %t ; CHECK: [[func:%\w+]] = OpFunctionCall %void %fn [[o]] ; OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpSource HLSL 630 OpName %main "main" OpName %bb_entry "bb.entry" OpName %t "t" OpName %fn "fn" OpName %p0 "p0" OpName %bb_entry_0 "bb.entry" OpDecorate %main LinkageAttributes "main" Export %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %4 = OpTypeFunction %int %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %void = OpTypeVoid %12 = OpTypeFunction %void %_ptr_Function_float %main = OpFunction %int None %4 %bb_entry = OpLabel %t = OpVariable %_ptr_Function_float Function %t1 = OpCopyObject %_ptr_Function_float %t %10 = OpFunctionCall %void %fn %t1 OpReturnValue %int_1 OpFunctionEnd %fn = OpFunction %void DontInline %12 %p0 = OpFunctionParameter %_ptr_Function_float %bb_entry_0 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } } // namespace } // namespace opt } // namespace spvtoolsKhronosGroup-SPIRV-Tools-f289d04/test/opt/fix_storage_class_test.cpp000066400000000000000000001256201475742701700255620ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using FixStorageClassTest = PassTest<::testing::Test>; TEST_F(FixStorageClassTest, FixAccessChain) { const std::string text = R"( ; CHECK: OpAccessChain %_ptr_Workgroup_float ; CHECK: OpAccessChain %_ptr_Uniform_float OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "testMain" %gl_GlobalInvocationID %gl_LocalInvocationID %gl_WorkGroupID OpExecutionMode %1 LocalSize 8 8 1 OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId OpDecorate %gl_LocalInvocationID BuiltIn LocalInvocationId OpDecorate %gl_WorkGroupID BuiltIn WorkgroupId OpDecorate %8 DescriptorSet 0 OpDecorate %8 Binding 0 OpDecorate %_runtimearr_float ArrayStride 4 OpMemberDecorate %_struct_7 0 Offset 0 OpDecorate %_struct_7 BufferBlock %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %float_2 = OpConstant %float 2 %uint = OpTypeInt 32 0 %uint_10 = OpConstant %uint 10 %_arr_float_uint_10 = OpTypeArray %float %uint_10 %ptr = OpTypePointer Function %_arr_float_uint_10 %_arr__arr_float_uint_10_uint_10 = OpTypeArray %_arr_float_uint_10 %uint_10 %_struct_5 = OpTypeStruct %_arr__arr_float_uint_10_uint_10 %_ptr_Workgroup__struct_5 = OpTypePointer Workgroup %_struct_5 %_runtimearr_float = OpTypeRuntimeArray %float %_struct_7 = OpTypeStruct %_runtimearr_float %_ptr_Uniform__struct_7 = OpTypePointer Uniform %_struct_7 %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %void = OpTypeVoid %30 = OpTypeFunction %void %_ptr_Function_float = OpTypePointer Function %float %_ptr_Uniform_float = OpTypePointer Uniform %float %6 = OpVariable %_ptr_Workgroup__struct_5 Workgroup %8 = OpVariable %_ptr_Uniform__struct_7 Uniform %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %gl_LocalInvocationID = OpVariable %_ptr_Input_v3uint Input %gl_WorkGroupID = OpVariable %_ptr_Input_v3uint Input %1 = OpFunction %void None %30 %38 = OpLabel %44 = OpLoad %v3uint %gl_LocalInvocationID %50 = OpAccessChain %_ptr_Function_float %6 %int_0 %int_0 %int_0 %51 = OpLoad %float %50 %52 = OpFMul %float %float_2 %51 OpStore %50 %52 %55 = OpLoad %float %50 %59 = OpCompositeExtract %uint %44 0 %60 = OpAccessChain %_ptr_Uniform_float %8 %int_0 %59 OpStore %60 %55 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(FixStorageClassTest, FixLinkedAccessChain) { const std::string text = R"( ; CHECK: OpAccessChain %_ptr_Workgroup__arr_float_uint_10 ; CHECK: OpAccessChain %_ptr_Workgroup_float ; CHECK: OpAccessChain %_ptr_Uniform_float OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "testMain" %gl_GlobalInvocationID %gl_LocalInvocationID %gl_WorkGroupID OpExecutionMode %1 LocalSize 8 8 1 OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId OpDecorate %gl_LocalInvocationID BuiltIn LocalInvocationId OpDecorate %gl_WorkGroupID BuiltIn WorkgroupId OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 0 OpDecorate %_runtimearr_float ArrayStride 4 OpMemberDecorate %_struct_7 0 Offset 0 OpDecorate %_struct_7 BufferBlock %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %float_2 = OpConstant %float 2 %uint = OpTypeInt 32 0 %uint_10 = OpConstant %uint 10 %_arr_float_uint_10 = OpTypeArray %float %uint_10 %_ptr_Function__arr_float_uint_10 = OpTypePointer Function %_arr_float_uint_10 %_ptr = OpTypePointer Function %_arr_float_uint_10 %_arr__arr_float_uint_10_uint_10 = OpTypeArray %_arr_float_uint_10 %uint_10 %_struct_17 = OpTypeStruct %_arr__arr_float_uint_10_uint_10 %_ptr_Workgroup__struct_17 = OpTypePointer Workgroup %_struct_17 %_runtimearr_float = OpTypeRuntimeArray %float %_struct_7 = OpTypeStruct %_runtimearr_float %_ptr_Uniform__struct_7 = OpTypePointer Uniform %_struct_7 %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %void = OpTypeVoid %23 = OpTypeFunction %void %_ptr_Function_float = OpTypePointer Function %float %_ptr_Uniform_float = OpTypePointer Uniform %float %27 = OpVariable %_ptr_Workgroup__struct_17 Workgroup %5 = OpVariable %_ptr_Uniform__struct_7 Uniform %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %gl_LocalInvocationID = OpVariable %_ptr_Input_v3uint Input %gl_WorkGroupID = OpVariable %_ptr_Input_v3uint Input %1 = OpFunction %void None %23 %28 = OpLabel %29 = OpLoad %v3uint %gl_LocalInvocationID %30 = OpAccessChain %_ptr_Function__arr_float_uint_10 %27 %int_0 %int_0 %31 = OpAccessChain %_ptr_Function_float %30 %int_0 %32 = OpLoad %float %31 %33 = OpFMul %float %float_2 %32 OpStore %31 %33 %34 = OpLoad %float %31 %35 = OpCompositeExtract %uint %29 0 %36 = OpAccessChain %_ptr_Uniform_float %5 %int_0 %35 OpStore %36 %34 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(FixStorageClassTest, FixCopyObject) { const std::string text = R"( ; CHECK: OpCopyObject %_ptr_Workgroup__struct_17 ; CHECK: OpAccessChain %_ptr_Workgroup_float ; CHECK: OpAccessChain %_ptr_Uniform_float OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "testMain" %gl_GlobalInvocationID %gl_LocalInvocationID %gl_WorkGroupID OpExecutionMode %1 LocalSize 8 8 1 OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId OpDecorate %gl_LocalInvocationID BuiltIn LocalInvocationId OpDecorate %gl_WorkGroupID BuiltIn WorkgroupId OpDecorate %8 DescriptorSet 0 OpDecorate %8 Binding 0 OpDecorate %_runtimearr_float ArrayStride 4 OpMemberDecorate %_struct_7 0 Offset 0 OpDecorate %_struct_7 BufferBlock %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %float_2 = OpConstant %float 2 %uint = OpTypeInt 32 0 %uint_10 = OpConstant %uint 10 %_arr_float_uint_10 = OpTypeArray %float %uint_10 %ptr = OpTypePointer Function %_arr_float_uint_10 %_arr__arr_float_uint_10_uint_10 = OpTypeArray %_arr_float_uint_10 %uint_10 %_struct_17 = OpTypeStruct %_arr__arr_float_uint_10_uint_10 %_ptr_Workgroup__struct_17 = OpTypePointer Workgroup %_struct_17 %_ptr_Function__struct_17 = OpTypePointer Function %_struct_17 %_runtimearr_float = OpTypeRuntimeArray %float %_struct_7 = OpTypeStruct %_runtimearr_float %_ptr_Uniform__struct_7 = OpTypePointer Uniform %_struct_7 %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %void = OpTypeVoid %30 = OpTypeFunction %void %_ptr_Function_float = OpTypePointer Function %float %_ptr_Uniform_float = OpTypePointer Uniform %float %6 = OpVariable %_ptr_Workgroup__struct_17 Workgroup %8 = OpVariable %_ptr_Uniform__struct_7 Uniform %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %gl_LocalInvocationID = OpVariable %_ptr_Input_v3uint Input %gl_WorkGroupID = OpVariable %_ptr_Input_v3uint Input %1 = OpFunction %void None %30 %38 = OpLabel %44 = OpLoad %v3uint %gl_LocalInvocationID %cp = OpCopyObject %_ptr_Function__struct_17 %6 %50 = OpAccessChain %_ptr_Function_float %cp %int_0 %int_0 %int_0 %51 = OpLoad %float %50 %52 = OpFMul %float %float_2 %51 OpStore %50 %52 %55 = OpLoad %float %50 %59 = OpCompositeExtract %uint %44 0 %60 = OpAccessChain %_ptr_Uniform_float %8 %int_0 %59 OpStore %60 %55 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(FixStorageClassTest, FixPhiInSelMerge) { const std::string text = R"( ; CHECK: OpPhi %_ptr_Workgroup__struct_19 ; CHECK: OpAccessChain %_ptr_Workgroup_float ; CHECK: OpAccessChain %_ptr_Uniform_float OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "testMain" %gl_GlobalInvocationID %gl_LocalInvocationID %gl_WorkGroupID OpExecutionMode %1 LocalSize 8 8 1 OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId OpDecorate %gl_LocalInvocationID BuiltIn LocalInvocationId OpDecorate %gl_WorkGroupID BuiltIn WorkgroupId OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 0 OpDecorate %_runtimearr_float ArrayStride 4 OpMemberDecorate %_struct_7 0 Offset 0 OpDecorate %_struct_7 BufferBlock %bool = OpTypeBool %true = OpConstantTrue %bool %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %float_2 = OpConstant %float 2 %uint = OpTypeInt 32 0 %uint_10 = OpConstant %uint 10 %_arr_float_uint_10 = OpTypeArray %float %uint_10 %_ptr_Function__arr_float_uint_10 = OpTypePointer Function %_arr_float_uint_10 %_arr__arr_float_uint_10_uint_10 = OpTypeArray %_arr_float_uint_10 %uint_10 %_struct_19 = OpTypeStruct %_arr__arr_float_uint_10_uint_10 %_ptr_Workgroup__struct_19 = OpTypePointer Workgroup %_struct_19 %_ptr_Function__struct_19 = OpTypePointer Function %_struct_19 %_runtimearr_float = OpTypeRuntimeArray %float %_struct_7 = OpTypeStruct %_runtimearr_float %_ptr_Uniform__struct_7 = OpTypePointer Uniform %_struct_7 %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %void = OpTypeVoid %25 = OpTypeFunction %void %_ptr_Function_float = OpTypePointer Function %float %_ptr_Uniform_float = OpTypePointer Uniform %float %28 = OpVariable %_ptr_Workgroup__struct_19 Workgroup %29 = OpVariable %_ptr_Workgroup__struct_19 Workgroup %5 = OpVariable %_ptr_Uniform__struct_7 Uniform %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %gl_LocalInvocationID = OpVariable %_ptr_Input_v3uint Input %gl_WorkGroupID = OpVariable %_ptr_Input_v3uint Input %1 = OpFunction %void None %25 %30 = OpLabel OpSelectionMerge %31 None OpBranchConditional %true %32 %31 %32 = OpLabel OpBranch %31 %31 = OpLabel %33 = OpPhi %_ptr_Function__struct_19 %28 %30 %29 %32 %34 = OpLoad %v3uint %gl_LocalInvocationID %35 = OpAccessChain %_ptr_Function_float %33 %int_0 %int_0 %int_0 %36 = OpLoad %float %35 %37 = OpFMul %float %float_2 %36 OpStore %35 %37 %38 = OpLoad %float %35 %39 = OpCompositeExtract %uint %34 0 %40 = OpAccessChain %_ptr_Uniform_float %5 %int_0 %39 OpStore %40 %38 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(FixStorageClassTest, FixPhiInLoop) { const std::string text = R"( ; CHECK: OpPhi %_ptr_Workgroup__struct_19 ; CHECK: OpAccessChain %_ptr_Workgroup_float ; CHECK: OpAccessChain %_ptr_Uniform_float OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "testMain" %gl_GlobalInvocationID %gl_LocalInvocationID %gl_WorkGroupID OpExecutionMode %1 LocalSize 8 8 1 OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId OpDecorate %gl_LocalInvocationID BuiltIn LocalInvocationId OpDecorate %gl_WorkGroupID BuiltIn WorkgroupId OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 0 OpDecorate %_runtimearr_float ArrayStride 4 OpMemberDecorate %_struct_7 0 Offset 0 OpDecorate %_struct_7 BufferBlock %bool = OpTypeBool %true = OpConstantTrue %bool %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %float_2 = OpConstant %float 2 %uint = OpTypeInt 32 0 %uint_10 = OpConstant %uint 10 %_arr_float_uint_10 = OpTypeArray %float %uint_10 %_ptr_Function__arr_float_uint_10 = OpTypePointer Function %_arr_float_uint_10 %_arr__arr_float_uint_10_uint_10 = OpTypeArray %_arr_float_uint_10 %uint_10 %_struct_19 = OpTypeStruct %_arr__arr_float_uint_10_uint_10 %_ptr_Workgroup__struct_19 = OpTypePointer Workgroup %_struct_19 %_ptr_Function__struct_19 = OpTypePointer Function %_struct_19 %_runtimearr_float = OpTypeRuntimeArray %float %_struct_7 = OpTypeStruct %_runtimearr_float %_ptr_Uniform__struct_7 = OpTypePointer Uniform %_struct_7 %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %void = OpTypeVoid %25 = OpTypeFunction %void %_ptr_Function_float = OpTypePointer Function %float %_ptr_Uniform_float = OpTypePointer Uniform %float %28 = OpVariable %_ptr_Workgroup__struct_19 Workgroup %29 = OpVariable %_ptr_Workgroup__struct_19 Workgroup %5 = OpVariable %_ptr_Uniform__struct_7 Uniform %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %gl_LocalInvocationID = OpVariable %_ptr_Input_v3uint Input %gl_WorkGroupID = OpVariable %_ptr_Input_v3uint Input %1 = OpFunction %void None %25 %30 = OpLabel OpSelectionMerge %31 None OpBranchConditional %true %32 %31 %32 = OpLabel OpBranch %31 %31 = OpLabel %33 = OpPhi %_ptr_Function__struct_19 %28 %30 %29 %32 %34 = OpLoad %v3uint %gl_LocalInvocationID %35 = OpAccessChain %_ptr_Function_float %33 %int_0 %int_0 %int_0 %36 = OpLoad %float %35 %37 = OpFMul %float %float_2 %36 OpStore %35 %37 %38 = OpLoad %float %35 %39 = OpCompositeExtract %uint %34 0 %40 = OpAccessChain %_ptr_Uniform_float %5 %int_0 %39 OpStore %40 %38 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(FixStorageClassTest, DontChangeFunctionCalls) { const std::string text = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "testMain" OpExecutionMode %1 LocalSize 8 8 1 OpDecorate %2 DescriptorSet 0 OpDecorate %2 Binding 0 %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %_ptr_Workgroup_int = OpTypePointer Workgroup %int %_ptr_Uniform_int = OpTypePointer Uniform %int %void = OpTypeVoid %8 = OpTypeFunction %void %9 = OpTypeFunction %_ptr_Uniform_int %_ptr_Function_int %10 = OpVariable %_ptr_Workgroup_int Workgroup %2 = OpVariable %_ptr_Uniform_int Uniform %1 = OpFunction %void None %8 %11 = OpLabel %12 = OpFunctionCall %_ptr_Uniform_int %13 %10 OpReturn OpFunctionEnd %13 = OpFunction %_ptr_Uniform_int None %9 %14 = OpFunctionParameter %_ptr_Function_int %15 = OpLabel OpReturnValue %2 OpFunctionEnd )"; SinglePassRunAndCheck(text, text, false, false); } TEST_F(FixStorageClassTest, FixSelect) { const std::string text = R"( ; CHECK: OpSelect %_ptr_Workgroup__struct_19 ; CHECK: OpAccessChain %_ptr_Workgroup_float ; CHECK: OpAccessChain %_ptr_Uniform_float OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "testMain" %gl_GlobalInvocationID %gl_LocalInvocationID %gl_WorkGroupID OpExecutionMode %1 LocalSize 8 8 1 OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId OpDecorate %gl_LocalInvocationID BuiltIn LocalInvocationId OpDecorate %gl_WorkGroupID BuiltIn WorkgroupId OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 0 OpDecorate %_runtimearr_float ArrayStride 4 OpMemberDecorate %_struct_7 0 Offset 0 OpDecorate %_struct_7 BufferBlock %bool = OpTypeBool %true = OpConstantTrue %bool %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %float_2 = OpConstant %float 2 %uint = OpTypeInt 32 0 %uint_10 = OpConstant %uint 10 %_arr_float_uint_10 = OpTypeArray %float %uint_10 %_ptr_Function__arr_float_uint_10 = OpTypePointer Function %_arr_float_uint_10 %_arr__arr_float_uint_10_uint_10 = OpTypeArray %_arr_float_uint_10 %uint_10 %_struct_19 = OpTypeStruct %_arr__arr_float_uint_10_uint_10 %_ptr_Workgroup__struct_19 = OpTypePointer Workgroup %_struct_19 %_ptr_Function__struct_19 = OpTypePointer Function %_struct_19 %_runtimearr_float = OpTypeRuntimeArray %float %_struct_7 = OpTypeStruct %_runtimearr_float %_ptr_Uniform__struct_7 = OpTypePointer Uniform %_struct_7 %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %void = OpTypeVoid %25 = OpTypeFunction %void %_ptr_Function_float = OpTypePointer Function %float %_ptr_Uniform_float = OpTypePointer Uniform %float %28 = OpVariable %_ptr_Workgroup__struct_19 Workgroup %29 = OpVariable %_ptr_Workgroup__struct_19 Workgroup %5 = OpVariable %_ptr_Uniform__struct_7 Uniform %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %gl_LocalInvocationID = OpVariable %_ptr_Input_v3uint Input %gl_WorkGroupID = OpVariable %_ptr_Input_v3uint Input %1 = OpFunction %void None %25 %30 = OpLabel %33 = OpSelect %_ptr_Function__struct_19 %true %28 %29 %34 = OpLoad %v3uint %gl_LocalInvocationID %35 = OpAccessChain %_ptr_Function_float %33 %int_0 %int_0 %int_0 %36 = OpLoad %float %35 %37 = OpFMul %float %float_2 %36 OpStore %35 %37 %38 = OpLoad %float %35 %39 = OpCompositeExtract %uint %34 0 %40 = OpAccessChain %_ptr_Uniform_float %5 %int_0 %39 OpStore %40 %38 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(FixStorageClassTest, BitCast) { const std::string text = R"(OpCapability VariablePointersStorageBuffer OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %3 = OpTypeFunction %void %_ptr_Output_void = OpTypePointer Output %void %_ptr_Private__ptr_Output_void = OpTypePointer Private %_ptr_Output_void %6 = OpVariable %_ptr_Private__ptr_Output_void Private %1 = OpFunction %void Inline %3 %7 = OpLabel %8 = OpBitcast %_ptr_Output_void %6 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(text, text, false); } TEST_F(FixStorageClassTest, FixLinkedAccessChain2) { // This case is similar to FixLinkedAccessChain. The difference is that the // first OpAccessChain instruction starts as workgroup storage class. Only // the second one needs to change. const std::string text = R"( ; CHECK: OpAccessChain %_ptr_Workgroup__arr_float_uint_10 ; CHECK: OpAccessChain %_ptr_Workgroup_float ; CHECK: OpAccessChain %_ptr_Uniform_float OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "testMain" %gl_GlobalInvocationID %gl_LocalInvocationID %gl_WorkGroupID OpExecutionMode %1 LocalSize 8 8 1 OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId OpDecorate %gl_LocalInvocationID BuiltIn LocalInvocationId OpDecorate %gl_WorkGroupID BuiltIn WorkgroupId OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 0 OpDecorate %_runtimearr_float ArrayStride 4 OpMemberDecorate %_struct_7 0 Offset 0 OpDecorate %_struct_7 BufferBlock %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %float_2 = OpConstant %float 2 %uint = OpTypeInt 32 0 %uint_10 = OpConstant %uint 10 %_arr_float_uint_10 = OpTypeArray %float %uint_10 %_ptr_Workgroup__arr_float_uint_10 = OpTypePointer Workgroup %_arr_float_uint_10 %_ptr = OpTypePointer Function %_arr_float_uint_10 %_arr__arr_float_uint_10_uint_10 = OpTypeArray %_arr_float_uint_10 %uint_10 %_struct_17 = OpTypeStruct %_arr__arr_float_uint_10_uint_10 %_ptr_Workgroup__struct_17 = OpTypePointer Workgroup %_struct_17 %_runtimearr_float = OpTypeRuntimeArray %float %_struct_7 = OpTypeStruct %_runtimearr_float %_ptr_Uniform__struct_7 = OpTypePointer Uniform %_struct_7 %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %void = OpTypeVoid %23 = OpTypeFunction %void %_ptr_Function_float = OpTypePointer Function %float %_ptr_Uniform_float = OpTypePointer Uniform %float %27 = OpVariable %_ptr_Workgroup__struct_17 Workgroup %5 = OpVariable %_ptr_Uniform__struct_7 Uniform %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %gl_LocalInvocationID = OpVariable %_ptr_Input_v3uint Input %gl_WorkGroupID = OpVariable %_ptr_Input_v3uint Input %1 = OpFunction %void None %23 %28 = OpLabel %29 = OpLoad %v3uint %gl_LocalInvocationID %30 = OpAccessChain %_ptr_Workgroup__arr_float_uint_10 %27 %int_0 %int_0 %31 = OpAccessChain %_ptr_Function_float %30 %int_0 %32 = OpLoad %float %31 %33 = OpFMul %float %float_2 %32 OpStore %31 %33 %34 = OpLoad %float %31 %35 = OpCompositeExtract %uint %29 0 %36 = OpAccessChain %_ptr_Uniform_float %5 %int_0 %35 OpStore %36 %34 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(FixStorageClassTest, AllowImageFormatMismatch) { const std::string text = R"(OpCapability Shader OpCapability SampledBuffer OpCapability ImageBuffer OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource HLSL 600 OpName %type_buffer_image "type.buffer.image" OpName %Buf "Buf" OpName %main "main" OpName %src_main "src.main" OpName %bb_entry "bb.entry" OpName %type_buffer_image_0 "type.buffer.image" OpName %b "b" OpDecorate %Buf DescriptorSet 0 OpDecorate %Buf Binding 0 %float = OpTypeFloat 32 %type_buffer_image = OpTypeImage %float Buffer 2 0 0 2 Rgba16f %_ptr_UniformConstant_type_buffer_image = OpTypePointer UniformConstant %type_buffer_image %void = OpTypeVoid %11 = OpTypeFunction %void %type_buffer_image_0 = OpTypeImage %float Buffer 2 0 0 2 Rgba32f %_ptr_Function_type_buffer_image_0 = OpTypePointer Function %type_buffer_image_0 %Buf = OpVariable %_ptr_UniformConstant_type_buffer_image UniformConstant %main = OpFunction %void None %11 %13 = OpLabel %14 = OpFunctionCall %void %src_main OpReturn OpFunctionEnd %src_main = OpFunction %void None %11 %bb_entry = OpLabel %b = OpVariable %_ptr_Function_type_buffer_image_0 Function %15 = OpLoad %type_buffer_image %Buf OpStore %b %15 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(text, text, false, false); } using FixTypeTest = PassTest<::testing::Test>; TEST_F(FixTypeTest, FixAccessChain) { const std::string text = R"( ; CHECK: [[ac1:%\w+]] = OpAccessChain %_ptr_Uniform_S %A %int_0 %uint_0 ; CHECK: [[ac2:%\w+]] = OpAccessChain %_ptr_Uniform_T [[ac1]] %int_0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource HLSL 600 OpName %type_RWStructuredBuffer_S "type.RWStructuredBuffer.S" OpName %S "S" OpMemberName %S 0 "t" OpName %T "T" OpMemberName %T 0 "a" OpName %A "A" OpName %type_ACSBuffer_counter "type.ACSBuffer.counter" OpMemberName %type_ACSBuffer_counter 0 "counter" OpName %counter_var_A "counter.var.A" OpName %main "main" OpName %S_0 "S" OpMemberName %S_0 0 "t" OpName %T_0 "T" OpMemberName %T_0 0 "a" OpDecorate %A DescriptorSet 0 OpDecorate %A Binding 0 OpDecorate %counter_var_A DescriptorSet 0 OpDecorate %counter_var_A Binding 1 OpMemberDecorate %T 0 Offset 0 OpMemberDecorate %S 0 Offset 0 OpDecorate %_runtimearr_S ArrayStride 4 OpMemberDecorate %type_RWStructuredBuffer_S 0 Offset 0 OpDecorate %type_RWStructuredBuffer_S BufferBlock OpMemberDecorate %type_ACSBuffer_counter 0 Offset 0 OpDecorate %type_ACSBuffer_counter BufferBlock %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %T = OpTypeStruct %int %S = OpTypeStruct %T %_runtimearr_S = OpTypeRuntimeArray %S %type_RWStructuredBuffer_S = OpTypeStruct %_runtimearr_S %_ptr_Uniform_type_RWStructuredBuffer_S = OpTypePointer Uniform %type_RWStructuredBuffer_S %type_ACSBuffer_counter = OpTypeStruct %int %_ptr_Uniform_type_ACSBuffer_counter = OpTypePointer Uniform %type_ACSBuffer_counter %void = OpTypeVoid %18 = OpTypeFunction %void %T_0 = OpTypeStruct %int %S_0 = OpTypeStruct %T_0 %_ptr_Function_S_0 = OpTypePointer Function %S_0 %_ptr_Uniform_S = OpTypePointer Uniform %S %_ptr_Uniform_T = OpTypePointer Uniform %T %22 = OpTypeFunction %T_0 %_ptr_Function_S_0 %_ptr_Function_T_0 = OpTypePointer Function %T_0 %A = OpVariable %_ptr_Uniform_type_RWStructuredBuffer_S Uniform %counter_var_A = OpVariable %_ptr_Uniform_type_ACSBuffer_counter Uniform %main = OpFunction %void None %18 %24 = OpLabel %25 = OpVariable %_ptr_Function_T_0 Function %26 = OpVariable %_ptr_Function_S_0 Function %27 = OpAccessChain %_ptr_Uniform_S %A %int_0 %uint_0 %28 = OpAccessChain %_ptr_Function_T_0 %27 %int_0 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(FixTypeTest, FixLoad) { const std::string text = R"( ; CHECK: [[ac1:%\w+]] = OpAccessChain %_ptr_Uniform_S %A %int_0 %uint_0 ; CHECK: [[ac2:%\w+]] = OpAccessChain %_ptr_Uniform_T [[ac1]] %int_0 ; CHECK: [[ld:%\w+]] = OpLoad %T [[ac2]] OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource HLSL 600 OpName %type_RWStructuredBuffer_S "type.RWStructuredBuffer.S" OpName %S "S" OpMemberName %S 0 "t" OpName %T "T" OpMemberName %T 0 "a" OpName %A "A" OpName %type_ACSBuffer_counter "type.ACSBuffer.counter" OpMemberName %type_ACSBuffer_counter 0 "counter" OpName %counter_var_A "counter.var.A" OpName %main "main" OpName %S_0 "S" OpMemberName %S_0 0 "t" OpName %T_0 "T" OpMemberName %T_0 0 "a" OpDecorate %A DescriptorSet 0 OpDecorate %A Binding 0 OpDecorate %counter_var_A DescriptorSet 0 OpDecorate %counter_var_A Binding 1 OpMemberDecorate %T 0 Offset 0 OpMemberDecorate %S 0 Offset 0 OpDecorate %_runtimearr_S ArrayStride 4 OpMemberDecorate %type_RWStructuredBuffer_S 0 Offset 0 OpDecorate %type_RWStructuredBuffer_S BufferBlock OpMemberDecorate %type_ACSBuffer_counter 0 Offset 0 OpDecorate %type_ACSBuffer_counter BufferBlock %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %T = OpTypeStruct %int %S = OpTypeStruct %T %_runtimearr_S = OpTypeRuntimeArray %S %type_RWStructuredBuffer_S = OpTypeStruct %_runtimearr_S %_ptr_Uniform_type_RWStructuredBuffer_S = OpTypePointer Uniform %type_RWStructuredBuffer_S %type_ACSBuffer_counter = OpTypeStruct %int %_ptr_Uniform_type_ACSBuffer_counter = OpTypePointer Uniform %type_ACSBuffer_counter %void = OpTypeVoid %18 = OpTypeFunction %void %T_0 = OpTypeStruct %int %S_0 = OpTypeStruct %T_0 %_ptr_Function_S_0 = OpTypePointer Function %S_0 %_ptr_Uniform_S = OpTypePointer Uniform %S %_ptr_Uniform_T = OpTypePointer Uniform %T %22 = OpTypeFunction %T_0 %_ptr_Function_S_0 %_ptr_Function_T_0 = OpTypePointer Function %T_0 %A = OpVariable %_ptr_Uniform_type_RWStructuredBuffer_S Uniform %counter_var_A = OpVariable %_ptr_Uniform_type_ACSBuffer_counter Uniform %main = OpFunction %void None %18 %24 = OpLabel %25 = OpVariable %_ptr_Function_T_0 Function %26 = OpVariable %_ptr_Function_S_0 Function %27 = OpAccessChain %_ptr_Uniform_S %A %int_0 %uint_0 %28 = OpAccessChain %_ptr_Uniform_T %27 %int_0 %29 = OpLoad %T_0 %28 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(FixTypeTest, FixStore) { const std::string text = R"( ; CHECK: [[ld:%\w+]] = OpLoad %T ; CHECK: OpStore OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource HLSL 600 OpName %type_RWStructuredBuffer_S "type.RWStructuredBuffer.S" OpName %S "S" OpMemberName %S 0 "t" OpName %T "T" OpMemberName %T 0 "a" OpName %A "A" OpName %type_ACSBuffer_counter "type.ACSBuffer.counter" OpMemberName %type_ACSBuffer_counter 0 "counter" OpName %counter_var_A "counter.var.A" OpName %main "main" OpName %S_0 "S" OpMemberName %S_0 0 "t" OpName %T_0 "T" OpMemberName %T_0 0 "a" OpDecorate %A DescriptorSet 0 OpDecorate %A Binding 0 OpDecorate %counter_var_A DescriptorSet 0 OpDecorate %counter_var_A Binding 1 OpMemberDecorate %T 0 Offset 0 OpMemberDecorate %S 0 Offset 0 OpDecorate %_runtimearr_S ArrayStride 4 OpMemberDecorate %type_RWStructuredBuffer_S 0 Offset 0 OpDecorate %type_RWStructuredBuffer_S BufferBlock OpMemberDecorate %type_ACSBuffer_counter 0 Offset 0 OpDecorate %type_ACSBuffer_counter BufferBlock %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %T = OpTypeStruct %int %S = OpTypeStruct %T %_runtimearr_S = OpTypeRuntimeArray %S %type_RWStructuredBuffer_S = OpTypeStruct %_runtimearr_S %_ptr_Uniform_type_RWStructuredBuffer_S = OpTypePointer Uniform %type_RWStructuredBuffer_S %type_ACSBuffer_counter = OpTypeStruct %int %_ptr_Uniform_type_ACSBuffer_counter = OpTypePointer Uniform %type_ACSBuffer_counter %void = OpTypeVoid %18 = OpTypeFunction %void %T_0 = OpTypeStruct %int %S_0 = OpTypeStruct %T_0 %_ptr_Function_S_0 = OpTypePointer Function %S_0 %_ptr_Uniform_S = OpTypePointer Uniform %S %_ptr_Uniform_T = OpTypePointer Uniform %T %22 = OpTypeFunction %T_0 %_ptr_Function_S_0 %_ptr_Function_T_0 = OpTypePointer Function %T_0 %A = OpVariable %_ptr_Uniform_type_RWStructuredBuffer_S Uniform %counter_var_A = OpVariable %_ptr_Uniform_type_ACSBuffer_counter Uniform %main = OpFunction %void None %18 %24 = OpLabel %25 = OpVariable %_ptr_Function_T_0 Function %26 = OpVariable %_ptr_Function_S_0 Function %27 = OpAccessChain %_ptr_Uniform_S %A %int_0 %uint_0 %28 = OpAccessChain %_ptr_Uniform_T %27 %int_0 %29 = OpLoad %T %28 OpStore %25 %29 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(FixTypeTest, FixSelect) { const std::string text = R"( ; CHECK: OpSelect %_ptr_Uniform__struct_3 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 OpSource HLSL 600 OpDecorate %2 DescriptorSet 0 OpDecorate %2 Binding 0 OpMemberDecorate %_struct_3 0 Offset 0 OpDecorate %_runtimearr__struct_3 ArrayStride 4 OpMemberDecorate %_struct_5 0 Offset 0 OpDecorate %_struct_5 BufferBlock %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %_struct_3 = OpTypeStruct %uint %_runtimearr__struct_3 = OpTypeRuntimeArray %_struct_3 %_struct_5 = OpTypeStruct %_runtimearr__struct_3 %_ptr_Uniform__struct_5 = OpTypePointer Uniform %_struct_5 %void = OpTypeVoid %11 = OpTypeFunction %void %_struct_12 = OpTypeStruct %uint %_ptr_Function__struct_12 = OpTypePointer Function %_struct_12 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %bool = OpTypeBool %_ptr_Uniform__struct_3 = OpTypePointer Uniform %_struct_3 %2 = OpVariable %_ptr_Uniform__struct_5 Uniform %1 = OpFunction %void None %11 %17 = OpLabel %18 = OpAccessChain %_ptr_Uniform_uint %2 %uint_0 %uint_0 %uint_0 %19 = OpLoad %uint %18 %20 = OpSGreaterThan %bool %19 %uint_0 %21 = OpAccessChain %_ptr_Uniform__struct_3 %2 %uint_0 %uint_0 %22 = OpAccessChain %_ptr_Uniform__struct_3 %2 %uint_0 %uint_1 %23 = OpSelect %_ptr_Function__struct_12 %20 %21 %22 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(FixTypeTest, FixPhiInLoop) { const std::string text = R"( ; CHECK: [[ac_init:%\w+]] = OpAccessChain %_ptr_Uniform__struct_3 ; CHECK: [[ac_phi:%\w+]] = OpPhi %_ptr_Uniform__struct_3 [[ac_init]] {{%\w+}} [[ac_update:%\w+]] {{%\w+}} ; CHECK: [[ac_update]] = OpPtrAccessChain %_ptr_Uniform__struct_3 [[ac_phi]] %int_1 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 OpSource HLSL 600 OpDecorate %2 DescriptorSet 0 OpDecorate %2 Binding 0 OpMemberDecorate %_struct_3 0 Offset 0 OpDecorate %_runtimearr__struct_3 ArrayStride 4 OpMemberDecorate %_struct_5 0 Offset 0 OpDecorate %_struct_5 BufferBlock %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %_struct_3 = OpTypeStruct %int %_struct_9 = OpTypeStruct %int %_runtimearr__struct_3 = OpTypeRuntimeArray %_struct_3 %_struct_5 = OpTypeStruct %_runtimearr__struct_3 %_ptr_Uniform__struct_5 = OpTypePointer Uniform %_struct_5 %void = OpTypeVoid %12 = OpTypeFunction %void %bool = OpTypeBool %_ptr_Uniform__struct_3 = OpTypePointer Uniform %_struct_3 %_ptr_Function__struct_9 = OpTypePointer Function %_struct_9 %2 = OpVariable %_ptr_Uniform__struct_5 Uniform %1 = OpFunction %void None %12 %16 = OpLabel %17 = OpAccessChain %_ptr_Uniform__struct_3 %2 %int_0 %int_0 OpBranch %18 %18 = OpLabel %20 = OpPhi %_ptr_Function__struct_9 %17 %16 %21 %22 %23 = OpUndef %bool OpLoopMerge %24 %22 None OpBranchConditional %23 %22 %24 %22 = OpLabel %21 = OpPtrAccessChain %_ptr_Function__struct_9 %20 %int_1 OpBranch %18 %24 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(FixStorageClassTest, SupportsU64Index) { const std::string text = R"( ; CHECK: OpAccessChain %_ptr_Uniform_float OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "testMain" %gl_LocalInvocationID OpExecutionMode %1 LocalSize 8 8 1 OpDecorate %gl_LocalInvocationID BuiltIn LocalInvocationId OpDecorate %8 DescriptorSet 0 OpDecorate %8 Binding 0 OpDecorate %_runtimearr_float ArrayStride 4 OpMemberDecorate %_struct_7 0 Offset 0 OpDecorate %_struct_7 BufferBlock %ulong = OpTypeInt 64 0 %ulong_0 = OpConstant %ulong 0 %float = OpTypeFloat 32 %float_123 = OpConstant %float 123 %uint = OpTypeInt 32 0 %uint_10 = OpConstant %uint 10 %_runtimearr_float = OpTypeRuntimeArray %float %_struct_7 = OpTypeStruct %_runtimearr_float %_ptr_Uniform__struct_7 = OpTypePointer Uniform %_struct_7 %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %void = OpTypeVoid %30 = OpTypeFunction %void %_ptr_Uniform_float = OpTypePointer Uniform %float %8 = OpVariable %_ptr_Uniform__struct_7 Uniform %gl_LocalInvocationID = OpVariable %_ptr_Input_v3uint Input %1 = OpFunction %void None %30 %38 = OpLabel %44 = OpLoad %v3uint %gl_LocalInvocationID %59 = OpCompositeExtract %uint %44 0 %60 = OpAccessChain %_ptr_Uniform_float %8 %ulong_0 %59 OpStore %60 %float_123 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(FixStorageClassTest, CorrectlyProcessAccessChainOnCoopMatrix) { const std::string text = R"(OpCapability CooperativeMatrixKHR OpCapability Shader OpExtension "SPV_KHR_cooperative_matrix" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 64 1 1 OpSource HLSL 600 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_3 = OpConstant %uint 3 %uint_16 = OpConstant %uint 16 %uint_4 = OpConstant %uint 4 %9 = OpTypeCooperativeMatrixKHR %int %uint_3 %uint_16 %uint_4 %uint_0 %void = OpTypeVoid %11 = OpTypeFunction %void %_struct_12 = OpTypeStruct %9 %_ptr_Function__struct_12 = OpTypePointer Function %_struct_12 %_ptr_Function_9 = OpTypePointer Function %9 %_ptr_Function_int = OpTypePointer Function %int %_ptr_Function__ptr_Function_int = OpTypePointer Function %_ptr_Function_int %1 = OpFunction %void None %11 %17 = OpLabel %18 = OpVariable %_ptr_Function__ptr_Function_int Function %19 = OpVariable %_ptr_Function__struct_12 Function %20 = OpAccessChain %_ptr_Function_9 %19 %int_0 %21 = OpAccessChain %_ptr_Function_int %20 %uint_4 OpStore %18 %21 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(text, text, false, false); } // Tests that the pass is not confused when there are multiple definitions // of a pointer type to the same type with the same storage class. TEST_F(FixStorageClassTest, DuplicatePointerType) { const std::string text = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 64 1 1 OpSource HLSL 600 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_3 = OpConstant %uint 3 %_arr_uint_uint_3 = OpTypeArray %uint %uint_3 %void = OpTypeVoid %7 = OpTypeFunction %void %_struct_8 = OpTypeStruct %_arr_uint_uint_3 %_ptr_Function__struct_8 = OpTypePointer Function %_struct_8 %_ptr_Function_uint = OpTypePointer Function %uint %_ptr_Function__arr_uint_uint_3 = OpTypePointer Function %_arr_uint_uint_3 %_ptr_Function_uint_0 = OpTypePointer Function %uint %_ptr_Function__ptr_Function_uint_0 = OpTypePointer Function %_ptr_Function_uint_0 %1 = OpFunction %void None %7 %14 = OpLabel %15 = OpVariable %_ptr_Function__ptr_Function_uint_0 Function %16 = OpVariable %_ptr_Function__struct_8 Function %17 = OpAccessChain %_ptr_Function__arr_uint_uint_3 %16 %uint_0 %18 = OpAccessChain %_ptr_Function_uint_0 %17 %uint_0 OpStore %15 %18 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(text, text, false); } // This example is generated by DXC when certain inline spiir-v is used. // The intention is that the function scope variable will eventually be // optimized away, removing the type mismatch. We want to make sure the // OpCopyObject is rewritten, and that the pass does not fail. TEST_F(FixStorageClassTest, DoNotFailWithMismatchedPointerTypes) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %38 OpExecutionMode %1 LocalSize 64 1 1 OpSource HLSL 600 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %uint = OpTypeInt 32 0 %uint_64 = OpConstant %uint 64 %_arr_float_uint_64 = OpTypeArray %float %uint_64 %_ptr_Workgroup__arr_float_uint_64 = OpTypePointer Workgroup %_arr_float_uint_64 %void = OpTypeVoid %80 = OpTypeFunction %void %_ptr_Workgroup_float = OpTypePointer Workgroup %float %_ptr_Function__ptr_Workgroup_float = OpTypePointer Function %_ptr_Workgroup_float %_ptr_Workgroup_float_0 = OpTypePointer Workgroup %float %38 = OpVariable %_ptr_Workgroup__arr_float_uint_64 Workgroup %1 = OpFunction %void None %80 %98 = OpLabel ; CHECK: [[var:%\d+]] = OpVariable %_ptr_Function__ptr_Workgroup_float Function %113 = OpVariable %_ptr_Function__ptr_Workgroup_float Function ; CHECK: [[ac:%\d+]] = OpAccessChain %_ptr_Workgroup_float_0 {{%\d+}} %int_0 %136 = OpAccessChain %_ptr_Workgroup_float_0 %38 %int_0 ; Verify that the type for the OpCopyObject has changed to match [[ac]]. ; CHECK: [[copy:%\d+]] = OpCopyObject %_ptr_Workgroup_float_0 [[ac]] %137 = OpCopyObject %_ptr_Workgroup_float %136 ; This has a type mismatch, but this is because we do not have a way to copy ; a pointer from one type to another, so FixStorageClass cannot do anything ; about it. We want fix storage class to leave it as is, and the validator ; will report an error if the store is not remove by a later optimization. ; CHECK: OpStore [[var]] [[copy]] OpStore %113 %137 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/flatten_decoration_test.cpp000066400000000000000000000270001475742701700257200ustar00rootroot00000000000000// Copyright (c) 2017 Valve Corporation // Copyright (c) 2017 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { // Returns the initial part of the assembly text for a valid // SPIR-V module, including instructions prior to decorations. std::string PreambleAssembly() { return R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %hue %saturation %value OpExecutionMode %main OriginUpperLeft OpName %main "main" OpName %void_fn "void_fn" OpName %hue "hue" OpName %saturation "saturation" OpName %value "value" OpName %entry "entry" OpName %Point "Point" OpName %Camera "Camera" )"; } // Returns types std::string TypesAndFunctionsAssembly() { return R"(%void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %Point = OpTypeStruct %float %float %float %Camera = OpTypeStruct %float %float %_ptr_Input_float = OpTypePointer Input %float %hue = OpVariable %_ptr_Input_float Input %saturation = OpVariable %_ptr_Input_float Input %value = OpVariable %_ptr_Input_float Input %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; } struct FlattenDecorationCase { // Names and decorations before the pass. std::string input; // Names and decorations after the pass. std::string expected; }; using FlattenDecorationTest = PassTest<::testing::TestWithParam>; TEST_P(FlattenDecorationTest, TransformsDecorations) { const auto before = PreambleAssembly() + GetParam().input + TypesAndFunctionsAssembly(); const auto after = PreambleAssembly() + GetParam().expected + TypesAndFunctionsAssembly(); SinglePassRunAndCheck(before, after, false, true); } INSTANTIATE_TEST_SUITE_P(NoUses, FlattenDecorationTest, ::testing::ValuesIn(std::vector{ // No OpDecorationGroup {"", ""}, // OpDecorationGroup without any uses, and // no OpName. {"%group = OpDecorationGroup\n", ""}, // OpDecorationGroup without any uses, and // with OpName targeting it. Proves you must // remove the names as well. {"OpName %group \"group\"\n" "%group = OpDecorationGroup\n", ""}, // OpDecorationGroup with decorations that // target it, but no uses in OpGroupDecorate // or OpGroupMemberDecorate instructions. {"OpDecorate %group Flat\n" "OpDecorate %group NoPerspective\n" "%group = OpDecorationGroup\n", ""}, })); INSTANTIATE_TEST_SUITE_P(OpGroupDecorate, FlattenDecorationTest, ::testing::ValuesIn(std::vector{ // One OpGroupDecorate {"OpName %group \"group\"\n" "OpDecorate %group Flat\n" "OpDecorate %group NoPerspective\n" "%group = OpDecorationGroup\n" "OpGroupDecorate %group %hue %saturation\n", "OpDecorate %hue Flat\n" "OpDecorate %saturation Flat\n" "OpDecorate %hue NoPerspective\n" "OpDecorate %saturation NoPerspective\n"}, // Multiple OpGroupDecorate {"OpName %group \"group\"\n" "OpDecorate %group Flat\n" "OpDecorate %group NoPerspective\n" "%group = OpDecorationGroup\n" "OpGroupDecorate %group %hue %value\n" "OpGroupDecorate %group %saturation\n", "OpDecorate %hue Flat\n" "OpDecorate %value Flat\n" "OpDecorate %saturation Flat\n" "OpDecorate %hue NoPerspective\n" "OpDecorate %value NoPerspective\n" "OpDecorate %saturation NoPerspective\n"}, // Two group decorations, interleaved {"OpName %group0 \"group0\"\n" "OpName %group1 \"group1\"\n" "OpDecorate %group0 Flat\n" "OpDecorate %group1 NoPerspective\n" "%group0 = OpDecorationGroup\n" "%group1 = OpDecorationGroup\n" "OpGroupDecorate %group0 %hue %value\n" "OpGroupDecorate %group1 %saturation\n", "OpDecorate %hue Flat\n" "OpDecorate %value Flat\n" "OpDecorate %saturation NoPerspective\n"}, // Decoration with operands {"OpName %group \"group\"\n" "OpDecorate %group Location 42\n" "%group = OpDecorationGroup\n" "OpGroupDecorate %group %hue %saturation\n", "OpDecorate %hue Location 42\n" "OpDecorate %saturation Location 42\n"}, })); INSTANTIATE_TEST_SUITE_P(OpGroupMemberDecorate, FlattenDecorationTest, ::testing::ValuesIn(std::vector{ // One OpGroupMemberDecorate {"OpName %group \"group\"\n" "OpDecorate %group Flat\n" "OpDecorate %group Offset 16\n" "%group = OpDecorationGroup\n" "OpGroupMemberDecorate %group %Point 1\n", "OpMemberDecorate %Point 1 Flat\n" "OpMemberDecorate %Point 1 Offset 16\n"}, // Multiple OpGroupMemberDecorate using the same // decoration group. {"OpName %group \"group\"\n" "OpDecorate %group Flat\n" "OpDecorate %group NoPerspective\n" "OpDecorate %group Offset 8\n" "%group = OpDecorationGroup\n" "OpGroupMemberDecorate %group %Point 2\n" "OpGroupMemberDecorate %group %Camera 1\n", "OpMemberDecorate %Point 2 Flat\n" "OpMemberDecorate %Camera 1 Flat\n" "OpMemberDecorate %Point 2 NoPerspective\n" "OpMemberDecorate %Camera 1 NoPerspective\n" "OpMemberDecorate %Point 2 Offset 8\n" "OpMemberDecorate %Camera 1 Offset 8\n"}, // Two groups of member decorations, interleaved. // Decoration is with and without operands. {"OpName %group0 \"group0\"\n" "OpName %group1 \"group1\"\n" "OpDecorate %group0 Flat\n" "OpDecorate %group0 Offset 8\n" "OpDecorate %group1 NoPerspective\n" "OpDecorate %group1 Offset 16\n" "%group0 = OpDecorationGroup\n" "%group1 = OpDecorationGroup\n" "OpGroupMemberDecorate %group0 %Point 0\n" "OpGroupMemberDecorate %group1 %Point 2\n", "OpMemberDecorate %Point 0 Flat\n" "OpMemberDecorate %Point 0 Offset 8\n" "OpMemberDecorate %Point 2 NoPerspective\n" "OpMemberDecorate %Point 2 Offset 16\n"}, })); INSTANTIATE_TEST_SUITE_P(UnrelatedDecorations, FlattenDecorationTest, ::testing::ValuesIn(std::vector{ // A non-group non-member decoration is untouched. {"OpDecorate %hue Centroid\n" "OpDecorate %saturation Flat\n", "OpDecorate %hue Centroid\n" "OpDecorate %saturation Flat\n"}, // A non-group member decoration is untouched. {"OpMemberDecorate %Point 0 Offset 0\n" "OpMemberDecorate %Point 1 Offset 4\n" "OpMemberDecorate %Point 1 Flat\n", "OpMemberDecorate %Point 0 Offset 0\n" "OpMemberDecorate %Point 1 Offset 4\n" "OpMemberDecorate %Point 1 Flat\n"}, // A non-group non-member decoration survives any // replacement of group decorations. {"OpName %group \"group\"\n" "OpDecorate %group Flat\n" "OpDecorate %hue Centroid\n" "OpDecorate %group NoPerspective\n" "%group = OpDecorationGroup\n" "OpGroupDecorate %group %hue %saturation\n", "OpDecorate %hue Flat\n" "OpDecorate %saturation Flat\n" "OpDecorate %hue Centroid\n" "OpDecorate %hue NoPerspective\n" "OpDecorate %saturation NoPerspective\n"}, // A non-group member decoration survives any // replacement of group decorations. {"OpDecorate %group Offset 0\n" "OpDecorate %group Flat\n" "OpMemberDecorate %Point 1 Offset 4\n" "%group = OpDecorationGroup\n" "OpGroupMemberDecorate %group %Point 0\n", "OpMemberDecorate %Point 0 Offset 0\n" "OpMemberDecorate %Point 0 Flat\n" "OpMemberDecorate %Point 1 Offset 4\n"}, })); } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/fold_spec_const_op_composite_test.cpp000066400000000000000000002616551475742701700300200ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include "test/opt/assembly_builder.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using FoldSpecConstantOpAndCompositePassBasicTest = PassTest<::testing::Test>; TEST_F(FoldSpecConstantOpAndCompositePassBasicTest, Empty) { SinglePassRunAndCheck( "", "", /* skip_nop = */ true); } // A test of the basic functionality of FoldSpecConstantOpAndCompositePass. // A spec constant defined with an integer addition operation should be folded // to a normal constant with fixed value. TEST_F(FoldSpecConstantOpAndCompositePassBasicTest, Basic) { AssemblyBuilder builder; builder.AppendTypesConstantsGlobals({ // clang-format off "%int = OpTypeInt 32 1", "%frozen_spec_const_int = OpConstant %int 1", "%const_int = OpConstant %int 2", // Folding target: "%spec_add = OpSpecConstantOp %int IAdd %frozen_spec_const_int %const_int", // clang-format on }); std::vector expected = { // clang-format off "OpCapability Shader", "OpCapability Float64", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Vertex %main \"main\"", "OpName %void \"void\"", "OpName %main_func_type \"main_func_type\"", "OpName %main \"main\"", "OpName %main_func_entry_block \"main_func_entry_block\"", "OpName %int \"int\"", "OpName %frozen_spec_const_int \"frozen_spec_const_int\"", "OpName %const_int \"const_int\"", "OpName %spec_add \"spec_add\"", "%void = OpTypeVoid", "%main_func_type = OpTypeFunction %void", "%int = OpTypeInt 32 1", "%frozen_spec_const_int = OpConstant %int 1", "%const_int = OpConstant %int 2", // The SpecConstantOp IAdd instruction should be replace by OpConstant // instruction: "%spec_add = OpConstant %int 3", "%main = OpFunction %void None %main_func_type", "%main_func_entry_block = OpLabel", "OpReturn", "OpFunctionEnd", // clang-format on }; SinglePassRunAndCheck( builder.GetCode(), JoinAllInsts(expected), /* skip_nop = */ true); } // A test of skipping folding an instruction when the instruction result type // has decorations. TEST_F(FoldSpecConstantOpAndCompositePassBasicTest, SkipWhenTypeHasDecorations) { AssemblyBuilder builder; builder .AppendAnnotations({ // clang-format off "OpDecorate %int RelaxedPrecision", // clang-format on }) .AppendTypesConstantsGlobals({ // clang-format off "%int = OpTypeInt 32 1", "%frozen_spec_const_int = OpConstant %int 1", "%const_int = OpConstant %int 2", // The following spec constant should not be folded as the result type // has relaxed precision decoration. "%spec_add = OpSpecConstantOp %int IAdd %frozen_spec_const_int %const_int", // clang-format on }); SinglePassRunAndCheck( builder.GetCode(), builder.GetCode(), /* skip_nop = */ true); } // Test where OpSpecConstantOp depends on another OpSpecConstantOp with // CompositeExtract TEST_F(FoldSpecConstantOpAndCompositePassBasicTest, StackedCompositeExtract) { AssemblyBuilder builder; builder.AppendTypesConstantsGlobals({ // clang-format off "%uint = OpTypeInt 32 0", "%v3uint = OpTypeVector %uint 3", "%uint_2 = OpConstant %uint 2", "%uint_3 = OpConstant %uint 3", // Folding target: "%composite_0 = OpSpecConstantComposite %v3uint %uint_2 %uint_3 %uint_2", "%op_0 = OpSpecConstantOp %uint CompositeExtract %composite_0 0", "%op_1 = OpSpecConstantOp %uint CompositeExtract %composite_0 1", "%op_2 = OpSpecConstantOp %uint IMul %op_0 %op_1", "%composite_1 = OpSpecConstantComposite %v3uint %op_0 %op_1 %op_2", "%op_3 = OpSpecConstantOp %uint CompositeExtract %composite_1 0", "%op_4 = OpSpecConstantOp %uint IMul %op_2 %op_3", // clang-format on }); std::vector expected = { // clang-format off "OpCapability Shader", "OpCapability Float64", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Vertex %main \"main\"", "OpName %void \"void\"", "OpName %main_func_type \"main_func_type\"", "OpName %main \"main\"", "OpName %main_func_entry_block \"main_func_entry_block\"", "OpName %uint \"uint\"", "OpName %v3uint \"v3uint\"", "OpName %uint_2 \"uint_2\"", "OpName %uint_3 \"uint_3\"", "OpName %composite_0 \"composite_0\"", "OpName %op_0 \"op_0\"", "OpName %op_1 \"op_1\"", "OpName %op_2 \"op_2\"", "OpName %composite_1 \"composite_1\"", "OpName %op_3 \"op_3\"", "OpName %op_4 \"op_4\"", "%void = OpTypeVoid", "%main_func_type = OpTypeFunction %void", "%uint = OpTypeInt 32 0", "%v3uint = OpTypeVector %uint 3", "%uint_2 = OpConstant %uint 2", "%uint_3 = OpConstant %uint 3", "%composite_0 = OpConstantComposite %v3uint %uint_2 %uint_3 %uint_2", "%op_0 = OpConstant %uint 2", "%op_1 = OpConstant %uint 3", "%op_2 = OpConstant %uint 6", "%composite_1 = OpConstantComposite %v3uint %op_0 %op_1 %op_2", "%op_3 = OpConstant %uint 2", "%op_4 = OpConstant %uint 12", "%main = OpFunction %void None %main_func_type", "%main_func_entry_block = OpLabel", "OpReturn", "OpFunctionEnd", // clang-format on }; SinglePassRunAndCheck( builder.GetCode(), JoinAllInsts(expected), /* skip_nop = */ true); } // Test where OpSpecConstantOp depends on another OpSpecConstantOp with // VectorShuffle TEST_F(FoldSpecConstantOpAndCompositePassBasicTest, StackedVectorShuffle) { AssemblyBuilder builder; builder.AppendTypesConstantsGlobals({ // clang-format off "%uint = OpTypeInt 32 0", "%v3uint = OpTypeVector %uint 3", "%uint_1 = OpConstant %uint 1", "%uint_2 = OpConstant %uint 2", "%uint_3 = OpConstant %uint 3", "%uint_4 = OpConstant %uint 4", "%uint_5 = OpConstant %uint 5", "%uint_6 = OpConstant %uint 6", // Folding target: "%composite_0 = OpSpecConstantComposite %v3uint %uint_1 %uint_2 %uint_3", "%composite_1 = OpSpecConstantComposite %v3uint %uint_4 %uint_5 %uint_6", "%vecshuffle = OpSpecConstantOp %v3uint VectorShuffle %composite_0 %composite_1 0 5 3", "%op = OpSpecConstantOp %uint CompositeExtract %vecshuffle 1", // clang-format on }); std::vector expected = { // clang-format off "OpCapability Shader", "OpCapability Float64", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Vertex %main \"main\"", "OpName %void \"void\"", "OpName %main_func_type \"main_func_type\"", "OpName %main \"main\"", "OpName %main_func_entry_block \"main_func_entry_block\"", "OpName %uint \"uint\"", "OpName %v3uint \"v3uint\"", "OpName %uint_1 \"uint_1\"", "OpName %uint_2 \"uint_2\"", "OpName %uint_3 \"uint_3\"", "OpName %uint_4 \"uint_4\"", "OpName %uint_5 \"uint_5\"", "OpName %uint_6 \"uint_6\"", "OpName %composite_0 \"composite_0\"", "OpName %composite_1 \"composite_1\"", "OpName %vecshuffle \"vecshuffle\"", "OpName %op \"op\"", "%void = OpTypeVoid", "%main_func_type = OpTypeFunction %void", "%uint = OpTypeInt 32 0", "%v3uint = OpTypeVector %uint 3", "%uint_1 = OpConstant %uint 1", "%uint_2 = OpConstant %uint 2", "%uint_3 = OpConstant %uint 3", "%uint_4 = OpConstant %uint 4", "%uint_5 = OpConstant %uint 5", "%uint_6 = OpConstant %uint 6", "%composite_0 = OpConstantComposite %v3uint %uint_1 %uint_2 %uint_3", "%composite_1 = OpConstantComposite %v3uint %uint_4 %uint_5 %uint_6", "%vecshuffle = OpConstantComposite %v3uint %uint_1 %uint_6 %uint_4", "%op = OpConstant %uint 6", "%main = OpFunction %void None %main_func_type", "%main_func_entry_block = OpLabel", "OpReturn", "OpFunctionEnd", // clang-format on }; SinglePassRunAndCheck( builder.GetCode(), JoinAllInsts(expected), /* skip_nop = */ true); } // Test CompositeExtract with matrix TEST_F(FoldSpecConstantOpAndCompositePassBasicTest, CompositeExtractMaxtrix) { AssemblyBuilder builder; builder.AppendTypesConstantsGlobals({ // clang-format off "%uint = OpTypeInt 32 0", "%v3uint = OpTypeVector %uint 3", "%mat3x3 = OpTypeMatrix %v3uint 3", "%uint_1 = OpConstant %uint 1", "%uint_2 = OpConstant %uint 2", "%uint_3 = OpConstant %uint 3", // Folding target: "%a = OpSpecConstantComposite %v3uint %uint_1 %uint_1 %uint_1", "%b = OpSpecConstantComposite %v3uint %uint_1 %uint_1 %uint_3", "%c = OpSpecConstantComposite %v3uint %uint_1 %uint_2 %uint_1", "%op = OpSpecConstantComposite %mat3x3 %a %b %c", "%x = OpSpecConstantOp %uint CompositeExtract %op 2 1", "%y = OpSpecConstantOp %uint CompositeExtract %op 1 2", // clang-format on }); std::vector expected = { // clang-format off "OpCapability Shader", "OpCapability Float64", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Vertex %main \"main\"", "OpName %void \"void\"", "OpName %main_func_type \"main_func_type\"", "OpName %main \"main\"", "OpName %main_func_entry_block \"main_func_entry_block\"", "OpName %uint \"uint\"", "OpName %v3uint \"v3uint\"", "OpName %mat3x3 \"mat3x3\"", "OpName %uint_1 \"uint_1\"", "OpName %uint_2 \"uint_2\"", "OpName %uint_3 \"uint_3\"", "OpName %a \"a\"", "OpName %b \"b\"", "OpName %c \"c\"", "OpName %op \"op\"", "OpName %x \"x\"", "OpName %y \"y\"", "%void = OpTypeVoid", "%main_func_type = OpTypeFunction %void", "%uint = OpTypeInt 32 0", "%v3uint = OpTypeVector %uint 3", "%mat3x3 = OpTypeMatrix %v3uint 3", "%uint_1 = OpConstant %uint 1", "%uint_2 = OpConstant %uint 2", "%uint_3 = OpConstant %uint 3", "%a = OpConstantComposite %v3uint %uint_1 %uint_1 %uint_1", "%b = OpConstantComposite %v3uint %uint_1 %uint_1 %uint_3", "%c = OpConstantComposite %v3uint %uint_1 %uint_2 %uint_1", "%op = OpConstantComposite %mat3x3 %a %b %c", "%x = OpConstant %uint 2", "%y = OpConstant %uint 3", "%main = OpFunction %void None %main_func_type", "%main_func_entry_block = OpLabel", "OpReturn", "OpFunctionEnd", // clang-format on }; SinglePassRunAndCheck( builder.GetCode(), JoinAllInsts(expected), /* skip_nop = */ true); } TEST_F(FoldSpecConstantOpAndCompositePassBasicTest, CompositeInsertVector) { const std::string test = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v3uint = OpTypeVector %uint 3 %uint_2 = OpConstant %uint 2 %uint_3 = OpConstant %uint 3 %8 = OpConstantNull %uint %9 = OpSpecConstantComposite %v3uint %uint_2 %uint_2 %uint_2 ; CHECK: %15 = OpConstantComposite %v3uint %uint_3 %uint_2 %uint_2 ; CHECK: %uint_3_0 = OpConstant %uint 3 ; CHECK: %17 = OpConstantComposite %v3uint %8 %uint_2 %uint_2 ; CHECK: %18 = OpConstantNull %uint %10 = OpSpecConstantOp %v3uint CompositeInsert %uint_3 %9 0 %11 = OpSpecConstantOp %uint CompositeExtract %10 0 %12 = OpSpecConstantOp %v3uint CompositeInsert %8 %9 0 %13 = OpSpecConstantOp %uint CompositeExtract %12 0 %1 = OpFunction %void None %3 %14 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(test, false); } TEST_F(FoldSpecConstantOpAndCompositePassBasicTest, CompositeInsertVectorIntoMatrix) { const std::string test = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %mat2v2float = OpTypeMatrix %v2float 2 %float_0 = OpConstant %float 0 %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %v2float_01 = OpConstantComposite %v2float %float_0 %float_1 %v2float_12 = OpConstantComposite %v2float %float_1 %float_2 ; CHECK: %10 = OpConstantComposite %v2float %float_0 %float_1 ; CHECK: %11 = OpConstantComposite %v2float %float_1 %float_2 ; CHECK: %12 = OpConstantComposite %mat2v2float %11 %11 %mat2v2float_1212 = OpConstantComposite %mat2v2float %v2float_12 %v2float_12 ; CHECK: %15 = OpConstantComposite %mat2v2float %10 %11 %spec_0 = OpSpecConstantOp %mat2v2float CompositeInsert %v2float_01 %mat2v2float_1212 0 %1 = OpFunction %void None %3 %label = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(test, false); } TEST_F(FoldSpecConstantOpAndCompositePassBasicTest, CompositeInsertMatrix) { const std::string test = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %mat3v3float = OpTypeMatrix %v3float 3 %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %9 = OpSpecConstantComposite %v3float %float_1 %float_1 %float_1 %10 = OpSpecConstantComposite %v3float %float_1 %float_1 %float_1 %11 = OpSpecConstantComposite %v3float %float_1 %float_2 %float_1 %12 = OpSpecConstantComposite %mat3v3float %9 %10 %11 ; CHECK: %float_2_0 = OpConstant %float 2 ; CHECK: %18 = OpConstantComposite %v3float %float_1 %float_1 %float_2 ; CHECK: %19 = OpConstantComposite %mat3v3float %9 %18 %11 ; CHECK: %float_2_1 = OpConstant %float 2 %13 = OpSpecConstantOp %float CompositeExtract %12 2 1 %14 = OpSpecConstantOp %mat3v3float CompositeInsert %13 %12 1 2 %15 = OpSpecConstantOp %float CompositeExtract %14 1 2 %1 = OpFunction %void None %3 %16 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(test, false); } TEST_F(FoldSpecConstantOpAndCompositePassBasicTest, CompositeInsertFloatNull) { const std::string test = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %float_1 = OpConstant %float 1 ; CHECK: %7 = OpConstantNull %float ; CHECK: %8 = OpConstantComposite %v3float %7 %7 %7 ; CHECK: %12 = OpConstantComposite %v3float %7 %7 %float_1 %null = OpConstantNull %float %spec_0 = OpConstantComposite %v3float %null %null %null %spec_1 = OpSpecConstantOp %v3float CompositeInsert %float_1 %spec_0 2 ; CHECK: %float_1_0 = OpConstant %float 1 %spec_2 = OpSpecConstantOp %float CompositeExtract %spec_1 2 %1 = OpFunction %void None %3 %label = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(test, false); } TEST_F(FoldSpecConstantOpAndCompositePassBasicTest, CompositeInsertFloatSetNull) { const std::string test = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %float_1 = OpConstant %float 1 ; CHECK: %7 = OpConstantNull %float ; CHECK: %8 = OpConstantComposite %v3float %7 %7 %float_1 ; CHECK: %12 = OpConstantComposite %v3float %7 %7 %7 %null = OpConstantNull %float %spec_0 = OpConstantComposite %v3float %null %null %float_1 %spec_1 = OpSpecConstantOp %v3float CompositeInsert %null %spec_0 2 ; CHECK: %13 = OpConstantNull %float %spec_2 = OpSpecConstantOp %float CompositeExtract %spec_1 2 %1 = OpFunction %void None %3 %label = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(test, false); } TEST_F(FoldSpecConstantOpAndCompositePassBasicTest, CompositeInsertVectorNull) { const std::string test = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %float_1 = OpConstant %float 1 %null = OpConstantNull %v3float ; CHECK: %11 = OpConstantNull %float ; CHECK: %12 = OpConstantComposite %v3float %11 %11 %float_1 %spec_0 = OpSpecConstantOp %v3float CompositeInsert %float_1 %null 2 ; CHECK: %float_1_0 = OpConstant %float 1 %spec_1 = OpSpecConstantOp %float CompositeExtract %spec_0 2 %1 = OpFunction %void None %3 %label = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(test, false); } TEST_F(FoldSpecConstantOpAndCompositePassBasicTest, CompositeInsertNullVectorIntoMatrix) { const std::string test = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %mat2v2float = OpTypeMatrix %v2float 2 %null = OpConstantNull %mat2v2float %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %v2float_12 = OpConstantComposite %v2float %float_1 %float_2 ; CHECK: %13 = OpConstantNull %v2float ; CHECK: %14 = OpConstantComposite %mat2v2float %10 %13 %spec_0 = OpSpecConstantOp %mat2v2float CompositeInsert %v2float_12 %null 0 %1 = OpFunction %void None %3 %label = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(test, false); } TEST_F(FoldSpecConstantOpAndCompositePassBasicTest, CompositeInsertVectorKeepNull) { const std::string test = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %float_0 = OpConstant %float 0 %null_float = OpConstantNull %float %null_vec = OpConstantNull %v3float ; CHECK: %15 = OpConstantComposite %v3float %7 %7 %float_0 %spec_0 = OpSpecConstantOp %v3float CompositeInsert %float_0 %null_vec 2 ; CHECK: %float_0_0 = OpConstant %float 0 %spec_1 = OpSpecConstantOp %float CompositeExtract %spec_0 2 ; CHECK: %17 = OpConstantComposite %v3float %7 %7 %7 %spec_2 = OpSpecConstantOp %v3float CompositeInsert %null_float %null_vec 2 ; CHECK: %18 = OpConstantNull %float %spec_3 = OpSpecConstantOp %float CompositeExtract %spec_2 2 %1 = OpFunction %void None %3 %label = OpLabel %add = OpFAdd %float %spec_3 %spec_3 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(test, false); } TEST_F(FoldSpecConstantOpAndCompositePassBasicTest, CompositeInsertVectorChainNull) { const std::string test = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %float_1 = OpConstant %float 1 %null = OpConstantNull %v3float ; CHECK: %15 = OpConstantNull %float ; CHECK: %16 = OpConstantComposite %v3float %15 %15 %float_1 ; CHECK: %17 = OpConstantComposite %v3float %15 %float_1 %float_1 ; CHECK: %18 = OpConstantComposite %v3float %float_1 %float_1 %float_1 %spec_0 = OpSpecConstantOp %v3float CompositeInsert %float_1 %null 2 %spec_1 = OpSpecConstantOp %v3float CompositeInsert %float_1 %spec_0 1 %spec_2 = OpSpecConstantOp %v3float CompositeInsert %float_1 %spec_1 0 ; CHECK: %float_1_0 = OpConstant %float 1 ; CHECK: %float_1_1 = OpConstant %float 1 ; CHECK: %float_1_2 = OpConstant %float 1 %spec_3 = OpSpecConstantOp %float CompositeExtract %spec_2 0 %spec_4 = OpSpecConstantOp %float CompositeExtract %spec_2 1 %spec_5 = OpSpecConstantOp %float CompositeExtract %spec_2 2 %1 = OpFunction %void None %3 %label = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(test, false); } TEST_F(FoldSpecConstantOpAndCompositePassBasicTest, CompositeInsertVectorChainReset) { const std::string test = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %float_1 = OpConstant %float 1 %null = OpConstantNull %float ; CHECK: %8 = OpConstantComposite %v3float %7 %7 %float_1 %spec_0 = OpConstantComposite %v3float %null %null %float_1 ; set to null ; CHECK: %13 = OpConstantComposite %v3float %7 %7 %7 %spec_1 = OpSpecConstantOp %v3float CompositeInsert %null %spec_0 2 ; set to back to original value ; CHECK: %14 = OpConstantComposite %v3float %7 %7 %float_1 %spec_2 = OpSpecConstantOp %v3float CompositeInsert %float_1 %spec_1 2 ; CHECK: %float_1_0 = OpConstant %float 1 %spec_3 = OpSpecConstantOp %float CompositeExtract %spec_2 2 %1 = OpFunction %void None %3 %label = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(test, false); } TEST_F(FoldSpecConstantOpAndCompositePassBasicTest, CompositeInsertMatrixNull) { const std::string test = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %func = OpTypeFunction %void %float = OpTypeFloat 32 %int = OpTypeInt 32 0 %v2float = OpTypeVector %float 2 %mat2v2float = OpTypeMatrix %v2float 2 %null = OpConstantNull %mat2v2float %float_1 = OpConstant %float 1 ; CHECK: %13 = OpConstantNull %v2float ; CHECK: %14 = OpConstantNull %float ; CHECK: %15 = OpConstantComposite %v2float %float_1 %14 ; CHECK: %16 = OpConstantComposite %mat2v2float %13 %15 %spec = OpSpecConstantOp %mat2v2float CompositeInsert %float_1 %null 1 0 ; extra type def to make sure new type def are not just thrown at end %v2int = OpTypeVector %int 2 %main = OpFunction %void None %func %label = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(test, false); } // Silently ignore spec constants that cannot be folded TEST_F(FoldSpecConstantOpAndCompositePassBasicTest, UnfoldableOp) { const std::string test = R"( OpCapability Shader OpCapability SignedZeroInfNanPreserve OpExtension "SPV_KHR_float_controls" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpDecorate %v SpecId 1 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v = OpConstant %float 0x1p-1 %c = OpSpecConstantOp %float QuantizeToF16 %v ;CHECK: {{%\w+}} = OpSpecConstantOp {{%\w+}} QuantizeToF16 {{%\w+}} %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(test, false); } // All types and some common constants that are potentially required in // FoldSpecConstantOpAndCompositeTest. std::vector CommonTypesAndConstants() { return std::vector{ // clang-format off // scalar types "%bool = OpTypeBool", "%ushort = OpTypeInt 16 0", "%short = OpTypeInt 16 1", "%uint = OpTypeInt 32 0", "%int = OpTypeInt 32 1", "%ulong = OpTypeInt 64 0", "%long = OpTypeInt 64 1", "%float = OpTypeFloat 32", "%double = OpTypeFloat 64", // vector types "%v2bool = OpTypeVector %bool 2", "%v2uint = OpTypeVector %uint 2", "%v2int = OpTypeVector %int 2", "%v3int = OpTypeVector %int 3", "%v4int = OpTypeVector %int 4", "%v2long = OpTypeVector %long 2", "%v2ulong = OpTypeVector %ulong 2", "%v2float = OpTypeVector %float 2", "%v2double = OpTypeVector %double 2", // variable pointer types "%_pf_bool = OpTypePointer Function %bool", "%_pf_uint = OpTypePointer Function %uint", "%_pf_int = OpTypePointer Function %int", "%_pf_float = OpTypePointer Function %float", "%_pf_double = OpTypePointer Function %double", "%_pf_v2int = OpTypePointer Function %v2int", "%_pf_v2float = OpTypePointer Function %v2float", "%_pf_v2double = OpTypePointer Function %v2double", // struct types "%inner_struct = OpTypeStruct %bool %int %float", "%outer_struct = OpTypeStruct %inner_struct %int", "%flat_struct = OpTypeStruct %bool %int %float", // common constants // scalar constants: "%bool_true = OpConstantTrue %bool", "%bool_false = OpConstantFalse %bool", "%bool_null = OpConstantNull %bool", "%signed_zero = OpConstant %int 0", "%unsigned_zero = OpConstant %uint 0", "%long_zero = OpConstant %long 0", "%ulong_zero = OpConstant %ulong 0", "%signed_one = OpConstant %int 1", "%unsigned_one = OpConstant %uint 1", "%signed_two = OpConstant %int 2", "%unsigned_two = OpConstant %uint 2", "%signed_three = OpConstant %int 3", "%unsigned_three = OpConstant %uint 3", "%signed_null = OpConstantNull %int", "%unsigned_null = OpConstantNull %uint", "%signed_minus_one = OpConstant %int -1", // vector constants: "%bool_true_vec = OpConstantComposite %v2bool %bool_true %bool_true", "%bool_false_vec = OpConstantComposite %v2bool %bool_false %bool_false", "%bool_null_vec = OpConstantNull %v2bool", "%signed_zero_vec = OpConstantComposite %v2int %signed_zero %signed_zero", "%unsigned_zero_vec = OpConstantComposite %v2uint %unsigned_zero %unsigned_zero", "%signed_one_vec = OpConstantComposite %v2int %signed_one %signed_one", "%unsigned_one_vec = OpConstantComposite %v2uint %unsigned_one %unsigned_one", "%signed_two_vec = OpConstantComposite %v2int %signed_two %signed_two", "%unsigned_two_vec = OpConstantComposite %v2uint %unsigned_two %unsigned_two", "%signed_three_vec = OpConstantComposite %v2int %signed_three %signed_three", "%unsigned_three_vec = OpConstantComposite %v2uint %unsigned_three %unsigned_three", "%signed_null_vec = OpConstantNull %v2int", "%unsigned_null_vec = OpConstantNull %v2uint", "%signed_minus_one_vec = OpConstantComposite %v2int %signed_minus_one %signed_minus_one", "%v4int_0_1_2_3 = OpConstantComposite %v4int %signed_zero %signed_one %signed_two %signed_three", // clang-format on }; } // A helper function to strip OpName instructions from the given string of // disassembly code. Returns the string with all OpName instruction stripped. std::string StripOpNameInstructions(const std::string& str) { std::stringstream ss(str); std::ostringstream oss; std::string inst_str; while (std::getline(ss, inst_str, '\n')) { if (inst_str.find("OpName %") == std::string::npos) { oss << inst_str << '\n'; } } return oss.str(); } struct FoldSpecConstantOpAndCompositePassTestCase { // Original constants with unfolded spec constants. std::vector original; // Expected constant after folding. std::vector expected; }; using FoldSpecConstantOpAndCompositePassTest = PassTest< ::testing::TestWithParam>; TEST_P(FoldSpecConstantOpAndCompositePassTest, ParamTestCase) { AssemblyBuilder test_code_builder, expected_code_builder; const auto& tc = GetParam(); test_code_builder.AppendTypesConstantsGlobals(CommonTypesAndConstants()); test_code_builder.AppendTypesConstantsGlobals(tc.original); expected_code_builder.AppendTypesConstantsGlobals(CommonTypesAndConstants()); expected_code_builder.AppendTypesConstantsGlobals(tc.expected); const std::string original = test_code_builder.GetCode(); const std::string expected = expected_code_builder.GetCode(); // Run the optimization and get the result code in disassembly. std::string optimized; auto status = Pass::Status::SuccessWithoutChange; std::tie(optimized, status) = SinglePassRunAndDisassemble( original, /* skip_nop = */ true, /* do_validation = */ false); // Check the optimized code, but ignore the OpName instructions. EXPECT_NE(Pass::Status::Failure, status); EXPECT_EQ( StripOpNameInstructions(expected) == StripOpNameInstructions(original), status == Pass::Status::SuccessWithoutChange); EXPECT_EQ(StripOpNameInstructions(expected), StripOpNameInstructions(optimized)); } // Tests that OpSpecConstantComposite opcodes are replace with // OpConstantComposite correctly. INSTANTIATE_TEST_SUITE_P( Composite, FoldSpecConstantOpAndCompositePassTest, ::testing::ValuesIn(std::vector< FoldSpecConstantOpAndCompositePassTestCase>({ // clang-format off // normal vector { // original { "%spec_v2bool = OpSpecConstantComposite %v2bool %bool_true %bool_false", "%spec_v2uint = OpSpecConstantComposite %v2uint %unsigned_one %unsigned_one", "%spec_v2int_a = OpSpecConstantComposite %v2int %signed_one %signed_two", // Spec constants whose value can not be fully resolved should // not be processed. "%spec_int = OpSpecConstant %int 99", "%spec_v2int_b = OpSpecConstantComposite %v2int %signed_one %spec_int", }, // expected { "%spec_v2bool = OpConstantComposite %v2bool %bool_true %bool_false", "%spec_v2uint = OpConstantComposite %v2uint %unsigned_one %unsigned_one", "%spec_v2int_a = OpConstantComposite %v2int %signed_one %signed_two", "%spec_int = OpSpecConstant %int 99", "%spec_v2int_b = OpSpecConstantComposite %v2int %signed_one %spec_int", }, }, // vector with null constants { // original { "%null_bool = OpConstantNull %bool", "%null_int = OpConstantNull %int", "%spec_v2bool = OpSpecConstantComposite %v2bool %null_bool %null_bool", "%spec_v3int = OpSpecConstantComposite %v3int %null_int %null_int %null_int", "%spec_v4int = OpSpecConstantComposite %v4int %null_int %null_int %null_int %null_int", }, // expected { "%null_bool = OpConstantNull %bool", "%null_int = OpConstantNull %int", "%spec_v2bool = OpConstantComposite %v2bool %null_bool %null_bool", "%spec_v3int = OpConstantComposite %v3int %null_int %null_int %null_int", "%spec_v4int = OpConstantComposite %v4int %null_int %null_int %null_int %null_int", }, }, // flat struct { // original { "%float_1 = OpConstant %float 1", "%flat_1 = OpSpecConstantComposite %flat_struct %bool_true %signed_null %float_1", // following struct should not be folded as the value of // %spec_float is not determined. "%spec_float = OpSpecConstant %float 1", "%flat_2 = OpSpecConstantComposite %flat_struct %bool_true %signed_one %spec_float", }, // expected { "%float_1 = OpConstant %float 1", "%flat_1 = OpConstantComposite %flat_struct %bool_true %signed_null %float_1", "%spec_float = OpSpecConstant %float 1", "%flat_2 = OpSpecConstantComposite %flat_struct %bool_true %signed_one %spec_float", } }, // nested struct { // original { "%float_1 = OpConstant %float 1", "%inner_1 = OpSpecConstantComposite %inner_struct %bool_true %signed_null %float_1", "%outer_1 = OpSpecConstantComposite %outer_struct %inner_1 %signed_one", // following structs should not be folded as the value of // %spec_float is not determined. "%spec_float = OpSpecConstant %float 1", "%inner_2 = OpSpecConstantComposite %inner_struct %bool_true %signed_null %spec_float", "%outer_2 = OpSpecConstantComposite %outer_struct %inner_2 %signed_one", }, // expected { "%float_1 = OpConstant %float 1", "%inner_1 = OpConstantComposite %inner_struct %bool_true %signed_null %float_1", "%outer_1 = OpConstantComposite %outer_struct %inner_1 %signed_one", "%spec_float = OpSpecConstant %float 1", "%inner_2 = OpSpecConstantComposite %inner_struct %bool_true %signed_null %spec_float", "%outer_2 = OpSpecConstantComposite %outer_struct %inner_2 %signed_one", } }, // composite constants touched by OpUndef should be skipped { // original { "%undef = OpUndef %float", "%inner = OpConstantComposite %inner_struct %bool_true %signed_one %undef", "%outer = OpSpecConstantComposite %outer_struct %inner %signed_one", }, // expected { "%undef = OpUndef %float", "%inner = OpConstantComposite %inner_struct %bool_true %signed_one %undef", "%outer = OpSpecConstantComposite %outer_struct %inner %signed_one", }, }, // Fold an QuantizetoF16 instruction { // original { "%float_1 = OpConstant %float 1", "%quant_float = OpSpecConstantOp %float QuantizeToF16 %float_1", }, // expected { "%float_1 = OpConstant %float 1", "%quant_float = OpConstant %float 1", }, } // clang-format on }))); // Tests for operations that resulting in different types. INSTANTIATE_TEST_SUITE_P( Cast, FoldSpecConstantOpAndCompositePassTest, ::testing::ValuesIn(std::vector< FoldSpecConstantOpAndCompositePassTestCase>({ // clang-format off // int -> bool scalar { // original { "%spec_bool_t = OpSpecConstantOp %bool INotEqual %signed_three %signed_zero", "%spec_bool_f = OpSpecConstantOp %bool INotEqual %signed_zero %signed_zero", "%spec_bool_from_null = OpSpecConstantOp %bool INotEqual %signed_null %signed_zero", }, // expected { "%spec_bool_t = OpConstantTrue %bool", "%spec_bool_f = OpConstantFalse %bool", "%spec_bool_from_null = OpConstantFalse %bool", }, }, // uint -> bool scalar { // original { "%spec_bool_t = OpSpecConstantOp %bool INotEqual %unsigned_three %unsigned_zero", "%spec_bool_f = OpSpecConstantOp %bool INotEqual %unsigned_zero %unsigned_zero", "%spec_bool_from_null = OpSpecConstantOp %bool INotEqual %unsigned_null %unsigned_zero", }, // expected { "%spec_bool_t = OpConstantTrue %bool", "%spec_bool_f = OpConstantFalse %bool", "%spec_bool_from_null = OpConstantFalse %bool", }, }, // bool -> int scalar { // original { "%spec_int_one = OpSpecConstantOp %int Select %bool_true %signed_one %signed_zero", "%spec_int_zero = OpSpecConstantOp %int Select %bool_false %signed_one %signed_zero", "%spec_int_from_null = OpSpecConstantOp %int Select %bool_null %signed_one %signed_zero", }, // expected { "%spec_int_one = OpConstant %int 1", "%spec_int_zero = OpConstant %int 0", "%spec_int_from_null = OpConstant %int 0", }, }, // uint -> int scalar { // original { "%spec_int_one = OpSpecConstantOp %int IAdd %unsigned_one %signed_zero", "%spec_int_zero = OpSpecConstantOp %int IAdd %unsigned_zero %signed_zero", "%spec_int_from_null = OpSpecConstantOp %int IAdd %unsigned_null %unsigned_zero", }, // expected { "%spec_int_one = OpConstant %int 1", "%spec_int_zero = OpConstant %int 0", "%spec_int_from_null = OpConstant %int 0", }, }, // bool -> uint scalar { // original { "%spec_uint_one = OpSpecConstantOp %uint Select %bool_true %unsigned_one %unsigned_zero", "%spec_uint_zero = OpSpecConstantOp %uint Select %bool_false %unsigned_one %unsigned_zero", "%spec_uint_from_null = OpSpecConstantOp %uint Select %bool_null %unsigned_one %unsigned_zero", }, // expected { "%spec_uint_one = OpConstant %uint 1", "%spec_uint_zero = OpConstant %uint 0", "%spec_uint_from_null = OpConstant %uint 0", }, }, // int -> uint scalar { // original { "%spec_uint_one = OpSpecConstantOp %uint IAdd %signed_one %unsigned_zero", "%spec_uint_zero = OpSpecConstantOp %uint IAdd %signed_zero %unsigned_zero", "%spec_uint_from_null = OpSpecConstantOp %uint IAdd %signed_null %unsigned_zero", }, // expected { "%spec_uint_one = OpConstant %uint 1", "%spec_uint_zero = OpConstant %uint 0", "%spec_uint_from_null = OpConstant %uint 0", }, }, // int -> bool vector { // original { "%spec_bool_t_vec = OpSpecConstantOp %v2bool INotEqual %signed_three_vec %signed_zero_vec", "%spec_bool_f_vec = OpSpecConstantOp %v2bool INotEqual %signed_zero_vec %signed_zero_vec", "%spec_bool_from_null = OpSpecConstantOp %v2bool INotEqual %signed_null_vec %signed_zero_vec", }, // expected { "%spec_bool_t_vec = OpConstantComposite %v2bool %bool_true %bool_true", "%spec_bool_f_vec = OpConstantComposite %v2bool %bool_false %bool_false", "%spec_bool_from_null = OpConstantComposite %v2bool %bool_false %bool_false", }, }, // uint -> bool vector { // original { "%spec_bool_t_vec = OpSpecConstantOp %v2bool INotEqual %unsigned_three_vec %unsigned_zero_vec", "%spec_bool_f_vec = OpSpecConstantOp %v2bool INotEqual %unsigned_zero_vec %unsigned_zero_vec", "%spec_bool_from_null = OpSpecConstantOp %v2bool INotEqual %unsigned_null_vec %unsigned_zero_vec", }, // expected { "%spec_bool_t_vec = OpConstantComposite %v2bool %bool_true %bool_true", "%spec_bool_f_vec = OpConstantComposite %v2bool %bool_false %bool_false", "%spec_bool_from_null = OpConstantComposite %v2bool %bool_false %bool_false", }, }, // bool -> int vector { // original { "%spec_int_one_vec = OpSpecConstantOp %v2int Select %bool_true_vec %signed_one_vec %signed_zero_vec", "%spec_int_zero_vec = OpSpecConstantOp %v2int Select %bool_false_vec %signed_one_vec %signed_zero_vec", "%spec_int_from_null = OpSpecConstantOp %v2int Select %bool_null_vec %signed_one_vec %signed_zero_vec", }, // expected { "%spec_int_one_vec = OpConstantComposite %v2int %signed_one %signed_one", "%spec_int_zero_vec = OpConstantComposite %v2int %signed_zero %signed_zero", "%spec_int_from_null = OpConstantComposite %v2int %signed_zero %signed_zero", }, }, // uint -> int vector { // original { "%spec_int_one_vec = OpSpecConstantOp %v2int IAdd %unsigned_one_vec %signed_zero_vec", "%spec_int_zero_vec = OpSpecConstantOp %v2int IAdd %unsigned_zero_vec %signed_zero_vec", "%spec_int_from_null = OpSpecConstantOp %v2int IAdd %unsigned_null_vec %signed_zero_vec", }, // expected { "%spec_int_one_vec = OpConstantComposite %v2int %signed_one %signed_one", "%spec_int_zero_vec = OpConstantComposite %v2int %signed_zero %signed_zero", "%spec_int_from_null = OpConstantComposite %v2int %signed_zero %signed_zero", }, }, // bool -> uint vector { // original { "%spec_uint_one_vec = OpSpecConstantOp %v2uint Select %bool_true_vec %unsigned_one_vec %unsigned_zero_vec", "%spec_uint_zero_vec = OpSpecConstantOp %v2uint Select %bool_false_vec %unsigned_one_vec %unsigned_zero_vec", "%spec_uint_from_null = OpSpecConstantOp %v2uint Select %bool_null_vec %unsigned_one_vec %unsigned_zero_vec", }, // expected { "%spec_uint_one_vec = OpConstantComposite %v2uint %unsigned_one %unsigned_one", "%spec_uint_zero_vec = OpConstantComposite %v2uint %unsigned_zero %unsigned_zero", "%spec_uint_from_null = OpConstantComposite %v2uint %unsigned_zero %unsigned_zero", }, }, // int -> uint vector { // original { "%spec_uint_one_vec = OpSpecConstantOp %v2uint IAdd %signed_one_vec %unsigned_zero_vec", "%spec_uint_zero_vec = OpSpecConstantOp %v2uint IAdd %signed_zero_vec %unsigned_zero_vec", "%spec_uint_from_null = OpSpecConstantOp %v2uint IAdd %signed_null_vec %unsigned_zero_vec", }, // expected { "%spec_uint_one_vec = OpConstantComposite %v2uint %unsigned_one %unsigned_one", "%spec_uint_zero_vec = OpConstantComposite %v2uint %unsigned_zero %unsigned_zero", "%spec_uint_from_null = OpConstantComposite %v2uint %unsigned_zero %unsigned_zero", }, }, // UConvert scalar { // original { "%spec_ulong_zero = OpSpecConstantOp %ulong UConvert %unsigned_zero", "%spec_ulong_one = OpSpecConstantOp %ulong UConvert %unsigned_one", "%spec_short_zero = OpSpecConstantOp %ushort UConvert %unsigned_zero", "%spec_short_one = OpSpecConstantOp %ushort UConvert %unsigned_one", "%uint_max = OpConstant %uint 4294967295", "%spec_ushort_max = OpSpecConstantOp %ushort UConvert %uint_max", "%uint_0xDDDDDDDD = OpConstant %uint 3722304989", "%spec_ushort_0xDDDD = OpSpecConstantOp %ushort UConvert %uint_0xDDDDDDDD", }, // expected { "%spec_ulong_zero = OpConstant %ulong 0", "%spec_ulong_one = OpConstant %ulong 1", "%spec_short_zero = OpConstant %ushort 0", "%spec_short_one = OpConstant %ushort 1", "%uint_max = OpConstant %uint 4294967295", "%spec_ushort_max = OpConstant %ushort 65535", "%uint_0xDDDDDDDD = OpConstant %uint 3722304989", "%spec_ushort_0xDDDD = OpConstant %ushort 56797", }, }, // SConvert scalar { // original { "%spec_long_zero = OpSpecConstantOp %long SConvert %signed_zero", "%spec_long_one = OpSpecConstantOp %long SConvert %signed_one", "%spec_long_minus_one = OpSpecConstantOp %long SConvert %signed_minus_one", "%spec_short_minus_one_trunc = OpSpecConstantOp %short SConvert %signed_minus_one", "%int_2_to_17_minus_one = OpConstant %int 131071", "%spec_short_minus_one_trunc2 = OpSpecConstantOp %short SConvert %int_2_to_17_minus_one", }, // expected { "%spec_long_zero = OpConstant %long 0", "%spec_long_one = OpConstant %long 1", "%spec_long_minus_one = OpConstant %long -1", "%spec_short_minus_one_trunc = OpConstant %short -1", "%int_2_to_17_minus_one = OpConstant %int 131071", "%spec_short_minus_one_trunc2 = OpConstant %short -1", }, }, // UConvert vector { // original { "%spec_v2ulong_zero = OpSpecConstantOp %v2ulong UConvert %unsigned_zero_vec", "%spec_v2ulong_one = OpSpecConstantOp %v2ulong UConvert %unsigned_one_vec", }, // expected { "%spec_v2ulong_zero = OpConstantComposite %v2ulong %ulong_zero %ulong_zero", "%ulong_1 = OpConstant %ulong 1", "%spec_v2ulong_one = OpConstantComposite %v2ulong %ulong_1 %ulong_1", }, }, // SConvert vector { // original { "%spec_v2long_zero = OpSpecConstantOp %v2long SConvert %signed_zero_vec", "%spec_v2long_one = OpSpecConstantOp %v2long SConvert %signed_one_vec", "%spec_v2long_minus_one = OpSpecConstantOp %v2long SConvert %signed_minus_one_vec", }, // expected { "%spec_v2long_zero = OpConstantComposite %v2long %long_zero %long_zero", "%long_1 = OpConstant %long 1", "%spec_v2long_one = OpConstantComposite %v2long %long_1 %long_1", "%long_n1 = OpConstant %long -1", "%spec_v2long_minus_one = OpConstantComposite %v2long %long_n1 %long_n1", }, }, // clang-format on }))); // Tests about boolean scalar logical operations and comparison operations with // scalar int/uint type. INSTANTIATE_TEST_SUITE_P( Logical, FoldSpecConstantOpAndCompositePassTest, ::testing::ValuesIn(std::vector< FoldSpecConstantOpAndCompositePassTestCase>({ // clang-format off // scalar integer comparison { // original { "%int_minus_1 = OpConstant %int -1", "%slt_0_1 = OpSpecConstantOp %bool SLessThan %signed_zero %signed_one", "%sgt_0_1 = OpSpecConstantOp %bool SGreaterThan %signed_zero %signed_one", "%sle_2_2 = OpSpecConstantOp %bool SLessThanEqual %signed_two %signed_two", "%sge_2_1 = OpSpecConstantOp %bool SGreaterThanEqual %signed_two %signed_one", "%sge_2_null = OpSpecConstantOp %bool SGreaterThanEqual %signed_two %signed_null", "%sge_minus_1_null = OpSpecConstantOp %bool SGreaterThanEqual %int_minus_1 %signed_null", "%ult_0_1 = OpSpecConstantOp %bool ULessThan %unsigned_zero %unsigned_one", "%ugt_0_1 = OpSpecConstantOp %bool UGreaterThan %unsigned_zero %unsigned_one", "%ule_2_3 = OpSpecConstantOp %bool ULessThanEqual %unsigned_two %unsigned_three", "%uge_1_1 = OpSpecConstantOp %bool UGreaterThanEqual %unsigned_one %unsigned_one", "%uge_2_null = OpSpecConstantOp %bool UGreaterThanEqual %unsigned_two %unsigned_null", "%uge_minus_1_null = OpSpecConstantOp %bool UGreaterThanEqual %int_minus_1 %unsigned_null", }, // expected { "%int_minus_1 = OpConstant %int -1", "%slt_0_1 = OpConstantTrue %bool", "%sgt_0_1 = OpConstantFalse %bool", "%sle_2_2 = OpConstantTrue %bool", "%sge_2_1 = OpConstantTrue %bool", "%sge_2_null = OpConstantTrue %bool", "%sge_minus_1_null = OpConstantFalse %bool", "%ult_0_1 = OpConstantTrue %bool", "%ugt_0_1 = OpConstantFalse %bool", "%ule_2_3 = OpConstantTrue %bool", "%uge_1_1 = OpConstantTrue %bool", "%uge_2_null = OpConstantTrue %bool", "%uge_minus_1_null = OpConstantTrue %bool", }, }, // Logical and, or, xor. { // original { "%logical_or = OpSpecConstantOp %bool LogicalOr %bool_true %bool_false", "%logical_and = OpSpecConstantOp %bool LogicalAnd %bool_true %bool_false", "%logical_not = OpSpecConstantOp %bool LogicalNot %bool_true", "%logical_eq = OpSpecConstantOp %bool LogicalEqual %bool_true %bool_true", "%logical_neq = OpSpecConstantOp %bool LogicalNotEqual %bool_true %bool_true", "%logical_and_null = OpSpecConstantOp %bool LogicalAnd %bool_true %bool_null", }, // expected { "%logical_or = OpConstantTrue %bool", "%logical_and = OpConstantFalse %bool", "%logical_not = OpConstantFalse %bool", "%logical_eq = OpConstantTrue %bool", "%logical_neq = OpConstantFalse %bool", "%logical_and_null = OpConstantFalse %bool", }, }, // clang-format on }))); // Tests about arithmetic operations for scalar int and uint types. INSTANTIATE_TEST_SUITE_P( ScalarArithmetic, FoldSpecConstantOpAndCompositePassTest, ::testing::ValuesIn(std::vector< FoldSpecConstantOpAndCompositePassTestCase>({ // clang-format off // scalar integer negate { // original { "%int_minus_1 = OpSpecConstantOp %int SNegate %signed_one", "%int_minus_2 = OpSpecConstantOp %int SNegate %signed_two", "%int_neg_null = OpSpecConstantOp %int SNegate %signed_null", "%int_max = OpConstant %int 2147483647", "%int_neg_max = OpSpecConstantOp %int SNegate %int_max", }, // expected { "%int_minus_1 = OpConstant %int -1", "%int_minus_2 = OpConstant %int -2", "%int_neg_null = OpConstantNull %int", "%int_max = OpConstant %int 2147483647", "%int_neg_max = OpConstant %int -2147483647", }, }, // scalar integer not { // original { "%uint_4294967294 = OpSpecConstantOp %uint Not %unsigned_one", "%uint_4294967293 = OpSpecConstantOp %uint Not %unsigned_two", "%uint_neg_null = OpSpecConstantOp %uint Not %unsigned_null", }, // expected { "%uint_4294967294 = OpConstant %uint 4294967294", "%uint_4294967293 = OpConstant %uint 4294967293", "%uint_neg_null = OpConstant %uint 4294967295", }, }, // scalar integer add, sub, mul, div { // original { "%signed_max = OpConstant %int 2147483647", "%signed_min = OpConstant %int -2147483648", "%spec_int_iadd = OpSpecConstantOp %int IAdd %signed_three %signed_two", "%spec_int_isub = OpSpecConstantOp %int ISub %signed_one %spec_int_iadd", "%spec_int_sdiv = OpSpecConstantOp %int SDiv %spec_int_isub %signed_two", "%spec_int_imul = OpSpecConstantOp %int IMul %spec_int_sdiv %signed_three", "%spec_int_iadd_null = OpSpecConstantOp %int IAdd %spec_int_imul %signed_null", "%spec_int_imul_null = OpSpecConstantOp %int IMul %spec_int_iadd_null %signed_null", "%spec_int_iadd_overflow = OpSpecConstantOp %int IAdd %signed_max %signed_three", "%spec_int_isub_overflow = OpSpecConstantOp %int ISub %signed_min %signed_three", "%spec_uint_iadd = OpSpecConstantOp %uint IAdd %unsigned_three %unsigned_two", "%spec_uint_isub = OpSpecConstantOp %uint ISub %unsigned_one %spec_uint_iadd", "%spec_uint_udiv = OpSpecConstantOp %uint UDiv %spec_uint_isub %unsigned_three", "%spec_uint_imul = OpSpecConstantOp %uint IMul %spec_uint_udiv %unsigned_two", "%spec_uint_isub_null = OpSpecConstantOp %uint ISub %spec_uint_imul %signed_null", }, // expected { "%signed_max = OpConstant %int 2147483647", "%signed_min = OpConstant %int -2147483648", "%spec_int_iadd = OpConstant %int 5", "%spec_int_isub = OpConstant %int -4", "%spec_int_sdiv = OpConstant %int -2", "%spec_int_imul = OpConstant %int -6", "%spec_int_iadd_null = OpConstant %int -6", "%spec_int_imul_null = OpConstant %int 0", "%spec_int_iadd_overflow = OpConstant %int -2147483646", "%spec_int_isub_overflow = OpConstant %int 2147483645", "%spec_uint_iadd = OpConstant %uint 5", "%spec_uint_isub = OpConstant %uint 4294967292", "%spec_uint_udiv = OpConstant %uint 1431655764", "%spec_uint_imul = OpConstant %uint 2863311528", "%spec_uint_isub_null = OpConstant %uint 2863311528", }, }, // scalar integer rem, mod { // original { // common constants "%int_7 = OpConstant %int 7", "%uint_7 = OpConstant %uint 7", "%int_minus_7 = OpConstant %int -7", "%int_minus_3 = OpConstant %int -3", // srem "%7_srem_3 = OpSpecConstantOp %int SRem %int_7 %signed_three", "%minus_7_srem_3 = OpSpecConstantOp %int SRem %int_minus_7 %signed_three", "%7_srem_minus_3 = OpSpecConstantOp %int SRem %int_7 %int_minus_3", "%minus_7_srem_minus_3 = OpSpecConstantOp %int SRem %int_minus_7 %int_minus_3", // smod "%7_smod_3 = OpSpecConstantOp %int SMod %int_7 %signed_three", "%minus_7_smod_3 = OpSpecConstantOp %int SMod %int_minus_7 %signed_three", "%7_smod_minus_3 = OpSpecConstantOp %int SMod %int_7 %int_minus_3", "%minus_7_smod_minus_3 = OpSpecConstantOp %int SMod %int_minus_7 %int_minus_3", // umod "%7_umod_3 = OpSpecConstantOp %uint UMod %uint_7 %unsigned_three", // null constant "%null_srem_3 = OpSpecConstantOp %int SRem %signed_null %signed_three", "%null_smod_3 = OpSpecConstantOp %int SMod %signed_null %signed_three", "%null_umod_3 = OpSpecConstantOp %uint UMod %unsigned_null %unsigned_three", }, // expected { // common constants "%int_7 = OpConstant %int 7", "%uint_7 = OpConstant %uint 7", "%int_minus_7 = OpConstant %int -7", "%int_minus_3 = OpConstant %int -3", // srem "%7_srem_3 = OpConstant %int 1", "%minus_7_srem_3 = OpConstant %int -1", "%7_srem_minus_3 = OpConstant %int 1", "%minus_7_srem_minus_3 = OpConstant %int -1", // smod "%7_smod_3 = OpConstant %int 1", "%minus_7_smod_3 = OpConstant %int 2", "%7_smod_minus_3 = OpConstant %int -2", "%minus_7_smod_minus_3 = OpConstant %int -1", // umod "%7_umod_3 = OpConstant %uint 1", // null constant "%null_srem_3 = OpConstant %int 0", "%null_smod_3 = OpConstant %int 0", "%null_umod_3 = OpConstant %uint 0", }, }, // scalar integer bitwise and shift { // original { // bitwise "%xor_1_3 = OpSpecConstantOp %int BitwiseXor %signed_one %signed_three", "%and_1_2 = OpSpecConstantOp %int BitwiseAnd %signed_one %xor_1_3", "%or_1_2 = OpSpecConstantOp %int BitwiseOr %signed_one %xor_1_3", "%xor_3_null = OpSpecConstantOp %int BitwiseXor %or_1_2 %signed_null", // shift "%unsigned_31 = OpConstant %uint 31", "%unsigned_left_shift_max = OpSpecConstantOp %uint ShiftLeftLogical %unsigned_one %unsigned_31", "%unsigned_right_shift_logical = OpSpecConstantOp %uint ShiftRightLogical %unsigned_left_shift_max %unsigned_31", "%signed_right_shift_arithmetic = OpSpecConstantOp %int ShiftRightArithmetic %unsigned_left_shift_max %unsigned_31", "%left_shift_null_31 = OpSpecConstantOp %uint ShiftLeftLogical %unsigned_null %unsigned_31", "%right_shift_31_null = OpSpecConstantOp %uint ShiftRightLogical %unsigned_31 %unsigned_null", }, // expected { "%xor_1_3 = OpConstant %int 2", "%and_1_2 = OpConstant %int 0", "%or_1_2 = OpConstant %int 3", "%xor_3_null = OpConstant %int 3", "%unsigned_31 = OpConstant %uint 31", "%unsigned_left_shift_max = OpConstant %uint 2147483648", "%unsigned_right_shift_logical = OpConstant %uint 1", "%signed_right_shift_arithmetic = OpConstant %int -1", "%left_shift_null_31 = OpConstant %uint 0", "%right_shift_31_null = OpConstant %uint 31", }, }, // Skip folding if any operands have undetermined value. { // original { "%spec_int = OpSpecConstant %int 1", "%spec_iadd = OpSpecConstantOp %int IAdd %signed_three %spec_int", }, // expected { "%spec_int = OpSpecConstant %int 1", "%spec_iadd = OpSpecConstantOp %int IAdd %signed_three %spec_int", }, }, // clang-format on }))); // Tests about arithmetic operations for vector int and uint types. INSTANTIATE_TEST_SUITE_P( VectorArithmetic, FoldSpecConstantOpAndCompositePassTest, ::testing::ValuesIn(std::vector< FoldSpecConstantOpAndCompositePassTestCase>({ // clang-format off // vector integer negate { // original { "%v2int_minus_1 = OpSpecConstantOp %v2int SNegate %signed_one_vec", "%v2int_minus_2 = OpSpecConstantOp %v2int SNegate %signed_two_vec", "%v2int_neg_null = OpSpecConstantOp %v2int SNegate %signed_null_vec", }, // expected { "%v2int_minus_1 = OpConstantComposite %v2int %signed_minus_one %signed_minus_one", "%int_n2 = OpConstant %int -2", "%v2int_minus_2 = OpConstantComposite %v2int %int_n2 %int_n2", "%v2int_neg_null = OpConstantComposite %v2int %signed_null %signed_null", }, }, // vector integer (including null vetors) add, sub, div, mul { // original { "%spec_v2int_iadd = OpSpecConstantOp %v2int IAdd %signed_three_vec %signed_two_vec", "%spec_v2int_isub = OpSpecConstantOp %v2int ISub %signed_one_vec %spec_v2int_iadd", "%spec_v2int_sdiv = OpSpecConstantOp %v2int SDiv %spec_v2int_isub %signed_two_vec", "%spec_v2int_imul = OpSpecConstantOp %v2int IMul %spec_v2int_sdiv %signed_three_vec", "%spec_v2int_iadd_null = OpSpecConstantOp %v2int IAdd %spec_v2int_imul %signed_null_vec", "%spec_v2uint_iadd = OpSpecConstantOp %v2uint IAdd %unsigned_three_vec %unsigned_two_vec", "%spec_v2uint_isub = OpSpecConstantOp %v2uint ISub %unsigned_one_vec %spec_v2uint_iadd", "%spec_v2uint_udiv = OpSpecConstantOp %v2uint UDiv %spec_v2uint_isub %unsigned_three_vec", "%spec_v2uint_imul = OpSpecConstantOp %v2uint IMul %spec_v2uint_udiv %unsigned_two_vec", "%spec_v2uint_isub_null = OpSpecConstantOp %v2uint ISub %spec_v2uint_imul %signed_null_vec", }, // expected { "%int_5 = OpConstant %int 5", "%spec_v2int_iadd = OpConstantComposite %v2int %int_5 %int_5", "%int_n4 = OpConstant %int -4", "%spec_v2int_isub = OpConstantComposite %v2int %int_n4 %int_n4", "%int_n2 = OpConstant %int -2", "%spec_v2int_sdiv = OpConstantComposite %v2int %int_n2 %int_n2", "%int_n6 = OpConstant %int -6", "%spec_v2int_imul = OpConstantComposite %v2int %int_n6 %int_n6", "%spec_v2int_iadd_null = OpConstantComposite %v2int %int_n6 %int_n6", "%uint_5 = OpConstant %uint 5", "%spec_v2uint_iadd = OpConstantComposite %v2uint %uint_5 %uint_5", "%uint_4294967292 = OpConstant %uint 4294967292", "%spec_v2uint_isub = OpConstantComposite %v2uint %uint_4294967292 %uint_4294967292", "%uint_1431655764 = OpConstant %uint 1431655764", "%spec_v2uint_udiv = OpConstantComposite %v2uint %uint_1431655764 %uint_1431655764", "%uint_2863311528 = OpConstant %uint 2863311528", "%spec_v2uint_imul = OpConstantComposite %v2uint %uint_2863311528 %uint_2863311528", "%spec_v2uint_isub_null = OpConstantComposite %v2uint %uint_2863311528 %uint_2863311528", }, }, // vector integer rem, mod { // original { // common constants "%int_7 = OpConstant %int 7", "%v2int_7 = OpConstantComposite %v2int %int_7 %int_7", "%uint_7 = OpConstant %uint 7", "%v2uint_7 = OpConstantComposite %v2uint %uint_7 %uint_7", "%int_minus_7 = OpConstant %int -7", "%v2int_minus_7 = OpConstantComposite %v2int %int_minus_7 %int_minus_7", "%int_minus_3 = OpConstant %int -3", "%v2int_minus_3 = OpConstantComposite %v2int %int_minus_3 %int_minus_3", // srem "%7_srem_3 = OpSpecConstantOp %v2int SRem %v2int_7 %signed_three_vec", "%minus_7_srem_3 = OpSpecConstantOp %v2int SRem %v2int_minus_7 %signed_three_vec", "%7_srem_minus_3 = OpSpecConstantOp %v2int SRem %v2int_7 %v2int_minus_3", "%minus_7_srem_minus_3 = OpSpecConstantOp %v2int SRem %v2int_minus_7 %v2int_minus_3", // smod "%7_smod_3 = OpSpecConstantOp %v2int SMod %v2int_7 %signed_three_vec", "%minus_7_smod_3 = OpSpecConstantOp %v2int SMod %v2int_minus_7 %signed_three_vec", "%7_smod_minus_3 = OpSpecConstantOp %v2int SMod %v2int_7 %v2int_minus_3", "%minus_7_smod_minus_3 = OpSpecConstantOp %v2int SMod %v2int_minus_7 %v2int_minus_3", // umod "%7_umod_3 = OpSpecConstantOp %v2uint UMod %v2uint_7 %unsigned_three_vec", }, // expected { // common constants "%int_7 = OpConstant %int 7", "%v2int_7 = OpConstantComposite %v2int %int_7 %int_7", "%uint_7 = OpConstant %uint 7", "%v2uint_7 = OpConstantComposite %v2uint %uint_7 %uint_7", "%int_minus_7 = OpConstant %int -7", "%v2int_minus_7 = OpConstantComposite %v2int %int_minus_7 %int_minus_7", "%int_minus_3 = OpConstant %int -3", "%v2int_minus_3 = OpConstantComposite %v2int %int_minus_3 %int_minus_3", // srem "%7_srem_3 = OpConstantComposite %v2int %signed_one %signed_one", "%minus_7_srem_3 = OpConstantComposite %v2int %signed_minus_one %signed_minus_one", "%7_srem_minus_3 = OpConstantComposite %v2int %signed_one %signed_one", "%minus_7_srem_minus_3 = OpConstantComposite %v2int %signed_minus_one %signed_minus_one", // smod "%7_smod_3 = OpConstantComposite %v2int %signed_one %signed_one", "%minus_7_smod_3 = OpConstantComposite %v2int %signed_two %signed_two", "%int_n2 = OpConstant %int -2", "%7_smod_minus_3 = OpConstantComposite %v2int %int_n2 %int_n2", "%minus_7_smod_minus_3 = OpConstantComposite %v2int %signed_minus_one %signed_minus_one", // umod "%7_umod_3 = OpConstantComposite %v2uint %unsigned_one %unsigned_one", }, }, // vector integer bitwise, shift { // original { "%xor_1_3 = OpSpecConstantOp %v2int BitwiseXor %signed_one_vec %signed_three_vec", "%and_1_2 = OpSpecConstantOp %v2int BitwiseAnd %signed_one_vec %xor_1_3", "%or_1_2 = OpSpecConstantOp %v2int BitwiseOr %signed_one_vec %xor_1_3", "%unsigned_31 = OpConstant %uint 31", "%v2unsigned_31 = OpConstantComposite %v2uint %unsigned_31 %unsigned_31", "%unsigned_left_shift_max = OpSpecConstantOp %v2uint ShiftLeftLogical %unsigned_one_vec %v2unsigned_31", "%unsigned_right_shift_logical = OpSpecConstantOp %v2uint ShiftRightLogical %unsigned_left_shift_max %v2unsigned_31", "%signed_right_shift_arithmetic = OpSpecConstantOp %v2int ShiftRightArithmetic %unsigned_left_shift_max %v2unsigned_31", }, // expected { "%xor_1_3 = OpConstantComposite %v2int %signed_two %signed_two", "%and_1_2 = OpConstantComposite %v2int %signed_zero %signed_zero", "%or_1_2 = OpConstantComposite %v2int %signed_three %signed_three", "%unsigned_31 = OpConstant %uint 31", "%v2unsigned_31 = OpConstantComposite %v2uint %unsigned_31 %unsigned_31", "%uint_2147483648 = OpConstant %uint 2147483648", "%unsigned_left_shift_max = OpConstantComposite %v2uint %uint_2147483648 %uint_2147483648", "%unsigned_right_shift_logical = OpConstantComposite %v2uint %unsigned_one %unsigned_one", "%signed_right_shift_arithmetic = OpConstantComposite %v2int %signed_minus_one %signed_minus_one", }, }, // Skip folding if any vector operands or components of the operands // have undetermined value. { // original { "%spec_int = OpSpecConstant %int 1", "%spec_vec = OpSpecConstantComposite %v2int %signed_zero %spec_int", "%spec_iadd = OpSpecConstantOp %v2int IAdd %signed_three_vec %spec_vec", }, // expected { "%spec_int = OpSpecConstant %int 1", "%spec_vec = OpSpecConstantComposite %v2int %signed_zero %spec_int", "%spec_iadd = OpSpecConstantOp %v2int IAdd %signed_three_vec %spec_vec", }, }, // Skip folding if any vector operands are defined by OpUndef { // original { "%undef = OpUndef %int", "%vec = OpConstantComposite %v2int %undef %signed_one", "%spec_iadd = OpSpecConstantOp %v2int IAdd %signed_three_vec %vec", }, // expected { "%undef = OpUndef %int", "%vec = OpConstantComposite %v2int %undef %signed_one", "%spec_iadd = OpSpecConstantOp %v2int IAdd %signed_three_vec %vec", }, }, // clang-format on }))); // Tests for SpecConstantOp CompositeExtract instruction INSTANTIATE_TEST_SUITE_P( CompositeExtract, FoldSpecConstantOpAndCompositePassTest, ::testing::ValuesIn(std::vector< FoldSpecConstantOpAndCompositePassTestCase>({ // clang-format off // normal vector { // original { "%r = OpSpecConstantOp %int CompositeExtract %signed_three_vec 0", "%x = OpSpecConstantOp %int CompositeExtract %v4int_0_1_2_3 0", "%y = OpSpecConstantOp %int CompositeExtract %v4int_0_1_2_3 1", "%z = OpSpecConstantOp %int CompositeExtract %v4int_0_1_2_3 2", "%w = OpSpecConstantOp %int CompositeExtract %v4int_0_1_2_3 3", }, // expected { "%r = OpConstant %int 3", "%x = OpConstant %int 0", "%y = OpConstant %int 1", "%z = OpConstant %int 2", "%w = OpConstant %int 3", }, }, // null vector { // original { "%x = OpSpecConstantOp %int CompositeExtract %signed_null_vec 0", "%y = OpSpecConstantOp %int CompositeExtract %signed_null_vec 1", "%null_v4int = OpConstantNull %v4int", "%z = OpSpecConstantOp %int CompositeExtract %signed_null_vec 2", }, // expected { "%x = OpConstantNull %int", "%y = OpConstantNull %int", "%null_v4int = OpConstantNull %v4int", "%z = OpConstantNull %int", } }, // normal flat struct { // original { "%float_1 = OpConstant %float 1", "%flat_1 = OpConstantComposite %flat_struct %bool_true %signed_null %float_1", "%extract_bool = OpSpecConstantOp %bool CompositeExtract %flat_1 0", "%extract_int = OpSpecConstantOp %int CompositeExtract %flat_1 1", "%extract_float_1 = OpSpecConstantOp %float CompositeExtract %flat_1 2", // foldable composite constants built with OpSpecConstantComposite // should also be processed. "%flat_2 = OpSpecConstantComposite %flat_struct %bool_true %signed_null %float_1", "%extract_float_2 = OpSpecConstantOp %float CompositeExtract %flat_2 2", }, // expected { "%float_1 = OpConstant %float 1", "%flat_1 = OpConstantComposite %flat_struct %bool_true %signed_null %float_1", "%extract_bool = OpConstantTrue %bool", "%extract_int = OpConstantNull %int", "%extract_float_1 = OpConstant %float 1", "%flat_2 = OpConstantComposite %flat_struct %bool_true %signed_null %float_1", "%extract_float_2 = OpConstant %float 1", }, }, // null flat struct { // original { "%flat = OpConstantNull %flat_struct", "%extract_bool = OpSpecConstantOp %bool CompositeExtract %flat 0", "%extract_int = OpSpecConstantOp %int CompositeExtract %flat 1", "%extract_float = OpSpecConstantOp %float CompositeExtract %flat 2", }, // expected { "%flat = OpConstantNull %flat_struct", "%extract_bool = OpConstantNull %bool", "%extract_int = OpConstantNull %int", "%extract_float = OpConstantNull %float", }, }, // normal nested struct { // original { "%float_1 = OpConstant %float 1", "%inner = OpConstantComposite %inner_struct %bool_true %signed_null %float_1", "%outer = OpConstantComposite %outer_struct %inner %signed_one", "%extract_inner = OpSpecConstantOp %inner_struct CompositeExtract %outer 0", "%extract_int = OpSpecConstantOp %int CompositeExtract %outer 1", "%extract_inner_float = OpSpecConstantOp %float CompositeExtract %outer 0 2", }, // expected { "%float_1 = OpConstant %float 1", "%inner = OpConstantComposite %inner_struct %bool_true %signed_null %float_1", "%outer = OpConstantComposite %outer_struct %inner %signed_one", "%extract_inner = OpConstantComposite %inner_struct %bool_true %signed_null %float_1", "%extract_int = OpConstant %int 1", "%extract_inner_float = OpConstant %float 1", }, }, // null nested struct { // original { "%outer = OpConstantNull %outer_struct", "%extract_inner = OpSpecConstantOp %inner_struct CompositeExtract %outer 0", "%extract_int = OpSpecConstantOp %int CompositeExtract %outer 1", "%extract_inner_float = OpSpecConstantOp %float CompositeExtract %outer 0 2", }, // expected { "%outer = OpConstantNull %outer_struct", "%extract_inner = OpConstantNull %inner_struct", "%extract_int = OpConstantNull %int", "%extract_inner_float = OpConstantNull %float", }, }, // skip folding if the any composite constant's value are not fully // determined, even though the extracting target might have // determined value. { // original { "%float_1 = OpConstant %float 1", "%spec_float = OpSpecConstant %float 1", "%spec_inner = OpSpecConstantComposite %inner_struct %bool_true %signed_null %spec_float", "%spec_outer = OpSpecConstantComposite %outer_struct %spec_inner %signed_one", "%spec_vec = OpSpecConstantComposite %v2float %spec_float %float_1", "%extract_inner = OpSpecConstantOp %int CompositeExtract %spec_inner 1", "%extract_outer = OpSpecConstantOp %int CompositeExtract %spec_outer 1", "%extract_vec = OpSpecConstantOp %float CompositeExtract %spec_vec 1", }, // expected { "%float_1 = OpConstant %float 1", "%spec_float = OpSpecConstant %float 1", "%spec_inner = OpSpecConstantComposite %inner_struct %bool_true %signed_null %spec_float", "%spec_outer = OpSpecConstantComposite %outer_struct %spec_inner %signed_one", "%spec_vec = OpSpecConstantComposite %v2float %spec_float %float_1", "%extract_inner = OpSpecConstantOp %int CompositeExtract %spec_inner 1", "%extract_outer = OpSpecConstantOp %int CompositeExtract %spec_outer 1", "%extract_vec = OpSpecConstantOp %float CompositeExtract %spec_vec 1", }, }, // skip if the composite constant depends on the result of OpUndef, // even though the composite extract target element does not depends // on the OpUndef. { // original { "%undef = OpUndef %float", "%inner = OpConstantComposite %inner_struct %bool_true %signed_one %undef", "%outer = OpConstantComposite %outer_struct %inner %signed_one", "%extract_inner = OpSpecConstantOp %int CompositeExtract %inner 1", "%extract_outer = OpSpecConstantOp %int CompositeExtract %outer 1", }, // expected { "%undef = OpUndef %float", "%inner = OpConstantComposite %inner_struct %bool_true %signed_one %undef", "%outer = OpConstantComposite %outer_struct %inner %signed_one", "%extract_inner = OpSpecConstantOp %int CompositeExtract %inner 1", "%extract_outer = OpSpecConstantOp %int CompositeExtract %outer 1", }, }, // TODO(qining): Add tests for Array and other composite type constants. // clang-format on }))); // Tests the swizzle operations for spec const vectors. INSTANTIATE_TEST_SUITE_P( VectorShuffle, FoldSpecConstantOpAndCompositePassTest, ::testing::ValuesIn(std::vector< FoldSpecConstantOpAndCompositePassTestCase>({ // clang-format off // normal vector { // original { "%xy = OpSpecConstantOp %v2int VectorShuffle %v4int_0_1_2_3 %v4int_0_1_2_3 0 1", "%yz = OpSpecConstantOp %v2int VectorShuffle %v4int_0_1_2_3 %v4int_0_1_2_3 1 2", "%zw = OpSpecConstantOp %v2int VectorShuffle %v4int_0_1_2_3 %v4int_0_1_2_3 2 3", "%wx = OpSpecConstantOp %v2int VectorShuffle %v4int_0_1_2_3 %v4int_0_1_2_3 3 0", "%xx = OpSpecConstantOp %v2int VectorShuffle %v4int_0_1_2_3 %v4int_0_1_2_3 0 0", "%yyy = OpSpecConstantOp %v3int VectorShuffle %v4int_0_1_2_3 %v4int_0_1_2_3 1 1 1", "%wwww = OpSpecConstantOp %v4int VectorShuffle %v4int_0_1_2_3 %v4int_0_1_2_3 2 2 2 2", }, // expected { "%xy = OpConstantComposite %v2int %signed_zero %signed_one", "%yz = OpConstantComposite %v2int %signed_one %signed_two", "%zw = OpConstantComposite %v2int %signed_two %signed_three", "%wx = OpConstantComposite %v2int %signed_three %signed_zero", "%xx = OpConstantComposite %v2int %signed_zero %signed_zero", "%yyy = OpConstantComposite %v3int %signed_one %signed_one %signed_one", "%wwww = OpConstantComposite %v4int %signed_two %signed_two %signed_two %signed_two", }, }, // null vector { // original { "%a = OpSpecConstantOp %v2int VectorShuffle %signed_null_vec %v4int_0_1_2_3 0 1", "%b = OpSpecConstantOp %v2int VectorShuffle %signed_null_vec %v4int_0_1_2_3 2 3", "%c = OpSpecConstantOp %v2int VectorShuffle %v4int_0_1_2_3 %signed_null_vec 3 4", "%d = OpSpecConstantOp %v2int VectorShuffle %signed_null_vec %signed_null_vec 1 2", }, // expected { "%a = OpConstantComposite %v2int %signed_null %signed_null", "%b = OpConstantComposite %v2int %signed_zero %signed_one", "%c = OpConstantComposite %v2int %signed_three %signed_null", "%d = OpConstantComposite %v2int %signed_null %signed_null", } }, // skip if any of the components of the vector operands do not have // determined value, even though the result vector might not be // built with those undermined values. { // original { "%spec_int = OpSpecConstant %int 1", "%spec_ivec = OpSpecConstantComposite %v2int %signed_null %spec_int", "%a = OpSpecConstantOp %v2int VectorShuffle %v4int_0_1_2_3 %spec_ivec 0 1", "%b = OpSpecConstantOp %v2int VectorShuffle %v4int_0_1_2_3 %spec_ivec 3 4", }, // expected { "%spec_int = OpSpecConstant %int 1", "%spec_ivec = OpSpecConstantComposite %v2int %signed_null %spec_int", "%a = OpSpecConstantOp %v2int VectorShuffle %v4int_0_1_2_3 %spec_ivec 0 1", "%b = OpSpecConstantOp %v2int VectorShuffle %v4int_0_1_2_3 %spec_ivec 3 4", }, }, // Skip if any components of the two vector operands depend on // the result of OpUndef. Even though the selected components do // not depend on the OpUndef result. { // original { "%undef = OpUndef %int", "%vec_1 = OpConstantComposite %v2int %undef %signed_one", "%dep = OpSpecConstantOp %v2int VectorShuffle %vec_1 %signed_three_vec 0 3", "%not_dep_element = OpSpecConstantOp %v2int VectorShuffle %vec_1 %signed_three_vec 1 3", "%no_dep_vector = OpSpecConstantOp %v2int VectorShuffle %vec_1 %signed_three_vec 2 3", }, // expected { "%undef = OpUndef %int", "%vec_1 = OpConstantComposite %v2int %undef %signed_one", "%dep = OpSpecConstantOp %v2int VectorShuffle %vec_1 %signed_three_vec 0 3", "%not_dep_element = OpSpecConstantOp %v2int VectorShuffle %vec_1 %signed_three_vec 1 3", "%no_dep_vector = OpSpecConstantOp %v2int VectorShuffle %vec_1 %signed_three_vec 2 3", }, }, // clang-format on }))); // Test with long use-def chain. INSTANTIATE_TEST_SUITE_P( LongDefUseChain, FoldSpecConstantOpAndCompositePassTest, ::testing::ValuesIn(std::vector< FoldSpecConstantOpAndCompositePassTestCase>({ // clang-format off // Long Def-Use chain with binary operations. { // original { "%array_size = OpConstant %int 4", "%type_arr_int_4 = OpTypeArray %int %array_size", "%spec_int_0 = OpConstant %int 100", "%spec_int_1 = OpConstant %int 1", "%spec_int_2 = OpSpecConstantOp %int IAdd %spec_int_0 %spec_int_1", "%spec_int_3 = OpSpecConstantOp %int ISub %spec_int_0 %spec_int_2", "%spec_int_4 = OpSpecConstantOp %int IAdd %spec_int_0 %spec_int_3", "%spec_int_5 = OpSpecConstantOp %int ISub %spec_int_0 %spec_int_4", "%spec_int_6 = OpSpecConstantOp %int IAdd %spec_int_0 %spec_int_5", "%spec_int_7 = OpSpecConstantOp %int ISub %spec_int_0 %spec_int_6", "%spec_int_8 = OpSpecConstantOp %int IAdd %spec_int_0 %spec_int_7", "%spec_int_9 = OpSpecConstantOp %int ISub %spec_int_0 %spec_int_8", "%spec_int_10 = OpSpecConstantOp %int IAdd %spec_int_0 %spec_int_9", "%spec_int_11 = OpSpecConstantOp %int ISub %spec_int_0 %spec_int_10", "%spec_int_12 = OpSpecConstantOp %int IAdd %spec_int_0 %spec_int_11", "%spec_int_13 = OpSpecConstantOp %int ISub %spec_int_0 %spec_int_12", "%spec_int_14 = OpSpecConstantOp %int IAdd %spec_int_0 %spec_int_13", "%spec_int_15 = OpSpecConstantOp %int ISub %spec_int_0 %spec_int_14", "%spec_int_16 = OpSpecConstantOp %int ISub %spec_int_0 %spec_int_15", "%spec_int_17 = OpSpecConstantOp %int IAdd %spec_int_0 %spec_int_16", "%spec_int_18 = OpSpecConstantOp %int ISub %spec_int_0 %spec_int_17", "%spec_int_19 = OpSpecConstantOp %int IAdd %spec_int_0 %spec_int_18", "%spec_int_20 = OpSpecConstantOp %int ISub %spec_int_0 %spec_int_19", "%used_vec_a = OpSpecConstantComposite %v2int %spec_int_18 %spec_int_19", "%used_vec_b = OpSpecConstantOp %v2int IMul %used_vec_a %used_vec_a", "%spec_int_21 = OpSpecConstantOp %int CompositeExtract %used_vec_b 0", "%array = OpConstantComposite %type_arr_int_4 %spec_int_20 %spec_int_20 %spec_int_21 %spec_int_21", // Spec constants whose values can not be fully resolved should // not be processed. "%spec_int_22 = OpSpecConstant %int 123", "%spec_int_23 = OpSpecConstantOp %int IAdd %spec_int_22 %signed_one", }, // expected { "%array_size = OpConstant %int 4", "%type_arr_int_4 = OpTypeArray %int %array_size", "%spec_int_0 = OpConstant %int 100", "%spec_int_1 = OpConstant %int 1", "%spec_int_2 = OpConstant %int 101", "%spec_int_3 = OpConstant %int -1", "%spec_int_4 = OpConstant %int 99", "%spec_int_5 = OpConstant %int 1", "%spec_int_6 = OpConstant %int 101", "%spec_int_7 = OpConstant %int -1", "%spec_int_8 = OpConstant %int 99", "%spec_int_9 = OpConstant %int 1", "%spec_int_10 = OpConstant %int 101", "%spec_int_11 = OpConstant %int -1", "%spec_int_12 = OpConstant %int 99", "%spec_int_13 = OpConstant %int 1", "%spec_int_14 = OpConstant %int 101", "%spec_int_15 = OpConstant %int -1", "%spec_int_16 = OpConstant %int 101", "%spec_int_17 = OpConstant %int 201", "%spec_int_18 = OpConstant %int -101", "%spec_int_19 = OpConstant %int -1", "%spec_int_20 = OpConstant %int 101", "%used_vec_a = OpConstantComposite %v2int %spec_int_18 %spec_int_19", "%int_10201 = OpConstant %int 10201", "%used_vec_b = OpConstantComposite %v2int %int_10201 %signed_one", "%spec_int_21 = OpConstant %int 10201", "%array = OpConstantComposite %type_arr_int_4 %spec_int_20 %spec_int_20 %spec_int_21 %spec_int_21", "%spec_int_22 = OpSpecConstant %int 123", "%spec_int_23 = OpSpecConstantOp %int IAdd %spec_int_22 %signed_one", }, }, // Long Def-Use chain with swizzle }))); } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/fold_test.cpp000066400000000000000000013401171475742701700230100ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/fold.h" #include #include #include #include #include "effcee/effcee.h" #include "gmock/gmock.h" #include "gtest/gtest.h" #include "source/opt/build_module.h" #include "source/opt/def_use_manager.h" #include "source/opt/ir_context.h" #include "source/opt/module.h" #include "spirv-tools/libspirv.hpp" namespace spvtools { namespace opt { namespace { using ::testing::Contains; std::string Disassemble(const std::string& original, IRContext* context, uint32_t disassemble_options = 0) { std::vector optimized_bin; context->module()->ToBinary(&optimized_bin, true); spv_target_env target_env = SPV_ENV_UNIVERSAL_1_2; SpirvTools tools(target_env); std::string optimized_asm; EXPECT_TRUE( tools.Disassemble(optimized_bin, &optimized_asm, disassemble_options)) << "Disassembling failed for shader:\n" << original << std::endl; return optimized_asm; } void Match(const std::string& original, IRContext* context, uint32_t disassemble_options = 0) { std::string disassembly = Disassemble(original, context, disassemble_options); auto match_result = effcee::Match(disassembly, original); EXPECT_EQ(effcee::Result::Status::Ok, match_result.status()) << match_result.message() << "\nChecking result:\n" << disassembly; } template struct InstructionFoldingCase { InstructionFoldingCase(const std::string& tb, uint32_t id, ResultType result) : test_body(tb), id_to_fold(id), expected_result(result) {} std::string test_body; uint32_t id_to_fold; ResultType expected_result; }; std::tuple, Instruction*> GetInstructionToFold( const std::string test_body, const uint32_t id_to_fold, spv_target_env spv_env) { // Build module. std::unique_ptr context = BuildModule(spv_env, nullptr, test_body, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); EXPECT_NE(nullptr, context); if (context == nullptr) { return {nullptr, nullptr}; } // Fold the instruction to test. if (id_to_fold != 0) { analysis::DefUseManager* def_use_mgr = context->get_def_use_mgr(); Instruction* inst = def_use_mgr->GetDef(id_to_fold); return {std::move(context), inst}; } // If there is not ID, we get the instruction just before a terminator // instruction. That could be a return or abort. This is used for cases where // the instruction we want to fold does not have a result id. Function* func = &*context->module()->begin(); for (auto& bb : *func) { Instruction* terminator = bb.terminator(); if (terminator->IsReturnOrAbort()) { return {std::move(context), terminator->PreviousNode()}; } } return {nullptr, nullptr}; } std::tuple, Instruction*> FoldInstruction( const std::string test_body, const uint32_t id_to_fold, spv_target_env spv_env) { // Build module. std::unique_ptr context; Instruction* inst = nullptr; std::tie(context, inst) = GetInstructionToFold(test_body, id_to_fold, spv_env); if (context == nullptr) { return {nullptr, nullptr}; } std::unique_ptr original_inst(inst->Clone(context.get())); bool succeeded = context->get_instruction_folder().FoldInstruction(inst); EXPECT_EQ(inst->result_id(), original_inst->result_id()); EXPECT_EQ(inst->type_id(), original_inst->type_id()); if (!succeeded && inst != nullptr) { EXPECT_EQ(inst->NumInOperands(), original_inst->NumInOperands()); for (uint32_t i = 0; i < inst->NumInOperands(); ++i) { EXPECT_EQ(inst->GetOperand(i), original_inst->GetOperand(i)); } } return {std::move(context), succeeded ? inst : nullptr}; } template void CheckForExpectedScalarConstant(Instruction* inst, ElementType expected_result, Function GetValue) { ASSERT_TRUE(inst); IRContext* context = inst->context(); analysis::DefUseManager* def_use_mgr = context->get_def_use_mgr(); while (inst->opcode() == spv::Op::OpCopyObject) { inst = def_use_mgr->GetDef(inst->GetSingleWordInOperand(0)); } // Make sure we have a constant. analysis::ConstantManager* const_mrg = context->get_constant_mgr(); const analysis::Constant* constant = const_mrg->GetConstantFromInst(inst); ASSERT_TRUE(constant); // Make sure the constant is a scalar. const analysis::ScalarConstant* result = constant->AsScalarConstant(); ASSERT_TRUE(result); // Check if the result matches the expected value. // If ExpectedType is not a float type, it should cast the value to a double // and never get a nan. if (!std::isnan(static_cast(expected_result))) { EXPECT_EQ(expected_result, GetValue(result)); } else { EXPECT_TRUE(std::isnan(static_cast(GetValue(result)))); } } template void CheckForExpectedVectorConstant(Instruction* inst, std::vector expected_result, Function GetValue) { ASSERT_TRUE(inst); IRContext* context = inst->context(); EXPECT_EQ(inst->opcode(), spv::Op::OpCopyObject); analysis::DefUseManager* def_use_mgr = context->get_def_use_mgr(); inst = def_use_mgr->GetDef(inst->GetSingleWordInOperand(0)); std::vector opcodes = {spv::Op::OpConstantComposite}; EXPECT_THAT(opcodes, Contains(inst->opcode())); analysis::ConstantManager* const_mrg = context->get_constant_mgr(); const analysis::Constant* result = const_mrg->GetConstantFromInst(inst); EXPECT_NE(result, nullptr); if (result != nullptr) { const std::vector& componenets = result->AsVectorConstant()->GetComponents(); EXPECT_EQ(componenets.size(), expected_result.size()); for (size_t i = 0; i < componenets.size(); i++) { EXPECT_EQ(expected_result[i], GetValue(componenets[i])); } } } using IntegerInstructionFoldingTest = ::testing::TestWithParam>; TEST_P(IntegerInstructionFoldingTest, Case) { const auto& tc = GetParam(); std::unique_ptr context; Instruction* inst; std::tie(context, inst) = FoldInstruction(tc.test_body, tc.id_to_fold, SPV_ENV_UNIVERSAL_1_1); CheckForExpectedScalarConstant( inst, tc.expected_result, [](const analysis::Constant* c) { return c->AsScalarConstant()->GetU32BitValue(); }); } // Returns a common SPIR-V header for all of the test that follow. #define INT_0_ID 100 #define TRUE_ID 101 #define VEC2_0_ID 102 #define INT_7_ID 103 #define FLOAT_0_ID 104 #define DOUBLE_0_ID 105 #define VEC4_0_ID 106 #define DVEC4_0_ID 106 #define HALF_0_ID 108 const std::string& Header() { static const std::string header = R"(OpCapability Shader OpCapability Float16 OpCapability Float64 OpCapability Int8 OpCapability Int16 OpCapability Int64 OpCapability CooperativeMatrixKHR OpExtension "SPV_KHR_cooperative_matrix" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" %void = OpTypeVoid %void_func = OpTypeFunction %void %bool = OpTypeBool %float = OpTypeFloat 32 %double = OpTypeFloat 64 %half = OpTypeFloat 16 %101 = OpConstantTrue %bool ; Need a def with an numerical id to define id maps. %true = OpConstantTrue %bool %false = OpConstantFalse %bool %bool_null = OpConstantNull %bool %short = OpTypeInt 16 1 %ushort = OpTypeInt 16 0 %byte = OpTypeInt 8 1 %ubyte = OpTypeInt 8 0 %int = OpTypeInt 32 1 %long = OpTypeInt 64 1 %uint = OpTypeInt 32 0 %ulong = OpTypeInt 64 0 %v2int = OpTypeVector %int 2 %v4int = OpTypeVector %int 4 %v2short = OpTypeVector %short 2 %v2long = OpTypeVector %long 2 %v4long = OpTypeVector %long 4 %v4float = OpTypeVector %float 4 %v4double = OpTypeVector %double 4 %v2uint = OpTypeVector %uint 2 %v2ulong = OpTypeVector %ulong 2 %v2float = OpTypeVector %float 2 %v2double = OpTypeVector %double 2 %v2half = OpTypeVector %half 2 %v2bool = OpTypeVector %bool 2 %m2x2int = OpTypeMatrix %v2int 2 %mat4v2float = OpTypeMatrix %v2float 4 %mat2v4float = OpTypeMatrix %v4float 2 %mat4v4float = OpTypeMatrix %v4float 4 %mat4v4double = OpTypeMatrix %v4double 4 %struct_v2int_int_int = OpTypeStruct %v2int %int %int %_ptr_int = OpTypePointer Function %int %_ptr_uint = OpTypePointer Function %uint %_ptr_bool = OpTypePointer Function %bool %_ptr_float = OpTypePointer Function %float %_ptr_double = OpTypePointer Function %double %_ptr_half = OpTypePointer Function %half %_ptr_long = OpTypePointer Function %long %_ptr_ulong = OpTypePointer Function %ulong %_ptr_v2int = OpTypePointer Function %v2int %_ptr_v4int = OpTypePointer Function %v4int %_ptr_v4float = OpTypePointer Function %v4float %_ptr_v4double = OpTypePointer Function %v4double %_ptr_struct_v2int_int_int = OpTypePointer Function %struct_v2int_int_int %_ptr_v2float = OpTypePointer Function %v2float %_ptr_v2double = OpTypePointer Function %v2double %int_2 = OpConstant %int 2 %int_arr_2 = OpTypeArray %int %int_2 %short_0 = OpConstant %short 0 %short_2 = OpConstant %short 2 %short_3 = OpConstant %short 3 %short_n5 = OpConstant %short -5 %ubyte_1 = OpConstant %ubyte 1 %byte_n1 = OpConstant %byte -1 %100 = OpConstant %int 0 ; Need a def with an numerical id to define id maps. %103 = OpConstant %int 7 ; Need a def with an numerical id to define id maps. %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %int_3 = OpConstant %int 3 %int_4 = OpConstant %int 4 %int_10 = OpConstant %int 10 %int_1073741824 = OpConstant %int 1073741824 %int_n1 = OpConstant %int -1 %int_n24 = OpConstant %int -24 %int_n858993459 = OpConstant %int -858993459 %int_min = OpConstant %int -2147483648 %int_max = OpConstant %int 2147483647 %long_0 = OpConstant %long 0 %long_1 = OpConstant %long 1 %long_2 = OpConstant %long 2 %long_3 = OpConstant %long 3 %long_n3 = OpConstant %long -3 %long_7 = OpConstant %long 7 %long_n7 = OpConstant %long -7 %long_10 = OpConstant %long 10 %long_32768 = OpConstant %long 32768 %long_n57344 = OpConstant %long -57344 %long_n4611686018427387904 = OpConstant %long -4611686018427387904 %long_4611686018427387904 = OpConstant %long 4611686018427387904 %long_n1 = OpConstant %long -1 %long_n3689348814741910323 = OpConstant %long -3689348814741910323 %long_min = OpConstant %long -9223372036854775808 %long_max = OpConstant %long 9223372036854775807 %ulong_7 = OpConstant %ulong 7 %ulong_4611686018427387904 = OpConstant %ulong 4611686018427387904 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %uint_3 = OpConstant %uint 3 %uint_4 = OpConstant %uint 4 %uint_32 = OpConstant %uint 32 %uint_42 = OpConstant %uint 42 %uint_2147483649 = OpConstant %uint 2147483649 %uint_max = OpConstant %uint 4294967295 %ulong_0 = OpConstant %ulong 0 %ulong_1 = OpConstant %ulong 1 %ulong_2 = OpConstant %ulong 2 %ulong_9223372036854775809 = OpConstant %ulong 9223372036854775809 %ulong_max = OpConstant %ulong 18446744073709551615 %v2int_undef = OpUndef %v2int %v2int_0_0 = OpConstantComposite %v2int %int_0 %int_0 %v2int_1_0 = OpConstantComposite %v2int %int_1 %int_0 %v2int_2_2 = OpConstantComposite %v2int %int_2 %int_2 %v2int_2_3 = OpConstantComposite %v2int %int_2 %int_3 %v2int_3_2 = OpConstantComposite %v2int %int_3 %int_2 %v2int_n1_n24 = OpConstantComposite %v2int %int_n1 %int_n24 %v2int_4_4 = OpConstantComposite %v2int %int_4 %int_4 %v2int_min_max = OpConstantComposite %v2int %int_min %int_max %v2short_2_n5 = OpConstantComposite %v2short %short_2 %short_n5 %v2long_2_2 = OpConstantComposite %v2long %long_2 %long_2 %v2long_2_3 = OpConstantComposite %v2long %long_2 %long_3 %v2bool_null = OpConstantNull %v2bool %v2bool_true_false = OpConstantComposite %v2bool %true %false %v2bool_false_true = OpConstantComposite %v2bool %false %true %struct_v2int_int_int_null = OpConstantNull %struct_v2int_int_int %v2int_null = OpConstantNull %v2int %102 = OpConstantComposite %v2int %103 %103 %v4int_undef = OpUndef %v4int %v4int_0_0_0_0 = OpConstantComposite %v4int %int_0 %int_0 %int_0 %int_0 %m2x2int_undef = OpUndef %m2x2int %struct_undef_0_0 = OpConstantComposite %struct_v2int_int_int %v2int_undef %int_0 %int_0 %float_n1 = OpConstant %float -1 %104 = OpConstant %float 0 ; Need a def with an numerical id to define id maps. %float_null = OpConstantNull %float %float_0 = OpConstant %float 0 %float_n0 = OpConstant %float -0.0 %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %float_3 = OpConstant %float 3 %float_4 = OpConstant %float 4 %float_2049 = OpConstant %float 2049 %float_n2049 = OpConstant %float -2049 %float_0p5 = OpConstant %float 0.5 %float_0p2 = OpConstant %float 0.2 %float_pi = OpConstant %float 1.5555 %float_1e16 = OpConstant %float 1e16 %float_n1e16 = OpConstant %float -1e16 %float_1en16 = OpConstant %float 1e-16 %float_n1en16 = OpConstant %float -1e-16 %v2float_0_0 = OpConstantComposite %v2float %float_0 %float_0 %v2float_2_2 = OpConstantComposite %v2float %float_2 %float_2 %v2float_2_3 = OpConstantComposite %v2float %float_2 %float_3 %v2float_3_2 = OpConstantComposite %v2float %float_3 %float_2 %v2float_4_4 = OpConstantComposite %v2float %float_4 %float_4 %v2float_2_0p5 = OpConstantComposite %v2float %float_2 %float_0p5 %v2float_0p2_0p5 = OpConstantComposite %v2float %float_0p2 %float_0p5 %v2float_null = OpConstantNull %v2float %double_n1 = OpConstant %double -1 %105 = OpConstant %double 0 ; Need a def with an numerical id to define id maps. %double_null = OpConstantNull %double %double_0 = OpConstant %double 0 %double_n0 = OpConstant %double -0.0 %double_1 = OpConstant %double 1 %double_2 = OpConstant %double 2 %double_3 = OpConstant %double 3 %double_4 = OpConstant %double 4 %double_5 = OpConstant %double 5 %double_0p5 = OpConstant %double 0.5 %double_0p2 = OpConstant %double 0.2 %v2double_0_0 = OpConstantComposite %v2double %double_0 %double_0 %v2double_2_2 = OpConstantComposite %v2double %double_2 %double_2 %v2double_2_3 = OpConstantComposite %v2double %double_2 %double_3 %v2double_3_2 = OpConstantComposite %v2double %double_3 %double_2 %v2double_4_4 = OpConstantComposite %v2double %double_4 %double_4 %v2double_2_0p5 = OpConstantComposite %v2double %double_2 %double_0p5 %v2double_null = OpConstantNull %v2double %108 = OpConstant %half 0 %half_1 = OpConstant %half 1 %half_2 = OpConstant %half 2 %half_0_1 = OpConstantComposite %v2half %108 %half_1 %106 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %v4float_0_0_0_0 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %v4float_0_0_0_1 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_1 %v4float_0_1_0_0 = OpConstantComposite %v4float %float_0 %float_1 %float_null %float_0 %v4float_1_1_1_1 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %v4float_1_2_3_4 = OpConstantComposite %v4float %float_1 %float_2 %float_3 %float_4 %v4float_null = OpConstantNull %v4float %mat2v4float_null = OpConstantNull %mat2v4float %mat4v4float_null = OpConstantNull %mat4v4float %mat4v4float_1_2_3_4 = OpConstantComposite %mat4v4float %v4float_1_2_3_4 %v4float_1_2_3_4 %v4float_1_2_3_4 %v4float_1_2_3_4 %mat4v4float_1_2_3_4_null = OpConstantComposite %mat4v4float %v4float_1_2_3_4 %v4float_null %v4float_1_2_3_4 %v4float_null %107 = OpConstantComposite %v4double %double_0 %double_0 %double_0 %double_0 %v4double_0_0_0_0 = OpConstantComposite %v4double %double_0 %double_0 %double_0 %double_0 %v4double_0_0_0_1 = OpConstantComposite %v4double %double_0 %double_0 %double_0 %double_1 %v4double_0_1_0_0 = OpConstantComposite %v4double %double_0 %double_1 %double_null %double_0 %v4double_1_1_1_1 = OpConstantComposite %v4double %double_1 %double_1 %double_1 %double_1 %v4double_1_2_3_4 = OpConstantComposite %v4double %double_1 %double_2 %double_3 %double_4 %v4double_1_1_1_0p5 = OpConstantComposite %v4double %double_1 %double_1 %double_1 %double_0p5 %v4double_null = OpConstantNull %v4double %mat4v4double_null = OpConstantNull %mat4v4double %mat4v4double_1_2_3_4 = OpConstantComposite %mat4v4double %v4double_1_2_3_4 %v4double_1_2_3_4 %v4double_1_2_3_4 %v4double_1_2_3_4 %mat4v4double_1_2_3_4_null = OpConstantComposite %mat4v4double %v4double_1_2_3_4 %v4double_null %v4double_1_2_3_4 %v4double_null %v4float_n1_2_1_3 = OpConstantComposite %v4float %float_n1 %float_2 %float_1 %float_3 %uint_0x3f800000 = OpConstant %uint 0x3f800000 %uint_0xbf800000 = OpConstant %uint 0xbf800000 %v2uint_0x3f800000_0xbf800000 = OpConstantComposite %v2uint %uint_0x3f800000 %uint_0xbf800000 %long_0xbf8000003f800000 = OpConstant %long 0xbf8000003f800000 %int_0x3FF00000 = OpConstant %int 0x3FF00000 %int_0x00000000 = OpConstant %int 0x00000000 %int_0xC05FD666 = OpConstant %int 0xC05FD666 %int_0x66666666 = OpConstant %int 0x66666666 %v4int_0x3FF00000_0x00000000_0xC05FD666_0x66666666 = OpConstantComposite %v4int %int_0x00000000 %int_0x3FF00000 %int_0x66666666 %int_0xC05FD666 %ushort_0x4400 = OpConstant %ushort 0x4400 %short_0x4400 = OpConstant %short 0x4400 %ushort_0xBC00 = OpConstant %ushort 0xBC00 %short_0xBC00 = OpConstant %short 0xBC00 %int_arr_2_undef = OpUndef %int_arr_2 %int_coop_matrix = OpTypeCooperativeMatrixKHR %int %uint_3 %uint_3 %uint_32 %uint_0 %undef_int_coop_matrix = OpUndef %int_coop_matrix %uint_coop_matrix = OpTypeCooperativeMatrixKHR %uint %uint_3 %uint_3 %uint_32 %uint_0 %undef_uint_coop_matrix = OpUndef %uint_coop_matrix %float_coop_matrix = OpTypeCooperativeMatrixKHR %float %uint_3 %uint_3 %uint_32 %uint_0 %undef_float_coop_matrix = OpUndef %float_coop_matrix )"; return header; } // Returns the header with definitions of float NaN and double NaN. Since FC // "; CHECK: [[double_n0:%\\w+]] = OpConstant [[double]] -0\n" finds // %double_nan = OpConstant %double -0x1.8p+1024 instead of // %double_n0 = OpConstant %double -0, // we separates those definitions from Header(). const std::string& HeaderWithNaN() { static const std::string headerWithNaN = Header() + R"(%float_nan = OpConstant %float -0x1.8p+128 %double_nan = OpConstant %double -0x1.8p+1024 )"; return headerWithNaN; } // clang-format off INSTANTIATE_TEST_SUITE_P(TestCase, IntegerInstructionFoldingTest, ::testing::Values( // Test case 0: fold 0*n InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpIMul %int %int_0 %load\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 1: fold n*0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpIMul %int %load %int_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 2: fold 0/n (signed) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpSDiv %int %int_0 %load\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 3: fold n/0 (signed) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpSDiv %int %load %int_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 4: fold 0/n (unsigned) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%load = OpLoad %uint %n\n" + "%2 = OpUDiv %uint %uint_0 %load\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 5: fold n/0 (unsigned) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpSDiv %int %load %int_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 6: fold 0 remainder n InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpSRem %int %int_0 %load\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 7: fold n remainder 0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpSRem %int %load %int_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 8: fold 0%n (signed) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpSMod %int %int_0 %load\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 9: fold n%0 (signed) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpSMod %int %load %int_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 10: fold 0%n (unsigned) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%load = OpLoad %uint %n\n" + "%2 = OpUMod %uint %uint_0 %load\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 11: fold n%0 (unsigned) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%load = OpLoad %uint %n\n" + "%2 = OpUMod %uint %load %uint_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 12: fold n << 32 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%load = OpLoad %uint %n\n" + "%2 = OpShiftLeftLogical %uint %load %uint_32\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 13: fold n >> 32 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%load = OpLoad %uint %n\n" + "%2 = OpShiftRightLogical %uint %load %uint_32\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 14: fold n | 0xFFFFFFFF InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%load = OpLoad %uint %n\n" + "%2 = OpBitwiseOr %uint %load %uint_max\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0xFFFFFFFF), // Test case 15: fold 0xFFFFFFFF | n InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%load = OpLoad %uint %n\n" + "%2 = OpBitwiseOr %uint %uint_max %load\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0xFFFFFFFF), // Test case 16: fold n & 0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%load = OpLoad %uint %n\n" + "%2 = OpBitwiseAnd %uint %load %uint_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 17: fold 1/0 (signed) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpSDiv %int %int_1 %int_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 18: fold 1/0 (unsigned) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpUDiv %uint %uint_1 %uint_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 19: fold OpSRem 1 0 (signed) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpSRem %int %int_1 %int_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 20: fold 1%0 (signed) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpSMod %int %int_1 %int_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 21: fold 1%0 (unsigned) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpUMod %uint %uint_1 %uint_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 22: fold unsigned n >> 42 (undefined, so set to zero). InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%load = OpLoad %uint %n\n" + "%2 = OpShiftRightLogical %uint %load %uint_42\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 23: fold signed n >> 42 (undefined, so set to zero). InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpShiftRightLogical %int %load %uint_42\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 24: fold n << 42 (undefined, so set to zero). InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpShiftLeftLogical %int %load %uint_42\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 25: fold -24 >> 32 (defined as -1) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpShiftRightArithmetic %int %int_n24 %uint_32\n" + "OpReturn\n" + "OpFunctionEnd", 2, -1), // Test case 26: fold 2 >> 32 (signed) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpShiftRightArithmetic %int %int_2 %uint_32\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 27: fold 2 >> 32 (unsigned) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpShiftRightLogical %int %int_2 %uint_32\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 28: fold 2 << 32 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpShiftLeftLogical %int %int_2 %uint_32\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 29: fold -INT_MIN InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpSNegate %int %int_min\n" + "OpReturn\n" + "OpFunctionEnd", 2, std::numeric_limits::min()), // Test case 30: fold UMin 3 4 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %uint %1 UMin %uint_3 %uint_4\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3), // Test case 31: fold UMin 4 2 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %uint %1 UMin %uint_4 %uint_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, 2), // Test case 32: fold SMin 3 4 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %int %1 UMin %int_3 %int_4\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3), // Test case 33: fold SMin 4 2 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %int %1 SMin %int_4 %int_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, 2), // Test case 34: fold UMax 3 4 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %uint %1 UMax %uint_3 %uint_4\n" + "OpReturn\n" + "OpFunctionEnd", 2, 4), // Test case 35: fold UMax 3 2 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %uint %1 UMax %uint_3 %uint_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3), // Test case 36: fold SMax 3 4 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %int %1 UMax %int_3 %int_4\n" + "OpReturn\n" + "OpFunctionEnd", 2, 4), // Test case 37: fold SMax 3 2 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %int %1 SMax %int_3 %int_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3), // Test case 38: fold UClamp 2 3 4 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %uint %1 UClamp %uint_2 %uint_3 %uint_4\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3), // Test case 39: fold UClamp 2 0 4 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %uint %1 UClamp %uint_2 %uint_0 %uint_4\n" + "OpReturn\n" + "OpFunctionEnd", 2, 2), // Test case 40: fold UClamp 2 0 1 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %uint %1 UClamp %uint_2 %uint_0 %uint_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, 1), // Test case 41: fold SClamp 2 3 4 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %int %1 SClamp %int_2 %int_3 %int_4\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3), // Test case 42: fold SClamp 2 0 4 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %int %1 SClamp %int_2 %int_0 %int_4\n" + "OpReturn\n" + "OpFunctionEnd", 2, 2), // Test case 43: fold SClamp 2 0 1 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %int %1 SClamp %int_2 %int_0 %int_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, 1), // Test case 44: SClamp 1 2 x InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%undef = OpUndef %int\n" + "%2 = OpExtInst %int %1 SClamp %int_1 %int_2 %undef\n" + "OpReturn\n" + "OpFunctionEnd", 2, 2), // Test case 45: SClamp 2 x 1 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%undef = OpUndef %int\n" + "%2 = OpExtInst %int %1 SClamp %int_2 %undef %int_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, 1), // Test case 46: UClamp 1 2 x InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%undef = OpUndef %uint\n" + "%2 = OpExtInst %uint %1 UClamp %uint_1 %uint_2 %undef\n" + "OpReturn\n" + "OpFunctionEnd", 2, 2), // Test case 47: UClamp 2 x 1 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%undef = OpUndef %uint\n" + "%2 = OpExtInst %uint %1 UClamp %uint_2 %undef %uint_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, 1), // Test case 48: Bit-cast int 0 to unsigned int InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpBitcast %uint %int_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 49: Bit-cast int -24 to unsigned int InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpBitcast %uint %int_n24\n" + "OpReturn\n" + "OpFunctionEnd", 2, static_cast(-24)), // Test case 50: Bit-cast float 1.0f to unsigned int InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpBitcast %uint %float_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, static_cast(0x3f800000)), // Test case 51: Bit-cast ushort 0xBC00 to ushort InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpBitcast %ushort %ushort_0xBC00\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0xBC00), // Test case 52: Bit-cast short 0xBC00 to ushort InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpBitcast %ushort %short_0xBC00\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0xBC00), // Test case 53: Bit-cast half 1 to ushort InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpBitcast %ushort %half_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0x3C00), // Test case 54: Bit-cast ushort 0xBC00 to short InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpBitcast %short %ushort_0xBC00\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0xFFFFBC00), // Test case 55: Bit-cast short 0xBC00 to short InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpBitcast %short %short_0xBC00\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0xFFFFBC00), // Test case 56: Bit-cast half 1 to short InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpBitcast %short %half_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0x3C00), // Test case 57: Bit-cast ushort 0xBC00 to half InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpBitcast %half %ushort_0xBC00\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0xBC00), // Test case 58: Bit-cast short 0xBC00 to half InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpBitcast %half %short_0xBC00\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0xFFFFBC00), // Test case 59: Bit-cast half 1 to half InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpBitcast %half %half_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0x3C00), // Test case 60: Bit-cast ubyte 1 to byte InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpBitcast %byte %ubyte_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, 1), // Test case 61: Bit-cast byte -1 to ubyte InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpBitcast %ubyte %byte_n1\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0xFF), // Test case 62: Negate 2. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpSNegate %int %int_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, -2), // Test case 63: Negate negative short. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpSNegate %short %short_0xBC00\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0x4400 /* expected to be sign extended. */), // Test case 64: Negate positive short. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpSNegate %short %short_0x4400\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0xFFFFBC00 /* expected to be sign extended. */), // Test case 65: Negate a negative short. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpSNegate %ushort %ushort_0xBC00\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0x4400 /* expected to be zero extended. */), // Test case 66: Negate positive short. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpSNegate %ushort %ushort_0x4400\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0xBC00 /* expected to be zero extended. */), // Test case 67: Fold 2 + 3 (short) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpIAdd %short %short_2 %short_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 5), // Test case 68: Fold 2 + -5 (short) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpIAdd %short %short_2 %short_n5\n" + "OpReturn\n" + "OpFunctionEnd", 2, -3), // Test case 69: Fold int(3ll) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpSConvert %int %long_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3), // Test case 70: Fold short(-3ll) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpSConvert %short %long_n3\n" + "OpReturn\n" + "OpFunctionEnd", 2, -3), // Test case 71: Fold short(32768ll) - This should do a sign extend when // converting to short. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpSConvert %short %long_32768\n" + "OpReturn\n" + "OpFunctionEnd", 2, -32768), // Test case 72: Fold short(-57344) - This should do a sign extend when // converting to short making the upper bits 0. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpSConvert %short %long_n57344\n" + "OpReturn\n" + "OpFunctionEnd", 2, 8192), // Test case 73: Fold int(-5(short)). The -5 should be interpreted as an unsigned value, and be zero extended to 32-bits. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpUConvert %uint %short_n5\n" + "OpReturn\n" + "OpFunctionEnd", 2, 65531), // Test case 74: Fold short(-24(int)). The upper bits should be cleared. So 0xFFFFFFE8 should become 0x0000FFE8. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpUConvert %ushort %int_n24\n" + "OpReturn\n" + "OpFunctionEnd", 2, 65512) )); // clang-format on using LongIntegerInstructionFoldingTest = ::testing::TestWithParam>; TEST_P(LongIntegerInstructionFoldingTest, Case) { const auto& tc = GetParam(); std::unique_ptr context; Instruction* inst; std::tie(context, inst) = FoldInstruction(tc.test_body, tc.id_to_fold, SPV_ENV_UNIVERSAL_1_1); CheckForExpectedScalarConstant( inst, tc.expected_result, [](const analysis::Constant* c) { return c->AsScalarConstant()->GetU64BitValue(); }); } INSTANTIATE_TEST_SUITE_P( TestCase, LongIntegerInstructionFoldingTest, ::testing::Values( // Test case 0: fold 1+4611686018427387904 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpIAdd %long %long_1 %long_4611686018427387904\n" + "OpReturn\n" + "OpFunctionEnd", 2, 1 + 4611686018427387904), // Test case 1: fold 1-4611686018427387904 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpISub %long %long_1 %long_4611686018427387904\n" + "OpReturn\n" + "OpFunctionEnd", 2, 1 - 4611686018427387904), // Test case 2: fold 2*4611686018427387904 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpIMul %long %long_2 %long_4611686018427387904\n" + "OpReturn\n" + "OpFunctionEnd", 2, 9223372036854775808ull), // Test case 3: fold 4611686018427387904/2 (unsigned) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpUDiv %ulong %ulong_4611686018427387904 %ulong_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, 4611686018427387904 / 2), // Test case 4: fold 4611686018427387904/2 (signed) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpSDiv %long %long_4611686018427387904 %long_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, 4611686018427387904 / 2), // Test case 5: fold -4611686018427387904/2 (signed) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpSDiv %long %long_n4611686018427387904 %long_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, -4611686018427387904 / 2), // Test case 6: fold 4611686018427387904 mod 7 (unsigned) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpUMod %ulong %ulong_4611686018427387904 %ulong_7\n" + "OpReturn\n" + "OpFunctionEnd", 2, 4611686018427387904ull % 7ull), // Test case 7: fold 7 mod 3 (signed) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpSMod %long %long_7 %long_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 1ull), // Test case 8: fold 7 rem 3 (signed) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpSRem %long %long_7 %long_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 1ull), // Test case 9: fold 7 mod -3 (signed) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpSMod %long %long_7 %long_n3\n" + "OpReturn\n" + "OpFunctionEnd", 2, -2ll), // Test case 10: fold 7 rem 3 (signed) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpSRem %long %long_7 %long_n3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 1ll), // Test case 11: fold -7 mod 3 (signed) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpSMod %long %long_n7 %long_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 2ll), // Test case 12: fold -7 rem 3 (signed) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpSRem %long %long_n7 %long_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, -1ll), // Test case 13: fold long(-24) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpSConvert %long %int_n24\n" + "OpReturn\n" + "OpFunctionEnd", 2, -24ll), // Test case 14: fold long(-24) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpSConvert %long %int_10\n" + "OpReturn\n" + "OpFunctionEnd", 2, 10ll), // Test case 15: fold long(-24(short)). // The upper bits should be cleared. So 0xFFFFFFE8 should become // 0x000000000000FFE8. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpUConvert %ulong %short_n5\n" + "OpReturn\n" + "OpFunctionEnd", 2, 65531ull))); using UIntVectorInstructionFoldingTest = ::testing::TestWithParam>>; TEST_P(UIntVectorInstructionFoldingTest, Case) { const auto& tc = GetParam(); std::unique_ptr context; Instruction* inst; std::tie(context, inst) = FoldInstruction(tc.test_body, tc.id_to_fold, SPV_ENV_UNIVERSAL_1_1); CheckForExpectedVectorConstant( inst, tc.expected_result, [](const analysis::Constant* c) { return c->GetU32(); }); } // clang-format off INSTANTIATE_TEST_SUITE_P(TestCase, UIntVectorInstructionFoldingTest, ::testing::Values( // Test case 0: fold 0*n InstructionFoldingCase>( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpVectorShuffle %v2int %v2int_2_2 %v2int_2_3 0 3\n" + "OpReturn\n" + "OpFunctionEnd", 2, {2,3}), InstructionFoldingCase>( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpVectorShuffle %v2int %v2int_null %v2int_2_3 0 3\n" + "OpReturn\n" + "OpFunctionEnd", 2, {0,3}), // Test case 4: fold bit-cast int -24 to unsigned int InstructionFoldingCase>( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpBitcast %v2uint %v2int_min_max\n" + "OpReturn\n" + "OpFunctionEnd", 2, {2147483648, 2147483647}), // Test case 5: fold SNegate vector of uint InstructionFoldingCase>( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpSNegate %v2uint %v2uint_0x3f800000_0xbf800000\n" + "OpReturn\n" + "OpFunctionEnd", 2, {static_cast(-0x3f800000), static_cast(-0xbf800000)}), // Test case 6: fold vector components of uint (including integer overflow) InstructionFoldingCase>( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpIAdd %v2uint %v2uint_0x3f800000_0xbf800000 %v2uint_0x3f800000_0xbf800000\n" + "OpReturn\n" + "OpFunctionEnd", 2, {0x7f000000u, 0x7f000000u}), // Test case 6: fold vector components of uint InstructionFoldingCase>( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpSConvert %v2int %v2short_2_n5\n" + "OpReturn\n" + "OpFunctionEnd", 2, {2,static_cast(-5)}), // Test case 6: fold vector components of uint (incuding integer overflow) InstructionFoldingCase>( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpUConvert %v2uint %v2short_2_n5\n" + "OpReturn\n" + "OpFunctionEnd", 2, {2,65531}) )); // clang-format on using IntVectorInstructionFoldingTest = ::testing::TestWithParam>>; TEST_P(IntVectorInstructionFoldingTest, Case) { const auto& tc = GetParam(); std::unique_ptr context; Instruction* inst; std::tie(context, inst) = FoldInstruction(tc.test_body, tc.id_to_fold, SPV_ENV_UNIVERSAL_1_1); CheckForExpectedVectorConstant( inst, tc.expected_result, [](const analysis::Constant* c) { return c->GetS32(); }); } // clang-format off INSTANTIATE_TEST_SUITE_P(TestCase, IntVectorInstructionFoldingTest, ::testing::Values( // Test case 0: fold negate of a vector InstructionFoldingCase>( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpSNegate %v2int %v2int_2_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, {-2, -3}), // Test case 1: fold negate of a vector containing negative values. InstructionFoldingCase>( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpSNegate %v2int %v2int_n1_n24\n" + "OpReturn\n" + "OpFunctionEnd", 2, {1, 24}), // Test case 2: fold negate of a vector at the limits InstructionFoldingCase>( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpSNegate %v2int %v2int_min_max\n" + "OpReturn\n" + "OpFunctionEnd", 2, {INT_MIN, -INT_MAX}), // Test case 3: fold vector components of int InstructionFoldingCase>( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpIMul %v2int %v2int_2_3 %v2int_2_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, {4,9}) )); // clang-format on using LongIntVectorInstructionFoldingTest = ::testing::TestWithParam>>; TEST_P(LongIntVectorInstructionFoldingTest, Case) { const auto& tc = GetParam(); std::unique_ptr context; Instruction* inst; std::tie(context, inst) = FoldInstruction(tc.test_body, tc.id_to_fold, SPV_ENV_UNIVERSAL_1_1); CheckForExpectedVectorConstant( inst, tc.expected_result, [](const analysis::Constant* c) { return c->GetU64(); }); } // clang-format off INSTANTIATE_TEST_SUITE_P(TestCase, LongIntVectorInstructionFoldingTest, ::testing::Values( // Test case 0: fold {2,2} + {2,3} (Testing that the vector logic works // correctly. Scalar tests will check that the 64-bit values are correctly // folded.) InstructionFoldingCase>( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpIAdd %v2long %v2long_2_2 %v2long_2_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, {4,5}), // Test case 0: fold {2,2} / {2,3} (Testing that the vector logic works // correctly. Scalar tests will check that the 64-bit values are correctly // folded.) InstructionFoldingCase>( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpSDiv %v2long %v2long_2_2 %v2long_2_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, {1,0}) )); // clang-format on using DoubleVectorInstructionFoldingTest = ::testing::TestWithParam>>; TEST_P(DoubleVectorInstructionFoldingTest, Case) { const auto& tc = GetParam(); std::unique_ptr context; Instruction* inst; std::tie(context, inst) = FoldInstruction(tc.test_body, tc.id_to_fold, SPV_ENV_UNIVERSAL_1_1); CheckForExpectedVectorConstant( inst, tc.expected_result, [](const analysis::Constant* c) { return c->GetDouble(); }); } // clang-format off INSTANTIATE_TEST_SUITE_P(TestCase, DoubleVectorInstructionFoldingTest, ::testing::Values( // Test case 0: bit-cast int {0x3FF00000,0x00000000,0xC05FD666,0x66666666} // to double vector InstructionFoldingCase>( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpBitcast %v2double %v4int_0x3FF00000_0x00000000_0xC05FD666_0x66666666\n" + "OpReturn\n" + "OpFunctionEnd", 2, {1.0,-127.35}), // Test case 1: OpVectorTimesMatrix Non-Zero Zero {{0.0, 0.0, 0.0, 0.0}, {0.0, 0.0, 0.0, 0.0}, {0.0, 0.0, 0.0, 0.0}, {0.0, 0.0, 0.0, 0.0}} {1.0, 2.0, 3.0, 4.0} {0.0, 0.0, 0.0, 0.0} InstructionFoldingCase>( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpVectorTimesMatrix %v4double %v4double_1_2_3_4 %mat4v4double_null\n" + "OpReturn\n" + "OpFunctionEnd", 2, {0.0,0.0,0.0,0.0}), // Test case 2: OpVectorTimesMatrix Zero Non-Zero {{1.0, 2.0, 3.0, 4.0}, {1.0, 2.0, 3.0, 4.0}, {1.0, 2.0, 3.0, 4.0}, {1.0, 2.0, 3.0, 4.0}} {0.0, 0.0, 0.0, 0.0} {0.0, 0.0, 0.0, 0.0} InstructionFoldingCase>( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpVectorTimesMatrix %v4double %v4double_null %mat4v4double_1_2_3_4\n" + "OpReturn\n" + "OpFunctionEnd", 2, {0.0,0.0,0.0,0.0}), // Test case 3: OpVectorTimesMatrix Non-Zero Non-Zero {{1.0, 2.0, 3.0, 4.0}, {1.0, 2.0, 3.0, 4.0}, {1.0, 2.0, 3.0, 4.0}, {1.0, 2.0, 3.0, 4.0}} {1.0, 2.0, 3.0, 4.0} {30.0, 30.0, 30.0, 30.0} InstructionFoldingCase>( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpVectorTimesMatrix %v4double %v4double_1_2_3_4 %mat4v4double_1_2_3_4\n" + "OpReturn\n" + "OpFunctionEnd", 2, {30.0,30.0,30.0,30.0}), // Test case 4: OpVectorTimesMatrix Non-Zero Non-Zero {{1.0, 2.0, 3.0, 4.0}, Null, {1.0, 2.0, 3.0, 4.0}, Null} {1.0, 2.0, 3.0, 4.0} {30.0, 0.0, 30.0, 0.0} InstructionFoldingCase>( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpVectorTimesMatrix %v4double %v4double_1_2_3_4 %mat4v4double_1_2_3_4_null\n" + "OpReturn\n" + "OpFunctionEnd", 2, {30.0,0.0,30.0,0.0}), // Test case 5: OpMatrixTimesVector Zero Non-Zero {1.0, 2.0, 3.0, 4.0} {{0.0, 0.0, 0.0, 0.0}, {0.0, 0.0, 0.0, 0.0}, {0.0, 0.0, 0.0, 0.0}, {0.0, 0.0, 0.0, 0.0}} {0.0, 0.0, 0.0, 0.0} InstructionFoldingCase>( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpMatrixTimesVector %v4double %mat4v4double_null %v4double_1_2_3_4\n" + "OpReturn\n" + "OpFunctionEnd", 2, {0.0,0.0,0.0,0.0}), // Test case 6: OpMatrixTimesVector Non-Zero Zero {{1.0, 2.0, 3.0, 4.0}, {1.0, 2.0, 3.0, 4.0}, {1.0, 2.0, 3.0, 4.0}, {1.0, 2.0, 3.0, 4.0}} {0.0, 0.0, 0.0, 0.0} {0.0, 0.0, 0.0, 0.0} InstructionFoldingCase>( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpMatrixTimesVector %v4double %mat4v4double_1_2_3_4 %v4double_null\n" + "OpReturn\n" + "OpFunctionEnd", 2, {0.0,0.0,0.0,0.0}), // Test case 7: OpMatrixTimesVector Non-Zero Non-Zero {1.0, 2.0, 3.0, 4.0} {{1.0, 2.0, 3.0, 4.0}, {1.0, 2.0, 3.0, 4.0}, {1.0, 2.0, 3.0, 4.0}, {1.0, 2.0, 3.0, 4.0}} {10.0, 20.0, 30.0, 40.0} InstructionFoldingCase>( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpMatrixTimesVector %v4double %mat4v4double_1_2_3_4 %v4double_1_2_3_4\n" + "OpReturn\n" + "OpFunctionEnd", 2, {10.0,20.0,30.0,40.0}), // Test case 8: OpMatrixTimesVector Non-Zero Non-Zero {1.0, 2.0, 3.0, 4.0} {{1.0, 2.0, 3.0, 4.0}, Null, {1.0, 2.0, 3.0, 4.0}, Null} {10.0, 20.0, 30.0, 40.0} InstructionFoldingCase>( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpMatrixTimesVector %v4double %mat4v4double_1_2_3_4_null %v4double_1_2_3_4\n" + "OpReturn\n" + "OpFunctionEnd", 2, {4.0,8.0,12.0,16.0}) )); using FloatVectorInstructionFoldingTest = ::testing::TestWithParam>>; TEST_P(FloatVectorInstructionFoldingTest, Case) { const auto& tc = GetParam(); std::unique_ptr context; Instruction* inst; std::tie(context, inst) = FoldInstruction(tc.test_body, tc.id_to_fold,SPV_ENV_UNIVERSAL_1_1); CheckForExpectedVectorConstant(inst, tc.expected_result, [](const analysis::Constant* c){ return c->GetFloat();}); } // clang-format off INSTANTIATE_TEST_SUITE_P(TestCase, FloatVectorInstructionFoldingTest, ::testing::Values( // Test case 0: FMix {2.0, 2.0}, {2.0, 3.0} {0.2,0.5} InstructionFoldingCase>( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %v2float %1 FMix %v2float_2_3 %v2float_0_0 %v2float_0p2_0p5\n" + "OpReturn\n" + "OpFunctionEnd", 2, {1.6f,1.5f}), // Test case 1: bit-cast unsigned int vector {0x3f800000, 0xbf800000} to // float vector InstructionFoldingCase>( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpBitcast %v2float %v2uint_0x3f800000_0xbf800000\n" + "OpReturn\n" + "OpFunctionEnd", 2, {1.0f,-1.0f}), // Test case 2: bit-cast long int 0xbf8000003f800000 to float vector InstructionFoldingCase>( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpBitcast %v2float %long_0xbf8000003f800000\n" + "OpReturn\n" + "OpFunctionEnd", 2, {1.0f,-1.0f}), // Test case 3: OpVectorTimesMatrix Non-Zero Zero {{0.0, 0.0, 0.0, 0.0}, {0.0, 0.0, 0.0, 0.0}, {0.0, 0.0, 0.0, 0.0}, {0.0, 0.0, 0.0, 0.0}} {1.0, 2.0, 3.0, 4.0} {0.0, 0.0, 0.0, 0.0} InstructionFoldingCase>( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpVectorTimesMatrix %v4float %v4float_1_2_3_4 %mat4v4float_null\n" + "OpReturn\n" + "OpFunctionEnd", 2, {0.0f,0.0f,0.0f,0.0f}), // Test case 4: OpVectorTimesMatrix Non-Zero Non-Zero {{1.0, 2.0, 3.0, 4.0}, Null, {1.0, 2.0, 3.0, 4.0}, Null} {1.0, 2.0, 3.0, 4.0} {30.0, 0.0, 30.0, 0.0} InstructionFoldingCase>( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpVectorTimesMatrix %v4float %v4float_1_2_3_4 %mat4v4float_1_2_3_4_null\n" + "OpReturn\n" + "OpFunctionEnd", 2, {30.0,0.0,30.0,0.0}), // Test case 5: OpVectorTimesMatrix Zero Non-Zero {{1.0, 2.0, 3.0, 4.0}, {1.0, 2.0, 3.0, 4.0}, {1.0, 2.0, 3.0, 4.0}, {1.0, 2.0, 3.0, 4.0}} {0.0, 0.0, 0.0, 0.0} {0.0, 0.0, 0.0, 0.0} InstructionFoldingCase>( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpVectorTimesMatrix %v4float %v4float_null %mat4v4float_1_2_3_4\n" + "OpReturn\n" + "OpFunctionEnd", 2, {0.0f,0.0f,0.0f,0.0f}), // Test case 6: OpVectorTimesMatrix Non-Zero Non-Zero {{1.0, 2.0, 3.0, 4.0}, {1.0, 2.0, 3.0, 4.0}, {1.0, 2.0, 3.0, 4.0}, {1.0, 2.0, 3.0, 4.0}} {1.0, 2.0, 3.0, 4.0} {30.0, 30.0, 30.0, 30.0} InstructionFoldingCase>( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpVectorTimesMatrix %v4float %v4float_1_2_3_4 %mat4v4float_1_2_3_4\n" + "OpReturn\n" + "OpFunctionEnd", 2, {30.0f,30.0f,30.0f,30.0f}), // Test case 7: OpMatrixTimesVector Zero Non-Zero {1.0, 2.0, 3.0, 4.0} {{0.0, 0.0, 0.0, 0.0}, {0.0, 0.0, 0.0, 0.0}, {0.0, 0.0, 0.0, 0.0}, {0.0, 0.0, 0.0, 0.0}} {0.0, 0.0, 0.0, 0.0} InstructionFoldingCase>( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpMatrixTimesVector %v4float %mat4v4float_null %v4float_1_2_3_4\n" + "OpReturn\n" + "OpFunctionEnd", 2, {0.0f,0.0f,0.0f,0.0f}), // Test case 8: OpMatrixTimesVector Non-Zero Zero {{1.0, 2.0, 3.0, 4.0}, {1.0, 2.0, 3.0, 4.0}, {1.0, 2.0, 3.0, 4.0}, {1.0, 2.0, 3.0, 4.0}} {0.0, 0.0, 0.0, 0.0} {0.0, 0.0, 0.0, 0.0} InstructionFoldingCase>( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpMatrixTimesVector %v4float %mat4v4float_1_2_3_4 %v4float_null\n" + "OpReturn\n" + "OpFunctionEnd", 2, {0.0f,0.0f,0.0f,0.0f}), // Test case 9: OpMatrixTimesVector Non-Zero Non-Zero {1.0, 2.0, 3.0, 4.0} {{1.0, 2.0, 3.0, 4.0}, {1.0, 2.0, 3.0, 4.0}, {1.0, 2.0, 3.0, 4.0}, {1.0, 2.0, 3.0, 4.0}} {10.0, 20.0, 30.0, 40.0} InstructionFoldingCase>( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpMatrixTimesVector %v4float %mat4v4float_1_2_3_4 %v4float_1_2_3_4\n" + "OpReturn\n" + "OpFunctionEnd", 2, {10.0f,20.0f,30.0f,40.0f}), // Test case 10: OpMatrixTimesVector Non-Zero Non-Zero {1.0, 2.0, 3.0, 4.0} {{1.0, 2.0, 3.0, 4.0}, Null, {1.0, 2.0, 3.0, 4.0}, Null} {10.0, 20.0, 30.0, 40.0} InstructionFoldingCase>( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpMatrixTimesVector %v4float %mat4v4float_1_2_3_4_null %v4float_1_2_3_4\n" + "OpReturn\n" + "OpFunctionEnd", 2, {4.0,8.0,12.0,16.0}) )); // clang-format on using FloatMatrixInstructionFoldingTest = ::testing::TestWithParam< InstructionFoldingCase>>>; TEST_P(FloatMatrixInstructionFoldingTest, Case) { const auto& tc = GetParam(); std::unique_ptr context; Instruction* inst; std::tie(context, inst) = FoldInstruction(tc.test_body, tc.id_to_fold, SPV_ENV_UNIVERSAL_1_1); EXPECT_EQ(inst->opcode(), spv::Op::OpCopyObject); if (inst->opcode() == spv::Op::OpCopyObject) { analysis::DefUseManager* def_use_mgr = context->get_def_use_mgr(); inst = def_use_mgr->GetDef(inst->GetSingleWordInOperand(0)); analysis::ConstantManager* const_mgr = context->get_constant_mgr(); const analysis::Constant* result = const_mgr->GetConstantFromInst(inst); EXPECT_NE(result, nullptr); if (result != nullptr) { std::vector matrix = result->AsMatrixConstant()->GetComponents(); EXPECT_EQ(matrix.size(), tc.expected_result.size()); for (size_t c = 0; c < matrix.size(); c++) { if (matrix[c]->AsNullConstant() != nullptr) { matrix[c] = const_mgr->GetNullCompositeConstant(matrix[c]->type()); } const analysis::VectorConstant* column_const = matrix[c]->AsVectorConstant(); ASSERT_NE(column_const, nullptr); const std::vector& column = column_const->GetComponents(); EXPECT_EQ(column.size(), tc.expected_result[c].size()); for (size_t r = 0; r < column.size(); r++) { EXPECT_EQ(tc.expected_result[c][r], column[r]->GetFloat()); } } } } } // clang-format off INSTANTIATE_TEST_SUITE_P(TestCase, FloatMatrixInstructionFoldingTest, ::testing::Values( // Test case 0: OpTranspose square null matrix InstructionFoldingCase>>( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpTranspose %mat4v4float %mat4v4float_null\n" + "OpReturn\n" + "OpFunctionEnd", 2, {{0.0f, 0.0f, 0.0f, 0.0f},{0.0f, 0.0f, 0.0f, 0.0f},{0.0f, 0.0f, 0.0f, 0.0f},{0.0f, 0.0f, 0.0f, 0.0f}}), // Test case 1: OpTranspose rectangular null matrix InstructionFoldingCase>>( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpTranspose %mat4v2float %mat2v4float_null\n" + "OpReturn\n" + "OpFunctionEnd", 2, {{0.0f, 0.0f},{0.0f, 0.0f},{0.0f, 0.0f},{0.0f, 0.0f}}), InstructionFoldingCase>>( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpTranspose %mat4v4float %mat4v4float_1_2_3_4\n" + "OpReturn\n" + "OpFunctionEnd", 2, {{1.0f, 1.0f, 1.0f, 1.0f},{2.0f, 2.0f, 2.0f, 2.0f},{3.0f, 3.0f, 3.0f, 3.0f},{4.0f, 4.0f, 4.0f, 4.0f}}) )); // clang-format on using BooleanInstructionFoldingTest = ::testing::TestWithParam>; TEST_P(BooleanInstructionFoldingTest, Case) { const auto& tc = GetParam(); std::unique_ptr context; Instruction* inst; std::tie(context, inst) = FoldInstruction(tc.test_body, tc.id_to_fold, SPV_ENV_UNIVERSAL_1_1); CheckForExpectedScalarConstant( inst, tc.expected_result, [](const analysis::Constant* c) { return c->AsBoolConstant()->value(); }); } // clang-format off INSTANTIATE_TEST_SUITE_P(TestCase, BooleanInstructionFoldingTest, ::testing::Values( // Test case 0: fold true || n InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_bool Function\n" + "%load = OpLoad %bool %n\n" + "%2 = OpLogicalOr %bool %true %load\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 1: fold n || true InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_bool Function\n" + "%load = OpLoad %bool %n\n" + "%2 = OpLogicalOr %bool %load %true\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 2: fold false && n InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_bool Function\n" + "%load = OpLoad %bool %n\n" + "%2 = OpLogicalAnd %bool %false %load\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 3: fold n && false InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_bool Function\n" + "%load = OpLoad %bool %n\n" + "%2 = OpLogicalAnd %bool %load %false\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 4: fold n < 0 (unsigned) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%load = OpLoad %uint %n\n" + "%2 = OpULessThan %bool %load %uint_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 5: fold UINT_MAX < n (unsigned) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%load = OpLoad %uint %n\n" + "%2 = OpULessThan %bool %uint_max %load\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 6: fold INT_MAX < n (signed) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpSLessThan %bool %int_max %load\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 7: fold n < INT_MIN (signed) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpSLessThan %bool %load %int_min\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 8: fold 0 > n (unsigned) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%load = OpLoad %uint %n\n" + "%2 = OpUGreaterThan %bool %uint_0 %load\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 9: fold n > UINT_MAX (unsigned) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%load = OpLoad %uint %n\n" + "%2 = OpUGreaterThan %bool %load %uint_max\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 10: fold n > INT_MAX (signed) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpSGreaterThan %bool %load %int_max\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 11: fold INT_MIN > n (signed) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%load = OpLoad %uint %n\n" + "%2 = OpSGreaterThan %bool %int_min %load\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 12: fold 0 <= n (unsigned) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%load = OpLoad %uint %n\n" + "%2 = OpULessThanEqual %bool %uint_0 %load\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 13: fold n <= UINT_MAX (unsigned) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%load = OpLoad %uint %n\n" + "%2 = OpULessThanEqual %bool %load %uint_max\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 14: fold INT_MIN <= n (signed) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpSLessThanEqual %bool %int_min %load\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 15: fold n <= INT_MAX (signed) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpSLessThanEqual %bool %load %int_max\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 16: fold n >= 0 (unsigned) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%load = OpLoad %uint %n\n" + "%2 = OpUGreaterThanEqual %bool %load %uint_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 17: fold UINT_MAX >= n (unsigned) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%load = OpLoad %uint %n\n" + "%2 = OpUGreaterThanEqual %bool %uint_max %load\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 18: fold n >= INT_MIN (signed) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpSGreaterThanEqual %bool %load %int_min\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 19: fold INT_MAX >= n (signed) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpSGreaterThanEqual %bool %int_max %load\n" + "OpReturn\n" + "OpFunctionEnd", 2, true) )); INSTANTIATE_TEST_SUITE_P(FClampAndCmpLHS, BooleanInstructionFoldingTest, ::testing::Values( // Test case 0: fold 0.0 > clamp(n, 0.0, 1.0) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_0 %float_1\n" + "%2 = OpFOrdGreaterThan %bool %float_0 %clamp\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 1: fold 0.0 > clamp(n, -1.0, -1.0) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_n1 %float_n1\n" + "%2 = OpFOrdGreaterThan %bool %float_0 %clamp\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 2: fold 0.0 >= clamp(n, 1, 2) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_1 %float_2\n" + "%2 = OpFOrdGreaterThanEqual %bool %float_0 %clamp\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 3: fold 0.0 >= clamp(n, -1.0, 0.0) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_n1 %float_0\n" + "%2 = OpFOrdGreaterThanEqual %bool %float_0 %clamp\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 4: fold 0.0 <= clamp(n, 0.0, 1.0) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_0 %float_1\n" + "%2 = OpFOrdLessThanEqual %bool %float_0 %clamp\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 5: fold 0.0 <= clamp(n, -1.0, -1.0) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_n1 %float_n1\n" + "%2 = OpFOrdLessThanEqual %bool %float_0 %clamp\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 6: fold 0.0 < clamp(n, 1, 2) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_1 %float_2\n" + "%2 = OpFOrdLessThan %bool %float_0 %clamp\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 7: fold 0.0 < clamp(n, -1.0, 0.0) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_n1 %float_0\n" + "%2 = OpFOrdLessThan %bool %float_0 %clamp\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 8: fold 0.0 > clamp(n, 0.0, 1.0) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_0 %float_1\n" + "%2 = OpFUnordGreaterThan %bool %float_0 %clamp\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 9: fold 0.0 > clamp(n, -1.0, -1.0) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_n1 %float_n1\n" + "%2 = OpFUnordGreaterThan %bool %float_0 %clamp\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 10: fold 0.0 >= clamp(n, 1, 2) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_1 %float_2\n" + "%2 = OpFUnordGreaterThanEqual %bool %float_0 %clamp\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 11: fold 0.0 >= clamp(n, -1.0, 0.0) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_n1 %float_0\n" + "%2 = OpFUnordGreaterThanEqual %bool %float_0 %clamp\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 12: fold 0.0 <= clamp(n, 0.0, 1.0) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_0 %float_1\n" + "%2 = OpFUnordLessThanEqual %bool %float_0 %clamp\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 13: fold 0.0 <= clamp(n, -1.0, -1.0) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_n1 %float_n1\n" + "%2 = OpFUnordLessThanEqual %bool %float_0 %clamp\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 14: fold 0.0 < clamp(n, 1, 2) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_1 %float_2\n" + "%2 = OpFUnordLessThan %bool %float_0 %clamp\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 15: fold 0.0 < clamp(n, -1.0, 0.0) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_n1 %float_0\n" + "%2 = OpFUnordLessThan %bool %float_0 %clamp\n" + "OpReturn\n" + "OpFunctionEnd", 2, false) )); INSTANTIATE_TEST_SUITE_P(FClampAndCmpRHS, BooleanInstructionFoldingTest, ::testing::Values( // Test case 0: fold clamp(n, 0.0, 1.0) > 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_0 %float_1\n" + "%2 = OpFOrdGreaterThan %bool %clamp %float_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 1: fold clamp(n, 1.0, 1.0) > 0.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_1 %float_1\n" + "%2 = OpFOrdGreaterThan %bool %clamp %float_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 2: fold clamp(n, 1, 2) >= 0.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_1 %float_2\n" + "%2 = OpFOrdGreaterThanEqual %bool %clamp %float_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 3: fold clamp(n, 1.0, 2.0) >= 3.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_1 %float_2\n" + "%2 = OpFOrdGreaterThanEqual %bool %clamp %float_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 4: fold clamp(n, 0.0, 1.0) <= 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_0 %float_1\n" + "%2 = OpFOrdLessThanEqual %bool %clamp %float_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 5: fold clamp(n, 1.0, 2.0) <= 0.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_1 %float_2\n" + "%2 = OpFOrdLessThanEqual %bool %clamp %float_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 6: fold clamp(n, 1, 2) < 3 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_1 %float_2\n" + "%2 = OpFOrdLessThan %bool %clamp %float_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 7: fold clamp(n, -1.0, 0.0) < -1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_n1 %float_0\n" + "%2 = OpFOrdLessThan %bool %clamp %float_n1\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 8: fold clamp(n, 0.0, 1.0) > 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_0 %float_1\n" + "%2 = OpFUnordGreaterThan %bool %clamp %float_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 9: fold clamp(n, 1.0, 2.0) > 0.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_1 %float_2\n" + "%2 = OpFUnordGreaterThan %bool %clamp %float_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 10: fold clamp(n, 1, 2) >= 3.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_1 %float_2\n" + "%2 = OpFUnordGreaterThanEqual %bool %clamp %float_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 11: fold clamp(n, -1.0, 0.0) >= -1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_n1 %float_0\n" + "%2 = OpFUnordGreaterThanEqual %bool %clamp %float_n1\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 12: fold clamp(n, 0.0, 1.0) <= 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_0 %float_1\n" + "%2 = OpFUnordLessThanEqual %bool %clamp %float_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 13: fold clamp(n, 1.0, 1.0) <= 0.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_1 %float_1\n" + "%2 = OpFUnordLessThanEqual %bool %clamp %float_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 14: fold clamp(n, 1, 2) < 3 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_1 %float_2\n" + "%2 = OpFUnordLessThan %bool %clamp %float_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 15: fold clamp(n, -1.0, 0.0) < -1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_n1 %float_0\n" + "%2 = OpFUnordLessThan %bool %clamp %float_n1\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 16: fold clamp(n, -1.0, 0.0) < -1.0 (one test for double) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_double Function\n" + "%ld = OpLoad %double %n\n" + "%clamp = OpExtInst %double %1 FClamp %ld %double_n1 %double_0\n" + "%2 = OpFUnordLessThan %bool %clamp %double_n1\n" + "OpReturn\n" + "OpFunctionEnd", 2, false) )); // clang-format on using FloatInstructionFoldingTest = ::testing::TestWithParam>; TEST_P(FloatInstructionFoldingTest, Case) { const auto& tc = GetParam(); std::unique_ptr context; Instruction* inst; std::tie(context, inst) = FoldInstruction(tc.test_body, tc.id_to_fold, SPV_ENV_UNIVERSAL_1_1); CheckForExpectedScalarConstant(inst, tc.expected_result, [](const analysis::Constant* c) { return c->AsFloatConstant()->GetFloatValue(); }); } // Not testing NaNs because there are no expectations concerning NaNs according // to the "Precision and Operation of SPIR-V Instructions" section of the Vulkan // specification. // clang-format off INSTANTIATE_TEST_SUITE_P(FloatConstantFoldingTest, FloatInstructionFoldingTest, ::testing::Values( // Test case 0: Fold 2.0 - 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFSub %float %float_2 %float_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, 1.0), // Test case 1: Fold 2.0 + 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFAdd %float %float_2 %float_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3.0), // Test case 2: Fold 3.0 * 2.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFMul %float %float_3 %float_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, 6.0), // Test case 3: Fold 1.0 / 2.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFDiv %float %float_1 %float_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0.5), // Test case 4: Fold 1.0 / 0.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFDiv %float %float_1 %float_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, std::numeric_limits::infinity()), // Test case 5: Fold -1.0 / 0.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFDiv %float %float_n1 %float_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, -std::numeric_limits::infinity()), // Test case 6: Fold (2.0, 3.0) dot (2.0, 0.5) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpDot %float %v2float_2_3 %v2float_2_0p5\n" + "OpReturn\n" + "OpFunctionEnd", 2, 5.5f), // Test case 7: Fold (0.0, 0.0) dot v InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%v = OpVariable %_ptr_v2float Function\n" + "%2 = OpLoad %v2float %v\n" + "%3 = OpDot %float %v2float_0_0 %2\n" + "OpReturn\n" + "OpFunctionEnd", 3, 0.0f), // Test case 8: Fold v dot (0.0, 0.0) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%v = OpVariable %_ptr_v2float Function\n" + "%2 = OpLoad %v2float %v\n" + "%3 = OpDot %float %2 %v2float_0_0\n" + "OpReturn\n" + "OpFunctionEnd", 3, 0.0f), // Test case 9: Fold Null dot v InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%v = OpVariable %_ptr_v2float Function\n" + "%2 = OpLoad %v2float %v\n" + "%3 = OpDot %float %v2float_null %2\n" + "OpReturn\n" + "OpFunctionEnd", 3, 0.0f), // Test case 10: Fold v dot Null InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%v = OpVariable %_ptr_v2float Function\n" + "%2 = OpLoad %v2float %v\n" + "%3 = OpDot %float %2 %v2float_null\n" + "OpReturn\n" + "OpFunctionEnd", 3, 0.0f), // Test case 11: Fold -2.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFNegate %float %float_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, -2), // Test case 12: QuantizeToF16 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpQuantizeToF16 %float %float_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, 1.0), // Test case 13: QuantizeToF16 positive non exact InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpQuantizeToF16 %float %float_2049\n" + "OpReturn\n" + "OpFunctionEnd", 2, 2048), // Test case 14: QuantizeToF16 negative non exact InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpQuantizeToF16 %float %float_n2049\n" + "OpReturn\n" + "OpFunctionEnd", 2, -2048), // Test case 15: QuantizeToF16 large positive InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpQuantizeToF16 %float %float_1e16\n" + "OpReturn\n" + "OpFunctionEnd", 2, std::numeric_limits::infinity()), // Test case 16: QuantizeToF16 large negative InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpQuantizeToF16 %float %float_n1e16\n" + "OpReturn\n" + "OpFunctionEnd", 2, -std::numeric_limits::infinity()), // Test case 17: QuantizeToF16 small positive InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpQuantizeToF16 %float %float_1en16\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0.0), // Test case 18: QuantizeToF16 small negative InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpQuantizeToF16 %float %float_n1en16\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0.0), // Test case 19: QuantizeToF16 nan InstructionFoldingCase( HeaderWithNaN() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpQuantizeToF16 %float %float_nan\n" + "OpReturn\n" + "OpFunctionEnd", 2, std::numeric_limits::quiet_NaN()), // Test case 20: FMix 1.0 4.0 0.2 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %float %1 FMix %float_1 %float_4 %float_0p2\n" + "OpReturn\n" + "OpFunctionEnd", 2, 1.6f), // Test case 21: FMin 1.0 4.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %float %1 FMin %float_1 %float_4\n" + "OpReturn\n" + "OpFunctionEnd", 2, 1.0f), // Test case 22: FMin 4.0 0.2 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %float %1 FMin %float_4 %float_0p2\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0.2f), // Test case 23: FMax 1.0 4.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %float %1 FMax %float_1 %float_4\n" + "OpReturn\n" + "OpFunctionEnd", 2, 4.0f), // Test case 24: FMax 1.0 0.2 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %float %1 FMax %float_1 %float_0p2\n" + "OpReturn\n" + "OpFunctionEnd", 2, 1.0f), // Test case 25: FClamp 1.0 0.2 4.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %float %1 FClamp %float_1 %float_0p2 %float_4\n" + "OpReturn\n" + "OpFunctionEnd", 2, 1.0f), // Test case 26: FClamp 0.2 2.0 4.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %float %1 FClamp %float_0p2 %float_2 %float_4\n" + "OpReturn\n" + "OpFunctionEnd", 2, 2.0f), // Test case 27: FClamp 2049.0 2.0 4.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %float %1 FClamp %float_2049 %float_2 %float_4\n" + "OpReturn\n" + "OpFunctionEnd", 2, 4.0f), // Test case 28: FClamp 1.0 2.0 x InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%undef = OpUndef %float\n" + "%2 = OpExtInst %float %1 FClamp %float_1 %float_2 %undef\n" + "OpReturn\n" + "OpFunctionEnd", 2, 2.0), // Test case 29: FClamp 1.0 x 0.5 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%undef = OpUndef %float\n" + "%2 = OpExtInst %float %1 FClamp %float_1 %undef %float_0p5\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0.5), // Test case 30: Sin 0.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %float %1 Sin %float_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0.0), // Test case 31: Cos 0.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %float %1 Cos %float_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, 1.0), // Test case 32: Tan 0.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %float %1 Tan %float_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0.0), // Test case 33: Asin 0.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %float %1 Asin %float_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0.0), // Test case 34: Acos 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %float %1 Acos %float_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0.0), // Test case 35: Atan 0.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %float %1 Atan %float_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0.0), // Test case 36: Exp 0.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %float %1 Exp %float_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, 1.0), // Test case 37: Log 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %float %1 Log %float_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0.0), // Test case 38: Exp2 2.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %float %1 Exp2 %float_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, 4.0), // Test case 39: Log2 4.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %float %1 Log2 %float_4\n" + "OpReturn\n" + "OpFunctionEnd", 2, 2.0), // Test case 40: Sqrt 4.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %float %1 Sqrt %float_4\n" + "OpReturn\n" + "OpFunctionEnd", 2, 2.0), // Test case 41: Atan2 0.0 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %float %1 Atan2 %float_0 %float_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0.0), // Test case 42: Pow 2.0 3.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %float %1 Pow %float_2 %float_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 8.0), // Test case 43: Fold 1.0 / -0.0. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFDiv %float %float_1 %float_n0\n" + "OpReturn\n" + "OpFunctionEnd", 2, -std::numeric_limits::infinity()), // Test case 44: Fold -1.0 / -0.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFDiv %float %float_n1 %float_n0\n" + "OpReturn\n" + "OpFunctionEnd", 2, std::numeric_limits::infinity()), // Test case 45: Fold 0.0 / 0.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFDiv %float %float_0 %float_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, std::numeric_limits::quiet_NaN()), // Test case 46: Fold 0.0 / -0.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFDiv %float %float_0 %float_n0\n" + "OpReturn\n" + "OpFunctionEnd", 2, std::numeric_limits::quiet_NaN()) )); // clang-format on using DoubleInstructionFoldingTest = ::testing::TestWithParam>; TEST_P(DoubleInstructionFoldingTest, Case) { const auto& tc = GetParam(); std::unique_ptr context; Instruction* inst; std::tie(context, inst) = FoldInstruction(tc.test_body, tc.id_to_fold, SPV_ENV_UNIVERSAL_1_1); CheckForExpectedScalarConstant( inst, tc.expected_result, [](const analysis::Constant* c) { return c->AsFloatConstant()->GetDoubleValue(); }); } // clang-format off INSTANTIATE_TEST_SUITE_P(DoubleConstantFoldingTest, DoubleInstructionFoldingTest, ::testing::Values( // Test case 0: Fold 2.0 - 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFSub %double %double_2 %double_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, 1.0), // Test case 1: Fold 2.0 + 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFAdd %double %double_2 %double_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3.0), // Test case 2: Fold 3.0 * 2.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFMul %double %double_3 %double_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, 6.0), // Test case 3: Fold 1.0 / 2.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFDiv %double %double_1 %double_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0.5), // Test case 4: Fold 1.0 / 0.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFDiv %double %double_1 %double_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, std::numeric_limits::infinity()), // Test case 5: Fold -1.0 / 0.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFDiv %double %double_n1 %double_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, -std::numeric_limits::infinity()), // Test case 6: Fold (2.0, 3.0) dot (2.0, 0.5) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpDot %double %v2double_2_3 %v2double_2_0p5\n" + "OpReturn\n" + "OpFunctionEnd", 2, 5.5f), // Test case 7: Fold (0.0, 0.0) dot v InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%v = OpVariable %_ptr_v2double Function\n" + "%2 = OpLoad %v2double %v\n" + "%3 = OpDot %double %v2double_0_0 %2\n" + "OpReturn\n" + "OpFunctionEnd", 3, 0.0f), // Test case 8: Fold v dot (0.0, 0.0) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%v = OpVariable %_ptr_v2double Function\n" + "%2 = OpLoad %v2double %v\n" + "%3 = OpDot %double %2 %v2double_0_0\n" + "OpReturn\n" + "OpFunctionEnd", 3, 0.0f), // Test case 9: Fold Null dot v InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%v = OpVariable %_ptr_v2double Function\n" + "%2 = OpLoad %v2double %v\n" + "%3 = OpDot %double %v2double_null %2\n" + "OpReturn\n" + "OpFunctionEnd", 3, 0.0f), // Test case 10: Fold v dot Null InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%v = OpVariable %_ptr_v2double Function\n" + "%2 = OpLoad %v2double %v\n" + "%3 = OpDot %double %2 %v2double_null\n" + "OpReturn\n" + "OpFunctionEnd", 3, 0.0f), // Test case 11: Fold -2.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFNegate %double %double_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, -2), // Test case 12: FMin 1.0 4.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %double %1 FMin %double_1 %double_4\n" + "OpReturn\n" + "OpFunctionEnd", 2, 1.0), // Test case 13: FMin 4.0 0.2 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %double %1 FMin %double_4 %double_0p2\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0.2), // Test case 14: FMax 1.0 4.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %double %1 FMax %double_1 %double_4\n" + "OpReturn\n" + "OpFunctionEnd", 2, 4.0), // Test case 15: FMax 1.0 0.2 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %double %1 FMax %double_1 %double_0p2\n" + "OpReturn\n" + "OpFunctionEnd", 2, 1.0), // Test case 16: FClamp 1.0 0.2 4.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %double %1 FClamp %double_1 %double_0p2 %double_4\n" + "OpReturn\n" + "OpFunctionEnd", 2, 1.0), // Test case 17: FClamp 0.2 2.0 4.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %double %1 FClamp %double_0p2 %double_2 %double_4\n" + "OpReturn\n" + "OpFunctionEnd", 2, 2.0), // Test case 18: FClamp 5.0 2.0 4.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpExtInst %double %1 FClamp %double_5 %double_2 %double_4\n" + "OpReturn\n" + "OpFunctionEnd", 2, 4.0), // Test case 19: FClamp 1.0 2.0 x InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%undef = OpUndef %double\n" + "%2 = OpExtInst %double %1 FClamp %double_1 %double_2 %undef\n" + "OpReturn\n" + "OpFunctionEnd", 2, 2.0), // Test case 20: FClamp 1.0 x 0.5 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%undef = OpUndef %double\n" + "%2 = OpExtInst %double %1 FClamp %double_1 %undef %double_0p5\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0.5), // Test case 21: Sqrt 4.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%undef = OpUndef %double\n" + "%2 = OpExtInst %double %1 Sqrt %double_4\n" + "OpReturn\n" + "OpFunctionEnd", 2, 2.0), // Test case 22: Pow 2.0 3.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%undef = OpUndef %double\n" + "%2 = OpExtInst %double %1 Pow %double_2 %double_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 8.0), // Test case 23: Fold 1.0 / -0.0. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFDiv %double %double_1 %double_n0\n" + "OpReturn\n" + "OpFunctionEnd", 2, -std::numeric_limits::infinity()), // Test case 24: Fold -1.0 / -0.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFDiv %double %double_n1 %double_n0\n" + "OpReturn\n" + "OpFunctionEnd", 2, std::numeric_limits::infinity()), // Test case 25: Fold 0.0 / 0.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFDiv %double %double_0 %double_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, std::numeric_limits::quiet_NaN()), // Test case 26: Fold 0.0 / -0.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFDiv %double %double_0 %double_n0\n" + "OpReturn\n" + "OpFunctionEnd", 2, std::numeric_limits::quiet_NaN()) )); // clang-format on // clang-format off INSTANTIATE_TEST_SUITE_P(DoubleOrderedCompareConstantFoldingTest, BooleanInstructionFoldingTest, ::testing::Values( // Test case 0: fold 1.0 == 2.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFOrdEqual %bool %double_1 %double_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 1: fold 1.0 != 2.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFOrdNotEqual %bool %double_1 %double_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 2: fold 1.0 < 2.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFOrdLessThan %bool %double_1 %double_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 3: fold 1.0 > 2.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFOrdGreaterThan %bool %double_1 %double_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 4: fold 1.0 <= 2.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFOrdLessThanEqual %bool %double_1 %double_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 5: fold 1.0 >= 2.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFOrdGreaterThanEqual %bool %double_1 %double_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 6: fold 1.0 == 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFOrdEqual %bool %double_1 %double_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 7: fold 1.0 != 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFOrdNotEqual %bool %double_1 %double_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 8: fold 1.0 < 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFOrdLessThan %bool %double_1 %double_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 9: fold 1.0 > 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFOrdGreaterThan %bool %double_1 %double_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 10: fold 1.0 <= 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFOrdLessThanEqual %bool %double_1 %double_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 11: fold 1.0 >= 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFOrdGreaterThanEqual %bool %double_1 %double_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 12: fold 2.0 < 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFOrdLessThan %bool %double_2 %double_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 13: fold 2.0 > 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFOrdGreaterThan %bool %double_2 %double_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 14: fold 2.0 <= 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFOrdLessThanEqual %bool %double_2 %double_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 15: fold 2.0 >= 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFOrdGreaterThanEqual %bool %double_2 %double_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, true) )); INSTANTIATE_TEST_SUITE_P(DoubleUnorderedCompareConstantFoldingTest, BooleanInstructionFoldingTest, ::testing::Values( // Test case 0: fold 1.0 == 2.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFUnordEqual %bool %double_1 %double_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 1: fold 1.0 != 2.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFUnordNotEqual %bool %double_1 %double_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 2: fold 1.0 < 2.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFUnordLessThan %bool %double_1 %double_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 3: fold 1.0 > 2.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFUnordGreaterThan %bool %double_1 %double_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 4: fold 1.0 <= 2.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFUnordLessThanEqual %bool %double_1 %double_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 5: fold 1.0 >= 2.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFUnordGreaterThanEqual %bool %double_1 %double_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 6: fold 1.0 == 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFUnordEqual %bool %double_1 %double_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 7: fold 1.0 != 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFUnordNotEqual %bool %double_1 %double_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 8: fold 1.0 < 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFUnordLessThan %bool %double_1 %double_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 9: fold 1.0 > 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFUnordGreaterThan %bool %double_1 %double_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 10: fold 1.0 <= 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFUnordLessThanEqual %bool %double_1 %double_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 11: fold 1.0 >= 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFUnordGreaterThanEqual %bool %double_1 %double_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 12: fold 2.0 < 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFUnordLessThan %bool %double_2 %double_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 13: fold 2.0 > 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFUnordGreaterThan %bool %double_2 %double_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 14: fold 2.0 <= 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFUnordLessThanEqual %bool %double_2 %double_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 15: fold 2.0 >= 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFUnordGreaterThanEqual %bool %double_2 %double_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, true) )); INSTANTIATE_TEST_SUITE_P(FloatOrderedCompareConstantFoldingTest, BooleanInstructionFoldingTest, ::testing::Values( // Test case 0: fold 1.0 == 2.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFOrdEqual %bool %float_1 %float_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 1: fold 1.0 != 2.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFOrdNotEqual %bool %float_1 %float_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 2: fold 1.0 < 2.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFOrdLessThan %bool %float_1 %float_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 3: fold 1.0 > 2.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFOrdGreaterThan %bool %float_1 %float_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 4: fold 1.0 <= 2.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFOrdLessThanEqual %bool %float_1 %float_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 5: fold 1.0 >= 2.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFOrdGreaterThanEqual %bool %float_1 %float_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 6: fold 1.0 == 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFOrdEqual %bool %float_1 %float_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 7: fold 1.0 != 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFOrdNotEqual %bool %float_1 %float_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 8: fold 1.0 < 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFOrdLessThan %bool %float_1 %float_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 9: fold 1.0 > 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFOrdGreaterThan %bool %float_1 %float_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 10: fold 1.0 <= 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFOrdLessThanEqual %bool %float_1 %float_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 11: fold 1.0 >= 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFOrdGreaterThanEqual %bool %float_1 %float_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 12: fold 2.0 < 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFOrdLessThan %bool %float_2 %float_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 13: fold 2.0 > 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFOrdGreaterThan %bool %float_2 %float_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 14: fold 2.0 <= 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFOrdLessThanEqual %bool %float_2 %float_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 15: fold 2.0 >= 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFOrdGreaterThanEqual %bool %float_2 %float_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, true) )); INSTANTIATE_TEST_SUITE_P(FloatUnorderedCompareConstantFoldingTest, BooleanInstructionFoldingTest, ::testing::Values( // Test case 0: fold 1.0 == 2.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFUnordEqual %bool %float_1 %float_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 1: fold 1.0 != 2.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFUnordNotEqual %bool %float_1 %float_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 2: fold 1.0 < 2.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFUnordLessThan %bool %float_1 %float_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 3: fold 1.0 > 2.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFUnordGreaterThan %bool %float_1 %float_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 4: fold 1.0 <= 2.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFUnordLessThanEqual %bool %float_1 %float_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 5: fold 1.0 >= 2.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFUnordGreaterThanEqual %bool %float_1 %float_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 6: fold 1.0 == 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFUnordEqual %bool %float_1 %float_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 7: fold 1.0 != 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFUnordNotEqual %bool %float_1 %float_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 8: fold 1.0 < 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFUnordLessThan %bool %float_1 %float_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 9: fold 1.0 > 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFUnordGreaterThan %bool %float_1 %float_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 10: fold 1.0 <= 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFUnordLessThanEqual %bool %float_1 %float_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 11: fold 1.0 >= 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFUnordGreaterThanEqual %bool %float_1 %float_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 12: fold 2.0 < 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFUnordLessThan %bool %float_2 %float_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 13: fold 2.0 > 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFUnordGreaterThan %bool %float_2 %float_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 14: fold 2.0 <= 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFUnordLessThanEqual %bool %float_2 %float_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 15: fold 2.0 >= 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFUnordGreaterThanEqual %bool %float_2 %float_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, true) )); INSTANTIATE_TEST_SUITE_P(DoubleNaNCompareConstantFoldingTest, BooleanInstructionFoldingTest, ::testing::Values( // Test case 0: fold NaN == 0 (ord) InstructionFoldingCase( HeaderWithNaN() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFOrdEqual %bool %double_nan %double_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 1: fold NaN == NaN (unord) InstructionFoldingCase( HeaderWithNaN() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFUnordEqual %bool %double_nan %double_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 2: fold NaN != NaN (ord) InstructionFoldingCase( HeaderWithNaN() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFOrdNotEqual %bool %double_nan %double_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 3: fold NaN != NaN (unord) InstructionFoldingCase( HeaderWithNaN() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFUnordNotEqual %bool %double_nan %double_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, true) )); INSTANTIATE_TEST_SUITE_P(FloatNaNCompareConstantFoldingTest, BooleanInstructionFoldingTest, ::testing::Values( // Test case 0: fold NaN == 0 (ord) InstructionFoldingCase( HeaderWithNaN() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFOrdEqual %bool %float_nan %float_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 1: fold NaN == NaN (unord) InstructionFoldingCase( HeaderWithNaN() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFUnordEqual %bool %float_nan %float_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 2: fold NaN != NaN (ord) InstructionFoldingCase( HeaderWithNaN() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFOrdNotEqual %bool %float_nan %float_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, false), // Test case 3: fold NaN != NaN (unord) InstructionFoldingCase( HeaderWithNaN() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFUnordNotEqual %bool %float_nan %float_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, true) )); // clang-format on template struct InstructionFoldingCaseWithMap { InstructionFoldingCaseWithMap(const std::string& tb, uint32_t id, ResultType result, std::function map) : test_body(tb), id_to_fold(id), expected_result(result), id_map(map) {} std::string test_body; uint32_t id_to_fold; ResultType expected_result; std::function id_map; }; using IntegerInstructionFoldingTestWithMap = ::testing::TestWithParam>; TEST_P(IntegerInstructionFoldingTestWithMap, Case) { const auto& tc = GetParam(); std::unique_ptr context; Instruction* inst; std::tie(context, inst) = GetInstructionToFold(tc.test_body, tc.id_to_fold, SPV_ENV_UNIVERSAL_1_5); inst = context->get_instruction_folder().FoldInstructionToConstant(inst, tc.id_map); EXPECT_NE(inst, nullptr); CheckForExpectedScalarConstant(inst, tc.expected_result, [](const analysis::Constant* c) { return c->AsIntConstant()->GetU32BitValue(); }); } // clang-format off INSTANTIATE_TEST_SUITE_P(TestCase, IntegerInstructionFoldingTestWithMap, ::testing::Values( // Test case 0: fold %3 = 0; %3 * n InstructionFoldingCaseWithMap( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%3 = OpCopyObject %int %int_0\n" "%2 = OpIMul %int %3 %load\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0, [](uint32_t id) {return (id == 3 ? INT_0_ID : id);}) )); // clang-format on using BooleanInstructionFoldingTestWithMap = ::testing::TestWithParam>; TEST_P(BooleanInstructionFoldingTestWithMap, Case) { const auto& tc = GetParam(); std::unique_ptr context; Instruction* inst; std::tie(context, inst) = GetInstructionToFold(tc.test_body, tc.id_to_fold, SPV_ENV_UNIVERSAL_1_5); inst = context->get_instruction_folder().FoldInstructionToConstant(inst, tc.id_map); ASSERT_NE(inst, nullptr); CheckForExpectedScalarConstant( inst, tc.expected_result, [](const analysis::Constant* c) { return c->AsBoolConstant()->value(); }); } // clang-format off INSTANTIATE_TEST_SUITE_P(TestCase, BooleanInstructionFoldingTestWithMap, ::testing::Values( // Test case 0: fold %3 = true; %3 || n InstructionFoldingCaseWithMap( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_bool Function\n" + "%load = OpLoad %bool %n\n" + "%3 = OpCopyObject %bool %true\n" + "%2 = OpLogicalOr %bool %3 %load\n" + "OpReturn\n" + "OpFunctionEnd", 2, true, [](uint32_t id) {return (id == 3 ? TRUE_ID : id);}) )); // clang-format on using GeneralInstructionFoldingTest = ::testing::TestWithParam>; TEST_P(GeneralInstructionFoldingTest, Case) { const auto& tc = GetParam(); std::unique_ptr context; Instruction* inst; std::tie(context, inst) = FoldInstruction(tc.test_body, tc.id_to_fold, SPV_ENV_UNIVERSAL_1_1); EXPECT_TRUE((inst == nullptr) == (tc.expected_result == 0)); if (inst != nullptr) { EXPECT_EQ(inst->opcode(), spv::Op::OpCopyObject); EXPECT_EQ(inst->GetSingleWordInOperand(0), tc.expected_result); } } // clang-format off INSTANTIATE_TEST_SUITE_P(IntegerArithmeticTestCases, GeneralInstructionFoldingTest, ::testing::Values( // Test case 0: Don't fold n * m InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%m = OpVariable %_ptr_int Function\n" + "%load_n = OpLoad %int %n\n" + "%load_m = OpLoad %int %m\n" + "%2 = OpIMul %int %load_n %load_m\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 1: Don't fold n / m (unsigned) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%m = OpVariable %_ptr_uint Function\n" + "%load_n = OpLoad %uint %n\n" + "%load_m = OpLoad %uint %m\n" + "%2 = OpUDiv %uint %load_n %load_m\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 2: Don't fold n / m (signed) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%m = OpVariable %_ptr_int Function\n" + "%load_n = OpLoad %int %n\n" + "%load_m = OpLoad %int %m\n" + "%2 = OpSDiv %int %load_n %load_m\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 3: Don't fold n remainder m InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%m = OpVariable %_ptr_int Function\n" + "%load_n = OpLoad %int %n\n" + "%load_m = OpLoad %int %m\n" + "%2 = OpSRem %int %load_n %load_m\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 4: Don't fold n % m (signed) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%m = OpVariable %_ptr_int Function\n" + "%load_n = OpLoad %int %n\n" + "%load_m = OpLoad %int %m\n" + "%2 = OpSMod %int %load_n %load_m\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 5: Don't fold n % m (unsigned) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%m = OpVariable %_ptr_uint Function\n" + "%load_n = OpLoad %uint %n\n" + "%load_m = OpLoad %uint %m\n" + "%2 = OpUMod %int %load_n %load_m\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 6: Don't fold n << m InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%m = OpVariable %_ptr_uint Function\n" + "%load_n = OpLoad %uint %n\n" + "%load_m = OpLoad %uint %m\n" + "%2 = OpShiftRightLogical %int %load_n %load_m\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 7: Don't fold n >> m InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%m = OpVariable %_ptr_uint Function\n" + "%load_n = OpLoad %uint %n\n" + "%load_m = OpLoad %uint %m\n" + "%2 = OpShiftLeftLogical %int %load_n %load_m\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 8: Don't fold n | m InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%m = OpVariable %_ptr_uint Function\n" + "%load_n = OpLoad %uint %n\n" + "%load_m = OpLoad %uint %m\n" + "%2 = OpBitwiseOr %int %load_n %load_m\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 9: Don't fold n & m InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%m = OpVariable %_ptr_uint Function\n" + "%load_n = OpLoad %uint %n\n" + "%load_m = OpLoad %uint %m\n" + "%2 = OpBitwiseAnd %int %load_n %load_m\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 10: Don't fold n < m (unsigned) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%m = OpVariable %_ptr_uint Function\n" + "%load_n = OpLoad %uint %n\n" + "%load_m = OpLoad %uint %m\n" + "%2 = OpULessThan %bool %load_n %load_m\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 11: Don't fold n > m (unsigned) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%m = OpVariable %_ptr_uint Function\n" + "%load_n = OpLoad %uint %n\n" + "%load_m = OpLoad %uint %m\n" + "%2 = OpUGreaterThan %bool %load_n %load_m\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 12: Don't fold n <= m (unsigned) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%m = OpVariable %_ptr_uint Function\n" + "%load_n = OpLoad %uint %n\n" + "%load_m = OpLoad %uint %m\n" + "%2 = OpULessThanEqual %bool %load_n %load_m\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 13: Don't fold n >= m (unsigned) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%m = OpVariable %_ptr_uint Function\n" + "%load_n = OpLoad %uint %n\n" + "%load_m = OpLoad %uint %m\n" + "%2 = OpUGreaterThanEqual %bool %load_n %load_m\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 14: Don't fold n < m (signed) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%m = OpVariable %_ptr_int Function\n" + "%load_n = OpLoad %int %n\n" + "%load_m = OpLoad %int %m\n" + "%2 = OpULessThan %bool %load_n %load_m\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 15: Don't fold n > m (signed) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%m = OpVariable %_ptr_int Function\n" + "%load_n = OpLoad %int %n\n" + "%load_m = OpLoad %int %m\n" + "%2 = OpUGreaterThan %bool %load_n %load_m\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 16: Don't fold n <= m (signed) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%m = OpVariable %_ptr_int Function\n" + "%load_n = OpLoad %int %n\n" + "%load_m = OpLoad %int %m\n" + "%2 = OpULessThanEqual %bool %load_n %load_m\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 17: Don't fold n >= m (signed) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%m = OpVariable %_ptr_int Function\n" + "%load_n = OpLoad %int %n\n" + "%load_m = OpLoad %int %m\n" + "%2 = OpUGreaterThanEqual %bool %load_n %load_m\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 18: Don't fold n || m InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_bool Function\n" + "%m = OpVariable %_ptr_bool Function\n" + "%load_n = OpLoad %bool %n\n" + "%load_m = OpLoad %bool %m\n" + "%2 = OpLogicalOr %bool %load_n %load_m\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 19: Don't fold n && m InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_bool Function\n" + "%m = OpVariable %_ptr_bool Function\n" + "%load_n = OpLoad %bool %n\n" + "%load_m = OpLoad %bool %m\n" + "%2 = OpLogicalAnd %bool %load_n %load_m\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 20: Don't fold n * 3 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load_n = OpLoad %int %n\n" + "%2 = OpIMul %int %load_n %int_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 21: Don't fold n / 3 (unsigned) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%load_n = OpLoad %uint %n\n" + "%2 = OpUDiv %uint %load_n %uint_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 22: Don't fold n / 3 (signed) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load_n = OpLoad %int %n\n" + "%2 = OpSDiv %int %load_n %int_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 23: Don't fold n remainder 3 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load_n = OpLoad %int %n\n" + "%2 = OpSRem %int %load_n %int_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 24: Don't fold n % 3 (signed) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load_n = OpLoad %int %n\n" + "%2 = OpSMod %int %load_n %int_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 25: Don't fold n % 3 (unsigned) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%load_n = OpLoad %uint %n\n" + "%2 = OpUMod %int %load_n %int_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 26: Don't fold n << 3 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%load_n = OpLoad %uint %n\n" + "%2 = OpShiftRightLogical %int %load_n %int_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 27: Don't fold n >> 3 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%load_n = OpLoad %uint %n\n" + "%2 = OpShiftLeftLogical %int %load_n %int_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 28: Don't fold n | 3 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%load_n = OpLoad %uint %n\n" + "%2 = OpBitwiseOr %int %load_n %int_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 29: Don't fold n & 3 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%load_n = OpLoad %uint %n\n" + "%2 = OpBitwiseAnd %uint %load_n %uint_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 30: Don't fold n < 3 (unsigned) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%load_n = OpLoad %uint %n\n" + "%2 = OpULessThan %bool %load_n %uint_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 31: Don't fold n > 3 (unsigned) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%load_n = OpLoad %uint %n\n" + "%2 = OpUGreaterThan %bool %load_n %uint_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 32: Don't fold n <= 3 (unsigned) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%load_n = OpLoad %uint %n\n" + "%2 = OpULessThanEqual %bool %load_n %uint_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 33: Don't fold n >= 3 (unsigned) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%load_n = OpLoad %uint %n\n" + "%2 = OpUGreaterThanEqual %bool %load_n %uint_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 34: Don't fold n < 3 (signed) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load_n = OpLoad %int %n\n" + "%2 = OpULessThan %bool %load_n %int_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 35: Don't fold n > 3 (signed) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load_n = OpLoad %int %n\n" + "%2 = OpUGreaterThan %bool %load_n %int_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 36: Don't fold n <= 3 (signed) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load_n = OpLoad %int %n\n" + "%2 = OpULessThanEqual %bool %load_n %int_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 37: Don't fold n >= 3 (signed) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load_n = OpLoad %int %n\n" + "%2 = OpUGreaterThanEqual %bool %load_n %int_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 38: fold 1*n InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%3 = OpLoad %int %n\n" + "%2 = OpIMul %int %int_1 %3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3), // Test case 39: fold n*1 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%3 = OpLoad %int %n\n" + "%2 = OpIMul %int %3 %int_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3), // Test case 40: Don't fold comparisons of 64-bit types // (https://github.com/KhronosGroup/SPIRV-Tools/issues/3343). InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpSLessThan %bool %long_0 %long_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 41: Don't fold OpSNegate for cooperative matrices. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpSNegate %int_coop_matrix %undef_int_coop_matrix\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 42: Don't fold OpIAdd for cooperative matrices. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpIAdd %int_coop_matrix %undef_int_coop_matrix %undef_int_coop_matrix\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 43: Don't fold OpISub for cooperative matrices. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpISub %int_coop_matrix %undef_int_coop_matrix %undef_int_coop_matrix\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 44: Don't fold OpIMul for cooperative matrices. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpIMul %int_coop_matrix %undef_int_coop_matrix %undef_int_coop_matrix\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 45: Don't fold OpSDiv for cooperative matrices. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpSDiv %int_coop_matrix %undef_int_coop_matrix %undef_int_coop_matrix\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 46: Don't fold OpUDiv for cooperative matrices. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpUDiv %uint_coop_matrix %undef_uint_coop_matrix %undef_uint_coop_matrix\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 47: Don't fold OpMatrixTimesScalar for cooperative matrices. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpMatrixTimesScalar %uint_coop_matrix %undef_uint_coop_matrix %uint_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0) )); INSTANTIATE_TEST_SUITE_P(CompositeExtractFoldingTest, GeneralInstructionFoldingTest, ::testing::Values( // Test case 0: fold Insert feeding extract InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %n\n" + "%3 = OpCompositeInsert %v4int %2 %v4int_0_0_0_0 0\n" + "%4 = OpCompositeInsert %v4int %int_1 %3 1\n" + "%5 = OpCompositeInsert %v4int %int_1 %4 2\n" + "%6 = OpCompositeInsert %v4int %int_1 %5 3\n" + "%7 = OpCompositeExtract %int %6 0\n" + "OpReturn\n" + "OpFunctionEnd", 7, 2), // Test case 1: fold Composite construct feeding extract (position 0) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %n\n" + "%3 = OpCompositeConstruct %v4int %2 %int_0 %int_0 %int_0\n" + "%4 = OpCompositeExtract %int %3 0\n" + "OpReturn\n" + "OpFunctionEnd", 4, 2), // Test case 2: fold Composite construct feeding extract (position 3) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %n\n" + "%3 = OpCompositeConstruct %v4int %2 %int_0 %int_0 %100\n" + "%4 = OpCompositeExtract %int %3 3\n" + "OpReturn\n" + "OpFunctionEnd", 4, INT_0_ID), // Test case 3: fold Composite construct with vectors feeding extract (scalar element) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %n\n" + "%3 = OpCompositeConstruct %v2int %2 %int_0\n" + "%4 = OpCompositeConstruct %v4int %3 %int_0 %100\n" + "%5 = OpCompositeExtract %int %4 3\n" + "OpReturn\n" + "OpFunctionEnd", 5, INT_0_ID), // Test case 4: fold Composite construct with vectors feeding extract (start of vector element) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %n\n" + "%3 = OpCompositeConstruct %v2int %2 %int_0\n" + "%4 = OpCompositeConstruct %v4int %3 %int_0 %100\n" + "%5 = OpCompositeExtract %int %4 0\n" + "OpReturn\n" + "OpFunctionEnd", 5, 2), // Test case 5: fold Composite construct with vectors feeding extract (middle of vector element) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %n\n" + "%3 = OpCompositeConstruct %v2int %int_0 %2\n" + "%4 = OpCompositeConstruct %v4int %3 %int_0 %100\n" + "%5 = OpCompositeExtract %int %4 1\n" + "OpReturn\n" + "OpFunctionEnd", 5, 2), // Test case 6: fold Composite construct with multiple indices. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %n\n" + "%3 = OpCompositeConstruct %v2int %int_0 %2\n" + "%4 = OpCompositeConstruct %struct_v2int_int_int %3 %int_0 %100\n" + "%5 = OpCompositeExtract %int %4 0 1\n" + "OpReturn\n" + "OpFunctionEnd", 5, 2), // Test case 7: fold constant extract. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpCompositeExtract %int %102 1\n" + "OpReturn\n" + "OpFunctionEnd", 2, INT_7_ID), // Test case 8: constant struct has OpUndef InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpCompositeExtract %int %struct_undef_0_0 0 1\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 9: Extracting a member of element inserted via Insert InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_struct_v2int_int_int Function\n" + "%2 = OpLoad %struct_v2int_int_int %n\n" + "%3 = OpCompositeInsert %struct_v2int_int_int %102 %2 0\n" + "%4 = OpCompositeExtract %int %3 0 1\n" + "OpReturn\n" + "OpFunctionEnd", 4, 103), // Test case 10: Extracting a element that is partially changed by Insert. (Don't fold) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_struct_v2int_int_int Function\n" + "%2 = OpLoad %struct_v2int_int_int %n\n" + "%3 = OpCompositeInsert %struct_v2int_int_int %int_0 %2 0 1\n" + "%4 = OpCompositeExtract %v2int %3 0\n" + "OpReturn\n" + "OpFunctionEnd", 4, 0), // Test case 11: Extracting from result of vector shuffle (first input) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_v2int Function\n" + "%2 = OpLoad %v2int %n\n" + "%3 = OpVectorShuffle %v2int %102 %2 3 0\n" + "%4 = OpCompositeExtract %int %3 1\n" + "OpReturn\n" + "OpFunctionEnd", 4, INT_7_ID), // Test case 12: Extracting from result of vector shuffle (second input) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_v2int Function\n" + "%2 = OpLoad %v2int %n\n" + "%3 = OpVectorShuffle %v2int %2 %102 2 0\n" + "%4 = OpCompositeExtract %int %3 0\n" + "OpReturn\n" + "OpFunctionEnd", 4, INT_7_ID), // Test case 13: https://github.com/KhronosGroup/SPIRV-Tools/issues/2608 // Out of bounds access. Do not fold. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1\n" + "%3 = OpCompositeExtract %float %2 4\n" + "OpReturn\n" + "OpFunctionEnd", 3, 0), // Test case 14: https://github.com/KhronosGroup/SPIRV-Tools/issues/3631 // Extract the component right after the vector constituent. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpCompositeConstruct %v2int %int_0 %int_0\n" + "%3 = OpCompositeConstruct %v4int %2 %100 %int_0\n" + "%4 = OpCompositeExtract %int %3 2\n" + "OpReturn\n" + "OpFunctionEnd", 4, INT_0_ID), // Test case 15: // Don't fold extract fed by construct with vector result if the index is // past the last element. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpCompositeConstruct %v2int %int_0 %int_0\n" + "%3 = OpCompositeConstruct %v4int %2 %100 %int_0\n" + "%4 = OpCompositeExtract %int %3 4\n" + "OpReturn\n" + "OpFunctionEnd", 4, 0) )); INSTANTIATE_TEST_SUITE_P(CompositeConstructFoldingTest, GeneralInstructionFoldingTest, ::testing::Values( // Test case 0: fold Extracts feeding construct InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpCopyObject %v4int %v4int_0_0_0_0\n" + "%3 = OpCompositeExtract %int %2 0\n" + "%4 = OpCompositeExtract %int %2 1\n" + "%5 = OpCompositeExtract %int %2 2\n" + "%6 = OpCompositeExtract %int %2 3\n" + "%7 = OpCompositeConstruct %v4int %3 %4 %5 %6\n" + "OpReturn\n" + "OpFunctionEnd", 7, 2), // Test case 1: Don't fold Extracts feeding construct (Different source) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpCopyObject %v4int %v4int_0_0_0_0\n" + "%3 = OpCompositeExtract %int %2 0\n" + "%4 = OpCompositeExtract %int %2 1\n" + "%5 = OpCompositeExtract %int %2 2\n" + "%6 = OpCompositeExtract %int %v4int_0_0_0_0 3\n" + "%7 = OpCompositeConstruct %v4int %3 %4 %5 %6\n" + "OpReturn\n" + "OpFunctionEnd", 7, 0), // Test case 2: Don't fold Extracts feeding construct (bad indices) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpCopyObject %v4int %v4int_0_0_0_0\n" + "%3 = OpCompositeExtract %int %2 0\n" + "%4 = OpCompositeExtract %int %2 0\n" + "%5 = OpCompositeExtract %int %2 2\n" + "%6 = OpCompositeExtract %int %2 3\n" + "%7 = OpCompositeConstruct %v4int %3 %4 %5 %6\n" + "OpReturn\n" + "OpFunctionEnd", 7, 0), // Test case 3: Don't fold Extracts feeding construct (different type) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpCopyObject %struct_v2int_int_int %struct_v2int_int_int_null\n" + "%3 = OpCompositeExtract %v2int %2 0\n" + "%4 = OpCompositeExtract %int %2 1\n" + "%5 = OpCompositeExtract %int %2 2\n" + "%7 = OpCompositeConstruct %v4int %3 %4 %5\n" + "OpReturn\n" + "OpFunctionEnd", 7, 0), // Test case 4: Fold construct with constants to constant. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpCompositeConstruct %v2int %103 %103\n" + "OpReturn\n" + "OpFunctionEnd", 2, VEC2_0_ID), // Test case 5: Don't segfault when trying to fold an OpCompositeConstruct // for an empty struct, and we reached the id limit. InstructionFoldingCase( Header() + "%empty_struct = OpTypeStruct\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%4194303 = OpCompositeConstruct %empty_struct\n" + "OpReturn\n" + "OpFunctionEnd", 4194303, 0) )); INSTANTIATE_TEST_SUITE_P(PhiFoldingTest, GeneralInstructionFoldingTest, ::testing::Values( // Test case 0: Fold phi with the same values for all edges. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + " OpBranchConditional %true %l1 %l2\n" + "%l1 = OpLabel\n" + " OpBranch %merge_lab\n" + "%l2 = OpLabel\n" + " OpBranch %merge_lab\n" + "%merge_lab = OpLabel\n" + "%2 = OpPhi %int %100 %l1 %100 %l2\n" + "OpReturn\n" + "OpFunctionEnd", 2, INT_0_ID), // Test case 1: Fold phi in pass through loop. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + " OpBranch %l1\n" + "%l1 = OpLabel\n" + "%2 = OpPhi %int %100 %main_lab %2 %l1\n" + " OpBranchConditional %true %l1 %merge_lab\n" + "%merge_lab = OpLabel\n" + "OpReturn\n" + "OpFunctionEnd", 2, INT_0_ID), // Test case 2: Don't Fold phi because of different values. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + " OpBranch %l1\n" + "%l1 = OpLabel\n" + "%2 = OpPhi %int %int_0 %main_lab %int_3 %l1\n" + " OpBranchConditional %true %l1 %merge_lab\n" + "%merge_lab = OpLabel\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0) )); INSTANTIATE_TEST_SUITE_P(FloatRedundantFoldingTest, GeneralInstructionFoldingTest, ::testing::Values( // Test case 0: Don't fold n + 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%3 = OpLoad %float %n\n" + "%2 = OpFAdd %float %3 %float_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 1: Don't fold n - 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%3 = OpLoad %float %n\n" + "%2 = OpFSub %float %3 %float_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 2: Don't fold n * 2.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%3 = OpLoad %float %n\n" + "%2 = OpFMul %float %3 %float_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 3: Fold n + 0.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%3 = OpLoad %float %n\n" + "%2 = OpFAdd %float %3 %float_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3), // Test case 4: Fold 0.0 + n InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%3 = OpLoad %float %n\n" + "%2 = OpFAdd %float %float_0 %3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3), // Test case 5: Fold n - 0.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%3 = OpLoad %float %n\n" + "%2 = OpFSub %float %3 %float_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3), // Test case 6: Fold n * 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%3 = OpLoad %float %n\n" + "%2 = OpFMul %float %3 %float_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3), // Test case 7: Fold 1.0 * n InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%3 = OpLoad %float %n\n" + "%2 = OpFMul %float %float_1 %3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3), // Test case 8: Fold n / 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%3 = OpLoad %float %n\n" + "%2 = OpFDiv %float %3 %float_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3), // Test case 9: Fold n * 0.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%3 = OpLoad %float %n\n" + "%2 = OpFMul %float %3 %104\n" + "OpReturn\n" + "OpFunctionEnd", 2, FLOAT_0_ID), // Test case 10: Fold 0.0 * n InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%3 = OpLoad %float %n\n" + "%2 = OpFMul %float %104 %3\n" + "OpReturn\n" + "OpFunctionEnd", 2, FLOAT_0_ID), // Test case 11: Fold 0.0 / n InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%3 = OpLoad %float %n\n" + "%2 = OpFDiv %float %104 %3\n" + "OpReturn\n" + "OpFunctionEnd", 2, FLOAT_0_ID), // Test case 12: Don't fold mix(a, b, 2.0) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%a = OpVariable %_ptr_float Function\n" + "%b = OpVariable %_ptr_float Function\n" + "%3 = OpLoad %float %a\n" + "%4 = OpLoad %float %b\n" + "%2 = OpExtInst %float %1 FMix %3 %4 %float_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 13: Fold mix(a, b, 0.0) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%a = OpVariable %_ptr_float Function\n" + "%b = OpVariable %_ptr_float Function\n" + "%3 = OpLoad %float %a\n" + "%4 = OpLoad %float %b\n" + "%2 = OpExtInst %float %1 FMix %3 %4 %float_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3), // Test case 14: Fold mix(a, b, 1.0) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%a = OpVariable %_ptr_float Function\n" + "%b = OpVariable %_ptr_float Function\n" + "%3 = OpLoad %float %a\n" + "%4 = OpLoad %float %b\n" + "%2 = OpExtInst %float %1 FMix %3 %4 %float_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, 4), // Test case 15: Fold vector fadd with null InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%a = OpVariable %_ptr_v2float Function\n" + "%2 = OpLoad %v2float %a\n" + "%3 = OpFAdd %v2float %2 %v2float_null\n" + "OpReturn\n" + "OpFunctionEnd", 3, 2), // Test case 16: Fold vector fadd with null InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%a = OpVariable %_ptr_v2float Function\n" + "%2 = OpLoad %v2float %a\n" + "%3 = OpFAdd %v2float %v2float_null %2\n" + "OpReturn\n" + "OpFunctionEnd", 3, 2), // Test case 17: Fold vector fsub with null InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%a = OpVariable %_ptr_v2float Function\n" + "%2 = OpLoad %v2float %a\n" + "%3 = OpFSub %v2float %2 %v2float_null\n" + "OpReturn\n" + "OpFunctionEnd", 3, 2), // Test case 18: Fold 0.0(half) * n InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_half Function\n" + "%3 = OpLoad %half %n\n" + "%2 = OpFMul %half %108 %3\n" + "OpReturn\n" + "OpFunctionEnd", 2, HALF_0_ID), // Test case 19: Don't fold 1.0(half) * n InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_half Function\n" + "%3 = OpLoad %half %n\n" + "%2 = OpFMul %half %half_1 %3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 20: Don't fold 1.0 * 1.0 (half) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFMul %half %half_1 %half_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 21: Don't fold (0.0, 1.0) * (0.0, 1.0) (half) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFMul %v2half %half_0_1 %half_0_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 22: Don't fold (0.0, 1.0) dotp (0.0, 1.0) (half) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpDot %half %half_0_1 %half_0_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 23: Don't fold 1.0(half) / 2.0(half) // We do not have to code to emulate 16-bit float operations. Just make sure we do not crash. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_half Function\n" + "%3 = OpLoad %half %n\n" + "%2 = OpFDiv %half %half_1 %half_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 24: Don't fold OpFNegate for cooperative matrices. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFNegate %float_coop_matrix %undef_float_coop_matrix\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 25: Don't fold OpIAdd for cooperative matrices. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFAdd %float_coop_matrix %undef_float_coop_matrix %undef_float_coop_matrix\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 26: Don't fold OpISub for cooperative matrices. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFSub %float_coop_matrix %undef_float_coop_matrix %undef_float_coop_matrix\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 27: Don't fold OpIMul for cooperative matrices. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFMul %float_coop_matrix %undef_float_coop_matrix %undef_float_coop_matrix\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 28: Don't fold OpSDiv for cooperative matrices. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFDiv %float_coop_matrix %undef_float_coop_matrix %undef_float_coop_matrix\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 29: Don't fold OpMatrixTimesScalar for cooperative matrices. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpMatrixTimesScalar %float_coop_matrix %undef_float_coop_matrix %float_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0) )); INSTANTIATE_TEST_SUITE_P(DoubleRedundantFoldingTest, GeneralInstructionFoldingTest, ::testing::Values( // Test case 0: Don't fold n + 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_double Function\n" + "%3 = OpLoad %double %n\n" + "%2 = OpFAdd %double %3 %double_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 1: Don't fold n - 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_double Function\n" + "%3 = OpLoad %double %n\n" + "%2 = OpFSub %double %3 %double_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 2: Don't fold n * 2.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_double Function\n" + "%3 = OpLoad %double %n\n" + "%2 = OpFMul %double %3 %double_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 3: Fold n + 0.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_double Function\n" + "%3 = OpLoad %double %n\n" + "%2 = OpFAdd %double %3 %double_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3), // Test case 4: Fold 0.0 + n InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_double Function\n" + "%3 = OpLoad %double %n\n" + "%2 = OpFAdd %double %double_0 %3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3), // Test case 5: Fold n - 0.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_double Function\n" + "%3 = OpLoad %double %n\n" + "%2 = OpFSub %double %3 %double_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3), // Test case 6: Fold n * 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_double Function\n" + "%3 = OpLoad %double %n\n" + "%2 = OpFMul %double %3 %double_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3), // Test case 7: Fold 1.0 * n InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_double Function\n" + "%3 = OpLoad %double %n\n" + "%2 = OpFMul %double %double_1 %3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3), // Test case 8: Fold n / 1.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_double Function\n" + "%3 = OpLoad %double %n\n" + "%2 = OpFDiv %double %3 %double_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3), // Test case 9: Fold n * 0.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_double Function\n" + "%3 = OpLoad %double %n\n" + "%2 = OpFMul %double %3 %105\n" + "OpReturn\n" + "OpFunctionEnd", 2, DOUBLE_0_ID), // Test case 10: Fold 0.0 * n InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_double Function\n" + "%3 = OpLoad %double %n\n" + "%2 = OpFMul %double %105 %3\n" + "OpReturn\n" + "OpFunctionEnd", 2, DOUBLE_0_ID), // Test case 11: Fold 0.0 / n InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_double Function\n" + "%3 = OpLoad %double %n\n" + "%2 = OpFDiv %double %105 %3\n" + "OpReturn\n" + "OpFunctionEnd", 2, DOUBLE_0_ID), // Test case 12: Don't fold mix(a, b, 2.0) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%a = OpVariable %_ptr_double Function\n" + "%b = OpVariable %_ptr_double Function\n" + "%3 = OpLoad %double %a\n" + "%4 = OpLoad %double %b\n" + "%2 = OpExtInst %double %1 FMix %3 %4 %double_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 13: Fold mix(a, b, 0.0) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%a = OpVariable %_ptr_double Function\n" + "%b = OpVariable %_ptr_double Function\n" + "%3 = OpLoad %double %a\n" + "%4 = OpLoad %double %b\n" + "%2 = OpExtInst %double %1 FMix %3 %4 %double_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3), // Test case 14: Fold mix(a, b, 1.0) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%a = OpVariable %_ptr_double Function\n" + "%b = OpVariable %_ptr_double Function\n" + "%3 = OpLoad %double %a\n" + "%4 = OpLoad %double %b\n" + "%2 = OpExtInst %double %1 FMix %3 %4 %double_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, 4) )); INSTANTIATE_TEST_SUITE_P(FloatVectorRedundantFoldingTest, GeneralInstructionFoldingTest, ::testing::Values( // Test case 0: Don't fold a * vec4(0.0, 0.0, 0.0, 1.0) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_v4float Function\n" + "%3 = OpLoad %v4float %n\n" + "%2 = OpFMul %v4float %3 %v4float_0_0_0_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 1: Fold a * vec4(0.0, 0.0, 0.0, 0.0) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_v4float Function\n" + "%3 = OpLoad %v4float %n\n" + "%2 = OpFMul %v4float %3 %106\n" + "OpReturn\n" + "OpFunctionEnd", 2, VEC4_0_ID), // Test case 2: Fold a * vec4(1.0, 1.0, 1.0, 1.0) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_v4float Function\n" + "%3 = OpLoad %v4float %n\n" + "%2 = OpFMul %v4float %3 %v4float_1_1_1_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3) )); INSTANTIATE_TEST_SUITE_P(DoubleVectorRedundantFoldingTest, GeneralInstructionFoldingTest, ::testing::Values( // Test case 0: Don't fold a * vec4(0.0, 0.0, 0.0, 1.0) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_v4double Function\n" + "%3 = OpLoad %v4double %n\n" + "%2 = OpFMul %v4double %3 %v4double_0_0_0_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 1: Fold a * vec4(0.0, 0.0, 0.0, 0.0) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_v4double Function\n" + "%3 = OpLoad %v4double %n\n" + "%2 = OpFMul %v4double %3 %106\n" + "OpReturn\n" + "OpFunctionEnd", 2, DVEC4_0_ID), // Test case 2: Fold a * vec4(1.0, 1.0, 1.0, 1.0) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_v4double Function\n" + "%3 = OpLoad %v4double %n\n" + "%2 = OpFMul %v4double %3 %v4double_1_1_1_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3) )); INSTANTIATE_TEST_SUITE_P(IntegerRedundantFoldingTest, GeneralInstructionFoldingTest, ::testing::Values( // Test case 0: Don't fold n + 1 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%3 = OpLoad %uint %n\n" + "%2 = OpIAdd %uint %3 %uint_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 1: Don't fold 1 + n InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%3 = OpLoad %uint %n\n" + "%2 = OpIAdd %uint %uint_1 %3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 2: Fold n + 0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%3 = OpLoad %uint %n\n" + "%2 = OpIAdd %uint %3 %uint_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3), // Test case 3: Fold 0 + n InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_uint Function\n" + "%3 = OpLoad %uint %n\n" + "%2 = OpIAdd %uint %uint_0 %3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3), // Test case 4: Don't fold n + (1,0) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_v2int Function\n" + "%3 = OpLoad %v2int %n\n" + "%2 = OpIAdd %v2int %3 %v2int_1_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 5: Don't fold (1,0) + n InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_v2int Function\n" + "%3 = OpLoad %v2int %n\n" + "%2 = OpIAdd %v2int %v2int_1_0 %3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 6: Fold n + (0,0) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_v2int Function\n" + "%3 = OpLoad %v2int %n\n" + "%2 = OpIAdd %v2int %3 %v2int_0_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3), // Test case 7: Fold (0,0) + n InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_v2int Function\n" + "%3 = OpLoad %v2int %n\n" + "%2 = OpIAdd %v2int %v2int_0_0 %3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3), // Test case 8: Don't fold because of undefined value. Using 4294967295 // means that entry is undefined. We do not expect it to ever happen, so // not worth folding. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpVectorShuffle %v2int %v2int_null %v2int_2_3 4294967295 3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 9: Don't fold because of undefined value. Using 4294967295 // means that entry is undefined. We do not expect it to ever happen, so // not worth folding. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpVectorShuffle %v2int %v2int_null %v2int_2_3 0 4294967295 \n" + "OpReturn\n" + "OpFunctionEnd", 2, 0) )); INSTANTIATE_TEST_SUITE_P(ClampAndCmpLHS, GeneralInstructionFoldingTest, ::testing::Values( // Test case 0: Don't Fold 0.0 < clamp(-1, 1) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_n1 %float_1\n" + "%2 = OpFUnordLessThan %bool %float_0 %clamp\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 1: Don't Fold 0.0 < clamp(-1, 1) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_n1 %float_1\n" + "%2 = OpFOrdLessThan %bool %float_0 %clamp\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 2: Don't Fold 0.0 <= clamp(-1, 1) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_n1 %float_1\n" + "%2 = OpFUnordLessThanEqual %bool %float_0 %clamp\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 3: Don't Fold 0.0 <= clamp(-1, 1) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_n1 %float_1\n" + "%2 = OpFOrdLessThanEqual %bool %float_0 %clamp\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 4: Don't Fold 0.0 > clamp(-1, 1) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_n1 %float_1\n" + "%2 = OpFUnordGreaterThan %bool %float_0 %clamp\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 5: Don't Fold 0.0 > clamp(-1, 1) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_n1 %float_1\n" + "%2 = OpFOrdGreaterThan %bool %float_0 %clamp\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 6: Don't Fold 0.0 >= clamp(-1, 1) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_n1 %float_1\n" + "%2 = OpFUnordGreaterThanEqual %bool %float_0 %clamp\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 7: Don't Fold 0.0 >= clamp(-1, 1) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_n1 %float_1\n" + "%2 = OpFOrdGreaterThanEqual %bool %float_0 %clamp\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 8: Don't Fold 0.0 < clamp(0, 1) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_0 %float_1\n" + "%2 = OpFUnordLessThan %bool %float_0 %clamp\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 9: Don't Fold 0.0 < clamp(0, 1) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_0 %float_1\n" + "%2 = OpFOrdLessThan %bool %float_0 %clamp\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 10: Don't Fold 0.0 > clamp(-1, 0) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_n1 %float_0\n" + "%2 = OpFUnordGreaterThan %bool %float_0 %clamp\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 11: Don't Fold 0.0 > clamp(-1, 0) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_n1 %float_0\n" + "%2 = OpFOrdGreaterThan %bool %float_0 %clamp\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0) )); INSTANTIATE_TEST_SUITE_P(ClampAndCmpRHS, GeneralInstructionFoldingTest, ::testing::Values( // Test case 0: Don't Fold clamp(-1, 1) < 0.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_n1 %float_1\n" + "%2 = OpFUnordLessThan %bool %clamp %float_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 1: Don't Fold clamp(-1, 1) < 0.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_n1 %float_1\n" + "%2 = OpFOrdLessThan %bool %clamp %float_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 2: Don't Fold clamp(-1, 1) <= 0.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_n1 %float_1\n" + "%2 = OpFUnordLessThanEqual %bool %clamp %float_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 3: Don't Fold clamp(-1, 1) <= 0.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_n1 %float_1\n" + "%2 = OpFOrdLessThanEqual %bool %clamp %float_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 4: Don't Fold clamp(-1, 1) > 0.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_n1 %float_1\n" + "%2 = OpFUnordGreaterThan %bool %clamp %float_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 5: Don't Fold clamp(-1, 1) > 0.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_n1 %float_1\n" + "%2 = OpFOrdGreaterThan %bool %clamp %float_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 6: Don't Fold clamp(-1, 1) >= 0.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_n1 %float_1\n" + "%2 = OpFUnordGreaterThanEqual %bool %clamp %float_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 7: Don't Fold clamp(-1, 1) >= 0.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_n1 %float_1\n" + "%2 = OpFOrdGreaterThanEqual %bool %clamp %float_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 8: Don't Fold clamp(-1, 0) < 0.0 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_n1 %float_0\n" + "%2 = OpFUnordLessThan %bool %clamp %float_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 9: Don't Fold clamp(0, 1) < 1 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_0 %float_1\n" + "%2 = OpFOrdLessThan %bool %clamp %float_1\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 10: Don't Fold clamp(-1, 0) > -1 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_n1 %float_0\n" + "%2 = OpFUnordGreaterThan %bool %clamp %float_n1\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 11: Don't Fold clamp(-1, 0) > -1 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%ld = OpLoad %float %n\n" + "%clamp = OpExtInst %float %1 FClamp %ld %float_n1 %float_0\n" + "%2 = OpFOrdGreaterThan %bool %clamp %float_n1\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0) )); INSTANTIATE_TEST_SUITE_P(FToIConstantFoldingTest, IntegerInstructionFoldingTest, ::testing::Values( // Test case 0: Fold int(3.0) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpConvertFToS %int %float_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3), // Test case 1: Fold uint(3.0) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpConvertFToU %int %float_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3) )); INSTANTIATE_TEST_SUITE_P(IToFConstantFoldingTest, FloatInstructionFoldingTest, ::testing::Values( // Test case 0: Fold float(3) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpConvertSToF %float %int_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3.0), // Test case 1: Fold float(3u) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpConvertUToF %float %uint_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3.0) )); // clang-format on using ToNegateFoldingTest = ::testing::TestWithParam>; TEST_P(ToNegateFoldingTest, Case) { const auto& tc = GetParam(); std::unique_ptr context; Instruction* inst; std::tie(context, inst) = FoldInstruction(tc.test_body, tc.id_to_fold, SPV_ENV_UNIVERSAL_1_1); EXPECT_TRUE((inst == nullptr) == (tc.expected_result == 0)); if (inst != nullptr) { EXPECT_EQ(inst->opcode(), spv::Op::OpFNegate); EXPECT_EQ(inst->GetSingleWordInOperand(0), tc.expected_result); } } // clang-format off INSTANTIATE_TEST_SUITE_P(FloatRedundantSubFoldingTest, ToNegateFoldingTest, ::testing::Values( // Test case 0: Don't fold 1.0 - n InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%3 = OpLoad %float %n\n" + "%2 = OpFSub %float %float_1 %3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 1: Fold 0.0 - n InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_float Function\n" + "%3 = OpLoad %float %n\n" + "%2 = OpFSub %float %float_0 %3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3), // Test case 2: Don't fold (0,0,0,1) - n InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_v4float Function\n" + "%3 = OpLoad %v4float %n\n" + "%2 = OpFSub %v4float %v4float_0_0_0_1 %3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 3: Fold (0,0,0,0) - n InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_v4float Function\n" + "%3 = OpLoad %v4float %n\n" + "%2 = OpFSub %v4float %v4float_0_0_0_0 %3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3) )); INSTANTIATE_TEST_SUITE_P(DoubleRedundantSubFoldingTest, ToNegateFoldingTest, ::testing::Values( // Test case 0: Don't fold 1.0 - n InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_double Function\n" + "%3 = OpLoad %double %n\n" + "%2 = OpFSub %double %double_1 %3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 1: Fold 0.0 - n InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_double Function\n" + "%3 = OpLoad %double %n\n" + "%2 = OpFSub %double %double_0 %3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3), // Test case 2: Don't fold (0,0,0,1) - n InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_v4double Function\n" + "%3 = OpLoad %v4double %n\n" + "%2 = OpFSub %v4double %v4double_0_0_0_1 %3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 0), // Test case 3: Fold (0,0,0,0) - n InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_v4double Function\n" + "%3 = OpLoad %v4double %n\n" + "%2 = OpFSub %v4double %v4double_0_0_0_0 %3\n" + "OpReturn\n" + "OpFunctionEnd", 2, 3) )); using MatchingInstructionFoldingTest = ::testing::TestWithParam>; TEST_P(MatchingInstructionFoldingTest, Case) { const auto& tc = GetParam(); std::unique_ptr context; Instruction* inst; std::tie(context, inst) = FoldInstruction(tc.test_body, tc.id_to_fold,SPV_ENV_UNIVERSAL_1_1); EXPECT_EQ(inst != nullptr, tc.expected_result); if (inst != nullptr) { Match(tc.test_body, context.get()); } } INSTANTIATE_TEST_SUITE_P(RedundantIntegerMatching, MatchingInstructionFoldingTest, ::testing::Values( // Test case 0: Fold 0 + n (change sign) InstructionFoldingCase( Header() + "; CHECK: [[uint:%\\w+]] = OpTypeInt 32 0\n" + "; CHECK: %2 = OpBitcast [[uint]] %3\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%3 = OpLoad %uint %n\n" + "%2 = OpIAdd %uint %int_0 %3\n" + "OpReturn\n" + "OpFunctionEnd\n", 2, true), // Test case 0: Fold 0 + n (change sign) InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32 1\n" + "; CHECK: %2 = OpBitcast [[int]] %3\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%3 = OpLoad %int %n\n" + "%2 = OpIAdd %int %uint_0 %3\n" + "OpReturn\n" + "OpFunctionEnd\n", 2, true) )); INSTANTIATE_TEST_SUITE_P(MergeNegateTest, MatchingInstructionFoldingTest, ::testing::Values( // Test case 0: fold consecutive fnegate // -(-x) = x InstructionFoldingCase( Header() + "; CHECK: [[ld:%\\w+]] = OpLoad [[float:%\\w+]]\n" + "; CHECK: %4 = OpCopyObject [[float]] [[ld]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFNegate %float %2\n" + "%4 = OpFNegate %float %3\n" + "OpReturn\n" + "OpFunctionEnd", 4, true), // Test case 1: fold fnegate(fmul with const). // -(x * 2.0) = x * -2.0 InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_n2:%\\w+]] = OpConstant [[float]] -2{{[[:space:]]}}\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %4 = OpFMul [[float]] [[ld]] [[float_n2]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFMul %float %2 %float_2\n" + "%4 = OpFNegate %float %3\n" + "OpReturn\n" + "OpFunctionEnd", 4, true), // Test case 2: fold fnegate(fmul with const). // -(2.0 * x) = x * 2.0 InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_n2:%\\w+]] = OpConstant [[float]] -2{{[[:space:]]}}\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %4 = OpFMul [[float]] [[ld]] [[float_n2]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFMul %float %float_2 %2\n" + "%4 = OpFNegate %float %3\n" + "OpReturn\n" + "OpFunctionEnd", 4, true), // Test case 3: fold fnegate(fdiv with const). // -(x / 2.0) = x * -0.5 InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_n0p5:%\\w+]] = OpConstant [[float]] -0.5\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %4 = OpFMul [[float]] [[ld]] [[float_n0p5]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFDiv %float %2 %float_2\n" + "%4 = OpFNegate %float %3\n" + "OpReturn\n" + "OpFunctionEnd", 4, true), // Test case 4: fold fnegate(fdiv with const). // -(2.0 / x) = -2.0 / x InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_n2:%\\w+]] = OpConstant [[float]] -2{{[[:space:]]}}\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %4 = OpFDiv [[float]] [[float_n2]] [[ld]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFDiv %float %float_2 %2\n" + "%4 = OpFNegate %float %3\n" + "OpReturn\n" + "OpFunctionEnd", 4, true), // Test case 5: fold fnegate(fadd with const). // -(2.0 + x) = -2.0 - x InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_n2:%\\w+]] = OpConstant [[float]] -2{{[[:space:]]}}\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %4 = OpFSub [[float]] [[float_n2]] [[ld]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFAdd %float %float_2 %2\n" + "%4 = OpFNegate %float %3\n" + "OpReturn\n" + "OpFunctionEnd", 4, true), // Test case 6: fold fnegate(fadd with const). // -(x + 2.0) = -2.0 - x InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_n2:%\\w+]] = OpConstant [[float]] -2{{[[:space:]]}}\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %4 = OpFSub [[float]] [[float_n2]] [[ld]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFAdd %float %2 %float_2\n" + "%4 = OpFNegate %float %3\n" + "OpReturn\n" + "OpFunctionEnd", 4, true), // Test case 7: fold fnegate(fsub with const). // -(2.0 - x) = x - 2.0 InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_2:%\\w+]] = OpConstant [[float]] 2\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %4 = OpFSub [[float]] [[ld]] [[float_2]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFSub %float %float_2 %2\n" + "%4 = OpFNegate %float %3\n" + "OpReturn\n" + "OpFunctionEnd", 4, true), // Test case 8: fold fnegate(fsub with const). // -(x - 2.0) = 2.0 - x InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_2:%\\w+]] = OpConstant [[float]] 2\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %4 = OpFSub [[float]] [[float_2]] [[ld]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFSub %float %2 %float_2\n" + "%4 = OpFNegate %float %3\n" + "OpReturn\n" + "OpFunctionEnd", 4, true), // Test case 9: fold consecutive snegate // -(-x) = x InstructionFoldingCase( Header() + "; CHECK: [[ld:%\\w+]] = OpLoad [[int:%\\w+]]\n" + "; CHECK: %4 = OpCopyObject [[int]] [[ld]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %var\n" + "%3 = OpSNegate %int %2\n" + "%4 = OpSNegate %int %3\n" + "OpReturn\n" + "OpFunctionEnd", 4, true), // Test case 10: fold consecutive vector negate // -(-x) = x InstructionFoldingCase( Header() + "; CHECK: [[ld:%\\w+]] = OpLoad [[v2float:%\\w+]]\n" + "; CHECK: %4 = OpCopyObject [[v2float]] [[ld]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_v2float Function\n" + "%2 = OpLoad %v2float %var\n" + "%3 = OpFNegate %v2float %2\n" + "%4 = OpFNegate %v2float %3\n" + "OpReturn\n" + "OpFunctionEnd", 4, true), // Test case 11: fold snegate(iadd with const). // -(2 + x) = -2 - x InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32 1\n" + "; CHECK: OpConstant [[int]] -2147483648\n" + "; CHECK: [[int_n2:%\\w+]] = OpConstant [[int]] -2{{[[:space:]]}}\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[int]]\n" + "; CHECK: %4 = OpISub [[int]] [[int_n2]] [[ld]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %var\n" + "%3 = OpIAdd %int %int_2 %2\n" + "%4 = OpSNegate %int %3\n" + "OpReturn\n" + "OpFunctionEnd", 4, true), // Test case 12: fold snegate(iadd with const). // -(x + 2) = -2 - x InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32 1\n" + "; CHECK: OpConstant [[int]] -2147483648\n" + "; CHECK: [[int_n2:%\\w+]] = OpConstant [[int]] -2{{[[:space:]]}}\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[int]]\n" + "; CHECK: %4 = OpISub [[int]] [[int_n2]] [[ld]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %var\n" + "%3 = OpIAdd %int %2 %int_2\n" + "%4 = OpSNegate %int %3\n" + "OpReturn\n" + "OpFunctionEnd", 4, true), // Test case 13: fold snegate(isub with const). // -(2 - x) = x - 2 InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32 1\n" + "; CHECK: [[int_2:%\\w+]] = OpConstant [[int]] 2\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[int]]\n" + "; CHECK: %4 = OpISub [[int]] [[ld]] [[int_2]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %var\n" + "%3 = OpISub %int %int_2 %2\n" + "%4 = OpSNegate %int %3\n" + "OpReturn\n" + "OpFunctionEnd", 4, true), // Test case 14: fold snegate(isub with const). // -(x - 2) = 2 - x InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32 1\n" + "; CHECK: [[int_2:%\\w+]] = OpConstant [[int]] 2\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[int]]\n" + "; CHECK: %4 = OpISub [[int]] [[int_2]] [[ld]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %var\n" + "%3 = OpISub %int %2 %int_2\n" + "%4 = OpSNegate %int %3\n" + "OpReturn\n" + "OpFunctionEnd", 4, true), // Test case 15: fold snegate(iadd with const). // -(x + 2) = -2 - x InstructionFoldingCase( Header() + "; CHECK: [[long:%\\w+]] = OpTypeInt 64 1\n" + "; CHECK: [[long_n2:%\\w+]] = OpConstant [[long]] -2{{[[:space:]]}}\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[long]]\n" + "; CHECK: %4 = OpISub [[long]] [[long_n2]] [[ld]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_long Function\n" + "%2 = OpLoad %long %var\n" + "%3 = OpIAdd %long %2 %long_2\n" + "%4 = OpSNegate %long %3\n" + "OpReturn\n" + "OpFunctionEnd", 4, true), // Test case 16: fold snegate(isub with const). // -(2 - x) = x - 2 InstructionFoldingCase( Header() + "; CHECK: [[long:%\\w+]] = OpTypeInt 64 1\n" + "; CHECK: [[long_2:%\\w+]] = OpConstant [[long]] 2\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[long]]\n" + "; CHECK: %4 = OpISub [[long]] [[ld]] [[long_2]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_long Function\n" + "%2 = OpLoad %long %var\n" + "%3 = OpISub %long %long_2 %2\n" + "%4 = OpSNegate %long %3\n" + "OpReturn\n" + "OpFunctionEnd", 4, true), // Test case 17: fold snegate(isub with const). // -(x - 2) = 2 - x InstructionFoldingCase( Header() + "; CHECK: [[long:%\\w+]] = OpTypeInt 64 1\n" + "; CHECK: [[long_2:%\\w+]] = OpConstant [[long]] 2\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[long]]\n" + "; CHECK: %4 = OpISub [[long]] [[long_2]] [[ld]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_long Function\n" + "%2 = OpLoad %long %var\n" + "%3 = OpISub %long %2 %long_2\n" + "%4 = OpSNegate %long %3\n" + "OpReturn\n" + "OpFunctionEnd", 4, true), // Test case 18: fold -vec4(-1.0, 2.0, 1.0, 3.0) InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[v4float:%\\w+]] = OpTypeVector [[float]] 4{{[[:space:]]}}\n" + "; CHECK: [[float_n1:%\\w+]] = OpConstant [[float]] -1{{[[:space:]]}}\n" + "; CHECK: [[float_1:%\\w+]] = OpConstant [[float]] 1{{[[:space:]]}}\n" + "; CHECK: [[float_n2:%\\w+]] = OpConstant [[float]] -2{{[[:space:]]}}\n" + "; CHECK: [[float_n3:%\\w+]] = OpConstant [[float]] -3{{[[:space:]]}}\n" + "; CHECK: [[v4float_1_n2_n1_n3:%\\w+]] = OpConstantComposite [[v4float]] [[float_1]] [[float_n2]] [[float_n1]] [[float_n3]]\n" + "; CHECK: %2 = OpCopyObject [[v4float]] [[v4float_1_n2_n1_n3]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFNegate %v4float %v4float_n1_2_1_3\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 19: fold vector fnegate with null InstructionFoldingCase( Header() + "; CHECK: [[double:%\\w+]] = OpTypeFloat 64\n" + "; CHECK: [[v2double:%\\w+]] = OpTypeVector [[double]] 2\n" + "; CHECK: [[double_n0:%\\w+]] = OpConstant [[double]] -0\n" + "; CHECK: [[v2double_0_0:%\\w+]] = OpConstantComposite [[v2double]] [[double_n0]] [[double_n0]]\n" + "; CHECK: %2 = OpCopyObject [[v2double]] [[v2double_0_0]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpFNegate %v2double %v2double_null\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 20: fold snegate with OpIMul. // -(x * 2) = x * -2 InstructionFoldingCase( Header() + "; CHECK: [[long:%\\w+]] = OpTypeInt 64 1\n" + "; CHECK: [[long_n2:%\\w+]] = OpConstant [[long]] -2\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[long]]\n" + "; CHECK: %4 = OpIMul [[long]] [[ld]] [[long_n2]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_long Function\n" + "%2 = OpLoad %long %var\n" + "%3 = OpIMul %long %2 %long_2\n" + "%4 = OpSNegate %long %3\n" + "OpReturn\n" + "OpFunctionEnd", 4, true), // Test case 21: fold snegate with OpIMul. // -(x * 2) = x * -2 InstructionFoldingCase( Header() + "; CHECK-DAG: [[int:%\\w+]] = OpTypeInt 32 1\n" + "; CHECK-DAG: [[uint:%\\w+]] = OpTypeInt 32 0\n" + "; CHECK: [[uint_n2:%\\w+]] = OpConstant [[uint]] 4294967294\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[int]]\n" + "; CHECK: %4 = OpIMul [[int]] [[ld]] [[uint_n2]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %var\n" + "%3 = OpIMul %int %2 %uint_2\n" + "%4 = OpSNegate %int %3\n" + "OpReturn\n" + "OpFunctionEnd", 4, true), // Test case 22: fold snegate with OpIMul. // -(-24 * x) = x * 24 InstructionFoldingCase( Header() + "; CHECK-DAG: [[int:%\\w+]] = OpTypeInt 32 1\n" + "; CHECK: [[int_24:%\\w+]] = OpConstant [[int]] 24\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[int]]\n" + "; CHECK: %4 = OpIMul [[int]] [[ld]] [[int_24]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %var\n" + "%3 = OpIMul %int %int_n24 %2\n" + "%4 = OpSNegate %int %3\n" + "OpReturn\n" + "OpFunctionEnd", 4, true), // Test case 23: fold snegate with OpIMul with UINT_MAX // -(UINT_MAX * x) = x InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32 1\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[int]]\n" + "; CHECK: %4 = OpCopyObject [[int]] [[ld]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %var\n" + "%3 = OpIMul %int %uint_max %2\n" + "%4 = OpSNegate %int %3\n" + "OpReturn\n" + "OpFunctionEnd", 4, true), // Test case 24: fold snegate with OpIMul using -INT_MAX // -(x * 2147483649u) = x * 2147483647u InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32 1\n" + "; CHECK: [[uint:%\\w+]] = OpTypeInt 32 0\n" + "; CHECK: [[uint_2147483647:%\\w+]] = OpConstant [[uint]] 2147483647\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[int]]\n" + "; CHECK: %4 = OpIMul [[int]] [[ld]] [[uint_2147483647]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %var\n" + "%3 = OpIMul %int %2 %uint_2147483649\n" + "%4 = OpSNegate %int %3\n" + "OpReturn\n" + "OpFunctionEnd", 4, true), // Test case 25: fold snegate with OpSDiv (long). // -(x / 2) = x / -2 InstructionFoldingCase( Header() + "; CHECK: [[long:%\\w+]] = OpTypeInt 64 1\n" + "; CHECK: [[long_n2:%\\w+]] = OpConstant [[long]] -2\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[long]]\n" + "; CHECK: %4 = OpSDiv [[long]] [[ld]] [[long_n2]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_long Function\n" + "%2 = OpLoad %long %var\n" + "%3 = OpSDiv %long %2 %long_2\n" + "%4 = OpSNegate %long %3\n" + "OpReturn\n" + "OpFunctionEnd", 4, true), // Test case 26: fold snegate with OpSDiv (int). // -(x / 2) = x / -2 InstructionFoldingCase( Header() + "; CHECK-DAG: [[int:%\\w+]] = OpTypeInt 32 1\n" + "; CHECK-DAG: [[uint:%\\w+]] = OpTypeInt 32 0\n" + "; CHECK: [[uint_n2:%\\w+]] = OpConstant [[uint]] 4294967294\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[int]]\n" + "; CHECK: %4 = OpSDiv [[int]] [[ld]] [[uint_n2]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %var\n" + "%3 = OpSDiv %int %2 %uint_2\n" + "%4 = OpSNegate %int %3\n" + "OpReturn\n" + "OpFunctionEnd", 4, true), // Test case 27: fold snegate with OpSDiv. // -(-24 / x) = 24 / x InstructionFoldingCase( Header() + "; CHECK-DAG: [[int:%\\w+]] = OpTypeInt 32 1\n" + "; CHECK: [[int_24:%\\w+]] = OpConstant [[int]] 24\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[int]]\n" + "; CHECK: %4 = OpSDiv [[int]] [[int_24]] [[ld]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %var\n" + "%3 = OpSDiv %int %int_n24 %2\n" + "%4 = OpSNegate %int %3\n" + "OpReturn\n" + "OpFunctionEnd", 4, true), // Test case 28: fold snegate with OpSDiv with UINT_MAX // -(UINT_MAX / x) = (1 / x) InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32 1\n" + "; CHECK: [[uint:%\\w+]] = OpTypeInt 32 0\n" + "; CHECK: [[uint_1:%\\w+]] = OpConstant [[uint]] 1\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[int]]\n" + "; CHECK: %4 = OpSDiv [[int]] [[uint_1]] [[ld]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %var\n" + "%3 = OpSDiv %int %uint_max %2\n" + "%4 = OpSNegate %int %3\n" + "OpReturn\n" + "OpFunctionEnd", 4, true), // Test case 29: fold snegate with OpSDiv using -INT_MAX // -(x / 2147483647u) = x / 2147483647 InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32 1\n" + "; CHECK: [[uint:%\\w+]] = OpTypeInt 32 0\n" + "; CHECK: [[uint_2147483647:%\\w+]] = OpConstant [[uint]] 2147483647\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[int]]\n" + "; CHECK: %4 = OpSDiv [[int]] [[ld]] [[uint_2147483647]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %var\n" + "%3 = OpSDiv %int %2 %uint_2147483649\n" + "%4 = OpSNegate %int %3\n" + "OpReturn\n" + "OpFunctionEnd", 4, true), // Test case 30: Don't fold snegate int OpUDiv. The operands are interpreted // as unsigned, so negating an operand is not the same a negating the // result. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %var\n" + "%3 = OpUDiv %int %2 %uint_1\n" + "%4 = OpSNegate %int %3\n" + "OpReturn\n" + "OpFunctionEnd", 4, false) )); INSTANTIATE_TEST_SUITE_P(ReciprocalFDivTest, MatchingInstructionFoldingTest, ::testing::Values( // Test case 0: scalar reicprocal // x / 0.5 = x * 2.0 InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_2:%\\w+]] = OpConstant [[float]] 2\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %3 = OpFMul [[float]] [[ld]] [[float_2]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFDiv %float %2 %float_0p5\n" + "OpReturn\n" + "OpFunctionEnd\n", 3, true), // Test case 1: Unfoldable InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_0:%\\w+]] = OpConstant [[float]] 0\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %3 = OpFDiv [[float]] [[ld]] [[float_0]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFDiv %float %2 %104\n" + "OpReturn\n" + "OpFunctionEnd\n", 3, false), // Test case 2: Vector reciprocal // x / {2.0, 0.5} = x * {0.5, 2.0} InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[v2float:%\\w+]] = OpTypeVector [[float]] 2\n" + "; CHECK: [[float_2:%\\w+]] = OpConstant [[float]] 2\n" + "; CHECK: [[float_0p5:%\\w+]] = OpConstant [[float]] 0.5\n" + "; CHECK: [[v2float_0p5_2:%\\w+]] = OpConstantComposite [[v2float]] [[float_0p5]] [[float_2]]\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[v2float]]\n" + "; CHECK: %3 = OpFMul [[v2float]] [[ld]] [[v2float_0p5_2]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_v2float Function\n" + "%2 = OpLoad %v2float %var\n" + "%3 = OpFDiv %v2float %2 %v2float_2_0p5\n" + "OpReturn\n" + "OpFunctionEnd\n", 3, true), // Test case 3: double reciprocal // x / 2.0 = x * 0.5 InstructionFoldingCase( Header() + "; CHECK: [[double:%\\w+]] = OpTypeFloat 64\n" + "; CHECK: [[double_0p5:%\\w+]] = OpConstant [[double]] 0.5\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[double]]\n" + "; CHECK: %3 = OpFMul [[double]] [[ld]] [[double_0p5]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_double Function\n" + "%2 = OpLoad %double %var\n" + "%3 = OpFDiv %double %2 %double_2\n" + "OpReturn\n" + "OpFunctionEnd\n", 3, true), // Test case 4: don't fold x / 0. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_v2float Function\n" + "%2 = OpLoad %v2float %var\n" + "%3 = OpFDiv %v2float %2 %v2float_null\n" + "OpReturn\n" + "OpFunctionEnd\n", 3, false) )); INSTANTIATE_TEST_SUITE_P(MergeMulTest, MatchingInstructionFoldingTest, ::testing::Values( // Test case 0: fold consecutive fmuls // (x * 3.0) * 2.0 = x * 6.0 InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_6:%\\w+]] = OpConstant [[float]] 6\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %4 = OpFMul [[float]] [[ld]] [[float_6]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFMul %float %2 %float_3\n" + "%4 = OpFMul %float %3 %float_2\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 1: fold consecutive fmuls // 2.0 * (x * 3.0) = x * 6.0 InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_6:%\\w+]] = OpConstant [[float]] 6\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %4 = OpFMul [[float]] [[ld]] [[float_6]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFMul %float %2 %float_3\n" + "%4 = OpFMul %float %float_2 %3\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 2: fold consecutive fmuls // (3.0 * x) * 2.0 = x * 6.0 InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_6:%\\w+]] = OpConstant [[float]] 6\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %4 = OpFMul [[float]] [[ld]] [[float_6]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFMul %float %float_3 %2\n" + "%4 = OpFMul %float %float_2 %3\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 3: fold vector fmul InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[v2float:%\\w+]] = OpTypeVector [[float]] 2\n" + "; CHECK: [[float_6:%\\w+]] = OpConstant [[float]] 6\n" + "; CHECK: [[v2float_6_6:%\\w+]] = OpConstantComposite [[v2float]] [[float_6]] [[float_6]]\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[v2float]]\n" + "; CHECK: %4 = OpFMul [[v2float]] [[ld]] [[v2float_6_6]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_v2float Function\n" + "%2 = OpLoad %v2float %var\n" + "%3 = OpFMul %v2float %2 %v2float_2_3\n" + "%4 = OpFMul %v2float %3 %v2float_3_2\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 4: fold double fmuls // (x * 3.0) * 2.0 = x * 6.0 InstructionFoldingCase( Header() + "; CHECK: [[double:%\\w+]] = OpTypeFloat 64\n" + "; CHECK: [[double_6:%\\w+]] = OpConstant [[double]] 6\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[double]]\n" + "; CHECK: %4 = OpFMul [[double]] [[ld]] [[double_6]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_double Function\n" + "%2 = OpLoad %double %var\n" + "%3 = OpFMul %double %2 %double_3\n" + "%4 = OpFMul %double %3 %double_2\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 5: fold 32 bit imuls // (x * 3) * 2 = x * 6 InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32 1\n" + "; CHECK: [[int_6:%\\w+]] = OpConstant [[int]] 6\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[int]]\n" + "; CHECK: %4 = OpIMul [[int]] [[ld]] [[int_6]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %var\n" + "%3 = OpIMul %int %2 %int_3\n" + "%4 = OpIMul %int %3 %int_2\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 6: fold 64 bit imuls // (x * 3) * 2 = x * 6 InstructionFoldingCase( Header() + "; CHECK: [[long:%\\w+]] = OpTypeInt 64\n" + "; CHECK: [[long_6:%\\w+]] = OpConstant [[long]] 6\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[long]]\n" + "; CHECK: %4 = OpIMul [[long]] [[ld]] [[long_6]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_long Function\n" + "%2 = OpLoad %long %var\n" + "%3 = OpIMul %long %2 %long_3\n" + "%4 = OpIMul %long %3 %long_2\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 7: merge vector integer mults InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32 1\n" + "; CHECK: [[v2int:%\\w+]] = OpTypeVector [[int]] 2\n" + "; CHECK: [[int_6:%\\w+]] = OpConstant [[int]] 6\n" + "; CHECK: [[v2int_6_6:%\\w+]] = OpConstantComposite [[v2int]] [[int_6]] [[int_6]]\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[v2int]]\n" + "; CHECK: %4 = OpIMul [[v2int]] [[ld]] [[v2int_6_6]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_v2int Function\n" + "%2 = OpLoad %v2int %var\n" + "%3 = OpIMul %v2int %2 %v2int_2_3\n" + "%4 = OpIMul %v2int %3 %v2int_3_2\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 8: merge fmul of fdiv // 2.0 * (2.0 / x) = 4.0 / x InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_4:%\\w+]] = OpConstant [[float]] 4\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %4 = OpFDiv [[float]] [[float_4]] [[ld]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFDiv %float %float_2 %2\n" + "%4 = OpFMul %float %float_2 %3\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 9: merge fmul of fdiv // (2.0 / x) * 2.0 = 4.0 / x InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_4:%\\w+]] = OpConstant [[float]] 4\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %4 = OpFDiv [[float]] [[float_4]] [[ld]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFDiv %float %float_2 %2\n" + "%4 = OpFMul %float %3 %float_2\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 10: Do not merge imul of sdiv // 4 * (x / 2) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %var\n" + "%3 = OpSDiv %int %2 %int_2\n" + "%4 = OpIMul %int %int_4 %3\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, false), // Test case 11: Do not merge imul of sdiv // (x / 2) * 4 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %var\n" + "%3 = OpSDiv %int %2 %int_2\n" + "%4 = OpIMul %int %3 %int_4\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, false), // Test case 12: Do not merge imul of udiv // 4 * (x / 2) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_uint Function\n" + "%2 = OpLoad %uint %var\n" + "%3 = OpUDiv %uint %2 %uint_2\n" + "%4 = OpIMul %uint %uint_4 %3\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, false), // Test case 13: Do not merge imul of udiv // (x / 2) * 4 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_uint Function\n" + "%2 = OpLoad %uint %var\n" + "%3 = OpUDiv %uint %2 %uint_2\n" + "%4 = OpIMul %uint %3 %uint_4\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, false), // Test case 14: Don't fold // (x / 3) * 4 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_uint Function\n" + "%2 = OpLoad %uint %var\n" + "%3 = OpUDiv %uint %2 %uint_3\n" + "%4 = OpIMul %uint %3 %uint_4\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, false), // Test case 15: merge vector fmul of fdiv // (x / {2,2}) * {4,4} = x * {2,2} InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[v2float:%\\w+]] = OpTypeVector [[float]] 2\n" + "; CHECK: [[float_2:%\\w+]] = OpConstant [[float]] 2\n" + "; CHECK: [[v2float_2_2:%\\w+]] = OpConstantComposite [[v2float]] [[float_2]] [[float_2]]\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[v2float]]\n" + "; CHECK: %4 = OpFMul [[v2float]] [[ld]] [[v2float_2_2]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_v2float Function\n" + "%2 = OpLoad %v2float %var\n" + "%3 = OpFDiv %v2float %2 %v2float_2_2\n" + "%4 = OpFMul %v2float %3 %v2float_4_4\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 16: merge vector imul of snegate // (-x) * {2,2} = x * {-2,-2} InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32 1\n" + "; CHECK: [[v2int:%\\w+]] = OpTypeVector [[int]] 2{{[[:space:]]}}\n" + "; CHECK: OpConstant [[int]] -2147483648{{[[:space:]]}}\n" + "; CHECK: [[int_n2:%\\w+]] = OpConstant [[int]] -2{{[[:space:]]}}\n" + "; CHECK: [[v2int_n2_n2:%\\w+]] = OpConstantComposite [[v2int]] [[int_n2]] [[int_n2]]\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[v2int]]\n" + "; CHECK: %4 = OpIMul [[v2int]] [[ld]] [[v2int_n2_n2]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_v2int Function\n" + "%2 = OpLoad %v2int %var\n" + "%3 = OpSNegate %v2int %2\n" + "%4 = OpIMul %v2int %3 %v2int_2_2\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 17: merge vector imul of snegate // {2,2} * (-x) = x * {-2,-2} InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32 1\n" + "; CHECK: [[v2int:%\\w+]] = OpTypeVector [[int]] 2{{[[:space:]]}}\n" + "; CHECK: OpConstant [[int]] -2147483648{{[[:space:]]}}\n" + "; CHECK: [[int_n2:%\\w+]] = OpConstant [[int]] -2{{[[:space:]]}}\n" + "; CHECK: [[v2int_n2_n2:%\\w+]] = OpConstantComposite [[v2int]] [[int_n2]] [[int_n2]]\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[v2int]]\n" + "; CHECK: %4 = OpIMul [[v2int]] [[ld]] [[v2int_n2_n2]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_v2int Function\n" + "%2 = OpLoad %v2int %var\n" + "%3 = OpSNegate %v2int %2\n" + "%4 = OpIMul %v2int %v2int_2_2 %3\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 18: Fold OpVectorTimesScalar // {4,4} = OpVectorTimesScalar v2float {2,2} 2 InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[v2float:%\\w+]] = OpTypeVector [[float]] 2\n" + "; CHECK: [[float_4:%\\w+]] = OpConstant [[float]] 4\n" + "; CHECK: [[v2float_4_4:%\\w+]] = OpConstantComposite [[v2float]] [[float_4]] [[float_4]]\n" + "; CHECK: %2 = OpCopyObject [[v2float]] [[v2float_4_4]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpVectorTimesScalar %v2float %v2float_2_2 %float_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 19: Fold OpVectorTimesScalar // {0,0} = OpVectorTimesScalar v2float v2float_null -1 InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[v2float:%\\w+]] = OpTypeVector [[float]] 2\n" + "; CHECK: [[v2float_null:%\\w+]] = OpConstantNull [[v2float]]\n" + "; CHECK: %2 = OpCopyObject [[v2float]] [[v2float_null]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpVectorTimesScalar %v2float %v2float_null %float_n1\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 20: Fold OpVectorTimesScalar // {4,4} = OpVectorTimesScalar v2double {2,2} 2 InstructionFoldingCase( Header() + "; CHECK: [[double:%\\w+]] = OpTypeFloat 64\n" + "; CHECK: [[v2double:%\\w+]] = OpTypeVector [[double]] 2\n" + "; CHECK: [[double_4:%\\w+]] = OpConstant [[double]] 4\n" + "; CHECK: [[v2double_4_4:%\\w+]] = OpConstantComposite [[v2double]] [[double_4]] [[double_4]]\n" + "; CHECK: %2 = OpCopyObject [[v2double]] [[v2double_4_4]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpVectorTimesScalar %v2double %v2double_2_2 %double_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 21: Fold OpVectorTimesScalar // {0,0} = OpVectorTimesScalar v2double {0,0} n InstructionFoldingCase( Header() + "; CHECK: [[double:%\\w+]] = OpTypeFloat 64\n" + "; CHECK: [[v2double:%\\w+]] = OpTypeVector [[double]] 2\n" + "; CHECK: {{%\\w+}} = OpConstant [[double]] 0\n" + "; CHECK: [[double_0:%\\w+]] = OpConstant [[double]] 0\n" + "; CHECK: [[v2double_0_0:%\\w+]] = OpConstantComposite [[v2double]] [[double_0]] [[double_0]]\n" + "; CHECK: %2 = OpCopyObject [[v2double]] [[v2double_0_0]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_double Function\n" + "%load = OpLoad %double %n\n" + "%2 = OpVectorTimesScalar %v2double %v2double_0_0 %load\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 22: Fold OpVectorTimesScalar // {0,0} = OpVectorTimesScalar v2double n 0 InstructionFoldingCase( Header() + "; CHECK: [[double:%\\w+]] = OpTypeFloat 64\n" + "; CHECK: [[v2double:%\\w+]] = OpTypeVector [[double]] 2\n" + "; CHECK: [[v2double_null:%\\w+]] = OpConstantNull [[v2double]]\n" + "; CHECK: %2 = OpCopyObject [[v2double]] [[v2double_null]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_v2double Function\n" + "%load = OpLoad %v2double %n\n" + "%2 = OpVectorTimesScalar %v2double %load %double_0\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 23: merge fmul of fdiv // x * (y / x) = y InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[ldx:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: [[ldy:%\\w+]] = OpLoad [[float]] [[y:%\\w+]]\n" + "; CHECK: %5 = OpCopyObject [[float]] [[ldy]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%x = OpVariable %_ptr_float Function\n" + "%y = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %x\n" + "%3 = OpLoad %float %y\n" + "%4 = OpFDiv %float %3 %2\n" + "%5 = OpFMul %float %2 %4\n" + "OpReturn\n" + "OpFunctionEnd\n", 5, true), // Test case 24: merge fmul of fdiv // (y / x) * x = y InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[ldx:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: [[ldy:%\\w+]] = OpLoad [[float]] [[y:%\\w+]]\n" + "; CHECK: %5 = OpCopyObject [[float]] [[ldy]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%x = OpVariable %_ptr_float Function\n" + "%y = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %x\n" + "%3 = OpLoad %float %y\n" + "%4 = OpFDiv %float %3 %2\n" + "%5 = OpFMul %float %4 %2\n" + "OpReturn\n" + "OpFunctionEnd\n", 5, true), // Test case 25: fold overflowing signed 32 bit imuls // (x * 1073741824) * 2 = x * int_min InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32\n" + "; CHECK: [[int_min:%\\w+]] = OpConstant [[int]] -2147483648\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[int]]\n" + "; CHECK: %4 = OpIMul [[int]] [[ld]] [[int_min]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %var\n" + "%3 = OpIMul %int %2 %int_1073741824\n" + "%4 = OpIMul %int %3 %int_2\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 26: fold overflowing signed 64 bit imuls // (x * 4611686018427387904) * 2 = x * long_min InstructionFoldingCase( Header() + "; CHECK: [[long:%\\w+]] = OpTypeInt 64\n" + "; CHECK: [[long_min:%\\w+]] = OpConstant [[long]] -9223372036854775808\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[long]]\n" + "; CHECK: %4 = OpIMul [[long]] [[ld]] [[long_min]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_long Function\n" + "%2 = OpLoad %long %var\n" + "%3 = OpIMul %long %2 %long_4611686018427387904\n" + "%4 = OpIMul %long %3 %long_2\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 27: fold overflowing 32 bit unsigned imuls // (x * 2147483649) * 2 = x * 2 InstructionFoldingCase( Header() + "; CHECK: [[uint:%\\w+]] = OpTypeInt 32 0\n" + "; CHECK: [[uint_2:%\\w+]] = OpConstant [[uint]] 2\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[uint]]\n" + "; CHECK: %4 = OpIMul [[uint]] [[ld]] [[uint_2]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_uint Function\n" + "%2 = OpLoad %uint %var\n" + "%3 = OpIMul %uint %2 %uint_2147483649\n" + "%4 = OpIMul %uint %3 %uint_2\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 28: fold overflowing 64 bit unsigned imuls // (x * 9223372036854775809) * 2 = x * 2 InstructionFoldingCase( Header() + "; CHECK: [[ulong:%\\w+]] = OpTypeInt 64 0\n" + "; CHECK: [[ulong_2:%\\w+]] = OpConstant [[ulong]] 2\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[ulong]]\n" + "; CHECK: %4 = OpIMul [[ulong]] [[ld]] [[ulong_2]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_ulong Function\n" + "%2 = OpLoad %ulong %var\n" + "%3 = OpIMul %ulong %2 %ulong_9223372036854775809\n" + "%4 = OpIMul %ulong %3 %ulong_2\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 29: fold underflowing signed 32 bit imuls // (x * (-858993459)) * 10 = x * 2 InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32\n" + "; CHECK: [[int_2:%\\w+]] = OpConstant [[int]] 2\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[int]]\n" + "; CHECK: %4 = OpIMul [[int]] [[ld]] [[int_2]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %var\n" + "%3 = OpIMul %int %2 %int_n858993459\n" + "%4 = OpIMul %int %3 %int_10\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 30: fold underflowing signed 64 bit imuls // (x * (-3689348814741910323)) * 10 = x * 2 InstructionFoldingCase( Header() + "; CHECK: [[long:%\\w+]] = OpTypeInt 64\n" + "; CHECK: [[long_2:%\\w+]] = OpConstant [[long]] 2\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[long]]\n" + "; CHECK: %4 = OpIMul [[long]] [[ld]] [[long_2]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_long Function\n" + "%2 = OpLoad %long %var\n" + "%3 = OpIMul %long %2 %long_n3689348814741910323\n" + "%4 = OpIMul %long %3 %long_10\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true) )); INSTANTIATE_TEST_SUITE_P(MergeDivTest, MatchingInstructionFoldingTest, ::testing::Values( // Test case 0: merge consecutive fdiv // 4.0 / (2.0 / x) = 2.0 * x InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_2:%\\w+]] = OpConstant [[float]] 2\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %4 = OpFMul [[float]] [[float_2]] [[ld]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFDiv %float %float_2 %2\n" + "%4 = OpFDiv %float %float_4 %3\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 1: merge consecutive fdiv // 4.0 / (x / 2.0) = 8.0 / x InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_8:%\\w+]] = OpConstant [[float]] 8\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %4 = OpFDiv [[float]] [[float_8]] [[ld]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFDiv %float %2 %float_2\n" + "%4 = OpFDiv %float %float_4 %3\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 2: merge consecutive fdiv // (4.0 / x) / 2.0 = 2.0 / x InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_2:%\\w+]] = OpConstant [[float]] 2\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %4 = OpFDiv [[float]] [[float_2]] [[ld]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFDiv %float %float_4 %2\n" + "%4 = OpFDiv %float %3 %float_2\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 3: Do not merge consecutive sdiv // 4 / (2 / x) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %var\n" + "%3 = OpSDiv %int %int_2 %2\n" + "%4 = OpSDiv %int %int_4 %3\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, false), // Test case 4: Do not merge consecutive sdiv // 4 / (x / 2) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %var\n" + "%3 = OpSDiv %int %2 %int_2\n" + "%4 = OpSDiv %int %int_4 %3\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, false), // Test case 5: Do not merge consecutive sdiv // (4 / x) / 2 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %var\n" + "%3 = OpSDiv %int %int_4 %2\n" + "%4 = OpSDiv %int %3 %int_2\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, false), // Test case 6: Do not merge consecutive sdiv // (x / 4) / 2 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %var\n" + "%3 = OpSDiv %int %2 %int_4\n" + "%4 = OpSDiv %int %3 %int_2\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, false), // Test case 7: Do not merge sdiv of imul // 4 / (2 * x) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %var\n" + "%3 = OpIMul %int %int_2 %2\n" + "%4 = OpSDiv %int %int_4 %3\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, false), // Test case 8: Do not merge sdiv of imul // 4 / (x * 2) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %var\n" + "%3 = OpIMul %int %2 %int_2\n" + "%4 = OpSDiv %int %int_4 %3\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, false), // Test case 9: Do not merge sdiv of imul // (4 * x) / 2 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %var\n" + "%3 = OpIMul %int %int_4 %2\n" + "%4 = OpSDiv %int %3 %int_2\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, false), // Test case 10: Do not merge sdiv of imul // (x * 4) / 2 InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %var\n" + "%3 = OpIMul %int %2 %int_4\n" + "%4 = OpSDiv %int %3 %int_2\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, false), // Test case 11: Do not merge sdiv of snegate. If %2 is INT_MIN, then the // sign of %3 will be the same as %2. This cannot be accounted for in OpSDiv. // Specifically, (-INT_MIN) / 2 != INT_MIN / -2. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %var\n" + "%3 = OpSNegate %int %2\n" + "%4 = OpSDiv %int %3 %int_2\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, false), // Test case 12: Do not merge sdiv of snegate. If %2 is INT_MIN, then the // sign of %3 will be the same as %2. This cannot be accounted for in OpSDiv. // Specifically, 2 / (-INT_MIN) != -2 / INT_MIN. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %var\n" + "%3 = OpSNegate %int %2\n" + "%4 = OpSDiv %int %int_2 %3\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, false), // Test case 13: Don't merge // (x / {null}) / {null} InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_v2float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFDiv %float %2 %v2float_null\n" + "%4 = OpFDiv %float %3 %v2float_null\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, false), // Test case 14: merge fmul of fdiv // (y * x) / x = y InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[ldx:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: [[ldy:%\\w+]] = OpLoad [[float]] [[y:%\\w+]]\n" + "; CHECK: %5 = OpCopyObject [[float]] [[ldy]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%x = OpVariable %_ptr_float Function\n" + "%y = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %x\n" + "%3 = OpLoad %float %y\n" + "%4 = OpFMul %float %3 %2\n" + "%5 = OpFDiv %float %4 %2\n" + "OpReturn\n" + "OpFunctionEnd\n", 5, true), // Test case 15: merge fmul of fdiv // (x * y) / x = y InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[ldx:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: [[ldy:%\\w+]] = OpLoad [[float]] [[y:%\\w+]]\n" + "; CHECK: %5 = OpCopyObject [[float]] [[ldy]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%x = OpVariable %_ptr_float Function\n" + "%y = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %x\n" + "%3 = OpLoad %float %y\n" + "%4 = OpFMul %float %2 %3\n" + "%5 = OpFDiv %float %4 %2\n" + "OpReturn\n" + "OpFunctionEnd\n", 5, true), // Test case 16: Do not merge udiv of snegate // (-x) / 2u InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_uint Function\n" + "%2 = OpLoad %uint %var\n" + "%3 = OpSNegate %uint %2\n" + "%4 = OpUDiv %uint %3 %uint_2\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, false), // Test case 17: Do not merge udiv of snegate // 2u / (-x) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_uint Function\n" + "%2 = OpLoad %uint %var\n" + "%3 = OpSNegate %uint %2\n" + "%4 = OpUDiv %uint %uint_2 %3\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, false) )); INSTANTIATE_TEST_SUITE_P(MergeAddTest, MatchingInstructionFoldingTest, ::testing::Values( // Test case 0: merge add of negate // (-x) + 2 = 2 - x InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_2:%\\w+]] = OpConstant [[float]] 2\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %4 = OpFSub [[float]] [[float_2]] [[ld]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFNegate %float %2\n" + "%4 = OpFAdd %float %3 %float_2\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 1: merge add of negate // 2 + (-x) = 2 - x InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_2:%\\w+]] = OpConstant [[float]] 2\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %4 = OpFSub [[float]] [[float_2]] [[ld]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpSNegate %float %2\n" + "%4 = OpIAdd %float %float_2 %3\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 2: merge add of negate // (-x) + 2 = 2 - x InstructionFoldingCase( Header() + "; CHECK: [[long:%\\w+]] = OpTypeInt 64 1\n" + "; CHECK: [[long_2:%\\w+]] = OpConstant [[long]] 2\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[long]]\n" + "; CHECK: %4 = OpISub [[long]] [[long_2]] [[ld]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_long Function\n" + "%2 = OpLoad %long %var\n" + "%3 = OpSNegate %long %2\n" + "%4 = OpIAdd %long %3 %long_2\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 3: merge add of negate // 2 + (-x) = 2 - x InstructionFoldingCase( Header() + "; CHECK: [[long:%\\w+]] = OpTypeInt 64 1\n" + "; CHECK: [[long_2:%\\w+]] = OpConstant [[long]] 2\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[long]]\n" + "; CHECK: %4 = OpISub [[long]] [[long_2]] [[ld]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_long Function\n" + "%2 = OpLoad %long %var\n" + "%3 = OpSNegate %long %2\n" + "%4 = OpIAdd %long %long_2 %3\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 4: merge add of subtract // (x - 1) + 2 = x + 1 InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_1:%\\w+]] = OpConstant [[float]] 1\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %4 = OpFAdd [[float]] [[ld]] [[float_1]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFSub %float %2 %float_1\n" + "%4 = OpFAdd %float %3 %float_2\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 5: merge add of subtract // (1 - x) + 2 = 3 - x InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_3:%\\w+]] = OpConstant [[float]] 3\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %4 = OpFSub [[float]] [[float_3]] [[ld]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFSub %float %float_1 %2\n" + "%4 = OpFAdd %float %3 %float_2\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 6: merge add of subtract // 2 + (x - 1) = x + 1 InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_1:%\\w+]] = OpConstant [[float]] 1\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %4 = OpFAdd [[float]] [[ld]] [[float_1]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFSub %float %2 %float_1\n" + "%4 = OpFAdd %float %float_2 %3\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 7: merge add of subtract // 2 + (1 - x) = 3 - x InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_3:%\\w+]] = OpConstant [[float]] 3\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %4 = OpFSub [[float]] [[float_3]] [[ld]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFSub %float %float_1 %2\n" + "%4 = OpFAdd %float %float_2 %3\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 8: merge add of add // (x + 1) + 2 = x + 3 InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_3:%\\w+]] = OpConstant [[float]] 3\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %4 = OpFAdd [[float]] [[ld]] [[float_3]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFAdd %float %2 %float_1\n" + "%4 = OpFAdd %float %3 %float_2\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 9: merge add of add // (1 + x) + 2 = 3 + x InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_3:%\\w+]] = OpConstant [[float]] 3\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %4 = OpFAdd [[float]] [[ld]] [[float_3]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFAdd %float %float_1 %2\n" + "%4 = OpFAdd %float %3 %float_2\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 10: merge add of add // 2 + (x + 1) = x + 1 InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_3:%\\w+]] = OpConstant [[float]] 3\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %4 = OpFAdd [[float]] [[ld]] [[float_3]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFAdd %float %2 %float_1\n" + "%4 = OpFAdd %float %float_2 %3\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 11: merge add of add // 2 + (1 + x) = 3 - x InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_3:%\\w+]] = OpConstant [[float]] 3\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %4 = OpFAdd [[float]] [[ld]] [[float_3]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFAdd %float %float_1 %2\n" + "%4 = OpFAdd %float %float_2 %3\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 12: fold overflowing signed 32 bit iadds // (x + int_max) + 1 = x + int_min InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32\n" + "; CHECK: [[int_min:%\\w+]] = OpConstant [[int]] -2147483648\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[int]]\n" + "; CHECK: %4 = OpIAdd [[int]] [[ld]] [[int_min]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %var\n" + "%3 = OpIAdd %int %2 %int_max\n" + "%4 = OpIAdd %int %3 %int_1\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 13: fold overflowing signed 64 bit iadds // (x + long_max) + 1 = x + long_min InstructionFoldingCase( Header() + "; CHECK: [[long:%\\w+]] = OpTypeInt 64\n" + "; CHECK: [[long_min:%\\w+]] = OpConstant [[long]] -9223372036854775808\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[long]]\n" + "; CHECK: %4 = OpIAdd [[long]] [[ld]] [[long_min]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_long Function\n" + "%2 = OpLoad %long %var\n" + "%3 = OpIAdd %long %2 %long_max\n" + "%4 = OpIAdd %long %3 %long_1\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 14: fold overflowing 32 bit unsigned iadds // (x + uint_max) + 2 = x + 1 InstructionFoldingCase( Header() + "; CHECK: [[uint:%\\w+]] = OpTypeInt 32 0\n" + "; CHECK: [[uint_1:%\\w+]] = OpConstant [[uint]] 1\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[uint]]\n" + "; CHECK: %4 = OpIAdd [[uint]] [[ld]] [[uint_1]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_uint Function\n" + "%2 = OpLoad %uint %var\n" + "%3 = OpIAdd %uint %2 %uint_max\n" + "%4 = OpIAdd %uint %3 %uint_2\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 15: fold overflowing 64 bit unsigned iadds // (x + ulong_max) + 2 = x + 1 InstructionFoldingCase( Header() + "; CHECK: [[ulong:%\\w+]] = OpTypeInt 64 0\n" + "; CHECK: [[ulong_1:%\\w+]] = OpConstant [[ulong]] 1\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[ulong]]\n" + "; CHECK: %4 = OpIAdd [[ulong]] [[ld]] [[ulong_1]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_ulong Function\n" + "%2 = OpLoad %ulong %var\n" + "%3 = OpIAdd %ulong %2 %ulong_max\n" + "%4 = OpIAdd %ulong %3 %ulong_2\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 16: fold underflowing signed 32 bit iadds // (x + int_min) + (-1) = x + int_max InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32\n" + "; CHECK: [[int_max:%\\w+]] = OpConstant [[int]] 2147483647\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[int]]\n" + "; CHECK: %4 = OpIAdd [[int]] [[ld]] [[int_max]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %var\n" + "%3 = OpIAdd %int %2 %int_min\n" + "%4 = OpIAdd %int %3 %int_n1\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 17: fold underflowing signed 64 bit iadds // (x + long_min) + (-1) = x + long_max InstructionFoldingCase( Header() + "; CHECK: [[long:%\\w+]] = OpTypeInt 64\n" + "; CHECK: [[long_max:%\\w+]] = OpConstant [[long]] 9223372036854775807\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[long]]\n" + "; CHECK: %4 = OpIAdd [[long]] [[ld]] [[long_max]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_long Function\n" + "%2 = OpLoad %long %var\n" + "%3 = OpIAdd %long %2 %long_min\n" + "%4 = OpIAdd %long %3 %long_n1\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true) )); INSTANTIATE_TEST_SUITE_P(MergeGenericAddSub, MatchingInstructionFoldingTest, ::testing::Values( // Test case 0: merge of add of sub // (a - b) + b => a InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: %6 = OpCopyObject [[float]] %3\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var0 = OpVariable %_ptr_float Function\n" + "%var1 = OpVariable %_ptr_float Function\n" + "%3 = OpLoad %float %var0\n" + "%4 = OpLoad %float %var1\n" + "%5 = OpFSub %float %3 %4\n" + "%6 = OpFAdd %float %5 %4\n" + "OpReturn\n" + "OpFunctionEnd\n", 6, true), // Test case 1: merge of add of sub // b + (a - b) => a InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: %6 = OpCopyObject [[float]] %3\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var0 = OpVariable %_ptr_float Function\n" + "%var1 = OpVariable %_ptr_float Function\n" + "%3 = OpLoad %float %var0\n" + "%4 = OpLoad %float %var1\n" + "%5 = OpFSub %float %3 %4\n" + "%6 = OpFAdd %float %4 %5\n" + "OpReturn\n" + "OpFunctionEnd\n", 6, true) )); INSTANTIATE_TEST_SUITE_P(FactorAddMul, MatchingInstructionFoldingTest, ::testing::Values( // Test case 0: factor of add of muls // (a * b) + (a * c) => a * (b + c) InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[newadd:%\\w+]] = OpFAdd [[float]] %4 %5\n" + "; CHECK: %9 = OpFMul [[float]] %6 [[newadd]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var0 = OpVariable %_ptr_float Function\n" + "%var1 = OpVariable %_ptr_float Function\n" + "%var2 = OpVariable %_ptr_float Function\n" + "%4 = OpLoad %float %var0\n" + "%5 = OpLoad %float %var1\n" + "%6 = OpLoad %float %var2\n" + "%7 = OpFMul %float %6 %4\n" + "%8 = OpFMul %float %6 %5\n" + "%9 = OpFAdd %float %7 %8\n" + "OpReturn\n" + "OpFunctionEnd\n", 9, true), // Test case 1: factor of add of muls // (b * a) + (a * c) => a * (b + c) InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[newadd:%\\w+]] = OpFAdd [[float]] %4 %5\n" + "; CHECK: %9 = OpFMul [[float]] %6 [[newadd]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var0 = OpVariable %_ptr_float Function\n" + "%var1 = OpVariable %_ptr_float Function\n" + "%var2 = OpVariable %_ptr_float Function\n" + "%4 = OpLoad %float %var0\n" + "%5 = OpLoad %float %var1\n" + "%6 = OpLoad %float %var2\n" + "%7 = OpFMul %float %4 %6\n" + "%8 = OpFMul %float %6 %5\n" + "%9 = OpFAdd %float %7 %8\n" + "OpReturn\n" + "OpFunctionEnd\n", 9, true), // Test case 2: factor of add of muls // (a * b) + (c * a) => a * (b + c) InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[newadd:%\\w+]] = OpFAdd [[float]] %4 %5\n" + "; CHECK: %9 = OpFMul [[float]] %6 [[newadd]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var0 = OpVariable %_ptr_float Function\n" + "%var1 = OpVariable %_ptr_float Function\n" + "%var2 = OpVariable %_ptr_float Function\n" + "%4 = OpLoad %float %var0\n" + "%5 = OpLoad %float %var1\n" + "%6 = OpLoad %float %var2\n" + "%7 = OpFMul %float %6 %4\n" + "%8 = OpFMul %float %5 %6\n" + "%9 = OpFAdd %float %7 %8\n" + "OpReturn\n" + "OpFunctionEnd\n", 9, true), // Test case 3: factor of add of muls // (b * a) + (c * a) => a * (b + c) InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[newadd:%\\w+]] = OpFAdd [[float]] %4 %5\n" + "; CHECK: %9 = OpFMul [[float]] %6 [[newadd]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var0 = OpVariable %_ptr_float Function\n" + "%var1 = OpVariable %_ptr_float Function\n" + "%var2 = OpVariable %_ptr_float Function\n" + "%4 = OpLoad %float %var0\n" + "%5 = OpLoad %float %var1\n" + "%6 = OpLoad %float %var2\n" + "%7 = OpFMul %float %4 %6\n" + "%8 = OpFMul %float %5 %6\n" + "%9 = OpFAdd %float %7 %8\n" + "OpReturn\n" + "OpFunctionEnd\n", 9, true) )); INSTANTIATE_TEST_SUITE_P(MergeSubTest, MatchingInstructionFoldingTest, ::testing::Values( // Test case 0: merge sub of negate // (-x) - 2 = -2 - x InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_n2:%\\w+]] = OpConstant [[float]] -2{{[[:space:]]}}\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %4 = OpFSub [[float]] [[float_n2]] [[ld]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFNegate %float %2\n" + "%4 = OpFSub %float %3 %float_2\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 1: merge sub of negate // 2 - (-x) = x + 2 InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_2:%\\w+]] = OpConstant [[float]] 2\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %4 = OpFAdd [[float]] [[ld]] [[float_2]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFNegate %float %2\n" + "%4 = OpFSub %float %float_2 %3\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 2: merge sub of negate // (-x) - 2 = -2 - x InstructionFoldingCase( Header() + "; CHECK: [[long:%\\w+]] = OpTypeInt 64 1\n" + "; CHECK: [[long_n2:%\\w+]] = OpConstant [[long]] -2{{[[:space:]]}}\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[long]]\n" + "; CHECK: %4 = OpISub [[long]] [[long_n2]] [[ld]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_long Function\n" + "%2 = OpLoad %long %var\n" + "%3 = OpSNegate %long %2\n" + "%4 = OpISub %long %3 %long_2\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 3: merge sub of negate // 2 - (-x) = x + 2 InstructionFoldingCase( Header() + "; CHECK: [[long:%\\w+]] = OpTypeInt 64 1\n" + "; CHECK: [[long_2:%\\w+]] = OpConstant [[long]] 2\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[long]]\n" + "; CHECK: %4 = OpIAdd [[long]] [[ld]] [[long_2]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_long Function\n" + "%2 = OpLoad %long %var\n" + "%3 = OpSNegate %long %2\n" + "%4 = OpISub %long %long_2 %3\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 4: merge add of subtract // (x + 2) - 1 = x + 1 InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_1:%\\w+]] = OpConstant [[float]] 1\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %4 = OpFAdd [[float]] [[ld]] [[float_1]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFAdd %float %2 %float_2\n" + "%4 = OpFSub %float %3 %float_1\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 5: merge add of subtract // (2 + x) - 1 = x + 1 InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_1:%\\w+]] = OpConstant [[float]] 1\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %4 = OpFAdd [[float]] [[ld]] [[float_1]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFAdd %float %float_2 %2\n" + "%4 = OpFSub %float %3 %float_1\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 6: merge add of subtract // 2 - (x + 1) = 1 - x InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_1:%\\w+]] = OpConstant [[float]] 1\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %4 = OpFSub [[float]] [[float_1]] [[ld]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFAdd %float %2 %float_1\n" + "%4 = OpFSub %float %float_2 %3\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 7: merge add of subtract // 2 - (1 + x) = 1 - x InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_1:%\\w+]] = OpConstant [[float]] 1\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %4 = OpFSub [[float]] [[float_1]] [[ld]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFAdd %float %float_1 %2\n" + "%4 = OpFSub %float %float_2 %3\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 8: merge subtract of subtract // (x - 2) - 1 = x - 3 InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_3:%\\w+]] = OpConstant [[float]] 3\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %4 = OpFSub [[float]] [[ld]] [[float_3]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFSub %float %2 %float_2\n" + "%4 = OpFSub %float %3 %float_1\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 9: merge subtract of subtract // (2 - x) - 1 = 1 - x InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_1:%\\w+]] = OpConstant [[float]] 1\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %4 = OpFSub [[float]] [[float_1]] [[ld]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFSub %float %float_2 %2\n" + "%4 = OpFSub %float %3 %float_1\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 10: merge subtract of subtract // 2 - (x - 1) = 3 - x InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_3:%\\w+]] = OpConstant [[float]] 3\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %4 = OpFSub [[float]] [[float_3]] [[ld]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFSub %float %2 %float_1\n" + "%4 = OpFSub %float %float_2 %3\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 11: merge subtract of subtract // 1 - (2 - x) = x + (-1) InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_n1:%\\w+]] = OpConstant [[float]] -1\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %4 = OpFAdd [[float]] [[ld]] [[float_n1]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFSub %float %float_2 %2\n" + "%4 = OpFSub %float %float_1 %3\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 12: merge subtract of subtract // 2 - (1 - x) = x + 1 InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: [[float_1:%\\w+]] = OpConstant [[float]] 1\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[float]]\n" + "; CHECK: %4 = OpFAdd [[float]] [[ld]] [[float_1]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_float Function\n" + "%2 = OpLoad %float %var\n" + "%3 = OpFSub %float %float_1 %2\n" + "%4 = OpFSub %float %float_2 %3\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 13: merge subtract of subtract with mixed types. // 2 - (1 - x) = x + 1 InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32 1\n" + "; CHECK: [[int_1:%\\w+]] = OpConstant [[int]] 1\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[int]]\n" + "; CHECK: %4 = OpIAdd [[int]] [[ld]] [[int_1]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %var\n" + "%3 = OpISub %int %uint_1 %2\n" + "%4 = OpISub %int %int_2 %3\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 14: fold overflowing signed 32 bit isubs // (x - int_max) - 1 = x - int_min InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32\n" + "; CHECK: [[int_min:%\\w+]] = OpConstant [[int]] -2147483648\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[int]]\n" + "; CHECK: %4 = OpISub [[int]] [[ld]] [[int_min]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_int Function\n" + "%2 = OpLoad %int %var\n" + "%3 = OpISub %int %2 %int_max\n" + "%4 = OpISub %int %3 %int_1\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true), // Test case 15: fold overflowing signed 64 bit isubs // (x - long_max) - 1 = x - long_min InstructionFoldingCase( Header() + "; CHECK: [[long:%\\w+]] = OpTypeInt 64\n" + "; CHECK: [[long_min:%\\w+]] = OpConstant [[long]] -9223372036854775808\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[long]]\n" + "; CHECK: %4 = OpISub [[long]] [[ld]] [[long_min]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%var = OpVariable %_ptr_long Function\n" + "%2 = OpLoad %long %var\n" + "%3 = OpISub %long %2 %long_max\n" + "%4 = OpISub %long %3 %long_1\n" + "OpReturn\n" + "OpFunctionEnd\n", 4, true) )); INSTANTIATE_TEST_SUITE_P(SelectFoldingTest, MatchingInstructionFoldingTest, ::testing::Values( // Test case 0: Fold select with the same values for both sides InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32 1\n" + "; CHECK: [[int0:%\\w+]] = OpConstant [[int]] 0\n" + "; CHECK: %2 = OpCopyObject [[int]] [[int0]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_bool Function\n" + "%load = OpLoad %bool %n\n" + "%2 = OpSelect %int %load %100 %100\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 1: Fold select true to left side InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32 1\n" + "; CHECK: [[int0:%\\w+]] = OpConstant [[int]] 0\n" + "; CHECK: %2 = OpCopyObject [[int]] [[int0]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %bool %n\n" + "%2 = OpSelect %int %true %100 %n\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 2: Fold select false to right side InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32 1\n" + "; CHECK: [[int0:%\\w+]] = OpConstant [[int]] 0\n" + "; CHECK: %2 = OpCopyObject [[int]] [[int0]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %bool %n\n" + "%2 = OpSelect %int %false %n %100\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 3: Fold select null to right side InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32 1\n" + "; CHECK: [[int0:%\\w+]] = OpConstant [[int]] 0\n" + "; CHECK: %2 = OpCopyObject [[int]] [[int0]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpSelect %int %bool_null %load %100\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 4: vector null InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32 1\n" + "; CHECK: [[v2int:%\\w+]] = OpTypeVector [[int]] 2\n" + "; CHECK: [[int2:%\\w+]] = OpConstant [[int]] 2\n" + "; CHECK: [[v2int2_2:%\\w+]] = OpConstantComposite [[v2int]] [[int2]] [[int2]]\n" + "; CHECK: %2 = OpCopyObject [[v2int]] [[v2int2_2]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_v2int Function\n" + "%load = OpLoad %v2int %n\n" + "%2 = OpSelect %v2int %v2bool_null %load %v2int_2_2\n" + "OpReturn\n" + "OpFunctionEnd", 2, true), // Test case 5: vector select InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32 1\n" + "; CHECK: [[v2int:%\\w+]] = OpTypeVector [[int]] 2\n" + "; CHECK: %4 = OpVectorShuffle [[v2int]] %2 %3 0 3\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%m = OpVariable %_ptr_v2int Function\n" + "%n = OpVariable %_ptr_v2int Function\n" + "%2 = OpLoad %v2int %n\n" + "%3 = OpLoad %v2int %n\n" + "%4 = OpSelect %v2int %v2bool_true_false %2 %3\n" + "OpReturn\n" + "OpFunctionEnd", 4, true), // Test case 6: vector select InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32 1\n" + "; CHECK: [[v2int:%\\w+]] = OpTypeVector [[int]] 2\n" + "; CHECK: %4 = OpVectorShuffle [[v2int]] %2 %3 2 1\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%m = OpVariable %_ptr_v2int Function\n" + "%n = OpVariable %_ptr_v2int Function\n" + "%2 = OpLoad %v2int %n\n" + "%3 = OpLoad %v2int %n\n" + "%4 = OpSelect %v2int %v2bool_false_true %2 %3\n" + "OpReturn\n" + "OpFunctionEnd", 4, true) )); INSTANTIATE_TEST_SUITE_P(CompositeExtractOrInsertMatchingTest, MatchingInstructionFoldingTest, ::testing::Values( // Test case 0: Extracting from result of consecutive shuffles of differing // size. InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32 1\n" + "; CHECK: %5 = OpCompositeExtract [[int]] %2 2\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_v4int Function\n" + "%2 = OpLoad %v4int %n\n" + "%3 = OpVectorShuffle %v2int %2 %2 2 3\n" + "%4 = OpVectorShuffle %v4int %2 %3 0 4 2 5\n" + "%5 = OpCompositeExtract %int %4 1\n" + "OpReturn\n" + "OpFunctionEnd", 5, true), // Test case 1: Extracting from result of vector shuffle of differing // input and result sizes. InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32 1\n" + "; CHECK: %4 = OpCompositeExtract [[int]] %2 2\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_v4int Function\n" + "%2 = OpLoad %v4int %n\n" + "%3 = OpVectorShuffle %v2int %2 %2 2 3\n" + "%4 = OpCompositeExtract %int %3 0\n" + "OpReturn\n" + "OpFunctionEnd", 4, true), // Test case 2: Extracting from result of vector shuffle of differing // input and result sizes. InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32 1\n" + "; CHECK: %4 = OpCompositeExtract [[int]] %2 3\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_v4int Function\n" + "%2 = OpLoad %v4int %n\n" + "%3 = OpVectorShuffle %v2int %2 %2 2 3\n" + "%4 = OpCompositeExtract %int %3 1\n" + "OpReturn\n" + "OpFunctionEnd", 4, true), // Test case 3: Using fmix feeding extract with a 1 in the a position. InstructionFoldingCase( Header() + "; CHECK: [[double:%\\w+]] = OpTypeFloat 64\n" + "; CHECK: [[v4double:%\\w+]] = OpTypeVector [[double]] 4\n" + "; CHECK: [[ptr_v4double:%\\w+]] = OpTypePointer Function [[v4double]]\n" + "; CHECK: [[m:%\\w+]] = OpVariable [[ptr_v4double]] Function\n" + "; CHECK: [[n:%\\w+]] = OpVariable [[ptr_v4double]] Function\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[v4double]] [[n]]\n" + "; CHECK: %5 = OpCompositeExtract [[double]] [[ld]] 1\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%m = OpVariable %_ptr_v4double Function\n" + "%n = OpVariable %_ptr_v4double Function\n" + "%2 = OpLoad %v4double %m\n" + "%3 = OpLoad %v4double %n\n" + "%4 = OpExtInst %v4double %1 FMix %2 %3 %v4double_0_1_0_0\n" + "%5 = OpCompositeExtract %double %4 1\n" + "OpReturn\n" + "OpFunctionEnd", 5, true), // Test case 4: Using fmix feeding extract with a 0 in the a position. InstructionFoldingCase( Header() + "; CHECK: [[double:%\\w+]] = OpTypeFloat 64\n" + "; CHECK: [[v4double:%\\w+]] = OpTypeVector [[double]] 4\n" + "; CHECK: [[ptr_v4double:%\\w+]] = OpTypePointer Function [[v4double]]\n" + "; CHECK: [[m:%\\w+]] = OpVariable [[ptr_v4double]] Function\n" + "; CHECK: [[n:%\\w+]] = OpVariable [[ptr_v4double]] Function\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[v4double]] [[m]]\n" + "; CHECK: %5 = OpCompositeExtract [[double]] [[ld]] 2\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%m = OpVariable %_ptr_v4double Function\n" + "%n = OpVariable %_ptr_v4double Function\n" + "%2 = OpLoad %v4double %m\n" + "%3 = OpLoad %v4double %n\n" + "%4 = OpExtInst %v4double %1 FMix %2 %3 %v4double_0_1_0_0\n" + "%5 = OpCompositeExtract %double %4 2\n" + "OpReturn\n" + "OpFunctionEnd", 5, true), // Test case 5: Using fmix feeding extract with a null for the alpha InstructionFoldingCase( Header() + "; CHECK: [[double:%\\w+]] = OpTypeFloat 64\n" + "; CHECK: [[v4double:%\\w+]] = OpTypeVector [[double]] 4\n" + "; CHECK: [[ptr_v4double:%\\w+]] = OpTypePointer Function [[v4double]]\n" + "; CHECK: [[m:%\\w+]] = OpVariable [[ptr_v4double]] Function\n" + "; CHECK: [[n:%\\w+]] = OpVariable [[ptr_v4double]] Function\n" + "; CHECK: [[ld:%\\w+]] = OpLoad [[v4double]] [[m]]\n" + "; CHECK: %5 = OpCompositeExtract [[double]] [[ld]] 0\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%m = OpVariable %_ptr_v4double Function\n" + "%n = OpVariable %_ptr_v4double Function\n" + "%2 = OpLoad %v4double %m\n" + "%3 = OpLoad %v4double %n\n" + "%4 = OpExtInst %v4double %1 FMix %2 %3 %v4double_null\n" + "%5 = OpCompositeExtract %double %4 0\n" + "OpReturn\n" + "OpFunctionEnd", 5, true), // Test case 6: Don't fold: Using fmix feeding extract with 0.5 in the a // position. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%m = OpVariable %_ptr_v4double Function\n" + "%n = OpVariable %_ptr_v4double Function\n" + "%2 = OpLoad %v4double %m\n" + "%3 = OpLoad %v4double %n\n" + "%4 = OpExtInst %v4double %1 FMix %2 %3 %v4double_1_1_1_0p5\n" + "%5 = OpCompositeExtract %double %4 3\n" + "OpReturn\n" + "OpFunctionEnd", 5, false), // Test case 7: Extracting the undefined literal value from a vector // shuffle. InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32 1\n" + "; CHECK: %4 = OpUndef [[int]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_v4int Function\n" + "%2 = OpLoad %v4int %n\n" + "%3 = OpVectorShuffle %v2int %2 %2 2 4294967295\n" + "%4 = OpCompositeExtract %int %3 1\n" + "OpReturn\n" + "OpFunctionEnd", 4, true), // Test case 8: Inserting every element of a vector turns into a composite construct. InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32 1\n" + "; CHECK-DAG: [[v4:%\\w+]] = OpTypeVector [[int]] 4\n" + "; CHECK-DAG: [[int1:%\\w+]] = OpConstant [[int]] 1\n" + "; CHECK-DAG: [[int2:%\\w+]] = OpConstant [[int]] 2\n" + "; CHECK-DAG: [[int3:%\\w+]] = OpConstant [[int]] 3\n" + "; CHECK: [[construct:%\\w+]] = OpCompositeConstruct [[v4]] %100 [[int1]] [[int2]] [[int3]]\n" + "; CHECK: %5 = OpCopyObject [[v4]] [[construct]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpCompositeInsert %v4int %100 %v4int_undef 0\n" + "%3 = OpCompositeInsert %v4int %int_1 %2 1\n" + "%4 = OpCompositeInsert %v4int %int_2 %3 2\n" + "%5 = OpCompositeInsert %v4int %int_3 %4 3\n" + "OpReturn\n" + "OpFunctionEnd", 5, true), // Test case 9: Inserting every element of a vector turns into a composite construct in a different order. InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32 1\n" + "; CHECK-DAG: [[v4:%\\w+]] = OpTypeVector [[int]] 4\n" + "; CHECK-DAG: [[int1:%\\w+]] = OpConstant [[int]] 1\n" + "; CHECK-DAG: [[int2:%\\w+]] = OpConstant [[int]] 2\n" + "; CHECK-DAG: [[int3:%\\w+]] = OpConstant [[int]] 3\n" + "; CHECK: [[construct:%\\w+]] = OpCompositeConstruct [[v4]] %100 [[int1]] [[int2]] [[int3]]\n" + "; CHECK: %5 = OpCopyObject [[v4]] [[construct]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpCompositeInsert %v4int %100 %v4int_undef 0\n" + "%4 = OpCompositeInsert %v4int %int_2 %2 2\n" + "%3 = OpCompositeInsert %v4int %int_1 %4 1\n" + "%5 = OpCompositeInsert %v4int %int_3 %3 3\n" + "OpReturn\n" + "OpFunctionEnd", 5, true), // Test case 10: Check multiple inserts to the same position are handled correctly. InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32 1\n" + "; CHECK-DAG: [[v4:%\\w+]] = OpTypeVector [[int]] 4\n" + "; CHECK-DAG: [[int1:%\\w+]] = OpConstant [[int]] 1\n" + "; CHECK-DAG: [[int2:%\\w+]] = OpConstant [[int]] 2\n" + "; CHECK-DAG: [[int3:%\\w+]] = OpConstant [[int]] 3\n" + "; CHECK: [[construct:%\\w+]] = OpCompositeConstruct [[v4]] %100 [[int1]] [[int2]] [[int3]]\n" + "; CHECK: %6 = OpCopyObject [[v4]] [[construct]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpCompositeInsert %v4int %100 %v4int_undef 0\n" + "%3 = OpCompositeInsert %v4int %int_2 %2 2\n" + "%4 = OpCompositeInsert %v4int %int_4 %3 1\n" + "%5 = OpCompositeInsert %v4int %int_1 %4 1\n" + "%6 = OpCompositeInsert %v4int %int_3 %5 3\n" + "OpReturn\n" + "OpFunctionEnd", 6, true), // Test case 11: The last indexes are 0 and 1, but they have different first indexes. This should not be folded. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpCompositeInsert %m2x2int %100 %m2x2int_undef 0 0\n" + "%3 = OpCompositeInsert %m2x2int %int_1 %2 1 1\n" + "OpReturn\n" + "OpFunctionEnd", 3, false), // Test case 12: Don't fold when there is a partial insertion. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpCompositeInsert %m2x2int %v2int_1_0 %m2x2int_undef 0\n" + "%3 = OpCompositeInsert %m2x2int %int_4 %2 0 0\n" + "%4 = OpCompositeInsert %m2x2int %v2int_2_3 %3 1\n" + "OpReturn\n" + "OpFunctionEnd", 4, false), // Test case 13: Insert into a column of a matrix InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32 1\n" + "; CHECK-DAG: [[v2:%\\w+]] = OpTypeVector [[int]] 2\n" + "; CHECK: [[m2x2:%\\w+]] = OpTypeMatrix [[v2]] 2\n" + "; CHECK-DAG: [[m2x2_undef:%\\w+]] = OpUndef [[m2x2]]\n" + "; CHECK-DAG: [[int1:%\\w+]] = OpConstant [[int]] 1\n" + // We keep this insert in the chain. DeadInsertElimPass should remove it. "; CHECK: [[insert:%\\w+]] = OpCompositeInsert [[m2x2]] %100 [[m2x2_undef]] 0 0\n" + "; CHECK: [[construct:%\\w+]] = OpCompositeConstruct [[v2]] %100 [[int1]]\n" + "; CHECK: %3 = OpCompositeInsert [[m2x2]] [[construct]] [[insert]] 0\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpCompositeInsert %m2x2int %100 %m2x2int_undef 0 0\n" + "%3 = OpCompositeInsert %m2x2int %int_1 %2 0 1\n" + "OpReturn\n" + "OpFunctionEnd", 3, true), // Test case 14: Insert all elements of the matrix. InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32 1\n" + "; CHECK-DAG: [[v2:%\\w+]] = OpTypeVector [[int]] 2\n" + "; CHECK: [[m2x2:%\\w+]] = OpTypeMatrix [[v2]] 2\n" + "; CHECK-DAG: [[m2x2_undef:%\\w+]] = OpUndef [[m2x2]]\n" + "; CHECK-DAG: [[int1:%\\w+]] = OpConstant [[int]] 1\n" + "; CHECK-DAG: [[int2:%\\w+]] = OpConstant [[int]] 2\n" + "; CHECK-DAG: [[int3:%\\w+]] = OpConstant [[int]] 3\n" + "; CHECK: [[c0:%\\w+]] = OpCompositeConstruct [[v2]] %100 [[int1]]\n" + "; CHECK: [[c1:%\\w+]] = OpCompositeConstruct [[v2]] [[int2]] [[int3]]\n" + "; CHECK: [[matrix:%\\w+]] = OpCompositeConstruct [[m2x2]] [[c0]] [[c1]]\n" + "; CHECK: %5 = OpCopyObject [[m2x2]] [[matrix]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpCompositeConstruct %v2int %100 %int_1\n" + "%3 = OpCompositeInsert %m2x2int %2 %m2x2int_undef 0\n" + "%4 = OpCompositeInsert %m2x2int %int_2 %3 1 0\n" + "%5 = OpCompositeInsert %m2x2int %int_3 %4 1 1\n" + "OpReturn\n" + "OpFunctionEnd", 5, true), // Test case 15: Replace construct with extract when reconstructing a member // of another object. InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32 1\n" + "; CHECK: [[v2:%\\w+]] = OpTypeVector [[int]] 2\n" + "; CHECK: [[m2x2:%\\w+]] = OpTypeMatrix [[v2]] 2\n" + "; CHECK: [[m2x2_undef:%\\w+]] = OpUndef [[m2x2]]\n" + "; CHECK: %5 = OpCompositeExtract [[v2]] [[m2x2_undef]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%3 = OpCompositeExtract %int %m2x2int_undef 1 0\n" + "%4 = OpCompositeExtract %int %m2x2int_undef 1 1\n" + "%5 = OpCompositeConstruct %v2int %3 %4\n" + "OpReturn\n" + "OpFunctionEnd", 5, true), // Test case 16: Don't fold when type cannot be deduced to a constant. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%4 = OpCompositeInsert %struct_v2int_int_int %int_1 %struct_v2int_int_int_null 2\n" + "OpReturn\n" + "OpFunctionEnd", 4, false), // Test case 17: Don't fold when index into composite is out of bounds. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%4 = OpCompositeExtract %int %struct_v2int_int_int 3\n" + "OpReturn\n" + "OpFunctionEnd", 4, false), // Test case 18: Fold when every element of an array is inserted. InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32 1\n" + "; CHECK: [[int2:%\\w+]] = OpConstant [[int]] 2\n" + "; CHECK-DAG: [[arr_type:%\\w+]] = OpTypeArray [[int]] [[int2]]\n" + "; CHECK-DAG: [[int10:%\\w+]] = OpConstant [[int]] 10\n" + "; CHECK-DAG: [[int1:%\\w+]] = OpConstant [[int]] 1\n" + "; CHECK: [[construct:%\\w+]] = OpCompositeConstruct [[arr_type]] [[int10]] [[int1]]\n" + "; CHECK: %5 = OpCopyObject [[arr_type]] [[construct]]\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%4 = OpCompositeInsert %int_arr_2 %int_10 %int_arr_2_undef 0\n" + "%5 = OpCompositeInsert %int_arr_2 %int_1 %4 1\n" + "OpReturn\n" + "OpFunctionEnd", 5, true), // Test case 19: Don't fold for isomorphic structs InstructionFoldingCase( Header() + "%structA = OpTypeStruct %ulong\n" + "%structB = OpTypeStruct %ulong\n" + "%structC = OpTypeStruct %structB\n" + "%struct_a_undef = OpUndef %structA\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%3 = OpCompositeExtract %ulong %struct_a_undef 0\n" + "%4 = OpCompositeConstruct %structB %3\n" + "OpReturn\n" + "OpFunctionEnd", 4, false) )); INSTANTIATE_TEST_SUITE_P(DotProductMatchingTest, MatchingInstructionFoldingTest, ::testing::Values( // Test case 0: Using OpDot to extract last element. InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: %3 = OpCompositeExtract [[float]] %2 3\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_v4float Function\n" + "%2 = OpLoad %v4float %n\n" + "%3 = OpDot %float %2 %v4float_0_0_0_1\n" + "OpReturn\n" + "OpFunctionEnd", 3, true), // Test case 1: Using OpDot to extract last element. InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: %3 = OpCompositeExtract [[float]] %2 3\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_v4float Function\n" + "%2 = OpLoad %v4float %n\n" + "%3 = OpDot %float %v4float_0_0_0_1 %2\n" + "OpReturn\n" + "OpFunctionEnd", 3, true), // Test case 2: Using OpDot to extract second element. InstructionFoldingCase( Header() + "; CHECK: [[float:%\\w+]] = OpTypeFloat 32\n" + "; CHECK: %3 = OpCompositeExtract [[float]] %2 1\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_v4float Function\n" + "%2 = OpLoad %v4float %n\n" + "%3 = OpDot %float %v4float_0_1_0_0 %2\n" + "OpReturn\n" + "OpFunctionEnd", 3, true), // Test case 3: Using OpDot to extract last element. InstructionFoldingCase( Header() + "; CHECK: [[double:%\\w+]] = OpTypeFloat 64\n" + "; CHECK: %3 = OpCompositeExtract [[double]] %2 3\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_v4double Function\n" + "%2 = OpLoad %v4double %n\n" + "%3 = OpDot %double %2 %v4double_0_0_0_1\n" + "OpReturn\n" + "OpFunctionEnd", 3, true), // Test case 4: Using OpDot to extract last element. InstructionFoldingCase( Header() + "; CHECK: [[double:%\\w+]] = OpTypeFloat 64\n" + "; CHECK: %3 = OpCompositeExtract [[double]] %2 3\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_v4double Function\n" + "%2 = OpLoad %v4double %n\n" + "%3 = OpDot %double %v4double_0_0_0_1 %2\n" + "OpReturn\n" + "OpFunctionEnd", 3, true), // Test case 5: Using OpDot to extract second element. InstructionFoldingCase( Header() + "; CHECK: [[double:%\\w+]] = OpTypeFloat 64\n" + "; CHECK: %3 = OpCompositeExtract [[double]] %2 1\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_v4double Function\n" + "%2 = OpLoad %v4double %n\n" + "%3 = OpDot %double %v4double_0_1_0_0 %2\n" + "OpReturn\n" + "OpFunctionEnd", 3, true) )); INSTANTIATE_TEST_SUITE_P(VectorShuffleMatchingTest, MatchingInstructionFoldingTest, ::testing::Values( // Test case 0: Using OpDot to extract last element. InstructionFoldingCase( Header() + "; CHECK: [[int:%\\w+]] = OpTypeInt 32 1\n" + "; CHECK: [[v2int:%\\w+]] = OpTypeVector [[int]] 2{{[[:space:]]}}\n" + "; CHECK: [[null:%\\w+]] = OpConstantNull [[v2int]]\n" + "; CHECK: OpVectorShuffle\n" + "; CHECK: %3 = OpVectorShuffle [[v2int]] [[null]] {{%\\w+}} 4294967295 2\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_int Function\n" + "%load = OpLoad %int %n\n" + "%2 = OpVectorShuffle %v2int %v2int_null %v2int_2_3 3 0xFFFFFFFF \n" + "%3 = OpVectorShuffle %v2int %2 %v2int_2_3 1 2 \n" + "OpReturn\n" + "OpFunctionEnd", 3, true) )); // Issue #5658: The Adreno compiler does not handle 16-bit FMA instructions well. // We want to avoid this by not generating FMA. We decided to never generate // FMAs because, from a SPIR-V perspective, it is neutral. The ICD can generate // the FMA if it wants. The simplest code is no code. INSTANTIATE_TEST_SUITE_P(FmaGenerationMatchingTest, MatchingInstructionFoldingTest, ::testing::Values( // Test case 0: Don't fold (x * y) + a InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%x = OpVariable %_ptr_float Function\n" + "%y = OpVariable %_ptr_float Function\n" + "%a = OpVariable %_ptr_float Function\n" + "%lx = OpLoad %float %x\n" + "%ly = OpLoad %float %y\n" + "%mul = OpFMul %float %lx %ly\n" + "%la = OpLoad %float %a\n" + "%3 = OpFAdd %float %mul %la\n" + "OpStore %a %3\n" + "OpReturn\n" + "OpFunctionEnd", 3, false), // Test case 1: Don't fold a + (x * y) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%x = OpVariable %_ptr_float Function\n" + "%y = OpVariable %_ptr_float Function\n" + "%a = OpVariable %_ptr_float Function\n" + "%lx = OpLoad %float %x\n" + "%ly = OpLoad %float %y\n" + "%mul = OpFMul %float %lx %ly\n" + "%la = OpLoad %float %a\n" + "%3 = OpFAdd %float %la %mul\n" + "OpStore %a %3\n" + "OpReturn\n" + "OpFunctionEnd", 3, false), // Test case 2: Don't fold (x * y) + a with vectors InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%x = OpVariable %_ptr_v4float Function\n" + "%y = OpVariable %_ptr_v4float Function\n" + "%a = OpVariable %_ptr_v4float Function\n" + "%lx = OpLoad %v4float %x\n" + "%ly = OpLoad %v4float %y\n" + "%mul = OpFMul %v4float %lx %ly\n" + "%la = OpLoad %v4float %a\n" + "%3 = OpFAdd %v4float %mul %la\n" + "OpStore %a %3\n" + "OpReturn\n" + "OpFunctionEnd", 3,false), // Test case 3: Don't fold a + (x * y) with vectors InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%x = OpVariable %_ptr_float Function\n" + "%y = OpVariable %_ptr_float Function\n" + "%a = OpVariable %_ptr_float Function\n" + "%lx = OpLoad %float %x\n" + "%ly = OpLoad %float %y\n" + "%mul = OpFMul %float %lx %ly\n" + "%la = OpLoad %float %a\n" + "%3 = OpFAdd %float %la %mul\n" + "OpStore %a %3\n" + "OpReturn\n" + "OpFunctionEnd", 3, false), // Test 4: Don't fold if the multiple is marked no contract. InstructionFoldingCase( std::string() + "OpCapability Shader\n" + "OpMemoryModel Logical GLSL450\n" + "OpEntryPoint Fragment %main \"main\"\n" + "OpExecutionMode %main OriginUpperLeft\n" + "OpSource GLSL 140\n" + "OpName %main \"main\"\n" + "OpDecorate %mul NoContraction\n" + "%void = OpTypeVoid\n" + "%void_func = OpTypeFunction %void\n" + "%bool = OpTypeBool\n" + "%float = OpTypeFloat 32\n" + "%_ptr_float = OpTypePointer Function %float\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%x = OpVariable %_ptr_float Function\n" + "%y = OpVariable %_ptr_float Function\n" + "%a = OpVariable %_ptr_float Function\n" + "%lx = OpLoad %float %x\n" + "%ly = OpLoad %float %y\n" + "%mul = OpFMul %float %lx %ly\n" + "%la = OpLoad %float %a\n" + "%3 = OpFAdd %float %mul %la\n" + "OpStore %a %3\n" + "OpReturn\n" + "OpFunctionEnd", 3, false), // Test 5: Don't fold if the add is marked no contract. InstructionFoldingCase( std::string() + "OpCapability Shader\n" + "OpMemoryModel Logical GLSL450\n" + "OpEntryPoint Fragment %main \"main\"\n" + "OpExecutionMode %main OriginUpperLeft\n" + "OpSource GLSL 140\n" + "OpName %main \"main\"\n" + "OpDecorate %3 NoContraction\n" + "%void = OpTypeVoid\n" + "%void_func = OpTypeFunction %void\n" + "%bool = OpTypeBool\n" + "%float = OpTypeFloat 32\n" + "%_ptr_float = OpTypePointer Function %float\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%x = OpVariable %_ptr_float Function\n" + "%y = OpVariable %_ptr_float Function\n" + "%a = OpVariable %_ptr_float Function\n" + "%lx = OpLoad %float %x\n" + "%ly = OpLoad %float %y\n" + "%mul = OpFMul %float %lx %ly\n" + "%la = OpLoad %float %a\n" + "%3 = OpFAdd %float %mul %la\n" + "OpStore %a %3\n" + "OpReturn\n" + "OpFunctionEnd", 3, false), // Test case 6: Don't fold (x * y) - a InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%x = OpVariable %_ptr_float Function\n" + "%y = OpVariable %_ptr_float Function\n" + "%a = OpVariable %_ptr_float Function\n" + "%lx = OpLoad %float %x\n" + "%ly = OpLoad %float %y\n" + "%mul = OpFMul %float %lx %ly\n" + "%la = OpLoad %float %a\n" + "%3 = OpFSub %float %mul %la\n" + "OpStore %a %3\n" + "OpReturn\n" + "OpFunctionEnd", 3, false), // Test case 7: Don't fold a - (x * y) InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%x = OpVariable %_ptr_float Function\n" + "%y = OpVariable %_ptr_float Function\n" + "%a = OpVariable %_ptr_float Function\n" + "%lx = OpLoad %float %x\n" + "%ly = OpLoad %float %y\n" + "%mul = OpFMul %float %lx %ly\n" + "%la = OpLoad %float %a\n" + "%3 = OpFSub %float %la %mul\n" + "OpStore %a %3\n" + "OpReturn\n" + "OpFunctionEnd", 3, false) )); using MatchingInstructionWithNoResultFoldingTest = ::testing::TestWithParam>; // Test folding instructions that do not have a result. The instruction // that will be folded is the last instruction before the return. If there // are multiple returns, there is not guarantee which one is used. TEST_P(MatchingInstructionWithNoResultFoldingTest, Case) { const auto& tc = GetParam(); std::unique_ptr context; Instruction* inst; std::tie(context, inst) = FoldInstruction(tc.test_body, tc.id_to_fold,SPV_ENV_UNIVERSAL_1_1); // Find the instruction to test. EXPECT_EQ(inst != nullptr, tc.expected_result); if (inst != nullptr) { Match(tc.test_body, context.get()); } } INSTANTIATE_TEST_SUITE_P(StoreMatchingTest, MatchingInstructionWithNoResultFoldingTest, ::testing::Values( // Test case 0: Remove store of undef. InstructionFoldingCase( Header() + "; CHECK: OpLabel\n" + "; CHECK-NOT: OpStore\n" + "; CHECK: OpReturn\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_v4double Function\n" + "%undef = OpUndef %v4double\n" + "OpStore %n %undef\n" + "OpReturn\n" + "OpFunctionEnd", 0 /* OpStore */, true), // Test case 1: Keep volatile store. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%n = OpVariable %_ptr_v4double Function\n" + "%undef = OpUndef %v4double\n" + "OpStore %n %undef Volatile\n" + "OpReturn\n" + "OpFunctionEnd", 0 /* OpStore */, false) )); INSTANTIATE_TEST_SUITE_P(VectorShuffleMatchingTest, MatchingInstructionWithNoResultFoldingTest, ::testing::Values( // Test case 0: Basic test 1 InstructionFoldingCase( Header() + "; CHECK: OpVectorShuffle\n" + "; CHECK: OpVectorShuffle {{%\\w+}} %7 %5 2 3 6 7\n" + "; CHECK: OpReturn\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpVariable %_ptr_v4double Function\n" + "%3 = OpVariable %_ptr_v4double Function\n" + "%4 = OpVariable %_ptr_v4double Function\n" + "%5 = OpLoad %v4double %2\n" + "%6 = OpLoad %v4double %3\n" + "%7 = OpLoad %v4double %4\n" + "%8 = OpVectorShuffle %v4double %5 %6 2 3 4 5\n" + "%9 = OpVectorShuffle %v4double %7 %8 2 3 4 5\n" + "OpReturn\n" + "OpFunctionEnd", 9, true), // Test case 1: Basic test 2 InstructionFoldingCase( Header() + "; CHECK: OpVectorShuffle\n" + "; CHECK: OpVectorShuffle {{%\\w+}} %6 %7 0 1 4 5\n" + "; CHECK: OpReturn\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpVariable %_ptr_v4double Function\n" + "%3 = OpVariable %_ptr_v4double Function\n" + "%4 = OpVariable %_ptr_v4double Function\n" + "%5 = OpLoad %v4double %2\n" + "%6 = OpLoad %v4double %3\n" + "%7 = OpLoad %v4double %4\n" + "%8 = OpVectorShuffle %v4double %5 %6 2 3 4 5\n" + "%9 = OpVectorShuffle %v4double %8 %7 2 3 4 5\n" + "OpReturn\n" + "OpFunctionEnd", 9, true), // Test case 2: Basic test 3 InstructionFoldingCase( Header() + "; CHECK: OpVectorShuffle\n" + "; CHECK: OpVectorShuffle {{%\\w+}} %5 %7 3 2 4 5\n" + "; CHECK: OpReturn\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpVariable %_ptr_v4double Function\n" + "%3 = OpVariable %_ptr_v4double Function\n" + "%4 = OpVariable %_ptr_v4double Function\n" + "%5 = OpLoad %v4double %2\n" + "%6 = OpLoad %v4double %3\n" + "%7 = OpLoad %v4double %4\n" + "%8 = OpVectorShuffle %v4double %5 %6 2 3 4 5\n" + "%9 = OpVectorShuffle %v4double %8 %7 1 0 4 5\n" + "OpReturn\n" + "OpFunctionEnd", 9, true), // Test case 3: Basic test 4 InstructionFoldingCase( Header() + "; CHECK: OpVectorShuffle\n" + "; CHECK: OpVectorShuffle {{%\\w+}} %7 %6 2 3 5 4\n" + "; CHECK: OpReturn\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpVariable %_ptr_v4double Function\n" + "%3 = OpVariable %_ptr_v4double Function\n" + "%4 = OpVariable %_ptr_v4double Function\n" + "%5 = OpLoad %v4double %2\n" + "%6 = OpLoad %v4double %3\n" + "%7 = OpLoad %v4double %4\n" + "%8 = OpVectorShuffle %v4double %5 %6 2 3 4 5\n" + "%9 = OpVectorShuffle %v4double %7 %8 2 3 7 6\n" + "OpReturn\n" + "OpFunctionEnd", 9, true), // Test case 4: Don't fold, need both operands of the feeder. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpVariable %_ptr_v4double Function\n" + "%3 = OpVariable %_ptr_v4double Function\n" + "%4 = OpVariable %_ptr_v4double Function\n" + "%5 = OpLoad %v4double %2\n" + "%6 = OpLoad %v4double %3\n" + "%7 = OpLoad %v4double %4\n" + "%8 = OpVectorShuffle %v4double %5 %6 2 3 4 5\n" + "%9 = OpVectorShuffle %v4double %7 %8 2 3 7 5\n" + "OpReturn\n" + "OpFunctionEnd", 9, false), // Test case 5: Don't fold, need both operands of the feeder. InstructionFoldingCase( Header() + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpVariable %_ptr_v4double Function\n" + "%3 = OpVariable %_ptr_v4double Function\n" + "%4 = OpVariable %_ptr_v4double Function\n" + "%5 = OpLoad %v4double %2\n" + "%6 = OpLoad %v4double %3\n" + "%7 = OpLoad %v4double %4\n" + "%8 = OpVectorShuffle %v4double %5 %6 2 3 4 5\n" + "%9 = OpVectorShuffle %v4double %8 %7 2 0 7 5\n" + "OpReturn\n" + "OpFunctionEnd", 9, false), // Test case 6: Fold, need both operands of the feeder, but they are the same. InstructionFoldingCase( Header() + "; CHECK: OpVectorShuffle\n" + "; CHECK: OpVectorShuffle {{%\\w+}} %5 %7 0 2 7 5\n" + "; CHECK: OpReturn\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpVariable %_ptr_v4double Function\n" + "%3 = OpVariable %_ptr_v4double Function\n" + "%4 = OpVariable %_ptr_v4double Function\n" + "%5 = OpLoad %v4double %2\n" + "%6 = OpLoad %v4double %3\n" + "%7 = OpLoad %v4double %4\n" + "%8 = OpVectorShuffle %v4double %5 %5 2 3 4 5\n" + "%9 = OpVectorShuffle %v4double %8 %7 2 0 7 5\n" + "OpReturn\n" + "OpFunctionEnd", 9, true), // Test case 7: Fold, need both operands of the feeder, but they are the same. InstructionFoldingCase( Header() + "; CHECK: OpVectorShuffle\n" + "; CHECK: OpVectorShuffle {{%\\w+}} %7 %5 2 0 5 7\n" + "; CHECK: OpReturn\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpVariable %_ptr_v4double Function\n" + "%3 = OpVariable %_ptr_v4double Function\n" + "%4 = OpVariable %_ptr_v4double Function\n" + "%5 = OpLoad %v4double %2\n" + "%6 = OpLoad %v4double %3\n" + "%7 = OpLoad %v4double %4\n" + "%8 = OpVectorShuffle %v4double %5 %5 2 3 4 5\n" + "%9 = OpVectorShuffle %v4double %7 %8 2 0 7 5\n" + "OpReturn\n" + "OpFunctionEnd", 9, true), // Test case 8: Replace first operand with a smaller vector. InstructionFoldingCase( Header() + "; CHECK: OpVectorShuffle\n" + "; CHECK: OpVectorShuffle {{%\\w+}} %5 %7 0 0 5 3\n" + "; CHECK: OpReturn\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpVariable %_ptr_v2double Function\n" + "%3 = OpVariable %_ptr_v4double Function\n" + "%4 = OpVariable %_ptr_v4double Function\n" + "%5 = OpLoad %v2double %2\n" + "%6 = OpLoad %v4double %3\n" + "%7 = OpLoad %v4double %4\n" + "%8 = OpVectorShuffle %v4double %5 %5 0 1 2 3\n" + "%9 = OpVectorShuffle %v4double %8 %7 2 0 7 5\n" + "OpReturn\n" + "OpFunctionEnd", 9, true), // Test case 9: Replace first operand with a larger vector. InstructionFoldingCase( Header() + "; CHECK: OpVectorShuffle\n" + "; CHECK: OpVectorShuffle {{%\\w+}} %5 %7 3 0 7 5\n" + "; CHECK: OpReturn\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpVariable %_ptr_v4double Function\n" + "%3 = OpVariable %_ptr_v4double Function\n" + "%4 = OpVariable %_ptr_v4double Function\n" + "%5 = OpLoad %v4double %2\n" + "%6 = OpLoad %v4double %3\n" + "%7 = OpLoad %v4double %4\n" + "%8 = OpVectorShuffle %v2double %5 %5 0 3\n" + "%9 = OpVectorShuffle %v4double %8 %7 1 0 5 3\n" + "OpReturn\n" + "OpFunctionEnd", 9, true), // Test case 10: Replace unused operand with null. InstructionFoldingCase( Header() + "; CHECK: [[double:%\\w+]] = OpTypeFloat 64\n" + "; CHECK: [[v4double:%\\w+]] = OpTypeVector [[double]] 2\n" + "; CHECK: [[null:%\\w+]] = OpConstantNull [[v4double]]\n" + "; CHECK: OpVectorShuffle\n" + "; CHECK: OpVectorShuffle {{%\\w+}} [[null]] %7 4 2 5 3\n" + "; CHECK: OpReturn\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpVariable %_ptr_v4double Function\n" + "%3 = OpVariable %_ptr_v4double Function\n" + "%4 = OpVariable %_ptr_v4double Function\n" + "%5 = OpLoad %v4double %2\n" + "%6 = OpLoad %v4double %3\n" + "%7 = OpLoad %v4double %4\n" + "%8 = OpVectorShuffle %v2double %5 %5 0 3\n" + "%9 = OpVectorShuffle %v4double %8 %7 4 2 5 3\n" + "OpReturn\n" + "OpFunctionEnd", 9, true), // Test case 11: Replace unused operand with null. InstructionFoldingCase( Header() + "; CHECK: [[double:%\\w+]] = OpTypeFloat 64\n" + "; CHECK: [[v4double:%\\w+]] = OpTypeVector [[double]] 2\n" + "; CHECK: [[null:%\\w+]] = OpConstantNull [[v4double]]\n" + "; CHECK: OpVectorShuffle\n" + "; CHECK: OpVectorShuffle {{%\\w+}} [[null]] %5 2 2 5 5\n" + "; CHECK: OpReturn\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpVariable %_ptr_v4double Function\n" + "%3 = OpVariable %_ptr_v4double Function\n" + "%5 = OpLoad %v4double %2\n" + "%6 = OpLoad %v4double %3\n" + "%8 = OpVectorShuffle %v2double %5 %5 0 3\n" + "%9 = OpVectorShuffle %v4double %8 %8 2 2 3 3\n" + "OpReturn\n" + "OpFunctionEnd", 9, true), // Test case 12: Replace unused operand with null. InstructionFoldingCase( Header() + "; CHECK: [[double:%\\w+]] = OpTypeFloat 64\n" + "; CHECK: [[v4double:%\\w+]] = OpTypeVector [[double]] 2\n" + "; CHECK: [[null:%\\w+]] = OpConstantNull [[v4double]]\n" + "; CHECK: OpVectorShuffle\n" + "; CHECK: OpVectorShuffle {{%\\w+}} %7 [[null]] 2 0 1 3\n" + "; CHECK: OpReturn\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpVariable %_ptr_v4double Function\n" + "%3 = OpVariable %_ptr_v4double Function\n" + "%4 = OpVariable %_ptr_v4double Function\n" + "%5 = OpLoad %v4double %2\n" + "%6 = OpLoad %v4double %3\n" + "%7 = OpLoad %v4double %4\n" + "%8 = OpVectorShuffle %v2double %5 %5 0 3\n" + "%9 = OpVectorShuffle %v4double %7 %8 2 0 1 3\n" + "OpReturn\n" + "OpFunctionEnd", 9, true), // Test case 13: Shuffle with undef literal. InstructionFoldingCase( Header() + "; CHECK: [[double:%\\w+]] = OpTypeFloat 64\n" + "; CHECK: [[v4double:%\\w+]] = OpTypeVector [[double]] 2\n" + "; CHECK: OpVectorShuffle\n" + "; CHECK: OpVectorShuffle {{%\\w+}} %7 {{%\\w+}} 2 0 1 4294967295\n" + "; CHECK: OpReturn\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpVariable %_ptr_v4double Function\n" + "%3 = OpVariable %_ptr_v4double Function\n" + "%4 = OpVariable %_ptr_v4double Function\n" + "%5 = OpLoad %v4double %2\n" + "%6 = OpLoad %v4double %3\n" + "%7 = OpLoad %v4double %4\n" + "%8 = OpVectorShuffle %v2double %5 %5 0 1\n" + "%9 = OpVectorShuffle %v4double %7 %8 2 0 1 4294967295\n" + "OpReturn\n" + "OpFunctionEnd", 9, true), // Test case 14: Shuffle with undef literal and change size of first input vector. InstructionFoldingCase( Header() + "; CHECK: [[double:%\\w+]] = OpTypeFloat 64\n" + "; CHECK: [[v4double:%\\w+]] = OpTypeVector [[double]] 2\n" + "; CHECK: OpVectorShuffle\n" + "; CHECK: OpVectorShuffle {{%\\w+}} %5 %7 0 1 4 4294967295\n" + "; CHECK: OpReturn\n" + "%main = OpFunction %void None %void_func\n" + "%main_lab = OpLabel\n" + "%2 = OpVariable %_ptr_v4double Function\n" + "%3 = OpVariable %_ptr_v4double Function\n" + "%4 = OpVariable %_ptr_v4double Function\n" + "%5 = OpLoad %v4double %2\n" + "%6 = OpLoad %v4double %3\n" + "%7 = OpLoad %v4double %4\n" + "%8 = OpVectorShuffle %v2double %5 %5 0 1\n" + "%9 = OpVectorShuffle %v4double %8 %7 0 1 2 4294967295\n" + "OpReturn\n" + "OpFunctionEnd", 9, true) )); using EntryPointFoldingTest = ::testing::TestWithParam>; TEST_P(EntryPointFoldingTest, Case) { const auto& tc = GetParam(); // Build module. std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, tc.test_body, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); ASSERT_NE(nullptr, context); // Find the first entry point. That is the instruction we want to fold. Instruction* inst = nullptr; ASSERT_FALSE(context->module()->entry_points().empty()); inst = &*context->module()->entry_points().begin(); assert(inst && "Invalid test. Could not find entry point instruction to fold."); std::unique_ptr original_inst(inst->Clone(context.get())); bool succeeded = context->get_instruction_folder().FoldInstruction(inst); EXPECT_EQ(succeeded, tc.expected_result); if (succeeded) { Match(tc.test_body, context.get()); } } INSTANTIATE_TEST_SUITE_P(OpEntryPointFoldingTest, EntryPointFoldingTest, ::testing::Values( // Test case 0: Basic test 1 InstructionFoldingCase(std::string() + "; CHECK: OpEntryPoint Fragment %2 \"main\" %3\n" + "OpCapability Shader\n" + "%1 = OpExtInstImport \"GLSL.std.450\"\n" + "OpMemoryModel Logical GLSL450\n" + "OpEntryPoint Fragment %2 \"main\" %3 %3 %3\n" + "OpExecutionMode %2 OriginUpperLeft\n" + "OpSource GLSL 430\n" + "OpDecorate %3 Location 0\n" + "%void = OpTypeVoid\n" + "%5 = OpTypeFunction %void\n" + "%float = OpTypeFloat 32\n" + "%v4float = OpTypeVector %float 4\n" + "%_ptr_Output_v4float = OpTypePointer Output %v4float\n" + "%3 = OpVariable %_ptr_Output_v4float Output\n" + "%int = OpTypeInt 32 1\n" + "%int_0 = OpConstant %int 0\n" + "%_ptr_PushConstant_v4float = OpTypePointer PushConstant %v4float\n" + "%2 = OpFunction %void None %5\n" + "%12 = OpLabel\n" + "OpReturn\n" + "OpFunctionEnd\n", 9, true), InstructionFoldingCase(std::string() + "; CHECK: OpEntryPoint Fragment %2 \"main\" %3 %4\n" + "OpCapability Shader\n" + "%1 = OpExtInstImport \"GLSL.std.450\"\n" + "OpMemoryModel Logical GLSL450\n" + "OpEntryPoint Fragment %2 \"main\" %3 %4 %3\n" + "OpExecutionMode %2 OriginUpperLeft\n" + "OpSource GLSL 430\n" + "OpDecorate %3 Location 0\n" + "%void = OpTypeVoid\n" + "%5 = OpTypeFunction %void\n" + "%float = OpTypeFloat 32\n" + "%v4float = OpTypeVector %float 4\n" + "%_ptr_Output_v4float = OpTypePointer Output %v4float\n" + "%3 = OpVariable %_ptr_Output_v4float Output\n" + "%4 = OpVariable %_ptr_Output_v4float Output\n" + "%int = OpTypeInt 32 1\n" + "%int_0 = OpConstant %int 0\n" + "%_ptr_PushConstant_v4float = OpTypePointer PushConstant %v4float\n" + "%2 = OpFunction %void None %5\n" + "%12 = OpLabel\n" + "OpReturn\n" + "OpFunctionEnd\n", 9, true), InstructionFoldingCase(std::string() + "; CHECK: OpEntryPoint Fragment %2 \"main\" %4 %3\n" + "OpCapability Shader\n" + "%1 = OpExtInstImport \"GLSL.std.450\"\n" + "OpMemoryModel Logical GLSL450\n" + "OpEntryPoint Fragment %2 \"main\" %4 %4 %3\n" + "OpExecutionMode %2 OriginUpperLeft\n" + "OpSource GLSL 430\n" + "OpDecorate %3 Location 0\n" + "%void = OpTypeVoid\n" + "%5 = OpTypeFunction %void\n" + "%float = OpTypeFloat 32\n" + "%v4float = OpTypeVector %float 4\n" + "%_ptr_Output_v4float = OpTypePointer Output %v4float\n" + "%3 = OpVariable %_ptr_Output_v4float Output\n" + "%4 = OpVariable %_ptr_Output_v4float Output\n" + "%int = OpTypeInt 32 1\n" + "%int_0 = OpConstant %int 0\n" + "%_ptr_PushConstant_v4float = OpTypePointer PushConstant %v4float\n" + "%2 = OpFunction %void None %5\n" + "%12 = OpLabel\n" + "OpReturn\n" + "OpFunctionEnd\n", 9, true) )); using SPV14FoldingTest = ::testing::TestWithParam>; TEST_P(SPV14FoldingTest, Case) { const auto& tc = GetParam(); std::unique_ptr context; Instruction* inst; std::tie(context, inst) = FoldInstruction(tc.test_body, tc.id_to_fold,SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(inst != nullptr, tc.expected_result); if (inst != nullptr) { Match(tc.test_body, context.get()); } } INSTANTIATE_TEST_SUITE_P(SPV14FoldingTest, SPV14FoldingTest, ::testing::Values( // Test case 0: select vectors with scalar condition. InstructionFoldingCase(std::string() + "; CHECK-NOT: OpSelect\n" + "; CHECK: %3 = OpCopyObject {{%\\w+}} %1\n" + "OpCapability Shader\n" + "OpCapability Linkage\n" + "%void = OpTypeVoid\n" + "%bool = OpTypeBool\n" + "%true = OpConstantTrue %bool\n" + "%int = OpTypeInt 32 0\n" + "%int4 = OpTypeVector %int 4\n" + "%int_0 = OpConstant %int 0\n" + "%int_1 = OpConstant %int 1\n" + "%1 = OpUndef %int4\n" + "%2 = OpUndef %int4\n" + "%void_fn = OpTypeFunction %void\n" + "%func = OpFunction %void None %void_fn\n" + "%entry = OpLabel\n" + "%3 = OpSelect %int4 %true %1 %2\n" + "OpReturn\n" + "OpFunctionEnd\n" , 3, true), // Test case 1: select struct with scalar condition. InstructionFoldingCase(std::string() + "; CHECK-NOT: OpSelect\n" + "; CHECK: %3 = OpCopyObject {{%\\w+}} %2\n" + "OpCapability Shader\n" + "OpCapability Linkage\n" + "%void = OpTypeVoid\n" + "%bool = OpTypeBool\n" + "%true = OpConstantFalse %bool\n" + "%int = OpTypeInt 32 0\n" + "%struct = OpTypeStruct %int %int %int %int\n" + "%int_0 = OpConstant %int 0\n" + "%int_1 = OpConstant %int 1\n" + "%1 = OpUndef %struct\n" + "%2 = OpUndef %struct\n" + "%void_fn = OpTypeFunction %void\n" + "%func = OpFunction %void None %void_fn\n" + "%entry = OpLabel\n" + "%3 = OpSelect %struct %true %1 %2\n" + "OpReturn\n" + "OpFunctionEnd\n" , 3, true), // Test case 1: select array with scalar condition. InstructionFoldingCase(std::string() + "; CHECK-NOT: OpSelect\n" + "; CHECK: %3 = OpCopyObject {{%\\w+}} %2\n" + "OpCapability Shader\n" + "OpCapability Linkage\n" + "%void = OpTypeVoid\n" + "%bool = OpTypeBool\n" + "%true = OpConstantFalse %bool\n" + "%int = OpTypeInt 32 0\n" + "%int_0 = OpConstant %int 0\n" + "%int_1 = OpConstant %int 1\n" + "%int_4 = OpConstant %int 4\n" + "%array = OpTypeStruct %int %int %int %int\n" + "%1 = OpUndef %array\n" + "%2 = OpUndef %array\n" + "%void_fn = OpTypeFunction %void\n" + "%func = OpFunction %void None %void_fn\n" + "%entry = OpLabel\n" + "%3 = OpSelect %array %true %1 %2\n" + "OpReturn\n" + "OpFunctionEnd\n" , 3, true) )); std::string FloatControlsHeader(const std::string& capabilities) { std::string header = R"( OpCapability Shader )" + capabilities + R"( %void = OpTypeVoid %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %float_1 = OpConstant %float 1 %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel )"; return header; } using FloatControlsFoldingTest = ::testing::TestWithParam>; TEST_P(FloatControlsFoldingTest, Case) { const auto& tc = GetParam(); std::unique_ptr context; Instruction* inst; std::tie(context, inst) = FoldInstruction(tc.test_body, tc.id_to_fold, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(inst != nullptr, tc.expected_result); if (inst != nullptr) { Match(tc.test_body, context.get()); } } INSTANTIATE_TEST_SUITE_P(FloatControlsFoldingTest, FloatControlsFoldingTest, ::testing::Values( // Test case 0: no folding with DenormPreserve InstructionFoldingCase(FloatControlsHeader("OpCapability DenormPreserve") + "%1 = OpFAdd %float %float_0 %float_1\n" + "OpReturn\n" + "OpFunctionEnd\n" , 1, false), // Test case 1: no folding with DenormFlushToZero InstructionFoldingCase(FloatControlsHeader("OpCapability DenormFlushToZero") + "%1 = OpFAdd %float %float_0 %float_1\n" + "OpReturn\n" + "OpFunctionEnd\n" , 1, false), // Test case 2: no folding with SignedZeroInfNanPreserve InstructionFoldingCase(FloatControlsHeader("OpCapability SignedZeroInfNanPreserve") + "%1 = OpFAdd %float %float_0 %float_1\n" + "OpReturn\n" + "OpFunctionEnd\n" , 1, false), // Test case 3: no folding with RoundingModeRTE InstructionFoldingCase(FloatControlsHeader("OpCapability RoundingModeRTE") + "%1 = OpFAdd %float %float_0 %float_1\n" + "OpReturn\n" + "OpFunctionEnd\n" , 1, false), // Test case 4: no folding with RoundingModeRTZ InstructionFoldingCase(FloatControlsHeader("OpCapability RoundingModeRTZ") + "%1 = OpFAdd %float %float_0 %float_1\n" + "OpReturn\n" + "OpFunctionEnd\n" , 1, false) )); std::string ImageOperandsTestBody(const std::string& image_instruction) { std::string body = R"( OpCapability Shader OpCapability ImageGatherExtended OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpDecorate %Texture DescriptorSet 0 OpDecorate %Texture Binding 0 %int = OpTypeInt 32 1 %int_n1 = OpConstant %int -1 %5 = OpConstant %int 0 %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %type_sampled_image = OpTypeSampledImage %type_2d_image %type_sampler = OpTypeSampler %_ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %type_sampler %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %_ptr_int = OpTypePointer Function %int %v2int = OpTypeVector %int 2 %10 = OpTypeVector %float 4 %void = OpTypeVoid %22 = OpTypeFunction %void %v2float = OpTypeVector %float 2 %v3int = OpTypeVector %int 3 %Texture = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %gSampler = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %110 = OpConstantComposite %v2int %5 %5 %101 = OpConstantComposite %v2int %int_n1 %int_n1 %20 = OpConstantComposite %v2float %float_0 %float_0 %main = OpFunction %void None %22 %23 = OpLabel %var = OpVariable %_ptr_int Function %88 = OpLoad %type_2d_image %Texture %val = OpLoad %int %var %sampler = OpLoad %type_sampler %gSampler %26 = OpSampledImage %type_sampled_image %88 %sampler )" + image_instruction + R"( OpReturn OpFunctionEnd )"; return body; } INSTANTIATE_TEST_SUITE_P(ImageOperandsBitmaskFoldingTest, MatchingInstructionWithNoResultFoldingTest, ::testing::Values( // Test case 0: OpImageFetch without Offset InstructionFoldingCase(ImageOperandsTestBody( "%89 = OpImageFetch %10 %88 %101 Lod %5 \n") , 89, false), // Test case 1: OpImageFetch with non-const offset InstructionFoldingCase(ImageOperandsTestBody( "%89 = OpImageFetch %10 %88 %101 Lod|Offset %5 %val \n") , 89, false), // Test case 2: OpImageFetch with Lod and Offset InstructionFoldingCase(ImageOperandsTestBody( " %89 = OpImageFetch %10 %88 %101 Lod|Offset %5 %101 \n" "; CHECK: %89 = OpImageFetch %10 %88 %101 Lod|ConstOffset %5 %101 \n") , 89, true), // Test case 3: OpImageFetch with Bias and Offset InstructionFoldingCase(ImageOperandsTestBody( " %89 = OpImageFetch %10 %88 %101 Bias|Offset %5 %101 \n" "; CHECK: %89 = OpImageFetch %10 %88 %101 Bias|ConstOffset %5 %101 \n") , 89, true), // Test case 4: OpImageFetch with Grad and Offset. // Grad adds 2 operands to the instruction. InstructionFoldingCase(ImageOperandsTestBody( " %89 = OpImageFetch %10 %88 %101 Grad|Offset %5 %5 %101 \n" "; CHECK: %89 = OpImageFetch %10 %88 %101 Grad|ConstOffset %5 %5 %101 \n") , 89, true), // Test case 5: OpImageFetch with Offset and MinLod. // This is an example of a case where the bitmask bit-offset is larger than // that of the Offset. InstructionFoldingCase(ImageOperandsTestBody( " %89 = OpImageFetch %10 %88 %101 Offset|MinLod %101 %5 \n" "; CHECK: %89 = OpImageFetch %10 %88 %101 ConstOffset|MinLod %101 %5 \n") , 89, true), // Test case 6: OpImageGather with constant Offset InstructionFoldingCase(ImageOperandsTestBody( " %89 = OpImageGather %10 %26 %20 %5 Offset %101 \n" "; CHECK: %89 = OpImageGather %10 %26 %20 %5 ConstOffset %101 \n") , 89, true), // Test case 7: OpImageWrite with constant Offset InstructionFoldingCase(ImageOperandsTestBody( " OpImageWrite %88 %5 %101 Offset %101 \n" "; CHECK: OpImageWrite %88 %5 %101 ConstOffset %101 \n") , 0 /* No result-id */, true), // Test case 8: OpImageFetch with zero constant Offset InstructionFoldingCase(ImageOperandsTestBody( " %89 = OpImageFetch %10 %88 %101 Lod|Offset %5 %110 \n" "; CHECK: %89 = OpImageFetch %10 %88 %101 Lod %5 \n") , 89, true) )); } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/freeze_spec_const_test.cpp000066400000000000000000000157421475742701700255660ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { struct FreezeSpecConstantValueTypeTestCase { const char* type_decl; const char* spec_const; const char* expected_frozen_const; }; using FreezeSpecConstantValueTypeTest = PassTest<::testing::TestWithParam>; TEST_P(FreezeSpecConstantValueTypeTest, PrimaryType) { auto& test_case = GetParam(); std::vector text = {"OpCapability Shader", "OpMemoryModel Logical GLSL450", test_case.type_decl, test_case.spec_const}; std::vector expected = { "OpCapability Shader", "OpMemoryModel Logical GLSL450", test_case.type_decl, test_case.expected_frozen_const}; SinglePassRunAndCheck( JoinAllInsts(text), JoinAllInsts(expected), /* skip_nop = */ false); } // Test each primary type. INSTANTIATE_TEST_SUITE_P( PrimaryTypeSpecConst, FreezeSpecConstantValueTypeTest, ::testing::ValuesIn(std::vector({ // Type declaration, original spec constant definition, expected frozen // spec constants. {"%int = OpTypeInt 32 1", "%2 = OpSpecConstant %int 1", "%int_1 = OpConstant %int 1"}, {"%uint = OpTypeInt 32 0", "%2 = OpSpecConstant %uint 1", "%uint_1 = OpConstant %uint 1"}, {"%float = OpTypeFloat 32", "%2 = OpSpecConstant %float 3.1415", "%float_3_1415 = OpConstant %float 3.1415"}, {"%double = OpTypeFloat 64", "%2 = OpSpecConstant %double 3.141592653", "%double_3_141592653 = OpConstant %double 3.141592653"}, {"%bool = OpTypeBool", "%2 = OpSpecConstantTrue %bool", "%true = OpConstantTrue %bool"}, {"%bool = OpTypeBool", "%2 = OpSpecConstantFalse %bool", "%false = OpConstantFalse %bool"}, }))); using FreezeSpecConstantValueRemoveDecorationTest = PassTest<::testing::Test>; TEST_F(FreezeSpecConstantValueRemoveDecorationTest, RemoveDecorationInstWithSpecId) { std::vector text = { // clang-format off "OpCapability Shader", "OpCapability Float64", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Vertex %main \"main\"", "OpSource GLSL 450", "OpSourceExtension \"GL_GOOGLE_cpp_style_line_directive\"", "OpSourceExtension \"GL_GOOGLE_include_directive\"", "OpName %main \"main\"", "OpDecorate %3 SpecId 200", "OpDecorate %4 SpecId 201", "OpDecorate %5 SpecId 202", "OpDecorate %6 SpecId 203", "%void = OpTypeVoid", "%8 = OpTypeFunction %void", "%int = OpTypeInt 32 1", "%3 = OpSpecConstant %int 3", "%float = OpTypeFloat 32", "%4 = OpSpecConstant %float 3.1415", "%double = OpTypeFloat 64", "%5 = OpSpecConstant %double 3.14159265358979", "%bool = OpTypeBool", "%6 = OpSpecConstantTrue %bool", "%13 = OpSpecConstantFalse %bool", "%main = OpFunction %void None %8", "%14 = OpLabel", "OpReturn", "OpFunctionEnd", // clang-format on }; std::string expected_disassembly = SelectiveJoin(text, [](const char* line) { return std::string(line).find("SpecId") != std::string::npos; }); std::vector> replacement_pairs = { {"%3 = OpSpecConstant %int 3", "%int_3 = OpConstant %int 3"}, {"%4 = OpSpecConstant %float 3.1415", "%float_3_1415 = OpConstant %float 3.1415"}, {"%5 = OpSpecConstant %double 3.14159265358979", "%double_3_14159265358979 = OpConstant %double 3.14159265358979"}, {"%6 = OpSpecConstantTrue ", "%true = OpConstantTrue "}, {"%13 = OpSpecConstantFalse ", "%false = OpConstantFalse "}, }; for (auto& p : replacement_pairs) { EXPECT_TRUE(FindAndReplace(&expected_disassembly, p.first, p.second)) << "text:\n" << expected_disassembly << "\n" << "find_str:\n" << p.first << "\n" << "replace_str:\n" << p.second << "\n"; } SinglePassRunAndCheck(JoinAllInsts(text), expected_disassembly, /* skip_nop = */ true); } TEST_F(FreezeSpecConstantValueRemoveDecorationTest, RemoveDecorationForLocalSizeIdWithSpecId) { std::vector text = { // clang-format off "OpCapability Shader", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint GLCompute %2 \"main\"", "OpExecutionModeId %2 LocalSizeId %uint_32 %uint_1 %uint_1_0", "OpSource GLSL 450", "OpDecorate %3 SpecId 18", "OpDecorate %5 SpecId 19", "%void = OpTypeVoid", "%9 = OpTypeFunction %void", "%uint = OpTypeInt 32 0", "%uint_32 = OpSpecConstant %uint 32", "%uint_1 = OpConstant %uint 1", "%uint_1_0 = OpSpecConstant %uint 1", "%2 = OpFunction %void None %9", "%11 = OpLabel", "OpReturn", "OpFunctionEnd", // clang-format on }; std::string expected_disassembly = SelectiveJoin(text, [](const char* line) { return std::string(line).find("SpecId") != std::string::npos; }); std::vector> replacement_pairs = { {"%uint_32 = OpSpecConstant %uint 32", "%uint_32 = OpConstant %uint 32"}, {"%uint_1_0 = OpSpecConstant %uint 1", "%uint_1_0 = OpConstant %uint 1"}, }; for (auto& p : replacement_pairs) { EXPECT_TRUE(FindAndReplace(&expected_disassembly, p.first, p.second)) << "text:\n" << expected_disassembly << "\n" << "find_str:\n" << p.first << "\n" << "replace_str:\n" << p.second << "\n"; } SinglePassRunAndCheck(JoinAllInsts(text), expected_disassembly, /* skip_nop = */ true); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/function_test.cpp000066400000000000000000000235531475742701700237120ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "function_utils.h" #include "gmock/gmock.h" #include "gtest/gtest.h" #include "source/opt/build_module.h" #include "source/opt/ir_context.h" namespace spvtools { namespace opt { namespace { using ::testing::Eq; TEST(FunctionTest, HasEarlyReturn) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %6 "main" ; Types %2 = OpTypeBool %3 = OpTypeVoid %4 = OpTypeFunction %3 ; Constants %5 = OpConstantTrue %2 ; main function without early return %6 = OpFunction %3 None %4 %7 = OpLabel OpBranch %8 %8 = OpLabel OpBranch %9 %9 = OpLabel OpBranch %10 %10 = OpLabel OpReturn OpFunctionEnd ; function with early return %11 = OpFunction %3 None %4 %12 = OpLabel OpSelectionMerge %15 None OpBranchConditional %5 %13 %14 %13 = OpLabel OpReturn %14 = OpLabel OpBranch %15 %15 = OpLabel OpReturn OpFunctionEnd )"; const auto context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, shader, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); // Tests |function| without early return. auto* function = spvtest::GetFunction(context->module(), 6); ASSERT_FALSE(function->HasEarlyReturn()); // Tests |function| with early return. function = spvtest::GetFunction(context->module(), 11); ASSERT_TRUE(function->HasEarlyReturn()); } TEST(FunctionTest, IsNotRecursive) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpDecorate %2 DescriptorSet 439418829 %void = OpTypeVoid %4 = OpTypeFunction %void %float = OpTypeFloat 32 %_struct_6 = OpTypeStruct %float %float %7 = OpTypeFunction %_struct_6 %1 = OpFunction %void Pure|Const %4 %8 = OpLabel %2 = OpFunctionCall %_struct_6 %9 OpKill OpFunctionEnd %9 = OpFunction %_struct_6 None %7 %10 = OpLabel %11 = OpFunctionCall %_struct_6 %12 OpUnreachable OpFunctionEnd %12 = OpFunction %_struct_6 None %7 %13 = OpLabel OpUnreachable OpFunctionEnd )"; std::unique_ptr ctx = spvtools::BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); auto* func = spvtest::GetFunction(ctx->module(), 9); EXPECT_FALSE(func->IsRecursive()); func = spvtest::GetFunction(ctx->module(), 12); EXPECT_FALSE(func->IsRecursive()); } TEST(FunctionTest, IsDirectlyRecursive) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpDecorate %2 DescriptorSet 439418829 %void = OpTypeVoid %4 = OpTypeFunction %void %float = OpTypeFloat 32 %_struct_6 = OpTypeStruct %float %float %7 = OpTypeFunction %_struct_6 %1 = OpFunction %void Pure|Const %4 %8 = OpLabel %2 = OpFunctionCall %_struct_6 %9 OpKill OpFunctionEnd %9 = OpFunction %_struct_6 None %7 %10 = OpLabel %11 = OpFunctionCall %_struct_6 %9 OpUnreachable OpFunctionEnd )"; std::unique_ptr ctx = spvtools::BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); auto* func = spvtest::GetFunction(ctx->module(), 9); EXPECT_TRUE(func->IsRecursive()); } TEST(FunctionTest, IsIndirectlyRecursive) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpDecorate %2 DescriptorSet 439418829 %void = OpTypeVoid %4 = OpTypeFunction %void %float = OpTypeFloat 32 %_struct_6 = OpTypeStruct %float %float %7 = OpTypeFunction %_struct_6 %1 = OpFunction %void Pure|Const %4 %8 = OpLabel %2 = OpFunctionCall %_struct_6 %9 OpKill OpFunctionEnd %9 = OpFunction %_struct_6 None %7 %10 = OpLabel %11 = OpFunctionCall %_struct_6 %12 OpUnreachable OpFunctionEnd %12 = OpFunction %_struct_6 None %7 %13 = OpLabel %14 = OpFunctionCall %_struct_6 %9 OpUnreachable OpFunctionEnd )"; std::unique_ptr ctx = spvtools::BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); auto* func = spvtest::GetFunction(ctx->module(), 9); EXPECT_TRUE(func->IsRecursive()); func = spvtest::GetFunction(ctx->module(), 12); EXPECT_TRUE(func->IsRecursive()); } TEST(FunctionTest, IsNotRecuriseCallingRecursive) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpDecorate %2 DescriptorSet 439418829 %void = OpTypeVoid %4 = OpTypeFunction %void %float = OpTypeFloat 32 %_struct_6 = OpTypeStruct %float %float %7 = OpTypeFunction %_struct_6 %1 = OpFunction %void Pure|Const %4 %8 = OpLabel %2 = OpFunctionCall %_struct_6 %9 OpKill OpFunctionEnd %9 = OpFunction %_struct_6 None %7 %10 = OpLabel %11 = OpFunctionCall %_struct_6 %9 OpUnreachable OpFunctionEnd )"; std::unique_ptr ctx = spvtools::BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); auto* func = spvtest::GetFunction(ctx->module(), 1); EXPECT_FALSE(func->IsRecursive()); } TEST(FunctionTest, NonSemanticInfoSkipIteration) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpExtension "SPV_KHR_non_semantic_info" %1 = OpExtInstImport "NonSemantic.Test" OpMemoryModel Logical GLSL450 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel %6 = OpExtInst %2 %1 1 OpReturn OpFunctionEnd %7 = OpExtInst %2 %1 2 %8 = OpExtInst %2 %1 3 )"; std::unique_ptr ctx = spvtools::BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); auto* func = spvtest::GetFunction(ctx->module(), 4); ASSERT_TRUE(func != nullptr); std::unordered_set non_semantic_ids; func->ForEachInst( [&non_semantic_ids](const Instruction* inst) { if (inst->opcode() == spv::Op::OpExtInst) { non_semantic_ids.insert(inst->result_id()); } }, true, false); EXPECT_EQ(1, non_semantic_ids.count(6)); EXPECT_EQ(0, non_semantic_ids.count(7)); EXPECT_EQ(0, non_semantic_ids.count(8)); } TEST(FunctionTest, NonSemanticInfoIncludeIteration) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpExtension "SPV_KHR_non_semantic_info" %1 = OpExtInstImport "NonSemantic.Test" OpMemoryModel Logical GLSL450 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel %6 = OpExtInst %2 %1 1 OpReturn OpFunctionEnd %7 = OpExtInst %2 %1 2 %8 = OpExtInst %2 %1 3 )"; std::unique_ptr ctx = spvtools::BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); auto* func = spvtest::GetFunction(ctx->module(), 4); ASSERT_TRUE(func != nullptr); std::unordered_set non_semantic_ids; func->ForEachInst( [&non_semantic_ids](const Instruction* inst) { if (inst->opcode() == spv::Op::OpExtInst) { non_semantic_ids.insert(inst->result_id()); } }, true, true); EXPECT_EQ(1, non_semantic_ids.count(6)); EXPECT_EQ(1, non_semantic_ids.count(7)); EXPECT_EQ(1, non_semantic_ids.count(8)); } TEST(FunctionTest, ReorderBlocksinStructuredOrder) { // The spir-v has the basic block in a random order. We want to reorder them // in structured order. const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %100 "PSMain" OpExecutionMode %PSMain OriginUpperLeft OpSource HLSL 600 %int = OpTypeInt 32 1 %void = OpTypeVoid %19 = OpTypeFunction %void %bool = OpTypeBool %undef_bool = OpUndef %bool %undef_int = OpUndef %int %100 = OpFunction %void None %19 %11 = OpLabel OpSelectionMerge %10 None OpSwitch %undef_int %3 0 %2 10 %1 %2 = OpLabel OpReturn %7 = OpLabel OpBranch %8 %3 = OpLabel OpBranch %4 %10 = OpLabel OpReturn %9 = OpLabel OpBranch %10 %8 = OpLabel OpBranch %4 %4 = OpLabel OpLoopMerge %9 %8 None OpBranchConditional %undef_bool %5 %9 %1 = OpLabel OpReturn %6 = OpLabel OpBranch %7 %5 = OpLabel OpSelectionMerge %7 None OpBranchConditional %undef_bool %6 %7 OpFunctionEnd )"; std::unique_ptr ctx = spvtools::BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); ASSERT_TRUE(ctx); auto* func = spvtest::GetFunction(ctx->module(), 100); ASSERT_TRUE(func); func->ReorderBasicBlocksInStructuredOrder(); auto first_block = func->begin(); auto bb = first_block; for (++bb; bb != func->end(); ++bb) { EXPECT_EQ(bb->id(), (bb - first_block)); } } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/function_utils.h000066400000000000000000000030131475742701700235250ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef TEST_OPT_FUNCTION_UTILS_H_ #define TEST_OPT_FUNCTION_UTILS_H_ #include "source/opt/function.h" #include "source/opt/module.h" namespace spvtest { inline spvtools::opt::Function* GetFunction(spvtools::opt::Module* module, uint32_t id) { for (spvtools::opt::Function& f : *module) { if (f.result_id() == id) { return &f; } } return nullptr; } inline const spvtools::opt::Function* GetFunction( const spvtools::opt::Module* module, uint32_t id) { for (const spvtools::opt::Function& f : *module) { if (f.result_id() == id) { return &f; } } return nullptr; } inline const spvtools::opt::BasicBlock* GetBasicBlock( const spvtools::opt::Function* fn, uint32_t id) { for (const spvtools::opt::BasicBlock& bb : *fn) { if (bb.id() == id) { return &bb; } } return nullptr; } } // namespace spvtest #endif // TEST_OPT_FUNCTION_UTILS_H_ KhronosGroup-SPIRV-Tools-f289d04/test/opt/graphics_robust_access_test.cpp000066400000000000000000002033541475742701700266030ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include "pass_fixture.h" #include "pass_utils.h" #include "source/opt/graphics_robust_access_pass.h" namespace { using namespace spvtools; using opt::GraphicsRobustAccessPass; using GraphicsRobustAccessTest = opt::PassTest<::testing::Test>; // Test incompatible module, determined at module-level. TEST_F(GraphicsRobustAccessTest, FailNotShader) { const std::string text = R"( ; CHECK: Can only process Shader modules OpCapability Kernel )"; SinglePassRunAndFail(text); } TEST_F(GraphicsRobustAccessTest, FailCantProcessVariablePointers) { const std::string text = R"( ; CHECK: Can't process modules with VariablePointers capability OpCapability VariablePointers )"; SinglePassRunAndFail(text); } TEST_F(GraphicsRobustAccessTest, FailCantProcessVariablePointersStorageBuffer) { const std::string text = R"( ; CHECK: Can't process modules with VariablePointersStorageBuffer capability OpCapability VariablePointersStorageBuffer )"; SinglePassRunAndFail(text); } TEST_F(GraphicsRobustAccessTest, FailCantProcessRuntimeDescriptorArrayEXT) { const std::string text = R"( ; CHECK: Can't process modules with RuntimeDescriptorArrayEXT capability OpCapability RuntimeDescriptorArrayEXT )"; SinglePassRunAndFail(text); } TEST_F(GraphicsRobustAccessTest, FailCantProcessPhysical32AddressingModel) { const std::string text = R"( ; CHECK: Addressing model must be Logical. Found OpMemoryModel Physical32 OpenCL OpCapability Shader OpMemoryModel Physical32 OpenCL )"; SinglePassRunAndFail(text); } TEST_F(GraphicsRobustAccessTest, FailCantProcessPhysical64AddressingModel) { const std::string text = R"( ; CHECK: Addressing model must be Logical. Found OpMemoryModel Physical64 OpenCL OpCapability Shader OpMemoryModel Physical64 OpenCL )"; SinglePassRunAndFail(text); } TEST_F(GraphicsRobustAccessTest, FailCantProcessPhysicalStorageBuffer64EXTAddressingModel) { const std::string text = R"( ; CHECK: Addressing model must be Logical. Found OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpCapability Shader OpMemoryModel PhysicalStorageBuffer64EXT GLSL450 )"; SinglePassRunAndFail(text); } // Test access chains // Returns the names of access chain instructions handled by the pass. // For the purposes of this pass, regular and in-bounds access chains are the // same.) std::vector AccessChains() { return {"OpAccessChain", "OpInBoundsAccessChain"}; } std::string ShaderPreamble() { return R"( OpCapability Shader OpMemoryModel Logical Simple OpEntryPoint GLCompute %main "main" )"; } std::string ShaderPreamble(const std::vector& names) { std::ostringstream os; os << ShaderPreamble(); for (auto& name : names) { os << " OpName %" << name << " \"" << name << "\"\n"; } return os.str(); } std::string ShaderPreambleAC() { return ShaderPreamble({"ac", "ptr_ty", "var"}); } std::string ShaderPreambleAC(const std::vector& names) { auto names2 = names; names2.push_back("ac"); names2.push_back("ptr_ty"); names2.push_back("var"); return ShaderPreamble(names2); } std::string DecoSSBO() { return R"( OpDecorate %ssbo_s BufferBlock OpMemberDecorate %ssbo_s 0 Offset 0 OpMemberDecorate %ssbo_s 1 Offset 4 OpMemberDecorate %ssbo_s 2 Offset 16 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 )"; } std::string TypesVoid() { return R"( %void = OpTypeVoid %void_fn = OpTypeFunction %void )"; } std::string TypesInt() { return R"( %uint = OpTypeInt 32 0 %int = OpTypeInt 32 1 )"; } std::string TypesFloat() { return R"( %float = OpTypeFloat 32 )"; } std::string TypesShort() { return R"( %ushort = OpTypeInt 16 0 %short = OpTypeInt 16 1 )"; } std::string TypesLong() { return R"( %ulong = OpTypeInt 64 0 %long = OpTypeInt 64 1 )"; } std::string MainPrefix() { return R"( %main = OpFunction %void None %void_fn %entry = OpLabel )"; } std::string MainSuffix() { return R"( OpReturn OpFunctionEnd )"; } std::string ACCheck(const std::string& access_chain_inst, const std::string& original, const std::string& transformed) { return "\n ; CHECK: %ac = " + access_chain_inst + " %ptr_ty %var" + (transformed.empty() ? "" : " ") + transformed + "\n ; CHECK-NOT: " + access_chain_inst + "\n ; CHECK-NEXT: OpReturn" "\n %ac = " + access_chain_inst + " %ptr_ty %var " + (original.empty() ? "" : " ") + original + "\n"; } std::string ACCheckFail(const std::string& access_chain_inst, const std::string& original, const std::string& transformed) { return "\n ; CHECK: %ac = " + access_chain_inst + " %ptr_ty %var" + (transformed.empty() ? "" : " ") + transformed + "\n ; CHECK-NOT: " + access_chain_inst + "\n ; CHECK-NOT: OpReturn" "\n %ac = " + access_chain_inst + " %ptr_ty %var " + (original.empty() ? "" : " ") + original + "\n"; } // Access chain into: // Vector // Vector sizes 2, 3, 4 // Matrix // Matrix columns 2, 4 // Component is vector 2, 4 // Array // Struct // TODO(dneto): RuntimeArray TEST_F(GraphicsRobustAccessTest, ACVectorLeastInboundConstantUntouched) { for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << ShaderPreambleAC() << TypesVoid() << TypesInt() << R"( %uvec2 = OpTypeVector %uint 2 %var_ty = OpTypePointer Function %uvec2 %ptr_ty = OpTypePointer Function %uint %uint_0 = OpConstant %uint 0 )" << MainPrefix() << R"( %var = OpVariable %var_ty Function)" << ACCheck(ac, "%uint_0", "%uint_0") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACVectorMostInboundConstantUntouched) { for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << ShaderPreambleAC() << TypesVoid() << TypesInt() << R"( %v4uint = OpTypeVector %uint 4 %var_ty = OpTypePointer Function %v4uint %ptr_ty = OpTypePointer Function %uint %uint_3 = OpConstant %uint 3 )" << MainPrefix() << R"( %var = OpVariable %var_ty Function)" << ACCheck(ac, "%uint_3", "%uint_3") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACVectorExcessConstantClamped) { for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << ShaderPreambleAC() << TypesVoid() << TypesInt() << R"( %v4uint = OpTypeVector %uint 4 %var_ty = OpTypePointer Function %v4uint %ptr_ty = OpTypePointer Function %uint %uint_4 = OpConstant %uint 4 )" << MainPrefix() << R"( %var = OpVariable %var_ty Function)" << ACCheck(ac, "%uint_4", "%int_3") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACVectorNegativeConstantClamped) { for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << ShaderPreambleAC() << TypesVoid() << TypesInt() << R"( %v4uint = OpTypeVector %uint 4 %var_ty = OpTypePointer Function %v4uint %ptr_ty = OpTypePointer Function %uint %int_n1 = OpConstant %int -1 )" << MainPrefix() << R"( ; CHECK: %int_0 = OpConstant %int 0 %var = OpVariable %var_ty Function)" << ACCheck(ac, "%int_n1", "%int_0") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } // Like the previous test, but ensures the pass knows how to modify an index // which does not come first in the access chain. TEST_F(GraphicsRobustAccessTest, ACVectorInArrayNegativeConstantClamped) { for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << ShaderPreambleAC() << TypesVoid() << TypesInt() << R"( %v4uint = OpTypeVector %uint 4 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %arr = OpTypeArray %v4uint %uint_2 %var_ty = OpTypePointer Function %arr %ptr_ty = OpTypePointer Function %uint %int_n1 = OpConstant %int -1 )" << MainPrefix() << R"( ; CHECK: %int_0 = OpConstant %int 0 %var = OpVariable %var_ty Function)" << ACCheck(ac, "%uint_1 %int_n1", "%uint_1 %int_0") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACVectorGeneralClamped) { for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << ShaderPreambleAC({"i"}) << TypesVoid() << TypesInt() << R"( %v4uint = OpTypeVector %uint 4 %var_ty = OpTypePointer Function %v4uint %ptr_ty = OpTypePointer Function %uint %i = OpUndef %int)" << MainPrefix() << R"( ; CHECK: %[[GLSLSTD450:\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK-DAG: %int_0 = OpConstant %int 0 ; CHECK-DAG: %int_3 = OpConstant %int 3 ; CHECK: OpLabel ; CHECK: %[[clamp:\w+]] = OpExtInst %int %[[GLSLSTD450]] SClamp %i %int_0 %int_3 %var = OpVariable %var_ty Function)" << ACCheck(ac, "%i", "%[[clamp]]") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACVectorGeneralShortClamped) { // Show that signed 16 bit integers are clamped as well. for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << "OpCapability Int16\n" << ShaderPreambleAC({"i"}) << TypesVoid() << TypesShort() << R"( %v4short = OpTypeVector %short 4 %var_ty = OpTypePointer Function %v4short %ptr_ty = OpTypePointer Function %short %i = OpUndef %short)" << MainPrefix() << R"( ; CHECK: %[[GLSLSTD450:\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK-NOT: = OpTypeInt 32 ; CHECK-DAG: %short_0 = OpConstant %short 0 ; CHECK-DAG: %short_3 = OpConstant %short 3 ; CHECK-NOT: = OpTypeInt 32 ; CHECK: OpLabel ; CHECK: %[[clamp:\w+]] = OpExtInst %short %[[GLSLSTD450]] SClamp %i %short_0 %short_3 %var = OpVariable %var_ty Function)" << ACCheck(ac, "%i", "%[[clamp]]") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACVectorGeneralUShortClamped) { // Show that unsigned 16 bit integers are clamped as well. for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << "OpCapability Int16\n" << ShaderPreambleAC({"i"}) << TypesVoid() << TypesShort() << R"( %v4ushort = OpTypeVector %ushort 4 %var_ty = OpTypePointer Function %v4ushort %ptr_ty = OpTypePointer Function %ushort %i = OpUndef %ushort)" << MainPrefix() << R"( ; CHECK: %[[GLSLSTD450:\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK-NOT: = OpTypeInt 32 ; CHECK-DAG: %short_0 = OpConstant %short 0 ; CHECK-DAG: %short_3 = OpConstant %short 3 ; CHECK-NOT: = OpTypeInt 32 ; CHECK: OpLabel ; CHECK: %[[clamp:\w+]] = OpExtInst %ushort %[[GLSLSTD450]] SClamp %i %short_0 %short_3 %var = OpVariable %var_ty Function)" << ACCheck(ac, "%i", "%[[clamp]]") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACVectorGeneralLongClamped) { // Show that signed 64 bit integers are clamped as well. for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << "OpCapability Int64\n" << ShaderPreambleAC({"i"}) << TypesVoid() << TypesLong() << R"( %v4long = OpTypeVector %long 4 %var_ty = OpTypePointer Function %v4long %ptr_ty = OpTypePointer Function %long %i = OpUndef %long)" << MainPrefix() << R"( ; CHECK: %[[GLSLSTD450:\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK-NOT: = OpTypeInt 32 ; CHECK-DAG: %long_0 = OpConstant %long 0 ; CHECK-DAG: %long_3 = OpConstant %long 3 ; CHECK-NOT: = OpTypeInt 32 ; CHECK: OpLabel ; CHECK: %[[clamp:\w+]] = OpExtInst %long %[[GLSLSTD450]] SClamp %i %long_0 %long_3 %var = OpVariable %var_ty Function)" << ACCheck(ac, "%i", "%[[clamp]]") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACVectorGeneralULongClamped) { // Show that unsigned 64 bit integers are clamped as well. for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << "OpCapability Int64\n" << ShaderPreambleAC({"i"}) << TypesVoid() << TypesLong() << R"( %v4ulong = OpTypeVector %ulong 4 %var_ty = OpTypePointer Function %v4ulong %ptr_ty = OpTypePointer Function %ulong %i = OpUndef %ulong)" << MainPrefix() << R"( ; CHECK: %[[GLSLSTD450:\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK-NOT: = OpTypeInt 32 ; CHECK-DAG: %long_0 = OpConstant %long 0 ; CHECK-DAG: %long_3 = OpConstant %long 3 ; CHECK-NOT: = OpTypeInt 32 ; CHECK: OpLabel ; CHECK: %[[clamp:\w+]] = OpExtInst %ulong %[[GLSLSTD450]] SClamp %i %long_0 %long_3 %var = OpVariable %var_ty Function)" << ACCheck(ac, "%i", "%[[clamp]]") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACMatrixLeastInboundConstantUntouched) { for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << ShaderPreambleAC() << TypesVoid() << TypesInt() << TypesFloat() << R"( %v2float = OpTypeVector %float 2 %mat4v2float = OpTypeMatrix %v2float 4 %var_ty = OpTypePointer Function %mat4v2float %ptr_ty = OpTypePointer Function %float %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 )" << MainPrefix() << R"( %var = OpVariable %var_ty Function)" << ACCheck(ac, "%uint_0 %uint_1", "%uint_0 %uint_1") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACMatrixMostInboundConstantUntouched) { for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << ShaderPreambleAC() << TypesVoid() << TypesInt() << TypesFloat() << R"( %v2float = OpTypeVector %float 2 %mat4v2float = OpTypeMatrix %v2float 4 %var_ty = OpTypePointer Function %mat4v2float %ptr_ty = OpTypePointer Function %float %uint_1 = OpConstant %uint 1 %uint_3 = OpConstant %uint 3 )" << MainPrefix() << R"( %var = OpVariable %var_ty Function)" << ACCheck(ac, "%uint_3 %uint_1", "%uint_3 %uint_1") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACMatrixExcessConstantClamped) { for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << ShaderPreambleAC() << TypesVoid() << TypesInt() << TypesFloat() << R"( %v2float = OpTypeVector %float 2 %mat4v2float = OpTypeMatrix %v2float 4 %var_ty = OpTypePointer Function %mat4v2float %ptr_ty = OpTypePointer Function %float %uint_1 = OpConstant %uint 1 %uint_4 = OpConstant %uint 4 )" << MainPrefix() << R"( ; CHECK: %int_3 = OpConstant %int 3 %var = OpVariable %var_ty Function)" << ACCheck(ac, "%uint_4 %uint_1", "%int_3 %uint_1") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACMatrixNegativeConstantClamped) { for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << ShaderPreambleAC() << TypesVoid() << TypesInt() << TypesFloat() << R"( %v2float = OpTypeVector %float 2 %mat4v2float = OpTypeMatrix %v2float 4 %var_ty = OpTypePointer Function %mat4v2float %ptr_ty = OpTypePointer Function %float %uint_1 = OpConstant %uint 1 %int_n1 = OpConstant %int -1 )" << MainPrefix() << R"( ; CHECK: %int_0 = OpConstant %int 0 %var = OpVariable %var_ty Function)" << ACCheck(ac, "%int_n1 %uint_1", "%int_0 %uint_1") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACMatrixGeneralClamped) { for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << ShaderPreambleAC({"i"}) << TypesVoid() << TypesInt() << TypesFloat() << R"( %v2float = OpTypeVector %float 2 %mat4v2float = OpTypeMatrix %v2float 4 %var_ty = OpTypePointer Function %mat4v2float %ptr_ty = OpTypePointer Function %float %uint_1 = OpConstant %uint 1 %i = OpUndef %int )" << MainPrefix() << R"( ; CHECK: %[[GLSLSTD450:\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK-DAG: %int_0 = OpConstant %int 0 ; CHECK-DAG: %int_3 = OpConstant %int 3 ; CHECK: OpLabel ; CHECK: %[[clamp:\w+]] = OpExtInst %int %[[GLSLSTD450]] SClamp %i %int_0 %int_3 %var = OpVariable %var_ty Function)" << ACCheck(ac, "%i %uint_1", "%[[clamp]] %uint_1") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACArrayLeastInboundConstantUntouched) { for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << ShaderPreambleAC() << TypesVoid() << TypesInt() << TypesFloat() << R"( %uint_200 = OpConstant %uint 200 %arr = OpTypeArray %float %uint_200 %var_ty = OpTypePointer Function %arr %ptr_ty = OpTypePointer Function %float %int_0 = OpConstant %int 0 )" << MainPrefix() << R"( %var = OpVariable %var_ty Function)" << ACCheck(ac, "%int_0", "%int_0") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACArrayMostInboundConstantUntouched) { for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << ShaderPreambleAC() << TypesVoid() << TypesInt() << TypesFloat() << R"( %uint_200 = OpConstant %uint 200 %arr = OpTypeArray %float %uint_200 %var_ty = OpTypePointer Function %arr %ptr_ty = OpTypePointer Function %float %int_199 = OpConstant %int 199 )" << MainPrefix() << R"( %var = OpVariable %var_ty Function)" << ACCheck(ac, "%int_199", "%int_199") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACArrayGeneralClamped) { for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << ShaderPreambleAC({"i"}) << TypesVoid() << TypesInt() << TypesFloat() << R"( %uint_200 = OpConstant %uint 200 %arr = OpTypeArray %float %uint_200 %var_ty = OpTypePointer Function %arr %ptr_ty = OpTypePointer Function %float %i = OpUndef %int )" << MainPrefix() << R"( ; CHECK: %[[GLSLSTD450:\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK-DAG: %int_0 = OpConstant %int 0 ; CHECK-DAG: %int_199 = OpConstant %int 199 ; CHECK: OpLabel ; CHECK: %[[clamp:\w+]] = OpExtInst %int %[[GLSLSTD450]] SClamp %i %int_0 %int_199 %var = OpVariable %var_ty Function)" << ACCheck(ac, "%i", "%[[clamp]]") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACArrayGeneralShortIndexUIntBoundsClamped) { // Index is signed short, array bounds overflows the index type. for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << "OpCapability Int16\n" << ShaderPreambleAC({"i"}) << TypesVoid() << TypesInt() << TypesShort() << TypesFloat() << R"( %uint_70000 = OpConstant %uint 70000 ; overflows 16bits %arr = OpTypeArray %float %uint_70000 %var_ty = OpTypePointer Function %arr %ptr_ty = OpTypePointer Function %float %i = OpUndef %short )" << MainPrefix() << R"( ; CHECK: %[[GLSLSTD450:\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK-DAG: %int_0 = OpConstant %int 0 ; CHECK-DAG: %int_69999 = OpConstant %int 69999 ; CHECK: OpLabel ; CHECK: %[[i_ext:\w+]] = OpSConvert %uint %i ; CHECK: %[[clamp:\w+]] = OpExtInst %uint %[[GLSLSTD450]] SClamp %[[i_ext]] %int_0 %int_69999 %var = OpVariable %var_ty Function)" << ACCheck(ac, "%i", "%[[clamp]]") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACArrayGeneralUShortIndexIntBoundsClamped) { // Index is unsigned short, array bounds overflows the index type. for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << "OpCapability Int16\n" << ShaderPreambleAC({"i"}) << TypesVoid() << TypesInt() << TypesShort() << TypesFloat() << R"( %int_70000 = OpConstant %int 70000 ; overflows 16bits %arr = OpTypeArray %float %int_70000 %var_ty = OpTypePointer Function %arr %ptr_ty = OpTypePointer Function %float %i = OpUndef %ushort )" << MainPrefix() << R"( ; CHECK: %[[GLSLSTD450:\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK-DAG: %int_0 = OpConstant %int 0 ; CHECK-DAG: %int_69999 = OpConstant %int 69999 ; CHECK: OpLabel ; CHECK: %[[i_ext:\w+]] = OpUConvert %uint %i ; CHECK: %[[clamp:\w+]] = OpExtInst %uint %[[GLSLSTD450]] SClamp %[[i_ext]] %int_0 %int_69999 %var = OpVariable %var_ty Function)" << ACCheck(ac, "%i", "%[[clamp]]") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACArrayGeneralUIntIndexShortBoundsClamped) { // Signed int index i is wider than the array bounds type. for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << "OpCapability Int16\n" << ShaderPreambleAC({"i"}) << TypesVoid() << TypesInt() << TypesShort() << TypesFloat() << R"( %short_200 = OpConstant %short 200 %arr = OpTypeArray %float %short_200 %var_ty = OpTypePointer Function %arr %ptr_ty = OpTypePointer Function %float %i = OpUndef %uint )" << MainPrefix() << R"( ; CHECK: %[[GLSLSTD450:\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK-DAG: %int_0 = OpConstant %int 0 ; CHECK-DAG: %int_199 = OpConstant %int 199 ; CHECK: OpLabel ; CHECK: %[[clamp:\w+]] = OpExtInst %uint %[[GLSLSTD450]] SClamp %i %int_0 %int_199 %var = OpVariable %var_ty Function)" << ACCheck(ac, "%i", "%[[clamp]]") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACArrayGeneralIntIndexUShortBoundsClamped) { // Unsigned int index i is wider than the array bounds type. for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << "OpCapability Int16\n" << ShaderPreambleAC({"i"}) << TypesVoid() << TypesInt() << TypesShort() << TypesFloat() << R"( %ushort_200 = OpConstant %ushort 200 %arr = OpTypeArray %float %ushort_200 %var_ty = OpTypePointer Function %arr %ptr_ty = OpTypePointer Function %float %i = OpUndef %int )" << MainPrefix() << R"( ; CHECK: %[[GLSLSTD450:\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK-DAG: %int_0 = OpConstant %int 0 ; CHECK-DAG: %int_199 = OpConstant %int 199 ; CHECK: OpLabel ; CHECK: %[[clamp:\w+]] = OpExtInst %int %[[GLSLSTD450]] SClamp %i %int_0 %int_199 %var = OpVariable %var_ty Function)" << ACCheck(ac, "%i", "%[[clamp]]") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACArrayGeneralLongIndexUIntBoundsClamped) { // Signed long index i is wider than the array bounds type. for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << "OpCapability Int64\n" << ShaderPreambleAC({"i"}) << TypesVoid() << TypesInt() << TypesLong() << TypesFloat() << R"( %uint_200 = OpConstant %uint 200 %arr = OpTypeArray %float %uint_200 %var_ty = OpTypePointer Function %arr %ptr_ty = OpTypePointer Function %float %i = OpUndef %long )" << MainPrefix() << R"( ; CHECK: %[[GLSLSTD450:\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK-DAG: %long_0 = OpConstant %long 0 ; CHECK-DAG: %long_199 = OpConstant %long 199 ; CHECK: OpLabel ; CHECK: %[[clamp:\w+]] = OpExtInst %long %[[GLSLSTD450]] SClamp %i %long_0 %long_199 %var = OpVariable %var_ty Function)" << ACCheck(ac, "%i", "%[[clamp]]") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACArrayGeneralULongIndexIntBoundsClamped) { // Unsigned long index i is wider than the array bounds type. for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << "OpCapability Int64\n" << ShaderPreambleAC({"i"}) << TypesVoid() << TypesInt() << TypesLong() << TypesFloat() << R"( %int_200 = OpConstant %int 200 %arr = OpTypeArray %float %int_200 %var_ty = OpTypePointer Function %arr %ptr_ty = OpTypePointer Function %float %i = OpUndef %ulong )" << MainPrefix() << R"( ; CHECK: %[[GLSLSTD450:\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK-DAG: %long_0 = OpConstant %long 0 ; CHECK-DAG: %long_199 = OpConstant %long 199 ; CHECK: OpLabel ; CHECK: %[[clamp:\w+]] = OpExtInst %ulong %[[GLSLSTD450]] SClamp %i %long_0 %long_199 %var = OpVariable %var_ty Function)" << ACCheck(ac, "%i", "%[[clamp]]") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACArrayGeneralShortIndeArrayBiggerThanShortMaxClipsToShortIntMax) { for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << "OpCapability Int16\n" << ShaderPreambleAC({"i"}) << TypesVoid() << TypesShort() << TypesInt() << TypesFloat() << R"( %uint_50000 = OpConstant %uint 50000 %arr = OpTypeArray %float %uint_50000 %var_ty = OpTypePointer Function %arr %ptr_ty = OpTypePointer Function %float %i = OpUndef %ushort )" << MainPrefix() << R"( ; CHECK: %[[GLSLSTD450:\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK-DAG: %short_0 = OpConstant %short 0 ; CHECK-DAG: %[[intmax:\w+]] = OpConstant %short 32767 ; CHECK: OpLabel ; CHECK: %[[clamp:\w+]] = OpExtInst %ushort %[[GLSLSTD450]] SClamp %i %short_0 %[[intmax]] %var = OpVariable %var_ty Function)" << ACCheck(ac, "%i", "%[[clamp]]") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACArrayGeneralIntIndexArrayBiggerThanIntMaxClipsToSignedIntMax) { for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << ShaderPreambleAC({"i"}) << TypesVoid() << TypesInt() << TypesFloat() << R"( %uint_3000000000 = OpConstant %uint 3000000000 %arr = OpTypeArray %float %uint_3000000000 %var_ty = OpTypePointer Function %arr %ptr_ty = OpTypePointer Function %float %i = OpUndef %uint )" << MainPrefix() << R"( ; CHECK: %[[GLSLSTD450:\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK-DAG: %int_0 = OpConstant %int 0 ; CHECK-DAG: %[[intmax:\w+]] = OpConstant %int 2147483647 ; CHECK: OpLabel ; CHECK: %[[clamp:\w+]] = OpExtInst %uint %[[GLSLSTD450]] SClamp %i %int_0 %[[intmax]] %var = OpVariable %var_ty Function)" << ACCheck(ac, "%i", "%[[clamp]]") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACArrayGeneralLongIndexArrayBiggerThanLongMaxClipsToSignedLongMax) { for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << "OpCapability Int64\n" << ShaderPreambleAC({"i"}) << TypesVoid() << TypesInt() << TypesLong() << TypesFloat() // 2^63 == 9,223,372,036,854,775,807 << R"( %ulong_9223372036854775999 = OpConstant %ulong 9223372036854775999 %arr = OpTypeArray %float %ulong_9223372036854775999 %var_ty = OpTypePointer Function %arr %ptr_ty = OpTypePointer Function %float %i = OpUndef %ulong )" << MainPrefix() << R"( ; CHECK: %[[GLSLSTD450:\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK-DAG: %long_0 = OpConstant %long 0 ; CHECK-DAG: %[[intmax:\w+]] = OpConstant %long 9223372036854775807 ; CHECK: OpLabel ; CHECK: %[[clamp:\w+]] = OpExtInst %ulong %[[GLSLSTD450]] SClamp %i %long_0 %[[intmax]] %var = OpVariable %var_ty Function)" << ACCheck(ac, "%i", "%[[clamp]]") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACArraySpecIdSizedAlwaysClamped) { for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << ShaderPreambleAC({"spec200"}) << R"( OpDecorate %spec200 SpecId 0 )" << TypesVoid() << TypesInt() << TypesFloat() << R"( %spec200 = OpSpecConstant %int 200 %arr = OpTypeArray %float %spec200 %var_ty = OpTypePointer Function %arr %ptr_ty = OpTypePointer Function %float %uint_5 = OpConstant %uint 5 )" << MainPrefix() << R"( ; CHECK: %[[GLSLSTD450:\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK-DAG: %uint_0 = OpConstant %uint 0 ; CHECK-DAG: %uint_1 = OpConstant %uint 1 ; CHECK-DAG: %[[uint_intmax:\w+]] = OpConstant %uint 2147483647 ; CHECK: OpLabel ; CHECK: %[[max:\w+]] = OpISub %uint %spec200 %uint_1 ; CHECK: %[[smin:\w+]] = OpExtInst %uint %[[GLSLSTD450]] UMin %[[max]] %[[uint_intmax]] ; CHECK: %[[clamp:\w+]] = OpExtInst %uint %[[GLSLSTD450]] SClamp %uint_5 %uint_0 %[[smin]] %var = OpVariable %var_ty Function)" << ACCheck(ac, "%uint_5", "%[[clamp]]") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACStructLeastUntouched) { for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << ShaderPreambleAC() << TypesVoid() << TypesInt() << TypesFloat() << R"( %struct = OpTypeStruct %float %float %float %var_ty = OpTypePointer Function %struct %ptr_ty = OpTypePointer Function %float %int_0 = OpConstant %int 0 )" << MainPrefix() << R"( %var = OpVariable %var_ty Function)" << ACCheck(ac, "%int_0", "%int_0") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACStructMostUntouched) { for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << ShaderPreambleAC() << TypesVoid() << TypesInt() << TypesFloat() << R"( %struct = OpTypeStruct %float %float %float %var_ty = OpTypePointer Function %struct %ptr_ty = OpTypePointer Function %float %int_2 = OpConstant %int 2 )" << MainPrefix() << R"( %var = OpVariable %var_ty Function)" << ACCheck(ac, "%int_2", "%int_2") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACStructSpecConstantFail) { for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << ShaderPreambleAC({"struct", "spec200"}) << "OpDecorate %spec200 SpecId 0\n" << TypesVoid() << TypesInt() << TypesFloat() << R"( %spec200 = OpSpecConstant %int 200 %struct = OpTypeStruct %float %float %float %var_ty = OpTypePointer Function %struct %ptr_ty = OpTypePointer Function %float )" << MainPrefix() << R"( %var = OpVariable %var_ty Function ; CHECK: Member index into struct is not a constant integer ; CHECK-SAME: %spec200 = OpSpecConstant %int 200 )" << ACCheckFail(ac, "%spec200", "%spec200") << MainSuffix(); SinglePassRunAndFail(shaders.str()); } } TEST_F(GraphicsRobustAccessTest, ACStructFloatConstantFail) { for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << ShaderPreambleAC({"struct"}) << TypesVoid() << TypesInt() << TypesFloat() << R"( %float_2 = OpConstant %float 2 %struct = OpTypeStruct %float %float %float %var_ty = OpTypePointer Function %struct %ptr_ty = OpTypePointer Function %float )" << MainPrefix() << R"( %var = OpVariable %var_ty Function ; CHECK: Member index into struct is not a constant integer ; CHECK-SAME: %float_2 = OpConstant %float 2 )" << ACCheckFail(ac, "%float_2", "%float_2") << MainSuffix(); SinglePassRunAndFail(shaders.str()); } } TEST_F(GraphicsRobustAccessTest, ACStructNonConstantFail) { for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << ShaderPreambleAC({"struct", "i"}) << TypesVoid() << TypesInt() << TypesFloat() << R"( %float_2 = OpConstant %float 2 %struct = OpTypeStruct %float %float %float %var_ty = OpTypePointer Function %struct %ptr_ty = OpTypePointer Function %float %i = OpUndef %int )" << MainPrefix() << R"( %var = OpVariable %var_ty Function ; CHECK: Member index into struct is not a constant integer ; CHECK-SAME: %i = OpUndef %int )" << ACCheckFail(ac, "%i", "%i") << MainSuffix(); SinglePassRunAndFail(shaders.str()); } } TEST_F(GraphicsRobustAccessTest, ACStructExcessFail) { for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << ShaderPreambleAC({"struct", "i"}) << TypesVoid() << TypesInt() << TypesFloat() << R"( %struct = OpTypeStruct %float %float %float %var_ty = OpTypePointer Function %struct %ptr_ty = OpTypePointer Function %float %i = OpConstant %int 4 )" << MainPrefix() << R"( %var = OpVariable %var_ty Function ; CHECK: Member index 4 is out of bounds for struct type: ; CHECK-SAME: %struct = OpTypeStruct %float %float %float )" << ACCheckFail(ac, "%i", "%i") << MainSuffix(); SinglePassRunAndFail(shaders.str()); } } TEST_F(GraphicsRobustAccessTest, ACStructNegativeFail) { for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << ShaderPreambleAC({"struct", "i"}) << TypesVoid() << TypesInt() << TypesFloat() << R"( %struct = OpTypeStruct %float %float %float %var_ty = OpTypePointer Function %struct %ptr_ty = OpTypePointer Function %float %i = OpConstant %int -1 )" << MainPrefix() << R"( %var = OpVariable %var_ty Function ; CHECK: Member index -1 is out of bounds for struct type: ; CHECK-SAME: %struct = OpTypeStruct %float %float %float )" << ACCheckFail(ac, "%i", "%i") << MainSuffix(); SinglePassRunAndFail(shaders.str()); } } TEST_F(GraphicsRobustAccessTest, ACRTArrayLeastInboundClamped) { for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << ShaderPreambleAC() << "OpDecorate %rtarr ArrayStride 4 " << DecoSSBO() << TypesVoid() << TypesInt() << TypesFloat() << R"( %rtarr = OpTypeRuntimeArray %float %ssbo_s = OpTypeStruct %uint %uint %rtarr %var_ty = OpTypePointer Uniform %ssbo_s %ptr_ty = OpTypePointer Uniform %float %var = OpVariable %var_ty Uniform %int_0 = OpConstant %int 0 %int_2 = OpConstant %int 2 ; CHECK: %[[GLSLSTD450:\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK-DAG: %int_1 = OpConstant %int 1 ; CHECK-DAG: %[[intmax:\w+]] = OpConstant %int 2147483647 ; CHECK: OpLabel ; CHECK: %[[arrlen:\w+]] = OpArrayLength %uint %var 2 ; CHECK: %[[max:\w+]] = OpISub %int %[[arrlen]] %int_1 ; CHECK: %[[smin:\w+]] = OpExtInst %int %[[GLSLSTD450]] UMin %[[max]] %[[intmax]] ; CHECK: %[[clamp:\w+]] = OpExtInst %int %[[GLSLSTD450]] SClamp %int_0 %int_0 %[[smin]] )" << MainPrefix() << ACCheck(ac, "%int_2 %int_0", "%int_2 %[[clamp]]") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACRTArrayGeneralShortIndexClamped) { for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << "OpCapability Int16\n" << ShaderPreambleAC({"i"}) << "OpDecorate %rtarr ArrayStride 4 " << DecoSSBO() << TypesVoid() << TypesShort() << TypesFloat() << R"( %rtarr = OpTypeRuntimeArray %float %ssbo_s = OpTypeStruct %short %short %rtarr %var_ty = OpTypePointer Uniform %ssbo_s %ptr_ty = OpTypePointer Uniform %float %var = OpVariable %var_ty Uniform %short_2 = OpConstant %short 2 %i = OpUndef %short ; CHECK: %[[GLSLSTD450:\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK: %uint = OpTypeInt 32 0 ; CHECK-DAG: %uint_1 = OpConstant %uint 1 ; CHECK-DAG: %uint_0 = OpConstant %uint 0 ; CHECK-DAG: %[[intmax:\w+]] = OpConstant %uint 2147483647 ; CHECK: OpLabel ; CHECK: %[[arrlen:\w+]] = OpArrayLength %uint %var 2 ; CHECK-DAG: %[[max:\w+]] = OpISub %uint %[[arrlen]] %uint_1 ; CHECK-DAG: %[[i_ext:\w+]] = OpSConvert %uint %i ; CHECK: %[[smin:\w+]] = OpExtInst %uint %[[GLSLSTD450]] UMin %[[max]] %[[intmax]] ; CHECK: %[[clamp:\w+]] = OpExtInst %uint %[[GLSLSTD450]] SClamp %[[i_ext]] %uint_0 %[[smin]] )" << MainPrefix() << ACCheck(ac, "%short_2 %i", "%short_2 %[[clamp]]") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACRTArrayGeneralUShortIndexClamped) { for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << "OpCapability Int16\n" << ShaderPreambleAC({"i"}) << "OpDecorate %rtarr ArrayStride 4 " << DecoSSBO() << TypesVoid() << TypesShort() << TypesFloat() << R"( %rtarr = OpTypeRuntimeArray %float %ssbo_s = OpTypeStruct %short %short %rtarr %var_ty = OpTypePointer Uniform %ssbo_s %ptr_ty = OpTypePointer Uniform %float %var = OpVariable %var_ty Uniform %short_2 = OpConstant %short 2 %i = OpUndef %ushort ; CHECK: %[[GLSLSTD450:\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK: %uint = OpTypeInt 32 0 ; CHECK-DAG: %uint_1 = OpConstant %uint 1 ; CHECK-DAG: %uint_0 = OpConstant %uint 0 ; CHECK-DAG: %[[intmax:\w+]] = OpConstant %uint 2147483647 ; CHECK: OpLabel ; CHECK: %[[arrlen:\w+]] = OpArrayLength %uint %var 2 ; CHECK-DAG: %[[max:\w+]] = OpISub %uint %[[arrlen]] %uint_1 ; CHECK-DAG: %[[i_ext:\w+]] = OpSConvert %uint %i ; CHECK: %[[smin:\w+]] = OpExtInst %uint %[[GLSLSTD450]] UMin %[[max]] %[[intmax]] ; CHECK: %[[clamp:\w+]] = OpExtInst %uint %[[GLSLSTD450]] SClamp %[[i_ext]] %uint_0 %[[smin]] )" << MainPrefix() << ACCheck(ac, "%short_2 %i", "%short_2 %[[clamp]]") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACRTArrayGeneralIntIndexClamped) { for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << ShaderPreambleAC({"i"}) << "OpDecorate %rtarr ArrayStride 4 " << DecoSSBO() << TypesVoid() << TypesInt() << TypesFloat() << R"( %rtarr = OpTypeRuntimeArray %float %ssbo_s = OpTypeStruct %int %int %rtarr %var_ty = OpTypePointer Uniform %ssbo_s %ptr_ty = OpTypePointer Uniform %float %var = OpVariable %var_ty Uniform %int_2 = OpConstant %int 2 %i = OpUndef %int ; CHECK: %[[GLSLSTD450:\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK-DAG: %int_1 = OpConstant %int 1 ; CHECK-DAG: %int_0 = OpConstant %int 0 ; CHECK-DAG: %[[intmax:\w+]] = OpConstant %int 2147483647 ; CHECK: OpLabel ; CHECK: %[[arrlen:\w+]] = OpArrayLength %uint %var 2 ; CHECK: %[[max:\w+]] = OpISub %int %[[arrlen]] %int_1 ; CHECK: %[[smin:\w+]] = OpExtInst %int %[[GLSLSTD450]] UMin %[[max]] %[[intmax]] ; CHECK: %[[clamp:\w+]] = OpExtInst %int %[[GLSLSTD450]] SClamp %i %int_0 %[[smin]] )" << MainPrefix() << ACCheck(ac, "%int_2 %i", "%int_2 %[[clamp]]") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACRTArrayGeneralUIntIndexClamped) { for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << ShaderPreambleAC({"i"}) << "OpDecorate %rtarr ArrayStride 4 " << DecoSSBO() << TypesVoid() << TypesInt() << TypesFloat() << R"( %rtarr = OpTypeRuntimeArray %float %ssbo_s = OpTypeStruct %int %int %rtarr %var_ty = OpTypePointer Uniform %ssbo_s %ptr_ty = OpTypePointer Uniform %float %var = OpVariable %var_ty Uniform %int_2 = OpConstant %int 2 %i = OpUndef %uint ; CHECK: %[[GLSLSTD450:\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK-DAG: %uint_1 = OpConstant %uint 1 ; CHECK-DAG: %uint_0 = OpConstant %uint 0 ; CHECK-DAG: %[[intmax:\w+]] = OpConstant %uint 2147483647 ; CHECK: OpLabel ; CHECK: %[[arrlen:\w+]] = OpArrayLength %uint %var 2 ; CHECK: %[[max:\w+]] = OpISub %uint %[[arrlen]] %uint_1 ; CHECK: %[[smin:\w+]] = OpExtInst %uint %[[GLSLSTD450]] UMin %[[max]] %[[intmax]] ; CHECK: %[[clamp:\w+]] = OpExtInst %uint %[[GLSLSTD450]] SClamp %i %uint_0 %[[smin]] )" << MainPrefix() << ACCheck(ac, "%int_2 %i", "%int_2 %[[clamp]]") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACRTArrayGeneralLongIndexClamped) { for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << "OpCapability Int64" << ShaderPreambleAC({"i"}) << "OpDecorate %rtarr ArrayStride 4 " << DecoSSBO() << TypesVoid() << TypesInt() << TypesLong() << TypesFloat() << R"( %rtarr = OpTypeRuntimeArray %float %ssbo_s = OpTypeStruct %int %int %rtarr %var_ty = OpTypePointer Uniform %ssbo_s %ptr_ty = OpTypePointer Uniform %float %var = OpVariable %var_ty Uniform %int_2 = OpConstant %int 2 %i = OpUndef %long ; CHECK: %[[GLSLSTD450:\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK-DAG: %long_0 = OpConstant %long 0 ; CHECK-DAG: %long_1 = OpConstant %long 1 ; CHECK-DAG: %[[longmax:\w+]] = OpConstant %long 9223372036854775807 ; CHECK: OpLabel ; CHECK: %[[arrlen:\w+]] = OpArrayLength %uint %var 2 ; CHECK: %[[arrlen_ext:\w+]] = OpUConvert %ulong %[[arrlen]] ; CHECK: %[[max:\w+]] = OpISub %long %[[arrlen_ext]] %long_1 ; CHECK: %[[smin:\w+]] = OpExtInst %long %[[GLSLSTD450]] UMin %[[max]] %[[longmax]] ; CHECK: %[[clamp:\w+]] = OpExtInst %long %[[GLSLSTD450]] SClamp %i %long_0 %[[smin]] )" << MainPrefix() << ACCheck(ac, "%int_2 %i", "%int_2 %[[clamp]]") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACRTArrayGeneralULongIndexClamped) { for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << "OpCapability Int64" << ShaderPreambleAC({"i"}) << "OpDecorate %rtarr ArrayStride 4 " << DecoSSBO() << TypesVoid() << TypesInt() << TypesLong() << TypesFloat() << R"( %rtarr = OpTypeRuntimeArray %float %ssbo_s = OpTypeStruct %int %int %rtarr %var_ty = OpTypePointer Uniform %ssbo_s %ptr_ty = OpTypePointer Uniform %float %var = OpVariable %var_ty Uniform %int_2 = OpConstant %int 2 %i = OpUndef %ulong ; CHECK: %[[GLSLSTD450:\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK-DAG: %ulong_0 = OpConstant %ulong 0 ; CHECK-DAG: %ulong_1 = OpConstant %ulong 1 ; CHECK-DAG: %[[longmax:\w+]] = OpConstant %ulong 9223372036854775807 ; CHECK: OpLabel ; CHECK: %[[arrlen:\w+]] = OpArrayLength %uint %var 2 ; CHECK: %[[arrlen_ext:\w+]] = OpUConvert %ulong %[[arrlen]] ; CHECK: %[[max:\w+]] = OpISub %ulong %[[arrlen_ext]] %ulong_1 ; CHECK: %[[smin:\w+]] = OpExtInst %ulong %[[GLSLSTD450]] UMin %[[max]] %[[longmax]] ; CHECK: %[[clamp:\w+]] = OpExtInst %ulong %[[GLSLSTD450]] SClamp %i %ulong_0 %[[smin]] )" << MainPrefix() << ACCheck(ac, "%int_2 %i", "%int_2 %[[clamp]]") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACRTArrayStructVectorElem) { // The point of this test is that the access chain can have indices past the // index into the runtime array. For good measure, the index into the final // struct is out of bounds. We have to clamp that index too. for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << ShaderPreambleAC({"i", "j"}) << "OpDecorate %rtarr ArrayStride 32\n" << DecoSSBO() << "OpMemberDecorate %rtelem 0 Offset 0\n" << "OpMemberDecorate %rtelem 1 Offset 16\n" << TypesVoid() << TypesInt() << TypesFloat() << R"( %v4float = OpTypeVector %float 4 %rtelem = OpTypeStruct %v4float %v4float %rtarr = OpTypeRuntimeArray %rtelem %ssbo_s = OpTypeStruct %int %int %rtarr %var_ty = OpTypePointer Uniform %ssbo_s %ptr_ty = OpTypePointer Uniform %float %var = OpVariable %var_ty Uniform %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %i = OpUndef %int %j = OpUndef %int ; CHECK: %[[GLSLSTD450:\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK-DAG: %int_0 = OpConstant %int 0 ; CHECK-DAG: %int_3 = OpConstant %int 3 ; CHECK-DAG: %[[intmax:\w+]] = OpConstant %int 2147483647 ; CHECK: OpLabel ; CHECK: %[[arrlen:\w+]] = OpArrayLength %uint %var 2 ; CHECK: %[[max:\w+]] = OpISub %int %[[arrlen]] %int_1 ; CHECK: %[[smin:\w+]] = OpExtInst %int %[[GLSLSTD450]] UMin %[[max]] %[[intmax]] ; CHECK: %[[clamp_i:\w+]] = OpExtInst %int %[[GLSLSTD450]] SClamp %i %int_0 %[[smin]] ; CHECK: %[[clamp_j:\w+]] = OpExtInst %int %[[GLSLSTD450]] SClamp %j %int_0 %int_3 )" << MainPrefix() << ACCheck(ac, "%int_2 %i %int_1 %j", "%int_2 %[[clamp_i]] %int_1 %[[clamp_j]]") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACArrayRTArrayStructVectorElem) { // Now add an additional level of arrays around the Block-decorated struct. for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << ShaderPreambleAC({"i", "ssbo_s"}) << "OpDecorate %rtarr ArrayStride 32\n" << DecoSSBO() << "OpMemberDecorate %rtelem 0 Offset 0\n" << "OpMemberDecorate %rtelem 1 Offset 16\n" << TypesVoid() << TypesInt() << TypesFloat() << R"( %v4float = OpTypeVector %float 4 %rtelem = OpTypeStruct %v4float %v4float %rtarr = OpTypeRuntimeArray %rtelem %ssbo_s = OpTypeStruct %int %int %rtarr %arr_size = OpConstant %int 10 %arr_ssbo = OpTypeArray %ssbo_s %arr_size %var_ty = OpTypePointer Uniform %arr_ssbo %ptr_ty = OpTypePointer Uniform %float %var = OpVariable %var_ty Uniform %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %int_17 = OpConstant %int 17 %i = OpUndef %int ; CHECK: %[[GLSLSTD450:\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK-DAG: %[[ssbo_p:\w+]] = OpTypePointer Uniform %ssbo_s ; CHECK-DAG: %int_0 = OpConstant %int 0 ; CHECK-DAG: %int_9 = OpConstant %int 9 ; CHECK-DAG: %[[intmax:\w+]] = OpConstant %int 2147483647 ; CHECK: OpLabel ; This access chain is manufactured only so we can compute the array length. ; Note that the %int_9 is already clamped ; CHECK: %[[ssbo_base:\w+]] = )" << ac << R"( %[[ssbo_p]] %var %int_9 ; CHECK: %[[arrlen:\w+]] = OpArrayLength %uint %[[ssbo_base]] 2 ; CHECK: %[[max:\w+]] = OpISub %int %[[arrlen]] %int_1 ; CHECK: %[[smin:\w+]] = OpExtInst %int %[[GLSLSTD450]] UMin %[[max]] %[[intmax]] ; CHECK: %[[clamp_i:\w+]] = OpExtInst %int %[[GLSLSTD450]] SClamp %i %int_0 %[[smin]] )" << MainPrefix() << ACCheck(ac, "%int_17 %int_2 %i %int_1 %int_2", "%int_9 %int_2 %[[clamp_i]] %int_1 %int_2") << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACSplitACArrayRTArrayStructVectorElem) { // Split the address calculation across two access chains. Force // the transform to walk up the access chains to find the base variable. for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << ShaderPreambleAC({"i", "j", "k", "ssbo_s", "ssbo_pty", "rtarr_pty", "ac_ssbo", "ac_rtarr"}) << "OpDecorate %rtarr ArrayStride 32\n" << DecoSSBO() << "OpMemberDecorate %rtelem 0 Offset 0\n" << "OpMemberDecorate %rtelem 1 Offset 16\n" << TypesVoid() << TypesInt() << TypesFloat() << R"( %v4float = OpTypeVector %float 4 %rtelem = OpTypeStruct %v4float %v4float %rtarr = OpTypeRuntimeArray %rtelem %ssbo_s = OpTypeStruct %int %int %rtarr %arr_size = OpConstant %int 10 %arr_ssbo = OpTypeArray %ssbo_s %arr_size %var_ty = OpTypePointer Uniform %arr_ssbo %ssbo_pty = OpTypePointer Uniform %ssbo_s %rtarr_pty = OpTypePointer Uniform %rtarr %ptr_ty = OpTypePointer Uniform %float %var = OpVariable %var_ty Uniform %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %i = OpUndef %int %j = OpUndef %int %k = OpUndef %int ; CHECK: %[[GLSLSTD450:\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK-DAG: %int_0 = OpConstant %int 0 ; CHECK-DAG: %int_9 = OpConstant %int 9 ; CHECK-DAG: %int_3 = OpConstant %int 3 ; CHECK-DAG: %[[intmax:\w+]] = OpConstant %int 2147483647 ; CHECK: OpLabel ; CHECK: %[[clamp_i:\w+]] = OpExtInst %int %[[GLSLSTD450]] SClamp %i %int_0 %int_9 ; CHECK: %ac_ssbo = )" << ac << R"( %ssbo_pty %var %[[clamp_i]] ; CHECK: %ac_rtarr = )" << ac << R"( %rtarr_pty %ac_ssbo %int_2 ; This is the interesting bit. This array length is needed for an OpAccessChain ; computing %ac, but the algorithm had to track back through %ac_rtarr's ; definition to find the base pointer %ac_ssbo. ; CHECK: %[[arrlen:\w+]] = OpArrayLength %uint %ac_ssbo 2 ; CHECK: %[[max:\w+]] = OpISub %int %[[arrlen]] %int_1 ; CHECK: %[[smin:\w+]] = OpExtInst %int %[[GLSLSTD450]] UMin %[[max]] %[[intmax]] ; CHECK: %[[clamp_j:\w+]] = OpExtInst %int %[[GLSLSTD450]] SClamp %j %int_0 %[[smin]] ; CHECK: %[[clamp_k:\w+]] = OpExtInst %int %[[GLSLSTD450]] SClamp %k %int_0 %int_3 ; CHECK: %ac = )" << ac << R"( %ptr_ty %ac_rtarr %[[clamp_j]] %int_1 %[[clamp_k]] ; CHECK-NOT: AccessChain )" << MainPrefix() << "%ac_ssbo = " << ac << " %ssbo_pty %var %i\n" << "%ac_rtarr = " << ac << " %rtarr_pty %ac_ssbo %int_2\n" << "%ac = " << ac << " %ptr_ty %ac_rtarr %j %int_1 %k\n" << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, ACSplitACArrayRTArrayStructVectorElemAcrossBasicBlocks) { // Split the address calculation across two access chains. Force // the transform to walk up the access chains to find the base variable. // This time, put the different access chains in different basic blocks. // This is an integrity check to ensure that we keep the instruction-to-block // mapping consistent. for (auto* ac : AccessChains()) { std::ostringstream shaders; shaders << ShaderPreambleAC({"i", "j", "k", "bb1", "bb2", "ssbo_s", "ssbo_pty", "rtarr_pty", "ac_ssbo", "ac_rtarr"}) << "OpDecorate %rtarr ArrayStride 32\n" << DecoSSBO() << "OpMemberDecorate %rtelem 0 Offset 0\n" << "OpMemberDecorate %rtelem 1 Offset 16\n" << TypesVoid() << TypesInt() << TypesFloat() << R"( %v4float = OpTypeVector %float 4 %rtelem = OpTypeStruct %v4float %v4float %rtarr = OpTypeRuntimeArray %rtelem %ssbo_s = OpTypeStruct %int %int %rtarr %arr_size = OpConstant %int 10 %arr_ssbo = OpTypeArray %ssbo_s %arr_size %var_ty = OpTypePointer Uniform %arr_ssbo %ssbo_pty = OpTypePointer Uniform %ssbo_s %rtarr_pty = OpTypePointer Uniform %rtarr %ptr_ty = OpTypePointer Uniform %float %var = OpVariable %var_ty Uniform %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %i = OpUndef %int %j = OpUndef %int %k = OpUndef %int ; CHECK: %[[GLSLSTD450:\w+]] = OpExtInstImport "GLSL.std.450" ; CHECK-DAG: %int_0 = OpConstant %int 0 ; CHECK-DAG: %int_9 = OpConstant %int 9 ; CHECK-DAG: %int_3 = OpConstant %int 3 ; CHECK-DAG: %[[intmax:\w+]] = OpConstant %int 2147483647 ; CHECK: OpLabel ; CHECK: %[[clamp_i:\w+]] = OpExtInst %int %[[GLSLSTD450]] SClamp %i %int_0 %int_9 ; CHECK: %ac_ssbo = )" << ac << R"( %ssbo_pty %var %[[clamp_i]] ; CHECK: %bb1 = OpLabel ; CHECK: %ac_rtarr = )" << ac << R"( %rtarr_pty %ac_ssbo %int_2 ; CHECK: %bb2 = OpLabel ; This is the interesting bit. This array length is needed for an OpAccessChain ; computing %ac, but the algorithm had to track back through %ac_rtarr's ; definition to find the base pointer %ac_ssbo. ; CHECK: %[[arrlen:\w+]] = OpArrayLength %uint %ac_ssbo 2 ; CHECK: %[[max:\w+]] = OpISub %int %[[arrlen]] %int_1 ; CHECK: %[[smin:\w+]] = OpExtInst %int %[[GLSLSTD450]] UMin %[[max]] %[[intmax]] ; CHECK: %[[clamp_j:\w+]] = OpExtInst %int %[[GLSLSTD450]] SClamp %j %int_0 %[[smin]] ; CHECK: %[[clamp_k:\w+]] = OpExtInst %int %[[GLSLSTD450]] SClamp %k %int_0 %int_3 ; CHECK: %ac = )" << ac << R"( %ptr_ty %ac_rtarr %[[clamp_j]] %int_1 %[[clamp_k]] ; CHECK-NOT: AccessChain )" << MainPrefix() << "%ac_ssbo = " << ac << " %ssbo_pty %var %i\n" << "OpBranch %bb1\n%bb1 = OpLabel\n" << "%ac_rtarr = " << ac << " %rtarr_pty %ac_ssbo %int_2\n" << "OpBranch %bb2\n%bb2 = OpLabel\n" << "%ac = " << ac << " %ptr_ty %ac_rtarr %j %int_1 %k\n" << MainSuffix(); SinglePassRunAndMatch(shaders.str(), true); } } TEST_F(GraphicsRobustAccessTest, bug3813) { // This shader comes from Dawn's // TextureViewSamplingTest.TextureCubeMapOnWholeTexture, converted from GLSL // by glslang. // The pass was inserting a signed 32-bit int type, but not correctly marking // the shader as changed. std::string shader = R"( ; SPIR-V ; Version: 1.0 ; Generator: Google Shaderc over Glslang; 10 ; Bound: 46 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %12 %29 OpExecutionMode %4 OriginUpperLeft OpSource GLSL 450 OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpName %4 "main" OpName %8 "sc" OpName %12 "texCoord" OpName %21 "tc" OpName %29 "fragColor" OpName %32 "texture0" OpName %36 "sampler0" OpDecorate %12 Location 0 OpDecorate %29 Location 0 OpDecorate %32 DescriptorSet 0 OpDecorate %32 Binding 1 OpDecorate %36 DescriptorSet 0 OpDecorate %36 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %9 = OpConstant %6 2 %10 = OpTypeVector %6 2 %11 = OpTypePointer Input %10 %12 = OpVariable %11 Input %13 = OpTypeInt 32 0 %14 = OpConstant %13 0 %15 = OpTypePointer Input %6 %19 = OpConstant %6 1 %22 = OpConstant %13 1 %27 = OpTypeVector %6 4 %28 = OpTypePointer Output %27 %29 = OpVariable %28 Output %30 = OpTypeImage %6 Cube 0 0 0 1 Unknown %31 = OpTypePointer UniformConstant %30 %32 = OpVariable %31 UniformConstant %34 = OpTypeSampler %35 = OpTypePointer UniformConstant %34 %36 = OpVariable %35 UniformConstant %38 = OpTypeSampledImage %30 %43 = OpTypeVector %6 3 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %21 = OpVariable %7 Function %16 = OpAccessChain %15 %12 %14 %17 = OpLoad %6 %16 %18 = OpFMul %6 %9 %17 %20 = OpFSub %6 %18 %19 OpStore %8 %20 %23 = OpAccessChain %15 %12 %22 %24 = OpLoad %6 %23 %25 = OpFMul %6 %9 %24 %26 = OpFSub %6 %25 %19 OpStore %21 %26 %33 = OpLoad %30 %32 %37 = OpLoad %34 %36 %39 = OpSampledImage %38 %33 %37 %40 = OpLoad %6 %21 %41 = OpLoad %6 %8 %42 = OpFNegate %6 %41 %44 = OpCompositeConstruct %43 %19 %40 %42 %45 = OpImageSampleImplicitLod %27 %39 %44 OpStore %29 %45 OpReturn OpFunctionEnd )"; std::string expected = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %texCoord %fragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpName %main "main" OpName %sc "sc" OpName %texCoord "texCoord" OpName %tc "tc" OpName %fragColor "fragColor" OpName %texture0 "texture0" OpName %sampler0 "sampler0" OpDecorate %texCoord Location 0 OpDecorate %fragColor Location 0 OpDecorate %texture0 DescriptorSet 0 OpDecorate %texture0 Binding 1 OpDecorate %sampler0 DescriptorSet 0 OpDecorate %sampler0 Binding 0 %void = OpTypeVoid %10 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_2 = OpConstant %float 2 %v2float = OpTypeVector %float 2 %_ptr_Input_v2float = OpTypePointer Input %v2float %texCoord = OpVariable %_ptr_Input_v2float Input %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %float_1 = OpConstant %float 1 %uint_1 = OpConstant %uint 1 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %fragColor = OpVariable %_ptr_Output_v4float Output %23 = OpTypeImage %float Cube 0 0 0 1 Unknown %_ptr_UniformConstant_23 = OpTypePointer UniformConstant %23 %texture0 = OpVariable %_ptr_UniformConstant_23 UniformConstant %25 = OpTypeSampler %_ptr_UniformConstant_25 = OpTypePointer UniformConstant %25 %sampler0 = OpVariable %_ptr_UniformConstant_25 UniformConstant %27 = OpTypeSampledImage %23 %v3float = OpTypeVector %float 3 %int = OpTypeInt 32 1 %main = OpFunction %void None %10 %29 = OpLabel %sc = OpVariable %_ptr_Function_float Function %tc = OpVariable %_ptr_Function_float Function %30 = OpAccessChain %_ptr_Input_float %texCoord %uint_0 %31 = OpLoad %float %30 %32 = OpFMul %float %float_2 %31 %33 = OpFSub %float %32 %float_1 OpStore %sc %33 %34 = OpAccessChain %_ptr_Input_float %texCoord %uint_1 %35 = OpLoad %float %34 %36 = OpFMul %float %float_2 %35 %37 = OpFSub %float %36 %float_1 OpStore %tc %37 %38 = OpLoad %23 %texture0 %39 = OpLoad %25 %sampler0 %40 = OpSampledImage %27 %38 %39 %41 = OpLoad %float %tc %42 = OpLoad %float %sc %43 = OpFNegate %float %42 %44 = OpCompositeConstruct %v3float %float_1 %41 %43 %45 = OpImageSampleImplicitLod %v4float %40 %44 OpStore %fragColor %45 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(shader, expected, false, true); } TEST_F(GraphicsRobustAccessTest, ReplaceIndexReportsChanged) { // A ClusterFuzz generated shader that triggered a // "Binary size unexpectedly changed despite the optimizer saying there was no // change" assertion. // See https://github.com/KhronosGroup/SPIRV-Tools/issues/4166. std::string shader = R"( ; SPIR-V ; Version: 1.0 ; Generator: Google Shaderc over Glslang; 245 ; Bound: 41 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "else" %gl_GlobalInvocationID OpExecutionMode %main LocalSize 1 1 3338665985 OpSource GLSL 450 OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpName %main "main" OpName %index "index" OpName %gl_GlobalInvocationID "gl_GlobalInvocationID" OpName %S "S" OpMemberName %_struct_24 0 "" OpMemberName %_struct_24 1 "" OpName %Dst "Dst" OpMemberName %Dst 0 "s" OpName %dst "dst" OpName %Src "Src" OpMemberName %Src 0 "s" OpName %src "src" OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId OpMemberDecorate %_struct_24 0 Offset 64 OpMemberDecorate %_struct_24 1 Offset 8 OpDecorate %_arr__struct_24_uint_1 ArrayStride 16 OpMemberDecorate %Dst 0 Offset 0 OpDecorate %Dst BufferBlock OpDecorate %dst DescriptorSet 0 OpDecorate %dst Binding 1 OpDecorate %_arr__struct_24_uint_1_0 ArrayStride 16 OpMemberDecorate %Src 0 Offset 0 OpDecorate %Src Block OpDecorate %src DescriptorSet 0 OpDecorate %src Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_ptr_Function_uint = OpTypePointer Function %uint %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %uint_4864 = OpConstant %uint 4864 %_ptr_Input_uint = OpTypePointer Input %uint %uint_1 = OpConstant %uint 1 %bool = OpTypeBool %v2uint = OpTypeVector %uint 2 %_struct_24 = OpTypeStruct %_ptr_Input_uint %v2uint %_arr__struct_24_uint_1 = OpTypeArray %_struct_24 %uint_1 %Dst = OpTypeStruct %_arr__struct_24_uint_1 %_ptr_Uniform_Dst = OpTypePointer Uniform %Dst %dst = OpVariable %_ptr_Uniform_Dst Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_arr__struct_24_uint_1_0 = OpTypeArray %_struct_24 %uint_1 %Src = OpTypeStruct %_arr__struct_24_uint_1_0 %_ptr_Uniform_Src = OpTypePointer Uniform %Src %src = OpVariable %_ptr_Uniform_Src Uniform %_ptr_Uniform__struct_24 = OpTypePointer Uniform %_struct_24 %main = OpFunction %void None %3 %5 = OpLabel %index = OpVariable %_ptr_Function_uint Function %14 = OpAccessChain %_ptr_Input_uint %gl_GlobalInvocationID %uint_4864 %15 = OpLoad %uint %14 OpStore %index %15 %16 = OpLoad %uint %index %S = OpUGreaterThanEqual %bool %16 %uint_1 OpSelectionMerge %21 None OpBranchConditional %S %20 %21 %20 = OpLabel OpReturn %21 = OpLabel %31 = OpLoad %uint %index %36 = OpLoad %uint %index %38 = OpAccessChain %_ptr_Uniform__struct_24 %src %int_0 %36 %39 = OpLoad %_struct_24 %38 %40 = OpAccessChain %_ptr_Uniform__struct_24 %dst %int_0 %31 OpStore %40 %39 OpReturn OpFunctionEnd )"; std::vector optimized_bin; auto status = spvtools::opt::Pass::Status::Failure; std::tie(optimized_bin, status) = SinglePassRunToBinary(shader, false); // Check whether the pass returns the correct modification indication. EXPECT_EQ(status, spvtools::opt::Pass::Status::SuccessWithChange); } // TODO(dneto): Test access chain index wider than 64 bits? // TODO(dneto): Test struct access chain index wider than 64 bits? // TODO(dneto): OpImageTexelPointer // - all Dim types: 1D 2D Cube 3D Rect Buffer // - all Dim types that can be arrayed: 1D 2D 3D // - sample index: set to 0 if not multisampled // - Dim (2D, Cube Rect} with multisampling // -1 0 max excess // TODO(dneto): Test OpImageTexelPointer with coordinate component index other // than 32 bits. } // namespace KhronosGroup-SPIRV-Tools-f289d04/test/opt/if_conversion_test.cpp000066400000000000000000000413601475742701700247240ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using IfConversionTest = PassTest<::testing::Test>; TEST_F(IfConversionTest, TestSimpleIfThenElse) { const std::string text = R"( ; CHECK: OpSelectionMerge [[merge:%\w+]] ; CHECK: [[merge]] = OpLabel ; CHECK-NOT: OpPhi ; CHECK: [[sel:%\w+]] = OpSelect %uint %true %uint_0 %uint_1 ; CHECK OpStore {{%\w+}} [[sel]] OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "func" %2 %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %_ptr_Output_uint = OpTypePointer Output %uint %2 = OpVariable %_ptr_Output_uint Output %11 = OpTypeFunction %void %1 = OpFunction %void None %11 %12 = OpLabel OpSelectionMerge %14 None OpBranchConditional %true %15 %16 %15 = OpLabel OpBranch %14 %16 = OpLabel OpBranch %14 %14 = OpLabel %18 = OpPhi %uint %uint_0 %15 %uint_1 %16 OpStore %2 %18 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(IfConversionTest, TestSimpleHalfIfTrue) { const std::string text = R"( ; CHECK: OpSelectionMerge [[merge:%\w+]] ; CHECK: [[merge]] = OpLabel ; CHECK-NOT: OpPhi ; CHECK: [[sel:%\w+]] = OpSelect %uint %true %uint_0 %uint_1 ; CHECK OpStore {{%\w+}} [[sel]] OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "func" %2 %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %_ptr_Output_uint = OpTypePointer Output %uint %2 = OpVariable %_ptr_Output_uint Output %11 = OpTypeFunction %void %1 = OpFunction %void None %11 %12 = OpLabel OpSelectionMerge %14 None OpBranchConditional %true %15 %14 %15 = OpLabel OpBranch %14 %14 = OpLabel %18 = OpPhi %uint %uint_0 %15 %uint_1 %12 OpStore %2 %18 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(IfConversionTest, TestSimpleHalfIfExtraBlock) { const std::string text = R"( ; CHECK: OpSelectionMerge [[merge:%\w+]] ; CHECK: [[merge]] = OpLabel ; CHECK-NOT: OpPhi ; CHECK: [[sel:%\w+]] = OpSelect %uint %true %uint_0 %uint_1 ; CHECK OpStore {{%\w+}} [[sel]] OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "func" %2 %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %_ptr_Output_uint = OpTypePointer Output %uint %2 = OpVariable %_ptr_Output_uint Output %11 = OpTypeFunction %void %1 = OpFunction %void None %11 %12 = OpLabel OpSelectionMerge %14 None OpBranchConditional %true %15 %14 %15 = OpLabel OpBranch %16 %16 = OpLabel OpBranch %14 %14 = OpLabel %18 = OpPhi %uint %uint_0 %15 %uint_1 %12 OpStore %2 %18 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(IfConversionTest, TestSimpleHalfIfFalse) { const std::string text = R"( ; CHECK: OpSelectionMerge [[merge:%\w+]] ; CHECK: [[merge]] = OpLabel ; CHECK-NOT: OpPhi ; CHECK: [[sel:%\w+]] = OpSelect %uint %true %uint_0 %uint_1 ; CHECK OpStore {{%\w+}} [[sel]] OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "func" %2 %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %_ptr_Output_uint = OpTypePointer Output %uint %2 = OpVariable %_ptr_Output_uint Output %11 = OpTypeFunction %void %1 = OpFunction %void None %11 %12 = OpLabel OpSelectionMerge %14 None OpBranchConditional %true %14 %15 %15 = OpLabel OpBranch %14 %14 = OpLabel %18 = OpPhi %uint %uint_0 %12 %uint_1 %15 OpStore %2 %18 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(IfConversionTest, TestVectorSplat) { const std::string text = R"( ; CHECK: [[bool_vec:%\w+]] = OpTypeVector %bool 2 ; CHECK: OpSelectionMerge [[merge:%\w+]] ; CHECK: [[merge]] = OpLabel ; CHECK-NOT: OpPhi ; CHECK: [[comp:%\w+]] = OpCompositeConstruct [[bool_vec]] %true %true ; CHECK: [[sel:%\w+]] = OpSelect {{%\w+}} [[comp]] ; CHECK OpStore {{%\w+}} [[sel]] OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "func" %2 %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_vec2 = OpTypeVector %uint 2 %vec2_01 = OpConstantComposite %uint_vec2 %uint_0 %uint_1 %vec2_10 = OpConstantComposite %uint_vec2 %uint_1 %uint_0 %_ptr_Output_uint = OpTypePointer Output %uint_vec2 %2 = OpVariable %_ptr_Output_uint Output %11 = OpTypeFunction %void %1 = OpFunction %void None %11 %12 = OpLabel OpSelectionMerge %14 None OpBranchConditional %true %15 %16 %15 = OpLabel OpBranch %14 %16 = OpLabel OpBranch %14 %14 = OpLabel %18 = OpPhi %uint_vec2 %vec2_01 %15 %vec2_10 %16 OpStore %2 %18 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(IfConversionTest, CodeMotionSameValue) { const std::string text = R"( ; CHECK: [[var:%\w+]] = OpVariable ; CHECK: OpFunction ; CHECK: OpLabel ; CHECK-NOT: OpLabel ; CHECK: [[add:%\w+]] = OpIAdd %uint %uint_0 %uint_1 ; CHECK: OpSelectionMerge [[merge_lab:%\w+]] None ; CHECK-NEXT: OpBranchConditional ; CHECK: [[merge_lab]] = OpLabel ; CHECK-NOT: OpLabel ; CHECK: OpStore [[var]] [[add]] OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "func" %2 %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %_ptr_Output_uint = OpTypePointer Output %uint %2 = OpVariable %_ptr_Output_uint Output %8 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %1 = OpFunction %void None %8 %11 = OpLabel OpSelectionMerge %12 None OpBranchConditional %true %13 %15 %13 = OpLabel %14 = OpIAdd %uint %uint_0 %uint_1 OpBranch %12 %15 = OpLabel %16 = OpIAdd %uint %uint_0 %uint_1 OpBranch %12 %12 = OpLabel %17 = OpPhi %uint %16 %15 %14 %13 OpStore %2 %17 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(IfConversionTest, CodeMotionMultipleInstructions) { const std::string text = R"( ; CHECK: [[var:%\w+]] = OpVariable ; CHECK: OpFunction ; CHECK: OpLabel ; CHECK-NOT: OpLabel ; CHECK: [[a1:%\w+]] = OpIAdd %uint %uint_0 %uint_1 ; CHECK: [[a2:%\w+]] = OpIAdd %uint [[a1]] %uint_1 ; CHECK: OpSelectionMerge [[merge_lab:%\w+]] None ; CHECK-NEXT: OpBranchConditional ; CHECK: [[merge_lab]] = OpLabel ; CHECK-NOT: OpLabel ; CHECK: OpStore [[var]] [[a2]] OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "func" %2 %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %_ptr_Output_uint = OpTypePointer Output %uint %2 = OpVariable %_ptr_Output_uint Output %8 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %1 = OpFunction %void None %8 %11 = OpLabel OpSelectionMerge %12 None OpBranchConditional %true %13 %15 %13 = OpLabel %a1 = OpIAdd %uint %uint_0 %uint_1 %a2 = OpIAdd %uint %a1 %uint_1 OpBranch %12 %15 = OpLabel %b1 = OpIAdd %uint %uint_0 %uint_1 %b2 = OpIAdd %uint %b1 %uint_1 OpBranch %12 %12 = OpLabel %17 = OpPhi %uint %b2 %15 %a2 %13 OpStore %2 %17 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(IfConversionTest, NoCommonDominator) { const std::string text = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "func" %2 %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %_ptr_Output_uint = OpTypePointer Output %uint %2 = OpVariable %_ptr_Output_uint Output %8 = OpTypeFunction %void %1 = OpFunction %void None %8 %9 = OpLabel OpBranch %10 %11 = OpLabel OpBranch %10 %10 = OpLabel %12 = OpPhi %uint %uint_0 %9 %uint_1 %11 OpStore %2 %12 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(text, text, true, true); } TEST_F(IfConversionTest, DontFlatten) { const std::string text = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "func" %2 %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %v2uint = OpTypeVector %uint 2 %10 = OpConstantComposite %v2uint %uint_0 %uint_1 %11 = OpConstantComposite %v2uint %uint_1 %uint_0 %_ptr_Output_v2uint = OpTypePointer Output %v2uint %2 = OpVariable %_ptr_Output_v2uint Output %13 = OpTypeFunction %void %1 = OpFunction %void None %13 %14 = OpLabel OpSelectionMerge %15 DontFlatten OpBranchConditional %true %16 %17 %16 = OpLabel OpBranch %15 %17 = OpLabel OpBranch %15 %15 = OpLabel %18 = OpPhi %v2uint %10 %16 %11 %17 OpStore %2 %18 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(text, text, true, true); } TEST_F(IfConversionTest, LoopUntouched) { const std::string text = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "func" %2 %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %_ptr_Output_uint = OpTypePointer Output %uint %2 = OpVariable %_ptr_Output_uint Output %8 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %1 = OpFunction %void None %8 %11 = OpLabel OpBranch %12 %12 = OpLabel %13 = OpPhi %uint %uint_0 %11 %uint_1 %12 OpLoopMerge %14 %12 None OpBranchConditional %true %14 %12 %14 = OpLabel OpStore %2 %13 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(text, text, true, true); } TEST_F(IfConversionTest, TooManyPredecessors) { const std::string text = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "func" %2 %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %_ptr_Output_uint = OpTypePointer Output %uint %2 = OpVariable %_ptr_Output_uint Output %8 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %1 = OpFunction %void None %8 %11 = OpLabel OpSelectionMerge %12 None OpBranchConditional %true %13 %12 %13 = OpLabel OpBranchConditional %true %14 %12 %14 = OpLabel OpBranch %12 %12 = OpLabel %15 = OpPhi %uint %uint_0 %11 %uint_0 %13 %uint_1 %14 OpStore %2 %15 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(text, text, true, true); } TEST_F(IfConversionTest, NoCodeMotion) { const std::string text = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "func" %2 %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %_ptr_Output_uint = OpTypePointer Output %uint %2 = OpVariable %_ptr_Output_uint Output %8 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %1 = OpFunction %void None %8 %11 = OpLabel OpSelectionMerge %12 None OpBranchConditional %true %13 %12 %13 = OpLabel %14 = OpIAdd %uint %uint_0 %uint_1 OpBranch %12 %12 = OpLabel %15 = OpPhi %uint %uint_0 %11 %14 %13 OpStore %2 %15 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(text, text, true, true); } TEST_F(IfConversionTest, NoCodeMotionImmovableInst) { const std::string text = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "func" %2 %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %_ptr_Output_uint = OpTypePointer Output %uint %2 = OpVariable %_ptr_Output_uint Output %8 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %1 = OpFunction %void None %8 %11 = OpLabel OpSelectionMerge %12 None OpBranchConditional %true %13 %14 %13 = OpLabel OpSelectionMerge %15 None OpBranchConditional %true %16 %15 %16 = OpLabel %17 = OpIAdd %uint %uint_0 %uint_1 OpBranch %15 %15 = OpLabel %18 = OpPhi %uint %uint_0 %13 %17 %16 %19 = OpIAdd %uint %18 %uint_1 OpBranch %12 %14 = OpLabel OpSelectionMerge %20 None OpBranchConditional %true %21 %20 %21 = OpLabel %22 = OpIAdd %uint %uint_0 %uint_1 OpBranch %20 %20 = OpLabel %23 = OpPhi %uint %uint_0 %14 %22 %21 %24 = OpIAdd %uint %23 %uint_1 OpBranch %12 %12 = OpLabel %25 = OpPhi %uint %24 %20 %19 %15 OpStore %2 %25 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(text, text, true, true); } TEST_F(IfConversionTest, InvalidCommonDominator) { const std::string text = R"(OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %float_1 = OpConstant %float 1 %bool = OpTypeBool %true = OpConstantTrue %bool %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel OpBranch %4 %4 = OpLabel OpLoopMerge %5 %6 None OpBranch %7 %7 = OpLabel OpSelectionMerge %8 None OpBranchConditional %true %8 %9 %9 = OpLabel OpSelectionMerge %10 None OpBranchConditional %true %10 %5 %10 = OpLabel OpBranch %8 %8 = OpLabel OpBranch %6 %6 = OpLabel OpBranchConditional %true %4 %5 %5 = OpLabel %11 = OpPhi %float %float_0 %6 %float_1 %9 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(text, text, true, true); } TEST_F(IfConversionTest, DebugInfoSimpleIfThenElse) { // When it replaces an OpPhi with OpSelect, the new OpSelect must have // the same scope and line information with the OpPhi. const std::string text = R"( ; CHECK: OpSelectionMerge [[merge:%\w+]] ; CHECK: [[merge]] = OpLabel ; CHECK-NOT: OpPhi ; CHECK: DebugScope ; CHECK-NEXT: OpLine {{%\w+}} 3 7 ; CHECK-NEXT: [[sel:%\w+]] = OpSelect %uint %true %uint_0 %uint_1 ; CHECK-NEXT: DebugValue {{%\w+}} [[sel]] ; CHECK: OpStore {{%\w+}} [[sel]] OpCapability Shader %ext = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "func" %2 %name = OpString "test" %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_32 = OpConstant %uint 32 %_ptr_Output_uint = OpTypePointer Output %uint %2 = OpVariable %_ptr_Output_uint Output %11 = OpTypeFunction %void %null_expr = OpExtInst %void %ext DebugExpression %src = OpExtInst %void %ext DebugSource %name %cu = OpExtInst %void %ext DebugCompilationUnit 1 4 %src HLSL %dbg_tf = OpExtInst %void %ext DebugTypeBasic %name %uint_32 Float %dbg_f = OpExtInst %void %ext DebugLocalVariable %name %dbg_tf %src 0 0 %cu FlagIsLocal %1 = OpFunction %void None %11 %12 = OpLabel OpSelectionMerge %14 None OpBranchConditional %true %15 %16 %15 = OpLabel OpBranch %14 %16 = OpLabel OpBranch %14 %14 = OpLabel %scope = OpExtInst %void %ext DebugScope %cu OpLine %name 3 7 %18 = OpPhi %uint %uint_0 %15 %uint_1 %16 %value = OpExtInst %void %ext DebugValue %dbg_f %18 %null_expr OpStore %2 %18 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(IfConversionTest, MultipleEdgesFromSameBlock) { // If a block has two out going edges that go to the same block, then there // can be an OpPhi instruction with fewer entries than the number of incoming // edges. This must be handled. const std::string text = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft %void = OpTypeVoid %4 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %true_0 = OpConstantTrue %bool %2 = OpFunction %void None %4 %8 = OpLabel OpSelectionMerge %9 None OpBranchConditional %true_0 %9 %9 %9 = OpLabel %10 = OpPhi %bool %true %8 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(text, text, true, true); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/inline_opaque_test.cpp000066400000000000000000000370751475742701700247210ustar00rootroot00000000000000// Copyright (c) 2017 Valve Corporation // Copyright (c) 2017 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using InlineOpaqueTest = PassTest<::testing::Test>; TEST_F(InlineOpaqueTest, InlineCallWithStructArgContainingSampledImage) { // Function with opaque argument is inlined. // TODO(greg-lunarg): Add HLSL code const std::string predefs_1 = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %outColor %texCoords OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %S_t "S_t" OpMemberName %S_t 0 "v0" OpMemberName %S_t 1 "v1" OpMemberName %S_t 2 "smp" OpName %foo_struct_S_t_vf2_vf21_ "foo(struct-S_t-vf2-vf21;" OpName %s "s" OpName %outColor "outColor" OpName %sampler15 "sampler15" OpName %s0 "s0" OpName %texCoords "texCoords" OpName %param "param" )"; const std::string name = R"(OpName %return_value "return_value" )"; const std::string predefs_2 = R"(OpDecorate %sampler15 DescriptorSet 0 %void = OpTypeVoid %13 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %outColor = OpVariable %_ptr_Output_v4float Output %18 = OpTypeImage %float 2D 0 0 0 1 Unknown %19 = OpTypeSampledImage %18 %S_t = OpTypeStruct %v2float %v2float %19 %_ptr_Function_S_t = OpTypePointer Function %S_t %21 = OpTypeFunction %void %_ptr_Function_S_t %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %_ptr_Function_19 = OpTypePointer Function %19 %sampler15 = OpVariable %_ptr_UniformConstant_19 UniformConstant %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_2 = OpConstant %int 2 %_ptr_Function_v2float = OpTypePointer Function %v2float %_ptr_Input_v2float = OpTypePointer Input %v2float %texCoords = OpVariable %_ptr_Input_v2float Input )"; const std::string before = R"(%main = OpFunction %void None %13 %29 = OpLabel %s0 = OpVariable %_ptr_Function_S_t Function %param = OpVariable %_ptr_Function_S_t Function %30 = OpLoad %v2float %texCoords %31 = OpAccessChain %_ptr_Function_v2float %s0 %int_0 OpStore %31 %30 %32 = OpLoad %19 %sampler15 %33 = OpAccessChain %_ptr_Function_19 %s0 %int_2 OpStore %33 %32 %34 = OpLoad %S_t %s0 OpStore %param %34 %return_value = OpFunctionCall %void %foo_struct_S_t_vf2_vf21_ %param OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %13 %29 = OpLabel %s0 = OpVariable %_ptr_Function_S_t Function %param = OpVariable %_ptr_Function_S_t Function %30 = OpLoad %v2float %texCoords %31 = OpAccessChain %_ptr_Function_v2float %s0 %int_0 OpStore %31 %30 %32 = OpLoad %19 %sampler15 %33 = OpAccessChain %_ptr_Function_19 %s0 %int_2 OpStore %33 %32 %34 = OpLoad %S_t %s0 OpStore %param %34 %42 = OpAccessChain %_ptr_Function_19 %param %int_2 %43 = OpLoad %19 %42 %44 = OpAccessChain %_ptr_Function_v2float %param %int_0 %45 = OpLoad %v2float %44 %46 = OpImageSampleImplicitLod %v4float %43 %45 OpStore %outColor %46 OpReturn OpFunctionEnd )"; const std::string post_defs = R"(%foo_struct_S_t_vf2_vf21_ = OpFunction %void None %21 %s = OpFunctionParameter %_ptr_Function_S_t %35 = OpLabel %36 = OpAccessChain %_ptr_Function_19 %s %int_2 %37 = OpLoad %19 %36 %38 = OpAccessChain %_ptr_Function_v2float %s %int_0 %39 = OpLoad %v2float %38 %40 = OpImageSampleImplicitLod %v4float %37 %39 OpStore %outColor %40 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck( predefs_1 + name + predefs_2 + before + post_defs, predefs_1 + predefs_2 + after + post_defs, true, true); } TEST_F(InlineOpaqueTest, InlineOpaqueReturn) { // Function with opaque return value is inlined. // TODO(greg-lunarg): Add HLSL code const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %texCoords %outColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %foo_ "foo(" OpName %texCoords "texCoords" OpName %outColor "outColor" OpName %sampler15 "sampler15" OpName %sampler16 "sampler16" OpDecorate %sampler15 DescriptorSet 0 OpDecorate %sampler16 DescriptorSet 0 %void = OpTypeVoid %9 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %bool = OpTypeBool %false = OpConstantFalse %bool %_ptr_Input_v2float = OpTypePointer Input %v2float %texCoords = OpVariable %_ptr_Input_v2float Input %float_0 = OpConstant %float 0 %16 = OpConstantComposite %v2float %float_0 %float_0 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %outColor = OpVariable %_ptr_Output_v4float Output %19 = OpTypeImage %float 2D 0 0 0 1 Unknown %20 = OpTypeSampledImage %19 %21 = OpTypeFunction %20 %_ptr_UniformConstant_20 = OpTypePointer UniformConstant %20 %_ptr_Function_20 = OpTypePointer Function %20 %sampler15 = OpVariable %_ptr_UniformConstant_20 UniformConstant %sampler16 = OpVariable %_ptr_UniformConstant_20 UniformConstant )"; const std::string before = R"(%main = OpFunction %void None %9 %24 = OpLabel %25 = OpVariable %_ptr_Function_20 Function %26 = OpFunctionCall %20 %foo_ OpStore %25 %26 %27 = OpLoad %20 %25 %28 = OpLoad %v2float %texCoords %29 = OpImageSampleImplicitLod %v4float %27 %28 OpStore %outColor %29 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %9 %24 = OpLabel %34 = OpVariable %_ptr_Function_20 Function %35 = OpVariable %_ptr_Function_20 Function %25 = OpVariable %_ptr_Function_20 Function %37 = OpLoad %20 %sampler16 OpStore %34 %37 %38 = OpLoad %20 %34 OpStore %35 %38 %26 = OpLoad %20 %35 OpStore %25 %26 %27 = OpLoad %20 %25 %28 = OpLoad %v2float %texCoords %29 = OpImageSampleImplicitLod %v4float %27 %28 OpStore %outColor %29 OpReturn OpFunctionEnd )"; const std::string post_defs = R"(%foo_ = OpFunction %20 None %21 %30 = OpLabel %31 = OpVariable %_ptr_Function_20 Function %32 = OpLoad %20 %sampler16 OpStore %31 %32 %33 = OpLoad %20 %31 OpReturnValue %33 OpFunctionEnd )"; SinglePassRunAndCheck( predefs + before + post_defs, predefs + after + post_defs, true, true); } TEST_F(InlineOpaqueTest, InlineOpaqueForLinkage) { const std::string predefs_1 = R"(OpCapability Shader OpCapability Linkage %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpSource HLSL 630 OpName %main "main" OpName %S_t "S_t" OpMemberName %S_t 0 "v0" OpMemberName %S_t 1 "v1" OpMemberName %S_t 2 "smp" OpName %foo_struct_S_t_vf2_vf21_ "foo(struct-S_t-vf2-vf21;" OpName %s "s" OpName %outColor "outColor" OpName %sampler15 "sampler15" OpName %s0 "s0" OpName %texCoords "texCoords" OpName %param "param" OpDecorate %main LinkageAttributes "main" Export )"; const std::string name = R"(OpName %return_value "return_value" )"; const std::string predefs_2 = R"(OpDecorate %sampler15 DescriptorSet 0 %void = OpTypeVoid %13 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %outColor = OpVariable %_ptr_Output_v4float Output %18 = OpTypeImage %float 2D 0 0 0 1 Unknown %19 = OpTypeSampledImage %18 %S_t = OpTypeStruct %v2float %v2float %19 %_ptr_Function_S_t = OpTypePointer Function %S_t %21 = OpTypeFunction %void %_ptr_Function_S_t %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %_ptr_Function_19 = OpTypePointer Function %19 %sampler15 = OpVariable %_ptr_UniformConstant_19 UniformConstant %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_2 = OpConstant %int 2 %_ptr_Function_v2float = OpTypePointer Function %v2float %_ptr_Input_v2float = OpTypePointer Input %v2float %texCoords = OpVariable %_ptr_Input_v2float Input )"; const std::string before = R"(%main = OpFunction %void None %13 %29 = OpLabel %s0 = OpVariable %_ptr_Function_S_t Function %param = OpVariable %_ptr_Function_S_t Function %30 = OpLoad %v2float %texCoords %31 = OpAccessChain %_ptr_Function_v2float %s0 %int_0 OpStore %31 %30 %32 = OpLoad %19 %sampler15 %33 = OpAccessChain %_ptr_Function_19 %s0 %int_2 OpStore %33 %32 %34 = OpLoad %S_t %s0 OpStore %param %34 %return_value = OpFunctionCall %void %foo_struct_S_t_vf2_vf21_ %param OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %13 %29 = OpLabel %s0 = OpVariable %_ptr_Function_S_t Function %param = OpVariable %_ptr_Function_S_t Function %30 = OpLoad %v2float %texCoords %31 = OpAccessChain %_ptr_Function_v2float %s0 %int_0 OpStore %31 %30 %32 = OpLoad %19 %sampler15 %33 = OpAccessChain %_ptr_Function_19 %s0 %int_2 OpStore %33 %32 %34 = OpLoad %S_t %s0 OpStore %param %34 %42 = OpAccessChain %_ptr_Function_19 %param %int_2 %43 = OpLoad %19 %42 %44 = OpAccessChain %_ptr_Function_v2float %param %int_0 %45 = OpLoad %v2float %44 %46 = OpImageSampleImplicitLod %v4float %43 %45 OpStore %outColor %46 OpReturn OpFunctionEnd )"; const std::string post_defs = R"(%foo_struct_S_t_vf2_vf21_ = OpFunction %void None %21 %s = OpFunctionParameter %_ptr_Function_S_t %35 = OpLabel %36 = OpAccessChain %_ptr_Function_19 %s %int_2 %37 = OpLoad %19 %36 %38 = OpAccessChain %_ptr_Function_v2float %s %int_0 %39 = OpLoad %v2float %38 %40 = OpImageSampleImplicitLod %v4float %37 %39 OpStore %outColor %40 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck( predefs_1 + name + predefs_2 + before + post_defs, predefs_1 + predefs_2 + after + post_defs, true, true); } TEST_F(InlineOpaqueTest, InlineInNonEntryPointFunction) { // This demonstrates opaque inlining in a function that is not // an entry point function (main2) but is in the call tree of an // entry point function (main). // TODO(greg-lunarg): Add HLSL code const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %outColor %texCoords OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %main2 "main2" OpName %S_t "S_t" OpMemberName %S_t 0 "v0" OpMemberName %S_t 1 "v1" OpMemberName %S_t 2 "smp" OpName %foo_struct_S_t_vf2_vf21_ "foo(struct-S_t-vf2-vf21;" OpName %s "s" OpName %outColor "outColor" OpName %sampler15 "sampler15" OpName %s0 "s0" OpName %texCoords "texCoords" OpName %param "param" OpDecorate %sampler15 DescriptorSet 0 %void = OpTypeVoid %13 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %outColor = OpVariable %_ptr_Output_v4float Output %18 = OpTypeImage %float 2D 0 0 0 1 Unknown %19 = OpTypeSampledImage %18 %S_t = OpTypeStruct %v2float %v2float %19 %_ptr_Function_S_t = OpTypePointer Function %S_t %21 = OpTypeFunction %void %_ptr_Function_S_t %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %_ptr_Function_19 = OpTypePointer Function %19 %sampler15 = OpVariable %_ptr_UniformConstant_19 UniformConstant %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_2 = OpConstant %int 2 %_ptr_Function_v2float = OpTypePointer Function %v2float %_ptr_Input_v2float = OpTypePointer Input %v2float %texCoords = OpVariable %_ptr_Input_v2float Input )"; const std::string before = R"(%main2 = OpFunction %void None %13 %29 = OpLabel %s0 = OpVariable %_ptr_Function_S_t Function %param = OpVariable %_ptr_Function_S_t Function %30 = OpLoad %v2float %texCoords %31 = OpAccessChain %_ptr_Function_v2float %s0 %int_0 OpStore %31 %30 %32 = OpLoad %19 %sampler15 %33 = OpAccessChain %_ptr_Function_19 %s0 %int_2 OpStore %33 %32 %34 = OpLoad %S_t %s0 OpStore %param %34 %35 = OpFunctionCall %void %foo_struct_S_t_vf2_vf21_ %param OpReturn OpFunctionEnd )"; const std::string after = R"(%main2 = OpFunction %void None %13 %29 = OpLabel %s0 = OpVariable %_ptr_Function_S_t Function %param = OpVariable %_ptr_Function_S_t Function %30 = OpLoad %v2float %texCoords %31 = OpAccessChain %_ptr_Function_v2float %s0 %int_0 OpStore %31 %30 %32 = OpLoad %19 %sampler15 %33 = OpAccessChain %_ptr_Function_19 %s0 %int_2 OpStore %33 %32 %34 = OpLoad %S_t %s0 OpStore %param %34 %45 = OpAccessChain %_ptr_Function_19 %param %int_2 %46 = OpLoad %19 %45 %47 = OpAccessChain %_ptr_Function_v2float %param %int_0 %48 = OpLoad %v2float %47 %49 = OpImageSampleImplicitLod %v4float %46 %48 OpStore %outColor %49 OpReturn OpFunctionEnd )"; const std::string post_defs = R"(%main = OpFunction %void None %13 %36 = OpLabel %37 = OpFunctionCall %void %main2 OpReturn OpFunctionEnd %foo_struct_S_t_vf2_vf21_ = OpFunction %void None %21 %s = OpFunctionParameter %_ptr_Function_S_t %38 = OpLabel %39 = OpAccessChain %_ptr_Function_19 %s %int_2 %40 = OpLoad %19 %39 %41 = OpAccessChain %_ptr_Function_v2float %s %int_0 %42 = OpLoad %v2float %41 %43 = OpImageSampleImplicitLod %v4float %40 %42 OpStore %outColor %43 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck( predefs + before + post_defs, predefs + after + post_defs, true, true); } TEST_F(InlineOpaqueTest, NoInlineNoOpaque) { // Function without opaque interface is not inlined. // #version 140 // // in vec4 BaseColor; // // float foo(vec4 bar) // { // return bar.x + bar.y; // } // // void main() // { // vec4 color = vec4(foo(BaseColor)); // gl_FragColor = color; // } const std::string assembly = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %foo_vf4_ "foo(vf4;" OpName %bar "bar" OpName %color "color" OpName %BaseColor "BaseColor" OpName %param "param" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %10 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %14 = OpTypeFunction %float %_ptr_Function_v4float %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Function_float = OpTypePointer Function %float %uint_1 = OpConstant %uint 1 %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %10 %21 = OpLabel %color = OpVariable %_ptr_Function_v4float Function %param = OpVariable %_ptr_Function_v4float Function %22 = OpLoad %v4float %BaseColor OpStore %param %22 %23 = OpFunctionCall %float %foo_vf4_ %param %24 = OpCompositeConstruct %v4float %23 %23 %23 %23 OpStore %color %24 %25 = OpLoad %v4float %color OpStore %gl_FragColor %25 OpReturn OpFunctionEnd %foo_vf4_ = OpFunction %float None %14 %bar = OpFunctionParameter %_ptr_Function_v4float %26 = OpLabel %27 = OpAccessChain %_ptr_Function_float %bar %uint_0 %28 = OpLoad %float %27 %29 = OpAccessChain %_ptr_Function_float %bar %uint_1 %30 = OpLoad %float %29 %31 = OpFAdd %float %28 %30 OpReturnValue %31 OpFunctionEnd )"; SinglePassRunAndCheck(assembly, assembly, true, true); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/inline_test.cpp000066400000000000000000005006501475742701700233410ustar00rootroot00000000000000// Copyright (c) 2017-2022 Valve Corporation // Copyright (c) 2017-2022 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using InlineTest = PassTest<::testing::Test>; TEST_F(InlineTest, Simple) { // #version 140 // // in vec4 BaseColor; // // float foo(vec4 bar) // { // return bar.x + bar.y; // } // // void main() // { // vec4 color = vec4(foo(BaseColor)); // gl_FragColor = color; // } const std::vector predefs = { // clang-format off "OpCapability Shader", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Fragment %main \"main\" %BaseColor %gl_FragColor", "OpExecutionMode %main OriginUpperLeft", "OpSource GLSL 140", "OpName %main \"main\"", "OpName %foo_vf4_ \"foo(vf4;\"", "OpName %bar \"bar\"", "OpName %color \"color\"", "OpName %BaseColor \"BaseColor\"", "OpName %param \"param\"", "OpName %gl_FragColor \"gl_FragColor\"", "%void = OpTypeVoid", "%10 = OpTypeFunction %void", "%float = OpTypeFloat 32", "%v4float = OpTypeVector %float 4", "%_ptr_Function_v4float = OpTypePointer Function %v4float", "%14 = OpTypeFunction %float %_ptr_Function_v4float", "%uint = OpTypeInt 32 0", "%uint_0 = OpConstant %uint 0", "%_ptr_Function_float = OpTypePointer Function %float", "%uint_1 = OpConstant %uint 1", "%_ptr_Input_v4float = OpTypePointer Input %v4float", "%BaseColor = OpVariable %_ptr_Input_v4float Input", "%_ptr_Output_v4float = OpTypePointer Output %v4float", "%gl_FragColor = OpVariable %_ptr_Output_v4float Output", // clang-format on }; const std::vector nonEntryFuncs = { // clang-format off "%foo_vf4_ = OpFunction %float None %14", "%bar = OpFunctionParameter %_ptr_Function_v4float", "%26 = OpLabel", "%27 = OpAccessChain %_ptr_Function_float %bar %uint_0", "%28 = OpLoad %float %27", "%29 = OpAccessChain %_ptr_Function_float %bar %uint_1", "%30 = OpLoad %float %29", "%31 = OpFAdd %float %28 %30", "OpReturnValue %31", "OpFunctionEnd", // clang-format on }; const std::vector before = { // clang-format off "%main = OpFunction %void None %10", "%21 = OpLabel", "%color = OpVariable %_ptr_Function_v4float Function", "%param = OpVariable %_ptr_Function_v4float Function", "%22 = OpLoad %v4float %BaseColor", "OpStore %param %22", "%23 = OpFunctionCall %float %foo_vf4_ %param", "%24 = OpCompositeConstruct %v4float %23 %23 %23 %23", "OpStore %color %24", "%25 = OpLoad %v4float %color", "OpStore %gl_FragColor %25", "OpReturn", "OpFunctionEnd", // clang-format on }; const std::vector after = { // clang-format off "%main = OpFunction %void None %10", "%21 = OpLabel", "%32 = OpVariable %_ptr_Function_float Function", "%color = OpVariable %_ptr_Function_v4float Function", "%param = OpVariable %_ptr_Function_v4float Function", "%22 = OpLoad %v4float %BaseColor", "OpStore %param %22", "%34 = OpAccessChain %_ptr_Function_float %param %uint_0", "%35 = OpLoad %float %34", "%36 = OpAccessChain %_ptr_Function_float %param %uint_1", "%37 = OpLoad %float %36", "%38 = OpFAdd %float %35 %37", "OpStore %32 %38", "%23 = OpLoad %float %32", "%24 = OpCompositeConstruct %v4float %23 %23 %23 %23", "OpStore %color %24", "%25 = OpLoad %v4float %color", "OpStore %gl_FragColor %25", "OpReturn", "OpFunctionEnd", // clang-format on }; SinglePassRunAndCheck( JoinAllInsts(Concat(Concat(predefs, before), nonEntryFuncs)), JoinAllInsts(Concat(Concat(predefs, after), nonEntryFuncs)), /* skip_nop = */ false, /* do_validate = */ true); } TEST_F(InlineTest, Nested) { // #version 140 // // in vec4 BaseColor; // // float foo2(float f, float f2) // { // return f * f2; // } // // float foo(vec4 bar) // { // return foo2(bar.x + bar.y, bar.z); // } // // void main() // { // vec4 color = vec4(foo(BaseColor)); // gl_FragColor = color; // } const std::vector predefs = { // clang-format off "OpCapability Shader", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Fragment %main \"main\" %BaseColor %gl_FragColor", "OpExecutionMode %main OriginUpperLeft", "OpSource GLSL 140", "OpName %main \"main\"", "OpName %foo2_f1_f1_ \"foo2(f1;f1;\"", "OpName %f \"f\"", "OpName %f2 \"f2\"", "OpName %foo_vf4_ \"foo(vf4;\"", "OpName %bar \"bar\"", "OpName %param \"param\"", "OpName %param_0 \"param\"", "OpName %color \"color\"", "OpName %BaseColor \"BaseColor\"", "OpName %param_1 \"param\"", "OpName %gl_FragColor \"gl_FragColor\"", "%void = OpTypeVoid", "%15 = OpTypeFunction %void", "%float = OpTypeFloat 32", "%_ptr_Function_float = OpTypePointer Function %float", "%18 = OpTypeFunction %float %_ptr_Function_float %_ptr_Function_float", "%v4float = OpTypeVector %float 4", "%_ptr_Function_v4float = OpTypePointer Function %v4float", "%21 = OpTypeFunction %float %_ptr_Function_v4float", "%uint = OpTypeInt 32 0", "%uint_0 = OpConstant %uint 0", "%uint_1 = OpConstant %uint 1", "%uint_2 = OpConstant %uint 2", "%_ptr_Input_v4float = OpTypePointer Input %v4float", "%BaseColor = OpVariable %_ptr_Input_v4float Input", "%_ptr_Output_v4float = OpTypePointer Output %v4float", "%gl_FragColor = OpVariable %_ptr_Output_v4float Output", // clang-format on }; const std::vector nonEntryFuncs = { // clang-format off "%foo2_f1_f1_ = OpFunction %float None %18", "%f = OpFunctionParameter %_ptr_Function_float", "%f2 = OpFunctionParameter %_ptr_Function_float", "%33 = OpLabel", "%34 = OpLoad %float %f", "%35 = OpLoad %float %f2", "%36 = OpFMul %float %34 %35", "OpReturnValue %36", "OpFunctionEnd", "%foo_vf4_ = OpFunction %float None %21", "%bar = OpFunctionParameter %_ptr_Function_v4float", "%37 = OpLabel", "%param = OpVariable %_ptr_Function_float Function", "%param_0 = OpVariable %_ptr_Function_float Function", "%38 = OpAccessChain %_ptr_Function_float %bar %uint_0", "%39 = OpLoad %float %38", "%40 = OpAccessChain %_ptr_Function_float %bar %uint_1", "%41 = OpLoad %float %40", "%42 = OpFAdd %float %39 %41", "OpStore %param %42", "%43 = OpAccessChain %_ptr_Function_float %bar %uint_2", "%44 = OpLoad %float %43", "OpStore %param_0 %44", "%45 = OpFunctionCall %float %foo2_f1_f1_ %param %param_0", "OpReturnValue %45", "OpFunctionEnd", // clang-format on }; const std::vector before = { // clang-format off "%main = OpFunction %void None %15", "%28 = OpLabel", "%color = OpVariable %_ptr_Function_v4float Function", "%param_1 = OpVariable %_ptr_Function_v4float Function", "%29 = OpLoad %v4float %BaseColor", "OpStore %param_1 %29", "%30 = OpFunctionCall %float %foo_vf4_ %param_1", "%31 = OpCompositeConstruct %v4float %30 %30 %30 %30", "OpStore %color %31", "%32 = OpLoad %v4float %color", "OpStore %gl_FragColor %32", "OpReturn", "OpFunctionEnd", // clang-format on }; const std::vector after = { // clang-format off "%main = OpFunction %void None %15", "%28 = OpLabel", "%58 = OpVariable %_ptr_Function_float Function", "%46 = OpVariable %_ptr_Function_float Function", "%47 = OpVariable %_ptr_Function_float Function", "%48 = OpVariable %_ptr_Function_float Function", "%color = OpVariable %_ptr_Function_v4float Function", "%param_1 = OpVariable %_ptr_Function_v4float Function", "%29 = OpLoad %v4float %BaseColor", "OpStore %param_1 %29", "%50 = OpAccessChain %_ptr_Function_float %param_1 %uint_0", "%51 = OpLoad %float %50", "%52 = OpAccessChain %_ptr_Function_float %param_1 %uint_1", "%53 = OpLoad %float %52", "%54 = OpFAdd %float %51 %53", "OpStore %46 %54", "%55 = OpAccessChain %_ptr_Function_float %param_1 %uint_2", "%56 = OpLoad %float %55", "OpStore %47 %56", "%60 = OpLoad %float %46", "%61 = OpLoad %float %47", "%62 = OpFMul %float %60 %61", "OpStore %58 %62", "%57 = OpLoad %float %58", "OpStore %48 %57", "%30 = OpLoad %float %48", "%31 = OpCompositeConstruct %v4float %30 %30 %30 %30", "OpStore %color %31", "%32 = OpLoad %v4float %color", "OpStore %gl_FragColor %32", "OpReturn", "OpFunctionEnd", // clang-format on }; SinglePassRunAndCheck( JoinAllInsts(Concat(Concat(predefs, before), nonEntryFuncs)), JoinAllInsts(Concat(Concat(predefs, after), nonEntryFuncs)), /* skip_nop = */ false, /* do_validate = */ true); } TEST_F(InlineTest, InOutParameter) { // #version 400 // // in vec4 Basecolor; // // void foo(inout vec4 bar) // { // bar.z = bar.x + bar.y; // } // // void main() // { // vec4 b = Basecolor; // foo(b); // vec4 color = vec4(b.z); // gl_FragColor = color; // } const std::vector predefs = { // clang-format off "OpCapability Shader", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Fragment %main \"main\" %Basecolor %gl_FragColor", "OpExecutionMode %main OriginUpperLeft", "OpSource GLSL 400", "OpName %main \"main\"", "OpName %foo_vf4_ \"foo(vf4;\"", "OpName %bar \"bar\"", "OpName %b \"b\"", "OpName %Basecolor \"Basecolor\"", "OpName %param \"param\"", "OpName %color \"color\"", "OpName %gl_FragColor \"gl_FragColor\"", "%void = OpTypeVoid", "%11 = OpTypeFunction %void", "%float = OpTypeFloat 32", "%v4float = OpTypeVector %float 4", "%_ptr_Function_v4float = OpTypePointer Function %v4float", "%15 = OpTypeFunction %void %_ptr_Function_v4float", "%uint = OpTypeInt 32 0", "%uint_0 = OpConstant %uint 0", "%_ptr_Function_float = OpTypePointer Function %float", "%uint_1 = OpConstant %uint 1", "%uint_2 = OpConstant %uint 2", "%_ptr_Input_v4float = OpTypePointer Input %v4float", "%Basecolor = OpVariable %_ptr_Input_v4float Input", "%_ptr_Output_v4float = OpTypePointer Output %v4float", "%gl_FragColor = OpVariable %_ptr_Output_v4float Output", // clang-format on }; const std::vector nonEntryFuncs = { // clang-format off "%foo_vf4_ = OpFunction %void None %15", "%bar = OpFunctionParameter %_ptr_Function_v4float", "%32 = OpLabel", "%33 = OpAccessChain %_ptr_Function_float %bar %uint_0", "%34 = OpLoad %float %33", "%35 = OpAccessChain %_ptr_Function_float %bar %uint_1", "%36 = OpLoad %float %35", "%37 = OpFAdd %float %34 %36", "%38 = OpAccessChain %_ptr_Function_float %bar %uint_2", "OpStore %38 %37", "OpReturn", "OpFunctionEnd", // clang-format on }; const std::vector before = { // clang-format off "%main = OpFunction %void None %11", "%23 = OpLabel", "%b = OpVariable %_ptr_Function_v4float Function", "%param = OpVariable %_ptr_Function_v4float Function", "%color = OpVariable %_ptr_Function_v4float Function", "%24 = OpLoad %v4float %Basecolor", "OpStore %b %24", "%25 = OpLoad %v4float %b", "OpStore %param %25", "%26 = OpFunctionCall %void %foo_vf4_ %param", "%27 = OpLoad %v4float %param", "OpStore %b %27", "%28 = OpAccessChain %_ptr_Function_float %b %uint_2", "%29 = OpLoad %float %28", "%30 = OpCompositeConstruct %v4float %29 %29 %29 %29", "OpStore %color %30", "%31 = OpLoad %v4float %color", "OpStore %gl_FragColor %31", "OpReturn", "OpFunctionEnd", // clang-format on }; const std::vector after = { // clang-format off "%main = OpFunction %void None %11", "%23 = OpLabel", "%b = OpVariable %_ptr_Function_v4float Function", "%param = OpVariable %_ptr_Function_v4float Function", "%color = OpVariable %_ptr_Function_v4float Function", "%24 = OpLoad %v4float %Basecolor", "OpStore %b %24", "%25 = OpLoad %v4float %b", "OpStore %param %25", "%40 = OpAccessChain %_ptr_Function_float %param %uint_0", "%41 = OpLoad %float %40", "%42 = OpAccessChain %_ptr_Function_float %param %uint_1", "%43 = OpLoad %float %42", "%44 = OpFAdd %float %41 %43", "%45 = OpAccessChain %_ptr_Function_float %param %uint_2", "OpStore %45 %44", "%27 = OpLoad %v4float %param", "OpStore %b %27", "%28 = OpAccessChain %_ptr_Function_float %b %uint_2", "%29 = OpLoad %float %28", "%30 = OpCompositeConstruct %v4float %29 %29 %29 %29", "OpStore %color %30", "%31 = OpLoad %v4float %color", "OpStore %gl_FragColor %31", "OpReturn", "OpFunctionEnd", // clang-format on }; SinglePassRunAndCheck( JoinAllInsts(Concat(Concat(predefs, before), nonEntryFuncs)), JoinAllInsts(Concat(Concat(predefs, after), nonEntryFuncs)), /* skip_nop = */ false, /* do_validate = */ true); } TEST_F(InlineTest, BranchInCallee) { // #version 140 // // in vec4 BaseColor; // // float foo(vec4 bar) // { // float r = bar.x; // if (r < 0.0) // r = -r; // return r; // } // // void main() // { // vec4 color = vec4(foo(BaseColor)); // // gl_FragColor = color; // } const std::vector predefs = { // clang-format off "OpCapability Shader", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Fragment %main \"main\" %BaseColor %gl_FragColor", "OpExecutionMode %main OriginUpperLeft", "OpSource GLSL 140", "OpName %main \"main\"", "OpName %foo_vf4_ \"foo(vf4;\"", "OpName %bar \"bar\"", "OpName %r \"r\"", "OpName %color \"color\"", "OpName %BaseColor \"BaseColor\"", "OpName %param \"param\"", "OpName %gl_FragColor \"gl_FragColor\"", "%void = OpTypeVoid", "%11 = OpTypeFunction %void", "%float = OpTypeFloat 32", "%v4float = OpTypeVector %float 4", "%_ptr_Function_v4float = OpTypePointer Function %v4float", "%15 = OpTypeFunction %float %_ptr_Function_v4float", "%_ptr_Function_float = OpTypePointer Function %float", "%uint = OpTypeInt 32 0", "%uint_0 = OpConstant %uint 0", "%float_0 = OpConstant %float 0", "%bool = OpTypeBool", "%_ptr_Input_v4float = OpTypePointer Input %v4float", "%BaseColor = OpVariable %_ptr_Input_v4float Input", "%_ptr_Output_v4float = OpTypePointer Output %v4float", "%gl_FragColor = OpVariable %_ptr_Output_v4float Output", // clang-format on }; const std::vector nonEntryFuncs = { // clang-format off "%foo_vf4_ = OpFunction %float None %15", "%bar = OpFunctionParameter %_ptr_Function_v4float", "%28 = OpLabel", "%r = OpVariable %_ptr_Function_float Function", "%29 = OpAccessChain %_ptr_Function_float %bar %uint_0", "%30 = OpLoad %float %29", "OpStore %r %30", "%31 = OpLoad %float %r", "%32 = OpFOrdLessThan %bool %31 %float_0", "OpSelectionMerge %33 None", "OpBranchConditional %32 %34 %33", "%34 = OpLabel", "%35 = OpLoad %float %r", "%36 = OpFNegate %float %35", "OpStore %r %36", "OpBranch %33", "%33 = OpLabel", "%37 = OpLoad %float %r", "OpReturnValue %37", "OpFunctionEnd", // clang-format on }; const std::vector before = { // clang-format off "%main = OpFunction %void None %11", "%23 = OpLabel", "%color = OpVariable %_ptr_Function_v4float Function", "%param = OpVariable %_ptr_Function_v4float Function", "%24 = OpLoad %v4float %BaseColor", "OpStore %param %24", "%25 = OpFunctionCall %float %foo_vf4_ %param", "%26 = OpCompositeConstruct %v4float %25 %25 %25 %25", "OpStore %color %26", "%27 = OpLoad %v4float %color", "OpStore %gl_FragColor %27", "OpReturn", "OpFunctionEnd", // clang-format on }; const std::vector after = { // clang-format off "%main = OpFunction %void None %11", "%23 = OpLabel", "%38 = OpVariable %_ptr_Function_float Function", "%39 = OpVariable %_ptr_Function_float Function", "%color = OpVariable %_ptr_Function_v4float Function", "%param = OpVariable %_ptr_Function_v4float Function", "%24 = OpLoad %v4float %BaseColor", "OpStore %param %24", "%41 = OpAccessChain %_ptr_Function_float %param %uint_0", "%42 = OpLoad %float %41", "OpStore %38 %42", "%43 = OpLoad %float %38", "%44 = OpFOrdLessThan %bool %43 %float_0", "OpSelectionMerge %48 None", "OpBranchConditional %44 %45 %48", "%45 = OpLabel", "%46 = OpLoad %float %38", "%47 = OpFNegate %float %46", "OpStore %38 %47", "OpBranch %48", "%48 = OpLabel", "%49 = OpLoad %float %38", "OpStore %39 %49", "%25 = OpLoad %float %39", "%26 = OpCompositeConstruct %v4float %25 %25 %25 %25", "OpStore %color %26", "%27 = OpLoad %v4float %color", "OpStore %gl_FragColor %27", "OpReturn", "OpFunctionEnd", // clang-format on }; SinglePassRunAndCheck( JoinAllInsts(Concat(Concat(predefs, before), nonEntryFuncs)), JoinAllInsts(Concat(Concat(predefs, after), nonEntryFuncs)), /* skip_nop = */ false, /* do_validate = */ true); } TEST_F(InlineTest, PhiAfterCall) { // #version 140 // // in vec4 BaseColor; // // float foo(float bar) // { // float r = bar; // if (r < 0.0) // r = -r; // return r; // } // // void main() // { // vec4 color = BaseColor; // if (foo(color.x) > 2.0 && foo(color.y) > 2.0) // color = vec4(0.0); // gl_FragColor = color; // } const std::vector predefs = { // clang-format off "OpCapability Shader", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Fragment %main \"main\" %BaseColor %gl_FragColor", "OpExecutionMode %main OriginUpperLeft", "OpSource GLSL 140", "OpName %main \"main\"", "OpName %foo_f1_ \"foo(f1;\"", "OpName %bar \"bar\"", "OpName %r \"r\"", "OpName %color \"color\"", "OpName %BaseColor \"BaseColor\"", "OpName %param \"param\"", "OpName %param_0 \"param\"", "OpName %gl_FragColor \"gl_FragColor\"", "%void = OpTypeVoid", "%12 = OpTypeFunction %void", "%float = OpTypeFloat 32", "%_ptr_Function_float = OpTypePointer Function %float", "%15 = OpTypeFunction %float %_ptr_Function_float", "%float_0 = OpConstant %float 0", "%bool = OpTypeBool", "%v4float = OpTypeVector %float 4", "%_ptr_Function_v4float = OpTypePointer Function %v4float", "%_ptr_Input_v4float = OpTypePointer Input %v4float", "%BaseColor = OpVariable %_ptr_Input_v4float Input", "%uint = OpTypeInt 32 0", "%uint_0 = OpConstant %uint 0", "%float_2 = OpConstant %float 2", "%uint_1 = OpConstant %uint 1", "%25 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0", "%_ptr_Output_v4float = OpTypePointer Output %v4float", "%gl_FragColor = OpVariable %_ptr_Output_v4float Output", // clang-format on }; const std::vector nonEntryFuncs = { // clang-format off "%foo_f1_ = OpFunction %float None %15", "%bar = OpFunctionParameter %_ptr_Function_float", "%43 = OpLabel", "%r = OpVariable %_ptr_Function_float Function", "%44 = OpLoad %float %bar", "OpStore %r %44", "%45 = OpLoad %float %r", "%46 = OpFOrdLessThan %bool %45 %float_0", "OpSelectionMerge %47 None", "OpBranchConditional %46 %48 %47", "%48 = OpLabel", "%49 = OpLoad %float %r", "%50 = OpFNegate %float %49", "OpStore %r %50", "OpBranch %47", "%47 = OpLabel", "%51 = OpLoad %float %r", "OpReturnValue %51", "OpFunctionEnd", // clang-format on }; const std::vector before = { // clang-format off "%main = OpFunction %void None %12", "%27 = OpLabel", "%color = OpVariable %_ptr_Function_v4float Function", "%param = OpVariable %_ptr_Function_float Function", "%param_0 = OpVariable %_ptr_Function_float Function", "%28 = OpLoad %v4float %BaseColor", "OpStore %color %28", "%29 = OpAccessChain %_ptr_Function_float %color %uint_0", "%30 = OpLoad %float %29", "OpStore %param %30", "%31 = OpFunctionCall %float %foo_f1_ %param", "%32 = OpFOrdGreaterThan %bool %31 %float_2", "OpSelectionMerge %33 None", "OpBranchConditional %32 %34 %33", "%34 = OpLabel", "%35 = OpAccessChain %_ptr_Function_float %color %uint_1", "%36 = OpLoad %float %35", "OpStore %param_0 %36", "%37 = OpFunctionCall %float %foo_f1_ %param_0", "%38 = OpFOrdGreaterThan %bool %37 %float_2", "OpBranch %33", "%33 = OpLabel", "%39 = OpPhi %bool %32 %27 %38 %34", "OpSelectionMerge %40 None", "OpBranchConditional %39 %41 %40", "%41 = OpLabel", "OpStore %color %25", "OpBranch %40", "%40 = OpLabel", "%42 = OpLoad %v4float %color", "OpStore %gl_FragColor %42", "OpReturn", "OpFunctionEnd", // clang-format on }; const std::vector after = { // clang-format off "%main = OpFunction %void None %12", "%27 = OpLabel", "%63 = OpVariable %_ptr_Function_float Function", "%64 = OpVariable %_ptr_Function_float Function", "%52 = OpVariable %_ptr_Function_float Function", "%53 = OpVariable %_ptr_Function_float Function", "%color = OpVariable %_ptr_Function_v4float Function", "%param = OpVariable %_ptr_Function_float Function", "%param_0 = OpVariable %_ptr_Function_float Function", "%28 = OpLoad %v4float %BaseColor", "OpStore %color %28", "%29 = OpAccessChain %_ptr_Function_float %color %uint_0", "%30 = OpLoad %float %29", "OpStore %param %30", "%55 = OpLoad %float %param", "OpStore %52 %55", "%56 = OpLoad %float %52", "%57 = OpFOrdLessThan %bool %56 %float_0", "OpSelectionMerge %61 None", "OpBranchConditional %57 %58 %61", "%58 = OpLabel", "%59 = OpLoad %float %52", "%60 = OpFNegate %float %59", "OpStore %52 %60", "OpBranch %61", "%61 = OpLabel", "%62 = OpLoad %float %52", "OpStore %53 %62", "%31 = OpLoad %float %53", "%32 = OpFOrdGreaterThan %bool %31 %float_2", "OpSelectionMerge %33 None", "OpBranchConditional %32 %34 %33", "%34 = OpLabel", "%35 = OpAccessChain %_ptr_Function_float %color %uint_1", "%36 = OpLoad %float %35", "OpStore %param_0 %36", "%66 = OpLoad %float %param_0", "OpStore %63 %66", "%67 = OpLoad %float %63", "%68 = OpFOrdLessThan %bool %67 %float_0", "OpSelectionMerge %72 None", "OpBranchConditional %68 %69 %72", "%69 = OpLabel", "%70 = OpLoad %float %63", "%71 = OpFNegate %float %70", "OpStore %63 %71", "OpBranch %72", "%72 = OpLabel", "%73 = OpLoad %float %63", "OpStore %64 %73", "%37 = OpLoad %float %64", "%38 = OpFOrdGreaterThan %bool %37 %float_2", "OpBranch %33", "%33 = OpLabel", "%39 = OpPhi %bool %32 %61 %38 %72", "OpSelectionMerge %40 None", "OpBranchConditional %39 %41 %40", "%41 = OpLabel", "OpStore %color %25", "OpBranch %40", "%40 = OpLabel", "%42 = OpLoad %v4float %color", "OpStore %gl_FragColor %42", "OpReturn", "OpFunctionEnd", // clang-format on }; SinglePassRunAndCheck( JoinAllInsts(Concat(Concat(predefs, before), nonEntryFuncs)), JoinAllInsts(Concat(Concat(predefs, after), nonEntryFuncs)), /* skip_nop = */ false, /* do_validate = */ true); } TEST_F(InlineTest, OpSampledImageOutOfBlock) { // #version 450 // // uniform texture2D t2D; // uniform sampler samp; // out vec4 FragColor; // in vec4 BaseColor; // // float foo(vec4 bar) // { // float r = bar.x; // if (r < 0.0) // r = -r; // return r; // } // // void main() // { // vec4 color1 = texture(sampler2D(t2D, samp), vec2(1.0)); // vec4 color2 = vec4(foo(BaseColor)); // vec4 color3 = texture(sampler2D(t2D, samp), vec2(0.5)); // FragColor = (color1 + color2 + color3)/3; // } // // Note: the before SPIR-V will need to be edited to create a use of // the OpSampledImage across the function call. const std::vector predefs = { // clang-format off "OpCapability Shader", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Fragment %main \"main\" %BaseColor %FragColor", "OpExecutionMode %main OriginUpperLeft", "OpSource GLSL 450", "OpName %main \"main\"", "OpName %foo_vf4_ \"foo(vf4;\"", "OpName %bar \"bar\"", "OpName %r \"r\"", "OpName %color1 \"color1\"", "OpName %t2D \"t2D\"", "OpName %samp \"samp\"", "OpName %color2 \"color2\"", "OpName %BaseColor \"BaseColor\"", "OpName %param \"param\"", "OpName %color3 \"color3\"", "OpName %FragColor \"FragColor\"", "OpDecorate %t2D DescriptorSet 0", "OpDecorate %samp DescriptorSet 0", "%void = OpTypeVoid", "%15 = OpTypeFunction %void", "%float = OpTypeFloat 32", "%v4float = OpTypeVector %float 4", "%_ptr_Function_v4float = OpTypePointer Function %v4float", "%19 = OpTypeFunction %float %_ptr_Function_v4float", "%_ptr_Function_float = OpTypePointer Function %float", "%uint = OpTypeInt 32 0", "%uint_0 = OpConstant %uint 0", "%float_0 = OpConstant %float 0", "%bool = OpTypeBool", "%25 = OpTypeImage %float 2D 0 0 0 1 Unknown", "%_ptr_UniformConstant_25 = OpTypePointer UniformConstant %25", "%t2D = OpVariable %_ptr_UniformConstant_25 UniformConstant", "%27 = OpTypeSampler", "%_ptr_UniformConstant_27 = OpTypePointer UniformConstant %27", "%samp = OpVariable %_ptr_UniformConstant_27 UniformConstant", "%29 = OpTypeSampledImage %25", "%v2float = OpTypeVector %float 2", "%float_1 = OpConstant %float 1", "%32 = OpConstantComposite %v2float %float_1 %float_1", "%_ptr_Input_v4float = OpTypePointer Input %v4float", "%BaseColor = OpVariable %_ptr_Input_v4float Input", "%float_0_5 = OpConstant %float 0.5", "%35 = OpConstantComposite %v2float %float_0_5 %float_0_5", "%_ptr_Output_v4float = OpTypePointer Output %v4float", "%FragColor = OpVariable %_ptr_Output_v4float Output", "%float_3 = OpConstant %float 3", // clang-format on }; const std::vector nonEntryFuncs = { // clang-format off "%foo_vf4_ = OpFunction %float None %19", "%bar = OpFunctionParameter %_ptr_Function_v4float", "%56 = OpLabel", "%r = OpVariable %_ptr_Function_float Function", "%57 = OpAccessChain %_ptr_Function_float %bar %uint_0", "%58 = OpLoad %float %57", "OpStore %r %58", "%59 = OpLoad %float %r", "%60 = OpFOrdLessThan %bool %59 %float_0", "OpSelectionMerge %61 None", "OpBranchConditional %60 %62 %61", "%62 = OpLabel", "%63 = OpLoad %float %r", "%64 = OpFNegate %float %63", "OpStore %r %64", "OpBranch %61", "%61 = OpLabel", "%65 = OpLoad %float %r", "OpReturnValue %65", "OpFunctionEnd", // clang-format on }; const std::vector before = { // clang-format off "%main = OpFunction %void None %15", "%38 = OpLabel", "%color1 = OpVariable %_ptr_Function_v4float Function", "%color2 = OpVariable %_ptr_Function_v4float Function", "%param = OpVariable %_ptr_Function_v4float Function", "%color3 = OpVariable %_ptr_Function_v4float Function", "%39 = OpLoad %25 %t2D", "%40 = OpLoad %27 %samp", "%41 = OpSampledImage %29 %39 %40", "%42 = OpImageSampleImplicitLod %v4float %41 %32", "OpStore %color1 %42", "%43 = OpLoad %v4float %BaseColor", "OpStore %param %43", "%44 = OpFunctionCall %float %foo_vf4_ %param", "%45 = OpCompositeConstruct %v4float %44 %44 %44 %44", "OpStore %color2 %45", "%46 = OpLoad %25 %t2D", "%47 = OpLoad %27 %samp", "%48 = OpImageSampleImplicitLod %v4float %41 %35", "OpStore %color3 %48", "%49 = OpLoad %v4float %color1", "%50 = OpLoad %v4float %color2", "%51 = OpFAdd %v4float %49 %50", "%52 = OpLoad %v4float %color3", "%53 = OpFAdd %v4float %51 %52", "%54 = OpCompositeConstruct %v4float %float_3 %float_3 %float_3 %float_3", "%55 = OpFDiv %v4float %53 %54", "OpStore %FragColor %55", "OpReturn", "OpFunctionEnd", // clang-format on }; const std::vector after = { // clang-format off "%main = OpFunction %void None %15", "%38 = OpLabel", "%66 = OpVariable %_ptr_Function_float Function", "%67 = OpVariable %_ptr_Function_float Function", "%color1 = OpVariable %_ptr_Function_v4float Function", "%color2 = OpVariable %_ptr_Function_v4float Function", "%param = OpVariable %_ptr_Function_v4float Function", "%color3 = OpVariable %_ptr_Function_v4float Function", "%39 = OpLoad %25 %t2D", "%40 = OpLoad %27 %samp", "%41 = OpSampledImage %29 %39 %40", "%42 = OpImageSampleImplicitLod %v4float %41 %32", "OpStore %color1 %42", "%43 = OpLoad %v4float %BaseColor", "OpStore %param %43", "%69 = OpAccessChain %_ptr_Function_float %param %uint_0", "%70 = OpLoad %float %69", "OpStore %66 %70", "%71 = OpLoad %float %66", "%72 = OpFOrdLessThan %bool %71 %float_0", "OpSelectionMerge %76 None", "OpBranchConditional %72 %73 %76", "%73 = OpLabel", "%74 = OpLoad %float %66", "%75 = OpFNegate %float %74", "OpStore %66 %75", "OpBranch %76", "%76 = OpLabel", "%77 = OpLoad %float %66", "OpStore %67 %77", "%44 = OpLoad %float %67", "%45 = OpCompositeConstruct %v4float %44 %44 %44 %44", "OpStore %color2 %45", "%46 = OpLoad %25 %t2D", "%47 = OpLoad %27 %samp", "%78 = OpSampledImage %29 %39 %40", "%48 = OpImageSampleImplicitLod %v4float %78 %35", "OpStore %color3 %48", "%49 = OpLoad %v4float %color1", "%50 = OpLoad %v4float %color2", "%51 = OpFAdd %v4float %49 %50", "%52 = OpLoad %v4float %color3", "%53 = OpFAdd %v4float %51 %52", "%54 = OpCompositeConstruct %v4float %float_3 %float_3 %float_3 %float_3", "%55 = OpFDiv %v4float %53 %54", "OpStore %FragColor %55", "OpReturn", "OpFunctionEnd", // clang-format on }; SinglePassRunAndCheck( JoinAllInsts(Concat(Concat(predefs, before), nonEntryFuncs)), JoinAllInsts(Concat(Concat(predefs, after), nonEntryFuncs)), /* skip_nop = */ false, /* do_validate = */ true); } TEST_F(InlineTest, OpImageOutOfBlock) { // #version 450 // // uniform texture2D t2D; // uniform sampler samp; // uniform sampler samp2; // // out vec4 FragColor; // // in vec4 BaseColor; // // float foo(vec4 bar) // { // float r = bar.x; // if (r < 0.0) // r = -r; // return r; // } // // void main() // { // vec4 color1 = texture(sampler2D(t2D, samp), vec2(1.0)); // vec4 color2 = vec4(foo(BaseColor)); // vec4 color3 = texture(sampler2D(t2D, samp2), vec2(0.5)); // FragColor = (color1 + color2 + color3)/3; // } // Note: the before SPIR-V will need to be edited to create an OpImage // from the first OpSampledImage, place it before the call and use it // in the second OpSampledImage following the call. const std::vector predefs = { // clang-format off "OpCapability Shader", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Fragment %main \"main\" %BaseColor %FragColor", "OpExecutionMode %main OriginUpperLeft", "OpSource GLSL 450", "OpName %main \"main\"", "OpName %foo_vf4_ \"foo(vf4;\"", "OpName %bar \"bar\"", "OpName %r \"r\"", "OpName %color1 \"color1\"", "OpName %t2D \"t2D\"", "OpName %samp \"samp\"", "OpName %color2 \"color2\"", "OpName %BaseColor \"BaseColor\"", "OpName %param \"param\"", "OpName %color3 \"color3\"", "OpName %samp2 \"samp2\"", "OpName %FragColor \"FragColor\"", "OpDecorate %t2D DescriptorSet 0", "OpDecorate %samp DescriptorSet 0", "OpDecorate %samp2 DescriptorSet 0", "%void = OpTypeVoid", "%16 = OpTypeFunction %void", "%float = OpTypeFloat 32", "%v4float = OpTypeVector %float 4", "%_ptr_Function_v4float = OpTypePointer Function %v4float", "%20 = OpTypeFunction %float %_ptr_Function_v4float", "%_ptr_Function_float = OpTypePointer Function %float", "%uint = OpTypeInt 32 0", "%uint_0 = OpConstant %uint 0", "%float_0 = OpConstant %float 0", "%bool = OpTypeBool", "%26 = OpTypeImage %float 2D 0 0 0 1 Unknown", "%_ptr_UniformConstant_26 = OpTypePointer UniformConstant %26", "%t2D = OpVariable %_ptr_UniformConstant_26 UniformConstant", "%28 = OpTypeSampler", "%_ptr_UniformConstant_28 = OpTypePointer UniformConstant %28", "%samp = OpVariable %_ptr_UniformConstant_28 UniformConstant", "%30 = OpTypeSampledImage %26", "%v2float = OpTypeVector %float 2", "%float_1 = OpConstant %float 1", "%33 = OpConstantComposite %v2float %float_1 %float_1", "%_ptr_Input_v4float = OpTypePointer Input %v4float", "%BaseColor = OpVariable %_ptr_Input_v4float Input", "%samp2 = OpVariable %_ptr_UniformConstant_28 UniformConstant", "%float_0_5 = OpConstant %float 0.5", "%36 = OpConstantComposite %v2float %float_0_5 %float_0_5", "%_ptr_Output_v4float = OpTypePointer Output %v4float", "%FragColor = OpVariable %_ptr_Output_v4float Output", "%float_3 = OpConstant %float 3", // clang-format on }; const std::vector nonEntryFuncs = { // clang-format off "%foo_vf4_ = OpFunction %float None %20", "%bar = OpFunctionParameter %_ptr_Function_v4float", "%58 = OpLabel", "%r = OpVariable %_ptr_Function_float Function", "%59 = OpAccessChain %_ptr_Function_float %bar %uint_0", "%60 = OpLoad %float %59", "OpStore %r %60", "%61 = OpLoad %float %r", "%62 = OpFOrdLessThan %bool %61 %float_0", "OpSelectionMerge %63 None", "OpBranchConditional %62 %64 %63", "%64 = OpLabel", "%65 = OpLoad %float %r", "%66 = OpFNegate %float %65", "OpStore %r %66", "OpBranch %63", "%63 = OpLabel", "%67 = OpLoad %float %r", "OpReturnValue %67", "OpFunctionEnd", // clang-format on }; const std::vector before = { // clang-format off "%main = OpFunction %void None %16", "%39 = OpLabel", "%color1 = OpVariable %_ptr_Function_v4float Function", "%color2 = OpVariable %_ptr_Function_v4float Function", "%param = OpVariable %_ptr_Function_v4float Function", "%color3 = OpVariable %_ptr_Function_v4float Function", "%40 = OpLoad %26 %t2D", "%41 = OpLoad %28 %samp", "%42 = OpSampledImage %30 %40 %41", "%43 = OpImageSampleImplicitLod %v4float %42 %33", "%44 = OpImage %26 %42", "%45 = OpLoad %28 %samp2", "OpStore %color1 %43", "%46 = OpLoad %v4float %BaseColor", "OpStore %param %46", "%47 = OpFunctionCall %float %foo_vf4_ %param", "%48 = OpCompositeConstruct %v4float %47 %47 %47 %47", "OpStore %color2 %48", "%49 = OpSampledImage %30 %44 %45", "%50 = OpImageSampleImplicitLod %v4float %49 %36", "OpStore %color3 %50", "%51 = OpLoad %v4float %color1", "%52 = OpLoad %v4float %color2", "%53 = OpFAdd %v4float %51 %52", "%54 = OpLoad %v4float %color3", "%55 = OpFAdd %v4float %53 %54", "%56 = OpCompositeConstruct %v4float %float_3 %float_3 %float_3 %float_3", "%57 = OpFDiv %v4float %55 %56", "OpStore %FragColor %57", "OpReturn", "OpFunctionEnd", // clang-format on }; const std::vector after = { // clang-format off "%main = OpFunction %void None %16", "%39 = OpLabel", "%68 = OpVariable %_ptr_Function_float Function", "%69 = OpVariable %_ptr_Function_float Function", "%color1 = OpVariable %_ptr_Function_v4float Function", "%color2 = OpVariable %_ptr_Function_v4float Function", "%param = OpVariable %_ptr_Function_v4float Function", "%color3 = OpVariable %_ptr_Function_v4float Function", "%40 = OpLoad %26 %t2D", "%41 = OpLoad %28 %samp", "%42 = OpSampledImage %30 %40 %41", "%43 = OpImageSampleImplicitLod %v4float %42 %33", "%44 = OpImage %26 %42", "%45 = OpLoad %28 %samp2", "OpStore %color1 %43", "%46 = OpLoad %v4float %BaseColor", "OpStore %param %46", "%71 = OpAccessChain %_ptr_Function_float %param %uint_0", "%72 = OpLoad %float %71", "OpStore %68 %72", "%73 = OpLoad %float %68", "%74 = OpFOrdLessThan %bool %73 %float_0", "OpSelectionMerge %78 None", "OpBranchConditional %74 %75 %78", "%75 = OpLabel", "%76 = OpLoad %float %68", "%77 = OpFNegate %float %76", "OpStore %68 %77", "OpBranch %78", "%78 = OpLabel", "%79 = OpLoad %float %68", "OpStore %69 %79", "%47 = OpLoad %float %69", "%48 = OpCompositeConstruct %v4float %47 %47 %47 %47", "OpStore %color2 %48", "%80 = OpSampledImage %30 %40 %41", "%81 = OpImage %26 %80", "%49 = OpSampledImage %30 %81 %45", "%50 = OpImageSampleImplicitLod %v4float %49 %36", "OpStore %color3 %50", "%51 = OpLoad %v4float %color1", "%52 = OpLoad %v4float %color2", "%53 = OpFAdd %v4float %51 %52", "%54 = OpLoad %v4float %color3", "%55 = OpFAdd %v4float %53 %54", "%56 = OpCompositeConstruct %v4float %float_3 %float_3 %float_3 %float_3", "%57 = OpFDiv %v4float %55 %56", "OpStore %FragColor %57", "OpReturn", "OpFunctionEnd", // clang-format on }; SinglePassRunAndCheck( JoinAllInsts(Concat(Concat(predefs, before), nonEntryFuncs)), JoinAllInsts(Concat(Concat(predefs, after), nonEntryFuncs)), /* skip_nop = */ false, /* do_validate = */ true); } TEST_F(InlineTest, OpImageAndOpSampledImageOutOfBlock) { // #version 450 // // uniform texture2D t2D; // uniform sampler samp; // uniform sampler samp2; // // out vec4 FragColor; // // in vec4 BaseColor; // // float foo(vec4 bar) // { // float r = bar.x; // if (r < 0.0) // r = -r; // return r; // } // // void main() // { // vec4 color1 = texture(sampler2D(t2D, samp), vec2(1.0)); // vec4 color2 = vec4(foo(BaseColor)); // vec4 color3 = texture(sampler2D(t2D, samp2), vec2(0.5)); // FragColor = (color1 + color2 + color3)/3; // } // Note: the before SPIR-V will need to be edited to create an OpImage // and subsequent OpSampledImage that is used across the function call. const std::vector predefs = { // clang-format off "OpCapability Shader", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Fragment %main \"main\" %BaseColor %FragColor", "OpExecutionMode %main OriginUpperLeft", "OpSource GLSL 450", "OpName %main \"main\"", "OpName %foo_vf4_ \"foo(vf4;\"", "OpName %bar \"bar\"", "OpName %r \"r\"", "OpName %color1 \"color1\"", "OpName %t2D \"t2D\"", "OpName %samp \"samp\"", "OpName %color2 \"color2\"", "OpName %BaseColor \"BaseColor\"", "OpName %param \"param\"", "OpName %color3 \"color3\"", "OpName %samp2 \"samp2\"", "OpName %FragColor \"FragColor\"", "OpDecorate %t2D DescriptorSet 0", "OpDecorate %samp DescriptorSet 0", "OpDecorate %samp2 DescriptorSet 0", "%void = OpTypeVoid", "%16 = OpTypeFunction %void", "%float = OpTypeFloat 32", "%v4float = OpTypeVector %float 4", "%_ptr_Function_v4float = OpTypePointer Function %v4float", "%20 = OpTypeFunction %float %_ptr_Function_v4float", "%_ptr_Function_float = OpTypePointer Function %float", "%uint = OpTypeInt 32 0", "%uint_0 = OpConstant %uint 0", "%float_0 = OpConstant %float 0", "%bool = OpTypeBool", "%26 = OpTypeImage %float 2D 0 0 0 1 Unknown", "%_ptr_UniformConstant_26 = OpTypePointer UniformConstant %26", "%t2D = OpVariable %_ptr_UniformConstant_26 UniformConstant", "%28 = OpTypeSampler", "%_ptr_UniformConstant_28 = OpTypePointer UniformConstant %28", "%samp = OpVariable %_ptr_UniformConstant_28 UniformConstant", "%30 = OpTypeSampledImage %26", "%v2float = OpTypeVector %float 2", "%float_1 = OpConstant %float 1", "%33 = OpConstantComposite %v2float %float_1 %float_1", "%_ptr_Input_v4float = OpTypePointer Input %v4float", "%BaseColor = OpVariable %_ptr_Input_v4float Input", "%samp2 = OpVariable %_ptr_UniformConstant_28 UniformConstant", "%float_0_5 = OpConstant %float 0.5", "%36 = OpConstantComposite %v2float %float_0_5 %float_0_5", "%_ptr_Output_v4float = OpTypePointer Output %v4float", "%FragColor = OpVariable %_ptr_Output_v4float Output", "%float_3 = OpConstant %float 3", // clang-format on }; const std::vector nonEntryFuncs = { // clang-format off "%foo_vf4_ = OpFunction %float None %20", "%bar = OpFunctionParameter %_ptr_Function_v4float", "%58 = OpLabel", "%r = OpVariable %_ptr_Function_float Function", "%59 = OpAccessChain %_ptr_Function_float %bar %uint_0", "%60 = OpLoad %float %59", "OpStore %r %60", "%61 = OpLoad %float %r", "%62 = OpFOrdLessThan %bool %61 %float_0", "OpSelectionMerge %63 None", "OpBranchConditional %62 %64 %63", "%64 = OpLabel", "%65 = OpLoad %float %r", "%66 = OpFNegate %float %65", "OpStore %r %66", "OpBranch %63", "%63 = OpLabel", "%67 = OpLoad %float %r", "OpReturnValue %67", "OpFunctionEnd", // clang-format on }; const std::vector before = { // clang-format off "%main = OpFunction %void None %16", "%39 = OpLabel", "%color1 = OpVariable %_ptr_Function_v4float Function", "%color2 = OpVariable %_ptr_Function_v4float Function", "%param = OpVariable %_ptr_Function_v4float Function", "%color3 = OpVariable %_ptr_Function_v4float Function", "%40 = OpLoad %26 %t2D", "%41 = OpLoad %28 %samp", "%42 = OpSampledImage %30 %40 %41", "%43 = OpImageSampleImplicitLod %v4float %42 %33", "%44 = OpImage %26 %42", "%45 = OpLoad %28 %samp2", "%46 = OpSampledImage %30 %44 %45", "OpStore %color1 %43", "%47 = OpLoad %v4float %BaseColor", "OpStore %param %47", "%48 = OpFunctionCall %float %foo_vf4_ %param", "%49 = OpCompositeConstruct %v4float %48 %48 %48 %48", "OpStore %color2 %49", "%50 = OpImageSampleImplicitLod %v4float %46 %36", "OpStore %color3 %50", "%51 = OpLoad %v4float %color1", "%52 = OpLoad %v4float %color2", "%53 = OpFAdd %v4float %51 %52", "%54 = OpLoad %v4float %color3", "%55 = OpFAdd %v4float %53 %54", "%56 = OpCompositeConstruct %v4float %float_3 %float_3 %float_3 %float_3", "%57 = OpFDiv %v4float %55 %56", "OpStore %FragColor %57", "OpReturn", "OpFunctionEnd", // clang-format on }; const std::vector after = { // clang-format off "%main = OpFunction %void None %16", "%39 = OpLabel", "%68 = OpVariable %_ptr_Function_float Function", "%69 = OpVariable %_ptr_Function_float Function", "%color1 = OpVariable %_ptr_Function_v4float Function", "%color2 = OpVariable %_ptr_Function_v4float Function", "%param = OpVariable %_ptr_Function_v4float Function", "%color3 = OpVariable %_ptr_Function_v4float Function", "%40 = OpLoad %26 %t2D", "%41 = OpLoad %28 %samp", "%42 = OpSampledImage %30 %40 %41", "%43 = OpImageSampleImplicitLod %v4float %42 %33", "%44 = OpImage %26 %42", "%45 = OpLoad %28 %samp2", "%46 = OpSampledImage %30 %44 %45", "OpStore %color1 %43", "%47 = OpLoad %v4float %BaseColor", "OpStore %param %47", "%71 = OpAccessChain %_ptr_Function_float %param %uint_0", "%72 = OpLoad %float %71", "OpStore %68 %72", "%73 = OpLoad %float %68", "%74 = OpFOrdLessThan %bool %73 %float_0", "OpSelectionMerge %78 None", "OpBranchConditional %74 %75 %78", "%75 = OpLabel", "%76 = OpLoad %float %68", "%77 = OpFNegate %float %76", "OpStore %68 %77", "OpBranch %78", "%78 = OpLabel", "%79 = OpLoad %float %68", "OpStore %69 %79", "%48 = OpLoad %float %69", "%49 = OpCompositeConstruct %v4float %48 %48 %48 %48", "OpStore %color2 %49", "%80 = OpSampledImage %30 %40 %41", "%81 = OpImage %26 %80", "%82 = OpSampledImage %30 %81 %45", "%50 = OpImageSampleImplicitLod %v4float %82 %36", "OpStore %color3 %50", "%51 = OpLoad %v4float %color1", "%52 = OpLoad %v4float %color2", "%53 = OpFAdd %v4float %51 %52", "%54 = OpLoad %v4float %color3", "%55 = OpFAdd %v4float %53 %54", "%56 = OpCompositeConstruct %v4float %float_3 %float_3 %float_3 %float_3", "%57 = OpFDiv %v4float %55 %56", "OpStore %FragColor %57", "OpReturn", "OpFunctionEnd", // clang-format on }; SinglePassRunAndCheck( JoinAllInsts(Concat(Concat(predefs, before), nonEntryFuncs)), JoinAllInsts(Concat(Concat(predefs, after), nonEntryFuncs)), /* skip_nop = */ false, /* do_validate = */ true); } TEST_F(InlineTest, EarlyReturnInLoopIsNotInlined) { // #version 140 // // in vec4 BaseColor; // // float foo(vec4 bar) // { // while (true) { // if (bar.x < 0.0) // return 0.0; // return bar.x; // } // } // // void main() // { // vec4 color = vec4(foo(BaseColor)); // gl_FragColor = color; // } const std::string assembly = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %foo_vf4_ "foo(vf4;" OpName %bar "bar" OpName %color "color" OpName %BaseColor "BaseColor" OpName %param "param" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %10 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %14 = OpTypeFunction %float %_ptr_Function_v4float %bool = OpTypeBool %true = OpConstantTrue %bool %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %10 %23 = OpLabel %color = OpVariable %_ptr_Function_v4float Function %param = OpVariable %_ptr_Function_v4float Function %24 = OpLoad %v4float %BaseColor OpStore %param %24 %25 = OpFunctionCall %float %foo_vf4_ %param %26 = OpCompositeConstruct %v4float %25 %25 %25 %25 OpStore %color %26 %27 = OpLoad %v4float %color OpStore %gl_FragColor %27 OpReturn OpFunctionEnd %foo_vf4_ = OpFunction %float None %14 %bar = OpFunctionParameter %_ptr_Function_v4float %28 = OpLabel OpBranch %29 %29 = OpLabel OpLoopMerge %30 %31 None OpBranch %32 %32 = OpLabel OpBranchConditional %true %33 %30 %33 = OpLabel %34 = OpAccessChain %_ptr_Function_float %bar %uint_0 %35 = OpLoad %float %34 %36 = OpFOrdLessThan %bool %35 %float_0 OpSelectionMerge %37 None OpBranchConditional %36 %38 %37 %38 = OpLabel OpReturnValue %float_0 %37 = OpLabel %39 = OpAccessChain %_ptr_Function_float %bar %uint_0 %40 = OpLoad %float %39 OpReturnValue %40 %31 = OpLabel OpBranch %29 %30 = OpLabel %41 = OpUndef %float OpReturnValue %41 OpFunctionEnd )"; SinglePassRunAndCheck(assembly, assembly, false, true); } TEST_F(InlineTest, ExternalFunctionIsNotInlined) { // In particular, don't crash. // See report https://github.com/KhronosGroup/SPIRV-Tools/issues/605 const std::string assembly = R"(OpCapability Addresses OpCapability Kernel OpCapability Linkage OpMemoryModel Physical32 OpenCL OpEntryPoint Kernel %1 "entry_pt" OpDecorate %2 LinkageAttributes "external" Import %void = OpTypeVoid %4 = OpTypeFunction %void %2 = OpFunction %void None %4 OpFunctionEnd %1 = OpFunction %void None %4 %5 = OpLabel %6 = OpFunctionCall %void %2 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(assembly, assembly, false, true); } TEST_F(InlineTest, SingleBlockLoopCallsMultiBlockCallee) { // Example from https://github.com/KhronosGroup/SPIRV-Tools/issues/787 // // CFG structure is: // foo: // fooentry -> fooexit // // main: // entry -> loop // loop -> loop, merge // loop calls foo() // merge // // Since the callee has multiple blocks, it will split the calling block // into at least two, resulting in a new "back-half" block that contains // the instructions after the inlined function call. If the calling block // has an OpLoopMerge that points back to the calling block itself, then // the OpLoopMerge can't remain in the back-half block, but must be // moved to the end of the original calling block, and it continue target // operand updated to point to the back-half block. const std::string predefs = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpSource OpenCL_C 120 %bool = OpTypeBool %true = OpConstantTrue %bool %void = OpTypeVoid %5 = OpTypeFunction %void )"; const std::string nonEntryFuncs = R"(%6 = OpFunction %void None %5 %7 = OpLabel OpBranch %8 %8 = OpLabel OpReturn OpFunctionEnd )"; const std::string before = R"(%1 = OpFunction %void None %5 %9 = OpLabel OpBranch %10 %10 = OpLabel %11 = OpFunctionCall %void %6 OpLoopMerge %12 %10 None OpBranchConditional %true %10 %12 %12 = OpLabel OpReturn OpFunctionEnd )"; const std::string after = R"(%1 = OpFunction %void None %5 %9 = OpLabel OpBranch %10 %10 = OpLabel OpLoopMerge %12 %15 None OpBranch %14 %14 = OpLabel OpBranch %15 %15 = OpLabel OpBranchConditional %true %10 %12 %12 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + nonEntryFuncs + before, predefs + nonEntryFuncs + after, false, true); } TEST_F(InlineTest, MultiBlockLoopHeaderCallsMultiBlockCallee) { // Like SingleBlockLoopCallsMultiBlockCallee but the loop has several // blocks, but the function call still occurs in the loop header. // Example from https://github.com/KhronosGroup/SPIRV-Tools/issues/800 const std::string predefs = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpSource OpenCL_C 120 %bool = OpTypeBool %true = OpConstantTrue %bool %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %int_3 = OpConstant %int 3 %int_4 = OpConstant %int 4 %int_5 = OpConstant %int 5 %void = OpTypeVoid %11 = OpTypeFunction %void )"; const std::string nonEntryFuncs = R"(%12 = OpFunction %void None %11 %13 = OpLabel %14 = OpCopyObject %int %int_1 OpBranch %15 %15 = OpLabel %16 = OpCopyObject %int %int_2 OpReturn OpFunctionEnd )"; const std::string before = R"(%1 = OpFunction %void None %11 %17 = OpLabel OpBranch %18 %18 = OpLabel %19 = OpCopyObject %int %int_3 %20 = OpFunctionCall %void %12 %21 = OpCopyObject %int %int_4 OpLoopMerge %22 %23 None OpBranchConditional %true %23 %22 %23 = OpLabel %24 = OpCopyObject %int %int_5 OpBranchConditional %true %18 %22 %22 = OpLabel OpReturn OpFunctionEnd )"; const std::string after = R"(%1 = OpFunction %void None %11 %17 = OpLabel OpBranch %18 %18 = OpLabel %19 = OpCopyObject %int %int_3 %26 = OpCopyObject %int %int_1 OpLoopMerge %22 %23 None OpBranch %27 %27 = OpLabel %28 = OpCopyObject %int %int_2 %21 = OpCopyObject %int %int_4 OpBranchConditional %true %23 %22 %23 = OpLabel %24 = OpCopyObject %int %int_5 OpBranchConditional %true %18 %22 %22 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + nonEntryFuncs + before, predefs + nonEntryFuncs + after, false, true); } TEST_F(InlineTest, SingleBlockLoopCallsMultiBlockCalleeHavingSelectionMerge) { // This is similar to SingleBlockLoopCallsMultiBlockCallee except // that calleee block also has a merge instruction in its first block. // That merge instruction must be an OpSelectionMerge (because the entry // block of a function can't be the header of a loop since the entry // block can't be the target of a branch). // // In this case the OpLoopMerge can't be placed in the same block as // the OpSelectionMerge, so inlining must create a new block to contain // the callee contents. // // Additionally, we have two extra OpCopyObject instructions to prove that // the OpLoopMerge is moved to the right location. // // Also ensure that OpPhis within the cloned callee code are valid. // We need to test that the predecessor blocks are remapped correctly so that // dominance rules are satisfied const std::string predefs = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpSource OpenCL_C 120 %bool = OpTypeBool %true = OpConstantTrue %bool %false = OpConstantFalse %bool %void = OpTypeVoid %6 = OpTypeFunction %void )"; // This callee has multiple blocks, and an OpPhi in the last block // that references a value from the first block. This tests that // cloned block IDs are remapped appropriately. The OpPhi dominance // requires that the remapped %9 must be in a block that dominates // the remapped %8. const std::string nonEntryFuncs = R"(%7 = OpFunction %void None %6 %8 = OpLabel %9 = OpCopyObject %bool %true OpSelectionMerge %10 None OpBranchConditional %true %10 %10 %10 = OpLabel %11 = OpPhi %bool %9 %8 OpReturn OpFunctionEnd )"; const std::string before = R"(%1 = OpFunction %void None %6 %12 = OpLabel OpBranch %13 %13 = OpLabel %14 = OpCopyObject %bool %false %15 = OpFunctionCall %void %7 OpLoopMerge %16 %13 None OpBranchConditional %true %13 %16 %16 = OpLabel OpReturn OpFunctionEnd )"; // Note the remapped Phi uses %17 as the parent instead // of %13, demonstrating that the parent block has been remapped // correctly. const std::string after = R"(%1 = OpFunction %void None %6 %12 = OpLabel OpBranch %13 %13 = OpLabel %14 = OpCopyObject %bool %false OpLoopMerge %16 %22 None OpBranch %17 %17 = OpLabel %19 = OpCopyObject %bool %true OpSelectionMerge %20 None OpBranchConditional %true %20 %20 %20 = OpLabel %21 = OpPhi %bool %19 %17 OpBranch %22 %22 = OpLabel OpBranchConditional %true %13 %16 %16 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + nonEntryFuncs + before, predefs + nonEntryFuncs + after, false, true); } TEST_F(InlineTest, MultiBlockLoopHeaderCallsFromToMultiBlockCalleeHavingSelectionMerge) { // This is similar to SingleBlockLoopCallsMultiBlockCalleeHavingSelectionMerge // but the call is in the header block of a multi block loop. const std::string predefs = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpSource OpenCL_C 120 %bool = OpTypeBool %true = OpConstantTrue %bool %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %int_3 = OpConstant %int 3 %int_4 = OpConstant %int 4 %int_5 = OpConstant %int 5 %void = OpTypeVoid %11 = OpTypeFunction %void )"; const std::string nonEntryFuncs = R"(%12 = OpFunction %void None %11 %13 = OpLabel %14 = OpCopyObject %int %int_1 OpSelectionMerge %15 None OpBranchConditional %true %15 %15 %15 = OpLabel %16 = OpCopyObject %int %int_2 OpReturn OpFunctionEnd )"; const std::string before = R"(%1 = OpFunction %void None %11 %17 = OpLabel OpBranch %18 %18 = OpLabel %19 = OpCopyObject %int %int_3 %20 = OpFunctionCall %void %12 %21 = OpCopyObject %int %int_4 OpLoopMerge %22 %23 None OpBranchConditional %true %23 %22 %23 = OpLabel %24 = OpCopyObject %int %int_5 OpBranchConditional %true %18 %22 %22 = OpLabel OpReturn OpFunctionEnd )"; const std::string after = R"(%1 = OpFunction %void None %11 %17 = OpLabel OpBranch %18 %18 = OpLabel %19 = OpCopyObject %int %int_3 OpLoopMerge %22 %23 None OpBranch %25 %25 = OpLabel %27 = OpCopyObject %int %int_1 OpSelectionMerge %28 None OpBranchConditional %true %28 %28 %28 = OpLabel %29 = OpCopyObject %int %int_2 %21 = OpCopyObject %int %int_4 OpBranchConditional %true %23 %22 %23 = OpLabel %24 = OpCopyObject %int %int_5 OpBranchConditional %true %18 %22 %22 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + nonEntryFuncs + before, predefs + nonEntryFuncs + after, false, true); } TEST_F(InlineTest, NonInlinableCalleeWithSingleReturn) { // The case from https://github.com/KhronosGroup/SPIRV-Tools/issues/2018 // // The callee has a single return, but cannot be inlined because the // return is inside a loop. const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %_GLF_color OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %f_ "f(" OpName %i "i" OpName %_GLF_color "_GLF_color" OpDecorate %_GLF_color Location 0 %void = OpTypeVoid %7 = OpTypeFunction %void %float = OpTypeFloat 32 %9 = OpTypeFunction %float %float_1 = OpConstant %float 1 %bool = OpTypeBool %false = OpConstantFalse %bool %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %_GLF_color = OpVariable %_ptr_Output_v4float Output %float_0 = OpConstant %float 0 %20 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %21 = OpConstantComposite %v4float %float_0 %float_1 %float_0 %float_1 )"; const std::string caller = R"(%main = OpFunction %void None %7 %22 = OpLabel %i = OpVariable %_ptr_Function_int Function OpStore %i %int_0 OpBranch %23 %23 = OpLabel OpLoopMerge %24 %25 None OpBranch %26 %26 = OpLabel %27 = OpLoad %int %i %28 = OpSLessThan %bool %27 %int_1 OpBranchConditional %28 %29 %24 %29 = OpLabel OpStore %_GLF_color %20 %30 = OpFunctionCall %float %f_ OpBranch %25 %25 = OpLabel %31 = OpLoad %int %i %32 = OpIAdd %int %31 %int_1 OpStore %i %32 OpBranch %23 %24 = OpLabel OpStore %_GLF_color %21 OpReturn OpFunctionEnd )"; const std::string callee = R"(%f_ = OpFunction %float None %9 %33 = OpLabel OpBranch %34 %34 = OpLabel OpLoopMerge %35 %36 None OpBranch %37 %37 = OpLabel OpReturnValue %float_1 %36 = OpLabel OpBranch %34 %35 = OpLabel OpUnreachable OpFunctionEnd )"; SinglePassRunAndCheck( predefs + caller + callee, predefs + caller + callee, false, true); } TEST_F(InlineTest, Decorated1) { // Same test as Simple with the difference // that OpFAdd in the outlined function is // decorated with RelaxedPrecision // Expected result is an equal decoration // of the corresponding inlined instruction // // #version 140 // // in vec4 BaseColor; // // float foo(vec4 bar) // { // return bar.x + bar.y; // } // // void main() // { // vec4 color = vec4(foo(BaseColor)); // gl_FragColor = color; // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %foo_vf4_ "foo(vf4;" OpName %bar "bar" OpName %color "color" OpName %BaseColor "BaseColor" OpName %param "param" OpName %gl_FragColor "gl_FragColor" OpDecorate %9 RelaxedPrecision )"; const std::string before = R"(%void = OpTypeVoid %11 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %15 = OpTypeFunction %float %_ptr_Function_v4float %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Function_float = OpTypePointer Function %float %uint_1 = OpConstant %uint 1 %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %11 %22 = OpLabel %color = OpVariable %_ptr_Function_v4float Function %param = OpVariable %_ptr_Function_v4float Function %23 = OpLoad %v4float %BaseColor OpStore %param %23 %24 = OpFunctionCall %float %foo_vf4_ %param %25 = OpCompositeConstruct %v4float %24 %24 %24 %24 OpStore %color %25 %26 = OpLoad %v4float %color OpStore %gl_FragColor %26 OpReturn OpFunctionEnd )"; const std::string after = R"(OpDecorate %38 RelaxedPrecision %void = OpTypeVoid %11 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %15 = OpTypeFunction %float %_ptr_Function_v4float %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Function_float = OpTypePointer Function %float %uint_1 = OpConstant %uint 1 %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %11 %22 = OpLabel %32 = OpVariable %_ptr_Function_float Function %color = OpVariable %_ptr_Function_v4float Function %param = OpVariable %_ptr_Function_v4float Function %23 = OpLoad %v4float %BaseColor OpStore %param %23 %34 = OpAccessChain %_ptr_Function_float %param %uint_0 %35 = OpLoad %float %34 %36 = OpAccessChain %_ptr_Function_float %param %uint_1 %37 = OpLoad %float %36 %38 = OpFAdd %float %35 %37 OpStore %32 %38 %24 = OpLoad %float %32 %25 = OpCompositeConstruct %v4float %24 %24 %24 %24 OpStore %color %25 %26 = OpLoad %v4float %color OpStore %gl_FragColor %26 OpReturn OpFunctionEnd )"; const std::string nonEntryFuncs = R"(%foo_vf4_ = OpFunction %float None %15 %bar = OpFunctionParameter %_ptr_Function_v4float %27 = OpLabel %28 = OpAccessChain %_ptr_Function_float %bar %uint_0 %29 = OpLoad %float %28 %30 = OpAccessChain %_ptr_Function_float %bar %uint_1 %31 = OpLoad %float %30 %9 = OpFAdd %float %29 %31 OpReturnValue %9 OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before + nonEntryFuncs, predefs + after + nonEntryFuncs, false, true); } TEST_F(InlineTest, Decorated2) { // Same test as Simple with the difference // that the Result of the outlined OpFunction // is decorated with RelaxedPrecision // Expected result is an equal decoration // of the created return variable // // #version 140 // // in vec4 BaseColor; // // float foo(vec4 bar) // { // return bar.x + bar.y; // } // // void main() // { // vec4 color = vec4(foo(BaseColor)); // gl_FragColor = color; // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %foo_vf4_ "foo(vf4;" OpName %bar "bar" OpName %color "color" OpName %BaseColor "BaseColor" OpName %param "param" OpName %gl_FragColor "gl_FragColor" OpDecorate %foo_vf4_ RelaxedPrecision )"; const std::string before = R"(%void = OpTypeVoid %10 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %14 = OpTypeFunction %float %_ptr_Function_v4float %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Function_float = OpTypePointer Function %float %uint_1 = OpConstant %uint 1 %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %10 %21 = OpLabel %color = OpVariable %_ptr_Function_v4float Function %param = OpVariable %_ptr_Function_v4float Function %22 = OpLoad %v4float %BaseColor OpStore %param %22 %23 = OpFunctionCall %float %foo_vf4_ %param %24 = OpCompositeConstruct %v4float %23 %23 %23 %23 OpStore %color %24 %25 = OpLoad %v4float %color OpStore %gl_FragColor %25 OpReturn OpFunctionEnd )"; const std::string after = R"(OpDecorate %32 RelaxedPrecision %void = OpTypeVoid %10 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %14 = OpTypeFunction %float %_ptr_Function_v4float %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Function_float = OpTypePointer Function %float %uint_1 = OpConstant %uint 1 %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %10 %21 = OpLabel %32 = OpVariable %_ptr_Function_float Function %color = OpVariable %_ptr_Function_v4float Function %param = OpVariable %_ptr_Function_v4float Function %22 = OpLoad %v4float %BaseColor OpStore %param %22 %34 = OpAccessChain %_ptr_Function_float %param %uint_0 %35 = OpLoad %float %34 %36 = OpAccessChain %_ptr_Function_float %param %uint_1 %37 = OpLoad %float %36 %38 = OpFAdd %float %35 %37 OpStore %32 %38 %23 = OpLoad %float %32 %24 = OpCompositeConstruct %v4float %23 %23 %23 %23 OpStore %color %24 %25 = OpLoad %v4float %color OpStore %gl_FragColor %25 OpReturn OpFunctionEnd )"; const std::string nonEntryFuncs = R"(%foo_vf4_ = OpFunction %float None %14 %bar = OpFunctionParameter %_ptr_Function_v4float %26 = OpLabel %27 = OpAccessChain %_ptr_Function_float %bar %uint_0 %28 = OpLoad %float %27 %29 = OpAccessChain %_ptr_Function_float %bar %uint_1 %30 = OpLoad %float %29 %31 = OpFAdd %float %28 %30 OpReturnValue %31 OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before + nonEntryFuncs, predefs + after + nonEntryFuncs, false, true); } TEST_F(InlineTest, DeleteName) { // Test that the name of the result id of the call is deleted. const std::string before = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpName %main "main" OpName %main_entry "main_entry" OpName %foo_result "foo_result" OpName %void_fn "void_fn" OpName %foo "foo" OpName %foo_entry "foo_entry" %void = OpTypeVoid %void_fn = OpTypeFunction %void %foo = OpFunction %void None %void_fn %foo_entry = OpLabel OpReturn OpFunctionEnd %main = OpFunction %void None %void_fn %main_entry = OpLabel %foo_result = OpFunctionCall %void %foo OpReturn OpFunctionEnd )"; const std::string after = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpName %main "main" OpName %main_entry "main_entry" OpName %void_fn "void_fn" OpName %foo "foo" OpName %foo_entry "foo_entry" %void = OpTypeVoid %void_fn = OpTypeFunction %void %foo = OpFunction %void None %void_fn %foo_entry = OpLabel OpReturn OpFunctionEnd %main = OpFunction %void None %void_fn %main_entry = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(before, after, false, true); } TEST_F(InlineTest, SetParent) { // Test that after inlining all basic blocks have the correct parent. const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpName %main "main" OpName %main_entry "main_entry" OpName %foo_result "foo_result" OpName %void_fn "void_fn" OpName %foo "foo" OpName %foo_entry "foo_entry" %void = OpTypeVoid %void_fn = OpTypeFunction %void %foo = OpFunction %void None %void_fn %foo_entry = OpLabel OpReturn OpFunctionEnd %main = OpFunction %void None %void_fn %main_entry = OpLabel %foo_result = OpFunctionCall %void %foo OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); InlineExhaustivePass pass; pass.Run(context.get()); for (Function& func : *context->module()) { for (BasicBlock& bb : func) { EXPECT_TRUE(bb.GetParent() == &func); } } } TEST_F(InlineTest, OpVariableWithInit) { // Check that there is a store that corresponds to the initializer. This // test makes sure that is a store to the variable in the loop and before any // load. const std::string text = R"( ; CHECK: OpFunction ; CHECK-NOT: OpFunctionEnd ; CHECK: [[var:%\w+]] = OpVariable %_ptr_Function_float Function %float_0 ; CHECK: OpLoopMerge [[outer_merge:%\w+]] ; CHECK-NOT: OpLoad %float [[var]] ; CHECK: OpStore [[var]] %float_0 ; CHECK: OpFunctionEnd OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %o OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpDecorate %o Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %7 = OpTypeFunction %float %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %bool = OpTypeBool %float_1 = OpConstant %float 1 %_ptr_Output_float = OpTypePointer Output %float %o = OpVariable %_ptr_Output_float Output %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %_ptr_Input_int = OpTypePointer Input %int %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %main = OpFunction %void None %3 %5 = OpLabel OpStore %o %float_0 OpBranch %34 %34 = OpLabel %39 = OpPhi %int %int_0 %5 %47 %37 OpLoopMerge %36 %37 None OpBranch %38 %38 = OpLabel %41 = OpSLessThan %bool %39 %int_2 OpBranchConditional %41 %35 %36 %35 = OpLabel %42 = OpFunctionCall %float %foo_ %43 = OpLoad %float %o %44 = OpFAdd %float %43 %42 OpStore %o %44 OpBranch %37 %37 = OpLabel %47 = OpIAdd %int %39 %int_1 OpBranch %34 %36 = OpLabel OpReturn OpFunctionEnd %foo_ = OpFunction %float None %7 %9 = OpLabel %n = OpVariable %_ptr_Function_float Function %float_0 %13 = OpLoad %float %n %15 = OpFOrdEqual %bool %13 %float_0 OpSelectionMerge %17 None OpBranchConditional %15 %16 %17 %16 = OpLabel %19 = OpLoad %float %n %20 = OpFAdd %float %19 %float_1 OpStore %n %20 OpBranch %17 %17 = OpLabel %21 = OpLoad %float %n OpReturnValue %21 OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(InlineTest, DontInlineDirectlyRecursiveFunc) { // Test that the name of the result id of the call is deleted. const std::string test = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %4 = OpTypeFunction %void %float = OpTypeFloat 32 %_struct_6 = OpTypeStruct %float %float %15 = OpConstantNull %_struct_6 %7 = OpTypeFunction %_struct_6 %1 = OpFunction %void Pure|Const %4 %8 = OpLabel %2 = OpFunctionCall %_struct_6 %9 OpKill OpFunctionEnd %9 = OpFunction %_struct_6 None %7 %10 = OpLabel %11 = OpFunctionCall %_struct_6 %9 OpReturnValue %15 OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(test, test, false, true); } TEST_F(InlineTest, DontInlineInDirectlyRecursiveFunc) { // Test that the name of the result id of the call is deleted. const std::string test = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %4 = OpTypeFunction %void %float = OpTypeFloat 32 %_struct_6 = OpTypeStruct %float %float %15 = OpConstantNull %_struct_6 %7 = OpTypeFunction %_struct_6 %1 = OpFunction %void Pure|Const %4 %8 = OpLabel %2 = OpFunctionCall %_struct_6 %9 OpKill OpFunctionEnd %9 = OpFunction %_struct_6 None %7 %10 = OpLabel %11 = OpFunctionCall %_struct_6 %12 OpReturnValue %15 OpFunctionEnd %12 = OpFunction %_struct_6 None %7 %13 = OpLabel %14 = OpFunctionCall %_struct_6 %9 OpReturnValue %15 OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(test, test, false, true); } TEST_F(InlineTest, DontInlineFuncWithOpKillInContinue) { const std::string test = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 330 OpName %main "main" OpName %kill_ "kill(" %void = OpTypeVoid %3 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %main = OpFunction %void None %3 %5 = OpLabel OpBranch %9 %9 = OpLabel OpLoopMerge %11 %12 None OpBranch %13 %13 = OpLabel OpBranchConditional %true %10 %11 %10 = OpLabel OpBranch %12 %12 = OpLabel %16 = OpFunctionCall %void %kill_ OpBranch %9 %11 = OpLabel OpReturn OpFunctionEnd %kill_ = OpFunction %void None %3 %7 = OpLabel OpKill OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(test, test, false, true); } TEST_F(InlineTest, DontInlineFuncWithDontInline) { // Check that the function with DontInline flag is not inlined. const std::string text = R"( ; CHECK: %foo = OpFunction %int DontInline ; CHECK: OpReturnValue %int_0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %main "main" OpName %foo "foo" %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %void = OpTypeVoid %6 = OpTypeFunction %void %7 = OpTypeFunction %int %main = OpFunction %void None %6 %8 = OpLabel %9 = OpFunctionCall %int %foo OpReturn OpFunctionEnd %foo = OpFunction %int DontInline %7 %10 = OpLabel OpReturnValue %int_0 OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(InlineTest, InlineFuncWithOpKillNotInContinue) { const std::string before = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 330 OpName %main "main" OpName %kill_ "kill(" %void = OpTypeVoid %3 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %main = OpFunction %void None %3 %5 = OpLabel %16 = OpFunctionCall %void %kill_ OpReturn OpFunctionEnd %kill_ = OpFunction %void None %3 %7 = OpLabel OpKill OpFunctionEnd )"; const std::string after = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 330 OpName %main "main" OpName %kill_ "kill(" %void = OpTypeVoid %3 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %main = OpFunction %void None %3 %5 = OpLabel OpKill %18 = OpLabel OpReturn OpFunctionEnd %kill_ = OpFunction %void None %3 %7 = OpLabel OpKill OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(before, after, false, true); } TEST_F(InlineTest, DontInlineFuncWithOpTerminateInvocationInContinue) { const std::string test = R"(OpCapability Shader OpExtension "SPV_KHR_terminate_invocation" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 330 OpName %main "main" OpName %kill_ "kill(" %void = OpTypeVoid %3 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %main = OpFunction %void None %3 %5 = OpLabel OpBranch %9 %9 = OpLabel OpLoopMerge %11 %12 None OpBranch %13 %13 = OpLabel OpBranchConditional %true %10 %11 %10 = OpLabel OpBranch %12 %12 = OpLabel %16 = OpFunctionCall %void %kill_ OpBranch %9 %11 = OpLabel OpReturn OpFunctionEnd %kill_ = OpFunction %void None %3 %7 = OpLabel OpTerminateInvocation OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(test, test, false, true); } TEST_F(InlineTest, InlineFuncWithOpTerminateInvocationNotInContinue) { const std::string before = R"(OpCapability Shader OpExtension "SPV_KHR_terminate_invocation" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 330 OpName %main "main" OpName %kill_ "kill(" %void = OpTypeVoid %3 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %main = OpFunction %void None %3 %5 = OpLabel %16 = OpFunctionCall %void %kill_ OpReturn OpFunctionEnd %kill_ = OpFunction %void None %3 %7 = OpLabel OpTerminateInvocation OpFunctionEnd )"; const std::string after = R"(OpCapability Shader OpExtension "SPV_KHR_terminate_invocation" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 330 OpName %main "main" OpName %kill_ "kill(" %void = OpTypeVoid %3 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %main = OpFunction %void None %3 %5 = OpLabel OpTerminateInvocation %18 = OpLabel OpReturn OpFunctionEnd %kill_ = OpFunction %void None %3 %7 = OpLabel OpTerminateInvocation OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(before, after, false, true); } TEST_F(InlineTest, InlineForLinkage) { const std::string before = R"(OpCapability SampledBuffer OpCapability ImageBuffer OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpSource HLSL 630 OpName %type_buffer_image "type.buffer.image" OpName %output "output" OpName %main "main" OpName %color "color" OpName %bb_entry "bb.entry" OpName %param_var_color "param.var.color" OpName %fn "fn" OpName %color_0 "color" OpName %bb_entry_0 "bb.entry" OpName %v "v" OpDecorate %main LinkageAttributes "main" Export OpDecorate %output DescriptorSet 0 OpDecorate %output Binding 1 %float = OpTypeFloat 32 %float_0_200000003 = OpConstant %float 0.200000003 %v4float = OpTypeVector %float 4 %6 = OpConstantComposite %v4float %float_0_200000003 %float_0_200000003 %float_0_200000003 %float_0_200000003 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %type_buffer_image = OpTypeImage %float Buffer 2 0 0 2 Rgba32f %_ptr_UniformConstant_type_buffer_image = OpTypePointer UniformConstant %type_buffer_image %_ptr_Function_v4float = OpTypePointer Function %v4float %11 = OpTypeFunction %float %_ptr_Function_v4float %_ptr_Function_float = OpTypePointer Function %float %output = OpVariable %_ptr_UniformConstant_type_buffer_image UniformConstant %main = OpFunction %float None %11 %color = OpFunctionParameter %_ptr_Function_v4float %bb_entry = OpLabel %param_var_color = OpVariable %_ptr_Function_v4float Function %16 = OpLoad %v4float %color OpStore %param_var_color %16 %17 = OpFunctionCall %float %fn %param_var_color OpReturnValue %17 OpFunctionEnd %fn = OpFunction %float None %11 %color_0 = OpFunctionParameter %_ptr_Function_v4float %bb_entry_0 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %22 = OpLoad %v4float %color_0 OpStore %v %22 %23 = OpLoad %v4float %v %24 = OpFMul %v4float %23 %6 OpStore %v %24 %26 = OpAccessChain %_ptr_Function_float %v %int_0 %27 = OpLoad %float %26 OpReturnValue %27 OpFunctionEnd )"; const std::string after = R"(OpCapability SampledBuffer OpCapability ImageBuffer OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpSource HLSL 630 OpName %type_buffer_image "type.buffer.image" OpName %output "output" OpName %main "main" OpName %color "color" OpName %bb_entry "bb.entry" OpName %param_var_color "param.var.color" OpName %fn "fn" OpName %color_0 "color" OpName %bb_entry_0 "bb.entry" OpName %v "v" OpDecorate %main LinkageAttributes "main" Export OpDecorate %output DescriptorSet 0 OpDecorate %output Binding 1 %float = OpTypeFloat 32 %float_0_200000003 = OpConstant %float 0.200000003 %v4float = OpTypeVector %float 4 %6 = OpConstantComposite %v4float %float_0_200000003 %float_0_200000003 %float_0_200000003 %float_0_200000003 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %type_buffer_image = OpTypeImage %float Buffer 2 0 0 2 Rgba32f %_ptr_UniformConstant_type_buffer_image = OpTypePointer UniformConstant %type_buffer_image %_ptr_Function_v4float = OpTypePointer Function %v4float %11 = OpTypeFunction %float %_ptr_Function_v4float %_ptr_Function_float = OpTypePointer Function %float %output = OpVariable %_ptr_UniformConstant_type_buffer_image UniformConstant %main = OpFunction %float None %11 %color = OpFunctionParameter %_ptr_Function_v4float %bb_entry = OpLabel %28 = OpVariable %_ptr_Function_v4float Function %29 = OpVariable %_ptr_Function_float Function %param_var_color = OpVariable %_ptr_Function_v4float Function %16 = OpLoad %v4float %color OpStore %param_var_color %16 %31 = OpLoad %v4float %param_var_color OpStore %28 %31 %32 = OpLoad %v4float %28 %33 = OpFMul %v4float %32 %6 OpStore %28 %33 %34 = OpAccessChain %_ptr_Function_float %28 %int_0 %35 = OpLoad %float %34 OpStore %29 %35 %17 = OpLoad %float %29 OpReturnValue %17 OpFunctionEnd %fn = OpFunction %float None %11 %color_0 = OpFunctionParameter %_ptr_Function_v4float %bb_entry_0 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %22 = OpLoad %v4float %color_0 OpStore %v %22 %23 = OpLoad %v4float %v %24 = OpFMul %v4float %23 %6 OpStore %v %24 %26 = OpAccessChain %_ptr_Function_float %v %int_0 %27 = OpLoad %float %26 OpReturnValue %27 OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(before, after, false, true); } TEST_F(InlineTest, InlineFuncWithOpTerminateRayNotInContinue) { const std::string text = R"( OpCapability RayTracingKHR OpExtension "SPV_KHR_ray_tracing" OpMemoryModel Logical GLSL450 OpEntryPoint AnyHitKHR %MyAHitMain2 "MyAHitMain2" %a OpSource HLSL 630 OpName %a "a" OpName %MyAHitMain2 "MyAHitMain2" OpName %param_var_a "param.var.a" OpName %src_MyAHitMain2 "src.MyAHitMain2" OpName %a_0 "a" OpName %bb_entry "bb.entry" %int = OpTypeInt 32 1 %_ptr_IncomingRayPayloadKHR_int = OpTypePointer IncomingRayPayloadKHR %int %void = OpTypeVoid %6 = OpTypeFunction %void %_ptr_Function_int = OpTypePointer Function %int %14 = OpTypeFunction %void %_ptr_Function_int %a = OpVariable %_ptr_IncomingRayPayloadKHR_int IncomingRayPayloadKHR %MyAHitMain2 = OpFunction %void None %6 %7 = OpLabel %param_var_a = OpVariable %_ptr_Function_int Function %10 = OpLoad %int %a OpStore %param_var_a %10 %11 = OpFunctionCall %void %src_MyAHitMain2 %param_var_a %13 = OpLoad %int %param_var_a OpStore %a %13 OpReturn OpFunctionEnd %src_MyAHitMain2 = OpFunction %void None %14 %a_0 = OpFunctionParameter %_ptr_Function_int %bb_entry = OpLabel %17 = OpLoad %int %a_0 OpStore %a %17 OpTerminateRayKHR OpFunctionEnd ; CHECK: %MyAHitMain2 = OpFunction %void None ; CHECK-NEXT: OpLabel ; CHECK-NEXT: %param_var_a = OpVariable %_ptr_Function_int Function ; CHECK-NEXT: OpLoad %int %a ; CHECK-NEXT: OpStore %param_var_a {{%\d+}} ; CHECK-NEXT: OpLoad %int %param_var_a ; CHECK-NEXT: OpStore %a {{%\d+}} ; CHECK-NEXT: OpTerminateRayKHR ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpLoad %int %param_var_a ; CHECK-NEXT: OpStore %a %16 ; CHECK-NEXT: OpReturn ; CHECK-NEXT: OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(InlineTest, EarlyReturnFunctionInlined) { // #version 140 // // in vec4 BaseColor; // // float foo(vec4 bar) // { // if (bar.x < 0.0) // return 0.0; // return bar.x; // } // // void main() // { // vec4 color = vec4(foo(BaseColor)); // gl_FragColor = color; // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %foo_vf4_ "foo(vf4;" OpName %bar "bar" OpName %color "color" OpName %BaseColor "BaseColor" OpName %param "param" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %10 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %14 = OpTypeFunction %float %_ptr_Function_v4float %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %bool = OpTypeBool %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output )"; const std::string foo = R"(%foo_vf4_ = OpFunction %float None %14 %bar = OpFunctionParameter %_ptr_Function_v4float %27 = OpLabel %28 = OpAccessChain %_ptr_Function_float %bar %uint_0 %29 = OpLoad %float %28 %30 = OpFOrdLessThan %bool %29 %float_0 OpSelectionMerge %31 None OpBranchConditional %30 %32 %31 %32 = OpLabel OpReturnValue %float_0 %31 = OpLabel %33 = OpAccessChain %_ptr_Function_float %bar %uint_0 %34 = OpLoad %float %33 OpReturnValue %34 OpFunctionEnd )"; const std::string fooMergeReturn = R"(%foo_vf4_ = OpFunction %float None %14 %bar = OpFunctionParameter %_ptr_Function_v4float %27 = OpLabel %41 = OpVariable %_ptr_Function_bool Function %false %36 = OpVariable %_ptr_Function_float Function OpSelectionMerge %35 None OpSwitch %uint_0 %38 %38 = OpLabel %28 = OpAccessChain %_ptr_Function_float %bar %uint_0 %29 = OpLoad %float %28 %30 = OpFOrdLessThan %bool %29 %float_0 OpSelectionMerge %31 None OpBranchConditional %30 %32 %31 %32 = OpLabel OpStore %41 %true OpStore %36 %float_0 OpBranch %35 %31 = OpLabel %33 = OpAccessChain %_ptr_Function_float %bar %uint_0 %34 = OpLoad %float %33 OpStore %41 %true OpStore %36 %34 OpBranch %35 %35 = OpLabel %37 = OpLoad %float %36 OpReturnValue %37 OpFunctionEnd )"; const std::string before = R"(%main = OpFunction %void None %10 %22 = OpLabel %color = OpVariable %_ptr_Function_v4float Function %param = OpVariable %_ptr_Function_v4float Function %23 = OpLoad %v4float %BaseColor OpStore %param %23 %24 = OpFunctionCall %float %foo_vf4_ %param %25 = OpCompositeConstruct %v4float %24 %24 %24 %24 OpStore %color %25 %26 = OpLoad %v4float %color OpStore %gl_FragColor %26 OpReturn OpFunctionEnd )"; const std::string after = R"(%false = OpConstantFalse %bool %_ptr_Function_bool = OpTypePointer Function %bool %true = OpConstantTrue %bool %main = OpFunction %void None %10 %22 = OpLabel %43 = OpVariable %_ptr_Function_bool Function %false %44 = OpVariable %_ptr_Function_float Function %45 = OpVariable %_ptr_Function_float Function %color = OpVariable %_ptr_Function_v4float Function %param = OpVariable %_ptr_Function_v4float Function %23 = OpLoad %v4float %BaseColor OpStore %param %23 OpStore %43 %false OpSelectionMerge %55 None OpSwitch %uint_0 %47 %47 = OpLabel %48 = OpAccessChain %_ptr_Function_float %param %uint_0 %49 = OpLoad %float %48 %50 = OpFOrdLessThan %bool %49 %float_0 OpSelectionMerge %52 None OpBranchConditional %50 %51 %52 %51 = OpLabel OpStore %43 %true OpStore %44 %float_0 OpBranch %55 %52 = OpLabel %53 = OpAccessChain %_ptr_Function_float %param %uint_0 %54 = OpLoad %float %53 OpStore %43 %true OpStore %44 %54 OpBranch %55 %55 = OpLabel %56 = OpLoad %float %44 OpStore %45 %56 %24 = OpLoad %float %45 %25 = OpCompositeConstruct %v4float %24 %24 %24 %24 OpStore %color %25 %26 = OpLoad %v4float %color OpStore %gl_FragColor %26 OpReturn OpFunctionEnd )"; // The early return case must be handled by merge-return first. AddPass(); AddPass(); RunAndCheck(predefs + before + foo, predefs + after + fooMergeReturn); } TEST_F(InlineTest, EarlyReturnNotAppearingLastInFunctionInlined) { // Example from https://github.com/KhronosGroup/SPIRV-Tools/issues/755 // // Original example is derived from: // // #version 450 // // float foo() { // if (true) { // } // } // // void main() { foo(); } // // But the order of basic blocks in foo is changed so that the return // block is listed second-last. There is only one return in the callee // but it does not appear last. const std::string predefs = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpName %main "main" OpName %foo_ "foo(" %void = OpTypeVoid %4 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool )"; const std::string foo = R"(%foo_ = OpFunction %void None %4 %7 = OpLabel OpSelectionMerge %8 None OpBranchConditional %true %9 %8 %8 = OpLabel OpReturn %9 = OpLabel OpBranch %8 OpFunctionEnd )"; const std::string fooMergeReturn = R"(%uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %false = OpConstantFalse %bool %_ptr_Function_bool = OpTypePointer Function %bool %foo_ = OpFunction %void None %4 %7 = OpLabel %18 = OpVariable %_ptr_Function_bool Function %false OpSelectionMerge %12 None OpSwitch %uint_0 %13 %13 = OpLabel OpSelectionMerge %8 None OpBranchConditional %true %9 %8 %8 = OpLabel OpStore %18 %true OpBranch %12 %9 = OpLabel OpBranch %8 %12 = OpLabel OpReturn OpFunctionEnd )"; const std::string before = R"(%main = OpFunction %void None %4 %10 = OpLabel %11 = OpFunctionCall %void %foo_ OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %4 %10 = OpLabel %19 = OpVariable %_ptr_Function_bool Function %false OpStore %19 %false OpSelectionMerge %24 None OpSwitch %uint_0 %21 %21 = OpLabel OpSelectionMerge %22 None OpBranchConditional %true %23 %22 %22 = OpLabel OpStore %19 %true OpBranch %24 %23 = OpLabel OpBranch %22 %24 = OpLabel OpReturn OpFunctionEnd )"; // The early return case must be handled by merge-return first. AddPass(); AddPass(); RunAndCheck(predefs + foo + before, predefs + fooMergeReturn + after); } TEST_F(InlineTest, CalleeWithSingleReturnNeedsSingleTripLoopWrapper) { // The case from https://github.com/KhronosGroup/SPIRV-Tools/issues/2018 // // The callee has a single return, but needs single-trip loop wrapper // to be inlined because the return is in a selection structure. const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %_GLF_color OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %f_ "f(" OpName %i "i" OpName %_GLF_color "_GLF_color" OpDecorate %_GLF_color Location 0 %void = OpTypeVoid %7 = OpTypeFunction %void %float = OpTypeFloat 32 %9 = OpTypeFunction %float %float_1 = OpConstant %float 1 %bool = OpTypeBool %false = OpConstantFalse %bool %true = OpConstantTrue %bool %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %_GLF_color = OpVariable %_ptr_Output_v4float Output %float_0 = OpConstant %float 0 %21 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %22 = OpConstantComposite %v4float %float_0 %float_1 %float_0 %float_1 )"; const std::string new_predefs = R"(%_ptr_Function_float = OpTypePointer Function %float %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Function_bool = OpTypePointer Function %bool )"; const std::string main_before = R"(%main = OpFunction %void None %7 %23 = OpLabel %i = OpVariable %_ptr_Function_int Function OpStore %i %int_0 OpBranch %24 %24 = OpLabel OpLoopMerge %25 %26 None OpBranch %27 %27 = OpLabel %28 = OpLoad %int %i %29 = OpSLessThan %bool %28 %int_1 OpBranchConditional %29 %30 %25 %30 = OpLabel OpStore %_GLF_color %21 %31 = OpFunctionCall %float %f_ OpBranch %26 %26 = OpLabel %32 = OpLoad %int %i %33 = OpIAdd %int %32 %int_1 OpStore %i %33 OpBranch %24 %25 = OpLabel OpStore %_GLF_color %22 OpReturn OpFunctionEnd )"; const std::string main_after = R"(%main = OpFunction %void None %7 %23 = OpLabel %46 = OpVariable %_ptr_Function_bool Function %false %47 = OpVariable %_ptr_Function_float Function %48 = OpVariable %_ptr_Function_float Function %i = OpVariable %_ptr_Function_int Function OpStore %i %int_0 OpBranch %24 %24 = OpLabel OpLoopMerge %25 %26 None OpBranch %27 %27 = OpLabel %28 = OpLoad %int %i %29 = OpSLessThan %bool %28 %int_1 OpBranchConditional %29 %30 %25 %30 = OpLabel OpStore %_GLF_color %21 OpStore %46 %false OpSelectionMerge %53 None OpSwitch %uint_0 %50 %50 = OpLabel OpSelectionMerge %52 None OpBranchConditional %true %51 %52 %51 = OpLabel OpStore %46 %true OpStore %47 %float_1 OpBranch %53 %52 = OpLabel OpStore %46 %true OpStore %47 %float_1 OpBranch %53 %53 = OpLabel %54 = OpLoad %float %47 OpStore %48 %54 %31 = OpLoad %float %48 OpBranch %26 %26 = OpLabel %32 = OpLoad %int %i %33 = OpIAdd %int %32 %int_1 OpStore %i %33 OpBranch %24 %25 = OpLabel OpStore %_GLF_color %22 OpReturn OpFunctionEnd )"; const std::string callee = R"(%f_ = OpFunction %float None %9 %34 = OpLabel OpSelectionMerge %35 None OpBranchConditional %true %36 %35 %36 = OpLabel OpReturnValue %float_1 %35 = OpLabel OpReturnValue %float_1 OpFunctionEnd )"; const std::string calleeMergeReturn = R"(%f_ = OpFunction %float None %9 %34 = OpLabel %45 = OpVariable %_ptr_Function_bool Function %false %39 = OpVariable %_ptr_Function_float Function OpSelectionMerge %37 None OpSwitch %uint_0 %41 %41 = OpLabel OpSelectionMerge %35 None OpBranchConditional %true %36 %35 %36 = OpLabel OpStore %45 %true OpStore %39 %float_1 OpBranch %37 %35 = OpLabel OpStore %45 %true OpStore %39 %float_1 OpBranch %37 %37 = OpLabel %40 = OpLoad %float %39 OpReturnValue %40 OpFunctionEnd )"; // The early return case must be handled by merge-return first. AddPass(); AddPass(); RunAndCheck(predefs + main_before + callee, predefs + new_predefs + main_after + calleeMergeReturn); } TEST_F(InlineTest, ForwardReferencesInPhiInlined) { // The basic structure of the test case is like this: // // int foo() { // int result = 1; // if (true) { // result = 1; // } // return result; // } // // void main() { // int x = foo(); // } // // but with modifications: Using Phi instead of load/store, and the // return block in foo appears before the "then" block. const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpName %main "main" OpName %foo_ "foo(" OpName %x "x" %void = OpTypeVoid %6 = OpTypeFunction %void %int = OpTypeInt 32 1 %8 = OpTypeFunction %int %bool = OpTypeBool %true = OpConstantTrue %bool %int_0 = OpConstant %int 0 %_ptr_Function_int = OpTypePointer Function %int )"; const std::string callee = R"(%foo_ = OpFunction %int None %8 %13 = OpLabel %14 = OpCopyObject %int %int_0 OpSelectionMerge %15 None OpBranchConditional %true %16 %15 %15 = OpLabel %17 = OpPhi %int %14 %13 %18 %16 OpReturnValue %17 %16 = OpLabel %18 = OpCopyObject %int %int_0 OpBranch %15 OpFunctionEnd )"; const std::string calleeMergeReturn = R"(%uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %false = OpConstantFalse %bool %_ptr_Function_bool = OpTypePointer Function %bool %foo_ = OpFunction %int None %8 %13 = OpLabel %29 = OpVariable %_ptr_Function_bool Function %false %22 = OpVariable %_ptr_Function_int Function OpSelectionMerge %21 None OpSwitch %uint_0 %24 %24 = OpLabel %14 = OpCopyObject %int %int_0 OpSelectionMerge %15 None OpBranchConditional %true %16 %15 %15 = OpLabel %17 = OpPhi %int %14 %24 %18 %16 OpStore %29 %true OpStore %22 %17 OpBranch %21 %16 = OpLabel %18 = OpCopyObject %int %int_0 OpBranch %15 %21 = OpLabel %23 = OpLoad %int %22 OpReturnValue %23 OpFunctionEnd )"; const std::string before = R"(%main = OpFunction %void None %6 %19 = OpLabel %x = OpVariable %_ptr_Function_int Function %20 = OpFunctionCall %int %foo_ OpStore %x %20 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %6 %19 = OpLabel %30 = OpVariable %_ptr_Function_bool Function %false %31 = OpVariable %_ptr_Function_int Function %32 = OpVariable %_ptr_Function_int Function %x = OpVariable %_ptr_Function_int Function OpStore %30 %false OpSelectionMerge %40 None OpSwitch %uint_0 %34 %34 = OpLabel %35 = OpCopyObject %int %int_0 OpSelectionMerge %36 None OpBranchConditional %true %38 %36 %36 = OpLabel %37 = OpPhi %int %35 %34 %39 %38 OpStore %30 %true OpStore %31 %37 OpBranch %40 %38 = OpLabel %39 = OpCopyObject %int %int_0 OpBranch %36 %40 = OpLabel %41 = OpLoad %int %31 OpStore %32 %41 %20 = OpLoad %int %32 OpStore %x %20 OpReturn OpFunctionEnd )"; AddPass(); AddPass(); RunAndCheck(predefs + callee + before, predefs + calleeMergeReturn + after); } TEST_F(InlineTest, DebugSimple) { // Check that it correctly generates DebugInlinedAt and maps it to DebugScope // for the inlined function foo(). const std::string text = R"( ; CHECK: [[main_name:%\d+]] = OpString "main" ; CHECK: [[foo_name:%\d+]] = OpString "foo" ; CHECK: [[dbg_main:%\d+]] = OpExtInst %void {{%\d+}} DebugFunction [[main_name]] {{%\d+}} {{%\d+}} 4 1 {{%\d+}} [[main_name]] FlagIsProtected|FlagIsPrivate 4 [[main:%\d+]] ; CHECK: [[dbg_foo:%\d+]] = OpExtInst %void {{%\d+}} DebugFunction [[foo_name]] {{%\d+}} {{%\d+}} 1 1 {{%\d+}} [[foo_name]] FlagIsProtected|FlagIsPrivate 1 [[foo:%\d+]] ; CHECK: [[foo_bb:%\d+]] = OpExtInst %void {{%\d+}} DebugLexicalBlock {{%\d+}} 1 14 [[dbg_foo]] ; CHECK: [[inlined_at:%\d+]] = OpExtInst %void {{%\d+}} DebugInlinedAt 4 [[dbg_main]] ; CHECK: [[main]] = OpFunction %void None ; CHECK: {{%\d+}} = OpExtInst %void {{%\d+}} DebugScope [[foo_bb]] [[inlined_at]] ; CHECK: [[foo]] = OpFunction %v4float None OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %3 %4 OpExecutionMode %main OriginUpperLeft %5 = OpString "ps.hlsl" OpSource HLSL 600 %5 %6 = OpString "float" %main_name = OpString "main" %foo_name = OpString "foo" OpDecorate %3 Location 0 OpDecorate %4 Location 0 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %float = OpTypeFloat 32 %float_1 = OpConstant %float 1 %v4float = OpTypeVector %float 4 %14 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %18 = OpTypeFunction %void %19 = OpTypeFunction %v4float %3 = OpVariable %_ptr_Input_v4float Input %4 = OpVariable %_ptr_Output_v4float Output %20 = OpExtInst %void %1 DebugSource %5 %21 = OpExtInst %void %1 DebugCompilationUnit 1 4 %20 HLSL %22 = OpExtInst %void %1 DebugTypeBasic %6 %uint_32 Float %23 = OpExtInst %void %1 DebugTypeVector %22 4 %24 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %23 %23 %25 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %23 %dbg_main = OpExtInst %void %1 DebugFunction %main_name %24 %20 4 1 %21 %main_name FlagIsProtected|FlagIsPrivate 4 %main %dbg_foo = OpExtInst %void %1 DebugFunction %foo_name %25 %20 1 1 %21 %foo_name FlagIsProtected|FlagIsPrivate 1 %foo %29 = OpExtInst %void %1 DebugLexicalBlock %20 1 14 %dbg_foo %main = OpFunction %void None %18 %30 = OpLabel %31 = OpExtInst %void %1 DebugScope %dbg_main %32 = OpFunctionCall %v4float %foo %33 = OpLoad %v4float %3 %34 = OpFAdd %v4float %32 %33 OpStore %4 %34 OpReturn OpFunctionEnd %foo = OpFunction %v4float None %19 %35 = OpExtInst %void %1 DebugScope %dbg_foo %36 = OpLabel %37 = OpExtInst %void %1 DebugScope %29 OpReturnValue %14 OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(InlineTest, ShaderDebugSimple) { // Same as DebugSimple but for NonSemantic.Shader.DebugInfo.100. const std::string text = R"( ; CHECK: [[main_name:%\d+]] = OpString "main" ; CHECK: [[foo_name:%\d+]] = OpString "foo" ; CHECK: [[dbg_main:%\d+]] = OpExtInst %void {{%\d+}} DebugFunction [[main_name]] {{%\d+}} {{%\d+}} %uint_4 %uint_1 {{%\d+}} [[main_name]] %uint_3 %uint_4 ; CHECK: [[dbg_foo:%\d+]] = OpExtInst %void {{%\d+}} DebugFunction [[foo_name]] {{%\d+}} {{%\d+}} %uint_1 %uint_1 {{%\d+}} [[foo_name]] %uint_3 %uint_1 ; CHECK: [[foo_bb:%\d+]] = OpExtInst %void {{%\d+}} DebugLexicalBlock {{%\d+}} %uint_1 %uint_14 [[dbg_foo]] ; CHECK: [[inlined_at:%\d+]] = OpExtInst %void {{%\d+}} DebugInlinedAt %uint_4 [[dbg_main]] ; CHECK: [[main:%\d+]] = OpFunction %void None ; CHECK: {{%\d+}} = OpExtInst %void {{%\d+}} DebugScope [[foo_bb]] [[inlined_at]] ; CHECK: [[foo:%\d+]] = OpFunction %v4float None OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %1 = OpExtInstImport "NonSemantic.Shader.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %3 %4 OpExecutionMode %main OriginUpperLeft %5 = OpString "ps.hlsl" OpSource HLSL 600 %5 %6 = OpString "float" %main_name = OpString "main" %foo_name = OpString "foo" OpDecorate %3 Location 0 OpDecorate %4 Location 0 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %uint_3 = OpConstant %uint 3 %uint_4 = OpConstant %uint 4 %uint_5 = OpConstant %uint 5 %uint_14 = OpConstant %uint 14 %uint_32 = OpConstant %uint 32 %float = OpTypeFloat 32 %float_1 = OpConstant %float 1 %v4float = OpTypeVector %float 4 %14 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %18 = OpTypeFunction %void %19 = OpTypeFunction %v4float %3 = OpVariable %_ptr_Input_v4float Input %4 = OpVariable %_ptr_Output_v4float Output %20 = OpExtInst %void %1 DebugSource %5 %21 = OpExtInst %void %1 DebugCompilationUnit %uint_1 %uint_4 %20 %uint_5 %22 = OpExtInst %void %1 DebugTypeBasic %6 %uint_32 %uint_3 %uint_0 %23 = OpExtInst %void %1 DebugTypeVector %22 %uint_4 %24 = OpExtInst %void %1 DebugTypeFunction %uint_3 %23 %23 %25 = OpExtInst %void %1 DebugTypeFunction %uint_3 %23 %dbg_main = OpExtInst %void %1 DebugFunction %main_name %24 %20 %uint_4 %uint_1 %21 %main_name %uint_3 %uint_4 %dbg_foo = OpExtInst %void %1 DebugFunction %foo_name %25 %20 %uint_1 %uint_1 %21 %foo_name %uint_3 %uint_1 %29 = OpExtInst %void %1 DebugLexicalBlock %20 %uint_1 %uint_14 %dbg_foo %main = OpFunction %void None %18 %30 = OpLabel %dbg_main_def = OpExtInst %void %1 DebugFunctionDefinition %dbg_main %main %31 = OpExtInst %void %1 DebugScope %dbg_main %32 = OpFunctionCall %v4float %foo %33 = OpLoad %v4float %3 %34 = OpFAdd %v4float %32 %33 OpStore %4 %34 OpReturn OpFunctionEnd %foo = OpFunction %v4float None %19 %36 = OpLabel %dbg_foo_def = OpExtInst %void %1 DebugFunctionDefinition %dbg_foo %foo %35 = OpExtInst %void %1 DebugScope %dbg_foo %37 = OpExtInst %void %1 DebugScope %29 OpReturnValue %14 OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(InlineTest, DebugNested) { // When function main() calls function zoo() and function zoo() calls // function bar() and function bar() calls function foo(), check that // the inline pass correctly generates DebugInlinedAt instructions // for the nested function calls. const std::string text = R"( ; CHECK: [[v4f1:%\d+]] = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 ; CHECK: [[v4f2:%\d+]] = OpConstantComposite %v4float %float_2 %float_2 %float_2 %float_2 ; CHECK: [[v4f3:%\d+]] = OpConstantComposite %v4float %float_3 %float_3 %float_3 %float_3 ; CHECK: [[color:%\d+]] = OpVariable %_ptr_Input_v4float Input ; CHECK: [[dbg_main:%\d+]] = OpExtInst %void [[ext:%\d+]] DebugFunction {{%\d+}} {{%\d+}} {{%\d+}} 10 1 {{%\d+}} {{%\d+}} FlagIsProtected|FlagIsPrivate 10 [[main:%\d+]] ; CHECK: [[dbg_foo:%\d+]] = OpExtInst %void [[ext]] DebugFunction {{%\d+}} {{%\d+}} {{%\d+}} 1 1 {{%\d+}} {{%\d+}} FlagIsProtected|FlagIsPrivate 1 [[foo:%\d+]] ; CHECK: [[dbg_bar:%\d+]] = OpExtInst %void [[ext]] DebugFunction {{%\d+}} {{%\d+}} {{%\d+}} 4 1 {{%\d+}} {{%\d+}} FlagIsProtected|FlagIsPrivate 4 [[bar:%\d+]] ; CHECK: [[dbg_zoo:%\d+]] = OpExtInst %void [[ext]] DebugFunction {{%\d+}} {{%\d+}} {{%\d+}} 7 1 {{%\d+}} {{%\d+}} FlagIsProtected|FlagIsPrivate 7 [[zoo:%\d+]] ; CHECK: [[inlined_to_main:%\d+]] = OpExtInst %void [[ext]] DebugInlinedAt 600 [[dbg_main]] ; CHECK: [[inlined_to_zoo:%\d+]] = OpExtInst %void [[ext]] DebugInlinedAt 700 [[dbg_zoo]] [[inlined_to_main]] ; CHECK: [[inlined_to_bar:%\d+]] = OpExtInst %void [[ext]] DebugInlinedAt 300 [[dbg_bar]] [[inlined_to_zoo]] ; CHECK: [[main]] = OpFunction %void None ; CHECK: {{%\d+}} = OpExtInst %void [[ext]] DebugScope [[dbg_foo]] [[inlined_to_bar]] ; CHECK-NEXT: OpLine {{%\d+}} 100 0 ; CHECK-NEXT: OpStore {{%\d+}} [[v4f1]] ; CHECK: {{%\d+}} = OpExtInst %void [[ext]] DebugScope [[dbg_bar]] [[inlined_to_zoo]] ; CHECK-NEXT: OpLine {{%\d+}} 300 0 ; CHECK-NEXT: [[foo_ret:%\d+]] = OpLoad %v4float ; CHECK-NEXT: OpLine {{%\d+}} 400 0 ; CHECK-NEXT: {{%\d+}} = OpFAdd %v4float [[foo_ret]] [[v4f2]] ; CHECK: {{%\d+}} = OpExtInst %void [[ext]] DebugScope [[dbg_zoo]] [[inlined_to_main]] ; CHECK-NEXT: OpLine {{%\d+}} 700 0 ; CHECK-NEXT: [[bar_ret:%\d+]] = OpLoad %v4float ; CHECK-NEXT: {{%\d+}} = OpFAdd %v4float [[bar_ret]] [[v4f3]] ; CHECK: {{%\d+}} = OpExtInst %void [[ext]] DebugScope [[dbg_main]] ; CHECK-NEXT: OpLine {{%\d+}} 600 0 ; CHECK-NEXT: [[zoo_ret:%\d+]] = OpLoad %v4float ; CHECK-NEXT: [[color_val:%\d+]] = OpLoad %v4float [[color]] ; CHECK-NEXT: {{%\d+}} = OpFAdd %v4float [[zoo_ret]] [[color_val]] ; CHECK: [[foo]] = OpFunction %v4float None ; CHECK: [[bar]] = OpFunction %v4float None ; CHECK: [[zoo]] = OpFunction %v4float None OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %3 %4 OpExecutionMode %main OriginUpperLeft %5 = OpString "ps.hlsl" OpSource HLSL 600 %5 %6 = OpString "float" %7 = OpString "main" %8 = OpString "foo" %9 = OpString "bar" %10 = OpString "zoo" OpDecorate %3 Location 0 OpDecorate %4 Location 0 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %float = OpTypeFloat 32 %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %float_3 = OpConstant %float 3 %v4float = OpTypeVector %float 4 %18 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %19 = OpConstantComposite %v4float %float_2 %float_2 %float_2 %float_2 %20 = OpConstantComposite %v4float %float_3 %float_3 %float_3 %float_3 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %24 = OpTypeFunction %void %25 = OpTypeFunction %v4float %3 = OpVariable %_ptr_Input_v4float Input %4 = OpVariable %_ptr_Output_v4float Output %26 = OpExtInst %void %1 DebugSource %5 %27 = OpExtInst %void %1 DebugCompilationUnit 1 4 %26 HLSL %28 = OpExtInst %void %1 DebugTypeBasic %6 %uint_32 Float %29 = OpExtInst %void %1 DebugTypeVector %28 4 %30 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %29 %29 %31 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %29 %32 = OpExtInst %void %1 DebugFunction %7 %30 %26 10 1 %27 %7 FlagIsProtected|FlagIsPrivate 10 %main %33 = OpExtInst %void %1 DebugFunction %8 %31 %26 1 1 %27 %8 FlagIsProtected|FlagIsPrivate 1 %foo %35 = OpExtInst %void %1 DebugFunction %9 %31 %26 4 1 %27 %9 FlagIsProtected|FlagIsPrivate 4 %bar %37 = OpExtInst %void %1 DebugFunction %10 %31 %26 7 1 %27 %10 FlagIsProtected|FlagIsPrivate 7 %zoo %main = OpFunction %void None %24 %39 = OpLabel %40 = OpExtInst %void %1 DebugScope %32 OpLine %5 600 0 %41 = OpFunctionCall %v4float %zoo %42 = OpLoad %v4float %3 %43 = OpFAdd %v4float %41 %42 OpStore %4 %43 OpReturn OpFunctionEnd %foo = OpFunction %v4float None %25 %44 = OpExtInst %void %1 DebugScope %33 %45 = OpLabel OpLine %5 100 0 OpReturnValue %18 OpFunctionEnd OpLine %5 200 0 %bar = OpFunction %v4float None %25 %46 = OpExtInst %void %1 DebugScope %35 %47 = OpLabel OpLine %5 300 0 %48 = OpFunctionCall %v4float %foo OpLine %5 400 0 %49 = OpFAdd %v4float %48 %19 OpLine %5 500 0 OpReturnValue %49 OpFunctionEnd %zoo = OpFunction %v4float None %25 %50 = OpExtInst %void %1 DebugScope %37 %51 = OpLabel OpLine %5 700 0 %52 = OpFunctionCall %v4float %bar %53 = OpFAdd %v4float %52 %20 OpReturnValue %53 OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(InlineTest, DebugSimpleHLSLPixelShader) { const std::string text = R"( ; CHECK: [[dbg_main:%\d+]] = OpExtInst %void [[ext:%\d+]] DebugFunction {{%\d+}} {{%\d+}} {{%\d+}} 1 1 {{%\d+}} {{%\d+}} FlagIsProtected|FlagIsPrivate 1 %src_main ; CHECK: [[lex_blk:%\d+]] = OpExtInst %void [[ext]] DebugLexicalBlock {{%\d+}} 1 47 [[dbg_main]] ; CHECK: %main = OpFunction %void None ; CHECK: {{%\d+}} = OpExtInst %void [[ext]] DebugScope [[dbg_main]] ; CHECK: {{%\d+}} = OpExtInst %void [[ext]] DebugDeclare {{%\d+}} %param_var_color ; CHECK: {{%\d+}} = OpExtInst %void [[ext]] DebugScope [[lex_blk]] ; CHECK: OpLine {{%\d+}} 2 10 ; CHECK: {{%\d+}} = OpLoad %v4float %param_var_color ; CHECK: OpLine {{%\d+}} 2 3 ; CHECK: OpFunctionEnd ; CHECK: %src_main = OpFunction %v4float None OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_COLOR %out_var_SV_TARGET OpExecutionMode %main OriginUpperLeft %5 = OpString "ps.hlsl" OpSource HLSL 600 %5 %14 = OpString "#line 1 \"ps.hlsl\" float4 main(float4 color : COLOR) : SV_TARGET { return color; } " %17 = OpString "float" %21 = OpString "src.main" %24 = OpString "color" OpName %in_var_COLOR "in.var.COLOR" OpName %out_var_SV_TARGET "out.var.SV_TARGET" OpName %main "main" OpName %param_var_color "param.var.color" OpName %src_main "src.main" OpName %color "color" OpName %bb_entry "bb.entry" OpDecorate %in_var_COLOR Location 0 OpDecorate %out_var_SV_TARGET Location 0 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %27 = OpTypeFunction %void %_ptr_Function_v4float = OpTypePointer Function %v4float %33 = OpTypeFunction %v4float %_ptr_Function_v4float %in_var_COLOR = OpVariable %_ptr_Input_v4float Input %out_var_SV_TARGET = OpVariable %_ptr_Output_v4float Output %13 = OpExtInst %void %1 DebugExpression %15 = OpExtInst %void %1 DebugSource %5 %14 %16 = OpExtInst %void %1 DebugCompilationUnit 1 4 %15 HLSL %18 = OpExtInst %void %1 DebugTypeBasic %17 %uint_32 Float %19 = OpExtInst %void %1 DebugTypeVector %18 4 %20 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %19 %19 %22 = OpExtInst %void %1 DebugFunction %21 %20 %15 1 1 %16 %21 FlagIsProtected|FlagIsPrivate 1 %src_main %25 = OpExtInst %void %1 DebugLocalVariable %24 %19 %15 1 20 %22 FlagIsLocal 0 %26 = OpExtInst %void %1 DebugLexicalBlock %15 1 47 %22 %main = OpFunction %void None %27 %28 = OpLabel %param_var_color = OpVariable %_ptr_Function_v4float Function %31 = OpLoad %v4float %in_var_COLOR OpStore %param_var_color %31 %32 = OpFunctionCall %v4float %src_main %param_var_color OpStore %out_var_SV_TARGET %32 OpReturn OpFunctionEnd OpLine %5 1 1 %src_main = OpFunction %v4float None %33 %34 = OpExtInst %void %1 DebugScope %22 %color = OpFunctionParameter %_ptr_Function_v4float %36 = OpExtInst %void %1 DebugDeclare %25 %color %13 %bb_entry = OpLabel %38 = OpExtInst %void %1 DebugScope %26 OpLine %5 2 10 %39 = OpLoad %v4float %color OpLine %5 2 3 OpReturnValue %39 OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(InlineTest, ShaderDebugSimpleHLSLPixelShader) { // Same as DebugSimpleHLSLPixelShader but for // NonSemantic.Shader.DebugInfo.100. const std::string text = R"( ; CHECK: [[dbg_main:%\d+]] = OpExtInst %void [[ext:%\d+]] DebugFunction {{%\d+}} {{%\d+}} {{%\d+}} %uint_1 %uint_1 {{%\d+}} {{%\d+}} %uint_3 %uint_1 ; CHECK: [[lex_blk:%\d+]] = OpExtInst %void [[ext]] DebugLexicalBlock {{%\d+}} %uint_1 %uint_47 [[dbg_main]] ; CHECK: %main = OpFunction %void None ; CHECK: {{%\d+}} = OpExtInst %void [[ext]] DebugScope [[dbg_main]] ; CHECK: {{%\d+}} = OpExtInst %void [[ext]] DebugDeclare {{%\d+}} %param_var_color ; CHECK: {{%\d+}} = OpExtInst %void [[ext]] DebugScope [[lex_blk]] ; CHECK: {{%\d+}} = OpExtInst %void %1 DebugLine {{%\d+}} %uint_2 %uint_2 %uint_10 %uint_10 ; CHECK: {{%\d+}} = OpLoad %v4float %param_var_color ; CHECK: {{%\d+}} = OpExtInst %void %1 DebugLine {{%\d+}} %uint_2 %uint_2 %uint_3 %uint_3 ; CHECK: OpFunctionEnd ; CHECK: %src_main = OpFunction %v4float None OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %1 = OpExtInstImport "NonSemantic.Shader.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_COLOR %out_var_SV_TARGET OpExecutionMode %main OriginUpperLeft %5 = OpString "ps.hlsl" OpSource HLSL 600 %5 %14 = OpString "#line 1 \"ps.hlsl\" float4 main(float4 color : COLOR) : SV_TARGET { return color; } " %17 = OpString "float" %21 = OpString "src.main" %24 = OpString "color" OpName %in_var_COLOR "in.var.COLOR" OpName %out_var_SV_TARGET "out.var.SV_TARGET" OpName %main "main" OpName %param_var_color "param.var.color" OpName %src_main "src.main" OpName %color "color" OpName %bb_entry "bb.entry" OpDecorate %in_var_COLOR Location 0 OpDecorate %out_var_SV_TARGET Location 0 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %uint_3 = OpConstant %uint 3 %uint_4 = OpConstant %uint 4 %uint_5 = OpConstant %uint 5 %uint_10 = OpConstant %uint 10 %uint_20 = OpConstant %uint 20 %uint_32 = OpConstant %uint 32 %uint_47 = OpConstant %uint 47 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %27 = OpTypeFunction %void %_ptr_Function_v4float = OpTypePointer Function %v4float %33 = OpTypeFunction %v4float %_ptr_Function_v4float %in_var_COLOR = OpVariable %_ptr_Input_v4float Input %out_var_SV_TARGET = OpVariable %_ptr_Output_v4float Output %13 = OpExtInst %void %1 DebugExpression %15 = OpExtInst %void %1 DebugSource %5 %14 %16 = OpExtInst %void %1 DebugCompilationUnit %uint_1 %uint_4 %15 %uint_5 %18 = OpExtInst %void %1 DebugTypeBasic %17 %uint_32 %uint_3 %uint_0 %19 = OpExtInst %void %1 DebugTypeVector %18 %uint_4 %20 = OpExtInst %void %1 DebugTypeFunction %uint_3 %19 %19 %22 = OpExtInst %void %1 DebugFunction %21 %20 %15 %uint_1 %uint_1 %16 %21 %uint_3 %uint_1 %25 = OpExtInst %void %1 DebugLocalVariable %24 %19 %15 %uint_1 %uint_20 %22 %uint_4 %uint_0 %26 = OpExtInst %void %1 DebugLexicalBlock %15 %uint_1 %uint_47 %22 %main = OpFunction %void None %27 %28 = OpLabel %param_var_color = OpVariable %_ptr_Function_v4float Function %31 = OpLoad %v4float %in_var_COLOR OpStore %param_var_color %31 %32 = OpFunctionCall %v4float %src_main %param_var_color OpStore %out_var_SV_TARGET %32 OpReturn OpFunctionEnd %src_main = OpFunction %v4float None %33 %color = OpFunctionParameter %_ptr_Function_v4float %bb_entry = OpLabel %140 = OpExtInst %void %1 DebugFunctionDefinition %22 %src_main %141 = OpExtInst %void %1 DebugLine %15 %uint_1 %uint_1 %uint_1 %uint_1 %34 = OpExtInst %void %1 DebugScope %22 %36 = OpExtInst %void %1 DebugDeclare %25 %color %13 %38 = OpExtInst %void %1 DebugScope %26 %142 = OpExtInst %void %1 DebugLine %15 %uint_2 %uint_2 %uint_10 %uint_10 %39 = OpLoad %v4float %color %143 = OpExtInst %void %1 DebugLine %15 %uint_2 %uint_2 %uint_3 %uint_3 OpReturnValue %39 OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(InlineTest, DebugDeclareForCalleeFunctionParam) { // Check that InlinePass correctly generates DebugDeclare instructions // for callee function's parameters and maps them to corresponding // local variables of caller function. const std::string text = R"( ; CHECK: [[add:%\d+]] = OpString "add" ; CHECK: [[a:%\d+]] = OpString "a" ; CHECK: [[b:%\d+]] = OpString "b" ; CHECK: [[dbg_add:%\d+]] = OpExtInst %void [[ext:%\d+]] DebugFunction [[add]] ; CHECK: [[dbg_a:%\d+]] = OpExtInst %void [[ext]] DebugLocalVariable [[a]] ; CHECK: [[dbg_b:%\d+]] = OpExtInst %void [[ext]] DebugLocalVariable [[b]] ; CHECK: [[inlinedat:%\d+]] = OpExtInst %void [[ext]] DebugInlinedAt 5 ; CHECK: OpStore [[param_a:%\d+]] ; CHECK: OpStore [[param_b:%\d+]] ; CHECK: {{%\d+}} = OpExtInst %void [[ext]] DebugScope [[dbg_add]] [[inlinedat]] ; CHECK: {{%\d+}} = OpExtInst %void [[ext]] DebugDeclare [[dbg_a]] [[param_a]] ; CHECK: {{%\d+}} = OpExtInst %void [[ext]] DebugDeclare [[dbg_b]] [[param_b]] OpCapability Shader %ext = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_COLOR %out_var_SV_TARGET OpExecutionMode %main OriginUpperLeft %file_name = OpString "ps.hlsl" OpSource HLSL 600 %file_name %float_name = OpString "float" %main_name = OpString "main" %add_name = OpString "add" %a_name = OpString "a" %b_name = OpString "b" OpDecorate %in_var_COLOR Location 0 OpDecorate %out_var_SV_TARGET Location 0 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %float = OpTypeFloat 32 %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %v4float = OpTypeVector %float 4 %v4f1 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %v4f2 = OpConstantComposite %v4float %float_2 %float_2 %float_2 %float_2 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %_ptr_Function_v4float = OpTypePointer Function %v4float %add_fn_type = OpTypeFunction %v4float %_ptr_Function_v4float %_ptr_Function_v4float %void = OpTypeVoid %void_fn_type = OpTypeFunction %void %v4f_fn_type = OpTypeFunction %v4float %in_var_COLOR = OpVariable %_ptr_Input_v4float Input %out_var_SV_TARGET = OpVariable %_ptr_Output_v4float Output %null_expr = OpExtInst %void %ext DebugExpression %src = OpExtInst %void %ext DebugSource %file_name %cu = OpExtInst %void %ext DebugCompilationUnit 1 4 %src HLSL %dbg_f = OpExtInst %void %ext DebugTypeBasic %float_name %uint_32 Float %dbg_v4f = OpExtInst %void %ext DebugTypeVector %dbg_f 4 %main_ty = OpExtInst %void %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %dbg_v4f %dbg_v4f %add_ty = OpExtInst %void %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %dbg_v4f %dbg_v4f %dbg_v4f %dbg_main = OpExtInst %void %ext DebugFunction %main_name %main_ty %src 5 1 %cu %main_name FlagIsProtected|FlagIsPrivate 10 %main %dbg_add = OpExtInst %void %ext DebugFunction %add_name %add_ty %src 1 1 %cu %add_name FlagIsProtected|FlagIsPrivate 1 %add %dbg_a = OpExtInst %void %ext DebugLocalVariable %a_name %dbg_v4f %src 1 13 %dbg_add FlagIsLocal 0 %dbg_b = OpExtInst %void %ext DebugLocalVariable %b_name %dbg_v4f %src 1 20 %dbg_add FlagIsLocal 1 %add_lb = OpExtInst %void %ext DebugLexicalBlock %src 1 23 %dbg_add %main = OpFunction %void None %void_fn_type %main_bb = OpLabel %param_a = OpVariable %_ptr_Function_v4float Function %param_b = OpVariable %_ptr_Function_v4float Function %scope0 = OpExtInst %void %ext DebugScope %dbg_main OpStore %param_a %v4f1 OpStore %param_b %v4f2 %result = OpFunctionCall %v4float %add %param_a %param_b OpStore %out_var_SV_TARGET %result OpReturn OpFunctionEnd %add = OpFunction %v4float None %add_fn_type %scope1 = OpExtInst %void %ext DebugScope %dbg_add %a = OpFunctionParameter %_ptr_Function_v4float %b = OpFunctionParameter %_ptr_Function_v4float %decl0 = OpExtInst %void %ext DebugDeclare %dbg_a %a %null_expr %decl1 = OpExtInst %void %ext DebugDeclare %dbg_b %b %null_expr %add_bb = OpLabel %scope2 = OpExtInst %void %ext DebugScope %add_lb %a_val = OpLoad %v4float %a %b_val = OpLoad %v4float %b %res = OpFAdd %v4float %a_val %b_val OpReturnValue %res OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(InlineTest, DebugDeclareForCalleeLocalVar) { // Check that InlinePass correctly generates DebugDeclare instructions // for callee function's local variables and maps them to corresponding // local variables of caller function. const std::string text = R"( ; CHECK: [[add:%\d+]] = OpString "add" ; CHECK: [[foo:%\d+]] = OpString "foo" ; CHECK: [[dbg_add:%\d+]] = OpExtInst %void [[ext:%\d+]] DebugFunction [[add]] ; CHECK: [[dbg_foo:%\d+]] = OpExtInst %void [[ext]] DebugLocalVariable [[foo]] {{%\d+}} {{%\d+}} 2 2 [[dbg_add]] ; CHECK: [[inlinedat:%\d+]] = OpExtInst %void [[ext]] DebugInlinedAt 5 ; CHECK: {{%\d+}} = OpExtInst %void [[ext]] DebugScope [[dbg_add]] [[inlinedat]] ; CHECK: [[new_foo:%\d+]] = OpVariable %_ptr_Function_v4float Function ; CHECK: {{%\d+}} = OpExtInst %void [[ext]] DebugScope [[dbg_add]] [[inlinedat]] ; CHECK: [[a_val:%\d+]] = OpLoad %v4float ; CHECK: [[b_val:%\d+]] = OpLoad %v4float ; CHECK: [[res:%\d+]] = OpFAdd %v4float [[a_val]] [[b_val]] ; CHECK: OpStore [[new_foo]] [[res]] ; CHECK: {{%\d+}} = OpExtInst %void [[ext]] DebugDeclare [[dbg_foo]] [[new_foo]] OpCapability Shader %ext = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_COLOR %out_var_SV_TARGET OpExecutionMode %main OriginUpperLeft %file_name = OpString "ps.hlsl" OpSource HLSL 600 %file_name %float_name = OpString "float" %main_name = OpString "main" %add_name = OpString "add" %foo_name = OpString "foo" OpDecorate %in_var_COLOR Location 0 OpDecorate %out_var_SV_TARGET Location 0 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %float = OpTypeFloat 32 %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %v4float = OpTypeVector %float 4 %v4f1 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %v4f2 = OpConstantComposite %v4float %float_2 %float_2 %float_2 %float_2 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %_ptr_Function_v4float = OpTypePointer Function %v4float %add_fn_type = OpTypeFunction %v4float %_ptr_Function_v4float %_ptr_Function_v4float %void = OpTypeVoid %void_fn_type = OpTypeFunction %void %v4f_fn_type = OpTypeFunction %v4float %in_var_COLOR = OpVariable %_ptr_Input_v4float Input %out_var_SV_TARGET = OpVariable %_ptr_Output_v4float Output %null_expr = OpExtInst %void %ext DebugExpression %src = OpExtInst %void %ext DebugSource %file_name %cu = OpExtInst %void %ext DebugCompilationUnit 1 4 %src HLSL %dbg_f = OpExtInst %void %ext DebugTypeBasic %float_name %uint_32 Float %dbg_v4f = OpExtInst %void %ext DebugTypeVector %dbg_f 4 %main_ty = OpExtInst %void %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %dbg_v4f %dbg_v4f %add_ty = OpExtInst %void %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %dbg_v4f %dbg_v4f %dbg_v4f %dbg_main = OpExtInst %void %ext DebugFunction %main_name %main_ty %src 5 1 %cu %main_name FlagIsProtected|FlagIsPrivate 10 %main %dbg_add = OpExtInst %void %ext DebugFunction %add_name %add_ty %src 1 1 %cu %add_name FlagIsProtected|FlagIsPrivate 1 %add %dbg_foo = OpExtInst %void %ext DebugLocalVariable %foo_name %dbg_v4f %src 2 2 %dbg_add FlagIsLocal %main = OpFunction %void None %void_fn_type %main_bb = OpLabel %param_a = OpVariable %_ptr_Function_v4float Function %param_b = OpVariable %_ptr_Function_v4float Function %scope0 = OpExtInst %void %ext DebugScope %dbg_main OpStore %param_a %v4f1 OpStore %param_b %v4f2 %result = OpFunctionCall %v4float %add %param_a %param_b OpStore %out_var_SV_TARGET %result OpReturn OpFunctionEnd %add = OpFunction %v4float None %add_fn_type %scope1 = OpExtInst %void %ext DebugScope %dbg_add %a = OpFunctionParameter %_ptr_Function_v4float %b = OpFunctionParameter %_ptr_Function_v4float %add_bb = OpLabel %foo = OpVariable %_ptr_Function_v4float Function %a_val = OpLoad %v4float %a %b_val = OpLoad %v4float %b %res = OpFAdd %v4float %a_val %b_val OpStore %foo %res %decl = OpExtInst %void %ext DebugDeclare %dbg_foo %foo %null_expr %foo_val = OpLoad %v4float %foo OpReturnValue %foo_val OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(InlineTest, DebugDeclareMultiple) { // Check that InlinePass correctly generates DebugDeclare instructions // for callee function's parameters and maps them to corresponding // local variables of caller function. const std::string text = R"( ; CHECK: [[add:%\d+]] = OpString "add" ; CHECK: [[a:%\d+]] = OpString "a" ; CHECK: [[b:%\d+]] = OpString "b" ; CHECK: [[dbg_add:%\d+]] = OpExtInst %void [[ext:%\d+]] DebugFunction [[add]] ; CHECK: [[dbg_a:%\d+]] = OpExtInst %void [[ext]] DebugLocalVariable [[a]] ; CHECK: [[dbg_b:%\d+]] = OpExtInst %void [[ext]] DebugLocalVariable [[b]] ; CHECK: OpFunction ; CHECK-NOT: OpFunctionEnd ; CHECK: OpStore [[param_a:%\d+]] ; CHECK: OpStore [[param_b:%\d+]] ; CHECK: {{%\d+}} = OpExtInst %void [[ext]] DebugScope [[dbg_add]] ; CHECK: {{%\d+}} = OpExtInst %void [[ext]] DebugDeclare [[dbg_a]] [[param_a]] ; CHECK: {{%\d+}} = OpExtInst %void [[ext]] DebugDeclare [[dbg_b]] [[param_b]] ; CHECK: [[a_val:%\d+]] = OpLoad %v4float [[param_a]] ; CHECK: OpStore [[foo:%\d+]] [[a_val]] ; CHECK: {{%\d+}} = OpExtInst %void [[ext]] DebugValue [[dbg_a]] [[foo]] OpCapability Shader %ext = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_COLOR %out_var_SV_TARGET OpExecutionMode %main OriginUpperLeft %file_name = OpString "ps.hlsl" OpSource HLSL 600 %file_name %float_name = OpString "float" %main_name = OpString "main" %add_name = OpString "add" %a_name = OpString "a" %b_name = OpString "b" OpDecorate %in_var_COLOR Location 0 OpDecorate %out_var_SV_TARGET Location 0 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %float = OpTypeFloat 32 %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %v4float = OpTypeVector %float 4 %v4f1 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %v4f2 = OpConstantComposite %v4float %float_2 %float_2 %float_2 %float_2 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %_ptr_Function_v4float = OpTypePointer Function %v4float %add_fn_type = OpTypeFunction %v4float %_ptr_Function_v4float %_ptr_Function_v4float %void = OpTypeVoid %void_fn_type = OpTypeFunction %void %v4f_fn_type = OpTypeFunction %v4float %in_var_COLOR = OpVariable %_ptr_Input_v4float Input %out_var_SV_TARGET = OpVariable %_ptr_Output_v4float Output %null_expr = OpExtInst %void %ext DebugExpression %src = OpExtInst %void %ext DebugSource %file_name %cu = OpExtInst %void %ext DebugCompilationUnit 1 4 %src HLSL %dbg_f = OpExtInst %void %ext DebugTypeBasic %float_name %uint_32 Float %dbg_v4f = OpExtInst %void %ext DebugTypeVector %dbg_f 4 %main_ty = OpExtInst %void %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %dbg_v4f %dbg_v4f %add_ty = OpExtInst %void %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %dbg_v4f %dbg_v4f %dbg_v4f %dbg_main = OpExtInst %void %ext DebugFunction %main_name %main_ty %src 5 1 %cu %main_name FlagIsProtected|FlagIsPrivate 10 %main %dbg_add = OpExtInst %void %ext DebugFunction %add_name %add_ty %src 1 1 %cu %add_name FlagIsProtected|FlagIsPrivate 1 %add %dbg_a = OpExtInst %void %ext DebugLocalVariable %a_name %dbg_v4f %src 1 13 %dbg_add FlagIsLocal 0 %dbg_b = OpExtInst %void %ext DebugLocalVariable %b_name %dbg_v4f %src 1 20 %dbg_add FlagIsLocal 1 %main = OpFunction %void None %void_fn_type %main_bb = OpLabel %param_a = OpVariable %_ptr_Function_v4float Function %param_b = OpVariable %_ptr_Function_v4float Function %scope0 = OpExtInst %void %ext DebugScope %dbg_main OpStore %param_a %v4f1 OpStore %param_b %v4f2 %result = OpFunctionCall %v4float %add %param_a %param_b OpStore %out_var_SV_TARGET %result OpReturn OpFunctionEnd %add = OpFunction %v4float None %add_fn_type %scope1 = OpExtInst %void %ext DebugScope %dbg_add %a = OpFunctionParameter %_ptr_Function_v4float %b = OpFunctionParameter %_ptr_Function_v4float %decl0 = OpExtInst %void %ext DebugDeclare %dbg_a %a %null_expr %add_bb = OpLabel %decl1 = OpExtInst %void %ext DebugDeclare %dbg_b %b %null_expr %foo = OpVariable %_ptr_Function_v4float Function %a_val = OpLoad %v4float %a OpStore %foo %a_val %dbg_val = OpExtInst %void %ext DebugValue %dbg_a %foo %null_expr %b_val = OpLoad %v4float %b %res = OpFAdd %v4float %a_val %b_val OpReturnValue %res OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(InlineTest, DebugValueForFunctionCallReturn) { // Check that InlinePass correctly generates DebugValue instruction // for function call's return value and maps it to a corresponding // value in the caller function. const std::string text = R"( ; CHECK: [[main:%\d+]] = OpString "main" ; CHECK: [[add:%\d+]] = OpString "add" ; CHECK: [[result:%\d+]] = OpString "result" ; CHECK: [[dbg_main:%\d+]] = OpExtInst %void [[ext:%\d+]] DebugFunction [[main]] ; CHECK: [[dbg_add:%\d+]] = OpExtInst %void [[ext:%\d+]] DebugFunction [[add]] ; CHECK: [[dbg_result:%\d+]] = OpExtInst %void [[ext]] DebugLocalVariable [[result]] {{%\d+}} {{%\d+}} 6 2 [[dbg_main]] ; CHECK: [[inlinedat:%\d+]] = OpExtInst %void [[ext]] DebugInlinedAt 5 ; CHECK: {{%\d+}} = OpExtInst %void [[ext]] DebugScope [[dbg_add]] [[inlinedat]] ; CHECK: [[a_val:%\d+]] = OpLoad %v4float ; CHECK: [[b_val:%\d+]] = OpLoad %v4float ; CHECK: [[res:%\d+]] = OpFAdd %v4float [[a_val]] [[b_val]] ; CHECK: OpStore [[new_result:%\d+]] [[res]] ; CHECK: {{%\d+}} = OpExtInst %void [[ext]] DebugScope [[dbg_main]] ; CHECK: [[result_val:%\d+]] = OpLoad %v4float [[new_result]] ; CHECK: {{%\d+}} = OpExtInst %void [[ext]] DebugValue [[dbg_result]] [[result_val]] OpCapability Shader %ext = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_COLOR %out_var_SV_TARGET OpExecutionMode %main OriginUpperLeft %file_name = OpString "ps.hlsl" OpSource HLSL 600 %file_name %float_name = OpString "float" %main_name = OpString "main" %add_name = OpString "add" %result_name = OpString "result" OpDecorate %in_var_COLOR Location 0 OpDecorate %out_var_SV_TARGET Location 0 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %float = OpTypeFloat 32 %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %v4float = OpTypeVector %float 4 %v4f1 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %v4f2 = OpConstantComposite %v4float %float_2 %float_2 %float_2 %float_2 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %_ptr_Function_v4float = OpTypePointer Function %v4float %add_fn_type = OpTypeFunction %v4float %_ptr_Function_v4float %_ptr_Function_v4float %void = OpTypeVoid %void_fn_type = OpTypeFunction %void %v4f_fn_type = OpTypeFunction %v4float %in_var_COLOR = OpVariable %_ptr_Input_v4float Input %out_var_SV_TARGET = OpVariable %_ptr_Output_v4float Output %null_expr = OpExtInst %void %ext DebugExpression %src = OpExtInst %void %ext DebugSource %file_name %cu = OpExtInst %void %ext DebugCompilationUnit 1 4 %src HLSL %dbg_f = OpExtInst %void %ext DebugTypeBasic %float_name %uint_32 Float %dbg_v4f = OpExtInst %void %ext DebugTypeVector %dbg_f 4 %main_ty = OpExtInst %void %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %dbg_v4f %dbg_v4f %add_ty = OpExtInst %void %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %dbg_v4f %dbg_v4f %dbg_v4f %dbg_main = OpExtInst %void %ext DebugFunction %main_name %main_ty %src 5 1 %cu %main_name FlagIsProtected|FlagIsPrivate 10 %main %dbg_add = OpExtInst %void %ext DebugFunction %add_name %add_ty %src 1 1 %cu %add_name FlagIsProtected|FlagIsPrivate 1 %add %dbg_result = OpExtInst %void %ext DebugLocalVariable %result_name %dbg_v4f %src 6 2 %dbg_main FlagIsLocal %main = OpFunction %void None %void_fn_type %main_bb = OpLabel %param_a = OpVariable %_ptr_Function_v4float Function %param_b = OpVariable %_ptr_Function_v4float Function %scope0 = OpExtInst %void %ext DebugScope %dbg_main OpStore %param_a %v4f1 OpStore %param_b %v4f2 %result = OpFunctionCall %v4float %add %param_a %param_b %value = OpExtInst %void %ext DebugValue %dbg_result %result %null_expr OpStore %out_var_SV_TARGET %result OpReturn OpFunctionEnd %add = OpFunction %v4float None %add_fn_type %scope1 = OpExtInst %void %ext DebugScope %dbg_add %a = OpFunctionParameter %_ptr_Function_v4float %b = OpFunctionParameter %_ptr_Function_v4float %add_bb = OpLabel %a_val = OpLoad %v4float %a %b_val = OpLoad %v4float %b %res = OpFAdd %v4float %a_val %b_val OpReturnValue %res OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(InlineTest, NestedWithAnExistingDebugInlinedAt) { // When a DebugScope instruction in a callee function already has a // DebugInlinedAt information, we have to create a recursive // DebugInlinedAt chain. See inlined_to_zoo and inlined_to_bar in // the following code. const std::string text = R"( ; CHECK: [[main:%\d+]] = OpString "main" ; CHECK: [[foo:%\d+]] = OpString "foo" ; CHECK: [[bar:%\d+]] = OpString "bar" ; CHECK: [[zoo:%\d+]] = OpString "zoo" ; CHECK: [[v4f1:%\d+]] = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 ; CHECK: [[v4f2:%\d+]] = OpConstantComposite %v4float %float_2 %float_2 %float_2 %float_2 ; CHECK: [[v4f3:%\d+]] = OpConstantComposite %v4float %float_3 %float_3 %float_3 %float_3 ; CHECK: [[dbg_main:%\d+]] = OpExtInst %void [[ext:%\d+]] DebugFunction [[main]] ; CHECK: [[dbg_foo:%\d+]] = OpExtInst %void [[ext]] DebugFunction [[foo]] ; CHECK: [[dbg_bar:%\d+]] = OpExtInst %void [[ext]] DebugFunction [[bar]] ; CHECK: [[dbg_zoo:%\d+]] = OpExtInst %void [[ext]] DebugFunction [[zoo]] ; CHECK: [[inlined_to_main:%\d+]] = OpExtInst %void [[ext]] DebugInlinedAt 10 [[dbg_main]] ; CHECK: [[inlined_to_zoo:%\d+]] = OpExtInst %void [[ext]] DebugInlinedAt 7 [[dbg_zoo]] [[inlined_to_main]] ; CHECK: [[inlined_to_main:%\d+]] = OpExtInst %void [[ext]] DebugInlinedAt 10 [[dbg_main]] ; CHECK: [[inlined_to_bar:%\d+]] = OpExtInst %void [[ext]] DebugInlinedAt 4 [[dbg_bar]] [[inlined_to_zoo]] ; CHECK: {{%\d+}} = OpExtInst %void [[ext]] DebugScope [[dbg_foo]] [[inlined_to_bar]] ; CHECK: OpStore [[foo_ret:%\d+]] [[v4f1]] ; CHECK: {{%\d+}} = OpExtInst %void [[ext]] DebugScope [[dbg_bar]] [[inlined_to_zoo]] ; CHECK: [[foo_ret_val:%\d+]] = OpLoad %v4float [[foo_ret]] ; CHECK: [[bar_ret:%\d+]] = OpFAdd %v4float [[foo_ret_val]] [[v4f2]] ; CHECK: {{%\d+}} = OpExtInst %void [[ext]] DebugScope [[dbg_zoo]] [[inlined_to_main]] ; CHECK: [[zoo_result:%\d+]] = OpFAdd %v4float [[bar_ret]] [[v4f3]] ; CHECK: OpStore [[zoo_ret:%\d+]] [[zoo_result]] ; CHECK: {{%\d+}} = OpExtInst %void [[ext]] DebugScope [[dbg_main]] ; CHECK: [[zoo_ret_val:%\d+]] = OpLoad %v4float [[zoo_ret]] ; CHECK: {{%\d+}} = OpFAdd %v4float [[zoo_ret_val]] {{%\d+}} OpCapability Shader %ext = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_COLOR %out_var_SV_TARGET OpExecutionMode %main OriginUpperLeft %file_name = OpString "ps.hlsl" OpSource HLSL 600 %file_name %float_name = OpString "float" %main_name = OpString "main" %foo_name = OpString "foo" %bar_name = OpString "bar" %zoo_name = OpString "zoo" OpDecorate %in_var_COLOR Location 0 OpDecorate %out_var_SV_TARGET Location 0 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %float = OpTypeFloat 32 %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %float_3 = OpConstant %float 3 %v4float = OpTypeVector %float 4 %v4f1 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %v4f2 = OpConstantComposite %v4float %float_2 %float_2 %float_2 %float_2 %v4f3 = OpConstantComposite %v4float %float_3 %float_3 %float_3 %float_3 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %void_fn_type = OpTypeFunction %void %v4f_fn_type = OpTypeFunction %v4float %in_var_COLOR = OpVariable %_ptr_Input_v4float Input %out_var_SV_TARGET = OpVariable %_ptr_Output_v4float Output %src = OpExtInst %void %ext DebugSource %file_name %cu = OpExtInst %void %ext DebugCompilationUnit 1 4 %src HLSL %dbg_f = OpExtInst %void %ext DebugTypeBasic %float_name %uint_32 Float %dbg_v4f = OpExtInst %void %ext DebugTypeVector %dbg_f 4 %main_ty = OpExtInst %void %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %dbg_v4f %dbg_v4f %foo_ty = OpExtInst %void %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %dbg_v4f %dbg_main = OpExtInst %void %ext DebugFunction %main_name %main_ty %src 10 1 %cu %main_name FlagIsProtected|FlagIsPrivate 10 %main %dbg_foo = OpExtInst %void %ext DebugFunction %foo_name %foo_ty %src 1 1 %cu %foo_name FlagIsProtected|FlagIsPrivate 1 %foo %dbg_bar = OpExtInst %void %ext DebugFunction %bar_name %foo_ty %src 4 1 %cu %bar_name FlagIsProtected|FlagIsPrivate 4 %bar %dbg_zoo = OpExtInst %void %ext DebugFunction %zoo_name %foo_ty %src 7 1 %cu %zoo_name FlagIsProtected|FlagIsPrivate 7 %zoo %inlined_to_zoo = OpExtInst %void %ext DebugInlinedAt 7 %dbg_zoo %main = OpFunction %void None %void_fn_type %main_bb = OpLabel %scope0 = OpExtInst %void %ext DebugScope %dbg_main %zoo_val = OpFunctionCall %v4float %zoo %color = OpLoad %v4float %in_var_COLOR %result = OpFAdd %v4float %zoo_val %color OpStore %out_var_SV_TARGET %result OpReturn OpFunctionEnd %foo = OpFunction %v4float None %v4f_fn_type %scope1 = OpExtInst %void %ext DebugScope %dbg_foo %foo_bb = OpLabel OpReturnValue %v4f1 OpFunctionEnd %zoo = OpFunction %v4float None %v4f_fn_type %scope3 = OpExtInst %void %ext DebugScope %dbg_zoo %zoo_bb = OpLabel %scope2 = OpExtInst %void %ext DebugScope %dbg_bar %inlined_to_zoo %foo_val = OpFunctionCall %v4float %foo %bar_val = OpFAdd %v4float %foo_val %v4f2 %scope4 = OpExtInst %void %ext DebugScope %dbg_zoo %zoo_ret = OpFAdd %v4float %bar_val %v4f3 OpReturnValue %zoo_ret OpFunctionEnd %bar = OpFunction %v4float None %v4f_fn_type %scope5 = OpExtInst %void %ext DebugScope %dbg_bar %bar_bb = OpLabel %foo_val0 = OpFunctionCall %v4float %foo %bar_ret = OpFAdd %v4float %foo_val0 %v4f2 OpReturnValue %bar_ret OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(InlineTest, CreateConstantForInlinedAt) { // This shader causes CreateDebugInlinedAt to generate a constant. // Using the Constant manager would attempt to build the invalidated // DefUse manager during inlining which could cause an assert because // the function is in an inconsistent state. This test verifies that // CreateDebugInlinedAt detects that the DefUse manager is disabled // and creates a duplicate constant safely without the Constant manager. // // int function1() { // return 1; // } // // void main() { // function1(); // } const std::string text = R"(OpCapability Shader ; CHECK: %uint_7 = OpConstant %uint 7 ; CHECK: %uint_7_0 = OpConstant %uint 7 ; CHECK: OpExtInst %void %1 DebugInlinedAt %uint_7_0 OpExtension "SPV_KHR_non_semantic_info" %1 = OpExtInstImport "NonSemantic.Shader.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %3 = OpString "parent3.hlsl" %8 = OpString "int" %19 = OpString "function1" %20 = OpString "" %26 = OpString "main" OpName %main "main" OpName %src_main "src.main" OpName %bb_entry "bb.entry" OpName %function1 "function1" OpName %bb_entry_0 "bb.entry" %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %void = OpTypeVoid %uint_4 = OpConstant %uint 4 %uint_0 = OpConstant %uint 0 %uint_3 = OpConstant %uint 3 %uint_1 = OpConstant %uint 1 %uint_5 = OpConstant %uint 5 %uint_2 = OpConstant %uint 2 %uint_17 = OpConstant %uint 17 %uint_6 = OpConstant %uint 6 %uint_13 = OpConstant %uint 13 %uint_7 = OpConstant %uint 7 %31 = OpTypeFunction %void %42 = OpTypeFunction %int %10 = OpExtInst %void %1 DebugTypeBasic %8 %uint_32 %uint_4 %uint_0 %13 = OpExtInst %void %1 DebugTypeFunction %uint_3 %10 %15 = OpExtInst %void %1 DebugSource %3 %16 = OpExtInst %void %1 DebugCompilationUnit %uint_1 %uint_4 %15 %uint_5 %21 = OpExtInst %void %1 DebugFunction %19 %13 %15 %uint_2 %uint_1 %16 %20 %uint_3 %uint_2 %23 = OpExtInst %void %1 DebugLexicalBlock %15 %uint_2 %uint_17 %21 %25 = OpExtInst %void %1 DebugTypeFunction %uint_3 %void %27 = OpExtInst %void %1 DebugFunction %26 %25 %15 %uint_6 %uint_1 %16 %20 %uint_3 %uint_6 %29 = OpExtInst %void %1 DebugLexicalBlock %15 %uint_6 %uint_13 %27 %main = OpFunction %void None %31 %32 = OpLabel %33 = OpFunctionCall %void %src_main OpLine %3 8 1 OpReturn OpFunctionEnd OpLine %3 6 1 %src_main = OpFunction %void None %31 OpNoLine %bb_entry = OpLabel %47 = OpExtInst %void %1 DebugScope %27 %37 = OpExtInst %void %1 DebugFunctionDefinition %27 %src_main %48 = OpExtInst %void %1 DebugScope %29 OpLine %3 7 3 %39 = OpFunctionCall %int %function1 %49 = OpExtInst %void %1 DebugScope %27 OpLine %3 8 1 OpReturn %50 = OpExtInst %void %1 DebugNoScope OpFunctionEnd OpLine %3 2 1 %function1 = OpFunction %int None %42 OpNoLine %bb_entry_0 = OpLabel %51 = OpExtInst %void %1 DebugScope %21 %45 = OpExtInst %void %1 DebugFunctionDefinition %21 %function1 %52 = OpExtInst %void %1 DebugScope %23 OpLine %3 3 3 OpReturnValue %int_1 %53 = OpExtInst %void %1 DebugNoScope OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_2); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(text, true); } TEST_F(InlineTest, CreateDebugInlinedAtFromDebugLine) { const std::string text = R"(OpCapability Shader ; CHECK: OpExtInst %void %1 DebugInlinedAt %uint_6 OpExtension "SPV_KHR_non_semantic_info" %1 = OpExtInstImport "NonSemantic.Shader.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %3 = OpString "debuginlinedat.frag" %8 = OpString "int" %15 = OpString "int function1() { return 1; } void main() { function1(); } " %20 = OpString "function1" %21 = OpString "" %26 = OpString "main" OpName %main "main" OpName %src_main "src.main" OpName %bb_entry "bb.entry" OpName %function1 "function1" OpName %bb_entry_0 "bb.entry" %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %void = OpTypeVoid %uint_4 = OpConstant %uint 4 %uint_0 = OpConstant %uint 0 %uint_3 = OpConstant %uint 3 %uint_1 = OpConstant %uint 1 %uint_5 = OpConstant %uint 5 %uint_17 = OpConstant %uint 17 %uint_13 = OpConstant %uint 13 %30 = OpTypeFunction %void %uint_7 = OpConstant %uint 7 %uint_6 = OpConstant %uint 6 %uint_2 = OpConstant %uint 2 %uint_12 = OpConstant %uint 12 %48 = OpTypeFunction %int %uint_9 = OpConstant %uint 9 %10 = OpExtInst %void %1 DebugTypeBasic %8 %uint_32 %uint_4 %uint_0 %13 = OpExtInst %void %1 DebugTypeFunction %uint_3 %10 %16 = OpExtInst %void %1 DebugSource %3 %15 %17 = OpExtInst %void %1 DebugCompilationUnit %uint_1 %uint_4 %16 %uint_5 %22 = OpExtInst %void %1 DebugFunction %20 %13 %16 %uint_1 %uint_1 %17 %21 %uint_3 %uint_1 %23 = OpExtInst %void %1 DebugLexicalBlock %16 %uint_1 %uint_17 %22 %25 = OpExtInst %void %1 DebugTypeFunction %uint_3 %void %27 = OpExtInst %void %1 DebugFunction %26 %25 %16 %uint_5 %uint_1 %17 %21 %uint_3 %uint_5 %28 = OpExtInst %void %1 DebugLexicalBlock %16 %uint_5 %uint_13 %27 %main = OpFunction %void None %30 %31 = OpLabel %32 = OpFunctionCall %void %src_main %34 = OpExtInst %void %1 DebugLine %16 %uint_7 %uint_7 %uint_1 %uint_1 OpReturn OpFunctionEnd %src_main = OpFunction %void None %30 %bb_entry = OpLabel %37 = OpExtInst %void %1 DebugScope %27 %38 = OpExtInst %void %1 DebugFunctionDefinition %27 %src_main %39 = OpExtInst %void %1 DebugScope %28 %40 = OpExtInst %void %1 DebugLine %16 %uint_6 %uint_6 %uint_2 %uint_12 %44 = OpFunctionCall %int %function1 %46 = OpExtInst %void %1 DebugScope %27 %47 = OpExtInst %void %1 DebugLine %16 %uint_7 %uint_7 %uint_1 %uint_1 OpReturn OpFunctionEnd %function1 = OpFunction %int None %48 %bb_entry_0 = OpLabel %50 = OpExtInst %void %1 DebugScope %22 %51 = OpExtInst %void %1 DebugFunctionDefinition %22 %function1 %52 = OpExtInst %void %1 DebugScope %23 %53 = OpExtInst %void %1 DebugLine %16 %uint_2 %uint_2 %uint_2 %uint_9 OpReturnValue %int_1 OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_2); SinglePassRunAndMatch(text, true); } TEST_F(InlineTest, DecorateReturnVariableWithAliasedPointer) { const std::string text = R"(OpCapability Int64 OpCapability VariablePointers OpCapability PhysicalStorageBufferAddresses OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_KHR_variable_pointers" OpExtension "SPV_KHR_physical_storage_buffer" OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 8 8 1 OpDecorate %_ptr_PhysicalStorageBuffer__struct_5 ArrayStride 8 OpMemberDecorate %_struct_3 0 Offset 0 OpMemberDecorate %_struct_3 1 Offset 8 OpDecorate %_ptr_PhysicalStorageBuffer_int ArrayStride 4 OpMemberDecorate %_struct_5 0 Offset 0 OpMemberDecorate %_struct_5 1 Offset 4 OpDecorate %6 Aliased ; CHECK: OpDecorate %22 AliasedPointer %void = OpTypeVoid %8 = OpTypeFunction %void %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 OpTypeForwardPointer %_ptr_PhysicalStorageBuffer__struct_5 PhysicalStorageBuffer %_struct_3 = OpTypeStruct %int %_ptr_PhysicalStorageBuffer__struct_5 %_ptr_PhysicalStorageBuffer_int = OpTypePointer PhysicalStorageBuffer %int %_struct_5 = OpTypeStruct %int %int %11 = OpTypeFunction %_ptr_PhysicalStorageBuffer_int %_ptr_PhysicalStorageBuffer__struct_5 %_ptr_PhysicalStorageBuffer__struct_5 = OpTypePointer PhysicalStorageBuffer %_struct_5 %_ptr_Function__struct_3 = OpTypePointer Function %_struct_3 %1 = OpFunction %void None %8 %13 = OpLabel %14 = OpVariable %_ptr_Function__struct_3 Function %15 = OpLoad %_struct_3 %14 %16 = OpCompositeExtract %_ptr_PhysicalStorageBuffer__struct_5 %15 1 %17 = OpFunctionCall %_ptr_PhysicalStorageBuffer_int %18 %16 OpReturn OpFunctionEnd %18 = OpFunction %_ptr_PhysicalStorageBuffer_int None %11 %6 = OpFunctionParameter %_ptr_PhysicalStorageBuffer__struct_5 %19 = OpLabel %20 = OpAccessChain %_ptr_PhysicalStorageBuffer_int %6 %int_0 OpReturnValue %20 OpFunctionEnd)"; SetTargetEnv(SPV_ENV_VULKAN_1_2); SinglePassRunAndMatch(text, true); } TEST_F(InlineTest, DebugDeclareWithAccessChain) { const std::string text = R"( ; CHECK: [[EmptyStruct:%[\w]+]] = OpTypeStruct %float ; CHECK-DAG: [[Struct:%[\w]+]] = OpTypeStruct [[EmptyStruct]] ; CHECK-DAG: [[PtrType:%[\w]+]] = OpTypePointer Function [[Struct]] ; CHECK-DAG: [[EmptyPtrType:%[\w]+]] = OpTypePointer Function [[EmptyStruct]] OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" OpExtension "SPV_KHR_relaxed_extended_instruction" %1 = OpExtInstImport "NonSemantic.Shader.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "computeMain" OpExecutionMode %2 LocalSize 1 1 1 %3 = OpString "s.hlsl" %4 = OpString "float" %5 = OpString "source" %6 = OpString "a" %7 = OpString "SomeStruct" %8 = OpString "SomeStruct.getA" %9 = OpString "" %10 = OpString "this" %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_32 = OpConstant %uint 32 %float = OpTypeFloat 32 %void = OpTypeVoid %uint_3 = OpConstant %uint 3 %uint_1 = OpConstant %uint 1 %uint_4 = OpConstant %uint 4 %uint_5 = OpConstant %uint 5 %uint_11 = OpConstant %uint 11 %uint_8 = OpConstant %uint 8 %uint_288 = OpConstant %uint 288 %25 = OpTypeFunction %void %_struct_26 = OpTypeStruct %float %_struct_27 = OpTypeStruct %_struct_26 %_ptr_Function__struct_27 = OpTypePointer Function %_struct_27 %_ptr_Function__struct_26 = OpTypePointer Function %_struct_26 %_ptr_Function_float = OpTypePointer Function %float %30 = OpTypeFunction %float %_ptr_Function__struct_26 %_ptr_Function_float %31 = OpUndef %float %32 = OpExtInst %void %1 DebugTypeBasic %4 %uint_32 %uint_3 %uint_0 %33 = OpExtInst %void %1 DebugSource %3 %5 %34 = OpExtInst %void %1 DebugCompilationUnit %uint_1 %uint_4 %33 %uint_5 %35 = OpExtInst %void %1 DebugTypeMember %6 %32 %33 %uint_3 %uint_11 %uint_0 %uint_32 %uint_3 %36 = OpExtInstWithForwardRefsKHR %void %1 DebugTypeComposite %7 %uint_1 %33 %uint_1 %uint_8 %34 %7 %uint_32 %uint_3 %35 %37 %38 = OpExtInst %void %1 DebugTypeFunction %uint_3 %32 %36 %37 = OpExtInst %void %1 DebugFunction %8 %38 %33 %uint_4 %uint_5 %36 %9 %uint_3 %uint_4 %39 = OpExtInst %void %1 DebugLocalVariable %10 %36 %33 %uint_4 %uint_5 %37 %uint_288 %uint_1 %52 = OpExtInst %void %1 DebugLocalVariable %10 %32 %33 %uint_4 %uint_5 %37 %uint_288 %uint_1 %40 = OpExtInst %void %1 DebugExpression ; CHECK: OpFunction %void None ; CHECK: [[Var:%[\w]+]] = OpVariable [[PtrType]] Function ; CHECK: OpExtInst %void {{%[\w+]+}} DebugDeclare {{%[\w+]+}} [[Var]] {{%[\w+]+}} %int_0 ; CHECK: OpExtInst %void {{%[\w+]+}} DebugDeclare {{%[\w+]+}} [[Var]] {{%[\w+]+}} %int_0 %int_0 %2 = OpFunction %void None %25 %41 = OpLabel %42 = OpVariable %_ptr_Function__struct_27 Function %43 = OpAccessChain %_ptr_Function__struct_26 %42 %int_0 %49 = OpAccessChain %_ptr_Function_float %43 %int_0 %44 = OpFunctionCall %float %45 %43 %49 OpReturn OpFunctionEnd ; CHECK: OpFunction %float None %45 = OpFunction %float None %30 %46 = OpFunctionParameter %_ptr_Function__struct_26 %50 = OpFunctionParameter %_ptr_Function_float %47 = OpLabel %48 = OpExtInst %void %1 DebugDeclare %39 %46 %40 %51 = OpExtInst %void %1 DebugDeclare %52 %50 %40 OpReturnValue %31 OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_2); SinglePassRunAndMatch(text, true); } // TODO(greg-lunarg): Add tests to verify handling of these cases: // // Empty modules // Modules without function definitions // Modules in which all functions do not call other functions // Caller and callee both accessing the same global variable // Functions with OpLine & OpNoLine // Others? // TODO(dneto): Test suggestions from code review // https://github.com/KhronosGroup/SPIRV-Tools/pull/534 // // Callee function returns a value generated outside the callee, // e.g. a constant value. This might exercise some logic not yet // exercised by the current tests: the false branch in the "if" // inside the spv::Op::OpReturnValue case in InlinePass::GenInlineCode? // SampledImage before function call, but callee is only single block. // Then the SampledImage instruction is not cloned. Documents existing // behaviour. // SampledImage after function call. It is not cloned or changed. } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/insert_extract_elim_test.cpp000066400000000000000000000627461475742701700261400ustar00rootroot00000000000000// Copyright (c) 2017 Valve Corporation // Copyright (c) 2017 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "source/opt/simplification_pass.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using InsertExtractElimTest = PassTest<::testing::Test>; TEST_F(InsertExtractElimTest, Simple) { // Note: The SPIR-V assembly has had store/load elimination // performed to allow the inserts and extracts to directly // reference each other. // // #version 140 // // in vec4 BaseColor; // // struct S_t { // vec4 v0; // vec4 v1; // }; // // void main() // { // S_t s0; // s0.v1 = BaseColor; // gl_FragColor = s0.v1; // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %S_t "S_t" OpMemberName %S_t 0 "v0" OpMemberName %S_t 1 "v1" OpName %s0 "s0" OpName %BaseColor "BaseColor" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %S_t = OpTypeStruct %v4float %v4float %_ptr_Function_S_t = OpTypePointer Function %S_t %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output )"; const std::string before = R"(%main = OpFunction %void None %8 %17 = OpLabel %s0 = OpVariable %_ptr_Function_S_t Function %18 = OpLoad %v4float %BaseColor %19 = OpLoad %S_t %s0 %20 = OpCompositeInsert %S_t %18 %19 1 OpStore %s0 %20 %21 = OpCompositeExtract %v4float %20 1 OpStore %gl_FragColor %21 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %8 %17 = OpLabel %s0 = OpVariable %_ptr_Function_S_t Function %18 = OpLoad %v4float %BaseColor %19 = OpLoad %S_t %s0 %20 = OpCompositeInsert %S_t %18 %19 1 OpStore %s0 %20 OpStore %gl_FragColor %18 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before, predefs + after, true, true); } TEST_F(InsertExtractElimTest, OptimizeAcrossNonConflictingInsert) { // Note: The SPIR-V assembly has had store/load elimination // performed to allow the inserts and extracts to directly // reference each other. // // #version 140 // // in vec4 BaseColor; // // struct S_t { // vec4 v0; // vec4 v1; // }; // // void main() // { // S_t s0; // s0.v1 = BaseColor; // s0.v0[2] = 0.0; // gl_FragColor = s0.v1; // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %S_t "S_t" OpMemberName %S_t 0 "v0" OpMemberName %S_t 1 "v1" OpName %s0 "s0" OpName %BaseColor "BaseColor" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %S_t = OpTypeStruct %v4float %v4float %_ptr_Function_S_t = OpTypePointer Function %S_t %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %float_0 = OpConstant %float 0 %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output )"; const std::string before = R"(%main = OpFunction %void None %8 %18 = OpLabel %s0 = OpVariable %_ptr_Function_S_t Function %19 = OpLoad %v4float %BaseColor %20 = OpLoad %S_t %s0 %21 = OpCompositeInsert %S_t %19 %20 1 %22 = OpCompositeInsert %S_t %float_0 %21 0 2 OpStore %s0 %22 %23 = OpCompositeExtract %v4float %22 1 OpStore %gl_FragColor %23 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %8 %18 = OpLabel %s0 = OpVariable %_ptr_Function_S_t Function %19 = OpLoad %v4float %BaseColor %20 = OpLoad %S_t %s0 %21 = OpCompositeInsert %S_t %19 %20 1 %22 = OpCompositeInsert %S_t %float_0 %21 0 2 OpStore %s0 %22 OpStore %gl_FragColor %19 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before, predefs + after, true, true); } TEST_F(InsertExtractElimTest, OptimizeOpaque) { // SPIR-V not representable in GLSL; not generatable from HLSL // for the moment. const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %outColor %texCoords OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %S_t "S_t" OpMemberName %S_t 0 "v0" OpMemberName %S_t 1 "v1" OpMemberName %S_t 2 "smp" OpName %outColor "outColor" OpName %sampler15 "sampler15" OpName %s0 "s0" OpName %texCoords "texCoords" OpDecorate %sampler15 DescriptorSet 0 %void = OpTypeVoid %9 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %outColor = OpVariable %_ptr_Output_v4float Output %14 = OpTypeImage %float 2D 0 0 0 1 Unknown %15 = OpTypeSampledImage %14 %S_t = OpTypeStruct %v2float %v2float %15 %_ptr_Function_S_t = OpTypePointer Function %S_t %17 = OpTypeFunction %void %_ptr_Function_S_t %_ptr_UniformConstant_15 = OpTypePointer UniformConstant %15 %_ptr_Function_15 = OpTypePointer Function %15 %sampler15 = OpVariable %_ptr_UniformConstant_15 UniformConstant %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_2 = OpConstant %int 2 %_ptr_Function_v2float = OpTypePointer Function %v2float %_ptr_Input_v2float = OpTypePointer Input %v2float %texCoords = OpVariable %_ptr_Input_v2float Input )"; const std::string before = R"(%main = OpFunction %void None %9 %25 = OpLabel %s0 = OpVariable %_ptr_Function_S_t Function %26 = OpLoad %v2float %texCoords %27 = OpLoad %S_t %s0 %28 = OpCompositeInsert %S_t %26 %27 0 %29 = OpLoad %15 %sampler15 %30 = OpCompositeInsert %S_t %29 %28 2 OpStore %s0 %30 %31 = OpCompositeExtract %15 %30 2 %32 = OpCompositeExtract %v2float %30 0 %33 = OpImageSampleImplicitLod %v4float %31 %32 OpStore %outColor %33 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %9 %25 = OpLabel %s0 = OpVariable %_ptr_Function_S_t Function %26 = OpLoad %v2float %texCoords %27 = OpLoad %S_t %s0 %28 = OpCompositeInsert %S_t %26 %27 0 %29 = OpLoad %15 %sampler15 %30 = OpCompositeInsert %S_t %29 %28 2 OpStore %s0 %30 %33 = OpImageSampleImplicitLod %v4float %29 %26 OpStore %outColor %33 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before, predefs + after, true, true); } TEST_F(InsertExtractElimTest, OptimizeNestedStruct) { // The following HLSL has been pre-optimized to get the SPIR-V: // struct S0 // { // int x; // SamplerState ss; // }; // // struct S1 // { // float b; // S0 s0; // }; // // struct S2 // { // int a1; // S1 resources; // }; // // SamplerState samp; // Texture2D tex; // // float4 main(float4 vpos : VPOS) : COLOR0 // { // S1 s1; // S2 s2; // s1.s0.ss = samp; // s2.resources = s1; // return tex.Sample(s2.resources.s0.ss, float2(0.5)); // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %_entryPointOutput OpExecutionMode %main OriginUpperLeft OpSource HLSL 500 OpName %main "main" OpName %S0 "S0" OpMemberName %S0 0 "x" OpMemberName %S0 1 "ss" OpName %S1 "S1" OpMemberName %S1 0 "b" OpMemberName %S1 1 "s0" OpName %samp "samp" OpName %S2 "S2" OpMemberName %S2 0 "a1" OpMemberName %S2 1 "resources" OpName %tex "tex" OpName %_entryPointOutput "@entryPointOutput" OpDecorate %samp DescriptorSet 0 OpDecorate %tex DescriptorSet 0 OpDecorate %_entryPointOutput Location 0 %void = OpTypeVoid %10 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %14 = OpTypeFunction %v4float %_ptr_Function_v4float %int = OpTypeInt 32 1 %16 = OpTypeSampler %S0 = OpTypeStruct %int %16 %S1 = OpTypeStruct %float %S0 %_ptr_Function_S1 = OpTypePointer Function %S1 %int_1 = OpConstant %int 1 %_ptr_UniformConstant_16 = OpTypePointer UniformConstant %16 %samp = OpVariable %_ptr_UniformConstant_16 UniformConstant %_ptr_Function_16 = OpTypePointer Function %16 %S2 = OpTypeStruct %int %S1 %_ptr_Function_S2 = OpTypePointer Function %S2 %22 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_22 = OpTypePointer UniformConstant %22 %tex = OpVariable %_ptr_UniformConstant_22 UniformConstant %24 = OpTypeSampledImage %22 %v2float = OpTypeVector %float 2 %float_0_5 = OpConstant %float 0.5 %27 = OpConstantComposite %v2float %float_0_5 %float_0_5 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput = OpVariable %_ptr_Output_v4float Output )"; const std::string before = R"(%main = OpFunction %void None %10 %30 = OpLabel %31 = OpVariable %_ptr_Function_S1 Function %32 = OpVariable %_ptr_Function_S2 Function %33 = OpLoad %16 %samp %34 = OpLoad %S1 %31 %35 = OpCompositeInsert %S1 %33 %34 1 1 OpStore %31 %35 %36 = OpLoad %S2 %32 %37 = OpCompositeInsert %S2 %35 %36 1 OpStore %32 %37 %38 = OpLoad %22 %tex %39 = OpCompositeExtract %16 %37 1 1 1 %40 = OpSampledImage %24 %38 %39 %41 = OpImageSampleImplicitLod %v4float %40 %27 OpStore %_entryPointOutput %41 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %10 %30 = OpLabel %31 = OpVariable %_ptr_Function_S1 Function %32 = OpVariable %_ptr_Function_S2 Function %33 = OpLoad %16 %samp %34 = OpLoad %S1 %31 %35 = OpCompositeInsert %S1 %33 %34 1 1 OpStore %31 %35 %36 = OpLoad %S2 %32 %37 = OpCompositeInsert %S2 %35 %36 1 OpStore %32 %37 %38 = OpLoad %22 %tex %40 = OpSampledImage %24 %38 %33 %41 = OpImageSampleImplicitLod %v4float %40 %27 OpStore %_entryPointOutput %41 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before, predefs + after, true, true); } TEST_F(InsertExtractElimTest, ConflictingInsertPreventsOptimization) { // Note: The SPIR-V assembly has had store/load elimination // performed to allow the inserts and extracts to directly // reference each other. // // #version 140 // // in vec4 BaseColor; // // struct S_t { // vec4 v0; // vec4 v1; // }; // // void main() // { // S_t s0; // s0.v1 = BaseColor; // s0.v1[2] = 0.0; // gl_FragColor = s0.v1; // } const std::string assembly = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %S_t "S_t" OpMemberName %S_t 0 "v0" OpMemberName %S_t 1 "v1" OpName %s0 "s0" OpName %BaseColor "BaseColor" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %S_t = OpTypeStruct %v4float %v4float %_ptr_Function_S_t = OpTypePointer Function %S_t %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %float_0 = OpConstant %float 0 %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %8 %18 = OpLabel %s0 = OpVariable %_ptr_Function_S_t Function %19 = OpLoad %v4float %BaseColor %20 = OpLoad %S_t %s0 %21 = OpCompositeInsert %S_t %19 %20 1 %22 = OpCompositeInsert %S_t %float_0 %21 1 2 OpStore %s0 %22 %23 = OpCompositeExtract %v4float %22 1 OpStore %gl_FragColor %23 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(assembly, assembly, true, true); } TEST_F(InsertExtractElimTest, ConflictingInsertPreventsOptimization2) { // Note: The SPIR-V assembly has had store/load elimination // performed to allow the inserts and extracts to directly // reference each other. // // #version 140 // // in vec4 BaseColor; // // struct S_t { // vec4 v0; // vec4 v1; // }; // // void main() // { // S_t s0; // s0.v1[1] = 1.0; // dead // s0.v1 = Baseline; // gl_FragColor = vec4(s0.v1[1], 0.0, 0.0, 0.0); // } const std::string before_predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %S_t "S_t" OpMemberName %S_t 0 "v0" OpMemberName %S_t 1 "v1" OpName %s0 "s0" OpName %BaseColor "BaseColor" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %S_t = OpTypeStruct %v4float %v4float %_ptr_Function_S_t = OpTypePointer Function %S_t %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %float_1 = OpConstant %float 1 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_ptr_Function_float = OpTypePointer Function %float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output %float_0 = OpConstant %float 0 )"; const std::string after_predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %S_t "S_t" OpMemberName %S_t 0 "v0" OpMemberName %S_t 1 "v1" OpName %s0 "s0" OpName %BaseColor "BaseColor" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %S_t = OpTypeStruct %v4float %v4float %_ptr_Function_S_t = OpTypePointer Function %S_t %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %float_1 = OpConstant %float 1 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_ptr_Function_float = OpTypePointer Function %float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output %float_0 = OpConstant %float 0 )"; const std::string before = R"(%main = OpFunction %void None %8 %22 = OpLabel %s0 = OpVariable %_ptr_Function_S_t Function %23 = OpLoad %S_t %s0 %24 = OpCompositeInsert %S_t %float_1 %23 1 1 %25 = OpLoad %v4float %BaseColor %26 = OpCompositeInsert %S_t %25 %24 1 %27 = OpCompositeExtract %float %26 1 1 %28 = OpCompositeConstruct %v4float %27 %float_0 %float_0 %float_0 OpStore %gl_FragColor %28 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %8 %22 = OpLabel %s0 = OpVariable %_ptr_Function_S_t Function %23 = OpLoad %S_t %s0 %24 = OpCompositeInsert %S_t %float_1 %23 1 1 %25 = OpLoad %v4float %BaseColor %26 = OpCompositeInsert %S_t %25 %24 1 %27 = OpCompositeExtract %float %25 1 %28 = OpCompositeConstruct %v4float %27 %float_0 %float_0 %float_0 OpStore %gl_FragColor %28 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(before_predefs + before, after_predefs + after, true, true); } TEST_F(InsertExtractElimTest, MixWithConstants) { // Extract component of FMix with 0.0 or 1.0 as the a-value. // // Note: The SPIR-V assembly has had store/load elimination // performed to allow the inserts and extracts to directly // reference each other. // // #version 450 // // layout (location=0) in float bc; // layout (location=1) in float bc2; // layout (location=2) in float m; // layout (location=3) in float m2; // layout (location=0) out vec4 OutColor; // // void main() // { // vec4 bcv = vec4(bc, bc2, 0.0, 1.0); // vec4 bcv2 = vec4(bc2, bc, 1.0, 0.0); // vec4 v = mix(bcv, bcv2, vec4(0.0,1.0,m,m2)); // OutColor = vec4(v.y); // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %bc %bc2 %m %m2 %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %bc "bc" OpName %bc2 "bc2" OpName %m "m" OpName %m2 "m2" OpName %OutColor "OutColor" OpDecorate %bc Location 0 OpDecorate %bc2 Location 1 OpDecorate %m Location 2 OpDecorate %m2 Location 3 OpDecorate %OutColor Location 0 %void = OpTypeVoid %9 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_float = OpTypePointer Input %float %bc = OpVariable %_ptr_Input_float Input %bc2 = OpVariable %_ptr_Input_float Input %float_0 = OpConstant %float 0 %float_1 = OpConstant %float 1 %m = OpVariable %_ptr_Input_float Input %m2 = OpVariable %_ptr_Input_float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %uint = OpTypeInt 32 0 %_ptr_Function_float = OpTypePointer Function %float )"; const std::string before = R"(%main = OpFunction %void None %9 %19 = OpLabel %20 = OpLoad %float %bc %21 = OpLoad %float %bc2 %22 = OpCompositeConstruct %v4float %20 %21 %float_0 %float_1 %23 = OpLoad %float %bc2 %24 = OpLoad %float %bc %25 = OpCompositeConstruct %v4float %23 %24 %float_1 %float_0 %26 = OpLoad %float %m %27 = OpLoad %float %m2 %28 = OpCompositeConstruct %v4float %float_0 %float_1 %26 %27 %29 = OpExtInst %v4float %1 FMix %22 %25 %28 %30 = OpCompositeExtract %float %29 1 %31 = OpCompositeConstruct %v4float %30 %30 %30 %30 OpStore %OutColor %31 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %9 %19 = OpLabel %20 = OpLoad %float %bc %21 = OpLoad %float %bc2 %22 = OpCompositeConstruct %v4float %20 %21 %float_0 %float_1 %23 = OpLoad %float %bc2 %24 = OpLoad %float %bc %25 = OpCompositeConstruct %v4float %23 %24 %float_1 %float_0 %26 = OpLoad %float %m %27 = OpLoad %float %m2 %28 = OpCompositeConstruct %v4float %float_0 %float_1 %26 %27 %29 = OpExtInst %v4float %1 FMix %22 %25 %28 %31 = OpCompositeConstruct %v4float %24 %24 %24 %24 OpStore %OutColor %31 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before, predefs + after, true, true); } TEST_F(InsertExtractElimTest, VectorShuffle1) { // Extract component from first vector in VectorShuffle // // Note: The SPIR-V assembly has had store/load elimination // performed to allow the inserts and extracts to directly // reference each other. // // #version 450 // // layout (location=0) in float bc; // layout (location=1) in float bc2; // layout (location=0) out vec4 OutColor; // // void main() // { // vec4 bcv = vec4(bc, bc2, 0.0, 1.0); // vec4 v = bcv.zwxy; // OutColor = vec4(v.y); // } const std::string predefs_before = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %bc %bc2 %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %bc "bc" OpName %bc2 "bc2" OpName %OutColor "OutColor" OpDecorate %bc Location 0 OpDecorate %bc2 Location 1 OpDecorate %OutColor Location 0 %void = OpTypeVoid %7 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_float = OpTypePointer Input %float %bc = OpVariable %_ptr_Input_float Input %bc2 = OpVariable %_ptr_Input_float Input %float_0 = OpConstant %float 0 %float_1 = OpConstant %float 1 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %uint = OpTypeInt 32 0 %_ptr_Function_float = OpTypePointer Function %float )"; const std::string predefs_after = predefs_before + "%24 = OpConstantComposite %v4float " "%float_1 %float_1 %float_1 %float_1\n"; const std::string before = R"(%main = OpFunction %void None %7 %17 = OpLabel %18 = OpLoad %float %bc %19 = OpLoad %float %bc2 %20 = OpCompositeConstruct %v4float %18 %19 %float_0 %float_1 %21 = OpVectorShuffle %v4float %20 %20 2 3 0 1 %22 = OpCompositeExtract %float %21 1 %23 = OpCompositeConstruct %v4float %22 %22 %22 %22 OpStore %OutColor %23 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %7 %17 = OpLabel %18 = OpLoad %float %bc %19 = OpLoad %float %bc2 %20 = OpCompositeConstruct %v4float %18 %19 %float_0 %float_1 %21 = OpVectorShuffle %v4float %20 %20 2 3 0 1 OpStore %OutColor %24 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs_before + before, predefs_after + after, true, true); } TEST_F(InsertExtractElimTest, VectorShuffle2) { // Extract component from second vector in VectorShuffle // Identical to test VectorShuffle1 except for the vector // shuffle index of 7. // // Note: The SPIR-V assembly has had store/load elimination // performed to allow the inserts and extracts to directly // reference each other. // // #version 450 // // layout (location=0) in float bc; // layout (location=1) in float bc2; // layout (location=0) out vec4 OutColor; // // void main() // { // vec4 bcv = vec4(bc, bc2, 0.0, 1.0); // vec4 v = bcv.zwxy; // OutColor = vec4(v.y); // } const std::string predefs_before = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %bc %bc2 %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %bc "bc" OpName %bc2 "bc2" OpName %OutColor "OutColor" OpDecorate %bc Location 0 OpDecorate %bc2 Location 1 OpDecorate %OutColor Location 0 %void = OpTypeVoid %7 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_float = OpTypePointer Input %float %bc = OpVariable %_ptr_Input_float Input %bc2 = OpVariable %_ptr_Input_float Input %float_0 = OpConstant %float 0 %float_1 = OpConstant %float 1 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %uint = OpTypeInt 32 0 %_ptr_Function_float = OpTypePointer Function %float )"; const std::string predefs_after = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %bc %bc2 %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %bc "bc" OpName %bc2 "bc2" OpName %OutColor "OutColor" OpDecorate %bc Location 0 OpDecorate %bc2 Location 1 OpDecorate %OutColor Location 0 %void = OpTypeVoid %7 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_float = OpTypePointer Input %float %bc = OpVariable %_ptr_Input_float Input %bc2 = OpVariable %_ptr_Input_float Input %float_0 = OpConstant %float 0 %float_1 = OpConstant %float 1 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %uint = OpTypeInt 32 0 %_ptr_Function_float = OpTypePointer Function %float %24 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 )"; const std::string before = R"(%main = OpFunction %void None %7 %17 = OpLabel %18 = OpLoad %float %bc %19 = OpLoad %float %bc2 %20 = OpCompositeConstruct %v4float %18 %19 %float_0 %float_1 %21 = OpVectorShuffle %v4float %20 %20 2 7 0 1 %22 = OpCompositeExtract %float %21 1 %23 = OpCompositeConstruct %v4float %22 %22 %22 %22 OpStore %OutColor %23 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %7 %17 = OpLabel %18 = OpLoad %float %bc %19 = OpLoad %float %bc2 %20 = OpCompositeConstruct %v4float %18 %19 %float_0 %float_1 %21 = OpVectorShuffle %v4float %20 %20 2 7 0 1 OpStore %OutColor %24 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs_before + before, predefs_after + after, true, true); } // TODO(greg-lunarg): Add tests to verify handling of these cases: // } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/instruction_list_test.cpp000066400000000000000000000102631475742701700254730ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include #include "gmock/gmock.h" #include "gtest/gtest.h" #include "source/opt/instruction.h" #include "source/opt/instruction_list.h" namespace spvtools { namespace opt { namespace { using ::testing::ContainerEq; using ::testing::ElementsAre; using InstructionListTest = ::testing::Test; // A class that overrides the destructor, so we can trace it. class TestInstruction : public Instruction { public: TestInstruction() : Instruction() { created_instructions_.push_back(this); } ~TestInstruction() override{ deleted_instructions_.push_back(this); } static std::vector created_instructions_; static std::vector deleted_instructions_; }; std::vector TestInstruction::created_instructions_; std::vector TestInstruction::deleted_instructions_; // Test that the destructor for InstructionList is calling the destructor // for every element that is in the list. TEST(InstructionListTest, Destructor) { InstructionList* list = new InstructionList(); list->push_back(std::unique_ptr(new Instruction())); list->push_back(std::unique_ptr(new Instruction())); delete list; // Sorting because we do not care if the order of create and destruction is // the same. Using generic sort just incase things are changed above. std::sort(TestInstruction::created_instructions_.begin(), TestInstruction::created_instructions_.end()); std::sort(TestInstruction::deleted_instructions_.begin(), TestInstruction::deleted_instructions_.end()); EXPECT_THAT(TestInstruction::created_instructions_, ContainerEq(TestInstruction::deleted_instructions_)); } // Test the |InsertBefore| with a single instruction in the iterator class. // Need to make sure the elements are inserted in the correct order, and the // return value points to the correct location. // // Comparing addresses to make sure they remain stable, so other data structures // can have pointers to instructions in InstructionList. TEST(InstructionListTest, InsertBefore1) { InstructionList list; std::vector inserted_instructions; for (int i = 0; i < 4; i++) { std::unique_ptr inst(new Instruction()); inserted_instructions.push_back(inst.get()); auto new_element = list.end().InsertBefore(std::move(inst)); EXPECT_EQ(&*new_element, inserted_instructions.back()); } std::vector output; for (auto& i : list) { output.push_back(&i); } EXPECT_THAT(output, ContainerEq(inserted_instructions)); } // Test inserting an entire vector of instructions using InsertBefore. Checking // the order of insertion and the return value. // // Comparing addresses to make sure they remain stable, so other data structures // can have pointers to instructions in InstructionList. TEST(InstructionListTest, InsertBefore2) { InstructionList list; std::vector> new_instructions; std::vector created_instructions; for (int i = 0; i < 4; i++) { std::unique_ptr inst(new Instruction()); created_instructions.push_back(inst.get()); new_instructions.push_back(std::move(inst)); } auto new_element = list.begin().InsertBefore(std::move(new_instructions)); EXPECT_TRUE(new_instructions.empty()); EXPECT_EQ(&*new_element, created_instructions.front()); std::vector output; for (auto& i : list) { output.push_back(&i); } EXPECT_THAT(output, ContainerEq(created_instructions)); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/instruction_test.cpp000066400000000000000000001444371475742701700244530ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/instruction.h" #include #include #include #include "gmock/gmock.h" #include "source/opt/ir_context.h" #include "spirv-tools/libspirv.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" #include "test/unit_spirv.h" namespace spvtools { namespace opt { namespace { using ::testing::Eq; using spvtest::MakeInstruction; using DescriptorTypeTest = PassTest<::testing::Test>; using OpaqueTypeTest = PassTest<::testing::Test>; using GetBaseTest = PassTest<::testing::Test>; using ValidBasePointerTest = PassTest<::testing::Test>; using VulkanBufferTest = PassTest<::testing::Test>; TEST(InstructionTest, CreateTrivial) { Instruction empty; EXPECT_EQ(spv::Op::OpNop, empty.opcode()); EXPECT_EQ(0u, empty.type_id()); EXPECT_EQ(0u, empty.result_id()); EXPECT_EQ(0u, empty.NumOperands()); EXPECT_EQ(0u, empty.NumOperandWords()); EXPECT_EQ(0u, empty.NumInOperandWords()); EXPECT_EQ(empty.cend(), empty.cbegin()); EXPECT_EQ(empty.end(), empty.begin()); } TEST(InstructionTest, CreateWithOpcodeAndNoOperands) { IRContext context(SPV_ENV_UNIVERSAL_1_2, nullptr); Instruction inst(&context, spv::Op::OpReturn); EXPECT_EQ(spv::Op::OpReturn, inst.opcode()); EXPECT_EQ(0u, inst.type_id()); EXPECT_EQ(0u, inst.result_id()); EXPECT_EQ(0u, inst.NumOperands()); EXPECT_EQ(0u, inst.NumOperandWords()); EXPECT_EQ(0u, inst.NumInOperandWords()); EXPECT_EQ(inst.cend(), inst.cbegin()); EXPECT_EQ(inst.end(), inst.begin()); } TEST(InstructionTest, OperandAsString) { Operand::OperandData abcde{0x64636261, 0x65}; Operand operand(SPV_OPERAND_TYPE_LITERAL_STRING, std::move(abcde)); EXPECT_EQ("abcde", operand.AsString()); } TEST(InstructionTest, OperandAsLiteralUint64_32bits) { Operand::OperandData words{0x1234}; Operand operand(SPV_OPERAND_TYPE_TYPED_LITERAL_NUMBER, std::move(words)); EXPECT_EQ(uint64_t(0x1234), operand.AsLiteralUint64()); } TEST(InstructionTest, OperandAsLiteralUint64_64bits) { Operand::OperandData words{0x1234, 0x89ab}; Operand operand(SPV_OPERAND_TYPE_TYPED_LITERAL_NUMBER, std::move(words)); EXPECT_EQ((uint64_t(0x89ab) << 32 | 0x1234), operand.AsLiteralUint64()); } // The words for an OpTypeInt for 32-bit signed integer resulting in Id 44. uint32_t kSampleInstructionWords[] = {(4 << 16) | uint32_t(spv::Op::OpTypeInt), 44, 32, 1}; // The operands that would be parsed from kSampleInstructionWords spv_parsed_operand_t kSampleParsedOperands[] = { {1, 1, SPV_OPERAND_TYPE_RESULT_ID, SPV_NUMBER_NONE, 0}, {2, 1, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_NUMBER_UNSIGNED_INT, 32}, {3, 1, SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_NUMBER_UNSIGNED_INT, 1}, }; // A valid parse of kSampleParsedOperands. spv_parsed_instruction_t kSampleParsedInstruction = { kSampleInstructionWords, uint16_t(4), uint16_t(spv::Op::OpTypeInt), SPV_EXT_INST_TYPE_NONE, 0, // type id 44, // result id kSampleParsedOperands, 3}; // The words for an OpAccessChain instruction. uint32_t kSampleAccessChainInstructionWords[] = { (7 << 16) | uint32_t(spv::Op::OpAccessChain), 100, 101, 102, 103, 104, 105}; // The operands that would be parsed from kSampleAccessChainInstructionWords. spv_parsed_operand_t kSampleAccessChainOperands[] = { {1, 1, SPV_OPERAND_TYPE_RESULT_ID, SPV_NUMBER_NONE, 0}, {2, 1, SPV_OPERAND_TYPE_TYPE_ID, SPV_NUMBER_NONE, 0}, {3, 1, SPV_OPERAND_TYPE_ID, SPV_NUMBER_NONE, 0}, {4, 1, SPV_OPERAND_TYPE_ID, SPV_NUMBER_NONE, 0}, {5, 1, SPV_OPERAND_TYPE_ID, SPV_NUMBER_NONE, 0}, {6, 1, SPV_OPERAND_TYPE_ID, SPV_NUMBER_NONE, 0}, }; // A valid parse of kSampleAccessChainInstructionWords spv_parsed_instruction_t kSampleAccessChainInstruction = { kSampleAccessChainInstructionWords, uint16_t(7), uint16_t(spv::Op::OpAccessChain), SPV_EXT_INST_TYPE_NONE, 100, // type id 101, // result id kSampleAccessChainOperands, 6}; // The words for an OpControlBarrier instruction. uint32_t kSampleControlBarrierInstructionWords[] = { (4 << 16) | uint32_t(spv::Op::OpControlBarrier), 100, 101, 102}; // The operands that would be parsed from kSampleControlBarrierInstructionWords. spv_parsed_operand_t kSampleControlBarrierOperands[] = { {1, 1, SPV_OPERAND_TYPE_SCOPE_ID, SPV_NUMBER_NONE, 0}, // Execution {2, 1, SPV_OPERAND_TYPE_SCOPE_ID, SPV_NUMBER_NONE, 0}, // Memory {3, 1, SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID, SPV_NUMBER_NONE, 0}, // Semantics }; // A valid parse of kSampleControlBarrierInstructionWords spv_parsed_instruction_t kSampleControlBarrierInstruction = { kSampleControlBarrierInstructionWords, uint16_t(4), uint16_t(spv::Op::OpControlBarrier), SPV_EXT_INST_TYPE_NONE, 0, // type id 0, // result id kSampleControlBarrierOperands, 3}; TEST(InstructionTest, CreateWithOpcodeAndOperands) { IRContext context(SPV_ENV_UNIVERSAL_1_2, nullptr); Instruction inst(&context, kSampleParsedInstruction); EXPECT_EQ(spv::Op::OpTypeInt, inst.opcode()); EXPECT_EQ(0u, inst.type_id()); EXPECT_EQ(44u, inst.result_id()); EXPECT_EQ(3u, inst.NumOperands()); EXPECT_EQ(3u, inst.NumOperandWords()); EXPECT_EQ(2u, inst.NumInOperandWords()); } TEST(InstructionTest, GetOperand) { IRContext context(SPV_ENV_UNIVERSAL_1_2, nullptr); Instruction inst(&context, kSampleParsedInstruction); EXPECT_THAT(inst.GetOperand(0).words, Eq(std::vector{44})); EXPECT_THAT(inst.GetOperand(1).words, Eq(std::vector{32})); EXPECT_THAT(inst.GetOperand(2).words, Eq(std::vector{1})); } TEST(InstructionTest, GetInOperand) { IRContext context(SPV_ENV_UNIVERSAL_1_2, nullptr); Instruction inst(&context, kSampleParsedInstruction); EXPECT_THAT(inst.GetInOperand(0).words, Eq(std::vector{32})); EXPECT_THAT(inst.GetInOperand(1).words, Eq(std::vector{1})); } TEST(InstructionTest, OperandConstIterators) { IRContext context(SPV_ENV_UNIVERSAL_1_2, nullptr); Instruction inst(&context, kSampleParsedInstruction); // Spot check iteration across operands. auto cbegin = inst.cbegin(); auto cend = inst.cend(); EXPECT_NE(cend, inst.cbegin()); auto citer = inst.cbegin(); for (int i = 0; i < 3; ++i, ++citer) { const auto& operand = *citer; EXPECT_THAT(operand.type, Eq(kSampleParsedOperands[i].type)); EXPECT_THAT(operand.words, Eq(std::vector{kSampleInstructionWords[i + 1]})); EXPECT_NE(cend, citer); } EXPECT_EQ(cend, citer); // Check that cbegin and cend have not changed. EXPECT_EQ(cbegin, inst.cbegin()); EXPECT_EQ(cend, inst.cend()); // Check arithmetic. const Operand& operand2 = *(inst.cbegin() + 2); EXPECT_EQ(SPV_OPERAND_TYPE_LITERAL_INTEGER, operand2.type); } TEST(InstructionTest, OperandIterators) { IRContext context(SPV_ENV_UNIVERSAL_1_2, nullptr); Instruction inst(&context, kSampleParsedInstruction); // Spot check iteration across operands, with mutable iterators. auto begin = inst.begin(); auto end = inst.end(); EXPECT_NE(end, inst.begin()); auto iter = inst.begin(); for (int i = 0; i < 3; ++i, ++iter) { const auto& operand = *iter; EXPECT_THAT(operand.type, Eq(kSampleParsedOperands[i].type)); EXPECT_THAT(operand.words, Eq(std::vector{kSampleInstructionWords[i + 1]})); EXPECT_NE(end, iter); } EXPECT_EQ(end, iter); // Check that begin and end have not changed. EXPECT_EQ(begin, inst.begin()); EXPECT_EQ(end, inst.end()); // Check arithmetic. Operand& operand2 = *(inst.begin() + 2); EXPECT_EQ(SPV_OPERAND_TYPE_LITERAL_INTEGER, operand2.type); // Check mutation through an iterator. operand2.type = SPV_OPERAND_TYPE_TYPE_ID; EXPECT_EQ(SPV_OPERAND_TYPE_TYPE_ID, (*(inst.cbegin() + 2)).type); } TEST(InstructionTest, ForInIdStandardIdTypes) { IRContext context(SPV_ENV_UNIVERSAL_1_2, nullptr); Instruction inst(&context, kSampleAccessChainInstruction); std::vector ids; inst.ForEachInId([&ids](const uint32_t* idptr) { ids.push_back(*idptr); }); EXPECT_THAT(ids, Eq(std::vector{102, 103, 104, 105})); ids.clear(); inst.ForEachInId([&ids](uint32_t* idptr) { ids.push_back(*idptr); }); EXPECT_THAT(ids, Eq(std::vector{102, 103, 104, 105})); } TEST(InstructionTest, ForInIdNonstandardIdTypes) { IRContext context(SPV_ENV_UNIVERSAL_1_2, nullptr); Instruction inst(&context, kSampleControlBarrierInstruction); std::vector ids; inst.ForEachInId([&ids](const uint32_t* idptr) { ids.push_back(*idptr); }); EXPECT_THAT(ids, Eq(std::vector{100, 101, 102})); ids.clear(); inst.ForEachInId([&ids](uint32_t* idptr) { ids.push_back(*idptr); }); EXPECT_THAT(ids, Eq(std::vector{100, 101, 102})); } TEST(InstructionTest, UniqueIds) { IRContext context(SPV_ENV_UNIVERSAL_1_2, nullptr); Instruction inst1(&context); Instruction inst2(&context); EXPECT_NE(inst1.unique_id(), inst2.unique_id()); } TEST(InstructionTest, CloneUniqueIdDifferent) { IRContext context(SPV_ENV_UNIVERSAL_1_2, nullptr); Instruction inst(&context); std::unique_ptr clone(inst.Clone(&context)); EXPECT_EQ(inst.context(), clone->context()); EXPECT_NE(inst.unique_id(), clone->unique_id()); } TEST(InstructionTest, CloneDifferentContext) { IRContext c1(SPV_ENV_UNIVERSAL_1_2, nullptr); IRContext c2(SPV_ENV_UNIVERSAL_1_2, nullptr); Instruction inst(&c1); std::unique_ptr clone(inst.Clone(&c2)); EXPECT_EQ(&c1, inst.context()); EXPECT_EQ(&c2, clone->context()); EXPECT_NE(&c1, &c2); } TEST(InstructionTest, CloneDifferentContextDifferentUniqueId) { IRContext c1(SPV_ENV_UNIVERSAL_1_2, nullptr); IRContext c2(SPV_ENV_UNIVERSAL_1_2, nullptr); Instruction inst(&c1); Instruction other(&c2); std::unique_ptr clone(inst.Clone(&c2)); EXPECT_EQ(&c2, clone->context()); EXPECT_NE(other.unique_id(), clone->unique_id()); } TEST(InstructionTest, EqualsEqualsOperator) { IRContext context(SPV_ENV_UNIVERSAL_1_2, nullptr); Instruction i1(&context); Instruction i2(&context); std::unique_ptr clone(i1.Clone(&context)); EXPECT_TRUE(i1 == i1); EXPECT_FALSE(i1 == i2); EXPECT_FALSE(i1 == *clone); EXPECT_FALSE(i2 == *clone); } TEST(InstructionTest, LessThanOperator) { IRContext context(SPV_ENV_UNIVERSAL_1_2, nullptr); Instruction i1(&context); Instruction i2(&context); std::unique_ptr clone(i1.Clone(&context)); EXPECT_TRUE(i1 < i2); EXPECT_TRUE(i1 < *clone); EXPECT_TRUE(i2 < *clone); } TEST_F(DescriptorTypeTest, StorageImage) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %3 "myStorageImage" OpDecorate %3 DescriptorSet 0 OpDecorate %3 Binding 0 %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeFloat 32 %7 = OpTypeImage %6 2D 0 0 0 2 R32f %8 = OpTypePointer UniformConstant %7 %3 = OpVariable %8 UniformConstant %2 = OpFunction %4 None %5 %9 = OpLabel %10 = OpCopyObject %8 %3 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); Instruction* type = context->get_def_use_mgr()->GetDef(8); EXPECT_TRUE(type->IsVulkanStorageImage()); EXPECT_FALSE(type->IsVulkanSampledImage()); EXPECT_FALSE(type->IsVulkanStorageTexelBuffer()); EXPECT_FALSE(type->IsVulkanStorageBuffer()); EXPECT_FALSE(type->IsVulkanUniformBuffer()); Instruction* variable = context->get_def_use_mgr()->GetDef(3); EXPECT_FALSE(variable->IsReadOnlyPointer()); Instruction* object_copy = context->get_def_use_mgr()->GetDef(10); EXPECT_FALSE(object_copy->IsReadOnlyPointer()); } TEST_F(DescriptorTypeTest, SampledImage) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %3 "myStorageImage" OpDecorate %3 DescriptorSet 0 OpDecorate %3 Binding 0 %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeFloat 32 %7 = OpTypeImage %6 2D 0 0 0 1 Unknown %8 = OpTypePointer UniformConstant %7 %3 = OpVariable %8 UniformConstant %2 = OpFunction %4 None %5 %9 = OpLabel %10 = OpCopyObject %8 %3 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); Instruction* type = context->get_def_use_mgr()->GetDef(8); EXPECT_FALSE(type->IsVulkanStorageImage()); EXPECT_TRUE(type->IsVulkanSampledImage()); EXPECT_FALSE(type->IsVulkanStorageTexelBuffer()); EXPECT_FALSE(type->IsVulkanStorageBuffer()); EXPECT_FALSE(type->IsVulkanUniformBuffer()); Instruction* variable = context->get_def_use_mgr()->GetDef(3); EXPECT_TRUE(variable->IsReadOnlyPointer()); Instruction* object_copy = context->get_def_use_mgr()->GetDef(10); EXPECT_TRUE(object_copy->IsReadOnlyPointer()); } TEST_F(DescriptorTypeTest, StorageTexelBuffer) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %3 "myStorageImage" OpDecorate %3 DescriptorSet 0 OpDecorate %3 Binding 0 %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeFloat 32 %7 = OpTypeImage %6 Buffer 0 0 0 2 R32f %8 = OpTypePointer UniformConstant %7 %3 = OpVariable %8 UniformConstant %2 = OpFunction %4 None %5 %9 = OpLabel %10 = OpCopyObject %8 %3 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); Instruction* type = context->get_def_use_mgr()->GetDef(8); EXPECT_FALSE(type->IsVulkanStorageImage()); EXPECT_FALSE(type->IsVulkanSampledImage()); EXPECT_TRUE(type->IsVulkanStorageTexelBuffer()); EXPECT_FALSE(type->IsVulkanStorageBuffer()); EXPECT_FALSE(type->IsVulkanUniformBuffer()); Instruction* variable = context->get_def_use_mgr()->GetDef(3); EXPECT_FALSE(variable->IsReadOnlyPointer()); Instruction* object_copy = context->get_def_use_mgr()->GetDef(10); EXPECT_FALSE(object_copy->IsReadOnlyPointer()); } TEST_F(DescriptorTypeTest, StorageBuffer) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %3 "myStorageImage" OpDecorate %3 DescriptorSet 0 OpDecorate %3 Binding 0 OpDecorate %9 BufferBlock %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypeRuntimeArray %7 %9 = OpTypeStruct %8 %10 = OpTypePointer Uniform %9 %3 = OpVariable %10 Uniform %2 = OpFunction %4 None %5 %11 = OpLabel %12 = OpCopyObject %8 %3 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); Instruction* type = context->get_def_use_mgr()->GetDef(10); EXPECT_FALSE(type->IsVulkanStorageImage()); EXPECT_FALSE(type->IsVulkanSampledImage()); EXPECT_FALSE(type->IsVulkanStorageTexelBuffer()); EXPECT_TRUE(type->IsVulkanStorageBuffer()); EXPECT_FALSE(type->IsVulkanUniformBuffer()); Instruction* variable = context->get_def_use_mgr()->GetDef(3); EXPECT_FALSE(variable->IsReadOnlyPointer()); Instruction* object_copy = context->get_def_use_mgr()->GetDef(12); EXPECT_FALSE(object_copy->IsReadOnlyPointer()); } TEST_F(DescriptorTypeTest, UniformBuffer) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %3 "myStorageImage" OpDecorate %3 DescriptorSet 0 OpDecorate %3 Binding 0 OpDecorate %9 Block %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypeRuntimeArray %7 %9 = OpTypeStruct %8 %10 = OpTypePointer Uniform %9 %3 = OpVariable %10 Uniform %2 = OpFunction %4 None %5 %11 = OpLabel %12 = OpCopyObject %10 %3 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); Instruction* type = context->get_def_use_mgr()->GetDef(10); EXPECT_FALSE(type->IsVulkanStorageImage()); EXPECT_FALSE(type->IsVulkanSampledImage()); EXPECT_FALSE(type->IsVulkanStorageTexelBuffer()); EXPECT_FALSE(type->IsVulkanStorageBuffer()); EXPECT_TRUE(type->IsVulkanUniformBuffer()); Instruction* variable = context->get_def_use_mgr()->GetDef(3); EXPECT_TRUE(variable->IsReadOnlyPointer()); Instruction* object_copy = context->get_def_use_mgr()->GetDef(12); EXPECT_TRUE(object_copy->IsReadOnlyPointer()); } TEST_F(DescriptorTypeTest, NonWritableIsReadOnly) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %3 "myStorageImage" OpDecorate %3 DescriptorSet 0 OpDecorate %3 Binding 0 OpDecorate %9 BufferBlock OpDecorate %3 NonWritable %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypeRuntimeArray %7 %9 = OpTypeStruct %8 %10 = OpTypePointer Uniform %9 %3 = OpVariable %10 Uniform %2 = OpFunction %4 None %5 %11 = OpLabel %12 = OpCopyObject %8 %3 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); Instruction* variable = context->get_def_use_mgr()->GetDef(3); EXPECT_TRUE(variable->IsReadOnlyPointer()); // This demonstrates that the check for whether a pointer is read-only is not // precise: copying a NonWritable-decorated variable can yield a pointer that // the check does not regard as read-only. Instruction* object_copy = context->get_def_use_mgr()->GetDef(12); EXPECT_FALSE(object_copy->IsReadOnlyPointer()); } TEST_F(DescriptorTypeTest, AccessChainIntoReadOnlyStructIsReadOnly) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 320 OpMemberDecorate %3 0 Offset 0 OpMemberDecorate %3 1 Offset 4 OpDecorate %3 Block %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFloat 32 %3 = OpTypeStruct %6 %8 %9 = OpTypePointer PushConstant %3 %10 = OpVariable %9 PushConstant %11 = OpConstant %6 0 %12 = OpTypePointer PushConstant %6 %13 = OpConstant %6 1 %14 = OpTypePointer PushConstant %8 %2 = OpFunction %4 None %5 %15 = OpLabel %16 = OpVariable %7 Function %17 = OpAccessChain %12 %10 %11 %18 = OpAccessChain %14 %10 %13 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); Instruction* push_constant_struct_variable = context->get_def_use_mgr()->GetDef(10); EXPECT_TRUE(push_constant_struct_variable->IsReadOnlyPointer()); Instruction* push_constant_struct_field_0 = context->get_def_use_mgr()->GetDef(17); EXPECT_TRUE(push_constant_struct_field_0->IsReadOnlyPointer()); Instruction* push_constant_struct_field_1 = context->get_def_use_mgr()->GetDef(18); EXPECT_TRUE(push_constant_struct_field_1->IsReadOnlyPointer()); } TEST_F(DescriptorTypeTest, ReadOnlyPointerParameter) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 320 OpMemberDecorate %3 0 Offset 0 OpMemberDecorate %3 1 Offset 4 OpDecorate %3 Block %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFloat 32 %3 = OpTypeStruct %6 %8 %9 = OpTypePointer PushConstant %3 %10 = OpVariable %9 PushConstant %11 = OpConstant %6 0 %12 = OpTypePointer PushConstant %6 %13 = OpConstant %6 1 %14 = OpTypePointer PushConstant %8 %15 = OpTypeFunction %4 %9 %2 = OpFunction %4 None %5 %16 = OpLabel %17 = OpVariable %7 Function %18 = OpAccessChain %12 %10 %11 %19 = OpAccessChain %14 %10 %13 OpReturn OpFunctionEnd %20 = OpFunction %4 None %15 %21 = OpFunctionParameter %9 %22 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); Instruction* push_constant_struct_parameter = context->get_def_use_mgr()->GetDef(21); EXPECT_TRUE(push_constant_struct_parameter->IsReadOnlyPointer()); } TEST_F(OpaqueTypeTest, BaseOpaqueTypesShader) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %6 = OpTypeImage %5 2D 1 0 0 1 Unknown %7 = OpTypeSampler %8 = OpTypeSampledImage %6 %9 = OpTypeRuntimeArray %5 %2 = OpFunction %3 None %4 %10 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); Instruction* image_type = context->get_def_use_mgr()->GetDef(6); EXPECT_TRUE(image_type->IsOpaqueType()); Instruction* sampler_type = context->get_def_use_mgr()->GetDef(7); EXPECT_TRUE(sampler_type->IsOpaqueType()); Instruction* sampled_image_type = context->get_def_use_mgr()->GetDef(8); EXPECT_TRUE(sampled_image_type->IsOpaqueType()); Instruction* runtime_array_type = context->get_def_use_mgr()->GetDef(9); EXPECT_TRUE(runtime_array_type->IsOpaqueType()); Instruction* float_type = context->get_def_use_mgr()->GetDef(5); EXPECT_FALSE(float_type->IsOpaqueType()); Instruction* void_type = context->get_def_use_mgr()->GetDef(3); EXPECT_FALSE(void_type->IsOpaqueType()); } TEST_F(OpaqueTypeTest, OpaqueStructTypes) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %6 = OpTypeRuntimeArray %5 %7 = OpTypeStruct %6 %6 %8 = OpTypeStruct %5 %6 %9 = OpTypeStruct %6 %5 %10 = OpTypeStruct %7 %2 = OpFunction %3 None %4 %11 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); for (int i = 7; i <= 10; i++) { Instruction* type = context->get_def_use_mgr()->GetDef(i); EXPECT_TRUE(type->IsOpaqueType()); } } TEST_F(GetBaseTest, SampleImage) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %3 "myStorageImage" OpDecorate %3 DescriptorSet 0 OpDecorate %3 Binding 0 %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 2 %8 = OpTypeVector %6 4 %9 = OpConstant %6 0 %10 = OpConstantComposite %7 %9 %9 %11 = OpTypeImage %6 2D 0 0 0 1 R32f %12 = OpTypePointer UniformConstant %11 %3 = OpVariable %12 UniformConstant %13 = OpTypeSampledImage %11 %14 = OpTypeSampler %15 = OpTypePointer UniformConstant %14 %16 = OpVariable %15 UniformConstant %2 = OpFunction %4 None %5 %17 = OpLabel %18 = OpLoad %11 %3 %19 = OpLoad %14 %16 %20 = OpSampledImage %13 %18 %19 %21 = OpImageSampleImplicitLod %8 %20 %10 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); Instruction* load = context->get_def_use_mgr()->GetDef(21); Instruction* base = context->get_def_use_mgr()->GetDef(20); EXPECT_TRUE(load->GetBaseAddress() == base); } TEST_F(GetBaseTest, PtrAccessChain) { const std::string text = R"( OpCapability VariablePointers OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "PSMain" %2 OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %4 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %int = OpTypeInt 32 8388353 %int_0 = OpConstant %int 0 %_ptr_Function_v4float = OpTypePointer Function %v4float %2 = OpVariable %_ptr_Function_v4float Input %1 = OpFunction %void None %4 %10 = OpLabel %11 = OpPtrAccessChain %_ptr_Function_v4float %2 %int_0 %12 = OpLoad %v4float %11 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); Instruction* load = context->get_def_use_mgr()->GetDef(12); Instruction* base = context->get_def_use_mgr()->GetDef(2); EXPECT_TRUE(load->GetBaseAddress() == base); } TEST_F(GetBaseTest, ImageRead) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %3 "myStorageImage" OpDecorate %3 DescriptorSet 0 OpDecorate %3 Binding 0 %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeInt 32 0 %7 = OpTypeVector %6 2 %8 = OpConstant %6 0 %9 = OpConstantComposite %7 %8 %8 %10 = OpTypeImage %6 2D 0 0 0 2 R32f %11 = OpTypePointer UniformConstant %10 %3 = OpVariable %11 UniformConstant %2 = OpFunction %4 None %5 %12 = OpLabel %13 = OpLoad %10 %3 %14 = OpImageRead %6 %13 %9 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); Instruction* load = context->get_def_use_mgr()->GetDef(14); Instruction* base = context->get_def_use_mgr()->GetDef(13); EXPECT_TRUE(load->GetBaseAddress() == base); } TEST_F(ValidBasePointerTest, OpSelectBadNoVariablePointersStorageBuffer) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" %2 = OpTypeVoid %3 = OpTypeInt 32 0 %4 = OpTypePointer StorageBuffer %3 %5 = OpVariable %4 StorageBuffer %6 = OpTypeFunction %2 %7 = OpTypeBool %8 = OpConstantTrue %7 %1 = OpFunction %2 None %6 %9 = OpLabel %10 = OpSelect %4 %8 %5 %5 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_3, nullptr, text); EXPECT_NE(context, nullptr); Instruction* select = context->get_def_use_mgr()->GetDef(10); EXPECT_NE(select, nullptr); EXPECT_FALSE(select->IsValidBasePointer()); } TEST_F(ValidBasePointerTest, OpSelectBadNoVariablePointers) { const std::string text = R"( OpCapability Shader OpCapability VariablePointersStorageBuffer OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" %2 = OpTypeVoid %3 = OpTypeInt 32 0 %4 = OpTypePointer Workgroup %3 %5 = OpVariable %4 Workgroup %6 = OpTypeFunction %2 %7 = OpTypeBool %8 = OpConstantTrue %7 %1 = OpFunction %2 None %6 %9 = OpLabel %10 = OpSelect %4 %8 %5 %5 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_3, nullptr, text); EXPECT_NE(context, nullptr); Instruction* select = context->get_def_use_mgr()->GetDef(10); EXPECT_NE(select, nullptr); EXPECT_FALSE(select->IsValidBasePointer()); } TEST_F(ValidBasePointerTest, OpSelectGoodVariablePointersStorageBuffer) { const std::string text = R"( OpCapability Shader OpCapability VariablePointersStorageBuffer OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" %2 = OpTypeVoid %3 = OpTypeInt 32 0 %4 = OpTypePointer StorageBuffer %3 %5 = OpVariable %4 StorageBuffer %6 = OpTypeFunction %2 %7 = OpTypeBool %8 = OpConstantTrue %7 %1 = OpFunction %2 None %6 %9 = OpLabel %10 = OpSelect %4 %8 %5 %5 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_3, nullptr, text); EXPECT_NE(context, nullptr); Instruction* select = context->get_def_use_mgr()->GetDef(10); EXPECT_NE(select, nullptr); EXPECT_TRUE(select->IsValidBasePointer()); } TEST_F(ValidBasePointerTest, OpSelectGoodVariablePointers) { const std::string text = R"( OpCapability Shader OpCapability VariablePointers OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" %2 = OpTypeVoid %3 = OpTypeInt 32 0 %4 = OpTypePointer Workgroup %3 %5 = OpVariable %4 Workgroup %6 = OpTypeFunction %2 %7 = OpTypeBool %8 = OpConstantTrue %7 %1 = OpFunction %2 None %6 %9 = OpLabel %10 = OpSelect %4 %8 %5 %5 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_3, nullptr, text); EXPECT_NE(context, nullptr); Instruction* select = context->get_def_use_mgr()->GetDef(10); EXPECT_NE(select, nullptr); EXPECT_TRUE(select->IsValidBasePointer()); } TEST_F(ValidBasePointerTest, OpConstantNullBadNoVariablePointersStorageBuffer) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" %2 = OpTypeVoid %3 = OpTypeInt 32 0 %4 = OpTypePointer StorageBuffer %3 %5 = OpConstantNull %4 %6 = OpTypeFunction %2 %1 = OpFunction %2 None %6 %7 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_3, nullptr, text); EXPECT_NE(context, nullptr); Instruction* null_inst = context->get_def_use_mgr()->GetDef(5); EXPECT_NE(null_inst, nullptr); EXPECT_FALSE(null_inst->IsValidBasePointer()); } TEST_F(ValidBasePointerTest, OpConstantNullBadNoVariablePointers) { const std::string text = R"( OpCapability Shader OpCapability VariablePointersStorageBuffer OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" %2 = OpTypeVoid %3 = OpTypeInt 32 0 %4 = OpTypePointer Workgroup %3 %5 = OpConstantNull %4 %6 = OpTypeFunction %2 %1 = OpFunction %2 None %6 %7 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_3, nullptr, text); EXPECT_NE(context, nullptr); Instruction* null_inst = context->get_def_use_mgr()->GetDef(5); EXPECT_NE(null_inst, nullptr); EXPECT_FALSE(null_inst->IsValidBasePointer()); } TEST_F(ValidBasePointerTest, OpConstantNullGoodVariablePointersStorageBuffer) { const std::string text = R"( OpCapability Shader OpCapability VariablePointersStorageBuffer OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" %2 = OpTypeVoid %3 = OpTypeInt 32 0 %4 = OpTypePointer StorageBuffer %3 %5 = OpConstantNull %4 %6 = OpTypeFunction %2 %1 = OpFunction %2 None %6 %9 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_3, nullptr, text); EXPECT_NE(context, nullptr); Instruction* null_inst = context->get_def_use_mgr()->GetDef(5); EXPECT_NE(null_inst, nullptr); EXPECT_TRUE(null_inst->IsValidBasePointer()); } TEST_F(ValidBasePointerTest, OpConstantNullGoodVariablePointers) { const std::string text = R"( OpCapability Shader OpCapability VariablePointers OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" %2 = OpTypeVoid %3 = OpTypeInt 32 0 %4 = OpTypePointer Workgroup %3 %5 = OpConstantNull %4 %6 = OpTypeFunction %2 %1 = OpFunction %2 None %6 %7 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_3, nullptr, text); EXPECT_NE(context, nullptr); Instruction* null_inst = context->get_def_use_mgr()->GetDef(5); EXPECT_NE(null_inst, nullptr); EXPECT_TRUE(null_inst->IsValidBasePointer()); } TEST_F(ValidBasePointerTest, OpPhiBadNoVariablePointersStorageBuffer) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" %2 = OpTypeVoid %3 = OpTypeInt 32 0 %4 = OpTypePointer StorageBuffer %3 %5 = OpVariable %4 StorageBuffer %6 = OpTypeFunction %2 %1 = OpFunction %2 None %6 %7 = OpLabel OpBranch %8 %8 = OpLabel %9 = OpPhi %4 %5 %7 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_3, nullptr, text); EXPECT_NE(context, nullptr); Instruction* phi = context->get_def_use_mgr()->GetDef(9); EXPECT_NE(phi, nullptr); EXPECT_FALSE(phi->IsValidBasePointer()); } TEST_F(ValidBasePointerTest, OpPhiBadNoVariablePointers) { const std::string text = R"( OpCapability Shader OpCapability VariablePointersStorageBuffer OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" %2 = OpTypeVoid %3 = OpTypeInt 32 0 %4 = OpTypePointer Workgroup %3 %5 = OpVariable %4 Workgroup %6 = OpTypeFunction %2 %1 = OpFunction %2 None %6 %7 = OpLabel OpBranch %8 %8 = OpLabel %9 = OpPhi %4 %5 %7 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_3, nullptr, text); EXPECT_NE(context, nullptr); Instruction* phi = context->get_def_use_mgr()->GetDef(9); EXPECT_NE(phi, nullptr); EXPECT_FALSE(phi->IsValidBasePointer()); } TEST_F(ValidBasePointerTest, OpPhiGoodVariablePointersStorageBuffer) { const std::string text = R"( OpCapability Shader OpCapability VariablePointersStorageBuffer OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" %2 = OpTypeVoid %3 = OpTypeInt 32 0 %4 = OpTypePointer StorageBuffer %3 %5 = OpVariable %4 StorageBuffer %6 = OpTypeFunction %2 %1 = OpFunction %2 None %6 %7 = OpLabel OpBranch %8 %8 = OpLabel %9 = OpPhi %4 %5 %7 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_3, nullptr, text); EXPECT_NE(context, nullptr); Instruction* phi = context->get_def_use_mgr()->GetDef(9); EXPECT_NE(phi, nullptr); EXPECT_TRUE(phi->IsValidBasePointer()); } TEST_F(ValidBasePointerTest, OpPhiGoodVariablePointers) { const std::string text = R"( OpCapability Shader OpCapability VariablePointers OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" %2 = OpTypeVoid %3 = OpTypeInt 32 0 %4 = OpTypePointer Workgroup %3 %5 = OpVariable %4 Workgroup %6 = OpTypeFunction %2 %1 = OpFunction %2 None %6 %7 = OpLabel OpBranch %8 %8 = OpLabel %9 = OpPhi %4 %5 %7 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_3, nullptr, text); EXPECT_NE(context, nullptr); Instruction* phi = context->get_def_use_mgr()->GetDef(9); EXPECT_NE(phi, nullptr); EXPECT_TRUE(phi->IsValidBasePointer()); } TEST_F(ValidBasePointerTest, OpFunctionCallBadNoVariablePointersStorageBuffer) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" %2 = OpTypeVoid %3 = OpTypeInt 32 0 %4 = OpTypePointer StorageBuffer %3 %5 = OpConstantNull %4 %6 = OpTypeFunction %2 %7 = OpTypeFunction %4 %1 = OpFunction %2 None %6 %8 = OpLabel %9 = OpFunctionCall %4 %10 OpReturn OpFunctionEnd %10 = OpFunction %4 None %7 %11 = OpLabel OpReturnValue %5 OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_3, nullptr, text); EXPECT_NE(context, nullptr); Instruction* null_inst = context->get_def_use_mgr()->GetDef(9); EXPECT_NE(null_inst, nullptr); EXPECT_FALSE(null_inst->IsValidBasePointer()); } TEST_F(ValidBasePointerTest, OpFunctionCallBadNoVariablePointers) { const std::string text = R"( OpCapability Shader OpCapability VariablePointersStorageBuffer OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" %2 = OpTypeVoid %3 = OpTypeInt 32 0 %4 = OpTypePointer Workgroup %3 %5 = OpConstantNull %4 %6 = OpTypeFunction %2 %7 = OpTypeFunction %4 %1 = OpFunction %2 None %6 %8 = OpLabel %9 = OpFunctionCall %4 %10 OpReturn OpFunctionEnd %10 = OpFunction %4 None %7 %11 = OpLabel OpReturnValue %5 OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_3, nullptr, text); EXPECT_NE(context, nullptr); Instruction* null_inst = context->get_def_use_mgr()->GetDef(9); EXPECT_NE(null_inst, nullptr); EXPECT_FALSE(null_inst->IsValidBasePointer()); } TEST_F(ValidBasePointerTest, OpFunctionCallGoodVariablePointersStorageBuffer) { const std::string text = R"( OpCapability Shader OpCapability VariablePointersStorageBuffer OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" %2 = OpTypeVoid %3 = OpTypeInt 32 0 %4 = OpTypePointer StorageBuffer %3 %5 = OpConstantNull %4 %6 = OpTypeFunction %2 %7 = OpTypeFunction %4 %1 = OpFunction %2 None %6 %8 = OpLabel %9 = OpFunctionCall %4 %10 OpReturn OpFunctionEnd %10 = OpFunction %4 None %7 %11 = OpLabel OpReturnValue %5 OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_3, nullptr, text); EXPECT_NE(context, nullptr); Instruction* null_inst = context->get_def_use_mgr()->GetDef(9); EXPECT_NE(null_inst, nullptr); EXPECT_TRUE(null_inst->IsValidBasePointer()); } TEST_F(ValidBasePointerTest, OpFunctionCallGoodVariablePointers) { const std::string text = R"( OpCapability Shader OpCapability VariablePointers OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" %2 = OpTypeVoid %3 = OpTypeInt 32 0 %4 = OpTypePointer Workgroup %3 %5 = OpConstantNull %4 %6 = OpTypeFunction %2 %7 = OpTypeFunction %4 %1 = OpFunction %2 None %6 %8 = OpLabel %9 = OpFunctionCall %4 %10 OpReturn OpFunctionEnd %10 = OpFunction %4 None %7 %11 = OpLabel OpReturnValue %5 OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_3, nullptr, text); EXPECT_NE(context, nullptr); Instruction* null_inst = context->get_def_use_mgr()->GetDef(9); EXPECT_NE(null_inst, nullptr); EXPECT_TRUE(null_inst->IsValidBasePointer()); } TEST_F(VulkanBufferTest, VulkanStorageBuffer) { const std::string text = R"( OpCapability Shader OpCapability RuntimeDescriptorArray OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 OpDecorate %2 Block OpMemberDecorate %2 0 Offset 0 OpDecorate %3 BufferBlock OpMemberDecorate %3 0 Offset 0 %4 = OpTypeVoid %5 = OpTypeInt 32 0 %2 = OpTypeStruct %5 %3 = OpTypeStruct %5 %6 = OpTypePointer StorageBuffer %2 %7 = OpTypePointer Uniform %2 %8 = OpTypePointer Uniform %3 %9 = OpConstant %5 1 %10 = OpTypeArray %2 %9 %11 = OpTypeArray %3 %9 %12 = OpTypePointer StorageBuffer %10 %13 = OpTypePointer Uniform %10 %14 = OpTypePointer Uniform %11 %15 = OpTypeRuntimeArray %2 %16 = OpTypeRuntimeArray %3 %17 = OpTypePointer StorageBuffer %15 %18 = OpTypePointer Uniform %15 %19 = OpTypePointer Uniform %16 %50 = OpTypeFunction %4 %1 = OpFunction %4 None %50 %51 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_3, nullptr, text); EXPECT_NE(context, nullptr); // Standard SSBO and UBO Instruction* inst = context->get_def_use_mgr()->GetDef(6); EXPECT_EQ(true, inst->IsVulkanStorageBuffer()); inst = context->get_def_use_mgr()->GetDef(7); EXPECT_EQ(false, inst->IsVulkanStorageBuffer()); inst = context->get_def_use_mgr()->GetDef(8); EXPECT_EQ(true, inst->IsVulkanStorageBuffer()); // Arrayed SSBO and UBO inst = context->get_def_use_mgr()->GetDef(12); EXPECT_EQ(true, inst->IsVulkanStorageBuffer()); inst = context->get_def_use_mgr()->GetDef(13); EXPECT_EQ(false, inst->IsVulkanStorageBuffer()); inst = context->get_def_use_mgr()->GetDef(14); EXPECT_EQ(true, inst->IsVulkanStorageBuffer()); // Runtime arrayed SSBO and UBO inst = context->get_def_use_mgr()->GetDef(17); EXPECT_EQ(true, inst->IsVulkanStorageBuffer()); inst = context->get_def_use_mgr()->GetDef(18); EXPECT_EQ(false, inst->IsVulkanStorageBuffer()); inst = context->get_def_use_mgr()->GetDef(19); EXPECT_EQ(true, inst->IsVulkanStorageBuffer()); } TEST_F(VulkanBufferTest, VulkanUniformBuffer) { const std::string text = R"( OpCapability Shader OpCapability RuntimeDescriptorArray OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 OpDecorate %2 Block OpMemberDecorate %2 0 Offset 0 OpDecorate %3 BufferBlock OpMemberDecorate %3 0 Offset 0 %4 = OpTypeVoid %5 = OpTypeInt 32 0 %2 = OpTypeStruct %5 %3 = OpTypeStruct %5 %6 = OpTypePointer StorageBuffer %2 %7 = OpTypePointer Uniform %2 %8 = OpTypePointer Uniform %3 %9 = OpConstant %5 1 %10 = OpTypeArray %2 %9 %11 = OpTypeArray %3 %9 %12 = OpTypePointer StorageBuffer %10 %13 = OpTypePointer Uniform %10 %14 = OpTypePointer Uniform %11 %15 = OpTypeRuntimeArray %2 %16 = OpTypeRuntimeArray %3 %17 = OpTypePointer StorageBuffer %15 %18 = OpTypePointer Uniform %15 %19 = OpTypePointer Uniform %16 %50 = OpTypeFunction %4 %1 = OpFunction %4 None %50 %51 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_3, nullptr, text); EXPECT_NE(context, nullptr); // Standard SSBO and UBO Instruction* inst = context->get_def_use_mgr()->GetDef(6); EXPECT_EQ(false, inst->IsVulkanUniformBuffer()); inst = context->get_def_use_mgr()->GetDef(7); EXPECT_EQ(true, inst->IsVulkanUniformBuffer()); inst = context->get_def_use_mgr()->GetDef(8); EXPECT_EQ(false, inst->IsVulkanUniformBuffer()); // Arrayed SSBO and UBO inst = context->get_def_use_mgr()->GetDef(12); EXPECT_EQ(false, inst->IsVulkanUniformBuffer()); inst = context->get_def_use_mgr()->GetDef(13); EXPECT_EQ(true, inst->IsVulkanUniformBuffer()); inst = context->get_def_use_mgr()->GetDef(14); EXPECT_EQ(false, inst->IsVulkanUniformBuffer()); // Runtime arrayed SSBO and UBO inst = context->get_def_use_mgr()->GetDef(17); EXPECT_EQ(false, inst->IsVulkanUniformBuffer()); inst = context->get_def_use_mgr()->GetDef(18); EXPECT_EQ(true, inst->IsVulkanUniformBuffer()); inst = context->get_def_use_mgr()->GetDef(19); EXPECT_EQ(false, inst->IsVulkanUniformBuffer()); } TEST_F(VulkanBufferTest, ImageQueries) { const std::string text = R"( OpCapability Shader OpCapability ImageBuffer OpCapability RuntimeDescriptorArray OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 %2 = OpTypeVoid %3 = OpTypeFloat 32 %4 = OpTypeImage %3 Buffer 0 0 0 1 Rgba32f %5 = OpTypeImage %3 Buffer 0 0 0 2 Rgba32f %6 = OpTypeImage %3 2D 0 0 0 1 Rgba32f %7 = OpTypeImage %3 2D 0 0 0 2 Rgba32f %8 = OpTypePointer UniformConstant %4 %9 = OpTypePointer UniformConstant %5 %10 = OpTypePointer UniformConstant %6 %11 = OpTypePointer UniformConstant %7 %12 = OpTypeInt 32 0 %13 = OpConstant %12 1 %14 = OpTypeArray %4 %13 %15 = OpTypeArray %5 %13 %16 = OpTypeArray %6 %13 %17 = OpTypeArray %7 %13 %18 = OpTypePointer UniformConstant %14 %19 = OpTypePointer UniformConstant %15 %20 = OpTypePointer UniformConstant %16 %21 = OpTypePointer UniformConstant %17 %22 = OpTypeRuntimeArray %4 %23 = OpTypeRuntimeArray %5 %24 = OpTypeRuntimeArray %6 %25 = OpTypeRuntimeArray %7 %26 = OpTypePointer UniformConstant %22 %27 = OpTypePointer UniformConstant %23 %28 = OpTypePointer UniformConstant %24 %29 = OpTypePointer UniformConstant %25 %50 = OpTypeFunction %4 %1 = OpFunction %4 None %50 %51 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_3, nullptr, text); EXPECT_NE(context, nullptr); // Bare pointers Instruction* inst = context->get_def_use_mgr()->GetDef(8); EXPECT_EQ(false, inst->IsVulkanStorageImage()); EXPECT_EQ(false, inst->IsVulkanSampledImage()); EXPECT_EQ(false, inst->IsVulkanStorageTexelBuffer()); inst = context->get_def_use_mgr()->GetDef(9); EXPECT_EQ(false, inst->IsVulkanStorageImage()); EXPECT_EQ(false, inst->IsVulkanSampledImage()); EXPECT_EQ(true, inst->IsVulkanStorageTexelBuffer()); inst = context->get_def_use_mgr()->GetDef(10); EXPECT_EQ(false, inst->IsVulkanStorageImage()); EXPECT_EQ(true, inst->IsVulkanSampledImage()); EXPECT_EQ(false, inst->IsVulkanStorageTexelBuffer()); inst = context->get_def_use_mgr()->GetDef(11); EXPECT_EQ(true, inst->IsVulkanStorageImage()); EXPECT_EQ(false, inst->IsVulkanSampledImage()); EXPECT_EQ(false, inst->IsVulkanStorageTexelBuffer()); // Array pointers inst = context->get_def_use_mgr()->GetDef(18); EXPECT_EQ(false, inst->IsVulkanStorageImage()); EXPECT_EQ(false, inst->IsVulkanSampledImage()); EXPECT_EQ(false, inst->IsVulkanStorageTexelBuffer()); inst = context->get_def_use_mgr()->GetDef(19); EXPECT_EQ(false, inst->IsVulkanStorageImage()); EXPECT_EQ(false, inst->IsVulkanSampledImage()); EXPECT_EQ(true, inst->IsVulkanStorageTexelBuffer()); inst = context->get_def_use_mgr()->GetDef(20); EXPECT_EQ(false, inst->IsVulkanStorageImage()); EXPECT_EQ(true, inst->IsVulkanSampledImage()); EXPECT_EQ(false, inst->IsVulkanStorageTexelBuffer()); inst = context->get_def_use_mgr()->GetDef(21); EXPECT_EQ(true, inst->IsVulkanStorageImage()); EXPECT_EQ(false, inst->IsVulkanSampledImage()); EXPECT_EQ(false, inst->IsVulkanStorageTexelBuffer()); // Runtime array pointers inst = context->get_def_use_mgr()->GetDef(26); EXPECT_EQ(false, inst->IsVulkanStorageImage()); EXPECT_EQ(false, inst->IsVulkanSampledImage()); EXPECT_EQ(false, inst->IsVulkanStorageTexelBuffer()); inst = context->get_def_use_mgr()->GetDef(27); EXPECT_EQ(false, inst->IsVulkanStorageImage()); EXPECT_EQ(false, inst->IsVulkanSampledImage()); EXPECT_EQ(true, inst->IsVulkanStorageTexelBuffer()); inst = context->get_def_use_mgr()->GetDef(28); EXPECT_EQ(false, inst->IsVulkanStorageImage()); EXPECT_EQ(true, inst->IsVulkanSampledImage()); EXPECT_EQ(false, inst->IsVulkanStorageTexelBuffer()); inst = context->get_def_use_mgr()->GetDef(29); EXPECT_EQ(true, inst->IsVulkanStorageImage()); EXPECT_EQ(false, inst->IsVulkanSampledImage()); EXPECT_EQ(false, inst->IsVulkanStorageTexelBuffer()); } TEST_F(DescriptorTypeTest, GetShader100DebugOpcode) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "NonSemantic.Shader.DebugInfo.100" %2 = OpString "ps.hlsl" %3 = OpString "#line 1 \"ps.hlsl\"" %void = OpTypeVoid %5 = OpExtInst %void %1 DebugExpression %6 = OpExtInst %void %1 DebugSource %2 %3 )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); Instruction* debug_expression = context->get_def_use_mgr()->GetDef(5); EXPECT_EQ(debug_expression->GetShader100DebugOpcode(), NonSemanticShaderDebugInfo100DebugExpression); Instruction* debug_source = context->get_def_use_mgr()->GetDef(6); EXPECT_EQ(debug_source->GetShader100DebugOpcode(), NonSemanticShaderDebugInfo100DebugSource); // Test that an opcode larger than the max will return Max. This instruction // cannot be in the assembly above because the assembler expects the string // for the opcode, so we cannot use an arbitrary number. However, a binary // file could have an arbitrary number. std::unique_ptr past_max(debug_expression->Clone(context.get())); const uint32_t kExtInstOpcodeInIndex = 1; uint32_t large_opcode = NonSemanticShaderDebugInfo100InstructionsMax + 2; past_max->SetInOperand(kExtInstOpcodeInIndex, {large_opcode}); EXPECT_EQ(past_max->GetShader100DebugOpcode(), NonSemanticShaderDebugInfo100InstructionsMax); // Test that an opcode without a value in the enum, but less than Max returns // the same value. uint32_t opcode = NonSemanticShaderDebugInfo100InstructionsMax - 2; past_max->SetInOperand(kExtInstOpcodeInIndex, {opcode}); EXPECT_EQ(past_max->GetShader100DebugOpcode(), opcode); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/interface_var_sroa_test.cpp000066400000000000000000000406011475742701700257120ustar00rootroot00000000000000// Copyright (c) 2022 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using InterfaceVariableScalarReplacementTest = PassTest<::testing::Test>; TEST_F(InterfaceVariableScalarReplacementTest, ReplaceInterfaceVarsWithScalars) { const std::string spirv = R"( OpCapability Shader OpCapability Tessellation OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %func "shader" %x %y %z %w %u %v ; CHECK: OpName [[x:%\w+]] "x" ; CHECK-NOT: OpName {{%\w+}} "x" ; CHECK: OpName [[y:%\w+]] "y" ; CHECK-NOT: OpName {{%\w+}} "y" ; CHECK: OpName [[z0:%\w+]] "z" ; CHECK: OpName [[z1:%\w+]] "z" ; CHECK: OpName [[w0:%\w+]] "w" ; CHECK: OpName [[w1:%\w+]] "w" ; CHECK: OpName [[u0:%\w+]] "u" ; CHECK: OpName [[u1:%\w+]] "u" ; CHECK: OpName [[v0:%\w+]] "v" ; CHECK: OpName [[v1:%\w+]] "v" ; CHECK: OpName [[v2:%\w+]] "v" ; CHECK: OpName [[v3:%\w+]] "v" ; CHECK: OpName [[v4:%\w+]] "v" ; CHECK: OpName [[v5:%\w+]] "v" OpName %x "x" OpName %y "y" OpName %z "z" OpName %w "w" OpName %u "u" OpName %v "v" ; CHECK-DAG: OpDecorate [[x]] Location 2 ; CHECK-DAG: OpDecorate [[y]] Location 0 ; CHECK-DAG: OpDecorate [[z0]] Location 0 ; CHECK-DAG: OpDecorate [[z0]] Component 0 ; CHECK-DAG: OpDecorate [[z1]] Location 1 ; CHECK-DAG: OpDecorate [[z1]] Component 0 ; CHECK-DAG: OpDecorate [[z0]] Patch ; CHECK-DAG: OpDecorate [[z1]] Patch ; CHECK-DAG: OpDecorate [[w0]] Location 2 ; CHECK-DAG: OpDecorate [[w0]] Component 0 ; CHECK-DAG: OpDecorate [[w1]] Location 3 ; CHECK-DAG: OpDecorate [[w1]] Component 0 ; CHECK-DAG: OpDecorate [[w0]] Patch ; CHECK-DAG: OpDecorate [[w1]] Patch ; CHECK-DAG: OpDecorate [[u0]] Location 3 ; CHECK-DAG: OpDecorate [[u0]] Component 2 ; CHECK-DAG: OpDecorate [[u1]] Location 4 ; CHECK-DAG: OpDecorate [[u1]] Component 2 ; CHECK-DAG: OpDecorate [[v0]] Location 3 ; CHECK-DAG: OpDecorate [[v0]] Component 3 ; CHECK-DAG: OpDecorate [[v1]] Location 4 ; CHECK-DAG: OpDecorate [[v1]] Component 3 ; CHECK-DAG: OpDecorate [[v2]] Location 5 ; CHECK-DAG: OpDecorate [[v2]] Component 3 ; CHECK-DAG: OpDecorate [[v3]] Location 6 ; CHECK-DAG: OpDecorate [[v3]] Component 3 ; CHECK-DAG: OpDecorate [[v4]] Location 7 ; CHECK-DAG: OpDecorate [[v4]] Component 3 ; CHECK-DAG: OpDecorate [[v5]] Location 8 ; CHECK-DAG: OpDecorate [[v5]] Component 3 OpDecorate %z Patch OpDecorate %w Patch OpDecorate %z Location 0 OpDecorate %x Location 2 OpDecorate %v Location 3 OpDecorate %v Component 3 OpDecorate %y Location 0 OpDecorate %w Location 2 OpDecorate %u Location 3 OpDecorate %u Component 2 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %uint_3 = OpConstant %uint 3 %uint_4 = OpConstant %uint 4 %_arr_uint_uint_2 = OpTypeArray %uint %uint_2 %_ptr_Output__arr_uint_uint_2 = OpTypePointer Output %_arr_uint_uint_2 %_ptr_Input__arr_uint_uint_2 = OpTypePointer Input %_arr_uint_uint_2 %_ptr_Input_uint = OpTypePointer Input %uint %_ptr_Output_uint = OpTypePointer Output %uint %_arr_arr_uint_uint_2_3 = OpTypeArray %_arr_uint_uint_2 %uint_3 %_ptr_Input__arr_arr_uint_uint_2_3 = OpTypePointer Input %_arr_arr_uint_uint_2_3 %_arr_arr_arr_uint_uint_2_3_4 = OpTypeArray %_arr_arr_uint_uint_2_3 %uint_4 %_ptr_Output__arr_arr_arr_uint_uint_2_3_4 = OpTypePointer Output %_arr_arr_arr_uint_uint_2_3_4 %_ptr_Output__arr_arr_uint_uint_2_3 = OpTypePointer Output %_arr_arr_uint_uint_2_3 %z = OpVariable %_ptr_Output__arr_uint_uint_2 Output %x = OpVariable %_ptr_Output__arr_uint_uint_2 Output %y = OpVariable %_ptr_Input__arr_uint_uint_2 Input %w = OpVariable %_ptr_Input__arr_uint_uint_2 Input %u = OpVariable %_ptr_Input__arr_arr_uint_uint_2_3 Input %v = OpVariable %_ptr_Output__arr_arr_arr_uint_uint_2_3_4 Output ; CHECK-DAG: [[x]] = OpVariable %_ptr_Output__arr_uint_uint_2 Output ; CHECK-DAG: [[y]] = OpVariable %_ptr_Input__arr_uint_uint_2 Input ; CHECK-DAG: [[z0]] = OpVariable %_ptr_Output_uint Output ; CHECK-DAG: [[z1]] = OpVariable %_ptr_Output_uint Output ; CHECK-DAG: [[w0]] = OpVariable %_ptr_Input_uint Input ; CHECK-DAG: [[w1]] = OpVariable %_ptr_Input_uint Input ; CHECK-DAG: [[u0]] = OpVariable %_ptr_Input__arr_uint_uint_3 Input ; CHECK-DAG: [[u1]] = OpVariable %_ptr_Input__arr_uint_uint_3 Input ; CHECK-DAG: [[v0]] = OpVariable %_ptr_Output__arr_uint_uint_4 Output ; CHECK-DAG: [[v1]] = OpVariable %_ptr_Output__arr_uint_uint_4 Output ; CHECK-DAG: [[v2]] = OpVariable %_ptr_Output__arr_uint_uint_4 Output ; CHECK-DAG: [[v3]] = OpVariable %_ptr_Output__arr_uint_uint_4 Output ; CHECK-DAG: [[v4]] = OpVariable %_ptr_Output__arr_uint_uint_4 Output ; CHECK-DAG: [[v5]] = OpVariable %_ptr_Output__arr_uint_uint_4 Output %void = OpTypeVoid %void_f = OpTypeFunction %void %func = OpFunction %void None %void_f %label = OpLabel ; CHECK: [[w0_value:%\w+]] = OpLoad %uint [[w0]] ; CHECK: [[w1_value:%\w+]] = OpLoad %uint [[w1]] ; CHECK: [[w_value:%\w+]] = OpCompositeConstruct %_arr_uint_uint_2 [[w0_value]] [[w1_value]] ; CHECK: [[w0:%\w+]] = OpCompositeExtract %uint [[w_value]] 0 ; CHECK: OpStore [[z0]] [[w0]] ; CHECK: [[w1:%\w+]] = OpCompositeExtract %uint [[w_value]] 1 ; CHECK: OpStore [[z1]] [[w1]] %w_value = OpLoad %_arr_uint_uint_2 %w OpStore %z %w_value ; CHECK: [[u00_ptr:%\w+]] = OpAccessChain %_ptr_Input_uint [[u0]] %uint_0 ; CHECK: [[u00:%\w+]] = OpLoad %uint [[u00_ptr]] ; CHECK: [[u10_ptr:%\w+]] = OpAccessChain %_ptr_Input_uint [[u1]] %uint_0 ; CHECK: [[u10:%\w+]] = OpLoad %uint [[u10_ptr]] ; CHECK: [[u01_ptr:%\w+]] = OpAccessChain %_ptr_Input_uint [[u0]] %uint_1 ; CHECK: [[u01:%\w+]] = OpLoad %uint [[u01_ptr]] ; CHECK: [[u11_ptr:%\w+]] = OpAccessChain %_ptr_Input_uint [[u1]] %uint_1 ; CHECK: [[u11:%\w+]] = OpLoad %uint [[u11_ptr]] ; CHECK: [[u02_ptr:%\w+]] = OpAccessChain %_ptr_Input_uint [[u0]] %uint_2 ; CHECK: [[u02:%\w+]] = OpLoad %uint [[u02_ptr]] ; CHECK: [[u12_ptr:%\w+]] = OpAccessChain %_ptr_Input_uint [[u1]] %uint_2 ; CHECK: [[u12:%\w+]] = OpLoad %uint [[u12_ptr]] ; CHECK-DAG: [[u0_val:%\w+]] = OpCompositeConstruct %_arr_uint_uint_2 [[u00]] [[u10]] ; CHECK-DAG: [[u1_val:%\w+]] = OpCompositeConstruct %_arr_uint_uint_2 [[u01]] [[u11]] ; CHECK-DAG: [[u2_val:%\w+]] = OpCompositeConstruct %_arr_uint_uint_2 [[u02]] [[u12]] ; CHECK: [[u_val:%\w+]] = OpCompositeConstruct %_arr__arr_uint_uint_2_uint_3 [[u0_val]] [[u1_val]] [[u2_val]] ; CHECK: [[ptr:%\w+]] = OpAccessChain %_ptr_Output_uint [[v0]] %uint_1 ; CHECK: [[val:%\w+]] = OpCompositeExtract %uint [[u_val]] 0 0 ; CHECK: OpStore [[ptr]] [[val]] ; CHECK: [[ptr:%\w+]] = OpAccessChain %_ptr_Output_uint [[v1]] %uint_1 ; CHECK: [[val:%\w+]] = OpCompositeExtract %uint [[u_val]] 0 1 ; CHECK: OpStore [[ptr]] [[val]] ; CHECK: [[ptr:%\w+]] = OpAccessChain %_ptr_Output_uint [[v2]] %uint_1 ; CHECK: [[val:%\w+]] = OpCompositeExtract %uint [[u_val]] 1 0 ; CHECK: OpStore [[ptr]] [[val]] ; CHECK: [[ptr:%\w+]] = OpAccessChain %_ptr_Output_uint [[v3]] %uint_1 ; CHECK: [[val:%\w+]] = OpCompositeExtract %uint [[u_val]] 1 1 ; CHECK: OpStore [[ptr]] [[val]] ; CHECK: [[ptr:%\w+]] = OpAccessChain %_ptr_Output_uint [[v4]] %uint_1 ; CHECK: [[val:%\w+]] = OpCompositeExtract %uint [[u_val]] 2 0 ; CHECK: OpStore [[ptr]] [[val]] ; CHECK: [[ptr:%\w+]] = OpAccessChain %_ptr_Output_uint [[v5]] %uint_1 ; CHECK: [[val:%\w+]] = OpCompositeExtract %uint [[u_val]] 2 1 ; CHECK: OpStore [[ptr]] [[val]] %v_ptr = OpAccessChain %_ptr_Output__arr_arr_uint_uint_2_3 %v %uint_1 %u_val = OpLoad %_arr_arr_uint_uint_2_3 %u OpStore %v_ptr %u_val OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(spirv, true); } TEST_F(InterfaceVariableScalarReplacementTest, CheckPatchDecorationPreservation) { // Make sure scalars for the variables with the extra arrayness have the extra // arrayness after running the pass while others do not have it. // Only "y" does not have the extra arrayness in the following SPIR-V. const std::string spirv = R"( OpCapability Shader OpCapability Tessellation OpMemoryModel Logical GLSL450 OpEntryPoint TessellationEvaluation %func "shader" %x %y %z %w OpDecorate %z Patch OpDecorate %w Patch OpDecorate %z Location 0 OpDecorate %x Location 2 OpDecorate %y Location 0 OpDecorate %w Location 1 OpName %x "x" OpName %y "y" OpName %z "z" OpName %w "w" ; CHECK: OpName [[y:%\w+]] "y" ; CHECK-NOT: OpName {{%\w+}} "y" ; CHECK-DAG: OpName [[z0:%\w+]] "z" ; CHECK-DAG: OpName [[z1:%\w+]] "z" ; CHECK-DAG: OpName [[w0:%\w+]] "w" ; CHECK-DAG: OpName [[w1:%\w+]] "w" ; CHECK-DAG: OpName [[x0:%\w+]] "x" ; CHECK-DAG: OpName [[x1:%\w+]] "x" %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_arr_uint_uint_2 = OpTypeArray %uint %uint_2 %_ptr_Output__arr_uint_uint_2 = OpTypePointer Output %_arr_uint_uint_2 %_ptr_Input__arr_uint_uint_2 = OpTypePointer Input %_arr_uint_uint_2 %z = OpVariable %_ptr_Output__arr_uint_uint_2 Output %x = OpVariable %_ptr_Output__arr_uint_uint_2 Output %y = OpVariable %_ptr_Input__arr_uint_uint_2 Input %w = OpVariable %_ptr_Input__arr_uint_uint_2 Input ; CHECK-DAG: [[y]] = OpVariable %_ptr_Input__arr_uint_uint_2 Input ; CHECK-DAG: [[z0]] = OpVariable %_ptr_Output_uint Output ; CHECK-DAG: [[z1]] = OpVariable %_ptr_Output_uint Output ; CHECK-DAG: [[w0]] = OpVariable %_ptr_Input_uint Input ; CHECK-DAG: [[w1]] = OpVariable %_ptr_Input_uint Input ; CHECK-DAG: [[x0]] = OpVariable %_ptr_Output_uint Output ; CHECK-DAG: [[x1]] = OpVariable %_ptr_Output_uint Output %void = OpTypeVoid %void_f = OpTypeFunction %void %func = OpFunction %void None %void_f %label = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(spirv, true); } TEST_F(InterfaceVariableScalarReplacementTest, CheckEntryPointInterfaceOperands) { const std::string spirv = R"( OpCapability Shader OpCapability Tessellation OpMemoryModel Logical GLSL450 OpEntryPoint TessellationEvaluation %tess "tess" %x %y OpEntryPoint Vertex %vert "vert" %w OpDecorate %z Location 0 OpDecorate %x Location 2 OpDecorate %y Location 0 OpDecorate %w Location 1 OpName %x "x" OpName %y "y" OpName %z "z" OpName %w "w" ; CHECK: OpName [[y:%\w+]] "y" ; CHECK-NOT: OpName {{%\w+}} "y" ; CHECK-DAG: OpName [[x0:%\w+]] "x" ; CHECK-DAG: OpName [[x1:%\w+]] "x" ; CHECK-DAG: OpName [[w0:%\w+]] "w" ; CHECK-DAG: OpName [[w1:%\w+]] "w" ; CHECK-DAG: OpName [[z:%\w+]] "z" ; CHECK-NOT: OpName {{%\w+}} "z" %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_arr_uint_uint_2 = OpTypeArray %uint %uint_2 %_ptr_Output__arr_uint_uint_2 = OpTypePointer Output %_arr_uint_uint_2 %_ptr_Input__arr_uint_uint_2 = OpTypePointer Input %_arr_uint_uint_2 %z = OpVariable %_ptr_Output__arr_uint_uint_2 Output %x = OpVariable %_ptr_Output__arr_uint_uint_2 Output %y = OpVariable %_ptr_Input__arr_uint_uint_2 Input %w = OpVariable %_ptr_Input__arr_uint_uint_2 Input ; CHECK-DAG: [[y]] = OpVariable %_ptr_Input__arr_uint_uint_2 Input ; CHECK-DAG: [[z]] = OpVariable %_ptr_Output__arr_uint_uint_2 Output ; CHECK-DAG: [[w0]] = OpVariable %_ptr_Input_uint Input ; CHECK-DAG: [[w1]] = OpVariable %_ptr_Input_uint Input ; CHECK-DAG: [[x0]] = OpVariable %_ptr_Output_uint Output ; CHECK-DAG: [[x1]] = OpVariable %_ptr_Output_uint Output %void = OpTypeVoid %void_f = OpTypeFunction %void %tess = OpFunction %void None %void_f %bb0 = OpLabel OpReturn OpFunctionEnd %vert = OpFunction %void None %void_f %bb1 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(spirv, true); } class InterfaceVarSROAErrorTest : public PassTest<::testing::Test> { public: InterfaceVarSROAErrorTest() : consumer_([this](spv_message_level_t level, const char*, const spv_position_t& position, const char* message) { if (!error_message_.empty()) error_message_ += "\n"; switch (level) { case SPV_MSG_FATAL: case SPV_MSG_INTERNAL_ERROR: case SPV_MSG_ERROR: error_message_ += "ERROR"; break; case SPV_MSG_WARNING: error_message_ += "WARNING"; break; case SPV_MSG_INFO: error_message_ += "INFO"; break; case SPV_MSG_DEBUG: error_message_ += "DEBUG"; break; } error_message_ += ": " + std::to_string(position.index) + ": " + message; }) {} Pass::Status RunPass(const std::string& text) { std::unique_ptr context_ = spvtools::BuildModule(SPV_ENV_UNIVERSAL_1_2, consumer_, text); if (!context_.get()) return Pass::Status::Failure; PassManager manager; manager.SetMessageConsumer(consumer_); manager.AddPass(); return manager.Run(context_.get()); } std::string GetErrorMessage() const { return error_message_; } void TearDown() override { error_message_.clear(); } private: spvtools::MessageConsumer consumer_; std::string error_message_; }; TEST_F(InterfaceVarSROAErrorTest, CheckConflictOfExtraArraynessBetweenEntries) { const std::string spirv = R"( OpCapability Shader OpCapability Tessellation OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %tess "tess" %x %y %z OpEntryPoint Vertex %vert "vert" %z %w OpDecorate %z Location 0 OpDecorate %x Location 2 OpDecorate %y Location 0 OpDecorate %w Location 1 OpName %x "x" OpName %y "y" OpName %z "z" OpName %w "w" %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_arr_uint_uint_2 = OpTypeArray %uint %uint_2 %_ptr_Output__arr_uint_uint_2 = OpTypePointer Output %_arr_uint_uint_2 %_ptr_Input__arr_uint_uint_2 = OpTypePointer Input %_arr_uint_uint_2 %z = OpVariable %_ptr_Output__arr_uint_uint_2 Output %x = OpVariable %_ptr_Output__arr_uint_uint_2 Output %y = OpVariable %_ptr_Input__arr_uint_uint_2 Input %w = OpVariable %_ptr_Input__arr_uint_uint_2 Input %void = OpTypeVoid %void_f = OpTypeFunction %void %tess = OpFunction %void None %void_f %bb0 = OpLabel OpReturn OpFunctionEnd %vert = OpFunction %void None %void_f %bb1 = OpLabel OpReturn OpFunctionEnd )"; EXPECT_EQ(RunPass(spirv), Pass::Status::Failure); const char expected_error[] = "ERROR: 0: A variable is arrayed for an entry point but it is not " "arrayed for another entry point\n" " %z = OpVariable %_ptr_Output__arr_uint_uint_2 Output"; EXPECT_STREQ(GetErrorMessage().c_str(), expected_error); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/interp_fixup_test.cpp000066400000000000000000000151711475742701700245760ustar00rootroot00000000000000// Copyright (c) 2021 The Khronos Group Inc. // Copyright (c) 2021 Valve Corporation // Copyright (c) 2021 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gmock/gmock.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using InterpFixupTest = PassTest<::testing::Test>; using ::testing::HasSubstr; TEST_F(InterpFixupTest, FixInterpAtSample) { const std::string text = R"( OpCapability Shader OpCapability InterpolationFunction %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %MainPs "MainPs" %i_vPositionOs %_entryPointOutput OpExecutionMode %MainPs OriginUpperLeft OpSource HLSL 500 OpName %MainPs "MainPs" OpName %i_vPositionOs "i.vPositionOs" OpName %_entryPointOutput "@entryPointOutput" OpDecorate %i_vPositionOs Location 0 OpDecorate %_entryPointOutput Location 0 %void = OpTypeVoid %6 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %float_0 = OpConstant %float 0 %10 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_4 = OpConstant %uint 4 %bool = OpTypeBool %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %_ptr_Input_v4float = OpTypePointer Input %v4float %i_vPositionOs = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput = OpVariable %_ptr_Output_v4float Output %MainPs = OpFunction %void None %6 %19 = OpLabel %20 = OpLoad %v4float %i_vPositionOs OpBranch %21 %21 = OpLabel %22 = OpPhi %v4float %10 %19 %23 %24 %25 = OpPhi %uint %uint_0 %19 %26 %24 %27 = OpULessThan %bool %25 %uint_4 OpLoopMerge %28 %24 None OpBranchConditional %27 %24 %28 %24 = OpLabel %29 = OpExtInst %v4float %1 InterpolateAtSample %20 %25 ;CHECK: %29 = OpExtInst %v4float %1 InterpolateAtSample %i_vPositionOs %25 %30 = OpCompositeExtract %float %29 0 %31 = OpCompositeExtract %float %22 0 %32 = OpFAdd %float %31 %30 %23 = OpCompositeInsert %v4float %32 %22 0 %26 = OpIAdd %uint %25 %int_1 OpBranch %21 %28 = OpLabel OpStore %_entryPointOutput %22 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(InterpFixupTest, FixInterpAtCentroid) { const std::string text = R"( OpCapability Shader OpCapability InterpolationFunction %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %MainPs "MainPs" %i_vPositionOs %_entryPointOutput OpExecutionMode %MainPs OriginUpperLeft OpSource HLSL 500 OpName %MainPs "MainPs" OpName %i_vPositionOs "i.vPositionOs" OpName %_entryPointOutput "@entryPointOutput" OpDecorate %i_vPositionOs Location 0 OpDecorate %_entryPointOutput Location 0 %void = OpTypeVoid %6 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %float_0 = OpConstant %float 0 %10 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %_ptr_Input_v4float = OpTypePointer Input %v4float %i_vPositionOs = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput = OpVariable %_ptr_Output_v4float Output %MainPs = OpFunction %void None %6 %13 = OpLabel %14 = OpLoad %v4float %i_vPositionOs %15 = OpExtInst %v4float %1 InterpolateAtCentroid %14 ;CHECK: %15 = OpExtInst %v4float %1 InterpolateAtCentroid %i_vPositionOs %16 = OpCompositeExtract %float %15 0 %17 = OpCompositeInsert %v4float %16 %10 0 OpStore %_entryPointOutput %17 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(InterpFixupTest, FixInterpAtOffset) { const std::string text = R"( OpCapability Shader OpCapability InterpolationFunction %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %MainPs "MainPs" %i_vPositionOs %_entryPointOutput OpExecutionMode %MainPs OriginUpperLeft OpSource HLSL 500 OpName %MainPs "MainPs" OpName %i_vPositionOs "i.vPositionOs" OpName %_entryPointOutput "@entryPointOutput" OpDecorate %i_vPositionOs Location 0 OpDecorate %_entryPointOutput Location 0 %void = OpTypeVoid %6 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %float_0 = OpConstant %float 0 %10 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %v2float = OpTypeVector %float 2 %float_0_0625 = OpConstant %float 0.0625 %13 = OpConstantComposite %v2float %float_0_0625 %float_0_0625 %_ptr_Input_v4float = OpTypePointer Input %v4float %i_vPositionOs = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput = OpVariable %_ptr_Output_v4float Output %MainPs = OpFunction %void None %6 %16 = OpLabel %17 = OpLoad %v4float %i_vPositionOs %18 = OpExtInst %v4float %1 InterpolateAtOffset %17 %13 ;CHECK: %18 = OpExtInst %v4float %1 InterpolateAtOffset %i_vPositionOs %13 %19 = OpCompositeExtract %float %18 0 %20 = OpCompositeInsert %v4float %19 %10 0 OpStore %_entryPointOutput %20 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/invocation_interlock_placement_test.cpp000066400000000000000000000526131475742701700303370ustar00rootroot00000000000000// Copyright (c) 2023 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "spirv-tools/optimizer.hpp" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using InterlockInvocationPlacementTest = PassTest<::testing::Test>; TEST_F(InterlockInvocationPlacementTest, CheckUnchangedIfNotFragment) { const std::string kTest = R"( OpCapability Shader OpCapability FragmentShaderSampleInterlockEXT OpExtension "SPV_EXT_fragment_shader_interlock" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpExecutionMode %main SampleInterlockOrderedEXT OpName %main "main" %void = OpTypeVoid %1 = OpTypeFunction %void %main = OpFunction %void None %1 %2 = OpLabel OpBeginInvocationInterlockEXT OpBeginInvocationInterlockEXT OpEndInvocationInterlockEXT OpBeginInvocationInterlockEXT OpEndInvocationInterlockEXT OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); EXPECT_EQ( Pass::Status::SuccessWithoutChange, std::get<1>(SinglePassRunAndDisassemble( kTest, /* skip_nop= */ false, /* do_validation= */ false))); } TEST_F(InterlockInvocationPlacementTest, CheckUnchangedWithoutCapability) { const std::string kTest = R"( OpCapability Shader OpExtension "SPV_EXT_fragment_shader_interlock" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpExecutionMode %main SampleInterlockOrderedEXT OpName %main "main" %void = OpTypeVoid %1 = OpTypeFunction %void %main = OpFunction %void None %1 %2 = OpLabel OpBeginInvocationInterlockEXT OpBeginInvocationInterlockEXT OpEndInvocationInterlockEXT OpBeginInvocationInterlockEXT OpEndInvocationInterlockEXT OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); EXPECT_EQ( Pass::Status::SuccessWithoutChange, std::get<1>(SinglePassRunAndDisassemble( kTest, /* skip_nop= */ false, /* do_validation= */ false))); } TEST_F(InterlockInvocationPlacementTest, CheckSingleBasicBlock) { // We're using OpNoLine as a generic standin for any other instruction, to // test that begin and end aren't moved. const std::string kTest = R"( OpCapability Shader OpCapability FragmentShaderSampleInterlockEXT OpExtension "SPV_EXT_fragment_shader_interlock" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpExecutionMode %main SampleInterlockOrderedEXT OpName %main "main" %void = OpTypeVoid %1 = OpTypeFunction %void %main = OpFunction %void None %1 ; CHECK: OpLabel %2 = OpLabel ; CHECK-NEXT: OpNoLine OpNoLine ; CHECK-NEXT: OpBeginInvocationInterlockEXT OpBeginInvocationInterlockEXT OpBeginInvocationInterlockEXT OpEndInvocationInterlockEXT OpBeginInvocationInterlockEXT ; CHECK-NEXT: OpNoLine OpNoLine ; CHECK-NEXT: OpEndInvocationInterlockEXT OpEndInvocationInterlockEXT ; CHECK-NEXT: OpNoLine OpNoLine ; CHECK-NEXT: OpReturn OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); const auto result = SinglePassRunAndMatch( kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(InterlockInvocationPlacementTest, CheckFunctionCallExtractionBegin) { const std::string kTest = R"( OpCapability Shader OpCapability FragmentShaderSampleInterlockEXT OpExtension "SPV_EXT_fragment_shader_interlock" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpExecutionMode %main SampleInterlockOrderedEXT OpName %main "main" %void = OpTypeVoid %1 = OpTypeFunction %void %foo = OpFunction %void None %1 ; CHECK: OpLabel ; CHECK-NOT: OpBeginInvocationInterlockEXT %2 = OpLabel OpBeginInvocationInterlockEXT OpBeginInvocationInterlockEXT OpReturn ; CHECK: OpFunctionEnd OpFunctionEnd %main = OpFunction %void None %1 ; CHECK: OpLabel %3 = OpLabel ; CHECK-NEXT: OpBeginInvocationInterlockEXT ; CHECK-NEXT: OpFunctionCall %4 = OpFunctionCall %void %foo ; CHECK-NEXT: OpReturn OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); const auto result = SinglePassRunAndMatch( kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(InterlockInvocationPlacementTest, CheckFunctionCallExtractionEnd) { const std::string kTest = R"( OpCapability Shader OpCapability FragmentShaderSampleInterlockEXT OpExtension "SPV_EXT_fragment_shader_interlock" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpExecutionMode %main SampleInterlockOrderedEXT OpName %main "main" %void = OpTypeVoid %1 = OpTypeFunction %void %foo = OpFunction %void None %1 ; CHECK: OpLabel ; CHECK-NOT: OpEndInvocationInterlockEXT %2 = OpLabel OpEndInvocationInterlockEXT OpEndInvocationInterlockEXT OpReturn ; CHECK: OpFunctionEnd OpFunctionEnd %main = OpFunction %void None %1 ; CHECK: OpLabel %3 = OpLabel ; CHECK-NEXT: OpFunctionCall %4 = OpFunctionCall %void %foo ; CHECK-NEXT: OpEndInvocationInterlockEXT ; CHECK-NEXT: OpReturn OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); const auto result = SinglePassRunAndMatch( kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(InterlockInvocationPlacementTest, CheckFunctionCallExtractionRepeatedCall) { const std::string kTest = R"( OpCapability Shader OpCapability FragmentShaderSampleInterlockEXT OpExtension "SPV_EXT_fragment_shader_interlock" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpExecutionMode %main SampleInterlockOrderedEXT OpName %main "main" %void = OpTypeVoid %1 = OpTypeFunction %void %foo = OpFunction %void None %1 ; CHECK: OpLabel ; CHECK-NOT: OpBeginInvocationInterlockEXT ; CHECK-NOT: OpEndInvocationInterlockEXT %2 = OpLabel OpBeginInvocationInterlockEXT OpEndInvocationInterlockEXT OpReturn ; CHECK: OpFunctionEnd OpFunctionEnd %main = OpFunction %void None %1 ; CHECK: OpLabel %3 = OpLabel ; CHECK-NEXT: OpBeginInvocationInterlockEXT ; CHECK-NEXT: OpFunctionCall %4 = OpFunctionCall %void %foo ; CHECK-NEXT: OpFunctionCall %5 = OpFunctionCall %void %foo ; CHECK-NEXT: OpEndInvocationInterlockEXT ; CHECK-NEXT: OpReturn OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); const auto result = SinglePassRunAndMatch( kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(InterlockInvocationPlacementTest, CheckFunctionCallExtractionNestedCall) { const std::string kTest = R"( OpCapability Shader OpCapability FragmentShaderSampleInterlockEXT OpExtension "SPV_EXT_fragment_shader_interlock" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpExecutionMode %main SampleInterlockOrderedEXT OpName %main "main" %void = OpTypeVoid %1 = OpTypeFunction %void %foo = OpFunction %void None %1 ; CHECK: OpLabel ; CHECK-NOT: OpBeginInvocationInterlockEXT ; CHECK-NOT: OpEndInvocationInterlockEXT %2 = OpLabel OpBeginInvocationInterlockEXT OpEndInvocationInterlockEXT OpReturn ; CHECK: OpFunctionEnd OpFunctionEnd %bar = OpFunction %void None %1 ; CHECK: OpLabel ; CHECK-NOT: OpBeginInvocationInterlockEXT ; CHECK-NOT: OpEndInvocationInterlockEXT %3 = OpLabel %4 = OpFunctionCall %void %foo OpReturn ; CHECK: OpFunctionEnd OpFunctionEnd %main = OpFunction %void None %1 ; CHECK: OpLabel %5 = OpLabel ; CHECK-NEXT: OpBeginInvocationInterlockEXT ; CHECK-NEXT: OpFunctionCall %6 = OpFunctionCall %void %bar ; CHECK-NEXT: OpEndInvocationInterlockEXT ; CHECK-NEXT: OpReturn OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); const auto result = SinglePassRunAndMatch( kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(InterlockInvocationPlacementTest, CheckLoopExtraction) { // Tests that any begin or end instructions in a loop are moved outside of the // loop. const std::string kTest = R"( OpCapability Shader OpCapability FragmentShaderSampleInterlockEXT OpExtension "SPV_EXT_fragment_shader_interlock" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpExecutionMode %main SampleInterlockOrderedEXT %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %1 = OpTypeFunction %void %main = OpFunction %void None %1 %2 = OpLabel ; CHECK: OpBeginInvocationInterlockEXT ; CHECK-NOT: OpBeginInvocationInterlockEXT ; CHECK-NOT: OpEndInvocationInterlockEXT OpBranch %3 %3 = OpLabel OpLoopMerge %3 %4 None ; CHECK: OpBranchConditional ; CHECK-NOT: OpBeginInvocationInterlockEXT ; CHECK-NOT: OpEndInvocationInterlockEXT OpBranchConditional %true %4 %5 %4 = OpLabel OpBeginInvocationInterlockEXT OpEndInvocationInterlockEXT ; CHECK: OpBranch OpBranch %3 ; CHECK-NEXT: OpLabel %5 = OpLabel ; CHECK-NEXT: OpEndInvocationInterlockEXT ; CHECK-NOT: OpEndInvocationInterlockEXT OpEndInvocationInterlockEXT OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); const auto result = SinglePassRunAndMatch( kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(InterlockInvocationPlacementTest, CheckAddBeginToElse) { // Test that if there is a begin in a single branch of a conditional, begin // will be added to the other branch. const std::string kTest = R"( OpCapability Shader OpCapability FragmentShaderSampleInterlockEXT OpExtension "SPV_EXT_fragment_shader_interlock" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpExecutionMode %main SampleInterlockOrderedEXT OpName %main "main" %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %1 = OpTypeFunction %void %main = OpFunction %void None %1 %2 = OpLabel ; CHECK-NOT: OpBeginInvocationInterlockEXT OpSelectionMerge %5 None ; CHECK: OpBranchConditional OpBranchConditional %true %3 %4 ; CHECK-NEXT: OpLabel %3 = OpLabel ; CHECK-NEXT: OpBeginInvocationInterlockEXT OpBeginInvocationInterlockEXT OpEndInvocationInterlockEXT ; CHECK-NEXT: OpBranch OpBranch %5 %4 = OpLabel ; CHECK: OpBeginInvocationInterlockEXT ; CHECK-NEXT: OpBranch OpBranch %5 ; CHECK-NEXT: OpLabel %5 = OpLabel OpBeginInvocationInterlockEXT ; CHECK-NEXT: OpEndInvocationInterlockEXT OpEndInvocationInterlockEXT OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); const auto result = SinglePassRunAndMatch( kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(InterlockInvocationPlacementTest, CheckAddEndToElse) { const std::string kTest = R"( OpCapability Shader OpCapability FragmentShaderSampleInterlockEXT OpExtension "SPV_EXT_fragment_shader_interlock" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpExecutionMode %main SampleInterlockOrderedEXT OpName %main "main" %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %1 = OpTypeFunction %void %main = OpFunction %void None %1 %2 = OpLabel ; CHECK: OpBeginInvocationInterlockEXT OpBeginInvocationInterlockEXT ; CHECK-NOT: OpEndInvocationInterlockEXT OpEndInvocationInterlockEXT OpSelectionMerge %5 None ; CHECK: OpBranchConditional OpBranchConditional %true %3 %4 ; CHECK-NEXT: OpLabel %3 = OpLabel OpBeginInvocationInterlockEXT ; CHECK-NEXT: OpEndInvocationInterlockEXT OpEndInvocationInterlockEXT ; CHECK-NEXT: OpBranch OpBranch %5 %4 = OpLabel ; CHECK: OpEndInvocationInterlockEXT ; CHECK-NEXT: OpBranch OpBranch %5 ; CHECK-NEXT: OpLabel %5 = OpLabel ; CHECK-NOT: OpEndInvocationInterlockEXT OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); const auto result = SinglePassRunAndMatch( kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(InterlockInvocationPlacementTest, CheckSplitIfWithoutElseBegin) { // Test that if there is a begin in the then branch of a conditional, and no // else branch, an else branch with a begin will created. const std::string kTest = R"( OpCapability Shader OpCapability FragmentShaderSampleInterlockEXT OpExtension "SPV_EXT_fragment_shader_interlock" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpExecutionMode %main SampleInterlockOrderedEXT OpName %main "main" %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %1 = OpTypeFunction %void %main = OpFunction %void None %1 %2 = OpLabel ; CHECK-NOT: OpBeginInvocationInterlockEXT OpSelectionMerge %5 None ; CHECK: OpBranchConditional OpBranchConditional %true %3 %5 ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpBeginInvocationInterlockEXT ; CHECK-NEXT: OpBranch ; CHECK-NEXT: OpLabel %3 = OpLabel ; CHECK-NEXT: OpBeginInvocationInterlockEXT ; CHECK-NOT: OpEndInvocationInterlockEXT OpBeginInvocationInterlockEXT OpEndInvocationInterlockEXT OpBranch %5 ; CHECK: OpLabel %5 = OpLabel ; CHECK-NOT: OpBeginInvocationInterlockEXT OpBeginInvocationInterlockEXT ; CHECK-NEXT: OpEndInvocationInterlockEXT OpEndInvocationInterlockEXT OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); const auto result = SinglePassRunAndMatch( kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(InterlockInvocationPlacementTest, CheckSplitIfWithoutElseEnd) { const std::string kTest = R"( OpCapability Shader OpCapability FragmentShaderSampleInterlockEXT OpExtension "SPV_EXT_fragment_shader_interlock" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpExecutionMode %main SampleInterlockOrderedEXT OpName %main "main" %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %1 = OpTypeFunction %void %main = OpFunction %void None %1 %2 = OpLabel ; CHECK: OpBeginInvocationInterlockEXT OpBeginInvocationInterlockEXT ; CHECK-NOT: OpEndInvocationInterlockEXT OpEndInvocationInterlockEXT ; CHECK-NEXT: OpSelectionMerge [[merge:%\d+]] OpSelectionMerge %5 None ; CHECK-NEXT: OpBranchConditional %true [[then:%\d+]] [[else:%\d+]] OpBranchConditional %true %3 %5 ; CHECK-NEXT: [[else]] = OpLabel ; CHECK-NEXT: OpEndInvocationInterlockEXT ; CHECK-NEXT: OpBranch [[merge]] ; CHECK-NEXT: [[then]] = OpLabel %3 = OpLabel ; CHECK-NEXT: OpEndInvocationInterlockEXT OpBeginInvocationInterlockEXT OpEndInvocationInterlockEXT ; CHECK-NEXT: OpBranch [[merge]] OpBranch %5 ; CHECK-NEXT: [[merge]] = OpLabel %5 = OpLabel ; CHECK-NEXT: OpReturn OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); const auto result = SinglePassRunAndMatch( kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(InterlockInvocationPlacementTest, CheckSplitSwitch) { // Test that if there is a begin or end in a single branch of a switch, begin // or end will be added to all the other branches. const std::string kTest = R"( OpCapability Shader OpCapability FragmentShaderSampleInterlockEXT OpExtension "SPV_EXT_fragment_shader_interlock" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpExecutionMode %main SampleInterlockOrderedEXT OpName %main "main" %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %1 = OpTypeFunction %void %main = OpFunction %void None %1 ; CHECK: OpLabel %2 = OpLabel ; CHECK-NEXT: OpSelectionMerge [[merge:%\d+]] OpSelectionMerge %8 None ; CHECK-NEXT: OpSwitch %uint_1 [[default:%\d+]] 0 [[case_0:%\d+]] 1 [[case_1:%\d+]] 2 [[case_2:%\d+]] OpSwitch %uint_1 %8 0 %4 1 %5 2 %8 ; CHECK-NEXT: [[case_2]] = OpLabel ; CHECK-NEXT: OpBeginInvocationInterlockEXT ; CHECK-NEXT: OpBranch [[merge]] ; CHECK-NEXT: [[default]] = OpLabel ; CHECK-NEXT: OpBeginInvocationInterlockEXT ; CHECK-NEXT: OpBranch [[merge]] ; CHECK-NEXT: [[case_0]] = OpLabel %4 = OpLabel ; CHECK-NEXT: OpBeginInvocationInterlockEXT ; CHECK-NOT: OpEndInvocationInterlockEXT OpBeginInvocationInterlockEXT OpEndInvocationInterlockEXT ; CHECK-NEXT: OpNoLine OpNoLine ; CHECK-NEXT: OpBranch [[merge]] OpBranch %8 ; CHECK-NEXT: [[case_1]] = OpLabel %5 = OpLabel ; CHECK-NEXT: OpBeginInvocationInterlockEXT ; CHECK-NOT: OpEndInvocationInterlockEXT OpBeginInvocationInterlockEXT OpEndInvocationInterlockEXT ; CHECK-NEXT: OpNoLine OpNoLine ; CHECK-NEXT: OpNoLine OpNoLine ; CHECK-NEXT: OpBranch [[merge]] OpBranch %8 ; CHECK-NEXT: [[merge]] = OpLabel %8 = OpLabel ; CHECK-NOT: OpBeginInvocationInterlockEXT OpBeginInvocationInterlockEXT ; CHECK-NEXT: OpEndInvocationInterlockEXT OpEndInvocationInterlockEXT OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); const auto result = SinglePassRunAndMatch( kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/ir_builder.cpp000066400000000000000000000346771475742701700231570ustar00rootroot00000000000000// Copyright (c) 2018 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/ir_builder.h" #include #include #include "effcee/effcee.h" #include "gtest/gtest.h" #include "source/opt/basic_block.h" #include "source/opt/build_module.h" #include "source/opt/instruction.h" #include "source/opt/type_manager.h" #include "spirv-tools/libspirv.hpp" namespace spvtools { namespace opt { namespace { using Analysis = IRContext::Analysis; using IRBuilderTest = ::testing::Test; bool Validate(const std::vector& bin) { spv_target_env target_env = SPV_ENV_UNIVERSAL_1_2; spv_context spvContext = spvContextCreate(target_env); spv_diagnostic diagnostic = nullptr; spv_const_binary_t binary = {bin.data(), bin.size()}; spv_result_t error = spvValidate(spvContext, &binary, &diagnostic); if (error != 0) spvDiagnosticPrint(diagnostic); spvDiagnosticDestroy(diagnostic); spvContextDestroy(spvContext); return error == 0; } void Match(const std::string& original, IRContext* context, bool do_validation = true) { std::vector bin; context->module()->ToBinary(&bin, true); if (do_validation) { EXPECT_TRUE(Validate(bin)); } std::string assembly; SpirvTools tools(SPV_ENV_UNIVERSAL_1_2); EXPECT_TRUE( tools.Disassemble(bin, &assembly, SpirvTools::kDefaultDisassembleOption)) << "Disassembling failed for shader:\n" << assembly << std::endl; auto match_result = effcee::Match(assembly, original); EXPECT_EQ(effcee::Result::Status::Ok, match_result.status()) << match_result.message() << "\nChecking result:\n" << assembly; } TEST_F(IRBuilderTest, TestInsnAddition) { const std::string text = R"( ; CHECK: %18 = OpLabel ; CHECK: OpPhi %int %int_0 %14 ; CHECK: OpPhi %bool %16 %14 ; CHECK: OpBranch %17 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 330 OpName %2 "main" OpName %4 "i" OpName %3 "c" OpDecorate %3 Location 0 %5 = OpTypeVoid %6 = OpTypeFunction %5 %7 = OpTypeInt 32 1 %8 = OpTypePointer Function %7 %9 = OpConstant %7 0 %10 = OpTypeBool %11 = OpTypeFloat 32 %12 = OpTypeVector %11 4 %13 = OpTypePointer Output %12 %3 = OpVariable %13 Output %2 = OpFunction %5 None %6 %14 = OpLabel %4 = OpVariable %8 Function OpStore %4 %9 %15 = OpLoad %7 %4 %16 = OpINotEqual %10 %15 %9 OpSelectionMerge %17 None OpBranchConditional %16 %18 %17 %18 = OpLabel OpBranch %17 %17 = OpLabel OpReturn OpFunctionEnd )"; { std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); BasicBlock* bb = context->cfg()->block(18); // Build managers. context->get_def_use_mgr(); context->get_instr_block(nullptr); InstructionBuilder builder(context.get(), &*bb->begin()); Instruction* phi1 = builder.AddPhi(7, {9, 14}); Instruction* phi2 = builder.AddPhi(10, {16, 14}); // Make sure the InstructionBuilder did not update the def/use manager. EXPECT_EQ(context->get_def_use_mgr()->GetDef(phi1->result_id()), nullptr); EXPECT_EQ(context->get_def_use_mgr()->GetDef(phi2->result_id()), nullptr); EXPECT_EQ(context->get_instr_block(phi1), nullptr); EXPECT_EQ(context->get_instr_block(phi2), nullptr); Match(text, context.get()); } { std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); // Build managers. context->get_def_use_mgr(); context->get_instr_block(nullptr); BasicBlock* bb = context->cfg()->block(18); InstructionBuilder builder( context.get(), &*bb->begin(), IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); Instruction* phi1 = builder.AddPhi(7, {9, 14}); Instruction* phi2 = builder.AddPhi(10, {16, 14}); // Make sure InstructionBuilder updated the def/use manager EXPECT_NE(context->get_def_use_mgr()->GetDef(phi1->result_id()), nullptr); EXPECT_NE(context->get_def_use_mgr()->GetDef(phi2->result_id()), nullptr); EXPECT_NE(context->get_instr_block(phi1), nullptr); EXPECT_NE(context->get_instr_block(phi2), nullptr); Match(text, context.get()); } } TEST_F(IRBuilderTest, TestCondBranchAddition) { const std::string text = R"( ; CHECK: %main = OpFunction %void None %6 ; CHECK-NEXT: %15 = OpLabel ; CHECK-NEXT: OpSelectionMerge %13 None ; CHECK-NEXT: OpBranchConditional %true %14 %13 ; CHECK-NEXT: %14 = OpLabel ; CHECK-NEXT: OpBranch %13 ; CHECK-NEXT: %13 = OpLabel ; CHECK-NEXT: OpReturn OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 330 OpName %2 "main" OpName %4 "i" OpName %3 "c" OpDecorate %3 Location 0 %5 = OpTypeVoid %6 = OpTypeFunction %5 %7 = OpTypeBool %8 = OpTypePointer Private %7 %9 = OpConstantTrue %7 %10 = OpTypeFloat 32 %11 = OpTypeVector %10 4 %12 = OpTypePointer Output %11 %3 = OpVariable %12 Output %4 = OpVariable %8 Private %2 = OpFunction %5 None %6 %13 = OpLabel OpReturn OpFunctionEnd )"; { std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); Function& fn = *context->module()->begin(); BasicBlock& bb_merge = *fn.begin(); // TODO(1841): Handle id overflow. fn.begin().InsertBefore(std::unique_ptr( new BasicBlock(std::unique_ptr(new Instruction( context.get(), spv::Op::OpLabel, 0, context->TakeNextId(), {}))))); BasicBlock& bb_true = *fn.begin(); { InstructionBuilder builder(context.get(), &*bb_true.begin()); builder.AddBranch(bb_merge.id()); } // TODO(1841): Handle id overflow. fn.begin().InsertBefore(std::unique_ptr( new BasicBlock(std::unique_ptr(new Instruction( context.get(), spv::Op::OpLabel, 0, context->TakeNextId(), {}))))); BasicBlock& bb_cond = *fn.begin(); InstructionBuilder builder(context.get(), &bb_cond); // This also test consecutive instruction insertion: merge selection + // branch. builder.AddConditionalBranch(9, bb_true.id(), bb_merge.id(), bb_merge.id()); Match(text, context.get()); } } TEST_F(IRBuilderTest, AddSelect) { const std::string text = R"( ; CHECK: [[bool:%\w+]] = OpTypeBool ; CHECK: [[uint:%\w+]] = OpTypeInt 32 0 ; CHECK: [[true:%\w+]] = OpConstantTrue [[bool]] ; CHECK: [[u0:%\w+]] = OpConstant [[uint]] 0 ; CHECK: [[u1:%\w+]] = OpConstant [[uint]] 1 ; CHECK: OpSelect [[uint]] [[true]] [[u0]] [[u1]] OpCapability Kernel OpCapability Linkage OpMemoryModel Logical OpenCL %1 = OpTypeVoid %2 = OpTypeBool %3 = OpTypeInt 32 0 %4 = OpConstantTrue %2 %5 = OpConstant %3 0 %6 = OpConstant %3 1 %7 = OpTypeFunction %1 %8 = OpFunction %1 None %7 %9 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); EXPECT_NE(nullptr, context); InstructionBuilder builder(context.get(), &*context->module()->begin()->begin()->begin()); EXPECT_NE(nullptr, builder.AddSelect(3u, 4u, 5u, 6u)); Match(text, context.get()); } TEST_F(IRBuilderTest, AddVariable) { // Use Private beacuse its' enun is 7 which is higher // than the ID limit. const std::string text = R"( ; CHECK: [[uint:%\w+]] = OpTypeInt 32 0 ; CHECK: [[ptr:%\w+]] = OpTypePointer Private [[uint]] ; CHECK: [[var:%\w+]] = OpVariable [[ptr]] Private ; CHECK: OpTypeFloat OpCapability Kernel OpCapability VectorComputeINTEL OpCapability Linkage OpExtension "SPV_INTEL_vector_compute" OpMemoryModel Logical OpenCL %1 = OpTypeInt 32 0 %2 = OpTypePointer Private %1 %3 = OpTypeFloat 32 )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); EXPECT_NE(nullptr, context) << text; auto* float_ty = context->get_def_use_mgr()->GetDef(3); InstructionBuilder builder(context.get(), float_ty); auto* var = builder.AddVariable(2u, uint32_t(spv::StorageClass::Private)); EXPECT_NE(nullptr, var); context->get_def_use_mgr()->AnalyzeInstDefUse(var); // should not assert Match(text, context.get()); } TEST_F(IRBuilderTest, AddCompositeConstruct) { const std::string text = R"( ; CHECK: [[uint:%\w+]] = OpTypeInt ; CHECK: [[u0:%\w+]] = OpConstant [[uint]] 0 ; CHECK: [[u1:%\w+]] = OpConstant [[uint]] 1 ; CHECK: [[struct:%\w+]] = OpTypeStruct [[uint]] [[uint]] [[uint]] [[uint]] ; CHECK: OpCompositeConstruct [[struct]] [[u0]] [[u1]] [[u1]] [[u0]] OpCapability Kernel OpCapability Linkage OpMemoryModel Logical OpenCL %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpConstant %2 0 %4 = OpConstant %2 1 %5 = OpTypeStruct %2 %2 %2 %2 %6 = OpTypeFunction %1 %7 = OpFunction %1 None %6 %8 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); EXPECT_NE(nullptr, context); InstructionBuilder builder(context.get(), &*context->module()->begin()->begin()->begin()); std::vector ids = {3u, 4u, 4u, 3u}; EXPECT_NE(nullptr, builder.AddCompositeConstruct(5u, ids)); Match(text, context.get()); } TEST_F(IRBuilderTest, ConstantAdder) { const std::string text = R"( ; CHECK: [[uint:%\w+]] = OpTypeInt 32 0 ; CHECK: OpConstant [[uint]] 13 ; CHECK: [[sint:%\w+]] = OpTypeInt 32 1 ; CHECK: OpConstant [[sint]] -1 ; CHECK: OpConstant [[uint]] 1 ; CHECK: OpConstant [[sint]] 34 ; CHECK: OpConstant [[uint]] 0 ; CHECK: OpConstant [[sint]] 0 OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpFunction %1 None %2 %4 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); EXPECT_NE(nullptr, context); InstructionBuilder builder(context.get(), &*context->module()->begin()->begin()->begin()); EXPECT_NE(nullptr, builder.GetUintConstant(13)); EXPECT_NE(nullptr, builder.GetSintConstant(-1)); // Try adding the same constants again to make sure they aren't added. EXPECT_NE(nullptr, builder.GetUintConstant(13)); EXPECT_NE(nullptr, builder.GetSintConstant(-1)); // Try adding different constants to make sure the type is reused. EXPECT_NE(nullptr, builder.GetUintConstant(1)); EXPECT_NE(nullptr, builder.GetSintConstant(34)); // Try adding 0 as both signed and unsigned. EXPECT_NE(nullptr, builder.GetUintConstant(0)); EXPECT_NE(nullptr, builder.GetSintConstant(0)); Match(text, context.get()); } TEST_F(IRBuilderTest, ConstantAdderTypeAlreadyExists) { const std::string text = R"( ; CHECK: OpConstant %uint 13 ; CHECK: OpConstant %int -1 ; CHECK: OpConstant %uint 1 ; CHECK: OpConstant %int 34 ; CHECK: OpConstant %uint 0 ; CHECK: OpConstant %int 0 OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeVoid %uint = OpTypeInt 32 0 %int = OpTypeInt 32 1 %4 = OpTypeFunction %1 %5 = OpFunction %1 None %4 %6 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); EXPECT_NE(nullptr, context); InstructionBuilder builder(context.get(), &*context->module()->begin()->begin()->begin()); Instruction* const_1 = builder.GetUintConstant(13); Instruction* const_2 = builder.GetSintConstant(-1); EXPECT_NE(nullptr, const_1); EXPECT_NE(nullptr, const_2); // Try adding the same constants again to make sure they aren't added. EXPECT_EQ(const_1, builder.GetUintConstant(13)); EXPECT_EQ(const_2, builder.GetSintConstant(-1)); Instruction* const_3 = builder.GetUintConstant(1); Instruction* const_4 = builder.GetSintConstant(34); // Try adding different constants to make sure the type is reused. EXPECT_NE(nullptr, const_3); EXPECT_NE(nullptr, const_4); Instruction* const_5 = builder.GetUintConstant(0); Instruction* const_6 = builder.GetSintConstant(0); // Try adding 0 as both signed and unsigned. EXPECT_NE(nullptr, const_5); EXPECT_NE(nullptr, const_6); // They have the same value but different types so should be unique. EXPECT_NE(const_5, const_6); // Check the types are correct. uint32_t type_id_unsigned = const_1->GetSingleWordOperand(0); uint32_t type_id_signed = const_2->GetSingleWordOperand(0); EXPECT_NE(type_id_unsigned, type_id_signed); EXPECT_EQ(const_3->GetSingleWordOperand(0), type_id_unsigned); EXPECT_EQ(const_5->GetSingleWordOperand(0), type_id_unsigned); EXPECT_EQ(const_4->GetSingleWordOperand(0), type_id_signed); EXPECT_EQ(const_6->GetSingleWordOperand(0), type_id_signed); Match(text, context.get()); } TEST_F(IRBuilderTest, AccelerationStructureNV) { const std::string text = R"( ; CHECK: OpTypeAccelerationStructureKHR OpCapability Shader OpCapability RayTracingNV OpExtension "SPV_NV_ray_tracing" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %8 "main" OpExecutionMode %8 OriginUpperLeft %1 = OpTypeVoid %2 = OpTypeBool %3 = OpTypeAccelerationStructureNV %7 = OpTypeFunction %1 %8 = OpFunction %1 None %7 %9 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); EXPECT_NE(nullptr, context); InstructionBuilder builder(context.get(), &*context->module()->begin()->begin()->begin()); Match(text, context.get()); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/ir_context_test.cpp000066400000000000000000001540531475742701700242430ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/ir_context.h" #include #include #include #include "OpenCLDebugInfo100.h" #include "gmock/gmock.h" #include "gtest/gtest.h" #include "source/opt/pass.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" static const uint32_t kDebugDeclareOperandVariableIndex = 5; static const uint32_t kDebugValueOperandValueIndex = 5; namespace spvtools { namespace opt { namespace { using Analysis = IRContext::Analysis; using ::testing::Each; using ::testing::UnorderedElementsAre; class NoopPassPreservesNothing : public Pass { public: NoopPassPreservesNothing(Status s) : Pass(), status_to_return_(s) {} const char* name() const override { return "noop-pass"; } Status Process() override { return status_to_return_; } private: Status status_to_return_; }; class NoopPassPreservesAll : public Pass { public: NoopPassPreservesAll(Status s) : Pass(), status_to_return_(s) {} const char* name() const override { return "noop-pass"; } Status Process() override { return status_to_return_; } Analysis GetPreservedAnalyses() override { return Analysis(IRContext::kAnalysisEnd - 1); } private: Status status_to_return_; }; class NoopPassPreservesFirst : public Pass { public: NoopPassPreservesFirst(Status s) : Pass(), status_to_return_(s) {} const char* name() const override { return "noop-pass"; } Status Process() override { return status_to_return_; } Analysis GetPreservedAnalyses() override { return IRContext::kAnalysisBegin; } private: Status status_to_return_; }; using IRContextTest = PassTest<::testing::Test>; TEST_F(IRContextTest, IndividualValidAfterBuild) { std::unique_ptr module(new Module()); IRContext localContext(SPV_ENV_UNIVERSAL_1_2, std::move(module), spvtools::MessageConsumer()); for (Analysis i = IRContext::kAnalysisBegin; i < IRContext::kAnalysisEnd; i <<= 1) { localContext.BuildInvalidAnalyses(i); EXPECT_TRUE(localContext.AreAnalysesValid(i)); } } TEST_F(IRContextTest, DontRebuildValidAnalysis) { std::unique_ptr module(new Module()); IRContext localContext(SPV_ENV_UNIVERSAL_1_2, std::move(module), spvtools::MessageConsumer()); auto* oldCfg = localContext.cfg(); auto* oldDefUse = localContext.get_def_use_mgr(); localContext.BuildInvalidAnalyses(IRContext::kAnalysisCFG | IRContext::kAnalysisDefUse); auto* newCfg = localContext.cfg(); auto* newDefUse = localContext.get_def_use_mgr(); EXPECT_EQ(oldCfg, newCfg); EXPECT_EQ(oldDefUse, newDefUse); } TEST_F(IRContextTest, AllValidAfterBuild) { std::unique_ptr module = MakeUnique(); IRContext localContext(SPV_ENV_UNIVERSAL_1_2, std::move(module), spvtools::MessageConsumer()); Analysis built_analyses = IRContext::kAnalysisNone; for (Analysis i = IRContext::kAnalysisBegin; i < IRContext::kAnalysisEnd; i <<= 1) { localContext.BuildInvalidAnalyses(i); built_analyses |= i; } EXPECT_TRUE(localContext.AreAnalysesValid(built_analyses)); } TEST_F(IRContextTest, AllValidAfterPassNoChange) { std::unique_ptr module = MakeUnique(); IRContext localContext(SPV_ENV_UNIVERSAL_1_2, std::move(module), spvtools::MessageConsumer()); Analysis built_analyses = IRContext::kAnalysisNone; for (Analysis i = IRContext::kAnalysisBegin; i < IRContext::kAnalysisEnd; i <<= 1) { localContext.BuildInvalidAnalyses(i); built_analyses |= i; } NoopPassPreservesNothing pass(Pass::Status::SuccessWithoutChange); Pass::Status s = pass.Run(&localContext); EXPECT_EQ(s, Pass::Status::SuccessWithoutChange); EXPECT_TRUE(localContext.AreAnalysesValid(built_analyses)); } TEST_F(IRContextTest, NoneValidAfterPassWithChange) { std::unique_ptr module = MakeUnique(); IRContext localContext(SPV_ENV_UNIVERSAL_1_2, std::move(module), spvtools::MessageConsumer()); for (Analysis i = IRContext::kAnalysisBegin; i < IRContext::kAnalysisEnd; i <<= 1) { localContext.BuildInvalidAnalyses(i); } NoopPassPreservesNothing pass(Pass::Status::SuccessWithChange); Pass::Status s = pass.Run(&localContext); EXPECT_EQ(s, Pass::Status::SuccessWithChange); for (Analysis i = IRContext::kAnalysisBegin; i < IRContext::kAnalysisEnd; i <<= 1) { EXPECT_FALSE(localContext.AreAnalysesValid(i)); } } TEST_F(IRContextTest, AllPreservedAfterPassWithChange) { std::unique_ptr module = MakeUnique(); IRContext localContext(SPV_ENV_UNIVERSAL_1_2, std::move(module), spvtools::MessageConsumer()); for (Analysis i = IRContext::kAnalysisBegin; i < IRContext::kAnalysisEnd; i <<= 1) { localContext.BuildInvalidAnalyses(i); } NoopPassPreservesAll pass(Pass::Status::SuccessWithChange); Pass::Status s = pass.Run(&localContext); EXPECT_EQ(s, Pass::Status::SuccessWithChange); for (Analysis i = IRContext::kAnalysisBegin; i < IRContext::kAnalysisEnd; i <<= 1) { EXPECT_TRUE(localContext.AreAnalysesValid(i)); } } TEST_F(IRContextTest, PreserveFirstOnlyAfterPassWithChange) { std::unique_ptr module = MakeUnique(); IRContext localContext(SPV_ENV_UNIVERSAL_1_2, std::move(module), spvtools::MessageConsumer()); for (Analysis i = IRContext::kAnalysisBegin; i < IRContext::kAnalysisEnd; i <<= 1) { localContext.BuildInvalidAnalyses(i); } NoopPassPreservesFirst pass(Pass::Status::SuccessWithChange); Pass::Status s = pass.Run(&localContext); EXPECT_EQ(s, Pass::Status::SuccessWithChange); EXPECT_TRUE(localContext.AreAnalysesValid(IRContext::kAnalysisBegin)); for (Analysis i = IRContext::kAnalysisBegin << 1; i < IRContext::kAnalysisEnd; i <<= 1) { EXPECT_FALSE(localContext.AreAnalysesValid(i)); } } TEST_F(IRContextTest, KillMemberName) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %3 "stuff" OpMemberName %3 0 "refZ" OpMemberDecorate %3 0 Offset 0 OpDecorate %3 Block %4 = OpTypeFloat 32 %3 = OpTypeStruct %4 %5 = OpTypeVoid %6 = OpTypeFunction %5 %2 = OpFunction %5 None %6 %7 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); // Build the decoration manager. context->get_decoration_mgr(); // Delete the OpTypeStruct. Should delete the OpName, OpMemberName, and // OpMemberDecorate associated with it. context->KillDef(3); // Make sure all of the name are removed. for (auto& inst : context->debugs2()) { EXPECT_EQ(inst.opcode(), spv::Op::OpNop); } // Make sure all of the decorations are removed. for (auto& inst : context->annotations()) { EXPECT_EQ(inst.opcode(), spv::Op::OpNop); } } TEST_F(IRContextTest, KillGroupDecoration) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpDecorate %3 Restrict %3 = OpDecorationGroup OpGroupDecorate %3 %4 %5 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %8 = OpTypeStruct %6 %9 = OpTypeVoid %10 = OpTypeFunction %9 %2 = OpFunction %9 None %10 %11 = OpLabel %4 = OpVariable %7 Function %5 = OpVariable %7 Function OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); // Build the decoration manager. context->get_decoration_mgr(); // Delete the second variable. context->KillDef(5); // The three decorations instructions should still be there. The first two // should be the same, but the third should have %5 removed. // Check the OpDecorate instruction auto inst = context->annotation_begin(); EXPECT_EQ(inst->opcode(), spv::Op::OpDecorate); EXPECT_EQ(inst->GetSingleWordInOperand(0), 3); // Check the OpDecorationGroup Instruction ++inst; EXPECT_EQ(inst->opcode(), spv::Op::OpDecorationGroup); EXPECT_EQ(inst->result_id(), 3); // Check that %5 is no longer part of the group. ++inst; EXPECT_EQ(inst->opcode(), spv::Op::OpGroupDecorate); EXPECT_EQ(inst->NumInOperands(), 2); EXPECT_EQ(inst->GetSingleWordInOperand(0), 3); EXPECT_EQ(inst->GetSingleWordInOperand(1), 4); // Check that we are at the end. ++inst; EXPECT_EQ(inst, context->annotation_end()); } TEST_F(IRContextTest, TakeNextUniqueIdIncrementing) { const uint32_t NUM_TESTS = 1000; IRContext localContext(SPV_ENV_UNIVERSAL_1_2, nullptr); for (uint32_t i = 1; i < NUM_TESTS; ++i) EXPECT_EQ(i, localContext.TakeNextUniqueId()); } TEST_F(IRContextTest, KillGroupDecorationWitNoDecorations) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpDecorationGroup OpGroupDecorate %3 %4 %5 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %8 = OpTypeStruct %6 %9 = OpTypeVoid %10 = OpTypeFunction %9 %2 = OpFunction %9 None %10 %11 = OpLabel %4 = OpVariable %7 Function %5 = OpVariable %7 Function OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); // Build the decoration manager. context->get_decoration_mgr(); // Delete the second variable. context->KillDef(5); // The two decoration instructions should still be there. The first one // should be the same, but the second should have %5 removed. // Check the OpDecorationGroup Instruction auto inst = context->annotation_begin(); EXPECT_EQ(inst->opcode(), spv::Op::OpDecorationGroup); EXPECT_EQ(inst->result_id(), 3); // Check that %5 is no longer part of the group. ++inst; EXPECT_EQ(inst->opcode(), spv::Op::OpGroupDecorate); EXPECT_EQ(inst->NumInOperands(), 2); EXPECT_EQ(inst->GetSingleWordInOperand(0), 3); EXPECT_EQ(inst->GetSingleWordInOperand(1), 4); // Check that we are at the end. ++inst; EXPECT_EQ(inst, context->annotation_end()); } TEST_F(IRContextTest, KillDecorationGroup) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpDecorationGroup OpGroupDecorate %3 %4 %5 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %8 = OpTypeStruct %6 %9 = OpTypeVoid %10 = OpTypeFunction %9 %2 = OpFunction %9 None %10 %11 = OpLabel %4 = OpVariable %7 Function %5 = OpVariable %7 Function OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); // Build the decoration manager. context->get_decoration_mgr(); // Delete the second variable. context->KillDef(3); // Check the OpDecorationGroup Instruction is still there. EXPECT_TRUE(context->annotations().empty()); } TEST_F(IRContextTest, KillFunctionFromDebugFunction) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft %3 = OpString "ps.hlsl" %4 = OpString "foo" OpSource HLSL 600 %void = OpTypeVoid %6 = OpTypeFunction %void %7 = OpExtInst %void %1 DebugSource %3 %8 = OpExtInst %void %1 DebugCompilationUnit 1 4 %7 HLSL %9 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %void %10 = OpExtInst %void %1 DebugFunction %4 %9 %7 1 1 %8 %4 FlagIsProtected|FlagIsPrivate 1 %11 %2 = OpFunction %void None %6 %12 = OpLabel OpReturn OpFunctionEnd %11 = OpFunction %void None %6 %13 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); // Delete the second variable. context->KillDef(11); // Get DebugInfoNone id. uint32_t debug_info_none_id = 0; for (auto it = context->ext_inst_debuginfo_begin(); it != context->ext_inst_debuginfo_end(); ++it) { if (it->GetOpenCL100DebugOpcode() == OpenCLDebugInfo100DebugInfoNone) { debug_info_none_id = it->result_id(); } } EXPECT_NE(0, debug_info_none_id); // Check the Function operand of DebugFunction is DebugInfoNone. const uint32_t kDebugFunctionOperandFunctionIndex = 13; bool checked = false; for (auto it = context->ext_inst_debuginfo_begin(); it != context->ext_inst_debuginfo_end(); ++it) { if (it->GetOpenCL100DebugOpcode() == OpenCLDebugInfo100DebugFunction) { EXPECT_FALSE(checked); EXPECT_EQ(it->GetOperand(kDebugFunctionOperandFunctionIndex).words[0], debug_info_none_id); checked = true; } } EXPECT_TRUE(checked); } TEST_F(IRContextTest, KillVariableFromDebugGlobalVariable) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft %3 = OpString "ps.hlsl" %4 = OpString "foo" %5 = OpString "int" OpSource HLSL 600 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %_ptr_Private_uint = OpTypePointer Private %uint %void = OpTypeVoid %10 = OpTypeFunction %void %11 = OpVariable %_ptr_Private_uint Private %12 = OpExtInst %void %1 DebugSource %3 %13 = OpExtInst %void %1 DebugCompilationUnit 1 4 %12 HLSL %14 = OpExtInst %void %1 DebugTypeBasic %5 %uint_32 Signed %15 = OpExtInst %void %1 DebugGlobalVariable %4 %14 %12 1 12 %13 %4 %11 FlagIsDefinition %2 = OpFunction %void None %10 %16 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); // Delete the second variable. context->KillDef(11); // Get DebugInfoNone id. uint32_t debug_info_none_id = 0; for (auto it = context->ext_inst_debuginfo_begin(); it != context->ext_inst_debuginfo_end(); ++it) { if (it->GetOpenCL100DebugOpcode() == OpenCLDebugInfo100DebugInfoNone) { debug_info_none_id = it->result_id(); } } EXPECT_NE(0, debug_info_none_id); // Check the Function operand of DebugFunction is DebugInfoNone. const uint32_t kDebugGlobalVariableOperandVariableIndex = 11; bool checked = false; for (auto it = context->ext_inst_debuginfo_begin(); it != context->ext_inst_debuginfo_end(); ++it) { if (it->GetOpenCL100DebugOpcode() == OpenCLDebugInfo100DebugGlobalVariable) { EXPECT_FALSE(checked); EXPECT_EQ( it->GetOperand(kDebugGlobalVariableOperandVariableIndex).words[0], debug_info_none_id); checked = true; } } EXPECT_TRUE(checked); } TEST_F(IRContextTest, BasicVisitFromEntryPoint) { // Make sure we visit the entry point, and the function it calls. // Do not visit Dead or Exported. const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %10 "main" OpName %10 "main" OpName %Dead "Dead" OpName %11 "Constant" OpName %ExportedFunc "ExportedFunc" OpDecorate %ExportedFunc LinkageAttributes "ExportedFunc" Export %void = OpTypeVoid %6 = OpTypeFunction %void %10 = OpFunction %void None %6 %14 = OpLabel %15 = OpFunctionCall %void %11 %16 = OpFunctionCall %void %11 OpReturn OpFunctionEnd %11 = OpFunction %void None %6 %18 = OpLabel OpReturn OpFunctionEnd %Dead = OpFunction %void None %6 %19 = OpLabel OpReturn OpFunctionEnd %ExportedFunc = OpFunction %void None %7 %20 = OpLabel %21 = OpFunctionCall %void %11 OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr localContext = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); EXPECT_NE(nullptr, localContext) << "Assembling failed for shader:\n" << text << std::endl; std::vector processed; Pass::ProcessFunction mark_visited = [&processed](Function* fp) { processed.push_back(fp->result_id()); return false; }; localContext->ProcessEntryPointCallTree(mark_visited); EXPECT_THAT(processed, UnorderedElementsAre(10, 11)); } TEST_F(IRContextTest, BasicVisitReachable) { // Make sure we visit the entry point, exported function, and the function // they call. Do not visit Dead. const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %10 "main" OpName %10 "main" OpName %Dead "Dead" OpName %11 "Constant" OpName %12 "ExportedFunc" OpName %13 "Constant2" OpDecorate %12 LinkageAttributes "ExportedFunc" Export %void = OpTypeVoid %6 = OpTypeFunction %void %10 = OpFunction %void None %6 %14 = OpLabel %15 = OpFunctionCall %void %11 %16 = OpFunctionCall %void %11 OpReturn OpFunctionEnd %11 = OpFunction %void None %6 %18 = OpLabel OpReturn OpFunctionEnd %Dead = OpFunction %void None %6 %19 = OpLabel OpReturn OpFunctionEnd %12 = OpFunction %void None %6 %20 = OpLabel %21 = OpFunctionCall %void %13 OpReturn OpFunctionEnd %13 = OpFunction %void None %6 %22 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr localContext = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); EXPECT_NE(nullptr, localContext) << "Assembling failed for shader:\n" << text << std::endl; std::vector processed; Pass::ProcessFunction mark_visited = [&processed](Function* fp) { processed.push_back(fp->result_id()); return false; }; localContext->ProcessReachableCallTree(mark_visited); EXPECT_THAT(processed, UnorderedElementsAre(10, 11, 12, 13)); } TEST_F(IRContextTest, BasicVisitOnlyOnce) { // Make sure we visit %12 only once, even if it is called from two different // functions. const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %10 "main" OpName %10 "main" OpName %Dead "Dead" OpName %11 "Constant" OpName %12 "ExportedFunc" OpDecorate %12 LinkageAttributes "ExportedFunc" Export %void = OpTypeVoid %6 = OpTypeFunction %void %10 = OpFunction %void None %6 %14 = OpLabel %15 = OpFunctionCall %void %11 %16 = OpFunctionCall %void %12 OpReturn OpFunctionEnd %11 = OpFunction %void None %6 %18 = OpLabel %19 = OpFunctionCall %void %12 OpReturn OpFunctionEnd %Dead = OpFunction %void None %6 %20 = OpLabel OpReturn OpFunctionEnd %12 = OpFunction %void None %6 %21 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr localContext = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); EXPECT_NE(nullptr, localContext) << "Assembling failed for shader:\n" << text << std::endl; std::vector processed; Pass::ProcessFunction mark_visited = [&processed](Function* fp) { processed.push_back(fp->result_id()); return false; }; localContext->ProcessReachableCallTree(mark_visited); EXPECT_THAT(processed, UnorderedElementsAre(10, 11, 12)); } TEST_F(IRContextTest, BasicDontVisitExportedVariable) { // Make sure we only visit functions and not exported variables. const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %10 "main" OpExecutionMode %10 OriginUpperLeft OpSource GLSL 150 OpName %10 "main" OpName %12 "export_var" OpDecorate %12 LinkageAttributes "export_var" Export %void = OpTypeVoid %6 = OpTypeFunction %void %float = OpTypeFloat 32 %float_1 = OpConstant %float 1 %12 = OpVariable %float Output %10 = OpFunction %void None %6 %14 = OpLabel OpStore %12 %float_1 OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr localContext = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); EXPECT_NE(nullptr, localContext) << "Assembling failed for shader:\n" << text << std::endl; std::vector processed; Pass::ProcessFunction mark_visited = [&processed](Function* fp) { processed.push_back(fp->result_id()); return false; }; localContext->ProcessReachableCallTree(mark_visited); EXPECT_THAT(processed, UnorderedElementsAre(10)); } TEST_F(IRContextTest, IdBoundTestAtLimit) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpFunction %1 None %2 %4 = OpLabel OpReturn OpFunctionEnd)"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); uint32_t current_bound = context->module()->id_bound(); context->set_max_id_bound(current_bound); uint32_t next_id_bound = context->TakeNextId(); EXPECT_EQ(next_id_bound, 0); EXPECT_EQ(current_bound, context->module()->id_bound()); next_id_bound = context->TakeNextId(); EXPECT_EQ(next_id_bound, 0); } TEST_F(IRContextTest, IdBoundTestBelowLimit) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpFunction %1 None %2 %4 = OpLabel OpReturn OpFunctionEnd)"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); uint32_t current_bound = context->module()->id_bound(); context->set_max_id_bound(current_bound + 100); uint32_t next_id_bound = context->TakeNextId(); EXPECT_EQ(next_id_bound, current_bound); EXPECT_EQ(current_bound + 1, context->module()->id_bound()); next_id_bound = context->TakeNextId(); EXPECT_EQ(next_id_bound, current_bound + 1); } TEST_F(IRContextTest, IdBoundTestNearLimit) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpFunction %1 None %2 %4 = OpLabel OpReturn OpFunctionEnd)"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); uint32_t current_bound = context->module()->id_bound(); context->set_max_id_bound(current_bound + 1); uint32_t next_id_bound = context->TakeNextId(); EXPECT_EQ(next_id_bound, current_bound); EXPECT_EQ(current_bound + 1, context->module()->id_bound()); next_id_bound = context->TakeNextId(); EXPECT_EQ(next_id_bound, 0); } TEST_F(IRContextTest, IdBoundTestUIntMax) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpFunction %1 None %2 %4294967294 = OpLabel ; ID is UINT_MAX-1 OpReturn OpFunctionEnd)"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); uint32_t current_bound = context->module()->id_bound(); // Expecting |BuildModule| to preserve the numeric ids. EXPECT_EQ(current_bound, std::numeric_limits::max()); context->set_max_id_bound(current_bound); uint32_t next_id_bound = context->TakeNextId(); EXPECT_EQ(next_id_bound, 0); EXPECT_EQ(current_bound, context->module()->id_bound()); } TEST_F(IRContextTest, CfgAndDomAnalysis) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpFunction %1 None %2 %4 = OpLabel OpReturn OpFunctionEnd)"; std::unique_ptr ctx = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); // Building the dominator analysis should build the CFG. ASSERT_TRUE(ctx->module()->begin() != ctx->module()->end()); ctx->GetDominatorAnalysis(&*ctx->module()->begin()); EXPECT_TRUE(ctx->AreAnalysesValid(IRContext::kAnalysisCFG)); EXPECT_TRUE(ctx->AreAnalysesValid(IRContext::kAnalysisDominatorAnalysis)); // Invalidating the CFG analysis should invalidate the dominator analysis. ctx->InvalidateAnalyses(IRContext::kAnalysisCFG); EXPECT_FALSE(ctx->AreAnalysesValid(IRContext::kAnalysisCFG)); EXPECT_FALSE(ctx->AreAnalysesValid(IRContext::kAnalysisDominatorAnalysis)); } TEST_F(IRContextTest, AsanErrorTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "x" OpName %10 "y" OpDecorate %8 RelaxedPrecision OpDecorate %10 RelaxedPrecision OpDecorate %11 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function OpStore %8 %9 %11 = OpLoad %6 %8 OpBranch %20 %20 = OpLabel %21 = OpPhi %6 %11 %5 OpStore %10 %21 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule( env, consumer, shader, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); opt::Function* fun = context->cfg()->block(5)->GetParent(); // Computes the CFG analysis opt::DominatorAnalysis* dom = nullptr; // NOLINTNEXTLINE dom = context->GetDominatorAnalysis(fun); // Computes the dominator analysis, // which depends on the CFG // analysis context->InvalidateAnalysesExceptFor( opt::IRContext::Analysis::kAnalysisDominatorAnalysis); // Invalidates the // CFG analysis dom = context->GetDominatorAnalysis( fun); // Recompute the CFG analysis because the Dominator tree uses it. auto bb = dom->ImmediateDominator(5); std::cout << bb->id(); // Make sure asan does not complain about use after free. } TEST_F(IRContextTest, DebugInstructionReplaceSingleUse) { const std::string text = R"( OpCapability Shader OpCapability Linkage %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 %2 = OpString "test" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %6 = OpTypePointer Function %5 %7 = OpConstant %5 0 %8 = OpTypeInt 32 0 %9 = OpConstant %8 32 %10 = OpExtInst %3 %1 DebugExpression %11 = OpExtInst %3 %1 DebugSource %2 %12 = OpExtInst %3 %1 DebugCompilationUnit 1 4 %11 HLSL %13 = OpExtInst %3 %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %3 %14 = OpExtInst %3 %1 DebugFunction %2 %13 %11 0 0 %12 %2 FlagIsProtected|FlagIsPrivate 0 %17 %15 = OpExtInst %3 %1 DebugTypeBasic %2 %9 Float %16 = OpExtInst %3 %1 DebugLocalVariable %2 %15 %11 0 0 %14 FlagIsLocal %17 = OpFunction %3 None %4 %18 = OpLabel %19 = OpExtInst %3 %1 DebugScope %14 %20 = OpVariable %6 Function %26 = OpVariable %6 Function OpBranch %21 %21 = OpLabel %22 = OpPhi %5 %7 %18 OpBranch %23 %23 = OpLabel OpLine %2 0 0 OpStore %20 %7 %24 = OpExtInst %3 %1 DebugValue %16 %22 %10 %25 = OpExtInst %3 %1 DebugDeclare %16 %26 %10 OpReturn OpFunctionEnd)"; std::unique_ptr ctx = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); ctx->BuildInvalidAnalyses(IRContext::kAnalysisDebugInfo); NoopPassPreservesAll pass(Pass::Status::SuccessWithChange); pass.Run(ctx.get()); EXPECT_TRUE(ctx->AreAnalysesValid(IRContext::kAnalysisDebugInfo)); auto* dbg_value = ctx->get_def_use_mgr()->GetDef(24); EXPECT_TRUE(dbg_value->GetSingleWordOperand(kDebugValueOperandValueIndex) == 22); EXPECT_TRUE(ctx->ReplaceAllUsesWith(22, 7)); dbg_value = ctx->get_def_use_mgr()->GetDef(24); EXPECT_TRUE(dbg_value->GetSingleWordOperand(kDebugValueOperandValueIndex) == 7); auto* dbg_decl = ctx->get_def_use_mgr()->GetDef(25); EXPECT_TRUE( dbg_decl->GetSingleWordOperand(kDebugDeclareOperandVariableIndex) == 26); EXPECT_TRUE(ctx->ReplaceAllUsesWith(26, 20)); dbg_decl = ctx->get_def_use_mgr()->GetDef(25); EXPECT_TRUE( dbg_decl->GetSingleWordOperand(kDebugDeclareOperandVariableIndex) == 20); } TEST_F(IRContextTest, DebugInstructionReplaceAllUses) { const std::string text = R"( OpCapability Shader OpCapability Linkage %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 %2 = OpString "test" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %6 = OpTypePointer Function %5 %7 = OpConstant %5 0 %8 = OpTypeInt 32 0 %9 = OpConstant %8 32 %10 = OpExtInst %3 %1 DebugExpression %11 = OpExtInst %3 %1 DebugSource %2 %12 = OpExtInst %3 %1 DebugCompilationUnit 1 4 %11 HLSL %13 = OpExtInst %3 %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %3 %14 = OpExtInst %3 %1 DebugFunction %2 %13 %11 0 0 %12 %2 FlagIsProtected|FlagIsPrivate 0 %17 %15 = OpExtInst %3 %1 DebugTypeBasic %2 %9 Float %16 = OpExtInst %3 %1 DebugLocalVariable %2 %15 %11 0 0 %14 FlagIsLocal %27 = OpExtInst %3 %1 DebugLocalVariable %2 %15 %11 1 0 %14 FlagIsLocal %17 = OpFunction %3 None %4 %18 = OpLabel %19 = OpExtInst %3 %1 DebugScope %14 %20 = OpVariable %6 Function %26 = OpVariable %6 Function OpBranch %21 %21 = OpLabel %22 = OpPhi %5 %7 %18 OpBranch %23 %23 = OpLabel OpLine %2 0 0 OpStore %20 %7 %24 = OpExtInst %3 %1 DebugValue %16 %22 %10 %25 = OpExtInst %3 %1 DebugDeclare %16 %26 %10 %28 = OpExtInst %3 %1 DebugValue %27 %22 %10 %29 = OpExtInst %3 %1 DebugDeclare %27 %26 %10 OpReturn OpFunctionEnd)"; std::unique_ptr ctx = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); ctx->BuildInvalidAnalyses(IRContext::kAnalysisDebugInfo); NoopPassPreservesAll pass(Pass::Status::SuccessWithChange); pass.Run(ctx.get()); EXPECT_TRUE(ctx->AreAnalysesValid(IRContext::kAnalysisDebugInfo)); auto* dbg_value0 = ctx->get_def_use_mgr()->GetDef(24); auto* dbg_value1 = ctx->get_def_use_mgr()->GetDef(28); EXPECT_TRUE(dbg_value0->GetSingleWordOperand(kDebugValueOperandValueIndex) == 22); EXPECT_TRUE(dbg_value1->GetSingleWordOperand(kDebugValueOperandValueIndex) == 22); EXPECT_TRUE(ctx->ReplaceAllUsesWith(22, 7)); dbg_value0 = ctx->get_def_use_mgr()->GetDef(24); dbg_value1 = ctx->get_def_use_mgr()->GetDef(28); EXPECT_TRUE(dbg_value0->GetSingleWordOperand(kDebugValueOperandValueIndex) == 7); EXPECT_TRUE(dbg_value1->GetSingleWordOperand(kDebugValueOperandValueIndex) == 7); auto* dbg_decl0 = ctx->get_def_use_mgr()->GetDef(25); auto* dbg_decl1 = ctx->get_def_use_mgr()->GetDef(29); EXPECT_TRUE( dbg_decl0->GetSingleWordOperand(kDebugDeclareOperandVariableIndex) == 26); EXPECT_TRUE( dbg_decl1->GetSingleWordOperand(kDebugDeclareOperandVariableIndex) == 26); EXPECT_TRUE(ctx->ReplaceAllUsesWith(26, 20)); dbg_decl0 = ctx->get_def_use_mgr()->GetDef(25); dbg_decl1 = ctx->get_def_use_mgr()->GetDef(29); EXPECT_TRUE( dbg_decl0->GetSingleWordOperand(kDebugDeclareOperandVariableIndex) == 20); EXPECT_TRUE( dbg_decl1->GetSingleWordOperand(kDebugDeclareOperandVariableIndex) == 20); } TEST_F(IRContextTest, DebugInstructionReplaceDebugScopeAndDebugInlinedAt) { const std::string text = R"( OpCapability Shader OpCapability Linkage %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 %2 = OpString "test" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %6 = OpTypePointer Function %5 %7 = OpConstant %5 0 %8 = OpTypeInt 32 0 %9 = OpConstant %8 32 %10 = OpExtInst %3 %1 DebugExpression %11 = OpExtInst %3 %1 DebugSource %2 %12 = OpExtInst %3 %1 DebugCompilationUnit 1 4 %11 HLSL %13 = OpExtInst %3 %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %3 %14 = OpExtInst %3 %1 DebugFunction %2 %13 %11 0 0 %12 %2 FlagIsProtected|FlagIsPrivate 0 %17 %15 = OpExtInst %3 %1 DebugInfoNone %16 = OpExtInst %3 %1 DebugFunction %2 %13 %11 10 10 %12 %2 FlagIsProtected|FlagIsPrivate 0 %15 %25 = OpExtInst %3 %1 DebugInlinedAt 0 %14 %26 = OpExtInst %3 %1 DebugInlinedAt 2 %14 %17 = OpFunction %3 None %4 %18 = OpLabel %19 = OpExtInst %3 %1 DebugScope %14 %20 = OpVariable %6 Function OpBranch %21 %21 = OpLabel %24 = OpExtInst %3 %1 DebugScope %16 %22 = OpPhi %5 %7 %18 OpBranch %23 %23 = OpLabel %27 = OpExtInst %3 %1 DebugScope %16 %25 OpLine %2 0 0 %28 = OpFAdd %5 %7 %7 OpStore %20 %28 OpReturn OpFunctionEnd)"; std::unique_ptr ctx = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); ctx->BuildInvalidAnalyses(IRContext::kAnalysisDebugInfo); NoopPassPreservesAll pass(Pass::Status::SuccessWithChange); pass.Run(ctx.get()); EXPECT_TRUE(ctx->AreAnalysesValid(IRContext::kAnalysisDebugInfo)); auto* inst0 = ctx->get_def_use_mgr()->GetDef(20); auto* inst1 = ctx->get_def_use_mgr()->GetDef(22); auto* inst2 = ctx->get_def_use_mgr()->GetDef(28); EXPECT_EQ(inst0->GetDebugScope().GetLexicalScope(), 14); EXPECT_EQ(inst1->GetDebugScope().GetLexicalScope(), 16); EXPECT_EQ(inst2->GetDebugScope().GetLexicalScope(), 16); EXPECT_EQ(inst2->GetDebugInlinedAt(), 25); EXPECT_TRUE(ctx->ReplaceAllUsesWith(14, 12)); EXPECT_TRUE(ctx->ReplaceAllUsesWith(16, 14)); EXPECT_TRUE(ctx->ReplaceAllUsesWith(25, 26)); EXPECT_EQ(inst0->GetDebugScope().GetLexicalScope(), 12); EXPECT_EQ(inst1->GetDebugScope().GetLexicalScope(), 14); EXPECT_EQ(inst2->GetDebugScope().GetLexicalScope(), 14); EXPECT_EQ(inst2->GetDebugInlinedAt(), 26); } TEST_F(IRContextTest, AddDebugValueAfterReplaceUse) { const std::string text = R"( OpCapability Shader OpCapability Linkage %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 %2 = OpString "test" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %6 = OpTypePointer Function %5 %7 = OpConstant %5 0 %8 = OpTypeInt 32 0 %9 = OpConstant %8 32 %10 = OpExtInst %3 %1 DebugExpression %11 = OpExtInst %3 %1 DebugSource %2 %12 = OpExtInst %3 %1 DebugCompilationUnit 1 4 %11 HLSL %13 = OpExtInst %3 %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %3 %14 = OpExtInst %3 %1 DebugFunction %2 %13 %11 0 0 %12 %2 FlagIsProtected|FlagIsPrivate 0 %17 %15 = OpExtInst %3 %1 DebugTypeBasic %2 %9 Float %16 = OpExtInst %3 %1 DebugLocalVariable %2 %15 %11 0 0 %14 FlagIsLocal %17 = OpFunction %3 None %4 %18 = OpLabel %19 = OpExtInst %3 %1 DebugScope %14 %20 = OpVariable %6 Function %26 = OpVariable %6 Function OpBranch %21 %21 = OpLabel %27 = OpExtInst %3 %1 DebugScope %14 %22 = OpPhi %5 %7 %18 OpBranch %23 %23 = OpLabel %28 = OpExtInst %3 %1 DebugScope %14 OpLine %2 0 0 OpStore %20 %7 %24 = OpExtInst %3 %1 DebugValue %16 %22 %10 %25 = OpExtInst %3 %1 DebugDeclare %16 %26 %10 OpReturn OpFunctionEnd)"; std::unique_ptr ctx = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); ctx->BuildInvalidAnalyses(IRContext::kAnalysisDebugInfo); NoopPassPreservesAll pass(Pass::Status::SuccessWithChange); pass.Run(ctx.get()); EXPECT_TRUE(ctx->AreAnalysesValid(IRContext::kAnalysisDebugInfo)); // Replace all uses of result it '26' with '20' auto* dbg_decl = ctx->get_def_use_mgr()->GetDef(25); EXPECT_EQ(dbg_decl->GetSingleWordOperand(kDebugDeclareOperandVariableIndex), 26); EXPECT_TRUE(ctx->ReplaceAllUsesWith(26, 20)); dbg_decl = ctx->get_def_use_mgr()->GetDef(25); EXPECT_EQ(dbg_decl->GetSingleWordOperand(kDebugDeclareOperandVariableIndex), 20); } struct TargetEnvCompareTestData { spv_target_env later_env, earlier_env; }; using TargetEnvCompareTest = ::testing::TestWithParam; TEST_P(TargetEnvCompareTest, IsTargetEnvAtLeast) { const auto& tc = GetParam(); std::unique_ptr module(new Module()); IRContext localContext(tc.later_env, std::move(module), spvtools::MessageConsumer()); EXPECT_TRUE(localContext.IsTargetEnvAtLeast(tc.earlier_env)); if (tc.earlier_env != tc.later_env) { std::unique_ptr module(new Module()); IRContext localContext(tc.earlier_env, std::move(module), spvtools::MessageConsumer()); EXPECT_FALSE(localContext.IsTargetEnvAtLeast(tc.later_env)); } } TEST_F(IRContextTest, ReturnsTrueWhenExtensionIsRemoved) { const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_shader_clock" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %6 = OpTypeFunction %void %1 = OpFunction %void None %6 %9 = OpLabel OpReturn OpFunctionEnd)"; std::unique_ptr ctx = BuildModule(SPV_ENV_UNIVERSAL_1_6, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); EXPECT_TRUE(ctx->get_feature_mgr()->HasExtension(kSPV_KHR_shader_clock)); EXPECT_EQ(std::distance(ctx->module()->extension_begin(), ctx->module()->extension_end()), 1); EXPECT_TRUE(ctx->RemoveExtension(kSPV_KHR_shader_clock)); EXPECT_FALSE(ctx->get_feature_mgr()->HasExtension(kSPV_KHR_shader_clock)); EXPECT_EQ(std::distance(ctx->module()->extension_begin(), ctx->module()->extension_end()), 0); } TEST_F(IRContextTest, ReturnsFalseWhenExtensionIsNotRemoved) { const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_device_group" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %6 = OpTypeFunction %void %1 = OpFunction %void None %6 %9 = OpLabel OpReturn OpFunctionEnd)"; std::unique_ptr ctx = BuildModule(SPV_ENV_UNIVERSAL_1_6, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); EXPECT_TRUE(ctx->get_feature_mgr()->HasExtension(kSPV_KHR_device_group)); EXPECT_EQ(std::distance(ctx->module()->extension_begin(), ctx->module()->extension_end()), 1); EXPECT_FALSE(ctx->RemoveExtension(kSPV_KHR_shader_clock)); EXPECT_TRUE(ctx->get_feature_mgr()->HasExtension(kSPV_KHR_device_group)); EXPECT_EQ(std::distance(ctx->module()->extension_begin(), ctx->module()->extension_end()), 1); } TEST_F(IRContextTest, RemovesExtensionIfLast) { const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_device_group" OpExtension "SPV_KHR_shader_clock" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %6 = OpTypeFunction %void %1 = OpFunction %void None %6 %9 = OpLabel OpReturn OpFunctionEnd)"; std::unique_ptr ctx = BuildModule(SPV_ENV_UNIVERSAL_1_6, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); EXPECT_TRUE(ctx->get_feature_mgr()->HasExtension(kSPV_KHR_device_group)); EXPECT_TRUE(ctx->get_feature_mgr()->HasExtension(kSPV_KHR_shader_clock)); EXPECT_EQ(std::distance(ctx->module()->extension_begin(), ctx->module()->extension_end()), 2); EXPECT_TRUE(ctx->RemoveExtension(kSPV_KHR_shader_clock)); EXPECT_TRUE(ctx->get_feature_mgr()->HasExtension(kSPV_KHR_device_group)); EXPECT_FALSE(ctx->get_feature_mgr()->HasExtension(kSPV_KHR_shader_clock)); EXPECT_EQ(std::distance(ctx->module()->extension_begin(), ctx->module()->extension_end()), 1); } TEST_F(IRContextTest, RemovesExtensionIfFirst) { const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_shader_clock" OpExtension "SPV_KHR_device_group" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %6 = OpTypeFunction %void %1 = OpFunction %void None %6 %9 = OpLabel OpReturn OpFunctionEnd)"; std::unique_ptr ctx = BuildModule(SPV_ENV_UNIVERSAL_1_6, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); EXPECT_TRUE(ctx->get_feature_mgr()->HasExtension(kSPV_KHR_device_group)); EXPECT_TRUE(ctx->get_feature_mgr()->HasExtension(kSPV_KHR_shader_clock)); EXPECT_EQ(std::distance(ctx->module()->extension_begin(), ctx->module()->extension_end()), 2); EXPECT_TRUE(ctx->RemoveExtension(kSPV_KHR_shader_clock)); EXPECT_TRUE(ctx->get_feature_mgr()->HasExtension(kSPV_KHR_device_group)); EXPECT_FALSE(ctx->get_feature_mgr()->HasExtension(kSPV_KHR_shader_clock)); EXPECT_EQ(std::distance(ctx->module()->extension_begin(), ctx->module()->extension_end()), 1); } TEST_F(IRContextTest, RemovesMultipleExtensions) { const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_shader_clock" OpExtension "SPV_KHR_shader_clock" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %6 = OpTypeFunction %void %1 = OpFunction %void None %6 %9 = OpLabel OpReturn OpFunctionEnd)"; std::unique_ptr ctx = BuildModule(SPV_ENV_UNIVERSAL_1_6, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); EXPECT_TRUE(ctx->get_feature_mgr()->HasExtension(kSPV_KHR_shader_clock)); EXPECT_EQ(std::distance(ctx->module()->extension_begin(), ctx->module()->extension_end()), 2); EXPECT_TRUE(ctx->RemoveExtension(kSPV_KHR_shader_clock)); EXPECT_FALSE(ctx->get_feature_mgr()->HasExtension(kSPV_KHR_shader_clock)); EXPECT_EQ(std::distance(ctx->module()->extension_begin(), ctx->module()->extension_end()), 0); } TEST_F(IRContextTest, ReturnsTrueWhenCapabilityIsRemoved) { const std::string text = R"( OpCapability Shader OpCapability ShaderClockKHR OpExtension "SPV_KHR_shader_clock" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %6 = OpTypeFunction %void %1 = OpFunction %void None %6 %9 = OpLabel OpReturn OpFunctionEnd)"; std::unique_ptr ctx = BuildModule(SPV_ENV_UNIVERSAL_1_6, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); EXPECT_TRUE( ctx->get_feature_mgr()->HasCapability(spv::Capability::ShaderClockKHR)); EXPECT_EQ(std::distance(ctx->module()->capability_begin(), ctx->module()->capability_end()), 2); EXPECT_TRUE(ctx->RemoveCapability(spv::Capability::ShaderClockKHR)); EXPECT_FALSE( ctx->get_feature_mgr()->HasCapability(spv::Capability::ShaderClockKHR)); EXPECT_EQ(std::distance(ctx->module()->capability_begin(), ctx->module()->capability_end()), 1); } TEST_F(IRContextTest, ReturnsFalseWhenCapabilityIsNotRemoved) { const std::string text = R"( OpCapability Shader OpCapability DeviceGroup OpExtension "SPV_KHR_device_group" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %6 = OpTypeFunction %void %1 = OpFunction %void None %6 %9 = OpLabel OpReturn OpFunctionEnd)"; std::unique_ptr ctx = BuildModule(SPV_ENV_UNIVERSAL_1_6, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); EXPECT_TRUE( ctx->get_feature_mgr()->HasCapability(spv::Capability::DeviceGroup)); EXPECT_EQ(std::distance(ctx->module()->capability_begin(), ctx->module()->capability_end()), 2); EXPECT_FALSE(ctx->RemoveCapability(spv::Capability::ShaderClockKHR)); EXPECT_TRUE( ctx->get_feature_mgr()->HasCapability(spv::Capability::DeviceGroup)); EXPECT_EQ(std::distance(ctx->module()->capability_begin(), ctx->module()->capability_end()), 2); } TEST_F(IRContextTest, RemovesMultipleCapabilities) { const std::string text = R"( OpCapability Shader OpCapability DeviceGroup OpCapability DeviceGroup OpExtension "SPV_KHR_device_group" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %6 = OpTypeFunction %void %1 = OpFunction %void None %6 %9 = OpLabel OpReturn OpFunctionEnd)"; std::unique_ptr ctx = BuildModule(SPV_ENV_UNIVERSAL_1_6, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); EXPECT_TRUE( ctx->get_feature_mgr()->HasCapability(spv::Capability::DeviceGroup)); EXPECT_EQ(std::distance(ctx->module()->capability_begin(), ctx->module()->capability_end()), 3); EXPECT_TRUE(ctx->RemoveCapability(spv::Capability::DeviceGroup)); EXPECT_FALSE( ctx->get_feature_mgr()->HasCapability(spv::Capability::DeviceGroup)); EXPECT_EQ(std::distance(ctx->module()->capability_begin(), ctx->module()->capability_end()), 1); } // If new environments are added, then we must update the list of tests. static_assert(SPV_ENV_VULKAN_1_4 + 1 == SPV_ENV_MAX); INSTANTIATE_TEST_SUITE_P( TestCase, TargetEnvCompareTest, ::testing::Values( TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_0}, TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_1, SPV_ENV_UNIVERSAL_1_0}, TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_2, SPV_ENV_UNIVERSAL_1_0}, TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_3, SPV_ENV_UNIVERSAL_1_0}, TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_4, SPV_ENV_UNIVERSAL_1_0}, TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_5, SPV_ENV_UNIVERSAL_1_0}, TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_6, SPV_ENV_UNIVERSAL_1_0}, TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_1, SPV_ENV_UNIVERSAL_1_1}, TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_2, SPV_ENV_UNIVERSAL_1_1}, TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_3, SPV_ENV_UNIVERSAL_1_1}, TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_4, SPV_ENV_UNIVERSAL_1_1}, TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_5, SPV_ENV_UNIVERSAL_1_1}, TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_6, SPV_ENV_UNIVERSAL_1_1}, TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_2, SPV_ENV_UNIVERSAL_1_2}, TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_3, SPV_ENV_UNIVERSAL_1_2}, TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_4, SPV_ENV_UNIVERSAL_1_2}, TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_5, SPV_ENV_UNIVERSAL_1_2}, TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_6, SPV_ENV_UNIVERSAL_1_2}, TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_3, SPV_ENV_UNIVERSAL_1_3}, TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_4, SPV_ENV_UNIVERSAL_1_3}, TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_5, SPV_ENV_UNIVERSAL_1_3}, TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_6, SPV_ENV_UNIVERSAL_1_3}, TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_4, SPV_ENV_UNIVERSAL_1_4}, TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_5, SPV_ENV_UNIVERSAL_1_4}, TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_6, SPV_ENV_UNIVERSAL_1_4}, TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_5, SPV_ENV_UNIVERSAL_1_5}, TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_6, SPV_ENV_UNIVERSAL_1_5}, TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_6, SPV_ENV_UNIVERSAL_1_6}, TargetEnvCompareTestData{SPV_ENV_VULKAN_1_0, SPV_ENV_UNIVERSAL_1_0}, TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_1, SPV_ENV_VULKAN_1_0}, TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_2, SPV_ENV_VULKAN_1_0}, TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_3, SPV_ENV_VULKAN_1_0}, TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_4, SPV_ENV_VULKAN_1_0}, TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_5, SPV_ENV_VULKAN_1_0}, TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_6, SPV_ENV_VULKAN_1_0}, TargetEnvCompareTestData{SPV_ENV_VULKAN_1_1, SPV_ENV_UNIVERSAL_1_0}, TargetEnvCompareTestData{SPV_ENV_VULKAN_1_1, SPV_ENV_UNIVERSAL_1_1}, TargetEnvCompareTestData{SPV_ENV_VULKAN_1_1, SPV_ENV_UNIVERSAL_1_2}, TargetEnvCompareTestData{SPV_ENV_VULKAN_1_1, SPV_ENV_UNIVERSAL_1_3}, TargetEnvCompareTestData{SPV_ENV_VULKAN_1_1, SPV_ENV_VULKAN_1_0}, TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_4, SPV_ENV_VULKAN_1_1}, TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_5, SPV_ENV_VULKAN_1_1}, TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_6, SPV_ENV_VULKAN_1_1}, TargetEnvCompareTestData{SPV_ENV_VULKAN_1_2, SPV_ENV_UNIVERSAL_1_0}, TargetEnvCompareTestData{SPV_ENV_VULKAN_1_2, SPV_ENV_UNIVERSAL_1_1}, TargetEnvCompareTestData{SPV_ENV_VULKAN_1_2, SPV_ENV_UNIVERSAL_1_2}, TargetEnvCompareTestData{SPV_ENV_VULKAN_1_2, SPV_ENV_UNIVERSAL_1_3}, TargetEnvCompareTestData{SPV_ENV_VULKAN_1_2, SPV_ENV_UNIVERSAL_1_4}, TargetEnvCompareTestData{SPV_ENV_VULKAN_1_2, SPV_ENV_UNIVERSAL_1_5}, TargetEnvCompareTestData{SPV_ENV_VULKAN_1_2, SPV_ENV_VULKAN_1_1}, TargetEnvCompareTestData{SPV_ENV_UNIVERSAL_1_6, SPV_ENV_VULKAN_1_2}, TargetEnvCompareTestData{SPV_ENV_VULKAN_1_3, SPV_ENV_UNIVERSAL_1_0}, TargetEnvCompareTestData{SPV_ENV_VULKAN_1_3, SPV_ENV_UNIVERSAL_1_1}, TargetEnvCompareTestData{SPV_ENV_VULKAN_1_3, SPV_ENV_UNIVERSAL_1_2}, TargetEnvCompareTestData{SPV_ENV_VULKAN_1_3, SPV_ENV_UNIVERSAL_1_3}, TargetEnvCompareTestData{SPV_ENV_VULKAN_1_3, SPV_ENV_UNIVERSAL_1_4}, TargetEnvCompareTestData{SPV_ENV_VULKAN_1_3, SPV_ENV_UNIVERSAL_1_5}, TargetEnvCompareTestData{SPV_ENV_VULKAN_1_3, SPV_ENV_UNIVERSAL_1_6}, TargetEnvCompareTestData{SPV_ENV_VULKAN_1_3, SPV_ENV_VULKAN_1_2}, TargetEnvCompareTestData{SPV_ENV_VULKAN_1_4, SPV_ENV_UNIVERSAL_1_0}, TargetEnvCompareTestData{SPV_ENV_VULKAN_1_4, SPV_ENV_UNIVERSAL_1_1}, TargetEnvCompareTestData{SPV_ENV_VULKAN_1_4, SPV_ENV_UNIVERSAL_1_2}, TargetEnvCompareTestData{SPV_ENV_VULKAN_1_4, SPV_ENV_UNIVERSAL_1_3}, TargetEnvCompareTestData{SPV_ENV_VULKAN_1_4, SPV_ENV_UNIVERSAL_1_4}, TargetEnvCompareTestData{SPV_ENV_VULKAN_1_4, SPV_ENV_UNIVERSAL_1_5}, TargetEnvCompareTestData{SPV_ENV_VULKAN_1_4, SPV_ENV_UNIVERSAL_1_6}, TargetEnvCompareTestData{SPV_ENV_VULKAN_1_4, SPV_ENV_VULKAN_1_3})); } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/ir_loader_test.cpp000066400000000000000000001405131475742701700240210ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include #include #include "gmock/gmock.h" #include "source/opt/build_module.h" #include "source/opt/def_use_manager.h" #include "source/opt/ir_context.h" #include "spirv-tools/libspirv.hpp" namespace spvtools { namespace opt { namespace { using ::testing::ContainerEq; constexpr uint32_t kOpLineOperandLineIndex = 1; void DoRoundTripCheck(const std::string& text) { SpirvTools t(SPV_ENV_UNIVERSAL_1_1); std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text); ASSERT_NE(nullptr, context) << "Failed to assemble\n" << text; std::vector binary; context->module()->ToBinary(&binary, /* skip_nop = */ false); std::string disassembled_text; EXPECT_TRUE(t.Disassemble(binary, &disassembled_text)); EXPECT_EQ(text, disassembled_text); } TEST(IrBuilder, RoundTrip) { // #version 310 es // int add(int a, int b) { return a + b; } // void main() { add(1, 2); } DoRoundTripCheck( // clang-format off "OpCapability Shader\n" "%1 = OpExtInstImport \"GLSL.std.450\"\n" "OpMemoryModel Logical GLSL450\n" "OpEntryPoint Vertex %main \"main\"\n" "OpSource ESSL 310\n" "OpSourceExtension \"GL_GOOGLE_cpp_style_line_directive\"\n" "OpSourceExtension \"GL_GOOGLE_include_directive\"\n" "OpName %main \"main\"\n" "OpName %add_i1_i1_ \"add(i1;i1;\"\n" "OpName %a \"a\"\n" "OpName %b \"b\"\n" "OpName %param \"param\"\n" "OpName %param_0 \"param\"\n" "%void = OpTypeVoid\n" "%9 = OpTypeFunction %void\n" "%int = OpTypeInt 32 1\n" "%_ptr_Function_int = OpTypePointer Function %int\n" "%12 = OpTypeFunction %int %_ptr_Function_int %_ptr_Function_int\n" "%int_1 = OpConstant %int 1\n" "%int_2 = OpConstant %int 2\n" "%main = OpFunction %void None %9\n" "%15 = OpLabel\n" "%param = OpVariable %_ptr_Function_int Function\n" "%param_0 = OpVariable %_ptr_Function_int Function\n" "OpStore %param %int_1\n" "OpStore %param_0 %int_2\n" "%16 = OpFunctionCall %int %add_i1_i1_ %param %param_0\n" "OpReturn\n" "OpFunctionEnd\n" "%add_i1_i1_ = OpFunction %int None %12\n" "%a = OpFunctionParameter %_ptr_Function_int\n" "%b = OpFunctionParameter %_ptr_Function_int\n" "%17 = OpLabel\n" "%18 = OpLoad %int %a\n" "%19 = OpLoad %int %b\n" "%20 = OpIAdd %int %18 %19\n" "OpReturnValue %20\n" "OpFunctionEnd\n"); // clang-format on } TEST(IrBuilder, RoundTripIncompleteBasicBlock) { DoRoundTripCheck( "%2 = OpFunction %1 None %3\n" "%4 = OpLabel\n" "OpNop\n"); } TEST(IrBuilder, RoundTripIncompleteFunction) { DoRoundTripCheck("%2 = OpFunction %1 None %3\n"); } TEST(IrBuilder, RoundTripFunctionPointer) { DoRoundTripCheck( "OpCapability Linkage\n" "OpCapability FunctionPointersINTEL\n" "OpName %some_function \"some_function\"\n" "OpName %ptr_to_function \"ptr_to_function\"\n" "OpDecorate %some_function LinkageAttributes \"some_function\" Import\n" "%float = OpTypeFloat 32\n" "%4 = OpTypeFunction %float %float\n" "%_ptr_Function_4 = OpTypePointer Function %4\n" "%ptr_to_function = OpConstantFunctionPointerINTEL %_ptr_Function_4 " "%some_function\n" "%some_function = OpFunction %float Const %4\n" "%6 = OpFunctionParameter %float\n" "OpFunctionEnd\n"); } TEST(IrBuilder, KeepLineDebugInfo) { // #version 310 es // void main() {} DoRoundTripCheck( // clang-format off "OpCapability Shader\n" "%1 = OpExtInstImport \"GLSL.std.450\"\n" "OpMemoryModel Logical GLSL450\n" "OpEntryPoint Vertex %main \"main\"\n" "%3 = OpString \"minimal.vert\"\n" "OpSource ESSL 310\n" "OpName %main \"main\"\n" "OpLine %3 10 10\n" "%void = OpTypeVoid\n" "OpLine %3 100 100\n" "%5 = OpTypeFunction %void\n" "%main = OpFunction %void None %5\n" "OpLine %3 1 1\n" "OpNoLine\n" "OpLine %3 2 2\n" "OpLine %3 3 3\n" "%6 = OpLabel\n" "OpLine %3 4 4\n" "OpNoLine\n" "OpReturn\n" "OpFunctionEnd\n"); // clang-format on } TEST(IrBuilder, DistributeLineDebugInfo) { const std::string text = // clang-format off "OpCapability Shader\n" "%1 = OpExtInstImport \"GLSL.std.450\"\n" "OpMemoryModel Logical GLSL450\n" "OpEntryPoint Vertex %main \"main\"\n" "OpSource ESSL 310\n" "%file = OpString \"test\"\n" "OpName %main \"main\"\n" "OpName %f_ \"f(\"\n" "OpName %gv1 \"gv1\"\n" "OpName %gv2 \"gv2\"\n" "OpName %lv1 \"lv1\"\n" "OpName %lv2 \"lv2\"\n" "OpName %lv1_0 \"lv1\"\n" "%void = OpTypeVoid\n" "%10 = OpTypeFunction %void\n" "OpLine %file 10 0\n" "%float = OpTypeFloat 32\n" "%12 = OpTypeFunction %float\n" "%_ptr_Private_float = OpTypePointer Private %float\n" "%gv1 = OpVariable %_ptr_Private_float Private\n" "%float_10 = OpConstant %float 10\n" "%gv2 = OpVariable %_ptr_Private_float Private\n" "%float_100 = OpConstant %float 100\n" "%_ptr_Function_float = OpTypePointer Function %float\n" "%main = OpFunction %void None %10\n" "%17 = OpLabel\n" "%lv1_0 = OpVariable %_ptr_Function_float Function\n" "OpStore %gv1 %float_10\n" "OpStore %gv2 %float_100\n" "OpLine %file 1 0\n" "OpNoLine\n" "OpLine %file 2 0\n" "%18 = OpLoad %float %gv1\n" "%19 = OpLoad %float %gv2\n" "%20 = OpFSub %float %18 %19\n" "OpStore %lv1_0 %20\n" "OpReturn\n" "OpFunctionEnd\n" "%f_ = OpFunction %float None %12\n" "%21 = OpLabel\n" "%lv1 = OpVariable %_ptr_Function_float Function\n" "%lv2 = OpVariable %_ptr_Function_float Function\n" "OpLine %file 3 0\n" "OpLine %file 4 0\n" "%22 = OpLoad %float %gv1\n" "%23 = OpLoad %float %gv2\n" "%24 = OpFAdd %float %22 %23\n" "OpStore %lv1 %24\n" "OpLine %file 5 0\n" "OpLine %file 6 0\n" "OpNoLine\n" "%25 = OpLoad %float %gv1\n" "%26 = OpLoad %float %gv2\n" "%27 = OpFMul %float %25 %26\n" "OpBranch %28\n" "%28 = OpLabel\n" "OpStore %lv2 %27\n" "%29 = OpLoad %float %lv1\n" "OpLine %file 7 0\n" "%30 = OpLoad %float %lv2\n" "%31 = OpFDiv %float %28 %29\n" "OpReturnValue %30\n" "OpFunctionEnd\n"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); ASSERT_NE(nullptr, context); struct LineInstrCheck { uint32_t id; std::vector line_numbers; }; const uint32_t kNoLine = 0; const LineInstrCheck line_checks[] = { {12, {10}}, {18, {1, kNoLine, 2}}, {19, {2}}, {20, {2}}, {22, {3, 4}}, {23, {4}}, {24, {4}}, {25, {5, 6, kNoLine}}, {26, {}}, {27, {}}, {28, {}}, {29, {}}, {30, {7}}, {31, {7}}, }; spvtools::opt::analysis::DefUseManager* def_use_mgr = context->get_def_use_mgr(); for (const LineInstrCheck& check : line_checks) { auto& lines = def_use_mgr->GetDef(check.id)->dbg_line_insts(); for (uint32_t i = 0; i < check.line_numbers.size(); ++i) { if (check.line_numbers[i] == kNoLine) { EXPECT_EQ(lines[i].opcode(), spv::Op::OpNoLine); continue; } EXPECT_EQ(lines[i].opcode(), spv::Op::OpLine); EXPECT_EQ(lines[i].GetSingleWordOperand(kOpLineOperandLineIndex), check.line_numbers[i]); } } } TEST(IrBuilder, BuildModule_WithoutExtraLines) { const std::string text = R"(OpCapability Shader OpMemoryModel Logical Simple OpEntryPoint Vertex %main "main" %file = OpString "my file" %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %float_1 = OpConstant %float 1 %main = OpFunction %void None %voidfn %100 = OpLabel %1 = OpFAdd %float %float_1 %float_1 OpLine %file 1 0 %2 = OpFMul %float %1 %1 %3 = OpFSub %float %2 %2 OpReturn OpFunctionEnd )"; std::vector binary; SpirvTools t(SPV_ENV_UNIVERSAL_1_1); ASSERT_TRUE(t.Assemble(text, &binary, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS)); // This is the function we're testing. std::unique_ptr context = BuildModule( SPV_ENV_UNIVERSAL_1_5, nullptr, binary.data(), binary.size(), false); ASSERT_NE(nullptr, context); spvtools::opt::analysis::DefUseManager* def_use_mgr = context->get_def_use_mgr(); std::vector opcodes; for (auto* inst = def_use_mgr->GetDef(1); inst && (inst->opcode() != spv::Op::OpFunctionEnd); inst = inst->NextNode()) { inst->ForEachInst( [&opcodes](spvtools::opt::Instruction* sub_inst) { opcodes.push_back(sub_inst->opcode()); }, true); } EXPECT_THAT(opcodes, ContainerEq(std::vector{ spv::Op::OpFAdd, spv::Op::OpLine, spv::Op::OpFMul, spv::Op::OpFSub, spv::Op::OpReturn})); } TEST(IrBuilder, BuildModule_WithExtraLines_IsDefault) { const std::string text = R"(OpCapability Shader OpMemoryModel Logical Simple OpEntryPoint Vertex %main "main" %file = OpString "my file" %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %float_1 = OpConstant %float 1 %main = OpFunction %void None %voidfn %100 = OpLabel %1 = OpFAdd %float %float_1 %float_1 OpLine %file 1 0 %2 = OpFMul %float %1 %1 %3 = OpFSub %float %2 %2 OpReturn OpFunctionEnd )"; std::vector binary; SpirvTools t(SPV_ENV_UNIVERSAL_1_1); ASSERT_TRUE(t.Assemble(text, &binary, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS)); // This is the function we're testing. std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_5, nullptr, binary.data(), binary.size()); spvtools::opt::analysis::DefUseManager* def_use_mgr = context->get_def_use_mgr(); std::vector opcodes; for (auto* inst = def_use_mgr->GetDef(1); inst && (inst->opcode() != spv::Op::OpFunctionEnd); inst = inst->NextNode()) { inst->ForEachInst( [&opcodes](spvtools::opt::Instruction* sub_inst) { opcodes.push_back(sub_inst->opcode()); }, true); } EXPECT_THAT(opcodes, ContainerEq(std::vector{ spv::Op::OpFAdd, spv::Op::OpLine, spv::Op::OpFMul, spv::Op::OpLine, spv::Op::OpFSub, spv::Op::OpLine, spv::Op::OpReturn})); } TEST(IrBuilder, ConsumeDebugInfoInst) { // /* HLSL */ // // struct VS_OUTPUT { // float4 pos : SV_POSITION; // float4 color : COLOR; // }; // // VS_OUTPUT main(float4 pos : POSITION, // float4 color : COLOR) { // VS_OUTPUT vout; // vout.pos = pos; // vout.color = color; // return vout; // } DoRoundTripCheck(R"(OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %pos %color %gl_Position %out_var_COLOR %7 = OpString "simple_vs.hlsl" %8 = OpString "#line 1 \"simple_vs.hlsl\" struct VS_OUTPUT { float4 pos : SV_POSITION; float4 color : COLOR; }; VS_OUTPUT main(float4 pos : POSITION, float4 color : COLOR) { VS_OUTPUT vout; vout.pos = pos; vout.color = color; return vout; } " OpSource HLSL 600 %7 "#line 1 \"simple_vs.hlsl\" struct VS_OUTPUT { float4 pos : SV_POSITION; float4 color : COLOR; }; VS_OUTPUT main(float4 pos : POSITION, float4 color : COLOR) { VS_OUTPUT vout; vout.pos = pos; vout.color = color; return vout; } " %9 = OpString "struct VS_OUTPUT" %10 = OpString "float" %11 = OpString "pos : SV_POSITION" %12 = OpString "color : COLOR" %13 = OpString "VS_OUTPUT" %14 = OpString "main" %15 = OpString "VS_OUTPUT_main_v4f_v4f" %16 = OpString "pos : POSITION" %17 = OpString "color : COLOR" %18 = OpString "vout" OpName %out_var_COLOR "out.var.COLOR" OpName %main "main" OpName %VS_OUTPUT "VS_OUTPUT" OpMemberName %VS_OUTPUT 0 "pos" OpMemberName %VS_OUTPUT 1 "color" OpName %pos "pos" OpName %color "color" OpName %vout "vout" OpDecorate %gl_Position BuiltIn Position OpDecorate %pos Location 0 OpDecorate %color Location 1 OpDecorate %out_var_COLOR Location 0 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %int_32 = OpConstant %int 32 %int_128 = OpConstant %int 128 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %31 = OpTypeFunction %void %_ptr_Function_v4float = OpTypePointer Function %v4float %VS_OUTPUT = OpTypeStruct %v4float %v4float %_ptr_Function_VS_OUTPUT = OpTypePointer Function %VS_OUTPUT OpLine %7 6 23 %pos = OpVariable %_ptr_Input_v4float Input OpLine %7 7 23 %color = OpVariable %_ptr_Input_v4float Input OpLine %7 2 16 %gl_Position = OpVariable %_ptr_Output_v4float Output OpLine %7 3 18 %out_var_COLOR = OpVariable %_ptr_Output_v4float Output %34 = OpExtInst %void %1 DebugSource %7 %8 %35 = OpExtInst %void %1 DebugCompilationUnit 2 4 %34 HLSL %36 = OpExtInst %void %1 DebugTypeComposite %9 Structure %34 1 1 %35 %13 %int_128 FlagIsProtected|FlagIsPrivate %37 %38 %39 = OpExtInst %void %1 DebugTypeBasic %10 %int_32 Float %40 = OpExtInst %void %1 DebugTypeVector %39 4 %37 = OpExtInst %void %1 DebugTypeMember %11 %40 %34 2 3 %36 %int_0 %int_128 FlagIsProtected|FlagIsPrivate %38 = OpExtInst %void %1 DebugTypeMember %12 %40 %34 3 3 %36 %int_128 %int_128 FlagIsProtected|FlagIsPrivate %41 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %36 %40 %40 %42 = OpExtInst %void %1 DebugExpression %43 = OpExtInst %void %1 DebugFunction %14 %41 %34 6 1 %35 %15 FlagIsProtected|FlagIsPrivate 7 %main %44 = OpExtInst %void %1 DebugLocalVariable %16 %40 %34 6 16 %43 FlagIsLocal 0 %45 = OpExtInst %void %1 DebugLocalVariable %17 %40 %34 7 16 %43 FlagIsLocal 1 %46 = OpExtInst %void %1 DebugLocalVariable %18 %36 %34 8 3 %43 FlagIsLocal OpLine %7 6 1 %main = OpFunction %void None %31 %47 = OpLabel %60 = OpExtInst %void %1 DebugScope %43 OpLine %7 8 13 %vout = OpVariable %_ptr_Function_VS_OUTPUT Function %49 = OpExtInst %void %1 DebugDeclare %46 %vout %42 OpLine %7 9 14 %50 = OpLoad %v4float %pos OpLine %7 9 3 %51 = OpAccessChain %_ptr_Function_v4float %vout %int_0 %52 = OpExtInst %void %1 DebugValue %46 %51 %42 %int_0 OpStore %51 %50 OpLine %7 10 16 %53 = OpLoad %v4float %color OpLine %7 10 3 %54 = OpAccessChain %_ptr_Function_v4float %vout %int_1 %55 = OpExtInst %void %1 DebugValue %46 %54 %42 %int_1 OpStore %54 %53 OpLine %7 11 10 %56 = OpLoad %VS_OUTPUT %vout OpLine %7 11 3 %57 = OpCompositeExtract %v4float %56 0 OpStore %gl_Position %57 %58 = OpCompositeExtract %v4float %56 1 OpStore %out_var_COLOR %58 %61 = OpExtInst %void %1 DebugNoScope OpReturn OpFunctionEnd )"); } TEST(IrBuilder, ConsumeDebugInfoLexicalScopeInst) { // /* HLSL */ // // float4 func2(float arg2) { // func2_block // return float4(arg2, 0, 0, 0); // } // // float4 func1(float arg1) { // func1_block // if (arg1 > 1) { // if_true_block // return float4(0, 0, 0, 0); // } // return func2(arg1); // if_merge_block // } // // float4 main(float pos : POSITION) : SV_POSITION { // main // return func1(pos); // } DoRoundTripCheck(R"(OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %pos %gl_Position %5 = OpString "block/block.hlsl" %6 = OpString "#line 1 \"block/block.hlsl\" float4 func2(float arg2) { return float4(arg2, 0, 0, 0); } float4 func1(float arg1) { if (arg1 > 1) { return float4(0, 0, 0, 0); } return func2(arg1); } float4 main(float pos : POSITION) : SV_POSITION { return func1(pos); } " OpSource HLSL 600 %5 "#line 1 \"block/block.hlsl\" float4 func2(float arg2) { return float4(arg2, 0, 0, 0); } float4 func1(float arg1) { if (arg1 > 1) { return float4(0, 0, 0, 0); } return func2(arg1); } float4 main(float pos : POSITION) : SV_POSITION { return func1(pos); } " %7 = OpString "float" %8 = OpString "main" %9 = OpString "v4f_main_f" %10 = OpString "v4f_func1_f" %11 = OpString "v4f_func2_f" %12 = OpString "pos : POSITION" %13 = OpString "func1" %14 = OpString "func2" OpName %main "main" OpName %pos "pos" OpName %bb_entry "bb.entry" OpName %param_var_arg1 "param.var.arg1" OpName %func1 "func1" OpName %arg1 "arg1" OpName %bb_entry_0 "bb.entry" OpName %param_var_arg2 "param.var.arg2" OpName %if_true "if.true" OpName %if_merge "if.merge" OpName %func2 "func2" OpName %arg2 "arg2" OpName %bb_entry_1 "bb.entry" OpDecorate %gl_Position BuiltIn Position OpDecorate %pos Location 0 %float = OpTypeFloat 32 %int = OpTypeInt 32 1 %float_1 = OpConstant %float 1 %float_0 = OpConstant %float 0 %int_32 = OpConstant %int 32 %v4float = OpTypeVector %float 4 %32 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %_ptr_Input_float = OpTypePointer Input %float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %36 = OpTypeFunction %void %_ptr_Function_float = OpTypePointer Function %float %38 = OpTypeFunction %v4float %_ptr_Function_float %bool = OpTypeBool OpLine %5 12 25 %pos = OpVariable %_ptr_Input_float Input OpLine %5 12 37 %gl_Position = OpVariable %_ptr_Output_v4float Output %40 = OpExtInst %void %1 DebugSource %5 %6 %41 = OpExtInst %void %1 DebugCompilationUnit 2 4 %40 HLSL %42 = OpExtInst %void %1 DebugTypeBasic %7 %int_32 Float %43 = OpExtInst %void %1 DebugTypeVector %42 4 %44 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %43 %42 %45 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %43 %42 %46 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %43 %42 %47 = OpExtInst %void %1 DebugFunction %8 %44 %40 12 1 %41 %9 FlagIsProtected|FlagIsPrivate 13 %main %48 = OpExtInst %void %1 DebugFunction %13 %45 %40 5 1 %41 %10 FlagIsProtected|FlagIsPrivate 13 %func1 %49 = OpExtInst %void %1 DebugFunction %14 %46 %40 1 1 %41 %11 FlagIsProtected|FlagIsPrivate 13 %func2 %50 = OpExtInst %void %1 DebugLexicalBlock %40 6 17 %48 %51 = OpExtInst %void %1 DebugLexicalBlock %40 9 3 %48 OpLine %5 12 1 %main = OpFunction %void None %36 %bb_entry = OpLabel %70 = OpExtInst %void %1 DebugScope %47 OpLine %5 13 16 %param_var_arg1 = OpVariable %_ptr_Function_float Function %53 = OpLoad %float %pos OpStore %param_var_arg1 %53 OpLine %5 13 10 %54 = OpFunctionCall %v4float %func1 %param_var_arg1 OpLine %5 13 3 OpStore %gl_Position %54 %71 = OpExtInst %void %1 DebugNoScope OpReturn OpFunctionEnd OpLine %5 5 1 %func1 = OpFunction %v4float None %38 OpLine %5 5 20 %arg1 = OpFunctionParameter %_ptr_Function_float %bb_entry_0 = OpLabel %72 = OpExtInst %void %1 DebugScope %48 OpLine %5 9 16 %param_var_arg2 = OpVariable %_ptr_Function_float Function OpLine %5 6 7 %57 = OpLoad %float %arg1 OpLine %5 6 12 %58 = OpFOrdGreaterThan %bool %57 %float_1 OpLine %5 6 17 %73 = OpExtInst %void %1 DebugNoScope OpSelectionMerge %if_merge None OpBranchConditional %58 %if_true %if_merge %if_true = OpLabel %74 = OpExtInst %void %1 DebugScope %50 OpLine %5 7 5 %75 = OpExtInst %void %1 DebugNoScope OpReturnValue %32 %if_merge = OpLabel %76 = OpExtInst %void %1 DebugScope %51 OpLine %5 9 16 %63 = OpLoad %float %arg1 OpStore %param_var_arg2 %63 OpLine %5 9 10 %64 = OpFunctionCall %v4float %func2 %param_var_arg2 OpLine %5 9 3 %77 = OpExtInst %void %1 DebugNoScope OpReturnValue %64 OpFunctionEnd OpLine %5 1 1 %func2 = OpFunction %v4float None %38 OpLine %5 1 20 %arg2 = OpFunctionParameter %_ptr_Function_float %bb_entry_1 = OpLabel %78 = OpExtInst %void %1 DebugScope %49 OpLine %5 2 17 %67 = OpLoad %float %arg2 %68 = OpCompositeConstruct %v4float %67 %float_0 %float_0 %float_0 OpLine %5 2 3 %79 = OpExtInst %void %1 DebugNoScope OpReturnValue %68 OpFunctionEnd )"); } TEST(IrBuilder, ConsumeDebugInlinedAt) { // /* HLSL */ // // float4 func2(float arg2) { // func2_block // return float4(arg2, 0, 0, 0); // } // // float4 func1(float arg1) { // func1_block // if (arg1 > 1) { // if_true_block // return float4(0, 0, 0, 0); // } // return func2(arg1); // if_merge_block // } // // float4 main(float pos : POSITION) : SV_POSITION { // main // return func1(pos); // } // // TODO(https://gitlab.khronos.org/spirv/SPIR-V/issues/533): In the following // SPIRV code, we use DebugInfoNone to reference opted-out function from // DebugFunction similar to opted-out global variable for DebugGlobalVariable, // but this is not a part of the spec yet. We are still in discussion and we // must correct it if our decision is different. DoRoundTripCheck(R"(OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %pos %gl_Position %5 = OpString "block/block.hlsl" %6 = OpString "#line 1 \"block/block.hlsl\" float4 func2(float arg2) { return float4(arg2, 0, 0, 0); } float4 func1(float arg1) { if (arg1 > 1) { return float4(0, 0, 0, 0); } return func2(arg1); } float4 main(float pos : POSITION) : SV_POSITION { return func1(pos); } " OpSource HLSL 600 %5 "#line 1 \"block/block.hlsl\" float4 func2(float arg2) { return float4(arg2, 0, 0, 0); } float4 func1(float arg1) { if (arg1 > 1) { return float4(0, 0, 0, 0); } return func2(arg1); } float4 main(float pos : POSITION) : SV_POSITION { return func1(pos); } " %7 = OpString "float" %8 = OpString "main" %9 = OpString "v4f_main_f" %10 = OpString "v4f_func1_f" %11 = OpString "v4f_func2_f" %12 = OpString "pos : POSITION" %13 = OpString "func1" %14 = OpString "func2" OpName %main "main" OpName %pos "pos" OpName %bb_entry "bb.entry" OpName %if_true "if.true" OpName %if_merge "if.merge" OpDecorate %gl_Position BuiltIn Position OpDecorate %pos Location 0 %float = OpTypeFloat 32 %int = OpTypeInt 32 1 %float_1 = OpConstant %float 1 %float_0 = OpConstant %float 0 %int_32 = OpConstant %int 32 %v4float = OpTypeVector %float 4 %24 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %_ptr_Input_float = OpTypePointer Input %float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %28 = OpTypeFunction %void %_ptr_Function_float = OpTypePointer Function %float %30 = OpTypeFunction %v4float %_ptr_Function_float %bool = OpTypeBool OpLine %5 12 25 %pos = OpVariable %_ptr_Input_float Input OpLine %5 12 37 %gl_Position = OpVariable %_ptr_Output_v4float Output %32 = OpExtInst %void %1 DebugInfoNone %33 = OpExtInst %void %1 DebugSource %5 %6 %34 = OpExtInst %void %1 DebugCompilationUnit 2 4 %33 HLSL %35 = OpExtInst %void %1 DebugTypeBasic %7 %int_32 Float %36 = OpExtInst %void %1 DebugTypeVector %35 4 %37 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %36 %35 %38 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %36 %35 %39 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %36 %35 %40 = OpExtInst %void %1 DebugFunction %8 %37 %33 12 1 %34 %9 FlagIsProtected|FlagIsPrivate 13 %main %41 = OpExtInst %void %1 DebugFunction %13 %38 %33 5 1 %34 %10 FlagIsProtected|FlagIsPrivate 13 %32 %42 = OpExtInst %void %1 DebugFunction %14 %39 %33 1 1 %34 %11 FlagIsProtected|FlagIsPrivate 13 %32 %43 = OpExtInst %void %1 DebugLexicalBlock %33 12 49 %40 %44 = OpExtInst %void %1 DebugLexicalBlock %33 5 26 %41 %45 = OpExtInst %void %1 DebugLexicalBlock %33 1 26 %42 %46 = OpExtInst %void %1 DebugLexicalBlock %33 6 17 %44 %47 = OpExtInst %void %1 DebugLexicalBlock %33 9 3 %44 %48 = OpExtInst %void %1 DebugInlinedAt 9 %47 %49 = OpExtInst %void %1 DebugInlinedAt 13 %43 %50 = OpExtInst %void %1 DebugInlinedAt 13 %43 %48 OpLine %5 12 1 %main = OpFunction %void None %28 %bb_entry = OpLabel %62 = OpExtInst %void %1 DebugScope %44 %49 OpLine %5 6 7 %52 = OpLoad %float %pos OpLine %5 6 12 %53 = OpFOrdGreaterThan %bool %52 %float_1 OpLine %5 6 17 %63 = OpExtInst %void %1 DebugNoScope OpSelectionMerge %if_merge None OpBranchConditional %53 %if_true %if_merge %if_true = OpLabel %64 = OpExtInst %void %1 DebugScope %46 %49 OpLine %5 7 5 OpStore %gl_Position %24 %65 = OpExtInst %void %1 DebugNoScope OpReturn %if_merge = OpLabel %66 = OpExtInst %void %1 DebugScope %45 %50 OpLine %5 2 17 %58 = OpLoad %float %pos OpLine %5 2 10 %59 = OpCompositeConstruct %v4float %58 %float_0 %float_0 %float_0 %67 = OpExtInst %void %1 DebugScope %43 OpLine %5 13 3 OpStore %gl_Position %59 %68 = OpExtInst %void %1 DebugNoScope OpReturn OpFunctionEnd )"); } TEST(IrBuilder, DebugInfoInstInFunctionOutOfBlock) { // /* HLSL */ // // float4 func2(float arg2) { // func2_block // return float4(arg2, 0, 0, 0); // } // // float4 func1(float arg1) { // func1_block // if (arg1 > 1) { // if_true_block // return float4(0, 0, 0, 0); // } // return func2(arg1); // if_merge_block // } // // float4 main(float pos : POSITION) : SV_POSITION { // main // return func1(pos); // } const std::string text = R"(OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %pos %gl_Position %5 = OpString "block/block.hlsl" %6 = OpString "#line 1 \"block/block.hlsl\" float4 func2(float arg2) { return float4(arg2, 0, 0, 0); } float4 func1(float arg1) { if (arg1 > 1) { return float4(0, 0, 0, 0); } return func2(arg1); } float4 main(float pos : POSITION) : SV_POSITION { return func1(pos); } " OpSource HLSL 600 %5 "#line 1 \"block/block.hlsl\" float4 func2(float arg2) { return float4(arg2, 0, 0, 0); } float4 func1(float arg1) { if (arg1 > 1) { return float4(0, 0, 0, 0); } return func2(arg1); } float4 main(float pos : POSITION) : SV_POSITION { return func1(pos); } " %7 = OpString "float" %8 = OpString "main" %9 = OpString "v4f_main_f" %10 = OpString "v4f_func1_f" %11 = OpString "v4f_func2_f" %12 = OpString "pos : POSITION" %13 = OpString "func1" %14 = OpString "func2" OpName %main "main" OpName %pos "pos" OpName %bb_entry "bb.entry" OpName %param_var_arg1 "param.var.arg1" OpName %func1 "func1" OpName %arg1 "arg1" OpName %bb_entry_0 "bb.entry" OpName %param_var_arg2 "param.var.arg2" OpName %if_true "if.true" OpName %if_merge "if.merge" OpName %func2 "func2" OpName %arg2 "arg2" OpName %bb_entry_1 "bb.entry" OpDecorate %gl_Position BuiltIn Position OpDecorate %pos Location 0 %float = OpTypeFloat 32 %int = OpTypeInt 32 1 %float_1 = OpConstant %float 1 %float_0 = OpConstant %float 0 %int_32 = OpConstant %int 32 %v4float = OpTypeVector %float 4 %32 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %_ptr_Input_float = OpTypePointer Input %float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %36 = OpTypeFunction %void %_ptr_Function_float = OpTypePointer Function %float %38 = OpTypeFunction %v4float %_ptr_Function_float %bool = OpTypeBool OpLine %5 12 25 %pos = OpVariable %_ptr_Input_float Input OpLine %5 12 37 %gl_Position = OpVariable %_ptr_Output_v4float Output %40 = OpExtInst %void %1 DebugSource %5 %6 %41 = OpExtInst %void %1 DebugCompilationUnit 2 4 %40 HLSL %42 = OpExtInst %void %1 DebugTypeBasic %7 %int_32 Float %43 = OpExtInst %void %1 DebugTypeVector %42 4 %44 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %43 %42 %45 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %43 %42 %46 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %43 %42 %47 = OpExtInst %void %1 DebugFunction %8 %44 %40 12 1 %41 %9 FlagIsProtected|FlagIsPrivate 13 %main %48 = OpExtInst %void %1 DebugFunction %13 %45 %40 5 1 %41 %10 FlagIsProtected|FlagIsPrivate 13 %func1 %49 = OpExtInst %void %1 DebugFunction %14 %46 %40 1 1 %41 %11 FlagIsProtected|FlagIsPrivate 13 %func2 %50 = OpExtInst %void %1 DebugLexicalBlock %40 6 17 %48 %51 = OpExtInst %void %1 DebugLexicalBlock %40 9 3 %48 OpLine %5 12 1 %main = OpFunction %void None %36 %bb_entry = OpLabel %70 = OpExtInst %void %1 DebugScope %47 OpLine %5 13 16 %param_var_arg1 = OpVariable %_ptr_Function_float Function %53 = OpLoad %float %pos OpStore %param_var_arg1 %53 OpLine %5 13 10 %54 = OpFunctionCall %v4float %func1 %param_var_arg1 OpLine %5 13 3 OpStore %gl_Position %54 %71 = OpExtInst %void %1 DebugNoScope OpReturn OpFunctionEnd OpLine %5 5 1 %func1 = OpFunction %v4float None %38 OpLine %5 5 20 %arg1 = OpFunctionParameter %_ptr_Function_float %bb_entry_0 = OpLabel %72 = OpExtInst %void %1 DebugScope %48 OpLine %5 9 16 %param_var_arg2 = OpVariable %_ptr_Function_float Function OpLine %5 6 7 %57 = OpLoad %float %arg1 OpLine %5 6 12 %58 = OpFOrdGreaterThan %bool %57 %float_1 OpLine %5 6 17 %73 = OpExtInst %void %1 DebugNoScope OpSelectionMerge %if_merge None OpBranchConditional %58 %if_true %if_merge %if_true = OpLabel %74 = OpExtInst %void %1 DebugScope %50 OpLine %5 7 5 %75 = OpExtInst %void %1 DebugNoScope OpReturnValue %32 %if_merge = OpLabel %76 = OpExtInst %void %1 DebugScope %51 OpLine %5 9 16 %63 = OpLoad %float %arg1 OpStore %param_var_arg2 %63 OpLine %5 9 10 %64 = OpFunctionCall %v4float %func2 %param_var_arg2 OpLine %5 9 3 %77 = OpExtInst %void %1 DebugNoScope OpReturnValue %64 OpFunctionEnd OpLine %5 1 1 %func2 = OpFunction %v4float None %38 OpLine %5 1 20 %arg2 = OpFunctionParameter %_ptr_Function_float %bb_entry_1 = OpLabel %78 = OpExtInst %void %1 DebugScope %49 OpLine %5 2 17 %67 = OpLoad %float %arg2 %68 = OpCompositeConstruct %v4float %67 %float_0 %float_0 %float_0 OpLine %5 2 3 %79 = OpExtInst %void %1 DebugNoScope OpReturnValue %68 OpFunctionEnd )"; SpirvTools t(SPV_ENV_UNIVERSAL_1_1); std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text); ASSERT_NE(nullptr, context); std::vector binary; context->module()->ToBinary(&binary, /* skip_nop = */ false); std::string disassembled_text; EXPECT_TRUE(t.Disassemble(binary, &disassembled_text)); EXPECT_EQ(text, disassembled_text); } TEST(IrBuilder, DebugInfoInstInFunctionOutOfBlock2) { // /* HLSL */ // // struct VS_OUTPUT { // float4 pos : SV_POSITION; // float4 color : COLOR; // }; // // VS_OUTPUT main(float4 pos : POSITION, // float4 color : COLOR) { // VS_OUTPUT vout; // vout.pos = pos; // vout.color = color; // return vout; // } const std::string text = R"(OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %in_var_POSITION %in_var_COLOR %gl_Position %out_var_COLOR %7 = OpString "vs.hlsl" OpSource HLSL 600 %7 "#line 1 \"vs.hlsl\" struct VS_OUTPUT { float4 pos : SV_POSITION; float4 color : COLOR; }; VS_OUTPUT main(float4 pos : POSITION, float4 color : COLOR) { VS_OUTPUT vout; vout.pos = pos; vout.color = color; return vout; } " %8 = OpString "#line 1 \"vs.hlsl\" struct VS_OUTPUT { float4 pos : SV_POSITION; float4 color : COLOR; }; VS_OUTPUT main(float4 pos : POSITION, float4 color : COLOR) { VS_OUTPUT vout; vout.pos = pos; vout.color = color; return vout; } " %9 = OpString "VS_OUTPUT" %10 = OpString "float" %11 = OpString "src.main" %12 = OpString "pos" %13 = OpString "color" %14 = OpString "vout" OpName %in_var_POSITION "in.var.POSITION" OpName %in_var_COLOR "in.var.COLOR" OpName %out_var_COLOR "out.var.COLOR" OpName %main "main" OpName %param_var_pos "param.var.pos" OpName %param_var_color "param.var.color" OpName %VS_OUTPUT "VS_OUTPUT" OpMemberName %VS_OUTPUT 0 "pos" OpMemberName %VS_OUTPUT 1 "color" OpName %src_main "src.main" OpName %pos "pos" OpName %color "color" OpName %bb_entry "bb.entry" OpName %vout "vout" OpDecorate %gl_Position BuiltIn Position OpDecorate %in_var_POSITION Location 0 OpDecorate %in_var_COLOR Location 1 OpDecorate %out_var_COLOR Location 0 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %uint_256 = OpConstant %uint 256 %uint_0 = OpConstant %uint 0 %uint_128 = OpConstant %uint 128 %36 = OpTypeFunction %void %_ptr_Function_v4float = OpTypePointer Function %v4float %VS_OUTPUT = OpTypeStruct %v4float %v4float %38 = OpTypeFunction %VS_OUTPUT %_ptr_Function_v4float %_ptr_Function_v4float %_ptr_Function_VS_OUTPUT = OpTypePointer Function %VS_OUTPUT OpLine %7 6 29 %in_var_POSITION = OpVariable %_ptr_Input_v4float Input OpLine %7 7 31 %in_var_COLOR = OpVariable %_ptr_Input_v4float Input OpLine %7 2 16 %gl_Position = OpVariable %_ptr_Output_v4float Output OpLine %7 3 18 %out_var_COLOR = OpVariable %_ptr_Output_v4float Output %40 = OpExtInst %void %1 DebugExpression %41 = OpExtInst %void %1 DebugSource %7 %8 %42 = OpExtInst %void %1 DebugCompilationUnit 1 4 %41 HLSL %43 = OpExtInst %void %1 DebugTypeComposite %9 Structure %41 1 1 %42 %9 %uint_256 FlagIsProtected|FlagIsPrivate %44 %45 %46 = OpExtInst %void %1 DebugTypeBasic %10 %uint_32 Float %47 = OpExtInst %void %1 DebugTypeVector %46 4 %48 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %43 %47 %47 %49 = OpExtInst %void %1 DebugFunction %11 %48 %41 6 1 %42 %11 FlagIsProtected|FlagIsPrivate 7 %src_main %50 = OpExtInst %void %1 DebugLocalVariable %12 %47 %41 6 23 %49 FlagIsLocal 0 %51 = OpExtInst %void %1 DebugLocalVariable %13 %47 %41 7 23 %49 FlagIsLocal 1 %52 = OpExtInst %void %1 DebugLexicalBlock %41 7 38 %49 %53 = OpExtInst %void %1 DebugLocalVariable %14 %43 %41 8 13 %52 FlagIsLocal %44 = OpExtInst %void %1 DebugTypeMember %12 %47 %41 2 3 %43 %uint_0 %uint_128 FlagIsProtected|FlagIsPrivate %45 = OpExtInst %void %1 DebugTypeMember %13 %47 %41 3 3 %43 %uint_128 %uint_128 FlagIsProtected|FlagIsPrivate OpLine %7 6 1 %main = OpFunction %void None %36 %54 = OpLabel %74 = OpExtInst %void %1 DebugScope %42 OpLine %7 6 23 %param_var_pos = OpVariable %_ptr_Function_v4float Function OpLine %7 7 23 %param_var_color = OpVariable %_ptr_Function_v4float Function OpLine %7 6 23 %56 = OpLoad %v4float %in_var_POSITION OpStore %param_var_pos %56 OpLine %7 7 23 %57 = OpLoad %v4float %in_var_COLOR OpStore %param_var_color %57 OpLine %7 6 1 %58 = OpFunctionCall %VS_OUTPUT %src_main %param_var_pos %param_var_color OpLine %7 6 11 %59 = OpCompositeExtract %v4float %58 0 OpLine %7 2 16 OpStore %gl_Position %59 OpLine %7 6 11 %60 = OpCompositeExtract %v4float %58 1 OpLine %7 3 18 OpStore %out_var_COLOR %60 %75 = OpExtInst %void %1 DebugNoScope OpReturn OpFunctionEnd OpLine %7 6 1 %src_main = OpFunction %VS_OUTPUT None %38 %76 = OpExtInst %void %1 DebugScope %49 OpLine %7 6 23 %pos = OpFunctionParameter %_ptr_Function_v4float OpLine %7 7 23 %color = OpFunctionParameter %_ptr_Function_v4float %63 = OpExtInst %void %1 DebugDeclare %50 %pos %40 %64 = OpExtInst %void %1 DebugDeclare %51 %color %40 %77 = OpExtInst %void %1 DebugNoScope %bb_entry = OpLabel %78 = OpExtInst %void %1 DebugScope %52 OpLine %7 8 13 %vout = OpVariable %_ptr_Function_VS_OUTPUT Function %67 = OpExtInst %void %1 DebugDeclare %53 %vout %40 OpLine %7 9 14 %68 = OpLoad %v4float %pos OpLine %7 9 3 %69 = OpAccessChain %_ptr_Function_v4float %vout %int_0 OpStore %69 %68 OpLine %7 10 16 %70 = OpLoad %v4float %color OpLine %7 10 3 %71 = OpAccessChain %_ptr_Function_v4float %vout %int_1 OpStore %71 %70 OpLine %7 11 10 %72 = OpLoad %VS_OUTPUT %vout OpLine %7 11 3 %79 = OpExtInst %void %1 DebugNoScope OpReturnValue %72 OpFunctionEnd )"; SpirvTools t(SPV_ENV_UNIVERSAL_1_1); std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text); ASSERT_NE(nullptr, context); std::vector binary; context->module()->ToBinary(&binary, /* skip_nop = */ false); std::string disassembled_text; EXPECT_TRUE(t.Disassemble(binary, &disassembled_text)); EXPECT_EQ(text, disassembled_text); } TEST(IrBuilder, DebugInfoForTerminationInsts) { // Check that DebugScope instructions for termination instructions are // preserved. DoRoundTripCheck(R"(OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %3 = OpString "simple_vs.hlsl" OpSource HLSL 600 %3 OpName %main "main" %void = OpTypeVoid %5 = OpTypeFunction %void %6 = OpExtInst %void %1 DebugSource %3 %7 = OpExtInst %void %1 DebugCompilationUnit 2 4 %6 HLSL %main = OpFunction %void None %5 %8 = OpLabel %20 = OpExtInst %void %1 DebugScope %7 OpBranch %10 %21 = OpExtInst %void %1 DebugNoScope %10 = OpLabel %22 = OpExtInst %void %1 DebugScope %7 OpKill %23 = OpExtInst %void %1 DebugNoScope %14 = OpLabel %24 = OpExtInst %void %1 DebugScope %7 OpUnreachable %25 = OpExtInst %void %1 DebugNoScope %17 = OpLabel %26 = OpExtInst %void %1 DebugScope %7 OpReturn %27 = OpExtInst %void %1 DebugNoScope OpFunctionEnd )"); } TEST(IrBuilder, LocalGlobalVariables) { // #version 310 es // // float gv1 = 10.; // float gv2 = 100.; // // float f() { // float lv1 = gv1 + gv2; // float lv2 = gv1 * gv2; // return lv1 / lv2; // } // // void main() { // float lv1 = gv1 - gv2; // } DoRoundTripCheck( // clang-format off "OpCapability Shader\n" "%1 = OpExtInstImport \"GLSL.std.450\"\n" "OpMemoryModel Logical GLSL450\n" "OpEntryPoint Vertex %main \"main\"\n" "OpSource ESSL 310\n" "OpName %main \"main\"\n" "OpName %f_ \"f(\"\n" "OpName %gv1 \"gv1\"\n" "OpName %gv2 \"gv2\"\n" "OpName %lv1 \"lv1\"\n" "OpName %lv2 \"lv2\"\n" "OpName %lv1_0 \"lv1\"\n" "%void = OpTypeVoid\n" "%10 = OpTypeFunction %void\n" "%float = OpTypeFloat 32\n" "%12 = OpTypeFunction %float\n" "%_ptr_Private_float = OpTypePointer Private %float\n" "%gv1 = OpVariable %_ptr_Private_float Private\n" "%float_10 = OpConstant %float 10\n" "%gv2 = OpVariable %_ptr_Private_float Private\n" "%float_100 = OpConstant %float 100\n" "%_ptr_Function_float = OpTypePointer Function %float\n" "%main = OpFunction %void None %10\n" "%17 = OpLabel\n" "%lv1_0 = OpVariable %_ptr_Function_float Function\n" "OpStore %gv1 %float_10\n" "OpStore %gv2 %float_100\n" "%18 = OpLoad %float %gv1\n" "%19 = OpLoad %float %gv2\n" "%20 = OpFSub %float %18 %19\n" "OpStore %lv1_0 %20\n" "OpReturn\n" "OpFunctionEnd\n" "%f_ = OpFunction %float None %12\n" "%21 = OpLabel\n" "%lv1 = OpVariable %_ptr_Function_float Function\n" "%lv2 = OpVariable %_ptr_Function_float Function\n" "%22 = OpLoad %float %gv1\n" "%23 = OpLoad %float %gv2\n" "%24 = OpFAdd %float %22 %23\n" "OpStore %lv1 %24\n" "%25 = OpLoad %float %gv1\n" "%26 = OpLoad %float %gv2\n" "%27 = OpFMul %float %25 %26\n" "OpStore %lv2 %27\n" "%28 = OpLoad %float %lv1\n" "%29 = OpLoad %float %lv2\n" "%30 = OpFDiv %float %28 %29\n" "OpReturnValue %30\n" "OpFunctionEnd\n"); // clang-format on } TEST(IrBuilder, OpUndefOutsideFunction) { // #version 310 es // void main() {} const std::string text = // clang-format off "OpMemoryModel Logical GLSL450\n" "%int = OpTypeInt 32 1\n" "%uint = OpTypeInt 32 0\n" "%float = OpTypeFloat 32\n" "%4 = OpUndef %int\n" "%int_10 = OpConstant %int 10\n" "%6 = OpUndef %uint\n" "%bool = OpTypeBool\n" "%8 = OpUndef %float\n" "%double = OpTypeFloat 64\n"; // clang-format on SpirvTools t(SPV_ENV_UNIVERSAL_1_1); std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text); ASSERT_NE(nullptr, context); const auto opundef_count = std::count_if( context->module()->types_values_begin(), context->module()->types_values_end(), [](const Instruction& inst) { return inst.opcode() == spv::Op::OpUndef; }); EXPECT_EQ(3, opundef_count); std::vector binary; context->module()->ToBinary(&binary, /* skip_nop = */ false); std::string disassembled_text; EXPECT_TRUE(t.Disassemble(binary, &disassembled_text)); EXPECT_EQ(text, disassembled_text); } TEST(IrBuilder, OpUndefInBasicBlock) { DoRoundTripCheck( // clang-format off "OpMemoryModel Logical GLSL450\n" "OpName %main \"main\"\n" "%void = OpTypeVoid\n" "%uint = OpTypeInt 32 0\n" "%double = OpTypeFloat 64\n" "%5 = OpTypeFunction %void\n" "%main = OpFunction %void None %5\n" "%6 = OpLabel\n" "%7 = OpUndef %uint\n" "%8 = OpUndef %double\n" "OpReturn\n" "OpFunctionEnd\n"); // clang-format on } TEST(IrBuilder, KeepLineDebugInfoBeforeType) { DoRoundTripCheck( // clang-format off "OpCapability Shader\n" "OpMemoryModel Logical GLSL450\n" "%1 = OpString \"minimal.vert\"\n" "OpLine %1 1 1\n" "OpNoLine\n" "%void = OpTypeVoid\n" "OpLine %1 2 2\n" "%3 = OpTypeFunction %void\n"); // clang-format on } TEST(IrBuilder, KeepLineDebugInfoBeforeLabel) { DoRoundTripCheck( // clang-format off "OpCapability Shader\n" "OpMemoryModel Logical GLSL450\n" "%1 = OpString \"minimal.vert\"\n" "%void = OpTypeVoid\n" "%3 = OpTypeFunction %void\n" "%4 = OpFunction %void None %3\n" "%5 = OpLabel\n" "OpBranch %6\n" "OpLine %1 1 1\n" "OpLine %1 2 2\n" "%6 = OpLabel\n" "OpBranch %7\n" "OpLine %1 100 100\n" "%7 = OpLabel\n" "OpReturn\n" "OpFunctionEnd\n"); // clang-format on } TEST(IrBuilder, KeepLineDebugInfoBeforeFunctionEnd) { DoRoundTripCheck( // clang-format off "OpCapability Shader\n" "OpMemoryModel Logical GLSL450\n" "%1 = OpString \"minimal.vert\"\n" "%void = OpTypeVoid\n" "%3 = OpTypeFunction %void\n" "%4 = OpFunction %void None %3\n" "OpLine %1 1 1\n" "OpLine %1 2 2\n" "OpFunctionEnd\n"); // clang-format on } TEST(IrBuilder, KeepModuleProcessedInRightPlace) { DoRoundTripCheck( // clang-format off "OpCapability Shader\n" "OpMemoryModel Logical GLSL450\n" "%1 = OpString \"minimal.vert\"\n" "OpName %void \"void\"\n" "OpModuleProcessed \"Made it faster\"\n" "OpModuleProcessed \".. and smaller\"\n" "%void = OpTypeVoid\n"); // clang-format on } // Checks the given |error_message| is reported when trying to build a module // from the given |assembly|. void DoErrorMessageCheck(const std::string& assembly, const std::string& error_message, uint32_t line_num) { auto consumer = [error_message, line_num](spv_message_level_t, const char*, const spv_position_t& position, const char* m) { EXPECT_EQ(error_message, m); EXPECT_EQ(line_num, position.line); }; SpirvTools t(SPV_ENV_UNIVERSAL_1_1); std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, std::move(consumer), assembly); EXPECT_EQ(nullptr, context); } TEST(IrBuilder, FunctionInsideFunction) { DoErrorMessageCheck("%2 = OpFunction %1 None %3\n%5 = OpFunction %4 None %6", "function inside function", 2); } TEST(IrBuilder, MismatchOpFunctionEnd) { DoErrorMessageCheck("OpFunctionEnd", "OpFunctionEnd without corresponding OpFunction", 1); } TEST(IrBuilder, OpFunctionEndInsideBasicBlock) { DoErrorMessageCheck( "%2 = OpFunction %1 None %3\n" "%4 = OpLabel\n" "OpFunctionEnd", "OpFunctionEnd inside basic block", 3); } TEST(IrBuilder, BasicBlockOutsideFunction) { DoErrorMessageCheck("OpCapability Shader\n%1 = OpLabel", "OpLabel outside function", 2); } TEST(IrBuilder, OpLabelInsideBasicBlock) { DoErrorMessageCheck( "%2 = OpFunction %1 None %3\n" "%4 = OpLabel\n" "%5 = OpLabel", "OpLabel inside basic block", 3); } TEST(IrBuilder, TerminatorOutsideFunction) { DoErrorMessageCheck("OpReturn", "terminator instruction outside function", 1); } TEST(IrBuilder, TerminatorOutsideBasicBlock) { DoErrorMessageCheck("%2 = OpFunction %1 None %3\nOpReturn", "terminator instruction outside basic block", 2); } TEST(IrBuilder, NotAllowedInstAppearingInFunction) { DoErrorMessageCheck("%2 = OpFunction %1 None %3\n%5 = OpVariable %4 Function", "Non-OpFunctionParameter (opcode: 59) found inside " "function but outside basic block", 2); } TEST(IrBuilder, UniqueIds) { const std::string text = // clang-format off "OpCapability Shader\n" "%1 = OpExtInstImport \"GLSL.std.450\"\n" "OpMemoryModel Logical GLSL450\n" "OpEntryPoint Vertex %main \"main\"\n" "OpSource ESSL 310\n" "OpName %main \"main\"\n" "OpName %f_ \"f(\"\n" "OpName %gv1 \"gv1\"\n" "OpName %gv2 \"gv2\"\n" "OpName %lv1 \"lv1\"\n" "OpName %lv2 \"lv2\"\n" "OpName %lv1_0 \"lv1\"\n" "%void = OpTypeVoid\n" "%10 = OpTypeFunction %void\n" "%float = OpTypeFloat 32\n" "%12 = OpTypeFunction %float\n" "%_ptr_Private_float = OpTypePointer Private %float\n" "%gv1 = OpVariable %_ptr_Private_float Private\n" "%float_10 = OpConstant %float 10\n" "%gv2 = OpVariable %_ptr_Private_float Private\n" "%float_100 = OpConstant %float 100\n" "%_ptr_Function_float = OpTypePointer Function %float\n" "%main = OpFunction %void None %10\n" "%17 = OpLabel\n" "%lv1_0 = OpVariable %_ptr_Function_float Function\n" "OpStore %gv1 %float_10\n" "OpStore %gv2 %float_100\n" "%18 = OpLoad %float %gv1\n" "%19 = OpLoad %float %gv2\n" "%20 = OpFSub %float %18 %19\n" "OpStore %lv1_0 %20\n" "OpReturn\n" "OpFunctionEnd\n" "%f_ = OpFunction %float None %12\n" "%21 = OpLabel\n" "%lv1 = OpVariable %_ptr_Function_float Function\n" "%lv2 = OpVariable %_ptr_Function_float Function\n" "%22 = OpLoad %float %gv1\n" "%23 = OpLoad %float %gv2\n" "%24 = OpFAdd %float %22 %23\n" "OpStore %lv1 %24\n" "%25 = OpLoad %float %gv1\n" "%26 = OpLoad %float %gv2\n" "%27 = OpFMul %float %25 %26\n" "OpStore %lv2 %27\n" "%28 = OpLoad %float %lv1\n" "%29 = OpLoad %float %lv2\n" "%30 = OpFDiv %float %28 %29\n" "OpReturnValue %30\n" "OpFunctionEnd\n"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text); ASSERT_NE(nullptr, context); std::unordered_set ids; context->module()->ForEachInst([&ids](const Instruction* inst) { EXPECT_TRUE(ids.insert(inst->unique_id()).second); }); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/iterator_test.cpp000066400000000000000000000164641475742701700237210ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gmock/gmock.h" #include "source/opt/iterator.h" #include "source/util/make_unique.h" namespace spvtools { namespace opt { namespace { using ::testing::ContainerEq; TEST(Iterator, IncrementDeref) { const int count = 100; std::vector> data; for (int i = 0; i < count; ++i) { data.emplace_back(new int(i)); } UptrVectorIterator it(&data, data.begin()); UptrVectorIterator end(&data, data.end()); EXPECT_EQ(*data[0], *it); for (int i = 1; i < count; ++i) { EXPECT_NE(end, it); EXPECT_EQ(*data[i], *(++it)); } EXPECT_EQ(end, ++it); } TEST(Iterator, DecrementDeref) { const int count = 100; std::vector> data; for (int i = 0; i < count; ++i) { data.emplace_back(new int(i)); } UptrVectorIterator begin(&data, data.begin()); UptrVectorIterator it(&data, data.end()); for (int i = count - 1; i >= 0; --i) { EXPECT_NE(begin, it); EXPECT_EQ(*data[i], *(--it)); } EXPECT_EQ(begin, it); } TEST(Iterator, PostIncrementDeref) { const int count = 100; std::vector> data; for (int i = 0; i < count; ++i) { data.emplace_back(new int(i)); } UptrVectorIterator it(&data, data.begin()); UptrVectorIterator end(&data, data.end()); for (int i = 0; i < count; ++i) { EXPECT_NE(end, it); EXPECT_EQ(*data[i], *(it++)); } EXPECT_EQ(end, it); } TEST(Iterator, PostDecrementDeref) { const int count = 100; std::vector> data; for (int i = 0; i < count; ++i) { data.emplace_back(new int(i)); } UptrVectorIterator begin(&data, data.begin()); UptrVectorIterator end(&data, data.end()); UptrVectorIterator it(&data, data.end()); EXPECT_EQ(end, it--); for (int i = count - 1; i >= 1; --i) { EXPECT_EQ(*data[i], *(it--)); } // Decrementing .begin() is undefined behavior. EXPECT_EQ(*data[0], *it); } TEST(Iterator, Access) { const int count = 100; std::vector> data; for (int i = 0; i < count; ++i) { data.emplace_back(new int(i)); } UptrVectorIterator it(&data, data.begin()); for (int i = 0; i < count; ++i) EXPECT_EQ(*data[i], it[i]); } TEST(Iterator, Comparison) { const int count = 100; std::vector> data; for (int i = 0; i < count; ++i) { data.emplace_back(new int(i)); } UptrVectorIterator it(&data, data.begin()); UptrVectorIterator end(&data, data.end()); for (int i = 0; i < count; ++i, ++it) EXPECT_TRUE(it < end); EXPECT_EQ(end, it); } TEST(Iterator, InsertBeginEnd) { const int count = 100; std::vector> data; std::vector expected; std::vector actual; for (int i = 0; i < count; ++i) { data.emplace_back(new int(i)); expected.push_back(i); } // Insert at the beginning expected.insert(expected.begin(), -100); UptrVectorIterator begin(&data, data.begin()); auto insert_point = begin.InsertBefore(MakeUnique(-100)); for (int i = 0; i < count + 1; ++i) { actual.push_back(*(insert_point++)); } EXPECT_THAT(actual, ContainerEq(expected)); // Insert at the end expected.push_back(-42); expected.push_back(-36); expected.push_back(-77); UptrVectorIterator end(&data, data.end()); end = end.InsertBefore(MakeUnique(-77)); end = end.InsertBefore(MakeUnique(-36)); end = end.InsertBefore(MakeUnique(-42)); actual.clear(); begin = UptrVectorIterator(&data, data.begin()); for (int i = 0; i < count + 4; ++i) { actual.push_back(*(begin++)); } EXPECT_THAT(actual, ContainerEq(expected)); } TEST(Iterator, InsertMiddle) { const int count = 100; std::vector> data; std::vector expected; std::vector actual; for (int i = 0; i < count; ++i) { data.emplace_back(new int(i)); expected.push_back(i); } const int insert_pos = 42; expected.insert(expected.begin() + insert_pos, -100); expected.insert(expected.begin() + insert_pos, -42); UptrVectorIterator it(&data, data.begin()); for (int i = 0; i < insert_pos; ++i) ++it; it = it.InsertBefore(MakeUnique(-100)); it = it.InsertBefore(MakeUnique(-42)); auto begin = UptrVectorIterator(&data, data.begin()); for (int i = 0; i < count + 2; ++i) { actual.push_back(*(begin++)); } EXPECT_THAT(actual, ContainerEq(expected)); } TEST(IteratorRange, Interface) { const uint32_t count = 100; std::vector> data; for (uint32_t i = 0; i < count; ++i) { data.emplace_back(new uint32_t(i)); } auto b = UptrVectorIterator(&data, data.begin()); auto e = UptrVectorIterator(&data, data.end()); auto range = IteratorRange(b, e); EXPECT_EQ(b, range.begin()); EXPECT_EQ(e, range.end()); EXPECT_FALSE(range.empty()); EXPECT_EQ(count, range.size()); EXPECT_EQ(0u, *range.begin()); EXPECT_EQ(99u, *(--range.end())); // IteratorRange itself is immutable. ++b, --e; EXPECT_EQ(count, range.size()); ++range.begin(), --range.end(); EXPECT_EQ(count, range.size()); } TEST(Iterator, FilterIterator) { struct Placeholder { int val; }; std::vector data = {{1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}}; // Predicate to only consider odd values. struct Predicate { bool operator()(const Placeholder& data) { return data.val % 2; } }; Predicate pred; auto filter_range = MakeFilterIteratorRange(data.begin(), data.end(), pred); EXPECT_EQ(filter_range.begin().Get(), data.begin()); EXPECT_EQ(filter_range.end(), filter_range.begin().GetEnd()); for (Placeholder& data : filter_range) { EXPECT_EQ(data.val % 2, 1); } for (auto it = filter_range.begin(); it != filter_range.end(); it++) { EXPECT_EQ(it->val % 2, 1); EXPECT_EQ((*it).val % 2, 1); } for (auto it = filter_range.begin(); it != filter_range.end(); ++it) { EXPECT_EQ(it->val % 2, 1); EXPECT_EQ((*it).val % 2, 1); } EXPECT_EQ(MakeFilterIterator(data.begin(), data.end(), pred).Get(), data.begin()); EXPECT_EQ(MakeFilterIterator(data.end(), data.end(), pred).Get(), data.end()); EXPECT_EQ(MakeFilterIterator(data.begin(), data.end(), pred).GetEnd(), MakeFilterIterator(data.end(), data.end(), pred)); EXPECT_NE(MakeFilterIterator(data.begin(), data.end(), pred), MakeFilterIterator(data.end(), data.end(), pred)); // Empty range: no values satisfies the predicate. auto empty_range = MakeFilterIteratorRange( data.begin(), data.end(), [](const Placeholder& data) { return data.val > 10; }); EXPECT_EQ(empty_range.begin(), empty_range.end()); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/line_debug_info_test.cpp000066400000000000000000000065001475742701700251660ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { // A pass turning all none debug line instructions into Nop. class NopifyPass : public Pass { public: const char* name() const override { return "NopifyPass"; } Status Process() override { bool modified = false; context()->module()->ForEachInst( [&modified](Instruction* inst) { inst->ToNop(); modified = true; }, /* run_on_debug_line_insts = */ false); return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } }; using PassTestForLineDebugInfo = PassTest<::testing::Test>; // This test's purpose to show our implementation choice: line debug info is // preserved even if the following instruction is killed. It serves as a guard // of potential behavior changes. TEST_F(PassTestForLineDebugInfo, KeepLineDebugInfo) { // clang-format off const char* text = "OpCapability Shader " "%1 = OpExtInstImport \"GLSL.std.450\" " "OpMemoryModel Logical GLSL450 " "OpEntryPoint Vertex %2 \"main\" " "%3 = OpString \"minimal.vert\" " "OpNoLine " "OpLine %3 10 10 " "%void = OpTypeVoid " "OpLine %3 100 100 " "%5 = OpTypeFunction %void " "%2 = OpFunction %void None %5 " "OpLine %3 1 1 " "OpNoLine " "OpLine %3 2 2 " "OpLine %3 3 3 " "%6 = OpLabel " "OpLine %3 4 4 " "OpNoLine " "OpReturn " "OpLine %3 4 4 " "OpNoLine " "OpFunctionEnd "; // clang-format on const char* result_keep_nop = "OpNop\n" "OpNop\n" "OpNop\n" "OpNop\n" "OpNop\n" "OpNoLine\n" "OpLine %3 10 10\n" "OpNop\n" "OpLine %3 100 100\n" "OpNop\n" "OpNop\n" "OpLine %3 1 1\n" "OpNoLine\n" "OpLine %3 2 2\n" "OpLine %3 3 3\n" "OpNop\n" "OpLine %3 4 4\n" "OpNoLine\n" "OpNop\n" "OpLine %3 4 4\n" "OpNoLine\n" "OpNop\n"; SinglePassRunAndCheck(text, result_keep_nop, /* skip_nop = */ false); const char* result_skip_nop = "OpNoLine\n" "OpLine %3 10 10\n" "OpLine %3 100 100\n" "OpLine %3 1 1\n" "OpNoLine\n" "OpLine %3 2 2\n" "OpLine %3 3 3\n" "OpLine %3 4 4\n" "OpNoLine\n" "OpLine %3 4 4\n" "OpNoLine\n"; SinglePassRunAndCheck(text, result_skip_nop, /* skip_nop = */ true); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/local_access_chain_convert_test.cpp000066400000000000000000001313031475742701700273730ustar00rootroot00000000000000// Copyright (c) 2017 Valve Corporation // Copyright (c) 2017 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using LocalAccessChainConvertTest = PassTest<::testing::Test>; TEST_F(LocalAccessChainConvertTest, StructOfVecsOfFloatConverted) { // #version 140 // // in vec4 BaseColor; // // struct S_t { // vec4 v0; // vec4 v1; // }; // // void main() // { // S_t s0; // s0.v1 = BaseColor; // gl_FragColor = s0.v1; // } const std::string predefs_before = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %S_t "S_t" OpMemberName %S_t 0 "v0" OpMemberName %S_t 1 "v1" OpName %s0 "s0" OpName %BaseColor "BaseColor" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %S_t = OpTypeStruct %v4float %v4float %_ptr_Function_S_t = OpTypePointer Function %S_t %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output )"; const std::string before = R"( ; CHECK: [[st_id:%\w+]] = OpLoad %v4float %BaseColor ; CHECK: [[ld1:%\w+]] = OpLoad %S_t %s0 ; CHECK: [[ex1:%\w+]] = OpCompositeInsert %S_t [[st_id]] [[ld1]] 1 ; CHECK: OpStore %s0 [[ex1]] ; CHECK: [[ld2:%\w+]] = OpLoad %S_t %s0 ; CHECK: [[ex2:%\w+]] = OpCompositeExtract %v4float [[ld2]] 1 ; CHECK: OpStore %gl_FragColor [[ex2]] %main = OpFunction %void None %8 %17 = OpLabel %s0 = OpVariable %_ptr_Function_S_t Function %18 = OpLoad %v4float %BaseColor %19 = OpAccessChain %_ptr_Function_v4float %s0 %int_1 OpStore %19 %18 %20 = OpAccessChain %_ptr_Function_v4float %s0 %int_1 %21 = OpLoad %v4float %20 OpStore %gl_FragColor %21 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(predefs_before + before, true); } TEST_F(LocalAccessChainConvertTest, DebugScopeAndLineInfoForNewInstructions) { // #version 140 // // in vec4 BaseColor; // // struct S_t { // vec4 v0; // vec4 v1; // }; // // void main() // { // S_t s0; // s0.v1 = BaseColor; // gl_FragColor = s0.v1; // } const std::string predefs_before = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" %ext = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %S_t "S_t" OpMemberName %S_t 0 "v0" OpMemberName %S_t 1 "v1" OpName %s0 "s0" OpName %BaseColor "BaseColor" OpName %gl_FragColor "gl_FragColor" %5 = OpString "ps.hlsl" %6 = OpString "float" %var_name = OpString "s0" %main_name = OpString "main" %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %S_t = OpTypeStruct %v4float %v4float %_ptr_Function_S_t = OpTypePointer Function %S_t %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %int_32 = OpConstant %int 32 %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output %20 = OpExtInst %void %ext DebugSource %5 %21 = OpExtInst %void %ext DebugCompilationUnit 1 4 %20 HLSL %22 = OpExtInst %void %ext DebugTypeBasic %6 %int_32 Float %23 = OpExtInst %void %ext DebugTypeVector %22 4 %24 = OpExtInst %void %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %23 %dbg_main = OpExtInst %void %ext DebugFunction %main_name %24 %20 4 1 %21 %main_name FlagIsProtected|FlagIsPrivate 4 %main %25 = OpExtInst %void %ext DebugLocalVariable %var_name %23 %20 0 0 %dbg_main FlagIsLocal )"; const std::string before = R"( ; CHECK: [[st_id:%\w+]] = OpLoad %v4float %BaseColor ; CHECK: OpLine {{%\w+}} 1 0 ; CHECK: [[ld1:%\w+]] = OpLoad %S_t %s0 ; CHECK: [[ex1:%\w+]] = OpCompositeInsert %S_t [[st_id]] [[ld1]] 1 ; CHECK: OpStore %s0 [[ex1]] ; CHECK: OpLine {{%\w+}} 3 0 ; CHECK: [[ld2:%\w+]] = OpLoad %S_t %s0 ; CHECK: [[ex2:%\w+]] = OpCompositeExtract %v4float [[ld2]] 1 ; CHECK: OpLine {{%\w+}} 4 0 ; CHECK: OpStore %gl_FragColor [[ex2]] %main = OpFunction %void None %8 %17 = OpLabel %26 = OpExtInst %void %ext DebugScope %dbg_main %s0 = OpVariable %_ptr_Function_S_t Function %18 = OpLoad %v4float %BaseColor OpLine %5 0 0 %19 = OpAccessChain %_ptr_Function_v4float %s0 %int_1 OpLine %5 1 0 OpStore %19 %18 OpLine %5 2 0 %27 = OpAccessChain %_ptr_Function_v4float %s0 %int_1 OpLine %5 3 0 %28 = OpLoad %v4float %27 OpLine %5 4 0 OpStore %gl_FragColor %28 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(predefs_before + before, true); } TEST_F(LocalAccessChainConvertTest, TestTargetsReferencedByDebugValue) { // #version 140 // // in vec4 BaseColor; // // struct S_t { // vec4 v0; // vec4 v1; // }; // // void main() // { // S_t s0; // s0.v1 = BaseColor; // gl_FragColor = s0.v1; // } const std::string predefs_before = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" %ext = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %S_t "S_t" OpMemberName %S_t 0 "v0" OpMemberName %S_t 1 "v1" OpName %s0 "s0" OpName %BaseColor "BaseColor" OpName %gl_FragColor "gl_FragColor" %5 = OpString "ps.hlsl" %6 = OpString "float" %var_name = OpString "s0" %main_name = OpString "main" %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %S_t = OpTypeStruct %v4float %v4float %_ptr_Function_S_t = OpTypePointer Function %S_t %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %int_32 = OpConstant %int 32 %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output %deref = OpExtInst %void %ext DebugOperation Deref %deref_expr = OpExtInst %void %ext DebugExpression %deref %null_expr = OpExtInst %void %ext DebugExpression %20 = OpExtInst %void %ext DebugSource %5 %21 = OpExtInst %void %ext DebugCompilationUnit 1 4 %20 HLSL %22 = OpExtInst %void %ext DebugTypeBasic %6 %int_32 Float %23 = OpExtInst %void %ext DebugTypeVector %22 4 %24 = OpExtInst %void %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %23 %dbg_main = OpExtInst %void %ext DebugFunction %main_name %24 %20 4 1 %21 %main_name FlagIsProtected|FlagIsPrivate 4 %main %25 = OpExtInst %void %ext DebugLocalVariable %var_name %23 %20 0 0 %dbg_main FlagIsLocal )"; const std::string before = R"( ; CHECK: [[st_id:%\w+]] = OpLoad %v4float %BaseColor ; CHECK: OpLine {{%\w+}} 0 0 ; CHECK: [[s0_1_ptr:%\w+]] = OpAccessChain %_ptr_Function_v4float %s0 %int_1 ; CHECK: DebugValue [[dbg_s0:%\w+]] [[s0_1_ptr]] ; CHECK: OpLine {{%\w+}} 1 0 ; CHECK: [[s0:%\w+]] = OpLoad %S_t %s0 ; CHECK: [[comp:%\w+]] = OpCompositeInsert %S_t [[st_id]] [[s0]] 1 ; CHECK: OpStore %s0 [[comp]] ; CHECK: OpLine {{%\w+}} 2 0 ; CHECK: [[s0_2_ptr:%\w+]] = OpAccessChain %_ptr_Function_v4float %s0 %int_1 ; CHECK: OpLine {{%\w+}} 3 0 ; CHECK: [[s0:%\w+]] = OpLoad %S_t %s0 ; CHECK: [[s0_2_val:%\w+]] = OpCompositeExtract %v4float [[s0]] 1 ; CHECK: DebugValue [[dbg_s0]] [[s0_2_val]] ; CHECK: OpLine {{%\w+}} 4 0 ; CHECK: OpStore %gl_FragColor [[s0_2_val]] %main = OpFunction %void None %8 %17 = OpLabel %26 = OpExtInst %void %ext DebugScope %dbg_main %s0 = OpVariable %_ptr_Function_S_t Function %18 = OpLoad %v4float %BaseColor OpLine %5 0 0 %19 = OpAccessChain %_ptr_Function_v4float %s0 %int_1 %29 = OpExtInst %void %ext DebugValue %25 %19 %deref_expr %int_1 OpLine %5 1 0 OpStore %19 %18 OpLine %5 2 0 %27 = OpAccessChain %_ptr_Function_v4float %s0 %int_1 OpLine %5 3 0 %28 = OpLoad %v4float %27 %30 = OpExtInst %void %ext DebugValue %25 %28 %null_expr %int_1 OpLine %5 4 0 OpStore %gl_FragColor %28 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(predefs_before + before, true); } TEST_F(LocalAccessChainConvertTest, InBoundsAccessChainsConverted) { // #version 140 // // in vec4 BaseColor; // // struct S_t { // vec4 v0; // vec4 v1; // }; // // void main() // { // S_t s0; // s0.v1 = BaseColor; // gl_FragColor = s0.v1; // } const std::string predefs_before = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %S_t "S_t" OpMemberName %S_t 0 "v0" OpMemberName %S_t 1 "v1" OpName %s0 "s0" OpName %BaseColor "BaseColor" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %S_t = OpTypeStruct %v4float %v4float %_ptr_Function_S_t = OpTypePointer Function %S_t %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output )"; const std::string before = R"( ; CHECK: [[st_id:%\w+]] = OpLoad %v4float %BaseColor ; CHECK: [[ld1:%\w+]] = OpLoad %S_t %s0 ; CHECK: [[ex1:%\w+]] = OpCompositeInsert %S_t [[st_id]] [[ld1]] 1 ; CHECK: OpStore %s0 [[ex1]] ; CHECK: [[ld2:%\w+]] = OpLoad %S_t %s0 ; CHECK: [[ex2:%\w+]] = OpCompositeExtract %v4float [[ld2]] 1 ; CHECK: OpStore %gl_FragColor [[ex2]] %main = OpFunction %void None %8 %17 = OpLabel %s0 = OpVariable %_ptr_Function_S_t Function %18 = OpLoad %v4float %BaseColor %19 = OpInBoundsAccessChain %_ptr_Function_v4float %s0 %int_1 OpStore %19 %18 %20 = OpInBoundsAccessChain %_ptr_Function_v4float %s0 %int_1 %21 = OpLoad %v4float %20 OpStore %gl_FragColor %21 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(predefs_before + before, true); } TEST_F(LocalAccessChainConvertTest, TwoUsesofSingleChainConverted) { // #version 140 // // in vec4 BaseColor; // // struct S_t { // vec4 v0; // vec4 v1; // }; // // void main() // { // S_t s0; // s0.v1 = BaseColor; // gl_FragColor = s0.v1; // } const std::string predefs_before = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %S_t "S_t" OpMemberName %S_t 0 "v0" OpMemberName %S_t 1 "v1" OpName %s0 "s0" OpName %BaseColor "BaseColor" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %S_t = OpTypeStruct %v4float %v4float %_ptr_Function_S_t = OpTypePointer Function %S_t %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output )"; const std::string before = R"( ; CHECK: [[st_id:%\w+]] = OpLoad %v4float %BaseColor ; CHECK: [[ld1:%\w+]] = OpLoad %S_t %s0 ; CHECK: [[ex1:%\w+]] = OpCompositeInsert %S_t [[st_id]] [[ld1]] 1 ; CHECK: OpStore %s0 [[ex1]] ; CHECK: [[ld2:%\w+]] = OpLoad %S_t %s0 ; CHECK: [[ex2:%\w+]] = OpCompositeExtract %v4float [[ld2]] 1 ; CHECK: OpStore %gl_FragColor [[ex2]] %main = OpFunction %void None %8 %17 = OpLabel %s0 = OpVariable %_ptr_Function_S_t Function %18 = OpLoad %v4float %BaseColor %19 = OpAccessChain %_ptr_Function_v4float %s0 %int_1 OpStore %19 %18 %20 = OpLoad %v4float %19 OpStore %gl_FragColor %20 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(predefs_before + before, true); } TEST_F(LocalAccessChainConvertTest, OpaqueConverted) { // SPIR-V not representable in GLSL; not generatable from HLSL // at the moment const std::string predefs = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %outColor %texCoords OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %S_t "S_t" OpMemberName %S_t 0 "v0" OpMemberName %S_t 1 "v1" OpMemberName %S_t 2 "smp" OpName %foo_struct_S_t_vf2_vf21_ "foo(struct-S_t-vf2-vf21;" OpName %s "s" OpName %outColor "outColor" OpName %sampler15 "sampler15" OpName %s0 "s0" OpName %texCoords "texCoords" OpName %param "param" OpDecorate %sampler15 DescriptorSet 0 %void = OpTypeVoid %12 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %outColor = OpVariable %_ptr_Output_v4float Output %17 = OpTypeImage %float 2D 0 0 0 1 Unknown %18 = OpTypeSampledImage %17 %S_t = OpTypeStruct %v2float %v2float %18 %_ptr_Function_S_t = OpTypePointer Function %S_t %20 = OpTypeFunction %void %_ptr_Function_S_t %_ptr_UniformConstant_18 = OpTypePointer UniformConstant %18 %_ptr_Function_18 = OpTypePointer Function %18 %sampler15 = OpVariable %_ptr_UniformConstant_18 UniformConstant %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_2 = OpConstant %int 2 %_ptr_Function_v2float = OpTypePointer Function %v2float %_ptr_Input_v2float = OpTypePointer Input %v2float %texCoords = OpVariable %_ptr_Input_v2float Input )"; const std::string before = R"( ; CHECK: [[l1:%\w+]] = OpLoad %S_t %param ; CHECK: [[e1:%\w+]] = OpCompositeExtract {{%\w+}} [[l1]] 2 ; CHECK: [[l2:%\w+]] = OpLoad %S_t %param ; CHECK: [[e2:%\w+]] = OpCompositeExtract {{%\w+}} [[l2]] 0 ; CHECK: OpImageSampleImplicitLod {{%\w+}} [[e1]] [[e2]] %main = OpFunction %void None %12 %28 = OpLabel %s0 = OpVariable %_ptr_Function_S_t Function %param = OpVariable %_ptr_Function_S_t Function %29 = OpLoad %v2float %texCoords %30 = OpAccessChain %_ptr_Function_v2float %s0 %int_0 OpStore %30 %29 %31 = OpLoad %18 %sampler15 %32 = OpAccessChain %_ptr_Function_18 %s0 %int_2 OpStore %32 %31 %33 = OpLoad %S_t %s0 OpStore %param %33 %34 = OpAccessChain %_ptr_Function_18 %param %int_2 %35 = OpLoad %18 %34 %36 = OpAccessChain %_ptr_Function_v2float %param %int_0 %37 = OpLoad %v2float %36 %38 = OpImageSampleImplicitLod %v4float %35 %37 OpStore %outColor %38 OpReturn OpFunctionEnd )"; const std::string remain = R"(%foo_struct_S_t_vf2_vf21_ = OpFunction %void None %20 %s = OpFunctionParameter %_ptr_Function_S_t %39 = OpLabel %40 = OpAccessChain %_ptr_Function_18 %s %int_2 %41 = OpLoad %18 %40 %42 = OpAccessChain %_ptr_Function_v2float %s %int_0 %43 = OpLoad %v2float %42 %44 = OpImageSampleImplicitLod %v4float %41 %43 OpStore %outColor %44 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(predefs + before + remain, true); } TEST_F(LocalAccessChainConvertTest, NestedStructsConverted) { // #version 140 // // in vec4 BaseColor; // // struct S1_t { // vec4 v1; // }; // // struct S2_t { // vec4 v2; // S1_t s1; // }; // // void main() // { // S2_t s2; // s2.s1.v1 = BaseColor; // gl_FragColor = s2.s1.v1; // } const std::string predefs_before = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %S1_t "S1_t" OpMemberName %S1_t 0 "v1" OpName %S2_t "S2_t" OpMemberName %S2_t 0 "v2" OpMemberName %S2_t 1 "s1" OpName %s2 "s2" OpName %BaseColor "BaseColor" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %9 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %S1_t = OpTypeStruct %v4float %S2_t = OpTypeStruct %v4float %S1_t %_ptr_Function_S2_t = OpTypePointer Function %S2_t %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %int_0 = OpConstant %int 0 %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output )"; const std::string before = R"( ; CHECK: [[st_id:%\w+]] = OpLoad %v4float %BaseColor ; CHECK: [[ld1:%\w+]] = OpLoad %S2_t %s2 ; CHECK: [[ex1:%\w+]] = OpCompositeInsert %S2_t [[st_id]] [[ld1]] 1 0 ; CHECK: OpStore %s2 [[ex1]] ; CHECK: [[ld2:%\w+]] = OpLoad %S2_t %s2 ; CHECK: [[ex2:%\w+]] = OpCompositeExtract %v4float [[ld2]] 1 0 ; CHECK: OpStore %gl_FragColor [[ex2]] %main = OpFunction %void None %9 %19 = OpLabel %s2 = OpVariable %_ptr_Function_S2_t Function %20 = OpLoad %v4float %BaseColor %21 = OpAccessChain %_ptr_Function_v4float %s2 %int_1 %int_0 OpStore %21 %20 %22 = OpAccessChain %_ptr_Function_v4float %s2 %int_1 %int_0 %23 = OpLoad %v4float %22 OpStore %gl_FragColor %23 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(predefs_before + before, true); } TEST_F(LocalAccessChainConvertTest, SomeAccessChainsHaveNoUse) { // Based on HLSL source code: // struct S { // float f; // }; // float main(float input : A) : B { // S local = { input }; // return local.f; // } const std::string predefs = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %in_var_A %out_var_B OpName %main "main" OpName %in_var_A "in.var.A" OpName %out_var_B "out.var.B" OpName %S "S" OpName %local "local" %int = OpTypeInt 32 1 %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %_ptr_Input_float = OpTypePointer Input %float %_ptr_Output_float = OpTypePointer Output %float %S = OpTypeStruct %float %_ptr_Function_S = OpTypePointer Function %S %int_0 = OpConstant %int 0 %in_var_A = OpVariable %_ptr_Input_float Input %out_var_B = OpVariable %_ptr_Output_float Output %main = OpFunction %void None %8 %15 = OpLabel %local = OpVariable %_ptr_Function_S Function %16 = OpLoad %float %in_var_A %17 = OpCompositeConstruct %S %16 OpStore %local %17 )"; const std::string before = R"( ; CHECK: [[ld:%\w+]] = OpLoad %S %local ; CHECK: [[ex:%\w+]] = OpCompositeExtract %float [[ld]] 0 ; CHECK: OpStore %out_var_B [[ex]] %18 = OpAccessChain %_ptr_Function_float %local %int_0 %19 = OpAccessChain %_ptr_Function_float %local %int_0 %20 = OpLoad %float %18 OpStore %out_var_B %20 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(predefs + before, true); } TEST_F(LocalAccessChainConvertTest, StructOfVecsOfFloatConvertedWithDecorationOnLoad) { // #version 140 // // in vec4 BaseColor; // // struct S_t { // vec4 v0; // vec4 v1; // }; // // void main() // { // S_t s0; // s0.v1 = BaseColor; // gl_FragColor = s0.v1; // } const std::string predefs_before = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %S_t "S_t" OpMemberName %S_t 0 "v0" OpMemberName %S_t 1 "v1" OpName %s0 "s0" OpName %BaseColor "BaseColor" OpName %gl_FragColor "gl_FragColor" OpDecorate %21 RelaxedPrecision %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %S_t = OpTypeStruct %v4float %v4float %_ptr_Function_S_t = OpTypePointer Function %S_t %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output )"; const std::string before = R"( ; CHECK: OpDecorate ; CHECK: OpDecorate [[ld2:%\w+]] RelaxedPrecision ; CHECK-NOT: OpDecorate ; CHECK: [[st_id:%\w+]] = OpLoad %v4float %BaseColor ; CHECK: [[ld1:%\w+]] = OpLoad %S_t %s0 ; CHECK: [[ins:%\w+]] = OpCompositeInsert %S_t [[st_id]] [[ld1]] 1 ; CHECK: OpStore %s0 [[ins]] ; CHECK: [[ld2]] = OpLoad %S_t %s0 ; CHECK: [[ex2:%\w+]] = OpCompositeExtract %v4float [[ld2]] 1 ; CHECK: OpStore %gl_FragColor [[ex2]] %main = OpFunction %void None %8 %17 = OpLabel %s0 = OpVariable %_ptr_Function_S_t Function %18 = OpLoad %v4float %BaseColor %19 = OpAccessChain %_ptr_Function_v4float %s0 %int_1 OpStore %19 %18 %20 = OpAccessChain %_ptr_Function_v4float %s0 %int_1 %21 = OpLoad %v4float %20 OpStore %gl_FragColor %21 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(predefs_before + before, true); } TEST_F(LocalAccessChainConvertTest, StructOfVecsOfFloatConvertedWithDecorationOnStore) { // #version 140 // // in vec4 BaseColor; // // struct S_t { // vec4 v0; // vec4 v1; // }; // // void main() // { // S_t s0; // s0.v1 = BaseColor; // gl_FragColor = s0.v1; // } const std::string predefs_before = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %S_t "S_t" OpMemberName %S_t 0 "v0" OpMemberName %S_t 1 "v1" OpName %s0 "s0" OpName %BaseColor "BaseColor" OpName %gl_FragColor "gl_FragColor" OpDecorate %s0 RelaxedPrecision %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %S_t = OpTypeStruct %v4float %v4float %_ptr_Function_S_t = OpTypePointer Function %S_t %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output )"; const std::string before = R"( ; CHECK: OpDecorate ; CHECK: OpDecorate [[ld1:%\w+]] RelaxedPrecision ; CHECK: OpDecorate [[ins:%\w+]] RelaxedPrecision ; CHECK-NOT: OpDecorate ; CHECK: [[st_id:%\w+]] = OpLoad %v4float %BaseColor ; CHECK: [[ld1]] = OpLoad %S_t %s0 ; CHECK: [[ins]] = OpCompositeInsert %S_t [[st_id]] [[ld1]] 1 ; CHECK: OpStore %s0 [[ins]] ; CHECK: [[ld2:%\w+]] = OpLoad %S_t %s0 ; CHECK: [[ex2:%\w+]] = OpCompositeExtract %v4float [[ld2]] 1 ; CHECK: OpStore %gl_FragColor [[ex2]] %main = OpFunction %void None %8 %17 = OpLabel %s0 = OpVariable %_ptr_Function_S_t Function %18 = OpLoad %v4float %BaseColor %19 = OpAccessChain %_ptr_Function_v4float %s0 %int_1 OpStore %19 %18 %20 = OpAccessChain %_ptr_Function_v4float %s0 %int_1 %21 = OpLoad %v4float %20 OpStore %gl_FragColor %21 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(predefs_before + before, true); } TEST_F(LocalAccessChainConvertTest, DynamicallyIndexedVarNotConverted) { // #version 140 // // in vec4 BaseColor; // flat in int Idx; // in float Bi; // // struct S_t { // vec4 v0; // vec4 v1; // }; // // void main() // { // S_t s0; // s0.v1 = BaseColor; // s0.v1[Idx] = Bi; // gl_FragColor = s0.v1; // } const std::string assembly = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %Idx %Bi %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %S_t "S_t" OpMemberName %S_t 0 "v0" OpMemberName %S_t 1 "v1" OpName %s0 "s0" OpName %BaseColor "BaseColor" OpName %Idx "Idx" OpName %Bi "Bi" OpName %gl_FragColor "gl_FragColor" OpDecorate %Idx Flat %void = OpTypeVoid %10 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %S_t = OpTypeStruct %v4float %v4float %_ptr_Function_S_t = OpTypePointer Function %S_t %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_int = OpTypePointer Input %int %Idx = OpVariable %_ptr_Input_int Input %_ptr_Input_float = OpTypePointer Input %float %Bi = OpVariable %_ptr_Input_float Input %_ptr_Function_float = OpTypePointer Function %float %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %10 %22 = OpLabel %s0 = OpVariable %_ptr_Function_S_t Function %23 = OpLoad %v4float %BaseColor %24 = OpAccessChain %_ptr_Function_v4float %s0 %int_1 OpStore %24 %23 %25 = OpLoad %int %Idx %26 = OpLoad %float %Bi %27 = OpAccessChain %_ptr_Function_float %s0 %int_1 %25 OpStore %27 %26 %28 = OpAccessChain %_ptr_Function_v4float %s0 %int_1 %29 = OpLoad %v4float %28 OpStore %gl_FragColor %29 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(assembly, assembly, false, true); } TEST_F(LocalAccessChainConvertTest, VariablePointersStorageBuffer) { // A case with a storage buffer variable pointer. We should still convert // the access chain on the function scope symbol. const std::string test = R"( ; CHECK: OpFunction ; CHECK: [[var:%\w+]] = OpVariable {{%\w+}} Function ; CHECK: [[ld:%\w+]] = OpLoad {{%\w+}} [[var]] ; CHECK: OpCompositeExtract {{%\w+}} [[ld]] 0 0 OpCapability Shader OpCapability VariablePointersStorageBuffer %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" OpExecutionMode %2 LocalSize 1 1 1 OpSource GLSL 450 OpMemberDecorate %_struct_3 0 Offset 0 OpDecorate %_struct_3 Block OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 0 OpDecorate %_ptr_StorageBuffer_int ArrayStride 4 OpDecorate %_arr_int_int_128 ArrayStride 4 %void = OpTypeVoid %8 = OpTypeFunction %void %int = OpTypeInt 32 1 %int_128 = OpConstant %int 128 %_arr_int_int_128 = OpTypeArray %int %int_128 %_struct_3 = OpTypeStruct %_arr_int_int_128 %_ptr_StorageBuffer__struct_3 = OpTypePointer StorageBuffer %_struct_3 %_ptr_Function__struct_3 = OpTypePointer Function %_struct_3 %4 = OpVariable %_ptr_StorageBuffer__struct_3 StorageBuffer %bool = OpTypeBool %true = OpConstantTrue %bool %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %_ptr_StorageBuffer_int = OpTypePointer StorageBuffer %int %_ptr_Function_int = OpTypePointer Function %int %2 = OpFunction %void None %8 %18 = OpLabel %19 = OpVariable %_ptr_Function__struct_3 Function %20 = OpAccessChain %_ptr_StorageBuffer_int %4 %int_0 %int_0 OpBranch %21 %21 = OpLabel %22 = OpPhi %_ptr_StorageBuffer_int %20 %18 %23 %24 OpLoopMerge %25 %24 None OpBranchConditional %true %26 %25 %26 = OpLabel OpStore %22 %int_0 OpBranch %24 %24 = OpLabel %23 = OpPtrAccessChain %_ptr_StorageBuffer_int %22 %int_1 OpBranch %21 %25 = OpLabel %27 = OpAccessChain %_ptr_Function_int %19 %int_0 %int_0 %28 = OpLoad %int %27 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(test, true); } TEST_F(LocalAccessChainConvertTest, VariablePointers) { // A case with variable pointer capability. We should not convert // the access chain on the function scope symbol because the variable pointer // could the analysis to miss references to function scope symbols. const std::string test = R"(OpCapability Shader OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" OpExecutionMode %2 LocalSize 1 1 1 OpSource GLSL 450 OpMemberDecorate %_struct_3 0 Offset 0 OpDecorate %_struct_3 Block OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 0 OpDecorate %_ptr_StorageBuffer_int ArrayStride 4 OpDecorate %_arr_int_int_128 ArrayStride 4 %void = OpTypeVoid %8 = OpTypeFunction %void %int = OpTypeInt 32 1 %int_128 = OpConstant %int 128 %_arr_int_int_128 = OpTypeArray %int %int_128 %_struct_3 = OpTypeStruct %_arr_int_int_128 %_ptr_StorageBuffer__struct_3 = OpTypePointer StorageBuffer %_struct_3 %_ptr_Function__struct_3 = OpTypePointer Function %_struct_3 %4 = OpVariable %_ptr_StorageBuffer__struct_3 StorageBuffer %bool = OpTypeBool %true = OpConstantTrue %bool %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %_ptr_StorageBuffer_int = OpTypePointer StorageBuffer %int %_ptr_Function_int = OpTypePointer Function %int %2 = OpFunction %void None %8 %18 = OpLabel %19 = OpVariable %_ptr_Function__struct_3 Function %20 = OpAccessChain %_ptr_StorageBuffer_int %4 %int_0 %int_0 OpBranch %21 %21 = OpLabel %22 = OpPhi %_ptr_StorageBuffer_int %20 %18 %23 %24 OpLoopMerge %25 %24 None OpBranchConditional %true %26 %25 %26 = OpLabel OpStore %22 %int_0 OpBranch %24 %24 = OpLabel %23 = OpPtrAccessChain %_ptr_StorageBuffer_int %22 %int_1 OpBranch %21 %25 = OpLabel %27 = OpAccessChain %_ptr_Function_int %19 %int_0 %int_0 %28 = OpLoad %int %27 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(test, test, false, true); } TEST_F(LocalAccessChainConvertTest, IdOverflowReplacingLoad) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "PSMain" OpExecutionMode %4 OriginUpperLeft OpDecorate %10 Location 47360 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_struct_8 = OpTypeStruct %v4float %_ptr_Function__struct_8 = OpTypePointer Function %_struct_8 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Function_v4float = OpTypePointer Function %v4float %4 = OpFunction %void None %3 %5 = OpLabel %10 = OpVariable %_ptr_Function__struct_8 Function %4194301 = OpAccessChain %_ptr_Function_v4float %10 %int_0 %4194302 = OpLoad %v4float %4194301 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); std::vector messages = { {SPV_MSG_ERROR, "", 0, 0, "ID overflow. Try running compact-ids."}}; SetMessageConsumer(GetTestMessageConsumer(messages)); auto result = SinglePassRunToBinary(text, true); EXPECT_EQ(Pass::Status::Failure, std::get<1>(result)); } TEST_F(LocalAccessChainConvertTest, IdOverflowReplacingStore1) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "PSMain" OpExecutionMode %4 OriginUpperLeft OpDecorate %10 Location 47360 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_struct_7 = OpTypeStruct %v4float %_ptr_Function__struct_7 = OpTypePointer Function %_struct_7 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Function_v4float = OpTypePointer Function %v4float %13 = OpConstantNull %v4float %4 = OpFunction %void None %3 %5 = OpLabel %10 = OpVariable %_ptr_Function__struct_7 Function %4194302 = OpAccessChain %_ptr_Function_v4float %10 %int_0 OpStore %4194302 %13 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); std::vector messages = { {SPV_MSG_ERROR, "", 0, 0, "ID overflow. Try running compact-ids."}}; SetMessageConsumer(GetTestMessageConsumer(messages)); auto result = SinglePassRunToBinary(text, true); EXPECT_EQ(Pass::Status::Failure, std::get<1>(result)); } TEST_F(LocalAccessChainConvertTest, IdOverflowReplacingStore2) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "PSMain" OpExecutionMode %4 OriginUpperLeft OpDecorate %10 Location 47360 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_struct_7 = OpTypeStruct %v4float %_ptr_Function__struct_7 = OpTypePointer Function %_struct_7 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Function_v4float = OpTypePointer Function %v4float %13 = OpConstantNull %v4float %4 = OpFunction %void None %3 %5 = OpLabel %10 = OpVariable %_ptr_Function__struct_7 Function %4194301 = OpAccessChain %_ptr_Function_v4float %10 %int_0 OpStore %4194301 %13 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); std::vector messages = { {SPV_MSG_ERROR, "", 0, 0, "ID overflow. Try running compact-ids."}}; SetMessageConsumer(GetTestMessageConsumer(messages)); auto result = SinglePassRunToBinary(text, true); EXPECT_EQ(Pass::Status::Failure, std::get<1>(result)); } TEST_F(LocalAccessChainConvertTest, AccessChainWithNoIndex) { const std::string before = R"( ; CHECK: OpFunction ; CHECK: [[var:%\w+]] = OpVariable ; CHECK: OpStore [[var]] %true ; CHECK: OpLoad %bool [[var]] OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %void = OpTypeVoid %4 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %_ptr_Function_bool = OpTypePointer Function %bool %2 = OpFunction %void None %4 %8 = OpLabel %9 = OpVariable %_ptr_Function_bool Function %10 = OpAccessChain %_ptr_Function_bool %9 OpStore %10 %true %11 = OpLoad %bool %10 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(before, true); } TEST_F(LocalAccessChainConvertTest, AccessChainWithLongIndex) { // The access chain take a value that is larger than 32-bit. The index cannot // be encoded in an OpCompositeExtract, so nothing should be done. const std::string before = R"(OpCapability Shader OpCapability Int64 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main_0004f4d4_85b2f584" OpExecutionMode %2 OriginUpperLeft %ulong = OpTypeInt 64 0 %ulong_8589934592 = OpConstant %ulong 8589934592 %ulong_8589934591 = OpConstant %ulong 8589934591 %_arr_ulong_ulong_8589934592 = OpTypeArray %ulong %ulong_8589934592 %_ptr_Function__arr_ulong_ulong_8589934592 = OpTypePointer Function %_arr_ulong_ulong_8589934592 %_ptr_Function_ulong = OpTypePointer Function %ulong %void = OpTypeVoid %10 = OpTypeFunction %void %2 = OpFunction %void None %10 %11 = OpLabel %12 = OpVariable %_ptr_Function__arr_ulong_ulong_8589934592 Function %13 = OpAccessChain %_ptr_Function_ulong %12 %ulong_8589934591 %14 = OpLoad %ulong %13 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(before, before, false, true); } TEST_F(LocalAccessChainConvertTest, AccessChainWith32BitIndexInLong) { // The access chain has a value that is 32-bits, but it is stored in a 64-bit // variable. This access change can be converted to an extract. const std::string before = R"( ; CHECK: OpFunction ; CHECK: [[var:%\w+]] = OpVariable ; CHECK: [[ld:%\w+]] = OpLoad {{%\w+}} [[var]] ; CHECK: OpCompositeExtract %ulong [[ld]] 3 OpCapability Shader OpCapability Int64 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main_0004f4d4_85b2f584" OpExecutionMode %2 OriginUpperLeft %ulong = OpTypeInt 64 0 %ulong_8589934592 = OpConstant %ulong 8589934592 %ulong_3 = OpConstant %ulong 3 %_arr_ulong_ulong_8589934592 = OpTypeArray %ulong %ulong_8589934592 %_ptr_Function__arr_ulong_ulong_8589934592 = OpTypePointer Function %_arr_ulong_ulong_8589934592 %_ptr_Function_ulong = OpTypePointer Function %ulong %void = OpTypeVoid %10 = OpTypeFunction %void %2 = OpFunction %void None %10 %11 = OpLabel %12 = OpVariable %_ptr_Function__arr_ulong_ulong_8589934592 Function %13 = OpAccessChain %_ptr_Function_ulong %12 %ulong_3 %14 = OpLoad %ulong %13 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(before, true); } TEST_F(LocalAccessChainConvertTest, AccessChainWithVarIndex) { // The access chain has a value that is not constant, so there should not be // any changes. const std::string before = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main_0004f4d4_85b2f584" OpExecutionMode %2 OriginUpperLeft %uint = OpTypeInt 32 0 %uint_5 = OpConstant %uint 5 %_arr_uint_uint_5 = OpTypeArray %uint %uint_5 %_ptr_Function__arr_uint_uint_5 = OpTypePointer Function %_arr_uint_uint_5 %_ptr_Function_uint = OpTypePointer Function %uint %8 = OpUndef %uint %void = OpTypeVoid %10 = OpTypeFunction %void %2 = OpFunction %void None %10 %11 = OpLabel %12 = OpVariable %_ptr_Function__arr_uint_uint_5 Function %13 = OpAccessChain %_ptr_Function_uint %12 %8 %14 = OpLoad %uint %13 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(before, before, false, true); } TEST_F(LocalAccessChainConvertTest, OutOfBoundsAccess) { // The access chain indexes element 12 in an array of size 10. Nothing should // be done. const std::string assembly = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft %void = OpTypeVoid %5 = OpTypeFunction %void %int = OpTypeInt 32 1 %int_10 = OpConstant %int 10 %_arr_int_int_10 = OpTypeArray %int %int_10 %_ptr_Function_int = OpTypePointer Function %int %int_12 = OpConstant %int 12 %_ptr_Output_int = OpTypePointer Output %int %3 = OpVariable %_ptr_Output_int Output %_ptr_Function__arr_int_int_10 = OpTypePointer Function %_arr_int_int_10 %2 = OpFunction %void None %5 %13 = OpLabel %14 = OpVariable %_ptr_Function__arr_int_int_10 Function %15 = OpAccessChain %_ptr_Function_int %14 %int_12 %16 = OpLoad %int %15 OpStore %3 %16 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(assembly, assembly, false, true); } TEST_F(LocalAccessChainConvertTest, OutOfBoundsAccessAtBoundary) { // The access chain indexes element 10 in an array of size 10. Nothing should // be done. const std::string assembly = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft %void = OpTypeVoid %5 = OpTypeFunction %void %int = OpTypeInt 32 1 %int_10 = OpConstant %int 10 %_arr_int_int_10 = OpTypeArray %int %int_10 %_ptr_Function_int = OpTypePointer Function %int %_ptr_Output_int = OpTypePointer Output %int %3 = OpVariable %_ptr_Output_int Output %_ptr_Function__arr_int_int_10 = OpTypePointer Function %_arr_int_int_10 %2 = OpFunction %void None %5 %12 = OpLabel %13 = OpVariable %_ptr_Function__arr_int_int_10 Function %14 = OpAccessChain %_ptr_Function_int %13 %int_10 %15 = OpLoad %int %14 OpStore %3 %15 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(assembly, assembly, false, true); } TEST_F(LocalAccessChainConvertTest, NegativeIndex) { // The access chain has a negative index and should not be converted because // the extract instruction cannot hold a negative number. const std::string assembly = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft %void = OpTypeVoid %4 = OpTypeFunction %void %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %uint_3808428041 = OpConstant %uint 3808428041 %_arr_int_uint_3808428041 = OpTypeArray %int %uint_3808428041 %_ptr_Function__arr_int_uint_3808428041 = OpTypePointer Function %_arr_int_uint_3808428041 %_ptr_Function_int = OpTypePointer Function %int %int_n1272971256 = OpConstant %int -1272971256 %2 = OpFunction %void None %4 %12 = OpLabel %13 = OpVariable %_ptr_Function__arr_int_uint_3808428041 Function %14 = OpAccessChain %_ptr_Function_int %13 %int_n1272971256 %15 = OpLoad %int %14 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(assembly, assembly, false, true); } TEST_F(LocalAccessChainConvertTest, VkMemoryModelTest) { const std::string text = R"( ; CHECK: OpCapability Shader ; CHECK: OpCapability VulkanMemoryModel ; CHECK: OpExtension "SPV_KHR_vulkan_memory_model" OpCapability Shader OpCapability VulkanMemoryModel OpExtension "SPV_KHR_vulkan_memory_model" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical Vulkan OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpName %main "main" OpName %a "a" %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Function_float = OpTypePointer Function %float %float_1 = OpConstant %float 1 ; CHECK: OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: [[a:%\w+]] = OpVariable ; Make sure the access chains were removed. ; CHECK: [[ld:%\w+]] = OpLoad {{%\w+}} [[a]] ; CHECK: [[ex:%\w+]] = OpCompositeExtract {{%\w+}} [[ld]] 0 ; CHECK: [[ld2:%\w+]] = OpLoad {{%\w+}} [[a]] ; CHECK: [[v:%\w+]] = OpCompositeInsert {{%\w+}} [[ex]] [[ld2]] 0 ; CHECK: OpStore [[a]] [[v]] %main = OpFunction %void None %3 %5 = OpLabel %a = OpVariable %_ptr_Function_v4float Function %13 = OpAccessChain %_ptr_Function_float %a %uint_0 %14 = OpLoad %float %13 %17 = OpAccessChain %_ptr_Function_float %a %uint_0 OpStore %17 %14 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } // TODO(greg-lunarg): Add tests to verify handling of these cases: // // Assorted vector and matrix types // Assorted struct array types // Assorted scalar types // Assorted non-target types // OpInBoundsAccessChain // Others? } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/local_redundancy_elimination_test.cpp000066400000000000000000000150751475742701700277630ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gmock/gmock.h" #include "source/opt/value_number_table.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using ::testing::HasSubstr; using ::testing::MatchesRegex; using LocalRedundancyEliminationTest = PassTest<::testing::Test>; // Remove an instruction when it was already computed. TEST_F(LocalRedundancyEliminationTest, RemoveRedundantAdd) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %6 = OpTypePointer Function %5 %2 = OpFunction %3 None %4 %7 = OpLabel %8 = OpVariable %6 Function %9 = OpLoad %5 %8 %10 = OpFAdd %5 %9 %9 ; CHECK: OpFAdd ; CHECK-NOT: OpFAdd %11 = OpFAdd %5 %9 %9 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } // Make sure we keep instruction that are different, but look similar. TEST_F(LocalRedundancyEliminationTest, KeepDifferentAdd) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %6 = OpTypePointer Function %5 %2 = OpFunction %3 None %4 %7 = OpLabel %8 = OpVariable %6 Function %9 = OpLoad %5 %8 %10 = OpFAdd %5 %9 %9 ; CHECK: OpFAdd OpStore %8 %10 %11 = OpLoad %5 %8 ; CHECK: %11 = OpLoad %12 = OpFAdd %5 %11 %11 ; CHECK: OpFAdd [[:%\w+]] %11 %11 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(text, false); } // This test is check that the values are being propagated properly, and that // we are able to identify sequences of instruction that are not needed. TEST_F(LocalRedundancyEliminationTest, RemoveMultipleInstructions) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %6 = OpTypePointer Uniform %5 %8 = OpVariable %6 Uniform %2 = OpFunction %3 None %4 %7 = OpLabel ; CHECK: [[r1:%\w+]] = OpLoad %9 = OpLoad %5 %8 ; CHECK-NEXT: [[r2:%\w+]] = OpFAdd [[:%\w+]] [[r1]] [[r1]] %10 = OpFAdd %5 %9 %9 ; CHECK-NEXT: [[r3:%\w+]] = OpFMul [[:%\w+]] [[r2]] [[r1]] %11 = OpFMul %5 %10 %9 ; CHECK-NOT: OpLoad %12 = OpLoad %5 %8 ; CHECK-NOT: OpFAdd [[:\w+]] %12 %12 %13 = OpFAdd %5 %12 %12 ; CHECK-NOT: OpFMul %14 = OpFMul %5 %13 %12 ; CHECK-NEXT: [[:%\w+]] = OpFAdd [[:%\w+]] [[r3]] [[r3]] %15 = OpFAdd %5 %14 %11 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(text, false); } // Redundant instructions in different blocks should be kept. TEST_F(LocalRedundancyEliminationTest, KeepInstructionsInDifferentBlocks) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %6 = OpTypePointer Function %5 %2 = OpFunction %3 None %4 %bb1 = OpLabel %8 = OpVariable %6 Function %9 = OpLoad %5 %8 %10 = OpFAdd %5 %9 %9 ; CHECK: OpFAdd OpBranch %bb2 %bb2 = OpLabel ; CHECK: OpFAdd %11 = OpFAdd %5 %9 %9 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(LocalRedundancyEliminationTest, StorageBufferIdentification) { const std::string text = R"( ; CHECK: [[gep:%\w+]] = OpAccessChain ; CHECK: [[ld:%\w+]] = OpLoad {{%\w+}} [[gep]] ; CHECK: [[add:%\w+]] = OpIAdd {{%\w+}} [[ld]] ; CHECK: OpStore [[gep]] [[add]] ; CHECK: [[ld:%\w+]] = OpLoad {{%\w+}} [[gep]] ; CHECK: [[add:%\w+]] = OpIAdd {{%\w+}} [[ld]] ; CHECK: OpStore [[gep]] [[add]] OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %block BufferBlock OpMemberDecorate %block 0 Offset 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %block = OpTypeStruct %int %array = OpTypeArray %block %int_1 %ptr_ssbo_array = OpTypePointer Uniform %array %ptr_ssbo_int = OpTypePointer Uniform %int %var = OpVariable %ptr_ssbo_array Uniform %void_fn = OpTypeFunction %void %fn = OpFunction %void None %void_fn %entry = OpLabel %gep1 = OpAccessChain %ptr_ssbo_int %var %int_0 %int_0 %ld1 = OpLoad %int %gep1 %add1 = OpIAdd %int %ld1 %int_1 %gep2 = OpAccessChain %ptr_ssbo_int %var %int_0 %int_0 OpStore %gep2 %add1 %gep3 = OpAccessChain %ptr_ssbo_int %var %int_0 %int_0 %ld3 = OpLoad %int %gep3 %add3 = OpIAdd %int %ld3 %int_1 %gep4 = OpAccessChain %ptr_ssbo_int %var %int_0 %int_0 OpStore %gep4 %add3 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/local_single_block_elim.cpp000066400000000000000000001445141475742701700256420ustar00rootroot00000000000000// Copyright (c) 2017 Valve Corporation // Copyright (c) 2017 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using LocalSingleBlockLoadStoreElimTest = PassTest<::testing::Test>; TEST_F(LocalSingleBlockLoadStoreElimTest, SimpleStoreLoadElim) { // #version 140 // // in vec4 BaseColor; // // void main() // { // vec4 v = BaseColor; // gl_FragColor = v; // } const std::string predefs_before = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %7 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output )"; const std::string before = R"(%main = OpFunction %void None %7 %13 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %14 = OpLoad %v4float %BaseColor OpStore %v %14 %15 = OpLoad %v4float %v OpStore %gl_FragColor %15 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %7 %13 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %14 = OpLoad %v4float %BaseColor OpStore %v %14 OpStore %gl_FragColor %14 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck( predefs_before + before, predefs_before + after, true, true); } TEST_F(LocalSingleBlockLoadStoreElimTest, LSBElimForLinkage) { const std::string predefs_before = R"(OpCapability Shader OpCapability Linkage %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpSource HLSL 630 OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" OpName %gl_FragColor "gl_FragColor" OpDecorate %main LinkageAttributes "main" Export %void = OpTypeVoid %7 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output )"; const std::string before = R"(%main = OpFunction %void None %7 %13 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %14 = OpLoad %v4float %BaseColor OpStore %v %14 %15 = OpLoad %v4float %v OpStore %gl_FragColor %15 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %7 %13 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %14 = OpLoad %v4float %BaseColor OpStore %v %14 OpStore %gl_FragColor %14 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck( predefs_before + before, predefs_before + after, true, true); } TEST_F(LocalSingleBlockLoadStoreElimTest, SimpleLoadLoadElim) { // #version 140 // // in vec4 BaseColor; // in float fi; // // void main() // { // vec4 v = BaseColor; // if (fi < 0) // v = vec4(0.0); // gl_FragData[0] = v; // gl_FragData[1] = v; // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %fi %gl_FragData OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" OpName %fi "fi" OpName %gl_FragData "gl_FragData" %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Input_float = OpTypePointer Input %float %fi = OpVariable %_ptr_Input_float Input %float_0 = OpConstant %float 0 %bool = OpTypeBool %16 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %_arr_v4float_uint_32 = OpTypeArray %v4float %uint_32 %_ptr_Output__arr_v4float_uint_32 = OpTypePointer Output %_arr_v4float_uint_32 %gl_FragData = OpVariable %_ptr_Output__arr_v4float_uint_32 Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Output_v4float = OpTypePointer Output %v4float %int_1 = OpConstant %int 1 )"; const std::string before = R"(%main = OpFunction %void None %8 %25 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %26 = OpLoad %v4float %BaseColor OpStore %v %26 %27 = OpLoad %float %fi %28 = OpFOrdLessThan %bool %27 %float_0 OpSelectionMerge %29 None OpBranchConditional %28 %30 %29 %30 = OpLabel OpStore %v %16 OpBranch %29 %29 = OpLabel %31 = OpLoad %v4float %v %32 = OpAccessChain %_ptr_Output_v4float %gl_FragData %int_0 OpStore %32 %31 %33 = OpLoad %v4float %v %34 = OpAccessChain %_ptr_Output_v4float %gl_FragData %int_1 OpStore %34 %33 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %8 %25 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %26 = OpLoad %v4float %BaseColor OpStore %v %26 %27 = OpLoad %float %fi %28 = OpFOrdLessThan %bool %27 %float_0 OpSelectionMerge %29 None OpBranchConditional %28 %30 %29 %30 = OpLabel OpStore %v %16 OpBranch %29 %29 = OpLabel %31 = OpLoad %v4float %v %32 = OpAccessChain %_ptr_Output_v4float %gl_FragData %int_0 OpStore %32 %31 %34 = OpAccessChain %_ptr_Output_v4float %gl_FragData %int_1 OpStore %34 %31 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck( predefs + before, predefs + after, true, true); } TEST_F(LocalSingleBlockLoadStoreElimTest, StoreStoreElim) { // // Note first store to v is eliminated // // #version 450 // // layout(location = 0) in vec4 BaseColor; // layout(location = 0) out vec4 OutColor; // // void main() // { // vec4 v = BaseColor; // v = v * 0.5; // OutColor = v; // } const std::string predefs_before = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" OpName %OutColor "OutColor" OpDecorate %BaseColor Location 0 OpDecorate %OutColor Location 0 %void = OpTypeVoid %7 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %float_0_5 = OpConstant %float 0.5 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output )"; const std::string before = R"(%main = OpFunction %void None %7 %14 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %15 = OpLoad %v4float %BaseColor OpStore %v %15 %16 = OpLoad %v4float %v %17 = OpVectorTimesScalar %v4float %16 %float_0_5 OpStore %v %17 %18 = OpLoad %v4float %v OpStore %OutColor %18 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %7 %14 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %15 = OpLoad %v4float %BaseColor %17 = OpVectorTimesScalar %v4float %15 %float_0_5 OpStore %v %17 OpStore %OutColor %17 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck( predefs_before + before, predefs_before + after, true, true); } TEST_F(LocalSingleBlockLoadStoreElimTest, NoStoreElimIfInterveningAccessChainLoad) { // // Note the first Store to %v is not eliminated due to the following access // chain reference. // // #version 450 // // layout(location = 0) in vec4 BaseColor0; // layout(location = 1) in vec4 BaseColor1; // layout(location = 2) flat in int Idx; // layout(location = 0) out vec4 OutColor; // // void main() // { // vec4 v = BaseColor0; // float f = v[Idx]; // v = BaseColor1 + vec4(0.1); // OutColor = v/f; // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor0 %Idx %BaseColor1 %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %v "v" OpName %BaseColor0 "BaseColor0" OpName %f "f" OpName %Idx "Idx" OpName %BaseColor1 "BaseColor1" OpName %OutColor "OutColor" OpDecorate %BaseColor0 Location 0 OpDecorate %Idx Flat OpDecorate %Idx Location 2 OpDecorate %BaseColor1 Location 1 OpDecorate %OutColor Location 0 %void = OpTypeVoid %10 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor0 = OpVariable %_ptr_Input_v4float Input %_ptr_Function_float = OpTypePointer Function %float %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %Idx = OpVariable %_ptr_Input_int Input %BaseColor1 = OpVariable %_ptr_Input_v4float Input %float_0_100000001 = OpConstant %float 0.100000001 %19 = OpConstantComposite %v4float %float_0_100000001 %float_0_100000001 %float_0_100000001 %float_0_100000001 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output )"; const std::string before = R"(%main = OpFunction %void None %10 %21 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %f = OpVariable %_ptr_Function_float Function %22 = OpLoad %v4float %BaseColor0 OpStore %v %22 %23 = OpLoad %int %Idx %24 = OpAccessChain %_ptr_Function_float %v %23 %25 = OpLoad %float %24 OpStore %f %25 %26 = OpLoad %v4float %BaseColor1 %27 = OpFAdd %v4float %26 %19 OpStore %v %27 %28 = OpLoad %v4float %v %29 = OpLoad %float %f %30 = OpCompositeConstruct %v4float %29 %29 %29 %29 %31 = OpFDiv %v4float %28 %30 OpStore %OutColor %31 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %10 %21 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %f = OpVariable %_ptr_Function_float Function %22 = OpLoad %v4float %BaseColor0 OpStore %v %22 %23 = OpLoad %int %Idx %24 = OpAccessChain %_ptr_Function_float %v %23 %25 = OpLoad %float %24 OpStore %f %25 %26 = OpLoad %v4float %BaseColor1 %27 = OpFAdd %v4float %26 %19 OpStore %v %27 %30 = OpCompositeConstruct %v4float %25 %25 %25 %25 %31 = OpFDiv %v4float %27 %30 OpStore %OutColor %31 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck( predefs + before, predefs + after, true, true); } TEST_F(LocalSingleBlockLoadStoreElimTest, NoElimIfInterveningAccessChainStore) { // #version 140 // // in vec4 BaseColor; // flat in int Idx; // // void main() // { // vec4 v = BaseColor; // v[Idx] = 0; // gl_FragColor = v; // } const std::string assembly = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %Idx %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" OpName %Idx "Idx" OpName %gl_FragColor "gl_FragColor" OpDecorate %Idx Flat %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %Idx = OpVariable %_ptr_Input_int Input %float_0 = OpConstant %float 0 %_ptr_Function_float = OpTypePointer Function %float %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %8 %18 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %19 = OpLoad %v4float %BaseColor OpStore %v %19 %20 = OpLoad %int %Idx %21 = OpAccessChain %_ptr_Function_float %v %20 OpStore %21 %float_0 %22 = OpLoad %v4float %v OpStore %gl_FragColor %22 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(assembly, assembly, false, true); } TEST_F(LocalSingleBlockLoadStoreElimTest, NoElimIfInterveningFunctionCall) { // #version 140 // // in vec4 BaseColor; // // void foo() { // } // // void main() // { // vec4 v = BaseColor; // foo(); // gl_FragColor = v; // } const std::string assembly = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %foo_ "foo(" OpName %v "v" OpName %BaseColor "BaseColor" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %8 %14 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %15 = OpLoad %v4float %BaseColor OpStore %v %15 %16 = OpFunctionCall %void %foo_ %17 = OpLoad %v4float %v OpStore %gl_FragColor %17 OpReturn OpFunctionEnd %foo_ = OpFunction %void None %8 %18 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(assembly, assembly, false, true); } TEST_F(LocalSingleBlockLoadStoreElimTest, ElimIfCopyObjectInFunction) { // Note: SPIR-V hand edited to insert CopyObject // // #version 140 // // in vec4 BaseColor; // // void main() // { // vec4 v1 = BaseColor; // gl_FragData[0] = v1; // vec4 v2 = BaseColor * 0.5; // gl_FragData[1] = v2; // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %gl_FragData OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %v1 "v1" OpName %BaseColor "BaseColor" OpName %gl_FragData "gl_FragData" OpName %v2 "v2" %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %_arr_v4float_uint_32 = OpTypeArray %v4float %uint_32 %_ptr_Output__arr_v4float_uint_32 = OpTypePointer Output %_arr_v4float_uint_32 %gl_FragData = OpVariable %_ptr_Output__arr_v4float_uint_32 Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Output_v4float = OpTypePointer Output %v4float %float_0_5 = OpConstant %float 0.5 %int_1 = OpConstant %int 1 )"; const std::string before = R"(%main = OpFunction %void None %8 %22 = OpLabel %v1 = OpVariable %_ptr_Function_v4float Function %v2 = OpVariable %_ptr_Function_v4float Function %23 = OpLoad %v4float %BaseColor OpStore %v1 %23 %24 = OpLoad %v4float %v1 %25 = OpAccessChain %_ptr_Output_v4float %gl_FragData %int_0 OpStore %25 %24 %26 = OpLoad %v4float %BaseColor %27 = OpVectorTimesScalar %v4float %26 %float_0_5 %28 = OpCopyObject %_ptr_Function_v4float %v2 OpStore %28 %27 %29 = OpLoad %v4float %28 %30 = OpAccessChain %_ptr_Output_v4float %gl_FragData %int_1 OpStore %30 %29 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %8 %22 = OpLabel %v1 = OpVariable %_ptr_Function_v4float Function %v2 = OpVariable %_ptr_Function_v4float Function %23 = OpLoad %v4float %BaseColor OpStore %v1 %23 %25 = OpAccessChain %_ptr_Output_v4float %gl_FragData %int_0 OpStore %25 %23 %26 = OpLoad %v4float %BaseColor %27 = OpVectorTimesScalar %v4float %26 %float_0_5 %28 = OpCopyObject %_ptr_Function_v4float %v2 OpStore %28 %27 %30 = OpAccessChain %_ptr_Output_v4float %gl_FragData %int_1 OpStore %30 %27 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck( predefs + before, predefs + after, true, true); } TEST_F(LocalSingleBlockLoadStoreElimTest, ElimOpaque) { // SPIR-V not representable in GLSL; not generatable from HLSL // at the moment const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %outColor %texCoords OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %S_t "S_t" OpMemberName %S_t 0 "v0" OpMemberName %S_t 1 "v1" OpMemberName %S_t 2 "smp" OpName %outColor "outColor" OpName %sampler15 "sampler15" OpName %s0 "s0" OpName %texCoords "texCoords" OpName %param "param" OpDecorate %sampler15 DescriptorSet 0 %void = OpTypeVoid %12 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %outColor = OpVariable %_ptr_Output_v4float Output %17 = OpTypeImage %float 2D 0 0 0 1 Unknown %18 = OpTypeSampledImage %17 %S_t = OpTypeStruct %v2float %v2float %18 %_ptr_Function_S_t = OpTypePointer Function %S_t %20 = OpTypeFunction %void %_ptr_Function_S_t %_ptr_UniformConstant_18 = OpTypePointer UniformConstant %18 %_ptr_Function_18 = OpTypePointer Function %18 %sampler15 = OpVariable %_ptr_UniformConstant_18 UniformConstant %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_2 = OpConstant %int 2 %_ptr_Function_v2float = OpTypePointer Function %v2float %_ptr_Input_v2float = OpTypePointer Input %v2float %texCoords = OpVariable %_ptr_Input_v2float Input )"; const std::string before = R"(%main = OpFunction %void None %12 %28 = OpLabel %s0 = OpVariable %_ptr_Function_S_t Function %param = OpVariable %_ptr_Function_S_t Function %29 = OpLoad %v2float %texCoords %30 = OpLoad %S_t %s0 %31 = OpCompositeInsert %S_t %29 %30 0 OpStore %s0 %31 %32 = OpLoad %18 %sampler15 %33 = OpLoad %S_t %s0 %34 = OpCompositeInsert %S_t %32 %33 2 OpStore %s0 %34 %35 = OpLoad %S_t %s0 OpStore %param %35 %36 = OpLoad %S_t %param %37 = OpCompositeExtract %18 %36 2 %38 = OpLoad %S_t %param %39 = OpCompositeExtract %v2float %38 0 %40 = OpImageSampleImplicitLod %v4float %37 %39 OpStore %outColor %40 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %12 %28 = OpLabel %s0 = OpVariable %_ptr_Function_S_t Function %param = OpVariable %_ptr_Function_S_t Function %29 = OpLoad %v2float %texCoords %30 = OpLoad %S_t %s0 %31 = OpCompositeInsert %S_t %29 %30 0 %32 = OpLoad %18 %sampler15 %34 = OpCompositeInsert %S_t %32 %31 2 OpStore %s0 %34 OpStore %param %34 %37 = OpCompositeExtract %18 %34 2 %39 = OpCompositeExtract %v2float %34 0 %40 = OpImageSampleImplicitLod %v4float %37 %39 OpStore %outColor %40 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck( predefs + before, predefs + after, true, true); } TEST_F(LocalSingleBlockLoadStoreElimTest, PositiveAndNegativeCallTree) { // Note that the call tree function bar is optimized, but foo is not // // #version 140 // // in vec4 BaseColor; // // vec4 foo(vec4 v1) // { // vec4 t = v1; // return t; // } // // vec4 bar(vec4 v1) // { // vec4 t = v1; // return t; // } // // void main() // { // gl_FragColor = bar(BaseColor); // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragColor %BaseColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %foo_vf4_ "foo(vf4;" OpName %v1 "v1" OpName %bar_vf4_ "bar(vf4;" OpName %v1_0 "v1" OpName %t "t" OpName %t_0 "t" OpName %gl_FragColor "gl_FragColor" OpName %BaseColor "BaseColor" OpName %param "param" %void = OpTypeVoid %13 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %17 = OpTypeFunction %v4float %_ptr_Function_v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %main = OpFunction %void None %13 %20 = OpLabel %param = OpVariable %_ptr_Function_v4float Function %21 = OpLoad %v4float %BaseColor OpStore %param %21 %22 = OpFunctionCall %v4float %bar_vf4_ %param OpStore %gl_FragColor %22 OpReturn OpFunctionEnd )"; const std::string before = R"(%foo_vf4_ = OpFunction %v4float None %17 %v1 = OpFunctionParameter %_ptr_Function_v4float %23 = OpLabel %t = OpVariable %_ptr_Function_v4float Function %24 = OpLoad %v4float %v1 OpStore %t %24 %25 = OpLoad %v4float %t OpReturnValue %25 OpFunctionEnd %bar_vf4_ = OpFunction %v4float None %17 %v1_0 = OpFunctionParameter %_ptr_Function_v4float %26 = OpLabel %t_0 = OpVariable %_ptr_Function_v4float Function %27 = OpLoad %v4float %v1_0 OpStore %t_0 %27 %28 = OpLoad %v4float %t_0 OpReturnValue %28 OpFunctionEnd )"; const std::string after = R"(%foo_vf4_ = OpFunction %v4float None %17 %v1 = OpFunctionParameter %_ptr_Function_v4float %23 = OpLabel %t = OpVariable %_ptr_Function_v4float Function %24 = OpLoad %v4float %v1 OpStore %t %24 %25 = OpLoad %v4float %t OpReturnValue %25 OpFunctionEnd %bar_vf4_ = OpFunction %v4float None %17 %v1_0 = OpFunctionParameter %_ptr_Function_v4float %26 = OpLabel %t_0 = OpVariable %_ptr_Function_v4float Function %27 = OpLoad %v4float %v1_0 OpStore %t_0 %27 OpReturnValue %27 OpFunctionEnd )"; SinglePassRunAndCheck( predefs + before, predefs + after, true, true); } TEST_F(LocalSingleBlockLoadStoreElimTest, PointerVariable) { // Test that checks if a pointer variable is removed. const std::string before = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" %2 OpExecutionMode %1 OriginUpperLeft OpMemberDecorate %_struct_3 0 Offset 0 OpDecorate %_runtimearr__struct_3 ArrayStride 16 OpMemberDecorate %_struct_5 0 Offset 0 OpDecorate %_struct_5 BufferBlock OpMemberDecorate %_struct_6 0 Offset 0 OpDecorate %_struct_6 BufferBlock OpDecorate %2 Location 0 OpDecorate %7 DescriptorSet 0 OpDecorate %7 Binding 0 %void = OpTypeVoid %10 = OpTypeFunction %void %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %_struct_3 = OpTypeStruct %v4float %_runtimearr__struct_3 = OpTypeRuntimeArray %_struct_3 %_struct_5 = OpTypeStruct %_runtimearr__struct_3 %_ptr_Uniform__struct_5 = OpTypePointer Uniform %_struct_5 %_struct_6 = OpTypeStruct %int %_ptr_Uniform__struct_6 = OpTypePointer Uniform %_struct_6 %_ptr_Function__ptr_Uniform__struct_5 = OpTypePointer Function %_ptr_Uniform__struct_5 %_ptr_Function__ptr_Uniform__struct_6 = OpTypePointer Function %_ptr_Uniform__struct_6 %int_0 = OpConstant %int 0 %uint_0 = OpConstant %uint 0 %2 = OpVariable %_ptr_Output_v4float Output %7 = OpVariable %_ptr_Uniform__struct_5 Uniform %1 = OpFunction %void None %10 %23 = OpLabel %24 = OpVariable %_ptr_Function__ptr_Uniform__struct_5 Function OpStore %24 %7 %26 = OpLoad %_ptr_Uniform__struct_5 %24 %27 = OpAccessChain %_ptr_Uniform_v4float %26 %int_0 %uint_0 %int_0 %28 = OpLoad %v4float %27 %29 = OpCopyObject %v4float %28 OpStore %2 %28 OpReturn OpFunctionEnd )"; const std::string after = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" %2 OpExecutionMode %1 OriginUpperLeft OpMemberDecorate %_struct_3 0 Offset 0 OpDecorate %_runtimearr__struct_3 ArrayStride 16 OpMemberDecorate %_struct_5 0 Offset 0 OpDecorate %_struct_5 BufferBlock OpMemberDecorate %_struct_6 0 Offset 0 OpDecorate %_struct_6 BufferBlock OpDecorate %2 Location 0 OpDecorate %7 DescriptorSet 0 OpDecorate %7 Binding 0 %void = OpTypeVoid %10 = OpTypeFunction %void %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %_struct_3 = OpTypeStruct %v4float %_runtimearr__struct_3 = OpTypeRuntimeArray %_struct_3 %_struct_5 = OpTypeStruct %_runtimearr__struct_3 %_ptr_Uniform__struct_5 = OpTypePointer Uniform %_struct_5 %_struct_6 = OpTypeStruct %int %_ptr_Uniform__struct_6 = OpTypePointer Uniform %_struct_6 %_ptr_Function__ptr_Uniform__struct_5 = OpTypePointer Function %_ptr_Uniform__struct_5 %_ptr_Function__ptr_Uniform__struct_6 = OpTypePointer Function %_ptr_Uniform__struct_6 %int_0 = OpConstant %int 0 %uint_0 = OpConstant %uint 0 %2 = OpVariable %_ptr_Output_v4float Output %7 = OpVariable %_ptr_Uniform__struct_5 Uniform %1 = OpFunction %void None %10 %23 = OpLabel %24 = OpVariable %_ptr_Function__ptr_Uniform__struct_5 Function OpStore %24 %7 %27 = OpAccessChain %_ptr_Uniform_v4float %7 %int_0 %uint_0 %int_0 %28 = OpLoad %v4float %27 %29 = OpCopyObject %v4float %28 OpStore %2 %28 OpReturn OpFunctionEnd )"; // Relax logical pointers to allow pointer allocations. SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); ValidatorOptions()->relax_logical_pointer = true; SinglePassRunAndCheck(before, after, true, true); } TEST_F(LocalSingleBlockLoadStoreElimTest, RedundantStore) { // Test that checks if a pointer variable is removed. const std::string predefs_before = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %7 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output )"; const std::string before = R"(%main = OpFunction %void None %7 %13 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %14 = OpLoad %v4float %BaseColor OpStore %v %14 OpBranch %16 %16 = OpLabel %15 = OpLoad %v4float %v OpStore %v %15 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %7 %13 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %14 = OpLoad %v4float %BaseColor OpStore %v %14 OpBranch %16 %16 = OpLabel %15 = OpLoad %v4float %v OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck( predefs_before + before, predefs_before + after, true, true); } TEST_F(LocalSingleBlockLoadStoreElimTest, RedundantStore2) { // Test that checks if a pointer variable is removed. const std::string predefs_before = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %7 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output )"; const std::string before = R"(%main = OpFunction %void None %7 %13 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %14 = OpLoad %v4float %BaseColor OpStore %v %14 OpBranch %16 %16 = OpLabel %15 = OpLoad %v4float %v OpStore %v %15 %17 = OpLoad %v4float %v OpStore %v %17 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %7 %13 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %14 = OpLoad %v4float %BaseColor OpStore %v %14 OpBranch %16 %16 = OpLabel %15 = OpLoad %v4float %v OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck( predefs_before + before, predefs_before + after, true, true); } // Test that that an unused OpAccessChain between two store does does not // hinders the removal of the first store. We need to check this because // local-access-chain-convert does always remove the OpAccessChain instructions // that become dead. TEST_F(LocalSingleBlockLoadStoreElimTest, StoreElimIfInterveningUnusedAccessChain) { const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor0 %Idx %BaseColor1 %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %v "v" OpName %BaseColor0 "BaseColor0" OpName %Idx "Idx" OpName %BaseColor1 "BaseColor1" OpName %OutColor "OutColor" OpDecorate %BaseColor0 Location 0 OpDecorate %Idx Flat OpDecorate %Idx Location 2 OpDecorate %BaseColor1 Location 1 OpDecorate %OutColor Location 0 %void = OpTypeVoid %10 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor0 = OpVariable %_ptr_Input_v4float Input %_ptr_Function_float = OpTypePointer Function %float %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %Idx = OpVariable %_ptr_Input_int Input %BaseColor1 = OpVariable %_ptr_Input_v4float Input %float_0_100000001 = OpConstant %float 0.100000001 %19 = OpConstantComposite %v4float %float_0_100000001 %float_0_100000001 %float_0_100000001 %float_0_100000001 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output )"; const std::string before = R"(%main = OpFunction %void None %10 %21 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %22 = OpLoad %v4float %BaseColor0 OpStore %v %22 %23 = OpLoad %int %Idx %24 = OpAccessChain %_ptr_Function_float %v %23 %26 = OpLoad %v4float %BaseColor1 %27 = OpFAdd %v4float %26 %19 OpStore %v %27 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %10 %21 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %22 = OpLoad %v4float %BaseColor0 %23 = OpLoad %int %Idx %24 = OpAccessChain %_ptr_Function_float %v %23 %26 = OpLoad %v4float %BaseColor1 %27 = OpFAdd %v4float %26 %19 OpStore %v %27 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck( predefs + before, predefs + after, true, true); } TEST_F(LocalSingleBlockLoadStoreElimTest, VariablePointerTest) { // Check that the load of the first variable is still used and that the load // of the third variable is propagated. The first load has to remain because // of the store to the variable pointer. const std::string text = R"( ; CHECK: [[v1:%\w+]] = OpVariable ; CHECK: [[v2:%\w+]] = OpVariable ; CHECK: [[v3:%\w+]] = OpVariable ; CHECK: [[phi:%\w+]] = OpPhi ; CHECK: [[ld1:%\w+]] = OpLoad %int [[v1]] ; CHECK: OpIAdd %int [[ld1]] %int_0 OpCapability Shader OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" OpExecutionMode %2 LocalSize 1 1 1 OpSource GLSL 450 OpMemberDecorate %_struct_3 0 Offset 0 OpMemberDecorate %_struct_3 1 Offset 4 %void = OpTypeVoid %5 = OpTypeFunction %void %int = OpTypeInt 32 1 %bool = OpTypeBool %_struct_3 = OpTypeStruct %int %int %_ptr_Function__struct_3 = OpTypePointer Function %_struct_3 %_ptr_Function_int = OpTypePointer Function %int %true = OpConstantTrue %bool %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %13 = OpConstantNull %_struct_3 %2 = OpFunction %void None %5 %14 = OpLabel %15 = OpVariable %_ptr_Function_int Function %16 = OpVariable %_ptr_Function_int Function %17 = OpVariable %_ptr_Function_int Function OpSelectionMerge %18 None OpBranchConditional %true %19 %20 %19 = OpLabel OpBranch %18 %20 = OpLabel OpBranch %18 %18 = OpLabel %21 = OpPhi %_ptr_Function_int %15 %19 %16 %20 OpStore %15 %int_1 OpStore %21 %int_0 %22 = OpLoad %int %15 OpStore %17 %int_0 %23 = OpLoad %int %17 %24 = OpIAdd %int %22 %23 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(LocalSingleBlockLoadStoreElimTest, DebugDeclareTest) { // If OpenCL.DebugInfo.100 enabled, check that store/load is still // optimized, but stores are not deleted for store/store. // // struct PS_INPUT { // float4 c0 : COLOR0; // float4 c1 : COLOR1; // }; // // struct PS_OUTPUT { // float4 vColor : SV_Target0; // }; // // PS_OUTPUT MainPs(PS_INPUT i) { // PS_OUTPUT ps_output; // float4 c; // c = i.c0; // c += i.c1; // c /= 2.0; // ps_output.vColor = c; // return ps_output; // } const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %MainPs "MainPs" %in_var_COLOR0 %in_var_COLOR1 %out_var_SV_Target0 OpExecutionMode %MainPs OriginUpperLeft %6 = OpString "foo3.frag" %7 = OpString "PS_OUTPUT" %8 = OpString "float" %9 = OpString "vColor" %10 = OpString "PS_INPUT" %11 = OpString "c1" %12 = OpString "c0" %13 = OpString "src.MainPs" %14 = OpString "c" %15 = OpString "ps_output" %16 = OpString "i" OpName %in_var_COLOR0 "in.var.COLOR0" OpName %in_var_COLOR1 "in.var.COLOR1" OpName %out_var_SV_Target0 "out.var.SV_Target0" OpName %MainPs "MainPs" OpName %PS_INPUT "PS_INPUT" OpMemberName %PS_INPUT 0 "c0" OpMemberName %PS_INPUT 1 "c1" OpName %param_var_i "param.var.i" OpName %PS_OUTPUT "PS_OUTPUT" OpMemberName %PS_OUTPUT 0 "vColor" OpName %src_MainPs "src.MainPs" OpName %i "i" OpName %bb_entry "bb.entry" OpName %ps_output "ps_output" OpName %c "c" OpDecorate %in_var_COLOR0 Location 0 OpDecorate %in_var_COLOR1 Location 1 OpDecorate %out_var_SV_Target0 Location 0 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %float = OpTypeFloat 32 %float_2 = OpConstant %float 2 %v4float = OpTypeVector %float 4 %31 = OpConstantComposite %v4float %float_2 %float_2 %float_2 %float_2 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %uint_128 = OpConstant %uint 128 %uint_0 = OpConstant %uint 0 %uint_256 = OpConstant %uint 256 %40 = OpTypeFunction %void %PS_INPUT = OpTypeStruct %v4float %v4float %_ptr_Function_PS_INPUT = OpTypePointer Function %PS_INPUT %PS_OUTPUT = OpTypeStruct %v4float %42 = OpTypeFunction %PS_OUTPUT %_ptr_Function_PS_INPUT %_ptr_Function_PS_OUTPUT = OpTypePointer Function %PS_OUTPUT %_ptr_Function_v4float = OpTypePointer Function %v4float %in_var_COLOR0 = OpVariable %_ptr_Input_v4float Input %in_var_COLOR1 = OpVariable %_ptr_Input_v4float Input %out_var_SV_Target0 = OpVariable %_ptr_Output_v4float Output %45 = OpExtInst %void %1 DebugSource %6 %46 = OpExtInst %void %1 DebugCompilationUnit 1 4 %45 HLSL %47 = OpExtInst %void %1 DebugTypeComposite %7 Structure %45 8 1 %46 %7 %uint_128 FlagIsProtected|FlagIsPrivate %48 %49 = OpExtInst %void %1 DebugTypeBasic %8 %uint_32 Float %50 = OpExtInst %void %1 DebugTypeVector %49 4 %48 = OpExtInst %void %1 DebugTypeMember %9 %50 %45 10 5 %47 %uint_0 %uint_128 FlagIsProtected|FlagIsPrivate %51 = OpExtInst %void %1 DebugTypeComposite %10 Structure %45 2 1 %46 %10 %uint_256 FlagIsProtected|FlagIsPrivate %52 %53 %53 = OpExtInst %void %1 DebugTypeMember %11 %50 %45 5 5 %51 %uint_128 %uint_128 FlagIsProtected|FlagIsPrivate %52 = OpExtInst %void %1 DebugTypeMember %12 %50 %45 4 5 %51 %uint_0 %uint_128 FlagIsProtected|FlagIsPrivate %54 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %47 %51 %55 = OpExtInst %void %1 DebugFunction %13 %54 %45 13 1 %46 %13 FlagIsProtected|FlagIsPrivate 14 %src_MainPs %56 = OpExtInst %void %1 DebugLexicalBlock %45 14 1 %55 %57 = OpExtInst %void %1 DebugLocalVariable %14 %50 %45 16 12 %56 FlagIsLocal %58 = OpExtInst %void %1 DebugLocalVariable %15 %47 %45 15 15 %56 FlagIsLocal %59 = OpExtInst %void %1 DebugExpression %60 = OpExtInst %void %1 DebugLocalVariable %16 %51 %45 13 29 %55 FlagIsLocal 1 %61 = OpExtInst %void %1 DebugLocalVariable %14 %50 %45 16 12 %55 FlagIsLocal 1 %MainPs = OpFunction %void None %40 %62 = OpLabel %param_var_i = OpVariable %_ptr_Function_PS_INPUT Function %63 = OpLoad %v4float %in_var_COLOR0 %64 = OpLoad %v4float %in_var_COLOR1 %65 = OpCompositeConstruct %PS_INPUT %63 %64 OpStore %param_var_i %65 %66 = OpFunctionCall %PS_OUTPUT %src_MainPs %param_var_i %67 = OpCompositeExtract %v4float %66 0 OpStore %out_var_SV_Target0 %67 OpReturn OpFunctionEnd OpLine %6 13 1 %src_MainPs = OpFunction %PS_OUTPUT None %42 %83 = OpExtInst %void %1 DebugScope %55 OpLine %6 13 29 %i = OpFunctionParameter %_ptr_Function_PS_INPUT %69 = OpExtInst %void %1 DebugDeclare %60 %i %59 %84 = OpExtInst %void %1 DebugNoScope %bb_entry = OpLabel %85 = OpExtInst %void %1 DebugScope %56 %ps_output = OpVariable %_ptr_Function_PS_OUTPUT Function %c = OpVariable %_ptr_Function_v4float Function %71 = OpExtInst %void %1 DebugDeclare %61 %c %59 OpLine %6 18 9 %72 = OpAccessChain %_ptr_Function_v4float %i %int_0 OpLine %6 18 13 %73 = OpLoad %v4float %72 OpLine %6 18 5 OpStore %c %73 ;CHECK: OpStore %c %73 OpLine %6 19 10 %74 = OpAccessChain %_ptr_Function_v4float %i %int_1 OpLine %6 19 14 %75 = OpLoad %v4float %74 OpLine %6 19 5 %76 = OpLoad %v4float %c ;CHECK-NOT: OpLine %6 19 5 ;CHECK-NOT: %76 = OpLoad %v4float %c OpLine %6 19 7 %77 = OpFAdd %v4float %76 %75 ;CHECK-NOT: %77 = OpFAdd %v4float %76 %75 ;CHECK: %77 = OpFAdd %v4float %73 %75 OpLine %6 19 5 OpStore %c %77 ;CHECK: OpStore %c %77 OpLine %6 20 5 %78 = OpLoad %v4float %c ;CHECK-NOT: OpLine %6 20 5 ;CHECK-NOT: %78 = OpLoad %v4float %c OpLine %6 20 7 %79 = OpFDiv %v4float %78 %31 ;CHECK-NOT %79 = OpFDiv %v4float %78 %31 ;CHECK: %79 = OpFDiv %v4float %77 %31 OpLine %6 20 5 OpStore %c %79 ;CHECK: OpStore %c %79 OpLine %6 22 26 %80 = OpLoad %v4float %c ;CHECK-NOT: OpLine %6 22 26 ;CHECK-NOT: %80 = OpLoad %v4float %c OpLine %6 22 5 %81 = OpAccessChain %_ptr_Function_v4float %ps_output %int_0 OpStore %81 %80 ;CHECK-NOT: OpStore %81 %80 ;CHECK: OpStore %81 %79 OpLine %6 23 12 %82 = OpLoad %PS_OUTPUT %ps_output OpLine %6 23 5 OpReturnValue %82 %86 = OpExtInst %void %1 DebugNoScope OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(text, false); } TEST_F(LocalSingleBlockLoadStoreElimTest, DebugValueTest) { // If OpenCL.DebugInfo.100 enabled, check that store/load is still // optimized, but stores are not deleted for store/store. // Same source as DebugDeclareTest; DebugDeclare replaced with // equivalent DebugValue const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %MainPs "MainPs" %in_var_COLOR0 %in_var_COLOR1 %out_var_SV_Target0 OpExecutionMode %MainPs OriginUpperLeft %6 = OpString "foo3.frag" %7 = OpString "PS_OUTPUT" %8 = OpString "float" %9 = OpString "vColor" %10 = OpString "PS_INPUT" %11 = OpString "c1" %12 = OpString "c0" %13 = OpString "src.MainPs" %14 = OpString "c" %15 = OpString "ps_output" %16 = OpString "i" OpName %in_var_COLOR0 "in.var.COLOR0" OpName %in_var_COLOR1 "in.var.COLOR1" OpName %out_var_SV_Target0 "out.var.SV_Target0" OpName %MainPs "MainPs" OpName %PS_INPUT "PS_INPUT" OpMemberName %PS_INPUT 0 "c0" OpMemberName %PS_INPUT 1 "c1" OpName %param_var_i "param.var.i" OpName %PS_OUTPUT "PS_OUTPUT" OpMemberName %PS_OUTPUT 0 "vColor" OpName %src_MainPs "src.MainPs" OpName %i "i" OpName %bb_entry "bb.entry" OpName %ps_output "ps_output" OpName %c "c" OpDecorate %in_var_COLOR0 Location 0 OpDecorate %in_var_COLOR1 Location 1 OpDecorate %out_var_SV_Target0 Location 0 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %float = OpTypeFloat 32 %float_2 = OpConstant %float 2 %v4float = OpTypeVector %float 4 %31 = OpConstantComposite %v4float %float_2 %float_2 %float_2 %float_2 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %uint_128 = OpConstant %uint 128 %uint_0 = OpConstant %uint 0 %uint_256 = OpConstant %uint 256 %40 = OpTypeFunction %void %PS_INPUT = OpTypeStruct %v4float %v4float %_ptr_Function_PS_INPUT = OpTypePointer Function %PS_INPUT %PS_OUTPUT = OpTypeStruct %v4float %42 = OpTypeFunction %PS_OUTPUT %_ptr_Function_PS_INPUT %_ptr_Function_PS_OUTPUT = OpTypePointer Function %PS_OUTPUT %_ptr_Function_v4float = OpTypePointer Function %v4float %in_var_COLOR0 = OpVariable %_ptr_Input_v4float Input %in_var_COLOR1 = OpVariable %_ptr_Input_v4float Input %out_var_SV_Target0 = OpVariable %_ptr_Output_v4float Output %45 = OpExtInst %void %1 DebugSource %6 %46 = OpExtInst %void %1 DebugCompilationUnit 1 4 %45 HLSL %47 = OpExtInst %void %1 DebugTypeComposite %7 Structure %45 8 1 %46 %7 %uint_128 FlagIsProtected|FlagIsPrivate %48 %49 = OpExtInst %void %1 DebugTypeBasic %8 %uint_32 Float %50 = OpExtInst %void %1 DebugTypeVector %49 4 %48 = OpExtInst %void %1 DebugTypeMember %9 %50 %45 10 5 %47 %uint_0 %uint_128 FlagIsProtected|FlagIsPrivate %51 = OpExtInst %void %1 DebugTypeComposite %10 Structure %45 2 1 %46 %10 %uint_256 FlagIsProtected|FlagIsPrivate %52 %53 %53 = OpExtInst %void %1 DebugTypeMember %11 %50 %45 5 5 %51 %uint_128 %uint_128 FlagIsProtected|FlagIsPrivate %52 = OpExtInst %void %1 DebugTypeMember %12 %50 %45 4 5 %51 %uint_0 %uint_128 FlagIsProtected|FlagIsPrivate %54 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %47 %51 %55 = OpExtInst %void %1 DebugFunction %13 %54 %45 13 1 %46 %13 FlagIsProtected|FlagIsPrivate 14 %src_MainPs %56 = OpExtInst %void %1 DebugLexicalBlock %45 14 1 %55 %57 = OpExtInst %void %1 DebugLocalVariable %14 %50 %45 16 12 %56 FlagIsLocal %58 = OpExtInst %void %1 DebugLocalVariable %15 %47 %45 15 15 %56 FlagIsLocal %59 = OpExtInst %void %1 DebugExpression %60 = OpExtInst %void %1 DebugOperation Deref %61 = OpExtInst %void %1 DebugExpression %60 %62 = OpExtInst %void %1 DebugLocalVariable %16 %51 %45 13 29 %55 FlagIsLocal 1 %63 = OpExtInst %void %1 DebugLocalVariable %14 %50 %45 16 12 %55 FlagIsLocal 1 %MainPs = OpFunction %void None %40 %64 = OpLabel %param_var_i = OpVariable %_ptr_Function_PS_INPUT Function %65 = OpLoad %v4float %in_var_COLOR0 %66 = OpLoad %v4float %in_var_COLOR1 %67 = OpCompositeConstruct %PS_INPUT %65 %66 OpStore %param_var_i %67 %68 = OpFunctionCall %PS_OUTPUT %src_MainPs %param_var_i %69 = OpCompositeExtract %v4float %68 0 OpStore %out_var_SV_Target0 %69 OpReturn OpFunctionEnd OpLine %6 13 1 %src_MainPs = OpFunction %PS_OUTPUT None %42 %70 = OpExtInst %void %1 DebugScope %55 OpLine %6 13 29 %i = OpFunctionParameter %_ptr_Function_PS_INPUT %71 = OpExtInst %void %1 DebugDeclare %62 %i %59 %72 = OpExtInst %void %1 DebugNoScope %bb_entry = OpLabel %73 = OpExtInst %void %1 DebugScope %56 %ps_output = OpVariable %_ptr_Function_PS_OUTPUT Function %c = OpVariable %_ptr_Function_v4float Function %74 = OpExtInst %void %1 DebugValue %63 %c %61 OpLine %6 18 9 %75 = OpAccessChain %_ptr_Function_v4float %i %int_0 OpLine %6 18 13 %76 = OpLoad %v4float %75 OpLine %6 18 5 OpStore %c %76 ;CHECK: OpStore %c %76 OpLine %6 19 10 %77 = OpAccessChain %_ptr_Function_v4float %i %int_1 OpLine %6 19 14 %78 = OpLoad %v4float %77 OpLine %6 19 5 %79 = OpLoad %v4float %c ;CHECK-NOT: OpLine %6 19 5 ;CHECK-NOT: %79 = OpLoad %v4float %c OpLine %6 19 7 %80 = OpFAdd %v4float %79 %78 ;CHECK-NOT: %80 = OpFAdd %v4float %79 %78 ;CHECK: %80 = OpFAdd %v4float %76 %78 OpLine %6 19 5 OpStore %c %80 ;CHECK: OpStore %c %80 OpLine %6 20 5 %81 = OpLoad %v4float %c ;CHECK-NOT: OpLine %6 20 5 ;CHECK-NOT: %81 = OpLoad %v4float %c OpLine %6 20 7 %82 = OpFDiv %v4float %81 %31 ;CHECK-NOT: %82 = OpFDiv %v4float %81 %31 ;CHECK: %82 = OpFDiv %v4float %80 %31 OpLine %6 20 5 OpStore %c %82 ;CHECK: OpStore %c %82 OpLine %6 22 26 %83 = OpLoad %v4float %c ;CHECK-NOT: OpLine %6 22 26 ;CHECK-NOT: %83 = OpLoad %v4float %c OpLine %6 22 5 %84 = OpAccessChain %_ptr_Function_v4float %ps_output %int_0 OpStore %84 %83 ;CHECK-NOT: OpStore %84 %83 ;CHECK: OpStore %84 %82 OpLine %6 23 12 %85 = OpLoad %PS_OUTPUT %ps_output OpLine %6 23 5 OpReturnValue %85 %86 = OpExtInst %void %1 DebugNoScope OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(text, false); } TEST_F(LocalSingleBlockLoadStoreElimTest, VkMemoryModelTest) { const std::string text = R"( ; CHECK: OpCapability Shader ; CHECK: OpCapability VulkanMemoryModel ; CHECK: OpExtension "SPV_KHR_vulkan_memory_model" OpCapability Shader OpCapability VulkanMemoryModel OpExtension "SPV_KHR_vulkan_memory_model" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical Vulkan OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %bool = OpTypeBool %false = OpConstantFalse %bool ; CHECK: OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: [[a:%\w+]] = OpVariable ; CHECK-NEXT: [[b:%\w+]] = OpVariable ; CHECK: OpStore [[a]] [[v:%\w+]] ; CHECK-NOT: OpLoad %int [[a]] ; CHECK: OpStore [[b]] [[v]] %main = OpFunction %void None %3 %5 = OpLabel %a = OpVariable %_ptr_Function_int Function %b = OpVariable %_ptr_Function_int Function OpStore %a %int_0 %16 = OpLoad %int %a OpStore %b %16 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } // TODO(greg-lunarg): Add tests to verify handling of these cases: // // Other target variable types // InBounds Access Chains // Check for correctness in the presence of function calls // Others? } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/local_single_store_elim_test.cpp000066400000000000000000002110021475742701700267260ustar00rootroot00000000000000// Copyright (c) 2017 Valve Corporation // Copyright (c) 2017 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using LocalSingleStoreElimTest = PassTest<::testing::Test>; TEST_F(LocalSingleStoreElimTest, DoSomethingWithExtensions) { const std::string capabilities_and_extensions = R"(OpCapability Shader OpExtension "SPV_EXT_fragment_shader_interlock" OpExtension "SPV_NV_compute_shader_derivatives" OpExtension "SPV_KHR_ray_query" OpExtension "SPV_NV_shader_subgroup_partitioned" OpExtension "SPV_KHR_ray_tracing" OpExtension "SPV_EXT_descriptor_indexing" )"; const std::string before = capabilities_and_extensions + R"(%1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 140 %void = OpTypeVoid %4 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %2 = OpFunction %void None %4 %8 = OpLabel %9 = OpVariable %_ptr_Function_float Function OpStore %9 %float_0 %10 = OpLoad %float %9 OpReturn OpFunctionEnd )"; const std::string after = capabilities_and_extensions + R"(%1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 140 %void = OpTypeVoid %4 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %2 = OpFunction %void None %4 %8 = OpLabel %9 = OpVariable %_ptr_Function_float Function OpStore %9 %float_0 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(before, after, true, true); } TEST_F(LocalSingleStoreElimTest, PositiveAndNegative) { // Single store to v is optimized. Multiple store to // f is not optimized. // // #version 140 // // in vec4 BaseColor; // in float fi; // // void main() // { // vec4 v = BaseColor; // float f = fi; // if (f < 0) // f = 0.0; // gl_FragColor = v + f; // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %fi %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" OpName %f "f" OpName %fi "fi" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %9 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Function_float = OpTypePointer Function %float %_ptr_Input_float = OpTypePointer Input %float %fi = OpVariable %_ptr_Input_float Input %float_0 = OpConstant %float 0 %bool = OpTypeBool %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output )"; const std::string before = R"(%main = OpFunction %void None %9 %19 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %f = OpVariable %_ptr_Function_float Function %20 = OpLoad %v4float %BaseColor OpStore %v %20 %21 = OpLoad %float %fi OpStore %f %21 %22 = OpLoad %float %f %23 = OpFOrdLessThan %bool %22 %float_0 OpSelectionMerge %24 None OpBranchConditional %23 %25 %24 %25 = OpLabel OpStore %f %float_0 OpBranch %24 %24 = OpLabel %26 = OpLoad %v4float %v %27 = OpLoad %float %f %28 = OpCompositeConstruct %v4float %27 %27 %27 %27 %29 = OpFAdd %v4float %26 %28 OpStore %gl_FragColor %29 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %9 %19 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %f = OpVariable %_ptr_Function_float Function %20 = OpLoad %v4float %BaseColor OpStore %v %20 %21 = OpLoad %float %fi OpStore %f %21 %22 = OpLoad %float %f %23 = OpFOrdLessThan %bool %22 %float_0 OpSelectionMerge %24 None OpBranchConditional %23 %25 %24 %25 = OpLabel OpStore %f %float_0 OpBranch %24 %24 = OpLabel %27 = OpLoad %float %f %28 = OpCompositeConstruct %v4float %27 %27 %27 %27 %29 = OpFAdd %v4float %20 %28 OpStore %gl_FragColor %29 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before, predefs + after, true, true); } TEST_F(LocalSingleStoreElimTest, LSSElimForLinkage) { const std::string predefs = R"(OpCapability Shader OpCapability Linkage %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpSource HLSL 630 OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" OpName %f "f" OpName %fi "fi" OpName %gl_FragColor "gl_FragColor" OpDecorate %main LinkageAttributes "main" Export %void = OpTypeVoid %9 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Function_float = OpTypePointer Function %float %_ptr_Input_float = OpTypePointer Input %float %fi = OpVariable %_ptr_Input_float Input %float_0 = OpConstant %float 0 %bool = OpTypeBool %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output )"; const std::string before = R"(%main = OpFunction %void None %9 %19 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %f = OpVariable %_ptr_Function_float Function %20 = OpLoad %v4float %BaseColor OpStore %v %20 %21 = OpLoad %float %fi OpStore %f %21 %22 = OpLoad %float %f %23 = OpFOrdLessThan %bool %22 %float_0 OpSelectionMerge %24 None OpBranchConditional %23 %25 %24 %25 = OpLabel OpStore %f %float_0 OpBranch %24 %24 = OpLabel %26 = OpLoad %v4float %v %27 = OpLoad %float %f %28 = OpCompositeConstruct %v4float %27 %27 %27 %27 %29 = OpFAdd %v4float %26 %28 OpStore %gl_FragColor %29 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %9 %19 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %f = OpVariable %_ptr_Function_float Function %20 = OpLoad %v4float %BaseColor OpStore %v %20 %21 = OpLoad %float %fi OpStore %f %21 %22 = OpLoad %float %f %23 = OpFOrdLessThan %bool %22 %float_0 OpSelectionMerge %24 None OpBranchConditional %23 %25 %24 %25 = OpLabel OpStore %f %float_0 OpBranch %24 %24 = OpLabel %27 = OpLoad %float %f %28 = OpCompositeConstruct %v4float %27 %27 %27 %27 %29 = OpFAdd %v4float %20 %28 OpStore %gl_FragColor %29 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before, predefs + after, true, true); } TEST_F(LocalSingleStoreElimTest, ThreeStores) { // Three stores to multiple loads of v is not optimized. const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %fi %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" OpName %fi "fi" OpName %r "r" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %9 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Input_float = OpTypePointer Input %float %fi = OpVariable %_ptr_Input_float Input %float_0 = OpConstant %float 0 %bool = OpTypeBool %float_1 = OpConstant %float 1 %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output )"; const std::string before = R"(%main = OpFunction %void None %9 %19 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %r = OpVariable %_ptr_Function_v4float Function %20 = OpLoad %v4float %BaseColor OpStore %v %20 %21 = OpLoad %float %fi %22 = OpFOrdLessThan %bool %21 %float_0 OpSelectionMerge %23 None OpBranchConditional %22 %24 %25 %24 = OpLabel %26 = OpLoad %v4float %v OpStore %v %26 OpStore %r %26 OpBranch %23 %25 = OpLabel %27 = OpLoad %v4float %v %28 = OpCompositeConstruct %v4float %float_1 %float_1 %float_1 %float_1 OpStore %v %28 %29 = OpFSub %v4float %28 %27 OpStore %r %29 OpBranch %23 %23 = OpLabel %30 = OpLoad %v4float %r OpStore %gl_FragColor %30 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before, predefs + before, true, true); } TEST_F(LocalSingleStoreElimTest, MultipleLoads) { // Single store to multiple loads of v is optimized. // // #version 140 // // in vec4 BaseColor; // in float fi; // // void main() // { // vec4 v = BaseColor; // float f = fi; // if (f < 0) // f = 0.0; // gl_FragColor = v + f; // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %fi %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" OpName %fi "fi" OpName %r "r" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %9 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Input_float = OpTypePointer Input %float %fi = OpVariable %_ptr_Input_float Input %float_0 = OpConstant %float 0 %bool = OpTypeBool %float_1 = OpConstant %float 1 %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output )"; const std::string before = R"(%main = OpFunction %void None %9 %19 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %r = OpVariable %_ptr_Function_v4float Function %20 = OpLoad %v4float %BaseColor OpStore %v %20 %21 = OpLoad %float %fi %22 = OpFOrdLessThan %bool %21 %float_0 OpSelectionMerge %23 None OpBranchConditional %22 %24 %25 %24 = OpLabel %26 = OpLoad %v4float %v OpStore %r %26 OpBranch %23 %25 = OpLabel %27 = OpLoad %v4float %v %28 = OpCompositeConstruct %v4float %float_1 %float_1 %float_1 %float_1 %29 = OpFSub %v4float %28 %27 OpStore %r %29 OpBranch %23 %23 = OpLabel %30 = OpLoad %v4float %r OpStore %gl_FragColor %30 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %9 %19 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %r = OpVariable %_ptr_Function_v4float Function %20 = OpLoad %v4float %BaseColor OpStore %v %20 %21 = OpLoad %float %fi %22 = OpFOrdLessThan %bool %21 %float_0 OpSelectionMerge %23 None OpBranchConditional %22 %24 %25 %24 = OpLabel OpStore %r %20 OpBranch %23 %25 = OpLabel %28 = OpCompositeConstruct %v4float %float_1 %float_1 %float_1 %float_1 %29 = OpFSub %v4float %28 %20 OpStore %r %29 OpBranch %23 %23 = OpLabel %30 = OpLoad %v4float %r OpStore %gl_FragColor %30 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before, predefs + after, true, true); } TEST_F(LocalSingleStoreElimTest, NoStoreElimWithInterveningAccessChainLoad) { // Last load of v is eliminated, but access chain load and store of v isn't // // #version 140 // // in vec4 BaseColor; // // void main() // { // vec4 v = BaseColor; // float f = v[3]; // gl_FragColor = v * f; // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" OpName %f "f" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Function_float = OpTypePointer Function %float %uint = OpTypeInt 32 0 %uint_3 = OpConstant %uint 3 %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output )"; const std::string before = R"(%main = OpFunction %void None %8 %17 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %f = OpVariable %_ptr_Function_float Function %18 = OpLoad %v4float %BaseColor OpStore %v %18 %19 = OpAccessChain %_ptr_Function_float %v %uint_3 %20 = OpLoad %float %19 OpStore %f %20 %21 = OpLoad %v4float %v %22 = OpLoad %float %f %23 = OpVectorTimesScalar %v4float %21 %22 OpStore %gl_FragColor %23 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %8 %17 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %f = OpVariable %_ptr_Function_float Function %18 = OpLoad %v4float %BaseColor OpStore %v %18 %19 = OpAccessChain %_ptr_Function_float %v %uint_3 %20 = OpLoad %float %19 OpStore %f %20 %23 = OpVectorTimesScalar %v4float %18 %20 OpStore %gl_FragColor %23 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before, predefs + after, true, true); } TEST_F(LocalSingleStoreElimTest, NoReplaceOfDominatingPartialStore) { // Note: SPIR-V hand edited to initialize v to vec4(0.0) // // #version 140 // // in vec4 BaseColor; // // void main() // { // vec4 v; // float v[1] = 1.0; // gl_FragColor = v; // } const std::string assembly = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragColor %BaseColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %v "v" OpName %gl_FragColor "gl_FragColor" OpName %BaseColor "BaseColor" %void = OpTypeVoid %7 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %float_0 = OpConstant %float 0 %12 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %float_1 = OpConstant %float 1 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_ptr_Function_float = OpTypePointer Function %float %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %main = OpFunction %void None %7 %19 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %12 %20 = OpAccessChain %_ptr_Function_float %v %uint_1 OpStore %20 %float_1 %21 = OpLoad %v4float %v OpStore %gl_FragColor %21 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(assembly, assembly, true, true); } TEST_F(LocalSingleStoreElimTest, ElimIfCopyObjectInFunction) { // Note: hand edited to insert OpCopyObject // // #version 140 // // in vec4 BaseColor; // in float fi; // // void main() // { // vec4 v = BaseColor; // float f = fi; // if (f < 0) // f = 0.0; // gl_FragColor = v + f; // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %fi %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" OpName %f "f" OpName %fi "fi" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %9 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Function_float = OpTypePointer Function %float %_ptr_Input_float = OpTypePointer Input %float %fi = OpVariable %_ptr_Input_float Input %float_0 = OpConstant %float 0 %bool = OpTypeBool %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output )"; const std::string before = R"(%main = OpFunction %void None %9 %19 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %f = OpVariable %_ptr_Function_float Function %20 = OpLoad %v4float %BaseColor OpStore %v %20 %21 = OpLoad %float %fi OpStore %f %21 %22 = OpLoad %float %f %23 = OpFOrdLessThan %bool %22 %float_0 OpSelectionMerge %24 None OpBranchConditional %23 %25 %24 %25 = OpLabel OpStore %f %float_0 OpBranch %24 %24 = OpLabel %26 = OpCopyObject %_ptr_Function_v4float %v %27 = OpLoad %v4float %26 %28 = OpLoad %float %f %29 = OpCompositeConstruct %v4float %28 %28 %28 %28 %30 = OpFAdd %v4float %27 %29 OpStore %gl_FragColor %30 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %9 %19 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %f = OpVariable %_ptr_Function_float Function %20 = OpLoad %v4float %BaseColor OpStore %v %20 %21 = OpLoad %float %fi OpStore %f %21 %22 = OpLoad %float %f %23 = OpFOrdLessThan %bool %22 %float_0 OpSelectionMerge %24 None OpBranchConditional %23 %25 %24 %25 = OpLabel OpStore %f %float_0 OpBranch %24 %24 = OpLabel %26 = OpCopyObject %_ptr_Function_v4float %v %28 = OpLoad %float %f %29 = OpCompositeConstruct %v4float %28 %28 %28 %28 %30 = OpFAdd %v4float %20 %29 OpStore %gl_FragColor %30 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before, predefs + after, true, true); } TEST_F(LocalSingleStoreElimTest, NoOptIfStoreNotDominating) { // Single store to f not optimized because it does not dominate // the load. // // #version 140 // // in vec4 BaseColor; // in float fi; // // void main() // { // float f; // if (fi < 0) // f = 0.5; // if (fi < 0) // gl_FragColor = BaseColor * f; // else // gl_FragColor = BaseColor; // } const std::string assembly = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %fi %gl_FragColor %BaseColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %fi "fi" OpName %f "f" OpName %gl_FragColor "gl_FragColor" OpName %BaseColor "BaseColor" %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Input_float = OpTypePointer Input %float %fi = OpVariable %_ptr_Input_float Input %float_0 = OpConstant %float 0 %bool = OpTypeBool %_ptr_Function_float = OpTypePointer Function %float %float_0_5 = OpConstant %float 0.5 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %main = OpFunction %void None %8 %18 = OpLabel %f = OpVariable %_ptr_Function_float Function %19 = OpLoad %float %fi %20 = OpFOrdLessThan %bool %19 %float_0 OpSelectionMerge %21 None OpBranchConditional %20 %22 %21 %22 = OpLabel OpStore %f %float_0_5 OpBranch %21 %21 = OpLabel %23 = OpLoad %float %fi %24 = OpFOrdLessThan %bool %23 %float_0 OpSelectionMerge %25 None OpBranchConditional %24 %26 %27 %26 = OpLabel %28 = OpLoad %v4float %BaseColor %29 = OpLoad %float %f %30 = OpVectorTimesScalar %v4float %28 %29 OpStore %gl_FragColor %30 OpBranch %25 %27 = OpLabel %31 = OpLoad %v4float %BaseColor OpStore %gl_FragColor %31 OpBranch %25 %25 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(assembly, assembly, true, true); } TEST_F(LocalSingleStoreElimTest, OptInitializedVariableLikeStore) { // Initialized variable f is optimized like it was a store. // Note: The SPIR-V was edited to turn the store to f to an // an initialization. // // #version 140 // // void main() // { // float f = 0.0; // gl_FragColor = vec4(f); // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %f "f" OpName %gl_FragColor "gl_FragColor" OpDecorate %gl_FragColor Location 0 %void = OpTypeVoid %6 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output )"; const std::string before = R"(%main = OpFunction %void None %6 %12 = OpLabel %f = OpVariable %_ptr_Function_float Function %float_0 %13 = OpLoad %float %f %14 = OpCompositeConstruct %v4float %13 %13 %13 %13 OpStore %gl_FragColor %14 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %6 %12 = OpLabel %f = OpVariable %_ptr_Function_float Function %float_0 %14 = OpCompositeConstruct %v4float %float_0 %float_0 %float_0 %float_0 OpStore %gl_FragColor %14 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before, predefs + after, true, true); } TEST_F(LocalSingleStoreElimTest, PointerVariable) { // Test that checks if a pointer variable is removed. const std::string before = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" %2 OpExecutionMode %1 OriginUpperLeft OpMemberDecorate %_struct_3 0 Offset 0 OpDecorate %_runtimearr__struct_3 ArrayStride 16 OpMemberDecorate %_struct_5 0 Offset 0 OpDecorate %_struct_5 BufferBlock OpMemberDecorate %_struct_6 0 Offset 0 OpDecorate %_struct_6 BufferBlock OpDecorate %2 Location 0 OpDecorate %7 DescriptorSet 0 OpDecorate %7 Binding 0 %void = OpTypeVoid %10 = OpTypeFunction %void %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %_struct_3 = OpTypeStruct %v4float %_runtimearr__struct_3 = OpTypeRuntimeArray %_struct_3 %_struct_5 = OpTypeStruct %_runtimearr__struct_3 %_ptr_Uniform__struct_5 = OpTypePointer Uniform %_struct_5 %_struct_6 = OpTypeStruct %int %_ptr_Uniform__struct_6 = OpTypePointer Uniform %_struct_6 %_ptr_Function__ptr_Uniform__struct_5 = OpTypePointer Function %_ptr_Uniform__struct_5 %_ptr_Function__ptr_Uniform__struct_6 = OpTypePointer Function %_ptr_Uniform__struct_6 %int_0 = OpConstant %int 0 %uint_0 = OpConstant %uint 0 %2 = OpVariable %_ptr_Output_v4float Output %7 = OpVariable %_ptr_Uniform__struct_5 Uniform %1 = OpFunction %void None %10 %23 = OpLabel %24 = OpVariable %_ptr_Function__ptr_Uniform__struct_5 Function OpStore %24 %7 %26 = OpLoad %_ptr_Uniform__struct_5 %24 %27 = OpAccessChain %_ptr_Uniform_v4float %26 %int_0 %uint_0 %int_0 %28 = OpLoad %v4float %27 %29 = OpCopyObject %v4float %28 OpStore %2 %28 OpReturn OpFunctionEnd )"; const std::string after = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" %2 OpExecutionMode %1 OriginUpperLeft OpMemberDecorate %_struct_3 0 Offset 0 OpDecorate %_runtimearr__struct_3 ArrayStride 16 OpMemberDecorate %_struct_5 0 Offset 0 OpDecorate %_struct_5 BufferBlock OpMemberDecorate %_struct_6 0 Offset 0 OpDecorate %_struct_6 BufferBlock OpDecorate %2 Location 0 OpDecorate %7 DescriptorSet 0 OpDecorate %7 Binding 0 %void = OpTypeVoid %10 = OpTypeFunction %void %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %_struct_3 = OpTypeStruct %v4float %_runtimearr__struct_3 = OpTypeRuntimeArray %_struct_3 %_struct_5 = OpTypeStruct %_runtimearr__struct_3 %_ptr_Uniform__struct_5 = OpTypePointer Uniform %_struct_5 %_struct_6 = OpTypeStruct %int %_ptr_Uniform__struct_6 = OpTypePointer Uniform %_struct_6 %_ptr_Function__ptr_Uniform__struct_5 = OpTypePointer Function %_ptr_Uniform__struct_5 %_ptr_Function__ptr_Uniform__struct_6 = OpTypePointer Function %_ptr_Uniform__struct_6 %int_0 = OpConstant %int 0 %uint_0 = OpConstant %uint 0 %2 = OpVariable %_ptr_Output_v4float Output %7 = OpVariable %_ptr_Uniform__struct_5 Uniform %1 = OpFunction %void None %10 %23 = OpLabel %24 = OpVariable %_ptr_Function__ptr_Uniform__struct_5 Function OpStore %24 %7 %27 = OpAccessChain %_ptr_Uniform_v4float %7 %int_0 %uint_0 %int_0 %28 = OpLoad %v4float %27 %29 = OpCopyObject %v4float %28 OpStore %2 %28 OpReturn OpFunctionEnd )"; // Relax logical pointers to allow pointer allocations. SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); ValidatorOptions()->relax_logical_pointer = true; SinglePassRunAndCheck(before, after, true, true); } // Test that that an unused OpAccessChain between a store and a use does does // not hinders the replacement of the use. We need to check this because // local-access-chain-convert does always remove the OpAccessChain instructions // that become dead. TEST_F(LocalSingleStoreElimTest, StoreElimWithUnusedInterveningAccessChainLoad) { // Last load of v is eliminated, but access chain load and store of v isn't // // #version 140 // // in vec4 BaseColor; // // void main() // { // vec4 v = BaseColor; // float f = v[3]; // gl_FragColor = v * f; // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Function_float = OpTypePointer Function %float %uint = OpTypeInt 32 0 %uint_3 = OpConstant %uint 3 %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output )"; const std::string before = R"(%main = OpFunction %void None %8 %17 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %18 = OpLoad %v4float %BaseColor OpStore %v %18 %19 = OpAccessChain %_ptr_Function_float %v %uint_3 %21 = OpLoad %v4float %v OpStore %gl_FragColor %21 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %8 %17 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %18 = OpLoad %v4float %BaseColor OpStore %v %18 %19 = OpAccessChain %_ptr_Function_float %v %uint_3 OpStore %gl_FragColor %18 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(predefs + before, predefs + after, true, true); } TEST_F(LocalSingleStoreElimTest, VariablePointerTest) { // Check that the load of the first variable is still used and that the load // of the third variable is propagated. The first load has to remain because // of the store to the variable pointer. const std::string text = R"( ; CHECK: [[v1:%\w+]] = OpVariable ; CHECK: [[v2:%\w+]] = OpVariable ; CHECK: [[v3:%\w+]] = OpVariable ; CHECK: [[ld1:%\w+]] = OpLoad %int [[v1]] ; CHECK: OpIAdd %int [[ld1]] %int_0 OpCapability Shader OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" OpExecutionMode %2 LocalSize 1 1 1 OpSource GLSL 450 OpMemberDecorate %_struct_3 0 Offset 0 OpMemberDecorate %_struct_3 1 Offset 4 %void = OpTypeVoid %5 = OpTypeFunction %void %int = OpTypeInt 32 1 %bool = OpTypeBool %_struct_3 = OpTypeStruct %int %int %_ptr_Function__struct_3 = OpTypePointer Function %_struct_3 %_ptr_Function_int = OpTypePointer Function %int %true = OpConstantTrue %bool %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %13 = OpConstantNull %_struct_3 %2 = OpFunction %void None %5 %14 = OpLabel %15 = OpVariable %_ptr_Function_int Function %16 = OpVariable %_ptr_Function_int Function %17 = OpVariable %_ptr_Function_int Function OpStore %15 %int_1 OpStore %17 %int_0 OpSelectionMerge %18 None OpBranchConditional %true %19 %20 %19 = OpLabel OpBranch %18 %20 = OpLabel OpBranch %18 %18 = OpLabel %21 = OpPhi %_ptr_Function_int %15 %19 %16 %20 OpStore %21 %int_0 %22 = OpLoad %int %15 %23 = OpLoad %int %17 %24 = OpIAdd %int %22 %23 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(LocalSingleStoreElimTest, DebugDeclareTest) { // If OpenCL.DebugInfo.100 enabled, check that store/load is still // optimized, DebugValue placed after the store and the associated // DebugDeclare is removed. const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %MainPs "MainPs" %g_tColor %g_sAniso %in_var_TEXCOORD2 %out_var_SV_Target0 OpExecutionMode %MainPs OriginUpperLeft %20 = OpString "foo.frag" %24 = OpString "PS_OUTPUT" %28 = OpString "float" %31 = OpString "vColor" %33 = OpString "PS_INPUT" %38 = OpString "vTextureCoords" %40 = OpString "@type.2d.image" %41 = OpString "type.2d.image" %43 = OpString "Texture2D.TemplateParam" %47 = OpString "src.MainPs" %51 = OpString "tc" %53 = OpString "ps_output" %56 = OpString "i" %58 = OpString "@type.sampler" %59 = OpString "type.sampler" %61 = OpString "g_sAniso" %63 = OpString "g_tColor" OpName %type_2d_image "type.2d.image" OpName %g_tColor "g_tColor" OpName %type_sampler "type.sampler" OpName %g_sAniso "g_sAniso" OpName %in_var_TEXCOORD2 "in.var.TEXCOORD2" OpName %out_var_SV_Target0 "out.var.SV_Target0" OpName %MainPs "MainPs" OpName %PS_INPUT "PS_INPUT" OpMemberName %PS_INPUT 0 "vTextureCoords" OpName %param_var_i "param.var.i" OpName %PS_OUTPUT "PS_OUTPUT" OpMemberName %PS_OUTPUT 0 "vColor" OpName %type_sampled_image "type.sampled.image" OpDecorate %in_var_TEXCOORD2 Location 0 OpDecorate %out_var_SV_Target0 Location 0 OpDecorate %g_tColor DescriptorSet 0 OpDecorate %g_tColor Binding 0 OpDecorate %g_sAniso DescriptorSet 0 OpDecorate %g_sAniso Binding 1 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %float = OpTypeFloat 32 %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %type_sampler = OpTypeSampler %_ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %type_sampler %v2float = OpTypeVector %float 2 %_ptr_Input_v2float = OpTypePointer Input %v2float %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %uint_128 = OpConstant %uint 128 %uint_0 = OpConstant %uint 0 %uint_64 = OpConstant %uint 64 %65 = OpTypeFunction %void %PS_INPUT = OpTypeStruct %v2float %_ptr_Function_PS_INPUT = OpTypePointer Function %PS_INPUT %PS_OUTPUT = OpTypeStruct %v4float %75 = OpTypeFunction %PS_OUTPUT %_ptr_Function_PS_INPUT %_ptr_Function_PS_OUTPUT = OpTypePointer Function %PS_OUTPUT %_ptr_Function_v2float = OpTypePointer Function %v2float %type_sampled_image = OpTypeSampledImage %type_2d_image %_ptr_Function_v4float = OpTypePointer Function %v4float %g_tColor = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %g_sAniso = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %in_var_TEXCOORD2 = OpVariable %_ptr_Input_v2float Input %out_var_SV_Target0 = OpVariable %_ptr_Output_v4float Output %39 = OpExtInst %void %1 DebugInfoNone %55 = OpExtInst %void %1 DebugExpression %22 = OpExtInst %void %1 DebugSource %20 %23 = OpExtInst %void %1 DebugCompilationUnit 1 4 %22 HLSL %26 = OpExtInst %void %1 DebugTypeComposite %24 Structure %22 10 1 %23 %24 %uint_128 FlagIsProtected|FlagIsPrivate %27 %29 = OpExtInst %void %1 DebugTypeBasic %28 %uint_32 Float %30 = OpExtInst %void %1 DebugTypeVector %29 4 %27 = OpExtInst %void %1 DebugTypeMember %31 %30 %22 12 5 %26 %uint_0 %uint_128 FlagIsProtected|FlagIsPrivate %35 = OpExtInst %void %1 DebugTypeComposite %33 Structure %22 5 1 %23 %33 %uint_64 FlagIsProtected|FlagIsPrivate %36 %37 = OpExtInst %void %1 DebugTypeVector %29 2 %36 = OpExtInst %void %1 DebugTypeMember %38 %37 %22 7 5 %35 %uint_0 %uint_64 FlagIsProtected|FlagIsPrivate %42 = OpExtInst %void %1 DebugTypeComposite %40 Class %22 0 0 %23 %41 %39 FlagIsProtected|FlagIsPrivate %44 = OpExtInst %void %1 DebugTypeTemplateParameter %43 %29 %39 %22 0 0 %45 = OpExtInst %void %1 DebugTypeTemplate %42 %44 %46 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %26 %35 %48 = OpExtInst %void %1 DebugFunction %47 %46 %22 15 1 %23 %47 FlagIsProtected|FlagIsPrivate 16 %39 %50 = OpExtInst %void %1 DebugLexicalBlock %22 16 1 %48 %52 = OpExtInst %void %1 DebugLocalVariable %51 %37 %22 19 12 %50 FlagIsLocal %54 = OpExtInst %void %1 DebugLocalVariable %53 %26 %22 17 15 %50 FlagIsLocal %57 = OpExtInst %void %1 DebugLocalVariable %56 %35 %22 15 29 %48 FlagIsLocal 1 %60 = OpExtInst %void %1 DebugTypeComposite %58 Structure %22 0 0 %23 %59 %39 FlagIsProtected|FlagIsPrivate %62 = OpExtInst %void %1 DebugGlobalVariable %61 %60 %22 3 14 %23 %61 %g_sAniso FlagIsDefinition %64 = OpExtInst %void %1 DebugGlobalVariable %63 %42 %22 1 11 %23 %63 %g_tColor FlagIsDefinition %MainPs = OpFunction %void None %65 %66 = OpLabel %114 = OpExtInst %void %1 DebugScope %50 %98 = OpVariable %_ptr_Function_PS_OUTPUT Function %99 = OpVariable %_ptr_Function_v2float Function %115 = OpExtInst %void %1 DebugNoScope %100 = OpVariable %_ptr_Function_PS_OUTPUT Function %param_var_i = OpVariable %_ptr_Function_PS_INPUT Function %70 = OpLoad %v2float %in_var_TEXCOORD2 %71 = OpCompositeConstruct %PS_INPUT %70 OpStore %param_var_i %71 %116 = OpExtInst %void %1 DebugScope %48 %102 = OpExtInst %void %1 DebugDeclare %57 %param_var_i %55 %117 = OpExtInst %void %1 DebugScope %50 %103 = OpExtInst %void %1 DebugDeclare %54 %98 %55 OpLine %20 19 17 %104 = OpAccessChain %_ptr_Function_v2float %param_var_i %int_0 %105 = OpLoad %v2float %104 OpLine %20 19 12 OpStore %99 %105 %106 = OpExtInst %void %1 DebugDeclare %52 %99 %55 ;CHECK-NOT: %106 = OpExtInst %void %1 DebugDeclare %52 %99 %55 ;CHECK: %119 = OpExtInst %void %1 DebugValue %52 %105 %55 OpLine %20 20 26 %107 = OpLoad %type_2d_image %g_tColor OpLine %20 20 46 %108 = OpLoad %type_sampler %g_sAniso OpLine %20 20 57 %109 = OpLoad %v2float %99 ;CHECK-NOT: %109 = OpLoad %v2float %99 OpLine %20 20 26 %110 = OpSampledImage %type_sampled_image %107 %108 %111 = OpImageSampleImplicitLod %v4float %110 %109 None ;CHECK-NOT: %111 = OpImageSampleImplicitLod %v4float %110 %109 None ;CHECK: %111 = OpImageSampleImplicitLod %v4float %110 %105 None OpLine %20 20 5 %112 = OpAccessChain %_ptr_Function_v4float %98 %int_0 OpStore %112 %111 OpLine %20 21 12 %113 = OpLoad %PS_OUTPUT %98 OpLine %20 21 5 OpStore %100 %113 %118 = OpExtInst %void %1 DebugNoScope %73 = OpLoad %PS_OUTPUT %100 %74 = OpCompositeExtract %v4float %73 0 OpStore %out_var_SV_Target0 %74 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(text, false); } TEST_F(LocalSingleStoreElimTest, DebugValueTest) { // If OpenCL.DebugInfo.100 enabled, check that store/load is still // optimized, DebugValue placed after the store and the associated // DebugValue Deref is removed. const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %MainPs "MainPs" %g_tColor %g_sAniso %in_var_TEXCOORD2 %out_var_SV_Target0 OpExecutionMode %MainPs OriginUpperLeft %7 = OpString "foo.frag" %8 = OpString "PS_OUTPUT" %9 = OpString "float" %10 = OpString "vColor" %11 = OpString "PS_INPUT" %12 = OpString "vTextureCoords" %13 = OpString "@type.2d.image" %14 = OpString "type.2d.image" %15 = OpString "Texture2D.TemplateParam" %16 = OpString "src.MainPs" %17 = OpString "tc" %18 = OpString "ps_output" %19 = OpString "i" %20 = OpString "@type.sampler" %21 = OpString "type.sampler" %22 = OpString "g_sAniso" %23 = OpString "g_tColor" OpName %type_2d_image "type.2d.image" OpName %g_tColor "g_tColor" OpName %type_sampler "type.sampler" OpName %g_sAniso "g_sAniso" OpName %in_var_TEXCOORD2 "in.var.TEXCOORD2" OpName %out_var_SV_Target0 "out.var.SV_Target0" OpName %MainPs "MainPs" OpName %PS_INPUT "PS_INPUT" OpMemberName %PS_INPUT 0 "vTextureCoords" OpName %param_var_i "param.var.i" OpName %PS_OUTPUT "PS_OUTPUT" OpMemberName %PS_OUTPUT 0 "vColor" OpName %type_sampled_image "type.sampled.image" OpDecorate %in_var_TEXCOORD2 Location 0 OpDecorate %out_var_SV_Target0 Location 0 OpDecorate %g_tColor DescriptorSet 0 OpDecorate %g_tColor Binding 0 OpDecorate %g_sAniso DescriptorSet 0 OpDecorate %g_sAniso Binding 1 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %float = OpTypeFloat 32 %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %type_sampler = OpTypeSampler %_ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %type_sampler %v2float = OpTypeVector %float 2 %_ptr_Input_v2float = OpTypePointer Input %v2float %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %uint_128 = OpConstant %uint 128 %uint_0 = OpConstant %uint 0 %uint_64 = OpConstant %uint 64 %45 = OpTypeFunction %void %PS_INPUT = OpTypeStruct %v2float %_ptr_Function_PS_INPUT = OpTypePointer Function %PS_INPUT %PS_OUTPUT = OpTypeStruct %v4float %47 = OpTypeFunction %PS_OUTPUT %_ptr_Function_PS_INPUT %_ptr_Function_PS_OUTPUT = OpTypePointer Function %PS_OUTPUT %_ptr_Function_v2float = OpTypePointer Function %v2float %type_sampled_image = OpTypeSampledImage %type_2d_image %_ptr_Function_v4float = OpTypePointer Function %v4float %g_tColor = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %g_sAniso = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %in_var_TEXCOORD2 = OpVariable %_ptr_Input_v2float Input %out_var_SV_Target0 = OpVariable %_ptr_Output_v4float Output %51 = OpExtInst %void %1 DebugInfoNone %52 = OpExtInst %void %1 DebugExpression %53 = OpExtInst %void %1 DebugOperation Deref %54 = OpExtInst %void %1 DebugExpression %53 %55 = OpExtInst %void %1 DebugSource %7 %56 = OpExtInst %void %1 DebugCompilationUnit 1 4 %55 HLSL %57 = OpExtInst %void %1 DebugTypeComposite %8 Structure %55 10 1 %56 %8 %uint_128 FlagIsProtected|FlagIsPrivate %58 %59 = OpExtInst %void %1 DebugTypeBasic %9 %uint_32 Float %60 = OpExtInst %void %1 DebugTypeVector %59 4 %58 = OpExtInst %void %1 DebugTypeMember %10 %60 %55 12 5 %57 %uint_0 %uint_128 FlagIsProtected|FlagIsPrivate %61 = OpExtInst %void %1 DebugTypeComposite %11 Structure %55 5 1 %56 %11 %uint_64 FlagIsProtected|FlagIsPrivate %62 %63 = OpExtInst %void %1 DebugTypeVector %59 2 %62 = OpExtInst %void %1 DebugTypeMember %12 %63 %55 7 5 %61 %uint_0 %uint_64 FlagIsProtected|FlagIsPrivate %64 = OpExtInst %void %1 DebugTypeComposite %13 Class %55 0 0 %56 %14 %51 FlagIsProtected|FlagIsPrivate %65 = OpExtInst %void %1 DebugTypeTemplateParameter %15 %59 %51 %55 0 0 %66 = OpExtInst %void %1 DebugTypeTemplate %64 %65 %67 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %57 %61 %68 = OpExtInst %void %1 DebugFunction %16 %67 %55 15 1 %56 %16 FlagIsProtected|FlagIsPrivate 16 %51 %69 = OpExtInst %void %1 DebugLexicalBlock %55 16 1 %68 %70 = OpExtInst %void %1 DebugLocalVariable %17 %63 %55 19 12 %69 FlagIsLocal %71 = OpExtInst %void %1 DebugLocalVariable %18 %57 %55 17 15 %69 FlagIsLocal %72 = OpExtInst %void %1 DebugLocalVariable %19 %61 %55 15 29 %68 FlagIsLocal 1 %73 = OpExtInst %void %1 DebugTypeComposite %20 Structure %55 0 0 %56 %21 %51 FlagIsProtected|FlagIsPrivate %74 = OpExtInst %void %1 DebugGlobalVariable %22 %73 %55 3 14 %56 %22 %g_sAniso FlagIsDefinition %75 = OpExtInst %void %1 DebugGlobalVariable %23 %64 %55 1 11 %56 %23 %g_tColor FlagIsDefinition %MainPs = OpFunction %void None %45 %76 = OpLabel %101 = OpExtInst %void %1 DebugScope %69 %78 = OpVariable %_ptr_Function_PS_OUTPUT Function %79 = OpVariable %_ptr_Function_v2float Function %102 = OpExtInst %void %1 DebugNoScope %81 = OpVariable %_ptr_Function_PS_OUTPUT Function %param_var_i = OpVariable %_ptr_Function_PS_INPUT Function %82 = OpLoad %v2float %in_var_TEXCOORD2 %83 = OpCompositeConstruct %PS_INPUT %82 OpStore %param_var_i %83 %103 = OpExtInst %void %1 DebugScope %68 %85 = OpExtInst %void %1 DebugDeclare %72 %param_var_i %52 %104 = OpExtInst %void %1 DebugScope %69 %87 = OpExtInst %void %1 DebugDeclare %71 %78 %52 OpLine %7 19 17 %88 = OpAccessChain %_ptr_Function_v2float %param_var_i %int_0 %89 = OpLoad %v2float %88 OpLine %7 19 12 OpStore %79 %89 %90 = OpExtInst %void %1 DebugValue %70 %79 %54 ;CHECK-NOT: %90 = OpExtInst %void %1 DebugValue %70 %79 %54 ;CHECK: %106 = OpExtInst %void %1 DebugValue %70 %89 %52 OpLine %7 20 26 %91 = OpLoad %type_2d_image %g_tColor OpLine %7 20 46 %92 = OpLoad %type_sampler %g_sAniso OpLine %7 20 57 %93 = OpLoad %v2float %79 ;CHECK-NOT: %93 = OpLoad %v2float %79 OpLine %7 20 26 %94 = OpSampledImage %type_sampled_image %91 %92 %95 = OpImageSampleImplicitLod %v4float %94 %93 None ;CHECK-NOT: %95 = OpImageSampleImplicitLod %v4float %94 %93 None ;CHECK: %95 = OpImageSampleImplicitLod %v4float %94 %89 None OpLine %7 20 5 %96 = OpAccessChain %_ptr_Function_v4float %78 %int_0 OpStore %96 %95 OpLine %7 21 12 %97 = OpLoad %PS_OUTPUT %78 OpLine %7 21 5 OpStore %81 %97 %105 = OpExtInst %void %1 DebugNoScope %99 = OpLoad %PS_OUTPUT %81 %100 = OpCompositeExtract %v4float %99 0 OpStore %out_var_SV_Target0 %100 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(text, false); } TEST_F(LocalSingleStoreElimTest, UseStoreLineInfoForDebugValueLine) { // When the store is in the scope of OpenCL.DebugInfo.100 DebugDeclare, // the OpLine of the added OpenCL.DebugInfo.100 DebugValue must be the // same with the OpLine of the store. const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %in_var_POSITION %in_var_COLOR %gl_Position %out_var_COLOR %7 = OpString "simple.hlsl" %8 = OpString "float" %9 = OpString "VS_OUTPUT" %10 = OpString "color" %11 = OpString "pos" %12 = OpString "main" %13 = OpString "" %14 = OpString "vout" OpName %in_var_POSITION "in.var.POSITION" OpName %in_var_COLOR "in.var.COLOR" OpName %out_var_COLOR "out.var.COLOR" OpName %main "main" OpName %VS_OUTPUT "VS_OUTPUT" OpMemberName %VS_OUTPUT 0 "pos" OpMemberName %VS_OUTPUT 1 "color" OpDecorate %gl_Position BuiltIn Position OpDecorate %in_var_POSITION Location 0 OpDecorate %in_var_COLOR Location 1 OpDecorate %out_var_COLOR Location 0 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %uint_256 = OpConstant %uint 256 %uint_128 = OpConstant %uint 128 %uint_0 = OpConstant %uint 0 %36 = OpTypeFunction %void %_ptr_Function_v4float = OpTypePointer Function %v4float %VS_OUTPUT = OpTypeStruct %v4float %v4float %_ptr_Function_VS_OUTPUT = OpTypePointer Function %VS_OUTPUT %in_var_POSITION = OpVariable %_ptr_Input_v4float Input %in_var_COLOR = OpVariable %_ptr_Input_v4float Input %gl_Position = OpVariable %_ptr_Output_v4float Output %out_var_COLOR = OpVariable %_ptr_Output_v4float Output %85 = OpExtInst %void %1 DebugOperation Deref %81 = OpExtInst %void %1 DebugInfoNone %52 = OpExtInst %void %1 DebugExpression %40 = OpExtInst %void %1 DebugTypeBasic %8 %uint_32 Float %41 = OpExtInst %void %1 DebugTypeVector %40 4 %42 = OpExtInst %void %1 DebugSource %7 %43 = OpExtInst %void %1 DebugCompilationUnit 1 4 %42 HLSL %44 = OpExtInst %void %1 DebugTypeComposite %9 Structure %42 1 8 %43 %9 %uint_256 FlagIsProtected|FlagIsPrivate %45 %46 %46 = OpExtInst %void %1 DebugTypeMember %10 %41 %42 3 10 %44 %uint_128 %uint_128 FlagIsProtected|FlagIsPrivate %45 = OpExtInst %void %1 DebugTypeMember %11 %41 %42 2 10 %44 %uint_0 %uint_128 FlagIsProtected|FlagIsPrivate %47 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %44 %41 %41 %48 = OpExtInst %void %1 DebugFunction %12 %47 %42 6 1 %43 %13 FlagIsProtected|FlagIsPrivate 7 %81 %49 = OpExtInst %void %1 DebugLexicalBlock %42 7 38 %48 %50 = OpExtInst %void %1 DebugLocalVariable %14 %44 %42 8 13 %49 FlagIsLocal %84 = OpExtInst %void %1 DebugExpression %85 %main = OpFunction %void None %36 %54 = OpLabel %91 = OpExtInst %void %1 DebugScope %49 OpLine %7 7 23 %83 = OpVariable %_ptr_Function_v4float Function OpLine %7 8 13 %87 = OpExtInst %void %1 DebugValue %50 %83 %84 %int_1 OpLine %7 7 23 %82 = OpVariable %_ptr_Function_v4float Function OpLine %7 8 13 %86 = OpExtInst %void %1 DebugValue %50 %82 %84 %int_0 OpNoLine %92 = OpExtInst %void %1 DebugNoScope %55 = OpLoad %v4float %in_var_POSITION %56 = OpLoad %v4float %in_var_COLOR ;CHECK: [[pos:%\w+]] = OpLoad %v4float %in_var_POSITION ;CHECK: [[color:%\w+]] = OpLoad %v4float %in_var_COLOR %94 = OpExtInst %void %1 DebugScope %49 OpLine %7 9 3 OpStore %82 %55 ;CHECK: OpLine [[file:%\w+]] 9 3 ;CHECK: OpStore {{%\w+}} [[pos]] ;CHECK: {{%\w+}} = OpExtInst %void {{%\w+}} DebugValue [[vout:%\w+]] [[pos]] [[empty_expr:%\w+]] %int_0 ;CHECK: OpLine [[file]] 10 3 ;CHECK: OpStore {{%\w+}} [[color]] ;CHECK: {{%\w+}} = OpExtInst %void {{%\w+}} DebugValue [[vout]] [[color]] [[empty_expr]] %int_1 OpLine %7 10 3 OpStore %83 %56 OpLine %7 11 10 %90 = OpCompositeConstruct %VS_OUTPUT %55 %56 OpNoLine %95 = OpExtInst %void %1 DebugNoScope %58 = OpCompositeExtract %v4float %90 0 OpStore %gl_Position %58 %59 = OpCompositeExtract %v4float %90 1 OpStore %out_var_COLOR %59 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(text, false); } TEST_F(LocalSingleStoreElimTest, AddDebugValueforStoreOutOfDebugDeclareScope) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %in_var_POSITION %in_var_COLOR %gl_Position %out_var_COLOR %7 = OpString "simple.hlsl" %8 = OpString "float" %9 = OpString "VS_OUTPUT" %10 = OpString "color" %11 = OpString "pos" %12 = OpString "main" %13 = OpString "" %14 = OpString "vout" OpName %in_var_POSITION "in.var.POSITION" OpName %in_var_COLOR "in.var.COLOR" OpName %out_var_COLOR "out.var.COLOR" OpName %main "main" OpName %VS_OUTPUT "VS_OUTPUT" OpMemberName %VS_OUTPUT 0 "pos" OpMemberName %VS_OUTPUT 1 "color" OpDecorate %gl_Position BuiltIn Position OpDecorate %in_var_POSITION Location 0 OpDecorate %in_var_COLOR Location 1 OpDecorate %out_var_COLOR Location 0 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %uint_256 = OpConstant %uint 256 %uint_128 = OpConstant %uint 128 %uint_0 = OpConstant %uint 0 %36 = OpTypeFunction %void %_ptr_Function_v4float = OpTypePointer Function %v4float %VS_OUTPUT = OpTypeStruct %v4float %v4float %_ptr_Function_VS_OUTPUT = OpTypePointer Function %VS_OUTPUT %in_var_POSITION = OpVariable %_ptr_Input_v4float Input %in_var_COLOR = OpVariable %_ptr_Input_v4float Input %gl_Position = OpVariable %_ptr_Output_v4float Output %out_var_COLOR = OpVariable %_ptr_Output_v4float Output %85 = OpExtInst %void %1 DebugOperation Deref %81 = OpExtInst %void %1 DebugInfoNone %52 = OpExtInst %void %1 DebugExpression %40 = OpExtInst %void %1 DebugTypeBasic %8 %uint_32 Float %41 = OpExtInst %void %1 DebugTypeVector %40 4 %42 = OpExtInst %void %1 DebugSource %7 %43 = OpExtInst %void %1 DebugCompilationUnit 1 4 %42 HLSL %44 = OpExtInst %void %1 DebugTypeComposite %9 Structure %42 1 8 %43 %9 %uint_256 FlagIsProtected|FlagIsPrivate %45 %46 %46 = OpExtInst %void %1 DebugTypeMember %10 %41 %42 3 10 %44 %uint_128 %uint_128 FlagIsProtected|FlagIsPrivate %45 = OpExtInst %void %1 DebugTypeMember %11 %41 %42 2 10 %44 %uint_0 %uint_128 FlagIsProtected|FlagIsPrivate %47 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %44 %41 %41 %48 = OpExtInst %void %1 DebugFunction %12 %47 %42 6 1 %43 %13 FlagIsProtected|FlagIsPrivate 7 %81 %49 = OpExtInst %void %1 DebugLexicalBlock %42 7 38 %48 %50 = OpExtInst %void %1 DebugLocalVariable %14 %44 %42 8 13 %49 FlagIsLocal %51 = OpExtInst %void %1 DebugLocalVariable %10 %41 %42 7 23 %48 FlagIsLocal 2 %53 = OpExtInst %void %1 DebugLocalVariable %11 %41 %42 6 23 %48 FlagIsLocal 1 ;CHECK: [[dbg_color:%\w+]] = OpExtInst %void {{%\w+}} DebugLocalVariable {{%\w+}} {{%\w+}} {{%\w+}} 7 23 {{%\w+}} FlagIsLocal 2 ;CHECK: [[dbg_pos:%\w+]] = OpExtInst %void {{%\w+}} DebugLocalVariable {{%\w+}} {{%\w+}} {{%\w+}} 6 23 {{%\w+}} FlagIsLocal 1 %84 = OpExtInst %void %1 DebugExpression %85 %main = OpFunction %void None %36 %54 = OpLabel %91 = OpExtInst %void %1 DebugScope %49 OpLine %7 7 23 %83 = OpVariable %_ptr_Function_v4float Function OpLine %7 8 13 %87 = OpExtInst %void %1 DebugValue %50 %83 %84 %int_1 OpLine %7 7 23 %82 = OpVariable %_ptr_Function_v4float Function OpLine %7 8 13 %86 = OpExtInst %void %1 DebugValue %50 %82 %84 %int_0 OpNoLine %92 = OpExtInst %void %1 DebugNoScope %param_var_pos = OpVariable %_ptr_Function_v4float Function %param_var_color = OpVariable %_ptr_Function_v4float Function %55 = OpLoad %v4float %in_var_POSITION OpLine %7 6 23 OpStore %param_var_pos %55 OpNoLine %56 = OpLoad %v4float %in_var_COLOR ;CHECK: DebugNoScope ;CHECK-NOT: OpLine OpLine %7 7 23 OpStore %param_var_color %56 OpNoLine %93 = OpExtInst %void %1 DebugScope %48 %73 = OpExtInst %void %1 DebugDeclare %53 %param_var_pos %52 %74 = OpExtInst %void %1 DebugDeclare %51 %param_var_color %52 ;CHECK: [[pos:%\w+]] = OpLoad %v4float %in_var_POSITION ;CHECK: OpLine [[file:%\w+]] 6 23 ;CHECK: {{%\w+}} = OpExtInst %void {{%\w+}} DebugValue [[dbg_pos]] [[pos]] [[empty_expr:%\w+]] ;CHECK: [[color:%\w+]] = OpLoad %v4float %in_var_COLOR ;CHECK: OpLine [[file]] 7 23 ;CHECK: {{%\w+}} = OpExtInst %void {{%\w+}} DebugValue [[dbg_color]] [[color]] [[empty_expr]] ;CHECK: OpLine [[file]] 9 3 %94 = OpExtInst %void %1 DebugScope %49 OpLine %7 9 3 OpStore %82 %55 OpLine %7 10 3 OpStore %83 %56 OpLine %7 11 10 %90 = OpCompositeConstruct %VS_OUTPUT %55 %56 OpNoLine %95 = OpExtInst %void %1 DebugNoScope %58 = OpCompositeExtract %v4float %90 0 OpStore %gl_Position %58 %59 = OpCompositeExtract %v4float %90 1 OpStore %out_var_COLOR %59 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(text, false); } TEST_F(LocalSingleStoreElimTest, DebugValuesForAllLocalsAndParams) { // Texture2D g_tColor; // // SamplerState g_sAniso; // // struct PS_INPUT // { // float2 vTextureCoords : TEXCOORD2 ; // } ; // // struct PS_OUTPUT // { // float4 vColor : SV_Target0 ; // } ; // // void do_sample ( in float2 tc, out float4 c ) { // c = g_tColor . Sample ( g_sAniso , tc ) ; // } // // PS_OUTPUT MainPs ( PS_INPUT i ) // { // PS_OUTPUT ps_output ; // float4 color; // // do_sample ( i . vTextureCoords . xy , color ) ; // ps_output . vColor = color; // return ps_output ; // } const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" ;CHECK: [[set:%\w+]] = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %MainPs "MainPs" %in_var_TEXCOORD2 %out_var_SV_Target0 %g_tColor %g_sAniso OpExecutionMode %MainPs OriginUpperLeft %7 = OpString "foo2.frag" %21 = OpString "float" %27 = OpString "PS_INPUT" %31 = OpString "vTextureCoords" %34 = OpString "PS_OUTPUT" %38 = OpString "vColor" %40 = OpString "do_sample" %41 = OpString "" %45 = OpString "c" %47 = OpString "tc" %50 = OpString "MainPs" %54 = OpString "color" %56 = OpString "ps_output" %59 = OpString "i" %62 = OpString "@type.sampler" %63 = OpString "type.sampler" %65 = OpString "g_sAniso" %67 = OpString "@type.2d.image" %68 = OpString "type.2d.image" %70 = OpString "TemplateParam" %73 = OpString "g_tColor" ;CHECK: [[str_c:%\w+]] = OpString "c" ;CHECK: [[str_tc:%\w+]] = OpString "tc" ;CHECK: [[str_color:%\w+]] = OpString "color" ;CHECK: [[str_ps_output:%\w+]] = OpString "ps_output" ;CHECK: [[str_i:%\w+]] = OpString "i" OpName %type_2d_image "type.2d.image" OpName %g_tColor "g_tColor" OpName %type_sampler "type.sampler" OpName %g_sAniso "g_sAniso" OpName %in_var_TEXCOORD2 "in.var.TEXCOORD2" OpName %out_var_SV_Target0 "out.var.SV_Target0" OpName %MainPs "MainPs" OpName %PS_INPUT "PS_INPUT" OpMemberName %PS_INPUT 0 "vTextureCoords" OpName %PS_OUTPUT "PS_OUTPUT" OpMemberName %PS_OUTPUT 0 "vColor" OpName %type_sampled_image "type.sampled.image" OpDecorate %in_var_TEXCOORD2 Location 0 OpDecorate %out_var_SV_Target0 Location 0 OpDecorate %g_tColor DescriptorSet 0 OpDecorate %g_tColor Binding 0 OpDecorate %g_sAniso DescriptorSet 0 OpDecorate %g_sAniso Binding 1 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %float = OpTypeFloat 32 %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %type_sampler = OpTypeSampler %_ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %type_sampler %v2float = OpTypeVector %float 2 %_ptr_Input_v2float = OpTypePointer Input %v2float %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %uint_64 = OpConstant %uint 64 %uint_0 = OpConstant %uint 0 %uint_128 = OpConstant %uint 128 %75 = OpTypeFunction %void %PS_INPUT = OpTypeStruct %v2float %_ptr_Function_PS_INPUT = OpTypePointer Function %PS_INPUT %PS_OUTPUT = OpTypeStruct %v4float %85 = OpTypeFunction %PS_OUTPUT %_ptr_Function_PS_INPUT %_ptr_Function_PS_OUTPUT = OpTypePointer Function %PS_OUTPUT %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Function_v2float = OpTypePointer Function %v2float %105 = OpTypeFunction %void %_ptr_Function_v2float %_ptr_Function_v4float %type_sampled_image = OpTypeSampledImage %type_2d_image %g_tColor = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %g_sAniso = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %in_var_TEXCOORD2 = OpVariable %_ptr_Input_v2float Input %out_var_SV_Target0 = OpVariable %_ptr_Output_v4float Output %145 = OpExtInst %void %1 DebugOperation Deref %61 = OpExtInst %void %1 DebugInfoNone %58 = OpExtInst %void %1 DebugExpression %23 = OpExtInst %void %1 DebugTypeBasic %21 %uint_32 Float %24 = OpExtInst %void %1 DebugTypeVector %23 2 %25 = OpExtInst %void %1 DebugSource %7 %26 = OpExtInst %void %1 DebugCompilationUnit 1 4 %25 HLSL %29 = OpExtInst %void %1 DebugTypeComposite %27 Structure %25 5 8 %26 %27 %uint_64 FlagIsProtected|FlagIsPrivate %30 %30 = OpExtInst %void %1 DebugTypeMember %31 %24 %25 7 12 %29 %uint_0 %uint_64 FlagIsProtected|FlagIsPrivate %33 = OpExtInst %void %1 DebugTypeVector %23 4 %36 = OpExtInst %void %1 DebugTypeComposite %34 Structure %25 10 8 %26 %34 %uint_128 FlagIsProtected|FlagIsPrivate %37 %37 = OpExtInst %void %1 DebugTypeMember %38 %33 %25 12 12 %36 %uint_0 %uint_128 FlagIsProtected|FlagIsPrivate %39 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %void %24 %33 %42 = OpExtInst %void %1 DebugFunction %40 %39 %25 15 1 %26 %41 FlagIsProtected|FlagIsPrivate 15 %61 %44 = OpExtInst %void %1 DebugLexicalBlock %25 15 47 %42 %46 = OpExtInst %void %1 DebugLocalVariable %45 %33 %25 15 43 %42 FlagIsLocal 2 %48 = OpExtInst %void %1 DebugLocalVariable %47 %24 %25 15 28 %42 FlagIsLocal 1 %49 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %36 %29 %51 = OpExtInst %void %1 DebugFunction %50 %49 %25 19 1 %26 %41 FlagIsProtected|FlagIsPrivate 20 %61 %53 = OpExtInst %void %1 DebugLexicalBlock %25 20 1 %51 %55 = OpExtInst %void %1 DebugLocalVariable %54 %33 %25 22 12 %53 FlagIsLocal %57 = OpExtInst %void %1 DebugLocalVariable %56 %36 %25 21 15 %53 FlagIsLocal %60 = OpExtInst %void %1 DebugLocalVariable %59 %29 %25 19 29 %51 FlagIsLocal 1 %64 = OpExtInst %void %1 DebugTypeComposite %62 Structure %25 0 0 %26 %63 %61 FlagIsProtected|FlagIsPrivate %66 = OpExtInst %void %1 DebugGlobalVariable %65 %64 %25 3 14 %26 %65 %g_sAniso FlagIsDefinition %69 = OpExtInst %void %1 DebugTypeComposite %67 Class %25 0 0 %26 %68 %61 FlagIsProtected|FlagIsPrivate %71 = OpExtInst %void %1 DebugTypeTemplateParameter %70 %33 %61 %25 0 0 %72 = OpExtInst %void %1 DebugTypeTemplate %69 %71 %74 = OpExtInst %void %1 DebugGlobalVariable %73 %72 %25 1 11 %26 %73 %g_tColor FlagIsDefinition %142 = OpExtInst %void %1 DebugInlinedAt 24 %53 %144 = OpExtInst %void %1 DebugExpression %145 %155 = OpExtInst %void %1 DebugExpression %145 ;CHECK: [[var_c:%\w+]] = OpExtInst %void [[set]] DebugLocalVariable [[str_c]] ;CHECK: [[var_tc:%\w+]] = OpExtInst %void [[set]] DebugLocalVariable [[str_tc]] ;CHECK: [[var_color:%\w+]] = OpExtInst %void [[set]] DebugLocalVariable [[str_color]] ;CHECK: [[var_ps_output:%\w+]] = OpExtInst %void [[set]] DebugLocalVariable [[str_ps_output]] ;CHECK: [[var_i:%\w+]] = OpExtInst %void [[set]] DebugLocalVariable [[str_i]] %MainPs = OpFunction %void None %75 %76 = OpLabel %153 = OpVariable %_ptr_Function_v2float Function %149 = OpVariable %_ptr_Function_v4float Function %157 = OpExtInst %void %1 DebugScope %53 %143 = OpVariable %_ptr_Function_v4float Function %121 = OpVariable %_ptr_Function_v4float Function %122 = OpVariable %_ptr_Function_v2float Function %158 = OpExtInst %void %1 DebugScope %51 OpLine %7 19 29 %156 = OpExtInst %void %1 DebugValue %60 %153 %155 %int_0 %159 = OpExtInst %void %1 DebugScope %53 OpLine %7 21 15 %146 = OpExtInst %void %1 DebugValue %57 %143 %144 %int_0 OpNoLine %160 = OpExtInst %void %1 DebugNoScope %80 = OpLoad %v2float %in_var_TEXCOORD2 %81 = OpCompositeConstruct %PS_INPUT %80 %154 = OpCompositeExtract %v2float %81 0 OpStore %153 %154 %161 = OpExtInst %void %1 DebugScope %53 OpLine %7 22 12 %127 = OpExtInst %void %1 DebugDeclare %55 %121 %58 OpLine %7 24 17 %129 = OpLoad %v2float %153 OpStore %122 %129 %162 = OpExtInst %void %1 DebugScope %42 %142 OpLine %7 15 28 %135 = OpExtInst %void %1 DebugDeclare %48 %122 %58 OpLine %7 15 43 %136 = OpExtInst %void %1 DebugDeclare %46 %121 %58 %163 = OpExtInst %void %1 DebugScope %44 %142 OpLine %7 16 9 %137 = OpLoad %type_2d_image %g_tColor OpLine %7 16 29 %138 = OpLoad %type_sampler %g_sAniso OpLine %7 16 40 %139 = OpLoad %v2float %122 OpLine %7 16 9 %140 = OpSampledImage %type_sampled_image %137 %138 %141 = OpImageSampleImplicitLod %v4float %140 %139 None OpLine %7 16 5 OpStore %121 %141 %164 = OpExtInst %void %1 DebugScope %53 OpLine %7 25 26 %131 = OpLoad %v4float %121 OpLine %7 25 5 OpStore %143 %131 OpLine %7 26 12 %147 = OpLoad %v4float %143 %148 = OpCompositeConstruct %PS_OUTPUT %147 OpLine %7 26 5 %150 = OpCompositeExtract %v4float %148 0 OpStore %149 %150 OpNoLine %165 = OpExtInst %void %1 DebugNoScope %151 = OpLoad %v4float %149 %152 = OpCompositeConstruct %PS_OUTPUT %151 %84 = OpCompositeExtract %v4float %152 0 OpStore %out_var_SV_Target0 %84 OpLine %7 27 1 OpReturn OpFunctionEnd ;CHECK: {{%\w+}} = OpExtInst %void [[set]] DebugValue [[var_i]] ;CHECK: {{%\w+}} = OpExtInst %void [[set]] DebugValue [[var_tc]] ;CHECK: {{%\w+}} = OpExtInst %void [[set]] DebugValue [[var_c]] ;CHECK: {{%\w+}} = OpExtInst %void [[set]] DebugValue [[var_color]] ;CHECK: {{%\w+}} = OpExtInst %void [[set]] DebugValue [[var_ps_output]] )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(text, false); } TEST_F(LocalSingleStoreElimTest, VkMemoryModelTest) { const std::string text = R"( ; CHECK: OpCapability Shader ; CHECK: OpCapability VulkanMemoryModel ; CHECK: OpExtension "SPV_KHR_vulkan_memory_model" OpCapability Shader OpCapability VulkanMemoryModel OpExtension "SPV_KHR_vulkan_memory_model" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical Vulkan OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %bool = OpTypeBool %false = OpConstantFalse %bool ; CHECK: OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: [[a:%\w+]] = OpVariable ; CHECK-NEXT: [[b:%\w+]] = OpVariable ; CHECK: OpStore [[a]] [[v:%\w+]] ; CHECK: OpStore [[b]] ; Make sure the load was removed. ; CHECK: OpLabel ; CHECK-NOT: OpLoad %int [[a]] ; CHECK: OpStore [[b]] [[v]] %main = OpFunction %void None %3 %5 = OpLabel %a = OpVariable %_ptr_Function_int Function %b = OpVariable %_ptr_Function_int Function OpStore %a %int_0 OpStore %b %int_1 OpSelectionMerge %15 None OpBranchConditional %false %14 %15 %14 = OpLabel %16 = OpLoad %int %a OpStore %b %16 OpBranch %15 %15 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } // TODO(greg-lunarg): Add tests to verify handling of these cases: // // Other types // Others? } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/local_ssa_elim_test.cpp000066400000000000000000006101331475742701700250270ustar00rootroot00000000000000// Copyright (c) 2017 Valve Corporation // Copyright (c) 2017 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using LocalSSAElimTest = PassTest<::testing::Test>; TEST_F(LocalSSAElimTest, ForLoop) { // #version 140 // // in vec4 BC; // out float fo; // // void main() // { // float f = 0.0; // for (int i=0; i<4; i++) { // f = f + BC[i]; // } // fo = f; // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BC %fo OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %f "f" OpName %i "i" OpName %BC "BC" OpName %fo "fo" %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_4 = OpConstant %int 4 %bool = OpTypeBool %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %BC = OpVariable %_ptr_Input_v4float Input %_ptr_Input_float = OpTypePointer Input %float %int_1 = OpConstant %int 1 %_ptr_Output_float = OpTypePointer Output %float %fo = OpVariable %_ptr_Output_float Output )"; const std::string before = R"(%main = OpFunction %void None %8 %22 = OpLabel %f = OpVariable %_ptr_Function_float Function %i = OpVariable %_ptr_Function_int Function OpStore %f %float_0 OpStore %i %int_0 OpBranch %23 %23 = OpLabel OpLoopMerge %24 %25 None OpBranch %26 %26 = OpLabel %27 = OpLoad %int %i %28 = OpSLessThan %bool %27 %int_4 OpBranchConditional %28 %29 %24 %29 = OpLabel %30 = OpLoad %float %f %31 = OpLoad %int %i %32 = OpAccessChain %_ptr_Input_float %BC %31 %33 = OpLoad %float %32 %34 = OpFAdd %float %30 %33 OpStore %f %34 OpBranch %25 %25 = OpLabel %35 = OpLoad %int %i %36 = OpIAdd %int %35 %int_1 OpStore %i %36 OpBranch %23 %24 = OpLabel %37 = OpLoad %float %f OpStore %fo %37 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %8 %22 = OpLabel %f = OpVariable %_ptr_Function_float Function %i = OpVariable %_ptr_Function_int Function OpStore %f %float_0 OpStore %i %int_0 OpBranch %23 %23 = OpLabel %39 = OpPhi %float %float_0 %22 %34 %25 %38 = OpPhi %int %int_0 %22 %36 %25 OpLoopMerge %24 %25 None OpBranch %26 %26 = OpLabel %28 = OpSLessThan %bool %38 %int_4 OpBranchConditional %28 %29 %24 %29 = OpLabel %32 = OpAccessChain %_ptr_Input_float %BC %38 %33 = OpLoad %float %32 %34 = OpFAdd %float %39 %33 OpStore %f %34 OpBranch %25 %25 = OpLabel %36 = OpIAdd %int %38 %int_1 OpStore %i %36 OpBranch %23 %24 = OpLabel OpStore %fo %39 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before, predefs + after, true, true); } TEST_F(LocalSSAElimTest, NestedForLoop) { // #version 450 // // layout (location=0) in mat4 BC; // layout (location=0) out float fo; // // void main() // { // float f = 0.0; // for (int i=0; i<4; i++) // for (int j=0; j<4; j++) // f = f + BC[i][j]; // fo = f; // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BC %fo OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %f "f" OpName %i "i" OpName %j "j" OpName %BC "BC" OpName %fo "fo" OpDecorate %BC Location 0 OpDecorate %fo Location 0 %void = OpTypeVoid %9 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_4 = OpConstant %int 4 %bool = OpTypeBool %v4float = OpTypeVector %float 4 %mat4v4float = OpTypeMatrix %v4float 4 %_ptr_Input_mat4v4float = OpTypePointer Input %mat4v4float %BC = OpVariable %_ptr_Input_mat4v4float Input %_ptr_Input_float = OpTypePointer Input %float %int_1 = OpConstant %int 1 %_ptr_Output_float = OpTypePointer Output %float %fo = OpVariable %_ptr_Output_float Output )"; const std::string before = R"( ; CHECK: = OpFunction ; CHECK-NEXT: [[entry:%\w+]] = OpLabel ; CHECK: [[outer_header:%\w+]] = OpLabel ; CHECK-NEXT: [[outer_f:%\w+]] = OpPhi %float %float_0 [[entry]] [[inner_f:%\w+]] [[outer_be:%\w+]] ; CHECK-NEXT: [[i:%\w+]] = OpPhi %int %int_0 [[entry]] [[i_next:%\w+]] [[outer_be]] ; CHECK-NEXT: OpSLessThan {{%\w+}} [[i]] ; CHECK: [[inner_pre_header:%\w+]] = OpLabel ; CHECK: [[inner_header:%\w+]] = OpLabel ; CHECK-NEXT: [[inner_f]] = OpPhi %float [[outer_f]] [[inner_pre_header]] [[f_next:%\w+]] [[inner_be:%\w+]] ; CHECK-NEXT: [[j:%\w+]] = OpPhi %int %int_0 [[inner_pre_header]] [[j_next:%\w+]] [[inner_be]] ; CHECK: [[inner_be]] = OpLabel ; CHECK: [[f_next]] = OpFAdd %float [[inner_f]] ; CHECK: [[j_next]] = OpIAdd %int [[j]] %int_1 ; CHECK: [[outer_be]] = OpLabel ; CHECK: [[i_next]] = OpIAdd ; CHECK: OpStore %fo [[outer_f]] %main = OpFunction %void None %9 %24 = OpLabel %f = OpVariable %_ptr_Function_float Function %i = OpVariable %_ptr_Function_int Function %j = OpVariable %_ptr_Function_int Function OpStore %f %float_0 OpStore %i %int_0 OpBranch %25 %25 = OpLabel %26 = OpLoad %int %i %27 = OpSLessThan %bool %26 %int_4 OpLoopMerge %28 %29 None OpBranchConditional %27 %30 %28 %30 = OpLabel OpStore %j %int_0 OpBranch %31 %31 = OpLabel %32 = OpLoad %int %j %33 = OpSLessThan %bool %32 %int_4 OpLoopMerge %50 %34 None OpBranchConditional %33 %34 %50 %34 = OpLabel %35 = OpLoad %float %f %36 = OpLoad %int %i %37 = OpLoad %int %j %38 = OpAccessChain %_ptr_Input_float %BC %36 %37 %39 = OpLoad %float %38 %40 = OpFAdd %float %35 %39 OpStore %f %40 %41 = OpLoad %int %j %42 = OpIAdd %int %41 %int_1 OpStore %j %42 OpBranch %31 %50 = OpLabel OpBranch %29 %29 = OpLabel %43 = OpLoad %int %i %44 = OpIAdd %int %43 %int_1 OpStore %i %44 OpBranch %25 %28 = OpLabel %45 = OpLoad %float %f OpStore %fo %45 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(predefs + before, true); } TEST_F(LocalSSAElimTest, ForLoopWithContinue) { // #version 140 // // in vec4 BC; // out float fo; // // void main() // { // float f = 0.0; // for (int i=0; i<4; i++) { // float t = BC[i]; // if (t < 0.0) // continue; // f = f + t; // } // fo = f; // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BC %fo OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 )"; const std::string names = R"(OpName %main "main" OpName %f "f" OpName %i "i" OpName %t "t" OpName %BC "BC" OpName %fo "fo" )"; const std::string predefs2 = R"(%void = OpTypeVoid %9 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_4 = OpConstant %int 4 %bool = OpTypeBool %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %BC = OpVariable %_ptr_Input_v4float Input %_ptr_Input_float = OpTypePointer Input %float %int_1 = OpConstant %int 1 %_ptr_Output_float = OpTypePointer Output %float %fo = OpVariable %_ptr_Output_float Output )"; const std::string before = R"(%main = OpFunction %void None %9 %23 = OpLabel %f = OpVariable %_ptr_Function_float Function %i = OpVariable %_ptr_Function_int Function %t = OpVariable %_ptr_Function_float Function OpStore %f %float_0 OpStore %i %int_0 OpBranch %24 %24 = OpLabel OpLoopMerge %25 %26 None OpBranch %27 %27 = OpLabel %28 = OpLoad %int %i %29 = OpSLessThan %bool %28 %int_4 OpBranchConditional %29 %30 %25 %30 = OpLabel %31 = OpLoad %int %i %32 = OpAccessChain %_ptr_Input_float %BC %31 %33 = OpLoad %float %32 OpStore %t %33 %34 = OpLoad %float %t %35 = OpFOrdLessThan %bool %34 %float_0 OpSelectionMerge %36 None OpBranchConditional %35 %37 %36 %37 = OpLabel OpBranch %26 %36 = OpLabel %38 = OpLoad %float %f %39 = OpLoad %float %t %40 = OpFAdd %float %38 %39 OpStore %f %40 OpBranch %26 %26 = OpLabel %41 = OpLoad %int %i %42 = OpIAdd %int %41 %int_1 OpStore %i %42 OpBranch %24 %25 = OpLabel %43 = OpLoad %float %f OpStore %fo %43 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %9 %23 = OpLabel %f = OpVariable %_ptr_Function_float Function %i = OpVariable %_ptr_Function_int Function %t = OpVariable %_ptr_Function_float Function OpStore %f %float_0 OpStore %i %int_0 OpBranch %24 %24 = OpLabel %45 = OpPhi %float %float_0 %23 %47 %26 %44 = OpPhi %int %int_0 %23 %42 %26 OpLoopMerge %25 %26 None OpBranch %27 %27 = OpLabel %29 = OpSLessThan %bool %44 %int_4 OpBranchConditional %29 %30 %25 %30 = OpLabel %32 = OpAccessChain %_ptr_Input_float %BC %44 %33 = OpLoad %float %32 OpStore %t %33 %35 = OpFOrdLessThan %bool %33 %float_0 OpSelectionMerge %36 None OpBranchConditional %35 %37 %36 %37 = OpLabel OpBranch %26 %36 = OpLabel %40 = OpFAdd %float %45 %33 OpStore %f %40 OpBranch %26 %26 = OpLabel %47 = OpPhi %float %45 %37 %40 %36 %42 = OpIAdd %int %44 %int_1 OpStore %i %42 OpBranch %24 %25 = OpLabel OpStore %fo %45 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + names + predefs2 + before, predefs + names + predefs2 + after, true, true); } TEST_F(LocalSSAElimTest, ForLoopWithBreak) { // #version 140 // // in vec4 BC; // out float fo; // // void main() // { // float f = 0.0; // for (int i=0; i<4; i++) { // float t = f + BC[i]; // if (t > 1.0) // break; // f = t; // } // fo = f; // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BC %fo OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %f "f" OpName %i "i" OpName %t "t" OpName %BC "BC" OpName %fo "fo" %void = OpTypeVoid %9 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_4 = OpConstant %int 4 %bool = OpTypeBool %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %BC = OpVariable %_ptr_Input_v4float Input %_ptr_Input_float = OpTypePointer Input %float %float_1 = OpConstant %float 1 %int_1 = OpConstant %int 1 %_ptr_Output_float = OpTypePointer Output %float %fo = OpVariable %_ptr_Output_float Output )"; const std::string before = R"(%main = OpFunction %void None %9 %24 = OpLabel %f = OpVariable %_ptr_Function_float Function %i = OpVariable %_ptr_Function_int Function %t = OpVariable %_ptr_Function_float Function OpStore %f %float_0 OpStore %i %int_0 OpBranch %25 %25 = OpLabel OpLoopMerge %26 %27 None OpBranch %28 %28 = OpLabel %29 = OpLoad %int %i %30 = OpSLessThan %bool %29 %int_4 OpBranchConditional %30 %31 %26 %31 = OpLabel %32 = OpLoad %float %f %33 = OpLoad %int %i %34 = OpAccessChain %_ptr_Input_float %BC %33 %35 = OpLoad %float %34 %36 = OpFAdd %float %32 %35 OpStore %t %36 %37 = OpLoad %float %t %38 = OpFOrdGreaterThan %bool %37 %float_1 OpSelectionMerge %39 None OpBranchConditional %38 %40 %39 %40 = OpLabel OpBranch %26 %39 = OpLabel %41 = OpLoad %float %t OpStore %f %41 OpBranch %27 %27 = OpLabel %42 = OpLoad %int %i %43 = OpIAdd %int %42 %int_1 OpStore %i %43 OpBranch %25 %26 = OpLabel %44 = OpLoad %float %f OpStore %fo %44 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %9 %24 = OpLabel %f = OpVariable %_ptr_Function_float Function %i = OpVariable %_ptr_Function_int Function %t = OpVariable %_ptr_Function_float Function OpStore %f %float_0 OpStore %i %int_0 OpBranch %25 %25 = OpLabel %46 = OpPhi %float %float_0 %24 %36 %27 %45 = OpPhi %int %int_0 %24 %43 %27 OpLoopMerge %26 %27 None OpBranch %28 %28 = OpLabel %30 = OpSLessThan %bool %45 %int_4 OpBranchConditional %30 %31 %26 %31 = OpLabel %34 = OpAccessChain %_ptr_Input_float %BC %45 %35 = OpLoad %float %34 %36 = OpFAdd %float %46 %35 OpStore %t %36 %38 = OpFOrdGreaterThan %bool %36 %float_1 OpSelectionMerge %39 None OpBranchConditional %38 %40 %39 %40 = OpLabel OpBranch %26 %39 = OpLabel OpStore %f %36 OpBranch %27 %27 = OpLabel %43 = OpIAdd %int %45 %int_1 OpStore %i %43 OpBranch %25 %26 = OpLabel OpStore %fo %46 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before, predefs + after, true, true); } TEST_F(LocalSSAElimTest, SwapProblem) { // #version 140 // // in float fe; // out float fo; // // void main() // { // float f1 = 0.0; // float f2 = 1.0; // int ie = int(fe); // for (int i=0; i(predefs + before, predefs + after, true, true); } TEST_F(LocalSSAElimTest, LostCopyProblem) { // #version 140 // // in vec4 BC; // out float fo; // // void main() // { // float f = 0.0; // float t; // for (int i=0; i<4; i++) { // t = f; // f = f + BC[i]; // if (f > 1.0) // break; // } // fo = t; // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BC %fo OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %f "f" OpName %i "i" OpName %t "t" OpName %BC "BC" OpName %fo "fo" %void = OpTypeVoid %9 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_4 = OpConstant %int 4 %bool = OpTypeBool %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %BC = OpVariable %_ptr_Input_v4float Input %_ptr_Input_float = OpTypePointer Input %float %float_1 = OpConstant %float 1 %int_1 = OpConstant %int 1 %_ptr_Output_float = OpTypePointer Output %float %fo = OpVariable %_ptr_Output_float Output )"; const std::string before = R"(%main = OpFunction %void None %9 %24 = OpLabel %f = OpVariable %_ptr_Function_float Function %i = OpVariable %_ptr_Function_int Function %t = OpVariable %_ptr_Function_float Function OpStore %f %float_0 OpStore %i %int_0 OpBranch %25 %25 = OpLabel OpLoopMerge %26 %27 None OpBranch %28 %28 = OpLabel %29 = OpLoad %int %i %30 = OpSLessThan %bool %29 %int_4 OpBranchConditional %30 %31 %26 %31 = OpLabel %32 = OpLoad %float %f OpStore %t %32 %33 = OpLoad %float %f %34 = OpLoad %int %i %35 = OpAccessChain %_ptr_Input_float %BC %34 %36 = OpLoad %float %35 %37 = OpFAdd %float %33 %36 OpStore %f %37 %38 = OpLoad %float %f %39 = OpFOrdGreaterThan %bool %38 %float_1 OpSelectionMerge %40 None OpBranchConditional %39 %41 %40 %41 = OpLabel OpBranch %26 %40 = OpLabel OpBranch %27 %27 = OpLabel %42 = OpLoad %int %i %43 = OpIAdd %int %42 %int_1 OpStore %i %43 OpBranch %25 %26 = OpLabel %44 = OpLoad %float %t OpStore %fo %44 OpReturn OpFunctionEnd )"; const std::string after = R"(%49 = OpUndef %float %main = OpFunction %void None %9 %24 = OpLabel %f = OpVariable %_ptr_Function_float Function %i = OpVariable %_ptr_Function_int Function %t = OpVariable %_ptr_Function_float Function OpStore %f %float_0 OpStore %i %int_0 OpBranch %25 %25 = OpLabel %46 = OpPhi %float %float_0 %24 %37 %27 %45 = OpPhi %int %int_0 %24 %43 %27 %48 = OpPhi %float %49 %24 %46 %27 OpLoopMerge %26 %27 None OpBranch %28 %28 = OpLabel %30 = OpSLessThan %bool %45 %int_4 OpBranchConditional %30 %31 %26 %31 = OpLabel OpStore %t %46 %35 = OpAccessChain %_ptr_Input_float %BC %45 %36 = OpLoad %float %35 %37 = OpFAdd %float %46 %36 OpStore %f %37 %39 = OpFOrdGreaterThan %bool %37 %float_1 OpSelectionMerge %40 None OpBranchConditional %39 %41 %40 %41 = OpLabel OpBranch %26 %40 = OpLabel OpBranch %27 %27 = OpLabel %43 = OpIAdd %int %45 %int_1 OpStore %i %43 OpBranch %25 %26 = OpLabel %47 = OpPhi %float %48 %28 %46 %41 OpStore %fo %47 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before, predefs + after, true, true); } TEST_F(LocalSSAElimTest, IfThenElse) { // #version 140 // // in vec4 BaseColor; // in float f; // // void main() // { // vec4 v; // if (f >= 0) // v = BaseColor * 0.5; // else // v = BaseColor + vec4(1.0,1.0,1.0,1.0); // gl_FragColor = v; // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %f %BaseColor %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %f "f" OpName %v "v" OpName %BaseColor "BaseColor" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Input_float = OpTypePointer Input %float %f = OpVariable %_ptr_Input_float Input %float_0 = OpConstant %float 0 %bool = OpTypeBool %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %float_0_5 = OpConstant %float 0.5 %float_1 = OpConstant %float 1 %18 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output )"; const std::string before = R"(%main = OpFunction %void None %8 %20 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %21 = OpLoad %float %f %22 = OpFOrdGreaterThanEqual %bool %21 %float_0 OpSelectionMerge %23 None OpBranchConditional %22 %24 %25 %24 = OpLabel %26 = OpLoad %v4float %BaseColor %27 = OpVectorTimesScalar %v4float %26 %float_0_5 OpStore %v %27 OpBranch %23 %25 = OpLabel %28 = OpLoad %v4float %BaseColor %29 = OpFAdd %v4float %28 %18 OpStore %v %29 OpBranch %23 %23 = OpLabel %30 = OpLoad %v4float %v OpStore %gl_FragColor %30 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %8 %20 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %21 = OpLoad %float %f %22 = OpFOrdGreaterThanEqual %bool %21 %float_0 OpSelectionMerge %23 None OpBranchConditional %22 %24 %25 %24 = OpLabel %26 = OpLoad %v4float %BaseColor %27 = OpVectorTimesScalar %v4float %26 %float_0_5 OpStore %v %27 OpBranch %23 %25 = OpLabel %28 = OpLoad %v4float %BaseColor %29 = OpFAdd %v4float %28 %18 OpStore %v %29 OpBranch %23 %23 = OpLabel %31 = OpPhi %v4float %27 %24 %29 %25 OpStore %gl_FragColor %31 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before, predefs + after, true, true); } TEST_F(LocalSSAElimTest, IfThen) { // #version 140 // // in vec4 BaseColor; // in float f; // // void main() // { // vec4 v = BaseColor; // if (f <= 0) // v = v * 0.5; // gl_FragColor = v; // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %f %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" OpName %f "f" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %_ptr_Input_float = OpTypePointer Input %float %f = OpVariable %_ptr_Input_float Input %float_0 = OpConstant %float 0 %bool = OpTypeBool %float_0_5 = OpConstant %float 0.5 %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output )"; const std::string before = R"(%main = OpFunction %void None %8 %18 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %19 = OpLoad %v4float %BaseColor OpStore %v %19 %20 = OpLoad %float %f %21 = OpFOrdLessThanEqual %bool %20 %float_0 OpSelectionMerge %22 None OpBranchConditional %21 %23 %22 %23 = OpLabel %24 = OpLoad %v4float %v %25 = OpVectorTimesScalar %v4float %24 %float_0_5 OpStore %v %25 OpBranch %22 %22 = OpLabel %26 = OpLoad %v4float %v OpStore %gl_FragColor %26 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %8 %18 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %19 = OpLoad %v4float %BaseColor OpStore %v %19 %20 = OpLoad %float %f %21 = OpFOrdLessThanEqual %bool %20 %float_0 OpSelectionMerge %22 None OpBranchConditional %21 %23 %22 %23 = OpLabel %25 = OpVectorTimesScalar %v4float %19 %float_0_5 OpStore %v %25 OpBranch %22 %22 = OpLabel %27 = OpPhi %v4float %19 %18 %25 %23 OpStore %gl_FragColor %27 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before, predefs + after, true, true); } TEST_F(LocalSSAElimTest, Switch) { // #version 140 // // in vec4 BaseColor; // in float f; // // void main() // { // vec4 v = BaseColor; // int i = int(f); // switch (i) { // case 0: // v = v * 0.25; // break; // case 1: // v = v * 0.625; // break; // case 2: // v = v * 0.75; // break; // default: // break; // } // gl_FragColor = v; // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %f %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" OpName %i "i" OpName %f "f" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %9 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %_ptr_Input_float = OpTypePointer Input %float %f = OpVariable %_ptr_Input_float Input %float_0_25 = OpConstant %float 0.25 %float_0_625 = OpConstant %float 0.625 %float_0_75 = OpConstant %float 0.75 %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output )"; const std::string before = R"(%main = OpFunction %void None %9 %21 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %i = OpVariable %_ptr_Function_int Function %22 = OpLoad %v4float %BaseColor OpStore %v %22 %23 = OpLoad %float %f %24 = OpConvertFToS %int %23 OpStore %i %24 %25 = OpLoad %int %i OpSelectionMerge %26 None OpSwitch %25 %27 0 %28 1 %29 2 %30 %27 = OpLabel OpBranch %26 %28 = OpLabel %31 = OpLoad %v4float %v %32 = OpVectorTimesScalar %v4float %31 %float_0_25 OpStore %v %32 OpBranch %26 %29 = OpLabel %33 = OpLoad %v4float %v %34 = OpVectorTimesScalar %v4float %33 %float_0_625 OpStore %v %34 OpBranch %26 %30 = OpLabel %35 = OpLoad %v4float %v %36 = OpVectorTimesScalar %v4float %35 %float_0_75 OpStore %v %36 OpBranch %26 %26 = OpLabel %37 = OpLoad %v4float %v OpStore %gl_FragColor %37 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %9 %21 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %i = OpVariable %_ptr_Function_int Function %22 = OpLoad %v4float %BaseColor OpStore %v %22 %23 = OpLoad %float %f %24 = OpConvertFToS %int %23 OpStore %i %24 OpSelectionMerge %26 None OpSwitch %24 %27 0 %28 1 %29 2 %30 %27 = OpLabel OpBranch %26 %28 = OpLabel %32 = OpVectorTimesScalar %v4float %22 %float_0_25 OpStore %v %32 OpBranch %26 %29 = OpLabel %34 = OpVectorTimesScalar %v4float %22 %float_0_625 OpStore %v %34 OpBranch %26 %30 = OpLabel %36 = OpVectorTimesScalar %v4float %22 %float_0_75 OpStore %v %36 OpBranch %26 %26 = OpLabel %38 = OpPhi %v4float %22 %27 %32 %28 %34 %29 %36 %30 OpStore %gl_FragColor %38 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before, predefs + after, true, true); } TEST_F(LocalSSAElimTest, SwitchWithFallThrough) { // #version 140 // // in vec4 BaseColor; // in float f; // // void main() // { // vec4 v = BaseColor; // int i = int(f); // switch (i) { // case 0: // v = v * 0.25; // break; // case 1: // v = v + 0.25; // case 2: // v = v * 0.75; // break; // default: // break; // } // gl_FragColor = v; // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %f %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" OpName %i "i" OpName %f "f" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %9 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %_ptr_Input_float = OpTypePointer Input %float %f = OpVariable %_ptr_Input_float Input %float_0_25 = OpConstant %float 0.25 %float_0_75 = OpConstant %float 0.75 %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output )"; const std::string before = R"(%main = OpFunction %void None %9 %20 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %i = OpVariable %_ptr_Function_int Function %21 = OpLoad %v4float %BaseColor OpStore %v %21 %22 = OpLoad %float %f %23 = OpConvertFToS %int %22 OpStore %i %23 %24 = OpLoad %int %i OpSelectionMerge %25 None OpSwitch %24 %26 0 %27 1 %28 2 %29 %26 = OpLabel OpBranch %25 %27 = OpLabel %30 = OpLoad %v4float %v %31 = OpVectorTimesScalar %v4float %30 %float_0_25 OpStore %v %31 OpBranch %25 %28 = OpLabel %32 = OpLoad %v4float %v %33 = OpCompositeConstruct %v4float %float_0_25 %float_0_25 %float_0_25 %float_0_25 %34 = OpFAdd %v4float %32 %33 OpStore %v %34 OpBranch %29 %29 = OpLabel %35 = OpLoad %v4float %v %36 = OpVectorTimesScalar %v4float %35 %float_0_75 OpStore %v %36 OpBranch %25 %25 = OpLabel %37 = OpLoad %v4float %v OpStore %gl_FragColor %37 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %9 %20 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %i = OpVariable %_ptr_Function_int Function %21 = OpLoad %v4float %BaseColor OpStore %v %21 %22 = OpLoad %float %f %23 = OpConvertFToS %int %22 OpStore %i %23 OpSelectionMerge %25 None OpSwitch %23 %26 0 %27 1 %28 2 %29 %26 = OpLabel OpBranch %25 %27 = OpLabel %31 = OpVectorTimesScalar %v4float %21 %float_0_25 OpStore %v %31 OpBranch %25 %28 = OpLabel %33 = OpCompositeConstruct %v4float %float_0_25 %float_0_25 %float_0_25 %float_0_25 %34 = OpFAdd %v4float %21 %33 OpStore %v %34 OpBranch %29 %29 = OpLabel %38 = OpPhi %v4float %21 %20 %34 %28 %36 = OpVectorTimesScalar %v4float %38 %float_0_75 OpStore %v %36 OpBranch %25 %25 = OpLabel %39 = OpPhi %v4float %21 %26 %31 %27 %36 %29 OpStore %gl_FragColor %39 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + before, predefs + after, true, true); } TEST_F(LocalSSAElimTest, DontPatchPhiInLoopHeaderThatIsNotAVar) { // From https://github.com/KhronosGroup/SPIRV-Tools/issues/826 // Don't try patching the (%16 %7) value/predecessor pair in the OpPhi. // That OpPhi is unrelated to this optimization: we did not set that up // in the SSA initialization for the loop header block. // The pass should be a no-op on this module. const std::string before = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %float_1 = OpConstant %float 1 %1 = OpFunction %void None %3 %6 = OpLabel OpBranch %7 %7 = OpLabel %8 = OpPhi %float %float_1 %6 %9 %7 %9 = OpFAdd %float %8 %float_1 OpLoopMerge %10 %7 None OpBranch %7 %10 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(before, before, true, true); } TEST_F(LocalSSAElimTest, OptInitializedVariableLikeStore) { // Note: SPIR-V edited to change store to v into variable initialization // // #version 450 // // layout (location=0) in vec4 iColor; // layout (location=1) in float fi; // layout (location=0) out vec4 oColor; // // void main() // { // vec4 v = vec4(0.0); // if (fi < 0.0) // v.x = iColor.x; // oColor = v; // } const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %fi %iColor %oColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %v "v" OpName %fi "fi" OpName %iColor "iColor" OpName %oColor "oColor" OpDecorate %fi Location 1 OpDecorate %iColor Location 0 OpDecorate %oColor Location 0 %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %float_0 = OpConstant %float 0 %13 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %_ptr_Input_float = OpTypePointer Input %float %fi = OpVariable %_ptr_Input_float Input %bool = OpTypeBool %_ptr_Input_v4float = OpTypePointer Input %v4float %iColor = OpVariable %_ptr_Input_v4float Input %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Function_float = OpTypePointer Function %float %_ptr_Output_v4float = OpTypePointer Output %v4float %oColor = OpVariable %_ptr_Output_v4float Output )"; const std::string func_before = R"(%main = OpFunction %void None %8 %21 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %13 %22 = OpLoad %float %fi %23 = OpFOrdLessThan %bool %22 %float_0 OpSelectionMerge %24 None OpBranchConditional %23 %25 %24 %25 = OpLabel %26 = OpAccessChain %_ptr_Input_float %iColor %uint_0 %27 = OpLoad %float %26 %28 = OpLoad %v4float %v %29 = OpCompositeInsert %v4float %27 %28 0 OpStore %v %29 OpBranch %24 %24 = OpLabel %30 = OpLoad %v4float %v OpStore %oColor %30 OpReturn OpFunctionEnd )"; const std::string func_after = R"(%main = OpFunction %void None %8 %21 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %13 %22 = OpLoad %float %fi %23 = OpFOrdLessThan %bool %22 %float_0 OpSelectionMerge %24 None OpBranchConditional %23 %25 %24 %25 = OpLabel %26 = OpAccessChain %_ptr_Input_float %iColor %uint_0 %27 = OpLoad %float %26 %29 = OpCompositeInsert %v4float %27 %13 0 OpStore %v %29 OpBranch %24 %24 = OpLabel %31 = OpPhi %v4float %13 %21 %29 %25 OpStore %oColor %31 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(predefs + func_before, predefs + func_after, true, true); } TEST_F(LocalSSAElimTest, PointerVariable) { // Test that checks if a pointer variable is removed. const std::string before = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" %2 OpExecutionMode %1 OriginUpperLeft OpMemberDecorate %_struct_3 0 Offset 0 OpDecorate %_runtimearr__struct_3 ArrayStride 16 OpMemberDecorate %_struct_5 0 Offset 0 OpDecorate %_struct_5 BufferBlock OpMemberDecorate %_struct_6 0 Offset 0 OpDecorate %_struct_6 BufferBlock OpDecorate %2 Location 0 OpDecorate %7 DescriptorSet 0 OpDecorate %7 Binding 0 %void = OpTypeVoid %10 = OpTypeFunction %void %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %_struct_3 = OpTypeStruct %v4float %_runtimearr__struct_3 = OpTypeRuntimeArray %_struct_3 %_struct_5 = OpTypeStruct %_runtimearr__struct_3 %_ptr_Uniform__struct_5 = OpTypePointer Uniform %_struct_5 %_struct_6 = OpTypeStruct %int %_ptr_Uniform__struct_6 = OpTypePointer Uniform %_struct_6 %_ptr_Function__ptr_Uniform__struct_5 = OpTypePointer Function %_ptr_Uniform__struct_5 %_ptr_Function__ptr_Uniform__struct_6 = OpTypePointer Function %_ptr_Uniform__struct_6 %int_0 = OpConstant %int 0 %uint_0 = OpConstant %uint 0 %2 = OpVariable %_ptr_Output_v4float Output %7 = OpVariable %_ptr_Uniform__struct_5 Uniform %1 = OpFunction %void None %10 %23 = OpLabel %24 = OpVariable %_ptr_Function__ptr_Uniform__struct_5 Function OpStore %24 %7 %26 = OpLoad %_ptr_Uniform__struct_5 %24 %27 = OpAccessChain %_ptr_Uniform_v4float %26 %int_0 %uint_0 %int_0 %28 = OpLoad %v4float %27 %29 = OpCopyObject %v4float %28 OpStore %2 %28 OpReturn OpFunctionEnd )"; const std::string after = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" %2 OpExecutionMode %1 OriginUpperLeft OpMemberDecorate %_struct_3 0 Offset 0 OpDecorate %_runtimearr__struct_3 ArrayStride 16 OpMemberDecorate %_struct_5 0 Offset 0 OpDecorate %_struct_5 BufferBlock OpMemberDecorate %_struct_6 0 Offset 0 OpDecorate %_struct_6 BufferBlock OpDecorate %2 Location 0 OpDecorate %7 DescriptorSet 0 OpDecorate %7 Binding 0 %void = OpTypeVoid %10 = OpTypeFunction %void %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %_struct_3 = OpTypeStruct %v4float %_runtimearr__struct_3 = OpTypeRuntimeArray %_struct_3 %_struct_5 = OpTypeStruct %_runtimearr__struct_3 %_ptr_Uniform__struct_5 = OpTypePointer Uniform %_struct_5 %_struct_6 = OpTypeStruct %int %_ptr_Uniform__struct_6 = OpTypePointer Uniform %_struct_6 %_ptr_Function__ptr_Uniform__struct_5 = OpTypePointer Function %_ptr_Uniform__struct_5 %_ptr_Function__ptr_Uniform__struct_6 = OpTypePointer Function %_ptr_Uniform__struct_6 %int_0 = OpConstant %int 0 %uint_0 = OpConstant %uint 0 %2 = OpVariable %_ptr_Output_v4float Output %7 = OpVariable %_ptr_Uniform__struct_5 Uniform %1 = OpFunction %void None %10 %23 = OpLabel %24 = OpVariable %_ptr_Function__ptr_Uniform__struct_5 Function OpStore %24 %7 %27 = OpAccessChain %_ptr_Uniform_v4float %7 %int_0 %uint_0 %int_0 %28 = OpLoad %v4float %27 %29 = OpCopyObject %v4float %28 OpStore %2 %28 OpReturn OpFunctionEnd )"; // Relax logical pointers to allow pointer allocations. SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); ValidatorOptions()->relax_logical_pointer = true; SinglePassRunAndCheck(before, after, true, true); } TEST_F(LocalSSAElimTest, VerifyInstToBlockMap) { // #version 140 // // in vec4 BC; // out float fo; // // void main() // { // float f = 0.0; // for (int i=0; i<4; i++) { // f = f + BC[i]; // } // fo = f; // } const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BC %fo OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" OpName %f "f" OpName %i "i" OpName %BC "BC" OpName %fo "fo" %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_4 = OpConstant %int 4 %bool = OpTypeBool %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %BC = OpVariable %_ptr_Input_v4float Input %_ptr_Input_float = OpTypePointer Input %float %int_1 = OpConstant %int 1 %_ptr_Output_float = OpTypePointer Output %float %fo = OpVariable %_ptr_Output_float Output %main = OpFunction %void None %8 %22 = OpLabel %f = OpVariable %_ptr_Function_float Function %i = OpVariable %_ptr_Function_int Function OpStore %f %float_0 OpStore %i %int_0 OpBranch %23 %23 = OpLabel OpLoopMerge %24 %25 None OpBranch %26 %26 = OpLabel %27 = OpLoad %int %i %28 = OpSLessThan %bool %27 %int_4 OpBranchConditional %28 %29 %24 %29 = OpLabel %30 = OpLoad %float %f %31 = OpLoad %int %i %32 = OpAccessChain %_ptr_Input_float %BC %31 %33 = OpLoad %float %32 %34 = OpFAdd %float %30 %33 OpStore %f %34 OpBranch %25 %25 = OpLabel %35 = OpLoad %int %i %36 = OpIAdd %int %35 %int_1 OpStore %i %36 OpBranch %23 %24 = OpLabel %37 = OpLoad %float %f OpStore %fo %37 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); EXPECT_NE(nullptr, context); // Force the instruction to block mapping to get built. context->get_instr_block(27u); auto pass = MakeUnique(); pass->SetMessageConsumer(nullptr); const auto status = pass->Run(context.get()); EXPECT_TRUE(status == Pass::Status::SuccessWithChange); } TEST_F(LocalSSAElimTest, CompositeExtractProblem) { const std::string spv_asm = R"( OpCapability Tessellation %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %2 "main" %16 %17 %18 %20 %22 %26 %27 %30 %31 %void = OpTypeVoid %4 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_3 = OpConstant %uint 3 %v3float = OpTypeVector %float 3 %v2float = OpTypeVector %float 2 %_struct_11 = OpTypeStruct %v4float %v4float %v4float %v3float %v3float %v2float %v2float %_arr__struct_11_uint_3 = OpTypeArray %_struct_11 %uint_3 %_ptr_Function__arr__struct_11_uint_3 = OpTypePointer Function %_arr__struct_11_uint_3 %_arr_v4float_uint_3 = OpTypeArray %v4float %uint_3 %_ptr_Input__arr_v4float_uint_3 = OpTypePointer Input %_arr_v4float_uint_3 %16 = OpVariable %_ptr_Input__arr_v4float_uint_3 Input %17 = OpVariable %_ptr_Input__arr_v4float_uint_3 Input %18 = OpVariable %_ptr_Input__arr_v4float_uint_3 Input %_ptr_Input_uint = OpTypePointer Input %uint %20 = OpVariable %_ptr_Input_uint Input %_ptr_Output__arr_v4float_uint_3 = OpTypePointer Output %_arr_v4float_uint_3 %22 = OpVariable %_ptr_Output__arr_v4float_uint_3 Output %_ptr_Output_v4float = OpTypePointer Output %v4float %_arr_v3float_uint_3 = OpTypeArray %v3float %uint_3 %_ptr_Input__arr_v3float_uint_3 = OpTypePointer Input %_arr_v3float_uint_3 %26 = OpVariable %_ptr_Input__arr_v3float_uint_3 Input %27 = OpVariable %_ptr_Input__arr_v3float_uint_3 Input %_arr_v2float_uint_3 = OpTypeArray %v2float %uint_3 %_ptr_Input__arr_v2float_uint_3 = OpTypePointer Input %_arr_v2float_uint_3 %30 = OpVariable %_ptr_Input__arr_v2float_uint_3 Input %31 = OpVariable %_ptr_Input__arr_v2float_uint_3 Input %_ptr_Function__struct_11 = OpTypePointer Function %_struct_11 %2 = OpFunction %void None %4 %33 = OpLabel %66 = OpVariable %_ptr_Function__arr__struct_11_uint_3 Function %34 = OpLoad %_arr_v4float_uint_3 %16 %35 = OpLoad %_arr_v4float_uint_3 %17 %36 = OpLoad %_arr_v4float_uint_3 %18 %37 = OpLoad %_arr_v3float_uint_3 %26 %38 = OpLoad %_arr_v3float_uint_3 %27 %39 = OpLoad %_arr_v2float_uint_3 %30 %40 = OpLoad %_arr_v2float_uint_3 %31 %41 = OpCompositeExtract %v4float %34 0 %42 = OpCompositeExtract %v4float %35 0 %43 = OpCompositeExtract %v4float %36 0 %44 = OpCompositeExtract %v3float %37 0 %45 = OpCompositeExtract %v3float %38 0 %46 = OpCompositeExtract %v2float %39 0 %47 = OpCompositeExtract %v2float %40 0 %48 = OpCompositeConstruct %_struct_11 %41 %42 %43 %44 %45 %46 %47 %49 = OpCompositeExtract %v4float %34 1 %50 = OpCompositeExtract %v4float %35 1 %51 = OpCompositeExtract %v4float %36 1 %52 = OpCompositeExtract %v3float %37 1 %53 = OpCompositeExtract %v3float %38 1 %54 = OpCompositeExtract %v2float %39 1 %55 = OpCompositeExtract %v2float %40 1 %56 = OpCompositeConstruct %_struct_11 %49 %50 %51 %52 %53 %54 %55 %57 = OpCompositeExtract %v4float %34 2 %58 = OpCompositeExtract %v4float %35 2 %59 = OpCompositeExtract %v4float %36 2 %60 = OpCompositeExtract %v3float %37 2 %61 = OpCompositeExtract %v3float %38 2 %62 = OpCompositeExtract %v2float %39 2 %63 = OpCompositeExtract %v2float %40 2 %64 = OpCompositeConstruct %_struct_11 %57 %58 %59 %60 %61 %62 %63 %65 = OpCompositeConstruct %_arr__struct_11_uint_3 %48 %56 %64 %67 = OpLoad %uint %20 ; CHECK OpStore {{%\d+}} [[store_source:%\d+]] OpStore %66 %65 %68 = OpAccessChain %_ptr_Function__struct_11 %66 %67 ; This load was being removed, because %_ptr_Function__struct_11 was being ; wrongfully considered an SSA target. ; CHECK OpLoad %_struct_11 %68 %69 = OpLoad %_struct_11 %68 ; Similarly, %69 cannot be replaced with %65. ; CHECK-NOT: OpCompositeExtract %v4float [[store_source]] 0 %70 = OpCompositeExtract %v4float %69 0 %71 = OpAccessChain %_ptr_Output_v4float %22 %67 OpStore %71 %70 OpReturn OpFunctionEnd)"; SinglePassRunAndMatch(spv_asm, true); } // Test that the RelaxedPrecision decoration on the variable to added to the // result of the OpPhi instruction. TEST_F(LocalSSAElimTest, DecoratedVariable) { const std::string spv_asm = R"( ; CHECK: OpDecorate [[var:%\w+]] RelaxedPrecision ; CHECK: OpDecorate [[phi_id:%\w+]] RelaxedPrecision ; CHECK: [[phi_id]] = OpPhi OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" OpDecorate %v RelaxedPrecision %void = OpTypeVoid %func_t = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %int = OpTypeInt 32 0 %int_p = OpTypePointer Function %int %int_1 = OpConstant %int 1 %int_0 = OpConstant %int 0 %2 = OpFunction %void None %func_t %33 = OpLabel %v = OpVariable %int_p Function OpSelectionMerge %merge None OpBranchConditional %true %l1 %l2 %l1 = OpLabel OpStore %v %int_1 OpBranch %merge %l2 = OpLabel OpStore %v %int_0 OpBranch %merge %merge = OpLabel %ld = OpLoad %int %v OpReturn OpFunctionEnd)"; SinglePassRunAndMatch(spv_asm, true); } // Test that the RelaxedPrecision decoration on the variable to added to the // result of the OpPhi instruction. TEST_F(LocalSSAElimTest, MultipleEdges) { const std::string spv_asm = R"( ; CHECK: OpSelectionMerge ; CHECK: [[header_bb:%\w+]] = OpLabel ; CHECK-NOT: OpLabel ; CHECK: OpSwitch {{%\w+}} {{%\w+}} 76 [[bb1:%\w+]] 17 [[bb2:%\w+]] ; CHECK-SAME: 4 [[bb2]] ; CHECK: [[bb2]] = OpLabel ; CHECK-NEXT: OpPhi [[type:%\w+]] [[val:%\w+]] [[header_bb]] %int_0 [[bb1]] OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %bool = OpTypeBool %true = OpConstantTrue %bool %false = OpConstantFalse %bool %int_1 = OpConstant %int 1 %4 = OpFunction %void None %3 %5 = OpLabel %8 = OpVariable %_ptr_Function_int Function OpBranch %10 %10 = OpLabel OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel OpBranchConditional %true %11 %12 %11 = OpLabel OpSelectionMerge %19 None OpBranchConditional %false %18 %19 %18 = OpLabel OpSelectionMerge %22 None OpSwitch %int_0 %22 76 %20 17 %21 4 %21 %20 = OpLabel %23 = OpLoad %int %8 OpStore %8 %int_0 OpBranch %21 %21 = OpLabel OpBranch %22 %22 = OpLabel OpBranch %19 %19 = OpLabel OpBranch %13 %13 = OpLabel OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(spv_asm, true); } TEST_F(LocalSSAElimTest, VariablePointerTest1) { // Check that the load of the first variable is still used and that the load // of the third variable is propagated. The first load has to remain because // of the store to the variable pointer. const std::string text = R"( ; CHECK: [[v1:%\w+]] = OpVariable ; CHECK: [[v2:%\w+]] = OpVariable ; CHECK: [[v3:%\w+]] = OpVariable ; CHECK: [[ld1:%\w+]] = OpLoad %int [[v1]] ; CHECK: OpIAdd %int [[ld1]] %int_0 OpCapability Shader OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" OpExecutionMode %2 LocalSize 1 1 1 OpSource GLSL 450 OpMemberDecorate %_struct_3 0 Offset 0 OpMemberDecorate %_struct_3 1 Offset 4 %void = OpTypeVoid %5 = OpTypeFunction %void %int = OpTypeInt 32 1 %bool = OpTypeBool %_struct_3 = OpTypeStruct %int %int %_ptr_Function__struct_3 = OpTypePointer Function %_struct_3 %_ptr_Function_int = OpTypePointer Function %int %true = OpConstantTrue %bool %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %13 = OpConstantNull %_struct_3 %2 = OpFunction %void None %5 %14 = OpLabel %15 = OpVariable %_ptr_Function_int Function %16 = OpVariable %_ptr_Function_int Function %17 = OpVariable %_ptr_Function_int Function OpStore %15 %int_1 OpStore %17 %int_0 OpSelectionMerge %18 None OpBranchConditional %true %19 %20 %19 = OpLabel OpBranch %18 %20 = OpLabel OpBranch %18 %18 = OpLabel %21 = OpPhi %_ptr_Function_int %15 %19 %16 %20 OpStore %21 %int_0 %22 = OpLoad %int %15 %23 = OpLoad %int %17 %24 = OpIAdd %int %22 %23 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(LocalSSAElimTest, VariablePointerTest2) { // Check that the load of the first variable is still used and that the load // of the third variable is propagated. The first load has to remain because // of the store to the variable pointer. const std::string text = R"( ; CHECK: [[v1:%\w+]] = OpVariable ; CHECK: [[v2:%\w+]] = OpVariable ; CHECK: [[v3:%\w+]] = OpVariable ; CHECK: [[ld1:%\w+]] = OpLoad %int [[v1]] ; CHECK: OpIAdd %int [[ld1]] %int_0 OpCapability Shader OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" OpExecutionMode %2 LocalSize 1 1 1 OpSource GLSL 450 OpMemberDecorate %_struct_3 0 Offset 0 OpMemberDecorate %_struct_3 1 Offset 4 %void = OpTypeVoid %5 = OpTypeFunction %void %int = OpTypeInt 32 1 %bool = OpTypeBool %_struct_3 = OpTypeStruct %int %int %_ptr_Function__struct_3 = OpTypePointer Function %_struct_3 %_ptr_Function_int = OpTypePointer Function %int %true = OpConstantTrue %bool %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %13 = OpConstantNull %_struct_3 %2 = OpFunction %void None %5 %14 = OpLabel %15 = OpVariable %_ptr_Function_int Function %16 = OpVariable %_ptr_Function_int Function %17 = OpVariable %_ptr_Function_int Function OpStore %15 %int_1 OpStore %17 %int_0 OpSelectionMerge %18 None OpBranchConditional %true %19 %20 %19 = OpLabel OpBranch %18 %20 = OpLabel OpBranch %18 %18 = OpLabel %21 = OpPhi %_ptr_Function_int %15 %19 %16 %20 OpStore %21 %int_0 %22 = OpLoad %int %15 %23 = OpLoad %int %17 %24 = OpIAdd %int %22 %23 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(LocalSSAElimTest, ChainedTrivialPhis) { // Check that the copy object get the undef value implicitly assigned in the // entry block. const std::string text = R"( ; CHECK: [[undef:%\w+]] = OpUndef %v4float ; CHECK: OpCopyObject %v4float [[undef]] OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" OpExecutionMode %2 LocalSize 1 18 6 OpSource ESSL 310 %void = OpTypeVoid %4 = OpTypeFunction %void %bool = OpTypeBool %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %2 = OpFunction %void None %4 %9 = OpLabel %10 = OpVariable %_ptr_Function_v4float Function OpBranch %11 %11 = OpLabel OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %15 = OpUndef %bool OpBranchConditional %15 %16 %12 %16 = OpLabel %17 = OpUndef %bool OpSelectionMerge %18 None OpBranchConditional %17 %19 %18 %19 = OpLabel %20 = OpUndef %bool OpLoopMerge %21 %22 None OpBranchConditional %20 %23 %21 %23 = OpLabel %24 = OpLoad %v4float %10 %25 = OpCopyObject %v4float %24 %26 = OpUndef %bool OpBranch %22 %22 = OpLabel OpBranch %19 %21 = OpLabel OpBranch %12 %18 = OpLabel OpBranch %13 %13 = OpLabel OpBranch %11 %12 = OpLabel %27 = OpLoad %v4float %10 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(LocalSSAElimTest, Overflowtest1) { // Check that the copy object get the undef value implicitly assigned in the // entry block. const std::string text = R"( OpCapability Geometry OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "P2Mai" %12 %17 OpExecutionMode %4 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %11 = OpTypePointer Input %7 %16 = OpTypePointer Output %7 %23 = OpTypePointer Function %7 %12 = OpVariable %11 Input %17 = OpVariable %16 Output %4 = OpFunction %2 None %3 %2177 = OpLabel %4194302 = OpVariable %23 Function %4194301 = OpLoad %7 %4194302 OpStore %17 %4194301 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); std::vector messages = { {SPV_MSG_ERROR, "", 0, 0, "ID overflow. Try running compact-ids."}}; SetMessageConsumer(GetTestMessageConsumer(messages)); auto result = SinglePassRunToBinary(text, true); EXPECT_EQ(Pass::Status::Failure, std::get<1>(result)); } TEST_F(LocalSSAElimTest, OpConstantNull) { const std::string text = R"( OpCapability Addresses OpCapability Kernel OpCapability Int64 OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %4 "A" OpSource OpenCL_C 200000 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %11 = OpTypePointer CrossWorkgroup %6 %16 = OpConstantNull %11 %20 = OpConstant %6 269484031 %4 = OpFunction %2 None %3 %17 = OpLabel %18 = OpLoad %6 %16 Aligned 536870912 %19 = OpBitwiseXor %6 %18 %20 OpStore %16 %19 Aligned 536870912 OpReturn OpFunctionEnd )"; SinglePassRunToBinary(text, false); } TEST_F(LocalSSAElimTest, DebugForLoop) { // #version 140 // // in vec4 BC; // out float fo; // // void main() // { // float f = 0.0; // for (int i=0; i<4; i++) { // f = f + BC[i]; // } // fo = f; // } const std::string text = R"( ; CHECK: [[f_name:%\w+]] = OpString "f" ; CHECK: [[i_name:%\w+]] = OpString "i" ; CHECK: [[dbg_f:%\w+]] = OpExtInst %void [[ext:%\d+]] DebugLocalVariable [[f_name]] ; CHECK: [[dbg_i:%\w+]] = OpExtInst %void [[ext]] DebugLocalVariable [[i_name]] ; CHECK: OpStore %f %float_0 ; CHECK-NEXT: OpExtInst %void [[ext]] DebugValue [[dbg_f]] %float_0 ; CHECK-NEXT: OpStore %i %int_0 ; CHECK-NEXT: OpExtInst %void [[ext]] DebugValue [[dbg_i]] %int_0 ; CHECK-NOT: DebugDeclare ; CHECK: [[loop_head:%\w+]] = OpLabel ; CHECK: [[phi0:%\w+]] = OpPhi %float %float_0 ; CHECK: [[phi1:%\w+]] = OpPhi %int %int_0 ; CHECK-NEXT: OpExtInst %void [[ext]] DebugValue [[dbg_f]] [[phi0]] ; CHECK-NEXT: OpExtInst %void [[ext]] DebugValue [[dbg_i]] [[phi1]] ; CHECK: OpLoopMerge [[loop_merge:%\w+]] [[loop_cont:%\w+]] None ; CHECK-NEXT: OpBranch [[loop_body:%\w+]] ; CHECK-NEXT: [[loop_body]] = OpLabel ; CHECK: OpBranchConditional {{%\w+}} [[bb:%\w+]] [[loop_merge]] ; CHECK: [[bb]] = OpLabel ; CHECK: OpStore %f [[f_val:%\w+]] ; CHECK-NEXT: OpExtInst %void [[ext]] DebugValue [[dbg_f]] [[f_val]] ; CHECK-NEXT: OpBranch [[loop_cont]] ; CHECK: [[loop_cont]] = OpLabel ; CHECK: OpStore %i [[i_val:%\w+]] ; CHECK-NEXT: OpExtInst %void [[ext]] DebugValue [[dbg_i]] [[i_val]] ; CHECK-NEXT: OpBranch [[loop_head]] ; CHECK: [[loop_merge]] = OpLabel OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" %ext = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BC %fo OpExecutionMode %main OriginUpperLeft %file_name = OpString "test" OpSource GLSL 140 %float_name = OpString "float" %main_name = OpString "main" %f_name = OpString "f" %i_name = OpString "i" OpName %main "main" OpName %f "f" OpName %i "i" OpName %BC "BC" OpName %fo "fo" %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_4 = OpConstant %int 4 %bool = OpTypeBool %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %BC = OpVariable %_ptr_Input_v4float Input %_ptr_Input_float = OpTypePointer Input %float %int_1 = OpConstant %int 1 %_ptr_Output_float = OpTypePointer Output %float %fo = OpVariable %_ptr_Output_float Output %null_expr = OpExtInst %void %ext DebugExpression %src = OpExtInst %void %ext DebugSource %file_name %cu = OpExtInst %void %ext DebugCompilationUnit 1 4 %src HLSL %dbg_tf = OpExtInst %void %ext DebugTypeBasic %float_name %uint_32 Float %dbg_v4f = OpExtInst %void %ext DebugTypeVector %dbg_tf 4 %main_ty = OpExtInst %void %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %dbg_v4f %dbg_v4f %dbg_main = OpExtInst %void %ext DebugFunction %main_name %main_ty %src 0 0 %cu %main_name FlagIsProtected|FlagIsPrivate 10 %main %dbg_f = OpExtInst %void %ext DebugLocalVariable %f_name %dbg_v4f %src 0 0 %dbg_main FlagIsLocal %dbg_i = OpExtInst %void %ext DebugLocalVariable %i_name %dbg_v4f %src 0 0 %dbg_main FlagIsLocal %main = OpFunction %void None %8 %22 = OpLabel %s0 = OpExtInst %void %ext DebugScope %dbg_main %f = OpVariable %_ptr_Function_float Function %i = OpVariable %_ptr_Function_int Function OpStore %f %float_0 OpStore %i %int_0 %decl0 = OpExtInst %void %ext DebugDeclare %dbg_f %f %null_expr %decl1 = OpExtInst %void %ext DebugDeclare %dbg_i %i %null_expr OpBranch %23 %23 = OpLabel %s1 = OpExtInst %void %ext DebugScope %dbg_main OpLoopMerge %24 %25 None OpBranch %26 %26 = OpLabel %s2 = OpExtInst %void %ext DebugScope %dbg_main %27 = OpLoad %int %i %28 = OpSLessThan %bool %27 %int_4 OpBranchConditional %28 %29 %24 %29 = OpLabel %s3 = OpExtInst %void %ext DebugScope %dbg_main %30 = OpLoad %float %f %31 = OpLoad %int %i %32 = OpAccessChain %_ptr_Input_float %BC %31 %33 = OpLoad %float %32 %34 = OpFAdd %float %30 %33 OpStore %f %34 OpBranch %25 %25 = OpLabel %s4 = OpExtInst %void %ext DebugScope %dbg_main %35 = OpLoad %int %i %36 = OpIAdd %int %35 %int_1 OpStore %i %36 OpBranch %23 %24 = OpLabel %s5 = OpExtInst %void %ext DebugScope %dbg_main %37 = OpLoad %float %f OpStore %fo %37 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(LocalSSAElimTest, ShaderDebugForLoop) { const std::string text = R"( ; CHECK: [[f_name:%\w+]] = OpString "f" ; CHECK: [[i_name:%\w+]] = OpString "i" ; CHECK: [[dbg_f:%\w+]] = OpExtInst %void [[ext:%\d+]] DebugLocalVariable [[f_name]] ; CHECK: [[dbg_i:%\w+]] = OpExtInst %void [[ext]] DebugLocalVariable [[i_name]] ; CHECK: OpStore %f %float_0 ; CHECK-NEXT: OpExtInst %void [[ext]] DebugValue [[dbg_f]] %float_0 ; CHECK-NEXT: OpStore %i %int_0 ; CHECK-NEXT: OpExtInst %void [[ext]] DebugValue [[dbg_i]] %int_0 ; CHECK-NOT: DebugDeclare ; CHECK: [[loop_head:%\w+]] = OpLabel ; CHECK: [[phi0:%\w+]] = OpPhi %float %float_0 ; CHECK: [[phi1:%\w+]] = OpPhi %int %int_0 ; CHECK-NEXT: OpExtInst %void [[ext]] DebugValue [[dbg_f]] [[phi0]] ; CHECK-NEXT: OpExtInst %void [[ext]] DebugValue [[dbg_i]] [[phi1]] ; CHECK: OpLoopMerge [[loop_merge:%\w+]] [[loop_cont:%\w+]] None ; CHECK-NEXT: OpBranch [[loop_body:%\w+]] ; CHECK-NEXT: [[loop_body]] = OpLabel ; CHECK: OpBranchConditional {{%\w+}} [[bb:%\w+]] [[loop_merge]] ; CHECK: [[bb]] = OpLabel ; CHECK: OpStore %f [[f_val:%\w+]] ; CHECK-NEXT: OpExtInst %void [[ext]] DebugValue [[dbg_f]] [[f_val]] ; CHECK-NEXT: OpBranch [[loop_cont]] ; CHECK: [[loop_cont]] = OpLabel ; CHECK: OpStore %i [[i_val:%\w+]] ; CHECK-NEXT: OpExtInst %void [[ext]] DebugValue [[dbg_i]] [[i_val]] ; CHECK-NEXT: OpBranch [[loop_head]] ; CHECK: [[loop_merge]] = OpLabel OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %1 = OpExtInstImport "GLSL.std.450" %ext = OpExtInstImport "NonSemantic.Shader.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BC %fo OpExecutionMode %main OriginUpperLeft %file_name = OpString "test" OpSource GLSL 140 %float_name = OpString "float" %main_name = OpString "main" %f_name = OpString "f" %i_name = OpString "i" OpName %main "main" OpName %f "f" OpName %i "i" OpName %BC "BC" OpName %fo "fo" %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_3 = OpConstant %uint 3 %uint_4 = OpConstant %uint 4 %uint_5 = OpConstant %uint 5 %uint_10 = OpConstant %uint 10 %uint_32 = OpConstant %uint 32 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_4 = OpConstant %int 4 %bool = OpTypeBool %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %BC = OpVariable %_ptr_Input_v4float Input %_ptr_Input_float = OpTypePointer Input %float %int_1 = OpConstant %int 1 %_ptr_Output_float = OpTypePointer Output %float %fo = OpVariable %_ptr_Output_float Output %null_expr = OpExtInst %void %ext DebugExpression %src = OpExtInst %void %ext DebugSource %file_name %cu = OpExtInst %void %ext DebugCompilationUnit %uint_1 %uint_4 %src %uint_5 %dbg_tf = OpExtInst %void %ext DebugTypeBasic %float_name %uint_32 %uint_3 %uint_0 %dbg_v4f = OpExtInst %void %ext DebugTypeVector %dbg_tf %uint_4 %main_ty = OpExtInst %void %ext DebugTypeFunction %uint_3 %dbg_v4f %dbg_v4f %dbg_main = OpExtInst %void %ext DebugFunction %main_name %main_ty %src %uint_0 %uint_0 %cu %main_name %uint_3 %uint_10 %dbg_f = OpExtInst %void %ext DebugLocalVariable %f_name %dbg_v4f %src %uint_0 %uint_0 %dbg_main %uint_4 %dbg_i = OpExtInst %void %ext DebugLocalVariable %i_name %dbg_v4f %src %uint_0 %uint_0 %dbg_main %uint_4 %main = OpFunction %void None %8 %22 = OpLabel %s0 = OpExtInst %void %ext DebugScope %dbg_main %f = OpVariable %_ptr_Function_float Function %i = OpVariable %_ptr_Function_int Function OpStore %f %float_0 OpStore %i %int_0 %decl0 = OpExtInst %void %ext DebugDeclare %dbg_f %f %null_expr %decl1 = OpExtInst %void %ext DebugDeclare %dbg_i %i %null_expr OpBranch %23 %23 = OpLabel %s1 = OpExtInst %void %ext DebugScope %dbg_main OpLoopMerge %24 %25 None OpBranch %26 %26 = OpLabel %s2 = OpExtInst %void %ext DebugScope %dbg_main %27 = OpLoad %int %i %28 = OpSLessThan %bool %27 %int_4 OpBranchConditional %28 %29 %24 %29 = OpLabel %s3 = OpExtInst %void %ext DebugScope %dbg_main %30 = OpLoad %float %f %31 = OpLoad %int %i %32 = OpAccessChain %_ptr_Input_float %BC %31 %33 = OpLoad %float %32 %34 = OpFAdd %float %30 %33 OpStore %f %34 OpBranch %25 %25 = OpLabel %s4 = OpExtInst %void %ext DebugScope %dbg_main %35 = OpLoad %int %i %36 = OpIAdd %int %35 %int_1 OpStore %i %36 OpBranch %23 %24 = OpLabel %s5 = OpExtInst %void %ext DebugScope %dbg_main %37 = OpLoad %float %f OpStore %fo %37 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(LocalSSAElimTest, AddDebugValueForFunctionParameterWithPhi) { // Test the distribution of DebugValue for a parameter of an inlined function // and the visibility of Phi instruction. The ssa-rewrite pass must add // DebugValue for the value assignment of function argument even when it is an // inlined function. It has to check the visibility Phi through all its value // operands. See the DebugValue for "int i" of "foo()" in the following code. // // struct VS_OUTPUT { // float4 pos : SV_POSITION; // float4 color : COLOR; // }; // // float4 foo(int i, float4 pos) { // while (i < pos.x) { // pos = pos.x + i; // ++i; // } // return pos; // } // // VS_OUTPUT main(float4 pos : POSITION, // float4 color : COLOR) { // VS_OUTPUT vout; // vout.pos = foo(4, pos); // vout.color = color; // return vout; // } const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %in_var_POSITION %in_var_COLOR %gl_Position %out_var_COLOR %7 = OpString "vertex.hlsl" %8 = OpString "float" %9 = OpString "VS_OUTPUT" %10 = OpString "color" %11 = OpString "pos" %12 = OpString "int" %13 = OpString "foo" %14 = OpString "" %15 = OpString "i" %16 = OpString "main" %17 = OpString "vout" OpName %in_var_POSITION "in.var.POSITION" OpName %in_var_COLOR "in.var.COLOR" OpName %out_var_COLOR "out.var.COLOR" OpName %main "main" OpName %param_var_pos "param.var.pos" OpName %param_var_color "param.var.color" OpName %VS_OUTPUT "VS_OUTPUT" OpMemberName %VS_OUTPUT 0 "pos" OpMemberName %VS_OUTPUT 1 "color" OpDecorate %gl_Position BuiltIn Position OpDecorate %in_var_POSITION Location 0 OpDecorate %in_var_COLOR Location 1 OpDecorate %out_var_COLOR Location 0 %int = OpTypeInt 32 1 %int_4 = OpConstant %int 4 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %uint_256 = OpConstant %uint 256 %uint_128 = OpConstant %uint 128 %uint_0 = OpConstant %uint 0 %50 = OpTypeFunction %void %_ptr_Function_v4float = OpTypePointer Function %v4float %VS_OUTPUT = OpTypeStruct %v4float %v4float %_ptr_Function_int = OpTypePointer Function %int %_ptr_Function_float = OpTypePointer Function %float %bool = OpTypeBool %in_var_POSITION = OpVariable %_ptr_Input_v4float Input %in_var_COLOR = OpVariable %_ptr_Input_v4float Input %gl_Position = OpVariable %_ptr_Output_v4float Output %out_var_COLOR = OpVariable %_ptr_Output_v4float Output %156 = OpExtInst %void %1 DebugInfoNone %77 = OpExtInst %void %1 DebugExpression %58 = OpExtInst %void %1 DebugTypeBasic %8 %uint_32 Float %59 = OpExtInst %void %1 DebugTypeVector %58 4 %60 = OpExtInst %void %1 DebugSource %7 %61 = OpExtInst %void %1 DebugCompilationUnit 1 4 %60 HLSL %62 = OpExtInst %void %1 DebugTypeComposite %9 Structure %60 1 8 %61 %9 %uint_256 FlagIsProtected|FlagIsPrivate %63 %64 %64 = OpExtInst %void %1 DebugTypeMember %10 %59 %60 3 10 %62 %uint_128 %uint_128 FlagIsProtected|FlagIsPrivate %63 = OpExtInst %void %1 DebugTypeMember %11 %59 %60 2 10 %62 %uint_0 %uint_128 FlagIsProtected|FlagIsPrivate %65 = OpExtInst %void %1 DebugTypeBasic %12 %uint_32 Signed %66 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %59 %65 %59 %67 = OpExtInst %void %1 DebugFunction %13 %66 %60 6 1 %61 %14 FlagIsProtected|FlagIsPrivate 6 %156 %68 = OpExtInst %void %1 DebugLexicalBlock %60 6 31 %67 %69 = OpExtInst %void %1 DebugLexicalBlock %60 7 21 %68 %70 = OpExtInst %void %1 DebugLocalVariable %11 %59 %60 6 26 %67 FlagIsLocal 2 ; CHECK: [[color_name:%\w+]] = OpString "color" ; CHECK: [[pos_name:%\w+]] = OpString "pos" ; CHECK: [[i_name:%\w+]] = OpString "i" ; CHECK: [[null_expr:%\w+]] = OpExtInst %void [[ext:%\w+]] DebugExpression ; CHECK: [[dbg_i:%\w+]] = OpExtInst %void [[ext]] DebugLocalVariable [[i_name]] {{%\w+}} {{%\w+}} 6 16 {{%\w+}} FlagIsLocal 1 ; CHECK: [[dbg_color:%\w+]] = OpExtInst %void [[ext]] DebugLocalVariable [[color_name]] {{%\w+}} {{%\w+}} 15 23 ; CHECK: [[dbg_pos:%\w+]] = OpExtInst %void [[ext]] DebugLocalVariable [[pos_name]] {{%\w+}} {{%\w+}} 14 23 %71 = OpExtInst %void %1 DebugLocalVariable %15 %65 %60 6 16 %67 FlagIsLocal 1 %72 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %62 %59 %59 %73 = OpExtInst %void %1 DebugFunction %16 %72 %60 14 1 %61 %14 FlagIsProtected|FlagIsPrivate 15 %156 %74 = OpExtInst %void %1 DebugLexicalBlock %60 15 38 %73 %75 = OpExtInst %void %1 DebugLocalVariable %17 %62 %60 16 13 %74 FlagIsLocal %76 = OpExtInst %void %1 DebugLocalVariable %10 %59 %60 15 23 %73 FlagIsLocal 2 %78 = OpExtInst %void %1 DebugLocalVariable %11 %59 %60 14 23 %73 FlagIsLocal 1 %155 = OpExtInst %void %1 DebugInlinedAt 17 %74 %main = OpFunction %void None %50 %79 = OpLabel %168 = OpExtInst %void %1 DebugScope %74 ; CHECK: [[i:%\w+]] = OpVariable %_ptr_Function_int Function %120 = OpVariable %_ptr_Function_int Function %121 = OpVariable %_ptr_Function_v4float Function %169 = OpExtInst %void %1 DebugNoScope %param_var_pos = OpVariable %_ptr_Function_v4float Function %param_var_color = OpVariable %_ptr_Function_v4float Function OpLine %7 100 105 %80 = OpLoad %v4float %in_var_POSITION OpStore %param_var_pos %80 OpNoLine OpLine %7 200 205 %81 = OpLoad %v4float %in_var_COLOR OpStore %param_var_color %81 OpNoLine %170 = OpExtInst %void %1 DebugScope %73 ; CHECK: OpLine {{%\w+}} 100 105 ; CHECK: DebugValue [[dbg_pos]] %124 = OpExtInst %void %1 DebugDeclare %78 %param_var_pos %77 ; CHECK: OpLine {{%\w+}} 200 205 ; CHECK: DebugValue [[dbg_color]] %125 = OpExtInst %void %1 DebugDeclare %76 %param_var_color %77 %171 = OpExtInst %void %1 DebugScope %74 OpLine %7 17 18 ; CHECK: OpStore {{%\w+}} %int_4 ; CHECK: DebugValue [[dbg_i]] %int_4 [[null_expr]] OpStore %120 %int_4 OpStore %121 %80 %172 = OpExtInst %void %1 DebugScope %67 %155 %135 = OpExtInst %void %1 DebugDeclare %71 %120 %77 %136 = OpExtInst %void %1 DebugDeclare %70 %121 %77 %173 = OpExtInst %void %1 DebugScope %68 %155 OpLine %7 7 3 OpBranch %137 %174 = OpExtInst %void %1 DebugNoScope %137 = OpLabel ; CHECK: [[phi:%\w+]] = OpPhi %int %int_4 ; CHECK: DebugValue [[dbg_i]] [[phi]] [[null_expr]] %175 = OpExtInst %void %1 DebugScope %68 %155 OpLine %7 7 10 %138 = OpLoad %int %120 %139 = OpConvertSToF %float %138 OpLine %7 7 14 %140 = OpAccessChain %_ptr_Function_float %121 %int_0 %141 = OpLoad %float %140 OpLine %7 7 12 %142 = OpFOrdLessThan %bool %139 %141 OpLine %7 7 3 %176 = OpExtInst %void %1 DebugNoScope OpLoopMerge %153 %152 None OpBranchConditional %142 %143 %153 %177 = OpExtInst %void %1 DebugNoScope %143 = OpLabel %178 = OpExtInst %void %1 DebugScope %69 %155 OpLine %7 8 11 %144 = OpAccessChain %_ptr_Function_float %121 %int_0 %145 = OpLoad %float %144 OpLine %7 8 19 %146 = OpLoad %int %120 %147 = OpConvertSToF %float %146 OpLine %7 8 17 %148 = OpFAdd %float %145 %147 OpLine %7 8 11 %149 = OpCompositeConstruct %v4float %148 %148 %148 %148 OpLine %7 8 5 OpStore %121 %149 OpLine %7 9 5 %151 = OpIAdd %int %146 %int_1 OpLine %7 9 7 ; CHECK: OpStore [[i]] [[value:%\w+]] ; CHECK: DebugValue [[dbg_i]] [[value]] [[null_expr]] OpStore %120 %151 %179 = OpExtInst %void %1 DebugScope %68 %155 OpLine %7 10 3 OpBranch %152 %180 = OpExtInst %void %1 DebugNoScope %152 = OpLabel %181 = OpExtInst %void %1 DebugScope %68 %155 OpBranch %137 %182 = OpExtInst %void %1 DebugNoScope %153 = OpLabel %183 = OpExtInst %void %1 DebugScope %68 %155 OpLine %7 11 10 %154 = OpLoad %v4float %121 %184 = OpExtInst %void %1 DebugScope %74 %167 = OpExtInst %void %1 DebugValue %75 %154 %77 %int_0 %166 = OpExtInst %void %1 DebugValue %75 %81 %77 %int_1 OpLine %7 19 10 %165 = OpCompositeConstruct %VS_OUTPUT %154 %81 %185 = OpExtInst %void %1 DebugNoScope %83 = OpCompositeExtract %v4float %165 0 OpStore %gl_Position %83 %84 = OpCompositeExtract %v4float %165 1 OpStore %out_var_COLOR %84 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(LocalSSAElimTest, DebugValueWithIndexesInForLoop) { // #version 140 // // in vec4 BC; // out float fo; // // struct T { // float a; // float f; // }; // // struct value { // int x; // int y; // T z; // }; // // void main() // { // value v; // v.z.f = 0.0; // for (int i=0; i<4; i++) { // v.z.f = v.z.f + BC[i]; // } // fo = v.z.f; // } const std::string text = R"( ; CHECK: [[f_name:%\w+]] = OpString "f" ; CHECK: [[dbg_f:%\w+]] = OpExtInst %void [[ext:%\d+]] DebugLocalVariable [[f_name]] ; CHECK: OpStore %f %float_0 ; CHECK-NEXT: OpExtInst %void [[ext]] DebugValue [[dbg_f]] %float_0 [[null_expr:%\d+]] %int_2 %int_1 ; CHECK-NOT: DebugDeclare ; CHECK: [[loop_head:%\w+]] = OpLabel ; CHECK: [[phi0:%\w+]] = OpPhi %float %float_0 ; CHECK: OpExtInst %void [[ext]] DebugValue [[dbg_f]] [[phi0]] [[null_expr]] %int_2 %int_1 ; CHECK: OpLoopMerge [[loop_merge:%\w+]] [[loop_cont:%\w+]] None ; CHECK-NEXT: OpBranch [[loop_body:%\w+]] ; CHECK-NEXT: [[loop_body]] = OpLabel ; CHECK: OpBranchConditional {{%\w+}} [[bb:%\w+]] [[loop_merge]] ; CHECK: [[bb]] = OpLabel ; CHECK: OpStore %f [[f_val:%\w+]] ; CHECK-NEXT: OpExtInst %void [[ext]] DebugValue [[dbg_f]] [[f_val]] [[null_expr]] %int_2 %int_1 ; CHECK-NEXT: OpBranch [[loop_cont]] ; CHECK: [[loop_cont]] = OpLabel ; CHECK: OpBranch [[loop_head]] ; CHECK: [[loop_merge]] = OpLabel OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" %ext = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BC %fo OpExecutionMode %main OriginUpperLeft %file_name = OpString "test" OpSource GLSL 140 %float_name = OpString "float" %main_name = OpString "main" %f_name = OpString "f" %i_name = OpString "i" OpName %main "main" OpName %f "f" OpName %i "i" OpName %BC "BC" OpName %fo "fo" %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_4 = OpConstant %int 4 %bool = OpTypeBool %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %BC = OpVariable %_ptr_Input_v4float Input %_ptr_Input_float = OpTypePointer Input %float %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %_ptr_Output_float = OpTypePointer Output %float %fo = OpVariable %_ptr_Output_float Output %deref = OpExtInst %void %ext DebugOperation Deref %null_expr = OpExtInst %void %ext DebugExpression %deref_expr = OpExtInst %void %ext DebugExpression %deref %src = OpExtInst %void %ext DebugSource %file_name %cu = OpExtInst %void %ext DebugCompilationUnit 1 4 %src HLSL %dbg_tf = OpExtInst %void %ext DebugTypeBasic %float_name %uint_32 Float %dbg_v4f = OpExtInst %void %ext DebugTypeVector %dbg_tf 4 %main_ty = OpExtInst %void %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %dbg_v4f %dbg_v4f %dbg_main = OpExtInst %void %ext DebugFunction %main_name %main_ty %src 0 0 %cu %main_name FlagIsProtected|FlagIsPrivate 10 %main %dbg_f = OpExtInst %void %ext DebugLocalVariable %f_name %dbg_v4f %src 0 0 %dbg_main FlagIsLocal %dbg_i = OpExtInst %void %ext DebugLocalVariable %i_name %dbg_v4f %src 0 0 %dbg_main FlagIsLocal %main = OpFunction %void None %8 %22 = OpLabel %s0 = OpExtInst %void %ext DebugScope %dbg_main %f = OpVariable %_ptr_Function_float Function %i = OpVariable %_ptr_Function_int Function OpStore %f %float_0 OpStore %i %int_0 %decl0 = OpExtInst %void %ext DebugValue %dbg_f %f %deref_expr %int_2 %int_1 %decl1 = OpExtInst %void %ext DebugDeclare %dbg_i %i %null_expr OpBranch %23 %23 = OpLabel %s1 = OpExtInst %void %ext DebugScope %dbg_main OpLoopMerge %24 %25 None OpBranch %26 %26 = OpLabel %s2 = OpExtInst %void %ext DebugScope %dbg_main %27 = OpLoad %int %i %28 = OpSLessThan %bool %27 %int_4 OpBranchConditional %28 %29 %24 %29 = OpLabel %s3 = OpExtInst %void %ext DebugScope %dbg_main %30 = OpLoad %float %f %31 = OpLoad %int %i %32 = OpAccessChain %_ptr_Input_float %BC %31 %33 = OpLoad %float %32 %34 = OpFAdd %float %30 %33 OpStore %f %34 OpBranch %25 %25 = OpLabel %s4 = OpExtInst %void %ext DebugScope %dbg_main %35 = OpLoad %int %i %36 = OpIAdd %int %35 %int_1 OpStore %i %36 OpBranch %23 %24 = OpLabel %s5 = OpExtInst %void %ext DebugScope %dbg_main %37 = OpLoad %float %f OpStore %fo %37 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(LocalSSAElimTest, PartiallyKillDebugDeclare) { // For a reference variable e.g., int i in the following example, // we do not propagate DebugValue for a store or phi instruction // out of the variable's scope. In that case, we should not remove // DebugDeclare for the variable that we did not add its DebugValue. // // #version 140 // // in vec4 BC; // out float fo; // // int j; // void main() // { // float f = 0.0; // for (j=0; j<4; j++) { // int& i = j; // f = f + BC[i]; // } // fo = f; // } const std::string text = R"( ; CHECK: [[f_name:%\w+]] = OpString "f" ; CHECK: [[i_name:%\w+]] = OpString "i" ; CHECK: [[fn:%\w+]] = OpExtInst %void [[ext:%\d+]] DebugFunction ; CHECK: [[bb:%\w+]] = OpExtInst %void [[ext]] DebugLexicalBlock ; CHECK: [[dbg_f:%\w+]] = OpExtInst %void [[ext]] DebugLocalVariable [[f_name]] {{%\w+}} {{%\w+}} 0 0 [[fn]] ; CHECK: [[dbg_i:%\w+]] = OpExtInst %void [[ext]] DebugLocalVariable [[i_name]] {{%\w+}} {{%\w+}} 0 0 [[bb]] ; CHECK: OpStore %f %float_0 ; CHECK-NEXT: OpExtInst %void [[ext]] DebugValue [[dbg_f]] %float_0 ; CHECK-NOT: DebugDeclare [[dbg_f]] ; CHECK: OpExtInst %void [[ext]] DebugDeclare [[dbg_i]] %j OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" %ext = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BC %fo OpExecutionMode %main OriginUpperLeft %file_name = OpString "test" OpSource GLSL 140 %float_name = OpString "float" %main_name = OpString "main" %f_name = OpString "f" %i_name = OpString "i" %j_name = OpString "j" OpName %main "main" OpName %f "f" OpName %j "j" OpName %BC "BC" OpName %fo "fo" %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %_ptr_Function_int = OpTypePointer Function %int %_ptr_Private_int = OpTypePointer Private %int %int_0 = OpConstant %int 0 %int_4 = OpConstant %int 4 %bool = OpTypeBool %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %BC = OpVariable %_ptr_Input_v4float Input %_ptr_Input_float = OpTypePointer Input %float %int_1 = OpConstant %int 1 %_ptr_Output_float = OpTypePointer Output %float %fo = OpVariable %_ptr_Output_float Output %j = OpVariable %_ptr_Private_int Private %null_expr = OpExtInst %void %ext DebugExpression %src = OpExtInst %void %ext DebugSource %file_name %cu = OpExtInst %void %ext DebugCompilationUnit 1 4 %src HLSL %dbg_tf = OpExtInst %void %ext DebugTypeBasic %float_name %uint_32 Float %dbg_v4f = OpExtInst %void %ext DebugTypeVector %dbg_tf 4 %main_ty = OpExtInst %void %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %dbg_v4f %dbg_v4f %dbg_main = OpExtInst %void %ext DebugFunction %main_name %main_ty %src 0 0 %cu %main_name FlagIsProtected|FlagIsPrivate 10 %main %bb = OpExtInst %void %ext DebugLexicalBlock %src 0 0 %dbg_main %dbg_f = OpExtInst %void %ext DebugLocalVariable %f_name %dbg_v4f %src 0 0 %dbg_main FlagIsLocal %dbg_i = OpExtInst %void %ext DebugLocalVariable %i_name %dbg_v4f %src 0 0 %bb FlagIsLocal %dbg_j = OpExtInst %void %ext DebugGlobalVariable %j_name %dbg_v4f %src 0 0 %dbg_main %j_name %j FlagIsPrivate %main = OpFunction %void None %8 %22 = OpLabel %s0 = OpExtInst %void %ext DebugScope %dbg_main %f = OpVariable %_ptr_Function_float Function OpStore %f %float_0 OpStore %j %int_0 %decl0 = OpExtInst %void %ext DebugDeclare %dbg_f %f %null_expr OpBranch %23 %23 = OpLabel %s1 = OpExtInst %void %ext DebugScope %dbg_main OpLoopMerge %24 %25 None OpBranch %26 %26 = OpLabel %s2 = OpExtInst %void %ext DebugScope %dbg_main %27 = OpLoad %int %j %28 = OpSLessThan %bool %27 %int_4 OpBranchConditional %28 %29 %24 %29 = OpLabel %s3 = OpExtInst %void %ext DebugScope %bb %decl1 = OpExtInst %void %ext DebugDeclare %dbg_i %j %null_expr %30 = OpLoad %float %f %31 = OpLoad %int %j %32 = OpAccessChain %_ptr_Input_float %BC %31 %33 = OpLoad %float %32 %34 = OpFAdd %float %30 %33 OpStore %f %34 OpBranch %25 %25 = OpLabel %s4 = OpExtInst %void %ext DebugScope %dbg_main %35 = OpLoad %int %j %36 = OpIAdd %int %35 %int_1 OpStore %j %36 OpBranch %23 %24 = OpLabel %s5 = OpExtInst %void %ext DebugScope %dbg_main %37 = OpLoad %float %f OpStore %fo %37 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(LocalSSAElimTest, DebugValueForReferenceVariable) { // #version 140 // // in vec4 BC; // out float fo; // // void main() // { // float f = 0.0; // float& x = f; // for (int i=0; i<4; i++) { // x = x + BC[i]; // } // fo = f; // } const std::string text = R"( ; CHECK: [[f_name:%\w+]] = OpString "f" ; CHECK: [[i_name:%\w+]] = OpString "i" ; CHECK: [[x_name:%\w+]] = OpString "x" ; CHECK: [[dbg_f:%\w+]] = OpExtInst %void [[ext:%\d+]] DebugLocalVariable [[f_name]] ; CHECK: [[dbg_i:%\w+]] = OpExtInst %void [[ext]] DebugLocalVariable [[i_name]] ; CHECK: [[dbg_x:%\w+]] = OpExtInst %void [[ext]] DebugLocalVariable [[x_name]] ; CHECK: OpStore %f %float_0 ; CHECK-DAG: OpExtInst %void [[ext]] DebugValue [[dbg_f]] %float_0 ; CHECK-DAG: OpExtInst %void [[ext]] DebugValue [[dbg_x]] %float_0 ; CHECK: OpStore %i %int_0 ; CHECK-NEXT: OpExtInst %void [[ext]] DebugValue [[dbg_i]] %int_0 ; CHECK-NOT: DebugDeclare ; CHECK: [[loop_head:%\w+]] = OpLabel ; CHECK: [[phi0:%\w+]] = OpPhi %float %float_0 ; CHECK: [[phi1:%\w+]] = OpPhi %int %int_0 ; CHECK-DAG: OpExtInst %void [[ext]] DebugValue [[dbg_f]] [[phi0]] ; CHECK-DAG: OpExtInst %void [[ext]] DebugValue [[dbg_x]] [[phi0]] ; CHECK: OpExtInst %void [[ext]] DebugValue [[dbg_i]] [[phi1]] ; CHECK: OpLoopMerge [[loop_merge:%\w+]] [[loop_cont:%\w+]] None ; CHECK-NEXT: OpBranch [[loop_body:%\w+]] ; CHECK: [[loop_body]] = OpLabel ; CHECK: OpBranchConditional {{%\w+}} [[bb:%\w+]] [[loop_merge]] ; CHECK: [[bb]] = OpLabel ; CHECK: OpStore %f [[f_val:%\w+]] ; CHECK-DAG: OpExtInst %void [[ext]] DebugValue [[dbg_f]] [[f_val]] ; CHECK-DAG: OpExtInst %void [[ext]] DebugValue [[dbg_x]] [[f_val]] ; CHECK: OpBranch [[loop_cont]] ; CHECK: [[loop_cont]] = OpLabel ; CHECK: OpStore %i [[i_val:%\w+]] ; CHECK-NEXT: OpExtInst %void [[ext]] DebugValue [[dbg_i]] [[i_val]] ; CHECK-NEXT: OpBranch [[loop_head]] ; CHECK: [[loop_merge]] = OpLabel OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" %ext = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BC %fo OpExecutionMode %main OriginUpperLeft %file_name = OpString "test" OpSource GLSL 140 %float_name = OpString "float" %main_name = OpString "main" %f_name = OpString "f" %i_name = OpString "i" %x_name = OpString "x" OpName %main "main" OpName %f "f" OpName %i "i" OpName %BC "BC" OpName %fo "fo" %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_4 = OpConstant %int 4 %bool = OpTypeBool %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %BC = OpVariable %_ptr_Input_v4float Input %_ptr_Input_float = OpTypePointer Input %float %int_1 = OpConstant %int 1 %_ptr_Output_float = OpTypePointer Output %float %fo = OpVariable %_ptr_Output_float Output %null_expr = OpExtInst %void %ext DebugExpression %src = OpExtInst %void %ext DebugSource %file_name %cu = OpExtInst %void %ext DebugCompilationUnit 1 4 %src HLSL %dbg_tf = OpExtInst %void %ext DebugTypeBasic %float_name %uint_32 Float %dbg_v4f = OpExtInst %void %ext DebugTypeVector %dbg_tf 4 %main_ty = OpExtInst %void %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %dbg_v4f %dbg_v4f %dbg_main = OpExtInst %void %ext DebugFunction %main_name %main_ty %src 0 0 %cu %main_name FlagIsProtected|FlagIsPrivate 10 %main %dbg_f = OpExtInst %void %ext DebugLocalVariable %f_name %dbg_v4f %src 0 0 %dbg_main FlagIsLocal %dbg_i = OpExtInst %void %ext DebugLocalVariable %i_name %dbg_v4f %src 1 0 %dbg_main FlagIsLocal %dbg_x = OpExtInst %void %ext DebugLocalVariable %x_name %dbg_v4f %src 2 0 %dbg_main FlagIsLocal %main = OpFunction %void None %8 %22 = OpLabel %s0 = OpExtInst %void %ext DebugScope %dbg_main %f = OpVariable %_ptr_Function_float Function %i = OpVariable %_ptr_Function_int Function OpStore %f %float_0 OpStore %i %int_0 %decl0 = OpExtInst %void %ext DebugDeclare %dbg_f %f %null_expr %decl1 = OpExtInst %void %ext DebugDeclare %dbg_i %i %null_expr %decl2 = OpExtInst %void %ext DebugDeclare %dbg_x %f %null_expr OpBranch %23 %23 = OpLabel %s1 = OpExtInst %void %ext DebugScope %dbg_main OpLoopMerge %24 %25 None OpBranch %26 %26 = OpLabel %s2 = OpExtInst %void %ext DebugScope %dbg_main %27 = OpLoad %int %i %28 = OpSLessThan %bool %27 %int_4 OpBranchConditional %28 %29 %24 %29 = OpLabel %s3 = OpExtInst %void %ext DebugScope %dbg_main %30 = OpLoad %float %f %31 = OpLoad %int %i %32 = OpAccessChain %_ptr_Input_float %BC %31 %33 = OpLoad %float %32 %34 = OpFAdd %float %30 %33 OpStore %f %34 OpBranch %25 %25 = OpLabel %s4 = OpExtInst %void %ext DebugScope %dbg_main %35 = OpLoad %int %i %36 = OpIAdd %int %35 %int_1 OpStore %i %36 OpBranch %23 %24 = OpLabel %s5 = OpExtInst %void %ext DebugScope %dbg_main %37 = OpLoad %float %f OpStore %fo %37 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(LocalSSAElimTest, DebugValueForReferenceVariableInBB) { // #version 140 // // in vec4 BC; // out float fo; // // void main() // { // float f = 0.0; // for (int i=0; i<4; i++) { // float& x = f; // x = x + BC[i]; // { // x = x + BC[i]; // } // } // fo = f; // } const std::string text = R"( ; CHECK: [[f_name:%\w+]] = OpString "f" ; CHECK: [[i_name:%\w+]] = OpString "i" ; CHECK: [[x_name:%\w+]] = OpString "x" ; CHECK: [[dbg_main:%\w+]] = OpExtInst %void [[ext:%\d+]] DebugFunction ; CHECK: [[dbg_bb:%\w+]] = OpExtInst %void [[ext]] DebugLexicalBlock ; CHECK: [[dbg_bb_child:%\w+]] = OpExtInst %void [[ext]] DebugLexicalBlock ; CHECK: [[dbg_f:%\w+]] = OpExtInst %void [[ext]] DebugLocalVariable [[f_name]] ; CHECK: [[dbg_i:%\w+]] = OpExtInst %void [[ext]] DebugLocalVariable [[i_name]] ; CHECK: [[dbg_x:%\w+]] = OpExtInst %void [[ext]] DebugLocalVariable [[x_name]] ; CHECK: OpExtInst %void [[ext]] DebugScope [[dbg_main]] ; CHECK: OpStore %f %float_0 ; CHECK-NEXT: OpExtInst %void [[ext]] DebugValue [[dbg_x]] %float_0 ; CHECK-NEXT: OpExtInst %void [[ext]] DebugValue [[dbg_f]] %float_0 ; CHECK-NEXT: OpStore %i %int_0 ; CHECK-NEXT: OpExtInst %void [[ext]] DebugValue [[dbg_i]] %int_0 ; CHECK-NOT: DebugDeclare ; CHECK: [[loop_head:%\w+]] = OpLabel ; CHECK: OpExtInst %void [[ext]] DebugScope [[dbg_main]] ; CHECK: [[phi0:%\w+]] = OpPhi %float %float_0 ; CHECK: [[phi1:%\w+]] = OpPhi %int %int_0 ; CHECK-DAG: OpExtInst %void [[ext]] DebugValue [[dbg_f]] [[phi0]] ; CHECK-DAG: OpExtInst %void [[ext]] DebugValue [[dbg_x]] [[phi0]] ; CHECK-DAG: OpExtInst %void [[ext]] DebugValue [[dbg_i]] [[phi1]] ; CHECK: OpLoopMerge [[loop_merge:%\w+]] [[loop_cont:%\w+]] None ; CHECK-NEXT: OpBranch [[loop_body:%\w+]] ; CHECK-NEXT: [[loop_body]] = OpLabel ; CHECK: OpBranchConditional {{%\w+}} [[bb:%\w+]] [[loop_merge]] ; CHECK: [[bb]] = OpLabel ; CHECK: OpExtInst %void [[ext]] DebugScope [[dbg_bb]] ; CHECK: OpStore %f [[f_val:%\w+]] ; CHECK-DAG: OpExtInst %void [[ext]] DebugValue [[dbg_f]] [[f_val]] ; CHECK-DAG: OpExtInst %void [[ext]] DebugValue [[dbg_x]] [[f_val]] ; CHECK: OpBranch [[bb_child:%\w+]] ; CHECK: [[bb_child]] = OpLabel ; CHECK: OpExtInst %void [[ext]] DebugScope [[dbg_bb_child]] ; CHECK: OpStore %f [[new_f_val:%\w+]] ; CHECK-DAG: OpExtInst %void [[ext]] DebugValue [[dbg_f]] [[new_f_val]] ; CHECK-DAG: OpExtInst %void [[ext]] DebugValue [[dbg_x]] [[new_f_val]] ; CHECK: OpBranch [[loop_cont]] ; CHECK: [[loop_cont]] = OpLabel ; CHECK: OpStore %i [[i_val:%\w+]] ; CHECK-NEXT: OpExtInst %void [[ext]] DebugValue [[dbg_i]] [[i_val]] ; CHECK-NEXT: OpBranch [[loop_head]] ; CHECK: [[loop_merge]] = OpLabel OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" %ext = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BC %fo OpExecutionMode %main OriginUpperLeft %file_name = OpString "test" OpSource GLSL 140 %float_name = OpString "float" %main_name = OpString "main" %f_name = OpString "f" %i_name = OpString "i" %x_name = OpString "x" OpName %main "main" OpName %f "f" OpName %i "i" OpName %BC "BC" OpName %fo "fo" %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_4 = OpConstant %int 4 %bool = OpTypeBool %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %BC = OpVariable %_ptr_Input_v4float Input %_ptr_Input_float = OpTypePointer Input %float %int_1 = OpConstant %int 1 %_ptr_Output_float = OpTypePointer Output %float %fo = OpVariable %_ptr_Output_float Output %null_expr = OpExtInst %void %ext DebugExpression %src = OpExtInst %void %ext DebugSource %file_name %cu = OpExtInst %void %ext DebugCompilationUnit 1 4 %src HLSL %dbg_tf = OpExtInst %void %ext DebugTypeBasic %float_name %uint_32 Float %dbg_v4f = OpExtInst %void %ext DebugTypeVector %dbg_tf 4 %main_ty = OpExtInst %void %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %dbg_v4f %dbg_v4f %dbg_main = OpExtInst %void %ext DebugFunction %main_name %main_ty %src 0 0 %cu %main_name FlagIsProtected|FlagIsPrivate 10 %main %bb = OpExtInst %void %ext DebugLexicalBlock %src 0 0 %dbg_main %bb_child = OpExtInst %void %ext DebugLexicalBlock %src 1 0 %bb %dbg_f = OpExtInst %void %ext DebugLocalVariable %f_name %dbg_v4f %src 0 0 %dbg_main FlagIsLocal %dbg_i = OpExtInst %void %ext DebugLocalVariable %i_name %dbg_v4f %src 1 0 %dbg_main FlagIsLocal %dbg_x = OpExtInst %void %ext DebugLocalVariable %x_name %dbg_v4f %src 2 0 %bb FlagIsLocal %main = OpFunction %void None %8 %22 = OpLabel %s0 = OpExtInst %void %ext DebugScope %dbg_main %f = OpVariable %_ptr_Function_float Function %i = OpVariable %_ptr_Function_int Function OpStore %f %float_0 OpStore %i %int_0 %decl0 = OpExtInst %void %ext DebugDeclare %dbg_f %f %null_expr %decl1 = OpExtInst %void %ext DebugDeclare %dbg_i %i %null_expr OpBranch %23 %23 = OpLabel %s1 = OpExtInst %void %ext DebugScope %dbg_main OpLoopMerge %24 %25 None OpBranch %26 %26 = OpLabel %s2 = OpExtInst %void %ext DebugScope %dbg_main %27 = OpLoad %int %i %28 = OpSLessThan %bool %27 %int_4 OpBranchConditional %28 %29 %24 %29 = OpLabel %scope = OpExtInst %void %ext DebugScope %bb %decl2 = OpExtInst %void %ext DebugDeclare %dbg_x %f %null_expr %30 = OpLoad %float %f %31 = OpLoad %int %i %32 = OpAccessChain %_ptr_Input_float %BC %31 %33 = OpLoad %float %32 %34 = OpFAdd %float %30 %33 OpStore %f %34 OpBranch %38 %38 = OpLabel %child_scope = OpExtInst %void %ext DebugScope %bb_child %39 = OpLoad %float %f %40 = OpFAdd %float %39 %33 OpStore %f %40 OpBranch %25 %25 = OpLabel %s3 = OpExtInst %void %ext DebugScope %dbg_main %35 = OpLoad %int %i %36 = OpIAdd %int %35 %int_1 OpStore %i %36 OpBranch %23 %24 = OpLabel %s4 = OpExtInst %void %ext DebugScope %dbg_main %37 = OpLoad %float %f OpStore %fo %37 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(LocalSSAElimTest, DebugForLoopUseDebugValueInsteadOfDebugDeclare) { // #version 140 // // in vec4 BC; // out float fo; // // struct S { // float f; // int i; // }; // // void main() // { // S foo = {0.0, 0}; // for (; foo.i<4; foo.i++) { // foo.f = foo.f + BC[foo.i]; // } // fo = foo.f; // } const std::string text = R"( ; CHECK: [[f_name:%\w+]] = OpString "f" ; CHECK: [[empty_expr:%\w+]] = OpExtInst %void [[ext:%\d+]] DebugExpression ; CHECK: [[deref_op:%\w+]] = OpExtInst %void [[ext]] DebugOperation Deref ; CHECK: [[deref:%\w+]] = OpExtInst %void [[ext]] DebugExpression [[deref_op]] ; CHECK: [[dbg_foo:%\w+]] = OpExtInst %void [[ext]] DebugLocalVariable [[f_name]] ; CHECK: OpStore %f %float_0 ; CHECK-NEXT: OpExtInst %void [[ext]] DebugValue [[dbg_foo]] %float_0 [[empty_expr]] %uint_0 ; CHECK-NEXT: OpStore %i %int_0 ; CHECK-NEXT: OpExtInst %void [[ext]] DebugValue [[dbg_foo]] %int_0 [[empty_expr]] %uint_1 ; CHECK: [[loop_head:%\w+]] = OpLabel ; CHECK: [[phi0:%\w+]] = OpPhi %float %float_0 ; CHECK: [[phi1:%\w+]] = OpPhi %int %int_0 ; CHECK-NEXT: OpExtInst %void [[ext]] DebugValue [[dbg_foo]] [[phi0]] [[empty_expr]] %uint_0 ; CHECK-NEXT: OpExtInst %void [[ext]] DebugValue [[dbg_foo]] [[phi1]] [[empty_expr]] %uint_1 ; CHECK: OpLoopMerge [[loop_merge:%\w+]] [[loop_cont:%\w+]] None ; CHECK-NEXT: OpBranch [[loop_body:%\w+]] ; CHECK: [[loop_body]] = OpLabel ; CHECK: OpBranchConditional {{%\w+}} [[bb:%\w+]] [[loop_merge]] ; CHECK: [[bb]] = OpLabel ; CHECK: OpStore %f [[f_val:%\w+]] ; CHECK-NEXT: OpExtInst %void [[ext]] DebugValue [[dbg_foo]] [[f_val]] [[empty_expr]] %uint_0 ; CHECK-NEXT: OpBranch [[loop_cont]] ; CHECK: [[loop_cont]] = OpLabel ; CHECK: OpStore %i [[i_val:%\w+]] ; CHECK-NEXT: OpExtInst %void [[ext]] DebugValue [[dbg_foo]] [[i_val]] [[empty_expr]] %uint_1 ; CHECK-NEXT: OpBranch [[loop_head]] OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" %ext = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BC %fo OpExecutionMode %main OriginUpperLeft %file_name = OpString "test" OpSource GLSL 140 %float_name = OpString "float" %main_name = OpString "main" %f_name = OpString "f" OpName %main "main" OpName %f "f" OpName %i "i" OpName %BC "BC" OpName %fo "fo" %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_4 = OpConstant %int 4 %bool = OpTypeBool %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %BC = OpVariable %_ptr_Input_v4float Input %_ptr_Input_float = OpTypePointer Input %float %int_1 = OpConstant %int 1 %_ptr_Output_float = OpTypePointer Output %float %fo = OpVariable %_ptr_Output_float Output %deref_op = OpExtInst %void %ext DebugOperation Deref %deref = OpExtInst %void %ext DebugExpression %deref_op %src = OpExtInst %void %ext DebugSource %file_name %cu = OpExtInst %void %ext DebugCompilationUnit 1 4 %src HLSL %dbg_tf = OpExtInst %void %ext DebugTypeBasic %float_name %uint_32 Float %dbg_v4f = OpExtInst %void %ext DebugTypeVector %dbg_tf 4 %main_ty = OpExtInst %void %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %dbg_v4f %dbg_v4f %dbg_main = OpExtInst %void %ext DebugFunction %main_name %main_ty %src 0 0 %cu %main_name FlagIsProtected|FlagIsPrivate 10 %main %dbg_foo = OpExtInst %void %ext DebugLocalVariable %f_name %dbg_v4f %src 0 0 %dbg_main FlagIsLocal %main = OpFunction %void None %8 %22 = OpLabel %s0 = OpExtInst %void %ext DebugScope %dbg_main %f = OpVariable %_ptr_Function_float Function %i = OpVariable %_ptr_Function_int Function OpStore %f %float_0 OpStore %i %int_0 %decl0 = OpExtInst %void %ext DebugValue %dbg_foo %f %deref %uint_0 %decl1 = OpExtInst %void %ext DebugValue %dbg_foo %i %deref %uint_1 OpBranch %23 %23 = OpLabel %s1 = OpExtInst %void %ext DebugScope %dbg_main OpLoopMerge %24 %25 None OpBranch %26 %26 = OpLabel %s2 = OpExtInst %void %ext DebugScope %dbg_main %27 = OpLoad %int %i %28 = OpSLessThan %bool %27 %int_4 OpBranchConditional %28 %29 %24 %29 = OpLabel %s3 = OpExtInst %void %ext DebugScope %dbg_main %30 = OpLoad %float %f %31 = OpLoad %int %i %32 = OpAccessChain %_ptr_Input_float %BC %31 %33 = OpLoad %float %32 %34 = OpFAdd %float %30 %33 OpStore %f %34 OpBranch %25 %25 = OpLabel %s4 = OpExtInst %void %ext DebugScope %dbg_main %35 = OpLoad %int %i %36 = OpIAdd %int %35 %int_1 OpStore %i %36 OpBranch %23 %24 = OpLabel %s5 = OpExtInst %void %ext DebugScope %dbg_main %37 = OpLoad %float %f OpStore %fo %37 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(LocalSSAElimTest, DebugValueNotUsedForDebugDeclare) { // #version 140 // // in vec4 BC; // out float fo; // // void main() // { // float f = 0.0; // for (int i=0; i<4; i++) { // f = f + BC[i]; // } // fo = f; // } const std::string text = R"( ; CHECK: [[f_name:%\w+]] = OpString "f" ; CHECK: [[i_name:%\w+]] = OpString "i" ; CHECK: [[dbg_f:%\w+]] = OpExtInst %void [[ext:%\d+]] DebugLocalVariable [[f_name]] ; CHECK: [[dbg_i:%\w+]] = OpExtInst %void [[ext]] DebugLocalVariable [[i_name]] ; CHECK: OpStore %f %float_0 ; CHECK-NEXT: OpStore %i %int_0 ; CHECK-NEXT: OpExtInst %void [[ext]] DebugValue [[dbg_f]] %f ; CHECK-NEXT: OpExtInst %void [[ext]] DebugValue [[dbg_i]] %i ; CHECK-NOT: DebugValue ; CHECK-NOT: DebugDeclare OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" %ext = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BC %fo OpExecutionMode %main OriginUpperLeft %file_name = OpString "test" OpSource GLSL 140 %float_name = OpString "float" %main_name = OpString "main" %f_name = OpString "f" %i_name = OpString "i" OpName %main "main" OpName %f "f" OpName %i "i" OpName %BC "BC" OpName %fo "fo" %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_4 = OpConstant %int 4 %bool = OpTypeBool %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %BC = OpVariable %_ptr_Input_v4float Input %_ptr_Input_float = OpTypePointer Input %float %int_1 = OpConstant %int 1 %_ptr_Output_float = OpTypePointer Output %float %fo = OpVariable %_ptr_Output_float Output %null_expr = OpExtInst %void %ext DebugExpression %src = OpExtInst %void %ext DebugSource %file_name %cu = OpExtInst %void %ext DebugCompilationUnit 1 4 %src HLSL %dbg_tf = OpExtInst %void %ext DebugTypeBasic %float_name %uint_32 Float %dbg_v4f = OpExtInst %void %ext DebugTypeVector %dbg_tf 4 %main_ty = OpExtInst %void %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %dbg_v4f %dbg_v4f %dbg_main = OpExtInst %void %ext DebugFunction %main_name %main_ty %src 0 0 %cu %main_name FlagIsProtected|FlagIsPrivate 10 %main %dbg_f = OpExtInst %void %ext DebugLocalVariable %f_name %dbg_v4f %src 0 0 %dbg_main FlagIsLocal %dbg_i = OpExtInst %void %ext DebugLocalVariable %i_name %dbg_v4f %src 1 0 %dbg_main FlagIsLocal %main = OpFunction %void None %8 %22 = OpLabel %s0 = OpExtInst %void %ext DebugScope %dbg_main %f = OpVariable %_ptr_Function_float Function %i = OpVariable %_ptr_Function_int Function OpStore %f %float_0 OpStore %i %int_0 %decl0 = OpExtInst %void %ext DebugValue %dbg_f %f %null_expr %decl1 = OpExtInst %void %ext DebugValue %dbg_i %i %null_expr OpBranch %23 %23 = OpLabel %s1 = OpExtInst %void %ext DebugScope %dbg_main OpLoopMerge %24 %25 None OpBranch %26 %26 = OpLabel %s2 = OpExtInst %void %ext DebugScope %dbg_main %27 = OpLoad %int %i %28 = OpSLessThan %bool %27 %int_4 OpBranchConditional %28 %29 %24 %29 = OpLabel %s3 = OpExtInst %void %ext DebugScope %dbg_main %30 = OpLoad %float %f %31 = OpLoad %int %i %32 = OpAccessChain %_ptr_Input_float %BC %31 %33 = OpLoad %float %32 %34 = OpFAdd %float %30 %33 OpStore %f %34 OpBranch %25 %25 = OpLabel %s4 = OpExtInst %void %ext DebugScope %dbg_main %35 = OpLoad %int %i %36 = OpIAdd %int %35 %int_1 OpStore %i %36 OpBranch %23 %24 = OpLabel %s5 = OpExtInst %void %ext DebugScope %dbg_main %37 = OpLoad %float %f OpStore %fo %37 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(LocalSSAElimTest, DebugNestedForLoop) { const std::string text = R"( ; CHECK: = OpFunction ; CHECK-NEXT: [[entry:%\w+]] = OpLabel ; CHECK: OpStore %f %float_0 ; CHECK-NEXT: = OpExtInst %void [[ext:%\w+]] DebugValue [[dbg_f:%\w+]] %float_0 ; CHECK: [[outer_header:%\w+]] = OpLabel ; CHECK: [[outer_f:%\w+]] = OpPhi %float %float_0 [[entry]] [[inner_f:%\w+]] [[outer_be:%\w+]] ; CHECK: = OpExtInst %void [[ext]] DebugValue [[dbg_f]] [[outer_f]] ; CHECK: [[inner_pre_header:%\w+]] = OpLabel ; CHECK: [[inner_header:%\w+]] = OpLabel ; CHECK: [[inner_f]] = OpPhi %float [[outer_f]] [[inner_pre_header]] [[f_next:%\w+]] [[inner_be:%\w+]] ; CHECK: = OpExtInst %void [[ext]] DebugValue [[dbg_f]] [[inner_f]] ; CHECK: [[inner_be]] = OpLabel ; CHECK: [[f_next]] = OpFAdd %float [[inner_f]] ; CHECK-NEXT: OpStore %f [[f_next]] ; CHECK-NEXT: = OpExtInst %void [[ext]] DebugValue [[dbg_f]] [[f_next]] OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" %ext = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BC %fo OpExecutionMode %main OriginUpperLeft %file_name = OpString "test" %float_name = OpString "float" %main_name = OpString "main" %f_name = OpString "f" OpSource GLSL 450 OpName %main "main" OpName %f "f" OpName %i "i" OpName %j "j" OpName %BC "BC" OpName %fo "fo" OpDecorate %BC Location 0 OpDecorate %fo Location 0 %void = OpTypeVoid %9 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_4 = OpConstant %int 4 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %bool = OpTypeBool %v4float = OpTypeVector %float 4 %mat4v4float = OpTypeMatrix %v4float 4 %_ptr_Input_mat4v4float = OpTypePointer Input %mat4v4float %BC = OpVariable %_ptr_Input_mat4v4float Input %_ptr_Input_float = OpTypePointer Input %float %int_1 = OpConstant %int 1 %_ptr_Output_float = OpTypePointer Output %float %fo = OpVariable %_ptr_Output_float Output ; Debug information %null_expr = OpExtInst %void %ext DebugExpression %src = OpExtInst %void %ext DebugSource %file_name %cu = OpExtInst %void %ext DebugCompilationUnit 1 4 %src HLSL %dbg_tf = OpExtInst %void %ext DebugTypeBasic %float_name %uint_32 Float %main_ty = OpExtInst %void %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %void %dbg_main = OpExtInst %void %ext DebugFunction %main_name %main_ty %src 0 0 %cu %main_name FlagIsProtected|FlagIsPrivate 10 %main %dbg_f = OpExtInst %void %ext DebugLocalVariable %f_name %dbg_tf %src 0 0 %dbg_main FlagIsLocal %main = OpFunction %void None %9 %24 = OpLabel %s1 = OpExtInst %void %ext DebugScope %dbg_main %f = OpVariable %_ptr_Function_float Function %i = OpVariable %_ptr_Function_int Function %j = OpVariable %_ptr_Function_int Function ; DebugDeclare OpStore %f %float_0 %decl = OpExtInst %void %ext DebugDeclare %dbg_f %f %null_expr OpStore %i %int_0 OpBranch %25 %25 = OpLabel %s2 = OpExtInst %void %ext DebugScope %dbg_main %26 = OpLoad %int %i %27 = OpSLessThan %bool %26 %int_4 OpLoopMerge %28 %29 None OpBranchConditional %27 %30 %28 %30 = OpLabel %s3 = OpExtInst %void %ext DebugScope %dbg_main OpStore %j %int_0 OpBranch %31 %31 = OpLabel %s4 = OpExtInst %void %ext DebugScope %dbg_main %32 = OpLoad %int %j %33 = OpSLessThan %bool %32 %int_4 OpLoopMerge %50 %34 None OpBranchConditional %33 %34 %50 %34 = OpLabel %s5 = OpExtInst %void %ext DebugScope %dbg_main %35 = OpLoad %float %f %36 = OpLoad %int %i %37 = OpLoad %int %j %38 = OpAccessChain %_ptr_Input_float %BC %36 %37 %39 = OpLoad %float %38 %40 = OpFAdd %float %35 %39 OpStore %f %40 %41 = OpLoad %int %j %42 = OpIAdd %int %41 %int_1 OpStore %j %42 OpBranch %31 %50 = OpLabel %s6 = OpExtInst %void %ext DebugScope %dbg_main OpBranch %29 %29 = OpLabel %s7 = OpExtInst %void %ext DebugScope %dbg_main %43 = OpLoad %int %i %44 = OpIAdd %int %43 %int_1 OpStore %i %44 OpBranch %25 %28 = OpLabel %s8 = OpExtInst %void %ext DebugScope %dbg_main %45 = OpLoad %float %f OpStore %fo %45 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(LocalSSAElimTest, DebugForLoopWithContinue) { const std::string text = R"( ; CHECK: = OpFunction ; CHECK-NEXT: [[entry:%\w+]] = OpLabel ; CHECK: OpStore %f %float_0 ; CHECK-NEXT: = OpExtInst %void [[ext:%\w+]] DebugValue [[dbg_f:%\w+]] %float_0 ; CHECK: [[outer_header:%\w+]] = OpLabel ; CHECK: [[outer_f:%\w+]] = OpPhi %float %float_0 [[entry]] [[inner_f:%\w+]] [[cont:%\w+]] ; CHECK: = OpExtInst %void [[ext]] DebugValue [[dbg_f]] [[outer_f]] ; CHECK: [[f_next:%\w+]] = OpFAdd %float [[outer_f]] ; CHECK-NEXT: OpStore %f [[f_next]] ; CHECK-NEXT: = OpExtInst %void [[ext]] DebugValue [[dbg_f]] [[f_next]] ; CHECK: [[cont]] = OpLabel ; CHECK: [[inner_f]] = OpPhi %float [[outer_f]] {{%\d+}} [[f_next]] {{%\d+}} ; CHECK-NEXT: = OpExtInst %void [[ext]] DebugValue [[dbg_f]] [[inner_f]] OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" %ext = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BC %fo OpExecutionMode %main OriginUpperLeft %file_name = OpString "test" %float_name = OpString "float" %main_name = OpString "main" %f_name = OpString "f" OpSource GLSL 140 OpName %main "main" OpName %f "f" OpName %i "i" OpName %t "t" OpName %BC "BC" OpName %fo "fo" %void = OpTypeVoid %9 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_4 = OpConstant %int 4 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %bool = OpTypeBool %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %BC = OpVariable %_ptr_Input_v4float Input %_ptr_Input_float = OpTypePointer Input %float %int_1 = OpConstant %int 1 %_ptr_Output_float = OpTypePointer Output %float %fo = OpVariable %_ptr_Output_float Output ; Debug information %null_expr = OpExtInst %void %ext DebugExpression %src = OpExtInst %void %ext DebugSource %file_name %cu = OpExtInst %void %ext DebugCompilationUnit 1 4 %src HLSL %dbg_tf = OpExtInst %void %ext DebugTypeBasic %float_name %uint_32 Float %main_ty = OpExtInst %void %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %void %dbg_main = OpExtInst %void %ext DebugFunction %main_name %main_ty %src 0 0 %cu %main_name FlagIsProtected|FlagIsPrivate 10 %main %dbg_f = OpExtInst %void %ext DebugLocalVariable %f_name %dbg_tf %src 0 0 %dbg_main FlagIsLocal %main = OpFunction %void None %9 %23 = OpLabel %s0 = OpExtInst %void %ext DebugScope %dbg_main %f = OpVariable %_ptr_Function_float Function %i = OpVariable %_ptr_Function_int Function %t = OpVariable %_ptr_Function_float Function ; DebugDeclare OpStore %f %float_0 %decl = OpExtInst %void %ext DebugDeclare %dbg_f %f %null_expr OpStore %i %int_0 OpBranch %24 %24 = OpLabel %s1 = OpExtInst %void %ext DebugScope %dbg_main OpLoopMerge %25 %26 None OpBranch %27 %27 = OpLabel %s2 = OpExtInst %void %ext DebugScope %dbg_main %28 = OpLoad %int %i %29 = OpSLessThan %bool %28 %int_4 OpBranchConditional %29 %30 %25 %30 = OpLabel %s3 = OpExtInst %void %ext DebugScope %dbg_main %31 = OpLoad %int %i %32 = OpAccessChain %_ptr_Input_float %BC %31 %33 = OpLoad %float %32 OpStore %t %33 %34 = OpLoad %float %t %35 = OpFOrdLessThan %bool %34 %float_0 OpSelectionMerge %36 None OpBranchConditional %35 %37 %36 %37 = OpLabel %s4 = OpExtInst %void %ext DebugScope %dbg_main OpBranch %26 %36 = OpLabel %s5 = OpExtInst %void %ext DebugScope %dbg_main %38 = OpLoad %float %f %39 = OpLoad %float %t %40 = OpFAdd %float %38 %39 OpStore %f %40 OpBranch %26 %26 = OpLabel %s6 = OpExtInst %void %ext DebugScope %dbg_main %41 = OpLoad %int %i %42 = OpIAdd %int %41 %int_1 OpStore %i %42 OpBranch %24 %25 = OpLabel %s7 = OpExtInst %void %ext DebugScope %dbg_main %43 = OpLoad %float %f OpStore %fo %43 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(LocalSSAElimTest, DebugIfElse) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" %ext = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %f %BaseColor %gl_FragColor OpExecutionMode %main OriginUpperLeft %file_name = OpString "test" %float_name = OpString "float" %main_name = OpString "main" %v_name = OpString "v" OpSource GLSL 140 OpName %main "main" OpName %f "f" OpName %v "v" OpName %BaseColor "BaseColor" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Input_float = OpTypePointer Input %float %f = OpVariable %_ptr_Input_float Input %float_0 = OpConstant %float 0 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %bool = OpTypeBool %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %float_0_5 = OpConstant %float 0.5 %float_1 = OpConstant %float 1 %18 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output ; Debug information %null_expr = OpExtInst %void %ext DebugExpression %src = OpExtInst %void %ext DebugSource %file_name %cu = OpExtInst %void %ext DebugCompilationUnit 1 4 %src HLSL %dbg_tf = OpExtInst %void %ext DebugTypeBasic %float_name %uint_32 Float %main_ty = OpExtInst %void %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %void %dbg_main = OpExtInst %void %ext DebugFunction %main_name %main_ty %src 0 0 %cu %main_name FlagIsProtected|FlagIsPrivate 10 %main %dbg_v = OpExtInst %void %ext DebugLocalVariable %v_name %dbg_tf %src 0 0 %dbg_main FlagIsLocal %main = OpFunction %void None %8 %20 = OpLabel %s0 = OpExtInst %void %ext DebugScope %dbg_main ; DebugDeclare %v = OpVariable %_ptr_Function_v4float Function %decl = OpExtInst %void %ext DebugDeclare %dbg_v %v %null_expr %21 = OpLoad %float %f %22 = OpFOrdGreaterThanEqual %bool %21 %float_0 OpSelectionMerge %23 None OpBranchConditional %22 %24 %25 ; CHECK: OpBranchConditional ; CHECK-NEXT: [[br0:%\w+]] = OpLabel ; CHECK: OpStore %v [[v0:%\w+]] ; CHECK-NEXT: = OpExtInst %void [[ext:%\w+]] DebugValue [[dbg_v:%\w+]] [[v0]] %24 = OpLabel %s1 = OpExtInst %void %ext DebugScope %dbg_main %26 = OpLoad %v4float %BaseColor %27 = OpVectorTimesScalar %v4float %26 %float_0_5 OpStore %v %27 OpBranch %23 ; CHECK: [[br1:%\w+]] = OpLabel ; CHECK: OpStore %v [[v1:%\w+]] ; CHECK-NEXT: = OpExtInst %void [[ext]] DebugValue [[dbg_v]] [[v1]] %25 = OpLabel %s2 = OpExtInst %void %ext DebugScope %dbg_main %28 = OpLoad %v4float %BaseColor %29 = OpFAdd %v4float %28 %18 OpStore %v %29 OpBranch %23 ; CHECK: [[phi:%\w+]] = OpPhi %v4float [[v0]] [[br0]] [[v1]] [[br1]] ; CHECK-NEXT: = OpExtInst %void [[ext]] DebugValue [[dbg_v]] [[phi]] %23 = OpLabel %s3 = OpExtInst %void %ext DebugScope %dbg_main %30 = OpLoad %v4float %v OpStore %gl_FragColor %30 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(LocalSSAElimTest, DebugSwitch) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" %ext = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %BaseColor %f %gl_FragColor OpExecutionMode %main OriginUpperLeft %file_name = OpString "test" %float_name = OpString "float" %main_name = OpString "main" %v_name = OpString "v" OpSource GLSL 140 OpName %main "main" OpName %v "v" OpName %BaseColor "BaseColor" OpName %i "i" OpName %f "f" OpName %gl_FragColor "gl_FragColor" %void = OpTypeVoid %9 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %BaseColor = OpVariable %_ptr_Input_v4float Input %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %_ptr_Input_float = OpTypePointer Input %float %f = OpVariable %_ptr_Input_float Input %float_0_25 = OpConstant %float 0.25 %float_0_75 = OpConstant %float 0.75 %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output ; Debug information %null_expr = OpExtInst %void %ext DebugExpression %src = OpExtInst %void %ext DebugSource %file_name %cu = OpExtInst %void %ext DebugCompilationUnit 1 4 %src HLSL %dbg_tf = OpExtInst %void %ext DebugTypeBasic %float_name %uint_32 Float %main_ty = OpExtInst %void %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %void %dbg_main = OpExtInst %void %ext DebugFunction %main_name %main_ty %src 0 0 %cu %main_name FlagIsProtected|FlagIsPrivate 10 %main %dbg_v = OpExtInst %void %ext DebugLocalVariable %v_name %dbg_tf %src 0 0 %dbg_main FlagIsLocal %main = OpFunction %void None %9 %20 = OpLabel %s0 = OpExtInst %void %ext DebugScope %dbg_main %v = OpVariable %_ptr_Function_v4float Function %i = OpVariable %_ptr_Function_int Function %21 = OpLoad %v4float %BaseColor ; DebugDeclare OpStore %v %21 %decl = OpExtInst %void %ext DebugDeclare %dbg_v %v %null_expr ; CHECK: %main = OpFunction %void None ; CHECK-NEXT: [[entry:%\w+]] = OpLabel ; CHECK: OpStore %v [[v0:%\w+]] ; CHECK-NEXT: = OpExtInst %void [[ext:%\w+]] DebugValue [[dbg_v:%\w+]] [[v0]] ; CHECK: OpSwitch {{%\w+}} [[case0:%\w+]] 0 [[case1:%\w+]] 1 [[case2:%\w+]] 2 [[case3:%\w+]] ; CHECK: OpStore %v [[v1:%\w+]] ; CHECK-NEXT: = OpExtInst %void [[ext]] DebugValue [[dbg_v]] [[v1]] ; CHECK: OpStore %v [[v2:%\w+]] ; CHECK-NEXT: = OpExtInst %void [[ext]] DebugValue [[dbg_v]] [[v2]] ; CHECK: [[phi0:%\w+]] = OpPhi %v4float [[v0]] [[entry]] [[v2]] [[case2]] ; CHECK-NEXT: = OpExtInst %void [[ext]] DebugValue [[dbg_v]] [[phi0]] ; CHECK: OpStore %v [[v3:%\w+]] ; CHECK-NEXT: = OpExtInst %void [[ext]] DebugValue [[dbg_v]] [[v3]] ; CHECK: [[phi1:%\w+]] = OpPhi %v4float [[v0]] [[case0]] [[v1]] [[case1]] [[v3]] [[case3]] ; CHECK-NEXT: = OpExtInst %void [[ext]] DebugValue [[dbg_v]] [[phi1]] %22 = OpLoad %float %f %23 = OpConvertFToS %int %22 OpStore %i %23 %24 = OpLoad %int %i OpSelectionMerge %25 None OpSwitch %24 %26 0 %27 1 %28 2 %29 %26 = OpLabel %s1 = OpExtInst %void %ext DebugScope %dbg_main OpBranch %25 %27 = OpLabel %s2 = OpExtInst %void %ext DebugScope %dbg_main %30 = OpLoad %v4float %v %31 = OpVectorTimesScalar %v4float %30 %float_0_25 OpStore %v %31 OpBranch %25 %28 = OpLabel %s3 = OpExtInst %void %ext DebugScope %dbg_main %32 = OpLoad %v4float %v %33 = OpCompositeConstruct %v4float %float_0_25 %float_0_25 %float_0_25 %float_0_25 %34 = OpFAdd %v4float %32 %33 OpStore %v %34 OpBranch %29 %29 = OpLabel %s4 = OpExtInst %void %ext DebugScope %dbg_main %35 = OpLoad %v4float %v %36 = OpVectorTimesScalar %v4float %35 %float_0_75 OpStore %v %36 OpBranch %25 %25 = OpLabel %s5 = OpExtInst %void %ext DebugScope %dbg_main %37 = OpLoad %v4float %v OpStore %gl_FragColor %37 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(LocalSSAElimTest, DebugSwapProblem) { // #version 140 // // in float fe; // out float fo; // // void main() // { // float f1 = 0.0; // float f2 = 1.0; // int ie = int(fe); // for (int i=0; i(text, true); } TEST_F(LocalSSAElimTest, RemoveDebugDeclareWithoutLoads) { // Check that the DebugDeclare for c is removed even though its loads // had been removed previously by single block store/load optimization. // In the presence of DebugDeclare, single-block can and does remove loads, // but cannot change the stores into DebugValues and remove the DebugDeclare // because it is only a per block optimization, not a function optimization. // So SSA-rewrite must perform this role. // // Texture2D g_tColor; // SamplerState g_sAniso; // // struct PS_INPUT // { // float2 vTextureCoords2 : TEXCOORD2; // float2 vTextureCoords3 : TEXCOORD3; // }; // // struct PS_OUTPUT // { // float4 vColor : SV_Target0; // }; // // PS_OUTPUT MainPs(PS_INPUT i) // { // PS_OUTPUT ps_output; // float4 c; // c = g_tColor.Sample(g_sAniso, i.vTextureCoords2.xy); // c += g_tColor.Sample(g_sAniso, i.vTextureCoords3.xy); // ps_output.vColor = c; // return ps_output; // } const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %MainPs "MainPs" %g_tColor %g_sAniso %in_var_TEXCOORD2 %in_var_TEXCOORD3 %out_var_SV_Target0 OpExecutionMode %MainPs OriginUpperLeft %22 = OpString "foo.frag" %26 = OpString "PS_OUTPUT" %30 = OpString "float" %33 = OpString "vColor" %35 = OpString "PS_INPUT" %40 = OpString "vTextureCoords3" %42 = OpString "vTextureCoords2" %44 = OpString "@type.2d.image" %45 = OpString "type.2d.image" %47 = OpString "Texture2D.TemplateParam" %51 = OpString "src.MainPs" %55 = OpString "c" %57 = OpString "ps_output" %60 = OpString "i" %62 = OpString "@type.sampler" %63 = OpString "type.sampler" %65 = OpString "g_sAniso" %67 = OpString "g_tColor" OpName %type_2d_image "type.2d.image" OpName %g_tColor "g_tColor" OpName %type_sampler "type.sampler" OpName %g_sAniso "g_sAniso" OpName %in_var_TEXCOORD2 "in.var.TEXCOORD2" OpName %in_var_TEXCOORD3 "in.var.TEXCOORD3" OpName %out_var_SV_Target0 "out.var.SV_Target0" OpName %MainPs "MainPs" OpName %PS_INPUT "PS_INPUT" OpMemberName %PS_INPUT 0 "vTextureCoords2" OpMemberName %PS_INPUT 1 "vTextureCoords3" OpName %param_var_i "param.var.i" OpName %PS_OUTPUT "PS_OUTPUT" OpMemberName %PS_OUTPUT 0 "vColor" OpName %type_sampled_image "type.sampled.image" OpDecorate %in_var_TEXCOORD2 Location 0 OpDecorate %in_var_TEXCOORD3 Location 1 OpDecorate %out_var_SV_Target0 Location 0 OpDecorate %g_tColor DescriptorSet 0 OpDecorate %g_tColor Binding 0 OpDecorate %g_sAniso DescriptorSet 0 OpDecorate %g_sAniso Binding 1 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %float = OpTypeFloat 32 %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %type_sampler = OpTypeSampler %_ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %type_sampler %v2float = OpTypeVector %float 2 %_ptr_Input_v2float = OpTypePointer Input %v2float %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %uint_128 = OpConstant %uint 128 %uint_0 = OpConstant %uint 0 %uint_64 = OpConstant %uint 64 %69 = OpTypeFunction %void %PS_INPUT = OpTypeStruct %v2float %v2float %_ptr_Function_PS_INPUT = OpTypePointer Function %PS_INPUT %PS_OUTPUT = OpTypeStruct %v4float %_ptr_Function_PS_OUTPUT = OpTypePointer Function %PS_OUTPUT %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Function_v2float = OpTypePointer Function %v2float %type_sampled_image = OpTypeSampledImage %type_2d_image %g_tColor = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %g_sAniso = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %in_var_TEXCOORD2 = OpVariable %_ptr_Input_v2float Input %in_var_TEXCOORD3 = OpVariable %_ptr_Input_v2float Input %out_var_SV_Target0 = OpVariable %_ptr_Output_v4float Output %43 = OpExtInst %void %1 DebugInfoNone %59 = OpExtInst %void %1 DebugExpression %24 = OpExtInst %void %1 DebugSource %22 %25 = OpExtInst %void %1 DebugCompilationUnit 1 4 %24 HLSL %28 = OpExtInst %void %1 DebugTypeComposite %26 Structure %24 11 1 %25 %26 %uint_128 FlagIsProtected|FlagIsPrivate %29 %31 = OpExtInst %void %1 DebugTypeBasic %30 %uint_32 Float %32 = OpExtInst %void %1 DebugTypeVector %31 4 %29 = OpExtInst %void %1 DebugTypeMember %33 %32 %24 13 5 %28 %uint_0 %uint_128 FlagIsProtected|FlagIsPrivate %36 = OpExtInst %void %1 DebugTypeComposite %35 Structure %24 5 1 %25 %35 %uint_128 FlagIsProtected|FlagIsPrivate %37 %38 %39 = OpExtInst %void %1 DebugTypeVector %31 2 %38 = OpExtInst %void %1 DebugTypeMember %40 %39 %24 8 5 %36 %uint_64 %uint_64 FlagIsProtected|FlagIsPrivate %37 = OpExtInst %void %1 DebugTypeMember %42 %39 %24 7 5 %36 %uint_0 %uint_64 FlagIsProtected|FlagIsPrivate %46 = OpExtInst %void %1 DebugTypeComposite %44 Class %24 0 0 %25 %45 %43 FlagIsProtected|FlagIsPrivate %50 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %28 %36 %52 = OpExtInst %void %1 DebugFunction %51 %50 %24 16 1 %25 %51 FlagIsProtected|FlagIsPrivate 17 %43 %54 = OpExtInst %void %1 DebugLexicalBlock %24 17 1 %52 %56 = OpExtInst %void %1 DebugLocalVariable %55 %32 %24 20 12 %54 FlagIsLocal %58 = OpExtInst %void %1 DebugLocalVariable %57 %28 %24 18 15 %54 FlagIsLocal %61 = OpExtInst %void %1 DebugLocalVariable %60 %36 %24 16 29 %52 FlagIsLocal 1 %64 = OpExtInst %void %1 DebugTypeComposite %62 Structure %24 0 0 %25 %63 %43 FlagIsProtected|FlagIsPrivate %66 = OpExtInst %void %1 DebugGlobalVariable %65 %64 %24 3 14 %25 %65 %g_sAniso FlagIsDefinition %68 = OpExtInst %void %1 DebugGlobalVariable %67 %46 %24 1 11 %25 %67 %g_tColor FlagIsDefinition %MainPs = OpFunction %void None %69 %70 = OpLabel %135 = OpExtInst %void %1 DebugScope %54 %111 = OpVariable %_ptr_Function_PS_OUTPUT Function %112 = OpVariable %_ptr_Function_v4float Function %136 = OpExtInst %void %1 DebugNoScope %param_var_i = OpVariable %_ptr_Function_PS_INPUT Function %74 = OpLoad %v2float %in_var_TEXCOORD2 %75 = OpLoad %v2float %in_var_TEXCOORD3 %76 = OpCompositeConstruct %PS_INPUT %74 %75 OpStore %param_var_i %76 %137 = OpExtInst %void %1 DebugScope %52 %115 = OpExtInst %void %1 DebugDeclare %61 %param_var_i %59 %138 = OpExtInst %void %1 DebugScope %54 %116 = OpExtInst %void %1 DebugDeclare %58 %111 %59 %117 = OpExtInst %void %1 DebugDeclare %56 %112 %59 ;CHECK-NOT: %117 = OpExtInst %void %1 DebugDeclare %56 %112 %59 OpLine %22 21 9 %118 = OpLoad %type_2d_image %g_tColor OpLine %22 21 29 %119 = OpLoad %type_sampler %g_sAniso OpLine %22 21 40 %120 = OpAccessChain %_ptr_Function_v2float %param_var_i %int_0 %121 = OpLoad %v2float %120 OpLine %22 21 9 %122 = OpSampledImage %type_sampled_image %118 %119 %123 = OpImageSampleImplicitLod %v4float %122 %121 None OpLine %22 21 5 OpStore %112 %123 ;CHECK: %140 = OpExtInst %void %1 DebugValue %56 %123 %59 OpLine %22 22 10 %124 = OpLoad %type_2d_image %g_tColor OpLine %22 22 30 %125 = OpLoad %type_sampler %g_sAniso OpLine %22 22 41 %126 = OpAccessChain %_ptr_Function_v2float %param_var_i %int_1 %127 = OpLoad %v2float %126 OpLine %22 22 10 %128 = OpSampledImage %type_sampled_image %124 %125 %129 = OpImageSampleImplicitLod %v4float %128 %127 None OpLine %22 22 7 %131 = OpFAdd %v4float %123 %129 OpLine %22 22 5 OpStore %112 %131 ;CHECK: %141 = OpExtInst %void %1 DebugValue %56 %131 %59 OpLine %22 23 5 %133 = OpAccessChain %_ptr_Function_v4float %111 %int_0 OpStore %133 %131 OpLine %22 24 12 %134 = OpLoad %PS_OUTPUT %111 %139 = OpExtInst %void %1 DebugNoScope %79 = OpCompositeExtract %v4float %134 0 OpStore %out_var_SV_Target0 %79 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_2); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(text, true); } // Check support for pointer variables. When pointer variables are used, the // computation of reaching definitions may need to follow pointer chains. // See https://github.com/KhronosGroup/SPIRV-Tools/issues/3873 for details. TEST_F(LocalSSAElimTest, PointerVariables) { const std::string text = R"( OpCapability Shader OpCapability VariablePointers OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical Simple OpEntryPoint Fragment %1 "main" %2 %3 OpExecutionMode %1 OriginUpperLeft %float = OpTypeFloat 32 %void = OpTypeVoid %6 = OpTypeFunction %void %_ptr_Input_float = OpTypePointer Input %float %_ptr_Output_float = OpTypePointer Output %float %_ptr_Function__ptr_Input_float = OpTypePointer Function %_ptr_Input_float %2 = OpVariable %_ptr_Input_float Input %3 = OpVariable %_ptr_Output_float Output %1 = OpFunction %void None %6 %10 = OpLabel %11 = OpVariable %_ptr_Function__ptr_Input_float Function OpStore %11 %2 ; CHECK-NOT: %12 = OpLoad %_ptr_Input_float %11 %12 = OpLoad %_ptr_Input_float %11 ; CHECK: %13 = OpLoad %float %2 %13 = OpLoad %float %12 OpStore %3 %13 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(LocalSSAElimTest, FunctionDeclaration) { // Make sure the pass works with a function declaration that is called. const std::string text = R"(OpCapability Addresses OpCapability Linkage OpCapability Kernel OpCapability Int8 %1 = OpExtInstImport "OpenCL.std" OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %2 "_Z23julia__1166_kernel_77094Bool" OpExecutionMode %2 ContractionOff OpSource Unknown 0 OpDecorate %3 LinkageAttributes "julia_error_7712" Import %void = OpTypeVoid %5 = OpTypeFunction %void %3 = OpFunction %void None %5 OpFunctionEnd %2 = OpFunction %void None %5 %6 = OpLabel %7 = OpFunctionCall %void %3 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(text, text, false); } TEST_F(LocalSSAElimTest, MissingDebugValue) { // Make sure DebugValue for final fragcolor assignment is generated. const std::string text = R"( OpCapability Shader OpCapability ImageQuery OpExtension "SPV_KHR_non_semantic_info" %1 = OpExtInstImport "GLSL.std.450" %2 = OpExtInstImport "NonSemantic.Shader.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in_var_TEXCOORD0 %out_var_SV_TARGET %textureposition %samplerposition %textureNormal %samplerNormal %textureAlbedo %samplerAlbedo %textureShadowMap %samplerShadowMap %ubo OpExecutionMode %main OriginUpperLeft %15 = OpString "d2.frag" %55 = OpString "float" %63 = OpString "// Copyright 2020 Google LLC Texture2D textureposition : register(t1); SamplerState samplerposition : register(s1); Texture2D textureNormal : register(t2); SamplerState samplerNormal : register(s2); Texture2D textureAlbedo : register(t3); SamplerState samplerAlbedo : register(s3); // Depth from the light's point of view //layout (binding = 5) uniform sampler2DShadow samplerShadowMap; Texture2DArray textureShadowMap : register(t5); SamplerState samplerShadowMap : register(s5); #define LIGHT_COUNT 3 #define SHADOW_FACTOR 0.25 #define AMBIENT_LIGHT 0.1 #define USE_PCF struct Light { float4 position; float4 target; float4 color; float4x4 viewMatrix; }; struct UBO { float4 viewPos; Light lights[LIGHT_COUNT]; int useShadows; int displayDebugTarget; }; cbuffer ubo : register(b4) { UBO ubo; } float textureProj(float4 P, float layer, float2 offset) { float shadow = 1.0; float4 shadowCoord = P / P.w; shadowCoord.xy = shadowCoord.xy * 0.5 + 0.5; if (shadowCoord.z > -1.0 && shadowCoord.z < 1.0) { float dist = textureShadowMap.Sample(samplerShadowMap, float3(shadowCoord.xy + offset, layer)).r; if (shadowCoord.w > 0.0 && dist < shadowCoord.z) { shadow = SHADOW_FACTOR; } } return shadow; } float filterPCF(float4 sc, float layer) { int2 texDim; int elements; int levels; textureShadowMap.GetDimensions(0, texDim.x, texDim.y, elements, levels); float scale = 1.5; float dx = scale * 1.0 / float(texDim.x); float dy = scale * 1.0 / float(texDim.y); float shadowFactor = 0.0; int count = 0; int range = 1; for (int x = -range; x <= range; x++) { for (int y = -range; y <= range; y++) { shadowFactor += textureProj(sc, layer, float2(dx*x, dy*y)); count++; } } return shadowFactor / count; } float3 shadow(float3 fragcolor, float3 fragPos) { for (int i = 0; i < LIGHT_COUNT; ++i) { float4 shadowClip = mul(ubo.lights[i].viewMatrix, float4(fragPos.xyz, 1.0)); float shadowFactor; #ifdef USE_PCF shadowFactor= filterPCF(shadowClip, i); #else shadowFactor = textureProj(shadowClip, i, float2(0.0, 0.0)); #endif fragcolor *= shadowFactor; } return fragcolor; } float4 main([[vk::location(0)]] float2 inUV : TEXCOORD0) : SV_TARGET { // Get G-Buffer values float3 fragPos = textureposition.Sample(samplerposition, inUV).rgb; float3 normal = textureNormal.Sample(samplerNormal, inUV).rgb; float4 albedo = textureAlbedo.Sample(samplerAlbedo, inUV); // Ambient part float3 fragcolor = albedo.rgb * AMBIENT_LIGHT; float3 N = normalize(normal); for(int i = 0; i < LIGHT_COUNT; ++i) { // Vector to light float3 L = ubo.lights[i].position.xyz - fragPos; // Distance from light to fragment position float dist = length(L); L = normalize(L); // Viewer to fragment float3 V = ubo.viewPos.xyz - fragPos; V = normalize(V); float lightCosInnerAngle = cos(radians(15.0)); float lightCosOuterAngle = cos(radians(25.0)); float lightRange = 100.0; // Direction vector from source to target float3 dir = normalize(ubo.lights[i].position.xyz - ubo.lights[i].target.xyz); // Dual cone spot light with smooth transition between inner and outer angle float cosDir = dot(L, dir); float spotEffect = smoothstep(lightCosOuterAngle, lightCosInnerAngle, cosDir); float heightAttenuation = smoothstep(lightRange, 0.0f, dist); // Diffuse lighting float NdotL = max(0.0, dot(N, L)); float3 diff = NdotL.xxx; // Specular lighting float3 R = reflect(-L, N); float NdotR = max(0.0, dot(R, V)); float3 spec = (pow(NdotR, 16.0) * albedo.a * 2.5).xxx; fragcolor += float3((diff + spec) * spotEffect * heightAttenuation) * ubo.lights[i].color.rgb * albedo.rgb; } // Shadow calculations in a separate pass if (ubo.useShadows > 0) { fragcolor = shadow(fragcolor, fragPos); } return float4(fragcolor, 1); } " %68 = OpString "textureProj" %69 = OpString "" %78 = OpString "dist" %82 = OpString "shadowCoord" %85 = OpString "shadow" %89 = OpString "offset" %92 = OpString "layer" %95 = OpString "P" %99 = OpString "filterPCF" %108 = OpString "int" %110 = OpString "y" %114 = OpString "x" %118 = OpString "range" %122 = OpString "count" %125 = OpString "shadowFactor" %128 = OpString "dy" %131 = OpString "dx" %134 = OpString "scale" %137 = OpString "levels" %141 = OpString "elements" %145 = OpString "texDim" %150 = OpString "sc" %162 = OpString "shadowClip" %166 = OpString "i" %169 = OpString "fragPos" %171 = OpString "fragcolor" %175 = OpString "main" %184 = OpString "spec" %187 = OpString "NdotR" %190 = OpString "R" %193 = OpString "diff" %196 = OpString "NdotL" %199 = OpString "heightAttenuation" %202 = OpString "spotEffect" %205 = OpString "cosDir" %208 = OpString "dir" %211 = OpString "lightRange" %214 = OpString "lightCosOuterAngle" %217 = OpString "lightCosInnerAngle" %220 = OpString "V" %225 = OpString "L" %230 = OpString "N" %235 = OpString "albedo" %238 = OpString "normal" %244 = OpString "inUV" %246 = OpString "viewPos" %249 = OpString "position" %252 = OpString "target" %254 = OpString "color" %259 = OpString "viewMatrix" %263 = OpString "Light" %267 = OpString "lights" %271 = OpString "useShadows" %275 = OpString "displayDebugTarget" %278 = OpString "UBO" %282 = OpString "ubo" %285 = OpString "type.ubo" %289 = OpString "@type.sampler" %290 = OpString "type.sampler" %292 = OpString "samplerShadowMap" %295 = OpString "@type.2d.image.array" %296 = OpString "type.2d.image.array" %298 = OpString "TemplateParam" %301 = OpString "textureShadowMap" %304 = OpString "samplerAlbedo" %306 = OpString "@type.2d.image" %307 = OpString "type.2d.image" %311 = OpString "textureAlbedo" %313 = OpString "samplerNormal" %315 = OpString "textureNormal" %317 = OpString "samplerposition" %319 = OpString "textureposition" OpName %type_2d_image "type.2d.image" OpName %textureposition "textureposition" OpName %type_sampler "type.sampler" OpName %samplerposition "samplerposition" OpName %textureNormal "textureNormal" OpName %samplerNormal "samplerNormal" OpName %textureAlbedo "textureAlbedo" OpName %samplerAlbedo "samplerAlbedo" OpName %type_2d_image_array "type.2d.image.array" OpName %textureShadowMap "textureShadowMap" OpName %samplerShadowMap "samplerShadowMap" OpName %type_ubo "type.ubo" OpMemberName %type_ubo 0 "ubo" OpName %UBO "UBO" OpMemberName %UBO 0 "viewPos" OpMemberName %UBO 1 "lights" OpMemberName %UBO 2 "useShadows" OpMemberName %UBO 3 "displayDebugTarget" OpName %Light "Light" OpMemberName %Light 0 "position" OpMemberName %Light 1 "target" OpMemberName %Light 2 "color" OpMemberName %Light 3 "viewMatrix" OpName %ubo "ubo" OpName %in_var_TEXCOORD0 "in.var.TEXCOORD0" OpName %out_var_SV_TARGET "out.var.SV_TARGET" OpName %main "main" OpName %param_var_inUV "param.var.inUV" OpName %type_sampled_image "type.sampled.image" OpName %type_sampled_image_0 "type.sampled.image" OpDecorate %in_var_TEXCOORD0 Location 0 OpDecorate %out_var_SV_TARGET Location 0 OpDecorate %textureposition DescriptorSet 0 OpDecorate %textureposition Binding 1 OpDecorate %samplerposition DescriptorSet 0 OpDecorate %samplerposition Binding 1 OpDecorate %textureNormal DescriptorSet 0 OpDecorate %textureNormal Binding 2 OpDecorate %samplerNormal DescriptorSet 0 OpDecorate %samplerNormal Binding 2 OpDecorate %textureAlbedo DescriptorSet 0 OpDecorate %textureAlbedo Binding 3 OpDecorate %samplerAlbedo DescriptorSet 0 OpDecorate %samplerAlbedo Binding 3 OpDecorate %textureShadowMap DescriptorSet 0 OpDecorate %textureShadowMap Binding 5 OpDecorate %samplerShadowMap DescriptorSet 0 OpDecorate %samplerShadowMap Binding 5 OpDecorate %ubo DescriptorSet 0 OpDecorate %ubo Binding 4 OpMemberDecorate %Light 0 Offset 0 OpMemberDecorate %Light 1 Offset 16 OpMemberDecorate %Light 2 Offset 32 OpMemberDecorate %Light 3 Offset 48 OpMemberDecorate %Light 3 MatrixStride 16 OpMemberDecorate %Light 3 RowMajor OpDecorate %_arr_Light_uint_3 ArrayStride 112 OpMemberDecorate %UBO 0 Offset 0 OpMemberDecorate %UBO 1 Offset 16 OpMemberDecorate %UBO 2 Offset 352 OpMemberDecorate %UBO 3 Offset 356 OpMemberDecorate %type_ubo 0 Offset 0 OpDecorate %type_ubo Block )" R"( %float = OpTypeFloat 32 %float_0_100000001 = OpConstant %float 0.100000001 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_3 = OpConstant %int 3 %int_1 = OpConstant %int 1 %float_15 = OpConstant %float 15 %float_25 = OpConstant %float 25 %float_100 = OpConstant %float 100 %float_0 = OpConstant %float 0 %float_16 = OpConstant %float 16 %float_2_5 = OpConstant %float 2.5 %int_2 = OpConstant %int 2 %float_1 = OpConstant %float 1 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %float_1_5 = OpConstant %float 1.5 %float_0_5 = OpConstant %float 0.5 %v2float = OpTypeVector %float 2 %35 = OpConstantComposite %v2float %float_0_5 %float_0_5 %float_n1 = OpConstant %float -1 %float_0_25 = OpConstant %float 0.25 %uint_32 = OpConstant %uint 32 %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %type_sampler = OpTypeSampler %_ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %type_sampler %type_2d_image_array = OpTypeImage %float 2D 2 1 0 1 Unknown %_ptr_UniformConstant_type_2d_image_array = OpTypePointer UniformConstant %type_2d_image_array %v4float = OpTypeVector %float 4 %uint_3 = OpConstant %uint 3 %mat4v4float = OpTypeMatrix %v4float 4 %Light = OpTypeStruct %v4float %v4float %v4float %mat4v4float %_arr_Light_uint_3 = OpTypeArray %Light %uint_3 %UBO = OpTypeStruct %v4float %_arr_Light_uint_3 %int %int %type_ubo = OpTypeStruct %UBO %_ptr_Uniform_type_ubo = OpTypePointer Uniform %type_ubo %_ptr_Input_v2float = OpTypePointer Input %v2float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %uint_4 = OpConstant %uint 4 %uint_2 = OpConstant %uint 2 %uint_1 = OpConstant %uint 1 %uint_5 = OpConstant %uint 5 %uint_37 = OpConstant %uint 37 %uint_38 = OpConstant %uint 38 %uint_44 = OpConstant %uint 44 %uint_47 = OpConstant %uint 47 %uint_45 = OpConstant %uint 45 %uint_9 = OpConstant %uint 9 %uint_40 = OpConstant %uint 40 %uint_39 = OpConstant %uint 39 %uint_8 = OpConstant %uint 8 %uint_49 = OpConstant %uint 49 %uint_35 = OpConstant %uint 35 %uint_26 = OpConstant %uint 26 %uint_54 = OpConstant %uint 54 %uint_55 = OpConstant %uint 55 %uint_67 = OpConstant %uint 67 %uint_69 = OpConstant %uint 69 %uint_68 = OpConstant %uint 68 %uint_12 = OpConstant %uint 12 %uint_66 = OpConstant %uint 66 %uint_11 = OpConstant %uint 11 %uint_64 = OpConstant %uint 64 %uint_6 = OpConstant %uint 6 %uint_63 = OpConstant %uint 63 %uint_62 = OpConstant %uint 62 %uint_60 = OpConstant %uint 60 %uint_59 = OpConstant %uint 59 %uint_58 = OpConstant %uint 58 %uint_56 = OpConstant %uint 56 %uint_33 = OpConstant %uint 33 %uint_19 = OpConstant %uint 19 %uint_7 = OpConstant %uint 7 %uint_34 = OpConstant %uint 34 %uint_24 = OpConstant %uint 24 %uint_78 = OpConstant %uint 78 %uint_80 = OpConstant %uint 80 %uint_83 = OpConstant %uint 83 %uint_81 = OpConstant %uint 81 %uint_10 = OpConstant %uint 10 %uint_79 = OpConstant %uint 79 %uint_22 = OpConstant %uint 22 %uint_95 = OpConstant %uint 95 %uint_96 = OpConstant %uint 96 %uint_145 = OpConstant %uint 145 %uint_108 = OpConstant %uint 108 %uint_138 = OpConstant %uint 138 %uint_137 = OpConstant %uint 137 %uint_136 = OpConstant %uint 136 %uint_133 = OpConstant %uint 133 %uint_132 = OpConstant %uint 132 %uint_129 = OpConstant %uint 129 %uint_128 = OpConstant %uint 128 %uint_127 = OpConstant %uint 127 %uint_124 = OpConstant %uint 124 %uint_121 = OpConstant %uint 121 %uint_120 = OpConstant %uint 120 %uint_119 = OpConstant %uint 119 %uint_116 = OpConstant %uint 116 %uint_112 = OpConstant %uint 112 %uint_110 = OpConstant %uint 110 %uint_107 = OpConstant %uint 107 %uint_105 = OpConstant %uint 105 %uint_103 = OpConstant %uint 103 %uint_100 = OpConstant %uint 100 %uint_99 = OpConstant %uint 99 %uint_98 = OpConstant %uint 98 %uint_29 = OpConstant %uint 29 %uint_21 = OpConstant %uint 21 %uint_256 = OpConstant %uint 256 %uint_23 = OpConstant %uint 23 %uint_384 = OpConstant %uint 384 %uint_512 = OpConstant %uint 512 %uint_896 = OpConstant %uint 896 %uint_2688 = OpConstant %uint 2688 %uint_30 = OpConstant %uint 30 %uint_2816 = OpConstant %uint 2816 %uint_31 = OpConstant %uint 31 %uint_2848 = OpConstant %uint 2848 %uint_2880 = OpConstant %uint 2880 %uint_27 = OpConstant %uint 27 %uint_2944 = OpConstant %uint 2944 %uint_14 = OpConstant %uint 14 %uint_16 = OpConstant %uint 16 %321 = OpTypeFunction %void %_ptr_Function_v2float = OpTypePointer Function %v2float %uint_150 = OpConstant %uint 150 %v3float = OpTypeVector %float 3 %_ptr_Function_v3float = OpTypePointer Function %v3float %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Function_int = OpTypePointer Function %int %_ptr_Function_float = OpTypePointer Function %float %uint_42 = OpConstant %uint 42 %type_sampled_image = OpTypeSampledImage %type_2d_image %uint_65 = OpConstant %uint 65 %uint_18 = OpConstant %uint 18 %uint_13 = OpConstant %uint 13 %uint_15 = OpConstant %uint 15 %uint_17 = OpConstant %uint 17 %bool = OpTypeBool %uint_25 = OpConstant %uint 25 %_ptr_Uniform_UBO = OpTypePointer Uniform %UBO %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %uint_28 = OpConstant %uint 28 %uint_43 = OpConstant %uint 43 %uint_113 = OpConstant %uint 113 %uint_117 = OpConstant %uint 117 %uint_46 = OpConstant %uint 46 %uint_76 = OpConstant %uint 76 %uint_53 = OpConstant %uint 53 %uint_73 = OpConstant %uint 73 %uint_48 = OpConstant %uint 48 %uint_140 = OpConstant %uint 140 %uint_52 = OpConstant %uint 52 %uint_93 = OpConstant %uint 93 %uint_87 = OpConstant %uint 87 %uint_106 = OpConstant %uint 106 %uint_36 = OpConstant %uint 36 %uint_144 = OpConstant %uint 144 %_ptr_Uniform_int = OpTypePointer Uniform %int %uint_146 = OpConstant %uint 146 %uint_147 = OpConstant %uint 147 %uint_149 = OpConstant %uint 149 %uint_41 = OpConstant %uint 41 %_ptr_Uniform_mat4v4float = OpTypePointer Uniform %mat4v4float %uint_77 = OpConstant %uint 77 %uint_85 = OpConstant %uint 85 %uint_90 = OpConstant %uint 90 %uint_92 = OpConstant %uint 92 %v2int = OpTypeVector %int 2 %_ptr_Function_v2int = OpTypePointer Function %v2int %uint_57 = OpConstant %uint 57 %v3uint = OpTypeVector %uint 3 %uint_72 = OpConstant %uint 72 %uint_70 = OpConstant %uint 70 %uint_50 = OpConstant %uint 50 %uint_61 = OpConstant %uint 61 %uint_71 = OpConstant %uint 71 %uint_75 = OpConstant %uint 75 %uint_82 = OpConstant %uint 82 %type_sampled_image_0 = OpTypeSampledImage %type_2d_image_array %uint_51 = OpConstant %uint 51 %textureposition = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %samplerposition = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %textureNormal = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %samplerNormal = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %textureAlbedo = OpVariable %_ptr_UniformConstant_type_2d_image UniformConstant %samplerAlbedo = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %textureShadowMap = OpVariable %_ptr_UniformConstant_type_2d_image_array UniformConstant %samplerShadowMap = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %ubo = OpVariable %_ptr_Uniform_type_ubo Uniform %in_var_TEXCOORD0 = OpVariable %_ptr_Input_v2float Input %out_var_SV_TARGET = OpVariable %_ptr_Output_v4float Output %uint_1792 = OpConstant %uint 1792 %uint_1869 = OpConstant %uint 1869 %uint_2060 = OpConstant %uint 2060 %288 = OpExtInst %void %2 DebugInfoNone %243 = OpExtInst %void %2 DebugExpression %57 = OpExtInst %void %2 DebugTypeBasic %55 %uint_32 %uint_3 %uint_0 %58 = OpExtInst %void %2 DebugTypeVector %57 %uint_4 %60 = OpExtInst %void %2 DebugTypeVector %57 %uint_2 %62 = OpExtInst %void %2 DebugTypeFunction %uint_3 %57 %58 %57 %60 %64 = OpExtInst %void %2 DebugSource %15 %63 %65 = OpExtInst %void %2 DebugCompilationUnit %uint_1 %uint_4 %64 %uint_5 %70 = OpExtInst %void %2 DebugFunction %68 %62 %64 %uint_37 %uint_1 %65 %69 %uint_3 %uint_38 %73 = OpExtInst %void %2 DebugLexicalBlock %64 %uint_38 %uint_1 %70 %74 = OpExtInst %void %2 DebugLexicalBlock %64 %uint_44 %uint_2 %73 %76 = OpExtInst %void %2 DebugLexicalBlock %64 %uint_47 %uint_3 %74 %79 = OpExtInst %void %2 DebugLocalVariable %78 %57 %64 %uint_45 %uint_9 %74 %uint_4 %83 = OpExtInst %void %2 DebugLocalVariable %82 %58 %64 %uint_40 %uint_9 %73 %uint_4 %86 = OpExtInst %void %2 DebugLocalVariable %85 %57 %64 %uint_39 %uint_8 %73 %uint_4 %90 = OpExtInst %void %2 DebugLocalVariable %89 %60 %64 %uint_37 %uint_49 %70 %uint_4 %uint_3 %93 = OpExtInst %void %2 DebugLocalVariable %92 %57 %64 %uint_37 %uint_35 %70 %uint_4 %uint_2 %96 = OpExtInst %void %2 DebugLocalVariable %95 %58 %64 %uint_37 %uint_26 %70 %uint_4 %uint_1 %98 = OpExtInst %void %2 DebugTypeFunction %uint_3 %57 %58 %57 %100 = OpExtInst %void %2 DebugFunction %99 %98 %64 %uint_54 %uint_1 %65 %69 %uint_3 %uint_55 %103 = OpExtInst %void %2 DebugLexicalBlock %64 %uint_55 %uint_1 %100 %104 = OpExtInst %void %2 DebugLexicalBlock %64 %uint_67 %uint_2 %103 %106 = OpExtInst %void %2 DebugLexicalBlock %64 %uint_69 %uint_3 %104 %109 = OpExtInst %void %2 DebugTypeBasic %108 %uint_32 %uint_4 %uint_0 %111 = OpExtInst %void %2 DebugLocalVariable %110 %109 %64 %uint_68 %uint_12 %104 %uint_4 %115 = OpExtInst %void %2 DebugLocalVariable %114 %109 %64 %uint_66 %uint_11 %103 %uint_4 %119 = OpExtInst %void %2 DebugLocalVariable %118 %109 %64 %uint_64 %uint_6 %103 %uint_4 %123 = OpExtInst %void %2 DebugLocalVariable %122 %109 %64 %uint_63 %uint_6 %103 %uint_4 %126 = OpExtInst %void %2 DebugLocalVariable %125 %57 %64 %uint_62 %uint_8 %103 %uint_4 %129 = OpExtInst %void %2 DebugLocalVariable %128 %57 %64 %uint_60 %uint_8 %103 %uint_4 %132 = OpExtInst %void %2 DebugLocalVariable %131 %57 %64 %uint_59 %uint_8 %103 %uint_4 %135 = OpExtInst %void %2 DebugLocalVariable %134 %57 %64 %uint_58 %uint_8 %103 %uint_4 %138 = OpExtInst %void %2 DebugLocalVariable %137 %109 %64 %uint_56 %uint_33 %103 %uint_4 %142 = OpExtInst %void %2 DebugLocalVariable %141 %109 %64 %uint_56 %uint_19 %103 %uint_4 %144 = OpExtInst %void %2 DebugTypeVector %109 %uint_2 %146 = OpExtInst %void %2 DebugLocalVariable %145 %144 %64 %uint_56 %uint_7 %103 %uint_4 %148 = OpExtInst %void %2 DebugLocalVariable %92 %57 %64 %uint_54 %uint_34 %100 %uint_4 %uint_2 %151 = OpExtInst %void %2 DebugLocalVariable %150 %58 %64 %uint_54 %uint_24 %100 %uint_4 %uint_1 %153 = OpExtInst %void %2 DebugTypeVector %57 %uint_3 %154 = OpExtInst %void %2 DebugTypeFunction %uint_3 %153 %153 %153 %155 = OpExtInst %void %2 DebugFunction %85 %154 %64 %uint_78 %uint_1 %65 %69 %uint_3 %uint_78 %157 = OpExtInst %void %2 DebugLexicalBlock %64 %uint_78 %uint_49 %155 %158 = OpExtInst %void %2 DebugLexicalBlock %64 %uint_80 %uint_2 %157 %160 = OpExtInst %void %2 DebugLocalVariable %125 %57 %64 %uint_83 %uint_9 %158 %uint_4 %163 = OpExtInst %void %2 DebugLocalVariable %162 %58 %64 %uint_81 %uint_10 %158 %uint_4 %167 = OpExtInst %void %2 DebugLocalVariable %166 %109 %64 %uint_79 %uint_11 %157 %uint_4 %170 = OpExtInst %void %2 DebugLocalVariable %169 %153 %64 %uint_78 %uint_40 %155 %uint_4 %uint_2 %172 = OpExtInst %void %2 DebugLocalVariable %171 %153 %64 %uint_78 %uint_22 %155 %uint_4 %uint_1 %174 = OpExtInst %void %2 DebugTypeFunction %uint_3 %58 %60 %176 = OpExtInst %void %2 DebugFunction %175 %174 %64 %uint_95 %uint_1 %65 %69 %uint_3 %uint_96 %179 = OpExtInst %void %2 DebugLexicalBlock %64 %uint_96 %uint_1 %176 %180 = OpExtInst %void %2 DebugLexicalBlock %64 %uint_145 %uint_2 %179 %182 = OpExtInst %void %2 DebugLexicalBlock %64 %uint_108 %uint_2 %179 %185 = OpExtInst %void %2 DebugLocalVariable %184 %153 %64 %uint_138 %uint_10 %182 %uint_4 %188 = OpExtInst %void %2 DebugLocalVariable %187 %57 %64 %uint_137 %uint_9 %182 %uint_4 %191 = OpExtInst %void %2 DebugLocalVariable %190 %153 %64 %uint_136 %uint_10 %182 %uint_4 %194 = OpExtInst %void %2 DebugLocalVariable %193 %153 %64 %uint_133 %uint_10 %182 %uint_4 %197 = OpExtInst %void %2 DebugLocalVariable %196 %57 %64 %uint_132 %uint_9 %182 %uint_4 %200 = OpExtInst %void %2 DebugLocalVariable %199 %57 %64 %uint_129 %uint_9 %182 %uint_4 %203 = OpExtInst %void %2 DebugLocalVariable %202 %57 %64 %uint_128 %uint_9 %182 %uint_4 %206 = OpExtInst %void %2 DebugLocalVariable %205 %57 %64 %uint_127 %uint_9 %182 %uint_4 %209 = OpExtInst %void %2 DebugLocalVariable %208 %153 %64 %uint_124 %uint_10 %182 %uint_4 %212 = OpExtInst %void %2 DebugLocalVariable %211 %57 %64 %uint_121 %uint_9 %182 %uint_4 %215 = OpExtInst %void %2 DebugLocalVariable %214 %57 %64 %uint_120 %uint_9 %182 %uint_4 %218 = OpExtInst %void %2 DebugLocalVariable %217 %57 %64 %uint_119 %uint_9 %182 %uint_4 %221 = OpExtInst %void %2 DebugLocalVariable %220 %153 %64 %uint_116 %uint_10 %182 %uint_4 %223 = OpExtInst %void %2 DebugLocalVariable %78 %57 %64 %uint_112 %uint_9 %182 %uint_4 %226 = OpExtInst %void %2 DebugLocalVariable %225 %153 %64 %uint_110 %uint_10 %182 %uint_4 %228 = OpExtInst %void %2 DebugLocalVariable %166 %109 %64 %uint_107 %uint_10 %179 %uint_4 %231 = OpExtInst %void %2 DebugLocalVariable %230 %153 %64 %uint_105 %uint_9 %179 %uint_4 %233 = OpExtInst %void %2 DebugLocalVariable %171 %153 %64 %uint_103 %uint_9 %179 %uint_4 %236 = OpExtInst %void %2 DebugLocalVariable %235 %58 %64 %uint_100 %uint_9 %179 %uint_4 %239 = OpExtInst %void %2 DebugLocalVariable %238 %153 %64 %uint_99 %uint_9 %179 %uint_4 %241 = OpExtInst %void %2 DebugLocalVariable %169 %153 %64 %uint_98 %uint_9 %179 %uint_4 %245 = OpExtInst %void %2 DebugLocalVariable %244 %60 %64 %uint_95 %uint_40 %176 %uint_4 %uint_1 )" R"( %247 = OpExtInst %void %2 DebugTypeMember %246 %58 %64 %uint_29 %uint_9 %uint_0 %uint_128 %uint_3 %250 = OpExtInst %void %2 DebugTypeMember %249 %58 %64 %uint_21 %uint_9 %uint_0 %uint_128 %uint_3 %253 = OpExtInst %void %2 DebugTypeMember %252 %58 %64 %uint_22 %uint_9 %uint_128 %uint_128 %uint_3 %256 = OpExtInst %void %2 DebugTypeMember %254 %58 %64 %uint_23 %uint_9 %uint_256 %uint_128 %uint_3 %258 = OpExtInst %void %2 DebugTypeArray %57 %uint_4 %uint_4 %262 = OpExtInst %void %2 DebugTypeMember %259 %258 %64 %uint_24 %uint_11 %uint_384 %uint_512 %uint_3 %265 = OpExtInst %void %2 DebugTypeComposite %263 %uint_1 %64 %uint_19 %uint_8 %65 %263 %uint_896 %uint_3 %250 %253 %256 %262 %266 = OpExtInst %void %2 DebugTypeArray %265 %uint_3 %269 = OpExtInst %void %2 DebugTypeMember %267 %266 %64 %uint_30 %uint_8 %uint_128 %uint_2688 %uint_3 %273 = OpExtInst %void %2 DebugTypeMember %271 %109 %64 %uint_31 %uint_6 %uint_2816 %uint_32 %uint_3 %277 = OpExtInst %void %2 DebugTypeMember %275 %109 %64 %uint_32 %uint_6 %uint_2848 %uint_32 %uint_3 %280 = OpExtInst %void %2 DebugTypeComposite %278 %uint_1 %64 %uint_27 %uint_8 %65 %278 %uint_2880 %uint_3 %247 %269 %273 %277 %284 = OpExtInst %void %2 DebugTypeMember %282 %280 %64 %uint_35 %uint_34 %uint_0 %uint_2944 %uint_3 %286 = OpExtInst %void %2 DebugTypeComposite %285 %uint_1 %64 %uint_35 %uint_9 %65 %285 %uint_2944 %uint_3 %284 %287 = OpExtInst %void %2 DebugGlobalVariable %282 %286 %64 %uint_35 %uint_9 %65 %282 %ubo %uint_8 %291 = OpExtInst %void %2 DebugTypeComposite %289 %uint_1 %64 %uint_0 %uint_0 %65 %290 %288 %uint_3 %293 = OpExtInst %void %2 DebugGlobalVariable %292 %291 %64 %uint_12 %uint_14 %65 %292 %samplerShadowMap %uint_8 %297 = OpExtInst %void %2 DebugTypeComposite %295 %uint_0 %64 %uint_0 %uint_0 %65 %296 %288 %uint_3 %299 = OpExtInst %void %2 DebugTypeTemplateParameter %298 %58 %288 %64 %uint_0 %uint_0 %300 = OpExtInst %void %2 DebugTypeTemplate %297 %299 %302 = OpExtInst %void %2 DebugGlobalVariable %301 %300 %64 %uint_11 %uint_16 %65 %301 %textureShadowMap %uint_8 %305 = OpExtInst %void %2 DebugGlobalVariable %304 %291 %64 %uint_8 %uint_14 %65 %304 %samplerAlbedo %uint_8 %308 = OpExtInst %void %2 DebugTypeComposite %306 %uint_0 %64 %uint_0 %uint_0 %65 %307 %288 %uint_3 %309 = OpExtInst %void %2 DebugTypeTemplateParameter %298 %58 %288 %64 %uint_0 %uint_0 %310 = OpExtInst %void %2 DebugTypeTemplate %308 %309 %312 = OpExtInst %void %2 DebugGlobalVariable %311 %310 %64 %uint_7 %uint_11 %65 %311 %textureAlbedo %uint_8 %314 = OpExtInst %void %2 DebugGlobalVariable %313 %291 %64 %uint_6 %uint_14 %65 %313 %samplerNormal %uint_8 %316 = OpExtInst %void %2 DebugGlobalVariable %315 %310 %64 %uint_5 %uint_11 %65 %315 %textureNormal %uint_8 %318 = OpExtInst %void %2 DebugGlobalVariable %317 %291 %64 %uint_4 %uint_14 %65 %317 %samplerposition %uint_8 %320 = OpExtInst %void %2 DebugGlobalVariable %319 %310 %64 %uint_3 %uint_11 %65 %319 %textureposition %uint_8 %1803 = OpExtInst %void %2 DebugInlinedAt %uint_1792 %180 %1885 = OpExtInst %void %2 DebugInlinedAt %uint_1869 %158 %1803 %2085 = OpExtInst %void %2 DebugInlinedAt %uint_2060 %106 %1885 )" R"( %main = OpFunction %void None %321 %322 = OpLabel %2083 = OpVariable %_ptr_Function_float Function %2086 = OpVariable %_ptr_Function_v4float Function %1883 = OpVariable %_ptr_Function_v2int Function %1891 = OpVariable %_ptr_Function_float Function %1892 = OpVariable %_ptr_Function_int Function %1894 = OpVariable %_ptr_Function_int Function %1895 = OpVariable %_ptr_Function_int Function %1896 = OpVariable %_ptr_Function_v4float Function %1801 = OpVariable %_ptr_Function_int Function %1447 = OpVariable %_ptr_Function_v4float Function %1448 = OpVariable %_ptr_Function_v3float Function %1450 = OpVariable %_ptr_Function_int Function %1451 = OpVariable %_ptr_Function_v3float Function %1453 = OpVariable %_ptr_Function_v3float Function %1466 = OpVariable %_ptr_Function_v3float Function %param_var_inUV = OpVariable %_ptr_Function_v2float Function %325 = OpExtInst %void %2 DebugFunctionDefinition %176 %main %326 = OpLoad %v2float %in_var_TEXCOORD0 OpStore %param_var_inUV %326 %2290 = OpExtInst %void %2 DebugScope %176 %1620 = OpExtInst %void %2 DebugLine %64 %uint_95 %uint_95 %uint_33 %uint_40 %1470 = OpExtInst %void %2 DebugDeclare %245 %param_var_inUV %243 %2291 = OpExtInst %void %2 DebugScope %179 %1621 = OpExtInst %void %2 DebugLine %64 %uint_98 %uint_98 %uint_19 %uint_19 %1471 = OpLoad %type_2d_image %textureposition %1622 = OpExtInst %void %2 DebugLine %64 %uint_98 %uint_98 %uint_42 %uint_42 %1472 = OpLoad %type_sampler %samplerposition %1624 = OpExtInst %void %2 DebugLine %64 %uint_98 %uint_98 %uint_19 %uint_63 %1474 = OpSampledImage %type_sampled_image %1471 %1472 %1475 = OpImageSampleImplicitLod %v4float %1474 %326 None %1626 = OpExtInst %void %2 DebugLine %64 %uint_98 %uint_98 %uint_19 %uint_65 %1476 = OpVectorShuffle %v3float %1475 %1475 0 1 2 %2241 = OpExtInst %void %2 DebugLine %64 %uint_98 %uint_98 %uint_2 %uint_65 %2240 = OpExtInst %void %2 DebugValue %241 %1476 %243 %1629 = OpExtInst %void %2 DebugLine %64 %uint_99 %uint_99 %uint_18 %uint_18 %1478 = OpLoad %type_2d_image %textureNormal %1630 = OpExtInst %void %2 DebugLine %64 %uint_99 %uint_99 %uint_39 %uint_39 %1479 = OpLoad %type_sampler %samplerNormal %1632 = OpExtInst %void %2 DebugLine %64 %uint_99 %uint_99 %uint_18 %uint_58 %1481 = OpSampledImage %type_sampled_image %1478 %1479 %1482 = OpImageSampleImplicitLod %v4float %1481 %326 None %1634 = OpExtInst %void %2 DebugLine %64 %uint_99 %uint_99 %uint_18 %uint_60 %1483 = OpVectorShuffle %v3float %1482 %1482 0 1 2 %2244 = OpExtInst %void %2 DebugLine %64 %uint_99 %uint_99 %uint_2 %uint_60 %2243 = OpExtInst %void %2 DebugValue %239 %1483 %243 %1637 = OpExtInst %void %2 DebugLine %64 %uint_100 %uint_100 %uint_18 %uint_18 %1485 = OpLoad %type_2d_image %textureAlbedo %1638 = OpExtInst %void %2 DebugLine %64 %uint_100 %uint_100 %uint_39 %uint_39 %1486 = OpLoad %type_sampler %samplerAlbedo %1640 = OpExtInst %void %2 DebugLine %64 %uint_100 %uint_100 %uint_18 %uint_58 %1488 = OpSampledImage %type_sampled_image %1485 %1486 %1489 = OpImageSampleImplicitLod %v4float %1488 %326 None %1642 = OpExtInst %void %2 DebugLine %64 %uint_100 %uint_100 %uint_2 %uint_58 OpStore %1447 %1489 %1490 = OpExtInst %void %2 DebugDeclare %236 %1447 %243 %1645 = OpExtInst %void %2 DebugLine %64 %uint_103 %uint_103 %uint_22 %uint_29 %1492 = OpVectorShuffle %v3float %1489 %1489 0 1 2 %1646 = OpExtInst %void %2 DebugLine %64 %uint_103 %uint_103 %uint_22 %uint_35 %1493 = OpVectorTimesScalar %v3float %1492 %float_0_100000001 %1647 = OpExtInst %void %2 DebugLine %64 %uint_103 %uint_103 %uint_2 %uint_35 OpStore %1448 %1493 %1494 = OpExtInst %void %2 DebugDeclare %233 %1448 %243 %1650 = OpExtInst %void %2 DebugLine %64 %uint_105 %uint_105 %uint_13 %uint_29 %1496 = OpExtInst %v3float %1 Normalize %1483 %2247 = OpExtInst %void %2 DebugLine %64 %uint_105 %uint_105 %uint_2 %uint_29 %2246 = OpExtInst %void %2 DebugValue %231 %1496 %243 %1653 = OpExtInst %void %2 DebugLine %64 %uint_107 %uint_107 %uint_6 %uint_14 OpStore %1450 %int_0 %1498 = OpExtInst %void %2 DebugDeclare %228 %1450 %243 %1655 = OpExtInst %void %2 DebugLine %64 %uint_107 %uint_107 %uint_6 %uint_15 OpBranch %1499 %1499 = OpLabel %2292 = OpExtInst %void %2 DebugScope %179 %1656 = OpExtInst %void %2 DebugLine %64 %uint_107 %uint_107 %uint_17 %uint_17 %1500 = OpLoad %int %1450 %1657 = OpExtInst %void %2 DebugLine %64 %uint_107 %uint_107 %uint_17 %uint_21 %1501 = OpSLessThan %bool %1500 %int_3 %2293 = OpExtInst %void %2 DebugNoScope OpLoopMerge %1605 %1602 None OpBranchConditional %1501 %1502 %1605 %1502 = OpLabel %2294 = OpExtInst %void %2 DebugScope %182 %1660 = OpExtInst %void %2 DebugLine %64 %uint_110 %uint_110 %uint_25 %uint_25 %1503 = OpLoad %int %1450 %1661 = OpExtInst %void %2 DebugLine %64 %uint_110 %uint_110 %uint_14 %uint_37 %1504 = OpAccessChain %_ptr_Uniform_UBO %ubo %int_0 %1505 = OpAccessChain %_ptr_Uniform_v4float %1504 %int_1 %1503 %int_0 %1663 = OpExtInst %void %2 DebugLine %64 %uint_110 %uint_110 %uint_14 %uint_28 %1506 = OpLoad %v4float %1505 %1664 = OpExtInst %void %2 DebugLine %64 %uint_110 %uint_110 %uint_14 %uint_37 %1507 = OpVectorShuffle %v3float %1506 %1506 0 1 2 %1666 = OpExtInst %void %2 DebugLine %64 %uint_110 %uint_110 %uint_14 %uint_43 %1509 = OpFSub %v3float %1507 %1476 %1667 = OpExtInst %void %2 DebugLine %64 %uint_110 %uint_110 %uint_3 %uint_43 OpStore %1451 %1509 %1510 = OpExtInst %void %2 DebugDeclare %226 %1451 %243 %1670 = OpExtInst %void %2 DebugLine %64 %uint_112 %uint_112 %uint_16 %uint_24 %1512 = OpExtInst %float %1 Length %1509 %2250 = OpExtInst %void %2 DebugLine %64 %uint_112 %uint_112 %uint_3 %uint_24 %2249 = OpExtInst %void %2 DebugValue %223 %1512 %243 %1674 = OpExtInst %void %2 DebugLine %64 %uint_113 %uint_113 %uint_7 %uint_18 %1515 = OpExtInst %v3float %1 Normalize %1509 %1675 = OpExtInst %void %2 DebugLine %64 %uint_113 %uint_113 %uint_3 %uint_18 OpStore %1451 %1515 %1676 = OpExtInst %void %2 DebugLine %64 %uint_116 %uint_116 %uint_14 %uint_26 %1516 = OpAccessChain %_ptr_Uniform_UBO %ubo %int_0 %1517 = OpAccessChain %_ptr_Uniform_v4float %1516 %int_0 %1678 = OpExtInst %void %2 DebugLine %64 %uint_116 %uint_116 %uint_14 %uint_18 %1518 = OpLoad %v4float %1517 %1679 = OpExtInst %void %2 DebugLine %64 %uint_116 %uint_116 %uint_14 %uint_26 %1519 = OpVectorShuffle %v3float %1518 %1518 0 1 2 %1681 = OpExtInst %void %2 DebugLine %64 %uint_116 %uint_116 %uint_14 %uint_32 %1521 = OpFSub %v3float %1519 %1476 %1682 = OpExtInst %void %2 DebugLine %64 %uint_116 %uint_116 %uint_3 %uint_32 OpStore %1453 %1521 %1522 = OpExtInst %void %2 DebugDeclare %221 %1453 %243 %1685 = OpExtInst %void %2 DebugLine %64 %uint_117 %uint_117 %uint_7 %uint_18 %1524 = OpExtInst %v3float %1 Normalize %1521 %1686 = OpExtInst %void %2 DebugLine %64 %uint_117 %uint_117 %uint_3 %uint_18 OpStore %1453 %1524 %1687 = OpExtInst %void %2 DebugLine %64 %uint_119 %uint_119 %uint_34 %uint_46 %1525 = OpExtInst %float %1 Radians %float_15 %1688 = OpExtInst %void %2 DebugLine %64 %uint_119 %uint_119 %uint_30 %uint_47 %1526 = OpExtInst %float %1 Cos %1525 %2253 = OpExtInst %void %2 DebugLine %64 %uint_119 %uint_119 %uint_3 %uint_47 %2252 = OpExtInst %void %2 DebugValue %218 %1526 %243 %1691 = OpExtInst %void %2 DebugLine %64 %uint_120 %uint_120 %uint_34 %uint_46 %1528 = OpExtInst %float %1 Radians %float_25 %1692 = OpExtInst %void %2 DebugLine %64 %uint_120 %uint_120 %uint_30 %uint_47 %1529 = OpExtInst %float %1 Cos %1528 %2256 = OpExtInst %void %2 DebugLine %64 %uint_120 %uint_120 %uint_3 %uint_47 %2255 = OpExtInst %void %2 DebugValue %215 %1529 %243 %2259 = OpExtInst %void %2 DebugLine %64 %uint_121 %uint_121 %uint_3 %uint_22 %2258 = OpExtInst %void %2 DebugValue %212 %float_100 %243 %1698 = OpExtInst %void %2 DebugLine %64 %uint_124 %uint_124 %uint_26 %uint_49 %1533 = OpAccessChain %_ptr_Uniform_UBO %ubo %int_0 %1534 = OpAccessChain %_ptr_Uniform_v4float %1533 %int_1 %1503 %int_0 %1700 = OpExtInst %void %2 DebugLine %64 %uint_124 %uint_124 %uint_26 %uint_40 %1535 = OpLoad %v4float %1534 %1701 = OpExtInst %void %2 DebugLine %64 %uint_124 %uint_124 %uint_26 %uint_49 %1536 = OpVectorShuffle %v3float %1535 %1535 0 1 2 %1703 = OpExtInst %void %2 DebugLine %64 %uint_124 %uint_124 %uint_55 %uint_76 %1538 = OpAccessChain %_ptr_Uniform_UBO %ubo %int_0 %1539 = OpAccessChain %_ptr_Uniform_v4float %1538 %int_1 %1503 %int_1 %1705 = OpExtInst %void %2 DebugLine %64 %uint_124 %uint_124 %uint_55 %uint_69 %1540 = OpLoad %v4float %1539 %1706 = OpExtInst %void %2 DebugLine %64 %uint_124 %uint_124 %uint_55 %uint_76 %1541 = OpVectorShuffle %v3float %1540 %1540 0 1 2 %1707 = OpExtInst %void %2 DebugLine %64 %uint_124 %uint_124 %uint_26 %uint_76 %1542 = OpFSub %v3float %1536 %1541 %1708 = OpExtInst %void %2 DebugLine %64 %uint_124 %uint_124 %uint_16 %uint_79 %1543 = OpExtInst %v3float %1 Normalize %1542 %2262 = OpExtInst %void %2 DebugLine %64 %uint_124 %uint_124 %uint_3 %uint_79 %2261 = OpExtInst %void %2 DebugValue %209 %1543 %243 %1713 = OpExtInst %void %2 DebugLine %64 %uint_127 %uint_127 %uint_18 %uint_28 %1547 = OpDot %float %1515 %1543 %2265 = OpExtInst %void %2 DebugLine %64 %uint_127 %uint_127 %uint_3 %uint_28 %2264 = OpExtInst %void %2 DebugValue %206 %1547 %243 %1719 = OpExtInst %void %2 DebugLine %64 %uint_128 %uint_128 %uint_22 %uint_79 %1552 = OpExtInst %float %1 SmoothStep %1529 %1526 %1547 %2268 = OpExtInst %void %2 DebugLine %64 %uint_128 %uint_128 %uint_3 %uint_79 %2267 = OpExtInst %void %2 DebugValue %203 %1552 %243 %1724 = OpExtInst %void %2 DebugLine %64 %uint_129 %uint_129 %uint_29 %uint_62 %1556 = OpExtInst %float %1 SmoothStep %float_100 %float_0 %1512 %2271 = OpExtInst %void %2 DebugLine %64 %uint_129 %uint_129 %uint_3 %uint_62 %2270 = OpExtInst %void %2 DebugValue %200 %1556 %243 %1729 = OpExtInst %void %2 DebugLine %64 %uint_132 %uint_132 %uint_26 %uint_34 %1560 = OpDot %float %1496 %1515 %1730 = OpExtInst %void %2 DebugLine %64 %uint_132 %uint_132 %uint_17 %uint_35 %1561 = OpExtInst %float %1 FMax %float_0 %1560 %2274 = OpExtInst %void %2 DebugLine %64 %uint_132 %uint_132 %uint_3 %uint_35 %2273 = OpExtInst %void %2 DebugValue %197 %1561 %243 %1734 = OpExtInst %void %2 DebugLine %64 %uint_133 %uint_133 %uint_17 %uint_23 %1564 = OpCompositeConstruct %v3float %1561 %1561 %1561 %2277 = OpExtInst %void %2 DebugLine %64 %uint_133 %uint_133 %uint_3 %uint_23 %2276 = OpExtInst %void %2 DebugValue %194 %1564 %243 %1738 = OpExtInst %void %2 DebugLine %64 %uint_136 %uint_136 %uint_22 %uint_23 %1567 = OpFNegate %v3float %1515 %1740 = OpExtInst %void %2 DebugLine %64 %uint_136 %uint_136 %uint_14 %uint_27 %1569 = OpExtInst %v3float %1 Reflect %1567 %1496 %2280 = OpExtInst %void %2 DebugLine %64 %uint_136 %uint_136 %uint_3 %uint_27 %2279 = OpExtInst %void %2 DebugValue %191 %1569 %243 %1745 = OpExtInst %void %2 DebugLine %64 %uint_137 %uint_137 %uint_26 %uint_34 %1573 = OpDot %float %1569 %1524 %1746 = OpExtInst %void %2 DebugLine %64 %uint_137 %uint_137 %uint_17 %uint_35 %1574 = OpExtInst %float %1 FMax %float_0 %1573 %2283 = OpExtInst %void %2 DebugLine %64 %uint_137 %uint_137 %uint_3 %uint_35 %2282 = OpExtInst %void %2 DebugValue %188 %1574 %243 %1750 = OpExtInst %void %2 DebugLine %64 %uint_138 %uint_138 %uint_18 %uint_33 %1577 = OpExtInst %float %1 Pow %1574 %float_16 %1751 = OpExtInst %void %2 DebugLine %64 %uint_138 %uint_138 %uint_37 %uint_44 %1578 = OpAccessChain %_ptr_Function_float %1447 %int_3 %1579 = OpLoad %float %1578 %1753 = OpExtInst %void %2 DebugLine %64 %uint_138 %uint_138 %uint_18 %uint_44 %1580 = OpFMul %float %1577 %1579 %1754 = OpExtInst %void %2 DebugLine %64 %uint_138 %uint_138 %uint_18 %uint_48 %1581 = OpFMul %float %1580 %float_2_5 %1755 = OpExtInst %void %2 DebugLine %64 %uint_138 %uint_138 %uint_17 %uint_53 %1582 = OpCompositeConstruct %v3float %1581 %1581 %1581 %2286 = OpExtInst %void %2 DebugLine %64 %uint_138 %uint_138 %uint_3 %uint_53 %2285 = OpExtInst %void %2 DebugValue %185 %1582 %243 %1760 = OpExtInst %void %2 DebugLine %64 %uint_140 %uint_140 %uint_24 %uint_31 %1586 = OpFAdd %v3float %1564 %1582 %1762 = OpExtInst %void %2 DebugLine %64 %uint_140 %uint_140 %uint_23 %uint_39 %1588 = OpVectorTimesScalar %v3float %1586 %1552 %1764 = OpExtInst %void %2 DebugLine %64 %uint_140 %uint_140 %uint_23 %uint_52 %1590 = OpVectorTimesScalar %v3float %1588 %1556 %1766 = OpExtInst %void %2 DebugLine %64 %uint_140 %uint_140 %uint_73 %uint_93 %1592 = OpAccessChain %_ptr_Uniform_UBO %ubo %int_0 %1593 = OpAccessChain %_ptr_Uniform_v4float %1592 %int_1 %1503 %int_2 %1768 = OpExtInst %void %2 DebugLine %64 %uint_140 %uint_140 %uint_73 %uint_87 %1594 = OpLoad %v4float %1593 %1769 = OpExtInst %void %2 DebugLine %64 %uint_140 %uint_140 %uint_73 %uint_93 %1595 = OpVectorShuffle %v3float %1594 %1594 0 1 2 %1770 = OpExtInst %void %2 DebugLine %64 %uint_140 %uint_140 %uint_16 %uint_93 %1596 = OpFMul %v3float %1590 %1595 %1772 = OpExtInst %void %2 DebugLine %64 %uint_140 %uint_140 %uint_99 %uint_106 %1598 = OpVectorShuffle %v3float %1489 %1489 0 1 2 %1773 = OpExtInst %void %2 DebugLine %64 %uint_140 %uint_140 %uint_16 %uint_106 %1599 = OpFMul %v3float %1596 %1598 %1774 = OpExtInst %void %2 DebugLine %64 %uint_140 %uint_140 %uint_3 %uint_3 %1600 = OpLoad %v3float %1448 %1775 = OpExtInst %void %2 DebugLine %64 %uint_140 %uint_140 %uint_3 %uint_106 %1601 = OpFAdd %v3float %1600 %1599 OpStore %1448 %1601 %2295 = OpExtInst %void %2 DebugScope %179 %1777 = OpExtInst %void %2 DebugLine %64 %uint_107 %uint_107 %uint_34 %uint_36 OpBranch %1602 %1602 = OpLabel %2296 = OpExtInst %void %2 DebugScope %179 %1778 = OpExtInst %void %2 DebugLine %64 %uint_107 %uint_107 %uint_34 %uint_36 %1603 = OpLoad %int %1450 %1604 = OpIAdd %int %1603 %int_1 OpStore %1450 %1604 OpBranch %1499 %1605 = OpLabel %2297 = OpExtInst %void %2 DebugScope %179 %1782 = OpExtInst %void %2 DebugLine %64 %uint_144 %uint_144 %uint_6 %uint_10 %1606 = OpAccessChain %_ptr_Uniform_UBO %ubo %int_0 %1607 = OpAccessChain %_ptr_Uniform_int %1606 %int_2 %1608 = OpLoad %int %1607 %1785 = OpExtInst %void %2 DebugLine %64 %uint_144 %uint_144 %uint_6 %uint_23 %1609 = OpSGreaterThan %bool %1608 %int_0 %2298 = OpExtInst %void %2 DebugNoScope OpSelectionMerge %1614 None OpBranchConditional %1609 %1610 %1614 )" R"( %1610 = OpLabel %2299 = OpExtInst %void %2 DebugScope %180 %1788 = OpExtInst %void %2 DebugLine %64 %uint_146 %uint_146 %uint_22 %uint_22 %1611 = OpLoad %v3float %1448 OpStore %1466 %1611 %2300 = OpExtInst %void %2 DebugScope %155 %1803 %1842 = OpExtInst %void %2 DebugLine %64 %uint_78 %uint_78 %uint_15 %uint_22 %1810 = OpExtInst %void %2 DebugDeclare %172 %1466 %243 %2301 = OpExtInst %void %2 DebugScope %180 %2289 = OpExtInst %void %2 DebugLine %64 %uint_146 %uint_146 %uint_33 %uint_33 %2288 = OpExtInst %void %2 DebugValue %170 %1476 %243 %2302 = OpExtInst %void %2 DebugScope %157 %1803 %1844 = OpExtInst %void %2 DebugLine %64 %uint_79 %uint_79 %uint_7 %uint_15 OpStore %1801 %int_0 %1813 = OpExtInst %void %2 DebugDeclare %167 %1801 %243 %1846 = OpExtInst %void %2 DebugLine %64 %uint_79 %uint_79 %uint_7 %uint_16 OpBranch %1814 %1814 = OpLabel %2303 = OpExtInst %void %2 DebugScope %157 %1803 %1847 = OpExtInst %void %2 DebugLine %64 %uint_79 %uint_79 %uint_18 %uint_18 %1815 = OpLoad %int %1801 %1848 = OpExtInst %void %2 DebugLine %64 %uint_79 %uint_79 %uint_18 %uint_22 %1816 = OpSLessThan %bool %1815 %int_3 %2304 = OpExtInst %void %2 DebugNoScope OpLoopMerge %1840 %1837 None OpBranchConditional %1816 %1817 %1840 %1817 = OpLabel %2305 = OpExtInst %void %2 DebugScope %158 %1803 %1851 = OpExtInst %void %2 DebugLine %64 %uint_81 %uint_81 %uint_38 %uint_38 %1818 = OpLoad %int %1801 %1852 = OpExtInst %void %2 DebugLine %64 %uint_81 %uint_81 %uint_27 %uint_41 %1819 = OpAccessChain %_ptr_Uniform_UBO %ubo %int_0 %1820 = OpAccessChain %_ptr_Uniform_mat4v4float %1819 %int_1 %1818 %int_3 %1821 = OpLoad %mat4v4float %1820 %1856 = OpExtInst %void %2 DebugLine %64 %uint_81 %uint_81 %uint_60 %uint_68 %1823 = OpCompositeExtract %float %1476 0 %1824 = OpCompositeExtract %float %1476 1 %1825 = OpCompositeExtract %float %1476 2 %1859 = OpExtInst %void %2 DebugLine %64 %uint_81 %uint_81 %uint_53 %uint_76 %1826 = OpCompositeConstruct %v4float %1823 %1824 %1825 %float_1 %1860 = OpExtInst %void %2 DebugLine %64 %uint_81 %uint_81 %uint_23 %uint_77 %1827 = OpVectorTimesMatrix %v4float %1826 %1821 %2229 = OpExtInst %void %2 DebugLine %64 %uint_81 %uint_81 %uint_3 %uint_77 %2228 = OpExtInst %void %2 DebugValue %163 %1827 %243 %1867 = OpExtInst %void %2 DebugLine %64 %uint_85 %uint_85 %uint_40 %uint_40 %1832 = OpConvertSToF %float %1818 %2235 = OpExtInst %void %2 DebugLine %64 %uint_85 %uint_85 %uint_28 %uint_28 %2234 = OpExtInst %void %2 DebugValue %151 %1827 %243 %2238 = OpExtInst %void %2 DebugLine %64 %uint_85 %uint_85 %uint_40 %uint_40 %2237 = OpExtInst %void %2 DebugValue %148 %1832 %243 %2306 = OpExtInst %void %2 DebugScope %103 %1885 %1983 = OpExtInst %void %2 DebugLine %64 %uint_56 %uint_56 %uint_2 %uint_7 %1904 = OpExtInst %void %2 DebugDeclare %146 %1883 %243 %1986 = OpExtInst %void %2 DebugLine %64 %uint_57 %uint_57 %uint_2 %uint_2 %1907 = OpLoad %type_2d_image_array %textureShadowMap )" R"( %1987 = OpExtInst %void %2 DebugLine %64 %uint_57 %uint_57 %uint_2 %uint_72 %1908 = OpImageQuerySizeLod %v3uint %1907 %uint_0 %1909 = OpCompositeExtract %uint %1908 0 %1910 = OpBitcast %int %1909 %1911 = OpAccessChain %_ptr_Function_int %1883 %int_0 OpStore %1911 %1910 %1912 = OpCompositeExtract %uint %1908 1 %1913 = OpBitcast %int %1912 %1914 = OpAccessChain %_ptr_Function_int %1883 %int_1 OpStore %1914 %1913 %1915 = OpCompositeExtract %uint %1908 2 %1916 = OpBitcast %int %1915 %2204 = OpExtInst %void %2 DebugValue %142 %1916 %243 %1999 = OpExtInst %void %2 DebugLine %64 %uint_57 %uint_57 %uint_19 %uint_19 %1917 = OpImageQueryLevels %uint %1907 %2000 = OpExtInst %void %2 DebugLine %64 %uint_57 %uint_57 %uint_2 %uint_72 %1918 = OpBitcast %int %1917 %2207 = OpExtInst %void %2 DebugValue %138 %1918 %243 %2211 = OpExtInst %void %2 DebugLine %64 %uint_58 %uint_58 %uint_2 %uint_16 %2210 = OpExtInst %void %2 DebugValue %135 %float_1_5 %243 %2005 = OpExtInst %void %2 DebugLine %64 %uint_59 %uint_59 %uint_13 %uint_21 %1921 = OpFMul %float %float_1_5 %float_1 %2006 = OpExtInst %void %2 DebugLine %64 %uint_59 %uint_59 %uint_33 %uint_40 %1922 = OpAccessChain %_ptr_Function_int %1883 %int_0 %1923 = OpLoad %int %1922 %1924 = OpConvertSToF %float %1923 %2009 = OpExtInst %void %2 DebugLine %64 %uint_59 %uint_59 %uint_13 %uint_41 %1925 = OpFDiv %float %1921 %1924 %2214 = OpExtInst %void %2 DebugLine %64 %uint_59 %uint_59 %uint_2 %uint_41 %2213 = OpExtInst %void %2 DebugValue %132 %1925 %243 %2013 = OpExtInst %void %2 DebugLine %64 %uint_60 %uint_60 %uint_13 %uint_21 %1928 = OpFMul %float %float_1_5 %float_1 %2014 = OpExtInst %void %2 DebugLine %64 %uint_60 %uint_60 %uint_33 %uint_40 %1929 = OpAccessChain %_ptr_Function_int %1883 %int_1 %1930 = OpLoad %int %1929 %1931 = OpConvertSToF %float %1930 %2017 = OpExtInst %void %2 DebugLine %64 %uint_60 %uint_60 %uint_13 %uint_41 %1932 = OpFDiv %float %1928 %1931 %2217 = OpExtInst %void %2 DebugLine %64 %uint_60 %uint_60 %uint_2 %uint_41 %2216 = OpExtInst %void %2 DebugValue %129 %1932 %243 %2020 = OpExtInst %void %2 DebugLine %64 %uint_62 %uint_62 %uint_2 %uint_23 OpStore %1891 %float_0 %1934 = OpExtInst %void %2 DebugDeclare %126 %1891 %243 %2022 = OpExtInst %void %2 DebugLine %64 %uint_63 %uint_63 %uint_2 %uint_14 OpStore %1892 %int_0 %1935 = OpExtInst %void %2 DebugDeclare %123 %1892 %243 %2220 = OpExtInst %void %2 DebugLine %64 %uint_64 %uint_64 %uint_2 %uint_14 %2219 = OpExtInst %void %2 DebugValue %119 %int_1 %243 %2027 = OpExtInst %void %2 DebugLine %64 %uint_66 %uint_66 %uint_15 %uint_16 %1938 = OpSNegate %int %int_1 %2028 = OpExtInst %void %2 DebugLine %64 %uint_66 %uint_66 %uint_7 %uint_16 OpStore %1894 %1938 %1939 = OpExtInst %void %2 DebugDeclare %115 %1894 %243 %2030 = OpExtInst %void %2 DebugLine %64 %uint_66 %uint_66 %uint_7 %uint_21 OpBranch %1940 %1940 = OpLabel %2307 = OpExtInst %void %2 DebugScope %103 %1885 %2031 = OpExtInst %void %2 DebugLine %64 %uint_66 %uint_66 %uint_23 %uint_23 %1941 = OpLoad %int %1894 %2033 = OpExtInst %void %2 DebugLine %64 %uint_66 %uint_66 %uint_23 %uint_28 %1943 = OpSLessThanEqual %bool %1941 %int_1 %2308 = OpExtInst %void %2 DebugNoScope OpLoopMerge %1976 %1973 None OpBranchConditional %1943 %1944 %1976 %1944 = OpLabel %2309 = OpExtInst %void %2 DebugScope %104 %1885 %2037 = OpExtInst %void %2 DebugLine %64 %uint_68 %uint_68 %uint_16 %uint_17 %1946 = OpSNegate %int %int_1 %2038 = OpExtInst %void %2 DebugLine %64 %uint_68 %uint_68 %uint_8 %uint_17 OpStore %1895 %1946 %1947 = OpExtInst %void %2 DebugDeclare %111 %1895 %243 %2040 = OpExtInst %void %2 DebugLine %64 %uint_68 %uint_68 %uint_8 %uint_22 OpBranch %1948 %1948 = OpLabel %2310 = OpExtInst %void %2 DebugScope %104 %1885 %2041 = OpExtInst %void %2 DebugLine %64 %uint_68 %uint_68 %uint_24 %uint_24 %1949 = OpLoad %int %1895 %2043 = OpExtInst %void %2 DebugLine %64 %uint_68 %uint_68 %uint_24 %uint_29 %1951 = OpSLessThanEqual %bool %1949 %int_1 %2311 = OpExtInst %void %2 DebugNoScope OpLoopMerge %1972 %1969 None OpBranchConditional %1951 %1952 %1972 %1952 = OpLabel %2312 = OpExtInst %void %2 DebugScope %106 %1885 %2047 = OpExtInst %void %2 DebugLine %64 %uint_70 %uint_70 %uint_32 %uint_32 OpStore %1896 %1827 %2051 = OpExtInst %void %2 DebugLine %64 %uint_70 %uint_70 %uint_53 %uint_53 %1956 = OpLoad %int %1894 %1957 = OpConvertSToF %float %1956 %2053 = OpExtInst %void %2 DebugLine %64 %uint_70 %uint_70 %uint_50 %uint_53 %1958 = OpFMul %float %1925 %1957 %2055 = OpExtInst %void %2 DebugLine %64 %uint_70 %uint_70 %uint_59 %uint_59 %1960 = OpLoad %int %1895 %1961 = OpConvertSToF %float %1960 %2057 = OpExtInst %void %2 DebugLine %64 %uint_70 %uint_70 %uint_56 %uint_59 %1962 = OpFMul %float %1932 %1961 %2058 = OpExtInst %void %2 DebugLine %64 %uint_70 %uint_70 %uint_43 %uint_60 %1963 = OpCompositeConstruct %v2float %1958 %1962 %2313 = OpExtInst %void %2 DebugScope %70 %2085 %2141 = OpExtInst %void %2 DebugLine %64 %uint_37 %uint_37 %uint_19 %uint_26 %2090 = OpExtInst %void %2 DebugDeclare %96 %1896 %243 %2314 = OpExtInst %void %2 DebugScope %106 %1885 %2223 = OpExtInst %void %2 DebugLine %64 %uint_70 %uint_70 %uint_36 %uint_36 %2222 = OpExtInst %void %2 DebugValue %93 %1832 %243 %2226 = OpExtInst %void %2 DebugLine %64 %uint_70 %uint_70 %uint_43 %uint_60 %2225 = OpExtInst %void %2 DebugValue %90 %1963 %243 %2315 = OpExtInst %void %2 DebugScope %73 %2085 %2144 = OpExtInst %void %2 DebugLine %64 %uint_39 %uint_39 %uint_2 %uint_17 OpStore %2083 %float_1 %2094 = OpExtInst %void %2 DebugDeclare %86 %2083 %243 %2147 = OpExtInst %void %2 DebugLine %64 %uint_40 %uint_40 %uint_27 %uint_29 %2096 = OpAccessChain %_ptr_Function_float %1896 %int_3 %2097 = OpLoad %float %2096 %2098 = OpCompositeConstruct %v4float %2097 %2097 %2097 %2097 %2150 = OpExtInst %void %2 DebugLine %64 %uint_40 %uint_40 %uint_23 %uint_29 %2099 = OpFDiv %v4float %1827 %2098 %2151 = OpExtInst %void %2 DebugLine %64 %uint_40 %uint_40 %uint_2 %uint_29 OpStore %2086 %2099 %2100 = OpExtInst %void %2 DebugDeclare %83 %2086 %243 %2154 = OpExtInst %void %2 DebugLine %64 %uint_41 %uint_41 %uint_19 %uint_31 %2102 = OpVectorShuffle %v2float %2099 %2099 0 1 %2155 = OpExtInst %void %2 DebugLine %64 %uint_41 %uint_41 %uint_19 %uint_36 %2103 = OpVectorTimesScalar %v2float %2102 %float_0_5 %2156 = OpExtInst %void %2 DebugLine %64 %uint_41 %uint_41 %uint_19 %uint_42 %2104 = OpFAdd %v2float %2103 %35 %2158 = OpExtInst %void %2 DebugLine %64 %uint_41 %uint_41 %uint_2 %uint_42 %2106 = OpVectorShuffle %v4float %2099 %2104 4 5 2 3 OpStore %2086 %2106 %2160 = OpExtInst %void %2 DebugLine %64 %uint_43 %uint_43 %uint_6 %uint_18 %2107 = OpAccessChain %_ptr_Function_float %2086 %int_2 %2108 = OpLoad %float %2107 %2162 = OpExtInst %void %2 DebugLine %64 %uint_43 %uint_43 %uint_6 %uint_23 %2109 = OpFOrdGreaterThan %bool %2108 %float_n1 %2163 = OpExtInst %void %2 DebugLine %64 %uint_43 %uint_43 %uint_30 %uint_42 %2110 = OpAccessChain %_ptr_Function_float %2086 %int_2 %2111 = OpLoad %float %2110 %2165 = OpExtInst %void %2 DebugLine %64 %uint_43 %uint_43 %uint_30 %uint_46 %2112 = OpFOrdLessThan %bool %2111 %float_1 %2166 = OpExtInst %void %2 DebugLine %64 %uint_43 %uint_43 %uint_6 %uint_46 %2113 = OpLogicalAnd %bool %2109 %2112 %2316 = OpExtInst %void %2 DebugNoScope OpSelectionMerge %2139 None OpBranchConditional %2113 %2114 %2139 %2114 = OpLabel %2317 = OpExtInst %void %2 DebugScope %74 %2085 %2169 = OpExtInst %void %2 DebugLine %64 %uint_45 %uint_45 %uint_16 %uint_16 %2115 = OpLoad %type_2d_image_array %textureShadowMap %2170 = OpExtInst %void %2 DebugLine %64 %uint_45 %uint_45 %uint_40 %uint_40 %2116 = OpLoad %type_sampler %samplerShadowMap %2171 = OpExtInst %void %2 DebugLine %64 %uint_45 %uint_45 %uint_65 %uint_65 %2117 = OpLoad %v4float %2086 %2172 = OpExtInst %void %2 DebugLine %64 %uint_45 %uint_45 %uint_65 %uint_77 %2118 = OpVectorShuffle %v2float %2117 %2117 0 1 %2174 = OpExtInst %void %2 DebugLine %64 %uint_45 %uint_45 %uint_65 %uint_82 %2120 = OpFAdd %v2float %2118 %1963 %2122 = OpCompositeExtract %float %2120 0 %2123 = OpCompositeExtract %float %2120 1 %2178 = OpExtInst %void %2 DebugLine %64 %uint_45 %uint_45 %uint_58 %uint_95 %2124 = OpCompositeConstruct %v3float %2122 %2123 %1832 %2179 = OpExtInst %void %2 DebugLine %64 %uint_45 %uint_45 %uint_16 %uint_96 %2125 = OpSampledImage %type_sampled_image_0 %2115 %2116 %2126 = OpImageSampleImplicitLod %v4float %2125 %2124 None %2181 = OpExtInst %void %2 DebugLine %64 %uint_45 %uint_45 %uint_16 %uint_98 %2127 = OpCompositeExtract %float %2126 0 %2202 = OpExtInst %void %2 DebugLine %64 %uint_45 %uint_45 %uint_3 %uint_98 %2201 = OpExtInst %void %2 DebugValue %79 %2127 %243 %2184 = OpExtInst %void %2 DebugLine %64 %uint_46 %uint_46 %uint_7 %uint_19 %2129 = OpAccessChain %_ptr_Function_float %2086 %int_3 %2130 = OpLoad %float %2129 %2186 = OpExtInst %void %2 DebugLine %64 %uint_46 %uint_46 %uint_7 %uint_23 %2131 = OpFOrdGreaterThan %bool %2130 %float_0 %2188 = OpExtInst %void %2 DebugLine %64 %uint_46 %uint_46 %uint_37 %uint_49 %2133 = OpAccessChain %_ptr_Function_float %2086 %int_2 %2134 = OpLoad %float %2133 %2190 = OpExtInst %void %2 DebugLine %64 %uint_46 %uint_46 %uint_30 %uint_49 %2135 = OpFOrdLessThan %bool %2127 %2134 %2191 = OpExtInst %void %2 DebugLine %64 %uint_46 %uint_46 %uint_7 %uint_49 %2136 = OpLogicalAnd %bool %2131 %2135 %2318 = OpExtInst %void %2 DebugNoScope OpSelectionMerge %2138 None OpBranchConditional %2136 %2137 %2138 %2137 = OpLabel %2319 = OpExtInst %void %2 DebugScope %76 %2085 %2194 = OpExtInst %void %2 DebugLine %64 %uint_48 %uint_48 %uint_4 %uint_13 OpStore %2083 %float_0_25 %2320 = OpExtInst %void %2 DebugScope %74 %2085 %2195 = OpExtInst %void %2 DebugLine %64 %uint_49 %uint_49 %uint_3 %uint_3 OpBranch %2138 %2138 = OpLabel %2321 = OpExtInst %void %2 DebugScope %73 %2085 %2196 = OpExtInst %void %2 DebugLine %64 %uint_50 %uint_50 %uint_2 %uint_2 OpBranch %2139 %2139 = OpLabel %2322 = OpExtInst %void %2 DebugScope %73 %2085 %2197 = OpExtInst %void %2 DebugLine %64 %uint_51 %uint_51 %uint_9 %uint_9 %2140 = OpLoad %float %2083 %2323 = OpExtInst %void %2 DebugScope %106 %1885 %2061 = OpExtInst %void %2 DebugLine %64 %uint_70 %uint_70 %uint_4 %uint_4 %1965 = OpLoad %float %1891 %2062 = OpExtInst %void %2 DebugLine %64 %uint_70 %uint_70 %uint_4 %uint_61 %1966 = OpFAdd %float %1965 %2140 OpStore %1891 %1966 %2064 = OpExtInst %void %2 DebugLine %64 %uint_71 %uint_71 %uint_4 %uint_9 %1967 = OpLoad %int %1892 %1968 = OpIAdd %int %1967 %int_1 OpStore %1892 %1968 %2324 = OpExtInst %void %2 DebugScope %104 %1885 %2067 = OpExtInst %void %2 DebugLine %64 %uint_68 %uint_68 %uint_36 %uint_37 OpBranch %1969 %1969 = OpLabel %2325 = OpExtInst %void %2 DebugScope %104 %1885 %2068 = OpExtInst %void %2 DebugLine %64 %uint_68 %uint_68 %uint_36 %uint_37 %1970 = OpLoad %int %1895 %1971 = OpIAdd %int %1970 %int_1 OpStore %1895 %1971 OpBranch %1948 %1972 = OpLabel %2326 = OpExtInst %void %2 DebugScope %103 %1885 %2072 = OpExtInst %void %2 DebugLine %64 %uint_66 %uint_66 %uint_35 %uint_36 OpBranch %1973 %1973 = OpLabel %2327 = OpExtInst %void %2 DebugScope %103 %1885 %2073 = OpExtInst %void %2 DebugLine %64 %uint_66 %uint_66 %uint_35 %uint_36 %1974 = OpLoad %int %1894 %1975 = OpIAdd %int %1974 %int_1 OpStore %1894 %1975 OpBranch %1940 %1976 = OpLabel %2328 = OpExtInst %void %2 DebugScope %103 %1885 %2077 = OpExtInst %void %2 DebugLine %64 %uint_75 %uint_75 %uint_9 %uint_9 %1977 = OpLoad %float %1891 %2078 = OpExtInst %void %2 DebugLine %64 %uint_75 %uint_75 %uint_24 %uint_24 %1978 = OpLoad %int %1892 %1979 = OpConvertSToF %float %1978 %2080 = OpExtInst %void %2 DebugLine %64 %uint_75 %uint_75 %uint_9 %uint_24 %1980 = OpFDiv %float %1977 %1979 %2329 = OpExtInst %void %2 DebugScope %158 %1803 %2232 = OpExtInst %void %2 DebugLine %64 %uint_85 %uint_85 %uint_4 %uint_41 %2231 = OpExtInst %void %2 DebugValue %160 %1980 %243 %1872 = OpExtInst %void %2 DebugLine %64 %uint_90 %uint_90 %uint_3 %uint_3 %1835 = OpLoad %v3float %1466 %1873 = OpExtInst %void %2 DebugLine %64 %uint_90 %uint_90 %uint_3 %uint_16 %1836 = OpVectorTimesScalar %v3float %1835 %1980 OpStore %1466 %1836 %2330 = OpExtInst %void %2 DebugScope %157 %1803 %1875 = OpExtInst %void %2 DebugLine %64 %uint_79 %uint_79 %uint_35 %uint_37 OpBranch %1837 %1837 = OpLabel %2331 = OpExtInst %void %2 DebugScope %157 %1803 %1876 = OpExtInst %void %2 DebugLine %64 %uint_79 %uint_79 %uint_35 %uint_37 %1838 = OpLoad %int %1801 %1839 = OpIAdd %int %1838 %int_1 OpStore %1801 %1839 OpBranch %1814 %1840 = OpLabel %2332 = OpExtInst %void %2 DebugScope %157 %1803 %1880 = OpExtInst %void %2 DebugLine %64 %uint_92 %uint_92 %uint_9 %uint_9 %1841 = OpLoad %v3float %1466 %2333 = OpExtInst %void %2 DebugScope %180 %1793 = OpExtInst %void %2 DebugLine %64 %uint_146 %uint_146 %uint_3 %uint_40 OpStore %1448 %1841 %2334 = OpExtInst %void %2 DebugScope %179 %1794 = OpExtInst %void %2 DebugLine %64 %uint_147 %uint_147 %uint_2 %uint_2 OpBranch %1614 %1614 = OpLabel ;CHECK: %1614 = OpLabel ;CHECK-NEXT: [[phi:%\w+]] = OpPhi ;CHECK-NEXT: {{%\w+}} = OpExtInst %void {{%\w+}} DebugValue %233 %2335 = OpExtInst %void %2 DebugScope %179 %1795 = OpExtInst %void %2 DebugLine %64 %uint_149 %uint_149 %uint_16 %uint_16 %1615 = OpLoad %v3float %1448 %1616 = OpCompositeExtract %float %1615 0 %1617 = OpCompositeExtract %float %1615 1 %1618 = OpCompositeExtract %float %1615 2 %1799 = OpExtInst %void %2 DebugLine %64 %uint_149 %uint_149 %uint_9 %uint_28 %1619 = OpCompositeConstruct %v4float %1616 %1617 %1618 %float_1 %2336 = OpExtInst %void %2 DebugNoLine %2337 = OpExtInst %void %2 DebugNoScope OpStore %out_var_SV_TARGET %1619 %329 = OpExtInst %void %2 DebugLine %64 %uint_150 %uint_150 %uint_1 %uint_1 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_2); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(text, true); } // TODO(greg-lunarg): Add tests to verify handling of these cases: // // No optimization in the presence of // access chains // function calls // OpCopyMemory? // unsupported extensions // Others? } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/loop_optimizations/000077500000000000000000000000001475742701700242545ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/opt/loop_optimizations/CMakeLists.txt000066400000000000000000000024611475742701700270170ustar00rootroot00000000000000# Copyright (c) 2017 Google Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. add_spvtools_unittest(TARGET opt_loops SRCS ../function_utils.h dependence_analysis.cpp dependence_analysis_helpers.cpp fusion_compatibility.cpp fusion_illegal.cpp fusion_legal.cpp fusion_pass.cpp hoist_access_chains.cpp hoist_all_loop_types.cpp hoist_double_nested_loops.cpp hoist_from_independent_loops.cpp hoist_simple_case.cpp hoist_single_nested_loops.cpp hoist_without_preheader.cpp lcssa.cpp loop_descriptions.cpp loop_fission.cpp nested_loops.cpp peeling.cpp peeling_pass.cpp unroll_assumptions.cpp unroll_simple.cpp unswitch.cpp LIBS SPIRV-Tools-opt PCH_FILE pch_test_opt_loop ) KhronosGroup-SPIRV-Tools-f289d04/test/opt/loop_optimizations/dependence_analysis.cpp000066400000000000000000004257001475742701700307650ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include #include "source/opt/loop_dependence.h" #include "source/opt/loop_descriptor.h" #include "test/opt//assembly_builder.h" #include "test/opt//function_utils.h" #include "test/opt//pass_fixture.h" #include "test/opt//pass_utils.h" namespace spvtools { namespace opt { namespace { using DependencyAnalysis = ::testing::Test; /* Generated from the following GLSL fragment shader with --eliminate-local-multi-store #version 440 core void main(){ int[10] arr; int[10] arr2; int a = 2; for (int i = 0; i < 10; i++) { arr[a] = arr[3]; arr[a*2] = arr[a+3]; arr[6] = arr2[6]; arr[a+5] = arr2[7]; } } */ TEST(DependencyAnalysis, ZIV) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %25 "arr" OpName %39 "arr2" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 2 %11 = OpConstant %6 0 %18 = OpConstant %6 10 %19 = OpTypeBool %21 = OpTypeInt 32 0 %22 = OpConstant %21 10 %23 = OpTypeArray %6 %22 %24 = OpTypePointer Function %23 %27 = OpConstant %6 3 %38 = OpConstant %6 6 %44 = OpConstant %6 5 %46 = OpConstant %6 7 %51 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %25 = OpVariable %24 Function %39 = OpVariable %24 Function OpBranch %12 %12 = OpLabel %53 = OpPhi %6 %11 %5 %52 %15 OpLoopMerge %14 %15 None OpBranch %16 %16 = OpLabel %20 = OpSLessThan %19 %53 %18 OpBranchConditional %20 %13 %14 %13 = OpLabel %28 = OpAccessChain %7 %25 %27 %29 = OpLoad %6 %28 %30 = OpAccessChain %7 %25 %9 OpStore %30 %29 %32 = OpIMul %6 %9 %9 %34 = OpIAdd %6 %9 %27 %35 = OpAccessChain %7 %25 %34 %36 = OpLoad %6 %35 %37 = OpAccessChain %7 %25 %32 OpStore %37 %36 %40 = OpAccessChain %7 %39 %38 %41 = OpLoad %6 %40 %42 = OpAccessChain %7 %25 %38 OpStore %42 %41 %45 = OpIAdd %6 %9 %44 %47 = OpAccessChain %7 %39 %46 %48 = OpLoad %6 %47 %49 = OpAccessChain %7 %25 %45 OpStore %49 %48 OpBranch %15 %15 = OpLabel %52 = OpIAdd %6 %53 %51 OpBranch %12 %14 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 4); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; const Instruction* store[4]; int stores_found = 0; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 13)) { if (inst.opcode() == spv::Op::OpStore) { store[stores_found] = &inst; ++stores_found; } } for (int i = 0; i < 4; ++i) { EXPECT_TRUE(store[i]); } // 29 -> 30 tests looking through constants. { DistanceVector distance_vector{loops.size()}; EXPECT_TRUE(analysis.GetDependence(context->get_def_use_mgr()->GetDef(29), store[0], &distance_vector)); } // 36 -> 37 tests looking through additions. { DistanceVector distance_vector{loops.size()}; EXPECT_TRUE(analysis.GetDependence(context->get_def_use_mgr()->GetDef(36), store[1], &distance_vector)); } // 41 -> 42 tests looking at same index across two different arrays. { DistanceVector distance_vector{loops.size()}; EXPECT_TRUE(analysis.GetDependence(context->get_def_use_mgr()->GetDef(41), store[2], &distance_vector)); } // 48 -> 49 tests looking through additions for same index in two different // arrays. { DistanceVector distance_vector{loops.size()}; EXPECT_TRUE(analysis.GetDependence(context->get_def_use_mgr()->GetDef(48), store[3], &distance_vector)); } } /* Generated from the following GLSL fragment shader with --eliminate-local-multi-store #version 440 core layout(location = 0) in vec4 c; void main(){ int[10] arr; int[10] arr2; int[10] arr3; int[10] arr4; int[10] arr5; int N = int(c.x); for (int i = 0; i < N; i++) { arr[2*N] = arr[N]; arr2[2*N+1] = arr2[N]; arr3[2*N] = arr3[N-1]; arr4[N] = arr5[N]; } } */ TEST(DependencyAnalysis, SymbolicZIV) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %12 OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %12 "c" OpName %33 "arr" OpName %41 "arr2" OpName %50 "arr3" OpName %58 "arr4" OpName %60 "arr5" OpDecorate %12 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpTypeFloat 32 %10 = OpTypeVector %9 4 %11 = OpTypePointer Input %10 %12 = OpVariable %11 Input %13 = OpTypeInt 32 0 %14 = OpConstant %13 0 %15 = OpTypePointer Input %9 %20 = OpConstant %6 0 %28 = OpTypeBool %30 = OpConstant %13 10 %31 = OpTypeArray %6 %30 %32 = OpTypePointer Function %31 %34 = OpConstant %6 2 %44 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %33 = OpVariable %32 Function %41 = OpVariable %32 Function %50 = OpVariable %32 Function %58 = OpVariable %32 Function %60 = OpVariable %32 Function %16 = OpAccessChain %15 %12 %14 %17 = OpLoad %9 %16 %18 = OpConvertFToS %6 %17 OpBranch %21 %21 = OpLabel %67 = OpPhi %6 %20 %5 %66 %24 OpLoopMerge %23 %24 None OpBranch %25 %25 = OpLabel %29 = OpSLessThan %28 %67 %18 OpBranchConditional %29 %22 %23 %22 = OpLabel %36 = OpIMul %6 %34 %18 %38 = OpAccessChain %7 %33 %18 %39 = OpLoad %6 %38 %40 = OpAccessChain %7 %33 %36 OpStore %40 %39 %43 = OpIMul %6 %34 %18 %45 = OpIAdd %6 %43 %44 %47 = OpAccessChain %7 %41 %18 %48 = OpLoad %6 %47 %49 = OpAccessChain %7 %41 %45 OpStore %49 %48 %52 = OpIMul %6 %34 %18 %54 = OpISub %6 %18 %44 %55 = OpAccessChain %7 %50 %54 %56 = OpLoad %6 %55 %57 = OpAccessChain %7 %50 %52 OpStore %57 %56 %62 = OpAccessChain %7 %60 %18 %63 = OpLoad %6 %62 %64 = OpAccessChain %7 %58 %18 OpStore %64 %63 OpBranch %24 %24 = OpLabel %66 = OpIAdd %6 %67 %44 OpBranch %21 %23 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 4); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; const Instruction* store[4]; int stores_found = 0; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 22)) { if (inst.opcode() == spv::Op::OpStore) { store[stores_found] = &inst; ++stores_found; } } for (int i = 0; i < 4; ++i) { EXPECT_TRUE(store[i]); } // independent due to loop bounds (won't enter if N <= 0). // 39 -> 40 tests looking through symbols and multiplicaiton. { DistanceVector distance_vector{loops.size()}; EXPECT_TRUE(analysis.GetDependence(context->get_def_use_mgr()->GetDef(39), store[0], &distance_vector)); } // 48 -> 49 tests looking through symbols and multiplication + addition. { DistanceVector distance_vector{loops.size()}; EXPECT_TRUE(analysis.GetDependence(context->get_def_use_mgr()->GetDef(48), store[1], &distance_vector)); } // 56 -> 57 tests looking through symbols and arithmetic on load and store. { DistanceVector distance_vector{loops.size()}; EXPECT_TRUE(analysis.GetDependence(context->get_def_use_mgr()->GetDef(56), store[2], &distance_vector)); } // independent as different arrays // 63 -> 64 tests looking through symbols and load/store from/to different // arrays. { DistanceVector distance_vector{loops.size()}; EXPECT_TRUE(analysis.GetDependence(context->get_def_use_mgr()->GetDef(63), store[3], &distance_vector)); } } /* Generated from the following GLSL fragment shader with --eliminate-local-multi-store #version 440 core void a(){ int[10] arr; int[11] arr2; int[20] arr3; int[20] arr4; int a = 2; for (int i = 0; i < 10; i++) { arr[i] = arr[i]; arr2[i] = arr2[i+1]; arr3[i] = arr3[i-1]; arr4[2*i] = arr4[i]; } } void b(){ int[10] arr; int[11] arr2; int[20] arr3; int[20] arr4; int a = 2; for (int i = 10; i > 0; i--) { arr[i] = arr[i]; arr2[i] = arr2[i+1]; arr3[i] = arr3[i-1]; arr4[2*i] = arr4[i]; } } void main() { a(); b(); } */ TEST(DependencyAnalysis, SIV) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %6 "a(" OpName %8 "b(" OpName %12 "a" OpName %14 "i" OpName %29 "arr" OpName %38 "arr2" OpName %49 "arr3" OpName %56 "arr4" OpName %65 "a" OpName %66 "i" OpName %74 "arr" OpName %80 "arr2" OpName %87 "arr3" OpName %94 "arr4" %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeInt 32 1 %11 = OpTypePointer Function %10 %13 = OpConstant %10 2 %15 = OpConstant %10 0 %22 = OpConstant %10 10 %23 = OpTypeBool %25 = OpTypeInt 32 0 %26 = OpConstant %25 10 %27 = OpTypeArray %10 %26 %28 = OpTypePointer Function %27 %35 = OpConstant %25 11 %36 = OpTypeArray %10 %35 %37 = OpTypePointer Function %36 %41 = OpConstant %10 1 %46 = OpConstant %25 20 %47 = OpTypeArray %10 %46 %48 = OpTypePointer Function %47 %4 = OpFunction %2 None %3 %5 = OpLabel %103 = OpFunctionCall %2 %6 %104 = OpFunctionCall %2 %8 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %12 = OpVariable %11 Function %14 = OpVariable %11 Function %29 = OpVariable %28 Function %38 = OpVariable %37 Function %49 = OpVariable %48 Function %56 = OpVariable %48 Function OpStore %12 %13 OpStore %14 %15 OpBranch %16 %16 = OpLabel %105 = OpPhi %10 %15 %7 %64 %19 OpLoopMerge %18 %19 None OpBranch %20 %20 = OpLabel %24 = OpSLessThan %23 %105 %22 OpBranchConditional %24 %17 %18 %17 = OpLabel %32 = OpAccessChain %11 %29 %105 %33 = OpLoad %10 %32 %34 = OpAccessChain %11 %29 %105 OpStore %34 %33 %42 = OpIAdd %10 %105 %41 %43 = OpAccessChain %11 %38 %42 %44 = OpLoad %10 %43 %45 = OpAccessChain %11 %38 %105 OpStore %45 %44 %52 = OpISub %10 %105 %41 %53 = OpAccessChain %11 %49 %52 %54 = OpLoad %10 %53 %55 = OpAccessChain %11 %49 %105 OpStore %55 %54 %58 = OpIMul %10 %13 %105 %60 = OpAccessChain %11 %56 %105 %61 = OpLoad %10 %60 %62 = OpAccessChain %11 %56 %58 OpStore %62 %61 OpBranch %19 %19 = OpLabel %64 = OpIAdd %10 %105 %41 OpStore %14 %64 OpBranch %16 %18 = OpLabel OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %65 = OpVariable %11 Function %66 = OpVariable %11 Function %74 = OpVariable %28 Function %80 = OpVariable %37 Function %87 = OpVariable %48 Function %94 = OpVariable %48 Function OpStore %65 %13 OpStore %66 %22 OpBranch %67 %67 = OpLabel %106 = OpPhi %10 %22 %9 %102 %70 OpLoopMerge %69 %70 None OpBranch %71 %71 = OpLabel %73 = OpSGreaterThan %23 %106 %15 OpBranchConditional %73 %68 %69 %68 = OpLabel %77 = OpAccessChain %11 %74 %106 %78 = OpLoad %10 %77 %79 = OpAccessChain %11 %74 %106 OpStore %79 %78 %83 = OpIAdd %10 %106 %41 %84 = OpAccessChain %11 %80 %83 %85 = OpLoad %10 %84 %86 = OpAccessChain %11 %80 %106 OpStore %86 %85 %90 = OpISub %10 %106 %41 %91 = OpAccessChain %11 %87 %90 %92 = OpLoad %10 %91 %93 = OpAccessChain %11 %87 %106 OpStore %93 %92 %96 = OpIMul %10 %13 %106 %98 = OpAccessChain %11 %94 %106 %99 = OpLoad %10 %98 %100 = OpAccessChain %11 %94 %96 OpStore %100 %99 OpBranch %70 %70 = OpLabel %102 = OpISub %10 %106 %41 OpStore %66 %102 OpBranch %67 %69 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; // For the loop in function a. { const Function* f = spvtest::GetFunction(module, 6); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; const Instruction* store[4]; int stores_found = 0; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 17)) { if (inst.opcode() == spv::Op::OpStore) { store[stores_found] = &inst; ++stores_found; } } for (int i = 0; i < 4; ++i) { EXPECT_TRUE(store[i]); } // = dependence // 33 -> 34 tests looking at SIV in same array. { DistanceVector distance_vector{loops.size()}; EXPECT_FALSE(analysis.GetDependence( context->get_def_use_mgr()->GetDef(33), store[0], &distance_vector)); EXPECT_EQ(distance_vector.GetEntries()[0].dependence_information, DistanceEntry::DependenceInformation::DISTANCE); EXPECT_EQ(distance_vector.GetEntries()[0].direction, DistanceEntry::Directions::EQ); EXPECT_EQ(distance_vector.GetEntries()[0].distance, 0); } // > -1 dependence // 44 -> 45 tests looking at SIV in same array with addition. { DistanceVector distance_vector{loops.size()}; EXPECT_FALSE(analysis.GetDependence( context->get_def_use_mgr()->GetDef(44), store[1], &distance_vector)); EXPECT_EQ(distance_vector.GetEntries()[0].dependence_information, DistanceEntry::DependenceInformation::DISTANCE); EXPECT_EQ(distance_vector.GetEntries()[0].direction, DistanceEntry::Directions::GT); EXPECT_EQ(distance_vector.GetEntries()[0].distance, -1); } // < 1 dependence // 54 -> 55 tests looking at SIV in same array with subtraction. { DistanceVector distance_vector{loops.size()}; EXPECT_FALSE(analysis.GetDependence( context->get_def_use_mgr()->GetDef(54), store[2], &distance_vector)); EXPECT_EQ(distance_vector.GetEntries()[0].dependence_information, DistanceEntry::DependenceInformation::DISTANCE); EXPECT_EQ(distance_vector.GetEntries()[0].direction, DistanceEntry::Directions::LT); EXPECT_EQ(distance_vector.GetEntries()[0].distance, 1); } // <=> dependence // 61 -> 62 tests looking at SIV in same array with multiplication. { DistanceVector distance_vector{loops.size()}; EXPECT_FALSE(analysis.GetDependence( context->get_def_use_mgr()->GetDef(61), store[3], &distance_vector)); EXPECT_EQ(distance_vector.GetEntries()[0].dependence_information, DistanceEntry::DependenceInformation::UNKNOWN); EXPECT_EQ(distance_vector.GetEntries()[0].direction, DistanceEntry::Directions::ALL); } } // For the loop in function b. { const Function* f = spvtest::GetFunction(module, 8); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; const Instruction* store[4]; int stores_found = 0; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 68)) { if (inst.opcode() == spv::Op::OpStore) { store[stores_found] = &inst; ++stores_found; } } for (int i = 0; i < 4; ++i) { EXPECT_TRUE(store[i]); } // = dependence // 78 -> 79 tests looking at SIV in same array. { DistanceVector distance_vector{loops.size()}; EXPECT_FALSE(analysis.GetDependence( context->get_def_use_mgr()->GetDef(78), store[0], &distance_vector)); EXPECT_EQ(distance_vector.GetEntries()[0].dependence_information, DistanceEntry::DependenceInformation::DISTANCE); EXPECT_EQ(distance_vector.GetEntries()[0].direction, DistanceEntry::Directions::EQ); EXPECT_EQ(distance_vector.GetEntries()[0].distance, 0); } // < 1 dependence // 85 -> 86 tests looking at SIV in same array with addition. { DistanceVector distance_vector{loops.size()}; EXPECT_FALSE(analysis.GetDependence( context->get_def_use_mgr()->GetDef(85), store[1], &distance_vector)); EXPECT_EQ(distance_vector.GetEntries()[0].dependence_information, DistanceEntry::DependenceInformation::DISTANCE); EXPECT_EQ(distance_vector.GetEntries()[0].direction, DistanceEntry::Directions::LT); EXPECT_EQ(distance_vector.GetEntries()[0].distance, 1); } // > -1 dependence // 92 -> 93 tests looking at SIV in same array with subtraction. { DistanceVector distance_vector{loops.size()}; EXPECT_FALSE(analysis.GetDependence( context->get_def_use_mgr()->GetDef(92), store[2], &distance_vector)); EXPECT_EQ(distance_vector.GetEntries()[0].dependence_information, DistanceEntry::DependenceInformation::DISTANCE); EXPECT_EQ(distance_vector.GetEntries()[0].direction, DistanceEntry::Directions::GT); EXPECT_EQ(distance_vector.GetEntries()[0].distance, -1); } // <=> dependence // 99 -> 100 tests looking at SIV in same array with multiplication. { DistanceVector distance_vector{loops.size()}; EXPECT_FALSE(analysis.GetDependence( context->get_def_use_mgr()->GetDef(99), store[3], &distance_vector)); EXPECT_EQ(distance_vector.GetEntries()[0].dependence_information, DistanceEntry::DependenceInformation::UNKNOWN); EXPECT_EQ(distance_vector.GetEntries()[0].direction, DistanceEntry::Directions::ALL); } } } /* Generated from the following GLSL fragment shader with --eliminate-local-multi-store #version 440 core layout(location = 0) in vec4 c; void a() { int[13] arr; int[15] arr2; int[18] arr3; int[18] arr4; int N = int(c.x); int C = 2; int a = 2; for (int i = 0; i < N; i++) { // Bounds are N - 1 arr[i+2*N] = arr[i+N]; // |distance| = N arr2[i+N] = arr2[i+2*N] + C; // |distance| = N arr3[2*i+2*N+1] = arr3[2*i+N+1]; // |distance| = N arr4[a*i+N+1] = arr4[a*i+2*N+1]; // |distance| = N } } void b() { int[13] arr; int[15] arr2; int[18] arr3; int[18] arr4; int N = int(c.x); int C = 2; int a = 2; for (int i = N; i > 0; i--) { // Bounds are N - 1 arr[i+2*N] = arr[i+N]; // |distance| = N arr2[i+N] = arr2[i+2*N] + C; // |distance| = N arr3[2*i+2*N+1] = arr3[2*i+N+1]; // |distance| = N arr4[a*i+N+1] = arr4[a*i+2*N+1]; // |distance| = N } } void main(){ a(); b(); }*/ TEST(DependencyAnalysis, SymbolicSIV) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %16 OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %6 "a(" OpName %8 "b(" OpName %12 "N" OpName %16 "c" OpName %23 "C" OpName %25 "a" OpName %26 "i" OpName %40 "arr" OpName %54 "arr2" OpName %70 "arr3" OpName %86 "arr4" OpName %105 "N" OpName %109 "C" OpName %110 "a" OpName %111 "i" OpName %120 "arr" OpName %131 "arr2" OpName %144 "arr3" OpName %159 "arr4" OpDecorate %16 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeInt 32 1 %11 = OpTypePointer Function %10 %13 = OpTypeFloat 32 %14 = OpTypeVector %13 4 %15 = OpTypePointer Input %14 %16 = OpVariable %15 Input %17 = OpTypeInt 32 0 %18 = OpConstant %17 0 %19 = OpTypePointer Input %13 %24 = OpConstant %10 2 %27 = OpConstant %10 0 %35 = OpTypeBool %37 = OpConstant %17 13 %38 = OpTypeArray %10 %37 %39 = OpTypePointer Function %38 %51 = OpConstant %17 15 %52 = OpTypeArray %10 %51 %53 = OpTypePointer Function %52 %67 = OpConstant %17 18 %68 = OpTypeArray %10 %67 %69 = OpTypePointer Function %68 %76 = OpConstant %10 1 %4 = OpFunction %2 None %3 %5 = OpLabel %178 = OpFunctionCall %2 %6 %179 = OpFunctionCall %2 %8 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %12 = OpVariable %11 Function %23 = OpVariable %11 Function %25 = OpVariable %11 Function %26 = OpVariable %11 Function %40 = OpVariable %39 Function %54 = OpVariable %53 Function %70 = OpVariable %69 Function %86 = OpVariable %69 Function %20 = OpAccessChain %19 %16 %18 %21 = OpLoad %13 %20 %22 = OpConvertFToS %10 %21 OpStore %12 %22 OpStore %23 %24 OpStore %25 %24 OpStore %26 %27 OpBranch %28 %28 = OpLabel %180 = OpPhi %10 %27 %7 %104 %31 OpLoopMerge %30 %31 None OpBranch %32 %32 = OpLabel %36 = OpSLessThan %35 %180 %22 OpBranchConditional %36 %29 %30 %29 = OpLabel %43 = OpIMul %10 %24 %22 %44 = OpIAdd %10 %180 %43 %47 = OpIAdd %10 %180 %22 %48 = OpAccessChain %11 %40 %47 %49 = OpLoad %10 %48 %50 = OpAccessChain %11 %40 %44 OpStore %50 %49 %57 = OpIAdd %10 %180 %22 %60 = OpIMul %10 %24 %22 %61 = OpIAdd %10 %180 %60 %62 = OpAccessChain %11 %54 %61 %63 = OpLoad %10 %62 %65 = OpIAdd %10 %63 %24 %66 = OpAccessChain %11 %54 %57 OpStore %66 %65 %72 = OpIMul %10 %24 %180 %74 = OpIMul %10 %24 %22 %75 = OpIAdd %10 %72 %74 %77 = OpIAdd %10 %75 %76 %79 = OpIMul %10 %24 %180 %81 = OpIAdd %10 %79 %22 %82 = OpIAdd %10 %81 %76 %83 = OpAccessChain %11 %70 %82 %84 = OpLoad %10 %83 %85 = OpAccessChain %11 %70 %77 OpStore %85 %84 %89 = OpIMul %10 %24 %180 %91 = OpIAdd %10 %89 %22 %92 = OpIAdd %10 %91 %76 %95 = OpIMul %10 %24 %180 %97 = OpIMul %10 %24 %22 %98 = OpIAdd %10 %95 %97 %99 = OpIAdd %10 %98 %76 %100 = OpAccessChain %11 %86 %99 %101 = OpLoad %10 %100 %102 = OpAccessChain %11 %86 %92 OpStore %102 %101 OpBranch %31 %31 = OpLabel %104 = OpIAdd %10 %180 %76 OpStore %26 %104 OpBranch %28 %30 = OpLabel OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %105 = OpVariable %11 Function %109 = OpVariable %11 Function %110 = OpVariable %11 Function %111 = OpVariable %11 Function %120 = OpVariable %39 Function %131 = OpVariable %53 Function %144 = OpVariable %69 Function %159 = OpVariable %69 Function %106 = OpAccessChain %19 %16 %18 %107 = OpLoad %13 %106 %108 = OpConvertFToS %10 %107 OpStore %105 %108 OpStore %109 %24 OpStore %110 %24 OpStore %111 %108 OpBranch %113 %113 = OpLabel %181 = OpPhi %10 %108 %9 %177 %116 OpLoopMerge %115 %116 None OpBranch %117 %117 = OpLabel %119 = OpSGreaterThan %35 %181 %27 OpBranchConditional %119 %114 %115 %114 = OpLabel %123 = OpIMul %10 %24 %108 %124 = OpIAdd %10 %181 %123 %127 = OpIAdd %10 %181 %108 %128 = OpAccessChain %11 %120 %127 %129 = OpLoad %10 %128 %130 = OpAccessChain %11 %120 %124 OpStore %130 %129 %134 = OpIAdd %10 %181 %108 %137 = OpIMul %10 %24 %108 %138 = OpIAdd %10 %181 %137 %139 = OpAccessChain %11 %131 %138 %140 = OpLoad %10 %139 %142 = OpIAdd %10 %140 %24 %143 = OpAccessChain %11 %131 %134 OpStore %143 %142 %146 = OpIMul %10 %24 %181 %148 = OpIMul %10 %24 %108 %149 = OpIAdd %10 %146 %148 %150 = OpIAdd %10 %149 %76 %152 = OpIMul %10 %24 %181 %154 = OpIAdd %10 %152 %108 %155 = OpIAdd %10 %154 %76 %156 = OpAccessChain %11 %144 %155 %157 = OpLoad %10 %156 %158 = OpAccessChain %11 %144 %150 OpStore %158 %157 %162 = OpIMul %10 %24 %181 %164 = OpIAdd %10 %162 %108 %165 = OpIAdd %10 %164 %76 %168 = OpIMul %10 %24 %181 %170 = OpIMul %10 %24 %108 %171 = OpIAdd %10 %168 %170 %172 = OpIAdd %10 %171 %76 %173 = OpAccessChain %11 %159 %172 %174 = OpLoad %10 %173 %175 = OpAccessChain %11 %159 %165 OpStore %175 %174 OpBranch %116 %116 = OpLabel %177 = OpISub %10 %181 %76 OpStore %111 %177 OpBranch %113 %115 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; // For the loop in function a. { const Function* f = spvtest::GetFunction(module, 6); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; const Instruction* store[4]; int stores_found = 0; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 29)) { if (inst.opcode() == spv::Op::OpStore) { store[stores_found] = &inst; ++stores_found; } } for (int i = 0; i < 4; ++i) { EXPECT_TRUE(store[i]); } // independent due to loop bounds (won't enter when N <= 0) // 49 -> 50 tests looking through SIV and symbols with multiplication { DistanceVector distance_vector{loops.size()}; // Independent but not yet supported. EXPECT_FALSE(analysis.GetDependence( context->get_def_use_mgr()->GetDef(49), store[0], &distance_vector)); } // 63 -> 66 tests looking through SIV and symbols with multiplication and + // C { DistanceVector distance_vector{loops.size()}; // Independent. EXPECT_TRUE(analysis.GetDependence(context->get_def_use_mgr()->GetDef(63), store[1], &distance_vector)); } // 84 -> 85 tests looking through arithmetic on SIV and symbols { DistanceVector distance_vector{loops.size()}; // Independent but not yet supported. EXPECT_FALSE(analysis.GetDependence( context->get_def_use_mgr()->GetDef(84), store[2], &distance_vector)); } // 101 -> 102 tests looking through symbol arithmetic on SIV and symbols { DistanceVector distance_vector{loops.size()}; // Independent. EXPECT_TRUE(analysis.GetDependence( context->get_def_use_mgr()->GetDef(101), store[3], &distance_vector)); } } // For the loop in function b. { const Function* f = spvtest::GetFunction(module, 8); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; const Instruction* store[4]; int stores_found = 0; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 114)) { if (inst.opcode() == spv::Op::OpStore) { store[stores_found] = &inst; ++stores_found; } } for (int i = 0; i < 4; ++i) { EXPECT_TRUE(store[i]); } // independent due to loop bounds (won't enter when N <= 0). // 129 -> 130 tests looking through SIV and symbols with multiplication. { DistanceVector distance_vector{loops.size()}; // Independent but not yet supported. EXPECT_FALSE(analysis.GetDependence( context->get_def_use_mgr()->GetDef(129), store[0], &distance_vector)); } // 140 -> 143 tests looking through SIV and symbols with multiplication and // + C. { DistanceVector distance_vector{loops.size()}; // Independent. EXPECT_TRUE(analysis.GetDependence( context->get_def_use_mgr()->GetDef(140), store[1], &distance_vector)); } // 157 -> 158 tests looking through arithmetic on SIV and symbols. { DistanceVector distance_vector{loops.size()}; // Independent but not yet supported. EXPECT_FALSE(analysis.GetDependence( context->get_def_use_mgr()->GetDef(157), store[2], &distance_vector)); } // 174 -> 175 tests looking through symbol arithmetic on SIV and symbols. { DistanceVector distance_vector{loops.size()}; // Independent. EXPECT_TRUE(analysis.GetDependence( context->get_def_use_mgr()->GetDef(174), store[3], &distance_vector)); } } } /* Generated from the following GLSL fragment shader with --eliminate-local-multi-store #version 440 core void a() { int[6] arr; int N = 5; for (int i = 1; i < N; i++) { arr[i] = arr[N-i]; } } void b() { int[6] arr; int N = 5; for (int i = 1; i < N; i++) { arr[N-i] = arr[i]; } } void c() { int[11] arr; int N = 10; for (int i = 1; i < N; i++) { arr[i] = arr[N-i+1]; } } void d() { int[11] arr; int N = 10; for (int i = 1; i < N; i++) { arr[N-i+1] = arr[i]; } } void e() { int[6] arr; int N = 5; for (int i = N; i > 0; i--) { arr[i] = arr[N-i]; } } void f() { int[6] arr; int N = 5; for (int i = N; i > 0; i--) { arr[N-i] = arr[i]; } } void g() { int[11] arr; int N = 10; for (int i = N; i > 0; i--) { arr[i] = arr[N-i+1]; } } void h() { int[11] arr; int N = 10; for (int i = N; i > 0; i--) { arr[N-i+1] = arr[i]; } } void main(){ a(); b(); c(); d(); e(); f(); g(); h(); } */ TEST(DependencyAnalysis, Crossing) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %6 "a(" OpName %8 "b(" OpName %10 "c(" OpName %12 "d(" OpName %14 "e(" OpName %16 "f(" OpName %18 "g(" OpName %20 "h(" OpName %24 "N" OpName %26 "i" OpName %41 "arr" OpName %51 "N" OpName %52 "i" OpName %61 "arr" OpName %71 "N" OpName %73 "i" OpName %85 "arr" OpName %96 "N" OpName %97 "i" OpName %106 "arr" OpName %117 "N" OpName %118 "i" OpName %128 "arr" OpName %138 "N" OpName %139 "i" OpName %148 "arr" OpName %158 "N" OpName %159 "i" OpName %168 "arr" OpName %179 "N" OpName %180 "i" OpName %189 "arr" %2 = OpTypeVoid %3 = OpTypeFunction %2 %22 = OpTypeInt 32 1 %23 = OpTypePointer Function %22 %25 = OpConstant %22 5 %27 = OpConstant %22 1 %35 = OpTypeBool %37 = OpTypeInt 32 0 %38 = OpConstant %37 6 %39 = OpTypeArray %22 %38 %40 = OpTypePointer Function %39 %72 = OpConstant %22 10 %82 = OpConstant %37 11 %83 = OpTypeArray %22 %82 %84 = OpTypePointer Function %83 %126 = OpConstant %22 0 %4 = OpFunction %2 None %3 %5 = OpLabel %200 = OpFunctionCall %2 %6 %201 = OpFunctionCall %2 %8 %202 = OpFunctionCall %2 %10 %203 = OpFunctionCall %2 %12 %204 = OpFunctionCall %2 %14 %205 = OpFunctionCall %2 %16 %206 = OpFunctionCall %2 %18 %207 = OpFunctionCall %2 %20 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %24 = OpVariable %23 Function %26 = OpVariable %23 Function %41 = OpVariable %40 Function OpStore %24 %25 OpStore %26 %27 OpBranch %28 %28 = OpLabel %208 = OpPhi %22 %27 %7 %50 %31 OpLoopMerge %30 %31 None OpBranch %32 %32 = OpLabel %36 = OpSLessThan %35 %208 %25 OpBranchConditional %36 %29 %30 %29 = OpLabel %45 = OpISub %22 %25 %208 %46 = OpAccessChain %23 %41 %45 %47 = OpLoad %22 %46 %48 = OpAccessChain %23 %41 %208 OpStore %48 %47 OpBranch %31 %31 = OpLabel %50 = OpIAdd %22 %208 %27 OpStore %26 %50 OpBranch %28 %30 = OpLabel OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %51 = OpVariable %23 Function %52 = OpVariable %23 Function %61 = OpVariable %40 Function OpStore %51 %25 OpStore %52 %27 OpBranch %53 %53 = OpLabel %209 = OpPhi %22 %27 %9 %70 %56 OpLoopMerge %55 %56 None OpBranch %57 %57 = OpLabel %60 = OpSLessThan %35 %209 %25 OpBranchConditional %60 %54 %55 %54 = OpLabel %64 = OpISub %22 %25 %209 %66 = OpAccessChain %23 %61 %209 %67 = OpLoad %22 %66 %68 = OpAccessChain %23 %61 %64 OpStore %68 %67 OpBranch %56 %56 = OpLabel %70 = OpIAdd %22 %209 %27 OpStore %52 %70 OpBranch %53 %55 = OpLabel OpReturn OpFunctionEnd %10 = OpFunction %2 None %3 %11 = OpLabel %71 = OpVariable %23 Function %73 = OpVariable %23 Function %85 = OpVariable %84 Function OpStore %71 %72 OpStore %73 %27 OpBranch %74 %74 = OpLabel %210 = OpPhi %22 %27 %11 %95 %77 OpLoopMerge %76 %77 None OpBranch %78 %78 = OpLabel %81 = OpSLessThan %35 %210 %72 OpBranchConditional %81 %75 %76 %75 = OpLabel %89 = OpISub %22 %72 %210 %90 = OpIAdd %22 %89 %27 %91 = OpAccessChain %23 %85 %90 %92 = OpLoad %22 %91 %93 = OpAccessChain %23 %85 %210 OpStore %93 %92 OpBranch %77 %77 = OpLabel %95 = OpIAdd %22 %210 %27 OpStore %73 %95 OpBranch %74 %76 = OpLabel OpReturn OpFunctionEnd %12 = OpFunction %2 None %3 %13 = OpLabel %96 = OpVariable %23 Function %97 = OpVariable %23 Function %106 = OpVariable %84 Function OpStore %96 %72 OpStore %97 %27 OpBranch %98 %98 = OpLabel %211 = OpPhi %22 %27 %13 %116 %101 OpLoopMerge %100 %101 None OpBranch %102 %102 = OpLabel %105 = OpSLessThan %35 %211 %72 OpBranchConditional %105 %99 %100 %99 = OpLabel %109 = OpISub %22 %72 %211 %110 = OpIAdd %22 %109 %27 %112 = OpAccessChain %23 %106 %211 %113 = OpLoad %22 %112 %114 = OpAccessChain %23 %106 %110 OpStore %114 %113 OpBranch %101 %101 = OpLabel %116 = OpIAdd %22 %211 %27 OpStore %97 %116 OpBranch %98 %100 = OpLabel OpReturn OpFunctionEnd %14 = OpFunction %2 None %3 %15 = OpLabel %117 = OpVariable %23 Function %118 = OpVariable %23 Function %128 = OpVariable %40 Function OpStore %117 %25 OpStore %118 %25 OpBranch %120 %120 = OpLabel %212 = OpPhi %22 %25 %15 %137 %123 OpLoopMerge %122 %123 None OpBranch %124 %124 = OpLabel %127 = OpSGreaterThan %35 %212 %126 OpBranchConditional %127 %121 %122 %121 = OpLabel %132 = OpISub %22 %25 %212 %133 = OpAccessChain %23 %128 %132 %134 = OpLoad %22 %133 %135 = OpAccessChain %23 %128 %212 OpStore %135 %134 OpBranch %123 %123 = OpLabel %137 = OpISub %22 %212 %27 OpStore %118 %137 OpBranch %120 %122 = OpLabel OpReturn OpFunctionEnd %16 = OpFunction %2 None %3 %17 = OpLabel %138 = OpVariable %23 Function %139 = OpVariable %23 Function %148 = OpVariable %40 Function OpStore %138 %25 OpStore %139 %25 OpBranch %141 %141 = OpLabel %213 = OpPhi %22 %25 %17 %157 %144 OpLoopMerge %143 %144 None OpBranch %145 %145 = OpLabel %147 = OpSGreaterThan %35 %213 %126 OpBranchConditional %147 %142 %143 %142 = OpLabel %151 = OpISub %22 %25 %213 %153 = OpAccessChain %23 %148 %213 %154 = OpLoad %22 %153 %155 = OpAccessChain %23 %148 %151 OpStore %155 %154 OpBranch %144 %144 = OpLabel %157 = OpISub %22 %213 %27 OpStore %139 %157 OpBranch %141 %143 = OpLabel OpReturn OpFunctionEnd %18 = OpFunction %2 None %3 %19 = OpLabel %158 = OpVariable %23 Function %159 = OpVariable %23 Function %168 = OpVariable %84 Function OpStore %158 %72 OpStore %159 %72 OpBranch %161 %161 = OpLabel %214 = OpPhi %22 %72 %19 %178 %164 OpLoopMerge %163 %164 None OpBranch %165 %165 = OpLabel %167 = OpSGreaterThan %35 %214 %126 OpBranchConditional %167 %162 %163 %162 = OpLabel %172 = OpISub %22 %72 %214 %173 = OpIAdd %22 %172 %27 %174 = OpAccessChain %23 %168 %173 %175 = OpLoad %22 %174 %176 = OpAccessChain %23 %168 %214 OpStore %176 %175 OpBranch %164 %164 = OpLabel %178 = OpISub %22 %214 %27 OpStore %159 %178 OpBranch %161 %163 = OpLabel OpReturn OpFunctionEnd %20 = OpFunction %2 None %3 %21 = OpLabel %179 = OpVariable %23 Function %180 = OpVariable %23 Function %189 = OpVariable %84 Function OpStore %179 %72 OpStore %180 %72 OpBranch %182 %182 = OpLabel %215 = OpPhi %22 %72 %21 %199 %185 OpLoopMerge %184 %185 None OpBranch %186 %186 = OpLabel %188 = OpSGreaterThan %35 %215 %126 OpBranchConditional %188 %183 %184 %183 = OpLabel %192 = OpISub %22 %72 %215 %193 = OpIAdd %22 %192 %27 %195 = OpAccessChain %23 %189 %215 %196 = OpLoad %22 %195 %197 = OpAccessChain %23 %189 %193 OpStore %197 %196 OpBranch %185 %185 = OpLabel %199 = OpISub %22 %215 %27 OpStore %180 %199 OpBranch %182 %184 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; // First two tests can be split into two loops. // Tests even crossing subscripts from low to high indexes. // 47 -> 48 { const Function* f = spvtest::GetFunction(module, 6); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; const Instruction* store = nullptr; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 29)) { if (inst.opcode() == spv::Op::OpStore) { store = &inst; } } DistanceVector distance_vector{loops.size()}; EXPECT_FALSE(analysis.GetDependence(context->get_def_use_mgr()->GetDef(47), store, &distance_vector)); } // Tests even crossing subscripts from high to low indexes. // 67 -> 68 { const Function* f = spvtest::GetFunction(module, 8); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; const Instruction* store = nullptr; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 54)) { if (inst.opcode() == spv::Op::OpStore) { store = &inst; } } DistanceVector distance_vector{loops.size()}; EXPECT_FALSE(analysis.GetDependence(context->get_def_use_mgr()->GetDef(67), store, &distance_vector)); } // Next two tests can have an end peeled, then be split. // Tests uneven crossing subscripts from low to high indexes. // 92 -> 93 { const Function* f = spvtest::GetFunction(module, 10); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; const Instruction* store = nullptr; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 75)) { if (inst.opcode() == spv::Op::OpStore) { store = &inst; } } DistanceVector distance_vector{loops.size()}; EXPECT_FALSE(analysis.GetDependence(context->get_def_use_mgr()->GetDef(92), store, &distance_vector)); } // Tests uneven crossing subscripts from high to low indexes. // 113 -> 114 { const Function* f = spvtest::GetFunction(module, 12); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; const Instruction* store = nullptr; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 99)) { if (inst.opcode() == spv::Op::OpStore) { store = &inst; } } DistanceVector distance_vector{loops.size()}; EXPECT_FALSE(analysis.GetDependence(context->get_def_use_mgr()->GetDef(113), store, &distance_vector)); } // First two tests can be split into two loops. // Tests even crossing subscripts from low to high indexes. // 134 -> 135 { const Function* f = spvtest::GetFunction(module, 14); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; const Instruction* store = nullptr; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 121)) { if (inst.opcode() == spv::Op::OpStore) { store = &inst; } } DistanceVector distance_vector{loops.size()}; EXPECT_FALSE(analysis.GetDependence(context->get_def_use_mgr()->GetDef(134), store, &distance_vector)); } // Tests even crossing subscripts from high to low indexes. // 154 -> 155 { const Function* f = spvtest::GetFunction(module, 16); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; const Instruction* store = nullptr; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 142)) { if (inst.opcode() == spv::Op::OpStore) { store = &inst; } } DistanceVector distance_vector{loops.size()}; EXPECT_FALSE(analysis.GetDependence(context->get_def_use_mgr()->GetDef(154), store, &distance_vector)); } // Next two tests can have an end peeled, then be split. // Tests uneven crossing subscripts from low to high indexes. // 175 -> 176 { const Function* f = spvtest::GetFunction(module, 18); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; const Instruction* store = nullptr; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 162)) { if (inst.opcode() == spv::Op::OpStore) { store = &inst; } } DistanceVector distance_vector{loops.size()}; EXPECT_FALSE(analysis.GetDependence(context->get_def_use_mgr()->GetDef(175), store, &distance_vector)); } // Tests uneven crossing subscripts from high to low indexes. // 196 -> 197 { const Function* f = spvtest::GetFunction(module, 20); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; const Instruction* store = nullptr; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 183)) { if (inst.opcode() == spv::Op::OpStore) { store = &inst; } } DistanceVector distance_vector{loops.size()}; EXPECT_FALSE(analysis.GetDependence(context->get_def_use_mgr()->GetDef(196), store, &distance_vector)); } } /* Generated from the following GLSL fragment shader with --eliminate-local-multi-store #version 440 core void a() { int[10] arr; for (int i = 0; i < 10; i++) { arr[0] = arr[i]; // peel first arr[i] = arr[0]; // peel first arr[9] = arr[i]; // peel last arr[i] = arr[9]; // peel last } } void b() { int[11] arr; for (int i = 0; i <= 10; i++) { arr[0] = arr[i]; // peel first arr[i] = arr[0]; // peel first arr[10] = arr[i]; // peel last arr[i] = arr[10]; // peel last } } void c() { int[11] arr; for (int i = 10; i > 0; i--) { arr[10] = arr[i]; // peel first arr[i] = arr[10]; // peel first arr[1] = arr[i]; // peel last arr[i] = arr[1]; // peel last } } void d() { int[11] arr; for (int i = 10; i >= 0; i--) { arr[10] = arr[i]; // peel first arr[i] = arr[10]; // peel first arr[0] = arr[i]; // peel last arr[i] = arr[0]; // peel last } } void main(){ a(); b(); c(); d(); } */ TEST(DependencyAnalysis, WeakZeroSIV) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %6 "a(" OpName %8 "b(" OpName %10 "c(" OpName %12 "d(" OpName %16 "i" OpName %31 "arr" OpName %52 "i" OpName %63 "arr" OpName %82 "i" OpName %90 "arr" OpName %109 "i" OpName %117 "arr" %2 = OpTypeVoid %3 = OpTypeFunction %2 %14 = OpTypeInt 32 1 %15 = OpTypePointer Function %14 %17 = OpConstant %14 0 %24 = OpConstant %14 10 %25 = OpTypeBool %27 = OpTypeInt 32 0 %28 = OpConstant %27 10 %29 = OpTypeArray %14 %28 %30 = OpTypePointer Function %29 %40 = OpConstant %14 9 %50 = OpConstant %14 1 %60 = OpConstant %27 11 %61 = OpTypeArray %14 %60 %62 = OpTypePointer Function %61 %4 = OpFunction %2 None %3 %5 = OpLabel %136 = OpFunctionCall %2 %6 %137 = OpFunctionCall %2 %8 %138 = OpFunctionCall %2 %10 %139 = OpFunctionCall %2 %12 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %16 = OpVariable %15 Function %31 = OpVariable %30 Function OpStore %16 %17 OpBranch %18 %18 = OpLabel %140 = OpPhi %14 %17 %7 %51 %21 OpLoopMerge %20 %21 None OpBranch %22 %22 = OpLabel %26 = OpSLessThan %25 %140 %24 OpBranchConditional %26 %19 %20 %19 = OpLabel %33 = OpAccessChain %15 %31 %140 %34 = OpLoad %14 %33 %35 = OpAccessChain %15 %31 %17 OpStore %35 %34 %37 = OpAccessChain %15 %31 %17 %38 = OpLoad %14 %37 %39 = OpAccessChain %15 %31 %140 OpStore %39 %38 %42 = OpAccessChain %15 %31 %140 %43 = OpLoad %14 %42 %44 = OpAccessChain %15 %31 %40 OpStore %44 %43 %46 = OpAccessChain %15 %31 %40 %47 = OpLoad %14 %46 %48 = OpAccessChain %15 %31 %140 OpStore %48 %47 OpBranch %21 %21 = OpLabel %51 = OpIAdd %14 %140 %50 OpStore %16 %51 OpBranch %18 %20 = OpLabel OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %52 = OpVariable %15 Function %63 = OpVariable %62 Function OpStore %52 %17 OpBranch %53 %53 = OpLabel %141 = OpPhi %14 %17 %9 %81 %56 OpLoopMerge %55 %56 None OpBranch %57 %57 = OpLabel %59 = OpSLessThanEqual %25 %141 %24 OpBranchConditional %59 %54 %55 %54 = OpLabel %65 = OpAccessChain %15 %63 %141 %66 = OpLoad %14 %65 %67 = OpAccessChain %15 %63 %17 OpStore %67 %66 %69 = OpAccessChain %15 %63 %17 %70 = OpLoad %14 %69 %71 = OpAccessChain %15 %63 %141 OpStore %71 %70 %73 = OpAccessChain %15 %63 %141 %74 = OpLoad %14 %73 %75 = OpAccessChain %15 %63 %24 OpStore %75 %74 %77 = OpAccessChain %15 %63 %24 %78 = OpLoad %14 %77 %79 = OpAccessChain %15 %63 %141 OpStore %79 %78 OpBranch %56 %56 = OpLabel %81 = OpIAdd %14 %141 %50 OpStore %52 %81 OpBranch %53 %55 = OpLabel OpReturn OpFunctionEnd %10 = OpFunction %2 None %3 %11 = OpLabel %82 = OpVariable %15 Function %90 = OpVariable %62 Function OpStore %82 %24 OpBranch %83 %83 = OpLabel %142 = OpPhi %14 %24 %11 %108 %86 OpLoopMerge %85 %86 None OpBranch %87 %87 = OpLabel %89 = OpSGreaterThan %25 %142 %17 OpBranchConditional %89 %84 %85 %84 = OpLabel %92 = OpAccessChain %15 %90 %142 %93 = OpLoad %14 %92 %94 = OpAccessChain %15 %90 %24 OpStore %94 %93 %96 = OpAccessChain %15 %90 %24 %97 = OpLoad %14 %96 %98 = OpAccessChain %15 %90 %142 OpStore %98 %97 %100 = OpAccessChain %15 %90 %142 %101 = OpLoad %14 %100 %102 = OpAccessChain %15 %90 %50 OpStore %102 %101 %104 = OpAccessChain %15 %90 %50 %105 = OpLoad %14 %104 %106 = OpAccessChain %15 %90 %142 OpStore %106 %105 OpBranch %86 %86 = OpLabel %108 = OpISub %14 %142 %50 OpStore %82 %108 OpBranch %83 %85 = OpLabel OpReturn OpFunctionEnd %12 = OpFunction %2 None %3 %13 = OpLabel %109 = OpVariable %15 Function %117 = OpVariable %62 Function OpStore %109 %24 OpBranch %110 %110 = OpLabel %143 = OpPhi %14 %24 %13 %135 %113 OpLoopMerge %112 %113 None OpBranch %114 %114 = OpLabel %116 = OpSGreaterThanEqual %25 %143 %17 OpBranchConditional %116 %111 %112 %111 = OpLabel %119 = OpAccessChain %15 %117 %143 %120 = OpLoad %14 %119 %121 = OpAccessChain %15 %117 %24 OpStore %121 %120 %123 = OpAccessChain %15 %117 %24 %124 = OpLoad %14 %123 %125 = OpAccessChain %15 %117 %143 OpStore %125 %124 %127 = OpAccessChain %15 %117 %143 %128 = OpLoad %14 %127 %129 = OpAccessChain %15 %117 %17 OpStore %129 %128 %131 = OpAccessChain %15 %117 %17 %132 = OpLoad %14 %131 %133 = OpAccessChain %15 %117 %143 OpStore %133 %132 OpBranch %113 %113 = OpLabel %135 = OpISub %14 %143 %50 OpStore %109 %135 OpBranch %110 %112 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; // For the loop in function a { const Function* f = spvtest::GetFunction(module, 6); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; const Instruction* store[4]; int stores_found = 0; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 19)) { if (inst.opcode() == spv::Op::OpStore) { store[stores_found] = &inst; ++stores_found; } } for (int i = 0; i < 4; ++i) { EXPECT_TRUE(store[i]); } // Tests identifying peel first with weak zero with destination as zero // index. // 34 -> 35 { DistanceVector distance_vector{loops.size()}; EXPECT_FALSE(analysis.GetDependence( context->get_def_use_mgr()->GetDef(34), store[0], &distance_vector)); EXPECT_EQ(distance_vector.GetEntries()[0].dependence_information, DistanceEntry::DependenceInformation::PEEL); EXPECT_TRUE(distance_vector.GetEntries()[0].peel_first); } // Tests identifying peel first with weak zero with source as zero index. // 38 -> 39 { DistanceVector distance_vector{loops.size()}; EXPECT_FALSE(analysis.GetDependence( context->get_def_use_mgr()->GetDef(38), store[1], &distance_vector)); EXPECT_EQ(distance_vector.GetEntries()[0].dependence_information, DistanceEntry::DependenceInformation::PEEL); EXPECT_TRUE(distance_vector.GetEntries()[0].peel_first); } // Tests identifying peel first with weak zero with destination as zero // index. // 43 -> 44 { DistanceVector distance_vector{loops.size()}; EXPECT_FALSE(analysis.GetDependence( context->get_def_use_mgr()->GetDef(43), store[2], &distance_vector)); EXPECT_EQ(distance_vector.GetEntries()[0].dependence_information, DistanceEntry::DependenceInformation::PEEL); EXPECT_TRUE(distance_vector.GetEntries()[0].peel_last); } // Tests identifying peel first with weak zero with source as zero index. // 47 -> 48 { DistanceVector distance_vector{loops.size()}; EXPECT_FALSE(analysis.GetDependence( context->get_def_use_mgr()->GetDef(47), store[3], &distance_vector)); EXPECT_EQ(distance_vector.GetEntries()[0].dependence_information, DistanceEntry::DependenceInformation::PEEL); EXPECT_TRUE(distance_vector.GetEntries()[0].peel_last); } } // For the loop in function b { const Function* f = spvtest::GetFunction(module, 8); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; const Instruction* store[4]; int stores_found = 0; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 54)) { if (inst.opcode() == spv::Op::OpStore) { store[stores_found] = &inst; ++stores_found; } } for (int i = 0; i < 4; ++i) { EXPECT_TRUE(store[i]); } // Tests identifying peel first with weak zero with destination as zero // index. // 66 -> 67 { DistanceVector distance_vector{loops.size()}; EXPECT_FALSE(analysis.GetDependence( context->get_def_use_mgr()->GetDef(66), store[0], &distance_vector)); EXPECT_EQ(distance_vector.GetEntries()[0].dependence_information, DistanceEntry::DependenceInformation::PEEL); EXPECT_TRUE(distance_vector.GetEntries()[0].peel_first); } // Tests identifying peel first with weak zero with source as zero index. // 70 -> 71 { DistanceVector distance_vector{loops.size()}; EXPECT_FALSE(analysis.GetDependence( context->get_def_use_mgr()->GetDef(70), store[1], &distance_vector)); EXPECT_EQ(distance_vector.GetEntries()[0].dependence_information, DistanceEntry::DependenceInformation::PEEL); EXPECT_TRUE(distance_vector.GetEntries()[0].peel_first); } // Tests identifying peel first with weak zero with destination as zero // index. // 74 -> 75 { DistanceVector distance_vector{loops.size()}; EXPECT_FALSE(analysis.GetDependence( context->get_def_use_mgr()->GetDef(74), store[2], &distance_vector)); EXPECT_EQ(distance_vector.GetEntries()[0].dependence_information, DistanceEntry::DependenceInformation::PEEL); EXPECT_TRUE(distance_vector.GetEntries()[0].peel_last); } // Tests identifying peel first with weak zero with source as zero index. // 78 -> 79 { DistanceVector distance_vector{loops.size()}; EXPECT_FALSE(analysis.GetDependence( context->get_def_use_mgr()->GetDef(78), store[3], &distance_vector)); EXPECT_EQ(distance_vector.GetEntries()[0].dependence_information, DistanceEntry::DependenceInformation::PEEL); EXPECT_TRUE(distance_vector.GetEntries()[0].peel_last); } } // For the loop in function c { const Function* f = spvtest::GetFunction(module, 10); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; const Instruction* store[4]; int stores_found = 0; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 84)) { if (inst.opcode() == spv::Op::OpStore) { store[stores_found] = &inst; ++stores_found; } } for (int i = 0; i < 4; ++i) { EXPECT_TRUE(store[i]); } // Tests identifying peel first with weak zero with destination as zero // index. // 93 -> 94 { DistanceVector distance_vector{loops.size()}; EXPECT_FALSE(analysis.GetDependence( context->get_def_use_mgr()->GetDef(93), store[0], &distance_vector)); EXPECT_EQ(distance_vector.GetEntries()[0].dependence_information, DistanceEntry::DependenceInformation::PEEL); EXPECT_TRUE(distance_vector.GetEntries()[0].peel_first); } // Tests identifying peel first with weak zero with source as zero index. // 97 -> 98 { DistanceVector distance_vector{loops.size()}; EXPECT_FALSE(analysis.GetDependence( context->get_def_use_mgr()->GetDef(97), store[1], &distance_vector)); EXPECT_EQ(distance_vector.GetEntries()[0].dependence_information, DistanceEntry::DependenceInformation::PEEL); EXPECT_TRUE(distance_vector.GetEntries()[0].peel_first); } // Tests identifying peel first with weak zero with destination as zero // index. // 101 -> 102 { DistanceVector distance_vector{loops.size()}; EXPECT_FALSE(analysis.GetDependence( context->get_def_use_mgr()->GetDef(101), store[2], &distance_vector)); EXPECT_EQ(distance_vector.GetEntries()[0].dependence_information, DistanceEntry::DependenceInformation::PEEL); EXPECT_TRUE(distance_vector.GetEntries()[0].peel_last); } // Tests identifying peel first with weak zero with source as zero index. // 105 -> 106 { DistanceVector distance_vector{loops.size()}; EXPECT_FALSE(analysis.GetDependence( context->get_def_use_mgr()->GetDef(105), store[3], &distance_vector)); EXPECT_EQ(distance_vector.GetEntries()[0].dependence_information, DistanceEntry::DependenceInformation::PEEL); EXPECT_TRUE(distance_vector.GetEntries()[0].peel_last); } } // For the loop in function d { const Function* f = spvtest::GetFunction(module, 12); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; const Instruction* store[4]; int stores_found = 0; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 111)) { if (inst.opcode() == spv::Op::OpStore) { store[stores_found] = &inst; ++stores_found; } } for (int i = 0; i < 4; ++i) { EXPECT_TRUE(store[i]); } // Tests identifying peel first with weak zero with destination as zero // index. // 120 -> 121 { DistanceVector distance_vector{loops.size()}; EXPECT_FALSE(analysis.GetDependence( context->get_def_use_mgr()->GetDef(120), store[0], &distance_vector)); EXPECT_EQ(distance_vector.GetEntries()[0].dependence_information, DistanceEntry::DependenceInformation::PEEL); EXPECT_TRUE(distance_vector.GetEntries()[0].peel_first); } // Tests identifying peel first with weak zero with source as zero index. // 124 -> 125 { DistanceVector distance_vector{loops.size()}; EXPECT_FALSE(analysis.GetDependence( context->get_def_use_mgr()->GetDef(124), store[1], &distance_vector)); EXPECT_EQ(distance_vector.GetEntries()[0].dependence_information, DistanceEntry::DependenceInformation::PEEL); EXPECT_TRUE(distance_vector.GetEntries()[0].peel_first); } // Tests identifying peel first with weak zero with destination as zero // index. // 128 -> 129 { DistanceVector distance_vector{loops.size()}; EXPECT_FALSE(analysis.GetDependence( context->get_def_use_mgr()->GetDef(128), store[2], &distance_vector)); EXPECT_EQ(distance_vector.GetEntries()[0].dependence_information, DistanceEntry::DependenceInformation::PEEL); EXPECT_TRUE(distance_vector.GetEntries()[0].peel_last); } // Tests identifying peel first with weak zero with source as zero index. // 132 -> 133 { DistanceVector distance_vector{loops.size()}; EXPECT_FALSE(analysis.GetDependence( context->get_def_use_mgr()->GetDef(132), store[3], &distance_vector)); EXPECT_EQ(distance_vector.GetEntries()[0].dependence_information, DistanceEntry::DependenceInformation::PEEL); EXPECT_TRUE(distance_vector.GetEntries()[0].peel_last); } } } /* Generated from the following GLSL fragment shader with --eliminate-local-multi-store #version 440 core void main(){ int[10][10] arr; for (int i = 0; i < 10; i++) { arr[i][i] = arr[i][i]; arr[0][i] = arr[1][i]; arr[1][i] = arr[0][i]; arr[i][0] = arr[i][1]; arr[i][1] = arr[i][0]; arr[0][1] = arr[1][0]; } } */ TEST(DependencyAnalysis, MultipleSubscriptZIVSIV) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %24 "arr" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %19 = OpTypeInt 32 0 %20 = OpConstant %19 10 %21 = OpTypeArray %6 %20 %22 = OpTypeArray %21 %20 %23 = OpTypePointer Function %22 %33 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %24 = OpVariable %23 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %58 = OpPhi %6 %9 %5 %57 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %58 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %29 = OpAccessChain %7 %24 %58 %58 %30 = OpLoad %6 %29 %31 = OpAccessChain %7 %24 %58 %58 OpStore %31 %30 %35 = OpAccessChain %7 %24 %33 %58 %36 = OpLoad %6 %35 %37 = OpAccessChain %7 %24 %9 %58 OpStore %37 %36 %40 = OpAccessChain %7 %24 %9 %58 %41 = OpLoad %6 %40 %42 = OpAccessChain %7 %24 %33 %58 OpStore %42 %41 %45 = OpAccessChain %7 %24 %58 %33 %46 = OpLoad %6 %45 %47 = OpAccessChain %7 %24 %58 %9 OpStore %47 %46 %50 = OpAccessChain %7 %24 %58 %9 %51 = OpLoad %6 %50 %52 = OpAccessChain %7 %24 %58 %33 OpStore %52 %51 %53 = OpAccessChain %7 %24 %33 %9 %54 = OpLoad %6 %53 %55 = OpAccessChain %7 %24 %9 %33 OpStore %55 %54 OpBranch %13 %13 = OpLabel %57 = OpIAdd %6 %58 %33 OpStore %8 %57 OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 4); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; const Instruction* store[6]; int stores_found = 0; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 11)) { if (inst.opcode() == spv::Op::OpStore) { store[stores_found] = &inst; ++stores_found; } } for (int i = 0; i < 6; ++i) { EXPECT_TRUE(store[i]); } // 30 -> 31 { DistanceVector distance_vector{loops.size()}; EXPECT_FALSE(analysis.GetDependence(context->get_def_use_mgr()->GetDef(30), store[0], &distance_vector)); EXPECT_EQ(distance_vector.GetEntries()[0].dependence_information, DistanceEntry::DependenceInformation::DISTANCE); EXPECT_EQ(distance_vector.GetEntries()[0].direction, DistanceEntry::Directions::EQ); EXPECT_EQ(distance_vector.GetEntries()[0].distance, 0); } // 36 -> 37 { DistanceVector distance_vector{loops.size()}; EXPECT_TRUE(analysis.GetDependence(context->get_def_use_mgr()->GetDef(36), store[1], &distance_vector)); } // 41 -> 42 { DistanceVector distance_vector{loops.size()}; EXPECT_TRUE(analysis.GetDependence(context->get_def_use_mgr()->GetDef(41), store[2], &distance_vector)); } // 46 -> 47 { DistanceVector distance_vector{loops.size()}; EXPECT_TRUE(analysis.GetDependence(context->get_def_use_mgr()->GetDef(46), store[3], &distance_vector)); EXPECT_EQ(distance_vector.GetEntries()[0].dependence_information, DistanceEntry::DependenceInformation::DISTANCE); EXPECT_EQ(distance_vector.GetEntries()[0].direction, DistanceEntry::Directions::EQ); EXPECT_EQ(distance_vector.GetEntries()[0].distance, 0); } // 51 -> 52 { DistanceVector distance_vector{loops.size()}; EXPECT_TRUE(analysis.GetDependence(context->get_def_use_mgr()->GetDef(51), store[4], &distance_vector)); EXPECT_EQ(distance_vector.GetEntries()[0].dependence_information, DistanceEntry::DependenceInformation::DISTANCE); EXPECT_EQ(distance_vector.GetEntries()[0].direction, DistanceEntry::Directions::EQ); EXPECT_EQ(distance_vector.GetEntries()[0].distance, 0); } // 54 -> 55 { DistanceVector distance_vector{loops.size()}; EXPECT_TRUE(analysis.GetDependence(context->get_def_use_mgr()->GetDef(54), store[5], &distance_vector)); } } /* Generated from the following GLSL fragment shader with --eliminate-local-multi-store #version 440 core void a(){ int[10] arr; for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { arr[j] = arr[j]; } } } void b(){ int[10] arr; for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { arr[i] = arr[i]; } } } void main() { a(); b(); } */ TEST(DependencyAnalysis, IrrelevantSubscripts) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %6 "a(" OpName %8 "b(" OpName %12 "i" OpName %23 "j" OpName %35 "arr" OpName %46 "i" OpName %54 "j" OpName %62 "arr" %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeInt 32 1 %11 = OpTypePointer Function %10 %13 = OpConstant %10 0 %20 = OpConstant %10 10 %21 = OpTypeBool %31 = OpTypeInt 32 0 %32 = OpConstant %31 10 %33 = OpTypeArray %10 %32 %34 = OpTypePointer Function %33 %42 = OpConstant %10 1 %4 = OpFunction %2 None %3 %5 = OpLabel %72 = OpFunctionCall %2 %6 %73 = OpFunctionCall %2 %8 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %12 = OpVariable %11 Function %23 = OpVariable %11 Function %35 = OpVariable %34 Function OpStore %12 %13 OpBranch %14 %14 = OpLabel %74 = OpPhi %10 %13 %7 %45 %17 OpLoopMerge %16 %17 None OpBranch %18 %18 = OpLabel %22 = OpSLessThan %21 %74 %20 OpBranchConditional %22 %15 %16 %15 = OpLabel OpStore %23 %13 OpBranch %24 %24 = OpLabel %75 = OpPhi %10 %13 %15 %43 %27 OpLoopMerge %26 %27 None OpBranch %28 %28 = OpLabel %30 = OpSLessThan %21 %75 %20 OpBranchConditional %30 %25 %26 %25 = OpLabel %38 = OpAccessChain %11 %35 %75 %39 = OpLoad %10 %38 %40 = OpAccessChain %11 %35 %75 OpStore %40 %39 OpBranch %27 %27 = OpLabel %43 = OpIAdd %10 %75 %42 OpStore %23 %43 OpBranch %24 %26 = OpLabel OpBranch %17 %17 = OpLabel %45 = OpIAdd %10 %74 %42 OpStore %12 %45 OpBranch %14 %16 = OpLabel OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %46 = OpVariable %11 Function %54 = OpVariable %11 Function %62 = OpVariable %34 Function OpStore %46 %13 OpBranch %47 %47 = OpLabel %77 = OpPhi %10 %13 %9 %71 %50 OpLoopMerge %49 %50 None OpBranch %51 %51 = OpLabel %53 = OpSLessThan %21 %77 %20 OpBranchConditional %53 %48 %49 %48 = OpLabel OpStore %54 %13 OpBranch %55 %55 = OpLabel %78 = OpPhi %10 %13 %48 %69 %58 OpLoopMerge %57 %58 None OpBranch %59 %59 = OpLabel %61 = OpSLessThan %21 %78 %20 OpBranchConditional %61 %56 %57 %56 = OpLabel %65 = OpAccessChain %11 %62 %77 %66 = OpLoad %10 %65 %67 = OpAccessChain %11 %62 %77 OpStore %67 %66 OpBranch %58 %58 = OpLabel %69 = OpIAdd %10 %78 %42 OpStore %54 %69 OpBranch %55 %57 = OpLabel OpBranch %50 %50 = OpLabel %71 = OpIAdd %10 %77 %42 OpStore %46 %71 OpBranch %47 %49 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; // For the loop in function a { const Function* f = spvtest::GetFunction(module, 6); LoopDescriptor& ld = *context->GetLoopDescriptor(f); std::vector loops{&ld.GetLoopByIndex(1), &ld.GetLoopByIndex(0)}; LoopDependenceAnalysis analysis{context.get(), loops}; const Instruction* store[1]; int stores_found = 0; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 25)) { if (inst.opcode() == spv::Op::OpStore) { store[stores_found] = &inst; ++stores_found; } } for (int i = 0; i < 1; ++i) { EXPECT_TRUE(store[i]); } // 39 -> 40 { DistanceVector distance_vector{loops.size()}; analysis.SetDebugStream(std::cout); EXPECT_FALSE(analysis.GetDependence( context->get_def_use_mgr()->GetDef(39), store[0], &distance_vector)); EXPECT_EQ(distance_vector.GetEntries()[0].dependence_information, DistanceEntry::DependenceInformation::IRRELEVANT); EXPECT_EQ(distance_vector.GetEntries()[1].dependence_information, DistanceEntry::DependenceInformation::DISTANCE); EXPECT_EQ(distance_vector.GetEntries()[1].distance, 0); } } // For the loop in function b { const Function* f = spvtest::GetFunction(module, 8); LoopDescriptor& ld = *context->GetLoopDescriptor(f); std::vector loops{&ld.GetLoopByIndex(1), &ld.GetLoopByIndex(0)}; LoopDependenceAnalysis analysis{context.get(), loops}; const Instruction* store[1]; int stores_found = 0; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 56)) { if (inst.opcode() == spv::Op::OpStore) { store[stores_found] = &inst; ++stores_found; } } for (int i = 0; i < 1; ++i) { EXPECT_TRUE(store[i]); } // 66 -> 67 { DistanceVector distance_vector{loops.size()}; EXPECT_FALSE(analysis.GetDependence( context->get_def_use_mgr()->GetDef(66), store[0], &distance_vector)); EXPECT_EQ(distance_vector.GetEntries()[0].dependence_information, DistanceEntry::DependenceInformation::DISTANCE); EXPECT_EQ(distance_vector.GetEntries()[0].distance, 0); EXPECT_EQ(distance_vector.GetEntries()[1].dependence_information, DistanceEntry::DependenceInformation::IRRELEVANT); } } } void CheckDependenceAndDirection(const Instruction* source, const Instruction* destination, bool expected_dependence, DistanceVector expected_distance, LoopDependenceAnalysis* analysis) { DistanceVector dv_entry(2); EXPECT_EQ(expected_dependence, analysis->GetDependence(source, destination, &dv_entry)); EXPECT_EQ(expected_distance, dv_entry); } /* Generated from the following GLSL fragment shader with --eliminate-local-multi-store #version 440 core layout(location = 0) in vec4 c; void main(){ int[10] arr; int a = 2; int b = 3; int N = int(c.x); for (int i = 0; i < 10; i++) { for (int j = 2; j < 10; j++) { arr[i] = arr[j]; // 0 arr[j] = arr[i]; // 1 arr[j-2] = arr[i+3]; // 2 arr[j-a] = arr[i+b]; // 3 arr[2*i] = arr[4*j+3]; // 4, independent arr[2*i] = arr[4*j]; // 5 arr[i+j] = arr[i+j]; // 6 arr[10*i+j] = arr[10*i+j]; // 7 arr[10*i+10*j] = arr[10*i+10*j+3]; // 8, independent arr[10*i+10*j] = arr[10*i+N*j+3]; // 9, bail out because of N coefficient arr[10*i+10*j] = arr[10*i+10*j+N]; // 10, bail out because of N constant // term arr[10*i+N*j] = arr[10*i+10*j+3]; // 11, bail out because of N coefficient arr[10*i+10*j+N] = arr[10*i+10*j]; // 12, bail out because of N constant // term arr[10*i] = arr[5*j]; // 13, independent arr[5*i] = arr[10*j]; // 14, independent arr[9*i] = arr[3*j]; // 15, independent arr[3*i] = arr[9*j]; // 16, independent } } } */ TEST(DependencyAnalysis, MIV) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %16 OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "a" OpName %10 "b" OpName %12 "N" OpName %16 "c" OpName %23 "i" OpName %34 "j" OpName %45 "arr" OpDecorate %16 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 2 %11 = OpConstant %6 3 %13 = OpTypeFloat 32 %14 = OpTypeVector %13 4 %15 = OpTypePointer Input %14 %16 = OpVariable %15 Input %17 = OpTypeInt 32 0 %18 = OpConstant %17 0 %19 = OpTypePointer Input %13 %24 = OpConstant %6 0 %31 = OpConstant %6 10 %32 = OpTypeBool %42 = OpConstant %17 10 %43 = OpTypeArray %6 %42 %44 = OpTypePointer Function %43 %74 = OpConstant %6 4 %184 = OpConstant %6 5 %197 = OpConstant %6 9 %213 = OpConstant %6 1 %218 = OpUndef %6 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %12 = OpVariable %7 Function %23 = OpVariable %7 Function %34 = OpVariable %7 Function %45 = OpVariable %44 Function OpStore %8 %9 OpStore %10 %11 %20 = OpAccessChain %19 %16 %18 %21 = OpLoad %13 %20 %22 = OpConvertFToS %6 %21 OpStore %12 %22 OpStore %23 %24 OpBranch %25 %25 = OpLabel %217 = OpPhi %6 %24 %5 %216 %28 %219 = OpPhi %6 %218 %5 %220 %28 OpLoopMerge %27 %28 None OpBranch %29 %29 = OpLabel %33 = OpSLessThan %32 %217 %31 OpBranchConditional %33 %26 %27 %26 = OpLabel OpStore %34 %9 OpBranch %35 %35 = OpLabel %220 = OpPhi %6 %9 %26 %214 %38 OpLoopMerge %37 %38 None OpBranch %39 %39 = OpLabel %41 = OpSLessThan %32 %220 %31 OpBranchConditional %41 %36 %37 %36 = OpLabel %48 = OpAccessChain %7 %45 %220 %49 = OpLoad %6 %48 %50 = OpAccessChain %7 %45 %217 OpStore %50 %49 %53 = OpAccessChain %7 %45 %217 %54 = OpLoad %6 %53 %55 = OpAccessChain %7 %45 %220 OpStore %55 %54 %57 = OpISub %6 %220 %9 %59 = OpIAdd %6 %217 %11 %60 = OpAccessChain %7 %45 %59 %61 = OpLoad %6 %60 %62 = OpAccessChain %7 %45 %57 OpStore %62 %61 %65 = OpISub %6 %220 %9 %68 = OpIAdd %6 %217 %11 %69 = OpAccessChain %7 %45 %68 %70 = OpLoad %6 %69 %71 = OpAccessChain %7 %45 %65 OpStore %71 %70 %73 = OpIMul %6 %9 %217 %76 = OpIMul %6 %74 %220 %77 = OpIAdd %6 %76 %11 %78 = OpAccessChain %7 %45 %77 %79 = OpLoad %6 %78 %80 = OpAccessChain %7 %45 %73 OpStore %80 %79 %82 = OpIMul %6 %9 %217 %84 = OpIMul %6 %74 %220 %85 = OpAccessChain %7 %45 %84 %86 = OpLoad %6 %85 %87 = OpAccessChain %7 %45 %82 OpStore %87 %86 %90 = OpIAdd %6 %217 %220 %93 = OpIAdd %6 %217 %220 %94 = OpAccessChain %7 %45 %93 %95 = OpLoad %6 %94 %96 = OpAccessChain %7 %45 %90 OpStore %96 %95 %98 = OpIMul %6 %31 %217 %100 = OpIAdd %6 %98 %220 %102 = OpIMul %6 %31 %217 %104 = OpIAdd %6 %102 %220 %105 = OpAccessChain %7 %45 %104 %106 = OpLoad %6 %105 %107 = OpAccessChain %7 %45 %100 OpStore %107 %106 %109 = OpIMul %6 %31 %217 %111 = OpIMul %6 %31 %220 %112 = OpIAdd %6 %109 %111 %114 = OpIMul %6 %31 %217 %116 = OpIMul %6 %31 %220 %117 = OpIAdd %6 %114 %116 %118 = OpIAdd %6 %117 %11 %119 = OpAccessChain %7 %45 %118 %120 = OpLoad %6 %119 %121 = OpAccessChain %7 %45 %112 OpStore %121 %120 %123 = OpIMul %6 %31 %217 %125 = OpIMul %6 %31 %220 %126 = OpIAdd %6 %123 %125 %128 = OpIMul %6 %31 %217 %131 = OpIMul %6 %22 %220 %132 = OpIAdd %6 %128 %131 %133 = OpIAdd %6 %132 %11 %134 = OpAccessChain %7 %45 %133 %135 = OpLoad %6 %134 %136 = OpAccessChain %7 %45 %126 OpStore %136 %135 %138 = OpIMul %6 %31 %217 %140 = OpIMul %6 %31 %220 %141 = OpIAdd %6 %138 %140 %143 = OpIMul %6 %31 %217 %145 = OpIMul %6 %31 %220 %146 = OpIAdd %6 %143 %145 %148 = OpIAdd %6 %146 %22 %149 = OpAccessChain %7 %45 %148 %150 = OpLoad %6 %149 %151 = OpAccessChain %7 %45 %141 OpStore %151 %150 %153 = OpIMul %6 %31 %217 %156 = OpIMul %6 %22 %220 %157 = OpIAdd %6 %153 %156 %159 = OpIMul %6 %31 %217 %161 = OpIMul %6 %31 %220 %162 = OpIAdd %6 %159 %161 %163 = OpIAdd %6 %162 %11 %164 = OpAccessChain %7 %45 %163 %165 = OpLoad %6 %164 %166 = OpAccessChain %7 %45 %157 OpStore %166 %165 %168 = OpIMul %6 %31 %217 %170 = OpIMul %6 %31 %220 %171 = OpIAdd %6 %168 %170 %173 = OpIAdd %6 %171 %22 %175 = OpIMul %6 %31 %217 %177 = OpIMul %6 %31 %220 %178 = OpIAdd %6 %175 %177 %179 = OpAccessChain %7 %45 %178 %180 = OpLoad %6 %179 %181 = OpAccessChain %7 %45 %173 OpStore %181 %180 %183 = OpIMul %6 %31 %217 %186 = OpIMul %6 %184 %220 %187 = OpAccessChain %7 %45 %186 %188 = OpLoad %6 %187 %189 = OpAccessChain %7 %45 %183 OpStore %189 %188 %191 = OpIMul %6 %184 %217 %193 = OpIMul %6 %31 %220 %194 = OpAccessChain %7 %45 %193 %195 = OpLoad %6 %194 %196 = OpAccessChain %7 %45 %191 OpStore %196 %195 %199 = OpIMul %6 %197 %217 %201 = OpIMul %6 %11 %220 %202 = OpAccessChain %7 %45 %201 %203 = OpLoad %6 %202 %204 = OpAccessChain %7 %45 %199 OpStore %204 %203 %206 = OpIMul %6 %11 %217 %208 = OpIMul %6 %197 %220 %209 = OpAccessChain %7 %45 %208 %210 = OpLoad %6 %209 %211 = OpAccessChain %7 %45 %206 OpStore %211 %210 OpBranch %38 %38 = OpLabel %214 = OpIAdd %6 %220 %213 OpStore %34 %214 OpBranch %35 %37 = OpLabel OpBranch %28 %28 = OpLabel %216 = OpIAdd %6 %217 %213 OpStore %23 %216 OpBranch %25 %27 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 4); LoopDescriptor& ld = *context->GetLoopDescriptor(f); std::vector loops{&ld.GetLoopByIndex(0), &ld.GetLoopByIndex(1)}; LoopDependenceAnalysis analysis{context.get(), loops}; const int instructions_expected = 17; const Instruction* store[instructions_expected]; const Instruction* load[instructions_expected]; int stores_found = 0; int loads_found = 0; int block_id = 36; ASSERT_TRUE(spvtest::GetBasicBlock(f, block_id)); for (const Instruction& inst : *spvtest::GetBasicBlock(f, block_id)) { if (inst.opcode() == spv::Op::OpStore) { store[stores_found] = &inst; ++stores_found; } if (inst.opcode() == spv::Op::OpLoad) { load[loads_found] = &inst; ++loads_found; } } EXPECT_EQ(instructions_expected, stores_found); EXPECT_EQ(instructions_expected, loads_found); auto directions_all = DistanceEntry(DistanceEntry::Directions::ALL); auto directions_none = DistanceEntry(DistanceEntry::Directions::NONE); auto dependent = DistanceVector({directions_all, directions_all}); auto independent = DistanceVector({directions_none, directions_none}); CheckDependenceAndDirection(load[0], store[0], false, dependent, &analysis); CheckDependenceAndDirection(load[1], store[1], false, dependent, &analysis); CheckDependenceAndDirection(load[2], store[2], false, dependent, &analysis); CheckDependenceAndDirection(load[3], store[3], false, dependent, &analysis); CheckDependenceAndDirection(load[4], store[4], true, independent, &analysis); CheckDependenceAndDirection(load[5], store[5], false, dependent, &analysis); CheckDependenceAndDirection(load[6], store[6], false, dependent, &analysis); CheckDependenceAndDirection(load[7], store[7], false, dependent, &analysis); CheckDependenceAndDirection(load[8], store[8], true, independent, &analysis); CheckDependenceAndDirection(load[9], store[9], false, dependent, &analysis); CheckDependenceAndDirection(load[10], store[10], false, dependent, &analysis); CheckDependenceAndDirection(load[11], store[11], false, dependent, &analysis); CheckDependenceAndDirection(load[12], store[12], false, dependent, &analysis); CheckDependenceAndDirection(load[13], store[13], true, independent, &analysis); CheckDependenceAndDirection(load[14], store[14], true, independent, &analysis); CheckDependenceAndDirection(load[15], store[15], true, independent, &analysis); CheckDependenceAndDirection(load[16], store[16], true, independent, &analysis); } void PartitionSubscripts(const Instruction* instruction_0, const Instruction* instruction_1, LoopDependenceAnalysis* analysis, std::vector> expected_ids) { auto subscripts_0 = analysis->GetSubscripts(instruction_0); auto subscripts_1 = analysis->GetSubscripts(instruction_1); std::vector>> expected_partition{}; for (const auto& partition : expected_ids) { expected_partition.push_back( std::set>{}); for (auto id : partition) { expected_partition.back().insert({subscripts_0[id], subscripts_1[id]}); } } EXPECT_EQ(expected_partition, analysis->PartitionSubscripts(subscripts_0, subscripts_1)); } /* Generated from the following GLSL fragment shader with --eliminate-local-multi-store #version 440 core void main(){ int[10][10][10][10] arr; for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { for (int k = 0; k < 10; k++) { for (int l = 0; l < 10; l++) { arr[i][j][k][l] = arr[i][j][k][l]; // 0, all independent arr[i][j][k][l] = arr[i][j][l][0]; // 1, last 2 coupled arr[i][j][k][l] = arr[j][i][k][l]; // 2, first 2 coupled arr[i][j][k][l] = arr[l][j][k][i]; // 3, first & last coupled arr[i][j][k][l] = arr[i][k][j][l]; // 4, middle 2 coupled arr[i+j][j][k][l] = arr[i][j][k][l]; // 5, first 2 coupled arr[i+j+k][j][k][l] = arr[i][j][k][l]; // 6, first 3 coupled arr[i+j+k+l][j][k][l] = arr[i][j][k][l]; // 7, all 4 coupled arr[i][j][k][l] = arr[i][l][j][k]; // 8, last 3 coupled arr[i][j-k][k][l] = arr[i][j][l][k]; // 9, last 3 coupled arr[i][j][k][l] = arr[l][i][j][k]; // 10, all 4 coupled arr[i][j][k][l] = arr[j][i][l][k]; // 11, 2 coupled partitions (i,j) & (l&k) arr[i][j][k][l] = arr[k][l][i][j]; // 12, 2 coupled partitions (i,k) & (j&l) } } } } } */ TEST(DependencyAnalysis, SubscriptPartitioning) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %19 "j" OpName %27 "k" OpName %35 "l" OpName %50 "arr" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %43 = OpTypeInt 32 0 %44 = OpConstant %43 10 %45 = OpTypeArray %6 %44 %46 = OpTypeArray %45 %44 %47 = OpTypeArray %46 %44 %48 = OpTypeArray %47 %44 %49 = OpTypePointer Function %48 %208 = OpConstant %6 1 %217 = OpUndef %6 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %19 = OpVariable %7 Function %27 = OpVariable %7 Function %35 = OpVariable %7 Function %50 = OpVariable %49 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %216 = OpPhi %6 %9 %5 %215 %13 %218 = OpPhi %6 %217 %5 %221 %13 %219 = OpPhi %6 %217 %5 %222 %13 %220 = OpPhi %6 %217 %5 %223 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %216 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel OpStore %19 %9 OpBranch %20 %20 = OpLabel %221 = OpPhi %6 %9 %11 %213 %23 %222 = OpPhi %6 %219 %11 %224 %23 %223 = OpPhi %6 %220 %11 %225 %23 OpLoopMerge %22 %23 None OpBranch %24 %24 = OpLabel %26 = OpSLessThan %17 %221 %16 OpBranchConditional %26 %21 %22 %21 = OpLabel OpStore %27 %9 OpBranch %28 %28 = OpLabel %224 = OpPhi %6 %9 %21 %211 %31 %225 = OpPhi %6 %223 %21 %226 %31 OpLoopMerge %30 %31 None OpBranch %32 %32 = OpLabel %34 = OpSLessThan %17 %224 %16 OpBranchConditional %34 %29 %30 %29 = OpLabel OpStore %35 %9 OpBranch %36 %36 = OpLabel %226 = OpPhi %6 %9 %29 %209 %39 OpLoopMerge %38 %39 None OpBranch %40 %40 = OpLabel %42 = OpSLessThan %17 %226 %16 OpBranchConditional %42 %37 %38 %37 = OpLabel %59 = OpAccessChain %7 %50 %216 %221 %224 %226 %60 = OpLoad %6 %59 %61 = OpAccessChain %7 %50 %216 %221 %224 %226 OpStore %61 %60 %69 = OpAccessChain %7 %50 %216 %221 %226 %9 %70 = OpLoad %6 %69 %71 = OpAccessChain %7 %50 %216 %221 %224 %226 OpStore %71 %70 %80 = OpAccessChain %7 %50 %221 %216 %224 %226 %81 = OpLoad %6 %80 %82 = OpAccessChain %7 %50 %216 %221 %224 %226 OpStore %82 %81 %91 = OpAccessChain %7 %50 %226 %221 %224 %216 %92 = OpLoad %6 %91 %93 = OpAccessChain %7 %50 %216 %221 %224 %226 OpStore %93 %92 %102 = OpAccessChain %7 %50 %216 %224 %221 %226 %103 = OpLoad %6 %102 %104 = OpAccessChain %7 %50 %216 %221 %224 %226 OpStore %104 %103 %107 = OpIAdd %6 %216 %221 %115 = OpAccessChain %7 %50 %216 %221 %224 %226 %116 = OpLoad %6 %115 %117 = OpAccessChain %7 %50 %107 %221 %224 %226 OpStore %117 %116 %120 = OpIAdd %6 %216 %221 %122 = OpIAdd %6 %120 %224 %130 = OpAccessChain %7 %50 %216 %221 %224 %226 %131 = OpLoad %6 %130 %132 = OpAccessChain %7 %50 %122 %221 %224 %226 OpStore %132 %131 %135 = OpIAdd %6 %216 %221 %137 = OpIAdd %6 %135 %224 %139 = OpIAdd %6 %137 %226 %147 = OpAccessChain %7 %50 %216 %221 %224 %226 %148 = OpLoad %6 %147 %149 = OpAccessChain %7 %50 %139 %221 %224 %226 OpStore %149 %148 %158 = OpAccessChain %7 %50 %216 %226 %221 %224 %159 = OpLoad %6 %158 %160 = OpAccessChain %7 %50 %216 %221 %224 %226 OpStore %160 %159 %164 = OpISub %6 %221 %224 %171 = OpAccessChain %7 %50 %216 %221 %226 %224 %172 = OpLoad %6 %171 %173 = OpAccessChain %7 %50 %216 %164 %224 %226 OpStore %173 %172 %182 = OpAccessChain %7 %50 %226 %216 %221 %224 %183 = OpLoad %6 %182 %184 = OpAccessChain %7 %50 %216 %221 %224 %226 OpStore %184 %183 %193 = OpAccessChain %7 %50 %221 %216 %226 %224 %194 = OpLoad %6 %193 %195 = OpAccessChain %7 %50 %216 %221 %224 %226 OpStore %195 %194 %204 = OpAccessChain %7 %50 %224 %226 %216 %221 %205 = OpLoad %6 %204 %206 = OpAccessChain %7 %50 %216 %221 %224 %226 OpStore %206 %205 OpBranch %39 %39 = OpLabel %209 = OpIAdd %6 %226 %208 OpStore %35 %209 OpBranch %36 %38 = OpLabel OpBranch %31 %31 = OpLabel %211 = OpIAdd %6 %224 %208 OpStore %27 %211 OpBranch %28 %30 = OpLabel OpBranch %23 %23 = OpLabel %213 = OpIAdd %6 %221 %208 OpStore %19 %213 OpBranch %20 %22 = OpLabel OpBranch %13 %13 = OpLabel %215 = OpIAdd %6 %216 %208 OpStore %8 %215 OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 4); LoopDescriptor& ld = *context->GetLoopDescriptor(f); std::vector loop_nest{ &ld.GetLoopByIndex(0), &ld.GetLoopByIndex(1), &ld.GetLoopByIndex(2), &ld.GetLoopByIndex(3)}; LoopDependenceAnalysis analysis{context.get(), loop_nest}; const int instructions_expected = 13; const Instruction* store[instructions_expected]; const Instruction* load[instructions_expected]; int stores_found = 0; int loads_found = 0; int block_id = 37; ASSERT_TRUE(spvtest::GetBasicBlock(f, block_id)); for (const Instruction& inst : *spvtest::GetBasicBlock(f, block_id)) { if (inst.opcode() == spv::Op::OpStore) { store[stores_found] = &inst; ++stores_found; } if (inst.opcode() == spv::Op::OpLoad) { load[loads_found] = &inst; ++loads_found; } } EXPECT_EQ(instructions_expected, stores_found); EXPECT_EQ(instructions_expected, loads_found); PartitionSubscripts(load[0], store[0], &analysis, {{0}, {1}, {2}, {3}}); PartitionSubscripts(load[1], store[1], &analysis, {{0}, {1}, {2, 3}}); PartitionSubscripts(load[2], store[2], &analysis, {{0, 1}, {2}, {3}}); PartitionSubscripts(load[3], store[3], &analysis, {{0, 3}, {1}, {2}}); PartitionSubscripts(load[4], store[4], &analysis, {{0}, {1, 2}, {3}}); PartitionSubscripts(load[5], store[5], &analysis, {{0, 1}, {2}, {3}}); PartitionSubscripts(load[6], store[6], &analysis, {{0, 1, 2}, {3}}); PartitionSubscripts(load[7], store[7], &analysis, {{0, 1, 2, 3}}); PartitionSubscripts(load[8], store[8], &analysis, {{0}, {1, 2, 3}}); PartitionSubscripts(load[9], store[9], &analysis, {{0}, {1, 2, 3}}); PartitionSubscripts(load[10], store[10], &analysis, {{0, 1, 2, 3}}); PartitionSubscripts(load[11], store[11], &analysis, {{0, 1}, {2, 3}}); PartitionSubscripts(load[12], store[12], &analysis, {{0, 2}, {1, 3}}); } /* Generated from the following GLSL fragment shader with --eliminate-local-multi-store #version 440 core void a() { int[10][10] arr; for (int i = 0; i < 10; ++i) { for (int j = 0; j < 10; ++j) { // Dependent, distance vector (1, -1) arr[i+1][i+j] = arr[i][i+j]; } } } void b() { int[10][10] arr; for (int i = 0; i < 10; ++i) { // Independent arr[i+1][i+2] = arr[i][i] + 2; } } void c() { int[10][10] arr; for (int i = 0; i < 10; ++i) { // Dependence point (1,2) arr[i][i] = arr[1][i-1] + 2; } } void d() { int[10][10][10] arr; for (int i = 0; i < 10; ++i) { for (int j = 0; j < 10; ++j) { for (int k = 0; k < 10; ++k) { // Dependent, distance vector (1,1,-1) arr[j-i][i+1][j+k] = arr[j-i][i][j+k]; } } } } void e() { int[10][10] arr; for (int i = 0; i < 10; ++i) { for (int j = 0; j < 10; ++j) { // Independent with GCD after propagation arr[i][2*j+i] = arr[i][2*j-i+5]; } } } void main(){ a(); b(); c(); d(); e(); } */ TEST(DependencyAnalysis, Delta) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %6 "a(" OpName %8 "b(" OpName %10 "c(" OpName %12 "d(" OpName %14 "e(" OpName %18 "i" OpName %29 "j" OpName %42 "arr" OpName %60 "i" OpName %68 "arr" OpName %82 "i" OpName %90 "arr" OpName %101 "i" OpName %109 "j" OpName %117 "k" OpName %127 "arr" OpName %152 "i" OpName %160 "j" OpName %168 "arr" %2 = OpTypeVoid %3 = OpTypeFunction %2 %16 = OpTypeInt 32 1 %17 = OpTypePointer Function %16 %19 = OpConstant %16 0 %26 = OpConstant %16 10 %27 = OpTypeBool %37 = OpTypeInt 32 0 %38 = OpConstant %37 10 %39 = OpTypeArray %16 %38 %40 = OpTypeArray %39 %38 %41 = OpTypePointer Function %40 %44 = OpConstant %16 1 %72 = OpConstant %16 2 %125 = OpTypeArray %40 %38 %126 = OpTypePointer Function %125 %179 = OpConstant %16 5 %4 = OpFunction %2 None %3 %5 = OpLabel %188 = OpFunctionCall %2 %6 %189 = OpFunctionCall %2 %8 %190 = OpFunctionCall %2 %10 %191 = OpFunctionCall %2 %12 %192 = OpFunctionCall %2 %14 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %18 = OpVariable %17 Function %29 = OpVariable %17 Function %42 = OpVariable %41 Function OpStore %18 %19 OpBranch %20 %20 = OpLabel %193 = OpPhi %16 %19 %7 %59 %23 OpLoopMerge %22 %23 None OpBranch %24 %24 = OpLabel %28 = OpSLessThan %27 %193 %26 OpBranchConditional %28 %21 %22 %21 = OpLabel OpStore %29 %19 OpBranch %30 %30 = OpLabel %194 = OpPhi %16 %19 %21 %57 %33 OpLoopMerge %32 %33 None OpBranch %34 %34 = OpLabel %36 = OpSLessThan %27 %194 %26 OpBranchConditional %36 %31 %32 %31 = OpLabel %45 = OpIAdd %16 %193 %44 %48 = OpIAdd %16 %193 %194 %52 = OpIAdd %16 %193 %194 %53 = OpAccessChain %17 %42 %193 %52 %54 = OpLoad %16 %53 %55 = OpAccessChain %17 %42 %45 %48 OpStore %55 %54 OpBranch %33 %33 = OpLabel %57 = OpIAdd %16 %194 %44 OpStore %29 %57 OpBranch %30 %32 = OpLabel OpBranch %23 %23 = OpLabel %59 = OpIAdd %16 %193 %44 OpStore %18 %59 OpBranch %20 %22 = OpLabel OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %60 = OpVariable %17 Function %68 = OpVariable %41 Function OpStore %60 %19 OpBranch %61 %61 = OpLabel %196 = OpPhi %16 %19 %9 %81 %64 OpLoopMerge %63 %64 None OpBranch %65 %65 = OpLabel %67 = OpSLessThan %27 %196 %26 OpBranchConditional %67 %62 %63 %62 = OpLabel %70 = OpIAdd %16 %196 %44 %73 = OpIAdd %16 %196 %72 %76 = OpAccessChain %17 %68 %196 %196 %77 = OpLoad %16 %76 %78 = OpIAdd %16 %77 %72 %79 = OpAccessChain %17 %68 %70 %73 OpStore %79 %78 OpBranch %64 %64 = OpLabel %81 = OpIAdd %16 %196 %44 OpStore %60 %81 OpBranch %61 %63 = OpLabel OpReturn OpFunctionEnd %10 = OpFunction %2 None %3 %11 = OpLabel %82 = OpVariable %17 Function %90 = OpVariable %41 Function OpStore %82 %19 OpBranch %83 %83 = OpLabel %197 = OpPhi %16 %19 %11 %100 %86 OpLoopMerge %85 %86 None OpBranch %87 %87 = OpLabel %89 = OpSLessThan %27 %197 %26 OpBranchConditional %89 %84 %85 %84 = OpLabel %94 = OpISub %16 %197 %44 %95 = OpAccessChain %17 %90 %44 %94 %96 = OpLoad %16 %95 %97 = OpIAdd %16 %96 %72 %98 = OpAccessChain %17 %90 %197 %197 OpStore %98 %97 OpBranch %86 %86 = OpLabel %100 = OpIAdd %16 %197 %44 OpStore %82 %100 OpBranch %83 %85 = OpLabel OpReturn OpFunctionEnd %12 = OpFunction %2 None %3 %13 = OpLabel %101 = OpVariable %17 Function %109 = OpVariable %17 Function %117 = OpVariable %17 Function %127 = OpVariable %126 Function OpStore %101 %19 OpBranch %102 %102 = OpLabel %198 = OpPhi %16 %19 %13 %151 %105 OpLoopMerge %104 %105 None OpBranch %106 %106 = OpLabel %108 = OpSLessThan %27 %198 %26 OpBranchConditional %108 %103 %104 %103 = OpLabel OpStore %109 %19 OpBranch %110 %110 = OpLabel %199 = OpPhi %16 %19 %103 %149 %113 OpLoopMerge %112 %113 None OpBranch %114 %114 = OpLabel %116 = OpSLessThan %27 %199 %26 OpBranchConditional %116 %111 %112 %111 = OpLabel OpStore %117 %19 OpBranch %118 %118 = OpLabel %201 = OpPhi %16 %19 %111 %147 %121 OpLoopMerge %120 %121 None OpBranch %122 %122 = OpLabel %124 = OpSLessThan %27 %201 %26 OpBranchConditional %124 %119 %120 %119 = OpLabel %130 = OpISub %16 %199 %198 %132 = OpIAdd %16 %198 %44 %135 = OpIAdd %16 %199 %201 %138 = OpISub %16 %199 %198 %142 = OpIAdd %16 %199 %201 %143 = OpAccessChain %17 %127 %138 %198 %142 %144 = OpLoad %16 %143 %145 = OpAccessChain %17 %127 %130 %132 %135 OpStore %145 %144 OpBranch %121 %121 = OpLabel %147 = OpIAdd %16 %201 %44 OpStore %117 %147 OpBranch %118 %120 = OpLabel OpBranch %113 %113 = OpLabel %149 = OpIAdd %16 %199 %44 OpStore %109 %149 OpBranch %110 %112 = OpLabel OpBranch %105 %105 = OpLabel %151 = OpIAdd %16 %198 %44 OpStore %101 %151 OpBranch %102 %104 = OpLabel OpReturn OpFunctionEnd %14 = OpFunction %2 None %3 %15 = OpLabel %152 = OpVariable %17 Function %160 = OpVariable %17 Function %168 = OpVariable %41 Function OpStore %152 %19 OpBranch %153 %153 = OpLabel %204 = OpPhi %16 %19 %15 %187 %156 OpLoopMerge %155 %156 None OpBranch %157 %157 = OpLabel %159 = OpSLessThan %27 %204 %26 OpBranchConditional %159 %154 %155 %154 = OpLabel OpStore %160 %19 OpBranch %161 %161 = OpLabel %205 = OpPhi %16 %19 %154 %185 %164 OpLoopMerge %163 %164 None OpBranch %165 %165 = OpLabel %167 = OpSLessThan %27 %205 %26 OpBranchConditional %167 %162 %163 %162 = OpLabel %171 = OpIMul %16 %72 %205 %173 = OpIAdd %16 %171 %204 %176 = OpIMul %16 %72 %205 %178 = OpISub %16 %176 %204 %180 = OpIAdd %16 %178 %179 %181 = OpAccessChain %17 %168 %204 %180 %182 = OpLoad %16 %181 %183 = OpAccessChain %17 %168 %204 %173 OpStore %183 %182 OpBranch %164 %164 = OpLabel %185 = OpIAdd %16 %205 %44 OpStore %160 %185 OpBranch %161 %163 = OpLabel OpBranch %156 %156 = OpLabel %187 = OpIAdd %16 %204 %44 OpStore %152 %187 OpBranch %153 %155 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); ASSERT_NE(nullptr, context); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; { const Function* f = spvtest::GetFunction(module, 6); LoopDescriptor& ld = *context->GetLoopDescriptor(f); const Instruction* store = nullptr; const Instruction* load = nullptr; int block_id = 31; ASSERT_TRUE(spvtest::GetBasicBlock(f, block_id)); for (const Instruction& inst : *spvtest::GetBasicBlock(f, block_id)) { if (inst.opcode() == spv::Op::OpStore) { store = &inst; } if (inst.opcode() == spv::Op::OpLoad) { load = &inst; } } EXPECT_NE(nullptr, store); EXPECT_NE(nullptr, load); std::vector loop_nest{&ld.GetLoopByIndex(0), &ld.GetLoopByIndex(1)}; LoopDependenceAnalysis analysis{context.get(), loop_nest}; DistanceVector dv_entry(loop_nest.size()); std::vector expected_entries{ DistanceEntry(DistanceEntry::Directions::LT, 1), DistanceEntry(DistanceEntry::Directions::LT, 1)}; DistanceVector expected_distance_vector(expected_entries); auto is_independent = analysis.GetDependence(load, store, &dv_entry); EXPECT_FALSE(is_independent); EXPECT_EQ(expected_distance_vector, dv_entry); } { const Function* f = spvtest::GetFunction(module, 8); LoopDescriptor& ld = *context->GetLoopDescriptor(f); const Instruction* store = nullptr; const Instruction* load = nullptr; int block_id = 62; ASSERT_TRUE(spvtest::GetBasicBlock(f, block_id)); for (const Instruction& inst : *spvtest::GetBasicBlock(f, block_id)) { if (inst.opcode() == spv::Op::OpStore) { store = &inst; } if (inst.opcode() == spv::Op::OpLoad) { load = &inst; } } EXPECT_NE(nullptr, store); EXPECT_NE(nullptr, load); std::vector loop_nest{&ld.GetLoopByIndex(0)}; LoopDependenceAnalysis analysis{context.get(), loop_nest}; DistanceVector dv_entry(loop_nest.size()); auto is_independent = analysis.GetDependence(load, store, &dv_entry); EXPECT_TRUE(is_independent); } { const Function* f = spvtest::GetFunction(module, 10); LoopDescriptor& ld = *context->GetLoopDescriptor(f); const Instruction* store = nullptr; const Instruction* load = nullptr; int block_id = 84; ASSERT_TRUE(spvtest::GetBasicBlock(f, block_id)); for (const Instruction& inst : *spvtest::GetBasicBlock(f, block_id)) { if (inst.opcode() == spv::Op::OpStore) { store = &inst; } if (inst.opcode() == spv::Op::OpLoad) { load = &inst; } } EXPECT_NE(nullptr, store); EXPECT_NE(nullptr, load); std::vector loop_nest{&ld.GetLoopByIndex(0)}; LoopDependenceAnalysis analysis{context.get(), loop_nest}; DistanceVector dv_entry(loop_nest.size()); auto is_independent = analysis.GetDependence(load, store, &dv_entry); DistanceVector expected_distance_vector({DistanceEntry(1, 2)}); EXPECT_FALSE(is_independent); EXPECT_EQ(expected_distance_vector, dv_entry); } { const Function* f = spvtest::GetFunction(module, 12); LoopDescriptor& ld = *context->GetLoopDescriptor(f); const Instruction* store = nullptr; const Instruction* load = nullptr; int block_id = 119; ASSERT_TRUE(spvtest::GetBasicBlock(f, block_id)); for (const Instruction& inst : *spvtest::GetBasicBlock(f, block_id)) { if (inst.opcode() == spv::Op::OpStore) { store = &inst; } if (inst.opcode() == spv::Op::OpLoad) { load = &inst; } } EXPECT_NE(nullptr, store); EXPECT_NE(nullptr, load); std::vector loop_nest{ &ld.GetLoopByIndex(0), &ld.GetLoopByIndex(1), &ld.GetLoopByIndex(2)}; LoopDependenceAnalysis analysis{context.get(), loop_nest}; DistanceVector dv_entry(loop_nest.size()); std::vector expected_entries{ DistanceEntry(DistanceEntry::Directions::LT, 1), DistanceEntry(DistanceEntry::Directions::LT, 1), DistanceEntry(DistanceEntry::Directions::GT, -1)}; DistanceVector expected_distance_vector(expected_entries); auto is_independent = analysis.GetDependence(store, load, &dv_entry); EXPECT_FALSE(is_independent); EXPECT_EQ(expected_distance_vector, dv_entry); } { const Function* f = spvtest::GetFunction(module, 14); LoopDescriptor& ld = *context->GetLoopDescriptor(f); const Instruction* store = nullptr; const Instruction* load = nullptr; int block_id = 162; ASSERT_TRUE(spvtest::GetBasicBlock(f, block_id)); for (const Instruction& inst : *spvtest::GetBasicBlock(f, block_id)) { if (inst.opcode() == spv::Op::OpStore) { store = &inst; } if (inst.opcode() == spv::Op::OpLoad) { load = &inst; } } EXPECT_NE(nullptr, store); EXPECT_NE(nullptr, load); std::vector loop_nest{&ld.GetLoopByIndex(0), &ld.GetLoopByIndex(1)}; LoopDependenceAnalysis analysis{context.get(), loop_nest}; DistanceVector dv_entry(loop_nest.size()); auto is_independent = analysis.GetDependence(load, store, &dv_entry); EXPECT_TRUE(is_independent); } } TEST(DependencyAnalysis, ConstraintIntersection) { LoopDependenceAnalysis analysis{nullptr, std::vector{}}; auto scalar_evolution = analysis.GetScalarEvolution(); { // One is none. Other should be returned auto none = analysis.make_constraint(); auto x = scalar_evolution->CreateConstant(1); auto y = scalar_evolution->CreateConstant(10); auto point = analysis.make_constraint(x, y, nullptr); auto ret_0 = analysis.IntersectConstraints(none, point, nullptr, nullptr); auto ret_point_0 = ret_0->AsDependencePoint(); ASSERT_NE(nullptr, ret_point_0); EXPECT_EQ(*x, *ret_point_0->GetSource()); EXPECT_EQ(*y, *ret_point_0->GetDestination()); auto ret_1 = analysis.IntersectConstraints(point, none, nullptr, nullptr); auto ret_point_1 = ret_1->AsDependencePoint(); ASSERT_NE(nullptr, ret_point_1); EXPECT_EQ(*x, *ret_point_1->GetSource()); EXPECT_EQ(*y, *ret_point_1->GetDestination()); } { // Both distances auto x = scalar_evolution->CreateConstant(1); auto y = scalar_evolution->CreateConstant(10); auto distance_0 = analysis.make_constraint(x, nullptr); auto distance_1 = analysis.make_constraint(y, nullptr); // Equal distances auto ret_0 = analysis.IntersectConstraints(distance_1, distance_1, nullptr, nullptr); auto ret_distance = ret_0->AsDependenceDistance(); ASSERT_NE(nullptr, ret_distance); EXPECT_EQ(*y, *ret_distance->GetDistance()); // Non-equal distances auto ret_1 = analysis.IntersectConstraints(distance_0, distance_1, nullptr, nullptr); EXPECT_NE(nullptr, ret_1->AsDependenceEmpty()); } { // Both points auto x = scalar_evolution->CreateConstant(1); auto y = scalar_evolution->CreateConstant(10); auto point_0 = analysis.make_constraint(x, y, nullptr); auto point_1 = analysis.make_constraint(x, y, nullptr); auto point_2 = analysis.make_constraint(y, y, nullptr); // Equal points auto ret_0 = analysis.IntersectConstraints(point_0, point_1, nullptr, nullptr); auto ret_point_0 = ret_0->AsDependencePoint(); ASSERT_NE(nullptr, ret_point_0); EXPECT_EQ(*x, *ret_point_0->GetSource()); EXPECT_EQ(*y, *ret_point_0->GetDestination()); // Non-equal points auto ret_1 = analysis.IntersectConstraints(point_0, point_2, nullptr, nullptr); EXPECT_NE(nullptr, ret_1->AsDependenceEmpty()); } { // Both lines, parallel auto a0 = scalar_evolution->CreateConstant(3); auto b0 = scalar_evolution->CreateConstant(6); auto c0 = scalar_evolution->CreateConstant(9); auto a1 = scalar_evolution->CreateConstant(6); auto b1 = scalar_evolution->CreateConstant(12); auto c1 = scalar_evolution->CreateConstant(18); auto line_0 = analysis.make_constraint(a0, b0, c0, nullptr); auto line_1 = analysis.make_constraint(a1, b1, c1, nullptr); // Same line, both ways auto ret_0 = analysis.IntersectConstraints(line_0, line_1, nullptr, nullptr); auto ret_1 = analysis.IntersectConstraints(line_1, line_0, nullptr, nullptr); auto ret_line_0 = ret_0->AsDependenceLine(); auto ret_line_1 = ret_1->AsDependenceLine(); EXPECT_NE(nullptr, ret_line_0); EXPECT_NE(nullptr, ret_line_1); // Non-intersecting parallel lines auto c2 = scalar_evolution->CreateConstant(12); auto line_2 = analysis.make_constraint(a1, b1, c2, nullptr); auto ret_2 = analysis.IntersectConstraints(line_0, line_2, nullptr, nullptr); auto ret_3 = analysis.IntersectConstraints(line_2, line_0, nullptr, nullptr); EXPECT_NE(nullptr, ret_2->AsDependenceEmpty()); EXPECT_NE(nullptr, ret_3->AsDependenceEmpty()); auto c3 = scalar_evolution->CreateConstant(20); auto line_3 = analysis.make_constraint(a1, b1, c3, nullptr); auto ret_4 = analysis.IntersectConstraints(line_0, line_3, nullptr, nullptr); auto ret_5 = analysis.IntersectConstraints(line_3, line_0, nullptr, nullptr); EXPECT_NE(nullptr, ret_4->AsDependenceEmpty()); EXPECT_NE(nullptr, ret_5->AsDependenceEmpty()); } { // Non-constant line auto unknown = scalar_evolution->CreateCantComputeNode(); auto constant = scalar_evolution->CreateConstant(10); auto line_0 = analysis.make_constraint(constant, constant, constant, nullptr); auto line_1 = analysis.make_constraint(unknown, unknown, unknown, nullptr); auto ret_0 = analysis.IntersectConstraints(line_0, line_1, nullptr, nullptr); auto ret_1 = analysis.IntersectConstraints(line_1, line_0, nullptr, nullptr); EXPECT_NE(nullptr, ret_0->AsDependenceNone()); EXPECT_NE(nullptr, ret_1->AsDependenceNone()); } { auto bound_0 = scalar_evolution->CreateConstant(0); auto bound_1 = scalar_evolution->CreateConstant(20); auto a0 = scalar_evolution->CreateConstant(1); auto b0 = scalar_evolution->CreateConstant(2); auto c0 = scalar_evolution->CreateConstant(6); auto a1 = scalar_evolution->CreateConstant(-1); auto b1 = scalar_evolution->CreateConstant(2); auto c1 = scalar_evolution->CreateConstant(2); auto line_0 = analysis.make_constraint(a0, b0, c0, nullptr); auto line_1 = analysis.make_constraint(a1, b1, c1, nullptr); // Intersecting lines, has integer solution, in bounds auto ret_0 = analysis.IntersectConstraints(line_0, line_1, bound_0, bound_1); auto ret_1 = analysis.IntersectConstraints(line_1, line_0, bound_0, bound_1); auto ret_point_0 = ret_0->AsDependencePoint(); auto ret_point_1 = ret_1->AsDependencePoint(); EXPECT_NE(nullptr, ret_point_0); EXPECT_NE(nullptr, ret_point_1); auto const_2 = scalar_evolution->CreateConstant(2); EXPECT_EQ(*const_2, *ret_point_0->GetSource()); EXPECT_EQ(*const_2, *ret_point_0->GetDestination()); EXPECT_EQ(*const_2, *ret_point_1->GetSource()); EXPECT_EQ(*const_2, *ret_point_1->GetDestination()); // Intersecting lines, has integer solution, out of bounds auto ret_2 = analysis.IntersectConstraints(line_0, line_1, bound_0, bound_0); auto ret_3 = analysis.IntersectConstraints(line_1, line_0, bound_0, bound_0); EXPECT_NE(nullptr, ret_2->AsDependenceEmpty()); EXPECT_NE(nullptr, ret_3->AsDependenceEmpty()); auto a2 = scalar_evolution->CreateConstant(-4); auto b2 = scalar_evolution->CreateConstant(1); auto c2 = scalar_evolution->CreateConstant(0); auto a3 = scalar_evolution->CreateConstant(4); auto b3 = scalar_evolution->CreateConstant(1); auto c3 = scalar_evolution->CreateConstant(4); auto line_2 = analysis.make_constraint(a2, b2, c2, nullptr); auto line_3 = analysis.make_constraint(a3, b3, c3, nullptr); // Intersecting, no integer solution auto ret_4 = analysis.IntersectConstraints(line_2, line_3, bound_0, bound_1); auto ret_5 = analysis.IntersectConstraints(line_3, line_2, bound_0, bound_1); EXPECT_NE(nullptr, ret_4->AsDependenceEmpty()); EXPECT_NE(nullptr, ret_5->AsDependenceEmpty()); auto unknown = scalar_evolution->CreateCantComputeNode(); // Non-constant bound auto ret_6 = analysis.IntersectConstraints(line_0, line_1, unknown, bound_1); auto ret_7 = analysis.IntersectConstraints(line_1, line_0, bound_0, unknown); EXPECT_NE(nullptr, ret_6->AsDependenceNone()); EXPECT_NE(nullptr, ret_7->AsDependenceNone()); } { auto constant_0 = scalar_evolution->CreateConstant(0); auto constant_1 = scalar_evolution->CreateConstant(1); auto constant_neg_1 = scalar_evolution->CreateConstant(-1); auto constant_2 = scalar_evolution->CreateConstant(2); auto constant_neg_2 = scalar_evolution->CreateConstant(-2); auto point_0_0 = analysis.make_constraint( constant_0, constant_0, nullptr); auto point_0_1 = analysis.make_constraint( constant_0, constant_1, nullptr); auto point_1_0 = analysis.make_constraint( constant_1, constant_0, nullptr); auto point_1_1 = analysis.make_constraint( constant_1, constant_1, nullptr); auto point_1_2 = analysis.make_constraint( constant_1, constant_2, nullptr); auto point_1_neg_1 = analysis.make_constraint( constant_1, constant_neg_1, nullptr); auto point_neg_1_1 = analysis.make_constraint( constant_neg_1, constant_1, nullptr); auto line_y_0 = analysis.make_constraint( constant_0, constant_1, constant_0, nullptr); auto line_y_1 = analysis.make_constraint( constant_0, constant_1, constant_1, nullptr); auto line_y_2 = analysis.make_constraint( constant_0, constant_1, constant_2, nullptr); // Parallel horizontal lines, y = 0 & y = 1, should return no intersection auto ret = analysis.IntersectConstraints(line_y_0, line_y_1, nullptr, nullptr); EXPECT_NE(nullptr, ret->AsDependenceEmpty()); // Parallel horizontal lines, y = 1 & y = 2, should return no intersection auto ret_y_12 = analysis.IntersectConstraints(line_y_1, line_y_2, nullptr, nullptr); EXPECT_NE(nullptr, ret_y_12->AsDependenceEmpty()); // Same horizontal lines, y = 0 & y = 0, should return the line auto ret_y_same_0 = analysis.IntersectConstraints(line_y_0, line_y_0, nullptr, nullptr); EXPECT_NE(nullptr, ret_y_same_0->AsDependenceLine()); // Same horizontal lines, y = 1 & y = 1, should return the line auto ret_y_same_1 = analysis.IntersectConstraints(line_y_1, line_y_1, nullptr, nullptr); EXPECT_NE(nullptr, ret_y_same_1->AsDependenceLine()); auto line_x_0 = analysis.make_constraint( constant_1, constant_0, constant_0, nullptr); auto line_x_1 = analysis.make_constraint( constant_1, constant_0, constant_1, nullptr); auto line_x_2 = analysis.make_constraint( constant_1, constant_0, constant_2, nullptr); auto line_2x_1 = analysis.make_constraint( constant_2, constant_0, constant_1, nullptr); auto line_2x_2 = analysis.make_constraint( constant_2, constant_0, constant_2, nullptr); // Parallel vertical lines, x = 0 & x = 1, should return no intersection auto ret_x = analysis.IntersectConstraints(line_x_0, line_x_1, nullptr, nullptr); EXPECT_NE(nullptr, ret_x->AsDependenceEmpty()); // Parallel vertical lines, x = 1 & x = 2, should return no intersection auto ret_x_12 = analysis.IntersectConstraints(line_x_1, line_x_2, nullptr, nullptr); EXPECT_NE(nullptr, ret_x_12->AsDependenceEmpty()); // Parallel vertical lines, 2x = 1 & 2x = 2, should return no intersection auto ret_2x_2_2x_1 = analysis.IntersectConstraints(line_2x_2, line_2x_1, nullptr, nullptr); EXPECT_NE(nullptr, ret_2x_2_2x_1->AsDependenceEmpty()); // same line, 2x=2 & x = 1 auto ret_2x_2_x_1 = analysis.IntersectConstraints(line_2x_2, line_x_1, nullptr, nullptr); EXPECT_NE(nullptr, ret_2x_2_x_1->AsDependenceLine()); // Same vertical lines, x = 0 & x = 0, should return the line auto ret_x_same_0 = analysis.IntersectConstraints(line_x_0, line_x_0, nullptr, nullptr); EXPECT_NE(nullptr, ret_x_same_0->AsDependenceLine()); // EXPECT_EQ(*line_x_0, *ret_x_same_0->AsDependenceLine()); // Same vertical lines, x = 1 & x = 1, should return the line auto ret_x_same_1 = analysis.IntersectConstraints(line_x_1, line_x_1, nullptr, nullptr); EXPECT_NE(nullptr, ret_x_same_1->AsDependenceLine()); EXPECT_EQ(*line_x_1, *ret_x_same_1->AsDependenceLine()); // x=1 & y = 0, intersect at (1, 0) auto ret_1_0 = analysis.IntersectConstraints(line_x_1, line_y_0, constant_neg_1, constant_2); auto ret_point_1_0 = ret_1_0->AsDependencePoint(); EXPECT_NE(nullptr, ret_point_1_0); EXPECT_EQ(*point_1_0, *ret_point_1_0); // x=1 & y = 1, intersect at (1, 1) auto ret_1_1 = analysis.IntersectConstraints(line_x_1, line_y_1, constant_neg_1, constant_2); auto ret_point_1_1 = ret_1_1->AsDependencePoint(); EXPECT_NE(nullptr, ret_point_1_1); EXPECT_EQ(*point_1_1, *ret_point_1_1); // x=0 & y = 0, intersect at (0, 0) auto ret_0_0 = analysis.IntersectConstraints(line_x_0, line_y_0, constant_neg_1, constant_2); auto ret_point_0_0 = ret_0_0->AsDependencePoint(); EXPECT_NE(nullptr, ret_point_0_0); EXPECT_EQ(*point_0_0, *ret_point_0_0); // x=0 & y = 1, intersect at (0, 1) auto ret_0_1 = analysis.IntersectConstraints(line_x_0, line_y_1, constant_neg_1, constant_2); auto ret_point_0_1 = ret_0_1->AsDependencePoint(); EXPECT_NE(nullptr, ret_point_0_1); EXPECT_EQ(*point_0_1, *ret_point_0_1); // x = 1 & y = 2 auto ret_1_2 = analysis.IntersectConstraints(line_x_1, line_y_2, constant_neg_1, constant_2); auto ret_point_1_2 = ret_1_2->AsDependencePoint(); EXPECT_NE(nullptr, ret_point_1_2); EXPECT_EQ(*point_1_2, *ret_point_1_2); auto line_x_y_0 = analysis.make_constraint( constant_1, constant_1, constant_0, nullptr); auto line_x_y_1 = analysis.make_constraint( constant_1, constant_1, constant_1, nullptr); // x+y=0 & x=0, intersect (0, 0) auto ret_xy_0_x_0 = analysis.IntersectConstraints( line_x_y_0, line_x_0, constant_neg_1, constant_2); EXPECT_NE(nullptr, ret_xy_0_x_0->AsDependencePoint()); EXPECT_EQ(*point_0_0, *ret_xy_0_x_0); // x+y=0 & y=0, intersect (0, 0) auto ret_xy_0_y_0 = analysis.IntersectConstraints( line_x_y_0, line_y_0, constant_neg_1, constant_2); EXPECT_NE(nullptr, ret_xy_0_y_0->AsDependencePoint()); EXPECT_EQ(*point_0_0, *ret_xy_0_y_0); // x+y=0 & x=1, intersect (1, -1) auto ret_xy_0_x_1 = analysis.IntersectConstraints( line_x_y_0, line_x_1, constant_neg_2, constant_2); EXPECT_NE(nullptr, ret_xy_0_x_1->AsDependencePoint()); EXPECT_EQ(*point_1_neg_1, *ret_xy_0_x_1); // x+y=0 & y=1, intersect (-1, 1) auto ret_xy_0_y_1 = analysis.IntersectConstraints( line_x_y_0, line_y_1, constant_neg_2, constant_2); EXPECT_NE(nullptr, ret_xy_0_y_1->AsDependencePoint()); EXPECT_EQ(*point_neg_1_1, *ret_xy_0_y_1); // x=0 & x+y=0, intersect (0, 0) auto ret_x_0_xy_0 = analysis.IntersectConstraints( line_x_0, line_x_y_0, constant_neg_1, constant_2); EXPECT_NE(nullptr, ret_x_0_xy_0->AsDependencePoint()); EXPECT_EQ(*point_0_0, *ret_x_0_xy_0); // y=0 & x+y=0, intersect (0, 0) auto ret_y_0_xy_0 = analysis.IntersectConstraints( line_y_0, line_x_y_0, constant_neg_1, constant_2); EXPECT_NE(nullptr, ret_y_0_xy_0->AsDependencePoint()); EXPECT_EQ(*point_0_0, *ret_y_0_xy_0); // x=1 & x+y=0, intersect (1, -1) auto ret_x_1_xy_0 = analysis.IntersectConstraints( line_x_1, line_x_y_0, constant_neg_2, constant_2); EXPECT_NE(nullptr, ret_x_1_xy_0->AsDependencePoint()); EXPECT_EQ(*point_1_neg_1, *ret_x_1_xy_0); // y=1 & x+y=0, intersect (-1, 1) auto ret_y_1_xy_0 = analysis.IntersectConstraints( line_y_1, line_x_y_0, constant_neg_2, constant_2); EXPECT_NE(nullptr, ret_y_1_xy_0->AsDependencePoint()); EXPECT_EQ(*point_neg_1_1, *ret_y_1_xy_0); // x+y=1 & x=0, intersect (0, 1) auto ret_xy_1_x_0 = analysis.IntersectConstraints( line_x_y_1, line_x_0, constant_neg_1, constant_2); EXPECT_NE(nullptr, ret_xy_1_x_0->AsDependencePoint()); EXPECT_EQ(*point_0_1, *ret_xy_1_x_0); // x+y=1 & y=0, intersect (1, 0) auto ret_xy_1_y_0 = analysis.IntersectConstraints( line_x_y_1, line_y_0, constant_neg_1, constant_2); EXPECT_NE(nullptr, ret_xy_1_y_0->AsDependencePoint()); EXPECT_EQ(*point_1_0, *ret_xy_1_y_0); // x+y=1 & x=1, intersect (1, 0) auto ret_xy_1_x_1 = analysis.IntersectConstraints( line_x_y_1, line_x_1, constant_neg_1, constant_2); EXPECT_NE(nullptr, ret_xy_1_x_1->AsDependencePoint()); EXPECT_EQ(*point_1_0, *ret_xy_1_x_1); // x+y=1 & y=1, intersect (0, 1) auto ret_xy_1_y_1 = analysis.IntersectConstraints( line_x_y_1, line_y_1, constant_neg_1, constant_2); EXPECT_NE(nullptr, ret_xy_1_y_1->AsDependencePoint()); EXPECT_EQ(*point_0_1, *ret_xy_1_y_1); // x=0 & x+y=1, intersect (0, 1) auto ret_x_0_xy_1 = analysis.IntersectConstraints( line_x_0, line_x_y_1, constant_neg_1, constant_2); EXPECT_NE(nullptr, ret_x_0_xy_1->AsDependencePoint()); EXPECT_EQ(*point_0_1, *ret_x_0_xy_1); // y=0 & x+y=1, intersect (1, 0) auto ret_y_0_xy_1 = analysis.IntersectConstraints( line_y_0, line_x_y_1, constant_neg_1, constant_2); EXPECT_NE(nullptr, ret_y_0_xy_1->AsDependencePoint()); EXPECT_EQ(*point_1_0, *ret_y_0_xy_1); // x=1 & x+y=1, intersect (1, 0) auto ret_x_1_xy_1 = analysis.IntersectConstraints( line_x_1, line_x_y_1, constant_neg_2, constant_2); EXPECT_NE(nullptr, ret_x_1_xy_1->AsDependencePoint()); EXPECT_EQ(*point_1_0, *ret_x_1_xy_1); // y=1 & x+y=1, intersect (0, 1) auto ret_y_1_xy_1 = analysis.IntersectConstraints( line_y_1, line_x_y_1, constant_neg_2, constant_2); EXPECT_NE(nullptr, ret_y_1_xy_1->AsDependencePoint()); EXPECT_EQ(*point_0_1, *ret_y_1_xy_1); } { // Line and point auto a = scalar_evolution->CreateConstant(3); auto b = scalar_evolution->CreateConstant(10); auto c = scalar_evolution->CreateConstant(16); auto line = analysis.make_constraint(a, b, c, nullptr); // Point on line auto x = scalar_evolution->CreateConstant(2); auto y = scalar_evolution->CreateConstant(1); auto point_0 = analysis.make_constraint(x, y, nullptr); auto ret_0 = analysis.IntersectConstraints(line, point_0, nullptr, nullptr); auto ret_1 = analysis.IntersectConstraints(point_0, line, nullptr, nullptr); auto ret_point_0 = ret_0->AsDependencePoint(); auto ret_point_1 = ret_1->AsDependencePoint(); ASSERT_NE(nullptr, ret_point_0); ASSERT_NE(nullptr, ret_point_1); EXPECT_EQ(*x, *ret_point_0->GetSource()); EXPECT_EQ(*y, *ret_point_0->GetDestination()); EXPECT_EQ(*x, *ret_point_1->GetSource()); EXPECT_EQ(*y, *ret_point_1->GetDestination()); // Point not on line auto point_1 = analysis.make_constraint(a, a, nullptr); auto ret_2 = analysis.IntersectConstraints(line, point_1, nullptr, nullptr); auto ret_3 = analysis.IntersectConstraints(point_1, line, nullptr, nullptr); EXPECT_NE(nullptr, ret_2->AsDependenceEmpty()); EXPECT_NE(nullptr, ret_3->AsDependenceEmpty()); // Non-constant auto unknown = scalar_evolution->CreateCantComputeNode(); auto point_2 = analysis.make_constraint(unknown, x, nullptr); auto ret_4 = analysis.IntersectConstraints(line, point_2, nullptr, nullptr); auto ret_5 = analysis.IntersectConstraints(point_2, line, nullptr, nullptr); EXPECT_NE(nullptr, ret_4->AsDependenceNone()); EXPECT_NE(nullptr, ret_5->AsDependenceNone()); } { // Distance and point auto d = scalar_evolution->CreateConstant(5); auto distance = analysis.make_constraint(d, nullptr); // Point on line auto x = scalar_evolution->CreateConstant(10); auto point_0 = analysis.make_constraint(d, x, nullptr); auto ret_0 = analysis.IntersectConstraints(distance, point_0, nullptr, nullptr); auto ret_1 = analysis.IntersectConstraints(point_0, distance, nullptr, nullptr); auto ret_point_0 = ret_0->AsDependencePoint(); auto ret_point_1 = ret_1->AsDependencePoint(); ASSERT_NE(nullptr, ret_point_0); ASSERT_NE(nullptr, ret_point_1); // Point not on line auto point_1 = analysis.make_constraint(x, x, nullptr); auto ret_2 = analysis.IntersectConstraints(distance, point_1, nullptr, nullptr); auto ret_3 = analysis.IntersectConstraints(point_1, distance, nullptr, nullptr); EXPECT_NE(nullptr, ret_2->AsDependenceEmpty()); EXPECT_NE(nullptr, ret_3->AsDependenceEmpty()); // Non-constant auto unknown = scalar_evolution->CreateCantComputeNode(); auto unknown_distance = analysis.make_constraint(unknown, nullptr); auto ret_4 = analysis.IntersectConstraints(unknown_distance, point_1, nullptr, nullptr); auto ret_5 = analysis.IntersectConstraints(point_1, unknown_distance, nullptr, nullptr); EXPECT_NE(nullptr, ret_4->AsDependenceNone()); EXPECT_NE(nullptr, ret_5->AsDependenceNone()); } } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/loop_optimizations/dependence_analysis_helpers.cpp000066400000000000000000003127661475742701700325160ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "source/opt/loop_dependence.h" #include "source/opt/loop_descriptor.h" #include "source/opt/scalar_analysis.h" #include "test/opt/assembly_builder.h" #include "test/opt/function_utils.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using DependencyAnalysisHelpers = ::testing::Test; /* Generated from the following GLSL fragment shader with --eliminate-local-multi-store #version 440 core void a() { int[10][10] arr; int i = 0; int j = 0; for (; i < 10 && j < 10; i++, j++) { arr[i][j] = arr[i][j]; } } void b() { int[10] arr; for (int i = 0; i < 10; i+=2) { arr[i] = arr[i]; } } void main(){ a(); b(); } */ TEST(DependencyAnalysisHelpers, UnsupportedLoops) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %6 "a(" OpName %8 "b(" OpName %12 "i" OpName %14 "j" OpName %32 "arr" OpName %45 "i" OpName %54 "arr" %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeInt 32 1 %11 = OpTypePointer Function %10 %13 = OpConstant %10 0 %21 = OpConstant %10 10 %22 = OpTypeBool %27 = OpTypeInt 32 0 %28 = OpConstant %27 10 %29 = OpTypeArray %10 %28 %30 = OpTypeArray %29 %28 %31 = OpTypePointer Function %30 %41 = OpConstant %10 1 %53 = OpTypePointer Function %29 %60 = OpConstant %10 2 %4 = OpFunction %2 None %3 %5 = OpLabel %63 = OpFunctionCall %2 %6 %64 = OpFunctionCall %2 %8 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %12 = OpVariable %11 Function %14 = OpVariable %11 Function %32 = OpVariable %31 Function OpStore %12 %13 OpStore %14 %13 OpBranch %15 %15 = OpLabel %65 = OpPhi %10 %13 %7 %42 %18 %66 = OpPhi %10 %13 %7 %44 %18 OpLoopMerge %17 %18 None OpBranch %19 %19 = OpLabel %23 = OpSLessThan %22 %65 %21 %25 = OpSLessThan %22 %66 %21 %26 = OpLogicalAnd %22 %23 %25 OpBranchConditional %26 %16 %17 %16 = OpLabel %37 = OpAccessChain %11 %32 %65 %66 %38 = OpLoad %10 %37 %39 = OpAccessChain %11 %32 %65 %66 OpStore %39 %38 OpBranch %18 %18 = OpLabel %42 = OpIAdd %10 %65 %41 OpStore %12 %42 %44 = OpIAdd %10 %66 %41 OpStore %14 %44 OpBranch %15 %17 = OpLabel OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %45 = OpVariable %11 Function %54 = OpVariable %53 Function OpStore %45 %13 OpBranch %46 %46 = OpLabel %67 = OpPhi %10 %13 %9 %62 %49 OpLoopMerge %48 %49 None OpBranch %50 %50 = OpLabel %52 = OpSLessThan %22 %67 %21 OpBranchConditional %52 %47 %48 %47 = OpLabel %57 = OpAccessChain %11 %54 %67 %58 = OpLoad %10 %57 %59 = OpAccessChain %11 %54 %67 OpStore %59 %58 OpBranch %49 %49 = OpLabel %62 = OpIAdd %10 %67 %60 OpStore %45 %62 OpBranch %46 %48 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; { // Function a const Function* f = spvtest::GetFunction(module, 6); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; const Instruction* store[1] = {nullptr}; int stores_found = 0; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 16)) { if (inst.opcode() == spv::Op::OpStore) { store[stores_found] = &inst; ++stores_found; } } // 38 -> 39 DistanceVector distance_vector{loops.size()}; EXPECT_FALSE(analysis.IsSupportedLoop(loops[0])); EXPECT_FALSE(analysis.GetDependence(context->get_def_use_mgr()->GetDef(38), store[0], &distance_vector)); EXPECT_EQ(distance_vector.GetEntries()[0].dependence_information, DistanceEntry::DependenceInformation::UNKNOWN); EXPECT_EQ(distance_vector.GetEntries()[0].direction, DistanceEntry::Directions::ALL); } { // Function b const Function* f = spvtest::GetFunction(module, 8); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; const Instruction* store[1] = {nullptr}; int stores_found = 0; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 47)) { if (inst.opcode() == spv::Op::OpStore) { store[stores_found] = &inst; ++stores_found; } } // 58 -> 59 DistanceVector distance_vector{loops.size()}; EXPECT_FALSE(analysis.IsSupportedLoop(loops[0])); EXPECT_FALSE(analysis.GetDependence(context->get_def_use_mgr()->GetDef(58), store[0], &distance_vector)); EXPECT_EQ(distance_vector.GetEntries()[0].dependence_information, DistanceEntry::DependenceInformation::UNKNOWN); EXPECT_EQ(distance_vector.GetEntries()[0].direction, DistanceEntry::Directions::ALL); } } /* Generated from the following GLSL fragment shader with --eliminate-local-multi-store #version 440 core void a() { for (int i = -10; i < 0; i++) { } } void b() { for (int i = -5; i < 5; i++) { } } void c() { for (int i = 0; i < 10; i++) { } } void d() { for (int i = 5; i < 15; i++) { } } void e() { for (int i = -10; i <= 0; i++) { } } void f() { for (int i = -5; i <= 5; i++) { } } void g() { for (int i = 0; i <= 10; i++) { } } void h() { for (int i = 5; i <= 15; i++) { } } void i() { for (int i = 0; i > -10; i--) { } } void j() { for (int i = 5; i > -5; i--) { } } void k() { for (int i = 10; i > 0; i--) { } } void l() { for (int i = 15; i > 5; i--) { } } void m() { for (int i = 0; i >= -10; i--) { } } void n() { for (int i = 5; i >= -5; i--) { } } void o() { for (int i = 10; i >= 0; i--) { } } void p() { for (int i = 15; i >= 5; i--) { } } void main(){ a(); b(); c(); d(); e(); f(); g(); h(); i(); j(); k(); l(); m(); n(); o(); p(); } */ TEST(DependencyAnalysisHelpers, loop_information) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %6 "a(" OpName %8 "b(" OpName %10 "c(" OpName %12 "d(" OpName %14 "e(" OpName %16 "f(" OpName %18 "g(" OpName %20 "h(" OpName %22 "i(" OpName %24 "j(" OpName %26 "k(" OpName %28 "l(" OpName %30 "m(" OpName %32 "n(" OpName %34 "o(" OpName %36 "p(" OpName %40 "i" OpName %54 "i" OpName %66 "i" OpName %77 "i" OpName %88 "i" OpName %98 "i" OpName %108 "i" OpName %118 "i" OpName %128 "i" OpName %138 "i" OpName %148 "i" OpName %158 "i" OpName %168 "i" OpName %178 "i" OpName %188 "i" OpName %198 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %38 = OpTypeInt 32 1 %39 = OpTypePointer Function %38 %41 = OpConstant %38 -10 %48 = OpConstant %38 0 %49 = OpTypeBool %52 = OpConstant %38 1 %55 = OpConstant %38 -5 %62 = OpConstant %38 5 %73 = OpConstant %38 10 %84 = OpConstant %38 15 %4 = OpFunction %2 None %3 %5 = OpLabel %208 = OpFunctionCall %2 %6 %209 = OpFunctionCall %2 %8 %210 = OpFunctionCall %2 %10 %211 = OpFunctionCall %2 %12 %212 = OpFunctionCall %2 %14 %213 = OpFunctionCall %2 %16 %214 = OpFunctionCall %2 %18 %215 = OpFunctionCall %2 %20 %216 = OpFunctionCall %2 %22 %217 = OpFunctionCall %2 %24 %218 = OpFunctionCall %2 %26 %219 = OpFunctionCall %2 %28 %220 = OpFunctionCall %2 %30 %221 = OpFunctionCall %2 %32 %222 = OpFunctionCall %2 %34 %223 = OpFunctionCall %2 %36 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %40 = OpVariable %39 Function OpStore %40 %41 OpBranch %42 %42 = OpLabel %224 = OpPhi %38 %41 %7 %53 %45 OpLoopMerge %44 %45 None OpBranch %46 %46 = OpLabel %50 = OpSLessThan %49 %224 %48 OpBranchConditional %50 %43 %44 %43 = OpLabel OpBranch %45 %45 = OpLabel %53 = OpIAdd %38 %224 %52 OpStore %40 %53 OpBranch %42 %44 = OpLabel OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %54 = OpVariable %39 Function OpStore %54 %55 OpBranch %56 %56 = OpLabel %225 = OpPhi %38 %55 %9 %65 %59 OpLoopMerge %58 %59 None OpBranch %60 %60 = OpLabel %63 = OpSLessThan %49 %225 %62 OpBranchConditional %63 %57 %58 %57 = OpLabel OpBranch %59 %59 = OpLabel %65 = OpIAdd %38 %225 %52 OpStore %54 %65 OpBranch %56 %58 = OpLabel OpReturn OpFunctionEnd %10 = OpFunction %2 None %3 %11 = OpLabel %66 = OpVariable %39 Function OpStore %66 %48 OpBranch %67 %67 = OpLabel %226 = OpPhi %38 %48 %11 %76 %70 OpLoopMerge %69 %70 None OpBranch %71 %71 = OpLabel %74 = OpSLessThan %49 %226 %73 OpBranchConditional %74 %68 %69 %68 = OpLabel OpBranch %70 %70 = OpLabel %76 = OpIAdd %38 %226 %52 OpStore %66 %76 OpBranch %67 %69 = OpLabel OpReturn OpFunctionEnd %12 = OpFunction %2 None %3 %13 = OpLabel %77 = OpVariable %39 Function OpStore %77 %62 OpBranch %78 %78 = OpLabel %227 = OpPhi %38 %62 %13 %87 %81 OpLoopMerge %80 %81 None OpBranch %82 %82 = OpLabel %85 = OpSLessThan %49 %227 %84 OpBranchConditional %85 %79 %80 %79 = OpLabel OpBranch %81 %81 = OpLabel %87 = OpIAdd %38 %227 %52 OpStore %77 %87 OpBranch %78 %80 = OpLabel OpReturn OpFunctionEnd %14 = OpFunction %2 None %3 %15 = OpLabel %88 = OpVariable %39 Function OpStore %88 %41 OpBranch %89 %89 = OpLabel %228 = OpPhi %38 %41 %15 %97 %92 OpLoopMerge %91 %92 None OpBranch %93 %93 = OpLabel %95 = OpSLessThanEqual %49 %228 %48 OpBranchConditional %95 %90 %91 %90 = OpLabel OpBranch %92 %92 = OpLabel %97 = OpIAdd %38 %228 %52 OpStore %88 %97 OpBranch %89 %91 = OpLabel OpReturn OpFunctionEnd %16 = OpFunction %2 None %3 %17 = OpLabel %98 = OpVariable %39 Function OpStore %98 %55 OpBranch %99 %99 = OpLabel %229 = OpPhi %38 %55 %17 %107 %102 OpLoopMerge %101 %102 None OpBranch %103 %103 = OpLabel %105 = OpSLessThanEqual %49 %229 %62 OpBranchConditional %105 %100 %101 %100 = OpLabel OpBranch %102 %102 = OpLabel %107 = OpIAdd %38 %229 %52 OpStore %98 %107 OpBranch %99 %101 = OpLabel OpReturn OpFunctionEnd %18 = OpFunction %2 None %3 %19 = OpLabel %108 = OpVariable %39 Function OpStore %108 %48 OpBranch %109 %109 = OpLabel %230 = OpPhi %38 %48 %19 %117 %112 OpLoopMerge %111 %112 None OpBranch %113 %113 = OpLabel %115 = OpSLessThanEqual %49 %230 %73 OpBranchConditional %115 %110 %111 %110 = OpLabel OpBranch %112 %112 = OpLabel %117 = OpIAdd %38 %230 %52 OpStore %108 %117 OpBranch %109 %111 = OpLabel OpReturn OpFunctionEnd %20 = OpFunction %2 None %3 %21 = OpLabel %118 = OpVariable %39 Function OpStore %118 %62 OpBranch %119 %119 = OpLabel %231 = OpPhi %38 %62 %21 %127 %122 OpLoopMerge %121 %122 None OpBranch %123 %123 = OpLabel %125 = OpSLessThanEqual %49 %231 %84 OpBranchConditional %125 %120 %121 %120 = OpLabel OpBranch %122 %122 = OpLabel %127 = OpIAdd %38 %231 %52 OpStore %118 %127 OpBranch %119 %121 = OpLabel OpReturn OpFunctionEnd %22 = OpFunction %2 None %3 %23 = OpLabel %128 = OpVariable %39 Function OpStore %128 %48 OpBranch %129 %129 = OpLabel %232 = OpPhi %38 %48 %23 %137 %132 OpLoopMerge %131 %132 None OpBranch %133 %133 = OpLabel %135 = OpSGreaterThan %49 %232 %41 OpBranchConditional %135 %130 %131 %130 = OpLabel OpBranch %132 %132 = OpLabel %137 = OpISub %38 %232 %52 OpStore %128 %137 OpBranch %129 %131 = OpLabel OpReturn OpFunctionEnd %24 = OpFunction %2 None %3 %25 = OpLabel %138 = OpVariable %39 Function OpStore %138 %62 OpBranch %139 %139 = OpLabel %233 = OpPhi %38 %62 %25 %147 %142 OpLoopMerge %141 %142 None OpBranch %143 %143 = OpLabel %145 = OpSGreaterThan %49 %233 %55 OpBranchConditional %145 %140 %141 %140 = OpLabel OpBranch %142 %142 = OpLabel %147 = OpISub %38 %233 %52 OpStore %138 %147 OpBranch %139 %141 = OpLabel OpReturn OpFunctionEnd %26 = OpFunction %2 None %3 %27 = OpLabel %148 = OpVariable %39 Function OpStore %148 %73 OpBranch %149 %149 = OpLabel %234 = OpPhi %38 %73 %27 %157 %152 OpLoopMerge %151 %152 None OpBranch %153 %153 = OpLabel %155 = OpSGreaterThan %49 %234 %48 OpBranchConditional %155 %150 %151 %150 = OpLabel OpBranch %152 %152 = OpLabel %157 = OpISub %38 %234 %52 OpStore %148 %157 OpBranch %149 %151 = OpLabel OpReturn OpFunctionEnd %28 = OpFunction %2 None %3 %29 = OpLabel %158 = OpVariable %39 Function OpStore %158 %84 OpBranch %159 %159 = OpLabel %235 = OpPhi %38 %84 %29 %167 %162 OpLoopMerge %161 %162 None OpBranch %163 %163 = OpLabel %165 = OpSGreaterThan %49 %235 %62 OpBranchConditional %165 %160 %161 %160 = OpLabel OpBranch %162 %162 = OpLabel %167 = OpISub %38 %235 %52 OpStore %158 %167 OpBranch %159 %161 = OpLabel OpReturn OpFunctionEnd %30 = OpFunction %2 None %3 %31 = OpLabel %168 = OpVariable %39 Function OpStore %168 %48 OpBranch %169 %169 = OpLabel %236 = OpPhi %38 %48 %31 %177 %172 OpLoopMerge %171 %172 None OpBranch %173 %173 = OpLabel %175 = OpSGreaterThanEqual %49 %236 %41 OpBranchConditional %175 %170 %171 %170 = OpLabel OpBranch %172 %172 = OpLabel %177 = OpISub %38 %236 %52 OpStore %168 %177 OpBranch %169 %171 = OpLabel OpReturn OpFunctionEnd %32 = OpFunction %2 None %3 %33 = OpLabel %178 = OpVariable %39 Function OpStore %178 %62 OpBranch %179 %179 = OpLabel %237 = OpPhi %38 %62 %33 %187 %182 OpLoopMerge %181 %182 None OpBranch %183 %183 = OpLabel %185 = OpSGreaterThanEqual %49 %237 %55 OpBranchConditional %185 %180 %181 %180 = OpLabel OpBranch %182 %182 = OpLabel %187 = OpISub %38 %237 %52 OpStore %178 %187 OpBranch %179 %181 = OpLabel OpReturn OpFunctionEnd %34 = OpFunction %2 None %3 %35 = OpLabel %188 = OpVariable %39 Function OpStore %188 %73 OpBranch %189 %189 = OpLabel %238 = OpPhi %38 %73 %35 %197 %192 OpLoopMerge %191 %192 None OpBranch %193 %193 = OpLabel %195 = OpSGreaterThanEqual %49 %238 %48 OpBranchConditional %195 %190 %191 %190 = OpLabel OpBranch %192 %192 = OpLabel %197 = OpISub %38 %238 %52 OpStore %188 %197 OpBranch %189 %191 = OpLabel OpReturn OpFunctionEnd %36 = OpFunction %2 None %3 %37 = OpLabel %198 = OpVariable %39 Function OpStore %198 %84 OpBranch %199 %199 = OpLabel %239 = OpPhi %38 %84 %37 %207 %202 OpLoopMerge %201 %202 None OpBranch %203 %203 = OpLabel %205 = OpSGreaterThanEqual %49 %239 %62 OpBranchConditional %205 %200 %201 %200 = OpLabel OpBranch %202 %202 = OpLabel %207 = OpISub %38 %239 %52 OpStore %198 %207 OpBranch %199 %201 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; { // Function a const Function* f = spvtest::GetFunction(module, 6); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; EXPECT_EQ( analysis.GetLowerBound(loop)->AsSEConstantNode()->FoldToSingleValue(), -10); EXPECT_EQ( analysis.GetUpperBound(loop)->AsSEConstantNode()->FoldToSingleValue(), -1); EXPECT_EQ( analysis.GetTripCount(loop)->AsSEConstantNode()->FoldToSingleValue(), 10); EXPECT_EQ(analysis.GetFirstTripInductionNode(loop), analysis.GetScalarEvolution()->CreateConstant(-10)); EXPECT_EQ(analysis.GetFinalTripInductionNode( loop, analysis.GetScalarEvolution()->CreateConstant(1)), analysis.GetScalarEvolution()->CreateConstant(-1)); } { // Function b const Function* f = spvtest::GetFunction(module, 8); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; EXPECT_EQ( analysis.GetLowerBound(loop)->AsSEConstantNode()->FoldToSingleValue(), -5); EXPECT_EQ( analysis.GetUpperBound(loop)->AsSEConstantNode()->FoldToSingleValue(), 4); EXPECT_EQ( analysis.GetTripCount(loop)->AsSEConstantNode()->FoldToSingleValue(), 10); EXPECT_EQ(analysis.GetFirstTripInductionNode(loop), analysis.GetScalarEvolution()->CreateConstant(-5)); EXPECT_EQ(analysis.GetFinalTripInductionNode( loop, analysis.GetScalarEvolution()->CreateConstant(1)), analysis.GetScalarEvolution()->CreateConstant(4)); } { // Function c const Function* f = spvtest::GetFunction(module, 10); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; EXPECT_EQ( analysis.GetLowerBound(loop)->AsSEConstantNode()->FoldToSingleValue(), 0); EXPECT_EQ( analysis.GetUpperBound(loop)->AsSEConstantNode()->FoldToSingleValue(), 9); EXPECT_EQ( analysis.GetTripCount(loop)->AsSEConstantNode()->FoldToSingleValue(), 10); EXPECT_EQ(analysis.GetFirstTripInductionNode(loop), analysis.GetScalarEvolution()->CreateConstant(0)); EXPECT_EQ(analysis.GetFinalTripInductionNode( loop, analysis.GetScalarEvolution()->CreateConstant(1)), analysis.GetScalarEvolution()->CreateConstant(9)); } { // Function d const Function* f = spvtest::GetFunction(module, 12); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; EXPECT_EQ( analysis.GetLowerBound(loop)->AsSEConstantNode()->FoldToSingleValue(), 5); EXPECT_EQ( analysis.GetUpperBound(loop)->AsSEConstantNode()->FoldToSingleValue(), 14); EXPECT_EQ( analysis.GetTripCount(loop)->AsSEConstantNode()->FoldToSingleValue(), 10); EXPECT_EQ(analysis.GetFirstTripInductionNode(loop), analysis.GetScalarEvolution()->CreateConstant(5)); EXPECT_EQ(analysis.GetFinalTripInductionNode( loop, analysis.GetScalarEvolution()->CreateConstant(1)), analysis.GetScalarEvolution()->CreateConstant(14)); } { // Function e const Function* f = spvtest::GetFunction(module, 14); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; EXPECT_EQ( analysis.GetLowerBound(loop)->AsSEConstantNode()->FoldToSingleValue(), -10); EXPECT_EQ( analysis.GetUpperBound(loop)->AsSEConstantNode()->FoldToSingleValue(), 0); EXPECT_EQ( analysis.GetTripCount(loop)->AsSEConstantNode()->FoldToSingleValue(), 11); EXPECT_EQ(analysis.GetFirstTripInductionNode(loop), analysis.GetScalarEvolution()->CreateConstant(-10)); EXPECT_EQ(analysis.GetFinalTripInductionNode( loop, analysis.GetScalarEvolution()->CreateConstant(1)), analysis.GetScalarEvolution()->CreateConstant(0)); } { // Function f const Function* f = spvtest::GetFunction(module, 16); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; EXPECT_EQ( analysis.GetLowerBound(loop)->AsSEConstantNode()->FoldToSingleValue(), -5); EXPECT_EQ( analysis.GetUpperBound(loop)->AsSEConstantNode()->FoldToSingleValue(), 5); EXPECT_EQ( analysis.GetTripCount(loop)->AsSEConstantNode()->FoldToSingleValue(), 11); EXPECT_EQ(analysis.GetFirstTripInductionNode(loop), analysis.GetScalarEvolution()->CreateConstant(-5)); EXPECT_EQ(analysis.GetFinalTripInductionNode( loop, analysis.GetScalarEvolution()->CreateConstant(1)), analysis.GetScalarEvolution()->CreateConstant(5)); } { // Function g const Function* f = spvtest::GetFunction(module, 18); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; EXPECT_EQ( analysis.GetLowerBound(loop)->AsSEConstantNode()->FoldToSingleValue(), 0); EXPECT_EQ( analysis.GetUpperBound(loop)->AsSEConstantNode()->FoldToSingleValue(), 10); EXPECT_EQ( analysis.GetTripCount(loop)->AsSEConstantNode()->FoldToSingleValue(), 11); EXPECT_EQ(analysis.GetFirstTripInductionNode(loop), analysis.GetScalarEvolution()->CreateConstant(0)); EXPECT_EQ(analysis.GetFinalTripInductionNode( loop, analysis.GetScalarEvolution()->CreateConstant(1)), analysis.GetScalarEvolution()->CreateConstant(10)); } { // Function h const Function* f = spvtest::GetFunction(module, 20); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; EXPECT_EQ( analysis.GetLowerBound(loop)->AsSEConstantNode()->FoldToSingleValue(), 5); EXPECT_EQ( analysis.GetUpperBound(loop)->AsSEConstantNode()->FoldToSingleValue(), 15); EXPECT_EQ( analysis.GetTripCount(loop)->AsSEConstantNode()->FoldToSingleValue(), 11); EXPECT_EQ(analysis.GetFirstTripInductionNode(loop), analysis.GetScalarEvolution()->CreateConstant(5)); EXPECT_EQ(analysis.GetFinalTripInductionNode( loop, analysis.GetScalarEvolution()->CreateConstant(1)), analysis.GetScalarEvolution()->CreateConstant(15)); } { // Function i const Function* f = spvtest::GetFunction(module, 22); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; EXPECT_EQ( analysis.GetLowerBound(loop)->AsSEConstantNode()->FoldToSingleValue(), 0); EXPECT_EQ( analysis.GetUpperBound(loop)->AsSEConstantNode()->FoldToSingleValue(), -9); EXPECT_EQ( analysis.GetTripCount(loop)->AsSEConstantNode()->FoldToSingleValue(), 10); EXPECT_EQ(analysis.GetFirstTripInductionNode(loop), analysis.GetScalarEvolution()->CreateConstant(0)); EXPECT_EQ(analysis.GetFinalTripInductionNode( loop, analysis.GetScalarEvolution()->CreateConstant(-1)), analysis.GetScalarEvolution()->CreateConstant(-9)); } { // Function j const Function* f = spvtest::GetFunction(module, 24); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; EXPECT_EQ( analysis.GetLowerBound(loop)->AsSEConstantNode()->FoldToSingleValue(), 5); EXPECT_EQ( analysis.GetUpperBound(loop)->AsSEConstantNode()->FoldToSingleValue(), -4); EXPECT_EQ( analysis.GetTripCount(loop)->AsSEConstantNode()->FoldToSingleValue(), 10); EXPECT_EQ(analysis.GetFirstTripInductionNode(loop), analysis.GetScalarEvolution()->CreateConstant(5)); EXPECT_EQ(analysis.GetFinalTripInductionNode( loop, analysis.GetScalarEvolution()->CreateConstant(-1)), analysis.GetScalarEvolution()->CreateConstant(-4)); } { // Function k const Function* f = spvtest::GetFunction(module, 26); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; EXPECT_EQ( analysis.GetLowerBound(loop)->AsSEConstantNode()->FoldToSingleValue(), 10); EXPECT_EQ( analysis.GetUpperBound(loop)->AsSEConstantNode()->FoldToSingleValue(), 1); EXPECT_EQ( analysis.GetTripCount(loop)->AsSEConstantNode()->FoldToSingleValue(), 10); EXPECT_EQ(analysis.GetFirstTripInductionNode(loop), analysis.GetScalarEvolution()->CreateConstant(10)); EXPECT_EQ(analysis.GetFinalTripInductionNode( loop, analysis.GetScalarEvolution()->CreateConstant(-1)), analysis.GetScalarEvolution()->CreateConstant(1)); } { // Function l const Function* f = spvtest::GetFunction(module, 28); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; EXPECT_EQ( analysis.GetLowerBound(loop)->AsSEConstantNode()->FoldToSingleValue(), 15); EXPECT_EQ( analysis.GetUpperBound(loop)->AsSEConstantNode()->FoldToSingleValue(), 6); EXPECT_EQ( analysis.GetTripCount(loop)->AsSEConstantNode()->FoldToSingleValue(), 10); EXPECT_EQ(analysis.GetFirstTripInductionNode(loop), analysis.GetScalarEvolution()->CreateConstant(15)); EXPECT_EQ(analysis.GetFinalTripInductionNode( loop, analysis.GetScalarEvolution()->CreateConstant(-1)), analysis.GetScalarEvolution()->CreateConstant(6)); } { // Function m const Function* f = spvtest::GetFunction(module, 30); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; EXPECT_EQ( analysis.GetLowerBound(loop)->AsSEConstantNode()->FoldToSingleValue(), 0); EXPECT_EQ( analysis.GetUpperBound(loop)->AsSEConstantNode()->FoldToSingleValue(), -10); EXPECT_EQ( analysis.GetTripCount(loop)->AsSEConstantNode()->FoldToSingleValue(), 11); EXPECT_EQ(analysis.GetFirstTripInductionNode(loop), analysis.GetScalarEvolution()->CreateConstant(0)); EXPECT_EQ(analysis.GetFinalTripInductionNode( loop, analysis.GetScalarEvolution()->CreateConstant(-1)), analysis.GetScalarEvolution()->CreateConstant(-10)); } { // Function n const Function* f = spvtest::GetFunction(module, 32); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; EXPECT_EQ( analysis.GetLowerBound(loop)->AsSEConstantNode()->FoldToSingleValue(), 5); EXPECT_EQ( analysis.GetUpperBound(loop)->AsSEConstantNode()->FoldToSingleValue(), -5); EXPECT_EQ( analysis.GetTripCount(loop)->AsSEConstantNode()->FoldToSingleValue(), 11); EXPECT_EQ(analysis.GetFirstTripInductionNode(loop), analysis.GetScalarEvolution()->CreateConstant(5)); EXPECT_EQ(analysis.GetFinalTripInductionNode( loop, analysis.GetScalarEvolution()->CreateConstant(-1)), analysis.GetScalarEvolution()->CreateConstant(-5)); } { // Function o const Function* f = spvtest::GetFunction(module, 34); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; EXPECT_EQ( analysis.GetLowerBound(loop)->AsSEConstantNode()->FoldToSingleValue(), 10); EXPECT_EQ( analysis.GetUpperBound(loop)->AsSEConstantNode()->FoldToSingleValue(), 0); EXPECT_EQ( analysis.GetTripCount(loop)->AsSEConstantNode()->FoldToSingleValue(), 11); EXPECT_EQ(analysis.GetFirstTripInductionNode(loop), analysis.GetScalarEvolution()->CreateConstant(10)); EXPECT_EQ(analysis.GetFinalTripInductionNode( loop, analysis.GetScalarEvolution()->CreateConstant(-1)), analysis.GetScalarEvolution()->CreateConstant(0)); } { // Function p const Function* f = spvtest::GetFunction(module, 36); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; EXPECT_EQ( analysis.GetLowerBound(loop)->AsSEConstantNode()->FoldToSingleValue(), 15); EXPECT_EQ( analysis.GetUpperBound(loop)->AsSEConstantNode()->FoldToSingleValue(), 5); EXPECT_EQ( analysis.GetTripCount(loop)->AsSEConstantNode()->FoldToSingleValue(), 11); EXPECT_EQ(analysis.GetFirstTripInductionNode(loop), analysis.GetScalarEvolution()->CreateConstant(15)); EXPECT_EQ(analysis.GetFinalTripInductionNode( loop, analysis.GetScalarEvolution()->CreateConstant(-1)), analysis.GetScalarEvolution()->CreateConstant(5)); } } /* Generated from the following GLSL fragment shader with --eliminate-local-multi-store #version 440 core void main(){ for (int i = 0; i < 10; i++) { } } */ TEST(DependencyAnalysisHelpers, bounds_checks) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %20 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %22 = OpPhi %6 %9 %5 %21 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %22 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel OpBranch %13 %13 = OpLabel %21 = OpIAdd %6 %22 %20 OpStore %8 %21 OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; // We need a shader that includes a loop for this test so we can build a // LoopDependenceAnalaysis const Function* f = spvtest::GetFunction(module, 4); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; EXPECT_TRUE(analysis.IsWithinBounds(0, 0, 0)); EXPECT_TRUE(analysis.IsWithinBounds(0, -1, 0)); EXPECT_TRUE(analysis.IsWithinBounds(0, 0, 1)); EXPECT_TRUE(analysis.IsWithinBounds(0, -1, 1)); EXPECT_TRUE(analysis.IsWithinBounds(-2, -2, -2)); EXPECT_TRUE(analysis.IsWithinBounds(-2, -3, 0)); EXPECT_TRUE(analysis.IsWithinBounds(-2, 0, -3)); EXPECT_TRUE(analysis.IsWithinBounds(2, 2, 2)); EXPECT_TRUE(analysis.IsWithinBounds(2, 3, 0)); EXPECT_FALSE(analysis.IsWithinBounds(2, 3, 3)); EXPECT_FALSE(analysis.IsWithinBounds(0, 1, 5)); EXPECT_FALSE(analysis.IsWithinBounds(0, -1, -4)); EXPECT_FALSE(analysis.IsWithinBounds(-2, -4, -3)); } /* Generated from the following GLSL fragment shader with --eliminate-local-multi-store #version 440 core layout(location = 0) in vec4 in_vec; // Loop iterates from constant to symbolic void a() { int N = int(in_vec.x); int arr[10]; for (int i = 0; i < N; i++) { // Bounds are N - 0 - 1 arr[i] = arr[i+N]; // |distance| = N arr[i+N] = arr[i]; // |distance| = N } } void b() { int N = int(in_vec.x); int arr[10]; for (int i = 0; i <= N; i++) { // Bounds are N - 0 arr[i] = arr[i+N]; // |distance| = N arr[i+N] = arr[i]; // |distance| = N } } void c() { int N = int(in_vec.x); int arr[10]; for (int i = 9; i > N; i--) { // Bounds are 9 - N - 1 arr[i] = arr[i+N]; // |distance| = N arr[i+N] = arr[i]; // |distance| = N } } void d() { int N = int(in_vec.x); int arr[10]; for (int i = 9; i >= N; i--) { // Bounds are 9 - N arr[i] = arr[i+N]; // |distance| = N arr[i+N] = arr[i]; // |distance| = N } } void main(){ a(); b(); c(); d(); } */ TEST(DependencyAnalysisHelpers, const_to_symbolic) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %20 OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %6 "a(" OpName %8 "b(" OpName %10 "c(" OpName %12 "d(" OpName %16 "N" OpName %20 "in_vec" OpName %27 "i" OpName %41 "arr" OpName %59 "N" OpName %63 "i" OpName %72 "arr" OpName %89 "N" OpName %93 "i" OpName %103 "arr" OpName %120 "N" OpName %124 "i" OpName %133 "arr" OpDecorate %20 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %14 = OpTypeInt 32 1 %15 = OpTypePointer Function %14 %17 = OpTypeFloat 32 %18 = OpTypeVector %17 4 %19 = OpTypePointer Input %18 %20 = OpVariable %19 Input %21 = OpTypeInt 32 0 %22 = OpConstant %21 0 %23 = OpTypePointer Input %17 %28 = OpConstant %14 0 %36 = OpTypeBool %38 = OpConstant %21 10 %39 = OpTypeArray %14 %38 %40 = OpTypePointer Function %39 %57 = OpConstant %14 1 %94 = OpConstant %14 9 %4 = OpFunction %2 None %3 %5 = OpLabel %150 = OpFunctionCall %2 %6 %151 = OpFunctionCall %2 %8 %152 = OpFunctionCall %2 %10 %153 = OpFunctionCall %2 %12 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %16 = OpVariable %15 Function %27 = OpVariable %15 Function %41 = OpVariable %40 Function %24 = OpAccessChain %23 %20 %22 %25 = OpLoad %17 %24 %26 = OpConvertFToS %14 %25 OpStore %16 %26 OpStore %27 %28 OpBranch %29 %29 = OpLabel %154 = OpPhi %14 %28 %7 %58 %32 OpLoopMerge %31 %32 None OpBranch %33 %33 = OpLabel %37 = OpSLessThan %36 %154 %26 OpBranchConditional %37 %30 %31 %30 = OpLabel %45 = OpIAdd %14 %154 %26 %46 = OpAccessChain %15 %41 %45 %47 = OpLoad %14 %46 %48 = OpAccessChain %15 %41 %154 OpStore %48 %47 %51 = OpIAdd %14 %154 %26 %53 = OpAccessChain %15 %41 %154 %54 = OpLoad %14 %53 %55 = OpAccessChain %15 %41 %51 OpStore %55 %54 OpBranch %32 %32 = OpLabel %58 = OpIAdd %14 %154 %57 OpStore %27 %58 OpBranch %29 %31 = OpLabel OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %59 = OpVariable %15 Function %63 = OpVariable %15 Function %72 = OpVariable %40 Function %60 = OpAccessChain %23 %20 %22 %61 = OpLoad %17 %60 %62 = OpConvertFToS %14 %61 OpStore %59 %62 OpStore %63 %28 OpBranch %64 %64 = OpLabel %155 = OpPhi %14 %28 %9 %88 %67 OpLoopMerge %66 %67 None OpBranch %68 %68 = OpLabel %71 = OpSLessThanEqual %36 %155 %62 OpBranchConditional %71 %65 %66 %65 = OpLabel %76 = OpIAdd %14 %155 %62 %77 = OpAccessChain %15 %72 %76 %78 = OpLoad %14 %77 %79 = OpAccessChain %15 %72 %155 OpStore %79 %78 %82 = OpIAdd %14 %155 %62 %84 = OpAccessChain %15 %72 %155 %85 = OpLoad %14 %84 %86 = OpAccessChain %15 %72 %82 OpStore %86 %85 OpBranch %67 %67 = OpLabel %88 = OpIAdd %14 %155 %57 OpStore %63 %88 OpBranch %64 %66 = OpLabel OpReturn OpFunctionEnd %10 = OpFunction %2 None %3 %11 = OpLabel %89 = OpVariable %15 Function %93 = OpVariable %15 Function %103 = OpVariable %40 Function %90 = OpAccessChain %23 %20 %22 %91 = OpLoad %17 %90 %92 = OpConvertFToS %14 %91 OpStore %89 %92 OpStore %93 %94 OpBranch %95 %95 = OpLabel %156 = OpPhi %14 %94 %11 %119 %98 OpLoopMerge %97 %98 None OpBranch %99 %99 = OpLabel %102 = OpSGreaterThan %36 %156 %92 OpBranchConditional %102 %96 %97 %96 = OpLabel %107 = OpIAdd %14 %156 %92 %108 = OpAccessChain %15 %103 %107 %109 = OpLoad %14 %108 %110 = OpAccessChain %15 %103 %156 OpStore %110 %109 %113 = OpIAdd %14 %156 %92 %115 = OpAccessChain %15 %103 %156 %116 = OpLoad %14 %115 %117 = OpAccessChain %15 %103 %113 OpStore %117 %116 OpBranch %98 %98 = OpLabel %119 = OpISub %14 %156 %57 OpStore %93 %119 OpBranch %95 %97 = OpLabel OpReturn OpFunctionEnd %12 = OpFunction %2 None %3 %13 = OpLabel %120 = OpVariable %15 Function %124 = OpVariable %15 Function %133 = OpVariable %40 Function %121 = OpAccessChain %23 %20 %22 %122 = OpLoad %17 %121 %123 = OpConvertFToS %14 %122 OpStore %120 %123 OpStore %124 %94 OpBranch %125 %125 = OpLabel %157 = OpPhi %14 %94 %13 %149 %128 OpLoopMerge %127 %128 None OpBranch %129 %129 = OpLabel %132 = OpSGreaterThanEqual %36 %157 %123 OpBranchConditional %132 %126 %127 %126 = OpLabel %137 = OpIAdd %14 %157 %123 %138 = OpAccessChain %15 %133 %137 %139 = OpLoad %14 %138 %140 = OpAccessChain %15 %133 %157 OpStore %140 %139 %143 = OpIAdd %14 %157 %123 %145 = OpAccessChain %15 %133 %157 %146 = OpLoad %14 %145 %147 = OpAccessChain %15 %133 %143 OpStore %147 %146 OpBranch %128 %128 = OpLabel %149 = OpISub %14 %157 %57 OpStore %124 %149 OpBranch %125 %127 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; { // Function a const Function* f = spvtest::GetFunction(module, 6); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; const Instruction* stores[2]; int stores_found = 0; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 30)) { if (inst.opcode() == spv::Op::OpStore) { stores[stores_found] = &inst; ++stores_found; } } for (int i = 0; i < 2; ++i) { EXPECT_TRUE(stores[i]); } // 47 -> 48 { // Analyse and simplify the instruction behind the access chain of this // load. Instruction* load_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(context->get_def_use_mgr() ->GetDef(47) ->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* load = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(load_var)); // Analyse and simplify the instruction behind the access chain of this // store. Instruction* store_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(stores[0]->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* store = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(store_var)); SENode* delta = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->CreateSubtraction(load, store)); // Independent and supported. EXPECT_TRUE(analysis.IsProvablyOutsideOfLoopBounds( loop, delta, store->AsSERecurrentNode()->GetCoefficient())); } // 54 -> 55 { // Analyse and simplify the instruction behind the access chain of this // load. Instruction* load_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(context->get_def_use_mgr() ->GetDef(54) ->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* load = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(load_var)); // Analyse and simplify the instruction behind the access chain of this // store. Instruction* store_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(stores[1]->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* store = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(store_var)); SENode* delta = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->CreateSubtraction(load, store)); // Independent but not supported. EXPECT_FALSE(analysis.IsProvablyOutsideOfLoopBounds( loop, delta, store->AsSERecurrentNode()->GetCoefficient())); } } { // Function b const Function* f = spvtest::GetFunction(module, 8); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; const Instruction* stores[2]; int stores_found = 0; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 65)) { if (inst.opcode() == spv::Op::OpStore) { stores[stores_found] = &inst; ++stores_found; } } for (int i = 0; i < 2; ++i) { EXPECT_TRUE(stores[i]); } // 78 -> 79 { // Analyse and simplify the instruction behind the access chain of this // load. Instruction* load_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(context->get_def_use_mgr() ->GetDef(78) ->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* load = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(load_var)); // Analyse and simplify the instruction behind the access chain of this // store. Instruction* store_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(stores[0]->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* store = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(store_var)); SENode* delta = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->CreateSubtraction(load, store)); // Dependent. EXPECT_FALSE(analysis.IsProvablyOutsideOfLoopBounds( loop, delta, store->AsSERecurrentNode()->GetCoefficient())); } // 85 -> 86 { // Analyse and simplify the instruction behind the access chain of this // load. Instruction* load_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(context->get_def_use_mgr() ->GetDef(85) ->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* load = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(load_var)); // Analyse and simplify the instruction behind the access chain of this // store. Instruction* store_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(stores[1]->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* store = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(store_var)); SENode* delta = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->CreateSubtraction(load, store)); // Dependent. EXPECT_FALSE(analysis.IsProvablyOutsideOfLoopBounds( loop, delta, store->AsSERecurrentNode()->GetCoefficient())); } } { // Function c const Function* f = spvtest::GetFunction(module, 10); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; const Instruction* stores[2]; int stores_found = 0; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 96)) { if (inst.opcode() == spv::Op::OpStore) { stores[stores_found] = &inst; ++stores_found; } } for (int i = 0; i < 2; ++i) { EXPECT_TRUE(stores[i]); } // 109 -> 110 { // Analyse and simplify the instruction behind the access chain of this // load. Instruction* load_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(context->get_def_use_mgr() ->GetDef(109) ->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* load = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(load_var)); // Analyse and simplify the instruction behind the access chain of this // store. Instruction* store_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(stores[0]->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* store = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(store_var)); SENode* delta = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->CreateSubtraction(load, store)); // Independent but not supported. EXPECT_FALSE(analysis.IsProvablyOutsideOfLoopBounds( loop, delta, store->AsSERecurrentNode()->GetCoefficient())); } // 116 -> 117 { // Analyse and simplify the instruction behind the access chain of this // load. Instruction* load_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(context->get_def_use_mgr() ->GetDef(116) ->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* load = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(load_var)); // Analyse and simplify the instruction behind the access chain of this // store. Instruction* store_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(stores[1]->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* store = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(store_var)); SENode* delta = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->CreateSubtraction(load, store)); // Independent but not supported. EXPECT_FALSE(analysis.IsProvablyOutsideOfLoopBounds( loop, delta, store->AsSERecurrentNode()->GetCoefficient())); } } { // Function d const Function* f = spvtest::GetFunction(module, 12); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; const Instruction* stores[2]; int stores_found = 0; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 126)) { if (inst.opcode() == spv::Op::OpStore) { stores[stores_found] = &inst; ++stores_found; } } for (int i = 0; i < 2; ++i) { EXPECT_TRUE(stores[i]); } // 139 -> 140 { // Analyse and simplify the instruction behind the access chain of this // load. Instruction* load_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(context->get_def_use_mgr() ->GetDef(139) ->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* load = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(load_var)); // Analyse and simplify the instruction behind the access chain of this // store. Instruction* store_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(stores[0]->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* store = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(store_var)); SENode* delta = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->CreateSubtraction(load, store)); // Dependent. EXPECT_FALSE(analysis.IsProvablyOutsideOfLoopBounds( loop, delta, store->AsSERecurrentNode()->GetCoefficient())); } // 146 -> 147 { // Analyse and simplify the instruction behind the access chain of this // load. Instruction* load_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(context->get_def_use_mgr() ->GetDef(146) ->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* load = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(load_var)); // Analyse and simplify the instruction behind the access chain of this // store. Instruction* store_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(stores[1]->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* store = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(store_var)); SENode* delta = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->CreateSubtraction(load, store)); // Dependent. EXPECT_FALSE(analysis.IsProvablyOutsideOfLoopBounds( loop, delta, store->AsSERecurrentNode()->GetCoefficient())); } } } /* Generated from the following GLSL fragment shader with --eliminate-local-multi-store #version 440 core layout(location = 0) in vec4 in_vec; // Loop iterates from symbolic to constant void a() { int N = int(in_vec.x); int arr[10]; for (int i = N; i < 9; i++) { // Bounds are 9 - N - 1 arr[i] = arr[i+N]; // |distance| = N arr[i+N] = arr[i]; // |distance| = N } } void b() { int N = int(in_vec.x); int arr[10]; for (int i = N; i <= 9; i++) { // Bounds are 9 - N arr[i] = arr[i+N]; // |distance| = N arr[i+N] = arr[i]; // |distance| = N } } void c() { int N = int(in_vec.x); int arr[10]; for (int i = N; i > 0; i--) { // Bounds are N - 0 - 1 arr[i] = arr[i+N]; // |distance| = N arr[i+N] = arr[i]; // |distance| = N } } void d() { int N = int(in_vec.x); int arr[10]; for (int i = N; i >= 0; i--) { // Bounds are N - 0 arr[i] = arr[i+N]; // |distance| = N arr[i+N] = arr[i]; // |distance| = N } } void main(){ a(); b(); c(); d(); } */ TEST(DependencyAnalysisHelpers, symbolic_to_const) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %20 OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %6 "a(" OpName %8 "b(" OpName %10 "c(" OpName %12 "d(" OpName %16 "N" OpName %20 "in_vec" OpName %27 "i" OpName %41 "arr" OpName %59 "N" OpName %63 "i" OpName %72 "arr" OpName %89 "N" OpName %93 "i" OpName %103 "arr" OpName %120 "N" OpName %124 "i" OpName %133 "arr" OpDecorate %20 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %14 = OpTypeInt 32 1 %15 = OpTypePointer Function %14 %17 = OpTypeFloat 32 %18 = OpTypeVector %17 4 %19 = OpTypePointer Input %18 %20 = OpVariable %19 Input %21 = OpTypeInt 32 0 %22 = OpConstant %21 0 %23 = OpTypePointer Input %17 %35 = OpConstant %14 9 %36 = OpTypeBool %38 = OpConstant %21 10 %39 = OpTypeArray %14 %38 %40 = OpTypePointer Function %39 %57 = OpConstant %14 1 %101 = OpConstant %14 0 %4 = OpFunction %2 None %3 %5 = OpLabel %150 = OpFunctionCall %2 %6 %151 = OpFunctionCall %2 %8 %152 = OpFunctionCall %2 %10 %153 = OpFunctionCall %2 %12 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %16 = OpVariable %15 Function %27 = OpVariable %15 Function %41 = OpVariable %40 Function %24 = OpAccessChain %23 %20 %22 %25 = OpLoad %17 %24 %26 = OpConvertFToS %14 %25 OpStore %16 %26 OpStore %27 %26 OpBranch %29 %29 = OpLabel %154 = OpPhi %14 %26 %7 %58 %32 OpLoopMerge %31 %32 None OpBranch %33 %33 = OpLabel %37 = OpSLessThan %36 %154 %35 OpBranchConditional %37 %30 %31 %30 = OpLabel %45 = OpIAdd %14 %154 %26 %46 = OpAccessChain %15 %41 %45 %47 = OpLoad %14 %46 %48 = OpAccessChain %15 %41 %154 OpStore %48 %47 %51 = OpIAdd %14 %154 %26 %53 = OpAccessChain %15 %41 %154 %54 = OpLoad %14 %53 %55 = OpAccessChain %15 %41 %51 OpStore %55 %54 OpBranch %32 %32 = OpLabel %58 = OpIAdd %14 %154 %57 OpStore %27 %58 OpBranch %29 %31 = OpLabel OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %59 = OpVariable %15 Function %63 = OpVariable %15 Function %72 = OpVariable %40 Function %60 = OpAccessChain %23 %20 %22 %61 = OpLoad %17 %60 %62 = OpConvertFToS %14 %61 OpStore %59 %62 OpStore %63 %62 OpBranch %65 %65 = OpLabel %155 = OpPhi %14 %62 %9 %88 %68 OpLoopMerge %67 %68 None OpBranch %69 %69 = OpLabel %71 = OpSLessThanEqual %36 %155 %35 OpBranchConditional %71 %66 %67 %66 = OpLabel %76 = OpIAdd %14 %155 %62 %77 = OpAccessChain %15 %72 %76 %78 = OpLoad %14 %77 %79 = OpAccessChain %15 %72 %155 OpStore %79 %78 %82 = OpIAdd %14 %155 %62 %84 = OpAccessChain %15 %72 %155 %85 = OpLoad %14 %84 %86 = OpAccessChain %15 %72 %82 OpStore %86 %85 OpBranch %68 %68 = OpLabel %88 = OpIAdd %14 %155 %57 OpStore %63 %88 OpBranch %65 %67 = OpLabel OpReturn OpFunctionEnd %10 = OpFunction %2 None %3 %11 = OpLabel %89 = OpVariable %15 Function %93 = OpVariable %15 Function %103 = OpVariable %40 Function %90 = OpAccessChain %23 %20 %22 %91 = OpLoad %17 %90 %92 = OpConvertFToS %14 %91 OpStore %89 %92 OpStore %93 %92 OpBranch %95 %95 = OpLabel %156 = OpPhi %14 %92 %11 %119 %98 OpLoopMerge %97 %98 None OpBranch %99 %99 = OpLabel %102 = OpSGreaterThan %36 %156 %101 OpBranchConditional %102 %96 %97 %96 = OpLabel %107 = OpIAdd %14 %156 %92 %108 = OpAccessChain %15 %103 %107 %109 = OpLoad %14 %108 %110 = OpAccessChain %15 %103 %156 OpStore %110 %109 %113 = OpIAdd %14 %156 %92 %115 = OpAccessChain %15 %103 %156 %116 = OpLoad %14 %115 %117 = OpAccessChain %15 %103 %113 OpStore %117 %116 OpBranch %98 %98 = OpLabel %119 = OpISub %14 %156 %57 OpStore %93 %119 OpBranch %95 %97 = OpLabel OpReturn OpFunctionEnd %12 = OpFunction %2 None %3 %13 = OpLabel %120 = OpVariable %15 Function %124 = OpVariable %15 Function %133 = OpVariable %40 Function %121 = OpAccessChain %23 %20 %22 %122 = OpLoad %17 %121 %123 = OpConvertFToS %14 %122 OpStore %120 %123 OpStore %124 %123 OpBranch %126 %126 = OpLabel %157 = OpPhi %14 %123 %13 %149 %129 OpLoopMerge %128 %129 None OpBranch %130 %130 = OpLabel %132 = OpSGreaterThanEqual %36 %157 %101 OpBranchConditional %132 %127 %128 %127 = OpLabel %137 = OpIAdd %14 %157 %123 %138 = OpAccessChain %15 %133 %137 %139 = OpLoad %14 %138 %140 = OpAccessChain %15 %133 %157 OpStore %140 %139 %143 = OpIAdd %14 %157 %123 %145 = OpAccessChain %15 %133 %157 %146 = OpLoad %14 %145 %147 = OpAccessChain %15 %133 %143 OpStore %147 %146 OpBranch %129 %129 = OpLabel %149 = OpISub %14 %157 %57 OpStore %124 %149 OpBranch %126 %128 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; { // Function a const Function* f = spvtest::GetFunction(module, 6); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; const Instruction* stores[2]; int stores_found = 0; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 30)) { if (inst.opcode() == spv::Op::OpStore) { stores[stores_found] = &inst; ++stores_found; } } for (int i = 0; i < 2; ++i) { EXPECT_TRUE(stores[i]); } // 47 -> 48 { // Analyse and simplify the instruction behind the access chain of this // load. Instruction* load_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(context->get_def_use_mgr() ->GetDef(47) ->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* load = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(load_var)); // Analyse and simplify the instruction behind the access chain of this // store. Instruction* store_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(stores[0]->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* store = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(store_var)); SENode* delta = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->CreateSubtraction(load, store)); // Independent but not supported. EXPECT_FALSE(analysis.IsProvablyOutsideOfLoopBounds( loop, delta, store->AsSERecurrentNode()->GetCoefficient())); } // 54 -> 55 { // Analyse and simplify the instruction behind the access chain of this // load. Instruction* load_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(context->get_def_use_mgr() ->GetDef(54) ->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* load = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(load_var)); // Analyse and simplify the instruction behind the access chain of this // store. Instruction* store_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(stores[1]->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* store = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(store_var)); SENode* delta = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->CreateSubtraction(load, store)); // Independent but not supported. EXPECT_FALSE(analysis.IsProvablyOutsideOfLoopBounds( loop, delta, store->AsSERecurrentNode()->GetCoefficient())); } } { // Function b const Function* f = spvtest::GetFunction(module, 8); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; const Instruction* stores[2]; int stores_found = 0; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 66)) { if (inst.opcode() == spv::Op::OpStore) { stores[stores_found] = &inst; ++stores_found; } } for (int i = 0; i < 2; ++i) { EXPECT_TRUE(stores[i]); } // 78 -> 79 { // Analyse and simplify the instruction behind the access chain of this // load. Instruction* load_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(context->get_def_use_mgr() ->GetDef(78) ->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* load = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(load_var)); // Analyse and simplify the instruction behind the access chain of this // store. Instruction* store_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(stores[0]->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* store = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(store_var)); SENode* delta = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->CreateSubtraction(load, store)); // Dependent. EXPECT_FALSE(analysis.IsProvablyOutsideOfLoopBounds( loop, delta, store->AsSERecurrentNode()->GetCoefficient())); } // 85 -> 86 { // Analyse and simplify the instruction behind the access chain of this // load. Instruction* load_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(context->get_def_use_mgr() ->GetDef(85) ->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* load = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(load_var)); // Analyse and simplify the instruction behind the access chain of this // store. Instruction* store_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(stores[1]->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* store = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(store_var)); SENode* delta = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->CreateSubtraction(load, store)); // Dependent. EXPECT_FALSE(analysis.IsProvablyOutsideOfLoopBounds( loop, delta, store->AsSERecurrentNode()->GetCoefficient())); } } { // Function c const Function* f = spvtest::GetFunction(module, 10); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; const Instruction* stores[2]; int stores_found = 0; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 96)) { if (inst.opcode() == spv::Op::OpStore) { stores[stores_found] = &inst; ++stores_found; } } for (int i = 0; i < 2; ++i) { EXPECT_TRUE(stores[i]); } // 109 -> 110 { // Analyse and simplify the instruction behind the access chain of this // load. Instruction* load_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(context->get_def_use_mgr() ->GetDef(109) ->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* load = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(load_var)); // Analyse and simplify the instruction behind the access chain of this // store. Instruction* store_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(stores[0]->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* store = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(store_var)); SENode* delta = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->CreateSubtraction(load, store)); // Independent and supported. EXPECT_TRUE(analysis.IsProvablyOutsideOfLoopBounds( loop, delta, store->AsSERecurrentNode()->GetCoefficient())); } // 116 -> 117 { // Analyse and simplify the instruction behind the access chain of this // load. Instruction* load_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(context->get_def_use_mgr() ->GetDef(116) ->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* load = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(load_var)); // Analyse and simplify the instruction behind the access chain of this // store. Instruction* store_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(stores[1]->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* store = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(store_var)); SENode* delta = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->CreateSubtraction(load, store)); // Independent but not supported. EXPECT_FALSE(analysis.IsProvablyOutsideOfLoopBounds( loop, delta, store->AsSERecurrentNode()->GetCoefficient())); } } { // Function d const Function* f = spvtest::GetFunction(module, 12); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; const Instruction* stores[2]; int stores_found = 0; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 127)) { if (inst.opcode() == spv::Op::OpStore) { stores[stores_found] = &inst; ++stores_found; } } for (int i = 0; i < 2; ++i) { EXPECT_TRUE(stores[i]); } // 139 -> 140 { // Analyse and simplify the instruction behind the access chain of this // load. Instruction* load_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(context->get_def_use_mgr() ->GetDef(139) ->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* load = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(load_var)); // Analyse and simplify the instruction behind the access chain of this // store. Instruction* store_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(stores[0]->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* store = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(store_var)); SENode* delta = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->CreateSubtraction(load, store)); // Dependent EXPECT_FALSE(analysis.IsProvablyOutsideOfLoopBounds( loop, delta, store->AsSERecurrentNode()->GetCoefficient())); } // 146 -> 147 { // Analyse and simplify the instruction behind the access chain of this // load. Instruction* load_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(context->get_def_use_mgr() ->GetDef(146) ->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* load = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(load_var)); // Analyse and simplify the instruction behind the access chain of this // store. Instruction* store_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(stores[1]->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* store = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(store_var)); SENode* delta = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->CreateSubtraction(load, store)); // Dependent EXPECT_FALSE(analysis.IsProvablyOutsideOfLoopBounds( loop, delta, store->AsSERecurrentNode()->GetCoefficient())); } } } /* Generated from the following GLSL fragment shader with --eliminate-local-multi-store #version 440 core layout(location = 0) in vec4 in_vec; // Loop iterates from symbolic to symbolic void a() { int M = int(in_vec.x); int N = int(in_vec.y); int arr[10]; for (int i = M; i < N; i++) { // Bounds are N - M - 1 arr[i+M+N] = arr[i+M+2*N]; // |distance| = N arr[i+M+2*N] = arr[i+M+N]; // |distance| = N } } void b() { int M = int(in_vec.x); int N = int(in_vec.y); int arr[10]; for (int i = M; i <= N; i++) { // Bounds are N - M arr[i+M+N] = arr[i+M+2*N]; // |distance| = N arr[i+M+2*N] = arr[i+M+N]; // |distance| = N } } void c() { int M = int(in_vec.x); int N = int(in_vec.y); int arr[10]; for (int i = M; i > N; i--) { // Bounds are M - N - 1 arr[i+M+N] = arr[i+M+2*N]; // |distance| = N arr[i+M+2*N] = arr[i+M+N]; // |distance| = N } } void d() { int M = int(in_vec.x); int N = int(in_vec.y); int arr[10]; for (int i = M; i >= N; i--) { // Bounds are M - N arr[i+M+N] = arr[i+M+2*N]; // |distance| = N arr[i+M+2*N] = arr[i+M+N]; // |distance| = N } } void main(){ a(); b(); c(); d(); } */ TEST(DependencyAnalysisHelpers, symbolic_to_symbolic) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %20 OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %6 "a(" OpName %8 "b(" OpName %10 "c(" OpName %12 "d(" OpName %16 "M" OpName %20 "in_vec" OpName %27 "N" OpName %32 "i" OpName %46 "arr" OpName %79 "M" OpName %83 "N" OpName %87 "i" OpName %97 "arr" OpName %128 "M" OpName %132 "N" OpName %136 "i" OpName %146 "arr" OpName %177 "M" OpName %181 "N" OpName %185 "i" OpName %195 "arr" OpDecorate %20 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %14 = OpTypeInt 32 1 %15 = OpTypePointer Function %14 %17 = OpTypeFloat 32 %18 = OpTypeVector %17 4 %19 = OpTypePointer Input %18 %20 = OpVariable %19 Input %21 = OpTypeInt 32 0 %22 = OpConstant %21 0 %23 = OpTypePointer Input %17 %28 = OpConstant %21 1 %41 = OpTypeBool %43 = OpConstant %21 10 %44 = OpTypeArray %14 %43 %45 = OpTypePointer Function %44 %55 = OpConstant %14 2 %77 = OpConstant %14 1 %4 = OpFunction %2 None %3 %5 = OpLabel %226 = OpFunctionCall %2 %6 %227 = OpFunctionCall %2 %8 %228 = OpFunctionCall %2 %10 %229 = OpFunctionCall %2 %12 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %16 = OpVariable %15 Function %27 = OpVariable %15 Function %32 = OpVariable %15 Function %46 = OpVariable %45 Function %24 = OpAccessChain %23 %20 %22 %25 = OpLoad %17 %24 %26 = OpConvertFToS %14 %25 OpStore %16 %26 %29 = OpAccessChain %23 %20 %28 %30 = OpLoad %17 %29 %31 = OpConvertFToS %14 %30 OpStore %27 %31 OpStore %32 %26 OpBranch %34 %34 = OpLabel %230 = OpPhi %14 %26 %7 %78 %37 OpLoopMerge %36 %37 None OpBranch %38 %38 = OpLabel %42 = OpSLessThan %41 %230 %31 OpBranchConditional %42 %35 %36 %35 = OpLabel %49 = OpIAdd %14 %230 %26 %51 = OpIAdd %14 %49 %31 %54 = OpIAdd %14 %230 %26 %57 = OpIMul %14 %55 %31 %58 = OpIAdd %14 %54 %57 %59 = OpAccessChain %15 %46 %58 %60 = OpLoad %14 %59 %61 = OpAccessChain %15 %46 %51 OpStore %61 %60 %64 = OpIAdd %14 %230 %26 %66 = OpIMul %14 %55 %31 %67 = OpIAdd %14 %64 %66 %70 = OpIAdd %14 %230 %26 %72 = OpIAdd %14 %70 %31 %73 = OpAccessChain %15 %46 %72 %74 = OpLoad %14 %73 %75 = OpAccessChain %15 %46 %67 OpStore %75 %74 OpBranch %37 %37 = OpLabel %78 = OpIAdd %14 %230 %77 OpStore %32 %78 OpBranch %34 %36 = OpLabel OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %79 = OpVariable %15 Function %83 = OpVariable %15 Function %87 = OpVariable %15 Function %97 = OpVariable %45 Function %80 = OpAccessChain %23 %20 %22 %81 = OpLoad %17 %80 %82 = OpConvertFToS %14 %81 OpStore %79 %82 %84 = OpAccessChain %23 %20 %28 %85 = OpLoad %17 %84 %86 = OpConvertFToS %14 %85 OpStore %83 %86 OpStore %87 %82 OpBranch %89 %89 = OpLabel %231 = OpPhi %14 %82 %9 %127 %92 OpLoopMerge %91 %92 None OpBranch %93 %93 = OpLabel %96 = OpSLessThanEqual %41 %231 %86 OpBranchConditional %96 %90 %91 %90 = OpLabel %100 = OpIAdd %14 %231 %82 %102 = OpIAdd %14 %100 %86 %105 = OpIAdd %14 %231 %82 %107 = OpIMul %14 %55 %86 %108 = OpIAdd %14 %105 %107 %109 = OpAccessChain %15 %97 %108 %110 = OpLoad %14 %109 %111 = OpAccessChain %15 %97 %102 OpStore %111 %110 %114 = OpIAdd %14 %231 %82 %116 = OpIMul %14 %55 %86 %117 = OpIAdd %14 %114 %116 %120 = OpIAdd %14 %231 %82 %122 = OpIAdd %14 %120 %86 %123 = OpAccessChain %15 %97 %122 %124 = OpLoad %14 %123 %125 = OpAccessChain %15 %97 %117 OpStore %125 %124 OpBranch %92 %92 = OpLabel %127 = OpIAdd %14 %231 %77 OpStore %87 %127 OpBranch %89 %91 = OpLabel OpReturn OpFunctionEnd %10 = OpFunction %2 None %3 %11 = OpLabel %128 = OpVariable %15 Function %132 = OpVariable %15 Function %136 = OpVariable %15 Function %146 = OpVariable %45 Function %129 = OpAccessChain %23 %20 %22 %130 = OpLoad %17 %129 %131 = OpConvertFToS %14 %130 OpStore %128 %131 %133 = OpAccessChain %23 %20 %28 %134 = OpLoad %17 %133 %135 = OpConvertFToS %14 %134 OpStore %132 %135 OpStore %136 %131 OpBranch %138 %138 = OpLabel %232 = OpPhi %14 %131 %11 %176 %141 OpLoopMerge %140 %141 None OpBranch %142 %142 = OpLabel %145 = OpSGreaterThan %41 %232 %135 OpBranchConditional %145 %139 %140 %139 = OpLabel %149 = OpIAdd %14 %232 %131 %151 = OpIAdd %14 %149 %135 %154 = OpIAdd %14 %232 %131 %156 = OpIMul %14 %55 %135 %157 = OpIAdd %14 %154 %156 %158 = OpAccessChain %15 %146 %157 %159 = OpLoad %14 %158 %160 = OpAccessChain %15 %146 %151 OpStore %160 %159 %163 = OpIAdd %14 %232 %131 %165 = OpIMul %14 %55 %135 %166 = OpIAdd %14 %163 %165 %169 = OpIAdd %14 %232 %131 %171 = OpIAdd %14 %169 %135 %172 = OpAccessChain %15 %146 %171 %173 = OpLoad %14 %172 %174 = OpAccessChain %15 %146 %166 OpStore %174 %173 OpBranch %141 %141 = OpLabel %176 = OpISub %14 %232 %77 OpStore %136 %176 OpBranch %138 %140 = OpLabel OpReturn OpFunctionEnd %12 = OpFunction %2 None %3 %13 = OpLabel %177 = OpVariable %15 Function %181 = OpVariable %15 Function %185 = OpVariable %15 Function %195 = OpVariable %45 Function %178 = OpAccessChain %23 %20 %22 %179 = OpLoad %17 %178 %180 = OpConvertFToS %14 %179 OpStore %177 %180 %182 = OpAccessChain %23 %20 %28 %183 = OpLoad %17 %182 %184 = OpConvertFToS %14 %183 OpStore %181 %184 OpStore %185 %180 OpBranch %187 %187 = OpLabel %233 = OpPhi %14 %180 %13 %225 %190 OpLoopMerge %189 %190 None OpBranch %191 %191 = OpLabel %194 = OpSGreaterThanEqual %41 %233 %184 OpBranchConditional %194 %188 %189 %188 = OpLabel %198 = OpIAdd %14 %233 %180 %200 = OpIAdd %14 %198 %184 %203 = OpIAdd %14 %233 %180 %205 = OpIMul %14 %55 %184 %206 = OpIAdd %14 %203 %205 %207 = OpAccessChain %15 %195 %206 %208 = OpLoad %14 %207 %209 = OpAccessChain %15 %195 %200 OpStore %209 %208 %212 = OpIAdd %14 %233 %180 %214 = OpIMul %14 %55 %184 %215 = OpIAdd %14 %212 %214 %218 = OpIAdd %14 %233 %180 %220 = OpIAdd %14 %218 %184 %221 = OpAccessChain %15 %195 %220 %222 = OpLoad %14 %221 %223 = OpAccessChain %15 %195 %215 OpStore %223 %222 OpBranch %190 %190 = OpLabel %225 = OpISub %14 %233 %77 OpStore %185 %225 OpBranch %187 %189 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; { // Function a const Function* f = spvtest::GetFunction(module, 6); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; const Instruction* stores[2]; int stores_found = 0; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 35)) { if (inst.opcode() == spv::Op::OpStore) { stores[stores_found] = &inst; ++stores_found; } } for (int i = 0; i < 2; ++i) { EXPECT_TRUE(stores[i]); } // 60 -> 61 { // Analyse and simplify the instruction behind the access chain of this // load. Instruction* load_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(context->get_def_use_mgr() ->GetDef(60) ->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* load = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(load_var)); // Analyse and simplify the instruction behind the access chain of this // store. Instruction* store_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(stores[0]->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* store = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(store_var)); SENode* delta = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->CreateSubtraction(load, store)); EXPECT_FALSE(analysis.IsProvablyOutsideOfLoopBounds( loop, delta, store->AsSERecurrentNode()->GetCoefficient())); } // 74 -> 75 { // Analyse and simplify the instruction behind the access chain of this // load. Instruction* load_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(context->get_def_use_mgr() ->GetDef(74) ->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* load = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(load_var)); // Analyse and simplify the instruction behind the access chain of this // store. Instruction* store_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(stores[1]->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* store = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(store_var)); SENode* delta = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->CreateSubtraction(load, store)); EXPECT_FALSE(analysis.IsProvablyOutsideOfLoopBounds( loop, delta, store->AsSERecurrentNode()->GetCoefficient())); } } { // Function b const Function* f = spvtest::GetFunction(module, 8); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; const Instruction* stores[2]; int stores_found = 0; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 90)) { if (inst.opcode() == spv::Op::OpStore) { stores[stores_found] = &inst; ++stores_found; } } for (int i = 0; i < 2; ++i) { EXPECT_TRUE(stores[i]); } // 110 -> 111 { // Analyse and simplify the instruction behind the access chain of this // load. Instruction* load_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(context->get_def_use_mgr() ->GetDef(110) ->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* load = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(load_var)); // Analyse and simplify the instruction behind the access chain of this // store. Instruction* store_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(stores[0]->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* store = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(store_var)); SENode* delta = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->CreateSubtraction(load, store)); EXPECT_FALSE(analysis.IsProvablyOutsideOfLoopBounds( loop, delta, store->AsSERecurrentNode()->GetCoefficient())); } // 124 -> 125 { // Analyse and simplify the instruction behind the access chain of this // load. Instruction* load_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(context->get_def_use_mgr() ->GetDef(124) ->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* load = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(load_var)); // Analyse and simplify the instruction behind the access chain of this // store. Instruction* store_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(stores[1]->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* store = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(store_var)); SENode* delta = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->CreateSubtraction(load, store)); EXPECT_FALSE(analysis.IsProvablyOutsideOfLoopBounds( loop, delta, store->AsSERecurrentNode()->GetCoefficient())); } } { // Function c const Function* f = spvtest::GetFunction(module, 10); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; const Instruction* stores[2]; int stores_found = 0; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 139)) { if (inst.opcode() == spv::Op::OpStore) { stores[stores_found] = &inst; ++stores_found; } } for (int i = 0; i < 2; ++i) { EXPECT_TRUE(stores[i]); } // 159 -> 160 { // Analyse and simplify the instruction behind the access chain of this // load. Instruction* load_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(context->get_def_use_mgr() ->GetDef(159) ->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* load = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(load_var)); // Analyse and simplify the instruction behind the access chain of this // store. Instruction* store_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(stores[0]->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* store = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(store_var)); SENode* delta = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->CreateSubtraction(load, store)); EXPECT_FALSE(analysis.IsProvablyOutsideOfLoopBounds( loop, delta, store->AsSERecurrentNode()->GetCoefficient())); } // 173 -> 174 { // Analyse and simplify the instruction behind the access chain of this // load. Instruction* load_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(context->get_def_use_mgr() ->GetDef(173) ->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* load = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(load_var)); // Analyse and simplify the instruction behind the access chain of this // store. Instruction* store_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(stores[1]->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* store = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(store_var)); SENode* delta = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->CreateSubtraction(load, store)); EXPECT_FALSE(analysis.IsProvablyOutsideOfLoopBounds( loop, delta, store->AsSERecurrentNode()->GetCoefficient())); } } { // Function d const Function* f = spvtest::GetFunction(module, 12); LoopDescriptor& ld = *context->GetLoopDescriptor(f); Loop* loop = &ld.GetLoopByIndex(0); std::vector loops{loop}; LoopDependenceAnalysis analysis{context.get(), loops}; const Instruction* stores[2]; int stores_found = 0; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 188)) { if (inst.opcode() == spv::Op::OpStore) { stores[stores_found] = &inst; ++stores_found; } } for (int i = 0; i < 2; ++i) { EXPECT_TRUE(stores[i]); } // 208 -> 209 { // Analyse and simplify the instruction behind the access chain of this // load. Instruction* load_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(context->get_def_use_mgr() ->GetDef(208) ->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* load = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(load_var)); // Analyse and simplify the instruction behind the access chain of this // store. Instruction* store_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(stores[0]->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* store = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(store_var)); SENode* delta = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->CreateSubtraction(load, store)); EXPECT_FALSE(analysis.IsProvablyOutsideOfLoopBounds( loop, delta, store->AsSERecurrentNode()->GetCoefficient())); } // 222 -> 223 { // Analyse and simplify the instruction behind the access chain of this // load. Instruction* load_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(context->get_def_use_mgr() ->GetDef(222) ->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* load = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(load_var)); // Analyse and simplify the instruction behind the access chain of this // store. Instruction* store_var = context->get_def_use_mgr()->GetDef( context->get_def_use_mgr() ->GetDef(stores[1]->GetSingleWordInOperand(0)) ->GetSingleWordInOperand(1)); SENode* store = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->AnalyzeInstruction(store_var)); SENode* delta = analysis.GetScalarEvolution()->SimplifyExpression( analysis.GetScalarEvolution()->CreateSubtraction(load, store)); EXPECT_FALSE(analysis.IsProvablyOutsideOfLoopBounds( loop, delta, store->AsSERecurrentNode()->GetCoefficient())); } } } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/loop_optimizations/fusion_compatibility.cpp000066400000000000000000001527211475742701700312240ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gmock/gmock.h" #include "source/opt/loop_descriptor.h" #include "source/opt/loop_fusion.h" #include "test/opt/pass_fixture.h" namespace spvtools { namespace opt { namespace { using FusionCompatibilityTest = PassTest<::testing::Test>; /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core void main() { int i = 0; // Can't fuse, i=0 in first & i=10 in second for (; i < 10; i++) {} for (; i < 10; i++) {} } */ TEST_F(FusionCompatibilityTest, SameInductionVariableDifferentBounds) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %20 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %31 = OpPhi %6 %9 %5 %21 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %31 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel OpBranch %13 %13 = OpLabel %21 = OpIAdd %6 %31 %20 OpStore %8 %21 OpBranch %10 %12 = OpLabel OpBranch %22 %22 = OpLabel %32 = OpPhi %6 %31 %12 %30 %25 OpLoopMerge %24 %25 None OpBranch %26 %26 = OpLabel %28 = OpSLessThan %17 %32 %16 OpBranchConditional %28 %23 %24 %23 = OpLabel OpBranch %25 %25 = OpLabel %30 = OpIAdd %6 %32 %20 OpStore %8 %30 OpBranch %22 %24 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_FALSE(fusion.AreCompatible()); } /* Generated from the following GLSL + --eliminate-local-multi-store // 1 #version 440 core void main() { for (int i = 0; i < 10; i++) {} for (int i = 0; i < 10; i++) {} } */ TEST_F(FusionCompatibilityTest, Compatible) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %22 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %20 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %22 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %32 = OpPhi %6 %9 %5 %21 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %32 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel OpBranch %13 %13 = OpLabel %21 = OpIAdd %6 %32 %20 OpStore %8 %21 OpBranch %10 %12 = OpLabel OpStore %22 %9 OpBranch %23 %23 = OpLabel %33 = OpPhi %6 %9 %12 %31 %26 OpLoopMerge %25 %26 None OpBranch %27 %27 = OpLabel %29 = OpSLessThan %17 %33 %16 OpBranchConditional %29 %24 %25 %24 = OpLabel OpBranch %26 %26 = OpLabel %31 = OpIAdd %6 %33 %20 OpStore %22 %31 OpBranch %23 %25 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_TRUE(fusion.AreCompatible()); } /* Generated from the following GLSL + --eliminate-local-multi-store // 2 #version 440 core void main() { for (int i = 0; i < 10; i++) {} for (int j = 0; j < 10; j++) {} } */ TEST_F(FusionCompatibilityTest, DifferentName) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %22 "j" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %20 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %22 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %32 = OpPhi %6 %9 %5 %21 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %32 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel OpBranch %13 %13 = OpLabel %21 = OpIAdd %6 %32 %20 OpStore %8 %21 OpBranch %10 %12 = OpLabel OpStore %22 %9 OpBranch %23 %23 = OpLabel %33 = OpPhi %6 %9 %12 %31 %26 OpLoopMerge %25 %26 None OpBranch %27 %27 = OpLabel %29 = OpSLessThan %17 %33 %16 OpBranchConditional %29 %24 %25 %24 = OpLabel OpBranch %26 %26 = OpLabel %31 = OpIAdd %6 %33 %20 OpStore %22 %31 OpBranch %23 %25 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_TRUE(fusion.AreCompatible()); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core void main() { // Can't fuse, different step for (int i = 0; i < 10; i++) {} for (int j = 0; j < 10; j=j+2) {} } */ TEST_F(FusionCompatibilityTest, SameBoundsDifferentStep) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %22 "j" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %20 = OpConstant %6 1 %31 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %22 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %33 = OpPhi %6 %9 %5 %21 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %33 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel OpBranch %13 %13 = OpLabel %21 = OpIAdd %6 %33 %20 OpStore %8 %21 OpBranch %10 %12 = OpLabel OpStore %22 %9 OpBranch %23 %23 = OpLabel %34 = OpPhi %6 %9 %12 %32 %26 OpLoopMerge %25 %26 None OpBranch %27 %27 = OpLabel %29 = OpSLessThan %17 %34 %16 OpBranchConditional %29 %24 %25 %24 = OpLabel OpBranch %26 %26 = OpLabel %32 = OpIAdd %6 %34 %31 OpStore %22 %32 OpBranch %23 %25 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_FALSE(fusion.AreCompatible()); } /* Generated from the following GLSL + --eliminate-local-multi-store // 4 #version 440 core void main() { // Can't fuse, different upper bound for (int i = 0; i < 10; i++) {} for (int j = 0; j < 20; j++) {} } */ TEST_F(FusionCompatibilityTest, DifferentUpperBound) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %22 "j" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %20 = OpConstant %6 1 %29 = OpConstant %6 20 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %22 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %33 = OpPhi %6 %9 %5 %21 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %33 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel OpBranch %13 %13 = OpLabel %21 = OpIAdd %6 %33 %20 OpStore %8 %21 OpBranch %10 %12 = OpLabel OpStore %22 %9 OpBranch %23 %23 = OpLabel %34 = OpPhi %6 %9 %12 %32 %26 OpLoopMerge %25 %26 None OpBranch %27 %27 = OpLabel %30 = OpSLessThan %17 %34 %29 OpBranchConditional %30 %24 %25 %24 = OpLabel OpBranch %26 %26 = OpLabel %32 = OpIAdd %6 %34 %20 OpStore %22 %32 OpBranch %23 %25 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_FALSE(fusion.AreCompatible()); } /* Generated from the following GLSL + --eliminate-local-multi-store // 5 #version 440 core void main() { // Can't fuse, different lower bound for (int i = 5; i < 10; i++) {} for (int j = 0; j < 10; j++) {} } */ TEST_F(FusionCompatibilityTest, DifferentLowerBound) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %22 "j" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 5 %16 = OpConstant %6 10 %17 = OpTypeBool %20 = OpConstant %6 1 %23 = OpConstant %6 0 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %22 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %33 = OpPhi %6 %9 %5 %21 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %33 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel OpBranch %13 %13 = OpLabel %21 = OpIAdd %6 %33 %20 OpStore %8 %21 OpBranch %10 %12 = OpLabel OpStore %22 %23 OpBranch %24 %24 = OpLabel %34 = OpPhi %6 %23 %12 %32 %27 OpLoopMerge %26 %27 None OpBranch %28 %28 = OpLabel %30 = OpSLessThan %17 %34 %16 OpBranchConditional %30 %25 %26 %25 = OpLabel OpBranch %27 %27 = OpLabel %32 = OpIAdd %6 %34 %20 OpStore %22 %32 OpBranch %24 %26 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_FALSE(fusion.AreCompatible()); } /* Generated from the following GLSL + --eliminate-local-multi-store // 6 #version 440 core void main() { // Can't fuse, break in first loop for (int i = 0; i < 10; i++) { if (i == 5) { break; } } for (int j = 0; j < 10; j++) {} } */ TEST_F(FusionCompatibilityTest, Break) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %28 "j" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %20 = OpConstant %6 5 %26 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %28 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %38 = OpPhi %6 %9 %5 %27 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %38 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %21 = OpIEqual %17 %38 %20 OpSelectionMerge %23 None OpBranchConditional %21 %22 %23 %22 = OpLabel OpBranch %12 %23 = OpLabel OpBranch %13 %13 = OpLabel %27 = OpIAdd %6 %38 %26 OpStore %8 %27 OpBranch %10 %12 = OpLabel OpStore %28 %9 OpBranch %29 %29 = OpLabel %39 = OpPhi %6 %9 %12 %37 %32 OpLoopMerge %31 %32 None OpBranch %33 %33 = OpLabel %35 = OpSLessThan %17 %39 %16 OpBranchConditional %35 %30 %31 %30 = OpLabel OpBranch %32 %32 = OpLabel %37 = OpIAdd %6 %39 %26 OpStore %28 %37 OpBranch %29 %31 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_FALSE(fusion.AreCompatible()); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core layout(location = 0) in vec4 c; void main() { int N = int(c.x); for (int i = 0; i < N; i++) {} for (int j = 0; j < N; j++) {} } */ TEST_F(FusionCompatibilityTest, UnknownButSameUpperBound) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %12 OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "N" OpName %12 "c" OpName %19 "i" OpName %33 "j" OpDecorate %12 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpTypeFloat 32 %10 = OpTypeVector %9 4 %11 = OpTypePointer Input %10 %12 = OpVariable %11 Input %13 = OpTypeInt 32 0 %14 = OpConstant %13 0 %15 = OpTypePointer Input %9 %20 = OpConstant %6 0 %28 = OpTypeBool %31 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %19 = OpVariable %7 Function %33 = OpVariable %7 Function %16 = OpAccessChain %15 %12 %14 %17 = OpLoad %9 %16 %18 = OpConvertFToS %6 %17 OpStore %8 %18 OpStore %19 %20 OpBranch %21 %21 = OpLabel %44 = OpPhi %6 %20 %5 %32 %24 OpLoopMerge %23 %24 None OpBranch %25 %25 = OpLabel %29 = OpSLessThan %28 %44 %18 OpBranchConditional %29 %22 %23 %22 = OpLabel OpBranch %24 %24 = OpLabel %32 = OpIAdd %6 %44 %31 OpStore %19 %32 OpBranch %21 %23 = OpLabel OpStore %33 %20 OpBranch %34 %34 = OpLabel %46 = OpPhi %6 %20 %23 %43 %37 OpLoopMerge %36 %37 None OpBranch %38 %38 = OpLabel %41 = OpSLessThan %28 %46 %18 OpBranchConditional %41 %35 %36 %35 = OpLabel OpBranch %37 %37 = OpLabel %43 = OpIAdd %6 %46 %31 OpStore %33 %43 OpBranch %34 %36 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_TRUE(fusion.AreCompatible()); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core layout(location = 0) in vec4 c; void main() { int N = int(c.x); for (int i = 0; N > j; i++) {} for (int j = 0; N > j; j++) {} } */ TEST_F(FusionCompatibilityTest, UnknownButSameUpperBoundReverseCondition) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %12 OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "N" OpName %12 "c" OpName %19 "i" OpName %33 "j" OpDecorate %12 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpTypeFloat 32 %10 = OpTypeVector %9 4 %11 = OpTypePointer Input %10 %12 = OpVariable %11 Input %13 = OpTypeInt 32 0 %14 = OpConstant %13 0 %15 = OpTypePointer Input %9 %20 = OpConstant %6 0 %28 = OpTypeBool %31 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %19 = OpVariable %7 Function %33 = OpVariable %7 Function %16 = OpAccessChain %15 %12 %14 %17 = OpLoad %9 %16 %18 = OpConvertFToS %6 %17 OpStore %8 %18 OpStore %19 %20 OpBranch %21 %21 = OpLabel %45 = OpPhi %6 %20 %5 %32 %24 OpLoopMerge %23 %24 None OpBranch %25 %25 = OpLabel %29 = OpSGreaterThan %28 %18 %45 OpBranchConditional %29 %22 %23 %22 = OpLabel OpBranch %24 %24 = OpLabel %32 = OpIAdd %6 %45 %31 OpStore %19 %32 OpBranch %21 %23 = OpLabel OpStore %33 %20 OpBranch %34 %34 = OpLabel %47 = OpPhi %6 %20 %23 %43 %37 OpLoopMerge %36 %37 None OpBranch %38 %38 = OpLabel %41 = OpSGreaterThan %28 %18 %47 OpBranchConditional %41 %35 %36 %35 = OpLabel OpBranch %37 %37 = OpLabel %43 = OpIAdd %6 %47 %31 OpStore %33 %43 OpBranch %34 %36 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_TRUE(fusion.AreCompatible()); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core layout(location = 0) in vec4 c; void main() { // Can't fuse different bound int N = int(c.x); for (int i = 0; i < N; i++) {} for (int j = 0; j < N+1; j++) {} } */ TEST_F(FusionCompatibilityTest, UnknownUpperBoundAddition) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %12 OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "N" OpName %12 "c" OpName %19 "i" OpName %33 "j" OpDecorate %12 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpTypeFloat 32 %10 = OpTypeVector %9 4 %11 = OpTypePointer Input %10 %12 = OpVariable %11 Input %13 = OpTypeInt 32 0 %14 = OpConstant %13 0 %15 = OpTypePointer Input %9 %20 = OpConstant %6 0 %28 = OpTypeBool %31 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %19 = OpVariable %7 Function %33 = OpVariable %7 Function %16 = OpAccessChain %15 %12 %14 %17 = OpLoad %9 %16 %18 = OpConvertFToS %6 %17 OpStore %8 %18 OpStore %19 %20 OpBranch %21 %21 = OpLabel %45 = OpPhi %6 %20 %5 %32 %24 OpLoopMerge %23 %24 None OpBranch %25 %25 = OpLabel %29 = OpSLessThan %28 %45 %18 OpBranchConditional %29 %22 %23 %22 = OpLabel OpBranch %24 %24 = OpLabel %32 = OpIAdd %6 %45 %31 OpStore %19 %32 OpBranch %21 %23 = OpLabel OpStore %33 %20 OpBranch %34 %34 = OpLabel %47 = OpPhi %6 %20 %23 %44 %37 OpLoopMerge %36 %37 None OpBranch %38 %38 = OpLabel %41 = OpIAdd %6 %18 %31 %42 = OpSLessThan %28 %47 %41 OpBranchConditional %42 %35 %36 %35 = OpLabel OpBranch %37 %37 = OpLabel %44 = OpIAdd %6 %47 %31 OpStore %33 %44 OpBranch %34 %36 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_FALSE(fusion.AreCompatible()); } /* Generated from the following GLSL + --eliminate-local-multi-store // 10 #version 440 core void main() { for (int i = 0; i < 10; i++) {} for (int j = 0; j < 10; j++) {} for (int k = 0; k < 10; k++) {} } */ TEST_F(FusionCompatibilityTest, SeveralAdjacentLoops) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %22 "j" OpName %32 "k" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %20 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %22 = OpVariable %7 Function %32 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %42 = OpPhi %6 %9 %5 %21 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %42 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel OpBranch %13 %13 = OpLabel %21 = OpIAdd %6 %42 %20 OpStore %8 %21 OpBranch %10 %12 = OpLabel OpStore %22 %9 OpBranch %23 %23 = OpLabel %43 = OpPhi %6 %9 %12 %31 %26 OpLoopMerge %25 %26 None OpBranch %27 %27 = OpLabel %29 = OpSLessThan %17 %43 %16 OpBranchConditional %29 %24 %25 %24 = OpLabel OpBranch %26 %26 = OpLabel %31 = OpIAdd %6 %43 %20 OpStore %22 %31 OpBranch %23 %25 = OpLabel OpStore %32 %9 OpBranch %33 %33 = OpLabel %44 = OpPhi %6 %9 %25 %41 %36 OpLoopMerge %35 %36 None OpBranch %37 %37 = OpLabel %39 = OpSLessThan %17 %44 %16 OpBranchConditional %39 %34 %35 %34 = OpLabel OpBranch %36 %36 = OpLabel %41 = OpIAdd %6 %44 %20 OpStore %32 %41 OpBranch %33 %35 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 3u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); auto loop_0 = loops[0]; auto loop_1 = loops[1]; auto loop_2 = loops[2]; EXPECT_FALSE(LoopFusion(context.get(), loop_0, loop_0).AreCompatible()); EXPECT_FALSE(LoopFusion(context.get(), loop_0, loop_2).AreCompatible()); EXPECT_FALSE(LoopFusion(context.get(), loop_1, loop_0).AreCompatible()); EXPECT_TRUE(LoopFusion(context.get(), loop_0, loop_1).AreCompatible()); EXPECT_TRUE(LoopFusion(context.get(), loop_1, loop_2).AreCompatible()); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core void main() { // Can't fuse, not adjacent int x = 0; for (int i = 0; i < 10; i++) { if (i > 10) { x++; } } x++; for (int j = 0; j < 10; j++) {} for (int k = 0; k < 10; k++) {} } */ TEST_F(FusionCompatibilityTest, NonAdjacentLoops) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "x" OpName %10 "i" OpName %31 "j" OpName %41 "k" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %17 = OpConstant %6 10 %18 = OpTypeBool %25 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %31 = OpVariable %7 Function %41 = OpVariable %7 Function OpStore %8 %9 OpStore %10 %9 OpBranch %11 %11 = OpLabel %52 = OpPhi %6 %9 %5 %56 %14 %51 = OpPhi %6 %9 %5 %28 %14 OpLoopMerge %13 %14 None OpBranch %15 %15 = OpLabel %19 = OpSLessThan %18 %51 %17 OpBranchConditional %19 %12 %13 %12 = OpLabel %21 = OpSGreaterThan %18 %52 %17 OpSelectionMerge %23 None OpBranchConditional %21 %22 %23 %22 = OpLabel %26 = OpIAdd %6 %52 %25 OpStore %8 %26 OpBranch %23 %23 = OpLabel %56 = OpPhi %6 %52 %12 %26 %22 OpBranch %14 %14 = OpLabel %28 = OpIAdd %6 %51 %25 OpStore %10 %28 OpBranch %11 %13 = OpLabel %30 = OpIAdd %6 %52 %25 OpStore %8 %30 OpStore %31 %9 OpBranch %32 %32 = OpLabel %53 = OpPhi %6 %9 %13 %40 %35 OpLoopMerge %34 %35 None OpBranch %36 %36 = OpLabel %38 = OpSLessThan %18 %53 %17 OpBranchConditional %38 %33 %34 %33 = OpLabel OpBranch %35 %35 = OpLabel %40 = OpIAdd %6 %53 %25 OpStore %31 %40 OpBranch %32 %34 = OpLabel OpStore %41 %9 OpBranch %42 %42 = OpLabel %54 = OpPhi %6 %9 %34 %50 %45 OpLoopMerge %44 %45 None OpBranch %46 %46 = OpLabel %48 = OpSLessThan %18 %54 %17 OpBranchConditional %48 %43 %44 %43 = OpLabel OpBranch %45 %45 = OpLabel %50 = OpIAdd %6 %54 %25 OpStore %41 %50 OpBranch %42 %44 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 3u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); auto loop_0 = loops[0]; auto loop_1 = loops[1]; auto loop_2 = loops[2]; EXPECT_FALSE(LoopFusion(context.get(), loop_0, loop_0).AreCompatible()); EXPECT_FALSE(LoopFusion(context.get(), loop_0, loop_2).AreCompatible()); EXPECT_FALSE(LoopFusion(context.get(), loop_0, loop_1).AreCompatible()); EXPECT_TRUE(LoopFusion(context.get(), loop_1, loop_2).AreCompatible()); } /* Generated from the following GLSL + --eliminate-local-multi-store // 12 #version 440 core void main() { int j = 0; int i = 0; for (; i < 10; i++) {} for (; j < 10; j++) {} } */ TEST_F(FusionCompatibilityTest, CompatibleInitDeclaredBeforeLoops) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "j" OpName %10 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %17 = OpConstant %6 10 %18 = OpTypeBool %21 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function OpStore %8 %9 OpStore %10 %9 OpBranch %11 %11 = OpLabel %32 = OpPhi %6 %9 %5 %22 %14 OpLoopMerge %13 %14 None OpBranch %15 %15 = OpLabel %19 = OpSLessThan %18 %32 %17 OpBranchConditional %19 %12 %13 %12 = OpLabel OpBranch %14 %14 = OpLabel %22 = OpIAdd %6 %32 %21 OpStore %10 %22 OpBranch %11 %13 = OpLabel OpBranch %23 %23 = OpLabel %33 = OpPhi %6 %9 %13 %31 %26 OpLoopMerge %25 %26 None OpBranch %27 %27 = OpLabel %29 = OpSLessThan %18 %33 %17 OpBranchConditional %29 %24 %25 %24 = OpLabel OpBranch %26 %26 = OpLabel %31 = OpIAdd %6 %33 %21 OpStore %8 %31 OpBranch %23 %25 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); EXPECT_TRUE(LoopFusion(context.get(), loops[0], loops[1]).AreCompatible()); } /* Generated from the following GLSL + --eliminate-local-multi-store // 13 regenerate! #version 440 core void main() { int[10] a; int[10] b; // Can't fuse, several induction variables for (int j = 0; j < 10; j++) { b[i] = a[i]; } for (int i = 0, j = 0; i < 10; i++, j = j+2) { } } */ TEST_F(FusionCompatibilityTest, SeveralInductionVariables) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "j" OpName %23 "b" OpName %25 "a" OpName %33 "i" OpName %34 "j" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %19 = OpTypeInt 32 0 %20 = OpConstant %19 10 %21 = OpTypeArray %6 %20 %22 = OpTypePointer Function %21 %31 = OpConstant %6 1 %48 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %23 = OpVariable %22 Function %25 = OpVariable %22 Function %33 = OpVariable %7 Function %34 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %50 = OpPhi %6 %9 %5 %32 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %50 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %27 = OpAccessChain %7 %25 %50 %28 = OpLoad %6 %27 %29 = OpAccessChain %7 %23 %50 OpStore %29 %28 OpBranch %13 %13 = OpLabel %32 = OpIAdd %6 %50 %31 OpStore %8 %32 OpBranch %10 %12 = OpLabel OpStore %33 %9 OpStore %34 %9 OpBranch %35 %35 = OpLabel %52 = OpPhi %6 %9 %12 %49 %38 %51 = OpPhi %6 %9 %12 %46 %38 OpLoopMerge %37 %38 None OpBranch %39 %39 = OpLabel %41 = OpSLessThan %17 %51 %16 OpBranchConditional %41 %36 %37 %36 = OpLabel %44 = OpAccessChain %7 %25 %52 OpStore %44 %51 OpBranch %38 %38 = OpLabel %46 = OpIAdd %6 %51 %31 OpStore %33 %46 %49 = OpIAdd %6 %52 %48 OpStore %34 %49 OpBranch %35 %37 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); EXPECT_FALSE(LoopFusion(context.get(), loops[0], loops[1]).AreCompatible()); } /* Generated from the following GLSL + --eliminate-local-multi-store // 14 #version 440 core void main() { // Fine for (int i = 0; i < 10; i = i + 2) {} for (int j = 0; j < 10; j = j + 2) {} } */ TEST_F(FusionCompatibilityTest, CompatibleNonIncrementStep) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "j" OpName %10 "i" OpName %11 "i" OpName %24 "j" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %18 = OpConstant %6 10 %19 = OpTypeBool %22 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %11 = OpVariable %7 Function %24 = OpVariable %7 Function OpStore %8 %9 OpStore %10 %9 OpStore %11 %9 OpBranch %12 %12 = OpLabel %34 = OpPhi %6 %9 %5 %23 %15 OpLoopMerge %14 %15 None OpBranch %16 %16 = OpLabel %20 = OpSLessThan %19 %34 %18 OpBranchConditional %20 %13 %14 %13 = OpLabel OpBranch %15 %15 = OpLabel %23 = OpIAdd %6 %34 %22 OpStore %11 %23 OpBranch %12 %14 = OpLabel OpStore %24 %9 OpBranch %25 %25 = OpLabel %35 = OpPhi %6 %9 %14 %33 %28 OpLoopMerge %27 %28 None OpBranch %29 %29 = OpLabel %31 = OpSLessThan %19 %35 %18 OpBranchConditional %31 %26 %27 %26 = OpLabel OpBranch %28 %28 = OpLabel %33 = OpIAdd %6 %35 %22 OpStore %24 %33 OpBranch %25 %27 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); EXPECT_TRUE(LoopFusion(context.get(), loops[0], loops[1]).AreCompatible()); } /* Generated from the following GLSL + --eliminate-local-multi-store // 15 #version 440 core int j = 0; void main() { // Not compatible, unknown init for second. for (int i = 0; i < 10; i = i + 2) {} for (; j < 10; j = j + 2) {} } */ TEST_F(FusionCompatibilityTest, UnknonInitForSecondLoop) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "j" OpName %11 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Private %6 %8 = OpVariable %7 Private %9 = OpConstant %6 0 %10 = OpTypePointer Function %6 %18 = OpConstant %6 10 %19 = OpTypeBool %22 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %11 = OpVariable %10 Function OpStore %8 %9 OpStore %11 %9 OpBranch %12 %12 = OpLabel %33 = OpPhi %6 %9 %5 %23 %15 OpLoopMerge %14 %15 None OpBranch %16 %16 = OpLabel %20 = OpSLessThan %19 %33 %18 OpBranchConditional %20 %13 %14 %13 = OpLabel OpBranch %15 %15 = OpLabel %23 = OpIAdd %6 %33 %22 OpStore %11 %23 OpBranch %12 %14 = OpLabel OpBranch %24 %24 = OpLabel OpLoopMerge %26 %27 None OpBranch %28 %28 = OpLabel %29 = OpLoad %6 %8 %30 = OpSLessThan %19 %29 %18 OpBranchConditional %30 %25 %26 %25 = OpLabel OpBranch %27 %27 = OpLabel %31 = OpLoad %6 %8 %32 = OpIAdd %6 %31 %22 OpStore %8 %32 OpBranch %24 %26 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); EXPECT_FALSE(LoopFusion(context.get(), loops[0], loops[1]).AreCompatible()); } /* Generated from the following GLSL + --eliminate-local-multi-store // 16 #version 440 core void main() { // Not compatible, continue in loop 0 for (int i = 0; i < 10; ++i) { if (i % 2 == 1) { continue; } } for (int j = 0; j < 10; ++j) {} } */ TEST_F(FusionCompatibilityTest, Continue) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %29 "j" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %20 = OpConstant %6 2 %22 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %29 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %39 = OpPhi %6 %9 %5 %28 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %39 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %21 = OpSMod %6 %39 %20 %23 = OpIEqual %17 %21 %22 OpSelectionMerge %25 None OpBranchConditional %23 %24 %25 %24 = OpLabel OpBranch %13 %25 = OpLabel OpBranch %13 %13 = OpLabel %28 = OpIAdd %6 %39 %22 OpStore %8 %28 OpBranch %10 %12 = OpLabel OpStore %29 %9 OpBranch %30 %30 = OpLabel %40 = OpPhi %6 %9 %12 %38 %33 OpLoopMerge %32 %33 None OpBranch %34 %34 = OpLabel %36 = OpSLessThan %17 %40 %16 OpBranchConditional %36 %31 %32 %31 = OpLabel OpBranch %33 %33 = OpLabel %38 = OpIAdd %6 %40 %22 OpStore %29 %38 OpBranch %30 %32 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); EXPECT_FALSE(LoopFusion(context.get(), loops[0], loops[1]).AreCompatible()); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core void main() { int[10] a; // Compatible for (int i = 0; i < 10; ++i) { if (i % 2 == 1) { } else { a[i] = i; } } for (int j = 0; j < 10; ++j) {} } */ TEST_F(FusionCompatibilityTest, IfElseInLoop) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %31 "a" OpName %37 "j" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %20 = OpConstant %6 2 %22 = OpConstant %6 1 %27 = OpTypeInt 32 0 %28 = OpConstant %27 10 %29 = OpTypeArray %6 %28 %30 = OpTypePointer Function %29 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %31 = OpVariable %30 Function %37 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %47 = OpPhi %6 %9 %5 %36 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %47 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %21 = OpSMod %6 %47 %20 %23 = OpIEqual %17 %21 %22 OpSelectionMerge %25 None OpBranchConditional %23 %24 %26 %24 = OpLabel OpBranch %25 %26 = OpLabel %34 = OpAccessChain %7 %31 %47 OpStore %34 %47 OpBranch %25 %25 = OpLabel OpBranch %13 %13 = OpLabel %36 = OpIAdd %6 %47 %22 OpStore %8 %36 OpBranch %10 %12 = OpLabel OpStore %37 %9 OpBranch %38 %38 = OpLabel %48 = OpPhi %6 %9 %12 %46 %41 OpLoopMerge %40 %41 None OpBranch %42 %42 = OpLabel %44 = OpSLessThan %17 %48 %16 OpBranchConditional %44 %39 %40 %39 = OpLabel OpBranch %41 %41 = OpLabel %46 = OpIAdd %6 %48 %22 OpStore %37 %46 OpBranch %38 %40 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); EXPECT_TRUE(LoopFusion(context.get(), loops[0], loops[1]).AreCompatible()); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/loop_optimizations/fusion_illegal.cpp000066400000000000000000001337131475742701700277640ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gmock/gmock.h" #include "source/opt/loop_descriptor.h" #include "source/opt/loop_fusion.h" #include "test/opt/pass_fixture.h" namespace spvtools { namespace opt { namespace { using FusionIllegalTest = PassTest<::testing::Test>; /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core void main() { int[10] a; int[10] b; int[10] c; // Illegal, loop-independent dependence will become a // backward loop-carried antidependence for (int i = 0; i < 10; i++) { a[i] = b[i] + 1; } for (int i = 0; i < 10; i++) { c[i] = a[i+1] + 2; } } */ TEST_F(FusionIllegalTest, PositiveDistanceCreatedRAW) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %23 "a" OpName %25 "b" OpName %34 "i" OpName %42 "c" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %19 = OpTypeInt 32 0 %20 = OpConstant %19 10 %21 = OpTypeArray %6 %20 %22 = OpTypePointer Function %21 %29 = OpConstant %6 1 %48 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %23 = OpVariable %22 Function %25 = OpVariable %22 Function %34 = OpVariable %7 Function %42 = OpVariable %22 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %53 = OpPhi %6 %9 %5 %33 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %53 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %27 = OpAccessChain %7 %25 %53 %28 = OpLoad %6 %27 %30 = OpIAdd %6 %28 %29 %31 = OpAccessChain %7 %23 %53 OpStore %31 %30 OpBranch %13 %13 = OpLabel %33 = OpIAdd %6 %53 %29 OpStore %8 %33 OpBranch %10 %12 = OpLabel OpStore %34 %9 OpBranch %35 %35 = OpLabel %54 = OpPhi %6 %9 %12 %52 %38 OpLoopMerge %37 %38 None OpBranch %39 %39 = OpLabel %41 = OpSLessThan %17 %54 %16 OpBranchConditional %41 %36 %37 %36 = OpLabel %45 = OpIAdd %6 %54 %29 %46 = OpAccessChain %7 %23 %45 %47 = OpLoad %6 %46 %49 = OpIAdd %6 %47 %48 %50 = OpAccessChain %7 %42 %54 OpStore %50 %49 OpBranch %38 %38 = OpLabel %52 = OpIAdd %6 %54 %29 OpStore %34 %52 OpBranch %35 %37 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_FALSE(fusion.IsLegal()); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core int func() { return 10; } void main() { int[10] a; int[10] b; // Illegal, function call for (int i = 0; i < 10; i++) { a[i] = func(); } for (int i = 0; i < 10; i++) { b[i] = a[i]; } } */ TEST_F(FusionIllegalTest, FunctionCall) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "func(" OpName %14 "i" OpName %28 "a" OpName %35 "i" OpName %43 "b" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeFunction %6 %10 = OpConstant %6 10 %13 = OpTypePointer Function %6 %15 = OpConstant %6 0 %22 = OpTypeBool %24 = OpTypeInt 32 0 %25 = OpConstant %24 10 %26 = OpTypeArray %6 %25 %27 = OpTypePointer Function %26 %33 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %14 = OpVariable %13 Function %28 = OpVariable %27 Function %35 = OpVariable %13 Function %43 = OpVariable %27 Function OpStore %14 %15 OpBranch %16 %16 = OpLabel %51 = OpPhi %6 %15 %5 %34 %19 OpLoopMerge %18 %19 None OpBranch %20 %20 = OpLabel %23 = OpSLessThan %22 %51 %10 OpBranchConditional %23 %17 %18 %17 = OpLabel %30 = OpFunctionCall %6 %8 %31 = OpAccessChain %13 %28 %51 OpStore %31 %30 OpBranch %19 %19 = OpLabel %34 = OpIAdd %6 %51 %33 OpStore %14 %34 OpBranch %16 %18 = OpLabel OpStore %35 %15 OpBranch %36 %36 = OpLabel %52 = OpPhi %6 %15 %18 %50 %39 OpLoopMerge %38 %39 None OpBranch %40 %40 = OpLabel %42 = OpSLessThan %22 %52 %10 OpBranchConditional %42 %37 %38 %37 = OpLabel %46 = OpAccessChain %13 %28 %52 %47 = OpLoad %6 %46 %48 = OpAccessChain %13 %43 %52 OpStore %48 %47 OpBranch %39 %39 = OpLabel %50 = OpIAdd %6 %52 %33 OpStore %35 %50 OpBranch %36 %38 = OpLabel OpReturn OpFunctionEnd %8 = OpFunction %6 None %7 %9 = OpLabel OpReturnValue %10 OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_FALSE(fusion.IsLegal()); } /* Generated from the following GLSL + --eliminate-local-multi-store // 16 #version 440 core void main() { int[10][10] a; int[10][10] b; int[10][10] c; // Illegal outer. for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { c[i][j] = a[i][j] + 2; } } for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { b[i][j] = c[i+1][j] + 10; } } } */ TEST_F(FusionIllegalTest, PositiveDistanceCreatedRAWOuterLoop) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %19 "j" OpName %32 "c" OpName %35 "a" OpName %48 "i" OpName %56 "j" OpName %64 "b" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %27 = OpTypeInt 32 0 %28 = OpConstant %27 10 %29 = OpTypeArray %6 %28 %30 = OpTypeArray %29 %28 %31 = OpTypePointer Function %30 %40 = OpConstant %6 2 %44 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %19 = OpVariable %7 Function %32 = OpVariable %31 Function %35 = OpVariable %31 Function %48 = OpVariable %7 Function %56 = OpVariable %7 Function %64 = OpVariable %31 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %78 = OpPhi %6 %9 %5 %47 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %78 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel OpStore %19 %9 OpBranch %20 %20 = OpLabel %82 = OpPhi %6 %9 %11 %45 %23 OpLoopMerge %22 %23 None OpBranch %24 %24 = OpLabel %26 = OpSLessThan %17 %82 %16 OpBranchConditional %26 %21 %22 %21 = OpLabel %38 = OpAccessChain %7 %35 %78 %82 %39 = OpLoad %6 %38 %41 = OpIAdd %6 %39 %40 %42 = OpAccessChain %7 %32 %78 %82 OpStore %42 %41 OpBranch %23 %23 = OpLabel %45 = OpIAdd %6 %82 %44 OpStore %19 %45 OpBranch %20 %22 = OpLabel OpBranch %13 %13 = OpLabel %47 = OpIAdd %6 %78 %44 OpStore %8 %47 OpBranch %10 %12 = OpLabel OpStore %48 %9 OpBranch %49 %49 = OpLabel %79 = OpPhi %6 %9 %12 %77 %52 OpLoopMerge %51 %52 None OpBranch %53 %53 = OpLabel %55 = OpSLessThan %17 %79 %16 OpBranchConditional %55 %50 %51 %50 = OpLabel OpStore %56 %9 OpBranch %57 %57 = OpLabel %80 = OpPhi %6 %9 %50 %75 %60 OpLoopMerge %59 %60 None OpBranch %61 %61 = OpLabel %63 = OpSLessThan %17 %80 %16 OpBranchConditional %63 %58 %59 %58 = OpLabel %68 = OpIAdd %6 %79 %44 %70 = OpAccessChain %7 %32 %68 %80 %71 = OpLoad %6 %70 %72 = OpIAdd %6 %71 %16 %73 = OpAccessChain %7 %64 %79 %80 OpStore %73 %72 OpBranch %60 %60 = OpLabel %75 = OpIAdd %6 %80 %44 OpStore %56 %75 OpBranch %57 %59 = OpLabel OpBranch %52 %52 = OpLabel %77 = OpIAdd %6 %79 %44 OpStore %48 %77 OpBranch %49 %51 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 4u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); auto loop_0 = loops[0]; auto loop_1 = loops[1]; auto loop_2 = loops[2]; auto loop_3 = loops[3]; { LoopFusion fusion(context.get(), loop_0, loop_1); EXPECT_FALSE(fusion.AreCompatible()); } { LoopFusion fusion(context.get(), loop_0, loop_2); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_FALSE(fusion.IsLegal()); } { LoopFusion fusion(context.get(), loop_1, loop_2); EXPECT_FALSE(fusion.AreCompatible()); } { LoopFusion fusion(context.get(), loop_2, loop_3); EXPECT_FALSE(fusion.AreCompatible()); } } } /* Generated from the following GLSL + --eliminate-local-multi-store // 19 #version 440 core void main() { int[10] a; int[10] b; int[10] c; // Illegal, would create a backward loop-carried anti-dependence. for (int i = 0; i < 10; i++) { c[i] = a[i] + 1; } for (int i = 0; i < 10; i++) { a[i+1] = c[i] + 2; } } */ TEST_F(FusionIllegalTest, PositiveDistanceCreatedWAR) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %23 "c" OpName %25 "a" OpName %34 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %19 = OpTypeInt 32 0 %20 = OpConstant %19 10 %21 = OpTypeArray %6 %20 %22 = OpTypePointer Function %21 %29 = OpConstant %6 1 %47 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %23 = OpVariable %22 Function %25 = OpVariable %22 Function %34 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %52 = OpPhi %6 %9 %5 %33 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %52 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %27 = OpAccessChain %7 %25 %52 %28 = OpLoad %6 %27 %30 = OpIAdd %6 %28 %29 %31 = OpAccessChain %7 %23 %52 OpStore %31 %30 OpBranch %13 %13 = OpLabel %33 = OpIAdd %6 %52 %29 OpStore %8 %33 OpBranch %10 %12 = OpLabel OpStore %34 %9 OpBranch %35 %35 = OpLabel %53 = OpPhi %6 %9 %12 %51 %38 OpLoopMerge %37 %38 None OpBranch %39 %39 = OpLabel %41 = OpSLessThan %17 %53 %16 OpBranchConditional %41 %36 %37 %36 = OpLabel %43 = OpIAdd %6 %53 %29 %45 = OpAccessChain %7 %23 %53 %46 = OpLoad %6 %45 %48 = OpIAdd %6 %46 %47 %49 = OpAccessChain %7 %25 %43 OpStore %49 %48 OpBranch %38 %38 = OpLabel %51 = OpIAdd %6 %53 %29 OpStore %34 %51 OpBranch %35 %37 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_FALSE(fusion.IsLegal()); } } /* Generated from the following GLSL + --eliminate-local-multi-store // 21 #version 440 core void main() { int[10] a; int[10] b; int[10] c; // Illegal, would create a backward loop-carried anti-dependence. for (int i = 0; i < 10; i++) { a[i] = b[i] + 1; } for (int i = 0; i < 10; i++) { a[i+1] = c[i+1] + 2; } } */ TEST_F(FusionIllegalTest, PositiveDistanceCreatedWAW) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %23 "a" OpName %25 "b" OpName %34 "i" OpName %44 "c" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %19 = OpTypeInt 32 0 %20 = OpConstant %19 10 %21 = OpTypeArray %6 %20 %22 = OpTypePointer Function %21 %29 = OpConstant %6 1 %49 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %23 = OpVariable %22 Function %25 = OpVariable %22 Function %34 = OpVariable %7 Function %44 = OpVariable %22 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %54 = OpPhi %6 %9 %5 %33 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %54 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %27 = OpAccessChain %7 %25 %54 %28 = OpLoad %6 %27 %30 = OpIAdd %6 %28 %29 %31 = OpAccessChain %7 %23 %54 OpStore %31 %30 OpBranch %13 %13 = OpLabel %33 = OpIAdd %6 %54 %29 OpStore %8 %33 OpBranch %10 %12 = OpLabel OpStore %34 %9 OpBranch %35 %35 = OpLabel %55 = OpPhi %6 %9 %12 %53 %38 OpLoopMerge %37 %38 None OpBranch %39 %39 = OpLabel %41 = OpSLessThan %17 %55 %16 OpBranchConditional %41 %36 %37 %36 = OpLabel %43 = OpIAdd %6 %55 %29 %46 = OpIAdd %6 %55 %29 %47 = OpAccessChain %7 %44 %46 %48 = OpLoad %6 %47 %50 = OpIAdd %6 %48 %49 %51 = OpAccessChain %7 %23 %43 OpStore %51 %50 OpBranch %38 %38 = OpLabel %53 = OpIAdd %6 %55 %29 OpStore %34 %53 OpBranch %35 %37 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_FALSE(fusion.IsLegal()); } } /* Generated from the following GLSL + --eliminate-local-multi-store // 28 #version 440 core void main() { int[10] a; int[10] b; int sum_0 = 0; // Illegal for (int i = 0; i < 10; i++) { sum_0 += a[i]; } for (int j = 0; j < 10; j++) { sum_0 += b[j]; } } */ TEST_F(FusionIllegalTest, SameReductionVariable) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "sum_0" OpName %10 "i" OpName %24 "a" OpName %33 "j" OpName %41 "b" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %17 = OpConstant %6 10 %18 = OpTypeBool %20 = OpTypeInt 32 0 %21 = OpConstant %20 10 %22 = OpTypeArray %6 %21 %23 = OpTypePointer Function %22 %31 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %24 = OpVariable %23 Function %33 = OpVariable %7 Function %41 = OpVariable %23 Function OpStore %8 %9 OpStore %10 %9 OpBranch %11 %11 = OpLabel %52 = OpPhi %6 %9 %5 %29 %14 %49 = OpPhi %6 %9 %5 %32 %14 OpLoopMerge %13 %14 None OpBranch %15 %15 = OpLabel %19 = OpSLessThan %18 %49 %17 OpBranchConditional %19 %12 %13 %12 = OpLabel %26 = OpAccessChain %7 %24 %49 %27 = OpLoad %6 %26 %29 = OpIAdd %6 %52 %27 OpStore %8 %29 OpBranch %14 %14 = OpLabel %32 = OpIAdd %6 %49 %31 OpStore %10 %32 OpBranch %11 %13 = OpLabel OpStore %33 %9 OpBranch %34 %34 = OpLabel %51 = OpPhi %6 %52 %13 %46 %37 %50 = OpPhi %6 %9 %13 %48 %37 OpLoopMerge %36 %37 None OpBranch %38 %38 = OpLabel %40 = OpSLessThan %18 %50 %17 OpBranchConditional %40 %35 %36 %35 = OpLabel %43 = OpAccessChain %7 %41 %50 %44 = OpLoad %6 %43 %46 = OpIAdd %6 %51 %44 OpStore %8 %46 OpBranch %37 %37 = OpLabel %48 = OpIAdd %6 %50 %31 OpStore %33 %48 OpBranch %34 %36 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_FALSE(fusion.IsLegal()); } } /* Generated from the following GLSL + --eliminate-local-multi-store // 28 #version 440 core void main() { int[10] a; int[10] b; int sum_0 = 0; // Illegal for (int i = 0; i < 10; i++) { sum_0 += a[i]; } for (int j = 0; j < 10; j++) { sum_0 += b[j]; } } */ TEST_F(FusionIllegalTest, SameReductionVariableLCSSA) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "sum_0" OpName %10 "i" OpName %24 "a" OpName %33 "j" OpName %41 "b" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %17 = OpConstant %6 10 %18 = OpTypeBool %20 = OpTypeInt 32 0 %21 = OpConstant %20 10 %22 = OpTypeArray %6 %21 %23 = OpTypePointer Function %22 %31 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %24 = OpVariable %23 Function %33 = OpVariable %7 Function %41 = OpVariable %23 Function OpStore %8 %9 OpStore %10 %9 OpBranch %11 %11 = OpLabel %52 = OpPhi %6 %9 %5 %29 %14 %49 = OpPhi %6 %9 %5 %32 %14 OpLoopMerge %13 %14 None OpBranch %15 %15 = OpLabel %19 = OpSLessThan %18 %49 %17 OpBranchConditional %19 %12 %13 %12 = OpLabel %26 = OpAccessChain %7 %24 %49 %27 = OpLoad %6 %26 %29 = OpIAdd %6 %52 %27 OpStore %8 %29 OpBranch %14 %14 = OpLabel %32 = OpIAdd %6 %49 %31 OpStore %10 %32 OpBranch %11 %13 = OpLabel OpStore %33 %9 OpBranch %34 %34 = OpLabel %51 = OpPhi %6 %52 %13 %46 %37 %50 = OpPhi %6 %9 %13 %48 %37 OpLoopMerge %36 %37 None OpBranch %38 %38 = OpLabel %40 = OpSLessThan %18 %50 %17 OpBranchConditional %40 %35 %36 %35 = OpLabel %43 = OpAccessChain %7 %41 %50 %44 = OpLoad %6 %43 %46 = OpIAdd %6 %51 %44 OpStore %8 %46 OpBranch %37 %37 = OpLabel %48 = OpIAdd %6 %50 %31 OpStore %33 %48 OpBranch %34 %36 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopUtils utils_0(context.get(), loops[0]); utils_0.MakeLoopClosedSSA(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_FALSE(fusion.IsLegal()); } } /* Generated from the following GLSL + --eliminate-local-multi-store // 30 #version 440 core int x; void main() { int[10] a; int[10] b; // Illegal, x is unknown. for (int i = 0; i < 10; i++) { a[x] = a[i]; } for (int j = 0; j < 10; j++) { a[j] = b[j]; } } */ TEST_F(FusionIllegalTest, UnknownIndexVariable) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %23 "a" OpName %25 "x" OpName %34 "j" OpName %43 "b" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %19 = OpTypeInt 32 0 %20 = OpConstant %19 10 %21 = OpTypeArray %6 %20 %22 = OpTypePointer Function %21 %24 = OpTypePointer Private %6 %25 = OpVariable %24 Private %32 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %23 = OpVariable %22 Function %34 = OpVariable %7 Function %43 = OpVariable %22 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %50 = OpPhi %6 %9 %5 %33 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %50 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %26 = OpLoad %6 %25 %28 = OpAccessChain %7 %23 %50 %29 = OpLoad %6 %28 %30 = OpAccessChain %7 %23 %26 OpStore %30 %29 OpBranch %13 %13 = OpLabel %33 = OpIAdd %6 %50 %32 OpStore %8 %33 OpBranch %10 %12 = OpLabel OpStore %34 %9 OpBranch %35 %35 = OpLabel %51 = OpPhi %6 %9 %12 %49 %38 OpLoopMerge %37 %38 None OpBranch %39 %39 = OpLabel %41 = OpSLessThan %17 %51 %16 OpBranchConditional %41 %36 %37 %36 = OpLabel %45 = OpAccessChain %7 %43 %51 %46 = OpLoad %6 %45 %47 = OpAccessChain %7 %23 %51 OpStore %47 %46 OpBranch %38 %38 = OpLabel %49 = OpIAdd %6 %51 %32 OpStore %34 %49 OpBranch %35 %37 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_FALSE(fusion.IsLegal()); } } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core void main() { int[10] a; int[10] b; int sum = 0; // Illegal, accumulator used for indexing. for (int i = 0; i < 10; i++) { sum += a[i]; b[sum] = a[i]; } for (int j = 0; j < 10; j++) { b[j] = b[j]+1; } } */ TEST_F(FusionIllegalTest, AccumulatorIndexing) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "sum" OpName %10 "i" OpName %24 "a" OpName %30 "b" OpName %39 "j" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %17 = OpConstant %6 10 %18 = OpTypeBool %20 = OpTypeInt 32 0 %21 = OpConstant %20 10 %22 = OpTypeArray %6 %21 %23 = OpTypePointer Function %22 %37 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %24 = OpVariable %23 Function %30 = OpVariable %23 Function %39 = OpVariable %7 Function OpStore %8 %9 OpStore %10 %9 OpBranch %11 %11 = OpLabel %57 = OpPhi %6 %9 %5 %29 %14 %55 = OpPhi %6 %9 %5 %38 %14 OpLoopMerge %13 %14 None OpBranch %15 %15 = OpLabel %19 = OpSLessThan %18 %55 %17 OpBranchConditional %19 %12 %13 %12 = OpLabel %26 = OpAccessChain %7 %24 %55 %27 = OpLoad %6 %26 %29 = OpIAdd %6 %57 %27 OpStore %8 %29 %33 = OpAccessChain %7 %24 %55 %34 = OpLoad %6 %33 %35 = OpAccessChain %7 %30 %29 OpStore %35 %34 OpBranch %14 %14 = OpLabel %38 = OpIAdd %6 %55 %37 OpStore %10 %38 OpBranch %11 %13 = OpLabel OpStore %39 %9 OpBranch %40 %40 = OpLabel %56 = OpPhi %6 %9 %13 %54 %43 OpLoopMerge %42 %43 None OpBranch %44 %44 = OpLabel %46 = OpSLessThan %18 %56 %17 OpBranchConditional %46 %41 %42 %41 = OpLabel %49 = OpAccessChain %7 %30 %56 %50 = OpLoad %6 %49 %51 = OpIAdd %6 %50 %37 %52 = OpAccessChain %7 %30 %56 OpStore %52 %51 OpBranch %43 %43 = OpLabel %54 = OpIAdd %6 %56 %37 OpStore %39 %54 OpBranch %40 %42 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_FALSE(fusion.IsLegal()); } } /* Generated from the following GLSL + --eliminate-local-multi-store // 33 #version 440 core void main() { int[10] a; int[10] b; // Illegal, barrier. for (int i = 0; i < 10; i++) { a[i] = a[i] * 2; memoryBarrier(); } for (int j = 0; j < 10; j++) { b[j] = b[j] + 1; } } */ TEST_F(FusionIllegalTest, Barrier) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %23 "a" OpName %36 "j" OpName %44 "b" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %19 = OpTypeInt 32 0 %20 = OpConstant %19 10 %21 = OpTypeArray %6 %20 %22 = OpTypePointer Function %21 %28 = OpConstant %6 2 %31 = OpConstant %19 1 %32 = OpConstant %19 3400 %34 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %23 = OpVariable %22 Function %36 = OpVariable %7 Function %44 = OpVariable %22 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %53 = OpPhi %6 %9 %5 %35 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %53 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %26 = OpAccessChain %7 %23 %53 %27 = OpLoad %6 %26 %29 = OpIMul %6 %27 %28 %30 = OpAccessChain %7 %23 %53 OpStore %30 %29 OpMemoryBarrier %31 %32 OpBranch %13 %13 = OpLabel %35 = OpIAdd %6 %53 %34 OpStore %8 %35 OpBranch %10 %12 = OpLabel OpStore %36 %9 OpBranch %37 %37 = OpLabel %54 = OpPhi %6 %9 %12 %52 %40 OpLoopMerge %39 %40 None OpBranch %41 %41 = OpLabel %43 = OpSLessThan %17 %54 %16 OpBranchConditional %43 %38 %39 %38 = OpLabel %47 = OpAccessChain %7 %44 %54 %48 = OpLoad %6 %47 %49 = OpIAdd %6 %48 %34 %50 = OpAccessChain %7 %44 %54 OpStore %50 %49 OpBranch %40 %40 = OpLabel %52 = OpIAdd %6 %54 %34 OpStore %36 %52 OpBranch %37 %39 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_FALSE(fusion.IsLegal()); } } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core struct TestStruct { int[10] a; int b; }; void main() { TestStruct test_0; TestStruct test_1; for (int i = 0; i < 10; i++) { test_0.a[i] = i; } for (int j = 0; j < 10; j++) { test_0 = test_1; } } */ TEST_F(FusionIllegalTest, ArrayInStruct) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %22 "TestStruct" OpMemberName %22 0 "a" OpMemberName %22 1 "b" OpName %24 "test_0" OpName %31 "j" OpName %39 "test_1" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %19 = OpTypeInt 32 0 %20 = OpConstant %19 10 %21 = OpTypeArray %6 %20 %22 = OpTypeStruct %21 %6 %23 = OpTypePointer Function %22 %29 = OpConstant %6 1 %47 = OpUndef %22 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %24 = OpVariable %23 Function %31 = OpVariable %7 Function %39 = OpVariable %23 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %43 = OpPhi %6 %9 %5 %30 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %43 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %27 = OpAccessChain %7 %24 %9 %43 OpStore %27 %43 OpBranch %13 %13 = OpLabel %30 = OpIAdd %6 %43 %29 OpStore %8 %30 OpBranch %10 %12 = OpLabel OpStore %31 %9 OpBranch %32 %32 = OpLabel %44 = OpPhi %6 %9 %12 %42 %35 OpLoopMerge %34 %35 None OpBranch %36 %36 = OpLabel %38 = OpSLessThan %17 %44 %16 OpBranchConditional %38 %33 %34 %33 = OpLabel OpStore %24 %47 OpBranch %35 %35 = OpLabel %42 = OpIAdd %6 %44 %29 OpStore %31 %42 OpBranch %32 %34 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_FALSE(fusion.IsLegal()); } } /* Generated from the following GLSL + --eliminate-local-multi-store #version 450 struct P {float x,y,z;}; uniform G { int a; P b[2]; int c; } g; layout(location = 0) out float o; void main() { P p[2]; for (int i = 0; i < 2; ++i) { p = g.b; } for (int j = 0; j < 2; ++j) { o = p[g.a].x; } } */ TEST_F(FusionIllegalTest, NestedAccessChain) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %64 OpExecutionMode %4 OriginUpperLeft OpSource GLSL 450 OpName %4 "main" OpName %8 "i" OpName %20 "P" OpMemberName %20 0 "x" OpMemberName %20 1 "y" OpMemberName %20 2 "z" OpName %25 "p" OpName %26 "P" OpMemberName %26 0 "x" OpMemberName %26 1 "y" OpMemberName %26 2 "z" OpName %28 "G" OpMemberName %28 0 "a" OpMemberName %28 1 "b" OpMemberName %28 2 "c" OpName %30 "g" OpName %55 "j" OpName %64 "o" OpMemberDecorate %26 0 Offset 0 OpMemberDecorate %26 1 Offset 4 OpMemberDecorate %26 2 Offset 8 OpDecorate %27 ArrayStride 16 OpMemberDecorate %28 0 Offset 0 OpMemberDecorate %28 1 Offset 16 OpMemberDecorate %28 2 Offset 48 OpDecorate %28 Block OpDecorate %30 DescriptorSet 0 OpDecorate %64 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 2 %17 = OpTypeBool %19 = OpTypeFloat 32 %20 = OpTypeStruct %19 %19 %19 %21 = OpTypeInt 32 0 %22 = OpConstant %21 2 %23 = OpTypeArray %20 %22 %24 = OpTypePointer Function %23 %26 = OpTypeStruct %19 %19 %19 %27 = OpTypeArray %26 %22 %28 = OpTypeStruct %6 %27 %6 %29 = OpTypePointer Uniform %28 %30 = OpVariable %29 Uniform %31 = OpConstant %6 1 %32 = OpTypePointer Uniform %27 %36 = OpTypePointer Function %20 %39 = OpTypePointer Function %19 %63 = OpTypePointer Output %19 %64 = OpVariable %63 Output %65 = OpTypePointer Uniform %6 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %25 = OpVariable %24 Function %55 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %72 = OpPhi %6 %9 %5 %54 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %72 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %33 = OpAccessChain %32 %30 %31 %34 = OpLoad %27 %33 %35 = OpCompositeExtract %26 %34 0 %37 = OpAccessChain %36 %25 %9 %38 = OpCompositeExtract %19 %35 0 %40 = OpAccessChain %39 %37 %9 OpStore %40 %38 %41 = OpCompositeExtract %19 %35 1 %42 = OpAccessChain %39 %37 %31 OpStore %42 %41 %43 = OpCompositeExtract %19 %35 2 %44 = OpAccessChain %39 %37 %16 OpStore %44 %43 %45 = OpCompositeExtract %26 %34 1 %46 = OpAccessChain %36 %25 %31 %47 = OpCompositeExtract %19 %45 0 %48 = OpAccessChain %39 %46 %9 OpStore %48 %47 %49 = OpCompositeExtract %19 %45 1 %50 = OpAccessChain %39 %46 %31 OpStore %50 %49 %51 = OpCompositeExtract %19 %45 2 %52 = OpAccessChain %39 %46 %16 OpStore %52 %51 OpBranch %13 %13 = OpLabel %54 = OpIAdd %6 %72 %31 OpStore %8 %54 OpBranch %10 %12 = OpLabel OpStore %55 %9 OpBranch %56 %56 = OpLabel %73 = OpPhi %6 %9 %12 %71 %59 OpLoopMerge %58 %59 None OpBranch %60 %60 = OpLabel %62 = OpSLessThan %17 %73 %16 OpBranchConditional %62 %57 %58 %57 = OpLabel %66 = OpAccessChain %65 %30 %9 %67 = OpLoad %6 %66 %68 = OpAccessChain %39 %25 %67 %9 %69 = OpLoad %19 %68 OpStore %64 %69 OpBranch %59 %59 = OpLabel %71 = OpIAdd %6 %73 %31 OpStore %55 %71 OpBranch %56 %58 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_FALSE(fusion.IsLegal()); } } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/loop_optimizations/fusion_legal.cpp000066400000000000000000004131571475742701700274420ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "effcee/effcee.h" #include "gmock/gmock.h" #include "source/opt/loop_descriptor.h" #include "source/opt/loop_fusion.h" #include "test/opt/pass_fixture.h" namespace spvtools { namespace opt { namespace { using FusionLegalTest = PassTest<::testing::Test>; bool Validate(const std::vector& bin) { spv_target_env target_env = SPV_ENV_UNIVERSAL_1_2; spv_context spvContext = spvContextCreate(target_env); spv_diagnostic diagnostic = nullptr; spv_const_binary_t binary = {bin.data(), bin.size()}; spv_result_t error = spvValidate(spvContext, &binary, &diagnostic); if (error != 0) spvDiagnosticPrint(diagnostic); spvDiagnosticDestroy(diagnostic); spvContextDestroy(spvContext); return error == 0; } void Match(const std::string& checks, IRContext* context) { // Silence unused warnings with !defined(SPIRV_EFFCE) (void)checks; std::vector bin; context->module()->ToBinary(&bin, true); EXPECT_TRUE(Validate(bin)); std::string assembly; SpirvTools tools(SPV_ENV_UNIVERSAL_1_2); EXPECT_TRUE( tools.Disassemble(bin, &assembly, SPV_BINARY_TO_TEXT_OPTION_NO_HEADER)) << "Disassembling failed for shader:\n" << assembly << std::endl; auto match_result = effcee::Match(assembly, checks); EXPECT_EQ(effcee::Result::Status::Ok, match_result.status()) << match_result.message() << "\nChecking result:\n" << assembly; } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core void main() { int[10] a; int[10] b; // No dependence, legal for (int i = 0; i < 10; i++) { a[i] = a[i]*2; } for (int i = 0; i < 10; i++) { b[i] = b[i]+2; } } */ TEST_F(FusionLegalTest, DifferentArraysInLoops) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %23 "a" OpName %34 "i" OpName %42 "b" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %19 = OpTypeInt 32 0 %20 = OpConstant %19 10 %21 = OpTypeArray %6 %20 %22 = OpTypePointer Function %21 %28 = OpConstant %6 2 %32 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %23 = OpVariable %22 Function %34 = OpVariable %7 Function %42 = OpVariable %22 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %51 = OpPhi %6 %9 %5 %33 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %51 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %26 = OpAccessChain %7 %23 %51 %27 = OpLoad %6 %26 %29 = OpIMul %6 %27 %28 %30 = OpAccessChain %7 %23 %51 OpStore %30 %29 OpBranch %13 %13 = OpLabel %33 = OpIAdd %6 %51 %32 OpStore %8 %33 OpBranch %10 %12 = OpLabel OpStore %34 %9 OpBranch %35 %35 = OpLabel %52 = OpPhi %6 %9 %12 %50 %38 OpLoopMerge %37 %38 None OpBranch %39 %39 = OpLabel %41 = OpSLessThan %17 %52 %16 OpBranchConditional %41 %36 %37 %36 = OpLabel %45 = OpAccessChain %7 %42 %52 %46 = OpLoad %6 %45 %47 = OpIAdd %6 %46 %28 %48 = OpAccessChain %7 %42 %52 OpStore %48 %47 OpBranch %38 %38 = OpLabel %50 = OpIAdd %6 %52 %32 OpStore %34 %50 OpBranch %35 %37 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_TRUE(fusion.IsLegal()); fusion.Fuse(); std::string checks = R"( CHECK: [[PHI:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[LOAD_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_0]] CHECK: [[STORE_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpStore [[STORE_0]] CHECK-NOT: OpPhi CHECK: [[LOAD_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_1]] CHECK: [[STORE_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpStore [[STORE_1]] )"; Match(checks, context.get()); auto& ld_final = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld_final.NumLoops(), 1u); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core void main() { int[10] a; int[10] b; int[10] c; // Only loads to the same array, legal for (int i = 0; i < 10; i++) { b[i] = a[i]*2; } for (int i = 0; i < 10; i++) { c[i] = a[i]+2; } } */ TEST_F(FusionLegalTest, OnlyLoadsToSameArray) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %23 "b" OpName %25 "a" OpName %35 "i" OpName %43 "c" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %19 = OpTypeInt 32 0 %20 = OpConstant %19 10 %21 = OpTypeArray %6 %20 %22 = OpTypePointer Function %21 %29 = OpConstant %6 2 %33 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %23 = OpVariable %22 Function %25 = OpVariable %22 Function %35 = OpVariable %7 Function %43 = OpVariable %22 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %52 = OpPhi %6 %9 %5 %34 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %52 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %27 = OpAccessChain %7 %25 %52 %28 = OpLoad %6 %27 %30 = OpIMul %6 %28 %29 %31 = OpAccessChain %7 %23 %52 OpStore %31 %30 OpBranch %13 %13 = OpLabel %34 = OpIAdd %6 %52 %33 OpStore %8 %34 OpBranch %10 %12 = OpLabel OpStore %35 %9 OpBranch %36 %36 = OpLabel %53 = OpPhi %6 %9 %12 %51 %39 OpLoopMerge %38 %39 None OpBranch %40 %40 = OpLabel %42 = OpSLessThan %17 %53 %16 OpBranchConditional %42 %37 %38 %37 = OpLabel %46 = OpAccessChain %7 %25 %53 %47 = OpLoad %6 %46 %48 = OpIAdd %6 %47 %29 %49 = OpAccessChain %7 %43 %53 OpStore %49 %48 OpBranch %39 %39 = OpLabel %51 = OpIAdd %6 %53 %33 OpStore %35 %51 OpBranch %36 %38 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_TRUE(fusion.IsLegal()); fusion.Fuse(); std::string checks = R"( CHECK: [[PHI:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[LOAD_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_0]] CHECK: [[STORE_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpStore [[STORE_0]] CHECK-NOT: OpPhi CHECK: [[LOAD_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_1]] CHECK: [[STORE_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpStore [[STORE_1]] )"; Match(checks, context.get()); auto& ld_final = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld_final.NumLoops(), 1u); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core void main() { int[10] a; int[10] b; // No loop-carried dependences, legal for (int i = 0; i < 10; i++) { a[i] = a[i]*2; } for (int i = 0; i < 10; i++) { b[i] = a[i]+2; } } */ TEST_F(FusionLegalTest, NoLoopCarriedDependences) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %23 "a" OpName %34 "i" OpName %42 "b" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %19 = OpTypeInt 32 0 %20 = OpConstant %19 10 %21 = OpTypeArray %6 %20 %22 = OpTypePointer Function %21 %28 = OpConstant %6 2 %32 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %23 = OpVariable %22 Function %34 = OpVariable %7 Function %42 = OpVariable %22 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %51 = OpPhi %6 %9 %5 %33 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %51 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %26 = OpAccessChain %7 %23 %51 %27 = OpLoad %6 %26 %29 = OpIMul %6 %27 %28 %30 = OpAccessChain %7 %23 %51 OpStore %30 %29 OpBranch %13 %13 = OpLabel %33 = OpIAdd %6 %51 %32 OpStore %8 %33 OpBranch %10 %12 = OpLabel OpStore %34 %9 OpBranch %35 %35 = OpLabel %52 = OpPhi %6 %9 %12 %50 %38 OpLoopMerge %37 %38 None OpBranch %39 %39 = OpLabel %41 = OpSLessThan %17 %52 %16 OpBranchConditional %41 %36 %37 %36 = OpLabel %45 = OpAccessChain %7 %23 %52 %46 = OpLoad %6 %45 %47 = OpIAdd %6 %46 %28 %48 = OpAccessChain %7 %42 %52 OpStore %48 %47 OpBranch %38 %38 = OpLabel %50 = OpIAdd %6 %52 %32 OpStore %34 %50 OpBranch %35 %37 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_TRUE(fusion.IsLegal()); fusion.Fuse(); std::string checks = R"( CHECK: [[PHI:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[LOAD_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_0]] CHECK: [[STORE_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpStore [[STORE_0]] CHECK-NOT: OpPhi CHECK: [[LOAD_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_1]] CHECK: [[STORE_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpStore [[STORE_1]] )"; Match(checks, context.get()); auto& ld_final = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld_final.NumLoops(), 1u); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core void main() { int[10] a; int[10] b; int[10] c; // Parallelism inhibiting, but legal. for (int i = 0; i < 10; i++) { a[i] = b[i] + 1; } for (int i = 0; i < 10; i++) { c[i] = a[i] + c[i-1]; } } */ TEST_F(FusionLegalTest, ExistingLoopCarriedDependence) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %23 "a" OpName %25 "b" OpName %34 "i" OpName %42 "c" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %19 = OpTypeInt 32 0 %20 = OpConstant %19 10 %21 = OpTypeArray %6 %20 %22 = OpTypePointer Function %21 %29 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %23 = OpVariable %22 Function %25 = OpVariable %22 Function %34 = OpVariable %7 Function %42 = OpVariable %22 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %55 = OpPhi %6 %9 %5 %33 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %55 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %27 = OpAccessChain %7 %25 %55 %28 = OpLoad %6 %27 %30 = OpIAdd %6 %28 %29 %31 = OpAccessChain %7 %23 %55 OpStore %31 %30 OpBranch %13 %13 = OpLabel %33 = OpIAdd %6 %55 %29 OpStore %8 %33 OpBranch %10 %12 = OpLabel OpStore %34 %9 OpBranch %35 %35 = OpLabel %56 = OpPhi %6 %9 %12 %54 %38 OpLoopMerge %37 %38 None OpBranch %39 %39 = OpLabel %41 = OpSLessThan %17 %56 %16 OpBranchConditional %41 %36 %37 %36 = OpLabel %45 = OpAccessChain %7 %23 %56 %46 = OpLoad %6 %45 %48 = OpISub %6 %56 %29 %49 = OpAccessChain %7 %42 %48 %50 = OpLoad %6 %49 %51 = OpIAdd %6 %46 %50 %52 = OpAccessChain %7 %42 %56 OpStore %52 %51 OpBranch %38 %38 = OpLabel %54 = OpIAdd %6 %56 %29 OpStore %34 %54 OpBranch %35 %37 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_TRUE(fusion.IsLegal()); fusion.Fuse(); std::string checks = R"( CHECK: [[PHI:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[LOAD_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_0]] CHECK: [[STORE_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpStore [[STORE_0]] CHECK-NOT: OpPhi CHECK: [[LOAD_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_1]] CHECK: [[I_1:%\w+]] = OpISub {{%\w+}} [[PHI]] {{%\w+}} CHECK-NEXT: [[LOAD_2:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[I_1]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_2]] CHECK: [[STORE_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpStore [[STORE_1]] )"; Match(checks, context.get()); auto& ld_final = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld_final.NumLoops(), 1u); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core void main() { int[10] a; int[10] b; int[10] c; // Creates a loop-carried dependence, but negative, so legal for (int i = 0; i < 10; i++) { a[i+1] = b[i] + 1; } for (int i = 0; i < 10; i++) { c[i] = a[i] + 2; } } */ TEST_F(FusionLegalTest, NegativeDistanceCreatedRAW) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %23 "a" OpName %27 "b" OpName %35 "i" OpName %43 "c" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %19 = OpTypeInt 32 0 %20 = OpConstant %19 10 %21 = OpTypeArray %6 %20 %22 = OpTypePointer Function %21 %25 = OpConstant %6 1 %48 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %23 = OpVariable %22 Function %27 = OpVariable %22 Function %35 = OpVariable %7 Function %43 = OpVariable %22 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %53 = OpPhi %6 %9 %5 %34 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %53 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %26 = OpIAdd %6 %53 %25 %29 = OpAccessChain %7 %27 %53 %30 = OpLoad %6 %29 %31 = OpIAdd %6 %30 %25 %32 = OpAccessChain %7 %23 %26 OpStore %32 %31 OpBranch %13 %13 = OpLabel %34 = OpIAdd %6 %53 %25 OpStore %8 %34 OpBranch %10 %12 = OpLabel OpStore %35 %9 OpBranch %36 %36 = OpLabel %54 = OpPhi %6 %9 %12 %52 %39 OpLoopMerge %38 %39 None OpBranch %40 %40 = OpLabel %42 = OpSLessThan %17 %54 %16 OpBranchConditional %42 %37 %38 %37 = OpLabel %46 = OpAccessChain %7 %23 %54 %47 = OpLoad %6 %46 %49 = OpIAdd %6 %47 %48 %50 = OpAccessChain %7 %43 %54 OpStore %50 %49 OpBranch %39 %39 = OpLabel %52 = OpIAdd %6 %54 %25 OpStore %35 %52 OpBranch %36 %38 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_TRUE(fusion.IsLegal()); fusion.Fuse(); std::string checks = R"( CHECK: [[PHI:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[I_1:%\w+]] = OpIAdd {{%\w+}} [[PHI]] {{%\w+}} CHECK: [[LOAD_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_0]] CHECK: [[STORE_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[I_1]] CHECK-NEXT: OpStore [[STORE_0]] CHECK-NOT: OpPhi CHECK: [[LOAD_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_1]] CHECK: [[STORE_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpStore [[STORE_1]] )"; Match(checks, context.get()); } { auto& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 1u); } } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core void main() { int[10] a; int[10] b; int[10] c; // Legal for (int i = 0; i < 10; i++) { a[i+1] = b[i] + 1; } for (int i = 0; i < 10; i++) { c[i] = a[i+1] + 2; } } */ TEST_F(FusionLegalTest, NoLoopCarriedDependencesAdjustedIndex) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %23 "a" OpName %27 "b" OpName %35 "i" OpName %43 "c" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %19 = OpTypeInt 32 0 %20 = OpConstant %19 10 %21 = OpTypeArray %6 %20 %22 = OpTypePointer Function %21 %25 = OpConstant %6 1 %49 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %23 = OpVariable %22 Function %27 = OpVariable %22 Function %35 = OpVariable %7 Function %43 = OpVariable %22 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %54 = OpPhi %6 %9 %5 %34 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %54 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %26 = OpIAdd %6 %54 %25 %29 = OpAccessChain %7 %27 %54 %30 = OpLoad %6 %29 %31 = OpIAdd %6 %30 %25 %32 = OpAccessChain %7 %23 %26 OpStore %32 %31 OpBranch %13 %13 = OpLabel %34 = OpIAdd %6 %54 %25 OpStore %8 %34 OpBranch %10 %12 = OpLabel OpStore %35 %9 OpBranch %36 %36 = OpLabel %55 = OpPhi %6 %9 %12 %53 %39 OpLoopMerge %38 %39 None OpBranch %40 %40 = OpLabel %42 = OpSLessThan %17 %55 %16 OpBranchConditional %42 %37 %38 %37 = OpLabel %46 = OpIAdd %6 %55 %25 %47 = OpAccessChain %7 %23 %46 %48 = OpLoad %6 %47 %50 = OpIAdd %6 %48 %49 %51 = OpAccessChain %7 %43 %55 OpStore %51 %50 OpBranch %39 %39 = OpLabel %53 = OpIAdd %6 %55 %25 OpStore %35 %53 OpBranch %36 %38 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_TRUE(fusion.IsLegal()); fusion.Fuse(); std::string checks = R"( CHECK: [[PHI:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[I_1:%\w+]] = OpIAdd {{%\w+}} [[PHI]] {{%\w+}} CHECK: [[LOAD_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_0]] CHECK: [[STORE_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[I_1]] CHECK-NEXT: OpStore [[STORE_0]] CHECK-NOT: OpPhi CHECK: [[I_1:%\w+]] = OpIAdd {{%\w+}} [[PHI]] {{%\w+}} CHECK-NEXT: [[LOAD_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[I_1]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_1]] CHECK: [[STORE_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpStore [[STORE_1]] )"; Match(checks, context.get()); auto& ld_final = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld_final.NumLoops(), 1u); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core void main() { int[10] a; int[10] b; int[10] c; // Legal, independent locations in |a|, SIV for (int i = 0; i < 10; i++) { a[2*i+1] = b[i] + 1; } for (int i = 0; i < 10; i++) { c[i] = a[2*i] + 2; } } */ TEST_F(FusionLegalTest, IndependentSIV) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %23 "a" OpName %29 "b" OpName %37 "i" OpName %45 "c" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %19 = OpTypeInt 32 0 %20 = OpConstant %19 10 %21 = OpTypeArray %6 %20 %22 = OpTypePointer Function %21 %24 = OpConstant %6 2 %27 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %23 = OpVariable %22 Function %29 = OpVariable %22 Function %37 = OpVariable %7 Function %45 = OpVariable %22 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %55 = OpPhi %6 %9 %5 %36 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %55 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %26 = OpIMul %6 %24 %55 %28 = OpIAdd %6 %26 %27 %31 = OpAccessChain %7 %29 %55 %32 = OpLoad %6 %31 %33 = OpIAdd %6 %32 %27 %34 = OpAccessChain %7 %23 %28 OpStore %34 %33 OpBranch %13 %13 = OpLabel %36 = OpIAdd %6 %55 %27 OpStore %8 %36 OpBranch %10 %12 = OpLabel OpStore %37 %9 OpBranch %38 %38 = OpLabel %56 = OpPhi %6 %9 %12 %54 %41 OpLoopMerge %40 %41 None OpBranch %42 %42 = OpLabel %44 = OpSLessThan %17 %56 %16 OpBranchConditional %44 %39 %40 %39 = OpLabel %48 = OpIMul %6 %24 %56 %49 = OpAccessChain %7 %23 %48 %50 = OpLoad %6 %49 %51 = OpIAdd %6 %50 %24 %52 = OpAccessChain %7 %45 %56 OpStore %52 %51 OpBranch %41 %41 = OpLabel %54 = OpIAdd %6 %56 %27 OpStore %37 %54 OpBranch %38 %40 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_TRUE(fusion.IsLegal()); fusion.Fuse(); std::string checks = R"( CHECK: [[PHI:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[I_2:%\w+]] = OpIMul {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: [[I_2_1:%\w+]] = OpIAdd {{%\w+}} [[I_2]] {{%\w+}} CHECK: [[LOAD_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_0]] CHECK: [[STORE_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[I_2_1]] CHECK-NEXT: OpStore [[STORE_0]] CHECK-NOT: OpPhi CHECK: [[I_2:%\w+]] = OpIMul {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: [[LOAD_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[I_2]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_1]] CHECK: [[STORE_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpStore [[STORE_1]] )"; Match(checks, context.get()); auto& ld_final = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld_final.NumLoops(), 1u); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core void main() { int[10] a; int[10] b; int[10] c; // Legal, independent locations in |a|, ZIV for (int i = 0; i < 10; i++) { a[1] = b[i] + 1; } for (int i = 0; i < 10; i++) { c[i] = a[9] + 2; } } */ TEST_F(FusionLegalTest, IndependentZIV) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %23 "a" OpName %25 "b" OpName %33 "i" OpName %41 "c" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %19 = OpTypeInt 32 0 %20 = OpConstant %19 10 %21 = OpTypeArray %6 %20 %22 = OpTypePointer Function %21 %24 = OpConstant %6 1 %43 = OpConstant %6 9 %46 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %23 = OpVariable %22 Function %25 = OpVariable %22 Function %33 = OpVariable %7 Function %41 = OpVariable %22 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %51 = OpPhi %6 %9 %5 %32 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %51 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %27 = OpAccessChain %7 %25 %51 %28 = OpLoad %6 %27 %29 = OpIAdd %6 %28 %24 %30 = OpAccessChain %7 %23 %24 OpStore %30 %29 OpBranch %13 %13 = OpLabel %32 = OpIAdd %6 %51 %24 OpStore %8 %32 OpBranch %10 %12 = OpLabel OpStore %33 %9 OpBranch %34 %34 = OpLabel %52 = OpPhi %6 %9 %12 %50 %37 OpLoopMerge %36 %37 None OpBranch %38 %38 = OpLabel %40 = OpSLessThan %17 %52 %16 OpBranchConditional %40 %35 %36 %35 = OpLabel %44 = OpAccessChain %7 %23 %43 %45 = OpLoad %6 %44 %47 = OpIAdd %6 %45 %46 %48 = OpAccessChain %7 %41 %52 OpStore %48 %47 OpBranch %37 %37 = OpLabel %50 = OpIAdd %6 %52 %24 OpStore %33 %50 OpBranch %34 %36 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_TRUE(fusion.IsLegal()); fusion.Fuse(); std::string checks = R"( CHECK: [[PHI:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[LOAD_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_0]] CHECK-NOT: OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK: OpStore CHECK-NOT: OpPhi CHECK-NOT: OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK: OpLoad CHECK: [[STORE_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpStore [[STORE_1]] )"; Match(checks, context.get()); auto& ld_final = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld_final.NumLoops(), 1u); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core void main() { int[20] a; int[10] b; int[10] c; // Legal, non-overlapping sections in |a| for (int i = 0; i < 10; i++) { a[i] = b[i] + 1; } for (int i = 0; i < 10; i++) { c[i] = a[i+10] + 2; } } */ TEST_F(FusionLegalTest, NonOverlappingAccesses) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %23 "a" OpName %28 "b" OpName %37 "i" OpName %45 "c" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %19 = OpTypeInt 32 0 %20 = OpConstant %19 20 %21 = OpTypeArray %6 %20 %22 = OpTypePointer Function %21 %25 = OpConstant %19 10 %26 = OpTypeArray %6 %25 %27 = OpTypePointer Function %26 %32 = OpConstant %6 1 %51 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %23 = OpVariable %22 Function %28 = OpVariable %27 Function %37 = OpVariable %7 Function %45 = OpVariable %27 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %56 = OpPhi %6 %9 %5 %36 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %56 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %30 = OpAccessChain %7 %28 %56 %31 = OpLoad %6 %30 %33 = OpIAdd %6 %31 %32 %34 = OpAccessChain %7 %23 %56 OpStore %34 %33 OpBranch %13 %13 = OpLabel %36 = OpIAdd %6 %56 %32 OpStore %8 %36 OpBranch %10 %12 = OpLabel OpStore %37 %9 OpBranch %38 %38 = OpLabel %57 = OpPhi %6 %9 %12 %55 %41 OpLoopMerge %40 %41 None OpBranch %42 %42 = OpLabel %44 = OpSLessThan %17 %57 %16 OpBranchConditional %44 %39 %40 %39 = OpLabel %48 = OpIAdd %6 %57 %16 %49 = OpAccessChain %7 %23 %48 %50 = OpLoad %6 %49 %52 = OpIAdd %6 %50 %51 %53 = OpAccessChain %7 %45 %57 OpStore %53 %52 OpBranch %41 %41 = OpLabel %55 = OpIAdd %6 %57 %32 OpStore %37 %55 OpBranch %38 %40 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_TRUE(fusion.IsLegal()); fusion.Fuse(); std::string checks = R"( CHECK: [[PHI:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[LOAD_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_0]] CHECK: [[STORE_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NOT: OpPhi CHECK: [[I_10:%\w+]] = OpIAdd {{%\w+}} [[PHI]] {{%\w+}} CHECK-NEXT: [[LOAD_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[I_10]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_1]] CHECK: [[STORE_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpStore [[STORE_1]] )"; Match(checks, context.get()); auto& ld_final = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld_final.NumLoops(), 1u); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core void main() { int[10] a; int[10] b; int[10] c; // Legal, 3 adjacent loops for (int i = 0; i < 10; i++) { a[i] = b[i] + 1; } for (int i = 0; i < 10; i++) { c[i] = a[i] + 2; } for (int i = 0; i < 10; i++) { b[i] = c[i] + 10; } } */ TEST_F(FusionLegalTest, AdjacentLoops) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %23 "a" OpName %25 "b" OpName %34 "i" OpName %42 "c" OpName %52 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %19 = OpTypeInt 32 0 %20 = OpConstant %19 10 %21 = OpTypeArray %6 %20 %22 = OpTypePointer Function %21 %29 = OpConstant %6 1 %47 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %23 = OpVariable %22 Function %25 = OpVariable %22 Function %34 = OpVariable %7 Function %42 = OpVariable %22 Function %52 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %68 = OpPhi %6 %9 %5 %33 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %68 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %27 = OpAccessChain %7 %25 %68 %28 = OpLoad %6 %27 %30 = OpIAdd %6 %28 %29 %31 = OpAccessChain %7 %23 %68 OpStore %31 %30 OpBranch %13 %13 = OpLabel %33 = OpIAdd %6 %68 %29 OpStore %8 %33 OpBranch %10 %12 = OpLabel OpStore %34 %9 OpBranch %35 %35 = OpLabel %69 = OpPhi %6 %9 %12 %51 %38 OpLoopMerge %37 %38 None OpBranch %39 %39 = OpLabel %41 = OpSLessThan %17 %69 %16 OpBranchConditional %41 %36 %37 %36 = OpLabel %45 = OpAccessChain %7 %23 %69 %46 = OpLoad %6 %45 %48 = OpIAdd %6 %46 %47 %49 = OpAccessChain %7 %42 %69 OpStore %49 %48 OpBranch %38 %38 = OpLabel %51 = OpIAdd %6 %69 %29 OpStore %34 %51 OpBranch %35 %37 = OpLabel OpStore %52 %9 OpBranch %53 %53 = OpLabel %70 = OpPhi %6 %9 %37 %67 %56 OpLoopMerge %55 %56 None OpBranch %57 %57 = OpLabel %59 = OpSLessThan %17 %70 %16 OpBranchConditional %59 %54 %55 %54 = OpLabel %62 = OpAccessChain %7 %42 %70 %63 = OpLoad %6 %62 %64 = OpIAdd %6 %63 %16 %65 = OpAccessChain %7 %25 %70 OpStore %65 %64 OpBranch %56 %56 = OpLabel %67 = OpIAdd %6 %70 %29 OpStore %52 %67 OpBranch %53 %55 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 3u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[1], loops[2]); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_TRUE(fusion.IsLegal()); fusion.Fuse(); } std::string checks = R"( CHECK: [[PHI_0:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[LOAD_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_0]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_0]] CHECK: [[STORE_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_0]] CHECK-NEXT: OpStore [[STORE_0]] CHECK: [[PHI_1:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[LOAD_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_1]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_1]] CHECK: [[STORE_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_1]] CHECK-NEXT: OpStore [[STORE_1]] CHECK-NOT: OpPhi CHECK: [[LOAD_2:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_1]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_2]] CHECK: [[STORE_2:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_1]] CHECK-NEXT: OpStore [[STORE_2]] )"; Match(checks, context.get()); { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_TRUE(fusion.IsLegal()); fusion.Fuse(); } std::string checks_ = R"( CHECK: [[PHI:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[LOAD_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_0]] CHECK: [[STORE_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpStore [[STORE_0]] CHECK-NOT: OpPhi CHECK: [[LOAD_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_1]] CHECK: [[STORE_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpStore [[STORE_1]] CHECK-NOT: OpPhi CHECK: [[LOAD_2:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_2]] CHECK: [[STORE_2:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpStore [[STORE_2]] )"; Match(checks_, context.get()); auto& ld_final = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld_final.NumLoops(), 1u); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core void main() { int[10][10] a; int[10][10] b; int[10][10] c; // Legal inner loop fusion for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { c[i][j] = a[i][j] + 2; } for (int j = 0; j < 10; j++) { b[i][j] = c[i][j] + 10; } } } */ TEST_F(FusionLegalTest, InnerLoopFusion) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %19 "j" OpName %32 "c" OpName %35 "a" OpName %46 "j" OpName %54 "b" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %27 = OpTypeInt 32 0 %28 = OpConstant %27 10 %29 = OpTypeArray %6 %28 %30 = OpTypeArray %29 %28 %31 = OpTypePointer Function %30 %40 = OpConstant %6 2 %44 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %19 = OpVariable %7 Function %32 = OpVariable %31 Function %35 = OpVariable %31 Function %46 = OpVariable %7 Function %54 = OpVariable %31 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %67 = OpPhi %6 %9 %5 %66 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %67 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel OpStore %19 %9 OpBranch %20 %20 = OpLabel %68 = OpPhi %6 %9 %11 %45 %23 OpLoopMerge %22 %23 None OpBranch %24 %24 = OpLabel %26 = OpSLessThan %17 %68 %16 OpBranchConditional %26 %21 %22 %21 = OpLabel %38 = OpAccessChain %7 %35 %67 %68 %39 = OpLoad %6 %38 %41 = OpIAdd %6 %39 %40 %42 = OpAccessChain %7 %32 %67 %68 OpStore %42 %41 OpBranch %23 %23 = OpLabel %45 = OpIAdd %6 %68 %44 OpStore %19 %45 OpBranch %20 %22 = OpLabel OpStore %46 %9 OpBranch %47 %47 = OpLabel %69 = OpPhi %6 %9 %22 %64 %50 OpLoopMerge %49 %50 None OpBranch %51 %51 = OpLabel %53 = OpSLessThan %17 %69 %16 OpBranchConditional %53 %48 %49 %48 = OpLabel %59 = OpAccessChain %7 %32 %67 %69 %60 = OpLoad %6 %59 %61 = OpIAdd %6 %60 %16 %62 = OpAccessChain %7 %54 %67 %69 OpStore %62 %61 OpBranch %50 %50 = OpLabel %64 = OpIAdd %6 %69 %44 OpStore %46 %64 OpBranch %47 %49 = OpLabel OpBranch %13 %13 = OpLabel %66 = OpIAdd %6 %67 %44 OpStore %8 %66 OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 3u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); auto loop_0 = loops[0]; auto loop_1 = loops[1]; auto loop_2 = loops[2]; { LoopFusion fusion(context.get(), loop_0, loop_1); EXPECT_FALSE(fusion.AreCompatible()); } { LoopFusion fusion(context.get(), loop_0, loop_2); EXPECT_FALSE(fusion.AreCompatible()); } { LoopFusion fusion(context.get(), loop_1, loop_2); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_TRUE(fusion.IsLegal()); fusion.Fuse(); } std::string checks = R"( CHECK: [[PHI_0:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[PHI_1:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[LOAD_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_0]] [[PHI_1]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_0]] CHECK: [[STORE_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_0]] [[PHI_1]] CHECK-NEXT: OpStore [[STORE_0]] CHECK-NOT: OpPhi CHECK: [[LOAD_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_0]] [[PHI_1]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_1]] CHECK: [[STORE_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_0]] [[PHI_1]] CHECK-NEXT: OpStore [[STORE_1]] )"; Match(checks, context.get()); auto& ld_final = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld_final.NumLoops(), 2u); } /* Generated from the following GLSL + --eliminate-local-multi-store // 12 #version 440 core void main() { int[10][10] a; int[10][10] b; int[10][10] c; // Legal both for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { c[i][j] = a[i][j] + 2; } } for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { b[i][j] = c[i][j] + 10; } } } */ TEST_F(FusionLegalTest, OuterAndInnerLoop) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %19 "j" OpName %32 "c" OpName %35 "a" OpName %48 "i" OpName %56 "j" OpName %64 "b" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %27 = OpTypeInt 32 0 %28 = OpConstant %27 10 %29 = OpTypeArray %6 %28 %30 = OpTypeArray %29 %28 %31 = OpTypePointer Function %30 %40 = OpConstant %6 2 %44 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %19 = OpVariable %7 Function %32 = OpVariable %31 Function %35 = OpVariable %31 Function %48 = OpVariable %7 Function %56 = OpVariable %7 Function %64 = OpVariable %31 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %77 = OpPhi %6 %9 %5 %47 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %77 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel OpStore %19 %9 OpBranch %20 %20 = OpLabel %81 = OpPhi %6 %9 %11 %45 %23 OpLoopMerge %22 %23 None OpBranch %24 %24 = OpLabel %26 = OpSLessThan %17 %81 %16 OpBranchConditional %26 %21 %22 %21 = OpLabel %38 = OpAccessChain %7 %35 %77 %81 %39 = OpLoad %6 %38 %41 = OpIAdd %6 %39 %40 %42 = OpAccessChain %7 %32 %77 %81 OpStore %42 %41 OpBranch %23 %23 = OpLabel %45 = OpIAdd %6 %81 %44 OpStore %19 %45 OpBranch %20 %22 = OpLabel OpBranch %13 %13 = OpLabel %47 = OpIAdd %6 %77 %44 OpStore %8 %47 OpBranch %10 %12 = OpLabel OpStore %48 %9 OpBranch %49 %49 = OpLabel %78 = OpPhi %6 %9 %12 %76 %52 OpLoopMerge %51 %52 None OpBranch %53 %53 = OpLabel %55 = OpSLessThan %17 %78 %16 OpBranchConditional %55 %50 %51 %50 = OpLabel OpStore %56 %9 OpBranch %57 %57 = OpLabel %79 = OpPhi %6 %9 %50 %74 %60 OpLoopMerge %59 %60 None OpBranch %61 %61 = OpLabel %63 = OpSLessThan %17 %79 %16 OpBranchConditional %63 %58 %59 %58 = OpLabel %69 = OpAccessChain %7 %32 %78 %79 %70 = OpLoad %6 %69 %71 = OpIAdd %6 %70 %16 %72 = OpAccessChain %7 %64 %78 %79 OpStore %72 %71 OpBranch %60 %60 = OpLabel %74 = OpIAdd %6 %79 %44 OpStore %56 %74 OpBranch %57 %59 = OpLabel OpBranch %52 %52 = OpLabel %76 = OpIAdd %6 %78 %44 OpStore %48 %76 OpBranch %49 %51 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 4u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); auto loop_0 = loops[0]; auto loop_1 = loops[1]; auto loop_2 = loops[2]; auto loop_3 = loops[3]; { LoopFusion fusion(context.get(), loop_0, loop_1); EXPECT_FALSE(fusion.AreCompatible()); } { LoopFusion fusion(context.get(), loop_1, loop_2); EXPECT_FALSE(fusion.AreCompatible()); } { LoopFusion fusion(context.get(), loop_2, loop_3); EXPECT_FALSE(fusion.AreCompatible()); } { LoopFusion fusion(context.get(), loop_1, loop_3); EXPECT_FALSE(fusion.AreCompatible()); } { LoopFusion fusion(context.get(), loop_0, loop_2); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_TRUE(fusion.IsLegal()); fusion.Fuse(); } std::string checks = R"( CHECK: [[PHI_0:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[PHI_1:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[LOAD_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_0]] [[PHI_1]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_0]] CHECK: [[STORE_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_0]] [[PHI_1]] CHECK-NEXT: OpStore [[STORE_0]] CHECK: [[PHI_2:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK-NOT: OpPhi CHECK: [[LOAD_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_0]] [[PHI_2]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_1]] CHECK: [[STORE_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_0]] [[PHI_2]] CHECK-NEXT: OpStore [[STORE_1]] )"; Match(checks, context.get()); } { auto& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 3u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); auto loop_0 = loops[0]; auto loop_1 = loops[1]; auto loop_2 = loops[2]; { LoopFusion fusion(context.get(), loop_0, loop_1); EXPECT_FALSE(fusion.AreCompatible()); } { LoopFusion fusion(context.get(), loop_0, loop_2); EXPECT_FALSE(fusion.AreCompatible()); } { LoopFusion fusion(context.get(), loop_1, loop_2); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_TRUE(fusion.IsLegal()); fusion.Fuse(); } std::string checks = R"( CHECK: [[PHI_0:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[PHI_1:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[LOAD_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_0]] [[PHI_1]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_0]] CHECK: [[STORE_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_0]] [[PHI_1]] CHECK-NEXT: OpStore [[STORE_0]] CHECK-NOT: OpPhi CHECK: [[LOAD_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_0]] [[PHI_1]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_1]] CHECK: [[STORE_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_0]] [[PHI_1]] CHECK-NEXT: OpStore [[STORE_1]] )"; Match(checks, context.get()); } { auto& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); } } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core void main() { int[10][10] a; int[10][10] b; int[10][10] c; // Legal both, more complex for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { if (i % 2 == 0 && j % 2 == 0) { c[i][j] = a[i][j] + 2; } } } for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { b[i][j] = c[i][j] + 10; } } } */ TEST_F(FusionLegalTest, OuterAndInnerLoopMoreComplex) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %19 "j" OpName %44 "c" OpName %47 "a" OpName %59 "i" OpName %67 "j" OpName %75 "b" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %28 = OpConstant %6 2 %39 = OpTypeInt 32 0 %40 = OpConstant %39 10 %41 = OpTypeArray %6 %40 %42 = OpTypeArray %41 %40 %43 = OpTypePointer Function %42 %55 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %19 = OpVariable %7 Function %44 = OpVariable %43 Function %47 = OpVariable %43 Function %59 = OpVariable %7 Function %67 = OpVariable %7 Function %75 = OpVariable %43 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %88 = OpPhi %6 %9 %5 %58 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %88 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel OpStore %19 %9 OpBranch %20 %20 = OpLabel %92 = OpPhi %6 %9 %11 %56 %23 OpLoopMerge %22 %23 None OpBranch %24 %24 = OpLabel %26 = OpSLessThan %17 %92 %16 OpBranchConditional %26 %21 %22 %21 = OpLabel %29 = OpSMod %6 %88 %28 %30 = OpIEqual %17 %29 %9 OpSelectionMerge %32 None OpBranchConditional %30 %31 %32 %31 = OpLabel %34 = OpSMod %6 %92 %28 %35 = OpIEqual %17 %34 %9 OpBranch %32 %32 = OpLabel %36 = OpPhi %17 %30 %21 %35 %31 OpSelectionMerge %38 None OpBranchConditional %36 %37 %38 %37 = OpLabel %50 = OpAccessChain %7 %47 %88 %92 %51 = OpLoad %6 %50 %52 = OpIAdd %6 %51 %28 %53 = OpAccessChain %7 %44 %88 %92 OpStore %53 %52 OpBranch %38 %38 = OpLabel OpBranch %23 %23 = OpLabel %56 = OpIAdd %6 %92 %55 OpStore %19 %56 OpBranch %20 %22 = OpLabel OpBranch %13 %13 = OpLabel %58 = OpIAdd %6 %88 %55 OpStore %8 %58 OpBranch %10 %12 = OpLabel OpStore %59 %9 OpBranch %60 %60 = OpLabel %89 = OpPhi %6 %9 %12 %87 %63 OpLoopMerge %62 %63 None OpBranch %64 %64 = OpLabel %66 = OpSLessThan %17 %89 %16 OpBranchConditional %66 %61 %62 %61 = OpLabel OpStore %67 %9 OpBranch %68 %68 = OpLabel %90 = OpPhi %6 %9 %61 %85 %71 OpLoopMerge %70 %71 None OpBranch %72 %72 = OpLabel %74 = OpSLessThan %17 %90 %16 OpBranchConditional %74 %69 %70 %69 = OpLabel %80 = OpAccessChain %7 %44 %89 %90 %81 = OpLoad %6 %80 %82 = OpIAdd %6 %81 %16 %83 = OpAccessChain %7 %75 %89 %90 OpStore %83 %82 OpBranch %71 %71 = OpLabel %85 = OpIAdd %6 %90 %55 OpStore %67 %85 OpBranch %68 %70 = OpLabel OpBranch %63 %63 = OpLabel %87 = OpIAdd %6 %89 %55 OpStore %59 %87 OpBranch %60 %62 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 4u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); auto loop_0 = loops[0]; auto loop_1 = loops[1]; auto loop_2 = loops[2]; auto loop_3 = loops[3]; { LoopFusion fusion(context.get(), loop_0, loop_1); EXPECT_FALSE(fusion.AreCompatible()); } { LoopFusion fusion(context.get(), loop_1, loop_2); EXPECT_FALSE(fusion.AreCompatible()); } { LoopFusion fusion(context.get(), loop_2, loop_3); EXPECT_FALSE(fusion.AreCompatible()); } { LoopFusion fusion(context.get(), loop_1, loop_3); EXPECT_FALSE(fusion.AreCompatible()); } { LoopFusion fusion(context.get(), loop_0, loop_2); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_TRUE(fusion.IsLegal()); fusion.Fuse(); } std::string checks = R"( CHECK: [[PHI_0:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[PHI_1:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: OpPhi CHECK-NEXT: OpSelectionMerge CHECK: [[LOAD_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_0]] [[PHI_1]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_0]] CHECK: [[STORE_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_0]] [[PHI_1]] CHECK-NEXT: OpStore [[STORE_0]] CHECK: [[PHI_2:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK-NOT: OpPhi CHECK: [[LOAD_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_0]] [[PHI_2]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_1]] CHECK: [[STORE_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_0]] [[PHI_2]] CHECK-NEXT: OpStore [[STORE_1]] )"; Match(checks, context.get()); } { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 3u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); auto loop_0 = loops[0]; auto loop_1 = loops[1]; auto loop_2 = loops[2]; { LoopFusion fusion(context.get(), loop_0, loop_1); EXPECT_FALSE(fusion.AreCompatible()); } { LoopFusion fusion(context.get(), loop_0, loop_2); EXPECT_FALSE(fusion.AreCompatible()); } { LoopFusion fusion(context.get(), loop_1, loop_2); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_TRUE(fusion.IsLegal()); fusion.Fuse(); } std::string checks = R"( CHECK: [[PHI_0:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[PHI_1:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: OpPhi CHECK-NEXT: OpSelectionMerge CHECK: [[LOAD_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_0]] [[PHI_1]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_0]] CHECK: [[STORE_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_0]] [[PHI_1]] CHECK-NEXT: OpStore [[STORE_0]] CHECK-NOT: OpPhi CHECK: [[LOAD_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_0]] [[PHI_1]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_1]] CHECK: [[STORE_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_0]] [[PHI_1]] CHECK-NEXT: OpStore [[STORE_1]] )"; Match(checks, context.get()); } { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); } } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core void main() { int[10][10] a; int[10][10] b; int[10][10] c; // Outer would have been illegal to fuse, but since written // like this, inner loop fusion is legal. for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { c[i][j] = a[i][j] + 2; } for (int j = 0; j < 10; j++) { b[i][j] = c[i+1][j] + 10; } } } */ TEST_F(FusionLegalTest, InnerWithExistingDependenceOnOuter) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %19 "j" OpName %32 "c" OpName %35 "a" OpName %46 "j" OpName %54 "b" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %27 = OpTypeInt 32 0 %28 = OpConstant %27 10 %29 = OpTypeArray %6 %28 %30 = OpTypeArray %29 %28 %31 = OpTypePointer Function %30 %40 = OpConstant %6 2 %44 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %19 = OpVariable %7 Function %32 = OpVariable %31 Function %35 = OpVariable %31 Function %46 = OpVariable %7 Function %54 = OpVariable %31 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %68 = OpPhi %6 %9 %5 %67 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %68 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel OpStore %19 %9 OpBranch %20 %20 = OpLabel %69 = OpPhi %6 %9 %11 %45 %23 OpLoopMerge %22 %23 None OpBranch %24 %24 = OpLabel %26 = OpSLessThan %17 %69 %16 OpBranchConditional %26 %21 %22 %21 = OpLabel %38 = OpAccessChain %7 %35 %68 %69 %39 = OpLoad %6 %38 %41 = OpIAdd %6 %39 %40 %42 = OpAccessChain %7 %32 %68 %69 OpStore %42 %41 OpBranch %23 %23 = OpLabel %45 = OpIAdd %6 %69 %44 OpStore %19 %45 OpBranch %20 %22 = OpLabel OpStore %46 %9 OpBranch %47 %47 = OpLabel %70 = OpPhi %6 %9 %22 %65 %50 OpLoopMerge %49 %50 None OpBranch %51 %51 = OpLabel %53 = OpSLessThan %17 %70 %16 OpBranchConditional %53 %48 %49 %48 = OpLabel %58 = OpIAdd %6 %68 %44 %60 = OpAccessChain %7 %32 %58 %70 %61 = OpLoad %6 %60 %62 = OpIAdd %6 %61 %16 %63 = OpAccessChain %7 %54 %68 %70 OpStore %63 %62 OpBranch %50 %50 = OpLabel %65 = OpIAdd %6 %70 %44 OpStore %46 %65 OpBranch %47 %49 = OpLabel OpBranch %13 %13 = OpLabel %67 = OpIAdd %6 %68 %44 OpStore %8 %67 OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 3u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); auto loop_0 = loops[0]; auto loop_1 = loops[1]; auto loop_2 = loops[2]; { LoopFusion fusion(context.get(), loop_0, loop_1); EXPECT_FALSE(fusion.AreCompatible()); } { LoopFusion fusion(context.get(), loop_0, loop_2); EXPECT_FALSE(fusion.AreCompatible()); } { LoopFusion fusion(context.get(), loop_1, loop_2); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_TRUE(fusion.IsLegal()); fusion.Fuse(); } } { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); std::string checks = R"( CHECK: [[PHI_0:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[PHI_1:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[LOAD_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_0]] [[PHI_1]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_0]] CHECK: [[STORE_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_0]] [[PHI_1]] CHECK-NEXT: OpStore [[STORE_0]] CHECK-NOT: OpPhi CHECK: [[I_1:%\w+]] = OpIAdd {{%\w+}} [[PHI_0]] {{%\w+}} CHECK: [[LOAD_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[I_1]] [[PHI_1]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_1]] CHECK: [[STORE_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_0]] [[PHI_1]] CHECK-NEXT: OpStore [[STORE_1]] )"; Match(checks, context.get()); } } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core void main() { int[10] a; int[10] b; int[10] c; // One dimensional arrays. Legal, outer dist 0, inner independent. for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { c[i] = a[j] + 2; } } for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { b[j] = c[i] + 10; } } } */ TEST_F(FusionLegalTest, OuterAndInnerLoopOneDimArrays) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %19 "j" OpName %31 "c" OpName %33 "a" OpName %45 "i" OpName %53 "j" OpName %61 "b" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %27 = OpTypeInt 32 0 %28 = OpConstant %27 10 %29 = OpTypeArray %6 %28 %30 = OpTypePointer Function %29 %37 = OpConstant %6 2 %41 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %19 = OpVariable %7 Function %31 = OpVariable %30 Function %33 = OpVariable %30 Function %45 = OpVariable %7 Function %53 = OpVariable %7 Function %61 = OpVariable %30 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %72 = OpPhi %6 %9 %5 %44 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %72 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel OpStore %19 %9 OpBranch %20 %20 = OpLabel %76 = OpPhi %6 %9 %11 %42 %23 OpLoopMerge %22 %23 None OpBranch %24 %24 = OpLabel %26 = OpSLessThan %17 %76 %16 OpBranchConditional %26 %21 %22 %21 = OpLabel %35 = OpAccessChain %7 %33 %76 %36 = OpLoad %6 %35 %38 = OpIAdd %6 %36 %37 %39 = OpAccessChain %7 %31 %72 OpStore %39 %38 OpBranch %23 %23 = OpLabel %42 = OpIAdd %6 %76 %41 OpStore %19 %42 OpBranch %20 %22 = OpLabel OpBranch %13 %13 = OpLabel %44 = OpIAdd %6 %72 %41 OpStore %8 %44 OpBranch %10 %12 = OpLabel OpStore %45 %9 OpBranch %46 %46 = OpLabel %73 = OpPhi %6 %9 %12 %71 %49 OpLoopMerge %48 %49 None OpBranch %50 %50 = OpLabel %52 = OpSLessThan %17 %73 %16 OpBranchConditional %52 %47 %48 %47 = OpLabel OpStore %53 %9 OpBranch %54 %54 = OpLabel %74 = OpPhi %6 %9 %47 %69 %57 OpLoopMerge %56 %57 None OpBranch %58 %58 = OpLabel %60 = OpSLessThan %17 %74 %16 OpBranchConditional %60 %55 %56 %55 = OpLabel %64 = OpAccessChain %7 %31 %73 %65 = OpLoad %6 %64 %66 = OpIAdd %6 %65 %16 %67 = OpAccessChain %7 %61 %74 OpStore %67 %66 OpBranch %57 %57 = OpLabel %69 = OpIAdd %6 %74 %41 OpStore %53 %69 OpBranch %54 %56 = OpLabel OpBranch %49 %49 = OpLabel %71 = OpIAdd %6 %73 %41 OpStore %45 %71 OpBranch %46 %48 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 4u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); auto loop_0 = loops[0]; auto loop_1 = loops[1]; auto loop_2 = loops[2]; auto loop_3 = loops[3]; { LoopFusion fusion(context.get(), loop_0, loop_1); EXPECT_FALSE(fusion.AreCompatible()); } { LoopFusion fusion(context.get(), loop_1, loop_2); EXPECT_FALSE(fusion.AreCompatible()); } { LoopFusion fusion(context.get(), loop_2, loop_3); EXPECT_FALSE(fusion.AreCompatible()); } { LoopFusion fusion(context.get(), loop_0, loop_2); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_TRUE(fusion.IsLegal()); fusion.Fuse(); } std::string checks = R"( CHECK: [[PHI_0:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[PHI_1:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[LOAD_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_1]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_0]] CHECK: [[STORE_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_0]] CHECK-NEXT: OpStore [[STORE_0]] CHECK: [[PHI_2:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK-NOT: OpPhi CHECK: [[LOAD_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_0]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_1]] CHECK: [[STORE_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_2]] CHECK-NEXT: OpStore [[STORE_1]] )"; Match(checks, context.get()); } { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 3u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); auto loop_0 = loops[0]; auto loop_1 = loops[1]; auto loop_2 = loops[2]; { LoopFusion fusion(context.get(), loop_0, loop_1); EXPECT_FALSE(fusion.AreCompatible()); } { LoopFusion fusion(context.get(), loop_0, loop_2); EXPECT_FALSE(fusion.AreCompatible()); } { LoopFusion fusion(context.get(), loop_1, loop_2); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_TRUE(fusion.IsLegal()); fusion.Fuse(); } std::string checks = R"( CHECK: [[PHI_0:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[PHI_1:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[LOAD_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_1]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_0]] CHECK: [[STORE_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_0]] CHECK-NEXT: OpStore [[STORE_0]] CHECK-NOT: OpPhi CHECK: [[LOAD_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_0]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_1]] CHECK: [[STORE_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_1]] CHECK-NEXT: OpStore [[STORE_1]] )"; Match(checks, context.get()); } } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core void main() { int[10] a; int[10] b; int[10] c; // Legal, creates a loop-carried dependence, but has negative distance for (int i = 0; i < 10; i++) { c[i] = a[i+1] + 1; } for (int i = 0; i < 10; i++) { a[i] = c[i] + 2; } } */ TEST_F(FusionLegalTest, NegativeDistanceCreatedWAR) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %23 "c" OpName %25 "a" OpName %35 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %19 = OpTypeInt 32 0 %20 = OpConstant %19 10 %21 = OpTypeArray %6 %20 %22 = OpTypePointer Function %21 %27 = OpConstant %6 1 %47 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %23 = OpVariable %22 Function %25 = OpVariable %22 Function %35 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %52 = OpPhi %6 %9 %5 %34 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %52 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %28 = OpIAdd %6 %52 %27 %29 = OpAccessChain %7 %25 %28 %30 = OpLoad %6 %29 %31 = OpIAdd %6 %30 %27 %32 = OpAccessChain %7 %23 %52 OpStore %32 %31 OpBranch %13 %13 = OpLabel %34 = OpIAdd %6 %52 %27 OpStore %8 %34 OpBranch %10 %12 = OpLabel OpStore %35 %9 OpBranch %36 %36 = OpLabel %53 = OpPhi %6 %9 %12 %51 %39 OpLoopMerge %38 %39 None OpBranch %40 %40 = OpLabel %42 = OpSLessThan %17 %53 %16 OpBranchConditional %42 %37 %38 %37 = OpLabel %45 = OpAccessChain %7 %23 %53 %46 = OpLoad %6 %45 %48 = OpIAdd %6 %46 %47 %49 = OpAccessChain %7 %25 %53 OpStore %49 %48 OpBranch %39 %39 = OpLabel %51 = OpIAdd %6 %53 %27 OpStore %35 %51 OpBranch %36 %38 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_TRUE(fusion.IsLegal()); fusion.Fuse(); std::string checks = R"( CHECK: [[PHI:%\w+]] = OpPhi CHECK: [[I_1:%\w+]] = OpIAdd {{%\w+}} [[PHI]] {{%\w+}} CHECK-NEXT: [[LOAD_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[I_1]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_0]] CHECK: [[STORE_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpStore [[STORE_0]] CHECK-NOT: OpPhi CHECK: [[LOAD_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_1]] CHECK: [[STORE_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpStore [[STORE_1]] )"; Match(checks, context.get()); } { auto& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 1u); } } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core void main() { int[10] a; int[10] b; int[10] c; // Legal, creates a loop-carried dependence, but has negative distance for (int i = 0; i < 10; i++) { a[i+1] = b[i] + 1; } for (int i = 0; i < 10; i++) { a[i] = c[i+1] + 2; } } */ TEST_F(FusionLegalTest, NegativeDistanceCreatedWAW) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %23 "a" OpName %27 "b" OpName %35 "i" OpName %44 "c" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %19 = OpTypeInt 32 0 %20 = OpConstant %19 10 %21 = OpTypeArray %6 %20 %22 = OpTypePointer Function %21 %25 = OpConstant %6 1 %49 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %23 = OpVariable %22 Function %27 = OpVariable %22 Function %35 = OpVariable %7 Function %44 = OpVariable %22 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %54 = OpPhi %6 %9 %5 %34 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %54 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %26 = OpIAdd %6 %54 %25 %29 = OpAccessChain %7 %27 %54 %30 = OpLoad %6 %29 %31 = OpIAdd %6 %30 %25 %32 = OpAccessChain %7 %23 %26 OpStore %32 %31 OpBranch %13 %13 = OpLabel %34 = OpIAdd %6 %54 %25 OpStore %8 %34 OpBranch %10 %12 = OpLabel OpStore %35 %9 OpBranch %36 %36 = OpLabel %55 = OpPhi %6 %9 %12 %53 %39 OpLoopMerge %38 %39 None OpBranch %40 %40 = OpLabel %42 = OpSLessThan %17 %55 %16 OpBranchConditional %42 %37 %38 %37 = OpLabel %46 = OpIAdd %6 %55 %25 %47 = OpAccessChain %7 %44 %46 %48 = OpLoad %6 %47 %50 = OpIAdd %6 %48 %49 %51 = OpAccessChain %7 %23 %55 OpStore %51 %50 OpBranch %39 %39 = OpLabel %53 = OpIAdd %6 %55 %25 OpStore %35 %53 OpBranch %36 %38 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_TRUE(fusion.IsLegal()); fusion.Fuse(); } { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 1u); std::string checks = R"( CHECK: [[PHI:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[I_1:%\w+]] = OpIAdd {{%\w+}} [[PHI]] {{%\w+}} CHECK: [[LOAD_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_0]] CHECK: [[STORE_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[I_1]] CHECK-NEXT: OpStore CHECK-NOT: OpPhi CHECK: [[I_1:%\w+]] = OpIAdd {{%\w+}} [[PHI]] {{%\w+}} CHECK-NEXT: [[LOAD_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[I_1]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_1]] CHECK: [[STORE_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpStore [[STORE_1]] )"; Match(checks, context.get()); } } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core void main() { int[10] a; int[10] b; int[10] c; // Legal, no loop-carried dependence for (int i = 0; i < 10; i++) { a[i] = b[i] + 1; } for (int i = 0; i < 10; i++) { a[i] = c[i+1] + 2; } } */ TEST_F(FusionLegalTest, NoLoopCarriedDependencesWAW) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %23 "a" OpName %25 "b" OpName %34 "i" OpName %43 "c" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %19 = OpTypeInt 32 0 %20 = OpConstant %19 10 %21 = OpTypeArray %6 %20 %22 = OpTypePointer Function %21 %29 = OpConstant %6 1 %48 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %23 = OpVariable %22 Function %25 = OpVariable %22 Function %34 = OpVariable %7 Function %43 = OpVariable %22 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %53 = OpPhi %6 %9 %5 %33 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %53 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %27 = OpAccessChain %7 %25 %53 %28 = OpLoad %6 %27 %30 = OpIAdd %6 %28 %29 %31 = OpAccessChain %7 %23 %53 OpStore %31 %30 OpBranch %13 %13 = OpLabel %33 = OpIAdd %6 %53 %29 OpStore %8 %33 OpBranch %10 %12 = OpLabel OpStore %34 %9 OpBranch %35 %35 = OpLabel %54 = OpPhi %6 %9 %12 %52 %38 OpLoopMerge %37 %38 None OpBranch %39 %39 = OpLabel %41 = OpSLessThan %17 %54 %16 OpBranchConditional %41 %36 %37 %36 = OpLabel %45 = OpIAdd %6 %54 %29 %46 = OpAccessChain %7 %43 %45 %47 = OpLoad %6 %46 %49 = OpIAdd %6 %47 %48 %50 = OpAccessChain %7 %23 %54 OpStore %50 %49 OpBranch %38 %38 = OpLabel %52 = OpIAdd %6 %54 %29 OpStore %34 %52 OpBranch %35 %37 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_TRUE(fusion.IsLegal()); fusion.Fuse(); } { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 1u); std::string checks = R"( CHECK: [[PHI:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[LOAD_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_0]] CHECK: [[STORE_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpStore [[STORE_0]] CHECK-NOT: OpPhi CHECK: [[I_1:%\w+]] = OpIAdd {{%\w+}} [[PHI]] {{%\w+}} CHECK-NEXT: [[LOAD_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[I_1]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_1]] CHECK: [[STORE_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpStore [[STORE_1]] )"; Match(checks, context.get()); } } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core void main() { int[10][10] a; int[10][10] b; int[10][10] c; // Legal outer. Continue and break are fine if nested in inner loops for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { if (j % 2 == 0) { c[i][j] = a[i][j] + 2; } else { continue; } } } for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { if (j % 2 == 0) { b[i][j] = c[i][j] + 10; } else { break; } } } } */ TEST_F(FusionLegalTest, OuterloopWithBreakContinueInInner) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %19 "j" OpName %38 "c" OpName %41 "a" OpName %55 "i" OpName %63 "j" OpName %76 "b" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %28 = OpConstant %6 2 %33 = OpTypeInt 32 0 %34 = OpConstant %33 10 %35 = OpTypeArray %6 %34 %36 = OpTypeArray %35 %34 %37 = OpTypePointer Function %36 %51 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %19 = OpVariable %7 Function %38 = OpVariable %37 Function %41 = OpVariable %37 Function %55 = OpVariable %7 Function %63 = OpVariable %7 Function %76 = OpVariable %37 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %91 = OpPhi %6 %9 %5 %54 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %91 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel OpStore %19 %9 OpBranch %20 %20 = OpLabel %96 = OpPhi %6 %9 %11 %52 %23 OpLoopMerge %22 %23 None OpBranch %24 %24 = OpLabel %26 = OpSLessThan %17 %96 %16 OpBranchConditional %26 %21 %22 %21 = OpLabel %29 = OpSMod %6 %96 %28 %30 = OpIEqual %17 %29 %9 OpSelectionMerge %sel_merge None OpBranchConditional %30 %31 %48 %31 = OpLabel %44 = OpAccessChain %7 %41 %91 %96 %45 = OpLoad %6 %44 %46 = OpIAdd %6 %45 %28 %47 = OpAccessChain %7 %38 %91 %96 OpStore %47 %46 OpBranch %32 %48 = OpLabel OpBranch %sel_merge %32 = OpLabel OpBranch %sel_merge %sel_merge = OpLabel OpBranch %23 %23 = OpLabel %52 = OpIAdd %6 %96 %51 OpStore %19 %52 OpBranch %20 %22 = OpLabel OpBranch %13 %13 = OpLabel %54 = OpIAdd %6 %91 %51 OpStore %8 %54 OpBranch %10 %12 = OpLabel OpStore %55 %9 OpBranch %56 %56 = OpLabel %92 = OpPhi %6 %9 %12 %90 %59 OpLoopMerge %58 %59 None OpBranch %60 %60 = OpLabel %62 = OpSLessThan %17 %92 %16 OpBranchConditional %62 %57 %58 %57 = OpLabel OpStore %63 %9 OpBranch %64 %64 = OpLabel %93 = OpPhi %6 %9 %57 %88 %67 OpLoopMerge %66 %67 None OpBranch %68 %68 = OpLabel %70 = OpSLessThan %17 %93 %16 OpBranchConditional %70 %65 %66 %65 = OpLabel %72 = OpSMod %6 %93 %28 %73 = OpIEqual %17 %72 %9 OpSelectionMerge %75 None OpBranchConditional %73 %74 %66 %74 = OpLabel %81 = OpAccessChain %7 %38 %92 %93 %82 = OpLoad %6 %81 %83 = OpIAdd %6 %82 %16 %84 = OpAccessChain %7 %76 %92 %93 OpStore %84 %83 OpBranch %75 %75 = OpLabel OpBranch %67 %67 = OpLabel %88 = OpIAdd %6 %93 %51 OpStore %63 %88 OpBranch %64 %66 = OpLabel OpBranch %59 %59 = OpLabel %90 = OpIAdd %6 %92 %51 OpStore %55 %90 OpBranch %56 %58 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 4u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[2]); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_TRUE(fusion.IsLegal()); fusion.Fuse(); } { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 3u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[1], loops[2]); EXPECT_FALSE(fusion.AreCompatible()); std::string checks = R"( CHECK: [[PHI_0:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[PHI_1:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[LOAD_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_0]] [[PHI_1]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_0]] CHECK: [[STORE_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_0]] [[PHI_1]] CHECK-NEXT: OpStore [[STORE_0]] CHECK: [[PHI_2:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK-NOT: OpPhi CHECK: [[LOAD_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_0]] [[PHI_2]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_1]] CHECK: [[STORE_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_0]] [[PHI_2]] CHECK-NEXT: OpStore [[STORE_1]] )"; Match(checks, context.get()); } } /* Generated from the following GLSL + --eliminate-local-multi-store // j loop preheader removed manually #version 440 core void main() { int[10] a; int[10] b; int i = 0; int j = 0; // No loop-carried dependences, legal for (; i < 10; i++) { a[i] = a[i]*2; } for (; j < 10; j++) { b[j] = a[j]+2; } } */ TEST_F(FusionLegalTest, DifferentArraysInLoopsNoPreheader) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %10 "j" OpName %24 "a" OpName %42 "b" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %17 = OpConstant %6 10 %18 = OpTypeBool %20 = OpTypeInt 32 0 %21 = OpConstant %20 10 %22 = OpTypeArray %6 %21 %23 = OpTypePointer Function %22 %29 = OpConstant %6 2 %33 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %24 = OpVariable %23 Function %42 = OpVariable %23 Function OpStore %8 %9 OpStore %10 %9 OpBranch %11 %11 = OpLabel %51 = OpPhi %6 %9 %5 %34 %14 OpLoopMerge %35 %14 None OpBranch %15 %15 = OpLabel %19 = OpSLessThan %18 %51 %17 OpBranchConditional %19 %12 %35 %12 = OpLabel %27 = OpAccessChain %7 %24 %51 %28 = OpLoad %6 %27 %30 = OpIMul %6 %28 %29 %31 = OpAccessChain %7 %24 %51 OpStore %31 %30 OpBranch %14 %14 = OpLabel %34 = OpIAdd %6 %51 %33 OpStore %8 %34 OpBranch %11 %35 = OpLabel %52 = OpPhi %6 %9 %15 %50 %38 OpLoopMerge %37 %38 None OpBranch %39 %39 = OpLabel %41 = OpSLessThan %18 %52 %17 OpBranchConditional %41 %36 %37 %36 = OpLabel %45 = OpAccessChain %7 %24 %52 %46 = OpLoad %6 %45 %47 = OpIAdd %6 %46 %29 %48 = OpAccessChain %7 %42 %52 OpStore %48 %47 OpBranch %38 %38 = OpLabel %50 = OpIAdd %6 %52 %33 OpStore %10 %50 OpBranch %35 %37 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); { LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_FALSE(fusion.AreCompatible()); } ld.CreatePreHeaderBlocksIfMissing(); { LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_TRUE(fusion.IsLegal()); fusion.Fuse(); } } { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 1u); std::string checks = R"( CHECK: [[PHI:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[LOAD_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_0]] CHECK: [[STORE_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpStore [[STORE_0]] CHECK-NOT: OpPhi CHECK: [[LOAD_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_1]] CHECK: [[STORE_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpStore [[STORE_1]] )"; Match(checks, context.get()); } } /* Generated from the following GLSL + --eliminate-local-multi-store // j & k loop preheaders removed manually #version 440 core void main() { int[10] a; int[10] b; int i = 0; int j = 0; int k = 0; // No loop-carried dependences, legal for (; i < 10; i++) { a[i] = a[i]*2; } for (; j < 10; j++) { b[j] = a[j]+2; } for (; k < 10; k++) { a[k] = a[k]*2; } } */ TEST_F(FusionLegalTest, AdjacentLoopsNoPreheaders) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %10 "j" OpName %11 "k" OpName %25 "a" OpName %43 "b" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %18 = OpConstant %6 10 %19 = OpTypeBool %21 = OpTypeInt 32 0 %22 = OpConstant %21 10 %23 = OpTypeArray %6 %22 %24 = OpTypePointer Function %23 %30 = OpConstant %6 2 %34 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %11 = OpVariable %7 Function %25 = OpVariable %24 Function %43 = OpVariable %24 Function OpStore %8 %9 OpStore %10 %9 OpStore %11 %9 OpBranch %12 %12 = OpLabel %67 = OpPhi %6 %9 %5 %35 %15 OpLoopMerge %36 %15 None OpBranch %16 %16 = OpLabel %20 = OpSLessThan %19 %67 %18 OpBranchConditional %20 %13 %36 %13 = OpLabel %28 = OpAccessChain %7 %25 %67 %29 = OpLoad %6 %28 %31 = OpIMul %6 %29 %30 %32 = OpAccessChain %7 %25 %67 OpStore %32 %31 OpBranch %15 %15 = OpLabel %35 = OpIAdd %6 %67 %34 OpStore %8 %35 OpBranch %12 %36 = OpLabel %68 = OpPhi %6 %9 %16 %51 %39 OpLoopMerge %52 %39 None OpBranch %40 %40 = OpLabel %42 = OpSLessThan %19 %68 %18 OpBranchConditional %42 %37 %52 %37 = OpLabel %46 = OpAccessChain %7 %25 %68 %47 = OpLoad %6 %46 %48 = OpIAdd %6 %47 %30 %49 = OpAccessChain %7 %43 %68 OpStore %49 %48 OpBranch %39 %39 = OpLabel %51 = OpIAdd %6 %68 %34 OpStore %10 %51 OpBranch %36 %52 = OpLabel %70 = OpPhi %6 %9 %40 %66 %55 OpLoopMerge %54 %55 None OpBranch %56 %56 = OpLabel %58 = OpSLessThan %19 %70 %18 OpBranchConditional %58 %53 %54 %53 = OpLabel %61 = OpAccessChain %7 %25 %70 %62 = OpLoad %6 %61 %63 = OpIMul %6 %62 %30 %64 = OpAccessChain %7 %25 %70 OpStore %64 %63 OpBranch %55 %55 = OpLabel %66 = OpIAdd %6 %70 %34 OpStore %11 %66 OpBranch %52 %54 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 3u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); { LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_FALSE(fusion.AreCompatible()); } ld.CreatePreHeaderBlocksIfMissing(); { LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_TRUE(fusion.IsLegal()); fusion.Fuse(); } } { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); std::string checks = R"( CHECK: [[PHI_0:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[LOAD_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_0]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_0]] CHECK: [[STORE_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_0]] CHECK-NEXT: OpStore [[STORE_0]] CHECK-NOT: OpPhi CHECK: [[LOAD_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_0]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_1]] CHECK: [[STORE_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_0]] CHECK-NEXT: OpStore [[STORE_1]] CHECK: [[PHI_1:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[LOAD_2:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_1]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_2]] CHECK: [[STORE_2:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI_1]] CHECK-NEXT: OpStore [[STORE_2]] )"; Match(checks, context.get()); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_TRUE(fusion.IsLegal()); fusion.Fuse(); } { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 1u); std::string checks = R"( CHECK: [[PHI:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[LOAD_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_0]] CHECK: [[STORE_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpStore [[STORE_0]] CHECK-NOT: OpPhi CHECK: [[LOAD_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_1]] CHECK: [[STORE_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpStore [[STORE_1]] CHECK-NOT: OpPhi CHECK: [[LOAD_2:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpLoad {{%\w+}} [[LOAD_2]] CHECK: [[STORE_2:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpStore [[STORE_2]] )"; Match(checks, context.get()); } } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core void main() { int[10] a; int[10] b; int sum_0 = 0; int sum_1 = 0; // No loop-carried dependences, legal for (int i = 0; i < 10; i++) { sum_0 += a[i]; } for (int j = 0; j < 10; j++) { sum_1 += b[j]; } int total = sum_0 + sum_1; } */ TEST_F(FusionLegalTest, IndependentReductions) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "sum_0" OpName %10 "sum_1" OpName %11 "i" OpName %25 "a" OpName %34 "j" OpName %42 "b" OpName %50 "total" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %18 = OpConstant %6 10 %19 = OpTypeBool %21 = OpTypeInt 32 0 %22 = OpConstant %21 10 %23 = OpTypeArray %6 %22 %24 = OpTypePointer Function %23 %32 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %11 = OpVariable %7 Function %25 = OpVariable %24 Function %34 = OpVariable %7 Function %42 = OpVariable %24 Function %50 = OpVariable %7 Function OpStore %8 %9 OpStore %10 %9 OpStore %11 %9 OpBranch %12 %12 = OpLabel %57 = OpPhi %6 %9 %5 %30 %15 %54 = OpPhi %6 %9 %5 %33 %15 OpLoopMerge %14 %15 None OpBranch %16 %16 = OpLabel %20 = OpSLessThan %19 %54 %18 OpBranchConditional %20 %13 %14 %13 = OpLabel %27 = OpAccessChain %7 %25 %54 %28 = OpLoad %6 %27 %30 = OpIAdd %6 %57 %28 OpStore %8 %30 OpBranch %15 %15 = OpLabel %33 = OpIAdd %6 %54 %32 OpStore %11 %33 OpBranch %12 %14 = OpLabel OpStore %34 %9 OpBranch %35 %35 = OpLabel %58 = OpPhi %6 %9 %14 %47 %38 %55 = OpPhi %6 %9 %14 %49 %38 OpLoopMerge %37 %38 None OpBranch %39 %39 = OpLabel %41 = OpSLessThan %19 %55 %18 OpBranchConditional %41 %36 %37 %36 = OpLabel %44 = OpAccessChain %7 %42 %55 %45 = OpLoad %6 %44 %47 = OpIAdd %6 %58 %45 OpStore %10 %47 OpBranch %38 %38 = OpLabel %49 = OpIAdd %6 %55 %32 OpStore %34 %49 OpBranch %35 %37 = OpLabel %53 = OpIAdd %6 %57 %58 OpStore %50 %53 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_TRUE(fusion.IsLegal()); fusion.Fuse(); } { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 1u); std::string checks = R"( CHECK: [[SUM_0:%\w+]] = OpPhi CHECK-NEXT: [[SUM_1:%\w+]] = OpPhi CHECK-NEXT: [[PHI:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[LOAD_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: [[LOAD_RES_0:%\w+]] = OpLoad {{%\w+}} [[LOAD_0]] CHECK-NEXT: [[ADD_RES_0:%\w+]] = OpIAdd {{%\w+}} [[SUM_0]] [[LOAD_RES_0]] CHECK-NEXT: OpStore {{%\w+}} [[ADD_RES_0]] CHECK-NOT: OpPhi CHECK: [[LOAD_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: [[LOAD_RES_1:%\w+]] = OpLoad {{%\w+}} [[LOAD_1]] CHECK-NEXT: [[ADD_RES_1:%\w+]] = OpIAdd {{%\w+}} [[SUM_1]] [[LOAD_RES_1]] CHECK-NEXT: OpStore {{%\w+}} [[ADD_RES_1]] )"; Match(checks, context.get()); } } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core void main() { int[10] a; int[10] b; int sum_0 = 0; int sum_1 = 0; // No loop-carried dependences, legal for (int i = 0; i < 10; i++) { sum_0 += a[i]; } for (int j = 0; j < 10; j++) { sum_1 += b[j]; } int total = sum_0 + sum_1; } */ TEST_F(FusionLegalTest, IndependentReductionsOneLCSSA) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "sum_0" OpName %10 "sum_1" OpName %11 "i" OpName %25 "a" OpName %34 "j" OpName %42 "b" OpName %50 "total" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %18 = OpConstant %6 10 %19 = OpTypeBool %21 = OpTypeInt 32 0 %22 = OpConstant %21 10 %23 = OpTypeArray %6 %22 %24 = OpTypePointer Function %23 %32 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %11 = OpVariable %7 Function %25 = OpVariable %24 Function %34 = OpVariable %7 Function %42 = OpVariable %24 Function %50 = OpVariable %7 Function OpStore %8 %9 OpStore %10 %9 OpStore %11 %9 OpBranch %12 %12 = OpLabel %57 = OpPhi %6 %9 %5 %30 %15 %54 = OpPhi %6 %9 %5 %33 %15 OpLoopMerge %14 %15 None OpBranch %16 %16 = OpLabel %20 = OpSLessThan %19 %54 %18 OpBranchConditional %20 %13 %14 %13 = OpLabel %27 = OpAccessChain %7 %25 %54 %28 = OpLoad %6 %27 %30 = OpIAdd %6 %57 %28 OpStore %8 %30 OpBranch %15 %15 = OpLabel %33 = OpIAdd %6 %54 %32 OpStore %11 %33 OpBranch %12 %14 = OpLabel OpStore %34 %9 OpBranch %35 %35 = OpLabel %58 = OpPhi %6 %9 %14 %47 %38 %55 = OpPhi %6 %9 %14 %49 %38 OpLoopMerge %37 %38 None OpBranch %39 %39 = OpLabel %41 = OpSLessThan %19 %55 %18 OpBranchConditional %41 %36 %37 %36 = OpLabel %44 = OpAccessChain %7 %42 %55 %45 = OpLoad %6 %44 %47 = OpIAdd %6 %58 %45 OpStore %10 %47 OpBranch %38 %38 = OpLabel %49 = OpIAdd %6 %55 %32 OpStore %34 %49 OpBranch %35 %37 = OpLabel %53 = OpIAdd %6 %57 %58 OpStore %50 %53 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopUtils utils_0(context.get(), loops[0]); utils_0.MakeLoopClosedSSA(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_TRUE(fusion.IsLegal()); fusion.Fuse(); } { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 1u); std::string checks = R"( CHECK: [[SUM_0:%\w+]] = OpPhi CHECK-NEXT: [[SUM_1:%\w+]] = OpPhi CHECK-NEXT: [[PHI:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[LOAD_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: [[LOAD_RES_0:%\w+]] = OpLoad {{%\w+}} [[LOAD_0]] CHECK-NEXT: [[ADD_RES_0:%\w+]] = OpIAdd {{%\w+}} [[SUM_0]] [[LOAD_RES_0]] CHECK-NEXT: OpStore {{%\w+}} [[ADD_RES_0]] CHECK-NOT: OpPhi CHECK: [[LOAD_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: [[LOAD_RES_1:%\w+]] = OpLoad {{%\w+}} [[LOAD_1]] CHECK-NEXT: [[ADD_RES_1:%\w+]] = OpIAdd {{%\w+}} [[SUM_1]] [[LOAD_RES_1]] CHECK-NEXT: OpStore {{%\w+}} [[ADD_RES_1]] )"; Match(checks, context.get()); } } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core void main() { int[10] a; int[10] b; int sum_0 = 0; int sum_1 = 0; // No loop-carried dependences, legal for (int i = 0; i < 10; i++) { sum_0 += a[i]; } for (int j = 0; j < 10; j++) { sum_1 += b[j]; } int total = sum_0 + sum_1; } */ TEST_F(FusionLegalTest, IndependentReductionsBothLCSSA) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "sum_0" OpName %10 "sum_1" OpName %11 "i" OpName %25 "a" OpName %34 "j" OpName %42 "b" OpName %50 "total" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %18 = OpConstant %6 10 %19 = OpTypeBool %21 = OpTypeInt 32 0 %22 = OpConstant %21 10 %23 = OpTypeArray %6 %22 %24 = OpTypePointer Function %23 %32 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %11 = OpVariable %7 Function %25 = OpVariable %24 Function %34 = OpVariable %7 Function %42 = OpVariable %24 Function %50 = OpVariable %7 Function OpStore %8 %9 OpStore %10 %9 OpStore %11 %9 OpBranch %12 %12 = OpLabel %57 = OpPhi %6 %9 %5 %30 %15 %54 = OpPhi %6 %9 %5 %33 %15 OpLoopMerge %14 %15 None OpBranch %16 %16 = OpLabel %20 = OpSLessThan %19 %54 %18 OpBranchConditional %20 %13 %14 %13 = OpLabel %27 = OpAccessChain %7 %25 %54 %28 = OpLoad %6 %27 %30 = OpIAdd %6 %57 %28 OpStore %8 %30 OpBranch %15 %15 = OpLabel %33 = OpIAdd %6 %54 %32 OpStore %11 %33 OpBranch %12 %14 = OpLabel OpStore %34 %9 OpBranch %35 %35 = OpLabel %58 = OpPhi %6 %9 %14 %47 %38 %55 = OpPhi %6 %9 %14 %49 %38 OpLoopMerge %37 %38 None OpBranch %39 %39 = OpLabel %41 = OpSLessThan %19 %55 %18 OpBranchConditional %41 %36 %37 %36 = OpLabel %44 = OpAccessChain %7 %42 %55 %45 = OpLoad %6 %44 %47 = OpIAdd %6 %58 %45 OpStore %10 %47 OpBranch %38 %38 = OpLabel %49 = OpIAdd %6 %55 %32 OpStore %34 %49 OpBranch %35 %37 = OpLabel %53 = OpIAdd %6 %57 %58 OpStore %50 %53 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopUtils utils_0(context.get(), loops[0]); utils_0.MakeLoopClosedSSA(); LoopUtils utils_1(context.get(), loops[1]); utils_1.MakeLoopClosedSSA(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_TRUE(fusion.IsLegal()); fusion.Fuse(); } { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 1u); std::string checks = R"( CHECK: [[SUM_0:%\w+]] = OpPhi CHECK-NEXT: [[SUM_1:%\w+]] = OpPhi CHECK-NEXT: [[PHI:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[LOAD_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: [[LOAD_RES_0:%\w+]] = OpLoad {{%\w+}} [[LOAD_0]] CHECK-NEXT: [[ADD_RES_0:%\w+]] = OpIAdd {{%\w+}} [[SUM_0]] [[LOAD_RES_0]] CHECK-NEXT: OpStore {{%\w+}} [[ADD_RES_0]] CHECK-NOT: OpPhi CHECK: [[LOAD_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: [[LOAD_RES_1:%\w+]] = OpLoad {{%\w+}} [[LOAD_1]] CHECK-NEXT: [[ADD_RES_1:%\w+]] = OpIAdd {{%\w+}} [[SUM_1]] [[LOAD_RES_1]] CHECK-NEXT: OpStore {{%\w+}} [[ADD_RES_1]] )"; Match(checks, context.get()); } } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core void main() { int[10] a; int[10] b; int sum_0 = 0; // No loop-carried dependences, legal for (int i = 0; i < 10; i++) { sum_0 += a[i]; } for (int j = 0; j < 10; j++) { a[j] = b[j]; } } */ TEST_F(FusionLegalTest, LoadStoreReductionAndNonLoopCarriedDependence) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "sum_0" OpName %10 "i" OpName %24 "a" OpName %33 "j" OpName %42 "b" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %17 = OpConstant %6 10 %18 = OpTypeBool %20 = OpTypeInt 32 0 %21 = OpConstant %20 10 %22 = OpTypeArray %6 %21 %23 = OpTypePointer Function %22 %31 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %24 = OpVariable %23 Function %33 = OpVariable %7 Function %42 = OpVariable %23 Function OpStore %8 %9 OpStore %10 %9 OpBranch %11 %11 = OpLabel %51 = OpPhi %6 %9 %5 %29 %14 %49 = OpPhi %6 %9 %5 %32 %14 OpLoopMerge %13 %14 None OpBranch %15 %15 = OpLabel %19 = OpSLessThan %18 %49 %17 OpBranchConditional %19 %12 %13 %12 = OpLabel %26 = OpAccessChain %7 %24 %49 %27 = OpLoad %6 %26 %29 = OpIAdd %6 %51 %27 OpStore %8 %29 OpBranch %14 %14 = OpLabel %32 = OpIAdd %6 %49 %31 OpStore %10 %32 OpBranch %11 %13 = OpLabel OpStore %33 %9 OpBranch %34 %34 = OpLabel %50 = OpPhi %6 %9 %13 %48 %37 OpLoopMerge %36 %37 None OpBranch %38 %38 = OpLabel %40 = OpSLessThan %18 %50 %17 OpBranchConditional %40 %35 %36 %35 = OpLabel %44 = OpAccessChain %7 %42 %50 %45 = OpLoad %6 %44 %46 = OpAccessChain %7 %24 %50 OpStore %46 %45 OpBranch %37 %37 = OpLabel %48 = OpIAdd %6 %50 %31 OpStore %33 %48 OpBranch %34 %36 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_TRUE(fusion.AreCompatible()); // TODO: Loop descriptor doesn't return induction variables but all OpPhi // in the header and LoopDependenceAnalysis falls over. // EXPECT_TRUE(fusion.IsLegal()); // fusion.Fuse(); } { // LoopDescriptor& ld = *context->GetLoopDescriptor(&f); // EXPECT_EQ(ld.NumLoops(), 1u); // std::string checks = R"( // CHECK: [[SUM_0:%\w+]] = OpPhi // CHECK-NEXT: [[PHI:%\w+]] = OpPhi // CHECK-NEXT: OpLoopMerge // CHECK: [[LOAD_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] // CHECK-NEXT: [[LOAD_RES_0:%\w+]] = OpLoad {{%\w+}} [[LOAD_0]] // CHECK-NEXT: [[ADD_RES_0:%\w+]] = OpIAdd {{%\w+}} [[SUM_0]] [[LOAD_RES_0]] // CHECK-NEXT: OpStore {{%\w+}} [[ADD_RES_0]] // CHECK-NOT: OpPhi // CHECK: [[LOAD_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] // CHECK-NEXT: [[LOAD_RES_1:%\w+]] = OpLoad {{%\w+}} [[LOAD_1]] // CHECK: [[STORE_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] // CHECK-NEXT: OpStore [[STORE_1]] [[LOAD_RES_1]] // )"; // Match(checks, context.get()); } } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core int x; void main() { int[10] a; int[10] b; // Legal. for (int i = 0; i < 10; i++) { x += a[i]; } for (int j = 0; j < 10; j++) { b[j] = b[j]+1; } } */ TEST_F(FusionLegalTest, ReductionAndNonLoopCarriedDependence) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %20 "x" OpName %25 "a" OpName %34 "j" OpName %42 "b" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %19 = OpTypePointer Private %6 %20 = OpVariable %19 Private %21 = OpTypeInt 32 0 %22 = OpConstant %21 10 %23 = OpTypeArray %6 %22 %24 = OpTypePointer Function %23 %32 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %25 = OpVariable %24 Function %34 = OpVariable %7 Function %42 = OpVariable %24 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %51 = OpPhi %6 %9 %5 %33 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %51 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %27 = OpAccessChain %7 %25 %51 %28 = OpLoad %6 %27 %29 = OpLoad %6 %20 %30 = OpIAdd %6 %29 %28 OpStore %20 %30 OpBranch %13 %13 = OpLabel %33 = OpIAdd %6 %51 %32 OpStore %8 %33 OpBranch %10 %12 = OpLabel OpStore %34 %9 OpBranch %35 %35 = OpLabel %52 = OpPhi %6 %9 %12 %50 %38 OpLoopMerge %37 %38 None OpBranch %39 %39 = OpLabel %41 = OpSLessThan %17 %52 %16 OpBranchConditional %41 %36 %37 %36 = OpLabel %45 = OpAccessChain %7 %42 %52 %46 = OpLoad %6 %45 %47 = OpIAdd %6 %46 %32 %48 = OpAccessChain %7 %42 %52 OpStore %48 %47 OpBranch %38 %38 = OpLabel %50 = OpIAdd %6 %52 %32 OpStore %34 %50 OpBranch %35 %37 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_TRUE(fusion.IsLegal()); fusion.Fuse(); } { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 1u); std::string checks = R"( CHECK: OpName [[X:%\w+]] "x" CHECK: [[PHI:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[LOAD_0:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: [[LOAD_RES_0:%\w+]] = OpLoad {{%\w+}} [[LOAD_0]] CHECK-NEXT: [[X_LOAD:%\w+]] = OpLoad {{%\w+}} [[X]] CHECK-NEXT: [[ADD_RES_0:%\w+]] = OpIAdd {{%\w+}} [[X_LOAD]] [[LOAD_RES_0]] CHECK-NEXT: OpStore [[X]] [[ADD_RES_0]] CHECK-NOT: OpPhi CHECK: [[LOAD_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: {{%\w+}} = OpLoad {{%\w+}} [[LOAD_1]] CHECK: [[STORE_1:%\w+]] = OpAccessChain {{%\w+}} {{%\w+}} [[PHI]] CHECK-NEXT: OpStore [[STORE_1]] )"; Match(checks, context.get()); } } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core struct TestStruct { int[10] a; int b; }; void main() { TestStruct test_0; TestStruct test_1; TestStruct test_2; test_1.b = 2; for (int i = 0; i < 10; i++) { test_0.a[i] = i; } for (int j = 0; j < 10; j++) { test_2 = test_1; } } */ TEST_F(FusionLegalTest, ArrayInStruct) { std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %10 "TestStruct" OpMemberName %10 0 "a" OpMemberName %10 1 "b" OpName %12 "test_1" OpName %17 "i" OpName %28 "test_0" OpName %34 "j" OpName %42 "test_2" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeInt 32 0 %8 = OpConstant %7 10 %9 = OpTypeArray %6 %8 %10 = OpTypeStruct %9 %6 %11 = OpTypePointer Function %10 %13 = OpConstant %6 1 %14 = OpConstant %6 2 %15 = OpTypePointer Function %6 %18 = OpConstant %6 0 %25 = OpConstant %6 10 %26 = OpTypeBool %4 = OpFunction %2 None %3 %5 = OpLabel %12 = OpVariable %11 Function %17 = OpVariable %15 Function %28 = OpVariable %11 Function %34 = OpVariable %15 Function %42 = OpVariable %11 Function %16 = OpAccessChain %15 %12 %13 OpStore %16 %14 OpStore %17 %18 OpBranch %19 %19 = OpLabel %46 = OpPhi %6 %18 %5 %33 %22 OpLoopMerge %21 %22 None OpBranch %23 %23 = OpLabel %27 = OpSLessThan %26 %46 %25 OpBranchConditional %27 %20 %21 %20 = OpLabel %31 = OpAccessChain %15 %28 %18 %46 OpStore %31 %46 OpBranch %22 %22 = OpLabel %33 = OpIAdd %6 %46 %13 OpStore %17 %33 OpBranch %19 %21 = OpLabel OpStore %34 %18 OpBranch %35 %35 = OpLabel %47 = OpPhi %6 %18 %21 %45 %38 OpLoopMerge %37 %38 None OpBranch %39 %39 = OpLabel %41 = OpSLessThan %26 %47 %25 OpBranchConditional %41 %36 %37 %36 = OpLabel %43 = OpLoad %10 %12 OpStore %42 %43 OpBranch %38 %38 = OpLabel %45 = OpIAdd %6 %47 %13 OpStore %34 %45 OpBranch %35 %37 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 2u); auto loops = ld.GetLoopsInBinaryLayoutOrder(); LoopFusion fusion(context.get(), loops[0], loops[1]); EXPECT_TRUE(fusion.AreCompatible()); EXPECT_TRUE(fusion.IsLegal()); fusion.Fuse(); } { LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 1u); // clang-format off std::string checks = R"( CHECK: OpName [[TEST_1:%\w+]] "test_1" CHECK: OpName [[TEST_0:%\w+]] "test_0" CHECK: OpName [[TEST_2:%\w+]] "test_2" CHECK: [[PHI:%\w+]] = OpPhi CHECK-NEXT: OpLoopMerge CHECK: [[TEST_0_STORE:%\w+]] = OpAccessChain {{%\w+}} [[TEST_0]] {{%\w+}} {{%\w+}} CHECK-NEXT: OpStore [[TEST_0_STORE]] [[PHI]] CHECK-NOT: OpPhi CHECK: [[TEST_1_LOAD:%\w+]] = OpLoad {{%\w+}} [[TEST_1]] CHECK: OpStore [[TEST_2]] [[TEST_1_LOAD]] )"; // clang-format on Match(checks, context.get()); } } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/loop_optimizations/fusion_pass.cpp000066400000000000000000000473131475742701700273210ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "effcee/effcee.h" #include "gmock/gmock.h" #include "test/opt/pass_fixture.h" namespace spvtools { namespace opt { namespace { using FusionPassTest = PassTest<::testing::Test>; /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core void main() { int[10] a; int[10] b; for (int i = 0; i < 10; i++) { a[i] = a[i]*2; } for (int i = 0; i < 10; i++) { b[i] = a[i]+2; } } */ TEST_F(FusionPassTest, SimpleFusion) { const std::string text = R"( ; CHECK: OpPhi ; CHECK: OpLoad ; CHECK: OpStore ; CHECK-NOT: OpPhi ; CHECK: OpLoad ; CHECK: OpStore OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %23 "a" OpName %34 "i" OpName %42 "b" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %19 = OpTypeInt 32 0 %20 = OpConstant %19 10 %21 = OpTypeArray %6 %20 %22 = OpTypePointer Function %21 %28 = OpConstant %6 2 %32 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %23 = OpVariable %22 Function %34 = OpVariable %7 Function %42 = OpVariable %22 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %51 = OpPhi %6 %9 %5 %33 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %51 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %26 = OpAccessChain %7 %23 %51 %27 = OpLoad %6 %26 %29 = OpIMul %6 %27 %28 %30 = OpAccessChain %7 %23 %51 OpStore %30 %29 OpBranch %13 %13 = OpLabel %33 = OpIAdd %6 %51 %32 OpStore %8 %33 OpBranch %10 %12 = OpLabel OpStore %34 %9 OpBranch %35 %35 = OpLabel %52 = OpPhi %6 %9 %12 %50 %38 OpLoopMerge %37 %38 None OpBranch %39 %39 = OpLabel %41 = OpSLessThan %17 %52 %16 OpBranchConditional %41 %36 %37 %36 = OpLabel %45 = OpAccessChain %7 %23 %52 %46 = OpLoad %6 %45 %47 = OpIAdd %6 %46 %28 %48 = OpAccessChain %7 %42 %52 OpStore %48 %47 OpBranch %38 %38 = OpLabel %50 = OpIAdd %6 %52 %32 OpStore %34 %50 OpBranch %35 %37 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true, 20); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core void main() { int[10] a; int[10] b; int[10] c; for (int i = 0; i < 10; i++) { a[i] = b[i] + 1; } for (int i = 0; i < 10; i++) { c[i] = a[i] + 2; } for (int i = 0; i < 10; i++) { b[i] = c[i] + 10; } } */ TEST_F(FusionPassTest, ThreeLoopsFused) { const std::string text = R"( ; CHECK: OpPhi ; CHECK: OpLoad ; CHECK: OpStore ; CHECK-NOT: OpPhi ; CHECK: OpLoad ; CHECK: OpStore ; CHECK-NOT: OpPhi ; CHECK: OpLoad ; CHECK: OpStore OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %23 "a" OpName %25 "b" OpName %34 "i" OpName %42 "c" OpName %52 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %19 = OpTypeInt 32 0 %20 = OpConstant %19 10 %21 = OpTypeArray %6 %20 %22 = OpTypePointer Function %21 %29 = OpConstant %6 1 %47 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %23 = OpVariable %22 Function %25 = OpVariable %22 Function %34 = OpVariable %7 Function %42 = OpVariable %22 Function %52 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %68 = OpPhi %6 %9 %5 %33 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %68 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %27 = OpAccessChain %7 %25 %68 %28 = OpLoad %6 %27 %30 = OpIAdd %6 %28 %29 %31 = OpAccessChain %7 %23 %68 OpStore %31 %30 OpBranch %13 %13 = OpLabel %33 = OpIAdd %6 %68 %29 OpStore %8 %33 OpBranch %10 %12 = OpLabel OpStore %34 %9 OpBranch %35 %35 = OpLabel %69 = OpPhi %6 %9 %12 %51 %38 OpLoopMerge %37 %38 None OpBranch %39 %39 = OpLabel %41 = OpSLessThan %17 %69 %16 OpBranchConditional %41 %36 %37 %36 = OpLabel %45 = OpAccessChain %7 %23 %69 %46 = OpLoad %6 %45 %48 = OpIAdd %6 %46 %47 %49 = OpAccessChain %7 %42 %69 OpStore %49 %48 OpBranch %38 %38 = OpLabel %51 = OpIAdd %6 %69 %29 OpStore %34 %51 OpBranch %35 %37 = OpLabel OpStore %52 %9 OpBranch %53 %53 = OpLabel %70 = OpPhi %6 %9 %37 %67 %56 OpLoopMerge %55 %56 None OpBranch %57 %57 = OpLabel %59 = OpSLessThan %17 %70 %16 OpBranchConditional %59 %54 %55 %54 = OpLabel %62 = OpAccessChain %7 %42 %70 %63 = OpLoad %6 %62 %64 = OpIAdd %6 %63 %16 %65 = OpAccessChain %7 %25 %70 OpStore %65 %64 OpBranch %56 %56 = OpLabel %67 = OpIAdd %6 %70 %29 OpStore %52 %67 OpBranch %53 %55 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true, 20); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core void main() { int[10][10] a; int[10][10] b; int[10][10] c; // Legal both for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { c[i][j] = a[i][j] + 2; } } for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { b[i][j] = c[i][j] + 10; } } } */ TEST_F(FusionPassTest, NestedLoopsFused) { const std::string text = R"( ; CHECK: OpPhi ; CHECK: OpPhi ; CHECK: OpLoad ; CHECK: OpStore ; CHECK-NOT: OpPhi ; CHECK: OpLoad ; CHECK: OpStore OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %19 "j" OpName %32 "c" OpName %35 "a" OpName %48 "i" OpName %56 "j" OpName %64 "b" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %27 = OpTypeInt 32 0 %28 = OpConstant %27 10 %29 = OpTypeArray %6 %28 %30 = OpTypeArray %29 %28 %31 = OpTypePointer Function %30 %40 = OpConstant %6 2 %44 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %19 = OpVariable %7 Function %32 = OpVariable %31 Function %35 = OpVariable %31 Function %48 = OpVariable %7 Function %56 = OpVariable %7 Function %64 = OpVariable %31 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %77 = OpPhi %6 %9 %5 %47 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %77 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel OpStore %19 %9 OpBranch %20 %20 = OpLabel %81 = OpPhi %6 %9 %11 %45 %23 OpLoopMerge %22 %23 None OpBranch %24 %24 = OpLabel %26 = OpSLessThan %17 %81 %16 OpBranchConditional %26 %21 %22 %21 = OpLabel %38 = OpAccessChain %7 %35 %77 %81 %39 = OpLoad %6 %38 %41 = OpIAdd %6 %39 %40 %42 = OpAccessChain %7 %32 %77 %81 OpStore %42 %41 OpBranch %23 %23 = OpLabel %45 = OpIAdd %6 %81 %44 OpStore %19 %45 OpBranch %20 %22 = OpLabel OpBranch %13 %13 = OpLabel %47 = OpIAdd %6 %77 %44 OpStore %8 %47 OpBranch %10 %12 = OpLabel OpStore %48 %9 OpBranch %49 %49 = OpLabel %78 = OpPhi %6 %9 %12 %76 %52 OpLoopMerge %51 %52 None OpBranch %53 %53 = OpLabel %55 = OpSLessThan %17 %78 %16 OpBranchConditional %55 %50 %51 %50 = OpLabel OpStore %56 %9 OpBranch %57 %57 = OpLabel %79 = OpPhi %6 %9 %50 %74 %60 OpLoopMerge %59 %60 None OpBranch %61 %61 = OpLabel %63 = OpSLessThan %17 %79 %16 OpBranchConditional %63 %58 %59 %58 = OpLabel %69 = OpAccessChain %7 %32 %78 %79 %70 = OpLoad %6 %69 %71 = OpIAdd %6 %70 %16 %72 = OpAccessChain %7 %64 %78 %79 OpStore %72 %71 OpBranch %60 %60 = OpLabel %74 = OpIAdd %6 %79 %44 OpStore %56 %74 OpBranch %57 %59 = OpLabel OpBranch %52 %52 = OpLabel %76 = OpIAdd %6 %78 %44 OpStore %48 %76 OpBranch %49 %51 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true, 20); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core void main() { // Can't fuse, different step for (int i = 0; i < 10; i++) {} for (int j = 0; j < 10; j=j+2) {} } */ TEST_F(FusionPassTest, Incompatible) { const std::string text = R"( ; CHECK: OpPhi ; CHECK-NEXT: OpLoopMerge ; CHECK: OpPhi ; CHECK-NEXT: OpLoopMerge OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %22 "j" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %20 = OpConstant %6 1 %31 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %22 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %33 = OpPhi %6 %9 %5 %21 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %33 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel OpBranch %13 %13 = OpLabel %21 = OpIAdd %6 %33 %20 OpStore %8 %21 OpBranch %10 %12 = OpLabel OpStore %22 %9 OpBranch %23 %23 = OpLabel %34 = OpPhi %6 %9 %12 %32 %26 OpLoopMerge %25 %26 None OpBranch %27 %27 = OpLabel %29 = OpSLessThan %17 %34 %16 OpBranchConditional %29 %24 %25 %24 = OpLabel OpBranch %26 %26 = OpLabel %32 = OpIAdd %6 %34 %31 OpStore %22 %32 OpBranch %23 %25 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true, 20); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core void main() { int[10] a; int[10] b; int[10] c; // Illegal, loop-independent dependence will become a // backward loop-carried antidependence for (int i = 0; i < 10; i++) { a[i] = b[i] + 1; } for (int i = 0; i < 10; i++) { c[i] = a[i+1] + 2; } } */ TEST_F(FusionPassTest, Illegal) { std::string text = R"( ; CHECK: OpPhi ; CHECK-NEXT: OpLoopMerge ; CHECK: OpLoad ; CHECK: OpStore ; CHECK: OpPhi ; CHECK-NEXT: OpLoopMerge ; CHECK: OpLoad ; CHECK: OpStore OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %23 "a" OpName %25 "b" OpName %34 "i" OpName %42 "c" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %19 = OpTypeInt 32 0 %20 = OpConstant %19 10 %21 = OpTypeArray %6 %20 %22 = OpTypePointer Function %21 %29 = OpConstant %6 1 %48 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %23 = OpVariable %22 Function %25 = OpVariable %22 Function %34 = OpVariable %7 Function %42 = OpVariable %22 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %53 = OpPhi %6 %9 %5 %33 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %53 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %27 = OpAccessChain %7 %25 %53 %28 = OpLoad %6 %27 %30 = OpIAdd %6 %28 %29 %31 = OpAccessChain %7 %23 %53 OpStore %31 %30 OpBranch %13 %13 = OpLabel %33 = OpIAdd %6 %53 %29 OpStore %8 %33 OpBranch %10 %12 = OpLabel OpStore %34 %9 OpBranch %35 %35 = OpLabel %54 = OpPhi %6 %9 %12 %52 %38 OpLoopMerge %37 %38 None OpBranch %39 %39 = OpLabel %41 = OpSLessThan %17 %54 %16 OpBranchConditional %41 %36 %37 %36 = OpLabel %45 = OpIAdd %6 %54 %29 %46 = OpAccessChain %7 %23 %45 %47 = OpLoad %6 %46 %49 = OpIAdd %6 %47 %48 %50 = OpAccessChain %7 %42 %54 OpStore %50 %49 OpBranch %38 %38 = OpLabel %52 = OpIAdd %6 %54 %29 OpStore %34 %52 OpBranch %35 %37 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true, 20); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core void main() { int[10] a; int[10] b; for (int i = 0; i < 10; i++) { a[i] = a[i]*2; } for (int i = 0; i < 10; i++) { b[i] = a[i]+2; } } */ TEST_F(FusionPassTest, TooManyRegisters) { const std::string text = R"( ; CHECK: OpPhi ; CHECK-NEXT: OpLoopMerge ; CHECK: OpLoad ; CHECK: OpStore ; CHECK: OpPhi ; CHECK-NEXT: OpLoopMerge ; CHECK: OpLoad ; CHECK: OpStore OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" OpName %8 "i" OpName %23 "a" OpName %34 "i" OpName %42 "b" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %19 = OpTypeInt 32 0 %20 = OpConstant %19 10 %21 = OpTypeArray %6 %20 %22 = OpTypePointer Function %21 %28 = OpConstant %6 2 %32 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %23 = OpVariable %22 Function %34 = OpVariable %7 Function %42 = OpVariable %22 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel %51 = OpPhi %6 %9 %5 %33 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %51 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %26 = OpAccessChain %7 %23 %51 %27 = OpLoad %6 %26 %29 = OpIMul %6 %27 %28 %30 = OpAccessChain %7 %23 %51 OpStore %30 %29 OpBranch %13 %13 = OpLabel %33 = OpIAdd %6 %51 %32 OpStore %8 %33 OpBranch %10 %12 = OpLabel OpStore %34 %9 OpBranch %35 %35 = OpLabel %52 = OpPhi %6 %9 %12 %50 %38 OpLoopMerge %37 %38 None OpBranch %39 %39 = OpLabel %41 = OpSLessThan %17 %52 %16 OpBranchConditional %41 %36 %37 %36 = OpLabel %45 = OpAccessChain %7 %23 %52 %46 = OpLoad %6 %45 %47 = OpIAdd %6 %46 %28 %48 = OpAccessChain %7 %42 %52 OpStore %48 %47 OpBranch %38 %38 = OpLabel %50 = OpIAdd %6 %52 %32 OpStore %34 %50 OpBranch %35 %37 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true, 5); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/loop_optimizations/hoist_access_chains.cpp000066400000000000000000000110021475742701700307460ustar00rootroot00000000000000// Copyright (c) 2023 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gmock/gmock.h" #include "source/opt/licm_pass.h" #include "test/opt/pass_fixture.h" namespace spvtools { namespace opt { namespace { using PassClassTest = PassTest<::testing::Test>; /* Tests for the LICM pass to check it handles access chains correctly Generated from the following GLSL fragment shader --eliminate-local-multi-store has also been run on the spv binary #version 460 void main() { for (uint i = 0; i < 123u; ++i) { vec2 do_not_hoist_store = vec2(0.0f); float do_not_hoist_access_chain_load = do_not_hoist_store.x; } } */ TEST_F(PassClassTest, HoistAccessChains) { const std::string before_hoist = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 460 OpName %main "main" OpName %i "i" OpName %do_not_hoist_store "do_not_hoist_store" OpName %do_not_hoist_access_chain_load "do_not_hoist_access_chain_load" %void = OpTypeVoid %7 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_ptr_Function_uint = OpTypePointer Function %uint %uint_0 = OpConstant %uint 0 %uint_123 = OpConstant %uint 123 %bool = OpTypeBool %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %_ptr_Function_v2float = OpTypePointer Function %v2float %float_0 = OpConstant %float 0 %17 = OpConstantComposite %v2float %float_0 %float_0 %_ptr_Function_float = OpTypePointer Function %float %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %main = OpFunction %void None %7 %21 = OpLabel %i = OpVariable %_ptr_Function_uint Function %do_not_hoist_store = OpVariable %_ptr_Function_v2float Function %do_not_hoist_access_chain_load = OpVariable %_ptr_Function_float Function OpStore %i %uint_0 OpBranch %22 %22 = OpLabel OpLoopMerge %23 %24 None OpBranch %25 %25 = OpLabel %26 = OpLoad %uint %i %27 = OpULessThan %bool %26 %uint_123 OpBranchConditional %27 %28 %23 %28 = OpLabel OpStore %do_not_hoist_store %17 %29 = OpAccessChain %_ptr_Function_float %do_not_hoist_store %uint_0 %30 = OpLoad %float %29 OpStore %do_not_hoist_access_chain_load %30 OpBranch %24 %24 = OpLabel %31 = OpLoad %uint %i %32 = OpIAdd %uint %31 %int_1 OpStore %i %32 OpBranch %22 %23 = OpLabel OpReturn OpFunctionEnd )"; const std::string after_hoist = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 460 OpName %main "main" OpName %i "i" OpName %do_not_hoist_store "do_not_hoist_store" OpName %do_not_hoist_access_chain_load "do_not_hoist_access_chain_load" %void = OpTypeVoid %7 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_ptr_Function_uint = OpTypePointer Function %uint %uint_0 = OpConstant %uint 0 %uint_123 = OpConstant %uint 123 %bool = OpTypeBool %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %_ptr_Function_v2float = OpTypePointer Function %v2float %float_0 = OpConstant %float 0 %17 = OpConstantComposite %v2float %float_0 %float_0 %_ptr_Function_float = OpTypePointer Function %float %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %main = OpFunction %void None %7 %21 = OpLabel %i = OpVariable %_ptr_Function_uint Function %do_not_hoist_store = OpVariable %_ptr_Function_v2float Function %do_not_hoist_access_chain_load = OpVariable %_ptr_Function_float Function OpStore %i %uint_0 %29 = OpAccessChain %_ptr_Function_float %do_not_hoist_store %uint_0 OpBranch %22 %22 = OpLabel OpLoopMerge %23 %24 None OpBranch %25 %25 = OpLabel %26 = OpLoad %uint %i %27 = OpULessThan %bool %26 %uint_123 OpBranchConditional %27 %28 %23 %28 = OpLabel OpStore %do_not_hoist_store %17 %30 = OpLoad %float %29 OpStore %do_not_hoist_access_chain_load %30 OpBranch %24 %24 = OpLabel %31 = OpLoad %uint %i %32 = OpIAdd %uint %31 %int_1 OpStore %i %32 OpBranch %22 %23 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(before_hoist, after_hoist, true); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/loop_optimizations/hoist_all_loop_types.cpp000066400000000000000000000144571475742701700312260ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gmock/gmock.h" #include "source/opt/licm_pass.h" #include "test/opt/pass_fixture.h" namespace spvtools { namespace opt { namespace { using ::testing::UnorderedElementsAre; using PassClassTest = PassTest<::testing::Test>; /* Tests that all loop types are handled appropriately by the LICM pass. Generated from the following GLSL fragment shader --eliminate-local-multi-store has also been run on the spv binary #version 440 core void main(){ int i_1 = 0; for (i_1 = 0; i_1 < 10; i_1++) { } int i_2 = 0; while (i_2 < 10) { i_2++; } int i_3 = 0; do { i_3++; } while (i_3 < 10); int hoist = 0; int i_4 = 0; int i_5 = 0; int i_6 = 0; for (i_4 = 0; i_4 < 10; i_4++) { while (i_5 < 10) { do { hoist = i_1 + i_2 + i_3; i_6++; } while (i_6 < 10); i_5++; } } } */ TEST_F(PassClassTest, AllLoopTypes) { const std::string before_hoist = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 440 OpName %main "main" %void = OpTypeVoid %4 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %bool = OpTypeBool %int_1 = OpConstant %int 1 %main = OpFunction %void None %4 %11 = OpLabel OpBranch %12 %12 = OpLabel %13 = OpPhi %int %int_0 %11 %14 %15 OpLoopMerge %16 %15 None OpBranch %17 %17 = OpLabel %18 = OpSLessThan %bool %13 %int_10 OpBranchConditional %18 %19 %16 %19 = OpLabel OpBranch %15 %15 = OpLabel %14 = OpIAdd %int %13 %int_1 OpBranch %12 %16 = OpLabel OpBranch %20 %20 = OpLabel %21 = OpPhi %int %int_0 %16 %22 %23 OpLoopMerge %24 %23 None OpBranch %25 %25 = OpLabel %26 = OpSLessThan %bool %21 %int_10 OpBranchConditional %26 %27 %24 %27 = OpLabel %22 = OpIAdd %int %21 %int_1 OpBranch %23 %23 = OpLabel OpBranch %20 %24 = OpLabel OpBranch %28 %28 = OpLabel %29 = OpPhi %int %int_0 %24 %30 %31 OpLoopMerge %32 %31 None OpBranch %33 %33 = OpLabel %30 = OpIAdd %int %29 %int_1 OpBranch %31 %31 = OpLabel %34 = OpSLessThan %bool %30 %int_10 OpBranchConditional %34 %28 %32 %32 = OpLabel OpBranch %35 %35 = OpLabel %36 = OpPhi %int %int_0 %32 %37 %38 %39 = OpPhi %int %int_0 %32 %40 %38 %41 = OpPhi %int %int_0 %32 %42 %38 %43 = OpPhi %int %int_0 %32 %44 %38 OpLoopMerge %45 %38 None OpBranch %46 %46 = OpLabel %47 = OpSLessThan %bool %39 %int_10 OpBranchConditional %47 %48 %45 %48 = OpLabel OpBranch %49 %49 = OpLabel %37 = OpPhi %int %36 %48 %50 %51 %42 = OpPhi %int %41 %48 %52 %51 %44 = OpPhi %int %43 %48 %53 %51 OpLoopMerge %54 %51 None OpBranch %55 %55 = OpLabel %56 = OpSLessThan %bool %42 %int_10 OpBranchConditional %56 %57 %54 %57 = OpLabel OpBranch %58 %58 = OpLabel %59 = OpPhi %int %37 %57 %50 %60 %61 = OpPhi %int %44 %57 %53 %60 OpLoopMerge %62 %60 None OpBranch %63 %63 = OpLabel %64 = OpIAdd %int %13 %21 %50 = OpIAdd %int %64 %30 %53 = OpIAdd %int %61 %int_1 OpBranch %60 %60 = OpLabel %65 = OpSLessThan %bool %53 %int_10 OpBranchConditional %65 %58 %62 %62 = OpLabel %52 = OpIAdd %int %42 %int_1 OpBranch %51 %51 = OpLabel OpBranch %49 %54 = OpLabel OpBranch %38 %38 = OpLabel %40 = OpIAdd %int %39 %int_1 OpBranch %35 %45 = OpLabel OpReturn OpFunctionEnd )"; const std::string after_hoist = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 440 OpName %main "main" %void = OpTypeVoid %4 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %bool = OpTypeBool %int_1 = OpConstant %int 1 %main = OpFunction %void None %4 %11 = OpLabel OpBranch %12 %12 = OpLabel %13 = OpPhi %int %int_0 %11 %14 %15 OpLoopMerge %16 %15 None OpBranch %17 %17 = OpLabel %18 = OpSLessThan %bool %13 %int_10 OpBranchConditional %18 %19 %16 %19 = OpLabel OpBranch %15 %15 = OpLabel %14 = OpIAdd %int %13 %int_1 OpBranch %12 %16 = OpLabel OpBranch %20 %20 = OpLabel %21 = OpPhi %int %int_0 %16 %22 %23 OpLoopMerge %24 %23 None OpBranch %25 %25 = OpLabel %26 = OpSLessThan %bool %21 %int_10 OpBranchConditional %26 %27 %24 %27 = OpLabel %22 = OpIAdd %int %21 %int_1 OpBranch %23 %23 = OpLabel OpBranch %20 %24 = OpLabel OpBranch %28 %28 = OpLabel %29 = OpPhi %int %int_0 %24 %30 %31 OpLoopMerge %32 %31 None OpBranch %33 %33 = OpLabel %30 = OpIAdd %int %29 %int_1 OpBranch %31 %31 = OpLabel %34 = OpSLessThan %bool %30 %int_10 OpBranchConditional %34 %28 %32 %32 = OpLabel %64 = OpIAdd %int %13 %21 %50 = OpIAdd %int %64 %30 OpBranch %35 %35 = OpLabel %36 = OpPhi %int %int_0 %32 %37 %38 %39 = OpPhi %int %int_0 %32 %40 %38 %41 = OpPhi %int %int_0 %32 %42 %38 %43 = OpPhi %int %int_0 %32 %44 %38 OpLoopMerge %45 %38 None OpBranch %46 %46 = OpLabel %47 = OpSLessThan %bool %39 %int_10 OpBranchConditional %47 %48 %45 %48 = OpLabel OpBranch %49 %49 = OpLabel %37 = OpPhi %int %36 %48 %50 %51 %42 = OpPhi %int %41 %48 %52 %51 %44 = OpPhi %int %43 %48 %53 %51 OpLoopMerge %54 %51 None OpBranch %55 %55 = OpLabel %56 = OpSLessThan %bool %42 %int_10 OpBranchConditional %56 %57 %54 %57 = OpLabel OpBranch %58 %58 = OpLabel %59 = OpPhi %int %37 %57 %50 %60 %61 = OpPhi %int %44 %57 %53 %60 OpLoopMerge %62 %60 None OpBranch %63 %63 = OpLabel %53 = OpIAdd %int %61 %int_1 OpBranch %60 %60 = OpLabel %65 = OpSLessThan %bool %53 %int_10 OpBranchConditional %65 %58 %62 %62 = OpLabel %52 = OpIAdd %int %42 %int_1 OpBranch %51 %51 = OpLabel OpBranch %49 %54 = OpLabel OpBranch %38 %38 = OpLabel %40 = OpIAdd %int %39 %int_1 OpBranch %35 %45 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(before_hoist, after_hoist, true); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/loop_optimizations/hoist_double_nested_loops.cpp000066400000000000000000000076101475742701700322220ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gmock/gmock.h" #include "source/opt/licm_pass.h" #include "test/opt/pass_fixture.h" namespace spvtools { namespace opt { namespace { using ::testing::UnorderedElementsAre; using PassClassTest = PassTest<::testing::Test>; /* Tests that the LICM pass will move invariants through multiple loops Generated from the following GLSL fragment shader --eliminate-local-multi-store has also been run on the spv binary #version 440 core void main(){ int a = 2; int b = 1; int hoist = 0; for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { // hoist 'hoist = a - b' out of both loops hoist = a - b; } } } */ TEST_F(PassClassTest, NestedDoubleHoist) { const std::string before_hoist = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 440 OpName %main "main" %void = OpTypeVoid %4 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_2 = OpConstant %int 2 %int_1 = OpConstant %int 1 %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %bool = OpTypeBool %12 = OpUndef %int %main = OpFunction %void None %4 %13 = OpLabel OpBranch %14 %14 = OpLabel %15 = OpPhi %int %int_0 %13 %16 %17 %18 = OpPhi %int %int_0 %13 %19 %17 %20 = OpPhi %int %12 %13 %21 %17 OpLoopMerge %22 %17 None OpBranch %23 %23 = OpLabel %24 = OpSLessThan %bool %18 %int_10 OpBranchConditional %24 %25 %22 %25 = OpLabel OpBranch %26 %26 = OpLabel %16 = OpPhi %int %15 %25 %27 %28 %21 = OpPhi %int %int_0 %25 %29 %28 OpLoopMerge %30 %28 None OpBranch %31 %31 = OpLabel %32 = OpSLessThan %bool %21 %int_10 OpBranchConditional %32 %33 %30 %33 = OpLabel %27 = OpISub %int %int_2 %int_1 OpBranch %28 %28 = OpLabel %29 = OpIAdd %int %21 %int_1 OpBranch %26 %30 = OpLabel OpBranch %17 %17 = OpLabel %19 = OpIAdd %int %18 %int_1 OpBranch %14 %22 = OpLabel OpReturn OpFunctionEnd )"; const std::string after_hoist = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 440 OpName %main "main" %void = OpTypeVoid %4 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_2 = OpConstant %int 2 %int_1 = OpConstant %int 1 %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %bool = OpTypeBool %12 = OpUndef %int %main = OpFunction %void None %4 %13 = OpLabel %27 = OpISub %int %int_2 %int_1 OpBranch %14 %14 = OpLabel %15 = OpPhi %int %int_0 %13 %16 %17 %18 = OpPhi %int %int_0 %13 %19 %17 %20 = OpPhi %int %12 %13 %21 %17 OpLoopMerge %22 %17 None OpBranch %23 %23 = OpLabel %24 = OpSLessThan %bool %18 %int_10 OpBranchConditional %24 %25 %22 %25 = OpLabel OpBranch %26 %26 = OpLabel %16 = OpPhi %int %15 %25 %27 %28 %21 = OpPhi %int %int_0 %25 %29 %28 OpLoopMerge %30 %28 None OpBranch %31 %31 = OpLabel %32 = OpSLessThan %bool %21 %int_10 OpBranchConditional %32 %33 %30 %33 = OpLabel OpBranch %28 %28 = OpLabel %29 = OpIAdd %int %21 %int_1 OpBranch %26 %30 = OpLabel OpBranch %17 %17 = OpLabel %19 = OpIAdd %int %18 %int_1 OpBranch %14 %22 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(before_hoist, after_hoist, true); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/loop_optimizations/hoist_from_independent_loops.cpp000066400000000000000000000112361475742701700327250ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gmock/gmock.h" #include "source/opt/licm_pass.h" #include "test/opt/pass_fixture.h" namespace spvtools { namespace opt { namespace { using ::testing::UnorderedElementsAre; using PassClassTest = PassTest<::testing::Test>; /* Tests that the LICM pass will analyse multiple independent loops in a function Generated from the following GLSL fragment shader --eliminate-local-multi-store has also been run on the spv binary #version 440 core void main(){ int a = 1; int b = 2; int hoist = 0; for (int i = 0; i < 10; i++) { // invariant hoist = a + b; } for (int i = 0; i < 10; i++) { // invariant hoist = a + b; } int c = 1; int d = 2; int hoist2 = 0; for (int i = 0; i < 10; i++) { // invariant hoist2 = c + d; } } */ TEST_F(PassClassTest, HoistFromIndependentLoops) { const std::string before_hoist = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 440 OpName %main "main" %void = OpTypeVoid %4 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %bool = OpTypeBool %main = OpFunction %void None %4 %12 = OpLabel OpBranch %13 %13 = OpLabel %14 = OpPhi %int %int_0 %12 %15 %16 %17 = OpPhi %int %int_0 %12 %18 %16 OpLoopMerge %19 %16 None OpBranch %20 %20 = OpLabel %21 = OpSLessThan %bool %17 %int_10 OpBranchConditional %21 %22 %19 %22 = OpLabel %15 = OpIAdd %int %int_1 %int_2 OpBranch %16 %16 = OpLabel %18 = OpIAdd %int %17 %int_1 OpBranch %13 %19 = OpLabel OpBranch %23 %23 = OpLabel %24 = OpPhi %int %14 %19 %25 %26 %27 = OpPhi %int %int_0 %19 %28 %26 OpLoopMerge %29 %26 None OpBranch %30 %30 = OpLabel %31 = OpSLessThan %bool %27 %int_10 OpBranchConditional %31 %32 %29 %32 = OpLabel %25 = OpIAdd %int %int_1 %int_2 OpBranch %26 %26 = OpLabel %28 = OpIAdd %int %27 %int_1 OpBranch %23 %29 = OpLabel OpBranch %33 %33 = OpLabel %34 = OpPhi %int %int_0 %29 %35 %36 %37 = OpPhi %int %int_0 %29 %38 %36 OpLoopMerge %39 %36 None OpBranch %40 %40 = OpLabel %41 = OpSLessThan %bool %37 %int_10 OpBranchConditional %41 %42 %39 %42 = OpLabel %35 = OpIAdd %int %int_1 %int_2 OpBranch %36 %36 = OpLabel %38 = OpIAdd %int %37 %int_1 OpBranch %33 %39 = OpLabel OpReturn OpFunctionEnd )"; const std::string after_hoist = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 440 OpName %main "main" %void = OpTypeVoid %4 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %bool = OpTypeBool %main = OpFunction %void None %4 %12 = OpLabel %15 = OpIAdd %int %int_1 %int_2 OpBranch %13 %13 = OpLabel %14 = OpPhi %int %int_0 %12 %15 %16 %17 = OpPhi %int %int_0 %12 %18 %16 OpLoopMerge %19 %16 None OpBranch %20 %20 = OpLabel %21 = OpSLessThan %bool %17 %int_10 OpBranchConditional %21 %22 %19 %22 = OpLabel OpBranch %16 %16 = OpLabel %18 = OpIAdd %int %17 %int_1 OpBranch %13 %19 = OpLabel %25 = OpIAdd %int %int_1 %int_2 OpBranch %23 %23 = OpLabel %24 = OpPhi %int %14 %19 %25 %26 %27 = OpPhi %int %int_0 %19 %28 %26 OpLoopMerge %29 %26 None OpBranch %30 %30 = OpLabel %31 = OpSLessThan %bool %27 %int_10 OpBranchConditional %31 %32 %29 %32 = OpLabel OpBranch %26 %26 = OpLabel %28 = OpIAdd %int %27 %int_1 OpBranch %23 %29 = OpLabel %35 = OpIAdd %int %int_1 %int_2 OpBranch %33 %33 = OpLabel %34 = OpPhi %int %int_0 %29 %35 %36 %37 = OpPhi %int %int_0 %29 %38 %36 OpLoopMerge %39 %36 None OpBranch %40 %40 = OpLabel %41 = OpSLessThan %bool %37 %int_10 OpBranchConditional %41 %42 %39 %42 = OpLabel OpBranch %36 %36 = OpLabel %38 = OpIAdd %int %37 %int_1 OpBranch %33 %39 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(before_hoist, after_hoist, true); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/loop_optimizations/hoist_simple_case.cpp000066400000000000000000000060701475742701700304550ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gmock/gmock.h" #include "source/opt/licm_pass.h" #include "test/opt/pass_fixture.h" namespace spvtools { namespace opt { namespace { using ::testing::UnorderedElementsAre; using PassClassTest = PassTest<::testing::Test>; /* A simple test for the LICM pass Generated from the following GLSL fragment shader --eliminate-local-multi-store has also been run on the spv binary #version 440 core void main(){ int a = 1; int b = 2; int hoist = 0; for (int i = 0; i < 10; i++) { // invariant hoist = a + b; } } */ TEST_F(PassClassTest, SimpleHoist) { const std::string before_hoist = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 440 OpName %main "main" %void = OpTypeVoid %4 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %bool = OpTypeBool %main = OpFunction %void None %4 %12 = OpLabel OpBranch %13 %13 = OpLabel %14 = OpPhi %int %int_0 %12 %15 %16 %17 = OpPhi %int %int_0 %12 %18 %16 OpLoopMerge %19 %16 None OpBranch %20 %20 = OpLabel %21 = OpSLessThan %bool %17 %int_10 OpBranchConditional %21 %22 %19 %22 = OpLabel %15 = OpIAdd %int %int_1 %int_2 OpBranch %16 %16 = OpLabel %18 = OpIAdd %int %17 %int_1 OpBranch %13 %19 = OpLabel OpReturn OpFunctionEnd )"; const std::string after_hoist = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 440 OpName %main "main" %void = OpTypeVoid %4 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %bool = OpTypeBool %main = OpFunction %void None %4 %12 = OpLabel %15 = OpIAdd %int %int_1 %int_2 OpBranch %13 %13 = OpLabel %14 = OpPhi %int %int_0 %12 %15 %16 %17 = OpPhi %int %int_0 %12 %18 %16 OpLoopMerge %19 %16 None OpBranch %20 %20 = OpLabel %21 = OpSLessThan %bool %17 %int_10 OpBranchConditional %21 %22 %19 %22 = OpLabel OpBranch %16 %16 = OpLabel %18 = OpIAdd %int %17 %int_1 OpBranch %13 %19 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(before_hoist, after_hoist, true); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/loop_optimizations/hoist_single_nested_loops.cpp000066400000000000000000000126001475742701700322240ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gmock/gmock.h" #include "source/opt/licm_pass.h" #include "test/opt/pass_fixture.h" namespace spvtools { namespace opt { namespace { using ::testing::UnorderedElementsAre; using PassClassTest = PassTest<::testing::Test>; /* Tests that the LICM pass will detect an move an invariant from a nested loop, but not it's parent loop Generated from the following GLSL fragment shader --eliminate-local-multi-store has also been run on the spv binary #version 440 core void main(){ int a = 2; int hoist = 0; for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { // hoist 'hoist = a - i' out of j loop, but not i loop hoist = a - i; } } } */ TEST_F(PassClassTest, NestedSingleHoist) { const std::string before_hoist = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 440 OpName %main "main" %void = OpTypeVoid %4 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_2 = OpConstant %int 2 %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %bool = OpTypeBool %int_1 = OpConstant %int 1 %12 = OpUndef %int %main = OpFunction %void None %4 %13 = OpLabel OpBranch %14 %14 = OpLabel %15 = OpPhi %int %int_0 %13 %16 %17 %18 = OpPhi %int %int_0 %13 %19 %17 %20 = OpPhi %int %12 %13 %21 %17 OpLoopMerge %22 %17 None OpBranch %23 %23 = OpLabel %24 = OpSLessThan %bool %18 %int_10 OpBranchConditional %24 %25 %22 %25 = OpLabel OpBranch %26 %26 = OpLabel %16 = OpPhi %int %15 %25 %27 %28 %21 = OpPhi %int %int_0 %25 %29 %28 OpLoopMerge %30 %28 None OpBranch %31 %31 = OpLabel %32 = OpSLessThan %bool %21 %int_10 OpBranchConditional %32 %33 %30 %33 = OpLabel %27 = OpISub %int %int_2 %18 OpBranch %28 %28 = OpLabel %29 = OpIAdd %int %21 %int_1 OpBranch %26 %30 = OpLabel OpBranch %17 %17 = OpLabel %19 = OpIAdd %int %18 %int_1 OpBranch %14 %22 = OpLabel OpReturn OpFunctionEnd )"; const std::string after_hoist = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 440 OpName %main "main" %void = OpTypeVoid %4 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_2 = OpConstant %int 2 %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %bool = OpTypeBool %int_1 = OpConstant %int 1 %12 = OpUndef %int %main = OpFunction %void None %4 %13 = OpLabel OpBranch %14 %14 = OpLabel %15 = OpPhi %int %int_0 %13 %16 %17 %18 = OpPhi %int %int_0 %13 %19 %17 %20 = OpPhi %int %12 %13 %21 %17 OpLoopMerge %22 %17 None OpBranch %23 %23 = OpLabel %24 = OpSLessThan %bool %18 %int_10 OpBranchConditional %24 %25 %22 %25 = OpLabel %27 = OpISub %int %int_2 %18 OpBranch %26 %26 = OpLabel %16 = OpPhi %int %15 %25 %27 %28 %21 = OpPhi %int %int_0 %25 %29 %28 OpLoopMerge %30 %28 None OpBranch %31 %31 = OpLabel %32 = OpSLessThan %bool %21 %int_10 OpBranchConditional %32 %33 %30 %33 = OpLabel OpBranch %28 %28 = OpLabel %29 = OpIAdd %int %21 %int_1 OpBranch %26 %30 = OpLabel OpBranch %17 %17 = OpLabel %19 = OpIAdd %int %18 %int_1 OpBranch %14 %22 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(before_hoist, after_hoist, true); } TEST_F(PassClassTest, PreHeaderIsAlsoHeader) { // Move OpSLessThan out of the inner loop. The preheader for the inner loop // is the header of the outer loop. The loop merge should not be separated // from the branch in that block. const std::string text = R"( ; CHECK: OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpBranch [[header:%\w+]] ; CHECK: [[header]] = OpLabel ; CHECK-NEXT: OpSLessThan %bool %int_1 %int_1 ; CHECK-NEXT: OpLoopMerge OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %void = OpTypeVoid %4 = OpTypeFunction %void %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %bool = OpTypeBool %2 = OpFunction %void None %4 %18 = OpLabel OpBranch %21 %21 = OpLabel OpLoopMerge %22 %23 None OpBranch %24 %24 = OpLabel %25 = OpSLessThan %bool %int_1 %int_1 OpLoopMerge %26 %27 None OpBranchConditional %25 %27 %26 %27 = OpLabel OpBranch %24 %26 = OpLabel OpBranch %22 %23 = OpLabel OpBranch %21 %22 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/loop_optimizations/hoist_without_preheader.cpp000066400000000000000000000117201475742701700317110ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gmock/gmock.h" #include "source/opt/licm_pass.h" #include "test/opt/pass_fixture.h" namespace spvtools { namespace opt { namespace { using ::testing::UnorderedElementsAre; using PassClassTest = PassTest<::testing::Test>; /* Tests that the LICM pass will generate a preheader when one is not present Generated from the following GLSL fragment shader --eliminate-local-multi-store has also been run on the spv binary #version 440 core void main(){ int a = 1; int b = 2; int hoist = 0; for (int i = 0; i < 10; i++) { if (i == 5) { break; } } for (int i = 0; i < 10; i++) { hoist = a + b; } } */ TEST_F(PassClassTest, HoistWithoutPreheader) { const std::string text = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 440 OpName %main "main" %void = OpTypeVoid %4 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %bool = OpTypeBool %int_5 = OpConstant %int 5 %main = OpFunction %void None %4 %13 = OpLabel OpBranch %14 %14 = OpLabel %15 = OpPhi %int %int_0 %13 %16 %17 ; CHECK: OpLoopMerge [[preheader:%\w+]] OpLoopMerge %25 %17 None OpBranch %19 %19 = OpLabel %20 = OpSLessThan %bool %15 %int_10 OpBranchConditional %20 %21 %25 %21 = OpLabel %22 = OpIEqual %bool %15 %int_5 OpSelectionMerge %23 None OpBranchConditional %22 %24 %23 %24 = OpLabel OpBranch %25 %23 = OpLabel OpBranch %17 %17 = OpLabel %16 = OpIAdd %int %15 %int_1 OpBranch %14 ; Check that we hoisted the code to the preheader ; CHECK: [[preheader]] = OpLabel ; CHECK-NEXT: OpPhi ; CHECK-NEXT: OpPhi ; CHECK-NEXT: OpIAdd ; CHECK-NEXT: OpBranch [[header:%\w+]] ; CHECK: [[header]] = OpLabel ; CHECK-NEXT: OpPhi ; CHECK-NEXT: OpPhi ; CHECK: OpLoopMerge %25 = OpLabel %26 = OpPhi %int %int_0 %24 %int_0 %19 %27 %28 %29 = OpPhi %int %int_0 %24 %int_0 %19 %30 %28 OpLoopMerge %31 %28 None OpBranch %32 %32 = OpLabel %33 = OpSLessThan %bool %29 %int_10 OpBranchConditional %33 %34 %31 %34 = OpLabel %27 = OpIAdd %int %int_1 %int_2 OpBranch %28 %28 = OpLabel %30 = OpIAdd %int %29 %int_1 OpBranch %25 %31 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(PassClassTest, HoistWithoutPreheaderAtIdBound) { const std::string text = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 440 OpName %main "main" %void = OpTypeVoid %4 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %bool = OpTypeBool %int_5 = OpConstant %int 5 %main = OpFunction %void None %4 %13 = OpLabel OpBranch %14 %14 = OpLabel %15 = OpPhi %int %int_0 %13 %16 %17 OpLoopMerge %25 %17 None OpBranch %19 %19 = OpLabel %20 = OpSLessThan %bool %15 %int_10 OpBranchConditional %20 %21 %25 %21 = OpLabel %22 = OpIEqual %bool %15 %int_5 OpSelectionMerge %23 None OpBranchConditional %22 %24 %23 %24 = OpLabel OpBranch %25 %23 = OpLabel OpBranch %17 %17 = OpLabel %16 = OpIAdd %int %15 %int_1 OpBranch %14 %25 = OpLabel %26 = OpPhi %int %int_0 %24 %int_0 %19 %27 %28 %29 = OpPhi %int %int_0 %24 %int_0 %19 %30 %28 OpLoopMerge %31 %28 None OpBranch %32 %32 = OpLabel %33 = OpSLessThan %bool %29 %int_10 OpBranchConditional %33 %34 %31 %34 = OpLabel %27 = OpIAdd %int %int_1 %int_2 OpBranch %28 %28 = OpLabel %30 = OpIAdd %int %29 %int_1 OpBranch %25 %31 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); uint32_t current_bound = context->module()->id_bound(); context->set_max_id_bound(current_bound); auto pass = MakeUnique(); auto result = pass->Run(context.get()); EXPECT_EQ(result, Pass::Status::Failure); std::vector binary; context->module()->ToBinary(&binary, false); std::string optimized_asm; SpirvTools tools_(SPV_ENV_UNIVERSAL_1_1); tools_.Disassemble(binary, &optimized_asm); std::cout << optimized_asm << std::endl; } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/loop_optimizations/lcssa.cpp000066400000000000000000000450571475742701700261000ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "effcee/effcee.h" #include "gmock/gmock.h" #include "source/opt/build_module.h" #include "source/opt/loop_descriptor.h" #include "source/opt/loop_utils.h" #include "test/opt//assembly_builder.h" #include "test/opt/function_utils.h" namespace spvtools { namespace opt { namespace { bool Validate(const std::vector& bin) { spv_target_env target_env = SPV_ENV_UNIVERSAL_1_2; spv_context spvContext = spvContextCreate(target_env); spv_diagnostic diagnostic = nullptr; spv_const_binary_t binary = {bin.data(), bin.size()}; spv_result_t error = spvValidate(spvContext, &binary, &diagnostic); if (error != 0) spvDiagnosticPrint(diagnostic); spvDiagnosticDestroy(diagnostic); spvContextDestroy(spvContext); return error == 0; } void Match(const std::string& original, IRContext* context, bool do_validation = true) { std::vector bin; context->module()->ToBinary(&bin, true); if (do_validation) { EXPECT_TRUE(Validate(bin)); } std::string assembly; SpirvTools tools(SPV_ENV_UNIVERSAL_1_2); EXPECT_TRUE( tools.Disassemble(bin, &assembly, SPV_BINARY_TO_TEXT_OPTION_NO_HEADER)) << "Disassembling failed for shader:\n" << assembly << std::endl; auto match_result = effcee::Match(assembly, original); EXPECT_EQ(effcee::Result::Status::Ok, match_result.status()) << match_result.message() << "\nChecking result:\n" << assembly; } using LCSSATest = ::testing::Test; /* Generated from the following GLSL + --eliminate-local-multi-store #version 330 core layout(location = 0) out vec4 c; void main() { int i = 0; for (; i < 10; i++) { } if (i != 0) { i = 1; } } */ TEST_F(LCSSATest, SimpleLCSSA) { const std::string text = R"( ; CHECK: OpLoopMerge [[merge:%\w+]] %19 None ; CHECK: [[merge]] = OpLabel ; CHECK-NEXT: [[phi:%\w+]] = OpPhi {{%\w+}} %30 %20 ; CHECK-NEXT: %27 = OpINotEqual {{%\w+}} [[phi]] %9 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 330 OpName %2 "main" OpName %3 "c" OpDecorate %3 Location 0 %5 = OpTypeVoid %6 = OpTypeFunction %5 %7 = OpTypeInt 32 1 %8 = OpTypePointer Function %7 %9 = OpConstant %7 0 %10 = OpConstant %7 10 %11 = OpTypeBool %12 = OpConstant %7 1 %13 = OpTypeFloat 32 %14 = OpTypeVector %13 4 %15 = OpTypePointer Output %14 %3 = OpVariable %15 Output %2 = OpFunction %5 None %6 %16 = OpLabel OpBranch %17 %17 = OpLabel %30 = OpPhi %7 %9 %16 %25 %19 OpLoopMerge %18 %19 None OpBranch %20 %20 = OpLabel %22 = OpSLessThan %11 %30 %10 OpBranchConditional %22 %23 %18 %23 = OpLabel OpBranch %19 %19 = OpLabel %25 = OpIAdd %7 %30 %12 OpBranch %17 %18 = OpLabel %27 = OpINotEqual %11 %30 %9 OpSelectionMerge %28 None OpBranchConditional %27 %29 %28 %29 = OpLabel OpBranch %28 %28 = OpLabel %31 = OpPhi %7 %30 %18 %12 %29 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 2); LoopDescriptor ld{context.get(), f}; Loop* loop = ld[17]; EXPECT_FALSE(loop->IsLCSSA()); LoopUtils Util(context.get(), loop); Util.MakeLoopClosedSSA(); EXPECT_TRUE(loop->IsLCSSA()); Match(text, context.get()); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 330 core layout(location = 0) out vec4 c; void main() { int i = 0; for (; i < 10; i++) { } if (i != 0) { i = 1; } } */ // Same test as above, but should reuse an existing phi. TEST_F(LCSSATest, PhiReuseLCSSA) { const std::string text = R"( ; CHECK: OpLoopMerge [[merge:%\w+]] %19 None ; CHECK: [[merge]] = OpLabel ; CHECK-NEXT: [[phi:%\w+]] = OpPhi {{%\w+}} %30 %20 ; CHECK-NEXT: %27 = OpINotEqual {{%\w+}} [[phi]] %9 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 330 OpName %2 "main" OpName %3 "c" OpDecorate %3 Location 0 %5 = OpTypeVoid %6 = OpTypeFunction %5 %7 = OpTypeInt 32 1 %8 = OpTypePointer Function %7 %9 = OpConstant %7 0 %10 = OpConstant %7 10 %11 = OpTypeBool %12 = OpConstant %7 1 %13 = OpTypeFloat 32 %14 = OpTypeVector %13 4 %15 = OpTypePointer Output %14 %3 = OpVariable %15 Output %2 = OpFunction %5 None %6 %16 = OpLabel OpBranch %17 %17 = OpLabel %30 = OpPhi %7 %9 %16 %25 %19 OpLoopMerge %18 %19 None OpBranch %20 %20 = OpLabel %22 = OpSLessThan %11 %30 %10 OpBranchConditional %22 %23 %18 %23 = OpLabel OpBranch %19 %19 = OpLabel %25 = OpIAdd %7 %30 %12 OpBranch %17 %18 = OpLabel %32 = OpPhi %7 %30 %20 %27 = OpINotEqual %11 %30 %9 OpSelectionMerge %28 None OpBranchConditional %27 %29 %28 %29 = OpLabel OpBranch %28 %28 = OpLabel %31 = OpPhi %7 %30 %18 %12 %29 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 2); LoopDescriptor ld{context.get(), f}; Loop* loop = ld[17]; EXPECT_FALSE(loop->IsLCSSA()); LoopUtils Util(context.get(), loop); Util.MakeLoopClosedSSA(); EXPECT_TRUE(loop->IsLCSSA()); Match(text, context.get()); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 330 core layout(location = 0) out vec4 c; void main() { int i = 0; int j = 0; for (; i < 10; i++) {} for (; j < 10; j++) {} if (j != 0) { i = 1; } } */ TEST_F(LCSSATest, DualLoopLCSSA) { const std::string text = R"( ; CHECK: %20 = OpLabel ; CHECK-NEXT: [[phi:%\w+]] = OpPhi %6 %17 %21 ; CHECK: %33 = OpLabel ; CHECK-NEXT: {{%\w+}} = OpPhi {{%\w+}} [[phi]] %28 %11 %34 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 330 OpName %2 "main" OpName %3 "c" OpDecorate %3 Location 0 %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpConstant %6 0 %9 = OpConstant %6 10 %10 = OpTypeBool %11 = OpConstant %6 1 %12 = OpTypeFloat 32 %13 = OpTypeVector %12 4 %14 = OpTypePointer Output %13 %3 = OpVariable %14 Output %2 = OpFunction %4 None %5 %15 = OpLabel OpBranch %16 %16 = OpLabel %17 = OpPhi %6 %8 %15 %18 %19 OpLoopMerge %20 %19 None OpBranch %21 %21 = OpLabel %22 = OpSLessThan %10 %17 %9 OpBranchConditional %22 %23 %20 %23 = OpLabel OpBranch %19 %19 = OpLabel %18 = OpIAdd %6 %17 %11 OpBranch %16 %20 = OpLabel OpBranch %24 %24 = OpLabel %25 = OpPhi %6 %8 %20 %26 %27 OpLoopMerge %28 %27 None OpBranch %29 %29 = OpLabel %30 = OpSLessThan %10 %25 %9 OpBranchConditional %30 %31 %28 %31 = OpLabel OpBranch %27 %27 = OpLabel %26 = OpIAdd %6 %25 %11 OpBranch %24 %28 = OpLabel %32 = OpINotEqual %10 %25 %8 OpSelectionMerge %33 None OpBranchConditional %32 %34 %33 %34 = OpLabel OpBranch %33 %33 = OpLabel %35 = OpPhi %6 %17 %28 %11 %34 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 2); LoopDescriptor ld{context.get(), f}; Loop* loop = ld[16]; EXPECT_FALSE(loop->IsLCSSA()); LoopUtils Util(context.get(), loop); Util.MakeLoopClosedSSA(); EXPECT_TRUE(loop->IsLCSSA()); Match(text, context.get()); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 330 core layout(location = 0) out vec4 c; void main() { int i = 0; if (i != 0) { for (; i < 10; i++) {} } if (i != 0) { i = 1; } } */ TEST_F(LCSSATest, PhiUserLCSSA) { const std::string text = R"( ; CHECK: OpLoopMerge [[merge:%\w+]] %22 None ; CHECK: [[merge]] = OpLabel ; CHECK-NEXT: [[phi:%\w+]] = OpPhi {{%\w+}} %20 %24 ; CHECK: %17 = OpLabel ; CHECK-NEXT: {{%\w+}} = OpPhi {{%\w+}} %8 %15 [[phi]] %23 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 330 OpName %2 "main" OpName %3 "c" OpDecorate %3 Location 0 %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpConstant %6 0 %9 = OpTypeBool %10 = OpConstant %6 10 %11 = OpConstant %6 1 %12 = OpTypeFloat 32 %13 = OpTypeVector %12 4 %14 = OpTypePointer Output %13 %3 = OpVariable %14 Output %2 = OpFunction %4 None %5 %15 = OpLabel %16 = OpINotEqual %9 %8 %8 OpSelectionMerge %17 None OpBranchConditional %16 %18 %17 %18 = OpLabel OpBranch %19 %19 = OpLabel %20 = OpPhi %6 %8 %18 %21 %22 OpLoopMerge %23 %22 None OpBranch %24 %24 = OpLabel %25 = OpSLessThan %9 %20 %10 OpBranchConditional %25 %26 %23 %26 = OpLabel OpBranch %22 %22 = OpLabel %21 = OpIAdd %6 %20 %11 OpBranch %19 %23 = OpLabel OpBranch %17 %17 = OpLabel %27 = OpPhi %6 %8 %15 %20 %23 %28 = OpINotEqual %9 %27 %8 OpSelectionMerge %29 None OpBranchConditional %28 %30 %29 %30 = OpLabel OpBranch %29 %29 = OpLabel %31 = OpPhi %6 %27 %17 %11 %30 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 2); LoopDescriptor ld{context.get(), f}; Loop* loop = ld[19]; EXPECT_FALSE(loop->IsLCSSA()); LoopUtils Util(context.get(), loop); Util.MakeLoopClosedSSA(); EXPECT_TRUE(loop->IsLCSSA()); Match(text, context.get()); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 330 core void main() { int i = 0; if (i != 0) { for (; i < 10; i++) { if (i > 5) break; } } if (i != 0) { i = 1; } } */ TEST_F(LCSSATest, LCSSAWithBreak) { const std::string text = R"( ; CHECK: OpLoopMerge [[merge:%\w+]] %19 None ; CHECK: [[merge]] = OpLabel ; CHECK-NEXT: [[phi:%\w+]] = OpPhi {{%\w+}} %17 %21 %17 %26 ; CHECK: %14 = OpLabel ; CHECK-NEXT: {{%\w+}} = OpPhi {{%\w+}} %7 %12 [[phi]] [[merge]] OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 330 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpConstant %5 0 %8 = OpTypeBool %9 = OpConstant %5 10 %10 = OpConstant %5 5 %11 = OpConstant %5 1 %2 = OpFunction %3 None %4 %12 = OpLabel %13 = OpINotEqual %8 %7 %7 OpSelectionMerge %14 None OpBranchConditional %13 %15 %14 %15 = OpLabel OpBranch %16 %16 = OpLabel %17 = OpPhi %5 %7 %15 %18 %19 OpLoopMerge %20 %19 None OpBranch %21 %21 = OpLabel %22 = OpSLessThan %8 %17 %9 OpBranchConditional %22 %23 %20 %23 = OpLabel %24 = OpSGreaterThan %8 %17 %10 OpSelectionMerge %25 None OpBranchConditional %24 %26 %25 %26 = OpLabel OpBranch %20 %25 = OpLabel OpBranch %19 %19 = OpLabel %18 = OpIAdd %5 %17 %11 OpBranch %16 %20 = OpLabel OpBranch %14 %14 = OpLabel %27 = OpPhi %5 %7 %12 %17 %20 %28 = OpINotEqual %8 %27 %7 OpSelectionMerge %29 None OpBranchConditional %28 %30 %29 %30 = OpLabel OpBranch %29 %29 = OpLabel %31 = OpPhi %5 %27 %14 %11 %30 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 2); LoopDescriptor ld{context.get(), f}; Loop* loop = ld[19]; EXPECT_FALSE(loop->IsLCSSA()); LoopUtils Util(context.get(), loop); Util.MakeLoopClosedSSA(); EXPECT_TRUE(loop->IsLCSSA()); Match(text, context.get()); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 330 core void main() { int i = 0; for (; i < 10; i++) {} for (int j = i; j < 10;) { j = i + j; } } */ TEST_F(LCSSATest, LCSSAUseInNonEligiblePhi) { const std::string text = R"( ; CHECK: %12 = OpLabel ; CHECK-NEXT: [[def_to_close:%\w+]] = OpPhi {{%\w+}} {{%\w+}} {{%\w+}} {{%\w+}} [[continue:%\w+]] ; CHECK-NEXT: OpLoopMerge [[merge:%\w+]] [[continue]] None ; CHECK: [[merge]] = OpLabel ; CHECK-NEXT: [[closing_phi:%\w+]] = OpPhi {{%\w+}} [[def_to_close]] %17 ; CHECK: %16 = OpLabel ; CHECK-NEXT: [[use_in_phi:%\w+]] = OpPhi {{%\w+}} %21 %22 [[closing_phi]] [[merge]] ; CHECK: OpIAdd {{%\w+}} [[closing_phi]] [[use_in_phi]] OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 330 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpConstant %5 0 %8 = OpConstant %5 10 %9 = OpTypeBool %10 = OpConstant %5 1 %2 = OpFunction %3 None %4 %11 = OpLabel OpBranch %12 %12 = OpLabel %13 = OpPhi %5 %7 %11 %14 %15 OpLoopMerge %16 %15 None OpBranch %17 %17 = OpLabel %18 = OpSLessThan %9 %13 %8 OpBranchConditional %18 %19 %16 %19 = OpLabel OpBranch %15 %15 = OpLabel %14 = OpIAdd %5 %13 %10 OpBranch %12 %16 = OpLabel %20 = OpPhi %5 %13 %17 %21 %22 OpLoopMerge %23 %22 None OpBranch %24 %24 = OpLabel %25 = OpSLessThan %9 %20 %8 OpBranchConditional %25 %26 %23 %26 = OpLabel %21 = OpIAdd %5 %13 %20 OpBranch %22 %22 = OpLabel OpBranch %16 %23 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 2); LoopDescriptor ld{context.get(), f}; Loop* loop = ld[12]; EXPECT_FALSE(loop->IsLCSSA()); LoopUtils Util(context.get(), loop); Util.MakeLoopClosedSSA(); EXPECT_TRUE(loop->IsLCSSA()); Match(text, context.get()); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/loop_optimizations/loop_descriptions.cpp000066400000000000000000000311421475742701700305200ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gmock/gmock.h" #include "source/opt/loop_descriptor.h" #include "source/opt/pass.h" #include "test/opt/assembly_builder.h" #include "test/opt/function_utils.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using ::testing::UnorderedElementsAre; using PassClassTest = PassTest<::testing::Test>; /* Generated from the following GLSL #version 330 core layout(location = 0) out vec4 c; void main() { int i = 0; for(; i < 10; ++i) { } } */ TEST_F(PassClassTest, BasicVisitFromEntryPoint) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 330 OpName %2 "main" OpName %5 "i" OpName %3 "c" OpDecorate %3 Location 0 %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %10 = OpConstant %8 0 %11 = OpConstant %8 10 %12 = OpTypeBool %13 = OpConstant %8 1 %14 = OpTypeFloat 32 %15 = OpTypeVector %14 4 %16 = OpTypePointer Output %15 %3 = OpVariable %16 Output %2 = OpFunction %6 None %7 %17 = OpLabel %5 = OpVariable %9 Function OpStore %5 %10 OpBranch %18 %18 = OpLabel OpLoopMerge %19 %20 None OpBranch %21 %21 = OpLabel %22 = OpLoad %8 %5 %23 = OpSLessThan %12 %22 %11 OpBranchConditional %23 %24 %19 %24 = OpLabel OpBranch %20 %20 = OpLabel %25 = OpLoad %8 %5 %26 = OpIAdd %8 %25 %13 OpStore %5 %26 OpBranch %18 %19 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 2); LoopDescriptor& ld = *context->GetLoopDescriptor(f); EXPECT_EQ(ld.NumLoops(), 1u); Loop& loop = ld.GetLoopByIndex(0); EXPECT_EQ(loop.GetHeaderBlock(), spvtest::GetBasicBlock(f, 18)); EXPECT_EQ(loop.GetLatchBlock(), spvtest::GetBasicBlock(f, 20)); EXPECT_EQ(loop.GetMergeBlock(), spvtest::GetBasicBlock(f, 19)); EXPECT_FALSE(loop.HasNestedLoops()); EXPECT_FALSE(loop.IsNested()); EXPECT_EQ(loop.GetDepth(), 1u); } /* Generated from the following GLSL: #version 330 core layout(location = 0) out vec4 c; void main() { for(int i = 0; i < 10; ++i) {} for(int i = 0; i < 10; ++i) {} } But it was "hacked" to make the first loop merge block the second loop header. */ TEST_F(PassClassTest, LoopWithNoPreHeader) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 330 OpName %2 "main" OpName %4 "i" OpName %5 "i" OpName %3 "c" OpDecorate %3 Location 0 %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %10 = OpConstant %8 0 %11 = OpConstant %8 10 %12 = OpTypeBool %13 = OpConstant %8 1 %14 = OpTypeFloat 32 %15 = OpTypeVector %14 4 %16 = OpTypePointer Output %15 %3 = OpVariable %16 Output %2 = OpFunction %6 None %7 %17 = OpLabel %4 = OpVariable %9 Function %5 = OpVariable %9 Function OpStore %4 %10 OpStore %5 %10 OpBranch %18 %18 = OpLabel OpLoopMerge %27 %20 None OpBranch %21 %21 = OpLabel %22 = OpLoad %8 %4 %23 = OpSLessThan %12 %22 %11 OpBranchConditional %23 %24 %27 %24 = OpLabel OpBranch %20 %20 = OpLabel %25 = OpLoad %8 %4 %26 = OpIAdd %8 %25 %13 OpStore %4 %26 OpBranch %18 %27 = OpLabel OpLoopMerge %28 %29 None OpBranch %30 %30 = OpLabel %31 = OpLoad %8 %5 %32 = OpSLessThan %12 %31 %11 OpBranchConditional %32 %33 %28 %33 = OpLabel OpBranch %29 %29 = OpLabel %34 = OpLoad %8 %5 %35 = OpIAdd %8 %34 %13 OpStore %5 %35 OpBranch %27 %28 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 2); LoopDescriptor& ld = *context->GetLoopDescriptor(f); EXPECT_EQ(ld.NumLoops(), 2u); Loop* loop = ld[27]; EXPECT_EQ(loop->GetPreHeaderBlock(), nullptr); EXPECT_NE(loop->GetOrCreatePreHeaderBlock(), nullptr); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 330 core in vec4 c; void main() { int i = 0; bool cond = c[0] == 0; for (; i < 10; i++) { if (cond) { return; } else { return; } } bool cond2 = i == 9; } */ TEST_F(PassClassTest, NoLoop) { const std::string text = R"(; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 3 ; Bound: 47 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %16 OpExecutionMode %4 OriginUpperLeft OpSource GLSL 330 OpName %4 "main" OpName %16 "c" OpDecorate %16 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %10 = OpTypeBool %11 = OpTypePointer Function %10 %13 = OpTypeFloat 32 %14 = OpTypeVector %13 4 %15 = OpTypePointer Input %14 %16 = OpVariable %15 Input %17 = OpTypeInt 32 0 %18 = OpConstant %17 0 %19 = OpTypePointer Input %13 %22 = OpConstant %13 0 %30 = OpConstant %6 10 %39 = OpConstant %6 1 %46 = OpUndef %6 %4 = OpFunction %2 None %3 %5 = OpLabel %20 = OpAccessChain %19 %16 %18 %21 = OpLoad %13 %20 %23 = OpFOrdEqual %10 %21 %22 OpBranch %24 %24 = OpLabel %45 = OpPhi %6 %9 %5 %40 %27 OpLoopMerge %26 %27 None OpBranch %28 %28 = OpLabel %31 = OpSLessThan %10 %45 %30 OpBranchConditional %31 %25 %26 %25 = OpLabel OpSelectionMerge %34 None OpBranchConditional %23 %33 %36 %33 = OpLabel OpReturn %36 = OpLabel OpReturn %34 = OpLabel OpBranch %27 %27 = OpLabel %40 = OpIAdd %6 %46 %39 OpBranch %24 %26 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 4); LoopDescriptor ld{context.get(), f}; EXPECT_EQ(ld.NumLoops(), 0u); } /* Generated from following GLSL with latch block artificially inserted to be separate from continue. #version 430 void main(void) { float x[10]; for (int i = 0; i < 10; ++i) { x[i] = i; } } */ TEST_F(PassClassTest, LoopLatchNotContinue) { const std::string text = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "i" OpName %4 "x" %5 = OpTypeVoid %6 = OpTypeFunction %5 %7 = OpTypeInt 32 1 %8 = OpTypePointer Function %7 %9 = OpConstant %7 0 %10 = OpConstant %7 10 %11 = OpTypeBool %12 = OpTypeFloat 32 %13 = OpTypeInt 32 0 %14 = OpConstant %13 10 %15 = OpTypeArray %12 %14 %16 = OpTypePointer Function %15 %17 = OpTypePointer Function %12 %18 = OpConstant %7 1 %2 = OpFunction %5 None %6 %19 = OpLabel %3 = OpVariable %8 Function %4 = OpVariable %16 Function OpStore %3 %9 OpBranch %20 %20 = OpLabel %21 = OpPhi %7 %9 %19 %22 %30 OpLoopMerge %24 %23 None OpBranch %25 %25 = OpLabel %26 = OpSLessThan %11 %21 %10 OpBranchConditional %26 %27 %24 %27 = OpLabel %28 = OpConvertSToF %12 %21 %29 = OpAccessChain %17 %4 %21 OpStore %29 %28 OpBranch %23 %23 = OpLabel %22 = OpIAdd %7 %21 %18 OpStore %3 %22 OpBranch %30 %30 = OpLabel OpBranch %20 %24 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 2); LoopDescriptor ld{context.get(), f}; EXPECT_EQ(ld.NumLoops(), 1u); Loop& loop = ld.GetLoopByIndex(0u); EXPECT_NE(loop.GetLatchBlock(), loop.GetContinueBlock()); EXPECT_EQ(loop.GetContinueBlock()->id(), 23u); EXPECT_EQ(loop.GetLatchBlock()->id(), 30u); } TEST_F(PassClassTest, UnreachableMerge) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %3 = OpTypeFunction %void %1 = OpFunction %void None %3 %4 = OpLabel OpBranch %5 %5 = OpLabel OpLoopMerge %6 %7 None OpBranch %8 %8 = OpLabel OpBranch %9 %9 = OpLabel OpBranch %7 %7 = OpLabel OpBranch %5 %6 = OpLabel OpUnreachable OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_3, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 1); LoopDescriptor ld{context.get(), f}; EXPECT_EQ(ld.NumLoops(), 1u); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/loop_optimizations/loop_fission.cpp000066400000000000000000002512061475742701700274710ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/loop_fission.h" #include #include #include "gmock/gmock.h" #include "source/opt/loop_utils.h" #include "test/opt/assembly_builder.h" #include "test/opt/function_utils.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using ::testing::UnorderedElementsAre; using FissionClassTest = PassTest<::testing::Test>; /* Generated from the following GLSL #version 430 void main(void) { float A[10]; float B[10]; for (int i = 0; i < 10; i++) { A[i] = B[i]; B[i] = A[i]; } } Result should be equivalent to: void main(void) { float A[10]; float B[10]; for (int i = 0; i < 10; i++) { A[i] = B[i]; } for (int i = 0; i < 10; i++) { B[i] = A[i]; } } */ TEST_F(FissionClassTest, SimpleFission) { // clang-format off // With LocalMultiStoreElimPass const std::string source = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "i" OpName %4 "A" OpName %5 "B" %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %10 = OpConstant %8 0 %11 = OpConstant %8 10 %12 = OpTypeBool %13 = OpTypeFloat 32 %14 = OpTypeInt 32 0 %15 = OpConstant %14 10 %16 = OpTypeArray %13 %15 %17 = OpTypePointer Function %16 %18 = OpTypePointer Function %13 %19 = OpConstant %8 1 %2 = OpFunction %6 None %7 %20 = OpLabel %3 = OpVariable %9 Function %4 = OpVariable %17 Function %5 = OpVariable %17 Function OpBranch %21 %21 = OpLabel %22 = OpPhi %8 %10 %20 %23 %24 OpLoopMerge %25 %24 None OpBranch %26 %26 = OpLabel %27 = OpSLessThan %12 %22 %11 OpBranchConditional %27 %28 %25 %28 = OpLabel %29 = OpAccessChain %18 %5 %22 %30 = OpLoad %13 %29 %31 = OpAccessChain %18 %4 %22 OpStore %31 %30 %32 = OpAccessChain %18 %4 %22 %33 = OpLoad %13 %32 %34 = OpAccessChain %18 %5 %22 OpStore %34 %33 OpBranch %24 %24 = OpLabel %23 = OpIAdd %8 %22 %19 OpBranch %21 %25 = OpLabel OpReturn OpFunctionEnd )"; const std::string expected = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "i" OpName %4 "A" OpName %5 "B" %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %10 = OpConstant %8 0 %11 = OpConstant %8 10 %12 = OpTypeBool %13 = OpTypeFloat 32 %14 = OpTypeInt 32 0 %15 = OpConstant %14 10 %16 = OpTypeArray %13 %15 %17 = OpTypePointer Function %16 %18 = OpTypePointer Function %13 %19 = OpConstant %8 1 %2 = OpFunction %6 None %7 %20 = OpLabel %3 = OpVariable %9 Function %4 = OpVariable %17 Function %5 = OpVariable %17 Function OpBranch %35 %35 = OpLabel %36 = OpPhi %8 %10 %20 %47 %46 OpLoopMerge %48 %46 None OpBranch %37 %37 = OpLabel %38 = OpSLessThan %12 %36 %11 OpBranchConditional %38 %39 %48 %39 = OpLabel %40 = OpAccessChain %18 %5 %36 %41 = OpLoad %13 %40 %42 = OpAccessChain %18 %4 %36 OpStore %42 %41 OpBranch %46 %46 = OpLabel %47 = OpIAdd %8 %36 %19 OpBranch %35 %48 = OpLabel OpBranch %21 %21 = OpLabel %22 = OpPhi %8 %10 %48 %23 %24 OpLoopMerge %25 %24 None OpBranch %26 %26 = OpLabel %27 = OpSLessThan %12 %22 %11 OpBranchConditional %27 %28 %25 %28 = OpLabel %32 = OpAccessChain %18 %4 %22 %33 = OpLoad %13 %32 %34 = OpAccessChain %18 %5 %22 OpStore %34 %33 OpBranch %24 %24 = OpLabel %23 = OpIAdd %8 %22 %19 OpBranch %21 %25 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, source, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << source << std::endl; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(source, expected, true); // Check that the loop will NOT be split when provided with a pass-through // register pressure functor which just returns false. SinglePassRunAndCheck( source, source, true, [](const RegisterLiveness::RegionRegisterLiveness&) { return false; }); } /* Generated from the following GLSL #version 430 void main(void) { float A[10]; float B[10]; for (int i = 0; i < 10; i++) { A[i] = B[i]; B[i] = A[i+1]; } } This loop should not be split, as the i+1 dependence would be broken by splitting the loop. */ TEST_F(FissionClassTest, FissionInterdependency) { // clang-format off // With LocalMultiStoreElimPass const std::string source = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "i" OpName %4 "A" OpName %5 "B" %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %10 = OpConstant %8 0 %11 = OpConstant %8 10 %12 = OpTypeBool %13 = OpTypeFloat 32 %14 = OpTypeInt 32 0 %15 = OpConstant %14 10 %16 = OpTypeArray %13 %15 %17 = OpTypePointer Function %16 %18 = OpTypePointer Function %13 %19 = OpConstant %8 1 %2 = OpFunction %6 None %7 %20 = OpLabel %3 = OpVariable %9 Function %4 = OpVariable %17 Function %5 = OpVariable %17 Function OpBranch %21 %21 = OpLabel %22 = OpPhi %8 %10 %20 %23 %24 OpLoopMerge %25 %24 None OpBranch %26 %26 = OpLabel %27 = OpSLessThan %12 %22 %11 OpBranchConditional %27 %28 %25 %28 = OpLabel %29 = OpAccessChain %18 %5 %22 %30 = OpLoad %13 %29 %31 = OpAccessChain %18 %4 %22 OpStore %31 %30 %32 = OpIAdd %8 %22 %19 %33 = OpAccessChain %18 %4 %32 %34 = OpLoad %13 %33 %35 = OpAccessChain %18 %5 %22 OpStore %35 %34 OpBranch %24 %24 = OpLabel %23 = OpIAdd %8 %22 %19 OpBranch %21 %25 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, source, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for ushader:\n" << source << std::endl; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(source, source, true); } /* Generated from the following GLSL #version 430 void main(void) { float A[10]; float B[10]; for (int i = 0; i < 10; i++) { A[i] = B[i]; B[i+1] = A[i]; } } This should not be split as the load B[i] is dependent on the store B[i+1] */ TEST_F(FissionClassTest, FissionInterdependency2) { // clang-format off // With LocalMultiStoreElimPass const std::string source = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "i" OpName %4 "A" OpName %5 "B" %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %10 = OpConstant %8 0 %11 = OpConstant %8 10 %12 = OpTypeBool %13 = OpTypeFloat 32 %14 = OpTypeInt 32 0 %15 = OpConstant %14 10 %16 = OpTypeArray %13 %15 %17 = OpTypePointer Function %16 %18 = OpTypePointer Function %13 %19 = OpConstant %8 1 %2 = OpFunction %6 None %7 %20 = OpLabel %3 = OpVariable %9 Function %4 = OpVariable %17 Function %5 = OpVariable %17 Function OpBranch %21 %21 = OpLabel %22 = OpPhi %8 %10 %20 %23 %24 OpLoopMerge %25 %24 None OpBranch %26 %26 = OpLabel %27 = OpSLessThan %12 %22 %11 OpBranchConditional %27 %28 %25 %28 = OpLabel %29 = OpAccessChain %18 %5 %22 %30 = OpLoad %13 %29 %31 = OpAccessChain %18 %4 %22 OpStore %31 %30 %32 = OpIAdd %8 %22 %19 %33 = OpAccessChain %18 %4 %22 %34 = OpLoad %13 %33 %35 = OpAccessChain %18 %5 %32 OpStore %35 %34 OpBranch %24 %24 = OpLabel %23 = OpIAdd %8 %22 %19 OpBranch %21 %25 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, source, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << source << std::endl; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(source, source, true); } /* #version 430 void main(void) { float A[10]; float B[10]; float C[10] float D[10] for (int i = 0; i < 10; i++) { A[i] = B[i]; B[i] = A[i]; C[i] = D[i]; D[i] = C[i]; } } This should be split into the equivalent of: for (int i = 0; i < 10; i++) { A[i] = B[i]; B[i] = A[i]; } for (int i = 0; i < 10; i++) { C[i] = D[i]; D[i] = C[i]; } We then check that the loop is broken into four for loops like so, if the pass is run twice: for (int i = 0; i < 10; i++) A[i] = B[i]; for (int i = 0; i < 10; i++) B[i] = A[i]; for (int i = 0; i < 10; i++) C[i] = D[i]; for (int i = 0; i < 10; i++) D[i] = C[i]; */ TEST_F(FissionClassTest, FissionMultipleLoadStores) { // clang-format off // With LocalMultiStoreElimPass const std::string source = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "i" OpName %4 "A" OpName %5 "B" OpName %6 "C" OpName %7 "D" %8 = OpTypeVoid %9 = OpTypeFunction %8 %10 = OpTypeInt 32 1 %11 = OpTypePointer Function %10 %12 = OpConstant %10 0 %13 = OpConstant %10 10 %14 = OpTypeBool %15 = OpTypeFloat 32 %16 = OpTypeInt 32 0 %17 = OpConstant %16 10 %18 = OpTypeArray %15 %17 %19 = OpTypePointer Function %18 %20 = OpTypePointer Function %15 %21 = OpConstant %10 1 %2 = OpFunction %8 None %9 %22 = OpLabel %3 = OpVariable %11 Function %4 = OpVariable %19 Function %5 = OpVariable %19 Function %6 = OpVariable %19 Function %7 = OpVariable %19 Function OpBranch %23 %23 = OpLabel %24 = OpPhi %10 %12 %22 %25 %26 OpLoopMerge %27 %26 None OpBranch %28 %28 = OpLabel %29 = OpSLessThan %14 %24 %13 OpBranchConditional %29 %30 %27 %30 = OpLabel %31 = OpAccessChain %20 %5 %24 %32 = OpLoad %15 %31 %33 = OpAccessChain %20 %4 %24 OpStore %33 %32 %34 = OpAccessChain %20 %4 %24 %35 = OpLoad %15 %34 %36 = OpAccessChain %20 %5 %24 OpStore %36 %35 %37 = OpAccessChain %20 %7 %24 %38 = OpLoad %15 %37 %39 = OpAccessChain %20 %6 %24 OpStore %39 %38 %40 = OpAccessChain %20 %6 %24 %41 = OpLoad %15 %40 %42 = OpAccessChain %20 %7 %24 OpStore %42 %41 OpBranch %26 %26 = OpLabel %25 = OpIAdd %10 %24 %21 OpBranch %23 %27 = OpLabel OpReturn OpFunctionEnd )"; const std::string expected = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "i" OpName %4 "A" OpName %5 "B" OpName %6 "C" OpName %7 "D" %8 = OpTypeVoid %9 = OpTypeFunction %8 %10 = OpTypeInt 32 1 %11 = OpTypePointer Function %10 %12 = OpConstant %10 0 %13 = OpConstant %10 10 %14 = OpTypeBool %15 = OpTypeFloat 32 %16 = OpTypeInt 32 0 %17 = OpConstant %16 10 %18 = OpTypeArray %15 %17 %19 = OpTypePointer Function %18 %20 = OpTypePointer Function %15 %21 = OpConstant %10 1 %2 = OpFunction %8 None %9 %22 = OpLabel %3 = OpVariable %11 Function %4 = OpVariable %19 Function %5 = OpVariable %19 Function %6 = OpVariable %19 Function %7 = OpVariable %19 Function OpBranch %43 %43 = OpLabel %44 = OpPhi %10 %12 %22 %61 %60 OpLoopMerge %62 %60 None OpBranch %45 %45 = OpLabel %46 = OpSLessThan %14 %44 %13 OpBranchConditional %46 %47 %62 %47 = OpLabel %48 = OpAccessChain %20 %5 %44 %49 = OpLoad %15 %48 %50 = OpAccessChain %20 %4 %44 OpStore %50 %49 %51 = OpAccessChain %20 %4 %44 %52 = OpLoad %15 %51 %53 = OpAccessChain %20 %5 %44 OpStore %53 %52 OpBranch %60 %60 = OpLabel %61 = OpIAdd %10 %44 %21 OpBranch %43 %62 = OpLabel OpBranch %23 %23 = OpLabel %24 = OpPhi %10 %12 %62 %25 %26 OpLoopMerge %27 %26 None OpBranch %28 %28 = OpLabel %29 = OpSLessThan %14 %24 %13 OpBranchConditional %29 %30 %27 %30 = OpLabel %37 = OpAccessChain %20 %7 %24 %38 = OpLoad %15 %37 %39 = OpAccessChain %20 %6 %24 OpStore %39 %38 %40 = OpAccessChain %20 %6 %24 %41 = OpLoad %15 %40 %42 = OpAccessChain %20 %7 %24 OpStore %42 %41 OpBranch %26 %26 = OpLabel %25 = OpIAdd %10 %24 %21 OpBranch %23 %27 = OpLabel OpReturn OpFunctionEnd )"; const std::string expected_multiple_passes = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "i" OpName %4 "A" OpName %5 "B" OpName %6 "C" OpName %7 "D" %8 = OpTypeVoid %9 = OpTypeFunction %8 %10 = OpTypeInt 32 1 %11 = OpTypePointer Function %10 %12 = OpConstant %10 0 %13 = OpConstant %10 10 %14 = OpTypeBool %15 = OpTypeFloat 32 %16 = OpTypeInt 32 0 %17 = OpConstant %16 10 %18 = OpTypeArray %15 %17 %19 = OpTypePointer Function %18 %20 = OpTypePointer Function %15 %21 = OpConstant %10 1 %2 = OpFunction %8 None %9 %22 = OpLabel %3 = OpVariable %11 Function %4 = OpVariable %19 Function %5 = OpVariable %19 Function %6 = OpVariable %19 Function %7 = OpVariable %19 Function OpBranch %63 %63 = OpLabel %64 = OpPhi %10 %12 %22 %75 %74 OpLoopMerge %76 %74 None OpBranch %65 %65 = OpLabel %66 = OpSLessThan %14 %64 %13 OpBranchConditional %66 %67 %76 %67 = OpLabel %68 = OpAccessChain %20 %5 %64 %69 = OpLoad %15 %68 %70 = OpAccessChain %20 %4 %64 OpStore %70 %69 OpBranch %74 %74 = OpLabel %75 = OpIAdd %10 %64 %21 OpBranch %63 %76 = OpLabel OpBranch %43 %43 = OpLabel %44 = OpPhi %10 %12 %76 %61 %60 OpLoopMerge %62 %60 None OpBranch %45 %45 = OpLabel %46 = OpSLessThan %14 %44 %13 OpBranchConditional %46 %47 %62 %47 = OpLabel %51 = OpAccessChain %20 %4 %44 %52 = OpLoad %15 %51 %53 = OpAccessChain %20 %5 %44 OpStore %53 %52 OpBranch %60 %60 = OpLabel %61 = OpIAdd %10 %44 %21 OpBranch %43 %62 = OpLabel OpBranch %77 %77 = OpLabel %78 = OpPhi %10 %12 %62 %89 %88 OpLoopMerge %90 %88 None OpBranch %79 %79 = OpLabel %80 = OpSLessThan %14 %78 %13 OpBranchConditional %80 %81 %90 %81 = OpLabel %82 = OpAccessChain %20 %7 %78 %83 = OpLoad %15 %82 %84 = OpAccessChain %20 %6 %78 OpStore %84 %83 OpBranch %88 %88 = OpLabel %89 = OpIAdd %10 %78 %21 OpBranch %77 %90 = OpLabel OpBranch %23 %23 = OpLabel %24 = OpPhi %10 %12 %90 %25 %26 OpLoopMerge %27 %26 None OpBranch %28 %28 = OpLabel %29 = OpSLessThan %14 %24 %13 OpBranchConditional %29 %30 %27 %30 = OpLabel %40 = OpAccessChain %20 %6 %24 %41 = OpLoad %15 %40 %42 = OpAccessChain %20 %7 %24 OpStore %42 %41 OpBranch %26 %26 = OpLabel %25 = OpIAdd %10 %24 %21 OpBranch %23 %27 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, source, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << source << std::endl; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(source, expected, true); // By passing 1 as argument we are using the constructor which makes the // criteria to split the loop be if the registers in the loop exceede 1. By // using this constructor we are also enabling multiple passes (disabled by // default). SinglePassRunAndCheck(source, expected_multiple_passes, true, 1); } /* #version 430 void main(void) { int accumulator = 0; float X[10]; float Y[10]; for (int i = 0; i < 10; i++) { X[i] = Y[i]; Y[i] = X[i]; accumulator += i; } } This should be split into the equivalent of: #version 430 void main(void) { int accumulator = 0; float X[10]; float Y[10]; for (int i = 0; i < 10; i++) { X[i] = Y[i]; } for (int i = 0; i < 10; i++) { Y[i] = X[i]; accumulator += i; } } */ TEST_F(FissionClassTest, FissionWithAccumulator) { // clang-format off // With LocalMultiStoreElimPass const std::string source = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "accumulator" OpName %4 "i" OpName %5 "X" OpName %6 "Y" %7 = OpTypeVoid %8 = OpTypeFunction %7 %9 = OpTypeInt 32 1 %10 = OpTypePointer Function %9 %11 = OpConstant %9 0 %12 = OpConstant %9 10 %13 = OpTypeBool %14 = OpTypeFloat 32 %15 = OpTypeInt 32 0 %16 = OpConstant %15 10 %17 = OpTypeArray %14 %16 %18 = OpTypePointer Function %17 %19 = OpTypePointer Function %14 %20 = OpConstant %9 1 %2 = OpFunction %7 None %8 %21 = OpLabel %3 = OpVariable %10 Function %4 = OpVariable %10 Function %5 = OpVariable %18 Function %6 = OpVariable %18 Function OpBranch %22 %22 = OpLabel %23 = OpPhi %9 %11 %21 %24 %25 %26 = OpPhi %9 %11 %21 %27 %25 OpLoopMerge %28 %25 None OpBranch %29 %29 = OpLabel %30 = OpSLessThan %13 %26 %12 OpBranchConditional %30 %31 %28 %31 = OpLabel %32 = OpAccessChain %19 %6 %26 %33 = OpLoad %14 %32 %34 = OpAccessChain %19 %5 %26 OpStore %34 %33 %35 = OpAccessChain %19 %5 %26 %36 = OpLoad %14 %35 %37 = OpAccessChain %19 %6 %26 OpStore %37 %36 %24 = OpIAdd %9 %23 %26 OpBranch %25 %25 = OpLabel %27 = OpIAdd %9 %26 %20 OpBranch %22 %28 = OpLabel OpReturn OpFunctionEnd )"; const std::string expected = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "accumulator" OpName %4 "i" OpName %5 "X" OpName %6 "Y" %7 = OpTypeVoid %8 = OpTypeFunction %7 %9 = OpTypeInt 32 1 %10 = OpTypePointer Function %9 %11 = OpConstant %9 0 %12 = OpConstant %9 10 %13 = OpTypeBool %14 = OpTypeFloat 32 %15 = OpTypeInt 32 0 %16 = OpConstant %15 10 %17 = OpTypeArray %14 %16 %18 = OpTypePointer Function %17 %19 = OpTypePointer Function %14 %20 = OpConstant %9 1 %2 = OpFunction %7 None %8 %21 = OpLabel %3 = OpVariable %10 Function %4 = OpVariable %10 Function %5 = OpVariable %18 Function %6 = OpVariable %18 Function OpBranch %38 %38 = OpLabel %40 = OpPhi %9 %11 %21 %52 %51 OpLoopMerge %53 %51 None OpBranch %41 %41 = OpLabel %42 = OpSLessThan %13 %40 %12 OpBranchConditional %42 %43 %53 %43 = OpLabel %44 = OpAccessChain %19 %6 %40 %45 = OpLoad %14 %44 %46 = OpAccessChain %19 %5 %40 OpStore %46 %45 OpBranch %51 %51 = OpLabel %52 = OpIAdd %9 %40 %20 OpBranch %38 %53 = OpLabel OpBranch %22 %22 = OpLabel %23 = OpPhi %9 %11 %53 %24 %25 %26 = OpPhi %9 %11 %53 %27 %25 OpLoopMerge %28 %25 None OpBranch %29 %29 = OpLabel %30 = OpSLessThan %13 %26 %12 OpBranchConditional %30 %31 %28 %31 = OpLabel %35 = OpAccessChain %19 %5 %26 %36 = OpLoad %14 %35 %37 = OpAccessChain %19 %6 %26 OpStore %37 %36 %24 = OpIAdd %9 %23 %26 OpBranch %25 %25 = OpLabel %27 = OpIAdd %9 %26 %20 OpBranch %22 %28 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, source, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << source << std::endl; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(source, expected, true); } /* Generated from the following glsl: #version 430 layout(location=0) out float x; layout(location=1) out float y; void main(void) { float accumulator_1 = 0; float accumulator_2 = 0; for (int i = 0; i < 10; i++) { accumulator_1 += i; accumulator_2 += i; } x = accumulator_1; y = accumulator_2; } Should be split into equivalent of: void main(void) { float accumulator_1 = 0; float accumulator_2 = 0; for (int i = 0; i < 10; i++) { accumulator_1 += i; } for (int i = 0; i < 10; i++) { accumulator_2 += i; } x = accumulator_1; y = accumulator_2; } */ TEST_F(FissionClassTest, FissionWithPhisUsedOutwithLoop) { // clang-format off // With LocalMultiStoreElimPass const std::string source = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %5 "accumulator_1" OpName %6 "accumulator_2" OpName %7 "i" OpName %3 "x" OpName %4 "y" OpDecorate %3 Location 0 OpDecorate %4 Location 1 %8 = OpTypeVoid %9 = OpTypeFunction %8 %10 = OpTypeFloat 32 %11 = OpTypePointer Function %10 %12 = OpConstant %10 0 %13 = OpTypeInt 32 1 %14 = OpTypePointer Function %13 %15 = OpConstant %13 0 %16 = OpConstant %13 10 %17 = OpTypeBool %18 = OpConstant %13 1 %19 = OpTypePointer Output %10 %3 = OpVariable %19 Output %4 = OpVariable %19 Output %2 = OpFunction %8 None %9 %20 = OpLabel %5 = OpVariable %11 Function %6 = OpVariable %11 Function %7 = OpVariable %14 Function OpBranch %21 %21 = OpLabel %22 = OpPhi %10 %12 %20 %23 %24 %25 = OpPhi %10 %12 %20 %26 %24 %27 = OpPhi %13 %15 %20 %28 %24 OpLoopMerge %29 %24 None OpBranch %30 %30 = OpLabel %31 = OpSLessThan %17 %27 %16 OpBranchConditional %31 %32 %29 %32 = OpLabel %33 = OpConvertSToF %10 %27 %26 = OpFAdd %10 %25 %33 %34 = OpConvertSToF %10 %27 %23 = OpFAdd %10 %22 %34 OpBranch %24 %24 = OpLabel %28 = OpIAdd %13 %27 %18 OpStore %7 %28 OpBranch %21 %29 = OpLabel OpStore %3 %25 OpStore %4 %22 OpReturn OpFunctionEnd )"; const std::string expected = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %5 "accumulator_1" OpName %6 "accumulator_2" OpName %7 "i" OpName %3 "x" OpName %4 "y" OpDecorate %3 Location 0 OpDecorate %4 Location 1 %8 = OpTypeVoid %9 = OpTypeFunction %8 %10 = OpTypeFloat 32 %11 = OpTypePointer Function %10 %12 = OpConstant %10 0 %13 = OpTypeInt 32 1 %14 = OpTypePointer Function %13 %15 = OpConstant %13 0 %16 = OpConstant %13 10 %17 = OpTypeBool %18 = OpConstant %13 1 %19 = OpTypePointer Output %10 %3 = OpVariable %19 Output %4 = OpVariable %19 Output %2 = OpFunction %8 None %9 %20 = OpLabel %5 = OpVariable %11 Function %6 = OpVariable %11 Function %7 = OpVariable %14 Function OpBranch %35 %35 = OpLabel %37 = OpPhi %10 %12 %20 %43 %46 %38 = OpPhi %13 %15 %20 %47 %46 OpLoopMerge %48 %46 None OpBranch %39 %39 = OpLabel %40 = OpSLessThan %17 %38 %16 OpBranchConditional %40 %41 %48 %41 = OpLabel %42 = OpConvertSToF %10 %38 %43 = OpFAdd %10 %37 %42 OpBranch %46 %46 = OpLabel %47 = OpIAdd %13 %38 %18 OpStore %7 %47 OpBranch %35 %48 = OpLabel OpBranch %21 %21 = OpLabel %22 = OpPhi %10 %12 %48 %23 %24 %27 = OpPhi %13 %15 %48 %28 %24 OpLoopMerge %29 %24 None OpBranch %30 %30 = OpLabel %31 = OpSLessThan %17 %27 %16 OpBranchConditional %31 %32 %29 %32 = OpLabel %34 = OpConvertSToF %10 %27 %23 = OpFAdd %10 %22 %34 OpBranch %24 %24 = OpLabel %28 = OpIAdd %13 %27 %18 OpStore %7 %28 OpBranch %21 %29 = OpLabel OpStore %3 %37 OpStore %4 %22 OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, source, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << source << std::endl; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(source, expected, true); } /* #version 430 void main(void) { float A[10][10]; float B[10][10]; for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { A[i][j] = B[i][j]; B[i][j] = A[i][j]; } } } Should be split into equivalent of: #version 430 void main(void) { float A[10][10]; float B[10][10]; for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { A[i][j] = B[i][j]; } for (int j = 0; j < 10; j++) { B[i][j] = A[i][j]; } } } */ TEST_F(FissionClassTest, FissionNested) { // clang-format off // With LocalMultiStoreElimPass const std::string source = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "i" OpName %4 "j" OpName %5 "A" OpName %6 "B" %7 = OpTypeVoid %8 = OpTypeFunction %7 %9 = OpTypeInt 32 1 %10 = OpTypePointer Function %9 %11 = OpConstant %9 0 %12 = OpConstant %9 10 %13 = OpTypeBool %14 = OpTypeFloat 32 %15 = OpTypeInt 32 0 %16 = OpConstant %15 10 %17 = OpTypeArray %14 %16 %18 = OpTypeArray %17 %16 %19 = OpTypePointer Function %18 %20 = OpTypePointer Function %14 %21 = OpConstant %9 1 %2 = OpFunction %7 None %8 %22 = OpLabel %3 = OpVariable %10 Function %4 = OpVariable %10 Function %5 = OpVariable %19 Function %6 = OpVariable %19 Function OpStore %3 %11 OpBranch %23 %23 = OpLabel %24 = OpPhi %9 %11 %22 %25 %26 OpLoopMerge %27 %26 None OpBranch %28 %28 = OpLabel %29 = OpSLessThan %13 %24 %12 OpBranchConditional %29 %30 %27 %30 = OpLabel OpStore %4 %11 OpBranch %31 %31 = OpLabel %32 = OpPhi %9 %11 %30 %33 %34 OpLoopMerge %35 %34 None OpBranch %36 %36 = OpLabel %37 = OpSLessThan %13 %32 %12 OpBranchConditional %37 %38 %35 %38 = OpLabel %39 = OpAccessChain %20 %6 %24 %32 %40 = OpLoad %14 %39 %41 = OpAccessChain %20 %5 %24 %32 OpStore %41 %40 %42 = OpAccessChain %20 %5 %24 %32 %43 = OpLoad %14 %42 %44 = OpAccessChain %20 %6 %24 %32 OpStore %44 %43 OpBranch %34 %34 = OpLabel %33 = OpIAdd %9 %32 %21 OpStore %4 %33 OpBranch %31 %35 = OpLabel OpBranch %26 %26 = OpLabel %25 = OpIAdd %9 %24 %21 OpStore %3 %25 OpBranch %23 %27 = OpLabel OpReturn OpFunctionEnd )"; const std::string expected = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "i" OpName %4 "j" OpName %5 "A" OpName %6 "B" %7 = OpTypeVoid %8 = OpTypeFunction %7 %9 = OpTypeInt 32 1 %10 = OpTypePointer Function %9 %11 = OpConstant %9 0 %12 = OpConstant %9 10 %13 = OpTypeBool %14 = OpTypeFloat 32 %15 = OpTypeInt 32 0 %16 = OpConstant %15 10 %17 = OpTypeArray %14 %16 %18 = OpTypeArray %17 %16 %19 = OpTypePointer Function %18 %20 = OpTypePointer Function %14 %21 = OpConstant %9 1 %2 = OpFunction %7 None %8 %22 = OpLabel %3 = OpVariable %10 Function %4 = OpVariable %10 Function %5 = OpVariable %19 Function %6 = OpVariable %19 Function OpStore %3 %11 OpBranch %23 %23 = OpLabel %24 = OpPhi %9 %11 %22 %25 %26 OpLoopMerge %27 %26 None OpBranch %28 %28 = OpLabel %29 = OpSLessThan %13 %24 %12 OpBranchConditional %29 %30 %27 %30 = OpLabel OpStore %4 %11 OpBranch %45 %45 = OpLabel %46 = OpPhi %9 %11 %30 %57 %56 OpLoopMerge %58 %56 None OpBranch %47 %47 = OpLabel %48 = OpSLessThan %13 %46 %12 OpBranchConditional %48 %49 %58 %49 = OpLabel %50 = OpAccessChain %20 %6 %24 %46 %51 = OpLoad %14 %50 %52 = OpAccessChain %20 %5 %24 %46 OpStore %52 %51 OpBranch %56 %56 = OpLabel %57 = OpIAdd %9 %46 %21 OpStore %4 %57 OpBranch %45 %58 = OpLabel OpBranch %31 %31 = OpLabel %32 = OpPhi %9 %11 %58 %33 %34 OpLoopMerge %35 %34 None OpBranch %36 %36 = OpLabel %37 = OpSLessThan %13 %32 %12 OpBranchConditional %37 %38 %35 %38 = OpLabel %42 = OpAccessChain %20 %5 %24 %32 %43 = OpLoad %14 %42 %44 = OpAccessChain %20 %6 %24 %32 OpStore %44 %43 OpBranch %34 %34 = OpLabel %33 = OpIAdd %9 %32 %21 OpStore %4 %33 OpBranch %31 %35 = OpLabel OpBranch %26 %26 = OpLabel %25 = OpIAdd %9 %24 %21 OpStore %3 %25 OpBranch %23 %27 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, source, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << source << std::endl; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(source, expected, true); } /* #version 430 void main(void) { int accumulator = 0; float A[10]; float B[10]; float C[10]; for (int i = 0; i < 10; i++) { int c = C[i]; A[i] = B[i]; B[i] = A[i] + c; } } This loop should not be split as we would have to break the order of the loads to do so. It would be grouped into two sets: 1 int c = C[i]; B[i] = A[i] + c; 2 A[i] = B[i]; To keep the load C[i] in the same order we would need to put B[i] ahead of that */ TEST_F(FissionClassTest, FissionLoad) { // clang-format off // With LocalMultiStoreElimPass const std::string source = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "i" OpName %4 "c" OpName %5 "C" OpName %6 "A" OpName %7 "B" %8 = OpTypeVoid %9 = OpTypeFunction %8 %10 = OpTypeInt 32 1 %11 = OpTypePointer Function %10 %12 = OpConstant %10 0 %13 = OpConstant %10 10 %14 = OpTypeBool %15 = OpTypeFloat 32 %16 = OpTypePointer Function %15 %17 = OpTypeInt 32 0 %18 = OpConstant %17 10 %19 = OpTypeArray %15 %18 %20 = OpTypePointer Function %19 %21 = OpConstant %10 1 %2 = OpFunction %8 None %9 %22 = OpLabel %3 = OpVariable %11 Function %4 = OpVariable %16 Function %5 = OpVariable %20 Function %6 = OpVariable %20 Function %7 = OpVariable %20 Function OpBranch %23 %23 = OpLabel %24 = OpPhi %10 %12 %22 %25 %26 OpLoopMerge %27 %26 None OpBranch %28 %28 = OpLabel %29 = OpSLessThan %14 %24 %13 OpBranchConditional %29 %30 %27 %30 = OpLabel %31 = OpAccessChain %16 %5 %24 %32 = OpLoad %15 %31 OpStore %4 %32 %33 = OpAccessChain %16 %7 %24 %34 = OpLoad %15 %33 %35 = OpAccessChain %16 %6 %24 OpStore %35 %34 %36 = OpAccessChain %16 %6 %24 %37 = OpLoad %15 %36 %38 = OpFAdd %15 %37 %32 %39 = OpAccessChain %16 %7 %24 OpStore %39 %38 OpBranch %26 %26 = OpLabel %25 = OpIAdd %10 %24 %21 OpBranch %23 %27 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, source, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << source << std::endl; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(source, source, true); } /* #version 430 layout(location=0) flat in int condition; void main(void) { float A[10]; float B[10]; for (int i = 0; i < 10; i++) { if (condition == 1) A[i] = B[i]; else B[i] = A[i]; } } When this is split we leave the condition check and control flow inplace and leave its removal for dead code elimination. #version 430 layout(location=0) flat in int condition; void main(void) { float A[10]; float B[10]; for (int i = 0; i < 10; i++) { if (condition == 1) A[i] = B[i]; else ; } for (int i = 0; i < 10; i++) { if (condition == 1) ; else B[i] = A[i]; } } */ TEST_F(FissionClassTest, FissionControlFlow) { // clang-format off // With LocalMultiStoreElimPass const std::string source = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %4 "i" OpName %3 "condition" OpName %5 "A" OpName %6 "B" OpDecorate %3 Flat OpDecorate %3 Location 0 %7 = OpTypeVoid %8 = OpTypeFunction %7 %9 = OpTypeInt 32 1 %10 = OpTypePointer Function %9 %11 = OpConstant %9 0 %12 = OpConstant %9 10 %13 = OpTypeBool %14 = OpTypePointer Input %9 %3 = OpVariable %14 Input %15 = OpConstant %9 1 %16 = OpTypeFloat 32 %17 = OpTypeInt 32 0 %18 = OpConstant %17 10 %19 = OpTypeArray %16 %18 %20 = OpTypePointer Function %19 %21 = OpTypePointer Function %16 %2 = OpFunction %7 None %8 %22 = OpLabel %4 = OpVariable %10 Function %5 = OpVariable %20 Function %6 = OpVariable %20 Function %31 = OpLoad %9 %3 OpStore %4 %11 OpBranch %23 %23 = OpLabel %24 = OpPhi %9 %11 %22 %25 %26 OpLoopMerge %27 %26 None OpBranch %28 %28 = OpLabel %29 = OpSLessThan %13 %24 %12 OpBranchConditional %29 %30 %27 %30 = OpLabel %32 = OpIEqual %13 %31 %15 OpSelectionMerge %33 None OpBranchConditional %32 %34 %35 %34 = OpLabel %36 = OpAccessChain %21 %6 %24 %37 = OpLoad %16 %36 %38 = OpAccessChain %21 %5 %24 OpStore %38 %37 OpBranch %33 %35 = OpLabel %39 = OpAccessChain %21 %5 %24 %40 = OpLoad %16 %39 %41 = OpAccessChain %21 %6 %24 OpStore %41 %40 OpBranch %33 %33 = OpLabel OpBranch %26 %26 = OpLabel %25 = OpIAdd %9 %24 %15 OpStore %4 %25 OpBranch %23 %27 = OpLabel OpReturn OpFunctionEnd )"; const std::string expected = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %4 "i" OpName %3 "condition" OpName %5 "A" OpName %6 "B" OpDecorate %3 Flat OpDecorate %3 Location 0 %7 = OpTypeVoid %8 = OpTypeFunction %7 %9 = OpTypeInt 32 1 %10 = OpTypePointer Function %9 %11 = OpConstant %9 0 %12 = OpConstant %9 10 %13 = OpTypeBool %14 = OpTypePointer Input %9 %3 = OpVariable %14 Input %15 = OpConstant %9 1 %16 = OpTypeFloat 32 %17 = OpTypeInt 32 0 %18 = OpConstant %17 10 %19 = OpTypeArray %16 %18 %20 = OpTypePointer Function %19 %21 = OpTypePointer Function %16 %2 = OpFunction %7 None %8 %22 = OpLabel %4 = OpVariable %10 Function %5 = OpVariable %20 Function %6 = OpVariable %20 Function %23 = OpLoad %9 %3 OpStore %4 %11 OpBranch %42 %42 = OpLabel %43 = OpPhi %9 %11 %22 %58 %57 OpLoopMerge %59 %57 None OpBranch %44 %44 = OpLabel %45 = OpSLessThan %13 %43 %12 OpBranchConditional %45 %46 %59 %46 = OpLabel %47 = OpIEqual %13 %23 %15 OpSelectionMerge %56 None OpBranchConditional %47 %52 %48 %48 = OpLabel OpBranch %56 %52 = OpLabel %53 = OpAccessChain %21 %6 %43 %54 = OpLoad %16 %53 %55 = OpAccessChain %21 %5 %43 OpStore %55 %54 OpBranch %56 %56 = OpLabel OpBranch %57 %57 = OpLabel %58 = OpIAdd %9 %43 %15 OpStore %4 %58 OpBranch %42 %59 = OpLabel OpBranch %24 %24 = OpLabel %25 = OpPhi %9 %11 %59 %26 %27 OpLoopMerge %28 %27 None OpBranch %29 %29 = OpLabel %30 = OpSLessThan %13 %25 %12 OpBranchConditional %30 %31 %28 %31 = OpLabel %32 = OpIEqual %13 %23 %15 OpSelectionMerge %33 None OpBranchConditional %32 %34 %35 %34 = OpLabel OpBranch %33 %35 = OpLabel %39 = OpAccessChain %21 %5 %25 %40 = OpLoad %16 %39 %41 = OpAccessChain %21 %6 %25 OpStore %41 %40 OpBranch %33 %33 = OpLabel OpBranch %27 %27 = OpLabel %26 = OpIAdd %9 %25 %15 OpStore %4 %26 OpBranch %24 %28 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, source, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << source << std::endl; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(source, expected, true); } /* #version 430 void main(void) { float A[10]; float B[10]; for (int i = 0; i < 10; i++) { if (i == 1) B[i] = A[i]; else if (i == 2) A[i] = B[i]; else A[i] = 0; } } After running the pass with multiple splits enabled (via register threshold of 1) we expect the equivalent of: #version 430 void main(void) { float A[10]; float B[10]; for (int i = 0; i < 10; i++) { if (i == 1) B[i] = A[i]; else if (i == 2) else } for (int i = 0; i < 10; i++) { if (i == 1) else if (i == 2) A[i] = B[i]; else } for (int i = 0; i < 10; i++) { if (i == 1) else if (i == 2) else A[i] = 0; } } */ TEST_F(FissionClassTest, FissionControlFlow2) { // clang-format off // With LocalMultiStoreElimPass const std::string source = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "i" OpName %4 "B" OpName %5 "A" %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %10 = OpConstant %8 0 %11 = OpConstant %8 10 %12 = OpTypeBool %13 = OpConstant %8 1 %14 = OpTypeFloat 32 %15 = OpTypeInt 32 0 %16 = OpConstant %15 10 %17 = OpTypeArray %14 %16 %18 = OpTypePointer Function %17 %19 = OpTypePointer Function %14 %20 = OpConstant %8 2 %21 = OpConstant %14 0 %2 = OpFunction %6 None %7 %22 = OpLabel %3 = OpVariable %9 Function %4 = OpVariable %18 Function %5 = OpVariable %18 Function OpStore %3 %10 OpBranch %23 %23 = OpLabel %24 = OpPhi %8 %10 %22 %25 %26 OpLoopMerge %27 %26 None OpBranch %28 %28 = OpLabel %29 = OpSLessThan %12 %24 %11 OpBranchConditional %29 %30 %27 %30 = OpLabel %31 = OpIEqual %12 %24 %13 OpSelectionMerge %32 None OpBranchConditional %31 %33 %34 %33 = OpLabel %35 = OpAccessChain %19 %5 %24 %36 = OpLoad %14 %35 %37 = OpAccessChain %19 %4 %24 OpStore %37 %36 OpBranch %32 %34 = OpLabel %38 = OpIEqual %12 %24 %20 OpSelectionMerge %39 None OpBranchConditional %38 %40 %41 %40 = OpLabel %42 = OpAccessChain %19 %4 %24 %43 = OpLoad %14 %42 %44 = OpAccessChain %19 %5 %24 OpStore %44 %43 OpBranch %39 %41 = OpLabel %45 = OpAccessChain %19 %5 %24 OpStore %45 %21 OpBranch %39 %39 = OpLabel OpBranch %32 %32 = OpLabel OpBranch %26 %26 = OpLabel %25 = OpIAdd %8 %24 %13 OpStore %3 %25 OpBranch %23 %27 = OpLabel OpReturn OpFunctionEnd )"; const std::string expected = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "i" OpName %4 "B" OpName %5 "A" %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %10 = OpConstant %8 0 %11 = OpConstant %8 10 %12 = OpTypeBool %13 = OpConstant %8 1 %14 = OpTypeFloat 32 %15 = OpTypeInt 32 0 %16 = OpConstant %15 10 %17 = OpTypeArray %14 %16 %18 = OpTypePointer Function %17 %19 = OpTypePointer Function %14 %20 = OpConstant %8 2 %21 = OpConstant %14 0 %2 = OpFunction %6 None %7 %22 = OpLabel %3 = OpVariable %9 Function %4 = OpVariable %18 Function %5 = OpVariable %18 Function OpStore %3 %10 OpBranch %46 %46 = OpLabel %47 = OpPhi %8 %10 %22 %67 %66 OpLoopMerge %68 %66 None OpBranch %48 %48 = OpLabel %49 = OpSLessThan %12 %47 %11 OpBranchConditional %49 %50 %68 %50 = OpLabel %51 = OpIEqual %12 %47 %13 OpSelectionMerge %65 None OpBranchConditional %51 %61 %52 %52 = OpLabel %53 = OpIEqual %12 %47 %20 OpSelectionMerge %60 None OpBranchConditional %53 %56 %54 %54 = OpLabel OpBranch %60 %56 = OpLabel OpBranch %60 %60 = OpLabel OpBranch %65 %61 = OpLabel %62 = OpAccessChain %19 %5 %47 %63 = OpLoad %14 %62 %64 = OpAccessChain %19 %4 %47 OpStore %64 %63 OpBranch %65 %65 = OpLabel OpBranch %66 %66 = OpLabel %67 = OpIAdd %8 %47 %13 OpStore %3 %67 OpBranch %46 %68 = OpLabel OpBranch %69 %69 = OpLabel %70 = OpPhi %8 %10 %68 %87 %86 OpLoopMerge %88 %86 None OpBranch %71 %71 = OpLabel %72 = OpSLessThan %12 %70 %11 OpBranchConditional %72 %73 %88 %73 = OpLabel %74 = OpIEqual %12 %70 %13 OpSelectionMerge %85 None OpBranchConditional %74 %84 %75 %75 = OpLabel %76 = OpIEqual %12 %70 %20 OpSelectionMerge %83 None OpBranchConditional %76 %79 %77 %77 = OpLabel OpBranch %83 %79 = OpLabel %80 = OpAccessChain %19 %4 %70 %81 = OpLoad %14 %80 %82 = OpAccessChain %19 %5 %70 OpStore %82 %81 OpBranch %83 %83 = OpLabel OpBranch %85 %84 = OpLabel OpBranch %85 %85 = OpLabel OpBranch %86 %86 = OpLabel %87 = OpIAdd %8 %70 %13 OpStore %3 %87 OpBranch %69 %88 = OpLabel OpBranch %23 %23 = OpLabel %24 = OpPhi %8 %10 %88 %25 %26 OpLoopMerge %27 %26 None OpBranch %28 %28 = OpLabel %29 = OpSLessThan %12 %24 %11 OpBranchConditional %29 %30 %27 %30 = OpLabel %31 = OpIEqual %12 %24 %13 OpSelectionMerge %32 None OpBranchConditional %31 %33 %34 %33 = OpLabel OpBranch %32 %34 = OpLabel %38 = OpIEqual %12 %24 %20 OpSelectionMerge %39 None OpBranchConditional %38 %40 %41 %40 = OpLabel OpBranch %39 %41 = OpLabel %45 = OpAccessChain %19 %5 %24 OpStore %45 %21 OpBranch %39 %39 = OpLabel OpBranch %32 %32 = OpLabel OpBranch %26 %26 = OpLabel %25 = OpIAdd %8 %24 %13 OpStore %3 %25 OpBranch %23 %27 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, source, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << source << std::endl; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(source, expected, true, 1); } /* #version 430 layout(location=0) flat in int condition; void main(void) { float A[10]; float B[10]; for (int i = 0; i < 10; i++) { B[i] = A[i]; memoryBarrier(); A[i] = B[i]; } } This should not be split due to the memory barrier. */ TEST_F(FissionClassTest, FissionBarrier) { // clang-format off // With LocalMultiStoreElimPass const std::string source = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %4 "i" OpName %5 "B" OpName %6 "A" OpName %3 "condition" OpDecorate %3 Flat OpDecorate %3 Location 0 %7 = OpTypeVoid %8 = OpTypeFunction %7 %9 = OpTypeInt 32 1 %10 = OpTypePointer Function %9 %11 = OpConstant %9 0 %12 = OpConstant %9 10 %13 = OpTypeBool %14 = OpTypeFloat 32 %15 = OpTypeInt 32 0 %16 = OpConstant %15 10 %17 = OpTypeArray %14 %16 %18 = OpTypePointer Function %17 %19 = OpTypePointer Function %14 %20 = OpConstant %15 1 %21 = OpConstant %15 4048 %22 = OpConstant %9 1 %23 = OpTypePointer Input %9 %3 = OpVariable %23 Input %2 = OpFunction %7 None %8 %24 = OpLabel %4 = OpVariable %10 Function %5 = OpVariable %18 Function %6 = OpVariable %18 Function OpStore %4 %11 OpBranch %25 %25 = OpLabel %26 = OpPhi %9 %11 %24 %27 %28 OpLoopMerge %29 %28 None OpBranch %30 %30 = OpLabel %31 = OpSLessThan %13 %26 %12 OpBranchConditional %31 %32 %29 %32 = OpLabel %33 = OpAccessChain %19 %6 %26 %34 = OpLoad %14 %33 %35 = OpAccessChain %19 %5 %26 OpStore %35 %34 OpMemoryBarrier %20 %21 %36 = OpAccessChain %19 %5 %26 %37 = OpLoad %14 %36 %38 = OpAccessChain %19 %6 %26 OpStore %38 %37 OpBranch %28 %28 = OpLabel %27 = OpIAdd %9 %26 %22 OpStore %4 %27 OpBranch %25 %29 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, source, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << source << std::endl; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(source, source, true); } /* #version 430 void main(void) { float A[10]; float B[10]; for (int i = 0; i < 10; i++) { B[i] = A[i]; if ( i== 1) break; A[i] = B[i]; } } This should not be split due to the break. */ TEST_F(FissionClassTest, FissionBreak) { // clang-format off // With LocalMultiStoreElimPass const std::string source = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "i" OpName %4 "B" OpName %5 "A" %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %10 = OpConstant %8 0 %11 = OpConstant %8 10 %12 = OpTypeBool %13 = OpTypeFloat 32 %14 = OpTypeInt 32 0 %15 = OpConstant %14 10 %16 = OpTypeArray %13 %15 %17 = OpTypePointer Function %16 %18 = OpTypePointer Function %13 %19 = OpConstant %8 1 %2 = OpFunction %6 None %7 %20 = OpLabel %3 = OpVariable %9 Function %4 = OpVariable %17 Function %5 = OpVariable %17 Function OpStore %3 %10 OpBranch %21 %21 = OpLabel %22 = OpPhi %8 %10 %20 %23 %24 OpLoopMerge %25 %24 None OpBranch %26 %26 = OpLabel %27 = OpSLessThan %12 %22 %11 OpBranchConditional %27 %28 %25 %28 = OpLabel %29 = OpAccessChain %18 %5 %22 %30 = OpLoad %13 %29 %31 = OpAccessChain %18 %4 %22 OpStore %31 %30 %32 = OpIEqual %12 %22 %19 OpSelectionMerge %33 None OpBranchConditional %32 %34 %33 %34 = OpLabel OpBranch %25 %33 = OpLabel %35 = OpAccessChain %18 %4 %22 %36 = OpLoad %13 %35 %37 = OpAccessChain %18 %5 %22 OpStore %37 %36 OpBranch %24 %24 = OpLabel %23 = OpIAdd %8 %22 %19 OpStore %3 %23 OpBranch %21 %25 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, source, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << source << std::endl; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(source, source, true); } /* #version 430 void main(void) { float A[10]; float B[10]; for (int i = 0; i < 10; i++) { B[i] = A[i]; if ( i== 1) continue; A[i] = B[i]; } } This loop should be split into: for (int i = 0; i < 10; i++) { B[i] = A[i]; if ( i== 1) continue; } for (int i = 0; i < 10; i++) { if ( i== 1) continue; A[i] = B[i]; } The continue block in the first loop is left to DCE. } */ TEST_F(FissionClassTest, FissionContinue) { // clang-format off // With LocalMultiStoreElimPass const std::string source = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "i" OpName %4 "B" OpName %5 "A" %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %10 = OpConstant %8 0 %11 = OpConstant %8 10 %12 = OpTypeBool %13 = OpTypeFloat 32 %14 = OpTypeInt 32 0 %15 = OpConstant %14 10 %16 = OpTypeArray %13 %15 %17 = OpTypePointer Function %16 %18 = OpTypePointer Function %13 %19 = OpConstant %8 1 %2 = OpFunction %6 None %7 %20 = OpLabel %3 = OpVariable %9 Function %4 = OpVariable %17 Function %5 = OpVariable %17 Function OpStore %3 %10 OpBranch %21 %21 = OpLabel %22 = OpPhi %8 %10 %20 %23 %24 OpLoopMerge %25 %24 None OpBranch %26 %26 = OpLabel %27 = OpSLessThan %12 %22 %11 OpBranchConditional %27 %28 %25 %28 = OpLabel %29 = OpAccessChain %18 %5 %22 %30 = OpLoad %13 %29 %31 = OpAccessChain %18 %4 %22 OpStore %31 %30 %32 = OpIEqual %12 %22 %19 OpSelectionMerge %33 None OpBranchConditional %32 %34 %33 %34 = OpLabel OpBranch %24 %33 = OpLabel %35 = OpAccessChain %18 %4 %22 %36 = OpLoad %13 %35 %37 = OpAccessChain %18 %5 %22 OpStore %37 %36 OpBranch %24 %24 = OpLabel %23 = OpIAdd %8 %22 %19 OpStore %3 %23 OpBranch %21 %25 = OpLabel OpReturn OpFunctionEnd )"; const std::string expected = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "i" OpName %4 "B" OpName %5 "A" %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %10 = OpConstant %8 0 %11 = OpConstant %8 10 %12 = OpTypeBool %13 = OpTypeFloat 32 %14 = OpTypeInt 32 0 %15 = OpConstant %14 10 %16 = OpTypeArray %13 %15 %17 = OpTypePointer Function %16 %18 = OpTypePointer Function %13 %19 = OpConstant %8 1 %2 = OpFunction %6 None %7 %20 = OpLabel %3 = OpVariable %9 Function %4 = OpVariable %17 Function %5 = OpVariable %17 Function OpStore %3 %10 OpBranch %38 %38 = OpLabel %39 = OpPhi %8 %10 %20 %53 %52 OpLoopMerge %54 %52 None OpBranch %40 %40 = OpLabel %41 = OpSLessThan %12 %39 %11 OpBranchConditional %41 %42 %54 %42 = OpLabel %43 = OpAccessChain %18 %5 %39 %44 = OpLoad %13 %43 %45 = OpAccessChain %18 %4 %39 OpStore %45 %44 %46 = OpIEqual %12 %39 %19 OpSelectionMerge %48 None OpBranchConditional %46 %47 %48 %47 = OpLabel OpBranch %52 %48 = OpLabel OpBranch %52 %52 = OpLabel %53 = OpIAdd %8 %39 %19 OpStore %3 %53 OpBranch %38 %54 = OpLabel OpBranch %21 %21 = OpLabel %22 = OpPhi %8 %10 %54 %23 %24 OpLoopMerge %25 %24 None OpBranch %26 %26 = OpLabel %27 = OpSLessThan %12 %22 %11 OpBranchConditional %27 %28 %25 %28 = OpLabel %32 = OpIEqual %12 %22 %19 OpSelectionMerge %33 None OpBranchConditional %32 %34 %33 %34 = OpLabel OpBranch %24 %33 = OpLabel %35 = OpAccessChain %18 %4 %22 %36 = OpLoad %13 %35 %37 = OpAccessChain %18 %5 %22 OpStore %37 %36 OpBranch %24 %24 = OpLabel %23 = OpIAdd %8 %22 %19 OpStore %3 %23 OpBranch %21 %25 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, source, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << source << std::endl; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(source, expected, true); } /* #version 430 void main(void) { float A[10]; float B[10]; int i = 0; do { B[i] = A[i]; A[i] = B[i]; ++i; } while (i < 10); } Check that this is split into: int i = 0; do { B[i] = A[i]; ++i; } while (i < 10); i = 0; do { A[i] = B[i]; ++i; } while (i < 10); */ TEST_F(FissionClassTest, FissionDoWhile) { // clang-format off // With LocalMultiStoreElimPass const std::string source = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "i" OpName %4 "B" OpName %5 "A" %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %10 = OpConstant %8 0 %11 = OpTypeFloat 32 %12 = OpTypeInt 32 0 %13 = OpConstant %12 10 %14 = OpTypeArray %11 %13 %15 = OpTypePointer Function %14 %16 = OpTypePointer Function %11 %17 = OpConstant %8 1 %18 = OpConstant %8 10 %19 = OpTypeBool %2 = OpFunction %6 None %7 %20 = OpLabel %3 = OpVariable %9 Function %4 = OpVariable %15 Function %5 = OpVariable %15 Function OpStore %3 %10 OpBranch %21 %21 = OpLabel %22 = OpPhi %8 %10 %20 %23 %24 OpLoopMerge %25 %24 None OpBranch %26 %26 = OpLabel %27 = OpAccessChain %16 %5 %22 %28 = OpLoad %11 %27 %29 = OpAccessChain %16 %4 %22 OpStore %29 %28 %30 = OpAccessChain %16 %4 %22 %31 = OpLoad %11 %30 %32 = OpAccessChain %16 %5 %22 OpStore %32 %31 %23 = OpIAdd %8 %22 %17 OpStore %3 %23 OpBranch %24 %24 = OpLabel %33 = OpSLessThan %19 %23 %18 OpBranchConditional %33 %21 %25 %25 = OpLabel OpReturn OpFunctionEnd )"; const std::string expected = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "i" OpName %4 "B" OpName %5 "A" %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %10 = OpConstant %8 0 %11 = OpTypeFloat 32 %12 = OpTypeInt 32 0 %13 = OpConstant %12 10 %14 = OpTypeArray %11 %13 %15 = OpTypePointer Function %14 %16 = OpTypePointer Function %11 %17 = OpConstant %8 1 %18 = OpConstant %8 10 %19 = OpTypeBool %2 = OpFunction %6 None %7 %20 = OpLabel %3 = OpVariable %9 Function %4 = OpVariable %15 Function %5 = OpVariable %15 Function OpStore %3 %10 OpBranch %34 %34 = OpLabel %35 = OpPhi %8 %10 %20 %43 %44 OpLoopMerge %46 %44 None OpBranch %36 %36 = OpLabel %37 = OpAccessChain %16 %5 %35 %38 = OpLoad %11 %37 %39 = OpAccessChain %16 %4 %35 OpStore %39 %38 %43 = OpIAdd %8 %35 %17 OpStore %3 %43 OpBranch %44 %44 = OpLabel %45 = OpSLessThan %19 %43 %18 OpBranchConditional %45 %34 %46 %46 = OpLabel OpBranch %21 %21 = OpLabel %22 = OpPhi %8 %10 %46 %23 %24 OpLoopMerge %25 %24 None OpBranch %26 %26 = OpLabel %30 = OpAccessChain %16 %4 %22 %31 = OpLoad %11 %30 %32 = OpAccessChain %16 %5 %22 OpStore %32 %31 %23 = OpIAdd %8 %22 %17 OpStore %3 %23 OpBranch %24 %24 = OpLabel %33 = OpSLessThan %19 %23 %18 OpBranchConditional %33 %21 %25 %25 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, source, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << source << std::endl; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(source, expected, true); } /* #version 430 void main(void) { float A[10][10]; float B[10][10]; for (int j = 0; j < 10; ++j) { for (int i = 0; i < 10; ++i) { B[i][j] = A[i][i]; A[i][i] = B[i][j + 1]; } } } This loop can't be split because the load B[i][j + 1] is dependent on the store B[i][j]. */ TEST_F(FissionClassTest, FissionNestedDependency) { // clang-format off // With LocalMultiStoreElimPass const std::string source = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "j" OpName %4 "i" OpName %5 "B" OpName %6 "A" %7 = OpTypeVoid %8 = OpTypeFunction %7 %9 = OpTypeInt 32 1 %10 = OpTypePointer Function %9 %11 = OpConstant %9 0 %12 = OpConstant %9 10 %13 = OpTypeBool %14 = OpTypeFloat 32 %15 = OpTypeInt 32 0 %16 = OpConstant %15 10 %17 = OpTypeArray %14 %16 %18 = OpTypeArray %17 %16 %19 = OpTypePointer Function %18 %20 = OpTypePointer Function %14 %21 = OpConstant %9 1 %2 = OpFunction %7 None %8 %22 = OpLabel %3 = OpVariable %10 Function %4 = OpVariable %10 Function %5 = OpVariable %19 Function %6 = OpVariable %19 Function OpBranch %23 %23 = OpLabel %24 = OpPhi %9 %11 %22 %25 %26 OpLoopMerge %27 %26 None OpBranch %28 %28 = OpLabel %29 = OpSLessThan %13 %24 %12 OpBranchConditional %29 %30 %27 %30 = OpLabel OpBranch %31 %31 = OpLabel %32 = OpPhi %9 %11 %30 %33 %34 OpLoopMerge %35 %34 None OpBranch %36 %36 = OpLabel %37 = OpSLessThan %13 %32 %12 OpBranchConditional %37 %38 %35 %38 = OpLabel %39 = OpAccessChain %20 %6 %32 %32 %40 = OpLoad %14 %39 %41 = OpAccessChain %20 %5 %32 %24 OpStore %41 %40 %42 = OpIAdd %9 %24 %21 %43 = OpAccessChain %20 %5 %32 %42 %44 = OpLoad %14 %43 %45 = OpAccessChain %20 %6 %32 %32 OpStore %45 %44 OpBranch %34 %34 = OpLabel %33 = OpIAdd %9 %32 %21 OpBranch %31 %35 = OpLabel OpBranch %26 %26 = OpLabel %25 = OpIAdd %9 %24 %21 OpBranch %23 %27 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, source, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << source << std::endl; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(source, source, true); } /* #version 430 void main(void) { float A[10][10]; float B[10][10]; for (int j = 0; j < 10; ++j) { for (int i = 0; i < 10; ++i) { B[i][i] = A[i][j]; A[i][j+1] = B[i][i]; } } } This loop should not be split as the load A[i][j+1] would be reading a value written in the store A[i][j] which would be hit before A[i][j+1] if the loops where split but would not get hit before the read currently. */ TEST_F(FissionClassTest, FissionNestedDependency2) { // clang-format off // With LocalMultiStoreElimPass const std::string source = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "j" OpName %4 "i" OpName %5 "B" OpName %6 "A" %7 = OpTypeVoid %8 = OpTypeFunction %7 %9 = OpTypeInt 32 1 %10 = OpTypePointer Function %9 %11 = OpConstant %9 0 %12 = OpConstant %9 10 %13 = OpTypeBool %14 = OpTypeFloat 32 %15 = OpTypeInt 32 0 %16 = OpConstant %15 10 %17 = OpTypeArray %14 %16 %18 = OpTypeArray %17 %16 %19 = OpTypePointer Function %18 %20 = OpTypePointer Function %14 %21 = OpConstant %9 1 %2 = OpFunction %7 None %8 %22 = OpLabel %3 = OpVariable %10 Function %4 = OpVariable %10 Function %5 = OpVariable %19 Function %6 = OpVariable %19 Function OpStore %3 %11 OpBranch %23 %23 = OpLabel %24 = OpPhi %9 %11 %22 %25 %26 OpLoopMerge %27 %26 None OpBranch %28 %28 = OpLabel %29 = OpSLessThan %13 %24 %12 OpBranchConditional %29 %30 %27 %30 = OpLabel OpStore %4 %11 OpBranch %31 %31 = OpLabel %32 = OpPhi %9 %11 %30 %33 %34 OpLoopMerge %35 %34 None OpBranch %36 %36 = OpLabel %37 = OpSLessThan %13 %32 %12 OpBranchConditional %37 %38 %35 %38 = OpLabel %39 = OpAccessChain %20 %6 %32 %24 %40 = OpLoad %14 %39 %41 = OpAccessChain %20 %5 %32 %32 OpStore %41 %40 %42 = OpIAdd %9 %24 %21 %43 = OpAccessChain %20 %5 %32 %32 %44 = OpLoad %14 %43 %45 = OpAccessChain %20 %6 %32 %42 OpStore %45 %44 OpBranch %34 %34 = OpLabel %33 = OpIAdd %9 %32 %21 OpStore %4 %33 OpBranch %31 %35 = OpLabel OpBranch %26 %26 = OpLabel %25 = OpIAdd %9 %24 %21 OpStore %3 %25 OpBranch %23 %27 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, source, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << source << std::endl; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(source, source, true); } /* #version 430 void main(void) { float A[10][10]; float B[10][10]; for (int j = 0; j < 10; ++j) { for (int i = 0; i < 10; ++i) { B[i][j] = A[i][j]; A[i][j] = B[i][j]; } for (int i = 0; i < 10; ++i) { B[i][j] = A[i][j]; A[i][j] = B[i][j]; } } } Should be split into: for (int j = 0; j < 10; ++j) { for (int i = 0; i < 10; ++i) B[i][j] = A[i][j]; for (int i = 0; i < 10; ++i) A[i][j] = B[i][j]; for (int i = 0; i < 10; ++i) B[i][j] = A[i][j]; for (int i = 0; i < 10; ++i) A[i][j] = B[i][j]; */ TEST_F(FissionClassTest, FissionMultipleLoopsNested) { // clang-format off // With LocalMultiStoreElimPass const std::string source = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "j" OpName %4 "i" OpName %5 "B" OpName %6 "A" OpName %7 "i" %8 = OpTypeVoid %9 = OpTypeFunction %8 %10 = OpTypeInt 32 1 %11 = OpTypePointer Function %10 %12 = OpConstant %10 0 %13 = OpConstant %10 10 %14 = OpTypeBool %15 = OpTypeFloat 32 %16 = OpTypeInt 32 0 %17 = OpConstant %16 10 %18 = OpTypeArray %15 %17 %19 = OpTypeArray %18 %17 %20 = OpTypePointer Function %19 %21 = OpTypePointer Function %15 %22 = OpConstant %10 1 %2 = OpFunction %8 None %9 %23 = OpLabel %3 = OpVariable %11 Function %4 = OpVariable %11 Function %5 = OpVariable %20 Function %6 = OpVariable %20 Function %7 = OpVariable %11 Function OpStore %3 %12 OpBranch %24 %24 = OpLabel %25 = OpPhi %10 %12 %23 %26 %27 OpLoopMerge %28 %27 None OpBranch %29 %29 = OpLabel %30 = OpSLessThan %14 %25 %13 OpBranchConditional %30 %31 %28 %31 = OpLabel OpStore %4 %12 OpBranch %32 %32 = OpLabel %33 = OpPhi %10 %12 %31 %34 %35 OpLoopMerge %36 %35 None OpBranch %37 %37 = OpLabel %38 = OpSLessThan %14 %33 %13 OpBranchConditional %38 %39 %36 %39 = OpLabel %40 = OpAccessChain %21 %6 %33 %25 %41 = OpLoad %15 %40 %42 = OpAccessChain %21 %5 %33 %25 OpStore %42 %41 %43 = OpAccessChain %21 %5 %33 %25 %44 = OpLoad %15 %43 %45 = OpAccessChain %21 %6 %33 %25 OpStore %45 %44 OpBranch %35 %35 = OpLabel %34 = OpIAdd %10 %33 %22 OpStore %4 %34 OpBranch %32 %36 = OpLabel OpStore %7 %12 OpBranch %46 %46 = OpLabel %47 = OpPhi %10 %12 %36 %48 %49 OpLoopMerge %50 %49 None OpBranch %51 %51 = OpLabel %52 = OpSLessThan %14 %47 %13 OpBranchConditional %52 %53 %50 %53 = OpLabel %54 = OpAccessChain %21 %6 %47 %25 %55 = OpLoad %15 %54 %56 = OpAccessChain %21 %5 %47 %25 OpStore %56 %55 %57 = OpAccessChain %21 %5 %47 %25 %58 = OpLoad %15 %57 %59 = OpAccessChain %21 %6 %47 %25 OpStore %59 %58 OpBranch %49 %49 = OpLabel %48 = OpIAdd %10 %47 %22 OpStore %7 %48 OpBranch %46 %50 = OpLabel OpBranch %27 %27 = OpLabel %26 = OpIAdd %10 %25 %22 OpStore %3 %26 OpBranch %24 %28 = OpLabel OpReturn OpFunctionEnd )"; const std::string expected = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "j" OpName %4 "i" OpName %5 "B" OpName %6 "A" OpName %7 "i" %8 = OpTypeVoid %9 = OpTypeFunction %8 %10 = OpTypeInt 32 1 %11 = OpTypePointer Function %10 %12 = OpConstant %10 0 %13 = OpConstant %10 10 %14 = OpTypeBool %15 = OpTypeFloat 32 %16 = OpTypeInt 32 0 %17 = OpConstant %16 10 %18 = OpTypeArray %15 %17 %19 = OpTypeArray %18 %17 %20 = OpTypePointer Function %19 %21 = OpTypePointer Function %15 %22 = OpConstant %10 1 %2 = OpFunction %8 None %9 %23 = OpLabel %3 = OpVariable %11 Function %4 = OpVariable %11 Function %5 = OpVariable %20 Function %6 = OpVariable %20 Function %7 = OpVariable %11 Function OpStore %3 %12 OpBranch %24 %24 = OpLabel %25 = OpPhi %10 %12 %23 %26 %27 OpLoopMerge %28 %27 None OpBranch %29 %29 = OpLabel %30 = OpSLessThan %14 %25 %13 OpBranchConditional %30 %31 %28 %31 = OpLabel OpStore %4 %12 OpBranch %60 %60 = OpLabel %61 = OpPhi %10 %12 %31 %72 %71 OpLoopMerge %73 %71 None OpBranch %62 %62 = OpLabel %63 = OpSLessThan %14 %61 %13 OpBranchConditional %63 %64 %73 %64 = OpLabel %65 = OpAccessChain %21 %6 %61 %25 %66 = OpLoad %15 %65 %67 = OpAccessChain %21 %5 %61 %25 OpStore %67 %66 OpBranch %71 %71 = OpLabel %72 = OpIAdd %10 %61 %22 OpStore %4 %72 OpBranch %60 %73 = OpLabel OpBranch %32 %32 = OpLabel %33 = OpPhi %10 %12 %73 %34 %35 OpLoopMerge %36 %35 None OpBranch %37 %37 = OpLabel %38 = OpSLessThan %14 %33 %13 OpBranchConditional %38 %39 %36 %39 = OpLabel %43 = OpAccessChain %21 %5 %33 %25 %44 = OpLoad %15 %43 %45 = OpAccessChain %21 %6 %33 %25 OpStore %45 %44 OpBranch %35 %35 = OpLabel %34 = OpIAdd %10 %33 %22 OpStore %4 %34 OpBranch %32 %36 = OpLabel OpStore %7 %12 OpBranch %74 %74 = OpLabel %75 = OpPhi %10 %12 %36 %86 %85 OpLoopMerge %87 %85 None OpBranch %76 %76 = OpLabel %77 = OpSLessThan %14 %75 %13 OpBranchConditional %77 %78 %87 %78 = OpLabel %79 = OpAccessChain %21 %6 %75 %25 %80 = OpLoad %15 %79 %81 = OpAccessChain %21 %5 %75 %25 OpStore %81 %80 OpBranch %85 %85 = OpLabel %86 = OpIAdd %10 %75 %22 OpStore %7 %86 OpBranch %74 %87 = OpLabel OpBranch %46 %46 = OpLabel %47 = OpPhi %10 %12 %87 %48 %49 OpLoopMerge %50 %49 None OpBranch %51 %51 = OpLabel %52 = OpSLessThan %14 %47 %13 OpBranchConditional %52 %53 %50 %53 = OpLabel %57 = OpAccessChain %21 %5 %47 %25 %58 = OpLoad %15 %57 %59 = OpAccessChain %21 %6 %47 %25 OpStore %59 %58 OpBranch %49 %49 = OpLabel %48 = OpIAdd %10 %47 %22 OpStore %7 %48 OpBranch %46 %50 = OpLabel OpBranch %27 %27 = OpLabel %26 = OpIAdd %10 %25 %22 OpStore %3 %26 OpBranch %24 %28 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, source, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << source << std::endl; const Function* function = spvtest::GetFunction(module, 2); LoopDescriptor& pre_pass_descriptor = *context->GetLoopDescriptor(function); EXPECT_EQ(pre_pass_descriptor.NumLoops(), 3u); EXPECT_EQ(pre_pass_descriptor.pre_begin()->NumImmediateChildren(), 2u); // Test that the pass transforms the ir into the expected output. SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(source, expected, true); // Test that the loop descriptor is correctly maintained and updated by the // pass. LoopFissionPass loop_fission; loop_fission.SetContextForTesting(context.get()); loop_fission.Process(); function = spvtest::GetFunction(module, 2); LoopDescriptor& post_pass_descriptor = *context->GetLoopDescriptor(function); EXPECT_EQ(post_pass_descriptor.NumLoops(), 5u); EXPECT_EQ(post_pass_descriptor.pre_begin()->NumImmediateChildren(), 4u); } /* #version 430 void main(void) { float A[10][10]; float B[10][10]; for (int i = 0; i < 10; ++i) { B[i][i] = A[i][i]; A[i][i] = B[i][i]; } for (int i = 0; i < 10; ++i) { B[i][i] = A[i][i]; A[i][i] = B[i][i] } } Should be split into: for (int i = 0; i < 10; ++i) B[i][i] = A[i][i]; for (int i = 0; i < 10; ++i) A[i][i] = B[i][i]; for (int i = 0; i < 10; ++i) B[i][i] = A[i][i]; for (int i = 0; i < 10; ++i) A[i][i] = B[i][i]; */ TEST_F(FissionClassTest, FissionMultipleLoops) { // clang-format off // With LocalMultiStoreElimPass const std::string source = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "i" OpName %4 "B" OpName %5 "A" OpName %6 "i" %7 = OpTypeVoid %8 = OpTypeFunction %7 %9 = OpTypeInt 32 1 %10 = OpTypePointer Function %9 %11 = OpConstant %9 0 %12 = OpConstant %9 10 %13 = OpTypeBool %14 = OpTypeFloat 32 %15 = OpTypeInt 32 0 %16 = OpConstant %15 10 %17 = OpTypeArray %14 %16 %18 = OpTypePointer Function %17 %19 = OpTypePointer Function %14 %20 = OpConstant %9 1 %2 = OpFunction %7 None %8 %21 = OpLabel %3 = OpVariable %10 Function %4 = OpVariable %18 Function %5 = OpVariable %18 Function %6 = OpVariable %10 Function OpStore %3 %11 OpBranch %22 %22 = OpLabel %23 = OpPhi %9 %11 %21 %24 %25 OpLoopMerge %26 %25 None OpBranch %27 %27 = OpLabel %28 = OpSLessThan %13 %23 %12 OpBranchConditional %28 %29 %26 %29 = OpLabel %30 = OpAccessChain %19 %5 %23 %31 = OpLoad %14 %30 %32 = OpAccessChain %19 %4 %23 OpStore %32 %31 %33 = OpAccessChain %19 %4 %23 %34 = OpLoad %14 %33 %35 = OpAccessChain %19 %5 %23 OpStore %35 %34 OpBranch %25 %25 = OpLabel %24 = OpIAdd %9 %23 %20 OpStore %3 %24 OpBranch %22 %26 = OpLabel OpStore %6 %11 OpBranch %36 %36 = OpLabel %37 = OpPhi %9 %11 %26 %38 %39 OpLoopMerge %40 %39 None OpBranch %41 %41 = OpLabel %42 = OpSLessThan %13 %37 %12 OpBranchConditional %42 %43 %40 %43 = OpLabel %44 = OpAccessChain %19 %5 %37 %45 = OpLoad %14 %44 %46 = OpAccessChain %19 %4 %37 OpStore %46 %45 %47 = OpAccessChain %19 %4 %37 %48 = OpLoad %14 %47 %49 = OpAccessChain %19 %5 %37 OpStore %49 %48 OpBranch %39 %39 = OpLabel %38 = OpIAdd %9 %37 %20 OpStore %6 %38 OpBranch %36 %40 = OpLabel OpReturn OpFunctionEnd )"; const std::string expected = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "i" OpName %4 "B" OpName %5 "A" OpName %6 "i" %7 = OpTypeVoid %8 = OpTypeFunction %7 %9 = OpTypeInt 32 1 %10 = OpTypePointer Function %9 %11 = OpConstant %9 0 %12 = OpConstant %9 10 %13 = OpTypeBool %14 = OpTypeFloat 32 %15 = OpTypeInt 32 0 %16 = OpConstant %15 10 %17 = OpTypeArray %14 %16 %18 = OpTypePointer Function %17 %19 = OpTypePointer Function %14 %20 = OpConstant %9 1 %2 = OpFunction %7 None %8 %21 = OpLabel %3 = OpVariable %10 Function %4 = OpVariable %18 Function %5 = OpVariable %18 Function %6 = OpVariable %10 Function OpStore %3 %11 OpBranch %64 %64 = OpLabel %65 = OpPhi %9 %11 %21 %76 %75 OpLoopMerge %77 %75 None OpBranch %66 %66 = OpLabel %67 = OpSLessThan %13 %65 %12 OpBranchConditional %67 %68 %77 %68 = OpLabel %69 = OpAccessChain %19 %5 %65 %70 = OpLoad %14 %69 %71 = OpAccessChain %19 %4 %65 OpStore %71 %70 OpBranch %75 %75 = OpLabel %76 = OpIAdd %9 %65 %20 OpStore %3 %76 OpBranch %64 %77 = OpLabel OpBranch %22 %22 = OpLabel %23 = OpPhi %9 %11 %77 %24 %25 OpLoopMerge %26 %25 None OpBranch %27 %27 = OpLabel %28 = OpSLessThan %13 %23 %12 OpBranchConditional %28 %29 %26 %29 = OpLabel %33 = OpAccessChain %19 %4 %23 %34 = OpLoad %14 %33 %35 = OpAccessChain %19 %5 %23 OpStore %35 %34 OpBranch %25 %25 = OpLabel %24 = OpIAdd %9 %23 %20 OpStore %3 %24 OpBranch %22 %26 = OpLabel OpStore %6 %11 OpBranch %50 %50 = OpLabel %51 = OpPhi %9 %11 %26 %62 %61 OpLoopMerge %63 %61 None OpBranch %52 %52 = OpLabel %53 = OpSLessThan %13 %51 %12 OpBranchConditional %53 %54 %63 %54 = OpLabel %55 = OpAccessChain %19 %5 %51 %56 = OpLoad %14 %55 %57 = OpAccessChain %19 %4 %51 OpStore %57 %56 OpBranch %61 %61 = OpLabel %62 = OpIAdd %9 %51 %20 OpStore %6 %62 OpBranch %50 %63 = OpLabel OpBranch %36 %36 = OpLabel %37 = OpPhi %9 %11 %63 %38 %39 OpLoopMerge %40 %39 None OpBranch %41 %41 = OpLabel %42 = OpSLessThan %13 %37 %12 OpBranchConditional %42 %43 %40 %43 = OpLabel %47 = OpAccessChain %19 %4 %37 %48 = OpLoad %14 %47 %49 = OpAccessChain %19 %5 %37 OpStore %49 %48 OpBranch %39 %39 = OpLabel %38 = OpIAdd %9 %37 %20 OpStore %6 %38 OpBranch %36 %40 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, source, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << source << std::endl; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(source, expected, true); const Function* function = spvtest::GetFunction(module, 2); LoopDescriptor& pre_pass_descriptor = *context->GetLoopDescriptor(function); EXPECT_EQ(pre_pass_descriptor.NumLoops(), 2u); EXPECT_EQ(pre_pass_descriptor.pre_begin()->NumImmediateChildren(), 0u); // Test that the pass transforms the ir into the expected output. SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(source, expected, true); // Test that the loop descriptor is correctly maintained and updated by the // pass. LoopFissionPass loop_fission; loop_fission.SetContextForTesting(context.get()); loop_fission.Process(); function = spvtest::GetFunction(module, 2); LoopDescriptor& post_pass_descriptor = *context->GetLoopDescriptor(function); EXPECT_EQ(post_pass_descriptor.NumLoops(), 4u); EXPECT_EQ(post_pass_descriptor.pre_begin()->NumImmediateChildren(), 0u); } /* #version 430 int foo() { return 1; } void main(void) { float A[10]; float B[10]; for (int i = 0; i < 10; ++i) { B[i] = A[i]; foo(); A[i] = B[i]; } } This should not be split as it has a function call in it so we can't determine if it has side effects. */ TEST_F(FissionClassTest, FissionFunctionCall) { // clang-format off // With LocalMultiStoreElimPass const std::string source = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "foo(" OpName %4 "i" OpName %5 "B" OpName %6 "A" %7 = OpTypeVoid %8 = OpTypeFunction %7 %9 = OpTypeInt 32 1 %10 = OpTypeFunction %9 %11 = OpConstant %9 1 %12 = OpTypePointer Function %9 %13 = OpConstant %9 0 %14 = OpConstant %9 10 %15 = OpTypeBool %16 = OpTypeFloat 32 %17 = OpTypeInt 32 0 %18 = OpConstant %17 10 %19 = OpTypeArray %16 %18 %20 = OpTypePointer Function %19 %21 = OpTypePointer Function %16 %2 = OpFunction %7 None %8 %22 = OpLabel %4 = OpVariable %12 Function %5 = OpVariable %20 Function %6 = OpVariable %20 Function OpStore %4 %13 OpBranch %23 %23 = OpLabel %24 = OpPhi %9 %13 %22 %25 %26 OpLoopMerge %27 %26 None OpBranch %28 %28 = OpLabel %29 = OpSLessThan %15 %24 %14 OpBranchConditional %29 %30 %27 %30 = OpLabel %31 = OpAccessChain %21 %6 %24 %32 = OpLoad %16 %31 %33 = OpAccessChain %21 %5 %24 OpStore %33 %32 %34 = OpFunctionCall %9 %3 %35 = OpAccessChain %21 %5 %24 %36 = OpLoad %16 %35 %37 = OpAccessChain %21 %6 %24 OpStore %37 %36 OpBranch %26 %26 = OpLabel %25 = OpIAdd %9 %24 %11 OpStore %4 %25 OpBranch %23 %27 = OpLabel OpReturn OpFunctionEnd %3 = OpFunction %9 None %10 %38 = OpLabel OpReturnValue %11 OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, source, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << source << std::endl; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(source, source, true); } /* #version 430 void main(void) { float A[10]; float B[10]; for (int i = 0; i < 10; ++i) { switch (i) { case 1: B[i] = A[i]; break; default: A[i] = B[i]; } } } This should be split into: for (int i = 0; i < 10; ++i) { switch (i) { case 1: break; default: A[i] = B[i]; } } for (int i = 0; i < 10; ++i) { switch (i) { case 1: B[i] = A[i]; break; default: break; } } */ TEST_F(FissionClassTest, FissionSwitchStatement) { // clang-format off // With LocalMultiStoreElimPass const std::string source = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "i" OpName %4 "B" OpName %5 "A" %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %10 = OpConstant %8 0 %11 = OpConstant %8 10 %12 = OpTypeBool %13 = OpTypeFloat 32 %14 = OpTypeInt 32 0 %15 = OpConstant %14 10 %16 = OpTypeArray %13 %15 %17 = OpTypePointer Function %16 %18 = OpTypePointer Function %13 %19 = OpConstant %8 1 %2 = OpFunction %6 None %7 %20 = OpLabel %3 = OpVariable %9 Function %4 = OpVariable %17 Function %5 = OpVariable %17 Function OpStore %3 %10 OpBranch %21 %21 = OpLabel %22 = OpPhi %8 %10 %20 %23 %24 OpLoopMerge %25 %24 None OpBranch %26 %26 = OpLabel %27 = OpSLessThan %12 %22 %11 OpBranchConditional %27 %28 %25 %28 = OpLabel OpSelectionMerge %29 None OpSwitch %22 %30 1 %31 %30 = OpLabel %32 = OpAccessChain %18 %4 %22 %33 = OpLoad %13 %32 %34 = OpAccessChain %18 %5 %22 OpStore %34 %33 OpBranch %29 %31 = OpLabel %35 = OpAccessChain %18 %5 %22 %36 = OpLoad %13 %35 %37 = OpAccessChain %18 %4 %22 OpStore %37 %36 OpBranch %29 %29 = OpLabel OpBranch %24 %24 = OpLabel %23 = OpIAdd %8 %22 %19 OpStore %3 %23 OpBranch %21 %25 = OpLabel OpReturn OpFunctionEnd )"; const std::string expected = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "i" OpName %4 "B" OpName %5 "A" %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %10 = OpConstant %8 0 %11 = OpConstant %8 10 %12 = OpTypeBool %13 = OpTypeFloat 32 %14 = OpTypeInt 32 0 %15 = OpConstant %14 10 %16 = OpTypeArray %13 %15 %17 = OpTypePointer Function %16 %18 = OpTypePointer Function %13 %19 = OpConstant %8 1 %2 = OpFunction %6 None %7 %20 = OpLabel %3 = OpVariable %9 Function %4 = OpVariable %17 Function %5 = OpVariable %17 Function OpStore %3 %10 OpBranch %38 %38 = OpLabel %39 = OpPhi %8 %10 %20 %53 %52 OpLoopMerge %54 %52 None OpBranch %40 %40 = OpLabel %41 = OpSLessThan %12 %39 %11 OpBranchConditional %41 %42 %54 %42 = OpLabel OpSelectionMerge %51 None OpSwitch %39 %47 1 %43 %43 = OpLabel OpBranch %51 %47 = OpLabel %48 = OpAccessChain %18 %4 %39 %49 = OpLoad %13 %48 %50 = OpAccessChain %18 %5 %39 OpStore %50 %49 OpBranch %51 %51 = OpLabel OpBranch %52 %52 = OpLabel %53 = OpIAdd %8 %39 %19 OpStore %3 %53 OpBranch %38 %54 = OpLabel OpBranch %21 %21 = OpLabel %22 = OpPhi %8 %10 %54 %23 %24 OpLoopMerge %25 %24 None OpBranch %26 %26 = OpLabel %27 = OpSLessThan %12 %22 %11 OpBranchConditional %27 %28 %25 %28 = OpLabel OpSelectionMerge %29 None OpSwitch %22 %30 1 %31 %30 = OpLabel OpBranch %29 %31 = OpLabel %35 = OpAccessChain %18 %5 %22 %36 = OpLoad %13 %35 %37 = OpAccessChain %18 %4 %22 OpStore %37 %36 OpBranch %29 %29 = OpLabel OpBranch %24 %24 = OpLabel %23 = OpIAdd %8 %22 %19 OpStore %3 %23 OpBranch %21 %25 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, source, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << source << std::endl; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(source, expected, true); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/loop_optimizations/nested_loops.cpp000066400000000000000000000630631475742701700274660ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include #include "gmock/gmock.h" #include "source/opt/iterator.h" #include "source/opt/loop_descriptor.h" #include "source/opt/pass.h" #include "source/opt/tree_iterator.h" #include "test/opt/assembly_builder.h" #include "test/opt/function_utils.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using ::testing::UnorderedElementsAre; bool Validate(const std::vector& bin) { spv_target_env target_env = SPV_ENV_UNIVERSAL_1_2; spv_context spvContext = spvContextCreate(target_env); spv_diagnostic diagnostic = nullptr; spv_const_binary_t binary = {bin.data(), bin.size()}; spv_result_t error = spvValidate(spvContext, &binary, &diagnostic); if (error != 0) spvDiagnosticPrint(diagnostic); spvDiagnosticDestroy(diagnostic); spvContextDestroy(spvContext); return error == 0; } using PassClassTest = PassTest<::testing::Test>; /* Generated from the following GLSL #version 330 core layout(location = 0) out vec4 c; void main() { int i = 0; for (; i < 10; ++i) { int j = 0; int k = 0; for (; j < 11; ++j) {} for (; k < 12; ++k) {} } } */ TEST_F(PassClassTest, BasicVisitFromEntryPoint) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 330 OpName %2 "main" OpName %4 "i" OpName %5 "j" OpName %6 "k" OpName %3 "c" OpDecorate %3 Location 0 %7 = OpTypeVoid %8 = OpTypeFunction %7 %9 = OpTypeInt 32 1 %10 = OpTypePointer Function %9 %11 = OpConstant %9 0 %12 = OpConstant %9 10 %13 = OpTypeBool %14 = OpConstant %9 11 %15 = OpConstant %9 1 %16 = OpConstant %9 12 %17 = OpTypeFloat 32 %18 = OpTypeVector %17 4 %19 = OpTypePointer Output %18 %3 = OpVariable %19 Output %2 = OpFunction %7 None %8 %20 = OpLabel %4 = OpVariable %10 Function %5 = OpVariable %10 Function %6 = OpVariable %10 Function OpStore %4 %11 OpBranch %21 %21 = OpLabel OpLoopMerge %22 %23 None OpBranch %24 %24 = OpLabel %25 = OpLoad %9 %4 %26 = OpSLessThan %13 %25 %12 OpBranchConditional %26 %27 %22 %27 = OpLabel OpStore %5 %11 OpStore %6 %11 OpBranch %28 %28 = OpLabel OpLoopMerge %29 %30 None OpBranch %31 %31 = OpLabel %32 = OpLoad %9 %5 %33 = OpSLessThan %13 %32 %14 OpBranchConditional %33 %34 %29 %34 = OpLabel OpBranch %30 %30 = OpLabel %35 = OpLoad %9 %5 %36 = OpIAdd %9 %35 %15 OpStore %5 %36 OpBranch %28 %29 = OpLabel OpBranch %37 %37 = OpLabel OpLoopMerge %38 %39 None OpBranch %40 %40 = OpLabel %41 = OpLoad %9 %6 %42 = OpSLessThan %13 %41 %16 OpBranchConditional %42 %43 %38 %43 = OpLabel OpBranch %39 %39 = OpLabel %44 = OpLoad %9 %6 %45 = OpIAdd %9 %44 %15 OpStore %6 %45 OpBranch %37 %38 = OpLabel OpBranch %23 %23 = OpLabel %46 = OpLoad %9 %4 %47 = OpIAdd %9 %46 %15 OpStore %4 %47 OpBranch %21 %22 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 2); LoopDescriptor& ld = *context->GetLoopDescriptor(f); EXPECT_EQ(ld.NumLoops(), 3u); // Invalid basic block id. EXPECT_EQ(ld[0u], nullptr); // Not a loop header. EXPECT_EQ(ld[20], nullptr); Loop& parent_loop = *ld[21]; EXPECT_TRUE(parent_loop.HasNestedLoops()); EXPECT_FALSE(parent_loop.IsNested()); EXPECT_EQ(parent_loop.GetDepth(), 1u); EXPECT_EQ(std::distance(parent_loop.begin(), parent_loop.end()), 2u); EXPECT_EQ(parent_loop.GetHeaderBlock(), spvtest::GetBasicBlock(f, 21)); EXPECT_EQ(parent_loop.GetLatchBlock(), spvtest::GetBasicBlock(f, 23)); EXPECT_EQ(parent_loop.GetMergeBlock(), spvtest::GetBasicBlock(f, 22)); Loop& child_loop_1 = *ld[28]; EXPECT_FALSE(child_loop_1.HasNestedLoops()); EXPECT_TRUE(child_loop_1.IsNested()); EXPECT_EQ(child_loop_1.GetDepth(), 2u); EXPECT_EQ(std::distance(child_loop_1.begin(), child_loop_1.end()), 0u); EXPECT_EQ(child_loop_1.GetHeaderBlock(), spvtest::GetBasicBlock(f, 28)); EXPECT_EQ(child_loop_1.GetLatchBlock(), spvtest::GetBasicBlock(f, 30)); EXPECT_EQ(child_loop_1.GetMergeBlock(), spvtest::GetBasicBlock(f, 29)); Loop& child_loop_2 = *ld[37]; EXPECT_FALSE(child_loop_2.HasNestedLoops()); EXPECT_TRUE(child_loop_2.IsNested()); EXPECT_EQ(child_loop_2.GetDepth(), 2u); EXPECT_EQ(std::distance(child_loop_2.begin(), child_loop_2.end()), 0u); EXPECT_EQ(child_loop_2.GetHeaderBlock(), spvtest::GetBasicBlock(f, 37)); EXPECT_EQ(child_loop_2.GetLatchBlock(), spvtest::GetBasicBlock(f, 39)); EXPECT_EQ(child_loop_2.GetMergeBlock(), spvtest::GetBasicBlock(f, 38)); } static void CheckLoopBlocks(Loop* loop, std::unordered_set* expected_ids) { SCOPED_TRACE("Check loop " + std::to_string(loop->GetHeaderBlock()->id())); for (uint32_t bb_id : loop->GetBlocks()) { EXPECT_EQ(expected_ids->count(bb_id), 1u); expected_ids->erase(bb_id); } EXPECT_FALSE(loop->IsInsideLoop(loop->GetMergeBlock())); EXPECT_EQ(expected_ids->size(), 0u); } /* Generated from the following GLSL #version 330 core layout(location = 0) out vec4 c; void main() { int i = 0; for (; i < 10; ++i) { for (int j = 0; j < 11; ++j) { if (j < 5) { for (int k = 0; k < 12; ++k) {} } else {} for (int k = 0; k < 12; ++k) {} } } }*/ TEST_F(PassClassTest, TripleNestedLoop) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 330 OpName %2 "main" OpName %4 "i" OpName %5 "j" OpName %6 "k" OpName %7 "k" OpName %3 "c" OpDecorate %3 Location 0 %8 = OpTypeVoid %9 = OpTypeFunction %8 %10 = OpTypeInt 32 1 %11 = OpTypePointer Function %10 %12 = OpConstant %10 0 %13 = OpConstant %10 10 %14 = OpTypeBool %15 = OpConstant %10 11 %16 = OpConstant %10 5 %17 = OpConstant %10 12 %18 = OpConstant %10 1 %19 = OpTypeFloat 32 %20 = OpTypeVector %19 4 %21 = OpTypePointer Output %20 %3 = OpVariable %21 Output %2 = OpFunction %8 None %9 %22 = OpLabel %4 = OpVariable %11 Function %5 = OpVariable %11 Function %6 = OpVariable %11 Function %7 = OpVariable %11 Function OpStore %4 %12 OpBranch %23 %23 = OpLabel OpLoopMerge %24 %25 None OpBranch %26 %26 = OpLabel %27 = OpLoad %10 %4 %28 = OpSLessThan %14 %27 %13 OpBranchConditional %28 %29 %24 %29 = OpLabel OpStore %5 %12 OpBranch %30 %30 = OpLabel OpLoopMerge %31 %32 None OpBranch %33 %33 = OpLabel %34 = OpLoad %10 %5 %35 = OpSLessThan %14 %34 %15 OpBranchConditional %35 %36 %31 %36 = OpLabel %37 = OpLoad %10 %5 %38 = OpSLessThan %14 %37 %16 OpSelectionMerge %39 None OpBranchConditional %38 %40 %39 %40 = OpLabel OpStore %6 %12 OpBranch %41 %41 = OpLabel OpLoopMerge %42 %43 None OpBranch %44 %44 = OpLabel %45 = OpLoad %10 %6 %46 = OpSLessThan %14 %45 %17 OpBranchConditional %46 %47 %42 %47 = OpLabel OpBranch %43 %43 = OpLabel %48 = OpLoad %10 %6 %49 = OpIAdd %10 %48 %18 OpStore %6 %49 OpBranch %41 %42 = OpLabel OpBranch %39 %39 = OpLabel OpStore %7 %12 OpBranch %50 %50 = OpLabel OpLoopMerge %51 %52 None OpBranch %53 %53 = OpLabel %54 = OpLoad %10 %7 %55 = OpSLessThan %14 %54 %17 OpBranchConditional %55 %56 %51 %56 = OpLabel OpBranch %52 %52 = OpLabel %57 = OpLoad %10 %7 %58 = OpIAdd %10 %57 %18 OpStore %7 %58 OpBranch %50 %51 = OpLabel OpBranch %32 %32 = OpLabel %59 = OpLoad %10 %5 %60 = OpIAdd %10 %59 %18 OpStore %5 %60 OpBranch %30 %31 = OpLabel OpBranch %25 %25 = OpLabel %61 = OpLoad %10 %4 %62 = OpIAdd %10 %61 %18 OpStore %4 %62 OpBranch %23 %24 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 2); LoopDescriptor& ld = *context->GetLoopDescriptor(f); EXPECT_EQ(ld.NumLoops(), 4u); // Invalid basic block id. EXPECT_EQ(ld[0u], nullptr); // Not in a loop. EXPECT_EQ(ld[22], nullptr); // Check that we can map basic block to the correct loop. // The following block ids do not belong to a loop. for (uint32_t bb_id : {22, 24}) EXPECT_EQ(ld[bb_id], nullptr); { std::unordered_set basic_block_in_loop = { {23, 26, 29, 30, 33, 36, 40, 41, 44, 47, 43, 42, 39, 50, 53, 56, 52, 51, 32, 31, 25}}; Loop* loop = ld[23]; CheckLoopBlocks(loop, &basic_block_in_loop); EXPECT_TRUE(loop->HasNestedLoops()); EXPECT_FALSE(loop->IsNested()); EXPECT_EQ(loop->GetDepth(), 1u); EXPECT_EQ(std::distance(loop->begin(), loop->end()), 1u); EXPECT_EQ(loop->GetPreHeaderBlock(), spvtest::GetBasicBlock(f, 22)); EXPECT_EQ(loop->GetHeaderBlock(), spvtest::GetBasicBlock(f, 23)); EXPECT_EQ(loop->GetLatchBlock(), spvtest::GetBasicBlock(f, 25)); EXPECT_EQ(loop->GetMergeBlock(), spvtest::GetBasicBlock(f, 24)); EXPECT_FALSE(loop->IsInsideLoop(loop->GetMergeBlock())); EXPECT_FALSE(loop->IsInsideLoop(loop->GetPreHeaderBlock())); } { std::unordered_set basic_block_in_loop = { {30, 33, 36, 40, 41, 44, 47, 43, 42, 39, 50, 53, 56, 52, 51, 32}}; Loop* loop = ld[30]; CheckLoopBlocks(loop, &basic_block_in_loop); EXPECT_TRUE(loop->HasNestedLoops()); EXPECT_TRUE(loop->IsNested()); EXPECT_EQ(loop->GetDepth(), 2u); EXPECT_EQ(std::distance(loop->begin(), loop->end()), 2u); EXPECT_EQ(loop->GetPreHeaderBlock(), spvtest::GetBasicBlock(f, 29)); EXPECT_EQ(loop->GetHeaderBlock(), spvtest::GetBasicBlock(f, 30)); EXPECT_EQ(loop->GetLatchBlock(), spvtest::GetBasicBlock(f, 32)); EXPECT_EQ(loop->GetMergeBlock(), spvtest::GetBasicBlock(f, 31)); EXPECT_FALSE(loop->IsInsideLoop(loop->GetMergeBlock())); EXPECT_FALSE(loop->IsInsideLoop(loop->GetPreHeaderBlock())); } { std::unordered_set basic_block_in_loop = {{41, 44, 47, 43}}; Loop* loop = ld[41]; CheckLoopBlocks(loop, &basic_block_in_loop); EXPECT_FALSE(loop->HasNestedLoops()); EXPECT_TRUE(loop->IsNested()); EXPECT_EQ(loop->GetDepth(), 3u); EXPECT_EQ(std::distance(loop->begin(), loop->end()), 0u); EXPECT_EQ(loop->GetPreHeaderBlock(), spvtest::GetBasicBlock(f, 40)); EXPECT_EQ(loop->GetHeaderBlock(), spvtest::GetBasicBlock(f, 41)); EXPECT_EQ(loop->GetLatchBlock(), spvtest::GetBasicBlock(f, 43)); EXPECT_EQ(loop->GetMergeBlock(), spvtest::GetBasicBlock(f, 42)); EXPECT_FALSE(loop->IsInsideLoop(loop->GetMergeBlock())); EXPECT_FALSE(loop->IsInsideLoop(loop->GetPreHeaderBlock())); } { std::unordered_set basic_block_in_loop = {{50, 53, 56, 52}}; Loop* loop = ld[50]; CheckLoopBlocks(loop, &basic_block_in_loop); EXPECT_FALSE(loop->HasNestedLoops()); EXPECT_TRUE(loop->IsNested()); EXPECT_EQ(loop->GetDepth(), 3u); EXPECT_EQ(std::distance(loop->begin(), loop->end()), 0u); EXPECT_EQ(loop->GetPreHeaderBlock(), spvtest::GetBasicBlock(f, 39)); EXPECT_EQ(loop->GetHeaderBlock(), spvtest::GetBasicBlock(f, 50)); EXPECT_EQ(loop->GetLatchBlock(), spvtest::GetBasicBlock(f, 52)); EXPECT_EQ(loop->GetMergeBlock(), spvtest::GetBasicBlock(f, 51)); EXPECT_FALSE(loop->IsInsideLoop(loop->GetMergeBlock())); EXPECT_FALSE(loop->IsInsideLoop(loop->GetPreHeaderBlock())); } // Make sure LoopDescriptor gives us the inner most loop when we query for // loops. for (const BasicBlock& bb : *f) { if (Loop* loop = ld[&bb]) { for (Loop& sub_loop : make_range(++TreeDFIterator(loop), TreeDFIterator())) { EXPECT_FALSE(sub_loop.IsInsideLoop(bb.id())); } } } } /* Generated from the following GLSL #version 330 core layout(location = 0) out vec4 c; void main() { for (int i = 0; i < 10; ++i) { for (int j = 0; j < 11; ++j) { for (int k = 0; k < 11; ++k) {} } for (int k = 0; k < 12; ++k) {} } } */ TEST_F(PassClassTest, LoopParentTest) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 330 OpName %2 "main" OpName %4 "i" OpName %5 "j" OpName %6 "k" OpName %7 "k" OpName %3 "c" OpDecorate %3 Location 0 %8 = OpTypeVoid %9 = OpTypeFunction %8 %10 = OpTypeInt 32 1 %11 = OpTypePointer Function %10 %12 = OpConstant %10 0 %13 = OpConstant %10 10 %14 = OpTypeBool %15 = OpConstant %10 11 %16 = OpConstant %10 1 %17 = OpConstant %10 12 %18 = OpTypeFloat 32 %19 = OpTypeVector %18 4 %20 = OpTypePointer Output %19 %3 = OpVariable %20 Output %2 = OpFunction %8 None %9 %21 = OpLabel %4 = OpVariable %11 Function %5 = OpVariable %11 Function %6 = OpVariable %11 Function %7 = OpVariable %11 Function OpStore %4 %12 OpBranch %22 %22 = OpLabel OpLoopMerge %23 %24 None OpBranch %25 %25 = OpLabel %26 = OpLoad %10 %4 %27 = OpSLessThan %14 %26 %13 OpBranchConditional %27 %28 %23 %28 = OpLabel OpStore %5 %12 OpBranch %29 %29 = OpLabel OpLoopMerge %30 %31 None OpBranch %32 %32 = OpLabel %33 = OpLoad %10 %5 %34 = OpSLessThan %14 %33 %15 OpBranchConditional %34 %35 %30 %35 = OpLabel OpStore %6 %12 OpBranch %36 %36 = OpLabel OpLoopMerge %37 %38 None OpBranch %39 %39 = OpLabel %40 = OpLoad %10 %6 %41 = OpSLessThan %14 %40 %15 OpBranchConditional %41 %42 %37 %42 = OpLabel OpBranch %38 %38 = OpLabel %43 = OpLoad %10 %6 %44 = OpIAdd %10 %43 %16 OpStore %6 %44 OpBranch %36 %37 = OpLabel OpBranch %31 %31 = OpLabel %45 = OpLoad %10 %5 %46 = OpIAdd %10 %45 %16 OpStore %5 %46 OpBranch %29 %30 = OpLabel OpStore %7 %12 OpBranch %47 %47 = OpLabel OpLoopMerge %48 %49 None OpBranch %50 %50 = OpLabel %51 = OpLoad %10 %7 %52 = OpSLessThan %14 %51 %17 OpBranchConditional %52 %53 %48 %53 = OpLabel OpBranch %49 %49 = OpLabel %54 = OpLoad %10 %7 %55 = OpIAdd %10 %54 %16 OpStore %7 %55 OpBranch %47 %48 = OpLabel OpBranch %24 %24 = OpLabel %56 = OpLoad %10 %4 %57 = OpIAdd %10 %56 %16 OpStore %4 %57 OpBranch %22 %23 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 2); LoopDescriptor& ld = *context->GetLoopDescriptor(f); EXPECT_EQ(ld.NumLoops(), 4u); { Loop& loop = *ld[22]; EXPECT_TRUE(loop.HasNestedLoops()); EXPECT_FALSE(loop.IsNested()); EXPECT_EQ(loop.GetDepth(), 1u); EXPECT_EQ(loop.GetParent(), nullptr); } { Loop& loop = *ld[29]; EXPECT_TRUE(loop.HasNestedLoops()); EXPECT_TRUE(loop.IsNested()); EXPECT_EQ(loop.GetDepth(), 2u); EXPECT_EQ(loop.GetParent(), ld[22]); } { Loop& loop = *ld[36]; EXPECT_FALSE(loop.HasNestedLoops()); EXPECT_TRUE(loop.IsNested()); EXPECT_EQ(loop.GetDepth(), 3u); EXPECT_EQ(loop.GetParent(), ld[29]); } { Loop& loop = *ld[47]; EXPECT_FALSE(loop.HasNestedLoops()); EXPECT_TRUE(loop.IsNested()); EXPECT_EQ(loop.GetDepth(), 2u); EXPECT_EQ(loop.GetParent(), ld[22]); } } /* Generated from the following GLSL + --eliminate-local-multi-store The preheader of loop %33 and %41 were removed as well. #version 330 core void main() { int a = 0; for (int i = 0; i < 10; ++i) { if (i == 0) { a = 1; } else { a = 2; } for (int j = 0; j < 11; ++j) { a++; } } for (int k = 0; k < 12; ++k) {} } */ TEST_F(PassClassTest, CreatePreheaderTest) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 330 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpConstant %5 0 %8 = OpConstant %5 10 %9 = OpTypeBool %10 = OpConstant %5 1 %11 = OpConstant %5 2 %12 = OpConstant %5 11 %13 = OpConstant %5 12 %14 = OpUndef %5 %2 = OpFunction %3 None %4 %15 = OpLabel OpBranch %16 %16 = OpLabel %17 = OpPhi %5 %7 %15 %18 %19 %20 = OpPhi %5 %7 %15 %21 %19 %22 = OpPhi %5 %14 %15 %23 %19 OpLoopMerge %41 %19 None OpBranch %25 %25 = OpLabel %26 = OpSLessThan %9 %20 %8 OpBranchConditional %26 %27 %41 %27 = OpLabel %28 = OpIEqual %9 %20 %7 OpSelectionMerge %33 None OpBranchConditional %28 %30 %31 %30 = OpLabel OpBranch %33 %31 = OpLabel OpBranch %33 %33 = OpLabel %18 = OpPhi %5 %10 %30 %11 %31 %34 %35 %23 = OpPhi %5 %7 %30 %7 %31 %36 %35 OpLoopMerge %37 %35 None OpBranch %38 %38 = OpLabel %39 = OpSLessThan %9 %23 %12 OpBranchConditional %39 %40 %37 %40 = OpLabel %34 = OpIAdd %5 %18 %10 OpBranch %35 %35 = OpLabel %36 = OpIAdd %5 %23 %10 OpBranch %33 %37 = OpLabel OpBranch %19 %19 = OpLabel %21 = OpIAdd %5 %20 %10 OpBranch %16 %41 = OpLabel %42 = OpPhi %5 %7 %25 %43 %44 OpLoopMerge %45 %44 None OpBranch %46 %46 = OpLabel %47 = OpSLessThan %9 %42 %13 OpBranchConditional %47 %48 %45 %48 = OpLabel OpBranch %44 %44 = OpLabel %43 = OpIAdd %5 %42 %10 OpBranch %41 %45 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 2); LoopDescriptor& ld = *context->GetLoopDescriptor(f); // No invalidation of the cfg should occur during this test. CFG* cfg = context->cfg(); EXPECT_EQ(ld.NumLoops(), 3u); { Loop& loop = *ld[16]; EXPECT_TRUE(loop.HasNestedLoops()); EXPECT_FALSE(loop.IsNested()); EXPECT_EQ(loop.GetDepth(), 1u); EXPECT_EQ(loop.GetParent(), nullptr); } { Loop& loop = *ld[33]; EXPECT_EQ(loop.GetPreHeaderBlock(), nullptr); EXPECT_NE(loop.GetOrCreatePreHeaderBlock(), nullptr); // Make sure the loop descriptor was properly updated. EXPECT_EQ(ld[loop.GetPreHeaderBlock()], ld[16]); { const std::vector& preds = cfg->preds(loop.GetPreHeaderBlock()->id()); std::unordered_set pred_set(preds.begin(), preds.end()); EXPECT_EQ(pred_set.size(), 2u); EXPECT_TRUE(pred_set.count(30)); EXPECT_TRUE(pred_set.count(31)); // Check the phi instructions. loop.GetPreHeaderBlock()->ForEachPhiInst([&pred_set](Instruction* phi) { for (uint32_t i = 1; i < phi->NumInOperands(); i += 2) { EXPECT_TRUE(pred_set.count(phi->GetSingleWordInOperand(i))); } }); } { const std::vector& preds = cfg->preds(loop.GetHeaderBlock()->id()); std::unordered_set pred_set(preds.begin(), preds.end()); EXPECT_EQ(pred_set.size(), 2u); EXPECT_TRUE(pred_set.count(loop.GetPreHeaderBlock()->id())); EXPECT_TRUE(pred_set.count(35)); // Check the phi instructions. loop.GetHeaderBlock()->ForEachPhiInst([&pred_set](Instruction* phi) { for (uint32_t i = 1; i < phi->NumInOperands(); i += 2) { EXPECT_TRUE(pred_set.count(phi->GetSingleWordInOperand(i))); } }); } } { Loop& loop = *ld[41]; EXPECT_EQ(loop.GetPreHeaderBlock(), nullptr); EXPECT_NE(loop.GetOrCreatePreHeaderBlock(), nullptr); EXPECT_EQ(ld[loop.GetPreHeaderBlock()], nullptr); EXPECT_EQ(cfg->preds(loop.GetPreHeaderBlock()->id()).size(), 1u); EXPECT_EQ(cfg->preds(loop.GetPreHeaderBlock()->id())[0], 25u); // Check the phi instructions. loop.GetPreHeaderBlock()->ForEachPhiInst([](Instruction* phi) { EXPECT_EQ(phi->NumInOperands(), 2u); EXPECT_EQ(phi->GetSingleWordInOperand(1), 25u); }); { const std::vector& preds = cfg->preds(loop.GetHeaderBlock()->id()); std::unordered_set pred_set(preds.begin(), preds.end()); EXPECT_EQ(pred_set.size(), 2u); EXPECT_TRUE(pred_set.count(loop.GetPreHeaderBlock()->id())); EXPECT_TRUE(pred_set.count(44)); // Check the phi instructions. loop.GetHeaderBlock()->ForEachPhiInst([&pred_set](Instruction* phi) { for (uint32_t i = 1; i < phi->NumInOperands(); i += 2) { EXPECT_TRUE(pred_set.count(phi->GetSingleWordInOperand(i))); } }); } } // Make sure pre-header insertion leaves the module valid. std::vector bin; context->module()->ToBinary(&bin, true); EXPECT_TRUE(Validate(bin)); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/loop_optimizations/pch_test_opt_loop.cpp000066400000000000000000000011731475742701700305060ustar00rootroot00000000000000// Copyright (c) 2018 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "pch_test_opt_loop.h" KhronosGroup-SPIRV-Tools-f289d04/test/opt/loop_optimizations/pch_test_opt_loop.h000066400000000000000000000017411475742701700301540ustar00rootroot00000000000000// Copyright (c) 2018 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "gmock/gmock.h" #include "source/opt/iterator.h" #include "source/opt/loop_dependence.h" #include "source/opt/loop_descriptor.h" #include "source/opt/pass.h" #include "source/opt/scalar_analysis.h" #include "source/opt/tree_iterator.h" #include "test/opt/assembly_builder.h" #include "test/opt/function_utils.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" KhronosGroup-SPIRV-Tools-f289d04/test/opt/loop_optimizations/peeling.cpp000066400000000000000000001163241475742701700264120ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "effcee/effcee.h" #include "gmock/gmock.h" #include "source/opt/ir_builder.h" #include "source/opt/loop_descriptor.h" #include "source/opt/loop_peeling.h" #include "test/opt/pass_fixture.h" namespace spvtools { namespace opt { namespace { using PeelingTest = PassTest<::testing::Test>; bool Validate(const std::vector& bin) { spv_target_env target_env = SPV_ENV_UNIVERSAL_1_2; spv_context spvContext = spvContextCreate(target_env); spv_diagnostic diagnostic = nullptr; spv_const_binary_t binary = {bin.data(), bin.size()}; spv_result_t error = spvValidate(spvContext, &binary, &diagnostic); if (error != 0) spvDiagnosticPrint(diagnostic); spvDiagnosticDestroy(diagnostic); spvContextDestroy(spvContext); return error == 0; } void Match(const std::string& checks, IRContext* context) { // Silence unused warnings with !defined(SPIRV_EFFCE) (void)checks; std::vector bin; context->module()->ToBinary(&bin, true); EXPECT_TRUE(Validate(bin)); std::string assembly; SpirvTools tools(SPV_ENV_UNIVERSAL_1_2); EXPECT_TRUE( tools.Disassemble(bin, &assembly, SPV_BINARY_TO_TEXT_OPTION_NO_HEADER)) << "Disassembling failed for shader:\n" << assembly << std::endl; auto match_result = effcee::Match(assembly, checks); EXPECT_EQ(effcee::Result::Status::Ok, match_result.status()) << match_result.message() << "\nChecking result:\n" << assembly; } /* Generated from the following GLSL + --eliminate-local-multi-store First test: #version 330 core void main() { for(int i = 0; i < 10; ++i) { if (i < 4) break; } } Second test (with a common sub-expression elimination): #version 330 core void main() { for(int i = 0; i + 1 < 10; ++i) { } } Third test: #version 330 core void main() { int a[10]; for (int i = 0; a[i] != 0; i++) {} } Forth test: #version 330 core void main() { for (long i = 0; i < 10; i++) {} } Fifth test: #version 330 core void main() { for (float i = 0; i < 10; i++) {} } Sixth test: #version 450 layout(location = 0)out float o; void main() { o = 0.0; for( int i = 0; true; i++ ) { o += 1.0; if (i > 10) break; } } */ TEST_F(PeelingTest, CannotPeel) { // Build the given SPIR-V program in |text|, take the first loop in the first // function and test that it is not peelable. |loop_count_id| is the id // representing the loop count, if equals to 0, then the function build a 10 // constant as loop count. auto test_cannot_peel = [](const std::string& text, uint32_t loop_count_id) { std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 1u); Instruction* loop_count = nullptr; if (loop_count_id) { loop_count = context->get_def_use_mgr()->GetDef(loop_count_id); } else { InstructionBuilder builder(context.get(), &*f.begin()); // Exit condition. loop_count = builder.GetSintConstant(10); } LoopPeeling peel(&*ld.begin(), loop_count); EXPECT_FALSE(peel.CanPeelLoop()); }; { SCOPED_TRACE("loop with break"); const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginLowerLeft OpSource GLSL 330 OpName %main "main" %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %bool = OpTypeBool %int_4 = OpConstant %int 4 %int_1 = OpConstant %int 1 %main = OpFunction %void None %3 %5 = OpLabel OpBranch %10 %10 = OpLabel %28 = OpPhi %int %int_0 %5 %27 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %bool %28 %int_10 OpBranchConditional %18 %11 %12 %11 = OpLabel %21 = OpSLessThan %bool %28 %int_4 OpSelectionMerge %23 None OpBranchConditional %21 %22 %23 %22 = OpLabel OpBranch %12 %23 = OpLabel OpBranch %13 %13 = OpLabel %27 = OpIAdd %int %28 %int_1 OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; test_cannot_peel(text, 0); } { SCOPED_TRACE("Ambiguous iterator update"); const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginLowerLeft OpSource GLSL 330 OpName %main "main" %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %int_10 = OpConstant %int 10 %bool = OpTypeBool %main = OpFunction %void None %3 %5 = OpLabel OpBranch %10 %10 = OpLabel %23 = OpPhi %int %int_0 %5 %17 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %17 = OpIAdd %int %23 %int_1 %20 = OpSLessThan %bool %17 %int_10 OpBranchConditional %20 %11 %12 %11 = OpLabel OpBranch %13 %13 = OpLabel OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; test_cannot_peel(text, 0); } { SCOPED_TRACE("No loop static bounds"); const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginLowerLeft OpSource GLSL 330 OpName %main "main" OpName %i "i" OpName %a "a" %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %uint_10 = OpConstant %uint 10 %_arr_int_uint_10 = OpTypeArray %int %uint_10 %_ptr_Function__arr_int_uint_10 = OpTypePointer Function %_arr_int_uint_10 %bool = OpTypeBool %int_1 = OpConstant %int 1 %main = OpFunction %void None %3 %5 = OpLabel %i = OpVariable %_ptr_Function_int Function %a = OpVariable %_ptr_Function__arr_int_uint_10 Function OpStore %i %int_0 OpBranch %10 %10 = OpLabel %28 = OpPhi %int %int_0 %5 %27 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %21 = OpAccessChain %_ptr_Function_int %a %28 %22 = OpLoad %int %21 %24 = OpINotEqual %bool %22 %int_0 OpBranchConditional %24 %11 %12 %11 = OpLabel OpBranch %13 %13 = OpLabel %27 = OpIAdd %int %28 %int_1 OpStore %i %27 OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; test_cannot_peel(text, 22); } { SCOPED_TRACE("Int 64 type for conditions"); const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginLowerLeft OpSource GLSL 330 OpName %2 "main" OpName %4 "i" %6 = OpTypeVoid %3 = OpTypeFunction %6 %7 = OpTypeInt 64 1 %8 = OpTypePointer Function %7 %9 = OpConstant %7 0 %15 = OpConstant %7 10 %16 = OpTypeBool %17 = OpConstant %7 1 %2 = OpFunction %6 None %3 %5 = OpLabel %4 = OpVariable %8 Function OpStore %4 %9 OpBranch %10 %10 = OpLabel %22 = OpPhi %7 %9 %5 %21 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %16 %22 %15 OpBranchConditional %18 %11 %12 %11 = OpLabel OpBranch %13 %13 = OpLabel %21 = OpIAdd %7 %22 %17 OpStore %4 %21 OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; // %15 is a constant for a 64 int. Currently rejected. test_cannot_peel(text, 15); } { SCOPED_TRACE("Float type for conditions"); const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginLowerLeft OpSource GLSL 330 OpName %2 "main" OpName %4 "i" %6 = OpTypeVoid %3 = OpTypeFunction %6 %7 = OpTypeFloat 32 %8 = OpTypePointer Function %7 %9 = OpConstant %7 0 %15 = OpConstant %7 10 %16 = OpTypeBool %17 = OpConstant %7 1 %2 = OpFunction %6 None %3 %5 = OpLabel %4 = OpVariable %8 Function OpStore %4 %9 OpBranch %10 %10 = OpLabel %22 = OpPhi %7 %9 %5 %21 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpFOrdLessThan %16 %22 %15 OpBranchConditional %18 %11 %12 %11 = OpLabel OpBranch %13 %13 = OpLabel %21 = OpFAdd %7 %22 %17 OpStore %4 %21 OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; // %15 is a constant for a float. Currently rejected. test_cannot_peel(text, 15); } { SCOPED_TRACE("Side effect before exit"); const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %o OpExecutionMode %main OriginLowerLeft OpSource GLSL 450 OpName %main "main" OpName %o "o" OpName %i "i" OpDecorate %o Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Output_float = OpTypePointer Output %float %o = OpVariable %_ptr_Output_float Output %float_0 = OpConstant %float 0 %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %bool = OpTypeBool %true = OpConstantTrue %bool %float_1 = OpConstant %float 1 %int_10 = OpConstant %int 10 %int_1 = OpConstant %int 1 %main = OpFunction %void None %3 %5 = OpLabel %i = OpVariable %_ptr_Function_int Function OpStore %o %float_0 OpStore %i %int_0 OpBranch %14 %14 = OpLabel %33 = OpPhi %int %int_0 %5 %32 %17 OpLoopMerge %16 %17 None OpBranch %15 %15 = OpLabel %22 = OpLoad %float %o %23 = OpFAdd %float %22 %float_1 OpStore %o %23 %26 = OpSGreaterThan %bool %33 %int_10 OpSelectionMerge %28 None OpBranchConditional %26 %27 %28 %27 = OpLabel OpBranch %16 %28 = OpLabel OpBranch %17 %17 = OpLabel %32 = OpIAdd %int %33 %int_1 OpStore %i %32 OpBranch %14 %16 = OpLabel OpReturn OpFunctionEnd )"; test_cannot_peel(text, 0); } } /* Generated from the following GLSL + --eliminate-local-multi-store #version 330 core void main() { int i = 0; for (; i < 10; i++) {} } */ TEST_F(PeelingTest, SimplePeeling) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginLowerLeft OpSource GLSL 330 OpName %main "main" %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %bool = OpTypeBool %int_1 = OpConstant %int 1 %main = OpFunction %void None %3 %5 = OpLabel OpBranch %10 %10 = OpLabel %22 = OpPhi %int %int_0 %5 %21 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %bool %22 %int_10 OpBranchConditional %18 %11 %12 %11 = OpLabel OpBranch %13 %13 = OpLabel %21 = OpIAdd %int %22 %int_1 OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; // Peel before. { SCOPED_TRACE("Peel before"); std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 1u); InstructionBuilder builder(context.get(), &*f.begin()); // Exit condition. Instruction* ten_cst = builder.GetSintConstant(10); LoopPeeling peel(&*ld.begin(), ten_cst); EXPECT_TRUE(peel.CanPeelLoop()); peel.PeelBefore(2); const std::string check = R"( CHECK: [[CST_TEN:%\w+]] = OpConstant {{%\w+}} 10 CHECK: [[CST_TWO:%\w+]] = OpConstant {{%\w+}} 2 CHECK: OpFunction CHECK-NEXT: [[ENTRY:%\w+]] = OpLabel CHECK: [[MIN_LOOP_COUNT:%\w+]] = OpSLessThan {{%\w+}} [[CST_TWO]] [[CST_TEN]] CHECK-NEXT: [[LOOP_COUNT:%\w+]] = OpSelect {{%\w+}} [[MIN_LOOP_COUNT]] [[CST_TWO]] [[CST_TEN]] CHECK: [[BEFORE_LOOP:%\w+]] = OpLabel CHECK-NEXT: [[DUMMY_IT:%\w+]] = OpPhi {{%\w+}} {{%\w+}} [[ENTRY]] [[DUMMY_IT_1:%\w+]] [[BE:%\w+]] CHECK-NEXT: [[i:%\w+]] = OpPhi {{%\w+}} {{%\w+}} [[ENTRY]] [[I_1:%\w+]] [[BE]] CHECK-NEXT: OpLoopMerge [[AFTER_LOOP_PREHEADER:%\w+]] [[BE]] None CHECK: [[COND_BLOCK:%\w+]] = OpLabel CHECK-NEXT: OpSLessThan CHECK-NEXT: [[EXIT_COND:%\w+]] = OpSLessThan {{%\w+}} [[DUMMY_IT]] CHECK-NEXT: OpBranchConditional [[EXIT_COND]] {{%\w+}} [[AFTER_LOOP_PREHEADER]] CHECK: [[I_1]] = OpIAdd {{%\w+}} [[i]] CHECK-NEXT: [[DUMMY_IT_1]] = OpIAdd {{%\w+}} [[DUMMY_IT]] CHECK-NEXT: OpBranch [[BEFORE_LOOP]] CHECK: [[AFTER_LOOP_PREHEADER]] = OpLabel CHECK-NEXT: OpSelectionMerge [[IF_MERGE:%\w+]] CHECK-NEXT: OpBranchConditional [[MIN_LOOP_COUNT]] [[AFTER_LOOP:%\w+]] [[IF_MERGE]] CHECK: [[AFTER_LOOP]] = OpLabel CHECK-NEXT: OpPhi {{%\w+}} {{%\w+}} {{%\w+}} [[i]] [[AFTER_LOOP_PREHEADER]] CHECK-NEXT: OpLoopMerge )"; Match(check, context.get()); } // Peel after. { SCOPED_TRACE("Peel after"); std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 1u); InstructionBuilder builder(context.get(), &*f.begin()); // Exit condition. Instruction* ten_cst = builder.GetSintConstant(10); LoopPeeling peel(&*ld.begin(), ten_cst); EXPECT_TRUE(peel.CanPeelLoop()); peel.PeelAfter(2); const std::string check = R"( CHECK: OpFunction CHECK-NEXT: [[ENTRY:%\w+]] = OpLabel CHECK: [[MIN_LOOP_COUNT:%\w+]] = OpSLessThan {{%\w+}} CHECK-NEXT: OpSelectionMerge [[IF_MERGE:%\w+]] CHECK-NEXT: OpBranchConditional [[MIN_LOOP_COUNT]] [[BEFORE_LOOP:%\w+]] [[IF_MERGE]] CHECK: [[BEFORE_LOOP]] = OpLabel CHECK-NEXT: [[DUMMY_IT:%\w+]] = OpPhi {{%\w+}} {{%\w+}} [[ENTRY]] [[DUMMY_IT_1:%\w+]] [[BE:%\w+]] CHECK-NEXT: [[I:%\w+]] = OpPhi {{%\w+}} {{%\w+}} [[ENTRY]] [[I_1:%\w+]] [[BE]] CHECK-NEXT: OpLoopMerge [[BEFORE_LOOP_MERGE:%\w+]] [[BE]] None CHECK: [[COND_BLOCK:%\w+]] = OpLabel CHECK-NEXT: OpSLessThan CHECK-NEXT: [[TMP:%\w+]] = OpIAdd {{%\w+}} [[DUMMY_IT]] {{%\w+}} CHECK-NEXT: [[EXIT_COND:%\w+]] = OpSLessThan {{%\w+}} [[TMP]] CHECK-NEXT: OpBranchConditional [[EXIT_COND]] {{%\w+}} [[BEFORE_LOOP_MERGE]] CHECK: [[I_1]] = OpIAdd {{%\w+}} [[I]] CHECK-NEXT: [[DUMMY_IT_1]] = OpIAdd {{%\w+}} [[DUMMY_IT]] CHECK-NEXT: OpBranch [[BEFORE_LOOP]] CHECK: [[IF_MERGE]] = OpLabel CHECK-NEXT: [[TMP:%\w+]] = OpPhi {{%\w+}} [[I]] [[BEFORE_LOOP_MERGE]] CHECK-NEXT: OpBranch [[AFTER_LOOP:%\w+]] CHECK: [[AFTER_LOOP]] = OpLabel CHECK-NEXT: OpPhi {{%\w+}} {{%\w+}} {{%\w+}} [[TMP]] [[IF_MERGE]] CHECK-NEXT: OpLoopMerge )"; Match(check, context.get()); } // Same as above, but reuse the induction variable. // Peel before. { SCOPED_TRACE("Peel before with IV reuse"); std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 1u); InstructionBuilder builder(context.get(), &*f.begin()); // Exit condition. Instruction* ten_cst = builder.GetSintConstant(10); LoopPeeling peel(&*ld.begin(), ten_cst, context->get_def_use_mgr()->GetDef(22)); EXPECT_TRUE(peel.CanPeelLoop()); peel.PeelBefore(2); const std::string check = R"( CHECK: [[CST_TEN:%\w+]] = OpConstant {{%\w+}} 10 CHECK: [[CST_TWO:%\w+]] = OpConstant {{%\w+}} 2 CHECK: OpFunction CHECK-NEXT: [[ENTRY:%\w+]] = OpLabel CHECK: [[MIN_LOOP_COUNT:%\w+]] = OpSLessThan {{%\w+}} [[CST_TWO]] [[CST_TEN]] CHECK-NEXT: [[LOOP_COUNT:%\w+]] = OpSelect {{%\w+}} [[MIN_LOOP_COUNT]] [[CST_TWO]] [[CST_TEN]] CHECK: [[BEFORE_LOOP:%\w+]] = OpLabel CHECK-NEXT: [[i:%\w+]] = OpPhi {{%\w+}} {{%\w+}} [[ENTRY]] [[I_1:%\w+]] [[BE:%\w+]] CHECK-NEXT: OpLoopMerge [[AFTER_LOOP_PREHEADER:%\w+]] [[BE]] None CHECK: [[COND_BLOCK:%\w+]] = OpLabel CHECK-NEXT: OpSLessThan CHECK-NEXT: [[EXIT_COND:%\w+]] = OpSLessThan {{%\w+}} [[i]] CHECK-NEXT: OpBranchConditional [[EXIT_COND]] {{%\w+}} [[AFTER_LOOP_PREHEADER]] CHECK: [[I_1]] = OpIAdd {{%\w+}} [[i]] CHECK-NEXT: OpBranch [[BEFORE_LOOP]] CHECK: [[AFTER_LOOP_PREHEADER]] = OpLabel CHECK-NEXT: OpSelectionMerge [[IF_MERGE:%\w+]] CHECK-NEXT: OpBranchConditional [[MIN_LOOP_COUNT]] [[AFTER_LOOP:%\w+]] [[IF_MERGE]] CHECK: [[AFTER_LOOP]] = OpLabel CHECK-NEXT: OpPhi {{%\w+}} {{%\w+}} {{%\w+}} [[i]] [[AFTER_LOOP_PREHEADER]] CHECK-NEXT: OpLoopMerge )"; Match(check, context.get()); } // Peel after. { SCOPED_TRACE("Peel after IV reuse"); std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 1u); InstructionBuilder builder(context.get(), &*f.begin()); // Exit condition. Instruction* ten_cst = builder.GetSintConstant(10); LoopPeeling peel(&*ld.begin(), ten_cst, context->get_def_use_mgr()->GetDef(22)); EXPECT_TRUE(peel.CanPeelLoop()); peel.PeelAfter(2); const std::string check = R"( CHECK: OpFunction CHECK-NEXT: [[ENTRY:%\w+]] = OpLabel CHECK: [[MIN_LOOP_COUNT:%\w+]] = OpSLessThan {{%\w+}} CHECK-NEXT: OpSelectionMerge [[IF_MERGE:%\w+]] CHECK-NEXT: OpBranchConditional [[MIN_LOOP_COUNT]] [[BEFORE_LOOP:%\w+]] [[IF_MERGE]] CHECK: [[BEFORE_LOOP]] = OpLabel CHECK-NEXT: [[I:%\w+]] = OpPhi {{%\w+}} {{%\w+}} [[ENTRY]] [[I_1:%\w+]] [[BE:%\w+]] CHECK-NEXT: OpLoopMerge [[BEFORE_LOOP_MERGE:%\w+]] [[BE]] None CHECK: [[COND_BLOCK:%\w+]] = OpLabel CHECK-NEXT: OpSLessThan CHECK-NEXT: [[TMP:%\w+]] = OpIAdd {{%\w+}} [[I]] {{%\w+}} CHECK-NEXT: [[EXIT_COND:%\w+]] = OpSLessThan {{%\w+}} [[TMP]] CHECK-NEXT: OpBranchConditional [[EXIT_COND]] {{%\w+}} [[BEFORE_LOOP_MERGE]] CHECK: [[I_1]] = OpIAdd {{%\w+}} [[I]] CHECK-NEXT: OpBranch [[BEFORE_LOOP]] CHECK: [[IF_MERGE]] = OpLabel CHECK-NEXT: [[TMP:%\w+]] = OpPhi {{%\w+}} [[I]] [[BEFORE_LOOP_MERGE]] CHECK-NEXT: OpBranch [[AFTER_LOOP:%\w+]] CHECK: [[AFTER_LOOP]] = OpLabel CHECK-NEXT: OpPhi {{%\w+}} {{%\w+}} {{%\w+}} [[TMP]] [[IF_MERGE]] CHECK-NEXT: OpLoopMerge )"; Match(check, context.get()); } } /* Generated from the following GLSL + --eliminate-local-multi-store #version 330 core void main() { int a[10]; int n = a[0]; for(int i = 0; i < n; ++i) {} } */ TEST_F(PeelingTest, PeelingUncountable) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginLowerLeft OpSource GLSL 330 OpName %main "main" OpName %a "a" %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %uint = OpTypeInt 32 0 %uint_10 = OpConstant %uint 10 %_arr_int_uint_10 = OpTypeArray %int %uint_10 %_ptr_Function__arr_int_uint_10 = OpTypePointer Function %_arr_int_uint_10 %int_0 = OpConstant %int 0 %bool = OpTypeBool %int_1 = OpConstant %int 1 %main = OpFunction %void None %3 %5 = OpLabel %a = OpVariable %_ptr_Function__arr_int_uint_10 Function %15 = OpAccessChain %_ptr_Function_int %a %int_0 %16 = OpLoad %int %15 OpBranch %18 %18 = OpLabel %30 = OpPhi %int %int_0 %5 %29 %21 OpLoopMerge %20 %21 None OpBranch %22 %22 = OpLabel %26 = OpSLessThan %bool %30 %16 OpBranchConditional %26 %19 %20 %19 = OpLabel OpBranch %21 %21 = OpLabel %29 = OpIAdd %int %30 %int_1 OpBranch %18 %20 = OpLabel OpReturn OpFunctionEnd )"; // Peel before. { SCOPED_TRACE("Peel before"); std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 1u); Instruction* loop_count = context->get_def_use_mgr()->GetDef(16); EXPECT_EQ(loop_count->opcode(), spv::Op::OpLoad); LoopPeeling peel(&*ld.begin(), loop_count); EXPECT_TRUE(peel.CanPeelLoop()); peel.PeelBefore(1); const std::string check = R"( CHECK: OpFunction CHECK-NEXT: [[ENTRY:%\w+]] = OpLabel CHECK: [[LOOP_COUNT:%\w+]] = OpLoad CHECK: [[MIN_LOOP_COUNT:%\w+]] = OpSLessThan {{%\w+}} {{%\w+}} [[LOOP_COUNT]] CHECK-NEXT: [[LOOP_COUNT:%\w+]] = OpSelect {{%\w+}} [[MIN_LOOP_COUNT]] {{%\w+}} [[LOOP_COUNT]] CHECK: [[BEFORE_LOOP:%\w+]] = OpLabel CHECK-NEXT: [[DUMMY_IT:%\w+]] = OpPhi {{%\w+}} {{%\w+}} [[ENTRY]] [[DUMMY_IT_1:%\w+]] [[BE:%\w+]] CHECK-NEXT: [[i:%\w+]] = OpPhi {{%\w+}} {{%\w+}} [[ENTRY]] [[I_1:%\w+]] [[BE]] CHECK-NEXT: OpLoopMerge [[AFTER_LOOP_PREHEADER:%\w+]] [[BE]] None CHECK: [[COND_BLOCK:%\w+]] = OpLabel CHECK-NEXT: OpSLessThan CHECK-NEXT: [[EXIT_COND:%\w+]] = OpSLessThan {{%\w+}} [[DUMMY_IT]] CHECK-NEXT: OpBranchConditional [[EXIT_COND]] {{%\w+}} [[AFTER_LOOP_PREHEADER]] CHECK: [[I_1]] = OpIAdd {{%\w+}} [[i]] CHECK-NEXT: [[DUMMY_IT_1]] = OpIAdd {{%\w+}} [[DUMMY_IT]] CHECK-NEXT: OpBranch [[BEFORE_LOOP]] CHECK: [[AFTER_LOOP_PREHEADER]] = OpLabel CHECK-NEXT: OpSelectionMerge [[IF_MERGE:%\w+]] CHECK-NEXT: OpBranchConditional [[MIN_LOOP_COUNT]] [[AFTER_LOOP:%\w+]] [[IF_MERGE]] CHECK: [[AFTER_LOOP]] = OpLabel CHECK-NEXT: OpPhi {{%\w+}} {{%\w+}} {{%\w+}} [[i]] [[AFTER_LOOP_PREHEADER]] CHECK-NEXT: OpLoopMerge )"; Match(check, context.get()); } // Peel after. { SCOPED_TRACE("Peel after"); std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 1u); Instruction* loop_count = context->get_def_use_mgr()->GetDef(16); EXPECT_EQ(loop_count->opcode(), spv::Op::OpLoad); LoopPeeling peel(&*ld.begin(), loop_count); EXPECT_TRUE(peel.CanPeelLoop()); peel.PeelAfter(1); const std::string check = R"( CHECK: OpFunction CHECK-NEXT: [[ENTRY:%\w+]] = OpLabel CHECK: [[MIN_LOOP_COUNT:%\w+]] = OpSLessThan {{%\w+}} CHECK-NEXT: OpSelectionMerge [[IF_MERGE:%\w+]] CHECK-NEXT: OpBranchConditional [[MIN_LOOP_COUNT]] [[BEFORE_LOOP:%\w+]] [[IF_MERGE]] CHECK: [[BEFORE_LOOP]] = OpLabel CHECK-NEXT: [[DUMMY_IT:%\w+]] = OpPhi {{%\w+}} {{%\w+}} [[ENTRY]] [[DUMMY_IT_1:%\w+]] [[BE:%\w+]] CHECK-NEXT: [[I:%\w+]] = OpPhi {{%\w+}} {{%\w+}} [[ENTRY]] [[I_1:%\w+]] [[BE]] CHECK-NEXT: OpLoopMerge [[BEFORE_LOOP_MERGE:%\w+]] [[BE]] None CHECK: [[COND_BLOCK:%\w+]] = OpLabel CHECK-NEXT: OpSLessThan CHECK-NEXT: [[TMP:%\w+]] = OpIAdd {{%\w+}} [[DUMMY_IT]] {{%\w+}} CHECK-NEXT: [[EXIT_COND:%\w+]] = OpSLessThan {{%\w+}} [[TMP]] CHECK-NEXT: OpBranchConditional [[EXIT_COND]] {{%\w+}} [[BEFORE_LOOP_MERGE]] CHECK: [[I_1]] = OpIAdd {{%\w+}} [[I]] CHECK-NEXT: [[DUMMY_IT_1]] = OpIAdd {{%\w+}} [[DUMMY_IT]] CHECK-NEXT: OpBranch [[BEFORE_LOOP]] CHECK: [[IF_MERGE]] = OpLabel CHECK-NEXT: [[TMP:%\w+]] = OpPhi {{%\w+}} [[I]] [[BEFORE_LOOP_MERGE]] CHECK-NEXT: OpBranch [[AFTER_LOOP:%\w+]] CHECK: [[AFTER_LOOP]] = OpLabel CHECK-NEXT: OpPhi {{%\w+}} {{%\w+}} {{%\w+}} [[TMP]] [[IF_MERGE]] CHECK-NEXT: OpLoopMerge )"; Match(check, context.get()); } } /* Generated from the following GLSL + --eliminate-local-multi-store #version 330 core void main() { int i = 0; do { i++; } while (i < 10); } */ TEST_F(PeelingTest, DoWhilePeeling) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginLowerLeft OpSource GLSL 330 OpName %main "main" %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %int_10 = OpConstant %int 10 %bool = OpTypeBool %main = OpFunction %void None %3 %5 = OpLabel OpBranch %10 %10 = OpLabel %21 = OpPhi %int %int_0 %5 %16 %13 OpLoopMerge %12 %13 None OpBranch %11 %11 = OpLabel %16 = OpIAdd %int %21 %int_1 OpBranch %13 %13 = OpLabel %20 = OpSLessThan %bool %16 %int_10 OpBranchConditional %20 %10 %12 %12 = OpLabel OpReturn OpFunctionEnd )"; // Peel before. { SCOPED_TRACE("Peel before"); std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 1u); InstructionBuilder builder(context.get(), &*f.begin()); // Exit condition. Instruction* ten_cst = builder.GetUintConstant(10); LoopPeeling peel(&*ld.begin(), ten_cst); EXPECT_TRUE(peel.CanPeelLoop()); peel.PeelBefore(2); const std::string check = R"( CHECK: OpFunction CHECK-NEXT: [[ENTRY:%\w+]] = OpLabel CHECK: [[MIN_LOOP_COUNT:%\w+]] = OpULessThan {{%\w+}} CHECK-NEXT: [[LOOP_COUNT:%\w+]] = OpSelect {{%\w+}} [[MIN_LOOP_COUNT]] CHECK: [[BEFORE_LOOP:%\w+]] = OpLabel CHECK-NEXT: [[DUMMY_IT:%\w+]] = OpPhi {{%\w+}} {{%\w+}} [[ENTRY]] [[DUMMY_IT_1:%\w+]] [[BE:%\w+]] CHECK-NEXT: [[i:%\w+]] = OpPhi {{%\w+}} {{%\w+}} [[ENTRY]] [[I_1:%\w+]] [[BE]] CHECK-NEXT: OpLoopMerge [[AFTER_LOOP_PREHEADER:%\w+]] [[BE]] None CHECK: [[I_1]] = OpIAdd {{%\w+}} [[i]] CHECK: [[BE]] = OpLabel CHECK: [[DUMMY_IT_1]] = OpIAdd {{%\w+}} [[DUMMY_IT]] CHECK-NEXT: [[EXIT_COND:%\w+]] = OpULessThan {{%\w+}} [[DUMMY_IT_1]] CHECK-NEXT: OpBranchConditional [[EXIT_COND]] [[BEFORE_LOOP]] [[AFTER_LOOP_PREHEADER]] CHECK: [[AFTER_LOOP_PREHEADER]] = OpLabel CHECK-NEXT: OpSelectionMerge [[IF_MERGE:%\w+]] CHECK-NEXT: OpBranchConditional [[MIN_LOOP_COUNT]] [[AFTER_LOOP:%\w+]] [[IF_MERGE]] CHECK: [[AFTER_LOOP]] = OpLabel CHECK-NEXT: OpPhi {{%\w+}} {{%\w+}} {{%\w+}} [[I_1]] [[AFTER_LOOP_PREHEADER]] CHECK-NEXT: OpLoopMerge )"; Match(check, context.get()); } // Peel after. { SCOPED_TRACE("Peel after"); std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 1u); InstructionBuilder builder(context.get(), &*f.begin()); // Exit condition. Instruction* ten_cst = builder.GetUintConstant(10); LoopPeeling peel(&*ld.begin(), ten_cst); EXPECT_TRUE(peel.CanPeelLoop()); peel.PeelAfter(2); const std::string check = R"( CHECK: OpFunction CHECK-NEXT: [[ENTRY:%\w+]] = OpLabel CHECK: [[MIN_LOOP_COUNT:%\w+]] = OpULessThan {{%\w+}} CHECK-NEXT: OpSelectionMerge [[IF_MERGE:%\w+]] CHECK-NEXT: OpBranchConditional [[MIN_LOOP_COUNT]] [[BEFORE_LOOP:%\w+]] [[IF_MERGE]] CHECK: [[BEFORE_LOOP]] = OpLabel CHECK-NEXT: [[DUMMY_IT:%\w+]] = OpPhi {{%\w+}} {{%\w+}} [[ENTRY]] [[DUMMY_IT_1:%\w+]] [[BE:%\w+]] CHECK-NEXT: [[I:%\w+]] = OpPhi {{%\w+}} {{%\w+}} [[ENTRY]] [[I_1:%\w+]] [[BE]] CHECK-NEXT: OpLoopMerge [[BEFORE_LOOP_MERGE:%\w+]] [[BE]] None CHECK: [[I_1]] = OpIAdd {{%\w+}} [[I]] CHECK: [[BE]] = OpLabel CHECK: [[DUMMY_IT_1]] = OpIAdd {{%\w+}} [[DUMMY_IT]] CHECK-NEXT: [[EXIT_VAL:%\w+]] = OpIAdd {{%\w+}} [[DUMMY_IT_1]] CHECK-NEXT: [[EXIT_COND:%\w+]] = OpULessThan {{%\w+}} [[EXIT_VAL]] CHECK-NEXT: OpBranchConditional [[EXIT_COND]] [[BEFORE_LOOP]] [[BEFORE_LOOP_MERGE]] CHECK: [[IF_MERGE]] = OpLabel CHECK-NEXT: [[TMP:%\w+]] = OpPhi {{%\w+}} [[I_1]] [[BEFORE_LOOP_MERGE]] CHECK-NEXT: OpBranch [[AFTER_LOOP:%\w+]] CHECK: [[AFTER_LOOP]] = OpLabel CHECK-NEXT: OpPhi {{%\w+}} {{%\w+}} {{%\w+}} [[TMP]] [[IF_MERGE]] CHECK-NEXT: OpLoopMerge )"; Match(check, context.get()); } } /* Generated from the following GLSL + --eliminate-local-multi-store #version 330 core void main() { int a[10]; int n = a[0]; for(int i = 0; i < n; ++i) {} } */ TEST_F(PeelingTest, PeelingLoopWithStore) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %o %n OpExecutionMode %main OriginLowerLeft OpSource GLSL 450 OpName %main "main" OpName %o "o" OpName %end "end" OpName %n "n" OpName %i "i" OpDecorate %o Location 0 OpDecorate %n Flat OpDecorate %n Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Output_float = OpTypePointer Output %float %o = OpVariable %_ptr_Output_float Output %float_0 = OpConstant %float 0 %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %_ptr_Input_int = OpTypePointer Input %int %n = OpVariable %_ptr_Input_int Input %int_0 = OpConstant %int 0 %bool = OpTypeBool %float_1 = OpConstant %float 1 %int_1 = OpConstant %int 1 %main = OpFunction %void None %3 %5 = OpLabel %end = OpVariable %_ptr_Function_int Function %i = OpVariable %_ptr_Function_int Function OpStore %o %float_0 %15 = OpLoad %int %n OpStore %end %15 OpStore %i %int_0 OpBranch %18 %18 = OpLabel %33 = OpPhi %int %int_0 %5 %32 %21 OpLoopMerge %20 %21 None OpBranch %22 %22 = OpLabel %26 = OpSLessThan %bool %33 %15 OpBranchConditional %26 %19 %20 %19 = OpLabel %28 = OpLoad %float %o %29 = OpFAdd %float %28 %float_1 OpStore %o %29 OpBranch %21 %21 = OpLabel %32 = OpIAdd %int %33 %int_1 OpStore %i %32 OpBranch %18 %20 = OpLabel OpReturn OpFunctionEnd )"; // Peel before. { SCOPED_TRACE("Peel before"); std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 1u); Instruction* loop_count = context->get_def_use_mgr()->GetDef(15); EXPECT_EQ(loop_count->opcode(), spv::Op::OpLoad); LoopPeeling peel(&*ld.begin(), loop_count); EXPECT_TRUE(peel.CanPeelLoop()); peel.PeelBefore(1); const std::string check = R"( CHECK: OpFunction CHECK-NEXT: [[ENTRY:%\w+]] = OpLabel CHECK: [[LOOP_COUNT:%\w+]] = OpLoad CHECK: [[MIN_LOOP_COUNT:%\w+]] = OpSLessThan {{%\w+}} {{%\w+}} [[LOOP_COUNT]] CHECK-NEXT: [[LOOP_COUNT:%\w+]] = OpSelect {{%\w+}} [[MIN_LOOP_COUNT]] {{%\w+}} [[LOOP_COUNT]] CHECK: [[BEFORE_LOOP:%\w+]] = OpLabel CHECK-NEXT: [[DUMMY_IT:%\w+]] = OpPhi {{%\w+}} {{%\w+}} [[ENTRY]] [[DUMMY_IT_1:%\w+]] [[BE:%\w+]] CHECK-NEXT: [[i:%\w+]] = OpPhi {{%\w+}} {{%\w+}} [[ENTRY]] [[I_1:%\w+]] [[BE]] CHECK-NEXT: OpLoopMerge [[AFTER_LOOP_PREHEADER:%\w+]] [[BE]] None CHECK: [[COND_BLOCK:%\w+]] = OpLabel CHECK-NEXT: OpSLessThan CHECK-NEXT: [[EXIT_COND:%\w+]] = OpSLessThan {{%\w+}} [[DUMMY_IT]] CHECK-NEXT: OpBranchConditional [[EXIT_COND]] {{%\w+}} [[AFTER_LOOP_PREHEADER]] CHECK: [[I_1]] = OpIAdd {{%\w+}} [[i]] CHECK: [[DUMMY_IT_1]] = OpIAdd {{%\w+}} [[DUMMY_IT]] CHECK-NEXT: OpBranch [[BEFORE_LOOP]] CHECK: [[AFTER_LOOP_PREHEADER]] = OpLabel CHECK-NEXT: OpSelectionMerge [[IF_MERGE:%\w+]] CHECK-NEXT: OpBranchConditional [[MIN_LOOP_COUNT]] [[AFTER_LOOP:%\w+]] [[IF_MERGE]] CHECK: [[AFTER_LOOP]] = OpLabel CHECK-NEXT: OpPhi {{%\w+}} {{%\w+}} {{%\w+}} [[i]] [[AFTER_LOOP_PREHEADER]] CHECK-NEXT: OpLoopMerge )"; Match(check, context.get()); } // Peel after. { SCOPED_TRACE("Peel after"); std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function& f = *module->begin(); LoopDescriptor& ld = *context->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), 1u); Instruction* loop_count = context->get_def_use_mgr()->GetDef(15); EXPECT_EQ(loop_count->opcode(), spv::Op::OpLoad); LoopPeeling peel(&*ld.begin(), loop_count); EXPECT_TRUE(peel.CanPeelLoop()); peel.PeelAfter(1); const std::string check = R"( CHECK: OpFunction CHECK-NEXT: [[ENTRY:%\w+]] = OpLabel CHECK: [[MIN_LOOP_COUNT:%\w+]] = OpSLessThan {{%\w+}} CHECK-NEXT: OpSelectionMerge [[IF_MERGE:%\w+]] CHECK-NEXT: OpBranchConditional [[MIN_LOOP_COUNT]] [[BEFORE_LOOP:%\w+]] [[IF_MERGE]] CHECK: [[BEFORE_LOOP]] = OpLabel CHECK-NEXT: [[DUMMY_IT:%\w+]] = OpPhi {{%\w+}} {{%\w+}} [[ENTRY]] [[DUMMY_IT_1:%\w+]] [[BE:%\w+]] CHECK-NEXT: [[I:%\w+]] = OpPhi {{%\w+}} {{%\w+}} [[ENTRY]] [[I_1:%\w+]] [[BE]] CHECK-NEXT: OpLoopMerge [[BEFORE_LOOP_MERGE:%\w+]] [[BE]] None CHECK: [[COND_BLOCK:%\w+]] = OpLabel CHECK-NEXT: OpSLessThan CHECK-NEXT: [[TMP:%\w+]] = OpIAdd {{%\w+}} [[DUMMY_IT]] {{%\w+}} CHECK-NEXT: [[EXIT_COND:%\w+]] = OpSLessThan {{%\w+}} [[TMP]] CHECK-NEXT: OpBranchConditional [[EXIT_COND]] {{%\w+}} [[BEFORE_LOOP_MERGE]] CHECK: [[I_1]] = OpIAdd {{%\w+}} [[I]] CHECK: [[DUMMY_IT_1]] = OpIAdd {{%\w+}} [[DUMMY_IT]] CHECK-NEXT: OpBranch [[BEFORE_LOOP]] CHECK: [[IF_MERGE]] = OpLabel CHECK-NEXT: [[TMP:%\w+]] = OpPhi {{%\w+}} [[I]] [[BEFORE_LOOP_MERGE]] CHECK-NEXT: OpBranch [[AFTER_LOOP:%\w+]] CHECK: [[AFTER_LOOP]] = OpLabel CHECK-NEXT: OpPhi {{%\w+}} {{%\w+}} {{%\w+}} [[TMP]] [[IF_MERGE]] CHECK-NEXT: OpLoopMerge )"; Match(check, context.get()); } } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/loop_optimizations/peeling_pass.cpp000066400000000000000000001040461475742701700274360ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include "gmock/gmock.h" #include "source/opt/loop_descriptor.h" #include "source/opt/loop_peeling.h" #include "test/opt/pass_fixture.h" namespace spvtools { namespace opt { namespace { class PeelingPassTest : public PassTest<::testing::Test> { public: // Generic routine to run the loop peeling pass and check LoopPeelingPass::LoopPeelingStats AssembleAndRunPeelingTest( const std::string& text_head, const std::string& text_tail, spv::Op opcode, const std::string& res_id, const std::string& op1, const std::string& op2) { std::string opcode_str; switch (opcode) { case spv::Op::OpSLessThan: opcode_str = "OpSLessThan"; break; case spv::Op::OpSGreaterThan: opcode_str = "OpSGreaterThan"; break; case spv::Op::OpSLessThanEqual: opcode_str = "OpSLessThanEqual"; break; case spv::Op::OpSGreaterThanEqual: opcode_str = "OpSGreaterThanEqual"; break; case spv::Op::OpIEqual: opcode_str = "OpIEqual"; break; case spv::Op::OpINotEqual: opcode_str = "OpINotEqual"; break; default: assert(false && "Unhandled"); break; } std::string test_cond = res_id + " = " + opcode_str + " %bool " + op1 + " " + op2 + "\n"; LoopPeelingPass::LoopPeelingStats stats; SinglePassRunAndDisassemble( text_head + test_cond + text_tail, true, true, &stats); return stats; } // Generic routine to run the loop peeling pass and check LoopPeelingPass::LoopPeelingStats RunPeelingTest( const std::string& text_head, const std::string& text_tail, spv::Op opcode, const std::string& res_id, const std::string& op1, const std::string& op2, size_t nb_of_loops) { LoopPeelingPass::LoopPeelingStats stats = AssembleAndRunPeelingTest( text_head, text_tail, opcode, res_id, op1, op2); Function& f = *context()->module()->begin(); LoopDescriptor& ld = *context()->GetLoopDescriptor(&f); EXPECT_EQ(ld.NumLoops(), nb_of_loops); return stats; } using PeelTraceType = std::vector>; void BuildAndCheckTrace(const std::string& text_head, const std::string& text_tail, spv::Op opcode, const std::string& res_id, const std::string& op1, const std::string& op2, const PeelTraceType& expected_peel_trace, size_t expected_nb_of_loops) { auto stats = RunPeelingTest(text_head, text_tail, opcode, res_id, op1, op2, expected_nb_of_loops); EXPECT_EQ(stats.peeled_loops_.size(), expected_peel_trace.size()); if (stats.peeled_loops_.size() != expected_peel_trace.size()) { return; } PeelTraceType::const_iterator expected_trace_it = expected_peel_trace.begin(); decltype(stats.peeled_loops_)::const_iterator stats_it = stats.peeled_loops_.begin(); while (expected_trace_it != expected_peel_trace.end()) { EXPECT_EQ(expected_trace_it->first, std::get<1>(*stats_it)); EXPECT_EQ(expected_trace_it->second, std::get<2>(*stats_it)); ++expected_trace_it; ++stats_it; } } }; /* Test are derivation of the following generated test from the following GLSL + --eliminate-local-multi-store #version 330 core void main() { int a = 0; for(int i = 1; i < 10; i += 2) { if (i < 3) { a += 2; } } } The condition is interchanged to test < > <= >= == and peel before/after opportunities. */ TEST_F(PeelingPassTest, PeelingPassBasic) { const std::string text_head = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginLowerLeft OpSource GLSL 330 OpName %main "main" OpName %a "a" OpName %i "i" %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %bool = OpTypeBool %int_20 = OpConstant %int 20 %int_19 = OpConstant %int 19 %int_18 = OpConstant %int 18 %int_17 = OpConstant %int 17 %int_16 = OpConstant %int 16 %int_15 = OpConstant %int 15 %int_14 = OpConstant %int 14 %int_13 = OpConstant %int 13 %int_12 = OpConstant %int 12 %int_11 = OpConstant %int 11 %int_10 = OpConstant %int 10 %int_9 = OpConstant %int 9 %int_8 = OpConstant %int 8 %int_7 = OpConstant %int 7 %int_6 = OpConstant %int 6 %int_5 = OpConstant %int 5 %int_4 = OpConstant %int 4 %int_3 = OpConstant %int 3 %int_2 = OpConstant %int 2 %int_1 = OpConstant %int 1 %int_0 = OpConstant %int 0 %main = OpFunction %void None %3 %5 = OpLabel %a = OpVariable %_ptr_Function_int Function %i = OpVariable %_ptr_Function_int Function OpStore %a %int_0 OpStore %i %int_0 OpBranch %11 %11 = OpLabel %31 = OpPhi %int %int_0 %5 %33 %14 %32 = OpPhi %int %int_1 %5 %30 %14 OpLoopMerge %13 %14 None OpBranch %15 %15 = OpLabel %19 = OpSLessThan %bool %32 %int_20 OpBranchConditional %19 %12 %13 %12 = OpLabel )"; const std::string text_tail = R"( OpSelectionMerge %24 None OpBranchConditional %22 %23 %24 %23 = OpLabel %27 = OpIAdd %int %31 %int_2 OpStore %a %27 OpBranch %24 %24 = OpLabel %33 = OpPhi %int %31 %12 %27 %23 OpBranch %14 %14 = OpLabel %30 = OpIAdd %int %32 %int_2 OpStore %i %30 OpBranch %11 %13 = OpLabel OpReturn OpFunctionEnd )"; auto run_test = [&text_head, &text_tail, this](spv::Op opcode, const std::string& op1, const std::string& op2) { auto stats = RunPeelingTest(text_head, text_tail, opcode, "%22", op1, op2, 2); EXPECT_EQ(stats.peeled_loops_.size(), 1u); if (stats.peeled_loops_.size() != 1u) return std::pair{ LoopPeelingPass::PeelDirection::kNone, 0}; return std::pair{ std::get<1>(*stats.peeled_loops_.begin()), std::get<2>(*stats.peeled_loops_.begin())}; }; // Test LT // Peel before by a factor of 2. { SCOPED_TRACE("Peel before iv < 4"); std::pair peel_info = run_test(spv::Op::OpSLessThan, "%32", "%int_4"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kBefore); EXPECT_EQ(peel_info.second, 2u); } { SCOPED_TRACE("Peel before 4 > iv"); std::pair peel_info = run_test(spv::Op::OpSGreaterThan, "%int_4", "%32"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kBefore); EXPECT_EQ(peel_info.second, 2u); } { SCOPED_TRACE("Peel before iv < 5"); std::pair peel_info = run_test(spv::Op::OpSLessThan, "%32", "%int_5"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kBefore); EXPECT_EQ(peel_info.second, 2u); } { SCOPED_TRACE("Peel before 5 > iv"); std::pair peel_info = run_test(spv::Op::OpSGreaterThan, "%int_5", "%32"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kBefore); EXPECT_EQ(peel_info.second, 2u); } // Peel after by a factor of 2. { SCOPED_TRACE("Peel after iv < 16"); std::pair peel_info = run_test(spv::Op::OpSLessThan, "%32", "%int_16"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kAfter); EXPECT_EQ(peel_info.second, 2u); } { SCOPED_TRACE("Peel after 16 > iv"); std::pair peel_info = run_test(spv::Op::OpSGreaterThan, "%int_16", "%32"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kAfter); EXPECT_EQ(peel_info.second, 2u); } { SCOPED_TRACE("Peel after iv < 17"); std::pair peel_info = run_test(spv::Op::OpSLessThan, "%32", "%int_17"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kAfter); EXPECT_EQ(peel_info.second, 2u); } { SCOPED_TRACE("Peel after 17 > iv"); std::pair peel_info = run_test(spv::Op::OpSGreaterThan, "%int_17", "%32"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kAfter); EXPECT_EQ(peel_info.second, 2u); } // Test GT // Peel before by a factor of 2. { SCOPED_TRACE("Peel before iv > 5"); std::pair peel_info = run_test(spv::Op::OpSGreaterThan, "%32", "%int_5"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kBefore); EXPECT_EQ(peel_info.second, 2u); } { SCOPED_TRACE("Peel before 5 < iv"); std::pair peel_info = run_test(spv::Op::OpSLessThan, "%int_5", "%32"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kBefore); EXPECT_EQ(peel_info.second, 2u); } { SCOPED_TRACE("Peel before iv > 4"); std::pair peel_info = run_test(spv::Op::OpSGreaterThan, "%32", "%int_4"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kBefore); EXPECT_EQ(peel_info.second, 2u); } { SCOPED_TRACE("Peel before 4 < iv"); std::pair peel_info = run_test(spv::Op::OpSLessThan, "%int_4", "%32"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kBefore); EXPECT_EQ(peel_info.second, 2u); } // Peel after by a factor of 2. { SCOPED_TRACE("Peel after iv > 16"); std::pair peel_info = run_test(spv::Op::OpSGreaterThan, "%32", "%int_16"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kAfter); EXPECT_EQ(peel_info.second, 2u); } { SCOPED_TRACE("Peel after 16 < iv"); std::pair peel_info = run_test(spv::Op::OpSLessThan, "%int_16", "%32"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kAfter); EXPECT_EQ(peel_info.second, 2u); } { SCOPED_TRACE("Peel after iv > 17"); std::pair peel_info = run_test(spv::Op::OpSGreaterThan, "%32", "%int_17"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kAfter); EXPECT_EQ(peel_info.second, 2u); } { SCOPED_TRACE("Peel after 17 < iv"); std::pair peel_info = run_test(spv::Op::OpSLessThan, "%int_17", "%32"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kAfter); EXPECT_EQ(peel_info.second, 2u); } // Test LE // Peel before by a factor of 2. { SCOPED_TRACE("Peel before iv <= 4"); std::pair peel_info = run_test(spv::Op::OpSLessThanEqual, "%32", "%int_4"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kBefore); EXPECT_EQ(peel_info.second, 2u); } { SCOPED_TRACE("Peel before 4 => iv"); std::pair peel_info = run_test(spv::Op::OpSGreaterThanEqual, "%int_4", "%32"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kBefore); EXPECT_EQ(peel_info.second, 2u); } { SCOPED_TRACE("Peel before iv <= 3"); std::pair peel_info = run_test(spv::Op::OpSLessThanEqual, "%32", "%int_3"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kBefore); EXPECT_EQ(peel_info.second, 2u); } { SCOPED_TRACE("Peel before 3 => iv"); std::pair peel_info = run_test(spv::Op::OpSGreaterThanEqual, "%int_3", "%32"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kBefore); EXPECT_EQ(peel_info.second, 2u); } // Peel after by a factor of 2. { SCOPED_TRACE("Peel after iv <= 16"); std::pair peel_info = run_test(spv::Op::OpSLessThanEqual, "%32", "%int_16"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kAfter); EXPECT_EQ(peel_info.second, 2u); } { SCOPED_TRACE("Peel after 16 => iv"); std::pair peel_info = run_test(spv::Op::OpSGreaterThanEqual, "%int_16", "%32"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kAfter); EXPECT_EQ(peel_info.second, 2u); } { SCOPED_TRACE("Peel after iv <= 15"); std::pair peel_info = run_test(spv::Op::OpSLessThanEqual, "%32", "%int_15"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kAfter); EXPECT_EQ(peel_info.second, 2u); } { SCOPED_TRACE("Peel after 15 => iv"); std::pair peel_info = run_test(spv::Op::OpSGreaterThanEqual, "%int_15", "%32"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kAfter); EXPECT_EQ(peel_info.second, 2u); } // Test GE // Peel before by a factor of 2. { SCOPED_TRACE("Peel before iv >= 5"); std::pair peel_info = run_test(spv::Op::OpSGreaterThanEqual, "%32", "%int_5"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kBefore); EXPECT_EQ(peel_info.second, 2u); } { SCOPED_TRACE("Peel before 35 >= iv"); std::pair peel_info = run_test(spv::Op::OpSLessThanEqual, "%int_5", "%32"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kBefore); EXPECT_EQ(peel_info.second, 2u); } { SCOPED_TRACE("Peel before iv >= 4"); std::pair peel_info = run_test(spv::Op::OpSGreaterThanEqual, "%32", "%int_4"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kBefore); EXPECT_EQ(peel_info.second, 2u); } { SCOPED_TRACE("Peel before 4 <= iv"); std::pair peel_info = run_test(spv::Op::OpSLessThanEqual, "%int_4", "%32"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kBefore); EXPECT_EQ(peel_info.second, 2u); } // Peel after by a factor of 2. { SCOPED_TRACE("Peel after iv >= 17"); std::pair peel_info = run_test(spv::Op::OpSGreaterThanEqual, "%32", "%int_17"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kAfter); EXPECT_EQ(peel_info.second, 2u); } { SCOPED_TRACE("Peel after 17 <= iv"); std::pair peel_info = run_test(spv::Op::OpSLessThanEqual, "%int_17", "%32"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kAfter); EXPECT_EQ(peel_info.second, 2u); } { SCOPED_TRACE("Peel after iv >= 16"); std::pair peel_info = run_test(spv::Op::OpSGreaterThanEqual, "%32", "%int_16"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kAfter); EXPECT_EQ(peel_info.second, 2u); } { SCOPED_TRACE("Peel after 16 <= iv"); std::pair peel_info = run_test(spv::Op::OpSLessThanEqual, "%int_16", "%32"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kAfter); EXPECT_EQ(peel_info.second, 2u); } // Test EQ // Peel before by a factor of 1. { SCOPED_TRACE("Peel before iv == 1"); std::pair peel_info = run_test(spv::Op::OpIEqual, "%32", "%int_1"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kBefore); EXPECT_EQ(peel_info.second, 1u); } { SCOPED_TRACE("Peel before 1 == iv"); std::pair peel_info = run_test(spv::Op::OpIEqual, "%int_1", "%32"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kBefore); EXPECT_EQ(peel_info.second, 1u); } // Peel after by a factor of 1. { SCOPED_TRACE("Peel after iv == 19"); std::pair peel_info = run_test(spv::Op::OpIEqual, "%32", "%int_19"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kAfter); EXPECT_EQ(peel_info.second, 1u); } { SCOPED_TRACE("Peel after 19 == iv"); std::pair peel_info = run_test(spv::Op::OpIEqual, "%int_19", "%32"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kAfter); EXPECT_EQ(peel_info.second, 1u); } // Test NE // Peel before by a factor of 1. { SCOPED_TRACE("Peel before iv != 1"); std::pair peel_info = run_test(spv::Op::OpINotEqual, "%32", "%int_1"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kBefore); EXPECT_EQ(peel_info.second, 1u); } { SCOPED_TRACE("Peel before 1 != iv"); std::pair peel_info = run_test(spv::Op::OpINotEqual, "%int_1", "%32"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kBefore); EXPECT_EQ(peel_info.second, 1u); } // Peel after by a factor of 1. { SCOPED_TRACE("Peel after iv != 19"); std::pair peel_info = run_test(spv::Op::OpINotEqual, "%32", "%int_19"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kAfter); EXPECT_EQ(peel_info.second, 1u); } { SCOPED_TRACE("Peel after 19 != iv"); std::pair peel_info = run_test(spv::Op::OpINotEqual, "%int_19", "%32"); EXPECT_EQ(peel_info.first, LoopPeelingPass::PeelDirection::kAfter); EXPECT_EQ(peel_info.second, 1u); } // No peel. { SCOPED_TRACE("No Peel: 20 => iv"); auto stats = RunPeelingTest(text_head, text_tail, spv::Op::OpSLessThanEqual, "%22", "%int_20", "%32", 1); EXPECT_EQ(stats.peeled_loops_.size(), 0u); } } /* Test are derivation of the following generated test from the following GLSL + --eliminate-local-multi-store #version 330 core void main() { int a = 0; for(int i = 0; i < 10; ++i) { if (i < 3) { a += 2; } if (i < 1) { a += 2; } } } The condition is interchanged to test < > <= >= == and peel before/after opportunities. */ TEST_F(PeelingPassTest, MultiplePeelingPass) { const std::string text_head = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginLowerLeft OpSource GLSL 330 OpName %main "main" OpName %a "a" OpName %i "i" %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %bool = OpTypeBool %int_10 = OpConstant %int 10 %int_9 = OpConstant %int 9 %int_8 = OpConstant %int 8 %int_7 = OpConstant %int 7 %int_6 = OpConstant %int 6 %int_5 = OpConstant %int 5 %int_4 = OpConstant %int 4 %int_3 = OpConstant %int 3 %int_2 = OpConstant %int 2 %int_1 = OpConstant %int 1 %int_0 = OpConstant %int 0 %main = OpFunction %void None %3 %5 = OpLabel %a = OpVariable %_ptr_Function_int Function %i = OpVariable %_ptr_Function_int Function OpStore %a %int_0 OpStore %i %int_0 OpBranch %11 %11 = OpLabel %37 = OpPhi %int %int_0 %5 %40 %14 %38 = OpPhi %int %int_0 %5 %36 %14 OpLoopMerge %13 %14 None OpBranch %15 %15 = OpLabel %19 = OpSLessThan %bool %38 %int_10 OpBranchConditional %19 %12 %13 %12 = OpLabel )"; const std::string text_tail = R"( OpSelectionMerge %24 None OpBranchConditional %22 %23 %24 %23 = OpLabel %27 = OpIAdd %int %37 %int_2 OpStore %a %27 OpBranch %24 %24 = OpLabel %39 = OpPhi %int %37 %12 %27 %23 %30 = OpSLessThan %bool %38 %int_1 OpSelectionMerge %32 None OpBranchConditional %30 %31 %32 %31 = OpLabel %34 = OpIAdd %int %39 %int_2 OpStore %a %34 OpBranch %32 %32 = OpLabel %40 = OpPhi %int %39 %24 %34 %31 OpBranch %14 %14 = OpLabel %36 = OpIAdd %int %38 %int_1 OpStore %i %36 OpBranch %11 %13 = OpLabel OpReturn OpFunctionEnd )"; auto run_test = [&text_head, &text_tail, this]( spv::Op opcode, const std::string& op1, const std::string& op2, const PeelTraceType& expected_peel_trace) { BuildAndCheckTrace(text_head, text_tail, opcode, "%22", op1, op2, expected_peel_trace, expected_peel_trace.size() + 1); }; // Test LT // Peel before by a factor of 3. { SCOPED_TRACE("Peel before iv < 3"); run_test(spv::Op::OpSLessThan, "%38", "%int_3", {{LoopPeelingPass::PeelDirection::kBefore, 3u}}); } { SCOPED_TRACE("Peel before 3 > iv"); run_test(spv::Op::OpSGreaterThan, "%int_3", "%38", {{LoopPeelingPass::PeelDirection::kBefore, 3u}}); } // Peel after by a factor of 2. { SCOPED_TRACE("Peel after iv < 8"); run_test(spv::Op::OpSLessThan, "%38", "%int_8", {{LoopPeelingPass::PeelDirection::kAfter, 2u}}); } { SCOPED_TRACE("Peel after 8 > iv"); run_test(spv::Op::OpSGreaterThan, "%int_8", "%38", {{LoopPeelingPass::PeelDirection::kAfter, 2u}}); } // Test GT // Peel before by a factor of 2. { SCOPED_TRACE("Peel before iv > 2"); run_test(spv::Op::OpSGreaterThan, "%38", "%int_2", {{LoopPeelingPass::PeelDirection::kBefore, 2u}}); } { SCOPED_TRACE("Peel before 2 < iv"); run_test(spv::Op::OpSLessThan, "%int_2", "%38", {{LoopPeelingPass::PeelDirection::kBefore, 2u}}); } // Peel after by a factor of 3. { SCOPED_TRACE("Peel after iv > 7"); run_test(spv::Op::OpSGreaterThan, "%38", "%int_7", {{LoopPeelingPass::PeelDirection::kAfter, 3u}}); } { SCOPED_TRACE("Peel after 7 < iv"); run_test(spv::Op::OpSLessThan, "%int_7", "%38", {{LoopPeelingPass::PeelDirection::kAfter, 3u}}); } // Test LE // Peel before by a factor of 2. { SCOPED_TRACE("Peel before iv <= 1"); run_test(spv::Op::OpSLessThanEqual, "%38", "%int_1", {{LoopPeelingPass::PeelDirection::kBefore, 2u}}); } { SCOPED_TRACE("Peel before 1 => iv"); run_test(spv::Op::OpSGreaterThanEqual, "%int_1", "%38", {{LoopPeelingPass::PeelDirection::kBefore, 2u}}); } // Peel after by a factor of 2. { SCOPED_TRACE("Peel after iv <= 7"); run_test(spv::Op::OpSLessThanEqual, "%38", "%int_7", {{LoopPeelingPass::PeelDirection::kAfter, 2u}}); } { SCOPED_TRACE("Peel after 7 => iv"); run_test(spv::Op::OpSGreaterThanEqual, "%int_7", "%38", {{LoopPeelingPass::PeelDirection::kAfter, 2u}}); } // Test GE // Peel before by a factor of 2. { SCOPED_TRACE("Peel before iv >= 2"); run_test(spv::Op::OpSGreaterThanEqual, "%38", "%int_2", {{LoopPeelingPass::PeelDirection::kBefore, 2u}}); } { SCOPED_TRACE("Peel before 2 <= iv"); run_test(spv::Op::OpSLessThanEqual, "%int_2", "%38", {{LoopPeelingPass::PeelDirection::kBefore, 2u}}); } // Peel after by a factor of 2. { SCOPED_TRACE("Peel after iv >= 8"); run_test(spv::Op::OpSGreaterThanEqual, "%38", "%int_8", {{LoopPeelingPass::PeelDirection::kAfter, 2u}}); } { SCOPED_TRACE("Peel after 8 <= iv"); run_test(spv::Op::OpSLessThanEqual, "%int_8", "%38", {{LoopPeelingPass::PeelDirection::kAfter, 2u}}); } // Test EQ // Peel before by a factor of 1. { SCOPED_TRACE("Peel before iv == 0"); run_test(spv::Op::OpIEqual, "%38", "%int_0", {{LoopPeelingPass::PeelDirection::kBefore, 1u}}); } { SCOPED_TRACE("Peel before 0 == iv"); run_test(spv::Op::OpIEqual, "%int_0", "%38", {{LoopPeelingPass::PeelDirection::kBefore, 1u}}); } // Peel after by a factor of 1. { SCOPED_TRACE("Peel after iv == 9"); run_test(spv::Op::OpIEqual, "%38", "%int_9", {{LoopPeelingPass::PeelDirection::kBefore, 1u}}); } { SCOPED_TRACE("Peel after 9 == iv"); run_test(spv::Op::OpIEqual, "%int_9", "%38", {{LoopPeelingPass::PeelDirection::kBefore, 1u}}); } // Test NE // Peel before by a factor of 1. { SCOPED_TRACE("Peel before iv != 0"); run_test(spv::Op::OpINotEqual, "%38", "%int_0", {{LoopPeelingPass::PeelDirection::kBefore, 1u}}); } { SCOPED_TRACE("Peel before 0 != iv"); run_test(spv::Op::OpINotEqual, "%int_0", "%38", {{LoopPeelingPass::PeelDirection::kBefore, 1u}}); } // Peel after by a factor of 1. { SCOPED_TRACE("Peel after iv != 9"); run_test(spv::Op::OpINotEqual, "%38", "%int_9", {{LoopPeelingPass::PeelDirection::kBefore, 1u}}); } { SCOPED_TRACE("Peel after 9 != iv"); run_test(spv::Op::OpINotEqual, "%int_9", "%38", {{LoopPeelingPass::PeelDirection::kBefore, 1u}}); } } /* Test are derivation of the following generated test from the following GLSL + --eliminate-local-multi-store #version 330 core void main() { int a = 0; for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { if (i < 3) { a += 2; } } } } */ TEST_F(PeelingPassTest, PeelingNestedPass) { const std::string text_head = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginLowerLeft OpSource GLSL 330 OpName %main "main" OpName %a "a" OpName %i "i" OpName %j "j" %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %bool = OpTypeBool %int_7 = OpConstant %int 7 %int_3 = OpConstant %int 3 %int_2 = OpConstant %int 2 %int_1 = OpConstant %int 1 %43 = OpUndef %int %main = OpFunction %void None %3 %5 = OpLabel %a = OpVariable %_ptr_Function_int Function %i = OpVariable %_ptr_Function_int Function %j = OpVariable %_ptr_Function_int Function OpStore %a %int_0 OpStore %i %int_0 OpBranch %11 %11 = OpLabel %41 = OpPhi %int %int_0 %5 %45 %14 %42 = OpPhi %int %int_0 %5 %40 %14 %44 = OpPhi %int %43 %5 %46 %14 OpLoopMerge %13 %14 None OpBranch %15 %15 = OpLabel %19 = OpSLessThan %bool %42 %int_10 OpBranchConditional %19 %12 %13 %12 = OpLabel OpStore %j %int_0 OpBranch %21 %21 = OpLabel %45 = OpPhi %int %41 %12 %47 %24 %46 = OpPhi %int %int_0 %12 %38 %24 OpLoopMerge %23 %24 None OpBranch %25 %25 = OpLabel %27 = OpSLessThan %bool %46 %int_10 OpBranchConditional %27 %22 %23 %22 = OpLabel )"; const std::string text_tail = R"( OpSelectionMerge %32 None OpBranchConditional %30 %31 %32 %31 = OpLabel %35 = OpIAdd %int %45 %int_2 OpStore %a %35 OpBranch %32 %32 = OpLabel %47 = OpPhi %int %45 %22 %35 %31 OpBranch %24 %24 = OpLabel %38 = OpIAdd %int %46 %int_1 OpStore %j %38 OpBranch %21 %23 = OpLabel OpBranch %14 %14 = OpLabel %40 = OpIAdd %int %42 %int_1 OpStore %i %40 OpBranch %11 %13 = OpLabel OpReturn OpFunctionEnd )"; auto run_test = [&text_head, &text_tail, this]( spv::Op opcode, const std::string& op1, const std::string& op2, const PeelTraceType& expected_peel_trace, size_t nb_of_loops) { BuildAndCheckTrace(text_head, text_tail, opcode, "%30", op1, op2, expected_peel_trace, nb_of_loops); }; // Peeling outer before by a factor of 3. { SCOPED_TRACE("Peel before iv_i < 3"); // Expect peel before by a factor of 3 and 4 loops at the end. run_test(spv::Op::OpSLessThan, "%42", "%int_3", {{LoopPeelingPass::PeelDirection::kBefore, 3u}}, 4); } // Peeling outer loop after by a factor of 3. { SCOPED_TRACE("Peel after iv_i < 7"); // Expect peel after by a factor of 3 and 4 loops at the end. run_test(spv::Op::OpSLessThan, "%42", "%int_7", {{LoopPeelingPass::PeelDirection::kAfter, 3u}}, 4); } // Peeling inner loop before by a factor of 3. { SCOPED_TRACE("Peel before iv_j < 3"); // Expect peel before by a factor of 3 and 3 loops at the end. run_test(spv::Op::OpSLessThan, "%46", "%int_3", {{LoopPeelingPass::PeelDirection::kBefore, 3u}}, 3); } // Peeling inner loop after by a factor of 3. { SCOPED_TRACE("Peel after iv_j < 7"); // Expect peel after by a factor of 3 and 3 loops at the end. run_test(spv::Op::OpSLessThan, "%46", "%int_7", {{LoopPeelingPass::PeelDirection::kAfter, 3u}}, 3); } // Not unworkable condition. { SCOPED_TRACE("No peel"); // Expect no peeling and 2 loops at the end. run_test(spv::Op::OpSLessThan, "%46", "%42", {}, 2); } // Could do a peeling of 3, but the goes over the threshold. { SCOPED_TRACE("Over threshold"); size_t current_threshold = LoopPeelingPass::GetLoopPeelingThreshold(); LoopPeelingPass::SetLoopPeelingThreshold(1u); // Expect no peeling and 2 loops at the end. run_test(spv::Op::OpSLessThan, "%46", "%int_7", {}, 2); LoopPeelingPass::SetLoopPeelingThreshold(current_threshold); } } /* Test are derivation of the following generated test from the following GLSL + --eliminate-local-multi-store #version 330 core void main() { int a = 0; for (int i = 0, j = 0; i < 10; j++, i++) { if (i < j) { a += 2; } } } */ TEST_F(PeelingPassTest, PeelingNoChanges) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginLowerLeft OpSource GLSL 330 OpName %main "main" OpName %a "a" OpName %i "i" OpName %j "j" %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %bool = OpTypeBool %int_2 = OpConstant %int 2 %int_1 = OpConstant %int 1 %main = OpFunction %void None %3 %5 = OpLabel %a = OpVariable %_ptr_Function_int Function %i = OpVariable %_ptr_Function_int Function %j = OpVariable %_ptr_Function_int Function OpStore %a %int_0 OpStore %i %int_0 OpStore %j %int_0 OpBranch %12 %12 = OpLabel %34 = OpPhi %int %int_0 %5 %37 %15 %35 = OpPhi %int %int_0 %5 %33 %15 %36 = OpPhi %int %int_0 %5 %31 %15 OpLoopMerge %14 %15 None OpBranch %16 %16 = OpLabel %20 = OpSLessThan %bool %35 %int_10 OpBranchConditional %20 %13 %14 %13 = OpLabel %23 = OpSLessThan %bool %35 %36 OpSelectionMerge %25 None OpBranchConditional %23 %24 %25 %24 = OpLabel %28 = OpIAdd %int %34 %int_2 OpStore %a %28 OpBranch %25 %25 = OpLabel %37 = OpPhi %int %34 %13 %28 %24 OpBranch %15 %15 = OpLabel %31 = OpIAdd %int %36 %int_1 OpStore %j %31 %33 = OpIAdd %int %35 %int_1 OpStore %i %33 OpBranch %12 %14 = OpLabel OpReturn OpFunctionEnd )"; { auto result = SinglePassRunAndDisassemble(text, true, false); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/loop_optimizations/unroll_assumptions.cpp000066400000000000000000001110461475742701700307430ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gmock/gmock.h" #include "source/opt/loop_unroller.h" #include "source/opt/loop_utils.h" #include "source/opt/pass.h" #include "test/opt/assembly_builder.h" #include "test/opt/function_utils.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using ::testing::UnorderedElementsAre; using PassClassTest = PassTest<::testing::Test>; template class PartialUnrollerTestPass : public Pass { public: PartialUnrollerTestPass() : Pass() {} const char* name() const override { return "Loop unroller"; } Status Process() override { bool changed = false; for (Function& f : *context()->module()) { if (f.IsDeclaration()) { continue; } LoopDescriptor& loop_descriptor = *context()->GetLoopDescriptor(&f); for (auto& loop : loop_descriptor) { LoopUtils loop_utils{context(), &loop}; if (loop_utils.PartiallyUnroll(factor)) { changed = true; } } } if (changed) return Pass::Status::SuccessWithChange; return Pass::Status::SuccessWithoutChange; } }; /* Generated from the following GLSL #version 410 core layout(location = 0) flat in int in_upper_bound; void main() { for (int i = 0; i < in_upper_bound; ++i) { x[i] = 1.0f; } } */ TEST_F(PassClassTest, CheckUpperBound) { // clang-format off // With LocalMultiStoreElimPass const std::string text = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 410 OpName %2 "main" OpName %3 "in_upper_bound" OpName %4 "x" OpDecorate %3 Flat OpDecorate %3 Location 0 %5 = OpTypeVoid %6 = OpTypeFunction %5 %7 = OpTypeInt 32 1 %8 = OpTypePointer Function %7 %9 = OpConstant %7 0 %10 = OpTypePointer Input %7 %3 = OpVariable %10 Input %11 = OpTypeBool %12 = OpTypeFloat 32 %13 = OpTypeInt 32 0 %14 = OpConstant %13 10 %15 = OpTypeArray %12 %14 %16 = OpTypePointer Function %15 %17 = OpConstant %12 1 %18 = OpTypePointer Function %12 %19 = OpConstant %7 1 %2 = OpFunction %5 None %6 %20 = OpLabel %4 = OpVariable %16 Function OpBranch %21 %21 = OpLabel %22 = OpPhi %7 %9 %20 %23 %24 OpLoopMerge %25 %24 Unroll OpBranch %26 %26 = OpLabel %27 = OpLoad %7 %3 %28 = OpSLessThan %11 %22 %27 OpBranchConditional %28 %29 %25 %29 = OpLabel %30 = OpAccessChain %18 %4 %22 OpStore %30 %17 OpBranch %24 %24 = OpLabel %23 = OpIAdd %7 %22 %19 OpBranch %21 %25 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; LoopUnroller loop_unroller; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); // Make sure the pass doesn't run SinglePassRunAndCheck(text, text, false); SinglePassRunAndCheck>(text, text, false); SinglePassRunAndCheck>(text, text, false); } /* Generated from the following GLSL #version 410 core void main() { float out_array[10]; for (uint i = 0; i < 2; i++) { for (float x = 0; x < 5; ++x) { out_array[x + i*5] = i; } } } */ TEST_F(PassClassTest, UnrollNestedLoopsInvalid) { // clang-format off // With LocalMultiStoreElimPass const std::string text = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 410 OpName %2 "main" OpName %3 "out_array" %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeInt 32 0 %7 = OpTypePointer Function %6 %8 = OpConstant %6 0 %9 = OpConstant %6 2 %10 = OpTypeBool %11 = OpTypeInt 32 1 %12 = OpTypePointer Function %11 %13 = OpConstant %11 0 %14 = OpConstant %11 5 %15 = OpTypeFloat 32 %16 = OpConstant %6 10 %17 = OpTypeArray %15 %16 %18 = OpTypePointer Function %17 %19 = OpConstant %6 5 %20 = OpTypePointer Function %15 %21 = OpConstant %11 1 %22 = OpUndef %11 %2 = OpFunction %4 None %5 %23 = OpLabel %3 = OpVariable %18 Function OpBranch %24 %24 = OpLabel %25 = OpPhi %6 %8 %23 %26 %27 %28 = OpPhi %11 %22 %23 %29 %27 OpLoopMerge %30 %27 Unroll OpBranch %31 %31 = OpLabel %32 = OpULessThan %10 %25 %9 OpBranchConditional %32 %33 %30 %33 = OpLabel OpBranch %34 %34 = OpLabel %29 = OpPhi %11 %13 %33 %35 %36 OpLoopMerge %37 %36 None OpBranch %38 %38 = OpLabel %39 = OpSLessThan %10 %29 %14 OpBranchConditional %39 %40 %37 %40 = OpLabel %41 = OpBitcast %6 %29 %42 = OpIMul %6 %25 %19 %43 = OpIAdd %6 %41 %42 %44 = OpConvertUToF %15 %25 %45 = OpAccessChain %20 %3 %43 OpStore %45 %44 OpBranch %36 %36 = OpLabel %35 = OpIAdd %11 %29 %21 OpBranch %34 %37 = OpLabel OpBranch %27 %27 = OpLabel %26 = OpIAdd %6 %25 %21 OpBranch %24 %30 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; LoopUnroller loop_unroller; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(text, text, false); } /* Generated from the following GLSL #version 440 core void main(){ float x[10]; for (int i = 0; i < 10; i++) { if (i == 5) { break; } x[i] = i; } } */ TEST_F(PassClassTest, BreakInBody) { // clang-format off // With LocalMultiStoreElimPass const std::string text = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 440 OpName %2 "main" OpName %3 "x" %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpConstant %6 0 %9 = OpConstant %6 10 %10 = OpTypeBool %11 = OpConstant %6 5 %12 = OpTypeFloat 32 %13 = OpTypeInt 32 0 %14 = OpConstant %13 10 %15 = OpTypeArray %12 %14 %16 = OpTypePointer Function %15 %17 = OpTypePointer Function %12 %18 = OpConstant %6 1 %2 = OpFunction %4 None %5 %19 = OpLabel %3 = OpVariable %16 Function OpBranch %20 %20 = OpLabel %21 = OpPhi %6 %8 %19 %22 %23 OpLoopMerge %24 %23 Unroll OpBranch %25 %25 = OpLabel %26 = OpSLessThan %10 %21 %9 OpBranchConditional %26 %27 %24 %27 = OpLabel %28 = OpIEqual %10 %21 %11 OpSelectionMerge %29 None OpBranchConditional %28 %30 %29 %30 = OpLabel OpBranch %24 %29 = OpLabel %31 = OpConvertSToF %12 %21 %32 = OpAccessChain %17 %3 %21 OpStore %32 %31 OpBranch %23 %23 = OpLabel %22 = OpIAdd %6 %21 %18 OpBranch %20 %24 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; LoopUnroller loop_unroller; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(text, text, false); } /* Generated from the following GLSL #version 440 core void main(){ float x[10]; for (int i = 0; i < 10; i++) { if (i == 5) { continue; } x[i] = i; } } */ TEST_F(PassClassTest, ContinueInBody) { // clang-format off // With LocalMultiStoreElimPass const std::string text = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 440 OpName %2 "main" OpName %3 "x" %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpConstant %6 0 %9 = OpConstant %6 10 %10 = OpTypeBool %11 = OpConstant %6 5 %12 = OpTypeFloat 32 %13 = OpTypeInt 32 0 %14 = OpConstant %13 10 %15 = OpTypeArray %12 %14 %16 = OpTypePointer Function %15 %17 = OpTypePointer Function %12 %18 = OpConstant %6 1 %2 = OpFunction %4 None %5 %19 = OpLabel %3 = OpVariable %16 Function OpBranch %20 %20 = OpLabel %21 = OpPhi %6 %8 %19 %22 %23 OpLoopMerge %24 %23 Unroll OpBranch %25 %25 = OpLabel %26 = OpSLessThan %10 %21 %9 OpBranchConditional %26 %27 %24 %27 = OpLabel %28 = OpIEqual %10 %21 %11 OpSelectionMerge %29 None OpBranchConditional %28 %30 %29 %30 = OpLabel OpBranch %23 %29 = OpLabel %31 = OpConvertSToF %12 %21 %32 = OpAccessChain %17 %3 %21 OpStore %32 %31 OpBranch %23 %23 = OpLabel %22 = OpIAdd %6 %21 %18 OpBranch %20 %24 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; LoopUnroller loop_unroller; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(text, text, false); } /* Generated from the following GLSL #version 440 core void main(){ float x[10]; for (int i = 0; i < 10; i++) { if (i == 5) { return; } x[i] = i; } } */ TEST_F(PassClassTest, ReturnInBody) { // clang-format off // With LocalMultiStoreElimPass const std::string text = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 440 OpName %2 "main" OpName %3 "x" %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpConstant %6 0 %9 = OpConstant %6 10 %10 = OpTypeBool %11 = OpConstant %6 5 %12 = OpTypeFloat 32 %13 = OpTypeInt 32 0 %14 = OpConstant %13 10 %15 = OpTypeArray %12 %14 %16 = OpTypePointer Function %15 %17 = OpTypePointer Function %12 %18 = OpConstant %6 1 %2 = OpFunction %4 None %5 %19 = OpLabel %3 = OpVariable %16 Function OpBranch %20 %20 = OpLabel %21 = OpPhi %6 %8 %19 %22 %23 OpLoopMerge %24 %23 Unroll OpBranch %25 %25 = OpLabel %26 = OpSLessThan %10 %21 %9 OpBranchConditional %26 %27 %24 %27 = OpLabel %28 = OpIEqual %10 %21 %11 OpSelectionMerge %29 None OpBranchConditional %28 %30 %29 %30 = OpLabel OpReturn %29 = OpLabel %31 = OpConvertSToF %12 %21 %32 = OpAccessChain %17 %3 %21 OpStore %32 %31 OpBranch %23 %23 = OpLabel %22 = OpIAdd %6 %21 %18 OpBranch %20 %24 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(text, text, false); } TEST_F(PassClassTest, KillInBody) { const std::string text = R"(OpCapability Shader OpMemoryModel Logical Simple OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeBool %5 = OpTypeInt 32 0 %6 = OpConstant %5 0 %7 = OpConstant %5 1 %8 = OpConstant %5 5 %1 = OpFunction %2 None %3 %9 = OpLabel OpBranch %10 %10 = OpLabel %11 = OpPhi %5 %6 %9 %12 %13 %14 = OpULessThan %4 %11 %8 OpLoopMerge %15 %13 Unroll OpBranchConditional %14 %16 %15 %16 = OpLabel OpKill %13 = OpLabel %12 = OpIAdd %5 %11 %7 OpBranch %10 %15 = OpLabel OpReturn OpFunctionEnd )"; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(text, text, false); } TEST_F(PassClassTest, TerminateInvocationInBody) { const std::string text = R"(OpCapability Shader OpExtension "SPV_KHR_terminate_invocation" OpMemoryModel Logical Simple OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeBool %5 = OpTypeInt 32 0 %6 = OpConstant %5 0 %7 = OpConstant %5 1 %8 = OpConstant %5 5 %1 = OpFunction %2 None %3 %9 = OpLabel OpBranch %10 %10 = OpLabel %11 = OpPhi %5 %6 %9 %12 %13 %14 = OpULessThan %4 %11 %8 OpLoopMerge %15 %13 Unroll OpBranchConditional %14 %16 %15 %16 = OpLabel OpTerminateInvocation %13 = OpLabel %12 = OpIAdd %5 %11 %7 OpBranch %10 %15 = OpLabel OpReturn OpFunctionEnd )"; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(text, text, false); } /* Generated from the following GLSL #version 440 core void main() { int j = 0; for (int i = 0; i < 10 && i > 0; i++) { j++; } } */ TEST_F(PassClassTest, MultipleConditionsSingleVariable) { // clang-format off // With LocalMultiStoreElimPass const std::string text = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 440 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpConstant %5 0 %8 = OpConstant %5 10 %9 = OpTypeBool %10 = OpConstant %5 1 %2 = OpFunction %3 None %4 %11 = OpLabel OpBranch %12 %12 = OpLabel %13 = OpPhi %5 %7 %11 %14 %15 %16 = OpPhi %5 %7 %11 %17 %15 OpLoopMerge %18 %15 Unroll OpBranch %19 %19 = OpLabel %20 = OpSLessThan %9 %16 %8 %21 = OpSGreaterThan %9 %16 %7 %22 = OpLogicalAnd %9 %20 %21 OpBranchConditional %22 %23 %18 %23 = OpLabel %14 = OpIAdd %5 %13 %10 OpBranch %15 %15 = OpLabel %17 = OpIAdd %5 %16 %10 OpBranch %12 %18 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; LoopUnroller loop_unroller; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); // Make sure the pass doesn't run SinglePassRunAndCheck(text, text, false); SinglePassRunAndCheck>(text, text, false); SinglePassRunAndCheck>(text, text, false); } /* Generated from the following GLSL #version 440 core void main() { int i = 0; int j = 0; int k = 0; for (; i < 10 && j > 0; i++, j++) { k++; } } */ TEST_F(PassClassTest, MultipleConditionsMultipleVariables) { // clang-format off // With LocalMultiStoreElimPass const std::string text = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 440 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpConstant %5 0 %8 = OpConstant %5 10 %9 = OpTypeBool %10 = OpConstant %5 1 %2 = OpFunction %3 None %4 %11 = OpLabel OpBranch %12 %12 = OpLabel %13 = OpPhi %5 %7 %11 %14 %15 %16 = OpPhi %5 %7 %11 %17 %15 %18 = OpPhi %5 %7 %11 %19 %15 OpLoopMerge %20 %15 Unroll OpBranch %21 %21 = OpLabel %22 = OpSLessThan %9 %13 %8 %23 = OpSGreaterThan %9 %16 %7 %24 = OpLogicalAnd %9 %22 %23 OpBranchConditional %24 %25 %20 %25 = OpLabel %19 = OpIAdd %5 %18 %10 OpBranch %15 %15 = OpLabel %14 = OpIAdd %5 %13 %10 %17 = OpIAdd %5 %16 %10 OpBranch %12 %20 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; LoopUnroller loop_unroller; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); // Make sure the pass doesn't run SinglePassRunAndCheck(text, text, false); SinglePassRunAndCheck>(text, text, false); SinglePassRunAndCheck>(text, text, false); } /* Generated from the following GLSL #version 440 core void main() { float i = 0.0; int j = 0; for (; i < 10; i++) { j++; } } */ TEST_F(PassClassTest, FloatingPointLoop) { // clang-format off // With LocalMultiStoreElimPass const std::string text = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 440 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %6 = OpTypePointer Function %5 %7 = OpConstant %5 0 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %10 = OpConstant %8 0 %11 = OpConstant %5 10 %12 = OpTypeBool %13 = OpConstant %8 1 %14 = OpConstant %5 1 %2 = OpFunction %3 None %4 %15 = OpLabel OpBranch %16 %16 = OpLabel %17 = OpPhi %5 %7 %15 %18 %19 %20 = OpPhi %8 %10 %15 %21 %19 OpLoopMerge %22 %19 Unroll OpBranch %23 %23 = OpLabel %24 = OpFOrdLessThan %12 %17 %11 OpBranchConditional %24 %25 %22 %25 = OpLabel %21 = OpIAdd %8 %20 %13 OpBranch %19 %19 = OpLabel %18 = OpFAdd %5 %17 %14 OpBranch %16 %22 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; LoopUnroller loop_unroller; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); // Make sure the pass doesn't run SinglePassRunAndCheck(text, text, false); SinglePassRunAndCheck>(text, text, false); SinglePassRunAndCheck>(text, text, false); } /* Generated from the following GLSL #version 440 core void main() { int i = 2; int j = 0; if (j == 0) { i = 5; } for (; i < 3; ++i) { j++; } } */ TEST_F(PassClassTest, InductionPhiOutsideLoop) { // clang-format off // With LocalMultiStoreElimPass const std::string text = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 440 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpConstant %5 2 %8 = OpConstant %5 0 %9 = OpTypeBool %10 = OpConstant %5 5 %11 = OpConstant %5 3 %12 = OpConstant %5 1 %2 = OpFunction %3 None %4 %13 = OpLabel %14 = OpIEqual %9 %8 %8 OpSelectionMerge %15 None OpBranchConditional %14 %16 %15 %16 = OpLabel OpBranch %15 %15 = OpLabel %17 = OpPhi %5 %7 %13 %10 %16 OpBranch %18 %18 = OpLabel %19 = OpPhi %5 %17 %15 %20 %21 %22 = OpPhi %5 %8 %15 %23 %21 OpLoopMerge %24 %21 Unroll OpBranch %25 %25 = OpLabel %26 = OpSLessThan %9 %19 %11 OpBranchConditional %26 %27 %24 %27 = OpLabel %23 = OpIAdd %5 %22 %12 OpBranch %21 %21 = OpLabel %20 = OpIAdd %5 %19 %12 OpBranch %18 %24 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; LoopUnroller loop_unroller; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); // Make sure the pass doesn't run SinglePassRunAndCheck(text, text, false); SinglePassRunAndCheck>(text, text, false); SinglePassRunAndCheck>(text, text, false); } /* Generated from the following GLSL #version 440 core void main() { int j = 0; for (int i = 0; i == 0; ++i) { ++j; } for (int i = 0; i != 3; ++i) { ++j; } for (int i = 0; i < 3; i *= 2) { ++j; } for (int i = 10; i > 3; i /= 2) { ++j; } for (int i = 10; i > 3; i |= 2) { ++j; } for (int i = 10; i > 3; i &= 2) { ++j; } for (int i = 10; i > 3; i ^= 2) { ++j; } for (int i = 0; i < 3; i << 2) { ++j; } for (int i = 10; i > 3; i >> 2) { ++j; } } */ TEST_F(PassClassTest, UnsupportedLoopTypes) { // clang-format off // With LocalMultiStoreElimPass const std::string text = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 440 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpConstant %5 0 %8 = OpTypeBool %9 = OpConstant %5 1 %10 = OpConstant %5 3 %11 = OpConstant %5 2 %12 = OpConstant %5 10 %2 = OpFunction %3 None %4 %13 = OpLabel OpBranch %14 %14 = OpLabel %15 = OpPhi %5 %7 %13 %16 %17 %18 = OpPhi %5 %7 %13 %19 %17 OpLoopMerge %20 %17 Unroll OpBranch %21 %21 = OpLabel %22 = OpIEqual %8 %18 %7 OpBranchConditional %22 %23 %20 %23 = OpLabel %16 = OpIAdd %5 %15 %9 OpBranch %17 %17 = OpLabel %19 = OpIAdd %5 %18 %9 OpBranch %14 %20 = OpLabel OpBranch %24 %24 = OpLabel %25 = OpPhi %5 %15 %20 %26 %27 %28 = OpPhi %5 %7 %20 %29 %27 OpLoopMerge %30 %27 Unroll OpBranch %31 %31 = OpLabel %32 = OpINotEqual %8 %28 %10 OpBranchConditional %32 %33 %30 %33 = OpLabel %26 = OpIAdd %5 %25 %9 OpBranch %27 %27 = OpLabel %29 = OpIAdd %5 %28 %9 OpBranch %24 %30 = OpLabel OpBranch %34 %34 = OpLabel %35 = OpPhi %5 %25 %30 %36 %37 %38 = OpPhi %5 %7 %30 %39 %37 OpLoopMerge %40 %37 Unroll OpBranch %41 %41 = OpLabel %42 = OpSLessThan %8 %38 %10 OpBranchConditional %42 %43 %40 %43 = OpLabel %36 = OpIAdd %5 %35 %9 OpBranch %37 %37 = OpLabel %39 = OpIMul %5 %38 %11 OpBranch %34 %40 = OpLabel OpBranch %44 %44 = OpLabel %45 = OpPhi %5 %35 %40 %46 %47 %48 = OpPhi %5 %12 %40 %49 %47 OpLoopMerge %50 %47 Unroll OpBranch %51 %51 = OpLabel %52 = OpSGreaterThan %8 %48 %10 OpBranchConditional %52 %53 %50 %53 = OpLabel %46 = OpIAdd %5 %45 %9 OpBranch %47 %47 = OpLabel %49 = OpSDiv %5 %48 %11 OpBranch %44 %50 = OpLabel OpBranch %54 %54 = OpLabel %55 = OpPhi %5 %45 %50 %56 %57 %58 = OpPhi %5 %12 %50 %59 %57 OpLoopMerge %60 %57 Unroll OpBranch %61 %61 = OpLabel %62 = OpSGreaterThan %8 %58 %10 OpBranchConditional %62 %63 %60 %63 = OpLabel %56 = OpIAdd %5 %55 %9 OpBranch %57 %57 = OpLabel %59 = OpBitwiseOr %5 %58 %11 OpBranch %54 %60 = OpLabel OpBranch %64 %64 = OpLabel %65 = OpPhi %5 %55 %60 %66 %67 %68 = OpPhi %5 %12 %60 %69 %67 OpLoopMerge %70 %67 Unroll OpBranch %71 %71 = OpLabel %72 = OpSGreaterThan %8 %68 %10 OpBranchConditional %72 %73 %70 %73 = OpLabel %66 = OpIAdd %5 %65 %9 OpBranch %67 %67 = OpLabel %69 = OpBitwiseAnd %5 %68 %11 OpBranch %64 %70 = OpLabel OpBranch %74 %74 = OpLabel %75 = OpPhi %5 %65 %70 %76 %77 %78 = OpPhi %5 %12 %70 %79 %77 OpLoopMerge %80 %77 Unroll OpBranch %81 %81 = OpLabel %82 = OpSGreaterThan %8 %78 %10 OpBranchConditional %82 %83 %80 %83 = OpLabel %76 = OpIAdd %5 %75 %9 OpBranch %77 %77 = OpLabel %79 = OpBitwiseXor %5 %78 %11 OpBranch %74 %80 = OpLabel OpBranch %84 %84 = OpLabel %85 = OpPhi %5 %75 %80 %86 %87 OpLoopMerge %88 %87 Unroll OpBranch %89 %89 = OpLabel %90 = OpSLessThan %8 %7 %10 OpBranchConditional %90 %91 %88 %91 = OpLabel %86 = OpIAdd %5 %85 %9 OpBranch %87 %87 = OpLabel %92 = OpShiftLeftLogical %5 %7 %11 OpBranch %84 %88 = OpLabel OpBranch %93 %93 = OpLabel %94 = OpPhi %5 %85 %88 %95 %96 OpLoopMerge %97 %96 Unroll OpBranch %98 %98 = OpLabel %99 = OpSGreaterThan %8 %12 %10 OpBranchConditional %99 %100 %97 %100 = OpLabel %95 = OpIAdd %5 %94 %9 OpBranch %96 %96 = OpLabel %101 = OpShiftRightArithmetic %5 %12 %11 OpBranch %93 %97 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; LoopUnroller loop_unroller; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); // Make sure the pass doesn't run SinglePassRunAndCheck(text, text, false); SinglePassRunAndCheck>(text, text, false); SinglePassRunAndCheck>(text, text, false); } /* #version 430 layout(location = 0) out float o; void main(void) { for (int j = 2; j < 0; j += 1) { o += 1.0; } } */ TEST_F(PassClassTest, NegativeNumberOfIterations) { // clang-format off // With LocalMultiStoreElimPass const std::string text = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "o" OpDecorate %3 Location 0 %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpConstant %6 2 %9 = OpConstant %6 0 %10 = OpTypeBool %11 = OpTypeFloat 32 %12 = OpTypePointer Output %11 %3 = OpVariable %12 Output %13 = OpConstant %11 1 %14 = OpConstant %6 1 %2 = OpFunction %4 None %5 %15 = OpLabel OpBranch %16 %16 = OpLabel %17 = OpPhi %6 %8 %15 %18 %19 OpLoopMerge %20 %19 None OpBranch %21 %21 = OpLabel %22 = OpSLessThan %10 %17 %9 OpBranchConditional %22 %23 %20 %23 = OpLabel %24 = OpLoad %11 %3 %25 = OpFAdd %11 %24 %13 OpStore %3 %25 OpBranch %19 %19 = OpLabel %18 = OpIAdd %6 %17 %14 OpBranch %16 %20 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; LoopUnroller loop_unroller; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); // Make sure the pass doesn't run SinglePassRunAndCheck(text, text, false); SinglePassRunAndCheck>(text, text, false); SinglePassRunAndCheck>(text, text, false); } /* #version 430 layout(location = 0) out float o; void main(void) { float s = 0.0; for (int j = 0; j < 3; j += 1) { s += 1.0; j += 1; } o = s; } */ TEST_F(PassClassTest, MultipleStepOperations) { // clang-format off // With LocalMultiStoreElimPass const std::string text = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "o" OpDecorate %3 Location 0 %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %8 = OpConstant %6 0 %9 = OpTypeInt 32 1 %10 = OpTypePointer Function %9 %11 = OpConstant %9 0 %12 = OpConstant %9 3 %13 = OpTypeBool %14 = OpConstant %6 1 %15 = OpConstant %9 1 %16 = OpTypePointer Output %6 %3 = OpVariable %16 Output %2 = OpFunction %4 None %5 %17 = OpLabel OpBranch %18 %18 = OpLabel %19 = OpPhi %6 %8 %17 %20 %21 %22 = OpPhi %9 %11 %17 %23 %21 OpLoopMerge %24 %21 Unroll OpBranch %25 %25 = OpLabel %26 = OpSLessThan %13 %22 %12 OpBranchConditional %26 %27 %24 %27 = OpLabel %20 = OpFAdd %6 %19 %14 %28 = OpIAdd %9 %22 %15 OpBranch %21 %21 = OpLabel %23 = OpIAdd %9 %28 %15 OpBranch %18 %24 = OpLabel OpStore %3 %19 OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; LoopUnroller loop_unroller; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); // Make sure the pass doesn't run SinglePassRunAndCheck(text, text, false); SinglePassRunAndCheck>(text, text, false); SinglePassRunAndCheck>(text, text, false); } /* #version 430 layout(location = 0) out float o; void main(void) { float s = 0.0; for (int j = 10; j > 20; j -= 1) { s += 1.0; } o = s; } */ TEST_F(PassClassTest, ConditionFalseFromStartGreaterThan) { // clang-format off // With LocalMultiStoreElimPass const std::string text = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "o" OpDecorate %3 Location 0 %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %8 = OpConstant %6 0 %9 = OpTypeInt 32 1 %10 = OpTypePointer Function %9 %11 = OpConstant %9 10 %12 = OpConstant %9 20 %13 = OpTypeBool %14 = OpConstant %6 1 %15 = OpConstant %9 1 %16 = OpTypePointer Output %6 %3 = OpVariable %16 Output %2 = OpFunction %4 None %5 %17 = OpLabel OpBranch %18 %18 = OpLabel %19 = OpPhi %6 %8 %17 %20 %21 %22 = OpPhi %9 %11 %17 %23 %21 OpLoopMerge %24 %21 Unroll OpBranch %25 %25 = OpLabel %26 = OpSGreaterThan %13 %22 %12 OpBranchConditional %26 %27 %24 %27 = OpLabel %20 = OpFAdd %6 %19 %14 OpBranch %21 %21 = OpLabel %23 = OpISub %9 %22 %15 OpBranch %18 %24 = OpLabel OpStore %3 %19 OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; LoopUnroller loop_unroller; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); // Make sure the pass doesn't run SinglePassRunAndCheck(text, text, false); SinglePassRunAndCheck>(text, text, false); SinglePassRunAndCheck>(text, text, false); } /* #version 430 layout(location = 0) out float o; void main(void) { float s = 0.0; for (int j = 10; j >= 20; j -= 1) { s += 1.0; } o = s; } */ TEST_F(PassClassTest, ConditionFalseFromStartGreaterThanOrEqual) { // clang-format off // With LocalMultiStoreElimPass const std::string text = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "o" OpDecorate %3 Location 0 %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %8 = OpConstant %6 0 %9 = OpTypeInt 32 1 %10 = OpTypePointer Function %9 %11 = OpConstant %9 10 %12 = OpConstant %9 20 %13 = OpTypeBool %14 = OpConstant %6 1 %15 = OpConstant %9 1 %16 = OpTypePointer Output %6 %3 = OpVariable %16 Output %2 = OpFunction %4 None %5 %17 = OpLabel OpBranch %18 %18 = OpLabel %19 = OpPhi %6 %8 %17 %20 %21 %22 = OpPhi %9 %11 %17 %23 %21 OpLoopMerge %24 %21 Unroll OpBranch %25 %25 = OpLabel %26 = OpSGreaterThanEqual %13 %22 %12 OpBranchConditional %26 %27 %24 %27 = OpLabel %20 = OpFAdd %6 %19 %14 OpBranch %21 %21 = OpLabel %23 = OpISub %9 %22 %15 OpBranch %18 %24 = OpLabel OpStore %3 %19 OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; LoopUnroller loop_unroller; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); // Make sure the pass doesn't run SinglePassRunAndCheck(text, text, false); SinglePassRunAndCheck>(text, text, false); SinglePassRunAndCheck>(text, text, false); } /* #version 430 layout(location = 0) out float o; void main(void) { float s = 0.0; for (int j = 20; j < 10; j -= 1) { s += 1.0; } o = s; } */ TEST_F(PassClassTest, ConditionFalseFromStartLessThan) { // clang-format off // With LocalMultiStoreElimPass const std::string text = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "o" OpDecorate %3 Location 0 %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %8 = OpConstant %6 0 %9 = OpTypeInt 32 1 %10 = OpTypePointer Function %9 %11 = OpConstant %9 20 %12 = OpConstant %9 10 %13 = OpTypeBool %14 = OpConstant %6 1 %15 = OpConstant %9 1 %16 = OpTypePointer Output %6 %3 = OpVariable %16 Output %2 = OpFunction %4 None %5 %17 = OpLabel OpBranch %18 %18 = OpLabel %19 = OpPhi %6 %8 %17 %20 %21 %22 = OpPhi %9 %11 %17 %23 %21 OpLoopMerge %24 %21 Unroll OpBranch %25 %25 = OpLabel %26 = OpSLessThan %13 %22 %12 OpBranchConditional %26 %27 %24 %27 = OpLabel %20 = OpFAdd %6 %19 %14 OpBranch %21 %21 = OpLabel %23 = OpISub %9 %22 %15 OpBranch %18 %24 = OpLabel OpStore %3 %19 OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; LoopUnroller loop_unroller; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); // Make sure the pass doesn't run SinglePassRunAndCheck(text, text, false); SinglePassRunAndCheck>(text, text, false); SinglePassRunAndCheck>(text, text, false); } /* #version 430 layout(location = 0) out float o; void main(void) { float s = 0.0; for (int j = 20; j <= 10; j -= 1) { s += 1.0; } o = s; } */ TEST_F(PassClassTest, ConditionFalseFromStartLessThanEqual) { // clang-format off // With LocalMultiStoreElimPass const std::string text = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "o" OpDecorate %3 Location 0 %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %8 = OpConstant %6 0 %9 = OpTypeInt 32 1 %10 = OpTypePointer Function %9 %11 = OpConstant %9 20 %12 = OpConstant %9 10 %13 = OpTypeBool %14 = OpConstant %6 1 %15 = OpConstant %9 1 %16 = OpTypePointer Output %6 %3 = OpVariable %16 Output %2 = OpFunction %4 None %5 %17 = OpLabel OpBranch %18 %18 = OpLabel %19 = OpPhi %6 %8 %17 %20 %21 %22 = OpPhi %9 %11 %17 %23 %21 OpLoopMerge %24 %21 Unroll OpBranch %25 %25 = OpLabel %26 = OpSLessThanEqual %13 %22 %12 OpBranchConditional %26 %27 %24 %27 = OpLabel %20 = OpFAdd %6 %19 %14 OpBranch %21 %21 = OpLabel %23 = OpISub %9 %22 %15 OpBranch %18 %24 = OpLabel OpStore %3 %19 OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; LoopUnroller loop_unroller; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); // Make sure the pass doesn't run SinglePassRunAndCheck(text, text, false); SinglePassRunAndCheck>(text, text, false); SinglePassRunAndCheck>(text, text, false); } TEST_F(PassClassTest, FunctionDeclaration) { // Make sure the pass works with a function declaration that is called. const std::string text = R"(OpCapability Addresses OpCapability Linkage OpCapability Kernel OpCapability Int8 %1 = OpExtInstImport "OpenCL.std" OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %2 "_Z23julia__1166_kernel_77094Bool" OpExecutionMode %2 ContractionOff OpSource Unknown 0 OpDecorate %3 LinkageAttributes "julia_error_7712" Import %void = OpTypeVoid %5 = OpTypeFunction %void %3 = OpFunction %void None %5 OpFunctionEnd %2 = OpFunction %void None %5 %6 = OpLabel %7 = OpFunctionCall %void %3 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(text, text, false); SinglePassRunAndCheck>(text, text, false); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/loop_optimizations/unroll_simple.cpp000066400000000000000000003155611475742701700276570ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gmock/gmock.h" #include "source/opt/loop_unroller.h" #include "source/opt/loop_utils.h" #include "source/opt/pass.h" #include "test/opt/assembly_builder.h" #include "test/opt/function_utils.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using ::testing::UnorderedElementsAre; using PassClassTest = PassTest<::testing::Test>; /* Generated from the following GLSL #version 330 core layout(location = 0) out vec4 c; void main() { float x[4]; for (int i = 0; i < 4; ++i) { x[i] = 1.0f; } } */ TEST_F(PassClassTest, SimpleFullyUnrollTest) { // With LocalMultiStoreElimPass const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 330 OpName %2 "main" OpName %5 "x" OpName %3 "c" OpDecorate %3 Location 0 %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %10 = OpConstant %8 0 %11 = OpConstant %8 4 %12 = OpTypeBool %13 = OpTypeFloat 32 %14 = OpTypeInt 32 0 %15 = OpConstant %14 4 %16 = OpTypeArray %13 %15 %17 = OpTypePointer Function %16 %18 = OpConstant %13 1 %19 = OpTypePointer Function %13 %20 = OpConstant %8 1 %21 = OpTypeVector %13 4 %22 = OpTypePointer Output %21 %3 = OpVariable %22 Output %2 = OpFunction %6 None %7 %23 = OpLabel %5 = OpVariable %17 Function OpBranch %24 %24 = OpLabel %35 = OpPhi %8 %10 %23 %34 %26 OpLoopMerge %25 %26 Unroll OpBranch %27 %27 = OpLabel %29 = OpSLessThan %12 %35 %11 OpBranchConditional %29 %30 %25 %30 = OpLabel %32 = OpAccessChain %19 %5 %35 OpStore %32 %18 OpBranch %26 %26 = OpLabel %34 = OpIAdd %8 %35 %20 OpBranch %24 %25 = OpLabel OpReturn OpFunctionEnd )"; const std::string output = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 330 OpName %2 "main" OpName %4 "x" OpName %3 "c" OpDecorate %3 Location 0 %5 = OpTypeVoid %6 = OpTypeFunction %5 %7 = OpTypeInt 32 1 %8 = OpTypePointer Function %7 %9 = OpConstant %7 0 %10 = OpConstant %7 4 %11 = OpTypeBool %12 = OpTypeFloat 32 %13 = OpTypeInt 32 0 %14 = OpConstant %13 4 %15 = OpTypeArray %12 %14 %16 = OpTypePointer Function %15 %17 = OpConstant %12 1 %18 = OpTypePointer Function %12 %19 = OpConstant %7 1 %20 = OpTypeVector %12 4 %21 = OpTypePointer Output %20 %3 = OpVariable %21 Output %2 = OpFunction %5 None %6 %22 = OpLabel %4 = OpVariable %16 Function OpBranch %23 %23 = OpLabel OpBranch %28 %28 = OpLabel %29 = OpSLessThan %11 %9 %10 OpBranch %30 %30 = OpLabel %31 = OpAccessChain %18 %4 %9 OpStore %31 %17 OpBranch %26 %26 = OpLabel %25 = OpIAdd %7 %9 %19 OpBranch %32 %32 = OpLabel OpBranch %34 %34 = OpLabel %35 = OpSLessThan %11 %25 %10 OpBranch %36 %36 = OpLabel %37 = OpAccessChain %18 %4 %25 OpStore %37 %17 OpBranch %38 %38 = OpLabel %39 = OpIAdd %7 %25 %19 OpBranch %40 %40 = OpLabel OpBranch %42 %42 = OpLabel %43 = OpSLessThan %11 %39 %10 OpBranch %44 %44 = OpLabel %45 = OpAccessChain %18 %4 %39 OpStore %45 %17 OpBranch %46 %46 = OpLabel %47 = OpIAdd %7 %39 %19 OpBranch %48 %48 = OpLabel OpBranch %50 %50 = OpLabel %51 = OpSLessThan %11 %47 %10 OpBranch %52 %52 = OpLabel %53 = OpAccessChain %18 %4 %47 OpStore %53 %17 OpBranch %54 %54 = OpLabel %55 = OpIAdd %7 %47 %19 OpBranch %27 %27 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for ushader:\n" << text << std::endl; LoopUnroller loop_unroller; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(text, output, false); } /* Generated from the following GLSL #version 330 core layout(location = 0) out vec4 c; void main() { float x[4]; for (int i = 0; i < 4; ++i) { x[i] = 1.0f; } } */ TEST_F(PassClassTest, SimpleFullyUnrollWithDebugInstructions) { // We must preserve the debug information including OpenCL.DebugInfo.100 // instructions and OpLine instructions. Only the first block has // DebugDeclare and DebugValue used for the declaration (i.e., DebugValue // with Deref). Other blocks unrolled from the loop must not contain them. const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" %ext = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 330 %file_name = OpString "test" %float_name = OpString "float" %main_name = OpString "main" %f_name = OpString "f" %i_name = OpString "i" OpName %2 "main" OpName %5 "x" OpName %3 "c" OpDecorate %3 Location 0 %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %10 = OpConstant %8 0 %11 = OpConstant %8 4 %12 = OpTypeBool %13 = OpTypeFloat 32 %14 = OpTypeInt 32 0 %uint_32 = OpConstant %14 32 %15 = OpConstant %14 4 %16 = OpTypeArray %13 %15 %17 = OpTypePointer Function %16 %18 = OpConstant %13 1 %19 = OpTypePointer Function %13 %20 = OpConstant %8 1 %21 = OpTypeVector %13 4 %22 = OpTypePointer Output %21 %3 = OpVariable %22 Output %null_expr = OpExtInst %6 %ext DebugExpression %deref = OpExtInst %6 %ext DebugOperation Deref %deref_expr = OpExtInst %6 %ext DebugExpression %deref %src = OpExtInst %6 %ext DebugSource %file_name %cu = OpExtInst %6 %ext DebugCompilationUnit 1 4 %src HLSL %dbg_tf = OpExtInst %6 %ext DebugTypeBasic %float_name %uint_32 Float %dbg_v4f = OpExtInst %6 %ext DebugTypeVector %dbg_tf 4 %main_ty = OpExtInst %6 %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %dbg_v4f %dbg_v4f %dbg_main = OpExtInst %6 %ext DebugFunction %main_name %main_ty %src 0 0 %cu %main_name FlagIsProtected|FlagIsPrivate 10 %2 %bb = OpExtInst %6 %ext DebugLexicalBlock %src 0 0 %dbg_main %dbg_f = OpExtInst %6 %ext DebugLocalVariable %f_name %dbg_v4f %src 0 0 %dbg_main FlagIsLocal %dbg_i = OpExtInst %6 %ext DebugLocalVariable %i_name %dbg_v4f %src 1 0 %bb FlagIsLocal ; CHECK: [[f:%\w+]] = OpString "f" ; CHECK: [[i:%\w+]] = OpString "i" ; CHECK: [[int_0:%\w+]] = OpConstant {{%\w+}} 0 ; CHECK: [[null_expr:%\w+]] = OpExtInst {{%\w+}} {{%\w+}} DebugExpression ; CHECK: [[deref:%\w+]] = OpExtInst {{%\w+}} {{%\w+}} DebugOperation Deref ; CHECK: [[deref_expr:%\w+]] = OpExtInst {{%\w+}} {{%\w+}} DebugExpression [[deref]] ; CHECK: [[dbg_fn:%\w+]] = OpExtInst {{%\w+}} {{%\w+}} DebugFunction ; CHECK: [[dbg_bb:%\w+]] = OpExtInst {{%\w+}} {{%\w+}} DebugLexicalBlock ; CHECK: [[dbg_f:%\w+]] = OpExtInst {{%\w+}} {{%\w+}} DebugLocalVariable [[f]] {{%\w+}} {{%\w+}} 0 0 [[dbg_fn]] ; CHECK: [[dbg_i:%\w+]] = OpExtInst {{%\w+}} {{%\w+}} DebugLocalVariable [[i]] {{%\w+}} {{%\w+}} 1 0 [[dbg_bb]] %2 = OpFunction %6 None %7 %23 = OpLabel ; The first block has DebugDeclare and DebugValue with Deref ; ; CHECK: OpLabel ; CHECK: DebugScope [[dbg_fn]] ; CHECK: [[x:%\w+]] = OpVariable {{%\w+}} Function ; CHECK: OpLine {{%\w+}} 0 0 ; CHECK: OpBranch ; CHECK: OpLabel ; CHECK: DebugScope [[dbg_fn]] ; CHECK: DebugValue [[dbg_f]] [[int_0]] [[null_expr]] ; CHECK: OpBranch ; CHECK: DebugScope [[dbg_fn]] ; CHECK: OpLine {{%\w+}} 1 1 ; CHECK: OpSLessThan ; CHECK: OpLine {{%\w+}} 2 0 ; CHECK: OpBranch ; CHECK: OpLabel ; CHECK: DebugScope [[dbg_bb]] ; CHECK: DebugDeclare [[dbg_f]] [[x]] [[null_expr]] ; CHECK: DebugValue [[dbg_i]] [[x]] [[deref_expr]] ; CHECK: OpLine {{%\w+}} 3 0 ; ; CHECK: OpLine {{%\w+}} 6 0 ; CHECK: [[add:%\w+]] = OpIAdd ; CHECK: DebugValue [[dbg_f]] [[add]] [[null_expr]] ; CHECK: OpLine {{%\w+}} 7 0 ; Other blocks do not have DebugDeclare and DebugValue with Deref ; ; CHECK: DebugScope [[dbg_fn]] ; CHECK: OpLine {{%\w+}} 1 1 ; CHECK: OpSLessThan ; CHECK: OpLine {{%\w+}} 2 0 ; CHECK: OpBranch ; CHECK: OpLabel ; ; CHECK: DebugScope [[dbg_bb]] ; CHECK-NOT: DebugDeclare [[dbg_f]] [[x]] [[null_expr]] ; CHECK-NOT: DebugValue [[dbg_i]] [[x]] [[deref_expr]] ; CHECK: OpLine {{%\w+}} 3 0 ; ; CHECK: OpLine {{%\w+}} 6 0 ; CHECK: [[add:%\w+]] = OpIAdd ; CHECK: DebugValue [[dbg_f]] [[add]] [[null_expr]] ; CHECK: OpLine {{%\w+}} 7 0 ; ; CHECK-NOT: DebugDeclare [[dbg_f]] [[x]] [[null_expr]] ; CHECK-NOT: DebugValue [[dbg_i]] [[x]] [[deref_expr]] ; CHECK: DebugScope [[dbg_fn]] ; CHECK: OpLine {{%\w+}} 8 0 ; CHECK: OpReturn %s0 = OpExtInst %6 %ext DebugScope %dbg_main %5 = OpVariable %17 Function OpLine %file_name 0 0 OpBranch %24 %24 = OpLabel %s1 = OpExtInst %6 %ext DebugScope %dbg_main %35 = OpPhi %8 %10 %23 %34 %26 %value0 = OpExtInst %6 %ext DebugValue %dbg_f %35 %null_expr OpLine %file_name 1 0 OpLoopMerge %25 %26 Unroll OpBranch %27 %27 = OpLabel %s2 = OpExtInst %6 %ext DebugScope %dbg_main OpLine %file_name 1 1 %29 = OpSLessThan %12 %35 %11 OpLine %file_name 2 0 OpBranchConditional %29 %30 %25 %30 = OpLabel %s3 = OpExtInst %6 %ext DebugScope %bb %decl0 = OpExtInst %6 %ext DebugDeclare %dbg_f %5 %null_expr %decl1 = OpExtInst %6 %ext DebugValue %dbg_i %5 %deref_expr OpLine %file_name 3 0 %32 = OpAccessChain %19 %5 %35 OpLine %file_name 4 0 OpStore %32 %18 OpLine %file_name 5 0 OpBranch %26 %26 = OpLabel %s4 = OpExtInst %6 %ext DebugScope %dbg_main OpLine %file_name 6 0 %34 = OpIAdd %8 %35 %20 %value1 = OpExtInst %6 %ext DebugValue %dbg_f %34 %null_expr OpLine %file_name 7 0 OpBranch %24 %25 = OpLabel %s5 = OpExtInst %6 %ext DebugScope %dbg_main OpLine %file_name 8 0 OpReturn OpFunctionEnd)"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for ushader:\n" << text << std::endl; LoopUnroller loop_unroller; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndMatch(text, true); } TEST_F(PassClassTest, SimpleFullyUnrollWithShaderDebugInstructions) { // We must preserve the debug information including // NonSemantic.Shader.DebugInfo.100 instructions and DebugLine instructions. const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %1 = OpExtInstImport "GLSL.std.450" %ext = OpExtInstImport "NonSemantic.Shader.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 330 %file_name = OpString "test" %float_name = OpString "float" %main_name = OpString "main" %f_name = OpString "f" %i_name = OpString "i" OpName %2 "main" OpName %5 "x" OpName %3 "c" OpDecorate %3 Location 0 %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %10 = OpConstant %8 0 %11 = OpConstant %8 4 %12 = OpTypeBool %13 = OpTypeFloat 32 %14 = OpTypeInt 32 0 %uint_0 = OpConstant %14 0 %uint_1 = OpConstant %14 1 %uint_2 = OpConstant %14 2 %uint_3 = OpConstant %14 3 %uint_4 = OpConstant %14 4 %uint_5 = OpConstant %14 5 %uint_6 = OpConstant %14 6 %uint_7 = OpConstant %14 7 %uint_8 = OpConstant %14 8 %uint_10 = OpConstant %14 10 %uint_32 = OpConstant %14 32 %15 = OpConstant %14 4 %16 = OpTypeArray %13 %15 %17 = OpTypePointer Function %16 %18 = OpConstant %13 1 %19 = OpTypePointer Function %13 %20 = OpConstant %8 1 %21 = OpTypeVector %13 4 %22 = OpTypePointer Output %21 %3 = OpVariable %22 Output %null_expr = OpExtInst %6 %ext DebugExpression %deref = OpExtInst %6 %ext DebugOperation %uint_0 %deref_expr = OpExtInst %6 %ext DebugExpression %deref %src = OpExtInst %6 %ext DebugSource %file_name %cu = OpExtInst %6 %ext DebugCompilationUnit %uint_1 %uint_4 %src %uint_5 %dbg_tf = OpExtInst %6 %ext DebugTypeBasic %float_name %uint_32 %uint_3 %uint_0 %dbg_v4f = OpExtInst %6 %ext DebugTypeVector %dbg_tf %uint_4 %main_ty = OpExtInst %6 %ext DebugTypeFunction %uint_3 %dbg_v4f %dbg_v4f %dbg_main = OpExtInst %6 %ext DebugFunction %main_name %main_ty %src %uint_0 %uint_0 %cu %main_name %uint_3 %uint_10 %bb = OpExtInst %6 %ext DebugLexicalBlock %src %uint_0 %uint_0 %dbg_main %dbg_f = OpExtInst %6 %ext DebugLocalVariable %f_name %dbg_v4f %src %uint_0 %uint_0 %dbg_main %uint_4 %dbg_i = OpExtInst %6 %ext DebugLocalVariable %i_name %dbg_v4f %src %uint_1 %uint_0 %bb %uint_4 ; CHECK: [[f:%\w+]] = OpString "f" ; CHECK: [[i:%\w+]] = OpString "i" ; CHECK: [[int_0:%\w+]] = OpConstant {{%\w+}} 0 ; CHECK: [[null_expr:%\w+]] = OpExtInst {{%\w+}} {{%\w+}} DebugExpression ; CHECK: [[deref:%\w+]] = OpExtInst {{%\w+}} {{%\w+}} DebugOperation %uint_0 ; CHECK: [[deref_expr:%\w+]] = OpExtInst {{%\w+}} {{%\w+}} DebugExpression [[deref]] ; CHECK: [[dbg_fn:%\w+]] = OpExtInst {{%\w+}} {{%\w+}} DebugFunction ; CHECK: [[dbg_bb:%\w+]] = OpExtInst {{%\w+}} {{%\w+}} DebugLexicalBlock ; CHECK: [[dbg_f:%\w+]] = OpExtInst {{%\w+}} {{%\w+}} DebugLocalVariable [[f]] {{%\w+}} {{%\w+}} %uint_0 %uint_0 [[dbg_fn]] ; CHECK: [[dbg_i:%\w+]] = OpExtInst {{%\w+}} {{%\w+}} DebugLocalVariable [[i]] {{%\w+}} {{%\w+}} %uint_1 %uint_0 [[dbg_bb]] %2 = OpFunction %6 None %7 %23 = OpLabel ; The first block has DebugDeclare and DebugValue with Deref ; ; CHECK: OpLabel ; CHECK: %x = OpVariable %_ptr_Function__arr_float_uint_4_0 Function ; CHECK: OpBranch ; CHECK: OpLabel ; CHECK: DebugScope [[dbg_fn]] ; CHECK: DebugValue [[dbg_f]] [[int_0]] [[null_expr]] ; CHECK: OpBranch ; CHECK: DebugScope [[dbg_fn]] ; CHECK: DebugLine {{%\w+}} %uint_1 %uint_1 %uint_1 %uint_1 ; CHECK: OpSLessThan ; CHECK: DebugLine {{%\w+}} %uint_2 %uint_2 %uint_0 %uint_0 ; CHECK: OpBranch ; CHECK: OpLabel ; CHECK: DebugScope [[dbg_bb]] ; CHECK: DebugDeclare [[dbg_f]] %x [[null_expr]] ; CHECK: DebugValue [[dbg_i]] %x [[deref_expr]] ; CHECK: DebugLine {{%\w+}} %uint_3 %uint_3 %uint_0 %uint_0 ; ; CHECK: DebugLine {{%\w+}} %uint_6 %uint_6 %uint_0 %uint_0 ; CHECK: [[add:%\w+]] = OpIAdd ; CHECK: DebugValue [[dbg_f]] [[add]] [[null_expr]] ; CHECK: DebugLine {{%\w+}} %uint_7 %uint_7 %uint_0 %uint_0 ; Other blocks do not have DebugDeclare and DebugValue with Deref ; ; CHECK: DebugScope [[dbg_fn]] ; CHECK: DebugLine {{%\w+}} %uint_1 %uint_1 %uint_1 %uint_1 ; CHECK: OpSLessThan ; CHECK: DebugLine {{%\w+}} %uint_2 %uint_2 %uint_0 %uint_0 ; CHECK: OpBranch ; CHECK: OpLabel ; ; CHECK: DebugScope [[dbg_bb]] ; CHECK-NOT: DebugDeclare [[dbg_f]] %x [[null_expr]] ; CHECK-NOT: DebugValue [[dbg_i]] %x [[deref_expr]] ; CHECK: DebugLine {{%\w+}} %uint_3 %uint_3 %uint_0 %uint_0 ; ; CHECK: DebugLine {{%\w+}} %uint_6 %uint_6 %uint_0 %uint_0 ; CHECK: [[add:%\w+]] = OpIAdd ; CHECK: DebugValue [[dbg_f]] [[add]] [[null_expr]] ; CHECK: DebugLine {{%\w+}} %uint_7 %uint_7 %uint_0 %uint_0 ; ; CHECK-NOT: DebugDeclare [[dbg_f]] %x [[null_expr]] ; CHECK-NOT: DebugValue [[dbg_i]] %x [[deref_expr]] ; CHECK: DebugScope [[dbg_fn]] ; CHECK: DebugLine {{%\w+}} %uint_8 %uint_8 %uint_0 %uint_0 ; CHECK: OpReturn %5 = OpVariable %17 Function OpBranch %24 %24 = OpLabel %35 = OpPhi %8 %10 %23 %34 %26 %s1 = OpExtInst %6 %ext DebugScope %dbg_main %d10 = OpExtInst %6 %ext DebugLine %src %uint_1 %uint_1 %uint_0 %uint_0 %value0 = OpExtInst %6 %ext DebugValue %dbg_f %35 %null_expr OpLoopMerge %25 %26 Unroll OpBranch %27 %27 = OpLabel %s2 = OpExtInst %6 %ext DebugScope %dbg_main %d1 = OpExtInst %6 %ext DebugLine %src %uint_1 %uint_1 %uint_1 %uint_1 %29 = OpSLessThan %12 %35 %11 %d2 = OpExtInst %6 %ext DebugLine %src %uint_2 %uint_2 %uint_0 %uint_0 OpBranchConditional %29 %30 %25 %30 = OpLabel %s3 = OpExtInst %6 %ext DebugScope %bb %decl0 = OpExtInst %6 %ext DebugDeclare %dbg_f %5 %null_expr %decl1 = OpExtInst %6 %ext DebugValue %dbg_i %5 %deref_expr %d3 = OpExtInst %6 %ext DebugLine %src %uint_3 %uint_3 %uint_0 %uint_0 %32 = OpAccessChain %19 %5 %35 %d4 = OpExtInst %6 %ext DebugLine %src %uint_4 %uint_4 %uint_0 %uint_0 OpStore %32 %18 %d5 = OpExtInst %6 %ext DebugLine %src %uint_5 %uint_5 %uint_0 %uint_0 OpBranch %26 %26 = OpLabel %s4 = OpExtInst %6 %ext DebugScope %dbg_main %d6 = OpExtInst %6 %ext DebugLine %src %uint_6 %uint_6 %uint_0 %uint_0 %34 = OpIAdd %8 %35 %20 %value1 = OpExtInst %6 %ext DebugValue %dbg_f %34 %null_expr %d7 = OpExtInst %6 %ext DebugLine %src %uint_7 %uint_7 %uint_0 %uint_0 OpBranch %24 %25 = OpLabel %s5 = OpExtInst %6 %ext DebugScope %dbg_main %d8 = OpExtInst %6 %ext DebugLine %src %uint_8 %uint_8 %uint_0 %uint_0 OpReturn OpFunctionEnd)"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for ushader:\n" << text << std::endl; LoopUnroller loop_unroller; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); SinglePassRunAndMatch(text, true); } template class PartialUnrollerTestPass : public Pass { public: PartialUnrollerTestPass() : Pass() {} const char* name() const override { return "Loop unroller"; } Status Process() override { for (Function& f : *context()->module()) { LoopDescriptor& loop_descriptor = *context()->GetLoopDescriptor(&f); for (auto& loop : loop_descriptor) { LoopUtils loop_utils{context(), &loop}; loop_utils.PartiallyUnroll(factor); } } return Pass::Status::SuccessWithChange; } }; /* Generated from the following GLSL #version 330 core layout(location = 0) out vec4 c; void main() { float x[10]; for (int i = 0; i < 10; ++i) { x[i] = 1.0f; } } */ TEST_F(PassClassTest, SimplePartialUnroll) { // With LocalMultiStoreElimPass const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 330 OpName %2 "main" OpName %5 "x" OpName %3 "c" OpDecorate %3 Location 0 %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %10 = OpConstant %8 0 %11 = OpConstant %8 10 %12 = OpTypeBool %13 = OpTypeFloat 32 %14 = OpTypeInt 32 0 %15 = OpConstant %14 10 %16 = OpTypeArray %13 %15 %17 = OpTypePointer Function %16 %18 = OpConstant %13 1 %19 = OpTypePointer Function %13 %20 = OpConstant %8 1 %21 = OpTypeVector %13 4 %22 = OpTypePointer Output %21 %3 = OpVariable %22 Output %2 = OpFunction %6 None %7 %23 = OpLabel %5 = OpVariable %17 Function OpBranch %24 %24 = OpLabel %35 = OpPhi %8 %10 %23 %34 %26 OpLoopMerge %25 %26 Unroll OpBranch %27 %27 = OpLabel %29 = OpSLessThan %12 %35 %11 OpBranchConditional %29 %30 %25 %30 = OpLabel %32 = OpAccessChain %19 %5 %35 OpStore %32 %18 OpBranch %26 %26 = OpLabel %34 = OpIAdd %8 %35 %20 OpBranch %24 %25 = OpLabel OpReturn OpFunctionEnd )"; const std::string output = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 330 OpName %2 "main" OpName %4 "x" OpName %3 "c" OpDecorate %3 Location 0 %5 = OpTypeVoid %6 = OpTypeFunction %5 %7 = OpTypeInt 32 1 %8 = OpTypePointer Function %7 %9 = OpConstant %7 0 %10 = OpConstant %7 10 %11 = OpTypeBool %12 = OpTypeFloat 32 %13 = OpTypeInt 32 0 %14 = OpConstant %13 10 %15 = OpTypeArray %12 %14 %16 = OpTypePointer Function %15 %17 = OpConstant %12 1 %18 = OpTypePointer Function %12 %19 = OpConstant %7 1 %20 = OpTypeVector %12 4 %21 = OpTypePointer Output %20 %3 = OpVariable %21 Output %2 = OpFunction %5 None %6 %22 = OpLabel %4 = OpVariable %16 Function OpBranch %23 %23 = OpLabel %24 = OpPhi %7 %9 %22 %39 %38 OpLoopMerge %27 %38 DontUnroll OpBranch %28 %28 = OpLabel %29 = OpSLessThan %11 %24 %10 OpBranchConditional %29 %30 %27 %30 = OpLabel %31 = OpAccessChain %18 %4 %24 OpStore %31 %17 OpBranch %26 %26 = OpLabel %25 = OpIAdd %7 %24 %19 OpBranch %32 %32 = OpLabel OpBranch %34 %34 = OpLabel %35 = OpSLessThan %11 %25 %10 OpBranch %36 %36 = OpLabel %37 = OpAccessChain %18 %4 %25 OpStore %37 %17 OpBranch %38 %38 = OpLabel %39 = OpIAdd %7 %25 %19 OpBranch %23 %27 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for ushader:\n" << text << std::endl; LoopUnroller loop_unroller; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck>(text, output, false); } /* Generated from the following GLSL #version 330 core layout(location = 0) out vec4 c; void main() { float x[10]; for (int i = 0; i < 10; ++i) { x[i] = 1.0f; } } */ TEST_F(PassClassTest, SimpleUnevenPartialUnroll) { // With LocalMultiStoreElimPass const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 330 OpName %2 "main" OpName %5 "x" OpName %3 "c" OpDecorate %3 Location 0 %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %10 = OpConstant %8 0 %11 = OpConstant %8 10 %12 = OpTypeBool %13 = OpTypeFloat 32 %14 = OpTypeInt 32 0 %15 = OpConstant %14 10 %16 = OpTypeArray %13 %15 %17 = OpTypePointer Function %16 %18 = OpConstant %13 1 %19 = OpTypePointer Function %13 %20 = OpConstant %8 1 %21 = OpTypeVector %13 4 %22 = OpTypePointer Output %21 %3 = OpVariable %22 Output %2 = OpFunction %6 None %7 %23 = OpLabel %5 = OpVariable %17 Function OpBranch %24 %24 = OpLabel %35 = OpPhi %8 %10 %23 %34 %26 OpLoopMerge %25 %26 Unroll OpBranch %27 %27 = OpLabel %29 = OpSLessThan %12 %35 %11 OpBranchConditional %29 %30 %25 %30 = OpLabel %32 = OpAccessChain %19 %5 %35 OpStore %32 %18 OpBranch %26 %26 = OpLabel %34 = OpIAdd %8 %35 %20 OpBranch %24 %25 = OpLabel OpReturn OpFunctionEnd )"; const std::string output = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 330 OpName %2 "main" OpName %4 "x" OpName %3 "c" OpDecorate %3 Location 0 %5 = OpTypeVoid %6 = OpTypeFunction %5 %7 = OpTypeInt 32 1 %8 = OpTypePointer Function %7 %9 = OpConstant %7 0 %10 = OpConstant %7 10 %11 = OpTypeBool %12 = OpTypeFloat 32 %13 = OpTypeInt 32 0 %14 = OpConstant %13 10 %15 = OpTypeArray %12 %14 %16 = OpTypePointer Function %15 %17 = OpConstant %12 1 %18 = OpTypePointer Function %12 %19 = OpConstant %7 1 %20 = OpTypeVector %12 4 %21 = OpTypePointer Output %20 %3 = OpVariable %21 Output %58 = OpConstant %13 1 %2 = OpFunction %5 None %6 %22 = OpLabel %4 = OpVariable %16 Function OpBranch %23 %23 = OpLabel %24 = OpPhi %7 %9 %22 %25 %26 OpLoopMerge %32 %26 Unroll OpBranch %28 %28 = OpLabel %29 = OpSLessThan %11 %24 %58 OpBranchConditional %29 %30 %32 %30 = OpLabel %31 = OpAccessChain %18 %4 %24 OpStore %31 %17 OpBranch %26 %26 = OpLabel %25 = OpIAdd %7 %24 %19 OpBranch %23 %32 = OpLabel OpBranch %33 %33 = OpLabel %34 = OpPhi %7 %24 %32 %57 %56 OpLoopMerge %41 %56 DontUnroll OpBranch %35 %35 = OpLabel %36 = OpSLessThan %11 %34 %10 OpBranchConditional %36 %37 %41 %37 = OpLabel %38 = OpAccessChain %18 %4 %34 OpStore %38 %17 OpBranch %39 %39 = OpLabel %40 = OpIAdd %7 %34 %19 OpBranch %42 %42 = OpLabel OpBranch %44 %44 = OpLabel %45 = OpSLessThan %11 %40 %10 OpBranch %46 %46 = OpLabel %47 = OpAccessChain %18 %4 %40 OpStore %47 %17 OpBranch %48 %48 = OpLabel %49 = OpIAdd %7 %40 %19 OpBranch %50 %50 = OpLabel OpBranch %52 %52 = OpLabel %53 = OpSLessThan %11 %49 %10 OpBranch %54 %54 = OpLabel %55 = OpAccessChain %18 %4 %49 OpStore %55 %17 OpBranch %56 %56 = OpLabel %57 = OpIAdd %7 %49 %19 OpBranch %33 %41 = OpLabel OpReturn %27 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for ushader:\n" << text << std::endl; LoopUnroller loop_unroller; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); // By unrolling by a factor that doesn't divide evenly into the number of loop // iterations we perform an additional transform when partially unrolling to // account for the remainder. SinglePassRunAndCheck>(text, output, false); } /* Generated from #version 410 core layout(location=0) flat in int upper_bound; void main() { float x[10]; for (int i = 2; i < 8; i+=2) { x[i] = i; } } */ TEST_F(PassClassTest, SimpleLoopIterationsCheck) { // With LocalMultiStoreElimPass const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 410 OpName %2 "main" OpName %5 "x" OpName %3 "upper_bound" OpDecorate %3 Flat OpDecorate %3 Location 0 %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %10 = OpConstant %8 2 %11 = OpConstant %8 8 %12 = OpTypeBool %13 = OpTypeFloat 32 %14 = OpTypeInt 32 0 %15 = OpConstant %14 10 %16 = OpTypeArray %13 %15 %17 = OpTypePointer Function %16 %18 = OpTypePointer Function %13 %19 = OpTypePointer Input %8 %3 = OpVariable %19 Input %2 = OpFunction %6 None %7 %20 = OpLabel %5 = OpVariable %17 Function OpBranch %21 %21 = OpLabel %34 = OpPhi %8 %10 %20 %33 %23 OpLoopMerge %22 %23 Unroll OpBranch %24 %24 = OpLabel %26 = OpSLessThan %12 %34 %11 OpBranchConditional %26 %27 %22 %27 = OpLabel %30 = OpConvertSToF %13 %34 %31 = OpAccessChain %18 %5 %34 OpStore %31 %30 OpBranch %23 %23 = OpLabel %33 = OpIAdd %8 %34 %10 OpBranch %21 %22 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for ushader:\n" << text << std::endl; Function* f = spvtest::GetFunction(module, 2); LoopDescriptor& loop_descriptor = *context->GetLoopDescriptor(f); EXPECT_EQ(loop_descriptor.NumLoops(), 1u); Loop& loop = loop_descriptor.GetLoopByIndex(0); EXPECT_TRUE(loop.HasUnrollLoopControl()); BasicBlock* condition = loop.FindConditionBlock(); EXPECT_EQ(condition->id(), 24u); Instruction* induction = loop.FindConditionVariable(condition); EXPECT_EQ(induction->result_id(), 34u); LoopUtils loop_utils{context.get(), &loop}; EXPECT_TRUE(loop_utils.CanPerformUnroll()); size_t iterations = 0; EXPECT_TRUE(loop.FindNumberOfIterations(induction, &*condition->ctail(), &iterations)); EXPECT_EQ(iterations, 3u); } /* Generated from #version 410 core void main() { float x[10]; for (int i = -1; i < 6; i+=3) { x[i] = i; } } */ TEST_F(PassClassTest, SimpleLoopIterationsCheckSignedInit) { // With LocalMultiStoreElimPass const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 410 OpName %2 "main" OpName %5 "x" OpName %3 "upper_bound" OpDecorate %3 Flat OpDecorate %3 Location 0 %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %10 = OpConstant %8 -1 %11 = OpConstant %8 6 %12 = OpTypeBool %13 = OpTypeFloat 32 %14 = OpTypeInt 32 0 %15 = OpConstant %14 10 %16 = OpTypeArray %13 %15 %17 = OpTypePointer Function %16 %18 = OpTypePointer Function %13 %19 = OpConstant %8 3 %20 = OpTypePointer Input %8 %3 = OpVariable %20 Input %2 = OpFunction %6 None %7 %21 = OpLabel %5 = OpVariable %17 Function OpBranch %22 %22 = OpLabel %35 = OpPhi %8 %10 %21 %34 %24 OpLoopMerge %23 %24 None OpBranch %25 %25 = OpLabel %27 = OpSLessThan %12 %35 %11 OpBranchConditional %27 %28 %23 %28 = OpLabel %31 = OpConvertSToF %13 %35 %32 = OpAccessChain %18 %5 %35 OpStore %32 %31 OpBranch %24 %24 = OpLabel %34 = OpIAdd %8 %35 %19 OpBranch %22 %23 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for ushader:\n" << text << std::endl; Function* f = spvtest::GetFunction(module, 2); LoopDescriptor& loop_descriptor = *context->GetLoopDescriptor(f); EXPECT_EQ(loop_descriptor.NumLoops(), 1u); Loop& loop = loop_descriptor.GetLoopByIndex(0); EXPECT_FALSE(loop.HasUnrollLoopControl()); BasicBlock* condition = loop.FindConditionBlock(); EXPECT_EQ(condition->id(), 25u); Instruction* induction = loop.FindConditionVariable(condition); EXPECT_EQ(induction->result_id(), 35u); LoopUtils loop_utils{context.get(), &loop}; EXPECT_TRUE(loop_utils.CanPerformUnroll()); size_t iterations = 0; EXPECT_TRUE(loop.FindNumberOfIterations(induction, &*condition->ctail(), &iterations)); EXPECT_EQ(iterations, 3u); } /* Generated from the following GLSL #version 410 core void main() { float out_array[6]; for (uint i = 0; i < 2; i++) { for (int x = 0; x < 3; ++x) { out_array[x + i*3] = i; } } } */ TEST_F(PassClassTest, UnrollNestedLoops) { // With LocalMultiStoreElimPass const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 410 OpName %4 "main" OpName %35 "out_array" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 2 %17 = OpTypeBool %19 = OpTypeInt 32 1 %20 = OpTypePointer Function %19 %22 = OpConstant %19 0 %29 = OpConstant %19 3 %31 = OpTypeFloat 32 %32 = OpConstant %6 6 %33 = OpTypeArray %31 %32 %34 = OpTypePointer Function %33 %39 = OpConstant %6 3 %44 = OpTypePointer Function %31 %47 = OpConstant %19 1 %4 = OpFunction %2 None %3 %5 = OpLabel %35 = OpVariable %34 Function OpBranch %10 %10 = OpLabel %51 = OpPhi %6 %9 %5 %50 %13 OpLoopMerge %12 %13 Unroll OpBranch %14 %14 = OpLabel %18 = OpULessThan %17 %51 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel OpBranch %23 %23 = OpLabel %54 = OpPhi %19 %22 %11 %48 %26 OpLoopMerge %25 %26 Unroll OpBranch %27 %27 = OpLabel %30 = OpSLessThan %17 %54 %29 OpBranchConditional %30 %24 %25 %24 = OpLabel %37 = OpBitcast %6 %54 %40 = OpIMul %6 %51 %39 %41 = OpIAdd %6 %37 %40 %43 = OpConvertUToF %31 %51 %45 = OpAccessChain %44 %35 %41 OpStore %45 %43 OpBranch %26 %26 = OpLabel %48 = OpIAdd %19 %54 %47 OpBranch %23 %25 = OpLabel OpBranch %13 %13 = OpLabel %50 = OpIAdd %6 %51 %47 OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; const std::string output = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 410 OpName %2 "main" OpName %3 "out_array" %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeInt 32 0 %7 = OpTypePointer Function %6 %8 = OpConstant %6 0 %9 = OpConstant %6 2 %10 = OpTypeBool %11 = OpTypeInt 32 1 %12 = OpTypePointer Function %11 %13 = OpConstant %11 0 %14 = OpConstant %11 3 %15 = OpTypeFloat 32 %16 = OpConstant %6 6 %17 = OpTypeArray %15 %16 %18 = OpTypePointer Function %17 %19 = OpConstant %6 3 %20 = OpTypePointer Function %15 %21 = OpConstant %11 1 %2 = OpFunction %4 None %5 %22 = OpLabel %3 = OpVariable %18 Function OpBranch %23 %23 = OpLabel OpBranch %28 %28 = OpLabel %29 = OpULessThan %10 %8 %9 OpBranch %30 %30 = OpLabel OpBranch %31 %31 = OpLabel OpBranch %36 %36 = OpLabel %37 = OpSLessThan %10 %13 %14 OpBranch %38 %38 = OpLabel %39 = OpBitcast %6 %13 %40 = OpIMul %6 %8 %19 %41 = OpIAdd %6 %39 %40 %42 = OpConvertUToF %15 %8 %43 = OpAccessChain %20 %3 %41 OpStore %43 %42 OpBranch %34 %34 = OpLabel %33 = OpIAdd %11 %13 %21 OpBranch %44 %44 = OpLabel OpBranch %46 %46 = OpLabel %47 = OpSLessThan %10 %33 %14 OpBranch %48 %48 = OpLabel %49 = OpBitcast %6 %33 %50 = OpIMul %6 %8 %19 %51 = OpIAdd %6 %49 %50 %52 = OpConvertUToF %15 %8 %53 = OpAccessChain %20 %3 %51 OpStore %53 %52 OpBranch %54 %54 = OpLabel %55 = OpIAdd %11 %33 %21 OpBranch %56 %56 = OpLabel OpBranch %58 %58 = OpLabel %59 = OpSLessThan %10 %55 %14 OpBranch %60 %60 = OpLabel %61 = OpBitcast %6 %55 %62 = OpIMul %6 %8 %19 %63 = OpIAdd %6 %61 %62 %64 = OpConvertUToF %15 %8 %65 = OpAccessChain %20 %3 %63 OpStore %65 %64 OpBranch %66 %66 = OpLabel %67 = OpIAdd %11 %55 %21 OpBranch %35 %35 = OpLabel OpBranch %26 %26 = OpLabel %25 = OpIAdd %6 %8 %21 OpBranch %68 %68 = OpLabel OpBranch %70 %70 = OpLabel %71 = OpULessThan %10 %25 %9 OpBranch %72 %72 = OpLabel OpBranch %73 %73 = OpLabel OpBranch %74 %74 = OpLabel %75 = OpSLessThan %10 %13 %14 OpBranch %76 %76 = OpLabel %77 = OpBitcast %6 %13 %78 = OpIMul %6 %25 %19 %79 = OpIAdd %6 %77 %78 %80 = OpConvertUToF %15 %25 %81 = OpAccessChain %20 %3 %79 OpStore %81 %80 OpBranch %82 %82 = OpLabel %83 = OpIAdd %11 %13 %21 OpBranch %84 %84 = OpLabel OpBranch %85 %85 = OpLabel %86 = OpSLessThan %10 %83 %14 OpBranch %87 %87 = OpLabel %88 = OpBitcast %6 %83 %89 = OpIMul %6 %25 %19 %90 = OpIAdd %6 %88 %89 %91 = OpConvertUToF %15 %25 %92 = OpAccessChain %20 %3 %90 OpStore %92 %91 OpBranch %93 %93 = OpLabel %94 = OpIAdd %11 %83 %21 OpBranch %95 %95 = OpLabel OpBranch %96 %96 = OpLabel %97 = OpSLessThan %10 %94 %14 OpBranch %98 %98 = OpLabel %99 = OpBitcast %6 %94 %100 = OpIMul %6 %25 %19 %101 = OpIAdd %6 %99 %100 %102 = OpConvertUToF %15 %25 %103 = OpAccessChain %20 %3 %101 OpStore %103 %102 OpBranch %104 %104 = OpLabel %105 = OpIAdd %11 %94 %21 OpBranch %106 %106 = OpLabel OpBranch %107 %107 = OpLabel %108 = OpIAdd %6 %25 %21 OpBranch %27 %27 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for ushader:\n" << text << std::endl; LoopUnroller loop_unroller; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(text, output, false); } /* Generated from the following GLSL #version 410 core void main() { float out_array[2]; for (int i = -3; i < -1; i++) { out_array[3 + i] = i; } } */ TEST_F(PassClassTest, NegativeConditionAndInit) { // With LocalMultiStoreElimPass const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 410 OpName %4 "main" OpName %23 "out_array" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 -3 %16 = OpConstant %6 -1 %17 = OpTypeBool %19 = OpTypeInt 32 0 %20 = OpConstant %19 2 %21 = OpTypeArray %6 %20 %22 = OpTypePointer Function %21 %25 = OpConstant %6 3 %30 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %23 = OpVariable %22 Function OpBranch %10 %10 = OpLabel %32 = OpPhi %6 %9 %5 %31 %13 OpLoopMerge %12 %13 Unroll OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %32 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %26 = OpIAdd %6 %32 %25 %28 = OpAccessChain %7 %23 %26 OpStore %28 %32 OpBranch %13 %13 = OpLabel %31 = OpIAdd %6 %32 %30 OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; const std::string expected = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 410 OpName %2 "main" OpName %3 "out_array" %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpConstant %6 -3 %9 = OpConstant %6 -1 %10 = OpTypeBool %11 = OpTypeInt 32 0 %12 = OpConstant %11 2 %13 = OpTypeArray %6 %12 %14 = OpTypePointer Function %13 %15 = OpConstant %6 3 %16 = OpConstant %6 1 %2 = OpFunction %4 None %5 %17 = OpLabel %3 = OpVariable %14 Function OpBranch %18 %18 = OpLabel OpBranch %23 %23 = OpLabel %24 = OpSLessThan %10 %8 %9 OpBranch %25 %25 = OpLabel %26 = OpIAdd %6 %8 %15 %27 = OpAccessChain %7 %3 %26 OpStore %27 %8 OpBranch %21 %21 = OpLabel %20 = OpIAdd %6 %8 %16 OpBranch %28 %28 = OpLabel OpBranch %30 %30 = OpLabel %31 = OpSLessThan %10 %20 %9 OpBranch %32 %32 = OpLabel %33 = OpIAdd %6 %20 %15 %34 = OpAccessChain %7 %3 %33 OpStore %34 %20 OpBranch %35 %35 = OpLabel %36 = OpIAdd %6 %20 %16 OpBranch %22 %22 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for ushader:\n" << text << std::endl; LoopUnroller loop_unroller; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); // SinglePassRunAndCheck(text, expected, false); Function* f = spvtest::GetFunction(module, 4); LoopDescriptor& loop_descriptor = *context->GetLoopDescriptor(f); EXPECT_EQ(loop_descriptor.NumLoops(), 1u); Loop& loop = loop_descriptor.GetLoopByIndex(0); EXPECT_TRUE(loop.HasUnrollLoopControl()); BasicBlock* condition = loop.FindConditionBlock(); EXPECT_EQ(condition->id(), 14u); Instruction* induction = loop.FindConditionVariable(condition); EXPECT_EQ(induction->result_id(), 32u); LoopUtils loop_utils{context.get(), &loop}; EXPECT_TRUE(loop_utils.CanPerformUnroll()); size_t iterations = 0; EXPECT_TRUE(loop.FindNumberOfIterations(induction, &*condition->ctail(), &iterations)); EXPECT_EQ(iterations, 2u); SinglePassRunAndCheck(text, expected, false); } /* Generated from the following GLSL #version 410 core void main() { float out_array[9]; for (int i = -10; i < -1; i++) { out_array[i] = i; } } */ TEST_F(PassClassTest, NegativeConditionAndInitResidualUnroll) { // With LocalMultiStoreElimPass const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 410 OpName %4 "main" OpName %23 "out_array" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 -10 %16 = OpConstant %6 -1 %17 = OpTypeBool %19 = OpTypeInt 32 0 %20 = OpConstant %19 9 %21 = OpTypeArray %6 %20 %22 = OpTypePointer Function %21 %25 = OpConstant %6 10 %30 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %23 = OpVariable %22 Function OpBranch %10 %10 = OpLabel %32 = OpPhi %6 %9 %5 %31 %13 OpLoopMerge %12 %13 Unroll OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %32 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %26 = OpIAdd %6 %32 %25 %28 = OpAccessChain %7 %23 %26 OpStore %28 %32 OpBranch %13 %13 = OpLabel %31 = OpIAdd %6 %32 %30 OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; const std::string expected = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 410 OpName %2 "main" OpName %3 "out_array" %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpConstant %6 -10 %9 = OpConstant %6 -1 %10 = OpTypeBool %11 = OpTypeInt 32 0 %12 = OpConstant %11 9 %13 = OpTypeArray %6 %12 %14 = OpTypePointer Function %13 %15 = OpConstant %6 10 %16 = OpConstant %6 1 %48 = OpConstant %6 -9 %2 = OpFunction %4 None %5 %17 = OpLabel %3 = OpVariable %14 Function OpBranch %18 %18 = OpLabel %19 = OpPhi %6 %8 %17 %20 %21 OpLoopMerge %28 %21 Unroll OpBranch %23 %23 = OpLabel %24 = OpSLessThan %10 %19 %48 OpBranchConditional %24 %25 %28 %25 = OpLabel %26 = OpIAdd %6 %19 %15 %27 = OpAccessChain %7 %3 %26 OpStore %27 %19 OpBranch %21 %21 = OpLabel %20 = OpIAdd %6 %19 %16 OpBranch %18 %28 = OpLabel OpBranch %29 %29 = OpLabel %30 = OpPhi %6 %19 %28 %47 %46 OpLoopMerge %38 %46 DontUnroll OpBranch %31 %31 = OpLabel %32 = OpSLessThan %10 %30 %9 OpBranchConditional %32 %33 %38 %33 = OpLabel %34 = OpIAdd %6 %30 %15 %35 = OpAccessChain %7 %3 %34 OpStore %35 %30 OpBranch %36 %36 = OpLabel %37 = OpIAdd %6 %30 %16 OpBranch %39 %39 = OpLabel OpBranch %41 %41 = OpLabel %42 = OpSLessThan %10 %37 %9 OpBranch %43 %43 = OpLabel %44 = OpIAdd %6 %37 %15 %45 = OpAccessChain %7 %3 %44 OpStore %45 %37 OpBranch %46 %46 = OpLabel %47 = OpIAdd %6 %37 %16 OpBranch %29 %38 = OpLabel OpReturn %22 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for ushader:\n" << text << std::endl; LoopUnroller loop_unroller; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); Function* f = spvtest::GetFunction(module, 4); LoopDescriptor& loop_descriptor = *context->GetLoopDescriptor(f); EXPECT_EQ(loop_descriptor.NumLoops(), 1u); Loop& loop = loop_descriptor.GetLoopByIndex(0); EXPECT_TRUE(loop.HasUnrollLoopControl()); BasicBlock* condition = loop.FindConditionBlock(); EXPECT_EQ(condition->id(), 14u); Instruction* induction = loop.FindConditionVariable(condition); EXPECT_EQ(induction->result_id(), 32u); LoopUtils loop_utils{context.get(), &loop}; EXPECT_TRUE(loop_utils.CanPerformUnroll()); size_t iterations = 0; EXPECT_TRUE(loop.FindNumberOfIterations(induction, &*condition->ctail(), &iterations)); EXPECT_EQ(iterations, 9u); SinglePassRunAndCheck>(text, expected, false); } /* Generated from the following GLSL #version 410 core void main() { float out_array[10]; for (uint i = 0; i < 2; i++) { for (int x = 0; x < 5; ++x) { out_array[x + i*5] = i; } } } */ TEST_F(PassClassTest, UnrollNestedLoopsValidateDescriptor) { // With LocalMultiStoreElimPass const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 410 OpName %4 "main" OpName %35 "out_array" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 2 %17 = OpTypeBool %19 = OpTypeInt 32 1 %20 = OpTypePointer Function %19 %22 = OpConstant %19 0 %29 = OpConstant %19 5 %31 = OpTypeFloat 32 %32 = OpConstant %6 10 %33 = OpTypeArray %31 %32 %34 = OpTypePointer Function %33 %39 = OpConstant %6 5 %44 = OpTypePointer Function %31 %47 = OpConstant %19 1 %4 = OpFunction %2 None %3 %5 = OpLabel %35 = OpVariable %34 Function OpBranch %10 %10 = OpLabel %51 = OpPhi %6 %9 %5 %50 %13 OpLoopMerge %12 %13 Unroll OpBranch %14 %14 = OpLabel %18 = OpULessThan %17 %51 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel OpBranch %23 %23 = OpLabel %54 = OpPhi %19 %22 %11 %48 %26 OpLoopMerge %25 %26 Unroll OpBranch %27 %27 = OpLabel %30 = OpSLessThan %17 %54 %29 OpBranchConditional %30 %24 %25 %24 = OpLabel %37 = OpBitcast %6 %54 %40 = OpIMul %6 %51 %39 %41 = OpIAdd %6 %37 %40 %43 = OpConvertUToF %31 %51 %45 = OpAccessChain %44 %35 %41 OpStore %45 %43 OpBranch %26 %26 = OpLabel %48 = OpIAdd %19 %54 %47 OpBranch %23 %25 = OpLabel OpBranch %13 %13 = OpLabel %50 = OpIAdd %6 %51 %47 OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; { // Test fully unroll std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for ushader:\n" << text << std::endl; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); Function* f = spvtest::GetFunction(module, 4); LoopDescriptor& loop_descriptor = *context->GetLoopDescriptor(f); EXPECT_EQ(loop_descriptor.NumLoops(), 2u); Loop& outer_loop = loop_descriptor.GetLoopByIndex(1); EXPECT_TRUE(outer_loop.HasUnrollLoopControl()); Loop& inner_loop = loop_descriptor.GetLoopByIndex(0); EXPECT_TRUE(inner_loop.HasUnrollLoopControl()); EXPECT_EQ(outer_loop.GetBlocks().size(), 9u); EXPECT_EQ(inner_loop.GetBlocks().size(), 4u); EXPECT_EQ(outer_loop.NumImmediateChildren(), 1u); EXPECT_EQ(inner_loop.NumImmediateChildren(), 0u); { LoopUtils loop_utils{context.get(), &inner_loop}; loop_utils.FullyUnroll(); loop_utils.Finalize(); } EXPECT_EQ(loop_descriptor.NumLoops(), 1u); EXPECT_EQ(outer_loop.GetBlocks().size(), 25u); EXPECT_EQ(outer_loop.NumImmediateChildren(), 0u); { LoopUtils loop_utils{context.get(), &outer_loop}; loop_utils.FullyUnroll(); loop_utils.Finalize(); } EXPECT_EQ(loop_descriptor.NumLoops(), 0u); } { // Test partially unroll std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for ushader:\n" << text << std::endl; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); Function* f = spvtest::GetFunction(module, 4); LoopDescriptor& loop_descriptor = *context->GetLoopDescriptor(f); EXPECT_EQ(loop_descriptor.NumLoops(), 2u); Loop& outer_loop = loop_descriptor.GetLoopByIndex(1); EXPECT_TRUE(outer_loop.HasUnrollLoopControl()); Loop& inner_loop = loop_descriptor.GetLoopByIndex(0); EXPECT_TRUE(inner_loop.HasUnrollLoopControl()); EXPECT_EQ(outer_loop.GetBlocks().size(), 9u); EXPECT_EQ(inner_loop.GetBlocks().size(), 4u); EXPECT_EQ(outer_loop.NumImmediateChildren(), 1u); EXPECT_EQ(inner_loop.NumImmediateChildren(), 0u); LoopUtils loop_utils{context.get(), &inner_loop}; loop_utils.PartiallyUnroll(2); loop_utils.Finalize(); // The number of loops should actually grow. EXPECT_EQ(loop_descriptor.NumLoops(), 3u); EXPECT_EQ(outer_loop.GetBlocks().size(), 18u); EXPECT_EQ(outer_loop.NumImmediateChildren(), 2u); } } /* Generated from the following GLSL #version 410 core void main() { float out_array[3]; for (int i = 3; i > 0; --i) { out_array[i] = i; } } */ TEST_F(PassClassTest, FullyUnrollNegativeStepLoopTest) { // With LocalMultiStoreElimPass const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 410 OpName %4 "main" OpName %24 "out_array" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 3 %16 = OpConstant %6 0 %17 = OpTypeBool %19 = OpTypeFloat 32 %20 = OpTypeInt 32 0 %21 = OpConstant %20 3 %22 = OpTypeArray %19 %21 %23 = OpTypePointer Function %22 %28 = OpTypePointer Function %19 %31 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %24 = OpVariable %23 Function OpBranch %10 %10 = OpLabel %33 = OpPhi %6 %9 %5 %32 %13 OpLoopMerge %12 %13 Unroll OpBranch %14 %14 = OpLabel %18 = OpSGreaterThan %17 %33 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %27 = OpConvertSToF %19 %33 %29 = OpAccessChain %28 %24 %33 OpStore %29 %27 OpBranch %13 %13 = OpLabel %32 = OpISub %6 %33 %31 OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; const std::string output = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 410 OpName %2 "main" OpName %3 "out_array" %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpConstant %6 3 %9 = OpConstant %6 0 %10 = OpTypeBool %11 = OpTypeFloat 32 %12 = OpTypeInt 32 0 %13 = OpConstant %12 3 %14 = OpTypeArray %11 %13 %15 = OpTypePointer Function %14 %16 = OpTypePointer Function %11 %17 = OpConstant %6 1 %2 = OpFunction %4 None %5 %18 = OpLabel %3 = OpVariable %15 Function OpBranch %19 %19 = OpLabel OpBranch %24 %24 = OpLabel %25 = OpSGreaterThan %10 %8 %9 OpBranch %26 %26 = OpLabel %27 = OpConvertSToF %11 %8 %28 = OpAccessChain %16 %3 %8 OpStore %28 %27 OpBranch %22 %22 = OpLabel %21 = OpISub %6 %8 %17 OpBranch %29 %29 = OpLabel OpBranch %31 %31 = OpLabel %32 = OpSGreaterThan %10 %21 %9 OpBranch %33 %33 = OpLabel %34 = OpConvertSToF %11 %21 %35 = OpAccessChain %16 %3 %21 OpStore %35 %34 OpBranch %36 %36 = OpLabel %37 = OpISub %6 %21 %17 OpBranch %38 %38 = OpLabel OpBranch %40 %40 = OpLabel %41 = OpSGreaterThan %10 %37 %9 OpBranch %42 %42 = OpLabel %43 = OpConvertSToF %11 %37 %44 = OpAccessChain %16 %3 %37 OpStore %44 %43 OpBranch %45 %45 = OpLabel %46 = OpISub %6 %37 %17 OpBranch %23 %23 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for ushader:\n" << text << std::endl; LoopUnroller loop_unroller; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(text, output, false); } /* Generated from the following GLSL #version 410 core void main() { float out_array[3]; for (int i = 9; i > 0; i-=3) { out_array[i] = i; } } */ TEST_F(PassClassTest, FullyUnrollNegativeNonOneStepLoop) { // With LocalMultiStoreElimPass const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 410 OpName %4 "main" OpName %24 "out_array" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 9 %16 = OpConstant %6 0 %17 = OpTypeBool %19 = OpTypeFloat 32 %20 = OpTypeInt 32 0 %21 = OpConstant %20 3 %22 = OpTypeArray %19 %21 %23 = OpTypePointer Function %22 %28 = OpTypePointer Function %19 %30 = OpConstant %6 3 %4 = OpFunction %2 None %3 %5 = OpLabel %24 = OpVariable %23 Function OpBranch %10 %10 = OpLabel %33 = OpPhi %6 %9 %5 %32 %13 OpLoopMerge %12 %13 Unroll OpBranch %14 %14 = OpLabel %18 = OpSGreaterThan %17 %33 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %27 = OpConvertSToF %19 %33 %29 = OpAccessChain %28 %24 %33 OpStore %29 %27 OpBranch %13 %13 = OpLabel %32 = OpISub %6 %33 %30 OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; const std::string output = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 410 OpName %2 "main" OpName %3 "out_array" %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpConstant %6 9 %9 = OpConstant %6 0 %10 = OpTypeBool %11 = OpTypeFloat 32 %12 = OpTypeInt 32 0 %13 = OpConstant %12 3 %14 = OpTypeArray %11 %13 %15 = OpTypePointer Function %14 %16 = OpTypePointer Function %11 %17 = OpConstant %6 3 %2 = OpFunction %4 None %5 %18 = OpLabel %3 = OpVariable %15 Function OpBranch %19 %19 = OpLabel OpBranch %24 %24 = OpLabel %25 = OpSGreaterThan %10 %8 %9 OpBranch %26 %26 = OpLabel %27 = OpConvertSToF %11 %8 %28 = OpAccessChain %16 %3 %8 OpStore %28 %27 OpBranch %22 %22 = OpLabel %21 = OpISub %6 %8 %17 OpBranch %29 %29 = OpLabel OpBranch %31 %31 = OpLabel %32 = OpSGreaterThan %10 %21 %9 OpBranch %33 %33 = OpLabel %34 = OpConvertSToF %11 %21 %35 = OpAccessChain %16 %3 %21 OpStore %35 %34 OpBranch %36 %36 = OpLabel %37 = OpISub %6 %21 %17 OpBranch %38 %38 = OpLabel OpBranch %40 %40 = OpLabel %41 = OpSGreaterThan %10 %37 %9 OpBranch %42 %42 = OpLabel %43 = OpConvertSToF %11 %37 %44 = OpAccessChain %16 %3 %37 OpStore %44 %43 OpBranch %45 %45 = OpLabel %46 = OpISub %6 %37 %17 OpBranch %23 %23 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for ushader:\n" << text << std::endl; LoopUnroller loop_unroller; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(text, output, false); } /* Generated from the following GLSL #version 410 core void main() { float out_array[3]; for (int i = 0; i < 7; i+=3) { out_array[i] = i; } } */ TEST_F(PassClassTest, FullyUnrollNonDivisibleStepLoop) { // With LocalMultiStoreElimPass const std::string text = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 410 OpName %4 "main" OpName %24 "out_array" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 7 %17 = OpTypeBool %19 = OpTypeFloat 32 %20 = OpTypeInt 32 0 %21 = OpConstant %20 3 %22 = OpTypeArray %19 %21 %23 = OpTypePointer Function %22 %28 = OpTypePointer Function %19 %30 = OpConstant %6 3 %4 = OpFunction %2 None %3 %5 = OpLabel %24 = OpVariable %23 Function OpBranch %10 %10 = OpLabel %33 = OpPhi %6 %9 %5 %32 %13 OpLoopMerge %12 %13 Unroll OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %33 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %27 = OpConvertSToF %19 %33 %29 = OpAccessChain %28 %24 %33 OpStore %29 %27 OpBranch %13 %13 = OpLabel %32 = OpIAdd %6 %33 %30 OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; const std::string output = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 410 OpName %2 "main" OpName %3 "out_array" %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpConstant %6 0 %9 = OpConstant %6 7 %10 = OpTypeBool %11 = OpTypeFloat 32 %12 = OpTypeInt 32 0 %13 = OpConstant %12 3 %14 = OpTypeArray %11 %13 %15 = OpTypePointer Function %14 %16 = OpTypePointer Function %11 %17 = OpConstant %6 3 %2 = OpFunction %4 None %5 %18 = OpLabel %3 = OpVariable %15 Function OpBranch %19 %19 = OpLabel OpBranch %24 %24 = OpLabel %25 = OpSLessThan %10 %8 %9 OpBranch %26 %26 = OpLabel %27 = OpConvertSToF %11 %8 %28 = OpAccessChain %16 %3 %8 OpStore %28 %27 OpBranch %22 %22 = OpLabel %21 = OpIAdd %6 %8 %17 OpBranch %29 %29 = OpLabel OpBranch %31 %31 = OpLabel %32 = OpSLessThan %10 %21 %9 OpBranch %33 %33 = OpLabel %34 = OpConvertSToF %11 %21 %35 = OpAccessChain %16 %3 %21 OpStore %35 %34 OpBranch %36 %36 = OpLabel %37 = OpIAdd %6 %21 %17 OpBranch %38 %38 = OpLabel OpBranch %40 %40 = OpLabel %41 = OpSLessThan %10 %37 %9 OpBranch %42 %42 = OpLabel %43 = OpConvertSToF %11 %37 %44 = OpAccessChain %16 %3 %37 OpStore %44 %43 OpBranch %45 %45 = OpLabel %46 = OpIAdd %6 %37 %17 OpBranch %23 %23 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for ushader:\n" << text << std::endl; LoopUnroller loop_unroller; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(text, output, false); } /* Generated from the following GLSL #version 410 core void main() { float out_array[4]; for (int i = 11; i > 0; i-=3) { out_array[i] = i; } } */ TEST_F(PassClassTest, FullyUnrollNegativeNonDivisibleStepLoop) { // With LocalMultiStoreElimPass const std::string text = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 410 OpName %4 "main" OpName %24 "out_array" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 11 %16 = OpConstant %6 0 %17 = OpTypeBool %19 = OpTypeFloat 32 %20 = OpTypeInt 32 0 %21 = OpConstant %20 4 %22 = OpTypeArray %19 %21 %23 = OpTypePointer Function %22 %28 = OpTypePointer Function %19 %30 = OpConstant %6 3 %4 = OpFunction %2 None %3 %5 = OpLabel %24 = OpVariable %23 Function OpBranch %10 %10 = OpLabel %33 = OpPhi %6 %9 %5 %32 %13 OpLoopMerge %12 %13 Unroll OpBranch %14 %14 = OpLabel %18 = OpSGreaterThan %17 %33 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %27 = OpConvertSToF %19 %33 %29 = OpAccessChain %28 %24 %33 OpStore %29 %27 OpBranch %13 %13 = OpLabel %32 = OpISub %6 %33 %30 OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; const std::string output = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 410 OpName %2 "main" OpName %3 "out_array" %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpConstant %6 11 %9 = OpConstant %6 0 %10 = OpTypeBool %11 = OpTypeFloat 32 %12 = OpTypeInt 32 0 %13 = OpConstant %12 4 %14 = OpTypeArray %11 %13 %15 = OpTypePointer Function %14 %16 = OpTypePointer Function %11 %17 = OpConstant %6 3 %2 = OpFunction %4 None %5 %18 = OpLabel %3 = OpVariable %15 Function OpBranch %19 %19 = OpLabel OpBranch %24 %24 = OpLabel %25 = OpSGreaterThan %10 %8 %9 OpBranch %26 %26 = OpLabel %27 = OpConvertSToF %11 %8 %28 = OpAccessChain %16 %3 %8 OpStore %28 %27 OpBranch %22 %22 = OpLabel %21 = OpISub %6 %8 %17 OpBranch %29 %29 = OpLabel OpBranch %31 %31 = OpLabel %32 = OpSGreaterThan %10 %21 %9 OpBranch %33 %33 = OpLabel %34 = OpConvertSToF %11 %21 %35 = OpAccessChain %16 %3 %21 OpStore %35 %34 OpBranch %36 %36 = OpLabel %37 = OpISub %6 %21 %17 OpBranch %38 %38 = OpLabel OpBranch %40 %40 = OpLabel %41 = OpSGreaterThan %10 %37 %9 OpBranch %42 %42 = OpLabel %43 = OpConvertSToF %11 %37 %44 = OpAccessChain %16 %3 %37 OpStore %44 %43 OpBranch %45 %45 = OpLabel %46 = OpISub %6 %37 %17 OpBranch %47 %47 = OpLabel OpBranch %49 %49 = OpLabel %50 = OpSGreaterThan %10 %46 %9 OpBranch %51 %51 = OpLabel %52 = OpConvertSToF %11 %46 %53 = OpAccessChain %16 %3 %46 OpStore %53 %52 OpBranch %54 %54 = OpLabel %55 = OpISub %6 %46 %17 OpBranch %23 %23 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for ushader:\n" << text << std::endl; LoopUnroller loop_unroller; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(text, output, false); } // With LocalMultiStoreElimPass static const std::string multiple_phi_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 410 OpName %4 "main" OpName %8 "foo(" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeFunction %6 %10 = OpTypePointer Function %6 %12 = OpConstant %6 0 %14 = OpConstant %6 3 %22 = OpConstant %6 6 %23 = OpTypeBool %31 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %40 = OpFunctionCall %6 %8 OpReturn OpFunctionEnd %8 = OpFunction %6 None %7 %9 = OpLabel OpBranch %16 %16 = OpLabel %41 = OpPhi %6 %12 %9 %34 %19 %42 = OpPhi %6 %14 %9 %29 %19 %43 = OpPhi %6 %12 %9 %32 %19 OpLoopMerge %18 %19 Unroll OpBranch %20 %20 = OpLabel %24 = OpSLessThan %23 %43 %22 OpBranchConditional %24 %17 %18 %17 = OpLabel %27 = OpIMul %6 %43 %41 %29 = OpIAdd %6 %42 %27 OpBranch %19 %19 = OpLabel %32 = OpIAdd %6 %43 %31 %34 = OpISub %6 %41 %31 OpBranch %16 %18 = OpLabel %37 = OpIAdd %6 %42 %41 OpReturnValue %37 OpFunctionEnd )"; TEST_F(PassClassTest, PartiallyUnrollResidualMultipleInductionVariables) { const std::string output = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 410 OpName %2 "main" OpName %3 "foo(" %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeInt 32 1 %7 = OpTypeFunction %6 %8 = OpTypePointer Function %6 %9 = OpConstant %6 0 %10 = OpConstant %6 3 %11 = OpConstant %6 6 %12 = OpTypeBool %13 = OpConstant %6 1 %82 = OpTypeInt 32 0 %83 = OpConstant %82 2 %2 = OpFunction %4 None %5 %14 = OpLabel %15 = OpFunctionCall %6 %3 OpReturn OpFunctionEnd %3 = OpFunction %6 None %7 %16 = OpLabel OpBranch %17 %17 = OpLabel %18 = OpPhi %6 %9 %16 %19 %20 %21 = OpPhi %6 %10 %16 %22 %20 %23 = OpPhi %6 %9 %16 %24 %20 OpLoopMerge %31 %20 Unroll OpBranch %26 %26 = OpLabel %27 = OpSLessThan %12 %23 %83 OpBranchConditional %27 %28 %31 %28 = OpLabel %29 = OpIMul %6 %23 %18 %22 = OpIAdd %6 %21 %29 OpBranch %20 %20 = OpLabel %24 = OpIAdd %6 %23 %13 %19 = OpISub %6 %18 %13 OpBranch %17 %31 = OpLabel OpBranch %32 %32 = OpLabel %33 = OpPhi %6 %18 %31 %81 %79 %34 = OpPhi %6 %21 %31 %78 %79 %35 = OpPhi %6 %23 %31 %80 %79 OpLoopMerge %44 %79 DontUnroll OpBranch %36 %36 = OpLabel %37 = OpSLessThan %12 %35 %11 OpBranchConditional %37 %38 %44 %38 = OpLabel %39 = OpIMul %6 %35 %33 %40 = OpIAdd %6 %34 %39 OpBranch %41 %41 = OpLabel %42 = OpIAdd %6 %35 %13 %43 = OpISub %6 %33 %13 OpBranch %46 %46 = OpLabel OpBranch %50 %50 = OpLabel %51 = OpSLessThan %12 %42 %11 OpBranch %52 %52 = OpLabel %53 = OpIMul %6 %42 %43 %54 = OpIAdd %6 %40 %53 OpBranch %55 %55 = OpLabel %56 = OpIAdd %6 %42 %13 %57 = OpISub %6 %43 %13 OpBranch %58 %58 = OpLabel OpBranch %62 %62 = OpLabel %63 = OpSLessThan %12 %56 %11 OpBranch %64 %64 = OpLabel %65 = OpIMul %6 %56 %57 %66 = OpIAdd %6 %54 %65 OpBranch %67 %67 = OpLabel %68 = OpIAdd %6 %56 %13 %69 = OpISub %6 %57 %13 OpBranch %70 %70 = OpLabel OpBranch %74 %74 = OpLabel %75 = OpSLessThan %12 %68 %11 OpBranch %76 %76 = OpLabel %77 = OpIMul %6 %68 %69 %78 = OpIAdd %6 %66 %77 OpBranch %79 %79 = OpLabel %80 = OpIAdd %6 %68 %13 %81 = OpISub %6 %69 %13 OpBranch %32 %44 = OpLabel %45 = OpIAdd %6 %34 %33 OpReturnValue %45 %25 = OpLabel %30 = OpIAdd %6 %34 %33 OpReturnValue %30 OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, multiple_phi_shader, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for ushader:\n" << multiple_phi_shader << std::endl; LoopUnroller loop_unroller; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck>(multiple_phi_shader, output, false); } TEST_F(PassClassTest, PartiallyUnrollMultipleInductionVariables) { const std::string output = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 410 OpName %2 "main" OpName %3 "foo(" %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeInt 32 1 %7 = OpTypeFunction %6 %8 = OpTypePointer Function %6 %9 = OpConstant %6 0 %10 = OpConstant %6 3 %11 = OpConstant %6 6 %12 = OpTypeBool %13 = OpConstant %6 1 %2 = OpFunction %4 None %5 %14 = OpLabel %15 = OpFunctionCall %6 %3 OpReturn OpFunctionEnd %3 = OpFunction %6 None %7 %16 = OpLabel OpBranch %17 %17 = OpLabel %18 = OpPhi %6 %9 %16 %42 %40 %21 = OpPhi %6 %10 %16 %39 %40 %23 = OpPhi %6 %9 %16 %41 %40 OpLoopMerge %25 %40 DontUnroll OpBranch %26 %26 = OpLabel %27 = OpSLessThan %12 %23 %11 OpBranchConditional %27 %28 %25 %28 = OpLabel %29 = OpIMul %6 %23 %18 %22 = OpIAdd %6 %21 %29 OpBranch %20 %20 = OpLabel %24 = OpIAdd %6 %23 %13 %19 = OpISub %6 %18 %13 OpBranch %31 %31 = OpLabel OpBranch %35 %35 = OpLabel %36 = OpSLessThan %12 %24 %11 OpBranch %37 %37 = OpLabel %38 = OpIMul %6 %24 %19 %39 = OpIAdd %6 %22 %38 OpBranch %40 %40 = OpLabel %41 = OpIAdd %6 %24 %13 %42 = OpISub %6 %19 %13 OpBranch %17 %25 = OpLabel %30 = OpIAdd %6 %21 %18 OpReturnValue %30 OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, multiple_phi_shader, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for ushader:\n" << multiple_phi_shader << std::endl; LoopUnroller loop_unroller; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck>(multiple_phi_shader, output, false); } TEST_F(PassClassTest, FullyUnrollMultipleInductionVariables) { const std::string output = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 410 OpName %2 "main" OpName %3 "foo(" %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeInt 32 1 %7 = OpTypeFunction %6 %8 = OpTypePointer Function %6 %9 = OpConstant %6 0 %10 = OpConstant %6 3 %11 = OpConstant %6 6 %12 = OpTypeBool %13 = OpConstant %6 1 %2 = OpFunction %4 None %5 %14 = OpLabel %15 = OpFunctionCall %6 %3 OpReturn OpFunctionEnd %3 = OpFunction %6 None %7 %16 = OpLabel OpBranch %17 %17 = OpLabel OpBranch %26 %26 = OpLabel %27 = OpSLessThan %12 %9 %11 OpBranch %28 %28 = OpLabel %29 = OpIMul %6 %9 %9 %22 = OpIAdd %6 %10 %29 OpBranch %20 %20 = OpLabel %24 = OpIAdd %6 %9 %13 %19 = OpISub %6 %9 %13 OpBranch %31 %31 = OpLabel OpBranch %35 %35 = OpLabel %36 = OpSLessThan %12 %24 %11 OpBranch %37 %37 = OpLabel %38 = OpIMul %6 %24 %19 %39 = OpIAdd %6 %22 %38 OpBranch %40 %40 = OpLabel %41 = OpIAdd %6 %24 %13 %42 = OpISub %6 %19 %13 OpBranch %43 %43 = OpLabel OpBranch %47 %47 = OpLabel %48 = OpSLessThan %12 %41 %11 OpBranch %49 %49 = OpLabel %50 = OpIMul %6 %41 %42 %51 = OpIAdd %6 %39 %50 OpBranch %52 %52 = OpLabel %53 = OpIAdd %6 %41 %13 %54 = OpISub %6 %42 %13 OpBranch %55 %55 = OpLabel OpBranch %59 %59 = OpLabel %60 = OpSLessThan %12 %53 %11 OpBranch %61 %61 = OpLabel %62 = OpIMul %6 %53 %54 %63 = OpIAdd %6 %51 %62 OpBranch %64 %64 = OpLabel %65 = OpIAdd %6 %53 %13 %66 = OpISub %6 %54 %13 OpBranch %67 %67 = OpLabel OpBranch %71 %71 = OpLabel %72 = OpSLessThan %12 %65 %11 OpBranch %73 %73 = OpLabel %74 = OpIMul %6 %65 %66 %75 = OpIAdd %6 %63 %74 OpBranch %76 %76 = OpLabel %77 = OpIAdd %6 %65 %13 %78 = OpISub %6 %66 %13 OpBranch %79 %79 = OpLabel OpBranch %83 %83 = OpLabel %84 = OpSLessThan %12 %77 %11 OpBranch %85 %85 = OpLabel %86 = OpIMul %6 %77 %78 %87 = OpIAdd %6 %75 %86 OpBranch %88 %88 = OpLabel %89 = OpIAdd %6 %77 %13 %90 = OpISub %6 %78 %13 OpBranch %25 %25 = OpLabel %30 = OpIAdd %6 %87 %90 OpReturnValue %30 OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, multiple_phi_shader, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for ushader:\n" << multiple_phi_shader << std::endl; LoopUnroller loop_unroller; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(multiple_phi_shader, output, false); } /* Generated from the following GLSL #version 440 core void main() { int j = 0; for (int i = 0; i <= 2; ++i) ++j; for (int i = 1; i >= 0; --i) ++j; } */ TEST_F(PassClassTest, FullyUnrollEqualToOperations) { // With LocalMultiStoreElimPass const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource GLSL 440 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %17 = OpConstant %6 2 %18 = OpTypeBool %21 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %11 %11 = OpLabel %37 = OpPhi %6 %9 %5 %22 %14 %38 = OpPhi %6 %9 %5 %24 %14 OpLoopMerge %13 %14 Unroll OpBranch %15 %15 = OpLabel %19 = OpSLessThanEqual %18 %38 %17 OpBranchConditional %19 %12 %13 %12 = OpLabel %22 = OpIAdd %6 %37 %21 OpBranch %14 %14 = OpLabel %24 = OpIAdd %6 %38 %21 OpBranch %11 %13 = OpLabel OpBranch %26 %26 = OpLabel %39 = OpPhi %6 %37 %13 %34 %29 %40 = OpPhi %6 %21 %13 %36 %29 OpLoopMerge %28 %29 Unroll OpBranch %30 %30 = OpLabel %32 = OpSGreaterThanEqual %18 %40 %9 OpBranchConditional %32 %27 %28 %27 = OpLabel %34 = OpIAdd %6 %39 %21 OpBranch %29 %29 = OpLabel %36 = OpISub %6 %40 %21 OpBranch %26 %28 = OpLabel OpReturn OpFunctionEnd )"; const std::string output = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 440 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpConstant %5 0 %8 = OpConstant %5 2 %9 = OpTypeBool %10 = OpConstant %5 1 %2 = OpFunction %3 None %4 %11 = OpLabel OpBranch %12 %12 = OpLabel OpBranch %19 %19 = OpLabel %20 = OpSLessThanEqual %9 %7 %8 OpBranch %21 %21 = OpLabel %14 = OpIAdd %5 %7 %10 OpBranch %15 %15 = OpLabel %17 = OpIAdd %5 %7 %10 OpBranch %41 %41 = OpLabel OpBranch %44 %44 = OpLabel %45 = OpSLessThanEqual %9 %17 %8 OpBranch %46 %46 = OpLabel %47 = OpIAdd %5 %14 %10 OpBranch %48 %48 = OpLabel %49 = OpIAdd %5 %17 %10 OpBranch %50 %50 = OpLabel OpBranch %53 %53 = OpLabel %54 = OpSLessThanEqual %9 %49 %8 OpBranch %55 %55 = OpLabel %56 = OpIAdd %5 %47 %10 OpBranch %57 %57 = OpLabel %58 = OpIAdd %5 %49 %10 OpBranch %18 %18 = OpLabel OpBranch %22 %22 = OpLabel OpBranch %29 %29 = OpLabel %30 = OpSGreaterThanEqual %9 %10 %7 OpBranch %31 %31 = OpLabel %24 = OpIAdd %5 %56 %10 OpBranch %25 %25 = OpLabel %27 = OpISub %5 %10 %10 OpBranch %32 %32 = OpLabel OpBranch %35 %35 = OpLabel %36 = OpSGreaterThanEqual %9 %27 %7 OpBranch %37 %37 = OpLabel %38 = OpIAdd %5 %24 %10 OpBranch %39 %39 = OpLabel %40 = OpISub %5 %27 %10 OpBranch %28 %28 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for ushader:\n" << text << std::endl; LoopUnroller loop_unroller; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(text, output, false); } // With LocalMultiStoreElimPass const std::string condition_in_header = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %o OpExecutionMode %main OriginUpperLeft OpSource GLSL 430 OpDecorate %o Location 0 %void = OpTypeVoid %6 = OpTypeFunction %void %int = OpTypeInt 32 1 %int_n2 = OpConstant %int -2 %int_2 = OpConstant %int 2 %bool = OpTypeBool %float = OpTypeFloat 32 %_ptr_Output_float = OpTypePointer Output %float %o = OpVariable %_ptr_Output_float Output %float_1 = OpConstant %float 1 %main = OpFunction %void None %6 %15 = OpLabel OpBranch %16 %16 = OpLabel %27 = OpPhi %int %int_n2 %15 %26 %18 %21 = OpSLessThanEqual %bool %27 %int_2 OpLoopMerge %17 %18 Unroll OpBranchConditional %21 %22 %17 %22 = OpLabel %23 = OpLoad %float %o %24 = OpFAdd %float %23 %float_1 OpStore %o %24 OpBranch %18 %18 = OpLabel %26 = OpIAdd %int %27 %int_2 OpBranch %16 %17 = OpLabel OpReturn OpFunctionEnd )"; TEST_F(PassClassTest, FullyUnrollConditionIsInHeaderBlock) { const std::string output = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" %2 OpExecutionMode %1 OriginUpperLeft OpSource GLSL 430 OpDecorate %2 Location 0 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpConstant %5 -2 %7 = OpConstant %5 2 %8 = OpTypeBool %9 = OpTypeFloat 32 %10 = OpTypePointer Output %9 %2 = OpVariable %10 Output %11 = OpConstant %9 1 %1 = OpFunction %3 None %4 %12 = OpLabel OpBranch %13 %13 = OpLabel %17 = OpSLessThanEqual %8 %6 %7 OpBranch %19 %19 = OpLabel %20 = OpLoad %9 %2 %21 = OpFAdd %9 %20 %11 OpStore %2 %21 OpBranch %16 %16 = OpLabel %15 = OpIAdd %5 %6 %7 OpBranch %22 %22 = OpLabel %24 = OpSLessThanEqual %8 %15 %7 OpBranch %25 %25 = OpLabel %26 = OpLoad %9 %2 %27 = OpFAdd %9 %26 %11 OpStore %2 %27 OpBranch %28 %28 = OpLabel %29 = OpIAdd %5 %15 %7 OpBranch %30 %30 = OpLabel %32 = OpSLessThanEqual %8 %29 %7 OpBranch %33 %33 = OpLabel %34 = OpLoad %9 %2 %35 = OpFAdd %9 %34 %11 OpStore %2 %35 OpBranch %36 %36 = OpLabel %37 = OpIAdd %5 %29 %7 OpBranch %18 %18 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, condition_in_header, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for ushader:\n" << condition_in_header << std::endl; LoopUnroller loop_unroller; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(condition_in_header, output, false); } TEST_F(PassClassTest, PartiallyUnrollResidualConditionIsInHeaderBlock) { const std::string output = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" %2 OpExecutionMode %1 OriginUpperLeft OpSource GLSL 430 OpDecorate %2 Location 0 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpConstant %5 -2 %7 = OpConstant %5 2 %8 = OpTypeBool %9 = OpTypeFloat 32 %10 = OpTypePointer Output %9 %2 = OpVariable %10 Output %11 = OpConstant %9 1 %40 = OpTypeInt 32 0 %41 = OpConstant %40 1 %1 = OpFunction %3 None %4 %12 = OpLabel OpBranch %13 %13 = OpLabel %14 = OpPhi %5 %6 %12 %15 %16 %17 = OpSLessThanEqual %8 %14 %41 OpLoopMerge %22 %16 Unroll OpBranchConditional %17 %19 %22 %19 = OpLabel %20 = OpLoad %9 %2 %21 = OpFAdd %9 %20 %11 OpStore %2 %21 OpBranch %16 %16 = OpLabel %15 = OpIAdd %5 %14 %7 OpBranch %13 %22 = OpLabel OpBranch %23 %23 = OpLabel %24 = OpPhi %5 %14 %22 %39 %38 %25 = OpSLessThanEqual %8 %24 %7 OpLoopMerge %31 %38 DontUnroll OpBranchConditional %25 %26 %31 %26 = OpLabel %27 = OpLoad %9 %2 %28 = OpFAdd %9 %27 %11 OpStore %2 %28 OpBranch %29 %29 = OpLabel %30 = OpIAdd %5 %24 %7 OpBranch %32 %32 = OpLabel %34 = OpSLessThanEqual %8 %30 %7 OpBranch %35 %35 = OpLabel %36 = OpLoad %9 %2 %37 = OpFAdd %9 %36 %11 OpStore %2 %37 OpBranch %38 %38 = OpLabel %39 = OpIAdd %5 %30 %7 OpBranch %23 %31 = OpLabel OpReturn %18 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, condition_in_header, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for ushader:\n" << condition_in_header << std::endl; LoopUnroller loop_unroller; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck>(condition_in_header, output, false); } /* Generated from following GLSL with latch block artificially inserted to be separate from continue. #version 430 void main(void) { float x[10]; for (int i = 0; i < 10; ++i) { x[i] = i; } } */ TEST_F(PassClassTest, PartiallyUnrollLatchNotContinue) { const std::string text = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "i" OpName %4 "x" %5 = OpTypeVoid %6 = OpTypeFunction %5 %7 = OpTypeInt 32 1 %8 = OpTypePointer Function %7 %9 = OpConstant %7 0 %10 = OpConstant %7 10 %11 = OpTypeBool %12 = OpTypeFloat 32 %13 = OpTypeInt 32 0 %14 = OpConstant %13 10 %15 = OpTypeArray %12 %14 %16 = OpTypePointer Function %15 %17 = OpTypePointer Function %12 %18 = OpConstant %7 1 %2 = OpFunction %5 None %6 %19 = OpLabel %3 = OpVariable %8 Function %4 = OpVariable %16 Function OpStore %3 %9 OpBranch %20 %20 = OpLabel %21 = OpPhi %7 %9 %19 %22 %30 OpLoopMerge %24 %23 Unroll OpBranch %25 %25 = OpLabel %26 = OpSLessThan %11 %21 %10 OpBranchConditional %26 %27 %24 %27 = OpLabel %28 = OpConvertSToF %12 %21 %29 = OpAccessChain %17 %4 %21 OpStore %29 %28 OpBranch %23 %23 = OpLabel %22 = OpIAdd %7 %21 %18 OpStore %3 %22 OpBranch %30 %30 = OpLabel OpBranch %20 %24 = OpLabel OpReturn OpFunctionEnd )"; const std::string expected = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "i" OpName %4 "x" %5 = OpTypeVoid %6 = OpTypeFunction %5 %7 = OpTypeInt 32 1 %8 = OpTypePointer Function %7 %9 = OpConstant %7 0 %10 = OpConstant %7 10 %11 = OpTypeBool %12 = OpTypeFloat 32 %13 = OpTypeInt 32 0 %14 = OpConstant %13 10 %15 = OpTypeArray %12 %14 %16 = OpTypePointer Function %15 %17 = OpTypePointer Function %12 %18 = OpConstant %7 1 %63 = OpConstant %13 1 %2 = OpFunction %5 None %6 %19 = OpLabel %3 = OpVariable %8 Function %4 = OpVariable %16 Function OpStore %3 %9 OpBranch %20 %20 = OpLabel %21 = OpPhi %7 %9 %19 %22 %23 OpLoopMerge %31 %25 Unroll OpBranch %26 %26 = OpLabel %27 = OpSLessThan %11 %21 %63 OpBranchConditional %27 %28 %31 %28 = OpLabel %29 = OpConvertSToF %12 %21 %30 = OpAccessChain %17 %4 %21 OpStore %30 %29 OpBranch %25 %25 = OpLabel %22 = OpIAdd %7 %21 %18 OpStore %3 %22 OpBranch %23 %23 = OpLabel OpBranch %20 %31 = OpLabel OpBranch %32 %32 = OpLabel %33 = OpPhi %7 %21 %31 %61 %62 OpLoopMerge %42 %60 DontUnroll OpBranch %34 %34 = OpLabel %35 = OpSLessThan %11 %33 %10 OpBranchConditional %35 %36 %42 %36 = OpLabel %37 = OpConvertSToF %12 %33 %38 = OpAccessChain %17 %4 %33 OpStore %38 %37 OpBranch %39 %39 = OpLabel %40 = OpIAdd %7 %33 %18 OpStore %3 %40 OpBranch %41 %41 = OpLabel OpBranch %43 %43 = OpLabel OpBranch %45 %45 = OpLabel %46 = OpSLessThan %11 %40 %10 OpBranch %47 %47 = OpLabel %48 = OpConvertSToF %12 %40 %49 = OpAccessChain %17 %4 %40 OpStore %49 %48 OpBranch %50 %50 = OpLabel %51 = OpIAdd %7 %40 %18 OpStore %3 %51 OpBranch %52 %52 = OpLabel OpBranch %53 %53 = OpLabel OpBranch %55 %55 = OpLabel %56 = OpSLessThan %11 %51 %10 OpBranch %57 %57 = OpLabel %58 = OpConvertSToF %12 %51 %59 = OpAccessChain %17 %4 %51 OpStore %59 %58 OpBranch %60 %60 = OpLabel %61 = OpIAdd %7 %51 %18 OpStore %3 %61 OpBranch %62 %62 = OpLabel OpBranch %32 %42 = OpLabel OpReturn %24 = OpLabel OpReturn OpFunctionEnd )"; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck>(text, expected, true); // Make sure the latch block information is preserved and propagated correctly // by the pass. std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); PartialUnrollerTestPass<3> unroller; unroller.SetContextForTesting(context.get()); unroller.Process(); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 2); LoopDescriptor ld{context.get(), f}; EXPECT_EQ(ld.NumLoops(), 2u); Loop& loop_1 = ld.GetLoopByIndex(0u); EXPECT_NE(loop_1.GetLatchBlock(), loop_1.GetContinueBlock()); Loop& loop_2 = ld.GetLoopByIndex(1u); EXPECT_NE(loop_2.GetLatchBlock(), loop_2.GetContinueBlock()); } // Test that a loop with a self-referencing OpPhi instruction is handled // correctly. TEST_F(PassClassTest, OpPhiSelfReference) { const std::string text = R"( ; Find the two adds from the unrolled loop ; CHECK: OpIAdd ; CHECK: OpIAdd ; CHECK: OpIAdd %uint %uint_0 %uint_1 ; CHECK-NEXT: OpReturn OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" OpExecutionMode %2 LocalSize 8 8 1 OpSource HLSL 600 %uint = OpTypeInt 32 0 %void = OpTypeVoid %5 = OpTypeFunction %void %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %bool = OpTypeBool %true = OpConstantTrue %bool %2 = OpFunction %void None %5 %10 = OpLabel OpBranch %19 %19 = OpLabel %20 = OpPhi %uint %uint_0 %10 %20 %21 %22 = OpPhi %uint %uint_0 %10 %23 %21 %24 = OpULessThanEqual %bool %22 %uint_1 OpLoopMerge %25 %21 Unroll OpBranchConditional %24 %21 %25 %21 = OpLabel %23 = OpIAdd %uint %22 %uint_1 OpBranch %19 %25 = OpLabel %14 = OpIAdd %uint %20 %uint_1 OpReturn OpFunctionEnd )"; const bool kFullyUnroll = true; const uint32_t kUnrollFactor = 0; SinglePassRunAndMatch(text, true, kFullyUnroll, kUnrollFactor); } // Test that a loop containing an unreachable merge block can still be unrolled // correctly. TEST_F(PassClassTest, UnreachableMerge) { const std::string text = R"( ; Identify the first iteration of the unrolled loop, and make sure it contains ; the unreachable merge block. ; The first SelectionMerge corresponds to the original loop merge. ; The second is the branch in the loop. ; CHECK: OpSelectionMerge {{%\w+}} None ; CHECK: OpSelectionMerge [[unrch1:%\w+]] None ; CHECK: [[unrch1]] = OpLabel ; CHECK-NEXT: OpUnreachable ; Identify the second iteration of the unrolled loop, and make sure it contains ; the unreachable merge block. ; The first SelectionMerge corresponds to the original loop merge ; The second is the branch in the loop. ; CHECK: OpSelectionMerge {{%\w+}} None ; CHECK: OpSelectionMerge [[unrch2:%\w+]] None ; CHECK: [[unrch2]] = OpLabel ; CHECK-NEXT: OpUnreachable OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 64 1 1 OpSource HLSL 600 OpName %main "main" %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_2 = OpConstant %uint 2 %uint_1 = OpConstant %uint 1 %bool = OpTypeBool %void = OpTypeVoid %18 = OpTypeFunction %void %main = OpFunction %void None %18 %23 = OpLabel OpBranch %24 %24 = OpLabel %28 = OpPhi %uint %uint_0 %23 %29 %27 %30 = OpULessThan %bool %28 %uint_2 OpLoopMerge %31 %27 Unroll OpBranchConditional %30 %32 %31 %32 = OpLabel OpSelectionMerge %33 None OpSwitch %uint_0 %34 %34 = OpLabel %35 = OpUndef %bool OpSelectionMerge %36 None OpBranchConditional %35 %37 %38 %38 = OpLabel OpBranch %33 %37 = OpLabel OpBranch %33 %36 = OpLabel OpUnreachable %33 = OpLabel OpBranch %27 %27 = OpLabel %29 = OpIAdd %uint %28 %uint_1 OpBranch %24 %31 = OpLabel OpReturn OpFunctionEnd )"; const bool kFullyUnroll = true; const uint32_t kUnrollFactor = 0; SinglePassRunAndMatch(text, true, kFullyUnroll, kUnrollFactor); } TEST_F(PassClassTest, InitValueIsConstantNull) { const std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpConstantNull %6 %13 = OpConstant %6 1 %21 = OpConstant %6 1 %10 = OpTypeBool %17 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %11 = OpLabel OpBranch %5 %5 = OpLabel %23 = OpPhi %6 %7 %11 %20 %15 OpLoopMerge %8 %15 Unroll OpBranch %14 %14 = OpLabel %9 = OpSLessThan %10 %23 %13 OpBranchConditional %9 %15 %8 %15 = OpLabel %20 = OpIAdd %6 %23 %21 OpBranch %5 %8 = OpLabel OpReturn OpFunctionEnd )"; const std::string output = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 320 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpConstantNull %5 %7 = OpConstant %5 1 %8 = OpConstant %5 1 %9 = OpTypeBool %10 = OpTypePointer Function %5 %2 = OpFunction %3 None %4 %11 = OpLabel OpBranch %12 %12 = OpLabel OpBranch %17 %17 = OpLabel %18 = OpSLessThan %9 %6 %7 OpBranch %15 %15 = OpLabel %14 = OpIAdd %5 %6 %8 OpBranch %16 %16 = OpLabel OpReturn OpFunctionEnd )"; auto context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, shader, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << shader << std::endl; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(shader, output, false); } TEST_F(PassClassTest, ConditionValueIsConstantNull) { const std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpConstantNull %6 %13 = OpConstant %6 1 %21 = OpConstant %6 1 %10 = OpTypeBool %17 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %11 = OpLabel OpBranch %5 %5 = OpLabel %23 = OpPhi %6 %13 %11 %20 %15 OpLoopMerge %8 %15 Unroll OpBranch %14 %14 = OpLabel %9 = OpSGreaterThan %10 %23 %7 OpBranchConditional %9 %15 %8 %15 = OpLabel %20 = OpISub %6 %23 %21 OpBranch %5 %8 = OpLabel OpReturn OpFunctionEnd )"; const std::string output = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 320 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpConstantNull %5 %7 = OpConstant %5 1 %8 = OpConstant %5 1 %9 = OpTypeBool %10 = OpTypePointer Function %5 %2 = OpFunction %3 None %4 %11 = OpLabel OpBranch %12 %12 = OpLabel OpBranch %17 %17 = OpLabel %18 = OpSGreaterThan %9 %7 %6 OpBranch %15 %15 = OpLabel %14 = OpISub %5 %7 %8 OpBranch %16 %16 = OpLabel OpReturn OpFunctionEnd )"; auto context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, shader, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << shader << std::endl; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(shader, output, false); } TEST_F(PassClassTest, UnrollWithPhiReferencesPhi) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %color OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %main "main" OpName %color "color" OpDecorate %color Location 0 %uint = OpTypeInt 32 0 %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %float_1 = OpConstant %float 1 %uint_1 = OpConstant %uint 1 %uint_3 = OpConstant %uint 3 %void = OpTypeVoid %11 = OpTypeFunction %void %bool = OpTypeBool %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %color = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %11 %15 = OpLabel OpBranch %16 %16 = OpLabel %17 = OpPhi %float %float_0 %15 %18 %19 %18 = OpPhi %float %float_1 %15 %20 %19 %21 = OpPhi %uint %uint_1 %15 %22 %19 %23 = OpULessThanEqual %bool %21 %uint_3 OpLoopMerge %24 %19 Unroll OpBranchConditional %23 %25 %24 %25 = OpLabel ; First loop iteration ; CHECK: [[next_phi1_0:%\w+]] = OpFSub %float %float_1 %float_0 ; Second loop iteration ; CHECK: [[next_phi1_1:%\w+]] = OpFSub %float [[next_phi1_0]] %float_1 ; Third loop iteration ; CHECK: OpFSub %float [[next_phi1_1]] [[next_phi1_0]] %20 = OpFSub %float %18 %17 OpBranch %19 %19 = OpLabel %22 = OpIAdd %uint %21 %uint_1 OpBranch %16 %24 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for ushader:\n" << text << std::endl; LoopUnroller loop_unroller; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); SinglePassRunAndMatch(text, true); } TEST_F(PassClassTest, UnrollWithDoublePhiReferencesPhi) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %color OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %main "main" OpName %color "color" OpDecorate %color Location 0 %uint = OpTypeInt 32 0 %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %float_1 = OpConstant %float 1 %uint_1 = OpConstant %uint 1 %uint_3 = OpConstant %uint 3 %void = OpTypeVoid %11 = OpTypeFunction %void %bool = OpTypeBool %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %color = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %11 %15 = OpLabel OpBranch %16 %16 = OpLabel %17 = OpPhi %float %float_1 %15 %18 %19 %18 = OpPhi %float %float_0 %15 %20 %19 %20 = OpPhi %float %float_1 %15 %21 %19 %22 = OpPhi %uint %uint_1 %15 %23 %19 %24 = OpULessThanEqual %bool %22 %uint_3 OpLoopMerge %25 %19 Unroll OpBranchConditional %24 %26 %25 %26 = OpLabel ; First loop iteration ; CHECK: [[next_phi1_0:%\w+]] = OpFSub %float %float_1 %float_0 ; CHECK: OpFMul %float %float_1 ; Second loop iteration ; CHECK: [[next_phi1_1:%\w+]] = OpFSub %float [[next_phi1_0]] %float_1 ; CHECK: OpFMul %float %float_0 ; Third loop iteration ; CHECK: OpFSub %float [[next_phi1_1]] [[next_phi1_0]] ; CHECK: OpFMul %float %float_1 %21 = OpFSub %float %20 %18 %27 = OpFMul %float %17 %21 OpBranch %19 %19 = OpLabel %23 = OpIAdd %uint %22 %uint_1 OpBranch %16 %25 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for ushader:\n" << text << std::endl; LoopUnroller loop_unroller; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); SinglePassRunAndMatch(text, true); } TEST_F(PassClassTest, PartialUnrollWithPhiReferencesPhi) { // With LocalMultiStoreElimPass const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %color OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %main "main" OpName %color "color" OpDecorate %color Location 0 %uint = OpTypeInt 32 0 %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %float_1 = OpConstant %float 1 %uint_1 = OpConstant %uint 1 %uint_3 = OpConstant %uint 3 %void = OpTypeVoid %11 = OpTypeFunction %void %bool = OpTypeBool %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %color = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %11 %15 = OpLabel OpBranch %16 %16 = OpLabel %17 = OpPhi %float %float_0 %15 %18 %19 %18 = OpPhi %float %float_1 %15 %20 %19 %21 = OpPhi %uint %uint_1 %15 %22 %19 %23 = OpULessThanEqual %bool %21 %uint_3 OpLoopMerge %24 %19 Unroll OpBranchConditional %23 %25 %24 %25 = OpLabel ; CHECK: [[phi0_0:%\w+]] = OpPhi {{%\w+}} {{%\w+}} {{%\w+}} [[phi1_0:%\w+]] ; CHECK: [[phi1_0]] = OpPhi {{%\w+}} {{%\w+}} {{%\w+}} [[sub:%\w+]] ; CHECK: [[sub]] = OpFSub {{%\w+}} [[phi1_0]] [[phi0_0]] ; CHECK: [[phi0_1:%\w+]] = OpPhi {{%\w+}} [[phi0_0]] ; CHECK: [[phi1_1:%\w+]] = OpPhi {{%\w+}} [[phi1_0]] ; CHECK: [[sub:%\w+]] = OpFSub {{%\w+}} [[phi1_1]] [[phi0_1]] ; CHECK: OpFSub {{%\w+}} [[sub]] [[phi1_1]] %20 = OpFSub %float %18 %17 OpBranch %19 %19 = OpLabel %22 = OpIAdd %uint %21 %uint_1 OpBranch %16 %24 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for ushader:\n" << text << std::endl; LoopUnroller loop_unroller; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndMatch>(text, true); } TEST_F(PassClassTest, DontUnrollInfiteLoop) { // This is an infinite loop that because the step is 0. We want to make sure // the unroller does not try to unroll it. const std::string text = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft %void = OpTypeVoid %4 = OpTypeFunction %void %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_50 = OpConstant %int 50 %bool = OpTypeBool %int_0_0 = OpConstant %int 0 %2 = OpFunction %void None %4 %10 = OpLabel OpBranch %11 %11 = OpLabel %12 = OpPhi %int %int_0 %10 %13 %14 %15 = OpSLessThan %bool %12 %int_50 OpLoopMerge %16 %14 Unroll OpBranchConditional %15 %14 %16 %14 = OpLabel %13 = OpIAdd %int %12 %int_0_0 OpBranch %11 %16 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(text, text, false); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/loop_optimizations/unswitch.cpp000066400000000000000000000753331475742701700266370ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "effcee/effcee.h" #include "gmock/gmock.h" #include "test/opt/pass_fixture.h" namespace spvtools { namespace opt { namespace { using UnswitchTest = PassTest<::testing::Test>; /* Generated from the following GLSL + --eliminate-local-multi-store #version 450 core uniform vec4 c; void main() { int i = 0; int j = 0; bool cond = c[0] == 0; for (; i < 10; i++, j++) { if (cond) { i++; } else { j++; } } } */ TEST_F(UnswitchTest, SimpleUnswitch) { const std::string text = R"( ; CHECK: [[cst_cond:%\w+]] = OpFOrdEqual ; CHECK-NEXT: OpSelectionMerge [[if_merge:%\w+]] None ; CHECK-NEXT: OpBranchConditional [[cst_cond]] [[loop_t:%\w+]] [[loop_f:%\w+]] ; Loop specialized for false. ; CHECK: [[loop_f]] = OpLabel ; CHECK-NEXT: OpBranch [[loop:%\w+]] ; CHECK: [[loop]] = OpLabel ; CHECK-NEXT: [[phi_i:%\w+]] = OpPhi %int %int_0 [[loop_f]] [[iv_i:%\w+]] [[continue:%\w+]] ; CHECK-NEXT: [[phi_j:%\w+]] = OpPhi %int %int_0 [[loop_f]] [[iv_j:%\w+]] [[continue]] ; CHECK-NEXT: OpLoopMerge [[merge:%\w+]] [[continue]] None ; CHECK: [[loop_exit:%\w+]] = OpSLessThan {{%\w+}} [[phi_i]] {{%\w+}} ; CHECK-NEXT: OpBranchConditional [[loop_exit]] [[loop_body:%\w+]] [[merge]] ; [[loop_body]] = OpLabel ; CHECK: OpSelectionMerge [[sel_merge:%\w+]] None ; CHECK: OpBranchConditional %false [[bb1:%\w+]] [[bb2:%\w+]] ; CHECK: [[bb2]] = OpLabel ; CHECK-NEXT: [[inc_j:%\w+]] = OpIAdd %int [[phi_j]] %int_1 ; CHECK-NEXT: OpBranch [[sel_merge]] ; CHECK: [[bb1]] = OpLabel ; CHECK-NEXT: [[inc_i:%\w+]] = OpIAdd %int [[phi_i]] %int_1 ; CHECK-NEXT: OpBranch [[sel_merge]] ; CHECK: [[sel_merge]] = OpLabel ; CHECK: OpBranch [[if_merge]] ; Loop specialized for true. ; CHECK: [[loop_t]] = OpLabel ; CHECK-NEXT: OpBranch [[loop:%\w+]] ; CHECK: [[loop]] = OpLabel ; CHECK-NEXT: [[phi_i:%\w+]] = OpPhi %int %int_0 [[loop_t]] [[iv_i:%\w+]] [[continue:%\w+]] ; CHECK-NEXT: [[phi_j:%\w+]] = OpPhi %int %int_0 [[loop_t]] [[iv_j:%\w+]] [[continue]] ; CHECK-NEXT: OpLoopMerge [[merge:%\w+]] [[continue]] None ; CHECK: [[loop_exit:%\w+]] = OpSLessThan {{%\w+}} [[phi_i]] {{%\w+}} ; CHECK-NEXT: OpBranchConditional [[loop_exit]] [[loop_body:%\w+]] [[merge]] ; [[loop_body]] = OpLabel ; CHECK: OpSelectionMerge [[sel_merge:%\w+]] None ; CHECK: OpBranchConditional %true [[bb1:%\w+]] [[bb2:%\w+]] ; CHECK: [[bb1]] = OpLabel ; CHECK-NEXT: [[inc_i:%\w+]] = OpIAdd %int [[phi_i]] %int_1 ; CHECK-NEXT: OpBranch [[sel_merge]] ; CHECK: [[bb2]] = OpLabel ; CHECK-NEXT: [[inc_j:%\w+]] = OpIAdd %int [[phi_j]] %int_1 ; CHECK-NEXT: OpBranch [[sel_merge]] ; CHECK: [[sel_merge]] = OpLabel ; CHECK: OpBranch [[if_merge]] ; CHECK: [[if_merge]] = OpLabel ; CHECK-NEXT: OpReturn OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginLowerLeft OpSource GLSL 450 OpName %main "main" OpName %c "c" OpDecorate %c Location 0 OpDecorate %c DescriptorSet 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %bool = OpTypeBool %_ptr_Function_bool = OpTypePointer Function %bool %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_UniformConstant_v4float = OpTypePointer UniformConstant %v4float %c = OpVariable %_ptr_UniformConstant_v4float UniformConstant %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_UniformConstant_float = OpTypePointer UniformConstant %float %float_0 = OpConstant %float 0 %int_10 = OpConstant %int 10 %int_1 = OpConstant %int 1 %main = OpFunction %void None %3 %5 = OpLabel %21 = OpAccessChain %_ptr_UniformConstant_float %c %uint_0 %22 = OpLoad %float %21 %24 = OpFOrdEqual %bool %22 %float_0 OpBranch %25 %25 = OpLabel %46 = OpPhi %int %int_0 %5 %43 %28 %47 = OpPhi %int %int_0 %5 %45 %28 OpLoopMerge %27 %28 None OpBranch %29 %29 = OpLabel %32 = OpSLessThan %bool %46 %int_10 OpBranchConditional %32 %26 %27 %26 = OpLabel OpSelectionMerge %35 None OpBranchConditional %24 %34 %39 %34 = OpLabel %38 = OpIAdd %int %46 %int_1 OpBranch %35 %39 = OpLabel %41 = OpIAdd %int %47 %int_1 OpBranch %35 %35 = OpLabel %48 = OpPhi %int %38 %34 %46 %39 %49 = OpPhi %int %47 %34 %41 %39 OpBranch %28 %28 = OpLabel %43 = OpIAdd %int %48 %int_1 %45 = OpIAdd %int %49 %int_1 OpBranch %25 %27 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 330 core in vec4 c; void main() { int i = 0; bool cond = c[0] == 0; for (; i < 10; i++) { if (cond) { i++; } else { return; } } } */ TEST_F(UnswitchTest, UnswitchExit) { const std::string text = R"( ; CHECK: [[cst_cond:%\w+]] = OpFOrdEqual ; CHECK-NEXT: OpSelectionMerge [[if_merge:%\w+]] None ; CHECK-NEXT: OpBranchConditional [[cst_cond]] [[loop_t:%\w+]] [[loop_f:%\w+]] ; Loop specialized for false. ; CHECK: [[loop_f]] = OpLabel ; CHECK: OpReturn ; Loop specialized for true. ; CHECK: [[loop_t]] = OpLabel ; CHECK-NEXT: OpBranch [[loop:%\w+]] ; CHECK: [[loop]] = OpLabel ; CHECK-NEXT: [[phi_i:%\w+]] = OpPhi %int %int_0 [[loop_t]] [[iv_i:%\w+]] [[continue:%\w+]] ; CHECK-NEXT: OpLoopMerge [[merge:%\w+]] [[continue]] None ; CHECK: [[loop_exit:%\w+]] = OpSLessThan {{%\w+}} [[phi_i]] {{%\w+}} ; CHECK-NEXT: OpBranchConditional [[loop_exit]] {{%\w+}} [[merge]] ; Check that we have i+=2. ; CHECK: [[phi_i:%\w+]] = OpIAdd %int [[phi_i]] %int_1 ; CHECK: [[iv_i]] = OpIAdd %int [[phi_i]] %int_1 ; CHECK: [[merge]] = OpLabel ; CHECK-NEXT: OpBranch [[if_merge]] ; CHECK: [[if_merge]] = OpLabel ; CHECK-NEXT: OpReturn OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %c OpExecutionMode %main OriginUpperLeft OpSource GLSL 330 OpName %main "main" OpName %c "c" OpDecorate %c Location 0 OpDecorate %23 Uniform %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %bool = OpTypeBool %_ptr_Function_bool = OpTypePointer Function %bool %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %c = OpVariable %_ptr_Input_v4float Input %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %float_0 = OpConstant %float 0 %int_10 = OpConstant %int 10 %int_1 = OpConstant %int 1 %main = OpFunction %void None %3 %5 = OpLabel %20 = OpAccessChain %_ptr_Input_float %c %uint_0 %21 = OpLoad %float %20 %23 = OpFOrdEqual %bool %21 %float_0 OpBranch %24 %24 = OpLabel %42 = OpPhi %int %int_0 %5 %41 %27 OpLoopMerge %26 %27 None OpBranch %28 %28 = OpLabel %31 = OpSLessThan %bool %42 %int_10 OpBranchConditional %31 %25 %26 %25 = OpLabel OpSelectionMerge %34 None OpBranchConditional %23 %33 %38 %33 = OpLabel %37 = OpIAdd %int %42 %int_1 OpBranch %34 %38 = OpLabel OpReturn %34 = OpLabel OpBranch %27 %27 = OpLabel %41 = OpIAdd %int %37 %int_1 OpBranch %24 %26 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 330 core in vec4 c; void main() { int i = 0; bool cond = c[0] == 0; for (; i < 10; i++) { if (cond) { continue; } else { i++; } } } */ TEST_F(UnswitchTest, UnswitchContinue) { const std::string text = R"( ; CHECK: [[cst_cond:%\w+]] = OpFOrdEqual ; CHECK-NEXT: OpSelectionMerge [[if_merge:%\w+]] None ; CHECK-NEXT: OpBranchConditional [[cst_cond]] [[loop_t:%\w+]] [[loop_f:%\w+]] ; Loop specialized for false. ; CHECK: [[loop_f]] = OpLabel ; CHECK-NEXT: OpBranch [[loop:%\w+]] ; CHECK: [[loop]] = OpLabel ; CHECK-NEXT: [[phi_i:%\w+]] = OpPhi %int %int_0 [[loop_f]] [[iv_i:%\w+]] [[continue:%\w+]] ; CHECK-NEXT: OpLoopMerge [[merge:%\w+]] [[continue]] None ; CHECK: [[loop_exit:%\w+]] = OpSLessThan {{%\w+}} [[phi_i]] {{%\w+}} ; CHECK-NEXT: OpBranchConditional [[loop_exit]] [[loop_body:%\w+]] [[merge]] ; CHECK: [[loop_body:%\w+]] = OpLabel ; CHECK-NEXT: OpSelectionMerge ; CHECK-NEXT: OpBranchConditional %false ; CHECK: [[merge]] = OpLabel ; CHECK-NEXT: OpBranch [[if_merge]] ; Loop specialized for true. ; CHECK: [[loop_t]] = OpLabel ; CHECK-NEXT: OpBranch [[loop:%\w+]] ; CHECK: [[loop]] = OpLabel ; CHECK-NEXT: [[phi_i:%\w+]] = OpPhi %int %int_0 [[loop_t]] [[iv_i:%\w+]] [[continue:%\w+]] ; CHECK-NEXT: OpLoopMerge [[merge:%\w+]] [[continue]] None ; CHECK: [[loop_exit:%\w+]] = OpSLessThan {{%\w+}} [[phi_i]] {{%\w+}} ; CHECK-NEXT: OpBranchConditional [[loop_exit]] [[loop_body:%\w+]] [[merge]] ; CHECK: [[loop_body:%\w+]] = OpLabel ; CHECK-NEXT: OpSelectionMerge ; CHECK-NEXT: OpBranchConditional %true ; CHECK: [[merge]] = OpLabel ; CHECK-NEXT: OpBranch [[if_merge]] ; CHECK: [[if_merge]] = OpLabel ; CHECK-NEXT: OpReturn OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %c OpExecutionMode %main OriginUpperLeft OpSource GLSL 330 OpName %main "main" OpName %c "c" OpDecorate %c Location 0 OpDecorate %23 Uniform %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %bool = OpTypeBool %_ptr_Function_bool = OpTypePointer Function %bool %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %c = OpVariable %_ptr_Input_v4float Input %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %float_0 = OpConstant %float 0 %int_10 = OpConstant %int 10 %int_1 = OpConstant %int 1 %main = OpFunction %void None %3 %5 = OpLabel %20 = OpAccessChain %_ptr_Input_float %c %uint_0 %21 = OpLoad %float %20 %23 = OpFOrdEqual %bool %21 %float_0 OpBranch %24 %24 = OpLabel %42 = OpPhi %int %int_0 %5 %41 %27 OpLoopMerge %26 %27 None OpBranch %28 %28 = OpLabel %31 = OpSLessThan %bool %42 %int_10 OpBranchConditional %31 %25 %26 %25 = OpLabel OpSelectionMerge %34 None OpBranchConditional %23 %33 %36 %33 = OpLabel OpBranch %27 %36 = OpLabel %39 = OpIAdd %int %42 %int_1 OpBranch %34 %34 = OpLabel OpBranch %27 %27 = OpLabel %43 = OpPhi %int %42 %33 %39 %34 %41 = OpIAdd %int %43 %int_1 OpBranch %24 %26 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 330 core in vec4 c; void main() { int i = 0; bool cond = c[0] == 0; for (; i < 10; i++) { if (cond) { i++; } else { break; } } } */ TEST_F(UnswitchTest, UnswitchKillLoop) { const std::string text = R"( ; CHECK: [[cst_cond:%\w+]] = OpFOrdEqual ; CHECK-NEXT: OpSelectionMerge [[if_merge:%\w+]] None ; CHECK-NEXT: OpBranchConditional [[cst_cond]] [[loop_t:%\w+]] [[loop_f:%\w+]] ; Loop specialized for false. ; CHECK: [[loop_f]] = OpLabel ; CHECK: OpBranch [[if_merge]] ; Loop specialized for true. ; CHECK: [[loop_t]] = OpLabel ; CHECK-NEXT: OpBranch [[loop:%\w+]] ; CHECK: [[loop]] = OpLabel ; CHECK-NEXT: [[phi_i:%\w+]] = OpPhi %int %int_0 [[loop_t]] [[iv_i:%\w+]] [[continue:%\w+]] ; CHECK-NEXT: OpLoopMerge [[merge:%\w+]] [[continue]] None ; CHECK: [[loop_exit:%\w+]] = OpSLessThan {{%\w+}} [[phi_i]] {{%\w+}} ; CHECK-NEXT: OpBranchConditional [[loop_exit]] {{%\w+}} [[merge]] ; Check that we have i+=2. ; CHECK: [[phi_i:%\w+]] = OpIAdd %int [[phi_i]] %int_1 ; CHECK: [[iv_i]] = OpIAdd %int [[phi_i]] %int_1 ; CHECK: [[merge]] = OpLabel ; CHECK-NEXT: OpBranch [[if_merge]] ; CHECK: [[if_merge]] = OpLabel ; CHECK-NEXT: OpReturn OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %c OpExecutionMode %main OriginUpperLeft OpSource GLSL 330 OpName %main "main" OpName %c "c" OpDecorate %c Location 0 OpDecorate %23 Uniform %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %bool = OpTypeBool %_ptr_Function_bool = OpTypePointer Function %bool %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %c = OpVariable %_ptr_Input_v4float Input %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %float_0 = OpConstant %float 0 %int_10 = OpConstant %int 10 %int_1 = OpConstant %int 1 %main = OpFunction %void None %3 %5 = OpLabel %20 = OpAccessChain %_ptr_Input_float %c %uint_0 %21 = OpLoad %float %20 %23 = OpFOrdEqual %bool %21 %float_0 OpBranch %24 %24 = OpLabel %42 = OpPhi %int %int_0 %5 %41 %27 OpLoopMerge %26 %27 None OpBranch %28 %28 = OpLabel %31 = OpSLessThan %bool %42 %int_10 OpBranchConditional %31 %25 %26 %25 = OpLabel OpSelectionMerge %34 None OpBranchConditional %23 %33 %38 %33 = OpLabel %37 = OpIAdd %int %42 %int_1 OpBranch %34 %38 = OpLabel OpBranch %26 %34 = OpLabel OpBranch %27 %27 = OpLabel %41 = OpIAdd %int %37 %int_1 OpBranch %24 %26 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 330 core in vec4 c; void main() { int i = 0; int cond = int(c[0]); for (; i < 10; i++) { switch (cond) { case 0: return; case 1: discard; case 2: break; default: break; } } bool cond2 = i == 9; } */ TEST_F(UnswitchTest, UnswitchSwitch) { const std::string text = R"( ; CHECK: [[cst_cond:%\w+]] = OpConvertFToS ; CHECK-NEXT: OpSelectionMerge [[if_merge:%\w+]] None ; CHECK-NEXT: OpSwitch [[cst_cond]] [[default:%\w+]] 0 [[loop_0:%\w+]] 1 [[loop_1:%\w+]] 2 [[loop_2:%\w+]] ; Loop specialized for 2. ; CHECK: [[loop_2]] = OpLabel ; CHECK-NEXT: OpBranch [[loop:%\w+]] ; CHECK: [[loop]] = OpLabel ; CHECK-NEXT: [[phi_i:%\w+]] = OpPhi %int %int_0 [[loop_2]] [[iv_i:%\w+]] [[continue:%\w+]] ; CHECK-NEXT: OpLoopMerge [[merge:%\w+]] [[continue]] None ; CHECK: [[loop_exit:%\w+]] = OpSLessThan {{%\w+}} [[phi_i]] {{%\w+}} ; CHECK-NEXT: OpBranchConditional [[loop_exit]] [[loop_body:%\w+]] [[merge]] ; CHECK: [[loop_body]] = OpLabel ; CHECK-NEXT: OpSelectionMerge ; CHECK-NEXT: OpSwitch %int_2 ; CHECK: [[merge]] = OpLabel ; CHECK-NEXT: OpBranch [[if_merge]] ; Loop specialized for 1. ; CHECK: [[loop_1]] = OpLabel ; CHECK-NEXT: OpBranch [[loop:%\w+]] ; CHECK: [[loop]] = OpLabel ; CHECK-NEXT: [[phi_i:%\w+]] = OpPhi %int %int_0 [[loop_1]] [[iv_i:%\w+]] [[continue:%\w+]] ; CHECK-NEXT: OpLoopMerge [[merge:%\w+]] [[continue]] None ; CHECK: [[loop_exit:%\w+]] = OpSLessThan {{%\w+}} [[phi_i]] {{%\w+}} ; CHECK-NEXT: OpBranchConditional [[loop_exit]] [[loop_body:%\w+]] [[merge]] ; CHECK: [[loop_body]] = OpLabel ; CHECK-NEXT: OpSelectionMerge ; CHECK-NEXT: OpSwitch %int_1 ; CHECK: [[merge]] = OpLabel ; CHECK-NEXT: OpBranch [[if_merge]] ; Loop specialized for 0. ; CHECK: [[loop_0]] = OpLabel ; CHECK-NEXT: OpBranch [[loop:%\w+]] ; CHECK: [[loop]] = OpLabel ; CHECK-NEXT: [[phi_i:%\w+]] = OpPhi %int %int_0 [[loop_0]] [[iv_i:%\w+]] [[continue:%\w+]] ; CHECK-NEXT: OpLoopMerge [[merge:%\w+]] [[continue]] None ; CHECK: [[loop_exit:%\w+]] = OpSLessThan {{%\w+}} [[phi_i]] {{%\w+}} ; CHECK-NEXT: OpBranchConditional [[loop_exit]] [[loop_body:%\w+]] [[merge]] ; CHECK: [[loop_body]] = OpLabel ; CHECK-NEXT: OpSelectionMerge ; CHECK-NEXT: OpSwitch %int_0 ; CHECK: [[merge]] = OpLabel ; CHECK-NEXT: OpBranch [[if_merge]] ; Loop specialized for the default case. ; CHECK: [[default]] = OpLabel ; CHECK-NEXT: OpBranch [[loop:%\w+]] ; CHECK: [[loop]] = OpLabel ; CHECK-NEXT: [[phi_i:%\w+]] = OpPhi %int %int_0 [[default]] [[iv_i:%\w+]] [[continue:%\w+]] ; CHECK-NEXT: OpLoopMerge [[merge:%\w+]] [[continue]] None ; CHECK: [[loop_exit:%\w+]] = OpSLessThan {{%\w+}} [[phi_i]] {{%\w+}} ; CHECK-NEXT: OpBranchConditional [[loop_exit]] [[loop_body:%\w+]] [[merge]] ; CHECK: [[loop_body]] = OpLabel ; CHECK-NEXT: OpSelectionMerge ; CHECK-NEXT: OpSwitch %uint_3 ; CHECK: [[merge]] = OpLabel ; CHECK-NEXT: OpBranch [[if_merge]] ; CHECK: [[if_merge]] = OpLabel ; CHECK-NEXT: OpReturn OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %c OpExecutionMode %main OriginUpperLeft OpSource GLSL 330 OpName %main "main" OpName %c "c" OpDecorate %c Location 0 OpDecorate %20 Uniform %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %c = OpVariable %_ptr_Input_v4float Input %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %int_10 = OpConstant %int 10 %bool = OpTypeBool %int_1 = OpConstant %int 1 %_ptr_Function_bool = OpTypePointer Function %bool %main = OpFunction %void None %3 %5 = OpLabel %18 = OpAccessChain %_ptr_Input_float %c %uint_0 %19 = OpLoad %float %18 %20 = OpConvertFToS %int %19 OpBranch %21 %21 = OpLabel %49 = OpPhi %int %int_0 %5 %43 %24 OpLoopMerge %23 %24 None OpBranch %25 %25 = OpLabel %29 = OpSLessThan %bool %49 %int_10 OpBranchConditional %29 %22 %23 %22 = OpLabel OpSelectionMerge %35 None OpSwitch %20 %34 0 %31 1 %32 2 %33 %34 = OpLabel OpBranch %35 %31 = OpLabel OpReturn %32 = OpLabel OpKill %33 = OpLabel OpBranch %35 %35 = OpLabel OpBranch %24 %24 = OpLabel %43 = OpIAdd %int %49 %int_1 OpBranch %21 %23 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 440 core layout(location = 0)in vec4 c; void main() { int i = 0; int j = 0; int k = 0; bool cond = c[0] == 0; for (; i < 10; i++) { for (; j < 10; j++) { if (cond) { i++; } else { j++; } } } } */ TEST_F(UnswitchTest, UnSwitchNested) { // Test that an branch can be unswitched out of two nested loops. const std::string text = R"( ; CHECK: [[cst_cond:%\w+]] = OpFOrdEqual ; CHECK-NEXT: OpSelectionMerge [[if_merge:%\w+]] None ; CHECK-NEXT: OpBranchConditional [[cst_cond]] [[loop_t:%\w+]] [[loop_f:%\w+]] ; Loop specialized for false ; CHECK: [[loop_f]] = OpLabel ; CHECK-NEXT: OpBranch [[loop:%\w+]] ; CHECK: [[loop]] = OpLabel ; CHECK-NEXT: {{%\w+}} = OpPhi %int %int_0 [[loop_f]] {{%\w+}} [[continue:%\w+]] ; CHECK-NEXT: {{%\w+}} = OpPhi %int %int_0 [[loop_f]] {{%\w+}} [[continue]] ; CHECK-NEXT: OpLoopMerge [[merge:%\w+]] [[continue]] None ; CHECK-NOT: [[merge]] = OpLabel ; CHECK: OpLoopMerge ; CHECK-NEXT: OpBranch [[bb1:%\w+]] ; CHECK: [[bb1]] = OpLabel ; CHECK-NEXT: OpSLessThan ; CHECK-NEXT: OpBranchConditional {{%\w+}} [[bb2:%\w+]] ; CHECK: [[bb2]] = OpLabel ; CHECK-NEXT: OpSelectionMerge ; CHECK-NEXT: OpBranchConditional %false ; CHECK: [[merge]] = OpLabel ; Loop specialized for true. Same as first loop except the branch condition is true. ; CHECK: [[loop_t]] = OpLabel ; CHECK-NEXT: OpBranch [[loop:%\w+]] ; CHECK: [[loop]] = OpLabel ; CHECK-NEXT: {{%\w+}} = OpPhi %int %int_0 [[loop_t]] {{%\w+}} [[continue:%\w+]] ; CHECK-NEXT: {{%\w+}} = OpPhi %int %int_0 [[loop_t]] {{%\w+}} [[continue]] ; CHECK-NEXT: OpLoopMerge [[merge:%\w+]] [[continue]] None ; CHECK-NOT: [[merge]] = OpLabel ; CHECK: OpLoopMerge ; CHECK-NEXT: OpBranch [[bb1:%\w+]] ; CHECK: [[bb1]] = OpLabel ; CHECK-NEXT: OpSLessThan ; CHECK-NEXT: OpBranchConditional {{%\w+}} [[bb2:%\w+]] ; CHECK: [[bb2]] = OpLabel ; CHECK-NEXT: OpSelectionMerge ; CHECK-NEXT: OpBranchConditional %true ; CHECK: [[merge]] = OpLabel OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %c OpExecutionMode %main OriginUpperLeft OpSource GLSL 440 OpName %main "main" OpName %c "c" OpDecorate %c Location 0 OpDecorate %25 Uniform %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %bool = OpTypeBool %_ptr_Function_bool = OpTypePointer Function %bool %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %c = OpVariable %_ptr_Input_v4float Input %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %float_0 = OpConstant %float 0 %int_10 = OpConstant %int 10 %int_1 = OpConstant %int 1 %main = OpFunction %void None %3 %5 = OpLabel %22 = OpAccessChain %_ptr_Input_float %c %uint_0 %23 = OpLoad %float %22 %25 = OpFOrdEqual %bool %23 %float_0 OpBranch %26 %26 = OpLabel %67 = OpPhi %int %int_0 %5 %52 %29 %68 = OpPhi %int %int_0 %5 %70 %29 OpLoopMerge %28 %29 None OpBranch %30 %30 = OpLabel %33 = OpSLessThan %bool %67 %int_10 OpBranchConditional %33 %27 %28 %27 = OpLabel OpBranch %34 %34 = OpLabel %69 = OpPhi %int %67 %27 %46 %37 %70 = OpPhi %int %68 %27 %50 %37 OpLoopMerge %36 %37 None OpBranch %38 %38 = OpLabel %40 = OpSLessThan %bool %70 %int_10 OpBranchConditional %40 %35 %36 %35 = OpLabel OpSelectionMerge %43 None OpBranchConditional %25 %42 %47 %42 = OpLabel %46 = OpIAdd %int %69 %int_1 OpBranch %43 %47 = OpLabel OpReturn %43 = OpLabel OpBranch %37 %37 = OpLabel %50 = OpIAdd %int %70 %int_1 OpBranch %34 %36 = OpLabel OpBranch %29 %29 = OpLabel %52 = OpIAdd %int %69 %int_1 OpBranch %26 %28 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 330 core in vec4 c; void main() { bool cond = false; if (c[0] == 0) { cond = c[1] == 0; } else { cond = c[2] == 0; } for (int i = 0; i < 10; i++) { if (cond) { i++; } } } */ TEST_F(UnswitchTest, UnswitchNotUniform) { // Check that the unswitch is not triggered (condition loop invariant but not // uniform) const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %c OpExecutionMode %main OriginUpperLeft OpSource GLSL 330 OpName %main "main" OpName %c "c" OpDecorate %c Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %bool = OpTypeBool %_ptr_Function_bool = OpTypePointer Function %bool %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %c = OpVariable %_ptr_Input_v4float Input %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %float_0 = OpConstant %float 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %int_10 = OpConstant %int 10 %int_1 = OpConstant %int 1 %main = OpFunction %void None %3 %5 = OpLabel %17 = OpAccessChain %_ptr_Input_float %c %uint_0 %18 = OpLoad %float %17 %20 = OpFOrdEqual %bool %18 %float_0 OpSelectionMerge %22 None OpBranchConditional %20 %21 %27 %21 = OpLabel %24 = OpAccessChain %_ptr_Input_float %c %uint_1 %25 = OpLoad %float %24 %26 = OpFOrdEqual %bool %25 %float_0 OpBranch %22 %27 = OpLabel %29 = OpAccessChain %_ptr_Input_float %c %uint_2 %30 = OpLoad %float %29 %31 = OpFOrdEqual %bool %30 %float_0 OpBranch %22 %22 = OpLabel %52 = OpPhi %bool %26 %21 %31 %27 OpBranch %36 %36 = OpLabel %53 = OpPhi %int %int_0 %22 %51 %39 OpLoopMerge %38 %39 None OpBranch %40 %40 = OpLabel %43 = OpSLessThan %bool %53 %int_10 OpBranchConditional %43 %37 %38 %37 = OpLabel OpSelectionMerge %46 None OpBranchConditional %52 %45 %46 %45 = OpLabel %49 = OpIAdd %int %53 %int_1 OpBranch %46 %46 = OpLabel %54 = OpPhi %int %53 %37 %49 %45 OpBranch %39 %39 = OpLabel %51 = OpIAdd %int %54 %int_1 OpBranch %36 %38 = OpLabel OpReturn OpFunctionEnd )"; auto result = SinglePassRunAndDisassemble(text, true, false); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } TEST_F(UnswitchTest, DontUnswitchLatch) { // Check that the unswitch is not triggered for the latch branch. const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %void = OpTypeVoid %3 = OpTypeFunction %void %bool = OpTypeBool %false = OpConstantFalse %bool %4 = OpFunction %void None %3 %5 = OpLabel OpBranch %6 %6 = OpLabel OpLoopMerge %8 %9 None OpBranch %7 %7 = OpLabel OpBranch %9 %9 = OpLabel OpBranchConditional %false %6 %8 %8 = OpLabel OpReturn OpFunctionEnd )"; auto result = SinglePassRunAndDisassemble(text, true, false); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } TEST_F(UnswitchTest, DontUnswitchConstantCondition) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginLowerLeft OpSource GLSL 450 OpName %main "main" %void = OpTypeVoid %4 = OpTypeFunction %void %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %bool = OpTypeBool %true = OpConstantTrue %bool %int_1 = OpConstant %int 1 %main = OpFunction %void None %4 %10 = OpLabel OpBranch %11 %11 = OpLabel %12 = OpPhi %int %int_0 %10 %13 %14 OpLoopMerge %15 %14 None OpBranch %16 %16 = OpLabel %17 = OpSLessThan %bool %12 %int_1 OpBranchConditional %17 %18 %15 %18 = OpLabel OpSelectionMerge %19 None OpBranchConditional %true %20 %19 %20 = OpLabel %21 = OpIAdd %int %12 %int_1 OpBranch %19 %19 = OpLabel %22 = OpPhi %int %21 %20 %12 %18 OpBranch %14 %14 = OpLabel %13 = OpIAdd %int %22 %int_1 OpBranch %11 %15 = OpLabel OpReturn OpFunctionEnd )"; auto result = SinglePassRunAndDisassemble(text, true, false); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/modify_maximal_reconvergence_test.cpp000066400000000000000000000216471475742701700277730ustar00rootroot00000000000000// Copyright (c) 2024 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "assembly_builder.h" #include "pass_fixture.h" #include "pass_utils.h" namespace { using namespace spvtools; using ModifyMaximalReconvergenceTest = opt::PassTest<::testing::Test>; TEST_F(ModifyMaximalReconvergenceTest, AddNoEntryPoint) { const std::string text = R"( ; CHECK-NOT: OpExtension OpCapability Kernel OpCapability Linkage OpMemoryModel Logical OpenCL )"; SinglePassRunAndMatch(text, true, true); } TEST_F(ModifyMaximalReconvergenceTest, AddSingleEntryPoint) { const std::string text = R"( ; CHECK: OpExtension "SPV_KHR_maximal_reconvergence" ; CHECK: OpExecutionMode %main MaximallyReconvergesKHR OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpName %main "main" %void = OpTypeVoid %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true, true); } TEST_F(ModifyMaximalReconvergenceTest, AddExtensionExists) { const std::string text = R"( ; CHECK: OpExtension "SPV_KHR_maximal_reconvergence" ; CHECK-NOT: OpExtension "SPV_KHR_maximal_reconvergence" ; CHECK: OpExecutionMode %main MaximallyReconvergesKHR OpCapability Shader OpExtension "SPV_KHR_maximal_reconvergence" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpName %main "main" %void = OpTypeVoid %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true, true); } TEST_F(ModifyMaximalReconvergenceTest, AddExecutionModeExists) { const std::string text = R"( ; CHECK: OpExtension "SPV_KHR_maximal_reconvergence" ; CHECK-NOT: OpExtension "SPV_KHR_maximal_reconvergence" ; CHECK: OpExecutionMode %main LocalSize 1 1 1 ; CHECK-NEXT: OpExecutionMode %main MaximallyReconvergesKHR ; CHECK-NOT: OpExecutionMode %main MaximallyReconvergesKHR OpCapability Shader OpExtension "SPV_KHR_maximal_reconvergence" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpExecutionMode %main MaximallyReconvergesKHR OpName %main "main" %void = OpTypeVoid %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true, true); } TEST_F(ModifyMaximalReconvergenceTest, AddTwoEntryPoints) { const std::string text = R"( ; CHECK: OpExtension "SPV_KHR_maximal_reconvergence" ; CHECK: OpExecutionMode %comp MaximallyReconvergesKHR ; CHECK: OpExecutionMode %frag MaximallyReconvergesKHR OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %comp "main" OpEntryPoint Fragment %frag "main" OpExecutionMode %comp LocalSize 1 1 1 OpExecutionMode %frag OriginUpperLeft OpName %comp "comp" OpName %frag "frag" %void = OpTypeVoid %void_fn = OpTypeFunction %void %comp = OpFunction %void None %void_fn %entry1 = OpLabel OpReturn OpFunctionEnd %frag = OpFunction %void None %void_fn %entry2 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true, true); } TEST_F(ModifyMaximalReconvergenceTest, AddTwoEntryPointsOneFunc) { const std::string text = R"( ; CHECK: OpExtension "SPV_KHR_maximal_reconvergence" ; CHECK: OpExecutionMode %comp MaximallyReconvergesKHR ; CHECK-NOT: OpExecutionMode %comp MaximallyReconvergesKHR OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %comp "main1" OpEntryPoint GLCompute %comp "main2" OpExecutionMode %comp LocalSize 1 1 1 OpName %comp "comp" %void = OpTypeVoid %void_fn = OpTypeFunction %void %comp = OpFunction %void None %void_fn %entry1 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true, true); } TEST_F(ModifyMaximalReconvergenceTest, AddTwoEntryPointsOneExecutionMode) { const std::string text = R"( ; CHECK: OpExtension "SPV_KHR_maximal_reconvergence" ; CHECK: OpExecutionMode %comp MaximallyReconvergesKHR ; CHECK-NOT: OpExecutionMode %comp MaximallyReconvergesKHR ; CHECK: OpExecutionMode %frag MaximallyReconvergesKHR ; CHECK-NOT: OpExecutionMode %comp MaximallyReconvergesKHR OpCapability Shader OpExtension "SPV_KHR_maximal_reconvergence" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %comp "main" OpEntryPoint Fragment %frag "main" OpExecutionMode %comp LocalSize 1 1 1 OpExecutionMode %frag OriginUpperLeft OpExecutionMode %comp MaximallyReconvergesKHR OpName %comp "comp" OpName %frag "frag" %void = OpTypeVoid %void_fn = OpTypeFunction %void %comp = OpFunction %void None %void_fn %entry1 = OpLabel OpReturn OpFunctionEnd %frag = OpFunction %void None %void_fn %entry2 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true, true); } TEST_F(ModifyMaximalReconvergenceTest, RemoveNoEntryPoint) { const std::string text = R"(OpCapability Kernel OpCapability Linkage OpMemoryModel Logical OpenCL )"; SinglePassRunAndCheck(text, text, false, true, false); } TEST_F(ModifyMaximalReconvergenceTest, RemoveOnlyExtension) { const std::string text = R"( ; CHECK-NOT: OpExtension "SPV_KHR_maximal_reconvergence" ; CHECK: OpExecutionMode %main LocalSize 1 1 1 OpCapability Shader OpExtension "SPV_KHR_maximal_reconvergence" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpName %main "main" %void = OpTypeVoid %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true, false); } TEST_F(ModifyMaximalReconvergenceTest, RemoveSingleEntryPoint) { const std::string text = R"( ; CHECK-NOT: OpExtension "SPV_KHR_maximal_reconvergence" ; CHECK: OpExecutionMode %main LocalSize 1 1 1 ; CHECK-NOT: OpExecutionMode %main MaximallyReconvergesKHR OpCapability Shader OpExtension "SPV_KHR_maximal_reconvergence" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpExecutionMode %main MaximallyReconvergesKHR OpName %main "main" %void = OpTypeVoid %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true, false); } TEST_F(ModifyMaximalReconvergenceTest, RemoveTwoEntryPointsOneExecutionMode) { const std::string text = R"( ; CHECK-NOT: OpExtension "SPV_KHR_maximal_reconvergence" ; CHECK: OpExecutionMode %comp LocalSize 1 1 1 ; CHECK-NEXT: OpExecutionMode %frag OriginUpperLeft ; CHECK-NOT: OpExecutionMode %comp MaximallyReconvergesKHR OpCapability Shader OpExtension "SPV_KHR_maximal_reconvergence" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %comp "main" OpEntryPoint Fragment %frag "main" OpExecutionMode %comp LocalSize 1 1 1 OpExecutionMode %comp MaximallyReconvergesKHR OpExecutionMode %frag OriginUpperLeft OpName %comp "comp" OpName %frag "frag" %void = OpTypeVoid %void_fn = OpTypeFunction %void %comp = OpFunction %void None %void_fn %entry1 = OpLabel OpReturn OpFunctionEnd %frag = OpFunction %void None %void_fn %entry2 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true, false); } TEST_F(ModifyMaximalReconvergenceTest, RemoveTwoEntryPoints) { const std::string text = R"( ; CHECK-NOT: OpExtension "SPV_KHR_maximal_reconvergence" ; CHECK: OpExecutionMode %comp LocalSize 1 1 1 ; CHECK-NEXT: OpExecutionMode %frag OriginUpperLeft ; CHECK-NOT: OpExecutionMode {{%\w}} MaximallyReconvergesKHR OpCapability Shader OpExtension "SPV_KHR_maximal_reconvergence" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %comp "main" OpEntryPoint Fragment %frag "main" OpExecutionMode %comp LocalSize 1 1 1 OpExecutionMode %comp MaximallyReconvergesKHR OpExecutionMode %frag OriginUpperLeft OpExecutionMode %frag MaximallyReconvergesKHR OpName %comp "comp" OpName %frag "frag" %void = OpTypeVoid %void_fn = OpTypeFunction %void %comp = OpFunction %void None %void_fn %entry1 = OpLabel OpReturn OpFunctionEnd %frag = OpFunction %void None %void_fn %entry2 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true, false); } } // namespace KhronosGroup-SPIRV-Tools-f289d04/test/opt/module_test.cpp000066400000000000000000000217751475742701700233560ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/module.h" #include #include #include "gmock/gmock.h" #include "gtest/gtest.h" #include "source/opt/build_module.h" #include "spirv-tools/libspirv.hpp" #include "test/opt/module_utils.h" namespace spvtools { namespace opt { namespace { using ::testing::Eq; using spvtest::GetIdBound; TEST(ModuleTest, SetIdBound) { Module m; // It's initialized to 0. EXPECT_EQ(0u, GetIdBound(m)); m.SetIdBound(19); EXPECT_EQ(19u, GetIdBound(m)); m.SetIdBound(102); EXPECT_EQ(102u, GetIdBound(m)); } // Returns an IRContext owning the module formed by assembling the given text, // then loading the result. inline std::unique_ptr BuildModule(std::string text) { return spvtools::BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); } TEST(ModuleTest, ComputeIdBound) { // Empty module case. EXPECT_EQ(1u, BuildModule("")->module()->ComputeIdBound()); // Sensitive to result id EXPECT_EQ(2u, BuildModule("%void = OpTypeVoid")->module()->ComputeIdBound()); // Sensitive to type id EXPECT_EQ(1000u, BuildModule("%a = OpTypeArray !999 3")->module()->ComputeIdBound()); // Sensitive to a regular Id parameter EXPECT_EQ(2000u, BuildModule("OpDecorate !1999 0")->module()->ComputeIdBound()); // Sensitive to a scope Id parameter. EXPECT_EQ(3000u, BuildModule("%f = OpFunction %void None %fntype %a = OpLabel " "OpMemoryBarrier !2999 %b\n") ->module() ->ComputeIdBound()); // Sensitive to a semantics Id parameter EXPECT_EQ(4000u, BuildModule("%f = OpFunction %void None %fntype %a = OpLabel " "OpMemoryBarrier %b !3999\n") ->module() ->ComputeIdBound()); } TEST(ModuleTest, OstreamOperator) { const std::string text = R"(OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %7 "restrict" OpDecorate %8 Restrict %9 = OpTypeVoid %10 = OpTypeInt 32 0 %11 = OpTypeStruct %10 %10 %12 = OpTypePointer Function %10 %13 = OpTypePointer Function %11 %14 = OpConstant %10 0 %15 = OpConstant %10 1 %7 = OpTypeFunction %9 %1 = OpFunction %9 None %7 %2 = OpLabel %8 = OpVariable %13 Function %3 = OpAccessChain %12 %8 %14 %4 = OpLoad %10 %3 %5 = OpAccessChain %12 %8 %15 %6 = OpLoad %10 %5 OpReturn OpFunctionEnd)"; std::string s; std::ostringstream str(s); str << *BuildModule(text)->module(); EXPECT_EQ(text, str.str()); } TEST(ModuleTest, OstreamOperatorInt64) { const std::string text = R"(OpCapability Shader OpCapability Linkage OpCapability Int64 OpMemoryModel Logical GLSL450 OpName %7 "restrict" OpDecorate %5 Restrict %9 = OpTypeVoid %10 = OpTypeInt 64 0 %11 = OpTypeStruct %10 %10 %12 = OpTypePointer Function %10 %13 = OpTypePointer Function %11 %14 = OpConstant %10 0 %15 = OpConstant %10 1 %16 = OpConstant %10 4294967297 %7 = OpTypeFunction %9 %1 = OpFunction %9 None %7 %2 = OpLabel %5 = OpVariable %12 Function %6 = OpLoad %10 %5 OpSelectionMerge %3 None OpSwitch %6 %3 4294967297 %4 %4 = OpLabel OpBranch %3 %3 = OpLabel OpReturn OpFunctionEnd)"; std::string s; std::ostringstream str(s); str << *BuildModule(text)->module(); EXPECT_EQ(text, str.str()); } TEST(ModuleTest, IdBoundTestAtLimit) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpFunction %1 None %2 %4 = OpLabel OpReturn OpFunctionEnd)"; std::unique_ptr context = BuildModule(text); uint32_t current_bound = context->module()->id_bound(); context->set_max_id_bound(current_bound); uint32_t next_id_bound = context->module()->TakeNextIdBound(); EXPECT_EQ(next_id_bound, 0); EXPECT_EQ(current_bound, context->module()->id_bound()); next_id_bound = context->module()->TakeNextIdBound(); EXPECT_EQ(next_id_bound, 0); } TEST(ModuleTest, IdBoundTestBelowLimit) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpFunction %1 None %2 %4 = OpLabel OpReturn OpFunctionEnd)"; std::unique_ptr context = BuildModule(text); uint32_t current_bound = context->module()->id_bound(); context->set_max_id_bound(current_bound + 100); uint32_t next_id_bound = context->module()->TakeNextIdBound(); EXPECT_EQ(next_id_bound, current_bound); EXPECT_EQ(current_bound + 1, context->module()->id_bound()); next_id_bound = context->module()->TakeNextIdBound(); EXPECT_EQ(next_id_bound, current_bound + 1); } TEST(ModuleTest, IdBoundTestNearLimit) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpFunction %1 None %2 %4 = OpLabel OpReturn OpFunctionEnd)"; std::unique_ptr context = BuildModule(text); uint32_t current_bound = context->module()->id_bound(); context->set_max_id_bound(current_bound + 1); uint32_t next_id_bound = context->module()->TakeNextIdBound(); EXPECT_EQ(next_id_bound, current_bound); EXPECT_EQ(current_bound + 1, context->module()->id_bound()); next_id_bound = context->module()->TakeNextIdBound(); EXPECT_EQ(next_id_bound, 0); } TEST(ModuleTest, IdBoundTestUIntMax) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpFunction %1 None %2 %4294967294 = OpLabel ; ID is UINT_MAX-1 OpReturn OpFunctionEnd)"; std::unique_ptr context = BuildModule(text); uint32_t current_bound = context->module()->id_bound(); // Expecting |BuildModule| to preserve the numeric ids. EXPECT_EQ(current_bound, std::numeric_limits::max()); context->set_max_id_bound(current_bound); uint32_t next_id_bound = context->module()->TakeNextIdBound(); EXPECT_EQ(next_id_bound, 0); EXPECT_EQ(current_bound, context->module()->id_bound()); } // Tests that "text" does not change when it is assembled, converted into a // module, converted back to a binary, and then disassembled. void AssembleAndDisassemble(const std::string& text) { std::unique_ptr context = BuildModule(text); std::vector binary; context->module()->ToBinary(&binary, false); SpirvTools tools(SPV_ENV_UNIVERSAL_1_1); std::string s; tools.Disassemble(binary, &s); EXPECT_EQ(s, text); } TEST(ModuleTest, TrailingOpLine) { const std::string text = R"(OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %5 = OpString "file.ext" %void = OpTypeVoid %2 = OpTypeFunction %void %3 = OpFunction %void None %2 %4 = OpLabel OpReturn OpFunctionEnd OpLine %5 1 0 )"; AssembleAndDisassemble(text); } TEST(ModuleTest, TrailingOpNoLine) { const std::string text = R"(OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %2 = OpTypeFunction %void %3 = OpFunction %void None %2 %4 = OpLabel OpReturn OpFunctionEnd OpNoLine )"; AssembleAndDisassemble(text); } TEST(ModuleTest, MulitpleTrailingOpLine) { const std::string text = R"(OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %5 = OpString "file.ext" %void = OpTypeVoid %2 = OpTypeFunction %void %3 = OpFunction %void None %2 %4 = OpLabel OpReturn OpFunctionEnd OpLine %5 1 0 OpNoLine OpLine %5 1 1 )"; AssembleAndDisassemble(text); } TEST(ModuleTest, NonSemanticInfoIteration) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpExtension "SPV_KHR_non_semantic_info" %1 = OpExtInstImport "NonSemantic.Test" OpMemoryModel Logical GLSL450 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpExtInst %2 %1 1 %5 = OpFunction %2 None %3 %6 = OpLabel %7 = OpExtInst %2 %1 1 OpReturn OpFunctionEnd %8 = OpExtInst %2 %1 1 %9 = OpFunction %2 None %3 %10 = OpLabel %11 = OpExtInst %2 %1 1 OpReturn OpFunctionEnd %12 = OpExtInst %2 %1 1 )"; std::unique_ptr context = BuildModule(text); std::unordered_set non_semantic_ids; context->module()->ForEachInst( [&non_semantic_ids](const Instruction* inst) { if (inst->opcode() == spv::Op::OpExtInst) { non_semantic_ids.insert(inst->result_id()); } }, false); EXPECT_EQ(1, non_semantic_ids.count(4)); EXPECT_EQ(1, non_semantic_ids.count(7)); EXPECT_EQ(1, non_semantic_ids.count(8)); EXPECT_EQ(1, non_semantic_ids.count(11)); EXPECT_EQ(1, non_semantic_ids.count(12)); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/module_utils.h000066400000000000000000000020601475742701700231660ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef TEST_OPT_MODULE_UTILS_H_ #define TEST_OPT_MODULE_UTILS_H_ #include #include "source/opt/module.h" #include "gtest/gtest.h" namespace spvtest { inline uint32_t GetIdBound(const spvtools::opt::Module& m) { std::vector binary; m.ToBinary(&binary, false); // The 5-word header must always exist. EXPECT_LE(5u, binary.size()); // The bound is the fourth word. return binary[3]; } } // namespace spvtest #endif // TEST_OPT_MODULE_UTILS_H_ KhronosGroup-SPIRV-Tools-f289d04/test/opt/opextinst_forward_ref_fixup_pass_test.cpp000066400000000000000000000366101475742701700307410ustar00rootroot00000000000000// Copyright (c) 2024 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "spirv-tools/optimizer.hpp" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using OpExtInstForwardRefFixupPassTest = PassTest<::testing::Test>; TEST_F(OpExtInstForwardRefFixupPassTest, NoChangeWithougExtendedInstructions) { const std::string kTest = R"( ; CHECK-NOT: SomeOpcode OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %3 = OpTypeFunction %void %main = OpFunction %void None %3 %6 = OpLabel OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch( kTest, /* do_validation= */ true); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(OpExtInstForwardRefFixupPassTest, NoForwardRef_NoChange) { const std::string kTest = R"(OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %1 = OpExtInstImport "NonSemantic.Shader.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %3 = OpString "/usr/local/google/home/nathangauer/projects/DirectXShaderCompiler/repro.hlsl" %4 = OpString "// RUN: %dxc -T cs_6_0 %s -E main -spirv -fspv-target-env=vulkan1.1 -fspv-debug=vulkan-with-source | FileCheck %s [numthreads(1, 1, 1)] void main() { } " %5 = OpString "main" %6 = OpString "" %7 = OpString "3f3d3740" %8 = OpString " -E main -T cs_6_0 -spirv -fspv-target-env=vulkan1.1 -fspv-debug=vulkan-with-source -Qembed_debug" OpName %main "main" %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_3 = OpConstant %uint 3 %uint_1 = OpConstant %uint 1 %uint_4 = OpConstant %uint 4 %uint_5 = OpConstant %uint 5 %15 = OpTypeFunction %void %16 = OpExtInst %void %1 DebugTypeFunction %uint_3 %void %17 = OpExtInst %void %1 DebugSource %3 %4 %18 = OpExtInst %void %1 DebugCompilationUnit %uint_1 %uint_4 %17 %uint_5 %19 = OpExtInst %void %1 DebugFunction %5 %16 %17 %uint_4 %uint_1 %18 %6 %uint_3 %uint_4 %20 = OpExtInst %void %1 DebugEntryPoint %19 %18 %7 %8 %main = OpFunction %void None %15 %21 = OpLabel %22 = OpExtInst %void %1 DebugFunctionDefinition %19 %main %23 = OpExtInst %void %1 DebugLine %17 %uint_5 %uint_5 %uint_1 %uint_1 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck( kTest, kTest, /* skip_nop= */ false); } TEST_F(OpExtInstForwardRefFixupPassTest, NoForwardRef_ReplaceOpExtInstWithForwardWithOpExtInst) { const std::string kTest = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" OpExtension "SPV_KHR_relaxed_extended_instruction" ; CHECK-NOT: OpExtension "SPV_KHR_relaxed_extended_instruction" %1 = OpExtInstImport "NonSemantic.Shader.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %3 = OpString "/usr/local/google/home/nathangauer/projects/DirectXShaderCompiler/repro.hlsl" %4 = OpString "// RUN: %dxc -T cs_6_0 %s -E main -spirv -fspv-target-env=vulkan1.1 -fspv-debug=vulkan-with-source | FileCheck %s [numthreads(1, 1, 1)] void main() { } " %5 = OpString "main" %6 = OpString "" %7 = OpString "3f3d3740" %8 = OpString " -E main -T cs_6_0 -spirv -fspv-target-env=vulkan1.1 -fspv-debug=vulkan-with-source -Qembed_debug" OpName %main "main" %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_3 = OpConstant %uint 3 %uint_1 = OpConstant %uint 1 %uint_4 = OpConstant %uint 4 %uint_5 = OpConstant %uint 5 %20 = OpTypeFunction %void %10 = OpExtInstWithForwardRefsKHR %void %1 DebugTypeFunction %uint_3 %void %12 = OpExtInstWithForwardRefsKHR %void %1 DebugSource %3 %4 %13 = OpExtInstWithForwardRefsKHR %void %1 DebugCompilationUnit %uint_1 %uint_4 %12 %uint_5 %17 = OpExtInstWithForwardRefsKHR %void %1 DebugFunction %5 %10 %12 %uint_4 %uint_1 %13 %6 %uint_3 %uint_4 %18 = OpExtInstWithForwardRefsKHR %void %1 DebugEntryPoint %17 %13 %7 %8 ; CHECK-NOT: {{.*}} = OpExtInstWithForwardRefsKHR %void %1 DebugTypeFunction %uint_3 %void ; CHECK-NOT: {{.*}} = OpExtInstWithForwardRefsKHR %void %1 DebugSource {{.*}} {{.*}} ; CHECK-NOT: {{.*}} = OpExtInstWithForwardRefsKHR %void %1 DebugCompilationUnit %uint_1 %uint_4 {{.*}} %uint_5 ; CHECK-NOT: {{.*}} = OpExtInstWithForwardRefsKHR %void %1 DebugFunction {{.*}} {{.*}} {{.*}} %uint_4 %uint_1 {{.*}} {{.*}} %uint_3 %uint_4 ; CHECK-NOT: {{.*}} = OpExtInstWithForwardRefsKHR %void %1 DebugEntryPoint {{.*}} {{.*}} {{.*}} {{.*}} ; CHECK: {{.*}} = OpExtInst %void %1 DebugTypeFunction %uint_3 %void ; CHECK: {{.*}} = OpExtInst %void %1 DebugSource {{.*}} {{.*}} ; CHECK: {{.*}} = OpExtInst %void %1 DebugCompilationUnit %uint_1 %uint_4 {{.*}} %uint_5 ; CHECK: {{.*}} = OpExtInst %void %1 DebugFunction {{.*}} {{.*}} {{.*}} %uint_4 %uint_1 {{.*}} {{.*}} %uint_3 %uint_4 ; CHECK: {{.*}} = OpExtInst %void %1 DebugEntryPoint {{.*}} {{.*}} {{.*}} {{.*}} %main = OpFunction %void None %20 %21 = OpLabel %22 = OpExtInst %void %1 DebugFunctionDefinition %17 %main %23 = OpExtInst %void %1 DebugLine %12 %uint_5 %uint_5 %uint_1 %uint_1 ; CHECK: {{.*}} = OpExtInst %void %1 DebugFunctionDefinition {{.*}} %main ; CHECK: {{.*}} = OpExtInst %void %1 DebugLine {{.*}} %uint_5 %uint_5 %uint_1 %uint_1 OpReturn OpFunctionEnd )"; const auto result = SinglePassRunAndMatch( kTest, /* do_validation= */ true); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(OpExtInstForwardRefFixupPassTest, ForwardRefs_NoChange) { const std::string kTest = R"(OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" OpExtension "SPV_KHR_relaxed_extended_instruction" %1 = OpExtInstImport "NonSemantic.Shader.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %3 = OpString "/usr/local/google/home/nathangauer/projects/DirectXShaderCompiler/repro.hlsl" %4 = OpString "// RUN: %dxc -T cs_6_0 %s -E main -spirv -fspv-target-env=vulkan1.1 -fspv-debug=vulkan-with-source | FileCheck %s class A { void foo() { } }; [numthreads(1, 1, 1)] void main() { A a; a.foo(); } " %5 = OpString "A" %6 = OpString "A.foo" %7 = OpString "" %8 = OpString "this" %9 = OpString "main" %10 = OpString "a" %11 = OpString "d59ae9c2" %12 = OpString " -E main -T cs_6_0 -spirv -fspv-target-env=vulkan1.1 -fspv-debug=vulkan-with-source -Vd -Qembed_debug" OpName %main "main" OpName %A "A" %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %uint_4 = OpConstant %uint 4 %uint_5 = OpConstant %uint 5 %uint_0 = OpConstant %uint 0 %uint_3 = OpConstant %uint 3 %uint_7 = OpConstant %uint 7 %uint_288 = OpConstant %uint 288 %uint_9 = OpConstant %uint 9 %uint_13 = OpConstant %uint 13 %uint_10 = OpConstant %uint 10 %26 = OpTypeFunction %void %uint_12 = OpConstant %uint 12 %A = OpTypeStruct %_ptr_Function_A = OpTypePointer Function %A %uint_11 = OpConstant %uint 11 %30 = OpExtInst %void %1 DebugExpression %31 = OpExtInst %void %1 DebugSource %3 %4 %32 = OpExtInst %void %1 DebugCompilationUnit %uint_1 %uint_4 %31 %uint_5 %33 = OpExtInstWithForwardRefsKHR %void %1 DebugTypeComposite %5 %uint_0 %31 %uint_3 %uint_7 %32 %5 %uint_0 %uint_3 %34 %35 = OpExtInst %void %1 DebugTypeFunction %uint_3 %void %33 %34 = OpExtInst %void %1 DebugFunction %6 %35 %31 %uint_4 %uint_3 %33 %7 %uint_3 %uint_4 %36 = OpExtInst %void %1 DebugLocalVariable %8 %33 %31 %uint_4 %uint_3 %34 %uint_288 %uint_1 %37 = OpExtInst %void %1 DebugTypeFunction %uint_3 %void %38 = OpExtInst %void %1 DebugFunction %9 %37 %31 %uint_9 %uint_1 %32 %7 %uint_3 %uint_9 %39 = OpExtInst %void %1 DebugLexicalBlock %31 %uint_9 %uint_13 %38 %40 = OpExtInst %void %1 DebugLocalVariable %10 %33 %31 %uint_10 %uint_5 %39 %uint_4 %41 = OpExtInst %void %1 DebugEntryPoint %38 %32 %11 %12 %42 = OpExtInst %void %1 DebugInlinedAt %uint_11 %39 %main = OpFunction %void None %26 %43 = OpLabel %44 = OpVariable %_ptr_Function_A Function %45 = OpExtInst %void %1 DebugFunctionDefinition %38 %main %57 = OpExtInst %void %1 DebugScope %39 %47 = OpExtInst %void %1 DebugLine %31 %uint_10 %uint_10 %uint_3 %uint_5 %48 = OpExtInst %void %1 DebugDeclare %40 %44 %30 %58 = OpExtInst %void %1 DebugScope %34 %42 %50 = OpExtInst %void %1 DebugLine %31 %uint_4 %uint_5 %uint_3 %uint_3 %51 = OpExtInst %void %1 DebugDeclare %36 %44 %30 %59 = OpExtInst %void %1 DebugNoScope %53 = OpExtInst %void %1 DebugLine %31 %uint_12 %uint_12 %uint_1 %uint_1 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck( kTest, kTest, /* skip_nop= */ false); } TEST_F(OpExtInstForwardRefFixupPassTest, ForwardRefs_ReplaceOpExtInstWithOpExtInstWithForwardRefs) { const std::string kTest = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" ; CHECK: OpExtension "SPV_KHR_relaxed_extended_instruction" %1 = OpExtInstImport "NonSemantic.Shader.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %3 = OpString "/usr/local/google/home/nathangauer/projects/DirectXShaderCompiler/repro.hlsl" %4 = OpString "// RUN: %dxc -T cs_6_0 %s -E main -spirv -fspv-target-env=vulkan1.1 -fspv-debug=vulkan-with-source | FileCheck %s class A { void foo() { } }; [numthreads(1, 1, 1)] void main() { A a; a.foo(); } " %5 = OpString "A" %6 = OpString "A.foo" %7 = OpString "" %8 = OpString "this" %9 = OpString "main" %10 = OpString "a" %11 = OpString "d59ae9c2" %12 = OpString " -E main -T cs_6_0 -spirv -fspv-target-env=vulkan1.1 -fspv-debug=vulkan-with-source -Vd -Qembed_debug" OpName %main "main" OpName %A "A" %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %uint_4 = OpConstant %uint 4 %uint_5 = OpConstant %uint 5 %uint_0 = OpConstant %uint 0 %uint_3 = OpConstant %uint 3 %uint_7 = OpConstant %uint 7 %uint_288 = OpConstant %uint 288 %uint_9 = OpConstant %uint 9 %uint_13 = OpConstant %uint 13 %uint_10 = OpConstant %uint 10 %40 = OpTypeFunction %void %uint_12 = OpConstant %uint 12 %A = OpTypeStruct %_ptr_Function_A = OpTypePointer Function %A %uint_11 = OpConstant %uint 11 %15 = OpExtInst %void %1 DebugExpression %16 = OpExtInst %void %1 DebugSource %3 %4 %17 = OpExtInst %void %1 DebugCompilationUnit %uint_1 %uint_4 %16 %uint_5 %21 = OpExtInst %void %1 DebugTypeComposite %5 %uint_0 %16 %uint_3 %uint_7 %17 %5 %uint_0 %uint_3 %25 %26 = OpExtInst %void %1 DebugTypeFunction %uint_3 %void %21 %25 = OpExtInst %void %1 DebugFunction %6 %26 %16 %uint_4 %uint_3 %21 %7 %uint_3 %uint_4 %27 = OpExtInst %void %1 DebugLocalVariable %8 %21 %16 %uint_4 %uint_3 %25 %uint_288 %uint_1 %29 = OpExtInst %void %1 DebugTypeFunction %uint_3 %void %30 = OpExtInst %void %1 DebugFunction %9 %29 %16 %uint_9 %uint_1 %17 %7 %uint_3 %uint_9 %32 = OpExtInst %void %1 DebugLexicalBlock %16 %uint_9 %uint_13 %30 %34 = OpExtInst %void %1 DebugLocalVariable %10 %21 %16 %uint_10 %uint_5 %32 %uint_4 %36 = OpExtInst %void %1 DebugEntryPoint %30 %17 %11 %12 %37 = OpExtInst %void %1 DebugInlinedAt %uint_11 %32 ; CHECK: {{.*}} = OpExtInst %void %1 DebugExpression ; CHECK: {{.*}} = OpExtInst %void %1 DebugSource ; CHECK: {{.*}} = OpExtInst %void %1 DebugCompilationUnit ; CHECK: {{.*}} = OpExtInstWithForwardRefsKHR %void {{.*}} DebugTypeComposite ; CHECK-NOT: {{.*}} = OpExtInst %void {{.*}} DebugTypeComposite ; CHECK: {{.*}} = OpExtInst %void %1 DebugTypeFunction ; CHECK: {{.*}} = OpExtInst %void %1 DebugFunction ; CHECK: {{.*}} = OpExtInst %void %1 DebugLocalVariable ; CHECK: {{.*}} = OpExtInst %void %1 DebugTypeFunction ; CHECK: {{.*}} = OpExtInst %void %1 DebugFunction ; CHECK: {{.*}} = OpExtInst %void %1 DebugLexicalBlock ; CHECK: {{.*}} = OpExtInst %void %1 DebugLocalVariable ; CHECK: {{.*}} = OpExtInst %void %1 DebugEntryPoint ; CHECK: {{.*}} = OpExtInst %void %1 DebugInlinedAt %main = OpFunction %void None %40 %43 = OpLabel %44 = OpVariable %_ptr_Function_A Function %45 = OpExtInst %void %1 DebugFunctionDefinition %30 %main %51 = OpExtInst %void %1 DebugScope %32 %46 = OpExtInst %void %1 DebugLine %16 %uint_10 %uint_10 %uint_3 %uint_5 %47 = OpExtInst %void %1 DebugDeclare %34 %44 %15 %52 = OpExtInst %void %1 DebugScope %25 %37 %48 = OpExtInst %void %1 DebugLine %16 %uint_4 %uint_5 %uint_3 %uint_3 %49 = OpExtInst %void %1 DebugDeclare %27 %44 %15 %53 = OpExtInst %void %1 DebugNoScope %50 = OpExtInst %void %1 DebugLine %16 %uint_12 %uint_12 %uint_1 %uint_1 ; CHECK: {{.*}} = OpExtInst %void %1 DebugFunctionDefinition ; CHECK: {{.*}} = OpExtInst %void %1 DebugScope ; CHECK: {{.*}} = OpExtInst %void %1 DebugLine ; CHECK: {{.*}} = OpExtInst %void %1 DebugDeclare ; CHECK: {{.*}} = OpExtInst %void %1 DebugScope ; CHECK: {{.*}} = OpExtInst %void %1 DebugLine ; CHECK: {{.*}} = OpExtInst %void %1 DebugDeclare ; CHECK: {{.*}} = OpExtInst %void %1 DebugNoScope ; CHECK: {{.*}} = OpExtInst %void %1 DebugLine OpReturn OpFunctionEnd )"; const auto result = SinglePassRunAndMatch( kTest, /* do_validation= */ true); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/optimizer_test.cpp000066400000000000000000000274261475742701700241120ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gmock/gmock.h" #include "spirv-tools/libspirv.hpp" #include "spirv-tools/optimizer.hpp" #include "test/opt/pass_fixture.h" namespace spvtools { namespace opt { namespace { using ::testing::Eq; // Return a string that contains the minimum instructions needed to form // a valid module. Other instructions can be appended to this string. std::string Header() { return R"(OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 )"; } TEST(Optimizer, CanRunNullPassWithDistinctInputOutputVectors) { SpirvTools tools(SPV_ENV_UNIVERSAL_1_0); std::vector binary_in; tools.Assemble(Header() + "OpName %foo \"foo\"\n%foo = OpTypeVoid", &binary_in); Optimizer opt(SPV_ENV_UNIVERSAL_1_0); opt.RegisterPass(CreateNullPass()); std::vector binary_out; opt.Run(binary_in.data(), binary_in.size(), &binary_out); std::string disassembly; tools.Disassemble(binary_out.data(), binary_out.size(), &disassembly); EXPECT_THAT(disassembly, Eq(Header() + "OpName %foo \"foo\"\n%foo = OpTypeVoid\n")); } TEST(Optimizer, CanRunTransformingPassWithDistinctInputOutputVectors) { SpirvTools tools(SPV_ENV_UNIVERSAL_1_0); std::vector binary_in; tools.Assemble(Header() + "OpName %foo \"foo\"\n%foo = OpTypeVoid", &binary_in); Optimizer opt(SPV_ENV_UNIVERSAL_1_0); opt.RegisterPass(CreateStripDebugInfoPass()); std::vector binary_out; opt.Run(binary_in.data(), binary_in.size(), &binary_out); std::string disassembly; tools.Disassemble(binary_out.data(), binary_out.size(), &disassembly); EXPECT_THAT(disassembly, Eq(Header() + "%void = OpTypeVoid\n")); } TEST(Optimizer, CanRunNullPassWithAliasedVectors) { SpirvTools tools(SPV_ENV_UNIVERSAL_1_0); std::vector binary; tools.Assemble("OpName %foo \"foo\"\n%foo = OpTypeVoid", &binary); Optimizer opt(SPV_ENV_UNIVERSAL_1_0); opt.RegisterPass(CreateNullPass()); opt.Run(binary.data(), binary.size(), &binary); // This is the key. std::string disassembly; tools.Disassemble(binary.data(), binary.size(), &disassembly); EXPECT_THAT(disassembly, Eq("OpName %foo \"foo\"\n%foo = OpTypeVoid\n")); } TEST(Optimizer, CanRunNullPassWithAliasedVectorDataButDifferentSize) { SpirvTools tools(SPV_ENV_UNIVERSAL_1_0); std::vector binary; tools.Assemble(Header() + "OpName %foo \"foo\"\n%foo = OpTypeVoid", &binary); Optimizer opt(SPV_ENV_UNIVERSAL_1_0); opt.RegisterPass(CreateNullPass()); auto orig_size = binary.size(); // Now change the size. Add a word that will be ignored // by the optimizer. binary.push_back(42); EXPECT_THAT(orig_size + 1, Eq(binary.size())); opt.Run(binary.data(), orig_size, &binary); // This is the key. // The binary vector should have been rewritten. EXPECT_THAT(binary.size(), Eq(orig_size)); std::string disassembly; tools.Disassemble(binary.data(), binary.size(), &disassembly); EXPECT_THAT(disassembly, Eq(Header() + "OpName %foo \"foo\"\n%foo = OpTypeVoid\n")); } TEST(Optimizer, CanRunTransformingPassWithAliasedVectors) { SpirvTools tools(SPV_ENV_UNIVERSAL_1_0); std::vector binary; tools.Assemble(Header() + "OpName %foo \"foo\"\n%foo = OpTypeVoid", &binary); Optimizer opt(SPV_ENV_UNIVERSAL_1_0); opt.RegisterPass(CreateStripDebugInfoPass()); opt.Run(binary.data(), binary.size(), &binary); // This is the key std::string disassembly; tools.Disassemble(binary.data(), binary.size(), &disassembly); EXPECT_THAT(disassembly, Eq(Header() + "%void = OpTypeVoid\n")); } TEST(Optimizer, CanValidateFlags) { Optimizer opt(SPV_ENV_UNIVERSAL_1_0); EXPECT_FALSE(opt.FlagHasValidForm("bad-flag")); EXPECT_TRUE(opt.FlagHasValidForm("-O")); EXPECT_TRUE(opt.FlagHasValidForm("-Os")); EXPECT_FALSE(opt.FlagHasValidForm("-O2")); EXPECT_TRUE(opt.FlagHasValidForm("--this_flag")); } TEST(Optimizer, CanRegisterPassesFromFlags) { SpirvTools tools(SPV_ENV_UNIVERSAL_1_0); Optimizer opt(SPV_ENV_UNIVERSAL_1_0); spv_message_level_t msg_level; const char* msg_fname; spv_position_t msg_position; const char* msg; auto examine_message = [&msg_level, &msg_fname, &msg_position, &msg]( spv_message_level_t ml, const char* f, const spv_position_t& p, const char* m) { msg_level = ml; msg_fname = f; msg_position = p; msg = m; }; opt.SetMessageConsumer(examine_message); std::vector pass_flags = { "--strip-debug", "--strip-nonsemantic", "--set-spec-const-default-value=23:42 21:12", "--if-conversion", "--freeze-spec-const", "--inline-entry-points-exhaustive", "--inline-entry-points-opaque", "--convert-local-access-chains", "--eliminate-dead-code-aggressive", "--eliminate-insert-extract", "--eliminate-local-single-block", "--eliminate-local-single-store", "--merge-blocks", "--merge-return", "--eliminate-dead-branches", "--eliminate-dead-functions", "--eliminate-local-multi-store", "--eliminate-dead-const", "--eliminate-dead-inserts", "--eliminate-dead-variables", "--fold-spec-const-op-composite", "--loop-unswitch", "--scalar-replacement=300", "--scalar-replacement", "--strength-reduction", "--unify-const", "--flatten-decorations", "--compact-ids", "--cfg-cleanup", "--local-redundancy-elimination", "--loop-invariant-code-motion", "--reduce-load-size", "--redundancy-elimination", "--private-to-local", "--remove-duplicates", "--workaround-1209", "--replace-invalid-opcode", "--simplify-instructions", "--ssa-rewrite", "--copy-propagate-arrays", "--loop-fission=20", "--loop-fusion=2", "--loop-unroll", "--vector-dce", "--loop-unroll-partial=3", "--loop-peeling", "--ccp", "-O", "-Os", "--legalize-hlsl"}; EXPECT_TRUE(opt.RegisterPassesFromFlags(pass_flags)); // Test some invalid flags. EXPECT_FALSE(opt.RegisterPassFromFlag("-O2")); EXPECT_EQ(msg_level, SPV_MSG_ERROR); EXPECT_FALSE(opt.RegisterPassFromFlag("-loop-unroll")); EXPECT_EQ(msg_level, SPV_MSG_ERROR); EXPECT_FALSE(opt.RegisterPassFromFlag("--set-spec-const-default-value")); EXPECT_EQ(msg_level, SPV_MSG_ERROR); EXPECT_FALSE(opt.RegisterPassFromFlag("--scalar-replacement=s")); EXPECT_EQ(msg_level, SPV_MSG_ERROR); EXPECT_FALSE(opt.RegisterPassFromFlag("--loop-fission=-4")); EXPECT_EQ(msg_level, SPV_MSG_ERROR); EXPECT_FALSE(opt.RegisterPassFromFlag("--loop-fusion=xx")); EXPECT_EQ(msg_level, SPV_MSG_ERROR); EXPECT_FALSE(opt.RegisterPassFromFlag("--loop-unroll-partial")); EXPECT_EQ(msg_level, SPV_MSG_ERROR); } TEST(Optimizer, RemoveNop) { // Test that OpNops are removed even if no optimizations are run. const std::string before = R"(OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %2 = OpTypeFunction %void %3 = OpFunction %void None %2 %4 = OpLabel OpNop OpReturn OpFunctionEnd )"; const std::string after = R"(OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %2 = OpTypeFunction %void %3 = OpFunction %void None %2 %4 = OpLabel OpReturn OpFunctionEnd )"; std::vector binary; { SpirvTools tools(SPV_ENV_VULKAN_1_1); tools.Assemble(before, &binary); } Optimizer opt(SPV_ENV_VULKAN_1_1); std::vector optimized; class ValidatorOptions validator_options; ASSERT_TRUE(opt.Run(binary.data(), binary.size(), &optimized, validator_options, true)) << before << "\n"; std::string disassembly; { SpirvTools tools(SPV_ENV_VULKAN_1_1); tools.Disassemble(optimized.data(), optimized.size(), &disassembly); } EXPECT_EQ(after, disassembly) << "Was expecting the OpNop to have been removed."; } TEST(Optimizer, AvoidIntegrityCheckForExtraLineInfo) { // Test that it avoids the integrity check when no optimizations are run and // OpLines are propagated. const std::string before = R"(OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpString "Test" %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_ptr_Function_uint = OpTypePointer Function %uint %6 = OpFunction %void None %3 %7 = OpLabel OpLine %1 10 0 %8 = OpVariable %_ptr_Function_uint Function OpLine %1 10 0 %9 = OpVariable %_ptr_Function_uint Function OpLine %1 20 0 OpReturn OpFunctionEnd )"; const std::string after = R"(OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpString "Test" %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_ptr_Function_uint = OpTypePointer Function %uint %6 = OpFunction %void None %3 %7 = OpLabel OpLine %1 10 0 %8 = OpVariable %_ptr_Function_uint Function %9 = OpVariable %_ptr_Function_uint Function OpLine %1 20 0 OpReturn OpFunctionEnd )"; std::vector binary; SpirvTools tools(SPV_ENV_VULKAN_1_1); tools.Assemble(before, &binary); Optimizer opt(SPV_ENV_VULKAN_1_1); std::vector optimized; class ValidatorOptions validator_options; ASSERT_TRUE(opt.Run(binary.data(), binary.size(), &optimized, validator_options, true)) << before << "\n"; std::string disassembly; tools.Disassemble(optimized.data(), optimized.size(), &disassembly); EXPECT_EQ(after, disassembly) << "Was expecting the OpLine to have been propagated."; } TEST(Optimizer, AvoidIntegrityCheckForDebugScope) { // Test that it avoids the integrity check when the code contains DebugScope. const std::string before = R"(OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %3 = OpString "simple_vs.hlsl" OpSource HLSL 600 %3 OpName %main "main" %void = OpTypeVoid %5 = OpTypeFunction %void %6 = OpExtInst %void %1 DebugSource %3 %7 = OpExtInst %void %1 DebugCompilationUnit 2 4 %6 HLSL %main = OpFunction %void None %5 %14 = OpLabel %26 = OpExtInst %void %1 DebugScope %7 OpReturn %27 = OpExtInst %void %1 DebugNoScope OpFunctionEnd )"; const std::string after = R"(OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %3 = OpString "simple_vs.hlsl" OpSource HLSL 600 %3 OpName %main "main" %void = OpTypeVoid %5 = OpTypeFunction %void %6 = OpExtInst %void %1 DebugSource %3 %7 = OpExtInst %void %1 DebugCompilationUnit 2 4 %6 HLSL %main = OpFunction %void None %5 %8 = OpLabel %11 = OpExtInst %void %1 DebugScope %7 OpReturn %12 = OpExtInst %void %1 DebugNoScope OpFunctionEnd )"; std::vector binary; SpirvTools tools(SPV_ENV_VULKAN_1_1); tools.Assemble(before, &binary); Optimizer opt(SPV_ENV_VULKAN_1_1); std::vector optimized; ASSERT_TRUE(opt.Run(binary.data(), binary.size(), &optimized)) << before << "\n"; std::string disassembly; tools.Disassemble(optimized.data(), optimized.size(), &disassembly); EXPECT_EQ(after, disassembly) << "Was expecting the result id of DebugScope to have been changed."; } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/pass_fixture.h000066400000000000000000000300471475742701700232030ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef TEST_OPT_PASS_FIXTURE_H_ #define TEST_OPT_PASS_FIXTURE_H_ #include #include #include #include #include #include #include "effcee/effcee.h" #include "gtest/gtest.h" #include "source/opt/build_module.h" #include "source/opt/pass_manager.h" #include "source/opt/passes.h" #include "source/spirv_optimizer_options.h" #include "source/spirv_validator_options.h" #include "source/util/make_unique.h" #include "spirv-tools/libspirv.hpp" namespace spvtools { namespace opt { // Template class for testing passes. It contains some handy utility methods for // running passes and checking results. // // To write value-Parameterized tests: // using ValueParamTest = PassTest<::testing::TestWithParam>; // To use as normal fixture: // using FixtureTest = PassTest<::testing::Test>; template class PassTest : public TestT { public: PassTest() : consumer_( [](spv_message_level_t, const char*, const spv_position_t&, const char* message) { std::cerr << message << std::endl; }), context_(nullptr), manager_(new PassManager()), assemble_options_(SpirvTools::kDefaultAssembleOption), disassemble_options_(SpirvTools::kDefaultDisassembleOption), env_(SPV_ENV_UNIVERSAL_1_3) {} // Runs the given |pass| on the binary assembled from the |original|. // Returns a tuple of the optimized binary and the boolean value returned // from pass Process() function. std::tuple, Pass::Status> OptimizeToBinary( Pass* pass, const std::string& original, bool skip_nop) { context_ = BuildModule(env_, consumer_, original, assemble_options_); EXPECT_NE(nullptr, context()) << "Assembling failed for shader:\n" << original << std::endl; if (!context()) { return std::make_tuple(std::vector(), Pass::Status::Failure); } context()->set_preserve_bindings(OptimizerOptions()->preserve_bindings_); context()->set_preserve_spec_constants( OptimizerOptions()->preserve_spec_constants_); const auto status = pass->Run(context()); std::vector binary; if (status != Pass::Status::Failure) { context()->module()->ToBinary(&binary, skip_nop); } return std::make_tuple(binary, status); } // Runs a single pass of class |PassT| on the binary assembled from the // |assembly|. Returns a tuple of the optimized binary and the boolean value // from the pass Process() function. template std::tuple, Pass::Status> SinglePassRunToBinary( const std::string& assembly, bool skip_nop, Args&&... args) { auto pass = MakeUnique(std::forward(args)...); pass->SetMessageConsumer(consumer_); return OptimizeToBinary(pass.get(), assembly, skip_nop); } // Runs a single pass of class |PassT| on the binary assembled from the // |assembly|, disassembles the optimized binary. Returns a tuple of // disassembly string and the boolean value from the pass Process() function. template std::tuple SinglePassRunAndDisassemble( const std::string& assembly, bool skip_nop, bool do_validation, Args&&... args) { std::vector optimized_bin; auto status = Pass::Status::SuccessWithoutChange; std::tie(optimized_bin, status) = SinglePassRunToBinary( assembly, skip_nop, std::forward(args)...); if (do_validation) { spv_context spvContext = spvContextCreate(env_); spv_diagnostic diagnostic = nullptr; spv_const_binary_t binary = {optimized_bin.data(), optimized_bin.size()}; spv_result_t error = spvValidateWithOptions( spvContext, ValidatorOptions(), &binary, &diagnostic); EXPECT_EQ(error, 0); if (error != 0) spvDiagnosticPrint(diagnostic); spvDiagnosticDestroy(diagnostic); spvContextDestroy(spvContext); } std::string optimized_asm; SpirvTools tools(env_); EXPECT_TRUE( tools.Disassemble(optimized_bin, &optimized_asm, disassemble_options_)) << "Disassembling failed for shader:\n" << assembly << std::endl; return std::make_tuple(optimized_asm, status); } // Runs a single pass of class |PassT| on the binary assembled from the // |original| assembly, and checks whether the optimized binary can be // disassembled to the |expected| assembly. Optionally will also validate // the optimized binary. This does *not* involve pass manager. Callers // are suggested to use SCOPED_TRACE() for better messages. template void SinglePassRunAndCheck(const std::string& original, const std::string& expected, bool skip_nop, bool do_validation, Args&&... args) { std::vector optimized_bin; auto status = Pass::Status::SuccessWithoutChange; std::tie(optimized_bin, status) = SinglePassRunToBinary( original, skip_nop, std::forward(args)...); // Check whether the pass returns the correct modification indication. EXPECT_NE(Pass::Status::Failure, status); EXPECT_EQ(original == expected, status == Pass::Status::SuccessWithoutChange); if (do_validation) { spv_context spvContext = spvContextCreate(env_); spv_diagnostic diagnostic = nullptr; spv_const_binary_t binary = {optimized_bin.data(), optimized_bin.size()}; spv_result_t error = spvValidateWithOptions( spvContext, ValidatorOptions(), &binary, &diagnostic); EXPECT_EQ(error, 0); if (error != 0) spvDiagnosticPrint(diagnostic); spvDiagnosticDestroy(diagnostic); spvContextDestroy(spvContext); } std::string optimized_asm; SpirvTools tools(env_); EXPECT_TRUE( tools.Disassemble(optimized_bin, &optimized_asm, disassemble_options_)) << "Disassembling failed for shader:\n" << original << std::endl; EXPECT_EQ(expected, optimized_asm); } // Runs a single pass of class |PassT| on the binary assembled from the // |original| assembly, and checks whether the optimized binary can be // disassembled to the |expected| assembly. This does *not* involve pass // manager. Callers are suggested to use SCOPED_TRACE() for better messages. template void SinglePassRunAndCheck(const std::string& original, const std::string& expected, bool skip_nop, Args&&... args) { SinglePassRunAndCheck(original, expected, skip_nop, false, std::forward(args)...); } // Runs a single pass of class |PassT| on the binary assembled from the // |original| assembly, then runs an Effcee matcher over the disassembled // result, using checks parsed from |original|. Always skips OpNop. // This does *not* involve pass manager. Callers are suggested to use // SCOPED_TRACE() for better messages. // Returns a tuple of disassembly string and the boolean value from the pass // Process() function. template std::tuple SinglePassRunAndMatch( const std::string& original, bool do_validation, Args&&... args) { const bool skip_nop = true; auto pass_result = SinglePassRunAndDisassemble( original, skip_nop, do_validation, std::forward(args)...); auto disassembly = std::get<0>(pass_result); auto match_result = effcee::Match(disassembly, original); EXPECT_EQ(effcee::Result::Status::Ok, match_result.status()) << match_result.message() << "\nChecking result:\n" << disassembly; return pass_result; } // Runs a single pass of class |PassT| on the binary assembled from the // |original| assembly. Check for failure and expect an Effcee matcher // to pass when run on the diagnostic messages. This does *not* involve // pass manager. Callers are suggested to use SCOPED_TRACE() for better // messages. template void SinglePassRunAndFail(const std::string& original, Args&&... args) { context_ = BuildModule(env_, consumer_, original, assemble_options_); EXPECT_NE(nullptr, context()) << "Assembling failed for shader:\n" << original << std::endl; std::ostringstream errs; auto error_consumer = [&errs](spv_message_level_t, const char*, const spv_position_t&, const char* message) { errs << message << std::endl; }; auto pass = MakeUnique(std::forward(args)...); pass->SetMessageConsumer(error_consumer); const auto status = pass->Run(context()); EXPECT_EQ(Pass::Status::Failure, status); auto match_result = effcee::Match(errs.str(), original); EXPECT_EQ(effcee::Result::Status::Ok, match_result.status()) << match_result.message() << "\nChecking messages:\n" << errs.str(); } // Adds a pass to be run. template void AddPass(Args&&... args) { manager_->AddPass(std::forward(args)...); } // Renews the pass manager, including clearing all previously added passes. void RenewPassManger() { manager_ = MakeUnique(); manager_->SetMessageConsumer(consumer_); } // Runs the passes added thus far using a pass manager on the binary assembled // from the |original| assembly, and checks whether the optimized binary can // be disassembled to the |expected| assembly. Callers are suggested to use // SCOPED_TRACE() for better messages. void RunAndCheck(const std::string& original, const std::string& expected) { assert(manager_->NumPasses()); context_ = BuildModule(env_, nullptr, original, assemble_options_); ASSERT_NE(nullptr, context()); context()->set_preserve_bindings(OptimizerOptions()->preserve_bindings_); context()->set_preserve_spec_constants( OptimizerOptions()->preserve_spec_constants_); auto status = manager_->Run(context()); EXPECT_NE(status, Pass::Status::Failure); if (status != Pass::Status::Failure) { std::vector binary; context()->module()->ToBinary(&binary, /* skip_nop = */ false); std::string optimized; SpirvTools tools(env_); EXPECT_TRUE(tools.Disassemble(binary, &optimized, disassemble_options_)); EXPECT_EQ(expected, optimized); } } void SetAssembleOptions(uint32_t assemble_options) { assemble_options_ = assemble_options; } void SetDisassembleOptions(uint32_t disassemble_options) { disassemble_options_ = disassemble_options; } MessageConsumer consumer() { return consumer_; } IRContext* context() { return context_.get(); } void SetMessageConsumer(MessageConsumer msg_consumer) { consumer_ = msg_consumer; } spv_optimizer_options OptimizerOptions() { return &optimizer_options_; } spv_validator_options ValidatorOptions() { return &validator_options_; } void SetTargetEnv(spv_target_env env) { env_ = env; } private: MessageConsumer consumer_; // Message consumer. std::unique_ptr context_; // IR context std::unique_ptr manager_; // The pass manager. uint32_t assemble_options_; uint32_t disassemble_options_; spv_optimizer_options_t optimizer_options_; spv_validator_options_t validator_options_; spv_target_env env_; }; } // namespace opt } // namespace spvtools #endif // TEST_OPT_PASS_FIXTURE_H_ KhronosGroup-SPIRV-Tools-f289d04/test/opt/pass_manager_test.cpp000066400000000000000000000142711475742701700245220ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include #include #include "gmock/gmock.h" #include "source/util/make_unique.h" #include "test/opt/module_utils.h" #include "test/opt/pass_fixture.h" namespace spvtools { namespace opt { namespace { using spvtest::GetIdBound; using ::testing::Eq; // A null pass whose constructors accept arguments class NullPassWithArgs : public NullPass { public: NullPassWithArgs(uint32_t) {} NullPassWithArgs(std::string) {} NullPassWithArgs(const std::vector&) {} NullPassWithArgs(const std::vector&, uint32_t) {} const char* name() const override { return "null-with-args"; } }; TEST(PassManager, Interface) { PassManager manager; EXPECT_EQ(0u, manager.NumPasses()); manager.AddPass(); EXPECT_EQ(1u, manager.NumPasses()); EXPECT_STREQ("strip-debug", manager.GetPass(0)->name()); manager.AddPass(MakeUnique()); EXPECT_EQ(2u, manager.NumPasses()); EXPECT_STREQ("strip-debug", manager.GetPass(0)->name()); EXPECT_STREQ("null", manager.GetPass(1)->name()); manager.AddPass(); EXPECT_EQ(3u, manager.NumPasses()); EXPECT_STREQ("strip-debug", manager.GetPass(0)->name()); EXPECT_STREQ("null", manager.GetPass(1)->name()); EXPECT_STREQ("strip-debug", manager.GetPass(2)->name()); manager.AddPass(1u); manager.AddPass("null pass args"); manager.AddPass(std::initializer_list{1, 2}); manager.AddPass(std::initializer_list{1, 2}, 3); EXPECT_EQ(7u, manager.NumPasses()); EXPECT_STREQ("strip-debug", manager.GetPass(0)->name()); EXPECT_STREQ("null", manager.GetPass(1)->name()); EXPECT_STREQ("strip-debug", manager.GetPass(2)->name()); EXPECT_STREQ("null-with-args", manager.GetPass(3)->name()); EXPECT_STREQ("null-with-args", manager.GetPass(4)->name()); EXPECT_STREQ("null-with-args", manager.GetPass(5)->name()); EXPECT_STREQ("null-with-args", manager.GetPass(6)->name()); } // A pass that appends an OpNop instruction to the debug1 section. class AppendOpNopPass : public Pass { public: const char* name() const override { return "AppendOpNop"; } Status Process() override { context()->AddDebug1Inst(MakeUnique(context())); return Status::SuccessWithChange; } }; // A pass that appends specified number of OpNop instructions to the debug1 // section. class AppendMultipleOpNopPass : public Pass { public: explicit AppendMultipleOpNopPass(uint32_t num_nop) : num_nop_(num_nop) {} const char* name() const override { return "AppendOpNop"; } Status Process() override { for (uint32_t i = 0; i < num_nop_; i++) { context()->AddDebug1Inst(MakeUnique(context())); } return Status::SuccessWithChange; } private: uint32_t num_nop_; }; // A pass that duplicates the last instruction in the debug1 section. class DuplicateInstPass : public Pass { public: const char* name() const override { return "DuplicateInst"; } Status Process() override { auto inst = MakeUnique(*(--context()->debug1_end())); context()->AddDebug1Inst(std::move(inst)); return Status::SuccessWithChange; } }; using PassManagerTest = PassTest<::testing::Test>; TEST_F(PassManagerTest, Run) { const std::string text = "OpMemoryModel Logical GLSL450\nOpSource ESSL 310\n"; AddPass(); AddPass(); RunAndCheck(text, text + "OpNop\nOpNop\n"); RenewPassManger(); AddPass(); AddPass(); RunAndCheck(text, text + "OpNop\nOpNop\n"); RenewPassManger(); AddPass(); AddPass(); RunAndCheck(text, text + "OpSource ESSL 310\nOpNop\n"); RenewPassManger(); AddPass(3); RunAndCheck(text, text + "OpNop\nOpNop\nOpNop\n"); } // A pass that appends an OpTypeVoid instruction that uses a given id. class AppendTypeVoidInstPass : public Pass { public: explicit AppendTypeVoidInstPass(uint32_t result_id) : result_id_(result_id) {} const char* name() const override { return "AppendTypeVoidInstPass"; } Status Process() override { auto inst = MakeUnique(context(), spv::Op::OpTypeVoid, 0, result_id_, std::vector{}); context()->AddType(std::move(inst)); return Status::SuccessWithChange; } private: uint32_t result_id_; }; TEST(PassManager, RecomputeIdBoundAutomatically) { PassManager manager; std::unique_ptr module(new Module()); IRContext context(SPV_ENV_UNIVERSAL_1_2, std::move(module), manager.consumer()); EXPECT_THAT(GetIdBound(*context.module()), Eq(0u)); manager.Run(&context); manager.AddPass(); // With no ID changes, the ID bound does not change. EXPECT_THAT(GetIdBound(*context.module()), Eq(0u)); // Now we force an Id of 100 to be used. manager.AddPass(MakeUnique(100)); EXPECT_THAT(GetIdBound(*context.module()), Eq(0u)); manager.Run(&context); // The Id has been updated automatically, even though the pass // did not update it. EXPECT_THAT(GetIdBound(*context.module()), Eq(101u)); // Try one more time! manager.AddPass(MakeUnique(200)); manager.Run(&context); EXPECT_THAT(GetIdBound(*context.module()), Eq(201u)); // Add another pass, but which uses a lower Id. manager.AddPass(MakeUnique(10)); manager.Run(&context); // The Id stays high. EXPECT_THAT(GetIdBound(*context.module()), Eq(201u)); } } // anonymous namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/pass_merge_return_test.cpp000066400000000000000000002314721475742701700256120ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "spirv-tools/libspirv.hpp" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using MergeReturnPassTest = PassTest<::testing::Test>; TEST_F(MergeReturnPassTest, OneReturn) { const std::string before = R"(OpCapability Addresses OpCapability Kernel OpCapability GenericPointer OpCapability Linkage OpMemoryModel Physical32 OpenCL OpEntryPoint Kernel %1 "simple_kernel" %2 = OpTypeVoid %3 = OpTypeFunction %2 %1 = OpFunction %2 None %3 %4 = OpLabel OpReturn OpFunctionEnd )"; const std::string after = before; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(before, after, false, true); } TEST_F(MergeReturnPassTest, TwoReturnsNoValue) { const std::string before = R"(OpCapability Addresses OpCapability Kernel OpCapability GenericPointer OpCapability Linkage OpMemoryModel Physical32 OpenCL OpEntryPoint Kernel %6 "simple_kernel" %2 = OpTypeVoid %3 = OpTypeBool %4 = OpConstantFalse %3 %1 = OpTypeFunction %2 %6 = OpFunction %2 None %1 %7 = OpLabel OpBranchConditional %4 %8 %9 %8 = OpLabel OpReturn %9 = OpLabel OpReturn OpFunctionEnd )"; const std::string after = R"(OpCapability Addresses OpCapability Kernel OpCapability GenericPointer OpCapability Linkage OpMemoryModel Physical32 OpenCL OpEntryPoint Kernel %6 "simple_kernel" %2 = OpTypeVoid %3 = OpTypeBool %4 = OpConstantFalse %3 %1 = OpTypeFunction %2 %6 = OpFunction %2 None %1 %7 = OpLabel OpBranchConditional %4 %8 %9 %8 = OpLabel OpBranch %10 %9 = OpLabel OpBranch %10 %10 = OpLabel OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(before, after, false, true); } TEST_F(MergeReturnPassTest, DebugTwoReturnsNoValue) { const std::string before = R"(OpCapability Addresses OpCapability Kernel OpCapability GenericPointer OpCapability Linkage %10 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Physical32 OpenCL OpEntryPoint Kernel %6 "simple_kernel" %11 = OpString "test" %2 = OpTypeVoid %3 = OpTypeBool %4 = OpConstantFalse %3 %1 = OpTypeFunction %2 %12 = OpExtInst %2 %10 DebugSource %11 %13 = OpExtInst %2 %10 DebugCompilationUnit 1 4 %12 HLSL %14 = OpExtInst %2 %10 DebugTypeFunction FlagIsProtected|FlagIsPrivate %2 %15 = OpExtInst %2 %10 DebugFunction %11 %14 %12 0 0 %13 %11 FlagIsProtected|FlagIsPrivate 0 %6 %6 = OpFunction %2 None %1 %7 = OpLabel OpBranchConditional %4 %8 %9 %8 = OpLabel %16 = OpExtInst %2 %10 DebugScope %15 OpLine %11 100 0 OpReturn %9 = OpLabel %17 = OpExtInst %2 %10 DebugScope %13 OpLine %11 200 0 OpReturn OpFunctionEnd )"; const std::string after = R"(OpCapability Addresses OpCapability Kernel OpCapability GenericPointer OpCapability Linkage %10 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Physical32 OpenCL OpEntryPoint Kernel %6 "simple_kernel" %11 = OpString "test" %2 = OpTypeVoid %3 = OpTypeBool %4 = OpConstantFalse %3 %1 = OpTypeFunction %2 %12 = OpExtInst %2 %10 DebugSource %11 %13 = OpExtInst %2 %10 DebugCompilationUnit 1 4 %12 HLSL %14 = OpExtInst %2 %10 DebugTypeFunction FlagIsProtected|FlagIsPrivate %2 %15 = OpExtInst %2 %10 DebugFunction %11 %14 %12 0 0 %13 %11 FlagIsProtected|FlagIsPrivate 0 %6 %6 = OpFunction %2 None %1 %7 = OpLabel OpBranchConditional %4 %8 %9 %8 = OpLabel %19 = OpExtInst %2 %10 DebugScope %15 OpLine %11 100 0 OpBranch %18 %20 = OpExtInst %2 %10 DebugNoScope %9 = OpLabel %21 = OpExtInst %2 %10 DebugScope %13 OpLine %11 200 0 OpBranch %18 %22 = OpExtInst %2 %10 DebugNoScope %18 = OpLabel OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(before, after, false, true); } TEST_F(MergeReturnPassTest, TwoReturnsWithValues) { const std::string before = R"(OpCapability Linkage OpCapability Kernel OpMemoryModel Logical OpenCL OpDecorate %7 LinkageAttributes "simple_kernel" Export %1 = OpTypeInt 32 0 %2 = OpTypeBool %3 = OpConstantFalse %2 %4 = OpConstant %1 0 %5 = OpConstant %1 1 %6 = OpTypeFunction %1 %7 = OpFunction %1 None %6 %8 = OpLabel OpBranchConditional %3 %9 %10 %9 = OpLabel OpReturnValue %4 %10 = OpLabel OpReturnValue %5 OpFunctionEnd )"; const std::string after = R"(OpCapability Linkage OpCapability Kernel OpMemoryModel Logical OpenCL OpDecorate %7 LinkageAttributes "simple_kernel" Export %1 = OpTypeInt 32 0 %2 = OpTypeBool %3 = OpConstantFalse %2 %4 = OpConstant %1 0 %5 = OpConstant %1 1 %6 = OpTypeFunction %1 %7 = OpFunction %1 None %6 %8 = OpLabel OpBranchConditional %3 %9 %10 %9 = OpLabel OpBranch %11 %10 = OpLabel OpBranch %11 %11 = OpLabel %12 = OpPhi %1 %4 %9 %5 %10 OpReturnValue %12 OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(before, after, false, true); } TEST_F(MergeReturnPassTest, UnreachableReturnsNoValue) { const std::string before = R"(OpCapability Addresses OpCapability Kernel OpCapability GenericPointer OpCapability Linkage OpMemoryModel Physical32 OpenCL OpEntryPoint Kernel %6 "simple_kernel" %2 = OpTypeVoid %3 = OpTypeBool %4 = OpConstantFalse %3 %1 = OpTypeFunction %2 %6 = OpFunction %2 None %1 %7 = OpLabel OpReturn %8 = OpLabel OpBranchConditional %4 %9 %10 %9 = OpLabel OpReturn %10 = OpLabel OpReturn OpFunctionEnd )"; const std::string after = R"(OpCapability Addresses OpCapability Kernel OpCapability GenericPointer OpCapability Linkage OpMemoryModel Physical32 OpenCL OpEntryPoint Kernel %6 "simple_kernel" %2 = OpTypeVoid %3 = OpTypeBool %4 = OpConstantFalse %3 %1 = OpTypeFunction %2 %6 = OpFunction %2 None %1 %7 = OpLabel OpBranch %11 %8 = OpLabel OpBranchConditional %4 %9 %10 %9 = OpLabel OpBranch %11 %10 = OpLabel OpBranch %11 %11 = OpLabel OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(before, after, false, true); } TEST_F(MergeReturnPassTest, UnreachableReturnsWithValues) { const std::string before = R"(OpCapability Linkage OpCapability Kernel OpMemoryModel Logical OpenCL OpDecorate %7 LinkageAttributes "simple_kernel" Export %1 = OpTypeInt 32 0 %2 = OpTypeBool %3 = OpConstantFalse %2 %4 = OpConstant %1 0 %5 = OpConstant %1 1 %6 = OpTypeFunction %1 %7 = OpFunction %1 None %6 %8 = OpLabel %9 = OpIAdd %1 %4 %5 OpReturnValue %9 %10 = OpLabel OpBranchConditional %3 %11 %12 %11 = OpLabel OpReturnValue %4 %12 = OpLabel OpReturnValue %5 OpFunctionEnd )"; const std::string after = R"(OpCapability Linkage OpCapability Kernel OpMemoryModel Logical OpenCL OpDecorate %7 LinkageAttributes "simple_kernel" Export %1 = OpTypeInt 32 0 %2 = OpTypeBool %3 = OpConstantFalse %2 %4 = OpConstant %1 0 %5 = OpConstant %1 1 %6 = OpTypeFunction %1 %7 = OpFunction %1 None %6 %8 = OpLabel %9 = OpIAdd %1 %4 %5 OpBranch %13 %10 = OpLabel OpBranchConditional %3 %11 %12 %11 = OpLabel OpBranch %13 %12 = OpLabel OpBranch %13 %13 = OpLabel %14 = OpPhi %1 %9 %8 %4 %11 %5 %12 OpReturnValue %14 OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(before, after, false, true); } TEST_F(MergeReturnPassTest, DebugUnreachableReturnsWithValues) { const std::string before = R"(OpCapability Linkage OpCapability Kernel %13 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical OpenCL %14 = OpString "test" OpDecorate %7 LinkageAttributes "simple_kernel" Export %1 = OpTypeInt 32 0 %20 = OpTypeVoid %2 = OpTypeBool %3 = OpConstantFalse %2 %4 = OpConstant %1 0 %5 = OpConstant %1 1 %6 = OpTypeFunction %1 %15 = OpExtInst %20 %13 DebugSource %14 %16 = OpExtInst %20 %13 DebugCompilationUnit 1 4 %15 HLSL %17 = OpExtInst %20 %13 DebugTypeFunction FlagIsProtected|FlagIsPrivate %20 %18 = OpExtInst %20 %13 DebugFunction %14 %17 %15 0 0 %16 %14 FlagIsProtected|FlagIsPrivate 0 %7 %7 = OpFunction %1 None %6 %8 = OpLabel %9 = OpIAdd %1 %4 %5 %19 = OpExtInst %20 %13 DebugScope %18 OpLine %14 100 0 OpReturnValue %9 %10 = OpLabel OpBranchConditional %3 %11 %12 %11 = OpLabel %21 = OpExtInst %20 %13 DebugScope %16 OpLine %14 200 0 OpReturnValue %4 %12 = OpLabel %22 = OpExtInst %20 %13 DebugScope %18 OpLine %14 300 0 OpReturnValue %5 OpFunctionEnd )"; const std::string after = R"(OpCapability Linkage OpCapability Kernel %13 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical OpenCL %14 = OpString "test" OpDecorate %7 LinkageAttributes "simple_kernel" Export %1 = OpTypeInt 32 0 %20 = OpTypeVoid %2 = OpTypeBool %3 = OpConstantFalse %2 %4 = OpConstant %1 0 %5 = OpConstant %1 1 %6 = OpTypeFunction %1 %15 = OpExtInst %20 %13 DebugSource %14 %16 = OpExtInst %20 %13 DebugCompilationUnit 1 4 %15 HLSL %17 = OpExtInst %20 %13 DebugTypeFunction FlagIsProtected|FlagIsPrivate %20 %18 = OpExtInst %20 %13 DebugFunction %14 %17 %15 0 0 %16 %14 FlagIsProtected|FlagIsPrivate 0 %7 %7 = OpFunction %1 None %6 %8 = OpLabel %9 = OpIAdd %1 %4 %5 %25 = OpExtInst %20 %13 DebugScope %18 OpLine %14 100 0 OpBranch %23 %26 = OpExtInst %20 %13 DebugNoScope %10 = OpLabel OpBranchConditional %3 %11 %12 %11 = OpLabel %27 = OpExtInst %20 %13 DebugScope %16 OpLine %14 200 0 OpBranch %23 %28 = OpExtInst %20 %13 DebugNoScope %12 = OpLabel %29 = OpExtInst %20 %13 DebugScope %18 OpLine %14 300 0 OpBranch %23 %30 = OpExtInst %20 %13 DebugNoScope %23 = OpLabel %24 = OpPhi %1 %9 %8 %4 %11 %5 %12 OpReturnValue %24 OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); SinglePassRunAndCheck(before, after, false, true); } TEST_F(MergeReturnPassTest, StructuredControlFlowWithUnreachableMerge) { const std::string before = R"( ; CHECK: [[false:%\w+]] = OpConstantFalse ; CHECK: [[true:%\w+]] = OpConstantTrue ; CHECK: OpFunction ; CHECK: [[var:%\w+]] = OpVariable [[:%\w+]] Function [[false]] ; CHECK: OpSelectionMerge [[return_block:%\w+]] ; CHECK: OpSelectionMerge [[merge_lab:%\w+]] ; CHECK: OpBranchConditional [[cond:%\w+]] [[if_lab:%\w+]] [[then_lab:%\w+]] ; CHECK: [[if_lab]] = OpLabel ; CHECK-NEXT: OpStore [[var]] [[true]] ; CHECK-NEXT: OpBranch [[return_block]] ; CHECK: [[then_lab]] = OpLabel ; CHECK-NEXT: OpStore [[var]] [[true]] ; CHECK-NEXT: OpBranch [[return_block]] ; CHECK: [[merge_lab]] = OpLabel ; CHECK-NEXT: OpBranch [[return_block]] ; CHECK: [[return_block]] = OpLabel ; CHECK-NEXT: OpReturn OpCapability Addresses OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %6 "simple_shader" %2 = OpTypeVoid %3 = OpTypeBool %4 = OpConstantFalse %3 %1 = OpTypeFunction %2 %6 = OpFunction %2 None %1 %7 = OpLabel OpSelectionMerge %10 None OpBranchConditional %4 %8 %9 %8 = OpLabel OpReturn %9 = OpLabel OpReturn %10 = OpLabel OpUnreachable OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(before, false); } TEST_F(MergeReturnPassTest, DebugStructuredControlFlowWithUnreachableMerge) { const std::string before = R"( ; CHECK: [[false:%\w+]] = OpConstantFalse ; CHECK: [[true:%\w+]] = OpConstantTrue ; CHECK: OpFunction ; CHECK: [[var:%\w+]] = OpVariable [[:%\w+]] Function [[false]] ; CHECK: OpSelectionMerge [[return_block:%\w+]] ; CHECK: OpSelectionMerge [[merge_lab:%\w+]] ; CHECK: OpBranchConditional [[cond:%\w+]] [[if_lab:%\w+]] [[then_lab:%\w+]] ; CHECK: [[if_lab]] = OpLabel ; CHECK-NEXT: OpStore [[var]] [[true]] ; CHECK-NEXT: DebugScope ; CHECK-NEXT: OpLine {{%\d+}} 100 0 ; CHECK-NEXT: OpBranch [[return_block]] ; CHECK: [[then_lab]] = OpLabel ; CHECK-NEXT: OpStore [[var]] [[true]] ; CHECK-NEXT: DebugScope ; CHECK-NEXT: OpLine {{%\d+}} 200 0 ; CHECK-NEXT: OpBranch [[return_block]] ; CHECK: [[merge_lab]] = OpLabel ; CHECK-NEXT: DebugScope ; CHECK-NEXT: OpLine {{%\d+}} 300 0 ; CHECK-NEXT: OpBranch [[return_block]] ; CHECK: [[return_block]] = OpLabel ; CHECK-NEXT: OpReturn OpCapability Addresses OpCapability Shader OpCapability Linkage %12 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %6 "simple_shader" %11 = OpString "test" %2 = OpTypeVoid %3 = OpTypeBool %4 = OpConstantFalse %3 %1 = OpTypeFunction %2 %13 = OpExtInst %2 %12 DebugSource %11 %14 = OpExtInst %2 %12 DebugCompilationUnit 1 4 %13 HLSL %6 = OpFunction %2 None %1 %7 = OpLabel OpSelectionMerge %10 None OpBranchConditional %4 %8 %9 %8 = OpLabel %15 = OpExtInst %2 %12 DebugScope %14 OpLine %11 100 0 OpReturn %9 = OpLabel %16 = OpExtInst %2 %12 DebugScope %14 OpLine %11 200 0 OpReturn %10 = OpLabel %17 = OpExtInst %2 %12 DebugScope %14 OpLine %11 300 0 OpUnreachable OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(before, false); } TEST_F(MergeReturnPassTest, StructuredControlFlowAddPhi) { const std::string before = R"( ; CHECK: [[false:%\w+]] = OpConstantFalse ; CHECK: [[true:%\w+]] = OpConstantTrue ; CHECK: OpFunction ; CHECK: [[var:%\w+]] = OpVariable [[:%\w+]] Function [[false]] ; CHECK: OpSelectionMerge [[single_case_switch_merge:%\w+]] ; CHECK: OpSelectionMerge [[merge_lab:%\w+]] ; CHECK: OpBranchConditional [[cond:%\w+]] [[if_lab:%\w+]] [[then_lab:%\w+]] ; CHECK: [[if_lab]] = OpLabel ; CHECK-NEXT: [[add:%\w+]] = OpIAdd [[type:%\w+]] ; CHECK-NEXT: OpBranch ; CHECK: [[then_lab]] = OpLabel ; CHECK-NEXT: OpStore [[var]] [[true]] ; CHECK-NEXT: OpBranch [[single_case_switch_merge]] ; CHECK: [[merge_lab]] = OpLabel ; CHECK: [[single_case_switch_merge]] = OpLabel ; CHECK-NEXT: OpReturn OpCapability Addresses OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %6 "simple_shader" %2 = OpTypeVoid %3 = OpTypeBool %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %4 = OpConstantFalse %3 %1 = OpTypeFunction %2 %6 = OpFunction %2 None %1 %7 = OpLabel OpSelectionMerge %10 None OpBranchConditional %4 %8 %9 %8 = OpLabel %11 = OpIAdd %int %int_0 %int_0 OpBranch %10 %9 = OpLabel OpReturn %10 = OpLabel %12 = OpIAdd %int %11 %11 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(before, false); } TEST_F(MergeReturnPassTest, StructuredControlDecoration) { const std::string before = R"( ; CHECK: OpDecorate [[dec_id:%\w+]] RelaxedPrecision ; CHECK: [[false:%\w+]] = OpConstantFalse ; CHECK: [[true:%\w+]] = OpConstantTrue ; CHECK: OpFunction ; CHECK: [[var:%\w+]] = OpVariable [[:%\w+]] Function [[false]] ; CHECK: OpSelectionMerge [[return_block:%\w+]] ; CHECK: OpSelectionMerge [[merge_lab:%\w+]] ; CHECK: OpBranchConditional [[cond:%\w+]] [[if_lab:%\w+]] [[then_lab:%\w+]] ; CHECK: [[if_lab]] = OpLabel ; CHECK-NEXT: [[dec_id]] = OpIAdd [[type:%\w+]] ; CHECK-NEXT: OpBranch ; CHECK: [[then_lab]] = OpLabel ; CHECK-NEXT: OpStore [[var]] [[true]] ; CHECK-NEXT: OpBranch [[return_block]] ; CHECK: [[merge_lab]] = OpLabel ; CHECK-NEXT: OpStore [[var]] [[true]] ; CHECK-NEXT: OpBranch [[return_block]] ; CHECK: [[return_block]] = OpLabel ; CHECK-NEXT: OpReturn OpCapability Addresses OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %6 "simple_shader" OpDecorate %11 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeBool %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %4 = OpConstantFalse %3 %1 = OpTypeFunction %2 %6 = OpFunction %2 None %1 %7 = OpLabel OpSelectionMerge %10 None OpBranchConditional %4 %8 %9 %8 = OpLabel %11 = OpIAdd %int %int_0 %int_0 OpBranch %10 %9 = OpLabel OpReturn %10 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(before, false); } TEST_F(MergeReturnPassTest, SplitBlockUsedInPhi) { const std::string before = R"( ; CHECK: OpFunction ; CHECK: OpSelectionMerge [[single_case_switch_merge:%\w+]] ; CHECK: OpLoopMerge [[loop_merge:%\w+]] ; CHECK: [[loop_merge]] = OpLabel ; CHECK: OpBranchConditional {{%\w+}} [[single_case_switch_merge]] [[old_code_path:%\w+]] ; CHECK: [[old_code_path:%\w+]] = OpLabel ; CHECK: OpBranchConditional {{%\w+}} [[side_node:%\w+]] [[phi_block:%\w+]] ; CHECK: [[phi_block]] = OpLabel ; CHECK-NEXT: OpPhi %bool %false [[side_node]] %true [[old_code_path]] OpCapability Addresses OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "simple_shader" %void = OpTypeVoid %bool = OpTypeBool %false = OpConstantFalse %bool %true = OpConstantTrue %bool %6 = OpTypeFunction %void %1 = OpFunction %void None %6 %7 = OpLabel OpLoopMerge %merge %cont None OpBranchConditional %false %9 %merge %9 = OpLabel OpReturn %cont = OpLabel OpBranch %7 %merge = OpLabel OpSelectionMerge %merge2 None OpBranchConditional %false %if %merge2 %if = OpLabel OpBranch %merge2 %merge2 = OpLabel %12 = OpPhi %bool %false %if %true %merge OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(before, false); } TEST_F(MergeReturnPassTest, DebugSplitBlockUsedInPhi) { const std::string before = R"( ; CHECK: DebugScope ; CHECK-NEXT: OpLine {{%\d+}} 100 0 ; CHECK: OpLoopMerge ; CHECK: OpStore [[return_in_loop:%\w+]] %true ; CHECK-NEXT: DebugScope ; CHECK-NEXT: OpLine {{%\d+}} 200 0 ; CHECK-NEXT: OpBranch [[check_early_return:%\w+]] ; CHECK: [[check_early_return]] = OpLabel ; CHECK-NEXT: [[early_return:%\w+]] = OpLoad %bool [[return_in_loop]] ; CHECK-NEXT: OpSelectionMerge [[not_early_return:%\w+]] None ; CHECK-NEXT: OpBranchConditional [[early_return]] {{%\d+}} [[not_early_return]] ; CHECK: [[not_early_return]] = OpLabel ; CHECK-NEXT: DebugScope ; CHECK-NEXT: OpLine {{%\d+}} 400 0 ; CHECK: OpSelectionMerge [[merge2:%\w+]] None ; CHECK: [[merge2]] = OpLabel ; CHECK-NEXT: DebugScope ; CHECK-NEXT: OpLine {{%\d+}} 600 0 ; CHECK-NEXT: [[phi:%\w+]] = OpPhi %bool %false {{%\d+}} %true [[not_early_return]] ; CHECK-NEXT: DebugValue {{%\d+}} [[phi]] OpCapability Addresses OpCapability Shader OpCapability Linkage %ext = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "simple_shader" %tn = OpString "test" %void = OpTypeVoid %bool = OpTypeBool %uint = OpTypeInt 32 0 %uint_8 = OpConstant %uint 8 %false = OpConstantFalse %bool %true = OpConstantTrue %bool %6 = OpTypeFunction %void %src = OpExtInst %void %ext DebugSource %tn %cu = OpExtInst %void %ext DebugCompilationUnit 1 4 %src HLSL %ty = OpExtInst %void %ext DebugTypeBasic %tn %uint_8 Boolean %v = OpExtInst %void %ext DebugLocalVariable %tn %ty %src 0 0 %cu FlagIsLocal %expr = OpExtInst %void %ext DebugExpression %1 = OpFunction %void None %6 %7 = OpLabel %s0 = OpExtInst %void %ext DebugScope %cu OpLine %tn 100 0 OpLoopMerge %merge %cont None OpBranchConditional %false %9 %merge %9 = OpLabel %s1 = OpExtInst %void %ext DebugScope %cu OpLine %tn 200 0 OpReturn %cont = OpLabel %s2 = OpExtInst %void %ext DebugScope %cu OpLine %tn 300 0 OpBranch %7 %merge = OpLabel %s3 = OpExtInst %void %ext DebugScope %cu OpLine %tn 400 0 OpSelectionMerge %merge2 None OpBranchConditional %false %if %merge2 %if = OpLabel %s4 = OpExtInst %void %ext DebugScope %cu OpLine %tn 500 0 OpBranch %merge2 %merge2 = OpLabel %s5 = OpExtInst %void %ext DebugScope %cu OpLine %tn 600 0 %12 = OpPhi %bool %false %if %true %merge %dv = OpExtInst %void %ext DebugValue %v %12 %expr OpLine %tn 900 0 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(before, false); } // TODO(#1861): Reenable these test when the breaks from selection constructs // are reenabled. /* TEST_F(MergeReturnPassTest, UpdateOrderWhenPredicating) { const std::string before = R"( ; CHECK: OpFunction ; CHECK: OpFunction ; CHECK: OpSelectionMerge [[m1:%\w+]] None ; CHECK-NOT: OpReturn ; CHECK: [[m1]] = OpLabel ; CHECK: OpSelectionMerge [[m2:%\w+]] None ; CHECK: OpSelectionMerge [[m3:%\w+]] None ; CHECK: OpSelectionMerge [[m4:%\w+]] None ; CHECK: OpLabel ; CHECK-NEXT: OpStore ; CHECK-NEXT: OpBranch [[m4]] ; CHECK: [[m4]] = OpLabel ; CHECK-NEXT: [[ld4:%\w+]] = OpLoad %bool ; CHECK-NEXT: OpBranchConditional [[ld4]] [[m3]] ; CHECK: [[m3]] = OpLabel ; CHECK-NEXT: [[ld3:%\w+]] = OpLoad %bool ; CHECK-NEXT: OpBranchConditional [[ld3]] [[m2]] ; CHECK: [[m2]] = OpLabel OpCapability SampledBuffer OpCapability StorageImageExtendedFormats OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "PS_DebugTiles" OpExecutionMode %1 OriginUpperLeft OpSource HLSL 600 %void = OpTypeVoid %3 = OpTypeFunction %void %bool = OpTypeBool %1 = OpFunction %void None %3 %5 = OpLabel %6 = OpFunctionCall %void %7 OpReturn OpFunctionEnd %7 = OpFunction %void None %3 %8 = OpLabel %9 = OpUndef %bool OpSelectionMerge %10 None OpBranchConditional %9 %11 %10 %11 = OpLabel OpReturn %10 = OpLabel %12 = OpUndef %bool OpSelectionMerge %13 None OpBranchConditional %12 %14 %15 %15 = OpLabel %16 = OpUndef %bool OpSelectionMerge %17 None OpBranchConditional %16 %18 %17 %18 = OpLabel OpReturn %17 = OpLabel OpBranch %13 %14 = OpLabel OpReturn %13 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(before, false); } */ TEST_F(MergeReturnPassTest, StructuredControlFlowBothMergeAndHeader) { const std::string test = R"( ; CHECK: OpFunction ; CHECK: [[ret_flag:%\w+]] = OpVariable %_ptr_Function_bool Function %false ; CHECK: OpSelectionMerge [[single_case_switch_merge:%\w+]] ; CHECK: OpLoopMerge [[loop1_merge:%\w+]] {{%\w+}} ; CHECK-NEXT: OpBranchConditional {{%\w+}} [[if_lab:%\w+]] {{%\w+}} ; CHECK: [[if_lab]] = OpLabel ; CHECK: OpStore [[ret_flag]] %true ; CHECK-NEXT: OpBranch [[loop1_merge]] ; CHECK: [[loop1_merge]] = OpLabel ; CHECK-NEXT: [[ld:%\w+]] = OpLoad %bool [[ret_flag]] ; CHECK-NOT: OpLabel ; CHECK: OpBranchConditional [[ld]] [[single_case_switch_merge]] [[empty_block:%\w+]] ; CHECK: [[empty_block]] = OpLabel ; CHECK-NEXT: OpBranch [[loop2:%\w+]] ; CHECK: [[loop2]] = OpLabel ; CHECK-NOT: OpLabel ; CHECK: OpLoopMerge OpCapability Addresses OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "simple_shader" %void = OpTypeVoid %bool = OpTypeBool %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %false = OpConstantFalse %bool %7 = OpTypeFunction %void %1 = OpFunction %void None %7 %8 = OpLabel OpBranch %9 %9 = OpLabel OpLoopMerge %10 %11 None OpBranchConditional %false %12 %13 %12 = OpLabel OpReturn %13 = OpLabel OpBranch %10 %11 = OpLabel OpBranch %9 %10 = OpLabel OpLoopMerge %14 %15 None OpBranch %15 %15 = OpLabel %16 = OpIAdd %uint %uint_0 %uint_0 OpBranchConditional %false %10 %14 %14 = OpLabel %17 = OpIAdd %uint %16 %16 OpReturn OpFunctionEnd )"; const std::string after = R"(OpCapability Addresses OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "simple_shader" %void = OpTypeVoid %bool = OpTypeBool %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %false = OpConstantFalse %bool %7 = OpTypeFunction %void %_ptr_Function_bool = OpTypePointer Function %bool %true = OpConstantTrue %bool %1 = OpFunction %void None %7 %8 = OpLabel %18 = OpVariable %_ptr_Function_bool Function %false OpSelectionMerge %9 None OpBranchConditional %false %10 %11 %10 = OpLabel OpStore %18 %true OpBranch %9 %11 = OpLabel OpBranch %9 %9 = OpLabel %23 = OpLoad %bool %18 OpSelectionMerge %22 None OpBranchConditional %23 %22 %21 %21 = OpLabel OpBranch %20 %20 = OpLabel OpLoopMerge %12 %13 None OpBranch %13 %13 = OpLabel %14 = OpIAdd %uint %uint_0 %uint_0 OpBranchConditional %false %20 %12 %12 = OpLabel %15 = OpIAdd %uint %14 %14 OpStore %18 %true OpBranch %22 %22 = OpLabel OpBranch %16 %16 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(test, false); } // TODO(#1861): Reenable these test when the breaks from selection constructs // are reenabled. /* TEST_F(MergeReturnPassTest, NestedSelectionMerge) { const std::string before = R"( OpCapability Addresses OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "simple_shader" %void = OpTypeVoid %bool = OpTypeBool %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %false = OpConstantFalse %bool %7 = OpTypeFunction %void %1 = OpFunction %void None %7 %8 = OpLabel OpSelectionMerge %9 None OpBranchConditional %false %10 %11 %10 = OpLabel OpReturn %11 = OpLabel OpSelectionMerge %12 None OpBranchConditional %false %13 %14 %13 = OpLabel %15 = OpIAdd %uint %uint_0 %uint_0 OpBranch %12 %14 = OpLabel OpReturn %12 = OpLabel OpBranch %9 %9 = OpLabel %16 = OpIAdd %uint %15 %15 OpReturn OpFunctionEnd )"; const std::string after = R"(OpCapability Addresses OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "simple_shader" %void = OpTypeVoid %bool = OpTypeBool %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %false = OpConstantFalse %bool %7 = OpTypeFunction %void %_ptr_Function_bool = OpTypePointer Function %bool %true = OpConstantTrue %bool %26 = OpUndef %uint %1 = OpFunction %void None %7 %8 = OpLabel %19 = OpVariable %_ptr_Function_bool Function %false OpSelectionMerge %9 None OpBranchConditional %false %10 %11 %10 = OpLabel OpStore %19 %true OpBranch %9 %11 = OpLabel OpSelectionMerge %12 None OpBranchConditional %false %13 %14 %13 = OpLabel %15 = OpIAdd %uint %uint_0 %uint_0 OpBranch %12 %14 = OpLabel OpStore %19 %true OpBranch %12 %12 = OpLabel %27 = OpPhi %uint %15 %13 %26 %14 %22 = OpLoad %bool %19 OpBranchConditional %22 %9 %21 %21 = OpLabel OpBranch %9 %9 = OpLabel %28 = OpPhi %uint %27 %21 %26 %10 %26 %12 %25 = OpLoad %bool %19 OpSelectionMerge %24 None OpBranchConditional %25 %24 %23 %23 = OpLabel %16 = OpIAdd %uint %28 %28 OpStore %19 %true OpBranch %24 %24 = OpLabel OpBranch %17 %17 = OpLabel OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(before, after, false, true); } // This is essentially the same as NestedSelectionMerge, except // the order of the first branch is changed. This is to make sure things // work even if the order of the traversals change. TEST_F(MergeReturnPassTest, NestedSelectionMerge2) { const std::string before = R"( OpCapability Addresses OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "simple_shader" %void = OpTypeVoid %bool = OpTypeBool %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %false = OpConstantFalse %bool %7 = OpTypeFunction %void %1 = OpFunction %void None %7 %8 = OpLabel OpSelectionMerge %9 None OpBranchConditional %false %10 %11 %11 = OpLabel OpReturn %10 = OpLabel OpSelectionMerge %12 None OpBranchConditional %false %13 %14 %13 = OpLabel %15 = OpIAdd %uint %uint_0 %uint_0 OpBranch %12 %14 = OpLabel OpReturn %12 = OpLabel OpBranch %9 %9 = OpLabel %16 = OpIAdd %uint %15 %15 OpReturn OpFunctionEnd )"; const std::string after = R"(OpCapability Addresses OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "simple_shader" %void = OpTypeVoid %bool = OpTypeBool %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %false = OpConstantFalse %bool %7 = OpTypeFunction %void %_ptr_Function_bool = OpTypePointer Function %bool %true = OpConstantTrue %bool %26 = OpUndef %uint %1 = OpFunction %void None %7 %8 = OpLabel %19 = OpVariable %_ptr_Function_bool Function %false OpSelectionMerge %9 None OpBranchConditional %false %10 %11 %11 = OpLabel OpStore %19 %true OpBranch %9 %10 = OpLabel OpSelectionMerge %12 None OpBranchConditional %false %13 %14 %13 = OpLabel %15 = OpIAdd %uint %uint_0 %uint_0 OpBranch %12 %14 = OpLabel OpStore %19 %true OpBranch %12 %12 = OpLabel %27 = OpPhi %uint %15 %13 %26 %14 %25 = OpLoad %bool %19 OpBranchConditional %25 %9 %24 %24 = OpLabel OpBranch %9 %9 = OpLabel %28 = OpPhi %uint %27 %24 %26 %11 %26 %12 %23 = OpLoad %bool %19 OpSelectionMerge %22 None OpBranchConditional %23 %22 %21 %21 = OpLabel %16 = OpIAdd %uint %28 %28 OpStore %19 %true OpBranch %22 %22 = OpLabel OpBranch %17 %17 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(before, after, false, true); } TEST_F(MergeReturnPassTest, NestedSelectionMerge3) { const std::string before = R"( OpCapability Addresses OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "simple_shader" %void = OpTypeVoid %bool = OpTypeBool %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %false = OpConstantFalse %bool %7 = OpTypeFunction %void %1 = OpFunction %void None %7 %8 = OpLabel OpSelectionMerge %9 None OpBranchConditional %false %10 %11 %11 = OpLabel OpReturn %10 = OpLabel %12 = OpIAdd %uint %uint_0 %uint_0 OpSelectionMerge %13 None OpBranchConditional %false %14 %15 %14 = OpLabel OpBranch %13 %15 = OpLabel OpReturn %13 = OpLabel OpBranch %9 %9 = OpLabel %16 = OpIAdd %uint %12 %12 OpReturn OpFunctionEnd )"; const std::string after = R"(OpCapability Addresses OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "simple_shader" %void = OpTypeVoid %bool = OpTypeBool %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %false = OpConstantFalse %bool %7 = OpTypeFunction %void %_ptr_Function_bool = OpTypePointer Function %bool %true = OpConstantTrue %bool %26 = OpUndef %uint %1 = OpFunction %void None %7 %8 = OpLabel %19 = OpVariable %_ptr_Function_bool Function %false OpSelectionMerge %9 None OpBranchConditional %false %10 %11 %11 = OpLabel OpStore %19 %true OpBranch %9 %10 = OpLabel %12 = OpIAdd %uint %uint_0 %uint_0 OpSelectionMerge %13 None OpBranchConditional %false %14 %15 %14 = OpLabel OpBranch %13 %15 = OpLabel OpStore %19 %true OpBranch %13 %13 = OpLabel %25 = OpLoad %bool %19 OpBranchConditional %25 %9 %24 %24 = OpLabel OpBranch %9 %9 = OpLabel %27 = OpPhi %uint %12 %24 %26 %11 %26 %13 %23 = OpLoad %bool %19 OpSelectionMerge %22 None OpBranchConditional %23 %22 %21 %21 = OpLabel %16 = OpIAdd %uint %27 %27 OpStore %19 %true OpBranch %22 %22 = OpLabel OpBranch %17 %17 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(before, after, false, true); } */ TEST_F(MergeReturnPassTest, NestedLoopMerge) { const std::string test = R"( ; CHECK: OpFunction ; CHECK: OpSelectionMerge [[single_case_switch_merge:%\w+]] ; CHECK: OpLoopMerge [[outer_loop_merge:%\w+]] ; CHECK: OpLoopMerge [[inner_loop_merge:%\w+]] ; CHECK: OpSelectionMerge ; CHECK-NEXT: OpBranchConditional %true [[early_exit_block:%\w+]] ; CHECK: [[early_exit_block]] = OpLabel ; CHECK-NOT: OpLabel ; CHECK: OpBranch [[inner_loop_merge]] ; CHECK: [[inner_loop_merge]] = OpLabel ; CHECK-NOT: OpLabel ; CHECK: OpBranchConditional {{%\w+}} [[outer_loop_merge]] ; CHECK: [[outer_loop_merge]] = OpLabel ; CHECK-NOT: OpLabel ; CHECK: OpBranchConditional {{%\w+}} [[single_case_switch_merge]] ; CHECK: [[single_case_switch_merge]] = OpLabel ; CHECK-NOT: OpLabel ; CHECK: OpReturn OpCapability SampledBuffer OpCapability StorageImageExtendedFormats OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "CS" OpExecutionMode %2 LocalSize 8 8 1 OpSource HLSL 600 %uint = OpTypeInt 32 0 %void = OpTypeVoid %6 = OpTypeFunction %void %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %v3uint = OpTypeVector %uint 3 %bool = OpTypeBool %true = OpConstantTrue %bool %_ptr_Function_uint = OpTypePointer Function %uint %2 = OpFunction %void None %6 %14 = OpLabel OpBranch %19 %19 = OpLabel %20 = OpPhi %uint %uint_0 %2 %34 %23 %21 = OpULessThan %bool %20 %uint_1 OpLoopMerge %22 %23 DontUnroll OpBranchConditional %21 %24 %22 %24 = OpLabel OpBranch %25 %25 = OpLabel %27 = OpINotEqual %bool %uint_1 %uint_0 OpLoopMerge %28 %29 DontUnroll OpBranchConditional %27 %30 %28 %30 = OpLabel OpSelectionMerge %31 None OpBranchConditional %true %32 %31 %32 = OpLabel OpReturn %31 = OpLabel OpBranch %29 %29 = OpLabel OpBranch %25 %28 = OpLabel OpBranch %23 %23 = OpLabel %34 = OpIAdd %uint %20 %uint_1 OpBranch %19 %22 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(test, false); } TEST_F(MergeReturnPassTest, ReturnValueDecoration) { const std::string test = R"( ; CHECK: OpDecorate [[func:%\w+]] RelaxedPrecision ; CHECK: OpDecorate [[ret_val:%\w+]] RelaxedPrecision ; CHECK: [[func]] = OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NOT: OpLabel ; CHECK: [[ret_val]] = OpVariable OpCapability Linkage OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %11 "simple_shader" OpDecorate %7 RelaxedPrecision %12 = OpTypeVoid %1 = OpTypeInt 32 0 %2 = OpTypeBool %3 = OpConstantFalse %2 %4 = OpConstant %1 0 %5 = OpConstant %1 1 %6 = OpTypeFunction %1 %13 = OpTypeFunction %12 %11 = OpFunction %12 None %13 %l1 = OpLabel %fc = OpFunctionCall %1 %7 OpReturn OpFunctionEnd %7 = OpFunction %1 None %6 %8 = OpLabel OpBranchConditional %3 %9 %10 %9 = OpLabel OpReturnValue %4 %10 = OpLabel OpReturnValue %5 OpFunctionEnd )"; SinglePassRunAndMatch(test, false); } TEST_F(MergeReturnPassTest, StructuredControlFlowWithNonTrivialUnreachableMerge) { const std::string before = R"( OpCapability Addresses OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %6 "simple_shader" %2 = OpTypeVoid %3 = OpTypeBool %4 = OpConstantFalse %3 %1 = OpTypeFunction %2 %6 = OpFunction %2 None %1 %7 = OpLabel OpSelectionMerge %10 None OpBranchConditional %4 %8 %9 %8 = OpLabel OpReturn %9 = OpLabel OpReturn %10 = OpLabel %11 = OpUndef %3 OpUnreachable OpFunctionEnd )"; std::vector messages = { {SPV_MSG_ERROR, nullptr, 0, 0, "Module contains unreachable blocks during merge return. Run dead " "branch elimination before merge return."}}; SetMessageConsumer(GetTestMessageConsumer(messages)); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); auto result = SinglePassRunToBinary(before, false); EXPECT_EQ(Pass::Status::Failure, std::get<1>(result)); EXPECT_TRUE(messages.empty()); } TEST_F(MergeReturnPassTest, StructuredControlFlowWithNonTrivialUnreachableContinue) { const std::string before = R"( OpCapability Addresses OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %6 "simple_shader" %2 = OpTypeVoid %3 = OpTypeBool %4 = OpConstantFalse %3 %1 = OpTypeFunction %2 %6 = OpFunction %2 None %1 %7 = OpLabel OpBranch %header %header = OpLabel OpLoopMerge %merge %continue None OpBranchConditional %4 %8 %merge %8 = OpLabel OpReturn %continue = OpLabel %11 = OpUndef %3 OpBranch %header %merge = OpLabel OpReturn OpFunctionEnd )"; std::vector messages = { {SPV_MSG_ERROR, nullptr, 0, 0, "Module contains unreachable blocks during merge return. Run dead " "branch elimination before merge return."}}; SetMessageConsumer(GetTestMessageConsumer(messages)); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); auto result = SinglePassRunToBinary(before, false); EXPECT_EQ(Pass::Status::Failure, std::get<1>(result)); EXPECT_TRUE(messages.empty()); } TEST_F(MergeReturnPassTest, StructuredControlFlowWithUnreachableBlock) { const std::string before = R"( OpCapability Addresses OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %6 "simple_shader" %2 = OpTypeVoid %3 = OpTypeBool %4 = OpConstantFalse %3 %1 = OpTypeFunction %2 %6 = OpFunction %2 None %1 %7 = OpLabel OpBranch %header %header = OpLabel OpLoopMerge %merge %continue None OpBranchConditional %4 %8 %merge %8 = OpLabel OpReturn %continue = OpLabel OpBranch %header %merge = OpLabel OpReturn %unreachable = OpLabel OpUnreachable OpFunctionEnd )"; std::vector messages = { {SPV_MSG_ERROR, nullptr, 0, 0, "Module contains unreachable blocks during merge return. Run dead " "branch elimination before merge return."}}; SetMessageConsumer(GetTestMessageConsumer(messages)); SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); auto result = SinglePassRunToBinary(before, false); EXPECT_EQ(Pass::Status::Failure, std::get<1>(result)); EXPECT_TRUE(messages.empty()); } TEST_F(MergeReturnPassTest, StructuredControlFlowDontChangeEntryPhi) { const std::string before = R"( ; CHECK: OpFunction %void ; CHECK: OpLabel ; CHECK: [[pre_header:%\w+]] = OpLabel ; CHECK: [[header:%\w+]] = OpLabel ; CHECK-NEXT: OpPhi %bool {{%\w+}} [[pre_header]] [[iv:%\w+]] [[continue:%\w+]] ; CHECK-NEXT: OpLoopMerge [[merge:%\w+]] [[continue]] ; CHECK: [[continue]] = OpLabel ; CHECK-NEXT: [[iv]] = Op ; CHECK: [[merge]] = OpLabel OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "main" %void = OpTypeVoid %bool = OpTypeBool %4 = OpTypeFunction %void %1 = OpFunction %void None %4 %5 = OpLabel %6 = OpUndef %bool OpBranch %7 %7 = OpLabel %8 = OpPhi %bool %6 %5 %9 %10 OpLoopMerge %11 %10 None OpBranch %12 %12 = OpLabel %13 = OpUndef %bool OpSelectionMerge %10 DontFlatten OpBranchConditional %13 %10 %14 %14 = OpLabel OpReturn %10 = OpLabel %9 = OpUndef %bool OpBranchConditional %13 %7 %11 %11 = OpLabel OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(before, false); } TEST_F(MergeReturnPassTest, StructuredControlFlowPartialReplacePhi) { const std::string before = R"( ; CHECK: OpFunction %void ; CHECK: OpLabel ; CHECK: [[pre_header:%\w+]] = OpLabel ; CHECK: [[header:%\w+]] = OpLabel ; CHECK-NEXT: OpPhi ; CHECK-NEXT: OpLoopMerge [[merge:%\w+]] ; CHECK: OpLabel ; CHECK: [[old_ret_block:%\w+]] = OpLabel ; CHECK: [[bb:%\w+]] = OpLabel ; CHECK-NEXT: [[val:%\w+]] = OpUndef %bool ; CHECK: [[merge]] = OpLabel ; CHECK-NEXT: [[phi1:%\w+]] = OpPhi %bool {{%\w+}} [[old_ret_block]] [[val]] [[bb]] ; CHECK: OpBranchConditional {{%\w+}} {{%\w+}} [[bb2:%\w+]] ; CHECK: [[bb2]] = OpLabel ; CHECK: OpBranch [[header2:%\w+]] ; CHECK: [[header2]] = OpLabel ; CHECK-NEXT: [[phi2:%\w+]] = OpPhi %bool [[phi1]] [[continue2:%\w+]] [[phi1]] [[bb2]] ; CHECK-NEXT: OpLoopMerge {{%\w+}} [[continue2]] ; CHECK: [[continue2]] = OpLabel ; CHECK-NEXT: OpBranch [[header2]] OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "main" %void = OpTypeVoid %bool = OpTypeBool %4 = OpTypeFunction %void %1 = OpFunction %void None %4 %5 = OpLabel %6 = OpUndef %bool OpBranch %7 %7 = OpLabel %8 = OpPhi %bool %6 %5 %9 %10 OpLoopMerge %11 %10 None OpBranch %12 %12 = OpLabel %13 = OpUndef %bool OpSelectionMerge %10 DontFlatten OpBranchConditional %13 %10 %14 %14 = OpLabel OpReturn %10 = OpLabel %9 = OpUndef %bool OpBranchConditional %13 %7 %11 %11 = OpLabel %phi = OpPhi %bool %9 %10 %9 %cont OpLoopMerge %ret %cont None OpBranch %bb %bb = OpLabel OpBranchConditional %13 %ret %cont %cont = OpLabel OpBranch %11 %ret = OpLabel OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(before, false); } TEST_F(MergeReturnPassTest, GeneratePhiInOuterLoop) { const std::string before = R"( ; CHECK: OpSelectionMerge ; CHECK-NEXT: OpSwitch {{%\w+}} [[def_bb1:%\w+]] ; CHECK-NEXT: [[def_bb1]] = OpLabel ; CHECK: OpLoopMerge [[merge:%\w+]] [[continue:%\w+]] ; CHECK: [[continue]] = OpLabel ; CHECK-NEXT: [[undef:%\w+]] = OpUndef ; CHECK: [[merge]] = OpLabel ; CHECK-NEXT: [[phi:%\w+]] = OpPhi %bool {{%\w+}} {{%\w+}} [[undef]] [[continue]] ; CHECK: OpCopyObject %bool [[phi]] OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %void = OpTypeVoid %3 = OpTypeFunction %void %bool = OpTypeBool %8 = OpTypeFunction %bool %false = OpConstantFalse %bool %4 = OpFunction %void None %3 %5 = OpLabel %63 = OpFunctionCall %bool %9 OpReturn OpFunctionEnd %9 = OpFunction %bool None %8 %10 = OpLabel OpBranch %31 %31 = OpLabel OpLoopMerge %33 %34 None OpBranch %32 %32 = OpLabel OpSelectionMerge %34 None OpBranchConditional %false %46 %34 %46 = OpLabel OpLoopMerge %51 %52 None OpBranch %53 %53 = OpLabel OpBranchConditional %false %50 %51 %50 = OpLabel OpReturnValue %false %52 = OpLabel OpBranch %46 %51 = OpLabel OpBranch %34 %34 = OpLabel %64 = OpUndef %bool OpBranchConditional %false %31 %33 %33 = OpLabel OpBranch %28 %28 = OpLabel %60 = OpCopyObject %bool %64 OpBranch %17 %17 = OpLabel OpReturnValue %false OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(before, false); } TEST_F(MergeReturnPassTest, SerialLoopsUpdateBlockMapping) { // #2455: This test case triggers phi insertions that use previously inserted // phis. Without the fix, it fails to validate. const std::string spirv = R"( ; CHECK: OpSelectionMerge ; CHECK-NEXT: OpSwitch {{%\w+}} [[def_bb1:%\w+]] ; CHECK-NEXT: [[def_bb1]] = OpLabel ; CHECK: OpLoopMerge ; CHECK: OpLoopMerge ; CHECK: OpLoopMerge [[merge:%\w+]] ; CHECK: [[def:%\w+]] = OpFOrdLessThan ; CHECK: [[merge]] = OpLabel ; CHECK-NEXT: [[phi:%\w+]] = OpPhi {{%\w+}} {{%\w+}} {{%\w+}} [[def]] ; CHECK: OpLoopMerge [[merge:%\w+]] [[cont:%\w+]] ; CHECK: [[cont]] = OpLabel ; CHECK-NEXT: OpBranchConditional [[phi]] ; CHECK-NOT: [[def]] OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %53 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %20 RelaxedPrecision OpDecorate %27 RelaxedPrecision OpDecorate %53 BuiltIn FragCoord %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 3 %8 = OpTypeFunction %7 %11 = OpTypeBool %12 = OpConstantFalse %11 %15 = OpConstant %6 1 %16 = OpConstantComposite %7 %15 %15 %15 %18 = OpTypeInt 32 1 %19 = OpTypePointer Function %18 %21 = OpConstant %18 1 %28 = OpConstant %18 0 %31 = OpTypePointer Function %11 %33 = OpConstantTrue %11 %51 = OpTypeVector %6 4 %52 = OpTypePointer Input %51 %53 = OpVariable %52 Input %54 = OpTypeInt 32 0 %55 = OpConstant %54 0 %56 = OpTypePointer Input %6 %59 = OpConstant %6 0 %76 = OpUndef %18 %77 = OpUndef %11 %78 = OpUndef %6 %4 = OpFunction %2 None %3 %5 = OpLabel %75 = OpFunctionCall %7 %9 OpReturn OpFunctionEnd %9 = OpFunction %7 None %8 %10 = OpLabel %20 = OpVariable %19 Function OpBranch %14 %14 = OpLabel OpBranch %22 %22 = OpLabel %27 = OpLoad %18 %20 OpLoopMerge %24 %25 None OpBranch %24 %25 = OpLabel OpBranch %22 %24 = OpLabel OpBranch %34 %34 = OpLabel OpLoopMerge %36 %40 None OpBranch %35 %35 = OpLabel OpBranchConditional %77 %39 %40 %39 = OpLabel OpReturnValue %16 %40 = OpLabel OpBranchConditional %12 %34 %36 %36 = OpLabel OpBranch %43 %43 = OpLabel OpLoopMerge %45 %49 None OpBranch %44 %44 = OpLabel OpBranchConditional %77 %48 %49 %48 = OpLabel OpReturnValue %16 %49 = OpLabel %60 = OpFOrdLessThan %11 %15 %59 OpBranchConditional %12 %43 %45 %45 = OpLabel OpBranch %62 %62 = OpLabel OpLoopMerge %64 %68 None OpBranch %63 %63 = OpLabel OpBranchConditional %77 %67 %68 %67 = OpLabel OpReturnValue %16 %68 = OpLabel OpBranchConditional %60 %62 %64 %64 = OpLabel OpReturnValue %16 OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(spirv, true); } TEST_F(MergeReturnPassTest, InnerLoopMergeIsOuterLoopContinue) { const std::string before = R"( ; CHECK: OpSelectionMerge ; CHECK-NEXT: OpSwitch {{%\w+}} [[def_bb1:%\w+]] ; CHECK-NEXT: [[def_bb1]] = OpLabel ; CHECK-NEXT: OpBranch [[outer_loop_header:%\w+]] ; CHECK: [[outer_loop_header]] = OpLabel ; CHECK-NEXT: OpLoopMerge [[outer_loop_merge:%\w+]] [[outer_loop_continue:%\w+]] None ; CHECK: [[outer_loop_continue]] = OpLabel ; CHECK-NEXT: OpBranch [[outer_loop_header]] OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %void = OpTypeVoid %4 = OpTypeFunction %void %bool = OpTypeBool %6 = OpTypeFunction %bool %true = OpConstantTrue %bool %2 = OpFunction %void None %4 %8 = OpLabel %9 = OpFunctionCall %bool %10 OpReturn OpFunctionEnd %10 = OpFunction %bool None %6 %11 = OpLabel OpBranch %12 %12 = OpLabel OpLoopMerge %13 %14 None OpBranchConditional %true %15 %13 %15 = OpLabel OpLoopMerge %14 %16 None OpBranchConditional %true %17 %14 %17 = OpLabel OpReturnValue %true %16 = OpLabel OpBranch %15 %14 = OpLabel OpBranch %12 %13 = OpLabel OpReturnValue %true OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(before, false); } TEST_F(MergeReturnPassTest, BreakFromLoopUseNoLongerDominated) { const std::string spirv = R"( ; CHECK: [[undef:%\w+]] = OpUndef ; CHECK: OpSelectionMerge ; CHECK-NEXT: OpSwitch {{%\w+}} [[def_bb1:%\w+]] ; CHECK-NEXT: [[def_bb1]] = OpLabel ; CHECK: OpLoopMerge [[merge:%\w+]] [[cont:%\w+]] ; CHECK-NEXT: OpBranch [[body:%\w+]] ; CHECK: [[body]] = OpLabel ; CHECK-NEXT: OpSelectionMerge [[non_ret:%\w+]] ; CHECK-NEXT: OpBranchConditional {{%\w+}} [[ret:%\w+]] [[non_ret]] ; CHECK: [[ret]] = OpLabel ; CHECK-NEXT: OpStore ; CHECK-NEXT: OpBranch [[merge]] ; CHECK: [[non_ret]] = OpLabel ; CHECK-NEXT: [[def:%\w+]] = OpLogicalNot ; CHECK-NEXT: OpBranchConditional {{%\w+}} [[break:%\w+]] [[cont]] ; CHECK: [[break]] = OpLabel ; CHECK-NEXT: OpBranch [[merge]] ; CHECK: [[cont]] = OpLabel ; CHECK-NEXT: OpBranchConditional {{%\w+}} {{%\w+}} [[merge]] ; CHECK: [[merge]] = OpLabel ; CHECK-NEXT: [[phi:%\w+]] = OpPhi {{%\w+}} [[undef]] [[ret]] [[def]] [[break]] [[def]] [[cont]] ; CHECK: OpLogicalNot {{%\w+}} [[phi]] OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %func "func" OpExecutionMode %func LocalSize 1 1 1 %void = OpTypeVoid %void_fn = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %func = OpFunction %void None %void_fn %1 = OpLabel OpBranch %2 %2 = OpLabel OpLoopMerge %8 %7 None OpBranch %3 %3 = OpLabel OpSelectionMerge %5 None OpBranchConditional %true %4 %5 %4 = OpLabel OpReturn %5 = OpLabel %def = OpLogicalNot %bool %true OpBranchConditional %true %6 %7 %6 = OpLabel OpBranch %8 %7 = OpLabel OpBranchConditional %true %2 %8 %8 = OpLabel OpBranch %9 %9 = OpLabel %use = OpLogicalNot %bool %def OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(spirv, true); } TEST_F(MergeReturnPassTest, TwoBreaksFromLoopUsesNoLongerDominated) { const std::string spirv = R"( ; CHECK: [[undef:%\w+]] = OpUndef ; CHECK: OpSelectionMerge ; CHECK-NEXT: OpSwitch {{%\w+}} [[def_bb1:%\w+]] ; CHECK-NEXT: [[def_bb1]] = OpLabel ; CHECK: OpLoopMerge [[merge:%\w+]] [[cont:%\w+]] ; CHECK-NEXT: OpBranch [[body:%\w+]] ; CHECK: [[body]] = OpLabel ; CHECK-NEXT: OpSelectionMerge [[body2:%\w+]] ; CHECK-NEXT: OpBranchConditional {{%\w+}} [[ret1:%\w+]] [[body2]] ; CHECK: [[ret1]] = OpLabel ; CHECK-NEXT: OpStore ; CHECK-NEXT: OpBranch [[merge]] ; CHECK: [[body2]] = OpLabel ; CHECK-NEXT: [[def1:%\w+]] = OpLogicalNot ; CHECK-NEXT: OpSelectionMerge [[body3:%\w+]] ; CHECK-NEXT: OpBranchConditional {{%\w+}} [[ret2:%\w+]] [[body3:%\w+]] ; CHECK: [[ret2]] = OpLabel ; CHECK-NEXT: OpStore ; CHECK-NEXT: OpBranch [[merge]] ; CHECK: [[body3]] = OpLabel ; CHECK-NEXT: [[def2:%\w+]] = OpLogicalAnd ; CHECK-NEXT: OpBranchConditional {{%\w+}} [[break:%\w+]] [[cont]] ; CHECK: [[break]] = OpLabel ; CHECK-NEXT: OpBranch [[merge]] ; CHECK: [[cont]] = OpLabel ; CHECK-NEXT: OpBranchConditional {{%\w+}} {{%\w+}} [[merge]] ; CHECK: [[merge]] = OpLabel ; CHECK-NEXT: [[phi1:%\w+]] = OpPhi {{%\w+}} [[undef]] [[ret1]] [[undef]] [[ret2]] [[def1]] [[break]] [[def1]] [[cont]] ; CHECK-NEXT: [[phi2:%\w+]] = OpPhi {{%\w+}} [[undef]] [[ret1]] [[undef]] [[ret2]] [[def2]] [[break]] [[def2]] [[cont]] ; CHECK: OpLogicalNot {{%\w+}} [[phi1]] ; CHECK: OpLogicalAnd {{%\w+}} [[phi2]] OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %func "func" OpExecutionMode %func LocalSize 1 1 1 %void = OpTypeVoid %void_fn = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %func = OpFunction %void None %void_fn %1 = OpLabel OpBranch %2 %2 = OpLabel OpLoopMerge %10 %9 None OpBranch %3 %3 = OpLabel OpSelectionMerge %5 None OpBranchConditional %true %4 %5 %4 = OpLabel OpReturn %5 = OpLabel %def1 = OpLogicalNot %bool %true OpSelectionMerge %7 None OpBranchConditional %true %6 %7 %6 = OpLabel OpReturn %7 = OpLabel %def2 = OpLogicalAnd %bool %true %true OpBranchConditional %true %8 %9 %8 = OpLabel OpBranch %10 %9 = OpLabel OpBranchConditional %true %2 %10 %10 = OpLabel OpBranch %11 %11 = OpLabel %use1 = OpLogicalNot %bool %def1 %use2 = OpLogicalAnd %bool %def2 %true OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(spirv, true); } TEST_F(MergeReturnPassTest, PredicateBreakBlock) { const std::string spirv = R"( ; IDs are being preserved so we can rely on basic block labels. ; CHECK: [[undef:%\w+]] = OpUndef ; CHECK: [[undef:%\w+]] = OpUndef ; CHECK: %13 = OpLabel ; CHECK-NEXT: [[def:%\w+]] = OpLogicalNot ; CHECK: %8 = OpLabel ; CHECK-NEXT: [[phi:%\w+]] = OpPhi {{%\w+}} [[undef]] {{%\w+}} [[undef]] {{%\w+}} [[def]] %13 [[undef]] {{%\w+}} ; CHECK: OpLogicalAnd {{%\w+}} [[phi]] OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "func" OpExecutionMode %1 LocalSize 1 1 1 %void = OpTypeVoid %3 = OpTypeFunction %void %bool = OpTypeBool %true = OpUndef %bool %1 = OpFunction %void None %3 %6 = OpLabel OpBranch %7 %7 = OpLabel OpLoopMerge %8 %9 None OpBranch %10 %10 = OpLabel OpSelectionMerge %11 None OpBranchConditional %true %12 %13 %12 = OpLabel OpLoopMerge %14 %15 None OpBranch %16 %16 = OpLabel OpReturn %15 = OpLabel OpBranch %12 %14 = OpLabel OpUnreachable %13 = OpLabel %17 = OpLogicalNot %bool %true OpBranch %8 %11 = OpLabel OpUnreachable %9 = OpLabel OpBranch %7 %8 = OpLabel OpBranch %18 %18 = OpLabel %19 = OpLogicalAnd %bool %17 %true OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(spirv, true); } TEST_F(MergeReturnPassTest, SingleReturnInLoop) { const std::string predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 %void = OpTypeVoid %7 = OpTypeFunction %void %float = OpTypeFloat 32 %9 = OpTypeFunction %float %float_1 = OpConstant %float 1 )"; const std::string caller = R"( ; CHECK: OpFunction ; CHECK: OpFunctionEnd %main = OpFunction %void None %7 %22 = OpLabel %30 = OpFunctionCall %float %f_ OpReturn OpFunctionEnd )"; const std::string callee = R"( ; CHECK: OpFunction ; CHECK: OpLoopMerge [[merge:%\w+]] ; CHECK: [[merge]] = OpLabel ; CHECK: OpReturnValue ; CHECK-NEXT: OpFunctionEnd %f_ = OpFunction %float None %9 %33 = OpLabel OpBranch %34 %34 = OpLabel OpLoopMerge %35 %36 None OpBranch %37 %37 = OpLabel OpReturnValue %float_1 %36 = OpLabel OpBranch %34 %35 = OpLabel OpUnreachable OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(predefs + caller + callee, true); } TEST_F(MergeReturnPassTest, MergeToMergeBranch) { const std::string text = R"( ; CHECK: [[new_undef:%\w+]] = OpUndef %uint ; CHECK: OpSelectionMerge ; CHECK-NEXT: OpSwitch {{%\w+}} [[def_bb1:%\w+]] ; CHECK-NEXT: [[def_bb1]] = OpLabel ; CHECK: OpLoopMerge [[merge1:%\w+]] ; CHECK: OpLoopMerge [[merge2:%\w+]] ; CHECK: [[merge1]] = OpLabel ; CHECK-NEXT: OpPhi %uint [[new_undef]] [[merge2]] OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" OpExecutionMode %2 LocalSize 100 1 1 OpSource ESSL 310 %void = OpTypeVoid %4 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %bool = OpTypeBool %false = OpConstantFalse %bool %uint_0 = OpConstant %uint 0 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %13 = OpUndef %bool %2 = OpFunction %void None %4 %14 = OpLabel OpBranch %15 %15 = OpLabel OpLoopMerge %16 %17 None OpBranch %18 %18 = OpLabel OpLoopMerge %19 %20 None OpBranchConditional %13 %21 %19 %21 = OpLabel OpReturn %20 = OpLabel OpBranch %18 %19 = OpLabel %22 = OpUndef %uint OpBranch %23 %23 = OpLabel OpBranch %16 %17 = OpLabel OpBranch %15 %16 = OpLabel %24 = OpCopyObject %uint %22 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(text, true); } TEST_F(MergeReturnPassTest, PhiInSecondMerge) { // Add and use a phi in the second merge block from the return. const std::string text = R"( ; CHECK: OpSelectionMerge ; CHECK-NEXT: OpSwitch {{%\w+}} [[def_bb1:%\w+]] ; CHECK-NEXT: [[def_bb1]] = OpLabel ; CHECK: OpLoopMerge [[merge_bb:%\w+]] [[continue_bb:%\w+]] ; CHECK: [[continue_bb]] = OpLabel ; CHECK-NEXT: [[val:%\w+]] = OpUndef %float ; CHECK: [[merge_bb]] = OpLabel ; CHECK-NEXT: [[phi:%\w+]] = OpPhi %float {{%\w+}} {{%\w+}} [[val]] [[continue_bb]] ; CHECK-NOT: OpLabel ; CHECK: OpBranchConditional {{%\w+}} {{%\w+}} [[old_merge:%\w+]] ; CHECK: [[old_merge]] = OpLabel ; CHECK-NEXT: OpConvertFToS %int [[phi]] OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %void = OpTypeVoid %4 = OpTypeFunction %void %int = OpTypeInt 32 1 %float = OpTypeFloat 32 %bool = OpTypeBool %8 = OpUndef %bool %2 = OpFunction %void None %4 %9 = OpLabel OpBranch %10 %10 = OpLabel OpLoopMerge %11 %12 None OpBranch %13 %13 = OpLabel OpLoopMerge %18 %14 None OpBranchConditional %8 %15 %18 %15 = OpLabel OpReturn %14 = OpLabel OpBranch %13 %18 = OpLabel OpBranch %12 %12 = OpLabel %16 = OpUndef %float OpBranchConditional %8 %10 %11 %11 = OpLabel %17 = OpConvertFToS %int %16 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(text, true); } TEST_F(MergeReturnPassTest, ReturnsInSwitch) { // Cannot branch directly to single case switch merge block from original // switch. Must branch to merge block of original switch and then do // predicated branch to merge block of single case switch. const std::string text = R"( ; CHECK: OpSelectionMerge [[single_case_switch_merge_bb:%\w+]] ; CHECK-NEXT: OpSwitch {{%\w+}} [[def_bb1:%\w+]] ; CHECK-NEXT: [[def_bb1]] = OpLabel ; CHECK: OpSelectionMerge ; CHECK-NEXT: OpSwitch {{%\w+}} [[inner_merge_bb:%\w+]] 0 {{%\w+}} 1 {{%\w+}} ; CHECK: OpBranch [[inner_merge_bb]] ; CHECK: OpBranch [[inner_merge_bb]] ; CHECK-NEXT: [[inner_merge_bb]] = OpLabel ; CHECK: OpBranchConditional {{%\w+}} [[single_case_switch_merge_bb]] {{%\w+}} OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %PSMain "PSMain" %_entryPointOutput_color OpExecutionMode %PSMain OriginUpperLeft OpSource HLSL 500 OpMemberDecorate %cb 0 Offset 0 OpMemberDecorate %cb 1 Offset 16 OpMemberDecorate %cb 2 Offset 32 OpMemberDecorate %cb 3 Offset 48 OpDecorate %cb Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %_entryPointOutput_color Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %8 = OpTypeFunction %v4float %int = OpTypeInt 32 1 %cb = OpTypeStruct %v4float %v4float %v4float %int %_ptr_Uniform_cb = OpTypePointer Uniform %cb %_ = OpVariable %_ptr_Uniform_cb Uniform %int_3 = OpConstant %int 3 %_ptr_Uniform_int = OpTypePointer Uniform %int %int_0 = OpConstant %int 0 %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %float_0 = OpConstant %float 0 %float_1 = OpConstant %float 1 %45 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_1 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput_color = OpVariable %_ptr_Output_v4float Output %PSMain = OpFunction %void None %3 %5 = OpLabel %50 = OpFunctionCall %v4float %BlendValue_ OpStore %_entryPointOutput_color %50 OpReturn OpFunctionEnd %BlendValue_ = OpFunction %v4float None %8 %10 = OpLabel %21 = OpAccessChain %_ptr_Uniform_int %_ %int_3 %22 = OpLoad %int %21 OpSelectionMerge %25 None OpSwitch %22 %25 0 %23 1 %24 %23 = OpLabel %28 = OpAccessChain %_ptr_Uniform_v4float %_ %int_0 %29 = OpLoad %v4float %28 OpReturnValue %29 %24 = OpLabel %31 = OpAccessChain %_ptr_Uniform_v4float %_ %int_0 %32 = OpLoad %v4float %31 %34 = OpAccessChain %_ptr_Uniform_v4float %_ %int_1 %35 = OpLoad %v4float %34 %37 = OpAccessChain %_ptr_Uniform_v4float %_ %int_2 %38 = OpLoad %v4float %37 %39 = OpFMul %v4float %35 %38 %40 = OpFAdd %v4float %32 %39 OpReturnValue %40 %25 = OpLabel OpReturnValue %45 OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndMatch(text, true); } TEST_F(MergeReturnPassTest, UnreachableMergeAndContinue) { // Make sure that the pass can handle a single block that is both a merge and // a continue. Note that this is invalid SPIR-V. const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %void = OpTypeVoid %4 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %2 = OpFunction %void None %4 %7 = OpLabel OpBranch %8 %8 = OpLabel OpLoopMerge %9 %10 None OpBranch %11 %11 = OpLabel OpSelectionMerge %10 None OpBranchConditional %true %12 %13 %12 = OpLabel OpReturn %13 = OpLabel OpReturn %10 = OpLabel OpBranch %8 %9 = OpLabel OpUnreachable OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); auto result = SinglePassRunAndDisassemble(text, true, false); // Not looking for any particular output. Other tests do that. // Just want to make sure the check for unreachable blocks does not emit an // error. EXPECT_EQ(Pass::Status::SuccessWithChange, std::get<1>(result)); } TEST_F(MergeReturnPassTest, SingleReturnInMiddle) { const std::string before = R"( ; CHECK: OpFunction ; CHECK: OpReturn ; CHECK-NEXT: OpFunctionEnd OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpName %main "main" OpName %foo_ "foo(" %void = OpTypeVoid %4 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %foo_ = OpFunction %void None %4 %7 = OpLabel OpSelectionMerge %8 None OpBranchConditional %true %9 %8 %8 = OpLabel OpReturn %9 = OpLabel OpBranch %8 OpFunctionEnd %main = OpFunction %void None %4 %10 = OpLabel %11 = OpFunctionCall %void %foo_ OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(before, false); } TEST_F(MergeReturnPassTest, PhiWithTooManyEntries) { // Check that the OpPhi node has the correct number of entries. This is // checked by doing validation with the match. const std::string before = R"( ; CHECK: OpLoopMerge [[merge:%\w+]] ; CHECK: [[merge]] = OpLabel ; CHECK-NEXT: {{%\w+}} = OpPhi %int {{%\w+}} {{%\w+}} {{%\w+}} {{%\w+}} {{%\w+}} {{%\w+}} {{%\w+}} {{%\w+}} OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft %void = OpTypeVoid %4 = OpTypeFunction %void %int = OpTypeInt 32 1 %6 = OpTypeFunction %int %bool = OpTypeBool %int_1 = OpConstant %int 1 %false = OpConstantFalse %bool %2 = OpFunction %void None %4 %10 = OpLabel %11 = OpFunctionCall %int %12 OpReturn OpFunctionEnd %12 = OpFunction %int None %6 %13 = OpLabel OpBranch %14 %14 = OpLabel %15 = OpPhi %int %int_1 %13 %16 %17 OpLoopMerge %18 %17 None OpBranch %19 %19 = OpLabel %20 = OpUndef %bool OpBranch %21 %21 = OpLabel OpLoopMerge %22 %23 None OpBranch %24 %24 = OpLabel OpSelectionMerge %25 None OpBranchConditional %20 %22 %25 %25 = OpLabel OpReturnValue %int_1 %23 = OpLabel OpBranch %21 %22 = OpLabel OpSelectionMerge %26 None OpBranchConditional %20 %27 %26 %27 = OpLabel OpBranch %28 %28 = OpLabel OpLoopMerge %29 %30 None OpBranch %31 %31 = OpLabel OpReturnValue %int_1 %30 = OpLabel OpBranch %28 %29 = OpLabel OpUnreachable %26 = OpLabel OpBranch %17 %17 = OpLabel %16 = OpPhi %int %15 %26 OpBranchConditional %false %14 %18 %18 = OpLabel OpReturnValue %16 OpFunctionEnd )"; SinglePassRunAndMatch(before, true); } TEST_F(MergeReturnPassTest, PointerUsedAfterLoop) { // Make sure that a Phi instruction is not generated for an id whose type is a // pointer. It needs to be regenerated. const std::string before = R"( ; CHECK: OpFunction %void ; CHECK: OpFunction %void ; CHECK-NEXT: [[param:%\w+]] = OpFunctionParameter %_ptr_Function_v2uint ; CHECK: OpLoopMerge [[merge_bb:%\w+]] ; CHECK: [[merge_bb]] = OpLabel ; CHECK-NEXT: [[ac:%\w+]] = OpAccessChain %_ptr_Function_uint [[param]] %uint_1 ; CHECK: OpStore [[ac]] %uint_1 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %void = OpTypeVoid %4 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %8 = OpTypeFunction %void %_ptr_Function_v2uint %uint_1 = OpConstant %uint 1 %bool = OpTypeBool %_ptr_Function_uint = OpTypePointer Function %uint %false = OpConstantFalse %bool %2 = OpFunction %void None %4 %13 = OpLabel %14 = OpVariable %_ptr_Function_v2uint Function %15 = OpFunctionCall %void %16 %14 OpReturn OpFunctionEnd %16 = OpFunction %void None %8 %17 = OpFunctionParameter %_ptr_Function_v2uint %18 = OpLabel OpBranch %19 %19 = OpLabel OpLoopMerge %20 %21 None OpBranch %22 %22 = OpLabel OpSelectionMerge %23 None OpBranchConditional %false %24 %23 %24 = OpLabel OpReturn %23 = OpLabel OpBranch %21 %21 = OpLabel %25 = OpAccessChain %_ptr_Function_uint %17 %uint_1 OpBranchConditional %false %19 %20 %20 = OpLabel OpStore %25 %uint_1 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(before, true); } TEST_F(MergeReturnPassTest, VariablePointerFunctionScope) { // Make sure that a Phi instruction is not generated for an id whose type is a // function scope pointer, even if the VariablePointers capability is // available. It needs to be regenerated. const std::string before = R"( ; CHECK: OpFunction %void ; CHECK: OpFunction %void ; CHECK-NEXT: [[param:%\w+]] = OpFunctionParameter %_ptr_Function_v2uint ; CHECK: OpLoopMerge [[merge_bb:%\w+]] ; CHECK: [[merge_bb]] = OpLabel ; CHECK-NEXT: [[ac:%\w+]] = OpAccessChain %_ptr_Function_uint [[param]] %uint_1 ; CHECK: OpStore [[ac]] %uint_1 OpCapability Shader OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %void = OpTypeVoid %4 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %8 = OpTypeFunction %void %_ptr_Function_v2uint %uint_1 = OpConstant %uint 1 %bool = OpTypeBool %_ptr_Function_uint = OpTypePointer Function %uint %false = OpConstantFalse %bool %2 = OpFunction %void None %4 %13 = OpLabel %14 = OpVariable %_ptr_Function_v2uint Function %15 = OpFunctionCall %void %16 %14 OpReturn OpFunctionEnd %16 = OpFunction %void None %8 %17 = OpFunctionParameter %_ptr_Function_v2uint %18 = OpLabel OpBranch %19 %19 = OpLabel OpLoopMerge %20 %21 None OpBranch %22 %22 = OpLabel OpSelectionMerge %23 None OpBranchConditional %false %24 %23 %24 = OpLabel OpReturn %23 = OpLabel OpBranch %21 %21 = OpLabel %25 = OpAccessChain %_ptr_Function_uint %17 %uint_1 OpBranchConditional %false %19 %20 %20 = OpLabel OpStore %25 %uint_1 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(before, true); } TEST_F(MergeReturnPassTest, ChainedPointerUsedAfterLoop) { // Make sure that a Phi instruction is not generated for an id whose type is a // pointer. It needs to be regenerated. const std::string before = R"( ; CHECK: OpFunction %void ; CHECK: OpFunction %void ; CHECK-NEXT: [[param:%\w+]] = OpFunctionParameter %_ptr_Function_ ; CHECK: OpLoopMerge [[merge_bb:%\w+]] ; CHECK: [[merge_bb]] = OpLabel ; CHECK-NEXT: [[ac1:%\w+]] = OpAccessChain %_ptr_Function_v2uint [[param]] %uint_1 ; CHECK-NEXT: [[ac2:%\w+]] = OpAccessChain %_ptr_Function_uint [[ac1]] %uint_1 ; CHECK: OpStore [[ac2]] %uint_1 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %void = OpTypeVoid %4 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %v2uint = OpTypeVector %uint 2 %_arr_v2uint_uint_2 = OpTypeArray %v2uint %uint_2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %_ptr_Function__arr_v2uint_uint_2 = OpTypePointer Function %_arr_v2uint_uint_2 %_ptr_Function_uint = OpTypePointer Function %uint %13 = OpTypeFunction %void %_ptr_Function__arr_v2uint_uint_2 %bool = OpTypeBool %false = OpConstantFalse %bool %2 = OpFunction %void None %4 %16 = OpLabel %17 = OpVariable %_ptr_Function__arr_v2uint_uint_2 Function %18 = OpFunctionCall %void %19 %17 OpReturn OpFunctionEnd %19 = OpFunction %void None %13 %20 = OpFunctionParameter %_ptr_Function__arr_v2uint_uint_2 %21 = OpLabel OpBranch %22 %22 = OpLabel OpLoopMerge %23 %24 None OpBranch %25 %25 = OpLabel OpSelectionMerge %26 None OpBranchConditional %false %27 %26 %27 = OpLabel OpReturn %26 = OpLabel OpBranch %24 %24 = OpLabel %28 = OpAccessChain %_ptr_Function_v2uint %20 %uint_1 %29 = OpAccessChain %_ptr_Function_uint %28 %uint_1 OpBranchConditional %false %22 %23 %23 = OpLabel OpStore %29 %uint_1 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(before, true); } TEST_F(MergeReturnPassTest, OverflowTest1) { const std::string text = R"( ; CHECK: OpReturn ; CHECK-NOT: OpReturn ; CHECK: OpFunctionEnd OpCapability ClipDistance OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft %void = OpTypeVoid %6 = OpTypeFunction %void %2 = OpFunction %void None %6 %4194303 = OpLabel OpBranch %18 %18 = OpLabel OpLoopMerge %19 %20 None OpBranch %21 %21 = OpLabel OpReturn %20 = OpLabel OpBranch %18 %19 = OpLabel OpUnreachable OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); auto result = SinglePassRunToBinary(text, /* skip_nop = */ true); EXPECT_EQ(Pass::Status::Failure, std::get<1>(result)); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/pass_remove_duplicates_test.cpp000066400000000000000000000416041475742701700266220ustar00rootroot00000000000000// Copyright (c) 2017 Pierre Moreau // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include "source/opt/build_module.h" #include "source/opt/ir_context.h" #include "source/opt/pass_manager.h" #include "source/opt/remove_duplicates_pass.h" #include "source/spirv_constant.h" #include "test/unit_spirv.h" namespace spvtools { namespace opt { namespace { class RemoveDuplicatesTest : public ::testing::Test { public: RemoveDuplicatesTest() : tools_(SPV_ENV_UNIVERSAL_1_2), context_(), consumer_([this](spv_message_level_t level, const char*, const spv_position_t& position, const char* message) { if (!error_message_.empty()) error_message_ += "\n"; switch (level) { case SPV_MSG_FATAL: case SPV_MSG_INTERNAL_ERROR: case SPV_MSG_ERROR: error_message_ += "ERROR"; break; case SPV_MSG_WARNING: error_message_ += "WARNING"; break; case SPV_MSG_INFO: error_message_ += "INFO"; break; case SPV_MSG_DEBUG: error_message_ += "DEBUG"; break; } error_message_ += ": " + std::to_string(position.index) + ": " + message; }), disassemble_options_(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER), error_message_() { tools_.SetMessageConsumer(consumer_); } void TearDown() override { error_message_.clear(); } std::string RunPass(const std::string& text) { context_ = spvtools::BuildModule(SPV_ENV_UNIVERSAL_1_2, consumer_, text); if (!context_.get()) return std::string(); PassManager manager; manager.SetMessageConsumer(consumer_); manager.AddPass(); Pass::Status pass_res = manager.Run(context_.get()); if (pass_res == Pass::Status::Failure) return std::string(); return ModuleToText(); } // Disassembles |binary| and outputs the result in |text|. If |text| is a // null pointer, SPV_ERROR_INVALID_POINTER is returned. spv_result_t Disassemble(const std::vector& binary, std::string* text) { if (!text) return SPV_ERROR_INVALID_POINTER; return tools_.Disassemble(binary, text, disassemble_options_) ? SPV_SUCCESS : SPV_ERROR_INVALID_BINARY; } // Returns the accumulated error messages for the test. std::string GetErrorMessage() const { return error_message_; } std::string ToText(const std::vector& inst) { std::vector binary = {spv::MagicNumber, 0x10200, 0u, 2u, 0u}; for (const Instruction* i : inst) i->ToBinaryWithoutAttachedDebugInsts(&binary); std::string text; Disassemble(binary, &text); return text; } std::string ModuleToText() { std::vector binary; context_->module()->ToBinary(&binary, false); std::string text; Disassemble(binary, &text); return text; } private: spvtools::SpirvTools tools_; // An instance for calling SPIRV-Tools functionalities. std::unique_ptr context_; spvtools::MessageConsumer consumer_; uint32_t disassemble_options_; std::string error_message_; }; TEST_F(RemoveDuplicatesTest, DuplicateCapabilities) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability Shader OpMemoryModel Logical GLSL450 )"; const std::string after = R"(OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 )"; EXPECT_EQ(RunPass(spirv), after); EXPECT_EQ(GetErrorMessage(), ""); } TEST_F(RemoveDuplicatesTest, DuplicateExtInstImports) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage %1 = OpExtInstImport "OpenCL.std" %2 = OpExtInstImport "OpenCL.std" %3 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 )"; const std::string after = R"(OpCapability Shader OpCapability Linkage %1 = OpExtInstImport "OpenCL.std" %3 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 )"; EXPECT_EQ(RunPass(spirv), after); EXPECT_EQ(GetErrorMessage(), ""); } TEST_F(RemoveDuplicatesTest, DuplicateTypes) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeInt 32 0 %2 = OpTypeInt 32 0 %3 = OpTypeStruct %1 %2 )"; const std::string after = R"(OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeInt 32 0 %3 = OpTypeStruct %1 %1 )"; EXPECT_EQ(RunPass(spirv), after); EXPECT_EQ(GetErrorMessage(), ""); } TEST_F(RemoveDuplicatesTest, SameTypeDifferentMemberDecoration) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 GLSLPacked %2 = OpTypeInt 32 0 %1 = OpTypeStruct %2 %2 %3 = OpTypeStruct %2 %2 )"; const std::string after = R"(OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 GLSLPacked %2 = OpTypeInt 32 0 %1 = OpTypeStruct %2 %2 %3 = OpTypeStruct %2 %2 )"; EXPECT_EQ(RunPass(spirv), after); EXPECT_EQ(GetErrorMessage(), ""); } TEST_F(RemoveDuplicatesTest, SameTypeAndMemberDecoration) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 GLSLPacked OpDecorate %2 GLSLPacked %3 = OpTypeInt 32 0 %1 = OpTypeStruct %3 %3 %2 = OpTypeStruct %3 %3 )"; const std::string after = R"(OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 GLSLPacked %3 = OpTypeInt 32 0 %1 = OpTypeStruct %3 %3 )"; EXPECT_EQ(RunPass(spirv), after); EXPECT_EQ(GetErrorMessage(), ""); } TEST_F(RemoveDuplicatesTest, SameTypeAndDifferentName) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %1 "Type1" OpName %2 "Type2" %3 = OpTypeInt 32 0 %1 = OpTypeStruct %3 %3 %2 = OpTypeStruct %3 %3 )"; const std::string after = R"(OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %1 "Type1" %3 = OpTypeInt 32 0 %1 = OpTypeStruct %3 %3 )"; EXPECT_EQ(RunPass(spirv), after); EXPECT_EQ(GetErrorMessage(), ""); } // Check that #1033 has been fixed. TEST_F(RemoveDuplicatesTest, DoNotRemoveDifferentOpDecorationGroup) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 Constant %1 = OpDecorationGroup OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %3 %1 %2 %4 = OpTypeInt 32 0 %3 = OpVariable %4 Uniform )"; const std::string after = R"(OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 Constant %1 = OpDecorationGroup OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %3 %1 %2 %4 = OpTypeInt 32 0 %3 = OpVariable %4 Uniform )"; EXPECT_EQ(RunPass(spirv), after); EXPECT_EQ(GetErrorMessage(), ""); } TEST_F(RemoveDuplicatesTest, DifferentDecorationGroup) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 Constant OpDecorate %1 Restrict %1 = OpDecorationGroup OpDecorate %2 Constant %2 = OpDecorationGroup OpGroupDecorate %1 %3 OpGroupDecorate %2 %4 %5 = OpTypeInt 32 0 %3 = OpVariable %5 Uniform %4 = OpVariable %5 Uniform )"; const std::string after = R"(OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 Constant OpDecorate %1 Restrict %1 = OpDecorationGroup OpDecorate %2 Constant %2 = OpDecorationGroup OpGroupDecorate %1 %3 OpGroupDecorate %2 %4 %5 = OpTypeInt 32 0 %3 = OpVariable %5 Uniform %4 = OpVariable %5 Uniform )"; EXPECT_EQ(RunPass(spirv), after); EXPECT_EQ(GetErrorMessage(), ""); } // Test what happens when a type is a resource type. For now we are merging // them, but, if we want to merge types and make reflection work (issue #1372), // we will not be able to merge %2 and %3 below. TEST_F(RemoveDuplicatesTest, DontMergeNestedResourceTypes) { const std::string spirv = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpSource HLSL 600 OpName %1 "PositionAdjust" OpMemberName %1 0 "XAdjust" OpName %2 "NormalAdjust" OpMemberName %2 0 "XDir" OpMemberName %3 0 "AdjustXYZ" OpMemberName %3 1 "AdjustDir" OpName %4 "Constants" OpMemberDecorate %1 0 Offset 0 OpMemberDecorate %2 0 Offset 0 OpMemberDecorate %3 0 Offset 0 OpMemberDecorate %3 1 Offset 16 OpDecorate %3 Block OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 0 %5 = OpTypeFloat 32 %6 = OpTypeVector %5 3 %1 = OpTypeStruct %6 %2 = OpTypeStruct %6 %3 = OpTypeStruct %1 %2 %7 = OpTypePointer Uniform %3 %4 = OpVariable %7 Uniform )"; const std::string result = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpSource HLSL 600 OpName %1 "PositionAdjust" OpMemberName %1 0 "XAdjust" OpMemberName %3 0 "AdjustXYZ" OpMemberName %3 1 "AdjustDir" OpName %4 "Constants" OpMemberDecorate %1 0 Offset 0 OpMemberDecorate %3 0 Offset 0 OpMemberDecorate %3 1 Offset 16 OpDecorate %3 Block OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 0 %5 = OpTypeFloat 32 %6 = OpTypeVector %5 3 %1 = OpTypeStruct %6 %3 = OpTypeStruct %1 %1 %7 = OpTypePointer Uniform %3 %4 = OpVariable %7 Uniform )"; EXPECT_EQ(RunPass(spirv), result); EXPECT_EQ(GetErrorMessage(), ""); } // See comment for DontMergeNestedResourceTypes. TEST_F(RemoveDuplicatesTest, DontMergeResourceTypes) { const std::string spirv = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpSource HLSL 600 OpName %1 "PositionAdjust" OpMemberName %1 0 "XAdjust" OpName %2 "NormalAdjust" OpMemberName %2 0 "XDir" OpName %3 "Constants" OpMemberDecorate %1 0 Offset 0 OpMemberDecorate %2 0 Offset 0 OpDecorate %3 DescriptorSet 0 OpDecorate %3 Binding 0 OpDecorate %4 DescriptorSet 1 OpDecorate %4 Binding 0 %5 = OpTypeFloat 32 %6 = OpTypeVector %5 3 %1 = OpTypeStruct %6 %2 = OpTypeStruct %6 %7 = OpTypePointer Uniform %1 %8 = OpTypePointer Uniform %2 %3 = OpVariable %7 Uniform %4 = OpVariable %8 Uniform )"; const std::string result = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpSource HLSL 600 OpName %1 "PositionAdjust" OpMemberName %1 0 "XAdjust" OpName %3 "Constants" OpMemberDecorate %1 0 Offset 0 OpDecorate %3 DescriptorSet 0 OpDecorate %3 Binding 0 OpDecorate %4 DescriptorSet 1 OpDecorate %4 Binding 0 %5 = OpTypeFloat 32 %6 = OpTypeVector %5 3 %1 = OpTypeStruct %6 %7 = OpTypePointer Uniform %1 %3 = OpVariable %7 Uniform %4 = OpVariable %7 Uniform )"; EXPECT_EQ(RunPass(spirv), result); EXPECT_EQ(GetErrorMessage(), ""); } // See comment for DontMergeNestedResourceTypes. TEST_F(RemoveDuplicatesTest, DontMergeResourceTypesContainingArray) { const std::string spirv = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpSource HLSL 600 OpName %1 "PositionAdjust" OpMemberName %1 0 "XAdjust" OpName %2 "NormalAdjust" OpMemberName %2 0 "XDir" OpName %3 "Constants" OpMemberDecorate %1 0 Offset 0 OpMemberDecorate %2 0 Offset 0 OpDecorate %3 DescriptorSet 0 OpDecorate %3 Binding 0 OpDecorate %4 DescriptorSet 1 OpDecorate %4 Binding 0 %5 = OpTypeFloat 32 %6 = OpTypeVector %5 3 %1 = OpTypeStruct %6 %2 = OpTypeStruct %6 %7 = OpTypeInt 32 0 %8 = OpConstant %7 4 %9 = OpTypeArray %1 %8 %10 = OpTypeArray %2 %8 %11 = OpTypePointer Uniform %9 %12 = OpTypePointer Uniform %10 %3 = OpVariable %11 Uniform %4 = OpVariable %12 Uniform )"; const std::string result = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpSource HLSL 600 OpName %1 "PositionAdjust" OpMemberName %1 0 "XAdjust" OpName %3 "Constants" OpMemberDecorate %1 0 Offset 0 OpDecorate %3 DescriptorSet 0 OpDecorate %3 Binding 0 OpDecorate %4 DescriptorSet 1 OpDecorate %4 Binding 0 %5 = OpTypeFloat 32 %6 = OpTypeVector %5 3 %1 = OpTypeStruct %6 %7 = OpTypeInt 32 0 %8 = OpConstant %7 4 %9 = OpTypeArray %1 %8 %11 = OpTypePointer Uniform %9 %3 = OpVariable %11 Uniform %4 = OpVariable %11 Uniform )"; EXPECT_EQ(RunPass(spirv), result); EXPECT_EQ(GetErrorMessage(), ""); } // Test that we merge the type of a resource with a type that is not the type // a resource. The resource type appears first in this case. We must keep // the resource type. TEST_F(RemoveDuplicatesTest, MergeResourceTypeWithNonresourceType1) { const std::string spirv = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpSource HLSL 600 OpName %1 "PositionAdjust" OpMemberName %1 0 "XAdjust" OpName %2 "NormalAdjust" OpMemberName %2 0 "XDir" OpName %3 "Constants" OpMemberDecorate %1 0 Offset 0 OpMemberDecorate %2 0 Offset 0 OpDecorate %3 DescriptorSet 0 OpDecorate %3 Binding 0 %4 = OpTypeFloat 32 %5 = OpTypeVector %4 3 %1 = OpTypeStruct %5 %2 = OpTypeStruct %5 %6 = OpTypePointer Uniform %1 %7 = OpTypePointer Uniform %2 %3 = OpVariable %6 Uniform %8 = OpVariable %7 Uniform )"; const std::string result = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpSource HLSL 600 OpName %1 "PositionAdjust" OpMemberName %1 0 "XAdjust" OpName %3 "Constants" OpMemberDecorate %1 0 Offset 0 OpDecorate %3 DescriptorSet 0 OpDecorate %3 Binding 0 %4 = OpTypeFloat 32 %5 = OpTypeVector %4 3 %1 = OpTypeStruct %5 %6 = OpTypePointer Uniform %1 %3 = OpVariable %6 Uniform %8 = OpVariable %6 Uniform )"; EXPECT_EQ(RunPass(spirv), result); EXPECT_EQ(GetErrorMessage(), ""); } // Test that we merge the type of a resource with a type that is not the type // a resource. The resource type appears second in this case. We must keep // the resource type. // // See comment for DontMergeNestedResourceTypes. TEST_F(RemoveDuplicatesTest, MergeResourceTypeWithNonresourceType2) { const std::string spirv = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpSource HLSL 600 OpName %1 "PositionAdjust" OpMemberName %1 0 "XAdjust" OpName %2 "NormalAdjust" OpMemberName %2 0 "XDir" OpName %3 "Constants" OpMemberDecorate %1 0 Offset 0 OpMemberDecorate %2 0 Offset 0 OpDecorate %3 DescriptorSet 0 OpDecorate %3 Binding 0 %4 = OpTypeFloat 32 %5 = OpTypeVector %4 3 %1 = OpTypeStruct %5 %2 = OpTypeStruct %5 %6 = OpTypePointer Uniform %1 %7 = OpTypePointer Uniform %2 %8 = OpVariable %6 Uniform %3 = OpVariable %7 Uniform )"; const std::string result = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpSource HLSL 600 OpName %1 "PositionAdjust" OpMemberName %1 0 "XAdjust" OpName %3 "Constants" OpMemberDecorate %1 0 Offset 0 OpDecorate %3 DescriptorSet 0 OpDecorate %3 Binding 0 %4 = OpTypeFloat 32 %5 = OpTypeVector %4 3 %1 = OpTypeStruct %5 %6 = OpTypePointer Uniform %1 %8 = OpVariable %6 Uniform %3 = OpVariable %6 Uniform )"; EXPECT_EQ(RunPass(spirv), result); EXPECT_EQ(GetErrorMessage(), ""); } // In this test, %8 and %9 are the same and only %9 is used in a resource. // However, we cannot merge them unless we also merge %2 and %3, which cannot // happen because both are used in resources. // // If we try to avoid replaces resource types, then remove duplicates should // have not change in this case. That is not currently implemented. TEST_F(RemoveDuplicatesTest, MergeResourceTypeWithNonresourceType3) { const std::string spirv = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpSource HLSL 600 OpName %2 "PositionAdjust" OpMemberName %2 0 "XAdjust" OpName %3 "NormalAdjust" OpMemberName %3 0 "XDir" OpName %4 "Constants" OpMemberDecorate %2 0 Offset 0 OpMemberDecorate %3 0 Offset 0 OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 0 OpDecorate %5 DescriptorSet 1 OpDecorate %5 Binding 0 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 3 %2 = OpTypeStruct %7 %3 = OpTypeStruct %7 %8 = OpTypePointer Uniform %3 %9 = OpTypePointer Uniform %2 %10 = OpTypeStruct %3 %11 = OpTypePointer Uniform %10 %5 = OpVariable %9 Uniform %4 = OpVariable %11 Uniform %12 = OpTypeVoid %13 = OpTypeFunction %12 %14 = OpTypeInt 32 0 %15 = OpConstant %14 0 %1 = OpFunction %12 None %13 %16 = OpLabel %17 = OpAccessChain %8 %4 %15 OpReturn OpFunctionEnd )"; const std::string result = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpSource HLSL 600 OpName %2 "PositionAdjust" OpMemberName %2 0 "XAdjust" OpName %4 "Constants" OpMemberDecorate %2 0 Offset 0 OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 0 OpDecorate %5 DescriptorSet 1 OpDecorate %5 Binding 0 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 3 %2 = OpTypeStruct %7 %8 = OpTypePointer Uniform %2 %10 = OpTypeStruct %2 %11 = OpTypePointer Uniform %10 %5 = OpVariable %8 Uniform %4 = OpVariable %11 Uniform %12 = OpTypeVoid %13 = OpTypeFunction %12 %14 = OpTypeInt 32 0 %15 = OpConstant %14 0 %1 = OpFunction %12 None %13 %16 = OpLabel %17 = OpAccessChain %8 %4 %15 OpReturn OpFunctionEnd )"; EXPECT_EQ(RunPass(spirv), result); EXPECT_EQ(GetErrorMessage(), ""); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/pass_utils.cpp000066400000000000000000000066701475742701700232150ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "test/opt/pass_utils.h" #include #include namespace spvtools { namespace opt { namespace { // Well, this is another place requiring the knowledge of the grammar and can be // stale when SPIR-V is updated. It would be nice to automatically generate // this, but the cost is just too high. const char* kDebugOpcodes[] = { // clang-format off "OpSourceContinued", "OpSource", "OpSourceExtension", "OpName", "OpMemberName", "OpString", "OpLine", "OpNoLine", "OpModuleProcessed" // clang-format on }; } // anonymous namespace MessageConsumer GetTestMessageConsumer( std::vector& expected_messages) { return [&expected_messages](spv_message_level_t level, const char* source, const spv_position_t& position, const char* message) { EXPECT_TRUE(!expected_messages.empty()); if (expected_messages.empty()) { return; } EXPECT_EQ(expected_messages[0].level, level); EXPECT_EQ(expected_messages[0].line_number, position.line); EXPECT_EQ(expected_messages[0].column_number, position.column); EXPECT_STREQ(expected_messages[0].source_file, source); EXPECT_STREQ(expected_messages[0].message, message); expected_messages.erase(expected_messages.begin()); }; } bool FindAndReplace(std::string* process_str, const std::string find_str, const std::string replace_str) { if (process_str->empty() || find_str.empty()) { return false; } bool replaced = false; // Note this algorithm has quadratic time complexity. It is OK for test cases // with short strings, but might not fit in other contexts. for (size_t pos = process_str->find(find_str, 0); pos != std::string::npos; pos = process_str->find(find_str, pos)) { process_str->replace(pos, find_str.length(), replace_str); pos += replace_str.length(); replaced = true; } return replaced; } bool ContainsDebugOpcode(const char* inst) { return std::any_of(std::begin(kDebugOpcodes), std::end(kDebugOpcodes), [inst](const char* op) { return std::string(inst).find(op) != std::string::npos; }); } std::string SelectiveJoin(const std::vector& strings, const std::function& skip_dictator, char delimiter) { std::ostringstream oss; for (const auto* str : strings) { if (!skip_dictator(str)) oss << str << delimiter; } return oss.str(); } std::string JoinAllInsts(const std::vector& insts) { return SelectiveJoin(insts, [](const char*) { return false; }); } std::string JoinNonDebugInsts(const std::vector& insts) { return SelectiveJoin( insts, [](const char* inst) { return ContainsDebugOpcode(inst); }); } } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/pass_utils.h000066400000000000000000000061501475742701700226530ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef TEST_OPT_PASS_UTILS_H_ #define TEST_OPT_PASS_UTILS_H_ #include #include #include #include #include #include "gtest/gtest.h" #include "include/spirv-tools/libspirv.h" #include "include/spirv-tools/libspirv.hpp" namespace spvtools { namespace opt { struct Message { spv_message_level_t level; const char* source_file; uint32_t line_number; uint32_t column_number; const char* message; }; // Return a message consumer that can be used to check that the message produced // are the messages in |expexted_messages|, and in the same order. MessageConsumer GetTestMessageConsumer(std::vector& expected_messages); // In-place substring replacement. Finds the |find_str| in the |process_str| // and replaces the found substring with |replace_str|. Returns true if at // least one replacement is done successfully, returns false otherwise. The // replaced substring won't be processed again, which means: If the // |replace_str| has |find_str| as its substring, that newly replaced part of // |process_str| won't be processed again. bool FindAndReplace(std::string* process_str, const std::string find_str, const std::string replace_str); // Returns true if the given string contains any debug opcode substring. bool ContainsDebugOpcode(const char* inst); // Returns the concatenated string from a vector of |strings|, with postfixing // each string with the given |delimiter|. if the |skip_dictator| returns true // for an original string, that string will be omitted. std::string SelectiveJoin(const std::vector& strings, const std::function& skip_dictator, char delimiter = '\n'); // Concatenates a vector of strings into one string. Each string is postfixed // with '\n'. std::string JoinAllInsts(const std::vector& insts); // Concatenates a vector of strings into one string. Each string is postfixed // with '\n'. If a string contains opcode for debug instruction, that string // will be ignored. std::string JoinNonDebugInsts(const std::vector& insts); // Returns a vector that contains the contents of |a| followed by the contents // of |b|. template std::vector Concat(const std::vector& a, const std::vector& b) { std::vector ret; std::copy(a.begin(), a.end(), back_inserter(ret)); std::copy(b.begin(), b.end(), back_inserter(ret)); return ret; } } // namespace opt } // namespace spvtools #endif // TEST_OPT_PASS_UTILS_H_ KhronosGroup-SPIRV-Tools-f289d04/test/opt/pch_test_opt.cpp000066400000000000000000000011661475742701700235150ustar00rootroot00000000000000// Copyright (c) 2018 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "pch_test_opt.h" KhronosGroup-SPIRV-Tools-f289d04/test/opt/pch_test_opt.h000066400000000000000000000017411475742701700231610ustar00rootroot00000000000000// Copyright (c) 2018 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "gmock/gmock.h" #include "source/opt/iterator.h" #include "source/opt/loop_dependence.h" #include "source/opt/loop_descriptor.h" #include "source/opt/pass.h" #include "source/opt/scalar_analysis.h" #include "source/opt/tree_iterator.h" #include "test/opt/assembly_builder.h" #include "test/opt/function_utils.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" KhronosGroup-SPIRV-Tools-f289d04/test/opt/private_to_local_test.cpp000066400000000000000000000430331475742701700254060ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gmock/gmock.h" #include "source/opt/value_number_table.h" #include "test/opt/assembly_builder.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using ::testing::HasSubstr; using ::testing::MatchesRegex; using PrivateToLocalTest = PassTest<::testing::Test>; TEST_F(PrivateToLocalTest, ChangeToLocal) { // Change the private variable to a local, and change the types accordingly. const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 ; CHECK: [[float:%[a-zA-Z_\d]+]] = OpTypeFloat 32 %5 = OpTypeFloat 32 ; CHECK: [[newtype:%[a-zA-Z_\d]+]] = OpTypePointer Function [[float]] %6 = OpTypePointer Private %5 ; CHECK-NOT: OpVariable [[.+]] Private %8 = OpVariable %6 Private ; CHECK: OpFunction %2 = OpFunction %3 None %4 ; CHECK: OpLabel %7 = OpLabel ; CHECK-NEXT: [[newvar:%[a-zA-Z_\d]+]] = OpVariable [[newtype]] Function ; CHECK: OpLoad [[float]] [[newvar]] %9 = OpLoad %5 %8 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(PrivateToLocalTest, ReuseExistingType) { // Change the private variable to a local, and change the types accordingly. const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 ; CHECK: [[float:%[a-zA-Z_\d]+]] = OpTypeFloat 32 %5 = OpTypeFloat 32 %func_ptr = OpTypePointer Function %5 ; CHECK: [[newtype:%[a-zA-Z_\d]+]] = OpTypePointer Function [[float]] ; CHECK-NOT: [[%[a-zA-Z_\d]+]] = OpTypePointer Function [[float]] %6 = OpTypePointer Private %5 ; CHECK-NOT: OpVariable [[.+]] Private %8 = OpVariable %6 Private ; CHECK: OpFunction %2 = OpFunction %3 None %4 ; CHECK: OpLabel %7 = OpLabel ; CHECK-NEXT: [[newvar:%[a-zA-Z_\d]+]] = OpVariable [[newtype]] Function ; CHECK: OpLoad [[float]] [[newvar]] %9 = OpLoad %5 %8 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(PrivateToLocalTest, UpdateAccessChain) { // Change the private variable to a local, and change the AccessChain. const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %void = OpTypeVoid %6 = OpTypeFunction %void ; CHECK: [[float:%[a-zA-Z_\d]+]] = OpTypeFloat %float = OpTypeFloat 32 ; CHECK: [[struct:%[a-zA-Z_\d]+]] = OpTypeStruct %_struct_8 = OpTypeStruct %float %_ptr_Private_float = OpTypePointer Private %float ; CHECK: [[new_struct_type:%[a-zA-Z_\d]+]] = OpTypePointer Function [[struct]] ; CHECK: [[new_float_type:%[a-zA-Z_\d]+]] = OpTypePointer Function [[float]] %_ptr_Private__struct_8 = OpTypePointer Private %_struct_8 ; CHECK-NOT: OpVariable [[.+]] Private %11 = OpVariable %_ptr_Private__struct_8 Private ; CHECK: OpFunction %2 = OpFunction %void None %6 ; CHECK: OpLabel %12 = OpLabel ; CHECK-NEXT: [[newvar:%[a-zA-Z_\d]+]] = OpVariable [[new_struct_type]] Function ; CHECK: [[member:%[a-zA-Z_\d]+]] = OpAccessChain [[new_float_type]] [[newvar]] %13 = OpAccessChain %_ptr_Private_float %11 %uint_0 ; CHECK: OpLoad [[float]] [[member]] %14 = OpLoad %float %13 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(PrivateToLocalTest, UseTexelPointer) { // Change the private variable to a local, and change the OpImageTexelPointer. const std::string text = R"( OpCapability SampledBuffer OpCapability StorageImageExtendedFormats OpCapability ImageBuffer OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "min" %gl_GlobalInvocationID OpExecutionMode %2 LocalSize 64 1 1 OpSource HLSL 600 OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId OpDecorate %4 DescriptorSet 4 OpDecorate %4 Binding 70 %uint = OpTypeInt 32 0 %6 = OpTypeImage %uint Buffer 0 0 0 2 R32ui %_ptr_UniformConstant_6 = OpTypePointer UniformConstant %6 %_ptr_Private_6 = OpTypePointer Private %6 %void = OpTypeVoid %10 = OpTypeFunction %void %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %_ptr_Image_uint = OpTypePointer Image %uint %4 = OpVariable %_ptr_UniformConstant_6 UniformConstant %16 = OpVariable %_ptr_Private_6 Private %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %2 = OpFunction %void None %10 %17 = OpLabel ; Make sure the variable was moved. ; CHECK: OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpVariable %_ptr_Function_6 Function %18 = OpLoad %6 %4 OpStore %16 %18 %19 = OpImageTexelPointer %_ptr_Image_uint %16 %uint_0 %uint_0 %20 = OpAtomicIAdd %uint %19 %uint_1 %uint_0 %uint_1 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(PrivateToLocalTest, UsedInTwoFunctions) { // Should not change because it is used in multiple functions. const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %6 = OpTypePointer Private %5 %8 = OpVariable %6 Private %2 = OpFunction %3 None %4 %7 = OpLabel %9 = OpLoad %5 %8 OpReturn OpFunctionEnd %10 = OpFunction %3 None %4 %11 = OpLabel %12 = OpLoad %5 %8 OpReturn OpFunctionEnd )"; auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ false); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } TEST_F(PrivateToLocalTest, UsedInFunctionCall) { // Should not change because it is used in a function call. Changing the // signature of the function would require cloning the function, which is not // worth it. const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %void = OpTypeVoid %4 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Private_float = OpTypePointer Private %float %7 = OpTypeFunction %void %_ptr_Private_float %8 = OpVariable %_ptr_Private_float Private %2 = OpFunction %void None %4 %9 = OpLabel %10 = OpFunctionCall %void %11 %8 OpReturn OpFunctionEnd %11 = OpFunction %void None %7 %12 = OpFunctionParameter %_ptr_Private_float %13 = OpLabel %14 = OpLoad %float %12 OpReturn OpFunctionEnd )"; auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ false); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } TEST_F(PrivateToLocalTest, CreatePointerToAmbiguousStruct1) { // Test that the correct pointer type is picked up. const std::string text = R"( ; CHECK: [[struct1:%[a-zA-Z_\d]+]] = OpTypeStruct ; CHECK: [[struct2:%[a-zA-Z_\d]+]] = OpTypeStruct ; CHECK: [[priv_ptr:%[\w]+]] = OpTypePointer Private [[struct1]] ; CHECK: [[fuct_ptr2:%[\w]+]] = OpTypePointer Function [[struct2]] ; CHECK: [[fuct_ptr1:%[\w]+]] = OpTypePointer Function [[struct1]] ; CHECK: OpFunction ; CHECK: OpLabel ; CHECK-NEXT: [[newvar:%[a-zA-Z_\d]+]] = OpVariable [[fuct_ptr1]] Function ; CHECK: OpLoad [[struct1]] [[newvar]] OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %struct1 = OpTypeStruct %5 %struct2 = OpTypeStruct %5 %6 = OpTypePointer Private %struct1 %func_ptr2 = OpTypePointer Function %struct2 %8 = OpVariable %6 Private %2 = OpFunction %3 None %4 %7 = OpLabel %9 = OpLoad %struct1 %8 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(PrivateToLocalTest, CreatePointerToAmbiguousStruct2) { // Test that the correct pointer type is picked up. const std::string text = R"( ; CHECK: [[struct1:%[a-zA-Z_\d]+]] = OpTypeStruct ; CHECK: [[struct2:%[a-zA-Z_\d]+]] = OpTypeStruct ; CHECK: [[priv_ptr:%[\w]+]] = OpTypePointer Private [[struct2]] ; CHECK: [[fuct_ptr1:%[\w]+]] = OpTypePointer Function [[struct1]] ; CHECK: [[fuct_ptr2:%[\w]+]] = OpTypePointer Function [[struct2]] ; CHECK: OpFunction ; CHECK: OpLabel ; CHECK-NEXT: [[newvar:%[a-zA-Z_\d]+]] = OpVariable [[fuct_ptr2]] Function ; CHECK: OpLoad [[struct2]] [[newvar]] OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %struct1 = OpTypeStruct %5 %struct2 = OpTypeStruct %5 %6 = OpTypePointer Private %struct2 %func_ptr2 = OpTypePointer Function %struct1 %8 = OpVariable %6 Private %2 = OpFunction %3 None %4 %7 = OpLabel %9 = OpLoad %struct2 %8 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(PrivateToLocalTest, SPV14RemoveFromInterface) { const std::string text = R"( ; CHECK-NOT: OpEntryPoint GLCompute %foo "foo" %in %priv ; CHECK: OpEntryPoint GLCompute %foo "foo" %in ; CHECK: %priv = OpVariable {{%\w+}} Function OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %foo "foo" %in %priv OpExecutionMode %foo LocalSize 1 1 1 OpName %foo "foo" OpName %in "in" OpName %priv "priv" %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr_ssbo_int = OpTypePointer StorageBuffer %int %ptr_private_int = OpTypePointer Private %int %in = OpVariable %ptr_ssbo_int StorageBuffer %priv = OpVariable %ptr_private_int Private %void_fn = OpTypeFunction %void %foo = OpFunction %void None %void_fn %entry = OpLabel %ld = OpLoad %int %in OpStore %priv %ld OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_UNIVERSAL_1_4); SinglePassRunAndMatch(text, true); } TEST_F(PrivateToLocalTest, SPV14RemoveFromInterfaceMultipleEntryPoints) { const std::string text = R"( ; CHECK-NOT: OpEntryPoint GLCompute %foo "foo" %in %priv ; CHECK-NOT: OpEntryPoint GLCompute %foo "bar" %in %priv ; CHECK: OpEntryPoint GLCompute %foo "foo" %in ; CHECK: OpEntryPoint GLCompute %foo "bar" %in ; CHECK: %priv = OpVariable {{%\w+}} Function OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %foo "foo" %in %priv OpEntryPoint GLCompute %foo "bar" %in %priv OpExecutionMode %foo LocalSize 1 1 1 OpName %foo "foo" OpName %in "in" OpName %priv "priv" %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr_ssbo_int = OpTypePointer StorageBuffer %int %ptr_private_int = OpTypePointer Private %int %in = OpVariable %ptr_ssbo_int StorageBuffer %priv = OpVariable %ptr_private_int Private %void_fn = OpTypeFunction %void %foo = OpFunction %void None %void_fn %entry = OpLabel %ld = OpLoad %int %in OpStore %priv %ld OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_UNIVERSAL_1_4); SinglePassRunAndMatch(text, true); } TEST_F(PrivateToLocalTest, SPV14RemoveFromInterfaceMultipleVariables) { const std::string text = R"( ; CHECK-NOT: OpEntryPoint GLCompute %foo "foo" %in %priv1 %priv2 ; CHECK: OpEntryPoint GLCompute %foo "foo" %in ; CHECK: %priv1 = OpVariable {{%\w+}} Function ; CHECK: %priv2 = OpVariable {{%\w+}} Function OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %foo "foo" %in %priv1 %priv2 OpExecutionMode %foo LocalSize 1 1 1 OpName %foo "foo" OpName %in "in" OpName %priv1 "priv1" OpName %priv2 "priv2" %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr_ssbo_int = OpTypePointer StorageBuffer %int %ptr_private_int = OpTypePointer Private %int %in = OpVariable %ptr_ssbo_int StorageBuffer %priv1 = OpVariable %ptr_private_int Private %priv2 = OpVariable %ptr_private_int Private %void_fn = OpTypeFunction %void %foo = OpFunction %void None %void_fn %entry = OpLabel %1 = OpFunctionCall %void %bar1 %2 = OpFunctionCall %void %bar2 OpReturn OpFunctionEnd %bar1 = OpFunction %void None %void_fn %3 = OpLabel %ld1 = OpLoad %int %in OpStore %priv1 %ld1 OpReturn OpFunctionEnd %bar2 = OpFunction %void None %void_fn %4 = OpLabel %ld2 = OpLoad %int %in OpStore %priv2 %ld2 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_UNIVERSAL_1_4); SinglePassRunAndMatch(text, true); } TEST_F(PrivateToLocalTest, IdBoundOverflow1) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginLowerLeft OpSource HLSL 84 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypeStruct %7 %4194302 = OpTypeStruct %8 %8 %9 = OpTypeStruct %8 %8 %11 = OpTypePointer Private %7 %18 = OpTypeStruct %6 %9 %12 = OpVariable %11 Private %4 = OpFunction %2 None %3 %5 = OpLabel %13 = OpLoad %7 %12 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); std::vector messages = { {SPV_MSG_ERROR, "", 0, 0, "ID overflow. Try running compact-ids."}}; SetMessageConsumer(GetTestMessageConsumer(messages)); auto result = SinglePassRunToBinary(text, true); EXPECT_EQ(Pass::Status::Failure, std::get<1>(result)); } TEST_F(PrivateToLocalTest, DebugPrivateToLocal) { // Debug instructions must not have any impact on changing the private // variable to a local. const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" %10 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft %11 = OpString "test" OpSource GLSL 430 %13 = OpTypeInt 32 0 %14 = OpConstant %13 32 %3 = OpTypeVoid %4 = OpTypeFunction %3 ; CHECK: [[float:%[a-zA-Z_\d]+]] = OpTypeFloat 32 %5 = OpTypeFloat 32 ; CHECK: [[newtype:%[a-zA-Z_\d]+]] = OpTypePointer Function [[float]] %6 = OpTypePointer Private %5 ; CHECK-NOT: OpVariable [[.+]] Private %8 = OpVariable %6 Private %12 = OpExtInst %3 %10 DebugTypeBasic %11 %14 Float %15 = OpExtInst %3 %10 DebugSource %11 %16 = OpExtInst %3 %10 DebugCompilationUnit 1 4 %15 GLSL ; CHECK-NOT: DebugGlobalVariable ; CHECK: [[dbg_newvar:%[a-zA-Z_\d]+]] = OpExtInst {{%\w+}} {{%\w+}} DebugLocalVariable %17 = OpExtInst %3 %10 DebugGlobalVariable %11 %12 %15 0 0 %16 %11 %8 FlagIsDefinition ; CHECK: OpFunction %2 = OpFunction %3 None %4 ; CHECK: OpLabel %7 = OpLabel ; CHECK-NEXT: [[newvar:%[a-zA-Z_\d]+]] = OpVariable [[newtype]] Function ; CHECK-NEXT: DebugDeclare [[dbg_newvar]] [[newvar]] ; CHECK: OpLoad [[float]] [[newvar]] %9 = OpLoad %5 %8 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/propagator_test.cpp000066400000000000000000000156671475742701700242520ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/propagator.h" #include #include #include #include "gmock/gmock.h" #include "gtest/gtest.h" #include "source/opt/build_module.h" #include "source/opt/cfg.h" #include "source/opt/ir_context.h" namespace spvtools { namespace opt { namespace { using ::testing::UnorderedElementsAre; class PropagatorTest : public testing::Test { protected: virtual void TearDown() { ctx_.reset(nullptr); values_.clear(); values_vec_.clear(); } void Assemble(const std::string& input) { ctx_ = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, input); ASSERT_NE(nullptr, ctx_) << "Assembling failed for shader:\n" << input << "\n"; } bool Propagate(const SSAPropagator::VisitFunction& visit_fn) { SSAPropagator propagator(ctx_.get(), visit_fn); bool retval = false; for (auto& fn : *ctx_->module()) { retval |= propagator.Run(&fn); } return retval; } const std::vector& GetValues() { values_vec_.clear(); for (const auto& it : values_) { values_vec_.push_back(it.second); } return values_vec_; } std::unique_ptr ctx_; std::map values_; std::vector values_vec_; }; TEST_F(PropagatorTest, LocalPropagate) { const std::string spv_asm = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %outparm OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %x "x" OpName %y "y" OpName %z "z" OpName %outparm "outparm" OpDecorate %outparm Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_4 = OpConstant %int 4 %int_3 = OpConstant %int 3 %int_1 = OpConstant %int 1 %_ptr_Output_int = OpTypePointer Output %int %outparm = OpVariable %_ptr_Output_int Output %main = OpFunction %void None %3 %5 = OpLabel %x = OpVariable %_ptr_Function_int Function %y = OpVariable %_ptr_Function_int Function %z = OpVariable %_ptr_Function_int Function OpStore %x %int_4 OpStore %y %int_3 OpStore %z %int_1 %20 = OpLoad %int %z OpStore %outparm %20 OpReturn OpFunctionEnd )"; Assemble(spv_asm); const auto visit_fn = [this](Instruction* instr, BasicBlock** dest_bb) { *dest_bb = nullptr; if (instr->opcode() == spv::Op::OpStore) { uint32_t lhs_id = instr->GetSingleWordOperand(0); uint32_t rhs_id = instr->GetSingleWordOperand(1); Instruction* rhs_def = ctx_->get_def_use_mgr()->GetDef(rhs_id); if (rhs_def->opcode() == spv::Op::OpConstant) { uint32_t val = rhs_def->GetSingleWordOperand(2); values_[lhs_id] = val; return SSAPropagator::kInteresting; } } return SSAPropagator::kVarying; }; EXPECT_TRUE(Propagate(visit_fn)); EXPECT_THAT(GetValues(), UnorderedElementsAre(4, 3, 1)); } TEST_F(PropagatorTest, PropagateThroughPhis) { const std::string spv_asm = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %x %outparm OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %x "x" OpName %outparm "outparm" OpDecorate %x Flat OpDecorate %x Location 0 OpDecorate %outparm Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %bool = OpTypeBool %_ptr_Function_int = OpTypePointer Function %int %int_4 = OpConstant %int 4 %int_3 = OpConstant %int 3 %int_1 = OpConstant %int 1 %_ptr_Input_int = OpTypePointer Input %int %x = OpVariable %_ptr_Input_int Input %_ptr_Output_int = OpTypePointer Output %int %outparm = OpVariable %_ptr_Output_int Output %main = OpFunction %void None %3 %4 = OpLabel %5 = OpLoad %int %x %6 = OpSGreaterThan %bool %5 %int_3 OpSelectionMerge %25 None OpBranchConditional %6 %22 %23 %22 = OpLabel %7 = OpLoad %int %int_4 OpBranch %25 %23 = OpLabel %8 = OpLoad %int %int_4 OpBranch %25 %25 = OpLabel %35 = OpPhi %int %7 %22 %8 %23 OpStore %outparm %35 OpReturn OpFunctionEnd )"; Assemble(spv_asm); Instruction* phi_instr = nullptr; const auto visit_fn = [this, &phi_instr](Instruction* instr, BasicBlock** dest_bb) { *dest_bb = nullptr; if (instr->opcode() == spv::Op::OpLoad) { uint32_t rhs_id = instr->GetSingleWordOperand(2); Instruction* rhs_def = ctx_->get_def_use_mgr()->GetDef(rhs_id); if (rhs_def->opcode() == spv::Op::OpConstant) { uint32_t val = rhs_def->GetSingleWordOperand(2); values_[instr->result_id()] = val; return SSAPropagator::kInteresting; } } else if (instr->opcode() == spv::Op::OpPhi) { phi_instr = instr; SSAPropagator::PropStatus retval = SSAPropagator::kNotInteresting; for (uint32_t i = 2; i < instr->NumOperands(); i += 2) { uint32_t phi_arg_id = instr->GetSingleWordOperand(i); auto it = values_.find(phi_arg_id); if (it != values_.end()) { EXPECT_EQ(it->second, 4u); retval = SSAPropagator::kInteresting; values_[instr->result_id()] = it->second; } else { retval = SSAPropagator::kNotInteresting; break; } } return retval; } return SSAPropagator::kVarying; }; EXPECT_TRUE(Propagate(visit_fn)); // The propagator should've concluded that the Phi instruction has a constant // value of 4. EXPECT_NE(phi_instr, nullptr); EXPECT_EQ(values_[phi_instr->result_id()], 4u); EXPECT_THAT(GetValues(), UnorderedElementsAre(4u, 4u, 4u)); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/reduce_load_size_test.cpp000066400000000000000000000523541475742701700253660ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace { const double kDefaultLoadReductionThreshold = 0.9; } // namespace namespace spvtools { namespace opt { namespace { using ReduceLoadSizeTest = PassTest<::testing::Test>; TEST_F(ReduceLoadSizeTest, cbuffer_load_extract) { // Originally from the following HLSL: // struct S { // uint f; // }; // // // cbuffer gBuffer { uint a[32]; }; // // RWStructuredBuffer gRWSBuffer; // // uint foo(uint p[32]) { // return p[1]; // } // // [numthreads(1,1,1)] // void main() { // gRWSBuffer[0].f = foo(a); // } const std::string test = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource HLSL 600 OpName %type_gBuffer "type.gBuffer" OpMemberName %type_gBuffer 0 "a" OpName %gBuffer "gBuffer" OpName %S "S" OpMemberName %S 0 "f" OpName %type_RWStructuredBuffer_S "type.RWStructuredBuffer.S" OpName %gRWSBuffer "gRWSBuffer" OpName %main "main" OpDecorate %_arr_uint_uint_32 ArrayStride 16 OpMemberDecorate %type_gBuffer 0 Offset 0 OpDecorate %type_gBuffer Block OpMemberDecorate %S 0 Offset 0 OpDecorate %_runtimearr_S ArrayStride 4 OpMemberDecorate %type_RWStructuredBuffer_S 0 Offset 0 OpDecorate %type_RWStructuredBuffer_S BufferBlock OpDecorate %gBuffer DescriptorSet 0 OpDecorate %gBuffer Binding 0 OpDecorate %gRWSBuffer DescriptorSet 0 OpDecorate %gRWSBuffer Binding 1 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %_arr_uint_uint_32 = OpTypeArray %uint %uint_32 %type_gBuffer = OpTypeStruct %_arr_uint_uint_32 %_ptr_Uniform_type_gBuffer = OpTypePointer Uniform %type_gBuffer %S = OpTypeStruct %uint %_runtimearr_S = OpTypeRuntimeArray %S %type_RWStructuredBuffer_S = OpTypeStruct %_runtimearr_S %_ptr_Uniform_type_RWStructuredBuffer_S = OpTypePointer Uniform %type_RWStructuredBuffer_S %int = OpTypeInt 32 1 %void = OpTypeVoid %15 = OpTypeFunction %void %int_0 = OpConstant %int 0 %_ptr_Uniform__arr_uint_uint_32 = OpTypePointer Uniform %_arr_uint_uint_32 %uint_0 = OpConstant %uint 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %gBuffer = OpVariable %_ptr_Uniform_type_gBuffer Uniform %gRWSBuffer = OpVariable %_ptr_Uniform_type_RWStructuredBuffer_S Uniform %main = OpFunction %void None %15 %20 = OpLabel ; CHECK: [[ac1:%\w+]] = OpAccessChain {{%\w+}} %gBuffer %int_0 ; CHECK: [[ac2:%\w+]] = OpAccessChain {{%\w+}} [[ac1]] %uint_1 ; CHECK: [[ld:%\w+]] = OpLoad {{%\w+}} [[ac2]] ; CHECK: OpStore {{%\w+}} [[ld]] %21 = OpAccessChain %_ptr_Uniform__arr_uint_uint_32 %gBuffer %int_0 %22 = OpLoad %_arr_uint_uint_32 %21 ; Load of 32-element array. %23 = OpCompositeExtract %uint %22 1 %24 = OpAccessChain %_ptr_Uniform_uint %gRWSBuffer %int_0 %uint_0 %int_0 OpStore %24 %23 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); SinglePassRunAndMatch(test, false, kDefaultLoadReductionThreshold); } TEST_F(ReduceLoadSizeTest, cbuffer_load_extract_not_affected_by_debug_instr) { // Originally from the following HLSL: // struct S { // uint f; // }; // // // cbuffer gBuffer { uint a[32]; }; // // RWStructuredBuffer gRWSBuffer; // // uint foo(uint p[32]) { // return p[1]; // } // // [numthreads(1,1,1)] // void main() { // gRWSBuffer[0].f = foo(a); // } const std::string test = R"( OpCapability Shader %ext = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource HLSL 600 %file_name = OpString "test" %float_name = OpString "float" %main_name = OpString "main" %f_name = OpString "f" OpName %type_gBuffer "type.gBuffer" OpMemberName %type_gBuffer 0 "a" OpName %gBuffer "gBuffer" OpName %S "S" OpMemberName %S 0 "f" OpName %type_RWStructuredBuffer_S "type.RWStructuredBuffer.S" OpName %gRWSBuffer "gRWSBuffer" OpName %main "main" OpDecorate %_arr_uint_uint_32 ArrayStride 16 OpMemberDecorate %type_gBuffer 0 Offset 0 OpDecorate %type_gBuffer Block OpMemberDecorate %S 0 Offset 0 OpDecorate %_runtimearr_S ArrayStride 4 OpMemberDecorate %type_RWStructuredBuffer_S 0 Offset 0 OpDecorate %type_RWStructuredBuffer_S BufferBlock OpDecorate %gBuffer DescriptorSet 0 OpDecorate %gBuffer Binding 0 OpDecorate %gRWSBuffer DescriptorSet 0 OpDecorate %gRWSBuffer Binding 1 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %_arr_uint_uint_32 = OpTypeArray %uint %uint_32 %type_gBuffer = OpTypeStruct %_arr_uint_uint_32 %_ptr_Uniform_type_gBuffer = OpTypePointer Uniform %type_gBuffer %S = OpTypeStruct %uint %_runtimearr_S = OpTypeRuntimeArray %S %type_RWStructuredBuffer_S = OpTypeStruct %_runtimearr_S %_ptr_Uniform_type_RWStructuredBuffer_S = OpTypePointer Uniform %type_RWStructuredBuffer_S %int = OpTypeInt 32 1 %void = OpTypeVoid %15 = OpTypeFunction %void %int_0 = OpConstant %int 0 %_ptr_Uniform__arr_uint_uint_32 = OpTypePointer Uniform %_arr_uint_uint_32 %uint_0 = OpConstant %uint 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %gBuffer = OpVariable %_ptr_Uniform_type_gBuffer Uniform %gRWSBuffer = OpVariable %_ptr_Uniform_type_RWStructuredBuffer_S Uniform %null_expr = OpExtInst %void %ext DebugExpression %src = OpExtInst %void %ext DebugSource %file_name %cu = OpExtInst %void %ext DebugCompilationUnit 1 4 %src HLSL %dbg_tf = OpExtInst %void %ext DebugTypeBasic %float_name %uint_32 Float %main_ty = OpExtInst %void %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %dbg_tf %dbg_main = OpExtInst %void %ext DebugFunction %main_name %main_ty %src 0 0 %cu %main_name FlagIsProtected|FlagIsPrivate 10 %main %dbg_f = OpExtInst %void %ext DebugLocalVariable %f_name %dbg_tf %src 0 0 %dbg_main FlagIsLocal %main = OpFunction %void None %15 %20 = OpLabel %s = OpExtInst %void %ext DebugScope %dbg_main ; CHECK: [[ac1:%\w+]] = OpAccessChain {{%\w+}} %gBuffer %int_0 ; CHECK: [[ac2:%\w+]] = OpAccessChain {{%\w+}} [[ac1]] %uint_1 ; CHECK: [[ld:%\w+]] = OpLoad {{%\w+}} [[ac2]] ; CHECK: OpStore {{%\w+}} [[ld]] %21 = OpAccessChain %_ptr_Uniform__arr_uint_uint_32 %gBuffer %int_0 %22 = OpLoad %_arr_uint_uint_32 %21 ; Load of 32-element array. %value = OpExtInst %void %ext DebugValue %dbg_f %22 %null_expr %23 = OpCompositeExtract %uint %22 1 %24 = OpAccessChain %_ptr_Uniform_uint %gRWSBuffer %int_0 %uint_0 %int_0 OpStore %24 %23 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); SinglePassRunAndMatch(test, false, kDefaultLoadReductionThreshold); } TEST_F(ReduceLoadSizeTest, cbuffer_load_extract_vector) { // Originally from the following HLSL: // struct S { // uint f; // }; // // // cbuffer gBuffer { uint4 a; }; // // RWStructuredBuffer gRWSBuffer; // // uint foo(uint p[32]) { // return p[1]; // } // // [numthreads(1,1,1)] // void main() { // gRWSBuffer[0].f = foo(a); // } const std::string test = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource HLSL 600 OpName %type_gBuffer "type.gBuffer" OpMemberName %type_gBuffer 0 "a" OpName %gBuffer "gBuffer" OpName %S "S" OpMemberName %S 0 "f" OpName %type_RWStructuredBuffer_S "type.RWStructuredBuffer.S" OpName %gRWSBuffer "gRWSBuffer" OpName %main "main" OpMemberDecorate %type_gBuffer 0 Offset 0 OpDecorate %type_gBuffer Block OpMemberDecorate %S 0 Offset 0 OpDecorate %_runtimearr_S ArrayStride 4 OpMemberDecorate %type_RWStructuredBuffer_S 0 Offset 0 OpDecorate %type_RWStructuredBuffer_S BufferBlock OpDecorate %gBuffer DescriptorSet 0 OpDecorate %gBuffer Binding 0 OpDecorate %gRWSBuffer DescriptorSet 0 OpDecorate %gRWSBuffer Binding 1 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %v4uint = OpTypeVector %uint 4 %type_gBuffer = OpTypeStruct %v4uint %_ptr_Uniform_type_gBuffer = OpTypePointer Uniform %type_gBuffer %S = OpTypeStruct %uint %_runtimearr_S = OpTypeRuntimeArray %S %type_RWStructuredBuffer_S = OpTypeStruct %_runtimearr_S %_ptr_Uniform_type_RWStructuredBuffer_S = OpTypePointer Uniform %type_RWStructuredBuffer_S %int = OpTypeInt 32 1 %void = OpTypeVoid %15 = OpTypeFunction %void %int_0 = OpConstant %int 0 %_ptr_Uniform_v4uint = OpTypePointer Uniform %v4uint %uint_0 = OpConstant %uint 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %gBuffer = OpVariable %_ptr_Uniform_type_gBuffer Uniform %gRWSBuffer = OpVariable %_ptr_Uniform_type_RWStructuredBuffer_S Uniform %main = OpFunction %void None %15 %20 = OpLabel %21 = OpAccessChain %_ptr_Uniform_v4uint %gBuffer %int_0 %22 = OpLoad %v4uint %21 %23 = OpCompositeExtract %uint %22 1 %24 = OpAccessChain %_ptr_Uniform_uint %gRWSBuffer %int_0 %uint_0 %int_0 OpStore %24 %23 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); SinglePassRunAndCheck(test, test, true, false, kDefaultLoadReductionThreshold); } TEST_F(ReduceLoadSizeTest, cbuffer_load_5_extract) { // All of the elements of the value loaded are used, so we should not // change the load. const std::string test = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource HLSL 600 OpName %type_gBuffer "type.gBuffer" OpMemberName %type_gBuffer 0 "a" OpName %gBuffer "gBuffer" OpName %S "S" OpMemberName %S 0 "f" OpName %type_RWStructuredBuffer_S "type.RWStructuredBuffer.S" OpName %gRWSBuffer "gRWSBuffer" OpName %main "main" OpDecorate %_arr_uint_uint_5 ArrayStride 16 OpMemberDecorate %type_gBuffer 0 Offset 0 OpDecorate %type_gBuffer Block OpMemberDecorate %S 0 Offset 0 OpDecorate %_runtimearr_S ArrayStride 4 OpMemberDecorate %type_RWStructuredBuffer_S 0 Offset 0 OpDecorate %type_RWStructuredBuffer_S BufferBlock OpDecorate %gBuffer DescriptorSet 0 OpDecorate %gBuffer Binding 0 OpDecorate %gRWSBuffer DescriptorSet 0 OpDecorate %gRWSBuffer Binding 1 %uint = OpTypeInt 32 0 %uint_5 = OpConstant %uint 5 %_arr_uint_uint_5 = OpTypeArray %uint %uint_5 %type_gBuffer = OpTypeStruct %_arr_uint_uint_5 %_ptr_Uniform_type_gBuffer = OpTypePointer Uniform %type_gBuffer %S = OpTypeStruct %uint %_runtimearr_S = OpTypeRuntimeArray %S %type_RWStructuredBuffer_S = OpTypeStruct %_runtimearr_S %_ptr_Uniform_type_RWStructuredBuffer_S = OpTypePointer Uniform %type_RWStructuredBuffer_S %int = OpTypeInt 32 1 %void = OpTypeVoid %15 = OpTypeFunction %void %int_0 = OpConstant %int 0 %_ptr_Uniform__arr_uint_uint_5 = OpTypePointer Uniform %_arr_uint_uint_5 %uint_0 = OpConstant %uint 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %gBuffer = OpVariable %_ptr_Uniform_type_gBuffer Uniform %gRWSBuffer = OpVariable %_ptr_Uniform_type_RWStructuredBuffer_S Uniform %main = OpFunction %void None %15 %20 = OpLabel %21 = OpAccessChain %_ptr_Uniform__arr_uint_uint_5 %gBuffer %int_0 %22 = OpLoad %_arr_uint_uint_5 %21 %23 = OpCompositeExtract %uint %22 0 %24 = OpCompositeExtract %uint %22 1 %25 = OpCompositeExtract %uint %22 2 %26 = OpCompositeExtract %uint %22 3 %27 = OpCompositeExtract %uint %22 4 %28 = OpIAdd %uint %23 %24 %29 = OpIAdd %uint %28 %25 %30 = OpIAdd %uint %29 %26 %31 = OpIAdd %uint %20 %27 %32 = OpAccessChain %_ptr_Uniform_uint %gRWSBuffer %int_0 %uint_0 %int_0 OpStore %32 %31 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); SinglePassRunAndCheck(test, test, true, false, kDefaultLoadReductionThreshold); } TEST_F(ReduceLoadSizeTest, cbuffer_load_fully_used) { // The result of the load (%22) is used in an instruction that uses the whole // load and has only 1 in operand. This trigger issue #1559. const std::string test = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource HLSL 600 OpName %type_gBuffer "type.gBuffer" OpMemberName %type_gBuffer 0 "a" OpName %gBuffer "gBuffer" OpName %S "S" OpMemberName %S 0 "f" OpName %type_RWStructuredBuffer_S "type.RWStructuredBuffer.S" OpName %gRWSBuffer "gRWSBuffer" OpName %main "main" OpMemberDecorate %type_gBuffer 0 Offset 0 OpDecorate %type_gBuffer Block OpMemberDecorate %S 0 Offset 0 OpDecorate %_runtimearr_S ArrayStride 4 OpMemberDecorate %type_RWStructuredBuffer_S 0 Offset 0 OpDecorate %type_RWStructuredBuffer_S BufferBlock OpDecorate %gBuffer DescriptorSet 0 OpDecorate %gBuffer Binding 0 OpDecorate %gRWSBuffer DescriptorSet 0 OpDecorate %gRWSBuffer Binding 1 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %v4uint = OpTypeVector %uint 4 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %type_gBuffer = OpTypeStruct %v4uint %_ptr_Uniform_type_gBuffer = OpTypePointer Uniform %type_gBuffer %S = OpTypeStruct %uint %_runtimearr_S = OpTypeRuntimeArray %S %type_RWStructuredBuffer_S = OpTypeStruct %_runtimearr_S %_ptr_Uniform_type_RWStructuredBuffer_S = OpTypePointer Uniform %type_RWStructuredBuffer_S %int = OpTypeInt 32 1 %void = OpTypeVoid %15 = OpTypeFunction %void %int_0 = OpConstant %int 0 %_ptr_Uniform_v4uint = OpTypePointer Uniform %v4uint %uint_0 = OpConstant %uint 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %gBuffer = OpVariable %_ptr_Uniform_type_gBuffer Uniform %gRWSBuffer = OpVariable %_ptr_Uniform_type_RWStructuredBuffer_S Uniform %main = OpFunction %void None %15 %20 = OpLabel %21 = OpAccessChain %_ptr_Uniform_v4uint %gBuffer %int_0 %22 = OpLoad %v4uint %21 %23 = OpCompositeExtract %uint %22 1 %24 = OpConvertUToF %v4float %22 %25 = OpAccessChain %_ptr_Uniform_uint %gRWSBuffer %int_0 %uint_0 %int_0 OpStore %25 %23 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); SinglePassRunAndCheck(test, test, true, false, kDefaultLoadReductionThreshold); } TEST_F(ReduceLoadSizeTest, replace_cbuffer_load_fully_used) { const std::string test = R"( OpCapability Shader OpCapability SampledBuffer OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %out_var_SV_Target0 OpExecutionMode %main OriginUpperLeft OpSource HLSL 600 OpName %type_MaterialInstancing_cbuffer "type.MaterialInstancing_cbuffer" OpMemberName %type_MaterialInstancing_cbuffer 0 "MaterialInstancing_constants" OpName %MaterialInstancing_Constants "MaterialInstancing_Constants" OpMemberName %MaterialInstancing_Constants 0 "offset0" OpMemberName %MaterialInstancing_Constants 1 "params" OpName %InstancingParams_Constants "InstancingParams_Constants" OpMemberName %InstancingParams_Constants 0 "offset1" OpName %MaterialInstancing_cbuffer "MaterialInstancing_cbuffer" OpName %out_var_SV_Target0 "out.var.SV_Target0" OpName %main "main" OpDecorate %out_var_SV_Target0 Location 0 OpDecorate %MaterialInstancing_cbuffer DescriptorSet 6 OpDecorate %MaterialInstancing_cbuffer Binding 0 OpMemberDecorate %InstancingParams_Constants 0 Offset 0 OpMemberDecorate %MaterialInstancing_Constants 0 Offset 0 OpMemberDecorate %MaterialInstancing_Constants 1 Offset 16 OpMemberDecorate %type_MaterialInstancing_cbuffer 0 Offset 0 OpDecorate %type_MaterialInstancing_cbuffer Block %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %v4int = OpTypeVector %int 4 %InstancingParams_Constants = OpTypeStruct %v4int %MaterialInstancing_Constants = OpTypeStruct %v4int %InstancingParams_Constants %type_MaterialInstancing_cbuffer = OpTypeStruct %MaterialInstancing_Constants %_ptr_Uniform_type_MaterialInstancing_cbuffer = OpTypePointer Uniform %type_MaterialInstancing_cbuffer %_ptr_Output_int = OpTypePointer Output %int %void = OpTypeVoid %60 = OpTypeFunction %void %_ptr_Uniform_MaterialInstancing_Constants = OpTypePointer Uniform %MaterialInstancing_Constants %MaterialInstancing_cbuffer = OpVariable %_ptr_Uniform_type_MaterialInstancing_cbuffer Uniform %out_var_SV_Target0 = OpVariable %_ptr_Output_int Output %main = OpFunction %void None %60 %80 = OpLabel %131 = OpAccessChain %_ptr_Uniform_MaterialInstancing_Constants %MaterialInstancing_cbuffer %int_0 %132 = OpLoad %MaterialInstancing_Constants %131 ; CHECK: [[ac1:%\w+]] = OpAccessChain {{%\w+}} %MaterialInstancing_cbuffer %int_0 ; CHECK: [[ac2:%\w+]] = OpAccessChain {{%\w+}} [[ac1]] %uint_0 ; CHECK: OpLoad %v4int [[ac2]] ; CHECK: [[ac3:%\w+]] = OpAccessChain {{%\w+}} [[ac1]] %uint_1 ; CHECK: [[ac4:%\w+]] = OpAccessChain {{%\w+}} [[ac3]] %uint_0 ; CHECK: OpLoad %v4int [[ac4]] %134 = OpCompositeExtract %v4int %132 0 %135 = OpCompositeExtract %InstancingParams_Constants %132 1 %136 = OpCompositeExtract %v4int %135 0 %149 = OpCompositeExtract %int %134 0 %185 = OpCompositeExtract %int %136 0 %156 = OpIAdd %int %149 %185 OpStore %out_var_SV_Target0 %156 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); SinglePassRunAndMatch(test, false, 1.1); } TEST_F(ReduceLoadSizeTest, replace_array_with_spec_constant_size) { const std::string test = R"( OpCapability ClipDistance OpExtension " " OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 " " OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %6 = OpSpecConstant %uint 538976288 %_arr_int_6 = OpTypeArray %int %6 %_struct_8 = OpTypeStruct %_arr_int_6 %_struct_9 = OpTypeStruct %_struct_8 %_ptr_Uniform__struct_9 = OpTypePointer Uniform %_struct_9 ; CHECK: [[var:%\w+]] = OpVariable %_ptr_Uniform__struct_9 Uniform %11 = OpVariable %_ptr_Uniform__struct_9 Uniform %int_0 = OpConstant %int 0 %_ptr_Uniform__arr_int_6 = OpTypePointer Uniform %_arr_int_6 %1 = OpFunction %void None %3 %14 = OpLabel ; CHECK: [[ac:%\w+]] = OpAccessChain %_ptr_Uniform__arr_int_6 [[var]] %int_0 %int_0 ; CHECK: [[new_ac:%\w+]] = OpAccessChain %_ptr_Uniform_int [[ac]] %uint_538976288 ; CHECK: [[ld:%\w+]] = OpLoad %int [[new_ac]] ; CHECK: %18 = OpIAdd %int [[ld]] [[ld]] %15 = OpAccessChain %_ptr_Uniform__arr_int_6 %11 %int_0 %int_0 %16 = OpLoad %_arr_int_6 %15 %17 = OpCompositeExtract %int %16 538976288 %18 = OpIAdd %int %17 %17 OpUnreachable OpFunctionEnd )"; SinglePassRunAndMatch(test, false, kDefaultLoadReductionThreshold); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/redundancy_elimination_test.cpp000066400000000000000000000303611475742701700266040ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gmock/gmock.h" #include "test/opt/assembly_builder.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using ::testing::HasSubstr; using ::testing::MatchesRegex; using RedundancyEliminationTest = PassTest<::testing::Test>; // Test that it can get a simple case of local redundancy elimination. // The rest of the test check for extra functionality. TEST_F(RedundancyEliminationTest, RemoveRedundantLocalAdd) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %6 = OpTypePointer Function %5 %2 = OpFunction %3 None %4 %7 = OpLabel %8 = OpVariable %6 Function %9 = OpLoad %5 %8 %10 = OpFAdd %5 %9 %9 ; CHECK: OpFAdd ; CHECK-NOT: OpFAdd %11 = OpFAdd %5 %9 %9 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } // Remove a redundant add across basic blocks. TEST_F(RedundancyEliminationTest, RemoveRedundantAdd) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %6 = OpTypePointer Function %5 %2 = OpFunction %3 None %4 %7 = OpLabel %8 = OpVariable %6 Function %9 = OpLoad %5 %8 %10 = OpFAdd %5 %9 %9 OpBranch %11 %11 = OpLabel ; CHECK: OpFAdd ; CHECK-NOT: OpFAdd %12 = OpFAdd %5 %9 %9 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } // Remove a redundant add going through a multiple basic blocks. TEST_F(RedundancyEliminationTest, RemoveRedundantAddDiamond) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %2 = OpFunction %3 None %4 %9 = OpLabel %10 = OpVariable %6 Function %11 = OpLoad %5 %10 %12 = OpFAdd %5 %11 %11 ; CHECK: OpFAdd ; CHECK-NOT: OpFAdd OpBranchConditional %8 %13 %14 %13 = OpLabel OpBranch %15 %14 = OpLabel OpBranch %15 %15 = OpLabel %16 = OpFAdd %5 %11 %11 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } // Remove a redundant add in a side node. TEST_F(RedundancyEliminationTest, RemoveRedundantAddInSideNode) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %2 = OpFunction %3 None %4 %9 = OpLabel %10 = OpVariable %6 Function %11 = OpLoad %5 %10 %12 = OpFAdd %5 %11 %11 ; CHECK: OpFAdd ; CHECK-NOT: OpFAdd OpBranchConditional %8 %13 %14 %13 = OpLabel OpBranch %15 %14 = OpLabel %16 = OpFAdd %5 %11 %11 OpBranch %15 %15 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } // Remove a redundant add whose value is in the result of a phi node. TEST_F(RedundancyEliminationTest, RemoveRedundantAddWithPhi) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %2 = OpFunction %3 None %4 %9 = OpLabel %10 = OpVariable %6 Function %11 = OpLoad %5 %10 OpBranchConditional %8 %13 %14 %13 = OpLabel %add1 = OpFAdd %5 %11 %11 ; CHECK: OpFAdd OpBranch %15 %14 = OpLabel %add2 = OpFAdd %5 %11 %11 ; CHECK: OpFAdd OpBranch %15 %15 = OpLabel ; CHECK: OpPhi %phi = OpPhi %5 %add1 %13 %add2 %14 ; CHECK-NOT: OpFAdd %16 = OpFAdd %5 %11 %11 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } // Keep the add because it is redundant on some paths, but not all paths. TEST_F(RedundancyEliminationTest, KeepPartiallyRedundantAdd) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %2 = OpFunction %3 None %4 %9 = OpLabel %10 = OpVariable %6 Function %11 = OpLoad %5 %10 OpBranchConditional %8 %13 %14 %13 = OpLabel %add = OpFAdd %5 %11 %11 OpBranch %15 %14 = OpLabel OpBranch %15 %15 = OpLabel %16 = OpFAdd %5 %11 %11 OpReturn OpFunctionEnd )"; auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ false); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } // Keep the add. Even if it is redundant on all paths, there is no single id // whose definition dominates the add and contains the same value. TEST_F(RedundancyEliminationTest, KeepRedundantAddWithoutPhi) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %2 = OpFunction %3 None %4 %9 = OpLabel %10 = OpVariable %6 Function %11 = OpLoad %5 %10 OpBranchConditional %8 %13 %14 %13 = OpLabel %add1 = OpFAdd %5 %11 %11 OpBranch %15 %14 = OpLabel %add2 = OpFAdd %5 %11 %11 OpBranch %15 %15 = OpLabel %16 = OpFAdd %5 %11 %11 OpReturn OpFunctionEnd )"; auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ false); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } // Test that it can get a simple case of local redundancy elimination // when it has OpenCL.DebugInfo.100 instructions. TEST_F(RedundancyEliminationTest, OpenCLDebugInfo100) { // When three redundant DebugValues exist, only one DebugValue must remain. const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" %2 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %3 "main" OpExecutionMode %3 OriginUpperLeft OpSource GLSL 430 %4 = OpString "ps.hlsl" %5 = OpString "float" %6 = OpString "s0" %7 = OpString "main" %void = OpTypeVoid %9 = OpTypeFunction %void %float = OpTypeFloat 32 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_32 = OpConstant %uint 32 %_ptr_Function_float = OpTypePointer Function %float %15 = OpExtInst %void %1 DebugExpression %16 = OpExtInst %void %1 DebugSource %4 %17 = OpExtInst %void %1 DebugCompilationUnit 1 4 %16 HLSL %18 = OpExtInst %void %1 DebugTypeBasic %5 %uint_32 Float %19 = OpExtInst %void %1 DebugTypeVector %18 4 %20 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %19 %21 = OpExtInst %void %1 DebugFunction %7 %20 %16 4 1 %17 %7 FlagIsProtected|FlagIsPrivate 4 %3 ; CHECK: [[dbg_local_var:%\w+]] = OpExtInst %void {{%\w+}} DebugLocalVariable %22 = OpExtInst %void %1 DebugLocalVariable %6 %19 %16 0 0 %21 FlagIsLocal %14 = OpExtInst %void %1 DebugLocalVariable %6 %19 %16 0 0 %21 FlagIsLocal %3 = OpFunction %void None %9 %23 = OpLabel %24 = OpExtInst %void %1 DebugScope %21 %25 = OpVariable %_ptr_Function_float Function %26 = OpLoad %float %25 OpLine %4 0 0 ; Two `OpFAdd %float %26 %26` are the same. One must be removed. ; After removing one `OpFAdd %float %26 %26`, two DebugValues are the same. ; One must be removed. ; ; CHECK: OpLine {{%\w+}} 0 0 ; CHECK-NEXT: [[add:%\w+]] = OpFAdd %float [[value:%\w+]] ; CHECK-NEXT: DebugValue [[dbg_local_var]] [[add]] ; CHECK-NEXT: OpLine {{%\w+}} 1 0 ; CHECK-NEXT: OpFAdd %float [[add]] [[value]] ; CHECK-NEXT: OpReturn %27 = OpFAdd %float %26 %26 %28 = OpExtInst %void %1 DebugValue %22 %27 %15 %uint_0 OpLine %4 1 0 %29 = OpFAdd %float %26 %26 %30 = OpExtInst %void %1 DebugValue %14 %29 %15 %uint_0 %31 = OpExtInst %void %1 DebugValue %22 %29 %15 %uint_0 %32 = OpFAdd %float %29 %26 %33 = OpFAdd %float %27 %26 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(RedundancyEliminationTest, FunctionDeclaration) { // Make sure the pass works with a function declaration that is called. const std::string text = R"(OpCapability Addresses OpCapability Linkage OpCapability Kernel OpCapability Int8 %1 = OpExtInstImport "OpenCL.std" OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %2 "_Z23julia__1166_kernel_77094Bool" OpExecutionMode %2 ContractionOff OpSource Unknown 0 OpDecorate %3 LinkageAttributes "julia_error_7712" Import %void = OpTypeVoid %5 = OpTypeFunction %void %3 = OpFunction %void None %5 OpFunctionEnd %2 = OpFunction %void None %5 %6 = OpLabel %7 = OpFunctionCall %void %3 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(text, text, false); } } // namespace } // namespace opt } // namespace spvtoolsKhronosGroup-SPIRV-Tools-f289d04/test/opt/register_liveness.cpp000066400000000000000000001327411475742701700245620ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include "gmock/gmock.h" #include "source/opt/register_pressure.h" #include "test/opt/assembly_builder.h" #include "test/opt/function_utils.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using ::testing::UnorderedElementsAre; using PassClassTest = PassTest<::testing::Test>; void CompareSets(const std::unordered_set& computed, const std::unordered_set& expected) { for (Instruction* insn : computed) { EXPECT_TRUE(expected.count(insn->result_id())) << "Unexpected instruction in live set: " << *insn; } EXPECT_EQ(computed.size(), expected.size()); } /* Generated from the following GLSL #version 330 in vec4 BaseColor; flat in int Count; void main() { vec4 color = BaseColor; vec4 acc; if (Count == 0) { acc = color; } else { acc = color + vec4(0,1,2,0); } gl_FragColor = acc + color; } */ TEST_F(PassClassTest, LivenessWithIf) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %11 %15 %32 OpExecutionMode %4 OriginLowerLeft OpSource GLSL 330 OpName %4 "main" OpName %11 "BaseColor" OpName %15 "Count" OpName %32 "gl_FragColor" OpDecorate %11 Location 0 OpDecorate %15 Flat OpDecorate %15 Location 0 OpDecorate %32 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %10 = OpTypePointer Input %7 %11 = OpVariable %10 Input %13 = OpTypeInt 32 1 %14 = OpTypePointer Input %13 %15 = OpVariable %14 Input %17 = OpConstant %13 0 %18 = OpTypeBool %26 = OpConstant %6 0 %27 = OpConstant %6 1 %28 = OpConstant %6 2 %29 = OpConstantComposite %7 %26 %27 %28 %26 %31 = OpTypePointer Output %7 %32 = OpVariable %31 Output %4 = OpFunction %2 None %3 %5 = OpLabel %12 = OpLoad %7 %11 %16 = OpLoad %13 %15 %19 = OpIEqual %18 %16 %17 OpSelectionMerge %21 None OpBranchConditional %19 %20 %24 %20 = OpLabel OpBranch %21 %24 = OpLabel %30 = OpFAdd %7 %12 %29 OpBranch %21 %21 = OpLabel %36 = OpPhi %7 %12 %20 %30 %24 %35 = OpFAdd %7 %36 %12 OpStore %32 %35 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function* f = &*module->begin(); LivenessAnalysis* liveness_analysis = context->GetLivenessAnalysis(); const RegisterLiveness* register_liveness = liveness_analysis->Get(f); { SCOPED_TRACE("Block 5"); auto live_sets = register_liveness->Get(5); std::unordered_set live_in{ 11, // %11 = OpVariable %10 Input 15, // %15 = OpVariable %14 Input 32, // %32 = OpVariable %31 Output }; CompareSets(live_sets->live_in_, live_in); std::unordered_set live_out{ 12, // %12 = OpLoad %7 %11 32, // %32 = OpVariable %31 Output }; CompareSets(live_sets->live_out_, live_out); } { SCOPED_TRACE("Block 20"); auto live_sets = register_liveness->Get(20); std::unordered_set live_inout{ 12, // %12 = OpLoad %7 %11 32, // %32 = OpVariable %31 Output }; CompareSets(live_sets->live_in_, live_inout); CompareSets(live_sets->live_out_, live_inout); } { SCOPED_TRACE("Block 24"); auto live_sets = register_liveness->Get(24); std::unordered_set live_in{ 12, // %12 = OpLoad %7 %11 32, // %32 = OpVariable %31 Output }; CompareSets(live_sets->live_in_, live_in); std::unordered_set live_out{ 12, // %12 = OpLoad %7 %11 30, // %30 = OpFAdd %7 %12 %29 32, // %32 = OpVariable %31 Output }; CompareSets(live_sets->live_out_, live_out); } { SCOPED_TRACE("Block 21"); auto live_sets = register_liveness->Get(21); std::unordered_set live_in{ 12, // %12 = OpLoad %7 %11 32, // %32 = OpVariable %31 Output 36, // %36 = OpPhi %7 %12 %20 %30 %24 }; CompareSets(live_sets->live_in_, live_in); std::unordered_set live_out{}; CompareSets(live_sets->live_out_, live_out); } } /* Generated from the following GLSL #version 330 in vec4 bigColor; in vec4 BaseColor; in float f; flat in int Count; flat in uvec4 v4; void main() { vec4 color = BaseColor; for (int i = 0; i < Count; ++i) color += bigColor; float sum = 0.0; for (int i = 0; i < 4; ++i) { float acc = 0.0; if (sum == 0.0) { acc = v4[i]; } else { acc = BaseColor[i]; } sum += acc + v4[i]; } vec4 tv4; for (int i = 0; i < 4; ++i) tv4[i] = v4[i] * 4u; color += vec4(sum) + tv4; vec4 r; r.xyz = BaseColor.xyz; for (int i = 0; i < Count; ++i) r.w = f; color.xyz += r.xyz; for (int i = 0; i < 16; i += 4) for (int j = 0; j < 4; j++) color *= f; gl_FragColor = color + tv4; } */ TEST_F(PassClassTest, RegisterLiveness) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %11 %24 %28 %55 %124 %176 OpExecutionMode %4 OriginLowerLeft OpSource GLSL 330 OpName %4 "main" OpName %11 "BaseColor" OpName %24 "Count" OpName %28 "bigColor" OpName %55 "v4" OpName %84 "tv4" OpName %124 "f" OpName %176 "gl_FragColor" OpDecorate %11 Location 0 OpDecorate %24 Flat OpDecorate %24 Location 0 OpDecorate %28 Location 0 OpDecorate %55 Flat OpDecorate %55 Location 0 OpDecorate %124 Location 0 OpDecorate %176 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypePointer Function %7 %10 = OpTypePointer Input %7 %11 = OpVariable %10 Input %13 = OpTypeInt 32 1 %16 = OpConstant %13 0 %23 = OpTypePointer Input %13 %24 = OpVariable %23 Input %26 = OpTypeBool %28 = OpVariable %10 Input %33 = OpConstant %13 1 %35 = OpTypePointer Function %6 %37 = OpConstant %6 0 %45 = OpConstant %13 4 %52 = OpTypeInt 32 0 %53 = OpTypeVector %52 4 %54 = OpTypePointer Input %53 %55 = OpVariable %54 Input %57 = OpTypePointer Input %52 %63 = OpTypePointer Input %6 %89 = OpConstant %52 4 %102 = OpTypeVector %6 3 %124 = OpVariable %63 Input %158 = OpConstant %13 16 %175 = OpTypePointer Output %7 %176 = OpVariable %175 Output %195 = OpUndef %7 %4 = OpFunction %2 None %3 %5 = OpLabel %84 = OpVariable %8 Function %12 = OpLoad %7 %11 OpBranch %17 %17 = OpLabel %191 = OpPhi %7 %12 %5 %31 %18 %184 = OpPhi %13 %16 %5 %34 %18 %25 = OpLoad %13 %24 %27 = OpSLessThan %26 %184 %25 OpLoopMerge %19 %18 None OpBranchConditional %27 %18 %19 %18 = OpLabel %29 = OpLoad %7 %28 %31 = OpFAdd %7 %191 %29 %34 = OpIAdd %13 %184 %33 OpBranch %17 %19 = OpLabel OpBranch %39 %39 = OpLabel %188 = OpPhi %6 %37 %19 %73 %51 %185 = OpPhi %13 %16 %19 %75 %51 %46 = OpSLessThan %26 %185 %45 OpLoopMerge %41 %51 None OpBranchConditional %46 %40 %41 %40 = OpLabel %49 = OpFOrdEqual %26 %188 %37 OpSelectionMerge %51 None OpBranchConditional %49 %50 %61 %50 = OpLabel %58 = OpAccessChain %57 %55 %185 %59 = OpLoad %52 %58 %60 = OpConvertUToF %6 %59 OpBranch %51 %61 = OpLabel %64 = OpAccessChain %63 %11 %185 %65 = OpLoad %6 %64 OpBranch %51 %51 = OpLabel %210 = OpPhi %6 %60 %50 %65 %61 %68 = OpAccessChain %57 %55 %185 %69 = OpLoad %52 %68 %70 = OpConvertUToF %6 %69 %71 = OpFAdd %6 %210 %70 %73 = OpFAdd %6 %188 %71 %75 = OpIAdd %13 %185 %33 OpBranch %39 %41 = OpLabel OpBranch %77 %77 = OpLabel %186 = OpPhi %13 %16 %41 %94 %78 %83 = OpSLessThan %26 %186 %45 OpLoopMerge %79 %78 None OpBranchConditional %83 %78 %79 %78 = OpLabel %87 = OpAccessChain %57 %55 %186 %88 = OpLoad %52 %87 %90 = OpIMul %52 %88 %89 %91 = OpConvertUToF %6 %90 %92 = OpAccessChain %35 %84 %186 OpStore %92 %91 %94 = OpIAdd %13 %186 %33 OpBranch %77 %79 = OpLabel %96 = OpCompositeConstruct %7 %188 %188 %188 %188 %97 = OpLoad %7 %84 %98 = OpFAdd %7 %96 %97 %100 = OpFAdd %7 %191 %98 %104 = OpVectorShuffle %102 %12 %12 0 1 2 %106 = OpVectorShuffle %7 %195 %104 4 5 6 3 OpBranch %108 %108 = OpLabel %197 = OpPhi %7 %106 %79 %208 %133 %196 = OpPhi %13 %16 %79 %143 %133 %115 = OpSLessThan %26 %196 %25 OpLoopMerge %110 %133 None OpBranchConditional %115 %109 %110 %109 = OpLabel OpBranch %117 %117 = OpLabel %209 = OpPhi %7 %197 %109 %181 %118 %204 = OpPhi %13 %16 %109 %129 %118 %123 = OpSLessThan %26 %204 %45 OpLoopMerge %119 %118 None OpBranchConditional %123 %118 %119 %118 = OpLabel %125 = OpLoad %6 %124 %181 = OpCompositeInsert %7 %125 %209 3 %129 = OpIAdd %13 %204 %33 OpBranch %117 %119 = OpLabel OpBranch %131 %131 = OpLabel %208 = OpPhi %7 %209 %119 %183 %132 %205 = OpPhi %13 %16 %119 %141 %132 %137 = OpSLessThan %26 %205 %45 OpLoopMerge %133 %132 None OpBranchConditional %137 %132 %133 %132 = OpLabel %138 = OpLoad %6 %124 %183 = OpCompositeInsert %7 %138 %208 3 %141 = OpIAdd %13 %205 %33 OpBranch %131 %133 = OpLabel %143 = OpIAdd %13 %196 %33 OpBranch %108 %110 = OpLabel %145 = OpVectorShuffle %102 %197 %197 0 1 2 %147 = OpVectorShuffle %102 %100 %100 0 1 2 %148 = OpFAdd %102 %147 %145 %150 = OpVectorShuffle %7 %100 %148 4 5 6 3 OpBranch %152 %152 = OpLabel %200 = OpPhi %7 %150 %110 %203 %163 %199 = OpPhi %13 %16 %110 %174 %163 %159 = OpSLessThan %26 %199 %158 OpLoopMerge %154 %163 None OpBranchConditional %159 %153 %154 %153 = OpLabel OpBranch %161 %161 = OpLabel %203 = OpPhi %7 %200 %153 %170 %162 %201 = OpPhi %13 %16 %153 %172 %162 %167 = OpSLessThan %26 %201 %45 OpLoopMerge %163 %162 None OpBranchConditional %167 %162 %163 %162 = OpLabel %168 = OpLoad %6 %124 %170 = OpVectorTimesScalar %7 %203 %168 %172 = OpIAdd %13 %201 %33 OpBranch %161 %163 = OpLabel %174 = OpIAdd %13 %199 %45 OpBranch %152 %154 = OpLabel %178 = OpLoad %7 %84 %179 = OpFAdd %7 %200 %178 OpStore %176 %179 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function* f = &*module->begin(); LivenessAnalysis* liveness_analysis = context->GetLivenessAnalysis(); const RegisterLiveness* register_liveness = liveness_analysis->Get(f); LoopDescriptor& ld = *context->GetLoopDescriptor(f); { SCOPED_TRACE("Block 5"); auto live_sets = register_liveness->Get(5); std::unordered_set live_in{ 11, // %11 = OpVariable %10 Input 24, // %24 = OpVariable %23 Input 28, // %28 = OpVariable %10 Input 55, // %55 = OpVariable %54 Input 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output }; CompareSets(live_sets->live_in_, live_in); std::unordered_set live_out{ 11, // %11 = OpVariable %10 Input 12, // %12 = OpLoad %7 %11 24, // %24 = OpVariable %23 Input 28, // %28 = OpVariable %10 Input 55, // %55 = OpVariable %54 Input 84, // %84 = OpVariable %8 Function 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output }; CompareSets(live_sets->live_out_, live_out); EXPECT_EQ(live_sets->used_registers_, 8u); } { SCOPED_TRACE("Block 17"); auto live_sets = register_liveness->Get(17); std::unordered_set live_in{ 11, // %11 = OpVariable %10 Input 12, // %12 = OpLoad %7 %11 24, // %24 = OpVariable %23 Input 28, // %28 = OpVariable %10 Input 55, // %55 = OpVariable %54 Input 84, // %84 = OpVariable %8 Function 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output 184, // %184 = OpPhi %13 %16 %5 %34 %18 191, // %191 = OpPhi %7 %12 %5 %31 %18 }; CompareSets(live_sets->live_in_, live_in); std::unordered_set live_out{ 11, // %11 = OpVariable %10 Input 12, // %12 = OpLoad %7 %11 25, // %25 = OpLoad %13 %24 28, // %28 = OpVariable %10 Input 55, // %55 = OpVariable %54 Input 84, // %84 = OpVariable %8 Function 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output 184, // %184 = OpPhi %13 %16 %5 %34 %18 191, // %191 = OpPhi %7 %12 %5 %31 %18 }; CompareSets(live_sets->live_out_, live_out); EXPECT_EQ(live_sets->used_registers_, 11u); } { SCOPED_TRACE("Block 18"); auto live_sets = register_liveness->Get(18); std::unordered_set live_in{ 11, // %11 = OpVariable %10 Input 12, // %12 = OpLoad %7 %11 24, // %24 = OpVariable %23 Input 28, // %28 = OpVariable %10 Input 55, // %55 = OpVariable %54 Input 84, // %84 = OpVariable %8 Function 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output 184, // %184 = OpPhi %13 %16 %5 %34 %18 191, // %191 = OpPhi %7 %12 %5 %31 %18 }; CompareSets(live_sets->live_in_, live_in); std::unordered_set live_out{ 11, // %11 = OpVariable %10 Input 12, // %12 = OpLoad %7 %11 24, // %24 = OpVariable %23 Input 28, // %28 = OpVariable %10 Input 31, // %31 = OpFAdd %7 %191 %29 34, // %34 = OpIAdd %13 %184 %33 55, // %55 = OpVariable %54 Input 84, // %84 = OpVariable %8 Function 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output }; CompareSets(live_sets->live_out_, live_out); EXPECT_EQ(live_sets->used_registers_, 12u); } { SCOPED_TRACE("Block 19"); auto live_sets = register_liveness->Get(19); std::unordered_set live_inout{ 11, // %11 = OpVariable %10 Input 12, // %12 = OpLoad %7 %11 25, // %25 = OpLoad %13 %24 55, // %55 = OpVariable %54 Input 84, // %84 = OpVariable %8 Function 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output 191, // %191 = OpPhi %7 %12 %5 %31 %18 }; CompareSets(live_sets->live_in_, live_inout); CompareSets(live_sets->live_out_, live_inout); EXPECT_EQ(live_sets->used_registers_, 8u); } { SCOPED_TRACE("Block 39"); auto live_sets = register_liveness->Get(39); std::unordered_set live_inout{ 11, // %11 = OpVariable %10 Input 12, // %12 = OpLoad %7 %11 25, // %25 = OpLoad %13 %24 55, // %55 = OpVariable %54 Input 84, // %84 = OpVariable %8 Function 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output 185, // %185 = OpPhi %13 %16 %19 %75 %51 188, // %188 = OpPhi %6 %37 %19 %73 %51 191, // %191 = OpPhi %7 %12 %5 %31 %18 }; CompareSets(live_sets->live_in_, live_inout); CompareSets(live_sets->live_out_, live_inout); EXPECT_EQ(live_sets->used_registers_, 11u); } { SCOPED_TRACE("Block 40"); auto live_sets = register_liveness->Get(40); std::unordered_set live_inout{ 11, // %11 = OpVariable %10 Input 12, // %12 = OpLoad %7 %11 25, // %25 = OpLoad %13 %24 55, // %55 = OpVariable %54 Input 84, // %84 = OpVariable %8 Function 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output 185, // %185 = OpPhi %13 %16 %19 %75 %51 188, // %188 = OpPhi %6 %37 %19 %73 %51 191, // %191 = OpPhi %7 %12 %5 %31 %18 }; CompareSets(live_sets->live_in_, live_inout); CompareSets(live_sets->live_out_, live_inout); EXPECT_EQ(live_sets->used_registers_, 11u); } { SCOPED_TRACE("Block 50"); auto live_sets = register_liveness->Get(50); std::unordered_set live_in{ 11, // %11 = OpVariable %10 Input 12, // %12 = OpLoad %7 %11 25, // %25 = OpLoad %13 %24 55, // %55 = OpVariable %54 Input 84, // %84 = OpVariable %8 Function 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output 185, // %185 = OpPhi %13 %16 %19 %75 %51 188, // %188 = OpPhi %6 %37 %19 %73 %51 191, // %191 = OpPhi %7 %12 %5 %31 %18 }; CompareSets(live_sets->live_in_, live_in); std::unordered_set live_out{ 11, // %11 = OpVariable %10 Input 12, // %12 = OpLoad %7 %11 25, // %25 = OpLoad %13 %24 55, // %55 = OpVariable %54 Input 60, // %60 = OpConvertUToF %6 %59 84, // %84 = OpVariable %8 Function 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output 185, // %185 = OpPhi %13 %16 %19 %75 %51 188, // %188 = OpPhi %6 %37 %19 %73 %51 191, // %191 = OpPhi %7 %12 %5 %31 %18 }; CompareSets(live_sets->live_out_, live_out); EXPECT_EQ(live_sets->used_registers_, 12u); } { SCOPED_TRACE("Block 61"); auto live_sets = register_liveness->Get(61); std::unordered_set live_in{ 11, // %11 = OpVariable %10 Input 12, // %12 = OpLoad %7 %11 25, // %25 = OpLoad %13 %24 55, // %55 = OpVariable %54 Input 84, // %84 = OpVariable %8 Function 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output 185, // %185 = OpPhi %13 %16 %19 %75 %51 188, // %188 = OpPhi %6 %37 %19 %73 %51 191, // %191 = OpPhi %7 %12 %5 %31 %18 }; CompareSets(live_sets->live_in_, live_in); std::unordered_set live_out{ 11, // %11 = OpVariable %10 Input 12, // %12 = OpLoad %7 %11 25, // %25 = OpLoad %13 %24 55, // %55 = OpVariable %54 Input 65, // %65 = OpLoad %6 %64 84, // %84 = OpVariable %8 Function 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output 185, // %185 = OpPhi %13 %16 %19 %75 %51 188, // %188 = OpPhi %6 %37 %19 %73 %51 191, // %191 = OpPhi %7 %12 %5 %31 %18 }; CompareSets(live_sets->live_out_, live_out); EXPECT_EQ(live_sets->used_registers_, 12u); } { SCOPED_TRACE("Block 51"); auto live_sets = register_liveness->Get(51); std::unordered_set live_in{ 11, // %11 = OpVariable %10 Input 12, // %12 = OpLoad %7 %11 25, // %25 = OpLoad %13 %24 55, // %55 = OpVariable %54 Input 84, // %84 = OpVariable %8 Function 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output 185, // %185 = OpPhi %13 %16 %19 %75 %51 188, // %188 = OpPhi %6 %37 %19 %73 %51 191, // %191 = OpPhi %7 %12 %5 %31 %18 210, // %210 = OpPhi %6 %60 %50 %65 %61 }; CompareSets(live_sets->live_in_, live_in); std::unordered_set live_out{ 11, // %11 = OpVariable %10 Input 12, // %12 = OpLoad %7 %11 25, // %25 = OpLoad %13 %24 55, // %55 = OpVariable %54 Input 73, // %73 = OpFAdd %6 %188 %71 75, // %75 = OpIAdd %13 %185 %33 84, // %84 = OpVariable %8 Function 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output 191, // %191 = OpPhi %7 %12 %5 %31 %18 }; CompareSets(live_sets->live_out_, live_out); EXPECT_EQ(live_sets->used_registers_, 13u); } { SCOPED_TRACE("Block 41"); auto live_sets = register_liveness->Get(41); std::unordered_set live_inout{ 12, // %12 = OpLoad %7 %11 25, // %25 = OpLoad %13 %24 55, // %55 = OpVariable %54 Input 84, // %84 = OpVariable %8 Function 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output 188, // %188 = OpPhi %6 %37 %19 %73 %51 191, // %191 = OpPhi %7 %12 %5 %31 %18 }; CompareSets(live_sets->live_in_, live_inout); CompareSets(live_sets->live_out_, live_inout); EXPECT_EQ(live_sets->used_registers_, 8u); } { SCOPED_TRACE("Block 77"); auto live_sets = register_liveness->Get(77); std::unordered_set live_inout{ 12, // %12 = OpLoad %7 %11 25, // %25 = OpLoad %13 %24 55, // %55 = OpVariable %54 Input 84, // %84 = OpVariable %8 Function 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output 186, // %186 = OpPhi %13 %16 %41 %94 %78 188, // %188 = OpPhi %6 %37 %19 %73 %51 191, // %191 = OpPhi %7 %12 %5 %31 %18 }; CompareSets(live_sets->live_in_, live_inout); CompareSets(live_sets->live_out_, live_inout); EXPECT_EQ(live_sets->used_registers_, 10u); } { SCOPED_TRACE("Block 78"); auto live_sets = register_liveness->Get(78); std::unordered_set live_in{ 12, // %12 = OpLoad %7 %11 25, // %25 = OpLoad %13 %24 55, // %55 = OpVariable %54 Input 84, // %84 = OpVariable %8 Function 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output 186, // %186 = OpPhi %13 %16 %41 %94 %78 188, // %188 = OpPhi %6 %37 %19 %73 %51 191, // %191 = OpPhi %7 %12 %5 %31 %18 }; CompareSets(live_sets->live_in_, live_in); std::unordered_set live_out{ 12, // %12 = OpLoad %7 %11 25, // %25 = OpLoad %13 %24 55, // %55 = OpVariable %54 Input 84, // %84 = OpVariable %8 Function 94, // %94 = OpIAdd %13 %186 %33 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output 188, // %188 = OpPhi %6 %37 %19 %73 %51 191, // %191 = OpPhi %7 %12 %5 %31 %18 }; CompareSets(live_sets->live_out_, live_out); EXPECT_EQ(live_sets->used_registers_, 11u); } { SCOPED_TRACE("Block 79"); auto live_sets = register_liveness->Get(79); std::unordered_set live_in{ 12, // %12 = OpLoad %7 %11 25, // %25 = OpLoad %13 %24 84, // %84 = OpVariable %8 Function 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output 188, // %188 = OpPhi %6 %37 %19 %73 %51 191, // %191 = OpPhi %7 %12 %5 %31 %18 }; CompareSets(live_sets->live_in_, live_in); std::unordered_set live_out{ 25, // %25 = OpLoad %13 %24 84, // %84 = OpVariable %8 Function 100, // %100 = OpFAdd %7 %191 %98 106, // %106 = OpVectorShuffle %7 %195 %104 4 5 6 3 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output }; CompareSets(live_sets->live_out_, live_out); EXPECT_EQ(live_sets->used_registers_, 9u); } { SCOPED_TRACE("Block 108"); auto live_sets = register_liveness->Get(108); std::unordered_set live_in{ 25, // %25 = OpLoad %13 %24 84, // %84 = OpVariable %8 Function 100, // %100 = OpFAdd %7 %191 %98 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output 196, // %196 = OpPhi %13 %16 %79 %143 %133 197, // %197 = OpPhi %7 %106 %79 %208 %133 }; CompareSets(live_sets->live_in_, live_in); std::unordered_set live_out{ 84, // %84 = OpVariable %8 Function 100, // %100 = OpFAdd %7 %191 %98 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output 196, // %196 = OpPhi %13 %16 %79 %143 %133 197, // %197 = OpPhi %7 %106 %79 %208 %133 }; CompareSets(live_sets->live_out_, live_out); EXPECT_EQ(live_sets->used_registers_, 8u); } { SCOPED_TRACE("Block 109"); auto live_sets = register_liveness->Get(109); std::unordered_set live_inout{ 25, // %25 = OpLoad %13 %24 84, // %84 = OpVariable %8 Function 100, // %100 = OpFAdd %7 %191 %98 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output 196, // %196 = OpPhi %13 %16 %79 %143 %133 197, // %197 = OpPhi %7 %106 %79 %208 %133 }; CompareSets(live_sets->live_in_, live_inout); CompareSets(live_sets->live_out_, live_inout); EXPECT_EQ(live_sets->used_registers_, 7u); } { SCOPED_TRACE("Block 117"); auto live_sets = register_liveness->Get(117); std::unordered_set live_inout{ 25, // %25 = OpLoad %13 %24 84, // %84 = OpVariable %8 Function 100, // %100 = OpFAdd %7 %191 %98 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output 196, // %196 = OpPhi %13 %16 %79 %143 %133 204, // %204 = OpPhi %13 %16 %109 %129 %118 209, // %209 = OpPhi %7 %197 %109 %181 %118 }; CompareSets(live_sets->live_in_, live_inout); CompareSets(live_sets->live_out_, live_inout); EXPECT_EQ(live_sets->used_registers_, 9u); } { SCOPED_TRACE("Block 118"); auto live_sets = register_liveness->Get(118); std::unordered_set live_in{ 25, // %25 = OpLoad %13 %24 84, // %84 = OpVariable %8 Function 100, // %100 = OpFAdd %7 %191 %98 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output 196, // %196 = OpPhi %13 %16 %79 %143 %133 204, // %204 = OpPhi %13 %16 %109 %129 %118 209, // %209 = OpPhi %7 %197 %109 %181 %118 }; CompareSets(live_sets->live_in_, live_in); std::unordered_set live_out{ 25, // %25 = OpLoad %13 %24 84, // %84 = OpVariable %8 Function 100, // %100 = OpFAdd %7 %191 %98 124, // %124 = OpVariable %63 Input 129, // %129 = OpIAdd %13 %204 %33 176, // %176 = OpVariable %175 Output 181, // %181 = OpCompositeInsert %7 %125 %209 3 196, // %196 = OpPhi %13 %16 %79 %143 %133 }; CompareSets(live_sets->live_out_, live_out); EXPECT_EQ(live_sets->used_registers_, 10u); } { SCOPED_TRACE("Block 119"); auto live_sets = register_liveness->Get(119); std::unordered_set live_inout{ 25, // %25 = OpLoad %13 %24 84, // %84 = OpVariable %8 Function 100, // %100 = OpFAdd %7 %191 %98 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output 196, // %196 = OpPhi %13 %16 %79 %143 %133 209, // %209 = OpPhi %7 %197 %109 %181 %118 }; CompareSets(live_sets->live_in_, live_inout); CompareSets(live_sets->live_out_, live_inout); EXPECT_EQ(live_sets->used_registers_, 7u); } { SCOPED_TRACE("Block 131"); auto live_sets = register_liveness->Get(131); std::unordered_set live_inout{ 25, // %25 = OpLoad %13 %24 84, // %84 = OpVariable %8 Function 100, // %100 = OpFAdd %7 %191 %98 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output 196, // %196 = OpPhi %13 %16 %79 %143 %133 205, // %205 = OpPhi %13 %16 %119 %141 %132 208, // %208 = OpPhi %7 %209 %119 %183 %132 }; CompareSets(live_sets->live_in_, live_inout); CompareSets(live_sets->live_out_, live_inout); EXPECT_EQ(live_sets->used_registers_, 9u); } { SCOPED_TRACE("Block 132"); auto live_sets = register_liveness->Get(132); std::unordered_set live_in{ 25, // %25 = OpLoad %13 %24 84, // %84 = OpVariable %8 Function 100, // %100 = OpFAdd %7 %191 %98 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output 196, // %196 = OpPhi %13 %16 %79 %143 %133 205, // %205 = OpPhi %13 %16 %119 %141 %132 208, // %208 = OpPhi %7 %209 %119 %183 %132 }; CompareSets(live_sets->live_in_, live_in); std::unordered_set live_out{ 25, // %25 = OpLoad %13 %24 84, // %84 = OpVariable %8 Function 100, // %100 = OpFAdd %7 %191 %98 124, // %124 = OpVariable %63 Input 141, // %141 = OpIAdd %13 %205 %33 176, // %176 = OpVariable %175 Output 183, // %183 = OpCompositeInsert %7 %138 %208 3 196, // %196 = OpPhi %13 %16 %79 %143 %133 }; CompareSets(live_sets->live_out_, live_out); EXPECT_EQ(live_sets->used_registers_, 10u); } { SCOPED_TRACE("Block 133"); auto live_sets = register_liveness->Get(133); std::unordered_set live_in{ 25, // %25 = OpLoad %13 %24 84, // %84 = OpVariable %8 Function 100, // %100 = OpFAdd %7 %191 %98 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output 196, // %196 = OpPhi %13 %16 %79 %143 %133 208, // %208 = OpPhi %7 %209 %119 %183 %132 }; CompareSets(live_sets->live_in_, live_in); std::unordered_set live_out{ 25, // %25 = OpLoad %13 %24 84, // %84 = OpVariable %8 Function 100, // %100 = OpFAdd %7 %191 %98 124, // %124 = OpVariable %63 Input 143, // %143 = OpIAdd %13 %196 %33 176, // %176 = OpVariable %175 Output 208, // %208 = OpPhi %7 %209 %119 %183 %132 }; CompareSets(live_sets->live_out_, live_out); EXPECT_EQ(live_sets->used_registers_, 8u); } { SCOPED_TRACE("Block 110"); auto live_sets = register_liveness->Get(110); std::unordered_set live_in{ 84, // %84 = OpVariable %8 Function 100, // %100 = OpFAdd %7 %191 %98 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output 197, // %197 = OpPhi %7 %106 %79 %208 %133 }; CompareSets(live_sets->live_in_, live_in); std::unordered_set live_out{ 84, // %84 = OpVariable %8 Function 124, // %124 = OpVariable %63 Input 150, // %150 = OpVectorShuffle %7 %100 %148 4 5 6 3 176, // %176 = OpVariable %175 Output }; CompareSets(live_sets->live_out_, live_out); EXPECT_EQ(live_sets->used_registers_, 7u); } { SCOPED_TRACE("Block 152"); auto live_sets = register_liveness->Get(152); std::unordered_set live_inout{ 84, // %84 = OpVariable %8 Function 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output 199, // %199 = OpPhi %13 %16 %110 %174 %163 200, // %200 = OpPhi %7 %150 %110 %203 %163 }; CompareSets(live_sets->live_in_, live_inout); CompareSets(live_sets->live_out_, live_inout); EXPECT_EQ(live_sets->used_registers_, 6u); } { SCOPED_TRACE("Block 153"); auto live_sets = register_liveness->Get(153); std::unordered_set live_inout{ 84, // %84 = OpVariable %8 Function 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output 199, // %199 = OpPhi %13 %16 %110 %174 %163 200, // %200 = OpPhi %7 %150 %110 %203 %163 }; CompareSets(live_sets->live_in_, live_inout); CompareSets(live_sets->live_out_, live_inout); EXPECT_EQ(live_sets->used_registers_, 5u); } { SCOPED_TRACE("Block 161"); auto live_sets = register_liveness->Get(161); std::unordered_set live_inout{ 84, // %84 = OpVariable %8 Function 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output 199, // %199 = OpPhi %13 %16 %110 %174 %163 201, // %201 = OpPhi %13 %16 %153 %172 %162 203, // %203 = OpPhi %7 %200 %153 %170 %162 }; CompareSets(live_sets->live_in_, live_inout); CompareSets(live_sets->live_out_, live_inout); EXPECT_EQ(live_sets->used_registers_, 7u); } { SCOPED_TRACE("Block 162"); auto live_sets = register_liveness->Get(162); std::unordered_set live_in{ 84, // %84 = OpVariable %8 Function 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output 199, // %199 = OpPhi %13 %16 %110 %174 %163 201, // %201 = OpPhi %13 %16 %153 %172 %162 203, // %203 = OpPhi %7 %200 %153 %170 %162 }; CompareSets(live_sets->live_in_, live_in); std::unordered_set live_out{ 84, // %84 = OpVariable %8 Function 124, // %124 = OpVariable %63 Input 170, // %170 = OpVectorTimesScalar %7 %203 %168 172, // %172 = OpIAdd %13 %201 %33 176, // %176 = OpVariable %175 Output 199, // %199 = OpPhi %13 %16 %110 %174 %163 }; CompareSets(live_sets->live_out_, live_out); EXPECT_EQ(live_sets->used_registers_, 8u); } { SCOPED_TRACE("Block 163"); auto live_sets = register_liveness->Get(163); std::unordered_set live_in{ 84, // %84 = OpVariable %8 Function 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output 199, // %199 = OpPhi %13 %16 %110 %174 %163 203, // %203 = OpPhi %7 %200 %153 %170 %162 }; CompareSets(live_sets->live_in_, live_in); std::unordered_set live_out{ 84, // %84 = OpVariable %8 Function 124, // %124 = OpVariable %63 Input 174, // %174 = OpIAdd %13 %199 %45 176, // %176 = OpVariable %175 Output 203, // %203 = OpPhi %7 %200 %153 %170 %162 }; CompareSets(live_sets->live_out_, live_out); EXPECT_EQ(live_sets->used_registers_, 6u); } { SCOPED_TRACE("Block 154"); auto live_sets = register_liveness->Get(154); std::unordered_set live_in{ 84, // %84 = OpVariable %8 Function 176, // %176 = OpVariable %175 Output 200, // %200 = OpPhi %7 %150 %110 %203 %163 }; CompareSets(live_sets->live_in_, live_in); std::unordered_set live_out{}; CompareSets(live_sets->live_out_, live_out); EXPECT_EQ(live_sets->used_registers_, 4u); } { SCOPED_TRACE("Compute loop pressure"); RegisterLiveness::RegionRegisterLiveness loop_reg_pressure; register_liveness->ComputeLoopRegisterPressure(*ld[39], &loop_reg_pressure); // Generate(*context->cfg()->block(39), &loop_reg_pressure); std::unordered_set live_in{ 11, // %11 = OpVariable %10 Input 12, // %12 = OpLoad %7 %11 25, // %25 = OpLoad %13 %24 55, // %55 = OpVariable %54 Input 84, // %84 = OpVariable %8 Function 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output 185, // %185 = OpPhi %13 %16 %19 %75 %51 188, // %188 = OpPhi %6 %37 %19 %73 %51 191, // %191 = OpPhi %7 %12 %5 %31 %18 }; CompareSets(loop_reg_pressure.live_in_, live_in); std::unordered_set live_out{ 12, // %12 = OpLoad %7 %11 25, // %25 = OpLoad %13 %24 55, // %55 = OpVariable %54 Input 84, // %84 = OpVariable %8 Function 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output 188, // %188 = OpPhi %6 %37 %19 %73 %51 191, // %191 = OpPhi %7 %12 %5 %31 %18 }; CompareSets(loop_reg_pressure.live_out_, live_out); EXPECT_EQ(loop_reg_pressure.used_registers_, 13u); } { SCOPED_TRACE("Loop Fusion simulation"); RegisterLiveness::RegionRegisterLiveness simulation_resut; register_liveness->SimulateFusion(*ld[17], *ld[39], &simulation_resut); std::unordered_set live_in{ 11, // %11 = OpVariable %10 Input 12, // %12 = OpLoad %7 %11 24, // %24 = OpVariable %23 Input 25, // %25 = OpLoad %13 %24 28, // %28 = OpVariable %10 Input 55, // %55 = OpVariable %54 Input 84, // %84 = OpVariable %8 Function 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output 184, // %184 = OpPhi %13 %16 %5 %34 %18 185, // %185 = OpPhi %13 %16 %19 %75 %51 188, // %188 = OpPhi %6 %37 %19 %73 %51 191, // %191 = OpPhi %7 %12 %5 %31 %18 }; CompareSets(simulation_resut.live_in_, live_in); std::unordered_set live_out{ 12, // %12 = OpLoad %7 %11 25, // %25 = OpLoad %13 %24 55, // %55 = OpVariable %54 Input 84, // %84 = OpVariable %8 Function 124, // %124 = OpVariable %63 Input 176, // %176 = OpVariable %175 Output 188, // %188 = OpPhi %6 %37 %19 %73 %51 191, // %191 = OpPhi %7 %12 %5 %31 %18 }; CompareSets(simulation_resut.live_out_, live_out); EXPECT_EQ(simulation_resut.used_registers_, 17u); } } TEST_F(PassClassTest, FissionSimulation) { const std::string source = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "i" OpName %4 "A" OpName %5 "B" %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %10 = OpConstant %8 0 %11 = OpConstant %8 10 %12 = OpTypeBool %13 = OpTypeFloat 32 %14 = OpTypeInt 32 0 %15 = OpConstant %14 10 %16 = OpTypeArray %13 %15 %17 = OpTypePointer Function %16 %18 = OpTypePointer Function %13 %19 = OpConstant %8 1 %2 = OpFunction %6 None %7 %20 = OpLabel %3 = OpVariable %9 Function %4 = OpVariable %17 Function %5 = OpVariable %17 Function OpBranch %21 %21 = OpLabel %22 = OpPhi %8 %10 %20 %23 %24 OpLoopMerge %25 %24 None OpBranch %26 %26 = OpLabel %27 = OpSLessThan %12 %22 %11 OpBranchConditional %27 %28 %25 %28 = OpLabel %29 = OpAccessChain %18 %5 %22 %30 = OpLoad %13 %29 %31 = OpAccessChain %18 %4 %22 OpStore %31 %30 %32 = OpAccessChain %18 %4 %22 %33 = OpLoad %13 %32 %34 = OpAccessChain %18 %5 %22 OpStore %34 %33 OpBranch %24 %24 = OpLabel %23 = OpIAdd %8 %22 %19 OpBranch %21 %25 = OpLabel OpStore %3 %22 OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, source, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << source << std::endl; Function* f = &*module->begin(); LivenessAnalysis* liveness_analysis = context->GetLivenessAnalysis(); const RegisterLiveness* register_liveness = liveness_analysis->Get(f); LoopDescriptor& ld = *context->GetLoopDescriptor(f); analysis::DefUseManager& def_use_mgr = *context->get_def_use_mgr(); { RegisterLiveness::RegionRegisterLiveness l1_sim_resut; RegisterLiveness::RegionRegisterLiveness l2_sim_resut; std::unordered_set moved_instructions{ def_use_mgr.GetDef(29), def_use_mgr.GetDef(30), def_use_mgr.GetDef(31), def_use_mgr.GetDef(31)->NextNode()}; std::unordered_set copied_instructions{ def_use_mgr.GetDef(22), def_use_mgr.GetDef(27), def_use_mgr.GetDef(27)->NextNode(), def_use_mgr.GetDef(23)}; register_liveness->SimulateFission(*ld[21], moved_instructions, copied_instructions, &l1_sim_resut, &l2_sim_resut); { SCOPED_TRACE("L1 simulation"); std::unordered_set live_in{ 3, // %3 = OpVariable %9 Function 4, // %4 = OpVariable %17 Function 5, // %5 = OpVariable %17 Function 22, // %22 = OpPhi %8 %10 %20 %23 %24 }; CompareSets(l1_sim_resut.live_in_, live_in); std::unordered_set live_out{ 3, // %3 = OpVariable %9 Function 4, // %4 = OpVariable %17 Function 5, // %5 = OpVariable %17 Function 22, // %22 = OpPhi %8 %10 %20 %23 %24 }; CompareSets(l1_sim_resut.live_out_, live_out); EXPECT_EQ(l1_sim_resut.used_registers_, 6u); } { SCOPED_TRACE("L2 simulation"); std::unordered_set live_in{ 3, // %3 = OpVariable %9 Function 4, // %4 = OpVariable %17 Function 5, // %5 = OpVariable %17 Function 22, // %22 = OpPhi %8 %10 %20 %23 %24 }; CompareSets(l2_sim_resut.live_in_, live_in); std::unordered_set live_out{ 3, // %3 = OpVariable %9 Function 22, // %22 = OpPhi %8 %10 %20 %23 %24 }; CompareSets(l2_sim_resut.live_out_, live_out); EXPECT_EQ(l2_sim_resut.used_registers_, 6u); } } } // Test that register liveness does not fail when there is an unreachable block. // We are not testing if the liveness is computed correctly because the specific // results do not matter for unreachable blocks. TEST_F(PassClassTest, RegisterLivenessWithUnreachableBlock) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginLowerLeft OpSource GLSL 330 OpSourceExtension "GL_ARB_shading_language_420pack" %void = OpTypeVoid %4 = OpTypeFunction %void %2 = OpFunction %void None %4 %5 = OpLabel OpBranch %6 %6 = OpLabel OpLoopMerge %7 %8 None OpBranch %9 %9 = OpLabel OpBranch %7 %8 = OpLabel OpBranch %6 %7 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; Function* f = &*module->begin(); LivenessAnalysis* liveness_analysis = context->GetLivenessAnalysis(); liveness_analysis->Get(f); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/relax_float_ops_test.cpp000066400000000000000000000152421475742701700252420ustar00rootroot00000000000000// Copyright (c) 2019 Valve Corporation // Copyright (c) 2019 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Relax float ops tests #include #include #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using RelaxFloatOpsTest = PassTest<::testing::Test>; TEST_F(RelaxFloatOpsTest, RelaxFloatOpsBasic) { // All float result instructions in functions should be relaxed // clang-format off // // SamplerState g_sSamp : register(s0); // uniform Texture1D g_tTex1df4 : register(t0); // // struct PS_INPUT // { // float Tex0 : TEXCOORD0; // float Tex1 : TEXCOORD1; // }; // // struct PS_OUTPUT // { // float4 Color : SV_Target0; // }; // // PS_OUTPUT main(PS_INPUT i) // { // PS_OUTPUT psout; // float4 txval10 = g_tTex1df4.Sample(g_sSamp, i.Tex0); // float4 txval11 = g_tTex1df4.Sample(g_sSamp, i.Tex1); // float4 t = txval10 + txval11; // float4 t2 = t / 2.0; // psout.Color = t2; // return psout; // } // clang-format on const std::string defs0 = R"(OpCapability Shader OpCapability Sampled1D %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %i_Tex0 %i_Tex1 %_entryPointOutput_Color OpExecutionMode %main OriginUpperLeft OpSource HLSL 500 OpName %main "main" OpName %g_tTex1df4 "g_tTex1df4" OpName %g_sSamp "g_sSamp" OpName %i_Tex0 "i.Tex0" OpName %i_Tex1 "i.Tex1" OpName %_entryPointOutput_Color "@entryPointOutput.Color" OpDecorate %g_tTex1df4 DescriptorSet 0 OpDecorate %g_tTex1df4 Binding 0 OpDecorate %g_sSamp DescriptorSet 0 OpDecorate %g_sSamp Binding 0 OpDecorate %i_Tex0 Location 0 OpDecorate %i_Tex1 Location 1 OpDecorate %_entryPointOutput_Color Location 0 )"; const std::string defs1 = R"(%void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %17 = OpTypeImage %float 1D 0 0 0 1 Unknown %_ptr_UniformConstant_17 = OpTypePointer UniformConstant %17 %g_tTex1df4 = OpVariable %_ptr_UniformConstant_17 UniformConstant %21 = OpTypeSampler %_ptr_UniformConstant_21 = OpTypePointer UniformConstant %21 %g_sSamp = OpVariable %_ptr_UniformConstant_21 UniformConstant %25 = OpTypeSampledImage %17 %_ptr_Input_float = OpTypePointer Input %float %i_Tex0 = OpVariable %_ptr_Input_float Input %i_Tex1 = OpVariable %_ptr_Input_float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput_Color = OpVariable %_ptr_Output_v4float Output %float_0_5 = OpConstant %float 0.5 %116 = OpConstantComposite %v4float %float_0_5 %float_0_5 %float_0_5 %float_0_5 )"; const std::string relax_decos = R"(OpDecorate %60 RelaxedPrecision OpDecorate %63 RelaxedPrecision OpDecorate %82 RelaxedPrecision OpDecorate %88 RelaxedPrecision OpDecorate %91 RelaxedPrecision OpDecorate %94 RelaxedPrecision )"; const std::string func_orig = R"(%main = OpFunction %void None %3 %5 = OpLabel %60 = OpLoad %float %i_Tex0 %63 = OpLoad %float %i_Tex1 %77 = OpLoad %17 %g_tTex1df4 %78 = OpLoad %21 %g_sSamp %79 = OpSampledImage %25 %77 %78 %82 = OpImageSampleImplicitLod %v4float %79 %60 %83 = OpLoad %17 %g_tTex1df4 %84 = OpLoad %21 %g_sSamp %85 = OpSampledImage %25 %83 %84 %88 = OpImageSampleImplicitLod %v4float %85 %63 %91 = OpFAdd %v4float %82 %88 %94 = OpFMul %v4float %91 %116 OpStore %_entryPointOutput_Color %94 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck( defs0 + defs1 + func_orig, defs0 + relax_decos + defs1 + func_orig, true, true); } TEST_F(RelaxFloatOpsTest, RelaxFloatOpsForLinkage) { const std::string defs0 = R"(OpCapability Shader OpCapability Linkage OpCapability Sampled1D %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpSource HLSL 630 OpName %main "main" OpName %g_tTex1df4 "g_tTex1df4" OpName %g_sSamp "g_sSamp" OpName %i_Tex0 "i.Tex0" OpName %i_Tex1 "i.Tex1" OpName %_entryPointOutput_Color "@entryPointOutput.Color" OpDecorate %main LinkageAttributes "main" Export OpDecorate %g_tTex1df4 DescriptorSet 0 OpDecorate %g_tTex1df4 Binding 0 OpDecorate %g_sSamp DescriptorSet 0 OpDecorate %g_sSamp Binding 0 OpDecorate %i_Tex0 Location 0 OpDecorate %i_Tex1 Location 1 OpDecorate %_entryPointOutput_Color Location 0 )"; const std::string defs1 = R"(%void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %17 = OpTypeImage %float 1D 0 0 0 1 Unknown %_ptr_UniformConstant_17 = OpTypePointer UniformConstant %17 %g_tTex1df4 = OpVariable %_ptr_UniformConstant_17 UniformConstant %21 = OpTypeSampler %_ptr_UniformConstant_21 = OpTypePointer UniformConstant %21 %g_sSamp = OpVariable %_ptr_UniformConstant_21 UniformConstant %25 = OpTypeSampledImage %17 %_ptr_Input_float = OpTypePointer Input %float %i_Tex0 = OpVariable %_ptr_Input_float Input %i_Tex1 = OpVariable %_ptr_Input_float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput_Color = OpVariable %_ptr_Output_v4float Output %float_0_5 = OpConstant %float 0.5 %116 = OpConstantComposite %v4float %float_0_5 %float_0_5 %float_0_5 %float_0_5 )"; const std::string relax_decos = R"(OpDecorate %60 RelaxedPrecision OpDecorate %63 RelaxedPrecision OpDecorate %82 RelaxedPrecision OpDecorate %88 RelaxedPrecision OpDecorate %91 RelaxedPrecision OpDecorate %94 RelaxedPrecision )"; const std::string func_orig = R"(%main = OpFunction %void None %3 %5 = OpLabel %60 = OpLoad %float %i_Tex0 %63 = OpLoad %float %i_Tex1 %77 = OpLoad %17 %g_tTex1df4 %78 = OpLoad %21 %g_sSamp %79 = OpSampledImage %25 %77 %78 %82 = OpImageSampleImplicitLod %v4float %79 %60 %83 = OpLoad %17 %g_tTex1df4 %84 = OpLoad %21 %g_sSamp %85 = OpSampledImage %25 %83 %84 %88 = OpImageSampleImplicitLod %v4float %85 %63 %91 = OpFAdd %v4float %82 %88 %94 = OpFMul %v4float %91 %116 OpStore %_entryPointOutput_Color %94 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck( defs0 + defs1 + func_orig, defs0 + relax_decos + defs1 + func_orig, true, true); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/remove_dontinline_test.cpp000066400000000000000000000076551475742701700256120ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using StrengthReductionBasicTest = PassTest<::testing::Test>; TEST_F(StrengthReductionBasicTest, ClearDontInline) { const std::vector text = { // clang-format off "OpCapability Shader", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Vertex %main \"main\"", "%void = OpTypeVoid", "%4 = OpTypeFunction %void", "; CHECK: OpFunction %void None", "%main = OpFunction %void DontInline %4", "%8 = OpLabel", "OpReturn", "OpFunctionEnd" // clang-format on }; SinglePassRunAndMatch(JoinAllInsts(text), true); } TEST_F(StrengthReductionBasicTest, LeaveUnchanged1) { const std::vector text = { // clang-format off "OpCapability Shader", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Vertex %main \"main\"", "%void = OpTypeVoid", "%4 = OpTypeFunction %void", "%main = OpFunction %void None %4", "%8 = OpLabel", "OpReturn", "OpFunctionEnd" // clang-format on }; EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(SinglePassRunAndDisassemble( JoinAllInsts(text), false, true))); } TEST_F(StrengthReductionBasicTest, LeaveUnchanged2) { const std::vector text = { // clang-format off "OpCapability Shader", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Vertex %main \"main\"", "%void = OpTypeVoid", "%4 = OpTypeFunction %void", "%main = OpFunction %void Inline %4", "%8 = OpLabel", "OpReturn", "OpFunctionEnd" // clang-format on }; EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(SinglePassRunAndDisassemble( JoinAllInsts(text), false, true))); } TEST_F(StrengthReductionBasicTest, ClearMultipleDontInline) { const std::vector text = { // clang-format off "OpCapability Shader", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Vertex %main1 \"main1\"", "OpEntryPoint Vertex %main2 \"main2\"", "OpEntryPoint Vertex %main3 \"main3\"", "OpEntryPoint Vertex %main4 \"main4\"", "%void = OpTypeVoid", "%4 = OpTypeFunction %void", "; CHECK: OpFunction %void None", "%main1 = OpFunction %void DontInline %4", "%8 = OpLabel", "OpReturn", "OpFunctionEnd", "; CHECK: OpFunction %void Inline", "%main2 = OpFunction %void Inline %4", "%9 = OpLabel", "OpReturn", "OpFunctionEnd", "; CHECK: OpFunction %void Pure", "%main3 = OpFunction %void DontInline|Pure %4", "%10 = OpLabel", "OpReturn", "OpFunctionEnd", "; CHECK: OpFunction %void None", "%main4 = OpFunction %void None %4", "%11 = OpLabel", "OpReturn", "OpFunctionEnd" // clang-format on }; SinglePassRunAndMatch(JoinAllInsts(text), true); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/remove_unused_interface_variables_test.cpp000066400000000000000000000142271475742701700310130ustar00rootroot00000000000000// Copyright (c) 2021 ZHOU He // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "test/opt/assembly_builder.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using RemoveUnusedInterfaceVariablesTest = PassTest<::testing::Test>; static const std::string expected = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %_Z5func1v "_Z5func1v" %out_var_SV_TARGET OpEntryPoint Fragment %_Z5func2v "_Z5func2v" %out_var_SV_TARGET_0 OpExecutionMode %_Z5func1v OriginUpperLeft OpExecutionMode %_Z5func2v OriginUpperLeft OpSource HLSL 630 OpName %type_cba "type.cba" OpMemberName %type_cba 0 "color" OpName %cba "cba" OpName %out_var_SV_TARGET "out.var.SV_TARGET" OpName %out_var_SV_TARGET_0 "out.var.SV_TARGET" OpName %_Z5func1v "_Z5func1v" OpName %_Z5func2v "_Z5func2v" OpDecorate %out_var_SV_TARGET Location 0 OpDecorate %out_var_SV_TARGET_0 Location 0 OpDecorate %cba DescriptorSet 0 OpDecorate %cba Binding 0 OpMemberDecorate %type_cba 0 Offset 0 OpDecorate %type_cba Block %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %type_cba = OpTypeStruct %v4float %_ptr_Uniform_type_cba = OpTypePointer Uniform %type_cba %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %14 = OpTypeFunction %void %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %cba = OpVariable %_ptr_Uniform_type_cba Uniform %out_var_SV_TARGET = OpVariable %_ptr_Output_v4float Output %out_var_SV_TARGET_0 = OpVariable %_ptr_Output_v4float Output %_Z5func1v = OpFunction %void None %14 %16 = OpLabel %17 = OpAccessChain %_ptr_Uniform_v4float %cba %int_0 %18 = OpLoad %v4float %17 OpStore %out_var_SV_TARGET %18 OpReturn OpFunctionEnd %_Z5func2v = OpFunction %void None %14 %19 = OpLabel %20 = OpAccessChain %_ptr_Uniform_v4float %cba %int_0 %21 = OpLoad %v4float %20 OpStore %out_var_SV_TARGET_0 %21 OpReturn OpFunctionEnd )"; TEST_F(RemoveUnusedInterfaceVariablesTest, RemoveUnusedVariable) { const std::string text = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %_Z5func1v "_Z5func1v" %out_var_SV_TARGET %out_var_SV_TARGET_0 OpEntryPoint Fragment %_Z5func2v "_Z5func2v" %out_var_SV_TARGET %out_var_SV_TARGET_0 OpExecutionMode %_Z5func1v OriginUpperLeft OpExecutionMode %_Z5func2v OriginUpperLeft OpSource HLSL 630 OpName %type_cba "type.cba" OpMemberName %type_cba 0 "color" OpName %cba "cba" OpName %out_var_SV_TARGET "out.var.SV_TARGET" OpName %out_var_SV_TARGET_0 "out.var.SV_TARGET" OpName %_Z5func1v "_Z5func1v" OpName %_Z5func2v "_Z5func2v" OpDecorate %out_var_SV_TARGET Location 0 OpDecorate %out_var_SV_TARGET_0 Location 0 OpDecorate %cba DescriptorSet 0 OpDecorate %cba Binding 0 OpMemberDecorate %type_cba 0 Offset 0 OpDecorate %type_cba Block %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %type_cba = OpTypeStruct %v4float %_ptr_Uniform_type_cba = OpTypePointer Uniform %type_cba %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %14 = OpTypeFunction %void %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %cba = OpVariable %_ptr_Uniform_type_cba Uniform %out_var_SV_TARGET = OpVariable %_ptr_Output_v4float Output %out_var_SV_TARGET_0 = OpVariable %_ptr_Output_v4float Output %_Z5func1v = OpFunction %void None %14 %16 = OpLabel %17 = OpAccessChain %_ptr_Uniform_v4float %cba %int_0 %18 = OpLoad %v4float %17 OpStore %out_var_SV_TARGET %18 OpReturn OpFunctionEnd %_Z5func2v = OpFunction %void None %14 %19 = OpLabel %20 = OpAccessChain %_ptr_Uniform_v4float %cba %int_0 %21 = OpLoad %v4float %20 OpStore %out_var_SV_TARGET_0 %21 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(text, expected, true, true); } TEST_F(RemoveUnusedInterfaceVariablesTest, FixMissingVariable) { const std::string text = R"(OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %_Z5func1v "_Z5func1v" OpEntryPoint Fragment %_Z5func2v "_Z5func2v" OpExecutionMode %_Z5func1v OriginUpperLeft OpExecutionMode %_Z5func2v OriginUpperLeft OpSource HLSL 630 OpName %type_cba "type.cba" OpMemberName %type_cba 0 "color" OpName %cba "cba" OpName %out_var_SV_TARGET "out.var.SV_TARGET" OpName %out_var_SV_TARGET_0 "out.var.SV_TARGET" OpName %_Z5func1v "_Z5func1v" OpName %_Z5func2v "_Z5func2v" OpDecorate %out_var_SV_TARGET Location 0 OpDecorate %out_var_SV_TARGET_0 Location 0 OpDecorate %cba DescriptorSet 0 OpDecorate %cba Binding 0 OpMemberDecorate %type_cba 0 Offset 0 OpDecorate %type_cba Block %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %type_cba = OpTypeStruct %v4float %_ptr_Uniform_type_cba = OpTypePointer Uniform %type_cba %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %14 = OpTypeFunction %void %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %cba = OpVariable %_ptr_Uniform_type_cba Uniform %out_var_SV_TARGET = OpVariable %_ptr_Output_v4float Output %out_var_SV_TARGET_0 = OpVariable %_ptr_Output_v4float Output %_Z5func1v = OpFunction %void None %14 %16 = OpLabel %17 = OpAccessChain %_ptr_Uniform_v4float %cba %int_0 %18 = OpLoad %v4float %17 OpStore %out_var_SV_TARGET %18 OpReturn OpFunctionEnd %_Z5func2v = OpFunction %void None %14 %19 = OpLabel %20 = OpAccessChain %_ptr_Uniform_v4float %cba %int_0 %21 = OpLoad %v4float %20 OpStore %out_var_SV_TARGET_0 %21 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(text, expected, true, true); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/replace_desc_array_access_using_var_index_test.cpp000066400000000000000000000613301475742701700324540ustar00rootroot00000000000000// Copyright (c) 2021 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using ReplaceDescArrayAccessUsingVarIndexTest = PassTest<::testing::Test>; TEST_F(ReplaceDescArrayAccessUsingVarIndexTest, ReplaceAccessChainToTextureArray) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %psmain "psmain" %gl_FragCoord %in_var_INSTANCEID %out_var_SV_TARGET OpExecutionMode %psmain OriginUpperLeft OpSource HLSL 600 OpName %type_sampler "type.sampler" OpName %Sampler0 "Sampler0" OpName %type_2d_image "type.2d.image" OpName %Tex0 "Tex0" OpName %in_var_INSTANCEID "in.var.INSTANCEID" OpName %out_var_SV_TARGET "out.var.SV_TARGET" OpName %psmain "psmain" OpName %type_sampled_image "type.sampled.image" OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorate %in_var_INSTANCEID Flat OpDecorate %in_var_INSTANCEID Location 0 OpDecorate %out_var_SV_TARGET Location 0 OpDecorate %Sampler0 DescriptorSet 0 OpDecorate %Sampler0 Binding 1 OpDecorate %Tex0 DescriptorSet 0 OpDecorate %Tex0 Binding 2 %bool = OpTypeBool %type_sampler = OpTypeSampler %_ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %type_sampler %uint = OpTypeInt 32 0 %uint_3 = OpConstant %uint 3 %float = OpTypeFloat 32 %type_2d_image = OpTypeImage %float 2D 2 0 0 0 Unknown %_arr_type_2d_image_uint_3 = OpTypeArray %type_2d_image %uint_3 %_ptr_UniformConstant__arr_type_2d_image_uint_3 = OpTypePointer UniformConstant %_arr_type_2d_image_uint_3 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Input_uint = OpTypePointer Input %uint %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %21 = OpTypeFunction %void %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %v2float = OpTypeVector %float 2 %v2uint = OpTypeVector %uint 2 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %27 = OpConstantComposite %v2uint %uint_0 %uint_1 %type_sampled_image = OpTypeSampledImage %type_2d_image %Sampler0 = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %Tex0 = OpVariable %_ptr_UniformConstant__arr_type_2d_image_uint_3 UniformConstant %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %in_var_INSTANCEID = OpVariable %_ptr_Input_uint Input %out_var_SV_TARGET = OpVariable %_ptr_Output_v4float Output %uint_2 = OpConstant %uint 2 %66 = OpConstantNull %v4float ; CHECK: [[null_value:%\w+]] = OpConstantNull %v4float %psmain = OpFunction %void None %21 %39 = OpLabel %29 = OpLoad %v4float %gl_FragCoord %30 = OpLoad %uint %in_var_INSTANCEID %37 = OpIEqual %bool %30 %uint_2 OpSelectionMerge %38 None OpBranchConditional %37 %28 %40 ; CHECK: [[var_index:%\w+]] = OpLoad %uint %in_var_INSTANCEID ; CHECK: OpSelectionMerge [[cond_branch_merge:%\w+]] None ; CHECK: OpBranchConditional {{%\w+}} {{%\w+}} [[bb_cond_br:%\w+]] %28 = OpLabel %31 = OpAccessChain %_ptr_UniformConstant_type_2d_image %Tex0 %30 %32 = OpLoad %type_2d_image %31 OpImageWrite %32 %27 %29 ; CHECK: OpSelectionMerge [[merge:%\w+]] None ; CHECK: OpSwitch [[var_index]] [[default:%\w+]] 0 [[case0:%\w+]] 1 [[case1:%\w+]] 2 [[case2:%\w+]] ; CHECK: [[case0]] = OpLabel ; CHECK: OpAccessChain ; CHECK: OpLoad ; CHECK: OpImageWrite ; CHECK: OpBranch [[merge]] ; CHECK: [[case1]] = OpLabel ; CHECK: OpAccessChain ; CHECK: OpLoad ; CHECK: OpImageWrite ; CHECK: OpBranch [[merge]] ; CHECK: [[case2]] = OpLabel ; CHECK: OpAccessChain ; CHECK: OpLoad ; CHECK: OpImageWrite ; CHECK: OpBranch [[merge]] ; CHECK: [[default]] = OpLabel ; CHECK: OpBranch [[merge]] ; CHECK: [[merge]] = OpLabel %33 = OpLoad %type_sampler %Sampler0 %34 = OpVectorShuffle %v2float %29 %29 0 1 %35 = OpSampledImage %type_sampled_image %32 %33 %36 = OpImageSampleImplicitLod %v4float %35 %34 None ; CHECK: OpSelectionMerge [[merge:%\w+]] None ; CHECK: OpSwitch [[var_index]] [[default:%\w+]] 0 [[case0:%\w+]] 1 [[case1:%\w+]] 2 [[case2:%\w+]] ; CHECK: [[case0]] = OpLabel ; CHECK: [[ac:%\w+]] = OpAccessChain %_ptr_UniformConstant_type_2d_image %Tex0 %uint_0 ; CHECK: [[sam:%\w+]] = OpLoad %type_sampler %Sampler0 ; CHECK: [[img:%\w+]] = OpLoad %type_2d_image [[ac]] ; CHECK: [[sampledImg:%\w+]] = OpSampledImage %type_sampled_image [[img]] [[sam]] ; CHECK: [[value0:%\w+]] = OpImageSampleImplicitLod %v4float [[sampledImg]] ; CHECK: OpBranch [[merge]] ; CHECK: [[case1]] = OpLabel ; CHECK: [[ac:%\w+]] = OpAccessChain %_ptr_UniformConstant_type_2d_image %Tex0 %uint_1 ; CHECK: [[sam:%\w+]] = OpLoad %type_sampler %Sampler0 ; CHECK: [[img:%\w+]] = OpLoad %type_2d_image [[ac]] ; CHECK: [[sampledImg:%\w+]] = OpSampledImage %type_sampled_image [[img]] [[sam]] ; CHECK: [[value1:%\w+]] = OpImageSampleImplicitLod %v4float [[sampledImg]] ; CHECK: OpBranch [[merge]] ; CHECK: [[case2]] = OpLabel ; CHECK: [[ac:%\w+]] = OpAccessChain %_ptr_UniformConstant_type_2d_image %Tex0 %uint_2 ; CHECK: [[sam:%\w+]] = OpLoad %type_sampler %Sampler0 ; CHECK: [[img:%\w+]] = OpLoad %type_2d_image [[ac]] ; CHECK: [[sampledImg:%\w+]] = OpSampledImage %type_sampled_image [[img]] [[sam]] ; CHECK: [[value2:%\w+]] = OpImageSampleImplicitLod %v4float [[sampledImg]] ; CHECK: OpBranch [[merge]] ; CHECK: [[default]] = OpLabel ; CHECK: OpBranch [[merge]] ; CHECK: [[merge]] = OpLabel ; CHECK: [[phi0:%\w+]] = OpPhi %v4float [[value0]] [[case0]] [[value1]] [[case1]] [[value2]] [[case2]] [[null_value]] [[default]] OpBranch %38 %40 = OpLabel OpBranch %38 %38 = OpLabel %41 = OpPhi %v4float %36 %28 %29 %40 ; CHECK: OpBranch [[cond_branch_merge]] ; CHECK: [[bb_cond_br]] = OpLabel ; CHECK: OpBranch [[cond_branch_merge]] ; CHECK: [[cond_branch_merge]] = OpLabel ; CHECK: [[phi1:%\w+]] = OpPhi %v4float [[phi0]] [[merge]] {{%\w+}} [[bb_cond_br]] ; CHECK: OpStore {{%\w+}} [[phi1]] OpStore %out_var_SV_TARGET %41 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ReplaceDescArrayAccessUsingVarIndexTest, ReplaceAccessChainToTextureArrayAndSamplerArray) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %psmain "psmain" %gl_FragCoord %in_var_INSTANCEID %out_var_SV_TARGET OpExecutionMode %psmain OriginUpperLeft OpSource HLSL 600 OpName %type_sampler "type.sampler" OpName %Sampler0 "Sampler0" OpName %type_2d_image "type.2d.image" OpName %Tex0 "Tex0" OpName %in_var_INSTANCEID "in.var.INSTANCEID" OpName %out_var_SV_TARGET "out.var.SV_TARGET" OpName %psmain "psmain" OpName %type_sampled_image "type.sampled.image" OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorate %in_var_INSTANCEID Flat OpDecorate %in_var_INSTANCEID Location 0 OpDecorate %out_var_SV_TARGET Location 0 OpDecorate %Sampler0 DescriptorSet 0 OpDecorate %Sampler0 Binding 1 OpDecorate %Tex0 DescriptorSet 0 OpDecorate %Tex0 Binding 2 %type_sampler = OpTypeSampler %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %type_sampler %_arr_type_sampler_uint_2 = OpTypeArray %type_sampler %uint_2 %_ptr_UniformConstant__arr_type_sampler_uint_2 = OpTypePointer UniformConstant %_arr_type_sampler_uint_2 %float = OpTypeFloat 32 %type_2d_image = OpTypeImage %float 2D 2 0 0 0 Unknown %_arr_type_2d_image_uint_2 = OpTypeArray %type_2d_image %uint_2 %_ptr_UniformConstant__arr_type_2d_image_uint_2 = OpTypePointer UniformConstant %_arr_type_2d_image_uint_2 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Input_uint = OpTypePointer Input %uint %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %21 = OpTypeFunction %void %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %v2float = OpTypeVector %float 2 %v2uint = OpTypeVector %uint 2 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %27 = OpConstantComposite %v2uint %uint_0 %uint_1 %type_sampled_image = OpTypeSampledImage %type_2d_image %Sampler0 = OpVariable %_ptr_UniformConstant__arr_type_sampler_uint_2 UniformConstant %Tex0 = OpVariable %_ptr_UniformConstant__arr_type_2d_image_uint_2 UniformConstant %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %in_var_INSTANCEID = OpVariable %_ptr_Input_uint Input %out_var_SV_TARGET = OpVariable %_ptr_Output_v4float Output %66 = OpConstantNull %v4float %psmain = OpFunction %void None %21 %28 = OpLabel %29 = OpLoad %v4float %gl_FragCoord %30 = OpLoad %uint %in_var_INSTANCEID %31 = OpAccessChain %_ptr_UniformConstant_type_2d_image %Tex0 %30 %32 = OpLoad %type_2d_image %31 OpImageWrite %32 %27 %29 ; CHECK: [[null_value:%\w+]] = OpConstantNull %v4float ; CHECK: [[var_index:%\w+]] = OpLoad %uint %in_var_INSTANCEID ; CHECK: OpSelectionMerge [[merge:%\w+]] None ; CHECK: OpSwitch [[var_index]] [[default:%\w+]] 0 [[case0:%\w+]] 1 [[case1:%\w+]] ; CHECK: [[case0]] = OpLabel ; CHECK: OpAccessChain ; CHECK: OpLoad ; CHECK: OpImageWrite ; CHECK: OpBranch [[merge]] ; CHECK: [[case1]] = OpLabel ; CHECK: OpAccessChain ; CHECK: OpLoad ; CHECK: OpImageWrite ; CHECK: OpBranch [[merge]] ; CHECK: [[default]] = OpLabel ; CHECK: OpBranch [[merge]] ; CHECK: [[merge]] = OpLabel %33 = OpAccessChain %_ptr_UniformConstant_type_sampler %Sampler0 %30 %37 = OpLoad %type_sampler %33 %34 = OpVectorShuffle %v2float %29 %29 0 1 %35 = OpSampledImage %type_sampled_image %32 %37 %36 = OpImageSampleImplicitLod %v4float %35 %34 None ; SPIR-V instructions to be replaced (will be killed by ADCE) ; CHECK: OpSelectionMerge ; CHECK: OpSwitch ; CHECK: OpSelectionMerge [[merge_sampler:%\w+]] None ; CHECK: OpSwitch [[var_index]] [[default_sampler:%\w+]] 0 [[case_sampler0:%\w+]] 1 [[case_sampler1:%\w+]] ; CHECK: [[case_sampler0]] = OpLabel ; CHECK: OpSelectionMerge [[merge_texture0:%\w+]] None ; CHECK: OpSwitch [[var_index]] [[default_texture:%\w+]] 0 [[case_texture0:%\w+]] 1 [[case_texture1:%\w+]] ; CHECK: [[case_texture0]] = OpLabel ; CHECK: [[pt0:%\w+]] = OpAccessChain %_ptr_UniformConstant_type_2d_image %Tex0 %uint_0 ; CHECK: [[ps0:%\w+]] = OpAccessChain %_ptr_UniformConstant_type_sampler %Sampler0 %uint_0 ; CHECK: [[s0:%\w+]] = OpLoad %type_sampler [[ps0]] ; CHECK: [[t0:%\w+]] = OpLoad %type_2d_image [[pt0]] ; CHECK: [[sampledImg0:%\w+]] = OpSampledImage %type_sampled_image [[t0]] [[s0]] ; CHECK: [[value0:%\w+]] = OpImageSampleImplicitLod %v4float [[sampledImg0]] ; CHECK: OpBranch [[merge_texture0]] ; CHECK: [[case_texture1]] = OpLabel ; CHECK: [[pt1:%\w+]] = OpAccessChain %_ptr_UniformConstant_type_2d_image %Tex0 %uint_1 ; CHECK: [[ps0:%\w+]] = OpAccessChain %_ptr_UniformConstant_type_sampler %Sampler0 %uint_0 ; CHECK: [[s0:%\w+]] = OpLoad %type_sampler [[ps0]] ; CHECK: [[t1:%\w+]] = OpLoad %type_2d_image [[pt1]] ; CHECK: [[sampledImg1:%\w+]] = OpSampledImage %type_sampled_image [[t1]] [[s0]] ; CHECK: [[value1:%\w+]] = OpImageSampleImplicitLod %v4float [[sampledImg1]] ; CHECK: OpBranch [[merge_texture0]] ; CHECK: [[default_texture]] = OpLabel ; CHECK: OpBranch [[merge_texture0]] ; CHECK: [[merge_texture0]] = OpLabel ; CHECK: [[phi0:%\w+]] = OpPhi %v4float [[value0]] [[case_texture0]] [[value1]] [[case_texture1]] [[null_value]] [[default_texture]] ; CHECK: OpBranch [[merge_sampler]] ; CHECK: [[case_sampler1]] = OpLabel ; CHECK: OpSelectionMerge [[merge_texture1:%\w+]] None ; CHECK: OpSwitch [[var_index]] [[default_texture:%\w+]] 0 [[case_texture0:%\w+]] 1 [[case_texture1:%\w+]] ; CHECK: [[case_texture0]] = OpLabel ; CHECK: [[pt0:%\w+]] = OpAccessChain %_ptr_UniformConstant_type_2d_image %Tex0 %uint_0 ; CHECK: [[ps1:%\w+]] = OpAccessChain %_ptr_UniformConstant_type_sampler %Sampler0 %uint_1 ; CHECK: [[s1:%\w+]] = OpLoad %type_sampler [[ps1]] ; CHECK: [[t0:%\w+]] = OpLoad %type_2d_image [[pt0]] ; CHECK: [[sampledImg0:%\w+]] = OpSampledImage %type_sampled_image [[t0]] [[s1]] ; CHECK: [[value0:%\w+]] = OpImageSampleImplicitLod %v4float [[sampledImg0]] ; CHECK: OpBranch [[merge_texture1]] ; CHECK: [[case_texture1]] = OpLabel ; CHECK: [[pt1:%\w+]] = OpAccessChain %_ptr_UniformConstant_type_2d_image %Tex0 %uint_1 ; CHECK: [[ps1:%\w+]] = OpAccessChain %_ptr_UniformConstant_type_sampler %Sampler0 %uint_1 ; CHECK: [[s1:%\w+]] = OpLoad %type_sampler [[ps1]] ; CHECK: [[t1:%\w+]] = OpLoad %type_2d_image [[pt1]] ; CHECK: [[sampledImg1:%\w+]] = OpSampledImage %type_sampled_image [[t1]] [[s1]] ; CHECK: [[value1:%\w+]] = OpImageSampleImplicitLod %v4float [[sampledImg1]] ; CHECK: OpBranch [[merge_texture1]] ; CHECK: [[default_texture]] = OpLabel ; CHECK: OpBranch [[merge_texture1]] ; CHECK: [[merge_texture1]] = OpLabel ; CHECK: [[phi1:%\w+]] = OpPhi %v4float [[value0]] [[case_texture0]] [[value1]] [[case_texture1]] [[null_value]] [[default_texture]] ; CHECK: [[default_sampler]] = OpLabel ; CHECK: OpBranch [[merge_sampler]] ; CHECK: [[merge_sampler]] = OpLabel ; CHECK: OpPhi %v4float [[phi0]] [[merge_texture0]] [[phi1]] [[merge_texture1]] [[null_value]] [[default_sampler]] ; CHECK: OpStore OpStore %out_var_SV_TARGET %36 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ReplaceDescArrayAccessUsingVarIndexTest, ReplaceAccessChainToTextureArrayWithSingleElement) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %psmain "psmain" %gl_FragCoord %in_var_INSTANCEID %out_var_SV_TARGET OpExecutionMode %psmain OriginUpperLeft OpSource HLSL 600 OpName %type_sampler "type.sampler" OpName %Sampler0 "Sampler0" OpName %type_2d_image "type.2d.image" OpName %Tex0 "Tex0" OpName %in_var_INSTANCEID "in.var.INSTANCEID" OpName %out_var_SV_TARGET "out.var.SV_TARGET" OpName %psmain "psmain" OpName %type_sampled_image "type.sampled.image" OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorate %in_var_INSTANCEID Flat OpDecorate %in_var_INSTANCEID Location 0 OpDecorate %out_var_SV_TARGET Location 0 OpDecorate %Sampler0 DescriptorSet 0 OpDecorate %Sampler0 Binding 1 OpDecorate %Tex0 DescriptorSet 0 OpDecorate %Tex0 Binding 2 %type_sampler = OpTypeSampler %_ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %type_sampler %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %float = OpTypeFloat 32 %type_2d_image = OpTypeImage %float 2D 2 0 0 0 Unknown %_arr_type_2d_image_uint_1 = OpTypeArray %type_2d_image %uint_1 %_ptr_UniformConstant__arr_type_2d_image_uint_1 = OpTypePointer UniformConstant %_arr_type_2d_image_uint_1 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Input_uint = OpTypePointer Input %uint %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %21 = OpTypeFunction %void %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %v2float = OpTypeVector %float 2 %v2uint = OpTypeVector %uint 2 %uint_0 = OpConstant %uint 0 %27 = OpConstantComposite %v2uint %uint_0 %uint_1 %type_sampled_image = OpTypeSampledImage %type_2d_image %Sampler0 = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %Tex0 = OpVariable %_ptr_UniformConstant__arr_type_2d_image_uint_1 UniformConstant %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %in_var_INSTANCEID = OpVariable %_ptr_Input_uint Input %out_var_SV_TARGET = OpVariable %_ptr_Output_v4float Output %uint_2 = OpConstant %uint 2 %66 = OpConstantNull %v4float %psmain = OpFunction %void None %21 %28 = OpLabel %29 = OpLoad %v4float %gl_FragCoord %30 = OpLoad %uint %in_var_INSTANCEID %31 = OpAccessChain %_ptr_UniformConstant_type_2d_image %Tex0 %30 %32 = OpLoad %type_2d_image %31 OpImageWrite %32 %27 %29 ; CHECK: [[ac:%\w+]] = OpAccessChain %_ptr_UniformConstant_type_2d_image %Tex0 %uint_0 ; CHECK-NOT: OpAccessChain ; CHECK-NOT: OpSwitch ; CHECK-NOT: OpPhi %33 = OpLoad %type_sampler %Sampler0 %34 = OpVectorShuffle %v2float %29 %29 0 1 %35 = OpSampledImage %type_sampled_image %32 %33 %36 = OpImageSampleImplicitLod %v4float %35 %34 None OpStore %out_var_SV_TARGET %36 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ReplaceDescArrayAccessUsingVarIndexTest, ReplaceMultipleAccessChains) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "TestFragment" %2 OpExecutionMode %1 OriginUpperLeft OpName %11 "type.ConstantBuffer.TestStruct" OpMemberName %11 0 "val1" OpMemberName %11 1 "val2" OpName %3 "TestResources" OpName %13 "type.2d.image" OpName %4 "OutBuffer" OpName %2 "in.var.SV_INSTANCEID" OpName %1 "TestFragment" OpDecorate %2 Flat OpDecorate %2 Location 0 OpDecorate %3 DescriptorSet 0 OpDecorate %3 Binding 0 OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 1 OpMemberDecorate %11 0 Offset 0 OpMemberDecorate %11 1 Offset 4 OpDecorate %11 Block %9 = OpTypeInt 32 0 %10 = OpConstant %9 2 %11 = OpTypeStruct %9 %9 %8 = OpTypeArray %11 %10 %7 = OpTypePointer Uniform %8 %13 = OpTypeImage %9 2D 2 0 0 2 R32ui %12 = OpTypePointer UniformConstant %13 %14 = OpTypePointer Input %9 %15 = OpTypeVoid %16 = OpTypeFunction %15 %40 = OpTypeVector %9 2 %3 = OpVariable %7 Uniform %4 = OpVariable %12 UniformConstant %2 = OpVariable %14 Input %57 = OpTypePointer Uniform %11 %61 = OpTypePointer Uniform %9 %62 = OpConstant %9 0 %1 = OpFunction %15 None %16 %17 = OpLabel %20 = OpLoad %9 %2 %47 = OpAccessChain %57 %3 %20 %63 = OpAccessChain %61 %47 %62 %64 = OpLoad %9 %63 ; CHECK: [[null_value:%\w+]] = OpConstantNull %uint ; CHECK: [[var_index:%\w+]] = OpLoad %uint %in_var_SV_INSTANCEID ; CHECK: OpSelectionMerge [[merge:%\w+]] None ; CHECK: OpSwitch [[var_index]] [[default:%\w+]] 0 [[case0:%\w+]] 1 [[case1:%\w+]] ; CHECK: [[case0]] = OpLabel ; CHECK: OpAccessChain ; CHECK: OpAccessChain ; CHECK: [[result0:%\w+]] = OpLoad ; CHECK: OpBranch [[merge]] ; CHECK: [[case1]] = OpLabel ; CHECK: OpAccessChain ; CHECK: OpAccessChain ; CHECK: [[result1:%\w+]] = OpLoad ; CHECK: OpBranch [[merge]] ; CHECK: [[default]] = OpLabel ; CHECK: OpBranch [[merge]] ; CHECK: [[merge]] = OpLabel ; CHECK: OpPhi %uint [[result0]] [[case0]] [[result1]] [[case1]] [[null_value]] [[default]] %55 = OpCompositeConstruct %40 %20 %20 %56 = OpLoad %13 %4 OpImageWrite %56 %55 %64 None OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ReplaceDescArrayAccessUsingVarIndexTest, ReplaceAccessChainToTextureArrayWithNonUniformIndex) { const std::string text = R"( OpCapability Shader OpCapability ShaderNonUniform OpCapability SampledImageArrayNonUniformIndexing OpExtension "SPV_EXT_descriptor_indexing" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %PSMain "PSMain" %in_var_TEXCOORD0 %in_var_MATERIAL_ID %out_var_SV_TARGET OpExecutionMode %PSMain OriginUpperLeft OpSource HLSL 610 OpName %type_sampler "type.sampler" OpName %sampler_ "sampler_" OpName %type_2d_image "type.2d.image" OpName %texture_2d "texture_2d" OpName %in_var_TEXCOORD0 "in.var.TEXCOORD0" OpName %in_var_MATERIAL_ID "in.var.MATERIAL_ID" OpName %out_var_SV_TARGET "out.var.SV_TARGET" OpName %PSMain "PSMain" OpName %type_sampled_image "type.sampled.image" OpDecorate %in_var_MATERIAL_ID Flat OpDecorate %in_var_TEXCOORD0 Location 0 OpDecorate %in_var_MATERIAL_ID Location 1 OpDecorate %out_var_SV_TARGET Location 0 OpDecorate %sampler_ DescriptorSet 1 OpDecorate %sampler_ Binding 1 OpDecorate %texture_2d DescriptorSet 0 OpDecorate %texture_2d Binding 0 ; CHECK: OpDecorate [[v0:%\w+]] NonUniform ; CHECK: OpDecorate [[v1:%\w+]] NonUniform ; CHECK: OpDecorate [[v2:%\w+]] NonUniform ; CHECK: OpDecorate [[v3:%\w+]] NonUniform OpDecorate %10 NonUniform OpDecorate %11 NonUniform OpDecorate %12 NonUniform OpDecorate %13 NonUniform %type_sampler = OpTypeSampler %_ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %type_sampler %uint = OpTypeInt 32 0 %uint_4 = OpConstant %uint 4 %float = OpTypeFloat 32 %type_2d_image = OpTypeImage %float 2D 2 0 0 1 Unknown %_arr_type_2d_image_uint_4 = OpTypeArray %type_2d_image %uint_4 %_ptr_UniformConstant__arr_type_2d_image_uint_4 = OpTypePointer UniformConstant %_arr_type_2d_image_uint_4 %v2float = OpTypeVector %float 2 %_ptr_Input_v2float = OpTypePointer Input %v2float %_ptr_Input_uint = OpTypePointer Input %uint %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %26 = OpTypeFunction %void %_ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %type_2d_image %type_sampled_image = OpTypeSampledImage %type_2d_image %sampler_ = OpVariable %_ptr_UniformConstant_type_sampler UniformConstant %texture_2d = OpVariable %_ptr_UniformConstant__arr_type_2d_image_uint_4 UniformConstant %in_var_TEXCOORD0 = OpVariable %_ptr_Input_v2float Input %in_var_MATERIAL_ID = OpVariable %_ptr_Input_uint Input %out_var_SV_TARGET = OpVariable %_ptr_Output_v4float Output ; CHECK: %uint_0 = OpConstant %uint 0 ; CHECK: %uint_1 = OpConstant %uint 1 ; CHECK: %uint_2 = OpConstant %uint 2 ; CHECK: %uint_3 = OpConstant %uint 3 %PSMain = OpFunction %void None %26 %28 = OpLabel %29 = OpLoad %v2float %in_var_TEXCOORD0 %30 = OpLoad %uint %in_var_MATERIAL_ID ; CHECK: [[v0]] = OpCopyObject %uint {{%\w+}} %10 = OpCopyObject %uint %30 ; CHECK: [[v1]] = OpAccessChain %_ptr_UniformConstant_type_2d_image %texture_2d [[v0]] %11 = OpAccessChain %_ptr_UniformConstant_type_2d_image %texture_2d %10 ; CHECK: [[v2]] = OpLoad %type_2d_image [[v1]] %12 = OpLoad %type_2d_image %11 %31 = OpLoad %type_sampler %sampler_ ; CHECK: [[v3]] = OpSampledImage %type_sampled_image [[v2]] {{%\w+}} %13 = OpSampledImage %type_sampled_image %12 %31 %32 = OpImageSampleImplicitLod %v4float %13 %29 None OpStore %out_var_SV_TARGET %32 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/replace_invalid_opc_test.cpp000066400000000000000000000611461475742701700260470ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "pass_utils.h" #include "test/opt/assembly_builder.h" #include "test/opt/pass_fixture.h" namespace spvtools { namespace opt { namespace { using ReplaceInvalidOpcodeTest = PassTest<::testing::Test>; TEST_F(ReplaceInvalidOpcodeTest, ReplaceInstruction) { const std::string text = R"( ; CHECK: [[special_const:%\w+]] = OpConstant %float -6.2598534e+18 ; CHECK: [[constant:%\w+]] = OpConstantComposite %v4float [[special_const]] [[special_const]] [[special_const]] [[special_const]] ; CHECK-NOT: OpImageSampleImplicitLod ; CHECK: OpStore [[:%\w+]] [[constant]] OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %3 %gl_VertexIndex %5 OpSource GLSL 400 OpSourceExtension "GL_ARB_separate_shader_objects" OpSourceExtension "GL_ARB_shading_language_420pack" OpName %main "main" OpDecorate %3 Location 0 OpDecorate %gl_VertexIndex BuiltIn VertexIndex OpMemberDecorate %_struct_6 0 BuiltIn Position OpDecorate %_struct_6 Block %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %10 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_10 = OpTypePointer UniformConstant %10 %12 = OpTypeSampler %_ptr_UniformConstant_12 = OpTypePointer UniformConstant %12 %14 = OpTypeSampledImage %10 %v4float = OpTypeVector %float 4 %v2float = OpTypeVector %float 2 %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %gl_VertexIndex = OpVariable %_ptr_Input_int Input %_struct_6 = OpTypeStruct %v4float %_ptr_Output__struct_6 = OpTypePointer Output %_struct_6 %5 = OpVariable %_ptr_Output__struct_6 Output %int_0 = OpConstant %int 0 %float_0 = OpConstant %float 0 %23 = OpConstantComposite %v2float %float_0 %float_0 %24 = OpVariable %_ptr_UniformConstant_10 UniformConstant %25 = OpVariable %_ptr_UniformConstant_12 UniformConstant %main = OpFunction %void None %8 %26 = OpLabel %27 = OpLoad %12 %25 %28 = OpLoad %10 %24 %29 = OpSampledImage %14 %28 %27 %30 = OpImageSampleImplicitLod %v4float %29 %23 %31 = OpAccessChain %_ptr_Output_v4float %5 %int_0 OpStore %31 %30 OpReturn OpFunctionEnd)"; SinglePassRunAndMatch(text, false); } TEST_F(ReplaceInvalidOpcodeTest, ReplaceInstructionInNonEntryPoint) { const std::string text = R"( ; CHECK: [[special_const:%\w+]] = OpConstant %float -6.2598534e+18 ; CHECK: [[constant:%\w+]] = OpConstantComposite %v4float [[special_const]] [[special_const]] [[special_const]] [[special_const]] ; CHECK-NOT: OpImageSampleImplicitLod ; CHECK: OpStore [[:%\w+]] [[constant]] OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %3 %gl_VertexIndex %5 OpSource GLSL 400 OpSourceExtension "GL_ARB_separate_shader_objects" OpSourceExtension "GL_ARB_shading_language_420pack" OpName %main "main" OpDecorate %3 Location 0 OpDecorate %gl_VertexIndex BuiltIn VertexIndex OpMemberDecorate %_struct_6 0 BuiltIn Position OpDecorate %_struct_6 Block %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %10 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_10 = OpTypePointer UniformConstant %10 %12 = OpTypeSampler %_ptr_UniformConstant_12 = OpTypePointer UniformConstant %12 %14 = OpTypeSampledImage %10 %v4float = OpTypeVector %float 4 %v2float = OpTypeVector %float 2 %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %gl_VertexIndex = OpVariable %_ptr_Input_int Input %_struct_6 = OpTypeStruct %v4float %_ptr_Output__struct_6 = OpTypePointer Output %_struct_6 %5 = OpVariable %_ptr_Output__struct_6 Output %int_0 = OpConstant %int 0 %float_0 = OpConstant %float 0 %23 = OpConstantComposite %v2float %float_0 %float_0 %24 = OpVariable %_ptr_UniformConstant_10 UniformConstant %25 = OpVariable %_ptr_UniformConstant_12 UniformConstant %main = OpFunction %void None %8 %26 = OpLabel %27 = OpFunctionCall %void %28 OpReturn OpFunctionEnd %28 = OpFunction %void None %8 %29 = OpLabel %30 = OpLoad %12 %25 %31 = OpLoad %10 %24 %32 = OpSampledImage %14 %31 %30 %33 = OpImageSampleImplicitLod %v4float %32 %23 %34 = OpAccessChain %_ptr_Output_v4float %5 %int_0 OpStore %34 %33 OpReturn OpFunctionEnd)"; SinglePassRunAndMatch(text, false); } TEST_F(ReplaceInvalidOpcodeTest, ReplaceInstructionMultipleEntryPoints) { const std::string text = R"( ; CHECK: [[special_const:%\w+]] = OpConstant %float -6.2598534e+18 ; CHECK: [[constant:%\w+]] = OpConstantComposite %v4float [[special_const]] [[special_const]] [[special_const]] [[special_const]] ; CHECK-NOT: OpImageSampleImplicitLod ; CHECK: OpStore [[:%\w+]] [[constant]] ; CHECK-NOT: OpImageSampleImplicitLod ; CHECK: OpStore [[:%\w+]] [[constant]] OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %3 %gl_VertexIndex %5 OpEntryPoint Vertex %main2 "main2" %3 %gl_VertexIndex %5 OpSource GLSL 400 OpSourceExtension "GL_ARB_separate_shader_objects" OpSourceExtension "GL_ARB_shading_language_420pack" OpName %main "main" OpName %main2 "main2" OpDecorate %3 Location 0 OpDecorate %gl_VertexIndex BuiltIn VertexIndex OpMemberDecorate %_struct_6 0 BuiltIn Position OpDecorate %_struct_6 Block %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %10 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_10 = OpTypePointer UniformConstant %10 %12 = OpTypeSampler %_ptr_UniformConstant_12 = OpTypePointer UniformConstant %12 %14 = OpTypeSampledImage %10 %v4float = OpTypeVector %float 4 %v2float = OpTypeVector %float 2 %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %gl_VertexIndex = OpVariable %_ptr_Input_int Input %_struct_6 = OpTypeStruct %v4float %_ptr_Output__struct_6 = OpTypePointer Output %_struct_6 %5 = OpVariable %_ptr_Output__struct_6 Output %int_0 = OpConstant %int 0 %float_0 = OpConstant %float 0 %23 = OpConstantComposite %v2float %float_0 %float_0 %24 = OpVariable %_ptr_UniformConstant_10 UniformConstant %25 = OpVariable %_ptr_UniformConstant_12 UniformConstant %main = OpFunction %void None %8 %26 = OpLabel %27 = OpLoad %12 %25 %28 = OpLoad %10 %24 %29 = OpSampledImage %14 %28 %27 %30 = OpImageSampleImplicitLod %v4float %29 %23 %31 = OpAccessChain %_ptr_Output_v4float %5 %int_0 OpStore %31 %30 OpReturn OpFunctionEnd %main2 = OpFunction %void None %8 %46 = OpLabel %47 = OpLoad %12 %25 %48 = OpLoad %10 %24 %49 = OpSampledImage %14 %48 %47 %50 = OpImageSampleImplicitLod %v4float %49 %23 %51 = OpAccessChain %_ptr_Output_v4float %5 %int_0 OpStore %51 %50 OpReturn OpFunctionEnd)"; SinglePassRunAndMatch(text, false); } TEST_F(ReplaceInvalidOpcodeTest, DontReplaceInstruction) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %3 %gl_VertexIndex %5 OpSource GLSL 400 OpSourceExtension "GL_ARB_separate_shader_objects" OpSourceExtension "GL_ARB_shading_language_420pack" OpName %main "main" OpDecorate %3 Location 0 OpDecorate %gl_VertexIndex BuiltIn VertexIndex OpMemberDecorate %_struct_6 0 BuiltIn Position OpDecorate %_struct_6 Block %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %10 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_10 = OpTypePointer UniformConstant %10 %12 = OpTypeSampler %_ptr_UniformConstant_12 = OpTypePointer UniformConstant %12 %14 = OpTypeSampledImage %10 %v4float = OpTypeVector %float 4 %v2float = OpTypeVector %float 2 %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %gl_VertexIndex = OpVariable %_ptr_Input_int Input %_struct_6 = OpTypeStruct %v4float %_ptr_Output__struct_6 = OpTypePointer Output %_struct_6 %5 = OpVariable %_ptr_Output__struct_6 Output %int_0 = OpConstant %int 0 %float_0 = OpConstant %float 0 %23 = OpConstantComposite %v2float %float_0 %float_0 %24 = OpVariable %_ptr_UniformConstant_10 UniformConstant %25 = OpVariable %_ptr_UniformConstant_12 UniformConstant %main = OpFunction %void None %8 %26 = OpLabel %27 = OpLoad %12 %25 %28 = OpLoad %10 %24 %29 = OpSampledImage %14 %28 %27 %30 = OpImageSampleImplicitLod %v4float %29 %23 %31 = OpAccessChain %_ptr_Output_v4float %5 %int_0 OpStore %31 %30 OpReturn OpFunctionEnd)"; auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ false); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } TEST_F(ReplaceInvalidOpcodeTest, MultipleEntryPointsDifferentStage) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %3 %gl_VertexIndex %5 OpEntryPoint Fragment %main2 "main2" %3 %gl_VertexIndex %5 OpSource GLSL 400 OpSourceExtension "GL_ARB_separate_shader_objects" OpSourceExtension "GL_ARB_shading_language_420pack" OpName %main "main" OpName %main2 "main2" OpDecorate %3 Location 0 OpDecorate %gl_VertexIndex BuiltIn VertexIndex OpMemberDecorate %_struct_6 0 BuiltIn Position OpDecorate %_struct_6 Block %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %10 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_10 = OpTypePointer UniformConstant %10 %12 = OpTypeSampler %_ptr_UniformConstant_12 = OpTypePointer UniformConstant %12 %14 = OpTypeSampledImage %10 %v4float = OpTypeVector %float 4 %v2float = OpTypeVector %float 2 %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %gl_VertexIndex = OpVariable %_ptr_Input_int Input %_struct_6 = OpTypeStruct %v4float %_ptr_Output__struct_6 = OpTypePointer Output %_struct_6 %5 = OpVariable %_ptr_Output__struct_6 Output %int_0 = OpConstant %int 0 %float_0 = OpConstant %float 0 %23 = OpConstantComposite %v2float %float_0 %float_0 %24 = OpVariable %_ptr_UniformConstant_10 UniformConstant %25 = OpVariable %_ptr_UniformConstant_12 UniformConstant %main = OpFunction %void None %8 %26 = OpLabel %27 = OpLoad %12 %25 %28 = OpLoad %10 %24 %29 = OpSampledImage %14 %28 %27 %30 = OpImageSampleImplicitLod %v4float %29 %23 %31 = OpAccessChain %_ptr_Output_v4float %5 %int_0 OpStore %31 %30 OpReturn OpFunctionEnd %main2 = OpFunction %void None %8 %46 = OpLabel %47 = OpLoad %12 %25 %48 = OpLoad %10 %24 %49 = OpSampledImage %14 %48 %47 %50 = OpImageSampleImplicitLod %v4float %49 %23 %51 = OpAccessChain %_ptr_Output_v4float %5 %int_0 OpStore %51 %50 OpReturn OpFunctionEnd)"; auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ false); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } TEST_F(ReplaceInvalidOpcodeTest, DontReplaceLinkage) { const std::string text = R"( OpCapability Shader OpCapability Linkage %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %3 %gl_VertexIndex %5 OpSource GLSL 400 OpSourceExtension "GL_ARB_separate_shader_objects" OpSourceExtension "GL_ARB_shading_language_420pack" OpName %main "main" OpDecorate %3 Location 0 OpDecorate %gl_VertexIndex BuiltIn VertexIndex OpMemberDecorate %_struct_6 0 BuiltIn Position OpDecorate %_struct_6 Block %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %10 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_10 = OpTypePointer UniformConstant %10 %12 = OpTypeSampler %_ptr_UniformConstant_12 = OpTypePointer UniformConstant %12 %14 = OpTypeSampledImage %10 %v4float = OpTypeVector %float 4 %v2float = OpTypeVector %float 2 %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %gl_VertexIndex = OpVariable %_ptr_Input_int Input %_struct_6 = OpTypeStruct %v4float %_ptr_Output__struct_6 = OpTypePointer Output %_struct_6 %5 = OpVariable %_ptr_Output__struct_6 Output %int_0 = OpConstant %int 0 %float_0 = OpConstant %float 0 %23 = OpConstantComposite %v2float %float_0 %float_0 %24 = OpVariable %_ptr_UniformConstant_10 UniformConstant %25 = OpVariable %_ptr_UniformConstant_12 UniformConstant %main = OpFunction %void None %8 %26 = OpLabel %27 = OpLoad %12 %25 %28 = OpLoad %10 %24 %29 = OpSampledImage %14 %28 %27 %30 = OpImageSampleImplicitLod %v4float %29 %23 %31 = OpAccessChain %_ptr_Output_v4float %5 %int_0 OpStore %31 %30 OpReturn OpFunctionEnd)"; auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ false); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } TEST_F(ReplaceInvalidOpcodeTest, BarrierDontReplace) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpName %main "main" %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %uint_264 = OpConstant %uint 264 %main = OpFunction %void None %3 %5 = OpLabel OpControlBarrier %uint_2 %uint_2 %uint_264 OpReturn OpFunctionEnd)"; SetTargetEnv(SPV_ENV_UNIVERSAL_1_2); auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ false); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } TEST_F(ReplaceInvalidOpcodeTest, BarrierReplace) { const std::string text = R"( ; CHECK-NOT: OpControlBarrier OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpName %main "main" %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %uint_264 = OpConstant %uint 264 %main = OpFunction %void None %3 %5 = OpLabel OpControlBarrier %uint_2 %uint_2 %uint_264 OpReturn OpFunctionEnd)"; SetTargetEnv(SPV_ENV_UNIVERSAL_1_2); SinglePassRunAndMatch(text, false); } // Since version 1.3 OpControlBarriers are allowed is more shaders. // https://registry.khronos.org/SPIR-V/specs/unified1/SPIRV.html#OpControlBarrier TEST_F(ReplaceInvalidOpcodeTest, BarrierDontReplaceV13) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpName %main "main" %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %uint_264 = OpConstant %uint 264 %main = OpFunction %void None %3 %5 = OpLabel OpControlBarrier %uint_2 %uint_2 %uint_264 OpReturn OpFunctionEnd)"; SetTargetEnv(SPV_ENV_UNIVERSAL_1_3); auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ false); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } TEST_F(ReplaceInvalidOpcodeTest, MessageTest) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %3 %gl_VertexIndex %5 OpSource GLSL 400 %6 = OpString "test.hlsl" OpSourceExtension "GL_ARB_separate_shader_objects" OpSourceExtension "GL_ARB_shading_language_420pack" OpName %main "main" OpDecorate %3 Location 0 OpDecorate %gl_VertexIndex BuiltIn VertexIndex OpMemberDecorate %_struct_7 0 BuiltIn Position OpDecorate %_struct_7 Block %void = OpTypeVoid %9 = OpTypeFunction %void %float = OpTypeFloat 32 %11 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_11 = OpTypePointer UniformConstant %11 %13 = OpTypeSampler %_ptr_UniformConstant_13 = OpTypePointer UniformConstant %13 %15 = OpTypeSampledImage %11 %v4float = OpTypeVector %float 4 %v2float = OpTypeVector %float 2 %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %gl_VertexIndex = OpVariable %_ptr_Input_int Input %_struct_7 = OpTypeStruct %v4float %_ptr_Output__struct_7 = OpTypePointer Output %_struct_7 %5 = OpVariable %_ptr_Output__struct_7 Output %int_0 = OpConstant %int 0 %float_0 = OpConstant %float 0 %24 = OpConstantComposite %v2float %float_0 %float_0 %25 = OpVariable %_ptr_UniformConstant_11 UniformConstant %26 = OpVariable %_ptr_UniformConstant_13 UniformConstant %main = OpFunction %void None %9 %27 = OpLabel OpLine %6 2 4 %28 = OpLoad %13 %26 %29 = OpLoad %11 %25 %30 = OpSampledImage %15 %29 %28 %31 = OpImageSampleImplicitLod %v4float %30 %24 %32 = OpAccessChain %_ptr_Output_v4float %5 %int_0 OpStore %32 %31 OpReturn OpFunctionEnd)"; std::vector messages = { {SPV_MSG_WARNING, "test.hlsl", 2, 4, "Removing ImageSampleImplicitLod instruction because of incompatible " "execution model."}}; SetMessageConsumer(GetTestMessageConsumer(messages)); auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ false); EXPECT_EQ(Pass::Status::SuccessWithChange, std::get<1>(result)); } TEST_F(ReplaceInvalidOpcodeTest, MultipleMessageTest) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %3 %gl_VertexIndex %5 OpSource GLSL 400 %6 = OpString "test.hlsl" OpSourceExtension "GL_ARB_separate_shader_objects" OpSourceExtension "GL_ARB_shading_language_420pack" OpName %main "main" OpDecorate %3 Location 0 OpDecorate %gl_VertexIndex BuiltIn VertexIndex OpMemberDecorate %_struct_7 0 BuiltIn Position OpDecorate %_struct_7 Block %void = OpTypeVoid %9 = OpTypeFunction %void %float = OpTypeFloat 32 %11 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_11 = OpTypePointer UniformConstant %11 %13 = OpTypeSampler %_ptr_UniformConstant_13 = OpTypePointer UniformConstant %13 %15 = OpTypeSampledImage %11 %v4float = OpTypeVector %float 4 %v2float = OpTypeVector %float 2 %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %gl_VertexIndex = OpVariable %_ptr_Input_int Input %_struct_7 = OpTypeStruct %v4float %_ptr_Output__struct_7 = OpTypePointer Output %_struct_7 %5 = OpVariable %_ptr_Output__struct_7 Output %int_0 = OpConstant %int 0 %float_0 = OpConstant %float 0 %24 = OpConstantComposite %v2float %float_0 %float_0 %25 = OpVariable %_ptr_UniformConstant_11 UniformConstant %26 = OpVariable %_ptr_UniformConstant_13 UniformConstant %main = OpFunction %void None %9 %27 = OpLabel OpLine %6 2 4 %28 = OpLoad %13 %26 %29 = OpLoad %11 %25 %30 = OpSampledImage %15 %29 %28 %31 = OpImageSampleImplicitLod %v4float %30 %24 OpLine %6 12 4 %41 = OpImageSampleProjImplicitLod %v4float %30 %24 %32 = OpAccessChain %_ptr_Output_v4float %5 %int_0 OpStore %32 %31 OpReturn OpFunctionEnd)"; std::vector messages = { {SPV_MSG_WARNING, "test.hlsl", 2, 4, "Removing ImageSampleImplicitLod instruction because of incompatible " "execution model."}, {SPV_MSG_WARNING, "test.hlsl", 12, 4, "Removing ImageSampleProjImplicitLod instruction because of " "incompatible " "execution model."}}; SetMessageConsumer(GetTestMessageConsumer(messages)); auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ false); EXPECT_EQ(Pass::Status::SuccessWithChange, std::get<1>(result)); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/scalar_analysis.cpp000066400000000000000000001215131475742701700241710ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/scalar_analysis.h" #include #include #include "gmock/gmock.h" #include "source/opt/pass.h" #include "test/opt/assembly_builder.h" #include "test/opt/function_utils.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using ::testing::UnorderedElementsAre; using ScalarAnalysisTest = PassTest<::testing::Test>; /* Generated from the following GLSL + --eliminate-local-multi-store #version 410 core layout (location = 1) out float array[10]; void main() { for (int i = 0; i < 10; ++i) { array[i] = array[i+1]; } } */ TEST_F(ScalarAnalysisTest, BasicEvolutionTest) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %24 OpExecutionMode %4 OriginUpperLeft OpSource GLSL 410 OpName %4 "main" OpName %24 "array" OpDecorate %24 Location 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 10 %17 = OpTypeBool %19 = OpTypeFloat 32 %20 = OpTypeInt 32 0 %21 = OpConstant %20 10 %22 = OpTypeArray %19 %21 %23 = OpTypePointer Output %22 %24 = OpVariable %23 Output %27 = OpConstant %6 1 %29 = OpTypePointer Output %19 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %10 %10 = OpLabel %35 = OpPhi %6 %9 %5 %34 %13 OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %18 = OpSLessThan %17 %35 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %28 = OpIAdd %6 %35 %27 %30 = OpAccessChain %29 %24 %28 %31 = OpLoad %19 %30 %32 = OpAccessChain %29 %24 %35 OpStore %32 %31 OpBranch %13 %13 = OpLabel %34 = OpIAdd %6 %35 %27 OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 4); ScalarEvolutionAnalysis analysis{context.get()}; const Instruction* store = nullptr; const Instruction* load = nullptr; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 11)) { if (inst.opcode() == spv::Op::OpStore) { store = &inst; } if (inst.opcode() == spv::Op::OpLoad) { load = &inst; } } EXPECT_NE(load, nullptr); EXPECT_NE(store, nullptr); Instruction* access_chain = context->get_def_use_mgr()->GetDef(load->GetSingleWordInOperand(0)); Instruction* child = context->get_def_use_mgr()->GetDef( access_chain->GetSingleWordInOperand(1)); const SENode* node = analysis.AnalyzeInstruction(child); EXPECT_NE(node, nullptr); // Unsimplified node should have the form of ADD(REC(0,1), 1) EXPECT_EQ(node->GetType(), SENode::Add); const SENode* child_1 = node->GetChild(0); EXPECT_TRUE(child_1->GetType() == SENode::Constant || child_1->GetType() == SENode::RecurrentAddExpr); const SENode* child_2 = node->GetChild(1); EXPECT_TRUE(child_2->GetType() == SENode::Constant || child_2->GetType() == SENode::RecurrentAddExpr); SENode* simplified = analysis.SimplifyExpression(const_cast(node)); // Simplified should be in the form of REC(1,1) EXPECT_EQ(simplified->GetType(), SENode::RecurrentAddExpr); EXPECT_EQ(simplified->GetChild(0)->GetType(), SENode::Constant); EXPECT_EQ(simplified->GetChild(0)->AsSEConstantNode()->FoldToSingleValue(), 1); EXPECT_EQ(simplified->GetChild(1)->GetType(), SENode::Constant); EXPECT_EQ(simplified->GetChild(1)->AsSEConstantNode()->FoldToSingleValue(), 1); EXPECT_EQ(simplified->GetChild(0), simplified->GetChild(1)); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 410 core layout (location = 1) out float array[10]; layout (location = 2) flat in int loop_invariant; void main() { for (int i = 0; i < 10; ++i) { array[i] = array[i+loop_invariant]; } } */ TEST_F(ScalarAnalysisTest, LoadTest) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "array" OpName %4 "loop_invariant" OpDecorate %3 Location 1 OpDecorate %4 Flat OpDecorate %4 Location 2 %5 = OpTypeVoid %6 = OpTypeFunction %5 %7 = OpTypeInt 32 1 %8 = OpTypePointer Function %7 %9 = OpConstant %7 0 %10 = OpConstant %7 10 %11 = OpTypeBool %12 = OpTypeFloat 32 %13 = OpTypeInt 32 0 %14 = OpConstant %13 10 %15 = OpTypeArray %12 %14 %16 = OpTypePointer Output %15 %3 = OpVariable %16 Output %17 = OpTypePointer Input %7 %4 = OpVariable %17 Input %18 = OpTypePointer Output %12 %19 = OpConstant %7 1 %2 = OpFunction %5 None %6 %20 = OpLabel OpBranch %21 %21 = OpLabel %22 = OpPhi %7 %9 %20 %23 %24 OpLoopMerge %25 %24 None OpBranch %26 %26 = OpLabel %27 = OpSLessThan %11 %22 %10 OpBranchConditional %27 %28 %25 %28 = OpLabel %29 = OpLoad %7 %4 %30 = OpIAdd %7 %22 %29 %31 = OpAccessChain %18 %3 %30 %32 = OpLoad %12 %31 %33 = OpAccessChain %18 %3 %22 OpStore %33 %32 OpBranch %24 %24 = OpLabel %23 = OpIAdd %7 %22 %19 OpBranch %21 %25 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 2); ScalarEvolutionAnalysis analysis{context.get()}; const Instruction* load = nullptr; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 28)) { if (inst.opcode() == spv::Op::OpLoad) { load = &inst; } } EXPECT_NE(load, nullptr); Instruction* access_chain = context->get_def_use_mgr()->GetDef(load->GetSingleWordInOperand(0)); Instruction* child = context->get_def_use_mgr()->GetDef( access_chain->GetSingleWordInOperand(1)); // const SENode* node = // analysis.GetNodeFromInstruction(child->unique_id()); const SENode* node = analysis.AnalyzeInstruction(child); EXPECT_NE(node, nullptr); // Unsimplified node should have the form of ADD(REC(0,1), X) EXPECT_EQ(node->GetType(), SENode::Add); const SENode* child_1 = node->GetChild(0); EXPECT_TRUE(child_1->GetType() == SENode::ValueUnknown || child_1->GetType() == SENode::RecurrentAddExpr); const SENode* child_2 = node->GetChild(1); EXPECT_TRUE(child_2->GetType() == SENode::ValueUnknown || child_2->GetType() == SENode::RecurrentAddExpr); SENode* simplified = analysis.SimplifyExpression(const_cast(node)); EXPECT_EQ(simplified->GetType(), SENode::RecurrentAddExpr); const SERecurrentNode* rec = simplified->AsSERecurrentNode(); EXPECT_NE(rec->GetChild(0), rec->GetChild(1)); EXPECT_EQ(rec->GetOffset()->GetType(), SENode::ValueUnknown); EXPECT_EQ(rec->GetCoefficient()->GetType(), SENode::Constant); EXPECT_EQ(rec->GetCoefficient()->AsSEConstantNode()->FoldToSingleValue(), 1u); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 410 core layout (location = 1) out float array[10]; layout (location = 2) flat in int loop_invariant; void main() { array[0] = array[loop_invariant * 2 + 4 + 5 - 24 - loop_invariant - loop_invariant+ 16 * 3]; } */ TEST_F(ScalarAnalysisTest, SimplifySimple) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %3 "array" OpName %4 "loop_invariant" OpDecorate %3 Location 1 OpDecorate %4 Flat OpDecorate %4 Location 2 %5 = OpTypeVoid %6 = OpTypeFunction %5 %7 = OpTypeFloat 32 %8 = OpTypeInt 32 0 %9 = OpConstant %8 10 %10 = OpTypeArray %7 %9 %11 = OpTypePointer Output %10 %3 = OpVariable %11 Output %12 = OpTypeInt 32 1 %13 = OpConstant %12 0 %14 = OpTypePointer Input %12 %4 = OpVariable %14 Input %15 = OpConstant %12 2 %16 = OpConstant %12 4 %17 = OpConstant %12 5 %18 = OpConstant %12 24 %19 = OpConstant %12 48 %20 = OpTypePointer Output %7 %2 = OpFunction %5 None %6 %21 = OpLabel %22 = OpLoad %12 %4 %23 = OpIMul %12 %22 %15 %24 = OpIAdd %12 %23 %16 %25 = OpIAdd %12 %24 %17 %26 = OpISub %12 %25 %18 %28 = OpISub %12 %26 %22 %30 = OpISub %12 %28 %22 %31 = OpIAdd %12 %30 %19 %32 = OpAccessChain %20 %3 %31 %33 = OpLoad %7 %32 %34 = OpAccessChain %20 %3 %13 OpStore %34 %33 OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 2); ScalarEvolutionAnalysis analysis{context.get()}; const Instruction* load = nullptr; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 21)) { if (inst.opcode() == spv::Op::OpLoad && inst.result_id() == 33) { load = &inst; } } EXPECT_NE(load, nullptr); Instruction* access_chain = context->get_def_use_mgr()->GetDef(load->GetSingleWordInOperand(0)); Instruction* child = context->get_def_use_mgr()->GetDef( access_chain->GetSingleWordInOperand(1)); const SENode* node = analysis.AnalyzeInstruction(child); // Unsimplified is a very large graph with an add at the top. EXPECT_NE(node, nullptr); EXPECT_EQ(node->GetType(), SENode::Add); // Simplified node should resolve down to a constant expression as the loads // will eliminate themselves. SENode* simplified = analysis.SimplifyExpression(const_cast(node)); EXPECT_EQ(simplified->GetType(), SENode::Constant); EXPECT_EQ(simplified->AsSEConstantNode()->FoldToSingleValue(), 33u); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 410 core layout(location = 0) in vec4 c; layout (location = 1) out float array[10]; void main() { int N = int(c.x); for (int i = 0; i < 10; ++i) { array[i] = array[i]; array[i] = array[i-1]; array[i] = array[i+1]; array[i+1] = array[i+1]; array[i+N] = array[i+N]; array[i] = array[i+N]; } } */ TEST_F(ScalarAnalysisTest, Simplify) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %12 %33 OpExecutionMode %4 OriginUpperLeft OpSource GLSL 410 OpName %4 "main" OpName %8 "N" OpName %12 "c" OpName %19 "i" OpName %33 "array" OpDecorate %12 Location 0 OpDecorate %33 Location 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpTypeFloat 32 %10 = OpTypeVector %9 4 %11 = OpTypePointer Input %10 %12 = OpVariable %11 Input %13 = OpTypeInt 32 0 %14 = OpConstant %13 0 %15 = OpTypePointer Input %9 %20 = OpConstant %6 0 %27 = OpConstant %6 10 %28 = OpTypeBool %30 = OpConstant %13 10 %31 = OpTypeArray %9 %30 %32 = OpTypePointer Output %31 %33 = OpVariable %32 Output %36 = OpTypePointer Output %9 %42 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %19 = OpVariable %7 Function %16 = OpAccessChain %15 %12 %14 %17 = OpLoad %9 %16 %18 = OpConvertFToS %6 %17 OpStore %8 %18 OpStore %19 %20 OpBranch %21 %21 = OpLabel %78 = OpPhi %6 %20 %5 %77 %24 OpLoopMerge %23 %24 None OpBranch %25 %25 = OpLabel %29 = OpSLessThan %28 %78 %27 OpBranchConditional %29 %22 %23 %22 = OpLabel %37 = OpAccessChain %36 %33 %78 %38 = OpLoad %9 %37 %39 = OpAccessChain %36 %33 %78 OpStore %39 %38 %43 = OpISub %6 %78 %42 %44 = OpAccessChain %36 %33 %43 %45 = OpLoad %9 %44 %46 = OpAccessChain %36 %33 %78 OpStore %46 %45 %49 = OpIAdd %6 %78 %42 %50 = OpAccessChain %36 %33 %49 %51 = OpLoad %9 %50 %52 = OpAccessChain %36 %33 %78 OpStore %52 %51 %54 = OpIAdd %6 %78 %42 %56 = OpIAdd %6 %78 %42 %57 = OpAccessChain %36 %33 %56 %58 = OpLoad %9 %57 %59 = OpAccessChain %36 %33 %54 OpStore %59 %58 %62 = OpIAdd %6 %78 %18 %65 = OpIAdd %6 %78 %18 %66 = OpAccessChain %36 %33 %65 %67 = OpLoad %9 %66 %68 = OpAccessChain %36 %33 %62 OpStore %68 %67 %72 = OpIAdd %6 %78 %18 %73 = OpAccessChain %36 %33 %72 %74 = OpLoad %9 %73 %75 = OpAccessChain %36 %33 %78 OpStore %75 %74 OpBranch %24 %24 = OpLabel %77 = OpIAdd %6 %78 %42 OpStore %19 %77 OpBranch %21 %23 = OpLabel OpReturn OpFunctionEnd )"; // clang-format on std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 4); ScalarEvolutionAnalysis analysis{context.get()}; const Instruction* loads[6]; const Instruction* stores[6]; int load_count = 0; int store_count = 0; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 22)) { if (inst.opcode() == spv::Op::OpLoad) { loads[load_count] = &inst; ++load_count; } if (inst.opcode() == spv::Op::OpStore) { stores[store_count] = &inst; ++store_count; } } EXPECT_EQ(load_count, 6); EXPECT_EQ(store_count, 6); Instruction* load_access_chain; Instruction* store_access_chain; Instruction* load_child; Instruction* store_child; SENode* load_node; SENode* store_node; SENode* subtract_node; SENode* simplified_node; // Testing [i] - [i] == 0 load_access_chain = context->get_def_use_mgr()->GetDef(loads[0]->GetSingleWordInOperand(0)); store_access_chain = context->get_def_use_mgr()->GetDef(stores[0]->GetSingleWordInOperand(0)); load_child = context->get_def_use_mgr()->GetDef( load_access_chain->GetSingleWordInOperand(1)); store_child = context->get_def_use_mgr()->GetDef( store_access_chain->GetSingleWordInOperand(1)); load_node = analysis.AnalyzeInstruction(load_child); store_node = analysis.AnalyzeInstruction(store_child); subtract_node = analysis.CreateSubtraction(store_node, load_node); simplified_node = analysis.SimplifyExpression(subtract_node); EXPECT_EQ(simplified_node->GetType(), SENode::Constant); EXPECT_EQ(simplified_node->AsSEConstantNode()->FoldToSingleValue(), 0u); // Testing [i] - [i-1] == 1 load_access_chain = context->get_def_use_mgr()->GetDef(loads[1]->GetSingleWordInOperand(0)); store_access_chain = context->get_def_use_mgr()->GetDef(stores[1]->GetSingleWordInOperand(0)); load_child = context->get_def_use_mgr()->GetDef( load_access_chain->GetSingleWordInOperand(1)); store_child = context->get_def_use_mgr()->GetDef( store_access_chain->GetSingleWordInOperand(1)); load_node = analysis.AnalyzeInstruction(load_child); store_node = analysis.AnalyzeInstruction(store_child); subtract_node = analysis.CreateSubtraction(store_node, load_node); simplified_node = analysis.SimplifyExpression(subtract_node); EXPECT_EQ(simplified_node->GetType(), SENode::Constant); EXPECT_EQ(simplified_node->AsSEConstantNode()->FoldToSingleValue(), 1u); // Testing [i] - [i+1] == -1 load_access_chain = context->get_def_use_mgr()->GetDef(loads[2]->GetSingleWordInOperand(0)); store_access_chain = context->get_def_use_mgr()->GetDef(stores[2]->GetSingleWordInOperand(0)); load_child = context->get_def_use_mgr()->GetDef( load_access_chain->GetSingleWordInOperand(1)); store_child = context->get_def_use_mgr()->GetDef( store_access_chain->GetSingleWordInOperand(1)); load_node = analysis.AnalyzeInstruction(load_child); store_node = analysis.AnalyzeInstruction(store_child); subtract_node = analysis.CreateSubtraction(store_node, load_node); simplified_node = analysis.SimplifyExpression(subtract_node); EXPECT_EQ(simplified_node->GetType(), SENode::Constant); EXPECT_EQ(simplified_node->AsSEConstantNode()->FoldToSingleValue(), -1); // Testing [i+1] - [i+1] == 0 load_access_chain = context->get_def_use_mgr()->GetDef(loads[3]->GetSingleWordInOperand(0)); store_access_chain = context->get_def_use_mgr()->GetDef(stores[3]->GetSingleWordInOperand(0)); load_child = context->get_def_use_mgr()->GetDef( load_access_chain->GetSingleWordInOperand(1)); store_child = context->get_def_use_mgr()->GetDef( store_access_chain->GetSingleWordInOperand(1)); load_node = analysis.AnalyzeInstruction(load_child); store_node = analysis.AnalyzeInstruction(store_child); subtract_node = analysis.CreateSubtraction(store_node, load_node); simplified_node = analysis.SimplifyExpression(subtract_node); EXPECT_EQ(simplified_node->GetType(), SENode::Constant); EXPECT_EQ(simplified_node->AsSEConstantNode()->FoldToSingleValue(), 0u); // Testing [i+N] - [i+N] == 0 load_access_chain = context->get_def_use_mgr()->GetDef(loads[4]->GetSingleWordInOperand(0)); store_access_chain = context->get_def_use_mgr()->GetDef(stores[4]->GetSingleWordInOperand(0)); load_child = context->get_def_use_mgr()->GetDef( load_access_chain->GetSingleWordInOperand(1)); store_child = context->get_def_use_mgr()->GetDef( store_access_chain->GetSingleWordInOperand(1)); load_node = analysis.AnalyzeInstruction(load_child); store_node = analysis.AnalyzeInstruction(store_child); subtract_node = analysis.CreateSubtraction(store_node, load_node); simplified_node = analysis.SimplifyExpression(subtract_node); EXPECT_EQ(simplified_node->GetType(), SENode::Constant); EXPECT_EQ(simplified_node->AsSEConstantNode()->FoldToSingleValue(), 0u); // Testing [i] - [i+N] == -N load_access_chain = context->get_def_use_mgr()->GetDef(loads[5]->GetSingleWordInOperand(0)); store_access_chain = context->get_def_use_mgr()->GetDef(stores[5]->GetSingleWordInOperand(0)); load_child = context->get_def_use_mgr()->GetDef( load_access_chain->GetSingleWordInOperand(1)); store_child = context->get_def_use_mgr()->GetDef( store_access_chain->GetSingleWordInOperand(1)); load_node = analysis.AnalyzeInstruction(load_child); store_node = analysis.AnalyzeInstruction(store_child); subtract_node = analysis.CreateSubtraction(store_node, load_node); simplified_node = analysis.SimplifyExpression(subtract_node); EXPECT_EQ(simplified_node->GetType(), SENode::Negative); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 430 layout(location = 1) out float array[10]; layout(location = 2) flat in int loop_invariant; void main(void) { for (int i = 0; i < 10; ++i) { array[i * 2 + i * 5] = array[i * i * 2]; array[i * 2] = array[i * 5]; } } */ TEST_F(ScalarAnalysisTest, SimplifyMultiplyInductions) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %5 "i" OpName %3 "array" OpName %4 "loop_invariant" OpDecorate %3 Location 1 OpDecorate %4 Flat OpDecorate %4 Location 2 %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %10 = OpConstant %8 0 %11 = OpConstant %8 10 %12 = OpTypeBool %13 = OpTypeFloat 32 %14 = OpTypeInt 32 0 %15 = OpConstant %14 10 %16 = OpTypeArray %13 %15 %17 = OpTypePointer Output %16 %3 = OpVariable %17 Output %18 = OpConstant %8 2 %19 = OpConstant %8 5 %20 = OpTypePointer Output %13 %21 = OpConstant %8 1 %22 = OpTypePointer Input %8 %4 = OpVariable %22 Input %2 = OpFunction %6 None %7 %23 = OpLabel %5 = OpVariable %9 Function OpStore %5 %10 OpBranch %24 %24 = OpLabel %25 = OpPhi %8 %10 %23 %26 %27 OpLoopMerge %28 %27 None OpBranch %29 %29 = OpLabel %30 = OpSLessThan %12 %25 %11 OpBranchConditional %30 %31 %28 %31 = OpLabel %32 = OpIMul %8 %25 %18 %33 = OpIMul %8 %25 %19 %34 = OpIAdd %8 %32 %33 %35 = OpIMul %8 %25 %25 %36 = OpIMul %8 %35 %18 %37 = OpAccessChain %20 %3 %36 %38 = OpLoad %13 %37 %39 = OpAccessChain %20 %3 %34 OpStore %39 %38 %40 = OpIMul %8 %25 %18 %41 = OpIMul %8 %25 %19 %42 = OpAccessChain %20 %3 %41 %43 = OpLoad %13 %42 %44 = OpAccessChain %20 %3 %40 OpStore %44 %43 OpBranch %27 %27 = OpLabel %26 = OpIAdd %8 %25 %21 OpStore %5 %26 OpBranch %24 %28 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 2); ScalarEvolutionAnalysis analysis{context.get()}; const Instruction* loads[2] = {nullptr, nullptr}; const Instruction* stores[2] = {nullptr, nullptr}; int load_count = 0; int store_count = 0; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 31)) { if (inst.opcode() == spv::Op::OpLoad) { loads[load_count] = &inst; ++load_count; } if (inst.opcode() == spv::Op::OpStore) { stores[store_count] = &inst; ++store_count; } } EXPECT_EQ(load_count, 2); EXPECT_EQ(store_count, 2); Instruction* load_access_chain = context->get_def_use_mgr()->GetDef(loads[0]->GetSingleWordInOperand(0)); Instruction* store_access_chain = context->get_def_use_mgr()->GetDef(stores[0]->GetSingleWordInOperand(0)); Instruction* load_child = context->get_def_use_mgr()->GetDef( load_access_chain->GetSingleWordInOperand(1)); Instruction* store_child = context->get_def_use_mgr()->GetDef( store_access_chain->GetSingleWordInOperand(1)); SENode* store_node = analysis.AnalyzeInstruction(store_child); SENode* store_simplified = analysis.SimplifyExpression(store_node); load_access_chain = context->get_def_use_mgr()->GetDef(loads[1]->GetSingleWordInOperand(0)); store_access_chain = context->get_def_use_mgr()->GetDef(stores[1]->GetSingleWordInOperand(0)); load_child = context->get_def_use_mgr()->GetDef( load_access_chain->GetSingleWordInOperand(1)); store_child = context->get_def_use_mgr()->GetDef( store_access_chain->GetSingleWordInOperand(1)); SENode* second_store = analysis.SimplifyExpression(analysis.AnalyzeInstruction(store_child)); SENode* second_load = analysis.SimplifyExpression(analysis.AnalyzeInstruction(load_child)); SENode* combined_add = analysis.SimplifyExpression( analysis.CreateAddNode(second_load, second_store)); // We're checking that the two recurrent expression have been correctly // folded. In store_simplified they will have been folded as the entire // expression was simplified as one. In combined_add the two expressions have // been simplified one after the other which means the recurrent expressions // aren't exactly the same but should still be folded as they are with respect // to the same loop. EXPECT_EQ(combined_add, store_simplified); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 430 void main(void) { for (int i = 0; i < 10; --i) { array[i] = array[i]; } } */ TEST_F(ScalarAnalysisTest, SimplifyNegativeSteps) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %5 "i" OpName %3 "array" OpName %4 "loop_invariant" OpDecorate %3 Location 1 OpDecorate %4 Flat OpDecorate %4 Location 2 %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %10 = OpConstant %8 0 %11 = OpConstant %8 10 %12 = OpTypeBool %13 = OpTypeFloat 32 %14 = OpTypeInt 32 0 %15 = OpConstant %14 10 %16 = OpTypeArray %13 %15 %17 = OpTypePointer Output %16 %3 = OpVariable %17 Output %18 = OpTypePointer Output %13 %19 = OpConstant %8 1 %20 = OpTypePointer Input %8 %4 = OpVariable %20 Input %2 = OpFunction %6 None %7 %21 = OpLabel %5 = OpVariable %9 Function OpStore %5 %10 OpBranch %22 %22 = OpLabel %23 = OpPhi %8 %10 %21 %24 %25 OpLoopMerge %26 %25 None OpBranch %27 %27 = OpLabel %28 = OpSLessThan %12 %23 %11 OpBranchConditional %28 %29 %26 %29 = OpLabel %30 = OpAccessChain %18 %3 %23 %31 = OpLoad %13 %30 %32 = OpAccessChain %18 %3 %23 OpStore %32 %31 OpBranch %25 %25 = OpLabel %24 = OpISub %8 %23 %19 OpStore %5 %24 OpBranch %22 %26 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 2); ScalarEvolutionAnalysis analysis{context.get()}; const Instruction* loads[1] = {nullptr}; int load_count = 0; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 29)) { if (inst.opcode() == spv::Op::OpLoad) { loads[load_count] = &inst; ++load_count; } } EXPECT_EQ(load_count, 1); Instruction* load_access_chain = context->get_def_use_mgr()->GetDef(loads[0]->GetSingleWordInOperand(0)); Instruction* load_child = context->get_def_use_mgr()->GetDef( load_access_chain->GetSingleWordInOperand(1)); SENode* load_node = analysis.AnalyzeInstruction(load_child); EXPECT_TRUE(load_node); EXPECT_EQ(load_node->GetType(), SENode::RecurrentAddExpr); EXPECT_TRUE(load_node->AsSERecurrentNode()); SENode* child_1 = load_node->AsSERecurrentNode()->GetCoefficient(); SENode* child_2 = load_node->AsSERecurrentNode()->GetOffset(); EXPECT_EQ(child_1->GetType(), SENode::Constant); EXPECT_EQ(child_2->GetType(), SENode::Constant); EXPECT_EQ(child_1->AsSEConstantNode()->FoldToSingleValue(), -1); EXPECT_EQ(child_2->AsSEConstantNode()->FoldToSingleValue(), 0u); SERecurrentNode* load_simplified = analysis.SimplifyExpression(load_node)->AsSERecurrentNode(); EXPECT_TRUE(load_simplified); EXPECT_EQ(load_node, load_simplified); EXPECT_EQ(load_simplified->GetType(), SENode::RecurrentAddExpr); EXPECT_TRUE(load_simplified->AsSERecurrentNode()); SENode* simplified_child_1 = load_simplified->AsSERecurrentNode()->GetCoefficient(); SENode* simplified_child_2 = load_simplified->AsSERecurrentNode()->GetOffset(); EXPECT_EQ(child_1, simplified_child_1); EXPECT_EQ(child_2, simplified_child_2); } /* Generated from the following GLSL + --eliminate-local-multi-store #version 430 void main(void) { for (int i = 0; i < 10; --i) { array[i] = array[i]; } } */ TEST_F(ScalarAnalysisTest, SimplifyInductionsAndLoads) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %5 "i" OpName %3 "array" OpName %4 "N" OpDecorate %3 Location 1 OpDecorate %4 Flat OpDecorate %4 Location 2 %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %10 = OpConstant %8 0 %11 = OpConstant %8 10 %12 = OpTypeBool %13 = OpTypeFloat 32 %14 = OpTypeInt 32 0 %15 = OpConstant %14 10 %16 = OpTypeArray %13 %15 %17 = OpTypePointer Output %16 %3 = OpVariable %17 Output %18 = OpConstant %8 2 %19 = OpTypePointer Input %8 %4 = OpVariable %19 Input %20 = OpTypePointer Output %13 %21 = OpConstant %8 1 %2 = OpFunction %6 None %7 %22 = OpLabel %5 = OpVariable %9 Function OpStore %5 %10 OpBranch %23 %23 = OpLabel %24 = OpPhi %8 %10 %22 %25 %26 OpLoopMerge %27 %26 None OpBranch %28 %28 = OpLabel %29 = OpSLessThan %12 %24 %11 OpBranchConditional %29 %30 %27 %30 = OpLabel %31 = OpLoad %8 %4 %32 = OpIMul %8 %18 %31 %33 = OpIAdd %8 %24 %32 %35 = OpIAdd %8 %24 %31 %36 = OpAccessChain %20 %3 %35 %37 = OpLoad %13 %36 %38 = OpAccessChain %20 %3 %33 OpStore %38 %37 %39 = OpIMul %8 %18 %24 %41 = OpIMul %8 %18 %31 %42 = OpIAdd %8 %39 %41 %43 = OpIAdd %8 %42 %21 %44 = OpIMul %8 %18 %24 %46 = OpIAdd %8 %44 %31 %47 = OpIAdd %8 %46 %21 %48 = OpAccessChain %20 %3 %47 %49 = OpLoad %13 %48 %50 = OpAccessChain %20 %3 %43 OpStore %50 %49 OpBranch %26 %26 = OpLabel %25 = OpISub %8 %24 %21 OpStore %5 %25 OpBranch %23 %27 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 2); ScalarEvolutionAnalysis analysis{context.get()}; std::vector loads{}; std::vector stores{}; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 30)) { if (inst.opcode() == spv::Op::OpLoad) { loads.push_back(&inst); } if (inst.opcode() == spv::Op::OpStore) { stores.push_back(&inst); } } EXPECT_EQ(loads.size(), 3u); EXPECT_EQ(stores.size(), 2u); { Instruction* store_access_chain = context->get_def_use_mgr()->GetDef( stores[0]->GetSingleWordInOperand(0)); Instruction* store_child = context->get_def_use_mgr()->GetDef( store_access_chain->GetSingleWordInOperand(1)); SENode* store_node = analysis.AnalyzeInstruction(store_child); SENode* store_simplified = analysis.SimplifyExpression(store_node); Instruction* load_access_chain = context->get_def_use_mgr()->GetDef(loads[1]->GetSingleWordInOperand(0)); Instruction* load_child = context->get_def_use_mgr()->GetDef( load_access_chain->GetSingleWordInOperand(1)); SENode* load_node = analysis.AnalyzeInstruction(load_child); SENode* load_simplified = analysis.SimplifyExpression(load_node); SENode* difference = analysis.CreateSubtraction(store_simplified, load_simplified); SENode* difference_simplified = analysis.SimplifyExpression(difference); // Check that i+2*N - i*N, turns into just N when both sides have already // been simplified into a single recurrent expression. EXPECT_EQ(difference_simplified->GetType(), SENode::ValueUnknown); // Check that the inverse, i*N - i+2*N turns into -N. SENode* difference_inverse = analysis.SimplifyExpression( analysis.CreateSubtraction(load_simplified, store_simplified)); EXPECT_EQ(difference_inverse->GetType(), SENode::Negative); EXPECT_EQ(difference_inverse->GetChild(0)->GetType(), SENode::ValueUnknown); EXPECT_EQ(difference_inverse->GetChild(0), difference_simplified); } { Instruction* store_access_chain = context->get_def_use_mgr()->GetDef( stores[1]->GetSingleWordInOperand(0)); Instruction* store_child = context->get_def_use_mgr()->GetDef( store_access_chain->GetSingleWordInOperand(1)); SENode* store_node = analysis.AnalyzeInstruction(store_child); SENode* store_simplified = analysis.SimplifyExpression(store_node); Instruction* load_access_chain = context->get_def_use_mgr()->GetDef(loads[2]->GetSingleWordInOperand(0)); Instruction* load_child = context->get_def_use_mgr()->GetDef( load_access_chain->GetSingleWordInOperand(1)); SENode* load_node = analysis.AnalyzeInstruction(load_child); SENode* load_simplified = analysis.SimplifyExpression(load_node); SENode* difference = analysis.CreateSubtraction(store_simplified, load_simplified); SENode* difference_simplified = analysis.SimplifyExpression(difference); // Check that 2*i + 2*N + 1 - 2*i + N + 1, turns into just N when both // sides have already been simplified into a single recurrent expression. EXPECT_EQ(difference_simplified->GetType(), SENode::ValueUnknown); // Check that the inverse, (2*i + N + 1) - (2*i + 2*N + 1) turns into -N. SENode* difference_inverse = analysis.SimplifyExpression( analysis.CreateSubtraction(load_simplified, store_simplified)); EXPECT_EQ(difference_inverse->GetType(), SENode::Negative); EXPECT_EQ(difference_inverse->GetChild(0)->GetType(), SENode::ValueUnknown); EXPECT_EQ(difference_inverse->GetChild(0), difference_simplified); } } /* Generated from the following GLSL + --eliminate-local-multi-store #version 430 layout(location = 1) out float array[10]; layout(location = 2) flat in int N; void main(void) { int step = 0; for (int i = 0; i < N; i += step) { step++; } } */ TEST_F(ScalarAnalysisTest, InductionWithVariantStep) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpName %2 "main" OpName %5 "step" OpName %6 "i" OpName %3 "N" OpName %4 "array" OpDecorate %3 Flat OpDecorate %3 Location 2 OpDecorate %4 Location 1 %7 = OpTypeVoid %8 = OpTypeFunction %7 %9 = OpTypeInt 32 1 %10 = OpTypePointer Function %9 %11 = OpConstant %9 0 %12 = OpTypePointer Input %9 %3 = OpVariable %12 Input %13 = OpTypeBool %14 = OpConstant %9 1 %15 = OpTypeFloat 32 %16 = OpTypeInt 32 0 %17 = OpConstant %16 10 %18 = OpTypeArray %15 %17 %19 = OpTypePointer Output %18 %4 = OpVariable %19 Output %2 = OpFunction %7 None %8 %20 = OpLabel %5 = OpVariable %10 Function %6 = OpVariable %10 Function OpStore %5 %11 OpStore %6 %11 OpBranch %21 %21 = OpLabel %22 = OpPhi %9 %11 %20 %23 %24 %25 = OpPhi %9 %11 %20 %26 %24 OpLoopMerge %27 %24 None OpBranch %28 %28 = OpLabel %29 = OpLoad %9 %3 %30 = OpSLessThan %13 %25 %29 OpBranchConditional %30 %31 %27 %31 = OpLabel %23 = OpIAdd %9 %22 %14 OpStore %5 %23 OpBranch %24 %24 = OpLabel %26 = OpIAdd %9 %25 %23 OpStore %6 %26 OpBranch %21 %27 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); Module* module = context->module(); EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n" << text << std::endl; const Function* f = spvtest::GetFunction(module, 2); ScalarEvolutionAnalysis analysis{context.get()}; std::vector phis{}; for (const Instruction& inst : *spvtest::GetBasicBlock(f, 21)) { if (inst.opcode() == spv::Op::OpPhi) { phis.push_back(&inst); } } EXPECT_EQ(phis.size(), 2u); SENode* phi_node_1 = analysis.AnalyzeInstruction(phis[0]); SENode* phi_node_2 = analysis.AnalyzeInstruction(phis[1]); EXPECT_NE(phi_node_1, nullptr); EXPECT_NE(phi_node_2, nullptr); EXPECT_EQ(phi_node_1->GetType(), SENode::RecurrentAddExpr); EXPECT_EQ(phi_node_2->GetType(), SENode::CanNotCompute); SENode* simplified_1 = analysis.SimplifyExpression(phi_node_1); SENode* simplified_2 = analysis.SimplifyExpression(phi_node_2); EXPECT_EQ(simplified_1->GetType(), SENode::RecurrentAddExpr); EXPECT_EQ(simplified_2->GetType(), SENode::CanNotCompute); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/scalar_replacement_test.cpp000066400000000000000000002310101475742701700256760ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "source/opt/scalar_replacement_pass.h" #include "test/opt/assembly_builder.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using ScalarReplacementPassName = ::testing::Test; TEST_F(ScalarReplacementPassName, Default) { auto srp = ScalarReplacementPass(); EXPECT_STREQ(srp.name(), "scalar-replacement=100"); } TEST_F(ScalarReplacementPassName, Large) { auto srp = ScalarReplacementPass(0xffffffffu); EXPECT_STREQ(srp.name(), "scalar-replacement=4294967295"); } using ScalarReplacementTest = PassTest<::testing::Test>; TEST_F(ScalarReplacementTest, SimpleStruct) { const std::string text = R"( ; ; CHECK: [[struct:%\w+]] = OpTypeStruct [[elem:%\w+]] ; CHECK: [[struct_ptr:%\w+]] = OpTypePointer Function [[struct]] ; CHECK: [[elem_ptr:%\w+]] = OpTypePointer Function [[elem]] ; CHECK: OpConstantNull [[struct]] ; CHECK: [[null:%\w+]] = OpConstantNull [[elem]] ; CHECK-NOT: OpVariable [[struct_ptr]] ; CHECK: [[one:%\w+]] = OpVariable [[elem_ptr]] Function [[null]] ; CHECK-NEXT: [[two:%\w+]] = OpVariable [[elem_ptr]] Function [[null]] ; CHECK-NOT: OpVariable [[elem_ptr]] Function [[null]] ; CHECK-NOT: OpVariable [[struct_ptr]] ; CHECK-NOT: OpInBoundsAccessChain ; CHECK: [[l1:%\w+]] = OpLoad [[elem]] [[two]] ; CHECK-NOT: OpAccessChain ; CHECK: [[l2:%\w+]] = OpLoad [[elem]] [[one]] ; CHECK: OpIAdd [[elem]] [[l1]] [[l2]] ; OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %6 "simple_struct" %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypeStruct %2 %2 %2 %2 %4 = OpTypePointer Function %3 %5 = OpTypePointer Function %2 %6 = OpTypeFunction %2 %7 = OpConstantNull %3 %8 = OpConstant %2 0 %9 = OpConstant %2 1 %10 = OpConstant %2 2 %11 = OpConstant %2 3 %12 = OpFunction %2 None %6 %13 = OpLabel %14 = OpVariable %4 Function %7 %15 = OpInBoundsAccessChain %5 %14 %8 %16 = OpLoad %2 %15 %17 = OpAccessChain %5 %14 %10 %18 = OpLoad %2 %17 %19 = OpIAdd %2 %16 %18 OpReturnValue %19 OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ScalarReplacementTest, StructInitialization) { const std::string text = R"( ; ; CHECK: [[elem:%\w+]] = OpTypeInt 32 0 ; CHECK: [[struct:%\w+]] = OpTypeStruct [[elem]] [[elem]] [[elem]] [[elem]] ; CHECK: [[struct_ptr:%\w+]] = OpTypePointer Function [[struct]] ; CHECK: [[elem_ptr:%\w+]] = OpTypePointer Function [[elem]] ; CHECK: [[zero:%\w+]] = OpConstant [[elem]] 0 ; CHECK: [[undef:%\w+]] = OpUndef [[elem]] ; CHECK: [[two:%\w+]] = OpConstant [[elem]] 2 ; CHECK: [[null:%\w+]] = OpConstantNull [[elem]] ; CHECK-NOT: OpVariable [[struct_ptr]] ; CHECK: OpVariable [[elem_ptr]] Function [[null]] ; CHECK-NEXT: OpVariable [[elem_ptr]] Function [[two]] ; CHECK-NOT: OpVariable [[elem_ptr]] Function [[undef]] ; CHECK-NEXT: OpVariable [[elem_ptr]] Function ; CHECK-NEXT: OpVariable [[elem_ptr]] Function [[zero]] ; CHECK-NOT: OpVariable [[elem_ptr]] Function [[undef]] ; OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %6 "struct_init" %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypeStruct %2 %2 %2 %2 %4 = OpTypePointer Function %3 %20 = OpTypePointer Function %2 %6 = OpTypeFunction %1 %7 = OpConstant %2 0 %8 = OpUndef %2 %9 = OpConstant %2 2 %30 = OpConstant %2 1 %31 = OpConstant %2 3 %10 = OpConstantNull %2 %11 = OpConstantComposite %3 %7 %8 %9 %10 %12 = OpFunction %1 None %6 %13 = OpLabel %14 = OpVariable %4 Function %11 %15 = OpAccessChain %20 %14 %7 OpStore %15 %10 %16 = OpAccessChain %20 %14 %9 OpStore %16 %10 %17 = OpAccessChain %20 %14 %30 OpStore %17 %10 %18 = OpAccessChain %20 %14 %31 OpStore %18 %10 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ScalarReplacementTest, SpecConstantInitialization) { const std::string text = R"( ; ; CHECK: [[int:%\w+]] = OpTypeInt 32 0 ; CHECK: [[struct:%\w+]] = OpTypeStruct [[int]] [[int]] ; CHECK: [[struct_ptr:%\w+]] = OpTypePointer Function [[struct]] ; CHECK: [[int_ptr:%\w+]] = OpTypePointer Function [[int]] ; CHECK: [[spec_comp:%\w+]] = OpSpecConstantComposite [[struct]] ; CHECK: [[ex0:%\w+]] = OpSpecConstantOp [[int]] CompositeExtract [[spec_comp]] 0 ; CHECK: [[ex1:%\w+]] = OpSpecConstantOp [[int]] CompositeExtract [[spec_comp]] 1 ; CHECK-NOT: OpVariable [[struct]] ; CHECK: OpVariable [[int_ptr]] Function [[ex1]] ; CHECK-NEXT: OpVariable [[int_ptr]] Function [[ex0]] ; CHECK-NOT: OpVariable [[struct]] ; OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %6 "spec_const" %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypeStruct %2 %2 %4 = OpTypePointer Function %3 %20 = OpTypePointer Function %2 %5 = OpTypeFunction %1 %6 = OpConstant %2 0 %30 = OpConstant %2 1 %7 = OpSpecConstant %2 0 %8 = OpSpecConstantOp %2 IAdd %7 %7 %9 = OpSpecConstantComposite %3 %7 %8 %10 = OpFunction %1 None %5 %11 = OpLabel %12 = OpVariable %4 Function %9 %13 = OpAccessChain %20 %12 %6 %14 = OpLoad %2 %13 %15 = OpAccessChain %20 %12 %30 %16 = OpLoad %2 %15 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } // TODO(alanbaker): Re-enable when vector and matrix scalarization is supported. // TEST_F(ScalarReplacementTest, VectorInitialization) { // const std::string text = R"( // ; // ; CHECK: [[elem:%\w+]] = OpTypeInt 32 0 // ; CHECK: [[vector:%\w+]] = OpTypeVector [[elem]] 4 // ; CHECK: [[vector_ptr:%\w+]] = OpTypePointer Function [[vector]] // ; CHECK: [[elem_ptr:%\w+]] = OpTypePointer Function [[elem]] // ; CHECK: [[zero:%\w+]] = OpConstant [[elem]] 0 // ; CHECK: [[undef:%\w+]] = OpUndef [[elem]] // ; CHECK: [[two:%\w+]] = OpConstant [[elem]] 2 // ; CHECK: [[null:%\w+]] = OpConstantNull [[elem]] // ; CHECK-NOT: OpVariable [[vector_ptr]] // ; CHECK: OpVariable [[elem_ptr]] Function [[zero]] // ; CHECK-NOT: OpVariable [[elem_ptr]] Function [[undef]] // ; CHECK-NEXT: OpVariable [[elem_ptr]] Function // ; CHECK-NEXT: OpVariable [[elem_ptr]] Function [[two]] // ; CHECK-NEXT: OpVariable [[elem_ptr]] Function [[null]] // ; CHECK-NOT: OpVariable [[elem_ptr]] Function [[undef]] // ; // OpCapability Shader // OpCapability Linkage // OpMemoryModel Logical GLSL450 // OpName %6 "vector_init" // %1 = OpTypeVoid // %2 = OpTypeInt 32 0 // %3 = OpTypeVector %2 4 // %4 = OpTypePointer Function %3 // %20 = OpTypePointer Function %2 // %6 = OpTypeFunction %1 // %7 = OpConstant %2 0 // %8 = OpUndef %2 // %9 = OpConstant %2 2 // %30 = OpConstant %2 1 // %31 = OpConstant %2 3 // %10 = OpConstantNull %2 // %11 = OpConstantComposite %3 %10 %9 %8 %7 // %12 = OpFunction %1 None %6 // %13 = OpLabel // %14 = OpVariable %4 Function %11 // %15 = OpAccessChain %20 %14 %7 // OpStore %15 %10 // %16 = OpAccessChain %20 %14 %9 // OpStore %16 %10 // %17 = OpAccessChain %20 %14 %30 // OpStore %17 %10 // %18 = OpAccessChain %20 %14 %31 // OpStore %18 %10 // OpReturn // OpFunctionEnd // )"; // // SinglePassRunAndMatch(text, true); // } // // TEST_F(ScalarReplacementTest, MatrixInitialization) { // const std::string text = R"( // ; // ; CHECK: [[float:%\w+]] = OpTypeFloat 32 // ; CHECK: [[vector:%\w+]] = OpTypeVector [[float]] 2 // ; CHECK: [[matrix:%\w+]] = OpTypeMatrix [[vector]] 2 // ; CHECK: [[matrix_ptr:%\w+]] = OpTypePointer Function [[matrix]] // ; CHECK: [[float_ptr:%\w+]] = OpTypePointer Function [[float]] // ; CHECK: [[vec_ptr:%\w+]] = OpTypePointer Function [[vector]] // ; CHECK: [[zerof:%\w+]] = OpConstant [[float]] 0 // ; CHECK: [[onef:%\w+]] = OpConstant [[float]] 1 // ; CHECK: [[one_zero:%\w+]] = OpConstantComposite [[vector]] [[onef]] // [[zerof]] ; CHECK: [[zero_one:%\w+]] = OpConstantComposite [[vector]] // [[zerof]] [[onef]] ; CHECK: [[const_mat:%\w+]] = OpConstantComposite // [[matrix]] [[one_zero]] // [[zero_one]] ; CHECK-NOT: OpVariable [[matrix]] ; CHECK-NOT: OpVariable // [[vector]] Function [[one_zero]] ; CHECK: [[f1:%\w+]] = OpVariable // [[float_ptr]] Function [[zerof]] ; CHECK-NEXT: [[f2:%\w+]] = OpVariable // [[float_ptr]] Function [[onef]] ; CHECK-NEXT: [[vec_var:%\w+]] = OpVariable // [[vec_ptr]] Function [[zero_one]] ; CHECK-NOT: OpVariable [[matrix]] ; // CHECK-NOT: OpVariable [[vector]] Function [[one_zero]] // ; // OpCapability Shader // OpCapability Linkage // OpMemoryModel Logical GLSL450 // OpName %7 "matrix_init" // %1 = OpTypeVoid // %2 = OpTypeFloat 32 // %3 = OpTypeVector %2 2 // %4 = OpTypeMatrix %3 2 // %5 = OpTypePointer Function %4 // %6 = OpTypePointer Function %2 // %30 = OpTypePointer Function %3 // %10 = OpTypeInt 32 0 // %7 = OpTypeFunction %1 %10 // %8 = OpConstant %2 0.0 // %9 = OpConstant %2 1.0 // %11 = OpConstant %10 0 // %12 = OpConstant %10 1 // %13 = OpConstantComposite %3 %9 %8 // %14 = OpConstantComposite %3 %8 %9 // %15 = OpConstantComposite %4 %13 %14 // %16 = OpFunction %1 None %7 // %31 = OpFunctionParameter %10 // %17 = OpLabel // %18 = OpVariable %5 Function %15 // %19 = OpAccessChain %6 %18 %11 %12 // OpStore %19 %8 // %20 = OpAccessChain %6 %18 %11 %11 // OpStore %20 %8 // %21 = OpAccessChain %30 %18 %12 // OpStore %21 %14 // OpReturn // OpFunctionEnd // )"; // // SinglePassRunAndMatch(text, true); // } TEST_F(ScalarReplacementTest, ElideAccessChain) { const std::string text = R"( ; ; CHECK: [[var:%\w+]] = OpVariable ; CHECK-NOT: OpAccessChain ; CHECK: OpStore [[var]] ; OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %6 "elide_access_chain" %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypeStruct %2 %2 %2 %2 %4 = OpTypePointer Function %3 %20 = OpTypePointer Function %2 %6 = OpTypeFunction %1 %7 = OpConstant %2 0 %8 = OpUndef %2 %9 = OpConstant %2 2 %10 = OpConstantNull %2 %11 = OpConstantComposite %3 %7 %8 %9 %10 %12 = OpFunction %1 None %6 %13 = OpLabel %14 = OpVariable %4 Function %11 %15 = OpAccessChain %20 %14 %7 OpStore %15 %10 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ScalarReplacementTest, ElideMultipleAccessChains) { const std::string text = R"( ; ; CHECK: [[var:%\w+]] = OpVariable ; CHECK-NOT: OpInBoundsAccessChain ; CHECK OpStore [[var]] ; OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %6 "elide_two_access_chains" %1 = OpTypeVoid %2 = OpTypeFloat 32 %3 = OpTypeStruct %2 %2 %4 = OpTypeStruct %3 %3 %5 = OpTypePointer Function %4 %6 = OpTypePointer Function %2 %7 = OpTypeFunction %1 %8 = OpConstant %2 0.0 %9 = OpConstant %2 1.0 %10 = OpTypeInt 32 0 %11 = OpConstant %10 0 %12 = OpConstant %10 1 %13 = OpConstantComposite %3 %9 %8 %14 = OpConstantComposite %3 %8 %9 %15 = OpConstantComposite %4 %13 %14 %16 = OpFunction %1 None %7 %17 = OpLabel %18 = OpVariable %5 Function %15 %19 = OpInBoundsAccessChain %6 %18 %11 %12 OpStore %19 %8 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ScalarReplacementTest, ReplaceAccessChain) { const std::string text = R"( ; ; CHECK: [[param:%\w+]] = OpFunctionParameter ; CHECK: [[var:%\w+]] = OpVariable ; CHECK: [[access:%\w+]] = OpAccessChain {{%\w+}} [[var]] [[param]] ; CHECK: OpStore [[access]] ; OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %7 "replace_access_chain" %1 = OpTypeVoid %2 = OpTypeFloat 32 %10 = OpTypeInt 32 0 %uint_2 = OpConstant %10 2 %3 = OpTypeArray %2 %uint_2 %4 = OpTypeStruct %3 %3 %5 = OpTypePointer Function %4 %20 = OpTypePointer Function %3 %6 = OpTypePointer Function %2 %7 = OpTypeFunction %1 %10 %8 = OpConstant %2 0.0 %9 = OpConstant %2 1.0 %11 = OpConstant %10 0 %12 = OpConstant %10 1 %13 = OpConstantComposite %3 %9 %8 %14 = OpConstantComposite %3 %8 %9 %15 = OpConstantComposite %4 %13 %14 %16 = OpFunction %1 None %7 %32 = OpFunctionParameter %10 %17 = OpLabel %18 = OpVariable %5 Function %15 %19 = OpAccessChain %6 %18 %11 %32 OpStore %19 %8 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ScalarReplacementTest, ArrayInitialization) { const std::string text = R"( ; ; CHECK: [[float:%\w+]] = OpTypeFloat 32 ; CHECK: [[array:%\w+]] = OpTypeArray ; CHECK: [[array_ptr:%\w+]] = OpTypePointer Function [[array]] ; CHECK: [[float_ptr:%\w+]] = OpTypePointer Function [[float]] ; CHECK: [[float0:%\w+]] = OpConstant [[float]] 0 ; CHECK: [[float1:%\w+]] = OpConstant [[float]] 1 ; CHECK: [[float2:%\w+]] = OpConstant [[float]] 2 ; CHECK-NOT: OpVariable [[array_ptr]] ; CHECK: [[var0:%\w+]] = OpVariable [[float_ptr]] Function [[float0]] ; CHECK-NEXT: [[var1:%\w+]] = OpVariable [[float_ptr]] Function [[float1]] ; CHECK-NEXT: [[var2:%\w+]] = OpVariable [[float_ptr]] Function [[float2]] ; CHECK-NOT: OpVariable [[array_ptr]] ; OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %func "array_init" %void = OpTypeVoid %uint = OpTypeInt 32 0 %float = OpTypeFloat 32 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %uint_3 = OpConstant %uint 3 %float_array = OpTypeArray %float %uint_3 %array_ptr = OpTypePointer Function %float_array %float_ptr = OpTypePointer Function %float %float_0 = OpConstant %float 0 %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %const_array = OpConstantComposite %float_array %float_2 %float_1 %float_0 %func = OpTypeFunction %void %1 = OpFunction %void None %func %2 = OpLabel %3 = OpVariable %array_ptr Function %const_array %4 = OpInBoundsAccessChain %float_ptr %3 %uint_0 OpStore %4 %float_0 %5 = OpInBoundsAccessChain %float_ptr %3 %uint_1 OpStore %5 %float_0 %6 = OpInBoundsAccessChain %float_ptr %3 %uint_2 OpStore %6 %float_0 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ScalarReplacementTest, NonUniformCompositeInitialization) { const std::string text = R"( ; ; CHECK: [[uint:%\w+]] = OpTypeInt 32 0 ; CHECK: [[long:%\w+]] = OpTypeInt 64 1 ; CHECK: [[dvector:%\w+]] = OpTypeVector ; CHECK: [[vector:%\w+]] = OpTypeVector ; CHECK: [[array:%\w+]] = OpTypeArray ; CHECK: [[matrix:%\w+]] = OpTypeMatrix ; CHECK: [[struct1:%\w+]] = OpTypeStruct [[uint]] [[vector]] ; CHECK: [[struct2:%\w+]] = OpTypeStruct [[struct1]] [[matrix]] [[array]] [[uint]] ; CHECK: [[struct1_ptr:%\w+]] = OpTypePointer Function [[struct1]] ; CHECK: [[matrix_ptr:%\w+]] = OpTypePointer Function [[matrix]] ; CHECK: [[array_ptr:%\w+]] = OpTypePointer Function [[array]] ; CHECK: [[uint_ptr:%\w+]] = OpTypePointer Function [[uint]] ; CHECK: [[struct2_ptr:%\w+]] = OpTypePointer Function [[struct2]] ; CHECK: [[const_array:%\w+]] = OpConstantComposite [[array]] ; CHECK: [[const_matrix:%\w+]] = OpConstantNull [[matrix]] ; CHECK: [[const_struct1:%\w+]] = OpConstantComposite [[struct1]] ; CHECK: OpUndef [[uint]] ; CHECK: OpUndef [[vector]] ; CHECK: OpUndef [[long]] ; CHECK: OpFunction ; CHECK-NOT: OpVariable [[struct2_ptr]] Function ; CHECK: OpVariable [[uint_ptr]] Function ; CHECK-NEXT: OpVariable [[matrix_ptr]] Function [[const_matrix]] ; CHECK-NOT: OpVariable [[struct1_ptr]] Function [[const_struct1]] ; CHECK-NOT: OpVariable [[struct2_ptr]] Function ; OpCapability Shader OpCapability Linkage OpCapability Int64 OpCapability Float64 OpMemoryModel Logical GLSL450 OpName %func "non_uniform_composite_init" %void = OpTypeVoid %uint = OpTypeInt 32 0 %int64 = OpTypeInt 64 1 %float = OpTypeFloat 32 %double = OpTypeFloat 64 %double2 = OpTypeVector %double 2 %float4 = OpTypeVector %float 4 %int64_0 = OpConstant %int64 0 %int64_1 = OpConstant %int64 1 %int64_2 = OpConstant %int64 2 %int64_3 = OpConstant %int64 3 %int64_array3 = OpTypeArray %int64 %int64_3 %matrix_double2 = OpTypeMatrix %double2 2 %struct1 = OpTypeStruct %uint %float4 %struct2 = OpTypeStruct %struct1 %matrix_double2 %int64_array3 %uint %struct1_ptr = OpTypePointer Function %struct1 %matrix_double2_ptr = OpTypePointer Function %matrix_double2 %int64_array_ptr = OpTypePointer Function %int64_array3 %uint_ptr = OpTypePointer Function %uint %struct2_ptr = OpTypePointer Function %struct2 %const_uint = OpConstant %uint 0 %const_int64_array = OpConstantComposite %int64_array3 %int64_0 %int64_1 %int64_2 %const_double2 = OpConstantNull %double2 %const_matrix_double2 = OpConstantNull %matrix_double2 %undef_float4 = OpUndef %float4 %const_struct1 = OpConstantComposite %struct1 %const_uint %undef_float4 %const_struct2 = OpConstantComposite %struct2 %const_struct1 %const_matrix_double2 %const_int64_array %const_uint %func = OpTypeFunction %void %1 = OpFunction %void None %func %2 = OpLabel %var = OpVariable %struct2_ptr Function %const_struct2 %3 = OpAccessChain %struct1_ptr %var %int64_0 OpStore %3 %const_struct1 %4 = OpAccessChain %matrix_double2_ptr %var %int64_1 OpStore %4 %const_matrix_double2 %5 = OpAccessChain %int64_array_ptr %var %int64_2 OpStore %5 %const_int64_array %6 = OpAccessChain %uint_ptr %var %int64_3 OpStore %6 %const_uint OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ScalarReplacementTest, ElideUncombinedAccessChains) { const std::string text = R"( ; ; CHECK: [[uint:%\w+]] = OpTypeInt 32 0 ; CHECK: [[uint_ptr:%\w+]] = OpTypePointer Function [[uint]] ; CHECK: [[const:%\w+]] = OpConstant [[uint]] 0 ; CHECK: [[var:%\w+]] = OpVariable [[uint_ptr]] Function ; CHECK-NOT: OpAccessChain ; CHECK: OpStore [[var]] [[const]] ; OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %func "elide_uncombined_access_chains" %void = OpTypeVoid %uint = OpTypeInt 32 0 %struct1 = OpTypeStruct %uint %struct2 = OpTypeStruct %struct1 %uint_ptr = OpTypePointer Function %uint %struct1_ptr = OpTypePointer Function %struct1 %struct2_ptr = OpTypePointer Function %struct2 %uint_0 = OpConstant %uint 0 %func = OpTypeFunction %void %1 = OpFunction %void None %func %2 = OpLabel %var = OpVariable %struct2_ptr Function %3 = OpAccessChain %struct1_ptr %var %uint_0 %4 = OpAccessChain %uint_ptr %3 %uint_0 OpStore %4 %uint_0 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ScalarReplacementTest, ElideSingleUncombinedAccessChains) { const std::string text = R"( ; ; CHECK: [[uint:%\w+]] = OpTypeInt 32 0 ; CHECK: [[array:%\w+]] = OpTypeArray [[uint]] ; CHECK: [[array_ptr:%\w+]] = OpTypePointer Function [[array]] ; CHECK: [[const:%\w+]] = OpConstant [[uint]] 0 ; CHECK: [[param:%\w+]] = OpFunctionParameter [[uint]] ; CHECK: [[var:%\w+]] = OpVariable [[array_ptr]] Function ; CHECK: [[access:%\w+]] = OpAccessChain {{.*}} [[var]] [[param]] ; CHECK: OpStore [[access]] [[const]] ; OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %func "elide_single_uncombined_access_chains" %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %array = OpTypeArray %uint %uint_1 %struct2 = OpTypeStruct %array %uint_ptr = OpTypePointer Function %uint %array_ptr = OpTypePointer Function %array %struct2_ptr = OpTypePointer Function %struct2 %uint_0 = OpConstant %uint 0 %func = OpTypeFunction %void %uint %1 = OpFunction %void None %func %param = OpFunctionParameter %uint %2 = OpLabel %var = OpVariable %struct2_ptr Function %3 = OpAccessChain %array_ptr %var %uint_0 %4 = OpAccessChain %uint_ptr %3 %param OpStore %4 %uint_0 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ScalarReplacementTest, ReplaceWholeLoad) { const std::string text = R"( ; ; CHECK: [[uint:%\w+]] = OpTypeInt 32 0 ; CHECK: [[struct1:%\w+]] = OpTypeStruct [[uint]] [[uint]] ; CHECK: [[uint_ptr:%\w+]] = OpTypePointer Function [[uint]] ; CHECK: [[const:%\w+]] = OpConstant [[uint]] 0 ; CHECK: [[var1:%\w+]] = OpVariable [[uint_ptr]] Function ; CHECK: [[var0:%\w+]] = OpVariable [[uint_ptr]] Function ; CHECK: [[l1:%\w+]] = OpLoad [[uint]] [[var1]] ; CHECK: [[l0:%\w+]] = OpLoad [[uint]] [[var0]] ; CHECK: OpCompositeConstruct [[struct1]] [[l0]] [[l1]] ; OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %func "replace_whole_load" %void = OpTypeVoid %uint = OpTypeInt 32 0 %struct1 = OpTypeStruct %uint %uint %uint_ptr = OpTypePointer Function %uint %struct1_ptr = OpTypePointer Function %struct1 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %func = OpTypeFunction %void %1 = OpFunction %void None %func %2 = OpLabel %var = OpVariable %struct1_ptr Function %load = OpLoad %struct1 %var %3 = OpAccessChain %uint_ptr %var %uint_0 OpStore %3 %uint_0 %4 = OpAccessChain %uint_ptr %var %uint_1 OpStore %4 %uint_0 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ScalarReplacementTest, ReplaceWholeLoadCopyMemoryAccess) { const std::string text = R"( ; ; CHECK: [[uint:%\w+]] = OpTypeInt 32 0 ; CHECK: [[struct1:%\w+]] = OpTypeStruct [[uint]] [[uint]] ; CHECK: [[uint_ptr:%\w+]] = OpTypePointer Function [[uint]] ; CHECK: [[undef:%\w+]] = OpUndef [[uint]] ; CHECK: [[var0:%\w+]] = OpVariable [[uint_ptr]] Function ; CHECK: [[l0:%\w+]] = OpLoad [[uint]] [[var0]] Nontemporal ; CHECK: OpCompositeConstruct [[struct1]] [[l0]] [[undef]] ; OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %func "replace_whole_load_copy_memory_access" %void = OpTypeVoid %uint = OpTypeInt 32 0 %struct1 = OpTypeStruct %uint %uint %uint_ptr = OpTypePointer Function %uint %struct1_ptr = OpTypePointer Function %struct1 %uint_0 = OpConstant %uint 0 %func = OpTypeFunction %void %1 = OpFunction %void None %func %2 = OpLabel %var = OpVariable %struct1_ptr Function %load = OpLoad %struct1 %var Nontemporal %3 = OpAccessChain %uint_ptr %var %uint_0 OpStore %3 %uint_0 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ScalarReplacementTest, ReplaceWholeStore) { const std::string text = R"( ; ; CHECK: [[uint:%\w+]] = OpTypeInt 32 0 ; CHECK: [[struct1:%\w+]] = OpTypeStruct [[uint]] [[uint]] ; CHECK: [[uint_ptr:%\w+]] = OpTypePointer Function [[uint]] ; CHECK: [[const:%\w+]] = OpConstant [[uint]] 0 ; CHECK: [[const_struct:%\w+]] = OpConstantComposite [[struct1]] [[const]] [[const]] ; CHECK: [[var0:%\w+]] = OpVariable [[uint_ptr]] Function ; CHECK: [[ex0:%\w+]] = OpCompositeExtract [[uint]] [[const_struct]] 0 ; CHECK: OpStore [[var0]] [[ex0]] ; OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %func "replace_whole_store" %void = OpTypeVoid %uint = OpTypeInt 32 0 %struct1 = OpTypeStruct %uint %uint %uint_ptr = OpTypePointer Function %uint %struct1_ptr = OpTypePointer Function %struct1 %uint_0 = OpConstant %uint 0 %const_struct = OpConstantComposite %struct1 %uint_0 %uint_0 %func = OpTypeFunction %void %1 = OpFunction %void None %func %2 = OpLabel %var = OpVariable %struct1_ptr Function OpStore %var %const_struct %3 = OpAccessChain %uint_ptr %var %uint_0 %4 = OpLoad %uint %3 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ScalarReplacementTest, ReplaceWholeStoreCopyMemoryAccess) { const std::string text = R"( ; ; CHECK: [[uint:%\w+]] = OpTypeInt 32 0 ; CHECK: [[struct1:%\w+]] = OpTypeStruct [[uint]] [[uint]] ; CHECK: [[uint_ptr:%\w+]] = OpTypePointer Function [[uint]] ; CHECK: [[const:%\w+]] = OpConstant [[uint]] 0 ; CHECK: [[const_struct:%\w+]] = OpConstantComposite [[struct1]] [[const]] [[const]] ; CHECK: [[var0:%\w+]] = OpVariable [[uint_ptr]] Function ; CHECK-NOT: OpVariable ; CHECK: [[ex0:%\w+]] = OpCompositeExtract [[uint]] [[const_struct]] 0 ; CHECK: OpStore [[var0]] [[ex0]] Aligned 4 ; OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %func "replace_whole_store_copy_memory_access" %void = OpTypeVoid %uint = OpTypeInt 32 0 %struct1 = OpTypeStruct %uint %uint %uint_ptr = OpTypePointer Function %uint %struct1_ptr = OpTypePointer Function %struct1 %uint_0 = OpConstant %uint 0 %const_struct = OpConstantComposite %struct1 %uint_0 %uint_0 %func = OpTypeFunction %void %1 = OpFunction %void None %func %2 = OpLabel %var = OpVariable %struct1_ptr Function OpStore %var %const_struct Aligned 4 %3 = OpAccessChain %uint_ptr %var %uint_0 %4 = OpLoad %uint %3 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ScalarReplacementTest, DontTouchVolatileLoad) { const std::string text = R"( ; ; CHECK: [[struct:%\w+]] = OpTypeStruct ; CHECK: [[struct_ptr:%\w+]] = OpTypePointer Function [[struct]] ; CHECK: OpLabel ; CHECK-NEXT: OpVariable [[struct_ptr]] ; CHECK-NOT: OpVariable ; OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %func "dont_touch_volatile_load" %void = OpTypeVoid %uint = OpTypeInt 32 0 %struct1 = OpTypeStruct %uint %uint_ptr = OpTypePointer Function %uint %struct1_ptr = OpTypePointer Function %struct1 %uint_0 = OpConstant %uint 0 %func = OpTypeFunction %void %1 = OpFunction %void None %func %2 = OpLabel %var = OpVariable %struct1_ptr Function %3 = OpAccessChain %uint_ptr %var %uint_0 %4 = OpLoad %uint %3 Volatile OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ScalarReplacementTest, DontTouchVolatileStore) { const std::string text = R"( ; ; CHECK: [[struct:%\w+]] = OpTypeStruct ; CHECK: [[struct_ptr:%\w+]] = OpTypePointer Function [[struct]] ; CHECK: OpLabel ; CHECK-NEXT: OpVariable [[struct_ptr]] ; CHECK-NOT: OpVariable ; OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %func "dont_touch_volatile_store" %void = OpTypeVoid %uint = OpTypeInt 32 0 %struct1 = OpTypeStruct %uint %uint_ptr = OpTypePointer Function %uint %struct1_ptr = OpTypePointer Function %struct1 %uint_0 = OpConstant %uint 0 %func = OpTypeFunction %void %1 = OpFunction %void None %func %2 = OpLabel %var = OpVariable %struct1_ptr Function %3 = OpAccessChain %uint_ptr %var %uint_0 OpStore %3 %uint_0 Volatile OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ScalarReplacementTest, DontTouchSpecNonFunctionVariable) { const std::string text = R"( ; ; CHECK: [[struct:%\w+]] = OpTypeStruct ; CHECK: [[struct_ptr:%\w+]] = OpTypePointer Uniform [[struct]] ; CHECK: OpConstant ; CHECK-NEXT: OpVariable [[struct_ptr]] ; CHECK-NOT: OpVariable ; OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %func "dont_touch_spec_constant_access_chain" %void = OpTypeVoid %uint = OpTypeInt 32 0 %struct1 = OpTypeStruct %uint %uint_ptr = OpTypePointer Uniform %uint %struct1_ptr = OpTypePointer Uniform %struct1 %uint_0 = OpConstant %uint 0 %var = OpVariable %struct1_ptr Uniform %func = OpTypeFunction %void %1 = OpFunction %void None %func %2 = OpLabel %3 = OpAccessChain %uint_ptr %var %uint_0 OpStore %3 %uint_0 Volatile OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ScalarReplacementTest, DontTouchSpecConstantAccessChain) { const std::string text = R"( ; ; CHECK: [[array:%\w+]] = OpTypeArray ; CHECK: [[array_ptr:%\w+]] = OpTypePointer Function [[array]] ; CHECK: OpLabel ; CHECK-NEXT: OpVariable [[array_ptr]] ; CHECK-NOT: OpVariable ; OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %func "dont_touch_spec_constant_access_chain" %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %array = OpTypeArray %uint %uint_1 %uint_ptr = OpTypePointer Function %uint %array_ptr = OpTypePointer Function %array %uint_0 = OpConstant %uint 0 %spec_const = OpSpecConstant %uint 0 %func = OpTypeFunction %void %1 = OpFunction %void None %func %2 = OpLabel %var = OpVariable %array_ptr Function %3 = OpAccessChain %uint_ptr %var %spec_const OpStore %3 %uint_0 Volatile OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ScalarReplacementTest, NoPartialAccesses) { const std::string text = R"( ; ; CHECK: [[uint:%\w+]] = OpTypeInt 32 0 ; CHECK: [[uint_ptr:%\w+]] = OpTypePointer Function [[uint]] ; CHECK: OpLabel ; CHECK-NOT: OpVariable ; OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %func "no_partial_accesses" %void = OpTypeVoid %uint = OpTypeInt 32 0 %struct1 = OpTypeStruct %uint %uint_ptr = OpTypePointer Function %uint %struct1_ptr = OpTypePointer Function %struct1 %const = OpConstantNull %struct1 %func = OpTypeFunction %void %1 = OpFunction %void None %func %2 = OpLabel %var = OpVariable %struct1_ptr Function OpStore %var %const OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ScalarReplacementTest, DontTouchPtrAccessChain) { const std::string text = R"( ; ; CHECK: [[struct:%\w+]] = OpTypeStruct ; CHECK: [[struct_ptr:%\w+]] = OpTypePointer Function [[struct]] ; CHECK: OpLabel ; CHECK-NEXT: OpVariable [[struct_ptr]] ; CHECK-NOT: OpVariable ; OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %func "dont_touch_ptr_access_chain" %void = OpTypeVoid %uint = OpTypeInt 32 0 %struct1 = OpTypeStruct %uint %uint_ptr = OpTypePointer Function %uint %struct1_ptr = OpTypePointer Function %struct1 %uint_0 = OpConstant %uint 0 %func = OpTypeFunction %void %1 = OpFunction %void None %func %2 = OpLabel %var = OpVariable %struct1_ptr Function %3 = OpPtrAccessChain %uint_ptr %var %uint_0 %uint_0 OpStore %3 %uint_0 %4 = OpAccessChain %uint_ptr %var %uint_0 OpStore %4 %uint_0 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(ScalarReplacementTest, DontTouchInBoundsPtrAccessChain) { const std::string text = R"( ; ; CHECK: [[struct:%\w+]] = OpTypeStruct ; CHECK: [[struct_ptr:%\w+]] = OpTypePointer Function [[struct]] ; CHECK: OpLabel ; CHECK-NEXT: OpVariable [[struct_ptr]] ; CHECK-NOT: OpVariable ; OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %func "dont_touch_in_bounds_ptr_access_chain" %void = OpTypeVoid %uint = OpTypeInt 32 0 %struct1 = OpTypeStruct %uint %uint_ptr = OpTypePointer Function %uint %struct1_ptr = OpTypePointer Function %struct1 %uint_0 = OpConstant %uint 0 %func = OpTypeFunction %void %1 = OpFunction %void None %func %2 = OpLabel %var = OpVariable %struct1_ptr Function %3 = OpInBoundsPtrAccessChain %uint_ptr %var %uint_0 %uint_0 OpStore %3 %uint_0 %4 = OpInBoundsAccessChain %uint_ptr %var %uint_0 OpStore %4 %uint_0 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(ScalarReplacementTest, DonTouchAliasedDecoration) { const std::string text = R"( ; ; CHECK: [[struct:%\w+]] = OpTypeStruct ; CHECK: [[struct_ptr:%\w+]] = OpTypePointer Function [[struct]] ; CHECK: OpLabel ; CHECK-NEXT: OpVariable [[struct_ptr]] ; CHECK-NOT: OpVariable ; OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %func "aliased" OpDecorate %var Aliased %void = OpTypeVoid %uint = OpTypeInt 32 0 %struct1 = OpTypeStruct %uint %uint_ptr = OpTypePointer Function %uint %struct1_ptr = OpTypePointer Function %struct1 %uint_0 = OpConstant %uint 0 %func = OpTypeFunction %void %1 = OpFunction %void None %func %2 = OpLabel %var = OpVariable %struct1_ptr Function %3 = OpAccessChain %uint_ptr %var %uint_0 %4 = OpLoad %uint %3 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ScalarReplacementTest, CopyRestrictDecoration) { const std::string text = R"( ; ; CHECK: OpName ; CHECK-NEXT: OpDecorate [[var0:%\w+]] Restrict ; CHECK-NEXT: OpDecorate [[var1:%\w+]] Restrict ; CHECK: [[int:%\w+]] = OpTypeInt ; CHECK: [[struct:%\w+]] = OpTypeStruct ; CHECK: [[int_ptr:%\w+]] = OpTypePointer Function [[int]] ; CHECK: [[struct_ptr:%\w+]] = OpTypePointer Function [[struct]] ; CHECK: OpLabel ; CHECK-NEXT: [[var1]] = OpVariable [[int_ptr]] ; CHECK-NEXT: [[var0]] = OpVariable [[int_ptr]] ; CHECK-NOT: OpVariable [[struct_ptr]] ; OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %func "restrict" OpDecorate %var Restrict %void = OpTypeVoid %uint = OpTypeInt 32 0 %struct1 = OpTypeStruct %uint %uint %uint_ptr = OpTypePointer Function %uint %struct1_ptr = OpTypePointer Function %struct1 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %func = OpTypeFunction %void %1 = OpFunction %void None %func %2 = OpLabel %var = OpVariable %struct1_ptr Function %3 = OpAccessChain %uint_ptr %var %uint_0 %4 = OpLoad %uint %3 %5 = OpAccessChain %uint_ptr %var %uint_1 %6 = OpLoad %uint %5 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ScalarReplacementTest, DontClobberDecoratesOnSubtypes) { const std::string text = R"( ; ; CHECK: OpDecorate [[array:%\w+]] ArrayStride 1 ; CHECK: [[uint:%\w+]] = OpTypeInt 32 0 ; CHECK: [[array]] = OpTypeArray [[uint]] ; CHECK: [[array_ptr:%\w+]] = OpTypePointer Function [[array]] ; CHECK: OpLabel ; CHECK-NEXT: OpVariable [[array_ptr]] Function ; CHECK-NOT: OpVariable ; OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %func "array_stride" OpDecorate %array ArrayStride 1 %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %array = OpTypeArray %uint %uint_1 %struct1 = OpTypeStruct %array %uint_ptr = OpTypePointer Function %uint %struct1_ptr = OpTypePointer Function %struct1 %uint_0 = OpConstant %uint 0 %func = OpTypeFunction %void %uint %1 = OpFunction %void None %func %param = OpFunctionParameter %uint %2 = OpLabel %var = OpVariable %struct1_ptr Function %3 = OpAccessChain %uint_ptr %var %uint_0 %param %4 = OpLoad %uint %3 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ScalarReplacementTest, DontCopyMemberDecorate) { const std::string text = R"( ; ; CHECK-NOT: OpDecorate ; CHECK: [[uint:%\w+]] = OpTypeInt 32 0 ; CHECK: [[struct:%\w+]] = OpTypeStruct [[uint]] ; CHECK: [[uint_ptr:%\w+]] = OpTypePointer Function [[uint]] ; CHECK: [[struct_ptr:%\w+]] = OpTypePointer Function [[struct]] ; CHECK: OpLabel ; CHECK-NEXT: OpVariable [[uint_ptr]] Function ; CHECK-NOT: OpVariable ; OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %func "member_decorate" OpMemberDecorate %struct1 0 Offset 1 %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %struct1 = OpTypeStruct %uint %uint_ptr = OpTypePointer Function %uint %struct1_ptr = OpTypePointer Function %struct1 %uint_0 = OpConstant %uint 0 %func = OpTypeFunction %void %uint %1 = OpFunction %void None %func %2 = OpLabel %var = OpVariable %struct1_ptr Function %3 = OpAccessChain %uint_ptr %var %uint_0 %4 = OpLoad %uint %3 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ScalarReplacementTest, NoPartialAccesses2) { const std::string text = R"( ; ; CHECK: [[float:%\w+]] = OpTypeFloat 32 ; CHECK: [[float_ptr:%\w+]] = OpTypePointer Function [[float]] ; CHECK: OpVariable [[float_ptr]] Function ; CHECK: OpVariable [[float_ptr]] Function ; CHECK: OpVariable [[float_ptr]] Function ; CHECK: OpVariable [[float_ptr]] Function ; CHECK: OpVariable [[float_ptr]] Function ; CHECK: OpVariable [[float_ptr]] Function ; CHECK: OpVariable [[float_ptr]] Function ; CHECK-NOT: OpVariable ; OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %fo OpExecutionMode %main OriginUpperLeft OpSource GLSL 430 OpName %main "main" OpName %S "S" OpMemberName %S 0 "x" OpMemberName %S 1 "y" OpName %ts1 "ts1" OpName %S_0 "S" OpMemberName %S_0 0 "x" OpMemberName %S_0 1 "y" OpName %U_t "U_t" OpMemberName %U_t 0 "g_s1" OpMemberName %U_t 1 "g_s2" OpMemberName %U_t 2 "g_s3" OpName %_ "" OpName %ts2 "ts2" OpName %_Globals_ "_Globals_" OpMemberName %_Globals_ 0 "g_b" OpName %__0 "" OpName %ts3 "ts3" OpName %ts4 "ts4" OpName %fo "fo" OpMemberDecorate %S_0 0 Offset 0 OpMemberDecorate %S_0 1 Offset 4 OpMemberDecorate %U_t 0 Offset 0 OpMemberDecorate %U_t 1 Offset 8 OpMemberDecorate %U_t 2 Offset 16 OpDecorate %U_t BufferBlock OpDecorate %_ DescriptorSet 0 OpMemberDecorate %_Globals_ 0 Offset 0 OpDecorate %_Globals_ Block OpDecorate %__0 DescriptorSet 0 OpDecorate %__0 Binding 0 OpDecorate %fo Location 0 %void = OpTypeVoid %15 = OpTypeFunction %void %float = OpTypeFloat 32 %S = OpTypeStruct %float %float %_ptr_Function_S = OpTypePointer Function %S %S_0 = OpTypeStruct %float %float %U_t = OpTypeStruct %S_0 %S_0 %S_0 %_ptr_Uniform_U_t = OpTypePointer Uniform %U_t %_ = OpVariable %_ptr_Uniform_U_t Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_S_0 = OpTypePointer Uniform %S_0 %_ptr_Function_float = OpTypePointer Function %float %int_1 = OpConstant %int 1 %uint = OpTypeInt 32 0 %_Globals_ = OpTypeStruct %uint %_ptr_Uniform__Globals_ = OpTypePointer Uniform %_Globals_ %__0 = OpVariable %_ptr_Uniform__Globals_ Uniform %_ptr_Uniform_uint = OpTypePointer Uniform %uint %bool = OpTypeBool %uint_0 = OpConstant %uint 0 %_ptr_Output_float = OpTypePointer Output %float %fo = OpVariable %_ptr_Output_float Output %main = OpFunction %void None %15 %30 = OpLabel %ts1 = OpVariable %_ptr_Function_S Function %ts2 = OpVariable %_ptr_Function_S Function %ts3 = OpVariable %_ptr_Function_S Function %ts4 = OpVariable %_ptr_Function_S Function %31 = OpAccessChain %_ptr_Uniform_S_0 %_ %int_0 %32 = OpLoad %S_0 %31 %33 = OpCompositeExtract %float %32 0 %34 = OpAccessChain %_ptr_Function_float %ts1 %int_0 OpStore %34 %33 %35 = OpCompositeExtract %float %32 1 %36 = OpAccessChain %_ptr_Function_float %ts1 %int_1 OpStore %36 %35 %37 = OpAccessChain %_ptr_Uniform_S_0 %_ %int_1 %38 = OpLoad %S_0 %37 %39 = OpCompositeExtract %float %38 0 %40 = OpAccessChain %_ptr_Function_float %ts2 %int_0 OpStore %40 %39 %41 = OpCompositeExtract %float %38 1 %42 = OpAccessChain %_ptr_Function_float %ts2 %int_1 OpStore %42 %41 %43 = OpAccessChain %_ptr_Uniform_uint %__0 %int_0 %44 = OpLoad %uint %43 %45 = OpINotEqual %bool %44 %uint_0 OpSelectionMerge %46 None OpBranchConditional %45 %47 %48 %47 = OpLabel %49 = OpLoad %S %ts1 OpStore %ts3 %49 OpBranch %46 %48 = OpLabel %50 = OpLoad %S %ts2 OpStore %ts3 %50 OpBranch %46 %46 = OpLabel %51 = OpLoad %S %ts3 OpStore %ts4 %51 %52 = OpAccessChain %_ptr_Function_float %ts4 %int_1 %53 = OpLoad %float %52 OpStore %fo %53 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ScalarReplacementTest, ReplaceWholeLoadAndStore) { const std::string text = R"( ; ; CHECK: [[uint:%\w+]] = OpTypeInt 32 0 ; CHECK: [[struct1:%\w+]] = OpTypeStruct [[uint]] [[uint]] ; CHECK: [[uint_ptr:%\w+]] = OpTypePointer Function [[uint]] ; CHECK: [[const:%\w+]] = OpConstant [[uint]] 0 ; CHECK: [[undef:%\w+]] = OpUndef [[uint]] ; CHECK: [[var0:%\w+]] = OpVariable [[uint_ptr]] Function ; CHECK: [[var1:%\w+]] = OpVariable [[uint_ptr]] Function ; CHECK-NOT: OpVariable ; CHECK: [[l0:%\w+]] = OpLoad [[uint]] [[var0]] ; CHECK: [[c0:%\w+]] = OpCompositeConstruct [[struct1]] [[l0]] [[undef]] ; CHECK: [[e0:%\w+]] = OpCompositeExtract [[uint]] [[c0]] 0 ; CHECK: OpStore [[var1]] [[e0]] ; CHECK: [[l1:%\w+]] = OpLoad [[uint]] [[var1]] ; CHECK: [[c1:%\w+]] = OpCompositeConstruct [[struct1]] [[l1]] [[undef]] ; CHECK: [[e1:%\w+]] = OpCompositeExtract [[uint]] [[c1]] 0 ; OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %func "replace_whole_load" %void = OpTypeVoid %uint = OpTypeInt 32 0 %struct1 = OpTypeStruct %uint %uint %uint_ptr = OpTypePointer Function %uint %struct1_ptr = OpTypePointer Function %struct1 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %func = OpTypeFunction %void %1 = OpFunction %void None %func %2 = OpLabel %var2 = OpVariable %struct1_ptr Function %var1 = OpVariable %struct1_ptr Function %load1 = OpLoad %struct1 %var1 OpStore %var2 %load1 %load2 = OpLoad %struct1 %var2 %3 = OpCompositeExtract %uint %load2 0 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ScalarReplacementTest, ReplaceWholeLoadAndStore2) { // TODO: We can improve this case by ensuring that |var2| is processed first. const std::string text = R"( ; ; CHECK: [[uint:%\w+]] = OpTypeInt 32 0 ; CHECK: [[struct1:%\w+]] = OpTypeStruct [[uint]] [[uint]] ; CHECK: [[uint_ptr:%\w+]] = OpTypePointer Function [[uint]] ; CHECK: [[const:%\w+]] = OpConstant [[uint]] 0 ; CHECK: [[undef:%\w+]] = OpUndef [[uint]] ; CHECK: [[var1:%\w+]] = OpVariable [[uint_ptr]] Function ; CHECK: [[var0a:%\w+]] = OpVariable [[uint_ptr]] Function ; CHECK: [[var0b:%\w+]] = OpVariable [[uint_ptr]] Function ; CHECK-NOT: OpVariable ; CHECK: [[l0a:%\w+]] = OpLoad [[uint]] [[var0a]] ; CHECK: [[l0b:%\w+]] = OpLoad [[uint]] [[var0b]] ; CHECK: [[c0:%\w+]] = OpCompositeConstruct [[struct1]] [[l0b]] [[l0a]] ; CHECK: [[e0:%\w+]] = OpCompositeExtract [[uint]] [[c0]] 0 ; CHECK: OpStore [[var1]] [[e0]] ; CHECK: [[l1:%\w+]] = OpLoad [[uint]] [[var1]] ; CHECK: [[c1:%\w+]] = OpCompositeConstruct [[struct1]] [[l1]] [[undef]] ; CHECK: [[e1:%\w+]] = OpCompositeExtract [[uint]] [[c1]] 0 ; OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %func "replace_whole_load" %void = OpTypeVoid %uint = OpTypeInt 32 0 %struct1 = OpTypeStruct %uint %uint %uint_ptr = OpTypePointer Function %uint %struct1_ptr = OpTypePointer Function %struct1 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %func = OpTypeFunction %void %1 = OpFunction %void None %func %2 = OpLabel %var1 = OpVariable %struct1_ptr Function %var2 = OpVariable %struct1_ptr Function %load1 = OpLoad %struct1 %var1 OpStore %var2 %load1 %load2 = OpLoad %struct1 %var2 %3 = OpCompositeExtract %uint %load2 0 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ScalarReplacementTest, CreateAmbiguousNullConstant1) { const std::string text = R"( ; ; CHECK: [[uint:%\w+]] = OpTypeInt 32 0 ; CHECK: [[struct1:%\w+]] = OpTypeStruct [[uint]] [[struct_member:%\w+]] ; CHECK: [[uint_ptr:%\w+]] = OpTypePointer Function [[uint]] ; CHECK: [[const:%\w+]] = OpConstant [[uint]] 0 ; CHECK: [[undef:%\w+]] = OpUndef [[struct_member]] ; CHECK: [[var0a:%\w+]] = OpVariable [[uint_ptr]] Function ; CHECK: [[var1:%\w+]] = OpVariable [[uint_ptr]] Function ; CHECK: [[var0b:%\w+]] = OpVariable [[uint_ptr]] Function ; CHECK-NOT: OpVariable ; CHECK: OpStore [[var1]] ; CHECK: [[l1:%\w+]] = OpLoad [[uint]] [[var1]] ; CHECK: [[c1:%\w+]] = OpCompositeConstruct [[struct1]] [[l1]] [[undef]] ; CHECK: [[e1:%\w+]] = OpCompositeExtract [[uint]] [[c1]] 0 ; OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %func "replace_whole_load" %void = OpTypeVoid %uint = OpTypeInt 32 0 %struct2 = OpTypeStruct %uint %struct3 = OpTypeStruct %uint %struct1 = OpTypeStruct %uint %struct2 %uint_ptr = OpTypePointer Function %uint %struct1_ptr = OpTypePointer Function %struct1 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %func = OpTypeFunction %void %1 = OpFunction %void None %func %2 = OpLabel %var1 = OpVariable %struct1_ptr Function %var2 = OpVariable %struct1_ptr Function %load1 = OpLoad %struct1 %var1 OpStore %var2 %load1 %load2 = OpLoad %struct1 %var2 %3 = OpCompositeExtract %uint %load2 0 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ScalarReplacementTest, SpecConstantArray) { const std::string text = R"( ; CHECK: [[int:%\w+]] = OpTypeInt ; CHECK: [[spec_const:%\w+]] = OpSpecConstant [[int]] 4 ; CHECK: [[spec_op:%\w+]] = OpSpecConstantOp [[int]] IAdd [[spec_const]] [[spec_const]] ; CHECK: [[array1:%\w+]] = OpTypeArray [[int]] [[spec_const]] ; CHECK: [[array2:%\w+]] = OpTypeArray [[int]] [[spec_op]] ; CHECK: [[ptr_array1:%\w+]] = OpTypePointer Function [[array1]] ; CHECK: [[ptr_array2:%\w+]] = OpTypePointer Function [[array2]] ; CHECK: OpLabel ; CHECK-NEXT: OpVariable [[ptr_array1]] Function ; CHECK-NEXT: OpVariable [[ptr_array2]] Function ; CHECK-NOT: OpVariable OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %void_fn = OpTypeFunction %void %int = OpTypeInt 32 0 %spec_const = OpSpecConstant %int 4 %spec_op = OpSpecConstantOp %int IAdd %spec_const %spec_const %array_1 = OpTypeArray %int %spec_const %array_2 = OpTypeArray %int %spec_op %ptr_array_1_Function = OpTypePointer Function %array_1 %ptr_array_2_Function = OpTypePointer Function %array_2 %func = OpFunction %void None %void_fn %1 = OpLabel %var_1 = OpVariable %ptr_array_1_Function Function %var_2 = OpVariable %ptr_array_2_Function Function OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ScalarReplacementTest, CreateAmbiguousNullConstant2) { const std::string text = R"( ; ; CHECK: [[uint:%\w+]] = OpTypeInt 32 0 ; CHECK: [[struct1:%\w+]] = OpTypeStruct [[uint]] [[struct_member:%\w+]] ; CHECK: [[uint_ptr:%\w+]] = OpTypePointer Function [[uint]] ; CHECK: [[const:%\w+]] = OpConstant [[uint]] 0 ; CHECK: [[undef:%\w+]] = OpUndef [[struct_member]] ; CHECK: [[var0a:%\w+]] = OpVariable [[uint_ptr]] Function ; CHECK: [[var1:%\w+]] = OpVariable [[uint_ptr]] Function ; CHECK: [[var0b:%\w+]] = OpVariable [[uint_ptr]] Function ; CHECK: OpStore [[var1]] ; CHECK: [[l1:%\w+]] = OpLoad [[uint]] [[var1]] ; CHECK: [[c1:%\w+]] = OpCompositeConstruct [[struct1]] [[l1]] [[undef]] ; CHECK: [[e1:%\w+]] = OpCompositeExtract [[uint]] [[c1]] 0 ; OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %func "replace_whole_load" %void = OpTypeVoid %uint = OpTypeInt 32 0 %struct3 = OpTypeStruct %uint %struct2 = OpTypeStruct %uint %struct1 = OpTypeStruct %uint %struct2 %uint_ptr = OpTypePointer Function %uint %struct1_ptr = OpTypePointer Function %struct1 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %func = OpTypeFunction %void %1 = OpFunction %void None %func %2 = OpLabel %var1 = OpVariable %struct1_ptr Function %var2 = OpVariable %struct1_ptr Function %load1 = OpLoad %struct1 %var1 OpStore %var2 %load1 %load2 = OpLoad %struct1 %var2 %3 = OpCompositeExtract %uint %load2 0 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } // Test that a struct of size 4 is not replaced when there is a limit of 2. TEST_F(ScalarReplacementTest, TestLimit) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %6 "simple_struct" %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypeStruct %2 %2 %2 %2 %4 = OpTypePointer Function %3 %5 = OpTypePointer Function %2 %6 = OpTypeFunction %2 %7 = OpConstantNull %3 %8 = OpConstant %2 0 %9 = OpConstant %2 1 %10 = OpConstant %2 2 %11 = OpConstant %2 3 %12 = OpFunction %2 None %6 %13 = OpLabel %14 = OpVariable %4 Function %7 %15 = OpInBoundsAccessChain %5 %14 %8 %16 = OpLoad %2 %15 %17 = OpAccessChain %5 %14 %10 %18 = OpLoad %2 %17 %19 = OpIAdd %2 %16 %18 OpReturnValue %19 OpFunctionEnd )"; auto result = SinglePassRunAndDisassemble(text, true, false, 2); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } // Test that a struct of size 4 is replaced when there is a limit of 0 (no // limit). This is the same spir-v as a test above, so we do not check that it // is correctly transformed. We leave that to the test above. TEST_F(ScalarReplacementTest, TestUnimited) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %6 "simple_struct" %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypeStruct %2 %2 %2 %2 %4 = OpTypePointer Function %3 %5 = OpTypePointer Function %2 %6 = OpTypeFunction %2 %7 = OpConstantNull %3 %8 = OpConstant %2 0 %9 = OpConstant %2 1 %10 = OpConstant %2 2 %11 = OpConstant %2 3 %12 = OpFunction %2 None %6 %13 = OpLabel %14 = OpVariable %4 Function %7 %15 = OpInBoundsAccessChain %5 %14 %8 %16 = OpLoad %2 %15 %17 = OpAccessChain %5 %14 %10 %18 = OpLoad %2 %17 %19 = OpIAdd %2 %16 %18 OpReturnValue %19 OpFunctionEnd )"; auto result = SinglePassRunAndDisassemble(text, true, false, 0); EXPECT_EQ(Pass::Status::SuccessWithChange, std::get<1>(result)); } TEST_F(ScalarReplacementTest, AmbigousPointer) { const std::string text = R"( ; CHECK: [[s1:%\w+]] = OpTypeStruct %uint ; CHECK: [[s2:%\w+]] = OpTypeStruct %uint ; CHECK: [[s3:%\w+]] = OpTypeStruct [[s2]] ; CHECK: [[s3_const:%\w+]] = OpConstantComposite [[s3]] ; CHECK: [[s2_ptr:%\w+]] = OpTypePointer Function [[s2]] ; CHECK: OpCompositeExtract [[s2]] [[s3_const]] OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %void = OpTypeVoid %5 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_struct_7 = OpTypeStruct %uint %_struct_8 = OpTypeStruct %uint %_struct_9 = OpTypeStruct %_struct_8 %uint_1 = OpConstant %uint 1 %11 = OpConstantComposite %_struct_8 %uint_1 %12 = OpConstantComposite %_struct_9 %11 %_ptr_Function__struct_9 = OpTypePointer Function %_struct_9 %_ptr_Function__struct_7 = OpTypePointer Function %_struct_7 %2 = OpFunction %void None %5 %15 = OpLabel %var = OpVariable %_ptr_Function__struct_9 Function OpStore %var %12 %ld = OpLoad %_struct_9 %var %ex = OpCompositeExtract %_struct_8 %ld 0 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } // Test that scalar replacement does not crash when there is an OpAccessChain // with no index. If we choose to handle this case in the future, then the // result can change. TEST_F(ScalarReplacementTest, TestAccessChainWithNoIndexes) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginLowerLeft %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %_struct_5 = OpTypeStruct %float %_ptr_Function__struct_5 = OpTypePointer Function %_struct_5 %1 = OpFunction %void None %3 %7 = OpLabel %8 = OpVariable %_ptr_Function__struct_5 Function %9 = OpAccessChain %_ptr_Function__struct_5 %8 OpReturn OpFunctionEnd )"; auto result = SinglePassRunAndDisassemble(text, true, false); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } // Test that id overflow is handled gracefully. TEST_F(ScalarReplacementTest, IdBoundOverflow1) { const std::string text = R"( OpCapability ImageQuery OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpDecorate %4194302 DescriptorSet 1073495039 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeStruct %6 %6 %557056 = OpTypeStruct %7 %9 = OpTypePointer Function %7 %18 = OpTypeFunction %7 %9 %4 = OpFunction %2 Pure|Const %3 %1836763 = OpLabel %4194302 = OpVariable %9 Function %10 = OpVariable %9 Function OpKill %4194301 = OpLabel %524296 = OpLoad %7 %4194302 OpKill OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); std::vector messages = { {SPV_MSG_ERROR, "", 0, 0, "ID overflow. Try running compact-ids."}, {SPV_MSG_ERROR, "", 0, 0, "ID overflow. Try running compact-ids."}}; SetMessageConsumer(GetTestMessageConsumer(messages)); auto result = SinglePassRunToBinary(text, true, false); EXPECT_EQ(Pass::Status::Failure, std::get<1>(result)); } // Test that id overflow is handled gracefully. TEST_F(ScalarReplacementTest, IdBoundOverflow2) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %17 OpExecutionMode %4 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypeStruct %7 %9 = OpTypePointer Function %8 %16 = OpTypePointer Output %7 %21 = OpTypeInt 32 1 %22 = OpConstant %21 0 %23 = OpTypePointer Function %7 %17 = OpVariable %16 Output %4 = OpFunction %2 None %3 %5 = OpLabel %4194300 = OpVariable %23 Function %10 = OpVariable %9 Function %4194301 = OpAccessChain %23 %10 %22 %4194302 = OpLoad %7 %4194301 OpStore %4194300 %4194302 %15 = OpLoad %7 %4194300 OpStore %17 %15 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); std::vector messages = { {SPV_MSG_ERROR, "", 0, 0, "ID overflow. Try running compact-ids."}}; SetMessageConsumer(GetTestMessageConsumer(messages)); auto result = SinglePassRunToBinary(text, true, false); EXPECT_EQ(Pass::Status::Failure, std::get<1>(result)); } // Test that id overflow is handled gracefully. TEST_F(ScalarReplacementTest, IdBoundOverflow3) { const std::string text = R"( OpCapability InterpolationFunction OpExtension "z" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeStruct %6 %6 %9 = OpTypePointer Function %7 %18 = OpTypeFunction %7 %9 %21 = OpTypeInt 32 0 %22 = OpConstant %21 4293000676 %4194302 = OpConstantNull %6 %4 = OpFunction %2 Inline|Pure %3 %786464 = OpLabel %4194298 = OpVariable %9 Function %10 = OpVariable %9 Function %4194299 = OpUDiv %21 %22 %22 %4194300 = OpLoad %7 %10 %50959 = OpLoad %7 %4194298 OpKill OpFunctionEnd %1 = OpFunction %7 None %18 %19 = OpFunctionParameter %9 %147667 = OpLabel %2044391 = OpUDiv %21 %22 %22 %25 = OpLoad %7 %19 OpReturnValue %25 OpFunctionEnd %4194295 = OpFunction %2 None %3 %4194296 = OpLabel OpKill OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); std::vector messages = { {SPV_MSG_ERROR, "", 0, 0, "ID overflow. Try running compact-ids."}, {SPV_MSG_ERROR, "", 0, 0, "ID overflow. Try running compact-ids."}, {SPV_MSG_ERROR, "", 0, 0, "ID overflow. Try running compact-ids."}, {SPV_MSG_ERROR, "", 0, 0, "ID overflow. Try running compact-ids."}, {SPV_MSG_ERROR, "", 0, 0, "ID overflow. Try running compact-ids."}, {SPV_MSG_ERROR, "", 0, 0, "ID overflow. Try running compact-ids."}, {SPV_MSG_ERROR, "", 0, 0, "ID overflow. Try running compact-ids."}, {SPV_MSG_ERROR, "", 0, 0, "ID overflow. Try running compact-ids."}, {SPV_MSG_ERROR, "", 0, 0, "ID overflow. Try running compact-ids."}}; SetMessageConsumer(GetTestMessageConsumer(messages)); auto result = SinglePassRunToBinary(text, true, false); EXPECT_EQ(Pass::Status::Failure, std::get<1>(result)); } // Test that replacements for OpAccessChain do not go out of bounds. // https://github.com/KhronosGroup/SPIRV-Tools/issues/2609. TEST_F(ScalarReplacementTest, OutOfBoundOpAccessChain) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %_GLF_color OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" OpName %a "a" OpName %_GLF_color "_GLF_color" OpDecorate %_GLF_color Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_1 = OpConstant %int 1 %float = OpTypeFloat 32 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %_ptr_Function__arr_float_uint_1 = OpTypePointer Function %_arr_float_uint_1 %_ptr_Function_float = OpTypePointer Function %float %_ptr_Output_float = OpTypePointer Output %float %_GLF_color = OpVariable %_ptr_Output_float Output %main = OpFunction %void None %3 %5 = OpLabel %a = OpVariable %_ptr_Function__arr_float_uint_1 Function %21 = OpAccessChain %_ptr_Function_float %a %int_1 %22 = OpLoad %float %21 OpStore %_GLF_color %22 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); auto result = SinglePassRunAndDisassemble(text, true, false); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } TEST_F(ScalarReplacementTest, CharIndex) { const std::string text = R"( ; CHECK: [[int:%\w+]] = OpTypeInt 32 0 ; CHECK: [[ptr:%\w+]] = OpTypePointer Function [[int]] ; CHECK: OpVariable [[ptr]] Function OpCapability Shader OpCapability Int8 OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_1024 = OpConstant %int 1024 %char = OpTypeInt 8 0 %char_1 = OpConstant %char 1 %array = OpTypeArray %int %int_1024 %ptr_func_array = OpTypePointer Function %array %ptr_func_int = OpTypePointer Function %int %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %var = OpVariable %ptr_func_array Function %gep = OpAccessChain %ptr_func_int %var %char_1 OpStore %gep %int_1024 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true, 0); } TEST_F(ScalarReplacementTest, OutOfBoundsOpAccessChainNegative) { const std::string text = R"( OpCapability Shader OpCapability Int8 OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_1024 = OpConstant %int 1024 %char = OpTypeInt 8 1 %char_n1 = OpConstant %char -1 %array = OpTypeArray %int %int_1024 %ptr_func_array = OpTypePointer Function %array %ptr_func_int = OpTypePointer Function %int %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %var = OpVariable %ptr_func_array Function %gep = OpAccessChain %ptr_func_int %var %char_n1 OpStore %gep %int_1024 OpReturn OpFunctionEnd )"; auto result = SinglePassRunAndDisassemble(text, true, true, 0); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } TEST_F(ScalarReplacementTest, RelaxedPrecisionMemberDecoration) { const std::string text = R"( ; CHECK: OpDecorate {{%\w+}} RelaxedPrecision ; CHECK: OpDecorate [[new_var:%\w+]] RelaxedPrecision ; CHECK: [[new_var]] = OpVariable %_ptr_Function_v3float Function ; CHECK: OpLoad %v3float [[new_var]] OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "Draw2DTexCol_VS" %2 %3 OpSource HLSL 600 OpDecorate %2 Location 0 OpDecorate %3 Location 1 OpDecorate %3 RelaxedPrecision OpMemberDecorate %_struct_4 1 RelaxedPrecision %float = OpTypeFloat 32 %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %v3float = OpTypeVector %float 3 %_ptr_Input_v3float = OpTypePointer Input %v3float %void = OpTypeVoid %11 = OpTypeFunction %void %_struct_4 = OpTypeStruct %v3float %v3float %_ptr_Function__struct_4 = OpTypePointer Function %_struct_4 %_ptr_Function_v3float = OpTypePointer Function %v3float %2 = OpVariable %_ptr_Input_v3float Input %3 = OpVariable %_ptr_Input_v3float Input %1 = OpFunction %void None %11 %14 = OpLabel %15 = OpVariable %_ptr_Function__struct_4 Function %16 = OpLoad %v3float %2 %17 = OpLoad %v3float %3 %18 = OpCompositeConstruct %_struct_4 %16 %17 OpStore %15 %18 %19 = OpAccessChain %_ptr_Function_v3float %15 %int_1 %20 = OpLoad %v3float %19 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ScalarReplacementTest, DebugDeclare) { const std::string text = R"( OpCapability Shader OpCapability Linkage %ext = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 %test = OpString "test" OpName %6 "simple_struct" %1 = OpTypeVoid %2 = OpTypeInt 32 0 %uint_32 = OpConstant %2 32 %3 = OpTypeStruct %2 %2 %2 %2 %4 = OpTypePointer Function %3 %5 = OpTypePointer Function %2 %6 = OpTypeFunction %2 %7 = OpConstantNull %3 %8 = OpConstant %2 0 %9 = OpConstant %2 1 %10 = OpConstant %2 2 %11 = OpConstant %2 3 %null_expr = OpExtInst %1 %ext DebugExpression %src = OpExtInst %1 %ext DebugSource %test %cu = OpExtInst %1 %ext DebugCompilationUnit 1 4 %src HLSL %dbg_tf = OpExtInst %1 %ext DebugTypeBasic %test %uint_32 Float %main_ty = OpExtInst %1 %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %1 %dbg_main = OpExtInst %1 %ext DebugFunction %test %main_ty %src 0 0 %cu %test FlagIsProtected|FlagIsPrivate 0 %12 %dbg_foo = OpExtInst %1 %ext DebugLocalVariable %test %dbg_tf %src 0 0 %dbg_main FlagIsLocal %12 = OpFunction %2 None %6 %13 = OpLabel %scope = OpExtInst %1 %ext DebugScope %dbg_main %14 = OpVariable %4 Function %7 ; CHECK: [[deref:%\w+]] = OpExtInst %void [[ext:%\w+]] DebugOperation Deref ; CHECK: [[dbg_local_var:%\w+]] = OpExtInst %void [[ext]] DebugLocalVariable ; CHECK: [[deref_expr:%\w+]] = OpExtInst %void [[ext]] DebugExpression [[deref]] ; CHECK: [[repl3:%\w+]] = OpVariable %_ptr_Function_uint Function ; CHECK: [[repl2:%\w+]] = OpVariable %_ptr_Function_uint Function ; CHECK: [[repl1:%\w+]] = OpVariable %_ptr_Function_uint Function ; CHECK: [[repl0:%\w+]] = OpVariable %_ptr_Function_uint Function ; CHECK: OpExtInst %void [[ext]] DebugValue [[dbg_local_var]] [[repl3]] [[deref_expr]] %int_3 ; CHECK: OpExtInst %void [[ext]] DebugValue [[dbg_local_var]] [[repl2]] [[deref_expr]] %int_2 ; CHECK: OpExtInst %void [[ext]] DebugValue [[dbg_local_var]] [[repl1]] [[deref_expr]] %int_1 ; CHECK: OpExtInst %void [[ext]] DebugValue [[dbg_local_var]] [[repl0]] [[deref_expr]] %int_0 ; CHECK-NOT: DebugDeclare %decl = OpExtInst %1 %ext DebugDeclare %dbg_foo %14 %null_expr %15 = OpInBoundsAccessChain %5 %14 %8 %16 = OpLoad %2 %15 %17 = OpAccessChain %5 %14 %10 %18 = OpLoad %2 %17 %19 = OpIAdd %2 %16 %18 OpReturnValue %19 OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ScalarReplacementTest, DebugValue) { const std::string text = R"( OpCapability Shader OpCapability Linkage %ext = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 %test = OpString "test" OpName %6 "simple_struct" %1 = OpTypeVoid %2 = OpTypeInt 32 0 %uint_32 = OpConstant %2 32 %3 = OpTypeStruct %2 %2 %2 %2 %4 = OpTypePointer Function %3 %5 = OpTypePointer Function %2 %6 = OpTypeFunction %2 %7 = OpConstantNull %3 %8 = OpConstant %2 0 %9 = OpConstant %2 1 %10 = OpConstant %2 2 %11 = OpConstant %2 3 %deref = OpExtInst %1 %ext DebugOperation Deref %deref_expr = OpExtInst %1 %ext DebugExpression %deref %null_expr = OpExtInst %1 %ext DebugExpression %src = OpExtInst %1 %ext DebugSource %test %cu = OpExtInst %1 %ext DebugCompilationUnit 1 4 %src HLSL %dbg_tf = OpExtInst %1 %ext DebugTypeBasic %test %uint_32 Float %main_ty = OpExtInst %1 %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %1 %dbg_main = OpExtInst %1 %ext DebugFunction %test %main_ty %src 0 0 %cu %test FlagIsProtected|FlagIsPrivate 0 %12 %dbg_foo = OpExtInst %1 %ext DebugLocalVariable %test %dbg_tf %src 0 0 %dbg_main FlagIsLocal %12 = OpFunction %2 None %6 %13 = OpLabel %scope = OpExtInst %1 %ext DebugScope %dbg_main %14 = OpVariable %4 Function %7 ; CHECK: [[deref:%\w+]] = OpExtInst %void [[ext:%\w+]] DebugOperation Deref ; CHECK: [[deref_expr:%\w+]] = OpExtInst %void [[ext]] DebugExpression [[deref]] ; CHECK: [[dbg_local_var:%\w+]] = OpExtInst %void [[ext]] DebugLocalVariable ; CHECK: [[repl3:%\w+]] = OpVariable %_ptr_Function_uint Function ; CHECK: [[repl2:%\w+]] = OpVariable %_ptr_Function_uint Function ; CHECK: [[repl1:%\w+]] = OpVariable %_ptr_Function_uint Function ; CHECK: [[repl0:%\w+]] = OpVariable %_ptr_Function_uint Function ; CHECK: OpExtInst %void [[ext]] DebugValue [[dbg_local_var]] [[repl0]] [[deref_expr]] %int_0 ; CHECK: OpExtInst %void [[ext]] DebugValue [[dbg_local_var]] [[repl1]] [[deref_expr]] %int_1 ; CHECK: OpExtInst %void [[ext]] DebugValue [[dbg_local_var]] [[repl2]] [[deref_expr]] %int_2 ; CHECK: OpExtInst %void [[ext]] DebugValue [[dbg_local_var]] [[repl3]] [[deref_expr]] %int_3 %value = OpExtInst %1 %ext DebugValue %dbg_foo %14 %deref_expr %15 = OpInBoundsAccessChain %5 %14 %8 %16 = OpLoad %2 %15 %17 = OpAccessChain %5 %14 %10 %18 = OpLoad %2 %17 %19 = OpIAdd %2 %16 %18 OpReturnValue %19 OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ScalarReplacementTest, DebugDeclareRecursive) { const std::string text = R"( OpCapability Shader OpCapability Linkage %ext = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 %test = OpString "test" OpName %6 "simple_struct" %1 = OpTypeVoid %2 = OpTypeInt 32 0 %uint_32 = OpConstant %2 32 %float = OpTypeFloat 32 %float_1 = OpConstant %float 1 %member = OpTypeStruct %2 %float %3 = OpTypeStruct %2 %member %float %4 = OpTypePointer Function %3 %5 = OpTypePointer Function %2 %ptr_float_Function = OpTypePointer Function %float %6 = OpTypeFunction %2 %cmember = OpConstantComposite %member %uint_32 %float_1 %7 = OpConstantComposite %3 %uint_32 %cmember %float_1 %8 = OpConstant %2 0 %9 = OpConstant %2 1 %10 = OpConstant %2 2 %null_expr = OpExtInst %1 %ext DebugExpression %src = OpExtInst %1 %ext DebugSource %test %cu = OpExtInst %1 %ext DebugCompilationUnit 1 4 %src HLSL %dbg_tf = OpExtInst %1 %ext DebugTypeBasic %test %uint_32 Float %main_ty = OpExtInst %1 %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %1 %dbg_main = OpExtInst %1 %ext DebugFunction %test %main_ty %src 0 0 %cu %test FlagIsProtected|FlagIsPrivate 0 %12 %dbg_foo = OpExtInst %1 %ext DebugLocalVariable %test %dbg_tf %src 0 0 %dbg_main FlagIsLocal %12 = OpFunction %2 None %6 %13 = OpLabel %scope = OpExtInst %1 %ext DebugScope %dbg_main %14 = OpVariable %4 Function %7 ; CHECK: [[deref:%\w+]] = OpExtInst %void [[ext:%\w+]] DebugOperation Deref ; CHECK: [[dbg_local_var:%\w+]] = OpExtInst %void [[ext]] DebugLocalVariable ; CHECK: [[deref_expr:%\w+]] = OpExtInst %void [[ext]] DebugExpression [[deref]] ; CHECK: [[repl2:%\w+]] = OpVariable %_ptr_Function_float Function %float_1 ; CHECK: [[repl1:%\w+]] = OpVariable %_ptr_Function_uint Function %uint_32 ; CHECK: [[repl3:%\w+]] = OpVariable %_ptr_Function_float Function %float_1 ; CHECK: [[repl0:%\w+]] = OpVariable %_ptr_Function_uint Function %uint_32 ; CHECK: OpExtInst %void [[ext]] DebugValue [[dbg_local_var]] [[repl3]] [[deref_expr]] %int_2 ; CHECK: OpExtInst %void [[ext]] DebugValue [[dbg_local_var]] [[repl1]] [[deref_expr]] %int_1 %int_0 ; CHECK: OpExtInst %void [[ext]] DebugValue [[dbg_local_var]] [[repl2]] [[deref_expr]] %int_1 %int_1 ; CHECK: OpExtInst %void [[ext]] DebugValue [[dbg_local_var]] [[repl0]] [[deref_expr]] %int_0 ; CHECK-NOT: DebugDeclare %decl = OpExtInst %1 %ext DebugDeclare %dbg_foo %14 %null_expr %15 = OpInBoundsAccessChain %5 %14 %8 %16 = OpLoad %2 %15 %17 = OpAccessChain %ptr_float_Function %14 %10 %18 = OpLoad %float %17 %value = OpConvertFToU %2 %18 %19 = OpIAdd %2 %16 %value OpReturnValue %19 OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ScalarReplacementTest, DebugValueWithIndex) { const std::string text = R"( OpCapability Shader OpCapability Linkage %ext = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 %test = OpString "test" OpName %6 "simple_struct" %1 = OpTypeVoid %2 = OpTypeInt 32 0 %uint_32 = OpConstant %2 32 %3 = OpTypeStruct %2 %2 %2 %2 %4 = OpTypePointer Function %3 %5 = OpTypePointer Function %2 %6 = OpTypeFunction %2 %7 = OpConstantNull %3 %8 = OpConstant %2 0 %9 = OpConstant %2 1 %10 = OpConstant %2 2 %11 = OpConstant %2 3 %deref = OpExtInst %1 %ext DebugOperation Deref %deref_expr = OpExtInst %1 %ext DebugExpression %deref %null_expr = OpExtInst %1 %ext DebugExpression %src = OpExtInst %1 %ext DebugSource %test %cu = OpExtInst %1 %ext DebugCompilationUnit 1 4 %src HLSL %dbg_tf = OpExtInst %1 %ext DebugTypeBasic %test %uint_32 Float %main_ty = OpExtInst %1 %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %1 %dbg_main = OpExtInst %1 %ext DebugFunction %test %main_ty %src 0 0 %cu %test FlagIsProtected|FlagIsPrivate 0 %12 %dbg_foo = OpExtInst %1 %ext DebugLocalVariable %test %dbg_tf %src 0 0 %dbg_main FlagIsLocal %12 = OpFunction %2 None %6 %13 = OpLabel %scope = OpExtInst %1 %ext DebugScope %dbg_main %14 = OpVariable %4 Function %7 ; CHECK: [[deref:%\w+]] = OpExtInst %void [[ext:%\w+]] DebugOperation Deref ; CHECK: [[deref_expr:%\w+]] = OpExtInst %void [[ext]] DebugExpression [[deref]] ; CHECK: [[dbg_local_var:%\w+]] = OpExtInst %void [[ext]] DebugLocalVariable ; CHECK: [[repl3:%\w+]] = OpVariable %_ptr_Function_uint Function ; CHECK: [[repl2:%\w+]] = OpVariable %_ptr_Function_uint Function ; CHECK: [[repl1:%\w+]] = OpVariable %_ptr_Function_uint Function ; CHECK: [[repl0:%\w+]] = OpVariable %_ptr_Function_uint Function ; CHECK: OpExtInst %void [[ext]] DebugValue [[dbg_local_var]] [[repl0]] [[deref_expr]] %uint_0 %uint_1 %uint_2 %int_0 ; CHECK: OpExtInst %void [[ext]] DebugValue [[dbg_local_var]] [[repl1]] [[deref_expr]] %uint_0 %uint_1 %uint_2 %int_1 ; CHECK: OpExtInst %void [[ext]] DebugValue [[dbg_local_var]] [[repl2]] [[deref_expr]] %uint_0 %uint_1 %uint_2 %int_2 ; CHECK: OpExtInst %void [[ext]] DebugValue [[dbg_local_var]] [[repl3]] [[deref_expr]] %uint_0 %uint_1 %uint_2 %int_3 %value = OpExtInst %1 %ext DebugValue %dbg_foo %14 %deref_expr %8 %9 %10 %15 = OpInBoundsAccessChain %5 %14 %8 %16 = OpLoad %2 %15 %17 = OpAccessChain %5 %14 %10 %18 = OpLoad %2 %17 %19 = OpIAdd %2 %16 %18 OpReturnValue %19 OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ScalarReplacementTest, DebugDeclareForVariableInOtherBB) { const std::string text = R"( OpCapability Shader OpCapability Linkage %ext = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 %test = OpString "test" OpName %6 "simple_struct" %1 = OpTypeVoid %2 = OpTypeInt 32 0 %uint_32 = OpConstant %2 32 %3 = OpTypeStruct %2 %2 %2 %2 %4 = OpTypePointer Function %3 %5 = OpTypePointer Function %2 %6 = OpTypeFunction %2 %7 = OpConstantNull %3 %8 = OpConstant %2 0 %9 = OpConstant %2 1 %10 = OpConstant %2 2 %11 = OpConstant %2 3 %deref = OpExtInst %1 %ext DebugOperation Deref %deref_expr = OpExtInst %1 %ext DebugExpression %deref %null_expr = OpExtInst %1 %ext DebugExpression %src = OpExtInst %1 %ext DebugSource %test %cu = OpExtInst %1 %ext DebugCompilationUnit 1 4 %src HLSL %dbg_tf = OpExtInst %1 %ext DebugTypeBasic %test %uint_32 Float %main_ty = OpExtInst %1 %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %1 %dbg_main = OpExtInst %1 %ext DebugFunction %test %main_ty %src 0 0 %cu %test FlagIsProtected|FlagIsPrivate 0 %12 %dbg_foo = OpExtInst %1 %ext DebugLocalVariable %test %dbg_tf %src 0 0 %dbg_main FlagIsLocal %12 = OpFunction %2 None %6 %13 = OpLabel %scope = OpExtInst %1 %ext DebugScope %dbg_main %14 = OpVariable %4 Function %7 ; CHECK: [[dbg_local_var:%\w+]] = OpExtInst %void [[ext:%\w+]] DebugLocalVariable ; CHECK: [[repl3:%\w+]] = OpVariable %_ptr_Function_uint Function ; CHECK: [[repl2:%\w+]] = OpVariable %_ptr_Function_uint Function ; CHECK: [[repl1:%\w+]] = OpVariable %_ptr_Function_uint Function ; CHECK: [[repl0:%\w+]] = OpVariable %_ptr_Function_uint Function ; CHECK: OpExtInst %void [[ext]] DebugValue [[dbg_local_var]] [[repl3]] [[deref_expr:%\w+]] %int_3 ; CHECK: OpExtInst %void [[ext]] DebugValue [[dbg_local_var]] [[repl2]] [[deref_expr]] %int_2 ; CHECK: OpExtInst %void [[ext]] DebugValue [[dbg_local_var]] [[repl1]] [[deref_expr]] %int_1 ; CHECK: OpExtInst %void [[ext]] DebugValue [[dbg_local_var]] [[repl0]] [[deref_expr]] %int_0 OpBranch %20 %20 = OpLabel %value = OpExtInst %1 %ext DebugDeclare %dbg_foo %14 %null_expr %15 = OpInBoundsAccessChain %5 %14 %8 %16 = OpLoad %2 %15 %17 = OpAccessChain %5 %14 %10 %18 = OpLoad %2 %17 %19 = OpIAdd %2 %16 %18 OpReturnValue %19 OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ScalarReplacementTest, ImageTexelPointer) { // Test whether the scalar replacement correctly checks the // OpImageTexelPointer user of an aggregate with an image type. const std::string text = R"( ; ; CHECK: [[imgTy:%\w+]] = OpTypeImage %uint Buffer 2 0 0 2 R32ui ; CHECK: [[ptrImgTy:%\w+]] = OpTypePointer Function [[imgTy]] ; CHECK: [[img:%\w+]] = OpVariable [[ptrImgTy]] Function ; CHECK: [[imgTexelPtr:%\w+]] = OpImageTexelPointer {{%\w+}} [[img]] %uint_0 %uint_0 ; CHECK: OpAtomicIAdd %uint [[imgTexelPtr]] %uint_1 %uint_0 %uint_1 ; OpCapability Shader OpCapability SampledBuffer OpCapability ImageBuffer OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 64 1 1 %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %_ptr_Image_uint = OpTypePointer Image %uint %type_buffer_image = OpTypeImage %uint Buffer 2 0 0 2 R32ui %_ptr_Function_type_buffer_image = OpTypePointer Function %type_buffer_image %image_struct = OpTypeStruct %type_buffer_image %type_buffer_image %_ptr_Function_image_struct = OpTypePointer Function %image_struct %func = OpTypeFunction %void %1 = OpFunction %void None %func %2 = OpLabel %3 = OpVariable %_ptr_Function_image_struct Function %4 = OpAccessChain %_ptr_Function_type_buffer_image %3 %uint_1 %5 = OpImageTexelPointer %_ptr_Image_uint %4 %uint_0 %uint_0 %6 = OpAtomicIAdd %uint %5 %uint_1 %uint_0 %uint_1 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(ScalarReplacementTest, FunctionDeclaration) { // Make sure the pass works with a function declaration that is called. const std::string text = R"(OpCapability Addresses OpCapability Linkage OpCapability Kernel OpCapability Int8 %1 = OpExtInstImport "OpenCL.std" OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %2 "_Z23julia__1166_kernel_77094Bool" OpExecutionMode %2 ContractionOff OpSource Unknown 0 OpDecorate %3 LinkageAttributes "julia_error_7712" Import %void = OpTypeVoid %5 = OpTypeFunction %void %3 = OpFunction %void None %5 OpFunctionEnd %2 = OpFunction %void None %5 %6 = OpLabel %7 = OpFunctionCall %void %3 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(text, text, false); } TEST_F(ScalarReplacementTest, UndefImageMember) { // Test that scalar replacement creates an undef for a type that cannot have // and OpConstantNull. const std::string text = R"( ; CHECK: [[image_type:%\w+]] = OpTypeSampledImage {{%\w+}} ; CHECK: [[struct_type:%\w+]] = OpTypeStruct [[image_type]] ; CHECK: [[undef:%\w+]] = OpUndef [[image_type]] ; CHECK: {{%\w+}} = OpCompositeConstruct [[struct_type]] [[undef]] OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft %void = OpTypeVoid %4 = OpTypeFunction %void %float = OpTypeFloat 32 %6 = OpTypeImage %float 2D 0 0 0 1 Unknown %7 = OpTypeSampledImage %6 %_struct_8 = OpTypeStruct %7 %9 = OpTypeFunction %_struct_8 %10 = OpUndef %_struct_8 %_ptr_Function__struct_8 = OpTypePointer Function %_struct_8 %2 = OpFunction %void None %4 %11 = OpLabel %16 = OpVariable %_ptr_Function__struct_8 Function OpStore %16 %10 %12 = OpLoad %_struct_8 %16 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(ScalarReplacementTest, RestrictPointer) { // This test makes sure that a variable with the restrict pointer decoration // is replaced, and that the pointer is applied to the new variable. const std::string text = R"( ; CHECK: OpDecorate [[new_var:%\w+]] RestrictPointer ; CHECK: [[struct_type:%\w+]] = OpTypeStruct %int ; CHECK: [[ptr_type:%\w+]] = OpTypePointer PhysicalStorageBuffer [[struct_type]] ; CHECK: [[dup_struct_type:%\w+]] = OpTypeStruct %int ; CHECK: {{%\w+}} = OpTypePointer PhysicalStorageBuffer [[dup_struct_type]] ; CHECK: [[var_type:%\w+]] = OpTypePointer Function [[ptr_type]] ; CHECK: [[new_var]] = OpVariable [[var_type]] Function OpCapability Shader OpCapability PhysicalStorageBufferAddresses %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpMemberDecorate %3 0 Offset 0 OpDecorate %3 Block OpMemberDecorate %4 0 Offset 0 OpDecorate %4 Block OpDecorate %5 RestrictPointer %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeInt 32 1 %9 = OpConstant %8 0 %3 = OpTypeStruct %8 %10 = OpTypePointer PhysicalStorageBuffer %3 %11 = OpTypeStruct %10 %4 = OpTypeStruct %8 %12 = OpTypePointer PhysicalStorageBuffer %4 %13 = OpTypePointer Function %11 %14 = OpTypePointer Function %10 %15 = OpTypePointer Function %12 %16 = OpUndef %11 %2 = OpFunction %6 None %7 %17 = OpLabel %5 = OpVariable %13 Function OpStore %5 %16 %18 = OpAccessChain %14 %5 %9 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_UNIVERSAL_1_6); SinglePassRunAndMatch(text, true); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/set_spec_const_default_value_test.cpp000066400000000000000000001274301475742701700277770ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gmock/gmock.h" #include "test/opt/pass_fixture.h" namespace spvtools { namespace opt { namespace { using testing::Eq; using SpecIdToValueStrMap = SetSpecConstantDefaultValuePass::SpecIdToValueStrMap; using SpecIdToValueBitPatternMap = SetSpecConstantDefaultValuePass::SpecIdToValueBitPatternMap; struct DefaultValuesStringParsingTestCase { const char* default_values_str; bool expect_success; SpecIdToValueStrMap expected_map; }; using DefaultValuesStringParsingTest = ::testing::TestWithParam; TEST_P(DefaultValuesStringParsingTest, TestCase) { const auto& tc = GetParam(); auto actual_map = SetSpecConstantDefaultValuePass::ParseDefaultValuesString( tc.default_values_str); if (tc.expect_success) { EXPECT_NE(nullptr, actual_map); if (actual_map) { EXPECT_THAT(*actual_map, Eq(tc.expected_map)); } } else { EXPECT_EQ(nullptr, actual_map); } } INSTANTIATE_TEST_SUITE_P( ValidString, DefaultValuesStringParsingTest, ::testing::ValuesIn(std::vector{ // 0. empty map {"", true, SpecIdToValueStrMap{}}, // 1. one pair {"100:1024", true, SpecIdToValueStrMap{{100, "1024"}}}, // 2. two pairs {"100:1024 200:2048", true, SpecIdToValueStrMap{{100, "1024"}, {200, "2048"}}}, // 3. spaces between entries {"100:1024 \n \r \t \v \f 200:2048", true, SpecIdToValueStrMap{{100, "1024"}, {200, "2048"}}}, // 4. \t, \n, \r and spaces before spec id {" \n \r\t \t \v \f 100:1024", true, SpecIdToValueStrMap{{100, "1024"}}}, // 5. \t, \n, \r and spaces after value string {"100:1024 \n \r\t \t \v \f ", true, SpecIdToValueStrMap{{100, "1024"}}}, // 6. maximum spec id {"4294967295:0", true, SpecIdToValueStrMap{{4294967295, "0"}}}, // 7. minimum spec id {"0:100", true, SpecIdToValueStrMap{{0, "100"}}}, // 8. random content without spaces are allowed {"200:random_stuff", true, SpecIdToValueStrMap{{200, "random_stuff"}}}, // 9. support hex format spec id (just because we use the // ParseNumber() utility) {"0x100:1024", true, SpecIdToValueStrMap{{256, "1024"}}}, // 10. multiple entries {"101:1 102:2 103:3 104:4 200:201 9999:1000 0x100:333", true, SpecIdToValueStrMap{{101, "1"}, {102, "2"}, {103, "3"}, {104, "4"}, {200, "201"}, {9999, "1000"}, {256, "333"}}}, // 11. default value in hex float format {"100:0x0.3p10", true, SpecIdToValueStrMap{{100, "0x0.3p10"}}}, // 12. default value in decimal float format {"100:1.5e-13", true, SpecIdToValueStrMap{{100, "1.5e-13"}}}, })); INSTANTIATE_TEST_SUITE_P( InvalidString, DefaultValuesStringParsingTest, ::testing::ValuesIn(std::vector{ // 0. missing default value {"100:", false, SpecIdToValueStrMap{}}, // 1. spec id is not an integer {"100.0:200", false, SpecIdToValueStrMap{}}, // 2. spec id is not a number {"something_not_a_number:1", false, SpecIdToValueStrMap{}}, // 3. only spec id number {"100", false, SpecIdToValueStrMap{}}, // 4. same spec id defined multiple times {"100:20 100:21", false, SpecIdToValueStrMap{}}, // 5. Multiple definition of an identical spec id in different forms // is not allowed {"0x100:100 256:200", false, SpecIdToValueStrMap{}}, // 6. empty spec id {":3", false, SpecIdToValueStrMap{}}, // 7. only colon {":", false, SpecIdToValueStrMap{}}, // 8. spec id overflow {"4294967296:200", false, SpecIdToValueStrMap{}}, // 9. spec id less than 0 {"-1:200", false, SpecIdToValueStrMap{}}, // 10. nullptr {nullptr, false, SpecIdToValueStrMap{}}, // 11. only a number is invalid {"1234", false, SpecIdToValueStrMap{}}, // 12. invalid entry separator {"12:34;23:14", false, SpecIdToValueStrMap{}}, // 13. invalid spec id and default value separator {"12@34", false, SpecIdToValueStrMap{}}, // 14. spaces before colon {"100 :1024", false, SpecIdToValueStrMap{}}, // 15. spaces after colon {"100: 1024", false, SpecIdToValueStrMap{}}, // 16. spec id represented in hex float format is invalid {"0x3p10:200", false, SpecIdToValueStrMap{}}, })); struct SetSpecConstantDefaultValueInStringFormTestCase { const char* code; SpecIdToValueStrMap default_values; const char* expected; }; using SetSpecConstantDefaultValueInStringFormParamTest = PassTest< ::testing::TestWithParam>; TEST_P(SetSpecConstantDefaultValueInStringFormParamTest, TestCase) { const auto& tc = GetParam(); SinglePassRunAndCheck( tc.code, tc.expected, /* skip_nop = */ false, tc.default_values); } INSTANTIATE_TEST_SUITE_P( ValidCases, SetSpecConstantDefaultValueInStringFormParamTest, ::testing::ValuesIn(std::vector< SetSpecConstantDefaultValueInStringFormTestCase>{ // 0. Empty. {"", SpecIdToValueStrMap{}, ""}, // 1. Empty with non-empty values to set. {"", SpecIdToValueStrMap{{1, "100"}, {2, "200"}}, ""}, // 2. Bool type. { // code "OpDecorate %1 SpecId 100\n" "OpDecorate %2 SpecId 101\n" "%bool = OpTypeBool\n" "%1 = OpSpecConstantTrue %bool\n" "%2 = OpSpecConstantFalse %bool\n", // default values SpecIdToValueStrMap{{100, "false"}, {101, "true"}}, // expected "OpDecorate %1 SpecId 100\n" "OpDecorate %2 SpecId 101\n" "%bool = OpTypeBool\n" "%1 = OpSpecConstantFalse %bool\n" "%2 = OpSpecConstantTrue %bool\n", }, // 3. 32-bit int type. { // code "OpDecorate %1 SpecId 100\n" "OpDecorate %2 SpecId 101\n" "OpDecorate %3 SpecId 102\n" "%int = OpTypeInt 32 1\n" "%1 = OpSpecConstant %int 10\n" "%2 = OpSpecConstant %int 11\n" "%3 = OpSpecConstant %int 11\n", // default values SpecIdToValueStrMap{ {100, "2147483647"}, {101, "0xffffffff"}, {102, "-42"}}, // expected "OpDecorate %1 SpecId 100\n" "OpDecorate %2 SpecId 101\n" "OpDecorate %3 SpecId 102\n" "%int = OpTypeInt 32 1\n" "%1 = OpSpecConstant %int 2147483647\n" "%2 = OpSpecConstant %int -1\n" "%3 = OpSpecConstant %int -42\n", }, // 4. 64-bit uint type. { // code "OpDecorate %1 SpecId 100\n" "OpDecorate %2 SpecId 101\n" "%ulong = OpTypeInt 64 0\n" "%1 = OpSpecConstant %ulong 10\n" "%2 = OpSpecConstant %ulong 11\n", // default values SpecIdToValueStrMap{{100, "18446744073709551614"}, {101, "0x100"}}, // expected "OpDecorate %1 SpecId 100\n" "OpDecorate %2 SpecId 101\n" "%ulong = OpTypeInt 64 0\n" "%1 = OpSpecConstant %ulong 18446744073709551614\n" "%2 = OpSpecConstant %ulong 256\n", }, // 5. 32-bit float type. { // code "OpDecorate %1 SpecId 101\n" "OpDecorate %2 SpecId 102\n" "%float = OpTypeFloat 32\n" "%1 = OpSpecConstant %float 200\n" "%2 = OpSpecConstant %float 201\n", // default values SpecIdToValueStrMap{{101, "-0x1.fffffep+128"}, {102, "2.5"}}, // expected "OpDecorate %1 SpecId 101\n" "OpDecorate %2 SpecId 102\n" "%float = OpTypeFloat 32\n" "%1 = OpSpecConstant %float -0x1.fffffep+128\n" "%2 = OpSpecConstant %float 2.5\n", }, // 6. 64-bit float type. { // code "OpDecorate %1 SpecId 201\n" "OpDecorate %2 SpecId 202\n" "%double = OpTypeFloat 64\n" "%1 = OpSpecConstant %double 3.14159265358979\n" "%2 = OpSpecConstant %double 0.14285\n", // default values SpecIdToValueStrMap{{201, "0x1.fffffffffffffp+1024"}, {202, "-32.5"}}, // expected "OpDecorate %1 SpecId 201\n" "OpDecorate %2 SpecId 202\n" "%double = OpTypeFloat 64\n" "%1 = OpSpecConstant %double 0x1.fffffffffffffp+1024\n" "%2 = OpSpecConstant %double -32.5\n", }, // 7. SpecId not found, expect no modification. { // code "OpDecorate %1 SpecId 201\n" "%double = OpTypeFloat 64\n" "%1 = OpSpecConstant %double 3.14159265358979\n", // default values SpecIdToValueStrMap{{8888, "0.0"}}, // expected "OpDecorate %1 SpecId 201\n" "%double = OpTypeFloat 64\n" "%1 = OpSpecConstant %double 3.14159265358979\n", }, // 8. Multiple types of spec constants. { // code "OpDecorate %1 SpecId 201\n" "OpDecorate %2 SpecId 202\n" "OpDecorate %3 SpecId 203\n" "%bool = OpTypeBool\n" "%int = OpTypeInt 32 1\n" "%double = OpTypeFloat 64\n" "%1 = OpSpecConstant %double 3.14159265358979\n" "%2 = OpSpecConstant %int 1024\n" "%3 = OpSpecConstantTrue %bool\n", // default values SpecIdToValueStrMap{ {201, "0x1.fffffffffffffp+1024"}, {202, "2048"}, {203, "false"}, }, // expected "OpDecorate %1 SpecId 201\n" "OpDecorate %2 SpecId 202\n" "OpDecorate %3 SpecId 203\n" "%bool = OpTypeBool\n" "%int = OpTypeInt 32 1\n" "%double = OpTypeFloat 64\n" "%1 = OpSpecConstant %double 0x1.fffffffffffffp+1024\n" "%2 = OpSpecConstant %int 2048\n" "%3 = OpSpecConstantFalse %bool\n", }, // 9. Ignore other decorations. { // code "OpDecorate %1 ArrayStride 4\n" "%int = OpTypeInt 32 1\n" "%1 = OpSpecConstant %int 100\n", // default values SpecIdToValueStrMap{{4, "0x7fffffff"}}, // expected "OpDecorate %1 ArrayStride 4\n" "%int = OpTypeInt 32 1\n" "%1 = OpSpecConstant %int 100\n", }, // 10. Distinguish from other decorations. { // code "OpDecorate %1 SpecId 100\n" "OpDecorate %1 ArrayStride 4\n" "%int = OpTypeInt 32 1\n" "%1 = OpSpecConstant %int 100\n", // default values SpecIdToValueStrMap{{4, "0x7fffffff"}, {100, "0xffffffff"}}, // expected "OpDecorate %1 SpecId 100\n" "OpDecorate %1 ArrayStride 4\n" "%int = OpTypeInt 32 1\n" "%1 = OpSpecConstant %int -1\n", }, // 11. Decorate through decoration group. { // code "OpDecorate %1 SpecId 100\n" "%1 = OpDecorationGroup\n" "OpGroupDecorate %1 %2\n" "%int = OpTypeInt 32 1\n" "%2 = OpSpecConstant %int 100\n", // default values SpecIdToValueStrMap{{100, "0x7fffffff"}}, // expected "OpDecorate %1 SpecId 100\n" "%1 = OpDecorationGroup\n" "OpGroupDecorate %1 %2\n" "%int = OpTypeInt 32 1\n" "%2 = OpSpecConstant %int 2147483647\n", }, // 12. Ignore other decorations in decoration group. { // code "OpDecorate %1 ArrayStride 4\n" "%1 = OpDecorationGroup\n" "OpGroupDecorate %1 %2\n" "%int = OpTypeInt 32 1\n" "%2 = OpSpecConstant %int 100\n", // default values SpecIdToValueStrMap{{4, "0x7fffffff"}}, // expected "OpDecorate %1 ArrayStride 4\n" "%1 = OpDecorationGroup\n" "OpGroupDecorate %1 %2\n" "%int = OpTypeInt 32 1\n" "%2 = OpSpecConstant %int 100\n", }, // 13. Distinguish from other decorations in decoration group. { // code "OpDecorate %1 SpecId 100\n" "OpDecorate %1 ArrayStride 4\n" "%1 = OpDecorationGroup\n" "OpGroupDecorate %1 %2\n" "%int = OpTypeInt 32 1\n" "%2 = OpSpecConstant %int 100\n", // default values SpecIdToValueStrMap{{100, "0x7fffffff"}, {4, "0x00000001"}}, // expected "OpDecorate %1 SpecId 100\n" "OpDecorate %1 ArrayStride 4\n" "%1 = OpDecorationGroup\n" "OpGroupDecorate %1 %2\n" "%int = OpTypeInt 32 1\n" "%2 = OpSpecConstant %int 2147483647\n", }, // 14. Unchanged bool default value { // code "OpDecorate %1 SpecId 100\n" "OpDecorate %2 SpecId 101\n" "%bool = OpTypeBool\n" "%1 = OpSpecConstantTrue %bool\n" "%2 = OpSpecConstantFalse %bool\n", // default values SpecIdToValueStrMap{{100, "true"}, {101, "false"}}, // expected "OpDecorate %1 SpecId 100\n" "OpDecorate %2 SpecId 101\n" "%bool = OpTypeBool\n" "%1 = OpSpecConstantTrue %bool\n" "%2 = OpSpecConstantFalse %bool\n", }, // 15. Unchanged int default values { // code "OpDecorate %1 SpecId 100\n" "OpDecorate %2 SpecId 101\n" "%int = OpTypeInt 32 1\n" "%ulong = OpTypeInt 64 0\n" "%1 = OpSpecConstant %int 10\n" "%2 = OpSpecConstant %ulong 11\n", // default values SpecIdToValueStrMap{{100, "10"}, {101, "11"}}, // expected "OpDecorate %1 SpecId 100\n" "OpDecorate %2 SpecId 101\n" "%int = OpTypeInt 32 1\n" "%ulong = OpTypeInt 64 0\n" "%1 = OpSpecConstant %int 10\n" "%2 = OpSpecConstant %ulong 11\n", }, // 16. Unchanged float default values { // code "OpDecorate %1 SpecId 201\n" "OpDecorate %2 SpecId 202\n" "%float = OpTypeFloat 32\n" "%double = OpTypeFloat 64\n" "%1 = OpSpecConstant %float 3.1415\n" "%2 = OpSpecConstant %double 0.14285\n", // default values SpecIdToValueStrMap{{201, "3.1415"}, {202, "0.14285"}}, // expected "OpDecorate %1 SpecId 201\n" "OpDecorate %2 SpecId 202\n" "%float = OpTypeFloat 32\n" "%double = OpTypeFloat 64\n" "%1 = OpSpecConstant %float 3.1415\n" "%2 = OpSpecConstant %double 0.14285\n", }, // 17. OpGroupDecorate may have multiple target ids defined by the same // eligible spec constant { // code "OpDecorate %1 SpecId 100\n" "%1 = OpDecorationGroup\n" "OpGroupDecorate %1 %2 %2 %2\n" "%int = OpTypeInt 32 1\n" "%2 = OpSpecConstant %int 100\n", // default values SpecIdToValueStrMap{{100, "0xffffffff"}}, // expected "OpDecorate %1 SpecId 100\n" "%1 = OpDecorationGroup\n" "OpGroupDecorate %1 %2 %2 %2\n" "%int = OpTypeInt 32 1\n" "%2 = OpSpecConstant %int -1\n", }, })); INSTANTIATE_TEST_SUITE_P( InvalidCases, SetSpecConstantDefaultValueInStringFormParamTest, ::testing::ValuesIn(std::vector< SetSpecConstantDefaultValueInStringFormTestCase>{ // 0. Do not crash when decoration group is not used. { // code "OpDecorate %1 SpecId 100\n" "%1 = OpDecorationGroup\n" "%int = OpTypeInt 32 1\n" "%3 = OpSpecConstant %int 100\n", // default values SpecIdToValueStrMap{{100, "0x7fffffff"}}, // expected "OpDecorate %1 SpecId 100\n" "%1 = OpDecorationGroup\n" "%int = OpTypeInt 32 1\n" "%3 = OpSpecConstant %int 100\n", }, // 1. Do not crash when target does not exist. { // code "OpDecorate %1 SpecId 100\n" "%1 = OpDecorationGroup\n" "%int = OpTypeInt 32 1\n", // default values SpecIdToValueStrMap{{100, "0x7fffffff"}}, // expected "OpDecorate %1 SpecId 100\n" "%1 = OpDecorationGroup\n" "%int = OpTypeInt 32 1\n", }, // 2. Do nothing when SpecId decoration is not attached to a // non-spec-constant instruction. { // code "OpDecorate %1 SpecId 100\n" "%1 = OpDecorationGroup\n" "%int = OpTypeInt 32 1\n" "%int_101 = OpConstant %int 101\n", // default values SpecIdToValueStrMap{{100, "0x7fffffff"}}, // expected "OpDecorate %1 SpecId 100\n" "%1 = OpDecorationGroup\n" "%int = OpTypeInt 32 1\n" "%int_101 = OpConstant %int 101\n", }, // 3. Do nothing when SpecId decoration is not attached to a // OpSpecConstant{|True|False} instruction. { // code "OpDecorate %1 SpecId 100\n" "%int = OpTypeInt 32 1\n" "%3 = OpSpecConstant %int 101\n" "%1 = OpSpecConstantOp %int IAdd %3 %3\n", // default values SpecIdToValueStrMap{{100, "0x7fffffff"}}, // expected "OpDecorate %1 SpecId 100\n" "%int = OpTypeInt 32 1\n" "%3 = OpSpecConstant %int 101\n" "%1 = OpSpecConstantOp %int IAdd %3 %3\n", }, // 4. Do not crash and do nothing when SpecId decoration is applied to // multiple spec constants. { // code "OpDecorate %1 SpecId 100\n" "%1 = OpDecorationGroup\n" "OpGroupDecorate %1 %2 %3 %4\n" "%int = OpTypeInt 32 1\n" "%2 = OpSpecConstant %int 100\n" "%3 = OpSpecConstant %int 200\n" "%4 = OpSpecConstant %int 300\n", // default values SpecIdToValueStrMap{{100, "0xffffffff"}}, // expected "OpDecorate %1 SpecId 100\n" "%1 = OpDecorationGroup\n" "OpGroupDecorate %1 %2 %3 %4\n" "%int = OpTypeInt 32 1\n" "%2 = OpSpecConstant %int 100\n" "%3 = OpSpecConstant %int 200\n" "%4 = OpSpecConstant %int 300\n", }, // 5. Do not crash and do nothing when SpecId decoration is attached to // non-spec-constants (invalid case). { // code "OpDecorate %1 SpecId 100\n" "%1 = OpDecorationGroup\n" "%2 = OpDecorationGroup\n" "OpGroupDecorate %1 %2\n" "%int = OpTypeInt 32 1\n" "%int_100 = OpConstant %int 100\n", // default values SpecIdToValueStrMap{{100, "0xffffffff"}}, // expected "OpDecorate %1 SpecId 100\n" "%1 = OpDecorationGroup\n" "%2 = OpDecorationGroup\n" "OpGroupDecorate %1 %2\n" "%int = OpTypeInt 32 1\n" "%int_100 = OpConstant %int 100\n", }, // 6. Boolean type spec constant cannot be set with numeric values in // string form. i.e. only 'true' and 'false' are acceptable for setting // boolean type spec constants. Nothing should be done if numeric values // in string form are provided. { // code "OpDecorate %1 SpecId 100\n" "OpDecorate %2 SpecId 101\n" "OpDecorate %3 SpecId 102\n" "OpDecorate %4 SpecId 103\n" "OpDecorate %5 SpecId 104\n" "OpDecorate %6 SpecId 105\n" "%bool = OpTypeBool\n" "%1 = OpSpecConstantTrue %bool\n" "%2 = OpSpecConstantFalse %bool\n" "%3 = OpSpecConstantTrue %bool\n" "%4 = OpSpecConstantTrue %bool\n" "%5 = OpSpecConstantTrue %bool\n" "%6 = OpSpecConstantFalse %bool\n", // default values SpecIdToValueStrMap{{100, "0"}, {101, "1"}, {102, "0x0"}, {103, "0.0"}, {104, "-0.0"}, {105, "0x12345678"}}, // expected "OpDecorate %1 SpecId 100\n" "OpDecorate %2 SpecId 101\n" "OpDecorate %3 SpecId 102\n" "OpDecorate %4 SpecId 103\n" "OpDecorate %5 SpecId 104\n" "OpDecorate %6 SpecId 105\n" "%bool = OpTypeBool\n" "%1 = OpSpecConstantTrue %bool\n" "%2 = OpSpecConstantFalse %bool\n" "%3 = OpSpecConstantTrue %bool\n" "%4 = OpSpecConstantTrue %bool\n" "%5 = OpSpecConstantTrue %bool\n" "%6 = OpSpecConstantFalse %bool\n", }, })); struct SetSpecConstantDefaultValueInBitPatternFormTestCase { const char* code; SpecIdToValueBitPatternMap default_values; const char* expected; }; using SetSpecConstantDefaultValueInBitPatternFormParamTest = PassTest<::testing::TestWithParam< SetSpecConstantDefaultValueInBitPatternFormTestCase>>; TEST_P(SetSpecConstantDefaultValueInBitPatternFormParamTest, TestCase) { const auto& tc = GetParam(); SinglePassRunAndCheck( tc.code, tc.expected, /* skip_nop = */ false, tc.default_values); } INSTANTIATE_TEST_SUITE_P( ValidCases, SetSpecConstantDefaultValueInBitPatternFormParamTest, ::testing::ValuesIn(std::vector< SetSpecConstantDefaultValueInBitPatternFormTestCase>{ // 0. Empty. {"", SpecIdToValueBitPatternMap{}, ""}, // 1. Empty with non-empty values to set. {"", SpecIdToValueBitPatternMap{{1, {100}}, {2, {200}}}, ""}, // 2. Basic bool type. { // code "OpDecorate %1 SpecId 100\n" "OpDecorate %2 SpecId 101\n" "%bool = OpTypeBool\n" "%1 = OpSpecConstantTrue %bool\n" "%2 = OpSpecConstantFalse %bool\n", // default values SpecIdToValueBitPatternMap{{100, {0x0}}, {101, {0x1}}}, // expected "OpDecorate %1 SpecId 100\n" "OpDecorate %2 SpecId 101\n" "%bool = OpTypeBool\n" "%1 = OpSpecConstantFalse %bool\n" "%2 = OpSpecConstantTrue %bool\n", }, // 3. 32-bit int type. { // code "OpDecorate %1 SpecId 100\n" "OpDecorate %2 SpecId 101\n" "OpDecorate %3 SpecId 102\n" "%int = OpTypeInt 32 1\n" "%1 = OpSpecConstant %int 10\n" "%2 = OpSpecConstant %int 11\n" "%3 = OpSpecConstant %int 11\n", // default values SpecIdToValueBitPatternMap{ {100, {2147483647}}, {101, {0xffffffff}}, {102, {0xffffffd6}}}, // expected "OpDecorate %1 SpecId 100\n" "OpDecorate %2 SpecId 101\n" "OpDecorate %3 SpecId 102\n" "%int = OpTypeInt 32 1\n" "%1 = OpSpecConstant %int 2147483647\n" "%2 = OpSpecConstant %int -1\n" "%3 = OpSpecConstant %int -42\n", }, // 4. 64-bit uint type. { // code "OpDecorate %1 SpecId 100\n" "OpDecorate %2 SpecId 101\n" "%ulong = OpTypeInt 64 0\n" "%1 = OpSpecConstant %ulong 10\n" "%2 = OpSpecConstant %ulong 11\n", // default values SpecIdToValueBitPatternMap{{100, {0xFFFFFFFE, 0xFFFFFFFF}}, {101, {0x100, 0x0}}}, // expected "OpDecorate %1 SpecId 100\n" "OpDecorate %2 SpecId 101\n" "%ulong = OpTypeInt 64 0\n" "%1 = OpSpecConstant %ulong 18446744073709551614\n" "%2 = OpSpecConstant %ulong 256\n", }, // 5. 32-bit float type. { // code "OpDecorate %1 SpecId 101\n" "OpDecorate %2 SpecId 102\n" "%float = OpTypeFloat 32\n" "%1 = OpSpecConstant %float 200\n" "%2 = OpSpecConstant %float 201\n", // default values SpecIdToValueBitPatternMap{{101, {0xffffffff}}, {102, {0x40200000}}}, // expected "OpDecorate %1 SpecId 101\n" "OpDecorate %2 SpecId 102\n" "%float = OpTypeFloat 32\n" "%1 = OpSpecConstant %float -0x1.fffffep+128\n" "%2 = OpSpecConstant %float 2.5\n", }, // 6. 64-bit float type. { // code "OpDecorate %1 SpecId 201\n" "OpDecorate %2 SpecId 202\n" "%double = OpTypeFloat 64\n" "%1 = OpSpecConstant %double 3.14159265358979\n" "%2 = OpSpecConstant %double 0.14285\n", // default values SpecIdToValueBitPatternMap{{201, {0xffffffff, 0x7fffffff}}, {202, {0x00000000, 0xc0404000}}}, // expected "OpDecorate %1 SpecId 201\n" "OpDecorate %2 SpecId 202\n" "%double = OpTypeFloat 64\n" "%1 = OpSpecConstant %double 0x1.fffffffffffffp+1024\n" "%2 = OpSpecConstant %double -32.5\n", }, // 7. SpecId not found, expect no modification. { // code "OpDecorate %1 SpecId 201\n" "%double = OpTypeFloat 64\n" "%1 = OpSpecConstant %double 3.14159265358979\n", // default values SpecIdToValueBitPatternMap{{8888, {0x0}}}, // expected "OpDecorate %1 SpecId 201\n" "%double = OpTypeFloat 64\n" "%1 = OpSpecConstant %double 3.14159265358979\n", }, // 8. Multiple types of spec constants. { // code "OpDecorate %1 SpecId 201\n" "OpDecorate %2 SpecId 202\n" "OpDecorate %3 SpecId 203\n" "%bool = OpTypeBool\n" "%int = OpTypeInt 32 1\n" "%double = OpTypeFloat 64\n" "%1 = OpSpecConstant %double 3.14159265358979\n" "%2 = OpSpecConstant %int 1024\n" "%3 = OpSpecConstantTrue %bool\n", // default values SpecIdToValueBitPatternMap{ {201, {0xffffffff, 0x7fffffff}}, {202, {0x00000800}}, {203, {0x0}}, }, // expected "OpDecorate %1 SpecId 201\n" "OpDecorate %2 SpecId 202\n" "OpDecorate %3 SpecId 203\n" "%bool = OpTypeBool\n" "%int = OpTypeInt 32 1\n" "%double = OpTypeFloat 64\n" "%1 = OpSpecConstant %double 0x1.fffffffffffffp+1024\n" "%2 = OpSpecConstant %int 2048\n" "%3 = OpSpecConstantFalse %bool\n", }, // 9. Ignore other decorations. { // code "OpDecorate %1 ArrayStride 4\n" "%int = OpTypeInt 32 1\n" "%1 = OpSpecConstant %int 100\n", // default values SpecIdToValueBitPatternMap{{4, {0x7fffffff}}}, // expected "OpDecorate %1 ArrayStride 4\n" "%int = OpTypeInt 32 1\n" "%1 = OpSpecConstant %int 100\n", }, // 10. Distinguish from other decorations. { // code "OpDecorate %1 SpecId 100\n" "OpDecorate %1 ArrayStride 4\n" "%int = OpTypeInt 32 1\n" "%1 = OpSpecConstant %int 100\n", // default values SpecIdToValueBitPatternMap{{4, {0x7fffffff}}, {100, {0xffffffff}}}, // expected "OpDecorate %1 SpecId 100\n" "OpDecorate %1 ArrayStride 4\n" "%int = OpTypeInt 32 1\n" "%1 = OpSpecConstant %int -1\n", }, // 11. Decorate through decoration group. { // code "OpDecorate %1 SpecId 100\n" "%1 = OpDecorationGroup\n" "OpGroupDecorate %1 %2\n" "%int = OpTypeInt 32 1\n" "%2 = OpSpecConstant %int 100\n", // default values SpecIdToValueBitPatternMap{{100, {0x7fffffff}}}, // expected "OpDecorate %1 SpecId 100\n" "%1 = OpDecorationGroup\n" "OpGroupDecorate %1 %2\n" "%int = OpTypeInt 32 1\n" "%2 = OpSpecConstant %int 2147483647\n", }, // 12. Ignore other decorations in decoration group. { // code "OpDecorate %1 ArrayStride 4\n" "%1 = OpDecorationGroup\n" "OpGroupDecorate %1 %2\n" "%int = OpTypeInt 32 1\n" "%2 = OpSpecConstant %int 100\n", // default values SpecIdToValueBitPatternMap{{4, {0x7fffffff}}}, // expected "OpDecorate %1 ArrayStride 4\n" "%1 = OpDecorationGroup\n" "OpGroupDecorate %1 %2\n" "%int = OpTypeInt 32 1\n" "%2 = OpSpecConstant %int 100\n", }, // 13. Distinguish from other decorations in decoration group. { // code "OpDecorate %1 SpecId 100\n" "OpDecorate %1 ArrayStride 4\n" "%1 = OpDecorationGroup\n" "OpGroupDecorate %1 %2\n" "%int = OpTypeInt 32 1\n" "%2 = OpSpecConstant %int 100\n", // default values SpecIdToValueBitPatternMap{{100, {0x7fffffff}}, {4, {0x00000001}}}, // expected "OpDecorate %1 SpecId 100\n" "OpDecorate %1 ArrayStride 4\n" "%1 = OpDecorationGroup\n" "OpGroupDecorate %1 %2\n" "%int = OpTypeInt 32 1\n" "%2 = OpSpecConstant %int 2147483647\n", }, // 14. Unchanged bool default value { // code "OpDecorate %1 SpecId 100\n" "OpDecorate %2 SpecId 101\n" "%bool = OpTypeBool\n" "%1 = OpSpecConstantTrue %bool\n" "%2 = OpSpecConstantFalse %bool\n", // default values SpecIdToValueBitPatternMap{{100, {0x1}}, {101, {0x0}}}, // expected "OpDecorate %1 SpecId 100\n" "OpDecorate %2 SpecId 101\n" "%bool = OpTypeBool\n" "%1 = OpSpecConstantTrue %bool\n" "%2 = OpSpecConstantFalse %bool\n", }, // 15. Unchanged int default values { // code "OpDecorate %1 SpecId 100\n" "OpDecorate %2 SpecId 101\n" "%int = OpTypeInt 32 1\n" "%ulong = OpTypeInt 64 0\n" "%1 = OpSpecConstant %int 10\n" "%2 = OpSpecConstant %ulong 11\n", // default values SpecIdToValueBitPatternMap{{100, {10}}, {101, {11, 0}}}, // expected "OpDecorate %1 SpecId 100\n" "OpDecorate %2 SpecId 101\n" "%int = OpTypeInt 32 1\n" "%ulong = OpTypeInt 64 0\n" "%1 = OpSpecConstant %int 10\n" "%2 = OpSpecConstant %ulong 11\n", }, // 16. Unchanged float default values { // code "OpDecorate %1 SpecId 201\n" "OpDecorate %2 SpecId 202\n" "%float = OpTypeFloat 32\n" "%double = OpTypeFloat 64\n" "%1 = OpSpecConstant %float 3.25\n" "%2 = OpSpecConstant %double 1.25\n", // default values SpecIdToValueBitPatternMap{{201, {0x40500000}}, {202, {0x00000000, 0x3ff40000}}}, // expected "OpDecorate %1 SpecId 201\n" "OpDecorate %2 SpecId 202\n" "%float = OpTypeFloat 32\n" "%double = OpTypeFloat 64\n" "%1 = OpSpecConstant %float 3.25\n" "%2 = OpSpecConstant %double 1.25\n", }, // 17. OpGroupDecorate may have multiple target ids defined by the same // eligible spec constant { // code "OpDecorate %1 SpecId 100\n" "%1 = OpDecorationGroup\n" "OpGroupDecorate %1 %2 %2 %2\n" "%int = OpTypeInt 32 1\n" "%2 = OpSpecConstant %int 100\n", // default values SpecIdToValueBitPatternMap{{100, {0xffffffff}}}, // expected "OpDecorate %1 SpecId 100\n" "%1 = OpDecorationGroup\n" "OpGroupDecorate %1 %2 %2 %2\n" "%int = OpTypeInt 32 1\n" "%2 = OpSpecConstant %int -1\n", }, // 18. For Boolean type spec constants,if any word in the bit pattern // is not zero, it can be considered as a 'true', otherwise, it can be // considered as a 'false'. { // code "OpDecorate %1 SpecId 100\n" "OpDecorate %2 SpecId 101\n" "OpDecorate %3 SpecId 102\n" "%bool = OpTypeBool\n" "%1 = OpSpecConstantTrue %bool\n" "%2 = OpSpecConstantFalse %bool\n" "%3 = OpSpecConstantFalse %bool\n", // default values SpecIdToValueBitPatternMap{ {100, {0x0, 0x0, 0x0, 0x0}}, {101, {0x10101010}}, {102, {0x0, 0x0, 0x0, 0x2}}, }, // expected "OpDecorate %1 SpecId 100\n" "OpDecorate %2 SpecId 101\n" "OpDecorate %3 SpecId 102\n" "%bool = OpTypeBool\n" "%1 = OpSpecConstantFalse %bool\n" "%2 = OpSpecConstantTrue %bool\n" "%3 = OpSpecConstantTrue %bool\n", }, // 19. 16-bit signed int type. { // code "OpDecorate %1 SpecId 100\n" "OpDecorate %2 SpecId 101\n" "OpDecorate %3 SpecId 102\n" "%short = OpTypeInt 16 1\n" "%1 = OpSpecConstant %short 10\n" "%2 = OpSpecConstant %short 11\n" "%3 = OpSpecConstant %short 11\n", // default values SpecIdToValueBitPatternMap{ {100, {32767}}, {101, {0xffff}}, {102, {0xffffffd6}}}, // expected. These are sign-extended "OpDecorate %1 SpecId 100\n" "OpDecorate %2 SpecId 101\n" "OpDecorate %3 SpecId 102\n" "%short = OpTypeInt 16 1\n" "%1 = OpSpecConstant %short 32767\n" "%2 = OpSpecConstant %short -1\n" "%3 = OpSpecConstant %short -42\n", }, // 20. 16-bit unsigned int type. { // code "OpDecorate %1 SpecId 100\n" "OpDecorate %2 SpecId 101\n" "OpDecorate %3 SpecId 102\n" "%ushort = OpTypeInt 16 0\n" "%1 = OpSpecConstant %ushort 10\n" "%2 = OpSpecConstant %ushort 11\n" "%3 = OpSpecConstant %ushort 11\n", // default values SpecIdToValueBitPatternMap{ {100, {32767}}, {101, {0xffff}}, {102, {0xffffffd6}}}, // expected. Upper bits are always zero. "OpDecorate %1 SpecId 100\n" "OpDecorate %2 SpecId 101\n" "OpDecorate %3 SpecId 102\n" "%ushort = OpTypeInt 16 0\n" "%1 = OpSpecConstant %ushort 32767\n" "%2 = OpSpecConstant %ushort 65535\n" "%3 = OpSpecConstant %ushort 65494\n", }, // 21. 8-bit signed int type. { // code "OpDecorate %1 SpecId 100\n" "OpDecorate %2 SpecId 101\n" "OpDecorate %3 SpecId 102\n" "%char = OpTypeInt 8 1\n" "%1 = OpSpecConstant %char 10\n" "%2 = OpSpecConstant %char 11\n" "%3 = OpSpecConstant %char 11\n", // default values SpecIdToValueBitPatternMap{ {100, {127}}, {101, {128}}, {102, {0xd6}}}, // expected. These are sign extended "OpDecorate %1 SpecId 100\n" "OpDecorate %2 SpecId 101\n" "OpDecorate %3 SpecId 102\n" "%char = OpTypeInt 8 1\n" "%1 = OpSpecConstant %char 127\n" "%2 = OpSpecConstant %char -128\n" "%3 = OpSpecConstant %char -42\n", }, // 22. 8-bit unsigned int type. { // code "OpDecorate %1 SpecId 100\n" "OpDecorate %2 SpecId 101\n" "OpDecorate %3 SpecId 102\n" "OpDecorate %4 SpecId 103\n" "%uchar = OpTypeInt 8 0\n" "%1 = OpSpecConstant %uchar 10\n" "%2 = OpSpecConstant %uchar 11\n" "%3 = OpSpecConstant %uchar 11\n" "%4 = OpSpecConstant %uchar 11\n", // default values SpecIdToValueBitPatternMap{ {100, {127}}, {101, {128}}, {102, {256}}, {103, {0xffffffd6}}}, // expected. Upper bits are always zero. "OpDecorate %1 SpecId 100\n" "OpDecorate %2 SpecId 101\n" "OpDecorate %3 SpecId 102\n" "OpDecorate %4 SpecId 103\n" "%uchar = OpTypeInt 8 0\n" "%1 = OpSpecConstant %uchar 127\n" "%2 = OpSpecConstant %uchar 128\n" "%3 = OpSpecConstant %uchar 0\n" "%4 = OpSpecConstant %uchar 214\n", }, })); INSTANTIATE_TEST_SUITE_P( InvalidCases, SetSpecConstantDefaultValueInBitPatternFormParamTest, ::testing::ValuesIn(std::vector< SetSpecConstantDefaultValueInBitPatternFormTestCase>{ // 0. Do not crash when decoration group is not used. { // code "OpDecorate %1 SpecId 100\n" "%1 = OpDecorationGroup\n" "%int = OpTypeInt 32 1\n" "%3 = OpSpecConstant %int 100\n", // default values SpecIdToValueBitPatternMap{{100, {0x7fffffff}}}, // expected "OpDecorate %1 SpecId 100\n" "%1 = OpDecorationGroup\n" "%int = OpTypeInt 32 1\n" "%3 = OpSpecConstant %int 100\n", }, // 1. Do not crash when target does not exist. { // code "OpDecorate %1 SpecId 100\n" "%1 = OpDecorationGroup\n" "%int = OpTypeInt 32 1\n", // default values SpecIdToValueBitPatternMap{{100, {0x7fffffff}}}, // expected "OpDecorate %1 SpecId 100\n" "%1 = OpDecorationGroup\n" "%int = OpTypeInt 32 1\n", }, // 2. Do nothing when SpecId decoration is not attached to a // non-spec-constant instruction. { // code "OpDecorate %1 SpecId 100\n" "%1 = OpDecorationGroup\n" "%int = OpTypeInt 32 1\n" "%int_101 = OpConstant %int 101\n", // default values SpecIdToValueBitPatternMap{{100, {0x7fffffff}}}, // expected "OpDecorate %1 SpecId 100\n" "%1 = OpDecorationGroup\n" "%int = OpTypeInt 32 1\n" "%int_101 = OpConstant %int 101\n", }, // 3. Do nothing when SpecId decoration is not attached to a // OpSpecConstant{|True|False} instruction. { // code "OpDecorate %1 SpecId 100\n" "%int = OpTypeInt 32 1\n" "%3 = OpSpecConstant %int 101\n" "%1 = OpSpecConstantOp %int IAdd %3 %3\n", // default values SpecIdToValueBitPatternMap{{100, {0x7fffffff}}}, // expected "OpDecorate %1 SpecId 100\n" "%int = OpTypeInt 32 1\n" "%3 = OpSpecConstant %int 101\n" "%1 = OpSpecConstantOp %int IAdd %3 %3\n", }, // 4. Do not crash and do nothing when SpecId decoration is applied to // multiple spec constants. { // code "OpDecorate %1 SpecId 100\n" "%1 = OpDecorationGroup\n" "OpGroupDecorate %1 %2 %3 %4\n" "%int = OpTypeInt 32 1\n" "%2 = OpSpecConstant %int 100\n" "%3 = OpSpecConstant %int 200\n" "%4 = OpSpecConstant %int 300\n", // default values SpecIdToValueBitPatternMap{{100, {0xffffffff}}}, // expected "OpDecorate %1 SpecId 100\n" "%1 = OpDecorationGroup\n" "OpGroupDecorate %1 %2 %3 %4\n" "%int = OpTypeInt 32 1\n" "%2 = OpSpecConstant %int 100\n" "%3 = OpSpecConstant %int 200\n" "%4 = OpSpecConstant %int 300\n", }, // 5. Do not crash and do nothing when SpecId decoration is attached to // non-spec-constants (invalid case). { // code "OpDecorate %1 SpecId 100\n" "%1 = OpDecorationGroup\n" "%2 = OpDecorationGroup\n" "OpGroupDecorate %1 %2\n" "%int = OpTypeInt 32 1\n" "%int_100 = OpConstant %int 100\n", // default values SpecIdToValueBitPatternMap{{100, {0xffffffff}}}, // expected "OpDecorate %1 SpecId 100\n" "%1 = OpDecorationGroup\n" "%2 = OpDecorationGroup\n" "OpGroupDecorate %1 %2\n" "%int = OpTypeInt 32 1\n" "%int_100 = OpConstant %int 100\n", }, // 6. Incompatible input bit pattern with the type. Nothing should be // done in such a case. { // code "OpDecorate %1 SpecId 100\n" "OpDecorate %2 SpecId 101\n" "OpDecorate %3 SpecId 102\n" "%int = OpTypeInt 32 1\n" "%ulong = OpTypeInt 64 0\n" "%double = OpTypeFloat 64\n" "%1 = OpSpecConstant %int 100\n" "%2 = OpSpecConstant %ulong 200\n" "%3 = OpSpecConstant %double 3.141592653\n", // default values SpecIdToValueBitPatternMap{ {100, {10, 0}}, {101, {11}}, {102, {0xffffffff}}}, // expected "OpDecorate %1 SpecId 100\n" "OpDecorate %2 SpecId 101\n" "OpDecorate %3 SpecId 102\n" "%int = OpTypeInt 32 1\n" "%ulong = OpTypeInt 64 0\n" "%double = OpTypeFloat 64\n" "%1 = OpSpecConstant %int 100\n" "%2 = OpSpecConstant %ulong 200\n" "%3 = OpSpecConstant %double 3.141592653\n", }, })); } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/simplification_test.cpp000066400000000000000000000320041475742701700250660ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gmock/gmock.h" #include "source/opt/simplification_pass.h" #include "test/opt/pass_fixture.h" namespace spvtools { namespace opt { namespace { using SimplificationTest = PassTest<::testing::Test>; TEST_F(SimplificationTest, StraightLineTest) { // Testing that folding rules are combined in simple straight line code. const std::string text = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %i %o OpExecutionMode %main OriginUpperLeft OpSource GLSL 430 OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpName %main "main" OpName %i "i" OpName %o "o" OpDecorate %i Flat OpDecorate %i Location 0 OpDecorate %o Location 0 %void = OpTypeVoid %8 = OpTypeFunction %void %int = OpTypeInt 32 1 %v4int = OpTypeVector %int 4 %int_0 = OpConstant %int 0 %13 = OpConstantComposite %v4int %int_0 %int_0 %int_0 %int_0 %int_1 = OpConstant %int 1 %_ptr_Input_v4int = OpTypePointer Input %v4int %i = OpVariable %_ptr_Input_v4int Input %_ptr_Output_int = OpTypePointer Output %int %o = OpVariable %_ptr_Output_int Output %main = OpFunction %void None %8 %21 = OpLabel %31 = OpCompositeInsert %v4int %int_1 %13 0 ; CHECK: [[load:%[a-zA-Z_\d]+]] = OpLoad %23 = OpLoad %v4int %i %33 = OpCompositeInsert %v4int %int_0 %23 0 %35 = OpCompositeExtract %int %31 0 ; CHECK: [[extract:%[a-zA-Z_\d]+]] = OpCompositeExtract %int [[load]] 1 %37 = OpCompositeExtract %int %33 1 ; CHECK: [[add:%[a-zA-Z_\d]+]] = OpIAdd %int %int_1 [[extract]] %29 = OpIAdd %int %35 %37 OpStore %o %29 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(SimplificationTest, NewInstructionTest) { // Testing that new instructions are simplified. Specifically, // that the new add instruction generated by FactorAddMul is // further simplified by MergeGenericAddSub. const std::string text = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 430 OpName %main "main" %void = OpTypeVoid %4 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_int = OpTypePointer Function %int ; CHECK: [[mul:%[a-zA-Z_\d]+]] = OpIMul %int %13 %11 %main = OpFunction %void None %4 %7 = OpLabel %8 = OpVariable %_ptr_int Function %9 = OpVariable %_ptr_int Function %10 = OpVariable %_ptr_int Function %11 = OpLoad %int %8 %12 = OpLoad %int %9 %13 = OpLoad %int %10 %14 = OpISub %int %11 %12 %15 = OpIMul %int %13 %11 %16 = OpIMul %int %13 %12 %17 = OpIAdd %int %14 %15 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(SimplificationTest, AcrossBasicBlocks) { // Testing that folding rules are combined across basic blocks. const std::string text = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %i %o OpExecutionMode %main OriginUpperLeft OpSource GLSL 430 OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpName %main "main" OpName %i "i" OpName %o "o" OpDecorate %i Flat OpDecorate %i Location 0 OpDecorate %o Location 0 %void = OpTypeVoid %8 = OpTypeFunction %void %int = OpTypeInt 32 1 %v4int = OpTypeVector %int 4 %int_0 = OpConstant %int 0 %_ptr_Input_v4int = OpTypePointer Input %v4int %i = OpVariable %_ptr_Input_v4int Input %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Input_int = OpTypePointer Input %int %int_10 = OpConstant %int 10 %bool = OpTypeBool %int_1 = OpConstant %int 1 %_ptr_Output_int = OpTypePointer Output %int %o = OpVariable %_ptr_Output_int Output %main = OpFunction %void None %8 %24 = OpLabel ; CHECK: [[load:%[a-zA-Z_\d]+]] = OpLoad %v4int %i %25 = OpLoad %v4int %i %41 = OpCompositeInsert %v4int %int_0 %25 0 %27 = OpAccessChain %_ptr_Input_int %i %uint_0 %28 = OpLoad %int %27 %29 = OpSGreaterThan %bool %28 %int_10 OpSelectionMerge %30 None OpBranchConditional %29 %31 %32 %31 = OpLabel %43 = OpCopyObject %v4int %25 OpBranch %30 %32 = OpLabel %45 = OpCopyObject %v4int %25 OpBranch %30 %30 = OpLabel %50 = OpPhi %v4int %43 %31 %45 %32 ; CHECK: [[extract1:%[a-zA-Z_\d]+]] = OpCompositeExtract %int [[load]] 0 %47 = OpCompositeExtract %int %50 0 ; CHECK: [[extract2:%[a-zA-Z_\d]+]] = OpCompositeExtract %int [[load]] 1 %49 = OpCompositeExtract %int %41 1 ; CHECK: [[add:%[a-zA-Z_\d]+]] = OpIAdd %int [[extract1]] [[extract2]] %39 = OpIAdd %int %47 %49 OpStore %o %39 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(SimplificationTest, ThroughLoops) { // Testing that folding rules are applied multiple times to instructions // to be able to propagate across loop iterations. const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %o %i OpExecutionMode %main OriginUpperLeft OpSource GLSL 430 OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpName %main "main" OpName %o "o" OpName %i "i" OpDecorate %o Location 0 OpDecorate %i Flat OpDecorate %i Location 0 %void = OpTypeVoid %8 = OpTypeFunction %void %int = OpTypeInt 32 1 %v4int = OpTypeVector %int 4 %int_0 = OpConstant %int 0 ; CHECK: [[constant:%[a-zA-Z_\d]+]] = OpConstantComposite %v4int %int_0 %int_0 %int_0 %int_0 %13 = OpConstantComposite %v4int %int_0 %int_0 %int_0 %int_0 %bool = OpTypeBool %_ptr_Output_int = OpTypePointer Output %int %o = OpVariable %_ptr_Output_int Output %_ptr_Input_v4int = OpTypePointer Input %v4int %i = OpVariable %_ptr_Input_v4int Input %68 = OpUndef %v4int %main = OpFunction %void None %8 %23 = OpLabel ; CHECK: [[load:%[a-zA-Z_\d]+]] = OpLoad %v4int %i %load = OpLoad %v4int %i OpBranch %24 %24 = OpLabel %67 = OpPhi %v4int %load %23 %64 %26 ; CHECK: OpLoopMerge [[merge_lab:%[a-zA-Z_\d]+]] OpLoopMerge %25 %26 None OpBranch %27 %27 = OpLabel %48 = OpCompositeExtract %int %67 0 %30 = OpIEqual %bool %48 %int_0 OpBranchConditional %30 %31 %25 %31 = OpLabel %50 = OpCompositeExtract %int %67 0 %54 = OpCompositeExtract %int %67 1 %58 = OpCompositeExtract %int %67 2 %62 = OpCompositeExtract %int %67 3 %64 = OpCompositeConstruct %v4int %50 %54 %58 %62 OpBranch %26 %26 = OpLabel OpBranch %24 %25 = OpLabel ; CHECK: [[merge_lab]] = OpLabel ; CHECK: [[extract:%[a-zA-Z_\d]+]] = OpCompositeExtract %int [[load]] 0 %66 = OpCompositeExtract %int %67 0 ; CHECK-NEXT: OpStore %o [[extract]] OpStore %o %66 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, false); } TEST_F(SimplificationTest, CopyObjectWithDecorations1) { // Don't simplify OpCopyObject if the result id has a decoration that the // operand does not. const std::string text = R"(OpCapability Shader OpCapability ShaderNonUniform %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpDecorate %3 NonUniform %void = OpTypeVoid %5 = OpTypeFunction %void %int = OpTypeInt 32 1 %2 = OpFunction %void None %5 %7 = OpLabel %8 = OpUndef %int %3 = OpCopyObject %int %8 %9 = OpIAdd %int %3 %3 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(text, text, false); } TEST_F(SimplificationTest, CopyObjectWithDecorations2) { // Simplify OpCopyObject if the result id is a subset of the decorations of // the operand. const std::string before = R"(OpCapability Shader OpCapability ShaderNonUniform %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpDecorate %3 NonUniform %void = OpTypeVoid %5 = OpTypeFunction %void %int = OpTypeInt 32 1 %2 = OpFunction %void None %5 %7 = OpLabel %3 = OpUndef %int %8 = OpCopyObject %int %3 %9 = OpIAdd %int %8 %8 OpReturn OpFunctionEnd )"; const std::string after = R"(OpCapability Shader OpCapability ShaderNonUniform %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpDecorate %3 NonUniform %void = OpTypeVoid %5 = OpTypeFunction %void %int = OpTypeInt 32 1 %2 = OpFunction %void None %5 %7 = OpLabel %3 = OpUndef %int %9 = OpIAdd %int %3 %3 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(before, after, false); } TEST_F(SimplificationTest, DontMoveDecorations) { const std::string spirv = R"( ; CHECK-NOT: RelaxedPrecision ; CHECK: [[sub:%\w+]] = OpFSub ; CHECK: OpStore {{.*}} [[sub]] OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %add RelaxedPrecision OpDecorate %block Block OpMemberDecorate %block 0 Offset 0 OpMemberDecorate %block 1 Offset 4 OpDecorate %in DescriptorSet 0 OpDecorate %in Binding 0 OpDecorate %out DescriptorSet 0 OpDecorate %out Binding 1 %void = OpTypeVoid %float = OpTypeFloat 32 %void_fn = OpTypeFunction %void %block = OpTypeStruct %float %float %ptr_ssbo_block = OpTypePointer StorageBuffer %block %in = OpVariable %ptr_ssbo_block StorageBuffer %out = OpVariable %ptr_ssbo_block StorageBuffer %ptr_ssbo_float = OpTypePointer StorageBuffer %float %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %float_0 = OpConstant %float 0 %main = OpFunction %void None %void_fn %entry = OpLabel %in_gep_0 = OpAccessChain %ptr_ssbo_float %in %int_0 %in_gep_1 = OpAccessChain %ptr_ssbo_float %in %int_1 %load_0 = OpLoad %float %in_gep_0 %load_1 = OpLoad %float %in_gep_1 %sub = OpFSub %float %load_0 %load_1 %add = OpFAdd %float %float_0 %sub %out_gep_0 = OpAccessChain %ptr_ssbo_float %out %int_0 OpStore %out_gep_0 %add OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(spirv, true); } TEST_F(SimplificationTest, FunctionDeclaration) { // Make sure the pass works with a function declaration that is called. const std::string text = R"(OpCapability Addresses OpCapability Linkage OpCapability Kernel OpCapability Int8 %1 = OpExtInstImport "OpenCL.std" OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %2 "_Z23julia__1166_kernel_77094Bool" OpExecutionMode %2 ContractionOff OpSource Unknown 0 OpDecorate %3 LinkageAttributes "julia_error_7712" Import %void = OpTypeVoid %5 = OpTypeFunction %void %3 = OpFunction %void None %5 OpFunctionEnd %2 = OpFunction %void None %5 %6 = OpLabel %7 = OpFunctionCall %void %3 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(text, text, false); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/spread_volatile_semantics_test.cpp000066400000000000000000001242261475742701700273070ustar00rootroot00000000000000// Copyright (c) 2022 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { struct ExecutionModelAndBuiltIn { const char* execution_model; const char* built_in; const bool use_v4uint; }; using AddVolatileDecorationTest = PassTest<::testing::TestWithParam>; TEST_P(AddVolatileDecorationTest, InMain) { const auto& tc = GetParam(); const std::string execution_model(tc.execution_model); const std::string built_in(tc.built_in); const std::string var_type = tc.use_v4uint ? "%_ptr_Input_v4uint" : "%_ptr_Input_uint"; const std::string var_load_type = tc.use_v4uint ? "%v4uint" : "%uint"; const std::string text = std::string(R"(OpCapability RuntimeDescriptorArray OpCapability RayTracingKHR OpCapability SubgroupBallotKHR OpExtension "SPV_EXT_descriptor_indexing" OpExtension "SPV_KHR_ray_tracing" OpExtension "SPV_KHR_shader_ballot" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint )") + execution_model + std::string(R"( %main "main" %var OpSource GLSL 460 OpSourceExtension "GL_EXT_nonuniform_qualifier" OpSourceExtension "GL_KHR_ray_tracing" OpName %main "main" OpName %fn "fn" OpName %StorageBuffer "StorageBuffer" OpMemberName %StorageBuffer 0 "index" OpMemberName %StorageBuffer 1 "red" OpName %sbo "sbo" OpName %images "images" OpMemberDecorate %StorageBuffer 0 Offset 0 OpMemberDecorate %StorageBuffer 1 Offset 4 OpDecorate %StorageBuffer BufferBlock OpDecorate %sbo DescriptorSet 0 OpDecorate %sbo Binding 0 OpDecorate %images DescriptorSet 0 OpDecorate %images Binding 1 OpDecorate %images NonWritable )") + std::string(R"( ; CHECK: OpDecorate [[var:%\w+]] BuiltIn )") + built_in + std::string(R"( ; CHECK: OpDecorate [[var]] Volatile OpDecorate %var BuiltIn )") + built_in + std::string(R"( %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %float = OpTypeFloat 32 %StorageBuffer = OpTypeStruct %uint %float %_ptr_Uniform_StorageBuffer = OpTypePointer Uniform %StorageBuffer %sbo = OpVariable %_ptr_Uniform_StorageBuffer Uniform %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %13 = OpTypeImage %float 2D 0 0 0 2 Rgba32f %_runtimearr_13 = OpTypeRuntimeArray %13 %_ptr_UniformConstant__runtimearr_13 = OpTypePointer UniformConstant %_runtimearr_13 %images = OpVariable %_ptr_UniformConstant__runtimearr_13 UniformConstant %_ptr_Input_uint = OpTypePointer Input %uint %v4uint = OpTypeVector %uint 4 %_ptr_Input_v4uint = OpTypePointer Input %v4uint %var = OpVariable )") + var_type + std::string(R"( Input %int_0 = OpConstant %int 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_ptr_UniformConstant_13 = OpTypePointer UniformConstant %13 %v2int = OpTypeVector %int 2 %25 = OpConstantComposite %v2int %int_0 %int_0 %v4float = OpTypeVector %float 4 %uint_0 = OpConstant %uint 0 %_ptr_Uniform_float = OpTypePointer Uniform %float %main = OpFunction %void None %3 %5 = OpLabel %19 = OpAccessChain %_ptr_Uniform_uint %sbo %int_0 %20 = OpLoad %uint %19 %load = OpLoad )") + var_load_type + std::string(R"( %var %22 = OpAccessChain %_ptr_UniformConstant_13 %images %20 %23 = OpLoad %13 %22 %27 = OpImageRead %v4float %23 %25 %29 = OpCompositeExtract %float %27 0 %31 = OpAccessChain %_ptr_Uniform_float %sbo %int_1 OpStore %31 %29 %32 = OpFunctionCall %void %fn OpReturn OpFunctionEnd %fn = OpFunction %void None %3 %33 = OpLabel OpReturn OpFunctionEnd )"); SinglePassRunAndMatch(text, true); } INSTANTIATE_TEST_SUITE_P( AddVolatileDecoration, AddVolatileDecorationTest, ::testing::ValuesIn(std::vector{ {"RayGenerationKHR", "SubgroupSize", false}, {"RayGenerationKHR", "SubgroupLocalInvocationId", false}, {"RayGenerationKHR", "SubgroupEqMask", true}, {"ClosestHitKHR", "SubgroupLocalInvocationId", true}, {"IntersectionKHR", "SubgroupEqMask", true}, {"MissKHR", "SubgroupGeMask", true}, {"CallableKHR", "SubgroupGtMask", true}, {"RayGenerationKHR", "SubgroupLeMask", true}, })); using SetLoadVolatileTest = PassTest<::testing::TestWithParam>; TEST_P(SetLoadVolatileTest, InMain) { const auto& tc = GetParam(); const std::string execution_model(tc.execution_model); const std::string built_in(tc.built_in); const std::string var_type = tc.use_v4uint ? "%_ptr_Input_v4uint" : "%_ptr_Input_uint"; const std::string var_value = tc.use_v4uint ? std::string(R"( ; CHECK: [[ptr:%\w+]] = OpAccessChain %_ptr_Input_uint [[var]] %int_0 ; CHECK: OpLoad {{%\w+}} [[ptr]] Volatile %ptr = OpAccessChain %_ptr_Input_uint %var %int_0 %var_value = OpLoad %uint %ptr)") : std::string(R"( ; CHECK: OpLoad {{%\w+}} [[var]] Volatile %var_value = OpLoad %uint %var)"); const std::string text = std::string(R"(OpCapability RuntimeDescriptorArray OpCapability RayTracingKHR OpCapability SubgroupBallotKHR OpCapability VulkanMemoryModel OpExtension "SPV_KHR_vulkan_memory_model" OpExtension "SPV_EXT_descriptor_indexing" OpExtension "SPV_KHR_ray_tracing" OpExtension "SPV_KHR_shader_ballot" OpMemoryModel Logical Vulkan OpEntryPoint )") + execution_model + std::string(R"( %main "main" %var OpName %main "main" OpName %StorageBuffer "StorageBuffer" OpMemberName %StorageBuffer 0 "index" OpMemberName %StorageBuffer 1 "red" OpName %sbo "sbo" OpName %images "images" OpMemberDecorate %StorageBuffer 0 Offset 0 OpMemberDecorate %StorageBuffer 1 Offset 4 OpDecorate %StorageBuffer BufferBlock OpDecorate %sbo DescriptorSet 0 OpDecorate %sbo Binding 0 OpDecorate %images DescriptorSet 0 OpDecorate %images Binding 1 OpDecorate %images NonWritable )") + std::string(R"( ; CHECK: OpDecorate [[var:%\w+]] BuiltIn )") + built_in + std::string(R"( OpDecorate %var BuiltIn )") + built_in + std::string(R"( %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %float = OpTypeFloat 32 %StorageBuffer = OpTypeStruct %uint %float %_ptr_Uniform_StorageBuffer = OpTypePointer Uniform %StorageBuffer %sbo = OpVariable %_ptr_Uniform_StorageBuffer Uniform %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %13 = OpTypeImage %float 2D 0 0 0 2 Rgba32f %_runtimearr_13 = OpTypeRuntimeArray %13 %_ptr_UniformConstant__runtimearr_13 = OpTypePointer UniformConstant %_runtimearr_13 %images = OpVariable %_ptr_UniformConstant__runtimearr_13 UniformConstant %_ptr_Input_uint = OpTypePointer Input %uint %v4uint = OpTypeVector %uint 4 %_ptr_Input_v4uint = OpTypePointer Input %v4uint %var = OpVariable )") + var_type + std::string(R"( Input %int_0 = OpConstant %int 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_ptr_UniformConstant_13 = OpTypePointer UniformConstant %13 %v2int = OpTypeVector %int 2 %25 = OpConstantComposite %v2int %int_0 %int_0 %v4float = OpTypeVector %float 4 %uint_0 = OpConstant %uint 0 %_ptr_Uniform_float = OpTypePointer Uniform %float %main = OpFunction %void None %3 %5 = OpLabel %19 = OpAccessChain %_ptr_Uniform_uint %sbo %int_0 %20 = OpLoad %uint %19 )") + var_value + std::string(R"( %test = OpIAdd %uint %var_value %20 %22 = OpAccessChain %_ptr_UniformConstant_13 %images %test %23 = OpLoad %13 %22 %27 = OpImageRead %v4float %23 %25 %29 = OpCompositeExtract %float %27 0 %31 = OpAccessChain %_ptr_Uniform_float %sbo %int_1 OpStore %31 %29 OpReturn OpFunctionEnd )"); SinglePassRunAndMatch(text, true); } INSTANTIATE_TEST_SUITE_P( SetLoadVolatile, SetLoadVolatileTest, ::testing::ValuesIn(std::vector{ {"RayGenerationKHR", "SubgroupSize", false}, {"RayGenerationKHR", "SubgroupLocalInvocationId", false}, {"RayGenerationKHR", "SubgroupEqMask", true}, {"ClosestHitKHR", "SubgroupLocalInvocationId", true}, {"IntersectionKHR", "SubgroupEqMask", true}, {"MissKHR", "SubgroupGeMask", true}, {"CallableKHR", "SubgroupGtMask", true}, {"RayGenerationKHR", "SubgroupLeMask", true}, })); using VolatileSpreadTest = PassTest<::testing::Test>; TEST_F(VolatileSpreadTest, SpreadVolatileForHelperInvocation) { const std::string text = R"( OpCapability Shader OpCapability DemoteToHelperInvocation OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %var OpExecutionMode %main OriginUpperLeft ; CHECK: OpDecorate [[var:%\w+]] BuiltIn HelperInvocation ; CHECK: OpDecorate [[var]] Volatile OpDecorate %var BuiltIn HelperInvocation %bool = OpTypeBool %void = OpTypeVoid %void_fn = OpTypeFunction %void %_ptr_Input_bool = OpTypePointer Input %bool %var = OpVariable %_ptr_Input_bool Input %main = OpFunction %void None %void_fn %entry = OpLabel %load = OpLoad %bool %var OpDemoteToHelperInvocation OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_UNIVERSAL_1_6); SinglePassRunAndMatch(text, true); } TEST_F(VolatileSpreadTest, MultipleExecutionModel) { const std::string text = R"( OpCapability RuntimeDescriptorArray OpCapability RayTracingKHR OpCapability SubgroupBallotKHR OpExtension "SPV_EXT_descriptor_indexing" OpExtension "SPV_KHR_ray_tracing" OpExtension "SPV_KHR_shader_ballot" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint RayGenerationKHR %RayGeneration "RayGeneration" %var OpEntryPoint GLCompute %compute "Compute" %gl_LocalInvocationIndex OpExecutionMode %compute LocalSize 16 16 1 OpSource GLSL 460 OpSourceExtension "GL_EXT_nonuniform_qualifier" OpSourceExtension "GL_KHR_ray_tracing" OpName %RayGeneration "RayGeneration" OpName %StorageBuffer "StorageBuffer" OpMemberName %StorageBuffer 0 "index" OpMemberName %StorageBuffer 1 "red" OpName %sbo "sbo" OpName %images "images" OpMemberDecorate %StorageBuffer 0 Offset 0 OpMemberDecorate %StorageBuffer 1 Offset 4 OpDecorate %gl_LocalInvocationIndex BuiltIn LocalInvocationIndex OpDecorate %StorageBuffer BufferBlock OpDecorate %sbo DescriptorSet 0 OpDecorate %sbo Binding 0 OpDecorate %images DescriptorSet 0 OpDecorate %images Binding 1 OpDecorate %images NonWritable ; CHECK: OpEntryPoint RayGenerationKHR {{%\w+}} "RayGeneration" [[var:%\w+]] ; CHECK: OpDecorate [[var]] BuiltIn SubgroupSize ; CHECK: OpDecorate [[var]] Volatile ; CHECK-NOT: OpDecorate {{%\w+}} Volatile OpDecorate %var BuiltIn SubgroupSize %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %float = OpTypeFloat 32 %StorageBuffer = OpTypeStruct %uint %float %_ptr_Uniform_StorageBuffer = OpTypePointer Uniform %StorageBuffer %sbo = OpVariable %_ptr_Uniform_StorageBuffer Uniform %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %13 = OpTypeImage %float 2D 0 0 0 2 Rgba32f %_runtimearr_13 = OpTypeRuntimeArray %13 %_ptr_UniformConstant__runtimearr_13 = OpTypePointer UniformConstant %_runtimearr_13 %images = OpVariable %_ptr_UniformConstant__runtimearr_13 UniformConstant %_ptr_Input_uint = OpTypePointer Input %uint %var = OpVariable %_ptr_Input_uint Input %int_0 = OpConstant %int 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_ptr_UniformConstant_13 = OpTypePointer UniformConstant %13 %v2int = OpTypeVector %int 2 %25 = OpConstantComposite %v2int %int_0 %int_0 %v4float = OpTypeVector %float 4 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %_ptr_Uniform_float = OpTypePointer Uniform %float %gl_LocalInvocationIndex = OpVariable %_ptr_Input_uint Input %_ptr_Workgroup_uint = OpTypePointer Workgroup %uint %shared = OpVariable %_ptr_Workgroup_uint Workgroup %RayGeneration = OpFunction %void None %3 %5 = OpLabel %19 = OpAccessChain %_ptr_Uniform_uint %sbo %int_0 %20 = OpLoad %uint %var %22 = OpAccessChain %_ptr_UniformConstant_13 %images %20 %23 = OpLoad %13 %22 %27 = OpImageRead %v4float %23 %25 %29 = OpCompositeExtract %float %27 0 %31 = OpAccessChain %_ptr_Uniform_float %sbo %int_1 OpStore %31 %29 OpReturn OpFunctionEnd %compute = OpFunction %void None %3 %66 = OpLabel %62 = OpLoad %uint %gl_LocalInvocationIndex %61 = OpAtomicIAdd %uint %shared %uint_1 %uint_0 %62 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(VolatileSpreadTest, VarUsedInMultipleEntryPoints) { const std::string text = R"( OpCapability RuntimeDescriptorArray OpCapability RayTracingKHR OpCapability SubgroupBallotKHR OpExtension "SPV_EXT_descriptor_indexing" OpExtension "SPV_KHR_ray_tracing" OpExtension "SPV_KHR_shader_ballot" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint RayGenerationKHR %RayGeneration "RayGeneration" %var OpEntryPoint ClosestHitKHR %ClosestHit "ClosestHit" %var OpSource GLSL 460 OpSourceExtension "GL_EXT_nonuniform_qualifier" OpSourceExtension "GL_KHR_ray_tracing" OpName %RayGeneration "RayGeneration" OpName %ClosestHit "ClosestHit" OpName %StorageBuffer "StorageBuffer" OpMemberName %StorageBuffer 0 "index" OpMemberName %StorageBuffer 1 "red" OpName %sbo "sbo" OpName %images "images" OpMemberDecorate %StorageBuffer 0 Offset 0 OpMemberDecorate %StorageBuffer 1 Offset 4 OpDecorate %gl_LocalInvocationIndex BuiltIn LocalInvocationIndex OpDecorate %StorageBuffer BufferBlock OpDecorate %sbo DescriptorSet 0 OpDecorate %sbo Binding 0 OpDecorate %images DescriptorSet 0 OpDecorate %images Binding 1 OpDecorate %images NonWritable ; CHECK: OpEntryPoint RayGenerationKHR {{%\w+}} "RayGeneration" [[var:%\w+]] ; CHECK: OpEntryPoint ClosestHitKHR {{%\w+}} "ClosestHit" [[var]] ; CHECK: OpDecorate [[var]] BuiltIn SubgroupSize ; CHECK: OpDecorate [[var]] Volatile ; CHECK-NOT: OpDecorate {{%\w+}} Volatile OpDecorate %var BuiltIn SubgroupSize %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %float = OpTypeFloat 32 %StorageBuffer = OpTypeStruct %uint %float %_ptr_Uniform_StorageBuffer = OpTypePointer Uniform %StorageBuffer %sbo = OpVariable %_ptr_Uniform_StorageBuffer Uniform %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %13 = OpTypeImage %float 2D 0 0 0 2 Rgba32f %_runtimearr_13 = OpTypeRuntimeArray %13 %_ptr_UniformConstant__runtimearr_13 = OpTypePointer UniformConstant %_runtimearr_13 %images = OpVariable %_ptr_UniformConstant__runtimearr_13 UniformConstant %_ptr_Input_uint = OpTypePointer Input %uint %var = OpVariable %_ptr_Input_uint Input %int_0 = OpConstant %int 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_ptr_UniformConstant_13 = OpTypePointer UniformConstant %13 %v2int = OpTypeVector %int 2 %25 = OpConstantComposite %v2int %int_0 %int_0 %v4float = OpTypeVector %float 4 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %_ptr_Uniform_float = OpTypePointer Uniform %float %gl_LocalInvocationIndex = OpVariable %_ptr_Input_uint Input %_ptr_Workgroup_uint = OpTypePointer Workgroup %uint %shared = OpVariable %_ptr_Workgroup_uint Workgroup %RayGeneration = OpFunction %void None %3 %5 = OpLabel %19 = OpAccessChain %_ptr_Uniform_uint %sbo %int_0 %20 = OpLoad %uint %var %22 = OpAccessChain %_ptr_UniformConstant_13 %images %20 %23 = OpLoad %13 %22 %27 = OpImageRead %v4float %23 %25 %29 = OpCompositeExtract %float %27 0 %31 = OpAccessChain %_ptr_Uniform_float %sbo %int_1 OpStore %31 %29 OpReturn OpFunctionEnd %ClosestHit = OpFunction %void None %3 %45 = OpLabel %49 = OpAccessChain %_ptr_Uniform_uint %sbo %int_0 %40 = OpLoad %uint %var %42 = OpAccessChain %_ptr_UniformConstant_13 %images %40 %43 = OpLoad %13 %42 %47 = OpImageRead %v4float %43 %25 %59 = OpCompositeExtract %float %47 0 %51 = OpAccessChain %_ptr_Uniform_float %sbo %int_1 OpStore %51 %59 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } class VolatileSpreadErrorTest : public PassTest<::testing::Test> { public: VolatileSpreadErrorTest() : consumer_([this](spv_message_level_t level, const char*, const spv_position_t& position, const char* message) { if (!error_message_.empty()) error_message_ += "\n"; switch (level) { case SPV_MSG_FATAL: case SPV_MSG_INTERNAL_ERROR: case SPV_MSG_ERROR: error_message_ += "ERROR"; break; case SPV_MSG_WARNING: error_message_ += "WARNING"; break; case SPV_MSG_INFO: error_message_ += "INFO"; break; case SPV_MSG_DEBUG: error_message_ += "DEBUG"; break; } error_message_ += ": " + std::to_string(position.index) + ": " + message; }) {} Pass::Status RunPass(const std::string& text) { std::unique_ptr context_ = spvtools::BuildModule(SPV_ENV_UNIVERSAL_1_2, consumer_, text); if (!context_.get()) return Pass::Status::Failure; PassManager manager; manager.SetMessageConsumer(consumer_); manager.AddPass(); return manager.Run(context_.get()); } std::string GetErrorMessage() const { return error_message_; } void TearDown() override { error_message_.clear(); } private: spvtools::MessageConsumer consumer_; std::string error_message_; }; TEST_F(VolatileSpreadErrorTest, VarUsedInMultipleExecutionModelError) { const std::string text = R"( OpCapability RuntimeDescriptorArray OpCapability RayTracingKHR OpCapability SubgroupBallotKHR OpExtension "SPV_EXT_descriptor_indexing" OpExtension "SPV_KHR_ray_tracing" OpExtension "SPV_KHR_shader_ballot" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint RayGenerationKHR %RayGeneration "RayGeneration" %var OpEntryPoint GLCompute %compute "Compute" %gl_LocalInvocationIndex %var OpExecutionMode %compute LocalSize 16 16 1 OpSource GLSL 460 OpSourceExtension "GL_EXT_nonuniform_qualifier" OpSourceExtension "GL_KHR_ray_tracing" OpName %RayGeneration "RayGeneration" OpName %StorageBuffer "StorageBuffer" OpMemberName %StorageBuffer 0 "index" OpMemberName %StorageBuffer 1 "red" OpName %sbo "sbo" OpName %images "images" OpMemberDecorate %StorageBuffer 0 Offset 0 OpMemberDecorate %StorageBuffer 1 Offset 4 OpDecorate %gl_LocalInvocationIndex BuiltIn LocalInvocationIndex OpDecorate %StorageBuffer BufferBlock OpDecorate %sbo DescriptorSet 0 OpDecorate %sbo Binding 0 OpDecorate %images DescriptorSet 0 OpDecorate %images Binding 1 OpDecorate %images NonWritable OpDecorate %var BuiltIn SubgroupSize %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %float = OpTypeFloat 32 %StorageBuffer = OpTypeStruct %uint %float %_ptr_Uniform_StorageBuffer = OpTypePointer Uniform %StorageBuffer %sbo = OpVariable %_ptr_Uniform_StorageBuffer Uniform %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %13 = OpTypeImage %float 2D 0 0 0 2 Rgba32f %_runtimearr_13 = OpTypeRuntimeArray %13 %_ptr_UniformConstant__runtimearr_13 = OpTypePointer UniformConstant %_runtimearr_13 %images = OpVariable %_ptr_UniformConstant__runtimearr_13 UniformConstant %_ptr_Input_uint = OpTypePointer Input %uint %var = OpVariable %_ptr_Input_uint Input %int_0 = OpConstant %int 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_ptr_UniformConstant_13 = OpTypePointer UniformConstant %13 %v2int = OpTypeVector %int 2 %25 = OpConstantComposite %v2int %int_0 %int_0 %v4float = OpTypeVector %float 4 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %_ptr_Uniform_float = OpTypePointer Uniform %float %gl_LocalInvocationIndex = OpVariable %_ptr_Input_uint Input %_ptr_Workgroup_uint = OpTypePointer Workgroup %uint %shared = OpVariable %_ptr_Workgroup_uint Workgroup %RayGeneration = OpFunction %void None %3 %5 = OpLabel %19 = OpAccessChain %_ptr_Uniform_uint %sbo %int_0 %20 = OpLoad %uint %var %22 = OpAccessChain %_ptr_UniformConstant_13 %images %20 %23 = OpLoad %13 %22 %27 = OpImageRead %v4float %23 %25 %29 = OpCompositeExtract %float %27 0 %31 = OpAccessChain %_ptr_Uniform_float %sbo %int_1 OpStore %31 %29 OpReturn OpFunctionEnd %compute = OpFunction %void None %3 %66 = OpLabel %62 = OpLoad %uint %gl_LocalInvocationIndex %63 = OpLoad %uint %var %64 = OpIAdd %uint %62 %63 %61 = OpAtomicIAdd %uint %shared %uint_1 %uint_0 %64 OpReturn OpFunctionEnd )"; EXPECT_EQ(RunPass(text), Pass::Status::Failure); const char expected_error[] = "ERROR: 0: Variable is a target for Volatile semantics for an entry " "point, but it is not for another entry point"; EXPECT_STREQ(GetErrorMessage().substr(0, sizeof(expected_error) - 1).c_str(), expected_error); } TEST_F(VolatileSpreadErrorTest, VarUsedInMultipleReverseOrderExecutionModelError) { const std::string text = R"( OpCapability RuntimeDescriptorArray OpCapability RayTracingKHR OpCapability SubgroupBallotKHR OpExtension "SPV_EXT_descriptor_indexing" OpExtension "SPV_KHR_ray_tracing" OpExtension "SPV_KHR_shader_ballot" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %compute "Compute" %gl_LocalInvocationIndex %var OpEntryPoint RayGenerationKHR %RayGeneration "RayGeneration" %var OpExecutionMode %compute LocalSize 16 16 1 OpSource GLSL 460 OpSourceExtension "GL_EXT_nonuniform_qualifier" OpSourceExtension "GL_KHR_ray_tracing" OpName %RayGeneration "RayGeneration" OpName %StorageBuffer "StorageBuffer" OpMemberName %StorageBuffer 0 "index" OpMemberName %StorageBuffer 1 "red" OpName %sbo "sbo" OpName %images "images" OpMemberDecorate %StorageBuffer 0 Offset 0 OpMemberDecorate %StorageBuffer 1 Offset 4 OpDecorate %gl_LocalInvocationIndex BuiltIn LocalInvocationIndex OpDecorate %StorageBuffer BufferBlock OpDecorate %sbo DescriptorSet 0 OpDecorate %sbo Binding 0 OpDecorate %images DescriptorSet 0 OpDecorate %images Binding 1 OpDecorate %images NonWritable OpDecorate %var BuiltIn SubgroupSize %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %float = OpTypeFloat 32 %StorageBuffer = OpTypeStruct %uint %float %_ptr_Uniform_StorageBuffer = OpTypePointer Uniform %StorageBuffer %sbo = OpVariable %_ptr_Uniform_StorageBuffer Uniform %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %13 = OpTypeImage %float 2D 0 0 0 2 Rgba32f %_runtimearr_13 = OpTypeRuntimeArray %13 %_ptr_UniformConstant__runtimearr_13 = OpTypePointer UniformConstant %_runtimearr_13 %images = OpVariable %_ptr_UniformConstant__runtimearr_13 UniformConstant %_ptr_Input_uint = OpTypePointer Input %uint %var = OpVariable %_ptr_Input_uint Input %int_0 = OpConstant %int 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_ptr_UniformConstant_13 = OpTypePointer UniformConstant %13 %v2int = OpTypeVector %int 2 %25 = OpConstantComposite %v2int %int_0 %int_0 %v4float = OpTypeVector %float 4 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %_ptr_Uniform_float = OpTypePointer Uniform %float %gl_LocalInvocationIndex = OpVariable %_ptr_Input_uint Input %_ptr_Workgroup_uint = OpTypePointer Workgroup %uint %shared = OpVariable %_ptr_Workgroup_uint Workgroup %RayGeneration = OpFunction %void None %3 %5 = OpLabel %19 = OpAccessChain %_ptr_Uniform_uint %sbo %int_0 %20 = OpLoad %uint %var %22 = OpAccessChain %_ptr_UniformConstant_13 %images %20 %23 = OpLoad %13 %22 %27 = OpImageRead %v4float %23 %25 %29 = OpCompositeExtract %float %27 0 %31 = OpAccessChain %_ptr_Uniform_float %sbo %int_1 OpStore %31 %29 OpReturn OpFunctionEnd %compute = OpFunction %void None %3 %66 = OpLabel %62 = OpLoad %uint %gl_LocalInvocationIndex %63 = OpLoad %uint %var %64 = OpIAdd %uint %62 %63 %61 = OpAtomicIAdd %uint %shared %uint_1 %uint_0 %64 OpReturn OpFunctionEnd )"; EXPECT_EQ(RunPass(text), Pass::Status::Failure); const char expected_error[] = "ERROR: 0: Variable is a target for Volatile semantics for an entry " "point, but it is not for another entry point"; EXPECT_STREQ(GetErrorMessage().substr(0, sizeof(expected_error) - 1).c_str(), expected_error); } TEST_F(VolatileSpreadErrorTest, FunctionNotInlined) { const std::string text = R"( OpCapability RuntimeDescriptorArray OpCapability RayTracingKHR OpCapability SubgroupBallotKHR OpExtension "SPV_EXT_descriptor_indexing" OpExtension "SPV_KHR_ray_tracing" OpExtension "SPV_KHR_shader_ballot" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint RayGenerationKHR %RayGeneration "RayGeneration" %var OpEntryPoint ClosestHitKHR %ClosestHit "ClosestHit" %var OpSource GLSL 460 OpSourceExtension "GL_EXT_nonuniform_qualifier" OpSourceExtension "GL_KHR_ray_tracing" OpName %RayGeneration "RayGeneration" OpName %ClosestHit "ClosestHit" OpName %StorageBuffer "StorageBuffer" OpMemberName %StorageBuffer 0 "index" OpMemberName %StorageBuffer 1 "red" OpName %sbo "sbo" OpName %images "images" OpMemberDecorate %StorageBuffer 0 Offset 0 OpMemberDecorate %StorageBuffer 1 Offset 4 OpDecorate %gl_LocalInvocationIndex BuiltIn LocalInvocationIndex OpDecorate %StorageBuffer BufferBlock OpDecorate %sbo DescriptorSet 0 OpDecorate %sbo Binding 0 OpDecorate %images DescriptorSet 0 OpDecorate %images Binding 1 OpDecorate %images NonWritable OpDecorate %var BuiltIn SubgroupSize %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %float = OpTypeFloat 32 %StorageBuffer = OpTypeStruct %uint %float %_ptr_Uniform_StorageBuffer = OpTypePointer Uniform %StorageBuffer %sbo = OpVariable %_ptr_Uniform_StorageBuffer Uniform %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %13 = OpTypeImage %float 2D 0 0 0 2 Rgba32f %_runtimearr_13 = OpTypeRuntimeArray %13 %_ptr_UniformConstant__runtimearr_13 = OpTypePointer UniformConstant %_runtimearr_13 %images = OpVariable %_ptr_UniformConstant__runtimearr_13 UniformConstant %_ptr_Input_uint = OpTypePointer Input %uint %var = OpVariable %_ptr_Input_uint Input %int_0 = OpConstant %int 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_ptr_UniformConstant_13 = OpTypePointer UniformConstant %13 %v2int = OpTypeVector %int 2 %25 = OpConstantComposite %v2int %int_0 %int_0 %v4float = OpTypeVector %float 4 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %_ptr_Uniform_float = OpTypePointer Uniform %float %gl_LocalInvocationIndex = OpVariable %_ptr_Input_uint Input %_ptr_Workgroup_uint = OpTypePointer Workgroup %uint %shared = OpVariable %_ptr_Workgroup_uint Workgroup %RayGeneration = OpFunction %void None %3 %5 = OpLabel %19 = OpAccessChain %_ptr_Uniform_uint %sbo %int_0 %20 = OpLoad %uint %19 %22 = OpAccessChain %_ptr_UniformConstant_13 %images %20 %23 = OpLoad %13 %22 %27 = OpImageRead %v4float %23 %25 %29 = OpCompositeExtract %float %27 0 %31 = OpAccessChain %_ptr_Uniform_float %sbo %int_1 OpStore %31 %29 OpReturn OpFunctionEnd %NotInlined = OpFunction %void None %3 %32 = OpLabel OpReturn OpFunctionEnd %ClosestHit = OpFunction %void None %3 %45 = OpLabel %49 = OpAccessChain %_ptr_Uniform_uint %sbo %int_0 %40 = OpLoad %uint %49 %42 = OpAccessChain %_ptr_UniformConstant_13 %images %40 %43 = OpLoad %13 %42 %47 = OpImageRead %v4float %43 %25 %59 = OpCompositeExtract %float %47 0 %51 = OpAccessChain %_ptr_Uniform_float %sbo %int_1 OpStore %51 %59 OpReturn OpFunctionEnd )"; EXPECT_EQ(RunPass(text), Pass::Status::SuccessWithoutChange); } TEST_F(VolatileSpreadErrorTest, VarNotUsedInEntryPointForVolatile) { const std::string text = R"( OpCapability RuntimeDescriptorArray OpCapability RayTracingKHR OpCapability SubgroupBallotKHR OpExtension "SPV_EXT_descriptor_indexing" OpExtension "SPV_KHR_ray_tracing" OpExtension "SPV_KHR_shader_ballot" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint RayGenerationKHR %RayGeneration "RayGeneration" %var OpEntryPoint GLCompute %compute "Compute" %gl_LocalInvocationIndex %var OpExecutionMode %compute LocalSize 16 16 1 OpSource GLSL 460 OpSourceExtension "GL_EXT_nonuniform_qualifier" OpSourceExtension "GL_KHR_ray_tracing" OpName %RayGeneration "RayGeneration" OpName %StorageBuffer "StorageBuffer" OpMemberName %StorageBuffer 0 "index" OpMemberName %StorageBuffer 1 "red" OpName %sbo "sbo" OpName %images "images" OpMemberDecorate %StorageBuffer 0 Offset 0 OpMemberDecorate %StorageBuffer 1 Offset 4 OpDecorate %gl_LocalInvocationIndex BuiltIn LocalInvocationIndex OpDecorate %StorageBuffer BufferBlock OpDecorate %sbo DescriptorSet 0 OpDecorate %sbo Binding 0 OpDecorate %images DescriptorSet 0 OpDecorate %images Binding 1 OpDecorate %images NonWritable ; CHECK-NOT: OpDecorate {{%\w+}} Volatile OpDecorate %var BuiltIn SubgroupSize %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %float = OpTypeFloat 32 %StorageBuffer = OpTypeStruct %uint %float %_ptr_Uniform_StorageBuffer = OpTypePointer Uniform %StorageBuffer %sbo = OpVariable %_ptr_Uniform_StorageBuffer Uniform %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %13 = OpTypeImage %float 2D 0 0 0 2 Rgba32f %_runtimearr_13 = OpTypeRuntimeArray %13 %_ptr_UniformConstant__runtimearr_13 = OpTypePointer UniformConstant %_runtimearr_13 %images = OpVariable %_ptr_UniformConstant__runtimearr_13 UniformConstant %_ptr_Input_uint = OpTypePointer Input %uint %var = OpVariable %_ptr_Input_uint Input %int_0 = OpConstant %int 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_ptr_UniformConstant_13 = OpTypePointer UniformConstant %13 %v2int = OpTypeVector %int 2 %25 = OpConstantComposite %v2int %int_0 %int_0 %v4float = OpTypeVector %float 4 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %_ptr_Uniform_float = OpTypePointer Uniform %float %gl_LocalInvocationIndex = OpVariable %_ptr_Input_uint Input %_ptr_Workgroup_uint = OpTypePointer Workgroup %uint %shared = OpVariable %_ptr_Workgroup_uint Workgroup %RayGeneration = OpFunction %void None %3 %5 = OpLabel %19 = OpAccessChain %_ptr_Uniform_uint %sbo %int_0 %20 = OpLoad %uint %19 %22 = OpAccessChain %_ptr_UniformConstant_13 %images %20 %23 = OpLoad %13 %22 %27 = OpImageRead %v4float %23 %25 %29 = OpCompositeExtract %float %27 0 %31 = OpAccessChain %_ptr_Uniform_float %sbo %int_1 OpStore %31 %29 OpReturn OpFunctionEnd %compute = OpFunction %void None %3 %66 = OpLabel %62 = OpLoad %uint %gl_LocalInvocationIndex %63 = OpLoad %uint %var %64 = OpIAdd %uint %62 %63 %61 = OpAtomicIAdd %uint %shared %uint_1 %uint_0 %64 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(VolatileSpreadTest, RecursivelySpreadVolatile) { const std::string text = R"( OpCapability RuntimeDescriptorArray OpCapability RayTracingKHR OpCapability SubgroupBallotKHR OpCapability VulkanMemoryModel OpExtension "SPV_KHR_vulkan_memory_model" OpExtension "SPV_EXT_descriptor_indexing" OpExtension "SPV_KHR_ray_tracing" OpExtension "SPV_KHR_shader_ballot" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical Vulkan OpEntryPoint RayGenerationKHR %RayGeneration "RayGeneration" %var0 %var1 OpSource GLSL 460 OpSourceExtension "GL_EXT_nonuniform_qualifier" OpSourceExtension "GL_KHR_ray_tracing" OpName %RayGeneration "RayGeneration" OpName %StorageBuffer "StorageBuffer" OpMemberName %StorageBuffer 0 "index" OpMemberName %StorageBuffer 1 "red" OpName %sbo "sbo" OpName %images "images" OpMemberDecorate %StorageBuffer 0 Offset 0 OpMemberDecorate %StorageBuffer 1 Offset 4 OpDecorate %StorageBuffer BufferBlock OpDecorate %sbo DescriptorSet 0 OpDecorate %sbo Binding 0 OpDecorate %images DescriptorSet 0 OpDecorate %images Binding 1 OpDecorate %images NonWritable ; CHECK: OpDecorate [[var0:%\w+]] BuiltIn SubgroupEqMask ; CHECK: OpDecorate [[var1:%\w+]] BuiltIn SubgroupGeMask OpDecorate %var0 BuiltIn SubgroupEqMask OpDecorate %var1 BuiltIn SubgroupGeMask %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %float = OpTypeFloat 32 %StorageBuffer = OpTypeStruct %uint %float %_ptr_Uniform_StorageBuffer = OpTypePointer Uniform %StorageBuffer %sbo = OpVariable %_ptr_Uniform_StorageBuffer Uniform %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %13 = OpTypeImage %float 2D 0 0 0 2 Rgba32f %_runtimearr_13 = OpTypeRuntimeArray %13 %_ptr_UniformConstant__runtimearr_13 = OpTypePointer UniformConstant %_runtimearr_13 %images = OpVariable %_ptr_UniformConstant__runtimearr_13 UniformConstant %v4uint = OpTypeVector %uint 4 %_ptr_Input_v4uint = OpTypePointer Input %v4uint %_ptr_Input_uint = OpTypePointer Input %uint %var0 = OpVariable %_ptr_Input_v4uint Input %var1 = OpVariable %_ptr_Input_v4uint Input %int_0 = OpConstant %int 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_ptr_UniformConstant_13 = OpTypePointer UniformConstant %13 %v2int = OpTypeVector %int 2 %25 = OpConstantComposite %v2int %int_0 %int_0 %v4float = OpTypeVector %float 4 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %_ptr_Uniform_float = OpTypePointer Uniform %float %RayGeneration = OpFunction %void None %3 %5 = OpLabel ; CHECK: [[ptr0:%\w+]] = OpAccessChain %_ptr_Input_uint [[var0]] %int_0 ; CHECK: OpLoad {{%\w+}} [[ptr0]] Volatile %19 = OpAccessChain %_ptr_Input_uint %var0 %int_0 %20 = OpLoad %uint %19 %22 = OpAccessChain %_ptr_UniformConstant_13 %images %20 %23 = OpLoad %13 %22 %27 = OpImageRead %v4float %23 %25 %29 = OpCompositeExtract %float %27 0 %31 = OpAccessChain %_ptr_Uniform_float %sbo %uint_1 ; CHECK: OpLoad {{%\w+}} [[ptr0]] Volatile %24 = OpLoad %uint %19 ; CHECK: [[var2:%\w+]] = OpCopyObject %_ptr_Input_v4uint [[var0]] ; CHECK: [[ptr2:%\w+]] = OpAccessChain %_ptr_Input_uint [[var2]] %int_1 ; CHECK: OpLoad {{%\w+}} [[ptr2]] Volatile %18 = OpCopyObject %_ptr_Input_v4uint %var0 %21 = OpAccessChain %_ptr_Input_uint %18 %int_1 %26 = OpLoad %uint %21 %28 = OpIAdd %uint %24 %26 %30 = OpConvertUToF %float %28 ; CHECK: [[ptr1:%\w+]] = OpAccessChain %_ptr_Input_uint [[var1]] %int_1 ; CHECK: OpLoad {{%\w+}} [[ptr1]] Volatile %32 = OpAccessChain %_ptr_Input_uint %var1 %int_1 %33 = OpLoad %uint %32 %34 = OpConvertUToF %float %33 %35 = OpFAdd %float %34 %30 %36 = OpFAdd %float %35 %29 OpStore %31 %36 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(VolatileSpreadTest, SpreadVolatileOnlyForTargetEntryPoints) { const std::string text = R"( OpCapability RuntimeDescriptorArray OpCapability RayTracingKHR OpCapability SubgroupBallotKHR OpCapability VulkanMemoryModel OpCapability VulkanMemoryModelDeviceScopeKHR OpExtension "SPV_KHR_vulkan_memory_model" OpExtension "SPV_EXT_descriptor_indexing" OpExtension "SPV_KHR_ray_tracing" OpExtension "SPV_KHR_shader_ballot" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical Vulkan OpEntryPoint RayGenerationKHR %RayGeneration "RayGeneration" %var0 %var1 OpEntryPoint GLCompute %compute "Compute" %var0 %var1 OpExecutionMode %compute LocalSize 16 16 1 OpSource GLSL 460 OpSourceExtension "GL_EXT_nonuniform_qualifier" OpSourceExtension "GL_KHR_ray_tracing" OpName %RayGeneration "RayGeneration" OpName %StorageBuffer "StorageBuffer" OpMemberName %StorageBuffer 0 "index" OpMemberName %StorageBuffer 1 "red" OpName %sbo "sbo" OpName %images "images" OpMemberDecorate %StorageBuffer 0 Offset 0 OpMemberDecorate %StorageBuffer 1 Offset 4 OpDecorate %StorageBuffer BufferBlock OpDecorate %sbo DescriptorSet 0 OpDecorate %sbo Binding 0 OpDecorate %images DescriptorSet 0 OpDecorate %images Binding 1 OpDecorate %images NonWritable ; CHECK: OpDecorate [[var0:%\w+]] BuiltIn SubgroupEqMask ; CHECK: OpDecorate [[var1:%\w+]] BuiltIn SubgroupGeMask OpDecorate %var0 BuiltIn SubgroupEqMask OpDecorate %var1 BuiltIn SubgroupGeMask %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %float = OpTypeFloat 32 %StorageBuffer = OpTypeStruct %uint %float %_ptr_Uniform_StorageBuffer = OpTypePointer Uniform %StorageBuffer %sbo = OpVariable %_ptr_Uniform_StorageBuffer Uniform %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %13 = OpTypeImage %float 2D 0 0 0 2 Rgba32f %_runtimearr_13 = OpTypeRuntimeArray %13 %_ptr_UniformConstant__runtimearr_13 = OpTypePointer UniformConstant %_runtimearr_13 %images = OpVariable %_ptr_UniformConstant__runtimearr_13 UniformConstant %v4uint = OpTypeVector %uint 4 %_ptr_Input_v4uint = OpTypePointer Input %v4uint %_ptr_Input_uint = OpTypePointer Input %uint %var0 = OpVariable %_ptr_Input_v4uint Input %var1 = OpVariable %_ptr_Input_v4uint Input %int_0 = OpConstant %int 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_ptr_UniformConstant_13 = OpTypePointer UniformConstant %13 %v2int = OpTypeVector %int 2 %25 = OpConstantComposite %v2int %int_0 %int_0 %v4float = OpTypeVector %float 4 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %_ptr_Uniform_float = OpTypePointer Uniform %float %_ptr_Workgroup_uint = OpTypePointer Workgroup %uint %shared = OpVariable %_ptr_Workgroup_uint Workgroup %RayGeneration = OpFunction %void None %3 %5 = OpLabel ; CHECK: [[ptr0:%\w+]] = OpAccessChain %_ptr_Input_uint [[var0]] %int_0 ; CHECK: OpLoad {{%\w+}} [[ptr0]] Volatile %19 = OpAccessChain %_ptr_Input_uint %var0 %int_0 %20 = OpLoad %uint %19 %22 = OpAccessChain %_ptr_UniformConstant_13 %images %20 %23 = OpLoad %13 %22 %27 = OpImageRead %v4float %23 %25 %29 = OpCompositeExtract %float %27 0 %31 = OpAccessChain %_ptr_Uniform_float %sbo %uint_1 ; CHECK: OpLoad {{%\w+}} [[ptr0]] Volatile %24 = OpLoad %uint %19 ; CHECK: [[var2:%\w+]] = OpCopyObject %_ptr_Input_v4uint [[var0]] ; CHECK: [[ptr2:%\w+]] = OpAccessChain %_ptr_Input_uint [[var2]] %int_1 ; CHECK: OpLoad {{%\w+}} [[ptr2]] Volatile %18 = OpCopyObject %_ptr_Input_v4uint %var0 %21 = OpAccessChain %_ptr_Input_uint %18 %int_1 %26 = OpLoad %uint %21 %28 = OpIAdd %uint %24 %26 %30 = OpConvertUToF %float %28 ; CHECK: [[ptr1:%\w+]] = OpAccessChain %_ptr_Input_uint [[var1]] %int_1 ; CHECK: OpLoad {{%\w+}} [[ptr1]] Volatile %32 = OpAccessChain %_ptr_Input_uint %var1 %int_1 %33 = OpLoad %uint %32 %34 = OpConvertUToF %float %33 %35 = OpFAdd %float %34 %30 %36 = OpFAdd %float %35 %29 OpStore %31 %36 OpReturn OpFunctionEnd %compute = OpFunction %void None %3 %66 = OpLabel ; CHECK-NOT: OpLoad {{%\w+}} {{%\w+}} Volatile %62 = OpLoad %v4uint %var0 %63 = OpLoad %v4uint %var1 %64 = OpIAdd %v4uint %62 %63 %65 = OpCompositeExtract %uint %64 0 %61 = OpAtomicIAdd %uint %shared %uint_1 %uint_0 %65 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(VolatileSpreadTest, SkipIfItHasNoExecutionModel) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; Pass::Status status; std::tie(std::ignore, status) = SinglePassRunToBinary(text, /* skip_nop = */ false); EXPECT_EQ(status, Pass::Status::SuccessWithoutChange); } TEST_F(VolatileSpreadTest, NoInlinedfuncCalls) { const std::string text = R"( OpCapability RayTracingNV OpCapability VulkanMemoryModel OpCapability GroupNonUniform OpExtension "SPV_NV_ray_tracing" OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical Vulkan OpEntryPoint RayGenerationNV %main "main" %SubgroupSize OpSource HLSL 630 OpName %main "main" OpName %src_main "src.main" OpName %bb_entry "bb.entry" OpName %func0 "func0" OpName %bb_entry_0 "bb.entry" OpName %func2 "func2" OpName %bb_entry_1 "bb.entry" OpName %param_var_count "param.var.count" OpName %func1 "func1" OpName %bb_entry_2 "bb.entry" OpName %func3 "func3" OpName %count "count" OpName %bb_entry_3 "bb.entry" OpDecorate %SubgroupSize BuiltIn SubgroupSize %uint = OpTypeInt 32 0 %_ptr_Input_uint = OpTypePointer Input %uint %void = OpTypeVoid %6 = OpTypeFunction %void %_ptr_Function_uint = OpTypePointer Function %uint %25 = OpTypeFunction %void %_ptr_Function_uint %SubgroupSize = OpVariable %_ptr_Input_uint Input %main = OpFunction %void None %6 %7 = OpLabel %8 = OpFunctionCall %void %src_main OpReturn OpFunctionEnd %src_main = OpFunction %void None %6 %bb_entry = OpLabel %11 = OpFunctionCall %void %func0 OpReturn OpFunctionEnd %func0 = OpFunction %void DontInline %6 %bb_entry_0 = OpLabel %14 = OpFunctionCall %void %func2 %16 = OpFunctionCall %void %func1 OpReturn OpFunctionEnd %func2 = OpFunction %void DontInline %6 %bb_entry_1 = OpLabel %param_var_count = OpVariable %_ptr_Function_uint Function ; CHECK: {{%\w+}} = OpLoad %uint %SubgroupSize Volatile %21 = OpLoad %uint %SubgroupSize OpStore %param_var_count %21 %22 = OpFunctionCall %void %func3 %param_var_count OpReturn OpFunctionEnd %func1 = OpFunction %void DontInline %6 %bb_entry_2 = OpLabel OpReturn OpFunctionEnd %func3 = OpFunction %void DontInline %25 %count = OpFunctionParameter %_ptr_Function_uint %bb_entry_3 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(VolatileSpreadErrorTest, NoInlinedMultiEntryfuncCalls) { const std::string text = R"( OpCapability RayTracingNV OpCapability SubgroupBallotKHR OpExtension "SPV_NV_ray_tracing" OpExtension "SPV_KHR_shader_ballot" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint RayGenerationNV %main "main" %SubgroupSize OpEntryPoint GLCompute %main2 "main2" %gl_LocalInvocationIndex %SubgroupSize OpSource HLSL 630 OpName %main "main" OpName %bb_entry "bb.entry" OpName %main2 "main2" OpName %bb_entry_0 "bb.entry" OpName %func "func" OpName %count "count" OpName %bb_entry_1 "bb.entry" OpDecorate %gl_LocalInvocationIndex BuiltIn LocalInvocationIndex OpDecorate %SubgroupSize BuiltIn SubgroupSize %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Input_uint = OpTypePointer Input %uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %void = OpTypeVoid %12 = OpTypeFunction %void %_ptr_Function_uint = OpTypePointer Function %uint %_ptr_Function_v4float = OpTypePointer Function %v4float %29 = OpTypeFunction %void %_ptr_Function_v4float %34 = OpTypeFunction %void %_ptr_Function_uint %SubgroupSize = OpVariable %_ptr_Input_uint Input %gl_LocalInvocationIndex = OpVariable %_ptr_Input_uint Input %main = OpFunction %void None %12 %bb_entry = OpLabel %20 = OpFunctionCall %void %func OpReturn OpFunctionEnd %main2 = OpFunction %void None %12 %bb_entry_0 = OpLabel %33 = OpFunctionCall %void %func OpReturn OpFunctionEnd %func = OpFunction %void DontInline %12 %bb_entry_1 = OpLabel %count = OpVariable %_ptr_Function_uint Function %35 = OpLoad %uint %SubgroupSize OpStore %count %35 OpReturn OpFunctionEnd )"; EXPECT_EQ(RunPass(text), Pass::Status::Failure); const char expected_error[] = "ERROR: 0: Variable is a target for Volatile semantics for an entry " "point, but it is not for another entry point"; EXPECT_STREQ(GetErrorMessage().substr(0, sizeof(expected_error) - 1).c_str(), expected_error); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/strength_reduction_test.cpp000066400000000000000000000400011475742701700257620ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include "gmock/gmock.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using ::testing::HasSubstr; using ::testing::MatchesRegex; using StrengthReductionBasicTest = PassTest<::testing::Test>; // Test to make sure we replace 5*8. TEST_F(StrengthReductionBasicTest, BasicReplaceMulBy8) { const std::vector text = { // clang-format off "OpCapability Shader", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Vertex %main \"main\"", "OpName %main \"main\"", "%void = OpTypeVoid", "%4 = OpTypeFunction %void", "%uint = OpTypeInt 32 0", "%uint_5 = OpConstant %uint 5", "%uint_8 = OpConstant %uint 8", "%main = OpFunction %void None %4", "%8 = OpLabel", "%9 = OpIMul %uint %uint_5 %uint_8", "OpReturn", "OpFunctionEnd" // clang-format on }; auto result = SinglePassRunAndDisassemble( JoinAllInsts(text), /* skip_nop = */ true, /* do_validation = */ false); EXPECT_EQ(Pass::Status::SuccessWithChange, std::get<1>(result)); const std::string& output = std::get<0>(result); EXPECT_THAT(output, Not(HasSubstr("OpIMul"))); EXPECT_THAT(output, HasSubstr("OpShiftLeftLogical %uint %uint_5 %uint_3")); } // TODO(dneto): Add Effcee as required dependency, and make this unconditional. // Test to make sure we replace 16*5 // Also demonstrate use of Effcee matching. TEST_F(StrengthReductionBasicTest, BasicReplaceMulBy16) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpName %main "main" %void = OpTypeVoid %4 = OpTypeFunction %void ; We know disassembly will produce %uint here, but ; CHECK: %uint = OpTypeInt 32 0 ; CHECK-DAG: [[five:%[a-zA-Z_\d]+]] = OpConstant %uint 5 ; We have RE2 regular expressions, so \w matches [_a-zA-Z0-9]. ; This shows the preferred pattern for matching SPIR-V identifiers. ; (We could have cheated in this case since we know the disassembler will ; generate the 'nice' name of "%uint_4". ; CHECK-DAG: [[four:%\w+]] = OpConstant %uint 4 %uint = OpTypeInt 32 0 %uint_5 = OpConstant %uint 5 %uint_16 = OpConstant %uint 16 %main = OpFunction %void None %4 ; CHECK: OpLabel %8 = OpLabel ; CHECK-NEXT: OpShiftLeftLogical %uint [[five]] [[four]] ; The multiplication disappears. ; CHECK-NOT: OpIMul %9 = OpIMul %uint %uint_16 %uint_5 OpReturn ; CHECK: OpFunctionEnd OpFunctionEnd)"; SinglePassRunAndMatch(text, false); } // Test to make sure we replace a multiple of 32 and 4. TEST_F(StrengthReductionBasicTest, BasicTwoPowersOf2) { // In this case, we have two powers of 2. Need to make sure we replace only // one of them for the bit shift. // clang-format off const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpName %main "main" %void = OpTypeVoid %4 = OpTypeFunction %void %int = OpTypeInt 32 1 %int_32 = OpConstant %int 32 %int_4 = OpConstant %int 4 %main = OpFunction %void None %4 %8 = OpLabel %9 = OpIMul %int %int_32 %int_4 OpReturn OpFunctionEnd )"; // clang-format on auto result = SinglePassRunAndDisassemble( text, /* skip_nop = */ true, /* do_validation = */ false); EXPECT_EQ(Pass::Status::SuccessWithChange, std::get<1>(result)); const std::string& output = std::get<0>(result); EXPECT_THAT(output, Not(HasSubstr("OpIMul"))); EXPECT_THAT(output, HasSubstr("OpShiftLeftLogical %int %int_4 %uint_5")); } // Test to make sure we don't replace 0*5. TEST_F(StrengthReductionBasicTest, BasicDontReplace0) { const std::vector text = { // clang-format off "OpCapability Shader", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Vertex %main \"main\"", "OpName %main \"main\"", "%void = OpTypeVoid", "%4 = OpTypeFunction %void", "%int = OpTypeInt 32 1", "%int_0 = OpConstant %int 0", "%int_5 = OpConstant %int 5", "%main = OpFunction %void None %4", "%8 = OpLabel", "%9 = OpIMul %int %int_0 %int_5", "OpReturn", "OpFunctionEnd" // clang-format on }; auto result = SinglePassRunAndDisassemble( JoinAllInsts(text), /* skip_nop = */ true, /* do_validation = */ false); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } // Test to make sure we do not replace a multiple of 5 and 7. TEST_F(StrengthReductionBasicTest, BasicNoChange) { const std::vector text = { // clang-format off "OpCapability Shader", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Vertex %2 \"main\"", "OpName %2 \"main\"", "%3 = OpTypeVoid", "%4 = OpTypeFunction %3", "%5 = OpTypeInt 32 1", "%6 = OpTypeInt 32 0", "%7 = OpConstant %5 5", "%8 = OpConstant %5 7", "%2 = OpFunction %3 None %4", "%9 = OpLabel", "%10 = OpIMul %5 %7 %8", "OpReturn", "OpFunctionEnd", // clang-format on }; auto result = SinglePassRunAndDisassemble( JoinAllInsts(text), /* skip_nop = */ true, /* do_validation = */ false); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } // Test to make sure constants and types are reused and not duplicated. TEST_F(StrengthReductionBasicTest, NoDuplicateConstantsAndTypes) { const std::vector text = { // clang-format off "OpCapability Shader", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Vertex %main \"main\"", "OpName %main \"main\"", "%void = OpTypeVoid", "%4 = OpTypeFunction %void", "%uint = OpTypeInt 32 0", "%uint_8 = OpConstant %uint 8", "%uint_3 = OpConstant %uint 3", "%main = OpFunction %void None %4", "%8 = OpLabel", "%9 = OpIMul %uint %uint_8 %uint_3", "OpReturn", "OpFunctionEnd", // clang-format on }; auto result = SinglePassRunAndDisassemble( JoinAllInsts(text), /* skip_nop = */ true, /* do_validation = */ false); EXPECT_EQ(Pass::Status::SuccessWithChange, std::get<1>(result)); const std::string& output = std::get<0>(result); EXPECT_THAT(output, Not(MatchesRegex(".*OpConstant %uint 3.*OpConstant %uint 3.*"))); EXPECT_THAT(output, Not(MatchesRegex(".*OpTypeInt 32 0.*OpTypeInt 32 0.*"))); } // Test to make sure we generate the constants only once TEST_F(StrengthReductionBasicTest, BasicCreateOneConst) { const std::vector text = { // clang-format off "OpCapability Shader", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Vertex %main \"main\"", "OpName %main \"main\"", "%void = OpTypeVoid", "%4 = OpTypeFunction %void", "%uint = OpTypeInt 32 0", "%uint_5 = OpConstant %uint 5", "%uint_9 = OpConstant %uint 9", "%uint_128 = OpConstant %uint 128", "%main = OpFunction %void None %4", "%8 = OpLabel", "%9 = OpIMul %uint %uint_5 %uint_128", "%10 = OpIMul %uint %uint_9 %uint_128", "OpReturn", "OpFunctionEnd" // clang-format on }; auto result = SinglePassRunAndDisassemble( JoinAllInsts(text), /* skip_nop = */ true, /* do_validation = */ false); EXPECT_EQ(Pass::Status::SuccessWithChange, std::get<1>(result)); const std::string& output = std::get<0>(result); EXPECT_THAT(output, Not(HasSubstr("OpIMul"))); EXPECT_THAT(output, HasSubstr("OpShiftLeftLogical %uint %uint_5 %uint_7")); EXPECT_THAT(output, HasSubstr("OpShiftLeftLogical %uint %uint_9 %uint_7")); } // Test to make sure we generate the instructions in the correct position and // that the uses get replaced as well. Here we check that the use in the return // is replaced, we also check that we can replace two OpIMuls when one feeds the // other. TEST_F(StrengthReductionBasicTest, BasicCheckPositionAndReplacement) { // This is just the preamble to set up the test. const std::vector common_text = { // clang-format off "OpCapability Shader", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Fragment %main \"main\" %gl_FragColor", "OpExecutionMode %main OriginUpperLeft", "OpName %main \"main\"", "OpName %foo_i1_ \"foo(i1;\"", "OpName %n \"n\"", "OpName %gl_FragColor \"gl_FragColor\"", "OpName %param \"param\"", "OpDecorate %gl_FragColor Location 0", "%void = OpTypeVoid", "%3 = OpTypeFunction %void", "%int = OpTypeInt 32 1", "%_ptr_Function_int = OpTypePointer Function %int", "%8 = OpTypeFunction %int %_ptr_Function_int", "%int_256 = OpConstant %int 256", "%int_2 = OpConstant %int 2", "%float = OpTypeFloat 32", "%v4float = OpTypeVector %float 4", "%_ptr_Output_v4float = OpTypePointer Output %v4float", "%gl_FragColor = OpVariable %_ptr_Output_v4float Output", "%float_1 = OpConstant %float 1", "%int_10 = OpConstant %int 10", "%float_0_375 = OpConstant %float 0.375", "%float_0_75 = OpConstant %float 0.75", "%uint = OpTypeInt 32 0", "%uint_8 = OpConstant %uint 8", "%uint_1 = OpConstant %uint 1", "%main = OpFunction %void None %3", "%5 = OpLabel", "%param = OpVariable %_ptr_Function_int Function", "OpStore %param %int_10", "%26 = OpFunctionCall %int %foo_i1_ %param", "%27 = OpConvertSToF %float %26", "%28 = OpFDiv %float %float_1 %27", "%31 = OpCompositeConstruct %v4float %28 %float_0_375 %float_0_75 %float_1", "OpStore %gl_FragColor %31", "OpReturn", "OpFunctionEnd" // clang-format on }; // This is the real test. The two OpIMul should be replaced. The expected // output is in |foo_after|. const std::vector foo_before = { // clang-format off "%foo_i1_ = OpFunction %int None %8", "%n = OpFunctionParameter %_ptr_Function_int", "%11 = OpLabel", "%12 = OpLoad %int %n", "%14 = OpIMul %int %12 %int_256", "%16 = OpIMul %int %14 %int_2", "OpReturnValue %16", "OpFunctionEnd", // clang-format on }; const std::vector foo_after = { // clang-format off "%foo_i1_ = OpFunction %int None %8", "%n = OpFunctionParameter %_ptr_Function_int", "%11 = OpLabel", "%12 = OpLoad %int %n", "%33 = OpShiftLeftLogical %int %12 %uint_8", "%34 = OpShiftLeftLogical %int %33 %uint_1", "OpReturnValue %34", "OpFunctionEnd", // clang-format on }; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck( JoinAllInsts(Concat(common_text, foo_before)), JoinAllInsts(Concat(common_text, foo_after)), /* skip_nop = */ true, /* do_validate = */ true); } // Test that, when the result of an OpIMul instruction has more than 1 use, and // the instruction is replaced, all of the uses of the results are replace with // the new result. TEST_F(StrengthReductionBasicTest, BasicTestMultipleReplacements) { // This is just the preamble to set up the test. const std::vector common_text = { // clang-format off "OpCapability Shader", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Fragment %main \"main\" %gl_FragColor", "OpExecutionMode %main OriginUpperLeft", "OpName %main \"main\"", "OpName %foo_i1_ \"foo(i1;\"", "OpName %n \"n\"", "OpName %gl_FragColor \"gl_FragColor\"", "OpName %param \"param\"", "OpDecorate %gl_FragColor Location 0", "%void = OpTypeVoid", "%3 = OpTypeFunction %void", "%int = OpTypeInt 32 1", "%_ptr_Function_int = OpTypePointer Function %int", "%8 = OpTypeFunction %int %_ptr_Function_int", "%int_256 = OpConstant %int 256", "%int_2 = OpConstant %int 2", "%float = OpTypeFloat 32", "%v4float = OpTypeVector %float 4", "%_ptr_Output_v4float = OpTypePointer Output %v4float", "%gl_FragColor = OpVariable %_ptr_Output_v4float Output", "%float_1 = OpConstant %float 1", "%int_10 = OpConstant %int 10", "%float_0_375 = OpConstant %float 0.375", "%float_0_75 = OpConstant %float 0.75", "%uint = OpTypeInt 32 0", "%uint_8 = OpConstant %uint 8", "%uint_1 = OpConstant %uint 1", "%main = OpFunction %void None %3", "%5 = OpLabel", "%param = OpVariable %_ptr_Function_int Function", "OpStore %param %int_10", "%26 = OpFunctionCall %int %foo_i1_ %param", "%27 = OpConvertSToF %float %26", "%28 = OpFDiv %float %float_1 %27", "%31 = OpCompositeConstruct %v4float %28 %float_0_375 %float_0_75 %float_1", "OpStore %gl_FragColor %31", "OpReturn", "OpFunctionEnd" // clang-format on }; // This is the real test. The two OpIMul instructions should be replaced. In // particular, we want to be sure that both uses of %16 are changed to use the // new result. const std::vector foo_before = { // clang-format off "%foo_i1_ = OpFunction %int None %8", "%n = OpFunctionParameter %_ptr_Function_int", "%11 = OpLabel", "%12 = OpLoad %int %n", "%14 = OpIMul %int %12 %int_256", "%16 = OpIMul %int %14 %int_2", "%17 = OpIAdd %int %14 %16", "OpReturnValue %17", "OpFunctionEnd", // clang-format on }; const std::vector foo_after = { // clang-format off "%foo_i1_ = OpFunction %int None %8", "%n = OpFunctionParameter %_ptr_Function_int", "%11 = OpLabel", "%12 = OpLoad %int %n", "%34 = OpShiftLeftLogical %int %12 %uint_8", "%35 = OpShiftLeftLogical %int %34 %uint_1", "%17 = OpIAdd %int %34 %35", "OpReturnValue %17", "OpFunctionEnd", // clang-format on }; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck( JoinAllInsts(Concat(common_text, foo_before)), JoinAllInsts(Concat(common_text, foo_after)), /* skip_nop = */ true, /* do_validate = */ true); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/strip_debug_info_test.cpp000066400000000000000000000213371475742701700254050ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using StripLineDebugInfoTest = PassTest<::testing::Test>; TEST_F(StripLineDebugInfoTest, LineNoLine) { std::vector text = { // clang-format off "OpCapability Shader", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Vertex %2 \"main\"", "%3 = OpString \"minimal.vert\"", "OpModuleProcessed \"42\"", "OpModuleProcessed \"43\"", "OpModuleProcessed \"44\"", "OpNoLine", "OpLine %3 10 10", "%void = OpTypeVoid", "OpLine %3 100 100", "%5 = OpTypeFunction %void", "%2 = OpFunction %void None %5", "OpLine %3 1 1", "OpNoLine", "OpLine %3 2 2", "OpLine %3 3 3", "%6 = OpLabel", "OpLine %3 4 4", "OpNoLine", "OpReturn", "OpLine %3 4 4", "OpNoLine", "OpFunctionEnd", "OpNoLine", "OpLine %3 4 5" // clang-format on }; SinglePassRunAndCheck(JoinAllInsts(text), JoinNonDebugInsts(text), /* skip_nop = */ false); // Let's add more debug instruction before the "OpString" instruction. const std::vector more_text = { "OpSourceContinued \"I'm a happy shader! Yay! ;)\"", "OpSourceContinued \"wahahaha\"", "OpSource ESSL 310", "OpSource ESSL 310", "OpSourceContinued \"wahahaha\"", "OpSourceContinued \"wahahaha\"", "OpSourceExtension \"save-the-world-extension\"", "OpName %2 \"main\"", }; text.insert(text.begin() + 4, more_text.cbegin(), more_text.cend()); SinglePassRunAndCheck(JoinAllInsts(text), JoinNonDebugInsts(text), /* skip_nop = */ false); } using StripDebugStringTest = PassTest<::testing::Test>; TEST_F(StripDebugStringTest, OpDecorateRemoved) { std::vector input{ // clang-format off "OpCapability Shader", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Vertex %2 \"main\"", "%3 = OpString \"minimal.vert\"", "OpDecorate %3 Location 1337", "%void = OpTypeVoid", "%5 = OpTypeFunction %void", "%2 = OpFunction %void None %5", "%6 = OpLabel", "OpReturn", "OpFunctionEnd", // clang-format on }; std::vector output{ // clang-format off "OpCapability Shader", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Vertex %2 \"main\"", "%void = OpTypeVoid", "%5 = OpTypeFunction %void", "%2 = OpFunction %void None %5", "%6 = OpLabel", "OpReturn", "OpFunctionEnd", // clang-format on }; SinglePassRunAndCheck(JoinAllInsts(input), JoinAllInsts(output), /* skip_nop = */ false, /* do_validation */ true); } TEST_F(StripDebugStringTest, OpNameRemoved) { std::vector input{ // clang-format off "OpCapability Shader", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Vertex %2 \"main\"", "%3 = OpString \"minimal.vert\"", "OpName %3 \"bob\"", "%void = OpTypeVoid", "%5 = OpTypeFunction %void", "%2 = OpFunction %void None %5", "%6 = OpLabel", "OpReturn", "OpFunctionEnd", // clang-format on }; std::vector output{ // clang-format off "OpCapability Shader", "%1 = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Vertex %2 \"main\"", "%void = OpTypeVoid", "%5 = OpTypeFunction %void", "%2 = OpFunction %void None %5", "%6 = OpLabel", "OpReturn", "OpFunctionEnd", // clang-format on }; SinglePassRunAndCheck(JoinAllInsts(input), JoinAllInsts(output), /* skip_nop = */ false, /* do_validation */ true); } TEST_F(StripDebugStringTest, OpStringRemovedWithNonSemantic) { std::vector input{ // clang-format off "OpCapability Shader", "OpExtension \"SPV_KHR_non_semantic_info\"", "%1 = OpExtInstImport \"NonSemantic.Testing.Set\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Vertex %2 \"main\"", // this string is not referenced, should be removed fully "%3 = OpString \"minimal.vert\"", "OpName %3 \"bob\"", // this string is referenced and cannot be removed, // but the name should be "%4 = OpString \"secondary.inc\"", "OpName %4 \"sue\"", "%void = OpTypeVoid", "%6 = OpTypeFunction %void", "%2 = OpFunction %void None %6", "%7 = OpLabel", "%8 = OpExtInst %void %1 5 %4", "OpReturn", "OpFunctionEnd", // clang-format on }; std::vector output{ // clang-format off "OpCapability Shader", "OpExtension \"SPV_KHR_non_semantic_info\"", "%1 = OpExtInstImport \"NonSemantic.Testing.Set\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint Vertex %2 \"main\"", "%4 = OpString \"secondary.inc\"", "%void = OpTypeVoid", "%6 = OpTypeFunction %void", "%2 = OpFunction %void None %6", "%7 = OpLabel", "%8 = OpExtInst %void %1 5 %4", "OpReturn", "OpFunctionEnd", // clang-format on }; SinglePassRunAndCheck(JoinAllInsts(input), JoinAllInsts(output), /* skip_nop = */ false, /* do_validation */ true); } using StripDebugInfoTest = PassTest<::testing::TestWithParam>; TEST_P(StripDebugInfoTest, Kind) { std::vector text = { "OpCapability Shader", "OpMemoryModel Logical GLSL450", GetParam(), }; SinglePassRunAndCheck(JoinAllInsts(text), JoinNonDebugInsts(text), /* skip_nop = */ false); } // Test each possible non-line debug instruction. // clang-format off INSTANTIATE_TEST_SUITE_P( SingleKindDebugInst, StripDebugInfoTest, ::testing::ValuesIn(std::vector({ "OpSourceContinued \"I'm a happy shader! Yay! ;)\"", "OpSource ESSL 310", "OpSourceExtension \"save-the-world-extension\"", "OpName %main \"main\"", "OpMemberName %struct 0 \"field\"", "%1 = OpString \"name.vert\"", "OpModuleProcessed \"42\"", }))); // clang-format on } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/strip_nonsemantic_info_test.cpp000066400000000000000000000223621475742701700266340ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gmock/gmock.h" #include "spirv-tools/optimizer.hpp" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using StripNonSemanticInfoTest = PassTest<::testing::Test>; // This test acts as an end-to-end code example on how to strip // reflection info from a SPIR-V module. Use this code pattern // when you have compiled HLSL code with Glslang or DXC using // option -fhlsl_functionality1 to insert reflection information, // but then want to filter out the extra instructions before sending // it to a driver that does not implement VK_GOOGLE_hlsl_functionality1. TEST_F(StripNonSemanticInfoTest, StripReflectEnd2EndExample) { // This is a non-sensical example, but exercises the instructions. std::string before = R"(OpCapability Shader OpCapability Linkage OpExtension "SPV_GOOGLE_decorate_string" OpExtension "SPV_GOOGLE_hlsl_functionality1" OpMemoryModel Logical Simple OpDecorateStringGOOGLE %float HlslSemanticGOOGLE "foobar" OpDecorateStringGOOGLE %void HlslSemanticGOOGLE "my goodness" %void = OpTypeVoid %float = OpTypeFloat 32 )"; SpirvTools tools(SPV_ENV_UNIVERSAL_1_1); std::vector binary_in; tools.Assemble(before, &binary_in); // Instantiate the optimizer, and run the strip-nonsemantic-info // pass over the |binary_in| module, and place the modified module // into |binary_out|. spvtools::Optimizer optimizer(SPV_ENV_UNIVERSAL_1_1); optimizer.RegisterPass(spvtools::CreateStripNonSemanticInfoPass()); std::vector binary_out; optimizer.Run(binary_in.data(), binary_in.size(), &binary_out); // Check results std::string disassembly; tools.Disassemble(binary_out.data(), binary_out.size(), &disassembly); std::string after = R"(OpCapability Shader OpCapability Linkage OpMemoryModel Logical Simple %void = OpTypeVoid %float = OpTypeFloat 32 )"; EXPECT_THAT(disassembly, testing::Eq(after)); } // This test is functionally the same as the end-to-end test above, // but uses the test SinglePassRunAndCheck test fixture instead. TEST_F(StripNonSemanticInfoTest, StripHlslSemantic) { // This is a non-sensical example, but exercises the instructions. std::string before = R"(OpCapability Shader OpCapability Linkage OpExtension "SPV_GOOGLE_decorate_string" OpExtension "SPV_GOOGLE_hlsl_functionality1" OpMemoryModel Logical Simple OpDecorateStringGOOGLE %float HlslSemanticGOOGLE "foobar" OpDecorateStringGOOGLE %void HlslSemanticGOOGLE "my goodness" %void = OpTypeVoid %float = OpTypeFloat 32 )"; std::string after = R"(OpCapability Shader OpCapability Linkage OpMemoryModel Logical Simple %void = OpTypeVoid %float = OpTypeFloat 32 )"; SinglePassRunAndCheck(before, after, false); } TEST_F(StripNonSemanticInfoTest, StripHlslCounterBuffer) { std::string before = R"(OpCapability Shader OpCapability Linkage OpExtension "SPV_GOOGLE_hlsl_functionality1" OpMemoryModel Logical Simple OpDecorateId %void HlslCounterBufferGOOGLE %float %void = OpTypeVoid %float = OpTypeFloat 32 )"; std::string after = R"(OpCapability Shader OpCapability Linkage OpMemoryModel Logical Simple %void = OpTypeVoid %float = OpTypeFloat 32 )"; SinglePassRunAndCheck(before, after, false); } TEST_F(StripNonSemanticInfoTest, StripHlslSemanticOnMember) { // This is a non-sensical example, but exercises the instructions. std::string before = R"(OpCapability Shader OpCapability Linkage OpExtension "SPV_GOOGLE_decorate_string" OpExtension "SPV_GOOGLE_hlsl_functionality1" OpMemoryModel Logical Simple OpMemberDecorateStringGOOGLE %struct 0 HlslSemanticGOOGLE "foobar" %float = OpTypeFloat 32 %_struct_3 = OpTypeStruct %float )"; std::string after = R"(OpCapability Shader OpCapability Linkage OpMemoryModel Logical Simple %float = OpTypeFloat 32 %_struct_3 = OpTypeStruct %float )"; SinglePassRunAndCheck(before, after, false); } TEST_F(StripNonSemanticInfoTest, StripNonSemanticImport) { std::string text = R"( ; CHECK-NOT: OpExtension "SPV_KHR_non_semantic_info" ; CHECK-NOT: OpExtInstImport OpCapability Shader OpCapability Linkage OpExtension "SPV_KHR_non_semantic_info" %ext = OpExtInstImport "NonSemantic.Test" OpMemoryModel Logical GLSL450 )"; SinglePassRunAndMatch(text, true); } TEST_F(StripNonSemanticInfoTest, StripNonSemanticGlobal) { std::string text = R"( ; CHECK-NOT: OpExtInst OpCapability Shader OpCapability Linkage OpExtension "SPV_KHR_non_semantic_info" %ext = OpExtInstImport "NonSemantic.Test" OpMemoryModel Logical GLSL450 %void = OpTypeVoid %1 = OpExtInst %void %ext 1 )"; SinglePassRunAndMatch(text, true); } TEST_F(StripNonSemanticInfoTest, StripNonSemanticInFunction) { std::string text = R"( ; CHECK-NOT: OpExtInst OpCapability Shader OpCapability Linkage OpExtension "SPV_KHR_non_semantic_info" %ext = OpExtInstImport "NonSemantic.Test" OpMemoryModel Logical GLSL450 %void = OpTypeVoid %void_fn = OpTypeFunction %void %foo = OpFunction %void None %void_fn %entry = OpLabel %1 = OpExtInst %void %ext 1 %foo OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(StripNonSemanticInfoTest, StripNonSemanticAfterFunction) { std::string text = R"( ; CHECK-NOT: OpExtInst OpCapability Shader OpCapability Linkage OpExtension "SPV_KHR_non_semantic_info" %ext = OpExtInstImport "NonSemantic.Test" OpMemoryModel Logical GLSL450 %void = OpTypeVoid %void_fn = OpTypeFunction %void %foo = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd %1 = OpExtInst %void %ext 1 %foo )"; SinglePassRunAndMatch(text, true); } TEST_F(StripNonSemanticInfoTest, StripNonSemanticBetweenFunctions) { std::string text = R"( ; CHECK-NOT: OpExtInst OpCapability Shader OpCapability Linkage OpExtension "SPV_KHR_non_semantic_info" %ext = OpExtInstImport "NonSemantic.Test" OpMemoryModel Logical GLSL450 %void = OpTypeVoid %void_fn = OpTypeFunction %void %foo = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd %1 = OpExtInst %void %ext 1 %foo %bar = OpFunction %void None %void_fn %bar_entry = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } // Make sure that strip reflect does not remove the debug info (OpString and // OpLine). TEST_F(StripNonSemanticInfoTest, DontStripDebug) { std::string text = R"(OpCapability Shader OpMemoryModel Logical Simple OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft %2 = OpString "file" %void = OpTypeVoid %4 = OpTypeFunction %void %1 = OpFunction %void None %4 %5 = OpLabel OpLine %2 1 1 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(text, text, false); } TEST_F(StripNonSemanticInfoTest, RemovedNonSemanticDebugInfo) { const std::string text = R"( ;CHECK-NOT: OpExtension "SPV_KHR_non_semantic_info ;CHECK-NOT: OpExtInstImport "NonSemantic.Shader.DebugInfo.100 ;CHECK-NOT: OpExtInst %void {{%\w+}} DebugSource ;CHECK-NOT: OpExtInst %void {{%\w+}} DebugLine OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %1 = OpExtInstImport "NonSemantic.Shader.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %PSMain "PSMain" %in_var_COLOR %out_var_SV_TARGET OpExecutionMode %PSMain OriginUpperLeft %5 = OpString "t.hlsl" %6 = OpString "float" %7 = OpString "color" %8 = OpString "PSInput" %9 = OpString "PSMain" %10 = OpString "" %11 = OpString "input" OpName %in_var_COLOR "in.var.COLOR" OpName %out_var_SV_TARGET "out.var.SV_TARGET" OpName %PSMain "PSMain" OpDecorate %in_var_COLOR Location 0 OpDecorate %out_var_SV_TARGET Location 0 %uint = OpTypeInt 32 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %uint_1 = OpConstant %uint 1 %uint_9 = OpConstant %uint 9 %21 = OpTypeFunction %void %in_var_COLOR = OpVariable %_ptr_Input_v4float Input %out_var_SV_TARGET = OpVariable %_ptr_Output_v4float Output %13 = OpExtInst %void %1 DebugSource %5 %PSMain = OpFunction %void None %21 %22 = OpLabel %23 = OpLoad %v4float %in_var_COLOR OpStore %out_var_SV_TARGET %23 %24 = OpExtInst %void %1 DebugLine %13 %uint_9 %uint_9 %uint_1 %uint_1 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/struct_cfg_analysis_test.cpp000066400000000000000000001532121475742701700261270ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/struct_cfg_analysis.h" #include #include "gmock/gmock.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using StructCFGAnalysisTest = PassTest<::testing::Test>; using ::testing::UnorderedElementsAre; TEST_F(StructCFGAnalysisTest, BBInSelection) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %void = OpTypeVoid %bool = OpTypeBool %bool_undef = OpUndef %bool %uint = OpTypeInt 32 0 %uint_undef = OpUndef %uint %void_func = OpTypeFunction %void %main = OpFunction %void None %void_func %1 = OpLabel OpSelectionMerge %3 None OpBranchConditional %undef_bool %2 %3 %2 = OpLabel OpBranch %3 %3 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); StructuredCFGAnalysis analysis(context.get()); // The header is not in the construct. EXPECT_EQ(analysis.ContainingConstruct(1), 0); EXPECT_EQ(analysis.ContainingLoop(1), 0); EXPECT_EQ(analysis.MergeBlock(1), 0); EXPECT_EQ(analysis.NestingDepth(1), 0); EXPECT_EQ(analysis.LoopMergeBlock(1), 0); EXPECT_EQ(analysis.LoopNestingDepth(1), 0); EXPECT_EQ(analysis.ContainingSwitch(1), 0); EXPECT_EQ(analysis.SwitchMergeBlock(1), 0); EXPECT_FALSE(analysis.IsContinueBlock(1)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(1)); EXPECT_FALSE(analysis.IsInContinueConstruct(1)); EXPECT_FALSE(analysis.IsMergeBlock(1)); // BB2 is in the construct. EXPECT_EQ(analysis.ContainingConstruct(2), 1); EXPECT_EQ(analysis.ContainingLoop(2), 0); EXPECT_EQ(analysis.MergeBlock(2), 3); EXPECT_EQ(analysis.NestingDepth(2), 1); EXPECT_EQ(analysis.LoopMergeBlock(2), 0); EXPECT_EQ(analysis.LoopNestingDepth(2), 0); EXPECT_EQ(analysis.ContainingSwitch(2), 0); EXPECT_EQ(analysis.SwitchMergeBlock(2), 0); EXPECT_FALSE(analysis.IsContinueBlock(2)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(2)); EXPECT_FALSE(analysis.IsInContinueConstruct(2)); EXPECT_FALSE(analysis.IsMergeBlock(2)); // The merge node is not in the construct. EXPECT_EQ(analysis.ContainingConstruct(3), 0); EXPECT_EQ(analysis.ContainingLoop(3), 0); EXPECT_EQ(analysis.MergeBlock(3), 0); EXPECT_EQ(analysis.NestingDepth(3), 0); EXPECT_EQ(analysis.LoopMergeBlock(3), 0); EXPECT_EQ(analysis.LoopNestingDepth(3), 0); EXPECT_EQ(analysis.ContainingSwitch(3), 0); EXPECT_EQ(analysis.SwitchMergeBlock(3), 0); EXPECT_FALSE(analysis.IsContinueBlock(3)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(3)); EXPECT_FALSE(analysis.IsInContinueConstruct(3)); EXPECT_TRUE(analysis.IsMergeBlock(3)); } TEST_F(StructCFGAnalysisTest, BBInLoop) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %void = OpTypeVoid %bool = OpTypeBool %bool_undef = OpUndef %bool %uint = OpTypeInt 32 0 %uint_undef = OpUndef %uint %void_func = OpTypeFunction %void %main = OpFunction %void None %void_func %entry_lab = OpLabel OpBranch %1 %1 = OpLabel OpLoopMerge %3 %4 None OpBranchConditional %undef_bool %2 %3 %2 = OpLabel OpBranch %3 %4 = OpLabel OpBranch %1 %3 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); StructuredCFGAnalysis analysis(context.get()); // The header is not in the construct. EXPECT_EQ(analysis.ContainingConstruct(1), 0); EXPECT_EQ(analysis.ContainingLoop(1), 0); EXPECT_EQ(analysis.MergeBlock(1), 0); EXPECT_EQ(analysis.NestingDepth(1), 0); EXPECT_EQ(analysis.LoopMergeBlock(1), 0); EXPECT_EQ(analysis.LoopNestingDepth(1), 0); EXPECT_EQ(analysis.ContainingSwitch(1), 0); EXPECT_EQ(analysis.SwitchMergeBlock(1), 0); EXPECT_FALSE(analysis.IsContinueBlock(1)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(1)); EXPECT_FALSE(analysis.IsInContinueConstruct(1)); EXPECT_FALSE(analysis.IsMergeBlock(1)); // BB2 is in the construct. EXPECT_EQ(analysis.ContainingConstruct(2), 1); EXPECT_EQ(analysis.ContainingLoop(2), 1); EXPECT_EQ(analysis.MergeBlock(2), 3); EXPECT_EQ(analysis.NestingDepth(2), 1); EXPECT_EQ(analysis.LoopMergeBlock(2), 3); EXPECT_EQ(analysis.LoopNestingDepth(2), 1); EXPECT_EQ(analysis.ContainingSwitch(2), 0); EXPECT_EQ(analysis.SwitchMergeBlock(2), 0); EXPECT_FALSE(analysis.IsContinueBlock(2)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(2)); EXPECT_FALSE(analysis.IsInContinueConstruct(2)); EXPECT_FALSE(analysis.IsMergeBlock(2)); // The merge node is not in the construct. EXPECT_EQ(analysis.ContainingConstruct(3), 0); EXPECT_EQ(analysis.ContainingLoop(3), 0); EXPECT_EQ(analysis.MergeBlock(3), 0); EXPECT_EQ(analysis.NestingDepth(3), 0); EXPECT_EQ(analysis.LoopMergeBlock(3), 0); EXPECT_EQ(analysis.LoopNestingDepth(3), 0); EXPECT_EQ(analysis.ContainingSwitch(3), 0); EXPECT_EQ(analysis.SwitchMergeBlock(3), 0); EXPECT_FALSE(analysis.IsContinueBlock(3)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(3)); EXPECT_FALSE(analysis.IsInContinueConstruct(3)); EXPECT_TRUE(analysis.IsMergeBlock(3)); // The continue block is in the construct. EXPECT_EQ(analysis.ContainingConstruct(4), 1); EXPECT_EQ(analysis.ContainingLoop(4), 1); EXPECT_EQ(analysis.MergeBlock(4), 3); EXPECT_EQ(analysis.NestingDepth(4), 1); EXPECT_EQ(analysis.LoopMergeBlock(4), 3); EXPECT_EQ(analysis.LoopNestingDepth(4), 1); EXPECT_EQ(analysis.ContainingSwitch(4), 0); EXPECT_EQ(analysis.SwitchMergeBlock(4), 0); EXPECT_TRUE(analysis.IsContinueBlock(4)); EXPECT_TRUE(analysis.IsInContainingLoopsContinueConstruct(4)); EXPECT_TRUE(analysis.IsInContinueConstruct(4)); EXPECT_FALSE(analysis.IsMergeBlock(4)); } TEST_F(StructCFGAnalysisTest, SelectionInLoop) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %void = OpTypeVoid %bool = OpTypeBool %bool_undef = OpUndef %bool %uint = OpTypeInt 32 0 %uint_undef = OpUndef %uint %void_func = OpTypeFunction %void %main = OpFunction %void None %void_func %entry_lab = OpLabel OpBranch %1 %1 = OpLabel OpLoopMerge %3 %4 None OpBranchConditional %undef_bool %2 %3 %2 = OpLabel OpSelectionMerge %6 None OpBranchConditional %undef_bool %5 %6 %5 = OpLabel OpBranch %6 %6 = OpLabel OpBranch %3 %4 = OpLabel OpBranch %1 %3 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); StructuredCFGAnalysis analysis(context.get()); // The loop header is not in either construct. EXPECT_EQ(analysis.ContainingConstruct(1), 0); EXPECT_EQ(analysis.ContainingLoop(1), 0); EXPECT_EQ(analysis.MergeBlock(1), 0); EXPECT_EQ(analysis.NestingDepth(1), 0); EXPECT_EQ(analysis.LoopMergeBlock(1), 0); EXPECT_EQ(analysis.LoopNestingDepth(1), 0); EXPECT_EQ(analysis.ContainingSwitch(1), 0); EXPECT_EQ(analysis.SwitchMergeBlock(1), 0); EXPECT_FALSE(analysis.IsContinueBlock(1)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(1)); EXPECT_FALSE(analysis.IsInContinueConstruct(1)); EXPECT_FALSE(analysis.IsMergeBlock(1)); // Selection header is in the loop only. EXPECT_EQ(analysis.ContainingConstruct(2), 1); EXPECT_EQ(analysis.ContainingLoop(2), 1); EXPECT_EQ(analysis.MergeBlock(2), 3); EXPECT_EQ(analysis.NestingDepth(2), 1); EXPECT_EQ(analysis.LoopMergeBlock(2), 3); EXPECT_EQ(analysis.LoopNestingDepth(2), 1); EXPECT_EQ(analysis.ContainingSwitch(2), 0); EXPECT_EQ(analysis.SwitchMergeBlock(2), 0); EXPECT_FALSE(analysis.IsContinueBlock(2)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(2)); EXPECT_FALSE(analysis.IsInContinueConstruct(2)); EXPECT_FALSE(analysis.IsMergeBlock(2)); // The loop merge node is not in either construct. EXPECT_EQ(analysis.ContainingConstruct(3), 0); EXPECT_EQ(analysis.ContainingLoop(3), 0); EXPECT_EQ(analysis.MergeBlock(3), 0); EXPECT_EQ(analysis.NestingDepth(3), 0); EXPECT_EQ(analysis.LoopMergeBlock(3), 0); EXPECT_EQ(analysis.LoopNestingDepth(3), 0); EXPECT_EQ(analysis.ContainingSwitch(3), 0); EXPECT_EQ(analysis.SwitchMergeBlock(3), 0); EXPECT_FALSE(analysis.IsContinueBlock(3)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(3)); EXPECT_FALSE(analysis.IsInContinueConstruct(3)); EXPECT_TRUE(analysis.IsMergeBlock(3)); // The continue block is in the loop only. EXPECT_EQ(analysis.ContainingConstruct(4), 1); EXPECT_EQ(analysis.ContainingLoop(4), 1); EXPECT_EQ(analysis.MergeBlock(4), 3); EXPECT_EQ(analysis.NestingDepth(4), 1); EXPECT_EQ(analysis.LoopMergeBlock(4), 3); EXPECT_EQ(analysis.LoopNestingDepth(4), 1); EXPECT_EQ(analysis.ContainingSwitch(4), 0); EXPECT_EQ(analysis.SwitchMergeBlock(4), 0); EXPECT_TRUE(analysis.IsContinueBlock(4)); EXPECT_TRUE(analysis.IsInContainingLoopsContinueConstruct(4)); EXPECT_TRUE(analysis.IsInContinueConstruct(4)); EXPECT_FALSE(analysis.IsMergeBlock(4)); // BB5 is in the selection and the loop. EXPECT_EQ(analysis.ContainingConstruct(5), 2); EXPECT_EQ(analysis.ContainingLoop(5), 1); EXPECT_EQ(analysis.MergeBlock(5), 6); EXPECT_EQ(analysis.NestingDepth(5), 2); EXPECT_EQ(analysis.LoopMergeBlock(5), 3); EXPECT_EQ(analysis.LoopNestingDepth(5), 1); EXPECT_EQ(analysis.ContainingSwitch(5), 0); EXPECT_EQ(analysis.SwitchMergeBlock(5), 0); EXPECT_FALSE(analysis.IsContinueBlock(5)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(5)); EXPECT_FALSE(analysis.IsInContinueConstruct(5)); EXPECT_FALSE(analysis.IsMergeBlock(5)); // The selection merge is in the loop only. EXPECT_EQ(analysis.ContainingConstruct(6), 1); EXPECT_EQ(analysis.ContainingLoop(6), 1); EXPECT_EQ(analysis.MergeBlock(6), 3); EXPECT_EQ(analysis.NestingDepth(6), 1); EXPECT_EQ(analysis.LoopMergeBlock(6), 3); EXPECT_EQ(analysis.LoopNestingDepth(6), 1); EXPECT_EQ(analysis.ContainingSwitch(6), 0); EXPECT_EQ(analysis.SwitchMergeBlock(6), 0); EXPECT_FALSE(analysis.IsContinueBlock(6)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(6)); EXPECT_FALSE(analysis.IsInContinueConstruct(6)); EXPECT_TRUE(analysis.IsMergeBlock(6)); } TEST_F(StructCFGAnalysisTest, LoopInSelection) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %void = OpTypeVoid %bool = OpTypeBool %bool_undef = OpUndef %bool %uint = OpTypeInt 32 0 %uint_undef = OpUndef %uint %void_func = OpTypeFunction %void %main = OpFunction %void None %void_func %entry_lab = OpLabel OpBranch %1 %1 = OpLabel OpSelectionMerge %3 None OpBranchConditional %undef_bool %2 %3 %2 = OpLabel OpLoopMerge %4 %5 None OpBranchConditional %undef_bool %4 %6 %5 = OpLabel OpBranch %2 %6 = OpLabel OpBranch %4 %4 = OpLabel OpBranch %3 %3 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); StructuredCFGAnalysis analysis(context.get()); // The selection header is not in either construct. EXPECT_EQ(analysis.ContainingConstruct(1), 0); EXPECT_EQ(analysis.ContainingLoop(1), 0); EXPECT_EQ(analysis.MergeBlock(1), 0); EXPECT_EQ(analysis.NestingDepth(1), 0); EXPECT_EQ(analysis.LoopMergeBlock(1), 0); EXPECT_EQ(analysis.LoopNestingDepth(1), 0); EXPECT_EQ(analysis.ContainingSwitch(1), 0); EXPECT_EQ(analysis.SwitchMergeBlock(1), 0); EXPECT_FALSE(analysis.IsContinueBlock(1)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(1)); EXPECT_FALSE(analysis.IsInContinueConstruct(1)); EXPECT_FALSE(analysis.IsMergeBlock(1)); // Loop header is in the selection only. EXPECT_EQ(analysis.ContainingConstruct(2), 1); EXPECT_EQ(analysis.ContainingLoop(2), 0); EXPECT_EQ(analysis.MergeBlock(2), 3); EXPECT_EQ(analysis.NestingDepth(2), 1); EXPECT_EQ(analysis.LoopMergeBlock(2), 0); EXPECT_EQ(analysis.LoopNestingDepth(2), 0); EXPECT_EQ(analysis.ContainingSwitch(2), 0); EXPECT_EQ(analysis.SwitchMergeBlock(2), 0); EXPECT_FALSE(analysis.IsContinueBlock(2)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(2)); EXPECT_FALSE(analysis.IsInContinueConstruct(2)); EXPECT_FALSE(analysis.IsMergeBlock(2)); // The selection merge node is not in either construct. EXPECT_EQ(analysis.ContainingConstruct(3), 0); EXPECT_EQ(analysis.ContainingLoop(3), 0); EXPECT_EQ(analysis.MergeBlock(3), 0); EXPECT_EQ(analysis.NestingDepth(3), 0); EXPECT_EQ(analysis.LoopMergeBlock(3), 0); EXPECT_EQ(analysis.LoopNestingDepth(3), 0); EXPECT_EQ(analysis.ContainingSwitch(3), 0); EXPECT_EQ(analysis.SwitchMergeBlock(3), 0); EXPECT_FALSE(analysis.IsContinueBlock(3)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(3)); EXPECT_FALSE(analysis.IsInContinueConstruct(3)); EXPECT_TRUE(analysis.IsMergeBlock(3)); // The loop merge is in the selection only. EXPECT_EQ(analysis.ContainingConstruct(4), 1); EXPECT_EQ(analysis.ContainingLoop(4), 0); EXPECT_EQ(analysis.MergeBlock(4), 3); EXPECT_EQ(analysis.NestingDepth(4), 1); EXPECT_EQ(analysis.LoopMergeBlock(4), 0); EXPECT_EQ(analysis.LoopNestingDepth(4), 0); EXPECT_EQ(analysis.ContainingSwitch(4), 0); EXPECT_EQ(analysis.SwitchMergeBlock(4), 0); EXPECT_FALSE(analysis.IsContinueBlock(4)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(4)); EXPECT_FALSE(analysis.IsInContinueConstruct(4)); EXPECT_TRUE(analysis.IsMergeBlock(4)); // The loop continue target is in the loop. EXPECT_EQ(analysis.ContainingConstruct(5), 2); EXPECT_EQ(analysis.ContainingLoop(5), 2); EXPECT_EQ(analysis.MergeBlock(5), 4); EXPECT_EQ(analysis.NestingDepth(5), 2); EXPECT_EQ(analysis.LoopMergeBlock(5), 4); EXPECT_EQ(analysis.LoopNestingDepth(5), 1); EXPECT_EQ(analysis.ContainingSwitch(5), 0); EXPECT_EQ(analysis.SwitchMergeBlock(5), 0); EXPECT_TRUE(analysis.IsContinueBlock(5)); EXPECT_TRUE(analysis.IsInContainingLoopsContinueConstruct(5)); EXPECT_TRUE(analysis.IsInContinueConstruct(5)); EXPECT_FALSE(analysis.IsMergeBlock(5)); // BB6 is in the loop. EXPECT_EQ(analysis.ContainingConstruct(6), 2); EXPECT_EQ(analysis.ContainingLoop(6), 2); EXPECT_EQ(analysis.MergeBlock(6), 4); EXPECT_EQ(analysis.NestingDepth(6), 2); EXPECT_EQ(analysis.LoopMergeBlock(6), 4); EXPECT_EQ(analysis.LoopNestingDepth(6), 1); EXPECT_EQ(analysis.ContainingSwitch(6), 0); EXPECT_EQ(analysis.SwitchMergeBlock(6), 0); EXPECT_FALSE(analysis.IsContinueBlock(6)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(6)); EXPECT_FALSE(analysis.IsInContinueConstruct(6)); EXPECT_FALSE(analysis.IsMergeBlock(6)); } TEST_F(StructCFGAnalysisTest, SelectionInSelection) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %void = OpTypeVoid %bool = OpTypeBool %bool_undef = OpUndef %bool %uint = OpTypeInt 32 0 %uint_undef = OpUndef %uint %void_func = OpTypeFunction %void %main = OpFunction %void None %void_func %entry_lab = OpLabel OpBranch %1 %1 = OpLabel OpSelectionMerge %3 None OpBranchConditional %undef_bool %2 %3 %2 = OpLabel OpSelectionMerge %4 None OpBranchConditional %undef_bool %4 %5 %5 = OpLabel OpBranch %4 %4 = OpLabel OpBranch %3 %3 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); StructuredCFGAnalysis analysis(context.get()); // The outer selection header is not in either construct. EXPECT_EQ(analysis.ContainingConstruct(1), 0); EXPECT_EQ(analysis.ContainingLoop(1), 0); EXPECT_EQ(analysis.MergeBlock(1), 0); EXPECT_EQ(analysis.NestingDepth(1), 0); EXPECT_EQ(analysis.LoopMergeBlock(1), 0); EXPECT_EQ(analysis.LoopNestingDepth(1), 0); EXPECT_EQ(analysis.ContainingSwitch(1), 0); EXPECT_EQ(analysis.SwitchMergeBlock(1), 0); EXPECT_FALSE(analysis.IsContinueBlock(1)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(1)); EXPECT_FALSE(analysis.IsInContinueConstruct(1)); EXPECT_FALSE(analysis.IsMergeBlock(1)); // The inner header is in the outer selection. EXPECT_EQ(analysis.ContainingConstruct(2), 1); EXPECT_EQ(analysis.ContainingLoop(2), 0); EXPECT_EQ(analysis.MergeBlock(2), 3); EXPECT_EQ(analysis.NestingDepth(2), 1); EXPECT_EQ(analysis.LoopMergeBlock(2), 0); EXPECT_EQ(analysis.LoopNestingDepth(2), 0); EXPECT_EQ(analysis.ContainingSwitch(2), 0); EXPECT_EQ(analysis.SwitchMergeBlock(2), 0); EXPECT_FALSE(analysis.IsContinueBlock(2)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(2)); EXPECT_FALSE(analysis.IsInContinueConstruct(2)); EXPECT_FALSE(analysis.IsMergeBlock(2)); // The outer merge node is not in either construct. EXPECT_EQ(analysis.ContainingConstruct(3), 0); EXPECT_EQ(analysis.ContainingLoop(3), 0); EXPECT_EQ(analysis.MergeBlock(3), 0); EXPECT_EQ(analysis.NestingDepth(3), 0); EXPECT_EQ(analysis.LoopMergeBlock(3), 0); EXPECT_EQ(analysis.LoopNestingDepth(3), 0); EXPECT_EQ(analysis.ContainingSwitch(3), 0); EXPECT_EQ(analysis.SwitchMergeBlock(3), 0); EXPECT_FALSE(analysis.IsContinueBlock(3)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(3)); EXPECT_FALSE(analysis.IsInContinueConstruct(3)); EXPECT_TRUE(analysis.IsMergeBlock(3)); // The inner merge is in the outer selection. EXPECT_EQ(analysis.ContainingConstruct(4), 1); EXPECT_EQ(analysis.ContainingLoop(4), 0); EXPECT_EQ(analysis.MergeBlock(4), 3); EXPECT_EQ(analysis.NestingDepth(4), 1); EXPECT_EQ(analysis.LoopMergeBlock(4), 0); EXPECT_EQ(analysis.LoopNestingDepth(4), 0); EXPECT_EQ(analysis.ContainingSwitch(4), 0); EXPECT_EQ(analysis.SwitchMergeBlock(4), 0); EXPECT_FALSE(analysis.IsContinueBlock(4)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(4)); EXPECT_FALSE(analysis.IsInContinueConstruct(4)); EXPECT_TRUE(analysis.IsMergeBlock(4)); // BB5 is in the inner selection. EXPECT_EQ(analysis.ContainingConstruct(5), 2); EXPECT_EQ(analysis.ContainingLoop(5), 0); EXPECT_EQ(analysis.MergeBlock(5), 4); EXPECT_EQ(analysis.NestingDepth(5), 2); EXPECT_EQ(analysis.LoopMergeBlock(5), 0); EXPECT_EQ(analysis.LoopNestingDepth(5), 0); EXPECT_EQ(analysis.ContainingSwitch(5), 0); EXPECT_EQ(analysis.SwitchMergeBlock(5), 0); EXPECT_FALSE(analysis.IsContinueBlock(5)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(5)); EXPECT_FALSE(analysis.IsInContinueConstruct(5)); EXPECT_FALSE(analysis.IsMergeBlock(5)); } TEST_F(StructCFGAnalysisTest, LoopInLoop) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %void = OpTypeVoid %bool = OpTypeBool %bool_undef = OpUndef %bool %uint = OpTypeInt 32 0 %uint_undef = OpUndef %uint %void_func = OpTypeFunction %void %main = OpFunction %void None %void_func %entry_lab = OpLabel OpBranch %1 %1 = OpLabel OpLoopMerge %3 %7 None OpBranchConditional %undef_bool %2 %3 %2 = OpLabel OpLoopMerge %4 %5 None OpBranchConditional %undef_bool %4 %6 %5 = OpLabel OpBranch %2 %6 = OpLabel OpBranch %4 %4 = OpLabel OpBranch %3 %7 = OpLabel OpBranch %1 %3 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); StructuredCFGAnalysis analysis(context.get()); // The outer loop header is not in either construct. EXPECT_EQ(analysis.ContainingConstruct(1), 0); EXPECT_EQ(analysis.ContainingLoop(1), 0); EXPECT_EQ(analysis.MergeBlock(1), 0); EXPECT_EQ(analysis.NestingDepth(1), 0); EXPECT_EQ(analysis.LoopMergeBlock(1), 0); EXPECT_EQ(analysis.LoopNestingDepth(1), 0); EXPECT_EQ(analysis.ContainingSwitch(1), 0); EXPECT_EQ(analysis.SwitchMergeBlock(1), 0); EXPECT_FALSE(analysis.IsContinueBlock(1)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(1)); EXPECT_FALSE(analysis.IsInContinueConstruct(1)); EXPECT_FALSE(analysis.IsMergeBlock(1)); // The inner loop header is in the outer loop. EXPECT_EQ(analysis.ContainingConstruct(2), 1); EXPECT_EQ(analysis.ContainingLoop(2), 1); EXPECT_EQ(analysis.MergeBlock(2), 3); EXPECT_EQ(analysis.NestingDepth(2), 1); EXPECT_EQ(analysis.LoopMergeBlock(2), 3); EXPECT_EQ(analysis.LoopNestingDepth(2), 1); EXPECT_EQ(analysis.ContainingSwitch(2), 0); EXPECT_EQ(analysis.SwitchMergeBlock(2), 0); EXPECT_FALSE(analysis.IsContinueBlock(2)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(2)); EXPECT_FALSE(analysis.IsInContinueConstruct(2)); EXPECT_FALSE(analysis.IsMergeBlock(2)); // The outer merge node is not in either construct. EXPECT_EQ(analysis.ContainingConstruct(3), 0); EXPECT_EQ(analysis.ContainingLoop(3), 0); EXPECT_EQ(analysis.MergeBlock(3), 0); EXPECT_EQ(analysis.NestingDepth(3), 0); EXPECT_EQ(analysis.LoopMergeBlock(3), 0); EXPECT_EQ(analysis.LoopNestingDepth(3), 0); EXPECT_EQ(analysis.ContainingSwitch(3), 0); EXPECT_EQ(analysis.SwitchMergeBlock(3), 0); EXPECT_FALSE(analysis.IsContinueBlock(3)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(3)); EXPECT_FALSE(analysis.IsInContinueConstruct(3)); EXPECT_TRUE(analysis.IsMergeBlock(3)); // The inner merge is in the outer loop. EXPECT_EQ(analysis.ContainingConstruct(4), 1); EXPECT_EQ(analysis.ContainingLoop(4), 1); EXPECT_EQ(analysis.MergeBlock(4), 3); EXPECT_EQ(analysis.NestingDepth(4), 1); EXPECT_EQ(analysis.LoopMergeBlock(4), 3); EXPECT_EQ(analysis.LoopNestingDepth(4), 1); EXPECT_EQ(analysis.ContainingSwitch(4), 0); EXPECT_EQ(analysis.SwitchMergeBlock(4), 0); EXPECT_FALSE(analysis.IsContinueBlock(4)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(4)); EXPECT_FALSE(analysis.IsInContinueConstruct(4)); EXPECT_TRUE(analysis.IsMergeBlock(4)); // The inner continue target is in the inner loop. EXPECT_EQ(analysis.ContainingConstruct(5), 2); EXPECT_EQ(analysis.ContainingLoop(5), 2); EXPECT_EQ(analysis.MergeBlock(5), 4); EXPECT_EQ(analysis.NestingDepth(5), 2); EXPECT_EQ(analysis.LoopMergeBlock(5), 4); EXPECT_EQ(analysis.LoopNestingDepth(5), 2); EXPECT_EQ(analysis.ContainingSwitch(5), 0); EXPECT_EQ(analysis.SwitchMergeBlock(5), 0); EXPECT_TRUE(analysis.IsContinueBlock(5)); EXPECT_TRUE(analysis.IsInContainingLoopsContinueConstruct(5)); EXPECT_TRUE(analysis.IsInContinueConstruct(5)); EXPECT_FALSE(analysis.IsMergeBlock(5)); // BB6 is in the loop. EXPECT_EQ(analysis.ContainingConstruct(6), 2); EXPECT_EQ(analysis.ContainingLoop(6), 2); EXPECT_EQ(analysis.MergeBlock(6), 4); EXPECT_EQ(analysis.NestingDepth(6), 2); EXPECT_EQ(analysis.LoopMergeBlock(6), 4); EXPECT_EQ(analysis.LoopNestingDepth(6), 2); EXPECT_EQ(analysis.ContainingSwitch(6), 0); EXPECT_EQ(analysis.SwitchMergeBlock(6), 0); EXPECT_FALSE(analysis.IsContinueBlock(6)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(6)); EXPECT_FALSE(analysis.IsInContinueConstruct(6)); EXPECT_FALSE(analysis.IsMergeBlock(6)); // The outer continue target is in the outer loop. EXPECT_EQ(analysis.ContainingConstruct(7), 1); EXPECT_EQ(analysis.ContainingLoop(7), 1); EXPECT_EQ(analysis.MergeBlock(7), 3); EXPECT_EQ(analysis.NestingDepth(7), 1); EXPECT_EQ(analysis.LoopMergeBlock(7), 3); EXPECT_EQ(analysis.LoopNestingDepth(7), 1); EXPECT_EQ(analysis.ContainingSwitch(7), 0); EXPECT_EQ(analysis.SwitchMergeBlock(7), 0); EXPECT_TRUE(analysis.IsContinueBlock(7)); EXPECT_TRUE(analysis.IsInContainingLoopsContinueConstruct(7)); EXPECT_TRUE(analysis.IsInContinueConstruct(7)); EXPECT_FALSE(analysis.IsMergeBlock(7)); } TEST_F(StructCFGAnalysisTest, KernelTest) { const std::string text = R"( OpCapability Kernel OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %void = OpTypeVoid %bool = OpTypeBool %bool_undef = OpUndef %bool %void_func = OpTypeFunction %void %main = OpFunction %void None %void_func %1 = OpLabel OpBranchConditional %undef_bool %2 %3 %2 = OpLabel OpBranch %3 %3 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); StructuredCFGAnalysis analysis(context.get()); // No structured control flow, so none of the basic block are in any // construct. for (uint32_t i = 1; i <= 3; i++) { EXPECT_EQ(analysis.ContainingConstruct(i), 0); EXPECT_EQ(analysis.ContainingLoop(i), 0); EXPECT_EQ(analysis.MergeBlock(i), 0); EXPECT_EQ(analysis.NestingDepth(i), 0); EXPECT_EQ(analysis.LoopMergeBlock(i), 0); EXPECT_EQ(analysis.LoopNestingDepth(i), 0); EXPECT_EQ(analysis.ContainingSwitch(i), 0); EXPECT_EQ(analysis.SwitchMergeBlock(i), 0); EXPECT_FALSE(analysis.IsContinueBlock(i)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(i)); EXPECT_FALSE(analysis.IsInContinueConstruct(i)); EXPECT_FALSE(analysis.IsMergeBlock(i)); } } TEST_F(StructCFGAnalysisTest, EmptyFunctionTest) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %func LinkageAttributes "x" Import %void = OpTypeVoid %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); // #2451: This segfaulted on empty functions. StructuredCFGAnalysis analysis(context.get()); } TEST_F(StructCFGAnalysisTest, BBInSwitch) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %void = OpTypeVoid %bool = OpTypeBool %bool_undef = OpUndef %bool %uint = OpTypeInt 32 0 %uint_undef = OpUndef %uint %void_func = OpTypeFunction %void %main = OpFunction %void None %void_func %1 = OpLabel OpSelectionMerge %3 None OpSwitch %uint_undef %2 0 %3 %2 = OpLabel OpBranch %3 %3 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); StructuredCFGAnalysis analysis(context.get()); // The header is not in the construct. EXPECT_EQ(analysis.ContainingConstruct(1), 0); EXPECT_EQ(analysis.ContainingLoop(1), 0); EXPECT_EQ(analysis.MergeBlock(1), 0); EXPECT_EQ(analysis.NestingDepth(1), 0); EXPECT_EQ(analysis.LoopMergeBlock(1), 0); EXPECT_EQ(analysis.LoopNestingDepth(1), 0); EXPECT_EQ(analysis.ContainingSwitch(1), 0); EXPECT_EQ(analysis.SwitchMergeBlock(1), 0); EXPECT_FALSE(analysis.IsContinueBlock(1)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(1)); EXPECT_FALSE(analysis.IsInContinueConstruct(1)); EXPECT_FALSE(analysis.IsMergeBlock(1)); // BB2 is in the construct. EXPECT_EQ(analysis.ContainingConstruct(2), 1); EXPECT_EQ(analysis.ContainingLoop(2), 0); EXPECT_EQ(analysis.MergeBlock(2), 3); EXPECT_EQ(analysis.NestingDepth(2), 1); EXPECT_EQ(analysis.LoopMergeBlock(2), 0); EXPECT_EQ(analysis.LoopNestingDepth(2), 0); EXPECT_EQ(analysis.ContainingSwitch(2), 1); EXPECT_EQ(analysis.SwitchMergeBlock(2), 3); EXPECT_FALSE(analysis.IsContinueBlock(2)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(2)); EXPECT_FALSE(analysis.IsInContinueConstruct(2)); EXPECT_FALSE(analysis.IsMergeBlock(2)); // The merge node is not in the construct. EXPECT_EQ(analysis.ContainingConstruct(3), 0); EXPECT_EQ(analysis.ContainingLoop(3), 0); EXPECT_EQ(analysis.MergeBlock(3), 0); EXPECT_EQ(analysis.NestingDepth(3), 0); EXPECT_EQ(analysis.LoopMergeBlock(3), 0); EXPECT_EQ(analysis.LoopNestingDepth(3), 0); EXPECT_EQ(analysis.ContainingSwitch(3), 0); EXPECT_EQ(analysis.SwitchMergeBlock(3), 0); EXPECT_FALSE(analysis.IsContinueBlock(3)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(3)); EXPECT_FALSE(analysis.IsInContinueConstruct(3)); EXPECT_TRUE(analysis.IsMergeBlock(3)); } TEST_F(StructCFGAnalysisTest, LoopInSwitch) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %void = OpTypeVoid %bool = OpTypeBool %bool_undef = OpUndef %bool %uint = OpTypeInt 32 0 %uint_undef = OpUndef %uint %void_func = OpTypeFunction %void %main = OpFunction %void None %void_func %entry_lab = OpLabel OpBranch %1 %1 = OpLabel OpSelectionMerge %3 None OpSwitch %uint_undef %2 1 %3 %2 = OpLabel OpLoopMerge %4 %5 None OpBranchConditional %undef_bool %4 %6 %5 = OpLabel OpBranch %2 %6 = OpLabel OpBranch %4 %4 = OpLabel OpBranch %3 %3 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); StructuredCFGAnalysis analysis(context.get()); // The selection header is not in either construct. EXPECT_EQ(analysis.ContainingConstruct(1), 0); EXPECT_EQ(analysis.ContainingLoop(1), 0); EXPECT_EQ(analysis.MergeBlock(1), 0); EXPECT_EQ(analysis.NestingDepth(1), 0); EXPECT_EQ(analysis.LoopMergeBlock(1), 0); EXPECT_EQ(analysis.LoopNestingDepth(1), 0); EXPECT_EQ(analysis.ContainingSwitch(1), 0); EXPECT_EQ(analysis.SwitchMergeBlock(1), 0); EXPECT_FALSE(analysis.IsContinueBlock(1)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(1)); EXPECT_FALSE(analysis.IsInContinueConstruct(1)); EXPECT_FALSE(analysis.IsMergeBlock(1)); // Loop header is in the selection only. EXPECT_EQ(analysis.ContainingConstruct(2), 1); EXPECT_EQ(analysis.ContainingLoop(2), 0); EXPECT_EQ(analysis.MergeBlock(2), 3); EXPECT_EQ(analysis.NestingDepth(2), 1); EXPECT_EQ(analysis.LoopMergeBlock(2), 0); EXPECT_EQ(analysis.LoopNestingDepth(2), 0); EXPECT_EQ(analysis.ContainingSwitch(2), 1); EXPECT_EQ(analysis.SwitchMergeBlock(2), 3); EXPECT_FALSE(analysis.IsContinueBlock(2)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(2)); EXPECT_FALSE(analysis.IsInContinueConstruct(2)); EXPECT_FALSE(analysis.IsMergeBlock(2)); // The selection merge node is not in either construct. EXPECT_EQ(analysis.ContainingConstruct(3), 0); EXPECT_EQ(analysis.ContainingLoop(3), 0); EXPECT_EQ(analysis.MergeBlock(3), 0); EXPECT_EQ(analysis.NestingDepth(3), 0); EXPECT_EQ(analysis.LoopMergeBlock(3), 0); EXPECT_EQ(analysis.LoopNestingDepth(3), 0); EXPECT_EQ(analysis.ContainingSwitch(3), 0); EXPECT_EQ(analysis.SwitchMergeBlock(3), 0); EXPECT_FALSE(analysis.IsContinueBlock(3)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(3)); EXPECT_FALSE(analysis.IsInContinueConstruct(3)); EXPECT_TRUE(analysis.IsMergeBlock(3)); // The loop merge is in the selection only. EXPECT_EQ(analysis.ContainingConstruct(4), 1); EXPECT_EQ(analysis.ContainingLoop(4), 0); EXPECT_EQ(analysis.MergeBlock(4), 3); EXPECT_EQ(analysis.NestingDepth(4), 1); EXPECT_EQ(analysis.LoopMergeBlock(4), 0); EXPECT_EQ(analysis.LoopNestingDepth(4), 0); EXPECT_EQ(analysis.ContainingSwitch(4), 1); EXPECT_EQ(analysis.SwitchMergeBlock(4), 3); EXPECT_FALSE(analysis.IsContinueBlock(4)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(4)); EXPECT_FALSE(analysis.IsInContinueConstruct(4)); EXPECT_TRUE(analysis.IsMergeBlock(4)); // The loop continue target is in the loop. EXPECT_EQ(analysis.ContainingConstruct(5), 2); EXPECT_EQ(analysis.ContainingLoop(5), 2); EXPECT_EQ(analysis.MergeBlock(5), 4); EXPECT_EQ(analysis.NestingDepth(5), 2); EXPECT_EQ(analysis.LoopMergeBlock(5), 4); EXPECT_EQ(analysis.LoopNestingDepth(5), 1); EXPECT_EQ(analysis.ContainingSwitch(5), 0); EXPECT_EQ(analysis.SwitchMergeBlock(5), 0); EXPECT_TRUE(analysis.IsContinueBlock(5)); EXPECT_TRUE(analysis.IsInContainingLoopsContinueConstruct(5)); EXPECT_TRUE(analysis.IsInContinueConstruct(5)); EXPECT_FALSE(analysis.IsMergeBlock(5)); // BB6 is in the loop. EXPECT_EQ(analysis.ContainingConstruct(6), 2); EXPECT_EQ(analysis.ContainingLoop(6), 2); EXPECT_EQ(analysis.MergeBlock(6), 4); EXPECT_EQ(analysis.NestingDepth(6), 2); EXPECT_EQ(analysis.LoopMergeBlock(6), 4); EXPECT_EQ(analysis.LoopNestingDepth(6), 1); EXPECT_EQ(analysis.ContainingSwitch(6), 0); EXPECT_EQ(analysis.SwitchMergeBlock(6), 0); EXPECT_FALSE(analysis.IsContinueBlock(6)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(6)); EXPECT_FALSE(analysis.IsInContinueConstruct(6)); EXPECT_FALSE(analysis.IsMergeBlock(6)); } TEST_F(StructCFGAnalysisTest, SelectionInSwitch) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %void = OpTypeVoid %bool = OpTypeBool %bool_undef = OpUndef %bool %uint = OpTypeInt 32 0 %uint_undef = OpUndef %uint %void_func = OpTypeFunction %void %main = OpFunction %void None %void_func %entry_lab = OpLabel OpBranch %1 %1 = OpLabel OpSelectionMerge %3 None OpSwitch %uint_undef %2 10 %3 %2 = OpLabel OpSelectionMerge %4 None OpBranchConditional %undef_bool %4 %5 %5 = OpLabel OpBranch %4 %4 = OpLabel OpBranch %3 %3 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); StructuredCFGAnalysis analysis(context.get()); // The outer selection header is not in either construct. EXPECT_EQ(analysis.ContainingConstruct(1), 0); EXPECT_EQ(analysis.ContainingLoop(1), 0); EXPECT_EQ(analysis.MergeBlock(1), 0); EXPECT_EQ(analysis.NestingDepth(1), 0); EXPECT_EQ(analysis.LoopMergeBlock(1), 0); EXPECT_EQ(analysis.LoopNestingDepth(1), 0); EXPECT_EQ(analysis.ContainingSwitch(1), 0); EXPECT_EQ(analysis.SwitchMergeBlock(1), 0); EXPECT_FALSE(analysis.IsContinueBlock(1)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(1)); EXPECT_FALSE(analysis.IsInContinueConstruct(1)); EXPECT_FALSE(analysis.IsMergeBlock(1)); // The inner header is in the outer selection. EXPECT_EQ(analysis.ContainingConstruct(2), 1); EXPECT_EQ(analysis.ContainingLoop(2), 0); EXPECT_EQ(analysis.MergeBlock(2), 3); EXPECT_EQ(analysis.NestingDepth(2), 1); EXPECT_EQ(analysis.LoopMergeBlock(2), 0); EXPECT_EQ(analysis.LoopNestingDepth(2), 0); EXPECT_EQ(analysis.ContainingSwitch(2), 1); EXPECT_EQ(analysis.SwitchMergeBlock(2), 3); EXPECT_FALSE(analysis.IsContinueBlock(2)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(2)); EXPECT_FALSE(analysis.IsInContinueConstruct(2)); EXPECT_FALSE(analysis.IsMergeBlock(2)); // The outer merge node is not in either construct. EXPECT_EQ(analysis.ContainingConstruct(3), 0); EXPECT_EQ(analysis.ContainingLoop(3), 0); EXPECT_EQ(analysis.MergeBlock(3), 0); EXPECT_EQ(analysis.NestingDepth(3), 0); EXPECT_EQ(analysis.LoopMergeBlock(3), 0); EXPECT_EQ(analysis.LoopNestingDepth(3), 0); EXPECT_EQ(analysis.ContainingSwitch(3), 0); EXPECT_EQ(analysis.SwitchMergeBlock(3), 0); EXPECT_FALSE(analysis.IsContinueBlock(3)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(3)); EXPECT_FALSE(analysis.IsInContinueConstruct(3)); EXPECT_TRUE(analysis.IsMergeBlock(3)); // The inner merge is in the outer selection. EXPECT_EQ(analysis.ContainingConstruct(4), 1); EXPECT_EQ(analysis.ContainingLoop(4), 0); EXPECT_EQ(analysis.MergeBlock(4), 3); EXPECT_EQ(analysis.NestingDepth(4), 1); EXPECT_EQ(analysis.LoopMergeBlock(4), 0); EXPECT_EQ(analysis.LoopNestingDepth(4), 0); EXPECT_EQ(analysis.ContainingSwitch(4), 1); EXPECT_EQ(analysis.SwitchMergeBlock(4), 3); EXPECT_FALSE(analysis.IsContinueBlock(4)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(4)); EXPECT_FALSE(analysis.IsInContinueConstruct(4)); EXPECT_TRUE(analysis.IsMergeBlock(4)); // BB5 is in the inner selection. EXPECT_EQ(analysis.ContainingConstruct(5), 2); EXPECT_EQ(analysis.ContainingLoop(5), 0); EXPECT_EQ(analysis.MergeBlock(5), 4); EXPECT_EQ(analysis.NestingDepth(5), 2); EXPECT_EQ(analysis.LoopMergeBlock(5), 0); EXPECT_EQ(analysis.LoopNestingDepth(5), 0); EXPECT_EQ(analysis.ContainingSwitch(5), 1); EXPECT_EQ(analysis.SwitchMergeBlock(5), 3); EXPECT_FALSE(analysis.IsContinueBlock(5)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(5)); EXPECT_FALSE(analysis.IsInContinueConstruct(5)); EXPECT_FALSE(analysis.IsMergeBlock(5)); } TEST_F(StructCFGAnalysisTest, SwitchInSelection) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %void = OpTypeVoid %bool = OpTypeBool %bool_undef = OpUndef %bool %uint = OpTypeInt 32 0 %uint_undef = OpUndef %uint %void_func = OpTypeFunction %void %main = OpFunction %void None %void_func %entry_lab = OpLabel OpBranch %1 %1 = OpLabel OpSelectionMerge %3 None OpBranchConditional %undef_bool %2 %3 %2 = OpLabel OpSelectionMerge %4 None OpSwitch %uint_undef %4 7 %5 %5 = OpLabel OpBranch %4 %4 = OpLabel OpBranch %3 %3 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); StructuredCFGAnalysis analysis(context.get()); // The outer selection header is not in either construct. EXPECT_EQ(analysis.ContainingConstruct(1), 0); EXPECT_EQ(analysis.ContainingLoop(1), 0); EXPECT_EQ(analysis.MergeBlock(1), 0); EXPECT_EQ(analysis.NestingDepth(1), 0); EXPECT_EQ(analysis.LoopMergeBlock(1), 0); EXPECT_EQ(analysis.LoopNestingDepth(1), 0); EXPECT_EQ(analysis.ContainingSwitch(1), 0); EXPECT_EQ(analysis.SwitchMergeBlock(1), 0); EXPECT_FALSE(analysis.IsContinueBlock(1)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(1)); EXPECT_FALSE(analysis.IsInContinueConstruct(1)); EXPECT_FALSE(analysis.IsMergeBlock(1)); // The inner header is in the outer selection. EXPECT_EQ(analysis.ContainingConstruct(2), 1); EXPECT_EQ(analysis.ContainingLoop(2), 0); EXPECT_EQ(analysis.MergeBlock(2), 3); EXPECT_EQ(analysis.NestingDepth(2), 1); EXPECT_EQ(analysis.LoopMergeBlock(2), 0); EXPECT_EQ(analysis.LoopNestingDepth(2), 0); EXPECT_EQ(analysis.ContainingSwitch(2), 0); EXPECT_EQ(analysis.SwitchMergeBlock(2), 0); EXPECT_FALSE(analysis.IsContinueBlock(2)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(2)); EXPECT_FALSE(analysis.IsInContinueConstruct(2)); EXPECT_FALSE(analysis.IsMergeBlock(2)); // The outer merge node is not in either construct. EXPECT_EQ(analysis.ContainingConstruct(3), 0); EXPECT_EQ(analysis.ContainingLoop(3), 0); EXPECT_EQ(analysis.MergeBlock(3), 0); EXPECT_EQ(analysis.NestingDepth(3), 0); EXPECT_EQ(analysis.LoopMergeBlock(3), 0); EXPECT_EQ(analysis.LoopNestingDepth(3), 0); EXPECT_EQ(analysis.ContainingSwitch(3), 0); EXPECT_EQ(analysis.SwitchMergeBlock(3), 0); EXPECT_FALSE(analysis.IsContinueBlock(3)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(3)); EXPECT_FALSE(analysis.IsInContinueConstruct(3)); EXPECT_TRUE(analysis.IsMergeBlock(3)); // The inner merge is in the outer selection. EXPECT_EQ(analysis.ContainingConstruct(4), 1); EXPECT_EQ(analysis.ContainingLoop(4), 0); EXPECT_EQ(analysis.MergeBlock(4), 3); EXPECT_EQ(analysis.NestingDepth(4), 1); EXPECT_EQ(analysis.LoopMergeBlock(4), 0); EXPECT_EQ(analysis.LoopNestingDepth(4), 0); EXPECT_EQ(analysis.ContainingSwitch(4), 0); EXPECT_EQ(analysis.SwitchMergeBlock(4), 0); EXPECT_FALSE(analysis.IsContinueBlock(4)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(4)); EXPECT_FALSE(analysis.IsInContinueConstruct(4)); EXPECT_TRUE(analysis.IsMergeBlock(4)); // BB5 is in the inner selection. EXPECT_EQ(analysis.ContainingConstruct(5), 2); EXPECT_EQ(analysis.ContainingLoop(5), 0); EXPECT_EQ(analysis.MergeBlock(5), 4); EXPECT_EQ(analysis.NestingDepth(5), 2); EXPECT_EQ(analysis.LoopMergeBlock(5), 0); EXPECT_EQ(analysis.LoopNestingDepth(5), 0); EXPECT_EQ(analysis.ContainingSwitch(5), 2); EXPECT_EQ(analysis.SwitchMergeBlock(5), 4); EXPECT_FALSE(analysis.IsContinueBlock(5)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(5)); EXPECT_FALSE(analysis.IsInContinueConstruct(5)); EXPECT_FALSE(analysis.IsMergeBlock(5)); } TEST_F(StructCFGAnalysisTest, SelectionInContinue) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %void = OpTypeVoid %bool = OpTypeBool %bool_undef = OpUndef %bool %uint = OpTypeInt 32 0 %uint_undef = OpUndef %uint %void_func = OpTypeFunction %void %main = OpFunction %void None %void_func %entry_lab = OpLabel OpBranch %1 %1 = OpLabel OpLoopMerge %3 %4 None OpBranchConditional %undef_bool %2 %3 %2 = OpLabel OpBranch %3 %4 = OpLabel OpSelectionMerge %6 None OpBranchConditional %undef_bool %5 %6 %5 = OpLabel OpBranch %6 %6 = OpLabel OpBranch %1 %3 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); StructuredCFGAnalysis analysis(context.get()); // The loop header is not in either construct. EXPECT_EQ(analysis.ContainingConstruct(1), 0); EXPECT_EQ(analysis.ContainingLoop(1), 0); EXPECT_EQ(analysis.MergeBlock(1), 0); EXPECT_EQ(analysis.NestingDepth(1), 0); EXPECT_EQ(analysis.LoopMergeBlock(1), 0); EXPECT_EQ(analysis.LoopNestingDepth(1), 0); EXPECT_EQ(analysis.ContainingSwitch(1), 0); EXPECT_EQ(analysis.SwitchMergeBlock(1), 0); EXPECT_FALSE(analysis.IsContinueBlock(1)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(1)); EXPECT_FALSE(analysis.IsInContinueConstruct(1)); EXPECT_FALSE(analysis.IsMergeBlock(1)); // Selection header is in the loop only. EXPECT_EQ(analysis.ContainingConstruct(2), 1); EXPECT_EQ(analysis.ContainingLoop(2), 1); EXPECT_EQ(analysis.MergeBlock(2), 3); EXPECT_EQ(analysis.NestingDepth(2), 1); EXPECT_EQ(analysis.LoopMergeBlock(2), 3); EXPECT_EQ(analysis.LoopNestingDepth(2), 1); EXPECT_EQ(analysis.ContainingSwitch(2), 0); EXPECT_EQ(analysis.SwitchMergeBlock(2), 0); EXPECT_FALSE(analysis.IsContinueBlock(2)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(2)); EXPECT_FALSE(analysis.IsInContinueConstruct(2)); EXPECT_FALSE(analysis.IsMergeBlock(2)); // The loop merge node is not in either construct. EXPECT_EQ(analysis.ContainingConstruct(3), 0); EXPECT_EQ(analysis.ContainingLoop(3), 0); EXPECT_EQ(analysis.MergeBlock(3), 0); EXPECT_EQ(analysis.NestingDepth(3), 0); EXPECT_EQ(analysis.LoopMergeBlock(3), 0); EXPECT_EQ(analysis.LoopNestingDepth(3), 0); EXPECT_EQ(analysis.ContainingSwitch(3), 0); EXPECT_EQ(analysis.SwitchMergeBlock(3), 0); EXPECT_FALSE(analysis.IsContinueBlock(3)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(3)); EXPECT_FALSE(analysis.IsInContinueConstruct(3)); EXPECT_TRUE(analysis.IsMergeBlock(3)); // The continue block is in the loop only. EXPECT_EQ(analysis.ContainingConstruct(4), 1); EXPECT_EQ(analysis.ContainingLoop(4), 1); EXPECT_EQ(analysis.MergeBlock(4), 3); EXPECT_EQ(analysis.NestingDepth(4), 1); EXPECT_EQ(analysis.LoopMergeBlock(4), 3); EXPECT_EQ(analysis.LoopNestingDepth(4), 1); EXPECT_EQ(analysis.ContainingSwitch(4), 0); EXPECT_EQ(analysis.SwitchMergeBlock(4), 0); EXPECT_TRUE(analysis.IsContinueBlock(4)); EXPECT_TRUE(analysis.IsInContainingLoopsContinueConstruct(4)); EXPECT_TRUE(analysis.IsInContinueConstruct(4)); EXPECT_FALSE(analysis.IsMergeBlock(4)); // BB5 is in the selection and the continue for the loop. EXPECT_EQ(analysis.ContainingConstruct(5), 4); EXPECT_EQ(analysis.ContainingLoop(5), 1); EXPECT_EQ(analysis.MergeBlock(5), 6); EXPECT_EQ(analysis.NestingDepth(5), 2); EXPECT_EQ(analysis.LoopMergeBlock(5), 3); EXPECT_EQ(analysis.LoopNestingDepth(5), 1); EXPECT_EQ(analysis.ContainingSwitch(5), 0); EXPECT_EQ(analysis.SwitchMergeBlock(5), 0); EXPECT_FALSE(analysis.IsContinueBlock(5)); EXPECT_TRUE(analysis.IsInContainingLoopsContinueConstruct(5)); EXPECT_TRUE(analysis.IsInContinueConstruct(5)); EXPECT_FALSE(analysis.IsMergeBlock(5)); // BB5 is in the continue for the loop. EXPECT_EQ(analysis.ContainingConstruct(6), 1); EXPECT_EQ(analysis.ContainingLoop(6), 1); EXPECT_EQ(analysis.MergeBlock(6), 3); EXPECT_EQ(analysis.NestingDepth(6), 1); EXPECT_EQ(analysis.LoopMergeBlock(6), 3); EXPECT_EQ(analysis.LoopNestingDepth(6), 1); EXPECT_EQ(analysis.ContainingSwitch(6), 0); EXPECT_EQ(analysis.SwitchMergeBlock(6), 0); EXPECT_FALSE(analysis.IsContinueBlock(6)); EXPECT_TRUE(analysis.IsInContainingLoopsContinueConstruct(6)); EXPECT_TRUE(analysis.IsInContinueConstruct(6)); EXPECT_TRUE(analysis.IsMergeBlock(6)); } TEST_F(StructCFGAnalysisTest, LoopInContinue) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %void = OpTypeVoid %bool = OpTypeBool %bool_undef = OpUndef %bool %uint = OpTypeInt 32 0 %uint_undef = OpUndef %uint %void_func = OpTypeFunction %void %main = OpFunction %void None %void_func %entry_lab = OpLabel OpBranch %1 %1 = OpLabel OpLoopMerge %3 %7 None OpBranchConditional %undef_bool %2 %3 %2 = OpLabel OpBranchConditional %undef_bool %3 %7 %7 = OpLabel OpLoopMerge %4 %5 None OpBranchConditional %undef_bool %4 %6 %5 = OpLabel OpBranch %7 %6 = OpLabel OpBranch %4 %4 = OpLabel OpBranch %1 %3 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); StructuredCFGAnalysis analysis(context.get()); // The outer loop header is not in either construct. EXPECT_EQ(analysis.ContainingConstruct(1), 0); EXPECT_EQ(analysis.ContainingLoop(1), 0); EXPECT_EQ(analysis.MergeBlock(1), 0); EXPECT_EQ(analysis.NestingDepth(1), 0); EXPECT_EQ(analysis.LoopMergeBlock(1), 0); EXPECT_EQ(analysis.LoopNestingDepth(1), 0); EXPECT_EQ(analysis.ContainingSwitch(1), 0); EXPECT_EQ(analysis.SwitchMergeBlock(1), 0); EXPECT_FALSE(analysis.IsContinueBlock(1)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(1)); EXPECT_FALSE(analysis.IsInContinueConstruct(1)); EXPECT_FALSE(analysis.IsMergeBlock(1)); // BB2 is a regular block in the inner loop. EXPECT_EQ(analysis.ContainingConstruct(2), 1); EXPECT_EQ(analysis.ContainingLoop(2), 1); EXPECT_EQ(analysis.MergeBlock(2), 3); EXPECT_EQ(analysis.NestingDepth(2), 1); EXPECT_EQ(analysis.LoopMergeBlock(2), 3); EXPECT_EQ(analysis.LoopNestingDepth(2), 1); EXPECT_EQ(analysis.ContainingSwitch(2), 0); EXPECT_EQ(analysis.SwitchMergeBlock(2), 0); EXPECT_FALSE(analysis.IsContinueBlock(2)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(2)); EXPECT_FALSE(analysis.IsInContinueConstruct(2)); EXPECT_FALSE(analysis.IsMergeBlock(2)); // The outer merge node is not in either construct. EXPECT_EQ(analysis.ContainingConstruct(3), 0); EXPECT_EQ(analysis.ContainingLoop(3), 0); EXPECT_EQ(analysis.MergeBlock(3), 0); EXPECT_EQ(analysis.NestingDepth(3), 0); EXPECT_EQ(analysis.LoopMergeBlock(3), 0); EXPECT_EQ(analysis.LoopNestingDepth(3), 0); EXPECT_EQ(analysis.ContainingSwitch(3), 0); EXPECT_EQ(analysis.SwitchMergeBlock(3), 0); EXPECT_FALSE(analysis.IsContinueBlock(3)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(3)); EXPECT_FALSE(analysis.IsInContinueConstruct(3)); EXPECT_TRUE(analysis.IsMergeBlock(3)); // The inner merge is in the continue of the outer loop. EXPECT_EQ(analysis.ContainingConstruct(4), 1); EXPECT_EQ(analysis.ContainingLoop(4), 1); EXPECT_EQ(analysis.MergeBlock(4), 3); EXPECT_EQ(analysis.NestingDepth(4), 1); EXPECT_EQ(analysis.LoopMergeBlock(4), 3); EXPECT_EQ(analysis.LoopNestingDepth(4), 1); EXPECT_EQ(analysis.ContainingSwitch(4), 0); EXPECT_EQ(analysis.SwitchMergeBlock(4), 0); EXPECT_FALSE(analysis.IsContinueBlock(4)); EXPECT_TRUE(analysis.IsInContainingLoopsContinueConstruct(4)); EXPECT_TRUE(analysis.IsInContinueConstruct(4)); EXPECT_TRUE(analysis.IsMergeBlock(4)); // The inner continue target is in the inner loop. EXPECT_EQ(analysis.ContainingConstruct(5), 7); EXPECT_EQ(analysis.ContainingLoop(5), 7); EXPECT_EQ(analysis.MergeBlock(5), 4); EXPECT_EQ(analysis.NestingDepth(5), 2); EXPECT_EQ(analysis.LoopMergeBlock(5), 4); EXPECT_EQ(analysis.LoopNestingDepth(5), 2); EXPECT_EQ(analysis.ContainingSwitch(5), 0); EXPECT_EQ(analysis.SwitchMergeBlock(5), 0); EXPECT_TRUE(analysis.IsContinueBlock(5)); EXPECT_TRUE(analysis.IsInContainingLoopsContinueConstruct(5)); EXPECT_TRUE(analysis.IsInContinueConstruct(5)); EXPECT_FALSE(analysis.IsMergeBlock(5)); // BB6 is a regular block in the inner loop. EXPECT_EQ(analysis.ContainingConstruct(6), 7); EXPECT_EQ(analysis.ContainingLoop(6), 7); EXPECT_EQ(analysis.MergeBlock(6), 4); EXPECT_EQ(analysis.NestingDepth(6), 2); EXPECT_EQ(analysis.LoopMergeBlock(6), 4); EXPECT_EQ(analysis.LoopNestingDepth(6), 2); EXPECT_EQ(analysis.ContainingSwitch(6), 0); EXPECT_EQ(analysis.SwitchMergeBlock(6), 0); EXPECT_FALSE(analysis.IsContinueBlock(6)); EXPECT_FALSE(analysis.IsInContainingLoopsContinueConstruct(6)); EXPECT_TRUE(analysis.IsInContinueConstruct(6)); EXPECT_FALSE(analysis.IsMergeBlock(6)); // The outer continue target is in the outer loop. EXPECT_EQ(analysis.ContainingConstruct(7), 1); EXPECT_EQ(analysis.ContainingLoop(7), 1); EXPECT_EQ(analysis.MergeBlock(7), 3); EXPECT_EQ(analysis.NestingDepth(7), 1); EXPECT_EQ(analysis.LoopMergeBlock(7), 3); EXPECT_EQ(analysis.LoopNestingDepth(7), 1); EXPECT_EQ(analysis.ContainingSwitch(7), 0); EXPECT_EQ(analysis.SwitchMergeBlock(7), 0); EXPECT_TRUE(analysis.IsContinueBlock(7)); EXPECT_TRUE(analysis.IsInContainingLoopsContinueConstruct(7)); EXPECT_TRUE(analysis.IsInContinueConstruct(7)); EXPECT_FALSE(analysis.IsMergeBlock(7)); } TEST_F(StructCFGAnalysisTest, FuncCallInContinueDirect) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" %void = OpTypeVoid %bool = OpTypeBool %4 = OpUndef %bool %uint = OpTypeInt 32 0 %6 = OpUndef %uint %7 = OpTypeFunction %void %1 = OpFunction %void None %7 %8 = OpLabel OpBranch %9 %9 = OpLabel OpLoopMerge %10 %11 None OpBranchConditional %12 %10 %11 %11 = OpLabel %13 = OpFunctionCall %void %14 OpBranch %9 %10 = OpLabel %15 = OpFunctionCall %void %16 OpReturn OpFunctionEnd %14 = OpFunction %void None %7 %17 = OpLabel OpReturn OpFunctionEnd %16 = OpFunction %void None %7 %18 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); StructuredCFGAnalysis analysis(context.get()); auto c = analysis.FindFuncsCalledFromContinue(); EXPECT_THAT(c, UnorderedElementsAre(14u)); } TEST_F(StructCFGAnalysisTest, FuncCallInContinueIndirect) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" %void = OpTypeVoid %bool = OpTypeBool %4 = OpUndef %bool %uint = OpTypeInt 32 0 %6 = OpUndef %uint %7 = OpTypeFunction %void %1 = OpFunction %void None %7 %8 = OpLabel OpBranch %9 %9 = OpLabel OpLoopMerge %10 %11 None OpBranchConditional %12 %10 %11 %11 = OpLabel %13 = OpFunctionCall %void %14 OpBranch %9 %10 = OpLabel %15 = OpFunctionCall %void %16 OpReturn OpFunctionEnd %14 = OpFunction %void None %7 %17 = OpLabel %19 = OpFunctionCall %void %16 OpReturn OpFunctionEnd %16 = OpFunction %void None %7 %18 = OpLabel %20 = OpFunctionCall %void %21 OpReturn OpFunctionEnd %21 = OpFunction %void None %7 %22 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); StructuredCFGAnalysis analysis(context.get()); auto c = analysis.FindFuncsCalledFromContinue(); EXPECT_THAT(c, UnorderedElementsAre(14u, 16u, 21u)); } TEST_F(StructCFGAnalysisTest, SingleBlockLoop) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %bool = OpTypeBool %undef = OpUndef %bool %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %2 = OpLabel OpBranch %3 %3 = OpLabel OpLoopMerge %4 %3 None OpBranchConditional %undef %3 %4 %4 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); StructuredCFGAnalysis analysis(context.get()); EXPECT_TRUE(analysis.IsInContinueConstruct(3)); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/struct_packing_test.cpp000066400000000000000000000161301475742701700250760ustar00rootroot00000000000000// Copyright (c) 2024 Epic Games, Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gmock/gmock.h" #include "source/opt/struct_packing_pass.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using StructPackingTest = PassTest<::testing::Test>; TEST_F(StructPackingTest, PackSimpleStructStd140) { // #version 420 // // layout(std140, binding = 0) uniform Globals { // layout(offset = 16) vec3 a_xyz; // float a_w; // layout(offset = 128) vec3 b_xyz; // int b_w; // }; // // void main() {} const std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginLowerLeft OpSource GLSL 420 OpName %main "main" OpName %Globals "Globals" OpMemberName %Globals 0 "a_xyz" OpMemberName %Globals 1 "a_w" OpMemberName %Globals 2 "b_xyz" OpMemberName %Globals 3 "b_w" OpName %_ "" ; CHECK: OpMemberDecorate %Globals 0 Offset 0 OpMemberDecorate %Globals 0 Offset 16 ; CHECK: OpMemberDecorate %Globals 1 Offset 12 OpMemberDecorate %Globals 1 Offset 28 ; CHECK: OpMemberDecorate %Globals 2 Offset 16 OpMemberDecorate %Globals 2 Offset 128 ; CHECK: OpMemberDecorate %Globals 3 Offset 28 OpMemberDecorate %Globals 3 Offset 140 OpDecorate %Globals Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %int = OpTypeInt 32 1 %Globals = OpTypeStruct %v3float %float %v3float %int %_ptr_Uniform_Globals = OpTypePointer Uniform %Globals %_ = OpVariable %_ptr_Uniform_Globals Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch( spirv, true, "Globals", StructPackingPass::PackingRules::Std140); } TEST_F(StructPackingTest, PackSimpleStructWithPaddingStd140) { // #version 420 // // layout(std140, binding = 0) uniform Globals { // layout(offset = 16) vec3 a_xyz; // float a_w; // float b_x_padding_yzw; // layout(offset = 128) vec3 c_xyz; // int c_w; // }; // // void main() {} const std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginLowerLeft OpSource GLSL 420 OpName %main "main" OpName %Globals "Globals" OpMemberName %Globals 0 "a_xyz" OpMemberName %Globals 1 "a_w" OpMemberName %Globals 2 "b_x_padding_yzw" OpMemberName %Globals 3 "c_xyz" OpMemberName %Globals 4 "c_w" OpName %_ "" ; CHECK: OpMemberDecorate %Globals 0 Offset 0 OpMemberDecorate %Globals 0 Offset 16 ; CHECK: OpMemberDecorate %Globals 1 Offset 12 OpMemberDecorate %Globals 1 Offset 28 ; CHECK: OpMemberDecorate %Globals 2 Offset 16 OpMemberDecorate %Globals 2 Offset 32 ; CHECK: OpMemberDecorate %Globals 3 Offset 32 OpMemberDecorate %Globals 3 Offset 128 ; CHECK: OpMemberDecorate %Globals 4 Offset 44 OpMemberDecorate %Globals 4 Offset 140 OpDecorate %Globals Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %int = OpTypeInt 32 1 %Globals = OpTypeStruct %v3float %float %float %v3float %int %_ptr_Uniform_Globals = OpTypePointer Uniform %Globals %_ = OpVariable %_ptr_Uniform_Globals Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch( spirv, true, "Globals", StructPackingPass::PackingRules::Std140); } TEST_F(StructPackingTest, PackSimpleScalarArrayStd140) { // #version 420 // // layout(std140, binding = 0) uniform Globals { // layout(offset = 16) float a[2]; // layout(offset = 128) float b[2]; // Must become offset 32 with std140 // }; // // void main() {} const std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginLowerLeft OpSource GLSL 420 OpName %main "main" OpName %Globals "Globals" OpMemberName %Globals 0 "a" OpMemberName %Globals 1 "b" OpName %_ "" OpDecorate %_arr_float_uint_2 ArrayStride 16 OpDecorate %_arr_float_uint_2_0 ArrayStride 16 ; CHECK: OpMemberDecorate %Globals 0 Offset 0 OpMemberDecorate %Globals 0 Offset 16 ; CHECK: OpMemberDecorate %Globals 1 Offset 32 OpMemberDecorate %Globals 1 Offset 128 OpDecorate %Globals Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_arr_float_uint_2 = OpTypeArray %float %uint_2 %_arr_float_uint_2_0 = OpTypeArray %float %uint_2 %Globals = OpTypeStruct %_arr_float_uint_2 %_arr_float_uint_2_0 %_ptr_Uniform_Globals = OpTypePointer Uniform %Globals %_ = OpVariable %_ptr_Uniform_Globals Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch( spirv, true, "Globals", StructPackingPass::PackingRules::Std140); } TEST_F(StructPackingTest, PackSimpleScalarArrayStd430) { // #version 430 // // layout(std430, binding = 0) buffer Globals { // layout(offset = 16) float a[2]; // layout(offset = 128) float b[2]; // Must become offset 8 with std430 // }; // // void main() {} const std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginLowerLeft OpSource GLSL 430 OpName %main "main" OpName %Globals "Globals" OpMemberName %Globals 0 "a" OpMemberName %Globals 1 "b" OpName %_ "" OpDecorate %_arr_float_uint_2 ArrayStride 4 OpDecorate %_arr_float_uint_2_0 ArrayStride 4 ; CHECK: OpMemberDecorate %Globals 0 Offset 0 OpMemberDecorate %Globals 0 Offset 16 ; CHECK: OpMemberDecorate %Globals 1 Offset 8 OpMemberDecorate %Globals 1 Offset 128 OpDecorate %Globals BufferBlock OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_arr_float_uint_2 = OpTypeArray %float %uint_2 %_arr_float_uint_2_0 = OpTypeArray %float %uint_2 %Globals = OpTypeStruct %_arr_float_uint_2 %_arr_float_uint_2_0 %_ptr_Uniform_Globals = OpTypePointer Uniform %Globals %_ = OpVariable %_ptr_Uniform_Globals Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch( spirv, true, "Globals", StructPackingPass::PackingRules::Std430); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/switch_descriptorset_test.cpp000066400000000000000000000143721475742701700263370ustar00rootroot00000000000000// Copyright (c) 2023 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Bindless Check Instrumentation Tests. // Tests ending with V2 use version 2 record format. #include #include #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using SwitchDescriptorSetTest = PassTest<::testing::Test>; TEST_F(SwitchDescriptorSetTest, Basic) { // #version 450 // #extension GL_EXT_buffer_reference : enable // // layout(buffer_reference, buffer_reference_align = 16) buffer bufStruct; // // layout(set = 7, binding = 7) uniform ufoo { // bufStruct data; // uint offset; // } u_info; // // layout(buffer_reference, std140) buffer bufStruct { // layout(offset = 0) int a[2]; // layout(offset = 32) int b; // }; // // void main() { // u_info.data.b = 0xca7; // } const std::string spirv = R"( OpCapability Shader OpCapability PhysicalStorageBufferAddresses OpExtension "SPV_EXT_physical_storage_buffer" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpSourceExtension "GL_EXT_buffer_reference" OpName %main "main" OpName %ufoo "ufoo" OpMemberName %ufoo 0 "data" OpMemberName %ufoo 1 "offset" OpName %bufStruct "bufStruct" OpMemberName %bufStruct 0 "a" OpMemberName %bufStruct 1 "b" OpName %u_info "u_info" OpMemberDecorate %ufoo 0 Offset 0 OpMemberDecorate %ufoo 1 Offset 8 OpDecorate %ufoo Block OpDecorate %_arr_int_uint_2 ArrayStride 16 OpMemberDecorate %bufStruct 0 Offset 0 OpMemberDecorate %bufStruct 1 Offset 32 OpDecorate %bufStruct Block OpDecorate %u_info DescriptorSet 7 ;CHECK: OpDecorate %u_info DescriptorSet 31 OpDecorate %u_info Binding 7 ;CHECK: OpDecorate %u_info Binding 7 %void = OpTypeVoid %3 = OpTypeFunction %void OpTypeForwardPointer %_ptr_PhysicalStorageBuffer_bufStruct PhysicalStorageBuffer %uint = OpTypeInt 32 0 %ufoo = OpTypeStruct %_ptr_PhysicalStorageBuffer_bufStruct %uint %int = OpTypeInt 32 1 %uint_2 = OpConstant %uint 2 %_arr_int_uint_2 = OpTypeArray %int %uint_2 %bufStruct = OpTypeStruct %_arr_int_uint_2 %int %_ptr_PhysicalStorageBuffer_bufStruct = OpTypePointer PhysicalStorageBuffer %bufStruct %_ptr_Uniform_ufoo = OpTypePointer Uniform %ufoo %u_info = OpVariable %_ptr_Uniform_ufoo Uniform %int_0 = OpConstant %int 0 %_ptr_Uniform__ptr_PhysicalStorageBuffer_bufStruct = OpTypePointer Uniform %_ptr_PhysicalStorageBuffer_bufStruct %int_1 = OpConstant %int 1 %int_3239 = OpConstant %int 3239 %_ptr_PhysicalStorageBuffer_int = OpTypePointer PhysicalStorageBuffer %int %main = OpFunction %void None %3 %5 = OpLabel %17 = OpAccessChain %_ptr_Uniform__ptr_PhysicalStorageBuffer_bufStruct %u_info %int_0 %18 = OpLoad %_ptr_PhysicalStorageBuffer_bufStruct %17 %22 = OpAccessChain %_ptr_PhysicalStorageBuffer_int %18 %int_1 OpReturn OpFunctionEnd )"; // clang-format off SinglePassRunAndMatch(spirv, true, 7, 31); } // Make sure DescriptorSet decorations that don't match the requested number // are left unchanged. TEST_F(SwitchDescriptorSetTest, Unchanged) { // #version 450 // #extension GL_EXT_buffer_reference : enable // // layout(buffer_reference, buffer_reference_align = 16) buffer bufStruct; // // layout(set = 11, binding = 7) uniform ufoo { // bufStruct data; // uint offset; // } u_info; // // layout(buffer_reference, std140) buffer bufStruct { // layout(offset = 0) int a[2]; // layout(offset = 32) int b; // }; // // void main() { // u_info.data.b = 0xca7; // } const std::string spirv = R"( OpCapability Shader OpCapability PhysicalStorageBufferAddresses OpExtension "SPV_EXT_physical_storage_buffer" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpSourceExtension "GL_EXT_buffer_reference" OpName %main "main" OpName %ufoo "ufoo" OpMemberName %ufoo 0 "data" OpMemberName %ufoo 1 "offset" OpName %bufStruct "bufStruct" OpMemberName %bufStruct 0 "a" OpMemberName %bufStruct 1 "b" OpName %u_info "u_info" OpMemberDecorate %ufoo 0 Offset 0 OpMemberDecorate %ufoo 1 Offset 8 OpDecorate %ufoo Block OpDecorate %_arr_int_uint_2 ArrayStride 16 OpMemberDecorate %bufStruct 0 Offset 0 OpMemberDecorate %bufStruct 1 Offset 32 OpDecorate %bufStruct Block OpDecorate %u_info DescriptorSet 11 ;CHECK: OpDecorate %u_info DescriptorSet 11 OpDecorate %u_info Binding 7 ;CHECK: OpDecorate %u_info Binding 7 %void = OpTypeVoid %3 = OpTypeFunction %void OpTypeForwardPointer %_ptr_PhysicalStorageBuffer_bufStruct PhysicalStorageBuffer %uint = OpTypeInt 32 0 %ufoo = OpTypeStruct %_ptr_PhysicalStorageBuffer_bufStruct %uint %int = OpTypeInt 32 1 %uint_2 = OpConstant %uint 2 %_arr_int_uint_2 = OpTypeArray %int %uint_2 %bufStruct = OpTypeStruct %_arr_int_uint_2 %int %_ptr_PhysicalStorageBuffer_bufStruct = OpTypePointer PhysicalStorageBuffer %bufStruct %_ptr_Uniform_ufoo = OpTypePointer Uniform %ufoo %u_info = OpVariable %_ptr_Uniform_ufoo Uniform %int_0 = OpConstant %int 0 %_ptr_Uniform__ptr_PhysicalStorageBuffer_bufStruct = OpTypePointer Uniform %_ptr_PhysicalStorageBuffer_bufStruct %int_1 = OpConstant %int 1 %int_3239 = OpConstant %int 3239 %_ptr_PhysicalStorageBuffer_int = OpTypePointer PhysicalStorageBuffer %int %main = OpFunction %void None %3 %5 = OpLabel %17 = OpAccessChain %_ptr_Uniform__ptr_PhysicalStorageBuffer_bufStruct %u_info %int_0 %18 = OpLoad %_ptr_PhysicalStorageBuffer_bufStruct %17 %22 = OpAccessChain %_ptr_PhysicalStorageBuffer_int %18 %int_1 OpReturn OpFunctionEnd )"; // clang-format off SinglePassRunAndMatch(spirv, true, 7, 31); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/trim_capabilities_pass_test.cpp000066400000000000000000004176221475742701700266030ustar00rootroot00000000000000// Copyright (c) 2023 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include "spirv-tools/optimizer.hpp" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using TrimCapabilitiesPassTest = PassTest<::testing::Test>; TEST_F(TrimCapabilitiesPassTest, CheckKnownAliasTransformations) { // Those are expected changes caused by the test process: // - SPV is assembled. -> capability goes from text to number. // - SPV is optimized. // - SPV is disassembled -> capability goes from number to text. // - CHECK rule compares both text versions. // Because some capabilities share the same number (aliases), the text // compared with the CHECK rules depends on which alias is the first on the // SPIRV-Headers enum. This could change, and we want to easily distinguish // real failure from alias order change. This test is only here to list known // alias transformations. If this test breaks, it's not a bug in the // optimization pass, but just the SPIRV-Headers enum order that has changed. // If that happens, tests needs to be updated to the correct alias is used in // the CHECK rule. const std::string kTest = R"( OpCapability Linkage OpCapability StorageUniform16 OpCapability StorageUniformBufferBlock16 OpCapability ShaderViewportIndexLayerNV OpCapability FragmentBarycentricNV OpCapability ShadingRateNV OpCapability ShaderNonUniformEXT OpCapability RuntimeDescriptorArrayEXT OpCapability InputAttachmentArrayDynamicIndexingEXT OpCapability UniformTexelBufferArrayDynamicIndexingEXT OpCapability StorageTexelBufferArrayDynamicIndexingEXT OpCapability UniformBufferArrayNonUniformIndexingEXT OpCapability SampledImageArrayNonUniformIndexingEXT OpCapability StorageBufferArrayNonUniformIndexingEXT OpCapability StorageImageArrayNonUniformIndexingEXT OpCapability InputAttachmentArrayNonUniformIndexingEXT OpCapability UniformTexelBufferArrayNonUniformIndexingEXT OpCapability StorageTexelBufferArrayNonUniformIndexingEXT OpCapability VulkanMemoryModelKHR OpCapability VulkanMemoryModelDeviceScopeKHR OpCapability PhysicalStorageBufferAddressesEXT OpCapability DemoteToHelperInvocationEXT OpCapability DotProductInputAllKHR OpCapability DotProductInput4x8BitKHR OpCapability DotProductInput4x8BitPackedKHR OpCapability DotProductKHR OpCapability ComputeDerivativeGroupQuadsKHR OpCapability ComputeDerivativeGroupLinearKHR ; CHECK: OpCapability Linkage ; CHECK-NOT: OpCapability StorageUniform16 ; CHECK-NOT: OpCapability StorageUniformBufferBlock16 ; CHECK-NOT: OpCapability ShaderViewportIndexLayerNV ; CHECK-NOT: OpCapability FragmentBarycentricNV ; CHECK-NOT: OpCapability ShadingRateNV ; CHECK-NOT: OpCapability ShaderNonUniformEXT ; CHECK-NOT: OpCapability RuntimeDescriptorArrayEXT ; CHECK-NOT: OpCapability InputAttachmentArrayDynamicIndexingEXT ; CHECK-NOT: OpCapability UniformTexelBufferArrayDynamicIndexingEXT ; CHECK-NOT: OpCapability StorageTexelBufferArrayDynamicIndexingEXT ; CHECK-NOT: OpCapability UniformBufferArrayNonUniformIndexingEXT ; CHECK-NOT: OpCapability SampledImageArrayNonUniformIndexingEXT ; CHECK-NOT: OpCapability StorageBufferArrayNonUniformIndexingEXT ; CHECK-NOT: OpCapability StorageImageArrayNonUniformIndexingEXT ; CHECK-NOT: OpCapability InputAttachmentArrayNonUniformIndexingEXT ; CHECK-NOT: OpCapability UniformTexelBufferArrayNonUniformIndexingEXT ; CHECK-NOT: OpCapability StorageTexelBufferArrayNonUniformIndexingEXT ; CHECK-NOT: OpCapability VulkanMemoryModelKHR ; CHECK-NOT: OpCapability VulkanMemoryModelDeviceScopeKHR ; CHECK-NOT: OpCapability PhysicalStorageBufferAddressesEXT ; CHECK-NOT: OpCapability DemoteToHelperInvocationEXT ; CHECK-NOT: OpCapability DotProductInputAllKHR ; CHECK-NOT: OpCapability DotProductInput4x8BitKHR ; CHECK-NOT: OpCapability DotProductInput4x8BitPackedKHR ; CHECK-NOT: OpCapability DotProductKHR ; CHECK-NOT: OpCapability ComputeDerivativeGroupQuadsKHR ; CHECK-NOT: OpCapability ComputeDerivativeGroupLinearKHR ; CHECK: OpCapability UniformAndStorageBuffer16BitAccess ; CHECK: OpCapability StorageBuffer16BitAccess ; CHECK: OpCapability ShaderViewportIndexLayerEXT ; CHECK: OpCapability FragmentBarycentricKHR ; CHECK: OpCapability FragmentDensityEXT ; CHECK: OpCapability ShaderNonUniform ; CHECK: OpCapability RuntimeDescriptorArray ; CHECK: OpCapability InputAttachmentArrayDynamicIndexing ; CHECK: OpCapability UniformTexelBufferArrayDynamicIndexing ; CHECK: OpCapability StorageTexelBufferArrayDynamicIndexing ; CHECK: OpCapability UniformBufferArrayNonUniformIndexing ; CHECK: OpCapability SampledImageArrayNonUniformIndexing ; CHECK: OpCapability StorageBufferArrayNonUniformIndexing ; CHECK: OpCapability StorageImageArrayNonUniformIndexing ; CHECK: OpCapability InputAttachmentArrayNonUniformIndexing ; CHECK: OpCapability UniformTexelBufferArrayNonUniformIndexing ; CHECK: OpCapability StorageTexelBufferArrayNonUniformIndexing ; CHECK: OpCapability VulkanMemoryModel ; CHECK: OpCapability VulkanMemoryModelDeviceScope ; CHECK: OpCapability PhysicalStorageBufferAddresses ; CHECK: OpCapability DemoteToHelperInvocation ; CHECK: OpCapability DotProductInputAll ; CHECK: OpCapability DotProductInput4x8Bit ; CHECK: OpCapability DotProductInput4x8BitPacked ; CHECK: OpCapability DotProduct OpMemoryModel Logical Vulkan OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %3 = OpTypeFunction %void %1 = OpFunction %void None %3 %6 = OpLabel OpReturn OpFunctionEnd; )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, LinkagePreventsChanges) { const std::string kTest = R"( OpCapability Linkage OpCapability ClipDistance OpCapability CullDistance OpCapability DemoteToHelperInvocation OpCapability DeviceGroup OpCapability DrawParameters OpCapability Float16 OpCapability Float64 OpCapability FragmentBarycentricKHR OpCapability FragmentFullyCoveredEXT OpCapability FragmentShadingRateKHR OpCapability GroupNonUniform OpCapability GroupNonUniformArithmetic OpCapability GroupNonUniformBallot OpCapability GroupNonUniformQuad OpCapability GroupNonUniformShuffle OpCapability Image1D OpCapability ImageBuffer OpCapability ImageGatherExtended OpCapability ImageMSArray OpCapability ImageQuery OpCapability InputAttachment OpCapability InputAttachmentArrayNonUniformIndexing OpCapability Int16 OpCapability Int64 OpCapability Int64Atomics OpCapability Int64ImageEXT OpCapability MeshShadingNV OpCapability MinLod OpCapability MultiView OpCapability MultiViewport OpCapability PhysicalStorageBufferAddresses OpCapability RayQueryKHR OpCapability RayTracingKHR OpCapability RayTracingNV OpCapability RayTraversalPrimitiveCullingKHR OpCapability RuntimeDescriptorArray OpCapability SampleMaskPostDepthCoverage OpCapability SampleRateShading OpCapability Sampled1D OpCapability SampledBuffer OpCapability SampledImageArrayNonUniformIndexing OpCapability Shader OpCapability ShaderClockKHR OpCapability ShaderLayer OpCapability ShaderNonUniform OpCapability ShaderViewportIndex OpCapability ShaderViewportIndexLayerEXT OpCapability SparseResidency OpCapability StencilExportEXT OpCapability StorageImageArrayNonUniformIndexingEXT OpCapability StorageImageExtendedFormats OpCapability StorageImageReadWithoutFormat OpCapability StorageImageWriteWithoutFormat OpCapability StorageInputOutput16 OpCapability StoragePushConstant16 OpCapability StorageTexelBufferArrayNonUniformIndexing OpCapability StorageUniform16 OpCapability StorageUniformBufferBlock16 OpCapability Tessellation OpCapability UniformTexelBufferArrayNonUniformIndexing OpCapability VulkanMemoryModel OpExtension "SPV_EXT_fragment_fully_covered" OpExtension "SPV_EXT_shader_image_int64" OpExtension "SPV_EXT_shader_stencil_export" OpExtension "SPV_EXT_shader_viewport_index_layer" OpExtension "SPV_KHR_fragment_shader_barycentric" OpExtension "SPV_KHR_fragment_shading_rate" OpExtension "SPV_KHR_post_depth_coverage" OpExtension "SPV_KHR_ray_query" OpExtension "SPV_KHR_ray_tracing" OpExtension "SPV_KHR_shader_clock" OpExtension "SPV_NV_mesh_shader" OpExtension "SPV_NV_ray_tracing" OpExtension "SPV_NV_viewport_array2" ; CHECK: OpCapability Linkage ; CHECK: OpCapability ClipDistance ; CHECK: OpCapability CullDistance ; CHECK: OpCapability DemoteToHelperInvocation ; CHECK: OpCapability DeviceGroup ; CHECK: OpCapability DrawParameters ; CHECK: OpCapability Float16 ; CHECK: OpCapability Float64 ; CHECK: OpCapability FragmentBarycentricKHR ; CHECK: OpCapability FragmentFullyCoveredEXT ; CHECK: OpCapability FragmentShadingRateKHR ; CHECK: OpCapability GroupNonUniform ; CHECK: OpCapability GroupNonUniformArithmetic ; CHECK: OpCapability GroupNonUniformBallot ; CHECK: OpCapability GroupNonUniformQuad ; CHECK: OpCapability GroupNonUniformShuffle ; CHECK: OpCapability Image1D ; CHECK: OpCapability ImageBuffer ; CHECK: OpCapability ImageGatherExtended ; CHECK: OpCapability ImageMSArray ; CHECK: OpCapability ImageQuery ; CHECK: OpCapability InputAttachment ; CHECK: OpCapability InputAttachmentArrayNonUniformIndexing ; CHECK: OpCapability Int16 ; CHECK: OpCapability Int64 ; CHECK: OpCapability Int64Atomics ; CHECK: OpCapability Int64ImageEXT ; CHECK: OpCapability MeshShadingNV ; CHECK: OpCapability MinLod ; CHECK: OpCapability MultiView ; CHECK: OpCapability MultiViewport ; CHECK: OpCapability PhysicalStorageBufferAddresses ; CHECK: OpCapability RayQueryKHR ; CHECK: OpCapability RayTracingKHR ; CHECK: OpCapability RayTracingNV ; CHECK: OpCapability RayTraversalPrimitiveCullingKHR ; CHECK: OpCapability RuntimeDescriptorArray ; CHECK: OpCapability SampleMaskPostDepthCoverage ; CHECK: OpCapability SampleRateShading ; CHECK: OpCapability Sampled1D ; CHECK: OpCapability SampledBuffer ; CHECK: OpCapability SampledImageArrayNonUniformIndexing ; CHECK: OpCapability Shader ; CHECK: OpCapability ShaderClockKHR ; CHECK: OpCapability ShaderLayer ; CHECK: OpCapability ShaderNonUniform ; CHECK: OpCapability ShaderViewportIndex ; CHECK: OpCapability ShaderViewportIndexLayerEXT ; CHECK: OpCapability SparseResidency ; CHECK: OpCapability StencilExportEXT ; CHECK: OpCapability StorageImageArrayNonUniformIndexing ; CHECK: OpCapability StorageImageExtendedFormats ; CHECK: OpCapability StorageImageReadWithoutFormat ; CHECK: OpCapability StorageImageWriteWithoutFormat ; CHECK: OpCapability StorageInputOutput16 ; CHECK: OpCapability StoragePushConstant16 ; CHECK: OpCapability StorageTexelBufferArrayNonUniformIndexing ; CHECK: OpCapability Tessellation ; CHECK: OpCapability UniformTexelBufferArrayNonUniformIndex ; CHECK: OpCapability VulkanMemoryModel ; CHECK: OpExtension "SPV_EXT_fragment_fully_covered" ; CHECK: OpExtension "SPV_EXT_shader_image_int64" ; CHECK: OpExtension "SPV_EXT_shader_stencil_export" ; CHECK: OpExtension "SPV_EXT_shader_viewport_index_layer" ; CHECK: OpExtension "SPV_KHR_fragment_shader_barycentric" ; CHECK: OpExtension "SPV_KHR_fragment_shading_rate" ; CHECK: OpExtension "SPV_KHR_post_depth_coverage" ; CHECK: OpExtension "SPV_KHR_ray_query" ; CHECK: OpExtension "SPV_KHR_ray_tracing" ; CHECK: OpExtension "SPV_KHR_shader_clock" ; CHECK: OpExtension "SPV_NV_mesh_shader" ; CHECK: OpExtension "SPV_NV_ray_tracing" ; CHECK: OpExtension "SPV_NV_viewport_array2" OpMemoryModel Logical Vulkan %void = OpTypeVoid %3 = OpTypeFunction %void %1 = OpFunction %void None %3 %6 = OpLabel OpReturn OpFunctionEnd; )"; SetTargetEnv(SPV_ENV_VULKAN_1_3); const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, KeepShader) { const std::string kTest = R"( OpCapability Shader ; CHECK: OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %3 = OpTypeFunction %void %1 = OpFunction %void None %3 %6 = OpLabel OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, KeepShaderClockWhenInUse) { const std::string kTest = R"( OpCapability Shader OpCapability Int64 OpCapability ShaderClockKHR OpExtension "SPV_KHR_shader_clock" ; CHECK: OpCapability ShaderClockKHR ; CHECK: OpExtension "SPV_KHR_shader_clock" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %uint = OpTypeInt 32 0 %ulong = OpTypeInt 64 0 %scope = OpConstant %uint 1 %3 = OpTypeFunction %void %1 = OpFunction %void None %3 %6 = OpLabel %7 = OpReadClockKHR %ulong %scope OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, TrimShaderClockWhenUnused) { const std::string kTest = R"( OpCapability Shader OpCapability Int64 OpCapability ShaderClockKHR OpExtension "SPV_KHR_shader_clock" ; CHECK-NOT: OpCapability ShaderClockKHR ; CHECK-NOT: OpExtension "SPV_KHR_shader_clock" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %3 = OpTypeFunction %void %1 = OpFunction %void None %3 %6 = OpLabel OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, AMDShaderBallotExtensionRemains) { const std::string kTest = R"( OpCapability Shader OpCapability Groups OpExtension "SPV_AMD_shader_ballot" ; CHECK: OpCapability Groups ; CHECK: OpExtension "SPV_AMD_shader_ballot" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %uint = OpTypeInt 32 0 %1 = OpTypeFunction %void %uint_0 = OpConstant %uint 0 %2 = OpFunction %void None %1 %3 = OpLabel %4 = OpGroupIAddNonUniformAMD %uint %uint_0 ExclusiveScan %uint_0 OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, AMDShaderBallotExtensionRemoved) { const std::string kTest = R"( OpCapability Shader OpCapability Groups OpExtension "SPV_AMD_shader_ballot" ; CHECK-NOT: OpCapability Groups ; CHECK-NOT: OpExtension "SPV_AMD_shader_ballot" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, MinLod_RemovedIfNotUsed) { const std::string kTest = R"( OpCapability Shader OpCapability Sampled1D OpCapability MinLod ; CHECK-NOT: OpCapability MinLod OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %v4float = OpTypeVector %float 4 %type_image = OpTypeImage %float Cube 2 0 0 1 Rgba32f %ptr_type_image = OpTypePointer UniformConstant %type_image %type_sampler = OpTypeSampler %ptr_type_sampler = OpTypePointer UniformConstant %type_sampler %float_0 = OpConstant %float 0 %float_000 = OpConstantComposite %v3float %float_0 %float_0 %float_0 %image = OpVariable %ptr_type_image UniformConstant %sampler = OpVariable %ptr_type_sampler UniformConstant %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel %21 = OpLoad %type_image %image %22 = OpLoad %type_sampler %sampler %24 = OpSampledImage %type_sampled_image %21 %22 %25 = OpImageSampleImplicitLod %v4float %24 %float_000 OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, MinLod_RemainsWithOpImageSampleImplicitLod) { const std::string kTest = R"( OpCapability Shader OpCapability Sampled1D OpCapability MinLod ; CHECK: OpCapability MinLod OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %v4float = OpTypeVector %float 4 %type_image = OpTypeImage %float Cube 2 0 0 1 Rgba32f %ptr_type_image = OpTypePointer UniformConstant %type_image %type_sampler = OpTypeSampler %ptr_type_sampler = OpTypePointer UniformConstant %type_sampler %float_0 = OpConstant %float 0 %float_000 = OpConstantComposite %v3float %float_0 %float_0 %float_0 %image = OpVariable %ptr_type_image UniformConstant %sampler = OpVariable %ptr_type_sampler UniformConstant %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel %21 = OpLoad %type_image %image %22 = OpLoad %type_sampler %sampler %24 = OpSampledImage %type_sampled_image %21 %22 %25 = OpImageSampleImplicitLod %v4float %24 %float_000 MinLod %float_0 OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, MinLod_RemainsWithOpImageSparseSampleImplicitLod) { const std::string kTest = R"( OpCapability Shader OpCapability SparseResidency OpCapability ImageGatherExtended OpCapability MinLod ; CHECK: OpCapability MinLod OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft %void = OpTypeVoid %uint = OpTypeInt 32 0 %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %v3float = OpTypeVector %float 3 %v4float = OpTypeVector %float 4 %type_image = OpTypeImage %float 2D 2 0 0 1 Unknown %ptr_type_image = OpTypePointer UniformConstant %type_image %type_sampler = OpTypeSampler %ptr_type_sampler = OpTypePointer UniformConstant %type_sampler %type_sampled_image = OpTypeSampledImage %type_image %sparse_struct = OpTypeStruct %uint %v4float %float_0 = OpConstant %float 0 %float_00 = OpConstantComposite %v2float %float_0 %float_0 %float_000 = OpConstantComposite %v3float %float_0 %float_0 %float_0 %image = OpVariable %ptr_type_image UniformConstant %sampler = OpVariable %ptr_type_sampler UniformConstant %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel %21 = OpLoad %type_image %image %22 = OpLoad %type_sampler %sampler %24 = OpSampledImage %type_sampled_image %21 %22 %25 = OpImageSparseSampleImplicitLod %sparse_struct %24 %float_00 MinLod %float_0 OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, MinLod_DetectsMinLodWithBitmaskImageOperand) { const std::string kTest = R"( OpCapability MinLod ; CHECK: OpCapability MinLod OpCapability Shader OpCapability SparseResidency OpCapability ImageGatherExtended OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft %type_sampler = OpTypeSampler %int = OpTypeInt 32 1 %float = OpTypeFloat 32 %v2int = OpTypeVector %int 2 %v2float = OpTypeVector %float 2 %v4float = OpTypeVector %float 4 %ptr_sampler = OpTypePointer UniformConstant %type_sampler %type_image = OpTypeImage %float 2D 2 0 0 1 Unknown %ptr_image = OpTypePointer UniformConstant %type_image %void = OpTypeVoid %uint = OpTypeInt 32 0 %type_sampled_image = OpTypeSampledImage %type_image %type_struct = OpTypeStruct %uint %v4float %int_1 = OpConstant %int 1 %float_0 = OpConstant %float 0 %float_1 = OpConstant %float 1 %8 = OpConstantComposite %v2float %float_0 %float_0 %12 = OpConstantComposite %v2int %int_1 %int_1 %2 = OpVariable %ptr_sampler UniformConstant %3 = OpVariable %ptr_image UniformConstant %27 = OpTypeFunction %void %1 = OpFunction %void None %27 %28 = OpLabel %29 = OpLoad %type_image %3 %30 = OpLoad %type_sampler %2 %31 = OpSampledImage %type_sampled_image %29 %30 %32 = OpImageSparseSampleImplicitLod %type_struct %31 %8 ConstOffset|MinLod %12 %float_0 OpReturn OpFunctionEnd )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, StorageInputOutput16_RemainsWithInputPointer_Vulkan1_0) { const std::string kTest = R"( OpCapability Shader OpCapability Float16 OpCapability StorageInputOutput16 OpExtension "SPV_KHR_16bit_storage" ; CHECK: OpCapability StorageInputOutput16 ; CHECK: OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" %void = OpTypeVoid %half = OpTypeFloat 16 %ptr = OpTypePointer Input %half %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_0); const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, StorageInputOutput16_RemainsWithInputPointer_Vulkan1_1) { const std::string kTest = R"( OpCapability Shader OpCapability Float16 OpCapability StorageInputOutput16 OpExtension "SPV_KHR_16bit_storage" ; CHECK: OpCapability StorageInputOutput16 ; CHECK-NOT: OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" %void = OpTypeVoid %half = OpTypeFloat 16 %ptr = OpTypePointer Input %half %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_1); const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, StorageInputOutput16_RemainsWithInputPointerArray_Vulkan1_0) { const std::string kTest = R"( OpCapability Shader OpCapability Float16 OpCapability StorageInputOutput16 OpExtension "SPV_KHR_16bit_storage" ; CHECK: OpCapability StorageInputOutput16 ; CHECK: OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" %void = OpTypeVoid %half = OpTypeFloat 16 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %array = OpTypeArray %half %uint_1 %ptr = OpTypePointer Input %array %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_0); const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, StorageInputOutput16_RemainsWithInputPointerArray_Vulkan1_1) { const std::string kTest = R"( OpCapability Shader OpCapability Float16 OpCapability StorageInputOutput16 OpExtension "SPV_KHR_16bit_storage" ; CHECK: OpCapability StorageInputOutput16 ; CHECK-NOT: OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" %void = OpTypeVoid %half = OpTypeFloat 16 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %array = OpTypeArray %half %uint_1 %ptr = OpTypePointer Input %array %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_1); const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, StorageInputOutput16_RemainsWithInputPointerStruct_Vulkan1_0) { const std::string kTest = R"( OpCapability Shader OpCapability Float16 OpCapability StorageInputOutput16 OpExtension "SPV_KHR_16bit_storage" ; CHECK: OpCapability StorageInputOutput16 ; CHECK: OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" %void = OpTypeVoid %half = OpTypeFloat 16 %struct = OpTypeStruct %half %ptr = OpTypePointer Input %struct %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_0); const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, StorageInputOutput16_RemainsWithInputPointerStruct_Vulkan1_1) { const std::string kTest = R"( OpCapability Shader OpCapability Float16 OpCapability StorageInputOutput16 OpExtension "SPV_KHR_16bit_storage" ; CHECK: OpCapability StorageInputOutput16 ; CHECK-NOT: OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" %void = OpTypeVoid %half = OpTypeFloat 16 %struct = OpTypeStruct %half %ptr = OpTypePointer Input %struct %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_1); const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, StorageInputOutput16_RemainsWithInputPointerStructOfStruct_Vulkan1_0) { const std::string kTest = R"( OpCapability Shader OpCapability Float16 OpCapability StorageInputOutput16 OpExtension "SPV_KHR_16bit_storage" ; CHECK: OpCapability StorageInputOutput16 ; CHECK: OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" %void = OpTypeVoid %half = OpTypeFloat 16 %float = OpTypeFloat 32 %struct = OpTypeStruct %float %half %parent = OpTypeStruct %float %struct %ptr = OpTypePointer Input %parent %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_0); const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, StorageInputOutput16_RemainsWithInputPointerStructOfStruct_Vulkan1_1) { const std::string kTest = R"( OpCapability Shader OpCapability Float16 OpCapability StorageInputOutput16 OpExtension "SPV_KHR_16bit_storage" ; CHECK: OpCapability StorageInputOutput16 ; CHECK-NOT: OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" %void = OpTypeVoid %half = OpTypeFloat 16 %float = OpTypeFloat 32 %struct = OpTypeStruct %float %half %parent = OpTypeStruct %float %struct %ptr = OpTypePointer Input %parent %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_1); const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, StorageInputOutput16_RemainsWithInputPointerArrayOfStruct_Vulkan1_0) { const std::string kTest = R"( OpCapability Shader OpCapability Float16 OpCapability StorageInputOutput16 OpExtension "SPV_KHR_16bit_storage" ; CHECK: OpCapability StorageInputOutput16 ; CHECK: OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" %void = OpTypeVoid %half = OpTypeFloat 16 %struct = OpTypeStruct %half %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %array = OpTypeArray %struct %uint_1 %ptr = OpTypePointer Input %array %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_0); const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, StorageInputOutput16_RemainsWithInputPointerArrayOfStruct_Vulkan1_1) { const std::string kTest = R"( OpCapability Shader OpCapability Float16 OpCapability StorageInputOutput16 OpExtension "SPV_KHR_16bit_storage" ; CHECK: OpCapability StorageInputOutput16 ; CHECK-NOT: OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" %void = OpTypeVoid %half = OpTypeFloat 16 %struct = OpTypeStruct %half %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %array = OpTypeArray %struct %uint_1 %ptr = OpTypePointer Input %array %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_1); const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, StorageInputOutput16_RemainsWithInputPointerVector_Vulkan1_0) { const std::string kTest = R"( OpCapability Shader OpCapability Float16 OpCapability StorageInputOutput16 OpExtension "SPV_KHR_16bit_storage" ; CHECK: OpCapability StorageInputOutput16 ; CHECK: OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" %void = OpTypeVoid %half = OpTypeFloat 16 %vector = OpTypeVector %half 4 %ptr = OpTypePointer Input %vector %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_0); const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, StorageInputOutput16_RemainsWithInputPointerVector_Vulkan1_1) { const std::string kTest = R"( OpCapability Shader OpCapability Float16 OpCapability StorageInputOutput16 OpExtension "SPV_KHR_16bit_storage" ; CHECK: OpCapability StorageInputOutput16 ; CHECK-NOT: OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" %void = OpTypeVoid %half = OpTypeFloat 16 %vector = OpTypeVector %half 4 %ptr = OpTypePointer Input %vector %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_1); const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, StorageInputOutput16_RemainsWithInputPointerMatrix_Vulkan1_0) { const std::string kTest = R"( OpCapability Shader OpCapability Float16 OpCapability StorageInputOutput16 OpExtension "SPV_KHR_16bit_storage" ; CHECK: OpCapability StorageInputOutput16 ; CHECK: OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" %void = OpTypeVoid %half = OpTypeFloat 16 %vector = OpTypeVector %half 4 %matrix = OpTypeMatrix %vector 4 %ptr = OpTypePointer Input %matrix %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_0); const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, StorageInputOutput16_RemainsWithInputPointerMatrix_Vulkan1_1) { const std::string kTest = R"( OpCapability Shader OpCapability Float16 OpCapability StorageInputOutput16 OpExtension "SPV_KHR_16bit_storage" ; CHECK: OpCapability StorageInputOutput16 ; CHECK-NOT: OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" %void = OpTypeVoid %half = OpTypeFloat 16 %vector = OpTypeVector %half 4 %matrix = OpTypeMatrix %vector 4 %ptr = OpTypePointer Input %matrix %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_1); const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, StorageInputOutput16_IsRemovedWithoutInputPointer) { const std::string kTest = R"( OpCapability Shader OpCapability Float16 OpCapability StorageInputOutput16 OpExtension "SPV_KHR_16bit_storage" ; CHECK-NOT: OpCapability StorageInputOutput16 ; CHECK-NOT: OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" %void = OpTypeVoid %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_0); const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, StorageInputOutput16_RemainsWithOutputPointer_Vulkan1_0) { const std::string kTest = R"( OpCapability Shader OpCapability Float16 OpCapability StorageInputOutput16 OpExtension "SPV_KHR_16bit_storage" ; CHECK: OpCapability StorageInputOutput16 ; CHECK: OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" %void = OpTypeVoid %half = OpTypeFloat 16 %ptr = OpTypePointer Output %half %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_0); const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, StorageInputOutput16_RemainsWithOutputPointer_Vulkan1_1) { const std::string kTest = R"( OpCapability Shader OpCapability Float16 OpCapability StorageInputOutput16 OpExtension "SPV_KHR_16bit_storage" ; CHECK: OpCapability StorageInputOutput16 ; CHECK-NOT: OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" %void = OpTypeVoid %half = OpTypeFloat 16 %ptr = OpTypePointer Output %half %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_1); const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, StorageInputOutput16_RemovedWithoutOutputPointer) { const std::string kTest = R"( OpCapability Shader OpCapability Float16 OpCapability StorageInputOutput16 OpExtension "SPV_KHR_16bit_storage" ; CHECK-NOT: OpCapability StorageInputOutput16 ; CHECK-NOT: OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" %void = OpTypeVoid %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel OpReturn OpFunctionEnd )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, StoragePushConstant16_RemainsSimplePointer_Vulkan1_0) { const std::string kTest = R"( OpCapability Shader OpCapability Float16 OpCapability StoragePushConstant16 OpExtension "SPV_KHR_16bit_storage" ; CHECK: OpCapability StoragePushConstant16 ; CHECK: OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" %void = OpTypeVoid %half = OpTypeFloat 16 %ptr = OpTypePointer PushConstant %half %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_0); const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, StoragePushConstant16_RemainsSimplePointer_Vulkan1_1) { const std::string kTest = R"( OpCapability Shader OpCapability Float16 OpCapability StoragePushConstant16 OpExtension "SPV_KHR_16bit_storage" ; CHECK: OpCapability StoragePushConstant16 ; CHECK-NOT: OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" %void = OpTypeVoid %half = OpTypeFloat 16 %ptr = OpTypePointer PushConstant %half %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_1); const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, StoragePushConstant16_RemovedSimplePointer) { const std::string kTest = R"( OpCapability Shader OpCapability Float16 OpCapability StoragePushConstant16 OpExtension "SPV_KHR_16bit_storage" ; CHECK-NOT: OpCapability StoragePushConstant16 ; CHECK-NOT: OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" %void = OpTypeVoid %half = OpTypeFloat 16 %ptr = OpTypePointer Function %half %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel OpReturn OpFunctionEnd )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, StorageUniformBufferBlock16_RemainsSimplePointer_Vulkan1_0) { // See https://github.com/KhronosGroup/SPIRV-Tools/issues/5354 static_assert(spv::Capability::StorageUniformBufferBlock16 == spv::Capability::StorageBuffer16BitAccess); const std::string kTest = R"( OpCapability Shader OpCapability Float16 OpCapability StorageBuffer16BitAccess OpExtension "SPV_KHR_16bit_storage" ; CHECK: OpCapability StorageBuffer16BitAccess ; `-> StorageUniformBufferBlock16 ; CHECK: OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" OpDecorate %struct BufferBlock %void = OpTypeVoid %half = OpTypeFloat 16 %struct = OpTypeStruct %half %ptr = OpTypePointer Uniform %struct %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_0); const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, StorageUniformBufferBlock16_RemainsSimplePointer_Vulkan1_1) { // See https://github.com/KhronosGroup/SPIRV-Tools/issues/5354 static_assert(spv::Capability::StorageUniformBufferBlock16 == spv::Capability::StorageBuffer16BitAccess); const std::string kTest = R"( OpCapability Shader OpCapability Float16 OpCapability StorageBuffer16BitAccess OpExtension "SPV_KHR_16bit_storage" ; CHECK: OpCapability StorageBuffer16BitAccess ; `-> StorageUniformBufferBlock16 ; CHECK-NOT: OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" OpDecorate %struct BufferBlock %void = OpTypeVoid %half = OpTypeFloat 16 %struct = OpTypeStruct %half %ptr = OpTypePointer Uniform %struct %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_1); const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, StorageUniformBufferBlock16_RemovedSimplePointer) { // See https://github.com/KhronosGroup/SPIRV-Tools/issues/5354 static_assert(spv::Capability::StorageUniformBufferBlock16 == spv::Capability::StorageBuffer16BitAccess); const std::string kTest = R"( OpCapability Shader OpCapability Float16 OpCapability StorageBuffer16BitAccess OpExtension "SPV_KHR_16bit_storage" ; CHECK-NOT: OpCapability StorageBuffer16BitAccess ; `-> StorageUniformBufferBlock16 ; CHECK-NOT: OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" %void = OpTypeVoid %half = OpTypeFloat 16 %struct = OpTypeStruct %half %ptr = OpTypePointer Function %struct %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel OpReturn OpFunctionEnd )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, StorageUniform16_RemovedWithBufferBlockPointer_Vulkan1_0) { // See https://github.com/KhronosGroup/SPIRV-Tools/issues/5354 static_assert(spv::Capability::StorageUniformBufferBlock16 == spv::Capability::StorageBuffer16BitAccess); static_assert(spv::Capability::StorageUniform16 == spv::Capability::UniformAndStorageBuffer16BitAccess); const std::string kTest = R"( OpCapability Shader OpCapability Float16 OpCapability StorageBuffer16BitAccess OpCapability UniformAndStorageBuffer16BitAccess OpExtension "SPV_KHR_16bit_storage" ; CHECK: OpCapability StorageBuffer16BitAccess ; `-> StorageUniformBufferBlock16 ; CHECK-NOT: OpCapability UniformAndStorageBuffer16BitAccess ; `-> StorageUniform16 ; CHECK: OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" OpDecorate %struct BufferBlock %void = OpTypeVoid %half = OpTypeFloat 16 %struct = OpTypeStruct %half %ptr = OpTypePointer Uniform %struct %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_0); const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, StorageUniform16_RemovedWithBufferBlockPointer_Vulkan1_1) { // See https://github.com/KhronosGroup/SPIRV-Tools/issues/5354 static_assert(spv::Capability::StorageUniformBufferBlock16 == spv::Capability::StorageBuffer16BitAccess); static_assert(spv::Capability::StorageUniform16 == spv::Capability::UniformAndStorageBuffer16BitAccess); const std::string kTest = R"( OpCapability Shader OpCapability Float16 OpCapability StorageBuffer16BitAccess OpCapability UniformAndStorageBuffer16BitAccess OpExtension "SPV_KHR_16bit_storage" ; CHECK: OpCapability StorageBuffer16BitAccess ; `-> StorageUniformBufferBlock16 ; CHECK-NOT: OpCapability UniformAndStorageBuffer16BitAccess ; `-> StorageUniform16 ; CHECK-NOT: OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" OpDecorate %struct BufferBlock %void = OpTypeVoid %half = OpTypeFloat 16 %struct = OpTypeStruct %half %ptr = OpTypePointer Uniform %struct %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_1); const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, StorageUniform16_RemovedWithNonBlockUniformPointer_Vulkan1_0) { // See https://github.com/KhronosGroup/SPIRV-Tools/issues/5354 static_assert(spv::Capability::StorageUniformBufferBlock16 == spv::Capability::StorageBuffer16BitAccess); static_assert(spv::Capability::StorageUniform16 == spv::Capability::UniformAndStorageBuffer16BitAccess); const std::string kTest = R"( OpCapability Shader OpCapability Float16 OpCapability StorageBuffer16BitAccess OpCapability UniformAndStorageBuffer16BitAccess OpExtension "SPV_KHR_16bit_storage" ; CHECK-NOT: OpCapability StorageBuffer16BitAccess ; `-> StorageUniformBufferBlock16 ; CHECK: OpCapability UniformAndStorageBuffer16BitAccess ; `-> StorageUniform16 ; CHECK: OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" %void = OpTypeVoid %half = OpTypeFloat 16 %struct = OpTypeStruct %half %ptr = OpTypePointer Uniform %struct %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_0); const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, StorageUniform16_RemovedWithNonBlockUniformPointer_Vulkan1_1) { // See https://github.com/KhronosGroup/SPIRV-Tools/issues/5354 static_assert(spv::Capability::StorageUniformBufferBlock16 == spv::Capability::StorageBuffer16BitAccess); static_assert(spv::Capability::StorageUniform16 == spv::Capability::UniformAndStorageBuffer16BitAccess); const std::string kTest = R"( OpCapability Shader OpCapability Float16 OpCapability StorageBuffer16BitAccess OpCapability UniformAndStorageBuffer16BitAccess OpExtension "SPV_KHR_16bit_storage" ; CHECK-NOT: OpCapability StorageBuffer16BitAccess ; `-> StorageUniformBufferBlock16 ; CHECK: OpCapability UniformAndStorageBuffer16BitAccess ; `-> StorageUniform16 ; CHECK-NOT: OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" %void = OpTypeVoid %half = OpTypeFloat 16 %struct = OpTypeStruct %half %ptr = OpTypePointer Uniform %struct %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_VULKAN_1_1); const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, FragmentShaderInterlock_RemovedIfNotUsed) { const std::string kTest = R"( OpCapability Shader OpCapability FragmentShaderPixelInterlockEXT OpCapability FragmentShaderSampleInterlockEXT OpCapability FragmentShaderShadingRateInterlockEXT OpExtension "SPV_EXT_fragment_shader_interlock" ; CHECK-NOT: OpCapability FragmentShaderPixelInterlockEXT ; CHECK-NOT: OpCapability FragmentShaderSampleInterlockEXT ; CHECK-NOT: OpCapability FragmentShaderShadingRateInterlockEXT ; CHECK-NOT: OpExtension "SPV_EXT_fragment_shader_interlock" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, FragmentShaderPixelInterlock_RemainsWhenOrderedIsUsed) { const std::string kTest = R"( OpCapability Shader OpCapability FragmentShaderPixelInterlockEXT OpCapability FragmentShaderSampleInterlockEXT OpCapability FragmentShaderShadingRateInterlockEXT OpExtension "SPV_EXT_fragment_shader_interlock" ; CHECK: OpCapability FragmentShaderPixelInterlockEXT ; CHECK-NOT: OpCapability FragmentShaderSampleInterlockEXT ; CHECK-NOT: OpCapability FragmentShaderShadingRateInterlockEXT ; CHECK: OpExtension "SPV_EXT_fragment_shader_interlock" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %main PixelInterlockOrderedEXT %void = OpTypeVoid %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel OpBeginInvocationInterlockEXT OpEndInvocationInterlockEXT OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, FragmentShaderPixelInterlock_RemainsWhenUnorderedIsUsed) { const std::string kTest = R"( OpCapability Shader OpCapability FragmentShaderPixelInterlockEXT OpCapability FragmentShaderSampleInterlockEXT OpCapability FragmentShaderShadingRateInterlockEXT OpExtension "SPV_EXT_fragment_shader_interlock" ; CHECK: OpCapability FragmentShaderPixelInterlockEXT ; CHECK-NOT: OpCapability FragmentShaderSampleInterlockEXT ; CHECK-NOT: OpCapability FragmentShaderShadingRateInterlockEXT ; CHECK: OpExtension "SPV_EXT_fragment_shader_interlock" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %main PixelInterlockUnorderedEXT %void = OpTypeVoid %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel OpBeginInvocationInterlockEXT OpEndInvocationInterlockEXT OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, FragmentShaderSampleInterlock_RemainsWhenOrderedIsUsed) { const std::string kTest = R"( OpCapability Shader OpCapability FragmentShaderPixelInterlockEXT OpCapability FragmentShaderSampleInterlockEXT OpCapability FragmentShaderShadingRateInterlockEXT OpExtension "SPV_EXT_fragment_shader_interlock" ; CHECK-NOT: OpCapability FragmentShaderPixelInterlockEXT ; CHECK: OpCapability FragmentShaderSampleInterlockEXT ; CHECK-NOT: OpCapability FragmentShaderShadingRateInterlockEXT ; CHECK: OpExtension "SPV_EXT_fragment_shader_interlock" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %main SampleInterlockOrderedEXT %void = OpTypeVoid %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel OpBeginInvocationInterlockEXT OpEndInvocationInterlockEXT OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, FragmentShaderSampleInterlock_RemainsWhenUnorderedIsUsed) { const std::string kTest = R"( OpCapability Shader OpCapability FragmentShaderPixelInterlockEXT OpCapability FragmentShaderSampleInterlockEXT OpCapability FragmentShaderShadingRateInterlockEXT OpExtension "SPV_EXT_fragment_shader_interlock" ; CHECK-NOT: OpCapability FragmentShaderPixelInterlockEXT ; CHECK: OpCapability FragmentShaderSampleInterlockEXT ; CHECK-NOT: OpCapability FragmentShaderShadingRateInterlockEXT ; CHECK: OpExtension "SPV_EXT_fragment_shader_interlock" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %main SampleInterlockUnorderedEXT %void = OpTypeVoid %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel OpBeginInvocationInterlockEXT OpEndInvocationInterlockEXT OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, FragmentShaderShadingRateInterlock_RemainsWhenOrderedIsUsed) { const std::string kTest = R"( OpCapability Shader OpCapability FragmentShaderPixelInterlockEXT OpCapability FragmentShaderSampleInterlockEXT OpCapability FragmentShaderShadingRateInterlockEXT OpExtension "SPV_EXT_fragment_shader_interlock" ; CHECK-NOT: OpCapability FragmentShaderPixelInterlockEXT ; CHECK-NOT: OpCapability FragmentShaderSampleInterlockEXT ; CHECK: OpCapability FragmentShaderShadingRateInterlockEXT ; CHECK: OpExtension "SPV_EXT_fragment_shader_interlock" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %main ShadingRateInterlockOrderedEXT %void = OpTypeVoid %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel OpBeginInvocationInterlockEXT OpEndInvocationInterlockEXT OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, FragmentShaderShadingRateInterlock_RemainsWhenUnorderedIsUsed) { const std::string kTest = R"( OpCapability Shader OpCapability FragmentShaderPixelInterlockEXT OpCapability FragmentShaderSampleInterlockEXT OpCapability FragmentShaderShadingRateInterlockEXT OpExtension "SPV_EXT_fragment_shader_interlock" ; CHECK-NOT: OpCapability FragmentShaderPixelInterlockEXT ; CHECK-NOT: OpCapability FragmentShaderSampleInterlockEXT ; CHECK: OpCapability FragmentShaderShadingRateInterlockEXT ; CHECK: OpExtension "SPV_EXT_fragment_shader_interlock" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %main ShadingRateInterlockUnorderedEXT %void = OpTypeVoid %1 = OpTypeFunction %void %2 = OpFunction %void None %1 %3 = OpLabel OpBeginInvocationInterlockEXT OpEndInvocationInterlockEXT OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, Int64_RemovedWhenUnused) { const std::string kTest = R"( OpCapability Int64 ; CHECK-NOT: OpCapability Int64 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %3 = OpTypeFunction %void %1 = OpFunction %void None %3 %6 = OpLabel OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, Int64_RemainsWhenUsed) { const std::string kTest = R"( OpCapability Int64 ; CHECK: OpCapability Int64 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %int = OpTypeInt 64 0 %3 = OpTypeFunction %void %1 = OpFunction %void None %3 %6 = OpLabel OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, RayQueryKHR_RemovedWhenUnused) { const std::string kTest = R"( OpCapability Shader OpCapability RayQueryKHR OpExtension "SPV_KHR_ray_query" ; CHECK-NOT: OpCapability RayQueryKHR ; CHECK-NOT: OpExtension "SPV_KHR_ray_query" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %out_var_TEXCOORD1 OpSource HLSL 660 OpName %out_var_TEXCOORD1 "out.var.TEXCOORD1" OpName %main "main" OpDecorate %out_var_TEXCOORD1 Flat OpDecorate %out_var_TEXCOORD1 Location 0 %uint = OpTypeInt 32 0 %uint_1234 = OpConstant %uint 1234 %_ptr_Output_uint = OpTypePointer Output %uint %void = OpTypeVoid %7 = OpTypeFunction %void %out_var_TEXCOORD1 = OpVariable %_ptr_Output_uint Output %main = OpFunction %void None %7 %8 = OpLabel OpStore %out_var_TEXCOORD1 %uint_1234 OpReturn OpFunctionEnd )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, RayQueryKHR_RemainsWhenAccelerationStructureIsPresent) { const std::string kTest = R"( OpCapability Shader OpCapability RayQueryKHR OpExtension "SPV_KHR_ray_query" ; CHECK: OpCapability RayQueryKHR ; CHECK: OpExtension "SPV_KHR_ray_query" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 2 4 OpDecorate %var_bvh DescriptorSet 0 OpDecorate %var_bvh Binding 0 %bvh = OpTypeAccelerationStructureKHR %ptr_bvh = OpTypePointer UniformConstant %bvh %void = OpTypeVoid %20 = OpTypeFunction %void %var_bvh = OpVariable %ptr_bvh UniformConstant %main = OpFunction %void None %20 %30 = OpLabel OpReturn OpFunctionEnd )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, RayQueryKHR_RemainsWhenRayQueryTypeIsPresent) { const std::string kTest = R"( OpCapability Shader OpCapability RayQueryKHR OpExtension "SPV_KHR_ray_query" ; CHECK: OpCapability RayQueryKHR ; CHECK: OpExtension "SPV_KHR_ray_query" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 2 4 %query = OpTypeRayQueryKHR %void = OpTypeVoid %20 = OpTypeFunction %void %ptr_query = OpTypePointer Function %query %main = OpFunction %void None %20 %30 = OpLabel %var_query = OpVariable %ptr_query Function OpReturn OpFunctionEnd )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, RayQueryKHR_RemainsWhenUsed) { const std::string kTest = R"( OpCapability Shader OpCapability RayQueryKHR OpExtension "SPV_KHR_ray_query" ; CHECK: OpCapability RayQueryKHR ; CHECK: OpExtension "SPV_KHR_ray_query" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 2 4 OpDecorate %bvh DescriptorSet 0 OpDecorate %bvh Binding 0 OpDecorate %output DescriptorSet 0 OpDecorate %output Binding 1 OpDecorate %_runtimearr_float ArrayStride 4 OpMemberDecorate %type_RWStructuredBuffer_float 0 Offset 0 OpDecorate %type_RWStructuredBuffer_float BufferBlock %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %int = OpTypeInt 32 1 %v3float = OpTypeVector %float 3 %12 = OpConstantComposite %v3float %float_0 %float_0 %float_0 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %accelerationStructureKHR = OpTypeAccelerationStructureKHR %_ptr_UniformConstant_accelerationStructureKHR = OpTypePointer UniformConstant %accelerationStructureKHR %_runtimearr_float = OpTypeRuntimeArray %float %type_RWStructuredBuffer_float = OpTypeStruct %_runtimearr_float %_ptr_Uniform_type_RWStructuredBuffer_float = OpTypePointer Uniform %type_RWStructuredBuffer_float %void = OpTypeVoid %20 = OpTypeFunction %void %rayQueryKHR = OpTypeRayQueryKHR %_ptr_Function_rayQueryKHR = OpTypePointer Function %rayQueryKHR %bool = OpTypeBool %_ptr_Uniform_float = OpTypePointer Uniform %float %bvh = OpVariable %_ptr_UniformConstant_accelerationStructureKHR UniformConstant %output = OpVariable %_ptr_Uniform_type_RWStructuredBuffer_float Uniform %main = OpFunction %void None %20 %24 = OpLabel %25 = OpVariable %_ptr_Function_rayQueryKHR Function %26 = OpLoad %accelerationStructureKHR %bvh OpRayQueryInitializeKHR %25 %26 %uint_0 %uint_0 %12 %float_0 %12 %float_0 %27 = OpRayQueryProceedKHR %bool %25 %28 = OpRayQueryGetIntersectionTypeKHR %uint %25 %uint_1 %29 = OpIEqual %bool %28 %uint_1 OpSelectionMerge %30 None OpBranchConditional %29 %31 %30 %31 = OpLabel %32 = OpAccessChain %_ptr_Uniform_float %output %int_0 %uint_0 OpStore %32 %float_0 OpBranch %30 %30 = OpLabel OpReturn OpFunctionEnd )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, RayTracingKHR_RemainsWithIntersectionExecutionMode) { const std::string kTest = R"( OpCapability RayTracingKHR OpExtension "SPV_KHR_ray_tracing" ; CHECK: OpCapability RayTracingKHR ; CHECK: OpExtension "SPV_KHR_ray_tracing" OpMemoryModel Logical GLSL450 OpEntryPoint IntersectionKHR %main "main" OpSource HLSL 660 OpName %main "main" %void = OpTypeVoid %3 = OpTypeFunction %void %main = OpFunction %void None %3 %4 = OpLabel OpReturn OpFunctionEnd )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, RayTracingKHR_RemainsWithClosestHitExecutionMode) { const std::string kTest = R"( OpCapability RayTracingKHR OpExtension "SPV_KHR_ray_tracing" ; CHECK: OpCapability RayTracingKHR ; CHECK: OpExtension "SPV_KHR_ray_tracing" OpMemoryModel Logical GLSL450 OpEntryPoint ClosestHitKHR %main "main" %a OpSource HLSL 630 OpName %Payload "Payload" OpMemberName %Payload 0 "color" OpName %a "a" OpName %main "main" %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %Payload = OpTypeStruct %v4float %ptr_payload = OpTypePointer IncomingRayPayloadKHR %Payload %void = OpTypeVoid %8 = OpTypeFunction %void %a = OpVariable %ptr_payload IncomingRayPayloadKHR %main = OpFunction %void None %8 %9 = OpLabel %10 = OpLoad %Payload %a OpStore %a %10 OpReturn OpFunctionEnd )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, RayTracingKHR_RemainsWithAnyHitExecutionMode) { const std::string kTest = R"( OpCapability RayTracingKHR OpExtension "SPV_KHR_ray_tracing" ; CHECK: OpCapability RayTracingKHR ; CHECK: OpExtension "SPV_KHR_ray_tracing" OpMemoryModel Logical GLSL450 OpEntryPoint AnyHitKHR %main "main" %a OpSource HLSL 630 OpName %Payload "Payload" OpMemberName %Payload 0 "color" OpName %a "a" OpName %main "main" %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %Payload = OpTypeStruct %v4float %ptr_payload = OpTypePointer IncomingRayPayloadKHR %Payload %void = OpTypeVoid %8 = OpTypeFunction %void %a = OpVariable %ptr_payload IncomingRayPayloadKHR %main = OpFunction %void None %8 %9 = OpLabel %10 = OpLoad %Payload %a OpStore %a %10 OpReturn OpFunctionEnd )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, RayTracingKHR_RemainsWithMissExecutionMode) { const std::string kTest = R"( OpCapability RayTracingKHR OpExtension "SPV_KHR_ray_tracing" ; CHECK: OpCapability RayTracingKHR ; CHECK: OpExtension "SPV_KHR_ray_tracing" OpMemoryModel Logical GLSL450 OpEntryPoint MissKHR %main "main" %a OpSource HLSL 630 OpName %Payload "Payload" OpMemberName %Payload 0 "color" OpName %a "a" OpName %main "main" %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %Payload = OpTypeStruct %v4float %ptr_payload = OpTypePointer IncomingRayPayloadKHR %Payload %void = OpTypeVoid %8 = OpTypeFunction %void %a = OpVariable %ptr_payload IncomingRayPayloadKHR %main = OpFunction %void None %8 %9 = OpLabel %10 = OpLoad %Payload %a OpStore %a %10 OpReturn OpFunctionEnd )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, RayTracingKHR_RemainsWithRayGenerationExecutionMode) { const std::string kTest = R"( OpCapability RayTracingKHR OpExtension "SPV_KHR_ray_tracing" ; CHECK: OpCapability RayTracingKHR ; CHECK: OpExtension "SPV_KHR_ray_tracing" OpMemoryModel Logical GLSL450 OpEntryPoint RayGenerationKHR %main "main" OpSource HLSL 630 OpName %main "main" %void = OpTypeVoid %3 = OpTypeFunction %void %main = OpFunction %void None %3 %4 = OpLabel OpReturn OpFunctionEnd )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, RayTracingKHR_RemainsWithCallableExecutionMode) { const std::string kTest = R"( ; CHECK: OpCapability RayTracingKHR ; CHECK: OpExtension "SPV_KHR_ray_tracing" OpCapability RayTracingKHR OpExtension "SPV_KHR_ray_tracing" OpMemoryModel Logical GLSL450 OpEntryPoint CallableKHR %main "main" %a OpSource HLSL 660 OpName %Payload "Payload" OpMemberName %Payload 0 "data" OpName %a "a" OpName %main "main" %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %Payload = OpTypeStruct %v4float %ptr_payload = OpTypePointer IncomingCallableDataKHR %Payload %void = OpTypeVoid %8 = OpTypeFunction %void %a = OpVariable %ptr_payload IncomingCallableDataKHR %main = OpFunction %void None %8 %9 = OpLabel %10 = OpLoad %Payload %a OpStore %a %10 OpReturn OpFunctionEnd )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, ImageMSArray_RemainsIfSampledIs2AndArrayedIs1) { const std::string kTest = R"( OpCapability ImageMSArray ; CHECK: OpCapability ImageMSArray OpCapability Shader OpCapability StorageImageMultisample OpCapability StorageImageReadWithoutFormat OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpDecorate %var_image DescriptorSet 0 OpDecorate %var_image Binding 1 %void = OpTypeVoid %func = OpTypeFunction %void %f32 = OpTypeFloat 32 %u32 = OpTypeInt 32 0 %uint_2 = OpConstant %u32 2 %uint_1 = OpConstant %u32 1 %v2uint = OpTypeVector %u32 2 %v4float = OpTypeVector %f32 4 %image = OpTypeImage %f32 2D 2 1 1 2 Unknown %ptr_image = OpTypePointer UniformConstant %image %10 = OpConstantComposite %v2uint %uint_1 %uint_2 %var_image = OpVariable %ptr_image UniformConstant %main = OpFunction %void None %func %main_lab = OpLabel %18 = OpLoad %image %var_image %19 = OpImageRead %v4float %18 %10 Sample %uint_2 OpReturn OpFunctionEnd )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, ImageMSArray_RemovedIfNotUsed) { const std::string kTest = R"( OpCapability Shader OpCapability ImageMSArray ; CHECK-NOT: OpCapability ImageMSArray OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpSource HLSL 660 OpName %out_var_SV_Target "out.var.SV_Target" OpName %main "main" OpDecorate %out_var_SV_Target Location 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %7 = OpTypeFunction %void %out_var_SV_Target = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %7 %8 = OpLabel OpReturn OpFunctionEnd )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, ImageMSArray_RemovedIfArrayedIsNot1) { const std::string kTest = R"( OpCapability ImageMSArray ; CHECK-NOT: OpCapability ImageMSArray OpCapability Shader OpCapability StorageImageMultisample OpCapability StorageImageReadWithoutFormat OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpDecorate %var_image DescriptorSet 0 OpDecorate %var_image Binding 1 %void = OpTypeVoid %func = OpTypeFunction %void %f32 = OpTypeFloat 32 %u32 = OpTypeInt 32 0 %uint_2 = OpConstant %u32 2 %uint_1 = OpConstant %u32 1 %v2uint = OpTypeVector %u32 2 %v4float = OpTypeVector %f32 4 %image = OpTypeImage %f32 2D 2 0 1 2 Unknown %ptr_image = OpTypePointer UniformConstant %image %10 = OpConstantComposite %v2uint %uint_1 %uint_2 %var_image = OpVariable %ptr_image UniformConstant %main = OpFunction %void None %func %main_lab = OpLabel %18 = OpLoad %image %var_image %19 = OpImageRead %v4float %18 %10 Sample %uint_2 OpReturn OpFunctionEnd )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, ImageMSArray_RemovedIfSampledNot2) { const std::string kTest = R"( OpCapability ImageMSArray ; CHECK-NOT: OpCapability ImageMSArray OpCapability Shader OpCapability StorageImageReadWithoutFormat OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpDecorate %var_image DescriptorSet 0 OpDecorate %var_image Binding 1 %void = OpTypeVoid %func = OpTypeFunction %void %f32 = OpTypeFloat 32 %u32 = OpTypeInt 32 0 %uint_3 = OpConstant %u32 3 %uint_2 = OpConstant %u32 2 %uint_1 = OpConstant %u32 1 %v3uint = OpTypeVector %u32 3 %v4float = OpTypeVector %f32 4 %image = OpTypeImage %f32 2D 2 1 0 2 Unknown %ptr_image = OpTypePointer UniformConstant %image %10 = OpConstantComposite %v3uint %uint_1 %uint_2 %uint_3 %var_image = OpVariable %ptr_image UniformConstant %main = OpFunction %void None %func %main_lab = OpLabel %18 = OpLoad %image %var_image %19 = OpImageRead %v4float %18 %10 OpReturn OpFunctionEnd )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, Float64_RemovedWhenUnused) { const std::string kTest = R"( OpCapability Float64 ; CHECK-NOT: OpCapability Float64 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %3 = OpTypeFunction %void %1 = OpFunction %void None %3 %6 = OpLabel OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, Float64_RemainsWhenUsed) { const std::string kTest = R"( OpCapability Float64 ; CHECK: OpCapability Float64 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %float = OpTypeFloat 64 %3 = OpTypeFunction %void %1 = OpFunction %void None %3 %6 = OpLabel OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, ComputeDerivativeGroupQuads_ReamainsWithExecMode) { const std::string kTest = R"( OpCapability ComputeDerivativeGroupQuadsKHR OpCapability ComputeDerivativeGroupLinearKHR ; CHECK-NOT: OpCapability ComputeDerivativeGroupLinearKHR ; CHECK: OpCapability ComputeDerivativeGroupQuadsKHR ; CHECK-NOT: OpCapability ComputeDerivativeGroupLinearKHR OpCapability Shader ; CHECK: OpExtension "SPV_NV_compute_shader_derivatives" OpExtension "SPV_NV_compute_shader_derivatives" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 DerivativeGroupQuadsNV %void = OpTypeVoid %3 = OpTypeFunction %void %1 = OpFunction %void None %3 %6 = OpLabel OpReturn OpFunctionEnd )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, ComputeDerivativeGroupLinear_ReamainsWithExecMode) { const std::string kTest = R"( OpCapability ComputeDerivativeGroupLinearKHR OpCapability ComputeDerivativeGroupQuadsKHR ; CHECK-NOT: OpCapability ComputeDerivativeGroupQuadsKHR ; CHECK: OpCapability ComputeDerivativeGroupLinearKHR ; CHECK-NOT: OpCapability ComputeDerivativeGroupQuadsKHR OpCapability Shader ; CHECK: OpExtension "SPV_NV_compute_shader_derivatives" OpExtension "SPV_NV_compute_shader_derivatives" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 DerivativeGroupLinearNV %void = OpTypeVoid %float = OpTypeFloat 64 %3 = OpTypeFunction %void %1 = OpFunction %void None %3 %6 = OpLabel OpReturn OpFunctionEnd )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, StorageImageReadWithoutFormat_RemovedIfUnused) { const std::string kTest = R"( OpCapability StorageImageReadWithoutFormat ; CHECK-NOT: OpCapability StorageImageReadWithoutFormat OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %PSMain "PSMain" %out_var OpExecutionMode %PSMain OriginUpperLeft OpDecorate %out_var Location 0 %float = OpTypeFloat 32 %float4 = OpTypeVector %float 4 %float_0 = OpConstant %float 0 %float4_0000 = OpConstantComposite %float4 %float_0 %float_0 %float_0 %float_0 %ptr_float4 = OpTypePointer Output %float4 %void = OpTypeVoid %9 = OpTypeFunction %void %out_var = OpVariable %ptr_float4 Output %PSMain = OpFunction %void None %9 %10 = OpLabel OpStore %out_var %float4_0000 OpReturn OpFunctionEnd )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, StorageImageReadWithoutFormat_RemovedIfUnusedOpImageFetch) { const std::string kTest = R"( OpCapability StorageImageReadWithoutFormat ; CHECK-NOT: OpCapability StorageImageReadWithoutFormat OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %PSMain "PSMain" %out_var OpExecutionMode %PSMain OriginUpperLeft OpDecorate %out_var Location 0 OpDecorate %texture DescriptorSet 0 OpDecorate %texture Binding 1 %float = OpTypeFloat 32 %float4 = OpTypeVector %float 4 %int = OpTypeInt 32 1 %int2 = OpTypeVector %int 2 %type_image = OpTypeImage %float 2D 2 0 0 1 Unknown %ptr_image = OpTypePointer UniformConstant %type_image %int_0 = OpConstant %int 0 %int2_00 = OpConstantComposite %int2 %int_0 %int_0 %ptr_float4 = OpTypePointer Output %float4 %void = OpTypeVoid %9 = OpTypeFunction %void %texture = OpVariable %ptr_image UniformConstant %out_var = OpVariable %ptr_float4 Output %PSMain = OpFunction %void None %9 %10 = OpLabel %11 = OpLoad %type_image %texture %12 = OpImageFetch %float4 %11 %int2_00 Lod %int_0 OpStore %out_var %12 OpReturn OpFunctionEnd )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, StorageImageReadWithoutFormat_RemainsWhenRequiredWithRead) { const std::string kTest = R"( OpCapability StorageImageReadWithoutFormat ; CHECK: OpCapability StorageImageReadWithoutFormat OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %PSMain "PSMain" %out_var OpExecutionMode %PSMain OriginUpperLeft OpDecorate %out_var Location 0 OpDecorate %texture DescriptorSet 0 OpDecorate %texture Binding 1 %float = OpTypeFloat 32 %float4 = OpTypeVector %float 4 %int = OpTypeInt 32 1 %int2 = OpTypeVector %int 2 %type_image = OpTypeImage %float 2D 2 0 0 1 Unknown %ptr_image = OpTypePointer UniformConstant %type_image %int_0 = OpConstant %int 0 %int2_00 = OpConstantComposite %int2 %int_0 %int_0 %ptr_float4 = OpTypePointer Output %float4 %void = OpTypeVoid %9 = OpTypeFunction %void %texture = OpVariable %ptr_image UniformConstant %out_var = OpVariable %ptr_float4 Output %PSMain = OpFunction %void None %9 %10 = OpLabel %11 = OpLoad %type_image %texture %12 = OpImageRead %float4 %11 %int2_00 Lod %int_0 OpStore %out_var %12 OpReturn OpFunctionEnd )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, StorageImageReadWithoutFormat_RemainsWhenRequiredWithSparseRead) { const std::string kTest = R"( OpCapability StorageImageReadWithoutFormat ; CHECK: OpCapability StorageImageReadWithoutFormat OpCapability SparseResidency OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %PSMain "PSMain" OpExecutionMode %PSMain OriginUpperLeft OpDecorate %texture DescriptorSet 0 OpDecorate %texture Binding 1 %float = OpTypeFloat 32 %float4 = OpTypeVector %float 4 %int = OpTypeInt 32 1 %int2 = OpTypeVector %int 2 %type_image = OpTypeImage %float 2D 2 0 0 2 Unknown %struct = OpTypeStruct %int %float4 %ptr_image = OpTypePointer UniformConstant %type_image %int_0 = OpConstant %int 0 %int2_00 = OpConstantComposite %int2 %int_0 %int_0 %void = OpTypeVoid %9 = OpTypeFunction %void %texture = OpVariable %ptr_image UniformConstant %PSMain = OpFunction %void None %9 %10 = OpLabel %11 = OpLoad %type_image %texture %12 = OpImageSparseRead %struct %11 %int2_00 OpReturn OpFunctionEnd )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, StorageImageReadWithoutFormat_RemovedWithReadOnSubpassData) { const std::string kTest = R"( OpCapability StorageImageReadWithoutFormat ; CHECK-NOT: OpCapability StorageImageReadWithoutFormat OpCapability InputAttachment OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %PSMain "PSMain" %out_var OpExecutionMode %PSMain OriginUpperLeft OpDecorate %out_var Location 0 OpDecorate %texture DescriptorSet 0 OpDecorate %texture Binding 1 %float = OpTypeFloat 32 %float4 = OpTypeVector %float 4 %int = OpTypeInt 32 1 %int2 = OpTypeVector %int 2 %type_image = OpTypeImage %float SubpassData 2 0 0 2 Unknown %ptr_image = OpTypePointer UniformConstant %type_image %int_0 = OpConstant %int 0 %int2_00 = OpConstantComposite %int2 %int_0 %int_0 %ptr_float4 = OpTypePointer Output %float4 %void = OpTypeVoid %9 = OpTypeFunction %void %texture = OpVariable %ptr_image UniformConstant %out_var = OpVariable %ptr_float4 Output %PSMain = OpFunction %void None %9 %10 = OpLabel %11 = OpLoad %type_image %texture %12 = OpImageRead %float4 %11 %int2_00 OpStore %out_var %12 OpReturn OpFunctionEnd )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, StorageImageWriteWithoutFormat_RemainsWhenRequiredWithWrite) { const std::string kTest = R"( OpCapability StorageImageWriteWithoutFormat ; CHECK: OpCapability StorageImageWriteWithoutFormat OpCapability Shader OpCapability StorageImageExtendedFormats OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %id %img OpExecutionMode %main LocalSize 8 8 8 OpSource HLSL 670 OpName %type_image "type.3d.image" OpName %img "img" OpName %main "main" OpDecorate %id BuiltIn GlobalInvocationId OpDecorate %img DescriptorSet 0 OpDecorate %img Binding 0 %float = OpTypeFloat 32 %float_4 = OpConstant %float 4 %float_5 = OpConstant %float 5 %v2float = OpTypeVector %float 2 %9 = OpConstantComposite %v2float %float_4 %float_5 %type_image = OpTypeImage %float 3D 2 0 0 2 Unknown %ptr_img = OpTypePointer UniformConstant %type_image %uint = OpTypeInt 32 0 %v3uint = OpTypeVector %uint 3 %ptr_input = OpTypePointer Input %v3uint %void = OpTypeVoid %15 = OpTypeFunction %void %img = OpVariable %ptr_img UniformConstant %id = OpVariable %ptr_input Input %main = OpFunction %void None %15 %16 = OpLabel %17 = OpLoad %v3uint %id %18 = OpLoad %type_image %img OpImageWrite %18 %17 %9 None OpReturn OpFunctionEnd )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, StorageImageWriteWithoutFormat_RemovedWithWriteOnKnownFormat) { const std::string kTest = R"( OpCapability StorageImageWriteWithoutFormat ; CHECK-NOT: OpCapability StorageImageWriteWithoutFormat OpCapability Shader OpCapability StorageImageExtendedFormats OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %id %img OpExecutionMode %main LocalSize 8 8 8 OpSource HLSL 670 OpName %type_image "type.3d.image" OpName %img "img" OpName %main "main" OpDecorate %id BuiltIn GlobalInvocationId OpDecorate %img DescriptorSet 0 OpDecorate %img Binding 0 %float = OpTypeFloat 32 %float_4 = OpConstant %float 4 %float_5 = OpConstant %float 5 %v2float = OpTypeVector %float 2 %9 = OpConstantComposite %v2float %float_4 %float_5 %type_image = OpTypeImage %float 3D 2 0 0 2 Rg32f %ptr_img = OpTypePointer UniformConstant %type_image %uint = OpTypeInt 32 0 %v3uint = OpTypeVector %uint 3 %ptr_input = OpTypePointer Input %v3uint %void = OpTypeVoid %15 = OpTypeFunction %void %img = OpVariable %ptr_img UniformConstant %id = OpVariable %ptr_input Input %main = OpFunction %void None %15 %16 = OpLabel %17 = OpLoad %v3uint %id %18 = OpLoad %type_image %img OpImageWrite %18 %17 %9 None OpReturn OpFunctionEnd )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, PhysicalStorageBuffer_RemovedWhenUnused) { const std::string kTest = R"( OpCapability PhysicalStorageBufferAddresses ; CHECK-NOT: OpCapability PhysicalStorageBufferAddresses OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %3 = OpTypeFunction %void %1 = OpFunction %void None %3 %6 = OpLabel OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, PhysicalStorageBuffer_RemainsWithOpTypeForwardPointer) { const std::string kTest = R"( OpCapability PhysicalStorageBufferAddresses ; CHECK: OpCapability PhysicalStorageBufferAddresses OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 2 4 %void = OpTypeVoid %int = OpTypeInt 32 0 %struct = OpTypeStruct %int OpTypeForwardPointer %ptr PhysicalStorageBuffer %ptr = OpTypePointer PhysicalStorageBuffer %struct %3 = OpTypeFunction %void %main = OpFunction %void None %3 %6 = OpLabel OpReturn OpFunctionEnd )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, PhysicalStorageBuffer_RemainsWithPhysicalStorageBufferStorage) { const std::string kTest = R"( OpCapability PhysicalStorageBufferAddresses ; CHECK: OpCapability PhysicalStorageBufferAddresses OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 2 4 %void = OpTypeVoid %int = OpTypeInt 32 0 %struct = OpTypeStruct %int %ptr = OpTypePointer PhysicalStorageBuffer %struct %3 = OpTypeFunction %void %main = OpFunction %void None %3 %6 = OpLabel OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, PhysicalStorageBuffer_RemainsWithRestrictDecoration) { const std::string kTest = R"( OpCapability PhysicalStorageBufferAddresses ; CHECK: OpCapability PhysicalStorageBufferAddresses OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 2 4 OpDecorate %var RestrictPointer %void = OpTypeVoid %int = OpTypeInt 32 0 %struct = OpTypeStruct %int %ptr = OpTypePointer Function %struct %3 = OpTypeFunction %void %main = OpFunction %void None %3 %6 = OpLabel %var = OpVariable %ptr Function OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, PhysicalStorageBuffer_RemainsWithAliasedDecoration) { const std::string kTest = R"( OpCapability PhysicalStorageBufferAddresses ; CHECK: OpCapability PhysicalStorageBufferAddresses OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 2 4 OpDecorate %var AliasedPointer %void = OpTypeVoid %int = OpTypeInt 32 0 %struct = OpTypeStruct %int %ptr = OpTypePointer Function %struct %3 = OpTypeFunction %void %main = OpFunction %void None %3 %6 = OpLabel %var = OpVariable %ptr Function OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, Float16_RemovedWhenUnused) { const std::string kTest = R"( OpCapability Float16 ; CHECK-NOT: OpCapability Float16 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %3 = OpTypeFunction %void %1 = OpFunction %void None %3 %6 = OpLabel OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, Float16_RemainsWhenUsed) { const std::string kTest = R"( OpCapability Float16 ; CHECK: OpCapability Float16 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %float = OpTypeFloat 16 %3 = OpTypeFunction %void %1 = OpFunction %void None %3 %6 = OpLabel OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, Int16_RemovedWhenUnused) { const std::string kTest = R"( OpCapability Int16 ; CHECK-NOT: OpCapability Int16 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %3 = OpTypeFunction %void %1 = OpFunction %void None %3 %6 = OpLabel OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, Int16_RemainsWhenUsed) { const std::string kTest = R"( OpCapability Int16 ; CHECK: OpCapability Int16 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %int = OpTypeInt 16 1 %3 = OpTypeFunction %void %1 = OpFunction %void None %3 %6 = OpLabel OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, UInt16_RemainsWhenUsed) { const std::string kTest = R"( OpCapability Int16 ; CHECK: OpCapability Int16 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %uint = OpTypeInt 16 0 %3 = OpTypeFunction %void %1 = OpFunction %void None %3 %6 = OpLabel OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, VulkanMemoryModelDeviceScope_RemovedWhenUnused) { const std::string kTest = R"( OpCapability VulkanMemoryModelDeviceScope ; CHECK-NOT: OpCapability VulkanMemoryModelDeviceScope OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" %void = OpTypeVoid %3 = OpTypeFunction %void %1 = OpFunction %void None %3 %6 = OpLabel OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, VulkanMemoryModelDeviceScope_RemovedWhenUsedWithGLSL450) { const std::string kTest = R"( OpCapability VulkanMemoryModelDeviceScope ; CHECK-NOT: OpCapability VulkanMemoryModelDeviceScope OpCapability Shader OpCapability ShaderClockKHR OpCapability Int64 OpExtension "SPV_KHR_shader_clock" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 2 4 %void = OpTypeVoid %uint = OpTypeInt 32 0 %ulong = OpTypeInt 64 0 %uint_1 = OpConstant %uint 1 %3 = OpTypeFunction %void %main = OpFunction %void None %3 %6 = OpLabel %22 = OpReadClockKHR %ulong %uint_1 ; Device Scope OpReturn OpFunctionEnd )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, VulkanMemoryModelDeviceScope_RemainsWhenUsedWithVulkan) { const std::string kTest = R"( OpCapability VulkanMemoryModelDeviceScope ; CHECK: OpCapability VulkanMemoryModelDeviceScope OpCapability Shader OpCapability ShaderClockKHR OpCapability Int64 OpExtension "SPV_KHR_shader_clock" OpMemoryModel Logical Vulkan OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 2 4 %void = OpTypeVoid %uint = OpTypeInt 32 0 %ulong = OpTypeInt 64 0 %uint_1 = OpConstant %uint 1 %3 = OpTypeFunction %void %main = OpFunction %void None %3 %6 = OpLabel %22 = OpReadClockKHR %ulong %uint_1 ; Device Scope OpReturn OpFunctionEnd )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } TEST_F(TrimCapabilitiesPassTest, GroupNonUniform_RemovedWhenUnused) { const std::string kTest = R"( OpCapability Shader OpCapability GroupNonUniformVote ; CHECK-NOT: OpCapability GroupNonUniformVote OpCapability GroupNonUniformArithmetic ; CHECK-NOT: OpCapability GroupNonUniformArithmetic OpCapability GroupNonUniformClustered ; CHECK-NOT: OpCapability GroupNonUniformClustered OpCapability GroupNonUniformPartitionedNV ; CHECK-NOT: OpCapability GroupNonUniformPartitionedNV OpCapability GroupNonUniform ; CHECK-NOT: OpCapability GroupNonUniform OpExtension "SPV_NV_shader_subgroup_partitioned" ; CHECK-NOT: OpExtension "SPV_NV_shader_subgroup_partitioned" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 2 4 %void = OpTypeVoid %3 = OpTypeFunction %void %main = OpFunction %void None %3 %6 = OpLabel OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch( kTest, /* do_validation= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, GroupNonUniform_RemainsGroupNonUniformWhenInUse) { const std::string kTest = R"( OpCapability GroupNonUniformVote ; CHECK-NOT: OpCapability GroupNonUniformVote OpCapability GroupNonUniformArithmetic ; CHECK-NOT: OpCapability GroupNonUniformArithmetic OpCapability GroupNonUniformClustered ; CHECK-NOT: OpCapability GroupNonUniformClustered OpCapability GroupNonUniformPartitionedNV ; CHECK-NOT: OpCapability GroupNonUniformPartitionedNV OpCapability GroupNonUniform ; CHECK: OpCapability GroupNonUniform OpCapability Shader OpExtension "SPV_NV_shader_subgroup_partitioned" ; CHECK-NOT: OpExtension "SPV_NV_shader_subgroup_partitioned" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 2 4 %void = OpTypeVoid %bool = OpTypeBool %uint = OpTypeInt 32 0 %scope_subgroup = OpConstant %uint 3 %3 = OpTypeFunction %void %main = OpFunction %void None %3 %6 = OpLabel %7 = OpGroupNonUniformElect %bool %scope_subgroup OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch( kTest, /* do_validation= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, GroupNonUniformVote_Remains_OpGroupNonUniformAll) { const std::string kTest = R"( OpCapability Shader OpCapability GroupNonUniformVote ; CHECK: OpCapability GroupNonUniformVote OpCapability GroupNonUniformArithmetic ; CHECK-NOT: OpCapability GroupNonUniformArithmetic OpCapability GroupNonUniformClustered ; CHECK-NOT: OpCapability GroupNonUniformClustered OpCapability GroupNonUniformPartitionedNV ; CHECK-NOT: OpCapability GroupNonUniformPartitionedNV OpCapability GroupNonUniform ; CHECK-NOT: OpCapability GroupNonUniform OpExtension "SPV_NV_shader_subgroup_partitioned" ; CHECK-NOT: OpExtension "SPV_NV_shader_subgroup_partitioned" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 2 4 %void = OpTypeVoid %bool = OpTypeBool %uint = OpTypeInt 32 0 %scope_subgroup = OpConstant %uint 3 %true = OpConstantTrue %bool %3 = OpTypeFunction %void %main = OpFunction %void None %3 %6 = OpLabel %7 = OpGroupNonUniformAll %bool %scope_subgroup %true OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch( kTest, /* do_validation= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, GroupNonUniformVote_Remains_OpGroupNonUniformAny) { const std::string kTest = R"( OpCapability Shader OpCapability GroupNonUniformVote ; CHECK: OpCapability GroupNonUniformVote OpCapability GroupNonUniformArithmetic ; CHECK-NOT: OpCapability GroupNonUniformArithmetic OpCapability GroupNonUniformClustered ; CHECK-NOT: OpCapability GroupNonUniformClustered OpCapability GroupNonUniformPartitionedNV ; CHECK-NOT: OpCapability GroupNonUniformPartitionedNV OpCapability GroupNonUniform ; CHECK-NOT: OpCapability GroupNonUniform OpExtension "SPV_NV_shader_subgroup_partitioned" ; CHECK-NOT: OpExtension "SPV_NV_shader_subgroup_partitioned" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 2 4 %void = OpTypeVoid %bool = OpTypeBool %uint = OpTypeInt 32 0 %scope_subgroup = OpConstant %uint 3 %true = OpConstantTrue %bool %3 = OpTypeFunction %void %main = OpFunction %void None %3 %6 = OpLabel %7 = OpGroupNonUniformAny %bool %scope_subgroup %true OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch( kTest, /* do_validation= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, GroupNonUniformArithmetic_Remains_OpGroupNonUniformIAdd_Reduce) { const std::string kTest = R"( OpCapability Shader OpCapability GroupNonUniformVote ; CHECK-NOT: OpCapability GroupNonUniformVote OpCapability GroupNonUniformArithmetic ; CHECK: OpCapability GroupNonUniformArithmetic OpCapability GroupNonUniformClustered ; CHECK-NOT: OpCapability GroupNonUniformClustered OpCapability GroupNonUniformPartitionedNV ; CHECK-NOT: OpCapability GroupNonUniformPartitionedNV OpCapability GroupNonUniform ; CHECK-NOT: OpCapability GroupNonUniform OpExtension "SPV_NV_shader_subgroup_partitioned" ; CHECK-NOT: OpExtension "SPV_NV_shader_subgroup_partitioned" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 2 4 %void = OpTypeVoid %bool = OpTypeBool %uint = OpTypeInt 32 0 %scope_subgroup = OpConstant %uint 3 %uint_1 = OpConstant %uint 1 %true = OpConstantTrue %bool %3 = OpTypeFunction %void %main = OpFunction %void None %3 %6 = OpLabel %7 = OpGroupNonUniformIAdd %uint %scope_subgroup Reduce %uint_1 OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch( kTest, /* do_validation= */ true); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, GroupNonUniformArithmetic_Remains_OpGroupNonUniformIAdd_InclusiveScan) { const std::string kTest = R"( OpCapability Shader OpCapability GroupNonUniformVote ; CHECK-NOT: OpCapability GroupNonUniformVote OpCapability GroupNonUniformArithmetic ; CHECK: OpCapability GroupNonUniformArithmetic OpCapability GroupNonUniformClustered ; CHECK-NOT: OpCapability GroupNonUniformClustered OpCapability GroupNonUniformPartitionedNV ; CHECK-NOT: OpCapability GroupNonUniformPartitionedNV OpCapability GroupNonUniform ; CHECK-NOT: OpCapability GroupNonUniform OpExtension "SPV_NV_shader_subgroup_partitioned" ; CHECK-NOT: OpExtension "SPV_NV_shader_subgroup_partitioned" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 2 4 %void = OpTypeVoid %bool = OpTypeBool %uint = OpTypeInt 32 0 %scope_subgroup = OpConstant %uint 3 %uint_1 = OpConstant %uint 1 %true = OpConstantTrue %bool %3 = OpTypeFunction %void %main = OpFunction %void None %3 %6 = OpLabel %7 = OpGroupNonUniformIAdd %uint %scope_subgroup InclusiveScan %uint_1 OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch( kTest, /* do_validation= */ true); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, GroupNonUniformArithmetic_Remains_OpGroupNonUniformIAdd_ExclusiveScan) { const std::string kTest = R"( OpCapability Shader OpCapability GroupNonUniformVote ; CHECK-NOT: OpCapability GroupNonUniformVote OpCapability GroupNonUniformArithmetic ; CHECK: OpCapability GroupNonUniformArithmetic OpCapability GroupNonUniformClustered ; CHECK-NOT: OpCapability GroupNonUniformClustered OpCapability GroupNonUniformPartitionedNV ; CHECK-NOT: OpCapability GroupNonUniformPartitionedNV OpCapability GroupNonUniform ; CHECK-NOT: OpCapability GroupNonUniform OpExtension "SPV_NV_shader_subgroup_partitioned" ; CHECK-NOT: OpExtension "SPV_NV_shader_subgroup_partitioned" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 2 4 %void = OpTypeVoid %bool = OpTypeBool %uint = OpTypeInt 32 0 %scope_subgroup = OpConstant %uint 3 %uint_1 = OpConstant %uint 1 %true = OpConstantTrue %bool %3 = OpTypeFunction %void %main = OpFunction %void None %3 %6 = OpLabel %7 = OpGroupNonUniformIAdd %uint %scope_subgroup ExclusiveScan %uint_1 OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch( kTest, /* do_validation= */ true); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, GroupNonUniformClustered_Remains_OpGroupNonUniformIAdd_ClusteredReduce) { const std::string kTest = R"( OpCapability Shader OpCapability GroupNonUniformVote ; CHECK-NOT: OpCapability GroupNonUniformVote OpCapability GroupNonUniformArithmetic ; CHECK-NOT: OpCapability GroupNonUniformArithmetic OpCapability GroupNonUniformClustered ; CHECK: OpCapability GroupNonUniformClustered OpCapability GroupNonUniformPartitionedNV ; CHECK-NOT: OpCapability GroupNonUniformPartitionedNV OpCapability GroupNonUniform ; CHECK-NOT: OpCapability GroupNonUniform OpExtension "SPV_NV_shader_subgroup_partitioned" ; CHECK-NOT: OpExtension "SPV_NV_shader_subgroup_partitioned" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 2 4 %void = OpTypeVoid %bool = OpTypeBool %uint = OpTypeInt 32 0 %scope_subgroup = OpConstant %uint 3 %uint_1 = OpConstant %uint 1 %true = OpConstantTrue %bool %3 = OpTypeFunction %void %main = OpFunction %void None %3 %6 = OpLabel %7 = OpGroupNonUniformIAdd %uint %scope_subgroup ClusteredReduce %uint_1 %uint_1 OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch( kTest, /* do_validation= */ true); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } struct SubgroupTestCase { // The result type of the subgroup instruction. std::string resultType; // The opcode of the subgroup instruction. std::string opcode; // The actual operand of the subgroup instruction. std::string operand; }; static const std::vector kSubgroupTestCases{ // clang-format off { "uint", "OpGroupNonUniformIAdd", "uint_1" }, { "float", "OpGroupNonUniformFAdd", "float_1" }, { "uint", "OpGroupNonUniformIMul", "uint_1" }, { "float", "OpGroupNonUniformFMul", "float_1" }, { "int", "OpGroupNonUniformSMin", "int_1" }, { "uint", "OpGroupNonUniformUMin", "uint_1" }, { "float", "OpGroupNonUniformFMin", "float_1" }, { "int", "OpGroupNonUniformSMax", "int_1" }, { "uint", "OpGroupNonUniformUMax", "uint_1" }, { "float", "OpGroupNonUniformFMax", "float_1" }, { "uint", "OpGroupNonUniformBitwiseAnd", "uint_1" }, { "uint", "OpGroupNonUniformBitwiseOr", "uint_1" }, { "uint", "OpGroupNonUniformBitwiseXor", "uint_1" }, { "bool", "OpGroupNonUniformLogicalAnd", "true" }, { "bool", "OpGroupNonUniformLogicalOr", "true" }, { "bool", "OpGroupNonUniformLogicalXor", "true" } // clang-format on }; using TrimCapabilitiesPassTestSubgroupNV_Unsigned = PassTest< ::testing::TestWithParam>>; TEST_P(TrimCapabilitiesPassTestSubgroupNV_Unsigned, GroupNonUniformPartitionedNV_Remains) { SubgroupTestCase test_case = std::get<0>(GetParam()); const std::string operation = std::get<1>(GetParam()); const std::string kTest = R"( OpCapability Shader OpCapability GroupNonUniformVote ; CHECK-NOT: OpCapability GroupNonUniformVote OpCapability GroupNonUniformArithmetic ; CHECK-NOT: OpCapability GroupNonUniformArithmetic OpCapability GroupNonUniformClustered ; CHECK-NOT: OpCapability GroupNonUniformClustered OpCapability GroupNonUniformPartitionedNV ; CHECK: OpCapability GroupNonUniformPartitionedNV OpCapability GroupNonUniform ; CHECK-NOT: OpCapability GroupNonUniform OpExtension "SPV_NV_shader_subgroup_partitioned" ; CHECK: OpExtension "SPV_NV_shader_subgroup_partitioned" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 2 4 %void = OpTypeVoid %bool = OpTypeBool %uint = OpTypeInt 32 0 %int = OpTypeInt 32 1 %float = OpTypeFloat 32 %v4uint = OpTypeVector %uint 4 %scope_subgroup = OpConstant %uint 3 %uint_1 = OpConstant %uint 1 %int_1 = OpConstant %int 1 %float_1 = OpConstant %float 1 %uint4_1111 = OpConstantComposite %v4uint %uint_1 %uint_1 %uint_1 %uint_1 %true = OpConstantTrue %bool %3 = OpTypeFunction %void %main = OpFunction %void None %3 %6 = OpLabel %7 = )" + test_case.opcode + " %" + test_case.resultType + " %scope_subgroup " + operation + " %" + test_case.operand + R"( %uint4_1111 OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch( kTest, /* do_validation= */ true); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } INSTANTIATE_TEST_SUITE_P( TrimCapabilitiesPassTestSubgroupNV_Unsigned_I, TrimCapabilitiesPassTestSubgroupNV_Unsigned, ::testing::Combine(::testing::ValuesIn(kSubgroupTestCases), ::testing::Values("PartitionedReduceNV", "PartitionedInclusiveScanNV", "PartitionedExclusiveScanNV")), [](const ::testing::TestParamInfo< TrimCapabilitiesPassTestSubgroupNV_Unsigned::ParamType>& info) { return std::get<0>(info.param).opcode + "_" + std::get<1>(info.param); }); using TrimCapabilitiesPassTestSubgroupArithmetic_Unsigned = PassTest< ::testing::TestWithParam>>; TEST_P(TrimCapabilitiesPassTestSubgroupArithmetic_Unsigned, GroupNonUniformPartitionedArithmetic_Remains) { SubgroupTestCase test_case = std::get<0>(GetParam()); const std::string operation = std::get<1>(GetParam()); const std::string kTest = R"( OpCapability Shader OpCapability GroupNonUniformVote ; CHECK-NOT: OpCapability GroupNonUniformVote OpCapability GroupNonUniformArithmetic ; CHECK: OpCapability GroupNonUniformArithmetic OpCapability GroupNonUniformClustered ; CHECK-NOT: OpCapability GroupNonUniformClustered OpCapability GroupNonUniformPartitionedNV ; CHECK-NOT: OpCapability GroupNonUniformPartitionedNV OpCapability GroupNonUniform ; CHECK-NOT: OpCapability GroupNonUniform OpExtension "SPV_NV_shader_subgroup_partitioned" ; CHECK-NOT: OpExtension "SPV_NV_shader_subgroup_partitioned" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 2 4 %void = OpTypeVoid %bool = OpTypeBool %uint = OpTypeInt 32 0 %int = OpTypeInt 32 1 %float = OpTypeFloat 32 %v4uint = OpTypeVector %uint 4 %scope_subgroup = OpConstant %uint 3 %uint_1 = OpConstant %uint 1 %int_1 = OpConstant %int 1 %float_1 = OpConstant %float 1 %uint4_1111 = OpConstantComposite %v4uint %uint_1 %uint_1 %uint_1 %uint_1 %true = OpConstantTrue %bool %3 = OpTypeFunction %void %main = OpFunction %void None %3 %6 = OpLabel %7 = )" + test_case.opcode + " %" + test_case.resultType + " %scope_subgroup " + operation + " %" + test_case.operand + R"( %uint_1 OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch( kTest, /* do_validation= */ true); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } INSTANTIATE_TEST_SUITE_P( TrimCapabilitiesPassTestSubgroupArithmetic_Unsigned_I, TrimCapabilitiesPassTestSubgroupArithmetic_Unsigned, ::testing::Combine(::testing::ValuesIn(kSubgroupTestCases), ::testing::Values("Reduce", "InclusiveScan", "ExclusiveScan")), [](const ::testing::TestParamInfo< TrimCapabilitiesPassTestSubgroupArithmetic_Unsigned::ParamType>& info) { return std::get<0>(info.param).opcode + "_" + std::get<1>(info.param); }); using TrimCapabilitiesPassTestSubgroupClustered_Unsigned = PassTest< ::testing::TestWithParam>>; TEST_P(TrimCapabilitiesPassTestSubgroupClustered_Unsigned, GroupNonUniformPartitionedClustered_Remains) { SubgroupTestCase test_case = std::get<0>(GetParam()); const std::string operation = std::get<1>(GetParam()); const std::string kTest = R"( OpCapability Shader OpCapability GroupNonUniformVote ; CHECK-NOT: OpCapability GroupNonUniformVote OpCapability GroupNonUniformArithmetic ; CHECK-NOT: OpCapability GroupNonUniformArithmetic OpCapability GroupNonUniformClustered ; CHECK: OpCapability GroupNonUniformClustered OpCapability GroupNonUniformPartitionedNV ; CHECK-NOT: OpCapability GroupNonUniformPartitionedNV OpCapability GroupNonUniform ; CHECK-NOT: OpCapability GroupNonUniform OpExtension "SPV_NV_shader_subgroup_partitioned" ; CHECK-NOT: OpExtension "SPV_NV_shader_subgroup_partitioned" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 2 4 %void = OpTypeVoid %bool = OpTypeBool %uint = OpTypeInt 32 0 %int = OpTypeInt 32 1 %float = OpTypeFloat 32 %v4uint = OpTypeVector %uint 4 %scope_subgroup = OpConstant %uint 3 %uint_1 = OpConstant %uint 1 %int_1 = OpConstant %int 1 %float_1 = OpConstant %float 1 %uint4_1111 = OpConstantComposite %v4uint %uint_1 %uint_1 %uint_1 %uint_1 %true = OpConstantTrue %bool %3 = OpTypeFunction %void %main = OpFunction %void None %3 %6 = OpLabel %7 = )" + test_case.opcode + " %" + test_case.resultType + " %scope_subgroup " + operation + " %" + test_case.operand + R"( %uint_1 OpReturn OpFunctionEnd; )"; const auto result = SinglePassRunAndMatch( kTest, /* do_validation= */ true); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, InterpolationFunction_RemovedIfNotUsed) { const std::string kTest = R"( OpCapability Shader OpCapability InterpolationFunction ; CHECK-NOT: OpCapability InterpolationFunction OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %out_var_SV_Target OpExecutionMode %main OriginUpperLeft OpSource HLSL 660 OpName %out_var_SV_Target "out.var.SV_Target" OpName %main "main" OpDecorate %out_var_SV_Target Location 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %void = OpTypeVoid %7 = OpTypeFunction %void %out_var_SV_Target = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %7 %8 = OpLabel OpReturn OpFunctionEnd )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithChange); } TEST_F(TrimCapabilitiesPassTest, InterpolationFunction_RemainsWithInterpolateAtCentroid) { const std::string kTest = R"( OpCapability Shader OpCapability InterpolationFunction ; CHECK: OpCapability InterpolationFunction %std450 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %out_var_SV_Target %gl_PointCoord OpExecutionMode %main OriginUpperLeft OpSource HLSL 660 OpName %out_var_SV_Target "out.var.SV_Target" OpName %main "main" OpDecorate %out_var_SV_Target Location 0 OpDecorate %gl_PointCoord BuiltIn PointCoord %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %_ptr_Input_v2float = OpTypePointer Input %v2float %void = OpTypeVoid %7 = OpTypeFunction %void %out_var_SV_Target = OpVariable %_ptr_Output_v4float Output %gl_PointCoord = OpVariable %_ptr_Input_v2float Input %main = OpFunction %void None %7 %8 = OpLabel %9 = OpExtInst %v4float %std450 InterpolateAtCentroid %gl_PointCoord OpReturn OpFunctionEnd )"; const auto result = SinglePassRunAndMatch(kTest, /* skip_nop= */ false); EXPECT_EQ(std::get<1>(result), Pass::Status::SuccessWithoutChange); } INSTANTIATE_TEST_SUITE_P( TrimCapabilitiesPassTestSubgroupClustered_Unsigned_I, TrimCapabilitiesPassTestSubgroupClustered_Unsigned, ::testing::Combine(::testing::ValuesIn(kSubgroupTestCases), ::testing::Values("ClusteredReduce")), [](const ::testing::TestParamInfo< TrimCapabilitiesPassTestSubgroupClustered_Unsigned::ParamType>& info) { return std::get<0>(info.param).opcode + "_" + std::get<1>(info.param); }); } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/type_manager_test.cpp000066400000000000000000001212351475742701700245340ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // Modifications Copyright (C) 2024 Advanced Micro Devices, Inc. All rights // reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/type_manager.h" #include #include #include #include "effcee/effcee.h" #include "gmock/gmock.h" #include "gtest/gtest.h" #include "source/opt/build_module.h" #include "source/opt/instruction.h" #include "spirv-tools/libspirv.hpp" namespace spvtools { namespace opt { namespace analysis { namespace { bool Validate(const std::vector& bin) { spv_target_env target_env = SPV_ENV_UNIVERSAL_1_2; spv_context spvContext = spvContextCreate(target_env); spv_diagnostic diagnostic = nullptr; spv_const_binary_t binary = {bin.data(), bin.size()}; spv_result_t error = spvValidate(spvContext, &binary, &diagnostic); if (error != 0) spvDiagnosticPrint(diagnostic); spvDiagnosticDestroy(diagnostic); spvContextDestroy(spvContext); return error == 0; } void Match(const std::string& original, IRContext* context, bool do_validation = true) { std::vector bin; context->module()->ToBinary(&bin, true); if (do_validation) { EXPECT_TRUE(Validate(bin)); } std::string assembly; SpirvTools tools(SPV_ENV_UNIVERSAL_1_2); EXPECT_TRUE( tools.Disassemble(bin, &assembly, SpirvTools::kDefaultDisassembleOption)) << "Disassembling failed for shader:\n" << assembly << std::endl; auto match_result = effcee::Match(assembly, original); EXPECT_EQ(effcee::Result::Status::Ok, match_result.status()) << match_result.message() << "\nChecking result:\n" << assembly; } std::vector> GenerateAllTypes() { // Types in this test case are only equal to themselves, nothing else. std::vector> types; // Void, Bool types.emplace_back(new Void()); auto* voidt = types.back().get(); types.emplace_back(new Bool()); auto* boolt = types.back().get(); // Integer types.emplace_back(new Integer(32, true)); auto* s32 = types.back().get(); types.emplace_back(new Integer(32, false)); types.emplace_back(new Integer(64, true)); types.emplace_back(new Integer(64, false)); auto* u64 = types.back().get(); // Float types.emplace_back(new Float(32)); auto* f32 = types.back().get(); types.emplace_back(new Float(64)); // Vector types.emplace_back(new Vector(s32, 2)); types.emplace_back(new Vector(s32, 3)); auto* v3s32 = types.back().get(); types.emplace_back(new Vector(u64, 4)); types.emplace_back(new Vector(f32, 3)); auto* v3f32 = types.back().get(); // Matrix types.emplace_back(new Matrix(v3s32, 3)); types.emplace_back(new Matrix(v3s32, 4)); types.emplace_back(new Matrix(v3f32, 4)); // Images types.emplace_back(new Image(s32, spv::Dim::Dim2D, 0, 0, 0, 0, spv::ImageFormat::Rg8, spv::AccessQualifier::ReadOnly)); auto* image1 = types.back().get(); types.emplace_back(new Image(s32, spv::Dim::Dim2D, 0, 1, 0, 0, spv::ImageFormat::Rg8, spv::AccessQualifier::ReadOnly)); types.emplace_back(new Image(s32, spv::Dim::Dim3D, 0, 1, 0, 0, spv::ImageFormat::Rg8, spv::AccessQualifier::ReadOnly)); types.emplace_back(new Image(voidt, spv::Dim::Dim3D, 0, 1, 0, 1, spv::ImageFormat::Rg8, spv::AccessQualifier::ReadWrite)); auto* image2 = types.back().get(); // Sampler types.emplace_back(new Sampler()); // Sampled Image types.emplace_back(new SampledImage(image1)); types.emplace_back(new SampledImage(image2)); // Array types.emplace_back(new Array(f32, Array::LengthInfo{100, {0, 100u}})); types.emplace_back(new Array(f32, Array::LengthInfo{42, {0, 42u}})); auto* a42f32 = types.back().get(); types.emplace_back(new Array(u64, Array::LengthInfo{24, {0, 24u}})); // RuntimeArray types.emplace_back(new RuntimeArray(v3f32)); types.emplace_back(new RuntimeArray(v3s32)); auto* rav3s32 = types.back().get(); // Struct types.emplace_back(new Struct(std::vector{s32})); types.emplace_back(new Struct(std::vector{s32, f32})); auto* sts32f32 = types.back().get(); types.emplace_back( new Struct(std::vector{u64, a42f32, rav3s32})); // Opaque types.emplace_back(new Opaque("")); types.emplace_back(new Opaque("hello")); types.emplace_back(new Opaque("world")); // Pointer types.emplace_back(new Pointer(f32, spv::StorageClass::Input)); types.emplace_back(new Pointer(sts32f32, spv::StorageClass::Function)); types.emplace_back(new Pointer(a42f32, spv::StorageClass::Function)); // Function types.emplace_back(new Function(voidt, {})); types.emplace_back(new Function(voidt, {boolt})); types.emplace_back(new Function(voidt, {boolt, s32})); types.emplace_back(new Function(s32, {boolt, s32})); // Event, Device Event, Reserve Id, Queue, types.emplace_back(new Event()); types.emplace_back(new DeviceEvent()); types.emplace_back(new ReserveId()); types.emplace_back(new Queue()); // Pipe, Forward Pointer, PipeStorage, NamedBarrier, AccelerationStructureNV, // CooperativeMatrixNV types.emplace_back(new Pipe(spv::AccessQualifier::ReadWrite)); types.emplace_back(new Pipe(spv::AccessQualifier::ReadOnly)); types.emplace_back(new ForwardPointer(1, spv::StorageClass::Input)); types.emplace_back(new ForwardPointer(2, spv::StorageClass::Input)); types.emplace_back(new ForwardPointer(2, spv::StorageClass::Uniform)); types.emplace_back(new PipeStorage()); types.emplace_back(new NamedBarrier()); types.emplace_back(new AccelerationStructureNV()); types.emplace_back(new CooperativeMatrixNV(f32, 24, 24, 24)); types.emplace_back(new CooperativeMatrixKHR(f32, 8, 8, 8, 1002)); types.emplace_back(new RayQueryKHR()); types.emplace_back(new HitObjectNV()); types.emplace_back(new CooperativeVectorNV(f32, 16)); // SPV_AMDX_shader_enqueue types.emplace_back(new NodePayloadArrayAMDX(sts32f32)); types.emplace_back(new TensorLayoutNV(1002, 1000)); types.emplace_back(new TensorViewNV(1002, 1003, {1000, 1001})); return types; } TEST(TypeManager, GenerateAllTypesGeneratesAllTypes) { std::set generated_types; for (auto& type : GenerateAllTypes()) { generated_types.insert(type->kind()); } std::vector all_types; for (uint32_t kind = 0; kind != Type::Kind::kLast; ++kind) { all_types.push_back(static_cast(kind)); } EXPECT_THAT(generated_types, testing::UnorderedElementsAreArray(all_types)); } TEST(TypeManager, TypeStrings) { const std::string text = R"( OpDecorate %spec_const_with_id SpecId 99 OpTypeForwardPointer %p Uniform %void = OpTypeVoid %bool = OpTypeBool %u32 = OpTypeInt 32 0 %id4 = OpConstant %u32 4 %s32 = OpTypeInt 32 1 %f64 = OpTypeFloat 64 %v3u32 = OpTypeVector %u32 3 %m3x3 = OpTypeMatrix %v3u32 3 %img1 = OpTypeImage %s32 Cube 0 1 1 0 R32f ReadWrite %img2 = OpTypeImage %s32 Cube 0 1 1 0 R32f %sampler = OpTypeSampler %si1 = OpTypeSampledImage %img1 %si2 = OpTypeSampledImage %img2 %a5u32 = OpTypeArray %u32 %id4 %af64 = OpTypeRuntimeArray %f64 %st1 = OpTypeStruct %u32 %st2 = OpTypeStruct %f64 %s32 %v3u32 %opaque1 = OpTypeOpaque "" %opaque2 = OpTypeOpaque "opaque" %p = OpTypePointer Uniform %st1 %f = OpTypeFunction %void %u32 %u32 %event = OpTypeEvent %de = OpTypeDeviceEvent %ri = OpTypeReserveId %queue = OpTypeQueue %pipe = OpTypePipe ReadOnly %ps = OpTypePipeStorage %nb = OpTypeNamedBarrier %rtacc = OpTypeAccelerationStructureNV ; Set up other kinds of OpTypeArray %s64 = OpTypeInt 64 1 ; ID 32 %spec_const_without_id = OpSpecConstant %s32 44 %spec_const_with_id = OpSpecConstant %s32 42 ;; This is ID 1 %long_constant = OpConstant %s64 5000000000 %spec_const_op = OpSpecConstantOp %s32 IAdd %id4 %id4 ; ID 35 %arr_spec_const_without_id = OpTypeArray %s32 %spec_const_without_id %arr_spec_const_with_id = OpTypeArray %s32 %spec_const_with_id %arr_long_constant = OpTypeArray %s32 %long_constant %arr_spec_const_op = OpTypeArray %s32 %spec_const_op %cm = OpTypeCooperativeMatrixNV %f64 %id4 %id4 %id4 %id2 = OpConstant %u32 2 %cmkhr = OpTypeCooperativeMatrixKHR %f64 %id4 %id4 %id4 %id2 )"; std::vector> type_id_strs = { {3, "void"}, {4, "bool"}, {5, "uint32"}, // Id 6 is used by the constant. {7, "sint32"}, {8, "float64"}, {9, ""}, {10, "<, 3>"}, {11, "image(sint32, 3, 0, 1, 1, 0, 3, 2)"}, {12, "image(sint32, 3, 0, 1, 1, 0, 3, 0)"}, {13, "sampler"}, {14, "sampled_image(image(sint32, 3, 0, 1, 1, 0, 3, 2))"}, {15, "sampled_image(image(sint32, 3, 0, 1, 1, 0, 3, 0))"}, {16, "[uint32, id(6), words(0,4)]"}, {17, "[float64]"}, {18, "{uint32}"}, {19, "{float64, sint32, }"}, {20, "opaque('')"}, {21, "opaque('opaque')"}, {2, "{uint32} 2*"}, // Include storage class number {22, "(uint32, uint32) -> void"}, {23, "event"}, {24, "device_event"}, {25, "reserve_id"}, {26, "queue"}, {27, "pipe(0)"}, {28, "pipe_storage"}, {29, "named_barrier"}, {30, "accelerationStructureNV"}, {31, "sint64"}, {35, "[sint32, id(32), words(0,44)]"}, {36, "[sint32, id(1), words(1,99,42)]"}, {37, "[sint32, id(33), words(0,705032704,1)]"}, {38, "[sint32, id(34), words(2,34)]"}, {39, ""}, {41, ""}, }; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text); ASSERT_NE(nullptr, context.get()); // It assembled TypeManager manager(nullptr, context.get()); EXPECT_EQ(type_id_strs.size(), manager.NumTypes()); for (const auto& p : type_id_strs) { ASSERT_NE(nullptr, manager.GetType(p.first)); EXPECT_EQ(p.second, manager.GetType(p.first)->str()) << " id is " << p.first; EXPECT_EQ(p.first, manager.GetId(manager.GetType(p.first))); } } TEST(TypeManager, StructWithFwdPtr) { const std::string text = R"( OpCapability Addresses OpCapability Kernel %1 = OpExtInstImport "OpenCL.std" OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %7 "test" OpSource OpenCL_C 102000 OpDecorate %11 FuncParamAttr NoCapture %11 = OpDecorationGroup OpGroupDecorate %11 %8 %9 OpTypeForwardPointer %100 CrossWorkgroup %void = OpTypeVoid %150 = OpTypeStruct %100 %100 = OpTypePointer CrossWorkgroup %150 %6 = OpTypeFunction %void %100 %100 %7 = OpFunction %void Pure %6 %8 = OpFunctionParameter %100 %9 = OpFunctionParameter %100 %10 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); TypeManager manager(nullptr, context.get()); Type* p100 = manager.GetType(100); Type* s150 = manager.GetType(150); EXPECT_TRUE(p100->AsPointer()); EXPECT_EQ(p100->AsPointer()->pointee_type(), s150); EXPECT_TRUE(s150->AsStruct()); EXPECT_EQ(s150->AsStruct()->element_types()[0], p100); } TEST(TypeManager, CircularFwdPtr) { const std::string text = R"( OpCapability Addresses OpCapability Kernel %1 = OpExtInstImport "OpenCL.std" OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %7 "test" OpSource OpenCL_C 102000 OpDecorate %11 FuncParamAttr NoCapture %11 = OpDecorationGroup OpGroupDecorate %11 %8 %9 OpTypeForwardPointer %100 CrossWorkgroup OpTypeForwardPointer %200 CrossWorkgroup %void = OpTypeVoid %int = OpTypeInt 32 0 %float = OpTypeFloat 32 %150 = OpTypeStruct %200 %int %250 = OpTypeStruct %100 %float %100 = OpTypePointer CrossWorkgroup %150 %200 = OpTypePointer CrossWorkgroup %250 %6 = OpTypeFunction %void %100 %200 %7 = OpFunction %void Pure %6 %8 = OpFunctionParameter %100 %9 = OpFunctionParameter %200 %10 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); TypeManager manager(nullptr, context.get()); Type* p100 = manager.GetType(100); Type* s150 = manager.GetType(150); Type* p200 = manager.GetType(200); Type* s250 = manager.GetType(250); EXPECT_TRUE(p100->AsPointer()); EXPECT_EQ(p100->AsPointer()->pointee_type(), s150); EXPECT_TRUE(p200->AsPointer()); EXPECT_EQ(p200->AsPointer()->pointee_type(), s250); EXPECT_TRUE(s150->AsStruct()); EXPECT_EQ(s150->AsStruct()->element_types()[0], p200); EXPECT_TRUE(s250->AsStruct()); EXPECT_EQ(s250->AsStruct()->element_types()[0], p100); } TEST(TypeManager, IsomorphicStructWithFwdPtr) { const std::string text = R"( OpCapability Addresses OpCapability Kernel %1 = OpExtInstImport "OpenCL.std" OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %7 "test" OpSource OpenCL_C 102000 OpDecorate %11 FuncParamAttr NoCapture %11 = OpDecorationGroup OpGroupDecorate %11 %8 %9 OpTypeForwardPointer %100 CrossWorkgroup OpTypeForwardPointer %200 CrossWorkgroup %void = OpTypeVoid %_struct_1 = OpTypeStruct %100 %_struct_2 = OpTypeStruct %200 %100 = OpTypePointer CrossWorkgroup %_struct_1 %200 = OpTypePointer CrossWorkgroup %_struct_2 %6 = OpTypeFunction %void %100 %200 %7 = OpFunction %void Pure %6 %8 = OpFunctionParameter %100 %9 = OpFunctionParameter %200 %10 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); TypeManager manager(nullptr, context.get()); EXPECT_EQ(manager.GetType(100), manager.GetType(200)); } TEST(TypeManager, IsomorphicCircularFwdPtr) { const std::string text = R"( OpCapability Addresses OpCapability Kernel %1 = OpExtInstImport "OpenCL.std" OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %7 "test" OpSource OpenCL_C 102000 OpDecorate %11 FuncParamAttr NoCapture %11 = OpDecorationGroup OpGroupDecorate %11 %8 %9 OpTypeForwardPointer %100 CrossWorkgroup OpTypeForwardPointer %200 CrossWorkgroup OpTypeForwardPointer %300 CrossWorkgroup OpTypeForwardPointer %400 CrossWorkgroup %void = OpTypeVoid %int = OpTypeInt 32 0 %float = OpTypeFloat 32 %150 = OpTypeStruct %200 %int %250 = OpTypeStruct %100 %float %350 = OpTypeStruct %400 %int %450 = OpTypeStruct %300 %float %100 = OpTypePointer CrossWorkgroup %150 %200 = OpTypePointer CrossWorkgroup %250 %300 = OpTypePointer CrossWorkgroup %350 %400 = OpTypePointer CrossWorkgroup %450 %6 = OpTypeFunction %void %100 %200 %7 = OpFunction %void Pure %6 %8 = OpFunctionParameter %100 %9 = OpFunctionParameter %200 %10 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); TypeManager manager(nullptr, context.get()); Type* p100 = manager.GetType(100); Type* p300 = manager.GetType(300); EXPECT_EQ(p100, p300); Type* p200 = manager.GetType(200); Type* p400 = manager.GetType(400); EXPECT_EQ(p200, p400); Type* p150 = manager.GetType(150); Type* p350 = manager.GetType(350); EXPECT_EQ(p150, p350); Type* p250 = manager.GetType(250); Type* p450 = manager.GetType(450); EXPECT_EQ(p250, p450); } TEST(TypeManager, PartialIsomorphicFwdPtr) { const std::string text = R"( OpCapability Addresses OpCapability Kernel %1 = OpExtInstImport "OpenCL.std" OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %7 "test" OpSource OpenCL_C 102000 OpDecorate %11 FuncParamAttr NoCapture %11 = OpDecorationGroup OpGroupDecorate %11 %8 %9 OpTypeForwardPointer %100 CrossWorkgroup OpTypeForwardPointer %200 CrossWorkgroup %void = OpTypeVoid %int = OpTypeInt 32 0 %float = OpTypeFloat 32 %150 = OpTypeStruct %200 %int %250 = OpTypeStruct %200 %int %100 = OpTypePointer CrossWorkgroup %150 %200 = OpTypePointer CrossWorkgroup %250 %6 = OpTypeFunction %void %100 %200 %7 = OpFunction %void Pure %6 %8 = OpFunctionParameter %100 %9 = OpFunctionParameter %200 %10 = OpLabel OpReturn OpFunctionEnd )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); TypeManager manager(nullptr, context.get()); Type* p100 = manager.GetType(100); Type* p200 = manager.GetType(200); EXPECT_EQ(p100->AsPointer()->pointee_type(), p200->AsPointer()->pointee_type()); } TEST(TypeManager, DecorationOnStruct) { const std::string text = R"( OpDecorate %struct1 Block OpDecorate %struct2 Block OpDecorate %struct3 Block OpDecorate %struct4 Block %u32 = OpTypeInt 32 0 ; id: 5 %f32 = OpTypeFloat 32 ; id: 6 %struct1 = OpTypeStruct %u32 %f32 ; base %struct2 = OpTypeStruct %f32 %u32 ; different member order %struct3 = OpTypeStruct %f32 ; different member list %struct4 = OpTypeStruct %u32 %f32 ; the same %struct7 = OpTypeStruct %f32 ; no decoration )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text); TypeManager manager(nullptr, context.get()); ASSERT_EQ(7u, manager.NumTypes()); // Make sure we get ids correct. ASSERT_EQ("uint32", manager.GetType(5)->str()); ASSERT_EQ("float32", manager.GetType(6)->str()); // Try all combinations of pairs. Expect to be the same type only when the // same id or (1, 4). for (const auto id1 : {1, 2, 3, 4, 7}) { for (const auto id2 : {1, 2, 3, 4, 7}) { if (id1 == id2 || (id1 == 1 && id2 == 4) || (id1 == 4 && id2 == 1)) { EXPECT_TRUE(manager.GetType(id1)->IsSame(manager.GetType(id2))) << "%struct" << id1 << " is expected to be the same as %struct" << id2; } else { EXPECT_FALSE(manager.GetType(id1)->IsSame(manager.GetType(id2))) << "%struct" << id1 << " is expected to be different with %struct" << id2; } } } } TEST(TypeManager, DecorationOnMember) { const std::string text = R"( OpMemberDecorate %struct1 0 Offset 0 OpMemberDecorate %struct2 0 Offset 0 OpMemberDecorate %struct3 0 Offset 0 OpMemberDecorate %struct4 0 Offset 0 OpMemberDecorate %struct5 1 Offset 0 OpMemberDecorate %struct6 0 Offset 4 OpDecorate %struct7 Block OpMemberDecorate %struct7 0 Offset 0 %u32 = OpTypeInt 32 0 ; id: 8 %f32 = OpTypeFloat 32 ; id: 9 %struct1 = OpTypeStruct %u32 %f32 ; base %struct2 = OpTypeStruct %f32 %u32 ; different member order %struct3 = OpTypeStruct %f32 ; different member list %struct4 = OpTypeStruct %u32 %f32 ; the same %struct5 = OpTypeStruct %u32 %f32 ; member decorate different field %struct6 = OpTypeStruct %u32 %f32 ; different member decoration parameter %struct7 = OpTypeStruct %u32 %f32 ; extra decoration on the struct %struct10 = OpTypeStruct %u32 %f32 ; no member decoration )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text); TypeManager manager(nullptr, context.get()); ASSERT_EQ(10u, manager.NumTypes()); // Make sure we get ids correct. ASSERT_EQ("uint32", manager.GetType(8)->str()); ASSERT_EQ("float32", manager.GetType(9)->str()); // Try all combinations of pairs. Expect to be the same type only when the // same id or (1, 4). for (const auto id1 : {1, 2, 3, 4, 5, 6, 7, 10}) { for (const auto id2 : {1, 2, 3, 4, 5, 6, 7, 10}) { if (id1 == id2 || (id1 == 1 && id2 == 4) || (id1 == 4 && id2 == 1)) { EXPECT_TRUE(manager.GetType(id1)->IsSame(manager.GetType(id2))) << "%struct" << id1 << " is expected to be the same as %struct" << id2; } else { EXPECT_FALSE(manager.GetType(id1)->IsSame(manager.GetType(id2))) << "%struct" << id1 << " is expected to be different with %struct" << id2; } } } } TEST(TypeManager, DecorationEmpty) { const std::string text = R"( OpDecorate %struct1 Block OpMemberDecorate %struct2 0 Offset 0 %u32 = OpTypeInt 32 0 ; id: 3 %f32 = OpTypeFloat 32 ; id: 4 %struct1 = OpTypeStruct %u32 %f32 %struct2 = OpTypeStruct %f32 %u32 %struct5 = OpTypeStruct %f32 )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text); TypeManager manager(nullptr, context.get()); ASSERT_EQ(5u, manager.NumTypes()); // Make sure we get ids correct. ASSERT_EQ("uint32", manager.GetType(3)->str()); ASSERT_EQ("float32", manager.GetType(4)->str()); // %struct1 with decoration on itself EXPECT_FALSE(manager.GetType(1)->decoration_empty()); // %struct2 with decoration on its member EXPECT_FALSE(manager.GetType(2)->decoration_empty()); EXPECT_TRUE(manager.GetType(3)->decoration_empty()); EXPECT_TRUE(manager.GetType(4)->decoration_empty()); // %struct5 has no decorations EXPECT_TRUE(manager.GetType(5)->decoration_empty()); } TEST(TypeManager, BeginEndForEmptyModule) { const std::string text = ""; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text); TypeManager manager(nullptr, context.get()); ASSERT_EQ(0u, manager.NumTypes()); EXPECT_EQ(manager.begin(), manager.end()); } TEST(TypeManager, BeginEnd) { const std::string text = R"( %void1 = OpTypeVoid %void2 = OpTypeVoid %bool = OpTypeBool %u32 = OpTypeInt 32 0 %f64 = OpTypeFloat 64 )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text); TypeManager manager(nullptr, context.get()); ASSERT_EQ(5u, manager.NumTypes()); EXPECT_NE(manager.begin(), manager.end()); for (const auto& t : manager) { switch (t.first) { case 1: case 2: EXPECT_EQ("void", t.second->str()); break; case 3: EXPECT_EQ("bool", t.second->str()); break; case 4: EXPECT_EQ("uint32", t.second->str()); break; case 5: EXPECT_EQ("float64", t.second->str()); break; default: EXPECT_TRUE(false && "unreachable"); break; } } } TEST(TypeManager, LookupType) { const std::string text = R"( %void = OpTypeVoid %uint = OpTypeInt 32 0 %int = OpTypeInt 32 1 %vec2 = OpTypeVector %int 2 )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); EXPECT_NE(context, nullptr); TypeManager manager(nullptr, context.get()); Void voidTy; EXPECT_EQ(manager.GetId(&voidTy), 1u); Integer uintTy(32, false); EXPECT_EQ(manager.GetId(&uintTy), 2u); Integer intTy(32, true); EXPECT_EQ(manager.GetId(&intTy), 3u); Integer intTy2(32, true); Vector vecTy(&intTy2, 2u); EXPECT_EQ(manager.GetId(&vecTy), 4u); } TEST(TypeManager, RemoveId) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeInt 32 0 %2 = OpTypeInt 32 1 )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); EXPECT_NE(context, nullptr); context->get_type_mgr()->RemoveId(1u); ASSERT_EQ(context->get_type_mgr()->GetType(1u), nullptr); ASSERT_NE(context->get_type_mgr()->GetType(2u), nullptr); context->get_type_mgr()->RemoveId(2u); ASSERT_EQ(context->get_type_mgr()->GetType(1u), nullptr); ASSERT_EQ(context->get_type_mgr()->GetType(2u), nullptr); } TEST(TypeManager, RemoveIdNonDuplicateAmbiguousType) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeInt 32 0 %2 = OpTypeStruct %1 )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); EXPECT_NE(context, nullptr); Integer u32(32, false); Struct st({&u32}); ASSERT_EQ(context->get_type_mgr()->GetId(&st), 2u); context->get_type_mgr()->RemoveId(2u); ASSERT_EQ(context->get_type_mgr()->GetType(2u), nullptr); ASSERT_EQ(context->get_type_mgr()->GetId(&st), 0u); } TEST(TypeManager, RemoveIdDuplicateAmbiguousType) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeInt 32 0 %2 = OpTypeStruct %1 %3 = OpTypeStruct %1 )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); EXPECT_NE(context, nullptr); Integer u32(32, false); Struct st({&u32}); uint32_t id = context->get_type_mgr()->GetId(&st); ASSERT_NE(id, 0u); uint32_t toRemove = id == 2u ? 2u : 3u; uint32_t toStay = id == 2u ? 3u : 2u; context->get_type_mgr()->RemoveId(toRemove); ASSERT_EQ(context->get_type_mgr()->GetType(toRemove), nullptr); ASSERT_EQ(context->get_type_mgr()->GetId(&st), toStay); } TEST(TypeManager, RemoveIdDoesntUnmapOtherTypes) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 %1 = OpTypeInt 32 0 %2 = OpTypeStruct %1 %3 = OpTypeStruct %1 )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); EXPECT_NE(context, nullptr); Integer u32(32, false); Struct st({&u32}); EXPECT_EQ(1u, context->get_type_mgr()->GetId(&u32)); uint32_t id = context->get_type_mgr()->GetId(&st); ASSERT_NE(id, 0u); uint32_t toRemove = id == 2u ? 3u : 2u; uint32_t toStay = id == 2u ? 2u : 3u; context->get_type_mgr()->RemoveId(toRemove); ASSERT_EQ(context->get_type_mgr()->GetType(toRemove), nullptr); ASSERT_EQ(context->get_type_mgr()->GetId(&st), toStay); } TEST(TypeManager, GetTypeAndPointerType) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeInt 32 0 %2 = OpTypeStruct %1 )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); EXPECT_NE(context, nullptr); Integer u32(32, false); Pointer u32Ptr(&u32, spv::StorageClass::Function); Struct st({&u32}); Pointer stPtr(&st, spv::StorageClass::Input); auto pair = context->get_type_mgr()->GetTypeAndPointerType( 3u, spv::StorageClass::Function); ASSERT_EQ(nullptr, pair.first); ASSERT_EQ(nullptr, pair.second); pair = context->get_type_mgr()->GetTypeAndPointerType( 1u, spv::StorageClass::Function); ASSERT_TRUE(pair.first->IsSame(&u32)); ASSERT_TRUE(pair.second->IsSame(&u32Ptr)); pair = context->get_type_mgr()->GetTypeAndPointerType( 2u, spv::StorageClass::Input); ASSERT_TRUE(pair.first->IsSame(&st)); ASSERT_TRUE(pair.second->IsSame(&stPtr)); } TEST(TypeManager, DuplicateType) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 %1 = OpTypeInt 32 0 %2 = OpTypeInt 32 0 )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); EXPECT_NE(context, nullptr); const Type* type1 = context->get_type_mgr()->GetType(1u); const Type* type2 = context->get_type_mgr()->GetType(2u); EXPECT_NE(type1, nullptr); EXPECT_NE(type2, nullptr); EXPECT_EQ(*type1, *type2); } TEST(TypeManager, MultipleStructs) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpDecorate %3 Constant %1 = OpTypeInt 32 0 %2 = OpTypeStruct %1 %3 = OpTypeStruct %1 )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); EXPECT_NE(context, nullptr); const Type* type1 = context->get_type_mgr()->GetType(2u); const Type* type2 = context->get_type_mgr()->GetType(3u); EXPECT_NE(type1, nullptr); EXPECT_NE(type2, nullptr); EXPECT_FALSE(type1->IsSame(type2)); } TEST(TypeManager, RemovingIdAvoidsUseAfterFree) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 %1 = OpTypeInt 32 0 %2 = OpTypeStruct %1 )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); EXPECT_NE(context, nullptr); Integer u32(32, false); Struct st({&u32}); const Type* type = context->get_type_mgr()->GetType(2u); EXPECT_NE(type, nullptr); context->get_type_mgr()->RemoveId(1u); EXPECT_TRUE(type->IsSame(&st)); } TEST(TypeManager, RegisterAndRemoveId) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 %1 = OpTypeInt 32 0 )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); EXPECT_NE(context, nullptr); uint32_t id = 2u; { // Ensure that u32 goes out of scope. Integer u32(32, false); Struct st({&u32}); context->get_type_mgr()->RegisterType(id, st); } context->get_type_mgr()->RemoveId(id); EXPECT_EQ(nullptr, context->get_type_mgr()->GetType(id)); } TEST(TypeManager, RegisterAndRemoveIdAllTypes) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); EXPECT_NE(context, nullptr); std::vector> types = GenerateAllTypes(); uint32_t id = 0u; for (auto& t : types) { context->get_type_mgr()->RegisterType(++id, *t); EXPECT_EQ(*t, *context->get_type_mgr()->GetType(id)); EXPECT_EQ(id, context->get_type_mgr()->GetId(t.get())); } types.clear(); for (; id > 0; --id) { context->get_type_mgr()->RemoveId(id); EXPECT_EQ(nullptr, context->get_type_mgr()->GetType(id)); } } TEST(TypeManager, RegisterAndRemoveIdWithDecorations) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 %1 = OpTypeInt 32 0 )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); EXPECT_NE(context, nullptr); uint32_t id = 2u; { Integer u32(32, false); Struct st({&u32, &u32}); st.AddDecoration({10}); st.AddDecoration({11}); st.AddMemberDecoration(0, {{35, 4}}); st.AddMemberDecoration(1, {{35, 4}}); st.AddMemberDecoration(1, {{36, 5}}); context->get_type_mgr()->RegisterType(id, st); EXPECT_EQ(st, *context->get_type_mgr()->GetType(id)); } context->get_type_mgr()->RemoveId(id); EXPECT_EQ(nullptr, context->get_type_mgr()->GetType(id)); } TEST(TypeManager, GetTypeInstructionInt) { const std::string text = R"( ; CHECK: OpTypeInt 32 0 ; CHECK: OpTypeInt 16 1 OpCapability Shader OpCapability Int16 OpCapability Linkage OpMemoryModel Logical GLSL450 )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); EXPECT_NE(context, nullptr); Integer uint_32(32, false); context->get_type_mgr()->GetTypeInstruction(&uint_32); Integer int_16(16, true); context->get_type_mgr()->GetTypeInstruction(&int_16); Match(text, context.get()); } TEST(TypeManager, GetTypeInstructionDuplicateInts) { const std::string text = R"( ; CHECK: OpTypeInt 32 0 ; CHECK-NOT: OpType OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); EXPECT_NE(context, nullptr); Integer uint_32(32, false); uint32_t id = context->get_type_mgr()->GetTypeInstruction(&uint_32); Integer other(32, false); EXPECT_EQ(context->get_type_mgr()->GetTypeInstruction(&other), id); Match(text, context.get()); } TEST(TypeManager, GetTypeInstructionAllTypes) { const std::string text = R"( ; CHECK: [[uint:%\w+]] = OpTypeInt 32 0 ; CHECK: [[input_ptr:%\w+]] = OpTypePointer Input [[uint]] ; CHECK: [[uniform_ptr:%\w+]] = OpTypePointer Uniform [[uint]] ; CHECK: [[uint2:%\w+]] = OpConstant [[uint]] 2 ; CHECK: [[uint8:%\w+]] = OpConstant [[uint]] 8 ; CHECK: [[uint24:%\w+]] = OpConstant [[uint]] 24 ; CHECK: [[uint42:%\w+]] = OpConstant [[uint]] 42 ; CHECK: [[uint100:%\w+]] = OpConstant [[uint]] 100 ; CHECK: [[void:%\w+]] = OpTypeVoid ; CHECK: [[bool:%\w+]] = OpTypeBool ; CHECK: [[s32:%\w+]] = OpTypeInt 32 1 ; CHECK: OpTypeInt 64 1 ; CHECK: [[u64:%\w+]] = OpTypeInt 64 0 ; CHECK: [[f32:%\w+]] = OpTypeFloat 32 ; CHECK: OpTypeFloat 64 ; CHECK: OpTypeVector [[s32]] 2 ; CHECK: [[v3s32:%\w+]] = OpTypeVector [[s32]] 3 ; CHECK: OpTypeVector [[u64]] 4 ; CHECK: [[v3f32:%\w+]] = OpTypeVector [[f32]] 3 ; CHECK: OpTypeMatrix [[v3s32]] 3 ; CHECK: OpTypeMatrix [[v3s32]] 4 ; CHECK: OpTypeMatrix [[v3f32]] 4 ; CHECK: [[image1:%\w+]] = OpTypeImage [[s32]] 2D 0 0 0 0 Rg8 ReadOnly ; CHECK: OpTypeImage [[s32]] 2D 0 1 0 0 Rg8 ReadOnly ; CHECK: OpTypeImage [[s32]] 3D 0 1 0 0 Rg8 ReadOnly ; CHECK: [[image2:%\w+]] = OpTypeImage [[void]] 3D 0 1 0 1 Rg8 ReadWrite ; CHECK: OpTypeSampler ; CHECK: OpTypeSampledImage [[image1]] ; CHECK: OpTypeSampledImage [[image2]] ; CHECK: OpTypeArray [[f32]] [[uint100]] ; CHECK: [[a42f32:%\w+]] = OpTypeArray [[f32]] [[uint42]] ; CHECK: OpTypeArray [[u64]] [[uint24]] ; CHECK: OpTypeRuntimeArray [[v3f32]] ; CHECK: [[rav3s32:%\w+]] = OpTypeRuntimeArray [[v3s32]] ; CHECK: OpTypeStruct [[s32]] ; CHECK: [[sts32f32:%\w+]] = OpTypeStruct [[s32]] [[f32]] ; CHECK: OpTypeStruct [[u64]] [[a42f32]] [[rav3s32]] ; CHECK: OpTypeOpaque "" ; CHECK: OpTypeOpaque "hello" ; CHECK: OpTypeOpaque "world" ; CHECK: OpTypePointer Input [[f32]] ; CHECK: OpTypePointer Function [[sts32f32]] ; CHECK: OpTypePointer Function [[a42f32]] ; CHECK: OpTypeFunction [[void]] ; CHECK: OpTypeFunction [[void]] [[bool]] ; CHECK: OpTypeFunction [[void]] [[bool]] [[s32]] ; CHECK: OpTypeFunction [[s32]] [[bool]] [[s32]] ; CHECK: OpTypeEvent ; CHECK: OpTypeDeviceEvent ; CHECK: OpTypeReserveId ; CHECK: OpTypeQueue ; CHECK: OpTypePipe ReadWrite ; CHECK: OpTypePipe ReadOnly ; CHECK: OpTypeForwardPointer [[input_ptr]] Input ; CHECK: OpTypeForwardPointer [[uniform_ptr]] Input ; CHECK: OpTypeForwardPointer [[uniform_ptr]] Uniform ; CHECK: OpTypePipeStorage ; CHECK: OpTypeNamedBarrier ; CHECK: OpTypeAccelerationStructureKHR ; CHECK: OpTypeCooperativeMatrixNV [[f32]] [[uint24]] [[uint24]] [[uint24]] ; CHECK: OpTypeCooperativeMatrixKHR [[f32]] [[uint8]] [[uint8]] [[uint8]] [[uint2]] ; CHECK: OpTypeRayQueryKHR ; CHECK: OpTypeHitObjectNV OpCapability Shader OpCapability Int64 OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpTypePointer Input %uint %2 = OpTypePointer Uniform %uint %1000 = OpConstant %uint 0 %1001 = OpConstant %uint 1 %1002 = OpConstant %uint 2 %8 = OpConstant %uint 8 %24 = OpConstant %uint 24 %42 = OpConstant %uint 42 %100 = OpConstant %uint 100 %1003 = OpConstantFalse %bool )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); EXPECT_NE(context, nullptr); std::vector> types = GenerateAllTypes(); for (auto& t : types) { context->get_type_mgr()->GetTypeInstruction(t.get()); } Match(text, context.get(), false); } TEST(TypeManager, GetTypeInstructionWithDecorations) { const std::string text = R"( ; CHECK: OpDecorate [[struct:%\w+]] CPacked ; CHECK: OpMemberDecorate [[struct]] 1 Offset 4 ; CHECK: [[uint:%\w+]] = OpTypeInt 32 0 ; CHECK: [[struct]] = OpTypeStruct [[uint]] [[uint]] OpCapability Shader OpCapability Kernel OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); EXPECT_NE(context, nullptr); Integer u32(32, false); Struct st({&u32, &u32}); st.AddDecoration({10}); st.AddMemberDecoration(1, {{35, 4}}); (void)context->get_def_use_mgr(); context->get_type_mgr()->GetTypeInstruction(&st); Match(text, context.get()); } TEST(TypeManager, GetPointerToAmbiguousType1) { const std::string text = R"( ; CHECK: [[struct1:%\w+]] = OpTypeStruct ; CHECK: [[struct2:%\w+]] = OpTypeStruct ; CHECK: OpTypePointer Function [[struct2]] ; CHECK: OpTypePointer Function [[struct1]] OpCapability Shader OpCapability Kernel OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpTypeStruct %uint %2 = OpTypeStruct %uint %3 = OpTypePointer Function %2 )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); EXPECT_NE(context, nullptr); context->get_type_mgr()->FindPointerToType(1, spv::StorageClass::Function); Match(text, context.get()); } TEST(TypeManager, GetPointerToAmbiguousType2) { const std::string text = R"( ; CHECK: [[struct1:%\w+]] = OpTypeStruct ; CHECK: [[struct2:%\w+]] = OpTypeStruct ; CHECK: OpTypePointer Function [[struct1]] ; CHECK: OpTypePointer Function [[struct2]] OpCapability Shader OpCapability Kernel OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpTypeStruct %uint %2 = OpTypeStruct %uint %3 = OpTypePointer Function %1 )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); EXPECT_NE(context, nullptr); context->get_type_mgr()->FindPointerToType(2, spv::StorageClass::Function); Match(text, context.get()); } // Structures containing circular type references // (from https://github.com/KhronosGroup/SPIRV-Tools/issues/5623). TEST(TypeManager, CircularPointerToStruct) { const std::string text = R"( OpCapability VariablePointers OpCapability PhysicalStorageBufferAddresses OpCapability Int64 OpCapability Shader OpExtension "SPV_KHR_variable_pointers" OpExtension "SPV_KHR_physical_storage_buffer" OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpExecutionMode %1 DepthReplacing OpDecorate %1200 ArrayStride 24 OpMemberDecorate %600 0 Offset 0 OpMemberDecorate %800 0 Offset 0 OpMemberDecorate %120 0 Offset 16 OpTypeForwardPointer %1200 PhysicalStorageBuffer %600 = OpTypeStruct %1200 %800 = OpTypeStruct %1200 %120 = OpTypeStruct %800 %1200 = OpTypePointer PhysicalStorageBuffer %120 )"; std::unique_ptr context = BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); TypeManager manager(nullptr, context.get()); uint32_t id = manager.FindPointerToType(600, spv::StorageClass::Function); EXPECT_EQ(id, 1201); } } // namespace } // namespace analysis } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/types_test.cpp000066400000000000000000000406641475742701700232330ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/opt/types.h" #include #include #include #include "gtest/gtest.h" #include "source/util/make_unique.h" namespace spvtools { namespace opt { namespace analysis { namespace { // Fixture class providing some element types. class SameTypeTest : public ::testing::Test { protected: void SetUp() override { void_t_ = MakeUnique(); u32_t_ = MakeUnique(32, false); f64_t_ = MakeUnique(64); v3u32_t_ = MakeUnique(u32_t_.get(), 3); image_t_ = MakeUnique(f64_t_.get(), spv::Dim::Dim2D, 1, 1, 0, 0, spv::ImageFormat::R16, spv::AccessQualifier::ReadWrite); } // Element types to be used for constructing other types for testing. std::unique_ptr void_t_; std::unique_ptr u32_t_; std::unique_ptr f64_t_; std::unique_ptr v3u32_t_; std::unique_ptr image_t_; }; #define TestMultipleInstancesOfTheSameTypeQualified(ty, name, ...) \ TEST_F(SameTypeTest, MultiSame##ty##name) { \ std::vector> types; \ for (int i = 0; i < 10; ++i) types.emplace_back(new ty(__VA_ARGS__)); \ for (size_t i = 0; i < types.size(); ++i) { \ for (size_t j = 0; j < types.size(); ++j) { \ EXPECT_TRUE(types[i]->IsSame(types[j].get())) \ << "expected '" << types[i]->str() << "' is the same as '" \ << types[j]->str() << "'"; \ EXPECT_TRUE(*types[i] == *types[j]) \ << "expected '" << types[i]->str() << "' is the same as '" \ << types[j]->str() << "'"; \ } \ } \ } #define TestMultipleInstancesOfTheSameType(ty, ...) \ TestMultipleInstancesOfTheSameTypeQualified(ty, Simple, __VA_ARGS__) // clang-format off TestMultipleInstancesOfTheSameType(Void) TestMultipleInstancesOfTheSameType(Bool) TestMultipleInstancesOfTheSameType(Integer, 32, true) TestMultipleInstancesOfTheSameType(Float, 64) TestMultipleInstancesOfTheSameType(Vector, u32_t_.get(), 3) TestMultipleInstancesOfTheSameType(Matrix, v3u32_t_.get(), 4) TestMultipleInstancesOfTheSameType(Image, f64_t_.get(), spv::Dim::Cube, 0, 0, 1, 1, spv::ImageFormat::Rgb10A2, spv::AccessQualifier::WriteOnly) TestMultipleInstancesOfTheSameType(Sampler) TestMultipleInstancesOfTheSameType(SampledImage, image_t_.get()) // There are three classes of arrays, based on the kinds of length information // they have. // 1. Array length is a constant or spec constant without spec ID, with literals // for the constant value. TestMultipleInstancesOfTheSameTypeQualified(Array, LenConstant, u32_t_.get(), Array::LengthInfo{42, { 0, 9999, }}) // 2. Array length is a spec constant with a given spec id. TestMultipleInstancesOfTheSameTypeQualified(Array, LenSpecId, u32_t_.get(), Array::LengthInfo{42, {1, 99}}) // 3. Array length is an OpSpecConstantOp expression TestMultipleInstancesOfTheSameTypeQualified(Array, LenDefiningId, u32_t_.get(), Array::LengthInfo{42, {2, 42}}) TestMultipleInstancesOfTheSameType(RuntimeArray, u32_t_.get()) TestMultipleInstancesOfTheSameType(Struct, std::vector{ u32_t_.get(), f64_t_.get()}) TestMultipleInstancesOfTheSameType(Opaque, "testing rocks") TestMultipleInstancesOfTheSameType(Pointer, u32_t_.get(), spv::StorageClass::Input) TestMultipleInstancesOfTheSameType(Function, u32_t_.get(), {f64_t_.get(), f64_t_.get()}) TestMultipleInstancesOfTheSameType(Event) TestMultipleInstancesOfTheSameType(DeviceEvent) TestMultipleInstancesOfTheSameType(ReserveId) TestMultipleInstancesOfTheSameType(Queue) TestMultipleInstancesOfTheSameType(Pipe, spv::AccessQualifier::ReadWrite) TestMultipleInstancesOfTheSameType(ForwardPointer, 10, spv::StorageClass::Uniform) TestMultipleInstancesOfTheSameType(PipeStorage) TestMultipleInstancesOfTheSameType(NamedBarrier) TestMultipleInstancesOfTheSameType(AccelerationStructureNV) #undef TestMultipleInstanceOfTheSameType #undef TestMultipleInstanceOfTheSameTypeQual std::vector> GenerateAllTypes() { // clang-format on // Types in this test case are only equal to themselves, nothing else. std::vector> types; // Forward Pointer types.emplace_back(new ForwardPointer(10000, spv::StorageClass::Input)); types.emplace_back(new ForwardPointer(20000, spv::StorageClass::Input)); // Void, Bool types.emplace_back(new Void()); auto* voidt = types.back().get(); types.emplace_back(new Bool()); auto* boolt = types.back().get(); // Integer types.emplace_back(new Integer(32, true)); auto* s32 = types.back().get(); types.emplace_back(new Integer(32, false)); types.emplace_back(new Integer(64, true)); types.emplace_back(new Integer(64, false)); auto* u64 = types.back().get(); // Float types.emplace_back(new Float(32)); auto* f32 = types.back().get(); types.emplace_back(new Float(64)); // Vector types.emplace_back(new Vector(s32, 2)); types.emplace_back(new Vector(s32, 3)); auto* v3s32 = types.back().get(); types.emplace_back(new Vector(u64, 4)); types.emplace_back(new Vector(f32, 3)); auto* v3f32 = types.back().get(); // Matrix types.emplace_back(new Matrix(v3s32, 3)); types.emplace_back(new Matrix(v3s32, 4)); types.emplace_back(new Matrix(v3f32, 4)); // Images types.emplace_back(new Image(s32, spv::Dim::Dim2D, 0, 0, 0, 0, spv::ImageFormat::Rg8, spv::AccessQualifier::ReadOnly)); auto* image1 = types.back().get(); types.emplace_back(new Image(s32, spv::Dim::Dim2D, 0, 1, 0, 0, spv::ImageFormat::Rg8, spv::AccessQualifier::ReadOnly)); types.emplace_back(new Image(s32, spv::Dim::Dim3D, 0, 1, 0, 0, spv::ImageFormat::Rg8, spv::AccessQualifier::ReadOnly)); types.emplace_back(new Image(voidt, spv::Dim::Dim3D, 0, 1, 0, 1, spv::ImageFormat::Rg8, spv::AccessQualifier::ReadWrite)); auto* image2 = types.back().get(); // Sampler types.emplace_back(new Sampler()); // Sampled Image types.emplace_back(new SampledImage(image1)); types.emplace_back(new SampledImage(image2)); // Array // Length is constant with integer bit representation of 42. types.emplace_back(new Array(f32, Array::LengthInfo{99u, {0, 42u}})); auto* a42f32 = types.back().get(); // Differs from previous in length value only. types.emplace_back(new Array(f32, Array::LengthInfo{99u, {0, 44u}})); // Length is 64-bit constant integer value 42. types.emplace_back(new Array(u64, Array::LengthInfo{100u, {0, 42u, 0u}})); // Differs from previous in length value only. types.emplace_back(new Array(u64, Array::LengthInfo{100u, {0, 44u, 0u}})); // Length is spec constant with spec id 18 and default value 44. types.emplace_back(new Array(f32, Array::LengthInfo{99u, { 1, 18u, 44u, }})); // Differs from previous in spec id only. types.emplace_back(new Array(f32, Array::LengthInfo{99u, {1, 19u, 44u}})); // Differs from previous in literal value only. types.emplace_back(new Array(f32, Array::LengthInfo{99u, {1, 19u, 48u}})); // Length is spec constant op with id 42. types.emplace_back(new Array(f32, Array::LengthInfo{42u, {2, 42}})); // Differs from previous in result id only. types.emplace_back(new Array(f32, Array::LengthInfo{43u, {2, 43}})); // RuntimeArray types.emplace_back(new RuntimeArray(v3f32)); types.emplace_back(new RuntimeArray(v3s32)); auto* rav3s32 = types.back().get(); // Struct types.emplace_back(new Struct(std::vector{s32})); types.emplace_back(new Struct(std::vector{s32, f32})); auto* sts32f32 = types.back().get(); types.emplace_back( new Struct(std::vector{u64, a42f32, rav3s32})); // Opaque types.emplace_back(new Opaque("")); types.emplace_back(new Opaque("hello")); types.emplace_back(new Opaque("world")); // Pointer types.emplace_back(new Pointer(f32, spv::StorageClass::Input)); types.emplace_back(new Pointer(sts32f32, spv::StorageClass::Function)); types.emplace_back(new Pointer(a42f32, spv::StorageClass::Function)); types.emplace_back(new Pointer(voidt, spv::StorageClass::Function)); // Function types.emplace_back(new Function(voidt, {})); types.emplace_back(new Function(voidt, {boolt})); types.emplace_back(new Function(voidt, {boolt, s32})); types.emplace_back(new Function(s32, {boolt, s32})); // Event, Device Event, Reserve Id, Queue, types.emplace_back(new Event()); types.emplace_back(new DeviceEvent()); types.emplace_back(new ReserveId()); types.emplace_back(new Queue()); // Pipe, Forward Pointer, PipeStorage, NamedBarrier types.emplace_back(new Pipe(spv::AccessQualifier::ReadWrite)); types.emplace_back(new Pipe(spv::AccessQualifier::ReadOnly)); types.emplace_back(new ForwardPointer(1, spv::StorageClass::Input)); types.emplace_back(new ForwardPointer(2, spv::StorageClass::Input)); types.emplace_back(new ForwardPointer(2, spv::StorageClass::Uniform)); types.emplace_back(new PipeStorage()); types.emplace_back(new NamedBarrier()); return types; } TEST(Types, AllTypes) { // Types in this test case are only equal to themselves, nothing else. std::vector> types = GenerateAllTypes(); for (size_t i = 0; i < types.size(); ++i) { for (size_t j = 0; j < types.size(); ++j) { if (i == j) { EXPECT_TRUE(types[i]->IsSame(types[j].get())) << "expected '" << types[i]->str() << "' is the same as '" << types[j]->str() << "'"; } else { EXPECT_FALSE(types[i]->IsSame(types[j].get())) << "entry (" << i << "," << j << ") expected '" << types[i]->str() << "' is different to '" << types[j]->str() << "'"; } } } } TEST(Types, TestNumberOfComponentsOnArrays) { Float f32(32); EXPECT_EQ(f32.NumberOfComponents(), 0); Array array_size_42( &f32, Array::LengthInfo{99u, {Array::LengthInfo::kConstant, 42u}}); EXPECT_EQ(array_size_42.NumberOfComponents(), 42); Array array_size_0xDEADBEEF00C0FFEE( &f32, Array::LengthInfo{ 99u, {Array::LengthInfo::kConstant, 0xC0FFEE, 0xDEADBEEF}}); EXPECT_EQ(array_size_0xDEADBEEF00C0FFEE.NumberOfComponents(), 0xDEADBEEF00C0FFEEull); Array array_size_unknown( &f32, Array::LengthInfo{99u, {Array::LengthInfo::kConstantWithSpecId, 10}}); EXPECT_EQ(array_size_unknown.NumberOfComponents(), UINT64_MAX); RuntimeArray runtime_array(&f32); EXPECT_EQ(runtime_array.NumberOfComponents(), UINT64_MAX); } TEST(Types, TestNumberOfComponentsOnVectors) { Float f32(32); EXPECT_EQ(f32.NumberOfComponents(), 0); for (uint32_t vector_size = 1; vector_size < 4; ++vector_size) { Vector vector(&f32, vector_size); EXPECT_EQ(vector.NumberOfComponents(), vector_size); } } TEST(Types, TestNumberOfComponentsOnMatrices) { Float f32(32); Vector vector(&f32, 2); for (uint32_t number_of_columns = 1; number_of_columns < 4; ++number_of_columns) { Matrix matrix(&vector, number_of_columns); EXPECT_EQ(matrix.NumberOfComponents(), number_of_columns); } } TEST(Types, TestNumberOfComponentsOnStructs) { Float f32(32); Vector vector(&f32, 2); Struct empty_struct({}); EXPECT_EQ(empty_struct.NumberOfComponents(), 0); Struct struct_f32({&f32}); EXPECT_EQ(struct_f32.NumberOfComponents(), 1); Struct struct_f32_vec({&f32, &vector}); EXPECT_EQ(struct_f32_vec.NumberOfComponents(), 2); Struct struct_100xf32(std::vector(100, &f32)); EXPECT_EQ(struct_100xf32.NumberOfComponents(), 100); } TEST(Types, IntSignedness) { std::vector signednesses = {true, false, false, true}; std::vector> types; for (bool s : signednesses) { types.emplace_back(new Integer(32, s)); } for (size_t i = 0; i < signednesses.size(); i++) { EXPECT_EQ(signednesses[i], types[i]->IsSigned()); } } TEST(Types, IntWidth) { std::vector widths = {1, 2, 4, 8, 16, 32, 48, 64, 128}; std::vector> types; for (uint32_t w : widths) { types.emplace_back(new Integer(w, true)); } for (size_t i = 0; i < widths.size(); i++) { EXPECT_EQ(widths[i], types[i]->width()); } } TEST(Types, FloatWidth) { std::vector widths = {1, 2, 4, 8, 16, 32, 48, 64, 128}; std::vector> types; for (uint32_t w : widths) { types.emplace_back(new Float(w)); } for (size_t i = 0; i < widths.size(); i++) { EXPECT_EQ(widths[i], types[i]->width()); } } TEST(Types, VectorElementCount) { auto s32 = MakeUnique(32, true); for (uint32_t c : {2, 3, 4}) { auto s32v = MakeUnique(s32.get(), c); EXPECT_EQ(c, s32v->element_count()); } } TEST(Types, MatrixElementCount) { auto s32 = MakeUnique(32, true); auto s32v4 = MakeUnique(s32.get(), 4); for (uint32_t c : {1, 2, 3, 4, 10, 100}) { auto s32m = MakeUnique(s32v4.get(), c); EXPECT_EQ(c, s32m->element_count()); } } TEST(Types, IsUniqueType) { std::vector> types = GenerateAllTypes(); for (auto& t : types) { bool expectation = true; // Disallowing variable pointers. switch (t->kind()) { case Type::kArray: case Type::kRuntimeArray: case Type::kStruct: case Type::kPointer: expectation = false; break; default: break; } EXPECT_EQ(t->IsUniqueType(), expectation) << "expected '" << t->str() << "' to be a " << (expectation ? "" : "non-") << "unique type"; } } std::vector> GenerateAllTypesWithDecorations() { std::vector> types = GenerateAllTypes(); uint32_t elems = 1; uint32_t decs = 1; for (auto& t : types) { for (uint32_t i = 0; i < (decs % 10); ++i) { std::vector decoration; for (uint32_t j = 0; j < (elems % 4) + 1; ++j) { decoration.push_back(j); } t->AddDecoration(std::move(decoration)); ++elems; ++decs; } } return types; } TEST(Types, Clone) { std::vector> types = GenerateAllTypesWithDecorations(); for (auto& t : types) { auto clone = t->Clone(); EXPECT_TRUE(*t == *clone); EXPECT_TRUE(t->HasSameDecorations(clone.get())); EXPECT_NE(clone.get(), t.get()); } } TEST(Types, RemoveDecorations) { std::vector> types = GenerateAllTypesWithDecorations(); for (auto& t : types) { auto decorationless = t->RemoveDecorations(); EXPECT_EQ(*t == *decorationless, t->decoration_empty()); EXPECT_EQ(t->HasSameDecorations(decorationless.get()), t->decoration_empty()); EXPECT_NE(t.get(), decorationless.get()); } } } // namespace } // namespace analysis } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/unify_const_test.cpp000066400000000000000000001216001475742701700244150ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include #include #include "test/opt/assembly_builder.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { // Returns the types defining instructions commonly used in many tests. std::vector CommonTypes() { return std::vector{ // clang-format off // scalar types "%bool = OpTypeBool", "%uint = OpTypeInt 32 0", "%int = OpTypeInt 32 1", "%uint64 = OpTypeInt 64 0", "%int64 = OpTypeInt 64 1", "%float = OpTypeFloat 32", "%double = OpTypeFloat 64", // vector types "%v2bool = OpTypeVector %bool 2", "%v2uint = OpTypeVector %uint 2", "%v2int = OpTypeVector %int 2", "%v3int = OpTypeVector %int 3", "%v4int = OpTypeVector %int 4", "%v2float = OpTypeVector %float 2", "%v3float = OpTypeVector %float 3", "%v2double = OpTypeVector %double 2", // struct types "%inner_struct = OpTypeStruct %bool %float", "%outer_struct = OpTypeStruct %inner_struct %int %double", "%flat_struct = OpTypeStruct %bool %int %float %double", // variable pointer types "%_pf_bool = OpTypePointer Function %bool", "%_pf_uint = OpTypePointer Function %uint", "%_pf_int = OpTypePointer Function %int", "%_pf_uint64 = OpTypePointer Function %uint64", "%_pf_int64 = OpTypePointer Function %int64", "%_pf_float = OpTypePointer Function %float", "%_pf_double = OpTypePointer Function %double", "%_pf_v2int = OpTypePointer Function %v2int", "%_pf_v3int = OpTypePointer Function %v3int", "%_pf_v4int = OpTypePointer Function %v4int", "%_pf_v2float = OpTypePointer Function %v2float", "%_pf_v3float = OpTypePointer Function %v3float", "%_pf_v2double = OpTypePointer Function %v2double", "%_pf_inner_struct = OpTypePointer Function %inner_struct", "%_pf_outer_struct = OpTypePointer Function %outer_struct", "%_pf_flat_struct = OpTypePointer Function %flat_struct", // clang-format on }; } // A helper function to strip OpName instructions from the given string of // disassembly code and put those debug instructions to a set. Returns the // string with all OpName instruction stripped and a set of OpName // instructions. std::tuple> StripOpNameInstructionsToSet(const std::string& str) { std::stringstream ss(str); std::ostringstream oss; std::string inst_str; std::unordered_set opname_instructions; while (std::getline(ss, inst_str, '\n')) { if (inst_str.find("OpName %") == std::string::npos) { oss << inst_str << '\n'; } else { opname_instructions.insert(inst_str); } } return std::make_tuple(oss.str(), std::move(opname_instructions)); } // The test fixture for all tests of UnifyConstantPass. This fixture defines // the rule of checking: all the optimized code should be exactly the same as // the expected code, except the OpName instructions, which can be different in // order. template class UnifyConstantTest : public PassTest { protected: // Runs UnifyConstantPass on the code built from the given |test_builder|, // and checks whether the optimization result matches with the code built // from |expected_builder|. void Check(const AssemblyBuilder& expected_builder, const AssemblyBuilder& test_builder) { // unoptimized code const std::string original_before_strip = test_builder.GetCode(); std::string original_without_opnames; std::unordered_set original_opnames; std::tie(original_without_opnames, original_opnames) = StripOpNameInstructionsToSet(original_before_strip); // expected code std::string expected_without_opnames; std::unordered_set expected_opnames; std::tie(expected_without_opnames, expected_opnames) = StripOpNameInstructionsToSet(expected_builder.GetCode()); // optimized code std::string optimized_before_strip; auto status = Pass::Status::SuccessWithoutChange; std::tie(optimized_before_strip, status) = this->template SinglePassRunAndDisassemble( test_builder.GetCode(), /* skip_nop = */ true, /* do_validation = */ false); std::string optimized_without_opnames; std::unordered_set optimized_opnames; std::tie(optimized_without_opnames, optimized_opnames) = StripOpNameInstructionsToSet(optimized_before_strip); // Flag "status" should be returned correctly. EXPECT_NE(Pass::Status::Failure, status); EXPECT_EQ(expected_without_opnames == original_without_opnames, status == Pass::Status::SuccessWithoutChange); // Code except OpName instructions should be exactly the same. EXPECT_EQ(expected_without_opnames, optimized_without_opnames); // OpName instructions can be in different order, but the content must be // the same. EXPECT_EQ(expected_opnames, optimized_opnames); } }; using UnifyFrontEndConstantSingleTest = UnifyConstantTest>; TEST_F(UnifyFrontEndConstantSingleTest, Basic) { AssemblyBuilder test_builder; AssemblyBuilder expected_builder; test_builder .AppendTypesConstantsGlobals({ "%uint = OpTypeInt 32 0", "%_pf_uint = OpTypePointer Function %uint", "%unsigned_1 = OpConstant %uint 1", "%unsigned_1_duplicate = OpConstant %uint 1", // duplicated constant }) .AppendInMain({ "%uint_var = OpVariable %_pf_uint Function", "OpStore %uint_var %unsigned_1_duplicate", }); expected_builder .AppendTypesConstantsGlobals({ "%uint = OpTypeInt 32 0", "%_pf_uint = OpTypePointer Function %uint", "%unsigned_1 = OpConstant %uint 1", }) .AppendInMain({ "%uint_var = OpVariable %_pf_uint Function", "OpStore %uint_var %unsigned_1", }) .AppendNames({ "OpName %unsigned_1 \"unsigned_1_duplicate\"", // the OpName // instruction of the // removed duplicated // constant won't be // erased. }); Check(expected_builder, test_builder); } TEST_F(UnifyFrontEndConstantSingleTest, SkipWhenResultIdHasDecorations) { AssemblyBuilder test_builder; AssemblyBuilder expected_builder; test_builder .AppendAnnotations({ // So far we don't have valid decorations for constants. This is // preparing for the future updates of SPIR-V. // TODO(qining): change to a valid decoration once they are available. "OpDecorate %f_1 RelaxedPrecision", "OpDecorate %f_2_dup RelaxedPrecision", }) .AppendTypesConstantsGlobals({ // clang-format off "%float = OpTypeFloat 32", "%_pf_float = OpTypePointer Function %float", "%f_1 = OpConstant %float 1", // %f_1 has decoration, so %f_1 will not be used to replace %f_1_dup. "%f_1_dup = OpConstant %float 1", "%f_2 = OpConstant %float 2", // %_2_dup has decoration, so %f_2 will not replace %f_2_dup. "%f_2_dup = OpConstant %float 2", // no decoration for %f_3 or %f_3_dup, %f_3_dup should be replaced. "%f_3 = OpConstant %float 3", "%f_3_dup = OpConstant %float 3", // clang-format on }) .AppendInMain({ // clang-format off "%f_var = OpVariable %_pf_float Function", "OpStore %f_var %f_1_dup", "OpStore %f_var %f_2_dup", "OpStore %f_var %f_3_dup", // clang-format on }); expected_builder .AppendAnnotations({ "OpDecorate %f_1 RelaxedPrecision", "OpDecorate %f_2_dup RelaxedPrecision", }) .AppendTypesConstantsGlobals({ // clang-format off "%float = OpTypeFloat 32", "%_pf_float = OpTypePointer Function %float", "%f_1 = OpConstant %float 1", "%f_1_dup = OpConstant %float 1", "%f_2 = OpConstant %float 2", "%f_2_dup = OpConstant %float 2", "%f_3 = OpConstant %float 3", // clang-format on }) .AppendInMain({ // clang-format off "%f_var = OpVariable %_pf_float Function", "OpStore %f_var %f_1_dup", "OpStore %f_var %f_2_dup", "OpStore %f_var %f_3", // clang-format on }) .AppendNames({ "OpName %f_3 \"f_3_dup\"", }); Check(expected_builder, test_builder); } TEST_F(UnifyFrontEndConstantSingleTest, UnifyWithDecorationOnTypes) { AssemblyBuilder test_builder; AssemblyBuilder expected_builder; test_builder .AppendAnnotations({ "OpMemberDecorate %flat_d 1 RelaxedPrecision", }) .AppendTypesConstantsGlobals({ // clang-format off "%int = OpTypeInt 32 1", "%float = OpTypeFloat 32", "%flat = OpTypeStruct %int %float", "%_pf_flat = OpTypePointer Function %flat", // decorated flat struct "%flat_d = OpTypeStruct %int %float", "%_pf_flat_d = OpTypePointer Function %flat_d", // preserved constants. %flat_1 and %flat_d has same members, but // their type are different in decorations, so they should not be // used to replace each other. "%int_1 = OpConstant %int 1", "%float_1 = OpConstant %float 1", "%flat_1 = OpConstantComposite %flat %int_1 %float_1", "%flat_d_1 = OpConstantComposite %flat_d %int_1 %float_1", // duplicated constants. "%flat_1_dup = OpConstantComposite %flat %int_1 %float_1", "%flat_d_1_dup = OpConstantComposite %flat_d %int_1 %float_1", // clang-format on }) .AppendInMain({ "%flat_var = OpVariable %_pf_flat Function", "OpStore %flat_var %flat_1_dup", "%flat_d_var = OpVariable %_pf_flat_d Function", "OpStore %flat_d_var %flat_d_1_dup", }); expected_builder .AppendAnnotations({ "OpMemberDecorate %flat_d 1 RelaxedPrecision", }) .AppendTypesConstantsGlobals({ // clang-format off "%int = OpTypeInt 32 1", "%float = OpTypeFloat 32", "%flat = OpTypeStruct %int %float", "%_pf_flat = OpTypePointer Function %flat", // decorated flat struct "%flat_d = OpTypeStruct %int %float", "%_pf_flat_d = OpTypePointer Function %flat_d", "%int_1 = OpConstant %int 1", "%float_1 = OpConstant %float 1", "%flat_1 = OpConstantComposite %flat %int_1 %float_1", "%flat_d_1 = OpConstantComposite %flat_d %int_1 %float_1", // clang-format on }) .AppendInMain({ "%flat_var = OpVariable %_pf_flat Function", "OpStore %flat_var %flat_1", "%flat_d_var = OpVariable %_pf_flat_d Function", "OpStore %flat_d_var %flat_d_1", }) .AppendNames({ "OpName %flat_1 \"flat_1_dup\"", "OpName %flat_d_1 \"flat_d_1_dup\"", }); Check(expected_builder, test_builder); } struct UnifyConstantTestCase { // preserved constants. std::vector preserved_consts; // expected uses of the preserved constants. std::vector use_preserved_consts; // duplicated constants of the preserved constants. std::vector duplicate_consts; // uses of the duplicated constants, expected to be updated to use the // preserved constants. std::vector use_duplicate_consts; // The updated OpName instructions that originally refer to duplicated // constants. std::vector remapped_names; }; using UnifyFrontEndConstantParamTest = UnifyConstantTest< PassTest<::testing::TestWithParam>>; TEST_P(UnifyFrontEndConstantParamTest, TestCase) { auto& tc = GetParam(); AssemblyBuilder test_builder; AssemblyBuilder expected_builder; test_builder.AppendTypesConstantsGlobals(CommonTypes()); expected_builder.AppendTypesConstantsGlobals(CommonTypes()); test_builder.AppendTypesConstantsGlobals(tc.preserved_consts) .AppendTypesConstantsGlobals(tc.duplicate_consts) .AppendInMain(tc.use_duplicate_consts); // Duplicated constants are killed in the expected output, and the debug // instructions attached to those duplicated instructions will be migrated to // the corresponding preserved constants. expected_builder.AppendTypesConstantsGlobals(tc.preserved_consts) .AppendInMain(tc.use_preserved_consts) .AppendNames(tc.remapped_names); Check(expected_builder, test_builder); } INSTANTIATE_TEST_SUITE_P( Case, UnifyFrontEndConstantParamTest, :: testing:: ValuesIn( std:: vector( { // clang-format off // basic tests for scalar constants { // preserved constants { "%bool_true = OpConstantTrue %bool", "%signed_1 = OpConstant %int 1", "%signed_minus_1 = OpConstant %int64 -1", "%unsigned_max = OpConstant %uint64 18446744073709551615", "%float_1 = OpConstant %float 1", "%double_1 = OpConstant %double 1", }, // use preserved constants in main { "%bool_var = OpVariable %_pf_bool Function", "OpStore %bool_var %bool_true", "%int_var = OpVariable %_pf_int Function", "OpStore %int_var %signed_1", "%int64_var = OpVariable %_pf_int64 Function", "OpStore %int64_var %signed_minus_1", "%uint64_var = OpVariable %_pf_uint64 Function", "OpStore %uint64_var %unsigned_max", "%float_var = OpVariable %_pf_float Function", "OpStore %float_var %float_1", "%double_var = OpVariable %_pf_double Function", "OpStore %double_var %double_1", }, // duplicated constants { "%bool_true_duplicate = OpConstantTrue %bool", "%signed_1_duplicate = OpConstant %int 1", "%signed_minus_1_duplicate = OpConstant %int64 -1", "%unsigned_max_duplicate = OpConstant %uint64 18446744073709551615", "%float_1_duplicate = OpConstant %float 1", "%double_1_duplicate = OpConstant %double 1", }, // use duplicated constants in main { "%bool_var = OpVariable %_pf_bool Function", "OpStore %bool_var %bool_true_duplicate", "%int_var = OpVariable %_pf_int Function", "OpStore %int_var %signed_1_duplicate", "%int64_var = OpVariable %_pf_int64 Function", "OpStore %int64_var %signed_minus_1_duplicate", "%uint64_var = OpVariable %_pf_uint64 Function", "OpStore %uint64_var %unsigned_max_duplicate", "%float_var = OpVariable %_pf_float Function", "OpStore %float_var %float_1_duplicate", "%double_var = OpVariable %_pf_double Function", "OpStore %double_var %double_1_duplicate", }, // remapped names { "OpName %bool_true \"bool_true_duplicate\"", "OpName %signed_1 \"signed_1_duplicate\"", "OpName %signed_minus_1 \"signed_minus_1_duplicate\"", "OpName %unsigned_max \"unsigned_max_duplicate\"", "OpName %float_1 \"float_1_duplicate\"", "OpName %double_1 \"double_1_duplicate\"", }, }, // NaN in different bit patterns should not be unified, but the ones // using same bit pattern should be unified. { // preserved constants { "%float_nan_1 = OpConstant %float 0x1.8p+128", // !2143289344, 7FC00000 "%float_nan_2 = OpConstant %float 0x1.800002p+128",// !2143289345 7FC00001 }, // use preserved constants in main { "%float_var = OpVariable %_pf_float Function", "OpStore %float_var %float_nan_1", "OpStore %float_var %float_nan_2", }, // duplicated constants { "%float_nan_1_duplicate = OpConstant %float 0x1.8p+128", // !2143289344, 7FC00000 "%float_nan_2_duplicate = OpConstant %float 0x1.800002p+128",// !2143289345, 7FC00001 }, // use duplicated constants in main { "%float_var = OpVariable %_pf_float Function", "OpStore %float_var %float_nan_1_duplicate", "OpStore %float_var %float_nan_2_duplicate", }, // remapped names { "OpName %float_nan_1 \"float_nan_1_duplicate\"", "OpName %float_nan_2 \"float_nan_2_duplicate\"", }, }, // null values { // preserved constants { "%bool_null = OpConstantNull %bool", "%signed_null = OpConstantNull %int", "%signed_64_null = OpConstantNull %int64", "%float_null = OpConstantNull %float", "%double_null = OpConstantNull %double", // zero-valued constants will not be unified with the equivalent // null constants. "%signed_zero = OpConstant %int 0", }, // use preserved constants in main { "%bool_var = OpVariable %_pf_bool Function", "OpStore %bool_var %bool_null", "%int_var = OpVariable %_pf_int Function", "OpStore %int_var %signed_null", "%int64_var = OpVariable %_pf_int64 Function", "OpStore %int64_var %signed_64_null", "%float_var = OpVariable %_pf_float Function", "OpStore %float_var %float_null", "%double_var = OpVariable %_pf_double Function", "OpStore %double_var %double_null", }, // duplicated constants { "%bool_null_duplicate = OpConstantNull %bool", "%signed_null_duplicate = OpConstantNull %int", "%signed_64_null_duplicate = OpConstantNull %int64", "%float_null_duplicate = OpConstantNull %float", "%double_null_duplicate = OpConstantNull %double", }, // use duplicated constants in main { "%bool_var = OpVariable %_pf_bool Function", "OpStore %bool_var %bool_null_duplicate", "%int_var = OpVariable %_pf_int Function", "OpStore %int_var %signed_null_duplicate", "%int64_var = OpVariable %_pf_int64 Function", "OpStore %int64_var %signed_64_null_duplicate", "%float_var = OpVariable %_pf_float Function", "OpStore %float_var %float_null_duplicate", "%double_var = OpVariable %_pf_double Function", "OpStore %double_var %double_null_duplicate", }, // remapped names { "OpName %bool_null \"bool_null_duplicate\"", "OpName %signed_null \"signed_null_duplicate\"", "OpName %signed_64_null \"signed_64_null_duplicate\"", "OpName %float_null \"float_null_duplicate\"", "OpName %double_null \"double_null_duplicate\"", }, }, // constant sampler { // preserved constants { "%sampler = OpTypeSampler", "%_pf_sampler = OpTypePointer Function %sampler", "%sampler_1 = OpConstantSampler %sampler Repeat 0 Linear", }, // use preserved constants in main { "%sampler_var = OpVariable %_pf_sampler Function", "OpStore %sampler_var %sampler_1", }, // duplicated constants { "%sampler_1_duplicate = OpConstantSampler %sampler Repeat 0 Linear", }, // use duplicated constants in main { "%sampler_var = OpVariable %_pf_sampler Function", "OpStore %sampler_var %sampler_1_duplicate", }, // remapped names { "OpName %sampler_1 \"sampler_1_duplicate\"", }, }, // duplicate vector built from same ids. { // preserved constants { "%signed_1 = OpConstant %int 1", "%signed_2 = OpConstant %int 2", "%signed_3 = OpConstant %int 3", "%signed_4 = OpConstant %int 4", "%vec = OpConstantComposite %v4int %signed_1 %signed_2 %signed_3 %signed_4", }, // use preserved constants in main { "%vec_var = OpVariable %_pf_v4int Function", "OpStore %vec_var %vec", }, // duplicated constants { "%vec_duplicate = OpConstantComposite %v4int %signed_1 %signed_2 %signed_3 %signed_4", }, // use duplicated constants in main { "%vec_var = OpVariable %_pf_v4int Function", "OpStore %vec_var %vec_duplicate", }, // remapped names { "OpName %vec \"vec_duplicate\"", } }, // duplicate vector built from duplicated ids. { // preserved constants { "%signed_1 = OpConstant %int 1", "%signed_2 = OpConstant %int 2", "%signed_3 = OpConstant %int 3", "%signed_4 = OpConstant %int 4", "%vec = OpConstantComposite %v4int %signed_1 %signed_2 %signed_3 %signed_4", }, // use preserved constants in main { "%vec_var = OpVariable %_pf_v4int Function", "OpStore %vec_var %vec", }, // duplicated constants { "%signed_3_duplicate = OpConstant %int 3", "%signed_4_duplicate = OpConstant %int 4", "%vec_duplicate = OpConstantComposite %v4int %signed_1 %signed_2 %signed_3_duplicate %signed_4_duplicate", }, // use duplicated constants in main { "%vec_var = OpVariable %_pf_v4int Function", "OpStore %vec_var %vec_duplicate", }, // remapped names { "OpName %signed_3 \"signed_3_duplicate\"", "OpName %signed_4 \"signed_4_duplicate\"", "OpName %vec \"vec_duplicate\"", }, }, // flat struct { // preserved constants { "%bool_true = OpConstantTrue %bool", "%signed_1 = OpConstant %int 1", "%float_1 = OpConstant %float 1", "%double_1 = OpConstant %double 1", "%s = OpConstantComposite %flat_struct %bool_true %signed_1 %float_1 %double_1", }, // use preserved constants in main { "%s_var = OpVariable %_pf_flat_struct Function", "OpStore %s_var %s", }, // duplicated constants { "%float_1_duplicate = OpConstant %float 1", "%double_1_duplicate = OpConstant %double 1", "%s_duplicate = OpConstantComposite %flat_struct %bool_true %signed_1 %float_1_duplicate %double_1_duplicate", }, // use duplicated constants in main { "%s_var = OpVariable %_pf_flat_struct Function", "OpStore %s_var %s_duplicate", }, // remapped names { "OpName %float_1 \"float_1_duplicate\"", "OpName %double_1 \"double_1_duplicate\"", "OpName %s \"s_duplicate\"", }, }, // nested struct { // preserved constants { "%bool_true = OpConstantTrue %bool", "%signed_1 = OpConstant %int 1", "%float_1 = OpConstant %float 1", "%double_1 = OpConstant %double 1", "%inner = OpConstantComposite %inner_struct %bool_true %float_1", "%outer = OpConstantComposite %outer_struct %inner %signed_1 %double_1", }, // use preserved constants in main { "%outer_var = OpVariable %_pf_outer_struct Function", "OpStore %outer_var %outer", }, // duplicated constants { "%float_1_duplicate = OpConstant %float 1", "%double_1_duplicate = OpConstant %double 1", "%inner_duplicate = OpConstantComposite %inner_struct %bool_true %float_1_duplicate", "%outer_duplicate = OpConstantComposite %outer_struct %inner_duplicate %signed_1 %double_1_duplicate", }, // use duplicated constants in main { "%outer_var = OpVariable %_pf_outer_struct Function", "OpStore %outer_var %outer_duplicate", }, // remapped names { "OpName %float_1 \"float_1_duplicate\"", "OpName %double_1 \"double_1_duplicate\"", "OpName %inner \"inner_duplicate\"", "OpName %outer \"outer_duplicate\"", }, }, // composite type null constants. Null constants and zero-valued // constants should not be used to replace each other. { // preserved constants { "%bool_zero = OpConstantFalse %bool", "%float_zero = OpConstant %float 0", "%int_null = OpConstantNull %int", "%double_null = OpConstantNull %double", // inner_struct type null constant. "%null_inner = OpConstantNull %inner_struct", // zero-valued composite constant built from zero-valued constant // component. inner_zero should not be replace by null_inner. "%inner_zero = OpConstantComposite %inner_struct %bool_zero %float_zero", // zero-valued composite constant built from zero-valued constants // and null constants. "%outer_zero = OpConstantComposite %outer_struct %inner_zero %int_null %double_null", // outer_struct type null constant, it should not be replaced by // outer_zero. "%null_outer = OpConstantNull %outer_struct", }, // use preserved constants in main { "%inner_var = OpVariable %_pf_inner_struct Function", "OpStore %inner_var %inner_zero", "OpStore %inner_var %null_inner", "%outer_var = OpVariable %_pf_outer_struct Function", "OpStore %outer_var %outer_zero", "OpStore %outer_var %null_outer", }, // duplicated constants { "%null_inner_dup = OpConstantNull %inner_struct", "%null_outer_dup = OpConstantNull %outer_struct", "%inner_zero_dup = OpConstantComposite %inner_struct %bool_zero %float_zero", "%outer_zero_dup = OpConstantComposite %outer_struct %inner_zero_dup %int_null %double_null", }, // use duplicated constants in main { "%inner_var = OpVariable %_pf_inner_struct Function", "OpStore %inner_var %inner_zero_dup", "OpStore %inner_var %null_inner_dup", "%outer_var = OpVariable %_pf_outer_struct Function", "OpStore %outer_var %outer_zero_dup", "OpStore %outer_var %null_outer_dup", }, // remapped names { "OpName %null_inner \"null_inner_dup\"", "OpName %null_outer \"null_outer_dup\"", "OpName %inner_zero \"inner_zero_dup\"", "OpName %outer_zero \"outer_zero_dup\"", }, }, // Spec Constants with SpecId decoration should be skipped. { // preserved constants { // Assembly builder will add OpDecorate SpecId instruction for the // following spec constant instructions automatically. "%spec_bool_1 = OpSpecConstantTrue %bool", "%spec_bool_2 = OpSpecConstantTrue %bool", "%spec_int_1 = OpSpecConstant %int 1", "%spec_int_2 = OpSpecConstant %int 1", }, // use preserved constants in main { "%bool_var = OpVariable %_pf_bool Function", "OpStore %bool_var %spec_bool_1", "OpStore %bool_var %spec_bool_2", "%int_var = OpVariable %_pf_int Function", "OpStore %int_var %spec_int_1", "OpStore %int_var %spec_int_2", }, // duplicated constants. No duplicated instruction to remove in this // case. {}, // use duplicated constants in main. Same as the above 'use preserved // constants in main' defined above, as no instruction should be // removed in this case. { "%bool_var = OpVariable %_pf_bool Function", "OpStore %bool_var %spec_bool_1", "OpStore %bool_var %spec_bool_2", "%int_var = OpVariable %_pf_int Function", "OpStore %int_var %spec_int_1", "OpStore %int_var %spec_int_2", }, // remapped names. No duplicated instruction removed, so this is // empty. {} }, // spec constant composite { // preserved constants { "%spec_bool_true = OpSpecConstantTrue %bool", "%spec_signed_1 = OpSpecConstant %int 1", "%float_1 = OpConstant %float 1", "%double_1 = OpConstant %double 1", "%spec_inner = OpSpecConstantComposite %inner_struct %spec_bool_true %float_1", "%spec_outer = OpSpecConstantComposite %outer_struct %spec_inner %spec_signed_1 %double_1", "%spec_vec2 = OpSpecConstantComposite %v2float %float_1 %float_1", }, // use preserved constants in main { "%outer_var = OpVariable %_pf_outer_struct Function", "OpStore %outer_var %spec_outer", "%v2float_var = OpVariable %_pf_v2float Function", "OpStore %v2float_var %spec_vec2", }, // duplicated constants { "%float_1_duplicate = OpConstant %float 1", "%double_1_duplicate = OpConstant %double 1", "%spec_inner_duplicate = OpSpecConstantComposite %inner_struct %spec_bool_true %float_1_duplicate", "%spec_outer_duplicate = OpSpecConstantComposite %outer_struct %spec_inner_duplicate %spec_signed_1 %double_1_duplicate", "%spec_vec2_duplicate = OpSpecConstantComposite %v2float %float_1 %float_1_duplicate", }, // use duplicated constants in main { "%outer_var = OpVariable %_pf_outer_struct Function", "OpStore %outer_var %spec_outer_duplicate", "%v2float_var = OpVariable %_pf_v2float Function", "OpStore %v2float_var %spec_vec2_duplicate", }, // remapped names { "OpName %float_1 \"float_1_duplicate\"", "OpName %double_1 \"double_1_duplicate\"", "OpName %spec_inner \"spec_inner_duplicate\"", "OpName %spec_outer \"spec_outer_duplicate\"", "OpName %spec_vec2 \"spec_vec2_duplicate\"", }, }, // spec constant op with int scalar { // preserved constants { "%spec_signed_1 = OpSpecConstant %int 1", "%spec_signed_2 = OpSpecConstant %int 2", "%spec_signed_add = OpSpecConstantOp %int IAdd %spec_signed_1 %spec_signed_2", }, // use preserved constants in main { "%int_var = OpVariable %_pf_int Function", "OpStore %int_var %spec_signed_add", }, // duplicated constants { "%spec_signed_add_duplicate = OpSpecConstantOp %int IAdd %spec_signed_1 %spec_signed_2", }, // use duplicated constants in main { "%int_var = OpVariable %_pf_int Function", "OpStore %int_var %spec_signed_add_duplicate", }, // remapped names { "OpName %spec_signed_add \"spec_signed_add_duplicate\"", }, }, // spec constant op composite extract { // preserved constants { "%float_1 = OpConstant %float 1", "%spec_vec2 = OpSpecConstantComposite %v2float %float_1 %float_1", "%spec_extract = OpSpecConstantOp %float CompositeExtract %spec_vec2 1", }, // use preserved constants in main { "%float_var = OpVariable %_pf_float Function", "OpStore %float_var %spec_extract", }, // duplicated constants { "%spec_extract_duplicate = OpSpecConstantOp %float CompositeExtract %spec_vec2 1", }, // use duplicated constants in main { "%float_var = OpVariable %_pf_float Function", "OpStore %float_var %spec_extract_duplicate", }, // remapped names { "OpName %spec_extract \"spec_extract_duplicate\"", }, }, // spec constant op vector shuffle { // preserved constants { "%float_1 = OpConstant %float 1", "%float_2 = OpConstant %float 2", "%spec_vec2_1 = OpSpecConstantComposite %v2float %float_1 %float_1", "%spec_vec2_2 = OpSpecConstantComposite %v2float %float_2 %float_2", "%spec_vector_shuffle = OpSpecConstantOp %v2float VectorShuffle %spec_vec2_1 %spec_vec2_2 1 2", }, // use preserved constants in main { "%v2float_var = OpVariable %_pf_v2float Function", "OpStore %v2float_var %spec_vector_shuffle", }, // duplicated constants { "%spec_vector_shuffle_duplicate = OpSpecConstantOp %v2float VectorShuffle %spec_vec2_1 %spec_vec2_2 1 2", }, // use duplicated constants in main { "%v2float_var = OpVariable %_pf_v2float Function", "OpStore %v2float_var %spec_vector_shuffle_duplicate", }, // remapped names { "OpName %spec_vector_shuffle \"spec_vector_shuffle_duplicate\"", }, }, // long dependency chain { // preserved constants { "%array_size = OpConstant %int 4", "%type_arr_int_4 = OpTypeArray %int %array_size", "%signed_0 = OpConstant %int 100", "%signed_1 = OpConstant %int 1", "%signed_2 = OpSpecConstantOp %int IAdd %signed_0 %signed_1", "%signed_3 = OpSpecConstantOp %int ISub %signed_0 %signed_2", "%signed_4 = OpSpecConstantOp %int IAdd %signed_0 %signed_3", "%signed_5 = OpSpecConstantOp %int ISub %signed_0 %signed_4", "%signed_6 = OpSpecConstantOp %int IAdd %signed_0 %signed_5", "%signed_7 = OpSpecConstantOp %int ISub %signed_0 %signed_6", "%signed_8 = OpSpecConstantOp %int IAdd %signed_0 %signed_7", "%signed_9 = OpSpecConstantOp %int ISub %signed_0 %signed_8", "%signed_10 = OpSpecConstantOp %int IAdd %signed_0 %signed_9", "%signed_11 = OpSpecConstantOp %int ISub %signed_0 %signed_10", "%signed_12 = OpSpecConstantOp %int IAdd %signed_0 %signed_11", "%signed_13 = OpSpecConstantOp %int ISub %signed_0 %signed_12", "%signed_14 = OpSpecConstantOp %int IAdd %signed_0 %signed_13", "%signed_15 = OpSpecConstantOp %int ISub %signed_0 %signed_14", "%signed_16 = OpSpecConstantOp %int ISub %signed_0 %signed_15", "%signed_17 = OpSpecConstantOp %int IAdd %signed_0 %signed_16", "%signed_18 = OpSpecConstantOp %int ISub %signed_0 %signed_17", "%signed_19 = OpSpecConstantOp %int IAdd %signed_0 %signed_18", "%signed_20 = OpSpecConstantOp %int ISub %signed_0 %signed_19", "%signed_vec_a = OpSpecConstantComposite %v2int %signed_18 %signed_19", "%signed_vec_b = OpSpecConstantOp %v2int IMul %signed_vec_a %signed_vec_a", "%signed_21 = OpSpecConstantOp %int CompositeExtract %signed_vec_b 0", "%signed_array = OpConstantComposite %type_arr_int_4 %signed_20 %signed_20 %signed_21 %signed_21", "%signed_22 = OpSpecConstantOp %int CompositeExtract %signed_array 0", }, // use preserved constants in main { "%int_var = OpVariable %_pf_int Function", "OpStore %int_var %signed_22", }, // duplicated constants { "%signed_0_dup = OpConstant %int 100", "%signed_1_dup = OpConstant %int 1", "%signed_2_dup = OpSpecConstantOp %int IAdd %signed_0_dup %signed_1_dup", "%signed_3_dup = OpSpecConstantOp %int ISub %signed_0_dup %signed_2_dup", "%signed_4_dup = OpSpecConstantOp %int IAdd %signed_0_dup %signed_3_dup", "%signed_5_dup = OpSpecConstantOp %int ISub %signed_0_dup %signed_4_dup", "%signed_6_dup = OpSpecConstantOp %int IAdd %signed_0_dup %signed_5_dup", "%signed_7_dup = OpSpecConstantOp %int ISub %signed_0_dup %signed_6_dup", "%signed_8_dup = OpSpecConstantOp %int IAdd %signed_0_dup %signed_7_dup", "%signed_9_dup = OpSpecConstantOp %int ISub %signed_0_dup %signed_8_dup", "%signed_10_dup = OpSpecConstantOp %int IAdd %signed_0_dup %signed_9_dup", "%signed_11_dup = OpSpecConstantOp %int ISub %signed_0_dup %signed_10_dup", "%signed_12_dup = OpSpecConstantOp %int IAdd %signed_0_dup %signed_11_dup", "%signed_13_dup = OpSpecConstantOp %int ISub %signed_0_dup %signed_12_dup", "%signed_14_dup = OpSpecConstantOp %int IAdd %signed_0_dup %signed_13_dup", "%signed_15_dup = OpSpecConstantOp %int ISub %signed_0_dup %signed_14_dup", "%signed_16_dup = OpSpecConstantOp %int ISub %signed_0_dup %signed_15_dup", "%signed_17_dup = OpSpecConstantOp %int IAdd %signed_0_dup %signed_16_dup", "%signed_18_dup = OpSpecConstantOp %int ISub %signed_0_dup %signed_17_dup", "%signed_19_dup = OpSpecConstantOp %int IAdd %signed_0_dup %signed_18_dup", "%signed_20_dup = OpSpecConstantOp %int ISub %signed_0_dup %signed_19_dup", "%signed_vec_a_dup = OpSpecConstantComposite %v2int %signed_18_dup %signed_19_dup", "%signed_vec_b_dup = OpSpecConstantOp %v2int IMul %signed_vec_a_dup %signed_vec_a_dup", "%signed_21_dup = OpSpecConstantOp %int CompositeExtract %signed_vec_b_dup 0", "%signed_array_dup = OpConstantComposite %type_arr_int_4 %signed_20_dup %signed_20_dup %signed_21_dup %signed_21_dup", "%signed_22_dup = OpSpecConstantOp %int CompositeExtract %signed_array_dup 0", }, // use duplicated constants in main { "%int_var = OpVariable %_pf_int Function", "OpStore %int_var %signed_22_dup", }, // remapped names { "OpName %signed_0 \"signed_0_dup\"", "OpName %signed_1 \"signed_1_dup\"", "OpName %signed_2 \"signed_2_dup\"", "OpName %signed_3 \"signed_3_dup\"", "OpName %signed_4 \"signed_4_dup\"", "OpName %signed_5 \"signed_5_dup\"", "OpName %signed_6 \"signed_6_dup\"", "OpName %signed_7 \"signed_7_dup\"", "OpName %signed_8 \"signed_8_dup\"", "OpName %signed_9 \"signed_9_dup\"", "OpName %signed_10 \"signed_10_dup\"", "OpName %signed_11 \"signed_11_dup\"", "OpName %signed_12 \"signed_12_dup\"", "OpName %signed_13 \"signed_13_dup\"", "OpName %signed_14 \"signed_14_dup\"", "OpName %signed_15 \"signed_15_dup\"", "OpName %signed_16 \"signed_16_dup\"", "OpName %signed_17 \"signed_17_dup\"", "OpName %signed_18 \"signed_18_dup\"", "OpName %signed_19 \"signed_19_dup\"", "OpName %signed_20 \"signed_20_dup\"", "OpName %signed_vec_a \"signed_vec_a_dup\"", "OpName %signed_vec_b \"signed_vec_b_dup\"", "OpName %signed_21 \"signed_21_dup\"", "OpName %signed_array \"signed_array_dup\"", "OpName %signed_22 \"signed_22_dup\"", }, }, // clang-format on }))); } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/upgrade_memory_model_test.cpp000066400000000000000000002236741475742701700262720ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "assembly_builder.h" #include "pass_fixture.h" #include "pass_utils.h" namespace { using namespace spvtools; using UpgradeMemoryModelTest = opt::PassTest<::testing::Test>; TEST_F(UpgradeMemoryModelTest, InvalidMemoryModelOpenCL) { const std::string text = R"( ; CHECK: OpMemoryModel Logical OpenCL OpCapability Kernel OpCapability Linkage OpMemoryModel Logical OpenCL )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, InvalidMemoryModelVulkan) { const std::string text = R"( ; CHECK: OpMemoryModel Logical Vulkan OpCapability Shader OpCapability Linkage OpCapability VulkanMemoryModel OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical Vulkan )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, JustMemoryModel) { const std::string text = R"( ; CHECK: OpCapability VulkanMemoryModel ; CHECK: OpExtension "SPV_KHR_vulkan_memory_model" ; CHECK: OpMemoryModel Logical Vulkan OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, RemoveDecorations) { const std::string text = R"( ; CHECK-NOT: OpDecorate OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %var Volatile OpDecorate %var Coherent %int = OpTypeInt 32 0 %ptr_int_Uniform = OpTypePointer Uniform %int %var = OpVariable %ptr_int_Uniform Uniform )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, WorkgroupVariable) { const std::string text = R"( ; CHECK: [[scope:%\w+]] = OpConstant {{%\w+}} 2 ; CHECK: OpLoad {{%\w+}} {{%\w+}} MakePointerVisible|NonPrivatePointer [[scope]] ; CHECK: OpStore {{%\w+}} {{%\w+}} MakePointerAvailable|NonPrivatePointer [[scope]] OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr_int_Workgroup = OpTypePointer Workgroup %int %var = OpVariable %ptr_int_Workgroup Workgroup %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel %ld = OpLoad %int %var OpStore %var %ld OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, WorkgroupFunctionParameter) { const std::string text = R"( ; CHECK: [[scope:%\w+]] = OpConstant {{%\w+}} 2 ; CHECK: OpLoad {{%\w+}} {{%\w+}} MakePointerVisible|NonPrivatePointer [[scope]] ; CHECK: OpStore {{%\w+}} {{%\w+}} MakePointerAvailable|NonPrivatePointer [[scope]] OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr_int_Workgroup = OpTypePointer Workgroup %int %func_ty = OpTypeFunction %void %ptr_int_Workgroup %func = OpFunction %void None %func_ty %param = OpFunctionParameter %ptr_int_Workgroup %1 = OpLabel %ld = OpLoad %int %param OpStore %param %ld OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, SimpleUniformVariable) { const std::string text = R"( ; CHECK-NOT: OpDecorate ; CHECK: [[scope:%\w+]] = OpConstant {{%\w+}} 5 ; CHECK: OpLoad {{%\w+}} {{%\w+}} Volatile|MakePointerVisible|NonPrivatePointer [[scope]] ; CHECK: OpStore {{%\w+}} {{%\w+}} Volatile|MakePointerAvailable|NonPrivatePointer [[scope]] OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %var Coherent OpDecorate %var Volatile %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr_int_Uniform = OpTypePointer Uniform %int %var = OpVariable %ptr_int_Uniform Uniform %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel %ld = OpLoad %int %var OpStore %var %ld OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, SimpleUniformFunctionParameter) { const std::string text = R"( ; CHECK-NOT: OpDecorate ; CHECK: [[scope:%\w+]] = OpConstant {{%\w+}} 5 ; CHECK: OpLoad {{%\w+}} {{%\w+}} Volatile|MakePointerVisible|NonPrivatePointer [[scope]] ; CHECK: OpStore {{%\w+}} {{%\w+}} Volatile|MakePointerAvailable|NonPrivatePointer [[scope]] OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %param Coherent OpDecorate %param Volatile %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr_int_Uniform = OpTypePointer Uniform %int %func_ty = OpTypeFunction %void %ptr_int_Uniform %func = OpFunction %void None %func_ty %param = OpFunctionParameter %ptr_int_Uniform %1 = OpLabel %ld = OpLoad %int %param OpStore %param %ld OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, SimpleUniformVariableOnlyVolatile) { const std::string text = R"( ; CHECK-NOT: OpDecorate ; CHECK-NOT: OpConstant ; CHECK: OpLoad {{%\w+}} {{%\w+}} Volatile ; CHECK: OpStore {{%\w+}} {{%\w+}} Volatile OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %var Volatile %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr_int_Uniform = OpTypePointer Uniform %int %var = OpVariable %ptr_int_Uniform Uniform %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel %ld = OpLoad %int %var OpStore %var %ld OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, SimpleUniformVariableCopied) { const std::string text = R"( ; CHECK-NOT: OpDecorate ; CHECK: [[scope:%\w+]] = OpConstant {{%\w+}} 5 ; CHECK: OpLoad {{%\w+}} {{%\w+}} Volatile|MakePointerVisible|NonPrivatePointer [[scope]] ; CHECK: OpStore {{%\w+}} {{%\w+}} Volatile|MakePointerAvailable|NonPrivatePointer [[scope]] OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %var Coherent OpDecorate %var Volatile %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr_int_Uniform = OpTypePointer Uniform %int %var = OpVariable %ptr_int_Uniform Uniform %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel %copy = OpCopyObject %ptr_int_Uniform %var %ld = OpLoad %int %copy OpStore %copy %ld OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, SimpleUniformFunctionParameterCopied) { const std::string text = R"( ; CHECK-NOT: OpDecorate ; CHECK: [[scope:%\w+]] = OpConstant {{%\w+}} 5 ; CHECK: OpLoad {{%\w+}} {{%\w+}} Volatile|MakePointerVisible|NonPrivatePointer [[scope]] ; CHECK: OpStore {{%\w+}} {{%\w+}} Volatile|MakePointerAvailable|NonPrivatePointer [[scope]] OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %param Coherent OpDecorate %param Volatile %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr_int_Uniform = OpTypePointer Uniform %int %func_ty = OpTypeFunction %void %ptr_int_Uniform %func = OpFunction %void None %func_ty %param = OpFunctionParameter %ptr_int_Uniform %1 = OpLabel %copy = OpCopyObject %ptr_int_Uniform %param %ld = OpLoad %int %copy %copy2 = OpCopyObject %ptr_int_Uniform %param OpStore %copy2 %ld OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, SimpleUniformVariableAccessChain) { const std::string text = R"( ; CHECK-NOT: OpDecorate ; CHECK: [[scope:%\w+]] = OpConstant {{%\w+}} 5 ; CHECK: OpLoad {{%\w+}} {{%\w+}} Volatile|MakePointerVisible|NonPrivatePointer [[scope]] ; CHECK: OpStore {{%\w+}} {{%\w+}} Volatile|MakePointerAvailable|NonPrivatePointer [[scope]] OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %var Coherent OpDecorate %var Volatile %void = OpTypeVoid %int = OpTypeInt 32 0 %int0 = OpConstant %int 0 %int3 = OpConstant %int 3 %int_array_3 = OpTypeArray %int %int3 %ptr_intarray_Uniform = OpTypePointer Uniform %int_array_3 %ptr_int_Uniform = OpTypePointer Uniform %int %var = OpVariable %ptr_intarray_Uniform Uniform %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel %gep = OpAccessChain %ptr_int_Uniform %var %int0 %ld = OpLoad %int %gep OpStore %gep %ld OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, SimpleUniformFunctionParameterAccessChain) { const std::string text = R"( ; CHECK-NOT: OpDecorate ; CHECK: [[scope:%\w+]] = OpConstant {{%\w+}} 5 ; CHECK: OpLoad {{%\w+}} {{%\w+}} Volatile|MakePointerVisible|NonPrivatePointer [[scope]] ; CHECK: OpStore {{%\w+}} {{%\w+}} Volatile|MakePointerAvailable|NonPrivatePointer [[scope]] OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %param Coherent OpDecorate %param Volatile %void = OpTypeVoid %int = OpTypeInt 32 0 %int0 = OpConstant %int 0 %int3 = OpConstant %int 3 %int_array_3 = OpTypeArray %int %int3 %ptr_intarray_Uniform = OpTypePointer Uniform %int_array_3 %ptr_int_Uniform = OpTypePointer Uniform %int %func_ty = OpTypeFunction %void %ptr_intarray_Uniform %func = OpFunction %void None %func_ty %param = OpFunctionParameter %ptr_intarray_Uniform %1 = OpLabel %ld_gep = OpAccessChain %ptr_int_Uniform %param %int0 %ld = OpLoad %int %ld_gep %st_gep = OpAccessChain %ptr_int_Uniform %param %int0 OpStore %st_gep %ld OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, VariablePointerSelect) { const std::string text = R"( ; CHECK-NOT: OpDecorate ; CHECK: [[scope:%\w+]] = OpConstant {{%\w+}} 5 ; CHECK: OpLoad {{%\w+}} {{%\w+}} Volatile|MakePointerVisible|NonPrivatePointer [[scope]] ; CHECK: OpStore {{%\w+}} {{%\w+}} Volatile|MakePointerAvailable|NonPrivatePointer [[scope]] OpCapability Shader OpCapability Linkage OpCapability VariablePointers OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 OpDecorate %var Coherent OpDecorate %var Volatile %void = OpTypeVoid %int = OpTypeInt 32 0 %bool = OpTypeBool %true = OpConstantTrue %bool %ptr_int_StorageBuffer = OpTypePointer StorageBuffer %int %null = OpConstantNull %ptr_int_StorageBuffer %var = OpVariable %ptr_int_StorageBuffer StorageBuffer %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel %select = OpSelect %ptr_int_StorageBuffer %true %var %null %ld = OpLoad %int %select OpStore %var %ld OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, VariablePointerSelectConservative) { const std::string text = R"( ; CHECK-NOT: OpDecorate ; CHECK: [[scope:%\w+]] = OpConstant {{%\w+}} 5 ; CHECK: OpLoad {{%\w+}} {{%\w+}} Volatile|MakePointerVisible|NonPrivatePointer [[scope]] ; CHECK: OpStore {{%\w+}} {{%\w+}} Volatile|MakePointerAvailable|NonPrivatePointer [[scope]] OpCapability Shader OpCapability Linkage OpCapability VariablePointers OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 OpDecorate %var1 Coherent OpDecorate %var2 Volatile %void = OpTypeVoid %int = OpTypeInt 32 0 %bool = OpTypeBool %true = OpConstantTrue %bool %ptr_int_StorageBuffer = OpTypePointer StorageBuffer %int %var1 = OpVariable %ptr_int_StorageBuffer StorageBuffer %var2 = OpVariable %ptr_int_StorageBuffer StorageBuffer %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel %select = OpSelect %ptr_int_StorageBuffer %true %var1 %var2 %ld = OpLoad %int %select OpStore %select %ld OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, VariablePointerIncrement) { const std::string text = R"( ; CHECK-NOT: OpDecorate {{%\w+}} Coherent ; CHECK: [[scope:%\w+]] = OpConstant {{%\w+}} 5 ; CHECK: OpLoad {{%\w+}} {{%\w+}} MakePointerVisible|NonPrivatePointer [[scope]] ; CHECK: OpStore {{%\w+}} {{%\w+}} MakePointerAvailable|NonPrivatePointer [[scope]] OpCapability Shader OpCapability Linkage OpCapability VariablePointers OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 OpDecorate %param Coherent OpDecorate %ptr_int_StorageBuffer ArrayStride 4 %void = OpTypeVoid %bool = OpTypeBool %int = OpTypeInt 32 0 %int0 = OpConstant %int 0 %int1 = OpConstant %int 1 %int10 = OpConstant %int 10 %ptr_int_StorageBuffer = OpTypePointer StorageBuffer %int %func_ty = OpTypeFunction %void %ptr_int_StorageBuffer %func = OpFunction %void None %func_ty %param = OpFunctionParameter %ptr_int_StorageBuffer %1 = OpLabel OpBranch %2 %2 = OpLabel %phi = OpPhi %ptr_int_StorageBuffer %param %1 %ptr_next %2 %iv = OpPhi %int %int0 %1 %inc %2 %inc = OpIAdd %int %iv %int1 %ptr_next = OpPtrAccessChain %ptr_int_StorageBuffer %phi %int1 %cmp = OpIEqual %bool %iv %int10 OpLoopMerge %3 %2 None OpBranchConditional %cmp %3 %2 %3 = OpLabel %ld = OpLoad %int %phi OpStore %phi %ld OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, CoherentStructElement) { const std::string text = R"( ; CHECK-NOT: OpMemberDecorate ; CHECK: [[scope:%\w+]] = OpConstant {{%\w+}} 5 ; CHECK: OpLoad {{%\w+}} {{%\w+}} MakePointerVisible|NonPrivatePointer [[scope]] ; CHECK: OpStore {{%\w+}} {{%\w+}} MakePointerAvailable|NonPrivatePointer [[scope]] OpCapability Shader OpCapability Linkage OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpMemberDecorate %struct 0 Coherent %void = OpTypeVoid %int = OpTypeInt 32 0 %int0 = OpConstant %int 0 %struct = OpTypeStruct %int %ptr_struct_StorageBuffer = OpTypePointer StorageBuffer %struct %ptr_int_StorageBuffer = OpTypePointer StorageBuffer %int %func_ty = OpTypeFunction %void %ptr_struct_StorageBuffer %func = OpFunction %void None %func_ty %param = OpFunctionParameter %ptr_struct_StorageBuffer %1 = OpLabel %gep = OpAccessChain %ptr_int_StorageBuffer %param %int0 %ld = OpLoad %int %gep OpStore %gep %ld OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, CoherentElementFullStructAccess) { const std::string text = R"( ; CHECK-NOT: OpMemberDecorate ; CHECK: [[scope:%\w+]] = OpConstant {{%\w+}} 5 ; CHECK: OpLoad {{%\w+}} {{%\w+}} MakePointerVisible|NonPrivatePointer [[scope]] ; CHECK: OpStore {{%\w+}} {{%\w+}} MakePointerAvailable|NonPrivatePointer [[scope]] OpCapability Shader OpCapability Linkage OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpMemberDecorate %struct 0 Coherent %void = OpTypeVoid %int = OpTypeInt 32 0 %struct = OpTypeStruct %int %ptr_struct_StorageBuffer = OpTypePointer StorageBuffer %struct %func_ty = OpTypeFunction %void %ptr_struct_StorageBuffer %func = OpFunction %void None %func_ty %param = OpFunctionParameter %ptr_struct_StorageBuffer %1 = OpLabel %ld = OpLoad %struct %param OpStore %param %ld OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, CoherentElementNotAccessed) { const std::string text = R"( ; CHECK-NOT: OpMemberDecorate ; CHECK-NOT: MakePointerAvailable ; CHECK-NOT: NonPrivatePointer ; CHECK-NOT: MakePointerVisible OpCapability Shader OpCapability Linkage OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpMemberDecorate %struct 1 Coherent %void = OpTypeVoid %int = OpTypeInt 32 0 %int0 = OpConstant %int 0 %struct = OpTypeStruct %int %int %ptr_struct_StorageBuffer = OpTypePointer StorageBuffer %struct %ptr_int_StorageBuffer = OpTypePointer StorageBuffer %int %func_ty = OpTypeFunction %void %ptr_struct_StorageBuffer %func = OpFunction %void None %func_ty %param = OpFunctionParameter %ptr_struct_StorageBuffer %1 = OpLabel %gep = OpAccessChain %ptr_int_StorageBuffer %param %int0 %ld = OpLoad %int %gep OpStore %gep %ld OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, MultiIndexAccessCoherent) { const std::string text = R"( ; CHECK-NOT: OpMemberDecorate ; CHECK: [[scope:%\w+]] = OpConstant {{%\w+}} 5 ; CHECK: OpLoad {{%\w+}} {{%\w+}} MakePointerVisible|NonPrivatePointer [[scope]] ; CHECK: OpStore {{%\w+}} {{%\w+}} MakePointerAvailable|NonPrivatePointer [[scope]] OpCapability Shader OpCapability Linkage OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpMemberDecorate %inner 1 Coherent %void = OpTypeVoid %int = OpTypeInt 32 0 %int0 = OpConstant %int 0 %int1 = OpConstant %int 1 %inner = OpTypeStruct %int %int %middle = OpTypeStruct %inner %outer = OpTypeStruct %middle %middle %ptr_outer_StorageBuffer = OpTypePointer StorageBuffer %outer %ptr_int_StorageBuffer = OpTypePointer StorageBuffer %int %func_ty = OpTypeFunction %void %ptr_outer_StorageBuffer %func = OpFunction %void None %func_ty %param = OpFunctionParameter %ptr_outer_StorageBuffer %1 = OpLabel %ld_gep = OpInBoundsAccessChain %ptr_int_StorageBuffer %param %int0 %int0 %int1 %ld = OpLoad %int %ld_gep %st_gep = OpInBoundsAccessChain %ptr_int_StorageBuffer %param %int1 %int0 %int1 OpStore %st_gep %ld OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, MultiIndexAccessNonCoherent) { const std::string text = R"( ; CHECK-NOT: OpMemberDecorate ; CHECK-NOT: MakePointerAvailable ; CHECK-NOT: NonPrivatePointer ; CHECK-NOT: MakePointerVisible OpCapability Shader OpCapability Linkage OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpMemberDecorate %inner 1 Coherent %void = OpTypeVoid %int = OpTypeInt 32 0 %int0 = OpConstant %int 0 %int1 = OpConstant %int 1 %inner = OpTypeStruct %int %int %middle = OpTypeStruct %inner %outer = OpTypeStruct %middle %middle %ptr_outer_StorageBuffer = OpTypePointer StorageBuffer %outer %ptr_int_StorageBuffer = OpTypePointer StorageBuffer %int %func_ty = OpTypeFunction %void %ptr_outer_StorageBuffer %func = OpFunction %void None %func_ty %param = OpFunctionParameter %ptr_outer_StorageBuffer %1 = OpLabel %ld_gep = OpInBoundsAccessChain %ptr_int_StorageBuffer %param %int0 %int0 %int0 %ld = OpLoad %int %ld_gep %st_gep = OpInBoundsAccessChain %ptr_int_StorageBuffer %param %int1 %int0 %int0 OpStore %st_gep %ld OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, ConsecutiveAccessChainCoherent) { const std::string text = R"( ; CHECK-NOT: OpMemberDecorate ; CHECK: [[scope:%\w+]] = OpConstant {{%\w+}} 5 ; CHECK: OpLoad {{%\w+}} {{%\w+}} MakePointerVisible|NonPrivatePointer [[scope]] ; CHECK: OpStore {{%\w+}} {{%\w+}} MakePointerAvailable|NonPrivatePointer [[scope]] OpCapability Shader OpCapability Linkage OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpMemberDecorate %inner 1 Coherent %void = OpTypeVoid %int = OpTypeInt 32 0 %int0 = OpConstant %int 0 %int1 = OpConstant %int 1 %inner = OpTypeStruct %int %int %middle = OpTypeStruct %inner %outer = OpTypeStruct %middle %middle %ptr_outer_StorageBuffer = OpTypePointer StorageBuffer %outer %ptr_middle_StorageBuffer = OpTypePointer StorageBuffer %middle %ptr_inner_StorageBuffer = OpTypePointer StorageBuffer %inner %ptr_int_StorageBuffer = OpTypePointer StorageBuffer %int %func_ty = OpTypeFunction %void %ptr_outer_StorageBuffer %func = OpFunction %void None %func_ty %param = OpFunctionParameter %ptr_outer_StorageBuffer %1 = OpLabel %ld_gep1 = OpInBoundsAccessChain %ptr_middle_StorageBuffer %param %int0 %ld_gep2 = OpInBoundsAccessChain %ptr_inner_StorageBuffer %ld_gep1 %int0 %ld_gep3 = OpInBoundsAccessChain %ptr_int_StorageBuffer %ld_gep2 %int1 %ld = OpLoad %int %ld_gep3 %st_gep1 = OpInBoundsAccessChain %ptr_middle_StorageBuffer %param %int1 %st_gep2 = OpInBoundsAccessChain %ptr_inner_StorageBuffer %st_gep1 %int0 %st_gep3 = OpInBoundsAccessChain %ptr_int_StorageBuffer %st_gep2 %int1 OpStore %st_gep3 %ld OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, ConsecutiveAccessChainNonCoherent) { const std::string text = R"( ; CHECK-NOT: OpMemberDecorate ; CHECK-NOT: MakePointerAvailable ; CHECK-NOT: NonPrivatePointer ; CHECK-NOT: MakePointerVisible OpCapability Shader OpCapability Linkage OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpMemberDecorate %inner 1 Coherent %void = OpTypeVoid %int = OpTypeInt 32 0 %int0 = OpConstant %int 0 %int1 = OpConstant %int 1 %inner = OpTypeStruct %int %int %middle = OpTypeStruct %inner %outer = OpTypeStruct %middle %middle %ptr_outer_StorageBuffer = OpTypePointer StorageBuffer %outer %ptr_middle_StorageBuffer = OpTypePointer StorageBuffer %middle %ptr_inner_StorageBuffer = OpTypePointer StorageBuffer %inner %ptr_int_StorageBuffer = OpTypePointer StorageBuffer %int %func_ty = OpTypeFunction %void %ptr_outer_StorageBuffer %func = OpFunction %void None %func_ty %param = OpFunctionParameter %ptr_outer_StorageBuffer %1 = OpLabel %ld_gep1 = OpInBoundsAccessChain %ptr_middle_StorageBuffer %param %int0 %ld_gep2 = OpInBoundsAccessChain %ptr_inner_StorageBuffer %ld_gep1 %int0 %ld_gep3 = OpInBoundsAccessChain %ptr_int_StorageBuffer %ld_gep2 %int0 %ld = OpLoad %int %ld_gep3 %st_gep1 = OpInBoundsAccessChain %ptr_middle_StorageBuffer %param %int1 %st_gep2 = OpInBoundsAccessChain %ptr_inner_StorageBuffer %st_gep1 %int0 %st_gep3 = OpInBoundsAccessChain %ptr_int_StorageBuffer %st_gep2 %int0 OpStore %st_gep3 %ld OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, CoherentStructElementAccess) { const std::string text = R"( ; CHECK-NOT: OpMemberDecorate ; CHECK: [[scope:%\w+]] = OpConstant {{%\w+}} 5 ; CHECK: OpLoad {{%\w+}} {{%\w+}} MakePointerVisible|NonPrivatePointer [[scope]] ; CHECK: OpStore {{%\w+}} {{%\w+}} MakePointerAvailable|NonPrivatePointer [[scope]] OpCapability Shader OpCapability Linkage OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpMemberDecorate %middle 0 Coherent %void = OpTypeVoid %int = OpTypeInt 32 0 %int0 = OpConstant %int 0 %int1 = OpConstant %int 1 %inner = OpTypeStruct %int %int %middle = OpTypeStruct %inner %outer = OpTypeStruct %middle %middle %ptr_outer_StorageBuffer = OpTypePointer StorageBuffer %outer %ptr_middle_StorageBuffer = OpTypePointer StorageBuffer %middle %ptr_inner_StorageBuffer = OpTypePointer StorageBuffer %inner %ptr_int_StorageBuffer = OpTypePointer StorageBuffer %int %func_ty = OpTypeFunction %void %ptr_outer_StorageBuffer %func = OpFunction %void None %func_ty %param = OpFunctionParameter %ptr_outer_StorageBuffer %1 = OpLabel %ld_gep1 = OpInBoundsAccessChain %ptr_middle_StorageBuffer %param %int0 %ld_gep2 = OpInBoundsAccessChain %ptr_inner_StorageBuffer %ld_gep1 %int0 %ld_gep3 = OpInBoundsAccessChain %ptr_int_StorageBuffer %ld_gep2 %int1 %ld = OpLoad %int %ld_gep3 %st_gep1 = OpInBoundsAccessChain %ptr_middle_StorageBuffer %param %int1 %st_gep2 = OpInBoundsAccessChain %ptr_inner_StorageBuffer %st_gep1 %int0 %st_gep3 = OpInBoundsAccessChain %ptr_int_StorageBuffer %st_gep2 %int1 OpStore %st_gep3 %ld OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, NonCoherentLoadCoherentStore) { const std::string text = R"( ; CHECK-NOT: OpMemberDecorate ; CHECK: [[scope:%\w+]] = OpConstant {{%\w+}} 5 ; CHECK-NOT: MakePointerVisible ; CHECK: OpStore {{%\w+}} {{%\w+}} MakePointerAvailable|NonPrivatePointer [[scope]] OpCapability Shader OpCapability Linkage OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpMemberDecorate %outer 1 Coherent %void = OpTypeVoid %int = OpTypeInt 32 0 %int0 = OpConstant %int 0 %int1 = OpConstant %int 1 %inner = OpTypeStruct %int %int %middle = OpTypeStruct %inner %outer = OpTypeStruct %middle %middle %ptr_outer_StorageBuffer = OpTypePointer StorageBuffer %outer %ptr_middle_StorageBuffer = OpTypePointer StorageBuffer %middle %ptr_inner_StorageBuffer = OpTypePointer StorageBuffer %inner %ptr_int_StorageBuffer = OpTypePointer StorageBuffer %int %func_ty = OpTypeFunction %void %ptr_outer_StorageBuffer %func = OpFunction %void None %func_ty %param = OpFunctionParameter %ptr_outer_StorageBuffer %1 = OpLabel %ld_gep1 = OpInBoundsAccessChain %ptr_middle_StorageBuffer %param %int0 %ld_gep2 = OpInBoundsAccessChain %ptr_inner_StorageBuffer %ld_gep1 %int0 %ld_gep3 = OpInBoundsAccessChain %ptr_int_StorageBuffer %ld_gep2 %int1 %ld = OpLoad %int %ld_gep3 %st_gep1 = OpInBoundsAccessChain %ptr_middle_StorageBuffer %param %int1 %st_gep2 = OpInBoundsAccessChain %ptr_inner_StorageBuffer %st_gep1 %int0 %st_gep3 = OpInBoundsAccessChain %ptr_int_StorageBuffer %st_gep2 %int1 OpStore %st_gep3 %ld OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, CopyMemory) { const std::string text = R"( ; CHECK-NOT: OpDecorate ; CHECK: [[queuefamily:%\w+]] = OpConstant {{%\w+}} 5 ; CHECK: OpCopyMemory {{%\w+}} {{%\w+}} Volatile|MakePointerVisible|NonPrivatePointer [[queuefamily]] ; CHECK-NOT: [[queuefamily]] OpCapability Shader OpCapability Linkage OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpDecorate %in_var Coherent OpDecorate %out_var Volatile %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr_int_StorageBuffer = OpTypePointer StorageBuffer %int %in_var = OpVariable %ptr_int_StorageBuffer StorageBuffer %out_var = OpVariable %ptr_int_StorageBuffer StorageBuffer %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel OpCopyMemory %out_var %in_var OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, CopyMemorySized) { const std::string text = R"( ; CHECK-NOT: OpDecorate ; CHECK: [[queuefamily:%\w+]] = OpConstant {{%\w+}} 5 ; CHECK: OpCopyMemorySized {{%\w+}} {{%\w+}} {{%\w+}} Volatile|MakePointerAvailable|NonPrivatePointer [[queuefamily]] ; CHECK-NOT: [[queuefamily]] OpCapability Shader OpCapability Linkage OpCapability Addresses OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpDecorate %out_param Coherent OpDecorate %in_param Volatile %void = OpTypeVoid %int = OpTypeInt 32 0 %int4 = OpConstant %int 4 %ptr_int_StorageBuffer = OpTypePointer StorageBuffer %int %func_ty = OpTypeFunction %void %ptr_int_StorageBuffer %ptr_int_StorageBuffer %func = OpFunction %void None %func_ty %in_param = OpFunctionParameter %ptr_int_StorageBuffer %out_param = OpFunctionParameter %ptr_int_StorageBuffer %1 = OpLabel OpCopyMemorySized %out_param %in_param %int4 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, CopyMemoryTwoScopes) { const std::string text = R"( ; CHECK-NOT: OpDecorate ; CHECK-DAG: [[queuefamily:%\w+]] = OpConstant {{%\w+}} 5 ; CHECK-DAG: [[workgroup:%\w+]] = OpConstant {{%\w+}} 2 ; CHECK: OpCopyMemory {{%\w+}} {{%\w+}} MakePointerAvailable|MakePointerVisible|NonPrivatePointer [[workgroup]] [[queuefamily]] OpCapability Shader OpCapability Linkage OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpDecorate %in_var Coherent OpDecorate %out_var Coherent %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr_int_Workgroup = OpTypePointer Workgroup %int %ptr_int_StorageBuffer = OpTypePointer StorageBuffer %int %in_var = OpVariable %ptr_int_StorageBuffer StorageBuffer %out_var = OpVariable %ptr_int_Workgroup Workgroup %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel OpCopyMemory %out_var %in_var OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, VolatileImageRead) { const std::string text = R"( ; CHECK-NOT: OpDecorate ; CHECK: OpLoad {{%\w+}} {{%\w+}} Volatile ; CHECK: OpImageRead {{%\w+}} {{%\w+}} {{%\w+}} VolatileTexel OpCapability Shader OpCapability Linkage OpCapability StorageImageReadWithoutFormat OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpDecorate %var Volatile %void = OpTypeVoid %int = OpTypeInt 32 0 %v2int = OpTypeVector %int 2 %float = OpTypeFloat 32 %int0 = OpConstant %int 0 %v2int_0 = OpConstantComposite %v2int %int0 %int0 %image = OpTypeImage %float 2D 0 0 0 2 Unknown %ptr_image_StorageBuffer = OpTypePointer StorageBuffer %image %var = OpVariable %ptr_image_StorageBuffer StorageBuffer %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel %ld = OpLoad %image %var %rd = OpImageRead %float %ld %v2int_0 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, CoherentImageRead) { const std::string text = R"( ; CHECK-NOT: OpDecorate ; CHECK: [[scope:%\w+]] = OpConstant {{%\w+}} 5 ; CHECK: OpLoad {{%\w+}} {{%\w+}} MakePointerVisible|NonPrivatePointer [[scope]] ; CHECK: OpImageRead {{%\w+}} {{%\w+}} {{%\w+}} MakeTexelVisible|NonPrivateTexel [[scope]] OpCapability Shader OpCapability Linkage OpCapability StorageImageReadWithoutFormat OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpDecorate %var Coherent %void = OpTypeVoid %int = OpTypeInt 32 0 %v2int = OpTypeVector %int 2 %float = OpTypeFloat 32 %int0 = OpConstant %int 0 %v2int_0 = OpConstantComposite %v2int %int0 %int0 %image = OpTypeImage %float 2D 0 0 0 2 Unknown %ptr_image_StorageBuffer = OpTypePointer StorageBuffer %image %var = OpVariable %ptr_image_StorageBuffer StorageBuffer %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel %ld = OpLoad %image %var %rd = OpImageRead %float %ld %v2int_0 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, CoherentImageReadExtractedFromSampledImage) { const std::string text = R"( ; CHECK-NOT: OpDecorate ; CHECK: [[image:%\w+]] = OpTypeImage ; CHECK: [[scope:%\w+]] = OpConstant {{%\w+}} 5 ; CHECK: OpLoad [[image]] {{%\w+}} MakePointerVisible|NonPrivatePointer [[scope]] ; CHECK-NOT: NonPrivatePointer ; CHECK: OpImageRead {{%\w+}} {{%\w+}} {{%\w+}} MakeTexelVisible|NonPrivateTexel [[scope]] OpCapability Shader OpCapability Linkage OpCapability StorageImageReadWithoutFormat OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpDecorate %var Coherent %void = OpTypeVoid %int = OpTypeInt 32 0 %v2int = OpTypeVector %int 2 %float = OpTypeFloat 32 %int0 = OpConstant %int 0 %v2int_0 = OpConstantComposite %v2int %int0 %int0 %image = OpTypeImage %float 2D 0 0 0 0 Unknown %sampled_image = OpTypeSampledImage %image %sampler = OpTypeSampler %ptr_image_StorageBuffer = OpTypePointer StorageBuffer %image %ptr_sampler_StorageBuffer = OpTypePointer StorageBuffer %sampler %var = OpVariable %ptr_image_StorageBuffer StorageBuffer %sampler_var = OpVariable %ptr_sampler_StorageBuffer StorageBuffer %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel %ld = OpLoad %image %var %ld_sampler = OpLoad %sampler %sampler_var %sample = OpSampledImage %sampled_image %ld %ld_sampler %extract = OpImage %image %sample %rd = OpImageRead %float %extract %v2int_0 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, VolatileImageWrite) { const std::string text = R"( ; CHECK-NOT: OpDecorate ; CHECK: OpLoad {{%\w+}} {{%\w+}} Volatile ; CHECK: OpImageWrite {{%\w+}} {{%\w+}} {{%\w+}} VolatileTexel OpCapability Shader OpCapability Linkage OpCapability StorageImageWriteWithoutFormat OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpDecorate %param Volatile %void = OpTypeVoid %int = OpTypeInt 32 0 %v2int = OpTypeVector %int 2 %float = OpTypeFloat 32 %float0 = OpConstant %float 0 %v2int_null = OpConstantNull %v2int %image = OpTypeImage %float 2D 0 0 0 0 Unknown %ptr_image_StorageBuffer = OpTypePointer StorageBuffer %image %func_ty = OpTypeFunction %void %ptr_image_StorageBuffer %func = OpFunction %void None %func_ty %param = OpFunctionParameter %ptr_image_StorageBuffer %1 = OpLabel %ld = OpLoad %image %param OpImageWrite %ld %v2int_null %float0 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, CoherentImageWrite) { const std::string text = R"( ; CHECK-NOT: OpDecorate ; CHECK: [[scope:%\w+]] = OpConstant {{%\w+}} 5 ; CHECK: OpLoad {{%\w+}} {{%\w+}} MakePointerVisible|NonPrivatePointer ; CHECK: OpImageWrite {{%\w+}} {{%\w+}} {{%\w+}} MakeTexelAvailable|NonPrivateTexel [[scope]] OpCapability Shader OpCapability Linkage OpCapability StorageImageWriteWithoutFormat OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpDecorate %param Coherent %void = OpTypeVoid %int = OpTypeInt 32 0 %v2int = OpTypeVector %int 2 %float = OpTypeFloat 32 %float0 = OpConstant %float 0 %v2int_null = OpConstantNull %v2int %image = OpTypeImage %float 2D 0 0 0 0 Unknown %ptr_image_StorageBuffer = OpTypePointer StorageBuffer %image %func_ty = OpTypeFunction %void %ptr_image_StorageBuffer %func = OpFunction %void None %func_ty %param = OpFunctionParameter %ptr_image_StorageBuffer %1 = OpLabel %ld = OpLoad %image %param OpImageWrite %ld %v2int_null %float0 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, CoherentImageWriteExtractFromSampledImage) { const std::string text = R"( ; CHECK-NOT: OpDecorate ; CHECK: [[scope:%\w+]] = OpConstant {{%\w+}} 5 ; CHECK: OpLoad {{%\w+}} {{%\w+}} MakePointerVisible|NonPrivatePointer ; CHECK-NOT: NonPrivatePointer ; CHECK: OpImageWrite {{%\w+}} {{%\w+}} {{%\w+}} MakeTexelAvailable|NonPrivateTexel [[scope]] OpCapability Shader OpCapability Linkage OpCapability StorageImageWriteWithoutFormat OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpDecorate %param Coherent %void = OpTypeVoid %int = OpTypeInt 32 0 %v2int = OpTypeVector %int 2 %float = OpTypeFloat 32 %float0 = OpConstant %float 0 %v2int_null = OpConstantNull %v2int %image = OpTypeImage %float 2D 0 0 0 0 Unknown %sampled_image = OpTypeSampledImage %image %sampler = OpTypeSampler %ptr_image_StorageBuffer = OpTypePointer StorageBuffer %image %ptr_sampler_StorageBuffer = OpTypePointer StorageBuffer %sampler %func_ty = OpTypeFunction %void %ptr_image_StorageBuffer %ptr_sampler_StorageBuffer %func = OpFunction %void None %func_ty %param = OpFunctionParameter %ptr_image_StorageBuffer %sampler_param = OpFunctionParameter %ptr_sampler_StorageBuffer %1 = OpLabel %ld = OpLoad %image %param %ld_sampler = OpLoad %sampler %sampler_param %sample = OpSampledImage %sampled_image %ld %ld_sampler %extract = OpImage %image %sample OpImageWrite %extract %v2int_null %float0 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, VolatileImageSparseRead) { const std::string text = R"( ; CHECK-NOT: OpDecorate ; CHECK: OpLoad {{%\w+}} {{%\w+}} Volatile ; CHECK: OpImageSparseRead {{%\w+}} {{%\w+}} {{%\w+}} VolatileTexel OpCapability Shader OpCapability Linkage OpCapability StorageImageReadWithoutFormat OpCapability SparseResidency OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpDecorate %var Volatile %void = OpTypeVoid %int = OpTypeInt 32 0 %v2int = OpTypeVector %int 2 %float = OpTypeFloat 32 %int0 = OpConstant %int 0 %v2int_0 = OpConstantComposite %v2int %int0 %int0 %image = OpTypeImage %float 2D 0 0 0 2 Unknown %struct = OpTypeStruct %int %float %ptr_image_StorageBuffer = OpTypePointer StorageBuffer %image %var = OpVariable %ptr_image_StorageBuffer StorageBuffer %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel %ld = OpLoad %image %var %rd = OpImageSparseRead %struct %ld %v2int_0 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, CoherentImageSparseRead) { const std::string text = R"( ; CHECK-NOT: OpDecorate ; CHECK: [[scope:%\w+]] = OpConstant {{%\w+}} 5 ; CHECK: OpLoad {{%\w+}} {{%\w+}} MakePointerVisible|NonPrivatePointer [[scope]] ; CHECK: OpImageSparseRead {{%\w+}} {{%\w+}} {{%\w+}} MakeTexelVisible|NonPrivateTexel [[scope]] OpCapability Shader OpCapability Linkage OpCapability StorageImageReadWithoutFormat OpCapability SparseResidency OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpDecorate %var Coherent %void = OpTypeVoid %int = OpTypeInt 32 0 %v2int = OpTypeVector %int 2 %float = OpTypeFloat 32 %int0 = OpConstant %int 0 %v2int_0 = OpConstantComposite %v2int %int0 %int0 %image = OpTypeImage %float 2D 0 0 0 2 Unknown %struct = OpTypeStruct %int %float %ptr_image_StorageBuffer = OpTypePointer StorageBuffer %image %var = OpVariable %ptr_image_StorageBuffer StorageBuffer %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel %ld = OpLoad %image %var %rd = OpImageSparseRead %struct %ld %v2int_0 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, CoherentImageSparseReadExtractedFromSampledImage) { const std::string text = R"( ; CHECK-NOT: OpDecorate ; CHECK: [[image:%\w+]] = OpTypeImage ; CHECK: [[scope:%\w+]] = OpConstant {{%\w+}} 5 ; CHECK: OpLoad [[image]] {{%\w+}} MakePointerVisible|NonPrivatePointer [[scope]] ; CHECK-NOT: NonPrivatePointer ; CHECK: OpImageSparseRead {{%\w+}} {{%\w+}} {{%\w+}} MakeTexelVisible|NonPrivateTexel [[scope]] OpCapability Shader OpCapability Linkage OpCapability StorageImageReadWithoutFormat OpCapability SparseResidency OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpDecorate %var Coherent %void = OpTypeVoid %int = OpTypeInt 32 0 %v2int = OpTypeVector %int 2 %float = OpTypeFloat 32 %int0 = OpConstant %int 0 %v2int_0 = OpConstantComposite %v2int %int0 %int0 %image = OpTypeImage %float 2D 0 0 0 0 Unknown %struct = OpTypeStruct %int %float %sampled_image = OpTypeSampledImage %image %sampler = OpTypeSampler %ptr_image_StorageBuffer = OpTypePointer StorageBuffer %image %ptr_sampler_StorageBuffer = OpTypePointer StorageBuffer %sampler %var = OpVariable %ptr_image_StorageBuffer StorageBuffer %sampler_var = OpVariable %ptr_sampler_StorageBuffer StorageBuffer %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel %ld = OpLoad %image %var %ld_sampler = OpLoad %sampler %sampler_var %sample = OpSampledImage %sampled_image %ld %ld_sampler %extract = OpImage %image %sample %rd = OpImageSparseRead %struct %extract %v2int_0 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, TessellationControlBarrierNoChange) { const std::string text = R"( ; CHECK: [[none:%\w+]] = OpConstant {{%\w+}} 0 ; CHECK: [[workgroup:%\w+]] = OpConstant {{%\w+}} 2 ; CHECK: OpControlBarrier [[workgroup]] [[workgroup]] [[none]] OpCapability Tessellation OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %func "func" %void = OpTypeVoid %int = OpTypeInt 32 0 %none = OpConstant %int 0 %workgroup = OpConstant %int 2 %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel OpControlBarrier %workgroup %workgroup %none OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, TessellationControlBarrierAddOutput) { const std::string text = R"( ; CHECK: [[workgroup:%\w+]] = OpConstant {{%\w+}} 2 ; CHECK: [[output:%\w+]] = OpConstant {{%\w+}} 4096 ; CHECK: OpControlBarrier [[workgroup]] [[workgroup]] [[output]] OpCapability Tessellation OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %func "func" %var %void = OpTypeVoid %int = OpTypeInt 32 0 %none = OpConstant %int 0 %workgroup = OpConstant %int 2 %ptr_int_Output = OpTypePointer Output %int %var = OpVariable %ptr_int_Output Output %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel %ld = OpLoad %int %var OpControlBarrier %workgroup %workgroup %none OpStore %var %ld OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, TessellationMemoryBarrierNoChange) { const std::string text = R"( ; CHECK: [[none:%\w+]] = OpConstant {{%\w+}} 0 ; CHECK: [[workgroup:%\w+]] = OpConstant {{%\w+}} 2 ; CHECK: OpMemoryBarrier [[workgroup]] [[none]] OpCapability Tessellation OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %func "func" %var %void = OpTypeVoid %int = OpTypeInt 32 0 %none = OpConstant %int 0 %workgroup = OpConstant %int 2 %ptr_int_Output = OpTypePointer Output %int %var = OpVariable %ptr_int_Output Output %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel %ld = OpLoad %int %var OpMemoryBarrier %workgroup %none OpStore %var %ld OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, TessellationControlBarrierAddOutputSubFunction) { const std::string text = R"( ; CHECK: [[workgroup:%\w+]] = OpConstant {{%\w+}} 2 ; CHECK: [[output:%\w+]] = OpConstant {{%\w+}} 4096 ; CHECK: OpControlBarrier [[workgroup]] [[workgroup]] [[output]] OpCapability Tessellation OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %func "func" %var %void = OpTypeVoid %int = OpTypeInt 32 0 %none = OpConstant %int 0 %workgroup = OpConstant %int 2 %ptr_int_Output = OpTypePointer Output %int %var = OpVariable %ptr_int_Output Output %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel %call = OpFunctionCall %void %sub_func OpReturn OpFunctionEnd %sub_func = OpFunction %void None %func_ty %2 = OpLabel %ld = OpLoad %int %var OpControlBarrier %workgroup %workgroup %none OpStore %var %ld OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, TessellationControlBarrierAddOutputDifferentFunctions) { const std::string text = R"( ; CHECK: [[workgroup:%\w+]] = OpConstant {{%\w+}} 2 ; CHECK: [[output:%\w+]] = OpConstant {{%\w+}} 4096 ; CHECK: OpControlBarrier [[workgroup]] [[workgroup]] [[output]] OpCapability Tessellation OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %func "func" %var %void = OpTypeVoid %int = OpTypeInt 32 0 %none = OpConstant %int 0 %workgroup = OpConstant %int 2 %ptr_int_Output = OpTypePointer Output %int %var = OpVariable %ptr_int_Output Output %func_ty = OpTypeFunction %void %ld_func_ty = OpTypeFunction %int %st_func_ty = OpTypeFunction %void %int %func = OpFunction %void None %func_ty %1 = OpLabel %call_ld = OpFunctionCall %int %ld_func %call_barrier = OpFunctionCall %void %barrier_func %call_st = OpFunctionCall %void %st_func %call_ld OpReturn OpFunctionEnd %ld_func = OpFunction %int None %ld_func_ty %2 = OpLabel %ld = OpLoad %int %var OpReturnValue %ld OpFunctionEnd %barrier_func = OpFunction %void None %func_ty %3 = OpLabel OpControlBarrier %workgroup %workgroup %none OpReturn OpFunctionEnd %st_func = OpFunction %void None %st_func_ty %param = OpFunctionParameter %int %4 = OpLabel OpStore %var %param OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, ChangeControlBarrierMemoryScope) { std::string text = R"( ; CHECK: [[workgroup:%\w+]] = OpConstant {{%\w+}} 2 ; CHECK: [[queuefamily:%\w+]] = OpConstant {{%\w+}} 5 ; CHECK: OpControlBarrier [[workgroup]] [[queuefamily]] OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %func "func" %void = OpTypeVoid %int = OpTypeInt 32 0 %none = OpConstant %int 0 %device = OpConstant %int 1 %workgroup = OpConstant %int 2 %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel OpControlBarrier %workgroup %device %none OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, ChangeMemoryBarrierMemoryScope) { std::string text = R"( ; CHECK: [[queuefamily:%\w+]] = OpConstant {{%\w+}} 5 ; CHECK: OpMemoryBarrier [[queuefamily]] OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %func "func" %void = OpTypeVoid %int = OpTypeInt 32 0 %none = OpConstant %int 0 %device = OpConstant %int 1 %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel OpMemoryBarrier %device %none OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, ChangeAtomicMemoryScope) { std::string text = R"( ; CHECK: [[int:%\w+]] = OpTypeInt ; CHECK: [[var:%\w+]] = OpVariable ; CHECK: [[qf:%\w+]] = OpConstant [[int]] 5 ; CHECK: OpAtomicLoad [[int]] [[var]] [[qf]] ; CHECK: OpAtomicStore [[var]] [[qf]] ; CHECK: OpAtomicExchange [[int]] [[var]] [[qf]] ; CHECK: OpAtomicCompareExchange [[int]] [[var]] [[qf]] ; CHECK: OpAtomicIIncrement [[int]] [[var]] [[qf]] ; CHECK: OpAtomicIDecrement [[int]] [[var]] [[qf]] ; CHECK: OpAtomicIAdd [[int]] [[var]] [[qf]] ; CHECK: OpAtomicISub [[int]] [[var]] [[qf]] ; CHECK: OpAtomicSMin [[int]] [[var]] [[qf]] ; CHECK: OpAtomicSMax [[int]] [[var]] [[qf]] ; CHECK: OpAtomicUMin [[int]] [[var]] [[qf]] ; CHECK: OpAtomicUMax [[int]] [[var]] [[qf]] ; CHECK: OpAtomicAnd [[int]] [[var]] [[qf]] ; CHECK: OpAtomicOr [[int]] [[var]] [[qf]] ; CHECK: OpAtomicXor [[int]] [[var]] [[qf]] OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %func "func" %void = OpTypeVoid %int = OpTypeInt 32 0 %none = OpConstant %int 0 %device = OpConstant %int 1 %func_ty = OpTypeFunction %void %ptr_int_StorageBuffer = OpTypePointer StorageBuffer %int %var = OpVariable %ptr_int_StorageBuffer StorageBuffer %func = OpFunction %void None %func_ty %1 = OpLabel %ld = OpAtomicLoad %int %var %device %none OpAtomicStore %var %device %none %ld %ex = OpAtomicExchange %int %var %device %none %ld %cmp_ex = OpAtomicCompareExchange %int %var %device %none %none %ld %ld %inc = OpAtomicIIncrement %int %var %device %none %dec = OpAtomicIDecrement %int %var %device %none %add = OpAtomicIAdd %int %var %device %none %ld %sub = OpAtomicISub %int %var %device %none %ld %smin = OpAtomicSMin %int %var %device %none %ld %smax = OpAtomicSMax %int %var %device %none %ld %umin = OpAtomicUMin %int %var %device %none %ld %umax = OpAtomicUMax %int %var %device %none %ld %and = OpAtomicAnd %int %var %device %none %ld %or = OpAtomicOr %int %var %device %none %ld %xor = OpAtomicXor %int %var %device %none %ld OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, UpgradeModfNoFlags) { const std::string text = R"( ; CHECK: [[float:%\w+]] = OpTypeFloat 32 ; CHECK: [[float_0:%\w+]] = OpConstant [[float]] 0 ; CHECK: [[ptr:%\w+]] = OpTypePointer StorageBuffer [[float]] ; CHECK: [[var:%\w+]] = OpVariable [[ptr]] StorageBuffer ; CHECK: [[struct:%\w+]] = OpTypeStruct [[float]] [[float]] ; CHECK: [[modfstruct:%\w+]] = OpExtInst [[struct]] {{%\w+}} ModfStruct [[float_0]] ; CHECK: [[ex0:%\w+]] = OpCompositeExtract [[float]] [[modfstruct]] 0 ; CHECK: [[ex1:%\w+]] = OpCompositeExtract [[float]] [[modfstruct]] 1 ; CHECK: OpStore [[var]] [[ex1]] ; CHECK-NOT: NonPrivatePointer ; CHECK: OpFAdd [[float]] [[float_0]] [[ex0]] OpCapability Shader OpMemoryModel Logical GLSL450 %import = OpExtInstImport "GLSL.std.450" OpEntryPoint GLCompute %func "func" %void = OpTypeVoid %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %ptr_ssbo_float = OpTypePointer StorageBuffer %float %ssbo_var = OpVariable %ptr_ssbo_float StorageBuffer %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel %2 = OpExtInst %float %import Modf %float_0 %ssbo_var %3 = OpFAdd %float %float_0 %2 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, UpgradeModfWorkgroupCoherent) { const std::string text = R"( ; CHECK: [[float:%\w+]] = OpTypeFloat 32 ; CHECK: [[float_0:%\w+]] = OpConstant [[float]] 0 ; CHECK: [[ptr:%\w+]] = OpTypePointer Workgroup [[float]] ; CHECK: [[var:%\w+]] = OpVariable [[ptr]] Workgroup ; CHECK: [[struct:%\w+]] = OpTypeStruct [[float]] [[float]] ; CHECK: [[wg_scope:%\w+]] = OpConstant {{%\w+}} 2 ; CHECK: [[modfstruct:%\w+]] = OpExtInst [[struct]] {{%\w+}} ModfStruct [[float_0]] ; CHECK: [[ex0:%\w+]] = OpCompositeExtract [[float]] [[modfstruct]] 0 ; CHECK: [[ex1:%\w+]] = OpCompositeExtract [[float]] [[modfstruct]] 1 ; CHECK: OpStore [[var]] [[ex1]] MakePointerAvailable|NonPrivatePointer [[wg_scope]] ; CHECK: OpFAdd [[float]] [[float_0]] [[ex0]] OpCapability Shader OpMemoryModel Logical GLSL450 %import = OpExtInstImport "GLSL.std.450" OpEntryPoint GLCompute %func "func" OpDecorate %wg_var Coherent %void = OpTypeVoid %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %ptr_wg_float = OpTypePointer Workgroup %float %wg_var = OpVariable %ptr_wg_float Workgroup %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel %2 = OpExtInst %float %import Modf %float_0 %wg_var %3 = OpFAdd %float %float_0 %2 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, UpgradeModfSSBOCoherent) { const std::string text = R"( ; CHECK: [[float:%\w+]] = OpTypeFloat 32 ; CHECK: [[float_0:%\w+]] = OpConstant [[float]] 0 ; CHECK: [[ptr:%\w+]] = OpTypePointer StorageBuffer [[float]] ; CHECK: [[var:%\w+]] = OpVariable [[ptr]] StorageBuffer ; CHECK: [[struct:%\w+]] = OpTypeStruct [[float]] [[float]] ; CHECK: [[qf_scope:%\w+]] = OpConstant {{%\w+}} 5 ; CHECK: [[modfstruct:%\w+]] = OpExtInst [[struct]] {{%\w+}} ModfStruct [[float_0]] ; CHECK: [[ex0:%\w+]] = OpCompositeExtract [[float]] [[modfstruct]] 0 ; CHECK: [[ex1:%\w+]] = OpCompositeExtract [[float]] [[modfstruct]] 1 ; CHECK: OpStore [[var]] [[ex1]] MakePointerAvailable|NonPrivatePointer [[qf_scope]] ; CHECK: OpFAdd [[float]] [[float_0]] [[ex0]] OpCapability Shader OpMemoryModel Logical GLSL450 %import = OpExtInstImport "GLSL.std.450" OpEntryPoint GLCompute %func "func" OpDecorate %ssbo_var Coherent %void = OpTypeVoid %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %ptr_ssbo_float = OpTypePointer StorageBuffer %float %ssbo_var = OpVariable %ptr_ssbo_float StorageBuffer %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel %2 = OpExtInst %float %import Modf %float_0 %ssbo_var %3 = OpFAdd %float %float_0 %2 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, UpgradeModfSSBOVolatile) { const std::string text = R"( ; CHECK: [[float:%\w+]] = OpTypeFloat 32 ; CHECK: [[float_0:%\w+]] = OpConstant [[float]] 0 ; CHECK: [[ptr:%\w+]] = OpTypePointer StorageBuffer [[float]] ; CHECK: [[var:%\w+]] = OpVariable [[ptr]] StorageBuffer ; CHECK: [[struct:%\w+]] = OpTypeStruct [[float]] [[float]] ; CHECK: [[modfstruct:%\w+]] = OpExtInst [[struct]] {{%\w+}} ModfStruct [[float_0]] ; CHECK: [[ex0:%\w+]] = OpCompositeExtract [[float]] [[modfstruct]] 0 ; CHECK: [[ex1:%\w+]] = OpCompositeExtract [[float]] [[modfstruct]] 1 ; CHECK: OpStore [[var]] [[ex1]] Volatile ; CHECK: OpFAdd [[float]] [[float_0]] [[ex0]] OpCapability Shader OpMemoryModel Logical GLSL450 %import = OpExtInstImport "GLSL.std.450" OpEntryPoint GLCompute %func "func" OpDecorate %wg_var Volatile %void = OpTypeVoid %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %ptr_ssbo_float = OpTypePointer StorageBuffer %float %wg_var = OpVariable %ptr_ssbo_float StorageBuffer %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel %2 = OpExtInst %float %import Modf %float_0 %wg_var %3 = OpFAdd %float %float_0 %2 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, UpgradeFrexpNoFlags) { const std::string text = R"( ; CHECK: [[float:%\w+]] = OpTypeFloat 32 ; CHECK: [[float_0:%\w+]] = OpConstant [[float]] 0 ; CHECK: [[int:%\w+]] = OpTypeInt 32 0 ; CHECK: [[ptr:%\w+]] = OpTypePointer StorageBuffer [[int]] ; CHECK: [[var:%\w+]] = OpVariable [[ptr]] StorageBuffer ; CHECK: [[struct:%\w+]] = OpTypeStruct [[float]] [[int]] ; CHECK: [[modfstruct:%\w+]] = OpExtInst [[struct]] {{%\w+}} FrexpStruct [[float_0]] ; CHECK: [[ex0:%\w+]] = OpCompositeExtract [[float]] [[modfstruct]] 0 ; CHECK: [[ex1:%\w+]] = OpCompositeExtract [[int]] [[modfstruct]] 1 ; CHECK: OpStore [[var]] [[ex1]] ; CHECK-NOT: NonPrivatePointer ; CHECK: OpFAdd [[float]] [[float_0]] [[ex0]] OpCapability Shader OpMemoryModel Logical GLSL450 %import = OpExtInstImport "GLSL.std.450" OpEntryPoint GLCompute %func "func" %void = OpTypeVoid %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %int = OpTypeInt 32 0 %ptr_ssbo_int = OpTypePointer StorageBuffer %int %ssbo_var = OpVariable %ptr_ssbo_int StorageBuffer %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel %2 = OpExtInst %float %import Frexp %float_0 %ssbo_var %3 = OpFAdd %float %float_0 %2 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, UpgradeFrexpWorkgroupCoherent) { const std::string text = R"( ; CHECK: [[float:%\w+]] = OpTypeFloat 32 ; CHECK: [[float_0:%\w+]] = OpConstant [[float]] 0 ; CHECK: [[int:%\w+]] = OpTypeInt 32 0 ; CHECK: [[ptr:%\w+]] = OpTypePointer Workgroup [[int]] ; CHECK: [[var:%\w+]] = OpVariable [[ptr]] Workgroup ; CHECK: [[struct:%\w+]] = OpTypeStruct [[float]] [[int]] ; CHECK: [[wg_scope:%\w+]] = OpConstant {{%\w+}} 2 ; CHECK: [[modfstruct:%\w+]] = OpExtInst [[struct]] {{%\w+}} FrexpStruct [[float_0]] ; CHECK: [[ex0:%\w+]] = OpCompositeExtract [[float]] [[modfstruct]] 0 ; CHECK: [[ex1:%\w+]] = OpCompositeExtract [[int]] [[modfstruct]] 1 ; CHECK: OpStore [[var]] [[ex1]] MakePointerAvailable|NonPrivatePointer [[wg_scope]] ; CHECK: OpFAdd [[float]] [[float_0]] [[ex0]] OpCapability Shader OpMemoryModel Logical GLSL450 %import = OpExtInstImport "GLSL.std.450" OpEntryPoint GLCompute %func "func" OpDecorate %wg_var Coherent %void = OpTypeVoid %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %int = OpTypeInt 32 0 %ptr_wg_int = OpTypePointer Workgroup %int %wg_var = OpVariable %ptr_wg_int Workgroup %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel %2 = OpExtInst %float %import Frexp %float_0 %wg_var %3 = OpFAdd %float %float_0 %2 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, UpgradeFrexpSSBOCoherent) { const std::string text = R"( ; CHECK: [[float:%\w+]] = OpTypeFloat 32 ; CHECK: [[float_0:%\w+]] = OpConstant [[float]] 0 ; CHECK: [[int:%\w+]] = OpTypeInt 32 0 ; CHECK: [[ptr:%\w+]] = OpTypePointer StorageBuffer [[int]] ; CHECK: [[var:%\w+]] = OpVariable [[ptr]] StorageBuffer ; CHECK: [[struct:%\w+]] = OpTypeStruct [[float]] [[int]] ; CHECK: [[qf_scope:%\w+]] = OpConstant {{%\w+}} 5 ; CHECK: [[modfstruct:%\w+]] = OpExtInst [[struct]] {{%\w+}} FrexpStruct [[float_0]] ; CHECK: [[ex0:%\w+]] = OpCompositeExtract [[float]] [[modfstruct]] 0 ; CHECK: [[ex1:%\w+]] = OpCompositeExtract [[int]] [[modfstruct]] 1 ; CHECK: OpStore [[var]] [[ex1]] MakePointerAvailable|NonPrivatePointer [[qf_scope]] ; CHECK: OpFAdd [[float]] [[float_0]] [[ex0]] OpCapability Shader OpMemoryModel Logical GLSL450 %import = OpExtInstImport "GLSL.std.450" OpEntryPoint GLCompute %func "func" OpDecorate %ssbo_var Coherent %void = OpTypeVoid %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %int = OpTypeInt 32 0 %ptr_ssbo_int = OpTypePointer StorageBuffer %int %ssbo_var = OpVariable %ptr_ssbo_int StorageBuffer %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel %2 = OpExtInst %float %import Frexp %float_0 %ssbo_var %3 = OpFAdd %float %float_0 %2 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, UpgradeFrexpSSBOVolatile) { const std::string text = R"( ; CHECK: [[float:%\w+]] = OpTypeFloat 32 ; CHECK: [[float_0:%\w+]] = OpConstant [[float]] 0 ; CHECK: [[int:%\w+]] = OpTypeInt 32 0 ; CHECK: [[ptr:%\w+]] = OpTypePointer StorageBuffer [[int]] ; CHECK: [[var:%\w+]] = OpVariable [[ptr]] StorageBuffer ; CHECK: [[struct:%\w+]] = OpTypeStruct [[float]] [[int]] ; CHECK: [[modfstruct:%\w+]] = OpExtInst [[struct]] {{%\w+}} FrexpStruct [[float_0]] ; CHECK: [[ex0:%\w+]] = OpCompositeExtract [[float]] [[modfstruct]] 0 ; CHECK: [[ex1:%\w+]] = OpCompositeExtract [[int]] [[modfstruct]] 1 ; CHECK: OpStore [[var]] [[ex1]] Volatile ; CHECK: OpFAdd [[float]] [[float_0]] [[ex0]] OpCapability Shader OpMemoryModel Logical GLSL450 %import = OpExtInstImport "GLSL.std.450" OpEntryPoint GLCompute %func "func" OpDecorate %wg_var Volatile %void = OpTypeVoid %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %int = OpTypeInt 32 0 %ptr_ssbo_int = OpTypePointer StorageBuffer %int %wg_var = OpVariable %ptr_ssbo_int StorageBuffer %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel %2 = OpExtInst %float %import Frexp %float_0 %wg_var %3 = OpFAdd %float %float_0 %2 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, SPV14NormalizeCopyMemoryAddOperands) { const std::string text = R"( ; CHECK: OpCopyMemory {{%\w+}} {{%\w+}} None None OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %func "func" %src %dst %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr_ssbo_int = OpTypePointer StorageBuffer %int %src = OpVariable %ptr_ssbo_int StorageBuffer %dst = OpVariable %ptr_ssbo_int StorageBuffer %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel OpCopyMemory %dst %src OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_UNIVERSAL_1_4); SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, SPV14NormalizeCopyMemoryDuplicateOperand) { const std::string text = R"( ; CHECK: OpCopyMemory {{%\w+}} {{%\w+}} Nontemporal Nontemporal OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %func "func" %src %dst %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr_ssbo_int = OpTypePointer StorageBuffer %int %src = OpVariable %ptr_ssbo_int StorageBuffer %dst = OpVariable %ptr_ssbo_int StorageBuffer %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel OpCopyMemory %dst %src Nontemporal OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_UNIVERSAL_1_4); SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, SPV14NormalizeCopyMemoryDuplicateOperands) { const std::string text = R"( ; CHECK: OpCopyMemory {{%\w+}} {{%\w+}} Aligned 4 Aligned 4 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %func "func" %src %dst %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr_ssbo_int = OpTypePointer StorageBuffer %int %src = OpVariable %ptr_ssbo_int StorageBuffer %dst = OpVariable %ptr_ssbo_int StorageBuffer %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel OpCopyMemory %dst %src Aligned 4 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_UNIVERSAL_1_4); SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, SPV14CopyMemoryDstCoherent) { const std::string text = R"( ; CHECK: [[scope:%\w+]] = OpConstant {{%\w+}} 5 ; CHECK: OpCopyMemory {{%\w+}} {{%\w+}} MakePointerAvailable|NonPrivatePointer [[scope]] None OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %func "func" %src %dst OpDecorate %dst Coherent %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr_ssbo_int = OpTypePointer StorageBuffer %int %src = OpVariable %ptr_ssbo_int StorageBuffer %dst = OpVariable %ptr_ssbo_int StorageBuffer %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel OpCopyMemory %dst %src OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_UNIVERSAL_1_4); SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, SPV14CopyMemoryDstCoherentPreviousArgs) { const std::string text = R"( ; CHECK: [[scope:%\w+]] = OpConstant {{%\w+}} 5 ; CHECK: OpCopyMemory {{%\w+}} {{%\w+}} Aligned|MakePointerAvailable|NonPrivatePointer 4 [[scope]] Aligned 4 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %func "func" %src %dst OpDecorate %dst Coherent %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr_ssbo_int = OpTypePointer StorageBuffer %int %src = OpVariable %ptr_ssbo_int StorageBuffer %dst = OpVariable %ptr_ssbo_int StorageBuffer %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel OpCopyMemory %dst %src Aligned 4 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_UNIVERSAL_1_4); SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, SPV14CopyMemorySrcCoherent) { const std::string text = R"( ; CHECK: [[scope:%\w+]] = OpConstant {{%\w+}} 5 ; CHECK: OpCopyMemory {{%\w+}} {{%\w+}} None MakePointerVisible|NonPrivatePointer [[scope]] OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %func "func" %src %dst OpDecorate %src Coherent %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr_ssbo_int = OpTypePointer StorageBuffer %int %src = OpVariable %ptr_ssbo_int StorageBuffer %dst = OpVariable %ptr_ssbo_int StorageBuffer %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel OpCopyMemory %dst %src OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_UNIVERSAL_1_4); SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, SPV14CopyMemorySrcCoherentPreviousArgs) { const std::string text = R"( ; CHECK: [[scope:%\w+]] = OpConstant {{%\w+}} 5 ; CHECK: OpCopyMemory {{%\w+}} {{%\w+}} Aligned 4 Aligned|MakePointerVisible|NonPrivatePointer 4 [[scope]] OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %func "func" %src %dst OpDecorate %src Coherent %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr_ssbo_int = OpTypePointer StorageBuffer %int %src = OpVariable %ptr_ssbo_int StorageBuffer %dst = OpVariable %ptr_ssbo_int StorageBuffer %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel OpCopyMemory %dst %src Aligned 4 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_UNIVERSAL_1_4); SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, SPV14CopyMemoryBothCoherent) { const std::string text = R"( ; CHECK-DAG: [[queue:%\w+]] = OpConstant {{%\w+}} 5 ; CHECK-DAG: [[wg:%\w+]] = OpConstant {{%\w+}} 2 ; CHECK: OpCopyMemory {{%\w+}} {{%\w+}} MakePointerAvailable|NonPrivatePointer [[wg]] MakePointerVisible|NonPrivatePointer [[queue]] OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %func "func" %src %dst OpDecorate %src Coherent %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr_ssbo_int = OpTypePointer StorageBuffer %int %ptr_wg_int = OpTypePointer Workgroup %int %src = OpVariable %ptr_ssbo_int StorageBuffer %dst = OpVariable %ptr_wg_int Workgroup %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel OpCopyMemory %dst %src OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_UNIVERSAL_1_4); SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, SPV14CopyMemoryBothCoherentPreviousArgs) { const std::string text = R"( ; CHECK-DAG: [[queue:%\w+]] = OpConstant {{%\w+}} 5 ; CHECK-DAG: [[wg:%\w+]] = OpConstant {{%\w+}} 2 ; CHECK: OpCopyMemory {{%\w+}} {{%\w+}} Aligned|MakePointerAvailable|NonPrivatePointer 4 [[queue]] Aligned|MakePointerVisible|NonPrivatePointer 4 [[wg]] OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %func "func" %src %dst OpDecorate %dst Coherent %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr_ssbo_int = OpTypePointer StorageBuffer %int %ptr_wg_int = OpTypePointer Workgroup %int %src = OpVariable %ptr_wg_int Workgroup %dst = OpVariable %ptr_ssbo_int StorageBuffer %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel OpCopyMemory %dst %src Aligned 4 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_UNIVERSAL_1_4); SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, SPV14CopyMemoryBothVolatile) { const std::string text = R"( ; CHECK: OpCopyMemory {{%\w+}} {{%\w+}} Volatile Volatile OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %func "func" %src %dst OpDecorate %src Volatile OpDecorate %dst Volatile %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr_ssbo_int = OpTypePointer StorageBuffer %int %src = OpVariable %ptr_ssbo_int StorageBuffer %dst = OpVariable %ptr_ssbo_int StorageBuffer %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel OpCopyMemory %dst %src OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_UNIVERSAL_1_4); SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, SPV14CopyMemoryBothVolatilePreviousArgs) { const std::string text = R"( ; CHECK: OpCopyMemory {{%\w+}} {{%\w+}} Volatile|Aligned 4 Volatile|Aligned 4 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %func "func" %src %dst OpDecorate %src Volatile OpDecorate %dst Volatile %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr_ssbo_int = OpTypePointer StorageBuffer %int %src = OpVariable %ptr_ssbo_int StorageBuffer %dst = OpVariable %ptr_ssbo_int StorageBuffer %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel OpCopyMemory %dst %src Aligned 4 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_UNIVERSAL_1_4); SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, SPV14CopyMemoryDstCoherentTwoOperands) { const std::string text = R"( ; CHECK: [[scope:%\w+]] = OpConstant {{%\w+}} 5 ; CHECK: OpCopyMemory {{%\w+}} {{%\w+}} MakePointerAvailable|NonPrivatePointer [[scope]] None OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %func "func" %src %dst OpDecorate %dst Coherent %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr_ssbo_int = OpTypePointer StorageBuffer %int %src = OpVariable %ptr_ssbo_int StorageBuffer %dst = OpVariable %ptr_ssbo_int StorageBuffer %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel OpCopyMemory %dst %src None None OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_UNIVERSAL_1_4); SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, SPV14CopyMemoryDstCoherentPreviousArgsTwoOperands) { const std::string text = R"( ; CHECK: [[scope:%\w+]] = OpConstant {{%\w+}} 5 ; CHECK: OpCopyMemory {{%\w+}} {{%\w+}} Aligned|MakePointerAvailable|NonPrivatePointer 4 [[scope]] Aligned 8 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %func "func" %src %dst OpDecorate %dst Coherent %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr_ssbo_int = OpTypePointer StorageBuffer %int %src = OpVariable %ptr_ssbo_int StorageBuffer %dst = OpVariable %ptr_ssbo_int StorageBuffer %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel OpCopyMemory %dst %src Aligned 4 Aligned 8 OpReturn OpFunctionEnd )"; SetTargetEnv(SPV_ENV_UNIVERSAL_1_4); SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, VolatileAtomicLoad) { const std::string text = R"( ; CHECK-NOT: OpDecorate {{.*}} Volatile ; CHECK: [[volatile:%[a-zA-Z0-9_]+]] = OpConstant [[int:%[a-zA-Z0-9_]+]] 32768 ; CHECK: OpAtomicLoad [[int]] {{.*}} {{.*}} [[volatile]] OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %ssbo_var Volatile %void = OpTypeVoid %int = OpTypeInt 32 0 %device = OpConstant %int 1 %relaxed = OpConstant %int 0 %ptr_ssbo_int = OpTypePointer StorageBuffer %int %ssbo_var = OpVariable %ptr_ssbo_int StorageBuffer %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel %ld = OpAtomicLoad %int %ssbo_var %device %relaxed OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, VolatileAtomicLoadPreviousFlags) { const std::string text = R"( ; CHECK-NOT: OpDecorate {{.*}} Volatile ; CHECK: [[volatile:%[a-zA-Z0-9_]+]] = OpConstant [[int:%[a-zA-Z0-9_]+]] 32834 ; CHECK: OpAtomicLoad [[int]] {{.*}} {{.*}} [[volatile]] OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %ssbo_var Volatile %void = OpTypeVoid %int = OpTypeInt 32 0 %device = OpConstant %int 1 %acquire_ssbo = OpConstant %int 66 %ptr_ssbo_int = OpTypePointer StorageBuffer %int %ssbo_var = OpVariable %ptr_ssbo_int StorageBuffer %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel %ld = OpAtomicLoad %int %ssbo_var %device %acquire_ssbo OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, VolatileAtomicStore) { const std::string text = R"( ; CHECK-NOT: OpDecorate {{.*}} Volatile ; CHECK: [[volatile:%[a-zA-Z0-9_]+]] = OpConstant {{.*}} 32768 ; CHECK: OpAtomicStore {{.*}} {{.*}} [[volatile]] OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %ssbo_var Volatile %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %device = OpConstant %int 1 %relaxed = OpConstant %int 0 %ptr_ssbo_int = OpTypePointer StorageBuffer %int %ssbo_var = OpVariable %ptr_ssbo_int StorageBuffer %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel OpAtomicStore %ssbo_var %device %relaxed %int_0 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, VolatileAtomicStorePreviousFlags) { const std::string text = R"( ; CHECK-NOT: OpDecorate {{.*}} Volatile ; CHECK: [[volatile:%[a-zA-Z0-9_]+]] = OpConstant {{.*}} 32836 ; CHECK: OpAtomicStore {{.*}} {{.*}} [[volatile]] OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %ssbo_var Volatile %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %device = OpConstant %int 1 %release_ssbo = OpConstant %int 68 %ptr_ssbo_int = OpTypePointer StorageBuffer %int %ssbo_var = OpVariable %ptr_ssbo_int StorageBuffer %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel OpAtomicStore %ssbo_var %device %release_ssbo %int_0 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, VolatileAtomicCompareExchange) { const std::string text = R"( ; CHECK-NOT: OpDecorate {{.*}} Volatile ; CHECK: [[volatile:%[a-zA-Z0-9_]+]] = OpConstant [[int:%[a-zA-Z0-9_]+]] 32768 ; CHECK: OpAtomicCompareExchange [[int]] {{.*}} {{.*}} [[volatile]] [[volatile]] OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %ssbo_var Volatile %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %device = OpConstant %int 1 %relaxed = OpConstant %int 0 %ptr_ssbo_int = OpTypePointer StorageBuffer %int %ssbo_var = OpVariable %ptr_ssbo_int StorageBuffer %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel %ld = OpAtomicCompareExchange %int %ssbo_var %device %relaxed %relaxed %int_0 %int_1 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, VolatileAtomicCompareExchangePreviousFlags) { const std::string text = R"( ; CHECK-NOT: OpDecorate {{.*}} Volatile ; CHECK: [[volatile_acq_rel:%[a-zA-Z0-9_]+]] = OpConstant [[int:%[a-zA-Z0-9_]+]] 32840 ; CHECK: [[volatile_acq:%[a-zA-Z0-9_]+]] = OpConstant [[int:%[a-zA-Z0-9_]+]] 32834 ; CHECK: OpAtomicCompareExchange [[int]] {{.*}} {{.*}} [[volatile_acq_rel]] [[volatile_acq]] OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %ssbo_var Volatile %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %device = OpConstant %int 1 %acq_ssbo = OpConstant %int 66 %acq_rel_ssbo = OpConstant %int 72 %ptr_ssbo_int = OpTypePointer StorageBuffer %int %ssbo_var = OpVariable %ptr_ssbo_int StorageBuffer %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel %ld = OpAtomicCompareExchange %int %ssbo_var %device %acq_rel_ssbo %acq_ssbo %int_0 %int_1 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, VolatileAtomicLoadMemberDecoration) { const std::string text = R"( ; CHECK-NOT: OpMemberDecorate {{.*}} {{.*}} Volatile ; CHECK: [[relaxed:%[a-zA-Z0-9_]+]] = OpConstant {{.*}} 0 ; CHECK: [[volatile:%[a-zA-Z0-9_]+]] = OpConstant [[int:%[a-zA-Z0-9_]+]] 32768 ; CHECK: OpAtomicLoad [[int]] {{.*}} {{.*}} [[relaxed]] ; CHECK: OpAtomicLoad [[int]] {{.*}} {{.*}} [[volatile]] OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpMemberDecorate %struct 1 Volatile %void = OpTypeVoid %int = OpTypeInt 32 0 %device = OpConstant %int 1 %relaxed = OpConstant %int 0 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %ptr_ssbo_int = OpTypePointer StorageBuffer %int %struct = OpTypeStruct %int %int %ptr_ssbo_struct = OpTypePointer StorageBuffer %struct %ssbo_var = OpVariable %ptr_ssbo_struct StorageBuffer %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel %gep0 = OpAccessChain %ptr_ssbo_int %ssbo_var %int_0 %ld0 = OpAtomicLoad %int %gep0 %device %relaxed %gep1 = OpAccessChain %ptr_ssbo_int %ssbo_var %int_1 %ld1 = OpAtomicLoad %int %gep1 %device %relaxed OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(UpgradeMemoryModelTest, CoherentStructMemberInArray) { const std::string text = R"( ; CHECK-NOT: OpMemberDecorate ; CHECK: [[int:%[a-zA-Z0-9_]+]] = OpTypeInt 32 0 ; CHECK: [[device:%[a-zA-Z0-9_]+]] = OpConstant [[int]] 1 ; CHECK: OpLoad [[int]] {{.*}} MakePointerVisible|NonPrivatePointer OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpMemberDecorate %inner 1 Coherent %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %int_4 = OpConstant %int 4 %inner = OpTypeStruct %int %int %array = OpTypeArray %inner %int_4 %struct = OpTypeStruct %array %ptr_ssbo_struct = OpTypePointer StorageBuffer %struct %ptr_ssbo_int = OpTypePointer StorageBuffer %int %ssbo_var = OpVariable %ptr_ssbo_struct StorageBuffer %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel %gep = OpAccessChain %ptr_ssbo_int %ssbo_var %int_0 %int_0 %int_1 %ld = OpLoad %int %gep OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } } // namespace KhronosGroup-SPIRV-Tools-f289d04/test/opt/utils_test.cpp000066400000000000000000000075571475742701700232330ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gtest/gtest.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { TEST(JoinAllInsts, Cases) { EXPECT_EQ("", JoinAllInsts({})); EXPECT_EQ("a\n", JoinAllInsts({"a"})); EXPECT_EQ("a\nb\n", JoinAllInsts({"a", "b"})); EXPECT_EQ("a\nb\nc\n", JoinAllInsts({"a", "b", "c"})); EXPECT_EQ("hello,\nworld!\n\n\n", JoinAllInsts({"hello,", "world!", "\n"})); } TEST(JoinNonDebugInsts, Cases) { EXPECT_EQ("", JoinNonDebugInsts({})); EXPECT_EQ("a\n", JoinNonDebugInsts({"a"})); EXPECT_EQ("", JoinNonDebugInsts({"OpName"})); EXPECT_EQ("a\nb\n", JoinNonDebugInsts({"a", "b"})); EXPECT_EQ("", JoinNonDebugInsts({"OpName", "%1 = OpString \"42\""})); EXPECT_EQ("Opstring\n", JoinNonDebugInsts({"OpName", "Opstring"})); EXPECT_EQ("the only remaining string\n", JoinNonDebugInsts( {"OpSourceContinued", "OpSource", "OpSourceExtension", "lgtm OpName", "hello OpMemberName", "this is a OpString", "lonely OpLine", "happy OpNoLine", "OpModuleProcessed", "the only remaining string"})); } struct SubstringReplacementTestCase { const char* orig_str; const char* find_substr; const char* replace_substr; const char* expected_str; bool replace_should_succeed; }; using FindAndReplaceTest = ::testing::TestWithParam; TEST_P(FindAndReplaceTest, SubstringReplacement) { auto process = std::string(GetParam().orig_str); EXPECT_EQ(GetParam().replace_should_succeed, FindAndReplace(&process, GetParam().find_substr, GetParam().replace_substr)) << "Original string: " << GetParam().orig_str << " replace: " << GetParam().find_substr << " to: " << GetParam().replace_substr << " should returns: " << GetParam().replace_should_succeed; EXPECT_STREQ(GetParam().expected_str, process.c_str()) << "Original string: " << GetParam().orig_str << " replace: " << GetParam().find_substr << " to: " << GetParam().replace_substr << " expected string: " << GetParam().expected_str; } INSTANTIATE_TEST_SUITE_P( SubstringReplacement, FindAndReplaceTest, ::testing::ValuesIn(std::vector({ // orig string, find substring, replace substring, expected string, // replacement happened {"", "", "", "", false}, {"", "b", "", "", false}, {"", "", "c", "", false}, {"", "a", "b", "", false}, {"a", "", "c", "a", false}, {"a", "b", "c", "a", false}, {"a", "b", "", "a", false}, {"a", "a", "", "", true}, {"a", "a", "b", "b", true}, {"ab", "a", "b", "bb", true}, {"ab", "a", "", "b", true}, {"ab", "b", "", "a", true}, {"ab", "ab", "", "", true}, {"ab", "ab", "cd", "cd", true}, {"bc", "abc", "efg", "bc", false}, {"abc", "ab", "bc", "bcc", true}, {"abc", "ab", "", "c", true}, {"abc", "bc", "", "a", true}, {"abc", "bc", "d", "ad", true}, {"abc", "a", "123", "123bc", true}, {"abc", "ab", "a", "ac", true}, {"abc", "a", "aab", "aabbc", true}, {"abc", "abcd", "efg", "abc", false}, }))); } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/value_table_test.cpp000066400000000000000000000747151475742701700243560ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gmock/gmock.h" #include "source/opt/build_module.h" #include "source/opt/value_number_table.h" #include "test/opt/pass_fixture.h" namespace spvtools { namespace opt { namespace { using ::testing::HasSubstr; using ::testing::MatchesRegex; using ValueTableTest = PassTest<::testing::Test>; TEST_F(ValueTableTest, SameInstructionSameValue) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %6 = OpTypePointer Function %5 %2 = OpFunction %3 None %4 %7 = OpLabel %8 = OpVariable %6 Function %9 = OpLoad %5 %8 %10 = OpFAdd %5 %9 %9 OpReturn OpFunctionEnd )"; auto context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); ValueNumberTable vtable(context.get()); Instruction* inst = context->get_def_use_mgr()->GetDef(10); EXPECT_EQ(vtable.GetValueNumber(inst), vtable.GetValueNumber(inst)); } TEST_F(ValueTableTest, DifferentInstructionSameValue) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %6 = OpTypePointer Function %5 %2 = OpFunction %3 None %4 %7 = OpLabel %8 = OpVariable %6 Function %9 = OpLoad %5 %8 %10 = OpFAdd %5 %9 %9 %11 = OpFAdd %5 %9 %9 OpReturn OpFunctionEnd )"; auto context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); ValueNumberTable vtable(context.get()); Instruction* inst1 = context->get_def_use_mgr()->GetDef(10); Instruction* inst2 = context->get_def_use_mgr()->GetDef(11); EXPECT_EQ(vtable.GetValueNumber(inst1), vtable.GetValueNumber(inst2)); } TEST_F(ValueTableTest, SameValueDifferentBlock) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %6 = OpTypePointer Function %5 %2 = OpFunction %3 None %4 %7 = OpLabel %8 = OpVariable %6 Function %9 = OpLoad %5 %8 %10 = OpFAdd %5 %9 %9 OpBranch %11 %11 = OpLabel %12 = OpFAdd %5 %9 %9 OpReturn OpFunctionEnd )"; auto context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); ValueNumberTable vtable(context.get()); Instruction* inst1 = context->get_def_use_mgr()->GetDef(10); Instruction* inst2 = context->get_def_use_mgr()->GetDef(12); EXPECT_EQ(vtable.GetValueNumber(inst1), vtable.GetValueNumber(inst2)); } TEST_F(ValueTableTest, DifferentValue) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %6 = OpTypePointer Function %5 %2 = OpFunction %3 None %4 %7 = OpLabel %8 = OpVariable %6 Function %9 = OpLoad %5 %8 %10 = OpFAdd %5 %9 %9 %11 = OpFAdd %5 %9 %10 OpReturn OpFunctionEnd )"; auto context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); ValueNumberTable vtable(context.get()); Instruction* inst1 = context->get_def_use_mgr()->GetDef(10); Instruction* inst2 = context->get_def_use_mgr()->GetDef(11); EXPECT_NE(vtable.GetValueNumber(inst1), vtable.GetValueNumber(inst2)); } TEST_F(ValueTableTest, DifferentValueDifferentBlock) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %6 = OpTypePointer Function %5 %2 = OpFunction %3 None %4 %7 = OpLabel %8 = OpVariable %6 Function %9 = OpLoad %5 %8 %10 = OpFAdd %5 %9 %9 OpBranch %11 %11 = OpLabel %12 = OpFAdd %5 %9 %10 OpReturn OpFunctionEnd )"; auto context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); ValueNumberTable vtable(context.get()); Instruction* inst1 = context->get_def_use_mgr()->GetDef(10); Instruction* inst2 = context->get_def_use_mgr()->GetDef(12); EXPECT_NE(vtable.GetValueNumber(inst1), vtable.GetValueNumber(inst2)); } TEST_F(ValueTableTest, SameLoad) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %6 = OpTypePointer Function %5 %2 = OpFunction %3 None %4 %7 = OpLabel %8 = OpVariable %6 Function %9 = OpLoad %5 %8 OpReturn OpFunctionEnd )"; auto context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); ValueNumberTable vtable(context.get()); Instruction* inst = context->get_def_use_mgr()->GetDef(9); EXPECT_EQ(vtable.GetValueNumber(inst), vtable.GetValueNumber(inst)); } // Two different loads, even from the same memory, must given different value // numbers if the memory is not read-only. TEST_F(ValueTableTest, DifferentFunctionLoad) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %6 = OpTypePointer Function %5 %2 = OpFunction %3 None %4 %7 = OpLabel %8 = OpVariable %6 Function %9 = OpLoad %5 %8 %10 = OpLoad %5 %8 OpReturn OpFunctionEnd )"; auto context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); ValueNumberTable vtable(context.get()); Instruction* inst1 = context->get_def_use_mgr()->GetDef(9); Instruction* inst2 = context->get_def_use_mgr()->GetDef(10); EXPECT_NE(vtable.GetValueNumber(inst1), vtable.GetValueNumber(inst2)); } TEST_F(ValueTableTest, DifferentUniformLoad) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %6 = OpTypePointer Uniform %5 %8 = OpVariable %6 Uniform %2 = OpFunction %3 None %4 %7 = OpLabel %9 = OpLoad %5 %8 %10 = OpLoad %5 %8 OpReturn OpFunctionEnd )"; auto context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); ValueNumberTable vtable(context.get()); Instruction* inst1 = context->get_def_use_mgr()->GetDef(9); Instruction* inst2 = context->get_def_use_mgr()->GetDef(10); EXPECT_EQ(vtable.GetValueNumber(inst1), vtable.GetValueNumber(inst2)); } TEST_F(ValueTableTest, DifferentInputLoad) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %6 = OpTypePointer Input %5 %8 = OpVariable %6 Input %2 = OpFunction %3 None %4 %7 = OpLabel %9 = OpLoad %5 %8 %10 = OpLoad %5 %8 OpReturn OpFunctionEnd )"; auto context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); ValueNumberTable vtable(context.get()); Instruction* inst1 = context->get_def_use_mgr()->GetDef(9); Instruction* inst2 = context->get_def_use_mgr()->GetDef(10); EXPECT_EQ(vtable.GetValueNumber(inst1), vtable.GetValueNumber(inst2)); } TEST_F(ValueTableTest, DifferentUniformConstantLoad) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %6 = OpTypePointer UniformConstant %5 %8 = OpVariable %6 UniformConstant %2 = OpFunction %3 None %4 %7 = OpLabel %9 = OpLoad %5 %8 %10 = OpLoad %5 %8 OpReturn OpFunctionEnd )"; auto context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); ValueNumberTable vtable(context.get()); Instruction* inst1 = context->get_def_use_mgr()->GetDef(9); Instruction* inst2 = context->get_def_use_mgr()->GetDef(10); EXPECT_EQ(vtable.GetValueNumber(inst1), vtable.GetValueNumber(inst2)); } TEST_F(ValueTableTest, DifferentPushConstantLoad) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %6 = OpTypePointer PushConstant %5 %8 = OpVariable %6 PushConstant %2 = OpFunction %3 None %4 %7 = OpLabel %9 = OpLoad %5 %8 %10 = OpLoad %5 %8 OpReturn OpFunctionEnd )"; auto context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); ValueNumberTable vtable(context.get()); Instruction* inst1 = context->get_def_use_mgr()->GetDef(9); Instruction* inst2 = context->get_def_use_mgr()->GetDef(10); EXPECT_EQ(vtable.GetValueNumber(inst1), vtable.GetValueNumber(inst2)); } TEST_F(ValueTableTest, SameCall) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %6 = OpTypeFunction %5 %7 = OpTypePointer Function %5 %8 = OpVariable %7 Private %2 = OpFunction %3 None %4 %9 = OpLabel %10 = OpFunctionCall %5 %11 OpReturn OpFunctionEnd %11 = OpFunction %5 None %6 %12 = OpLabel %13 = OpLoad %5 %8 OpReturnValue %13 OpFunctionEnd )"; auto context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); ValueNumberTable vtable(context.get()); Instruction* inst = context->get_def_use_mgr()->GetDef(10); EXPECT_EQ(vtable.GetValueNumber(inst), vtable.GetValueNumber(inst)); } // Function calls should be given a new value number, even if they are the same. TEST_F(ValueTableTest, DifferentCall) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %6 = OpTypeFunction %5 %7 = OpTypePointer Function %5 %8 = OpVariable %7 Private %2 = OpFunction %3 None %4 %9 = OpLabel %10 = OpFunctionCall %5 %11 %12 = OpFunctionCall %5 %11 OpReturn OpFunctionEnd %11 = OpFunction %5 None %6 %13 = OpLabel %14 = OpLoad %5 %8 OpReturnValue %14 OpFunctionEnd )"; auto context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); ValueNumberTable vtable(context.get()); Instruction* inst1 = context->get_def_use_mgr()->GetDef(10); Instruction* inst2 = context->get_def_use_mgr()->GetDef(12); EXPECT_NE(vtable.GetValueNumber(inst1), vtable.GetValueNumber(inst2)); } // It is possible to have two instruction that compute the same numerical value, // but with different types. They should have different value numbers. TEST_F(ValueTableTest, DifferentTypes) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 0 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %5 %2 = OpFunction %3 None %4 %8 = OpLabel %9 = OpVariable %7 Function %10 = OpLoad %5 %9 %11 = OpIAdd %5 %10 %10 %12 = OpIAdd %6 %10 %10 OpReturn OpFunctionEnd )"; auto context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); ValueNumberTable vtable(context.get()); Instruction* inst1 = context->get_def_use_mgr()->GetDef(11); Instruction* inst2 = context->get_def_use_mgr()->GetDef(12); EXPECT_NE(vtable.GetValueNumber(inst1), vtable.GetValueNumber(inst2)); } TEST_F(ValueTableTest, CopyObject) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %6 = OpTypePointer Function %5 %2 = OpFunction %3 None %4 %7 = OpLabel %8 = OpVariable %6 Function %9 = OpLoad %5 %8 %10 = OpCopyObject %5 %9 OpReturn OpFunctionEnd )"; auto context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); ValueNumberTable vtable(context.get()); Instruction* inst1 = context->get_def_use_mgr()->GetDef(9); Instruction* inst2 = context->get_def_use_mgr()->GetDef(10); EXPECT_EQ(vtable.GetValueNumber(inst1), vtable.GetValueNumber(inst2)); } TEST_F(ValueTableTest, CopyObjectWitDecoration) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpDecorate %3 NonUniformEXT %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %2 = OpFunction %4 None %5 %8 = OpLabel %9 = OpVariable %7 Function %10 = OpLoad %6 %9 %3 = OpCopyObject %6 %10 OpReturn OpFunctionEnd )"; auto context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); ValueNumberTable vtable(context.get()); Instruction* inst1 = context->get_def_use_mgr()->GetDef(10); Instruction* inst2 = context->get_def_use_mgr()->GetDef(3); EXPECT_NE(vtable.GetValueNumber(inst1), vtable.GetValueNumber(inst2)); } // Test that a phi where the operands have the same value assigned that value // to the result of the phi. TEST_F(ValueTableTest, PhiTest1) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %6 = OpTypePointer Uniform %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %9 = OpVariable %6 Uniform %2 = OpFunction %3 None %4 %10 = OpLabel OpBranchConditional %8 %11 %12 %11 = OpLabel %13 = OpLoad %5 %9 OpBranch %14 %12 = OpLabel %15 = OpLoad %5 %9 OpBranch %14 %14 = OpLabel %16 = OpPhi %5 %13 %11 %15 %12 OpReturn OpFunctionEnd )"; auto context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); ValueNumberTable vtable(context.get()); Instruction* inst1 = context->get_def_use_mgr()->GetDef(13); Instruction* inst2 = context->get_def_use_mgr()->GetDef(15); Instruction* phi = context->get_def_use_mgr()->GetDef(16); EXPECT_EQ(vtable.GetValueNumber(inst1), vtable.GetValueNumber(inst2)); EXPECT_EQ(vtable.GetValueNumber(inst1), vtable.GetValueNumber(phi)); } TEST_F(ValueTableTest, PhiTest1WithDecoration) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 OpDecorate %3 NonUniformEXT %4 = OpTypeVoid %5 = OpTypeFunction %5 %6 = OpTypeFloat 32 %7 = OpTypePointer Uniform %6 %8 = OpTypeBool %9 = OpConstantTrue %8 %10 = OpVariable %7 Uniform %2 = OpFunction %4 None %5 %11 = OpLabel OpBranchConditional %9 %12 %13 %12 = OpLabel %14 = OpLoad %6 %10 OpBranch %15 %13 = OpLabel %16 = OpLoad %6 %10 OpBranch %15 %15 = OpLabel %3 = OpPhi %6 %14 %12 %16 %13 OpReturn OpFunctionEnd )"; auto context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); ValueNumberTable vtable(context.get()); Instruction* inst1 = context->get_def_use_mgr()->GetDef(14); Instruction* inst2 = context->get_def_use_mgr()->GetDef(16); Instruction* phi = context->get_def_use_mgr()->GetDef(3); EXPECT_EQ(vtable.GetValueNumber(inst1), vtable.GetValueNumber(inst2)); EXPECT_NE(vtable.GetValueNumber(inst1), vtable.GetValueNumber(phi)); } // When the values for the inputs to a phi do not match, then the phi should // have its own value number. TEST_F(ValueTableTest, PhiTest2) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %6 = OpTypePointer Uniform %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %9 = OpVariable %6 Uniform %10 = OpVariable %6 Uniform %2 = OpFunction %3 None %4 %11 = OpLabel OpBranchConditional %8 %12 %13 %12 = OpLabel %14 = OpLoad %5 %9 OpBranch %15 %13 = OpLabel %16 = OpLoad %5 %10 OpBranch %15 %15 = OpLabel %17 = OpPhi %14 %12 %16 %13 OpReturn OpFunctionEnd )"; auto context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); ValueNumberTable vtable(context.get()); Instruction* inst1 = context->get_def_use_mgr()->GetDef(14); Instruction* inst2 = context->get_def_use_mgr()->GetDef(16); Instruction* phi = context->get_def_use_mgr()->GetDef(17); EXPECT_NE(vtable.GetValueNumber(inst1), vtable.GetValueNumber(inst2)); EXPECT_NE(vtable.GetValueNumber(inst1), vtable.GetValueNumber(phi)); EXPECT_NE(vtable.GetValueNumber(inst2), vtable.GetValueNumber(phi)); } // Test that a phi node in a loop header gets a new value because one of its // inputs comes from later in the loop. TEST_F(ValueTableTest, PhiLoopTest) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeFloat 32 %6 = OpTypePointer Uniform %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %9 = OpVariable %6 Uniform %10 = OpVariable %6 Uniform %2 = OpFunction %3 None %4 %11 = OpLabel %12 = OpLoad %5 %9 OpSelectionMerge %13 None OpBranchConditional %8 %14 %13 %14 = OpLabel %15 = OpPhi %5 %12 %11 %16 %14 %16 = OpLoad %5 %9 OpLoopMerge %17 %14 None OpBranchConditional %8 %14 %17 %17 = OpLabel OpBranch %13 %13 = OpLabel %18 = OpPhi %5 %12 %11 %16 %17 OpReturn OpFunctionEnd )"; auto context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); ValueNumberTable vtable(context.get()); Instruction* inst1 = context->get_def_use_mgr()->GetDef(12); Instruction* inst2 = context->get_def_use_mgr()->GetDef(16); EXPECT_EQ(vtable.GetValueNumber(inst1), vtable.GetValueNumber(inst2)); Instruction* phi1 = context->get_def_use_mgr()->GetDef(15); EXPECT_NE(vtable.GetValueNumber(inst1), vtable.GetValueNumber(phi1)); Instruction* phi2 = context->get_def_use_mgr()->GetDef(18); EXPECT_EQ(vtable.GetValueNumber(inst1), vtable.GetValueNumber(phi2)); EXPECT_NE(vtable.GetValueNumber(phi1), vtable.GetValueNumber(phi2)); } // Test to make sure that OpPhi instructions with no in operands are handled // correctly. TEST_F(ValueTableTest, EmptyPhiTest) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource GLSL 430 %void = OpTypeVoid %4 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %2 = OpFunction %void None %4 %7 = OpLabel OpSelectionMerge %8 None OpBranchConditional %true %9 %8 %9 = OpLabel OpKill %8 = OpLabel %10 = OpPhi %bool OpReturn OpFunctionEnd )"; auto context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); ValueNumberTable vtable(context.get()); Instruction* inst = context->get_def_use_mgr()->GetDef(10); vtable.GetValueNumber(inst); } TEST_F(ValueTableTest, RedundantSampledImageLoad) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragColor OpExecutionMode %main OriginLowerLeft OpSource GLSL 330 OpName %main "main" OpName %tex0 "tex0" OpName %gl_FragColor "gl_FragColor" OpDecorate %tex0 Location 0 OpDecorate %tex0 DescriptorSet 0 OpDecorate %tex0 Binding 0 OpDecorate %gl_FragColor Location 0 %void = OpTypeVoid %6 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %9 = OpTypeImage %float 2D 0 0 0 1 Unknown %10 = OpTypeSampledImage %9 %_ptr_UniformConstant_10 = OpTypePointer UniformConstant %10 %tex0 = OpVariable %_ptr_UniformConstant_10 UniformConstant %_ptr_Output_v4float = OpTypePointer Output %v4float %13 = OpConstantNull %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output %14 = OpUndef %v4float %main = OpFunction %void None %6 %15 = OpLabel %16 = OpLoad %10 %tex0 %17 = OpImageSampleProjImplicitLod %v4float %16 %13 %18 = OpImageSampleProjImplicitLod %v4float %16 %13 %19 = OpFAdd %v4float %18 %17 OpStore %gl_FragColor %19 OpReturn OpFunctionEnd )"; auto context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); ValueNumberTable vtable(context.get()); Instruction* load1 = context->get_def_use_mgr()->GetDef(17); Instruction* load2 = context->get_def_use_mgr()->GetDef(18); EXPECT_EQ(vtable.GetValueNumber(load1), vtable.GetValueNumber(load2)); } TEST_F(ValueTableTest, DifferentDebugLocalVariableSameValue) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" %2 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %3 "main" OpExecutionMode %3 OriginUpperLeft OpSource GLSL 430 %4 = OpString "test" %5 = OpTypeVoid %6 = OpTypeFunction %5 %7 = OpTypeInt 32 0 %8 = OpConstant %7 32 %9 = OpExtInst %5 %2 DebugSource %4 %10 = OpExtInst %5 %2 DebugCompilationUnit 1 4 %9 HLSL %11 = OpExtInst %5 %2 DebugTypeBasic %4 %8 Float %12 = OpExtInst %5 %2 DebugLocalVariable %4 %11 %9 0 0 %10 FlagIsLocal %13 = OpExtInst %5 %2 DebugLocalVariable %4 %11 %9 0 0 %10 FlagIsLocal %3 = OpFunction %5 None %6 %14 = OpLabel OpReturn OpFunctionEnd )"; auto context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); ValueNumberTable vtable(context.get()); Instruction* inst1 = context->get_def_use_mgr()->GetDef(12); Instruction* inst2 = context->get_def_use_mgr()->GetDef(13); EXPECT_EQ(vtable.GetValueNumber(inst1), vtable.GetValueNumber(inst2)); } TEST_F(ValueTableTest, DifferentDebugValueSameValue) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" %2 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %3 "main" OpExecutionMode %3 OriginUpperLeft OpSource GLSL 430 %4 = OpString "test" %5 = OpTypeVoid %6 = OpTypeFunction %5 %7 = OpTypeInt 32 0 %8 = OpConstant %7 32 %9 = OpExtInst %5 %2 DebugSource %4 %10 = OpExtInst %5 %2 DebugCompilationUnit 1 4 %9 HLSL %11 = OpExtInst %5 %2 DebugTypeBasic %4 %8 Float %12 = OpExtInst %5 %2 DebugLocalVariable %4 %11 %9 0 0 %10 FlagIsLocal %13 = OpExtInst %5 %2 DebugExpression %3 = OpFunction %5 None %6 %14 = OpLabel %15 = OpExtInst %5 %2 DebugValue %12 %8 %13 %16 = OpExtInst %5 %2 DebugValue %12 %8 %13 OpReturn OpFunctionEnd )"; auto context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); ValueNumberTable vtable(context.get()); Instruction* inst1 = context->get_def_use_mgr()->GetDef(15); Instruction* inst2 = context->get_def_use_mgr()->GetDef(16); EXPECT_EQ(vtable.GetValueNumber(inst1), vtable.GetValueNumber(inst2)); } TEST_F(ValueTableTest, DifferentDebugDeclareSameValue) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" %2 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %3 "main" OpExecutionMode %3 OriginUpperLeft OpSource GLSL 430 %4 = OpString "test" %void = OpTypeVoid %6 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_ptr_Function_uint = OpTypePointer Function %uint %uint_32 = OpConstant %uint 32 %10 = OpExtInst %void %2 DebugSource %4 %11 = OpExtInst %void %2 DebugCompilationUnit 1 4 %10 HLSL %12 = OpExtInst %void %2 DebugTypeBasic %4 %uint_32 Float %13 = OpExtInst %void %2 DebugLocalVariable %4 %12 %10 0 0 %11 FlagIsLocal %14 = OpExtInst %void %2 DebugExpression %3 = OpFunction %void None %6 %15 = OpLabel %16 = OpVariable %_ptr_Function_uint Function %17 = OpExtInst %void %2 DebugDeclare %13 %16 %14 %18 = OpExtInst %void %2 DebugDeclare %13 %16 %14 OpReturn OpFunctionEnd )"; auto context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text); ValueNumberTable vtable(context.get()); Instruction* inst1 = context->get_def_use_mgr()->GetDef(17); Instruction* inst2 = context->get_def_use_mgr()->GetDef(18); EXPECT_EQ(vtable.GetValueNumber(inst1), vtable.GetValueNumber(inst2)); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/vector_dce_test.cpp000066400000000000000000001333431475742701700242010ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using VectorDCETest = PassTest<::testing::Test>; TEST_F(VectorDCETest, InsertAfterInsertElim) { // With two insertions to the same offset, the first is dead. // // Note: The SPIR-V assembly has had store/load elimination // performed to allow the inserts and extracts to directly // reference each other. // // #version 450 // // layout (location=0) in float In0; // layout (location=1) in float In1; // layout (location=2) in vec2 In2; // layout (location=0) out vec4 OutColor; // // void main() // { // vec2 v = In2; // v.x = In0 + In1; // dead // v.x = 0.0; // OutColor = v.xyxy; // } const std::string before_predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %In2 %In0 %In1 %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %In2 "In2" OpName %In0 "In0" OpName %In1 "In1" OpName %OutColor "OutColor" OpName %_Globals_ "_Globals_" OpMemberName %_Globals_ 0 "g_b" OpMemberName %_Globals_ 1 "g_n" OpName %_ "" OpDecorate %In2 Location 2 OpDecorate %In0 Location 0 OpDecorate %In1 Location 1 OpDecorate %OutColor Location 0 OpMemberDecorate %_Globals_ 0 Offset 0 OpMemberDecorate %_Globals_ 1 Offset 4 OpDecorate %_Globals_ Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %11 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %_ptr_Function_v2float = OpTypePointer Function %v2float %_ptr_Input_v2float = OpTypePointer Input %v2float %In2 = OpVariable %_ptr_Input_v2float Input %_ptr_Input_float = OpTypePointer Input %float %In0 = OpVariable %_ptr_Input_float Input %In1 = OpVariable %_ptr_Input_float Input %uint = OpTypeInt 32 0 %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %int = OpTypeInt 32 1 %_Globals_ = OpTypeStruct %uint %int %_ptr_Uniform__Globals_ = OpTypePointer Uniform %_Globals_ %_ = OpVariable %_ptr_Uniform__Globals_ Uniform )"; const std::string after_predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %In2 %In0 %In1 %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %In2 "In2" OpName %In0 "In0" OpName %In1 "In1" OpName %OutColor "OutColor" OpName %_Globals_ "_Globals_" OpMemberName %_Globals_ 0 "g_b" OpMemberName %_Globals_ 1 "g_n" OpName %_ "" OpDecorate %In2 Location 2 OpDecorate %In0 Location 0 OpDecorate %In1 Location 1 OpDecorate %OutColor Location 0 OpMemberDecorate %_Globals_ 0 Offset 0 OpMemberDecorate %_Globals_ 1 Offset 4 OpDecorate %_Globals_ Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %10 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %_ptr_Function_v2float = OpTypePointer Function %v2float %_ptr_Input_v2float = OpTypePointer Input %v2float %In2 = OpVariable %_ptr_Input_v2float Input %_ptr_Input_float = OpTypePointer Input %float %In0 = OpVariable %_ptr_Input_float Input %In1 = OpVariable %_ptr_Input_float Input %uint = OpTypeInt 32 0 %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %int = OpTypeInt 32 1 %_Globals_ = OpTypeStruct %uint %int %_ptr_Uniform__Globals_ = OpTypePointer Uniform %_Globals_ %_ = OpVariable %_ptr_Uniform__Globals_ Uniform )"; const std::string before = R"(%main = OpFunction %void None %11 %25 = OpLabel %26 = OpLoad %v2float %In2 %27 = OpLoad %float %In0 %28 = OpLoad %float %In1 %29 = OpFAdd %float %27 %28 %35 = OpCompositeInsert %v2float %29 %26 0 %37 = OpCompositeInsert %v2float %float_0 %35 0 %33 = OpVectorShuffle %v4float %37 %37 0 1 0 1 OpStore %OutColor %33 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %10 %23 = OpLabel %24 = OpLoad %v2float %In2 %25 = OpLoad %float %In0 %26 = OpLoad %float %In1 %27 = OpFAdd %float %25 %26 %28 = OpCompositeInsert %v2float %27 %24 0 %29 = OpCompositeInsert %v2float %float_0 %24 0 %30 = OpVectorShuffle %v4float %29 %29 0 1 0 1 OpStore %OutColor %30 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(before_predefs + before, after_predefs + after, true, true); } TEST_F(VectorDCETest, DeadInsertInChainWithPhi) { // Dead insert eliminated with phi in insertion chain. // // Note: The SPIR-V assembly has had store/load elimination // performed to allow the inserts and extracts to directly // reference each other. // // #version 450 // // layout (location=0) in vec4 In0; // layout (location=1) in float In1; // layout (location=2) in float In2; // layout (location=0) out vec4 OutColor; // // layout(std140, binding = 0 ) uniform _Globals_ // { // bool g_b; // }; // // void main() // { // vec4 v = In0; // v.z = In1 + In2; // if (g_b) v.w = 1.0; // OutColor = vec4(v.x,v.y,0.0,v.w); // } const std::string before_predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %In0 %In1 %In2 %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %In0 "In0" OpName %In1 "In1" OpName %In2 "In2" OpName %_Globals_ "_Globals_" OpMemberName %_Globals_ 0 "g_b" OpName %_ "" OpName %OutColor "OutColor" OpDecorate %In0 Location 0 OpDecorate %In1 Location 1 OpDecorate %In2 Location 2 OpMemberDecorate %_Globals_ 0 Offset 0 OpDecorate %_Globals_ Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %OutColor Location 0 %void = OpTypeVoid %11 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %In0 = OpVariable %_ptr_Input_v4float Input %_ptr_Input_float = OpTypePointer Input %float %In1 = OpVariable %_ptr_Input_float Input %In2 = OpVariable %_ptr_Input_float Input %uint = OpTypeInt 32 0 %_ptr_Function_float = OpTypePointer Function %float %_Globals_ = OpTypeStruct %uint %_ptr_Uniform__Globals_ = OpTypePointer Uniform %_Globals_ %_ = OpVariable %_ptr_Uniform__Globals_ Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %bool = OpTypeBool %uint_0 = OpConstant %uint 0 %float_1 = OpConstant %float 1 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %float_0 = OpConstant %float 0 )"; const std::string after_predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %In0 %In1 %In2 %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %In0 "In0" OpName %In1 "In1" OpName %In2 "In2" OpName %_Globals_ "_Globals_" OpMemberName %_Globals_ 0 "g_b" OpName %_ "" OpName %OutColor "OutColor" OpDecorate %In0 Location 0 OpDecorate %In1 Location 1 OpDecorate %In2 Location 2 OpMemberDecorate %_Globals_ 0 Offset 0 OpDecorate %_Globals_ Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %OutColor Location 0 %void = OpTypeVoid %10 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %In0 = OpVariable %_ptr_Input_v4float Input %_ptr_Input_float = OpTypePointer Input %float %In1 = OpVariable %_ptr_Input_float Input %In2 = OpVariable %_ptr_Input_float Input %uint = OpTypeInt 32 0 %_ptr_Function_float = OpTypePointer Function %float %_Globals_ = OpTypeStruct %uint %_ptr_Uniform__Globals_ = OpTypePointer Uniform %_Globals_ %_ = OpVariable %_ptr_Uniform__Globals_ Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %bool = OpTypeBool %uint_0 = OpConstant %uint 0 %float_1 = OpConstant %float 1 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %float_0 = OpConstant %float 0 )"; const std::string before = R"(%main = OpFunction %void None %11 %31 = OpLabel %32 = OpLoad %v4float %In0 %33 = OpLoad %float %In1 %34 = OpLoad %float %In2 %35 = OpFAdd %float %33 %34 %51 = OpCompositeInsert %v4float %35 %32 2 %37 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %38 = OpLoad %uint %37 %39 = OpINotEqual %bool %38 %uint_0 OpSelectionMerge %40 None OpBranchConditional %39 %41 %40 %41 = OpLabel %53 = OpCompositeInsert %v4float %float_1 %51 3 OpBranch %40 %40 = OpLabel %60 = OpPhi %v4float %51 %31 %53 %41 %55 = OpCompositeExtract %float %60 0 %57 = OpCompositeExtract %float %60 1 %59 = OpCompositeExtract %float %60 3 %49 = OpCompositeConstruct %v4float %55 %57 %float_0 %59 OpStore %OutColor %49 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %10 %27 = OpLabel %28 = OpLoad %v4float %In0 %29 = OpLoad %float %In1 %30 = OpLoad %float %In2 %31 = OpFAdd %float %29 %30 %32 = OpCompositeInsert %v4float %31 %28 2 %33 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %34 = OpLoad %uint %33 %35 = OpINotEqual %bool %34 %uint_0 OpSelectionMerge %36 None OpBranchConditional %35 %37 %36 %37 = OpLabel %38 = OpCompositeInsert %v4float %float_1 %28 3 OpBranch %36 %36 = OpLabel %39 = OpPhi %v4float %28 %27 %38 %37 %40 = OpCompositeExtract %float %39 0 %41 = OpCompositeExtract %float %39 1 %42 = OpCompositeExtract %float %39 3 %43 = OpCompositeConstruct %v4float %40 %41 %float_0 %42 OpStore %OutColor %43 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(before_predefs + before, after_predefs + after, true, true); } TEST_F(VectorDCETest, DeadInsertWithScalars) { // Dead insert which requires two passes to eliminate // // Note: The SPIR-V assembly has had store/load elimination // performed to allow the inserts and extracts to directly // reference each other. // // #version 450 // // layout (location=0) in vec4 In0; // layout (location=1) in float In1; // layout (location=2) in float In2; // layout (location=0) out vec4 OutColor; // // layout(std140, binding = 0 ) uniform _Globals_ // { // bool g_b; // bool g_b2; // }; // // void main() // { // vec4 v1, v2; // v1 = In0; // v1.y = In1 + In2; // dead, second pass // if (g_b) v1.x = 1.0; // v2.x = v1.x; // v2.y = v1.y; // dead, first pass // if (g_b2) v2.x = 0.0; // OutColor = vec4(v2.x,v2.x,0.0,1.0); // } const std::string before_predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %In0 %In1 %In2 %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %In0 "In0" OpName %In1 "In1" OpName %In2 "In2" OpName %_Globals_ "_Globals_" OpMemberName %_Globals_ 0 "g_b" OpMemberName %_Globals_ 1 "g_b2" OpName %_ "" OpName %OutColor "OutColor" OpDecorate %In0 Location 0 OpDecorate %In1 Location 1 OpDecorate %In2 Location 2 OpMemberDecorate %_Globals_ 0 Offset 0 OpMemberDecorate %_Globals_ 1 Offset 4 OpDecorate %_Globals_ Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %OutColor Location 0 %void = OpTypeVoid %10 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %In0 = OpVariable %_ptr_Input_v4float Input %_ptr_Input_float = OpTypePointer Input %float %In1 = OpVariable %_ptr_Input_float Input %In2 = OpVariable %_ptr_Input_float Input %uint = OpTypeInt 32 0 %_Globals_ = OpTypeStruct %uint %uint %_ptr_Uniform__Globals_ = OpTypePointer Uniform %_Globals_ %_ = OpVariable %_ptr_Uniform__Globals_ Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %bool = OpTypeBool %uint_0 = OpConstant %uint 0 %float_1 = OpConstant %float 1 %int_1 = OpConstant %int 1 %float_0 = OpConstant %float 0 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %27 = OpUndef %v4float )"; const std::string after_predefs = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %In0 %In1 %In2 %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %In0 "In0" OpName %In1 "In1" OpName %In2 "In2" OpName %_Globals_ "_Globals_" OpMemberName %_Globals_ 0 "g_b" OpMemberName %_Globals_ 1 "g_b2" OpName %_ "" OpName %OutColor "OutColor" OpDecorate %In0 Location 0 OpDecorate %In1 Location 1 OpDecorate %In2 Location 2 OpMemberDecorate %_Globals_ 0 Offset 0 OpMemberDecorate %_Globals_ 1 Offset 4 OpDecorate %_Globals_ Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %OutColor Location 0 %void = OpTypeVoid %10 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Input_v4float = OpTypePointer Input %v4float %In0 = OpVariable %_ptr_Input_v4float Input %_ptr_Input_float = OpTypePointer Input %float %In1 = OpVariable %_ptr_Input_float Input %In2 = OpVariable %_ptr_Input_float Input %uint = OpTypeInt 32 0 %_Globals_ = OpTypeStruct %uint %uint %_ptr_Uniform__Globals_ = OpTypePointer Uniform %_Globals_ %_ = OpVariable %_ptr_Uniform__Globals_ Uniform %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %bool = OpTypeBool %uint_0 = OpConstant %uint 0 %float_1 = OpConstant %float 1 %int_1 = OpConstant %int 1 %float_0 = OpConstant %float 0 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %27 = OpUndef %v4float %55 = OpUndef %v4float )"; const std::string before = R"(%main = OpFunction %void None %10 %28 = OpLabel %29 = OpLoad %v4float %In0 %30 = OpLoad %float %In1 %31 = OpLoad %float %In2 %32 = OpFAdd %float %30 %31 %33 = OpCompositeInsert %v4float %32 %29 1 %34 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %35 = OpLoad %uint %34 %36 = OpINotEqual %bool %35 %uint_0 OpSelectionMerge %37 None OpBranchConditional %36 %38 %37 %38 = OpLabel %39 = OpCompositeInsert %v4float %float_1 %33 0 OpBranch %37 %37 = OpLabel %40 = OpPhi %v4float %33 %28 %39 %38 %41 = OpCompositeExtract %float %40 0 %42 = OpCompositeInsert %v4float %41 %27 0 %43 = OpCompositeExtract %float %40 1 %44 = OpCompositeInsert %v4float %43 %42 1 %45 = OpAccessChain %_ptr_Uniform_uint %_ %int_1 %46 = OpLoad %uint %45 %47 = OpINotEqual %bool %46 %uint_0 OpSelectionMerge %48 None OpBranchConditional %47 %49 %48 %49 = OpLabel %50 = OpCompositeInsert %v4float %float_0 %44 0 OpBranch %48 %48 = OpLabel %51 = OpPhi %v4float %44 %37 %50 %49 %52 = OpCompositeExtract %float %51 0 %53 = OpCompositeExtract %float %51 0 %54 = OpCompositeConstruct %v4float %52 %53 %float_0 %float_1 OpStore %OutColor %54 OpReturn OpFunctionEnd )"; const std::string after = R"(%main = OpFunction %void None %10 %28 = OpLabel %29 = OpLoad %v4float %In0 %30 = OpLoad %float %In1 %31 = OpLoad %float %In2 %32 = OpFAdd %float %30 %31 %33 = OpCompositeInsert %v4float %32 %29 1 %34 = OpAccessChain %_ptr_Uniform_uint %_ %int_0 %35 = OpLoad %uint %34 %36 = OpINotEqual %bool %35 %uint_0 OpSelectionMerge %37 None OpBranchConditional %36 %38 %37 %38 = OpLabel %39 = OpCompositeInsert %v4float %float_1 %55 0 OpBranch %37 %37 = OpLabel %40 = OpPhi %v4float %29 %28 %39 %38 %41 = OpCompositeExtract %float %40 0 %42 = OpCompositeInsert %v4float %41 %55 0 %43 = OpCompositeExtract %float %40 1 %44 = OpCompositeInsert %v4float %43 %42 1 %45 = OpAccessChain %_ptr_Uniform_uint %_ %int_1 %46 = OpLoad %uint %45 %47 = OpINotEqual %bool %46 %uint_0 OpSelectionMerge %48 None OpBranchConditional %47 %49 %48 %49 = OpLabel %50 = OpCompositeInsert %v4float %float_0 %55 0 OpBranch %48 %48 = OpLabel %51 = OpPhi %v4float %42 %37 %50 %49 %52 = OpCompositeExtract %float %51 0 %53 = OpCompositeExtract %float %51 0 %54 = OpCompositeConstruct %v4float %52 %53 %float_0 %float_1 OpStore %OutColor %54 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(before_predefs + before, after_predefs + after, true, true); } TEST_F(VectorDCETest, InsertObjectLive) { // Make sure that the object being inserted in an OpCompositeInsert // is not removed when it is uses later on. const std::string before = R"(OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %In0 %In1 %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %In0 "In0" OpName %In1 "In1" OpName %OutColor "OutColor" OpDecorate %In0 Location 0 OpDecorate %In1 Location 1 OpDecorate %OutColor Location 0 %void = OpTypeVoid %10 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %In0 = OpVariable %_ptr_Input_v4float Input %_ptr_Input_float = OpTypePointer Input %float %In1 = OpVariable %_ptr_Input_float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %10 %28 = OpLabel %29 = OpLoad %v4float %In0 %30 = OpLoad %float %In1 %33 = OpCompositeInsert %v4float %30 %29 1 OpStore %OutColor %33 OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); SinglePassRunAndCheck(before, before, true, true); } TEST_F(VectorDCETest, DeadInsertInCycle) { // Dead insert in chain with cycle. Demonstrates analysis can handle // cycles in chains going through scalars intermediate values. // // Note: The SPIR-V assembly has had store/load elimination // performed to allow the inserts and extracts to directly // reference each other. // // #version 450 // // layout (location=0) in vec4 In0; // layout (location=1) in float In1; // layout (location=2) in float In2; // layout (location=0) out vec4 OutColor; // // layout(std140, binding = 0 ) uniform _Globals_ // { // int g_n ; // }; // // void main() // { // vec2 v = vec2(0.0, 1.0); // for (int i = 0; i < g_n; i++) { // v.x = v.x + 1; // v.y = v.y * 0.9; // dead // } // OutColor = vec4(v.x); // } const std::string assembly = R"( ; CHECK: [[init_val:%\w+]] = OpConstantComposite %v2float %float_0 %float_1 ; CHECK: [[undef:%\w+]] = OpUndef %v2float ; CHECK: OpFunction ; CHECK: [[entry_lab:%\w+]] = OpLabel ; CHECK: [[loop_header:%\w+]] = OpLabel ; CHECK: OpPhi %v2float [[init_val]] [[entry_lab]] [[x_insert:%\w+]] {{%\w+}} ; CHECK: [[x_insert:%\w+]] = OpCompositeInsert %v2float %43 [[undef]] 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %OutColor %In0 %In1 %In2 OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %_Globals_ "_Globals_" OpMemberName %_Globals_ 0 "g_n" OpName %_ "" OpName %OutColor "OutColor" OpName %In0 "In0" OpName %In1 "In1" OpName %In2 "In2" OpMemberDecorate %_Globals_ 0 Offset 0 OpDecorate %_Globals_ Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %OutColor Location 0 OpDecorate %In0 Location 0 OpDecorate %In1 Location 1 OpDecorate %In2 Location 2 %void = OpTypeVoid %10 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %_ptr_Function_v2float = OpTypePointer Function %v2float %float_0 = OpConstant %float 0 %float_1 = OpConstant %float 1 %16 = OpConstantComposite %v2float %float_0 %float_1 %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %_Globals_ = OpTypeStruct %int %_ptr_Uniform__Globals_ = OpTypePointer Uniform %_Globals_ %_ = OpVariable %_ptr_Uniform__Globals_ Uniform %_ptr_Uniform_int = OpTypePointer Uniform %int %bool = OpTypeBool %float_0_75 = OpConstant %float 0.75 %int_1 = OpConstant %int 1 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %_ptr_Input_v4float = OpTypePointer Input %v4float %In0 = OpVariable %_ptr_Input_v4float Input %_ptr_Input_float = OpTypePointer Input %float %In1 = OpVariable %_ptr_Input_float Input %In2 = OpVariable %_ptr_Input_float Input %main = OpFunction %void None %10 %29 = OpLabel OpBranch %30 %30 = OpLabel %31 = OpPhi %v2float %16 %29 %32 %33 %34 = OpPhi %int %int_0 %29 %35 %33 OpLoopMerge %36 %33 None OpBranch %37 %37 = OpLabel %38 = OpAccessChain %_ptr_Uniform_int %_ %int_0 %39 = OpLoad %int %38 %40 = OpSLessThan %bool %34 %39 OpBranchConditional %40 %41 %36 %41 = OpLabel %42 = OpCompositeExtract %float %31 0 %43 = OpFAdd %float %42 %float_1 %44 = OpCompositeInsert %v2float %43 %31 0 %45 = OpCompositeExtract %float %44 1 %46 = OpFMul %float %45 %float_0_75 %32 = OpCompositeInsert %v2float %46 %44 1 OpBranch %33 %33 = OpLabel %35 = OpIAdd %int %34 %int_1 OpBranch %30 %36 = OpLabel %47 = OpCompositeExtract %float %31 0 %48 = OpCompositeConstruct %v4float %47 %47 %47 %47 OpStore %OutColor %48 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(assembly, true); } TEST_F(VectorDCETest, DeadLoadFeedingCompositeConstruct) { // Detach the loads feeding the CompositeConstruct for the unused elements. // TODO: Implement the rewrite for CompositeConstruct. const std::string assembly = R"( ; CHECK: [[undef:%\w+]] = OpUndef %float ; CHECK: [[ac:%\w+]] = OpAccessChain %_ptr_Input_float %In0 %uint_2 ; CHECK: [[load:%\w+]] = OpLoad %float [[ac]] ; CHECK: OpCompositeConstruct %v3float [[load]] [[undef]] [[undef]] OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %In0 %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpName %main "main" OpName %In0 "In0" OpName %OutColor "OutColor" OpDecorate %In0 Location 0 OpDecorate %OutColor Location 0 %void = OpTypeVoid %6 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %In0 = OpVariable %_ptr_Input_v4float Input %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %v3float = OpTypeVector %float 3 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_20 = OpConstant %int 20 %bool = OpTypeBool %float_1 = OpConstant %float 1 %int_1 = OpConstant %int 1 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %23 = OpUndef %v3float %main = OpFunction %void None %6 %24 = OpLabel %25 = OpAccessChain %_ptr_Input_float %In0 %uint_0 %26 = OpLoad %float %25 %27 = OpAccessChain %_ptr_Input_float %In0 %uint_1 %28 = OpLoad %float %27 %29 = OpAccessChain %_ptr_Input_float %In0 %uint_2 %30 = OpLoad %float %29 %31 = OpCompositeConstruct %v3float %30 %28 %26 OpBranch %32 %32 = OpLabel %33 = OpPhi %v3float %31 %24 %34 %35 %36 = OpPhi %int %int_0 %24 %37 %35 OpLoopMerge %38 %35 None OpBranch %39 %39 = OpLabel %40 = OpSLessThan %bool %36 %int_20 OpBranchConditional %40 %41 %38 %41 = OpLabel %42 = OpCompositeExtract %float %33 0 %43 = OpFAdd %float %42 %float_1 %34 = OpCompositeInsert %v3float %43 %33 0 OpBranch %35 %35 = OpLabel %37 = OpIAdd %int %36 %int_1 OpBranch %32 %38 = OpLabel %44 = OpCompositeExtract %float %33 0 %45 = OpCompositeConstruct %v4float %44 %44 %44 %44 OpStore %OutColor %45 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(assembly, true); } TEST_F(VectorDCETest, DeadLoadFeedingVectorShuffle) { // Detach the loads feeding the CompositeConstruct for the unused elements. // TODO: Implement the rewrite for CompositeConstruct. const std::string assembly = R"( ; MemPass Type2Undef does not reuse and already existing undef. ; CHECK: {{%\w+}} = OpUndef %v3float ; CHECK: [[undef:%\w+]] = OpUndef %v3float ; CHECK: OpFunction ; CHECK: OpVectorShuffle %v3float {{%\w+}} [[undef]] 0 4 5 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %In0 %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpName %main "main" OpName %In0 "In0" OpName %OutColor "OutColor" OpDecorate %In0 Location 0 OpDecorate %OutColor Location 0 %void = OpTypeVoid %6 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %In0 = OpVariable %_ptr_Input_v4float Input %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %v3float = OpTypeVector %float 3 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_20 = OpConstant %int 20 %bool = OpTypeBool %float_1 = OpConstant %float 1 %vec_const = OpConstantComposite %v3float %float_1 %float_1 %float_1 %int_1 = OpConstant %int 1 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %23 = OpUndef %v3float %main = OpFunction %void None %6 %24 = OpLabel %25 = OpAccessChain %_ptr_Input_float %In0 %uint_0 %26 = OpLoad %float %25 %27 = OpAccessChain %_ptr_Input_float %In0 %uint_1 %28 = OpLoad %float %27 %29 = OpAccessChain %_ptr_Input_float %In0 %uint_2 %30 = OpLoad %float %29 %31 = OpCompositeConstruct %v3float %30 %28 %26 %sh = OpVectorShuffle %v3float %vec_const %31 0 4 5 OpBranch %32 %32 = OpLabel %33 = OpPhi %v3float %sh %24 %34 %35 %36 = OpPhi %int %int_0 %24 %37 %35 OpLoopMerge %38 %35 None OpBranch %39 %39 = OpLabel %40 = OpSLessThan %bool %36 %int_20 OpBranchConditional %40 %41 %38 %41 = OpLabel %42 = OpCompositeExtract %float %33 0 %43 = OpFAdd %float %42 %float_1 %34 = OpCompositeInsert %v3float %43 %33 0 OpBranch %35 %35 = OpLabel %37 = OpIAdd %int %36 %int_1 OpBranch %32 %38 = OpLabel %44 = OpCompositeExtract %float %33 0 %45 = OpCompositeConstruct %v4float %44 %44 %44 %44 OpStore %OutColor %45 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(assembly, true); } TEST_F(VectorDCETest, DeadInstThroughShuffle) { // Dead insert in chain with cycle. Demonstrates analysis can handle // cycles in chains. // // Note: The SPIR-V assembly has had store/load elimination // performed to allow the inserts and extracts to directly // reference each other. // // #version 450 // // layout (location=0) out vec4 OutColor; // // void main() // { // vec2 v; // v.x = 0.0; // v.y = 0.1; // dead // for (int i = 0; i < 20; i++) { // v.x = v.x + 1; // v = v * 0.9; // } // OutColor = vec4(v.x); // } const std::string assembly = R"( ; CHECK: OpFunction ; CHECK-NOT: OpCompositeInsert %v2float {{%\w+}} 1 ; CHECK: OpFunctionEnd OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpName %main "main" OpName %OutColor "OutColor" OpDecorate %OutColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %float_0 = OpConstant %float 0 %float_0_100000001 = OpConstant %float 0.100000001 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_20 = OpConstant %int 20 %bool = OpTypeBool %float_1 = OpConstant %float 1 %float_0_899999976 = OpConstant %float 0.899999976 %int_1 = OpConstant %int 1 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %58 = OpUndef %v2float %main = OpFunction %void None %3 %5 = OpLabel %49 = OpCompositeInsert %v2float %float_0 %58 0 %51 = OpCompositeInsert %v2float %float_0_100000001 %49 1 OpBranch %22 %22 = OpLabel %60 = OpPhi %v2float %51 %5 %38 %25 %59 = OpPhi %int %int_0 %5 %41 %25 OpLoopMerge %24 %25 None OpBranch %26 %26 = OpLabel %30 = OpSLessThan %bool %59 %int_20 OpBranchConditional %30 %23 %24 %23 = OpLabel %53 = OpCompositeExtract %float %60 0 %34 = OpFAdd %float %53 %float_1 %55 = OpCompositeInsert %v2float %34 %60 0 %38 = OpVectorTimesScalar %v2float %55 %float_0_899999976 OpBranch %25 %25 = OpLabel %41 = OpIAdd %int %59 %int_1 OpBranch %22 %24 = OpLabel %57 = OpCompositeExtract %float %60 0 %47 = OpCompositeConstruct %v4float %57 %57 %57 %57 OpStore %OutColor %47 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(assembly, true); } TEST_F(VectorDCETest, DeadInsertThroughOtherInst) { // Dead insert in chain with cycle. Demonstrates analysis can handle // cycles in chains. // // Note: The SPIR-V assembly has had store/load elimination // performed to allow the inserts and extracts to directly // reference each other. // // #version 450 // // layout (location=0) out vec4 OutColor; // // void main() // { // vec2 v; // v.x = 0.0; // v.y = 0.1; // dead // for (int i = 0; i < 20; i++) { // v.x = v.x + 1; // v = v * 0.9; // } // OutColor = vec4(v.x); // } const std::string assembly = R"( ; CHECK: OpFunction ; CHECK-NOT: OpCompositeInsert %v2float {{%\w+}} 1 ; CHECK: OpFunctionEnd OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpName %main "main" OpName %OutColor "OutColor" OpDecorate %OutColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %float_0 = OpConstant %float 0 %float_0_100000001 = OpConstant %float 0.100000001 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_20 = OpConstant %int 20 %bool = OpTypeBool %float_1 = OpConstant %float 1 %float_0_899999976 = OpConstant %float 0.899999976 %int_1 = OpConstant %int 1 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %58 = OpUndef %v2float %main = OpFunction %void None %3 %5 = OpLabel %49 = OpCompositeInsert %v2float %float_0 %58 0 %51 = OpCompositeInsert %v2float %float_0_100000001 %49 1 OpBranch %22 %22 = OpLabel %60 = OpPhi %v2float %51 %5 %38 %25 %59 = OpPhi %int %int_0 %5 %41 %25 OpLoopMerge %24 %25 None OpBranch %26 %26 = OpLabel %30 = OpSLessThan %bool %59 %int_20 OpBranchConditional %30 %23 %24 %23 = OpLabel %53 = OpCompositeExtract %float %60 0 %34 = OpFAdd %float %53 %float_1 %55 = OpCompositeInsert %v2float %34 %60 0 %38 = OpVectorTimesScalar %v2float %55 %float_0_899999976 OpBranch %25 %25 = OpLabel %41 = OpIAdd %int %59 %int_1 OpBranch %22 %24 = OpLabel %57 = OpCompositeExtract %float %60 0 %47 = OpCompositeConstruct %v4float %57 %57 %57 %57 OpStore %OutColor %47 OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(assembly, true); } TEST_F(VectorDCETest, VectorIntoCompositeConstruct) { const std::string text = R"(OpCapability Linkage OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "EntryPoint_Main" %2 %3 OpExecutionMode %1 OriginUpperLeft OpDecorate %2 Location 0 OpDecorate %_struct_4 Block OpDecorate %3 Location 0 %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %_ptr_Function_v2float = OpTypePointer Function %v2float %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %mat4v4float = OpTypeMatrix %v4float 4 %_ptr_Function_mat4v4float = OpTypePointer Function %mat4v4float %v3float = OpTypeVector %float 3 %_ptr_Function_v3float = OpTypePointer Function %v3float %_struct_14 = OpTypeStruct %v2float %mat4v4float %v3float %v2float %v4float %_ptr_Function__struct_14 = OpTypePointer Function %_struct_14 %void = OpTypeVoid %int = OpTypeInt 32 1 %int_2 = OpConstant %int 2 %int_1 = OpConstant %int 1 %int_4 = OpConstant %int 4 %int_0 = OpConstant %int 0 %int_3 = OpConstant %int 3 %float_0 = OpConstant %float 0 %float_1 = OpConstant %float 1 %_ptr_Input_v2float = OpTypePointer Input %v2float %2 = OpVariable %_ptr_Input_v2float Input %_ptr_Output_v2float = OpTypePointer Output %v2float %_struct_4 = OpTypeStruct %v2float %_ptr_Output__struct_4 = OpTypePointer Output %_struct_4 %3 = OpVariable %_ptr_Output__struct_4 Output %28 = OpTypeFunction %void %29 = OpConstantComposite %v2float %float_0 %float_0 %30 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %31 = OpConstantComposite %mat4v4float %30 %30 %30 %30 %32 = OpConstantComposite %v3float %float_0 %float_0 %float_0 %1 = OpFunction %void None %28 %33 = OpLabel %34 = OpVariable %_ptr_Function_v4float Function %35 = OpVariable %_ptr_Function__struct_14 Function %36 = OpAccessChain %_ptr_Function_v2float %35 %int_0 OpStore %36 %29 %37 = OpAccessChain %_ptr_Function_mat4v4float %35 %int_1 OpStore %37 %31 %38 = OpAccessChain %_ptr_Function_v3float %35 %int_2 OpStore %38 %32 %39 = OpAccessChain %_ptr_Function_v2float %35 %int_3 OpStore %39 %29 %40 = OpAccessChain %_ptr_Function_v4float %35 %int_4 OpStore %40 %30 %41 = OpLoad %v2float %2 OpStore %36 %41 %42 = OpLoad %v3float %38 %43 = OpCompositeConstruct %v4float %42 %float_1 %44 = OpLoad %mat4v4float %37 %45 = OpVectorTimesMatrix %v4float %43 %44 OpStore %34 %45 OpCopyMemory %40 %34 OpCopyMemory %36 %39 %46 = OpAccessChain %_ptr_Output_v2float %3 %int_0 %47 = OpLoad %v2float %36 OpStore %46 %47 OpReturn OpFunctionEnd )"; SinglePassRunAndCheck(text, text, true, true); } TEST_F(VectorDCETest, NotAffectedByDebugValue) { // It tests that an OpenCL.DebugInfo.100 DebugValue instruction does // not change the vector DCE pass result. If the composite used for // the value of DebugValue is killed, the DebugValue must be killed as well. const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" %ext = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %In2 %In0 %In1 %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 %file_name = OpString "test" %float_name = OpString "float" %main_name = OpString "main" %f_name = OpString "f" OpName %main "main" OpName %In2 "In2" OpName %In0 "In0" OpName %In1 "In1" OpName %OutColor "OutColor" OpName %_Globals_ "_Globals_" OpMemberName %_Globals_ 0 "g_b" OpMemberName %_Globals_ 1 "g_n" OpName %_ "" OpDecorate %In2 Location 2 OpDecorate %In0 Location 0 OpDecorate %In1 Location 1 OpDecorate %OutColor Location 0 OpMemberDecorate %_Globals_ 0 Offset 0 OpMemberDecorate %_Globals_ 1 Offset 4 OpDecorate %_Globals_ Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 %void = OpTypeVoid %11 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %_ptr_Function_v2float = OpTypePointer Function %v2float %_ptr_Input_v2float = OpTypePointer Input %v2float %In2 = OpVariable %_ptr_Input_v2float Input %_ptr_Input_float = OpTypePointer Input %float %In0 = OpVariable %_ptr_Input_float Input %In1 = OpVariable %_ptr_Input_float Input %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %_ptr_Function_float = OpTypePointer Function %float %float_0 = OpConstant %float 0 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %int = OpTypeInt 32 1 %_Globals_ = OpTypeStruct %uint %int %_ptr_Uniform__Globals_ = OpTypePointer Uniform %_Globals_ %_ = OpVariable %_ptr_Uniform__Globals_ Uniform %null_expr = OpExtInst %void %ext DebugExpression %src = OpExtInst %void %ext DebugSource %file_name %cu = OpExtInst %void %ext DebugCompilationUnit 1 4 %src HLSL %dbg_tf = OpExtInst %void %ext DebugTypeBasic %float_name %uint_32 Float %main_ty = OpExtInst %void %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %dbg_tf %dbg_main = OpExtInst %void %ext DebugFunction %main_name %main_ty %src 0 0 %cu %main_name FlagIsProtected|FlagIsPrivate 10 %main %dbg_f = OpExtInst %void %ext DebugLocalVariable %f_name %dbg_tf %src 0 0 %dbg_main FlagIsLocal %main = OpFunction %void None %11 %25 = OpLabel %s = OpExtInst %void %ext DebugScope %dbg_main ; CHECK: [[in2:%\w+]] = OpLoad %v2float %In2 %26 = OpLoad %v2float %In2 %27 = OpLoad %float %In0 %28 = OpLoad %float %In1 %29 = OpFAdd %float %27 %28 ; CHECK: OpCompositeInsert %v2float {{%\w+}} [[in2]] 0 ; CHECK-NEXT: OpCompositeInsert %v2float {{%\w+}} [[in2]] 0 ; CHECK-NOT: DebugValue %35 = OpCompositeInsert %v2float %29 %26 0 %value = OpExtInst %void %ext DebugValue %dbg_f %35 %null_expr %37 = OpCompositeInsert %v2float %float_0 %35 0 %33 = OpVectorShuffle %v4float %37 %37 0 1 0 1 OpStore %OutColor %33 OpReturn OpFunctionEnd )"; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); SinglePassRunAndMatch(text, true); } TEST_F(VectorDCETest, RemoveDebugValueUsesKilledInstr) { // It tests that the vector DCE pass removes the OpenCL.DebugInfo.100 // DebugValue instruction using a killed instruction. const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" %ext = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %In0 %OutColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 %file_name = OpString "test" %float_name = OpString "float" %main_name = OpString "main" %f_name = OpString "f" OpSourceExtension "GL_GOOGLE_cpp_style_line_directive" OpSourceExtension "GL_GOOGLE_include_directive" OpName %main "main" OpName %In0 "In0" OpName %OutColor "OutColor" OpDecorate %In0 Location 0 OpDecorate %OutColor Location 0 %void = OpTypeVoid %6 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %In0 = OpVariable %_ptr_Input_v4float Input %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_32 = OpConstant %uint 32 %_ptr_Input_float = OpTypePointer Input %float %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %v3float = OpTypeVector %float 3 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_20 = OpConstant %int 20 %bool = OpTypeBool %float_1 = OpConstant %float 1 %int_1 = OpConstant %int 1 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %23 = OpUndef %v3float %null_expr = OpExtInst %void %ext DebugExpression %src = OpExtInst %void %ext DebugSource %file_name %cu = OpExtInst %void %ext DebugCompilationUnit 1 4 %src HLSL %dbg_tf = OpExtInst %void %ext DebugTypeBasic %float_name %uint_32 Float %main_ty = OpExtInst %void %ext DebugTypeFunction FlagIsProtected|FlagIsPrivate %dbg_tf %dbg_main = OpExtInst %void %ext DebugFunction %main_name %main_ty %src 0 0 %cu %main_name FlagIsProtected|FlagIsPrivate 10 %main %dbg_f = OpExtInst %void %ext DebugLocalVariable %f_name %dbg_tf %src 0 0 %dbg_main FlagIsLocal %main = OpFunction %void None %6 %24 = OpLabel %s0 = OpExtInst %void %ext DebugScope %dbg_main %25 = OpAccessChain %_ptr_Input_float %In0 %uint_0 %26 = OpLoad %float %25 %27 = OpAccessChain %_ptr_Input_float %In0 %uint_1 %28 = OpLoad %float %27 ; CHECK: [[undef:%\w+]] = OpUndef %float ; CHECK-NOT: DebugValue %value = OpExtInst %void %ext DebugValue %dbg_f %28 %null_expr %29 = OpAccessChain %_ptr_Input_float %In0 %uint_2 %30 = OpLoad %float %29 ; CHECK: [[composite:%\w+]] = OpCompositeConstruct %v3float {{%\w+}} [[undef]] [[undef]] ; CHECK-NEXT: DebugValue {{%\w+}} [[composite]] %31 = OpCompositeConstruct %v3float %30 %28 %26 %value_live = OpExtInst %void %ext DebugValue %dbg_f %31 %null_expr OpBranch %32 %32 = OpLabel %s1 = OpExtInst %void %ext DebugScope %dbg_main %33 = OpPhi %v3float %31 %24 %34 %35 %36 = OpPhi %int %int_0 %24 %37 %35 OpLoopMerge %38 %35 None OpBranch %39 %39 = OpLabel %s2 = OpExtInst %void %ext DebugScope %dbg_main %40 = OpSLessThan %bool %36 %int_20 OpBranchConditional %40 %41 %38 %41 = OpLabel %s3 = OpExtInst %void %ext DebugScope %dbg_main %42 = OpCompositeExtract %float %33 0 %43 = OpFAdd %float %42 %float_1 %34 = OpCompositeInsert %v3float %43 %33 0 OpBranch %35 %35 = OpLabel %s4 = OpExtInst %void %ext DebugScope %dbg_main %37 = OpIAdd %int %36 %int_1 OpBranch %32 %38 = OpLabel %s5 = OpExtInst %void %ext DebugScope %dbg_main %44 = OpCompositeExtract %float %33 0 %45 = OpCompositeConstruct %v4float %44 %44 %44 %44 OpStore %OutColor %45 OpReturn OpFunctionEnd )"; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); SinglePassRunAndMatch(text, true); } TEST_F(VectorDCETest, OutOfBoundsExtract) { // It tests that the vector DCE pass is able to handle an extract with an // index that is out of bounds. const std::string text = R"( ; CHECK: [[undef:%\w+]] = OpUndef %v4float ; CHECK: OpCompositeExtract %float [[undef]] 8 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %OutColor OpExecutionMode %main OriginUpperLeft OpDecorate %OutColor Location 0 %void = OpTypeVoid %10 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_float = OpTypePointer Output %float %OutColor = OpVariable %_ptr_Output_float Output %null = OpConstantNull %v4float %float_1 = OpConstant %float 1 %main = OpFunction %void None %10 %28 = OpLabel %33 = OpCompositeInsert %v4float %float_1 %null 1 %extract = OpCompositeExtract %float %33 8 OpStore %OutColor %extract OpReturn OpFunctionEnd )"; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); SinglePassRunAndMatch(text, false); } TEST_F(VectorDCETest, OutOfBoundsShuffle) { // It tests that the vector DCE pass is able to handle a shuffle with an // index that is out of bounds. const std::string text = R"( ; CHECK: [[undef:%\w+]] = OpUndef %v4float ; CHECK: OpVectorShuffle %v4float [[undef]] [[undef]] 9 10 11 12 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %OutColor OpExecutionMode %main OriginUpperLeft OpDecorate %OutColor Location 0 %void = OpTypeVoid %10 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %OutColor = OpVariable %_ptr_Output_v4float Output %null = OpConstantNull %v4float %float_1 = OpConstant %float 1 %main = OpFunction %void None %10 %28 = OpLabel %33 = OpCompositeInsert %v4float %float_1 %null 1 %shuffle = OpVectorShuffle %v4float %33 %33 9 10 11 12 OpStore %OutColor %shuffle OpReturn OpFunctionEnd )"; SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); SinglePassRunAndMatch(text, false); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/workaround1209_test.cpp000066400000000000000000000367441475742701700246020ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using Workaround1209Test = PassTest<::testing::Test>; TEST_F(Workaround1209Test, RemoveOpUnreachableInLoop) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %texcoord %gl_VertexIndex %_ OpSource GLSL 400 OpSourceExtension "GL_ARB_separate_shader_objects" OpSourceExtension "GL_ARB_shading_language_420pack" OpName %main "main" OpName %texcoord "texcoord" OpName %buf "buf" OpMemberName %buf 0 "MVP" OpMemberName %buf 1 "position" OpMemberName %buf 2 "attr" OpName %ubuf "ubuf" OpName %gl_VertexIndex "gl_VertexIndex" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpName %_ "" OpDecorate %texcoord Location 0 OpDecorate %_arr_v4float_uint_72 ArrayStride 16 OpDecorate %_arr_v4float_uint_72_0 ArrayStride 16 OpMemberDecorate %buf 0 ColMajor OpMemberDecorate %buf 0 Offset 0 OpMemberDecorate %buf 0 MatrixStride 16 OpMemberDecorate %buf 1 Offset 64 OpMemberDecorate %buf 2 Offset 1216 OpDecorate %buf Block OpDecorate %ubuf DescriptorSet 0 OpDecorate %ubuf Binding 0 OpDecorate %gl_VertexIndex BuiltIn VertexIndex OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpDecorate %gl_PerVertex Block %void = OpTypeVoid %12 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %texcoord = OpVariable %_ptr_Output_v4float Output %mat4v4float = OpTypeMatrix %v4float 4 %uint = OpTypeInt 32 0 %uint_72 = OpConstant %uint 72 %_arr_v4float_uint_72 = OpTypeArray %v4float %uint_72 %_arr_v4float_uint_72_0 = OpTypeArray %v4float %uint_72 %buf = OpTypeStruct %mat4v4float %_arr_v4float_uint_72 %_arr_v4float_uint_72_0 %_ptr_Uniform_buf = OpTypePointer Uniform %buf %ubuf = OpVariable %_ptr_Uniform_buf Uniform %int = OpTypeInt 32 1 %int_2 = OpConstant %int 2 %_ptr_Input_int = OpTypePointer Input %int %gl_VertexIndex = OpVariable %_ptr_Input_int Input %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %gl_PerVertex = OpTypeStruct %v4float %_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex %_ = OpVariable %_ptr_Output_gl_PerVertex Output %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %float_1 = OpConstant %float 1 %28 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %main = OpFunction %void None %12 %29 = OpLabel OpBranch %30 %30 = OpLabel ; CHECK: OpLoopMerge [[merge:%[a-zA-Z_\d]+]] OpLoopMerge %31 %32 None OpBranch %33 %33 = OpLabel ; CHECK: OpSelectionMerge [[sel_merge:%[a-zA-Z_\d]+]] OpSelectionMerge %34 None OpSwitch %int_1 %35 %35 = OpLabel %36 = OpLoad %int %gl_VertexIndex %37 = OpAccessChain %_ptr_Uniform_v4float %ubuf %int_2 %36 %38 = OpLoad %v4float %37 OpStore %texcoord %38 %39 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %39 %28 OpBranch %31 ; CHECK: [[sel_merge]] = OpLabel %34 = OpLabel ; CHECK-NEXT: OpBranch [[merge]] OpUnreachable %32 = OpLabel OpBranch %30 %31 = OpLabel OpReturn OpFunctionEnd)"; SinglePassRunAndMatch(text, false); } TEST_F(Workaround1209Test, RemoveOpUnreachableInNestedLoop) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %2 "main" %3 %4 %5 OpSource GLSL 400 OpSourceExtension "GL_ARB_separate_shader_objects" OpSourceExtension "GL_ARB_shading_language_420pack" OpName %2 "main" OpName %3 "texcoord" OpName %6 "buf" OpMemberName %6 0 "MVP" OpMemberName %6 1 "position" OpMemberName %6 2 "attr" OpName %7 "ubuf" OpName %4 "gl_VertexIndex" OpName %8 "gl_PerVertex" OpMemberName %8 0 "gl_Position" OpName %5 "" OpDecorate %3 Location 0 OpDecorate %9 ArrayStride 16 OpDecorate %10 ArrayStride 16 OpMemberDecorate %6 0 ColMajor OpMemberDecorate %6 0 Offset 0 OpMemberDecorate %6 0 MatrixStride 16 OpMemberDecorate %6 1 Offset 64 OpMemberDecorate %6 2 Offset 1216 OpDecorate %6 Block OpDecorate %7 DescriptorSet 0 OpDecorate %7 Binding 0 OpDecorate %4 BuiltIn VertexIndex OpMemberDecorate %8 0 BuiltIn Position OpDecorate %8 Block %11 = OpTypeVoid %12 = OpTypeFunction %11 %13 = OpTypeFloat 32 %14 = OpTypeVector %13 4 %15 = OpTypePointer Output %14 %3 = OpVariable %15 Output %16 = OpTypeMatrix %14 4 %17 = OpTypeInt 32 0 %18 = OpConstant %17 72 %9 = OpTypeArray %14 %18 %10 = OpTypeArray %14 %18 %6 = OpTypeStruct %16 %9 %10 %19 = OpTypePointer Uniform %6 %7 = OpVariable %19 Uniform %20 = OpTypeInt 32 1 %21 = OpConstant %20 2 %22 = OpTypePointer Input %20 %4 = OpVariable %22 Input %23 = OpTypePointer Uniform %14 %8 = OpTypeStruct %14 %24 = OpTypePointer Output %8 %5 = OpVariable %24 Output %25 = OpConstant %20 0 %26 = OpConstant %20 1 %27 = OpConstant %13 1 %28 = OpConstantComposite %14 %27 %27 %27 %27 %2 = OpFunction %11 None %12 %29 = OpLabel OpBranch %31 %31 = OpLabel ; CHECK: OpLoopMerge OpLoopMerge %32 %33 None OpBranch %30 %30 = OpLabel ; CHECK: OpLoopMerge [[merge:%[a-zA-Z_\d]+]] OpLoopMerge %34 %35 None OpBranch %36 %36 = OpLabel ; CHECK: OpSelectionMerge [[sel_merge:%[a-zA-Z_\d]+]] OpSelectionMerge %37 None OpSwitch %26 %38 %38 = OpLabel %39 = OpLoad %20 %4 %40 = OpAccessChain %23 %7 %21 %39 %41 = OpLoad %14 %40 OpStore %3 %41 %42 = OpAccessChain %15 %5 %25 OpStore %42 %28 OpBranch %34 ; CHECK: [[sel_merge]] = OpLabel %37 = OpLabel ; CHECK-NEXT: OpBranch [[merge]] OpUnreachable %35 = OpLabel OpBranch %30 %34 = OpLabel OpBranch %32 %33 = OpLabel OpBranch %31 %32 = OpLabel OpReturn OpFunctionEnd)"; SinglePassRunAndMatch(text, false); } TEST_F(Workaround1209Test, RemoveOpUnreachableInAdjacentLoops) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %2 "main" %3 %4 %5 OpSource GLSL 400 OpSourceExtension "GL_ARB_separate_shader_objects" OpSourceExtension "GL_ARB_shading_language_420pack" OpName %2 "main" OpName %3 "texcoord" OpName %6 "buf" OpMemberName %6 0 "MVP" OpMemberName %6 1 "position" OpMemberName %6 2 "attr" OpName %7 "ubuf" OpName %4 "gl_VertexIndex" OpName %8 "gl_PerVertex" OpMemberName %8 0 "gl_Position" OpName %5 "" OpDecorate %3 Location 0 OpDecorate %9 ArrayStride 16 OpDecorate %10 ArrayStride 16 OpMemberDecorate %6 0 ColMajor OpMemberDecorate %6 0 Offset 0 OpMemberDecorate %6 0 MatrixStride 16 OpMemberDecorate %6 1 Offset 64 OpMemberDecorate %6 2 Offset 1216 OpDecorate %6 Block OpDecorate %7 DescriptorSet 0 OpDecorate %7 Binding 0 OpDecorate %4 BuiltIn VertexIndex OpMemberDecorate %8 0 BuiltIn Position OpDecorate %8 Block %11 = OpTypeVoid %12 = OpTypeFunction %11 %13 = OpTypeFloat 32 %14 = OpTypeVector %13 4 %15 = OpTypePointer Output %14 %3 = OpVariable %15 Output %16 = OpTypeMatrix %14 4 %17 = OpTypeInt 32 0 %18 = OpConstant %17 72 %9 = OpTypeArray %14 %18 %10 = OpTypeArray %14 %18 %6 = OpTypeStruct %16 %9 %10 %19 = OpTypePointer Uniform %6 %7 = OpVariable %19 Uniform %20 = OpTypeInt 32 1 %21 = OpConstant %20 2 %22 = OpTypePointer Input %20 %4 = OpVariable %22 Input %23 = OpTypePointer Uniform %14 %8 = OpTypeStruct %14 %24 = OpTypePointer Output %8 %5 = OpVariable %24 Output %25 = OpConstant %20 0 %26 = OpConstant %20 1 %27 = OpConstant %13 1 %28 = OpConstantComposite %14 %27 %27 %27 %27 %2 = OpFunction %11 None %12 %29 = OpLabel OpBranch %30 %30 = OpLabel ; CHECK: OpLoopMerge [[merge1:%[a-zA-Z_\d]+]] OpLoopMerge %31 %32 None OpBranch %33 %33 = OpLabel ; CHECK: OpSelectionMerge [[sel_merge1:%[a-zA-Z_\d]+]] OpSelectionMerge %34 None OpSwitch %26 %35 %35 = OpLabel %36 = OpLoad %20 %4 %37 = OpAccessChain %23 %7 %21 %36 %38 = OpLoad %14 %37 OpStore %3 %38 %39 = OpAccessChain %15 %5 %25 OpStore %39 %28 OpBranch %31 ; CHECK: [[sel_merge1]] = OpLabel %34 = OpLabel ; CHECK-NEXT: OpBranch [[merge1]] OpUnreachable %32 = OpLabel OpBranch %30 %31 = OpLabel ; CHECK: OpLoopMerge [[merge2:%[a-zA-Z_\d]+]] OpLoopMerge %40 %41 None OpBranch %42 %42 = OpLabel ; CHECK: OpSelectionMerge [[sel_merge2:%[a-zA-Z_\d]+]] OpSelectionMerge %43 None OpSwitch %26 %44 %44 = OpLabel %45 = OpLoad %20 %4 %46 = OpAccessChain %23 %7 %21 %45 %47 = OpLoad %14 %46 OpStore %3 %47 %48 = OpAccessChain %15 %5 %25 OpStore %48 %28 OpBranch %40 ; CHECK: [[sel_merge2]] = OpLabel %43 = OpLabel ; CHECK-NEXT: OpBranch [[merge2]] OpUnreachable %41 = OpLabel OpBranch %31 %40 = OpLabel OpReturn OpFunctionEnd)"; SinglePassRunAndMatch(text, false); } TEST_F(Workaround1209Test, LeaveUnreachableNotInLoop) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %texcoord %gl_VertexIndex %_ OpSource GLSL 400 OpSourceExtension "GL_ARB_separate_shader_objects" OpSourceExtension "GL_ARB_shading_language_420pack" OpName %main "main" OpName %texcoord "texcoord" OpName %buf "buf" OpMemberName %buf 0 "MVP" OpMemberName %buf 1 "position" OpMemberName %buf 2 "attr" OpName %ubuf "ubuf" OpName %gl_VertexIndex "gl_VertexIndex" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpName %_ "" OpDecorate %texcoord Location 0 OpDecorate %_arr_v4float_uint_72 ArrayStride 16 OpDecorate %_arr_v4float_uint_72_0 ArrayStride 16 OpMemberDecorate %buf 0 ColMajor OpMemberDecorate %buf 0 Offset 0 OpMemberDecorate %buf 0 MatrixStride 16 OpMemberDecorate %buf 1 Offset 64 OpMemberDecorate %buf 2 Offset 1216 OpDecorate %buf Block OpDecorate %ubuf DescriptorSet 0 OpDecorate %ubuf Binding 0 OpDecorate %gl_VertexIndex BuiltIn VertexIndex OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpDecorate %gl_PerVertex Block %void = OpTypeVoid %12 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %texcoord = OpVariable %_ptr_Output_v4float Output %mat4v4float = OpTypeMatrix %v4float 4 %uint = OpTypeInt 32 0 %uint_72 = OpConstant %uint 72 %_arr_v4float_uint_72 = OpTypeArray %v4float %uint_72 %_arr_v4float_uint_72_0 = OpTypeArray %v4float %uint_72 %buf = OpTypeStruct %mat4v4float %_arr_v4float_uint_72 %_arr_v4float_uint_72_0 %_ptr_Uniform_buf = OpTypePointer Uniform %buf %ubuf = OpVariable %_ptr_Uniform_buf Uniform %int = OpTypeInt 32 1 %int_2 = OpConstant %int 2 %_ptr_Input_int = OpTypePointer Input %int %gl_VertexIndex = OpVariable %_ptr_Input_int Input %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %gl_PerVertex = OpTypeStruct %v4float %_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex %_ = OpVariable %_ptr_Output_gl_PerVertex Output %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %float_1 = OpConstant %float 1 %28 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %main = OpFunction %void None %12 %29 = OpLabel OpBranch %30 %30 = OpLabel OpSelectionMerge %34 None OpSwitch %int_1 %35 %35 = OpLabel %36 = OpLoad %int %gl_VertexIndex %37 = OpAccessChain %_ptr_Uniform_v4float %ubuf %int_2 %36 %38 = OpLoad %v4float %37 OpStore %texcoord %38 %39 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %39 %28 OpReturn %34 = OpLabel ; CHECK: OpUnreachable OpUnreachable OpFunctionEnd)"; SinglePassRunAndMatch(text, false); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/opt/wrap_opkill_test.cpp000066400000000000000000000703251475742701700244070ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "test/opt/assembly_builder.h" #include "test/opt/pass_fixture.h" #include "test/opt/pass_utils.h" namespace spvtools { namespace opt { namespace { using WrapOpKillTest = PassTest<::testing::Test>; TEST_F(WrapOpKillTest, SingleOpKill) { const std::string text = R"( ; CHECK: OpEntryPoint Fragment [[main:%\w+]] ; CHECK: [[main]] = OpFunction ; CHECK: OpFunctionCall %void [[orig_kill:%\w+]] ; CHECK: [[orig_kill]] = OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpFunctionCall %void [[new_kill:%\w+]] ; CHECK-NEXT: OpReturn ; CHECK: [[new_kill]] = OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpKill ; CHECK-NEXT: OpFunctionEnd OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 330 OpName %main "main" %void = OpTypeVoid %5 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %main = OpFunction %void None %5 %8 = OpLabel OpBranch %9 %9 = OpLabel OpLoopMerge %10 %11 None OpBranch %12 %12 = OpLabel OpBranchConditional %true %13 %10 %13 = OpLabel OpBranch %11 %11 = OpLabel %14 = OpFunctionCall %void %kill_ OpBranch %9 %10 = OpLabel OpReturn OpFunctionEnd %kill_ = OpFunction %void None %5 %15 = OpLabel OpKill OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(WrapOpKillTest, MultipleOpKillInSameFunc) { const std::string text = R"( ; CHECK: OpEntryPoint Fragment [[main:%\w+]] ; CHECK: [[main]] = OpFunction ; CHECK: OpFunctionCall %void [[orig_kill:%\w+]] ; CHECK: [[orig_kill]] = OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpSelectionMerge ; CHECK-NEXT: OpBranchConditional ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpFunctionCall %void [[new_kill:%\w+]] ; CHECK-NEXT: OpReturn ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpFunctionCall %void [[new_kill]] ; CHECK-NEXT: OpReturn ; CHECK: [[new_kill]] = OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpKill ; CHECK-NEXT: OpFunctionEnd OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 330 OpName %main "main" %void = OpTypeVoid %5 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %main = OpFunction %void None %5 %8 = OpLabel OpBranch %9 %9 = OpLabel OpLoopMerge %10 %11 None OpBranch %12 %12 = OpLabel OpBranchConditional %true %13 %10 %13 = OpLabel OpBranch %11 %11 = OpLabel %14 = OpFunctionCall %void %kill_ OpBranch %9 %10 = OpLabel OpReturn OpFunctionEnd %kill_ = OpFunction %void None %5 %15 = OpLabel OpSelectionMerge %16 None OpBranchConditional %true %17 %18 %17 = OpLabel OpKill %18 = OpLabel OpKill %16 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(WrapOpKillTest, MultipleOpKillInDifferentFunc) { const std::string text = R"( ; CHECK: OpEntryPoint Fragment [[main:%\w+]] ; CHECK: [[main]] = OpFunction ; CHECK: OpFunctionCall %void [[orig_kill1:%\w+]] ; CHECK-NEXT: OpFunctionCall %void [[orig_kill2:%\w+]] ; CHECK: [[orig_kill1]] = OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpFunctionCall %void [[new_kill:%\w+]] ; CHECK-NEXT: OpReturn ; CHECK: [[orig_kill2]] = OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpFunctionCall %void [[new_kill]] ; CHECK-NEXT: OpReturn ; CHECK: [[new_kill]] = OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpKill ; CHECK-NEXT: OpFunctionEnd OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 330 OpName %main "main" %void = OpTypeVoid %4 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %main = OpFunction %void None %4 %7 = OpLabel OpBranch %8 %8 = OpLabel OpLoopMerge %9 %10 None OpBranch %11 %11 = OpLabel OpBranchConditional %true %12 %9 %12 = OpLabel OpBranch %10 %10 = OpLabel %13 = OpFunctionCall %void %14 %15 = OpFunctionCall %void %16 OpBranch %8 %9 = OpLabel OpReturn OpFunctionEnd %14 = OpFunction %void None %4 %17 = OpLabel OpKill OpFunctionEnd %16 = OpFunction %void None %4 %18 = OpLabel OpKill OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(WrapOpKillTest, SingleOpTerminateInvocation) { const std::string text = R"( ; CHECK: OpEntryPoint Fragment [[main:%\w+]] ; CHECK: [[main]] = OpFunction ; CHECK: OpFunctionCall %void [[orig_kill:%\w+]] ; CHECK: [[orig_kill]] = OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpFunctionCall %void [[new_kill:%\w+]] ; CHECK-NEXT: OpReturn ; CHECK: [[new_kill]] = OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpTerminateInvocation ; CHECK-NEXT: OpFunctionEnd OpCapability Shader OpExtension "SPV_KHR_terminate_invocation" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 330 OpName %main "main" %void = OpTypeVoid %5 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %main = OpFunction %void None %5 %8 = OpLabel OpBranch %9 %9 = OpLabel OpLoopMerge %10 %11 None OpBranch %12 %12 = OpLabel OpBranchConditional %true %13 %10 %13 = OpLabel OpBranch %11 %11 = OpLabel %14 = OpFunctionCall %void %kill_ OpBranch %9 %10 = OpLabel OpReturn OpFunctionEnd %kill_ = OpFunction %void None %5 %15 = OpLabel OpTerminateInvocation OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(WrapOpKillTest, MultipleTerminateInvocationInSameFunc) { const std::string text = R"( ; CHECK: OpEntryPoint Fragment [[main:%\w+]] ; CHECK: [[main]] = OpFunction ; CHECK: OpFunctionCall %void [[orig_kill:%\w+]] ; CHECK: [[orig_kill]] = OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpSelectionMerge ; CHECK-NEXT: OpBranchConditional ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpFunctionCall %void [[new_kill:%\w+]] ; CHECK-NEXT: OpReturn ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpFunctionCall %void [[new_kill]] ; CHECK-NEXT: OpReturn ; CHECK: [[new_kill]] = OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpTerminateInvocation ; CHECK-NEXT: OpFunctionEnd OpCapability Shader OpExtension "SPV_KHR_terminate_invocation" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 330 OpName %main "main" %void = OpTypeVoid %5 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %main = OpFunction %void None %5 %8 = OpLabel OpBranch %9 %9 = OpLabel OpLoopMerge %10 %11 None OpBranch %12 %12 = OpLabel OpBranchConditional %true %13 %10 %13 = OpLabel OpBranch %11 %11 = OpLabel %14 = OpFunctionCall %void %kill_ OpBranch %9 %10 = OpLabel OpReturn OpFunctionEnd %kill_ = OpFunction %void None %5 %15 = OpLabel OpSelectionMerge %16 None OpBranchConditional %true %17 %18 %17 = OpLabel OpTerminateInvocation %18 = OpLabel OpTerminateInvocation %16 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(WrapOpKillTest, MultipleOpTerminateInvocationDifferentFunc) { const std::string text = R"( ; CHECK: OpEntryPoint Fragment [[main:%\w+]] ; CHECK: [[main]] = OpFunction ; CHECK: OpFunctionCall %void [[orig_kill1:%\w+]] ; CHECK-NEXT: OpFunctionCall %void [[orig_kill2:%\w+]] ; CHECK: [[orig_kill1]] = OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpFunctionCall %void [[new_kill:%\w+]] ; CHECK-NEXT: OpReturn ; CHECK: [[orig_kill2]] = OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpFunctionCall %void [[new_kill]] ; CHECK-NEXT: OpReturn ; CHECK: [[new_kill]] = OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpTerminateInvocation ; CHECK-NEXT: OpFunctionEnd OpCapability Shader OpExtension "SPV_KHR_terminate_invocation" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 330 OpName %main "main" %void = OpTypeVoid %4 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %main = OpFunction %void None %4 %7 = OpLabel OpBranch %8 %8 = OpLabel OpLoopMerge %9 %10 None OpBranch %11 %11 = OpLabel OpBranchConditional %true %12 %9 %12 = OpLabel OpBranch %10 %10 = OpLabel %13 = OpFunctionCall %void %14 %15 = OpFunctionCall %void %16 OpBranch %8 %9 = OpLabel OpReturn OpFunctionEnd %14 = OpFunction %void None %4 %17 = OpLabel OpTerminateInvocation OpFunctionEnd %16 = OpFunction %void None %4 %18 = OpLabel OpTerminateInvocation OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(WrapOpKillTest, KillAndTerminateInvocationSameFunc) { const std::string text = R"( ; CHECK: OpEntryPoint Fragment [[main:%\w+]] ; CHECK: [[main]] = OpFunction ; CHECK: OpFunctionCall %void [[orig_kill:%\w+]] ; CHECK: [[orig_kill]] = OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpSelectionMerge ; CHECK-NEXT: OpBranchConditional ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpFunctionCall %void [[new_kill:%\w+]] ; CHECK-NEXT: OpReturn ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpFunctionCall %void [[new_terminate:%\w+]] ; CHECK-NEXT: OpReturn ; CHECK: [[new_kill]] = OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpKill ; CHECK-NEXT: OpFunctionEnd ; CHECK-NEXT: [[new_terminate]] = OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpTerminateInvocation ; CHECK-NEXT: OpFunctionEnd OpCapability Shader OpExtension "SPV_KHR_terminate_invocation" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 330 OpName %main "main" %void = OpTypeVoid %5 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %main = OpFunction %void None %5 %8 = OpLabel OpBranch %9 %9 = OpLabel OpLoopMerge %10 %11 None OpBranch %12 %12 = OpLabel OpBranchConditional %true %13 %10 %13 = OpLabel OpBranch %11 %11 = OpLabel %14 = OpFunctionCall %void %kill_ OpBranch %9 %10 = OpLabel OpReturn OpFunctionEnd %kill_ = OpFunction %void None %5 %15 = OpLabel OpSelectionMerge %16 None OpBranchConditional %true %17 %18 %17 = OpLabel OpKill %18 = OpLabel OpTerminateInvocation %16 = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(WrapOpKillTest, KillAndTerminateInvocationDifferentFunc) { const std::string text = R"( ; CHECK: OpEntryPoint Fragment [[main:%\w+]] ; CHECK: [[main]] = OpFunction ; CHECK: OpFunctionCall %void [[orig_kill1:%\w+]] ; CHECK-NEXT: OpFunctionCall %void [[orig_kill2:%\w+]] ; CHECK: [[orig_kill1]] = OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpFunctionCall %void [[new_terminate:%\w+]] ; CHECK-NEXT: OpReturn ; CHECK: [[orig_kill2]] = OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpFunctionCall %void [[new_kill:%\w+]] ; CHECK-NEXT: OpReturn ; CHECK: [[new_kill]] = OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpKill ; CHECK-NEXT: OpFunctionEnd ; CHECK-NEXT: [[new_terminate]] = OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpTerminateInvocation ; CHECK-NEXT: OpFunctionEnd OpCapability Shader OpExtension "SPV_KHR_terminate_invocation" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 330 OpName %main "main" %void = OpTypeVoid %4 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %main = OpFunction %void None %4 %7 = OpLabel OpBranch %8 %8 = OpLabel OpLoopMerge %9 %10 None OpBranch %11 %11 = OpLabel OpBranchConditional %true %12 %9 %12 = OpLabel OpBranch %10 %10 = OpLabel %13 = OpFunctionCall %void %14 %15 = OpFunctionCall %void %16 OpBranch %8 %9 = OpLabel OpReturn OpFunctionEnd %14 = OpFunction %void None %4 %17 = OpLabel OpTerminateInvocation OpFunctionEnd %16 = OpFunction %void None %4 %18 = OpLabel OpKill OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(WrapOpKillTest, FuncWithReturnValue) { const std::string text = R"( ; CHECK: OpEntryPoint Fragment [[main:%\w+]] ; CHECK: [[main]] = OpFunction ; CHECK: OpFunctionCall %int [[orig_kill:%\w+]] ; CHECK: [[orig_kill]] = OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpFunctionCall %void [[new_kill:%\w+]] ; CHECK-NEXT: [[undef:%\w+]] = OpUndef %int ; CHECK-NEXT: OpReturnValue [[undef]] ; CHECK: [[new_kill]] = OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpKill ; CHECK-NEXT: OpFunctionEnd OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 330 OpName %main "main" %void = OpTypeVoid %5 = OpTypeFunction %void %int = OpTypeInt 32 1 %func_type = OpTypeFunction %int %bool = OpTypeBool %true = OpConstantTrue %bool %main = OpFunction %void None %5 %8 = OpLabel OpBranch %9 %9 = OpLabel OpLoopMerge %10 %11 None OpBranch %12 %12 = OpLabel OpBranchConditional %true %13 %10 %13 = OpLabel OpBranch %11 %11 = OpLabel %14 = OpFunctionCall %int %kill_ OpBranch %9 %10 = OpLabel OpReturn OpFunctionEnd %kill_ = OpFunction %int None %func_type %15 = OpLabel OpKill OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(WrapOpKillTest, IdBoundOverflow1) { const std::string text = R"( OpCapability GeometryStreams OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeFunction %2 %bool = OpTypeBool %true = OpConstantTrue %bool %main = OpFunction %2 None %3 %8 = OpLabel OpBranch %9 %9 = OpLabel OpLoopMerge %10 %11 None OpBranch %12 %12 = OpLabel OpBranchConditional %true %13 %10 %13 = OpLabel OpBranch %11 %11 = OpLabel %14 = OpFunctionCall %void %kill_ OpBranch %9 %10 = OpLabel OpReturn OpFunctionEnd %kill_ = OpFunction %2 Pure|Const %3 %4194302 = OpLabel OpKill OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); std::vector messages = { {SPV_MSG_ERROR, "", 0, 0, "ID overflow. Try running compact-ids."}}; SetMessageConsumer(GetTestMessageConsumer(messages)); auto result = SinglePassRunToBinary(text, true); EXPECT_EQ(Pass::Status::Failure, std::get<1>(result)); } TEST_F(WrapOpKillTest, IdBoundOverflow2) { const std::string text = R"( OpCapability GeometryStreams OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeFunction %2 %bool = OpTypeBool %true = OpConstantTrue %bool %main = OpFunction %2 None %3 %8 = OpLabel OpBranch %9 %9 = OpLabel OpLoopMerge %10 %11 None OpBranch %12 %12 = OpLabel OpBranchConditional %true %13 %10 %13 = OpLabel OpBranch %11 %11 = OpLabel %14 = OpFunctionCall %void %kill_ OpBranch %9 %10 = OpLabel OpReturn OpFunctionEnd %kill_ = OpFunction %2 Pure|Const %3 %4194301 = OpLabel OpKill OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); std::vector messages = { {SPV_MSG_ERROR, "", 0, 0, "ID overflow. Try running compact-ids."}}; SetMessageConsumer(GetTestMessageConsumer(messages)); auto result = SinglePassRunToBinary(text, true); EXPECT_EQ(Pass::Status::Failure, std::get<1>(result)); } TEST_F(WrapOpKillTest, IdBoundOverflow3) { const std::string text = R"( OpCapability GeometryStreams OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeFunction %2 %bool = OpTypeBool %true = OpConstantTrue %bool %main = OpFunction %2 None %3 %8 = OpLabel OpBranch %9 %9 = OpLabel OpLoopMerge %10 %11 None OpBranch %12 %12 = OpLabel OpBranchConditional %true %13 %10 %13 = OpLabel OpBranch %11 %11 = OpLabel %14 = OpFunctionCall %void %kill_ OpBranch %9 %10 = OpLabel OpReturn OpFunctionEnd %kill_ = OpFunction %2 Pure|Const %3 %4194300 = OpLabel OpKill OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); std::vector messages = { {SPV_MSG_ERROR, "", 0, 0, "ID overflow. Try running compact-ids."}}; SetMessageConsumer(GetTestMessageConsumer(messages)); auto result = SinglePassRunToBinary(text, true); EXPECT_EQ(Pass::Status::Failure, std::get<1>(result)); } TEST_F(WrapOpKillTest, IdBoundOverflow4) { const std::string text = R"( OpCapability DerivativeControl OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpDecorate %2 Location 539091968 %2 = OpTypeVoid %3 = OpTypeFunction %2 %bool = OpTypeBool %true = OpConstantTrue %bool %main = OpFunction %2 None %3 %8 = OpLabel OpBranch %9 %9 = OpLabel OpLoopMerge %10 %11 None OpBranch %12 %12 = OpLabel OpBranchConditional %true %13 %10 %13 = OpLabel OpBranch %11 %11 = OpLabel %14 = OpFunctionCall %void %kill_ OpBranch %9 %10 = OpLabel OpReturn OpFunctionEnd %kill_ = OpFunction %2 Inline|Pure|Const %3 %4194302 = OpLabel OpKill OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); std::vector messages = { {SPV_MSG_ERROR, "", 0, 0, "ID overflow. Try running compact-ids."}}; SetMessageConsumer(GetTestMessageConsumer(messages)); auto result = SinglePassRunToBinary(text, true); EXPECT_EQ(Pass::Status::Failure, std::get<1>(result)); } TEST_F(WrapOpKillTest, IdBoundOverflow5) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpDecorate %void Location 539091968 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %_struct_5 = OpTypeStruct %float %float %_struct_6 = OpTypeStruct %_struct_5 %_ptr_Function__struct_6 = OpTypePointer Function %_struct_6 %_ptr_Output_float = OpTypePointer Output %float %9 = OpTypeFunction %_struct_5 %_ptr_Function__struct_6 %bool = OpTypeBool %true = OpConstantTrue %bool %1 = OpFunction %void None %3 %12 = OpLabel %13 = OpVariable %_ptr_Function__struct_6 Function OpBranch %14 %14 = OpLabel OpLoopMerge %15 %16 None OpBranch %17 %17 = OpLabel OpBranchConditional %true %18 %15 %18 = OpLabel OpBranch %16 %16 = OpLabel %19 = OpFunctionCall %void %20 %21 = OpFunctionCall %_struct_5 %22 %13 OpBranch %14 %15 = OpLabel OpReturn OpFunctionEnd %20 = OpFunction %void Inline|Pure|Const %3 %23 = OpLabel %24 = OpVariable %_ptr_Function__struct_6 Function %25 = OpFunctionCall %_struct_5 %26 %24 OpKill OpFunctionEnd %26 = OpFunction %_struct_5 None %9 %27 = OpLabel OpUnreachable OpFunctionEnd %22 = OpFunction %_struct_5 Inline %9 %4194295 = OpLabel OpKill OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); std::vector messages = { {SPV_MSG_ERROR, "", 0, 0, "ID overflow. Try running compact-ids."}}; SetMessageConsumer(GetTestMessageConsumer(messages)); auto result = SinglePassRunToBinary(text, true); EXPECT_EQ(Pass::Status::Failure, std::get<1>(result)); } TEST_F(WrapOpKillTest, SkipEntryPoint) { const std::string text = R"( OpCapability GeometryStreams OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 Pure|Const %3 %5 = OpLabel OpKill OpFunctionEnd )"; auto result = SinglePassRunToBinary(text, true); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } TEST_F(WrapOpKillTest, SkipFunctionNotInContinue) { const std::string text = R"( OpCapability GeometryStreams OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeFunction %2 %bool = OpTypeBool %true = OpConstantTrue %bool %main = OpFunction %2 None %3 %6 = OpLabel %7 = OpFunctionCall %void %4 OpReturn OpFunctionEnd %4 = OpFunction %2 Pure|Const %3 %5 = OpLabel OpKill OpFunctionEnd )"; auto result = SinglePassRunToBinary(text, true); EXPECT_EQ(Pass::Status::SuccessWithoutChange, std::get<1>(result)); } TEST_F(WrapOpKillTest, SetParentBlock) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %bool = OpTypeBool %undef = OpUndef %bool %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpBranch %loop %loop = OpLabel OpLoopMerge %merge %continue None OpBranchConditional %undef %merge %continue %continue = OpLabel %call = OpFunctionCall %void %kill_func OpBranch %loop %merge = OpLabel OpReturn OpFunctionEnd %kill_func = OpFunction %void None %void_fn %kill_entry = OpLabel OpKill OpFunctionEnd )"; auto result = SinglePassRunToBinary(text, true); EXPECT_EQ(Pass::Status::SuccessWithChange, std::get<1>(result)); result = SinglePassRunToBinary(text, true); EXPECT_EQ(Pass::Status::SuccessWithChange, std::get<1>(result)); } TEST_F(WrapOpKillTest, KillInSingleBlockLoop) { const std::string text = R"( ; CHECK: OpFunction %void ; CHECK: OpFunction %void ; CHECK-NOT: OpKill ; CHECK: OpFunctionCall %void [[new_kill:%\w+]] ; CHECK-NOT: OpKill ; CHECK: [[new_kill]] = OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpKill ; CHECK-NEXT: OpFunctionEnd OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %bool = OpTypeBool %undef = OpUndef %bool %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %main_entry = OpLabel OpBranch %loop %loop = OpLabel %call = OpFunctionCall %void %sub OpLoopMerge %exit %loop None OpBranchConditional %undef %loop %exit %exit = OpLabel OpReturn OpFunctionEnd %sub = OpFunction %void None %void_fn %sub_entry = OpLabel OpSelectionMerge %ret None OpBranchConditional %undef %kill %ret %kill = OpLabel OpKill %ret = OpLabel OpReturn OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } TEST_F(WrapOpKillTest, DebugInfoSimple) { const std::string text = R"( ; CHECK: OpEntryPoint Fragment [[main:%\w+]] ; CHECK: [[main]] = OpFunction ; CHECK: OpFunctionCall %void [[orig_kill:%\w+]] ; CHECK: [[orig_kill]] = OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: {{%\d+}} = OpExtInst %void [[ext:%\d+]] DebugScope ; CHECK-NEXT: OpLine [[file:%\d+]] 100 200 ; CHECK-NEXT: OpFunctionCall %void [[new_kill:%\w+]] ; CHECK: {{%\d+}} = OpExtInst %void [[ext]] DebugNoScope ; CHECK-NEXT: OpReturn ; CHECK: [[new_kill]] = OpFunction ; CHECK-NEXT: OpLabel ; CHECK-NEXT: OpKill ; CHECK-NEXT: OpFunctionEnd OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %2 = OpString "File name" OpSource GLSL 330 OpName %main "main" %void = OpTypeVoid %5 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %3 = OpExtInst %void %1 DebugSource %2 %4 = OpExtInst %void %1 DebugCompilationUnit 0 0 %3 GLSL %main = OpFunction %void None %5 %8 = OpLabel OpBranch %9 %9 = OpLabel OpLoopMerge %10 %11 None OpBranch %12 %12 = OpLabel OpBranchConditional %true %13 %10 %13 = OpLabel OpBranch %11 %11 = OpLabel %14 = OpFunctionCall %void %kill_ OpBranch %9 %10 = OpLabel OpReturn OpFunctionEnd %kill_ = OpFunction %void None %5 %15 = OpLabel %16 = OpExtInst %void %1 DebugScope %4 OpLine %2 100 200 OpKill OpFunctionEnd )"; SinglePassRunAndMatch(text, true); } } // namespace } // namespace opt } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/parse_number_test.cpp000066400000000000000000001164431475742701700237460ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include "gmock/gmock.h" #include "source/util/parse_number.h" #include "spirv-tools/libspirv.h" namespace spvtools { namespace utils { namespace { using testing::Eq; using testing::IsNull; using testing::NotNull; TEST(ParseNarrowSignedIntegers, Sample) { int16_t i16; EXPECT_FALSE(ParseNumber(nullptr, &i16)); EXPECT_FALSE(ParseNumber("", &i16)); EXPECT_FALSE(ParseNumber("0=", &i16)); EXPECT_TRUE(ParseNumber("0", &i16)); EXPECT_EQ(0, i16); EXPECT_TRUE(ParseNumber("32767", &i16)); EXPECT_EQ(32767, i16); EXPECT_TRUE(ParseNumber("-32768", &i16)); EXPECT_EQ(-32768, i16); EXPECT_TRUE(ParseNumber("-0", &i16)); EXPECT_EQ(0, i16); // These are out of range, so they should return an error. // The error code depends on whether this is an optional value. EXPECT_FALSE(ParseNumber("32768", &i16)); EXPECT_FALSE(ParseNumber("65535", &i16)); // Check hex parsing. EXPECT_TRUE(ParseNumber("0x7fff", &i16)); EXPECT_EQ(32767, i16); // This is out of range. EXPECT_FALSE(ParseNumber("0xffff", &i16)); } TEST(ParseNarrowUnsignedIntegers, Sample) { uint16_t u16; EXPECT_FALSE(ParseNumber(nullptr, &u16)); EXPECT_FALSE(ParseNumber("", &u16)); EXPECT_FALSE(ParseNumber("0=", &u16)); EXPECT_TRUE(ParseNumber("0", &u16)); EXPECT_EQ(0, u16); EXPECT_TRUE(ParseNumber("65535", &u16)); EXPECT_EQ(65535, u16); EXPECT_FALSE(ParseNumber("65536", &u16)); // We don't care about -0 since it's rejected at a higher level. EXPECT_FALSE(ParseNumber("-1", &u16)); EXPECT_TRUE(ParseNumber("0xffff", &u16)); EXPECT_EQ(0xffff, u16); EXPECT_FALSE(ParseNumber("0x10000", &u16)); } TEST(ParseSignedIntegers, Sample) { int32_t i32; // Invalid parse. EXPECT_FALSE(ParseNumber(nullptr, &i32)); EXPECT_FALSE(ParseNumber("", &i32)); EXPECT_FALSE(ParseNumber("0=", &i32)); // Decimal values. EXPECT_TRUE(ParseNumber("0", &i32)); EXPECT_EQ(0, i32); EXPECT_TRUE(ParseNumber("2147483647", &i32)); EXPECT_EQ(std::numeric_limits::max(), i32); EXPECT_FALSE(ParseNumber("2147483648", &i32)); EXPECT_TRUE(ParseNumber("-0", &i32)); EXPECT_EQ(0, i32); EXPECT_TRUE(ParseNumber("-1", &i32)); EXPECT_EQ(-1, i32); EXPECT_TRUE(ParseNumber("-2147483648", &i32)); EXPECT_EQ(std::numeric_limits::min(), i32); // Hex values. EXPECT_TRUE(ParseNumber("0x7fffffff", &i32)); EXPECT_EQ(std::numeric_limits::max(), i32); EXPECT_FALSE(ParseNumber("0x80000000", &i32)); EXPECT_TRUE(ParseNumber("-0x000", &i32)); EXPECT_EQ(0, i32); EXPECT_TRUE(ParseNumber("-0x001", &i32)); EXPECT_EQ(-1, i32); EXPECT_TRUE(ParseNumber("-0x80000000", &i32)); EXPECT_EQ(std::numeric_limits::min(), i32); } TEST(ParseUnsignedIntegers, Sample) { uint32_t u32; // Invalid parse. EXPECT_FALSE(ParseNumber(nullptr, &u32)); EXPECT_FALSE(ParseNumber("", &u32)); EXPECT_FALSE(ParseNumber("0=", &u32)); // Valid values. EXPECT_TRUE(ParseNumber("0", &u32)); EXPECT_EQ(0u, u32); EXPECT_TRUE(ParseNumber("4294967295", &u32)); EXPECT_EQ(std::numeric_limits::max(), u32); EXPECT_FALSE(ParseNumber("4294967296", &u32)); // Hex values. EXPECT_TRUE(ParseNumber("0xffffffff", &u32)); EXPECT_EQ(std::numeric_limits::max(), u32); // We don't care about -0 since it's rejected at a higher level. EXPECT_FALSE(ParseNumber("-1", &u32)); } TEST(ParseWideSignedIntegers, Sample) { int64_t i64; EXPECT_FALSE(ParseNumber(nullptr, &i64)); EXPECT_FALSE(ParseNumber("", &i64)); EXPECT_FALSE(ParseNumber("0=", &i64)); EXPECT_TRUE(ParseNumber("0", &i64)); EXPECT_EQ(0, i64); EXPECT_TRUE(ParseNumber("0x7fffffffffffffff", &i64)); EXPECT_EQ(0x7fffffffffffffff, i64); EXPECT_TRUE(ParseNumber("-0", &i64)); EXPECT_EQ(0, i64); EXPECT_TRUE(ParseNumber("-1", &i64)); EXPECT_EQ(-1, i64); } TEST(ParseWideUnsignedIntegers, Sample) { uint64_t u64; EXPECT_FALSE(ParseNumber(nullptr, &u64)); EXPECT_FALSE(ParseNumber("", &u64)); EXPECT_FALSE(ParseNumber("0=", &u64)); EXPECT_TRUE(ParseNumber("0", &u64)); EXPECT_EQ(0u, u64); EXPECT_TRUE(ParseNumber("0xffffffffffffffff", &u64)); EXPECT_EQ(0xffffffffffffffffULL, u64); // We don't care about -0 since it's rejected at a higher level. EXPECT_FALSE(ParseNumber("-1", &u64)); } TEST(ParseFloat, Sample) { float f; EXPECT_FALSE(ParseNumber(nullptr, &f)); EXPECT_FALSE(ParseNumber("", &f)); EXPECT_FALSE(ParseNumber("0=", &f)); // These values are exactly representatble. EXPECT_TRUE(ParseNumber("0", &f)); EXPECT_EQ(0.0f, f); EXPECT_TRUE(ParseNumber("42", &f)); EXPECT_EQ(42.0f, f); EXPECT_TRUE(ParseNumber("2.5", &f)); EXPECT_EQ(2.5f, f); EXPECT_TRUE(ParseNumber("-32.5", &f)); EXPECT_EQ(-32.5f, f); EXPECT_TRUE(ParseNumber("1e38", &f)); EXPECT_EQ(1e38f, f); EXPECT_TRUE(ParseNumber("-1e38", &f)); EXPECT_EQ(-1e38f, f); } TEST(ParseFloat, Overflow) { // The assembler parses using HexFloat>. Make // sure that succeeds for in-range values, and fails for out of // range values. When it does overflow, the value is set to the // nearest finite value, matching C++11 behavior for operator>> // on floating point. HexFloat> f(0.0f); EXPECT_TRUE(ParseNumber("1e38", &f)); EXPECT_EQ(1e38f, f.value().getAsFloat()); EXPECT_TRUE(ParseNumber("-1e38", &f)); EXPECT_EQ(-1e38f, f.value().getAsFloat()); EXPECT_FALSE(ParseNumber("1e40", &f)); EXPECT_FALSE(ParseNumber("-1e40", &f)); EXPECT_FALSE(ParseNumber("1e400", &f)); EXPECT_FALSE(ParseNumber("-1e400", &f)); } TEST(ParseDouble, Sample) { double f; EXPECT_FALSE(ParseNumber(nullptr, &f)); EXPECT_FALSE(ParseNumber("", &f)); EXPECT_FALSE(ParseNumber("0=", &f)); // These values are exactly representatble. EXPECT_TRUE(ParseNumber("0", &f)); EXPECT_EQ(0.0, f); EXPECT_TRUE(ParseNumber("42", &f)); EXPECT_EQ(42.0, f); EXPECT_TRUE(ParseNumber("2.5", &f)); EXPECT_EQ(2.5, f); EXPECT_TRUE(ParseNumber("-32.5", &f)); EXPECT_EQ(-32.5, f); EXPECT_TRUE(ParseNumber("1e38", &f)); EXPECT_EQ(1e38, f); EXPECT_TRUE(ParseNumber("-1e38", &f)); EXPECT_EQ(-1e38, f); // These are out of range for 32-bit float, but in range for 64-bit float. EXPECT_TRUE(ParseNumber("1e40", &f)); EXPECT_EQ(1e40, f); EXPECT_TRUE(ParseNumber("-1e40", &f)); EXPECT_EQ(-1e40, f); } TEST(ParseDouble, Overflow) { // The assembler parses using HexFloat>. Make // sure that succeeds for in-range values, and fails for out of // range values. When it does overflow, the value is set to the // nearest finite value, matching C++11 behavior for operator>> // on floating point. HexFloat> f(0.0); EXPECT_TRUE(ParseNumber("1e38", &f)); EXPECT_EQ(1e38, f.value().getAsFloat()); EXPECT_TRUE(ParseNumber("-1e38", &f)); EXPECT_EQ(-1e38, f.value().getAsFloat()); EXPECT_TRUE(ParseNumber("1e40", &f)); EXPECT_EQ(1e40, f.value().getAsFloat()); EXPECT_TRUE(ParseNumber("-1e40", &f)); EXPECT_EQ(-1e40, f.value().getAsFloat()); EXPECT_FALSE(ParseNumber("1e400", &f)); EXPECT_FALSE(ParseNumber("-1e400", &f)); } TEST(ParseFloat16, Overflow) { // The assembler parses using HexFloat>. Make // sure that succeeds for in-range values, and fails for out of // range values. When it does overflow, the value is set to the // nearest finite value, matching C++11 behavior for operator>> // on floating point. HexFloat> f(0); EXPECT_FALSE(ParseNumber(nullptr, &f)); EXPECT_TRUE(ParseNumber("-0.0", &f)); EXPECT_EQ(uint16_t{0x8000}, f.value().getAsFloat().get_value()); EXPECT_TRUE(ParseNumber("1.0", &f)); EXPECT_EQ(uint16_t{0x3c00}, f.value().getAsFloat().get_value()); // Overflows 16-bit but not 32-bit EXPECT_FALSE(ParseNumber("1e38", &f)); EXPECT_FALSE(ParseNumber("-1e38", &f)); // Overflows 32-bit but not 64-bit EXPECT_FALSE(ParseNumber("1e40", &f)); EXPECT_FALSE(ParseNumber("-1e40", &f)); // Overflows 64-bit EXPECT_FALSE(ParseNumber("1e400", &f)); EXPECT_FALSE(ParseNumber("-1e400", &f)); } void AssertEmitFunc(uint32_t) { ASSERT_FALSE(true) << "Should not call emit() function when the number can not be parsed."; return; } TEST(ParseAndEncodeNarrowSignedIntegers, Invalid) { // The error message should be overwritten after each parsing call. EncodeNumberStatus rc = EncodeNumberStatus::kSuccess; std::string err_msg; NumberType type = {16, SPV_NUMBER_SIGNED_INT}; rc = ParseAndEncodeIntegerNumber(nullptr, type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("The given text is a nullptr", err_msg); rc = ParseAndEncodeIntegerNumber("", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid unsigned integer literal: ", err_msg); rc = ParseAndEncodeIntegerNumber("=", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid unsigned integer literal: =", err_msg); rc = ParseAndEncodeIntegerNumber("-", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid signed integer literal: -", err_msg); rc = ParseAndEncodeIntegerNumber("0=", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid unsigned integer literal: 0=", err_msg); } TEST(ParseAndEncodeNarrowSignedIntegers, Overflow) { // The error message should be overwritten after each parsing call. EncodeNumberStatus rc = EncodeNumberStatus::kSuccess; std::string err_msg; NumberType type = {16, SPV_NUMBER_SIGNED_INT}; rc = ParseAndEncodeIntegerNumber("32768", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Integer 32768 does not fit in a 16-bit signed integer", err_msg); rc = ParseAndEncodeIntegerNumber("-32769", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Integer -32769 does not fit in a 16-bit signed integer", err_msg); } TEST(ParseAndEncodeNarrowSignedIntegers, Success) { // Don't care the error message in this case. EncodeNumberStatus rc = EncodeNumberStatus::kInvalidText; NumberType type = {16, SPV_NUMBER_SIGNED_INT}; // Zero, maximum, and minimum value rc = ParseAndEncodeIntegerNumber( "0", type, [](uint32_t word) { EXPECT_EQ(0u, word); }, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); rc = ParseAndEncodeIntegerNumber( "-0", type, [](uint32_t word) { EXPECT_EQ(0u, word); }, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); rc = ParseAndEncodeIntegerNumber( "32767", type, [](uint32_t word) { EXPECT_EQ(0x00007fffu, word); }, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); rc = ParseAndEncodeIntegerNumber( "-32768", type, [](uint32_t word) { EXPECT_EQ(0xffff8000u, word); }, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); // Hex parsing rc = ParseAndEncodeIntegerNumber( "0x7fff", type, [](uint32_t word) { EXPECT_EQ(0x00007fffu, word); }, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); rc = ParseAndEncodeIntegerNumber( "0xffff", type, [](uint32_t word) { EXPECT_EQ(0xffffffffu, word); }, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); } TEST(ParseAndEncodeNarrowUnsignedIntegers, Invalid) { // The error message should be overwritten after each parsing call. EncodeNumberStatus rc = EncodeNumberStatus::kSuccess; std::string err_msg; NumberType type = {16, SPV_NUMBER_UNSIGNED_INT}; rc = ParseAndEncodeIntegerNumber(nullptr, type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("The given text is a nullptr", err_msg); rc = ParseAndEncodeIntegerNumber("", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid unsigned integer literal: ", err_msg); rc = ParseAndEncodeIntegerNumber("=", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid unsigned integer literal: =", err_msg); rc = ParseAndEncodeIntegerNumber("-", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidUsage, rc); EXPECT_EQ("Cannot put a negative number in an unsigned literal", err_msg); rc = ParseAndEncodeIntegerNumber("0=", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid unsigned integer literal: 0=", err_msg); rc = ParseAndEncodeIntegerNumber("-0", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidUsage, rc); EXPECT_EQ("Cannot put a negative number in an unsigned literal", err_msg); rc = ParseAndEncodeIntegerNumber("-1", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidUsage, rc); EXPECT_EQ("Cannot put a negative number in an unsigned literal", err_msg); } TEST(ParseAndEncodeNarrowUnsignedIntegers, Overflow) { // The error message should be overwritten after each parsing call. EncodeNumberStatus rc = EncodeNumberStatus::kSuccess; std::string err_msg("random content"); NumberType type = {16, SPV_NUMBER_UNSIGNED_INT}; // Overflow rc = ParseAndEncodeIntegerNumber("65536", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Integer 65536 does not fit in a 16-bit unsigned integer", err_msg); } TEST(ParseAndEncodeNarrowUnsignedIntegers, Success) { // Don't care the error message in this case. EncodeNumberStatus rc = EncodeNumberStatus::kInvalidText; NumberType type = {16, SPV_NUMBER_UNSIGNED_INT}; // Zero, maximum, and minimum value rc = ParseAndEncodeIntegerNumber( "0", type, [](uint32_t word) { EXPECT_EQ(0u, word); }, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); rc = ParseAndEncodeIntegerNumber( "65535", type, [](uint32_t word) { EXPECT_EQ(0x0000ffffu, word); }, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); // Hex parsing rc = ParseAndEncodeIntegerNumber( "0xffff", type, [](uint32_t word) { EXPECT_EQ(0x0000ffffu, word); }, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); } TEST(ParseAndEncodeSignedIntegers, Invalid) { // The error message should be overwritten after each parsing call. EncodeNumberStatus rc = EncodeNumberStatus::kSuccess; std::string err_msg; NumberType type = {32, SPV_NUMBER_SIGNED_INT}; rc = ParseAndEncodeIntegerNumber(nullptr, type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("The given text is a nullptr", err_msg); rc = ParseAndEncodeIntegerNumber("", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid unsigned integer literal: ", err_msg); rc = ParseAndEncodeIntegerNumber("=", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid unsigned integer literal: =", err_msg); rc = ParseAndEncodeIntegerNumber("-", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid signed integer literal: -", err_msg); rc = ParseAndEncodeIntegerNumber("0=", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid unsigned integer literal: 0=", err_msg); } TEST(ParseAndEncodeSignedIntegers, Overflow) { // The error message should be overwritten after each parsing call. EncodeNumberStatus rc = EncodeNumberStatus::kSuccess; std::string err_msg; NumberType type = {32, SPV_NUMBER_SIGNED_INT}; rc = ParseAndEncodeIntegerNumber("2147483648", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Integer 2147483648 does not fit in a 32-bit signed integer", err_msg); rc = ParseAndEncodeIntegerNumber("-2147483649", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Integer -2147483649 does not fit in a 32-bit signed integer", err_msg); } TEST(ParseAndEncodeSignedIntegers, Success) { // Don't care the error message in this case. EncodeNumberStatus rc = EncodeNumberStatus::kInvalidText; NumberType type = {32, SPV_NUMBER_SIGNED_INT}; // Zero, maximum, and minimum value rc = ParseAndEncodeIntegerNumber( "0", type, [](uint32_t word) { EXPECT_EQ(0u, word); }, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); rc = ParseAndEncodeIntegerNumber( "-0", type, [](uint32_t word) { EXPECT_EQ(0u, word); }, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); rc = ParseAndEncodeIntegerNumber( "2147483647", type, [](uint32_t word) { EXPECT_EQ(0x7fffffffu, word); }, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); rc = ParseAndEncodeIntegerNumber( "-2147483648", type, [](uint32_t word) { EXPECT_EQ(0x80000000u, word); }, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); // Hex parsing rc = ParseAndEncodeIntegerNumber( "0x7fffffff", type, [](uint32_t word) { EXPECT_EQ(0x7fffffffu, word); }, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); rc = ParseAndEncodeIntegerNumber( "0xffffffff", type, [](uint32_t word) { EXPECT_EQ(0xffffffffu, word); }, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); } TEST(ParseAndEncodeUnsignedIntegers, Invalid) { // The error message should be overwritten after each parsing call. EncodeNumberStatus rc = EncodeNumberStatus::kSuccess; std::string err_msg; NumberType type = {32, SPV_NUMBER_UNSIGNED_INT}; rc = ParseAndEncodeIntegerNumber(nullptr, type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("The given text is a nullptr", err_msg); rc = ParseAndEncodeIntegerNumber("", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid unsigned integer literal: ", err_msg); rc = ParseAndEncodeIntegerNumber("=", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid unsigned integer literal: =", err_msg); rc = ParseAndEncodeIntegerNumber("-", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidUsage, rc); EXPECT_EQ("Cannot put a negative number in an unsigned literal", err_msg); rc = ParseAndEncodeIntegerNumber("0=", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid unsigned integer literal: 0=", err_msg); rc = ParseAndEncodeIntegerNumber("-0", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidUsage, rc); EXPECT_EQ("Cannot put a negative number in an unsigned literal", err_msg); rc = ParseAndEncodeIntegerNumber("-1", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidUsage, rc); EXPECT_EQ("Cannot put a negative number in an unsigned literal", err_msg); } TEST(ParseAndEncodeUnsignedIntegers, Overflow) { // The error message should be overwritten after each parsing call. EncodeNumberStatus rc = EncodeNumberStatus::kSuccess; std::string err_msg("random content"); NumberType type = {32, SPV_NUMBER_UNSIGNED_INT}; // Overflow rc = ParseAndEncodeIntegerNumber("4294967296", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Integer 4294967296 does not fit in a 32-bit unsigned integer", err_msg); } TEST(ParseAndEncodeUnsignedIntegers, Success) { // Don't care the error message in this case. EncodeNumberStatus rc = EncodeNumberStatus::kInvalidText; NumberType type = {32, SPV_NUMBER_UNSIGNED_INT}; // Zero, maximum, and minimum value rc = ParseAndEncodeIntegerNumber( "0", type, [](uint32_t word) { EXPECT_EQ(0u, word); }, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); rc = ParseAndEncodeIntegerNumber( "4294967295", type, [](uint32_t word) { EXPECT_EQ(0xffffffffu, word); }, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); // Hex parsing rc = ParseAndEncodeIntegerNumber( "0xffffffff", type, [](uint32_t word) { EXPECT_EQ(0xffffffffu, word); }, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); } TEST(ParseAndEncodeWideSignedIntegers, Invalid) { // The error message should be overwritten after each parsing call. EncodeNumberStatus rc = EncodeNumberStatus::kSuccess; std::string err_msg; NumberType type = {64, SPV_NUMBER_SIGNED_INT}; rc = ParseAndEncodeIntegerNumber(nullptr, type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("The given text is a nullptr", err_msg); rc = ParseAndEncodeIntegerNumber("", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid unsigned integer literal: ", err_msg); rc = ParseAndEncodeIntegerNumber("=", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid unsigned integer literal: =", err_msg); rc = ParseAndEncodeIntegerNumber("-", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid signed integer literal: -", err_msg); rc = ParseAndEncodeIntegerNumber("0=", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid unsigned integer literal: 0=", err_msg); } TEST(ParseAndEncodeWideSignedIntegers, Overflow) { // The error message should be overwritten after each parsing call. EncodeNumberStatus rc = EncodeNumberStatus::kSuccess; std::string err_msg; NumberType type = {64, SPV_NUMBER_SIGNED_INT}; rc = ParseAndEncodeIntegerNumber("9223372036854775808", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ( "Integer 9223372036854775808 does not fit in a 64-bit signed integer", err_msg); rc = ParseAndEncodeIntegerNumber("-9223372036854775809", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid signed integer literal: -9223372036854775809", err_msg); } TEST(ParseAndEncodeWideSignedIntegers, Success) { // Don't care the error message in this case. EncodeNumberStatus rc = EncodeNumberStatus::kInvalidText; NumberType type = {64, SPV_NUMBER_SIGNED_INT}; std::vector word_buffer; auto emit = [&word_buffer](uint32_t word) { if (word_buffer.size() == 2) word_buffer.clear(); word_buffer.push_back(word); }; // Zero, maximum, and minimum value rc = ParseAndEncodeIntegerNumber("0", type, emit, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); EXPECT_THAT(word_buffer, Eq(std::vector{0u, 0u})); rc = ParseAndEncodeIntegerNumber("-0", type, emit, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); EXPECT_THAT(word_buffer, Eq(std::vector{0u, 0u})); rc = ParseAndEncodeIntegerNumber("9223372036854775807", type, emit, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); EXPECT_THAT(word_buffer, Eq(std::vector{0xffffffffu, 0x7fffffffu})); rc = ParseAndEncodeIntegerNumber("-9223372036854775808", type, emit, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); EXPECT_THAT(word_buffer, Eq(std::vector{0u, 0x80000000u})); rc = ParseAndEncodeIntegerNumber("-1", type, emit, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); EXPECT_THAT(word_buffer, Eq(std::vector{0xffffffffu, 0xffffffffu})); // Hex parsing rc = ParseAndEncodeIntegerNumber("0x7fffffffffffffff", type, emit, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); EXPECT_THAT(word_buffer, Eq(std::vector{0xffffffffu, 0x7fffffffu})); rc = ParseAndEncodeIntegerNumber("0xffffffffffffffff", type, emit, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); EXPECT_THAT(word_buffer, Eq(std::vector{0xffffffffu, 0xffffffffu})); } TEST(ParseAndEncodeWideUnsignedIntegers, Invalid) { // The error message should be overwritten after each parsing call. EncodeNumberStatus rc = EncodeNumberStatus::kSuccess; std::string err_msg; NumberType type = {64, SPV_NUMBER_UNSIGNED_INT}; // Invalid rc = ParseAndEncodeIntegerNumber(nullptr, type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("The given text is a nullptr", err_msg); rc = ParseAndEncodeIntegerNumber("", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid unsigned integer literal: ", err_msg); rc = ParseAndEncodeIntegerNumber("=", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid unsigned integer literal: =", err_msg); rc = ParseAndEncodeIntegerNumber("-", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidUsage, rc); EXPECT_EQ("Cannot put a negative number in an unsigned literal", err_msg); rc = ParseAndEncodeIntegerNumber("0=", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid unsigned integer literal: 0=", err_msg); rc = ParseAndEncodeIntegerNumber("-0", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidUsage, rc); EXPECT_EQ("Cannot put a negative number in an unsigned literal", err_msg); rc = ParseAndEncodeIntegerNumber("-1", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidUsage, rc); EXPECT_EQ("Cannot put a negative number in an unsigned literal", err_msg); } TEST(ParseAndEncodeWideUnsignedIntegers, Overflow) { // The error message should be overwritten after each parsing call. EncodeNumberStatus rc = EncodeNumberStatus::kSuccess; std::string err_msg; NumberType type = {64, SPV_NUMBER_UNSIGNED_INT}; // Overflow rc = ParseAndEncodeIntegerNumber("18446744073709551616", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid unsigned integer literal: 18446744073709551616", err_msg); } TEST(ParseAndEncodeWideUnsignedIntegers, Success) { // Don't care the error message in this case. EncodeNumberStatus rc = EncodeNumberStatus::kInvalidText; NumberType type = {64, SPV_NUMBER_UNSIGNED_INT}; std::vector word_buffer; auto emit = [&word_buffer](uint32_t word) { if (word_buffer.size() == 2) word_buffer.clear(); word_buffer.push_back(word); }; // Zero, maximum, and minimum value rc = ParseAndEncodeIntegerNumber("0", type, emit, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); EXPECT_THAT(word_buffer, Eq(std::vector{0u, 0u})); rc = ParseAndEncodeIntegerNumber("18446744073709551615", type, emit, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); EXPECT_THAT(word_buffer, Eq(std::vector{0xffffffffu, 0xffffffffu})); // Hex parsing rc = ParseAndEncodeIntegerNumber("0xffffffffffffffff", type, emit, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); EXPECT_THAT(word_buffer, Eq(std::vector{0xffffffffu, 0xffffffffu})); } TEST(ParseAndEncodeIntegerNumber, TypeNone) { EncodeNumberStatus rc = EncodeNumberStatus::kSuccess; std::string err_msg; NumberType type = {32, SPV_NUMBER_NONE}; rc = ParseAndEncodeIntegerNumber( "0.0", type, [](uint32_t word) { EXPECT_EQ(0x0u, word); }, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidUsage, rc); EXPECT_EQ("The expected type is not a integer type", err_msg); } TEST(ParseAndEncodeIntegerNumber, InvalidCaseWithoutErrorMessageString) { EncodeNumberStatus rc = EncodeNumberStatus::kSuccess; NumberType type = {32, SPV_NUMBER_SIGNED_INT}; rc = ParseAndEncodeIntegerNumber("invalid", type, AssertEmitFunc, nullptr); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); } TEST(ParseAndEncodeIntegerNumber, DoNotTouchErrorMessageStringOnSuccess) { EncodeNumberStatus rc = EncodeNumberStatus::kInvalidText; std::string err_msg("random content"); NumberType type = {32, SPV_NUMBER_SIGNED_INT}; rc = ParseAndEncodeIntegerNumber( "100", type, [](uint32_t word) { EXPECT_EQ(100u, word); }, &err_msg); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); EXPECT_EQ("random content", err_msg); } TEST(ParseAndEncodeFloat, Sample) { EncodeNumberStatus rc = EncodeNumberStatus::kSuccess; std::string err_msg; NumberType type = {32, SPV_NUMBER_FLOATING}; // Invalid rc = ParseAndEncodeFloatingPointNumber("", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid 32-bit float literal: ", err_msg); rc = ParseAndEncodeFloatingPointNumber("0=", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid 32-bit float literal: 0=", err_msg); // Representative samples rc = ParseAndEncodeFloatingPointNumber( "0.0", type, [](uint32_t word) { EXPECT_EQ(0x0u, word); }, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); rc = ParseAndEncodeFloatingPointNumber( "-0.0", type, [](uint32_t word) { EXPECT_EQ(0x80000000u, word); }, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); rc = ParseAndEncodeFloatingPointNumber( "42", type, [](uint32_t word) { EXPECT_EQ(0x42280000u, word); }, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); rc = ParseAndEncodeFloatingPointNumber( "2.5", type, [](uint32_t word) { EXPECT_EQ(0x40200000u, word); }, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); rc = ParseAndEncodeFloatingPointNumber( "-32.5", type, [](uint32_t word) { EXPECT_EQ(0xc2020000u, word); }, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); rc = ParseAndEncodeFloatingPointNumber( "1e38", type, [](uint32_t word) { EXPECT_EQ(0x7e967699u, word); }, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); rc = ParseAndEncodeFloatingPointNumber( "-1e38", type, [](uint32_t word) { EXPECT_EQ(0xfe967699u, word); }, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); // Overflow rc = ParseAndEncodeFloatingPointNumber("1e40", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid 32-bit float literal: 1e40", err_msg); rc = ParseAndEncodeFloatingPointNumber("-1e40", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid 32-bit float literal: -1e40", err_msg); rc = ParseAndEncodeFloatingPointNumber("1e400", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid 32-bit float literal: 1e400", err_msg); rc = ParseAndEncodeFloatingPointNumber("-1e400", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid 32-bit float literal: -1e400", err_msg); } TEST(ParseAndEncodeDouble, Sample) { EncodeNumberStatus rc = EncodeNumberStatus::kSuccess; std::string err_msg; NumberType type = {64, SPV_NUMBER_FLOATING}; std::vector word_buffer; auto emit = [&word_buffer](uint32_t word) { if (word_buffer.size() == 2) word_buffer.clear(); word_buffer.push_back(word); }; // Invalid rc = ParseAndEncodeFloatingPointNumber("", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid 64-bit float literal: ", err_msg); rc = ParseAndEncodeFloatingPointNumber("0=", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid 64-bit float literal: 0=", err_msg); // Representative samples rc = ParseAndEncodeFloatingPointNumber("0.0", type, emit, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); EXPECT_THAT(word_buffer, Eq(std::vector{0u, 0u})); rc = ParseAndEncodeFloatingPointNumber("-0.0", type, emit, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); EXPECT_THAT(word_buffer, Eq(std::vector{0u, 0x80000000u})); rc = ParseAndEncodeFloatingPointNumber("42", type, emit, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); EXPECT_THAT(word_buffer, Eq(std::vector{0u, 0x40450000u})); rc = ParseAndEncodeFloatingPointNumber("2.5", type, emit, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); EXPECT_THAT(word_buffer, Eq(std::vector{0u, 0x40040000u})); rc = ParseAndEncodeFloatingPointNumber("32.5", type, emit, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); EXPECT_THAT(word_buffer, Eq(std::vector{0u, 0x40404000u})); rc = ParseAndEncodeFloatingPointNumber("1e38", type, emit, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); EXPECT_THAT(word_buffer, Eq(std::vector{0x2a16a1b1u, 0x47d2ced3u})); rc = ParseAndEncodeFloatingPointNumber("-1e38", type, emit, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); EXPECT_THAT(word_buffer, Eq(std::vector{0x2a16a1b1u, 0xc7d2ced3u})); rc = ParseAndEncodeFloatingPointNumber("1e40", type, emit, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); EXPECT_THAT(word_buffer, Eq(std::vector{0xf1c35ca5u, 0x483d6329u})); rc = ParseAndEncodeFloatingPointNumber("-1e40", type, emit, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); EXPECT_THAT(word_buffer, Eq(std::vector{0xf1c35ca5u, 0xc83d6329u})); // Overflow rc = ParseAndEncodeFloatingPointNumber("1e400", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid 64-bit float literal: 1e400", err_msg); rc = ParseAndEncodeFloatingPointNumber("-1e400", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid 64-bit float literal: -1e400", err_msg); } TEST(ParseAndEncodeFloat16, Sample) { EncodeNumberStatus rc = EncodeNumberStatus::kSuccess; std::string err_msg; NumberType type = {16, SPV_NUMBER_FLOATING}; // Invalid rc = ParseAndEncodeFloatingPointNumber("", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid 16-bit float literal: ", err_msg); rc = ParseAndEncodeFloatingPointNumber("0=", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid 16-bit float literal: 0=", err_msg); // Representative samples rc = ParseAndEncodeFloatingPointNumber( "0.0", type, [](uint32_t word) { EXPECT_EQ(0x0u, word); }, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); rc = ParseAndEncodeFloatingPointNumber( "-0.0", type, [](uint32_t word) { EXPECT_EQ(0x8000u, word); }, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); rc = ParseAndEncodeFloatingPointNumber( "1.0", type, [](uint32_t word) { EXPECT_EQ(0x3c00u, word); }, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); rc = ParseAndEncodeFloatingPointNumber( "2.5", type, [](uint32_t word) { EXPECT_EQ(0x4100u, word); }, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); rc = ParseAndEncodeFloatingPointNumber( "32.5", type, [](uint32_t word) { EXPECT_EQ(0x5010u, word); }, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); // Overflow rc = ParseAndEncodeFloatingPointNumber("1e38", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid 16-bit float literal: 1e38", err_msg); rc = ParseAndEncodeFloatingPointNumber("-1e38", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid 16-bit float literal: -1e38", err_msg); rc = ParseAndEncodeFloatingPointNumber("1e40", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid 16-bit float literal: 1e40", err_msg); rc = ParseAndEncodeFloatingPointNumber("-1e40", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid 16-bit float literal: -1e40", err_msg); rc = ParseAndEncodeFloatingPointNumber("1e400", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid 16-bit float literal: 1e400", err_msg); rc = ParseAndEncodeFloatingPointNumber("-1e400", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid 16-bit float literal: -1e400", err_msg); } TEST(ParseAndEncodeFloatingPointNumber, TypeNone) { EncodeNumberStatus rc = EncodeNumberStatus::kSuccess; std::string err_msg; NumberType type = {32, SPV_NUMBER_NONE}; rc = ParseAndEncodeFloatingPointNumber( "0.0", type, [](uint32_t word) { EXPECT_EQ(0x0u, word); }, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidUsage, rc); EXPECT_EQ("The expected type is not a float type", err_msg); } TEST(ParseAndEncodeFloatingPointNumber, InvalidCaseWithoutErrorMessageString) { EncodeNumberStatus rc = EncodeNumberStatus::kSuccess; NumberType type = {32, SPV_NUMBER_FLOATING}; rc = ParseAndEncodeFloatingPointNumber("invalid", type, AssertEmitFunc, nullptr); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); } TEST(ParseAndEncodeFloatingPointNumber, DoNotTouchErrorMessageStringOnSuccess) { EncodeNumberStatus rc = EncodeNumberStatus::kInvalidText; std::string err_msg("random content"); NumberType type = {32, SPV_NUMBER_FLOATING}; rc = ParseAndEncodeFloatingPointNumber( "0.0", type, [](uint32_t word) { EXPECT_EQ(0x0u, word); }, &err_msg); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); EXPECT_EQ("random content", err_msg); } TEST(ParseAndEncodeNumber, Sample) { EncodeNumberStatus rc = EncodeNumberStatus::kSuccess; std::string err_msg; NumberType type = {32, SPV_NUMBER_SIGNED_INT}; // Invalid with error message string rc = ParseAndEncodeNumber("something wrong", type, AssertEmitFunc, &err_msg); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); EXPECT_EQ("Invalid unsigned integer literal: something wrong", err_msg); // Invalid without error message string rc = ParseAndEncodeNumber("something wrong", type, AssertEmitFunc, nullptr); EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc); // Signed integer, should not touch the error message string. err_msg = "random content"; rc = ParseAndEncodeNumber("-1", type, [](uint32_t word) { EXPECT_EQ(0xffffffffu, word); }, &err_msg); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); EXPECT_EQ("random content", err_msg); // Unsigned integer type = {32, SPV_NUMBER_UNSIGNED_INT}; rc = ParseAndEncodeNumber( "1", type, [](uint32_t word) { EXPECT_EQ(1u, word); }, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); // Float type = {32, SPV_NUMBER_FLOATING}; rc = ParseAndEncodeNumber("-1.0", type, [](uint32_t word) { EXPECT_EQ(0xbf800000, word); }, nullptr); EXPECT_EQ(EncodeNumberStatus::kSuccess, rc); } } // namespace } // namespace utils } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/pch_test.cpp000066400000000000000000000011621475742701700220250ustar00rootroot00000000000000// Copyright (c) 2018 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "pch_test.h" KhronosGroup-SPIRV-Tools-f289d04/test/pch_test.h000066400000000000000000000013241475742701700214720ustar00rootroot00000000000000// Copyright (c) 2018 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "gmock/gmock.h" #include "source/spirv_constant.h" #include "test/test_fixture.h" #include "test/unit_spirv.h" KhronosGroup-SPIRV-Tools-f289d04/test/preserve_numeric_ids_test.cpp000066400000000000000000000077261475742701700255030ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Tests for unique type declaration rules validator. #include #include "source/text.h" #include "source/text_handler.h" #include "test/test_fixture.h" namespace spvtools { namespace { using spvtest::ScopedContext; // Converts code to binary and then back to text. spv_result_t ToBinaryAndBack( const std::string& before, std::string* after, uint32_t text_to_binary_options = SPV_TEXT_TO_BINARY_OPTION_NONE, uint32_t binary_to_text_options = SPV_BINARY_TO_TEXT_OPTION_NONE, spv_target_env env = SPV_ENV_UNIVERSAL_1_0) { ScopedContext ctx(env); spv_binary binary; spv_text text; spv_result_t result = spvTextToBinaryWithOptions(ctx.context, before.c_str(), before.size(), text_to_binary_options, &binary, nullptr); if (result != SPV_SUCCESS) { return result; } result = spvBinaryToText(ctx.context, binary->code, binary->wordCount, binary_to_text_options, &text, nullptr); if (result != SPV_SUCCESS) { return result; } *after = std::string(text->str, text->length); spvBinaryDestroy(binary); spvTextDestroy(text); return SPV_SUCCESS; } TEST(ToBinaryAndBack, DontPreserveNumericIds) { const std::string before = R"(OpCapability Addresses OpCapability Kernel OpCapability GenericPointer OpCapability Linkage OpMemoryModel Physical32 OpenCL %i32 = OpTypeInt 32 1 %u32 = OpTypeInt 32 0 %f32 = OpTypeFloat 32 %200 = OpTypeVoid %300 = OpTypeFunction %200 %main = OpFunction %200 None %300 %entry = OpLabel %100 = OpConstant %u32 100 %1 = OpConstant %u32 200 %2 = OpConstant %u32 300 OpReturn OpFunctionEnd )"; const std::string expected = R"(OpCapability Addresses OpCapability Kernel OpCapability GenericPointer OpCapability Linkage OpMemoryModel Physical32 OpenCL %1 = OpTypeInt 32 1 %2 = OpTypeInt 32 0 %3 = OpTypeFloat 32 %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpFunction %4 None %5 %7 = OpLabel %8 = OpConstant %2 100 %9 = OpConstant %2 200 %10 = OpConstant %2 300 OpReturn OpFunctionEnd )"; std::string after; EXPECT_EQ(SPV_SUCCESS, ToBinaryAndBack(before, &after, SPV_TEXT_TO_BINARY_OPTION_NONE, SPV_BINARY_TO_TEXT_OPTION_NO_HEADER)); EXPECT_EQ(expected, after); } TEST(TextHandler, PreserveNumericIds) { const std::string before = R"(OpCapability Addresses OpCapability Kernel OpCapability GenericPointer OpCapability Linkage OpMemoryModel Physical32 OpenCL %i32 = OpTypeInt 32 1 %u32 = OpTypeInt 32 0 %f32 = OpTypeFloat 32 %200 = OpTypeVoid %300 = OpTypeFunction %200 %main = OpFunction %200 None %300 %entry = OpLabel %100 = OpConstant %u32 100 %1 = OpConstant %u32 200 %2 = OpConstant %u32 300 OpReturn OpFunctionEnd )"; const std::string expected = R"(OpCapability Addresses OpCapability Kernel OpCapability GenericPointer OpCapability Linkage OpMemoryModel Physical32 OpenCL %3 = OpTypeInt 32 1 %4 = OpTypeInt 32 0 %5 = OpTypeFloat 32 %200 = OpTypeVoid %300 = OpTypeFunction %200 %6 = OpFunction %200 None %300 %7 = OpLabel %100 = OpConstant %4 100 %1 = OpConstant %4 200 %2 = OpConstant %4 300 OpReturn OpFunctionEnd )"; std::string after; EXPECT_EQ(SPV_SUCCESS, ToBinaryAndBack(before, &after, SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS, SPV_BINARY_TO_TEXT_OPTION_NO_HEADER)); EXPECT_EQ(expected, after); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/reduce/000077500000000000000000000000001475742701700207575ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/reduce/CMakeLists.txt000066400000000000000000000025471475742701700235270ustar00rootroot00000000000000# Copyright (c) 2018 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. add_spvtools_unittest(TARGET reduce SRCS conditional_branch_to_simple_conditional_branch_test.cpp merge_blocks_test.cpp operand_to_constant_test.cpp operand_to_undef_test.cpp operand_to_dominating_id_test.cpp reduce_test_util.cpp reduce_test_util.h reducer_test.cpp remove_block_test.cpp remove_function_test.cpp remove_selection_test.cpp remove_unused_instruction_test.cpp remove_unused_struct_member_test.cpp simple_conditional_branch_to_branch_test.cpp structured_construct_to_block_test.cpp structured_loop_to_selection_test.cpp validation_during_reduction_test.cpp ${spirv-tools_SOURCE_DIR}/tools/io.cpp LIBS SPIRV-Tools-reduce ) conditional_branch_to_simple_conditional_branch_test.cpp000066400000000000000000000365141475742701700342470ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/reduce// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/conditional_branch_to_simple_conditional_branch_opportunity_finder.h" #include "source/opt/build_module.h" #include "source/reduce/reduction_opportunity.h" #include "source/reduce/reduction_pass.h" #include "test/reduce/reduce_test_util.h" namespace spvtools { namespace reduce { namespace { const spv_target_env kEnv = SPV_ENV_UNIVERSAL_1_3; TEST(ConditionalBranchToSimpleConditionalBranchTest, Diamond) { // A test with the following structure. // // selection header // OpBranchConditional // | | // b b // | | // selection merge // // There should be two opportunities for redirecting the OpBranchConditional // targets: redirecting the true to false, and vice-versa. E.g. false to true: // // selection header // OpBranchConditional // || // b b // | | // selection merge std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %2 = OpFunction %3 None %4 %9 = OpLabel OpBranch %10 %10 = OpLabel OpSelectionMerge %11 None OpBranchConditional %8 %12 %13 %12 = OpLabel OpBranch %11 %13 = OpLabel OpBranch %11 %11 = OpLabel OpReturn OpFunctionEnd )"; auto context = BuildModule(kEnv, nullptr, shader, kReduceAssembleOption); CheckValid(kEnv, context.get()); auto ops = ConditionalBranchToSimpleConditionalBranchOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(2, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ASSERT_TRUE(ops[1]->PreconditionHolds()); ops[0]->TryToApply(); // The other opportunity should now be disabled. ASSERT_FALSE(ops[1]->PreconditionHolds()); CheckValid(kEnv, context.get()); { std::string after = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %2 = OpFunction %3 None %4 %9 = OpLabel OpBranch %10 %10 = OpLabel OpSelectionMerge %11 None OpBranchConditional %8 %12 %12 %12 = OpLabel OpBranch %11 %13 = OpLabel OpBranch %11 %11 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(kEnv, after, context.get()); } ops = ConditionalBranchToSimpleConditionalBranchOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(0, ops.size()); // Start again, and apply the other op. context = BuildModule(kEnv, nullptr, shader, kReduceAssembleOption); CheckValid(kEnv, context.get()); ops = ConditionalBranchToSimpleConditionalBranchOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(2, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ASSERT_TRUE(ops[1]->PreconditionHolds()); ops[1]->TryToApply(); // The other opportunity should now be disabled. ASSERT_FALSE(ops[0]->PreconditionHolds()); CheckValid(kEnv, context.get()); { std::string after2 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %2 = OpFunction %3 None %4 %9 = OpLabel OpBranch %10 %10 = OpLabel OpSelectionMerge %11 None OpBranchConditional %8 %13 %13 %12 = OpLabel OpBranch %11 %13 = OpLabel OpBranch %11 %11 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(kEnv, after2, context.get()); } } TEST(ConditionalBranchToSimpleConditionalBranchTest, AlreadySimplified) { // A test with the following structure. // // selection header // OpBranchConditional // || // b b // | | // selection merge // // There should be no opportunities for redirecting the OpBranchConditional // as it is already simplified. // std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %2 = OpFunction %3 None %4 %9 = OpLabel OpBranch %10 %10 = OpLabel OpSelectionMerge %11 None OpBranchConditional %8 %12 %12 %12 = OpLabel OpBranch %11 %11 = OpLabel OpReturn OpFunctionEnd )"; auto context = BuildModule(kEnv, nullptr, shader, kReduceAssembleOption); CheckValid(kEnv, context.get()); auto ops = ConditionalBranchToSimpleConditionalBranchOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(0, ops.size()); } TEST(ConditionalBranchToSimpleConditionalBranchTest, DontRemoveBackEdge) { // A test with the following structure. The loop has a continue construct that // ends with OpBranchConditional. The OpBranchConditional can be simplified, // but only to point to the loop header, otherwise we have removed the // back-edge. Thus, there should be one opportunity instead of two. // // loop header // | // loop continue target and back-edge block // OpBranchConditional // | | // loop merge (to loop header^) std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %2 = OpFunction %3 None %4 %9 = OpLabel OpBranch %10 %10 = OpLabel OpLoopMerge %11 %12 None OpBranch %12 %12 = OpLabel OpBranchConditional %8 %11 %10 %11 = OpLabel OpReturn OpFunctionEnd )"; const auto context = BuildModule(kEnv, nullptr, shader, kReduceAssembleOption); CheckValid(kEnv, context.get()); auto ops = ConditionalBranchToSimpleConditionalBranchOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(1, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); CheckValid(kEnv, context.get()); std::string after = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %2 = OpFunction %3 None %4 %9 = OpLabel OpBranch %10 %10 = OpLabel OpLoopMerge %11 %12 None OpBranch %12 %12 = OpLabel OpBranchConditional %8 %10 %10 %11 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(kEnv, after, context.get()); ops = ConditionalBranchToSimpleConditionalBranchOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(0, ops.size()); } TEST(ConditionalBranchToSimpleConditionalBranchTest, DontRemoveBackEdgeCombinedHeaderContinue) { // A test with the following structure. // // loop header and continue target and back-edge block // OpBranchConditional // | | // loop merge (to loop header^) // // The OpBranchConditional-to-header edge must not be removed, so there should // only be one opportunity. It should change both targets to be to the loop // header. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %2 = OpFunction %3 None %4 %9 = OpLabel OpBranch %10 %10 = OpLabel OpLoopMerge %11 %10 None OpBranchConditional %8 %11 %10 %11 = OpLabel OpReturn OpFunctionEnd )"; const auto context = BuildModule(kEnv, nullptr, shader, kReduceAssembleOption); CheckValid(kEnv, context.get()); auto ops = ConditionalBranchToSimpleConditionalBranchOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(1, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); CheckValid(kEnv, context.get()); std::string after = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %2 = OpFunction %3 None %4 %9 = OpLabel OpBranch %10 %10 = OpLabel OpLoopMerge %11 %10 None OpBranchConditional %8 %10 %10 %11 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(kEnv, after, context.get()); ops = ConditionalBranchToSimpleConditionalBranchOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(0, ops.size()); } TEST(ConditionalBranchToSimpleConditionalBranchTest, BackEdgeUnreachable) { // A test with the following structure. I.e. a loop with an unreachable // continue construct that ends with OpBranchConditional. // // loop header // | // | loop continue target (unreachable) // | | // | back-edge block (unreachable) // | OpBranchConditional // | | | // loop merge (to loop header^) // // The branch to the loop header must not be removed, even though the continue // construct is unreachable. So there should only be one opportunity to make // the true and false targets of the OpBranchConditional to point to the loop // header. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %2 = OpFunction %3 None %4 %9 = OpLabel OpBranch %10 %10 = OpLabel OpLoopMerge %11 %12 None OpBranch %11 %12 = OpLabel OpBranch %13 %13 = OpLabel OpBranchConditional %8 %11 %10 %11 = OpLabel OpReturn OpFunctionEnd )"; const auto context = BuildModule(kEnv, nullptr, shader, kReduceAssembleOption); CheckValid(kEnv, context.get()); auto ops = ConditionalBranchToSimpleConditionalBranchOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(1, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); CheckValid(kEnv, context.get()); std::string after = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %2 = OpFunction %3 None %4 %9 = OpLabel OpBranch %10 %10 = OpLabel OpLoopMerge %11 %12 None OpBranch %11 %12 = OpLabel OpBranch %13 %13 = OpLabel OpBranchConditional %8 %10 %10 %11 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(kEnv, after, context.get()); ops = ConditionalBranchToSimpleConditionalBranchOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(0, ops.size()); } } // namespace } // namespace reduce } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/reduce/merge_blocks_test.cpp000066400000000000000000000530171475742701700251640ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/merge_blocks_reduction_opportunity_finder.h" #include "source/opt/build_module.h" #include "source/reduce/reduction_opportunity.h" #include "test/reduce/reduce_test_util.h" namespace spvtools { namespace reduce { namespace { TEST(MergeBlocksReductionPassTest, BasicCheck) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "x" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %10 = OpConstant %6 2 %11 = OpConstant %6 3 %12 = OpConstant %6 4 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpBranch %13 %13 = OpLabel OpStore %8 %9 OpBranch %14 %14 = OpLabel OpStore %8 %10 OpBranch %15 %15 = OpLabel OpStore %8 %11 OpBranch %16 %16 = OpLabel OpStore %8 %12 OpBranch %17 %17 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kReduceAssembleOption); const auto ops = MergeBlocksReductionOpportunityFinder().GetAvailableOpportunities( context.get(), 0); ASSERT_EQ(5, ops.size()); // Try order 3, 0, 2, 4, 1 ASSERT_TRUE(ops[3]->PreconditionHolds()); ops[3]->TryToApply(); std::string after_op_3 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "x" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %10 = OpConstant %6 2 %11 = OpConstant %6 3 %12 = OpConstant %6 4 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpBranch %13 %13 = OpLabel OpStore %8 %9 OpBranch %14 %14 = OpLabel OpStore %8 %10 OpBranch %15 %15 = OpLabel OpStore %8 %11 OpStore %8 %12 OpBranch %17 %17 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, after_op_3, context.get()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); std::string after_op_0 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "x" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %10 = OpConstant %6 2 %11 = OpConstant %6 3 %12 = OpConstant %6 4 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpStore %8 %9 OpBranch %14 %14 = OpLabel OpStore %8 %10 OpBranch %15 %15 = OpLabel OpStore %8 %11 OpStore %8 %12 OpBranch %17 %17 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, after_op_0, context.get()); ASSERT_TRUE(ops[2]->PreconditionHolds()); ops[2]->TryToApply(); std::string after_op_2 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "x" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %10 = OpConstant %6 2 %11 = OpConstant %6 3 %12 = OpConstant %6 4 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpStore %8 %9 OpBranch %14 %14 = OpLabel OpStore %8 %10 OpStore %8 %11 OpStore %8 %12 OpBranch %17 %17 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, after_op_2, context.get()); ASSERT_TRUE(ops[4]->PreconditionHolds()); ops[4]->TryToApply(); std::string after_op_4 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "x" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %10 = OpConstant %6 2 %11 = OpConstant %6 3 %12 = OpConstant %6 4 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpStore %8 %9 OpBranch %14 %14 = OpLabel OpStore %8 %10 OpStore %8 %11 OpStore %8 %12 OpReturn OpFunctionEnd )"; CheckEqual(env, after_op_4, context.get()); ASSERT_TRUE(ops[1]->PreconditionHolds()); ops[1]->TryToApply(); std::string after_op_1 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "x" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %10 = OpConstant %6 2 %11 = OpConstant %6 3 %12 = OpConstant %6 4 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpStore %8 %9 OpStore %8 %10 OpStore %8 %11 OpStore %8 %12 OpReturn OpFunctionEnd )"; CheckEqual(env, after_op_1, context.get()); } TEST(MergeBlocksReductionPassTest, Loops) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "x" OpName %10 "i" OpName %29 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %11 = OpConstant %6 0 %18 = OpConstant %6 10 %19 = OpTypeBool %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %29 = OpVariable %7 Function OpStore %8 %9 OpBranch %45 %45 = OpLabel OpStore %10 %11 OpBranch %12 %12 = OpLabel OpLoopMerge %14 %15 None OpBranch %16 %16 = OpLabel %17 = OpLoad %6 %10 OpBranch %46 %46 = OpLabel %20 = OpSLessThan %19 %17 %18 OpBranchConditional %20 %13 %14 %13 = OpLabel %21 = OpLoad %6 %10 OpBranch %47 %47 = OpLabel %22 = OpLoad %6 %8 %23 = OpIAdd %6 %22 %21 OpStore %8 %23 %24 = OpLoad %6 %10 %25 = OpLoad %6 %8 %26 = OpIAdd %6 %25 %24 OpStore %8 %26 OpBranch %48 %48 = OpLabel OpBranch %15 %15 = OpLabel %27 = OpLoad %6 %10 %28 = OpIAdd %6 %27 %9 OpStore %10 %28 OpBranch %12 %14 = OpLabel OpStore %29 %11 OpBranch %49 %49 = OpLabel OpBranch %30 %30 = OpLabel OpLoopMerge %32 %33 None OpBranch %34 %34 = OpLabel %35 = OpLoad %6 %29 %36 = OpSLessThan %19 %35 %18 OpBranch %50 %50 = OpLabel OpBranchConditional %36 %31 %32 %31 = OpLabel %37 = OpLoad %6 %29 %38 = OpLoad %6 %8 %39 = OpIAdd %6 %38 %37 OpStore %8 %39 %40 = OpLoad %6 %29 %41 = OpLoad %6 %8 %42 = OpIAdd %6 %41 %40 OpStore %8 %42 OpBranch %33 %33 = OpLabel %43 = OpLoad %6 %29 %44 = OpIAdd %6 %43 %9 OpBranch %51 %51 = OpLabel OpStore %29 %44 OpBranch %30 %32 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kReduceAssembleOption); const auto ops = MergeBlocksReductionOpportunityFinder().GetAvailableOpportunities( context.get(), 0); ASSERT_EQ(11, ops.size()); for (auto& ri : ops) { ASSERT_TRUE(ri->PreconditionHolds()); ri->TryToApply(); } std::string after = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "x" OpName %10 "i" OpName %29 "i" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %11 = OpConstant %6 0 %18 = OpConstant %6 10 %19 = OpTypeBool %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %29 = OpVariable %7 Function OpStore %8 %9 OpStore %10 %11 OpBranch %12 %12 = OpLabel %17 = OpLoad %6 %10 %20 = OpSLessThan %19 %17 %18 OpLoopMerge %14 %13 None OpBranchConditional %20 %13 %14 %13 = OpLabel %21 = OpLoad %6 %10 %22 = OpLoad %6 %8 %23 = OpIAdd %6 %22 %21 OpStore %8 %23 %24 = OpLoad %6 %10 %25 = OpLoad %6 %8 %26 = OpIAdd %6 %25 %24 OpStore %8 %26 %27 = OpLoad %6 %10 %28 = OpIAdd %6 %27 %9 OpStore %10 %28 OpBranch %12 %14 = OpLabel OpStore %29 %11 OpBranch %30 %30 = OpLabel %35 = OpLoad %6 %29 %36 = OpSLessThan %19 %35 %18 OpLoopMerge %32 %31 None OpBranchConditional %36 %31 %32 %31 = OpLabel %37 = OpLoad %6 %29 %38 = OpLoad %6 %8 %39 = OpIAdd %6 %38 %37 OpStore %8 %39 %40 = OpLoad %6 %29 %41 = OpLoad %6 %8 %42 = OpIAdd %6 %41 %40 OpStore %8 %42 %43 = OpLoad %6 %29 %44 = OpIAdd %6 %43 %9 OpStore %29 %44 OpBranch %30 %32 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, after, context.get()); } TEST(MergeBlocksReductionPassTest, MergeWithOpPhi) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "x" OpName %10 "y" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function OpStore %8 %9 %11 = OpLoad %6 %8 OpBranch %12 %12 = OpLabel %13 = OpPhi %6 %11 %5 OpStore %10 %13 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kReduceAssembleOption); const auto ops = MergeBlocksReductionOpportunityFinder().GetAvailableOpportunities( context.get(), 0); ASSERT_EQ(1, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); std::string after = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "x" OpName %10 "y" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function OpStore %8 %9 %11 = OpLoad %6 %8 OpStore %10 %11 OpReturn OpFunctionEnd )"; CheckEqual(env, after, context.get()); } void MergeBlocksReductionPassTest_LoopReturn_Helper(bool reverse) { // A merge block opportunity stores a block that can be merged with its // predecessor. // Given blocks A -> B -> C: // This test demonstrates how merging B->C can invalidate // the opportunity of merging A->B, and vice-versa. E.g. // B->C are merged: B is now terminated with OpReturn. // A->B can now no longer be merged because A is a loop header, which // cannot be terminated with OpReturn. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantFalse %7 %2 = OpFunction %3 None %4 %9 = OpLabel OpBranch %10 %10 = OpLabel ; A (loop header) OpLoopMerge %13 %12 None OpBranch %11 %12 = OpLabel ; (unreachable continue block) OpBranch %10 %11 = OpLabel ; B OpBranch %15 %15 = OpLabel ; C OpReturn %13 = OpLabel ; (unreachable merge block) OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kReduceAssembleOption); ASSERT_NE(context.get(), nullptr); auto opportunities = MergeBlocksReductionOpportunityFinder().GetAvailableOpportunities( context.get(), 0); // A->B and B->C ASSERT_EQ(opportunities.size(), 2); // Test applying opportunities in both orders. if (reverse) { std::reverse(opportunities.begin(), opportunities.end()); } size_t num_applied = 0; for (auto& ri : opportunities) { if (ri->PreconditionHolds()) { ri->TryToApply(); ++num_applied; } } // Only 1 opportunity can be applied, as both disable each other. ASSERT_EQ(num_applied, 1); std::string after = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantFalse %7 %2 = OpFunction %3 None %4 %9 = OpLabel OpBranch %10 %10 = OpLabel ; A-B (loop header) OpLoopMerge %13 %12 None OpBranch %15 %12 = OpLabel ; (unreachable continue block) OpBranch %10 %15 = OpLabel ; C OpReturn %13 = OpLabel ; (unreachable merge block) OpReturn OpFunctionEnd )"; // The only difference is the labels. std::string after_reversed = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantFalse %7 %2 = OpFunction %3 None %4 %9 = OpLabel OpBranch %10 %10 = OpLabel ; A (loop header) OpLoopMerge %13 %12 None OpBranch %11 %12 = OpLabel ; (unreachable continue block) OpBranch %10 %11 = OpLabel ; B-C OpReturn %13 = OpLabel ; (unreachable merge block) OpReturn OpFunctionEnd )"; CheckEqual(env, reverse ? after_reversed : after, context.get()); } TEST(MergeBlocksReductionPassTest, LoopReturn) { MergeBlocksReductionPassTest_LoopReturn_Helper(false); } TEST(MergeBlocksReductionPassTest, LoopReturnReverse) { MergeBlocksReductionPassTest_LoopReturn_Helper(true); } TEST(MergeBlocksReductionPassTest, MergeUnreachable) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %11 = OpTypeBool %12 = OpConstantFalse %11 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn %9 = OpLabel OpBranch %100 %100 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kReduceAssembleOption); const auto ops = MergeBlocksReductionOpportunityFinder().GetAvailableOpportunities( context.get(), 0); ASSERT_EQ(1, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); std::string after = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %11 = OpTypeBool %12 = OpConstantFalse %11 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn %9 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, after, context.get()); } } // namespace } // namespace reduce } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/reduce/operand_to_constant_test.cpp000066400000000000000000000244201475742701700265670ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/operand_to_const_reduction_opportunity_finder.h" #include "source/opt/build_module.h" #include "source/reduce/reduction_opportunity.h" #include "test/reduce/reduce_test_util.h" namespace spvtools { namespace reduce { namespace { TEST(OperandToConstantReductionPassTest, BasicCheck) { std::string prologue = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %37 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %9 "buf1" OpMemberName %9 0 "f" OpName %11 "" OpName %24 "buf2" OpMemberName %24 0 "i" OpName %26 "" OpName %37 "_GLF_color" OpMemberDecorate %9 0 Offset 0 OpDecorate %9 Block OpDecorate %11 DescriptorSet 0 OpDecorate %11 Binding 1 OpMemberDecorate %24 0 Offset 0 OpDecorate %24 Block OpDecorate %26 DescriptorSet 0 OpDecorate %26 Binding 2 OpDecorate %37 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %9 = OpTypeStruct %6 %10 = OpTypePointer Uniform %9 %11 = OpVariable %10 Uniform %12 = OpTypeInt 32 1 %13 = OpConstant %12 0 %14 = OpTypePointer Uniform %6 %20 = OpConstant %6 2 %24 = OpTypeStruct %12 %25 = OpTypePointer Uniform %24 %26 = OpVariable %25 Uniform %27 = OpTypePointer Uniform %12 %33 = OpConstant %12 3 %35 = OpTypeVector %6 4 %36 = OpTypePointer Output %35 %37 = OpVariable %36 Output %4 = OpFunction %2 None %3 %5 = OpLabel %15 = OpAccessChain %14 %11 %13 %16 = OpLoad %6 %15 %19 = OpFAdd %6 %16 %16 %21 = OpFAdd %6 %19 %20 %28 = OpAccessChain %27 %26 %13 %29 = OpLoad %12 %28 )"; std::string epilogue = R"( %45 = OpConvertSToF %6 %34 %46 = OpCompositeConstruct %35 %16 %21 %43 %45 OpStore %37 %46 OpReturn OpFunctionEnd )"; std::string original = prologue + R"( %32 = OpIAdd %12 %29 %29 %34 = OpIAdd %12 %32 %33 %43 = OpConvertSToF %6 %29 )" + epilogue; std::string expected = prologue + R"( %32 = OpIAdd %12 %13 %13 ; %29 -> %13 x 2 %34 = OpIAdd %12 %13 %33 ; %32 -> %13 %43 = OpConvertSToF %6 %13 ; %29 -> %13 )" + epilogue; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, original, kReduceAssembleOption); const auto ops = OperandToConstReductionOpportunityFinder().GetAvailableOpportunities( context.get(), 0); ASSERT_EQ(17, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); ASSERT_TRUE(ops[1]->PreconditionHolds()); ops[1]->TryToApply(); ASSERT_TRUE(ops[2]->PreconditionHolds()); ops[2]->TryToApply(); ASSERT_TRUE(ops[3]->PreconditionHolds()); ops[3]->TryToApply(); CheckEqual(env, expected, context.get()); } TEST(OperandToConstantReductionPassTest, WithCalledFunction) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %10 %12 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypeFunction %7 %9 = OpTypePointer Output %7 %10 = OpVariable %9 Output %11 = OpTypePointer Input %7 %12 = OpVariable %11 Input %13 = OpConstant %6 0 %14 = OpConstantComposite %7 %13 %13 %13 %13 %4 = OpFunction %2 None %3 %5 = OpLabel %15 = OpFunctionCall %7 %16 OpReturn OpFunctionEnd %16 = OpFunction %7 None %8 %17 = OpLabel OpReturnValue %14 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kReduceAssembleOption); const auto ops = OperandToConstReductionOpportunityFinder().GetAvailableOpportunities( context.get(), 0); ASSERT_EQ(0, ops.size()); } TEST(OperandToConstantReductionPassTest, TargetSpecificFunction) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %6 %7 %17 = OpConstant %6 1 %20 = OpConstant %6 2 %23 = OpConstant %6 0 %24 = OpTypeBool %35 = OpConstant %6 3 %53 = OpConstant %6 10 %4 = OpFunction %2 None %3 %5 = OpLabel %65 = OpVariable %7 Function %68 = OpVariable %7 Function %73 = OpVariable %7 Function OpStore %65 %35 %66 = OpLoad %6 %65 %67 = OpIAdd %6 %66 %17 OpStore %65 %67 %69 = OpLoad %6 %65 OpStore %68 %69 %70 = OpFunctionCall %6 %13 %68 %71 = OpLoad %6 %65 %72 = OpIAdd %6 %71 %70 OpStore %65 %72 %74 = OpLoad %6 %65 OpStore %73 %74 %75 = OpFunctionCall %6 %10 %73 %76 = OpLoad %6 %65 %77 = OpIAdd %6 %76 %75 OpStore %65 %77 OpReturn OpFunctionEnd %10 = OpFunction %6 None %8 %9 = OpFunctionParameter %7 %11 = OpLabel %15 = OpVariable %7 Function %16 = OpLoad %6 %9 %18 = OpIAdd %6 %16 %17 OpStore %15 %18 %19 = OpLoad %6 %15 %21 = OpIAdd %6 %19 %20 OpStore %15 %21 %22 = OpLoad %6 %15 %25 = OpSGreaterThan %24 %22 %23 OpSelectionMerge %27 None OpBranchConditional %25 %26 %27 %26 = OpLabel %28 = OpLoad %6 %9 OpReturnValue %28 %27 = OpLabel %30 = OpLoad %6 %9 %31 = OpIAdd %6 %30 %17 OpReturnValue %31 OpFunctionEnd %13 = OpFunction %6 None %8 %12 = OpFunctionParameter %7 %14 = OpLabel %41 = OpVariable %7 Function %46 = OpVariable %7 Function %55 = OpVariable %7 Function %34 = OpLoad %6 %12 %36 = OpIEqual %24 %34 %35 OpSelectionMerge %38 None OpBranchConditional %36 %37 %38 %37 = OpLabel %39 = OpLoad %6 %12 %40 = OpIMul %6 %20 %39 OpStore %41 %40 %42 = OpFunctionCall %6 %10 %41 OpReturnValue %42 %38 = OpLabel %44 = OpLoad %6 %12 %45 = OpIAdd %6 %44 %17 OpStore %12 %45 OpStore %46 %23 OpBranch %47 %47 = OpLabel OpLoopMerge %49 %50 None OpBranch %51 %51 = OpLabel %52 = OpLoad %6 %46 %54 = OpSLessThan %24 %52 %53 OpBranchConditional %54 %48 %49 %48 = OpLabel %56 = OpLoad %6 %12 OpStore %55 %56 %57 = OpFunctionCall %6 %10 %55 %58 = OpLoad %6 %12 %59 = OpIAdd %6 %58 %57 OpStore %12 %59 OpBranch %50 %50 = OpLabel %60 = OpLoad %6 %46 %61 = OpIAdd %6 %60 %17 OpStore %46 %61 OpBranch %47 %49 = OpLabel %62 = OpLoad %6 %12 OpReturnValue %62 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kReduceAssembleOption); // Targeting all functions, there are quite a few opportunities. To avoid // making the test too sensitive, we check that there are more than a number // somewhat lower than the real number. const auto all_ops = OperandToConstReductionOpportunityFinder().GetAvailableOpportunities( context.get(), 0); ASSERT_TRUE(all_ops.size() > 100); // Targeting individual functions, there are fewer opportunities. Again, we // avoid checking against an exact number so that the test is not too // sensitive. const auto ops_for_function_4 = OperandToConstReductionOpportunityFinder().GetAvailableOpportunities( context.get(), 4); const auto ops_for_function_10 = OperandToConstReductionOpportunityFinder().GetAvailableOpportunities( context.get(), 10); const auto ops_for_function_13 = OperandToConstReductionOpportunityFinder().GetAvailableOpportunities( context.get(), 13); ASSERT_TRUE(ops_for_function_4.size() < 60); ASSERT_TRUE(ops_for_function_10.size() < 50); ASSERT_TRUE(ops_for_function_13.size() < 80); // The total number of opportunities should be the sum of the per-function // opportunities. ASSERT_EQ(all_ops.size(), ops_for_function_4.size() + ops_for_function_10.size() + ops_for_function_13.size()); } } // namespace } // namespace reduce } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/reduce/operand_to_dominating_id_test.cpp000066400000000000000000000145051475742701700275460ustar00rootroot00000000000000// Copyright (c) 2018 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/operand_to_dominating_id_reduction_opportunity_finder.h" #include "source/opt/build_module.h" #include "source/reduce/reduction_opportunity.h" #include "test/reduce/reduce_test_util.h" namespace spvtools { namespace reduce { namespace { TEST(OperandToDominatingIdReductionPassTest, BasicCheck) { std::string original = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %14 = OpVariable %7 Function OpStore %8 %9 %11 = OpLoad %6 %8 %12 = OpLoad %6 %8 %13 = OpIAdd %6 %11 %12 OpStore %10 %13 %15 = OpLoad %6 %10 OpStore %14 %15 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, original, kReduceAssembleOption); const auto ops = OperandToDominatingIdReductionOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(10, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); std::string after_op_0 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %14 = OpVariable %7 Function OpStore %8 %9 %11 = OpLoad %6 %8 %12 = OpLoad %6 %8 %13 = OpIAdd %6 %11 %12 OpStore %8 %13 ; %10 -> %8 %15 = OpLoad %6 %10 OpStore %14 %15 OpReturn OpFunctionEnd )"; CheckEqual(env, after_op_0, context.get()); ASSERT_TRUE(ops[1]->PreconditionHolds()); ops[1]->TryToApply(); std::string after_op_1 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %14 = OpVariable %7 Function OpStore %8 %9 %11 = OpLoad %6 %8 %12 = OpLoad %6 %8 %13 = OpIAdd %6 %11 %12 OpStore %8 %13 ; %10 -> %8 %15 = OpLoad %6 %8 ; %10 -> %8 OpStore %14 %15 OpReturn OpFunctionEnd )"; CheckEqual(env, after_op_1, context.get()); ASSERT_TRUE(ops[2]->PreconditionHolds()); ops[2]->TryToApply(); std::string after_op_2 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %14 = OpVariable %7 Function OpStore %8 %9 %11 = OpLoad %6 %8 %12 = OpLoad %6 %8 %13 = OpIAdd %6 %11 %12 OpStore %8 %13 ; %10 -> %8 %15 = OpLoad %6 %8 ; %10 -> %8 OpStore %8 %15 ; %14 -> %8 OpReturn OpFunctionEnd )"; CheckEqual(env, after_op_2, context.get()); // The precondition has been disabled by an earlier opportunity's application. ASSERT_FALSE(ops[3]->PreconditionHolds()); ASSERT_TRUE(ops[4]->PreconditionHolds()); ops[4]->TryToApply(); std::string after_op_4 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %14 = OpVariable %7 Function OpStore %8 %9 %11 = OpLoad %6 %8 %12 = OpLoad %6 %8 %13 = OpIAdd %6 %11 %11 ; %12 -> %11 OpStore %8 %13 ; %10 -> %8 %15 = OpLoad %6 %8 ; %10 -> %8 OpStore %8 %15 ; %14 -> %8 OpReturn OpFunctionEnd )"; CheckEqual(env, after_op_4, context.get()); } } // namespace } // namespace reduce } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/reduce/operand_to_undef_test.cpp000066400000000000000000000177671475742701700260570ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/operand_to_undef_reduction_opportunity_finder.h" #include "source/opt/build_module.h" #include "source/reduce/reduction_opportunity.h" #include "test/reduce/reduce_test_util.h" namespace spvtools { namespace reduce { namespace { TEST(OperandToUndefReductionPassTest, BasicCheck) { // The following shader has 10 opportunities for replacing with undef. // #version 310 es // // precision highp float; // // layout(location=0) out vec4 _GLF_color; // // layout(set = 0, binding = 0) uniform buf0 { // vec2 uniform1; // }; // // void main() // { // _GLF_color = // vec4( // opportunity // uniform1.x / 2.0, // opportunity x2 (2.0 is const) // uniform1.y / uniform1.x, // opportunity x3 // uniform1.x + uniform1.x, // opportunity x3 // uniform1.y); // opportunity // } std::string original = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %9 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %9 "_GLF_color" OpName %11 "buf0" OpMemberName %11 0 "uniform1" OpName %13 "" OpDecorate %9 Location 0 OpMemberDecorate %11 0 Offset 0 OpDecorate %11 Block OpDecorate %13 DescriptorSet 0 OpDecorate %13 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypePointer Output %7 %9 = OpVariable %8 Output %10 = OpTypeVector %6 2 %11 = OpTypeStruct %10 %12 = OpTypePointer Uniform %11 %13 = OpVariable %12 Uniform %14 = OpTypeInt 32 1 %15 = OpConstant %14 0 %16 = OpTypeInt 32 0 %17 = OpConstant %16 0 %18 = OpTypePointer Uniform %6 %21 = OpConstant %6 2 %23 = OpConstant %16 1 %4 = OpFunction %2 None %3 %5 = OpLabel %19 = OpAccessChain %18 %13 %15 %17 %20 = OpLoad %6 %19 %22 = OpFDiv %6 %20 %21 ; opportunity %20 (%21 is const) %24 = OpAccessChain %18 %13 %15 %23 %25 = OpLoad %6 %24 %26 = OpAccessChain %18 %13 %15 %17 %27 = OpLoad %6 %26 %28 = OpFDiv %6 %25 %27 ; opportunity %25 %27 %29 = OpAccessChain %18 %13 %15 %17 %30 = OpLoad %6 %29 %31 = OpAccessChain %18 %13 %15 %17 %32 = OpLoad %6 %31 %33 = OpFAdd %6 %30 %32 ; opportunity %30 %32 %34 = OpAccessChain %18 %13 %15 %23 %35 = OpLoad %6 %34 %36 = OpCompositeConstruct %7 %22 %28 %33 %35 ; opportunity %22 %28 %33 %35 OpStore %9 %36 ; opportunity %36 OpReturn OpFunctionEnd )"; // This is the same as original, except where noted. std::string expected = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %9 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %9 "_GLF_color" OpName %11 "buf0" OpMemberName %11 0 "uniform1" OpName %13 "" OpDecorate %9 Location 0 OpMemberDecorate %11 0 Offset 0 OpDecorate %11 Block OpDecorate %13 DescriptorSet 0 OpDecorate %13 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypePointer Output %7 %9 = OpVariable %8 Output %10 = OpTypeVector %6 2 %11 = OpTypeStruct %10 %12 = OpTypePointer Uniform %11 %13 = OpVariable %12 Uniform %14 = OpTypeInt 32 1 %15 = OpConstant %14 0 %16 = OpTypeInt 32 0 %17 = OpConstant %16 0 %18 = OpTypePointer Uniform %6 %21 = OpConstant %6 2 %23 = OpConstant %16 1 %37 = OpUndef %6 ; Added undef float as %37 %4 = OpFunction %2 None %3 %5 = OpLabel %19 = OpAccessChain %18 %13 %15 %17 %20 = OpLoad %6 %19 %22 = OpFDiv %6 %37 %21 ; Replaced with %37 %24 = OpAccessChain %18 %13 %15 %23 %25 = OpLoad %6 %24 %26 = OpAccessChain %18 %13 %15 %17 %27 = OpLoad %6 %26 %28 = OpFDiv %6 %37 %37 ; Replaced with %37 twice %29 = OpAccessChain %18 %13 %15 %17 %30 = OpLoad %6 %29 %31 = OpAccessChain %18 %13 %15 %17 %32 = OpLoad %6 %31 %33 = OpFAdd %6 %30 %32 %34 = OpAccessChain %18 %13 %15 %23 %35 = OpLoad %6 %34 %36 = OpCompositeConstruct %7 %22 %28 %33 %35 OpStore %9 %36 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, original, kReduceAssembleOption); const auto ops = OperandToUndefReductionOpportunityFinder().GetAvailableOpportunities( context.get(), 0); ASSERT_EQ(10, ops.size()); // Apply first three opportunities. ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); ASSERT_TRUE(ops[1]->PreconditionHolds()); ops[1]->TryToApply(); ASSERT_TRUE(ops[2]->PreconditionHolds()); ops[2]->TryToApply(); CheckEqual(env, expected, context.get()); } TEST(OperandToUndefReductionPassTest, WithCalledFunction) { // The following shader has no opportunities. // Most importantly, the noted function operand is not changed. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %10 %12 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypeFunction %7 %9 = OpTypePointer Output %7 %10 = OpVariable %9 Output %11 = OpTypePointer Input %7 %12 = OpVariable %11 Input %13 = OpConstant %6 0 %14 = OpConstantComposite %7 %13 %13 %13 %13 %4 = OpFunction %2 None %3 %5 = OpLabel %15 = OpFunctionCall %7 %16 ; do not replace %16 with undef OpReturn OpFunctionEnd %16 = OpFunction %7 None %8 %17 = OpLabel OpReturnValue %14 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kReduceAssembleOption); const auto ops = OperandToUndefReductionOpportunityFinder().GetAvailableOpportunities( context.get(), 0); ASSERT_EQ(0, ops.size()); } } // namespace } // namespace reduce } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/reduce/reduce_test_util.cpp000066400000000000000000000106521475742701700250320ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "test/reduce/reduce_test_util.h" #include #include "tools/io.h" namespace spvtools { namespace reduce { const spvtools::MessageConsumer kConsoleMessageConsumer = [](spv_message_level_t level, const char*, const spv_position_t& position, const char* message) -> void { switch (level) { case SPV_MSG_FATAL: case SPV_MSG_INTERNAL_ERROR: case SPV_MSG_ERROR: std::cerr << "error: line " << position.index << ": " << message << std::endl; break; case SPV_MSG_WARNING: std::cout << "warning: line " << position.index << ": " << message << std::endl; break; case SPV_MSG_INFO: std::cout << "info: line " << position.index << ": " << message << std::endl; break; default: break; } }; void CheckEqual(const spv_target_env env, const std::vector& expected_binary, const std::vector& actual_binary) { if (expected_binary != actual_binary) { SpirvTools t(env); std::string expected_disassembled; std::string actual_disassembled; ASSERT_TRUE(t.Disassemble(expected_binary, &expected_disassembled, kReduceDisassembleOption)); ASSERT_TRUE(t.Disassemble(actual_binary, &actual_disassembled, kReduceDisassembleOption)); ASSERT_EQ(expected_disassembled, actual_disassembled); } } void CheckEqual(const spv_target_env env, const std::string& expected_text, const std::vector& actual_binary) { std::vector expected_binary; SpirvTools t(env); ASSERT_TRUE( t.Assemble(expected_text, &expected_binary, kReduceAssembleOption)); CheckEqual(env, expected_binary, actual_binary); } void CheckEqual(const spv_target_env env, const std::string& expected_text, const opt::IRContext* actual_ir) { std::vector actual_binary; actual_ir->module()->ToBinary(&actual_binary, false); CheckEqual(env, expected_text, actual_binary); } void CheckValid(spv_target_env env, const opt::IRContext* ir) { std::vector binary; ir->module()->ToBinary(&binary, false); SpirvTools tools(env); tools.SetMessageConsumer(kConsoleMessageConsumer); ASSERT_TRUE(tools.Validate(binary)); } std::string ToString(spv_target_env env, const opt::IRContext* ir) { std::vector binary; ir->module()->ToBinary(&binary, false); SpirvTools t(env); std::string result; t.Disassemble(binary, &result, kReduceDisassembleOption); return result; } void NopDiagnostic(spv_message_level_t /*level*/, const char* /*source*/, const spv_position_t& /*position*/, const char* /*message*/) {} void CLIMessageConsumer(spv_message_level_t level, const char*, const spv_position_t& position, const char* message) { switch (level) { case SPV_MSG_FATAL: case SPV_MSG_INTERNAL_ERROR: case SPV_MSG_ERROR: std::cerr << "error: line " << position.index << ": " << message << std::endl; break; case SPV_MSG_WARNING: std::cout << "warning: line " << position.index << ": " << message << std::endl; break; case SPV_MSG_INFO: std::cout << "info: line " << position.index << ": " << message << std::endl; break; default: break; } } void DumpShader(opt::IRContext* context, const char* filename) { std::vector binary; context->module()->ToBinary(&binary, false); DumpShader(binary, filename); } void DumpShader(const std::vector& binary, const char* filename) { auto write_file_succeeded = WriteFile(filename, "wb", &binary[0], binary.size()); if (!write_file_succeeded) { std::cerr << "Failed to dump shader" << std::endl; } } } // namespace reduce } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/reduce/reduce_test_util.h000066400000000000000000000057471475742701700245100ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef TEST_REDUCE_REDUCE_TEST_UTIL_H_ #define TEST_REDUCE_REDUCE_TEST_UTIL_H_ #include "gtest/gtest.h" #include "source/opt/ir_context.h" #include "source/reduce/reduction_opportunity.h" #include "spirv-tools/libspirv.h" namespace spvtools { namespace reduce { // Checks whether the given binaries are bit-wise equal. void CheckEqual(spv_target_env env, const std::vector& expected_binary, const std::vector& actual_binary); // Assembles the given text and check whether the resulting binary is bit-wise // equal to the given binary. void CheckEqual(spv_target_env env, const std::string& expected_text, const std::vector& actual_binary); // Assembles the given text and turns the given IR into binary, then checks // whether the resulting binaries are bit-wise equal. void CheckEqual(spv_target_env env, const std::string& expected_text, const opt::IRContext* actual_ir); // Assembles the given IR context and checks whether the resulting binary is // valid. void CheckValid(spv_target_env env, const opt::IRContext* ir); // Assembles the given IR context, then returns its disassembly as a string. // Useful for debugging. std::string ToString(spv_target_env env, const opt::IRContext* ir); // Assembly options for writing reduction tests. It simplifies matters if // numeric ids do not change. const uint32_t kReduceAssembleOption = SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS; // Disassembly options for writing reduction tests. const uint32_t kReduceDisassembleOption = SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | SPV_BINARY_TO_TEXT_OPTION_INDENT; // Don't print reducer info during testing. void NopDiagnostic(spv_message_level_t /*level*/, const char* /*source*/, const spv_position_t& /*position*/, const char* /*message*/); // Prints reducer messages (for debugging). void CLIMessageConsumer(spv_message_level_t level, const char*, const spv_position_t& position, const char* message); // Dumps the SPIRV-V module in |context| to file |filename|. Useful for // interactive debugging. void DumpShader(opt::IRContext* context, const char* filename); // Dumps |binary| to file |filename|. Useful for interactive debugging. void DumpShader(const std::vector& binary, const char* filename); } // namespace reduce } // namespace spvtools #endif // TEST_REDUCE_REDUCE_TEST_UTIL_H_ KhronosGroup-SPIRV-Tools-f289d04/test/reduce/reducer_test.cpp000066400000000000000000000474031475742701700241630ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/reducer.h" #include #include "source/opt/build_module.h" #include "source/reduce/operand_to_const_reduction_opportunity_finder.h" #include "source/reduce/remove_unused_instruction_reduction_opportunity_finder.h" #include "test/reduce/reduce_test_util.h" namespace spvtools { namespace reduce { namespace { const spv_target_env kEnv = SPV_ENV_UNIVERSAL_1_3; const MessageConsumer kMessageConsumer = NopDiagnostic; // This changes its mind each time IsInteresting is invoked as to whether the // binary is interesting, until some limit is reached after which the binary is // always deemed interesting. This is useful to test that reduction passes // interleave in interesting ways for a while, and then always succeed after // some point; the latter is important to end up with a predictable final // reduced binary for tests. class PingPongInteresting { public: explicit PingPongInteresting(uint32_t always_interesting_after) : is_interesting_(true), always_interesting_after_(always_interesting_after), count_(0) {} bool IsInteresting() { bool result; if (count_ > always_interesting_after_) { result = true; } else { result = is_interesting_; is_interesting_ = !is_interesting_; } count_++; return result; } private: bool is_interesting_; const uint32_t always_interesting_after_; uint32_t count_; }; TEST(ReducerTest, ExprToConstantAndRemoveUnreferenced) { // Check that ExprToConstant and RemoveUnreferenced work together; once some // ID uses have been changed to constants, those IDs can be removed. std::string original = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %60 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %16 "buf2" OpMemberName %16 0 "i" OpName %18 "" OpName %25 "buf1" OpMemberName %25 0 "f" OpName %27 "" OpName %60 "_GLF_color" OpMemberDecorate %16 0 Offset 0 OpDecorate %16 Block OpDecorate %18 DescriptorSet 0 OpDecorate %18 Binding 2 OpMemberDecorate %25 0 Offset 0 OpDecorate %25 Block OpDecorate %27 DescriptorSet 0 OpDecorate %27 Binding 1 OpDecorate %60 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %9 = OpConstant %6 0 %16 = OpTypeStruct %6 %17 = OpTypePointer Uniform %16 %18 = OpVariable %17 Uniform %19 = OpTypePointer Uniform %6 %22 = OpTypeBool %100 = OpConstantTrue %22 %24 = OpTypeFloat 32 %25 = OpTypeStruct %24 %26 = OpTypePointer Uniform %25 %27 = OpVariable %26 Uniform %28 = OpTypePointer Uniform %24 %31 = OpConstant %24 2 %56 = OpConstant %6 1 %58 = OpTypeVector %24 4 %59 = OpTypePointer Output %58 %60 = OpVariable %59 Output %72 = OpUndef %24 %74 = OpUndef %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %10 %10 = OpLabel %73 = OpPhi %6 %74 %5 %77 %34 %71 = OpPhi %24 %72 %5 %76 %34 %70 = OpPhi %6 %9 %5 %57 %34 %20 = OpAccessChain %19 %18 %9 %21 = OpLoad %6 %20 %23 = OpSLessThan %22 %70 %21 OpLoopMerge %12 %34 None OpBranchConditional %23 %11 %12 %11 = OpLabel %29 = OpAccessChain %28 %27 %9 %30 = OpLoad %24 %29 %32 = OpFOrdGreaterThan %22 %30 %31 OpSelectionMerge %90 None OpBranchConditional %32 %33 %46 %33 = OpLabel %40 = OpFAdd %24 %71 %30 %45 = OpISub %6 %73 %21 OpBranch %90 %46 = OpLabel %50 = OpFMul %24 %71 %30 %54 = OpSDiv %6 %73 %21 OpBranch %90 %90 = OpLabel %77 = OpPhi %6 %45 %33 %54 %46 %76 = OpPhi %24 %40 %33 %50 %46 OpBranch %34 %34 = OpLabel %57 = OpIAdd %6 %70 %56 OpBranch %10 %12 = OpLabel %61 = OpAccessChain %28 %27 %9 %62 = OpLoad %24 %61 %66 = OpConvertSToF %24 %21 %68 = OpConvertSToF %24 %73 %69 = OpCompositeConstruct %58 %62 %71 %66 %68 OpStore %60 %69 OpReturn OpFunctionEnd )"; std::string expected = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %9 = OpConstant %6 0 %22 = OpTypeBool %100 = OpConstantTrue %22 %24 = OpTypeFloat 32 %31 = OpConstant %24 2 %56 = OpConstant %6 1 %72 = OpUndef %24 %74 = OpUndef %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %10 %10 = OpLabel OpLoopMerge %12 %34 None OpBranchConditional %100 %11 %12 %11 = OpLabel OpSelectionMerge %90 None OpBranchConditional %100 %33 %46 %33 = OpLabel OpBranch %90 %46 = OpLabel OpBranch %90 %90 = OpLabel OpBranch %34 %34 = OpLabel OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; Reducer reducer(kEnv); PingPongInteresting ping_pong_interesting(10); reducer.SetMessageConsumer(kMessageConsumer); reducer.SetInterestingnessFunction( [&ping_pong_interesting](const std::vector&, uint32_t) -> bool { return ping_pong_interesting.IsInteresting(); }); reducer.AddReductionPass( MakeUnique(false)); reducer.AddReductionPass( MakeUnique()); std::vector binary_in; SpirvTools t(kEnv); ASSERT_TRUE(t.Assemble(original, &binary_in, kReduceAssembleOption)); std::vector binary_out; spvtools::ReducerOptions reducer_options; reducer_options.set_step_limit(500); reducer_options.set_fail_on_validation_error(true); spvtools::ValidatorOptions validator_options; Reducer::ReductionResultStatus status = reducer.Run( std::move(binary_in), &binary_out, reducer_options, validator_options); ASSERT_EQ(status, Reducer::ReductionResultStatus::kComplete); CheckEqual(kEnv, expected, binary_out); } bool InterestingWhileOpcodeExists(const std::vector& binary, spv::Op opcode, uint32_t count, bool dump) { if (dump) { std::stringstream ss; ss << "temp_" << count << ".spv"; DumpShader(binary, ss.str().c_str()); } std::unique_ptr context = BuildModule(kEnv, kMessageConsumer, binary.data(), binary.size()); assert(context); bool interesting = false; for (auto& function : *context->module()) { context->cfg()->ForEachBlockInPostOrder( &*function.begin(), [opcode, &interesting](opt::BasicBlock* block) -> void { for (auto& inst : *block) { if (inst.opcode() == spv::Op(opcode)) { interesting = true; break; } } }); if (interesting) { break; } } return interesting; } bool InterestingWhileIMulReachable(const std::vector& binary, uint32_t count) { return InterestingWhileOpcodeExists(binary, spv::Op::OpIMul, count, false); } bool InterestingWhileSDivReachable(const std::vector& binary, uint32_t count) { return InterestingWhileOpcodeExists(binary, spv::Op::OpSDiv, count, false); } // The shader below was derived from the following GLSL, and optimized. // #version 310 es // precision highp float; // layout(location = 0) out vec4 _GLF_color; // int foo() { // int x = 1; // int y; // x = y / x; // SDiv // return x; // } // void main() { // int c; // while (bool(c)) { // do { // if (bool(c)) { // if (bool(c)) { // ++c; // } else { // _GLF_color.x = float(c*c); // IMul // } // return; // } // } while(bool(foo())); // return; // } // } const std::string kShaderWithLoopsDivAndMul = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %49 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %49 "_GLF_color" OpDecorate %49 Location 0 OpDecorate %52 RelaxedPrecision OpDecorate %77 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %12 = OpConstant %6 1 %27 = OpTypeBool %28 = OpTypeInt 32 0 %29 = OpConstant %28 0 %46 = OpTypeFloat 32 %47 = OpTypeVector %46 4 %48 = OpTypePointer Output %47 %49 = OpVariable %48 Output %54 = OpTypePointer Output %46 %64 = OpConstantFalse %27 %67 = OpConstantTrue %27 %81 = OpUndef %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %61 %61 = OpLabel OpLoopMerge %60 %63 None OpBranch %20 %20 = OpLabel %30 = OpINotEqual %27 %81 %29 OpLoopMerge %22 %23 None OpBranchConditional %30 %21 %22 %21 = OpLabel OpBranch %31 %31 = OpLabel OpLoopMerge %33 %38 None OpBranch %32 %32 = OpLabel OpBranchConditional %30 %37 %38 %37 = OpLabel OpSelectionMerge %42 None OpBranchConditional %30 %41 %45 %41 = OpLabel OpBranch %42 %45 = OpLabel %52 = OpIMul %6 %81 %81 %53 = OpConvertSToF %46 %52 %55 = OpAccessChain %54 %49 %29 OpStore %55 %53 OpBranch %42 %42 = OpLabel OpBranch %33 %38 = OpLabel %77 = OpSDiv %6 %81 %12 %58 = OpINotEqual %27 %77 %29 OpBranchConditional %58 %31 %33 %33 = OpLabel %86 = OpPhi %27 %67 %42 %64 %38 OpSelectionMerge %68 None OpBranchConditional %86 %22 %68 %68 = OpLabel OpBranch %22 %23 = OpLabel OpBranch %20 %22 = OpLabel %90 = OpPhi %27 %64 %20 %86 %33 %67 %68 OpSelectionMerge %70 None OpBranchConditional %90 %60 %70 %70 = OpLabel OpBranch %60 %63 = OpLabel OpBranch %61 %60 = OpLabel OpReturn OpFunctionEnd )"; // The shader below comes from the following GLSL. // #version 320 es // // int baz(int x) { // int y = x + 1; // y = y + 2; // if (y > 0) { // return x; // } // return x + 1; // } // // int bar(int a) { // if (a == 3) { // return baz(2*a); // } // a = a + 1; // for (int i = 0; i < 10; i++) { // a += baz(a); // } // return a; // } // // void main() { // int x; // x = 3; // x += 1; // x += bar(x); // x += baz(x); // } const std::string kShaderWithMultipleFunctions = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %6 %7 %17 = OpConstant %6 1 %20 = OpConstant %6 2 %23 = OpConstant %6 0 %24 = OpTypeBool %35 = OpConstant %6 3 %53 = OpConstant %6 10 %4 = OpFunction %2 None %3 %5 = OpLabel %65 = OpVariable %7 Function %68 = OpVariable %7 Function %73 = OpVariable %7 Function OpStore %65 %35 %66 = OpLoad %6 %65 %67 = OpIAdd %6 %66 %17 OpStore %65 %67 %69 = OpLoad %6 %65 OpStore %68 %69 %70 = OpFunctionCall %6 %13 %68 %71 = OpLoad %6 %65 %72 = OpIAdd %6 %71 %70 OpStore %65 %72 %74 = OpLoad %6 %65 OpStore %73 %74 %75 = OpFunctionCall %6 %10 %73 %76 = OpLoad %6 %65 %77 = OpIAdd %6 %76 %75 OpStore %65 %77 OpReturn OpFunctionEnd %10 = OpFunction %6 None %8 %9 = OpFunctionParameter %7 %11 = OpLabel %15 = OpVariable %7 Function %16 = OpLoad %6 %9 %18 = OpIAdd %6 %16 %17 OpStore %15 %18 %19 = OpLoad %6 %15 %21 = OpIAdd %6 %19 %20 OpStore %15 %21 %22 = OpLoad %6 %15 %25 = OpSGreaterThan %24 %22 %23 OpSelectionMerge %27 None OpBranchConditional %25 %26 %27 %26 = OpLabel %28 = OpLoad %6 %9 OpReturnValue %28 %27 = OpLabel %30 = OpLoad %6 %9 %31 = OpIAdd %6 %30 %17 OpReturnValue %31 OpFunctionEnd %13 = OpFunction %6 None %8 %12 = OpFunctionParameter %7 %14 = OpLabel %41 = OpVariable %7 Function %46 = OpVariable %7 Function %55 = OpVariable %7 Function %34 = OpLoad %6 %12 %36 = OpIEqual %24 %34 %35 OpSelectionMerge %38 None OpBranchConditional %36 %37 %38 %37 = OpLabel %39 = OpLoad %6 %12 %40 = OpIMul %6 %20 %39 OpStore %41 %40 %42 = OpFunctionCall %6 %10 %41 OpReturnValue %42 %38 = OpLabel %44 = OpLoad %6 %12 %45 = OpIAdd %6 %44 %17 OpStore %12 %45 OpStore %46 %23 OpBranch %47 %47 = OpLabel OpLoopMerge %49 %50 None OpBranch %51 %51 = OpLabel %52 = OpLoad %6 %46 %54 = OpSLessThan %24 %52 %53 OpBranchConditional %54 %48 %49 %48 = OpLabel %56 = OpLoad %6 %12 OpStore %55 %56 %57 = OpFunctionCall %6 %10 %55 %58 = OpLoad %6 %12 %59 = OpIAdd %6 %58 %57 OpStore %12 %59 OpBranch %50 %50 = OpLabel %60 = OpLoad %6 %46 %61 = OpIAdd %6 %60 %17 OpStore %46 %61 OpBranch %47 %49 = OpLabel %62 = OpLoad %6 %12 OpReturnValue %62 OpFunctionEnd )"; TEST(ReducerTest, ShaderReduceWhileMulReachable) { Reducer reducer(kEnv); reducer.SetInterestingnessFunction(InterestingWhileIMulReachable); reducer.AddDefaultReductionPasses(); reducer.SetMessageConsumer(kMessageConsumer); std::vector binary_in; SpirvTools t(kEnv); ASSERT_TRUE( t.Assemble(kShaderWithLoopsDivAndMul, &binary_in, kReduceAssembleOption)); std::vector binary_out; spvtools::ReducerOptions reducer_options; reducer_options.set_step_limit(500); reducer_options.set_fail_on_validation_error(true); spvtools::ValidatorOptions validator_options; Reducer::ReductionResultStatus status = reducer.Run( std::move(binary_in), &binary_out, reducer_options, validator_options); ASSERT_EQ(status, Reducer::ReductionResultStatus::kComplete); } TEST(ReducerTest, ShaderReduceWhileDivReachable) { Reducer reducer(kEnv); reducer.SetInterestingnessFunction(InterestingWhileSDivReachable); reducer.AddDefaultReductionPasses(); reducer.SetMessageConsumer(kMessageConsumer); std::vector binary_in; SpirvTools t(kEnv); ASSERT_TRUE( t.Assemble(kShaderWithLoopsDivAndMul, &binary_in, kReduceAssembleOption)); std::vector binary_out; spvtools::ReducerOptions reducer_options; reducer_options.set_step_limit(500); reducer_options.set_fail_on_validation_error(true); spvtools::ValidatorOptions validator_options; Reducer::ReductionResultStatus status = reducer.Run( std::move(binary_in), &binary_out, reducer_options, validator_options); ASSERT_EQ(status, Reducer::ReductionResultStatus::kComplete); } // Computes an instruction count for each function in the module represented by // |binary|. std::unordered_map GetFunctionInstructionCount( const std::vector& binary) { std::unique_ptr context = BuildModule(kEnv, kMessageConsumer, binary.data(), binary.size()); assert(context != nullptr && "Failed to build module."); std::unordered_map result; for (auto& function : *context->module()) { uint32_t& count = result[function.result_id()] = 0; function.ForEachInst([&count](opt::Instruction*) { count++; }); } return result; } TEST(ReducerTest, SingleFunctionReduction) { Reducer reducer(kEnv); PingPongInteresting ping_pong_interesting(4); reducer.SetInterestingnessFunction( [&ping_pong_interesting](const std::vector&, uint32_t) -> bool { return ping_pong_interesting.IsInteresting(); }); reducer.AddDefaultReductionPasses(); reducer.SetMessageConsumer(kMessageConsumer); std::vector binary_in; SpirvTools t(kEnv); ASSERT_TRUE(t.Assemble(kShaderWithMultipleFunctions, &binary_in, kReduceAssembleOption)); auto original_instruction_count = GetFunctionInstructionCount(binary_in); std::vector binary_out; spvtools::ReducerOptions reducer_options; reducer_options.set_step_limit(500); reducer_options.set_fail_on_validation_error(true); // Instruct the reducer to only target function 13. reducer_options.set_target_function(13); spvtools::ValidatorOptions validator_options; Reducer::ReductionResultStatus status = reducer.Run( std::move(binary_in), &binary_out, reducer_options, validator_options); ASSERT_EQ(status, Reducer::ReductionResultStatus::kComplete); auto final_instruction_count = GetFunctionInstructionCount(binary_out); // Nothing should have been removed from these functions. ASSERT_EQ(original_instruction_count.at(4), final_instruction_count.at(4)); ASSERT_EQ(original_instruction_count.at(10), final_instruction_count.at(10)); // Function 13 should have been reduced to these five instructions: // OpFunction // OpFunctionParameter // OpLabel // OpReturnValue // OpFunctionEnd ASSERT_EQ(5, final_instruction_count.at(13)); } } // namespace } // namespace reduce } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/reduce/remove_block_test.cpp000066400000000000000000000263071475742701700252010ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/remove_block_reduction_opportunity_finder.h" #include "source/opt/build_module.h" #include "source/reduce/reduction_opportunity.h" #include "test/reduce/reduce_test_util.h" namespace spvtools { namespace reduce { namespace { TEST(RemoveBlockReductionPassTest, BasicCheck) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "x" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %10 = OpConstant %6 2 %11 = OpConstant %6 3 %12 = OpConstant %6 4 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpBranch %14 %13 = OpLabel ; unreachable OpStore %8 %9 OpBranch %14 %14 = OpLabel OpStore %8 %10 OpBranch %16 %15 = OpLabel ; unreachable OpStore %8 %11 OpBranch %16 %16 = OpLabel OpStore %8 %12 OpBranch %17 %17 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kReduceAssembleOption); const auto ops = RemoveBlockReductionOpportunityFinder().GetAvailableOpportunities( context.get(), 0); ASSERT_EQ(2, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); std::string after_op_0 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "x" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %10 = OpConstant %6 2 %11 = OpConstant %6 3 %12 = OpConstant %6 4 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpBranch %14 %14 = OpLabel OpStore %8 %10 OpBranch %16 %15 = OpLabel OpStore %8 %11 OpBranch %16 %16 = OpLabel OpStore %8 %12 OpBranch %17 %17 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, after_op_0, context.get()); ASSERT_TRUE(ops[1]->PreconditionHolds()); ops[1]->TryToApply(); std::string after_op_1 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %8 "x" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 1 %10 = OpConstant %6 2 %11 = OpConstant %6 3 %12 = OpConstant %6 4 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpBranch %14 %14 = OpLabel OpStore %8 %10 OpBranch %16 %16 = OpLabel OpStore %8 %12 OpBranch %17 %17 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, after_op_1, context.get()); } TEST(RemoveBlockReductionPassTest, UnreachableContinueAndMerge) { // Loop with unreachable merge and continue target. There should be no // opportunities. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %13 %13 = OpLabel OpLoopMerge %16 %15 None OpBranch %14 %14 = OpLabel OpReturn %15 = OpLabel OpBranch %13 %16 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kReduceAssembleOption); const auto ops = RemoveBlockReductionOpportunityFinder().GetAvailableOpportunities( context.get(), 0); ASSERT_EQ(0, ops.size()); } TEST(RemoveBlockReductionPassTest, OneBlock) { // Function with just one block. There should be no opportunities. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kReduceAssembleOption); const auto ops = RemoveBlockReductionOpportunityFinder().GetAvailableOpportunities( context.get(), 0); ASSERT_EQ(0, ops.size()); } TEST(RemoveBlockReductionPassTest, UnreachableBlocksWithOutsideIdUses) { // A function with two unreachable blocks A -> B. A defines ID %9 and B uses // %9. There are no references to A, but removing A would be invalid because // of B's use of %9, so there should be no opportunities. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeInt 32 1 %5 = OpTypeFunction %3 %6 = OpConstant %4 1 %2 = OpFunction %3 None %5 %7 = OpLabel OpReturn %8 = OpLabel ; A %9 = OpUndef %4 OpBranch %10 %10 = OpLabel ; B %11 = OpIAdd %4 %6 %9 ; uses %9 from A, so A cannot be removed OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kReduceAssembleOption); const auto ops = RemoveBlockReductionOpportunityFinder().GetAvailableOpportunities( context.get(), 0); ASSERT_EQ(0, ops.size()); } TEST(RemoveBlockReductionPassTest, UnreachableBlocksWithInsideIdUses) { // Similar to the above test. // A function with two unreachable blocks A -> B. Both blocks create and use // IDs, but the uses are contained within each block, so A should be removed. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeInt 32 1 %5 = OpTypeFunction %3 %6 = OpConstant %4 1 %2 = OpFunction %3 None %5 %7 = OpLabel OpReturn %8 = OpLabel ; A %9 = OpUndef %4 ; define %9 %10 = OpIAdd %4 %6 %9 ; use %9 OpBranch %11 %11 = OpLabel ; B %12 = OpUndef %4 ; define %12 %13 = OpIAdd %4 %6 %12 ; use %12 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kReduceAssembleOption); auto ops = RemoveBlockReductionOpportunityFinder().GetAvailableOpportunities( context.get(), 0); ASSERT_EQ(1, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); // Same as above, but block A is removed. std::string after_op_0 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeInt 32 1 %5 = OpTypeFunction %3 %6 = OpConstant %4 1 %2 = OpFunction %3 None %5 %7 = OpLabel OpReturn %11 = OpLabel %12 = OpUndef %4 %13 = OpIAdd %4 %6 %12 OpReturn OpFunctionEnd )"; CheckEqual(env, after_op_0, context.get()); // Find opportunities again. There are no reference to B. B should now be // removed. ops = RemoveBlockReductionOpportunityFinder().GetAvailableOpportunities( context.get(), 0); ASSERT_EQ(1, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); // Same as above, but block B is removed. std::string after_op_0_again = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeInt 32 1 %5 = OpTypeFunction %3 %6 = OpConstant %4 1 %2 = OpFunction %3 None %5 %7 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, after_op_0_again, context.get()); } } // namespace } // namespace reduce } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/reduce/remove_function_test.cpp000066400000000000000000000215261475742701700257320ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/remove_function_reduction_opportunity_finder.h" #include "source/opt/build_module.h" #include "source/reduce/reduction_opportunity.h" #include "test/reduce/reduce_test_util.h" namespace spvtools { namespace reduce { namespace { // Helper to count the number of functions in the module. // Remove if there turns out to be a more direct way to do this. uint32_t count_functions(opt::IRContext* context) { uint32_t result = 0; for (auto& function : *context->module()) { (void)(function); ++result; } return result; } TEST(RemoveFunctionTest, BasicCheck) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %10 = OpFunctionCall %2 %6 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kReduceAssembleOption); ASSERT_EQ(3, count_functions(context.get())); auto ops = RemoveFunctionReductionOpportunityFinder().GetAvailableOpportunities( context.get(), 0); ASSERT_EQ(1, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); ASSERT_EQ(2, count_functions(context.get())); std::string after_first = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, after_first, context.get()); ops = RemoveFunctionReductionOpportunityFinder().GetAvailableOpportunities( context.get(), 0); ASSERT_EQ(1, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); ASSERT_EQ(1, count_functions(context.get())); std::string after_second = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, after_second, context.get()); } TEST(RemoveFunctionTest, NothingToRemove) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel %11 = OpFunctionCall %2 %8 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel %10 = OpFunctionCall %2 %6 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kReduceAssembleOption); auto ops = RemoveFunctionReductionOpportunityFinder().GetAvailableOpportunities( context.get(), 0); ASSERT_EQ(0, ops.size()); } TEST(RemoveFunctionTest, TwoRemovableFunctions) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kReduceAssembleOption); ASSERT_EQ(3, count_functions(context.get())); auto ops = RemoveFunctionReductionOpportunityFinder().GetAvailableOpportunities( context.get(), 0); ASSERT_EQ(2, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); ASSERT_EQ(2, count_functions(context.get())); ASSERT_TRUE(ops[1]->PreconditionHolds()); ops[1]->TryToApply(); ASSERT_EQ(1, count_functions(context.get())); std::string after = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, after, context.get()); } TEST(RemoveFunctionTest, NoRemovalsDueToOpName) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %6 "foo(" OpName %8 "bar(" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel OpReturn OpFunctionEnd %8 = OpFunction %2 None %3 %9 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kReduceAssembleOption); auto ops = RemoveFunctionReductionOpportunityFinder().GetAvailableOpportunities( context.get(), 0); ASSERT_EQ(0, ops.size()); } TEST(RemoveFunctionTest, NoRemovalDueToLinkageDecoration) { // The non-entry point function is not removable because it is referenced by a // linkage decoration. Thus no function can be removed. std::string shader = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpName %1 "main" OpDecorate %2 LinkageAttributes "ExportedFunc" Export %4 = OpTypeVoid %5 = OpTypeFunction %4 %1 = OpFunction %4 None %5 %6 = OpLabel OpReturn OpFunctionEnd %2 = OpFunction %4 None %5 %7 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kReduceAssembleOption); auto ops = RemoveFunctionReductionOpportunityFinder().GetAvailableOpportunities( context.get(), 0); ASSERT_EQ(0, ops.size()); } } // namespace } // namespace reduce } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/reduce/remove_selection_test.cpp000066400000000000000000000372241475742701700260740ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/remove_selection_reduction_opportunity_finder.h" #include "source/opt/build_module.h" #include "source/reduce/reduction_opportunity.h" #include "test/reduce/reduce_test_util.h" namespace spvtools { namespace reduce { namespace { TEST(RemoveSelectionTest, OpportunityBecauseSameTargetBlock) { // A test with the following structure. The OpSelectionMerge instruction // should be removed. // // header // || // block // | // merge std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %2 = OpFunction %3 None %4 %9 = OpLabel OpSelectionMerge %10 None OpBranchConditional %8 %11 %11 %11 = OpLabel OpBranch %10 %10 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto context = BuildModule(env, nullptr, shader, kReduceAssembleOption); auto ops = RemoveSelectionReductionOpportunityFinder().GetAvailableOpportunities( context.get(), 0); ASSERT_EQ(1, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); CheckValid(env, context.get()); std::string after = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %2 = OpFunction %3 None %4 %9 = OpLabel OpBranchConditional %8 %11 %11 %11 = OpLabel OpBranch %10 %10 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, after, context.get()); ops = RemoveSelectionReductionOpportunityFinder().GetAvailableOpportunities( context.get(), 0); ASSERT_EQ(0, ops.size()); } TEST(RemoveSelectionTest, OpportunityBecauseSameTargetBlockMerge) { // A test with the following structure. The OpSelectionMerge instruction // should be removed. // // header // || // merge std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %2 = OpFunction %3 None %4 %9 = OpLabel OpSelectionMerge %10 None OpBranchConditional %8 %10 %10 %10 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto context = BuildModule(env, nullptr, shader, kReduceAssembleOption); auto ops = RemoveSelectionReductionOpportunityFinder().GetAvailableOpportunities( context.get(), 0); ASSERT_EQ(1, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); CheckValid(env, context.get()); std::string after = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %2 = OpFunction %3 None %4 %9 = OpLabel OpBranchConditional %8 %10 %10 %10 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, after, context.get()); ops = RemoveSelectionReductionOpportunityFinder().GetAvailableOpportunities( context.get(), 0); ASSERT_EQ(0, ops.size()); } TEST(RemoveSelectionTest, NoOpportunityBecauseDifferentTargetBlocksOneMerge) { // A test with the following structure. The OpSelectionMerge instruction // should NOT be removed. // // header // | | // | block // | | // merge std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %2 = OpFunction %3 None %4 %9 = OpLabel OpSelectionMerge %10 None OpBranchConditional %8 %10 %11 %11 = OpLabel OpBranch %10 %10 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto context = BuildModule(env, nullptr, shader, kReduceAssembleOption); auto ops = RemoveSelectionReductionOpportunityFinder().GetAvailableOpportunities( context.get(), 0); ASSERT_EQ(0, ops.size()); } TEST(RemoveSelectionTest, NoOpportunityBecauseDifferentTargetBlocks) { // A test with the following structure. The OpSelectionMerge instruction // should NOT be removed. // // header // | | // b b // | | // merge std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %2 = OpFunction %3 None %4 %9 = OpLabel OpSelectionMerge %10 None OpBranchConditional %8 %11 %12 %11 = OpLabel OpBranch %10 %12 = OpLabel OpBranch %10 %10 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto context = BuildModule(env, nullptr, shader, kReduceAssembleOption); auto ops = RemoveSelectionReductionOpportunityFinder().GetAvailableOpportunities( context.get(), 0); ASSERT_EQ(0, ops.size()); } TEST(RemoveSelectionTest, NoOpportunityBecauseMergeUsed) { // A test with the following structure. The OpSelectionMerge instruction // should NOT be removed. // // header // || // block // | | // | block // | | // merge std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %2 = OpFunction %3 None %4 %9 = OpLabel OpSelectionMerge %10 None OpBranchConditional %8 %11 %12 %11 = OpLabel OpBranchConditional %8 %10 %12 %12 = OpLabel OpBranch %10 %10 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto context = BuildModule(env, nullptr, shader, kReduceAssembleOption); auto ops = RemoveSelectionReductionOpportunityFinder().GetAvailableOpportunities( context.get(), 0); ASSERT_EQ(0, ops.size()); } TEST(RemoveSelectionTest, OpportunityBecauseLoopMergeUsed) { // A test with the following structure. The OpSelectionMerge instruction // should be removed. // // loop header // | // | // s.header // || // block // | | // | | // | | ^ (to loop header) // s.merge | | // | / loop continue target (unreachable) // loop merge // // // which becomes: // // loop header // | // | // block // || // block // | | // | | // | | ^ (to loop header) // block | | // | / loop continue target (unreachable) // loop merge std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %2 = OpFunction %3 None %4 %9 = OpLabel OpBranch %10 %10 = OpLabel OpLoopMerge %11 %12 None OpBranch %13 %13 = OpLabel OpSelectionMerge %14 None OpBranchConditional %8 %15 %15 %15 = OpLabel OpBranchConditional %8 %14 %11 %14 = OpLabel OpBranch %11 %12 = OpLabel OpBranch %10 %11 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto context = BuildModule(env, nullptr, shader, kReduceAssembleOption); CheckValid(env, context.get()); auto ops = RemoveSelectionReductionOpportunityFinder().GetAvailableOpportunities( context.get(), 0); ASSERT_EQ(1, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); CheckValid(env, context.get()); std::string after = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %2 = OpFunction %3 None %4 %9 = OpLabel OpBranch %10 %10 = OpLabel OpLoopMerge %11 %12 None OpBranch %13 %13 = OpLabel OpBranchConditional %8 %15 %15 %15 = OpLabel OpBranchConditional %8 %14 %11 %14 = OpLabel OpBranch %11 %12 = OpLabel OpBranch %10 %11 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, after, context.get()); ops = RemoveSelectionReductionOpportunityFinder().GetAvailableOpportunities( context.get(), 0); ASSERT_EQ(0, ops.size()); } TEST(RemoveSelectionTest, OpportunityBecauseLoopContinueUsed) { // A test with the following structure. The OpSelectionMerge instruction // should be removed. // // loop header // | // | // s.header // || // block // | | // | | // | | ^ (to loop header) // s.merge | | // | loop continue target // loop merge // // // which becomes: // // loop header // | // | // block // || // block // | | // | | // | | ^ (to loop header) // block | | // | loop continue target // loop merge std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %2 = OpFunction %3 None %4 %9 = OpLabel OpBranch %10 %10 = OpLabel OpLoopMerge %11 %12 None OpBranch %13 %13 = OpLabel OpSelectionMerge %14 None OpBranchConditional %8 %15 %15 %15 = OpLabel OpBranchConditional %8 %14 %12 %14 = OpLabel OpBranch %11 %12 = OpLabel OpBranch %10 %11 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto context = BuildModule(env, nullptr, shader, kReduceAssembleOption); CheckValid(env, context.get()); auto ops = RemoveSelectionReductionOpportunityFinder().GetAvailableOpportunities( context.get(), 0); ASSERT_EQ(1, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); CheckValid(env, context.get()); std::string after = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %2 = OpFunction %3 None %4 %9 = OpLabel OpBranch %10 %10 = OpLabel OpLoopMerge %11 %12 None OpBranch %13 %13 = OpLabel OpBranchConditional %8 %15 %15 %15 = OpLabel OpBranchConditional %8 %14 %12 %14 = OpLabel OpBranch %11 %12 = OpLabel OpBranch %10 %11 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, after, context.get()); ops = RemoveSelectionReductionOpportunityFinder().GetAvailableOpportunities( context.get(), 0); ASSERT_EQ(0, ops.size()); } } // namespace } // namespace reduce } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/reduce/remove_unused_instruction_test.cpp000066400000000000000000000425071475742701700300530ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/remove_unused_instruction_reduction_opportunity_finder.h" #include "source/opt/build_module.h" #include "source/reduce/reduction_opportunity.h" #include "source/util/make_unique.h" #include "test/reduce/reduce_test_util.h" namespace spvtools { namespace reduce { namespace { const spv_target_env kEnv = SPV_ENV_UNIVERSAL_1_3; TEST(RemoveUnusedInstructionReductionPassTest, RemoveStores) { // A module with some unused instructions, including some unused OpStore // instructions. RemoveUnusedInstructionReductionOpportunityFinder finder(true); const std::string original = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 ; 0 OpName %4 "main" ; 1 OpName %8 "a" ; 2 OpName %10 "b" ; 3 OpName %12 "c" ; 4 OpName %14 "d" ; 5 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 10 %11 = OpConstant %6 20 %13 = OpConstant %6 30 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function %12 = OpVariable %7 Function %14 = OpVariable %7 Function OpStore %8 %9 ; 6 OpStore %10 %11 ; 7 OpStore %12 %13 ; 8 %15 = OpLoad %6 %8 OpStore %14 %15 ; 9 OpReturn OpFunctionEnd )"; const MessageConsumer consumer = nullptr; const auto context = BuildModule(kEnv, consumer, original, kReduceAssembleOption); CheckValid(kEnv, context.get()); auto ops = finder.GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(10, ops.size()); for (auto& op : ops) { ASSERT_TRUE(op->PreconditionHolds()); op->TryToApply(); CheckValid(kEnv, context.get()); } const std::string step_2 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 10 ; 0 %11 = OpConstant %6 20 ; 1 %13 = OpConstant %6 30 ; 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %10 = OpVariable %7 Function ; 3 %12 = OpVariable %7 Function ; 4 %14 = OpVariable %7 Function ; 5 %15 = OpLoad %6 %8 ; 6 OpReturn OpFunctionEnd )"; CheckEqual(kEnv, step_2, context.get()); ops = finder.GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(7, ops.size()); for (auto& op : ops) { ASSERT_TRUE(op->PreconditionHolds()); op->TryToApply(); CheckValid(kEnv, context.get()); } const std::string step_3 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function ; 0 OpReturn OpFunctionEnd )"; CheckEqual(kEnv, step_3, context.get()); ops = finder.GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(1, ops.size()); for (auto& op : ops) { ASSERT_TRUE(op->PreconditionHolds()); op->TryToApply(); CheckValid(kEnv, context.get()); } const std::string step_4 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 ; 0 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(kEnv, step_4, context.get()); ops = finder.GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(1, ops.size()); for (auto& op : ops) { ASSERT_TRUE(op->PreconditionHolds()); op->TryToApply(); CheckValid(kEnv, context.get()); } const std::string step_5 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 ; 0 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(kEnv, step_5, context.get()); ops = finder.GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(1, ops.size()); for (auto& op : ops) { ASSERT_TRUE(op->PreconditionHolds()); op->TryToApply(); CheckValid(kEnv, context.get()); } const std::string step_6 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(kEnv, step_6, context.get()); ops = finder.GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(0, ops.size()); } TEST(RemoveUnusedInstructionReductionPassTest, Referenced) { // A module with some unused global variables, constants, and types. Some will // not be removed initially because of the OpDecorate instructions. RemoveUnusedInstructionReductionOpportunityFinder finder(true); const std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 ; 1 OpName %4 "main" ; 2 OpName %12 "a" ; 3 OpDecorate %12 RelaxedPrecision ; 4 OpDecorate %13 RelaxedPrecision ; 5 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantTrue %6 ; 6 %10 = OpTypeInt 32 1 %11 = OpTypePointer Private %10 %12 = OpVariable %11 Private %13 = OpConstant %10 1 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; auto context = BuildModule(kEnv, nullptr, shader, kReduceAssembleOption); CheckValid(kEnv, context.get()); auto ops = finder.GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(6, ops.size()); for (auto& op : ops) { ASSERT_TRUE(op->PreconditionHolds()); op->TryToApply(); CheckValid(kEnv, context.get()); } std::string after = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool ; 1 %10 = OpTypeInt 32 1 %11 = OpTypePointer Private %10 %12 = OpVariable %11 Private ; 2 %13 = OpConstant %10 1 ; 3 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(kEnv, after, context.get()); ops = finder.GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(3, ops.size()); for (auto& op : ops) { ASSERT_TRUE(op->PreconditionHolds()); op->TryToApply(); CheckValid(kEnv, context.get()); } std::string after_2 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeInt 32 1 %11 = OpTypePointer Private %10 ; 1 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(kEnv, after_2, context.get()); ops = finder.GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(1, ops.size()); for (auto& op : ops) { ASSERT_TRUE(op->PreconditionHolds()); op->TryToApply(); CheckValid(kEnv, context.get()); } std::string after_3 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeInt 32 1 ; 1 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(kEnv, after_3, context.get()); ops = finder.GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(1, ops.size()); for (auto& op : ops) { ASSERT_TRUE(op->PreconditionHolds()); op->TryToApply(); CheckValid(kEnv, context.get()); } std::string after_4 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(kEnv, after_4, context.get()); ops = finder.GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(0, ops.size()); } TEST(RemoveUnusedResourceVariableTest, RemoveUnusedResourceVariables) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpMemberDecorate %9 0 Offset 0 OpDecorate %9 Block OpDecorate %11 DescriptorSet 0 OpDecorate %11 Binding 1 OpMemberDecorate %16 0 Offset 0 OpMemberDecorate %16 1 Offset 4 OpDecorate %16 Block OpDecorate %18 DescriptorSet 0 OpDecorate %18 Binding 0 OpMemberDecorate %19 0 Offset 0 OpDecorate %19 BufferBlock OpDecorate %21 DescriptorSet 1 OpDecorate %21 Binding 0 OpMemberDecorate %22 0 Offset 0 OpDecorate %22 Block OpDecorate %29 DescriptorSet 1 OpDecorate %29 Binding 1 OpDecorate %32 DescriptorSet 1 OpDecorate %32 Binding 2 OpDecorate %32 NonReadable %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %9 = OpTypeStruct %6 %10 = OpTypePointer Uniform %9 %11 = OpVariable %10 Uniform %13 = OpTypePointer Uniform %6 %16 = OpTypeStruct %6 %6 %17 = OpTypePointer Uniform %16 %18 = OpVariable %17 Uniform %19 = OpTypeStruct %6 %20 = OpTypePointer Uniform %19 %21 = OpVariable %20 Uniform %22 = OpTypeStruct %6 %23 = OpTypePointer PushConstant %22 %24 = OpVariable %23 PushConstant %25 = OpTypeFloat 32 %26 = OpTypeImage %25 2D 0 0 0 1 Unknown %27 = OpTypeSampledImage %26 %28 = OpTypePointer UniformConstant %27 %29 = OpVariable %28 UniformConstant %30 = OpTypeImage %25 2D 0 0 0 2 Unknown %31 = OpTypePointer UniformConstant %30 %32 = OpVariable %31 UniformConstant %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kReduceAssembleOption); auto ops = RemoveUnusedInstructionReductionOpportunityFinder(true) .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(7, ops.size()); for (auto& op : ops) { ASSERT_TRUE(op->PreconditionHolds()); op->TryToApply(); } std::string expected_1 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpMemberDecorate %9 0 Offset 0 OpDecorate %9 Block OpMemberDecorate %16 0 Offset 0 OpMemberDecorate %16 1 Offset 4 OpDecorate %16 Block OpMemberDecorate %19 0 Offset 0 OpDecorate %19 BufferBlock OpMemberDecorate %22 0 Offset 0 OpDecorate %22 Block %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %9 = OpTypeStruct %6 %10 = OpTypePointer Uniform %9 %16 = OpTypeStruct %6 %6 %17 = OpTypePointer Uniform %16 %19 = OpTypeStruct %6 %20 = OpTypePointer Uniform %19 %22 = OpTypeStruct %6 %23 = OpTypePointer PushConstant %22 %25 = OpTypeFloat 32 %26 = OpTypeImage %25 2D 0 0 0 1 Unknown %27 = OpTypeSampledImage %26 %28 = OpTypePointer UniformConstant %27 %30 = OpTypeImage %25 2D 0 0 0 2 Unknown %31 = OpTypePointer UniformConstant %30 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, expected_1, context.get()); ops = RemoveUnusedInstructionReductionOpportunityFinder(true) .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(6, ops.size()); for (auto& op : ops) { ASSERT_TRUE(op->PreconditionHolds()); op->TryToApply(); } std::string expected_2 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpMemberDecorate %9 0 Offset 0 OpDecorate %9 Block OpMemberDecorate %16 0 Offset 0 OpMemberDecorate %16 1 Offset 4 OpDecorate %16 Block OpMemberDecorate %19 0 Offset 0 OpDecorate %19 BufferBlock OpMemberDecorate %22 0 Offset 0 OpDecorate %22 Block %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %9 = OpTypeStruct %6 %16 = OpTypeStruct %6 %6 %19 = OpTypeStruct %6 %22 = OpTypeStruct %6 %25 = OpTypeFloat 32 %26 = OpTypeImage %25 2D 0 0 0 1 Unknown %27 = OpTypeSampledImage %26 %30 = OpTypeImage %25 2D 0 0 0 2 Unknown %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, expected_2, context.get()); ops = RemoveUnusedInstructionReductionOpportunityFinder(true) .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(6, ops.size()); for (auto& op : ops) { ASSERT_TRUE(op->PreconditionHolds()); op->TryToApply(); } std::string expected_3 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %25 = OpTypeFloat 32 %26 = OpTypeImage %25 2D 0 0 0 1 Unknown %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, expected_3, context.get()); } } // namespace } // namespace reduce } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/reduce/remove_unused_struct_member_test.cpp000066400000000000000000000176001475742701700303410ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/remove_unused_struct_member_reduction_opportunity_finder.h" #include "source/opt/build_module.h" #include "source/reduce/reduction_opportunity.h" #include "test/reduce/reduce_test_util.h" namespace spvtools { namespace reduce { namespace { TEST(RemoveUnusedStructMemberTest, RemoveOneMember) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeStruct %6 %6 %8 = OpTypePointer Function %7 %50 = OpConstant %6 0 %10 = OpConstant %6 1 %11 = OpConstant %6 2 %12 = OpConstantComposite %7 %10 %11 %13 = OpConstant %6 4 %14 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %5 = OpLabel %9 = OpVariable %8 Function OpStore %9 %12 %15 = OpAccessChain %14 %9 %10 %22 = OpInBoundsAccessChain %14 %9 %10 %20 = OpLoad %7 %9 %21 = OpCompositeExtract %6 %20 1 %23 = OpCompositeInsert %7 %10 %20 1 OpStore %15 %13 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kReduceAssembleOption); auto ops = RemoveUnusedStructMemberReductionOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(1, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); CheckValid(env, context.get()); std::string expected = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeStruct %6 %8 = OpTypePointer Function %7 %50 = OpConstant %6 0 %10 = OpConstant %6 1 %11 = OpConstant %6 2 %12 = OpConstantComposite %7 %11 %13 = OpConstant %6 4 %14 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %5 = OpLabel %9 = OpVariable %8 Function OpStore %9 %12 %15 = OpAccessChain %14 %9 %50 %22 = OpInBoundsAccessChain %14 %9 %50 %20 = OpLoad %7 %9 %21 = OpCompositeExtract %6 %20 0 %23 = OpCompositeInsert %7 %10 %20 0 OpStore %15 %13 OpReturn OpFunctionEnd )"; CheckEqual(env, expected, context.get()); } TEST(RemoveUnusedStructMemberTest, RemoveUniformBufferMember) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpMemberDecorate %10 0 Offset 0 OpMemberDecorate %10 1 Offset 4 OpDecorate %10 Block OpDecorate %12 DescriptorSet 0 OpDecorate %12 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %9 = OpTypeInt 32 1 %10 = OpTypeStruct %9 %6 %11 = OpTypePointer Uniform %10 %12 = OpVariable %11 Uniform %13 = OpConstant %9 1 %20 = OpConstant %9 0 %14 = OpTypePointer Uniform %6 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %15 = OpAccessChain %14 %12 %13 %16 = OpLoad %6 %15 OpStore %8 %16 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kReduceAssembleOption); auto ops = RemoveUnusedStructMemberReductionOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(1, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); CheckValid(env, context.get()); std::string expected = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpMemberDecorate %10 0 Offset 4 OpDecorate %10 Block OpDecorate %12 DescriptorSet 0 OpDecorate %12 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %9 = OpTypeInt 32 1 %10 = OpTypeStruct %6 %11 = OpTypePointer Uniform %10 %12 = OpVariable %11 Uniform %13 = OpConstant %9 1 %20 = OpConstant %9 0 %14 = OpTypePointer Uniform %6 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %15 = OpAccessChain %14 %12 %20 %16 = OpLoad %6 %15 OpStore %8 %16 OpReturn OpFunctionEnd )"; CheckEqual(env, expected, context.get()); } TEST(RemoveUnusedStructMemberTest, DoNotRemoveNamedMemberRemoveOneMember) { // This illustrates that naming a member is enough to prevent its removal. // Removal of names is done by a different pass. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpMemberName %7 0 "someName" OpMemberName %7 1 "someOtherName" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeStruct %6 %6 %8 = OpTypePointer Function %7 %50 = OpConstant %6 0 %10 = OpConstant %6 1 %11 = OpConstant %6 2 %12 = OpConstantComposite %7 %10 %11 %13 = OpConstant %6 4 %14 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %5 = OpLabel %9 = OpVariable %8 Function OpStore %9 %12 %15 = OpAccessChain %14 %9 %10 %22 = OpInBoundsAccessChain %14 %9 %10 %20 = OpLoad %7 %9 %21 = OpCompositeExtract %6 %20 1 %23 = OpCompositeInsert %7 %10 %20 1 OpStore %15 %13 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kReduceAssembleOption); auto ops = RemoveUnusedStructMemberReductionOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(0, ops.size()); } } // namespace } // namespace reduce } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/reduce/simple_conditional_branch_to_branch_test.cpp000066400000000000000000000344251475742701700317420ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/simple_conditional_branch_to_branch_opportunity_finder.h" #include "source/opt/build_module.h" #include "source/reduce/reduction_opportunity.h" #include "source/reduce/reduction_pass.h" #include "test/reduce/reduce_test_util.h" namespace spvtools { namespace reduce { namespace { const spv_target_env kEnv = SPV_ENV_UNIVERSAL_1_3; TEST(SimpleConditionalBranchToBranchTest, Diamond) { // A test with the following structure. // // selection header // OpBranchConditional // || // b b // | | // selection merge // // The conditional branch cannot be simplified because selection headers // cannot end with OpBranch. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %2 = OpFunction %3 None %4 %9 = OpLabel OpBranch %10 %10 = OpLabel OpSelectionMerge %11 None OpBranchConditional %8 %12 %12 %12 = OpLabel OpBranch %11 %13 = OpLabel OpBranch %11 %11 = OpLabel OpReturn OpFunctionEnd )"; auto context = BuildModule(kEnv, nullptr, shader, kReduceAssembleOption); CheckValid(kEnv, context.get()); auto ops = SimpleConditionalBranchToBranchOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(0, ops.size()); } TEST(SimpleConditionalBranchToBranchTest, DiamondNoSelection) { // A test with the following structure. // // OpBranchConditional // || // b b // | / // b // // The conditional branch can be simplified. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %2 = OpFunction %3 None %4 %9 = OpLabel OpBranch %10 %10 = OpLabel OpBranchConditional %8 %12 %12 %12 = OpLabel OpBranch %11 %13 = OpLabel OpBranch %11 %11 = OpLabel OpReturn OpFunctionEnd )"; auto context = BuildModule(kEnv, nullptr, shader, kReduceAssembleOption); CheckValid(kEnv, context.get()); auto ops = SimpleConditionalBranchToBranchOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(1, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); CheckValid(kEnv, context.get()); std::string after = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %2 = OpFunction %3 None %4 %9 = OpLabel OpBranch %10 %10 = OpLabel OpBranch %12 %12 = OpLabel OpBranch %11 %13 = OpLabel OpBranch %11 %11 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(kEnv, after, context.get()); ops = SimpleConditionalBranchToBranchOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(0, ops.size()); } TEST(SimpleConditionalBranchToBranchTest, ConditionalBranchesButNotSimple) { // A test with the following structure. // // selection header // OpBranchConditional // | | // b OpBranchConditional // | | | // | b | // | | | // selection merge // // None of the conditional branches can be simplified; the first is not simple // AND part of a selection header; the second is just not simple (where // "simple" means it only has one target). std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %2 = OpFunction %3 None %4 %9 = OpLabel OpBranch %10 %10 = OpLabel OpSelectionMerge %11 None OpBranchConditional %8 %12 %13 %12 = OpLabel OpBranch %11 %13 = OpLabel OpBranchConditional %8 %14 %11 %14 = OpLabel OpBranch %11 %11 = OpLabel OpReturn OpFunctionEnd )"; auto context = BuildModule(kEnv, nullptr, shader, kReduceAssembleOption); CheckValid(kEnv, context.get()); auto ops = SimpleConditionalBranchToBranchOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(0, ops.size()); } TEST(SimpleConditionalBranchToBranchTest, SimplifyBackEdge) { // A test with the following structure. The loop has a continue construct that // ends with OpBranchConditional. The OpBranchConditional can be simplified. // // loop header // | // loop continue target and back-edge block // OpBranchConditional // || // loop merge (to loop header^) std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %2 = OpFunction %3 None %4 %9 = OpLabel OpBranch %10 %10 = OpLabel OpLoopMerge %11 %12 None OpBranch %12 %12 = OpLabel OpBranchConditional %8 %10 %10 %11 = OpLabel OpReturn OpFunctionEnd )"; const auto context = BuildModule(kEnv, nullptr, shader, kReduceAssembleOption); CheckValid(kEnv, context.get()); auto ops = SimpleConditionalBranchToBranchOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(1, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); CheckValid(kEnv, context.get()); std::string after = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %2 = OpFunction %3 None %4 %9 = OpLabel OpBranch %10 %10 = OpLabel OpLoopMerge %11 %12 None OpBranch %12 %12 = OpLabel OpBranch %10 %11 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(kEnv, after, context.get()); ops = SimpleConditionalBranchToBranchOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(0, ops.size()); } TEST(SimpleConditionalBranchToBranchTest, DontRemoveBackEdgeCombinedHeaderContinue) { // A test with the following structure. // // loop header and continue target and back-edge block // OpBranchConditional // || // loop merge (to loop header^) // // The conditional branch can be simplified. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %2 = OpFunction %3 None %4 %9 = OpLabel OpBranch %10 %10 = OpLabel OpLoopMerge %11 %10 None OpBranchConditional %8 %10 %10 %11 = OpLabel OpReturn OpFunctionEnd )"; const auto context = BuildModule(kEnv, nullptr, shader, kReduceAssembleOption); CheckValid(kEnv, context.get()); auto ops = SimpleConditionalBranchToBranchOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(1, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); CheckValid(kEnv, context.get()); std::string after = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %2 = OpFunction %3 None %4 %9 = OpLabel OpBranch %10 %10 = OpLabel OpLoopMerge %11 %10 None OpBranch %10 %11 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(kEnv, after, context.get()); ops = SimpleConditionalBranchToBranchOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(0, ops.size()); } TEST(SimpleConditionalBranchToBranchTest, BackEdgeUnreachable) { // A test with the following structure. I.e. a loop with an unreachable // continue construct that ends with OpBranchConditional. // // loop header // | // | loop continue target (unreachable) // | | // | back-edge block (unreachable) // | OpBranchConditional // | || // loop merge (to loop header^) // // The conditional branch can be simplified. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %2 = OpFunction %3 None %4 %9 = OpLabel OpBranch %10 %10 = OpLabel OpLoopMerge %11 %12 None OpBranch %11 %12 = OpLabel OpBranch %13 %13 = OpLabel OpBranchConditional %8 %10 %10 %11 = OpLabel OpReturn OpFunctionEnd )"; const auto context = BuildModule(kEnv, nullptr, shader, kReduceAssembleOption); CheckValid(kEnv, context.get()); auto ops = SimpleConditionalBranchToBranchOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(1, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); CheckValid(kEnv, context.get()); std::string after = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpName %2 "main" %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypePointer Function %5 %7 = OpTypeBool %8 = OpConstantTrue %7 %2 = OpFunction %3 None %4 %9 = OpLabel OpBranch %10 %10 = OpLabel OpLoopMerge %11 %12 None OpBranch %11 %12 = OpLabel OpBranch %13 %13 = OpLabel OpBranch %10 %11 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(kEnv, after, context.get()); ops = SimpleConditionalBranchToBranchOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(0, ops.size()); } } // namespace } // namespace reduce } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/reduce/structured_construct_to_block_test.cpp000066400000000000000000000174141475742701700307150ustar00rootroot00000000000000// Copyright (c) 2021 Alastair F. Donaldson // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/structured_construct_to_block_reduction_opportunity_finder.h" #include "source/opt/build_module.h" #include "source/reduce/reduction_opportunity.h" #include "test/reduce/reduce_test_util.h" namespace spvtools { namespace reduce { namespace { TEST(StructuredConstructToBlockReductionPassTest, SimpleTest) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %10 = OpTypeBool %11 = OpConstantTrue %10 %19 = OpConstant %6 3 %29 = OpConstant %6 1 %31 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpStore %8 %9 OpSelectionMerge %13 None OpBranchConditional %11 %12 %13 %12 = OpLabel OpBranch %13 %13 = OpLabel OpBranch %14 %14 = OpLabel OpLoopMerge %16 %17 None OpBranch %15 %15 = OpLabel %18 = OpLoad %6 %8 %20 = OpSGreaterThan %10 %18 %19 OpSelectionMerge %22 None OpBranchConditional %20 %21 %22 %21 = OpLabel OpBranch %16 %22 = OpLabel OpBranch %17 %17 = OpLabel OpBranch %14 %16 = OpLabel %24 = OpLoad %6 %8 OpSelectionMerge %28 None OpSwitch %24 %27 1 %25 2 %26 %27 = OpLabel OpStore %8 %19 OpBranch %28 %25 = OpLabel OpStore %8 %29 OpBranch %28 %26 = OpLabel OpStore %8 %31 OpBranch %28 %28 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto context = BuildModule(env, nullptr, shader, kReduceAssembleOption); const auto ops = StructuredConstructToBlockReductionOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(3, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); CheckValid(env, context.get()); ASSERT_TRUE(ops[1]->PreconditionHolds()); ops[1]->TryToApply(); CheckValid(env, context.get()); ASSERT_TRUE(ops[2]->PreconditionHolds()); ops[2]->TryToApply(); CheckValid(env, context.get()); std::string expected = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %10 = OpTypeBool %11 = OpConstantTrue %10 %19 = OpConstant %6 3 %29 = OpConstant %6 1 %31 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpStore %8 %9 OpBranch %13 %13 = OpLabel OpBranch %14 %14 = OpLabel OpBranch %16 %16 = OpLabel %24 = OpLoad %6 %8 OpBranch %28 %28 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, expected, context.get()); } TEST(StructuredConstructToBlockReductionPassTest, CannotBeRemovedDueToUses) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpName %100 "temp" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %10 = OpTypeBool %11 = OpConstantTrue %10 %19 = OpConstant %6 3 %29 = OpConstant %6 1 %31 = OpConstant %6 2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpStore %8 %9 OpSelectionMerge %13 None OpBranchConditional %11 %12 %13 %12 = OpLabel %100 = OpCopyObject %10 %11 OpBranch %13 %13 = OpLabel OpBranch %14 %14 = OpLabel OpLoopMerge %16 %17 None OpBranch %15 %15 = OpLabel %18 = OpLoad %6 %8 %20 = OpSGreaterThan %10 %18 %19 OpSelectionMerge %22 None OpBranchConditional %20 %21 %22 %21 = OpLabel OpBranch %16 %22 = OpLabel OpBranch %17 %17 = OpLabel OpBranch %14 %16 = OpLabel %101 = OpCopyObject %6 %18 %24 = OpLoad %6 %8 OpSelectionMerge %28 None OpSwitch %24 %27 1 %25 2 %26 %27 = OpLabel OpStore %8 %19 %102 = OpCopyObject %10 %11 OpBranch %28 %25 = OpLabel OpStore %8 %29 OpBranch %28 %26 = OpLabel OpStore %8 %31 OpBranch %28 %28 = OpLabel %103 = OpPhi %10 %102 %27 %11 %25 %11 %26 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto context = BuildModule(env, nullptr, shader, kReduceAssembleOption); const auto ops = StructuredConstructToBlockReductionOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_TRUE(ops.empty()); } TEST(StructuredConstructToBlockReductionPassTest, CannotBeRemovedDueToOpPhiAtMerge) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeBool %11 = OpConstantTrue %10 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %13 None OpBranchConditional %11 %12 %13 %12 = OpLabel OpBranch %13 %13 = OpLabel %101 = OpPhi %10 %11 %5 %11 %12 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto context = BuildModule(env, nullptr, shader, kReduceAssembleOption); const auto ops = StructuredConstructToBlockReductionOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_TRUE(ops.empty()); } } // namespace } // namespace reduce } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/reduce/structured_loop_to_selection_test.cpp000066400000000000000000003517531475742701700305440ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/structured_loop_to_selection_reduction_opportunity_finder.h" #include "source/opt/build_module.h" #include "source/reduce/reduction_opportunity.h" #include "test/reduce/reduce_test_util.h" namespace spvtools { namespace reduce { namespace { TEST(StructuredLoopToSelectionReductionPassTest, LoopyShader1) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 100 %17 = OpTypeBool %20 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %15 = OpLoad %6 %8 %18 = OpSLessThan %17 %15 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel OpBranch %13 %13 = OpLabel %19 = OpLoad %6 %8 %21 = OpIAdd %6 %19 %20 OpStore %8 %21 OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto context = BuildModule(env, nullptr, shader, kReduceAssembleOption); const auto ops = StructuredLoopToSelectionReductionOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(1, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); CheckValid(env, context.get()); std::string after_op_0 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 100 %17 = OpTypeBool %20 = OpConstant %6 1 %22 = OpConstantTrue %17 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel OpSelectionMerge %12 None OpBranchConditional %22 %14 %12 %14 = OpLabel %15 = OpLoad %6 %8 %18 = OpSLessThan %17 %15 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel OpBranch %12 %13 = OpLabel %19 = OpLoad %6 %8 %21 = OpIAdd %6 %19 %20 OpStore %8 %21 OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, after_op_0, context.get()); } TEST(StructuredLoopToSelectionReductionPassTest, LoopyShader2) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 100 %17 = OpTypeBool %28 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %19 = OpVariable %7 Function %32 = OpVariable %7 Function %40 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %15 = OpLoad %6 %8 %18 = OpSLessThan %17 %15 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel OpStore %19 %9 OpBranch %20 %20 = OpLabel OpLoopMerge %22 %23 None OpBranch %24 %24 = OpLabel %25 = OpLoad %6 %19 %26 = OpSLessThan %17 %25 %16 OpBranchConditional %26 %21 %22 %21 = OpLabel OpBranch %23 %23 = OpLabel %27 = OpLoad %6 %19 %29 = OpIAdd %6 %27 %28 OpStore %19 %29 OpBranch %20 %22 = OpLabel OpBranch %13 %13 = OpLabel %30 = OpLoad %6 %8 %31 = OpIAdd %6 %30 %28 OpStore %8 %31 OpBranch %10 %12 = OpLabel OpStore %32 %9 OpBranch %33 %33 = OpLabel OpLoopMerge %35 %36 None OpBranch %37 %37 = OpLabel %38 = OpLoad %6 %32 %39 = OpSLessThan %17 %38 %16 OpBranchConditional %39 %34 %35 %34 = OpLabel OpStore %40 %9 OpBranch %41 %41 = OpLabel OpLoopMerge %43 %44 None OpBranch %45 %45 = OpLabel %46 = OpLoad %6 %40 %47 = OpSLessThan %17 %46 %16 OpBranchConditional %47 %42 %43 %42 = OpLabel OpBranch %44 %44 = OpLabel %48 = OpLoad %6 %40 %49 = OpIAdd %6 %48 %28 OpStore %40 %49 OpBranch %41 %43 = OpLabel OpBranch %36 %36 = OpLabel %50 = OpLoad %6 %32 %51 = OpIAdd %6 %50 %28 OpStore %32 %51 OpBranch %33 %35 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto context = BuildModule(env, nullptr, shader, kReduceAssembleOption); const auto ops = StructuredLoopToSelectionReductionOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(4, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); CheckValid(env, context.get()); std::string after_op_0 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 100 %17 = OpTypeBool %28 = OpConstant %6 1 %52 = OpConstantTrue %17 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %19 = OpVariable %7 Function %32 = OpVariable %7 Function %40 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel OpSelectionMerge %12 None OpBranchConditional %52 %14 %12 %14 = OpLabel %15 = OpLoad %6 %8 %18 = OpSLessThan %17 %15 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel OpStore %19 %9 OpBranch %20 %20 = OpLabel OpLoopMerge %22 %23 None OpBranch %24 %24 = OpLabel %25 = OpLoad %6 %19 %26 = OpSLessThan %17 %25 %16 OpBranchConditional %26 %21 %22 %21 = OpLabel OpBranch %23 %23 = OpLabel %27 = OpLoad %6 %19 %29 = OpIAdd %6 %27 %28 OpStore %19 %29 OpBranch %20 %22 = OpLabel OpBranch %12 %13 = OpLabel %30 = OpLoad %6 %8 %31 = OpIAdd %6 %30 %28 OpStore %8 %31 OpBranch %10 %12 = OpLabel OpStore %32 %9 OpBranch %33 %33 = OpLabel OpLoopMerge %35 %36 None OpBranch %37 %37 = OpLabel %38 = OpLoad %6 %32 %39 = OpSLessThan %17 %38 %16 OpBranchConditional %39 %34 %35 %34 = OpLabel OpStore %40 %9 OpBranch %41 %41 = OpLabel OpLoopMerge %43 %44 None OpBranch %45 %45 = OpLabel %46 = OpLoad %6 %40 %47 = OpSLessThan %17 %46 %16 OpBranchConditional %47 %42 %43 %42 = OpLabel OpBranch %44 %44 = OpLabel %48 = OpLoad %6 %40 %49 = OpIAdd %6 %48 %28 OpStore %40 %49 OpBranch %41 %43 = OpLabel OpBranch %36 %36 = OpLabel %50 = OpLoad %6 %32 %51 = OpIAdd %6 %50 %28 OpStore %32 %51 OpBranch %33 %35 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, after_op_0, context.get()); ASSERT_TRUE(ops[1]->PreconditionHolds()); ops[1]->TryToApply(); CheckValid(env, context.get()); std::string after_op_1 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 100 %17 = OpTypeBool %28 = OpConstant %6 1 %52 = OpConstantTrue %17 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %19 = OpVariable %7 Function %32 = OpVariable %7 Function %40 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel OpSelectionMerge %12 None OpBranchConditional %52 %14 %12 %14 = OpLabel %15 = OpLoad %6 %8 %18 = OpSLessThan %17 %15 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel OpStore %19 %9 OpBranch %20 %20 = OpLabel OpSelectionMerge %22 None OpBranchConditional %52 %24 %22 %24 = OpLabel %25 = OpLoad %6 %19 %26 = OpSLessThan %17 %25 %16 OpBranchConditional %26 %21 %22 %21 = OpLabel OpBranch %22 %23 = OpLabel %27 = OpLoad %6 %19 %29 = OpIAdd %6 %27 %28 OpStore %19 %29 OpBranch %20 %22 = OpLabel OpBranch %12 %13 = OpLabel %30 = OpLoad %6 %8 %31 = OpIAdd %6 %30 %28 OpStore %8 %31 OpBranch %10 %12 = OpLabel OpStore %32 %9 OpBranch %33 %33 = OpLabel OpLoopMerge %35 %36 None OpBranch %37 %37 = OpLabel %38 = OpLoad %6 %32 %39 = OpSLessThan %17 %38 %16 OpBranchConditional %39 %34 %35 %34 = OpLabel OpStore %40 %9 OpBranch %41 %41 = OpLabel OpLoopMerge %43 %44 None OpBranch %45 %45 = OpLabel %46 = OpLoad %6 %40 %47 = OpSLessThan %17 %46 %16 OpBranchConditional %47 %42 %43 %42 = OpLabel OpBranch %44 %44 = OpLabel %48 = OpLoad %6 %40 %49 = OpIAdd %6 %48 %28 OpStore %40 %49 OpBranch %41 %43 = OpLabel OpBranch %36 %36 = OpLabel %50 = OpLoad %6 %32 %51 = OpIAdd %6 %50 %28 OpStore %32 %51 OpBranch %33 %35 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, after_op_1, context.get()); ASSERT_TRUE(ops[2]->PreconditionHolds()); ops[2]->TryToApply(); CheckValid(env, context.get()); std::string after_op_2 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 100 %17 = OpTypeBool %28 = OpConstant %6 1 %52 = OpConstantTrue %17 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %19 = OpVariable %7 Function %32 = OpVariable %7 Function %40 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel OpSelectionMerge %12 None OpBranchConditional %52 %14 %12 %14 = OpLabel %15 = OpLoad %6 %8 %18 = OpSLessThan %17 %15 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel OpStore %19 %9 OpBranch %20 %20 = OpLabel OpSelectionMerge %22 None OpBranchConditional %52 %24 %22 %24 = OpLabel %25 = OpLoad %6 %19 %26 = OpSLessThan %17 %25 %16 OpBranchConditional %26 %21 %22 %21 = OpLabel OpBranch %22 %23 = OpLabel %27 = OpLoad %6 %19 %29 = OpIAdd %6 %27 %28 OpStore %19 %29 OpBranch %20 %22 = OpLabel OpBranch %12 %13 = OpLabel %30 = OpLoad %6 %8 %31 = OpIAdd %6 %30 %28 OpStore %8 %31 OpBranch %10 %12 = OpLabel OpStore %32 %9 OpBranch %33 %33 = OpLabel OpSelectionMerge %35 None OpBranchConditional %52 %37 %35 %37 = OpLabel %38 = OpLoad %6 %32 %39 = OpSLessThan %17 %38 %16 OpBranchConditional %39 %34 %35 %34 = OpLabel OpStore %40 %9 OpBranch %41 %41 = OpLabel OpLoopMerge %43 %44 None OpBranch %45 %45 = OpLabel %46 = OpLoad %6 %40 %47 = OpSLessThan %17 %46 %16 OpBranchConditional %47 %42 %43 %42 = OpLabel OpBranch %44 %44 = OpLabel %48 = OpLoad %6 %40 %49 = OpIAdd %6 %48 %28 OpStore %40 %49 OpBranch %41 %43 = OpLabel OpBranch %35 %36 = OpLabel %50 = OpLoad %6 %32 %51 = OpIAdd %6 %50 %28 OpStore %32 %51 OpBranch %33 %35 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, after_op_2, context.get()); ASSERT_TRUE(ops[3]->PreconditionHolds()); ops[3]->TryToApply(); CheckValid(env, context.get()); std::string after_op_3 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpConstant %6 100 %17 = OpTypeBool %28 = OpConstant %6 1 %52 = OpConstantTrue %17 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %19 = OpVariable %7 Function %32 = OpVariable %7 Function %40 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel OpSelectionMerge %12 None OpBranchConditional %52 %14 %12 %14 = OpLabel %15 = OpLoad %6 %8 %18 = OpSLessThan %17 %15 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel OpStore %19 %9 OpBranch %20 %20 = OpLabel OpSelectionMerge %22 None OpBranchConditional %52 %24 %22 %24 = OpLabel %25 = OpLoad %6 %19 %26 = OpSLessThan %17 %25 %16 OpBranchConditional %26 %21 %22 %21 = OpLabel OpBranch %22 %23 = OpLabel %27 = OpLoad %6 %19 %29 = OpIAdd %6 %27 %28 OpStore %19 %29 OpBranch %20 %22 = OpLabel OpBranch %12 %13 = OpLabel %30 = OpLoad %6 %8 %31 = OpIAdd %6 %30 %28 OpStore %8 %31 OpBranch %10 %12 = OpLabel OpStore %32 %9 OpBranch %33 %33 = OpLabel OpSelectionMerge %35 None OpBranchConditional %52 %37 %35 %37 = OpLabel %38 = OpLoad %6 %32 %39 = OpSLessThan %17 %38 %16 OpBranchConditional %39 %34 %35 %34 = OpLabel OpStore %40 %9 OpBranch %41 %41 = OpLabel OpSelectionMerge %43 None OpBranchConditional %52 %45 %43 %45 = OpLabel %46 = OpLoad %6 %40 %47 = OpSLessThan %17 %46 %16 OpBranchConditional %47 %42 %43 %42 = OpLabel OpBranch %43 %44 = OpLabel %48 = OpLoad %6 %40 %49 = OpIAdd %6 %48 %28 OpStore %40 %49 OpBranch %41 %43 = OpLabel OpBranch %35 %36 = OpLabel %50 = OpLoad %6 %32 %51 = OpIAdd %6 %50 %28 OpStore %32 %51 OpBranch %33 %35 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, after_op_3, context.get()); } TEST(StructuredLoopToSelectionReductionPassTest, LoopyShader3) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 10 %16 = OpConstant %6 0 %17 = OpTypeBool %20 = OpConstant %6 1 %23 = OpConstant %6 3 %40 = OpConstant %6 5 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %15 = OpLoad %6 %8 %18 = OpSGreaterThan %17 %15 %16 OpBranchConditional %18 %11 %12 %11 = OpLabel %19 = OpLoad %6 %8 %21 = OpISub %6 %19 %20 OpStore %8 %21 %22 = OpLoad %6 %8 %24 = OpSLessThan %17 %22 %23 OpSelectionMerge %26 None OpBranchConditional %24 %25 %26 %25 = OpLabel OpBranch %13 %26 = OpLabel OpBranch %28 %28 = OpLabel OpLoopMerge %30 %31 None OpBranch %29 %29 = OpLabel %32 = OpLoad %6 %8 %33 = OpISub %6 %32 %20 OpStore %8 %33 %34 = OpLoad %6 %8 %35 = OpIEqual %17 %34 %20 OpSelectionMerge %37 None OpBranchConditional %35 %36 %37 %36 = OpLabel OpReturn ; This return spoils everything: it means the merge does not post-dominate the header. %37 = OpLabel OpBranch %31 %31 = OpLabel %39 = OpLoad %6 %8 %41 = OpSGreaterThan %17 %39 %40 OpBranchConditional %41 %28 %30 %30 = OpLabel OpBranch %13 %13 = OpLabel OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto context = BuildModule(env, nullptr, shader, kReduceAssembleOption); const auto ops = StructuredLoopToSelectionReductionOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(0, ops.size()); } TEST(StructuredLoopToSelectionReductionPassTest, LoopyShader4) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %6 %7 %13 = OpConstant %6 0 %22 = OpTypeBool %25 = OpConstant %6 1 %39 = OpConstant %6 100 %4 = OpFunction %2 None %3 %5 = OpLabel %45 = OpVariable %7 Function %46 = OpVariable %7 Function %47 = OpVariable %7 Function %32 = OpVariable %7 Function %42 = OpVariable %7 Function OpStore %32 %13 OpBranch %33 %33 = OpLabel OpLoopMerge %35 %36 None OpBranch %37 %37 = OpLabel %38 = OpLoad %6 %32 %40 = OpSLessThan %22 %38 %39 OpBranchConditional %40 %34 %35 %34 = OpLabel OpBranch %36 %36 = OpLabel %41 = OpLoad %6 %32 OpStore %42 %25 OpStore %45 %13 OpStore %46 %13 OpBranch %48 %48 = OpLabel OpLoopMerge %49 %50 None OpBranch %51 %51 = OpLabel %52 = OpLoad %6 %46 %53 = OpLoad %6 %42 %54 = OpSLessThan %22 %52 %53 OpBranchConditional %54 %55 %49 %55 = OpLabel %56 = OpLoad %6 %45 %57 = OpIAdd %6 %56 %25 OpStore %45 %57 OpBranch %50 %50 = OpLabel %58 = OpLoad %6 %46 %59 = OpIAdd %6 %58 %25 OpStore %46 %59 OpBranch %48 %49 = OpLabel %60 = OpLoad %6 %45 OpStore %47 %60 %43 = OpLoad %6 %47 %44 = OpIAdd %6 %41 %43 OpStore %32 %44 OpBranch %33 %35 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto context = BuildModule(env, nullptr, shader, kReduceAssembleOption); const auto ops = StructuredLoopToSelectionReductionOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); // Initially there are two opportunities. ASSERT_EQ(2, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); CheckValid(env, context.get()); std::string after_op_0 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %6 %7 %13 = OpConstant %6 0 %22 = OpTypeBool %25 = OpConstant %6 1 %39 = OpConstant %6 100 %61 = OpConstantTrue %22 %62 = OpUndef %6 %4 = OpFunction %2 None %3 %5 = OpLabel %45 = OpVariable %7 Function %46 = OpVariable %7 Function %47 = OpVariable %7 Function %32 = OpVariable %7 Function %42 = OpVariable %7 Function OpStore %32 %13 OpBranch %33 %33 = OpLabel OpSelectionMerge %35 None OpBranchConditional %61 %37 %35 %37 = OpLabel %38 = OpLoad %6 %32 %40 = OpSLessThan %22 %38 %39 OpBranchConditional %40 %34 %35 %34 = OpLabel OpBranch %35 %36 = OpLabel %41 = OpLoad %6 %32 OpStore %42 %25 OpStore %45 %13 OpStore %46 %13 OpBranch %48 %48 = OpLabel OpLoopMerge %49 %50 None OpBranch %51 %51 = OpLabel %52 = OpLoad %6 %46 %53 = OpLoad %6 %42 %54 = OpSLessThan %22 %52 %53 OpBranchConditional %54 %55 %49 %55 = OpLabel %56 = OpLoad %6 %45 %57 = OpIAdd %6 %56 %25 OpStore %45 %57 OpBranch %50 %50 = OpLabel %58 = OpLoad %6 %46 %59 = OpIAdd %6 %58 %25 OpStore %46 %59 OpBranch %48 %49 = OpLabel %60 = OpLoad %6 %45 OpStore %47 %60 %43 = OpLoad %6 %47 %44 = OpIAdd %6 %62 %43 OpStore %32 %44 OpBranch %33 %35 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, after_op_0, context.get()); // Applying the first opportunity has killed the second opportunity, because // there was a loop embedded in the continue target of the loop we have just // eliminated; the continue-embedded loop is now unreachable. ASSERT_FALSE(ops[1]->PreconditionHolds()); } TEST(StructuredLoopToSelectionReductionPassTest, ConditionalBreak1) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeBool %11 = OpConstantFalse %10 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %6 %6 = OpLabel OpLoopMerge %8 %9 None OpBranch %7 %7 = OpLabel OpSelectionMerge %13 None OpBranchConditional %11 %12 %13 %12 = OpLabel OpBranch %8 %13 = OpLabel OpBranch %9 %9 = OpLabel OpBranchConditional %11 %6 %8 %8 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto context = BuildModule(env, nullptr, shader, kReduceAssembleOption); const auto ops = StructuredLoopToSelectionReductionOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(1, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); CheckValid(env, context.get()); std::string after_op_0 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeBool %11 = OpConstantFalse %10 %14 = OpConstantTrue %10 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %6 %6 = OpLabel OpSelectionMerge %8 None OpBranchConditional %14 %7 %8 %7 = OpLabel OpSelectionMerge %13 None OpBranchConditional %11 %12 %13 %12 = OpLabel OpBranch %13 %13 = OpLabel OpBranch %8 %9 = OpLabel OpBranchConditional %11 %6 %8 %8 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, after_op_0, context.get()); } TEST(StructuredLoopToSelectionReductionPassTest, ConditionalBreak2) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeBool %11 = OpConstantFalse %10 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %6 %6 = OpLabel OpLoopMerge %8 %9 None OpBranch %7 %7 = OpLabel OpSelectionMerge %13 None OpBranchConditional %11 %8 %13 %13 = OpLabel OpBranch %9 %9 = OpLabel OpBranchConditional %11 %6 %8 %8 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto context = BuildModule(env, nullptr, shader, kReduceAssembleOption); const auto ops = StructuredLoopToSelectionReductionOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(1, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); CheckValid(env, context.get()); std::string after_op_0 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeBool %11 = OpConstantFalse %10 %14 = OpConstantTrue %10 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %6 %6 = OpLabel OpSelectionMerge %8 None OpBranchConditional %14 %7 %8 %7 = OpLabel OpSelectionMerge %13 None OpBranchConditional %11 %13 %13 %13 = OpLabel OpBranch %8 %9 = OpLabel OpBranchConditional %11 %6 %8 %8 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, after_op_0, context.get()); } TEST(StructuredLoopToSelectionReductionPassTest, UnconditionalBreak) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %6 %6 = OpLabel OpLoopMerge %8 %9 None OpBranch %7 %7 = OpLabel OpBranch %8 %9 = OpLabel OpBranch %6 %8 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto context = BuildModule(env, nullptr, shader, kReduceAssembleOption); const auto ops = StructuredLoopToSelectionReductionOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(1, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); CheckValid(env, context.get()); std::string after_op_0 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %10 = OpTypeBool %11 = OpConstantTrue %10 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %6 %6 = OpLabel OpSelectionMerge %8 None OpBranchConditional %11 %7 %8 %7 = OpLabel OpBranch %8 %9 = OpLabel OpBranch %6 %8 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, after_op_0, context.get()); } TEST(StructuredLoopToSelectionReductionPassTest, Complex) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpMemberDecorate %4 0 Offset 0 OpMemberDecorate %4 1 Offset 4 OpMemberDecorate %4 2 Offset 8 OpMemberDecorate %4 3 Offset 12 OpDecorate %4 Block OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 0 OpDecorate %3 Location 0 %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeBool %9 = OpTypePointer Function %8 %10 = OpTypeInt 32 1 %4 = OpTypeStruct %10 %10 %10 %10 %11 = OpTypePointer Uniform %4 %5 = OpVariable %11 Uniform %12 = OpConstant %10 0 %13 = OpTypePointer Uniform %10 %14 = OpTypeInt 32 0 %15 = OpConstant %14 0 %16 = OpConstant %10 1 %17 = OpConstant %10 2 %18 = OpConstant %10 3 %19 = OpTypePointer Function %10 %20 = OpConstantFalse %8 %21 = OpTypeFloat 32 %22 = OpTypeVector %21 4 %23 = OpTypePointer Output %22 %3 = OpVariable %23 Output %2 = OpFunction %6 None %7 %24 = OpLabel %25 = OpVariable %9 Function %26 = OpVariable %9 Function %27 = OpVariable %9 Function %28 = OpVariable %9 Function %29 = OpVariable %9 Function %30 = OpVariable %19 Function %31 = OpAccessChain %13 %5 %12 %32 = OpLoad %10 %31 %33 = OpINotEqual %8 %32 %15 OpStore %25 %33 %34 = OpAccessChain %13 %5 %16 %35 = OpLoad %10 %34 %36 = OpINotEqual %8 %35 %15 OpStore %26 %36 %37 = OpAccessChain %13 %5 %17 %38 = OpLoad %10 %37 %39 = OpINotEqual %8 %38 %15 OpStore %27 %39 %40 = OpAccessChain %13 %5 %18 %41 = OpLoad %10 %40 %42 = OpINotEqual %8 %41 %15 OpStore %28 %42 %43 = OpLoad %8 %25 OpStore %29 %43 OpStore %30 %12 OpBranch %44 %44 = OpLabel OpLoopMerge %45 %46 None OpBranch %47 %47 = OpLabel %48 = OpLoad %8 %29 OpBranchConditional %48 %49 %45 %49 = OpLabel %50 = OpLoad %8 %25 OpSelectionMerge %51 None OpBranchConditional %50 %52 %51 %52 = OpLabel %53 = OpLoad %8 %26 OpStore %29 %53 %54 = OpLoad %10 %30 %55 = OpIAdd %10 %54 %16 OpStore %30 %55 OpBranch %51 %51 = OpLabel %56 = OpLoad %8 %26 OpSelectionMerge %57 None OpBranchConditional %56 %58 %57 %58 = OpLabel %59 = OpLoad %10 %30 %60 = OpIAdd %10 %59 %16 OpStore %30 %60 %61 = OpLoad %8 %29 %62 = OpLoad %8 %25 %63 = OpLogicalOr %8 %61 %62 OpStore %29 %63 %64 = OpLoad %8 %27 OpSelectionMerge %65 None OpBranchConditional %64 %66 %65 %66 = OpLabel %67 = OpLoad %10 %30 %68 = OpIAdd %10 %67 %17 OpStore %30 %68 %69 = OpLoad %8 %29 %70 = OpLogicalNot %8 %69 OpStore %29 %70 OpBranch %46 %65 = OpLabel %71 = OpLoad %8 %29 %72 = OpLogicalOr %8 %71 %20 OpStore %29 %72 OpBranch %46 %57 = OpLabel OpBranch %73 %73 = OpLabel OpLoopMerge %74 %75 None OpBranch %76 %76 = OpLabel %77 = OpLoad %8 %28 OpSelectionMerge %78 None OpBranchConditional %77 %79 %80 %79 = OpLabel %81 = OpLoad %10 %30 OpSelectionMerge %82 None OpSwitch %81 %83 1 %84 2 %85 %83 = OpLabel OpBranch %82 %84 = OpLabel %86 = OpLoad %8 %29 %87 = OpSelect %10 %86 %16 %17 %88 = OpLoad %10 %30 %89 = OpIAdd %10 %88 %87 OpStore %30 %89 OpBranch %82 %85 = OpLabel OpBranch %75 %82 = OpLabel %90 = OpLoad %8 %27 OpSelectionMerge %91 None OpBranchConditional %90 %92 %91 %92 = OpLabel OpBranch %75 %91 = OpLabel OpBranch %78 %80 = OpLabel OpBranch %74 %78 = OpLabel OpBranch %75 %75 = OpLabel %93 = OpLoad %8 %29 OpBranchConditional %93 %73 %74 %74 = OpLabel OpBranch %46 %46 = OpLabel OpBranch %44 %45 = OpLabel %94 = OpLoad %10 %30 %95 = OpConvertSToF %21 %94 %96 = OpCompositeConstruct %22 %95 %95 %95 %95 OpStore %3 %96 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto context = BuildModule(env, nullptr, shader, kReduceAssembleOption); const auto ops = StructuredLoopToSelectionReductionOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(2, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); CheckValid(env, context.get()); std::string after_op_0 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpMemberDecorate %4 0 Offset 0 OpMemberDecorate %4 1 Offset 4 OpMemberDecorate %4 2 Offset 8 OpMemberDecorate %4 3 Offset 12 OpDecorate %4 Block OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 0 OpDecorate %3 Location 0 %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeBool %9 = OpTypePointer Function %8 %10 = OpTypeInt 32 1 %4 = OpTypeStruct %10 %10 %10 %10 %11 = OpTypePointer Uniform %4 %5 = OpVariable %11 Uniform %12 = OpConstant %10 0 %13 = OpTypePointer Uniform %10 %14 = OpTypeInt 32 0 %15 = OpConstant %14 0 %16 = OpConstant %10 1 %17 = OpConstant %10 2 %18 = OpConstant %10 3 %19 = OpTypePointer Function %10 %20 = OpConstantFalse %8 %21 = OpTypeFloat 32 %22 = OpTypeVector %21 4 %23 = OpTypePointer Output %22 %3 = OpVariable %23 Output %97 = OpConstantTrue %8 %2 = OpFunction %6 None %7 %24 = OpLabel %25 = OpVariable %9 Function %26 = OpVariable %9 Function %27 = OpVariable %9 Function %28 = OpVariable %9 Function %29 = OpVariable %9 Function %30 = OpVariable %19 Function %31 = OpAccessChain %13 %5 %12 %32 = OpLoad %10 %31 %33 = OpINotEqual %8 %32 %15 OpStore %25 %33 %34 = OpAccessChain %13 %5 %16 %35 = OpLoad %10 %34 %36 = OpINotEqual %8 %35 %15 OpStore %26 %36 %37 = OpAccessChain %13 %5 %17 %38 = OpLoad %10 %37 %39 = OpINotEqual %8 %38 %15 OpStore %27 %39 %40 = OpAccessChain %13 %5 %18 %41 = OpLoad %10 %40 %42 = OpINotEqual %8 %41 %15 OpStore %28 %42 %43 = OpLoad %8 %25 OpStore %29 %43 OpStore %30 %12 OpBranch %44 %44 = OpLabel OpSelectionMerge %45 None ; Was OpLoopMerge %45 %46 None OpBranchConditional %97 %47 %45 ; Was OpBranch %47 %47 = OpLabel %48 = OpLoad %8 %29 OpBranchConditional %48 %49 %45 %49 = OpLabel %50 = OpLoad %8 %25 OpSelectionMerge %51 None OpBranchConditional %50 %52 %51 %52 = OpLabel %53 = OpLoad %8 %26 OpStore %29 %53 %54 = OpLoad %10 %30 %55 = OpIAdd %10 %54 %16 OpStore %30 %55 OpBranch %51 %51 = OpLabel %56 = OpLoad %8 %26 OpSelectionMerge %57 None OpBranchConditional %56 %58 %57 %58 = OpLabel %59 = OpLoad %10 %30 %60 = OpIAdd %10 %59 %16 OpStore %30 %60 %61 = OpLoad %8 %29 %62 = OpLoad %8 %25 %63 = OpLogicalOr %8 %61 %62 OpStore %29 %63 %64 = OpLoad %8 %27 OpSelectionMerge %65 None OpBranchConditional %64 %66 %65 %66 = OpLabel %67 = OpLoad %10 %30 %68 = OpIAdd %10 %67 %17 OpStore %30 %68 %69 = OpLoad %8 %29 %70 = OpLogicalNot %8 %69 OpStore %29 %70 OpBranch %65 ; Was OpBranch %46 %65 = OpLabel %71 = OpLoad %8 %29 %72 = OpLogicalOr %8 %71 %20 OpStore %29 %72 OpBranch %57 ; Was OpBranch %46 %57 = OpLabel OpBranch %73 %73 = OpLabel OpLoopMerge %74 %75 None OpBranch %76 %76 = OpLabel %77 = OpLoad %8 %28 OpSelectionMerge %78 None OpBranchConditional %77 %79 %80 %79 = OpLabel %81 = OpLoad %10 %30 OpSelectionMerge %82 None OpSwitch %81 %83 1 %84 2 %85 %83 = OpLabel OpBranch %82 %84 = OpLabel %86 = OpLoad %8 %29 %87 = OpSelect %10 %86 %16 %17 %88 = OpLoad %10 %30 %89 = OpIAdd %10 %88 %87 OpStore %30 %89 OpBranch %82 %85 = OpLabel OpBranch %75 %82 = OpLabel %90 = OpLoad %8 %27 OpSelectionMerge %91 None OpBranchConditional %90 %92 %91 %92 = OpLabel OpBranch %75 %91 = OpLabel OpBranch %78 %80 = OpLabel OpBranch %74 %78 = OpLabel OpBranch %75 %75 = OpLabel %93 = OpLoad %8 %29 OpBranchConditional %93 %73 %74 %74 = OpLabel OpBranch %45 ; Was OpBranch %46 %46 = OpLabel OpBranch %44 %45 = OpLabel %94 = OpLoad %10 %30 %95 = OpConvertSToF %21 %94 %96 = OpCompositeConstruct %22 %95 %95 %95 %95 OpStore %3 %96 OpReturn OpFunctionEnd )"; CheckEqual(env, after_op_0, context.get()); ASSERT_TRUE(ops[1]->PreconditionHolds()); ops[1]->TryToApply(); CheckValid(env, context.get()); std::string after_op_1 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpMemberDecorate %4 0 Offset 0 OpMemberDecorate %4 1 Offset 4 OpMemberDecorate %4 2 Offset 8 OpMemberDecorate %4 3 Offset 12 OpDecorate %4 Block OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 0 OpDecorate %3 Location 0 %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeBool %9 = OpTypePointer Function %8 %10 = OpTypeInt 32 1 %4 = OpTypeStruct %10 %10 %10 %10 %11 = OpTypePointer Uniform %4 %5 = OpVariable %11 Uniform %12 = OpConstant %10 0 %13 = OpTypePointer Uniform %10 %14 = OpTypeInt 32 0 %15 = OpConstant %14 0 %16 = OpConstant %10 1 %17 = OpConstant %10 2 %18 = OpConstant %10 3 %19 = OpTypePointer Function %10 %20 = OpConstantFalse %8 %21 = OpTypeFloat 32 %22 = OpTypeVector %21 4 %23 = OpTypePointer Output %22 %3 = OpVariable %23 Output %97 = OpConstantTrue %8 %2 = OpFunction %6 None %7 %24 = OpLabel %25 = OpVariable %9 Function %26 = OpVariable %9 Function %27 = OpVariable %9 Function %28 = OpVariable %9 Function %29 = OpVariable %9 Function %30 = OpVariable %19 Function %31 = OpAccessChain %13 %5 %12 %32 = OpLoad %10 %31 %33 = OpINotEqual %8 %32 %15 OpStore %25 %33 %34 = OpAccessChain %13 %5 %16 %35 = OpLoad %10 %34 %36 = OpINotEqual %8 %35 %15 OpStore %26 %36 %37 = OpAccessChain %13 %5 %17 %38 = OpLoad %10 %37 %39 = OpINotEqual %8 %38 %15 OpStore %27 %39 %40 = OpAccessChain %13 %5 %18 %41 = OpLoad %10 %40 %42 = OpINotEqual %8 %41 %15 OpStore %28 %42 %43 = OpLoad %8 %25 OpStore %29 %43 OpStore %30 %12 OpBranch %44 %44 = OpLabel OpSelectionMerge %45 None ; Was OpLoopMerge %45 %46 None OpBranchConditional %97 %47 %45 ; Was OpBranch %47 %47 = OpLabel %48 = OpLoad %8 %29 OpBranchConditional %48 %49 %45 %49 = OpLabel %50 = OpLoad %8 %25 OpSelectionMerge %51 None OpBranchConditional %50 %52 %51 %52 = OpLabel %53 = OpLoad %8 %26 OpStore %29 %53 %54 = OpLoad %10 %30 %55 = OpIAdd %10 %54 %16 OpStore %30 %55 OpBranch %51 %51 = OpLabel %56 = OpLoad %8 %26 OpSelectionMerge %57 None OpBranchConditional %56 %58 %57 %58 = OpLabel %59 = OpLoad %10 %30 %60 = OpIAdd %10 %59 %16 OpStore %30 %60 %61 = OpLoad %8 %29 %62 = OpLoad %8 %25 %63 = OpLogicalOr %8 %61 %62 OpStore %29 %63 %64 = OpLoad %8 %27 OpSelectionMerge %65 None OpBranchConditional %64 %66 %65 %66 = OpLabel %67 = OpLoad %10 %30 %68 = OpIAdd %10 %67 %17 OpStore %30 %68 %69 = OpLoad %8 %29 %70 = OpLogicalNot %8 %69 OpStore %29 %70 OpBranch %65 ; Was OpBranch %46 %65 = OpLabel %71 = OpLoad %8 %29 %72 = OpLogicalOr %8 %71 %20 OpStore %29 %72 OpBranch %57 ; Was OpBranch %46 %57 = OpLabel OpBranch %73 %73 = OpLabel OpSelectionMerge %74 None ; Was OpLoopMerge %74 %75 None OpBranchConditional %97 %76 %74 ; Was OpBranch %76 %76 = OpLabel %77 = OpLoad %8 %28 OpSelectionMerge %78 None OpBranchConditional %77 %79 %80 %79 = OpLabel %81 = OpLoad %10 %30 OpSelectionMerge %82 None OpSwitch %81 %83 1 %84 2 %85 %83 = OpLabel OpBranch %82 %84 = OpLabel %86 = OpLoad %8 %29 %87 = OpSelect %10 %86 %16 %17 %88 = OpLoad %10 %30 %89 = OpIAdd %10 %88 %87 OpStore %30 %89 OpBranch %82 %85 = OpLabel OpBranch %82 %82 = OpLabel %90 = OpLoad %8 %27 OpSelectionMerge %91 None OpBranchConditional %90 %92 %91 %92 = OpLabel OpBranch %91 %91 = OpLabel OpBranch %78 %80 = OpLabel OpBranch %78 ; Was OpBranch %74 %78 = OpLabel OpBranch %74 %75 = OpLabel %93 = OpLoad %8 %29 OpBranchConditional %93 %73 %74 %74 = OpLabel OpBranch %45 ; Was OpBranch %46 %46 = OpLabel OpBranch %44 %45 = OpLabel %94 = OpLoad %10 %30 %95 = OpConvertSToF %21 %94 %96 = OpCompositeConstruct %22 %95 %95 %95 %95 OpStore %3 %96 OpReturn OpFunctionEnd )"; CheckEqual(env, after_op_1, context.get()); } TEST(StructuredLoopToSelectionReductionPassTest, ComplexOptimized) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpMemberDecorate %4 0 Offset 0 OpMemberDecorate %4 1 Offset 4 OpMemberDecorate %4 2 Offset 8 OpMemberDecorate %4 3 Offset 12 OpDecorate %4 Block OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 0 OpDecorate %3 Location 0 %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeBool %10 = OpTypeInt 32 1 %4 = OpTypeStruct %10 %10 %10 %10 %11 = OpTypePointer Uniform %4 %5 = OpVariable %11 Uniform %12 = OpConstant %10 0 %13 = OpTypePointer Uniform %10 %14 = OpTypeInt 32 0 %15 = OpConstant %14 0 %16 = OpConstant %10 1 %17 = OpConstant %10 2 %18 = OpConstant %10 3 %20 = OpConstantFalse %8 %21 = OpTypeFloat 32 %22 = OpTypeVector %21 4 %23 = OpTypePointer Output %22 %3 = OpVariable %23 Output %2 = OpFunction %6 None %7 %24 = OpLabel %31 = OpAccessChain %13 %5 %12 %32 = OpLoad %10 %31 %33 = OpINotEqual %8 %32 %15 %34 = OpAccessChain %13 %5 %16 %35 = OpLoad %10 %34 %36 = OpINotEqual %8 %35 %15 %37 = OpAccessChain %13 %5 %17 %38 = OpLoad %10 %37 %39 = OpINotEqual %8 %38 %15 %40 = OpAccessChain %13 %5 %18 %41 = OpLoad %10 %40 %42 = OpINotEqual %8 %41 %15 OpBranch %44 %44 = OpLabel %98 = OpPhi %10 %12 %24 %107 %46 %97 = OpPhi %8 %33 %24 %105 %46 OpLoopMerge %45 %46 None OpBranchConditional %97 %49 %45 %49 = OpLabel OpSelectionMerge %51 None OpBranchConditional %33 %52 %51 %52 = OpLabel %55 = OpIAdd %10 %98 %16 OpBranch %51 %51 = OpLabel %100 = OpPhi %10 %98 %49 %55 %52 %113 = OpSelect %8 %33 %36 %97 OpSelectionMerge %57 None OpBranchConditional %36 %58 %57 %58 = OpLabel %60 = OpIAdd %10 %100 %16 %63 = OpLogicalOr %8 %113 %33 OpSelectionMerge %65 None OpBranchConditional %39 %66 %65 %66 = OpLabel %68 = OpIAdd %10 %100 %18 %70 = OpLogicalNot %8 %63 OpBranch %46 %65 = OpLabel %72 = OpLogicalOr %8 %63 %20 OpBranch %46 %57 = OpLabel OpBranch %73 %73 = OpLabel %99 = OpPhi %10 %100 %57 %109 %75 OpLoopMerge %74 %75 None OpBranch %76 %76 = OpLabel OpSelectionMerge %78 None OpBranchConditional %42 %79 %80 %79 = OpLabel OpSelectionMerge %82 None OpSwitch %99 %83 1 %84 2 %85 %83 = OpLabel OpBranch %82 %84 = OpLabel %87 = OpSelect %10 %113 %16 %17 %89 = OpIAdd %10 %99 %87 OpBranch %82 %85 = OpLabel OpBranch %75 %82 = OpLabel %110 = OpPhi %10 %99 %83 %89 %84 OpSelectionMerge %91 None OpBranchConditional %39 %92 %91 %92 = OpLabel OpBranch %75 %91 = OpLabel OpBranch %78 %80 = OpLabel OpBranch %74 %78 = OpLabel OpBranch %75 %75 = OpLabel %109 = OpPhi %10 %99 %85 %110 %92 %110 %78 OpBranchConditional %113 %73 %74 %74 = OpLabel %108 = OpPhi %10 %99 %80 %109 %75 OpBranch %46 %46 = OpLabel %107 = OpPhi %10 %68 %66 %60 %65 %108 %74 %105 = OpPhi %8 %70 %66 %72 %65 %113 %74 OpBranch %44 %45 = OpLabel %95 = OpConvertSToF %21 %98 %96 = OpCompositeConstruct %22 %95 %95 %95 %95 OpStore %3 %96 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto context = BuildModule(env, nullptr, shader, kReduceAssembleOption); const auto ops = StructuredLoopToSelectionReductionOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(2, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); CheckValid(env, context.get()); std::string after_op_0 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpMemberDecorate %4 0 Offset 0 OpMemberDecorate %4 1 Offset 4 OpMemberDecorate %4 2 Offset 8 OpMemberDecorate %4 3 Offset 12 OpDecorate %4 Block OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 0 OpDecorate %3 Location 0 %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeBool %10 = OpTypeInt 32 1 %4 = OpTypeStruct %10 %10 %10 %10 %11 = OpTypePointer Uniform %4 %5 = OpVariable %11 Uniform %12 = OpConstant %10 0 %13 = OpTypePointer Uniform %10 %14 = OpTypeInt 32 0 %15 = OpConstant %14 0 %16 = OpConstant %10 1 %17 = OpConstant %10 2 %18 = OpConstant %10 3 %20 = OpConstantFalse %8 %21 = OpTypeFloat 32 %22 = OpTypeVector %21 4 %23 = OpTypePointer Output %22 %3 = OpVariable %23 Output %114 = OpUndef %10 %115 = OpUndef %8 %2 = OpFunction %6 None %7 %24 = OpLabel %31 = OpAccessChain %13 %5 %12 %32 = OpLoad %10 %31 %33 = OpINotEqual %8 %32 %15 %34 = OpAccessChain %13 %5 %16 %35 = OpLoad %10 %34 %36 = OpINotEqual %8 %35 %15 %37 = OpAccessChain %13 %5 %17 %38 = OpLoad %10 %37 %39 = OpINotEqual %8 %38 %15 %40 = OpAccessChain %13 %5 %18 %41 = OpLoad %10 %40 %42 = OpINotEqual %8 %41 %15 OpBranch %44 %44 = OpLabel %98 = OpPhi %10 %12 %24 %114 %46 %97 = OpPhi %8 %33 %24 %115 %46 OpSelectionMerge %45 None ; Was OpLoopMerge %45 %46 None OpBranchConditional %97 %49 %45 %49 = OpLabel OpSelectionMerge %51 None OpBranchConditional %33 %52 %51 %52 = OpLabel %55 = OpIAdd %10 %98 %16 OpBranch %51 %51 = OpLabel %100 = OpPhi %10 %98 %49 %55 %52 %113 = OpSelect %8 %33 %36 %97 OpSelectionMerge %57 None OpBranchConditional %36 %58 %57 %58 = OpLabel %60 = OpIAdd %10 %100 %16 %63 = OpLogicalOr %8 %113 %33 OpSelectionMerge %65 None OpBranchConditional %39 %66 %65 %66 = OpLabel %68 = OpIAdd %10 %100 %18 %70 = OpLogicalNot %8 %63 OpBranch %65 ; Was OpBranch %46 %65 = OpLabel %72 = OpLogicalOr %8 %63 %20 OpBranch %57 ; Was OpBranch %46 %57 = OpLabel OpBranch %73 %73 = OpLabel %99 = OpPhi %10 %100 %57 %109 %75 OpLoopMerge %74 %75 None OpBranch %76 %76 = OpLabel OpSelectionMerge %78 None OpBranchConditional %42 %79 %80 %79 = OpLabel OpSelectionMerge %82 None OpSwitch %99 %83 1 %84 2 %85 %83 = OpLabel OpBranch %82 %84 = OpLabel %87 = OpSelect %10 %113 %16 %17 %89 = OpIAdd %10 %99 %87 OpBranch %82 %85 = OpLabel OpBranch %75 %82 = OpLabel %110 = OpPhi %10 %99 %83 %89 %84 OpSelectionMerge %91 None OpBranchConditional %39 %92 %91 %92 = OpLabel OpBranch %75 %91 = OpLabel OpBranch %78 %80 = OpLabel OpBranch %74 %78 = OpLabel OpBranch %75 %75 = OpLabel %109 = OpPhi %10 %99 %85 %110 %92 %110 %78 OpBranchConditional %113 %73 %74 %74 = OpLabel %108 = OpPhi %10 %99 %80 %109 %75 OpBranch %45 ; Was OpBranch %46 %46 = OpLabel %107 = OpPhi %10 ; Was OpPhi %10 %68 %66 %60 %65 %108 %74 %105 = OpPhi %8 ; Was OpPhi %8 %70 %66 %72 %65 %113 %74 OpBranch %44 %45 = OpLabel %95 = OpConvertSToF %21 %98 %96 = OpCompositeConstruct %22 %95 %95 %95 %95 OpStore %3 %96 OpReturn OpFunctionEnd )"; CheckEqual(env, after_op_0, context.get()); ASSERT_TRUE(ops[1]->PreconditionHolds()); ops[1]->TryToApply(); CheckValid(env, context.get()); std::string after_op_1 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 OpMemberDecorate %4 0 Offset 0 OpMemberDecorate %4 1 Offset 4 OpMemberDecorate %4 2 Offset 8 OpMemberDecorate %4 3 Offset 12 OpDecorate %4 Block OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 0 OpDecorate %3 Location 0 %6 = OpTypeVoid %7 = OpTypeFunction %6 %8 = OpTypeBool %10 = OpTypeInt 32 1 %4 = OpTypeStruct %10 %10 %10 %10 %11 = OpTypePointer Uniform %4 %5 = OpVariable %11 Uniform %12 = OpConstant %10 0 %13 = OpTypePointer Uniform %10 %14 = OpTypeInt 32 0 %15 = OpConstant %14 0 %16 = OpConstant %10 1 %17 = OpConstant %10 2 %18 = OpConstant %10 3 %20 = OpConstantFalse %8 %21 = OpTypeFloat 32 %22 = OpTypeVector %21 4 %23 = OpTypePointer Output %22 %3 = OpVariable %23 Output %114 = OpUndef %10 %115 = OpUndef %8 %116 = OpConstantTrue %8 %2 = OpFunction %6 None %7 %24 = OpLabel %31 = OpAccessChain %13 %5 %12 %32 = OpLoad %10 %31 %33 = OpINotEqual %8 %32 %15 %34 = OpAccessChain %13 %5 %16 %35 = OpLoad %10 %34 %36 = OpINotEqual %8 %35 %15 %37 = OpAccessChain %13 %5 %17 %38 = OpLoad %10 %37 %39 = OpINotEqual %8 %38 %15 %40 = OpAccessChain %13 %5 %18 %41 = OpLoad %10 %40 %42 = OpINotEqual %8 %41 %15 OpBranch %44 %44 = OpLabel %98 = OpPhi %10 %12 %24 %114 %46 %97 = OpPhi %8 %33 %24 %115 %46 OpSelectionMerge %45 None ; Was OpLoopMerge %45 %46 None OpBranchConditional %97 %49 %45 %49 = OpLabel OpSelectionMerge %51 None OpBranchConditional %33 %52 %51 %52 = OpLabel %55 = OpIAdd %10 %98 %16 OpBranch %51 %51 = OpLabel %100 = OpPhi %10 %98 %49 %55 %52 %113 = OpSelect %8 %33 %36 %97 OpSelectionMerge %57 None OpBranchConditional %36 %58 %57 %58 = OpLabel %60 = OpIAdd %10 %100 %16 %63 = OpLogicalOr %8 %113 %33 OpSelectionMerge %65 None OpBranchConditional %39 %66 %65 %66 = OpLabel %68 = OpIAdd %10 %100 %18 %70 = OpLogicalNot %8 %63 OpBranch %65 ; Was OpBranch %46 %65 = OpLabel %72 = OpLogicalOr %8 %63 %20 OpBranch %57 ; Was OpBranch %46 %57 = OpLabel OpBranch %73 %73 = OpLabel %99 = OpPhi %10 %100 %57 %114 %75 OpSelectionMerge %74 None ; Was OpLoopMerge %74 %75 None OpBranchConditional %116 %76 %74 %76 = OpLabel OpSelectionMerge %78 None OpBranchConditional %42 %79 %80 %79 = OpLabel OpSelectionMerge %82 None OpSwitch %99 %83 1 %84 2 %85 %83 = OpLabel OpBranch %82 %84 = OpLabel %87 = OpSelect %10 %113 %16 %17 %89 = OpIAdd %10 %99 %87 OpBranch %82 %85 = OpLabel OpBranch %82 ; Was OpBranch %75 %82 = OpLabel %110 = OpPhi %10 %99 %83 %89 %84 %114 %85 ; Was OpPhi %10 %99 %83 %89 %84 OpSelectionMerge %91 None OpBranchConditional %39 %92 %91 %92 = OpLabel OpBranch %91 ; OpBranch %75 %91 = OpLabel OpBranch %78 %80 = OpLabel OpBranch %78 ; Was OpBranch %74 %78 = OpLabel OpBranch %74 ; Was OpBranch %75 %75 = OpLabel %109 = OpPhi %10 ; Was OpPhi %10 %99 %85 %110 %92 %110 %78 OpBranchConditional %115 %73 %74 %74 = OpLabel %108 = OpPhi %10 %114 %75 %114 %78 %114 %73 ; Was OpPhi %10 %99 %80 %109 %75 OpBranch %45 ; Was OpBranch %46 %46 = OpLabel %107 = OpPhi %10 ; Was OpPhi %10 %68 %66 %60 %65 %108 %74 %105 = OpPhi %8 ; Was OpPhi %8 %70 %66 %72 %65 %113 %74 OpBranch %44 %45 = OpLabel %95 = OpConvertSToF %21 %98 %96 = OpCompositeConstruct %22 %95 %95 %95 %95 OpStore %3 %96 OpReturn OpFunctionEnd )"; CheckEqual(env, after_op_1, context.get()); } TEST(StructuredLoopToSelectionReductionPassTest, DominanceIssue) { // Exposes a scenario where redirecting edges results in uses of ids being // non-dominated. We replace such uses with OpUndef to account for this. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %5 = OpTypeInt 32 1 %7 = OpTypePointer Function %5 %6 = OpTypeBool %8 = OpConstantTrue %6 %9 = OpConstant %5 10 %10 = OpConstant %5 20 %11 = OpConstant %5 30 %4 = OpFunction %2 None %3 %12 = OpLabel OpBranch %13 %13 = OpLabel OpLoopMerge %14 %15 None OpBranch %16 %16 = OpLabel OpSelectionMerge %17 None OpBranchConditional %8 %18 %19 %18 = OpLabel OpBranch %14 %19 = OpLabel %20 = OpIAdd %5 %9 %10 OpBranch %17 %17 = OpLabel %21 = OpIAdd %5 %20 %11 OpBranchConditional %8 %14 %15 %15 = OpLabel OpBranch %13 %14 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto context = BuildModule(env, nullptr, shader, kReduceAssembleOption); const auto ops = StructuredLoopToSelectionReductionOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(1, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); CheckValid(env, context.get()); std::string expected = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %5 = OpTypeInt 32 1 %7 = OpTypePointer Function %5 %6 = OpTypeBool %8 = OpConstantTrue %6 %9 = OpConstant %5 10 %10 = OpConstant %5 20 %11 = OpConstant %5 30 %22 = OpUndef %5 %4 = OpFunction %2 None %3 %12 = OpLabel OpBranch %13 %13 = OpLabel OpSelectionMerge %14 None OpBranchConditional %8 %16 %14 %16 = OpLabel OpSelectionMerge %17 None OpBranchConditional %8 %18 %19 %18 = OpLabel OpBranch %17 %19 = OpLabel %20 = OpIAdd %5 %9 %10 OpBranch %17 %17 = OpLabel %21 = OpIAdd %5 %22 %11 OpBranchConditional %8 %14 %14 %15 = OpLabel OpBranch %13 %14 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, expected, context.get()); } TEST(StructuredLoopToSelectionReductionPassTest, AccessChainIssue) { // Exposes a scenario where redirecting edges results in a use of an id // generated by an access chain being non-dominated. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %56 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpMemberDecorate %28 0 Offset 0 OpDecorate %28 Block OpDecorate %30 DescriptorSet 0 OpDecorate %30 Binding 0 OpDecorate %56 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 2 %8 = OpTypePointer Function %7 %60 = OpTypePointer Private %7 %10 = OpConstant %6 0 %11 = OpConstantComposite %7 %10 %10 %12 = OpTypePointer Function %6 %59 = OpTypePointer Private %6 %14 = OpTypeInt 32 1 %15 = OpTypePointer Function %14 %17 = OpConstant %14 0 %24 = OpConstant %14 100 %25 = OpTypeBool %28 = OpTypeStruct %6 %29 = OpTypePointer Uniform %28 %30 = OpVariable %29 Uniform %31 = OpTypePointer Uniform %6 %39 = OpTypeInt 32 0 %40 = OpConstant %39 1 %45 = OpConstant %39 0 %52 = OpConstant %14 1 %54 = OpTypeVector %6 4 %55 = OpTypePointer Output %54 %56 = OpVariable %55 Output %9 = OpVariable %60 Private %4 = OpFunction %2 None %3 %5 = OpLabel %13 = OpVariable %12 Function %16 = OpVariable %15 Function %38 = OpVariable %12 Function OpStore %9 %11 OpStore %13 %10 OpStore %16 %17 OpBranch %18 %18 = OpLabel OpLoopMerge %20 %21 None OpBranch %22 %22 = OpLabel %23 = OpLoad %14 %16 %26 = OpSLessThan %25 %23 %24 OpBranchConditional %26 %19 %20 %19 = OpLabel %27 = OpLoad %14 %16 %32 = OpAccessChain %31 %30 %17 %33 = OpLoad %6 %32 %34 = OpConvertFToS %14 %33 %35 = OpSLessThan %25 %27 %34 OpSelectionMerge %37 None OpBranchConditional %35 %36 %44 %36 = OpLabel %41 = OpAccessChain %59 %9 %40 %42 = OpLoad %6 %41 OpStore %38 %42 OpBranch %20 %44 = OpLabel %46 = OpAccessChain %59 %9 %45 OpBranch %37 %37 = OpLabel %47 = OpLoad %6 %46 OpStore %38 %47 %48 = OpLoad %6 %38 %49 = OpLoad %6 %13 %50 = OpFAdd %6 %49 %48 OpStore %13 %50 OpBranch %21 %21 = OpLabel %51 = OpLoad %14 %16 %53 = OpIAdd %14 %51 %52 OpStore %16 %53 OpBranch %18 %20 = OpLabel %57 = OpLoad %6 %13 %58 = OpCompositeConstruct %54 %57 %57 %57 %57 OpStore %56 %58 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto context = BuildModule(env, nullptr, shader, kReduceAssembleOption); const auto ops = StructuredLoopToSelectionReductionOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(1, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); CheckValid(env, context.get()); std::string expected = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %56 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpMemberDecorate %28 0 Offset 0 OpDecorate %28 Block OpDecorate %30 DescriptorSet 0 OpDecorate %30 Binding 0 OpDecorate %56 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 2 %8 = OpTypePointer Function %7 %60 = OpTypePointer Private %7 %10 = OpConstant %6 0 %11 = OpConstantComposite %7 %10 %10 %12 = OpTypePointer Function %6 %59 = OpTypePointer Private %6 %14 = OpTypeInt 32 1 %15 = OpTypePointer Function %14 %17 = OpConstant %14 0 %24 = OpConstant %14 100 %25 = OpTypeBool %28 = OpTypeStruct %6 %29 = OpTypePointer Uniform %28 %30 = OpVariable %29 Uniform %31 = OpTypePointer Uniform %6 %39 = OpTypeInt 32 0 %40 = OpConstant %39 1 %45 = OpConstant %39 0 %52 = OpConstant %14 1 %54 = OpTypeVector %6 4 %55 = OpTypePointer Output %54 %56 = OpVariable %55 Output %9 = OpVariable %60 Private %61 = OpConstantTrue %25 %62 = OpVariable %59 Private %4 = OpFunction %2 None %3 %5 = OpLabel %13 = OpVariable %12 Function %16 = OpVariable %15 Function %38 = OpVariable %12 Function OpStore %9 %11 OpStore %13 %10 OpStore %16 %17 OpBranch %18 %18 = OpLabel OpSelectionMerge %20 None OpBranchConditional %61 %22 %20 %22 = OpLabel %23 = OpLoad %14 %16 %26 = OpSLessThan %25 %23 %24 OpBranchConditional %26 %19 %20 %19 = OpLabel %27 = OpLoad %14 %16 %32 = OpAccessChain %31 %30 %17 %33 = OpLoad %6 %32 %34 = OpConvertFToS %14 %33 %35 = OpSLessThan %25 %27 %34 OpSelectionMerge %37 None OpBranchConditional %35 %36 %44 %36 = OpLabel %41 = OpAccessChain %59 %9 %40 %42 = OpLoad %6 %41 OpStore %38 %42 OpBranch %37 %44 = OpLabel %46 = OpAccessChain %59 %9 %45 OpBranch %37 %37 = OpLabel %47 = OpLoad %6 %62 OpStore %38 %47 %48 = OpLoad %6 %38 %49 = OpLoad %6 %13 %50 = OpFAdd %6 %49 %48 OpStore %13 %50 OpBranch %20 %21 = OpLabel %51 = OpLoad %14 %16 %53 = OpIAdd %14 %51 %52 OpStore %16 %53 OpBranch %18 %20 = OpLabel %57 = OpLoad %6 %13 %58 = OpCompositeConstruct %54 %57 %57 %57 %57 OpStore %56 %58 OpReturn OpFunctionEnd )"; CheckEqual(env, expected, context.get()); } TEST(StructuredLoopToSelectionReductionPassTest, DominanceAndPhiIssue) { // Exposes an interesting scenario where a use in a phi stops being dominated // by the block with which it is associated in the phi. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %17 = OpTypeBool %18 = OpConstantTrue %17 %19 = OpConstantFalse %17 %20 = OpTypeInt 32 1 %21 = OpConstant %20 5 %22 = OpConstant %20 6 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %6 %6 = OpLabel OpLoopMerge %16 %15 None OpBranch %7 %7 = OpLabel OpSelectionMerge %13 None OpBranchConditional %18 %8 %9 %8 = OpLabel OpSelectionMerge %12 None OpBranchConditional %18 %10 %11 %9 = OpLabel OpBranch %16 %10 = OpLabel OpBranch %16 %11 = OpLabel %23 = OpIAdd %20 %21 %22 OpBranch %12 %12 = OpLabel OpBranch %13 %13 = OpLabel OpBranch %14 %14 = OpLabel %24 = OpPhi %20 %23 %13 OpBranchConditional %19 %15 %16 %15 = OpLabel OpBranch %6 %16 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto context = BuildModule(env, nullptr, shader, kReduceAssembleOption); const auto ops = StructuredLoopToSelectionReductionOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(1, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); CheckValid(env, context.get()); std::string expected = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %17 = OpTypeBool %18 = OpConstantTrue %17 %19 = OpConstantFalse %17 %20 = OpTypeInt 32 1 %21 = OpConstant %20 5 %22 = OpConstant %20 6 %25 = OpUndef %20 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %6 %6 = OpLabel OpSelectionMerge %16 None OpBranchConditional %18 %7 %16 %7 = OpLabel OpSelectionMerge %13 None OpBranchConditional %18 %8 %9 %8 = OpLabel OpSelectionMerge %12 None OpBranchConditional %18 %10 %11 %9 = OpLabel OpBranch %13 %10 = OpLabel OpBranch %12 %11 = OpLabel %23 = OpIAdd %20 %21 %22 OpBranch %12 %12 = OpLabel OpBranch %13 %13 = OpLabel OpBranch %14 %14 = OpLabel %24 = OpPhi %20 %25 %13 OpBranchConditional %19 %16 %16 %15 = OpLabel OpBranch %6 %16 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, expected, context.get()); } TEST(StructuredLoopToSelectionReductionPassTest, OpLineBeforeOpPhi) { // Test to ensure the pass knows OpLine and OpPhi instructions can be // interleaved. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpString "somefile" %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeInt 32 1 %7 = OpConstant %6 10 %8 = OpConstant %6 20 %9 = OpConstant %6 30 %10 = OpTypeBool %11 = OpConstantTrue %10 %2 = OpFunction %4 None %5 %12 = OpLabel OpBranch %13 %13 = OpLabel OpLoopMerge %14 %15 None OpBranch %16 %16 = OpLabel OpSelectionMerge %17 None OpBranchConditional %11 %18 %19 %18 = OpLabel %20 = OpIAdd %6 %7 %8 %21 = OpIAdd %6 %7 %9 OpBranch %17 %19 = OpLabel OpBranch %14 %17 = OpLabel %22 = OpPhi %6 %20 %18 OpLine %3 0 0 %23 = OpPhi %6 %21 %18 OpBranch %15 %15 = OpLabel OpBranch %13 %14 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto context = BuildModule(env, nullptr, shader, kReduceAssembleOption); const auto ops = StructuredLoopToSelectionReductionOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(1, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); CheckValid(env, context.get()); std::string expected = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpString "somefile" %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpTypeInt 32 1 %7 = OpConstant %6 10 %8 = OpConstant %6 20 %9 = OpConstant %6 30 %10 = OpTypeBool %11 = OpConstantTrue %10 %24 = OpUndef %6 %2 = OpFunction %4 None %5 %12 = OpLabel OpBranch %13 %13 = OpLabel OpSelectionMerge %14 None OpBranchConditional %11 %16 %14 %16 = OpLabel OpSelectionMerge %17 None OpBranchConditional %11 %18 %19 %18 = OpLabel %20 = OpIAdd %6 %7 %8 %21 = OpIAdd %6 %7 %9 OpBranch %17 %19 = OpLabel OpBranch %17 %17 = OpLabel %22 = OpPhi %6 %20 %18 %24 %19 OpLine %3 0 0 %23 = OpPhi %6 %21 %18 %24 %19 OpBranch %14 %15 = OpLabel OpBranch %13 %14 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, expected, context.get()); } TEST(StructuredLoopToSelectionReductionPassTest, SelectionMergeIsContinueTarget) { // Example where a loop's continue target is also the target of a selection. // In this scenario we cautiously do not apply the transformation. std::string shader = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "main" %2 = OpTypeVoid %3 = OpTypeBool %4 = OpTypeFunction %2 %1 = OpFunction %2 None %4 %5 = OpLabel %6 = OpUndef %3 OpBranch %7 %7 = OpLabel %8 = OpPhi %3 %6 %5 %9 %10 OpLoopMerge %11 %10 None OpBranch %12 %12 = OpLabel %13 = OpUndef %3 OpSelectionMerge %10 None OpBranchConditional %13 %14 %10 %14 = OpLabel OpBranch %10 %10 = OpLabel %9 = OpUndef %3 OpBranchConditional %9 %7 %11 %11 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto context = BuildModule(env, nullptr, shader, kReduceAssembleOption); const auto ops = StructuredLoopToSelectionReductionOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); // There should be no opportunities. ASSERT_EQ(0, ops.size()); } TEST(StructuredLoopToSelectionReductionPassTest, SwitchSelectionMergeIsContinueTarget) { // Another example where a loop's continue target is also the target of a // selection; this time a selection associated with an OpSwitch. We // cautiously do not apply the transformation. std::string shader = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "main" %2 = OpTypeVoid %3 = OpTypeBool %5 = OpTypeInt 32 1 %4 = OpTypeFunction %2 %6 = OpConstant %5 2 %7 = OpConstantTrue %3 %1 = OpFunction %2 None %4 %8 = OpLabel OpBranch %9 %9 = OpLabel OpLoopMerge %14 %15 None OpBranchConditional %7 %10 %14 %10 = OpLabel OpSelectionMerge %15 None OpSwitch %6 %12 1 %11 2 %11 3 %15 %11 = OpLabel OpBranch %12 %12 = OpLabel OpBranch %15 %15 = OpLabel OpBranch %9 %14 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto context = BuildModule(env, nullptr, shader, kReduceAssembleOption); const auto ops = StructuredLoopToSelectionReductionOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); // There should be no opportunities. ASSERT_EQ(0, ops.size()); } TEST(StructuredLoopToSelectionReductionPassTest, ContinueTargetIsSwitchTarget) { std::string shader = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "main" %2 = OpTypeVoid %3 = OpTypeBool %5 = OpTypeInt 32 1 %4 = OpTypeFunction %2 %6 = OpConstant %5 2 %7 = OpConstantTrue %3 %1 = OpFunction %2 None %4 %8 = OpLabel OpBranch %9 %9 = OpLabel OpLoopMerge %14 %12 None OpBranchConditional %7 %10 %14 %10 = OpLabel OpSelectionMerge %15 None OpSwitch %6 %12 1 %11 2 %11 3 %15 %11 = OpLabel OpBranch %12 %12 = OpLabel OpBranch %9 %15 = OpLabel OpBranch %14 %14 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto context = BuildModule(env, nullptr, shader, kReduceAssembleOption); const auto ops = StructuredLoopToSelectionReductionOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(1, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); CheckValid(env, context.get()); std::string expected = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "main" %2 = OpTypeVoid %3 = OpTypeBool %5 = OpTypeInt 32 1 %4 = OpTypeFunction %2 %6 = OpConstant %5 2 %7 = OpConstantTrue %3 %1 = OpFunction %2 None %4 %8 = OpLabel OpBranch %9 %9 = OpLabel OpSelectionMerge %14 None OpBranchConditional %7 %10 %14 %10 = OpLabel OpSelectionMerge %15 None OpSwitch %6 %15 1 %11 2 %11 3 %15 %11 = OpLabel OpBranch %15 %12 = OpLabel OpBranch %9 %15 = OpLabel OpBranch %14 %14 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, expected, context.get()); } TEST(StructuredLoopToSelectionReductionPassTest, MultipleSwitchTargetsAreContinueTarget) { std::string shader = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "main" %2 = OpTypeVoid %3 = OpTypeBool %5 = OpTypeInt 32 1 %4 = OpTypeFunction %2 %6 = OpConstant %5 2 %7 = OpConstantTrue %3 %1 = OpFunction %2 None %4 %8 = OpLabel OpBranch %9 %9 = OpLabel OpLoopMerge %14 %12 None OpBranchConditional %7 %10 %14 %10 = OpLabel OpSelectionMerge %15 None OpSwitch %6 %11 1 %12 2 %12 3 %15 %11 = OpLabel OpBranch %12 %12 = OpLabel OpBranch %9 %15 = OpLabel OpBranch %14 %14 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto context = BuildModule(env, nullptr, shader, kReduceAssembleOption); const auto ops = StructuredLoopToSelectionReductionOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(1, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); CheckValid(env, context.get()); std::string expected = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "main" %2 = OpTypeVoid %3 = OpTypeBool %5 = OpTypeInt 32 1 %4 = OpTypeFunction %2 %6 = OpConstant %5 2 %7 = OpConstantTrue %3 %1 = OpFunction %2 None %4 %8 = OpLabel OpBranch %9 %9 = OpLabel OpSelectionMerge %14 None OpBranchConditional %7 %10 %14 %10 = OpLabel OpSelectionMerge %15 None OpSwitch %6 %11 1 %15 2 %15 3 %15 %11 = OpLabel OpBranch %15 %12 = OpLabel OpBranch %9 %15 = OpLabel OpBranch %14 %14 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, expected, context.get()); } TEST(StructuredLoopToSelectionReductionPassTest, LoopBranchesStraightToMerge) { std::string shader = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "main" %2 = OpTypeVoid %4 = OpTypeFunction %2 %1 = OpFunction %2 None %4 %8 = OpLabel OpBranch %9 %9 = OpLabel OpLoopMerge %14 %12 None OpBranch %14 %12 = OpLabel OpBranch %9 %14 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto context = BuildModule(env, nullptr, shader, kReduceAssembleOption); const auto ops = StructuredLoopToSelectionReductionOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(1, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); CheckValid(env, context.get()); std::string expected = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "main" %2 = OpTypeVoid %4 = OpTypeFunction %2 %15 = OpTypeBool %16 = OpConstantTrue %15 %1 = OpFunction %2 None %4 %8 = OpLabel OpBranch %9 %9 = OpLabel OpSelectionMerge %14 None OpBranchConditional %16 %14 %14 %12 = OpLabel OpBranch %9 %14 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, expected, context.get()); } TEST(StructuredLoopToSelectionReductionPassTest, LoopConditionallyJumpsToMergeOrContinue) { std::string shader = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "main" %2 = OpTypeVoid %3 = OpTypeBool %4 = OpTypeFunction %2 %7 = OpConstantTrue %3 %1 = OpFunction %2 None %4 %8 = OpLabel OpBranch %9 %9 = OpLabel OpLoopMerge %14 %12 None OpBranchConditional %7 %14 %12 %12 = OpLabel OpBranch %9 %14 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto context = BuildModule(env, nullptr, shader, kReduceAssembleOption); const auto ops = StructuredLoopToSelectionReductionOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(1, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); CheckValid(env, context.get()); std::string expected = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "main" %2 = OpTypeVoid %3 = OpTypeBool %4 = OpTypeFunction %2 %7 = OpConstantTrue %3 %1 = OpFunction %2 None %4 %8 = OpLabel OpBranch %9 %9 = OpLabel OpSelectionMerge %14 None OpBranchConditional %7 %14 %14 %12 = OpLabel OpBranch %9 %14 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, expected, context.get()); } TEST(StructuredLoopToSelectionReductionPassTest, MultipleAccessChains) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeStruct %6 %8 = OpTypeStruct %7 %9 = OpTypePointer Function %8 %11 = OpConstant %6 3 %12 = OpConstantComposite %7 %11 %13 = OpConstantComposite %8 %12 %14 = OpTypePointer Function %7 %16 = OpConstant %6 0 %19 = OpTypePointer Function %6 %15 = OpTypeBool %18 = OpConstantTrue %15 %4 = OpFunction %2 None %3 %5 = OpLabel %10 = OpVariable %9 Function %20 = OpVariable %19 Function OpStore %10 %13 OpBranch %23 %23 = OpLabel OpLoopMerge %25 %26 None OpBranch %27 %27 = OpLabel OpSelectionMerge %28 None OpBranchConditional %18 %29 %25 %29 = OpLabel %17 = OpAccessChain %14 %10 %16 OpBranch %28 %28 = OpLabel %21 = OpAccessChain %19 %17 %16 %22 = OpLoad %6 %21 %24 = OpAccessChain %19 %10 %16 %16 OpStore %24 %22 OpBranch %25 %26 = OpLabel OpBranch %23 %25 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto context = BuildModule(env, nullptr, shader, kReduceAssembleOption); const auto ops = StructuredLoopToSelectionReductionOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(1, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); CheckValid(env, context.get()); std::string expected = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeStruct %6 %8 = OpTypeStruct %7 %9 = OpTypePointer Function %8 %11 = OpConstant %6 3 %12 = OpConstantComposite %7 %11 %13 = OpConstantComposite %8 %12 %14 = OpTypePointer Function %7 %16 = OpConstant %6 0 %19 = OpTypePointer Function %6 %15 = OpTypeBool %18 = OpConstantTrue %15 %4 = OpFunction %2 None %3 %5 = OpLabel %10 = OpVariable %9 Function %20 = OpVariable %19 Function %30 = OpVariable %14 Function OpStore %10 %13 OpBranch %23 %23 = OpLabel OpSelectionMerge %25 None OpBranchConditional %18 %27 %25 %27 = OpLabel OpSelectionMerge %28 None OpBranchConditional %18 %29 %28 %29 = OpLabel %17 = OpAccessChain %14 %10 %16 OpBranch %28 %28 = OpLabel %21 = OpAccessChain %19 %30 %16 %22 = OpLoad %6 %21 %24 = OpAccessChain %19 %10 %16 %16 OpStore %24 %22 OpBranch %25 %26 = OpLabel OpBranch %23 %25 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, expected, context.get()); } TEST(StructuredLoopToSelectionReductionPassTest, UnreachableInnerLoopContinueBranchingToOuterLoopMerge) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %2 = OpFunction %3 None %4 %7 = OpLabel OpBranch %8 %8 = OpLabel OpLoopMerge %9 %10 None OpBranch %11 %11 = OpLabel OpLoopMerge %12 %13 None OpBranch %12 %13 = OpLabel OpBranch %11 %12 = OpLabel OpBranch %10 %10 = OpLabel OpBranchConditional %6 %9 %8 %9 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto context = BuildModule(env, nullptr, shader, kReduceAssembleOption); const auto ops = StructuredLoopToSelectionReductionOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(2, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); CheckValid(env, context.get()); std::string after_op_0 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %2 = OpFunction %3 None %4 %7 = OpLabel OpBranch %8 %8 = OpLabel OpSelectionMerge %9 None OpBranchConditional %6 %11 %9 %11 = OpLabel OpLoopMerge %12 %13 None OpBranch %12 %13 = OpLabel OpBranch %11 %12 = OpLabel OpBranch %9 %10 = OpLabel OpBranchConditional %6 %9 %8 %9 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, after_op_0, context.get()); ASSERT_TRUE(ops[1]->PreconditionHolds()); ops[1]->TryToApply(); CheckValid(env, context.get()); std::string after_op_1 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %2 = OpFunction %3 None %4 %7 = OpLabel OpBranch %8 %8 = OpLabel OpSelectionMerge %9 None OpBranchConditional %6 %11 %9 %11 = OpLabel OpSelectionMerge %12 None OpBranchConditional %6 %12 %12 %13 = OpLabel OpBranch %11 %12 = OpLabel OpBranch %9 %10 = OpLabel OpBranchConditional %6 %9 %8 %9 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, after_op_1, context.get()); } TEST(StructuredLoopToSelectionReductionPassTest, UnreachableInnerLoopContinueBranchingToOuterLoopMerge2) { // In this test, the unreachable continue is composed of multiple blocks. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %2 = OpFunction %3 None %4 %7 = OpLabel OpBranch %8 %8 = OpLabel OpLoopMerge %9 %10 None OpBranch %11 %11 = OpLabel OpLoopMerge %12 %13 None OpBranch %12 %13 = OpLabel OpBranch %14 %14 = OpLabel OpBranch %11 %12 = OpLabel OpBranch %10 %10 = OpLabel OpBranchConditional %6 %9 %8 %9 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto context = BuildModule(env, nullptr, shader, kReduceAssembleOption); const auto ops = StructuredLoopToSelectionReductionOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(2, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); CheckValid(env, context.get()); std::string after_op_0 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %2 = OpFunction %3 None %4 %7 = OpLabel OpBranch %8 %8 = OpLabel OpSelectionMerge %9 None OpBranchConditional %6 %11 %9 %11 = OpLabel OpLoopMerge %12 %13 None OpBranch %12 %13 = OpLabel OpBranch %14 %14 = OpLabel OpBranch %11 %12 = OpLabel OpBranch %9 %10 = OpLabel OpBranchConditional %6 %9 %8 %9 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, after_op_0, context.get()); ASSERT_TRUE(ops[1]->PreconditionHolds()); ops[1]->TryToApply(); CheckValid(env, context.get()); std::string after_op_1 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %2 = OpFunction %3 None %4 %7 = OpLabel OpBranch %8 %8 = OpLabel OpSelectionMerge %9 None OpBranchConditional %6 %11 %9 %11 = OpLabel OpSelectionMerge %12 None OpBranchConditional %6 %12 %12 %13 = OpLabel OpBranch %14 %14 = OpLabel OpBranch %11 %12 = OpLabel OpBranch %9 %10 = OpLabel OpBranchConditional %6 %9 %8 %9 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, after_op_1, context.get()); } TEST(StructuredLoopToSelectionReductionPassTest, InnerLoopHeaderBranchesToOuterLoopMerge) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %2 = OpFunction %3 None %4 %7 = OpLabel OpBranch %8 %8 = OpLabel OpLoopMerge %9 %10 None OpBranch %11 %11 = OpLabel OpLoopMerge %12 %13 None OpBranchConditional %6 %9 %13 %13 = OpLabel OpBranchConditional %6 %11 %12 %12 = OpLabel OpBranch %10 %10 = OpLabel OpBranchConditional %6 %9 %8 %9 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto context = BuildModule(env, nullptr, shader, kReduceAssembleOption); auto ops = StructuredLoopToSelectionReductionOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); // We cannot transform the inner loop due to its header jumping straight to // the outer loop merge (the inner loop's merge does not post-dominate its // header). ASSERT_EQ(1, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); CheckValid(env, context.get()); std::string after_op_0 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %2 = OpFunction %3 None %4 %7 = OpLabel OpBranch %8 %8 = OpLabel OpSelectionMerge %9 None OpBranchConditional %6 %11 %9 %11 = OpLabel OpLoopMerge %12 %13 None OpBranchConditional %6 %12 %13 %13 = OpLabel OpBranchConditional %6 %11 %12 %12 = OpLabel OpBranch %9 %10 = OpLabel OpBranchConditional %6 %9 %8 %9 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, after_op_0, context.get()); // Now look again for more opportunities. ops = StructuredLoopToSelectionReductionOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); // What was the inner loop should now be transformable, as the jump to the // outer loop's merge has been redirected. ASSERT_EQ(1, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); CheckValid(env, context.get()); std::string after_another_op_0 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %2 = OpFunction %3 None %4 %7 = OpLabel OpBranch %8 %8 = OpLabel OpSelectionMerge %9 None OpBranchConditional %6 %11 %9 %11 = OpLabel OpSelectionMerge %12 None OpBranchConditional %6 %12 %12 %13 = OpLabel OpBranchConditional %6 %11 %12 %12 = OpLabel OpBranch %9 %10 = OpLabel OpBranchConditional %6 %9 %8 %9 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, after_another_op_0, context.get()); } TEST(StructuredLoopToSelectionReductionPassTest, LongAccessChains) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft OpSource ESSL 310 %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeInt 32 1 %6 = OpTypeInt 32 0 %7 = OpConstant %6 5 %8 = OpTypeArray %5 %7 %9 = OpTypeStruct %8 %10 = OpTypeStruct %9 %9 %11 = OpConstant %6 2 %12 = OpTypeArray %10 %11 %13 = OpTypeStruct %12 %14 = OpTypePointer Function %13 %15 = OpConstant %5 0 %16 = OpConstant %5 1 %17 = OpConstant %5 2 %18 = OpConstant %5 3 %19 = OpConstant %5 4 %20 = OpConstantComposite %8 %15 %16 %17 %18 %19 %21 = OpConstantComposite %9 %20 %22 = OpConstant %5 5 %23 = OpConstant %5 6 %24 = OpConstant %5 7 %25 = OpConstant %5 8 %26 = OpConstant %5 9 %27 = OpConstantComposite %8 %22 %23 %24 %25 %26 %28 = OpConstantComposite %9 %27 %29 = OpConstantComposite %10 %21 %28 %30 = OpConstant %5 10 %31 = OpConstant %5 11 %32 = OpConstant %5 12 %33 = OpConstant %5 13 %34 = OpConstant %5 14 %35 = OpConstantComposite %8 %30 %31 %32 %33 %34 %36 = OpConstantComposite %9 %35 %37 = OpConstant %5 15 %38 = OpConstant %5 16 %39 = OpConstant %5 17 %40 = OpConstant %5 18 %41 = OpConstant %5 19 %42 = OpConstantComposite %8 %37 %38 %39 %40 %41 %43 = OpConstantComposite %9 %42 %44 = OpConstantComposite %10 %36 %43 %45 = OpConstantComposite %12 %29 %44 %46 = OpConstantComposite %13 %45 %47 = OpTypePointer Function %12 %48 = OpTypePointer Function %10 %49 = OpTypePointer Function %9 %50 = OpTypePointer Function %8 %51 = OpTypePointer Function %5 %52 = OpTypeBool %53 = OpConstantTrue %52 %2 = OpFunction %3 None %4 %54 = OpLabel %55 = OpVariable %14 Function OpStore %55 %46 OpBranch %56 %56 = OpLabel OpLoopMerge %57 %58 None OpBranchConditional %53 %57 %59 %59 = OpLabel OpSelectionMerge %60 None OpBranchConditional %53 %61 %57 %61 = OpLabel %62 = OpAccessChain %47 %55 %15 OpBranch %63 %63 = OpLabel OpSelectionMerge %64 None OpBranchConditional %53 %65 %57 %65 = OpLabel %66 = OpAccessChain %48 %62 %16 OpBranch %67 %67 = OpLabel OpSelectionMerge %68 None OpBranchConditional %53 %69 %57 %69 = OpLabel %70 = OpAccessChain %49 %66 %16 OpBranch %71 %71 = OpLabel OpSelectionMerge %72 None OpBranchConditional %53 %73 %57 %73 = OpLabel %74 = OpAccessChain %50 %70 %15 OpBranch %75 %75 = OpLabel OpSelectionMerge %76 None OpBranchConditional %53 %77 %57 %77 = OpLabel %78 = OpAccessChain %51 %74 %17 OpBranch %79 %79 = OpLabel OpSelectionMerge %80 None OpBranchConditional %53 %81 %57 %81 = OpLabel %82 = OpLoad %5 %78 OpBranch %80 %80 = OpLabel OpBranch %76 %76 = OpLabel OpBranch %72 %72 = OpLabel OpBranch %68 %68 = OpLabel OpBranch %64 %64 = OpLabel OpBranch %60 %60 = OpLabel OpBranch %58 %58 = OpLabel OpBranch %56 %57 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto context = BuildModule(env, nullptr, shader, kReduceAssembleOption); auto ops = StructuredLoopToSelectionReductionOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(1, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); CheckValid(env, context.get()); // TODO(2183): When we have a more general solution for handling access // chains, write an expected result for this test. // std::string expected = R"( // Expected text for transformed shader //)"; // CheckEqual(env, expected, context.get()); } TEST(StructuredLoopToSelectionReductionPassTest, LoopyShaderWithOpDecorate) { // A shader containing a function that contains a loop and some definitions // that are "used" in OpDecorate instructions (outside the function). These // "uses" were causing segfaults because we try to calculate their dominance // information, which doesn't make sense. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %9 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %9 "_GLF_color" OpName %14 "buf0" OpMemberName %14 0 "a" OpName %16 "" OpDecorate %9 RelaxedPrecision OpDecorate %9 Location 0 OpMemberDecorate %14 0 RelaxedPrecision OpMemberDecorate %14 0 Offset 0 OpDecorate %14 Block OpDecorate %16 DescriptorSet 0 OpDecorate %16 Binding 0 OpDecorate %21 RelaxedPrecision OpDecorate %35 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %40 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypePointer Output %7 %9 = OpVariable %8 Output %10 = OpConstant %6 1 %11 = OpConstantComposite %7 %10 %10 %10 %10 %14 = OpTypeStruct %6 %15 = OpTypePointer Uniform %14 %16 = OpVariable %15 Uniform %17 = OpTypeInt 32 1 %18 = OpConstant %17 0 %19 = OpTypePointer Uniform %6 %28 = OpConstant %6 2 %29 = OpTypeBool %31 = OpTypeInt 32 0 %32 = OpConstant %31 0 %33 = OpTypePointer Output %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpStore %9 %11 %20 = OpAccessChain %19 %16 %18 %21 = OpLoad %6 %20 OpBranch %22 %22 = OpLabel %40 = OpPhi %6 %21 %5 %39 %23 %30 = OpFOrdLessThan %29 %40 %28 OpLoopMerge %24 %23 None OpBranchConditional %30 %23 %24 %23 = OpLabel %34 = OpAccessChain %33 %9 %32 %35 = OpLoad %6 %34 %36 = OpFAdd %6 %35 %10 OpStore %34 %36 %39 = OpFAdd %6 %40 %10 OpBranch %22 %24 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto context = BuildModule(env, nullptr, shader, kReduceAssembleOption); const auto ops = StructuredLoopToSelectionReductionOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(1, ops.size()); ASSERT_TRUE(ops[0]->PreconditionHolds()); ops[0]->TryToApply(); CheckValid(env, context.get()); std::string after_op_0 = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %9 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %9 "_GLF_color" OpName %14 "buf0" OpMemberName %14 0 "a" OpName %16 "" OpDecorate %9 RelaxedPrecision OpDecorate %9 Location 0 OpMemberDecorate %14 0 RelaxedPrecision OpMemberDecorate %14 0 Offset 0 OpDecorate %14 Block OpDecorate %16 DescriptorSet 0 OpDecorate %16 Binding 0 OpDecorate %21 RelaxedPrecision OpDecorate %35 RelaxedPrecision OpDecorate %36 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %40 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypePointer Output %7 %9 = OpVariable %8 Output %10 = OpConstant %6 1 %11 = OpConstantComposite %7 %10 %10 %10 %10 %14 = OpTypeStruct %6 %15 = OpTypePointer Uniform %14 %16 = OpVariable %15 Uniform %17 = OpTypeInt 32 1 %18 = OpConstant %17 0 %19 = OpTypePointer Uniform %6 %28 = OpConstant %6 2 %29 = OpTypeBool %31 = OpTypeInt 32 0 %32 = OpConstant %31 0 %33 = OpTypePointer Output %6 %41 = OpUndef %6 ; Added %4 = OpFunction %2 None %3 %5 = OpLabel OpStore %9 %11 %20 = OpAccessChain %19 %16 %18 %21 = OpLoad %6 %20 OpBranch %22 %22 = OpLabel %40 = OpPhi %6 %21 %5 %41 %23 ; Changed %30 = OpFOrdLessThan %29 %40 %28 OpSelectionMerge %24 None ; Changed OpBranchConditional %30 %24 %24 %23 = OpLabel %34 = OpAccessChain %33 %9 %32 %35 = OpLoad %6 %34 %36 = OpFAdd %6 %35 %10 OpStore %34 %36 %39 = OpFAdd %6 %41 %10 ; Changed OpBranch %22 %24 = OpLabel OpReturn OpFunctionEnd )"; CheckEqual(env, after_op_0, context.get()); } TEST(StructuredLoopToSelectionReductionPassTest, LoopWithCombinedHeaderAndContinue) { // A shader containing a loop where the header is also the continue target. // For now, we don't simplify such loops. std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %30 = OpConstantFalse %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %10 %10 = OpLabel ; loop header and continue target OpLoopMerge %12 %10 None OpBranchConditional %30 %10 %12 %12 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto context = BuildModule(env, nullptr, shader, kReduceAssembleOption); const auto ops = StructuredLoopToSelectionReductionOpportunityFinder() .GetAvailableOpportunities(context.get(), 0); ASSERT_EQ(0, ops.size()); } } // namespace } // namespace reduce } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/reduce/validation_during_reduction_test.cpp000066400000000000000000000517441475742701700303130ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/reduce/reducer.h" #include "source/reduce/reduction_opportunity.h" #include "source/reduce/remove_instruction_reduction_opportunity.h" #include "test/reduce/reduce_test_util.h" namespace spvtools { namespace reduce { namespace { using opt::Function; using opt::IRContext; using opt::Instruction; // A reduction opportunity finder that finds opportunities to remove global // values regardless of whether they are referenced. This is very likely to make // the resulting module invalid. We use this to test the reducer's behavior in // the scenario where a bad reduction pass leads to an invalid module. class BlindlyRemoveGlobalValuesReductionOpportunityFinder : public ReductionOpportunityFinder { public: BlindlyRemoveGlobalValuesReductionOpportunityFinder() = default; ~BlindlyRemoveGlobalValuesReductionOpportunityFinder() override = default; // The name of this pass. std::string GetName() const final { return "BlindlyRemoveGlobalValuesPass"; } // Finds opportunities to remove all global values. Assuming they are all // referenced (directly or indirectly) from elsewhere in the module, each such // opportunity will make the module invalid. std::vector> GetAvailableOpportunities( IRContext* context, uint32_t /*unused*/) const final { std::vector> result; for (auto& inst : context->module()->types_values()) { if (inst.HasResultId()) { result.push_back( MakeUnique(&inst)); } } return result; } }; // A reduction opportunity that exists at the start of every function whose // first instruction is an OpVariable instruction. When applied, the OpVariable // instruction is duplicated (with a fresh result id). This allows each // reduction step to increase the number of variables to check if the validator // limits are enforced. class OpVariableDuplicatorReductionOpportunity : public ReductionOpportunity { public: OpVariableDuplicatorReductionOpportunity(Function* function) : function_(function) {} bool PreconditionHolds() override { Instruction* first_instruction = &*function_->begin()[0].begin(); return first_instruction->opcode() == spv::Op::OpVariable; } protected: void Apply() override { // Duplicate the first OpVariable instruction. Instruction* first_instruction = &*function_->begin()[0].begin(); assert(first_instruction->opcode() == spv::Op::OpVariable && "Expected first instruction to be OpVariable"); IRContext* context = first_instruction->context(); Instruction* cloned_instruction = first_instruction->Clone(context); cloned_instruction->SetResultId(context->TakeNextId()); cloned_instruction->InsertBefore(first_instruction); } private: Function* function_; }; // A reduction opportunity finder that finds // OpVariableDuplicatorReductionOpportunity. class OpVariableDuplicatorReductionOpportunityFinder : public ReductionOpportunityFinder { public: OpVariableDuplicatorReductionOpportunityFinder() = default; ~OpVariableDuplicatorReductionOpportunityFinder() override = default; std::string GetName() const final { return "LocalVariableAdderReductionOpportunityFinder"; } std::vector> GetAvailableOpportunities( IRContext* context, uint32_t /*unused*/) const final { std::vector> result; for (auto& function : *context->module()) { Instruction* first_instruction = &*function.begin()[0].begin(); if (first_instruction->opcode() == spv::Op::OpVariable) { result.push_back( MakeUnique(&function)); } } return result; } }; TEST(ValidationDuringReductionTest, CheckInvalidPassMakesNoProgress) { // A module whose global values are all referenced, so that any application of // MakeModuleInvalidPass will make the module invalid. Check that the reducer // makes no progress, as every step will be invalid and treated as // uninteresting. std::string original = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %60 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %16 "buf2" OpMemberName %16 0 "i" OpName %18 "" OpName %25 "buf1" OpMemberName %25 0 "f" OpName %27 "" OpName %60 "_GLF_color" OpMemberDecorate %16 0 Offset 0 OpDecorate %16 Block OpDecorate %18 DescriptorSet 0 OpDecorate %18 Binding 2 OpMemberDecorate %25 0 Offset 0 OpDecorate %25 Block OpDecorate %27 DescriptorSet 0 OpDecorate %27 Binding 1 OpDecorate %60 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %9 = OpConstant %6 0 %16 = OpTypeStruct %6 %17 = OpTypePointer Uniform %16 %18 = OpVariable %17 Uniform %19 = OpTypePointer Uniform %6 %22 = OpTypeBool %24 = OpTypeFloat 32 %25 = OpTypeStruct %24 %26 = OpTypePointer Uniform %25 %27 = OpVariable %26 Uniform %28 = OpTypePointer Uniform %24 %31 = OpConstant %24 2 %56 = OpConstant %6 1 %58 = OpTypeVector %24 4 %59 = OpTypePointer Output %58 %60 = OpVariable %59 Output %72 = OpUndef %24 %74 = OpUndef %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %10 %10 = OpLabel %73 = OpPhi %6 %74 %5 %77 %34 %71 = OpPhi %24 %72 %5 %76 %34 %70 = OpPhi %6 %9 %5 %57 %34 %20 = OpAccessChain %19 %18 %9 %21 = OpLoad %6 %20 %23 = OpSLessThan %22 %70 %21 OpLoopMerge %12 %34 None OpBranchConditional %23 %11 %12 %11 = OpLabel %29 = OpAccessChain %28 %27 %9 %30 = OpLoad %24 %29 %32 = OpFOrdGreaterThan %22 %30 %31 OpSelectionMerge %90 None OpBranchConditional %32 %33 %46 %33 = OpLabel %40 = OpFAdd %24 %71 %30 %45 = OpISub %6 %73 %21 OpBranch %90 %46 = OpLabel %50 = OpFMul %24 %71 %30 %54 = OpSDiv %6 %73 %21 OpBranch %90 %90 = OpLabel %77 = OpPhi %6 %45 %33 %54 %46 %76 = OpPhi %24 %40 %33 %50 %46 OpBranch %34 %34 = OpLabel %57 = OpIAdd %6 %70 %56 OpBranch %10 %12 = OpLabel %61 = OpAccessChain %28 %27 %9 %62 = OpLoad %24 %61 %66 = OpConvertSToF %24 %21 %68 = OpConvertSToF %24 %73 %69 = OpCompositeConstruct %58 %62 %71 %66 %68 OpStore %60 %69 OpReturn OpFunctionEnd )"; spv_target_env env = SPV_ENV_UNIVERSAL_1_3; Reducer reducer(env); reducer.SetMessageConsumer(NopDiagnostic); // Say that every module is interesting. reducer.SetInterestingnessFunction( [](const std::vector&, uint32_t) -> bool { return true; }); reducer.AddReductionPass( MakeUnique()); std::vector binary_in; SpirvTools t(env); ASSERT_TRUE(t.Assemble(original, &binary_in, kReduceAssembleOption)); std::vector binary_out; spvtools::ReducerOptions reducer_options; reducer_options.set_step_limit(500); // Don't fail on a validation error; just treat it as uninteresting. reducer_options.set_fail_on_validation_error(false); spvtools::ValidatorOptions validator_options; Reducer::ReductionResultStatus status = reducer.Run( std::move(binary_in), &binary_out, reducer_options, validator_options); ASSERT_EQ(status, Reducer::ReductionResultStatus::kComplete); // The reducer should have no impact. CheckEqual(env, original, binary_out); } TEST(ValidationDuringReductionTest, CheckNotAlwaysInvalidCanMakeProgress) { // A module with just one unreferenced global value. All but one application // of MakeModuleInvalidPass will make the module invalid. std::string original = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %60 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %16 "buf2" OpMemberName %16 0 "i" OpName %18 "" OpName %25 "buf1" OpMemberName %25 0 "f" OpName %27 "" OpName %60 "_GLF_color" OpMemberDecorate %16 0 Offset 0 OpDecorate %16 Block OpDecorate %18 DescriptorSet 0 OpDecorate %18 Binding 2 OpMemberDecorate %25 0 Offset 0 OpDecorate %25 Block OpDecorate %27 DescriptorSet 0 OpDecorate %27 Binding 1 OpDecorate %60 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %9 = OpConstant %6 0 %16 = OpTypeStruct %6 %17 = OpTypePointer Uniform %16 %18 = OpVariable %17 Uniform %19 = OpTypePointer Uniform %6 %22 = OpTypeBool %24 = OpTypeFloat 32 %25 = OpTypeStruct %24 %26 = OpTypePointer Uniform %25 %27 = OpVariable %26 Uniform %28 = OpTypePointer Uniform %24 %31 = OpConstant %24 2 %56 = OpConstant %6 1 %1000 = OpConstant %6 1000 ; It should be possible to remove this instruction without making the module invalid. %58 = OpTypeVector %24 4 %59 = OpTypePointer Output %58 %60 = OpVariable %59 Output %72 = OpUndef %24 %74 = OpUndef %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %10 %10 = OpLabel %73 = OpPhi %6 %74 %5 %77 %34 %71 = OpPhi %24 %72 %5 %76 %34 %70 = OpPhi %6 %9 %5 %57 %34 %20 = OpAccessChain %19 %18 %9 %21 = OpLoad %6 %20 %23 = OpSLessThan %22 %70 %21 OpLoopMerge %12 %34 None OpBranchConditional %23 %11 %12 %11 = OpLabel %29 = OpAccessChain %28 %27 %9 %30 = OpLoad %24 %29 %32 = OpFOrdGreaterThan %22 %30 %31 OpSelectionMerge %90 None OpBranchConditional %32 %33 %46 %33 = OpLabel %40 = OpFAdd %24 %71 %30 %45 = OpISub %6 %73 %21 OpBranch %90 %46 = OpLabel %50 = OpFMul %24 %71 %30 %54 = OpSDiv %6 %73 %21 OpBranch %90 %90 = OpLabel %77 = OpPhi %6 %45 %33 %54 %46 %76 = OpPhi %24 %40 %33 %50 %46 OpBranch %34 %34 = OpLabel %57 = OpIAdd %6 %70 %56 OpBranch %10 %12 = OpLabel %61 = OpAccessChain %28 %27 %9 %62 = OpLoad %24 %61 %66 = OpConvertSToF %24 %21 %68 = OpConvertSToF %24 %73 %69 = OpCompositeConstruct %58 %62 %71 %66 %68 OpStore %60 %69 OpReturn OpFunctionEnd )"; // This is the same as the original, except that the constant declaration of // 1000 is gone. std::string expected = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %60 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %16 "buf2" OpMemberName %16 0 "i" OpName %18 "" OpName %25 "buf1" OpMemberName %25 0 "f" OpName %27 "" OpName %60 "_GLF_color" OpMemberDecorate %16 0 Offset 0 OpDecorate %16 Block OpDecorate %18 DescriptorSet 0 OpDecorate %18 Binding 2 OpMemberDecorate %25 0 Offset 0 OpDecorate %25 Block OpDecorate %27 DescriptorSet 0 OpDecorate %27 Binding 1 OpDecorate %60 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %9 = OpConstant %6 0 %16 = OpTypeStruct %6 %17 = OpTypePointer Uniform %16 %18 = OpVariable %17 Uniform %19 = OpTypePointer Uniform %6 %22 = OpTypeBool %24 = OpTypeFloat 32 %25 = OpTypeStruct %24 %26 = OpTypePointer Uniform %25 %27 = OpVariable %26 Uniform %28 = OpTypePointer Uniform %24 %31 = OpConstant %24 2 %56 = OpConstant %6 1 %58 = OpTypeVector %24 4 %59 = OpTypePointer Output %58 %60 = OpVariable %59 Output %72 = OpUndef %24 %74 = OpUndef %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %10 %10 = OpLabel %73 = OpPhi %6 %74 %5 %77 %34 %71 = OpPhi %24 %72 %5 %76 %34 %70 = OpPhi %6 %9 %5 %57 %34 %20 = OpAccessChain %19 %18 %9 %21 = OpLoad %6 %20 %23 = OpSLessThan %22 %70 %21 OpLoopMerge %12 %34 None OpBranchConditional %23 %11 %12 %11 = OpLabel %29 = OpAccessChain %28 %27 %9 %30 = OpLoad %24 %29 %32 = OpFOrdGreaterThan %22 %30 %31 OpSelectionMerge %90 None OpBranchConditional %32 %33 %46 %33 = OpLabel %40 = OpFAdd %24 %71 %30 %45 = OpISub %6 %73 %21 OpBranch %90 %46 = OpLabel %50 = OpFMul %24 %71 %30 %54 = OpSDiv %6 %73 %21 OpBranch %90 %90 = OpLabel %77 = OpPhi %6 %45 %33 %54 %46 %76 = OpPhi %24 %40 %33 %50 %46 OpBranch %34 %34 = OpLabel %57 = OpIAdd %6 %70 %56 OpBranch %10 %12 = OpLabel %61 = OpAccessChain %28 %27 %9 %62 = OpLoad %24 %61 %66 = OpConvertSToF %24 %21 %68 = OpConvertSToF %24 %73 %69 = OpCompositeConstruct %58 %62 %71 %66 %68 OpStore %60 %69 OpReturn OpFunctionEnd )"; spv_target_env env = SPV_ENV_UNIVERSAL_1_3; Reducer reducer(env); reducer.SetMessageConsumer(NopDiagnostic); // Say that every module is interesting. reducer.SetInterestingnessFunction( [](const std::vector&, uint32_t) -> bool { return true; }); reducer.AddReductionPass( MakeUnique()); std::vector binary_in; SpirvTools t(env); ASSERT_TRUE(t.Assemble(original, &binary_in, kReduceAssembleOption)); std::vector binary_out; spvtools::ReducerOptions reducer_options; reducer_options.set_step_limit(500); // Don't fail on a validation error; just treat it as uninteresting. reducer_options.set_fail_on_validation_error(false); spvtools::ValidatorOptions validator_options; Reducer::ReductionResultStatus status = reducer.Run( std::move(binary_in), &binary_out, reducer_options, validator_options); ASSERT_EQ(status, Reducer::ReductionResultStatus::kComplete); CheckEqual(env, expected, binary_out); } // Sets up a Reducer for use in the CheckValidationOptions test; avoids // repetition. void SetupReducerForCheckValidationOptions(Reducer* reducer) { reducer->SetMessageConsumer(NopDiagnostic); // Say that every module is interesting. reducer->SetInterestingnessFunction( [](const std::vector&, uint32_t) -> bool { return true; }); // Each "reduction" step will duplicate the first OpVariable instruction in // the function. reducer->AddReductionPass( MakeUnique()); } TEST(ValidationDuringReductionTest, CheckValidationOptions) { // A module that only validates when the "skip-block-layout" validator option // is used. Also, the entry point's first instruction creates a local // variable; this instruction will be duplicated on each reduction step. std::string original = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %2 "Main" %3 OpSource HLSL 600 OpDecorate %3 BuiltIn Position OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 99 OpDecorate %5 ArrayStride 16 OpMemberDecorate %6 0 Offset 0 OpMemberDecorate %6 1 Offset 32 OpMemberDecorate %6 1 MatrixStride 16 OpMemberDecorate %6 1 ColMajor OpMemberDecorate %6 2 Offset 96 OpMemberDecorate %6 3 Offset 100 OpMemberDecorate %6 4 Offset 112 OpMemberDecorate %6 4 MatrixStride 16 OpMemberDecorate %6 4 ColMajor OpMemberDecorate %6 5 Offset 176 OpDecorate %6 Block %7 = OpTypeFloat 32 %8 = OpTypeVector %7 4 %9 = OpTypeMatrix %8 4 %10 = OpTypeVector %7 2 %11 = OpTypeInt 32 1 %12 = OpTypeInt 32 0 %13 = OpConstant %12 2 %14 = OpConstant %11 1 %15 = OpConstant %11 5 %5 = OpTypeArray %8 %13 %6 = OpTypeStruct %5 %9 %12 %10 %9 %7 %16 = OpTypePointer Uniform %6 %17 = OpTypePointer Output %8 %18 = OpTypeVoid %19 = OpTypeFunction %18 %20 = OpTypePointer Uniform %7 %4 = OpVariable %16 Uniform %3 = OpVariable %17 Output %21 = OpTypePointer Function %11 %2 = OpFunction %18 None %19 %22 = OpLabel %23 = OpVariable %21 Function %24 = OpAccessChain %20 %4 %15 %25 = OpLoad %7 %24 %26 = OpCompositeConstruct %8 %25 %25 %25 %25 OpStore %3 %26 OpReturn OpFunctionEnd )"; spv_target_env env = SPV_ENV_VULKAN_1_0; std::vector binary_in; SpirvTools t(env); ASSERT_TRUE(t.Assemble(original, &binary_in, kReduceAssembleOption)); std::vector binary_out; spvtools::ReducerOptions reducer_options; spvtools::ValidatorOptions validator_options; reducer_options.set_step_limit(3); reducer_options.set_fail_on_validation_error(true); // Reduction should fail because the initial state is invalid without the // "skip-block-layout" validator option. Note that the interestingness test // always returns true. { Reducer reducer(env); SetupReducerForCheckValidationOptions(&reducer); Reducer::ReductionResultStatus status = reducer.Run(std::vector(binary_in), &binary_out, reducer_options, validator_options); ASSERT_EQ(status, Reducer::ReductionResultStatus::kInitialStateInvalid); } // Try again with validator option. validator_options.SetSkipBlockLayout(true); // Reduction should hit step limit; module is seen as valid, interestingness // test always succeeds, and the finder yields infinite opportunities. { Reducer reducer(env); SetupReducerForCheckValidationOptions(&reducer); Reducer::ReductionResultStatus status = reducer.Run(std::vector(binary_in), &binary_out, reducer_options, validator_options); ASSERT_EQ(status, Reducer::ReductionResultStatus::kReachedStepLimit); } // Now set a limit on the number of local variables. validator_options.SetUniversalLimit(spv_validator_limit_max_local_variables, 2); // Reduction should now fail due to reaching an invalid state; after one step, // a local variable is added and the module becomes "invalid" given the // validator limits. { Reducer reducer(env); SetupReducerForCheckValidationOptions(&reducer); Reducer::ReductionResultStatus status = reducer.Run(std::vector(binary_in), &binary_out, reducer_options, validator_options); ASSERT_EQ(status, Reducer::ReductionResultStatus::kStateInvalid); } } } // namespace } // namespace reduce } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/scripts/000077500000000000000000000000001475742701700211775ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/scripts/test_compact_ids.py000066400000000000000000000056471475742701700251110ustar00rootroot00000000000000#!/usr/bin/env python3 # Copyright (c) 2017 Google Inc. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Tests correctness of opt pass tools/opt --compact-ids.""" import os.path import sys import tempfile def test_spirv_file(path, temp_dir): optimized_spv_path = os.path.join(temp_dir, 'optimized.spv') optimized_dis_path = os.path.join(temp_dir, 'optimized.dis') converted_spv_path = os.path.join(temp_dir, 'converted.spv') converted_dis_path = os.path.join(temp_dir, 'converted.dis') os.system('tools/spirv-opt ' + path + ' -o ' + optimized_spv_path + ' --compact-ids') os.system('tools/spirv-dis ' + optimized_spv_path + ' -o ' + optimized_dis_path) os.system('tools/spirv-dis ' + path + ' -o ' + converted_dis_path) os.system('tools/spirv-as ' + converted_dis_path + ' -o ' + converted_spv_path) os.system('tools/spirv-dis ' + converted_spv_path + ' -o ' + converted_dis_path) with open(converted_dis_path, 'r') as f: converted_dis = f.readlines()[3:] with open(optimized_dis_path, 'r') as f: optimized_dis = f.readlines()[3:] return converted_dis == optimized_dis def print_usage(): template= \ """{script} tests correctness of opt pass tools/opt --compact-ids USAGE: python3 {script} [] Requires tools/spirv-dis, tools/spirv-as and tools/spirv-opt to be in path (call the script from the SPIRV-Tools build output directory). TIP: In order to test all .spv files under current dir use find -name "*.spv" -print0 | xargs -0 -s 2000000 python {script} """ print(template.format(script=sys.argv[0])); def main(): if not os.path.isfile('tools/spirv-dis'): print('error: tools/spirv-dis not found') print_usage() exit(1) if not os.path.isfile('tools/spirv-as'): print('error: tools/spirv-as not found') print_usage() exit(1) if not os.path.isfile('tools/spirv-opt'): print('error: tools/spirv-opt not found') print_usage() exit(1) paths = sys.argv[1:] if not paths: print_usage() num_failed = 0 temp_dir = tempfile.mkdtemp() for path in paths: success = test_spirv_file(path, temp_dir) if not success: print('Test failed for ' + path) num_failed += 1 print('Tested ' + str(len(paths)) + ' files') if num_failed: print(str(num_failed) + ' tests failed') exit(1) else: print('All tests successful') exit(0) if __name__ == '__main__': main() KhronosGroup-SPIRV-Tools-f289d04/test/software_version_test.cpp000066400000000000000000000037311475742701700246560ustar00rootroot00000000000000// Copyright (c) 2015-2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gmock/gmock.h" #include "test/unit_spirv.h" namespace spvtools { namespace { using ::testing::AnyOf; using ::testing::Eq; using ::testing::Ge; using ::testing::StartsWith; void CheckFormOfHighLevelVersion(const std::string& version) { std::istringstream s(version); char v = 'x'; int year = -1; char period = 'x'; int index = -1; s >> v >> year >> period >> index; EXPECT_THAT(v, Eq('v')); EXPECT_THAT(year, Ge(2016)); EXPECT_THAT(period, Eq('.')); EXPECT_THAT(index, Ge(0)); EXPECT_TRUE(s.good() || s.eof()); std::string rest; s >> rest; EXPECT_THAT(rest, AnyOf("", "-dev")); } TEST(SoftwareVersion, ShortIsCorrectForm) { SCOPED_TRACE("short form"); CheckFormOfHighLevelVersion(spvSoftwareVersionString()); } TEST(SoftwareVersion, DetailedIsCorrectForm) { const std::string detailed_version(spvSoftwareVersionDetailsString()); EXPECT_THAT(detailed_version, StartsWith("SPIRV-Tools v")); // Parse the high level version. const std::string from_v = detailed_version.substr(detailed_version.find_first_of('v')); const size_t first_space_after_v_or_npos = from_v.find_first_of(' '); SCOPED_TRACE(detailed_version); CheckFormOfHighLevelVersion(from_v.substr(0, first_space_after_v_or_npos)); // We don't actually care about what comes after the version number. } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/string_utils_test.cpp000066400000000000000000000170111475742701700240010ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gtest/gtest.h" #include "source/util/string_utils.h" #include "spirv-tools/libspirv.h" namespace spvtools { namespace utils { namespace { TEST(ToString, Int) { EXPECT_EQ("0", ToString(0)); EXPECT_EQ("1000", ToString(1000)); EXPECT_EQ("-1", ToString(-1)); EXPECT_EQ("0", ToString(0LL)); EXPECT_EQ("1000", ToString(1000LL)); EXPECT_EQ("-1", ToString(-1LL)); } TEST(ToString, Uint) { EXPECT_EQ("0", ToString(0U)); EXPECT_EQ("1000", ToString(1000U)); EXPECT_EQ("0", ToString(0ULL)); EXPECT_EQ("1000", ToString(1000ULL)); } TEST(ToString, Float) { EXPECT_EQ("0", ToString(0.f)); EXPECT_EQ("1000", ToString(1000.f)); EXPECT_EQ("-1.5", ToString(-1.5f)); } TEST(ToString, Double) { EXPECT_EQ("0", ToString(0.)); EXPECT_EQ("1000", ToString(1000.)); EXPECT_EQ("-1.5", ToString(-1.5)); } TEST(CardinalToOrdinal, Test) { EXPECT_EQ("1st", CardinalToOrdinal(1)); EXPECT_EQ("2nd", CardinalToOrdinal(2)); EXPECT_EQ("3rd", CardinalToOrdinal(3)); EXPECT_EQ("4th", CardinalToOrdinal(4)); EXPECT_EQ("5th", CardinalToOrdinal(5)); EXPECT_EQ("6th", CardinalToOrdinal(6)); EXPECT_EQ("7th", CardinalToOrdinal(7)); EXPECT_EQ("8th", CardinalToOrdinal(8)); EXPECT_EQ("9th", CardinalToOrdinal(9)); EXPECT_EQ("10th", CardinalToOrdinal(10)); EXPECT_EQ("11th", CardinalToOrdinal(11)); EXPECT_EQ("12th", CardinalToOrdinal(12)); EXPECT_EQ("13th", CardinalToOrdinal(13)); EXPECT_EQ("14th", CardinalToOrdinal(14)); EXPECT_EQ("15th", CardinalToOrdinal(15)); EXPECT_EQ("16th", CardinalToOrdinal(16)); EXPECT_EQ("17th", CardinalToOrdinal(17)); EXPECT_EQ("18th", CardinalToOrdinal(18)); EXPECT_EQ("19th", CardinalToOrdinal(19)); EXPECT_EQ("20th", CardinalToOrdinal(20)); EXPECT_EQ("21st", CardinalToOrdinal(21)); EXPECT_EQ("22nd", CardinalToOrdinal(22)); EXPECT_EQ("23rd", CardinalToOrdinal(23)); EXPECT_EQ("24th", CardinalToOrdinal(24)); EXPECT_EQ("25th", CardinalToOrdinal(25)); EXPECT_EQ("26th", CardinalToOrdinal(26)); EXPECT_EQ("27th", CardinalToOrdinal(27)); EXPECT_EQ("28th", CardinalToOrdinal(28)); EXPECT_EQ("29th", CardinalToOrdinal(29)); EXPECT_EQ("30th", CardinalToOrdinal(30)); EXPECT_EQ("31st", CardinalToOrdinal(31)); EXPECT_EQ("32nd", CardinalToOrdinal(32)); EXPECT_EQ("33rd", CardinalToOrdinal(33)); EXPECT_EQ("34th", CardinalToOrdinal(34)); EXPECT_EQ("35th", CardinalToOrdinal(35)); EXPECT_EQ("100th", CardinalToOrdinal(100)); EXPECT_EQ("101st", CardinalToOrdinal(101)); EXPECT_EQ("102nd", CardinalToOrdinal(102)); EXPECT_EQ("103rd", CardinalToOrdinal(103)); EXPECT_EQ("104th", CardinalToOrdinal(104)); EXPECT_EQ("105th", CardinalToOrdinal(105)); EXPECT_EQ("106th", CardinalToOrdinal(106)); EXPECT_EQ("107th", CardinalToOrdinal(107)); EXPECT_EQ("108th", CardinalToOrdinal(108)); EXPECT_EQ("109th", CardinalToOrdinal(109)); EXPECT_EQ("110th", CardinalToOrdinal(110)); EXPECT_EQ("111th", CardinalToOrdinal(111)); EXPECT_EQ("112th", CardinalToOrdinal(112)); EXPECT_EQ("113th", CardinalToOrdinal(113)); EXPECT_EQ("114th", CardinalToOrdinal(114)); EXPECT_EQ("115th", CardinalToOrdinal(115)); EXPECT_EQ("116th", CardinalToOrdinal(116)); EXPECT_EQ("117th", CardinalToOrdinal(117)); EXPECT_EQ("118th", CardinalToOrdinal(118)); EXPECT_EQ("119th", CardinalToOrdinal(119)); EXPECT_EQ("120th", CardinalToOrdinal(120)); EXPECT_EQ("121st", CardinalToOrdinal(121)); EXPECT_EQ("122nd", CardinalToOrdinal(122)); EXPECT_EQ("123rd", CardinalToOrdinal(123)); EXPECT_EQ("124th", CardinalToOrdinal(124)); EXPECT_EQ("125th", CardinalToOrdinal(125)); EXPECT_EQ("126th", CardinalToOrdinal(126)); EXPECT_EQ("127th", CardinalToOrdinal(127)); EXPECT_EQ("128th", CardinalToOrdinal(128)); EXPECT_EQ("129th", CardinalToOrdinal(129)); EXPECT_EQ("130th", CardinalToOrdinal(130)); EXPECT_EQ("131st", CardinalToOrdinal(131)); EXPECT_EQ("132nd", CardinalToOrdinal(132)); EXPECT_EQ("133rd", CardinalToOrdinal(133)); EXPECT_EQ("134th", CardinalToOrdinal(134)); EXPECT_EQ("135th", CardinalToOrdinal(135)); EXPECT_EQ("1000th", CardinalToOrdinal(1000)); EXPECT_EQ("1001st", CardinalToOrdinal(1001)); EXPECT_EQ("1002nd", CardinalToOrdinal(1002)); EXPECT_EQ("1003rd", CardinalToOrdinal(1003)); EXPECT_EQ("1004th", CardinalToOrdinal(1004)); EXPECT_EQ("1005th", CardinalToOrdinal(1005)); EXPECT_EQ("1006th", CardinalToOrdinal(1006)); EXPECT_EQ("1007th", CardinalToOrdinal(1007)); EXPECT_EQ("1008th", CardinalToOrdinal(1008)); EXPECT_EQ("1009th", CardinalToOrdinal(1009)); EXPECT_EQ("1010th", CardinalToOrdinal(1010)); EXPECT_EQ("1011th", CardinalToOrdinal(1011)); EXPECT_EQ("1012th", CardinalToOrdinal(1012)); EXPECT_EQ("1013th", CardinalToOrdinal(1013)); EXPECT_EQ("1014th", CardinalToOrdinal(1014)); EXPECT_EQ("1015th", CardinalToOrdinal(1015)); EXPECT_EQ("1016th", CardinalToOrdinal(1016)); EXPECT_EQ("1017th", CardinalToOrdinal(1017)); EXPECT_EQ("1018th", CardinalToOrdinal(1018)); EXPECT_EQ("1019th", CardinalToOrdinal(1019)); EXPECT_EQ("1020th", CardinalToOrdinal(1020)); EXPECT_EQ("1021st", CardinalToOrdinal(1021)); EXPECT_EQ("1022nd", CardinalToOrdinal(1022)); EXPECT_EQ("1023rd", CardinalToOrdinal(1023)); EXPECT_EQ("1024th", CardinalToOrdinal(1024)); EXPECT_EQ("1025th", CardinalToOrdinal(1025)); EXPECT_EQ("1026th", CardinalToOrdinal(1026)); EXPECT_EQ("1027th", CardinalToOrdinal(1027)); EXPECT_EQ("1028th", CardinalToOrdinal(1028)); EXPECT_EQ("1029th", CardinalToOrdinal(1029)); EXPECT_EQ("1030th", CardinalToOrdinal(1030)); EXPECT_EQ("1031st", CardinalToOrdinal(1031)); EXPECT_EQ("1032nd", CardinalToOrdinal(1032)); EXPECT_EQ("1033rd", CardinalToOrdinal(1033)); EXPECT_EQ("1034th", CardinalToOrdinal(1034)); EXPECT_EQ("1035th", CardinalToOrdinal(1035)); EXPECT_EQ("1200th", CardinalToOrdinal(1200)); EXPECT_EQ("1201st", CardinalToOrdinal(1201)); EXPECT_EQ("1202nd", CardinalToOrdinal(1202)); EXPECT_EQ("1203rd", CardinalToOrdinal(1203)); EXPECT_EQ("1204th", CardinalToOrdinal(1204)); EXPECT_EQ("1205th", CardinalToOrdinal(1205)); EXPECT_EQ("1206th", CardinalToOrdinal(1206)); EXPECT_EQ("1207th", CardinalToOrdinal(1207)); EXPECT_EQ("1208th", CardinalToOrdinal(1208)); EXPECT_EQ("1209th", CardinalToOrdinal(1209)); EXPECT_EQ("1210th", CardinalToOrdinal(1210)); EXPECT_EQ("1211th", CardinalToOrdinal(1211)); EXPECT_EQ("1212th", CardinalToOrdinal(1212)); EXPECT_EQ("1213th", CardinalToOrdinal(1213)); EXPECT_EQ("1214th", CardinalToOrdinal(1214)); EXPECT_EQ("1215th", CardinalToOrdinal(1215)); EXPECT_EQ("1216th", CardinalToOrdinal(1216)); EXPECT_EQ("1217th", CardinalToOrdinal(1217)); EXPECT_EQ("1218th", CardinalToOrdinal(1218)); EXPECT_EQ("1219th", CardinalToOrdinal(1219)); EXPECT_EQ("1220th", CardinalToOrdinal(1220)); EXPECT_EQ("1221st", CardinalToOrdinal(1221)); EXPECT_EQ("1222nd", CardinalToOrdinal(1222)); EXPECT_EQ("1223rd", CardinalToOrdinal(1223)); EXPECT_EQ("1224th", CardinalToOrdinal(1224)); EXPECT_EQ("1225th", CardinalToOrdinal(1225)); } } // namespace } // namespace utils } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/target_env_test.cpp000066400000000000000000000223561475742701700234210ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gmock/gmock.h" #include "source/spirv_target_env.h" #include "test/unit_spirv.h" namespace spvtools { namespace { using ::testing::AnyOf; using ::testing::Eq; using ::testing::StartsWith; using ::testing::ValuesIn; using TargetEnvTest = ::testing::TestWithParam; TEST_P(TargetEnvTest, CreateContext) { spv_target_env env = GetParam(); spv_context context = spvContextCreate(env); ASSERT_NE(nullptr, context); spvContextDestroy(context); // Avoid leaking } TEST_P(TargetEnvTest, ValidDescription) { const char* description = spvTargetEnvDescription(GetParam()); ASSERT_NE(nullptr, description); ASSERT_THAT(description, StartsWith("SPIR-V ")); } TEST_P(TargetEnvTest, ValidSpirvVersion) { auto spirv_version = spvVersionForTargetEnv(GetParam()); ASSERT_THAT(spirv_version, AnyOf(0x10000, 0x10100, 0x10200, 0x10300)); } INSTANTIATE_TEST_SUITE_P(AllTargetEnvs, TargetEnvTest, ValuesIn(spvtest::AllTargetEnvironments())); TEST(GetContextTest, InvalidTargetEnvProducesNull) { // Use a value beyond the last valid enum value. spv_context context = spvContextCreate(static_cast(30)); EXPECT_EQ(context, nullptr); } // A test case for parsing an environment string. struct ParseCase { const char* input; bool success; // Expect to successfully parse? spv_target_env env; // The parsed environment, if successful. }; using TargetParseTest = ::testing::TestWithParam; TEST_P(TargetParseTest, Samples) { spv_target_env env; bool parsed = spvParseTargetEnv(GetParam().input, &env); EXPECT_THAT(parsed, Eq(GetParam().success)); if (parsed) { EXPECT_THAT(env, Eq(GetParam().env)); } } INSTANTIATE_TEST_SUITE_P( TargetParsing, TargetParseTest, ValuesIn(std::vector{ {"spv1.0", true, SPV_ENV_UNIVERSAL_1_0}, {"spv1.1", true, SPV_ENV_UNIVERSAL_1_1}, {"spv1.2", true, SPV_ENV_UNIVERSAL_1_2}, {"spv1.3", true, SPV_ENV_UNIVERSAL_1_3}, {"spv1.4", true, SPV_ENV_UNIVERSAL_1_4}, {"spv1.5", true, SPV_ENV_UNIVERSAL_1_5}, {"spv1.6", true, SPV_ENV_UNIVERSAL_1_6}, {"spv1.7", false, SPV_ENV_UNIVERSAL_1_3}, {"vulkan1.0", true, SPV_ENV_VULKAN_1_0}, {"vulkan1.1", true, SPV_ENV_VULKAN_1_1}, {"vulkan1.2", true, SPV_ENV_VULKAN_1_2}, {"vulkan1.3", true, SPV_ENV_VULKAN_1_3}, {"vulkan1.4", true, SPV_ENV_VULKAN_1_4}, {"vulkan1.5", false, SPV_ENV_UNIVERSAL_1_0}, {"opencl2.1", true, SPV_ENV_OPENCL_2_1}, {"opencl2.2", true, SPV_ENV_OPENCL_2_2}, {"opengl4.0", true, SPV_ENV_OPENGL_4_0}, {"opengl4.1", true, SPV_ENV_OPENGL_4_1}, {"opengl4.2", true, SPV_ENV_OPENGL_4_2}, {"opengl4.3", true, SPV_ENV_OPENGL_4_3}, {"opengl4.5", true, SPV_ENV_OPENGL_4_5}, {"opencl1.2", true, SPV_ENV_OPENCL_1_2}, {"opencl1.2embedded", true, SPV_ENV_OPENCL_EMBEDDED_1_2}, {"opencl2.0", true, SPV_ENV_OPENCL_2_0}, {"opencl2.0embedded", true, SPV_ENV_OPENCL_EMBEDDED_2_0}, {"opencl2.1embedded", true, SPV_ENV_OPENCL_EMBEDDED_2_1}, {"opencl2.2embedded", true, SPV_ENV_OPENCL_EMBEDDED_2_2}, {"opencl2.3", false, SPV_ENV_UNIVERSAL_1_0}, {"opencl3.0", false, SPV_ENV_UNIVERSAL_1_0}, {"vulkan1.9", false, SPV_ENV_UNIVERSAL_1_0}, {"vulkan2.0", false, SPV_ENV_UNIVERSAL_1_0}, {nullptr, false, SPV_ENV_UNIVERSAL_1_0}, {"", false, SPV_ENV_UNIVERSAL_1_0}, {"abc", false, SPV_ENV_UNIVERSAL_1_0}, })); // A test case for parsing an environment string. struct ParseVulkanCase { uint32_t vulkan; uint32_t spirv; bool success; // Expect to successfully parse? spv_target_env env; // The parsed environment, if successful. }; using TargetParseVulkanTest = ::testing::TestWithParam; TEST_P(TargetParseVulkanTest, Samples) { spv_target_env env; bool parsed = spvParseVulkanEnv(GetParam().vulkan, GetParam().spirv, &env); EXPECT_THAT(parsed, Eq(GetParam().success)); if (parsed) { EXPECT_THAT(env, Eq(GetParam().env)); } } #define VK(MAJ, MIN) ((MAJ << 22) | (MIN << 12)) #define SPV(MAJ, MIN) ((MAJ << 16) | (MIN << 8)) INSTANTIATE_TEST_SUITE_P( TargetVulkanParsing, TargetParseVulkanTest, ValuesIn(std::vector{ // Vulkan 1.0 cases {VK(1, 0), SPV(1, 0), true, SPV_ENV_VULKAN_1_0}, {VK(1, 0), SPV(1, 1), true, SPV_ENV_VULKAN_1_1}, {VK(1, 0), SPV(1, 2), true, SPV_ENV_VULKAN_1_1}, {VK(1, 0), SPV(1, 3), true, SPV_ENV_VULKAN_1_1}, {VK(1, 0), SPV(1, 4), true, SPV_ENV_VULKAN_1_1_SPIRV_1_4}, {VK(1, 0), SPV(1, 5), true, SPV_ENV_VULKAN_1_2}, {VK(1, 0), SPV(1, 6), true, SPV_ENV_VULKAN_1_3}, {VK(1, 0), SPV(1, 7), false, SPV_ENV_UNIVERSAL_1_0}, // Vulkan 1.1 cases {VK(1, 1), SPV(1, 0), true, SPV_ENV_VULKAN_1_1}, {VK(1, 1), SPV(1, 1), true, SPV_ENV_VULKAN_1_1}, {VK(1, 1), SPV(1, 2), true, SPV_ENV_VULKAN_1_1}, {VK(1, 1), SPV(1, 3), true, SPV_ENV_VULKAN_1_1}, {VK(1, 1), SPV(1, 4), true, SPV_ENV_VULKAN_1_1_SPIRV_1_4}, {VK(1, 1), SPV(1, 5), true, SPV_ENV_VULKAN_1_2}, {VK(1, 1), SPV(1, 6), true, SPV_ENV_VULKAN_1_3}, {VK(1, 1), SPV(1, 7), false, SPV_ENV_UNIVERSAL_1_0}, // Vulkan 1.2 cases {VK(1, 2), SPV(1, 0), true, SPV_ENV_VULKAN_1_2}, {VK(1, 2), SPV(1, 1), true, SPV_ENV_VULKAN_1_2}, {VK(1, 2), SPV(1, 2), true, SPV_ENV_VULKAN_1_2}, {VK(1, 2), SPV(1, 3), true, SPV_ENV_VULKAN_1_2}, {VK(1, 2), SPV(1, 4), true, SPV_ENV_VULKAN_1_2}, {VK(1, 2), SPV(1, 5), true, SPV_ENV_VULKAN_1_2}, {VK(1, 2), SPV(1, 6), true, SPV_ENV_VULKAN_1_3}, {VK(1, 2), SPV(1, 7), false, SPV_ENV_UNIVERSAL_1_0}, // Vulkan 1.3 cases {VK(1, 3), SPV(1, 0), true, SPV_ENV_VULKAN_1_3}, {VK(1, 3), SPV(1, 1), true, SPV_ENV_VULKAN_1_3}, {VK(1, 3), SPV(1, 2), true, SPV_ENV_VULKAN_1_3}, {VK(1, 3), SPV(1, 3), true, SPV_ENV_VULKAN_1_3}, {VK(1, 3), SPV(1, 4), true, SPV_ENV_VULKAN_1_3}, {VK(1, 3), SPV(1, 5), true, SPV_ENV_VULKAN_1_3}, {VK(1, 3), SPV(1, 6), true, SPV_ENV_VULKAN_1_3}, {VK(1, 3), SPV(1, 7), false, SPV_ENV_UNIVERSAL_1_0}, // Vulkan 2.0 cases {VK(2, 0), SPV(1, 0), false, SPV_ENV_UNIVERSAL_1_0}, // Vulkan 99.0 cases {VK(99, 0), SPV(1, 0), false, SPV_ENV_UNIVERSAL_1_0}, })); // A test case for parsing the text header of disassembly. struct ParseEnvInDisassemblyCase { std::string text; bool success; // Expect to successfully parse? spv_target_env env; // The parsed environment, if successful. }; using TargetParseEnvInDisassemblyTest = ::testing::TestWithParam; constexpr spv_target_env kSentinelEnv = SPV_ENV_OPENCL_2_2; TEST_P(TargetParseEnvInDisassemblyTest, Samples) { const std::string& text = GetParam().text; const std::vector text_vec(text.begin(), text.end()); spv_target_env got_env = kSentinelEnv; bool parsed = spvReadEnvironmentFromText(text_vec, &got_env); EXPECT_EQ(parsed, GetParam().success); EXPECT_EQ(got_env, GetParam().env) << '"' << text << '"'; } INSTANTIATE_TEST_SUITE_P( TargetTextParsing, TargetParseEnvInDisassemblyTest, ValuesIn(std::vector{ {"; Version: 1.0", true, SPV_ENV_UNIVERSAL_1_0}, {"; Version: 1.1", true, SPV_ENV_UNIVERSAL_1_1}, {"; Version: 1.2", true, SPV_ENV_UNIVERSAL_1_2}, {"; Version: 1.3", true, SPV_ENV_UNIVERSAL_1_3}, {"; Version: 1.4", true, SPV_ENV_UNIVERSAL_1_4}, {"; Version: 1.5", true, SPV_ENV_UNIVERSAL_1_5}, {"; Version: 1.6", true, SPV_ENV_UNIVERSAL_1_6}, {"; Version: 1.7", false, kSentinelEnv}, {"; Version: 1.8", false, kSentinelEnv}, {"; Version: 1.9", false, kSentinelEnv}, {"; Version: 2.0", false, kSentinelEnv}, // Check trailing text {"; Version: 1.1\n", true, SPV_ENV_UNIVERSAL_1_1}, {"; Version: 1.1\t", true, SPV_ENV_UNIVERSAL_1_1}, {"; Version: 1.1 ", true, SPV_ENV_UNIVERSAL_1_1}, {"; Version: 1.1x", true, SPV_ENV_UNIVERSAL_1_1}, // Not a digit. {"; Version: 1.10", false, kSentinelEnv}, // Unexpected prefix {";Version: 1.1", false, kSentinelEnv}, // Leading spaces {" \t ; Version: 1.1", true, SPV_ENV_UNIVERSAL_1_1}, // Previous lines {"; SPIR-V\n; Version: 1.1", true, SPV_ENV_UNIVERSAL_1_1}, {"; -\n; SPIR-V\n; Version: 1.1", true, SPV_ENV_UNIVERSAL_1_1}, // After a non-header line {"OpCapability Shader\n; Version: 1.1", false, kSentinelEnv}})); } // anonymous namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/test_fixture.h000066400000000000000000000164671475742701700224240ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef TEST_TEST_FIXTURE_H_ #define TEST_TEST_FIXTURE_H_ #include #include #include #include "test/unit_spirv.h" namespace spvtest { // RAII for spv_context. struct ScopedContext { ScopedContext(spv_target_env env = SPV_ENV_UNIVERSAL_1_0) : context(spvContextCreate(env)) {} ~ScopedContext() { spvContextDestroy(context); } spv_context context; }; // Common setup for TextToBinary tests. SetText() should be called to populate // the actual test text. template class TextToBinaryTestBase : public T { public: // Shorthand for SPIR-V compilation result. using SpirvVector = std::vector; // Offset into a SpirvVector at which the first instruction starts. static const SpirvVector::size_type kFirstInstruction = 5; TextToBinaryTestBase() : diagnostic(nullptr), text(), binary(nullptr) { char textStr[] = "substitute the text member variable with your test"; text = {textStr, strlen(textStr)}; } ~TextToBinaryTestBase() override { DestroyBinary(); if (diagnostic) spvDiagnosticDestroy(diagnostic); } // Returns subvector v[from:end). SpirvVector Subvector(const SpirvVector& v, SpirvVector::size_type from) { assert(from <= v.size()); return SpirvVector(v.begin() + from, v.end()); } // Compiles SPIR-V text in the given assembly syntax format, asserting // compilation success. Returns the compiled code. SpirvVector CompileSuccessfully(const std::string& txt, spv_target_env env = SPV_ENV_UNIVERSAL_1_0) { DestroyBinary(); DestroyDiagnostic(); spv_result_t status = spvTextToBinary(ScopedContext(env).context, txt.c_str(), txt.size(), &binary, &diagnostic); EXPECT_EQ(SPV_SUCCESS, status) << txt; SpirvVector code_copy; if (status == SPV_SUCCESS) { code_copy = SpirvVector(binary->code, binary->code + binary->wordCount); DestroyBinary(); } else { spvDiagnosticPrint(diagnostic); } return code_copy; } // Compiles SPIR-V text with the given format, asserting compilation failure. // Returns the error message(s). std::string CompileFailure(const std::string& txt, spv_target_env env = SPV_ENV_UNIVERSAL_1_0) { DestroyBinary(); DestroyDiagnostic(); EXPECT_NE(SPV_SUCCESS, spvTextToBinary(ScopedContext(env).context, txt.c_str(), txt.size(), &binary, &diagnostic)) << txt; DestroyBinary(); return diagnostic->error; } // Potentially flip the words in the binary representation to the other // endianness template void MaybeFlipWords(bool flip_words, It begin, It end) { SCOPED_TRACE(flip_words ? "Flipped Endianness" : "Normal Endianness"); if (flip_words) { std::transform(begin, end, begin, [](const uint32_t raw_word) { return spvFixWord(raw_word, I32_ENDIAN_HOST == I32_ENDIAN_BIG ? SPV_ENDIANNESS_LITTLE : SPV_ENDIANNESS_BIG); }); } } // Encodes SPIR-V text into binary and then decodes the binary using // given options. Returns the decoded text. std::string EncodeAndDecodeSuccessfully( const std::string& txt, uint32_t disassemble_options = SPV_BINARY_TO_TEXT_OPTION_NONE, uint32_t assemble_options = SPV_TEXT_TO_BINARY_OPTION_NONE, spv_target_env env = SPV_ENV_UNIVERSAL_1_0, bool flip_words = false) { DestroyBinary(); DestroyDiagnostic(); ScopedContext context(env); disassemble_options |= SPV_BINARY_TO_TEXT_OPTION_NO_HEADER; spv_result_t error = spvTextToBinaryWithOptions(context.context, txt.c_str(), txt.size(), assemble_options, &binary, &diagnostic); if (error) { spvDiagnosticPrint(diagnostic); spvDiagnosticDestroy(diagnostic); } EXPECT_EQ(SPV_SUCCESS, error); if (!binary) return ""; MaybeFlipWords(flip_words, binary->code, binary->code + binary->wordCount); spv_text decoded_text; error = spvBinaryToText(context.context, binary->code, binary->wordCount, disassemble_options, &decoded_text, &diagnostic); if (error) { spvDiagnosticPrint(diagnostic); spvDiagnosticDestroy(diagnostic); } EXPECT_EQ(SPV_SUCCESS, error) << txt; const std::string decoded_string = decoded_text->str; spvTextDestroy(decoded_text); return decoded_string; } // Encodes SPIR-V text into binary. This is expected to succeed. // The given words are then appended to the binary, and the result // is then decoded. This is expected to fail. // Returns the error message. std::string EncodeSuccessfullyDecodeFailed( const std::string& txt, const SpirvVector& words_to_append) { DestroyBinary(); DestroyDiagnostic(); SpirvVector code = spvtest::Concatenate({CompileSuccessfully(txt), words_to_append}); spv_text decoded_text; EXPECT_NE(SPV_SUCCESS, spvBinaryToText(ScopedContext().context, code.data(), code.size(), SPV_BINARY_TO_TEXT_OPTION_NONE, &decoded_text, &diagnostic)); if (diagnostic) { std::string error_message = diagnostic->error; spvDiagnosticDestroy(diagnostic); diagnostic = nullptr; return error_message; } return ""; } // Compiles SPIR-V text, asserts success, and returns the words representing // the instructions. In particular, skip the words in the SPIR-V header. SpirvVector CompiledInstructions(const std::string& txt, spv_target_env env = SPV_ENV_UNIVERSAL_1_0) { const SpirvVector code = CompileSuccessfully(txt, env); SpirvVector result; // Extract just the instructions. // If the code fails to compile, then return the empty vector. // In any case, don't crash or invoke undefined behaviour. if (code.size() >= kFirstInstruction) result = Subvector(code, kFirstInstruction); return result; } void SetText(const std::string& code) { textString = code; text.str = textString.c_str(); text.length = textString.size(); } // Destroys the binary, if it exists. void DestroyBinary() { spvBinaryDestroy(binary); binary = nullptr; } // Destroys the diagnostic, if it exists. void DestroyDiagnostic() { spvDiagnosticDestroy(diagnostic); diagnostic = nullptr; } spv_diagnostic diagnostic; std::string textString; spv_text_t text; spv_binary binary; }; using TextToBinaryTest = TextToBinaryTestBase<::testing::Test>; } // namespace spvtest using RoundTripTest = spvtest::TextToBinaryTestBase<::testing::TestWithParam>; #endif // TEST_TEST_FIXTURE_H_ KhronosGroup-SPIRV-Tools-f289d04/test/text_advance_test.cpp000066400000000000000000000103131475742701700237160ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "test/unit_spirv.h" namespace spvtools { namespace { using spvtest::AutoText; TEST(TextAdvance, LeadingNewLines) { AutoText input("\n\nWord"); AssemblyContext data(input, nullptr); ASSERT_EQ(SPV_SUCCESS, data.advance()); ASSERT_EQ(0u, data.position().column); ASSERT_EQ(2u, data.position().line); ASSERT_EQ(2u, data.position().index); } TEST(TextAdvance, LeadingSpaces) { AutoText input(" Word"); AssemblyContext data(input, nullptr); ASSERT_EQ(SPV_SUCCESS, data.advance()); ASSERT_EQ(4u, data.position().column); ASSERT_EQ(0u, data.position().line); ASSERT_EQ(4u, data.position().index); } TEST(TextAdvance, LeadingTabs) { AutoText input("\t\t\tWord"); AssemblyContext data(input, nullptr); ASSERT_EQ(SPV_SUCCESS, data.advance()); ASSERT_EQ(3u, data.position().column); ASSERT_EQ(0u, data.position().line); ASSERT_EQ(3u, data.position().index); } TEST(TextAdvance, LeadingNewLinesSpacesAndTabs) { AutoText input("\n\n\t Word"); AssemblyContext data(input, nullptr); ASSERT_EQ(SPV_SUCCESS, data.advance()); ASSERT_EQ(3u, data.position().column); ASSERT_EQ(2u, data.position().line); ASSERT_EQ(5u, data.position().index); } TEST(TextAdvance, LeadingWhitespaceAfterCommentLine) { AutoText input("; comment\n \t \tWord"); AssemblyContext data(input, nullptr); ASSERT_EQ(SPV_SUCCESS, data.advance()); ASSERT_EQ(4u, data.position().column); ASSERT_EQ(1u, data.position().line); ASSERT_EQ(14u, data.position().index); } TEST(TextAdvance, EOFAfterCommentLine) { AutoText input("; comment"); AssemblyContext data(input, nullptr); ASSERT_EQ(SPV_END_OF_STREAM, data.advance()); } TEST(TextAdvance, NullTerminator) { AutoText input(""); AssemblyContext data(input, nullptr); ASSERT_EQ(SPV_END_OF_STREAM, data.advance()); } TEST(TextAdvance, NoNullTerminatorAfterCommentLine) { std::string input = "; comment|padding beyond the end"; spv_text_t text = {input.data(), 9}; AssemblyContext data(&text, nullptr); ASSERT_EQ(SPV_END_OF_STREAM, data.advance()); EXPECT_EQ(9u, data.position().index); } TEST(TextAdvance, NoNullTerminator) { spv_text_t text = {"OpNop\nSomething else in memory", 6}; AssemblyContext data(&text, nullptr); const spv_position_t line_break = {1u, 5u, 5u}; data.setPosition(line_break); ASSERT_EQ(SPV_END_OF_STREAM, data.advance()); } // Invokes AssemblyContext::advance() on text, asserts success, and returns // AssemblyContext::position(). spv_position_t PositionAfterAdvance(const char* text) { AutoText input(text); AssemblyContext data(input, nullptr); EXPECT_EQ(SPV_SUCCESS, data.advance()); return data.position(); } TEST(TextAdvance, SkipOverCR) { const auto pos = PositionAfterAdvance("\rWord"); EXPECT_EQ(1u, pos.column); EXPECT_EQ(0u, pos.line); EXPECT_EQ(1u, pos.index); } TEST(TextAdvance, SkipOverCRs) { const auto pos = PositionAfterAdvance("\r\r\rWord"); EXPECT_EQ(3u, pos.column); EXPECT_EQ(0u, pos.line); EXPECT_EQ(3u, pos.index); } TEST(TextAdvance, SkipOverCRLF) { const auto pos = PositionAfterAdvance("\r\nWord"); EXPECT_EQ(0u, pos.column); EXPECT_EQ(1u, pos.line); EXPECT_EQ(2u, pos.index); } TEST(TextAdvance, SkipOverCRLFs) { const auto pos = PositionAfterAdvance("\r\n\r\nWord"); EXPECT_EQ(0u, pos.column); EXPECT_EQ(2u, pos.line); EXPECT_EQ(4u, pos.index); } TEST(TextAdvance, HandleLotsOfWhitespace) { std::string lots_of_spaces(10000, ' '); lots_of_spaces += "Word"; const auto pos = PositionAfterAdvance(lots_of_spaces.c_str()); EXPECT_EQ(10000u, pos.column); EXPECT_EQ(0u, pos.line); EXPECT_EQ(10000u, pos.index); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/text_destroy_test.cpp000066400000000000000000000044431475742701700240150ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "test/unit_spirv.h" namespace spvtools { namespace { TEST(TextDestroy, DestroyNull) { spvBinaryDestroy(nullptr); } TEST(TextDestroy, Default) { spv_context context = spvContextCreate(SPV_ENV_UNIVERSAL_1_0); char textStr[] = R"( OpSource OpenCL_C 12 OpMemoryModel Physical64 OpenCL OpSourceExtension "PlaceholderExtensionName" OpEntryPoint Kernel %0 "" OpExecutionMode %0 LocalSizeHint 1 1 1 %1 = OpTypeVoid %2 = OpTypeBool %3 = OpTypeInt 8 0 %4 = OpTypeInt 8 1 %5 = OpTypeInt 16 0 %6 = OpTypeInt 16 1 %7 = OpTypeInt 32 0 %8 = OpTypeInt 32 1 %9 = OpTypeInt 64 0 %10 = OpTypeInt 64 1 %11 = OpTypeFloat 16 %12 = OpTypeFloat 32 %13 = OpTypeFloat 64 %14 = OpTypeVector %3 2 )"; spv_binary binary = nullptr; spv_diagnostic diagnostic = nullptr; EXPECT_EQ(SPV_SUCCESS, spvTextToBinary(context, textStr, strlen(textStr), &binary, &diagnostic)); EXPECT_NE(nullptr, binary); EXPECT_NE(nullptr, binary->code); EXPECT_NE(0u, binary->wordCount); if (diagnostic) { spvDiagnosticPrint(diagnostic); ASSERT_TRUE(false); } spv_text resultText = nullptr; EXPECT_EQ(SPV_SUCCESS, spvBinaryToText(context, binary->code, binary->wordCount, 0, &resultText, &diagnostic)); spvBinaryDestroy(binary); if (diagnostic) { spvDiagnosticPrint(diagnostic); spvDiagnosticDestroy(diagnostic); ASSERT_TRUE(false); } EXPECT_NE(nullptr, resultText->str); EXPECT_NE(0u, resultText->length); spvTextDestroy(resultText); spvContextDestroy(context); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/text_literal_test.cpp000066400000000000000000000363041475742701700237610ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include "gmock/gmock.h" #include "test/test_fixture.h" #include "test/unit_spirv.h" namespace spvtools { namespace { using ::testing::Eq; TEST(TextLiteral, GoodI32) { spv_literal_t l; ASSERT_EQ(SPV_SUCCESS, spvTextToLiteral("-0", &l)); EXPECT_EQ(SPV_LITERAL_TYPE_INT_32, l.type); EXPECT_EQ(0, l.value.i32); ASSERT_EQ(SPV_SUCCESS, spvTextToLiteral("-2147483648", &l)); EXPECT_EQ(SPV_LITERAL_TYPE_INT_32, l.type); EXPECT_EQ((-2147483647L - 1), l.value.i32); } TEST(TextLiteral, GoodU32) { spv_literal_t l; ASSERT_EQ(SPV_SUCCESS, spvTextToLiteral("0", &l)); EXPECT_EQ(SPV_LITERAL_TYPE_UINT_32, l.type); EXPECT_EQ(0, l.value.i32); ASSERT_EQ(SPV_SUCCESS, spvTextToLiteral("4294967295", &l)); EXPECT_EQ(SPV_LITERAL_TYPE_UINT_32, l.type); EXPECT_EQ(4294967295, l.value.u32); } TEST(TextLiteral, GoodI64) { spv_literal_t l; ASSERT_EQ(SPV_SUCCESS, spvTextToLiteral("-2147483649", &l)); EXPECT_EQ(SPV_LITERAL_TYPE_INT_64, l.type); EXPECT_EQ(-2147483649LL, l.value.i64); } TEST(TextLiteral, GoodU64) { spv_literal_t l; ASSERT_EQ(SPV_SUCCESS, spvTextToLiteral("4294967296", &l)); EXPECT_EQ(SPV_LITERAL_TYPE_UINT_64, l.type); EXPECT_EQ(4294967296u, l.value.u64); } TEST(TextLiteral, GoodFloat) { spv_literal_t l; ASSERT_EQ(SPV_SUCCESS, spvTextToLiteral("1.0", &l)); EXPECT_EQ(SPV_LITERAL_TYPE_FLOAT_32, l.type); EXPECT_EQ(1.0, l.value.f); ASSERT_EQ(SPV_SUCCESS, spvTextToLiteral("1.5", &l)); EXPECT_EQ(SPV_LITERAL_TYPE_FLOAT_32, l.type); EXPECT_EQ(1.5, l.value.f); ASSERT_EQ(SPV_SUCCESS, spvTextToLiteral("-.25", &l)); EXPECT_EQ(SPV_LITERAL_TYPE_FLOAT_32, l.type); EXPECT_EQ(-.25, l.value.f); } TEST(TextLiteral, BadString) { spv_literal_t l; EXPECT_EQ(SPV_FAILED_MATCH, spvTextToLiteral("", &l)); EXPECT_EQ(SPV_FAILED_MATCH, spvTextToLiteral("-", &l)); EXPECT_EQ(SPV_FAILED_MATCH, spvTextToLiteral("--", &l)); EXPECT_EQ(SPV_FAILED_MATCH, spvTextToLiteral("1-2", &l)); EXPECT_EQ(SPV_FAILED_MATCH, spvTextToLiteral("123a", &l)); EXPECT_EQ(SPV_FAILED_MATCH, spvTextToLiteral("12.2.3", &l)); EXPECT_EQ(SPV_FAILED_MATCH, spvTextToLiteral("\"", &l)); EXPECT_EQ(SPV_FAILED_MATCH, spvTextToLiteral("\"z", &l)); EXPECT_EQ(SPV_FAILED_MATCH, spvTextToLiteral("a\"", &l)); } class GoodStringTest : public ::testing::TestWithParam> {}; TEST_P(GoodStringTest, GoodStrings) { spv_literal_t l; ASSERT_EQ(SPV_SUCCESS, spvTextToLiteral(std::get<0>(GetParam()), &l)); EXPECT_EQ(SPV_LITERAL_TYPE_STRING, l.type); EXPECT_EQ(std::get<1>(GetParam()), l.str); } INSTANTIATE_TEST_SUITE_P( TextLiteral, GoodStringTest, ::testing::ValuesIn(std::vector>{ {R"("-")", "-"}, {R"("--")", "--"}, {R"("1-2")", "1-2"}, {R"("123a")", "123a"}, {R"("12.2.3")", "12.2.3"}, {R"("\"")", "\""}, {R"("\\")", "\\"}, {"\"\\foo\nbar\"", "foo\nbar"}, {"\"\\foo\\\nbar\"", "foo\nbar"}, {"\"\xE4\xBA\xB2\"", "\xE4\xBA\xB2"}, {"\"\\\xE4\xBA\xB2\"", "\xE4\xBA\xB2"}, {"\"this \\\" and this \\\\ and \\\xE4\xBA\xB2\"", "this \" and this \\ and \xE4\xBA\xB2"}})); TEST(TextLiteral, StringTooLong) { spv_literal_t l; std::string too_long = std::string("\"") + std::string(SPV_LIMIT_LITERAL_STRING_BYTES_MAX + 1, 'a') + "\""; EXPECT_EQ(SPV_ERROR_OUT_OF_MEMORY, spvTextToLiteral(too_long.data(), &l)); } TEST(TextLiteral, GoodLongString) { spv_literal_t l; // The universal limit of 65535 Unicode characters might make this // fail validation, since SPV_LIMIT_LITERAL_STRING_BYTES_MAX is 4*65535. // However, as an implementation detail, we'll allow the assembler // to parse it. Otherwise we'd have to scan the string for valid UTF-8 // characters. std::string unquoted(SPV_LIMIT_LITERAL_STRING_BYTES_MAX, 'a'); std::string good_long = std::string("\"") + unquoted + "\""; EXPECT_EQ(SPV_SUCCESS, spvTextToLiteral(good_long.data(), &l)); EXPECT_EQ(SPV_LITERAL_TYPE_STRING, l.type); EXPECT_EQ(unquoted.data(), l.str); } TEST(TextLiteral, GoodUTF8String) { const std::string unquoted = spvtest::MakeLongUTF8String(SPV_LIMIT_LITERAL_STRING_UTF8_CHARS_MAX); const std::string good_long = std::string("\"") + unquoted + "\""; spv_literal_t l; EXPECT_EQ(SPV_SUCCESS, spvTextToLiteral(good_long.data(), &l)); EXPECT_EQ(SPV_LITERAL_TYPE_STRING, l.type); EXPECT_EQ(unquoted.data(), l.str); } // A test case for parsing literal numbers. struct TextLiteralCase { uint32_t bitwidth; const char* text; bool is_signed; bool success; std::vector expected_values; }; using IntegerTest = spvtest::TextToBinaryTestBase<::testing::TestWithParam>; std::vector successfulEncode(const TextLiteralCase& test, IdTypeClass type) { spv_instruction_t inst; std::string message; auto capture_message = [&message](spv_message_level_t, const char*, const spv_position_t&, const char* m) { message = m; }; IdType expected_type{test.bitwidth, test.is_signed, type}; EXPECT_EQ(SPV_SUCCESS, AssemblyContext(nullptr, capture_message) .binaryEncodeNumericLiteral(test.text, SPV_ERROR_INVALID_TEXT, expected_type, &inst)) << message; return inst.words; } std::string failedEncode(const TextLiteralCase& test, IdTypeClass type) { spv_instruction_t inst; std::string message; auto capture_message = [&message](spv_message_level_t, const char*, const spv_position_t&, const char* m) { message = m; }; IdType expected_type{test.bitwidth, test.is_signed, type}; EXPECT_EQ(SPV_ERROR_INVALID_TEXT, AssemblyContext(nullptr, capture_message) .binaryEncodeNumericLiteral(test.text, SPV_ERROR_INVALID_TEXT, expected_type, &inst)); return message; } TEST_P(IntegerTest, IntegerBounds) { if (GetParam().success) { EXPECT_THAT(successfulEncode(GetParam(), IdTypeClass::kScalarIntegerType), Eq(GetParam().expected_values)); } else { std::stringstream ss; ss << "Integer " << GetParam().text << " does not fit in a " << GetParam().bitwidth << "-bit " << (GetParam().is_signed ? "signed" : "unsigned") << " integer"; EXPECT_THAT(failedEncode(GetParam(), IdTypeClass::kScalarIntegerType), Eq(ss.str())); } } // Four nicely named methods for making TextLiteralCase values. // Their names have underscores in some places to make it easier // to read the table that follows. TextLiteralCase Make_Ok__Signed(uint32_t bitwidth, const char* text, std::vector encoding) { return TextLiteralCase{bitwidth, text, true, true, encoding}; } TextLiteralCase Make_Ok__Unsigned(uint32_t bitwidth, const char* text, std::vector encoding) { return TextLiteralCase{bitwidth, text, false, true, encoding}; } TextLiteralCase Make_Bad_Signed(uint32_t bitwidth, const char* text) { return TextLiteralCase{bitwidth, text, true, false, {}}; } TextLiteralCase Make_Bad_Unsigned(uint32_t bitwidth, const char* text) { return TextLiteralCase{bitwidth, text, false, false, {}}; } // clang-format off INSTANTIATE_TEST_SUITE_P( DecimalIntegers, IntegerTest, ::testing::ValuesIn(std::vector{ // Check max value and overflow value for 1-bit numbers. Make_Ok__Signed(1, "0", {0}), Make_Ok__Unsigned(1, "1", {1}), Make_Bad_Signed(1, "1"), Make_Bad_Unsigned(1, "2"), // Check max value and overflow value for 2-bit numbers. Make_Ok__Signed(2, "1", {1}), Make_Ok__Unsigned(2, "3", {3}), Make_Bad_Signed(2, "2"), Make_Bad_Unsigned(2, "4"), // Check max negative value and overflow value for signed // 1- and 2-bit numbers. Signed negative numbers are sign-extended. Make_Ok__Signed(1, "-0", {uint32_t(0)}), Make_Ok__Signed(1, "-1", {uint32_t(-1)}), Make_Ok__Signed(2, "-0", {0}), Make_Ok__Signed(2, "-1", {uint32_t(-1)}), Make_Ok__Signed(2, "-2", {uint32_t(-2)}), Make_Bad_Signed(2, "-3"), Make_Bad_Unsigned(2, "2224323424242424"), Make_Ok__Unsigned(16, "65535", {0xFFFF}), Make_Bad_Unsigned(16, "65536"), Make_Bad_Signed(16, "65535"), Make_Ok__Signed(16, "32767", {0x7FFF}), Make_Ok__Signed(16, "-32768", {0xFFFF8000}), // Check values around 32-bits in magnitude. Make_Ok__Unsigned(33, "4294967296", {0, 1}), Make_Ok__Unsigned(33, "4294967297", {1, 1}), Make_Bad_Unsigned(33, "8589934592"), Make_Bad_Signed(33, "4294967296"), Make_Ok__Signed(33, "-4294967296", {0x0, 0xFFFFFFFF}), Make_Ok__Unsigned(64, "4294967296", {0, 1}), Make_Ok__Unsigned(64, "4294967297", {1, 1}), // Check max value and overflow value for 64-bit numbers. Make_Ok__Signed(64, "9223372036854775807", {0xffffffff, 0x7fffffff}), Make_Bad_Signed(64, "9223372036854775808"), Make_Ok__Unsigned(64, "9223372036854775808", {0x00000000, 0x80000000}), Make_Ok__Unsigned(64, "18446744073709551615", {0xffffffff, 0xffffffff}), Make_Ok__Signed(64, "-9223372036854775808", {0x00000000, 0x80000000}), })); // clang-format on using IntegerLeadingMinusTest = spvtest::TextToBinaryTestBase<::testing::TestWithParam>; TEST_P(IntegerLeadingMinusTest, CantHaveLeadingMinusOnUnsigned) { EXPECT_FALSE(GetParam().success); EXPECT_THAT(failedEncode(GetParam(), IdTypeClass::kScalarIntegerType), Eq("Cannot put a negative number in an unsigned literal")); } // clang-format off INSTANTIATE_TEST_SUITE_P( DecimalAndHexIntegers, IntegerLeadingMinusTest, ::testing::ValuesIn(std::vector{ // Unsigned numbers never allow a leading minus sign. Make_Bad_Unsigned(16, "-0"), Make_Bad_Unsigned(16, "-0x0"), Make_Bad_Unsigned(16, "-0x1"), Make_Bad_Unsigned(32, "-0"), Make_Bad_Unsigned(32, "-0x0"), Make_Bad_Unsigned(32, "-0x1"), Make_Bad_Unsigned(64, "-0"), Make_Bad_Unsigned(64, "-0x0"), Make_Bad_Unsigned(64, "-0x1"), })); // clang-format off INSTANTIATE_TEST_SUITE_P( HexIntegers, IntegerTest, ::testing::ValuesIn(std::vector{ // Check 0x and 0X prefices. Make_Ok__Signed(16, "0x1234", {0x1234}), Make_Ok__Signed(16, "0X1234", {0x1234}), // Check 1-bit numbers Make_Ok__Signed(1, "0x0", {0}), Make_Ok__Signed(1, "0x1", {uint32_t(-1)}), Make_Ok__Unsigned(1, "0x0", {0}), Make_Ok__Unsigned(1, "0x1", {1}), Make_Bad_Signed(1, "0x2"), Make_Bad_Unsigned(1, "0x2"), // Check 2-bit numbers Make_Ok__Signed(2, "0x0", {0}), Make_Ok__Signed(2, "0x1", {1}), Make_Ok__Signed(2, "0x2", {uint32_t(-2)}), Make_Ok__Signed(2, "0x3", {uint32_t(-1)}), Make_Ok__Unsigned(2, "0x0", {0}), Make_Ok__Unsigned(2, "0x1", {1}), Make_Ok__Unsigned(2, "0x2", {2}), Make_Ok__Unsigned(2, "0x3", {3}), Make_Bad_Signed(2, "0x4"), Make_Bad_Unsigned(2, "0x4"), // Check 8-bit numbers Make_Ok__Signed(8, "0x7f", {0x7f}), Make_Ok__Signed(8, "0x80", {0xffffff80}), Make_Ok__Unsigned(8, "0x80", {0x80}), Make_Ok__Unsigned(8, "0xff", {0xff}), Make_Bad_Signed(8, "0x100"), Make_Bad_Unsigned(8, "0x100"), // Check 16-bit numbers Make_Ok__Signed(16, "0x7fff", {0x7fff}), Make_Ok__Signed(16, "0x8000", {0xffff8000}), Make_Ok__Unsigned(16, "0x8000", {0x8000}), Make_Ok__Unsigned(16, "0xffff", {0xffff}), Make_Bad_Signed(16, "0x10000"), Make_Bad_Unsigned(16, "0x10000"), // Check 32-bit numbers Make_Ok__Signed(32, "0x7fffffff", {0x7fffffff}), Make_Ok__Signed(32, "0x80000000", {0x80000000}), Make_Ok__Unsigned(32, "0x80000000", {0x80000000}), Make_Ok__Unsigned(32, "0xffffffff", {0xffffffff}), Make_Bad_Signed(32, "0x100000000"), Make_Bad_Unsigned(32, "0x100000000"), // Check 48-bit numbers Make_Ok__Unsigned(48, "0x7ffffffff", {0xffffffff, 7}), Make_Ok__Unsigned(48, "0x800000000", {0, 8}), Make_Ok__Signed(48, "0x7fffffffffff", {0xffffffff, 0x7fff}), Make_Ok__Signed(48, "0x800000000000", {0, 0xffff8000}), Make_Bad_Signed(48, "0x1000000000000"), Make_Bad_Unsigned(48, "0x1000000000000"), // Check 64-bit numbers Make_Ok__Signed(64, "0x7fffffffffffffff", {0xffffffff, 0x7fffffff}), Make_Ok__Signed(64, "0x8000000000000000", {0x00000000, 0x80000000}), Make_Ok__Unsigned(64, "0x7fffffffffffffff", {0xffffffff, 0x7fffffff}), Make_Ok__Unsigned(64, "0x8000000000000000", {0x00000000, 0x80000000}), })); // clang-format on TEST(OverflowIntegerParse, Decimal) { std::string signed_input = "-18446744073709551616"; std::string expected_message0 = "Invalid signed integer literal: " + signed_input; EXPECT_THAT(failedEncode(Make_Bad_Signed(64, signed_input.c_str()), IdTypeClass::kScalarIntegerType), Eq(expected_message0)); std::string unsigned_input = "18446744073709551616"; std::string expected_message1 = "Invalid unsigned integer literal: " + unsigned_input; EXPECT_THAT(failedEncode(Make_Bad_Unsigned(64, unsigned_input.c_str()), IdTypeClass::kScalarIntegerType), Eq(expected_message1)); // TODO(dneto): When the given number doesn't have a leading sign, // we say we're trying to parse an unsigned number, even when the caller // asked for a signed number. This is kind of weird, but it's an // artefact of how we do the parsing. EXPECT_THAT(failedEncode(Make_Bad_Signed(64, unsigned_input.c_str()), IdTypeClass::kScalarIntegerType), Eq(expected_message1)); } TEST(OverflowIntegerParse, Hex) { std::string input = "0x10000000000000000"; std::string expected_message = "Invalid unsigned integer literal: " + input; EXPECT_THAT(failedEncode(Make_Bad_Signed(64, input.c_str()), IdTypeClass::kScalarIntegerType), Eq(expected_message)); EXPECT_THAT(failedEncode(Make_Bad_Unsigned(64, input.c_str()), IdTypeClass::kScalarIntegerType), Eq(expected_message)); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/text_start_new_inst_test.cpp000066400000000000000000000046311475742701700253660ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "test/unit_spirv.h" namespace spvtools { namespace { using spvtest::AutoText; TEST(TextStartsWithOp, YesAtStart) { EXPECT_TRUE(AssemblyContext(AutoText("OpFoo"), nullptr).isStartOfNewInst()); EXPECT_TRUE(AssemblyContext(AutoText("OpFoo"), nullptr).isStartOfNewInst()); EXPECT_TRUE(AssemblyContext(AutoText("OpEnCL"), nullptr).isStartOfNewInst()); } TEST(TextStartsWithOp, YesAtMiddle) { { AutoText text(" OpFoo"); AssemblyContext dat(text, nullptr); dat.seekForward(2); EXPECT_TRUE(dat.isStartOfNewInst()); } { AutoText text("xx OpFoo"); AssemblyContext dat(text, nullptr); dat.seekForward(2); EXPECT_TRUE(dat.isStartOfNewInst()); } } TEST(TextStartsWithOp, NoIfTooFar) { AutoText text(" OpFoo"); AssemblyContext dat(text, nullptr); dat.seekForward(3); EXPECT_FALSE(dat.isStartOfNewInst()); } TEST(TextStartsWithOp, NoRegular) { EXPECT_FALSE( AssemblyContext(AutoText("Fee Fi Fo Fum"), nullptr).isStartOfNewInst()); EXPECT_FALSE(AssemblyContext(AutoText("123456"), nullptr).isStartOfNewInst()); EXPECT_FALSE(AssemblyContext(AutoText("123456"), nullptr).isStartOfNewInst()); EXPECT_FALSE(AssemblyContext(AutoText("OpenCL"), nullptr).isStartOfNewInst()); } TEST(TextStartsWithOp, YesForValueGenerationForm) { EXPECT_TRUE( AssemblyContext(AutoText("%foo = OpAdd"), nullptr).isStartOfNewInst()); EXPECT_TRUE( AssemblyContext(AutoText("%foo = OpAdd"), nullptr).isStartOfNewInst()); } TEST(TextStartsWithOp, NoForNearlyValueGeneration) { EXPECT_FALSE( AssemblyContext(AutoText("%foo = "), nullptr).isStartOfNewInst()); EXPECT_FALSE(AssemblyContext(AutoText("%foo "), nullptr).isStartOfNewInst()); EXPECT_FALSE(AssemblyContext(AutoText("%foo"), nullptr).isStartOfNewInst()); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/text_to_binary.annotation_test.cpp000066400000000000000000000542061475742701700264650ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Assembler tests for instructions in the "Annotation" section of the // SPIR-V spec. #include #include #include #include #include "gmock/gmock.h" #include "source/util/string_utils.h" #include "test/test_fixture.h" #include "test/unit_spirv.h" namespace spvtools { namespace { using spvtest::EnumCase; using spvtest::MakeInstruction; using utils::MakeVector; using spvtest::TextToBinaryTest; using ::testing::Combine; using ::testing::Eq; using ::testing::Values; using ::testing::ValuesIn; // Test OpDecorate using OpDecorateSimpleTest = spvtest::TextToBinaryTestBase<::testing::TestWithParam< std::tuple>>>; TEST_P(OpDecorateSimpleTest, AnySimpleDecoration) { // This string should assemble, but should not validate. std::stringstream input; input << "OpDecorate %1 " << std::get<1>(GetParam()).name(); for (auto operand : std::get<1>(GetParam()).operands()) input << " " << operand; input << std::endl; EXPECT_THAT(CompiledInstructions(input.str(), std::get<0>(GetParam())), Eq(MakeInstruction(spv::Op::OpDecorate, {1, uint32_t(std::get<1>(GetParam()).value())}, std::get<1>(GetParam()).operands()))); // Also check disassembly. EXPECT_THAT(EncodeAndDecodeSuccessfully( input.str(), SPV_BINARY_TO_TEXT_OPTION_NONE, SPV_TEXT_TO_BINARY_OPTION_NONE, std::get<0>(GetParam())), Eq(input.str())); } // Like above, but parameters to the decoration are IDs. using OpDecorateSimpleIdTest = spvtest::TextToBinaryTestBase<::testing::TestWithParam< std::tuple>>>; TEST_P(OpDecorateSimpleIdTest, AnySimpleDecoration) { // This string should assemble, but should not validate. std::stringstream input; input << "OpDecorateId %1 " << std::get<1>(GetParam()).name(); for (auto operand : std::get<1>(GetParam()).operands()) input << " %" << operand; input << std::endl; EXPECT_THAT(CompiledInstructions(input.str(), std::get<0>(GetParam())), Eq(MakeInstruction(spv::Op::OpDecorateId, {1, uint32_t(std::get<1>(GetParam()).value())}, std::get<1>(GetParam()).operands()))); // Also check disassembly. EXPECT_THAT(EncodeAndDecodeSuccessfully( input.str(), SPV_BINARY_TO_TEXT_OPTION_NONE, SPV_TEXT_TO_BINARY_OPTION_NONE, std::get<0>(GetParam())), Eq(input.str())); } #define CASE(NAME) spv::Decoration::NAME, #NAME INSTANTIATE_TEST_SUITE_P( TextToBinaryDecorateSimple, OpDecorateSimpleTest, Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), ValuesIn(std::vector>{ // The operand literal values are arbitrarily chosen, // but there are the right number of them. {CASE(RelaxedPrecision), {}}, {CASE(SpecId), {100}}, {CASE(Block), {}}, {CASE(BufferBlock), {}}, {CASE(RowMajor), {}}, {CASE(ColMajor), {}}, {CASE(ArrayStride), {4}}, {CASE(MatrixStride), {16}}, {CASE(GLSLShared), {}}, {CASE(GLSLPacked), {}}, {CASE(CPacked), {}}, // Placeholder line for enum value 12 {CASE(NoPerspective), {}}, {CASE(Flat), {}}, {CASE(Patch), {}}, {CASE(Centroid), {}}, {CASE(Sample), {}}, {CASE(Invariant), {}}, {CASE(Restrict), {}}, {CASE(Aliased), {}}, {CASE(Volatile), {}}, {CASE(Constant), {}}, {CASE(Coherent), {}}, {CASE(NonWritable), {}}, {CASE(NonReadable), {}}, {CASE(Uniform), {}}, {CASE(SaturatedConversion), {}}, {CASE(Stream), {2}}, {CASE(Location), {6}}, {CASE(Component), {3}}, {CASE(Index), {14}}, {CASE(Binding), {19}}, {CASE(DescriptorSet), {7}}, {CASE(Offset), {12}}, {CASE(XfbBuffer), {1}}, {CASE(XfbStride), {8}}, {CASE(NoContraction), {}}, {CASE(InputAttachmentIndex), {102}}, {CASE(Alignment), {16}}, }))); INSTANTIATE_TEST_SUITE_P(TextToBinaryDecorateSimpleV11, OpDecorateSimpleTest, Combine(Values(SPV_ENV_UNIVERSAL_1_1), Values(EnumCase{ CASE(MaxByteOffset), {128}}))); INSTANTIATE_TEST_SUITE_P( TextToBinaryDecorateSimpleV14, OpDecorateSimpleTest, Combine(Values(SPV_ENV_UNIVERSAL_1_4), ValuesIn(std::vector>{ {CASE(Uniform), {}}, }))); INSTANTIATE_TEST_SUITE_P( TextToBinaryDecorateSimpleIdV14, OpDecorateSimpleIdTest, Combine(Values(SPV_ENV_UNIVERSAL_1_4), ValuesIn(std::vector>{ // In 1.4, UniformId decoration takes a // scope Id. {CASE(UniformId), {1}}, }))); #undef CASE TEST_F(OpDecorateSimpleTest, WrongDecoration) { EXPECT_THAT(CompileFailure("OpDecorate %1 xxyyzz"), Eq("Invalid decoration 'xxyyzz'.")); } TEST_F(OpDecorateSimpleTest, ExtraOperandsOnDecorationExpectingNone) { EXPECT_THAT(CompileFailure("OpDecorate %1 RelaxedPrecision 99"), Eq("Expected or at the beginning of an " "instruction, found '99'.")); } TEST_F(OpDecorateSimpleTest, ExtraOperandsOnDecorationExpectingOne) { EXPECT_THAT(CompileFailure("OpDecorate %1 SpecId 99 100"), Eq("Expected or at the beginning of an " "instruction, found '100'.")); } TEST_F(OpDecorateSimpleTest, ExtraOperandsOnDecorationExpectingTwo) { EXPECT_THAT( CompileFailure("OpDecorate %1 LinkageAttributes \"abc\" Import 42"), Eq("Expected or at the beginning of an " "instruction, found '42'.")); } // A single test case for an enum decoration. struct DecorateEnumCase { // Place the enum value first, so it's easier to read the binary dumps when // the test fails. uint32_t value; // The value within the enum, e.g. Position std::string name; uint32_t enum_value; // Which enum, e.g. BuiltIn std::string enum_name; }; using OpDecorateEnumTest = spvtest::TextToBinaryTestBase<::testing::TestWithParam>; TEST_P(OpDecorateEnumTest, AnyEnumDecoration) { // This string should assemble, but should not validate. const std::string input = "OpDecorate %1 " + GetParam().enum_name + " " + GetParam().name; EXPECT_THAT(CompiledInstructions(input), Eq(MakeInstruction(spv::Op::OpDecorate, {1, GetParam().enum_value, GetParam().value}))); } // Test OpDecorate BuiltIn. // clang-format off #define CASE(NAME) \ { uint32_t(spv::BuiltIn::NAME), #NAME, uint32_t(spv::Decoration::BuiltIn), "BuiltIn" } INSTANTIATE_TEST_SUITE_P(TextToBinaryDecorateBuiltIn, OpDecorateEnumTest, ::testing::ValuesIn(std::vector{ CASE(Position), CASE(PointSize), CASE(ClipDistance), CASE(CullDistance), CASE(VertexId), CASE(InstanceId), CASE(PrimitiveId), CASE(InvocationId), CASE(Layer), CASE(ViewportIndex), CASE(TessLevelOuter), CASE(TessLevelInner), CASE(TessCoord), CASE(PatchVertices), CASE(FragCoord), CASE(PointCoord), CASE(FrontFacing), CASE(SampleId), CASE(SamplePosition), CASE(SampleMask), // Value 21 intentionally missing. CASE(FragDepth), CASE(HelperInvocation), CASE(NumWorkgroups), CASE(WorkgroupSize), CASE(WorkgroupId), CASE(LocalInvocationId), CASE(GlobalInvocationId), CASE(LocalInvocationIndex), CASE(WorkDim), CASE(GlobalSize), CASE(EnqueuedWorkgroupSize), CASE(GlobalOffset), CASE(GlobalLinearId), // Value 35 intentionally missing. CASE(SubgroupSize), CASE(SubgroupMaxSize), CASE(NumSubgroups), CASE(NumEnqueuedSubgroups), CASE(SubgroupId), CASE(SubgroupLocalInvocationId), CASE(VertexIndex), CASE(InstanceIndex), })); #undef CASE // clang-format on TEST_F(OpDecorateEnumTest, WrongBuiltIn) { EXPECT_THAT(CompileFailure("OpDecorate %1 BuiltIn xxyyzz"), Eq("Invalid built-in 'xxyyzz'.")); } // Test OpDecorate FuncParamAttr // clang-format off #define CASE(NAME) \ { uint32_t(spv::FunctionParameterAttribute::NAME), #NAME, uint32_t(spv::Decoration::FuncParamAttr), "FuncParamAttr" } INSTANTIATE_TEST_SUITE_P(TextToBinaryDecorateFuncParamAttr, OpDecorateEnumTest, ::testing::ValuesIn(std::vector{ CASE(Zext), CASE(Sext), CASE(ByVal), CASE(Sret), CASE(NoAlias), CASE(NoCapture), CASE(NoWrite), CASE(NoReadWrite), })); #undef CASE // clang-format on TEST_F(OpDecorateEnumTest, WrongFuncParamAttr) { EXPECT_THAT(CompileFailure("OpDecorate %1 FuncParamAttr xxyyzz"), Eq("Invalid function parameter attribute 'xxyyzz'.")); } // Test OpDecorate FPRoundingMode // clang-format off #define CASE(NAME) \ { uint32_t(spv::FPRoundingMode::NAME), #NAME, uint32_t(spv::Decoration::FPRoundingMode), "FPRoundingMode" } INSTANTIATE_TEST_SUITE_P(TextToBinaryDecorateFPRoundingMode, OpDecorateEnumTest, ::testing::ValuesIn(std::vector{ CASE(RTE), CASE(RTZ), CASE(RTP), CASE(RTN), })); #undef CASE // clang-format on TEST_F(OpDecorateEnumTest, WrongFPRoundingMode) { EXPECT_THAT(CompileFailure("OpDecorate %1 FPRoundingMode xxyyzz"), Eq("Invalid floating-point rounding mode 'xxyyzz'.")); } // Test OpDecorate FPFastMathMode. // These can by named enums for the single-bit masks. However, we don't support // symbolic combinations of the masks. Rather, they can use ! // syntax, e.g. !0x3 // clang-format off #define CASE(ENUM,NAME) \ { uint32_t(spv::FPFastMathModeMask::ENUM), #NAME, uint32_t(spv::Decoration::FPFastMathMode), "FPFastMathMode" } INSTANTIATE_TEST_SUITE_P(TextToBinaryDecorateFPFastMathMode, OpDecorateEnumTest, ::testing::ValuesIn(std::vector{ CASE(MaskNone, None), CASE(NotNaN, NotNaN), CASE(NotInf, NotInf), CASE(NSZ, NSZ), CASE(AllowRecip, AllowRecip), CASE(Fast, Fast), })); #undef CASE // clang-format on TEST_F(OpDecorateEnumTest, CombinedFPFastMathMask) { // Sample a single combination. This ensures we've integrated // the instruction parsing logic with spvTextParseMask. const std::string input = "OpDecorate %1 FPFastMathMode NotNaN|NotInf|NSZ"; const uint32_t expected_enum = uint32_t(spv::Decoration::FPFastMathMode); const uint32_t expected_mask = uint32_t(spv::FPFastMathModeMask::NotNaN) | uint32_t(spv::FPFastMathModeMask::NotInf) | uint32_t(spv::FPFastMathModeMask::NSZ); EXPECT_THAT(CompiledInstructions(input), Eq(MakeInstruction(spv::Op::OpDecorate, {1, expected_enum, expected_mask}))); } TEST_F(OpDecorateEnumTest, WrongFPFastMathMode) { EXPECT_THAT( CompileFailure("OpDecorate %1 FPFastMathMode NotNaN|xxyyzz"), Eq("Invalid floating-point fast math mode operand 'NotNaN|xxyyzz'.")); } // Test OpDecorate Linkage // A single test case for a linkage struct DecorateLinkageCase { uint32_t linkage_type_value; std::string linkage_type_name; std::string external_name; }; using OpDecorateLinkageTest = spvtest::TextToBinaryTestBase< ::testing::TestWithParam>; TEST_P(OpDecorateLinkageTest, AnyLinkageDecoration) { // This string should assemble, but should not validate. const std::string input = "OpDecorate %1 LinkageAttributes \"" + GetParam().external_name + "\" " + GetParam().linkage_type_name; std::vector expected_operands{ 1, uint32_t(spv::Decoration::LinkageAttributes)}; std::vector encoded_external_name = MakeVector(GetParam().external_name); expected_operands.insert(expected_operands.end(), encoded_external_name.begin(), encoded_external_name.end()); expected_operands.push_back(GetParam().linkage_type_value); EXPECT_THAT(CompiledInstructions(input), Eq(MakeInstruction(spv::Op::OpDecorate, expected_operands))); } // clang-format off #define CASE(ENUM) uint32_t(spv::LinkageType::ENUM), #ENUM INSTANTIATE_TEST_SUITE_P(TextToBinaryDecorateLinkage, OpDecorateLinkageTest, ::testing::ValuesIn(std::vector{ { CASE(Import), "a" }, { CASE(Export), "foo" }, { CASE(Import), "some kind of long name with spaces etc." }, // TODO(dneto): utf-8, escaping, quoting cases. })); #undef CASE // clang-format on TEST_F(OpDecorateLinkageTest, WrongType) { EXPECT_THAT(CompileFailure("OpDecorate %1 LinkageAttributes \"foo\" xxyyzz"), Eq("Invalid linkage type 'xxyyzz'.")); } // Test OpGroupMemberDecorate TEST_F(TextToBinaryTest, GroupMemberDecorateGoodOneTarget) { EXPECT_THAT(CompiledInstructions("OpGroupMemberDecorate %group %id0 42"), Eq(MakeInstruction(spv::Op::OpGroupMemberDecorate, {1, 2, 42}))); } TEST_F(TextToBinaryTest, GroupMemberDecorateGoodTwoTargets) { EXPECT_THAT( CompiledInstructions("OpGroupMemberDecorate %group %id0 96 %id1 42"), Eq(MakeInstruction(spv::Op::OpGroupMemberDecorate, {1, 2, 96, 3, 42}))); } TEST_F(TextToBinaryTest, GroupMemberDecorateMissingGroupId) { EXPECT_THAT(CompileFailure("OpGroupMemberDecorate"), Eq("Expected operand for OpGroupMemberDecorate instruction, but " "found the end of the stream.")); } TEST_F(TextToBinaryTest, GroupMemberDecorateInvalidGroupId) { EXPECT_THAT(CompileFailure("OpGroupMemberDecorate 16"), Eq("Expected id to start with %.")); } TEST_F(TextToBinaryTest, GroupMemberDecorateInvalidTargetId) { EXPECT_THAT(CompileFailure("OpGroupMemberDecorate %group 12"), Eq("Expected id to start with %.")); } TEST_F(TextToBinaryTest, GroupMemberDecorateMissingTargetMemberNumber) { EXPECT_THAT(CompileFailure("OpGroupMemberDecorate %group %id0"), Eq("Expected operand for OpGroupMemberDecorate instruction, but " "found the end of the stream.")); } TEST_F(TextToBinaryTest, GroupMemberDecorateInvalidTargetMemberNumber) { EXPECT_THAT(CompileFailure("OpGroupMemberDecorate %group %id0 %id1"), Eq("Invalid unsigned integer literal: %id1")); } TEST_F(TextToBinaryTest, GroupMemberDecorateInvalidSecondTargetId) { EXPECT_THAT(CompileFailure("OpGroupMemberDecorate %group %id1 42 12"), Eq("Expected id to start with %.")); } TEST_F(TextToBinaryTest, GroupMemberDecorateMissingSecondTargetMemberNumber) { EXPECT_THAT(CompileFailure("OpGroupMemberDecorate %group %id0 42 %id1"), Eq("Expected operand for OpGroupMemberDecorate instruction, but " "found the end of the stream.")); } TEST_F(TextToBinaryTest, GroupMemberDecorateInvalidSecondTargetMemberNumber) { EXPECT_THAT(CompileFailure("OpGroupMemberDecorate %group %id0 42 %id1 %id2"), Eq("Invalid unsigned integer literal: %id2")); } // Test OpMemberDecorate using OpMemberDecorateSimpleTest = spvtest::TextToBinaryTestBase<::testing::TestWithParam< std::tuple>>>; TEST_P(OpMemberDecorateSimpleTest, AnySimpleDecoration) { // This string should assemble, but should not validate. std::stringstream input; input << "OpMemberDecorate %1 42 " << std::get<1>(GetParam()).name(); for (auto operand : std::get<1>(GetParam()).operands()) input << " " << operand; input << std::endl; EXPECT_THAT( CompiledInstructions(input.str(), std::get<0>(GetParam())), Eq(MakeInstruction(spv::Op::OpMemberDecorate, {1, 42, uint32_t(std::get<1>(GetParam()).value())}, std::get<1>(GetParam()).operands()))); // Also check disassembly. EXPECT_THAT(EncodeAndDecodeSuccessfully( input.str(), SPV_BINARY_TO_TEXT_OPTION_NONE, SPV_TEXT_TO_BINARY_OPTION_NONE, std::get<0>(GetParam())), Eq(input.str())); } #define CASE(NAME) spv::Decoration::NAME, #NAME INSTANTIATE_TEST_SUITE_P( TextToBinaryDecorateSimple, OpMemberDecorateSimpleTest, Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), ValuesIn(std::vector>{ // The operand literal values are arbitrarily chosen, // but there are the right number of them. {CASE(RelaxedPrecision), {}}, {CASE(SpecId), {100}}, {CASE(Block), {}}, {CASE(BufferBlock), {}}, {CASE(RowMajor), {}}, {CASE(ColMajor), {}}, {CASE(ArrayStride), {4}}, {CASE(MatrixStride), {16}}, {CASE(GLSLShared), {}}, {CASE(GLSLPacked), {}}, {CASE(CPacked), {}}, // Placeholder line for enum value 12 {CASE(NoPerspective), {}}, {CASE(Flat), {}}, {CASE(Patch), {}}, {CASE(Centroid), {}}, {CASE(Sample), {}}, {CASE(Invariant), {}}, {CASE(Restrict), {}}, {CASE(Aliased), {}}, {CASE(Volatile), {}}, {CASE(Constant), {}}, {CASE(Coherent), {}}, {CASE(NonWritable), {}}, {CASE(NonReadable), {}}, {CASE(Uniform), {}}, {CASE(SaturatedConversion), {}}, {CASE(Stream), {2}}, {CASE(Location), {6}}, {CASE(Component), {3}}, {CASE(Index), {14}}, {CASE(Binding), {19}}, {CASE(DescriptorSet), {7}}, {CASE(Offset), {12}}, {CASE(XfbBuffer), {1}}, {CASE(XfbStride), {8}}, {CASE(NoContraction), {}}, {CASE(InputAttachmentIndex), {102}}, {CASE(Alignment), {16}}, }))); INSTANTIATE_TEST_SUITE_P( TextToBinaryDecorateSimpleV11, OpMemberDecorateSimpleTest, Combine(Values(SPV_ENV_UNIVERSAL_1_1), Values(EnumCase{CASE(MaxByteOffset), {128}}))); #undef CASE TEST_F(OpMemberDecorateSimpleTest, WrongDecoration) { EXPECT_THAT(CompileFailure("OpMemberDecorate %1 9 xxyyzz"), Eq("Invalid decoration 'xxyyzz'.")); } TEST_F(OpMemberDecorateSimpleTest, ExtraOperandsOnDecorationExpectingNone) { EXPECT_THAT(CompileFailure("OpMemberDecorate %1 12 RelaxedPrecision 99"), Eq("Expected or at the beginning of an " "instruction, found '99'.")); } TEST_F(OpMemberDecorateSimpleTest, ExtraOperandsOnDecorationExpectingOne) { EXPECT_THAT(CompileFailure("OpMemberDecorate %1 0 SpecId 99 100"), Eq("Expected or at the beginning of an " "instruction, found '100'.")); } TEST_F(OpMemberDecorateSimpleTest, ExtraOperandsOnDecorationExpectingTwo) { EXPECT_THAT(CompileFailure( "OpMemberDecorate %1 1 LinkageAttributes \"abc\" Import 42"), Eq("Expected or at the beginning of an " "instruction, found '42'.")); } // TODO(dneto): OpMemberDecorate cases for decorations with parameters which // are: not just lists of literal numbers. // TODO(dneto): OpDecorationGroup // TODO(dneto): OpGroupDecorate } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/text_to_binary.barrier_test.cpp000066400000000000000000000154231475742701700257370ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Assembler tests for instructions in the "Barrier Instructions" section // of the SPIR-V spec. #include #include "gmock/gmock.h" #include "test/test_fixture.h" #include "test/unit_spirv.h" namespace spvtools { namespace { using spvtest::MakeInstruction; using spvtest::TextToBinaryTest; using ::testing::_; using ::testing::ElementsAre; using ::testing::Eq; // Test OpMemoryBarrier using OpMemoryBarrier = spvtest::TextToBinaryTest; TEST_F(OpMemoryBarrier, Good) { const std::string input = "OpMemoryBarrier %1 %2\n"; EXPECT_THAT(CompiledInstructions(input), Eq(MakeInstruction(spv::Op::OpMemoryBarrier, {1, 2}))); EXPECT_THAT(EncodeAndDecodeSuccessfully(input), Eq(input)); } TEST_F(OpMemoryBarrier, BadMissingScopeId) { const std::string input = "OpMemoryBarrier\n"; EXPECT_THAT(CompileFailure(input), Eq("Expected operand for OpMemoryBarrier instruction, but found " "the end of the stream.")); } TEST_F(OpMemoryBarrier, BadInvalidScopeId) { const std::string input = "OpMemoryBarrier 99\n"; EXPECT_THAT(CompileFailure(input), Eq("Expected id to start with %.")); } TEST_F(OpMemoryBarrier, BadMissingMemorySemanticsId) { const std::string input = "OpMemoryBarrier %scope\n"; EXPECT_THAT(CompileFailure(input), Eq("Expected operand for OpMemoryBarrier instruction, but found " "the end of the stream.")); } TEST_F(OpMemoryBarrier, BadInvalidMemorySemanticsId) { const std::string input = "OpMemoryBarrier %scope 14\n"; EXPECT_THAT(CompileFailure(input), Eq("Expected id to start with %.")); } // TODO(dneto): OpControlBarrier // TODO(dneto): OpGroupAsyncCopy // TODO(dneto): OpGroupWaitEvents // TODO(dneto): OpGroupAll // TODO(dneto): OpGroupAny // TODO(dneto): OpGroupBroadcast // TODO(dneto): OpGroupIAdd // TODO(dneto): OpGroupFAdd // TODO(dneto): OpGroupFMin // TODO(dneto): OpGroupUMin // TODO(dneto): OpGroupSMin // TODO(dneto): OpGroupFMax // TODO(dneto): OpGroupUMax // TODO(dneto): OpGroupSMax using NamedMemoryBarrierTest = spvtest::TextToBinaryTest; // OpMemoryNamedBarrier is not in 1.0, but it is enabled by a capability. // We should be able to assemble it. Validation checks are in another test // file. TEST_F(NamedMemoryBarrierTest, OpcodeAssemblesInV10) { EXPECT_THAT( CompiledInstructions("OpMemoryNamedBarrier %bar %scope %semantics", SPV_ENV_UNIVERSAL_1_0), ElementsAre(spvOpcodeMake(4, spv::Op::OpMemoryNamedBarrier), _, _, _)); } TEST_F(NamedMemoryBarrierTest, ArgumentCount) { EXPECT_THAT(CompileFailure("OpMemoryNamedBarrier", SPV_ENV_UNIVERSAL_1_1), Eq("Expected operand for OpMemoryNamedBarrier instruction, but " "found the end of the stream.")); EXPECT_THAT( CompileFailure("OpMemoryNamedBarrier %bar", SPV_ENV_UNIVERSAL_1_1), Eq("Expected operand for OpMemoryNamedBarrier instruction, but found the " "end of the stream.")); EXPECT_THAT( CompileFailure("OpMemoryNamedBarrier %bar %scope", SPV_ENV_UNIVERSAL_1_1), Eq("Expected operand for OpMemoryNamedBarrier instruction, but found the " "end of the stream.")); EXPECT_THAT( CompiledInstructions("OpMemoryNamedBarrier %bar %scope %semantics", SPV_ENV_UNIVERSAL_1_1), ElementsAre(spvOpcodeMake(4, spv::Op::OpMemoryNamedBarrier), _, _, _)); EXPECT_THAT( CompileFailure("OpMemoryNamedBarrier %bar %scope %semantics %extra", SPV_ENV_UNIVERSAL_1_1), Eq("Expected '=', found end of stream.")); } TEST_F(NamedMemoryBarrierTest, ArgumentTypes) { EXPECT_THAT(CompileFailure("OpMemoryNamedBarrier 123 %scope %semantics", SPV_ENV_UNIVERSAL_1_1), Eq("Expected id to start with %.")); EXPECT_THAT(CompileFailure("OpMemoryNamedBarrier %bar %scope \"semantics\"", SPV_ENV_UNIVERSAL_1_1), Eq("Expected id to start with %.")); } using TypeNamedBarrierTest = spvtest::TextToBinaryTest; TEST_F(TypeNamedBarrierTest, OpcodeAssemblesInV10) { EXPECT_THAT( CompiledInstructions("%t = OpTypeNamedBarrier", SPV_ENV_UNIVERSAL_1_0), ElementsAre(spvOpcodeMake(2, spv::Op::OpTypeNamedBarrier), _)); } TEST_F(TypeNamedBarrierTest, ArgumentCount) { EXPECT_THAT(CompileFailure("OpTypeNamedBarrier", SPV_ENV_UNIVERSAL_1_1), Eq("Expected at the beginning of an instruction, " "found 'OpTypeNamedBarrier'.")); EXPECT_THAT( CompiledInstructions("%t = OpTypeNamedBarrier", SPV_ENV_UNIVERSAL_1_1), ElementsAre(spvOpcodeMake(2, spv::Op::OpTypeNamedBarrier), _)); EXPECT_THAT( CompileFailure("%t = OpTypeNamedBarrier 1 2 3", SPV_ENV_UNIVERSAL_1_1), Eq("Expected or at the beginning of an instruction, " "found '1'.")); } using NamedBarrierInitializeTest = spvtest::TextToBinaryTest; TEST_F(NamedBarrierInitializeTest, OpcodeAssemblesInV10) { EXPECT_THAT( CompiledInstructions("%bar = OpNamedBarrierInitialize %type %count", SPV_ENV_UNIVERSAL_1_0), ElementsAre(spvOpcodeMake(4, spv::Op::OpNamedBarrierInitialize), _, _, _)); } TEST_F(NamedBarrierInitializeTest, ArgumentCount) { EXPECT_THAT( CompileFailure("%bar = OpNamedBarrierInitialize", SPV_ENV_UNIVERSAL_1_1), Eq("Expected operand for OpNamedBarrierInitialize instruction, but found " "the end of the stream.")); EXPECT_THAT(CompileFailure("%bar = OpNamedBarrierInitialize %ype", SPV_ENV_UNIVERSAL_1_1), Eq("Expected operand for OpNamedBarrierInitialize instruction, " "but found the end of the stream.")); EXPECT_THAT( CompiledInstructions("%bar = OpNamedBarrierInitialize %type %count", SPV_ENV_UNIVERSAL_1_1), ElementsAre(spvOpcodeMake(4, spv::Op::OpNamedBarrierInitialize), _, _, _)); EXPECT_THAT( CompileFailure("%bar = OpNamedBarrierInitialize %type %count \"extra\"", SPV_ENV_UNIVERSAL_1_1), Eq("Expected or at the beginning of an instruction, " "found '\"extra\"'.")); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/text_to_binary.composite_test.cpp000066400000000000000000000030041475742701700263030ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Assembler tests for instructions in the "Group Instrucions" section of the // SPIR-V spec. #include #include #include "gmock/gmock.h" #include "test/test_fixture.h" #include "test/unit_spirv.h" using ::testing::Eq; using ::testing::HasSubstr; namespace spvtools { namespace { using spvtest::Concatenate; using CompositeRoundTripTest = RoundTripTest; TEST_F(CompositeRoundTripTest, Good) { std::string spirv = "%2 = OpCopyLogical %1 %3\n"; std::string disassembly = EncodeAndDecodeSuccessfully( spirv, SPV_BINARY_TO_TEXT_OPTION_NONE, SPV_TEXT_TO_BINARY_OPTION_NONE, SPV_ENV_UNIVERSAL_1_4); EXPECT_THAT(disassembly, Eq(spirv)); } TEST_F(CompositeRoundTripTest, V13Bad) { std::string spirv = "%2 = OpCopyLogical %1 %3\n"; std::string err = CompileFailure(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_THAT(err, HasSubstr("Invalid Opcode name 'OpCopyLogical'")); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/text_to_binary.constant_test.cpp000066400000000000000000001064751475742701700261520ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Assembler tests for instructions in the "Group Instrucions" section of the // SPIR-V spec. #include #include #include #include #include "gmock/gmock.h" #include "test/test_fixture.h" #include "test/unit_spirv.h" namespace spvtools { namespace { using spvtest::Concatenate; using spvtest::EnumCase; using spvtest::MakeInstruction; using ::testing::Eq; // Test Sampler Addressing Mode enum values using SamplerAddressingModeTest = spvtest::TextToBinaryTestBase< ::testing::TestWithParam>>; TEST_P(SamplerAddressingModeTest, AnySamplerAddressingMode) { const std::string input = "%result = OpConstantSampler %type " + GetParam().name() + " 0 Nearest"; EXPECT_THAT(CompiledInstructions(input), Eq(MakeInstruction(spv::Op::OpConstantSampler, {1, 2, uint32_t(GetParam().value()), 0, 0}))); } // clang-format off #define CASE(NAME) { spv::SamplerAddressingMode::NAME, #NAME } INSTANTIATE_TEST_SUITE_P( TextToBinarySamplerAddressingMode, SamplerAddressingModeTest, ::testing::ValuesIn(std::vector>{ CASE(None), CASE(ClampToEdge), CASE(Clamp), CASE(Repeat), CASE(RepeatMirrored), })); #undef CASE // clang-format on TEST_F(SamplerAddressingModeTest, WrongMode) { EXPECT_THAT(CompileFailure("%r = OpConstantSampler %t xxyyzz 0 Nearest"), Eq("Invalid sampler addressing mode 'xxyyzz'.")); } // Test Sampler Filter Mode enum values using SamplerFilterModeTest = spvtest::TextToBinaryTestBase< ::testing::TestWithParam>>; TEST_P(SamplerFilterModeTest, AnySamplerFilterMode) { const std::string input = "%result = OpConstantSampler %type Clamp 0 " + GetParam().name(); EXPECT_THAT(CompiledInstructions(input), Eq(MakeInstruction(spv::Op::OpConstantSampler, {1, 2, 2, 0, uint32_t(GetParam().value())}))); } // clang-format off #define CASE(NAME) { spv::SamplerFilterMode::NAME, #NAME} INSTANTIATE_TEST_SUITE_P( TextToBinarySamplerFilterMode, SamplerFilterModeTest, ::testing::ValuesIn(std::vector>{ CASE(Nearest), CASE(Linear), })); #undef CASE // clang-format on TEST_F(SamplerFilterModeTest, WrongMode) { EXPECT_THAT(CompileFailure("%r = OpConstantSampler %t Clamp 0 xxyyzz"), Eq("Invalid sampler filter mode 'xxyyzz'.")); } struct ConstantTestCase { std::string constant_type; std::string constant_value; std::vector expected_instructions; }; using OpConstantValidTest = spvtest::TextToBinaryTestBase<::testing::TestWithParam>; TEST_P(OpConstantValidTest, ValidTypes) { const std::string input = "%1 = " + GetParam().constant_type + "\n" "%2 = OpConstant %1 " + GetParam().constant_value + "\n"; std::vector instructions; EXPECT_THAT(CompiledInstructions(input), Eq(GetParam().expected_instructions)) << " type: " << GetParam().constant_type << " literal: " << GetParam().constant_value; } // clang-format off INSTANTIATE_TEST_SUITE_P( TextToBinaryOpConstantValid, OpConstantValidTest, ::testing::ValuesIn(std::vector{ // Check 16 bits {"OpTypeInt 16 0", "0x1234", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 16, 0}), MakeInstruction(spv::Op::OpConstant, {1, 2, 0x1234})})}, {"OpTypeInt 16 0", "0x8000", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 16, 0}), MakeInstruction(spv::Op::OpConstant, {1, 2, 0x8000})})}, {"OpTypeInt 16 0", "0", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 16, 0}), MakeInstruction(spv::Op::OpConstant, {1, 2, 0})})}, {"OpTypeInt 16 0", "65535", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 16, 0}), MakeInstruction(spv::Op::OpConstant, {1, 2, 65535})})}, {"OpTypeInt 16 0", "0xffff", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 16, 0}), MakeInstruction(spv::Op::OpConstant, {1, 2, 65535})})}, {"OpTypeInt 16 1", "0x8000", // Test sign extension. Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 16, 1}), MakeInstruction(spv::Op::OpConstant, {1, 2, 0xffff8000})})}, {"OpTypeInt 16 1", "-32", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 16, 1}), MakeInstruction(spv::Op::OpConstant, {1, 2, uint32_t(-32)})})}, {"OpTypeInt 16 1", "0", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 16, 1}), MakeInstruction(spv::Op::OpConstant, {1, 2, 0})})}, {"OpTypeInt 16 1", "-0", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 16, 1}), MakeInstruction(spv::Op::OpConstant, {1, 2, 0})})}, {"OpTypeInt 16 1", "-0x0", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 16, 1}), MakeInstruction(spv::Op::OpConstant, {1, 2, 0})})}, {"OpTypeInt 16 1", "-32768", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 16, 1}), MakeInstruction(spv::Op::OpConstant, {1, 2, uint32_t(-32768)})})}, // Check 32 bits {"OpTypeInt 32 0", "42", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 32, 0}), MakeInstruction(spv::Op::OpConstant, {1, 2, 42})})}, {"OpTypeInt 32 1", "-32", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 32, 1}), MakeInstruction(spv::Op::OpConstant, {1, 2, uint32_t(-32)})})}, {"OpTypeInt 32 1", "0", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 32, 1}), MakeInstruction(spv::Op::OpConstant, {1, 2, 0})})}, {"OpTypeInt 32 1", "-0", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 32, 1}), MakeInstruction(spv::Op::OpConstant, {1, 2, 0})})}, {"OpTypeInt 32 1", "-0x0", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 32, 1}), MakeInstruction(spv::Op::OpConstant, {1, 2, 0})})}, {"OpTypeInt 32 1", "-0x001", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 32, 1}), MakeInstruction(spv::Op::OpConstant, {1, 2, uint32_t(-1)})})}, {"OpTypeInt 32 1", "2147483647", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 32, 1}), MakeInstruction(spv::Op::OpConstant, {1, 2, 0x7fffffffu})})}, {"OpTypeInt 32 1", "-2147483648", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 32, 1}), MakeInstruction(spv::Op::OpConstant, {1, 2, 0x80000000u})})}, {"OpTypeFloat 32", "1.0", Concatenate({MakeInstruction(spv::Op::OpTypeFloat, {1, 32}), MakeInstruction(spv::Op::OpConstant, {1, 2, 0x3f800000})})}, {"OpTypeFloat 32", "10.0", Concatenate({MakeInstruction(spv::Op::OpTypeFloat, {1, 32}), MakeInstruction(spv::Op::OpConstant, {1, 2, 0x41200000})})}, {"OpTypeFloat 32", "-0x1p+128", // -infinity Concatenate({MakeInstruction(spv::Op::OpTypeFloat, {1, 32}), MakeInstruction(spv::Op::OpConstant, {1, 2, 0xFF800000})})}, {"OpTypeFloat 32", "0x1p+128", // +infinity Concatenate({MakeInstruction(spv::Op::OpTypeFloat, {1, 32}), MakeInstruction(spv::Op::OpConstant, {1, 2, 0x7F800000})})}, {"OpTypeFloat 32", "-0x1.8p+128", // A -NaN Concatenate({MakeInstruction(spv::Op::OpTypeFloat, {1, 32}), MakeInstruction(spv::Op::OpConstant, {1, 2, 0xFFC00000})})}, {"OpTypeFloat 32", "-0x1.0002p+128", // A +NaN Concatenate({MakeInstruction(spv::Op::OpTypeFloat, {1, 32}), MakeInstruction(spv::Op::OpConstant, {1, 2, 0xFF800100})})}, // Check 48 bits {"OpTypeInt 48 0", "0x1234", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 48, 0}), MakeInstruction(spv::Op::OpConstant, {1, 2, 0x1234, 0})})}, {"OpTypeInt 48 0", "0x800000000001", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 48, 0}), MakeInstruction(spv::Op::OpConstant, {1, 2, 1, 0x00008000})})}, {"OpTypeInt 48 1", "0x800000000000", // Test sign extension. Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 48, 1}), MakeInstruction(spv::Op::OpConstant, {1, 2, 0, 0xffff8000})})}, {"OpTypeInt 48 1", "-32", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 48, 1}), MakeInstruction(spv::Op::OpConstant, {1, 2, uint32_t(-32), uint32_t(-1)})})}, // Check 64 bits {"OpTypeInt 64 0", "0x1234", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 64, 0}), MakeInstruction(spv::Op::OpConstant, {1, 2, 0x1234, 0})})}, {"OpTypeInt 64 0", "18446744073709551615", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 64, 0}), MakeInstruction(spv::Op::OpConstant, {1, 2, 0xffffffffu, 0xffffffffu})})}, {"OpTypeInt 64 0", "0xffffffffffffffff", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 64, 0}), MakeInstruction(spv::Op::OpConstant, {1, 2, 0xffffffffu, 0xffffffffu})})}, {"OpTypeInt 64 1", "0x1234", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 64, 1}), MakeInstruction(spv::Op::OpConstant, {1, 2, 0x1234, 0})})}, {"OpTypeInt 64 1", "-42", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 64, 1}), MakeInstruction(spv::Op::OpConstant, {1, 2, uint32_t(-42), uint32_t(-1)})})}, {"OpTypeInt 64 1", "-0x01", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 64, 1}), MakeInstruction(spv::Op::OpConstant, {1, 2, 0xffffffffu, 0xffffffffu})})}, {"OpTypeInt 64 1", "9223372036854775807", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 64, 1}), MakeInstruction(spv::Op::OpConstant, {1, 2, 0xffffffffu, 0x7fffffffu})})}, {"OpTypeInt 64 1", "0x7fffffff", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 64, 1}), MakeInstruction(spv::Op::OpConstant, {1, 2, 0x7fffffffu, 0})})}, })); // clang-format on // A test case for checking OpConstant with invalid literals with a leading // minus. struct InvalidLeadingMinusCase { std::string type; std::string literal; }; using OpConstantInvalidLeadingMinusTest = spvtest::TextToBinaryTestBase< ::testing::TestWithParam>; TEST_P(OpConstantInvalidLeadingMinusTest, InvalidCase) { const std::string input = "%1 = " + GetParam().type + "\n" "%2 = OpConstant %1 " + GetParam().literal; EXPECT_THAT(CompileFailure(input), Eq("Cannot put a negative number in an unsigned literal")); } // clang-format off INSTANTIATE_TEST_SUITE_P( TextToBinaryOpConstantInvalidLeadingMinus, OpConstantInvalidLeadingMinusTest, ::testing::ValuesIn(std::vector{ {"OpTypeInt 16 0", "-0"}, {"OpTypeInt 16 0", "-0x0"}, {"OpTypeInt 16 0", "-1"}, {"OpTypeInt 32 0", "-0"}, {"OpTypeInt 32 0", "-0x0"}, {"OpTypeInt 32 0", "-1"}, {"OpTypeInt 64 0", "-0"}, {"OpTypeInt 64 0", "-0x0"}, {"OpTypeInt 64 0", "-1"}, })); // clang-format on // A test case for invalid floating point literals. struct InvalidFloatConstantCase { uint32_t width; std::string literal; }; using OpConstantInvalidFloatConstant = spvtest::TextToBinaryTestBase< ::testing::TestWithParam>; TEST_P(OpConstantInvalidFloatConstant, Samples) { // Check both kinds of instructions that take literal floats. for (const auto& instruction : {"OpConstant", "OpSpecConstant"}) { std::stringstream input; input << "%1 = OpTypeFloat " << GetParam().width << "\n" << "%2 = " << instruction << " %1 " << GetParam().literal; std::stringstream expected_error; expected_error << "Invalid " << GetParam().width << "-bit float literal: " << GetParam().literal; EXPECT_THAT(CompileFailure(input.str()), Eq(expected_error.str())); } } // clang-format off INSTANTIATE_TEST_SUITE_P( TextToBinaryInvalidFloatConstant, OpConstantInvalidFloatConstant, ::testing::ValuesIn(std::vector{ {16, "abc"}, {16, "--1"}, {16, "-+1"}, {16, "+-1"}, {16, "++1"}, {16, "1e30"}, // Overflow is an error for 16-bit floats. {16, "-1e30"}, {16, "1e40"}, {16, "-1e40"}, {16, "1e400"}, {16, "-1e400"}, {32, "abc"}, {32, "--1"}, {32, "-+1"}, {32, "+-1"}, {32, "++1"}, {32, "1e40"}, // Overflow is an error for 32-bit floats. {32, "-1e40"}, {32, "1e400"}, {32, "-1e400"}, {64, "abc"}, {64, "--1"}, {64, "-+1"}, {64, "+-1"}, {64, "++1"}, {32, "1e400"}, // Overflow is an error for 64-bit floats. {32, "-1e400"}, })); // clang-format on using OpConstantInvalidTypeTest = spvtest::TextToBinaryTestBase<::testing::TestWithParam>; TEST_P(OpConstantInvalidTypeTest, InvalidTypes) { const std::string input = "%1 = " + GetParam() + "\n" "%2 = OpConstant %1 0\n"; EXPECT_THAT( CompileFailure(input), Eq("Type for Constant must be a scalar floating point or integer type")); } // clang-format off INSTANTIATE_TEST_SUITE_P( TextToBinaryOpConstantInvalidValidType, OpConstantInvalidTypeTest, ::testing::ValuesIn(std::vector{ {"OpTypeVoid", "OpTypeBool", "OpTypeVector %a 32", "OpTypeMatrix %a 32", "OpTypeImage %a 1D 0 0 0 0 Unknown", "OpTypeSampler", "OpTypeSampledImage %a", "OpTypeArray %a %b", "OpTypeRuntimeArray %a", "OpTypeStruct %a", "OpTypeOpaque \"Foo\"", "OpTypePointer UniformConstant %a", "OpTypeFunction %a %b", "OpTypeEvent", "OpTypeDeviceEvent", "OpTypeReserveId", "OpTypeQueue", "OpTypePipe ReadOnly", // Skip OpTypeForwardPointer doesn't even produce a result ID. // The assembler errors out if we try to check it in this scenario. // Try at least one thing that isn't a type at all "OpNot %a %b" }, })); // clang-format on using OpSpecConstantValidTest = spvtest::TextToBinaryTestBase<::testing::TestWithParam>; TEST_P(OpSpecConstantValidTest, ValidTypes) { const std::string input = "%1 = " + GetParam().constant_type + "\n" "%2 = OpSpecConstant %1 " + GetParam().constant_value + "\n"; std::vector instructions; EXPECT_THAT(CompiledInstructions(input), Eq(GetParam().expected_instructions)); } // clang-format off INSTANTIATE_TEST_SUITE_P( TextToBinaryOpSpecConstantValid, OpSpecConstantValidTest, ::testing::ValuesIn(std::vector{ // Check 16 bits {"OpTypeInt 16 0", "0x1234", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 16, 0}), MakeInstruction(spv::Op::OpSpecConstant, {1, 2, 0x1234})})}, {"OpTypeInt 16 0", "0x8000", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 16, 0}), MakeInstruction(spv::Op::OpSpecConstant, {1, 2, 0x8000})})}, {"OpTypeInt 16 1", "0x8000", // Test sign extension. Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 16, 1}), MakeInstruction(spv::Op::OpSpecConstant, {1, 2, 0xffff8000})})}, {"OpTypeInt 16 1", "-32", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 16, 1}), MakeInstruction(spv::Op::OpSpecConstant, {1, 2, uint32_t(-32)})})}, // Check 32 bits {"OpTypeInt 32 0", "42", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 32, 0}), MakeInstruction(spv::Op::OpSpecConstant, {1, 2, 42})})}, {"OpTypeInt 32 1", "-32", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 32, 1}), MakeInstruction(spv::Op::OpSpecConstant, {1, 2, uint32_t(-32)})})}, {"OpTypeFloat 32", "1.0", Concatenate({MakeInstruction(spv::Op::OpTypeFloat, {1, 32}), MakeInstruction(spv::Op::OpSpecConstant, {1, 2, 0x3f800000})})}, {"OpTypeFloat 32", "10.0", Concatenate({MakeInstruction(spv::Op::OpTypeFloat, {1, 32}), MakeInstruction(spv::Op::OpSpecConstant, {1, 2, 0x41200000})})}, // Check 48 bits {"OpTypeInt 48 0", "0x1234", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 48, 0}), MakeInstruction(spv::Op::OpSpecConstant, {1, 2, 0x1234, 0})})}, {"OpTypeInt 48 0", "0x800000000001", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 48, 0}), MakeInstruction(spv::Op::OpSpecConstant, {1, 2, 1, 0x00008000})})}, {"OpTypeInt 48 1", "0x800000000000", // Test sign extension. Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 48, 1}), MakeInstruction(spv::Op::OpSpecConstant, {1, 2, 0, 0xffff8000})})}, {"OpTypeInt 48 1", "-32", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 48, 1}), MakeInstruction(spv::Op::OpSpecConstant, {1, 2, uint32_t(-32), uint32_t(-1)})})}, // Check 64 bits {"OpTypeInt 64 0", "0x1234", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 64, 0}), MakeInstruction(spv::Op::OpSpecConstant, {1, 2, 0x1234, 0})})}, {"OpTypeInt 64 1", "0x1234", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 64, 1}), MakeInstruction(spv::Op::OpSpecConstant, {1, 2, 0x1234, 0})})}, {"OpTypeInt 64 1", "-42", Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 64, 1}), MakeInstruction(spv::Op::OpSpecConstant, {1, 2, uint32_t(-42), uint32_t(-1)})})}, })); // clang-format on using OpSpecConstantInvalidTypeTest = spvtest::TextToBinaryTestBase<::testing::TestWithParam>; TEST_P(OpSpecConstantInvalidTypeTest, InvalidTypes) { const std::string input = "%1 = " + GetParam() + "\n" "%2 = OpSpecConstant %1 0\n"; EXPECT_THAT(CompileFailure(input), Eq("Type for SpecConstant must be a scalar floating point or " "integer type")); } // clang-format off INSTANTIATE_TEST_SUITE_P( TextToBinaryOpSpecConstantInvalidValidType, OpSpecConstantInvalidTypeTest, ::testing::ValuesIn(std::vector{ {"OpTypeVoid", "OpTypeBool", "OpTypeVector %a 32", "OpTypeMatrix %a 32", "OpTypeImage %a 1D 0 0 0 0 Unknown", "OpTypeSampler", "OpTypeSampledImage %a", "OpTypeArray %a %b", "OpTypeRuntimeArray %a", "OpTypeStruct %a", "OpTypeOpaque \"Foo\"", "OpTypePointer UniformConstant %a", "OpTypeFunction %a %b", "OpTypeEvent", "OpTypeDeviceEvent", "OpTypeReserveId", "OpTypeQueue", "OpTypePipe ReadOnly", // Skip testing OpTypeForwardPointer because it doesn't even produce a result ID. // Try at least one thing that isn't a type at all "OpNot %a %b" }, })); // clang-format on const int64_t kMaxUnsigned48Bit = (int64_t(1) << 48) - 1; const int64_t kMaxSigned48Bit = (int64_t(1) << 47) - 1; const int64_t kMinSigned48Bit = -kMaxSigned48Bit - 1; using ConstantRoundTripTest = RoundTripTest; TEST_P(ConstantRoundTripTest, DisassemblyEqualsAssemblyInput) { const std::string assembly = GetParam(); EXPECT_THAT(EncodeAndDecodeSuccessfully(assembly), Eq(assembly)) << assembly; } INSTANTIATE_TEST_SUITE_P( OpConstantRoundTrip, ConstantRoundTripTest, ::testing::ValuesIn(std::vector{ // 16 bit "%1 = OpTypeInt 16 0\n%2 = OpConstant %1 0\n", "%1 = OpTypeInt 16 0\n%2 = OpConstant %1 65535\n", "%1 = OpTypeInt 16 1\n%2 = OpConstant %1 -32768\n", "%1 = OpTypeInt 16 1\n%2 = OpConstant %1 32767\n", "%1 = OpTypeInt 32 0\n%2 = OpConstant %1 0\n", // 32 bit std::string("%1 = OpTypeInt 32 0\n%2 = OpConstant %1 0\n"), std::string("%1 = OpTypeInt 32 0\n%2 = OpConstant %1 ") + std::to_string(std::numeric_limits::max()) + "\n", std::string("%1 = OpTypeInt 32 1\n%2 = OpConstant %1 ") + std::to_string(std::numeric_limits::max()) + "\n", std::string("%1 = OpTypeInt 32 1\n%2 = OpConstant %1 ") + std::to_string(std::numeric_limits::min()) + "\n", // 48 bit std::string("%1 = OpTypeInt 48 0\n%2 = OpConstant %1 0\n"), std::string("%1 = OpTypeInt 48 0\n%2 = OpConstant %1 ") + std::to_string(kMaxUnsigned48Bit) + "\n", std::string("%1 = OpTypeInt 48 1\n%2 = OpConstant %1 ") + std::to_string(kMaxSigned48Bit) + "\n", std::string("%1 = OpTypeInt 48 1\n%2 = OpConstant %1 ") + std::to_string(kMinSigned48Bit) + "\n", // 64 bit std::string("%1 = OpTypeInt 64 0\n%2 = OpConstant %1 0\n"), std::string("%1 = OpTypeInt 64 0\n%2 = OpConstant %1 ") + std::to_string(std::numeric_limits::max()) + "\n", std::string("%1 = OpTypeInt 64 1\n%2 = OpConstant %1 ") + std::to_string(std::numeric_limits::max()) + "\n", std::string("%1 = OpTypeInt 64 1\n%2 = OpConstant %1 ") + std::to_string(std::numeric_limits::min()) + "\n", // 32-bit float "%1 = OpTypeFloat 32\n%2 = OpConstant %1 0\n", "%1 = OpTypeFloat 32\n%2 = OpConstant %1 13.5\n", "%1 = OpTypeFloat 32\n%2 = OpConstant %1 -12.5\n", // 64-bit float "%1 = OpTypeFloat 64\n%2 = OpConstant %1 0\n", "%1 = OpTypeFloat 64\n%2 = OpConstant %1 1.79767e+308\n", "%1 = OpTypeFloat 64\n%2 = OpConstant %1 -1.79767e+308\n", })); INSTANTIATE_TEST_SUITE_P( OpConstantHalfRoundTrip, ConstantRoundTripTest, ::testing::ValuesIn(std::vector{ "%1 = OpTypeFloat 16\n%2 = OpConstant %1 -0x0p+0\n", "%1 = OpTypeFloat 16\n%2 = OpConstant %1 0x0p+0\n", "%1 = OpTypeFloat 16\n%2 = OpConstant %1 0x1p+0\n", "%1 = OpTypeFloat 16\n%2 = OpConstant %1 0x1.1p+0\n", "%1 = OpTypeFloat 16\n%2 = OpConstant %1 0x1.01p-1\n", "%1 = OpTypeFloat 16\n%2 = OpConstant %1 0x1.8p+1\n", "%1 = OpTypeFloat 16\n%2 = OpConstant %1 0x1.ffcp+1\n", "%1 = OpTypeFloat 16\n%2 = OpConstant %1 -0x1p+0\n", "%1 = OpTypeFloat 16\n%2 = OpConstant %1 -0x1.1p+0\n", "%1 = OpTypeFloat 16\n%2 = OpConstant %1 -0x1.01p-1\n", "%1 = OpTypeFloat 16\n%2 = OpConstant %1 -0x1.8p+1\n", "%1 = OpTypeFloat 16\n%2 = OpConstant %1 -0x1.ffcp+1\n", "%1 = OpTypeFloat 16\n%2 = OpConstant %1 0x1p-16\n", // some denorms "%1 = OpTypeFloat 16\n%2 = OpConstant %1 0x1p-24\n", "%1 = OpTypeFloat 16\n%2 = OpConstant %1 -0x1p-24\n", "%1 = OpTypeFloat 16\n%2 = OpConstant %1 0x1p+16\n", // +inf "%1 = OpTypeFloat 16\n%2 = OpConstant %1 -0x1p+16\n", // -inf "%1 = OpTypeFloat 16\n%2 = OpConstant %1 -0x1.01p+16\n", // -inf "%1 = OpTypeFloat 16\n%2 = OpConstant %1 0x1.01p+16\n", // nan "%1 = OpTypeFloat 16\n%2 = OpConstant %1 0x1.11p+16\n", // nan "%1 = OpTypeFloat 16\n%2 = OpConstant %1 0x1.ffp+16\n", // nan "%1 = OpTypeFloat 16\n%2 = OpConstant %1 0x1.ffcp+16\n", // nan "%1 = OpTypeFloat 16\n%2 = OpConstant %1 0x1.004p+16\n", // nan "%1 = OpTypeFloat 16\n%2 = OpConstant %1 -0x1.01p+16\n", // -nan "%1 = OpTypeFloat 16\n%2 = OpConstant %1 -0x1.11p+16\n", // -nan "%1 = OpTypeFloat 16\n%2 = OpConstant %1 -0x1.ffp+16\n", // -nan "%1 = OpTypeFloat 16\n%2 = OpConstant %1 -0x1.ffcp+16\n", // -nan "%1 = OpTypeFloat 16\n%2 = OpConstant %1 -0x1.004p+16\n", // -nan })); // clang-format off // (Clang-format really wants to break up these strings across lines. INSTANTIATE_TEST_SUITE_P( OpConstantRoundTripNonFinite, ConstantRoundTripTest, ::testing::ValuesIn(std::vector{ "%1 = OpTypeFloat 32\n%2 = OpConstant %1 -0x1p+128\n", // -inf "%1 = OpTypeFloat 32\n%2 = OpConstant %1 0x1p+128\n", // inf "%1 = OpTypeFloat 32\n%2 = OpConstant %1 -0x1.8p+128\n", // -nan "%1 = OpTypeFloat 32\n%2 = OpConstant %1 -0x1.0002p+128\n", // -nan "%1 = OpTypeFloat 32\n%2 = OpConstant %1 -0x1.0018p+128\n", // -nan "%1 = OpTypeFloat 32\n%2 = OpConstant %1 -0x1.01ep+128\n", // -nan "%1 = OpTypeFloat 32\n%2 = OpConstant %1 -0x1.fffffep+128\n", // -nan "%1 = OpTypeFloat 32\n%2 = OpConstant %1 0x1.8p+128\n", // +nan "%1 = OpTypeFloat 32\n%2 = OpConstant %1 0x1.0002p+128\n", // +nan "%1 = OpTypeFloat 32\n%2 = OpConstant %1 0x1.0018p+128\n", // +nan "%1 = OpTypeFloat 32\n%2 = OpConstant %1 0x1.01ep+128\n", // +nan "%1 = OpTypeFloat 32\n%2 = OpConstant %1 0x1.fffffep+128\n", // +nan "%1 = OpTypeFloat 64\n%2 = OpConstant %1 -0x1p+1024\n", // -inf "%1 = OpTypeFloat 64\n%2 = OpConstant %1 0x1p+1024\n", // +inf "%1 = OpTypeFloat 64\n%2 = OpConstant %1 -0x1.8p+1024\n", // -nan "%1 = OpTypeFloat 64\n%2 = OpConstant %1 -0x1.0fp+1024\n", // -nan "%1 = OpTypeFloat 64\n%2 = OpConstant %1 -0x1.0000000000001p+1024\n", // -nan "%1 = OpTypeFloat 64\n%2 = OpConstant %1 -0x1.00003p+1024\n", // -nan "%1 = OpTypeFloat 64\n%2 = OpConstant %1 -0x1.fffffffffffffp+1024\n", // -nan "%1 = OpTypeFloat 64\n%2 = OpConstant %1 0x1.8p+1024\n", // +nan "%1 = OpTypeFloat 64\n%2 = OpConstant %1 0x1.0fp+1024\n", // +nan "%1 = OpTypeFloat 64\n%2 = OpConstant %1 0x1.0000000000001p+1024\n", // -nan "%1 = OpTypeFloat 64\n%2 = OpConstant %1 0x1.00003p+1024\n", // -nan "%1 = OpTypeFloat 64\n%2 = OpConstant %1 0x1.fffffffffffffp+1024\n", // -nan })); // clang-format on INSTANTIATE_TEST_SUITE_P( OpSpecConstantRoundTrip, ConstantRoundTripTest, ::testing::ValuesIn(std::vector{ // 16 bit "%1 = OpTypeInt 16 0\n%2 = OpSpecConstant %1 0\n", "%1 = OpTypeInt 16 0\n%2 = OpSpecConstant %1 65535\n", "%1 = OpTypeInt 16 1\n%2 = OpSpecConstant %1 -32768\n", "%1 = OpTypeInt 16 1\n%2 = OpSpecConstant %1 32767\n", "%1 = OpTypeInt 32 0\n%2 = OpSpecConstant %1 0\n", // 32 bit std::string("%1 = OpTypeInt 32 0\n%2 = OpSpecConstant %1 0\n"), std::string("%1 = OpTypeInt 32 0\n%2 = OpSpecConstant %1 ") + std::to_string(std::numeric_limits::max()) + "\n", std::string("%1 = OpTypeInt 32 1\n%2 = OpSpecConstant %1 ") + std::to_string(std::numeric_limits::max()) + "\n", std::string("%1 = OpTypeInt 32 1\n%2 = OpSpecConstant %1 ") + std::to_string(std::numeric_limits::min()) + "\n", // 48 bit std::string("%1 = OpTypeInt 48 0\n%2 = OpSpecConstant %1 0\n"), std::string("%1 = OpTypeInt 48 0\n%2 = OpSpecConstant %1 ") + std::to_string(kMaxUnsigned48Bit) + "\n", std::string("%1 = OpTypeInt 48 1\n%2 = OpSpecConstant %1 ") + std::to_string(kMaxSigned48Bit) + "\n", std::string("%1 = OpTypeInt 48 1\n%2 = OpSpecConstant %1 ") + std::to_string(kMinSigned48Bit) + "\n", // 64 bit std::string("%1 = OpTypeInt 64 0\n%2 = OpSpecConstant %1 0\n"), std::string("%1 = OpTypeInt 64 0\n%2 = OpSpecConstant %1 ") + std::to_string(std::numeric_limits::max()) + "\n", std::string("%1 = OpTypeInt 64 1\n%2 = OpSpecConstant %1 ") + std::to_string(std::numeric_limits::max()) + "\n", std::string("%1 = OpTypeInt 64 1\n%2 = OpSpecConstant %1 ") + std::to_string(std::numeric_limits::min()) + "\n", // 32-bit float "%1 = OpTypeFloat 32\n%2 = OpSpecConstant %1 0\n", "%1 = OpTypeFloat 32\n%2 = OpSpecConstant %1 13.5\n", "%1 = OpTypeFloat 32\n%2 = OpSpecConstant %1 -12.5\n", // 64-bit float "%1 = OpTypeFloat 64\n%2 = OpSpecConstant %1 0\n", "%1 = OpTypeFloat 64\n%2 = OpSpecConstant %1 1.79767e+308\n", "%1 = OpTypeFloat 64\n%2 = OpSpecConstant %1 -1.79767e+308\n", })); // Test OpSpecConstantOp using OpSpecConstantOpTestWithIds = spvtest::TextToBinaryTestBase<::testing::TestWithParam>>; // The operands to the OpSpecConstantOp opcode are all Ids. TEST_P(OpSpecConstantOpTestWithIds, Assembly) { std::stringstream input; input << "%2 = OpSpecConstantOp %1 " << GetParam().name(); for (auto id : GetParam().operands()) input << " %" << id; input << "\n"; EXPECT_THAT(CompiledInstructions(input.str()), Eq(MakeInstruction(spv::Op::OpSpecConstantOp, {1, 2, uint32_t(GetParam().value())}, GetParam().operands()))); // Check the disassembler as well. EXPECT_THAT(EncodeAndDecodeSuccessfully(input.str()), input.str()); } // clang-format off #define CASE1(NAME) { spv::Op::Op##NAME, #NAME, {3} } #define CASE2(NAME) { spv::Op::Op##NAME, #NAME, {3, 4} } #define CASE3(NAME) { spv::Op::Op##NAME, #NAME, {3, 4, 5} } #define CASE4(NAME) { spv::Op::Op##NAME, #NAME, {3, 4, 5, 6} } #define CASE5(NAME) { spv::Op::Op##NAME, #NAME, {3, 4, 5, 6, 7} } #define CASE6(NAME) { spv::Op::Op##NAME, #NAME, {3, 4, 5, 6, 7, 8} } INSTANTIATE_TEST_SUITE_P( TextToBinaryOpSpecConstantOp, OpSpecConstantOpTestWithIds, ::testing::ValuesIn(std::vector>{ // Conversion CASE1(SConvert), CASE1(FConvert), CASE1(ConvertFToS), CASE1(ConvertSToF), CASE1(ConvertFToU), CASE1(ConvertUToF), CASE1(UConvert), CASE1(ConvertPtrToU), CASE1(ConvertUToPtr), CASE1(GenericCastToPtr), CASE1(PtrCastToGeneric), CASE1(Bitcast), CASE1(QuantizeToF16), // Arithmetic CASE1(SNegate), CASE1(Not), CASE2(IAdd), CASE2(ISub), CASE2(IMul), CASE2(UDiv), CASE2(SDiv), CASE2(UMod), CASE2(SRem), CASE2(SMod), CASE2(ShiftRightLogical), CASE2(ShiftRightArithmetic), CASE2(ShiftLeftLogical), CASE2(BitwiseOr), CASE2(BitwiseAnd), CASE2(BitwiseXor), CASE1(FNegate), CASE2(FAdd), CASE2(FSub), CASE2(FMul), CASE2(FDiv), CASE2(FRem), CASE2(FMod), // Composite operations use literal numbers. So they're in another test. // Logical CASE2(LogicalOr), CASE2(LogicalAnd), CASE1(LogicalNot), CASE2(LogicalEqual), CASE2(LogicalNotEqual), CASE3(Select), // Comparison CASE2(IEqual), CASE2(INotEqual), // Allowed in 1.0 Rev 7 CASE2(ULessThan), CASE2(SLessThan), CASE2(UGreaterThan), CASE2(SGreaterThan), CASE2(ULessThanEqual), CASE2(SLessThanEqual), CASE2(UGreaterThanEqual), CASE2(SGreaterThanEqual), // Memory // For AccessChain, there is a base Id, then a sequence of index Ids. // Having no index Ids is a corner case. CASE1(AccessChain), CASE2(AccessChain), CASE6(AccessChain), CASE1(InBoundsAccessChain), CASE2(InBoundsAccessChain), CASE6(InBoundsAccessChain), // PtrAccessChain also has an element Id. CASE2(PtrAccessChain), CASE3(PtrAccessChain), CASE6(PtrAccessChain), CASE2(InBoundsPtrAccessChain), CASE3(InBoundsPtrAccessChain), CASE6(InBoundsPtrAccessChain), })); #undef CASE1 #undef CASE2 #undef CASE3 #undef CASE4 #undef CASE5 #undef CASE6 // clang-format on using OpSpecConstantOpTestWithTwoIdsThenLiteralNumbers = spvtest::TextToBinaryTestBase<::testing::TestWithParam>>; // The operands to the OpSpecConstantOp opcode are two Ids followed by a // sequence of literal numbers. TEST_P(OpSpecConstantOpTestWithTwoIdsThenLiteralNumbers, Assembly) { std::stringstream input; input << "%2 = OpSpecConstantOp %1 " << GetParam().name() << " %3 %4"; for (auto number : GetParam().operands()) input << " " << number; input << "\n"; EXPECT_THAT(CompiledInstructions(input.str()), Eq(MakeInstruction(spv::Op::OpSpecConstantOp, {1, 2, uint32_t(GetParam().value()), 3, 4}, GetParam().operands()))); // Check the disassembler as well. EXPECT_THAT(EncodeAndDecodeSuccessfully(input.str()), input.str()); } #define CASE(NAME) spv::Op::Op##NAME, #NAME INSTANTIATE_TEST_SUITE_P( TextToBinaryOpSpecConstantOp, OpSpecConstantOpTestWithTwoIdsThenLiteralNumbers, ::testing::ValuesIn(std::vector>{ // For VectorShuffle, there are two vector operands, and at least // two selector Ids. OpenCL can have up to 16-element vectors. {CASE(VectorShuffle), {0, 0}}, {CASE(VectorShuffle), {4, 3, 2, 1}}, {CASE(VectorShuffle), {0, 2, 4, 6, 1, 3, 5, 7}}, {CASE(VectorShuffle), {15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0}}, // For CompositeInsert, there is an object to insert, the target // composite, and then literal indices. {CASE(CompositeInsert), {0}}, {CASE(CompositeInsert), {4, 3, 99, 1}}, })); using OpSpecConstantOpTestWithOneIdThenLiteralNumbers = spvtest::TextToBinaryTestBase<::testing::TestWithParam>>; // The operands to the OpSpecConstantOp opcode are one Id followed by a // sequence of literal numbers. TEST_P(OpSpecConstantOpTestWithOneIdThenLiteralNumbers, Assembly) { std::stringstream input; input << "%2 = OpSpecConstantOp %1 " << GetParam().name() << " %3"; for (auto number : GetParam().operands()) input << " " << number; input << "\n"; EXPECT_THAT(CompiledInstructions(input.str()), Eq(MakeInstruction(spv::Op::OpSpecConstantOp, {1, 2, uint32_t(GetParam().value()), 3}, GetParam().operands()))); // Check the disassembler as well. EXPECT_THAT(EncodeAndDecodeSuccessfully(input.str()), input.str()); } #define CASE(NAME) spv::Op::Op##NAME, #NAME INSTANTIATE_TEST_SUITE_P( TextToBinaryOpSpecConstantOp, OpSpecConstantOpTestWithOneIdThenLiteralNumbers, ::testing::ValuesIn(std::vector>{ // For CompositeExtract, the universal limit permits up to 255 literal // indices. Let's only test a few. {CASE(CompositeExtract), {0}}, {CASE(CompositeExtract), {0, 99, 42, 16, 17, 12, 19}}, })); // TODO(dneto): OpConstantTrue // TODO(dneto): OpConstantFalse // TODO(dneto): OpConstantComposite // TODO(dneto): OpConstantSampler: other variations Param is 0 or 1 // TODO(dneto): OpConstantNull // TODO(dneto): OpSpecConstantTrue // TODO(dneto): OpSpecConstantFalse // TODO(dneto): OpSpecConstantComposite // TODO(dneto): Negative tests for OpSpecConstantOp } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/text_to_binary.control_flow_test.cpp000066400000000000000000000415511475742701700270210ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Assembler tests for instructions in the "Control Flow" section of the // SPIR-V spec. #include #include #include #include #include "gmock/gmock.h" #include "test/test_fixture.h" #include "test/unit_spirv.h" namespace spvtools { namespace { using spvtest::Concatenate; using spvtest::EnumCase; using spvtest::MakeInstruction; using spvtest::TextToBinaryTest; using ::testing::Combine; using ::testing::Eq; using ::testing::TestWithParam; using ::testing::Values; using ::testing::ValuesIn; // Test OpSelectionMerge using OpSelectionMergeTest = spvtest::TextToBinaryTestBase< TestWithParam>>; TEST_P(OpSelectionMergeTest, AnySingleSelectionControlMask) { const std::string input = "OpSelectionMerge %1 " + GetParam().name(); EXPECT_THAT(CompiledInstructions(input), Eq(MakeInstruction(spv::Op::OpSelectionMerge, {1, uint32_t(GetParam().value())}))); } // clang-format off #define CASE(VALUE,NAME) { spv::SelectionControlMask::VALUE, NAME} INSTANTIATE_TEST_SUITE_P(TextToBinarySelectionMerge, OpSelectionMergeTest, ValuesIn(std::vector>{ CASE(MaskNone, "None"), CASE(Flatten, "Flatten"), CASE(DontFlatten, "DontFlatten"), })); #undef CASE // clang-format on TEST_F(OpSelectionMergeTest, CombinedSelectionControlMask) { const std::string input = "OpSelectionMerge %1 Flatten|DontFlatten"; const uint32_t expected_mask = uint32_t(spv::SelectionControlMask::Flatten | spv::SelectionControlMask::DontFlatten); EXPECT_THAT( CompiledInstructions(input), Eq(MakeInstruction(spv::Op::OpSelectionMerge, {1, expected_mask}))); } TEST_F(OpSelectionMergeTest, WrongSelectionControl) { // Case sensitive: "flatten" != "Flatten" and thus wrong. EXPECT_THAT(CompileFailure("OpSelectionMerge %1 flatten|DontFlatten"), Eq("Invalid selection control operand 'flatten|DontFlatten'.")); } // Test OpLoopMerge using OpLoopMergeTest = spvtest::TextToBinaryTestBase< TestWithParam>>>; TEST_P(OpLoopMergeTest, AnySingleLoopControlMask) { const auto ctrl = std::get<1>(GetParam()); std::ostringstream input; input << "OpLoopMerge %merge %continue " << ctrl.name(); for (auto num : ctrl.operands()) input << " " << num; EXPECT_THAT(CompiledInstructions(input.str(), std::get<0>(GetParam())), Eq(MakeInstruction(spv::Op::OpLoopMerge, {1, 2, ctrl.value()}, ctrl.operands()))); } #define CASE(VALUE, NAME) \ { int32_t(spv::LoopControlMask::VALUE), NAME } #define CASE1(VALUE, NAME, PARM) \ { \ int32_t(spv::LoopControlMask::VALUE), NAME, { PARM } \ } INSTANTIATE_TEST_SUITE_P( TextToBinaryLoopMerge, OpLoopMergeTest, Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), ValuesIn(std::vector>{ // clang-format off CASE(MaskNone, "None"), CASE(Unroll, "Unroll"), CASE(DontUnroll, "DontUnroll"), // clang-format on }))); INSTANTIATE_TEST_SUITE_P( TextToBinaryLoopMergeV11, OpLoopMergeTest, Combine(Values(SPV_ENV_UNIVERSAL_1_1), ValuesIn(std::vector>{ // clang-format off CASE(DependencyInfinite, "DependencyInfinite"), CASE1(DependencyLength, "DependencyLength", 234), {int32_t(spv::LoopControlMask::Unroll|spv::LoopControlMask::DependencyLength), "DependencyLength|Unroll", {33}}, // clang-format on }))); #undef CASE #undef CASE1 TEST_F(OpLoopMergeTest, CombinedLoopControlMask) { const std::string input = "OpLoopMerge %merge %continue Unroll|DontUnroll"; const uint32_t expected_mask = uint32_t(spv::LoopControlMask::Unroll | spv::LoopControlMask::DontUnroll); EXPECT_THAT(CompiledInstructions(input), Eq(MakeInstruction(spv::Op::OpLoopMerge, {1, 2, expected_mask}))); } TEST_F(OpLoopMergeTest, WrongLoopControl) { EXPECT_THAT(CompileFailure("OpLoopMerge %m %c none"), Eq("Invalid loop control operand 'none'.")); } // Test OpSwitch TEST_F(TextToBinaryTest, SwitchGoodZeroTargets) { EXPECT_THAT(CompiledInstructions("OpSwitch %selector %default"), Eq(MakeInstruction(spv::Op::OpSwitch, {1, 2}))); } TEST_F(TextToBinaryTest, SwitchGoodOneTarget) { EXPECT_THAT( CompiledInstructions("%1 = OpTypeInt 32 0\n" "%2 = OpConstant %1 52\n" "OpSwitch %2 %default 12 %target0"), Eq(Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 32, 0}), MakeInstruction(spv::Op::OpConstant, {1, 2, 52}), MakeInstruction(spv::Op::OpSwitch, {2, 3, 12, 4})}))); } TEST_F(TextToBinaryTest, SwitchGoodTwoTargets) { EXPECT_THAT( CompiledInstructions("%1 = OpTypeInt 32 0\n" "%2 = OpConstant %1 52\n" "OpSwitch %2 %default 12 %target0 42 %target1"), Eq(Concatenate({ MakeInstruction(spv::Op::OpTypeInt, {1, 32, 0}), MakeInstruction(spv::Op::OpConstant, {1, 2, 52}), MakeInstruction(spv::Op::OpSwitch, {2, 3, 12, 4, 42, 5}), }))); } TEST_F(TextToBinaryTest, SwitchBadMissingSelector) { EXPECT_THAT(CompileFailure("OpSwitch"), Eq("Expected operand for OpSwitch instruction, but found the end " "of the stream.")); } TEST_F(TextToBinaryTest, SwitchBadInvalidSelector) { EXPECT_THAT(CompileFailure("OpSwitch 12"), Eq("Expected id to start with %.")); } TEST_F(TextToBinaryTest, SwitchBadMissingDefault) { EXPECT_THAT(CompileFailure("OpSwitch %selector"), Eq("Expected operand for OpSwitch instruction, but found the end " "of the stream.")); } TEST_F(TextToBinaryTest, SwitchBadInvalidDefault) { EXPECT_THAT(CompileFailure("OpSwitch %selector 12"), Eq("Expected id to start with %.")); } TEST_F(TextToBinaryTest, SwitchBadInvalidLiteral) { // The assembler recognizes "OpSwitch %selector %default" as a complete // instruction. Then it tries to parse "%abc" as the start of a new // instruction, but can't since it hits the end of stream. const auto input = R"(%i32 = OpTypeInt 32 0 %selector = OpConstant %i32 42 OpSwitch %selector %default %abc)"; EXPECT_THAT(CompileFailure(input), Eq("Expected '=', found end of stream.")); } TEST_F(TextToBinaryTest, SwitchBadMissingTarget) { EXPECT_THAT(CompileFailure("%1 = OpTypeInt 32 0\n" "%2 = OpConstant %1 52\n" "OpSwitch %2 %default 12"), Eq("Expected operand for OpSwitch instruction, but found the end " "of the stream.")); } // A test case for an OpSwitch. // It is also parameterized to test encodings OpConstant // integer literals. This can capture both single and multi-word // integer literal tests. struct SwitchTestCase { std::string constant_type_args; std::string constant_value_arg; std::string case_value_arg; std::vector expected_instructions; }; using OpSwitchValidTest = spvtest::TextToBinaryTestBase>; // Tests the encoding of OpConstant literal values, and also // the literal integer cases in an OpSwitch. This can // test both single and multi-word integer literal encodings. TEST_P(OpSwitchValidTest, ValidTypes) { const std::string input = "%1 = OpTypeInt " + GetParam().constant_type_args + "\n" "%2 = OpConstant %1 " + GetParam().constant_value_arg + "\n" "OpSwitch %2 %default " + GetParam().case_value_arg + " %4\n"; std::vector instructions; EXPECT_THAT(CompiledInstructions(input), Eq(GetParam().expected_instructions)); } // Constructs a SwitchTestCase from the given integer_width, signedness, // constant value string, and expected encoded constant. SwitchTestCase MakeSwitchTestCase(uint32_t integer_width, uint32_t integer_signedness, std::string constant_str, std::vector encoded_constant, std::string case_value_str, std::vector encoded_case_value) { std::stringstream ss; ss << integer_width << " " << integer_signedness; return SwitchTestCase{ ss.str(), constant_str, case_value_str, {Concatenate( {MakeInstruction(spv::Op::OpTypeInt, {1, integer_width, integer_signedness}), MakeInstruction(spv::Op::OpConstant, Concatenate({{1, 2}, encoded_constant})), MakeInstruction(spv::Op::OpSwitch, Concatenate({{2, 3}, encoded_case_value, {4}}))})}}; } INSTANTIATE_TEST_SUITE_P( TextToBinaryOpSwitchValid1Word, OpSwitchValidTest, ValuesIn(std::vector({ MakeSwitchTestCase(32, 0, "42", {42}, "100", {100}), MakeSwitchTestCase(32, 1, "-1", {0xffffffff}, "100", {100}), // SPIR-V 1.0 Rev 1 clarified that for an integer narrower than 32-bits, // its bits will appear in the lower order bits of the 32-bit word, and // a signed integer is sign-extended. MakeSwitchTestCase(7, 0, "127", {127}, "100", {100}), MakeSwitchTestCase(14, 0, "99", {99}, "100", {100}), MakeSwitchTestCase(16, 0, "65535", {65535}, "100", {100}), MakeSwitchTestCase(16, 1, "101", {101}, "100", {100}), // Demonstrate sign extension MakeSwitchTestCase(16, 1, "-2", {0xfffffffe}, "100", {100}), // Hex cases MakeSwitchTestCase(16, 1, "0x7ffe", {0x7ffe}, "0x1234", {0x1234}), MakeSwitchTestCase(16, 1, "0x8000", {0xffff8000}, "0x8100", {0xffff8100}), MakeSwitchTestCase(16, 0, "0x8000", {0x00008000}, "0x8100", {0x8100}), }))); // NB: The words LOW ORDER bits show up first. INSTANTIATE_TEST_SUITE_P( TextToBinaryOpSwitchValid2Words, OpSwitchValidTest, ValuesIn(std::vector({ MakeSwitchTestCase(33, 0, "101", {101, 0}, "500", {500, 0}), MakeSwitchTestCase(48, 1, "-1", {0xffffffff, 0xffffffff}, "900", {900, 0}), MakeSwitchTestCase(64, 1, "-2", {0xfffffffe, 0xffffffff}, "-5", {0xfffffffb, uint32_t(-1)}), // Hex cases MakeSwitchTestCase(48, 1, "0x7fffffffffff", {0xffffffff, 0x00007fff}, "100", {100, 0}), MakeSwitchTestCase(48, 1, "0x800000000000", {0x00000000, 0xffff8000}, "0x800000000000", {0x00000000, 0xffff8000}), MakeSwitchTestCase(48, 0, "0x800000000000", {0x00000000, 0x00008000}, "0x800000000000", {0x00000000, 0x00008000}), MakeSwitchTestCase(63, 0, "0x500000000", {0, 5}, "12", {12, 0}), MakeSwitchTestCase(64, 0, "0x600000000", {0, 6}, "12", {12, 0}), MakeSwitchTestCase(64, 1, "0x700000123", {0x123, 7}, "12", {12, 0}), }))); using ControlFlowRoundTripTest = RoundTripTest; TEST_P(ControlFlowRoundTripTest, DisassemblyEqualsAssemblyInput) { const std::string assembly = GetParam(); EXPECT_THAT(EncodeAndDecodeSuccessfully(assembly), Eq(assembly)) << assembly; } INSTANTIATE_TEST_SUITE_P( OpSwitchRoundTripUnsignedIntegers, ControlFlowRoundTripTest, ValuesIn(std::vector({ // Unsigned 16-bit. "%1 = OpTypeInt 16 0\n%2 = OpConstant %1 65535\nOpSwitch %2 %3\n", // Unsigned 32-bit, three non-default cases. "%1 = OpTypeInt 32 0\n%2 = OpConstant %1 123456\n" "OpSwitch %2 %3 100 %4 102 %5 1000000 %6\n", // Unsigned 48-bit, three non-default cases. "%1 = OpTypeInt 48 0\n%2 = OpConstant %1 5000000000\n" "OpSwitch %2 %3 100 %4 102 %5 6000000000 %6\n", // Unsigned 64-bit, three non-default cases. "%1 = OpTypeInt 64 0\n%2 = OpConstant %1 9223372036854775807\n" "OpSwitch %2 %3 100 %4 102 %5 9000000000000000000 %6\n", }))); INSTANTIATE_TEST_SUITE_P( OpSwitchRoundTripSignedIntegers, ControlFlowRoundTripTest, ValuesIn(std::vector{ // Signed 16-bit, with two non-default cases "%1 = OpTypeInt 16 1\n%2 = OpConstant %1 32767\n" "OpSwitch %2 %3 99 %4 -102 %5\n", "%1 = OpTypeInt 16 1\n%2 = OpConstant %1 -32768\n" "OpSwitch %2 %3 99 %4 -102 %5\n", // Signed 32-bit, two non-default cases. "%1 = OpTypeInt 32 1\n%2 = OpConstant %1 -123456\n" "OpSwitch %2 %3 100 %4 -123456 %5\n", "%1 = OpTypeInt 32 1\n%2 = OpConstant %1 123456\n" "OpSwitch %2 %3 100 %4 123456 %5\n", // Signed 48-bit, three non-default cases. "%1 = OpTypeInt 48 1\n%2 = OpConstant %1 5000000000\n" "OpSwitch %2 %3 100 %4 -7000000000 %5 6000000000 %6\n", "%1 = OpTypeInt 48 1\n%2 = OpConstant %1 -5000000000\n" "OpSwitch %2 %3 100 %4 -7000000000 %5 6000000000 %6\n", // Signed 64-bit, three non-default cases. "%1 = OpTypeInt 64 1\n%2 = OpConstant %1 9223372036854775807\n" "OpSwitch %2 %3 100 %4 7000000000 %5 -1000000000000000000 %6\n", "%1 = OpTypeInt 64 1\n%2 = OpConstant %1 -9223372036854775808\n" "OpSwitch %2 %3 100 %4 7000000000 %5 -1000000000000000000 %6\n", })); using OpSwitchInvalidTypeTestCase = spvtest::TextToBinaryTestBase>; TEST_P(OpSwitchInvalidTypeTestCase, InvalidTypes) { const std::string input = "%1 = " + GetParam() + "\n" "%3 = OpCopyObject %1 %2\n" // We only care the type of the expression " OpSwitch %3 %default 32 %c\n"; EXPECT_THAT(CompileFailure(input), Eq("The selector operand for OpSwitch must be the result of an " "instruction that generates an integer scalar")); } // clang-format off INSTANTIATE_TEST_SUITE_P( TextToBinaryOpSwitchInvalidTests, OpSwitchInvalidTypeTestCase, ValuesIn(std::vector{ {"OpTypeVoid", "OpTypeBool", "OpTypeFloat 32", "OpTypeVector %a 32", "OpTypeMatrix %a 32", "OpTypeImage %a 1D 0 0 0 0 Unknown", "OpTypeSampler", "OpTypeSampledImage %a", "OpTypeArray %a %b", "OpTypeRuntimeArray %a", "OpTypeStruct %a", "OpTypeOpaque \"Foo\"", "OpTypePointer UniformConstant %a", "OpTypeFunction %a %b", "OpTypeEvent", "OpTypeDeviceEvent", "OpTypeReserveId", "OpTypeQueue", "OpTypePipe ReadOnly", // Skip OpTypeForwardPointer because it doesn't even produce a result // ID. // At least one thing that isn't a type at all "OpNot %a %b" }, })); // clang-format on using OpKillTest = spvtest::TextToBinaryTest; INSTANTIATE_TEST_SUITE_P(OpKillTest, ControlFlowRoundTripTest, Values("OpKill\n")); TEST_F(OpKillTest, ExtraArgsAssemblyError) { const std::string input = "OpKill 1"; EXPECT_THAT(CompileFailure(input), Eq("Expected or at the beginning of an " "instruction, found '1'.")); } using OpTerminateInvocationTest = spvtest::TextToBinaryTest; INSTANTIATE_TEST_SUITE_P(OpTerminateInvocationTest, ControlFlowRoundTripTest, Values("OpTerminateInvocation\n")); TEST_F(OpTerminateInvocationTest, ExtraArgsAssemblyError) { const std::string input = "OpTerminateInvocation 1"; EXPECT_THAT(CompileFailure(input), Eq("Expected or at the beginning of an " "instruction, found '1'.")); } // TODO(dneto): OpPhi // TODO(dneto): OpLoopMerge // TODO(dneto): OpLabel // TODO(dneto): OpBranch // TODO(dneto): OpSwitch // TODO(dneto): OpReturn // TODO(dneto): OpReturnValue // TODO(dneto): OpUnreachable // TODO(dneto): OpLifetimeStart // TODO(dneto): OpLifetimeStop } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/text_to_binary.debug_test.cpp000066400000000000000000000164441475742701700254030ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Assembler tests for instructions in the "Debug" section of the // SPIR-V spec. #include #include #include "gmock/gmock.h" #include "source/util/string_utils.h" #include "test/test_fixture.h" #include "test/unit_spirv.h" namespace spvtools { namespace { using spvtest::MakeInstruction; using utils::MakeVector; using spvtest::TextToBinaryTest; using ::testing::Eq; // Test OpSource // A single test case for OpSource struct LanguageCase { uint32_t get_language_value() const { return static_cast(language_value); } const char* language_name; spv::SourceLanguage language_value; uint32_t version; }; // clang-format off // The list of OpSource cases to use. const LanguageCase kLanguageCases[] = { #define CASE(NAME, VERSION) \ { #NAME, spv::SourceLanguage::NAME, VERSION } CASE(Unknown, 0), CASE(Unknown, 999), CASE(ESSL, 310), CASE(GLSL, 450), CASE(OpenCL_C, 120), CASE(OpenCL_C, 200), CASE(OpenCL_C, 210), CASE(OpenCL_CPP, 210), CASE(HLSL, 5), CASE(HLSL, 6), #undef CASE }; // clang-format on using OpSourceTest = spvtest::TextToBinaryTestBase<::testing::TestWithParam>; TEST_P(OpSourceTest, AnyLanguage) { const std::string input = std::string("OpSource ") + GetParam().language_name + " " + std::to_string(GetParam().version); EXPECT_THAT( CompiledInstructions(input), Eq(MakeInstruction(spv::Op::OpSource, {GetParam().get_language_value(), GetParam().version}))); } INSTANTIATE_TEST_SUITE_P(TextToBinaryTestDebug, OpSourceTest, ::testing::ValuesIn(kLanguageCases)); TEST_F(OpSourceTest, WrongLanguage) { EXPECT_THAT(CompileFailure("OpSource xxyyzz 12345"), Eq("Invalid source language 'xxyyzz'.")); } TEST_F(TextToBinaryTest, OpSourceAcceptsOptionalFileId) { // In the grammar, the file id is an OperandOptionalId. const std::string input = "OpSource GLSL 450 %file_id"; EXPECT_THAT( CompiledInstructions(input), Eq(MakeInstruction(spv::Op::OpSource, {uint32_t(spv::SourceLanguage::GLSL), 450, 1}))); } TEST_F(TextToBinaryTest, OpSourceAcceptsOptionalSourceText) { std::string fake_source = "To be or not to be"; const std::string input = "OpSource GLSL 450 %file_id \"" + fake_source + "\""; EXPECT_THAT(CompiledInstructions(input), Eq(MakeInstruction(spv::Op::OpSource, {uint32_t(spv::SourceLanguage::GLSL), 450, 1}, MakeVector(fake_source)))); } // Test OpSourceContinued using OpSourceContinuedTest = spvtest::TextToBinaryTestBase<::testing::TestWithParam>; TEST_P(OpSourceContinuedTest, AnyExtension) { // TODO(dneto): utf-8, quoting, escaping const std::string input = std::string("OpSourceContinued \"") + GetParam() + "\""; EXPECT_THAT( CompiledInstructions(input), Eq(MakeInstruction(spv::Op::OpSourceContinued, MakeVector(GetParam())))); } // TODO(dneto): utf-8, quoting, escaping INSTANTIATE_TEST_SUITE_P(TextToBinaryTestDebug, OpSourceContinuedTest, ::testing::ValuesIn(std::vector{ "", "foo bar this and that"})); // Test OpSourceExtension using OpSourceExtensionTest = spvtest::TextToBinaryTestBase<::testing::TestWithParam>; TEST_P(OpSourceExtensionTest, AnyExtension) { // TODO(dneto): utf-8, quoting, escaping const std::string input = std::string("OpSourceExtension \"") + GetParam() + "\""; EXPECT_THAT( CompiledInstructions(input), Eq(MakeInstruction(spv::Op::OpSourceExtension, MakeVector(GetParam())))); } // TODO(dneto): utf-8, quoting, escaping INSTANTIATE_TEST_SUITE_P(TextToBinaryTestDebug, OpSourceExtensionTest, ::testing::ValuesIn(std::vector{ "", "foo bar this and that"})); TEST_F(TextToBinaryTest, OpLine) { EXPECT_THAT(CompiledInstructions("OpLine %srcfile 42 99"), Eq(MakeInstruction(spv::Op::OpLine, {1, 42, 99}))); } TEST_F(TextToBinaryTest, OpNoLine) { EXPECT_THAT(CompiledInstructions("OpNoLine"), Eq(MakeInstruction(spv::Op::OpNoLine, {}))); } using OpStringTest = spvtest::TextToBinaryTestBase<::testing::TestWithParam>; TEST_P(OpStringTest, AnyString) { // TODO(dneto): utf-8, quoting, escaping const std::string input = std::string("%result = OpString \"") + GetParam() + "\""; EXPECT_THAT( CompiledInstructions(input), Eq(MakeInstruction(spv::Op::OpString, {1}, MakeVector(GetParam())))); } // TODO(dneto): utf-8, quoting, escaping INSTANTIATE_TEST_SUITE_P(TextToBinaryTestDebug, OpStringTest, ::testing::ValuesIn(std::vector{ "", "foo bar this and that"})); using OpNameTest = spvtest::TextToBinaryTestBase<::testing::TestWithParam>; TEST_P(OpNameTest, AnyString) { const std::string input = std::string("OpName %target \"") + GetParam() + "\""; EXPECT_THAT( CompiledInstructions(input), Eq(MakeInstruction(spv::Op::OpName, {1}, MakeVector(GetParam())))); } // UTF-8, quoting, escaping, etc. are covered in the StringLiterals tests in // BinaryToText.Literal.cpp. INSTANTIATE_TEST_SUITE_P(TextToBinaryTestDebug, OpNameTest, ::testing::Values("", "foo bar this and that")); using OpMemberNameTest = spvtest::TextToBinaryTestBase<::testing::TestWithParam>; TEST_P(OpMemberNameTest, AnyString) { // TODO(dneto): utf-8, quoting, escaping const std::string input = std::string("OpMemberName %type 42 \"") + GetParam() + "\""; EXPECT_THAT(CompiledInstructions(input), Eq(MakeInstruction(spv::Op::OpMemberName, {1, 42}, MakeVector(GetParam())))); } // TODO(dneto): utf-8, quoting, escaping INSTANTIATE_TEST_SUITE_P(TextToBinaryTestDebug, OpMemberNameTest, ::testing::ValuesIn(std::vector{ "", "foo bar this and that"})); // TODO(dneto): Parse failures? using OpModuleProcessedTest = spvtest::TextToBinaryTestBase<::testing::TestWithParam>; TEST_P(OpModuleProcessedTest, AnyString) { const std::string input = std::string("OpModuleProcessed \"") + GetParam() + "\""; EXPECT_THAT( CompiledInstructions(input, SPV_ENV_UNIVERSAL_1_1), Eq(MakeInstruction(spv::Op::OpModuleProcessed, MakeVector(GetParam())))); } INSTANTIATE_TEST_SUITE_P(TextToBinaryTestDebug, OpModuleProcessedTest, ::testing::Values("", "foo bar this and that")); } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/text_to_binary.device_side_enqueue_test.cpp000066400000000000000000000101201475742701700302700ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Assembler tests for instructions in the "Device-Side Enqueue Instructions" // section of the SPIR-V spec. #include #include #include "gmock/gmock.h" #include "test/test_fixture.h" #include "test/unit_spirv.h" namespace spvtools { namespace { using spvtest::MakeInstruction; using ::testing::Eq; // Test OpEnqueueKernel struct KernelEnqueueCase { std::string local_size_source; std::vector local_size_operands; }; using OpEnqueueKernelGood = spvtest::TextToBinaryTestBase<::testing::TestWithParam>; TEST_P(OpEnqueueKernelGood, Sample) { const std::string input = "%result = OpEnqueueKernel %type %queue %flags %NDRange %num_events" " %wait_events %ret_event %invoke %param %param_size %param_align " + GetParam().local_size_source; EXPECT_THAT(CompiledInstructions(input), Eq(MakeInstruction(spv::Op::OpEnqueueKernel, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}, GetParam().local_size_operands))); } INSTANTIATE_TEST_SUITE_P( TextToBinaryTest, OpEnqueueKernelGood, ::testing::ValuesIn(std::vector{ // Provide IDs for pointer-to-local arguments for the // invoked function. // Test up to 10 such arguments. // I (dneto) can't find a limit on the number of kernel // arguments in OpenCL C 2.0 Rev 29, e.g. in section 6.9 // Restrictions. {"", {}}, {"%l0", {13}}, {"%l0 %l1", {13, 14}}, {"%l0 %l1 %l2", {13, 14, 15}}, {"%l0 %l1 %l2 %l3", {13, 14, 15, 16}}, {"%l0 %l1 %l2 %l3 %l4", {13, 14, 15, 16, 17}}, {"%l0 %l1 %l2 %l3 %l4 %l5", {13, 14, 15, 16, 17, 18}}, {"%l0 %l1 %l2 %l3 %l4 %l5 %l6", {13, 14, 15, 16, 17, 18, 19}}, {"%l0 %l1 %l2 %l3 %l4 %l5 %l6 %l7", {13, 14, 15, 16, 17, 18, 19, 20}}, {"%l0 %l1 %l2 %l3 %l4 %l5 %l6 %l7 %l8", {13, 14, 15, 16, 17, 18, 19, 20, 21}}, {"%l0 %l1 %l2 %l3 %l4 %l5 %l6 %l7 %l8 %l9", {13, 14, 15, 16, 17, 18, 19, 20, 21, 22}}, })); // Test some bad parses of OpEnqueueKernel. For other cases, we're relying // on the uniformity of the parsing algorithm. The following two tests, ensure // that every required ID operand is specified, and is actually an ID operand. using OpKernelEnqueueBad = spvtest::TextToBinaryTest; TEST_F(OpKernelEnqueueBad, MissingLastOperand) { EXPECT_THAT( CompileFailure( "%result = OpEnqueueKernel %type %queue %flags %NDRange %num_events" " %wait_events %ret_event %invoke %param %param_size"), Eq("Expected operand for OpEnqueueKernel instruction, but found the end " "of the stream.")); } TEST_F(OpKernelEnqueueBad, InvalidLastOperand) { EXPECT_THAT( CompileFailure( "%result = OpEnqueueKernel %type %queue %flags %NDRange %num_events" " %wait_events %ret_event %invoke %param %param_size 42"), Eq("Expected id to start with %.")); } // TODO(dneto): OpEnqueueMarker // TODO(dneto): OpGetKernelNDRangeSubGroupCount // TODO(dneto): OpGetKernelNDRangeMaxSubGroupSize // TODO(dneto): OpGetKernelWorkGroupSize // TODO(dneto): OpGetKernelPreferredWorkGroupSizeMultiple // TODO(dneto): OpRetainEvent // TODO(dneto): OpReleaseEvent // TODO(dneto): OpCreateUserEvent // TODO(dneto): OpSetUserEventStatus // TODO(dneto): OpCaptureEventProfilingInfo // TODO(dneto): OpGetDefaultQueue // TODO(dneto): OpBuildNDRange // TODO(dneto): OpBuildNDRange } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/text_to_binary.extension_test.cpp000066400000000000000000002040571475742701700263300ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Assembler tests for instructions in the "Extension Instruction" section // of the SPIR-V spec. #include #include #include #include "gmock/gmock.h" #include "source/latest_version_glsl_std_450_header.h" #include "source/latest_version_opencl_std_header.h" #include "source/util/string_utils.h" #include "test/test_fixture.h" #include "test/unit_spirv.h" namespace spvtools { namespace { using spvtest::Concatenate; using spvtest::MakeInstruction; using utils::MakeVector; using spvtest::TextToBinaryTest; using ::testing::Combine; using ::testing::Eq; using ::testing::Values; using ::testing::ValuesIn; // Returns a generator of common Vulkan environment values to be tested. std::vector CommonVulkanEnvs() { return {SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1, SPV_ENV_UNIVERSAL_1_2, SPV_ENV_UNIVERSAL_1_3, SPV_ENV_VULKAN_1_0, SPV_ENV_VULKAN_1_1}; } TEST_F(TextToBinaryTest, InvalidExtInstImportName) { EXPECT_THAT(CompileFailure("%1 = OpExtInstImport \"Haskell.std\""), Eq("Invalid extended instruction import 'Haskell.std'")); } TEST_F(TextToBinaryTest, InvalidImportId) { EXPECT_THAT(CompileFailure("%1 = OpTypeVoid\n" "%2 = OpExtInst %1 %1"), Eq("Invalid extended instruction import Id 2")); } TEST_F(TextToBinaryTest, InvalidImportInstruction) { const std::string input = R"(%1 = OpTypeVoid %2 = OpExtInstImport "OpenCL.std" %3 = OpExtInst %1 %2 not_in_the_opencl)"; EXPECT_THAT(CompileFailure(input), Eq("Invalid extended instruction name 'not_in_the_opencl'.")); } TEST_F(TextToBinaryTest, MultiImport) { const std::string input = R"(%2 = OpExtInstImport "OpenCL.std" %2 = OpExtInstImport "OpenCL.std")"; EXPECT_THAT(CompileFailure(input), Eq("Import Id is being defined a second time")); } TEST_F(TextToBinaryTest, TooManyArguments) { const std::string input = R"(%opencl = OpExtInstImport "OpenCL.std" %2 = OpExtInst %float %opencl cos %x %oops")"; EXPECT_THAT(CompileFailure(input), Eq("Expected '=', found end of stream.")); } TEST_F(TextToBinaryTest, ExtInstFromTwoDifferentImports) { const std::string input = R"(%1 = OpExtInstImport "OpenCL.std" %2 = OpExtInstImport "GLSL.std.450" %4 = OpExtInst %3 %1 native_sqrt %5 %7 = OpExtInst %6 %2 MatrixInverse %8 )"; // Make sure it assembles correctly. EXPECT_THAT( CompiledInstructions(input), Eq(Concatenate({ MakeInstruction(spv::Op::OpExtInstImport, {1}, MakeVector("OpenCL.std")), MakeInstruction(spv::Op::OpExtInstImport, {2}, MakeVector("GLSL.std.450")), MakeInstruction( spv::Op::OpExtInst, {3, 4, 1, uint32_t(OpenCLLIB::Entrypoints::Native_sqrt), 5}), MakeInstruction(spv::Op::OpExtInst, {6, 7, 2, uint32_t(GLSLstd450MatrixInverse), 8}), }))); // Make sure it disassembles correctly. EXPECT_THAT(EncodeAndDecodeSuccessfully(input), Eq(input)); } // A test case for assembling into words in an instruction. struct AssemblyCase { std::string input; std::vector expected; }; using ExtensionAssemblyTest = spvtest::TextToBinaryTestBase< ::testing::TestWithParam>>; TEST_P(ExtensionAssemblyTest, Samples) { const spv_target_env& env = std::get<0>(GetParam()); const AssemblyCase& ac = std::get<1>(GetParam()); // Check that it assembles correctly. EXPECT_THAT(CompiledInstructions(ac.input, env), Eq(ac.expected)); } using ExtensionRoundTripTest = spvtest::TextToBinaryTestBase< ::testing::TestWithParam>>; TEST_P(ExtensionRoundTripTest, Samples) { const spv_target_env& env = std::get<0>(GetParam()); const AssemblyCase& ac = std::get<1>(GetParam()); // Check that it assembles correctly. EXPECT_THAT(CompiledInstructions(ac.input, env), Eq(ac.expected)); // Check round trip through the disassembler. EXPECT_THAT( EncodeAndDecodeSuccessfully(ac.input, SPV_BINARY_TO_TEXT_OPTION_NONE, SPV_TEXT_TO_BINARY_OPTION_NONE, env), Eq(ac.input)) << "target env: " << spvTargetEnvDescription(env) << "\n"; } // SPV_KHR_shader_ballot INSTANTIATE_TEST_SUITE_P( SPV_KHR_shader_ballot, ExtensionRoundTripTest, // We'll get coverage over operand tables by trying the universal // environments, and at least one specific environment. Combine( Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1, SPV_ENV_VULKAN_1_0), ValuesIn(std::vector{ {"OpCapability SubgroupBallotKHR\n", MakeInstruction(spv::Op::OpCapability, {uint32_t(spv::Capability::SubgroupBallotKHR)})}, {"%2 = OpSubgroupBallotKHR %1 %3\n", MakeInstruction(spv::Op::OpSubgroupBallotKHR, {1, 2, 3})}, {"%2 = OpSubgroupFirstInvocationKHR %1 %3\n", MakeInstruction(spv::Op::OpSubgroupFirstInvocationKHR, {1, 2, 3})}, {"OpDecorate %1 BuiltIn SubgroupEqMask\n", MakeInstruction(spv::Op::OpDecorate, {1, uint32_t(spv::Decoration::BuiltIn), uint32_t(spv::BuiltIn::SubgroupEqMaskKHR)})}, {"OpDecorate %1 BuiltIn SubgroupGeMask\n", MakeInstruction(spv::Op::OpDecorate, {1, uint32_t(spv::Decoration::BuiltIn), uint32_t(spv::BuiltIn::SubgroupGeMaskKHR)})}, {"OpDecorate %1 BuiltIn SubgroupGtMask\n", MakeInstruction(spv::Op::OpDecorate, {1, uint32_t(spv::Decoration::BuiltIn), uint32_t(spv::BuiltIn::SubgroupGtMaskKHR)})}, {"OpDecorate %1 BuiltIn SubgroupLeMask\n", MakeInstruction(spv::Op::OpDecorate, {1, uint32_t(spv::Decoration::BuiltIn), uint32_t(spv::BuiltIn::SubgroupLeMaskKHR)})}, {"OpDecorate %1 BuiltIn SubgroupLtMask\n", MakeInstruction(spv::Op::OpDecorate, {1, uint32_t(spv::Decoration::BuiltIn), uint32_t(spv::BuiltIn::SubgroupLtMaskKHR)})}, }))); INSTANTIATE_TEST_SUITE_P( SPV_KHR_shader_ballot_vulkan_1_1, ExtensionRoundTripTest, // In SPIR-V 1.3 and Vulkan 1.1 we can drop the KHR suffix on the // builtin enums. Combine( Values(SPV_ENV_UNIVERSAL_1_3, SPV_ENV_VULKAN_1_1), ValuesIn(std::vector{ {"OpCapability SubgroupBallotKHR\n", MakeInstruction(spv::Op::OpCapability, {(uint32_t)spv::Capability::SubgroupBallotKHR})}, {"%2 = OpSubgroupBallotKHR %1 %3\n", MakeInstruction(spv::Op::OpSubgroupBallotKHR, {1, 2, 3})}, {"%2 = OpSubgroupFirstInvocationKHR %1 %3\n", MakeInstruction(spv::Op::OpSubgroupFirstInvocationKHR, {1, 2, 3})}, {"OpDecorate %1 BuiltIn SubgroupEqMask\n", MakeInstruction(spv::Op::OpDecorate, {1, uint32_t(spv::Decoration::BuiltIn), uint32_t(spv::BuiltIn::SubgroupEqMask)})}, {"OpDecorate %1 BuiltIn SubgroupGeMask\n", MakeInstruction(spv::Op::OpDecorate, {1, uint32_t(spv::Decoration::BuiltIn), uint32_t(spv::BuiltIn::SubgroupGeMask)})}, {"OpDecorate %1 BuiltIn SubgroupGtMask\n", MakeInstruction(spv::Op::OpDecorate, {1, uint32_t(spv::Decoration::BuiltIn), uint32_t(spv::BuiltIn::SubgroupGtMask)})}, {"OpDecorate %1 BuiltIn SubgroupLeMask\n", MakeInstruction(spv::Op::OpDecorate, {1, uint32_t(spv::Decoration::BuiltIn), uint32_t(spv::BuiltIn::SubgroupLeMask)})}, {"OpDecorate %1 BuiltIn SubgroupLtMask\n", MakeInstruction(spv::Op::OpDecorate, {1, uint32_t(spv::Decoration::BuiltIn), uint32_t(spv::BuiltIn::SubgroupLtMask)})}, }))); // The old builtin names (with KHR suffix) still work in the assembler, and // map to the enums without the KHR. INSTANTIATE_TEST_SUITE_P( SPV_KHR_shader_ballot_vulkan_1_1_alias_check, ExtensionAssemblyTest, // In SPIR-V 1.3 and Vulkan 1.1 we can drop the KHR suffix on the // builtin enums. Combine(Values(SPV_ENV_UNIVERSAL_1_3, SPV_ENV_VULKAN_1_1), ValuesIn(std::vector{ {"OpDecorate %1 BuiltIn SubgroupEqMaskKHR\n", MakeInstruction(spv::Op::OpDecorate, {1, (uint32_t)spv::Decoration::BuiltIn, (uint32_t)spv::BuiltIn::SubgroupEqMask})}, {"OpDecorate %1 BuiltIn SubgroupGeMaskKHR\n", MakeInstruction(spv::Op::OpDecorate, {1, (uint32_t)spv::Decoration::BuiltIn, (uint32_t)spv::BuiltIn::SubgroupGeMask})}, {"OpDecorate %1 BuiltIn SubgroupGtMaskKHR\n", MakeInstruction(spv::Op::OpDecorate, {1, (uint32_t)spv::Decoration::BuiltIn, (uint32_t)spv::BuiltIn::SubgroupGtMask})}, {"OpDecorate %1 BuiltIn SubgroupLeMaskKHR\n", MakeInstruction(spv::Op::OpDecorate, {1, (uint32_t)spv::Decoration::BuiltIn, (uint32_t)spv::BuiltIn::SubgroupLeMask})}, {"OpDecorate %1 BuiltIn SubgroupLtMaskKHR\n", MakeInstruction(spv::Op::OpDecorate, {1, (uint32_t)spv::Decoration::BuiltIn, (uint32_t)spv::BuiltIn::SubgroupLtMask})}, }))); // SPV_KHR_shader_draw_parameters INSTANTIATE_TEST_SUITE_P( SPV_KHR_shader_draw_parameters, ExtensionRoundTripTest, // We'll get coverage over operand tables by trying the universal // environments, and at least one specific environment. Combine(ValuesIn(CommonVulkanEnvs()), ValuesIn(std::vector{ {"OpCapability DrawParameters\n", MakeInstruction(spv::Op::OpCapability, {(uint32_t)spv::Capability::DrawParameters})}, {"OpDecorate %1 BuiltIn BaseVertex\n", MakeInstruction(spv::Op::OpDecorate, {1, (uint32_t)spv::Decoration::BuiltIn, (uint32_t)spv::BuiltIn::BaseVertex})}, {"OpDecorate %1 BuiltIn BaseInstance\n", MakeInstruction(spv::Op::OpDecorate, {1, (uint32_t)spv::Decoration::BuiltIn, (uint32_t)spv::BuiltIn::BaseInstance})}, {"OpDecorate %1 BuiltIn DrawIndex\n", MakeInstruction(spv::Op::OpDecorate, {1, (uint32_t)spv::Decoration::BuiltIn, (uint32_t)spv::BuiltIn::DrawIndex})}, }))); // SPV_KHR_subgroup_vote INSTANTIATE_TEST_SUITE_P( SPV_KHR_subgroup_vote, ExtensionRoundTripTest, // We'll get coverage over operand tables by trying the universal // environments, and at least one specific environment. Combine(ValuesIn(CommonVulkanEnvs()), ValuesIn(std::vector{ {"OpCapability SubgroupVoteKHR\n", MakeInstruction(spv::Op::OpCapability, {(uint32_t)spv::Capability::SubgroupVoteKHR})}, {"%2 = OpSubgroupAnyKHR %1 %3\n", MakeInstruction(spv::Op::OpSubgroupAnyKHR, {1, 2, 3})}, {"%2 = OpSubgroupAllKHR %1 %3\n", MakeInstruction(spv::Op::OpSubgroupAllKHR, {1, 2, 3})}, {"%2 = OpSubgroupAllEqualKHR %1 %3\n", MakeInstruction(spv::Op::OpSubgroupAllEqualKHR, {1, 2, 3})}, }))); // SPV_KHR_16bit_storage INSTANTIATE_TEST_SUITE_P( SPV_KHR_16bit_storage, ExtensionRoundTripTest, // We'll get coverage over operand tables by trying the universal // environments, and at least one specific environment. Combine( ValuesIn(CommonVulkanEnvs()), ValuesIn(std::vector{ {"OpCapability StorageBuffer16BitAccess\n", MakeInstruction( spv::Op::OpCapability, {(uint32_t)spv::Capability::StorageUniformBufferBlock16})}, {"OpCapability StorageBuffer16BitAccess\n", MakeInstruction( spv::Op::OpCapability, {(uint32_t)spv::Capability::StorageBuffer16BitAccess})}, {"OpCapability UniformAndStorageBuffer16BitAccess\n", MakeInstruction( spv::Op::OpCapability, {(uint32_t) spv::Capability::UniformAndStorageBuffer16BitAccess})}, {"OpCapability UniformAndStorageBuffer16BitAccess\n", MakeInstruction(spv::Op::OpCapability, {(uint32_t)spv::Capability::StorageUniform16})}, {"OpCapability StoragePushConstant16\n", MakeInstruction( spv::Op::OpCapability, {(uint32_t)spv::Capability::StoragePushConstant16})}, {"OpCapability StorageInputOutput16\n", MakeInstruction( spv::Op::OpCapability, {(uint32_t)spv::Capability::StorageInputOutput16})}, }))); INSTANTIATE_TEST_SUITE_P( SPV_KHR_16bit_storage_alias_check, ExtensionAssemblyTest, Combine( ValuesIn(CommonVulkanEnvs()), ValuesIn(std::vector{ // The old name maps to the new enum. {"OpCapability StorageUniformBufferBlock16\n", MakeInstruction( spv::Op::OpCapability, {(uint32_t)spv::Capability::StorageBuffer16BitAccess})}, // The new name maps to the old enum. {"OpCapability UniformAndStorageBuffer16BitAccess\n", MakeInstruction(spv::Op::OpCapability, {(uint32_t)spv::Capability::StorageUniform16})}, }))); // SPV_KHR_device_group INSTANTIATE_TEST_SUITE_P( SPV_KHR_device_group, ExtensionRoundTripTest, // We'll get coverage over operand tables by trying the universal // environments, and at least one specific environment. Combine(ValuesIn(CommonVulkanEnvs()), ValuesIn(std::vector{ {"OpCapability DeviceGroup\n", MakeInstruction(spv::Op::OpCapability, {(uint32_t)spv::Capability::DeviceGroup})}, {"OpDecorate %1 BuiltIn DeviceIndex\n", MakeInstruction(spv::Op::OpDecorate, {1, (uint32_t)spv::Decoration::BuiltIn, (uint32_t)spv::BuiltIn::DeviceIndex})}, }))); // SPV_KHR_8bit_storage INSTANTIATE_TEST_SUITE_P( SPV_KHR_8bit_storage, ExtensionRoundTripTest, // We'll get coverage over operand tables by trying the universal // environments, and at least one specific environment. Combine(ValuesIn(CommonVulkanEnvs()), ValuesIn(std::vector{ {"OpCapability StorageBuffer8BitAccess\n", MakeInstruction( spv::Op::OpCapability, {(uint32_t)spv::Capability::StorageBuffer8BitAccess})}, {"OpCapability UniformAndStorageBuffer8BitAccess\n", MakeInstruction( spv::Op::OpCapability, {(uint32_t) spv::Capability::UniformAndStorageBuffer8BitAccess})}, {"OpCapability StoragePushConstant8\n", MakeInstruction( spv::Op::OpCapability, {(uint32_t)spv::Capability::StoragePushConstant8})}, }))); // SPV_KHR_multiview INSTANTIATE_TEST_SUITE_P( SPV_KHR_multiview, ExtensionRoundTripTest, // We'll get coverage over operand tables by trying the universal // environments, and at least one specific environment. Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1, SPV_ENV_VULKAN_1_0), ValuesIn(std::vector{ {"OpCapability MultiView\n", MakeInstruction(spv::Op::OpCapability, {(uint32_t)spv::Capability::MultiView})}, {"OpDecorate %1 BuiltIn ViewIndex\n", MakeInstruction(spv::Op::OpDecorate, {1, (uint32_t)spv::Decoration::BuiltIn, (uint32_t)spv::BuiltIn::ViewIndex})}, }))); // SPV_AMD_shader_explicit_vertex_parameter #define PREAMBLE \ "%1 = OpExtInstImport \"SPV_AMD_shader_explicit_vertex_parameter\"\n" INSTANTIATE_TEST_SUITE_P( SPV_AMD_shader_explicit_vertex_parameter, ExtensionRoundTripTest, // We'll get coverage over operand tables by trying the universal // environments, and at least one specific environment. Combine( Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1, SPV_ENV_VULKAN_1_0), ValuesIn(std::vector{ {PREAMBLE "%3 = OpExtInst %2 %1 InterpolateAtVertexAMD %4 %5\n", Concatenate( {MakeInstruction( spv::Op::OpExtInstImport, {1}, MakeVector("SPV_AMD_shader_explicit_vertex_parameter")), MakeInstruction(spv::Op::OpExtInst, {2, 3, 1, 1, 4, 5})})}, }))); #undef PREAMBLE // SPV_AMD_shader_trinary_minmax #define PREAMBLE "%1 = OpExtInstImport \"SPV_AMD_shader_trinary_minmax\"\n" INSTANTIATE_TEST_SUITE_P( SPV_AMD_shader_trinary_minmax, ExtensionRoundTripTest, // We'll get coverage over operand tables by trying the universal // environments, and at least one specific environment. Combine( Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1, SPV_ENV_VULKAN_1_0), ValuesIn(std::vector{ {PREAMBLE "%3 = OpExtInst %2 %1 FMin3AMD %4 %5 %6\n", Concatenate( {MakeInstruction(spv::Op::OpExtInstImport, {1}, MakeVector("SPV_AMD_shader_trinary_minmax")), MakeInstruction(spv::Op::OpExtInst, {2, 3, 1, 1, 4, 5, 6})})}, {PREAMBLE "%3 = OpExtInst %2 %1 UMin3AMD %4 %5 %6\n", Concatenate( {MakeInstruction(spv::Op::OpExtInstImport, {1}, MakeVector("SPV_AMD_shader_trinary_minmax")), MakeInstruction(spv::Op::OpExtInst, {2, 3, 1, 2, 4, 5, 6})})}, {PREAMBLE "%3 = OpExtInst %2 %1 SMin3AMD %4 %5 %6\n", Concatenate( {MakeInstruction(spv::Op::OpExtInstImport, {1}, MakeVector("SPV_AMD_shader_trinary_minmax")), MakeInstruction(spv::Op::OpExtInst, {2, 3, 1, 3, 4, 5, 6})})}, {PREAMBLE "%3 = OpExtInst %2 %1 FMax3AMD %4 %5 %6\n", Concatenate( {MakeInstruction(spv::Op::OpExtInstImport, {1}, MakeVector("SPV_AMD_shader_trinary_minmax")), MakeInstruction(spv::Op::OpExtInst, {2, 3, 1, 4, 4, 5, 6})})}, {PREAMBLE "%3 = OpExtInst %2 %1 UMax3AMD %4 %5 %6\n", Concatenate( {MakeInstruction(spv::Op::OpExtInstImport, {1}, MakeVector("SPV_AMD_shader_trinary_minmax")), MakeInstruction(spv::Op::OpExtInst, {2, 3, 1, 5, 4, 5, 6})})}, {PREAMBLE "%3 = OpExtInst %2 %1 SMax3AMD %4 %5 %6\n", Concatenate( {MakeInstruction(spv::Op::OpExtInstImport, {1}, MakeVector("SPV_AMD_shader_trinary_minmax")), MakeInstruction(spv::Op::OpExtInst, {2, 3, 1, 6, 4, 5, 6})})}, {PREAMBLE "%3 = OpExtInst %2 %1 FMid3AMD %4 %5 %6\n", Concatenate( {MakeInstruction(spv::Op::OpExtInstImport, {1}, MakeVector("SPV_AMD_shader_trinary_minmax")), MakeInstruction(spv::Op::OpExtInst, {2, 3, 1, 7, 4, 5, 6})})}, {PREAMBLE "%3 = OpExtInst %2 %1 UMid3AMD %4 %5 %6\n", Concatenate( {MakeInstruction(spv::Op::OpExtInstImport, {1}, MakeVector("SPV_AMD_shader_trinary_minmax")), MakeInstruction(spv::Op::OpExtInst, {2, 3, 1, 8, 4, 5, 6})})}, {PREAMBLE "%3 = OpExtInst %2 %1 SMid3AMD %4 %5 %6\n", Concatenate( {MakeInstruction(spv::Op::OpExtInstImport, {1}, MakeVector("SPV_AMD_shader_trinary_minmax")), MakeInstruction(spv::Op::OpExtInst, {2, 3, 1, 9, 4, 5, 6})})}, }))); #undef PREAMBLE // SPV_AMD_gcn_shader #define PREAMBLE "%1 = OpExtInstImport \"SPV_AMD_gcn_shader\"\n" INSTANTIATE_TEST_SUITE_P( SPV_AMD_gcn_shader, ExtensionRoundTripTest, // We'll get coverage over operand tables by trying the universal // environments, and at least one specific environment. Combine( Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1, SPV_ENV_VULKAN_1_0), ValuesIn(std::vector{ {PREAMBLE "%3 = OpExtInst %2 %1 CubeFaceIndexAMD %4\n", Concatenate({MakeInstruction(spv::Op::OpExtInstImport, {1}, MakeVector("SPV_AMD_gcn_shader")), MakeInstruction(spv::Op::OpExtInst, {2, 3, 1, 1, 4})})}, {PREAMBLE "%3 = OpExtInst %2 %1 CubeFaceCoordAMD %4\n", Concatenate({MakeInstruction(spv::Op::OpExtInstImport, {1}, MakeVector("SPV_AMD_gcn_shader")), MakeInstruction(spv::Op::OpExtInst, {2, 3, 1, 2, 4})})}, {PREAMBLE "%3 = OpExtInst %2 %1 TimeAMD\n", Concatenate({MakeInstruction(spv::Op::OpExtInstImport, {1}, MakeVector("SPV_AMD_gcn_shader")), MakeInstruction(spv::Op::OpExtInst, {2, 3, 1, 3})})}, }))); #undef PREAMBLE // SPV_AMD_shader_ballot #define PREAMBLE "%1 = OpExtInstImport \"SPV_AMD_shader_ballot\"\n" INSTANTIATE_TEST_SUITE_P( SPV_AMD_shader_ballot, ExtensionRoundTripTest, // We'll get coverage over operand tables by trying the universal // environments, and at least one specific environment. Combine( Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1, SPV_ENV_VULKAN_1_0), ValuesIn(std::vector{ {PREAMBLE "%3 = OpExtInst %2 %1 SwizzleInvocationsAMD %4 %5\n", Concatenate({MakeInstruction(spv::Op::OpExtInstImport, {1}, MakeVector("SPV_AMD_shader_ballot")), MakeInstruction(spv::Op::OpExtInst, {2, 3, 1, 1, 4, 5})})}, {PREAMBLE "%3 = OpExtInst %2 %1 SwizzleInvocationsMaskedAMD %4 %5\n", Concatenate({MakeInstruction(spv::Op::OpExtInstImport, {1}, MakeVector("SPV_AMD_shader_ballot")), MakeInstruction(spv::Op::OpExtInst, {2, 3, 1, 2, 4, 5})})}, {PREAMBLE "%3 = OpExtInst %2 %1 WriteInvocationAMD %4 %5 %6\n", Concatenate({MakeInstruction(spv::Op::OpExtInstImport, {1}, MakeVector("SPV_AMD_shader_ballot")), MakeInstruction(spv::Op::OpExtInst, {2, 3, 1, 3, 4, 5, 6})})}, {PREAMBLE "%3 = OpExtInst %2 %1 MbcntAMD %4\n", Concatenate({MakeInstruction(spv::Op::OpExtInstImport, {1}, MakeVector("SPV_AMD_shader_ballot")), MakeInstruction(spv::Op::OpExtInst, {2, 3, 1, 4, 4})})}, }))); #undef PREAMBLE // SPV_KHR_variable_pointers INSTANTIATE_TEST_SUITE_P( SPV_KHR_variable_pointers, ExtensionRoundTripTest, // We'll get coverage over operand tables by trying the universal // environments, and at least one specific environment. Combine( Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1, SPV_ENV_VULKAN_1_0), ValuesIn(std::vector{ {"OpCapability VariablePointers\n", MakeInstruction(spv::Op::OpCapability, {(uint32_t)spv::Capability::VariablePointers})}, {"OpCapability VariablePointersStorageBuffer\n", MakeInstruction( spv::Op::OpCapability, {(uint32_t)spv::Capability::VariablePointersStorageBuffer})}, }))); // SPV_KHR_vulkan_memory_model INSTANTIATE_TEST_SUITE_P( SPV_KHR_vulkan_memory_model, ExtensionRoundTripTest, // We'll get coverage over operand tables by trying the universal // environments, and at least one specific environment. // // Note: SPV_KHR_vulkan_memory_model adds scope enum value QueueFamilyKHR. // Scope enums are used in ID definitions elsewhere, that don't know they // are using particular enums. So the assembler doesn't support assembling // those enums names into the corresponding values. So there is no asm/dis // tests for those enums. Combine( Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1, SPV_ENV_UNIVERSAL_1_3, SPV_ENV_VULKAN_1_0, SPV_ENV_VULKAN_1_1), ValuesIn(std::vector{ {"OpCapability VulkanMemoryModel\n", MakeInstruction( spv::Op::OpCapability, {(uint32_t)spv::Capability::VulkanMemoryModelKHR})}, {"OpCapability VulkanMemoryModelDeviceScope\n", MakeInstruction( spv::Op::OpCapability, {(uint32_t)spv::Capability::VulkanMemoryModelDeviceScopeKHR})}, {"OpMemoryModel Logical Vulkan\n", MakeInstruction(spv::Op::OpMemoryModel, {(uint32_t)spv::AddressingModel::Logical, (uint32_t)spv::MemoryModel::VulkanKHR})}, {"OpStore %1 %2 MakePointerAvailable %3\n", MakeInstruction( spv::Op::OpStore, {1, 2, (uint32_t)spv::MemoryAccessMask::MakePointerAvailableKHR, 3})}, {"OpStore %1 %2 Volatile|MakePointerAvailable %3\n", MakeInstruction( spv::Op::OpStore, {1, 2, int(spv::MemoryAccessMask::MakePointerAvailableKHR) | int(spv::MemoryAccessMask::Volatile), 3})}, {"OpStore %1 %2 Aligned|MakePointerAvailable 4 %3\n", MakeInstruction( spv::Op::OpStore, {1, 2, int(spv::MemoryAccessMask::MakePointerAvailableKHR) | int(spv::MemoryAccessMask::Aligned), 4, 3})}, {"OpStore %1 %2 MakePointerAvailable|NonPrivatePointer %3\n", MakeInstruction( spv::Op::OpStore, {1, 2, int(spv::MemoryAccessMask::MakePointerAvailableKHR) | int(spv::MemoryAccessMask::NonPrivatePointerKHR), 3})}, {"%2 = OpLoad %1 %3 MakePointerVisible %4\n", MakeInstruction( spv::Op::OpLoad, {1, 2, 3, (uint32_t)spv::MemoryAccessMask::MakePointerVisibleKHR, 4})}, {"%2 = OpLoad %1 %3 Volatile|MakePointerVisible %4\n", MakeInstruction( spv::Op::OpLoad, {1, 2, 3, int(spv::MemoryAccessMask::MakePointerVisibleKHR) | int(spv::MemoryAccessMask::Volatile), 4})}, {"%2 = OpLoad %1 %3 Aligned|MakePointerVisible 8 %4\n", MakeInstruction( spv::Op::OpLoad, {1, 2, 3, int(spv::MemoryAccessMask::MakePointerVisibleKHR) | int(spv::MemoryAccessMask::Aligned), 8, 4})}, {"%2 = OpLoad %1 %3 MakePointerVisible|NonPrivatePointer " "%4\n", MakeInstruction( spv::Op::OpLoad, {1, 2, 3, int(spv::MemoryAccessMask::MakePointerVisibleKHR) | int(spv::MemoryAccessMask::NonPrivatePointerKHR), 4})}, {"OpCopyMemory %1 %2 " "MakePointerAvailable|" "MakePointerVisible|" "NonPrivatePointer " "%3 %4\n", MakeInstruction( spv::Op::OpCopyMemory, {1, 2, (int(spv::MemoryAccessMask::MakePointerVisibleKHR) | int(spv::MemoryAccessMask::MakePointerAvailableKHR) | int(spv::MemoryAccessMask::NonPrivatePointerKHR)), 3, 4})}, {"OpCopyMemorySized %1 %2 %3 " "MakePointerAvailable|" "MakePointerVisible|" "NonPrivatePointer " "%4 %5\n", MakeInstruction( spv::Op::OpCopyMemorySized, {1, 2, 3, (int(spv::MemoryAccessMask::MakePointerVisibleKHR) | int(spv::MemoryAccessMask::MakePointerAvailableKHR) | int(spv::MemoryAccessMask::NonPrivatePointerKHR)), 4, 5})}, // Image operands {"OpImageWrite %1 %2 %3 MakeTexelAvailable " "%4\n", MakeInstruction( spv::Op::OpImageWrite, {1, 2, 3, int(spv::ImageOperandsMask::MakeTexelAvailableKHR), 4})}, {"OpImageWrite %1 %2 %3 MakeTexelAvailable|NonPrivateTexel " "%4\n", MakeInstruction( spv::Op::OpImageWrite, {1, 2, 3, int(spv::ImageOperandsMask::MakeTexelAvailableKHR) | int(spv::ImageOperandsMask::NonPrivateTexelKHR), 4})}, {"OpImageWrite %1 %2 %3 " "MakeTexelAvailable|NonPrivateTexel|VolatileTexel " "%4\n", MakeInstruction( spv::Op::OpImageWrite, {1, 2, 3, int(spv::ImageOperandsMask::MakeTexelAvailableKHR) | int(spv::ImageOperandsMask::NonPrivateTexelKHR) | int(spv::ImageOperandsMask::VolatileTexelKHR), 4})}, {"%2 = OpImageRead %1 %3 %4 MakeTexelVisible " "%5\n", MakeInstruction(spv::Op::OpImageRead, {1, 2, 3, 4, int(spv::ImageOperandsMask::MakeTexelVisibleKHR), 5})}, {"%2 = OpImageRead %1 %3 %4 " "MakeTexelVisible|NonPrivateTexel " "%5\n", MakeInstruction( spv::Op::OpImageRead, {1, 2, 3, 4, int(spv::ImageOperandsMask::MakeTexelVisibleKHR) | int(spv::ImageOperandsMask::NonPrivateTexelKHR), 5})}, {"%2 = OpImageRead %1 %3 %4 " "MakeTexelVisible|NonPrivateTexel|VolatileTexel " "%5\n", MakeInstruction( spv::Op::OpImageRead, {1, 2, 3, 4, int(spv::ImageOperandsMask::MakeTexelVisibleKHR) | int(spv::ImageOperandsMask::NonPrivateTexelKHR) | int(spv::ImageOperandsMask::VolatileTexelKHR), 5})}, // Memory semantics ID values are numbers put into a SPIR-V // constant integer referenced by Id. There is no token for // them, and so no assembler or disassembler support required. // Similar for Scope ID. }))); // SPV_GOOGLE_decorate_string // Now that OpDecorateString is the preferred spelling for // OpDecorateStringGOOGLE use that name in round trip tests, and the GOOGLE // name in an assembly-only test. INSTANTIATE_TEST_SUITE_P( SPV_GOOGLE_decorate_string, ExtensionRoundTripTest, Combine( // We'll get coverage over operand tables by trying the universal // environments, and at least one specific environment. Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1, SPV_ENV_UNIVERSAL_1_2, SPV_ENV_VULKAN_1_0), ValuesIn(std::vector{ {"OpDecorateString %1 UserSemantic \"ABC\"\n", MakeInstruction(spv::Op::OpDecorateStringGOOGLE, {1, (uint32_t)spv::Decoration::HlslSemanticGOOGLE}, MakeVector("ABC"))}, {"OpDecorateString %1 UserSemantic \"ABC\"\n", MakeInstruction(spv::Op::OpDecorateString, {1, (uint32_t)spv::Decoration::UserSemantic}, MakeVector("ABC"))}, {"OpMemberDecorateString %1 3 UserSemantic \"DEF\"\n", MakeInstruction(spv::Op::OpMemberDecorateStringGOOGLE, {1, 3, (uint32_t)spv::Decoration::UserSemantic}, MakeVector("DEF"))}, {"OpMemberDecorateString %1 3 UserSemantic \"DEF\"\n", MakeInstruction(spv::Op::OpMemberDecorateString, {1, 3, (uint32_t)spv::Decoration::UserSemantic}, MakeVector("DEF"))}, }))); INSTANTIATE_TEST_SUITE_P( SPV_GOOGLE_decorate_string, ExtensionAssemblyTest, Combine( // We'll get coverage over operand tables by trying the universal // environments, and at least one specific environment. Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1, SPV_ENV_UNIVERSAL_1_2, SPV_ENV_VULKAN_1_0), ValuesIn(std::vector{ {"OpDecorateStringGOOGLE %1 HlslSemanticGOOGLE \"ABC\"\n", MakeInstruction(spv::Op::OpDecorateStringGOOGLE, {1, (uint32_t)spv::Decoration::HlslSemanticGOOGLE}, MakeVector("ABC"))}, {"OpMemberDecorateStringGOOGLE %1 3 HlslSemanticGOOGLE \"DEF\"\n", MakeInstruction(spv::Op::OpMemberDecorateStringGOOGLE, {1, 3, (uint32_t)spv::Decoration::HlslSemanticGOOGLE}, MakeVector("DEF"))}, }))); // SPV_GOOGLE_hlsl_functionality1 // Now that CounterBuffer is the preferred spelling for HlslCounterBufferGOOGLE, // use that name in round trip tests, and the GOOGLE name in an assembly-only // test. INSTANTIATE_TEST_SUITE_P( SPV_GOOGLE_hlsl_functionality1, ExtensionRoundTripTest, Combine( // We'll get coverage over operand tables by trying the universal // environments, and at least one specific environment. Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1, SPV_ENV_UNIVERSAL_1_2, SPV_ENV_VULKAN_1_0), // HlslSemanticGOOGLE is tested in SPV_GOOGLE_decorate_string, since // they are coupled together. ValuesIn(std::vector{ {"OpDecorateId %1 CounterBuffer %2\n", MakeInstruction( spv::Op::OpDecorateId, {1, (uint32_t)spv::Decoration::HlslCounterBufferGOOGLE, 2})}, {"OpDecorateId %1 CounterBuffer %2\n", MakeInstruction(spv::Op::OpDecorateId, {1, (uint32_t)spv::Decoration::CounterBuffer, 2})}, }))); INSTANTIATE_TEST_SUITE_P( SPV_GOOGLE_hlsl_functionality1, ExtensionAssemblyTest, Combine( // We'll get coverage over operand tables by trying the universal // environments, and at least one specific environment. Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1, SPV_ENV_UNIVERSAL_1_2, SPV_ENV_VULKAN_1_0), // HlslSemanticGOOGLE is tested in SPV_GOOGLE_decorate_string, since // they are coupled together. ValuesIn(std::vector{ {"OpDecorateId %1 HlslCounterBufferGOOGLE %2\n", MakeInstruction( spv::Op::OpDecorateId, {1, (uint32_t)spv::Decoration::HlslCounterBufferGOOGLE, 2})}, }))); // SPV_NV_viewport_array2 INSTANTIATE_TEST_SUITE_P( SPV_NV_viewport_array2, ExtensionRoundTripTest, Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1, SPV_ENV_UNIVERSAL_1_2, SPV_ENV_UNIVERSAL_1_3, SPV_ENV_VULKAN_1_0, SPV_ENV_VULKAN_1_1), ValuesIn(std::vector{ {"OpExtension \"SPV_NV_viewport_array2\"\n", MakeInstruction(spv::Op::OpExtension, MakeVector("SPV_NV_viewport_array2"))}, // The EXT and NV extensions have the same token number for this // capability. {"OpCapability ShaderViewportIndexLayerEXT\n", MakeInstruction( spv::Op::OpCapability, {(uint32_t)spv::Capability::ShaderViewportIndexLayerNV})}, // Check the new capability's token number {"OpCapability ShaderViewportIndexLayerEXT\n", MakeInstruction(spv::Op::OpCapability, {5254})}, // Decorations {"OpDecorate %1 ViewportRelativeNV\n", MakeInstruction( spv::Op::OpDecorate, {1, (uint32_t)spv::Decoration::ViewportRelativeNV})}, {"OpDecorate %1 BuiltIn ViewportMaskNV\n", MakeInstruction(spv::Op::OpDecorate, {1, (uint32_t)spv::Decoration::BuiltIn, (uint32_t)spv::BuiltIn::ViewportMaskNV})}, }))); // SPV_NV_shader_subgroup_partitioned INSTANTIATE_TEST_SUITE_P( SPV_NV_shader_subgroup_partitioned, ExtensionRoundTripTest, Combine( Values(SPV_ENV_UNIVERSAL_1_3, SPV_ENV_VULKAN_1_1), ValuesIn(std::vector{ {"OpExtension \"SPV_NV_shader_subgroup_partitioned\"\n", MakeInstruction(spv::Op::OpExtension, MakeVector("SPV_NV_shader_subgroup_partitioned"))}, {"OpCapability GroupNonUniformPartitionedNV\n", MakeInstruction( spv::Op::OpCapability, {(uint32_t)spv::Capability::GroupNonUniformPartitionedNV})}, // Check the new capability's token number {"OpCapability GroupNonUniformPartitionedNV\n", MakeInstruction(spv::Op::OpCapability, {5297})}, {"%2 = OpGroupNonUniformPartitionNV %1 %3\n", MakeInstruction(spv::Op::OpGroupNonUniformPartitionNV, {1, 2, 3})}, // Check the new instruction's token number {"%2 = OpGroupNonUniformPartitionNV %1 %3\n", MakeInstruction(static_cast(5296), {1, 2, 3})}, // Check the new group operations {"%2 = OpGroupIAdd %1 %3 PartitionedReduceNV %4\n", MakeInstruction( spv::Op::OpGroupIAdd, {1, 2, 3, (uint32_t)spv::GroupOperation::PartitionedReduceNV, 4})}, {"%2 = OpGroupIAdd %1 %3 PartitionedReduceNV %4\n", MakeInstruction(spv::Op::OpGroupIAdd, {1, 2, 3, 6, 4})}, {"%2 = OpGroupIAdd %1 %3 PartitionedInclusiveScanNV %4\n", MakeInstruction( spv::Op::OpGroupIAdd, {1, 2, 3, (uint32_t)spv::GroupOperation::PartitionedInclusiveScanNV, 4})}, {"%2 = OpGroupIAdd %1 %3 PartitionedInclusiveScanNV %4\n", MakeInstruction(spv::Op::OpGroupIAdd, {1, 2, 3, 7, 4})}, {"%2 = OpGroupIAdd %1 %3 PartitionedExclusiveScanNV %4\n", MakeInstruction( spv::Op::OpGroupIAdd, {1, 2, 3, (uint32_t)spv::GroupOperation::PartitionedExclusiveScanNV, 4})}, {"%2 = OpGroupIAdd %1 %3 PartitionedExclusiveScanNV %4\n", MakeInstruction(spv::Op::OpGroupIAdd, {1, 2, 3, 8, 4})}, }))); // SPV_EXT_descriptor_indexing INSTANTIATE_TEST_SUITE_P( SPV_EXT_descriptor_indexing, ExtensionRoundTripTest, Combine( Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1, SPV_ENV_UNIVERSAL_1_2, SPV_ENV_UNIVERSAL_1_3, SPV_ENV_VULKAN_1_0, SPV_ENV_VULKAN_1_1), ValuesIn(std::vector{ {"OpExtension \"SPV_EXT_descriptor_indexing\"\n", MakeInstruction(spv::Op::OpExtension, MakeVector("SPV_EXT_descriptor_indexing"))}, // Check capabilities, by name {"OpCapability ShaderNonUniform\n", MakeInstruction(spv::Op::OpCapability, {(uint32_t)spv::Capability::ShaderNonUniformEXT})}, {"OpCapability RuntimeDescriptorArray\n", MakeInstruction( spv::Op::OpCapability, {(uint32_t)spv::Capability::RuntimeDescriptorArrayEXT})}, {"OpCapability InputAttachmentArrayDynamicIndexing\n", MakeInstruction(spv::Op::OpCapability, {(uint32_t)spv::Capability:: InputAttachmentArrayDynamicIndexingEXT})}, {"OpCapability UniformTexelBufferArrayDynamicIndexing\n", MakeInstruction(spv::Op::OpCapability, {(uint32_t)spv::Capability:: UniformTexelBufferArrayDynamicIndexingEXT})}, {"OpCapability StorageTexelBufferArrayDynamicIndexing\n", MakeInstruction(spv::Op::OpCapability, {(uint32_t)spv::Capability:: StorageTexelBufferArrayDynamicIndexingEXT})}, {"OpCapability UniformBufferArrayNonUniformIndexing\n", MakeInstruction(spv::Op::OpCapability, {(uint32_t)spv::Capability:: UniformBufferArrayNonUniformIndexingEXT})}, {"OpCapability SampledImageArrayNonUniformIndexing\n", MakeInstruction(spv::Op::OpCapability, {(uint32_t)spv::Capability:: SampledImageArrayNonUniformIndexingEXT})}, {"OpCapability StorageBufferArrayNonUniformIndexing\n", MakeInstruction(spv::Op::OpCapability, {(uint32_t)spv::Capability:: StorageBufferArrayNonUniformIndexingEXT})}, {"OpCapability StorageImageArrayNonUniformIndexing\n", MakeInstruction(spv::Op::OpCapability, {(uint32_t)spv::Capability:: StorageImageArrayNonUniformIndexingEXT})}, {"OpCapability InputAttachmentArrayNonUniformIndexing\n", MakeInstruction(spv::Op::OpCapability, {(uint32_t)spv::Capability:: InputAttachmentArrayNonUniformIndexingEXT})}, {"OpCapability UniformTexelBufferArrayNonUniformIndexing\n", MakeInstruction( spv::Op::OpCapability, {(uint32_t)spv::Capability:: UniformTexelBufferArrayNonUniformIndexingEXT})}, {"OpCapability StorageTexelBufferArrayNonUniformIndexing\n", MakeInstruction( spv::Op::OpCapability, {(uint32_t)spv::Capability:: StorageTexelBufferArrayNonUniformIndexingEXT})}, // Check capabilities, by number {"OpCapability ShaderNonUniform\n", MakeInstruction(spv::Op::OpCapability, {5301})}, {"OpCapability RuntimeDescriptorArray\n", MakeInstruction(spv::Op::OpCapability, {5302})}, {"OpCapability InputAttachmentArrayDynamicIndexing\n", MakeInstruction(spv::Op::OpCapability, {5303})}, {"OpCapability UniformTexelBufferArrayDynamicIndexing\n", MakeInstruction(spv::Op::OpCapability, {5304})}, {"OpCapability StorageTexelBufferArrayDynamicIndexing\n", MakeInstruction(spv::Op::OpCapability, {5305})}, {"OpCapability UniformBufferArrayNonUniformIndexing\n", MakeInstruction(spv::Op::OpCapability, {5306})}, {"OpCapability SampledImageArrayNonUniformIndexing\n", MakeInstruction(spv::Op::OpCapability, {5307})}, {"OpCapability StorageBufferArrayNonUniformIndexing\n", MakeInstruction(spv::Op::OpCapability, {5308})}, {"OpCapability StorageImageArrayNonUniformIndexing\n", MakeInstruction(spv::Op::OpCapability, {5309})}, {"OpCapability InputAttachmentArrayNonUniformIndexing\n", MakeInstruction(spv::Op::OpCapability, {5310})}, {"OpCapability UniformTexelBufferArrayNonUniformIndexing\n", MakeInstruction(spv::Op::OpCapability, {5311})}, {"OpCapability StorageTexelBufferArrayNonUniformIndexing\n", MakeInstruction(spv::Op::OpCapability, {5312})}, // Check the decoration token {"OpDecorate %1 NonUniform\n", MakeInstruction(spv::Op::OpDecorate, {1, (uint32_t)spv::Decoration::NonUniformEXT})}, {"OpDecorate %1 NonUniform\n", MakeInstruction(spv::Op::OpDecorate, {1, 5300})}, }))); // SPV_KHR_linkonce_odr INSTANTIATE_TEST_SUITE_P( SPV_KHR_linkonce_odr, ExtensionRoundTripTest, Combine( Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_3, SPV_ENV_VULKAN_1_0, SPV_ENV_VULKAN_1_1, SPV_ENV_VULKAN_1_2), ValuesIn(std::vector{ {"OpExtension \"SPV_KHR_linkonce_odr\"\n", MakeInstruction(spv::Op::OpExtension, MakeVector("SPV_KHR_linkonce_odr"))}, {"OpDecorate %1 LinkageAttributes \"foobar\" LinkOnceODR\n", MakeInstruction( spv::Op::OpDecorate, Concatenate({{1, (uint32_t)spv::Decoration::LinkageAttributes}, MakeVector("foobar"), {(uint32_t)spv::LinkageType::LinkOnceODR}}))}, }))); // SPV_KHR_expect_assume INSTANTIATE_TEST_SUITE_P( SPV_KHR_expect_assume, ExtensionRoundTripTest, Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_3, SPV_ENV_VULKAN_1_0, SPV_ENV_VULKAN_1_1, SPV_ENV_VULKAN_1_2), ValuesIn(std::vector{ {"OpExtension \"SPV_KHR_expect_assume\"\n", MakeInstruction(spv::Op::OpExtension, MakeVector("SPV_KHR_expect_assume"))}, {"OpAssumeTrueKHR %1\n", MakeInstruction(spv::Op::OpAssumeTrueKHR, {1})}}))); // SPV_KHR_subgroup_uniform_control_flow INSTANTIATE_TEST_SUITE_P( SPV_KHR_subgroup_uniform_control_flow, ExtensionRoundTripTest, Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_3, SPV_ENV_VULKAN_1_0, SPV_ENV_VULKAN_1_1, SPV_ENV_VULKAN_1_2), ValuesIn(std::vector{ {"OpExtension \"SPV_KHR_subgroup_uniform_control_flow\"\n", MakeInstruction( spv::Op::OpExtension, MakeVector("SPV_KHR_subgroup_uniform_control_flow"))}, {"OpExecutionMode %1 SubgroupUniformControlFlowKHR\n", MakeInstruction(spv::Op::OpExecutionMode, {1, (uint32_t)spv::ExecutionMode:: SubgroupUniformControlFlowKHR})}, }))); // SPV_KHR_integer_dot_product INSTANTIATE_TEST_SUITE_P( SPV_KHR_integer_dot_product, ExtensionRoundTripTest, Combine( Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_5, SPV_ENV_UNIVERSAL_1_6, SPV_ENV_VULKAN_1_0, SPV_ENV_VULKAN_1_1, SPV_ENV_VULKAN_1_2, SPV_ENV_VULKAN_1_3), ValuesIn(std::vector{ {"OpExtension \"SPV_KHR_integer_dot_product\"\n", MakeInstruction(spv::Op::OpExtension, MakeVector("SPV_KHR_integer_dot_product"))}, {"OpCapability DotProductInputAll\n", MakeInstruction( spv::Op::OpCapability, {(uint32_t)spv::Capability::DotProductInputAllKHR})}, {"OpCapability DotProductInput4x8Bit\n", MakeInstruction( spv::Op::OpCapability, {(uint32_t)spv::Capability::DotProductInput4x8BitKHR})}, {"OpCapability DotProductInput4x8BitPacked\n", MakeInstruction( spv::Op::OpCapability, {(uint32_t)spv::Capability::DotProductInput4x8BitPackedKHR})}, {"OpCapability DotProduct\n", MakeInstruction(spv::Op::OpCapability, {(uint32_t)spv::Capability::DotProductKHR})}, {"%2 = OpSDot %1 %3 %4\n", MakeInstruction(spv::Op::OpSDotKHR, {1, 2, 3, 4})}, {"%2 = OpSDot %1 %3 %4 PackedVectorFormat4x8Bit\n", MakeInstruction( spv::Op::OpSDotKHR, {1, 2, 3, 4, (uint32_t) spv::PackedVectorFormat::PackedVectorFormat4x8BitKHR})}, {"%2 = OpUDot %1 %3 %4\n", MakeInstruction(spv::Op::OpUDotKHR, {1, 2, 3, 4})}, {"%2 = OpUDot %1 %3 %4 PackedVectorFormat4x8Bit\n", MakeInstruction( spv::Op::OpUDotKHR, {1, 2, 3, 4, (uint32_t) spv::PackedVectorFormat::PackedVectorFormat4x8BitKHR})}, {"%2 = OpSUDot %1 %3 %4\n", MakeInstruction(spv::Op::OpSUDotKHR, {1, 2, 3, 4})}, {"%2 = OpSUDot %1 %3 %4 PackedVectorFormat4x8Bit\n", MakeInstruction( spv::Op::OpSUDotKHR, {1, 2, 3, 4, (uint32_t) spv::PackedVectorFormat::PackedVectorFormat4x8BitKHR})}, {"%2 = OpSDotAccSat %1 %3 %4 %5\n", MakeInstruction(spv::Op::OpSDotAccSatKHR, {1, 2, 3, 4, 5})}, {"%2 = OpSDotAccSat %1 %3 %4 %5 PackedVectorFormat4x8Bit\n", MakeInstruction( spv::Op::OpSDotAccSatKHR, {1, 2, 3, 4, 5, (uint32_t) spv::PackedVectorFormat::PackedVectorFormat4x8BitKHR})}, {"%2 = OpUDotAccSat %1 %3 %4 %5\n", MakeInstruction(spv::Op::OpUDotAccSatKHR, {1, 2, 3, 4, 5})}, {"%2 = OpUDotAccSat %1 %3 %4 %5 PackedVectorFormat4x8Bit\n", MakeInstruction( spv::Op::OpUDotAccSatKHR, {1, 2, 3, 4, 5, (uint32_t) spv::PackedVectorFormat::PackedVectorFormat4x8BitKHR})}, {"%2 = OpSUDotAccSat %1 %3 %4 %5\n", MakeInstruction(spv::Op::OpSUDotAccSatKHR, {1, 2, 3, 4, 5})}, {"%2 = OpSUDotAccSat %1 %3 %4 %5 PackedVectorFormat4x8Bit\n", MakeInstruction( spv::Op::OpSUDotAccSatKHR, {1, 2, 3, 4, 5, (uint32_t) spv::PackedVectorFormat::PackedVectorFormat4x8BitKHR})}, }))); // SPV_KHR_bit_instructions INSTANTIATE_TEST_SUITE_P( SPV_KHR_bit_instructions, ExtensionRoundTripTest, Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_5, SPV_ENV_VULKAN_1_0, SPV_ENV_VULKAN_1_1, SPV_ENV_VULKAN_1_2), ValuesIn(std::vector{ {"OpExtension \"SPV_KHR_bit_instructions\"\n", MakeInstruction(spv::Op::OpExtension, MakeVector("SPV_KHR_bit_instructions"))}, {"OpCapability BitInstructions\n", MakeInstruction(spv::Op::OpCapability, {(uint32_t)spv::Capability::BitInstructions})}, }))); // SPV_KHR_uniform_group_instructions INSTANTIATE_TEST_SUITE_P( SPV_KHR_uniform_group_instructions, ExtensionRoundTripTest, Combine( Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_5, SPV_ENV_UNIVERSAL_1_6, SPV_ENV_VULKAN_1_0, SPV_ENV_VULKAN_1_1, SPV_ENV_VULKAN_1_2, SPV_ENV_VULKAN_1_3), ValuesIn(std::vector{ {"OpExtension \"SPV_KHR_uniform_group_instructions\"\n", MakeInstruction(spv::Op::OpExtension, MakeVector("SPV_KHR_uniform_group_instructions"))}, {"OpCapability GroupUniformArithmeticKHR\n", MakeInstruction( spv::Op::OpCapability, {(uint32_t)spv::Capability::GroupUniformArithmeticKHR})}, {"%2 = OpGroupIMulKHR %1 %3 Reduce %4\n", MakeInstruction(spv::Op::OpGroupIMulKHR, {1, 2, 3, (uint32_t)spv::GroupOperation::Reduce, 4})}, {"%2 = OpGroupFMulKHR %1 %3 Reduce %4\n", MakeInstruction(spv::Op::OpGroupFMulKHR, {1, 2, 3, (uint32_t)spv::GroupOperation::Reduce, 4})}, {"%2 = OpGroupBitwiseAndKHR %1 %3 Reduce %4\n", MakeInstruction(spv::Op::OpGroupBitwiseAndKHR, {1, 2, 3, (uint32_t)spv::GroupOperation::Reduce, 4})}, {"%2 = OpGroupBitwiseOrKHR %1 %3 Reduce %4\n", MakeInstruction(spv::Op::OpGroupBitwiseOrKHR, {1, 2, 3, (uint32_t)spv::GroupOperation::Reduce, 4})}, {"%2 = OpGroupBitwiseXorKHR %1 %3 Reduce %4\n", MakeInstruction(spv::Op::OpGroupBitwiseXorKHR, {1, 2, 3, (uint32_t)spv::GroupOperation::Reduce, 4})}, {"%2 = OpGroupLogicalAndKHR %1 %3 Reduce %4\n", MakeInstruction(spv::Op::OpGroupLogicalAndKHR, {1, 2, 3, (uint32_t)spv::GroupOperation::Reduce, 4})}, {"%2 = OpGroupLogicalOrKHR %1 %3 Reduce %4\n", MakeInstruction(spv::Op::OpGroupLogicalOrKHR, {1, 2, 3, (uint32_t)spv::GroupOperation::Reduce, 4})}, {"%2 = OpGroupLogicalXorKHR %1 %3 Reduce %4\n", MakeInstruction(spv::Op::OpGroupLogicalXorKHR, {1, 2, 3, (uint32_t)spv::GroupOperation::Reduce, 4})}, }))); // SPV_KHR_subgroup_rotate INSTANTIATE_TEST_SUITE_P( SPV_KHR_subgroup_rotate, ExtensionRoundTripTest, Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_6, SPV_ENV_VULKAN_1_0, SPV_ENV_VULKAN_1_1, SPV_ENV_VULKAN_1_2, SPV_ENV_VULKAN_1_3, SPV_ENV_OPENCL_2_1), ValuesIn(std::vector{ {"OpExtension \"SPV_KHR_subgroup_rotate\"\n", MakeInstruction(spv::Op::OpExtension, MakeVector("SPV_KHR_subgroup_rotate"))}, {"OpCapability GroupNonUniformRotateKHR\n", MakeInstruction( spv::Op::OpCapability, {(uint32_t)spv::Capability::GroupNonUniformRotateKHR})}, {"%2 = OpGroupNonUniformRotateKHR %1 %3 %4 %5\n", MakeInstruction(spv::Op::OpGroupNonUniformRotateKHR, {1, 2, 3, 4, 5})}, {"%2 = OpGroupNonUniformRotateKHR %1 %3 %4 %5 %6\n", MakeInstruction(spv::Op::OpGroupNonUniformRotateKHR, {1, 2, 3, 4, 5, 6})}, }))); // SPV_EXT_shader_tile_image INSTANTIATE_TEST_SUITE_P( SPV_EXT_shader_tile_image, ExtensionRoundTripTest, Combine( Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_5, SPV_ENV_VULKAN_1_0, SPV_ENV_VULKAN_1_1, SPV_ENV_VULKAN_1_2, SPV_ENV_VULKAN_1_3), ValuesIn(std::vector{ {"OpExtension \"SPV_EXT_shader_tile_image\"\n", MakeInstruction(spv::Op::OpExtension, MakeVector("SPV_EXT_shader_tile_image"))}, {"OpCapability TileImageColorReadAccessEXT\n", MakeInstruction( spv::Op::OpCapability, {(uint32_t)spv::Capability::TileImageColorReadAccessEXT})}, {"OpCapability TileImageDepthReadAccessEXT\n", MakeInstruction( spv::Op::OpCapability, {(uint32_t)spv::Capability::TileImageDepthReadAccessEXT})}, {"OpCapability TileImageStencilReadAccessEXT\n", MakeInstruction( spv::Op::OpCapability, {(uint32_t)spv::Capability::TileImageStencilReadAccessEXT})}, {"OpExecutionMode %1 NonCoherentColorAttachmentReadEXT\n", MakeInstruction(spv::Op::OpExecutionMode, {1, (uint32_t)spv::ExecutionMode:: NonCoherentColorAttachmentReadEXT})}, {"OpExecutionMode %1 NonCoherentDepthAttachmentReadEXT\n", MakeInstruction(spv::Op::OpExecutionMode, {1, (uint32_t)spv::ExecutionMode:: NonCoherentDepthAttachmentReadEXT})}, {"OpExecutionMode %1 NonCoherentStencilAttachmentReadEXT\n", MakeInstruction(spv::Op::OpExecutionMode, {1, (uint32_t)spv::ExecutionMode:: NonCoherentStencilAttachmentReadEXT})}, {"%2 = OpColorAttachmentReadEXT %1 %3\n", MakeInstruction(spv::Op::OpColorAttachmentReadEXT, {1, 2, 3})}, {"%2 = OpColorAttachmentReadEXT %1 %3 %4\n", MakeInstruction(spv::Op::OpColorAttachmentReadEXT, {1, 2, 3, 4})}, {"%2 = OpDepthAttachmentReadEXT %1\n", MakeInstruction(spv::Op::OpDepthAttachmentReadEXT, {1, 2})}, {"%2 = OpDepthAttachmentReadEXT %1 %3\n", MakeInstruction(spv::Op::OpDepthAttachmentReadEXT, {1, 2, 3})}, {"%2 = OpStencilAttachmentReadEXT %1\n", MakeInstruction(spv::Op::OpStencilAttachmentReadEXT, {1, 2})}, {"%2 = OpStencilAttachmentReadEXT %1 %3\n", MakeInstruction(spv::Op::OpStencilAttachmentReadEXT, {1, 2, 3})}, }))); // SPV_KHR_maximal_reconvergence INSTANTIATE_TEST_SUITE_P( SPV_KHR_maximal_reconvergence, ExtensionRoundTripTest, Combine( Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_5, SPV_ENV_VULKAN_1_0, SPV_ENV_VULKAN_1_1, SPV_ENV_VULKAN_1_2, SPV_ENV_VULKAN_1_3), ValuesIn(std::vector{ {"OpExtension \"SPV_KHR_maximal_reconvergence\"\n", MakeInstruction(spv::Op::OpExtension, MakeVector("SPV_KHR_maximal_reconvergence"))}, {"OpExecutionMode %1 MaximallyReconvergesKHR\n", MakeInstruction( spv::Op::OpExecutionMode, {1, (uint32_t)spv::ExecutionMode::MaximallyReconvergesKHR})}, }))); // SPV_KHR_float_controls2 INSTANTIATE_TEST_SUITE_P( SPV_KHR_float_controls2, ExtensionRoundTripTest, Combine( Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_5, SPV_ENV_VULKAN_1_0, SPV_ENV_VULKAN_1_1, SPV_ENV_VULKAN_1_2, SPV_ENV_VULKAN_1_3), ValuesIn(std::vector{ {"OpExtension \"SPV_KHR_float_controls2\"\n", MakeInstruction(spv::Op::OpExtension, MakeVector("SPV_KHR_float_controls2"))}, {"OpCapability FloatControls2\n", MakeInstruction(spv::Op::OpCapability, {(uint32_t)spv::Capability::FloatControls2})}, {"OpExecutionMode %1 FPFastMathDefault %2 %3\n", // The operands are: target type, flags constant MakeInstruction( spv::Op::OpExecutionMode, {1, (uint32_t)spv::ExecutionMode::FPFastMathDefault, 2, 3})}, {"OpDecorate %1 FPFastMathMode AllowContract\n", MakeInstruction( spv::Op::OpDecorate, {1, (uint32_t)spv::Decoration::FPFastMathMode, (uint32_t)spv::FPFastMathModeMask::AllowContract})}, {"OpDecorate %1 FPFastMathMode AllowReassoc\n", MakeInstruction( spv::Op::OpDecorate, {1, (uint32_t)spv::Decoration::FPFastMathMode, (uint32_t)spv::FPFastMathModeMask::AllowReassoc})}, {"OpDecorate %1 FPFastMathMode AllowTransform\n", MakeInstruction( spv::Op::OpDecorate, {1, (uint32_t)spv::Decoration::FPFastMathMode, (uint32_t)spv::FPFastMathModeMask::AllowTransform})}, }))); // SPV_EXT_replicated_composites INSTANTIATE_TEST_SUITE_P( SPV_EXT_replicated_composites, ExtensionRoundTripTest, Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_6, SPV_ENV_VULKAN_1_0, SPV_ENV_VULKAN_1_1, SPV_ENV_VULKAN_1_2, SPV_ENV_VULKAN_1_3, SPV_ENV_OPENCL_2_1), ValuesIn(std::vector{ {"OpExtension \"SPV_EXT_replicated_composites\"\n", MakeInstruction(spv::Op::OpExtension, MakeVector("SPV_EXT_replicated_composites"))}, {"OpCapability ReplicatedCompositesEXT\n", MakeInstruction( spv::Op::OpCapability, {(uint32_t)spv::Capability::ReplicatedCompositesEXT})}, {"%2 = OpConstantCompositeReplicateEXT %1 %3\n", MakeInstruction(spv::Op::OpConstantCompositeReplicateEXT, {1, 2, 3})}, {"%2 = OpSpecConstantCompositeReplicateEXT %1 %3\n", MakeInstruction(spv::Op::OpSpecConstantCompositeReplicateEXT, {1, 2, 3})}, {"%2 = OpCompositeConstructReplicateEXT %1 %3\n", MakeInstruction(spv::Op::OpCompositeConstructReplicateEXT, {1, 2, 3})}, }))); // SPV_KHR_untyped_pointers INSTANTIATE_TEST_SUITE_P( SPV_KHR_untyped_pointers, ExtensionRoundTripTest, Combine( Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_3, SPV_ENV_VULKAN_1_0, SPV_ENV_VULKAN_1_1, SPV_ENV_VULKAN_1_2), ValuesIn(std::vector{ {"OpExtension \"SPV_KHR_untyped_pointers\"\n", MakeInstruction(spv::Op::OpExtension, MakeVector("SPV_KHR_untyped_pointers"))}, {"OpCapability UntypedPointersKHR\n", MakeInstruction(spv::Op::OpCapability, {(int)spv::Capability::UntypedPointersKHR})}, {"OpCapability UntypedPointersKHR\n", MakeInstruction(spv::Op::OpCapability, {4473})}, {"%1 = OpTypeUntypedPointerKHR Workgroup\n", MakeInstruction(spv::Op::OpTypeUntypedPointerKHR, {1, int(spv::StorageClass::Workgroup)})}, {"%2 = OpUntypedVariableKHR %1 Workgroup %3\n", MakeInstruction(spv::Op::OpUntypedVariableKHR, {1, 2, int(spv::StorageClass::Workgroup), 3})}, {"%2 = OpUntypedVariableKHR %1 Workgroup %3 %4\n", MakeInstruction(spv::Op::OpUntypedVariableKHR, {1, 2, int(spv::StorageClass::Workgroup), 3, 4})}, {"%2 = OpUntypedAccessChainKHR %1 %3 %4\n", MakeInstruction(spv::Op::OpUntypedAccessChainKHR, {1, 2, 3, 4})}, {"%2 = OpUntypedAccessChainKHR %1 %3 %4 %5 %6 %7\n", MakeInstruction(spv::Op::OpUntypedAccessChainKHR, {1, 2, 3, 4, 5, 6, 7})}, {"%2 = OpUntypedInBoundsAccessChainKHR %1 %3 %4\n", MakeInstruction(spv::Op::OpUntypedInBoundsAccessChainKHR, {1, 2, 3, 4})}, {"%2 = OpUntypedInBoundsAccessChainKHR %1 %3 %4 %5 %6 %7\n", MakeInstruction(spv::Op::OpUntypedInBoundsAccessChainKHR, {1, 2, 3, 4, 5, 6, 7})}, {"%2 = OpUntypedPtrAccessChainKHR %1 %3 %4 %5\n", MakeInstruction(spv::Op::OpUntypedPtrAccessChainKHR, {1, 2, 3, 4, 5})}, {"%2 = OpUntypedPtrAccessChainKHR %1 %3 %4 %5 %6 %7\n", MakeInstruction(spv::Op::OpUntypedPtrAccessChainKHR, {1, 2, 3, 4, 5, 6, 7})}, {"%2 = OpUntypedInBoundsPtrAccessChainKHR %1 %3 %4 %5\n", MakeInstruction(spv::Op::OpUntypedInBoundsPtrAccessChainKHR, {1, 2, 3, 4, 5})}, {"%2 = OpUntypedInBoundsPtrAccessChainKHR %1 %3 %4 %5 %6 %7\n", MakeInstruction(spv::Op::OpUntypedInBoundsPtrAccessChainKHR, {1, 2, 3, 4, 5, 6, 7})}, }))); } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/text_to_binary.function_test.cpp000066400000000000000000000057541475742701700261440ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Assembler tests for instructions in the "Function" section of the // SPIR-V spec. #include #include #include "gmock/gmock.h" #include "test/test_fixture.h" #include "test/unit_spirv.h" namespace spvtools { namespace { using spvtest::EnumCase; using spvtest::MakeInstruction; using spvtest::TextToBinaryTest; using ::testing::Eq; // Test OpFunction using OpFunctionControlTest = spvtest::TextToBinaryTestBase< ::testing::TestWithParam>>; TEST_P(OpFunctionControlTest, AnySingleFunctionControlMask) { const std::string input = "%result_id = OpFunction %result_type " + GetParam().name() + " %function_type "; EXPECT_THAT(CompiledInstructions(input), Eq(MakeInstruction(spv::Op::OpFunction, {1, 2, (uint32_t)GetParam().value(), 3}))); } // clang-format off #define CASE(VALUE,NAME) { spv::FunctionControlMask::VALUE, NAME } INSTANTIATE_TEST_SUITE_P(TextToBinaryFunctionTest, OpFunctionControlTest, ::testing::ValuesIn(std::vector>{ CASE(MaskNone, "None"), CASE(Inline, "Inline"), CASE(DontInline, "DontInline"), CASE(Pure, "Pure"), CASE(Const, "Const"), })); #undef CASE // clang-format on TEST_F(OpFunctionControlTest, CombinedFunctionControlMask) { // Sample a single combination. This ensures we've integrated // the instruction parsing logic with spvTextParseMask. const std::string input = "%result_id = OpFunction %result_type Inline|Pure|Const %function_type"; const uint32_t expected_mask = uint32_t(spv::FunctionControlMask::Inline | spv::FunctionControlMask::Pure | spv::FunctionControlMask::Const); EXPECT_THAT( CompiledInstructions(input), Eq(MakeInstruction(spv::Op::OpFunction, {1, 2, expected_mask, 3}))); } TEST_F(OpFunctionControlTest, WrongFunctionControl) { EXPECT_THAT(CompileFailure("%r = OpFunction %t Inline|Unroll %ft"), Eq("Invalid function control operand 'Inline|Unroll'.")); } // TODO(dneto): OpFunctionParameter // TODO(dneto): OpFunctionEnd // TODO(dneto): OpFunctionCall } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/text_to_binary.group_test.cpp000066400000000000000000000046241475742701700254460ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Assembler tests for instructions in the "Group Instrucions" section of the // SPIR-V spec. #include #include #include "gmock/gmock.h" #include "test/test_fixture.h" #include "test/unit_spirv.h" namespace spvtools { namespace { using spvtest::EnumCase; using spvtest::MakeInstruction; using ::testing::Eq; // Test GroupOperation enum using GroupOperationTest = spvtest::TextToBinaryTestBase< ::testing::TestWithParam>>; TEST_P(GroupOperationTest, AnyGroupOperation) { const std::string input = "%result = OpGroupIAdd %type %scope " + GetParam().name() + " %x"; EXPECT_THAT(CompiledInstructions(input), Eq(MakeInstruction(spv::Op::OpGroupIAdd, {1, 2, 3, (uint32_t)GetParam().value(), 4}))); } // clang-format off #define CASE(NAME) { spv::GroupOperation::NAME, #NAME} INSTANTIATE_TEST_SUITE_P(TextToBinaryGroupOperation, GroupOperationTest, ::testing::ValuesIn(std::vector>{ CASE(Reduce), CASE(InclusiveScan), CASE(ExclusiveScan), })); #undef CASE // clang-format on TEST_F(GroupOperationTest, WrongGroupOperation) { EXPECT_THAT(CompileFailure("%r = OpGroupUMin %t %e xxyyzz %x"), Eq("Invalid group operation 'xxyyzz'.")); } // TODO(dneto): OpGroupAsyncCopy // TODO(dneto): OpGroupWaitEvents // TODO(dneto): OpGroupAll // TODO(dneto): OpGroupAny // TODO(dneto): OpGroupBroadcast // TODO(dneto): OpGroupIAdd // TODO(dneto): OpGroupFAdd // TODO(dneto): OpGroupFMin // TODO(dneto): OpGroupUMin // TODO(dneto): OpGroupSMin // TODO(dneto): OpGroupFMax // TODO(dneto): OpGroupUMax // TODO(dneto): OpGroupSMax } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/text_to_binary.image_test.cpp000066400000000000000000000256711475742701700254010ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Assembler tests for instructions in the "Image Instructions" section of // the SPIR-V spec. #include #include #include "gmock/gmock.h" #include "test/test_fixture.h" #include "test/unit_spirv.h" namespace spvtools { namespace { using spvtest::MakeInstruction; using spvtest::TextToBinaryTest; using ::testing::Eq; // An example case for a mask value with operands. struct ImageOperandsCase { std::string image_operands; // The expected mask, followed by its operands. std::vector expected_mask_and_operands; }; // Test all kinds of image operands. using ImageOperandsTest = spvtest::TextToBinaryTestBase<::testing::TestWithParam>; TEST_P(ImageOperandsTest, Sample) { const std::string input = "%2 = OpImageFetch %1 %3 %4" + GetParam().image_operands + "\n"; EXPECT_THAT(CompiledInstructions(input), Eq(MakeInstruction(spv::Op::OpImageFetch, {1, 2, 3, 4}, GetParam().expected_mask_and_operands))); } #define MASK(NAME) uint32_t(spv::ImageOperandsMask::NAME) INSTANTIATE_TEST_SUITE_P( TextToBinaryImageOperandsAny, ImageOperandsTest, ::testing::ValuesIn(std::vector{ // TODO(dneto): Rev32 adds many more values, and rearranges their // values. // Image operands are optional. {"", {}}, // Test each kind, alone. {" Bias %5", {MASK(Bias), 5}}, {" Lod %5", {MASK(Lod), 5}}, {" Grad %5 %6", {MASK(Grad), 5, 6}}, {" ConstOffset %5", {MASK(ConstOffset), 5}}, {" Offset %5", {MASK(Offset), 5}}, {" ConstOffsets %5", {MASK(ConstOffsets), 5}}, {" Sample %5", {MASK(Sample), 5}}, {" MinLod %5", {MASK(MinLod), 5}}, })); #undef MASK #define MASK(NAME) static_cast(spv::ImageOperandsMask::NAME) INSTANTIATE_TEST_SUITE_P( TextToBinaryImageOperandsCombination, ImageOperandsTest, ::testing::ValuesIn(std::vector{ // TODO(dneto): Rev32 adds many more values, and rearranges their // values. // Test adjacent pairs, so we can easily debug the values when it fails. {" Bias|Lod %5 %6", {MASK(Bias) | MASK(Lod), 5, 6}}, {" Lod|Grad %5 %6 %7", {MASK(Lod) | MASK(Grad), 5, 6, 7}}, {" Grad|ConstOffset %5 %6 %7", {MASK(Grad) | MASK(ConstOffset), 5, 6, 7}}, {" ConstOffset|Offset %5 %6", {MASK(ConstOffset) | MASK(Offset), 5, 6}}, {" Offset|ConstOffsets %5 %6", {MASK(Offset) | MASK(ConstOffsets), 5, 6}}, {" ConstOffsets|Sample %5 %6", {MASK(ConstOffsets) | MASK(Sample), 5, 6}}, // Test all masks together. {" Bias|Lod|Grad|ConstOffset|Offset|ConstOffsets|Sample" " %5 %6 %7 %8 %9 %10 %11 %12", {MASK(Bias) | MASK(Lod) | MASK(Grad) | MASK(ConstOffset) | MASK(Offset) | MASK(ConstOffsets) | MASK(Sample), 5, 6, 7, 8, 9, 10, 11, 12}}, // The same, but with mask value names reversed. {" Sample|ConstOffsets|Offset|ConstOffset|Grad|Lod|Bias" " %5 %6 %7 %8 %9 %10 %11 %12", {MASK(Bias) | MASK(Lod) | MASK(Grad) | MASK(ConstOffset) | MASK(Offset) | MASK(ConstOffsets) | MASK(Sample), 5, 6, 7, 8, 9, 10, 11, 12}}})); #undef MASK TEST_F(ImageOperandsTest, WrongOperand) { EXPECT_THAT(CompileFailure("%r = OpImageFetch %t %i %c xxyyzz"), Eq("Invalid image operand 'xxyyzz'.")); } // Test OpImage using OpImageTest = TextToBinaryTest; TEST_F(OpImageTest, Valid) { const std::string input = "%2 = OpImage %1 %3\n"; EXPECT_THAT(CompiledInstructions(input), Eq(MakeInstruction(spv::Op::OpImage, {1, 2, 3}))); // Test the disassembler. EXPECT_THAT(EncodeAndDecodeSuccessfully(input), input); } TEST_F(OpImageTest, InvalidTypeOperand) { EXPECT_THAT(CompileFailure("%2 = OpImage 42"), Eq("Expected id to start with %.")); } TEST_F(OpImageTest, MissingSampledImageOperand) { EXPECT_THAT(CompileFailure("%2 = OpImage %1"), Eq("Expected operand for OpImage instruction, but found the end " "of the stream.")); } TEST_F(OpImageTest, InvalidSampledImageOperand) { EXPECT_THAT(CompileFailure("%2 = OpImage %1 1000"), Eq("Expected id to start with %.")); } TEST_F(OpImageTest, TooManyOperands) { // We should improve this message, to say what instruction we're trying to // parse. EXPECT_THAT(CompileFailure("%2 = OpImage %1 %3 %4"), // an Id Eq("Expected '=', found end of stream.")); EXPECT_THAT(CompileFailure("%2 = OpImage %1 %3 99"), // a number Eq("Expected or at the beginning of an " "instruction, found '99'.")); EXPECT_THAT(CompileFailure("%2 = OpImage %1 %3 \"abc\""), // a string Eq("Expected or at the beginning of an " "instruction, found '\"abc\"'.")); } // Test OpImageSparseRead using OpImageSparseReadTest = TextToBinaryTest; TEST_F(OpImageSparseReadTest, OnlyRequiredOperands) { const std::string input = "%2 = OpImageSparseRead %1 %3 %4\n"; EXPECT_THAT(CompiledInstructions(input), Eq(MakeInstruction(spv::Op::OpImageSparseRead, {1, 2, 3, 4}))); // Test the disassembler. EXPECT_THAT(EncodeAndDecodeSuccessfully(input), input); } // Test all kinds of image operands on OpImageSparseRead using ImageSparseReadImageOperandsTest = spvtest::TextToBinaryTestBase<::testing::TestWithParam>; TEST_P(ImageSparseReadImageOperandsTest, Sample) { const std::string input = "%2 = OpImageSparseRead %1 %3 %4" + GetParam().image_operands + "\n"; EXPECT_THAT(CompiledInstructions(input), Eq(MakeInstruction(spv::Op::OpImageSparseRead, {1, 2, 3, 4}, GetParam().expected_mask_and_operands))); // Test the disassembler. EXPECT_THAT(EncodeAndDecodeSuccessfully(input), input); } #define MASK(NAME) uint32_t(spv::ImageOperandsMask::NAME) INSTANTIATE_TEST_SUITE_P(ImageSparseReadImageOperandsAny, ImageSparseReadImageOperandsTest, ::testing::ValuesIn(std::vector{ // Image operands are optional. {"", {}}, // Test each kind, alone. {" Bias %5", {MASK(Bias), 5}}, {" Lod %5", {MASK(Lod), 5}}, {" Grad %5 %6", {MASK(Grad), 5, 6}}, {" ConstOffset %5", {MASK(ConstOffset), 5}}, {" Offset %5", {MASK(Offset), 5}}, {" ConstOffsets %5", {MASK(ConstOffsets), 5}}, {" Sample %5", {MASK(Sample), 5}}, {" MinLod %5", {MASK(MinLod), 5}}, })); #undef MASK #define MASK(NAME) static_cast(spv::ImageOperandsMask::NAME) INSTANTIATE_TEST_SUITE_P( ImageSparseReadImageOperandsCombination, ImageSparseReadImageOperandsTest, ::testing::ValuesIn(std::vector{ // values. // Test adjacent pairs, so we can easily debug the values when it fails. {" Bias|Lod %5 %6", {MASK(Bias) | MASK(Lod), 5, 6}}, {" Lod|Grad %5 %6 %7", {MASK(Lod) | MASK(Grad), 5, 6, 7}}, {" Grad|ConstOffset %5 %6 %7", {MASK(Grad) | MASK(ConstOffset), 5, 6, 7}}, {" ConstOffset|Offset %5 %6", {MASK(ConstOffset) | MASK(Offset), 5, 6}}, {" Offset|ConstOffsets %5 %6", {MASK(Offset) | MASK(ConstOffsets), 5, 6}}, {" ConstOffsets|Sample %5 %6", {MASK(ConstOffsets) | MASK(Sample), 5, 6}}, // Test all masks together. {" Bias|Lod|Grad|ConstOffset|Offset|ConstOffsets|Sample" " %5 %6 %7 %8 %9 %10 %11 %12", {MASK(Bias) | MASK(Lod) | MASK(Grad) | MASK(ConstOffset) | MASK(Offset) | MASK(ConstOffsets) | MASK(Sample), 5, 6, 7, 8, 9, 10, 11, 12}}, // Don't try the masks reversed, since this is a round trip test, // and the disassembler will sort them. })); #undef MASK TEST_F(OpImageSparseReadTest, InvalidTypeOperand) { EXPECT_THAT(CompileFailure("%2 = OpImageSparseRead 42"), Eq("Expected id to start with %.")); } TEST_F(OpImageSparseReadTest, MissingImageOperand) { EXPECT_THAT(CompileFailure("%2 = OpImageSparseRead %1"), Eq("Expected operand for OpImageSparseRead instruction, but " "found the end of the stream.")); } TEST_F(OpImageSparseReadTest, InvalidImageOperand) { EXPECT_THAT(CompileFailure("%2 = OpImageSparseRead %1 1000"), Eq("Expected id to start with %.")); } TEST_F(OpImageSparseReadTest, MissingCoordinateOperand) { EXPECT_THAT(CompileFailure("%2 = OpImageSparseRead %1 %2"), Eq("Expected operand for OpImageSparseRead instruction, but " "found the end of the stream.")); } TEST_F(OpImageSparseReadTest, InvalidCoordinateOperand) { EXPECT_THAT(CompileFailure("%2 = OpImageSparseRead %1 %2 1000"), Eq("Expected id to start with %.")); } // TODO(dneto): OpSampledImage // TODO(dneto): OpImageSampleImplicitLod // TODO(dneto): OpImageSampleExplicitLod // TODO(dneto): OpImageSampleDrefImplicitLod // TODO(dneto): OpImageSampleDrefExplicitLod // TODO(dneto): OpImageSampleProjImplicitLod // TODO(dneto): OpImageSampleProjExplicitLod // TODO(dneto): OpImageSampleProjDrefImplicitLod // TODO(dneto): OpImageSampleProjDrefExplicitLod // TODO(dneto): OpImageGather // TODO(dneto): OpImageDrefGather // TODO(dneto): OpImageRead // TODO(dneto): OpImageWrite // TODO(dneto): OpImageQueryFormat // TODO(dneto): OpImageQueryOrder // TODO(dneto): OpImageQuerySizeLod // TODO(dneto): OpImageQuerySize // TODO(dneto): OpImageQueryLod // TODO(dneto): OpImageQueryLevels // TODO(dneto): OpImageQuerySamples // TODO(dneto): OpImageSparseSampleImplicitLod // TODO(dneto): OpImageSparseSampleExplicitLod // TODO(dneto): OpImageSparseSampleDrefImplicitLod // TODO(dneto): OpImageSparseSampleDrefExplicitLod // TODO(dneto): OpImageSparseSampleProjImplicitLod // TODO(dneto): OpImageSparseSampleProjExplicitLod // TODO(dneto): OpImageSparseSampleProjDrefImplicitLod // TODO(dneto): OpImageSparseSampleProjDrefExplicitLod // TODO(dneto): OpImageSparseFetch // TODO(dneto): OpImageSparseDrefGather // TODO(dneto): OpImageSparseTexelsResident } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/text_to_binary.literal_test.cpp000066400000000000000000000113251475742701700257420ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Assembler tests for literal numbers and literal strings. #include #include "test/test_fixture.h" namespace spvtools { namespace { using spvtest::TextToBinaryTest; TEST_F(TextToBinaryTest, LiteralStringInPlaceOfLiteralNumber) { EXPECT_EQ( R"(Invalid unsigned integer literal: "I shouldn't be a string")", CompileFailure(R"(OpSource GLSL "I shouldn't be a string")")); } TEST_F(TextToBinaryTest, GarbageInPlaceOfLiteralString) { EXPECT_EQ("Invalid literal string 'nice-source-code'.", CompileFailure("OpSourceExtension nice-source-code")); } TEST_F(TextToBinaryTest, LiteralNumberInPlaceOfLiteralString) { EXPECT_EQ("Expected literal string, found literal number '1000'.", CompileFailure("OpSourceExtension 1000")); } TEST_F(TextToBinaryTest, LiteralFloatInPlaceOfLiteralInteger) { EXPECT_EQ("Invalid unsigned integer literal: 10.5", CompileFailure("OpSource GLSL 10.5")); EXPECT_EQ("Invalid unsigned integer literal: 0.2", CompileFailure(R"(OpMemberName %type 0.2 "member0.2")")); EXPECT_EQ("Invalid unsigned integer literal: 32.42", CompileFailure("%int = OpTypeInt 32.42 0")); EXPECT_EQ("Invalid unsigned integer literal: 4.5", CompileFailure("%mat = OpTypeMatrix %vec 4.5")); EXPECT_EQ("Invalid unsigned integer literal: 1.5", CompileFailure("OpExecutionMode %main LocalSize 1.5 1.6 1.7")); EXPECT_EQ("Invalid unsigned integer literal: 0.123", CompileFailure("%i32 = OpTypeInt 32 1\n" "%c = OpConstant %i32 0.123")); } TEST_F(TextToBinaryTest, LiteralInt64) { const std::string code = "%1 = OpTypeInt 64 0\n%2 = OpConstant %1 123456789021\n"; EXPECT_EQ(code, EncodeAndDecodeSuccessfully(code)); } TEST_F(TextToBinaryTest, LiteralDouble) { const std::string code = "%1 = OpTypeFloat 64\n%2 = OpSpecConstant %1 3.14159265358979\n"; EXPECT_EQ(code, EncodeAndDecodeSuccessfully(code)); } TEST_F(TextToBinaryTest, LiteralStringASCIILong) { // SPIR-V allows strings up to 65535 characters. // Test the simple case of UTF-8 code points corresponding // to ASCII characters. EXPECT_EQ(65535, SPV_LIMIT_LITERAL_STRING_UTF8_CHARS_MAX); const std::string code = "OpSourceExtension \"" + std::string(SPV_LIMIT_LITERAL_STRING_UTF8_CHARS_MAX, 'o') + "\"\n"; EXPECT_EQ(code, EncodeAndDecodeSuccessfully(code)); } TEST_F(TextToBinaryTest, LiteralStringUTF8LongEncodings) { // SPIR-V allows strings up to 65535 characters. // Test the case of many Unicode characters, each of which has // a 4-byte UTF-8 encoding. // An instruction is at most 65535 words long. The first one // contains the wordcount and opcode. So the worst case number of // 4-byte UTF-8 characters is 65533, since we also need to // store a terminating null character. // This string fits exactly into 65534 words. const std::string good_string = spvtest::MakeLongUTF8String(65533) // The following single character has a 3 byte encoding, // which fits snugly against the terminating null. + "\xe8\x80\x80"; // These strings will overflow any instruction with 0 or 1 other // arguments, respectively. const std::string bad_0_arg_string = spvtest::MakeLongUTF8String(65534); const std::string bad_1_arg_string = spvtest::MakeLongUTF8String(65533); const std::string good_code = "OpSourceExtension \"" + good_string + "\"\n"; EXPECT_EQ(good_code, EncodeAndDecodeSuccessfully(good_code)); // Prove that it works on more than one instruction. const std::string good_code_2 = "OpSourceContinued \"" + good_string + "\"\n"; EXPECT_EQ(good_code, EncodeAndDecodeSuccessfully(good_code)); // Failure cases. EXPECT_EQ("Instruction too long: more than 65535 words.", CompileFailure("OpSourceExtension \"" + bad_0_arg_string + "\"\n")); EXPECT_EQ("Instruction too long: more than 65535 words.", CompileFailure("OpSourceContinued \"" + bad_0_arg_string + "\"\n")); EXPECT_EQ("Instruction too long: more than 65535 words.", CompileFailure("OpName %target \"" + bad_1_arg_string + "\"\n")); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/text_to_binary.memory_test.cpp000066400000000000000000000400301475742701700256110ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Assembler tests for instructions in the "Memory Instructions" section of // the SPIR-V spec. #include #include #include #include "gmock/gmock.h" #include "test/test_fixture.h" #include "test/unit_spirv.h" namespace spvtools { namespace { using spvtest::EnumCase; using spvtest::MakeInstruction; using spvtest::TextToBinaryTest; using ::testing::Eq; using ::testing::HasSubstr; // Test assembly of Memory Access masks using MemoryAccessTest = spvtest::TextToBinaryTestBase< ::testing::TestWithParam>>; TEST_P(MemoryAccessTest, AnySingleMemoryAccessMask) { std::stringstream input; input << "OpStore %ptr %value " << GetParam().name(); for (auto operand : GetParam().operands()) input << " " << operand; EXPECT_THAT( CompiledInstructions(input.str()), Eq(MakeInstruction(spv::Op::OpStore, {1, 2, (uint32_t)GetParam().value()}, GetParam().operands()))); } INSTANTIATE_TEST_SUITE_P( TextToBinaryMemoryAccessTest, MemoryAccessTest, ::testing::ValuesIn(std::vector>{ {spv::MemoryAccessMask::MaskNone, "None", {}}, {spv::MemoryAccessMask::Volatile, "Volatile", {}}, {spv::MemoryAccessMask::Aligned, "Aligned", {16}}, {spv::MemoryAccessMask::Nontemporal, "Nontemporal", {}}, })); TEST_F(TextToBinaryTest, CombinedMemoryAccessMask) { const std::string input = "OpStore %ptr %value Volatile|Aligned 16"; const uint32_t expected_mask = uint32_t(spv::MemoryAccessMask::Volatile | spv::MemoryAccessMask::Aligned); EXPECT_THAT(expected_mask, Eq(3u)); EXPECT_THAT(CompiledInstructions(input), Eq(MakeInstruction(spv::Op::OpStore, {1, 2, expected_mask, 16}))); } // Test Storage Class enum values using StorageClassTest = spvtest::TextToBinaryTestBase< ::testing::TestWithParam>>; TEST_P(StorageClassTest, AnyStorageClass) { const std::string input = "%1 = OpVariable %2 " + GetParam().name(); EXPECT_THAT(CompiledInstructions(input), Eq(MakeInstruction(spv::Op::OpVariable, {1, 2, (uint32_t)GetParam().value()}))); } // clang-format off #define CASE(NAME) { spv::StorageClass::NAME, #NAME, {} } INSTANTIATE_TEST_SUITE_P( TextToBinaryStorageClassTest, StorageClassTest, ::testing::ValuesIn(std::vector>{ CASE(UniformConstant), CASE(Input), CASE(Uniform), CASE(Output), CASE(Workgroup), CASE(CrossWorkgroup), CASE(Private), CASE(Function), CASE(Generic), CASE(PushConstant), CASE(AtomicCounter), CASE(Image), })); #undef CASE // clang-format on using MemoryRoundTripTest = RoundTripTest; // OpPtrEqual appeared in SPIR-V 1.4 TEST_F(MemoryRoundTripTest, OpPtrEqualGood) { std::string spirv = "%2 = OpPtrEqual %1 %3 %4\n"; EXPECT_THAT(CompiledInstructions(spirv, SPV_ENV_UNIVERSAL_1_4), Eq(MakeInstruction(spv::Op::OpPtrEqual, {1, 2, 3, 4}))); std::string disassembly = EncodeAndDecodeSuccessfully( spirv, SPV_BINARY_TO_TEXT_OPTION_NONE, SPV_TEXT_TO_BINARY_OPTION_NONE, SPV_ENV_UNIVERSAL_1_4); EXPECT_THAT(disassembly, Eq(spirv)); } TEST_F(MemoryRoundTripTest, OpPtrEqualV13Bad) { std::string spirv = "%2 = OpPtrEqual %1 %3 %4\n"; std::string err = CompileFailure(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_THAT(err, HasSubstr("Invalid Opcode name 'OpPtrEqual'")); } // OpPtrNotEqual appeared in SPIR-V 1.4 TEST_F(MemoryRoundTripTest, OpPtrNotEqualGood) { std::string spirv = "%2 = OpPtrNotEqual %1 %3 %4\n"; EXPECT_THAT(CompiledInstructions(spirv, SPV_ENV_UNIVERSAL_1_4), Eq(MakeInstruction(spv::Op::OpPtrNotEqual, {1, 2, 3, 4}))); std::string disassembly = EncodeAndDecodeSuccessfully( spirv, SPV_BINARY_TO_TEXT_OPTION_NONE, SPV_TEXT_TO_BINARY_OPTION_NONE, SPV_ENV_UNIVERSAL_1_4); EXPECT_THAT(disassembly, Eq(spirv)); } TEST_F(MemoryRoundTripTest, OpPtrNotEqualV13Bad) { std::string spirv = "%2 = OpPtrNotEqual %1 %3 %4\n"; std::string err = CompileFailure(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_THAT(err, HasSubstr("Invalid Opcode name 'OpPtrNotEqual'")); } // OpPtrDiff appeared in SPIR-V 1.4 TEST_F(MemoryRoundTripTest, OpPtrDiffGood) { std::string spirv = "%2 = OpPtrDiff %1 %3 %4\n"; EXPECT_THAT(CompiledInstructions(spirv, SPV_ENV_UNIVERSAL_1_4), Eq(MakeInstruction(spv::Op::OpPtrDiff, {1, 2, 3, 4}))); std::string disassembly = EncodeAndDecodeSuccessfully( spirv, SPV_BINARY_TO_TEXT_OPTION_NONE, SPV_TEXT_TO_BINARY_OPTION_NONE, SPV_ENV_UNIVERSAL_1_4); EXPECT_THAT(disassembly, Eq(spirv)); } TEST_F(MemoryRoundTripTest, OpPtrDiffV13Good) { // OpPtrDiff is enabled by a capability as well, so we can assemble // it even in older SPIR-V environments. We do that so we can // write tests. std::string spirv = "%2 = OpPtrDiff %1 %3 %4\n"; std::string disassembly = EncodeAndDecodeSuccessfully( spirv, SPV_BINARY_TO_TEXT_OPTION_NONE, SPV_TEXT_TO_BINARY_OPTION_NONE, SPV_ENV_UNIVERSAL_1_4); } // OpCopyMemory TEST_F(MemoryRoundTripTest, OpCopyMemoryNoMemAccessGood) { std::string spirv = "OpCopyMemory %1 %2\n"; EXPECT_THAT(CompiledInstructions(spirv), Eq(MakeInstruction(spv::Op::OpCopyMemory, {1, 2}))); std::string disassembly = EncodeAndDecodeSuccessfully(spirv); EXPECT_THAT(disassembly, Eq(spirv)); } TEST_F(MemoryRoundTripTest, OpCopyMemoryTooFewArgsBad) { std::string spirv = "OpCopyMemory %1\n"; std::string err = CompileFailure(spirv); EXPECT_THAT(err, HasSubstr("Expected operand for OpCopyMemory instruction, " "but found the end of the stream.")); } TEST_F(MemoryRoundTripTest, OpCopyMemoryTooManyArgsBad) { std::string spirv = "OpCopyMemory %1 %2 %3\n"; std::string err = CompileFailure(spirv); EXPECT_THAT(err, HasSubstr("Invalid memory access operand '%3'")); } TEST_F(MemoryRoundTripTest, OpCopyMemoryAccessNoneGood) { std::string spirv = "OpCopyMemory %1 %2 None\n"; EXPECT_THAT(CompiledInstructions(spirv), Eq(MakeInstruction(spv::Op::OpCopyMemory, {1, 2, 0}))); std::string disassembly = EncodeAndDecodeSuccessfully(spirv); EXPECT_THAT(disassembly, Eq(spirv)); } TEST_F(MemoryRoundTripTest, OpCopyMemoryAccessVolatileGood) { std::string spirv = "OpCopyMemory %1 %2 Volatile\n"; EXPECT_THAT(CompiledInstructions(spirv), Eq(MakeInstruction(spv::Op::OpCopyMemory, {1, 2, 1}))); std::string disassembly = EncodeAndDecodeSuccessfully(spirv); EXPECT_THAT(disassembly, Eq(spirv)); } TEST_F(MemoryRoundTripTest, OpCopyMemoryAccessAligned8Good) { std::string spirv = "OpCopyMemory %1 %2 Aligned 8\n"; EXPECT_THAT(CompiledInstructions(spirv), Eq(MakeInstruction(spv::Op::OpCopyMemory, {1, 2, 2, 8}))); std::string disassembly = EncodeAndDecodeSuccessfully(spirv); EXPECT_THAT(disassembly, Eq(spirv)); } TEST_F(MemoryRoundTripTest, OpCopyMemoryAccessNontemporalGood) { std::string spirv = "OpCopyMemory %1 %2 Nontemporal\n"; EXPECT_THAT(CompiledInstructions(spirv), Eq(MakeInstruction(spv::Op::OpCopyMemory, {1, 2, 4}))); std::string disassembly = EncodeAndDecodeSuccessfully(spirv); EXPECT_THAT(disassembly, Eq(spirv)); } TEST_F(MemoryRoundTripTest, OpCopyMemoryAccessAvGood) { std::string spirv = "OpCopyMemory %1 %2 MakePointerAvailable %3\n"; EXPECT_THAT(CompiledInstructions(spirv), Eq(MakeInstruction(spv::Op::OpCopyMemory, {1, 2, 8, 3}))); std::string disassembly = EncodeAndDecodeSuccessfully(spirv); EXPECT_THAT(disassembly, Eq(spirv)); } TEST_F(MemoryRoundTripTest, OpCopyMemoryAccessVisGood) { std::string spirv = "OpCopyMemory %1 %2 MakePointerVisible %3\n"; EXPECT_THAT(CompiledInstructions(spirv), Eq(MakeInstruction(spv::Op::OpCopyMemory, {1, 2, 16, 3}))); std::string disassembly = EncodeAndDecodeSuccessfully(spirv); EXPECT_THAT(disassembly, Eq(spirv)); } TEST_F(MemoryRoundTripTest, OpCopyMemoryAccessNonPrivateGood) { std::string spirv = "OpCopyMemory %1 %2 NonPrivatePointer\n"; EXPECT_THAT(CompiledInstructions(spirv), Eq(MakeInstruction(spv::Op::OpCopyMemory, {1, 2, 32}))); std::string disassembly = EncodeAndDecodeSuccessfully(spirv); EXPECT_THAT(disassembly, Eq(spirv)); } TEST_F(MemoryRoundTripTest, OpCopyMemoryAccessMixedGood) { std::string spirv = "OpCopyMemory %1 %2 " "Volatile|Aligned|Nontemporal|MakePointerAvailable|" "MakePointerVisible|NonPrivatePointer 16 %3 %4\n"; EXPECT_THAT(CompiledInstructions(spirv), Eq(MakeInstruction(spv::Op::OpCopyMemory, {1, 2, 63, 16, 3, 4}))); std::string disassembly = EncodeAndDecodeSuccessfully(spirv); EXPECT_THAT(disassembly, Eq(spirv)); } TEST_F(MemoryRoundTripTest, OpCopyMemoryTwoAccessV13Good) { std::string spirv = "OpCopyMemory %1 %2 Volatile Volatile\n"; // Note: This will assemble but should not validate for SPIR-V 1.3 EXPECT_THAT(CompiledInstructions(spirv, SPV_ENV_UNIVERSAL_1_3), Eq(MakeInstruction(spv::Op::OpCopyMemory, {1, 2, 1, 1}))); std::string disassembly = EncodeAndDecodeSuccessfully(spirv); EXPECT_THAT(disassembly, Eq(spirv)); } TEST_F(MemoryRoundTripTest, OpCopyMemoryTwoAccessV14Good) { std::string spirv = "OpCopyMemory %1 %2 Volatile Volatile\n"; EXPECT_THAT(CompiledInstructions(spirv, SPV_ENV_UNIVERSAL_1_4), Eq(MakeInstruction(spv::Op::OpCopyMemory, {1, 2, 1, 1}))); std::string disassembly = EncodeAndDecodeSuccessfully(spirv); EXPECT_THAT(disassembly, Eq(spirv)); } TEST_F(MemoryRoundTripTest, OpCopyMemoryTwoAccessMixedV14Good) { std::string spirv = "OpCopyMemory %1 %2 Volatile|Nontemporal|" "MakePointerVisible %3 " "Aligned|MakePointerAvailable|NonPrivatePointer 16 %4\n"; EXPECT_THAT( CompiledInstructions(spirv), Eq(MakeInstruction(spv::Op::OpCopyMemory, {1, 2, 21, 3, 42, 16, 4}))); std::string disassembly = EncodeAndDecodeSuccessfully(spirv); EXPECT_THAT(disassembly, Eq(spirv)); } // OpCopyMemorySized TEST_F(MemoryRoundTripTest, OpCopyMemorySizedNoMemAccessGood) { std::string spirv = "OpCopyMemorySized %1 %2 %3\n"; EXPECT_THAT(CompiledInstructions(spirv), Eq(MakeInstruction(spv::Op::OpCopyMemorySized, {1, 2, 3}))); std::string disassembly = EncodeAndDecodeSuccessfully(spirv); EXPECT_THAT(disassembly, Eq(spirv)); } TEST_F(MemoryRoundTripTest, OpCopyMemorySizedTooFewArgsBad) { std::string spirv = "OpCopyMemorySized %1 %2\n"; std::string err = CompileFailure(spirv); EXPECT_THAT(err, HasSubstr("Expected operand for OpCopyMemorySized " "instruction, but found the end of the stream.")); } TEST_F(MemoryRoundTripTest, OpCopyMemorySizedTooManyArgsBad) { std::string spirv = "OpCopyMemorySized %1 %2 %3 %4\n"; std::string err = CompileFailure(spirv); EXPECT_THAT(err, HasSubstr("Invalid memory access operand '%4'")); } TEST_F(MemoryRoundTripTest, OpCopyMemorySizedAccessNoneGood) { std::string spirv = "OpCopyMemorySized %1 %2 %3 None\n"; EXPECT_THAT(CompiledInstructions(spirv), Eq(MakeInstruction(spv::Op::OpCopyMemorySized, {1, 2, 3, 0}))); std::string disassembly = EncodeAndDecodeSuccessfully(spirv); EXPECT_THAT(disassembly, Eq(spirv)); } TEST_F(MemoryRoundTripTest, OpCopyMemorySizedAccessVolatileGood) { std::string spirv = "OpCopyMemorySized %1 %2 %3 Volatile\n"; EXPECT_THAT(CompiledInstructions(spirv), Eq(MakeInstruction(spv::Op::OpCopyMemorySized, {1, 2, 3, 1}))); std::string disassembly = EncodeAndDecodeSuccessfully(spirv); EXPECT_THAT(disassembly, Eq(spirv)); } TEST_F(MemoryRoundTripTest, OpCopyMemorySizedAccessAligned8Good) { std::string spirv = "OpCopyMemorySized %1 %2 %3 Aligned 8\n"; EXPECT_THAT(CompiledInstructions(spirv), Eq(MakeInstruction(spv::Op::OpCopyMemorySized, {1, 2, 3, 2, 8}))); std::string disassembly = EncodeAndDecodeSuccessfully(spirv); EXPECT_THAT(disassembly, Eq(spirv)); } TEST_F(MemoryRoundTripTest, OpCopyMemorySizedAccessNontemporalGood) { std::string spirv = "OpCopyMemorySized %1 %2 %3 Nontemporal\n"; EXPECT_THAT(CompiledInstructions(spirv), Eq(MakeInstruction(spv::Op::OpCopyMemorySized, {1, 2, 3, 4}))); std::string disassembly = EncodeAndDecodeSuccessfully(spirv); EXPECT_THAT(disassembly, Eq(spirv)); } TEST_F(MemoryRoundTripTest, OpCopyMemorySizedAccessAvGood) { std::string spirv = "OpCopyMemorySized %1 %2 %3 MakePointerAvailable %4\n"; EXPECT_THAT(CompiledInstructions(spirv), Eq(MakeInstruction(spv::Op::OpCopyMemorySized, {1, 2, 3, 8, 4}))); std::string disassembly = EncodeAndDecodeSuccessfully(spirv); EXPECT_THAT(disassembly, Eq(spirv)); } TEST_F(MemoryRoundTripTest, OpCopyMemorySizedAccessVisGood) { std::string spirv = "OpCopyMemorySized %1 %2 %3 MakePointerVisible %4\n"; EXPECT_THAT( CompiledInstructions(spirv), Eq(MakeInstruction(spv::Op::OpCopyMemorySized, {1, 2, 3, 16, 4}))); std::string disassembly = EncodeAndDecodeSuccessfully(spirv); EXPECT_THAT(disassembly, Eq(spirv)); } TEST_F(MemoryRoundTripTest, OpCopyMemorySizedAccessNonPrivateGood) { std::string spirv = "OpCopyMemorySized %1 %2 %3 NonPrivatePointer\n"; EXPECT_THAT(CompiledInstructions(spirv), Eq(MakeInstruction(spv::Op::OpCopyMemorySized, {1, 2, 3, 32}))); std::string disassembly = EncodeAndDecodeSuccessfully(spirv); EXPECT_THAT(disassembly, Eq(spirv)); } TEST_F(MemoryRoundTripTest, OpCopyMemorySizedAccessMixedGood) { std::string spirv = "OpCopyMemorySized %1 %2 %3 " "Volatile|Aligned|Nontemporal|MakePointerAvailable|" "MakePointerVisible|NonPrivatePointer 16 %4 %5\n"; EXPECT_THAT( CompiledInstructions(spirv), Eq(MakeInstruction(spv::Op::OpCopyMemorySized, {1, 2, 3, 63, 16, 4, 5}))); std::string disassembly = EncodeAndDecodeSuccessfully(spirv); EXPECT_THAT(disassembly, Eq(spirv)); } TEST_F(MemoryRoundTripTest, OpCopyMemorySizedTwoAccessV13Good) { std::string spirv = "OpCopyMemorySized %1 %2 %3 Volatile Volatile\n"; // Note: This will assemble but should not validate for SPIR-V 1.3 EXPECT_THAT(CompiledInstructions(spirv, SPV_ENV_UNIVERSAL_1_3), Eq(MakeInstruction(spv::Op::OpCopyMemorySized, {1, 2, 3, 1, 1}))); std::string disassembly = EncodeAndDecodeSuccessfully(spirv); EXPECT_THAT(disassembly, Eq(spirv)); } TEST_F(MemoryRoundTripTest, OpCopyMemorySizedTwoAccessV14Good) { std::string spirv = "OpCopyMemorySized %1 %2 %3 Volatile Volatile\n"; EXPECT_THAT(CompiledInstructions(spirv, SPV_ENV_UNIVERSAL_1_4), Eq(MakeInstruction(spv::Op::OpCopyMemorySized, {1, 2, 3, 1, 1}))); std::string disassembly = EncodeAndDecodeSuccessfully(spirv); EXPECT_THAT(disassembly, Eq(spirv)); } TEST_F(MemoryRoundTripTest, OpCopyMemorySizedTwoAccessMixedV14Good) { std::string spirv = "OpCopyMemorySized %1 %2 %3 Volatile|Nontemporal|" "MakePointerVisible %4 " "Aligned|MakePointerAvailable|NonPrivatePointer 16 %5\n"; EXPECT_THAT(CompiledInstructions(spirv), Eq(MakeInstruction(spv::Op::OpCopyMemorySized, {1, 2, 3, 21, 4, 42, 16, 5}))); std::string disassembly = EncodeAndDecodeSuccessfully(spirv); EXPECT_THAT(disassembly, Eq(spirv)); } // TODO(dneto): OpVariable with initializers // TODO(dneto): OpImageTexelPointer // TODO(dneto): OpLoad // TODO(dneto): OpStore // TODO(dneto): OpAccessChain // TODO(dneto): OpInBoundsAccessChain // TODO(dneto): OpPtrAccessChain // TODO(dneto): OpArrayLength // TODO(dneto): OpGenercPtrMemSemantics } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/text_to_binary.misc_test.cpp000066400000000000000000000035151475742701700252430ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Assembler tests for instructions in the "Miscellaneous" section of the // SPIR-V spec. #include "test/unit_spirv.h" #include "gmock/gmock.h" #include "test/test_fixture.h" namespace spvtools { namespace { using SpirvVector = spvtest::TextToBinaryTest::SpirvVector; using spvtest::MakeInstruction; using ::testing::Eq; using TextToBinaryMisc = spvtest::TextToBinaryTest; TEST_F(TextToBinaryMisc, OpNop) { EXPECT_THAT(CompiledInstructions("OpNop"), Eq(MakeInstruction(spv::Op::OpNop, {}))); } TEST_F(TextToBinaryMisc, OpUndef) { const SpirvVector code = CompiledInstructions(R"(%f32 = OpTypeFloat 32 %u = OpUndef %f32)"); const uint32_t typeID = 1; EXPECT_THAT(code[1], Eq(typeID)); EXPECT_THAT(Subvector(code, 3), Eq(MakeInstruction(spv::Op::OpUndef, {typeID, 2}))); } TEST_F(TextToBinaryMisc, OpWrong) { EXPECT_THAT(CompileFailure(" OpWrong %1 %2"), Eq("Invalid Opcode name 'OpWrong'")); } TEST_F(TextToBinaryMisc, OpWrongAfterRight) { const auto assembly = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpXYZ )"; EXPECT_THAT(CompileFailure(assembly), Eq("Invalid Opcode name 'OpXYZ'")); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/text_to_binary.mode_setting_test.cpp000066400000000000000000000275771475742701700270070ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Assembler tests for instructions in the "Mode-Setting" section of the // SPIR-V spec. #include #include #include #include "gmock/gmock.h" #include "source/util/string_utils.h" #include "test/test_fixture.h" #include "test/unit_spirv.h" namespace spvtools { namespace { using spvtest::EnumCase; using spvtest::MakeInstruction; using utils::MakeVector; using ::testing::Combine; using ::testing::Eq; using ::testing::TestWithParam; using ::testing::Values; using ::testing::ValuesIn; // Test OpMemoryModel // An example case for OpMemoryModel struct MemoryModelCase { uint32_t get_addressing_value() const { return static_cast(addressing_value); } uint32_t get_memory_value() const { return static_cast(memory_value); } spv::AddressingModel addressing_value; std::string addressing_name; spv::MemoryModel memory_value; std::string memory_name; }; using OpMemoryModelTest = spvtest::TextToBinaryTestBase>; TEST_P(OpMemoryModelTest, AnyMemoryModelCase) { const std::string input = "OpMemoryModel " + GetParam().addressing_name + " " + GetParam().memory_name; EXPECT_THAT(CompiledInstructions(input), Eq(MakeInstruction(spv::Op::OpMemoryModel, {GetParam().get_addressing_value(), GetParam().get_memory_value()}))); } #define CASE(ADDRESSING, MEMORY) \ { \ spv::AddressingModel::ADDRESSING, #ADDRESSING, spv::MemoryModel::MEMORY, \ #MEMORY \ } // clang-format off INSTANTIATE_TEST_SUITE_P(TextToBinaryMemoryModel, OpMemoryModelTest, ValuesIn(std::vector{ // These cases exercise each addressing model, and // each memory model, but not necessarily in // combination. CASE(Logical,Simple), CASE(Logical,GLSL450), CASE(Physical32,OpenCL), CASE(Physical64,OpenCL), })); #undef CASE // clang-format on TEST_F(OpMemoryModelTest, WrongModel) { EXPECT_THAT(CompileFailure("OpMemoryModel xxyyzz Simple"), Eq("Invalid addressing model 'xxyyzz'.")); EXPECT_THAT(CompileFailure("OpMemoryModel Logical xxyyzz"), Eq("Invalid memory model 'xxyyzz'.")); } // Test OpEntryPoint // An example case for OpEntryPoint struct EntryPointCase { uint32_t get_execution_value() const { return static_cast(execution_value); } spv::ExecutionModel execution_value; std::string execution_name; std::string entry_point_name; }; using OpEntryPointTest = spvtest::TextToBinaryTestBase>; TEST_P(OpEntryPointTest, AnyEntryPointCase) { // TODO(dneto): utf-8, escaping, quoting cases for entry point name. const std::string input = "OpEntryPoint " + GetParam().execution_name + " %1 \"" + GetParam().entry_point_name + "\""; EXPECT_THAT(CompiledInstructions(input), Eq(MakeInstruction(spv::Op::OpEntryPoint, {GetParam().get_execution_value(), 1}, MakeVector(GetParam().entry_point_name)))); } // clang-format off #define CASE(NAME) spv::ExecutionModel::NAME, #NAME INSTANTIATE_TEST_SUITE_P(TextToBinaryEntryPoint, OpEntryPointTest, ValuesIn(std::vector{ { CASE(Vertex), "" }, { CASE(TessellationControl), "my tess" }, { CASE(TessellationEvaluation), "really fancy" }, { CASE(Geometry), "Euclid" }, { CASE(Fragment), "FAT32" }, { CASE(GLCompute), "cubic" }, { CASE(Kernel), "Sanders" }, })); #undef CASE // clang-format on TEST_F(OpEntryPointTest, WrongModel) { EXPECT_THAT(CompileFailure("OpEntryPoint xxyyzz %1 \"fun\""), Eq("Invalid execution model 'xxyyzz'.")); } // Test OpExecutionMode using OpExecutionModeTest = spvtest::TextToBinaryTestBase< TestWithParam>>>; TEST_P(OpExecutionModeTest, AnyExecutionMode) { // This string should assemble, but should not validate. std::stringstream input; input << "OpExecutionMode %1 " << std::get<1>(GetParam()).name(); for (auto operand : std::get<1>(GetParam()).operands()) input << " " << operand; EXPECT_THAT(CompiledInstructions(input.str(), std::get<0>(GetParam())), Eq(MakeInstruction(spv::Op::OpExecutionMode, {1, std::get<1>(GetParam()).value()}, std::get<1>(GetParam()).operands()))); } #define CASE(NAME) spv::ExecutionMode::NAME, #NAME INSTANTIATE_TEST_SUITE_P( TextToBinaryExecutionMode, OpExecutionModeTest, Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), ValuesIn(std::vector>{ // The operand literal values are arbitrarily chosen, // but there are the right number of them. {CASE(Invocations), {101}}, {CASE(SpacingEqual), {}}, {CASE(SpacingFractionalEven), {}}, {CASE(SpacingFractionalOdd), {}}, {CASE(VertexOrderCw), {}}, {CASE(VertexOrderCcw), {}}, {CASE(PixelCenterInteger), {}}, {CASE(OriginUpperLeft), {}}, {CASE(OriginLowerLeft), {}}, {CASE(EarlyFragmentTests), {}}, {CASE(PointMode), {}}, {CASE(Xfb), {}}, {CASE(DepthReplacing), {}}, {CASE(DepthGreater), {}}, {CASE(DepthLess), {}}, {CASE(DepthUnchanged), {}}, {CASE(LocalSize), {64, 1, 2}}, {CASE(LocalSizeHint), {8, 2, 4}}, {CASE(InputPoints), {}}, {CASE(InputLines), {}}, {CASE(InputLinesAdjacency), {}}, {CASE(Triangles), {}}, {CASE(InputTrianglesAdjacency), {}}, {CASE(Quads), {}}, {CASE(Isolines), {}}, {CASE(OutputVertices), {21}}, {CASE(OutputPoints), {}}, {CASE(OutputLineStrip), {}}, {CASE(OutputTriangleStrip), {}}, {CASE(VecTypeHint), {96}}, {CASE(ContractionOff), {}}, {CASE(SubgroupUniformControlFlowKHR), {}}, }))); INSTANTIATE_TEST_SUITE_P( TextToBinaryExecutionModeV11, OpExecutionModeTest, Combine(Values(SPV_ENV_UNIVERSAL_1_1), ValuesIn(std::vector>{ {CASE(Initializer)}, {CASE(Finalizer)}, {CASE(SubgroupSize), {12}}, {CASE(SubgroupsPerWorkgroup), {64}}}))); #undef CASE TEST_F(OpExecutionModeTest, WrongMode) { EXPECT_THAT(CompileFailure("OpExecutionMode %1 xxyyzz"), Eq("Invalid execution mode 'xxyyzz'.")); } TEST_F(OpExecutionModeTest, TooManyModes) { EXPECT_THAT(CompileFailure("OpExecutionMode %1 Xfb PointMode"), Eq("Expected or at the beginning of an " "instruction, found 'PointMode'.")); } // Test OpCapability using OpCapabilityTest = spvtest::TextToBinaryTestBase>>; TEST_P(OpCapabilityTest, AnyCapability) { const std::string input = "OpCapability " + GetParam().name(); EXPECT_THAT(CompiledInstructions(input), Eq(MakeInstruction(spv::Op::OpCapability, {GetParam().value()}))); } // clang-format off #define CASE(NAME) { spv::Capability::NAME, #NAME } INSTANTIATE_TEST_SUITE_P(TextToBinaryCapability, OpCapabilityTest, ValuesIn(std::vector>{ CASE(Matrix), CASE(Shader), CASE(Geometry), CASE(Tessellation), CASE(Addresses), CASE(Linkage), CASE(Kernel), CASE(Vector16), CASE(Float16Buffer), CASE(Float16), CASE(Float64), CASE(Int64), CASE(Int64Atomics), CASE(ImageBasic), CASE(ImageReadWrite), CASE(ImageMipmap), // Value 16 intentionally missing CASE(Pipes), CASE(Groups), CASE(DeviceEnqueue), CASE(LiteralSampler), CASE(AtomicStorage), CASE(Int16), CASE(TessellationPointSize), CASE(GeometryPointSize), CASE(ImageGatherExtended), // Value 26 intentionally missing CASE(StorageImageMultisample), CASE(UniformBufferArrayDynamicIndexing), CASE(SampledImageArrayDynamicIndexing), CASE(StorageBufferArrayDynamicIndexing), CASE(StorageImageArrayDynamicIndexing), CASE(ClipDistance), CASE(CullDistance), CASE(ImageCubeArray), CASE(SampleRateShading), CASE(ImageRect), CASE(SampledRect), CASE(GenericPointer), CASE(Int8), CASE(InputAttachment), CASE(SparseResidency), CASE(MinLod), CASE(Sampled1D), CASE(Image1D), CASE(SampledCubeArray), CASE(SampledBuffer), CASE(ImageBuffer), CASE(ImageMSArray), CASE(StorageImageExtendedFormats), CASE(ImageQuery), CASE(DerivativeControl), CASE(InterpolationFunction), CASE(TransformFeedback), })); #undef CASE // clang-format on using TextToBinaryCapability = spvtest::TextToBinaryTest; TEST_F(TextToBinaryCapability, BadMissingCapability) { EXPECT_THAT(CompileFailure("OpCapability"), Eq("Expected operand for OpCapability instruction, but found the " "end of the stream.")); } TEST_F(TextToBinaryCapability, BadInvalidCapability) { EXPECT_THAT(CompileFailure("OpCapability 123"), Eq("Invalid capability '123'.")); } // TODO(dneto): OpExecutionMode } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/text_to_binary.pipe_storage_test.cpp000066400000000000000000000134201475742701700267650ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "gmock/gmock.h" #include "test/test_fixture.h" namespace spvtools { namespace { using ::spvtest::MakeInstruction; using ::testing::Eq; using OpTypePipeStorageTest = spvtest::TextToBinaryTest; // It can assemble, but should not validate. Validation checks for version // and capability are in another test file. TEST_F(OpTypePipeStorageTest, OpcodeAssemblesInV10) { EXPECT_THAT( CompiledInstructions("%res = OpTypePipeStorage", SPV_ENV_UNIVERSAL_1_0), Eq(MakeInstruction(spv::Op::OpTypePipeStorage, {1}))); } TEST_F(OpTypePipeStorageTest, ArgumentCount) { EXPECT_THAT( CompileFailure("OpTypePipeStorage", SPV_ENV_UNIVERSAL_1_1), Eq("Expected at the beginning of an instruction, found " "'OpTypePipeStorage'.")); EXPECT_THAT( CompiledInstructions("%res = OpTypePipeStorage", SPV_ENV_UNIVERSAL_1_1), Eq(MakeInstruction(spv::Op::OpTypePipeStorage, {1}))); EXPECT_THAT(CompileFailure("%res = OpTypePipeStorage %1 %2 %3 %4 %5", SPV_ENV_UNIVERSAL_1_1), Eq("'=' expected after result id but found '%2'.")); } using OpConstantPipeStorageTest = spvtest::TextToBinaryTest; TEST_F(OpConstantPipeStorageTest, OpcodeAssemblesInV10) { EXPECT_THAT( CompiledInstructions("%1 = OpConstantPipeStorage %2 3 4 5", SPV_ENV_UNIVERSAL_1_0), Eq(MakeInstruction(spv::Op::OpConstantPipeStorage, {1, 2, 3, 4, 5}))); } TEST_F(OpConstantPipeStorageTest, ArgumentCount) { EXPECT_THAT( CompileFailure("OpConstantPipeStorage", SPV_ENV_UNIVERSAL_1_1), Eq("Expected at the beginning of an instruction, found " "'OpConstantPipeStorage'.")); EXPECT_THAT( CompileFailure("%1 = OpConstantPipeStorage", SPV_ENV_UNIVERSAL_1_1), Eq("Expected operand for OpConstantPipeStorage instruction, but found " "the end of the stream.")); EXPECT_THAT(CompileFailure("%1 = OpConstantPipeStorage %2 3 4", SPV_ENV_UNIVERSAL_1_1), Eq("Expected operand for OpConstantPipeStorage instruction, but " "found the end of the stream.")); EXPECT_THAT( CompiledInstructions("%1 = OpConstantPipeStorage %2 3 4 5", SPV_ENV_UNIVERSAL_1_1), Eq(MakeInstruction(spv::Op::OpConstantPipeStorage, {1, 2, 3, 4, 5}))); EXPECT_THAT(CompileFailure("%1 = OpConstantPipeStorage %2 3 4 5 %6 %7", SPV_ENV_UNIVERSAL_1_1), Eq("'=' expected after result id but found '%7'.")); } TEST_F(OpConstantPipeStorageTest, ArgumentTypes) { EXPECT_THAT(CompileFailure("%1 = OpConstantPipeStorage %2 %3 4 5", SPV_ENV_UNIVERSAL_1_1), Eq("Invalid unsigned integer literal: %3")); EXPECT_THAT(CompileFailure("%1 = OpConstantPipeStorage %2 3 %4 5", SPV_ENV_UNIVERSAL_1_1), Eq("Invalid unsigned integer literal: %4")); EXPECT_THAT(CompileFailure("%1 = OpConstantPipeStorage 2 3 4 5", SPV_ENV_UNIVERSAL_1_1), Eq("Expected id to start with %.")); EXPECT_THAT(CompileFailure("%1 = OpConstantPipeStorage %2 3 4 \"ab\"", SPV_ENV_UNIVERSAL_1_1), Eq("Invalid unsigned integer literal: \"ab\"")); } using OpCreatePipeFromPipeStorageTest = spvtest::TextToBinaryTest; TEST_F(OpCreatePipeFromPipeStorageTest, OpcodeAssemblesInV10) { EXPECT_THAT( CompiledInstructions("%1 = OpCreatePipeFromPipeStorage %2 %3", SPV_ENV_UNIVERSAL_1_0), Eq(MakeInstruction(spv::Op::OpCreatePipeFromPipeStorage, {1, 2, 3}))); } TEST_F(OpCreatePipeFromPipeStorageTest, ArgumentCount) { EXPECT_THAT( CompileFailure("OpCreatePipeFromPipeStorage", SPV_ENV_UNIVERSAL_1_1), Eq("Expected at the beginning of an instruction, found " "'OpCreatePipeFromPipeStorage'.")); EXPECT_THAT( CompileFailure("%1 = OpCreatePipeFromPipeStorage", SPV_ENV_UNIVERSAL_1_1), Eq("Expected operand for OpCreatePipeFromPipeStorage instruction, but " "found the end of the stream.")); EXPECT_THAT(CompileFailure("%1 = OpCreatePipeFromPipeStorage %2 OpNop", SPV_ENV_UNIVERSAL_1_1), Eq("Expected operand for OpCreatePipeFromPipeStorage " "instruction, but found the next instruction instead.")); EXPECT_THAT( CompiledInstructions("%1 = OpCreatePipeFromPipeStorage %2 %3", SPV_ENV_UNIVERSAL_1_1), Eq(MakeInstruction(spv::Op::OpCreatePipeFromPipeStorage, {1, 2, 3}))); EXPECT_THAT(CompileFailure("%1 = OpCreatePipeFromPipeStorage %2 %3 %4 %5", SPV_ENV_UNIVERSAL_1_1), Eq("'=' expected after result id but found '%5'.")); } TEST_F(OpCreatePipeFromPipeStorageTest, ArgumentTypes) { EXPECT_THAT(CompileFailure("%1 = OpCreatePipeFromPipeStorage \"\" %3", SPV_ENV_UNIVERSAL_1_1), Eq("Expected id to start with %.")); EXPECT_THAT(CompileFailure("%1 = OpCreatePipeFromPipeStorage %2 3", SPV_ENV_UNIVERSAL_1_1), Eq("Expected id to start with %.")); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/text_to_binary.reserved_sampling_test.cpp000066400000000000000000000046231475742701700300220ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validation tests for illegal instructions #include #include "gmock/gmock.h" #include "test/test_fixture.h" #include "test/unit_spirv.h" namespace spvtools { namespace { using ::spvtest::MakeInstruction; using ::testing::Eq; using ReservedSamplingInstTest = RoundTripTest; TEST_F(ReservedSamplingInstTest, OpImageSparseSampleProjImplicitLod) { std::string input = "%2 = OpImageSparseSampleProjImplicitLod %1 %3 %4\n"; EXPECT_THAT(CompiledInstructions(input, SPV_ENV_UNIVERSAL_1_0), Eq(MakeInstruction(spv::Op::OpImageSparseSampleProjImplicitLod, {1, 2, 3, 4}))); } TEST_F(ReservedSamplingInstTest, OpImageSparseSampleProjExplicitLod) { std::string input = "%2 = OpImageSparseSampleProjExplicitLod %1 %3 %4 Lod %5\n"; EXPECT_THAT(CompiledInstructions(input, SPV_ENV_UNIVERSAL_1_0), Eq(MakeInstruction( spv::Op::OpImageSparseSampleProjExplicitLod, {1, 2, 3, 4, (uint32_t)spv::ImageOperandsMask::Lod, 5}))); } TEST_F(ReservedSamplingInstTest, OpImageSparseSampleProjDrefImplicitLod) { std::string input = "%2 = OpImageSparseSampleProjDrefImplicitLod %1 %3 %4 %5\n"; EXPECT_THAT( CompiledInstructions(input, SPV_ENV_UNIVERSAL_1_0), Eq(MakeInstruction(spv::Op::OpImageSparseSampleProjDrefImplicitLod, {1, 2, 3, 4, 5}))); } TEST_F(ReservedSamplingInstTest, OpImageSparseSampleProjDrefExplicitLod) { std::string input = "%2 = OpImageSparseSampleProjDrefExplicitLod %1 %3 %4 %5 Lod %6\n"; EXPECT_THAT(CompiledInstructions(input, SPV_ENV_UNIVERSAL_1_0), Eq(MakeInstruction( spv::Op::OpImageSparseSampleProjDrefExplicitLod, {1, 2, 3, 4, 5, (uint32_t)spv::ImageOperandsMask::Lod, 6}))); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/text_to_binary.subgroup_dispatch_test.cpp000066400000000000000000000131501475742701700300310ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Assembler tests for instructions in the "Barrier Instructions" section // of the SPIR-V spec. #include "test/unit_spirv.h" #include "gmock/gmock.h" #include "test/test_fixture.h" namespace spvtools { namespace { using ::spvtest::MakeInstruction; using ::testing::Eq; using OpGetKernelLocalSizeForSubgroupCountTest = spvtest::TextToBinaryTest; // We should be able to assemble it. Validation checks are in another test // file. TEST_F(OpGetKernelLocalSizeForSubgroupCountTest, OpcodeAssemblesInV10) { EXPECT_THAT( CompiledInstructions("%res = OpGetKernelLocalSizeForSubgroupCount %type " "%sgcount %invoke %param %param_size %param_align", SPV_ENV_UNIVERSAL_1_0), Eq(MakeInstruction(spv::Op::OpGetKernelLocalSizeForSubgroupCount, {1, 2, 3, 4, 5, 6, 7}))); } TEST_F(OpGetKernelLocalSizeForSubgroupCountTest, ArgumentCount) { EXPECT_THAT(CompileFailure("OpGetKernelLocalSizeForSubgroupCount", SPV_ENV_UNIVERSAL_1_1), Eq("Expected at the beginning of an instruction, " "found 'OpGetKernelLocalSizeForSubgroupCount'.")); EXPECT_THAT(CompileFailure("%res = OpGetKernelLocalSizeForSubgroupCount", SPV_ENV_UNIVERSAL_1_1), Eq("Expected operand for OpGetKernelLocalSizeForSubgroupCount " "instruction, but found the end of the stream.")); EXPECT_THAT( CompileFailure("%1 = OpGetKernelLocalSizeForSubgroupCount %2 %3 %4 %5 %6", SPV_ENV_UNIVERSAL_1_1), Eq("Expected operand for OpGetKernelLocalSizeForSubgroupCount " "instruction, but found the end of the stream.")); EXPECT_THAT( CompiledInstructions("%res = OpGetKernelLocalSizeForSubgroupCount %type " "%sgcount %invoke %param %param_size %param_align", SPV_ENV_UNIVERSAL_1_1), Eq(MakeInstruction(spv::Op::OpGetKernelLocalSizeForSubgroupCount, {1, 2, 3, 4, 5, 6, 7}))); EXPECT_THAT( CompileFailure("%res = OpGetKernelLocalSizeForSubgroupCount %type " "%sgcount %invoke %param %param_size %param_align %extra", SPV_ENV_UNIVERSAL_1_1), Eq("Expected '=', found end of stream.")); } TEST_F(OpGetKernelLocalSizeForSubgroupCountTest, ArgumentTypes) { EXPECT_THAT(CompileFailure( "%1 = OpGetKernelLocalSizeForSubgroupCount 2 %3 %4 %5 %6 %7", SPV_ENV_UNIVERSAL_1_1), Eq("Expected id to start with %.")); EXPECT_THAT( CompileFailure( "%1 = OpGetKernelLocalSizeForSubgroupCount %2 %3 %4 %5 %6 \"abc\"", SPV_ENV_UNIVERSAL_1_1), Eq("Expected id to start with %.")); } using OpGetKernelMaxNumSubgroupsTest = spvtest::TextToBinaryTest; TEST_F(OpGetKernelMaxNumSubgroupsTest, OpcodeAssemblesInV10) { EXPECT_THAT(CompiledInstructions("%res = OpGetKernelMaxNumSubgroups %type " "%invoke %param %param_size %param_align", SPV_ENV_UNIVERSAL_1_0), Eq(MakeInstruction(spv::Op::OpGetKernelMaxNumSubgroups, {1, 2, 3, 4, 5, 6}))); } TEST_F(OpGetKernelMaxNumSubgroupsTest, ArgumentCount) { EXPECT_THAT( CompileFailure("OpGetKernelMaxNumSubgroups", SPV_ENV_UNIVERSAL_1_1), Eq("Expected at the beginning of an instruction, found " "'OpGetKernelMaxNumSubgroups'.")); EXPECT_THAT(CompileFailure("%res = OpGetKernelMaxNumSubgroups", SPV_ENV_UNIVERSAL_1_1), Eq("Expected operand for OpGetKernelMaxNumSubgroups instruction, " "but found the end of the stream.")); EXPECT_THAT(CompileFailure("%1 = OpGetKernelMaxNumSubgroups %2 %3 %4 %5", SPV_ENV_UNIVERSAL_1_1), Eq("Expected operand for OpGetKernelMaxNumSubgroups instruction, " "but found the end of the stream.")); EXPECT_THAT(CompiledInstructions("%res = OpGetKernelMaxNumSubgroups %type " "%invoke %param %param_size %param_align", SPV_ENV_UNIVERSAL_1_1), Eq(MakeInstruction(spv::Op::OpGetKernelMaxNumSubgroups, {1, 2, 3, 4, 5, 6}))); EXPECT_THAT(CompileFailure("%res = OpGetKernelMaxNumSubgroups %type %invoke " "%param %param_size %param_align %extra", SPV_ENV_UNIVERSAL_1_1), Eq("Expected '=', found end of stream.")); } TEST_F(OpGetKernelMaxNumSubgroupsTest, ArgumentTypes) { EXPECT_THAT(CompileFailure("%1 = OpGetKernelMaxNumSubgroups 2 %3 %4 %5 %6", SPV_ENV_UNIVERSAL_1_1), Eq("Expected id to start with %.")); EXPECT_THAT( CompileFailure("%1 = OpGetKernelMaxNumSubgroups %2 %3 %4 %5 \"abc\"", SPV_ENV_UNIVERSAL_1_1), Eq("Expected id to start with %.")); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/text_to_binary.type_declaration_test.cpp000066400000000000000000000230241475742701700276330ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Assembler tests for instructions in the "Type-Declaration" section of the // SPIR-V spec. #include #include #include "gmock/gmock.h" #include "test/test_fixture.h" #include "test/unit_spirv.h" namespace spvtools { namespace { using spvtest::EnumCase; using spvtest::MakeInstruction; using ::testing::Eq; // Test Dim enums via OpTypeImage using DimTest = spvtest::TextToBinaryTestBase<::testing::TestWithParam>>; TEST_P(DimTest, AnyDim) { const std::string input = "%1 = OpTypeImage %2 " + GetParam().name() + " 2 3 0 4 Rgba8\n"; EXPECT_THAT(CompiledInstructions(input), Eq(MakeInstruction(spv::Op::OpTypeImage, {1, 2, (uint32_t)GetParam().value(), 2, 3, 0, 4, (uint32_t)spv::ImageFormat::Rgba8}))); // Check the disassembler as well. EXPECT_THAT(EncodeAndDecodeSuccessfully(input), Eq(input)); } // clang-format off #define CASE(NAME) {spv::Dim::NAME, #NAME} #define CASE1(DIM, NAME) {spv::Dim::DIM, #NAME} INSTANTIATE_TEST_SUITE_P( TextToBinaryDim, DimTest, ::testing::ValuesIn(std::vector>{ CASE1(Dim1D, 1D), CASE1(Dim2D, 2D), CASE1(Dim3D, 3D), CASE(Cube), CASE(Rect), CASE(Buffer), CASE(SubpassData), CASE(TileImageDataEXT), })); #undef CASE // clang-format on TEST_F(DimTest, WrongDim) { EXPECT_THAT(CompileFailure("%i = OpTypeImage %t xxyyzz 1 2 3 4 R8"), Eq("Invalid dimensionality 'xxyyzz'.")); } // Test ImageFormat enums via OpTypeImage using ImageFormatTest = spvtest::TextToBinaryTestBase< ::testing::TestWithParam>>; TEST_P(ImageFormatTest, AnyImageFormatAndNoAccessQualifier) { const std::string input = "%1 = OpTypeImage %2 1D 2 3 0 4 " + GetParam().name() + "\n"; EXPECT_THAT(CompiledInstructions(input), Eq(MakeInstruction(spv::Op::OpTypeImage, {1, 2, (uint32_t)spv::Dim::Dim1D, 2, 3, 0, 4, GetParam().value()}))); // Check the disassembler as well. EXPECT_THAT(EncodeAndDecodeSuccessfully(input), Eq(input)); } // clang-format off #define CASE(NAME) {spv::ImageFormat::NAME, #NAME} INSTANTIATE_TEST_SUITE_P( TextToBinaryImageFormat, ImageFormatTest, ::testing::ValuesIn(std::vector>{ CASE(Unknown), CASE(Rgba32f), CASE(Rgba16f), CASE(R32f), CASE(Rgba8), CASE(Rgba8Snorm), CASE(Rg32f), CASE(Rg16f), CASE(R11fG11fB10f), CASE(R16f), CASE(Rgba16), CASE(Rgb10A2), CASE(Rg16), CASE(Rg8), CASE(R16), CASE(R8), CASE(Rgba16Snorm), CASE(Rg16Snorm), CASE(Rg8Snorm), CASE(R16Snorm), CASE(R8Snorm), CASE(Rgba32i), CASE(Rgba16i), CASE(Rgba8i), CASE(R32i), CASE(Rg32i), CASE(Rg16i), CASE(Rg8i), CASE(R16i), CASE(R8i), CASE(Rgba32ui), CASE(Rgba16ui), CASE(Rgba8ui), CASE(R32ui), CASE(Rgb10a2ui), CASE(Rg32ui), CASE(Rg16ui), CASE(Rg8ui), CASE(R16ui), CASE(R8ui), })); #undef CASE // clang-format on TEST_F(ImageFormatTest, WrongFormat) { EXPECT_THAT(CompileFailure("%r = OpTypeImage %t 1D 2 3 0 4 xxyyzz"), Eq("Invalid image format 'xxyyzz'.")); } // Test AccessQualifier enums via OpTypeImage. using ImageAccessQualifierTest = spvtest::TextToBinaryTestBase< ::testing::TestWithParam>>; TEST_P(ImageAccessQualifierTest, AnyAccessQualifier) { const std::string input = "%1 = OpTypeImage %2 1D 2 3 0 4 Rgba8 " + GetParam().name() + "\n"; EXPECT_THAT(CompiledInstructions(input), Eq(MakeInstruction( spv::Op::OpTypeImage, {1, 2, (uint32_t)spv::Dim::Dim1D, 2, 3, 0, 4, (uint32_t)spv::ImageFormat::Rgba8, GetParam().value()}))); // Check the disassembler as well. EXPECT_THAT(EncodeAndDecodeSuccessfully(input), Eq(input)); } // clang-format off #define CASE(NAME) {spv::AccessQualifier::NAME, #NAME} INSTANTIATE_TEST_SUITE_P( AccessQualifier, ImageAccessQualifierTest, ::testing::ValuesIn(std::vector>{ CASE(ReadOnly), CASE(WriteOnly), CASE(ReadWrite), })); // clang-format on #undef CASE // Test AccessQualifier enums via OpTypePipe. using OpTypePipeTest = spvtest::TextToBinaryTestBase< ::testing::TestWithParam>>; TEST_P(OpTypePipeTest, AnyAccessQualifier) { const std::string input = "%1 = OpTypePipe " + GetParam().name() + "\n"; EXPECT_THAT( CompiledInstructions(input), Eq(MakeInstruction(spv::Op::OpTypePipe, {1, GetParam().value()}))); // Check the disassembler as well. EXPECT_THAT(EncodeAndDecodeSuccessfully(input), Eq(input)); } // clang-format off #define CASE(NAME) {spv::AccessQualifier::NAME, #NAME} INSTANTIATE_TEST_SUITE_P( TextToBinaryTypePipe, OpTypePipeTest, ::testing::ValuesIn(std::vector>{ CASE(ReadOnly), CASE(WriteOnly), CASE(ReadWrite), })); #undef CASE // clang-format on TEST_F(OpTypePipeTest, WrongAccessQualifier) { EXPECT_THAT(CompileFailure("%1 = OpTypePipe xxyyzz"), Eq("Invalid access qualifier 'xxyyzz'.")); } using OpTypeForwardPointerTest = spvtest::TextToBinaryTest; #define CASE(storage_class) \ do { \ EXPECT_THAT( \ CompiledInstructions("OpTypeForwardPointer %pt " #storage_class), \ Eq(MakeInstruction(spv::Op::OpTypeForwardPointer, \ {1, (uint32_t)spv::StorageClass::storage_class}))); \ } while (0) TEST_F(OpTypeForwardPointerTest, ValidStorageClass) { CASE(UniformConstant); CASE(Input); CASE(Uniform); CASE(Output); CASE(Workgroup); CASE(CrossWorkgroup); CASE(Private); CASE(Function); CASE(Generic); CASE(PushConstant); CASE(AtomicCounter); CASE(Image); CASE(StorageBuffer); CASE(TileImageEXT); } #undef CASE TEST_F(OpTypeForwardPointerTest, MissingType) { EXPECT_THAT(CompileFailure("OpTypeForwardPointer"), Eq("Expected operand for OpTypeForwardPointer instruction, but " "found the end of the stream.")); } TEST_F(OpTypeForwardPointerTest, MissingClass) { EXPECT_THAT(CompileFailure("OpTypeForwardPointer %pt"), Eq("Expected operand for OpTypeForwardPointer instruction, but " "found the end of the stream.")); } TEST_F(OpTypeForwardPointerTest, WrongClass) { EXPECT_THAT(CompileFailure("OpTypeForwardPointer %pt xxyyzz"), Eq("Invalid storage class 'xxyyzz'.")); } using OpSizeOfTest = spvtest::TextToBinaryTest; // We should be able to assemble it. Validation checks are in another test // file. TEST_F(OpSizeOfTest, OpcodeAssemblesInV10) { EXPECT_THAT( CompiledInstructions("%1 = OpSizeOf %2 %3", SPV_ENV_UNIVERSAL_1_0), Eq(MakeInstruction(spv::Op::OpSizeOf, {1, 2, 3}))); } TEST_F(OpSizeOfTest, ArgumentCount) { EXPECT_THAT( CompileFailure("OpSizeOf", SPV_ENV_UNIVERSAL_1_1), Eq("Expected at the beginning of an instruction, found " "'OpSizeOf'.")); EXPECT_THAT(CompileFailure("%res = OpSizeOf OpNop", SPV_ENV_UNIVERSAL_1_1), Eq("Expected operand for OpSizeOf instruction, but found the " "next instruction instead.")); EXPECT_THAT( CompiledInstructions("%1 = OpSizeOf %2 %3", SPV_ENV_UNIVERSAL_1_1), Eq(MakeInstruction(spv::Op::OpSizeOf, {1, 2, 3}))); EXPECT_THAT( CompileFailure("%1 = OpSizeOf %2 %3 44 55 ", SPV_ENV_UNIVERSAL_1_1), Eq("Expected or at the beginning of an instruction, " "found '44'.")); } TEST_F(OpSizeOfTest, ArgumentTypes) { EXPECT_THAT(CompileFailure("%1 = OpSizeOf 2 %3", SPV_ENV_UNIVERSAL_1_1), Eq("Expected id to start with %.")); EXPECT_THAT(CompileFailure("%1 = OpSizeOf %2 \"abc\"", SPV_ENV_UNIVERSAL_1_1), Eq("Expected id to start with %.")); } // TODO(dneto): OpTypeVoid // TODO(dneto): OpTypeBool // TODO(dneto): OpTypeInt // TODO(dneto): OpTypeFloat // TODO(dneto): OpTypeVector // TODO(dneto): OpTypeMatrix // TODO(dneto): OpTypeImage // TODO(dneto): OpTypeSampler // TODO(dneto): OpTypeSampledImage // TODO(dneto): OpTypeArray // TODO(dneto): OpTypeRuntimeArray // TODO(dneto): OpTypeStruct // TODO(dneto): OpTypeOpaque // TODO(dneto): OpTypePointer // TODO(dneto): OpTypeFunction // TODO(dneto): OpTypeEvent // TODO(dneto): OpTypeDeviceEvent // TODO(dneto): OpTypeReserveId // TODO(dneto): OpTypeQueue } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/text_to_binary_test.cpp000066400000000000000000000231601475742701700243070ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include #include #include "gmock/gmock.h" #include "source/spirv_constant.h" #include "source/util/bitutils.h" #include "source/util/hex_float.h" #include "test/test_fixture.h" #include "test/unit_spirv.h" namespace spvtools { namespace { using spvtest::AutoText; using spvtest::Concatenate; using spvtest::MakeInstruction; using spvtest::ScopedContext; using spvtest::TextToBinaryTest; using testing::Eq; using testing::IsNull; using testing::NotNull; // An mask parsing test case. struct MaskCase { spv_operand_type_t which_enum; uint32_t expected_value; const char* expression; }; using GoodMaskParseTest = ::testing::TestWithParam; TEST_P(GoodMaskParseTest, GoodMaskExpressions) { spv_context context = spvContextCreate(SPV_ENV_UNIVERSAL_1_0); uint32_t value; EXPECT_EQ(SPV_SUCCESS, AssemblyGrammar(context).parseMaskOperand( GetParam().which_enum, GetParam().expression, &value)); EXPECT_EQ(GetParam().expected_value, value); spvContextDestroy(context); } INSTANTIATE_TEST_SUITE_P( ParseMask, GoodMaskParseTest, ::testing::ValuesIn(std::vector{ {SPV_OPERAND_TYPE_FP_FAST_MATH_MODE, 0, "None"}, {SPV_OPERAND_TYPE_FP_FAST_MATH_MODE, 1, "NotNaN"}, {SPV_OPERAND_TYPE_FP_FAST_MATH_MODE, 2, "NotInf"}, {SPV_OPERAND_TYPE_FP_FAST_MATH_MODE, 3, "NotNaN|NotInf"}, // Mask expressions are symmetric. {SPV_OPERAND_TYPE_FP_FAST_MATH_MODE, 3, "NotInf|NotNaN"}, // Repeating a value has no effect. {SPV_OPERAND_TYPE_FP_FAST_MATH_MODE, 3, "NotInf|NotNaN|NotInf"}, // Using 3 operands still works. {SPV_OPERAND_TYPE_FP_FAST_MATH_MODE, 0x13, "NotInf|NotNaN|Fast"}, {SPV_OPERAND_TYPE_SELECTION_CONTROL, 0, "None"}, {SPV_OPERAND_TYPE_SELECTION_CONTROL, 1, "Flatten"}, {SPV_OPERAND_TYPE_SELECTION_CONTROL, 2, "DontFlatten"}, // Weirdly, you can specify to flatten and don't flatten a selection. {SPV_OPERAND_TYPE_SELECTION_CONTROL, 3, "Flatten|DontFlatten"}, {SPV_OPERAND_TYPE_LOOP_CONTROL, 0, "None"}, {SPV_OPERAND_TYPE_LOOP_CONTROL, 1, "Unroll"}, {SPV_OPERAND_TYPE_LOOP_CONTROL, 2, "DontUnroll"}, // Weirdly, you can specify to unroll and don't unroll a loop. {SPV_OPERAND_TYPE_LOOP_CONTROL, 3, "Unroll|DontUnroll"}, {SPV_OPERAND_TYPE_FUNCTION_CONTROL, 0, "None"}, {SPV_OPERAND_TYPE_FUNCTION_CONTROL, 1, "Inline"}, {SPV_OPERAND_TYPE_FUNCTION_CONTROL, 2, "DontInline"}, {SPV_OPERAND_TYPE_FUNCTION_CONTROL, 4, "Pure"}, {SPV_OPERAND_TYPE_FUNCTION_CONTROL, 8, "Const"}, {SPV_OPERAND_TYPE_FUNCTION_CONTROL, 0xd, "Inline|Const|Pure"}, })); using BadFPFastMathMaskParseTest = ::testing::TestWithParam; TEST_P(BadFPFastMathMaskParseTest, BadMaskExpressions) { spv_context context = spvContextCreate(SPV_ENV_UNIVERSAL_1_0); uint32_t value; EXPECT_NE(SPV_SUCCESS, AssemblyGrammar(context).parseMaskOperand( SPV_OPERAND_TYPE_FP_FAST_MATH_MODE, GetParam(), &value)); spvContextDestroy(context); } INSTANTIATE_TEST_SUITE_P(ParseMask, BadFPFastMathMaskParseTest, ::testing::ValuesIn(std::vector{ nullptr, "", "NotValidEnum", "|", "NotInf|", "|NotInf", "NotInf||NotNaN", "Unroll" // A good word, but for the wrong enum })); TEST_F(TextToBinaryTest, InvalidText) { ASSERT_EQ(SPV_ERROR_INVALID_TEXT, spvTextToBinary(ScopedContext().context, nullptr, 0, &binary, &diagnostic)); EXPECT_NE(nullptr, diagnostic); EXPECT_THAT(diagnostic->error, Eq(std::string("Missing assembly text."))); } TEST_F(TextToBinaryTest, InvalidPointer) { SetText( "OpEntryPoint Kernel 0 \"\"\nOpExecutionMode 0 LocalSizeHint 1 1 1\n"); ASSERT_EQ(SPV_ERROR_INVALID_POINTER, spvTextToBinary(ScopedContext().context, text.str, text.length, nullptr, &diagnostic)); } TEST_F(TextToBinaryTest, InvalidPrefix) { EXPECT_EQ( "Expected or at the beginning of an instruction, " "found 'Invalid'.", CompileFailure("Invalid")); } TEST_F(TextToBinaryTest, EmptyAssemblyString) { // An empty assembly module is valid! // It should produce a valid module with zero instructions. EXPECT_THAT(CompiledInstructions(""), Eq(std::vector{})); } TEST_F(TextToBinaryTest, StringSpace) { const std::string code = ("OpSourceExtension \"string with spaces\"\n"); EXPECT_EQ(code, EncodeAndDecodeSuccessfully(code)); } TEST_F(TextToBinaryTest, UnknownBeginningOfInstruction) { EXPECT_EQ( "Expected or at the beginning of an instruction, " "found 'Google'.", CompileFailure( "\nOpSource OpenCL_C 12\nOpMemoryModel Physical64 OpenCL\nGoogle\n")); EXPECT_EQ(4u, diagnostic->position.line + 1); EXPECT_EQ(1u, diagnostic->position.column + 1); } TEST_F(TextToBinaryTest, NoEqualSign) { EXPECT_EQ("Expected '=', found end of stream.", CompileFailure("\nOpSource OpenCL_C 12\n" "OpMemoryModel Physical64 OpenCL\n%2\n")); EXPECT_EQ(5u, diagnostic->position.line + 1); EXPECT_EQ(1u, diagnostic->position.column + 1); } TEST_F(TextToBinaryTest, NoOpCode) { EXPECT_EQ("Expected opcode, found end of stream.", CompileFailure("\nOpSource OpenCL_C 12\n" "OpMemoryModel Physical64 OpenCL\n%2 =\n")); EXPECT_EQ(5u, diagnostic->position.line + 1); EXPECT_EQ(1u, diagnostic->position.column + 1); } TEST_F(TextToBinaryTest, WrongOpCode) { EXPECT_EQ("Invalid Opcode prefix 'Wahahaha'.", CompileFailure("\nOpSource OpenCL_C 12\n" "OpMemoryModel Physical64 OpenCL\n%2 = Wahahaha\n")); EXPECT_EQ(4u, diagnostic->position.line + 1); EXPECT_EQ(6u, diagnostic->position.column + 1); } TEST_F(TextToBinaryTest, CRLF) { const std::string input = "%i32 = OpTypeInt 32 1\r\n%c = OpConstant %i32 123\r\n"; EXPECT_THAT( CompiledInstructions(input), Eq(Concatenate({MakeInstruction(spv::Op::OpTypeInt, {1, 32, 1}), MakeInstruction(spv::Op::OpConstant, {1, 2, 123})}))); } using TextToBinaryFloatValueTest = spvtest::TextToBinaryTestBase< ::testing::TestWithParam>>; TEST_P(TextToBinaryFloatValueTest, Samples) { const std::string input = "%1 = OpTypeFloat 32\n%2 = OpConstant %1 " + GetParam().first; EXPECT_THAT(CompiledInstructions(input), Eq(Concatenate({MakeInstruction(spv::Op::OpTypeFloat, {1, 32}), MakeInstruction(spv::Op::OpConstant, {1, 2, GetParam().second})}))); } INSTANTIATE_TEST_SUITE_P( FloatValues, TextToBinaryFloatValueTest, ::testing::ValuesIn(std::vector>{ {"0.0", 0x00000000}, // +0 {"!0x00000001", 0x00000001}, // +denorm {"!0x00800000", 0x00800000}, // +norm {"1.5", 0x3fc00000}, {"!0x7f800000", 0x7f800000}, // +inf {"!0x7f800001", 0x7f800001}, // NaN {"-0.0", 0x80000000}, // -0 {"!0x80000001", 0x80000001}, // -denorm {"!0x80800000", 0x80800000}, // -norm {"-2.5", 0xc0200000}, {"!0xff800000", 0xff800000}, // -inf {"!0xff800001", 0xff800001}, // NaN })); using TextToBinaryHalfValueTest = spvtest::TextToBinaryTestBase< ::testing::TestWithParam>>; TEST_P(TextToBinaryHalfValueTest, Samples) { const std::string input = "%1 = OpTypeFloat 16\n%2 = OpConstant %1 " + GetParam().first; EXPECT_THAT(CompiledInstructions(input), Eq(Concatenate({MakeInstruction(spv::Op::OpTypeFloat, {1, 16}), MakeInstruction(spv::Op::OpConstant, {1, 2, GetParam().second})}))); } INSTANTIATE_TEST_SUITE_P( HalfValues, TextToBinaryHalfValueTest, ::testing::ValuesIn(std::vector>{ {"0.0", 0x00000000}, {"1.0", 0x00003c00}, {"1.000844", 0x00003c00}, // Truncate to 1.0 {"1.000977", 0x00003c01}, // Don't have to truncate {"1.001465", 0x00003c01}, // Truncate to 1.0000977 {"1.5", 0x00003e00}, {"-1.0", 0x0000bc00}, {"2.0", 0x00004000}, {"-2.0", 0x0000c000}, {"0x1p1", 0x00004000}, {"-0x1p1", 0x0000c000}, {"0x1.8p1", 0x00004200}, {"0x1.8p4", 0x00004e00}, {"0x1.801p4", 0x00004e00}, {"0x1.804p4", 0x00004e01}, })); TEST(CreateContext, UniversalEnvironment) { auto c = spvContextCreate(SPV_ENV_UNIVERSAL_1_0); EXPECT_THAT(c, NotNull()); spvContextDestroy(c); } TEST(CreateContext, VulkanEnvironment) { auto c = spvContextCreate(SPV_ENV_VULKAN_1_0); EXPECT_THAT(c, NotNull()); spvContextDestroy(c); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/text_word_get_test.cpp000066400000000000000000000175001475742701700241340ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "test/unit_spirv.h" namespace spvtools { namespace { using spvtest::AutoText; #define TAB "\t" #define NEWLINE "\n" #define BACKSLASH R"(\)" #define QUOTE R"(")" TEST(TextWordGet, NullTerminator) { std::string word; spv_position_t endPosition = {}; ASSERT_EQ( SPV_SUCCESS, AssemblyContext(AutoText("Word"), nullptr).getWord(&word, &endPosition)); ASSERT_EQ(4u, endPosition.column); ASSERT_EQ(0u, endPosition.line); ASSERT_EQ(4u, endPosition.index); ASSERT_STREQ("Word", word.c_str()); } TEST(TextWordGet, TabTerminator) { std::string word; spv_position_t endPosition = {}; ASSERT_EQ(SPV_SUCCESS, AssemblyContext(AutoText("Word\t"), nullptr) .getWord(&word, &endPosition)); ASSERT_EQ(4u, endPosition.column); ASSERT_EQ(0u, endPosition.line); ASSERT_EQ(4u, endPosition.index); ASSERT_STREQ("Word", word.c_str()); } TEST(TextWordGet, SpaceTerminator) { std::string word; spv_position_t endPosition = {}; ASSERT_EQ( SPV_SUCCESS, AssemblyContext(AutoText("Word "), nullptr).getWord(&word, &endPosition)); ASSERT_EQ(4u, endPosition.column); ASSERT_EQ(0u, endPosition.line); ASSERT_EQ(4u, endPosition.index); ASSERT_STREQ("Word", word.c_str()); } TEST(TextWordGet, SemicolonTerminator) { std::string word; spv_position_t endPosition = {}; ASSERT_EQ( SPV_SUCCESS, AssemblyContext(AutoText("Wo;rd"), nullptr).getWord(&word, &endPosition)); ASSERT_EQ(2u, endPosition.column); ASSERT_EQ(0u, endPosition.line); ASSERT_EQ(2u, endPosition.index); ASSERT_STREQ("Wo", word.c_str()); } TEST(TextWordGet, NoTerminator) { const std::string full_text = "abcdefghijklmn"; for (size_t len = 1; len <= full_text.size(); ++len) { std::string word; spv_text_t text = {full_text.data(), len}; spv_position_t endPosition = {}; ASSERT_EQ(SPV_SUCCESS, AssemblyContext(&text, nullptr).getWord(&word, &endPosition)); ASSERT_EQ(0u, endPosition.line); ASSERT_EQ(len, endPosition.column); ASSERT_EQ(len, endPosition.index); ASSERT_EQ(full_text.substr(0, len), word); } } TEST(TextWordGet, MultipleWords) { AutoText input("Words in a sentence"); AssemblyContext data(input, nullptr); spv_position_t endPosition = {}; const char* words[] = {"Words", "in", "a", "sentence"}; std::string word; for (uint32_t wordIndex = 0; wordIndex < 4; ++wordIndex) { ASSERT_EQ(SPV_SUCCESS, data.getWord(&word, &endPosition)); ASSERT_EQ(strlen(words[wordIndex]), endPosition.column - data.position().column); ASSERT_EQ(0u, endPosition.line); ASSERT_EQ(strlen(words[wordIndex]), endPosition.index - data.position().index); ASSERT_STREQ(words[wordIndex], word.c_str()); data.setPosition(endPosition); if (3 != wordIndex) { ASSERT_EQ(SPV_SUCCESS, data.advance()); } else { ASSERT_EQ(SPV_END_OF_STREAM, data.advance()); } } } TEST(TextWordGet, QuotesAreKept) { AutoText input(R"("quotes" "around words")"); const char* expected[] = {R"("quotes")", R"("around words")"}; AssemblyContext data(input, nullptr); std::string word; spv_position_t endPosition = {}; ASSERT_EQ(SPV_SUCCESS, data.getWord(&word, &endPosition)); EXPECT_EQ(8u, endPosition.column); EXPECT_EQ(0u, endPosition.line); EXPECT_EQ(8u, endPosition.index); EXPECT_STREQ(expected[0], word.c_str()); // Move to the next word. data.setPosition(endPosition); data.seekForward(1); ASSERT_EQ(SPV_SUCCESS, data.getWord(&word, &endPosition)); EXPECT_EQ(23u, endPosition.column); EXPECT_EQ(0u, endPosition.line); EXPECT_EQ(23u, endPosition.index); EXPECT_STREQ(expected[1], word.c_str()); } TEST(TextWordGet, QuotesBetweenWordsActLikeGlue) { AutoText input(R"(quotes" "between words)"); const char* expected[] = {R"(quotes" "between)", "words"}; AssemblyContext data(input, nullptr); std::string word; spv_position_t endPosition = {}; ASSERT_EQ(SPV_SUCCESS, data.getWord(&word, &endPosition)); EXPECT_EQ(16u, endPosition.column); EXPECT_EQ(0u, endPosition.line); EXPECT_EQ(16u, endPosition.index); EXPECT_STREQ(expected[0], word.c_str()); // Move to the next word. data.setPosition(endPosition); data.seekForward(1); ASSERT_EQ(SPV_SUCCESS, data.getWord(&word, &endPosition)); EXPECT_EQ(22u, endPosition.column); EXPECT_EQ(0u, endPosition.line); EXPECT_EQ(22u, endPosition.index); EXPECT_STREQ(expected[1], word.c_str()); } TEST(TextWordGet, QuotingWhitespace) { AutoText input(QUOTE "white " NEWLINE TAB " space" QUOTE); // Whitespace surrounded by quotes acts like glue. std::string word; spv_position_t endPosition = {}; ASSERT_EQ(SPV_SUCCESS, AssemblyContext(input, nullptr).getWord(&word, &endPosition)); EXPECT_EQ(input.str.length(), endPosition.column); EXPECT_EQ(0u, endPosition.line); EXPECT_EQ(input.str.length(), endPosition.index); EXPECT_EQ(input.str, word); } TEST(TextWordGet, QuoteAlone) { AutoText input(QUOTE); std::string word; spv_position_t endPosition = {}; ASSERT_EQ(SPV_SUCCESS, AssemblyContext(input, nullptr).getWord(&word, &endPosition)); ASSERT_EQ(1u, endPosition.column); ASSERT_EQ(0u, endPosition.line); ASSERT_EQ(1u, endPosition.index); ASSERT_STREQ(QUOTE, word.c_str()); } TEST(TextWordGet, EscapeAlone) { AutoText input(BACKSLASH); std::string word; spv_position_t endPosition = {}; ASSERT_EQ(SPV_SUCCESS, AssemblyContext(input, nullptr).getWord(&word, &endPosition)); ASSERT_EQ(1u, endPosition.column); ASSERT_EQ(0u, endPosition.line); ASSERT_EQ(1u, endPosition.index); ASSERT_STREQ(BACKSLASH, word.c_str()); } TEST(TextWordGet, EscapeAtEndOfInput) { AutoText input("word" BACKSLASH); std::string word; spv_position_t endPosition = {}; ASSERT_EQ(SPV_SUCCESS, AssemblyContext(input, nullptr).getWord(&word, &endPosition)); ASSERT_EQ(5u, endPosition.column); ASSERT_EQ(0u, endPosition.line); ASSERT_EQ(5u, endPosition.index); ASSERT_STREQ("word" BACKSLASH, word.c_str()); } TEST(TextWordGet, Escaping) { AutoText input("w" BACKSLASH QUOTE "o" BACKSLASH NEWLINE "r" BACKSLASH ";d"); std::string word; spv_position_t endPosition = {}; ASSERT_EQ(SPV_SUCCESS, AssemblyContext(input, nullptr).getWord(&word, &endPosition)); ASSERT_EQ(10u, endPosition.column); ASSERT_EQ(0u, endPosition.line); ASSERT_EQ(10u, endPosition.index); ASSERT_EQ(input.str, word); } TEST(TextWordGet, EscapingEscape) { AutoText input("word" BACKSLASH BACKSLASH " abc"); std::string word; spv_position_t endPosition = {}; ASSERT_EQ(SPV_SUCCESS, AssemblyContext(input, nullptr).getWord(&word, &endPosition)); ASSERT_EQ(6u, endPosition.column); ASSERT_EQ(0u, endPosition.line); ASSERT_EQ(6u, endPosition.index); ASSERT_STREQ("word" BACKSLASH BACKSLASH, word.c_str()); } TEST(TextWordGet, CRLF) { AutoText input("abc\r\nd"); AssemblyContext data(input, nullptr); std::string word; spv_position_t pos = {}; ASSERT_EQ(SPV_SUCCESS, data.getWord(&word, &pos)); EXPECT_EQ(3u, pos.column); EXPECT_STREQ("abc", word.c_str()); data.setPosition(pos); data.advance(); ASSERT_EQ(SPV_SUCCESS, data.getWord(&word, &pos)); EXPECT_EQ(1u, pos.column); EXPECT_STREQ("d", word.c_str()); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/timer_test.cpp000066400000000000000000000107441475742701700224010ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gtest/gtest.h" #include "source/util/timer.h" namespace spvtools { namespace utils { namespace { // A mock class to mimic Timer class for a testing purpose. It has fixed // CPU/WALL/USR/SYS time, RSS delta, and the delta of the number of page faults. class MockTimer : public Timer { public: MockTimer(std::ostream* out, bool measure_mem_usage = false) : Timer(out, measure_mem_usage) {} double CPUTime() override { return 0.019123; } double WallTime() override { return 0.019723; } double UserTime() override { return 0.012723; } double SystemTime() override { return 0.002723; } long RSS() const override { return 360L; } long PageFault() const override { return 3600L; } }; // This unit test checks whether the actual output of MockTimer::Report() is the // same as fixed CPU/WALL/USR/SYS time, RSS delta, and the delta of the number // of page faults that are returned by MockTimer. TEST(MockTimer, DoNothing) { std::ostringstream buf; PrintTimerDescription(&buf); MockTimer timer(&buf); timer.Start(); // Do nothing. timer.Stop(); timer.Report("TimerTest"); EXPECT_EQ(0.019123, timer.CPUTime()); EXPECT_EQ(0.019723, timer.WallTime()); EXPECT_EQ(0.012723, timer.UserTime()); EXPECT_EQ(0.002723, timer.SystemTime()); EXPECT_EQ( " PASS name CPU time WALL time USR time" " SYS time\n TimerTest 0.02 0.02" " 0.01 0.00\n", buf.str()); } // This unit test checks whether the ScopedTimer correctly reports // the fixed CPU/WALL/USR/SYS time, RSS delta, and the delta of the number of // page faults that are returned by MockTimer. TEST(MockTimer, TestScopedTimer) { std::ostringstream buf; { ScopedTimer scopedtimer(&buf, "ScopedTimerTest"); // Do nothing. } EXPECT_EQ( " ScopedTimerTest 0.02 0.02 0.01" " 0.00\n", buf.str()); } // A mock class to mimic CumulativeTimer class for a testing purpose. It has // fixed CPU/WALL/USR/SYS time, RSS delta, and the delta of the number of page // faults for each measurement (i.e., a pair of Start() and Stop()). If the // number of measurements increases, it increases |count_stop_| by the number of // calling Stop() and the amount of each resource usage is proportional to // |count_stop_|. class MockCumulativeTimer : public CumulativeTimer { public: MockCumulativeTimer(std::ostream* out, bool measure_mem_usage = false) : CumulativeTimer(out, measure_mem_usage), count_stop_(0) {} double CPUTime() override { return count_stop_ * 0.019123; } double WallTime() override { return count_stop_ * 0.019723; } double UserTime() override { return count_stop_ * 0.012723; } double SystemTime() override { return count_stop_ * 0.002723; } long RSS() const override { return count_stop_ * 360L; } long PageFault() const override { return count_stop_ * 3600L; } // Calling Stop() does nothing but just increases |count_stop_| by 1. void Stop() override { ++count_stop_; } private: unsigned int count_stop_; }; // This unit test checks whether the MockCumulativeTimer correctly reports the // cumulative CPU/WALL/USR/SYS time, RSS delta, and the delta of the number of // page faults whose values are fixed for each measurement (i.e., a pair of // Start() and Stop()). TEST(MockCumulativeTimer, DoNothing) { CumulativeTimer* ctimer; std::ostringstream buf; { ctimer = new MockCumulativeTimer(&buf); ctimer->Start(); // Do nothing. ctimer->Stop(); } { ctimer->Start(); // Do nothing. ctimer->Stop(); ctimer->Report("CumulativeTimerTest"); } EXPECT_EQ( " CumulativeTimerTest 0.04 0.04 0.03" " 0.01\n", buf.str()); if (ctimer) delete ctimer; } } // namespace } // namespace utils } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/to_string_test.cpp000066400000000000000000000016221475742701700232640ustar00rootroot00000000000000// Copyright (c) 2024 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/to_string.h" #include "gmock/gmock.h" namespace { TEST(ToString, Uint32) { EXPECT_EQ(spvtools::to_string(0u), "0"); EXPECT_EQ(spvtools::to_string(1u), "1"); EXPECT_EQ(spvtools::to_string(1234567890u), "1234567890"); EXPECT_EQ(spvtools::to_string(0xffffffffu), "4294967295"); } } // namespace KhronosGroup-SPIRV-Tools-f289d04/test/tools/000077500000000000000000000000001475742701700206505ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/tools/CMakeLists.txt000066400000000000000000000023321475742701700234100ustar00rootroot00000000000000# Copyright (c) 2018 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. add_test(NAME spirv-tools_expect_unittests COMMAND Python3::Interpreter -m unittest expect_unittest.py WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}) add_test(NAME spirv-tools_spirv_test_framework_unittests COMMAND Python3::Interpreter -m unittest spirv_test_framework_unittest.py WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}) add_spvtools_unittest( TARGET spirv_unit_test_tools_util SRCS flags_test.cpp ${spirv-tools_SOURCE_DIR}/tools/util/flags.cpp LIBS ${SPIRV_TOOLS_FULL_VISIBILITY} DEFINES TESTING=1) add_subdirectory(opt) if(NOT (${CMAKE_SYSTEM_NAME} STREQUAL "Android")) add_subdirectory(objdump) endif () KhronosGroup-SPIRV-Tools-f289d04/test/tools/expect.py000077500000000000000000000671421475742701700225270ustar00rootroot00000000000000# Copyright (c) 2018 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """A number of common spirv result checks coded in mixin classes. A test case can use these checks by declaring their enclosing mixin classes as superclass and providing the expected_* variables required by the check_*() methods in the mixin classes. """ import difflib import functools import os import re import subprocess import traceback from spirv_test_framework import SpirvTest from builtins import bytes DEFAULT_SPIRV_VERSION = 0x010000 def convert_to_unix_line_endings(source): """Converts all line endings in source to be unix line endings.""" result = source.replace('\r\n', '\n').replace('\r', '\n') return result def substitute_file_extension(filename, extension): """Substitutes file extension, respecting known shader extensions. foo.vert -> foo.vert.[extension] [similarly for .frag, .comp, etc.] foo.glsl -> foo.[extension] foo.unknown -> foo.[extension] foo -> foo.[extension] """ if filename[-5:] not in [ '.vert', '.frag', '.tesc', '.tese', '.geom', '.comp', '.spvasm' ]: return filename.rsplit('.', 1)[0] + '.' + extension else: return filename + '.' + extension def get_object_filename(source_filename): """Gets the object filename for the given source file.""" return substitute_file_extension(source_filename, 'spv') def get_assembly_filename(source_filename): """Gets the assembly filename for the given source file.""" return substitute_file_extension(source_filename, 'spvasm') def verify_file_non_empty(filename): """Checks that a given file exists and is not empty.""" if not os.path.isfile(filename): return False, 'Cannot find file: ' + filename if not os.path.getsize(filename): return False, 'Empty file: ' + filename return True, '' class ReturnCodeIsZero(SpirvTest): """Mixin class for checking that the return code is zero.""" def check_return_code_is_zero(self, status): if status.returncode: return False, 'Non-zero return code: {ret}\n'.format( ret=status.returncode) return True, '' class ReturnCodeIsNonZero(SpirvTest): """Mixin class for checking that the return code is not zero.""" def check_return_code_is_nonzero(self, status): if not status.returncode: return False, 'return code is 0' return True, '' class NoOutputOnStdout(SpirvTest): """Mixin class for checking that there is no output on stdout.""" def check_no_output_on_stdout(self, status): if status.stdout: return False, 'Non empty stdout: {out}\n'.format(out=status.stdout) return True, '' class NoOutputOnStderr(SpirvTest): """Mixin class for checking that there is no output on stderr.""" def check_no_output_on_stderr(self, status): if status.stderr: return False, 'Non empty stderr: {err}\n'.format(err=status.stderr) return True, '' class SuccessfulReturn(ReturnCodeIsZero, NoOutputOnStdout, NoOutputOnStderr): """Mixin class for checking that return code is zero and no output on stdout and stderr.""" pass class NoGeneratedFiles(SpirvTest): """Mixin class for checking that there is no file generated.""" def check_no_generated_files(self, status): all_files = os.listdir(status.directory) input_files = status.input_filenames if all([f.startswith(status.directory) for f in input_files]): all_files = [os.path.join(status.directory, f) for f in all_files] generated_files = set(all_files) - set(input_files) if len(generated_files) == 0: return True, '' else: return False, 'Extra files generated: {}'.format(generated_files) class CorrectBinaryLengthAndPreamble(SpirvTest): """Provides methods for verifying preamble for a SPIR-V binary.""" def verify_binary_length_and_header(self, binary, spv_version=0x10000): """Checks that the given SPIR-V binary has valid length and header. Returns: False, error string if anything is invalid True, '' otherwise Args: binary: a bytes object containing the SPIR-V binary spv_version: target SPIR-V version number, with same encoding as the version word in a SPIR-V header. """ def read_word(binary, index, little_endian): """Reads the index-th word from the given binary file.""" word = binary[index * 4:(index + 1) * 4] if little_endian: word = reversed(word) return functools.reduce(lambda w, b: (w << 8) | b, word, 0) def check_endianness(binary): """Checks the endianness of the given SPIR-V binary. Returns: True if it's little endian, False if it's big endian. None if magic number is wrong. """ first_word = read_word(binary, 0, True) if first_word == 0x07230203: return True first_word = read_word(binary, 0, False) if first_word == 0x07230203: return False return None num_bytes = len(binary) if num_bytes % 4 != 0: return False, ('Incorrect SPV binary: size should be a multiple' ' of words') if num_bytes < 20: return False, 'Incorrect SPV binary: size less than 5 words' preamble = binary[0:19] little_endian = check_endianness(preamble) # SPIR-V module magic number if little_endian is None: return False, 'Incorrect SPV binary: wrong magic number' # SPIR-V version number version = read_word(preamble, 1, little_endian) # TODO(dneto): Recent Glslang uses version word 0 for opengl_compat # profile if version != spv_version and version != 0: return False, 'Incorrect SPV binary: wrong version number: ' + hex(version) + ' expected ' + hex(spv_version) # Shaderc-over-Glslang (0x000d....) or # SPIRV-Tools (0x0007....) generator number if read_word(preamble, 2, little_endian) != 0x000d0007 and \ read_word(preamble, 2, little_endian) != 0x00070000: return False, ('Incorrect SPV binary: wrong generator magic ' 'number') # reserved for instruction schema if read_word(preamble, 4, little_endian) != 0: return False, 'Incorrect SPV binary: the 5th byte should be 0' return True, '' class CorrectObjectFilePreamble(CorrectBinaryLengthAndPreamble): """Provides methods for verifying preamble for a SPV object file.""" def verify_object_file_preamble(self, filename, spv_version=DEFAULT_SPIRV_VERSION): """Checks that the given SPIR-V binary file has correct preamble.""" success, message = verify_file_non_empty(filename) if not success: return False, message with open(filename, 'rb') as object_file: object_file.seek(0, os.SEEK_END) num_bytes = object_file.tell() object_file.seek(0) binary = bytes(object_file.read()) return self.verify_binary_length_and_header(binary, spv_version) return True, '' class CorrectAssemblyFilePreamble(SpirvTest): """Provides methods for verifying preamble for a SPV assembly file.""" def verify_assembly_file_preamble(self, filename): success, message = verify_file_non_empty(filename) if not success: return False, message with open(filename) as assembly_file: line1 = assembly_file.readline() line2 = assembly_file.readline() line3 = assembly_file.readline() if (line1 != '; SPIR-V\n' or line2 != '; Version: 1.0\n' or (not line3.startswith('; Generator: Google Shaderc over Glslang;'))): return False, 'Incorrect SPV assembly' return True, '' class ValidObjectFile(SuccessfulReturn, CorrectObjectFilePreamble): """Mixin class for checking that every input file generates a valid SPIR-V 1.0 object file following the object file naming rule, and there is no output on stdout/stderr.""" def check_object_file_preamble(self, status): for input_filename in status.input_filenames: object_filename = get_object_filename(input_filename) success, message = self.verify_object_file_preamble( os.path.join(status.directory, object_filename)) if not success: return False, message return True, '' class ValidObjectFile1_3(ReturnCodeIsZero, CorrectObjectFilePreamble): """Mixin class for checking that every input file generates a valid SPIR-V 1.3 object file following the object file naming rule, and there is no output on stdout/stderr.""" def check_object_file_preamble(self, status): for input_filename in status.input_filenames: object_filename = get_object_filename(input_filename) success, message = self.verify_object_file_preamble( os.path.join(status.directory, object_filename), 0x10300) if not success: return False, message return True, '' class ValidObjectFile1_5(ReturnCodeIsZero, CorrectObjectFilePreamble): """Mixin class for checking that every input file generates a valid SPIR-V 1.5 object file following the object file naming rule, and there is no output on stdout/stderr.""" def check_object_file_preamble(self, status): for input_filename in status.input_filenames: object_filename = get_object_filename(input_filename) success, message = self.verify_object_file_preamble( os.path.join(status.directory, object_filename), 0x10500) if not success: return False, message return True, '' class ValidObjectFile1_6(ReturnCodeIsZero, CorrectObjectFilePreamble): """Mixin class for checking that every input file generates a valid SPIR-V 1.6 object file following the object file naming rule, and there is no output on stdout/stderr.""" def check_object_file_preamble(self, status): for input_filename in status.input_filenames: object_filename = get_object_filename(input_filename) success, message = self.verify_object_file_preamble( os.path.join(status.directory, object_filename), 0x10600) if not success: return False, message return True, '' class ValidObjectFileWithAssemblySubstr(SuccessfulReturn, CorrectObjectFilePreamble): """Mixin class for checking that every input file generates a valid object file following the object file naming rule, there is no output on stdout/stderr, and the disassmbly contains a specified substring per input. """ def check_object_file_disassembly(self, status): for an_input in status.inputs: object_filename = get_object_filename(an_input.filename) obj_file = str(os.path.join(status.directory, object_filename)) success, message = self.verify_object_file_preamble(obj_file) if not success: return False, message cmd = [status.test_manager.disassembler_path, '--no-color', obj_file] process = subprocess.Popen( args=cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=status.directory) output = process.communicate(None) disassembly = output[0] if not isinstance(an_input.assembly_substr, str): return False, 'Missing assembly_substr member' if an_input.assembly_substr not in disassembly: return False, ('Incorrect disassembly output:\n{asm}\n' 'Expected substring not found:\n{exp}'.format( asm=disassembly, exp=an_input.assembly_substr)) return True, '' class ValidNamedObjectFile(SuccessfulReturn, CorrectObjectFilePreamble): """Mixin class for checking that a list of object files with the given names are correctly generated, and there is no output on stdout/stderr. To mix in this class, subclasses need to provide expected_object_filenames as the expected object filenames. """ def check_object_file_preamble(self, status): for object_filename in self.expected_object_filenames: success, message = self.verify_object_file_preamble( os.path.join(status.directory, object_filename)) if not success: return False, message return True, '' class ValidFileContents(SpirvTest): """Mixin class to test that a specific file contains specific text To mix in this class, subclasses need to provide expected_file_contents as the contents of the file and target_filename to determine the location.""" def check_file(self, status): target_filename = os.path.join(status.directory, self.target_filename) if not os.path.isfile(target_filename): return False, 'Cannot find file: ' + target_filename with open(target_filename, 'r') as target_file: file_contents = target_file.read() if isinstance(self.expected_file_contents, str): if file_contents == self.expected_file_contents: return True, '' return False, ('Incorrect file output: \n{act}\n' 'Expected:\n{exp}' 'With diff:\n{diff}'.format( act=file_contents, exp=self.expected_file_contents, diff='\n'.join( list( difflib.unified_diff( self.expected_file_contents.split('\n'), file_contents.split('\n'), fromfile='expected_output', tofile='actual_output'))))) elif isinstance(self.expected_file_contents, type(re.compile(''))): if self.expected_file_contents.search(file_contents): return True, '' return False, ('Incorrect file output: \n{act}\n' 'Expected matching regex pattern:\n{exp}'.format( act=file_contents, exp=self.expected_file_contents.pattern)) return False, ( 'Could not open target file ' + target_filename + ' for reading') class ValidAssemblyFile(SuccessfulReturn, CorrectAssemblyFilePreamble): """Mixin class for checking that every input file generates a valid assembly file following the assembly file naming rule, and there is no output on stdout/stderr.""" def check_assembly_file_preamble(self, status): for input_filename in status.input_filenames: assembly_filename = get_assembly_filename(input_filename) success, message = self.verify_assembly_file_preamble( os.path.join(status.directory, assembly_filename)) if not success: return False, message return True, '' class ValidAssemblyFileWithSubstr(ValidAssemblyFile): """Mixin class for checking that every input file generates a valid assembly file following the assembly file naming rule, there is no output on stdout/stderr, and all assembly files have the given substring specified by expected_assembly_substr. To mix in this class, subclasses need to provde expected_assembly_substr as the expected substring. """ def check_assembly_with_substr(self, status): for input_filename in status.input_filenames: assembly_filename = get_assembly_filename(input_filename) success, message = self.verify_assembly_file_preamble( os.path.join(status.directory, assembly_filename)) if not success: return False, message with open(assembly_filename, 'r') as f: content = f.read() if self.expected_assembly_substr not in convert_to_unix_line_endings( content): return False, ('Incorrect assembly output:\n{asm}\n' 'Expected substring not found:\n{exp}'.format( asm=content, exp=self.expected_assembly_substr)) return True, '' class ValidAssemblyFileWithoutSubstr(ValidAssemblyFile): """Mixin class for checking that every input file generates a valid assembly file following the assembly file naming rule, there is no output on stdout/stderr, and no assembly files have the given substring specified by unexpected_assembly_substr. To mix in this class, subclasses need to provde unexpected_assembly_substr as the substring we expect not to see. """ def check_assembly_for_substr(self, status): for input_filename in status.input_filenames: assembly_filename = get_assembly_filename(input_filename) success, message = self.verify_assembly_file_preamble( os.path.join(status.directory, assembly_filename)) if not success: return False, message with open(assembly_filename, 'r') as f: content = f.read() if self.unexpected_assembly_substr in convert_to_unix_line_endings( content): return False, ('Incorrect assembly output:\n{asm}\n' 'Unexpected substring found:\n{unexp}'.format( asm=content, exp=self.unexpected_assembly_substr)) return True, '' class ValidNamedAssemblyFile(SuccessfulReturn, CorrectAssemblyFilePreamble): """Mixin class for checking that a list of assembly files with the given names are correctly generated, and there is no output on stdout/stderr. To mix in this class, subclasses need to provide expected_assembly_filenames as the expected assembly filenames. """ def check_object_file_preamble(self, status): for assembly_filename in self.expected_assembly_filenames: success, message = self.verify_assembly_file_preamble( os.path.join(status.directory, assembly_filename)) if not success: return False, message return True, '' class ErrorMessage(SpirvTest): """Mixin class for tests that fail with a specific error message. To mix in this class, subclasses need to provide expected_error as the expected error message. The test should fail if the subprocess was terminated by a signal. """ def check_has_error_message(self, status): if not status.returncode: return False, ('Expected error message, but returned success from ' 'command execution') if status.returncode < 0: # On Unix, a negative value -N for Popen.returncode indicates # termination by signal N. # https://docs.python.org/2/library/subprocess.html return False, ('Expected error message, but command was terminated by ' 'signal ' + str(status.returncode)) if not status.stderr: return False, 'Expected error message, but no output on stderr' if self.expected_error != convert_to_unix_line_endings(status.stderr): return False, ('Incorrect stderr output:\n{act}\n' 'Expected:\n{exp}'.format( act=status.stderr, exp=self.expected_error)) return True, '' class ErrorMessageSubstr(SpirvTest): """Mixin class for tests that fail with a specific substring in the error message. To mix in this class, subclasses need to provide expected_error_substr as the expected error message substring. The test should fail if the subprocess was terminated by a signal. """ def check_has_error_message_as_substring(self, status): if not status.returncode: return False, ('Expected error message, but returned success from ' 'command execution') if status.returncode < 0: # On Unix, a negative value -N for Popen.returncode indicates # termination by signal N. # https://docs.python.org/2/library/subprocess.html return False, ('Expected error message, but command was terminated by ' 'signal ' + str(status.returncode)) if not status.stderr: return False, 'Expected error message, but no output on stderr' if self.expected_error_substr not in convert_to_unix_line_endings( status.stderr): return False, ('Incorrect stderr output:\n{act}\n' 'Expected substring not found in stderr:\n{exp}'.format( act=status.stderr, exp=self.expected_error_substr)) return True, '' class WarningMessage(SpirvTest): """Mixin class for tests that succeed but have a specific warning message. To mix in this class, subclasses need to provide expected_warning as the expected warning message. """ def check_has_warning_message(self, status): if status.returncode: return False, ('Expected warning message, but returned failure from' ' command execution') if not status.stderr: return False, 'Expected warning message, but no output on stderr' if self.expected_warning != convert_to_unix_line_endings(status.stderr): return False, ('Incorrect stderr output:\n{act}\n' 'Expected:\n{exp}'.format( act=status.stderr, exp=self.expected_warning)) return True, '' class ValidObjectFileWithWarning(NoOutputOnStdout, CorrectObjectFilePreamble, WarningMessage): """Mixin class for checking that every input file generates a valid object file following the object file naming rule, with a specific warning message. """ def check_object_file_preamble(self, status): for input_filename in status.input_filenames: object_filename = get_object_filename(input_filename) success, message = self.verify_object_file_preamble( os.path.join(status.directory, object_filename)) if not success: return False, message return True, '' class ValidAssemblyFileWithWarning(NoOutputOnStdout, CorrectAssemblyFilePreamble, WarningMessage): """Mixin class for checking that every input file generates a valid assembly file following the assembly file naming rule, with a specific warning message.""" def check_assembly_file_preamble(self, status): for input_filename in status.input_filenames: assembly_filename = get_assembly_filename(input_filename) success, message = self.verify_assembly_file_preamble( os.path.join(status.directory, assembly_filename)) if not success: return False, message return True, '' class StdoutMatch(SpirvTest): """Mixin class for tests that can expect output on stdout. To mix in this class, subclasses need to provide expected_stdout as the expected stdout output. For expected_stdout, if it's True, then they expect something on stdout but will not check what it is. If it's a string, expect an exact match. If it's anything else, it is assumed to be a compiled regular expression which will be matched against re.search(). It will expect expected_stdout.search(status.stdout) to be true. """ def check_stdout_match(self, status): # "True" in this case means we expect something on stdout, but we do not # care what it is, we want to distinguish this from "blah" which means we # expect exactly the string "blah". if self.expected_stdout is True: if not status.stdout: return False, 'Expected something on stdout' elif type(self.expected_stdout) == str: if self.expected_stdout != convert_to_unix_line_endings(status.stdout): return False, ('Incorrect stdout output:\n{ac}\n' 'Expected:\n{ex}'.format( ac=status.stdout, ex=self.expected_stdout)) else: converted = convert_to_unix_line_endings(status.stdout) if not self.expected_stdout.search(converted): return False, ('Incorrect stdout output:\n{ac}\n' 'Expected to match regex:\n{ex}'.format( ac=status.stdout, ex=self.expected_stdout.pattern)) return True, '' class StderrMatch(SpirvTest): """Mixin class for tests that can expect output on stderr. To mix in this class, subclasses need to provide expected_stderr as the expected stderr output. For expected_stderr, if it's True, then they expect something on stderr, but will not check what it is. If it's a string, expect an exact match. If it's anything else, it is assumed to be a compiled regular expression which will be matched against re.search(). It will expect expected_stderr.search(status.stderr) to be true. """ def check_stderr_match(self, status): # "True" in this case means we expect something on stderr, but we do not # care what it is, we want to distinguish this from "blah" which means we # expect exactly the string "blah". if self.expected_stderr is True: if not status.stderr: return False, 'Expected something on stderr' elif type(self.expected_stderr) == str: if self.expected_stderr != convert_to_unix_line_endings(status.stderr): return False, ('Incorrect stderr output:\n{ac}\n' 'Expected:\n{ex}'.format( ac=status.stderr, ex=self.expected_stderr)) else: if not self.expected_stderr.search( convert_to_unix_line_endings(status.stderr)): return False, ('Incorrect stderr output:\n{ac}\n' 'Expected to match regex:\n{ex}'.format( ac=status.stderr, ex=self.expected_stderr.pattern)) return True, '' class StdoutNoWiderThan80Columns(SpirvTest): """Mixin class for tests that require stdout to 80 characters or narrower. To mix in this class, subclasses need to provide expected_stdout as the expected stdout output. """ def check_stdout_not_too_wide(self, status): if not status.stdout: return True, '' else: for line in status.stdout.splitlines(): if len(line) > 80: return False, ('Stdout line longer than 80 columns: %s' % line) return True, '' class NoObjectFile(SpirvTest): """Mixin class for checking that no input file has a corresponding object file.""" def check_no_object_file(self, status): for input_filename in status.input_filenames: object_filename = get_object_filename(input_filename) full_object_file = os.path.join(status.directory, object_filename) print('checking %s' % full_object_file) if os.path.isfile(full_object_file): return False, ( 'Expected no object file, but found: %s' % full_object_file) return True, '' class NoNamedOutputFiles(SpirvTest): """Mixin class for checking that no specified output files exist. The expected_output_filenames member should be full pathnames.""" def check_no_named_output_files(self, status): for object_filename in self.expected_output_filenames: if os.path.isfile(object_filename): return False, ( 'Expected no output file, but found: %s' % object_filename) return True, '' class ExecutedListOfPasses(SpirvTest): """Mixin class for checking that a list of passes where executed. It works by analyzing the output of the --print-all flag to spirv-opt. For this mixin to work, the class member expected_passes should be a sequence of pass names as returned by Pass::name(). """ def check_list_of_executed_passes(self, status): # Collect all the output lines containing a pass name. pass_names = [] pass_name_re = re.compile(r'.*IR before pass (?P[\S]+)') for line in status.stderr.splitlines(): match = pass_name_re.match(line) if match: pass_names.append(match.group('pass_name')) for (expected, actual) in zip(self.expected_passes, pass_names): if expected != actual: return False, ( 'Expected pass "%s" but found pass "%s"\n' % (expected, actual)) return True, '' KhronosGroup-SPIRV-Tools-f289d04/test/tools/expect_unittest.py000066400000000000000000000057151475742701700244610ustar00rootroot00000000000000# Copyright (c) 2019 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Tests for the expect module.""" import expect from spirv_test_framework import TestStatus import re import unittest class TestStdoutMatchADotC(expect.StdoutMatch): expected_stdout = re.compile('a.c') class TestExpect(unittest.TestCase): def test_get_object_name(self): """Tests get_object_filename().""" source_and_object_names = [('a.vert', 'a.vert.spv'), ('b.frag', 'b.frag.spv'), ('c.tesc', 'c.tesc.spv'), ('d.tese', 'd.tese.spv'), ('e.geom', 'e.geom.spv'), ('f.comp', 'f.comp.spv'), ('file', 'file.spv'), ('file.', 'file.spv'), ('file.uk', 'file.spv'), ('file.vert.', 'file.vert.spv'), ('file.vert.bla', 'file.vert.spv')] actual_object_names = [ expect.get_object_filename(f[0]) for f in source_and_object_names ] expected_object_names = [f[1] for f in source_and_object_names] self.assertEqual(actual_object_names, expected_object_names) def test_stdout_match_regex_has_match(self): test = TestStdoutMatchADotC() status = TestStatus( test_manager=None, returncode=0, stdout=b'0abc1', stderr=None, directory=None, inputs=None, input_filenames=None) self.assertTrue(test.check_stdout_match(status)[0]) def test_stdout_match_regex_no_match(self): test = TestStdoutMatchADotC() status = TestStatus( test_manager=None, returncode=0, stdout=b'ab', stderr=None, directory=None, inputs=None, input_filenames=None) self.assertFalse(test.check_stdout_match(status)[0]) def test_stdout_match_regex_empty_stdout(self): test = TestStdoutMatchADotC() status = TestStatus( test_manager=None, returncode=0, stdout=b'', stderr=None, directory=None, inputs=None, input_filenames=None) self.assertFalse(test.check_stdout_match(status)[0]) KhronosGroup-SPIRV-Tools-f289d04/test/tools/flags_test.cpp000066400000000000000000000264771475742701700235270ustar00rootroot00000000000000// Copyright (c) 2023 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "tools/util/flags.h" #include "gmock/gmock.h" #ifdef UTIL_FLAGS_FLAG #undef UTIL_FLAGS_FLAG #define UTIL_FLAGS_FLAG(Type, Prefix, Name, Default, Required, IsShort) \ flags::Flag Name(Default); \ flags::FlagRegistration Name##_registration(Name, Prefix #Name, Required, \ IsShort) #else #error \ "UTIL_FLAGS_FLAG is not defined. Either flags.h is not included of the flag name changed." #endif class FlagTest : public ::testing::Test { protected: void SetUp() override { flags::FlagList::reset(); } }; TEST_F(FlagTest, NoFlags) { const char* argv[] = {"binary", nullptr}; EXPECT_TRUE(flags::Parse(argv)); EXPECT_EQ(flags::positional_arguments.size(), 0); } TEST_F(FlagTest, DashIsPositional) { const char* argv[] = {"binary", "-", nullptr}; EXPECT_TRUE(flags::Parse(argv)); EXPECT_EQ(flags::positional_arguments.size(), 1); EXPECT_EQ(flags::positional_arguments[0], "-"); } TEST_F(FlagTest, Positional) { const char* argv[] = {"binary", "A", "BCD", nullptr}; EXPECT_TRUE(flags::Parse(argv)); EXPECT_EQ(flags::positional_arguments.size(), 2); EXPECT_EQ(flags::positional_arguments[0], "A"); EXPECT_EQ(flags::positional_arguments[1], "BCD"); } TEST_F(FlagTest, MissingRequired) { FLAG_SHORT_bool(g, false, true); const char* argv[] = {"binary", nullptr}; EXPECT_FALSE(flags::Parse(argv)); EXPECT_EQ(flags::positional_arguments.size(), 0); } TEST_F(FlagTest, BooleanShortValue) { FLAG_SHORT_bool(g, false, false); const char* argv[] = {"binary", "-g", nullptr}; EXPECT_FALSE(g.value()); EXPECT_TRUE(flags::Parse(argv)); EXPECT_TRUE(g.value()); EXPECT_EQ(flags::positional_arguments.size(), 0); } TEST_F(FlagTest, BooleanShortDefaultValue) { FLAG_SHORT_bool(g, true, false); const char* argv[] = {"binary", nullptr}; EXPECT_TRUE(g.value()); EXPECT_TRUE(flags::Parse(argv)); EXPECT_TRUE(g.value()); } TEST_F(FlagTest, BooleanLongValueNotParsed) { FLAG_SHORT_bool(g, false, false); const char* argv[] = {"binary", "-g", "false", nullptr}; EXPECT_FALSE(g.value()); EXPECT_TRUE(flags::Parse(argv)); EXPECT_TRUE(g.value()); EXPECT_EQ(flags::positional_arguments.size(), 1); EXPECT_EQ(flags::positional_arguments[0], "false"); } TEST_F(FlagTest, BooleanLongSplitNotParsed) { FLAG_LONG_bool(foo, false, false); const char* argv[] = {"binary", "--foo", "true", nullptr}; EXPECT_FALSE(foo.value()); EXPECT_TRUE(flags::Parse(argv)); EXPECT_TRUE(foo.value()); EXPECT_EQ(flags::positional_arguments.size(), 1); EXPECT_EQ(flags::positional_arguments[0], "true"); } TEST_F(FlagTest, BooleanLongExplicitTrue) { FLAG_LONG_bool(foo, false, false); const char* argv[] = {"binary", "--foo=true", nullptr}; EXPECT_FALSE(foo.value()); EXPECT_TRUE(flags::Parse(argv)); EXPECT_TRUE(foo.value()); EXPECT_EQ(flags::positional_arguments.size(), 0); } TEST_F(FlagTest, BooleanLongExplicitFalse) { FLAG_LONG_bool(foo, false, false); const char* argv[] = {"binary", "--foo=false", nullptr}; EXPECT_FALSE(foo.value()); EXPECT_TRUE(flags::Parse(argv)); EXPECT_FALSE(foo.value()); EXPECT_EQ(flags::positional_arguments.size(), 0); } TEST_F(FlagTest, BooleanLongDefaultValue) { FLAG_LONG_bool(foo, true, false); const char* argv[] = {"binary", nullptr}; EXPECT_TRUE(foo.value()); EXPECT_TRUE(flags::Parse(argv)); EXPECT_TRUE(foo.value()); EXPECT_EQ(flags::positional_arguments.size(), 0); } TEST_F(FlagTest, BooleanLongDefaultValueCancelled) { FLAG_LONG_bool(foo, true, false); const char* argv[] = {"binary", "--foo=false", nullptr}; EXPECT_TRUE(foo.value()); EXPECT_TRUE(flags::Parse(argv)); EXPECT_FALSE(foo.value()); EXPECT_EQ(flags::positional_arguments.size(), 0); } TEST_F(FlagTest, StringFlagDefaultValue) { FLAG_SHORT_string(f, "default", false); const char* argv[] = {"binary", nullptr}; EXPECT_EQ(f.value(), "default"); EXPECT_TRUE(flags::Parse(argv)); EXPECT_EQ(f.value(), "default"); EXPECT_EQ(flags::positional_arguments.size(), 0); } TEST_F(FlagTest, StringFlagShortMissingString) { FLAG_SHORT_string(f, "default", false); const char* argv[] = {"binary", "-f", nullptr}; EXPECT_EQ(f.value(), "default"); EXPECT_FALSE(flags::Parse(argv)); } TEST_F(FlagTest, StringFlagDefault) { FLAG_SHORT_string(f, "default", false); const char* argv[] = {"binary", nullptr}; EXPECT_EQ(f.value(), "default"); EXPECT_TRUE(flags::Parse(argv)); EXPECT_EQ(f.value(), "default"); EXPECT_EQ(flags::positional_arguments.size(), 0); } TEST_F(FlagTest, StringFlagSet) { FLAG_SHORT_string(f, "default", false); const char* argv[] = {"binary", "-f", "toto", nullptr}; EXPECT_EQ(f.value(), "default"); EXPECT_TRUE(flags::Parse(argv)); EXPECT_EQ(f.value(), "toto"); EXPECT_EQ(flags::positional_arguments.size(), 0); } TEST_F(FlagTest, StringLongFlagSetSplit) { FLAG_LONG_string(foo, "default", false); const char* argv[] = {"binary", "--foo", "toto", nullptr}; EXPECT_EQ(foo.value(), "default"); EXPECT_TRUE(flags::Parse(argv)); EXPECT_EQ(foo.value(), "toto"); EXPECT_EQ(flags::positional_arguments.size(), 0); } TEST_F(FlagTest, StringLongFlagSetUnified) { FLAG_LONG_string(foo, "default", false); const char* argv[] = {"binary", "--foo=toto", nullptr}; EXPECT_EQ(foo.value(), "default"); EXPECT_TRUE(flags::Parse(argv)); EXPECT_EQ(foo.value(), "toto"); EXPECT_EQ(flags::positional_arguments.size(), 0); } TEST_F(FlagTest, StringLongFlagSetEmpty) { FLAG_LONG_string(foo, "default", false); const char* argv[] = {"binary", "--foo=", nullptr}; EXPECT_EQ(foo.value(), "default"); EXPECT_TRUE(flags::Parse(argv)); EXPECT_EQ(foo.value(), ""); EXPECT_EQ(flags::positional_arguments.size(), 0); } TEST_F(FlagTest, AllPositionalAfterDoubleDash) { FLAG_LONG_string(foo, "default", false); const char* argv[] = {"binary", "--", "--foo=toto", nullptr}; EXPECT_EQ(foo.value(), "default"); EXPECT_TRUE(flags::Parse(argv)); EXPECT_EQ(foo.value(), "default"); EXPECT_EQ(flags::positional_arguments.size(), 1); EXPECT_EQ(flags::positional_arguments[0], "--foo=toto"); } TEST_F(FlagTest, NothingAfterDoubleDash) { FLAG_LONG_string(foo, "default", false); const char* argv[] = {"binary", "--", nullptr}; EXPECT_EQ(foo.value(), "default"); EXPECT_TRUE(flags::Parse(argv)); EXPECT_EQ(foo.value(), "default"); EXPECT_EQ(flags::positional_arguments.size(), 0); } TEST_F(FlagTest, FlagDoubleSetNotAllowed) { FLAG_LONG_string(foo, "default", false); const char* argv[] = {"binary", "--foo=abc", "--foo=def", nullptr}; EXPECT_EQ(foo.value(), "default"); EXPECT_FALSE(flags::Parse(argv)); } TEST_F(FlagTest, MultipleFlags) { FLAG_LONG_string(foo, "default foo", false); FLAG_LONG_string(bar, "default_bar", false); const char* argv[] = {"binary", "--foo", "abc", "--bar=def", nullptr}; EXPECT_EQ(foo.value(), "default foo"); EXPECT_EQ(bar.value(), "default_bar"); EXPECT_TRUE(flags::Parse(argv)); EXPECT_EQ(foo.value(), "abc"); EXPECT_EQ(bar.value(), "def"); } TEST_F(FlagTest, MixedStringAndBool) { FLAG_LONG_string(foo, "default foo", false); FLAG_LONG_string(bar, "default_bar", false); FLAG_SHORT_bool(g, false, false); const char* argv[] = {"binary", "--foo", "abc", "-g", "--bar=def", nullptr}; EXPECT_EQ(foo.value(), "default foo"); EXPECT_EQ(bar.value(), "default_bar"); EXPECT_FALSE(g.value()); EXPECT_TRUE(flags::Parse(argv)); EXPECT_EQ(foo.value(), "abc"); EXPECT_EQ(bar.value(), "def"); EXPECT_TRUE(g.value()); } TEST_F(FlagTest, UintFlagDefaultValue) { FLAG_SHORT_uint(f, 18, false); const char* argv[] = {"binary", nullptr}; EXPECT_EQ(f.value(), 18); EXPECT_TRUE(flags::Parse(argv)); EXPECT_EQ(f.value(), 18); EXPECT_EQ(flags::positional_arguments.size(), 0); } TEST_F(FlagTest, UintFlagShortMissingValue) { FLAG_SHORT_uint(f, 19, false); const char* argv[] = {"binary", "-f", nullptr}; EXPECT_EQ(f.value(), 19); EXPECT_FALSE(flags::Parse(argv)); } TEST_F(FlagTest, UintFlagSet) { FLAG_SHORT_uint(f, 20, false); const char* argv[] = {"binary", "-f", "21", nullptr}; EXPECT_EQ(f.value(), 20); EXPECT_TRUE(flags::Parse(argv)); EXPECT_EQ(f.value(), 21); EXPECT_EQ(flags::positional_arguments.size(), 0); } TEST_F(FlagTest, UintLongFlagSetSplit) { FLAG_LONG_uint(foo, 22, false); const char* argv[] = {"binary", "--foo", "23", nullptr}; EXPECT_EQ(foo.value(), 22); EXPECT_TRUE(flags::Parse(argv)); EXPECT_EQ(foo.value(), 23); EXPECT_EQ(flags::positional_arguments.size(), 0); } TEST_F(FlagTest, UintLongFlagSetUnified) { FLAG_LONG_uint(foo, 24, false); const char* argv[] = {"binary", "--foo=25", nullptr}; EXPECT_EQ(foo.value(), 24); EXPECT_TRUE(flags::Parse(argv)); EXPECT_EQ(foo.value(), 25); EXPECT_EQ(flags::positional_arguments.size(), 0); } TEST_F(FlagTest, UintLongFlagSetEmptyIsWrong) { FLAG_LONG_uint(foo, 26, false); const char* argv[] = {"binary", "--foo=", nullptr}; EXPECT_EQ(foo.value(), 26); EXPECT_FALSE(flags::Parse(argv)); } TEST_F(FlagTest, UintLongFlagSetNegativeFails) { FLAG_LONG_uint(foo, 26, false); const char* argv[] = {"binary", "--foo=-2", nullptr}; EXPECT_EQ(foo.value(), 26); EXPECT_FALSE(flags::Parse(argv)); } TEST_F(FlagTest, UintLongFlagSetOverflowFails) { FLAG_LONG_uint(foo, 27, false); const char* argv[] = { "binary", "--foo=99999999999999999999999999999999999999999999999999999", nullptr}; EXPECT_EQ(foo.value(), 27); EXPECT_FALSE(flags::Parse(argv)); } TEST_F(FlagTest, UintLongFlagSetInvalidCharTrailing) { FLAG_LONG_uint(foo, 28, false); const char* argv[] = {"binary", "--foo=12A", nullptr}; EXPECT_EQ(foo.value(), 28); EXPECT_FALSE(flags::Parse(argv)); } TEST_F(FlagTest, UintLongFlagSetSpaces) { FLAG_LONG_uint(foo, 29, false); const char* argv[] = {"binary", "--foo= 12", nullptr}; EXPECT_EQ(foo.value(), 29); EXPECT_TRUE(flags::Parse(argv)); EXPECT_EQ(foo.value(), 12); EXPECT_EQ(flags::positional_arguments.size(), 0); } TEST_F(FlagTest, UintLongFlagSpacesOnly) { FLAG_LONG_uint(foo, 30, false); const char* argv[] = {"binary", "--foo= ", nullptr}; EXPECT_EQ(foo.value(), 30); EXPECT_FALSE(flags::Parse(argv)); } TEST_F(FlagTest, UintLongFlagSplitNumber) { FLAG_LONG_uint(foo, 31, false); const char* argv[] = {"binary", "--foo= 2 2", nullptr}; EXPECT_EQ(foo.value(), 31); EXPECT_FALSE(flags::Parse(argv)); } TEST_F(FlagTest, UintLongFlagHex) { FLAG_LONG_uint(foo, 32, false); const char* argv[] = {"binary", "--foo=0xA", nullptr}; EXPECT_EQ(foo.value(), 32); EXPECT_FALSE(flags::Parse(argv)); } TEST_F(FlagTest, UintLongFlagZeros) { FLAG_LONG_uint(foo, 33, false); const char* argv[] = {"binary", "--foo=0000", nullptr}; EXPECT_EQ(foo.value(), 33); EXPECT_TRUE(flags::Parse(argv)); EXPECT_EQ(foo.value(), 0); EXPECT_EQ(flags::positional_arguments.size(), 0); } KhronosGroup-SPIRV-Tools-f289d04/test/tools/objdump/000077500000000000000000000000001475742701700223105ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/tools/objdump/CMakeLists.txt000066400000000000000000000016361475742701700250560ustar00rootroot00000000000000# Copyright (c) 2023 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. add_spvtools_unittest( TARGET spirv_unit_test_tools_objdump SRCS extract_source_test.cpp ${spirv-tools_SOURCE_DIR}/tools/util/flags.cpp ${spirv-tools_SOURCE_DIR}/tools/util/cli_consumer.cpp ${spirv-tools_SOURCE_DIR}/tools/objdump/extract_source.cpp LIBS ${SPIRV_TOOLS_FULL_VISIBILITY} SPIRV-Tools-opt DEFINES TESTING=1) KhronosGroup-SPIRV-Tools-f289d04/test/tools/objdump/extract_source_test.cpp000066400000000000000000000174201475742701700271110ustar00rootroot00000000000000// Copyright (c) 2023 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "tools/objdump/extract_source.h" #include #include #include "source/opt/build_module.h" #include "source/opt/ir_context.h" #include "spirv-tools/libspirv.hpp" #include "tools/util/cli_consumer.h" namespace { constexpr auto kDefaultEnvironment = SPV_ENV_UNIVERSAL_1_6; std::pair> ExtractSource( const std::string& spv_source) { std::unique_ptr ctx = spvtools::BuildModule( kDefaultEnvironment, spvtools::utils::CLIMessageConsumer, spv_source, spvtools::SpirvTools::kDefaultAssembleOption | SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); std::vector binary; ctx->module()->ToBinary(&binary, /* skip_nop = */ false); std::unordered_map output; bool result = ExtractSourceFromModule(binary, &output); return std::make_pair(result, std::move(output)); } } // namespace TEST(ExtractSourceTest, no_debug) { std::string source = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %2 = OpTypeFunction %void %bool = OpTypeBool %4 = OpUndef %bool %5 = OpFunction %void None %2 %6 = OpLabel OpReturn OpFunctionEnd )"; auto[success, result] = ExtractSource(source); ASSERT_TRUE(success); ASSERT_TRUE(result.size() == 0); } TEST(ExtractSourceTest, SimpleSource) { std::string source = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "compute_1" OpExecutionMode %1 LocalSize 1 1 1 %2 = OpString "compute.hlsl" OpSource HLSL 660 %2 "[numthreads(1, 1, 1)] void compute_1(){ }" OpName %1 "compute_1" %3 = OpTypeVoid %4 = OpTypeFunction %3 %1 = OpFunction %3 None %4 %5 = OpLabel OpLine %2 1 41 OpReturn OpFunctionEnd )"; auto[success, result] = ExtractSource(source); ASSERT_TRUE(success); ASSERT_TRUE(result.size() == 1); ASSERT_TRUE(result["compute.hlsl"] == "[numthreads(1, 1, 1)] void compute_1(){ }"); } TEST(ExtractSourceTest, SourceContinued) { std::string source = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "compute_1" OpExecutionMode %1 LocalSize 1 1 1 %2 = OpString "compute.hlsl" OpSource HLSL 660 %2 "[numthreads(1, 1, 1)] " OpSourceContinued "void compute_1(){ }" OpName %1 "compute_1" %3 = OpTypeVoid %4 = OpTypeFunction %3 %1 = OpFunction %3 None %4 %5 = OpLabel OpLine %2 1 41 OpReturn OpFunctionEnd )"; auto[success, result] = ExtractSource(source); ASSERT_TRUE(success); ASSERT_TRUE(result.size() == 1); ASSERT_TRUE(result["compute.hlsl"] == "[numthreads(1, 1, 1)] void compute_1(){ }"); } TEST(ExtractSourceTest, OnlyFilename) { std::string source = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "compute_1" OpExecutionMode %1 LocalSize 1 1 1 %2 = OpString "compute.hlsl" OpSource HLSL 660 %2 OpName %1 "compute_1" %3 = OpTypeVoid %4 = OpTypeFunction %3 %1 = OpFunction %3 None %4 %5 = OpLabel OpLine %2 1 41 OpReturn OpFunctionEnd )"; auto[success, result] = ExtractSource(source); ASSERT_TRUE(success); ASSERT_TRUE(result.size() == 1); ASSERT_TRUE(result["compute.hlsl"] == ""); } TEST(ExtractSourceTest, MultipleFiles) { std::string source = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "compute_1" OpExecutionMode %1 LocalSize 1 1 1 %2 = OpString "compute1.hlsl" %3 = OpString "compute2.hlsl" OpSource HLSL 660 %2 "some instruction" OpSource HLSL 660 %3 "some other instruction" OpName %1 "compute_1" %4 = OpTypeVoid %5 = OpTypeFunction %4 %1 = OpFunction %4 None %5 %6 = OpLabel OpLine %2 1 41 OpReturn OpFunctionEnd )"; auto[success, result] = ExtractSource(source); ASSERT_TRUE(success); ASSERT_TRUE(result.size() == 2); ASSERT_TRUE(result["compute1.hlsl"] == "some instruction"); ASSERT_TRUE(result["compute2.hlsl"] == "some other instruction"); } TEST(ExtractSourceTest, MultilineCode) { std::string source = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "compute_1" OpExecutionMode %1 LocalSize 1 1 1 %2 = OpString "compute.hlsl" OpSource HLSL 660 %2 "[numthreads(1, 1, 1)] void compute_1() { } " OpName %1 "compute_1" %3 = OpTypeVoid %4 = OpTypeFunction %3 %1 = OpFunction %3 None %4 %5 = OpLabel OpLine %2 3 1 OpReturn OpFunctionEnd )"; auto[success, result] = ExtractSource(source); ASSERT_TRUE(success); ASSERT_TRUE(result.size() == 1); ASSERT_TRUE(result["compute.hlsl"] == "[numthreads(1, 1, 1)]\nvoid compute_1() {\n}\n"); } TEST(ExtractSourceTest, EmptyFilename) { std::string source = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "compute_1" OpExecutionMode %1 LocalSize 1 1 1 %2 = OpString "" OpSource HLSL 660 %2 "void compute(){}" OpName %1 "compute_1" %3 = OpTypeVoid %4 = OpTypeFunction %3 %1 = OpFunction %3 None %4 %5 = OpLabel OpLine %2 3 1 OpReturn OpFunctionEnd )"; auto[success, result] = ExtractSource(source); ASSERT_TRUE(success); ASSERT_TRUE(result.size() == 1); ASSERT_TRUE(result["unnamed-0.hlsl"] == "void compute(){}"); } TEST(ExtractSourceTest, EscapeEscaped) { std::string source = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "compute" OpExecutionMode %1 LocalSize 1 1 1 %2 = OpString "compute.hlsl" OpSource HLSL 660 %2 "// check \" escape removed" OpName %1 "compute" %3 = OpTypeVoid %4 = OpTypeFunction %3 %1 = OpFunction %3 None %4 %5 = OpLabel OpLine %2 6 1 OpReturn OpFunctionEnd )"; auto[success, result] = ExtractSource(source); ASSERT_TRUE(success); ASSERT_TRUE(result.size() == 1); ASSERT_TRUE(result["compute.hlsl"] == "// check \" escape removed"); } TEST(ExtractSourceTest, OpSourceWithNoSource) { std::string source = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "compute" OpExecutionMode %1 LocalSize 1 1 1 %2 = OpString "compute.hlsl" OpSource HLSL 660 %2 OpName %1 "compute" %3 = OpTypeVoid %4 = OpTypeFunction %3 %1 = OpFunction %3 None %4 %5 = OpLabel OpLine %2 6 1 OpReturn OpFunctionEnd )"; auto[success, result] = ExtractSource(source); ASSERT_TRUE(success); ASSERT_TRUE(result.size() == 1); ASSERT_TRUE(result["compute.hlsl"] == ""); } KhronosGroup-SPIRV-Tools-f289d04/test/tools/opt/000077500000000000000000000000001475742701700214525ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/tools/opt/CMakeLists.txt000066400000000000000000000017561475742701700242230ustar00rootroot00000000000000# Copyright (c) 2018 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. if(NOT ${SPIRV_SKIP_TESTS}) if(${Python3_Interpreter_FOUND}) add_test(NAME spirv_opt_cli_tools_tests COMMAND Python3::Interpreter ${CMAKE_CURRENT_SOURCE_DIR}/../spirv_test_framework.py $ $ $ --test-dir ${CMAKE_CURRENT_SOURCE_DIR}) else() message("Skipping CLI tools tests - Python executable not found") endif() endif() KhronosGroup-SPIRV-Tools-f289d04/test/tools/opt/flags.py000066400000000000000000000276761475742701700231420ustar00rootroot00000000000000# Copyright (c) 2018 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import placeholder import expect import re from spirv_test_framework import inside_spirv_testsuite def empty_main_assembly(): return """ OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %4 "main" OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd""" @inside_spirv_testsuite('SpirvOptBase') class TestAssemblyFileAsOnlyParameter(expect.ValidObjectFile1_6): """Tests that spirv-opt accepts a SPIR-V object file.""" shader = placeholder.FileSPIRVShader(empty_main_assembly(), '.spvasm') output = placeholder.TempFileName('output.spv') spirv_args = [shader, '-o', output] expected_object_filenames = (output) @inside_spirv_testsuite('SpirvOptFlags') class TestHelpFlag(expect.ReturnCodeIsZero, expect.StdoutMatch): """Test the --help flag.""" spirv_args = ['--help'] expected_stdout = re.compile(r'.*The SPIR-V binary is read from ') @inside_spirv_testsuite('SpirvOptFlags') class TestValidPassFlags(expect.ValidObjectFile1_6, expect.ExecutedListOfPasses): """Tests that spirv-opt accepts all valid optimization flags.""" flags = [ '--wrap-opkill', '--ccp', '--cfg-cleanup', '--combine-access-chains', '--compact-ids', '--convert-local-access-chains', '--copy-propagate-arrays', '--eliminate-dead-branches', '--eliminate-dead-code-aggressive', '--eliminate-dead-const', '--eliminate-dead-functions', '--eliminate-dead-inserts', '--eliminate-dead-variables', '--eliminate-insert-extract', '--eliminate-local-multi-store', '--eliminate-local-single-block', '--eliminate-local-single-store', '--flatten-decorations', '--fold-spec-const-op-composite', '--freeze-spec-const', '--if-conversion', '--inline-entry-points-exhaustive', '--loop-fission', '20', '--loop-fusion', '5', '--loop-unroll', '--loop-unroll-partial', '3', '--loop-peeling', '--merge-blocks', '--merge-return', '--loop-unswitch', '--private-to-local', '--reduce-load-size', '--redundancy-elimination', '--remove-duplicates', '--replace-invalid-opcode', '--ssa-rewrite', '--scalar-replacement', '--scalar-replacement=42', '--strength-reduction', '--strip-debug', '--strip-nonsemantic', '--vector-dce', '--workaround-1209', '--unify-const', '--graphics-robust-access', '--wrap-opkill', '--amd-ext-to-khr' ] expected_passes = [ 'wrap-opkill', 'ccp', 'cfg-cleanup', 'combine-access-chains', 'compact-ids', 'convert-local-access-chains', 'copy-propagate-arrays', 'eliminate-dead-branches', 'eliminate-dead-code-aggressive', 'eliminate-dead-const', 'eliminate-dead-functions', 'eliminate-dead-inserts', 'eliminate-dead-variables', # --eliminate-insert-extract runs the simplify-instructions pass. 'simplify-instructions', 'ssa-rewrite', 'eliminate-local-single-block', 'eliminate-local-single-store', 'flatten-decorations', 'fold-spec-const-op-composite', 'freeze-spec-const', 'if-conversion', 'inline-entry-points-exhaustive', 'loop-fission', 'loop-fusion', 'loop-unroll', 'loop-unroll', 'loop-peeling', 'merge-blocks', 'merge-return', 'loop-unswitch', 'private-to-local', 'reduce-load-size', 'redundancy-elimination', 'remove-duplicates', 'replace-invalid-opcode', 'ssa-rewrite', 'scalar-replacement=100', 'scalar-replacement=42', 'strength-reduction', 'strip-debug', 'strip-nonsemantic', 'vector-dce', 'workaround-1209', 'unify-const', 'graphics-robust-access', 'wrap-opkill', 'amd-ext-to-khr' ] shader = placeholder.FileSPIRVShader(empty_main_assembly(), '.spvasm') output = placeholder.TempFileName('output.spv') spirv_args = [shader, '-o', output, '--print-all'] + flags expected_object_filenames = (output) @inside_spirv_testsuite('SpirvOptFlags') class TestPerformanceOptimizationPasses(expect.ValidObjectFile1_6, expect.ExecutedListOfPasses): """Tests that spirv-opt schedules all the passes triggered by -O.""" flags = ['-O'] expected_passes = [ 'wrap-opkill', 'eliminate-dead-branches', 'merge-return', 'inline-entry-points-exhaustive', 'eliminate-dead-functions', 'eliminate-dead-code-aggressive', 'private-to-local', 'eliminate-local-single-block', 'eliminate-local-single-store', 'eliminate-dead-code-aggressive', 'scalar-replacement=100', 'convert-local-access-chains', 'eliminate-local-single-block', 'eliminate-local-single-store', 'eliminate-dead-code-aggressive', 'ssa-rewrite', 'eliminate-dead-code-aggressive', 'ccp', 'eliminate-dead-code-aggressive', 'loop-unroll', 'eliminate-dead-branches', 'redundancy-elimination', 'combine-access-chains', 'simplify-instructions', 'scalar-replacement=100', 'convert-local-access-chains', 'eliminate-local-single-block', 'eliminate-local-single-store', 'eliminate-dead-code-aggressive', 'ssa-rewrite', 'eliminate-dead-code-aggressive', 'vector-dce', 'eliminate-dead-inserts', 'eliminate-dead-branches', 'simplify-instructions', 'if-conversion', 'copy-propagate-arrays', 'reduce-load-size', 'eliminate-dead-code-aggressive', 'merge-blocks', 'redundancy-elimination', 'eliminate-dead-branches', 'merge-blocks', 'simplify-instructions', ] shader = placeholder.FileSPIRVShader(empty_main_assembly(), '.spvasm') output = placeholder.TempFileName('output.spv') spirv_args = [shader, '-o', output, '--print-all'] + flags expected_object_filenames = (output) @inside_spirv_testsuite('SpirvOptFlags') class TestSizeOptimizationPasses(expect.ValidObjectFile1_6, expect.ExecutedListOfPasses): """Tests that spirv-opt schedules all the passes triggered by -Os.""" flags = ['-Os'] expected_passes = [ 'wrap-opkill', 'eliminate-dead-branches', 'merge-return', 'inline-entry-points-exhaustive', 'eliminate-dead-functions', 'private-to-local', 'scalar-replacement=0', 'ssa-rewrite', 'ccp', 'loop-unroll', 'eliminate-dead-branches', 'simplify-instructions', 'scalar-replacement=0', 'eliminate-local-single-store', 'if-conversion', 'simplify-instructions', 'eliminate-dead-code-aggressive', 'eliminate-dead-branches', 'merge-blocks', 'convert-local-access-chains', 'eliminate-local-single-block', 'eliminate-dead-code-aggressive', 'copy-propagate-arrays', 'vector-dce', 'eliminate-dead-inserts', 'eliminate-dead-members', 'eliminate-local-single-store', 'merge-blocks', 'ssa-rewrite', 'redundancy-elimination', 'simplify-instructions', 'eliminate-dead-code-aggressive', 'cfg-cleanup', ] shader = placeholder.FileSPIRVShader(empty_main_assembly(), '.spvasm') output = placeholder.TempFileName('output.spv') spirv_args = [shader, '-o', output, '--print-all'] + flags expected_object_filenames = (output) @inside_spirv_testsuite('SpirvOptFlags') class TestLegalizationPasses(expect.ValidObjectFile1_6, expect.ExecutedListOfPasses): """Tests that spirv-opt schedules all the passes triggered by --legalize-hlsl. """ flags = ['--legalize-hlsl'] expected_passes = [ 'wrap-opkill', 'eliminate-dead-branches', 'merge-return', 'inline-entry-points-exhaustive', 'eliminate-dead-functions', 'private-to-local', 'fix-storage-class', 'eliminate-local-single-block', 'eliminate-local-single-store', 'eliminate-dead-code-aggressive', 'scalar-replacement=0', 'eliminate-local-single-block', 'eliminate-local-single-store', 'eliminate-dead-code-aggressive', 'ssa-rewrite', 'eliminate-dead-code-aggressive', 'ccp', 'loop-unroll', 'eliminate-dead-branches', 'simplify-instructions', 'eliminate-dead-code-aggressive', 'copy-propagate-arrays', 'vector-dce', 'eliminate-dead-inserts', 'reduce-load-size', 'eliminate-dead-code-aggressive', ] shader = placeholder.FileSPIRVShader(empty_main_assembly(), '.spvasm') output = placeholder.TempFileName('output.spv') spirv_args = [shader, '-o', output, '--print-all'] + flags expected_object_filenames = (output) @inside_spirv_testsuite('SpirvOptFlags') class TestScalarReplacementArgsNegative(expect.ErrorMessageSubstr): """Tests invalid arguments to --scalar-replacement.""" spirv_args = ['--scalar-replacement=-10'] expected_error_substr = 'must have no arguments or a non-negative integer argument' @inside_spirv_testsuite('SpirvOptFlags') class TestScalarReplacementArgsInvalidNumber(expect.ErrorMessageSubstr): """Tests invalid arguments to --scalar-replacement.""" spirv_args = ['--scalar-replacement=a10f'] expected_error_substr = 'must have no arguments or a non-negative integer argument' @inside_spirv_testsuite('SpirvOptFlags') class TestLoopFissionArgsNegative(expect.ErrorMessageSubstr): """Tests invalid arguments to --loop-fission.""" spirv_args = ['--loop-fission=-10'] expected_error_substr = 'must have a positive integer argument' @inside_spirv_testsuite('SpirvOptFlags') class TestLoopFissionArgsInvalidNumber(expect.ErrorMessageSubstr): """Tests invalid arguments to --loop-fission.""" spirv_args = ['--loop-fission=a10f'] expected_error_substr = 'must have a positive integer argument' @inside_spirv_testsuite('SpirvOptFlags') class TestLoopFusionArgsNegative(expect.ErrorMessageSubstr): """Tests invalid arguments to --loop-fusion.""" spirv_args = ['--loop-fusion=-10'] expected_error_substr = 'must have a positive integer argument' @inside_spirv_testsuite('SpirvOptFlags') class TestLoopFusionArgsInvalidNumber(expect.ErrorMessageSubstr): """Tests invalid arguments to --loop-fusion.""" spirv_args = ['--loop-fusion=a10f'] expected_error_substr = 'must have a positive integer argument' @inside_spirv_testsuite('SpirvOptFlags') class TestLoopUnrollPartialArgsNegative(expect.ErrorMessageSubstr): """Tests invalid arguments to --loop-unroll-partial.""" spirv_args = ['--loop-unroll-partial=-10'] expected_error_substr = 'must have a positive integer argument' @inside_spirv_testsuite('SpirvOptFlags') class TestLoopUnrollPartialArgsInvalidNumber(expect.ErrorMessageSubstr): """Tests invalid arguments to --loop-unroll-partial.""" spirv_args = ['--loop-unroll-partial=a10f'] expected_error_substr = 'must have a positive integer argument' @inside_spirv_testsuite('SpirvOptFlags') class TestLoopPeelingThresholdArgsNegative(expect.ErrorMessageSubstr): """Tests invalid arguments to --loop-peeling-threshold.""" spirv_args = ['--loop-peeling-threshold=-10'] expected_error_substr = 'must have a positive integer argument' @inside_spirv_testsuite('SpirvOptFlags') class TestLoopPeelingThresholdArgsInvalidNumber(expect.ErrorMessageSubstr): """Tests invalid arguments to --loop-peeling-threshold.""" spirv_args = ['--loop-peeling-threshold=a10f'] expected_error_substr = 'must have a positive integer argument' KhronosGroup-SPIRV-Tools-f289d04/test/tools/opt/oconfig.py000066400000000000000000000043201475742701700234470ustar00rootroot00000000000000# Copyright (c) 2018 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import placeholder import expect import re from spirv_test_framework import inside_spirv_testsuite def empty_main_assembly(): return """ OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %4 "main" OpName %4 "main" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd""" @inside_spirv_testsuite('SpirvOptConfigFile') class TestOconfigEmpty(expect.SuccessfulReturn): """Tests empty config files are accepted.""" shader = placeholder.FileSPIRVShader(empty_main_assembly(), '.spvasm') config = placeholder.ConfigFlagsFile('', '.cfg') spirv_args = [shader, '-o', placeholder.TempFileName('output.spv'), config] @inside_spirv_testsuite('SpirvOptConfigFile') class TestOconfigComments(expect.SuccessfulReturn): """Tests empty config files are accepted. https://github.com/KhronosGroup/SPIRV-Tools/issues/1778 """ shader = placeholder.FileSPIRVShader(empty_main_assembly(), '.spvasm') config = placeholder.ConfigFlagsFile(""" # This is a comment. -O --loop-unroll """, '.cfg') spirv_args = [shader, '-o', placeholder.TempFileName('output.spv'), config] @inside_spirv_testsuite('SpirvOptConfigFile') class TestOconfigComments(expect.SuccessfulReturn): """Tests empty config files are accepted. https://github.com/KhronosGroup/SPIRV-Tools/issues/1778 """ shader = placeholder.FileSPIRVShader(empty_main_assembly(), '.spvasm') config = placeholder.ConfigFlagsFile(""" # This is a comment. -O --relax-struct-store """, '.cfg') spirv_args = [shader, '-o', placeholder.TempFileName('output.spv'), config] KhronosGroup-SPIRV-Tools-f289d04/test/tools/placeholder.py000077500000000000000000000153051475742701700235130ustar00rootroot00000000000000# Copyright (c) 2018 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """A number of placeholders and their rules for expansion when used in tests. These placeholders, when used in spirv_args or expected_* variables of SpirvTest, have special meanings. In spirv_args, they will be substituted by the result of instantiate_for_spirv_args(), while in expected_*, by instantiate_for_expectation(). A TestCase instance will be passed in as argument to the instantiate_*() methods. """ import os import subprocess import tempfile from string import Template class PlaceHolderException(Exception): """Exception class for PlaceHolder.""" pass class PlaceHolder(object): """Base class for placeholders.""" def instantiate_for_spirv_args(self, testcase): """Instantiation rules for spirv_args. This method will be called when the current placeholder appears in spirv_args. Returns: A string to replace the current placeholder in spirv_args. """ raise PlaceHolderException('Subclass should implement this function.') def instantiate_for_expectation(self, testcase): """Instantiation rules for expected_*. This method will be called when the current placeholder appears in expected_*. Returns: A string to replace the current placeholder in expected_*. """ raise PlaceHolderException('Subclass should implement this function.') class FileShader(PlaceHolder): """Stands for a shader whose source code is in a file.""" def __init__(self, source, suffix, assembly_substr=None): assert isinstance(source, str) assert isinstance(suffix, str) self.source = source self.suffix = suffix self.filename = None # If provided, this is a substring which is expected to be in # the disassembly of the module generated from this input file. self.assembly_substr = assembly_substr def instantiate_for_spirv_args(self, testcase): """Creates a temporary file and writes the source into it. Returns: The name of the temporary file. """ shader, self.filename = tempfile.mkstemp( dir=testcase.directory, suffix=self.suffix) shader_object = os.fdopen(shader, 'w') shader_object.write(self.source) shader_object.close() return self.filename def instantiate_for_expectation(self, testcase): assert self.filename is not None return self.filename class ConfigFlagsFile(PlaceHolder): """Stands for a configuration file for spirv-opt generated out of a string.""" def __init__(self, content, suffix): assert isinstance(content, str) assert isinstance(suffix, str) self.content = content self.suffix = suffix self.filename = None def instantiate_for_spirv_args(self, testcase): """Creates a temporary file and writes content into it. Returns: The name of the temporary file. """ temp_fd, self.filename = tempfile.mkstemp( dir=testcase.directory, suffix=self.suffix) fd = os.fdopen(temp_fd, 'w') fd.write(self.content) fd.close() return '-Oconfig=%s' % self.filename def instantiate_for_expectation(self, testcase): assert self.filename is not None return self.filename class FileSPIRVShader(PlaceHolder): """Stands for a source shader file which must be converted to SPIR-V.""" def __init__(self, source, suffix, assembly_substr=None): assert isinstance(source, str) assert isinstance(suffix, str) self.source = source self.suffix = suffix self.filename = None # If provided, this is a substring which is expected to be in # the disassembly of the module generated from this input file. self.assembly_substr = assembly_substr def instantiate_for_spirv_args(self, testcase): """Creates a temporary file, writes the source into it and assembles it. Returns: The name of the assembled temporary file. """ shader, asm_filename = tempfile.mkstemp( dir=testcase.directory, suffix=self.suffix) shader_object = os.fdopen(shader, 'w') shader_object.write(self.source) shader_object.close() self.filename = '%s.spv' % asm_filename cmd = [ testcase.test_manager.assembler_path, asm_filename, '-o', self.filename ] process = subprocess.Popen( args=cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=testcase.directory) output = process.communicate() assert process.returncode == 0 and not output[0] and not output[1] return self.filename def instantiate_for_expectation(self, testcase): assert self.filename is not None return self.filename class StdinShader(PlaceHolder): """Stands for a shader whose source code is from stdin.""" def __init__(self, source): assert isinstance(source, str) self.source = source self.filename = None def instantiate_for_spirv_args(self, testcase): """Writes the source code back to the TestCase instance.""" testcase.stdin_shader = self.source self.filename = '-' return self.filename def instantiate_for_expectation(self, testcase): assert self.filename is not None return self.filename class TempFileName(PlaceHolder): """Stands for a temporary file's name.""" def __init__(self, filename): assert isinstance(filename, str) assert filename != '' self.filename = filename def instantiate_for_spirv_args(self, testcase): return os.path.join(testcase.directory, self.filename) def instantiate_for_expectation(self, testcase): return os.path.join(testcase.directory, self.filename) class SpecializedString(PlaceHolder): """Returns a string that has been specialized based on TestCase. The string is specialized by expanding it as a string.Template with all of the specialization being done with each $param replaced by the associated member on TestCase. """ def __init__(self, filename): assert isinstance(filename, str) assert filename != '' self.filename = filename def instantiate_for_spirv_args(self, testcase): return Template(self.filename).substitute(vars(testcase)) def instantiate_for_expectation(self, testcase): return Template(self.filename).substitute(vars(testcase)) KhronosGroup-SPIRV-Tools-f289d04/test/tools/spirv_test_framework.py000077500000000000000000000341461475742701700255140ustar00rootroot00000000000000# Copyright (c) 2018 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Manages and runs tests from the current working directory. This will traverse the current working directory and look for python files that contain subclasses of SpirvTest. If a class has an @inside_spirv_testsuite decorator, an instance of that class will be created and serve as a test case in that testsuite. The test case is then run by the following steps: 1. A temporary directory will be created. 2. The spirv_args member variable will be inspected and all placeholders in it will be expanded by calling instantiate_for_spirv_args() on placeholders. The transformed list elements are then supplied as arguments to the spirv-* tool under test. 3. If the environment member variable exists, its write() method will be invoked. 4. All expected_* member variables will be inspected and all placeholders in them will be expanded by calling instantiate_for_expectation() on those placeholders. After placeholder expansion, if the expected_* variable is a list, its element will be joined together with '' to form a single string. These expected_* variables are to be used by the check_*() methods. 5. The spirv-* tool will be run with the arguments supplied in spirv_args. 6. All check_*() member methods will be called by supplying a TestStatus as argument. Each check_*() method is expected to return a (Success, Message) pair where Success is a boolean indicating success and Message is an error message. 7. If any check_*() method fails, the error message is output and the current test case fails. If --leave-output was not specified, all temporary files and directories will be deleted. """ import argparse import fnmatch import inspect import os import shutil import subprocess import sys import tempfile from collections import defaultdict from placeholder import PlaceHolder EXPECTED_BEHAVIOR_PREFIX = 'expected_' VALIDATE_METHOD_PREFIX = 'check_' def get_all_variables(instance): """Returns the names of all the variables in instance.""" return [v for v in dir(instance) if not callable(getattr(instance, v))] def get_all_methods(instance): """Returns the names of all methods in instance.""" return [m for m in dir(instance) if callable(getattr(instance, m))] def get_all_superclasses(cls): """Returns all superclasses of a given class. Omits root 'object' superclass. Returns: A list of superclasses of the given class. The order guarantees that * A Base class precedes its derived classes, e.g., for "class B(A)", it will be [..., A, B, ...]. * When there are multiple base classes, base classes declared first precede those declared later, e.g., for "class C(A, B), it will be [..., A, B, C, ...] """ classes = [] for superclass in cls.__bases__: for c in get_all_superclasses(superclass): if c is not object and c not in classes: classes.append(c) for superclass in cls.__bases__: if superclass is not object and superclass not in classes: classes.append(superclass) return classes def get_all_test_methods(test_class): """Gets all validation methods. Returns: A list of validation methods. The order guarantees that * A method defined in superclass precedes one defined in subclass, e.g., for "class A(B)", methods defined in B precedes those defined in A. * If a subclass has more than one superclass, e.g., "class C(A, B)", then methods defined in A precedes those defined in B. """ classes = get_all_superclasses(test_class) classes.append(test_class) all_tests = [ m for c in classes for m in get_all_methods(c) if m.startswith(VALIDATE_METHOD_PREFIX) ] unique_tests = [] for t in all_tests: if t not in unique_tests: unique_tests.append(t) return unique_tests class SpirvTest: """Base class for spirv test cases. Subclasses define test cases' facts (shader source code, spirv command, result validation), which will be used by the TestCase class for running tests. Subclasses should define spirv_args (specifying spirv_tool command arguments), and at least one check_*() method (for result validation) for a full-fledged test case. All check_*() methods should take a TestStatus parameter and return a (Success, Message) pair, in which Success is a boolean indicating success and Message is an error message. The test passes iff all check_*() methods returns true. Often, a test case class will delegate the check_* behaviors by inheriting from other classes. """ def name(self): return self.__class__.__name__ class TestStatus: """A struct for holding run status of a test case.""" def __init__(self, test_manager, returncode, stdout, stderr, directory, inputs, input_filenames): self.test_manager = test_manager self.returncode = returncode # Some of our MacOS bots still run Python 2, so need to be backwards # compatible here. if type(stdout) is not str: if sys.version_info[0] == 2: self.stdout = stdout.decode('utf-8') elif sys.version_info[0] == 3: self.stdout = str(stdout, encoding='utf-8') if stdout is not None else stdout else: raise Exception('Unable to determine if running Python 2 or 3 from {}'.format(sys.version_info)) else: self.stdout = stdout if type(stderr) is not str: if sys.version_info[0] == 2: self.stderr = stderr.decode('utf-8') elif sys.version_info[0] == 3: self.stderr = str(stderr, encoding='utf-8') if stderr is not None else stderr else: raise Exception('Unable to determine if running Python 2 or 3 from {}'.format(sys.version_info)) else: self.stderr = stderr # temporary directory where the test runs self.directory = directory # List of inputs, as PlaceHolder objects. self.inputs = inputs # the names of input shader files (potentially including paths) self.input_filenames = input_filenames class SpirvTestException(Exception): """SpirvTest exception class.""" pass def inside_spirv_testsuite(testsuite_name): """Decorator for subclasses of SpirvTest. This decorator checks that a class meets the requirements (see below) for a test case class, and then puts the class in a certain testsuite. * The class needs to be a subclass of SpirvTest. * The class needs to have spirv_args defined as a list. * The class needs to define at least one check_*() methods. * All expected_* variables required by check_*() methods can only be of bool, str, or list type. * Python runtime will throw an exception if the expected_* member attributes required by check_*() methods are missing. """ def actual_decorator(cls): if not inspect.isclass(cls): raise SpirvTestException('Test case should be a class') if not issubclass(cls, SpirvTest): raise SpirvTestException( 'All test cases should be subclasses of SpirvTest') if 'spirv_args' not in get_all_variables(cls): raise SpirvTestException('No spirv_args found in the test case') if not isinstance(cls.spirv_args, list): raise SpirvTestException('spirv_args needs to be a list') if not any( [m.startswith(VALIDATE_METHOD_PREFIX) for m in get_all_methods(cls)]): raise SpirvTestException('No check_*() methods found in the test case') if not all( [isinstance(v, (bool, str, list)) for v in get_all_variables(cls)]): raise SpirvTestException( 'expected_* variables are only allowed to be bool, str, or ' 'list type.') cls.parent_testsuite = testsuite_name return cls return actual_decorator class TestManager: """Manages and runs a set of tests.""" def __init__(self, executable_path, assembler_path, disassembler_path): self.executable_path = executable_path self.assembler_path = assembler_path self.disassembler_path = disassembler_path self.num_successes = 0 self.num_failures = 0 self.num_tests = 0 self.leave_output = False self.tests = defaultdict(list) def notify_result(self, test_case, success, message): """Call this to notify the manager of the results of a test run.""" self.num_successes += 1 if success else 0 self.num_failures += 0 if success else 1 counter_string = str(self.num_successes + self.num_failures) + '/' + str( self.num_tests) print('%-10s %-40s ' % (counter_string, test_case.test.name()) + ('Passed' if success else '-Failed-')) if not success: print(' '.join(test_case.command)) print(message) def add_test(self, testsuite, test): """Add this to the current list of test cases.""" self.tests[testsuite].append(TestCase(test, self)) self.num_tests += 1 def run_tests(self): for suite in self.tests: print('SPIRV tool test suite: "{suite}"'.format(suite=suite)) for x in self.tests[suite]: x.runTest() class TestCase: """A single test case that runs in its own directory.""" def __init__(self, test, test_manager): self.test = test self.test_manager = test_manager self.inputs = [] # inputs, as PlaceHolder objects. self.file_shaders = [] # filenames of shader files. self.stdin_shader = None # text to be passed to spirv_tool as stdin def setUp(self): """Creates environment and instantiates placeholders for the test case.""" self.directory = tempfile.mkdtemp(dir=os.getcwd()) spirv_args = self.test.spirv_args # Instantiate placeholders in spirv_args self.test.spirv_args = [ arg.instantiate_for_spirv_args(self) if isinstance(arg, PlaceHolder) else arg for arg in self.test.spirv_args ] # Get all shader files' names self.inputs = [arg for arg in spirv_args if isinstance(arg, PlaceHolder)] self.file_shaders = [arg.filename for arg in self.inputs] if 'environment' in get_all_variables(self.test): self.test.environment.write(self.directory) expectations = [ v for v in get_all_variables(self.test) if v.startswith(EXPECTED_BEHAVIOR_PREFIX) ] # Instantiate placeholders in expectations for expectation_name in expectations: expectation = getattr(self.test, expectation_name) if isinstance(expectation, list): expanded_expections = [ element.instantiate_for_expectation(self) if isinstance(element, PlaceHolder) else element for element in expectation ] setattr(self.test, expectation_name, expanded_expections) elif isinstance(expectation, PlaceHolder): setattr(self.test, expectation_name, expectation.instantiate_for_expectation(self)) def tearDown(self): """Removes the directory if we were not instructed to do otherwise.""" if not self.test_manager.leave_output: shutil.rmtree(self.directory) def runTest(self): """Sets up and runs a test, reports any failures and then cleans up.""" self.setUp() success = False message = '' try: self.command = [self.test_manager.executable_path] self.command.extend(self.test.spirv_args) process = subprocess.Popen( args=self.command, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=self.directory) output = process.communicate(self.stdin_shader) test_status = TestStatus(self.test_manager, process.returncode, output[0], output[1], self.directory, self.inputs, self.file_shaders) run_results = [ getattr(self.test, test_method)(test_status) for test_method in get_all_test_methods(self.test.__class__) ] success, message = zip(*run_results) success = all(success) message = '\n'.join(message) except Exception as e: success = False message = str(e) self.test_manager.notify_result( self, success, message + '\nSTDOUT:\n%s\nSTDERR:\n%s' % (output[0], output[1])) self.tearDown() def main(): parser = argparse.ArgumentParser() parser.add_argument( 'spirv_tool', metavar='path/to/spirv_tool', type=str, nargs=1, help='Path to the spirv-* tool under test') parser.add_argument( 'spirv_as', metavar='path/to/spirv-as', type=str, nargs=1, help='Path to spirv-as') parser.add_argument( 'spirv_dis', metavar='path/to/spirv-dis', type=str, nargs=1, help='Path to spirv-dis') parser.add_argument( '--leave-output', action='store_const', const=1, help='Do not clean up temporary directories') parser.add_argument( '--test-dir', nargs=1, help='Directory to gather the tests from') args = parser.parse_args() default_path = sys.path root_dir = os.getcwd() if args.test_dir: root_dir = args.test_dir[0] manager = TestManager(args.spirv_tool[0], args.spirv_as[0], args.spirv_dis[0]) if args.leave_output: manager.leave_output = True for root, _, filenames in os.walk(root_dir): for filename in fnmatch.filter(filenames, '*.py'): if filename.endswith('nosetest.py'): # Skip nose tests, which are for testing functions of # the test framework. continue sys.path = default_path sys.path.append(root) mod = __import__(os.path.splitext(filename)[0]) for _, obj, in inspect.getmembers(mod): if inspect.isclass(obj) and hasattr(obj, 'parent_testsuite'): manager.add_test(obj.parent_testsuite, obj()) manager.run_tests() if manager.num_failures > 0: sys.exit(-1) if __name__ == '__main__': main() KhronosGroup-SPIRV-Tools-f289d04/test/tools/spirv_test_framework_unittest.py000066400000000000000000000073641475742701700274520ustar00rootroot00000000000000# Copyright (c) 2019 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Tests for the spirv test framework module.""" from spirv_test_framework import get_all_test_methods, get_all_superclasses import unittest # Classes to be used in testing get_all_{superclasses|test_methods}() class Root: def check_root(self): pass class A(Root): def check_a(self): pass class B(Root): def check_b(self): pass class C(Root): def check_c(self): pass class D(Root): def check_d(self): pass class E(Root): def check_e(self): pass class H(B, C, D): def check_h(self): pass class I(E): def check_i(self): pass class O(H, I): def check_o(self): pass class U(A, O): def check_u(self): pass class X(U, A): def check_x(self): pass class R1: def check_r1(self): pass class R2: def check_r2(self): pass class Multi(R1, R2): def check_multi(self): pass class TestSpirvTestFramework(unittest.TestCase): def test_get_all_superclasses(self): self.assertEqual(get_all_superclasses(A), [Root]) self.assertEqual(get_all_superclasses(B), [Root]) self.assertEqual(get_all_superclasses(C), [Root]) self.assertEqual(get_all_superclasses(D), [Root]) self.assertEqual(get_all_superclasses(E), [Root]) self.assertEqual(get_all_superclasses(H), [Root, B, C, D]) self.assertEqual(get_all_superclasses(I), [Root, E]) self.assertEqual(get_all_superclasses(O), [Root, B, C, D, E, H, I]) self.assertEqual(get_all_superclasses( U), [Root, B, C, D, E, H, I, A, O]) self.assertEqual(get_all_superclasses( X), [Root, B, C, D, E, H, I, A, O, U]) self.assertEqual(get_all_superclasses(Multi), [R1, R2]) def test_get_all_methods(self): self.assertEqual(get_all_test_methods(A), ['check_root', 'check_a']) self.assertEqual(get_all_test_methods(B), ['check_root', 'check_b']) self.assertEqual(get_all_test_methods(C), ['check_root', 'check_c']) self.assertEqual(get_all_test_methods(D), ['check_root', 'check_d']) self.assertEqual(get_all_test_methods(E), ['check_root', 'check_e']) self.assertEqual( get_all_test_methods(H), ['check_root', 'check_b', 'check_c', 'check_d', 'check_h']) self.assertEqual(get_all_test_methods( I), ['check_root', 'check_e', 'check_i']) self.assertEqual( get_all_test_methods(O), [ 'check_root', 'check_b', 'check_c', 'check_d', 'check_e', 'check_h', 'check_i', 'check_o' ]) self.assertEqual( get_all_test_methods(U), [ 'check_root', 'check_b', 'check_c', 'check_d', 'check_e', 'check_h', 'check_i', 'check_a', 'check_o', 'check_u' ]) self.assertEqual( get_all_test_methods(X), [ 'check_root', 'check_b', 'check_c', 'check_d', 'check_e', 'check_h', 'check_i', 'check_a', 'check_o', 'check_u', 'check_x' ]) self.assertEqual( get_all_test_methods(Multi), ['check_r1', 'check_r2', 'check_multi']) KhronosGroup-SPIRV-Tools-f289d04/test/unit_spirv.cpp000066400000000000000000000033131475742701700224160ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "test/unit_spirv.h" #include "gmock/gmock.h" #include "source/util/string_utils.h" #include "test/test_fixture.h" namespace spvtools { namespace { using utils::MakeVector; using ::testing::Eq; using Words = std::vector; TEST(MakeVector, Samples) { EXPECT_THAT(MakeVector(""), Eq(Words{0})); EXPECT_THAT(MakeVector("a"), Eq(Words{0x0061})); EXPECT_THAT(MakeVector("ab"), Eq(Words{0x006261})); EXPECT_THAT(MakeVector("abc"), Eq(Words{0x00636261})); EXPECT_THAT(MakeVector("abcd"), Eq(Words{0x64636261, 0x00})); EXPECT_THAT(MakeVector("abcde"), Eq(Words{0x64636261, 0x0065})); } TEST(WordVectorPrintTo, PreservesFlagsAndFill) { std::stringstream s; s << std::setw(4) << std::oct << std::setfill('x') << 8 << " "; spvtest::PrintTo(spvtest::WordVector({10, 16}), &s); // The octal setting and fill character should be preserved // from before the PrintTo. // Width is reset after each emission of a regular scalar type. // So set it explicitly again. s << std::setw(4) << 9; EXPECT_THAT(s.str(), Eq("xx10 0x0000000a 0x00000010 xx11")); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/unit_spirv.h000066400000000000000000000152751475742701700220750ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef TEST_UNIT_SPIRV_H_ #define TEST_UNIT_SPIRV_H_ #include #include #include #include #include "gtest/gtest.h" #include "source/assembly_grammar.h" #include "source/binary.h" #include "source/diagnostic.h" #include "source/enum_set.h" #include "source/opcode.h" #include "source/spirv_endian.h" #include "source/text.h" #include "source/text_handler.h" #include "source/val/validate.h" #include "spirv-tools/libspirv.h" #ifdef __ANDROID__ #include namespace std { template std::string to_string(const T& val) { std::ostringstream os; os << val; return os.str(); } } // namespace std #endif // Determine endianness & predicate tests on it enum { I32_ENDIAN_LITTLE = 0x03020100ul, I32_ENDIAN_BIG = 0x00010203ul, }; static const union { unsigned char bytes[4]; uint32_t value; } o32_host_order = {{0, 1, 2, 3}}; #define I32_ENDIAN_HOST (o32_host_order.value) // A namespace for utilities used in SPIR-V Tools unit tests. namespace spvtest { class WordVector; // Emits the given word vector to the given stream. // This function can be used by the gtest value printer. void PrintTo(const WordVector& words, ::std::ostream* os); // A proxy class to allow us to easily write out vectors of SPIR-V words. class WordVector { public: explicit WordVector(const std::vector& val) : value_(val) {} explicit WordVector(const spv_binary_t& binary) : value_(binary.code, binary.code + binary.wordCount) {} // Returns the underlying vector. const std::vector& value() const { return value_; } // Returns the string representation of this word vector. std::string str() const { std::ostringstream os; PrintTo(*this, &os); return os.str(); } private: const std::vector value_; }; inline void PrintTo(const WordVector& words, ::std::ostream* os) { size_t count = 0; const auto saved_flags = os->flags(); const auto saved_fill = os->fill(); for (uint32_t value : words.value()) { *os << "0x" << std::setw(8) << std::setfill('0') << std::hex << value << " "; if (count++ % 8 == 7) { *os << std::endl; } } os->flags(saved_flags); os->fill(saved_fill); } // Returns a vector of words representing a single instruction with the // given opcode and operand words as a vector. inline std::vector MakeInstruction( spv::Op opcode, const std::vector& args) { std::vector result{ spvOpcodeMake(uint16_t(args.size() + 1), opcode)}; result.insert(result.end(), args.begin(), args.end()); return result; } // Returns a vector of words representing a single instruction with the // given opcode and whose operands are the concatenation of the two given // argument lists. inline std::vector MakeInstruction( spv::Op opcode, std::vector args, const std::vector& extra_args) { args.insert(args.end(), extra_args.begin(), extra_args.end()); return MakeInstruction(opcode, args); } // Returns the vector of words representing the concatenation // of all input vectors. inline std::vector Concatenate( const std::vector>& instructions) { std::vector result; for (const auto& instruction : instructions) { result.insert(result.end(), instruction.begin(), instruction.end()); } return result; } // A type for easily creating spv_text_t values, with an implicit conversion to // spv_text. struct AutoText { explicit AutoText(const std::string& value) : str(value), text({str.data(), str.size()}) {} operator spv_text() { return &text; } std::string str; spv_text_t text; }; // An example case for an enumerated value, optionally with operands. template class EnumCase { public: EnumCase() = default; // Required by ::testing::Combine(). EnumCase(E val, std::string enum_name, std::vector ops = {}) : enum_value_(val), name_(enum_name), operands_(ops) {} // Returns the enum value as a uint32_t. uint32_t value() const { return static_cast(enum_value_); } // Returns the name of the enumerant. const std::string& name() const { return name_; } // Returns a reference to the operands. const std::vector& operands() const { return operands_; } private: E enum_value_; std::string name_; std::vector operands_; }; // Returns a string with num_4_byte_chars Unicode characters, // each of which has a 4-byte UTF-8 encoding. inline std::string MakeLongUTF8String(size_t num_4_byte_chars) { // An example of a longest valid UTF-8 character. // Be explicit about the character type because Microsoft compilers can // otherwise interpret the character string as being over wide (16-bit) // characters. Ideally, we would just use a C++11 UTF-8 string literal, // but we want to support older Microsoft compilers. const std::basic_string earth_africa("\xF0\x9F\x8C\x8D"); EXPECT_EQ(4u, earth_africa.size()); std::string result; result.reserve(num_4_byte_chars * 4); for (size_t i = 0; i < num_4_byte_chars; i++) { result += earth_africa; } EXPECT_EQ(4 * num_4_byte_chars, result.size()); return result; } // Returns a vector of all valid target environment enums. inline std::vector AllTargetEnvironments() { return { SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1, SPV_ENV_OPENCL_1_2, SPV_ENV_OPENCL_EMBEDDED_1_2, SPV_ENV_OPENCL_2_0, SPV_ENV_OPENCL_EMBEDDED_2_0, SPV_ENV_OPENCL_2_1, SPV_ENV_OPENCL_EMBEDDED_2_1, SPV_ENV_OPENCL_2_2, SPV_ENV_OPENCL_EMBEDDED_2_2, SPV_ENV_VULKAN_1_0, SPV_ENV_OPENGL_4_0, SPV_ENV_OPENGL_4_1, SPV_ENV_OPENGL_4_2, SPV_ENV_OPENGL_4_3, SPV_ENV_OPENGL_4_5, SPV_ENV_UNIVERSAL_1_2, SPV_ENV_UNIVERSAL_1_3, SPV_ENV_VULKAN_1_1, }; } // Returns the capabilities in a CapabilitySet as an ordered vector. inline std::vector ElementsIn( const spvtools::CapabilitySet& capabilities) { return std::vector(capabilities.cbegin(), capabilities.cend()); } } // namespace spvtest #endif // TEST_UNIT_SPIRV_H_ KhronosGroup-SPIRV-Tools-f289d04/test/util/000077500000000000000000000000001475742701700204655ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/util/CMakeLists.txt000066400000000000000000000014041475742701700232240ustar00rootroot00000000000000# Copyright (c) 2017 Google Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. add_spvtools_unittest(TARGET utils SRCS ilist_test.cpp bit_vector_test.cpp bitutils_test.cpp hash_combine_test.cpp small_vector_test.cpp LIBS SPIRV-Tools-opt ) KhronosGroup-SPIRV-Tools-f289d04/test/util/bit_vector_test.cpp000066400000000000000000000073351475742701700244000ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gmock/gmock.h" #include "source/util/bit_vector.h" namespace spvtools { namespace utils { namespace { using BitVectorTest = ::testing::Test; TEST(BitVectorTest, Initialize) { BitVector bvec; // Checks that all values are 0. Also tests checking a bit past the end of // the vector containing the bits. for (int i = 1; i < 10000; i *= 2) { EXPECT_FALSE(bvec.Get(i)); } } TEST(BitVectorTest, Set) { BitVector bvec; // Since 10,000 is larger than the initial size, this tests the resizing // code. for (int i = 3; i < 10000; i *= 2) { bvec.Set(i); } // Check that bits that were not set are 0. for (int i = 1; i < 10000; i *= 2) { EXPECT_FALSE(bvec.Get(i)); } // Check that bits that were set are 1. for (int i = 3; i < 10000; i *= 2) { EXPECT_TRUE(bvec.Get(i)); } } TEST(BitVectorTest, SetReturnValue) { BitVector bvec; // Make sure |Set| returns false when the bit was not set. for (int i = 3; i < 10000; i *= 2) { EXPECT_FALSE(bvec.Set(i)); } // Make sure |Set| returns true when the bit was already set. for (int i = 3; i < 10000; i *= 2) { EXPECT_TRUE(bvec.Set(i)); } } TEST(BitVectorTest, Clear) { BitVector bvec; for (int i = 3; i < 10000; i *= 2) { bvec.Set(i); } // Check that the bits were properly set. for (int i = 3; i < 10000; i *= 2) { EXPECT_TRUE(bvec.Get(i)); } // Clear all of the bits except for bit 3. for (int i = 6; i < 10000; i *= 2) { bvec.Clear(i); } // Make sure bit 3 was not cleared. EXPECT_TRUE(bvec.Get(3)); // Make sure all of the other bits that were set have been cleared. for (int i = 6; i < 10000; i *= 2) { EXPECT_FALSE(bvec.Get(i)); } } TEST(BitVectorTest, ClearReturnValue) { BitVector bvec; for (int i = 3; i < 10000; i *= 2) { bvec.Set(i); } // Make sure |Clear| returns true if the bit was set. for (int i = 3; i < 10000; i *= 2) { EXPECT_TRUE(bvec.Clear(i)); } // Make sure |Clear| returns false if the bit was not set. for (int i = 3; i < 10000; i *= 2) { EXPECT_FALSE(bvec.Clear(i)); } } TEST(BitVectorTest, SimpleOrTest) { BitVector bvec1; bvec1.Set(3); bvec1.Set(4); BitVector bvec2; bvec2.Set(2); bvec2.Set(4); // Check that |bvec1| changed when doing the |Or| operation. EXPECT_TRUE(bvec1.Or(bvec2)); // Check that the values are all correct. EXPECT_FALSE(bvec1.Get(0)); EXPECT_FALSE(bvec1.Get(1)); EXPECT_TRUE(bvec1.Get(2)); EXPECT_TRUE(bvec1.Get(3)); EXPECT_TRUE(bvec1.Get(4)); } TEST(BitVectorTest, ResizingOrTest) { BitVector bvec1; bvec1.Set(3); bvec1.Set(4); BitVector bvec2; bvec2.Set(10000); // Similar to above except with a large value to test resizing. EXPECT_TRUE(bvec1.Or(bvec2)); EXPECT_FALSE(bvec1.Get(0)); EXPECT_FALSE(bvec1.Get(1)); EXPECT_FALSE(bvec1.Get(2)); EXPECT_TRUE(bvec1.Get(3)); EXPECT_TRUE(bvec1.Get(10000)); } TEST(BitVectorTest, SubsetOrTest) { BitVector bvec1; bvec1.Set(3); bvec1.Set(4); BitVector bvec2; bvec2.Set(3); // |Or| returns false if |bvec1| does not change. EXPECT_FALSE(bvec1.Or(bvec2)); } } // namespace } // namespace utils } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/util/bitutils_test.cpp000066400000000000000000000173021475742701700240720ustar00rootroot00000000000000// Copyright (c) 2019 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/util/bitutils.h" #include "gmock/gmock.h" namespace spvtools { namespace utils { namespace { using BitUtilsTest = ::testing::Test; TEST(BitUtilsTest, MutateBitsWholeWord) { const uint32_t zero_u32 = 0; const uint32_t max_u32 = ~0; EXPECT_EQ(MutateBits(zero_u32, 0, 0, false), zero_u32); EXPECT_EQ(MutateBits(max_u32, 0, 0, false), max_u32); EXPECT_EQ(MutateBits(zero_u32, 0, 32, false), zero_u32); EXPECT_EQ(MutateBits(zero_u32, 0, 32, true), max_u32); EXPECT_EQ(MutateBits(max_u32, 0, 32, true), max_u32); EXPECT_EQ(MutateBits(max_u32, 0, 32, false), zero_u32); } TEST(BitUtilsTest, MutateBitsLow) { const uint32_t zero_u32 = 0; const uint32_t one_u32 = 1; const uint32_t max_u32 = ~0; EXPECT_EQ(MutateBits(zero_u32, 0, 1, false), zero_u32); EXPECT_EQ(MutateBits(zero_u32, 0, 1, true), one_u32); EXPECT_EQ(MutateBits(max_u32, 0, 1, true), max_u32); EXPECT_EQ(MutateBits(one_u32, 0, 32, false), zero_u32); EXPECT_EQ(MutateBits(one_u32, 0, 1, true), one_u32); EXPECT_EQ(MutateBits(one_u32, 0, 1, false), zero_u32); EXPECT_EQ(MutateBits(zero_u32, 0, 3, true), uint32_t(7)); EXPECT_EQ(MutateBits(uint32_t(7), 0, 2, false), uint32_t(4)); } TEST(BitUtilsTest, MutateBitsHigh) { const uint8_t zero_u8 = 0; const uint8_t one_u8 = 1; const uint8_t max_u8 = 255; EXPECT_EQ(MutateBits(zero_u8, 7, 0, true), zero_u8); EXPECT_EQ(MutateBits(zero_u8, 7, 1, true), uint8_t(128)); EXPECT_EQ(MutateBits(one_u8, 7, 1, true), uint8_t(129)); EXPECT_EQ(MutateBits(max_u8, 7, 1, true), max_u8); EXPECT_EQ(MutateBits(max_u8, 7, 1, false), uint8_t(127)); EXPECT_EQ(MutateBits(max_u8, 6, 2, true), max_u8); EXPECT_EQ(MutateBits(max_u8, 6, 2, false), uint8_t(63)); } TEST(BitUtilsTest, MutateBitsUint8Mid) { const uint8_t zero_u8 = 0; const uint8_t max_u8 = 255; EXPECT_EQ(MutateBits(zero_u8, 1, 2, true), uint8_t(6)); EXPECT_EQ(MutateBits(max_u8, 1, 2, true), max_u8); EXPECT_EQ(MutateBits(max_u8, 1, 2, false), uint8_t(0xF9)); EXPECT_EQ(MutateBits(zero_u8, 2, 3, true), uint8_t(0x1C)); } TEST(BitUtilsTest, MutateBitsUint64Mid) { const uint64_t zero_u64 = 0; const uint64_t max_u64 = ~zero_u64; EXPECT_EQ(MutateBits(zero_u64, 1, 2, true), uint64_t(6)); EXPECT_EQ(MutateBits(max_u64, 1, 2, true), max_u64); EXPECT_EQ(MutateBits(max_u64, 1, 2, false), uint64_t(0xFFFFFFFFFFFFFFF9)); EXPECT_EQ(MutateBits(zero_u64, 2, 3, true), uint64_t(0x000000000000001C)); EXPECT_EQ(MutateBits(zero_u64, 2, 35, true), uint64_t(0x0000001FFFFFFFFC)); EXPECT_EQ(MutateBits(zero_u64, 36, 4, true), uint64_t(0x000000F000000000)); EXPECT_EQ(MutateBits(max_u64, 36, 4, false), uint64_t(0xFFFFFF0FFFFFFFFF)); } TEST(BitUtilsTest, SetHighBitsUint32) { const uint32_t zero_u32 = 0; const uint32_t one_u32 = 1; const uint32_t max_u32 = ~zero_u32; EXPECT_EQ(SetHighBits(zero_u32, 0), zero_u32); EXPECT_EQ(SetHighBits(zero_u32, 1), 0x80000000); EXPECT_EQ(SetHighBits(one_u32, 1), 0x80000001); EXPECT_EQ(SetHighBits(one_u32, 2), 0xC0000001); EXPECT_EQ(SetHighBits(zero_u32, 31), 0xFFFFFFFE); EXPECT_EQ(SetHighBits(zero_u32, 32), max_u32); EXPECT_EQ(SetHighBits(max_u32, 32), max_u32); } TEST(BitUtilsTest, ClearHighBitsUint32) { const uint32_t zero_u32 = 0; const uint32_t one_u32 = 1; const uint32_t max_u32 = ~zero_u32; EXPECT_EQ(ClearHighBits(zero_u32, 0), zero_u32); EXPECT_EQ(ClearHighBits(zero_u32, 1), zero_u32); EXPECT_EQ(ClearHighBits(one_u32, 1), one_u32); EXPECT_EQ(ClearHighBits(one_u32, 31), one_u32); EXPECT_EQ(ClearHighBits(one_u32, 32), zero_u32); EXPECT_EQ(ClearHighBits(max_u32, 0), max_u32); EXPECT_EQ(ClearHighBits(max_u32, 1), 0x7FFFFFFF); EXPECT_EQ(ClearHighBits(max_u32, 2), 0x3FFFFFFF); EXPECT_EQ(ClearHighBits(max_u32, 31), one_u32); EXPECT_EQ(ClearHighBits(max_u32, 32), zero_u32); } TEST(BitUtilsTest, IsBitSetAtPositionZero) { const uint32_t zero_u32 = 0; for (size_t i = 0; i != 32; ++i) { EXPECT_FALSE(IsBitAtPositionSet(zero_u32, i)); } const uint8_t zero_u8 = 0; for (size_t i = 0; i != 8; ++i) { EXPECT_FALSE(IsBitAtPositionSet(zero_u8, i)); } const uint64_t zero_u64 = 0; for (size_t i = 0; i != 64; ++i) { EXPECT_FALSE(IsBitAtPositionSet(zero_u64, i)); } } TEST(BitUtilsTest, IsBitSetAtPositionOne) { const uint32_t one_u32 = 1; for (size_t i = 0; i != 32; ++i) { if (i == 0) { EXPECT_TRUE(IsBitAtPositionSet(one_u32, i)); } else { EXPECT_FALSE(IsBitAtPositionSet(one_u32, i)); } } const uint32_t two_to_17_u32 = 1 << 17; for (size_t i = 0; i != 32; ++i) { if (i == 17) { EXPECT_TRUE(IsBitAtPositionSet(two_to_17_u32, i)); } else { EXPECT_FALSE(IsBitAtPositionSet(two_to_17_u32, i)); } } const uint8_t two_to_4_u8 = 1 << 4; for (size_t i = 0; i != 8; ++i) { if (i == 4) { EXPECT_TRUE(IsBitAtPositionSet(two_to_4_u8, i)); } else { EXPECT_FALSE(IsBitAtPositionSet(two_to_4_u8, i)); } } const uint64_t two_to_55_u64 = uint64_t(1) << 55; for (size_t i = 0; i != 64; ++i) { if (i == 55) { EXPECT_TRUE(IsBitAtPositionSet(two_to_55_u64, i)); } else { EXPECT_FALSE(IsBitAtPositionSet(two_to_55_u64, i)); } } } TEST(BitUtilsTest, IsBitSetAtPositionAll) { const uint32_t max_u32 = ~0; for (size_t i = 0; i != 32; ++i) { EXPECT_TRUE(IsBitAtPositionSet(max_u32, i)); } const uint32_t max_u8 = ~uint8_t(0); for (size_t i = 0; i != 8; ++i) { EXPECT_TRUE(IsBitAtPositionSet(max_u8, i)); } const uint64_t max_u64 = ~uint64_t(0); for (size_t i = 0; i != 64; ++i) { EXPECT_TRUE(IsBitAtPositionSet(max_u64, i)); } } struct ExtendedValueTestCase { uint32_t input; uint32_t bit_width; uint32_t expected_result; }; using SignExtendedValueTest = ::testing::TestWithParam; TEST_P(SignExtendedValueTest, SignExtendValue) { const auto& tc = GetParam(); auto result = SignExtendValue(tc.input, tc.bit_width); EXPECT_EQ(result, tc.expected_result); } INSTANTIATE_TEST_SUITE_P( SignExtendValue, SignExtendedValueTest, ::testing::Values(ExtendedValueTestCase{1, 1, 0xFFFFFFFF}, ExtendedValueTestCase{1, 2, 0x1}, ExtendedValueTestCase{2, 1, 0x0}, ExtendedValueTestCase{0x8, 4, 0xFFFFFFF8}, ExtendedValueTestCase{0x8765, 16, 0xFFFF8765}, ExtendedValueTestCase{0x7765, 16, 0x7765}, ExtendedValueTestCase{0xDEADBEEF, 32, 0xDEADBEEF})); using ZeroExtendedValueTest = ::testing::TestWithParam; TEST_P(ZeroExtendedValueTest, ZeroExtendValue) { const auto& tc = GetParam(); auto result = ZeroExtendValue(tc.input, tc.bit_width); EXPECT_EQ(result, tc.expected_result); } INSTANTIATE_TEST_SUITE_P( ZeroExtendValue, ZeroExtendedValueTest, ::testing::Values(ExtendedValueTestCase{1, 1, 0x1}, ExtendedValueTestCase{1, 2, 0x1}, ExtendedValueTestCase{2, 1, 0x0}, ExtendedValueTestCase{0x8, 4, 0x8}, ExtendedValueTestCase{0xFF8765, 16, 0x8765}, ExtendedValueTestCase{0xDEADBEEF, 32, 0xDEADBEEF})); } // namespace } // namespace utils } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/util/hash_combine_test.cpp000066400000000000000000000024571475742701700246570ustar00rootroot00000000000000// Copyright (c) 2022 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gmock/gmock.h" #include "source/util/hash_combine.h" namespace spvtools { namespace utils { namespace { using HashCombineTest = ::testing::Test; TEST(HashCombineTest, Identity) { EXPECT_EQ(hash_combine(0), 0); } TEST(HashCombineTest, Variadic) { // Expect manual and variadic template versions be the same. EXPECT_EQ(hash_combine(hash_combine(hash_combine(0, 1), 2), 3), hash_combine(0, 1, 2, 3)); } TEST(HashCombineTest, Vector) { // Expect variadic and vector versions be the same. EXPECT_EQ(hash_combine(0, std::vector({1, 2, 3})), hash_combine(0, 1, 2, 3)); } } // namespace } // namespace utils } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/util/ilist_test.cpp000066400000000000000000000210121475742701700233500ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gmock/gmock.h" #include "source/util/ilist.h" namespace spvtools { namespace utils { namespace { using ::testing::ElementsAre; using IListTest = ::testing::Test; class TestNode : public IntrusiveNodeBase { public: TestNode() : IntrusiveNodeBase() {} int data_; }; class TestList : public IntrusiveList { public: TestList() = default; TestList(TestList&& that) : IntrusiveList(std::move(that)) {} TestList& operator=(TestList&& that) { static_cast&>(*this) = static_cast&&>(that); return *this; } }; // This test checks the push_back method, as well as using an iterator to // traverse the list from begin() to end(). This implicitly test the // PreviousNode and NextNode functions. TEST(IListTest, PushBack) { TestNode nodes[10]; TestList list; for (int i = 0; i < 10; i++) { nodes[i].data_ = i; list.push_back(&nodes[i]); } std::vector output; for (auto& i : list) output.push_back(i.data_); EXPECT_THAT(output, ElementsAre(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)); } // Returns a list containing the values 0 to n-1 using the first n elements of // nodes to build the list. TestList BuildList(TestNode nodes[], int n) { TestList list; for (int i = 0; i < n; i++) { nodes[i].data_ = i; list.push_back(&nodes[i]); } return list; } // Test decrementing begin() TEST(IListTest, DecrementingBegin) { TestNode nodes[10]; TestList list = BuildList(nodes, 10); EXPECT_EQ(--list.begin(), list.end()); } // Test incrementing end() TEST(IListTest, IncrementingEnd1) { TestNode nodes[10]; TestList list = BuildList(nodes, 10); EXPECT_EQ((++list.end())->data_, 0); } // Test incrementing end() should equal begin() TEST(IListTest, IncrementingEnd2) { TestNode nodes[10]; TestList list = BuildList(nodes, 10); EXPECT_EQ(++list.end(), list.begin()); } // Test decrementing end() TEST(IListTest, DecrementingEnd) { TestNode nodes[10]; TestList list = BuildList(nodes, 10); EXPECT_EQ((--list.end())->data_, 9); } // Test the move constructor for the list class. TEST(IListTest, MoveConstructor) { TestNode nodes[10]; TestList list = BuildList(nodes, 10); std::vector output; for (auto& i : list) output.push_back(i.data_); EXPECT_THAT(output, ElementsAre(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)); } // Using a const list so we can test the const_iterator. TEST(IListTest, ConstIterator) { TestNode nodes[10]; const TestList list = BuildList(nodes, 10); std::vector output; for (auto& i : list) output.push_back(i.data_); EXPECT_THAT(output, ElementsAre(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)); } // Uses the move assignement instead of the move constructor. TEST(IListTest, MoveAssignment) { TestNode nodes[10]; TestList list; list = BuildList(nodes, 10); std::vector output; for (auto& i : list) output.push_back(i.data_); EXPECT_THAT(output, ElementsAre(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)); } // Test inserting a new element at the end of a list using the IntrusiveNodeBase // "InsertAfter" function. TEST(IListTest, InsertAfter1) { TestNode nodes[10]; TestList list = BuildList(nodes, 5); nodes[5].data_ = 5; nodes[5].InsertAfter(&nodes[4]); std::vector output; for (auto& i : list) output.push_back(i.data_); EXPECT_THAT(output, ElementsAre(0, 1, 2, 3, 4, 5)); } // Test inserting a new element in the middle of a list using the // IntrusiveNodeBase "InsertAfter" function. TEST(IListTest, InsertAfter2) { TestNode nodes[10]; TestList list = BuildList(nodes, 5); nodes[5].data_ = 5; nodes[5].InsertAfter(&nodes[2]); std::vector output; for (auto& i : list) output.push_back(i.data_); EXPECT_THAT(output, ElementsAre(0, 1, 2, 5, 3, 4)); } // Test moving an element already in the list in the middle of a list using the // IntrusiveNodeBase "InsertAfter" function. TEST(IListTest, MoveUsingInsertAfter1) { TestNode nodes[10]; TestList list = BuildList(nodes, 6); nodes[5].InsertAfter(&nodes[2]); std::vector output; for (auto& i : list) output.push_back(i.data_); EXPECT_THAT(output, ElementsAre(0, 1, 2, 5, 3, 4)); } // Move the element at the start of the list into the middle. TEST(IListTest, MoveUsingInsertAfter2) { TestNode nodes[10]; TestList list = BuildList(nodes, 6); nodes[0].InsertAfter(&nodes[2]); std::vector output; for (auto& i : list) output.push_back(i.data_); EXPECT_THAT(output, ElementsAre(1, 2, 0, 3, 4, 5)); } // Move an element in the middle of the list to the end. TEST(IListTest, MoveUsingInsertAfter3) { TestNode nodes[10]; TestList list = BuildList(nodes, 6); nodes[2].InsertAfter(&nodes[5]); std::vector output; for (auto& i : list) output.push_back(i.data_); EXPECT_THAT(output, ElementsAre(0, 1, 3, 4, 5, 2)); } // Removing an element from the middle of a list. TEST(IListTest, Remove1) { TestNode nodes[10]; TestList list = BuildList(nodes, 6); nodes[2].RemoveFromList(); std::vector output; for (auto& i : list) output.push_back(i.data_); EXPECT_THAT(output, ElementsAre(0, 1, 3, 4, 5)); } // Removing an element from the beginning of the list. TEST(IListTest, Remove2) { TestNode nodes[10]; TestList list = BuildList(nodes, 6); nodes[0].RemoveFromList(); std::vector output; for (auto& i : list) output.push_back(i.data_); EXPECT_THAT(output, ElementsAre(1, 2, 3, 4, 5)); } // Removing the last element of a list. TEST(IListTest, Remove3) { TestNode nodes[10]; TestList list = BuildList(nodes, 6); nodes[5].RemoveFromList(); std::vector output; for (auto& i : list) output.push_back(i.data_); EXPECT_THAT(output, ElementsAre(0, 1, 2, 3, 4)); } // Test that operator== and operator!= work properly for the iterator class. TEST(IListTest, IteratorEqual) { TestNode nodes[10]; TestList list = BuildList(nodes, 6); std::vector output; for (auto i = list.begin(); i != list.end(); ++i) for (auto j = list.begin(); j != list.end(); ++j) if (i == j) output.push_back(i->data_); EXPECT_THAT(output, ElementsAre(0, 1, 2, 3, 4, 5)); } // Test MoveBefore. Moving into middle of a list. TEST(IListTest, MoveBefore1) { TestNode nodes[10]; TestList list1 = BuildList(nodes, 6); TestList list2 = BuildList(nodes + 6, 3); TestList::iterator insertion_point = list1.begin(); ++insertion_point; insertion_point.MoveBefore(&list2); std::vector output; for (auto i = list1.begin(); i != list1.end(); ++i) { output.push_back(i->data_); } EXPECT_THAT(output, ElementsAre(0, 0, 1, 2, 1, 2, 3, 4, 5)); } // Test MoveBefore. Moving to the start of a list. TEST(IListTest, MoveBefore2) { TestNode nodes[10]; TestList list1 = BuildList(nodes, 6); TestList list2 = BuildList(nodes + 6, 3); TestList::iterator insertion_point = list1.begin(); insertion_point.MoveBefore(&list2); std::vector output; for (auto i = list1.begin(); i != list1.end(); ++i) { output.push_back(i->data_); } EXPECT_THAT(output, ElementsAre(0, 1, 2, 0, 1, 2, 3, 4, 5)); } // Test MoveBefore. Moving to the end of a list. TEST(IListTest, MoveBefore3) { TestNode nodes[10]; TestList list1 = BuildList(nodes, 6); TestList list2 = BuildList(nodes + 6, 3); TestList::iterator insertion_point = list1.end(); insertion_point.MoveBefore(&list2); std::vector output; for (auto i = list1.begin(); i != list1.end(); ++i) { output.push_back(i->data_); } EXPECT_THAT(output, ElementsAre(0, 1, 2, 3, 4, 5, 0, 1, 2)); } // Test MoveBefore. Moving an empty list. TEST(IListTest, MoveBefore4) { TestNode nodes[10]; TestList list1 = BuildList(nodes, 6); TestList list2; TestList::iterator insertion_point = list1.end(); insertion_point.MoveBefore(&list2); std::vector output; for (auto i = list1.begin(); i != list1.end(); ++i) { output.push_back(i->data_); } EXPECT_THAT(output, ElementsAre(0, 1, 2, 3, 4, 5)); } } // namespace } // namespace utils } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/util/small_vector_test.cpp000066400000000000000000000406671475742701700247370ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gmock/gmock.h" #include "source/util/small_vector.h" namespace spvtools { namespace utils { namespace { using SmallVectorTest = ::testing::Test; TEST(SmallVectorTest, Initialize_default) { SmallVector vec; EXPECT_TRUE(vec.empty()); EXPECT_EQ(vec.size(), 0); EXPECT_EQ(vec.begin(), vec.end()); } TEST(SmallVectorTest, Initialize_list1) { SmallVector vec = {0, 1, 2, 3}; EXPECT_FALSE(vec.empty()); EXPECT_EQ(vec.size(), 4); uint32_t result[] = {0, 1, 2, 3}; for (uint32_t i = 0; i < vec.size(); ++i) { EXPECT_EQ(vec[i], result[i]); } } TEST(SmallVectorTest, Initialize_list2) { SmallVector vec = {0, 1, 2, 3}; EXPECT_FALSE(vec.empty()); EXPECT_EQ(vec.size(), 4); uint32_t result[] = {0, 1, 2, 3}; for (uint32_t i = 0; i < vec.size(); ++i) { EXPECT_EQ(vec[i], result[i]); } } TEST(SmallVectorTest, Initialize_list3) { std::vector result = {0, 1, 2, 3}; SmallVector vec(result.begin(), result.end()); EXPECT_FALSE(vec.empty()); EXPECT_EQ(vec.size(), 4); for (uint32_t i = 0; i < vec.size(); ++i) { EXPECT_EQ(vec[i], result[i]); } } TEST(SmallVectorTest, Initialize_copy1) { SmallVector vec1 = {0, 1, 2, 3}; SmallVector vec2(vec1); EXPECT_EQ(vec2.size(), 4); uint32_t result[] = {0, 1, 2, 3}; for (uint32_t i = 0; i < vec2.size(); ++i) { EXPECT_EQ(vec2[i], result[i]); } EXPECT_EQ(vec1, vec2); } TEST(SmallVectorTest, Initialize_copy2) { SmallVector vec1 = {0, 1, 2, 3}; SmallVector vec2(vec1); EXPECT_EQ(vec2.size(), 4); uint32_t result[] = {0, 1, 2, 3}; for (uint32_t i = 0; i < vec2.size(); ++i) { EXPECT_EQ(vec2[i], result[i]); } EXPECT_EQ(vec1, vec2); } TEST(SmallVectorTest, Initialize_copy_vec1) { std::vector vec1 = {0, 1, 2, 3}; SmallVector vec2(vec1); EXPECT_EQ(vec2.size(), 4); uint32_t result[] = {0, 1, 2, 3}; for (uint32_t i = 0; i < vec2.size(); ++i) { EXPECT_EQ(vec2[i], result[i]); } EXPECT_EQ(vec1, vec2); } TEST(SmallVectorTest, Initialize_copy_vec2) { std::vector vec1 = {0, 1, 2, 3}; SmallVector vec2(vec1); EXPECT_EQ(vec2.size(), 4); uint32_t result[] = {0, 1, 2, 3}; for (uint32_t i = 0; i < vec2.size(); ++i) { EXPECT_EQ(vec2[i], result[i]); } EXPECT_EQ(vec1, vec2); } TEST(SmallVectorTest, Initialize_move1) { SmallVector vec1 = {0, 1, 2, 3}; SmallVector vec2(std::move(vec1)); EXPECT_EQ(vec2.size(), 4); uint32_t result[] = {0, 1, 2, 3}; for (uint32_t i = 0; i < vec2.size(); ++i) { EXPECT_EQ(vec2[i], result[i]); } EXPECT_TRUE(vec1.empty()); } TEST(SmallVectorTest, Initialize_move2) { SmallVector vec1 = {0, 1, 2, 3}; SmallVector vec2(std::move(vec1)); EXPECT_EQ(vec2.size(), 4); uint32_t result[] = {0, 1, 2, 3}; for (uint32_t i = 0; i < vec2.size(); ++i) { EXPECT_EQ(vec2[i], result[i]); } EXPECT_TRUE(vec1.empty()); } TEST(SmallVectorTest, Initialize_move_vec1) { std::vector vec1 = {0, 1, 2, 3}; SmallVector vec2(std::move(vec1)); EXPECT_EQ(vec2.size(), 4); uint32_t result[] = {0, 1, 2, 3}; for (uint32_t i = 0; i < vec2.size(); ++i) { EXPECT_EQ(vec2[i], result[i]); } EXPECT_TRUE(vec1.empty()); } TEST(SmallVectorTest, Initialize_move_vec2) { std::vector vec1 = {0, 1, 2, 3}; SmallVector vec2(std::move(vec1)); EXPECT_EQ(vec2.size(), 4); uint32_t result[] = {0, 1, 2, 3}; for (uint32_t i = 0; i < vec2.size(); ++i) { EXPECT_EQ(vec2[i], result[i]); } EXPECT_TRUE(vec1.empty()); } TEST(SmallVectorTest, Initialize_iterators1) { SmallVector vec = {0, 1, 2, 3}; EXPECT_EQ(vec.size(), 4); uint32_t result[] = {0, 1, 2, 3}; uint32_t i = 0; for (uint32_t p : vec) { EXPECT_EQ(p, result[i]); i++; } } TEST(SmallVectorTest, Initialize_iterators2) { SmallVector vec = {0, 1, 2, 3}; EXPECT_EQ(vec.size(), 4); uint32_t result[] = {0, 1, 2, 3}; uint32_t i = 0; for (uint32_t p : vec) { EXPECT_EQ(p, result[i]); i++; } } TEST(SmallVectorTest, Initialize_iterators3) { SmallVector vec = {0, 1, 2, 3}; EXPECT_EQ(vec.size(), 4); uint32_t result[] = {0, 1, 2, 3}; uint32_t i = 0; for (SmallVector::iterator it = vec.begin(); it != vec.end(); ++it) { EXPECT_EQ(*it, result[i]); i++; } } TEST(SmallVectorTest, Initialize_iterators4) { SmallVector vec = {0, 1, 2, 3}; EXPECT_EQ(vec.size(), 4); uint32_t result[] = {0, 1, 2, 3}; uint32_t i = 0; for (SmallVector::iterator it = vec.begin(); it != vec.end(); ++it) { EXPECT_EQ(*it, result[i]); i++; } } TEST(SmallVectorTest, Initialize_iterators_write1) { SmallVector vec = {0, 1, 2, 3}; EXPECT_EQ(vec.size(), 4); for (SmallVector::iterator it = vec.begin(); it != vec.end(); ++it) { *it *= 2; } uint32_t result[] = {0, 2, 4, 6}; uint32_t i = 0; for (SmallVector::iterator it = vec.begin(); it != vec.end(); ++it) { EXPECT_EQ(*it, result[i]); i++; } } TEST(SmallVectorTest, Initialize_iterators_write2) { SmallVector vec = {0, 1, 2, 3}; EXPECT_EQ(vec.size(), 4); for (SmallVector::iterator it = vec.begin(); it != vec.end(); ++it) { *it *= 2; } uint32_t result[] = {0, 2, 4, 6}; uint32_t i = 0; for (SmallVector::iterator it = vec.begin(); it != vec.end(); ++it) { EXPECT_EQ(*it, result[i]); i++; } } TEST(SmallVectorTest, Initialize_front) { SmallVector vec = {0, 1, 2, 3}; EXPECT_EQ(vec.front(), 0); for (SmallVector::iterator it = vec.begin(); it != vec.end(); ++it) { *it += 2; } EXPECT_EQ(vec.front(), 2); } TEST(SmallVectorTest, Erase_element_front1) { SmallVector vec = {0, 1, 2, 3}; EXPECT_EQ(vec.front(), 0); EXPECT_EQ(vec.size(), 4); vec.erase(vec.begin()); EXPECT_EQ(vec.front(), 1); EXPECT_EQ(vec.size(), 3); } TEST(SmallVectorTest, Erase_element_front2) { SmallVector vec = {0, 1, 2, 3}; EXPECT_EQ(vec.front(), 0); EXPECT_EQ(vec.size(), 4); vec.erase(vec.begin()); EXPECT_EQ(vec.front(), 1); EXPECT_EQ(vec.size(), 3); } TEST(SmallVectorTest, Erase_element_back1) { SmallVector vec = {0, 1, 2, 3}; SmallVector result = {0, 1, 2}; EXPECT_EQ(vec[3], 3); EXPECT_EQ(vec.size(), 4); vec.erase(vec.begin() + 3); EXPECT_EQ(vec.size(), 3); EXPECT_EQ(vec, result); } TEST(SmallVectorTest, Erase_element_back2) { SmallVector vec = {0, 1, 2, 3}; SmallVector result = {0, 1, 2}; EXPECT_EQ(vec[3], 3); EXPECT_EQ(vec.size(), 4); vec.erase(vec.begin() + 3); EXPECT_EQ(vec.size(), 3); EXPECT_EQ(vec, result); } TEST(SmallVectorTest, Erase_element_middle1) { SmallVector vec = {0, 1, 2, 3}; SmallVector result = {0, 1, 3}; EXPECT_EQ(vec.size(), 4); vec.erase(vec.begin() + 2); EXPECT_EQ(vec.size(), 3); EXPECT_EQ(vec, result); } TEST(SmallVectorTest, Erase_element_middle2) { SmallVector vec = {0, 1, 2, 3}; SmallVector result = {0, 1, 3}; EXPECT_EQ(vec.size(), 4); vec.erase(vec.begin() + 2); EXPECT_EQ(vec.size(), 3); EXPECT_EQ(vec, result); } TEST(SmallVectorTest, Erase_range_1) { SmallVector vec = {0, 1, 2, 3}; SmallVector result = {}; EXPECT_EQ(vec.size(), 4); vec.erase(vec.begin(), vec.end()); EXPECT_EQ(vec.size(), 0); EXPECT_EQ(vec, result); } TEST(SmallVectorTest, Erase_range_2) { SmallVector vec = {0, 1, 2, 3}; SmallVector result = {}; EXPECT_EQ(vec.size(), 4); vec.erase(vec.begin(), vec.end()); EXPECT_EQ(vec.size(), 0); EXPECT_EQ(vec, result); } TEST(SmallVectorTest, Erase_range_3) { SmallVector vec = {0, 1, 2, 3}; SmallVector result = {2, 3}; EXPECT_EQ(vec.size(), 4); vec.erase(vec.begin(), vec.begin() + 2); EXPECT_EQ(vec.size(), 2); EXPECT_EQ(vec, result); } TEST(SmallVectorTest, Erase_range_4) { SmallVector vec = {0, 1, 2, 3}; SmallVector result = {2, 3}; EXPECT_EQ(vec.size(), 4); vec.erase(vec.begin(), vec.begin() + 2); EXPECT_EQ(vec.size(), 2); EXPECT_EQ(vec, result); } TEST(SmallVectorTest, Erase_range_5) { SmallVector vec = {0, 1, 2, 3}; SmallVector result = {0, 3}; EXPECT_EQ(vec.size(), 4); vec.erase(vec.begin() + 1, vec.begin() + 3); EXPECT_EQ(vec.size(), 2); EXPECT_EQ(vec, result); } TEST(SmallVectorTest, Erase_range_6) { SmallVector vec = {0, 1, 2, 3}; SmallVector result = {0, 3}; EXPECT_EQ(vec.size(), 4); vec.erase(vec.begin() + 1, vec.begin() + 3); EXPECT_EQ(vec.size(), 2); EXPECT_EQ(vec, result); } TEST(SmallVectorTest, Push_back) { SmallVector vec; SmallVector result = {0, 1, 2, 3}; EXPECT_EQ(vec.size(), 0); vec.push_back(0); EXPECT_EQ(vec.size(), 1); vec.push_back(1); EXPECT_EQ(vec.size(), 2); vec.push_back(2); EXPECT_EQ(vec.size(), 3); vec.push_back(3); EXPECT_EQ(vec.size(), 4); EXPECT_EQ(vec, result); } TEST(SmallVectorTest, Emplace_back) { SmallVector vec; SmallVector result = {0, 1, 2, 3}; EXPECT_EQ(vec.size(), 0); vec.emplace_back(0); EXPECT_EQ(vec.size(), 1); vec.emplace_back(1); EXPECT_EQ(vec.size(), 2); vec.emplace_back(2); EXPECT_EQ(vec.size(), 3); vec.emplace_back(3); EXPECT_EQ(vec.size(), 4); EXPECT_EQ(vec, result); } TEST(SmallVectorTest, Clear) { SmallVector vec = {0, 1, 2, 3}; SmallVector result = {}; EXPECT_EQ(vec.size(), 4); vec.clear(); EXPECT_EQ(vec.size(), 0); EXPECT_EQ(vec, result); } TEST(SmallVectorTest, Insert1) { SmallVector vec = {}; SmallVector insert_values = {10, 11}; SmallVector result = {10, 11}; EXPECT_EQ(vec.size(), 0); auto ret = vec.insert(vec.begin(), insert_values.begin(), insert_values.end()); EXPECT_EQ(vec.size(), 2); EXPECT_EQ(vec, result); EXPECT_EQ(*ret, 10); } TEST(SmallVectorTest, Insert2) { SmallVector vec = {}; SmallVector insert_values = {10, 11, 12}; SmallVector result = {10, 11, 12}; EXPECT_EQ(vec.size(), 0); auto ret = vec.insert(vec.begin(), insert_values.begin(), insert_values.end()); EXPECT_EQ(vec.size(), 3); EXPECT_EQ(vec, result); EXPECT_EQ(*ret, 10); } TEST(SmallVectorTest, Insert3) { SmallVector vec = {0}; SmallVector insert_values = {10, 11, 12}; SmallVector result = {10, 11, 12, 0}; EXPECT_EQ(vec.size(), 1); auto ret = vec.insert(vec.begin(), insert_values.begin(), insert_values.end()); EXPECT_EQ(vec.size(), 4); EXPECT_EQ(vec, result); EXPECT_EQ(*ret, 10); } TEST(SmallVectorTest, Insert4) { SmallVector vec = {0}; SmallVector insert_values = {10, 11, 12}; SmallVector result = {10, 11, 12, 0}; EXPECT_EQ(vec.size(), 1); auto ret = vec.insert(vec.begin(), insert_values.begin(), insert_values.end()); EXPECT_EQ(vec.size(), 4); EXPECT_EQ(vec, result); EXPECT_EQ(*ret, 10); } TEST(SmallVectorTest, Insert5) { SmallVector vec = {0, 1, 2}; SmallVector insert_values = {10, 11, 12}; SmallVector result = {0, 1, 2, 10, 11, 12}; EXPECT_EQ(vec.size(), 3); auto ret = vec.insert(vec.end(), insert_values.begin(), insert_values.end()); EXPECT_EQ(vec.size(), 6); EXPECT_EQ(vec, result); EXPECT_EQ(*ret, 10); } TEST(SmallVectorTest, Insert6) { SmallVector vec = {0, 1, 2}; SmallVector insert_values = {10, 11, 12}; SmallVector result = {0, 1, 2, 10, 11, 12}; EXPECT_EQ(vec.size(), 3); auto ret = vec.insert(vec.end(), insert_values.begin(), insert_values.end()); EXPECT_EQ(vec.size(), 6); EXPECT_EQ(vec, result); EXPECT_EQ(*ret, 10); } TEST(SmallVectorTest, Insert7) { SmallVector vec = {0, 1, 2}; SmallVector insert_values = {10, 11, 12}; SmallVector result = {0, 10, 11, 12, 1, 2}; EXPECT_EQ(vec.size(), 3); auto ret = vec.insert(vec.begin() + 1, insert_values.begin(), insert_values.end()); EXPECT_EQ(vec.size(), 6); EXPECT_EQ(vec, result); EXPECT_EQ(*ret, 10); } TEST(SmallVectorTest, Insert8) { SmallVector vec = {0, 1, 2}; SmallVector insert_values = {10, 11, 12}; SmallVector result = {0, 10, 11, 12, 1, 2}; EXPECT_EQ(vec.size(), 3); auto ret = vec.insert(vec.begin() + 1, insert_values.begin(), insert_values.end()); EXPECT_EQ(vec.size(), 6); EXPECT_EQ(vec, result); EXPECT_EQ(*ret, 10); } TEST(SmallVectorTest, Resize1) { SmallVector vec = {0, 1, 2}; SmallVector result = {0, 1, 2, 10, 10, 10}; EXPECT_EQ(vec.size(), 3); vec.resize(6, 10); EXPECT_EQ(vec.size(), 6); EXPECT_EQ(vec, result); } TEST(SmallVectorTest, Resize2) { SmallVector vec = {0, 1, 2}; SmallVector result = {0, 1, 2, 10, 10, 10}; EXPECT_EQ(vec.size(), 3); vec.resize(6, 10); EXPECT_EQ(vec.size(), 6); EXPECT_EQ(vec, result); } TEST(SmallVectorTest, Resize3) { SmallVector vec = {0, 1, 2}; SmallVector result = {0, 1, 2, 10, 10, 10}; EXPECT_EQ(vec.size(), 3); vec.resize(6, 10); EXPECT_EQ(vec.size(), 6); EXPECT_EQ(vec, result); } TEST(SmallVectorTest, Resize4) { SmallVector vec = {0, 1, 2, 10, 10, 10}; SmallVector result = {0, 1, 2}; EXPECT_EQ(vec.size(), 6); vec.resize(3, 10); EXPECT_EQ(vec.size(), 3); EXPECT_EQ(vec, result); } TEST(SmallVectorTest, Resize5) { SmallVector vec = {0, 1, 2, 10, 10, 10}; SmallVector result = {0, 1, 2}; EXPECT_EQ(vec.size(), 6); vec.resize(3, 10); EXPECT_EQ(vec.size(), 3); EXPECT_EQ(vec, result); } TEST(SmallVectorTest, Resize6) { SmallVector vec = {0, 1, 2, 10, 10, 10}; SmallVector result = {0, 1, 2}; EXPECT_EQ(vec.size(), 6); vec.resize(3, 10); EXPECT_EQ(vec.size(), 3); EXPECT_EQ(vec, result); } TEST(SmallVectorTest, Pop_back) { SmallVector vec = {0, 1, 2, 10, 10, 10}; SmallVector result = {0, 1, 2}; EXPECT_EQ(vec.size(), 6); vec.pop_back(); vec.pop_back(); vec.pop_back(); EXPECT_EQ(vec.size(), 3); EXPECT_EQ(vec, result); } TEST(SmallVectorTest, Pop_back_TestDestructor) { // Tracks number of constructions and destructions to ensure they are called. struct TracksDtor { TracksDtor& operator=(TracksDtor&&) = delete; TracksDtor& operator=(const TracksDtor&) = delete; TracksDtor(int& num_ctors, int& num_dtors) : num_ctors_(num_ctors), num_dtors_(num_dtors) { num_ctors_++; } TracksDtor(const TracksDtor& that) : TracksDtor(that.num_ctors_, that.num_dtors_) {} TracksDtor(TracksDtor&& that) : TracksDtor(that.num_ctors_, that.num_dtors_) {} ~TracksDtor() { num_dtors_++; } int& num_ctors_; int& num_dtors_; }; constexpr int capacity = 4; SmallVector vec; int num_ctors = 0; int num_dtors = 0; // Make sure it works when staying within the smallvector capacity for (int i = 0; i < capacity; ++i) { vec.emplace_back(num_ctors, num_dtors); } EXPECT_EQ(num_ctors, capacity); while (!vec.empty()) { vec.pop_back(); } EXPECT_EQ(num_ctors, capacity); EXPECT_EQ(num_dtors, num_ctors); // And when larger than builtin capacity for (int i = 0; i < capacity * 2; ++i) { vec.emplace_back(num_ctors, num_dtors); } while (!vec.empty()) { vec.pop_back(); } EXPECT_EQ(num_dtors, num_ctors); } } // namespace } // namespace utils } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/000077500000000000000000000000001475742701700202725ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/val/CMakeLists.txt000066400000000000000000000064501475742701700230370ustar00rootroot00000000000000# Copyright (c) 2016 The Khronos Group Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. set(VAL_TEST_COMMON_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/../test_fixture.h ${CMAKE_CURRENT_SOURCE_DIR}/../unit_spirv.h ${CMAKE_CURRENT_SOURCE_DIR}/val_code_generator.cpp ${CMAKE_CURRENT_SOURCE_DIR}/val_code_generator.h ${CMAKE_CURRENT_SOURCE_DIR}/val_fixtures.h ) add_spvtools_unittest(TARGET val_abcde SRCS val_adjacency_test.cpp val_annotation_test.cpp val_arithmetics_test.cpp val_atomics_test.cpp val_barriers_test.cpp val_bitwise_test.cpp val_builtins_test.cpp val_cfg_test.cpp val_composites_test.cpp val_constants_test.cpp val_conversion_test.cpp val_data_test.cpp val_decoration_test.cpp val_derivatives_test.cpp val_entry_point_test.cpp val_explicit_reserved_test.cpp val_extensions_test.cpp val_extension_spv_khr_expect_assume_test.cpp val_extension_spv_khr_linkonce_odr_test.cpp val_extension_spv_khr_subgroup_uniform_control_flow_test.cpp val_extension_spv_khr_integer_dot_product_test.cpp val_extension_spv_khr_bit_instructions_test.cpp val_extension_spv_khr_terminate_invocation_test.cpp val_extension_spv_khr_subgroup_rotate_test.cpp val_extension_spv_nv_raw_access_chains.cpp val_ext_inst_test.cpp val_ext_inst_debug_test.cpp ${VAL_TEST_COMMON_SRCS} LIBS ${SPIRV_TOOLS_FULL_VISIBILITY} PCH_FILE pch_test_val ) add_spvtools_unittest(TARGET val_capability SRCS val_capability_test.cpp LIBS ${SPIRV_TOOLS_FULL_VISIBILITY} PCH_FILE pch_test_val ) add_spvtools_unittest(TARGET val_limits SRCS val_limits_test.cpp ${VAL_TEST_COMMON_SRCS} LIBS ${SPIRV_TOOLS_FULL_VISIBILITY} PCH_FILE pch_test_val ) add_spvtools_unittest(TARGET val_fghijklmnop SRCS val_function_test.cpp val_id_test.cpp val_image_test.cpp val_interfaces_test.cpp val_layout_test.cpp val_literals_test.cpp val_logicals_test.cpp val_memory_test.cpp val_mesh_shading_test.cpp val_misc_test.cpp val_modes_test.cpp val_non_semantic_test.cpp val_non_uniform_test.cpp val_opencl_test.cpp val_primitives_test.cpp ${VAL_TEST_COMMON_SRCS} LIBS ${SPIRV_TOOLS_FULL_VISIBILITY} PCH_FILE pch_test_val ) add_spvtools_unittest(TARGET val_rstuvw SRCS val_ray_query_test.cpp val_ray_tracing_test.cpp val_ray_tracing_reorder_test.cpp val_small_type_uses_test.cpp val_ssa_test.cpp val_state_test.cpp val_storage_test.cpp val_type_unique_test.cpp val_validation_state_test.cpp val_version_test.cpp ${VAL_TEST_COMMON_SRCS} LIBS ${SPIRV_TOOLS_FULL_VISIBILITY} PCH_FILE pch_test_val ) KhronosGroup-SPIRV-Tools-f289d04/test/val/pch_test_val.cpp000066400000000000000000000011661475742701700234550ustar00rootroot00000000000000// Copyright (c) 2018 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "pch_test_val.h" KhronosGroup-SPIRV-Tools-f289d04/test/val/pch_test_val.h000066400000000000000000000013101475742701700231110ustar00rootroot00000000000000// Copyright (c) 2018 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gmock/gmock.h" #include "test/unit_spirv.h" #include "test/val/val_fixtures.h" KhronosGroup-SPIRV-Tools-f289d04/test/val/val_adjacency_test.cpp000066400000000000000000000462441475742701700246320ustar00rootroot00000000000000// Copyright (c) 2018 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gmock/gmock.h" #include "test/unit_spirv.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::HasSubstr; using ::testing::Not; using ValidateAdjacency = spvtest::ValidateBase; TEST_F(ValidateAdjacency, OpPhiBeginsModuleFail) { const std::string module = R"( %result = OpPhi %bool %true %true_label %false %false_label OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %false = OpConstantFalse %bool %func = OpTypeFunction %void %main = OpFunction %void None %func %main_entry = OpLabel OpBranch %true_label %true_label = OpLabel OpBranch %false_label %false_label = OpLabel OpBranch %end_label OpReturn OpFunctionEnd )"; CompileSuccessfully(module); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("ID '1[%bool]' has not been defined")); } TEST_F(ValidateAdjacency, OpLoopMergeEndsModuleFail) { const std::string module = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %func = OpTypeFunction %void %main = OpFunction %void None %func %main_entry = OpLabel OpBranch %loop %loop = OpLabel OpLoopMerge %end %loop None )"; CompileSuccessfully(module); EXPECT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing OpFunctionEnd at end of module")); } TEST_F(ValidateAdjacency, OpSelectionMergeEndsModuleFail) { const std::string module = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %func = OpTypeFunction %void %main = OpFunction %void None %func %main_entry = OpLabel OpBranch %merge %merge = OpLabel OpSelectionMerge %merge None )"; CompileSuccessfully(module); EXPECT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing OpFunctionEnd at end of module")); } std::string GenerateShaderCode( const std::string& body, const std::string& capabilities_and_extensions = "OpCapability Shader", const std::string& execution_model = "Fragment") { std::ostringstream ss; ss << capabilities_and_extensions << "\n"; ss << "OpMemoryModel Logical GLSL450\n"; ss << "OpEntryPoint " << execution_model << " %main \"main\"\n"; if (execution_model == "Fragment") { ss << "OpExecutionMode %main OriginUpperLeft\n"; } ss << R"( %string = OpString "" %void = OpTypeVoid %bool = OpTypeBool %int = OpTypeInt 32 0 %true = OpConstantTrue %bool %false = OpConstantFalse %bool %zero = OpConstant %int 0 %int_1 = OpConstant %int 1 %func = OpTypeFunction %void %func_int = OpTypePointer Function %int %main = OpFunction %void None %func %main_entry = OpLabel )"; ss << body; ss << R"( OpReturn OpFunctionEnd)"; return ss.str(); } TEST_F(ValidateAdjacency, OpPhiPreceededByOpLabelSuccess) { const std::string body = R"( OpSelectionMerge %end_label None OpBranchConditional %true %true_label %false_label %true_label = OpLabel OpBranch %end_label %false_label = OpLabel OpBranch %end_label %end_label = OpLabel OpLine %string 0 0 %result = OpPhi %bool %true %true_label %false %false_label )"; CompileSuccessfully(GenerateShaderCode(body)); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateAdjacency, OpPhiPreceededByOpPhiSuccess) { const std::string body = R"( OpSelectionMerge %end_label None OpBranchConditional %true %true_label %false_label %true_label = OpLabel OpBranch %end_label %false_label = OpLabel OpBranch %end_label %end_label = OpLabel %1 = OpPhi %bool %true %true_label %false %false_label %2 = OpPhi %bool %true %true_label %false %false_label )"; CompileSuccessfully(GenerateShaderCode(body)); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateAdjacency, OpPhiPreceededByOpLineSuccess) { const std::string body = R"( OpSelectionMerge %end_label None OpBranchConditional %true %true_label %false_label %true_label = OpLabel OpBranch %end_label %false_label = OpLabel OpBranch %end_label %end_label = OpLabel OpLine %string 0 0 %result = OpPhi %bool %true %true_label %false %false_label )"; CompileSuccessfully(GenerateShaderCode(body)); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateAdjacency, OpPhiPreceededByBadOpFail) { const std::string body = R"( OpSelectionMerge %end_label None OpBranchConditional %true %true_label %false_label %true_label = OpLabel OpBranch %end_label %false_label = OpLabel OpBranch %end_label %end_label = OpLabel OpNop %result = OpPhi %bool %true %true_label %false %false_label )"; CompileSuccessfully(GenerateShaderCode(body)); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpPhi must appear within a non-entry block before all " "non-OpPhi instructions")); } TEST_F(ValidateAdjacency, OpPhiPreceededByOpLineAndBadOpFail) { const std::string body = R"( OpSelectionMerge %end_label None OpBranchConditional %true %true_label %false_label %true_label = OpLabel OpBranch %end_label %false_label = OpLabel OpBranch %end_label %end_label = OpLabel OpNop OpLine %string 1 1 %result = OpPhi %bool %true %true_label %false %false_label )"; CompileSuccessfully(GenerateShaderCode(body)); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpPhi must appear within a non-entry block before all " "non-OpPhi instructions")); } TEST_F(ValidateAdjacency, OpPhiFollowedByOpLineGood) { const std::string body = R"( OpSelectionMerge %end_label None OpBranchConditional %true %true_label %false_label %true_label = OpLabel OpBranch %end_label %false_label = OpLabel OpBranch %end_label %end_label = OpLabel %result = OpPhi %bool %true %true_label %false %false_label OpLine %string 1 1 OpNop OpNop OpLine %string 2 1 OpNop OpLine %string 3 1 )"; CompileSuccessfully(GenerateShaderCode(body)); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateAdjacency, OpPhiMultipleOpLineAndOpPhiFail) { const std::string body = R"( OpSelectionMerge %end_label None OpBranchConditional %true %true_label %false_label %true_label = OpLabel OpBranch %end_label %false_label = OpLabel OpBranch %end_label %end_label = OpLabel OpLine %string 1 1 %value = OpPhi %int %zero %true_label %int_1 %false_label OpNop OpLine %string 2 1 OpNop OpLine %string 3 1 %result = OpPhi %bool %true %true_label %false %false_label )"; CompileSuccessfully(GenerateShaderCode(body)); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpPhi must appear within a non-entry block before all " "non-OpPhi instructions")); } TEST_F(ValidateAdjacency, OpPhiMultipleOpLineAndOpPhiGood) { const std::string body = R"( OpSelectionMerge %end_label None OpBranchConditional %true %true_label %false_label %true_label = OpLabel OpBranch %end_label %false_label = OpLabel OpBranch %end_label %end_label = OpLabel OpLine %string 1 1 %value = OpPhi %int %zero %true_label %int_1 %false_label OpLine %string 2 1 %result = OpPhi %bool %true %true_label %false %false_label OpLine %string 3 1 OpNop OpNop OpLine %string 4 1 OpNop )"; CompileSuccessfully(GenerateShaderCode(body)); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateAdjacency, OpPhiInEntryBlockBad) { const std::string body = R"( OpLine %string 1 1 %value = OpPhi %int OpLine %string 2 1 OpNop OpLine %string 3 1 OpNop )"; CompileSuccessfully(GenerateShaderCode(body)); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpPhi must appear within a non-entry block before all " "non-OpPhi instructions")); } TEST_F(ValidateAdjacency, NonSemanticBeforeOpPhiBad) { const std::string body = R"( OpSelectionMerge %end_label None OpBranchConditional %true %true_label %false_label %true_label = OpLabel OpBranch %end_label %false_label = OpLabel OpBranch %end_label %end_label = OpLabel %placeholder = OpExtInst %void %extinst 123 %int_1 %result = OpPhi %bool %true %true_label %false %false_label )"; const std::string extra = R"(OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %extinst = OpExtInstImport "NonSemantic.Testing.Set" )"; CompileSuccessfully(GenerateShaderCode(body, extra)); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpPhi must appear within a non-entry block before all " "non-OpPhi instructions")); } TEST_F(ValidateAdjacency, NonSemanticBetweenOpPhiBad) { const std::string body = R"( OpSelectionMerge %end_label None OpBranchConditional %true %true_label %false_label %true_label = OpLabel OpBranch %end_label %false_label = OpLabel OpBranch %end_label %end_label = OpLabel %result1 = OpPhi %bool %true %true_label %false %false_label %placeholder = OpExtInst %void %extinst 123 %int_1 %result2 = OpPhi %bool %true %true_label %false %false_label )"; const std::string extra = R"(OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %extinst = OpExtInstImport "NonSemantic.Testing.Set" )"; CompileSuccessfully(GenerateShaderCode(body, extra)); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpPhi must appear within a non-entry block before all " "non-OpPhi instructions")); } TEST_F(ValidateAdjacency, NonSemanticAfterOpPhiGood) { const std::string body = R"( OpSelectionMerge %end_label None OpBranchConditional %true %true_label %false_label %true_label = OpLabel OpBranch %end_label %false_label = OpLabel OpBranch %end_label %end_label = OpLabel OpLine %string 0 0 %result = OpPhi %bool %true %true_label %false %false_label %placeholder = OpExtInst %void %extinst 123 %int_1 )"; const std::string extra = R"(OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %extinst = OpExtInstImport "NonSemantic.Testing.Set" )"; CompileSuccessfully(GenerateShaderCode(body, extra)); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateAdjacency, NonSemanticBeforeOpFunctionParameterBad) { const std::string body = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %extinst = OpExtInstImport "NonSemantic.Testing.Set" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %string = OpString "" %void = OpTypeVoid %bool = OpTypeBool %int = OpTypeInt 32 0 %true = OpConstantTrue %bool %false = OpConstantFalse %bool %zero = OpConstant %int 0 %int_1 = OpConstant %int 1 %func = OpTypeFunction %void %func_int = OpTypePointer Function %int %paramfunc_type = OpTypeFunction %void %int %int %paramfunc = OpFunction %void None %paramfunc_type %placeholder = OpExtInst %void %extinst 123 %int_1 %a = OpFunctionParameter %int %b = OpFunctionParameter %int %paramfunc_entry = OpLabel OpReturn OpFunctionEnd %main = OpFunction %void None %func %main_entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(body); EXPECT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Non-semantic OpExtInst within function definition " "must appear in a block")); } TEST_F(ValidateAdjacency, NonSemanticBetweenOpFunctionParameterBad) { const std::string body = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %extinst = OpExtInstImport "NonSemantic.Testing.Set" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %string = OpString "" %void = OpTypeVoid %bool = OpTypeBool %int = OpTypeInt 32 0 %true = OpConstantTrue %bool %false = OpConstantFalse %bool %zero = OpConstant %int 0 %int_1 = OpConstant %int 1 %func = OpTypeFunction %void %func_int = OpTypePointer Function %int %paramfunc_type = OpTypeFunction %void %int %int %paramfunc = OpFunction %void None %paramfunc_type %a = OpFunctionParameter %int %placeholder = OpExtInst %void %extinst 123 %int_1 %b = OpFunctionParameter %int %paramfunc_entry = OpLabel OpReturn OpFunctionEnd %main = OpFunction %void None %func %main_entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(body); EXPECT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Non-semantic OpExtInst within function definition " "must appear in a block")); } TEST_F(ValidateAdjacency, NonSemanticAfterOpFunctionParameterGood) { const std::string body = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %extinst = OpExtInstImport "NonSemantic.Testing.Set" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %string = OpString "" %void = OpTypeVoid %bool = OpTypeBool %int = OpTypeInt 32 0 %true = OpConstantTrue %bool %false = OpConstantFalse %bool %zero = OpConstant %int 0 %int_1 = OpConstant %int 1 %func = OpTypeFunction %void %func_int = OpTypePointer Function %int %paramfunc_type = OpTypeFunction %void %int %int %paramfunc = OpFunction %void None %paramfunc_type %a = OpFunctionParameter %int %b = OpFunctionParameter %int %paramfunc_entry = OpLabel %placeholder = OpExtInst %void %extinst 123 %int_1 OpReturn OpFunctionEnd %main = OpFunction %void None %func %main_entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(body); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateAdjacency, NonSemanticBetweenFunctionsGood) { const std::string body = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %extinst = OpExtInstImport "NonSemantic.Testing.Set" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %string = OpString "" %void = OpTypeVoid %bool = OpTypeBool %int = OpTypeInt 32 0 %true = OpConstantTrue %bool %false = OpConstantFalse %bool %zero = OpConstant %int 0 %int_1 = OpConstant %int 1 %func = OpTypeFunction %void %func_int = OpTypePointer Function %int %paramfunc_type = OpTypeFunction %void %int %int %paramfunc = OpFunction %void None %paramfunc_type %a = OpFunctionParameter %int %b = OpFunctionParameter %int %paramfunc_entry = OpLabel OpReturn OpFunctionEnd %placeholder = OpExtInst %void %extinst 123 %int_1 %main = OpFunction %void None %func %main_entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(body); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateAdjacency, OpVariableInFunctionGood) { const std::string body = R"( OpLine %string 1 1 %var = OpVariable %func_int Function OpLine %string 2 1 OpNop OpLine %string 3 1 OpNop )"; CompileSuccessfully(GenerateShaderCode(body)); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateAdjacency, OpVariableInFunctionMultipleGood) { const std::string body = R"( OpLine %string 1 1 %1 = OpVariable %func_int Function OpLine %string 2 1 %2 = OpVariable %func_int Function %3 = OpVariable %func_int Function OpNop OpLine %string 3 1 OpNop )"; CompileSuccessfully(GenerateShaderCode(body)); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateAdjacency, OpVariableInFunctionBad) { const std::string body = R"( %1 = OpUndef %int %2 = OpVariable %func_int Function )"; CompileSuccessfully(GenerateShaderCode(body)); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("All OpVariable instructions in a function must be the " "first instructions")); } TEST_F(ValidateAdjacency, OpVariableInFunctionMultipleBad) { const std::string body = R"( OpNop %1 = OpVariable %func_int Function OpLine %string 1 1 %2 = OpVariable %func_int Function OpNop OpNop OpLine %string 2 1 %3 = OpVariable %func_int Function )"; CompileSuccessfully(GenerateShaderCode(body)); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("All OpVariable instructions in a function must be the " "first instructions")); } TEST_F(ValidateAdjacency, OpLoopMergePreceedsOpBranchSuccess) { const std::string body = R"( OpBranch %loop %loop = OpLabel OpLoopMerge %end %loop None OpBranch %loop %end = OpLabel )"; CompileSuccessfully(GenerateShaderCode(body)); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateAdjacency, OpLoopMergePreceedsOpBranchConditionalSuccess) { const std::string body = R"( OpBranch %loop %loop = OpLabel OpLoopMerge %end %loop None OpBranchConditional %true %loop %end %end = OpLabel )"; CompileSuccessfully(GenerateShaderCode(body)); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateAdjacency, OpLoopMergePreceedsBadOpFail) { const std::string body = R"( OpBranch %loop %loop = OpLabel OpLoopMerge %end %loop None OpNop OpBranchConditional %true %loop %end %end = OpLabel )"; CompileSuccessfully(GenerateShaderCode(body)); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpLoopMerge must immediately precede either an " "OpBranch or OpBranchConditional instruction.")); } TEST_F(ValidateAdjacency, OpSelectionMergePreceedsOpBranchConditionalSuccess) { const std::string body = R"( OpSelectionMerge %end_label None OpBranchConditional %true %true_label %false_label %true_label = OpLabel OpBranch %end_label %false_label = OpLabel OpBranch %end_label %end_label = OpLabel )"; CompileSuccessfully(GenerateShaderCode(body)); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateAdjacency, OpSelectionMergePreceedsOpSwitchSuccess) { const std::string body = R"( OpSelectionMerge %merge None OpSwitch %zero %merge 0 %label %label = OpLabel OpBranch %merge %merge = OpLabel )"; CompileSuccessfully(GenerateShaderCode(body)); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateAdjacency, OpSelectionMergePreceedsBadOpFail) { const std::string body = R"( OpSelectionMerge %merge None OpNop OpSwitch %zero %merge 0 %label %label = OpLabel OpBranch %merge %merge = OpLabel )"; CompileSuccessfully(GenerateShaderCode(body)); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpSelectionMerge must immediately precede either an " "OpBranchConditional or OpSwitch instruction")); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_annotation_test.cpp000066400000000000000000001031751475742701700250600ustar00rootroot00000000000000// Copyright (c) 2021 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validation tests for decorations #include #include #include "gmock/gmock.h" #include "test/unit_spirv.h" #include "test/val/val_code_generator.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::Combine; using ::testing::Eq; using ::testing::HasSubstr; using ::testing::Values; using DecorationTest = spvtest::ValidateBase; TEST_F(DecorationTest, WorkgroupSizeShader) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %ones BuiltIn WorkgroupSize %int = OpTypeInt 32 0 %int3 = OpTypeVector %int 3 %int_1 = OpConstant %int 1 %ones = OpConstantComposite %int3 %int_1 %int_1 %int_1 )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(DecorationTest, WorkgroupSizeKernel) { const std::string text = R"( OpCapability Kernel OpCapability Linkage OpMemoryModel Logical OpenCL OpDecorate %var BuiltIn WorkgroupSize %int = OpTypeInt 32 0 %int3 = OpTypeVector %int 3 %ptr = OpTypePointer Input %int3 %var = OpVariable %ptr Input )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(DecorationTest, FPFastMathModeInvalidMask) { const std::string text = R"( OpCapability Shader OpCapability FloatControls2 OpExtension "SPV_KHR_float_controls2" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %add FPFastMathMode !524288 %void = OpTypeVoid %float = OpTypeFloat 32 %undef = OpUndef %float %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %add = OpFAdd %float %undef %undef OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_BINARY, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Invalid floating-point fast math mode operand")); } TEST_F(DecorationTest, FPFastMathModeAllowTransformMissingAllowContract) { const std::string text = R"( OpCapability Shader OpCapability FloatControls2 OpExtension "SPV_KHR_float_controls2" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %add FPFastMathMode AllowTransform|AllowReassoc %void = OpTypeVoid %float = OpTypeFloat 32 %undef = OpUndef %float %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %add = OpFAdd %float %undef %undef OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("AllowReassoc and AllowContract must be specified when " "AllowTransform is specified")); } TEST_F(DecorationTest, FPFastMathModeAllowTransformMissingAllowReassoc) { const std::string text = R"( OpCapability Shader OpCapability FloatControls2 OpExtension "SPV_KHR_float_controls2" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %add FPFastMathMode AllowTransform|AllowContract %void = OpTypeVoid %float = OpTypeFloat 32 %undef = OpUndef %float %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %add = OpFAdd %float %undef %undef OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("AllowReassoc and AllowContract must be specified when " "AllowTransform is specified")); } TEST_F(DecorationTest, FPFastMathModeAllowTransformMissingContractAndReassoc) { const std::string text = R"( OpCapability Shader OpCapability FloatControls2 OpExtension "SPV_KHR_float_controls2" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %add FPFastMathMode AllowTransform %void = OpTypeVoid %float = OpTypeFloat 32 %undef = OpUndef %float %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %add = OpFAdd %float %undef %undef OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("AllowReassoc and AllowContract must be specified when " "AllowTransform is specified")); } TEST_F(DecorationTest, FPFastMathModeAndNoContraction) { const std::string text = R"( OpCapability Shader OpCapability FloatControls2 OpExtension "SPV_KHR_float_controls2" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %add FPFastMathMode None OpDecorate %add NoContraction %void = OpTypeVoid %float = OpTypeFloat 32 %undef = OpUndef %float %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %add = OpFAdd %float %undef %undef OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "FPFastMathMode and NoContraction cannot decorate the same target")); } TEST_F(DecorationTest, FPFastMathModeAndNoContraction2) { const std::string text = R"( OpCapability Shader OpCapability FloatControls2 OpExtension "SPV_KHR_float_controls2" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %add NoContraction OpDecorate %add FPFastMathMode None %void = OpTypeVoid %float = OpTypeFloat 32 %undef = OpUndef %float %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %add = OpFAdd %float %undef %undef OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "FPFastMathMode and NoContraction cannot decorate the same target")); } TEST_F(DecorationTest, RestrictOnUntypedPointer) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpCapability UntypedPointersKHR OpCapability SampleRateShading OpCapability TransformFeedback OpCapability GeometryStreams OpCapability Tessellation OpExtension "SPV_KHR_untyped_pointers" OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpDecorate %param Restrict %ptr = OpTypeUntypedPointerKHR StorageBuffer %void = OpTypeVoid %f_ty = OpTypeFunction %void %ptr %f = OpFunction %void None %f_ty %param = OpFunctionParameter %ptr %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(DecorationTest, ArrayStrideUntypedPointerKHR) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpDecorate %ptr ArrayStride 4 %ptr = OpTypeUntypedPointerKHR StorageBuffer )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } using MemberOnlyDecorations = spvtest::ValidateBase; TEST_P(MemberOnlyDecorations, MemberDecoration) { const auto deco = GetParam(); const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpMemberDecorate %struct 0 )" + deco + R"( %float = OpTypeFloat 32 %float2 = OpTypeVector %float 2 %float2x2 = OpTypeMatrix %float2 2 %struct = OpTypeStruct %float2x2 )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(MemberOnlyDecorations, Decoration) { const auto deco = GetParam(); const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %struct )" + deco + R"( %float = OpTypeFloat 32 %float2 = OpTypeVector %float 2 %float2x2 = OpTypeMatrix %float2 2 %struct = OpTypeStruct %float2x2 )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("can only be applied to structure members")); } INSTANTIATE_TEST_SUITE_P(ValidateMemberOnlyDecorations, MemberOnlyDecorations, Values("RowMajor", "ColMajor", "MatrixStride 16" // SPIR-V spec bug? /*,"Offset 0"*/)); using NonMemberOnlyDecorations = spvtest::ValidateBase; TEST_P(NonMemberOnlyDecorations, MemberDecoration) { const auto deco = GetParam(); const auto text = R"( OpCapability Shader OpCapability Kernel OpCapability Linkage OpCapability InputAttachment OpCapability Addresses OpCapability PhysicalStorageBufferAddresses OpCapability ShaderNonUniform OpExtension "SPV_KHR_no_integer_wrap_decoration" OpExtension "SPV_KHR_physical_storage_buffer" OpExtension "SPV_GOOGLE_hlsl_functionality1" OpExtension "SPV_EXT_descriptor_indexing" OpMemoryModel Logical GLSL450 OpMemberDecorate %struct 0 )" + deco + R"( %float = OpTypeFloat 32 %float2 = OpTypeVector %float 2 %float2x2 = OpTypeMatrix %float2 2 %struct = OpTypeStruct %float2x2 )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("cannot be applied to structure members")); } INSTANTIATE_TEST_SUITE_P( ValidateNonMemberOnlyDecorations, NonMemberOnlyDecorations, Values("SpecId 1", "Block", "BufferBlock", "ArrayStride 4", "GLSLShared", "GLSLPacked", "CPacked", // TODO: https://github.com/KhronosGroup/glslang/issues/703: // glslang applies Restrict to structure members. //"Restrict", "Aliased", "Constant", "Uniform", "SaturatedConversion", "Index 0", "Binding 0", "DescriptorSet 0", "FuncParamAttr Zext", "FPRoundingMode RTE", "FPFastMathMode None", "LinkageAttributes \"ext\" Import", "NoContraction", "InputAttachmentIndex 0", "Alignment 4", "MaxByteOffset 4", "AlignmentId %float", "MaxByteOffsetId %float", "NoSignedWrap", "NoUnsignedWrap", "NonUniform", "RestrictPointer", "AliasedPointer", "CounterBuffer %float")); using StructDecorations = spvtest::ValidateBase; TEST_P(StructDecorations, Struct) { const std::string deco = GetParam(); const std::string text = R"( OpCapability Shader OpCapability Kernel OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %struct )" + deco + R"( %struct = OpTypeStruct )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(StructDecorations, OtherType) { const std::string deco = GetParam(); const std::string text = R"( OpCapability Shader OpCapability Kernel OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %int )" + deco + R"( %int = OpTypeInt 32 0 )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be a structure type")); } TEST_P(StructDecorations, Variable) { const std::string deco = GetParam(); const std::string text = R"( OpCapability Shader OpCapability Kernel OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %var )" + deco + R"( %int = OpTypeInt 32 0 %ptr = OpTypePointer Private %int %var = OpVariable %ptr Private )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be a structure type")); } TEST_P(StructDecorations, FunctionParameter) { const auto deco = GetParam(); const std::string text = R"( OpCapability Shader OpCapability Kernel OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %func LinkageAttributes "import" Import OpDecorate %param )" + deco + R"( %int = OpTypeInt 32 0 %void = OpTypeVoid %fn = OpTypeFunction %void %int %func = OpFunction %void None %fn %param = OpFunctionParameter %int OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be a structure type")); } TEST_P(StructDecorations, Constant) { const std::string deco = GetParam(); const std::string text = R"( OpCapability Shader OpCapability Kernel OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %int_0 )" + deco + R"( %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be a structure type")); } INSTANTIATE_TEST_SUITE_P(ValidateStructDecorations, StructDecorations, Values("Block", "BufferBlock", "GLSLShared", "GLSLPacked", "CPacked")); using ArrayDecorations = spvtest::ValidateBase; TEST_P(ArrayDecorations, Array) { const auto deco = GetParam(); const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %array )" + deco + R"( %int = OpTypeInt 32 0 %int_4 = OpConstant %int 4 %array = OpTypeArray %int %int_4 )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ArrayDecorations, RuntimeArray) { const auto deco = GetParam(); const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %array )" + deco + R"( %int = OpTypeInt 32 0 %array = OpTypeRuntimeArray %int )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ArrayDecorations, Pointer) { const auto deco = GetParam(); const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %ptr )" + deco + R"( %int = OpTypeInt 32 0 %ptr = OpTypePointer Workgroup %int )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ArrayDecorations, Struct) { const auto deco = GetParam(); const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %struct )" + deco + R"( %int = OpTypeInt 32 0 %struct = OpTypeStruct %int )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be an array or pointer type")); } TEST_P(ArrayDecorations, Variable) { const auto deco = GetParam(); const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %var )" + deco + R"( %int = OpTypeInt 32 0 %ptr = OpTypePointer Private %int %var = OpVariable %ptr Private )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be an array or pointer type")); } TEST_P(ArrayDecorations, FunctionParameter) { const auto deco = GetParam(); const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %func LinkageAttributes "import" Import OpDecorate %param )" + deco + R"( %int = OpTypeInt 32 0 %void = OpTypeVoid %fn = OpTypeFunction %void %int %func = OpFunction %void None %fn %param = OpFunctionParameter %int OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be an array or pointer type")); } TEST_P(ArrayDecorations, Constant) { const auto deco = GetParam(); const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %null )" + deco + R"( %int = OpTypeInt 32 0 %int_4 = OpConstant %int 4 %array = OpTypeArray %int %int_4 %null = OpConstantNull %array )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be an array or pointer type")); } INSTANTIATE_TEST_SUITE_P(ValidateArrayDecorations, ArrayDecorations, Values("ArrayStride 4")); using BuiltInDecorations = spvtest::ValidateBase; TEST_P(BuiltInDecorations, Variable) { const auto deco = GetParam(); const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %var BuiltIn )" + deco + R"( %int = OpTypeInt 32 0 %ptr = OpTypePointer Input %int %var = OpVariable %ptr Input )"; CompileSuccessfully(text); if (deco != "WorkgroupSize") { EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } else { EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be a constant for WorkgroupSize")); } } TEST_P(BuiltInDecorations, IntegerType) { const auto deco = GetParam(); const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %int BuiltIn )" + deco + R"( %int = OpTypeInt 32 0 )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("BuiltIns can only target variables, structure members " "or constants")); } TEST_P(BuiltInDecorations, FunctionParameter) { const auto deco = GetParam(); const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %func LinkageAttributes "import" Import OpDecorate %param BuiltIn )" + deco + R"( %int = OpTypeInt 32 0 %void = OpTypeVoid %fn = OpTypeFunction %void %int %func = OpFunction %void None %fn %param = OpFunctionParameter %int OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("BuiltIns can only target variables, structure members " "or constants")); } TEST_P(BuiltInDecorations, Constant) { const auto deco = GetParam(); const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %const BuiltIn )" + deco + R"( %int = OpTypeInt 32 0 %int3 = OpTypeVector %int 3 %int_1 = OpConstant %int 1 %const = OpConstantComposite %int3 %int_1 %int_1 %int_1 )"; CompileSuccessfully(text); if (deco == "WorkgroupSize") { EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } else { EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be a variable")); } } TEST_P(BuiltInDecorations, SpecConstant) { const auto deco = GetParam(); const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %const BuiltIn )" + deco + R"( %int = OpTypeInt 32 0 %int3 = OpTypeVector %int 3 %int_1 = OpConstant %int 1 %const = OpSpecConstantComposite %int3 %int_1 %int_1 %int_1 )"; CompileSuccessfully(text); if (deco == "WorkgroupSize") { EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } else { EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be a variable")); } } INSTANTIATE_TEST_SUITE_P(ValidateBuiltInDecorations, BuiltInDecorations, Values("Position", "PointSize", "VertexId", "InstanceId", "FragCoord", "FrontFacing", "NumWorkgroups", "WorkgroupSize", "LocalInvocationId", "GlobalInvocationId")); using MemoryObjectDecorations = spvtest::ValidateBase; TEST_P(MemoryObjectDecorations, Variable) { const auto deco = GetParam(); const std::string text = R"( OpCapability Shader OpCapability Linkage OpCapability SampleRateShading OpCapability TransformFeedback OpCapability GeometryStreams OpCapability Tessellation OpCapability PhysicalStorageBufferAddresses OpExtension "SPV_KHR_physical_storage_buffer" OpMemoryModel Logical GLSL450 OpDecorate %var )" + deco + R"( %float = OpTypeFloat 32 %ptr = OpTypePointer Input %float %var = OpVariable %ptr Input )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(MemoryObjectDecorations, FunctionParameterGood) { const auto deco = GetParam(); const std::string text = R"( OpCapability Shader OpCapability Linkage OpCapability SampleRateShading OpCapability TransformFeedback OpCapability GeometryStreams OpCapability Tessellation OpCapability PhysicalStorageBufferAddresses OpExtension "SPV_KHR_physical_storage_buffer" OpMemoryModel Logical GLSL450 OpDecorate %func LinkageAttributes "import" Import OpDecorate %param )" + deco + R"( %float = OpTypeFloat 32 %ptr = OpTypePointer Input %float %void = OpTypeVoid %fn = OpTypeFunction %void %ptr %func = OpFunction %void None %fn %param = OpFunctionParameter %ptr OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(MemoryObjectDecorations, FunctionParameterNotAPointer) { const auto deco = GetParam(); const std::string text = R"( OpCapability Shader OpCapability Linkage OpCapability SampleRateShading OpCapability TransformFeedback OpCapability GeometryStreams OpCapability Tessellation OpCapability PhysicalStorageBufferAddresses OpExtension "SPV_KHR_physical_storage_buffer" OpMemoryModel Logical GLSL450 OpDecorate %func LinkageAttributes "import" Import OpDecorate %param )" + deco + R"( %float = OpTypeFloat 32 %void = OpTypeVoid %fn = OpTypeFunction %void %float %func = OpFunction %void None %fn %param = OpFunctionParameter %float OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be a pointer type")); } TEST_P(MemoryObjectDecorations, FloatType) { const auto deco = GetParam(); const std::string text = R"( OpCapability Shader OpCapability Linkage OpCapability SampleRateShading OpCapability TransformFeedback OpCapability GeometryStreams OpCapability Tessellation OpCapability PhysicalStorageBufferAddresses OpExtension "SPV_KHR_physical_storage_buffer" OpMemoryModel Logical GLSL450 OpDecorate %float )" + deco + R"( %float = OpTypeFloat 32 )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be a memory object declaration")); } TEST_P(MemoryObjectDecorations, Constant) { const auto deco = GetParam(); const std::string text = R"( OpCapability Shader OpCapability Linkage OpCapability SampleRateShading OpCapability TransformFeedback OpCapability GeometryStreams OpCapability Tessellation OpCapability PhysicalStorageBufferAddresses OpExtension "SPV_KHR_physical_storage_buffer" OpMemoryModel Logical GLSL450 OpDecorate %const )" + deco + R"( %float = OpTypeFloat 32 %const = OpConstant %float 0 )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be a memory object declaration")); } // NonWritable and NonReadable are covered by other tests. INSTANTIATE_TEST_SUITE_P( ValidateMemoryObjectDecorations, MemoryObjectDecorations, Values("NoPerspective", "Flat", "Patch", "Centroid", "Component 0", "Sample", "Restrict", "Aliased", "Volatile", "Coherent", "Stream 0", "XfbBuffer 1", "XfbStride 1", "AliasedPointer", "RestrictPointer")); using VariableDecorations = spvtest::ValidateBase; TEST_P(VariableDecorations, Variable) { const auto deco = GetParam(); const std::string text = R"( OpCapability Shader OpCapability Kernel OpCapability Linkage OpCapability InputAttachment OpMemoryModel Logical GLSL450 OpDecorate %var )" + deco + R"( %float = OpTypeFloat 32 %ptr = OpTypePointer Input %float %var = OpVariable %ptr Input )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(VariableDecorations, FunctionParameter) { const auto deco = GetParam(); const std::string text = R"( OpCapability Shader OpCapability Kernel OpCapability Linkage OpCapability InputAttachment OpMemoryModel Logical GLSL450 OpDecorate %func LinkageAttributes "import" Import OpDecorate %param )" + deco + R"( %float = OpTypeFloat 32 %void = OpTypeVoid %fn = OpTypeFunction %void %float %func = OpFunction %void None %fn %param = OpFunctionParameter %float OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be a variable")); } TEST_P(VariableDecorations, FloatType) { const auto deco = GetParam(); const std::string text = R"( OpCapability Shader OpCapability Kernel OpCapability Linkage OpCapability InputAttachment OpMemoryModel Logical GLSL450 OpDecorate %float )" + deco + R"( %float = OpTypeFloat 32 )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be a variable")); } TEST_P(VariableDecorations, Constant) { const auto deco = GetParam(); const std::string text = R"( OpCapability Shader OpCapability Kernel OpCapability Linkage OpCapability InputAttachment OpMemoryModel Logical GLSL450 OpDecorate %const )" + deco + R"( %float = OpTypeFloat 32 %const = OpConstant %float 0 )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be a variable")); } INSTANTIATE_TEST_SUITE_P(ValidateVariableDecorations, VariableDecorations, Values("Invariant", "Constant", "Location 0", "Index 0", "Binding 0", "DescriptorSet 0")); using VulkanIOStorageClass = spvtest::ValidateBase>; TEST_P(VulkanIOStorageClass, Invalid) { const auto deco = std::get<0>(GetParam()); const auto sc = std::get<1>(GetParam()); const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpDecorate %var )" + deco + R"( 0 %void = OpTypeVoid %float = OpTypeFloat 32 %ptr = OpTypePointer )" + sc + R"( %float %var = OpVariable %ptr )" + sc + R"( %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Location-06672")); EXPECT_THAT( getDiagnosticString(), HasSubstr("decoration must not be applied to this storage class")); } INSTANTIATE_TEST_SUITE_P(ValidateVulkanIOStorageClass, VulkanIOStorageClass, Combine(Values("Location", "Component"), Values("StorageBuffer", "Uniform", "UniformConstant", "Workgroup", "Private"))); using VulkanResourceStorageClass = spvtest::ValidateBase>; TEST_P(VulkanResourceStorageClass, Invalid) { const auto deco = std::get<0>(GetParam()); const auto sc = std::get<1>(GetParam()); const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpDecorate %var )" + deco + R"( 0 %void = OpTypeVoid %float = OpTypeFloat 32 %ptr = OpTypePointer )" + sc + R"( %float %var = OpVariable %ptr )" + sc + R"( %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("VUID-StandaloneSpirv-DescriptorSet-06491")); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be in the StorageBuffer, Uniform, or " "UniformConstant storage class")); } INSTANTIATE_TEST_SUITE_P(ValidateVulkanResourceStorageClass, VulkanResourceStorageClass, Combine(Values("DescriptorSet", "Binding"), Values("Private", "Input", "Output", "Workgroup"))); using VulkanInterpolationStorageClass = spvtest::ValidateBase; TEST_P(VulkanInterpolationStorageClass, Input) { const auto deco = GetParam(); const std::string text = R"( OpCapability Shader OpCapability SampleRateShading OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpDecorate %var )" + deco + R"( %void = OpTypeVoid %float = OpTypeFloat 32 %void_fn = OpTypeFunction %void %ptr = OpTypePointer Input %float %var = OpVariable %ptr Input %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_P(VulkanInterpolationStorageClass, Output) { const auto deco = GetParam(); const std::string text = R"( OpCapability Shader OpCapability SampleRateShading OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpDecorate %var )" + deco + R"( %void = OpTypeVoid %float = OpTypeFloat 32 %void_fn = OpTypeFunction %void %ptr = OpTypePointer Output %float %var = OpVariable %ptr Output %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_P(VulkanInterpolationStorageClass, Private) { const auto deco = GetParam(); const std::string text = R"( OpCapability Shader OpCapability SampleRateShading OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpDecorate %var )" + deco + R"( %void = OpTypeVoid %float = OpTypeFloat 32 %void_fn = OpTypeFunction %void %ptr = OpTypePointer Private %float %var = OpVariable %ptr Private %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("storage class must be Input or Output")); EXPECT_THAT(getDiagnosticString(), HasSubstr("[VUID-StandaloneSpirv-Flat-04670")); } TEST_P(VulkanInterpolationStorageClass, Uniform) { const auto deco = GetParam(); const std::string text = R"( OpCapability Shader OpCapability SampleRateShading OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpDecorate %var )" + deco + R"( OpDecorate %var Binding 0 OpDecorate %var DescriptorSet 0 %void = OpTypeVoid %float = OpTypeFloat 32 %void_fn = OpTypeFunction %void %ptr = OpTypePointer Uniform %float %var = OpVariable %ptr Uniform %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("storage class must be Input or Output")); EXPECT_THAT(getDiagnosticString(), HasSubstr("[VUID-StandaloneSpirv-Flat-04670")); } TEST_P(VulkanInterpolationStorageClass, StorageBuffer) { const auto deco = GetParam(); const std::string text = R"( OpCapability Shader OpCapability SampleRateShading OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpDecorate %var )" + deco + R"( OpDecorate %var Binding 0 OpDecorate %var DescriptorSet 0 %void = OpTypeVoid %float = OpTypeFloat 32 %void_fn = OpTypeFunction %void %ptr = OpTypePointer StorageBuffer %float %var = OpVariable %ptr StorageBuffer %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("storage class must be Input or Output")); EXPECT_THAT(getDiagnosticString(), HasSubstr("[VUID-StandaloneSpirv-Flat-04670")); } INSTANTIATE_TEST_SUITE_P(ValidateVulkanInterpolationStorageClass, VulkanInterpolationStorageClass, Values("Flat", "NoPerspective", "Centroid", "Sample")); } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_arithmetics_test.cpp000066400000000000000000002023541475742701700252210ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Tests for unique type declaration rules validator. #include #include "gmock/gmock.h" #include "test/unit_spirv.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::HasSubstr; using ::testing::Not; using ValidateArithmetics = spvtest::ValidateBase; std::string GenerateCode(const std::string& main_body) { const std::string prefix = R"( OpCapability Shader OpCapability Int64 OpCapability Float64 OpCapability Matrix %ext_inst = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f32 = OpTypeFloat 32 %u32 = OpTypeInt 32 0 %s32 = OpTypeInt 32 1 %f64 = OpTypeFloat 64 %u64 = OpTypeInt 64 0 %s64 = OpTypeInt 64 1 %boolvec2 = OpTypeVector %bool 2 %s32vec2 = OpTypeVector %s32 2 %u32vec2 = OpTypeVector %u32 2 %u64vec2 = OpTypeVector %u64 2 %f32vec2 = OpTypeVector %f32 2 %f64vec2 = OpTypeVector %f64 2 %boolvec3 = OpTypeVector %bool 3 %u32vec3 = OpTypeVector %u32 3 %u64vec3 = OpTypeVector %u64 3 %s32vec3 = OpTypeVector %s32 3 %f32vec3 = OpTypeVector %f32 3 %f64vec3 = OpTypeVector %f64 3 %boolvec4 = OpTypeVector %bool 4 %u32vec4 = OpTypeVector %u32 4 %u64vec4 = OpTypeVector %u64 4 %s32vec4 = OpTypeVector %s32 4 %f32vec4 = OpTypeVector %f32 4 %f64vec4 = OpTypeVector %f64 4 %f32mat22 = OpTypeMatrix %f32vec2 2 %f32mat23 = OpTypeMatrix %f32vec2 3 %f32mat32 = OpTypeMatrix %f32vec3 2 %f32mat33 = OpTypeMatrix %f32vec3 3 %f64mat22 = OpTypeMatrix %f64vec2 2 %struct_f32_f32 = OpTypeStruct %f32 %f32 %struct_u32_u32 = OpTypeStruct %u32 %u32 %struct_u32_u32_u32 = OpTypeStruct %u32 %u32 %u32 %struct_s32_s32 = OpTypeStruct %s32 %s32 %struct_s32_u32 = OpTypeStruct %s32 %u32 %struct_u32vec2_u32vec2 = OpTypeStruct %u32vec2 %u32vec2 %struct_s32vec2_s32vec2 = OpTypeStruct %s32vec2 %s32vec2 %f32_0 = OpConstant %f32 0 %f32_1 = OpConstant %f32 1 %f32_2 = OpConstant %f32 2 %f32_3 = OpConstant %f32 3 %f32_4 = OpConstant %f32 4 %f32_pi = OpConstant %f32 3.14159 %s32_0 = OpConstant %s32 0 %s32_1 = OpConstant %s32 1 %s32_2 = OpConstant %s32 2 %s32_3 = OpConstant %s32 3 %s32_4 = OpConstant %s32 4 %s32_m1 = OpConstant %s32 -1 %u32_0 = OpConstant %u32 0 %u32_1 = OpConstant %u32 1 %u32_2 = OpConstant %u32 2 %u32_3 = OpConstant %u32 3 %u32_4 = OpConstant %u32 4 %f64_0 = OpConstant %f64 0 %f64_1 = OpConstant %f64 1 %f64_2 = OpConstant %f64 2 %f64_3 = OpConstant %f64 3 %f64_4 = OpConstant %f64 4 %s64_0 = OpConstant %s64 0 %s64_1 = OpConstant %s64 1 %s64_2 = OpConstant %s64 2 %s64_3 = OpConstant %s64 3 %s64_4 = OpConstant %s64 4 %s64_m1 = OpConstant %s64 -1 %u64_0 = OpConstant %u64 0 %u64_1 = OpConstant %u64 1 %u64_2 = OpConstant %u64 2 %u64_3 = OpConstant %u64 3 %u64_4 = OpConstant %u64 4 %u32vec2_01 = OpConstantComposite %u32vec2 %u32_0 %u32_1 %u32vec2_12 = OpConstantComposite %u32vec2 %u32_1 %u32_2 %u32vec3_012 = OpConstantComposite %u32vec3 %u32_0 %u32_1 %u32_2 %u32vec3_123 = OpConstantComposite %u32vec3 %u32_1 %u32_2 %u32_3 %u32vec4_0123 = OpConstantComposite %u32vec4 %u32_0 %u32_1 %u32_2 %u32_3 %u32vec4_1234 = OpConstantComposite %u32vec4 %u32_1 %u32_2 %u32_3 %u32_4 %s32vec2_01 = OpConstantComposite %s32vec2 %s32_0 %s32_1 %s32vec2_12 = OpConstantComposite %s32vec2 %s32_1 %s32_2 %s32vec3_012 = OpConstantComposite %s32vec3 %s32_0 %s32_1 %s32_2 %s32vec3_123 = OpConstantComposite %s32vec3 %s32_1 %s32_2 %s32_3 %s32vec4_0123 = OpConstantComposite %s32vec4 %s32_0 %s32_1 %s32_2 %s32_3 %s32vec4_1234 = OpConstantComposite %s32vec4 %s32_1 %s32_2 %s32_3 %s32_4 %f32vec2_01 = OpConstantComposite %f32vec2 %f32_0 %f32_1 %f32vec2_12 = OpConstantComposite %f32vec2 %f32_1 %f32_2 %f32vec3_012 = OpConstantComposite %f32vec3 %f32_0 %f32_1 %f32_2 %f32vec3_123 = OpConstantComposite %f32vec3 %f32_1 %f32_2 %f32_3 %f32vec4_0123 = OpConstantComposite %f32vec4 %f32_0 %f32_1 %f32_2 %f32_3 %f32vec4_1234 = OpConstantComposite %f32vec4 %f32_1 %f32_2 %f32_3 %f32_4 %f64vec2_01 = OpConstantComposite %f64vec2 %f64_0 %f64_1 %f64vec2_12 = OpConstantComposite %f64vec2 %f64_1 %f64_2 %f64vec3_012 = OpConstantComposite %f64vec3 %f64_0 %f64_1 %f64_2 %f64vec3_123 = OpConstantComposite %f64vec3 %f64_1 %f64_2 %f64_3 %f64vec4_0123 = OpConstantComposite %f64vec4 %f64_0 %f64_1 %f64_2 %f64_3 %f64vec4_1234 = OpConstantComposite %f64vec4 %f64_1 %f64_2 %f64_3 %f64_4 %f32mat22_1212 = OpConstantComposite %f32mat22 %f32vec2_12 %f32vec2_12 %f32mat23_121212 = OpConstantComposite %f32mat23 %f32vec2_12 %f32vec2_12 %f32vec2_12 %f32mat32_123123 = OpConstantComposite %f32mat32 %f32vec3_123 %f32vec3_123 %f32mat33_123123123 = OpConstantComposite %f32mat33 %f32vec3_123 %f32vec3_123 %f32vec3_123 %f64mat22_1212 = OpConstantComposite %f64mat22 %f64vec2_12 %f64vec2_12 %main = OpFunction %void None %func %main_entry = OpLabel)"; const std::string suffix = R"( OpReturn OpFunctionEnd)"; return prefix + main_body + suffix; } TEST_F(ValidateArithmetics, F32Success) { const std::string body = R"( %val1 = OpFMul %f32 %f32_0 %f32_1 %val2 = OpFSub %f32 %f32_2 %f32_0 %val3 = OpFAdd %f32 %val1 %val2 %val4 = OpFNegate %f32 %val3 %val5 = OpFDiv %f32 %val4 %val1 %val6 = OpFRem %f32 %val4 %f32_2 %val7 = OpFMod %f32 %val4 %f32_2 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateArithmetics, F64Success) { const std::string body = R"( %val1 = OpFMul %f64 %f64_0 %f64_1 %val2 = OpFSub %f64 %f64_2 %f64_0 %val3 = OpFAdd %f64 %val1 %val2 %val4 = OpFNegate %f64 %val3 %val5 = OpFDiv %f64 %val4 %val1 %val6 = OpFRem %f64 %val4 %f64_2 %val7 = OpFMod %f64 %val4 %f64_2 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateArithmetics, Int32Success) { const std::string body = R"( %val1 = OpIMul %u32 %s32_0 %u32_1 %val2 = OpIMul %s32 %s32_2 %u32_1 %val3 = OpIAdd %u32 %val1 %val2 %val4 = OpIAdd %s32 %val1 %val2 %val5 = OpISub %u32 %val3 %val4 %val6 = OpISub %s32 %val4 %val3 %val7 = OpSDiv %s32 %val4 %val3 %val8 = OpSNegate %s32 %val7 %val9 = OpSRem %s32 %val4 %val3 %val10 = OpSMod %s32 %val4 %val3 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateArithmetics, Int64Success) { const std::string body = R"( %val1 = OpIMul %u64 %s64_0 %u64_1 %val2 = OpIMul %s64 %s64_2 %u64_1 %val3 = OpIAdd %u64 %val1 %val2 %val4 = OpIAdd %s64 %val1 %val2 %val5 = OpISub %u64 %val3 %val4 %val6 = OpISub %s64 %val4 %val3 %val7 = OpSDiv %s64 %val4 %val3 %val8 = OpSNegate %s64 %val7 %val9 = OpSRem %s64 %val4 %val3 %val10 = OpSMod %s64 %val4 %val3 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateArithmetics, F32Vec2Success) { const std::string body = R"( %val1 = OpFMul %f32vec2 %f32vec2_01 %f32vec2_12 %val2 = OpFSub %f32vec2 %f32vec2_12 %f32vec2_01 %val3 = OpFAdd %f32vec2 %val1 %val2 %val4 = OpFNegate %f32vec2 %val3 %val5 = OpFDiv %f32vec2 %val4 %val1 %val6 = OpFRem %f32vec2 %val4 %f32vec2_12 %val7 = OpFMod %f32vec2 %val4 %f32vec2_12 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateArithmetics, F64Vec2Success) { const std::string body = R"( %val1 = OpFMul %f64vec2 %f64vec2_01 %f64vec2_12 %val2 = OpFSub %f64vec2 %f64vec2_12 %f64vec2_01 %val3 = OpFAdd %f64vec2 %val1 %val2 %val4 = OpFNegate %f64vec2 %val3 %val5 = OpFDiv %f64vec2 %val4 %val1 %val6 = OpFRem %f64vec2 %val4 %f64vec2_12 %val7 = OpFMod %f64vec2 %val4 %f64vec2_12 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateArithmetics, U32Vec2Success) { const std::string body = R"( %val1 = OpIMul %u32vec2 %u32vec2_01 %u32vec2_12 %val2 = OpISub %u32vec2 %u32vec2_12 %u32vec2_01 %val3 = OpIAdd %u32vec2 %val1 %val2 %val4 = OpSNegate %u32vec2 %val3 %val5 = OpSDiv %u32vec2 %val4 %val1 %val6 = OpSRem %u32vec2 %val4 %u32vec2_12 %val7 = OpSMod %u32vec2 %val4 %u32vec2_12 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateArithmetics, FNegateTypeIdU32) { const std::string body = R"( %val = OpFNegate %u32 %u32_0 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected floating scalar or vector type as Result Type: FNegate")); } TEST_F(ValidateArithmetics, FNegateTypeIdVec2U32) { const std::string body = R"( %val = OpFNegate %u32vec2 %u32vec2_01 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected floating scalar or vector type as Result Type: FNegate")); } TEST_F(ValidateArithmetics, FNegateWrongOperand) { const std::string body = R"( %val = OpFNegate %f32 %u32_0 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected arithmetic operands to be of Result Type: " "FNegate operand index 2")); } TEST_F(ValidateArithmetics, FMulTypeIdU32) { const std::string body = R"( %val = OpFMul %u32 %u32_0 %u32_1 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected floating scalar or vector type as Result Type: FMul")); } TEST_F(ValidateArithmetics, FMulTypeIdVec2U32) { const std::string body = R"( %val = OpFMul %u32vec2 %u32vec2_01 %u32vec2_12 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected floating scalar or vector type as Result Type: FMul")); } TEST_F(ValidateArithmetics, FMulWrongOperand1) { const std::string body = R"( %val = OpFMul %f32 %u32_0 %f32_1 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected arithmetic operands to be of Result Type: " "FMul operand index 2")); } TEST_F(ValidateArithmetics, FMulWrongOperand2) { const std::string body = R"( %val = OpFMul %f32 %f32_0 %u32_1 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected arithmetic operands to be of Result Type: " "FMul operand index 3")); } TEST_F(ValidateArithmetics, FMulWrongVectorOperand1) { const std::string body = R"( %val = OpFMul %f64vec3 %f32vec3_123 %f64vec3_012 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected arithmetic operands to be of Result Type: " "FMul operand index 2")); } TEST_F(ValidateArithmetics, FMulWrongVectorOperand2) { const std::string body = R"( %val = OpFMul %f32vec3 %f32vec3_123 %f64vec3_012 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected arithmetic operands to be of Result Type: " "FMul operand index 3")); } TEST_F(ValidateArithmetics, IMulFloatTypeId) { const std::string body = R"( %val = OpIMul %f32 %u32_0 %s32_1 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected int scalar or vector type as Result Type: IMul")); } TEST_F(ValidateArithmetics, IMulFloatOperand1) { const std::string body = R"( %val = OpIMul %u32 %f32_0 %s32_1 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected int scalar or vector type as operand: " "IMul operand index 2")); } TEST_F(ValidateArithmetics, IMulFloatOperand2) { const std::string body = R"( %val = OpIMul %u32 %s32_0 %f32_1 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected int scalar or vector type as operand: " "IMul operand index 3")); } TEST_F(ValidateArithmetics, IMulWrongBitWidthOperand1) { const std::string body = R"( %val = OpIMul %u64 %u32_0 %s64_1 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected arithmetic operands to have the same bit width " "as Result Type: IMul operand index 2")); } TEST_F(ValidateArithmetics, IMulWrongBitWidthOperand2) { const std::string body = R"( %val = OpIMul %u32 %u32_0 %s64_1 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected arithmetic operands to have the same bit width " "as Result Type: IMul operand index 3")); } TEST_F(ValidateArithmetics, IMulWrongBitWidthVector) { const std::string body = R"( %val = OpIMul %u64vec3 %u32vec3_012 %u32vec3_123 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected arithmetic operands to have the same bit width " "as Result Type: IMul operand index 2")); } TEST_F(ValidateArithmetics, IMulVectorScalarOperand1) { const std::string body = R"( %val = OpIMul %u32vec2 %u32_0 %u32vec2_01 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected arithmetic operands to have the same dimension " "as Result Type: IMul operand index 2")); } TEST_F(ValidateArithmetics, IMulVectorScalarOperand2) { const std::string body = R"( %val = OpIMul %u32vec2 %u32vec2_01 %u32_0 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected arithmetic operands to have the same dimension " "as Result Type: IMul operand index 3")); } TEST_F(ValidateArithmetics, IMulScalarVectorOperand1) { const std::string body = R"( %val = OpIMul %s32 %u32vec2_01 %u32_0 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected arithmetic operands to have the same dimension " "as Result Type: IMul operand index 2")); } TEST_F(ValidateArithmetics, IMulScalarVectorOperand2) { const std::string body = R"( %val = OpIMul %u32 %u32_0 %s32vec2_01 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected arithmetic operands to have the same dimension " "as Result Type: IMul operand index 3")); } TEST_F(ValidateArithmetics, SNegateFloat) { const std::string body = R"( %val = OpSNegate %s32 %f32_1 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected int scalar or vector type as operand: " "SNegate operand index 2")); } TEST_F(ValidateArithmetics, UDivFloatType) { const std::string body = R"( %val = OpUDiv %f32 %u32_2 %u32_1 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected unsigned int scalar or vector type as Result Type: UDiv")); } TEST_F(ValidateArithmetics, UDivSignedIntType) { const std::string body = R"( %val = OpUDiv %s32 %u32_2 %u32_1 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected unsigned int scalar or vector type as Result Type: UDiv")); } TEST_F(ValidateArithmetics, UDivWrongOperand1) { const std::string body = R"( %val = OpUDiv %u64 %f64_2 %u64_1 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected arithmetic operands to be of Result Type: " "UDiv operand index 2")); } TEST_F(ValidateArithmetics, UDivWrongOperand2) { const std::string body = R"( %val = OpUDiv %u64 %u64_2 %u32_1 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected arithmetic operands to be of Result Type: " "UDiv operand index 3")); } TEST_F(ValidateArithmetics, DotSuccess) { const std::string body = R"( %val = OpDot %f32 %f32vec2_01 %f32vec2_12 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateArithmetics, DotWrongTypeId) { const std::string body = R"( %val = OpDot %u32 %u32vec2_01 %u32vec2_12 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected float scalar type as Result Type: Dot")); } TEST_F(ValidateArithmetics, DotNotVectorTypeOperand1) { const std::string body = R"( %val = OpDot %f32 %f32 %f32vec2_12 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Operand '6[%float]' cannot be a " "type")); } TEST_F(ValidateArithmetics, DotNotVectorTypeOperand2) { const std::string body = R"( %val = OpDot %f32 %f32vec3_012 %f32_1 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected float vector as operand: Dot operand index 3")); } TEST_F(ValidateArithmetics, DotWrongComponentOperand1) { const std::string body = R"( %val = OpDot %f64 %f32vec2_01 %f64vec2_12 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected component type to be equal to Result Type: " "Dot operand index 2")); } TEST_F(ValidateArithmetics, DotWrongComponentOperand2) { const std::string body = R"( %val = OpDot %f32 %f32vec2_01 %f64vec2_12 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected component type to be equal to Result Type: " "Dot operand index 3")); } TEST_F(ValidateArithmetics, DotDifferentVectorSize) { const std::string body = R"( %val = OpDot %f32 %f32vec2_01 %f32vec3_123 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected operands to have the same number of components: Dot")); } TEST_F(ValidateArithmetics, VectorTimesScalarSuccess) { const std::string body = R"( %val = OpVectorTimesScalar %f32vec2 %f32vec2_01 %f32_2 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateArithmetics, VectorTimesScalarWrongTypeId) { const std::string body = R"( %val = OpVectorTimesScalar %u32vec2 %f32vec2_01 %f32_2 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected float vector type as Result Type: " "VectorTimesScalar")); } TEST_F(ValidateArithmetics, VectorTimesScalarWrongVector) { const std::string body = R"( %val = OpVectorTimesScalar %f32vec2 %f32vec3_012 %f32_2 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected vector operand type to be equal to Result Type: " "VectorTimesScalar")); } TEST_F(ValidateArithmetics, VectorTimesScalarWrongScalar) { const std::string body = R"( %val = OpVectorTimesScalar %f32vec2 %f32vec2_01 %f64_2 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected scalar operand type to be equal to the component " "type of the vector operand: VectorTimesScalar")); } TEST_F(ValidateArithmetics, MatrixTimesScalarSuccess) { const std::string body = R"( %val = OpMatrixTimesScalar %f32mat22 %f32mat22_1212 %f32_2 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateArithmetics, MatrixTimesScalarWrongTypeId) { const std::string body = R"( %val = OpMatrixTimesScalar %f32vec2 %f32mat22_1212 %f32_2 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected float matrix type as Result Type: " "MatrixTimesScalar")); } TEST_F(ValidateArithmetics, MatrixTimesScalarWrongMatrix) { const std::string body = R"( %val = OpMatrixTimesScalar %f32mat22 %f32vec2_01 %f32_2 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected matrix operand type to be equal to Result Type: " "MatrixTimesScalar")); } TEST_F(ValidateArithmetics, MatrixTimesScalarWrongScalar) { const std::string body = R"( %val = OpMatrixTimesScalar %f32mat22 %f32mat22_1212 %f64_2 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected scalar operand type to be equal to the component " "type of the matrix operand: MatrixTimesScalar")); } TEST_F(ValidateArithmetics, VectorTimesMatrix2x22Success) { const std::string body = R"( %val = OpVectorTimesMatrix %f32vec2 %f32vec2_12 %f32mat22_1212 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateArithmetics, VectorTimesMatrix3x32Success) { const std::string body = R"( %val = OpVectorTimesMatrix %f32vec2 %f32vec3_123 %f32mat32_123123 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateArithmetics, VectorTimesMatrixWrongTypeId) { const std::string body = R"( %val = OpVectorTimesMatrix %f32mat22 %f32vec2_12 %f32mat22_1212 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected float vector type as Result Type: " "VectorTimesMatrix")); } TEST_F(ValidateArithmetics, VectorTimesMatrixNotFloatVector) { const std::string body = R"( %val = OpVectorTimesMatrix %f32vec2 %u32vec2_12 %f32mat22_1212 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected float vector type as left operand: " "VectorTimesMatrix")); } TEST_F(ValidateArithmetics, VectorTimesMatrixWrongVectorComponent) { const std::string body = R"( %val = OpVectorTimesMatrix %f32vec2 %f64vec2_12 %f32mat22_1212 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected component types of Result Type and vector to be equal: " "VectorTimesMatrix")); } TEST_F(ValidateArithmetics, VectorTimesMatrixWrongMatrix) { const std::string body = R"( %val = OpVectorTimesMatrix %f32vec2 %f32vec2_12 %f32vec2_12 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected float matrix type as right operand: " "VectorTimesMatrix")); } TEST_F(ValidateArithmetics, VectorTimesMatrixWrongMatrixComponent) { const std::string body = R"( %val = OpVectorTimesMatrix %f32vec2 %f32vec2_12 %f64mat22_1212 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected component types of Result Type and matrix to be equal: " "VectorTimesMatrix")); } TEST_F(ValidateArithmetics, VectorTimesMatrix2eq2x23Fail) { const std::string body = R"( %val = OpVectorTimesMatrix %f32vec2 %f32vec2_12 %f32mat23_121212 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected number of columns of the matrix to be equal to Result Type " "vector size: VectorTimesMatrix")); } TEST_F(ValidateArithmetics, VectorTimesMatrix2x32Fail) { const std::string body = R"( %val = OpVectorTimesMatrix %f32vec2 %f32vec2_12 %f32mat32_123123 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected number of rows of the matrix to be equal to the vector " "operand size: VectorTimesMatrix")); } TEST_F(ValidateArithmetics, MatrixTimesVector22x2Success) { const std::string body = R"( %val = OpMatrixTimesVector %f32vec2 %f32mat22_1212 %f32vec2_12 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateArithmetics, MatrixTimesVector23x3Success) { const std::string body = R"( %val = OpMatrixTimesVector %f32vec2 %f32mat23_121212 %f32vec3_123 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateArithmetics, MatrixTimesVectorWrongTypeId) { const std::string body = R"( %val = OpMatrixTimesVector %f32mat22 %f32mat22_1212 %f32vec2_12 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected float vector type as Result Type: " "MatrixTimesVector")); } TEST_F(ValidateArithmetics, MatrixTimesVectorWrongMatrix) { const std::string body = R"( %val = OpMatrixTimesVector %f32vec3 %f32vec3_123 %f32vec3_123 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected float matrix type as left operand: " "MatrixTimesVector")); } TEST_F(ValidateArithmetics, MatrixTimesVectorWrongMatrixCol) { const std::string body = R"( %val = OpMatrixTimesVector %f32vec3 %f32mat23_121212 %f32vec3_123 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected column type of the matrix to be equal to Result Type: " "MatrixTimesVector")); } TEST_F(ValidateArithmetics, MatrixTimesVectorWrongVector) { const std::string body = R"( %val = OpMatrixTimesVector %f32vec2 %f32mat22_1212 %u32vec2_12 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected float vector type as right operand: " "MatrixTimesVector")); } TEST_F(ValidateArithmetics, MatrixTimesVectorDifferentComponents) { const std::string body = R"( %val = OpMatrixTimesVector %f32vec2 %f32mat22_1212 %f64vec2_12 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected component types of the operands to be equal: " "MatrixTimesVector")); } TEST_F(ValidateArithmetics, MatrixTimesVector22x3Fail) { const std::string body = R"( %val = OpMatrixTimesVector %f32vec2 %f32mat22_1212 %f32vec3_123 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected number of columns of the matrix to be equal to the vector " "size: MatrixTimesVector")); } TEST_F(ValidateArithmetics, MatrixTimesMatrix22x22Success) { const std::string body = R"( %val = OpMatrixTimesMatrix %f32mat22 %f32mat22_1212 %f32mat22_1212 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateArithmetics, MatrixTimesMatrix23x32Success) { const std::string body = R"( %val = OpMatrixTimesMatrix %f32mat22 %f32mat23_121212 %f32mat32_123123 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateArithmetics, MatrixTimesMatrix33x33Success) { const std::string body = R"( %val = OpMatrixTimesMatrix %f32mat33 %f32mat33_123123123 %f32mat33_123123123 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateArithmetics, MatrixTimesMatrixWrongTypeId) { const std::string body = R"( %val = OpMatrixTimesMatrix %f32vec2 %f32mat22_1212 %f32mat22_1212 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected float matrix type as Result Type: MatrixTimesMatrix")); } TEST_F(ValidateArithmetics, MatrixTimesMatrixWrongLeftOperand) { const std::string body = R"( %val = OpMatrixTimesMatrix %f32mat22 %f32vec2_12 %f32mat22_1212 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected float matrix type as left operand: MatrixTimesMatrix")); } TEST_F(ValidateArithmetics, MatrixTimesMatrixWrongRightOperand) { const std::string body = R"( %val = OpMatrixTimesMatrix %f32mat22 %f32mat22_1212 %f32vec2_12 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected float matrix type as right operand: MatrixTimesMatrix")); } TEST_F(ValidateArithmetics, MatrixTimesMatrix32x23Fail) { const std::string body = R"( %val = OpMatrixTimesMatrix %f32mat22 %f32mat32_123123 %f32mat23_121212 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected column types of Result Type and left matrix to be equal: " "MatrixTimesMatrix")); } TEST_F(ValidateArithmetics, MatrixTimesMatrixDifferentComponents) { const std::string body = R"( %val = OpMatrixTimesMatrix %f32mat22 %f32mat22_1212 %f64mat22_1212 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected component types of Result Type and right " "matrix to be equal: " "MatrixTimesMatrix")); } TEST_F(ValidateArithmetics, MatrixTimesMatrix23x23Fail) { const std::string body = R"( %val = OpMatrixTimesMatrix %f32mat22 %f32mat23_121212 %f32mat23_121212 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected number of columns of Result Type and right " "matrix to be equal: " "MatrixTimesMatrix")); } TEST_F(ValidateArithmetics, MatrixTimesMatrix23x22Fail) { const std::string body = R"( %val = OpMatrixTimesMatrix %f32mat22 %f32mat23_121212 %f32mat22_1212 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected number of columns of left matrix and number " "of rows of right " "matrix to be equal: MatrixTimesMatrix")); } TEST_F(ValidateArithmetics, OuterProduct2x2Success) { const std::string body = R"( %val = OpOuterProduct %f32mat22 %f32vec2_12 %f32vec2_01 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateArithmetics, OuterProduct3x2Success) { const std::string body = R"( %val = OpOuterProduct %f32mat32 %f32vec3_123 %f32vec2_01 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateArithmetics, OuterProduct2x3Success) { const std::string body = R"( %val = OpOuterProduct %f32mat23 %f32vec2_01 %f32vec3_123 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateArithmetics, OuterProductWrongTypeId) { const std::string body = R"( %val = OpOuterProduct %f32vec2 %f32vec2_01 %f32vec3_123 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected float matrix type as Result Type: " "OuterProduct")); } TEST_F(ValidateArithmetics, OuterProductWrongLeftOperand) { const std::string body = R"( %val = OpOuterProduct %f32mat22 %f32vec3_123 %f32vec2_01 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected column type of Result Type to be equal to the type " "of the left operand: OuterProduct")); } TEST_F(ValidateArithmetics, OuterProductRightOperandNotFloatVector) { const std::string body = R"( %val = OpOuterProduct %f32mat22 %f32vec2_12 %u32vec2_01 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected float vector type as right operand: OuterProduct")); } TEST_F(ValidateArithmetics, OuterProductRightOperandWrongComponent) { const std::string body = R"( %val = OpOuterProduct %f32mat22 %f32vec2_12 %f64vec2_01 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected component types of the operands to be equal: " "OuterProduct")); } TEST_F(ValidateArithmetics, OuterProductRightOperandWrongDimension) { const std::string body = R"( %val = OpOuterProduct %f32mat22 %f32vec2_12 %f32vec3_123 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected number of columns of the matrix to be equal to the " "vector size of the right operand: OuterProduct")); } std::string GenerateCoopMatCode(const std::string& extra_types, const std::string& main_body) { const std::string prefix = R"( OpCapability Shader OpCapability Float16 OpCapability CooperativeMatrixNV OpExtension "SPV_NV_cooperative_matrix" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f16 = OpTypeFloat 16 %f32 = OpTypeFloat 32 %u32 = OpTypeInt 32 0 %s32 = OpTypeInt 32 1 %u32_8 = OpConstant %u32 8 %u32_16 = OpConstant %u32 16 %u32_4 = OpConstant %u32 4 %subgroup = OpConstant %u32 3 %f16mat = OpTypeCooperativeMatrixNV %f16 %subgroup %u32_8 %u32_8 %u32mat = OpTypeCooperativeMatrixNV %u32 %subgroup %u32_8 %u32_8 %s32mat = OpTypeCooperativeMatrixNV %s32 %subgroup %u32_8 %u32_8 %f16_1 = OpConstant %f16 1 %f32_1 = OpConstant %f32 1 %u32_1 = OpConstant %u32 1 %s32_1 = OpConstant %s32 1 %f16mat_1 = OpConstantComposite %f16mat %f16_1 %u32mat_1 = OpConstantComposite %u32mat %u32_1 %s32mat_1 = OpConstantComposite %s32mat %s32_1 %u32_c1 = OpSpecConstant %u32 1 %u32_c2 = OpSpecConstant %u32 2 %f16matc = OpTypeCooperativeMatrixNV %f16 %subgroup %u32_c1 %u32_c2 %f16matc_1 = OpConstantComposite %f16matc %f16_1 %mat16x4 = OpTypeCooperativeMatrixNV %f16 %subgroup %u32_16 %u32_4 %mat4x16 = OpTypeCooperativeMatrixNV %f16 %subgroup %u32_4 %u32_16 %mat16x16 = OpTypeCooperativeMatrixNV %f16 %subgroup %u32_16 %u32_16 %f16mat_16x4_1 = OpConstantComposite %mat16x4 %f16_1 %f16mat_4x16_1 = OpConstantComposite %mat4x16 %f16_1 %f16mat_16x16_1 = OpConstantComposite %mat16x16 %f16_1)"; const std::string func_begin = R"( %main = OpFunction %void None %func %main_entry = OpLabel)"; const std::string suffix = R"( OpReturn OpFunctionEnd)"; return prefix + extra_types + func_begin + main_body + suffix; } TEST_F(ValidateArithmetics, CoopMatSuccess) { const std::string body = R"( %val1 = OpFAdd %f16mat %f16mat_1 %f16mat_1 %val2 = OpFSub %f16mat %f16mat_1 %f16mat_1 %val3 = OpFDiv %f16mat %f16mat_1 %f16mat_1 %val4 = OpFNegate %f16mat %f16mat_1 %val5 = OpIAdd %u32mat %u32mat_1 %u32mat_1 %val6 = OpISub %u32mat %u32mat_1 %u32mat_1 %val7 = OpUDiv %u32mat %u32mat_1 %u32mat_1 %val8 = OpIAdd %s32mat %s32mat_1 %s32mat_1 %val9 = OpISub %s32mat %s32mat_1 %s32mat_1 %val10 = OpSDiv %s32mat %s32mat_1 %s32mat_1 %val11 = OpSNegate %s32mat %s32mat_1 %val12 = OpMatrixTimesScalar %f16mat %f16mat_1 %f16_1 %val13 = OpMatrixTimesScalar %u32mat %u32mat_1 %u32_1 %val14 = OpMatrixTimesScalar %s32mat %s32mat_1 %s32_1 %val15 = OpCooperativeMatrixMulAddNV %mat16x16 %f16mat_16x4_1 %f16mat_4x16_1 %f16mat_16x16_1 %val16 = OpCooperativeMatrixMulAddNV %f16matc %f16matc_1 %f16matc_1 %f16matc_1 )"; CompileSuccessfully(GenerateCoopMatCode("", body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateArithmetics, CoopMatFMulFail) { const std::string body = R"( %val1 = OpFMul %f16mat %f16mat_1 %f16mat_1 )"; CompileSuccessfully(GenerateCoopMatCode("", body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected floating scalar or vector type as Result Type: FMul")); } TEST_F(ValidateArithmetics, CoopMatMatrixTimesScalarMismatchFail) { const std::string body = R"( %val1 = OpMatrixTimesScalar %f16mat %f16mat_1 %f32_1 )"; CompileSuccessfully(GenerateCoopMatCode("", body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected scalar operand type to be equal to the component " "type of the matrix operand: MatrixTimesScalar")); } TEST_F(ValidateArithmetics, CoopMatScopeFail) { const std::string types = R"( %device = OpConstant %u32 1 %mat16x16_dv = OpTypeCooperativeMatrixNV %f16 %device %u32_16 %u32_16 %f16matdv_16x16_1 = OpConstantComposite %mat16x16_dv %f16_1 )"; const std::string body = R"( %val1 = OpCooperativeMatrixMulAddNV %mat16x16 %f16mat_16x4_1 %f16mat_4x16_1 %f16matdv_16x16_1 )"; CompileSuccessfully(GenerateCoopMatCode(types, body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Cooperative matrix scopes must match: CooperativeMatrixMulAddNV")); } TEST_F(ValidateArithmetics, CoopMatDimFail) { const std::string body = R"( %val1 = OpCooperativeMatrixMulAddNV %mat16x16 %f16mat_4x16_1 %f16mat_16x4_1 %f16mat_16x16_1 )"; CompileSuccessfully(GenerateCoopMatCode("", body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Cooperative matrix 'M' mismatch: CooperativeMatrixMulAddNV")); } TEST_F(ValidateArithmetics, CoopMatComponentTypeNotScalarNumeric) { const std::string types = R"( %bad = OpTypeCooperativeMatrixNV %bool %subgroup %u32_8 %u32_8 )"; CompileSuccessfully(GenerateCoopMatCode(types, "").c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpTypeCooperativeMatrix Component Type " "'4[%bool]' is not a scalar numerical type.")); } TEST_F(ValidateArithmetics, CoopMatScopeNotConstantInt) { const std::string types = R"( %bad = OpTypeCooperativeMatrixNV %f16 %f32_1 %u32_8 %u32_8 )"; CompileSuccessfully(GenerateCoopMatCode(types, "").c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpTypeCooperativeMatrix Scope '17[%float_1]' is not a " "constant instruction with scalar integer type.")); } TEST_F(ValidateArithmetics, CoopMatRowsNotConstantInt) { const std::string types = R"( %bad = OpTypeCooperativeMatrixNV %f16 %subgroup %f32_1 %u32_8 )"; CompileSuccessfully(GenerateCoopMatCode(types, "").c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpTypeCooperativeMatrix Rows '17[%float_1]' is not a " "constant instruction with scalar integer type.")); } TEST_F(ValidateArithmetics, CoopMatColumnsNotConstantInt) { const std::string types = R"( %bad = OpTypeCooperativeMatrixNV %f16 %subgroup %u32_8 %f32_1 )"; CompileSuccessfully(GenerateCoopMatCode(types, "").c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpTypeCooperativeMatrix Cols '17[%float_1]' is not a " "constant instruction with scalar integer type.")); } TEST_F(ValidateArithmetics, IAddCarrySuccess) { const std::string body = R"( %val1 = OpIAddCarry %struct_u32_u32 %u32_0 %u32_1 %val2 = OpIAddCarry %struct_u32vec2_u32vec2 %u32vec2_01 %u32vec2_12 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateArithmetics, IAddCarryResultTypeNotStruct) { const std::string body = R"( %val = OpIAddCarry %u32 %u32_0 %u32_1 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected a struct as Result Type: IAddCarry")); } TEST_F(ValidateArithmetics, IAddCarryResultTypeNotTwoMembers) { const std::string body = R"( %val = OpIAddCarry %struct_u32_u32_u32 %u32_0 %u32_1 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Result Type struct to have two members: IAddCarry")); } TEST_F(ValidateArithmetics, IAddCarryResultTypeMemberNotUnsignedInt) { const std::string body = R"( %val = OpIAddCarry %struct_s32_s32 %s32_0 %s32_1 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type struct member types to be " "unsigned integer scalar " "or vector: IAddCarry")); } TEST_F(ValidateArithmetics, IAddCarryWrongLeftOperand) { const std::string body = R"( %val = OpIAddCarry %struct_u32_u32 %s32_0 %u32_1 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected both operands to be of Result Type member " "type: IAddCarry")); } TEST_F(ValidateArithmetics, IAddCarryWrongRightOperand) { const std::string body = R"( %val = OpIAddCarry %struct_u32_u32 %u32_0 %s32_1 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected both operands to be of Result Type member " "type: IAddCarry")); } TEST_F(ValidateArithmetics, OpSMulExtendedSuccess) { const std::string body = R"( %val1 = OpSMulExtended %struct_u32_u32 %u32_0 %u32_1 %val2 = OpSMulExtended %struct_s32_s32 %s32_0 %s32_1 %val3 = OpSMulExtended %struct_u32vec2_u32vec2 %u32vec2_01 %u32vec2_12 %val4 = OpSMulExtended %struct_s32vec2_s32vec2 %s32vec2_01 %s32vec2_12 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateArithmetics, SMulExtendedResultTypeMemberNotInt) { const std::string body = R"( %val = OpSMulExtended %struct_f32_f32 %f32_0 %f32_1 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Result Type struct member types to be integer scalar " "or vector: SMulExtended")); } TEST_F(ValidateArithmetics, SMulExtendedResultTypeMembersNotIdentical) { const std::string body = R"( %val = OpSMulExtended %struct_s32_u32 %s32_0 %s32_1 )"; CompileSuccessfully(GenerateCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Result Type struct member types to be identical: " "SMulExtended")); } std::string GenerateCoopMatKHRCode(const std::string& extra_types, const std::string& main_body) { const std::string prefix = R"( OpCapability Shader OpCapability Float16 OpCapability CooperativeMatrixKHR OpCapability CooperativeMatrixReductionsNV OpCapability CooperativeMatrixPerElementOperationsNV OpExtension "SPV_KHR_cooperative_matrix" OpExtension "SPV_NV_cooperative_matrix2" OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f16 = OpTypeFloat 16 %f32 = OpTypeFloat 32 %u32 = OpTypeInt 32 0 %s32 = OpTypeInt 32 1 %u32_8 = OpConstant %u32 8 %u32_16 = OpConstant %u32 16 %u32_4 = OpConstant %u32 4 %subgroup = OpConstant %u32 3 %useA = OpConstant %u32 0 %useB = OpConstant %u32 1 %useC = OpConstant %u32 2 %f16matA = OpTypeCooperativeMatrixKHR %f16 %subgroup %u32_16 %u32_16 %useA %u32matA = OpTypeCooperativeMatrixKHR %u32 %subgroup %u32_16 %u32_16 %useA %s32matA = OpTypeCooperativeMatrixKHR %s32 %subgroup %u32_16 %u32_16 %useA %f16matB = OpTypeCooperativeMatrixKHR %f16 %subgroup %u32_16 %u32_16 %useB %u32matB = OpTypeCooperativeMatrixKHR %u32 %subgroup %u32_16 %u32_16 %useB %s32matB = OpTypeCooperativeMatrixKHR %s32 %subgroup %u32_16 %u32_16 %useB %f16matC = OpTypeCooperativeMatrixKHR %f16 %subgroup %u32_16 %u32_16 %useC %f32matC = OpTypeCooperativeMatrixKHR %f32 %subgroup %u32_16 %u32_16 %useC %u32matC = OpTypeCooperativeMatrixKHR %u32 %subgroup %u32_16 %u32_16 %useC %s32matC = OpTypeCooperativeMatrixKHR %s32 %subgroup %u32_16 %u32_16 %useC %f16_1 = OpConstant %f16 1 %f32_1 = OpConstant %f32 1 %u32_1 = OpConstant %u32 1 %s32_1 = OpConstant %s32 1 %f16mat_A_1 = OpConstantComposite %f16matA %f16_1 %u32mat_A_1 = OpConstantComposite %u32matA %u32_1 %s32mat_A_1 = OpConstantComposite %s32matA %s32_1 %f16mat_B_1 = OpConstantComposite %f16matB %f16_1 %u32mat_B_1 = OpConstantComposite %u32matB %u32_1 %s32mat_B_1 = OpConstantComposite %s32matB %s32_1 %f16mat_C_1 = OpConstantComposite %f16matC %f16_1 %u32mat_C_1 = OpConstantComposite %u32matC %u32_1 %s32mat_C_1 = OpConstantComposite %s32matC %s32_1 )"; const std::string func_begin = R"( %main = OpFunction %void None %func %main_entry = OpLabel)"; const std::string suffix = R"( OpReturn OpFunctionEnd)"; return prefix + extra_types + func_begin + main_body + suffix; } TEST_F(ValidateArithmetics, CoopMatKHRSuccess) { const std::string body = R"( %val1 = OpFAdd %f16matA %f16mat_A_1 %f16mat_A_1 %val2 = OpFSub %f16matA %f16mat_A_1 %f16mat_A_1 %val3 = OpFMul %f16matA %f16mat_A_1 %f16mat_A_1 %val4 = OpFDiv %f16matA %f16mat_A_1 %f16mat_A_1 %val5 = OpFNegate %f16matA %f16mat_A_1 %val6 = OpIAdd %u32matA %u32mat_A_1 %u32mat_A_1 %val7 = OpISub %u32matA %u32mat_A_1 %u32mat_A_1 %val8 = OpUDiv %u32matA %u32mat_A_1 %u32mat_A_1 %val9 = OpIAdd %s32matA %s32mat_A_1 %s32mat_A_1 %val10 = OpISub %s32matA %s32mat_A_1 %s32mat_A_1 %val11 = OpSDiv %s32matA %s32mat_A_1 %s32mat_A_1 %val12 = OpSNegate %s32matA %s32mat_A_1 %val13 = OpMatrixTimesScalar %f16matA %f16mat_A_1 %f16_1 %val14 = OpMatrixTimesScalar %u32matA %u32mat_A_1 %u32_1 %val15 = OpMatrixTimesScalar %s32matA %s32mat_A_1 %s32_1 %val16 = OpCooperativeMatrixMulAddKHR %f32matC %f16mat_A_1 %f16mat_B_1 %f16mat_C_1 %val17 = OpCooperativeMatrixMulAddKHR %s32matC %s32mat_A_1 %s32mat_B_1 %s32mat_C_1 MatrixASignedComponentsKHR|MatrixBSignedComponentsKHR|MatrixCSignedComponentsKHR|MatrixResultSignedComponentsKHR %val18 = OpCooperativeMatrixMulAddKHR %u32matC %u32mat_A_1 %u32mat_B_1 %u32mat_C_1 )"; CompileSuccessfully(GenerateCoopMatKHRCode("", body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateArithmetics, CoopMatMatrixKHRTimesScalarMismatchFail) { const std::string body = R"( %val1 = OpMatrixTimesScalar %f16matA %f16mat_A_1 %f32_1 )"; CompileSuccessfully(GenerateCoopMatKHRCode("", body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected scalar operand type to be equal to the component " "type of the matrix operand: MatrixTimesScalar")); } TEST_F(ValidateArithmetics, CoopMatKHRScopeFail) { const std::string types = R"( %device = OpConstant %u32 1 %mat16x16_dv = OpTypeCooperativeMatrixKHR %f16 %device %u32_16 %u32_16 %useC %f16matdv_16x16_1 = OpConstantComposite %mat16x16_dv %f16_1 )"; const std::string body = R"( %val1 = OpFAdd %f16matA %f16matdv_16x16_1 %f16mat_A_1 )"; CompileSuccessfully(GenerateCoopMatKHRCode(types, body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected scopes of Matrix and Result Type to be identical")); } TEST_F(ValidateArithmetics, CoopMatKHRDimFail) { const std::string types = R"( %mat16x4 = OpTypeCooperativeMatrixKHR %f16 %subgroup %u32_16 %u32_4 %useC %mat16x4_C_1 = OpConstantComposite %mat16x4 %f16_1 )"; const std::string body = R"( %val1 = OpCooperativeMatrixMulAddKHR %mat16x4 %f16mat_A_1 %f16mat_B_1 %mat16x4_C_1 )"; CompileSuccessfully(GenerateCoopMatKHRCode(types, body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Cooperative matrix 'N' mismatch: CooperativeMatrixMulAddKHR")); } TEST_F(ValidateArithmetics, CoopMat2ReduceSuccess) { const std::string extra_types = R"( %f16matC8 = OpTypeCooperativeMatrixKHR %f16 %subgroup %u32_8 %u32_8 %useC %f16matC16x8 = OpTypeCooperativeMatrixKHR %f16 %subgroup %u32_16 %u32_8 %useC %f16matC8x16 = OpTypeCooperativeMatrixKHR %f16 %subgroup %u32_8 %u32_16 %useC %functy = OpTypeFunction %f16 %f16 %f16 %reducefunc = OpFunction %f16 None %functy %x = OpFunctionParameter %f16 %y = OpFunctionParameter %f16 %entry2 = OpLabel %sum = OpFAdd %f16 %x %y OpReturnValue %sum OpFunctionEnd )"; const std::string body = R"( %val1 = OpCooperativeMatrixReduceNV %f16matC8 %f16mat_C_1 2x2 %reducefunc %val2 = OpCooperativeMatrixReduceNV %f16matC16x8 %f16mat_C_1 Row %reducefunc %val3 = OpCooperativeMatrixReduceNV %f16matC8x16 %f16mat_C_1 Column %reducefunc %val4 = OpCooperativeMatrixReduceNV %f16matC %f16mat_C_1 Row|Column %reducefunc %val5 = OpCooperativeMatrixReduceNV %f16matC8 %f16mat_C_1 Row|Column %reducefunc )"; CompileSuccessfully(GenerateCoopMatKHRCode(extra_types, body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateArithmetics, CoopMat2Reduce2x2DimFail) { const std::string extra_types = R"( %functy = OpTypeFunction %f16 %f16 %f16 %reducefunc = OpFunction %f16 None %functy %x = OpFunctionParameter %f16 %y = OpFunctionParameter %f16 %entry2 = OpLabel %sum = OpFAdd %f16 %x %y OpReturnValue %sum OpFunctionEnd )"; const std::string body = R"( %val1 = OpCooperativeMatrixReduceNV %f16matC %f16mat_C_1 2x2 %reducefunc )"; CompileSuccessfully(GenerateCoopMatKHRCode(extra_types, body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("For Reduce2x2, result rows/cols must be half of " "matrix rows/cols: CooperativeMatrixReduceNV")); } TEST_F(ValidateArithmetics, CoopMat2ReduceRowDimFail) { const std::string extra_types = R"( %f16matC8x16 = OpTypeCooperativeMatrixKHR %f16 %subgroup %u32_8 %u32_16 %useC %functy = OpTypeFunction %f16 %f16 %f16 %reducefunc = OpFunction %f16 None %functy %x = OpFunctionParameter %f16 %y = OpFunctionParameter %f16 %entry2 = OpLabel %sum = OpFAdd %f16 %x %y OpReturnValue %sum OpFunctionEnd )"; const std::string body = R"( %val1 = OpCooperativeMatrixReduceNV %f16matC8x16 %f16mat_C_1 Row %reducefunc )"; CompileSuccessfully(GenerateCoopMatKHRCode(extra_types, body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("For ReduceRow, result rows must match matrix rows: " "CooperativeMatrixReduceNV")); } TEST_F(ValidateArithmetics, CoopMat2ReduceColDimFail) { const std::string extra_types = R"( %f16matC16x8 = OpTypeCooperativeMatrixKHR %f16 %subgroup %u32_16 %u32_8 %useC %functy = OpTypeFunction %f16 %f16 %f16 %reducefunc = OpFunction %f16 None %functy %x = OpFunctionParameter %f16 %y = OpFunctionParameter %f16 %entry2 = OpLabel %sum = OpFAdd %f16 %x %y OpReturnValue %sum OpFunctionEnd )"; const std::string body = R"( %val1 = OpCooperativeMatrixReduceNV %f16matC16x8 %f16mat_C_1 Column %reducefunc )"; CompileSuccessfully(GenerateCoopMatKHRCode(extra_types, body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("For ReduceColumn, result cols must match matrix cols: " "CooperativeMatrixReduceNV")); } TEST_F(ValidateArithmetics, CoopMat2ReduceMaskFail) { const std::string extra_types = R"( %f16matC8 = OpTypeCooperativeMatrixKHR %f16 %subgroup %u32_8 %u32_8 %useC %functy = OpTypeFunction %f16 %f16 %f16 %reducefunc = OpFunction %f16 None %functy %x = OpFunctionParameter %f16 %y = OpFunctionParameter %f16 %entry2 = OpLabel %sum = OpFAdd %f16 %x %y OpReturnValue %sum OpFunctionEnd )"; const std::string body = R"( %val1 = OpCooperativeMatrixReduceNV %f16matC8 %f16mat_C_1 Row|Column|2x2 %reducefunc )"; CompileSuccessfully(GenerateCoopMatKHRCode(extra_types, body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Reduce 2x2 must not be used with Row/Column: " "CooperativeMatrixReduceNV")); } TEST_F(ValidateArithmetics, CoopMat2ReduceFuncTypeFail) { const std::string extra_types = R"( %functy = OpTypeFunction %f32 %f32 %f32 %reducefunc = OpFunction %f32 None %functy %x = OpFunctionParameter %f32 %y = OpFunctionParameter %f32 %entry2 = OpLabel %sum = OpFAdd %f32 %x %y OpReturnValue %sum OpFunctionEnd )"; const std::string body = R"( %val1 = OpCooperativeMatrixReduceNV %f16matC %f16mat_C_1 Row|Column %reducefunc )"; CompileSuccessfully(GenerateCoopMatKHRCode(extra_types, body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("CombineFunc return type and parameters must match " "matrix component type: CooperativeMatrixReduceNV")); } TEST_F(ValidateArithmetics, CoopMat2PerElementOpSuccess) { const std::string extra_types = R"( %functy = OpTypeFunction %f16 %u32 %u32 %f16 %functy2 = OpTypeFunction %f16 %u32 %u32 %f16 %u32 %elemfunc = OpFunction %f16 None %functy %row = OpFunctionParameter %u32 %col = OpFunctionParameter %u32 %el = OpFunctionParameter %f16 %entry2 = OpLabel OpReturnValue %el OpFunctionEnd %elemfunc2 = OpFunction %f16 None %functy2 %row2 = OpFunctionParameter %u32 %col2 = OpFunctionParameter %u32 %el2 = OpFunctionParameter %f16 %x = OpFunctionParameter %u32 %entry3 = OpLabel OpReturnValue %el2 OpFunctionEnd )"; const std::string body = R"( %val1 = OpCooperativeMatrixPerElementOpNV %f16matC %f16mat_C_1 %elemfunc %val2 = OpCooperativeMatrixPerElementOpNV %f16matC %f16mat_C_1 %elemfunc2 %f16_1 )"; CompileSuccessfully(GenerateCoopMatKHRCode(extra_types, body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateArithmetics, CoopMat2PerElementOpElemTyFail) { const std::string extra_types = R"( %functy = OpTypeFunction %f32 %u32 %u32 %f32 %elemfunc = OpFunction %f32 None %functy %row = OpFunctionParameter %u32 %col = OpFunctionParameter %u32 %el = OpFunctionParameter %f32 %entry2 = OpLabel OpReturnValue %el OpFunctionEnd )"; const std::string body = R"( %val1 = OpCooperativeMatrixPerElementOpNV %f16matC %f16mat_C_1 %elemfunc )"; CompileSuccessfully(GenerateCoopMatKHRCode(extra_types, body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must match matrix component type")); } TEST_F(ValidateArithmetics, CoopMat2PerElementOpRowTyFail) { const std::string extra_types = R"( %functy = OpTypeFunction %f16 %f16 %u32 %f16 %elemfunc = OpFunction %f16 None %functy %row = OpFunctionParameter %f16 %col = OpFunctionParameter %u32 %el = OpFunctionParameter %f16 %entry2 = OpLabel OpReturnValue %el OpFunctionEnd )"; const std::string body = R"( %val1 = OpCooperativeMatrixPerElementOpNV %f16matC %f16mat_C_1 %elemfunc )"; CompileSuccessfully(GenerateCoopMatKHRCode(extra_types, body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be a 32-bit integer")); } std::string GenerateCoopVecCode(const std::string& extra_types, const std::string& main_body) { const std::string prefix = R"( OpCapability Shader OpCapability Float16 OpCapability CooperativeVectorNV OpCapability ReplicatedCompositesEXT OpExtension "SPV_NV_cooperative_vector" OpExtension "SPV_EXT_replicated_composites" %ext_inst = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f16 = OpTypeFloat 16 %f32 = OpTypeFloat 32 %u32 = OpTypeInt 32 0 %s32 = OpTypeInt 32 1 %u32_8 = OpConstant %u32 8 %u32_16 = OpConstant %u32 16 %u32_4 = OpConstant %u32 4 %subgroup = OpConstant %u32 3 %f16vec = OpTypeCooperativeVectorNV %f16 %u32_8 %f16vec4 = OpTypeCooperativeVectorNV %f16 %u32_4 %u32vec = OpTypeCooperativeVectorNV %u32 %u32_8 %s32vec = OpTypeCooperativeVectorNV %s32 %u32_8 %f16_1 = OpConstant %f16 1 %f32_1 = OpConstant %f32 1 %u32_1 = OpConstant %u32 1 %s32_1 = OpConstant %s32 1 %f16vec4_1 = OpConstantComposite %f16vec4 %f16_1 %f16_1 %f16_1 %f16_1 %f16vec_1 = OpConstantComposite %f16vec %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %u32vec_1 = OpConstantComposite %u32vec %u32_1 %u32_1 %u32_1 %u32_1 %u32_1 %u32_1 %u32_1 %u32_1 %s32vec_1 = OpConstantComposite %s32vec %s32_1 %s32_1 %s32_1 %s32_1 %s32_1 %s32_1 %s32_1 %s32_1 %u32_c1 = OpSpecConstant %u32 1 %u32_c2 = OpSpecConstant %u32 2 %f16vecc = OpTypeCooperativeVectorNV %f16 %u32_c1 %f16vecc_1 = OpConstantCompositeReplicateEXT %f16vecc %f16_1 )"; const std::string func_begin = R"( %main = OpFunction %void None %func %main_entry = OpLabel)"; const std::string suffix = R"( OpReturn OpFunctionEnd)"; return prefix + extra_types + func_begin + main_body + suffix; } TEST_F(ValidateArithmetics, CoopVecSuccess) { const std::string body = R"( %val1 = OpFAdd %f16vec %f16vec_1 %f16vec_1 %val2 = OpFSub %f16vec %f16vec_1 %f16vec_1 %val3 = OpFDiv %f16vec %f16vec_1 %f16vec_1 %val4 = OpFNegate %f16vec %f16vec_1 %val5 = OpIAdd %u32vec %u32vec_1 %u32vec_1 %val6 = OpISub %u32vec %u32vec_1 %u32vec_1 %val7 = OpUDiv %u32vec %u32vec_1 %u32vec_1 %val8 = OpIAdd %s32vec %s32vec_1 %s32vec_1 %val9 = OpISub %s32vec %s32vec_1 %s32vec_1 %val10 = OpSDiv %s32vec %s32vec_1 %s32vec_1 %val11 = OpSNegate %s32vec %s32vec_1 %val12 = OpVectorTimesScalar %f16vec %f16vec_1 %f16_1 %val13 = OpExtInst %f16vec %ext_inst FMin %f16vec_1 %f16vec_1 %val14 = OpExtInst %f16vec %ext_inst FMax %f16vec_1 %f16vec_1 %val15 = OpExtInst %f16vec %ext_inst FClamp %f16vec_1 %f16vec_1 %f16vec_1 %val16 = OpExtInst %f16vec %ext_inst NClamp %f16vec_1 %f16vec_1 %f16vec_1 %val17 = OpExtInst %f16vec %ext_inst Step %f16vec_1 %f16vec_1 %val18 = OpExtInst %f16vec %ext_inst Exp %f16vec_1 %val19 = OpExtInst %f16vec %ext_inst Log %f16vec_1 %val20 = OpExtInst %f16vec %ext_inst Tanh %f16vec_1 %val21 = OpExtInst %f16vec %ext_inst Atan %f16vec_1 %val22 = OpExtInst %f16vec %ext_inst Fma %f16vec_1 %f16vec_1 %f16vec_1 %val23 = OpExtInst %u32vec %ext_inst UMin %u32vec_1 %u32vec_1 %val24 = OpExtInst %u32vec %ext_inst UMax %u32vec_1 %u32vec_1 %val25 = OpExtInst %u32vec %ext_inst UClamp %u32vec_1 %u32vec_1 %u32vec_1 %val26 = OpExtInst %s32vec %ext_inst SMin %s32vec_1 %s32vec_1 %val27 = OpExtInst %s32vec %ext_inst SMax %s32vec_1 %s32vec_1 %val28 = OpExtInst %s32vec %ext_inst SClamp %s32vec_1 %s32vec_1 %s32vec_1 %val29 = OpShiftRightLogical %u32vec %u32vec_1 %u32vec_1 %val30 = OpShiftRightArithmetic %u32vec %u32vec_1 %u32vec_1 %val31 = OpShiftLeftLogical %u32vec %u32vec_1 %u32vec_1 %val32 = OpBitwiseOr %u32vec %u32vec_1 %u32vec_1 %val33 = OpBitwiseXor %u32vec %u32vec_1 %u32vec_1 %val34 = OpBitwiseAnd %u32vec %u32vec_1 %u32vec_1 %val35 = OpNot %u32vec %u32vec_1 )"; CompileSuccessfully(GenerateCoopVecCode("", body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateArithmetics, CoopVecFMulPass) { const std::string body = R"( %val1 = OpFMul %f16vec %f16vec_1 %f16vec_1 )"; CompileSuccessfully(GenerateCoopVecCode("", body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateArithmetics, CoopVecVectorTimesScalarMismatchFail) { const std::string body = R"( %val1 = OpVectorTimesScalar %f16vec %f16vec_1 %f32_1 )"; CompileSuccessfully(GenerateCoopVecCode("", body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected scalar operand type to be equal to the component " "type of the vector operand: VectorTimesScalar")); } TEST_F(ValidateArithmetics, CoopVecDimFail) { const std::string body = R"( %val1 = OpFMul %f16vec %f16vec_1 %f16vec4_1 )"; CompileSuccessfully(GenerateCoopVecCode("", body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected number of components to be identical")); } TEST_F(ValidateArithmetics, CoopVecComponentTypeNotScalarNumeric) { const std::string types = R"( %bad = OpTypeCooperativeVectorNV %bool %u32_8 )"; CompileSuccessfully(GenerateCoopVecCode(types, "").c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpTypeCooperativeVectorNV Component Type " "'5[%bool]' is not a scalar numerical type.")); } TEST_F(ValidateArithmetics, CoopVecDimNotConstantInt) { const std::string types = R"( %bad = OpTypeCooperativeVectorNV %f16 %f32_1 )"; CompileSuccessfully(GenerateCoopVecCode(types, "").c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpTypeCooperativeVectorNV component count " "'19[%float_1]' is not a constant integer type")); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_atomics_test.cpp000066400000000000000000003073701475742701700243500ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gmock/gmock.h" #include "test/unit_spirv.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::HasSubstr; using ::testing::Not; using ValidateAtomics = spvtest::ValidateBase; std::string GenerateShaderCodeImpl( const std::string& body, const std::string& capabilities_and_extensions, const std::string& definitions, const std::string& memory_model, const std::string& execution) { std::ostringstream ss; ss << R"( OpCapability Shader )"; ss << capabilities_and_extensions; ss << "OpMemoryModel Logical " << memory_model << "\n"; ss << execution; ss << R"( %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f32 = OpTypeFloat 32 %u32 = OpTypeInt 32 0 %f32vec4 = OpTypeVector %f32 4 %f32_0 = OpConstant %f32 0 %f32_1 = OpConstant %f32 1 %u32_0 = OpConstant %u32 0 %u32_1 = OpConstant %u32 1 %f32vec4_0000 = OpConstantComposite %f32vec4 %f32_0 %f32_0 %f32_0 %f32_0 %cross_device = OpConstant %u32 0 %device = OpConstant %u32 1 %workgroup = OpConstant %u32 2 %subgroup = OpConstant %u32 3 %invocation = OpConstant %u32 4 %queuefamily = OpConstant %u32 5 %relaxed = OpConstant %u32 0 %acquire = OpConstant %u32 2 %release = OpConstant %u32 4 %acquire_release = OpConstant %u32 8 %acquire_and_release = OpConstant %u32 6 %sequentially_consistent = OpConstant %u32 16 %acquire_release_uniform_workgroup = OpConstant %u32 328 %f32_ptr = OpTypePointer Workgroup %f32 %f32_var = OpVariable %f32_ptr Workgroup %u32_ptr = OpTypePointer Workgroup %u32 %u32_var = OpVariable %u32_ptr Workgroup %f32vec4_ptr = OpTypePointer Workgroup %f32vec4 %f32vec4_var = OpVariable %f32vec4_ptr Workgroup %f32_ptr_function = OpTypePointer Function %f32 )"; ss << definitions; ss << R"( %main = OpFunction %void None %func %main_entry = OpLabel )"; ss << body; ss << R"( OpReturn OpFunctionEnd)"; return ss.str(); } std::string GenerateShaderCode( const std::string& body, const std::string& capabilities_and_extensions = "", const std::string& extra_defs = "", const std::string& memory_model = "GLSL450") { const std::string execution = R"( OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft )"; const std::string definitions = R"( %u64 = OpTypeInt 64 0 %s64 = OpTypeInt 64 1 %u64_1 = OpConstant %u64 1 %s64_1 = OpConstant %s64 1 %u64_ptr = OpTypePointer Workgroup %u64 %s64_ptr = OpTypePointer Workgroup %s64 %u64_var = OpVariable %u64_ptr Workgroup %s64_var = OpVariable %s64_ptr Workgroup )"; return GenerateShaderCodeImpl( body, "OpCapability Int64\n" + capabilities_and_extensions, definitions + extra_defs, memory_model, execution); } std::string GenerateShaderComputeCode( const std::string& body, const std::string& capabilities_and_extensions = "", const std::string& extra_defs = "", const std::string& memory_model = "GLSL450") { const std::string execution = R"( OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 32 1 1 )"; const std::string definitions = R"( %u64 = OpTypeInt 64 0 %s64 = OpTypeInt 64 1 %u64_1 = OpConstant %u64 1 %s64_1 = OpConstant %s64 1 %u64_ptr = OpTypePointer Workgroup %u64 %s64_ptr = OpTypePointer Workgroup %s64 %u64_var = OpVariable %u64_ptr Workgroup %s64_var = OpVariable %s64_ptr Workgroup )"; return GenerateShaderCodeImpl( body, "OpCapability Int64\n" + capabilities_and_extensions, definitions + extra_defs, memory_model, execution); } std::string GenerateKernelCode( const std::string& body, const std::string& capabilities_and_extensions = "") { std::ostringstream ss; ss << R"( OpCapability Addresses OpCapability Kernel OpCapability Linkage OpCapability Int64 )"; ss << capabilities_and_extensions; ss << R"( OpMemoryModel Physical32 OpenCL %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f32 = OpTypeFloat 32 %u32 = OpTypeInt 32 0 %u64 = OpTypeInt 64 0 %f32vec4 = OpTypeVector %f32 4 %f32_0 = OpConstant %f32 0 %f32_1 = OpConstant %f32 1 %u32_0 = OpConstant %u32 0 %u32_1 = OpConstant %u32 1 %u64_1 = OpConstant %u64 1 %f32vec4_0000 = OpConstantComposite %f32vec4 %f32_0 %f32_0 %f32_0 %f32_0 %cross_device = OpConstant %u32 0 %device = OpConstant %u32 1 %workgroup = OpConstant %u32 2 %subgroup = OpConstant %u32 3 %invocation = OpConstant %u32 4 %relaxed = OpConstant %u32 0 %acquire = OpConstant %u32 2 %release = OpConstant %u32 4 %acquire_release = OpConstant %u32 8 %acquire_and_release = OpConstant %u32 6 %sequentially_consistent = OpConstant %u32 16 %acquire_release_uniform_workgroup = OpConstant %u32 328 %acquire_release_atomic_counter_workgroup = OpConstant %u32 1288 %f32_ptr = OpTypePointer Workgroup %f32 %f32_var = OpVariable %f32_ptr Workgroup %u32_ptr = OpTypePointer Workgroup %u32 %u32_var = OpVariable %u32_ptr Workgroup %u64_ptr = OpTypePointer Workgroup %u64 %u64_var = OpVariable %u64_ptr Workgroup %f32vec4_ptr = OpTypePointer Workgroup %f32vec4 %f32vec4_var = OpVariable %f32vec4_ptr Workgroup %f32_ptr_function = OpTypePointer Function %f32 %f32_ptr_uniformconstant = OpTypePointer UniformConstant %f32 %f32_uc_var = OpVariable %f32_ptr_uniformconstant UniformConstant %f32_ptr_image = OpTypePointer Image %f32 %f32_im_var = OpVariable %f32_ptr_image Image %main = OpFunction %void None %func %main_entry = OpLabel )"; ss << body; ss << R"( OpReturn OpFunctionEnd)"; return ss.str(); } TEST_F(ValidateAtomics, AtomicLoadShaderSuccess) { const std::string body = R"( %val1 = OpAtomicLoad %u32 %u32_var %device %relaxed %val2 = OpAtomicLoad %u32 %u32_var %workgroup %acquire )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateAtomics, AtomicLoadKernelSuccess) { const std::string body = R"( %val1 = OpAtomicLoad %f32 %f32_var %device %relaxed %val2 = OpAtomicLoad %u32 %u32_var %workgroup %sequentially_consistent )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateAtomics, AtomicLoadInt64ShaderSuccess) { const std::string body = R"( %val1 = OpAtomicLoad %u64 %u64_var %subgroup %sequentially_consistent )"; CompileSuccessfully(GenerateShaderCode(body, "OpCapability Int64Atomics\n")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateAtomics, AtomicLoadInt64KernelSuccess) { const std::string body = R"( %val1 = OpAtomicLoad %u64 %u64_var %subgroup %acquire )"; CompileSuccessfully(GenerateKernelCode(body, "OpCapability Int64Atomics\n")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateAtomics, AtomicLoadInt32VulkanSuccess) { const std::string body = R"( %val1 = OpAtomicLoad %u32 %u32_var %device %relaxed %val2 = OpAtomicLoad %u32 %u32_var %workgroup %acquire %val3 = OpAtomicLoad %u32 %u32_var %invocation %relaxed )"; CompileSuccessfully(GenerateShaderComputeCode(body), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateAtomics, AtomicLoadVulkanWrongStorageClass) { const std::string body = R"( %val1 = OpAtomicLoad %u32 %u32_var %device %relaxed )"; CompileSuccessfully(GenerateShaderCode(body), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-None-04645")); EXPECT_THAT( getDiagnosticString(), HasSubstr("in Vulkan environment, Workgroup Storage Class is limited to " "MeshNV, TaskNV, and GLCompute execution model")); } TEST_F(ValidateAtomics, AtomicAddIntVulkanWrongType1) { const std::string body = R"( %val1 = OpAtomicIAdd %f32 %f32_var %device %relaxed %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicIAdd: " "expected Result Type to be integer scalar type")); } TEST_F(ValidateAtomics, AtomicAddIntVulkanWrongType2) { const std::string body = R"( %val1 = OpAtomicIAdd %f32vec4 %f32vec4_var %device %relaxed %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicIAdd: " "expected Result Type to be integer scalar type")); } TEST_F(ValidateAtomics, AtomicAddFloatVulkan) { const std::string body = R"( %val1 = OpAtomicFAddEXT %f32 %f32_var %device %relaxed %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_CAPABILITY, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Opcode AtomicFAddEXT requires one of these capabilities: " "AtomicFloat16VectorNV AtomicFloat32AddEXT AtomicFloat64AddEXT " "AtomicFloat16AddEXT")); } TEST_F(ValidateAtomics, AtomicMinFloatVulkan) { const std::string body = R"( %val1 = OpAtomicFMinEXT %f32 %f32_var %device %relaxed %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_CAPABILITY, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Opcode AtomicFMinEXT requires one of these capabilities: " "AtomicFloat16VectorNV AtomicFloat32MinMaxEXT " "AtomicFloat64MinMaxEXT AtomicFloat16MinMaxEXT")); } TEST_F(ValidateAtomics, AtomicMaxFloatVulkan) { const std::string body = R"( %val1 = OpAtomicFMaxEXT %f32 %f32_var %device %relaxed %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_CAPABILITY, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Opcode AtomicFMaxEXT requires one of these capabilities: " "AtomicFloat16VectorNV AtomicFloat32MinMaxEXT AtomicFloat64MinMaxEXT " "AtomicFloat16MinMaxEXT")); } TEST_F(ValidateAtomics, AtomicAddFloatVulkanWrongType1) { const std::string body = R"( %val1 = OpAtomicFAddEXT %f32vec4 %f32vec4_var %device %relaxed %f32_1 )"; const std::string extra = R"( OpCapability AtomicFloat32AddEXT OpExtension "SPV_EXT_shader_atomic_float_add" )"; CompileSuccessfully(GenerateShaderCode(body, extra), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicFAddEXT: " "expected Result Type to be float scalar type")); } TEST_F(ValidateAtomics, AtomicMinFloatVulkanWrongType1) { const std::string body = R"( %val1 = OpAtomicFMinEXT %f32vec4 %f32vec4_var %device %relaxed %f32_1 )"; const std::string extra = R"( OpCapability AtomicFloat32MinMaxEXT OpExtension "SPV_EXT_shader_atomic_float_min_max" )"; CompileSuccessfully(GenerateShaderCode(body, extra), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicFMinEXT: " "expected Result Type to be float scalar type")); } TEST_F(ValidateAtomics, AtomicMaxFloatVulkanWrongType1) { const std::string body = R"( %val1 = OpAtomicFMaxEXT %f32vec4 %f32vec4_var %device %relaxed %f32_1 )"; const std::string extra = R"( OpCapability AtomicFloat32MinMaxEXT OpExtension "SPV_EXT_shader_atomic_float_min_max" )"; CompileSuccessfully(GenerateShaderCode(body, extra), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicFMaxEXT: " "expected Result Type to be float scalar type")); } TEST_F(ValidateAtomics, AtomicAddFloatVulkanWrongType2) { const std::string body = R"( %val1 = OpAtomicFAddEXT %u32 %u32_var %device %relaxed %u32_1 )"; const std::string extra = R"( OpCapability AtomicFloat32AddEXT OpExtension "SPV_EXT_shader_atomic_float_add" )"; CompileSuccessfully(GenerateShaderCode(body, extra), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicFAddEXT: " "expected Result Type to be float scalar type")); } TEST_F(ValidateAtomics, AtomicMinFloatVulkanWrongType2) { const std::string body = R"( %val1 = OpAtomicFMinEXT %u32 %u32_var %device %relaxed %u32_1 )"; const std::string extra = R"( OpCapability AtomicFloat32MinMaxEXT OpExtension "SPV_EXT_shader_atomic_float_min_max" )"; CompileSuccessfully(GenerateShaderCode(body, extra), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicFMinEXT: " "expected Result Type to be float scalar type")); } TEST_F(ValidateAtomics, AtomicMaxFloatVulkanWrongType2) { const std::string body = R"( %val1 = OpAtomicFMaxEXT %u32 %u32_var %device %relaxed %u32_1 )"; const std::string extra = R"( OpCapability AtomicFloat32MinMaxEXT OpExtension "SPV_EXT_shader_atomic_float_min_max" )"; CompileSuccessfully(GenerateShaderCode(body, extra), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicFMaxEXT: " "expected Result Type to be float scalar type")); } TEST_F(ValidateAtomics, AtomicAddFloatVulkanWrongType3) { const std::string body = R"( %val1 = OpAtomicFAddEXT %u64 %u64_var %device %relaxed %u64_1 )"; const std::string extra = R"( OpCapability AtomicFloat32AddEXT OpExtension "SPV_EXT_shader_atomic_float_add" )"; CompileSuccessfully(GenerateShaderCode(body, extra), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicFAddEXT: " "expected Result Type to be float scalar type")); } TEST_F(ValidateAtomics, AtomicMinFloatVulkanWrongType3) { const std::string body = R"( %val1 = OpAtomicFMinEXT %u64 %u64_var %device %relaxed %u64_1 )"; const std::string extra = R"( OpCapability AtomicFloat32MinMaxEXT OpExtension "SPV_EXT_shader_atomic_float_min_max" )"; CompileSuccessfully(GenerateShaderCode(body, extra), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicFMinEXT: " "expected Result Type to be float scalar type")); } TEST_F(ValidateAtomics, AtomicMaxFloatVulkanWrongType3) { const std::string body = R"( %val1 = OpAtomicFMaxEXT %u64 %u64_var %device %relaxed %u64_1 )"; const std::string extra = R"( OpCapability AtomicFloat32MinMaxEXT OpExtension "SPV_EXT_shader_atomic_float_min_max" )"; CompileSuccessfully(GenerateShaderCode(body, extra), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicFMaxEXT: " "expected Result Type to be float scalar type")); } TEST_F(ValidateAtomics, AtomicAddFloatVulkanWrongCapability) { const std::string body = R"( %val1 = OpAtomicFAddEXT %f32 %f32_var %device %relaxed %f32_1 )"; const std::string extra = R"( OpCapability AtomicFloat64AddEXT OpExtension "SPV_EXT_shader_atomic_float_add" )"; CompileSuccessfully(GenerateShaderCode(body, extra), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicFAddEXT: float add atomics " "require the AtomicFloat32AddEXT capability")); } TEST_F(ValidateAtomics, AtomicMinFloatVulkanWrongCapability) { const std::string body = R"( %val1 = OpAtomicFMinEXT %f32 %f32_var %device %relaxed %f32_1 )"; const std::string extra = R"( OpCapability AtomicFloat64MinMaxEXT OpExtension "SPV_EXT_shader_atomic_float_min_max" )"; CompileSuccessfully(GenerateShaderCode(body, extra), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicFMinEXT: float min/max atomics " "require the AtomicFloat32MinMaxEXT capability")); } TEST_F(ValidateAtomics, AtomicMaxFloatVulkanWrongCapability) { const std::string body = R"( %val1 = OpAtomicFMaxEXT %f32 %f32_var %device %relaxed %f32_1 )"; const std::string extra = R"( OpCapability AtomicFloat64MinMaxEXT OpExtension "SPV_EXT_shader_atomic_float_min_max" )"; CompileSuccessfully(GenerateShaderCode(body, extra), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicFMaxEXT: float min/max atomics " "require the AtomicFloat32MinMaxEXT capability")); } TEST_F(ValidateAtomics, AtomicAddFloat16VulkanSuccess) { const std::string defs = R"( %f16 = OpTypeFloat 16 %f16_1 = OpConstant %f16 1 %f16_ptr = OpTypePointer Workgroup %f16 %f16_var = OpVariable %f16_ptr Workgroup )"; const std::string body = R"( %val1 = OpAtomicFAddEXT %f16 %f16_var %device %relaxed %f16_1 )"; const std::string extra = R"( OpCapability Float16 OpCapability AtomicFloat16AddEXT OpExtension "SPV_EXT_shader_atomic_float16_add" )"; CompileSuccessfully(GenerateShaderComputeCode(body, extra, defs), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateAtomics, AtomicAddFloatVulkanSuccess) { const std::string body = R"( %val1 = OpAtomicFAddEXT %f32 %f32_var %device %relaxed %f32_1 %val2 = OpAtomicFAddEXT %f32 %f32_var %invocation %relaxed %f32_1 )"; const std::string extra = R"( OpCapability AtomicFloat32AddEXT OpExtension "SPV_EXT_shader_atomic_float_add" )"; CompileSuccessfully(GenerateShaderComputeCode(body, extra), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateAtomics, AtomicMinFloat16VulkanSuccess) { const std::string defs = R"( %f16 = OpTypeFloat 16 %f16_1 = OpConstant %f16 1 %f16_ptr = OpTypePointer Workgroup %f16 %f16_var = OpVariable %f16_ptr Workgroup )"; const std::string body = R"( %val1 = OpAtomicFMinEXT %f16 %f16_var %device %relaxed %f16_1 )"; const std::string extra = R"( OpCapability Float16 OpCapability AtomicFloat16MinMaxEXT OpExtension "SPV_EXT_shader_atomic_float_min_max" )"; CompileSuccessfully(GenerateShaderComputeCode(body, extra, defs), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateAtomics, AtomicMaxFloat16VulkanSuccess) { const std::string defs = R"( %f16 = OpTypeFloat 16 %f16_1 = OpConstant %f16 1 %f16_ptr = OpTypePointer Workgroup %f16 %f16_var = OpVariable %f16_ptr Workgroup )"; const std::string body = R"( %val1 = OpAtomicFMaxEXT %f16 %f16_var %device %relaxed %f16_1 )"; const std::string extra = R"( OpCapability Float16 OpCapability AtomicFloat16MinMaxEXT OpExtension "SPV_EXT_shader_atomic_float_min_max" )"; CompileSuccessfully(GenerateShaderComputeCode(body, extra, defs), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateAtomics, AtomicMinFloat32VulkanSuccess) { const std::string body = R"( %val1 = OpAtomicFMinEXT %f32 %f32_var %device %relaxed %f32_1 )"; const std::string extra = R"( OpCapability AtomicFloat32MinMaxEXT OpExtension "SPV_EXT_shader_atomic_float_min_max" )"; CompileSuccessfully(GenerateShaderComputeCode(body, extra), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateAtomics, AtomicMaxFloat32VulkanSuccess) { const std::string body = R"( %val1 = OpAtomicFMaxEXT %f32 %f32_var %device %relaxed %f32_1 )"; const std::string extra = R"( OpCapability AtomicFloat32MinMaxEXT OpExtension "SPV_EXT_shader_atomic_float_min_max" )"; CompileSuccessfully(GenerateShaderComputeCode(body, extra), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateAtomics, AtomicMinFloat64VulkanSuccess) { const std::string defs = R"( %f64 = OpTypeFloat 64 %f64_1 = OpConstant %f64 1 %f64_ptr = OpTypePointer Workgroup %f64 %f64_var = OpVariable %f64_ptr Workgroup )"; const std::string body = R"( %val1 = OpAtomicFMinEXT %f64 %f64_var %device %relaxed %f64_1 )"; const std::string extra = R"( OpCapability Float64 OpCapability AtomicFloat64MinMaxEXT OpExtension "SPV_EXT_shader_atomic_float_min_max" )"; CompileSuccessfully(GenerateShaderComputeCode(body, extra, defs), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateAtomics, AtomicMaxFloat64VulkanSuccess) { const std::string defs = R"( %f64 = OpTypeFloat 64 %f64_1 = OpConstant %f64 1 %f64_ptr = OpTypePointer Workgroup %f64 %f64_var = OpVariable %f64_ptr Workgroup )"; const std::string body = R"( %val1 = OpAtomicFMaxEXT %f64 %f64_var %device %relaxed %f64_1 )"; const std::string extra = R"( OpCapability Float64 OpCapability AtomicFloat64MinMaxEXT OpExtension "SPV_EXT_shader_atomic_float_min_max" )"; CompileSuccessfully(GenerateShaderComputeCode(body, extra, defs), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateAtomics, AtomicLoadFloatVulkan) { const std::string body = R"( %val1 = OpAtomicLoad %f32 %f32_var %device %relaxed %val2 = OpAtomicLoad %f32 %f32_var %workgroup %acquire )"; CompileSuccessfully(GenerateShaderComputeCode(body), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateAtomics, AtomicStoreVulkanWrongStorageClass) { const std::string body = R"( OpAtomicStore %f32_var %device %relaxed %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-None-04645")); EXPECT_THAT( getDiagnosticString(), HasSubstr("in Vulkan environment, Workgroup Storage Class is limited to " "MeshNV, TaskNV, and GLCompute execution model")); } TEST_F(ValidateAtomics, AtomicStoreFloatVulkan) { const std::string body = R"( OpAtomicStore %f32_var %device %relaxed %f32_1 )"; CompileSuccessfully(GenerateShaderComputeCode(body), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateAtomics, AtomicExchangeFloatVulkan) { const std::string body = R"( %val2 = OpAtomicExchange %f32 %f32_var %device %relaxed %f32_0 )"; CompileSuccessfully(GenerateShaderComputeCode(body), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateAtomics, AtomicLoadInt64WithCapabilityVulkanSuccess) { const std::string body = R"( %val1 = OpAtomicLoad %u64 %u64_var %device %relaxed %val2 = OpAtomicLoad %u64 %u64_var %workgroup %acquire %val3 = OpAtomicLoad %u64 %u64_var %invocation %relaxed )"; CompileSuccessfully( GenerateShaderComputeCode(body, "OpCapability Int64Atomics\n"), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateAtomics, AtomicLoadInt64WithoutCapabilityVulkan) { const std::string body = R"( %val1 = OpAtomicLoad %u64 %u64_var %device %relaxed %val2 = OpAtomicLoad %u64 %u64_var %workgroup %acquire )"; CompileSuccessfully(GenerateShaderComputeCode(body), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("64-bit atomics require the Int64Atomics capability")); } TEST_F(ValidateAtomics, AtomicStoreOpenCLFunctionPointerStorageTypeSuccess) { const std::string body = R"( %f32_var_function = OpVariable %f32_ptr_function Function OpAtomicStore %f32_var_function %device %relaxed %f32_1 )"; CompileSuccessfully(GenerateKernelCode(body), SPV_ENV_OPENCL_1_2); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_OPENCL_1_2)); } TEST_F(ValidateAtomics, AtomicStoreVulkanFunctionPointerStorageType) { const std::string body = R"( %f32_var_function = OpVariable %f32_ptr_function Function OpAtomicStore %f32_var_function %device %relaxed %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-None-04686")); EXPECT_THAT( getDiagnosticString(), HasSubstr("AtomicStore: Vulkan spec only allows storage classes for " "atomic to be: Uniform, Workgroup, Image, StorageBuffer, " "PhysicalStorageBuffer or TaskPayloadWorkgroupEXT.")); } TEST_F(ValidateAtomics, AtomicStoreFunctionPointerStorageType) { const std::string body = R"( %f32_var_function = OpVariable %f32_ptr_function Function OpAtomicStore %f32_var_function %device %relaxed %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicStore: Function storage class forbidden when " "the Shader capability is declared.")); } // TODO(atgoo@github.com): the corresponding check fails Vulkan CTS, // reenable once fixed. TEST_F(ValidateAtomics, DISABLED_AtomicLoadVulkanSubgroup) { const std::string body = R"( %val1 = OpAtomicLoad %u32 %u32_var %subgroup %acquire )"; CompileSuccessfully(GenerateShaderCode(body), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicLoad: in Vulkan environment memory scope is " "limited to Device, Workgroup and Invocation")); } TEST_F(ValidateAtomics, AtomicLoadVulkanRelease) { const std::string body = R"( %val1 = OpAtomicLoad %u32 %u32_var %workgroup %release )"; CompileSuccessfully(GenerateShaderCode(body), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpAtomicLoad-04731")); EXPECT_THAT( getDiagnosticString(), HasSubstr("Vulkan spec disallows OpAtomicLoad with Memory Semantics " "Release, AcquireRelease and SequentiallyConsistent")); } TEST_F(ValidateAtomics, AtomicLoadVulkanAcquireRelease) { const std::string body = R"( %val1 = OpAtomicLoad %u32 %u32_var %workgroup %acquire_release )"; CompileSuccessfully(GenerateShaderCode(body), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpAtomicLoad-04731")); EXPECT_THAT( getDiagnosticString(), HasSubstr("Vulkan spec disallows OpAtomicLoad with Memory Semantics " "Release, AcquireRelease and SequentiallyConsistent")); } TEST_F(ValidateAtomics, AtomicLoadVulkanSequentiallyConsistent) { const std::string body = R"( %val1 = OpAtomicLoad %u32 %u32_var %workgroup %sequentially_consistent )"; CompileSuccessfully(GenerateShaderCode(body), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpAtomicLoad-04731")); EXPECT_THAT( getDiagnosticString(), HasSubstr("Vulkan spec disallows OpAtomicLoad with Memory Semantics " "Release, AcquireRelease and SequentiallyConsistent")); } TEST_F(ValidateAtomics, AtomicLoadVulkanInvocationSemantics) { const std::string body = R"( %val1 = OpAtomicLoad %u32 %u32_var %invocation %acquire )"; CompileSuccessfully(GenerateShaderCode(body), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-None-04641")); EXPECT_THAT( getDiagnosticString(), HasSubstr("AtomicLoad: Vulkan specification requires Memory Semantics to " "be None if used with Invocation Memory Scope")); } TEST_F(ValidateAtomics, AtomicLoadShaderFloat) { const std::string body = R"( %val1 = OpAtomicLoad %f32 %f32_var %device %relaxed )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateAtomics, AtomicLoadVulkanInt64) { const std::string body = R"( %val1 = OpAtomicLoad %u64 %u64_var %device %relaxed )"; CompileSuccessfully(GenerateShaderCode(body), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "AtomicLoad: 64-bit atomics require the Int64Atomics capability")); } TEST_F(ValidateAtomics, AtomicLoadKernelInt64) { const std::string body = R"( %val1 = OpAtomicLoad %u64 %u64_var %device %relaxed )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "AtomicLoad: 64-bit atomics require the Int64Atomics capability")); } TEST_F(ValidateAtomics, AtomicStoreVulkanInt64) { const std::string body = R"( OpAtomicStore %u64_var %device %relaxed %u64_1 )"; CompileSuccessfully(GenerateShaderCode(body), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "AtomicStore: 64-bit atomics require the Int64Atomics capability")); } TEST_F(ValidateAtomics, AtomicStoreKernelInt64) { const std::string body = R"( OpAtomicStore %u64_var %device %relaxed %u64_1 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "AtomicStore: 64-bit atomics require the Int64Atomics capability")); } TEST_F(ValidateAtomics, VK_KHR_shader_atomic_int64Success) { const std::string body = R"( %val1 = OpAtomicUMin %u64 %u64_var %device %relaxed %u64_1 %val2 = OpAtomicUMax %u64 %u64_var %device %relaxed %u64_1 %val3 = OpAtomicSMin %u64 %u64_var %device %relaxed %u64_1 %val4 = OpAtomicSMax %u64 %u64_var %device %relaxed %u64_1 %val5 = OpAtomicAnd %u64 %u64_var %device %relaxed %u64_1 %val6 = OpAtomicOr %u64 %u64_var %device %relaxed %u64_1 %val7 = OpAtomicXor %u64 %u64_var %device %relaxed %u64_1 %val8 = OpAtomicIAdd %u64 %u64_var %device %relaxed %u64_1 %val9 = OpAtomicExchange %u64 %u64_var %device %relaxed %u64_1 %val10 = OpAtomicCompareExchange %u64 %u64_var %device %relaxed %relaxed %u64_1 %u64_1 %val11 = OpAtomicUMin %s64 %s64_var %device %relaxed %s64_1 %val12 = OpAtomicUMax %s64 %s64_var %device %relaxed %s64_1 %val13 = OpAtomicSMin %s64 %s64_var %device %relaxed %s64_1 %val14 = OpAtomicSMax %s64 %s64_var %device %relaxed %s64_1 %val15 = OpAtomicAnd %s64 %s64_var %device %relaxed %s64_1 %val16 = OpAtomicOr %s64 %s64_var %device %relaxed %s64_1 %val17 = OpAtomicXor %s64 %s64_var %device %relaxed %s64_1 %val18 = OpAtomicIAdd %s64 %s64_var %device %relaxed %s64_1 %val19 = OpAtomicExchange %s64 %s64_var %device %relaxed %s64_1 %val20 = OpAtomicCompareExchange %s64 %s64_var %device %relaxed %relaxed %s64_1 %s64_1 %val21 = OpAtomicLoad %u64 %u64_var %device %relaxed %val22 = OpAtomicLoad %s64 %s64_var %device %relaxed OpAtomicStore %u64_var %device %relaxed %u64_1 OpAtomicStore %s64_var %device %relaxed %s64_1 )"; CompileSuccessfully( GenerateShaderComputeCode(body, "OpCapability Int64Atomics\n"), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateAtomics, VK_KHR_shader_atomic_int64MissingCapability) { const std::string body = R"( %val1 = OpAtomicUMin %u64 %u64_var %device %relaxed %u64_1 )"; CompileSuccessfully(GenerateShaderCode(body), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "AtomicUMin: 64-bit atomics require the Int64Atomics capability")); } TEST_F(ValidateAtomics, AtomicLoadWrongResultType) { const std::string body = R"( %val1 = OpAtomicLoad %f32vec4 %f32vec4_var %device %relaxed )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("AtomicLoad: " "expected Result Type to be integer or float scalar type")); } TEST_F(ValidateAtomics, AtomicLoadWrongPointerType) { const std::string body = R"( %val1 = OpAtomicLoad %f32 %f32_ptr %device %relaxed )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Operand '27[%_ptr_Workgroup_float]' cannot be a type")); } TEST_F(ValidateAtomics, AtomicLoadWrongPointerDataType) { const std::string body = R"( %val1 = OpAtomicLoad %u32 %f32_var %device %relaxed )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("AtomicLoad: " "expected Pointer to point to a value of type Result Type")); } TEST_F(ValidateAtomics, AtomicLoadWrongScopeType) { const std::string body = R"( %val1 = OpAtomicLoad %f32 %f32_var %f32_1 %relaxed )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicLoad: expected scope to be a 32-bit int")); } TEST_F(ValidateAtomics, AtomicLoadWrongMemorySemanticsType) { const std::string body = R"( %val1 = OpAtomicLoad %f32 %f32_var %device %u64_1 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("AtomicLoad: expected Memory Semantics to be a 32-bit int")); } TEST_F(ValidateAtomics, AtomicStoreKernelSuccess) { const std::string body = R"( OpAtomicStore %f32_var %device %relaxed %f32_1 OpAtomicStore %u32_var %subgroup %release %u32_1 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateAtomics, AtomicStoreShaderSuccess) { const std::string body = R"( OpAtomicStore %u32_var %device %release %u32_1 OpAtomicStore %u32_var %subgroup %sequentially_consistent %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateAtomics, AtomicStoreVulkanSuccess) { const std::string body = R"( OpAtomicStore %u32_var %device %release %u32_1 OpAtomicStore %u32_var %invocation %relaxed %u32_1 )"; CompileSuccessfully(GenerateShaderComputeCode(body), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateAtomics, AtomicStoreVulkanAcquire) { const std::string body = R"( OpAtomicStore %u32_var %device %acquire %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpAtomicStore-04730")); EXPECT_THAT( getDiagnosticString(), HasSubstr("Vulkan spec disallows OpAtomicStore with Memory Semantics " "Acquire, AcquireRelease and SequentiallyConsistent")); } TEST_F(ValidateAtomics, AtomicStoreVulkanAcquireRelease) { const std::string body = R"( OpAtomicStore %u32_var %device %acquire_release %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpAtomicStore-04730")); EXPECT_THAT( getDiagnosticString(), HasSubstr("Vulkan spec disallows OpAtomicStore with Memory Semantics " "Acquire, AcquireRelease and SequentiallyConsistent")); } TEST_F(ValidateAtomics, AtomicStoreVulkanSequentiallyConsistent) { const std::string body = R"( OpAtomicStore %u32_var %device %sequentially_consistent %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpAtomicStore-04730")); EXPECT_THAT( getDiagnosticString(), HasSubstr("Vulkan spec disallows OpAtomicStore with Memory Semantics " "Acquire, AcquireRelease and SequentiallyConsistent")); } TEST_F(ValidateAtomics, AtomicStoreVulkanInvocationSemantics) { const std::string body = R"( OpAtomicStore %u32_var %invocation %acquire %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-None-04641")); EXPECT_THAT( getDiagnosticString(), HasSubstr("AtomicStore: Vulkan specification requires Memory Semantics " "to be None if used with Invocation Memory Scope")); } TEST_F(ValidateAtomics, AtomicStoreWrongPointerType) { const std::string body = R"( OpAtomicStore %f32_1 %device %relaxed %f32_1 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicStore: expected Pointer to be a pointer type")); } TEST_F(ValidateAtomics, AtomicStoreWrongPointerDataType) { const std::string body = R"( OpAtomicStore %f32vec4_var %device %relaxed %f32_1 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "AtomicStore: " "expected Pointer to be a pointer to integer or float scalar type")); } TEST_F(ValidateAtomics, AtomicStoreWrongPointerStorageTypeForOpenCL) { const std::string body = R"( OpAtomicStore %f32_im_var %device %relaxed %f32_1 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_OPENCL_1_2)); EXPECT_THAT( getDiagnosticString(), HasSubstr("AtomicStore: storage class must be Function, Workgroup, " "CrossWorkGroup or Generic in the OpenCL environment.")); } TEST_F(ValidateAtomics, AtomicStoreWrongPointerStorageType) { const std::string body = R"( OpAtomicStore %f32_uc_var %device %relaxed %f32_1 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicStore: storage class forbidden by universal " "validation rules.")); } TEST_F(ValidateAtomics, AtomicStoreWrongScopeType) { const std::string body = R"( OpAtomicStore %f32_var %f32_1 %relaxed %f32_1 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicStore: expected scope to be a 32-bit int\n " "OpAtomicStore %28 %float_1 %uint_0_1 %float_1\n")); } TEST_F(ValidateAtomics, AtomicStoreWrongMemorySemanticsType) { const std::string body = R"( OpAtomicStore %f32_var %device %f32_1 %f32_1 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("AtomicStore: expected Memory Semantics to be a 32-bit int")); } TEST_F(ValidateAtomics, AtomicStoreWrongValueType) { const std::string body = R"( OpAtomicStore %f32_var %device %relaxed %u32_1 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("AtomicStore: " "expected Value type and the type pointed to by Pointer to " "be the same")); } TEST_F(ValidateAtomics, AtomicExchangeShaderSuccess) { const std::string body = R"( OpAtomicStore %u32_var %device %relaxed %u32_1 %val2 = OpAtomicExchange %u32 %u32_var %device %relaxed %u32_0 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateAtomics, AtomicExchangeKernelSuccess) { const std::string body = R"( OpAtomicStore %f32_var %device %relaxed %f32_1 %val2 = OpAtomicExchange %f32 %f32_var %device %relaxed %f32_0 OpAtomicStore %u32_var %device %relaxed %u32_1 %val4 = OpAtomicExchange %u32 %u32_var %device %relaxed %u32_0 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateAtomics, AtomicExchangeShaderFloat) { const std::string body = R"( OpAtomicStore %f32_var %device %relaxed %f32_1 %val2 = OpAtomicExchange %f32 %f32_var %device %relaxed %f32_0 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateAtomics, AtomicExchangeWrongResultType) { const std::string body = R"( OpStore %f32vec4_var %f32vec4_0000 %val2 = OpAtomicExchange %f32vec4 %f32vec4_var %device %relaxed %f32vec4_0000 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("AtomicExchange: " "expected Result Type to be integer or float scalar type")); } TEST_F(ValidateAtomics, AtomicExchangeWrongPointerType) { const std::string body = R"( %val2 = OpAtomicExchange %f32 %f32vec4_ptr %device %relaxed %f32vec4_0000 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Operand '33[%_ptr_Workgroup_v4float]' cannot be a " "type")); } TEST_F(ValidateAtomics, AtomicExchangeWrongPointerDataType) { const std::string body = R"( OpStore %f32vec4_var %f32vec4_0000 %val2 = OpAtomicExchange %f32 %f32vec4_var %device %relaxed %f32vec4_0000 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("AtomicExchange: " "expected Pointer to point to a value of type Result Type")); } TEST_F(ValidateAtomics, AtomicExchangeWrongScopeType) { const std::string body = R"( OpAtomicStore %f32_var %device %relaxed %f32_1 %val2 = OpAtomicExchange %f32 %f32_var %f32_1 %relaxed %f32_0 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicExchange: expected scope to be a 32-bit int")); } TEST_F(ValidateAtomics, AtomicExchangeWrongMemorySemanticsType) { const std::string body = R"( OpAtomicStore %f32_var %device %relaxed %f32_1 %val2 = OpAtomicExchange %f32 %f32_var %device %f32_1 %f32_0 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "AtomicExchange: expected Memory Semantics to be a 32-bit int")); } TEST_F(ValidateAtomics, AtomicExchangeWrongValueType) { const std::string body = R"( OpAtomicStore %f32_var %device %relaxed %f32_1 %val2 = OpAtomicExchange %f32 %f32_var %device %relaxed %u32_0 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicExchange: " "expected Value to be of type Result Type")); } TEST_F(ValidateAtomics, AtomicExchangeVulkanInvocationSemantics) { const std::string body = R"( OpAtomicStore %u32_var %invocation %relaxed %u32_1 %val2 = OpAtomicExchange %u32 %u32_var %invocation %acquire %u32_0 )"; CompileSuccessfully(GenerateShaderCode(body), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-None-04641")); EXPECT_THAT( getDiagnosticString(), HasSubstr("AtomicExchange: Vulkan specification requires Memory " "Semantics to be None if used with Invocation Memory Scope")); } TEST_F(ValidateAtomics, AtomicCompareExchangeShaderSuccess) { const std::string body = R"( OpAtomicStore %u32_var %device %relaxed %u32_1 %val2 = OpAtomicCompareExchange %u32 %u32_var %device %relaxed %relaxed %u32_0 %u32_0 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateAtomics, AtomicCompareExchangeKernelSuccess) { const std::string body = R"( OpAtomicStore %u32_var %device %relaxed %u32_1 %val2 = OpAtomicCompareExchange %u32 %u32_var %device %relaxed %relaxed %u32_0 %u32_0 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateAtomics, AtomicCompareExchangeShaderFloat) { const std::string body = R"( OpAtomicStore %f32_var %device %relaxed %f32_1 %val1 = OpAtomicCompareExchange %f32 %f32_var %device %relaxed %relaxed %f32_0 %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicCompareExchange: " "expected Result Type to be integer scalar type")); } TEST_F(ValidateAtomics, AtomicCompareExchangeWrongResultType) { const std::string body = R"( OpStore %f32vec4_var %f32vec4_0000 %val2 = OpAtomicCompareExchange %f32vec4 %f32vec4_var %device %relaxed %relaxed %f32vec4_0000 %f32vec4_0000 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicCompareExchange: " "expected Result Type to be integer scalar type")); } TEST_F(ValidateAtomics, AtomicCompareExchangeWrongPointerType) { const std::string body = R"( %val2 = OpAtomicCompareExchange %f32 %f32vec4_ptr %device %relaxed %relaxed %f32vec4_0000 %f32vec4_0000 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Operand '33[%_ptr_Workgroup_v4float]' cannot be a " "type")); } TEST_F(ValidateAtomics, AtomicCompareExchangeWrongPointerDataType) { const std::string body = R"( OpStore %f32vec4_var %f32vec4_0000 %val2 = OpAtomicCompareExchange %u32 %f32vec4_var %device %relaxed %relaxed %u32_0 %u32_0 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("AtomicCompareExchange: " "expected Pointer to point to a value of type Result Type")); } TEST_F(ValidateAtomics, AtomicCompareExchangeWrongScopeType) { const std::string body = R"( OpAtomicStore %u64_var %device %relaxed %u64_1 %val2 = OpAtomicCompareExchange %u64 %u64_var %u64_1 %relaxed %relaxed %u32_0 %u32_0 )"; CompileSuccessfully(GenerateKernelCode(body, "OpCapability Int64Atomics\n")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicCompareExchange: expected scope to be a 32-bit " "int")); } TEST_F(ValidateAtomics, AtomicCompareExchangeWrongMemorySemanticsType1) { const std::string body = R"( OpAtomicStore %u32_var %device %relaxed %u32_1 %val2 = OpAtomicCompareExchange %u32 %u32_var %device %f32_1 %relaxed %u32_0 %u32_0 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicCompareExchange: expected Memory Semantics to " "be a 32-bit int")); } TEST_F(ValidateAtomics, AtomicCompareExchangeWrongMemorySemanticsType2) { const std::string body = R"( OpAtomicStore %u32_var %device %relaxed %u32_1 %val2 = OpAtomicCompareExchange %u32 %u32_var %device %relaxed %f32_1 %u32_0 %u32_0 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicCompareExchange: expected Memory Semantics to " "be a 32-bit int")); } TEST_F(ValidateAtomics, AtomicCompareExchangeUnequalRelease) { const std::string body = R"( OpAtomicStore %u32_var %device %relaxed %u32_1 %val2 = OpAtomicCompareExchange %u32 %u32_var %device %relaxed %release %u32_0 %u32_0 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicCompareExchange: Memory Semantics Release and " "AcquireRelease cannot be used for operand Unequal")); } TEST_F(ValidateAtomics, AtomicCompareExchangeWrongValueType) { const std::string body = R"( OpAtomicStore %u32_var %device %relaxed %u32_1 %val2 = OpAtomicCompareExchange %u32 %u32_var %device %relaxed %relaxed %f32_1 %u32_0 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicCompareExchange: " "expected Value to be of type Result Type")); } TEST_F(ValidateAtomics, AtomicCompareExchangeWrongComparatorType) { const std::string body = R"( OpAtomicStore %u32_var %device %relaxed %u32_1 %val2 = OpAtomicCompareExchange %u32 %u32_var %device %relaxed %relaxed %u32_0 %f32_0 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicCompareExchange: " "expected Comparator to be of type Result Type")); } TEST_F(ValidateAtomics, AtomicCompareExchangeWeakSuccess) { const std::string body = R"( OpAtomicStore %u32_var %device %relaxed %u32_1 %val4 = OpAtomicCompareExchangeWeak %u32 %u32_var %device %relaxed %relaxed %u32_0 %u32_0 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateAtomics, AtomicCompareExchangeWeakWrongResultType) { const std::string body = R"( OpAtomicStore %f32_var %device %relaxed %f32_1 %val2 = OpAtomicCompareExchangeWeak %f32 %f32_var %device %relaxed %relaxed %f32_0 %f32_1 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicCompareExchangeWeak: " "expected Result Type to be integer scalar type")); } TEST_F(ValidateAtomics, AtomicCompareExchangeVulkanInvocationSemanticsEqual) { const std::string body = R"( OpAtomicStore %u32_var %device %relaxed %u32_1 %val2 = OpAtomicCompareExchange %u32 %u32_var %invocation %release %relaxed %u32_0 %u32_0 )"; CompileSuccessfully(GenerateShaderCode(body), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-None-04641")); EXPECT_THAT( getDiagnosticString(), HasSubstr("AtomicCompareExchange: Vulkan specification requires Memory " "Semantics to be None if used with Invocation Memory Scope")); } TEST_F(ValidateAtomics, AtomicCompareExchangeVulkanInvocationSemanticsUnequal) { const std::string body = R"( OpAtomicStore %u32_var %device %relaxed %u32_1 %val2 = OpAtomicCompareExchange %u32 %u32_var %invocation %relaxed %acquire %u32_0 %u32_0 )"; CompileSuccessfully(GenerateShaderCode(body), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-None-04641")); EXPECT_THAT( getDiagnosticString(), HasSubstr("AtomicCompareExchange: Vulkan specification requires Memory " "Semantics to be None if used with Invocation Memory Scope")); } TEST_F(ValidateAtomics, AtomicArithmeticsSuccess) { const std::string body = R"( OpAtomicStore %u32_var %device %relaxed %u32_1 %val1 = OpAtomicIIncrement %u32 %u32_var %device %acquire_release %val2 = OpAtomicIDecrement %u32 %u32_var %device %acquire_release %val3 = OpAtomicIAdd %u32 %u32_var %device %acquire_release %u32_1 %val4 = OpAtomicISub %u32 %u32_var %device %acquire_release %u32_1 %val5 = OpAtomicUMin %u32 %u32_var %device %acquire_release %u32_1 %val6 = OpAtomicUMax %u32 %u32_var %device %acquire_release %u32_1 %val7 = OpAtomicSMin %u32 %u32_var %device %sequentially_consistent %u32_1 %val8 = OpAtomicSMax %u32 %u32_var %device %sequentially_consistent %u32_1 %val9 = OpAtomicAnd %u32 %u32_var %device %sequentially_consistent %u32_1 %val10 = OpAtomicOr %u32 %u32_var %device %sequentially_consistent %u32_1 %val11 = OpAtomicXor %u32 %u32_var %device %sequentially_consistent %u32_1 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateAtomics, AtomicFlagsSuccess) { const std::string body = R"( OpAtomicFlagClear %u32_var %device %release %val1 = OpAtomicFlagTestAndSet %bool %u32_var %device %relaxed )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateAtomics, AtomicFlagTestAndSetWrongResultType) { const std::string body = R"( %val1 = OpAtomicFlagTestAndSet %u32 %u32_var %device %relaxed )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicFlagTestAndSet: " "expected Result Type to be bool scalar type")); } TEST_F(ValidateAtomics, AtomicFlagTestAndSetNotPointer) { const std::string body = R"( %val1 = OpAtomicFlagTestAndSet %bool %u32_1 %device %relaxed )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicFlagTestAndSet: " "expected Pointer to be a pointer type")); } TEST_F(ValidateAtomics, AtomicFlagTestAndSetNotIntPointer) { const std::string body = R"( %val1 = OpAtomicFlagTestAndSet %bool %f32_var %device %relaxed )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("AtomicFlagTestAndSet: " "expected Pointer to point to a value of 32-bit integer type")); } TEST_F(ValidateAtomics, AtomicFlagTestAndSetNotInt32Pointer) { const std::string body = R"( %val1 = OpAtomicFlagTestAndSet %bool %u64_var %device %relaxed )"; CompileSuccessfully(GenerateKernelCode(body, "OpCapability Int64Atomics\n")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("AtomicFlagTestAndSet: " "expected Pointer to point to a value of 32-bit integer type")); } TEST_F(ValidateAtomics, AtomicFlagTestAndSetWrongScopeType) { const std::string body = R"( %val1 = OpAtomicFlagTestAndSet %bool %u32_var %u64_1 %relaxed )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("AtomicFlagTestAndSet: expected scope to be a 32-bit int")); } TEST_F(ValidateAtomics, AtomicFlagTestAndSetWrongMemorySemanticsType) { const std::string body = R"( %val1 = OpAtomicFlagTestAndSet %bool %u32_var %device %u64_1 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicFlagTestAndSet: " "expected Memory Semantics to be a 32-bit int")); } TEST_F(ValidateAtomics, AtomicFlagClearAcquire) { const std::string body = R"( OpAtomicFlagClear %u32_var %device %acquire )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Memory Semantics Acquire and AcquireRelease cannot be " "used with AtomicFlagClear")); } TEST_F(ValidateAtomics, AtomicFlagClearNotPointer) { const std::string body = R"( OpAtomicFlagClear %u32_1 %device %relaxed )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicFlagClear: " "expected Pointer to be a pointer type")); } TEST_F(ValidateAtomics, AtomicFlagClearNotIntPointer) { const std::string body = R"( OpAtomicFlagClear %f32_var %device %relaxed )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("AtomicFlagClear: " "expected Pointer to point to a value of 32-bit integer type")); } TEST_F(ValidateAtomics, AtomicFlagClearNotInt32Pointer) { const std::string body = R"( OpAtomicFlagClear %u64_var %device %relaxed )"; CompileSuccessfully(GenerateKernelCode(body, "OpCapability Int64Atomics\n")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("AtomicFlagClear: " "expected Pointer to point to a value of 32-bit integer type")); } TEST_F(ValidateAtomics, AtomicFlagClearWrongScopeType) { const std::string body = R"( OpAtomicFlagClear %u32_var %u64_1 %relaxed )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicFlagClear: expected scope to be a 32-bit " "int\n OpAtomicFlagClear %30 %ulong_1 %uint_0_1\n")); } TEST_F(ValidateAtomics, AtomicFlagClearWrongMemorySemanticsType) { const std::string body = R"( OpAtomicFlagClear %u32_var %device %u64_1 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "AtomicFlagClear: expected Memory Semantics to be a 32-bit int")); } TEST_F(ValidateAtomics, AtomicIIncrementAcquireAndRelease) { const std::string body = R"( OpAtomicStore %u32_var %device %relaxed %u32_1 %val1 = OpAtomicIIncrement %u32 %u32_var %device %acquire_and_release )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicIIncrement: Memory Semantics can have at most " "one of the following bits set: Acquire, Release, " "AcquireRelease or SequentiallyConsistent")); } TEST_F(ValidateAtomics, AtomicUniformMemorySemanticsShader) { const std::string body = R"( OpAtomicStore %u32_var %device %relaxed %u32_1 %val1 = OpAtomicIIncrement %u32 %u32_var %device %acquire_release_uniform_workgroup )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateAtomics, AtomicUniformMemorySemanticsKernel) { const std::string body = R"( OpAtomicStore %u32_var %device %relaxed %u32_1 %val1 = OpAtomicIIncrement %u32 %u32_var %device %acquire_release_uniform_workgroup )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicIIncrement: Memory Semantics UniformMemory " "requires capability Shader")); } // Lack of the AtomicStorage capability is intentionally ignored, see // https://github.com/KhronosGroup/glslang/issues/1618 for the reasoning why. TEST_F(ValidateAtomics, AtomicCounterMemorySemanticsNoCapability) { const std::string body = R"( OpAtomicStore %u32_var %device %relaxed %u32_1 %val1 = OpAtomicIIncrement %u32 %u32_var %device %acquire_release_atomic_counter_workgroup )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateAtomics, AtomicCounterMemorySemanticsWithCapability) { const std::string body = R"( OpAtomicStore %u32_var %device %relaxed %u32_1 %val1 = OpAtomicIIncrement %u32 %u32_var %device %acquire_release_atomic_counter_workgroup )"; CompileSuccessfully(GenerateKernelCode(body, "OpCapability AtomicStorage\n")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateAtomics, VulkanMemoryModelBanSequentiallyConsistentAtomicLoad) { const std::string body = R"( %ld = OpAtomicLoad %u32 %u32_var %workgroup %sequentially_consistent )"; const std::string extra = R"( OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "", "VulkanKHR"), SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("SequentiallyConsistent memory semantics cannot be " "used with the VulkanKHR memory model.")); } TEST_F(ValidateAtomics, VulkanMemoryModelBanSequentiallyConsistentAtomicStore) { const std::string body = R"( OpAtomicStore %u32_var %workgroup %sequentially_consistent %u32_0 )"; const std::string extra = R"( OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "", "VulkanKHR"), SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("SequentiallyConsistent memory semantics cannot be " "used with the VulkanKHR memory model.")); } TEST_F(ValidateAtomics, VulkanMemoryModelBanSequentiallyConsistentAtomicExchange) { const std::string body = R"( %ex = OpAtomicExchange %u32 %u32_var %workgroup %sequentially_consistent %u32_0 )"; const std::string extra = R"( OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "", "VulkanKHR"), SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("SequentiallyConsistent memory semantics cannot be " "used with the VulkanKHR memory model.")); } TEST_F(ValidateAtomics, VulkanMemoryModelBanSequentiallyConsistentAtomicCompareExchangeEqual) { const std::string body = R"( %ex = OpAtomicCompareExchange %u32 %u32_var %workgroup %sequentially_consistent %relaxed %u32_0 %u32_0 )"; const std::string extra = R"( OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "", "VulkanKHR"), SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("SequentiallyConsistent memory semantics cannot be " "used with the VulkanKHR memory model.")); } TEST_F(ValidateAtomics, VulkanMemoryModelBanSequentiallyConsistentAtomicCompareExchangeUnequal) { const std::string body = R"( %ex = OpAtomicCompareExchange %u32 %u32_var %workgroup %relaxed %sequentially_consistent %u32_0 %u32_0 )"; const std::string extra = R"( OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "", "VulkanKHR"), SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("SequentiallyConsistent memory semantics cannot be " "used with the VulkanKHR memory model.")); } TEST_F(ValidateAtomics, VulkanMemoryModelBanSequentiallyConsistentAtomicIIncrement) { const std::string body = R"( %inc = OpAtomicIIncrement %u32 %u32_var %workgroup %sequentially_consistent )"; const std::string extra = R"( OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "", "VulkanKHR"), SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("SequentiallyConsistent memory semantics cannot be " "used with the VulkanKHR memory model.")); } TEST_F(ValidateAtomics, VulkanMemoryModelBanSequentiallyConsistentAtomicIDecrement) { const std::string body = R"( %dec = OpAtomicIDecrement %u32 %u32_var %workgroup %sequentially_consistent )"; const std::string extra = R"( OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "", "VulkanKHR"), SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("SequentiallyConsistent memory semantics cannot be " "used with the VulkanKHR memory model.")); } TEST_F(ValidateAtomics, VulkanMemoryModelBanSequentiallyConsistentAtomicIAdd) { const std::string body = R"( %add = OpAtomicIAdd %u32 %u32_var %workgroup %sequentially_consistent %u32_0 )"; const std::string extra = R"( OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "", "VulkanKHR"), SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("SequentiallyConsistent memory semantics cannot be " "used with the VulkanKHR memory model.")); } TEST_F(ValidateAtomics, VulkanMemoryModelBanSequentiallyConsistentAtomicISub) { const std::string body = R"( %sub = OpAtomicISub %u32 %u32_var %workgroup %sequentially_consistent %u32_0 )"; const std::string extra = R"( OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "", "VulkanKHR"), SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("SequentiallyConsistent memory semantics cannot be " "used with the VulkanKHR memory model.")); } TEST_F(ValidateAtomics, VulkanMemoryModelBanSequentiallyConsistentAtomicSMin) { const std::string body = R"( %min = OpAtomicSMin %u32 %u32_var %workgroup %sequentially_consistent %u32_0 )"; const std::string extra = R"( OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "", "VulkanKHR"), SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("SequentiallyConsistent memory semantics cannot be " "used with the VulkanKHR memory model.")); } TEST_F(ValidateAtomics, VulkanMemoryModelBanSequentiallyConsistentAtomicUMin) { const std::string body = R"( %min = OpAtomicUMin %u32 %u32_var %workgroup %sequentially_consistent %u32_0 )"; const std::string extra = R"( OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "", "VulkanKHR"), SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("SequentiallyConsistent memory semantics cannot be " "used with the VulkanKHR memory model.")); } TEST_F(ValidateAtomics, VulkanMemoryModelBanSequentiallyConsistentAtomicFMinEXT) { const std::string body = R"( %max = OpAtomicFMinEXT %f32 %f32_var %workgroup %sequentially_consistent %f32_0 )"; const std::string extra = R"( OpCapability VulkanMemoryModelKHR OpCapability AtomicFloat32MinMaxEXT OpExtension "SPV_KHR_vulkan_memory_model" OpExtension "SPV_EXT_shader_atomic_float_min_max" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "", "VulkanKHR"), SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("SequentiallyConsistent memory semantics cannot be " "used with the VulkanKHR memory model.")); } TEST_F(ValidateAtomics, VulkanMemoryModelBanSequentiallyConsistentAtomicSMax) { const std::string body = R"( %max = OpAtomicSMax %u32 %u32_var %workgroup %sequentially_consistent %u32_0 )"; const std::string extra = R"( OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "", "VulkanKHR"), SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("SequentiallyConsistent memory semantics cannot be " "used with the VulkanKHR memory model.")); } TEST_F(ValidateAtomics, VulkanMemoryModelBanSequentiallyConsistentAtomicUMax) { const std::string body = R"( %max = OpAtomicUMax %u32 %u32_var %workgroup %sequentially_consistent %u32_0 )"; const std::string extra = R"( OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "", "VulkanKHR"), SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("SequentiallyConsistent memory semantics cannot be " "used with the VulkanKHR memory model.")); } TEST_F(ValidateAtomics, VulkanMemoryModelBanSequentiallyConsistentAtomicFMaxEXT) { const std::string body = R"( %max = OpAtomicFMaxEXT %f32 %f32_var %workgroup %sequentially_consistent %f32_0 )"; const std::string extra = R"( OpCapability VulkanMemoryModelKHR OpCapability AtomicFloat32MinMaxEXT OpExtension "SPV_KHR_vulkan_memory_model" OpExtension "SPV_EXT_shader_atomic_float_min_max" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "", "VulkanKHR"), SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("SequentiallyConsistent memory semantics cannot be " "used with the VulkanKHR memory model.")); } TEST_F(ValidateAtomics, VulkanMemoryModelBanSequentiallyConsistentAtomicAnd) { const std::string body = R"( %and = OpAtomicAnd %u32 %u32_var %workgroup %sequentially_consistent %u32_0 )"; const std::string extra = R"( OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "", "VulkanKHR"), SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("SequentiallyConsistent memory semantics cannot be " "used with the VulkanKHR memory model.")); } TEST_F(ValidateAtomics, VulkanMemoryModelBanSequentiallyConsistentAtomicOr) { const std::string body = R"( %or = OpAtomicOr %u32 %u32_var %workgroup %sequentially_consistent %u32_0 )"; const std::string extra = R"( OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "", "VulkanKHR"), SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("SequentiallyConsistent memory semantics cannot be " "used with the VulkanKHR memory model.")); } TEST_F(ValidateAtomics, VulkanMemoryModelBanSequentiallyConsistentAtomicXor) { const std::string body = R"( %xor = OpAtomicXor %u32 %u32_var %workgroup %sequentially_consistent %u32_0 )"; const std::string extra = R"( OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "", "VulkanKHR"), SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("SequentiallyConsistent memory semantics cannot be " "used with the VulkanKHR memory model.")); } TEST_F(ValidateAtomics, OutputMemoryKHRRequiresVulkanMemoryModelKHR) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" OpExecutionMode %1 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeInt 32 0 %semantics = OpConstant %3 4100 %5 = OpTypeFunction %2 %workgroup = OpConstant %3 2 %ptr = OpTypePointer Workgroup %3 %var = OpVariable %ptr Workgroup %1 = OpFunction %2 None %5 %7 = OpLabel OpAtomicStore %var %workgroup %semantics %workgroup OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicStore: Memory Semantics OutputMemoryKHR " "requires capability VulkanMemoryModelKHR")); } TEST_F(ValidateAtomics, MakeAvailableKHRRequiresVulkanMemoryModelKHR) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" OpExecutionMode %1 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeInt 32 0 %semantics = OpConstant %3 8196 %5 = OpTypeFunction %2 %workgroup = OpConstant %3 2 %ptr = OpTypePointer Workgroup %3 %var = OpVariable %ptr Workgroup %1 = OpFunction %2 None %5 %7 = OpLabel OpAtomicStore %var %workgroup %semantics %workgroup OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicStore: Memory Semantics MakeAvailableKHR " "requires capability VulkanMemoryModelKHR")); } TEST_F(ValidateAtomics, MakeVisibleKHRRequiresVulkanMemoryModelKHR) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" OpExecutionMode %1 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeInt 32 0 %semantics = OpConstant %3 16386 %5 = OpTypeFunction %2 %workgroup = OpConstant %3 2 %ptr = OpTypePointer Workgroup %3 %var = OpVariable %ptr Workgroup %1 = OpFunction %2 None %5 %7 = OpLabel %ld = OpAtomicLoad %3 %var %workgroup %semantics OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicLoad: Memory Semantics MakeVisibleKHR requires " "capability VulkanMemoryModelKHR")); } TEST_F(ValidateAtomics, MakeAvailableKHRRequiresReleaseSemantics) { const std::string text = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR OpEntryPoint Fragment %1 "func" OpExecutionMode %1 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeInt 32 0 %semantics = OpConstant %3 8448 %5 = OpTypeFunction %2 %workgroup = OpConstant %3 2 %ptr = OpTypePointer Workgroup %3 %var = OpVariable %ptr Workgroup %1 = OpFunction %2 None %5 %7 = OpLabel OpAtomicStore %var %workgroup %semantics %workgroup OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("AtomicStore: MakeAvailableKHR Memory Semantics also requires " "either Release or AcquireRelease Memory Semantics")); } TEST_F(ValidateAtomics, MakeVisibleKHRRequiresAcquireSemantics) { const std::string text = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR OpEntryPoint Fragment %1 "func" OpExecutionMode %1 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeInt 32 0 %semantics = OpConstant %3 16640 %5 = OpTypeFunction %2 %workgroup = OpConstant %3 2 %ptr = OpTypePointer Workgroup %3 %var = OpVariable %ptr Workgroup %1 = OpFunction %2 None %5 %7 = OpLabel %ld = OpAtomicLoad %3 %var %workgroup %semantics OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("AtomicLoad: MakeVisibleKHR Memory Semantics also requires " "either Acquire or AcquireRelease Memory Semantics")); } TEST_F(ValidateAtomics, MakeAvailableKHRRequiresStorageSemantics) { const std::string text = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR OpEntryPoint Fragment %1 "func" OpExecutionMode %1 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeInt 32 0 %semantics = OpConstant %3 8196 %5 = OpTypeFunction %2 %workgroup = OpConstant %3 2 %ptr = OpTypePointer Workgroup %3 %var = OpVariable %ptr Workgroup %1 = OpFunction %2 None %5 %7 = OpLabel OpAtomicStore %var %workgroup %semantics %workgroup OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "AtomicStore: expected Memory Semantics to include a storage class")); } TEST_F(ValidateAtomics, MakeVisibleKHRRequiresStorageSemantics) { const std::string text = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR OpEntryPoint Fragment %1 "func" OpExecutionMode %1 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeInt 32 0 %semantics = OpConstant %3 16386 %5 = OpTypeFunction %2 %workgroup = OpConstant %3 2 %ptr = OpTypePointer Workgroup %3 %var = OpVariable %ptr Workgroup %1 = OpFunction %2 None %5 %7 = OpLabel %ld = OpAtomicLoad %3 %var %workgroup %semantics OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "AtomicLoad: expected Memory Semantics to include a storage class")); } TEST_F(ValidateAtomics, VulkanMemoryModelAllowsQueueFamilyKHR) { const std::string body = R"( %val = OpAtomicAnd %u32 %u32_var %queuefamily %relaxed %u32_1 )"; const std::string extra = R"( OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderComputeCode(body, extra, "", "VulkanKHR"), SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_1)); } TEST_F(ValidateAtomics, NonVulkanMemoryModelDisallowsQueueFamilyKHR) { const std::string body = R"( %val = OpAtomicAnd %u32 %u32_var %queuefamily %relaxed %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body), SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicAnd: Memory Scope QueueFamilyKHR requires " "capability VulkanMemoryModelKHR\n %42 = OpAtomicAnd " "%uint %29 %uint_5 %uint_0_1 %uint_1\n")); } TEST_F(ValidateAtomics, SemanticsSpecConstantShader) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %int = OpTypeInt 32 0 %spec_const = OpSpecConstant %int 0 %workgroup = OpConstant %int 2 %ptr_int_workgroup = OpTypePointer Workgroup %int %var = OpVariable %ptr_int_workgroup Workgroup %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel %ld = OpAtomicLoad %int %var %workgroup %spec_const OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Memory Semantics ids must be OpConstant when Shader " "capability is present")); } TEST_F(ValidateAtomics, SemanticsSpecConstantKernel) { const std::string spirv = R"( OpCapability Kernel OpCapability Linkage OpMemoryModel Logical OpenCL %void = OpTypeVoid %int = OpTypeInt 32 0 %spec_const = OpSpecConstant %int 0 %workgroup = OpConstant %int 2 %ptr_int_workgroup = OpTypePointer Workgroup %int %var = OpVariable %ptr_int_workgroup Workgroup %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel %ld = OpAtomicLoad %int %var %workgroup %spec_const OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateAtomics, ScopeSpecConstantShader) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %int = OpTypeInt 32 0 %spec_const = OpSpecConstant %int 0 %relaxed = OpConstant %int 0 %ptr_int_workgroup = OpTypePointer Workgroup %int %var = OpVariable %ptr_int_workgroup Workgroup %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel %ld = OpAtomicLoad %int %var %spec_const %relaxed OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Scope ids must be OpConstant when Shader capability is present")); } TEST_F(ValidateAtomics, ScopeSpecConstantKernel) { const std::string spirv = R"( OpCapability Kernel OpCapability Linkage OpMemoryModel Logical OpenCL %void = OpTypeVoid %int = OpTypeInt 32 0 %spec_const = OpSpecConstant %int 0 %relaxed = OpConstant %int 0 %ptr_int_workgroup = OpTypePointer Workgroup %int %var = OpVariable %ptr_int_workgroup Workgroup %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel %ld = OpAtomicLoad %int %var %spec_const %relaxed OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateAtomics, VulkanMemoryModelDeviceScopeBad) { const std::string body = R"( %val = OpAtomicAnd %u32 %u32_var %device %relaxed %u32_1 )"; const std::string extra = R"(OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "", "VulkanKHR"), SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Use of device scope with VulkanKHR memory model requires the " "VulkanMemoryModelDeviceScopeKHR capability")); } TEST_F(ValidateAtomics, VulkanMemoryModelDeviceScopeGood) { const std::string body = R"( %val = OpAtomicAnd %u32 %u32_var %device %relaxed %u32_1 )"; const std::string extra = R"(OpCapability VulkanMemoryModelKHR OpCapability VulkanMemoryModelDeviceScopeKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "", "VulkanKHR"), SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateAtomics, CompareExchangeWeakV13ValV14Good) { const std::string body = R"( %val1 = OpAtomicCompareExchangeWeak %u32 %u32_var %device %relaxed %relaxed %u32_0 %u32_0 )"; CompileSuccessfully(GenerateKernelCode(body), SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); } TEST_F(ValidateAtomics, CompareExchangeWeakV14Bad) { const std::string body = R"( %val1 = OpAtomicCompareExchangeWeak %u32 %u32_var %device %relaxed %relaxed %u32_0 %u32_0 )"; CompileSuccessfully(GenerateKernelCode(body), SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_WRONG_VERSION, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "AtomicCompareExchangeWeak requires SPIR-V version 1.3 or earlier")); } TEST_F(ValidateAtomics, CompareExchangeVolatileMatch) { const std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability Linkage OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %workgroup = OpConstant %int 2 %volatile = OpConstant %int 32768 %ptr_wg_int = OpTypePointer Workgroup %int %wg_var = OpVariable %ptr_wg_int Workgroup %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel %cmp_ex = OpAtomicCompareExchange %int %wg_var %workgroup %volatile %volatile %int_0 %int_1 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateAtomics, CompareExchangeVolatileMismatch) { const std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability Linkage OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %workgroup = OpConstant %int 2 %volatile = OpConstant %int 32768 %non_volatile = OpConstant %int 0 %ptr_wg_int = OpTypePointer Workgroup %int %wg_var = OpVariable %ptr_wg_int Workgroup %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel %cmp_ex = OpAtomicCompareExchange %int %wg_var %workgroup %non_volatile %volatile %int_0 %int_1 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Volatile mask setting must match for Equal and " "Unequal memory semantics")); } TEST_F(ValidateAtomics, CompareExchangeVolatileMismatchCooperativeMatrix) { const std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability Linkage OpCapability CooperativeMatrixNV OpExtension "SPV_KHR_vulkan_memory_model" OpExtension "SPV_NV_cooperative_matrix" OpMemoryModel Logical VulkanKHR %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %workgroup = OpConstant %int 2 %volatile = OpSpecConstant %int 32768 %non_volatile = OpSpecConstant %int 32768 %ptr_wg_int = OpTypePointer Workgroup %int %wg_var = OpVariable %ptr_wg_int Workgroup %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel %cmp_ex = OpAtomicCompareExchange %int %wg_var %workgroup %volatile %non_volatile %int_0 %int_1 OpReturn OpFunctionEnd )"; // This is ok because we cannot evaluate the spec constant defaults. CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateAtomics, VolatileRequiresVulkanMemoryModel) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %workgroup = OpConstant %int 2 %volatile = OpConstant %int 32768 %ptr_wg_int = OpTypePointer Workgroup %int %wg_var = OpVariable %ptr_wg_int Workgroup %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel %ld = OpAtomicLoad %int %wg_var %workgroup %volatile OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Memory Semantics Volatile requires capability " "VulkanMemoryModelKHR")); } TEST_F(ValidateAtomics, CooperativeMatrixSemanticsMustBeConstant) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability CooperativeMatrixNV OpExtension "SPV_NV_cooperative_matrix" OpMemoryModel Logical GLSL450 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %workgroup = OpConstant %int 2 %undef = OpUndef %int %ptr_wg_int = OpTypePointer Workgroup %int %wg_var = OpVariable %ptr_wg_int Workgroup %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel %ld = OpAtomicLoad %int %wg_var %workgroup %undef OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Memory Semantics must be a constant instruction when " "CooperativeMatrixNV capability is present")); } TEST_F(ValidateAtomics, IIncrementBadPointerDataType) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %_ptr_Input_uint = OpTypePointer Input %uint %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %void = OpTypeVoid %16 = OpTypeFunction %void %uint_538976288 = OpConstant %uint 538976288 %int = OpTypeInt 32 1 %_runtimearr_int = OpTypeRuntimeArray %int %_struct_5 = OpTypeStruct %_runtimearr_int %_ptr_Uniform__struct_5 = OpTypePointer Uniform %_struct_5 %3 = OpVariable %_ptr_Input_v3uint Input %7 = OpVariable %_ptr_Uniform__struct_5 Uniform %8224 = OpFunction %void None %16 %65312 = OpLabel %25 = OpAccessChain %_ptr_Input_uint %3 %uint_538976288 %26 = OpLoad %uint %25 %2097184 = OpAtomicIIncrement %int %7 %uint_538976288 %26 OpUnreachable OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicIIncrement: expected Pointer to point to a " "value of type Result Type")); } TEST_F(ValidateAtomics, AtomicFloat16VectorSuccess) { const std::string definitions = R"( %f16 = OpTypeFloat 16 %f16vec2 = OpTypeVector %f16 2 %f16vec4 = OpTypeVector %f16 4 %f16_1 = OpConstant %f16 1 %f16vec2_1 = OpConstantComposite %f16vec2 %f16_1 %f16_1 %f16vec4_1 = OpConstantComposite %f16vec4 %f16_1 %f16_1 %f16_1 %f16_1 %f16vec2_ptr = OpTypePointer Workgroup %f16vec2 %f16vec4_ptr = OpTypePointer Workgroup %f16vec4 %f16vec2_var = OpVariable %f16vec2_ptr Workgroup %f16vec4_var = OpVariable %f16vec4_ptr Workgroup )"; const std::string body = R"( %val3 = OpAtomicFMinEXT %f16vec2 %f16vec2_var %device %relaxed %f16vec2_1 %val4 = OpAtomicFMaxEXT %f16vec2 %f16vec2_var %device %relaxed %f16vec2_1 %val8 = OpAtomicFAddEXT %f16vec2 %f16vec2_var %device %relaxed %f16vec2_1 %val9 = OpAtomicExchange %f16vec2 %f16vec2_var %device %relaxed %f16vec2_1 %val11 = OpAtomicFMinEXT %f16vec4 %f16vec4_var %device %relaxed %f16vec4_1 %val12 = OpAtomicFMaxEXT %f16vec4 %f16vec4_var %device %relaxed %f16vec4_1 %val18 = OpAtomicFAddEXT %f16vec4 %f16vec4_var %device %relaxed %f16vec4_1 %val19 = OpAtomicExchange %f16vec4 %f16vec4_var %device %relaxed %f16vec4_1 )"; CompileSuccessfully(GenerateShaderComputeCode( body, "OpCapability Float16\n" "OpCapability AtomicFloat16VectorNV\n" "OpExtension \"SPV_NV_shader_atomic_fp16_vector\"\n", definitions), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } static constexpr char Float16Vector3Defs[] = R"( %f16 = OpTypeFloat 16 %f16vec3 = OpTypeVector %f16 3 %f16_1 = OpConstant %f16 1 %f16vec3_1 = OpConstantComposite %f16vec3 %f16_1 %f16_1 %f16_1 %f16vec3_ptr = OpTypePointer Workgroup %f16vec3 %f16vec3_var = OpVariable %f16vec3_ptr Workgroup )"; TEST_F(ValidateAtomics, AtomicFloat16Vector3MinFail) { const std::string definitions = Float16Vector3Defs; const std::string body = R"( %val11 = OpAtomicFMinEXT %f16vec3 %f16vec3_var %device %relaxed %f16vec3_1 )"; CompileSuccessfully(GenerateShaderComputeCode( body, "OpCapability Float16\n" "OpCapability AtomicFloat16VectorNV\n" "OpExtension \"SPV_NV_shader_atomic_fp16_vector\"\n", definitions), SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("AtomicFMinEXT: expected Result Type to be float scalar type")); } TEST_F(ValidateAtomics, AtomicFloat16Vector3MaxFail) { const std::string definitions = Float16Vector3Defs; const std::string body = R"( %val12 = OpAtomicFMaxEXT %f16vec3 %f16vec3_var %device %relaxed %f16vec3_1 )"; CompileSuccessfully(GenerateShaderComputeCode( body, "OpCapability Float16\n" "OpCapability AtomicFloat16VectorNV\n" "OpExtension \"SPV_NV_shader_atomic_fp16_vector\"\n", definitions), SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("AtomicFMaxEXT: expected Result Type to be float scalar type")); } TEST_F(ValidateAtomics, AtomicFloat16Vector3AddFail) { const std::string definitions = Float16Vector3Defs; const std::string body = R"( %val18 = OpAtomicFAddEXT %f16vec3 %f16vec3_var %device %relaxed %f16vec3_1 )"; CompileSuccessfully(GenerateShaderComputeCode( body, "OpCapability Float16\n" "OpCapability AtomicFloat16VectorNV\n" "OpExtension \"SPV_NV_shader_atomic_fp16_vector\"\n", definitions), SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("AtomicFAddEXT: expected Result Type to be float scalar type")); } TEST_F(ValidateAtomics, AtomicFloat16Vector3ExchangeFail) { const std::string definitions = Float16Vector3Defs; const std::string body = R"( %val19 = OpAtomicExchange %f16vec3 %f16vec3_var %device %relaxed %f16vec3_1 )"; CompileSuccessfully(GenerateShaderComputeCode( body, "OpCapability Float16\n" "OpCapability AtomicFloat16VectorNV\n" "OpExtension \"SPV_NV_shader_atomic_fp16_vector\"\n", definitions), SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("AtomicExchange: expected Result Type to be integer or " "float scalar type")); } TEST_F(ValidateAtomics, AtomicLoadUntypedPointer) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpCapability WorkgroupMemoryExplicitLayoutKHR OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %var OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %struct = OpTypeStruct %int %ptr = OpTypeUntypedPointerKHR Workgroup %var = OpUntypedVariableKHR %ptr Workgroup %struct %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %load = OpAtomicLoad %int %var %int_1 %int_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); } TEST_F(ValidateAtomics, AtomicStoreUntypedPointer) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpCapability WorkgroupMemoryExplicitLayoutKHR OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %var OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %struct = OpTypeStruct %int %ptr = OpTypeUntypedPointerKHR Workgroup %var = OpUntypedVariableKHR %ptr Workgroup %struct %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpAtomicStore %var %int_1 %int_0 %int_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); } TEST_F(ValidateAtomics, AtomicExchangeUntypedPointer) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpCapability WorkgroupMemoryExplicitLayoutKHR OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %var OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %struct = OpTypeStruct %int %ptr = OpTypeUntypedPointerKHR Workgroup %var = OpUntypedVariableKHR %ptr Workgroup %struct %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %ex = OpAtomicExchange %int %var %int_1 %int_0 %int_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); } TEST_F(ValidateAtomics, AtomicFlagClearUntypedPointer) { const std::string spirv = R"( OpCapability Kernel OpCapability Linkage OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical OpenCL %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %ptr = OpTypeUntypedPointerKHR Workgroup %var = OpUntypedVariableKHR %ptr Workgroup %int %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpAtomicFlagClear %var %int_1 %int_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Untyped pointers are not supported by atomic flag instructions")); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_barriers_test.cpp000066400000000000000000001512671475742701700245240ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gmock/gmock.h" #include "test/unit_spirv.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::HasSubstr; using ::testing::Not; using ValidateBarriers = spvtest::ValidateBase; std::string GenerateShaderCodeImpl( const std::string& body, const std::string& capabilities_and_extensions, const std::string& definitions, const std::string& execution_model, const std::string& memory_model) { std::ostringstream ss; ss << R"( OpCapability Shader )"; ss << capabilities_and_extensions; ss << memory_model << std::endl; ss << "OpEntryPoint " << execution_model << " %main \"main\"\n"; if (execution_model == "Fragment") { ss << "OpExecutionMode %main OriginUpperLeft\n"; } else if (execution_model == "Geometry") { ss << "OpExecutionMode %main InputPoints\n"; ss << "OpExecutionMode %main OutputPoints\n"; } else if (execution_model == "GLCompute") { ss << "OpExecutionMode %main LocalSize 1 1 1\n"; } ss << R"( %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f32 = OpTypeFloat 32 %u32 = OpTypeInt 32 0 %f32_0 = OpConstant %f32 0 %f32_1 = OpConstant %f32 1 %u32_0 = OpConstant %u32 0 %u32_1 = OpConstant %u32 1 %u32_4 = OpConstant %u32 4 )"; ss << definitions; ss << R"( %cross_device = OpConstant %u32 0 %device = OpConstant %u32 1 %workgroup = OpConstant %u32 2 %subgroup = OpConstant %u32 3 %invocation = OpConstant %u32 4 %queuefamily = OpConstant %u32 5 %shadercall = OpConstant %u32 6 %none = OpConstant %u32 0 %acquire = OpConstant %u32 2 %release = OpConstant %u32 4 %acquire_release = OpConstant %u32 8 %acquire_and_release = OpConstant %u32 6 %sequentially_consistent = OpConstant %u32 16 %acquire_release_uniform_workgroup = OpConstant %u32 328 %acquire_uniform_workgroup = OpConstant %u32 322 %release_uniform_workgroup = OpConstant %u32 324 %acquire_and_release_uniform = OpConstant %u32 70 %acquire_release_subgroup = OpConstant %u32 136 %acquire_release_workgroup = OpConstant %u32 264 %uniform = OpConstant %u32 64 %uniform_workgroup = OpConstant %u32 320 %workgroup_memory = OpConstant %u32 256 %image_memory = OpConstant %u32 2048 %uniform_image_memory = OpConstant %u32 2112 %main = OpFunction %void None %func %main_entry = OpLabel )"; ss << body; ss << R"( OpReturn OpFunctionEnd)"; return ss.str(); } std::string GenerateShaderCode( const std::string& body, const std::string& capabilities_and_extensions = "", const std::string& execution_model = "GLCompute") { const std::string int64_capability = R"( OpCapability Int64 )"; const std::string int64_declarations = R"( %u64 = OpTypeInt 64 0 %u64_0 = OpConstant %u64 0 %u64_1 = OpConstant %u64 1 )"; const std::string memory_model = "OpMemoryModel Logical GLSL450"; return GenerateShaderCodeImpl( body, int64_capability + capabilities_and_extensions, int64_declarations, execution_model, memory_model); } std::string GenerateVulkanVertexShaderCode( const std::string& body, const std::string& capabilities_and_extensions = "", const std::string& execution_model = "Vertex") { const std::string memory_model = "OpMemoryModel Logical GLSL450"; return GenerateShaderCodeImpl(body, capabilities_and_extensions, "", execution_model, memory_model); } std::string GenerateKernelCode( const std::string& body, const std::string& capabilities_and_extensions = "") { std::ostringstream ss; ss << R"( OpCapability Addresses OpCapability Kernel OpCapability Linkage OpCapability Int64 OpCapability NamedBarrier )"; ss << capabilities_and_extensions; ss << R"( OpMemoryModel Physical32 OpenCL %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f32 = OpTypeFloat 32 %u32 = OpTypeInt 32 0 %u64 = OpTypeInt 64 0 %f32_0 = OpConstant %f32 0 %f32_1 = OpConstant %f32 1 %f32_4 = OpConstant %f32 4 %u32_0 = OpConstant %u32 0 %u32_1 = OpConstant %u32 1 %u32_4 = OpConstant %u32 4 %u64_0 = OpConstant %u64 0 %u64_1 = OpConstant %u64 1 %u64_4 = OpConstant %u64 4 %cross_device = OpConstant %u32 0 %device = OpConstant %u32 1 %workgroup = OpConstant %u32 2 %subgroup = OpConstant %u32 3 %invocation = OpConstant %u32 4 %none = OpConstant %u32 0 %acquire = OpConstant %u32 2 %release = OpConstant %u32 4 %acquire_release = OpConstant %u32 8 %acquire_and_release = OpConstant %u32 6 %sequentially_consistent = OpConstant %u32 16 %acquire_release_workgroup = OpConstant %u32 264 %named_barrier = OpTypeNamedBarrier %main = OpFunction %void None %func %main_entry = OpLabel )"; ss << body; ss << R"( OpReturn OpFunctionEnd)"; return ss.str(); } TEST_F(ValidateBarriers, OpControlBarrierGLComputeSuccess) { const std::string body = R"( OpControlBarrier %device %device %none OpControlBarrier %workgroup %workgroup %acquire OpControlBarrier %workgroup %device %release OpControlBarrier %cross_device %cross_device %acquire_release OpControlBarrier %cross_device %cross_device %sequentially_consistent OpControlBarrier %cross_device %cross_device %acquire_release_uniform_workgroup )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateBarriers, OpControlBarrierKernelSuccess) { const std::string body = R"( OpControlBarrier %device %device %none OpControlBarrier %workgroup %workgroup %acquire OpControlBarrier %workgroup %device %release OpControlBarrier %cross_device %cross_device %acquire_release OpControlBarrier %cross_device %cross_device %sequentially_consistent OpControlBarrier %cross_device %cross_device %acquire_release_workgroup )"; CompileSuccessfully(GenerateKernelCode(body), SPV_ENV_UNIVERSAL_1_1); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_1)); } TEST_F(ValidateBarriers, OpControlBarrierTesselationControlSuccess) { const std::string body = R"( OpControlBarrier %device %device %none OpControlBarrier %workgroup %workgroup %acquire OpControlBarrier %workgroup %device %release OpControlBarrier %cross_device %cross_device %acquire_release OpControlBarrier %cross_device %cross_device %sequentially_consistent OpControlBarrier %cross_device %cross_device %acquire_release_uniform_workgroup )"; CompileSuccessfully(GenerateShaderCode(body, "OpCapability Tessellation\n", "TessellationControl")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateBarriers, OpControlBarrierVulkanSuccess) { const std::string body = R"( OpControlBarrier %workgroup %device %none OpControlBarrier %workgroup %workgroup %acquire_release_uniform_workgroup )"; CompileSuccessfully(GenerateShaderCode(body), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateBarriers, OpControlBarrierExecutionModelFragmentSpirv12) { const std::string body = R"( OpControlBarrier %device %device %none )"; CompileSuccessfully(GenerateShaderCode(body, "", "Fragment"), SPV_ENV_UNIVERSAL_1_2); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_2)); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpControlBarrier requires one of the following " "Execution Models: TessellationControl, GLCompute, Kernel, " "MeshNV or TaskNV")); } TEST_F(ValidateBarriers, OpControlBarrierExecutionModelFragmentSpirv13) { const std::string body = R"( OpControlBarrier %device %device %none )"; CompileSuccessfully(GenerateShaderCode(body, "", "Fragment"), SPV_ENV_UNIVERSAL_1_3); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateBarriers, OpControlBarrierFloatExecutionScope) { const std::string body = R"( OpControlBarrier %f32_1 %device %none )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("ControlBarrier: expected scope to be a 32-bit int")); } TEST_F(ValidateBarriers, OpControlBarrierU64ExecutionScope) { const std::string body = R"( OpControlBarrier %u64_1 %device %none )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("ControlBarrier: expected scope to be a 32-bit int")); } TEST_F(ValidateBarriers, OpControlBarrierFloatMemoryScope) { const std::string body = R"( OpControlBarrier %device %f32_1 %none )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("ControlBarrier: expected scope to be a 32-bit int")); } TEST_F(ValidateBarriers, OpControlBarrierU64MemoryScope) { const std::string body = R"( OpControlBarrier %device %u64_1 %none )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("ControlBarrier: expected scope to be a 32-bit int")); } TEST_F(ValidateBarriers, OpControlBarrierFloatMemorySemantics) { const std::string body = R"( OpControlBarrier %device %device %f32_0 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "ControlBarrier: expected Memory Semantics to be a 32-bit int")); } TEST_F(ValidateBarriers, OpControlBarrierU64MemorySemantics) { const std::string body = R"( OpControlBarrier %device %device %u64_0 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "ControlBarrier: expected Memory Semantics to be a 32-bit int")); } TEST_F(ValidateBarriers, OpControlBarrierVulkanExecutionScopeDevice) { const std::string body = R"( OpControlBarrier %device %workgroup %none )"; CompileSuccessfully(GenerateShaderCode(body), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-None-04636")); EXPECT_THAT(getDiagnosticString(), HasSubstr("ControlBarrier: in Vulkan environment Execution Scope " "is limited to Workgroup and Subgroup")); } TEST_F(ValidateBarriers, OpControlBarrierVulkanMemoryScopeSubgroup) { const std::string body = R"( OpControlBarrier %subgroup %subgroup %none )"; CompileSuccessfully(GenerateShaderCode(body), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-SubgroupVoteKHR-07951")); EXPECT_THAT( getDiagnosticString(), HasSubstr( "ControlBarrier: in Vulkan 1.0 environment Memory Scope is can not " "be Subgroup without SubgroupBallotKHR or SubgroupVoteKHR declared")); } TEST_F(ValidateBarriers, OpControlBarrierVulkanMemoryScopeSubgroupVoteKHR) { const std::string capabilities = R"( OpCapability SubgroupVoteKHR OpExtension "SPV_KHR_subgroup_vote" )"; const std::string body = R"( OpControlBarrier %subgroup %subgroup %none )"; CompileSuccessfully(GenerateShaderCode(body, capabilities), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateBarriers, OpControlBarrierVulkan1p1MemoryScopeSubgroup) { const std::string body = R"( OpControlBarrier %subgroup %subgroup %none )"; CompileSuccessfully(GenerateShaderCode(body), SPV_ENV_VULKAN_1_1); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_1)); } TEST_F(ValidateBarriers, OpControlBarrierVulkan1p1MemoryScopeCrossDevice) { const std::string body = R"( OpControlBarrier %subgroup %cross_device %none )"; CompileSuccessfully(GenerateShaderCode(body), SPV_ENV_VULKAN_1_1); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-None-04638")); EXPECT_THAT(getDiagnosticString(), HasSubstr("ControlBarrier: in Vulkan environment Memory Scope is " "limited to Device, QueueFamily, Workgroup, " "ShaderCallKHR, Subgroup, or Invocation")); } TEST_F(ValidateBarriers, OpControlBarrierVulkan1p1WorkgroupNonComputeMemoryFailure) { const std::string body = R"( OpControlBarrier %subgroup %workgroup %acquire_release_workgroup )"; CompileSuccessfully(GenerateVulkanVertexShaderCode(body), SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-None-07321")); EXPECT_THAT( getDiagnosticString(), HasSubstr("Workgroup Memory Scope is limited to MeshNV, " "TaskNV, MeshEXT, TaskEXT, TessellationControl, and GLCompute " "execution model")); } TEST_F(ValidateBarriers, OpControlBarrierVulkan1p1WorkgroupNonComputeExecutionFailure) { const std::string body = R"( OpControlBarrier %workgroup %subgroup %acquire_release_workgroup )"; CompileSuccessfully(GenerateVulkanVertexShaderCode(body), SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-None-04637")); EXPECT_THAT(getDiagnosticString(), HasSubstr("in Vulkan environment, Workgroup execution scope is " "only for TaskNV, MeshNV, TaskEXT, MeshEXT, " "TessellationControl, and GLCompute execution models")); } TEST_F(ValidateBarriers, OpControlBarrierVulkan1p1WorkgroupComputeSuccess) { const std::string body = R"( OpControlBarrier %workgroup %workgroup %acquire_uniform_workgroup )"; CompileSuccessfully(GenerateShaderCode(body), SPV_ENV_VULKAN_1_1); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_1)); } TEST_F(ValidateBarriers, OpControlBarrierVulkan1p1WorkgroupNonComputeSuccess) { const std::string body = R"( OpControlBarrier %subgroup %subgroup %acquire_uniform_workgroup )"; CompileSuccessfully(GenerateVulkanVertexShaderCode(body), SPV_ENV_VULKAN_1_1); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_1)); } TEST_F(ValidateBarriers, OpControlBarrierVulkanInvocationSuccess) { const std::string body = R"( OpControlBarrier %workgroup %invocation %none )"; CompileSuccessfully(GenerateShaderCode(body), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateBarriers, OpControlBarrierVulkanInvocationFailure) { const std::string body = R"( OpControlBarrier %workgroup %invocation %acquire )"; CompileSuccessfully(GenerateShaderCode(body), SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-None-04641")); EXPECT_THAT( getDiagnosticString(), HasSubstr("ControlBarrier: Vulkan specification requires Memory " "Semantics to be None if used with Invocation Memory Scope")); } TEST_F(ValidateBarriers, OpControlBarrierAcquireAndRelease) { const std::string body = R"( OpControlBarrier %device %device %acquire_and_release_uniform )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("ControlBarrier: Memory Semantics can have at most one " "of the following bits set: Acquire, Release, " "AcquireRelease or SequentiallyConsistent")); } TEST_F(ValidateBarriers, OpControlBarrierVulkanSubgroupStorageClass) { const std::string body = R"( OpControlBarrier %workgroup %device %acquire_release_subgroup )"; CompileSuccessfully(GenerateShaderCode(body), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpControlBarrier-04650")); EXPECT_THAT( getDiagnosticString(), HasSubstr( "ControlBarrier: expected Memory Semantics to include a " "Vulkan-supported storage class if Memory Semantics is not None")); } TEST_F(ValidateBarriers, OpControlBarrierSubgroupExecutionFragment1p1) { const std::string body = R"( OpControlBarrier %subgroup %subgroup %acquire_release_workgroup )"; CompileSuccessfully(GenerateShaderCode(body, "", "Fragment"), SPV_ENV_VULKAN_1_1); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_1)); } TEST_F(ValidateBarriers, OpControlBarrierWorkgroupExecutionFragment1p1) { const std::string body = R"( OpControlBarrier %workgroup %workgroup %acquire_release_workgroup )"; CompileSuccessfully(GenerateShaderCode(body, "", "Fragment"), SPV_ENV_VULKAN_1_1); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpControlBarrier-04682")); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpControlBarrier execution scope must be Subgroup for Fragment, " "Vertex, Geometry, TessellationEvaluation, RayGeneration, " "Intersection, AnyHit, ClosestHit, and Miss execution models")); } TEST_F(ValidateBarriers, OpControlBarrierSubgroupExecutionFragment1p0) { const std::string body = R"( OpControlBarrier %subgroup %workgroup %acquire_release_workgroup )"; CompileSuccessfully(GenerateShaderCode(body, "", "Fragment"), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpControlBarrier requires one of the following " "Execution " "Models: TessellationControl, GLCompute, Kernel, " "MeshNV or TaskNV")); } TEST_F(ValidateBarriers, OpControlBarrierSubgroupExecutionVertex1p1) { const std::string body = R"( OpControlBarrier %subgroup %subgroup %acquire_release_workgroup )"; CompileSuccessfully(GenerateShaderCode(body, "", "Vertex"), SPV_ENV_VULKAN_1_1); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_1)); } TEST_F(ValidateBarriers, OpControlBarrierWorkgroupExecutionVertex1p1) { const std::string body = R"( OpControlBarrier %workgroup %workgroup %acquire_release_workgroup )"; CompileSuccessfully(GenerateShaderCode(body, "", "Vertex"), SPV_ENV_VULKAN_1_1); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpControlBarrier-04682")); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpControlBarrier execution scope must be Subgroup for Fragment, " "Vertex, Geometry, TessellationEvaluation, RayGeneration, " "Intersection, AnyHit, ClosestHit, and Miss execution models")); } TEST_F(ValidateBarriers, OpControlBarrierSubgroupExecutionVertex1p0) { const std::string body = R"( OpControlBarrier %subgroup %workgroup %acquire_release_workgroup )"; CompileSuccessfully(GenerateShaderCode(body, "", "Vertex"), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpControlBarrier requires one of the following " "Execution Models: TessellationControl, GLCompute, Kernel, " "MeshNV or TaskNV")); } TEST_F(ValidateBarriers, OpControlBarrierSubgroupExecutionGeometry1p1) { const std::string body = R"( OpControlBarrier %subgroup %subgroup %acquire_release_workgroup )"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability Geometry\n", "Geometry"), SPV_ENV_VULKAN_1_1); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_1)); } TEST_F(ValidateBarriers, OpControlBarrierWorkgroupExecutionGeometry1p1) { const std::string body = R"( OpControlBarrier %workgroup %workgroup %acquire_release_workgroup )"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability Geometry\n", "Geometry"), SPV_ENV_VULKAN_1_1); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpControlBarrier-04682")); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpControlBarrier execution scope must be Subgroup for Fragment, " "Vertex, Geometry, TessellationEvaluation, RayGeneration, " "Intersection, AnyHit, ClosestHit, and Miss execution models")); } TEST_F(ValidateBarriers, OpControlBarrierSubgroupExecutionGeometry1p0) { const std::string body = R"( OpControlBarrier %subgroup %workgroup %acquire_release_workgroup )"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability Geometry\n", "Geometry"), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpControlBarrier requires one of the following " "Execution " "Models: TessellationControl, GLCompute, Kernel, " "MeshNV or TaskNV")); } TEST_F(ValidateBarriers, OpControlBarrierSubgroupExecutionTessellationEvaluation1p1) { const std::string body = R"( OpControlBarrier %subgroup %subgroup %acquire_release_workgroup )"; CompileSuccessfully(GenerateShaderCode(body, "OpCapability Tessellation\n", "TessellationEvaluation"), SPV_ENV_VULKAN_1_1); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_1)); } TEST_F(ValidateBarriers, OpControlBarrierWorkgroupExecutionTessellationEvaluation1p1) { const std::string body = R"( OpControlBarrier %workgroup %workgroup %acquire_release_workgroup )"; CompileSuccessfully(GenerateShaderCode(body, "OpCapability Tessellation\n", "TessellationEvaluation"), SPV_ENV_VULKAN_1_1); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpControlBarrier-04682")); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpControlBarrier execution scope must be Subgroup for Fragment, " "Vertex, Geometry, TessellationEvaluation, RayGeneration, " "Intersection, AnyHit, ClosestHit, and Miss execution models")); } TEST_F(ValidateBarriers, OpControlBarrierSubgroupExecutionTessellationEvaluation1p0) { const std::string body = R"( OpControlBarrier %subgroup %workgroup %acquire_release_workgroup )"; CompileSuccessfully(GenerateShaderCode(body, "OpCapability Tessellation\n", "TessellationEvaluation"), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpControlBarrier requires one of the following " "Execution " "Models: TessellationControl, GLCompute, Kernel, " "MeshNV or TaskNV")); } TEST_F(ValidateBarriers, OpMemoryBarrierSuccess) { const std::string body = R"( OpMemoryBarrier %cross_device %acquire_release_uniform_workgroup OpMemoryBarrier %device %uniform )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateBarriers, OpMemoryBarrierKernelSuccess) { const std::string body = R"( OpMemoryBarrier %cross_device %acquire_release_workgroup OpMemoryBarrier %device %none )"; CompileSuccessfully(GenerateKernelCode(body), SPV_ENV_UNIVERSAL_1_1); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_1)); } TEST_F(ValidateBarriers, OpMemoryBarrierVulkanSuccess) { const std::string body = R"( OpMemoryBarrier %workgroup %acquire_release_uniform_workgroup )"; CompileSuccessfully(GenerateShaderCode(body), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateBarriers, OpMemoryBarrierFloatMemoryScope) { const std::string body = R"( OpMemoryBarrier %f32_1 %acquire_release_uniform_workgroup )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("MemoryBarrier: expected scope to be a 32-bit int")); } TEST_F(ValidateBarriers, OpMemoryBarrierU64MemoryScope) { const std::string body = R"( OpMemoryBarrier %u64_1 %acquire_release_uniform_workgroup )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("MemoryBarrier: expected scope to be a 32-bit int")); } TEST_F(ValidateBarriers, OpMemoryBarrierFloatMemorySemantics) { const std::string body = R"( OpMemoryBarrier %device %f32_0 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("MemoryBarrier: expected Memory Semantics to be a 32-bit int")); } TEST_F(ValidateBarriers, OpMemoryBarrierU64MemorySemantics) { const std::string body = R"( OpMemoryBarrier %device %u64_0 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("MemoryBarrier: expected Memory Semantics to be a 32-bit int")); } TEST_F(ValidateBarriers, OpMemoryBarrierVulkanMemoryScopeSubgroup) { const std::string body = R"( OpMemoryBarrier %subgroup %acquire_release_uniform_workgroup )"; CompileSuccessfully(GenerateShaderCode(body), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-SubgroupVoteKHR-07951")); EXPECT_THAT( getDiagnosticString(), HasSubstr( "MemoryBarrier: in Vulkan 1.0 environment Memory Scope is can not be " "Subgroup without SubgroupBallotKHR or SubgroupVoteKHR declared")); } TEST_F(ValidateBarriers, OpMemoryBarrierVulkan1p1MemoryScopeSubgroup) { const std::string body = R"( OpMemoryBarrier %subgroup %acquire_release_uniform_workgroup )"; CompileSuccessfully(GenerateShaderCode(body), SPV_ENV_VULKAN_1_1); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_1)); } TEST_F(ValidateBarriers, OpMemoryBarrierAcquireAndRelease) { const std::string body = R"( OpMemoryBarrier %device %acquire_and_release_uniform )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("MemoryBarrier: Memory Semantics can have at most one " "of the following bits set: Acquire, Release, " "AcquireRelease or SequentiallyConsistent")); } TEST_F(ValidateBarriers, OpMemoryBarrierVulkanMemorySemanticsNone) { const std::string body = R"( OpMemoryBarrier %device %none )"; CompileSuccessfully(GenerateShaderCode(body), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpMemoryBarrier-04732")); EXPECT_THAT( getDiagnosticString(), HasSubstr("MemoryBarrier: Vulkan specification requires Memory Semantics " "to have one of the following bits set: Acquire, Release, " "AcquireRelease or SequentiallyConsistent")); } TEST_F(ValidateBarriers, OpMemoryBarrierVulkanMemorySemanticsAcquire) { const std::string body = R"( OpMemoryBarrier %device %acquire )"; CompileSuccessfully(GenerateShaderCode(body), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpMemoryBarrier-04733")); EXPECT_THAT(getDiagnosticString(), HasSubstr("MemoryBarrier: expected Memory Semantics to include a " "Vulkan-supported storage class")); } TEST_F(ValidateBarriers, OpMemoryBarrierVulkanSubgroupStorageClass) { const std::string body = R"( OpMemoryBarrier %device %acquire_release_subgroup )"; CompileSuccessfully(GenerateShaderCode(body), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpMemoryBarrier-04733")); EXPECT_THAT(getDiagnosticString(), HasSubstr("MemoryBarrier: expected Memory Semantics to include a " "Vulkan-supported storage class")); } TEST_F(ValidateBarriers, OpNamedBarrierInitializeSuccess) { const std::string body = R"( %barrier = OpNamedBarrierInitialize %named_barrier %u32_4 )"; CompileSuccessfully(GenerateKernelCode(body), SPV_ENV_UNIVERSAL_1_1); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_1)); } TEST_F(ValidateBarriers, OpNamedBarrierInitializeWrongResultType) { const std::string body = R"( %barrier = OpNamedBarrierInitialize %u32 %u32_4 )"; CompileSuccessfully(GenerateKernelCode(body), SPV_ENV_UNIVERSAL_1_1); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_1)); EXPECT_THAT(getDiagnosticString(), HasSubstr("NamedBarrierInitialize: expected Result Type to be " "OpTypeNamedBarrier")); } TEST_F(ValidateBarriers, OpNamedBarrierInitializeFloatSubgroupCount) { const std::string body = R"( %barrier = OpNamedBarrierInitialize %named_barrier %f32_4 )"; CompileSuccessfully(GenerateKernelCode(body), SPV_ENV_UNIVERSAL_1_1); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_1)); EXPECT_THAT(getDiagnosticString(), HasSubstr("NamedBarrierInitialize: expected Subgroup Count to be " "a 32-bit int")); } TEST_F(ValidateBarriers, OpNamedBarrierInitializeU64SubgroupCount) { const std::string body = R"( %barrier = OpNamedBarrierInitialize %named_barrier %u64_4 )"; CompileSuccessfully(GenerateKernelCode(body), SPV_ENV_UNIVERSAL_1_1); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_1)); EXPECT_THAT(getDiagnosticString(), HasSubstr("NamedBarrierInitialize: expected Subgroup Count to be " "a 32-bit int")); } TEST_F(ValidateBarriers, OpMemoryNamedBarrierSuccess) { const std::string body = R"( %barrier = OpNamedBarrierInitialize %named_barrier %u32_4 OpMemoryNamedBarrier %barrier %workgroup %acquire_release_workgroup )"; CompileSuccessfully(GenerateKernelCode(body), SPV_ENV_UNIVERSAL_1_1); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_1)); } TEST_F(ValidateBarriers, OpMemoryNamedBarrierNotNamedBarrier) { const std::string body = R"( OpMemoryNamedBarrier %u32_1 %workgroup %acquire_release_workgroup )"; CompileSuccessfully(GenerateKernelCode(body), SPV_ENV_UNIVERSAL_1_1); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_1)); EXPECT_THAT(getDiagnosticString(), HasSubstr("MemoryNamedBarrier: expected Named Barrier to be of " "type OpTypeNamedBarrier")); } TEST_F(ValidateBarriers, OpMemoryNamedBarrierFloatMemoryScope) { const std::string body = R"( %barrier = OpNamedBarrierInitialize %named_barrier %u32_4 OpMemoryNamedBarrier %barrier %f32_1 %acquire_release_workgroup )"; CompileSuccessfully(GenerateKernelCode(body), SPV_ENV_UNIVERSAL_1_1); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_1)); EXPECT_THAT( getDiagnosticString(), HasSubstr("MemoryNamedBarrier: expected scope to be a 32-bit int")); } TEST_F(ValidateBarriers, OpMemoryNamedBarrierFloatMemorySemantics) { const std::string body = R"( %barrier = OpNamedBarrierInitialize %named_barrier %u32_4 OpMemoryNamedBarrier %barrier %workgroup %f32_0 )"; CompileSuccessfully(GenerateKernelCode(body), SPV_ENV_UNIVERSAL_1_1); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_1)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "MemoryNamedBarrier: expected Memory Semantics to be a 32-bit int")); } TEST_F(ValidateBarriers, OpMemoryNamedBarrierAcquireAndRelease) { const std::string body = R"( %barrier = OpNamedBarrierInitialize %named_barrier %u32_4 OpMemoryNamedBarrier %barrier %workgroup %acquire_and_release )"; CompileSuccessfully(GenerateKernelCode(body), SPV_ENV_UNIVERSAL_1_1); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_1)); EXPECT_THAT(getDiagnosticString(), HasSubstr("MemoryNamedBarrier: Memory Semantics can have at most " "one of the following bits set: Acquire, Release, " "AcquireRelease or SequentiallyConsistent")); } TEST_F(ValidateBarriers, TypeAsMemoryScope) { const std::string body = R"( OpMemoryBarrier %u32 %u32_0 )"; CompileSuccessfully(GenerateKernelCode(body), SPV_ENV_UNIVERSAL_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_1)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Operand '5[%uint]' cannot be a " "type")); } TEST_F(ValidateBarriers, OpControlBarrierVulkanMemoryModelBanSequentiallyConsistent) { const std::string text = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR OpEntryPoint Fragment %1 "func" OpExecutionMode %1 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeInt 32 0 %4 = OpConstant %3 16 %5 = OpTypeFunction %2 %6 = OpConstant %3 5 %1 = OpFunction %2 None %5 %7 = OpLabel OpControlBarrier %6 %6 %4 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("SequentiallyConsistent memory semantics cannot be " "used with the VulkanKHR memory model.")); } TEST_F(ValidateBarriers, OpMemoryBarrierVulkanMemoryModelBanSequentiallyConsistent) { const std::string text = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR OpEntryPoint Fragment %1 "func" OpExecutionMode %1 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeInt 32 0 %4 = OpConstant %3 16 %5 = OpTypeFunction %2 %6 = OpConstant %3 5 %1 = OpFunction %2 None %5 %7 = OpLabel OpMemoryBarrier %6 %4 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("SequentiallyConsistent memory semantics cannot be " "used with the VulkanKHR memory model.")); } TEST_F(ValidateBarriers, OutputMemoryKHRRequireVulkanMemoryModelKHR) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" OpExecutionMode %1 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeInt 32 0 %semantics = OpConstant %3 4104 %5 = OpTypeFunction %2 %device = OpConstant %3 1 %1 = OpFunction %2 None %5 %7 = OpLabel OpControlBarrier %device %device %semantics OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("ControlBarrier: Memory Semantics OutputMemoryKHR " "requires capability VulkanMemoryModelKHR")); } TEST_F(ValidateBarriers, MakeAvailableKHRRequireVulkanMemoryModelKHR) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" OpExecutionMode %1 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeInt 32 0 %semantics = OpConstant %3 8264 %5 = OpTypeFunction %2 %device = OpConstant %3 1 %1 = OpFunction %2 None %5 %7 = OpLabel OpControlBarrier %device %device %semantics OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("ControlBarrier: Memory Semantics MakeAvailableKHR " "requires capability VulkanMemoryModelKHR")); } TEST_F(ValidateBarriers, MakeVisibleKHRRequireVulkanMemoryModelKHR) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" OpExecutionMode %1 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeInt 32 0 %semantics = OpConstant %3 16456 %5 = OpTypeFunction %2 %device = OpConstant %3 1 %1 = OpFunction %2 None %5 %7 = OpLabel OpControlBarrier %device %device %semantics OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("ControlBarrier: Memory Semantics MakeVisibleKHR " "requires capability VulkanMemoryModelKHR")); } TEST_F(ValidateBarriers, MakeAvailableKHRRequiresReleaseSemantics) { const std::string text = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %int = OpTypeInt 32 0 %workgroup = OpConstant %int 2 %semantics = OpConstant %int 8448 %functy = OpTypeFunction %void %func = OpFunction %void None %functy %1 = OpLabel OpControlBarrier %workgroup %workgroup %semantics OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("ControlBarrier: MakeAvailableKHR Memory Semantics also " "requires either Release or AcquireRelease Memory Semantics")); } TEST_F(ValidateBarriers, MakeVisibleKHRRequiresAcquireSemantics) { const std::string text = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %int = OpTypeInt 32 0 %workgroup = OpConstant %int 2 %semantics = OpConstant %int 16640 %functy = OpTypeFunction %void %func = OpFunction %void None %functy %1 = OpLabel OpControlBarrier %workgroup %workgroup %semantics OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("ControlBarrier: MakeVisibleKHR Memory Semantics also requires " "either Acquire or AcquireRelease Memory Semantics")); } TEST_F(ValidateBarriers, MakeAvailableKHRRequiresStorageSemantics) { const std::string text = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %int = OpTypeInt 32 0 %workgroup = OpConstant %int 2 %semantics = OpConstant %int 8196 %functy = OpTypeFunction %void %func = OpFunction %void None %functy %1 = OpLabel OpMemoryBarrier %workgroup %semantics OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("MemoryBarrier: expected Memory Semantics to include a " "storage class")); } TEST_F(ValidateBarriers, MakeVisibleKHRRequiresStorageSemantics) { const std::string text = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %int = OpTypeInt 32 0 %workgroup = OpConstant %int 2 %semantics = OpConstant %int 16386 %functy = OpTypeFunction %void %func = OpFunction %void None %functy %1 = OpLabel OpMemoryBarrier %workgroup %semantics OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("MemoryBarrier: expected Memory Semantics to include a " "storage class")); } TEST_F(ValidateBarriers, SemanticsSpecConstantShader) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr_int_workgroup = OpTypePointer Workgroup %int %var = OpVariable %ptr_int_workgroup Workgroup %voidfn = OpTypeFunction %void %spec_const = OpSpecConstant %int 0 %workgroup = OpConstant %int 2 %func = OpFunction %void None %voidfn %entry = OpLabel OpMemoryBarrier %workgroup %spec_const OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Memory Semantics ids must be OpConstant when Shader " "capability is present")); } TEST_F(ValidateBarriers, SemanticsSpecConstantKernel) { const std::string spirv = R"( OpCapability Kernel OpCapability Linkage OpMemoryModel Logical OpenCL %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr_int_workgroup = OpTypePointer Workgroup %int %var = OpVariable %ptr_int_workgroup Workgroup %voidfn = OpTypeFunction %void %spec_const = OpSpecConstant %int 0 %workgroup = OpConstant %int 2 %func = OpFunction %void None %voidfn %entry = OpLabel OpMemoryBarrier %workgroup %spec_const OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateBarriers, ScopeSpecConstantShader) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr_int_workgroup = OpTypePointer Workgroup %int %var = OpVariable %ptr_int_workgroup Workgroup %voidfn = OpTypeFunction %void %spec_const = OpSpecConstant %int 0 %relaxed = OpConstant %int 0 %func = OpFunction %void None %voidfn %entry = OpLabel OpMemoryBarrier %spec_const %relaxed OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Scope ids must be OpConstant when Shader " "capability is present")); } TEST_F(ValidateBarriers, ScopeSpecConstantKernel) { const std::string spirv = R"( OpCapability Kernel OpCapability Linkage OpMemoryModel Logical OpenCL %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr_int_workgroup = OpTypePointer Workgroup %int %var = OpVariable %ptr_int_workgroup Workgroup %voidfn = OpTypeFunction %void %spec_const = OpSpecConstant %int 0 %relaxed = OpConstant %int 0 %func = OpFunction %void None %voidfn %entry = OpLabel OpMemoryBarrier %spec_const %relaxed OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateBarriers, VulkanMemoryModelDeviceScopeBad) { const std::string text = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %int = OpTypeInt 32 0 %device = OpConstant %int 1 %semantics = OpConstant %int 0 %functy = OpTypeFunction %void %func = OpFunction %void None %functy %1 = OpLabel OpMemoryBarrier %device %semantics OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Use of device scope with VulkanKHR memory model requires the " "VulkanMemoryModelDeviceScopeKHR capability")); } TEST_F(ValidateBarriers, VulkanMemoryModelDeviceScopeGood) { const std::string text = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability VulkanMemoryModelDeviceScopeKHR OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %int = OpTypeInt 32 0 %device = OpConstant %int 1 %semantics = OpConstant %int 0 %functy = OpTypeFunction %void %func = OpFunction %void None %functy %1 = OpLabel OpMemoryBarrier %device %semantics OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateBarriers, VolatileMemoryBarrier) { const std::string text = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability VulkanMemoryModelDeviceScopeKHR OpCapability Linkage OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %void = OpTypeVoid %int = OpTypeInt 32 0 %device = OpConstant %int 1 %semantics = OpConstant %int 32768 %functy = OpTypeFunction %void %func = OpFunction %void None %functy %1 = OpLabel OpMemoryBarrier %device %semantics OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Memory Semantics Volatile can only be used with " "atomic instructions")); } TEST_F(ValidateBarriers, VolatileControlBarrier) { const std::string text = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability VulkanMemoryModelDeviceScopeKHR OpCapability Linkage OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %void = OpTypeVoid %int = OpTypeInt 32 0 %device = OpConstant %int 1 %semantics = OpConstant %int 32768 %functy = OpTypeFunction %void %func = OpFunction %void None %functy %1 = OpLabel OpControlBarrier %device %device %semantics OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Memory Semantics Volatile can only be used with " "atomic instructions")); } TEST_F(ValidateBarriers, CooperativeMatrixSpecConstantVolatile) { const std::string text = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability VulkanMemoryModelDeviceScopeKHR OpCapability CooperativeMatrixNV OpCapability Linkage OpExtension "SPV_KHR_vulkan_memory_model" OpExtension "SPV_NV_cooperative_matrix" OpMemoryModel Logical VulkanKHR %void = OpTypeVoid %int = OpTypeInt 32 0 %device = OpConstant %int 1 %semantics = OpSpecConstant %int 32768 %functy = OpTypeFunction %void %func = OpFunction %void None %functy %1 = OpLabel OpControlBarrier %device %device %semantics OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateBarriers, CooperativeMatrixNonConstantSemantics) { const std::string text = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability VulkanMemoryModelDeviceScopeKHR OpCapability CooperativeMatrixNV OpCapability Linkage OpExtension "SPV_KHR_vulkan_memory_model" OpExtension "SPV_NV_cooperative_matrix" OpMemoryModel Logical VulkanKHR %void = OpTypeVoid %int = OpTypeInt 32 0 %device = OpConstant %int 1 %semantics = OpUndef %int %functy = OpTypeFunction %void %func = OpFunction %void None %functy %1 = OpLabel OpControlBarrier %device %device %semantics OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Memory Semantics must be a constant instruction when " "CooperativeMatrixNV capability is present")); } TEST_F(ValidateBarriers, OpMemoryBarrierShaderCallRayGenSuccess) { const std::string body = "OpMemoryBarrier %shadercall %release_uniform_workgroup"; CompileSuccessfully(GenerateShaderCodeImpl(body, // capabilities_and_extensions R"( OpCapability VulkanMemoryModelKHR OpCapability RayTracingKHR OpExtension "SPV_KHR_vulkan_memory_model" OpExtension "SPV_KHR_ray_tracing" )", // definitions "", // execution_model "RayGenerationKHR", // memory_model "OpMemoryModel Logical VulkanKHR"), SPV_ENV_VULKAN_1_1); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_1)); } TEST_F(ValidateBarriers, OpMemoryBarrierShaderCallComputeFailure) { const std::string body = "OpMemoryBarrier %shadercall %release_uniform_workgroup"; CompileSuccessfully(GenerateShaderCodeImpl(body, // capabilities_and_extensions R"( OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )", // definitions "", // execution_model "GLCompute", // memory_model "OpMemoryModel Logical VulkanKHR"), SPV_ENV_VULKAN_1_1); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-None-04640")); EXPECT_THAT( getDiagnosticString(), HasSubstr( "ShaderCallKHR Memory Scope requires a ray tracing execution model")); } TEST_F(ValidateBarriers, OpControlBarrierShaderCallRayGenFailure) { const std::string body = "OpControlBarrier %shadercall %shadercall %none"; CompileSuccessfully(GenerateShaderCodeImpl(body, // capabilities_and_extensions R"( OpCapability VulkanMemoryModelKHR OpCapability RayTracingKHR OpExtension "SPV_KHR_vulkan_memory_model" OpExtension "SPV_KHR_ray_tracing" )", // definitions "", // execution_model "RayGenerationKHR", // memory_model "OpMemoryModel Logical VulkanKHR"), SPV_ENV_VULKAN_1_1); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-None-04636")); EXPECT_THAT(getDiagnosticString(), HasSubstr("in Vulkan environment Execution Scope is limited to " "Workgroup and Subgroup")); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_bitwise_test.cpp000066400000000000000000000523351475742701700243550ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Tests for unique type declaration rules validator. #include #include "gmock/gmock.h" #include "test/unit_spirv.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::HasSubstr; using ::testing::Not; using ValidateBitwise = spvtest::ValidateBase; std::string GenerateShaderCode( const std::string& body, const std::string& capabilities_and_extensions = "") { const std::string capabilities = R"( OpCapability Shader OpCapability Int64 OpCapability Float64)"; const std::string after_extension_before_body = R"( OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f32 = OpTypeFloat 32 %u32 = OpTypeInt 32 0 %s32 = OpTypeInt 32 1 %f64 = OpTypeFloat 64 %u64 = OpTypeInt 64 0 %s64 = OpTypeInt 64 1 %boolvec2 = OpTypeVector %bool 2 %s32vec2 = OpTypeVector %s32 2 %u32vec2 = OpTypeVector %u32 2 %u64vec2 = OpTypeVector %u64 2 %f32vec2 = OpTypeVector %f32 2 %f64vec2 = OpTypeVector %f64 2 %boolvec3 = OpTypeVector %bool 3 %u32vec3 = OpTypeVector %u32 3 %u64vec3 = OpTypeVector %u64 3 %s32vec3 = OpTypeVector %s32 3 %f32vec3 = OpTypeVector %f32 3 %f64vec3 = OpTypeVector %f64 3 %boolvec4 = OpTypeVector %bool 4 %u32vec4 = OpTypeVector %u32 4 %u64vec4 = OpTypeVector %u64 4 %s32vec4 = OpTypeVector %s32 4 %f32vec4 = OpTypeVector %f32 4 %f64vec4 = OpTypeVector %f64 4 %f32_0 = OpConstant %f32 0 %f32_1 = OpConstant %f32 1 %f32_2 = OpConstant %f32 2 %f32_3 = OpConstant %f32 3 %f32_4 = OpConstant %f32 4 %s32_0 = OpConstant %s32 0 %s32_1 = OpConstant %s32 1 %s32_2 = OpConstant %s32 2 %s32_3 = OpConstant %s32 3 %s32_4 = OpConstant %s32 4 %s32_m1 = OpConstant %s32 -1 %u32_0 = OpConstant %u32 0 %u32_1 = OpConstant %u32 1 %u32_2 = OpConstant %u32 2 %u32_3 = OpConstant %u32 3 %u32_4 = OpConstant %u32 4 %f64_0 = OpConstant %f64 0 %f64_1 = OpConstant %f64 1 %f64_2 = OpConstant %f64 2 %f64_3 = OpConstant %f64 3 %f64_4 = OpConstant %f64 4 %s64_0 = OpConstant %s64 0 %s64_1 = OpConstant %s64 1 %s64_2 = OpConstant %s64 2 %s64_3 = OpConstant %s64 3 %s64_4 = OpConstant %s64 4 %s64_m1 = OpConstant %s64 -1 %u64_0 = OpConstant %u64 0 %u64_1 = OpConstant %u64 1 %u64_2 = OpConstant %u64 2 %u64_3 = OpConstant %u64 3 %u64_4 = OpConstant %u64 4 %u32vec2_01 = OpConstantComposite %u32vec2 %u32_0 %u32_1 %u32vec2_12 = OpConstantComposite %u32vec2 %u32_1 %u32_2 %u32vec3_012 = OpConstantComposite %u32vec3 %u32_0 %u32_1 %u32_2 %u32vec3_123 = OpConstantComposite %u32vec3 %u32_1 %u32_2 %u32_3 %u32vec4_0123 = OpConstantComposite %u32vec4 %u32_0 %u32_1 %u32_2 %u32_3 %u32vec4_1234 = OpConstantComposite %u32vec4 %u32_1 %u32_2 %u32_3 %u32_4 %s32vec2_01 = OpConstantComposite %s32vec2 %s32_0 %s32_1 %s32vec2_12 = OpConstantComposite %s32vec2 %s32_1 %s32_2 %s32vec3_012 = OpConstantComposite %s32vec3 %s32_0 %s32_1 %s32_2 %s32vec3_123 = OpConstantComposite %s32vec3 %s32_1 %s32_2 %s32_3 %s32vec4_0123 = OpConstantComposite %s32vec4 %s32_0 %s32_1 %s32_2 %s32_3 %s32vec4_1234 = OpConstantComposite %s32vec4 %s32_1 %s32_2 %s32_3 %s32_4 %f32vec2_01 = OpConstantComposite %f32vec2 %f32_0 %f32_1 %f32vec2_12 = OpConstantComposite %f32vec2 %f32_1 %f32_2 %f32vec3_012 = OpConstantComposite %f32vec3 %f32_0 %f32_1 %f32_2 %f32vec3_123 = OpConstantComposite %f32vec3 %f32_1 %f32_2 %f32_3 %f32vec4_0123 = OpConstantComposite %f32vec4 %f32_0 %f32_1 %f32_2 %f32_3 %f32vec4_1234 = OpConstantComposite %f32vec4 %f32_1 %f32_2 %f32_3 %f32_4 %main = OpFunction %void None %func %main_entry = OpLabel)"; const std::string after_body = R"( OpReturn OpFunctionEnd)"; return capabilities + capabilities_and_extensions + after_extension_before_body + body + after_body; } TEST_F(ValidateBitwise, ShiftAllSuccess) { const std::string body = R"( %val1 = OpShiftRightLogical %u64 %u64_1 %s32_2 %val2 = OpShiftRightArithmetic %s32vec2 %s32vec2_12 %s32vec2_12 %val3 = OpShiftLeftLogical %u32vec2 %s32vec2_12 %u32vec2_12 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateBitwise, OpShiftRightLogicalWrongResultType) { const std::string body = R"( %val1 = OpShiftRightLogical %bool %u64_1 %s32_2 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected int scalar or vector type as Result Type: " "ShiftRightLogical")); } TEST_F(ValidateBitwise, OpShiftRightLogicalBaseNotInt) { const std::string body = R"( %val1 = OpShiftRightLogical %u32 %f32_1 %s32_2 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Base to be int scalar or vector: ShiftRightLogical")); } TEST_F(ValidateBitwise, OpShiftRightLogicalBaseWrongDimension) { const std::string body = R"( %val1 = OpShiftRightLogical %u32 %u32vec2_12 %s32_2 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Base to have the same dimension as Result Type: " "ShiftRightLogical")); } TEST_F(ValidateBitwise, OpShiftRightLogicalBaseWrongBitWidth) { const std::string body = R"( %val1 = OpShiftRightLogical %u64 %u32_1 %s32_2 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Base to have the same bit width as Result Type: " "ShiftRightLogical")); } TEST_F(ValidateBitwise, OpShiftRightLogicalShiftNotInt) { const std::string body = R"( %val1 = OpShiftRightLogical %u32 %u32_1 %f32_2 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected Shift to be int scalar or vector: ShiftRightLogical")); } TEST_F(ValidateBitwise, OpShiftRightLogicalShiftWrongDimension) { const std::string body = R"( %val1 = OpShiftRightLogical %u32 %u32_1 %s32vec2_12 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Shift to have the same dimension as Result Type: " "ShiftRightLogical")); } TEST_F(ValidateBitwise, LogicAllSuccess) { const std::string body = R"( %val1 = OpBitwiseOr %u64 %u64_1 %s64_0 %val2 = OpBitwiseAnd %s64 %s64_1 %u64_0 %val3 = OpBitwiseXor %s32vec2 %s32vec2_12 %u32vec2_01 %val4 = OpNot %s32vec2 %u32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateBitwise, OpBitwiseAndWrongResultType) { const std::string body = R"( %val1 = OpBitwiseAnd %bool %u64_1 %s32_2 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected int scalar or vector type as Result Type: BitwiseAnd")); } TEST_F(ValidateBitwise, OpBitwiseAndLeftNotInt) { const std::string body = R"( %val1 = OpBitwiseAnd %u32 %f32_1 %s32_2 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected int scalar or vector as operand: BitwiseAnd " "operand index 2")); } TEST_F(ValidateBitwise, OpBitwiseAndRightNotInt) { const std::string body = R"( %val1 = OpBitwiseAnd %u32 %u32_1 %f32_2 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected int scalar or vector as operand: BitwiseAnd " "operand index 3")); } TEST_F(ValidateBitwise, OpBitwiseAndLeftWrongDimension) { const std::string body = R"( %val1 = OpBitwiseAnd %u32 %u32vec2_12 %s32_2 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected operands to have the same dimension as Result Type: " "BitwiseAnd operand index 2")); } TEST_F(ValidateBitwise, OpBitwiseAndRightWrongDimension) { const std::string body = R"( %val1 = OpBitwiseAnd %u32 %s32_2 %u32vec2_12 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected operands to have the same dimension as Result Type: " "BitwiseAnd operand index 3")); } TEST_F(ValidateBitwise, OpBitwiseAndLeftWrongBitWidth) { const std::string body = R"( %val1 = OpBitwiseAnd %u64 %u32_1 %s64_2 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected operands to have the same bit width as Result Type: " "BitwiseAnd operand index 2")); } TEST_F(ValidateBitwise, OpBitwiseAndRightWrongBitWidth) { const std::string body = R"( %val1 = OpBitwiseAnd %u64 %u64_1 %s32_2 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected operands to have the same bit width as Result Type: " "BitwiseAnd operand index 3")); } TEST_F(ValidateBitwise, OpBitFieldInsertSuccess) { const std::string body = R"( %val1 = OpBitFieldInsert %u64 %u64_1 %u64_2 %s32_1 %s32_2 %val2 = OpBitFieldInsert %s32vec2 %s32vec2_12 %s32vec2_12 %s32_1 %u32_2 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateBitwise, OpBitFieldInsertVulkanSuccess) { const std::string body = R"( %val1 = OpBitFieldInsert %u32 %u32_1 %u32_2 %s32_1 %s32_2 %val2 = OpBitFieldInsert %s32vec2 %s32vec2_12 %s32vec2_12 %s32_1 %u32_2 )"; CompileSuccessfully(GenerateShaderCode(body).c_str(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateBitwise, OpBitFieldInsertWrongResultType) { const std::string body = R"( %val1 = OpBitFieldInsert %bool %u64_1 %u64_2 %s32_1 %s32_2 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected Base Type to be equal to Result Type: BitFieldInsert")); } TEST_F(ValidateBitwise, OpBitFieldInsertWrongBaseType) { const std::string body = R"( %val1 = OpBitFieldInsert %u64 %s64_1 %u64_2 %s32_1 %s32_2 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected Base Type to be equal to Result Type: BitFieldInsert")); } TEST_F(ValidateBitwise, OpBitFieldInsertWrongInsertType) { const std::string body = R"( %val1 = OpBitFieldInsert %u64 %u64_1 %s64_2 %s32_1 %s32_2 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected Insert Type to be equal to Result Type: BitFieldInsert")); } TEST_F(ValidateBitwise, OpBitFieldInsertOffsetNotInt) { const std::string body = R"( %val1 = OpBitFieldInsert %u64 %u64_1 %u64_2 %f32_1 %s32_2 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Offset Type to be int scalar: BitFieldInsert")); } TEST_F(ValidateBitwise, OpBitFieldInsertCountNotInt) { const std::string body = R"( %val1 = OpBitFieldInsert %u64 %u64_1 %u64_2 %u32_1 %f32_2 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Count Type to be int scalar: BitFieldInsert")); } TEST_F(ValidateBitwise, OpBitFieldInsertNot32Vulkan) { const std::string body = R"( %val1 = OpBitFieldInsert %u64 %u64_1 %u64_2 %s32_1 %s32_2 )"; CompileSuccessfully(GenerateShaderCode(body).c_str(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Base-04781")); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected 32-bit int type for Base operand: BitFieldInsert")); } TEST_F(ValidateBitwise, OpBitFieldInsertNot32Allow) { const std::string body = R"( %val1 = OpBitFieldInsert %u64 %u64_1 %u64_2 %s32_1 %s32_2 )"; CompileSuccessfully(GenerateShaderCode(body).c_str(), SPV_ENV_VULKAN_1_0); spvValidatorOptionsSetAllowVulkan32BitBitwise(getValidatorOptions(), true); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateBitwise, OpBitFieldSExtractSuccess) { const std::string body = R"( %val1 = OpBitFieldSExtract %u64 %u64_1 %s32_1 %s32_2 %val2 = OpBitFieldSExtract %s32vec2 %s32vec2_12 %s32_1 %u32_2 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateBitwise, OpBitFieldSExtractVulkanSuccess) { const std::string body = R"( %val1 = OpBitFieldSExtract %u32 %u32_1 %s32_1 %s32_2 %val2 = OpBitFieldSExtract %s32vec2 %s32vec2_12 %s32_1 %u32_2 )"; CompileSuccessfully(GenerateShaderCode(body).c_str(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateBitwise, OpBitFieldSExtractWrongResultType) { const std::string body = R"( %val1 = OpBitFieldSExtract %bool %u64_1 %s32_1 %s32_2 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected Base Type to be equal to Result Type: BitFieldSExtract")); } TEST_F(ValidateBitwise, OpBitFieldSExtractWrongBaseType) { const std::string body = R"( %val1 = OpBitFieldSExtract %u64 %s64_1 %s32_1 %s32_2 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected Base Type to be equal to Result Type: BitFieldSExtract")); } TEST_F(ValidateBitwise, OpBitFieldSExtractOffsetNotInt) { const std::string body = R"( %val1 = OpBitFieldSExtract %u64 %u64_1 %f32_1 %s32_2 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Offset Type to be int scalar: BitFieldSExtract")); } TEST_F(ValidateBitwise, OpBitFieldSExtractCountNotInt) { const std::string body = R"( %val1 = OpBitFieldSExtract %u64 %u64_1 %u32_1 %f32_2 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Count Type to be int scalar: BitFieldSExtract")); } TEST_F(ValidateBitwise, OpBitFieldSExtractNot32Vulkan) { const std::string body = R"( %val1 = OpBitFieldSExtract %u64 %u64_1 %s32_1 %s32_2 )"; CompileSuccessfully(GenerateShaderCode(body).c_str(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Base-04781")); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected 32-bit int type for Base operand: BitFieldSExtract")); } TEST_F(ValidateBitwise, OpBitReverseSuccess) { const std::string body = R"( %val1 = OpBitReverse %u64 %u64_1 %val2 = OpBitReverse %s32vec2 %s32vec2_12 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateBitwise, OpBitReverseVulkanSuccess) { const std::string body = R"( %val1 = OpBitReverse %u32 %u32_1 %val2 = OpBitReverse %s32vec2 %s32vec2_12 )"; CompileSuccessfully(GenerateShaderCode(body).c_str(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateBitwise, OpBitReverseWrongResultType) { const std::string body = R"( %val1 = OpBitReverse %bool %u64_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Base Type to be equal to Result Type: BitReverse")); } TEST_F(ValidateBitwise, OpBitReverseWrongBaseType) { const std::string body = R"( %val1 = OpBitReverse %u64 %s64_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Base Type to be equal to Result Type: BitReverse")); } TEST_F(ValidateBitwise, OpBitReverseNot32Vulkan) { const std::string body = R"( %val1 = OpBitReverse %u64 %u64_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Base-04781")); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected 32-bit int type for Base operand: BitReverse")); } TEST_F(ValidateBitwise, OpBitCountSuccess) { const std::string body = R"( %val1 = OpBitCount %s32 %u64_1 %val2 = OpBitCount %u32vec2 %s32vec2_12 %val3 = OpBitCount %s64 %s64_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateBitwise, OpBitCountVulkanSuccess) { const std::string body = R"( %val1 = OpBitCount %s32 %u32_1 %val2 = OpBitCount %u32vec2 %s32vec2_12 )"; CompileSuccessfully(GenerateShaderCode(body).c_str(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateBitwise, OpBitCountWrongResultType) { const std::string body = R"( %val1 = OpBitCount %bool %u64_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected int scalar or vector type as Result Type: BitCount")); } TEST_F(ValidateBitwise, OpBitCountBaseNotInt) { const std::string body = R"( %val1 = OpBitCount %u32 %f64_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected int scalar or vector type for Base operand: BitCount")); } TEST_F(ValidateBitwise, OpBitCountBaseWrongDimension) { const std::string body = R"( %val1 = OpBitCount %u32 %u32vec2_12 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Base dimension to be equal to Result Type dimension: " "BitCount")); } TEST_F(ValidateBitwise, OpBitCountNot32Vulkan) { const std::string body = R"( %val1 = OpBitCount %s64 %s64_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Base-04781")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected 32-bit int type for Base operand: BitCount")); } TEST_F(ValidateBitwise, OpBitCountPointer) { const std::string body = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr_int = OpTypePointer Function %int %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %var = OpVariable %ptr_int Function %count = OpBitCount %int %var OpReturn OpFunctionEnd )"; CompileSuccessfully(body); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected int scalar or vector type for Base operand: BitCount")); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_builtins_test.cpp000066400000000000000000007234621475742701700245460ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights // reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Tests validation rules of GLSL.450.std and OpenCL.std extended instructions. // Doesn't test OpenCL.std vector size 2, 3, 4, 8 or 16 rules (not supported // by standard SPIR-V). #include #include #include #include #include #include #include "gmock/gmock.h" #include "source/spirv_target_env.h" #include "test/unit_spirv.h" #include "test/val/val_code_generator.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { struct TestResult { TestResult(spv_result_t in_validation_result = SPV_SUCCESS, const char* in_error_str = nullptr, const char* in_error_str2 = nullptr) : validation_result(in_validation_result), error_str(in_error_str), error_str2(in_error_str2) {} spv_result_t validation_result; const char* error_str; const char* error_str2; }; using ::testing::Combine; using ::testing::HasSubstr; using ::testing::Not; using ::testing::Values; using ::testing::ValuesIn; using ValidateBuiltIns = spvtest::ValidateBase; using ValidateVulkanSubgroupBuiltIns = spvtest::ValidateBase>; using ValidateVulkanCombineBuiltInExecutionModelDataTypeResult = spvtest::ValidateBase>; using ValidateVulkanCombineBuiltInArrayedVariable = spvtest::ValidateBase>; using ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult = spvtest::ValidateBase< std::tuple>; using ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult = spvtest::ValidateBase>; bool InitializerRequired(const char* const storage_class) { return (strncmp(storage_class, "Output", 6) == 0 || strncmp(storage_class, "Private", 7) == 0 || strncmp(storage_class, "Function", 8) == 0); } CodeGenerator GetInMainCodeGenerator(const char* const built_in, const char* const execution_model, const char* const storage_class, const char* const capabilities, const char* const extensions, const char* const data_type) { CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator(); if (capabilities) { generator.capabilities_ += capabilities; } if (extensions) { generator.extensions_ += extensions; } generator.before_types_ = R"(OpDecorate %built_in_type Block OpMemberDecorate %built_in_type 0 BuiltIn )"; generator.before_types_ += built_in; generator.before_types_ += "\n"; std::ostringstream after_types; after_types << "%built_in_type = OpTypeStruct " << data_type << "\n"; if (InitializerRequired(storage_class)) { after_types << "%built_in_null = OpConstantNull %built_in_type\n"; } after_types << "%built_in_ptr = OpTypePointer " << storage_class << " %built_in_type\n"; after_types << "%built_in_var = OpVariable %built_in_ptr " << storage_class; if (InitializerRequired(storage_class)) { after_types << " %built_in_null"; } after_types << "\n"; after_types << "%data_ptr = OpTypePointer " << storage_class << " " << data_type << "\n"; generator.after_types_ = after_types.str(); EntryPoint entry_point; entry_point.name = "main"; entry_point.execution_model = execution_model; if (strncmp(storage_class, "Input", 5) == 0 || strncmp(storage_class, "Output", 6) == 0) { entry_point.interfaces = "%built_in_var"; } std::ostringstream execution_modes; if (0 == std::strcmp(execution_model, "Fragment")) { execution_modes << "OpExecutionMode %" << entry_point.name << " OriginUpperLeft\n"; if (0 == std::strcmp(built_in, "FragDepth")) { execution_modes << "OpExecutionMode %" << entry_point.name << " DepthReplacing\n"; } } if (0 == std::strcmp(execution_model, "Geometry")) { execution_modes << "OpExecutionMode %" << entry_point.name << " InputPoints\n"; execution_modes << "OpExecutionMode %" << entry_point.name << " OutputPoints\n"; } if (0 == std::strcmp(execution_model, "GLCompute")) { execution_modes << "OpExecutionMode %" << entry_point.name << " LocalSize 1 1 1\n"; } entry_point.execution_modes = execution_modes.str(); entry_point.body = R"( %ptr = OpAccessChain %data_ptr %built_in_var %u32_0 )"; generator.entry_points_.push_back(std::move(entry_point)); return generator; } TEST_P(ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, InMain) { const char* const built_in = std::get<0>(GetParam()); const char* const execution_model = std::get<1>(GetParam()); const char* const storage_class = std::get<2>(GetParam()); const char* const data_type = std::get<3>(GetParam()); const char* const vuid = std::get<4>(GetParam()); const TestResult& test_result = std::get<5>(GetParam()); CodeGenerator generator = GetInMainCodeGenerator( built_in, execution_model, storage_class, NULL, NULL, data_type); CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(test_result.validation_result, ValidateInstructions(SPV_ENV_VULKAN_1_0)); if (test_result.error_str) { EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str)); } if (test_result.error_str2) { EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str2)); } if (vuid) { EXPECT_THAT(getDiagnosticString(), AnyVUID(vuid)); } } TEST_P( ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, InMain) { const char* const built_in = std::get<0>(GetParam()); const char* const execution_model = std::get<1>(GetParam()); const char* const storage_class = std::get<2>(GetParam()); const char* const data_type = std::get<3>(GetParam()); const char* const capabilities = std::get<4>(GetParam()); const char* const extensions = std::get<5>(GetParam()); const char* const vuid = std::get<6>(GetParam()); const TestResult& test_result = std::get<7>(GetParam()); CodeGenerator generator = GetInMainCodeGenerator(built_in, execution_model, storage_class, capabilities, extensions, data_type); CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(test_result.validation_result, ValidateInstructions(SPV_ENV_VULKAN_1_0)); if (test_result.error_str) { EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str)); } if (test_result.error_str2) { EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str2)); } if (vuid) { EXPECT_THAT(getDiagnosticString(), AnyVUID(vuid)); } } TEST_P( ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, InMain) { const spv_target_env env = std::get<0>(GetParam()); const char* const built_in = std::get<1>(GetParam()); const char* const execution_model = std::get<2>(GetParam()); const char* const storage_class = std::get<3>(GetParam()); const char* const data_type = std::get<4>(GetParam()); const char* const capabilities = std::get<5>(GetParam()); const char* const extensions = std::get<6>(GetParam()); const char* const vuid = std::get<7>(GetParam()); const TestResult& test_result = std::get<8>(GetParam()); CodeGenerator generator = GetInMainCodeGenerator(built_in, execution_model, storage_class, capabilities, extensions, data_type); CompileSuccessfully(generator.Build(), env); ASSERT_EQ(test_result.validation_result, ValidateInstructions(env)); if (test_result.error_str) { EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str)); } if (test_result.error_str2) { EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str2)); } if (vuid) { EXPECT_THAT(getDiagnosticString(), AnyVUID(vuid)); } } CodeGenerator GetInFunctionCodeGenerator(const char* const built_in, const char* const execution_model, const char* const storage_class, const char* const capabilities, const char* const extensions, const char* const data_type) { CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator(); if (capabilities) { generator.capabilities_ += capabilities; } if (extensions) { generator.extensions_ += extensions; } generator.before_types_ = R"(OpDecorate %built_in_type Block OpMemberDecorate %built_in_type 0 BuiltIn )"; generator.before_types_ += built_in; generator.before_types_ += "\n"; std::ostringstream after_types; after_types << "%built_in_type = OpTypeStruct " << data_type << "\n"; if (InitializerRequired(storage_class)) { after_types << "%built_in_null = OpConstantNull %built_in_type\n"; } after_types << "%built_in_ptr = OpTypePointer " << storage_class << " %built_in_type\n"; after_types << "%built_in_var = OpVariable %built_in_ptr " << storage_class; if (InitializerRequired(storage_class)) { after_types << " %built_in_null"; } after_types << "\n"; after_types << "%data_ptr = OpTypePointer " << storage_class << " " << data_type << "\n"; generator.after_types_ = after_types.str(); EntryPoint entry_point; entry_point.name = "main"; entry_point.execution_model = execution_model; if (strncmp(storage_class, "Input", 5) == 0 || strncmp(storage_class, "Output", 6) == 0) { entry_point.interfaces = "%built_in_var"; } std::ostringstream execution_modes; if (0 == std::strcmp(execution_model, "Fragment")) { execution_modes << "OpExecutionMode %" << entry_point.name << " OriginUpperLeft\n"; if (0 == std::strcmp(built_in, "FragDepth")) { execution_modes << "OpExecutionMode %" << entry_point.name << " DepthReplacing\n"; } } if (0 == std::strcmp(execution_model, "Geometry")) { execution_modes << "OpExecutionMode %" << entry_point.name << " InputPoints\n"; execution_modes << "OpExecutionMode %" << entry_point.name << " OutputPoints\n"; } if (0 == std::strcmp(execution_model, "GLCompute")) { execution_modes << "OpExecutionMode %" << entry_point.name << " LocalSize 1 1 1\n"; } entry_point.execution_modes = execution_modes.str(); entry_point.body = R"( %val2 = OpFunctionCall %void %foo )"; std::string function_body = R"( %foo = OpFunction %void None %func %foo_entry = OpLabel %ptr = OpAccessChain %data_ptr %built_in_var %u32_0 OpReturn OpFunctionEnd )"; generator.add_at_the_end_ = function_body; generator.entry_points_.push_back(std::move(entry_point)); return generator; } TEST_P(ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, InFunction) { const char* const built_in = std::get<0>(GetParam()); const char* const execution_model = std::get<1>(GetParam()); const char* const storage_class = std::get<2>(GetParam()); const char* const data_type = std::get<3>(GetParam()); const char* const vuid = std::get<4>(GetParam()); const TestResult& test_result = std::get<5>(GetParam()); CodeGenerator generator = GetInFunctionCodeGenerator( built_in, execution_model, storage_class, NULL, NULL, data_type); CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(test_result.validation_result, ValidateInstructions(SPV_ENV_VULKAN_1_0)); if (test_result.error_str) { EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str)); } if (test_result.error_str2) { EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str2)); } if (vuid) { EXPECT_THAT(getDiagnosticString(), AnyVUID(vuid)); } } TEST_P( ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, InFunction) { const char* const built_in = std::get<0>(GetParam()); const char* const execution_model = std::get<1>(GetParam()); const char* const storage_class = std::get<2>(GetParam()); const char* const data_type = std::get<3>(GetParam()); const char* const capabilities = std::get<4>(GetParam()); const char* const extensions = std::get<5>(GetParam()); const char* const vuid = std::get<6>(GetParam()); const TestResult& test_result = std::get<7>(GetParam()); CodeGenerator generator = GetInFunctionCodeGenerator(built_in, execution_model, storage_class, capabilities, extensions, data_type); CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(test_result.validation_result, ValidateInstructions(SPV_ENV_VULKAN_1_0)); if (test_result.error_str) { EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str)); } if (test_result.error_str2) { EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str2)); } if (vuid) { EXPECT_THAT(getDiagnosticString(), AnyVUID(vuid)); } } CodeGenerator GetVariableCodeGenerator(const char* const built_in, const char* const execution_model, const char* const storage_class, const char* const capabilities, const char* const extensions, const char* const data_type) { CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator(); if (capabilities) { generator.capabilities_ += capabilities; } if (extensions) { generator.extensions_ += extensions; } generator.before_types_ = "OpDecorate %built_in_var BuiltIn "; generator.before_types_ += built_in; generator.before_types_ += "\n"; if ((0 == std::strcmp(storage_class, "Input")) && (0 == std::strcmp(execution_model, "Fragment"))) { // ensure any needed input types that might require Flat generator.before_types_ += "OpDecorate %built_in_var Flat\n"; } std::ostringstream after_types; if (InitializerRequired(storage_class)) { after_types << "%built_in_null = OpConstantNull " << data_type << "\n"; } after_types << "%built_in_ptr = OpTypePointer " << storage_class << " " << data_type << "\n"; after_types << "%built_in_var = OpVariable %built_in_ptr " << storage_class; if (InitializerRequired(storage_class)) { after_types << " %built_in_null"; } after_types << "\n"; generator.after_types_ = after_types.str(); EntryPoint entry_point; entry_point.name = "main"; entry_point.execution_model = execution_model; if (strncmp(storage_class, "Input", 5) == 0 || strncmp(storage_class, "Output", 6) == 0) { entry_point.interfaces = "%built_in_var"; } // Any kind of reference would do. entry_point.body = R"( %val = OpBitcast %u32 %built_in_var )"; std::ostringstream execution_modes; if (0 == std::strcmp(execution_model, "Fragment")) { execution_modes << "OpExecutionMode %" << entry_point.name << " OriginUpperLeft\n"; if (0 == std::strcmp(built_in, "FragDepth")) { execution_modes << "OpExecutionMode %" << entry_point.name << " DepthReplacing\n"; } } if (0 == std::strcmp(execution_model, "Geometry")) { execution_modes << "OpExecutionMode %" << entry_point.name << " InputPoints\n"; execution_modes << "OpExecutionMode %" << entry_point.name << " OutputPoints\n"; } if (0 == std::strcmp(execution_model, "GLCompute")) { execution_modes << "OpExecutionMode %" << entry_point.name << " LocalSize 1 1 1\n"; } entry_point.execution_modes = execution_modes.str(); generator.entry_points_.push_back(std::move(entry_point)); return generator; } TEST_P(ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Variable) { const char* const built_in = std::get<0>(GetParam()); const char* const execution_model = std::get<1>(GetParam()); const char* const storage_class = std::get<2>(GetParam()); const char* const data_type = std::get<3>(GetParam()); const char* const vuid = std::get<4>(GetParam()); const TestResult& test_result = std::get<5>(GetParam()); CodeGenerator generator = GetVariableCodeGenerator( built_in, execution_model, storage_class, NULL, NULL, data_type); CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(test_result.validation_result, ValidateInstructions(SPV_ENV_VULKAN_1_0)); if (test_result.error_str) { EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str)); } if (test_result.error_str2) { EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str2)); } if (vuid) { EXPECT_THAT(getDiagnosticString(), AnyVUID(vuid)); } } TEST_P( ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Variable) { const char* const built_in = std::get<0>(GetParam()); const char* const execution_model = std::get<1>(GetParam()); const char* const storage_class = std::get<2>(GetParam()); const char* const data_type = std::get<3>(GetParam()); const char* const capabilities = std::get<4>(GetParam()); const char* const extensions = std::get<5>(GetParam()); const char* const vuid = std::get<6>(GetParam()); const TestResult& test_result = std::get<7>(GetParam()); CodeGenerator generator = GetVariableCodeGenerator(built_in, execution_model, storage_class, capabilities, extensions, data_type); CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(test_result.validation_result, ValidateInstructions(SPV_ENV_VULKAN_1_0)); if (test_result.error_str) { EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str)); } if (test_result.error_str2) { EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str2)); } if (vuid) { EXPECT_THAT(getDiagnosticString(), AnyVUID(vuid)); } } INSTANTIATE_TEST_SUITE_P( ClipAndCullDistanceOutputSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("ClipDistance", "CullDistance"), Values("Vertex", "Geometry", "TessellationControl", "TessellationEvaluation"), Values("Output"), Values("%f32arr2", "%f32arr4"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( ClipAndCullDistanceInputSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("ClipDistance", "CullDistance"), Values("Fragment", "Geometry", "TessellationControl", "TessellationEvaluation"), Values("Input"), Values("%f32arr2", "%f32arr4"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( ClipAndCullDistanceInvalidStorageClass, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("ClipDistance", "CullDistance"), Values("Vertex", "Geometry", "TessellationControl", "TessellationEvaluation"), Values("Private"), Values("%f32arr2", "%f32arr4"), Values("VUID-ClipDistance-ClipDistance-04190 " "VUID-CullDistance-CullDistance-04199"), Values(TestResult( SPV_ERROR_INVALID_DATA, "to be only used for variables with Input or Output storage " "class.")))); INSTANTIATE_TEST_SUITE_P( ClipAndCullDistanceFragmentOutput, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("ClipDistance", "CullDistance"), Values("Fragment"), Values("Output"), Values("%f32arr4"), Values("VUID-ClipDistance-ClipDistance-04189 " "VUID-CullDistance-CullDistance-04198"), Values(TestResult( SPV_ERROR_INVALID_DATA, "Vulkan spec doesn't allow BuiltIn ClipDistance/CullDistance " "to be used for variables with Output storage class if " "execution model is Fragment.", "which is called with execution model Fragment.")))); INSTANTIATE_TEST_SUITE_P( VertexIdVertexInput, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine( Values("VertexId"), Values("Vertex"), Values("Input"), Values("%u32"), Values(nullptr), Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec doesn't allow BuiltIn VertexId to be " "used.")))); INSTANTIATE_TEST_SUITE_P( ClipAndCullDistanceVertexInput, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("ClipDistance", "CullDistance"), Values("Vertex"), Values("Input"), Values("%f32arr4"), Values("VUID-ClipDistance-ClipDistance-04188 " "VUID-CullDistance-CullDistance-04197"), Values(TestResult( SPV_ERROR_INVALID_DATA, "Vulkan spec doesn't allow BuiltIn ClipDistance/CullDistance " "to be used for variables with Input storage class if " "execution model is Vertex.", "which is called with execution model Vertex.")))); INSTANTIATE_TEST_SUITE_P( ClipAndCullInvalidExecutionModel, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("ClipDistance", "CullDistance"), Values("GLCompute"), Values("Input", "Output"), Values("%f32arr4"), Values("VUID-ClipDistance-ClipDistance-04187 " "VUID-CullDistance-CullDistance-04196"), Values(TestResult( SPV_ERROR_INVALID_DATA, "to be used only with Fragment, Vertex, TessellationControl, " "TessellationEvaluation or Geometry execution models")))); INSTANTIATE_TEST_SUITE_P( ClipAndCullDistanceNotArray, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("ClipDistance", "CullDistance"), Values("Fragment"), Values("Input"), Values("%f32vec2", "%f32vec4", "%f32"), Values("VUID-ClipDistance-ClipDistance-04191 " "VUID-CullDistance-CullDistance-04200"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit float array", "is not an array")))); INSTANTIATE_TEST_SUITE_P( ClipAndCullDistanceNotFloatArray, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("ClipDistance", "CullDistance"), Values("Fragment"), Values("Input"), Values("%u32arr2", "%u64arr4"), Values("VUID-ClipDistance-ClipDistance-04191 " "VUID-CullDistance-CullDistance-04200"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit float array", "components are not float scalar")))); INSTANTIATE_TEST_SUITE_P( ClipAndCullDistanceNotF32Array, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("ClipDistance", "CullDistance"), Values("Fragment"), Values("Input"), Values("%f64arr2", "%f64arr4"), Values("VUID-ClipDistance-ClipDistance-04191 " "VUID-CullDistance-CullDistance-04200"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit float array", "has components with bit width 64")))); INSTANTIATE_TEST_SUITE_P( FragCoordSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("FragCoord"), Values("Fragment"), Values("Input"), Values("%f32vec4"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( FragCoordNotFragment, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine( Values("FragCoord"), Values("Vertex", "GLCompute", "Geometry", "TessellationControl", "TessellationEvaluation"), Values("Input"), Values("%f32vec4"), Values("VUID-FragCoord-FragCoord-04210"), Values(TestResult(SPV_ERROR_INVALID_DATA, "to be used only with Fragment execution model")))); INSTANTIATE_TEST_SUITE_P( FragCoordNotInput, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("FragCoord"), Values("Fragment"), Values("Output"), Values("%f32vec4"), Values("VUID-FragCoord-FragCoord-04211"), Values(TestResult( SPV_ERROR_INVALID_DATA, "to be only used for variables with Input storage class", "uses storage class Output")))); INSTANTIATE_TEST_SUITE_P( FragCoordNotFloatVector, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("FragCoord"), Values("Fragment"), Values("Input"), Values("%f32arr4", "%u32vec4"), Values("VUID-FragCoord-FragCoord-04212"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 4-component 32-bit float vector", "is not a float vector")))); INSTANTIATE_TEST_SUITE_P( FragCoordNotFloatVec4, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("FragCoord"), Values("Fragment"), Values("Input"), Values("%f32vec3"), Values("VUID-FragCoord-FragCoord-04212"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 4-component 32-bit float vector", "has 3 components")))); INSTANTIATE_TEST_SUITE_P( FragCoordNotF32Vec4, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("FragCoord"), Values("Fragment"), Values("Input"), Values("%f64vec4"), Values("VUID-FragCoord-FragCoord-04212"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 4-component 32-bit float vector", "has components with bit width 64")))); INSTANTIATE_TEST_SUITE_P( FragDepthSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("FragDepth"), Values("Fragment"), Values("Output"), Values("%f32"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( FragDepthNotFragment, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine( Values("FragDepth"), Values("Vertex", "GLCompute", "Geometry", "TessellationControl", "TessellationEvaluation"), Values("Output"), Values("%f32"), Values("VUID-FragDepth-FragDepth-04213"), Values(TestResult(SPV_ERROR_INVALID_DATA, "to be used only with Fragment execution model")))); INSTANTIATE_TEST_SUITE_P( FragDepthNotOutput, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("FragDepth"), Values("Fragment"), Values("Input"), Values("%f32"), Values("VUID-FragDepth-FragDepth-04214"), Values(TestResult( SPV_ERROR_INVALID_DATA, "to be only used for variables with Output storage class", "uses storage class Input")))); INSTANTIATE_TEST_SUITE_P( FragDepthNotFloatScalar, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("FragDepth"), Values("Fragment"), Values("Output"), Values("%f32vec4", "%u32"), Values("VUID-FragDepth-FragDepth-04215"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit float scalar", "is not a float scalar")))); INSTANTIATE_TEST_SUITE_P( FragDepthNotF32, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("FragDepth"), Values("Fragment"), Values("Output"), Values("%f64"), Values("VUID-FragDepth-FragDepth-04215"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit float scalar", "has bit width 64")))); INSTANTIATE_TEST_SUITE_P( FrontFacingAndHelperInvocationSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("FrontFacing", "HelperInvocation"), Values("Fragment"), Values("Input"), Values("%bool"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( FrontFacingAndHelperInvocationNotFragment, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine( Values("FrontFacing", "HelperInvocation"), Values("Vertex", "GLCompute", "Geometry", "TessellationControl", "TessellationEvaluation"), Values("Input"), Values("%bool"), Values("VUID-FrontFacing-FrontFacing-04229 " "VUID-HelperInvocation-HelperInvocation-04239"), Values(TestResult(SPV_ERROR_INVALID_DATA, "to be used only with Fragment execution model")))); INSTANTIATE_TEST_SUITE_P( FrontFacingAndHelperInvocationNotInput, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("FrontFacing", "HelperInvocation"), Values("Fragment"), Values("Output"), Values("%bool"), Values("VUID-FrontFacing-FrontFacing-04230 " "VUID-HelperInvocation-HelperInvocation-04240"), Values(TestResult( SPV_ERROR_INVALID_DATA, "to be only used for variables with Input storage class", "uses storage class Output")))); INSTANTIATE_TEST_SUITE_P( FrontFacingAndHelperInvocationNotBool, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("FrontFacing", "HelperInvocation"), Values("Fragment"), Values("Input"), Values("%f32", "%u32"), Values("VUID-FrontFacing-FrontFacing-04231 " "VUID-HelperInvocation-HelperInvocation-04241"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a bool scalar", "is not a bool scalar")))); INSTANTIATE_TEST_SUITE_P( ComputeShaderInputInt32Vec3Success, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("GlobalInvocationId", "LocalInvocationId", "NumWorkgroups", "WorkgroupId"), Values("GLCompute"), Values("Input"), Values("%u32vec3"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( ComputeShaderInputInt32Vec3NotGLCompute, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("GlobalInvocationId", "LocalInvocationId", "NumWorkgroups", "WorkgroupId"), Values("Vertex", "Fragment", "Geometry", "TessellationControl", "TessellationEvaluation"), Values("Input"), Values("%u32vec3"), Values("VUID-GlobalInvocationId-GlobalInvocationId-04236 " "VUID-LocalInvocationId-LocalInvocationId-04281 " "VUID-NumWorkgroups-NumWorkgroups-04296 " "VUID-WorkgroupId-WorkgroupId-04422"), Values(TestResult(SPV_ERROR_INVALID_DATA, "to be used only with GLCompute, MeshNV, " "TaskNV, MeshEXT or TaskEXT execution model")))); INSTANTIATE_TEST_SUITE_P( ComputeShaderInputInt32Vec3NotInput, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("GlobalInvocationId", "LocalInvocationId", "NumWorkgroups", "WorkgroupId"), Values("GLCompute"), Values("Output"), Values("%u32vec3"), Values("VUID-GlobalInvocationId-GlobalInvocationId-04237 " "VUID-LocalInvocationId-LocalInvocationId-04282 " "VUID-NumWorkgroups-NumWorkgroups-04297 " "VUID-WorkgroupId-WorkgroupId-04423"), Values(TestResult( SPV_ERROR_INVALID_DATA, "to be only used for variables with Input storage class", "uses storage class Output")))); INSTANTIATE_TEST_SUITE_P( ComputeShaderInputInt32Vec3NotIntVector, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("GlobalInvocationId", "LocalInvocationId", "NumWorkgroups", "WorkgroupId"), Values("GLCompute"), Values("Input"), Values("%u32arr3", "%f32vec3"), Values("VUID-GlobalInvocationId-GlobalInvocationId-04238 " "VUID-LocalInvocationId-LocalInvocationId-04283 " "VUID-NumWorkgroups-NumWorkgroups-04298 " "VUID-WorkgroupId-WorkgroupId-04424"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 3-component 32-bit int vector", "is not an int vector")))); INSTANTIATE_TEST_SUITE_P( ComputeShaderInputInt32Vec3NotIntVec3, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("GlobalInvocationId", "LocalInvocationId", "NumWorkgroups", "WorkgroupId"), Values("GLCompute"), Values("Input"), Values("%u32vec4"), Values("VUID-GlobalInvocationId-GlobalInvocationId-04238 " "VUID-LocalInvocationId-LocalInvocationId-04283 " "VUID-NumWorkgroups-NumWorkgroups-04298 " "VUID-WorkgroupId-WorkgroupId-04424"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 3-component 32-bit int vector", "has 4 components")))); INSTANTIATE_TEST_SUITE_P( ComputeShaderInputInt32Vec3NotInt32Vec, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("GlobalInvocationId", "LocalInvocationId", "NumWorkgroups", "WorkgroupId"), Values("GLCompute"), Values("Input"), Values("%u64vec3"), Values("VUID-GlobalInvocationId-GlobalInvocationId-04238 " "VUID-LocalInvocationId-LocalInvocationId-04283 " "VUID-NumWorkgroups-NumWorkgroups-04298 " "VUID-WorkgroupId-WorkgroupId-04424"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 3-component 32-bit int vector", "has components with bit width 64")))); INSTANTIATE_TEST_SUITE_P( InvocationIdSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("InvocationId"), Values("Geometry", "TessellationControl"), Values("Input"), Values("%u32"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( InvocationIdInvalidExecutionModel, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("InvocationId"), Values("Vertex", "Fragment", "GLCompute", "TessellationEvaluation"), Values("Input"), Values("%u32"), Values("VUID-InvocationId-InvocationId-04257"), Values(TestResult(SPV_ERROR_INVALID_DATA, "to be used only with TessellationControl or " "Geometry execution models")))); INSTANTIATE_TEST_SUITE_P( InvocationIdNotInput, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("InvocationId"), Values("Geometry", "TessellationControl"), Values("Output"), Values("%u32"), Values("VUID-InvocationId-InvocationId-04258"), Values(TestResult( SPV_ERROR_INVALID_DATA, "to be only used for variables with Input storage class", "uses storage class Output")))); INSTANTIATE_TEST_SUITE_P( InvocationIdNotIntScalar, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("InvocationId"), Values("Geometry", "TessellationControl"), Values("Input"), Values("%f32", "%u32vec3"), Values("VUID-InvocationId-InvocationId-04259"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit int scalar", "is not an int scalar")))); INSTANTIATE_TEST_SUITE_P( InvocationIdNotInt32, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("InvocationId"), Values("Geometry", "TessellationControl"), Values("Input"), Values("%u64"), Values("VUID-InvocationId-InvocationId-04259"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit int scalar", "has bit width 64")))); INSTANTIATE_TEST_SUITE_P( InstanceIndexSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("InstanceIndex"), Values("Vertex"), Values("Input"), Values("%u32"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( InstanceIndexInvalidExecutionModel, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("InstanceIndex"), Values("Geometry", "Fragment", "GLCompute", "TessellationControl", "TessellationEvaluation"), Values("Input"), Values("%u32"), Values("VUID-InstanceIndex-InstanceIndex-04263"), Values(TestResult(SPV_ERROR_INVALID_DATA, "to be used only with Vertex execution model")))); INSTANTIATE_TEST_SUITE_P( InstanceIndexNotInput, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("InstanceIndex"), Values("Vertex"), Values("Output"), Values("%u32"), Values("VUID-InstanceIndex-InstanceIndex-04264"), Values(TestResult( SPV_ERROR_INVALID_DATA, "to be only used for variables with Input storage class", "uses storage class Output")))); INSTANTIATE_TEST_SUITE_P( InstanceIndexNotIntScalar, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("InstanceIndex"), Values("Vertex"), Values("Input"), Values("%f32", "%u32vec3"), Values("VUID-InstanceIndex-InstanceIndex-04265"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit int scalar", "is not an int scalar")))); INSTANTIATE_TEST_SUITE_P( InstanceIndexNotInt32, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("InstanceIndex"), Values("Vertex"), Values("Input"), Values("%u64"), Values("VUID-InstanceIndex-InstanceIndex-04265"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit int scalar", "has bit width 64")))); INSTANTIATE_TEST_SUITE_P( LayerAndViewportIndexInputSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("Layer", "ViewportIndex"), Values("Fragment"), Values("Input"), Values("%u32"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( LayerAndViewportIndexOutputSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("Layer", "ViewportIndex"), Values("Geometry"), Values("Output"), Values("%u32"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( LayerAndViewportIndexInvalidExecutionModel, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine( Values("Layer", "ViewportIndex"), Values("TessellationControl", "GLCompute"), Values("Input"), Values("%u32"), Values("VUID-Layer-Layer-04272 VUID-ViewportIndex-ViewportIndex-04404"), Values( TestResult(SPV_ERROR_INVALID_DATA, "to be used only with Vertex, TessellationEvaluation, " "Geometry, or Fragment execution models")))); INSTANTIATE_TEST_SUITE_P( ViewportIndexExecutionModelEnabledByCapability, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("ViewportIndex"), Values("Vertex", "TessellationEvaluation"), Values("Output"), Values("%u32"), Values("VUID-ViewportIndex-ViewportIndex-04405"), Values(TestResult( SPV_ERROR_INVALID_DATA, "ShaderViewportIndexLayerEXT or ShaderViewportIndex")))); INSTANTIATE_TEST_SUITE_P( LayerExecutionModelEnabledByCapability, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("Layer"), Values("Vertex", "TessellationEvaluation"), Values("Output"), Values("%u32"), Values("VUID-Layer-Layer-04273"), Values(TestResult(SPV_ERROR_INVALID_DATA, "ShaderViewportIndexLayerEXT or ShaderLayer")))); INSTANTIATE_TEST_SUITE_P( LayerAndViewportIndexFragmentNotInput, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine( Values("Layer", "ViewportIndex"), Values("Fragment"), Values("Output"), Values("%u32"), Values("VUID-Layer-Layer-04275 VUID-ViewportIndex-ViewportIndex-04407"), Values(TestResult(SPV_ERROR_INVALID_DATA, "Output storage class if execution model is Fragment", "which is called with execution model Fragment")))); INSTANTIATE_TEST_SUITE_P( LayerAndViewportIndexGeometryNotOutput, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine( Values("Layer", "ViewportIndex"), Values("Vertex", "TessellationEvaluation", "Geometry"), Values("Input"), Values("%u32"), Values("VUID-Layer-Layer-04274 VUID-ViewportIndex-ViewportIndex-04406"), Values(TestResult(SPV_ERROR_INVALID_DATA, "Input storage class if execution model is Vertex, " "TessellationEvaluation, Geometry, MeshNV or MeshEXT", "which is called with execution model")))); INSTANTIATE_TEST_SUITE_P( LayerAndViewportIndexNotIntScalar, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine( Values("Layer", "ViewportIndex"), Values("Fragment"), Values("Input"), Values("%f32", "%u32vec3"), Values("VUID-Layer-Layer-04276 VUID-ViewportIndex-ViewportIndex-04408"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit int scalar", "is not an int scalar")))); INSTANTIATE_TEST_SUITE_P( LayerAndViewportIndexNotInt32, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine( Values("Layer", "ViewportIndex"), Values("Fragment"), Values("Input"), Values("%u64"), Values("VUID-Layer-Layer-04276 VUID-ViewportIndex-ViewportIndex-04408"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit int scalar", "has bit width 64")))); INSTANTIATE_TEST_SUITE_P( LayerCapability, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("Layer"), Values("Vertex"), Values("Output"), Values("%u32"), Values("OpCapability ShaderLayer\n"), Values(nullptr), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( ViewportIndexCapability, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("ViewportIndex"), Values("Vertex"), Values("Output"), Values("%u32"), Values("OpCapability ShaderViewportIndex\n"), Values(nullptr), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( PatchVerticesSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("PatchVertices"), Values("TessellationEvaluation", "TessellationControl"), Values("Input"), Values("%u32"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( PatchVerticesInvalidExecutionModel, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("PatchVertices"), Values("Vertex", "Fragment", "GLCompute", "Geometry"), Values("Input"), Values("%u32"), Values("VUID-PatchVertices-PatchVertices-04308"), Values(TestResult(SPV_ERROR_INVALID_DATA, "to be used only with TessellationControl or " "TessellationEvaluation execution models")))); INSTANTIATE_TEST_SUITE_P( PatchVerticesNotInput, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("PatchVertices"), Values("TessellationEvaluation", "TessellationControl"), Values("Output"), Values("%u32"), Values("VUID-PatchVertices-PatchVertices-04309"), Values(TestResult( SPV_ERROR_INVALID_DATA, "to be only used for variables with Input storage class", "uses storage class Output")))); INSTANTIATE_TEST_SUITE_P( PatchVerticesNotIntScalar, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("PatchVertices"), Values("TessellationEvaluation", "TessellationControl"), Values("Input"), Values("%f32", "%u32vec3"), Values("VUID-PatchVertices-PatchVertices-04310"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit int scalar", "is not an int scalar")))); INSTANTIATE_TEST_SUITE_P( PatchVerticesNotInt32, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("PatchVertices"), Values("TessellationEvaluation", "TessellationControl"), Values("Input"), Values("%u64"), Values("VUID-PatchVertices-PatchVertices-04310"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit int scalar", "has bit width 64")))); INSTANTIATE_TEST_SUITE_P( PointCoordSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("PointCoord"), Values("Fragment"), Values("Input"), Values("%f32vec2"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( PointCoordNotFragment, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine( Values("PointCoord"), Values("Vertex", "GLCompute", "Geometry", "TessellationControl", "TessellationEvaluation"), Values("Input"), Values("%f32vec2"), Values("VUID-PointCoord-PointCoord-04311"), Values(TestResult(SPV_ERROR_INVALID_DATA, "to be used only with Fragment execution model")))); INSTANTIATE_TEST_SUITE_P( PointCoordNotInput, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("PointCoord"), Values("Fragment"), Values("Output"), Values("%f32vec2"), Values("VUID-PointCoord-PointCoord-04312"), Values(TestResult( SPV_ERROR_INVALID_DATA, "to be only used for variables with Input storage class", "uses storage class Output")))); INSTANTIATE_TEST_SUITE_P( PointCoordNotFloatVector, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("PointCoord"), Values("Fragment"), Values("Input"), Values("%f32arr2", "%u32vec2"), Values("VUID-PointCoord-PointCoord-04313"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 2-component 32-bit float vector", "is not a float vector")))); INSTANTIATE_TEST_SUITE_P( PointCoordNotFloatVec3, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("PointCoord"), Values("Fragment"), Values("Input"), Values("%f32vec3"), Values("VUID-PointCoord-PointCoord-04313"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 2-component 32-bit float vector", "has 3 components")))); INSTANTIATE_TEST_SUITE_P( PointCoordNotF32Vec4, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("PointCoord"), Values("Fragment"), Values("Input"), Values("%f64vec2"), Values("VUID-PointCoord-PointCoord-04313"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 2-component 32-bit float vector", "has components with bit width 64")))); INSTANTIATE_TEST_SUITE_P( PointSizeOutputSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("PointSize"), Values("Vertex", "Geometry", "TessellationControl", "TessellationEvaluation"), Values("Output"), Values("%f32"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( PointSizeInputSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("PointSize"), Values("Geometry", "TessellationControl", "TessellationEvaluation"), Values("Input"), Values("%f32"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( PointSizeVertexInput, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("PointSize"), Values("Vertex"), Values("Input"), Values("%f32"), Values("VUID-PointSize-PointSize-04315"), Values(TestResult( SPV_ERROR_INVALID_DATA, "Vulkan spec doesn't allow BuiltIn PointSize " "to be used for variables with Input storage class if " "execution model is Vertex.", "which is called with execution model Vertex.")))); INSTANTIATE_TEST_SUITE_P( PointSizeInvalidExecutionModel, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("PointSize"), Values("GLCompute", "Fragment"), Values("Input", "Output"), Values("%f32"), Values("VUID-PointSize-PointSize-04314"), Values(TestResult( SPV_ERROR_INVALID_DATA, "to be used only with Vertex, TessellationControl, " "TessellationEvaluation or Geometry execution models")))); INSTANTIATE_TEST_SUITE_P( PointSizeNotFloatScalar, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("PointSize"), Values("Vertex"), Values("Output"), Values("%f32vec4", "%u32"), Values("VUID-PointSize-PointSize-04317"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit float scalar", "is not a float scalar")))); INSTANTIATE_TEST_SUITE_P( PointSizeNotF32, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("PointSize"), Values("Vertex"), Values("Output"), Values("%f64"), Values("VUID-PointSize-PointSize-04317"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit float scalar", "has bit width 64")))); INSTANTIATE_TEST_SUITE_P( PositionOutputSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("Position"), Values("Vertex", "Geometry", "TessellationControl", "TessellationEvaluation"), Values("Output"), Values("%f32vec4"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( PositionInputSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("Position"), Values("Geometry", "TessellationControl", "TessellationEvaluation"), Values("Input"), Values("%f32vec4"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( PositionInvalidStorageClass, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("Position"), Values("Geometry", "TessellationControl", "TessellationEvaluation"), Values("Private"), Values("%f32vec4"), Values("VUID-Position-Position-04320"), Values(TestResult( SPV_ERROR_INVALID_DATA, "Vulkan spec allows BuiltIn Position to be only used for " "variables with Input or Output storage class.")))); INSTANTIATE_TEST_SUITE_P( PositionVertexInput, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("Position"), Values("Vertex"), Values("Input"), Values("%f32vec4"), Values("VUID-Position-Position-04319"), Values(TestResult( SPV_ERROR_INVALID_DATA, "Vulkan spec doesn't allow BuiltIn Position " "to be used for variables with Input storage class if " "execution model is Vertex.", "which is called with execution model Vertex.")))); INSTANTIATE_TEST_SUITE_P( PositionInvalidExecutionModel, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("Position"), Values("GLCompute", "Fragment"), Values("Input", "Output"), Values("%f32vec4"), Values("VUID-Position-Position-04318"), Values(TestResult( SPV_ERROR_INVALID_DATA, "to be used only with Vertex, TessellationControl, " "TessellationEvaluation or Geometry execution models")))); INSTANTIATE_TEST_SUITE_P( PositionNotFloatVector, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("Position"), Values("Geometry"), Values("Input"), Values("%f32arr4", "%u32vec4"), Values("VUID-Position-Position-04321"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 4-component 32-bit float vector", "is not a float vector")))); INSTANTIATE_TEST_SUITE_P( PositionNotFloatVec4, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("Position"), Values("Geometry"), Values("Input"), Values("%f32vec3"), Values("VUID-Position-Position-04321"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 4-component 32-bit float vector", "has 3 components")))); INSTANTIATE_TEST_SUITE_P( PositionNotF32Vec4, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("Position"), Values("Geometry"), Values("Input"), Values("%f64vec4"), Values("VUID-Position-Position-04321"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 4-component 32-bit float vector", "has components with bit width 64")))); INSTANTIATE_TEST_SUITE_P( PrimitiveIdInputSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("PrimitiveId"), Values("Fragment", "TessellationControl", "TessellationEvaluation", "Geometry"), Values("Input"), Values("%u32"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( PrimitiveIdOutputSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("PrimitiveId"), Values("Geometry"), Values("Output"), Values("%u32"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( PrimitiveIdInvalidExecutionModel, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine( Values("PrimitiveId"), Values("Vertex", "GLCompute"), Values("Input"), Values("%u32"), Values("VUID-PrimitiveId-PrimitiveId-04330"), Values(TestResult(SPV_ERROR_INVALID_DATA, "to be used only with Fragment, TessellationControl, " "TessellationEvaluation, Geometry, MeshNV, MeshEXT, " "IntersectionKHR, " "AnyHitKHR, and ClosestHitKHR execution models")))); INSTANTIATE_TEST_SUITE_P( PrimitiveIdFragmentNotInput, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine( Values("PrimitiveId"), Values("Fragment"), Values("Output"), Values("%u32"), Values("VUID-PrimitiveId-PrimitiveId-04334"), Values(TestResult(SPV_ERROR_INVALID_DATA, "Output storage class if execution model is Fragment", "which is called with execution model Fragment")))); INSTANTIATE_TEST_SUITE_P( PrimitiveIdTessellationNotInput, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("PrimitiveId"), Values("TessellationControl", "TessellationEvaluation"), Values("Output"), Values("%u32"), Values("VUID-PrimitiveId-PrimitiveId-04334"), Values(TestResult( SPV_ERROR_INVALID_DATA, "Output storage class if execution model is Tessellation", "which is called with execution model Tessellation")))); INSTANTIATE_TEST_SUITE_P( PrimitiveIdNotIntScalar, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("PrimitiveId"), Values("Fragment"), Values("Input"), Values("%f32", "%u32vec3"), Values("VUID-PrimitiveId-PrimitiveId-04337"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit int scalar", "is not an int scalar")))); INSTANTIATE_TEST_SUITE_P( PrimitiveIdNotInt32, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("PrimitiveId"), Values("Fragment"), Values("Input"), Values("%u64"), Values("VUID-PrimitiveId-PrimitiveId-04337"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit int scalar", "has bit width 64")))); INSTANTIATE_TEST_SUITE_P( SampleIdSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("SampleId"), Values("Fragment"), Values("Input"), Values("%u32"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( SampleIdInvalidExecutionModel, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine( Values("SampleId"), Values("Vertex", "GLCompute", "Geometry", "TessellationControl", "TessellationEvaluation"), Values("Input"), Values("%u32"), Values("VUID-SampleId-SampleId-04354"), Values(TestResult(SPV_ERROR_INVALID_DATA, "to be used only with Fragment execution model")))); INSTANTIATE_TEST_SUITE_P( SampleIdNotInput, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine( Values("SampleId"), Values("Fragment"), Values("Output"), Values("%u32"), Values("VUID-SampleId-SampleId-04355"), Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows BuiltIn SampleId to be only used " "for variables with Input storage class")))); INSTANTIATE_TEST_SUITE_P( SampleIdNotIntScalar, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("SampleId"), Values("Fragment"), Values("Input"), Values("%f32", "%u32vec3"), Values("VUID-SampleId-SampleId-04356"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit int scalar", "is not an int scalar")))); INSTANTIATE_TEST_SUITE_P( SampleIdNotInt32, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("SampleId"), Values("Fragment"), Values("Input"), Values("%u64"), Values("VUID-SampleId-SampleId-04356"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit int scalar", "has bit width 64")))); INSTANTIATE_TEST_SUITE_P( SampleMaskSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("SampleMask"), Values("Fragment"), Values("Input", "Output"), Values("%u32arr2", "%u32arr4"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( SampleMaskInvalidExecutionModel, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine( Values("SampleMask"), Values("Vertex", "GLCompute", "Geometry", "TessellationControl", "TessellationEvaluation"), Values("Input"), Values("%u32arr2"), Values("VUID-SampleMask-SampleMask-04357"), Values(TestResult(SPV_ERROR_INVALID_DATA, "to be used only with Fragment execution model")))); INSTANTIATE_TEST_SUITE_P( SampleMaskWrongStorageClass, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("SampleMask"), Values("Fragment"), Values("Workgroup"), Values("%u32arr2"), Values("VUID-SampleMask-SampleMask-04358"), Values(TestResult( SPV_ERROR_INVALID_DATA, "Vulkan spec allows BuiltIn SampleMask to be only used for " "variables with Input or Output storage class")))); INSTANTIATE_TEST_SUITE_P( SampleMaskNotArray, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("SampleMask"), Values("Fragment"), Values("Input"), Values("%f32", "%u32vec3"), Values("VUID-SampleMask-SampleMask-04359"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit int array", "is not an array")))); INSTANTIATE_TEST_SUITE_P( SampleMaskNotIntArray, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("SampleMask"), Values("Fragment"), Values("Input"), Values("%f32arr2"), Values("VUID-SampleMask-SampleMask-04359"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit int array", "components are not int scalar")))); INSTANTIATE_TEST_SUITE_P( SampleMaskNotInt32Array, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("SampleMask"), Values("Fragment"), Values("Input"), Values("%u64arr2"), Values("VUID-SampleMask-SampleMask-04359"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit int array", "has components with bit width 64")))); INSTANTIATE_TEST_SUITE_P( SamplePositionSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("SamplePosition"), Values("Fragment"), Values("Input"), Values("%f32vec2"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( SamplePositionNotFragment, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine( Values("SamplePosition"), Values("Vertex", "GLCompute", "Geometry", "TessellationControl", "TessellationEvaluation"), Values("Input"), Values("%f32vec2"), Values("VUID-SamplePosition-SamplePosition-04360"), Values(TestResult(SPV_ERROR_INVALID_DATA, "to be used only with Fragment execution model")))); INSTANTIATE_TEST_SUITE_P( SamplePositionNotInput, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("SamplePosition"), Values("Fragment"), Values("Output"), Values("%f32vec2"), Values("VUID-SamplePosition-SamplePosition-04361"), Values(TestResult( SPV_ERROR_INVALID_DATA, "to be only used for variables with Input storage class", "uses storage class Output")))); INSTANTIATE_TEST_SUITE_P( SamplePositionNotFloatVector, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("SamplePosition"), Values("Fragment"), Values("Input"), Values("%f32arr2", "%u32vec4"), Values("VUID-SamplePosition-SamplePosition-04362"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 2-component 32-bit float vector", "is not a float vector")))); INSTANTIATE_TEST_SUITE_P( SamplePositionNotFloatVec2, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("SamplePosition"), Values("Fragment"), Values("Input"), Values("%f32vec3"), Values("VUID-SamplePosition-SamplePosition-04362"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 2-component 32-bit float vector", "has 3 components")))); INSTANTIATE_TEST_SUITE_P( SamplePositionNotF32Vec2, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("SamplePosition"), Values("Fragment"), Values("Input"), Values("%f64vec2"), Values("VUID-SamplePosition-SamplePosition-04362"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 2-component 32-bit float vector", "has components with bit width 64")))); INSTANTIATE_TEST_SUITE_P( TessCoordSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("TessCoord"), Values("TessellationEvaluation"), Values("Input"), Values("%f32vec3"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( TessCoordNotFragment, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine( Values("TessCoord"), Values("Vertex", "GLCompute", "Geometry", "TessellationControl", "Fragment"), Values("Input"), Values("%f32vec3"), Values("VUID-TessCoord-TessCoord-04387"), Values(TestResult( SPV_ERROR_INVALID_DATA, "to be used only with TessellationEvaluation execution model")))); INSTANTIATE_TEST_SUITE_P( TessCoordNotInput, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("TessCoord"), Values("Fragment"), Values("Output"), Values("%f32vec3"), Values("VUID-TessCoord-TessCoord-04388"), Values(TestResult( SPV_ERROR_INVALID_DATA, "to be only used for variables with Input storage class", "uses storage class Output")))); INSTANTIATE_TEST_SUITE_P( TessCoordNotFloatVector, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("TessCoord"), Values("Fragment"), Values("Input"), Values("%f32arr3", "%u32vec4"), Values("VUID-TessCoord-TessCoord-04389"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 3-component 32-bit float vector", "is not a float vector")))); INSTANTIATE_TEST_SUITE_P( TessCoordNotFloatVec3, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("TessCoord"), Values("Fragment"), Values("Input"), Values("%f32vec2"), Values("VUID-TessCoord-TessCoord-04389"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 3-component 32-bit float vector", "has 2 components")))); INSTANTIATE_TEST_SUITE_P( TessCoordNotF32Vec3, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("TessCoord"), Values("Fragment"), Values("Input"), Values("%f64vec3"), Values("VUID-TessCoord-TessCoord-04389"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 3-component 32-bit float vector", "has components with bit width 64")))); INSTANTIATE_TEST_SUITE_P( TessLevelOuterTeseInputSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("TessLevelOuter"), Values("TessellationEvaluation"), Values("Input"), Values("%f32arr4"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( TessLevelOuterTescOutputSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("TessLevelOuter"), Values("TessellationControl"), Values("Output"), Values("%f32arr4"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( TessLevelOuterInvalidExecutionModel, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("TessLevelOuter"), Values("Vertex", "GLCompute", "Geometry", "Fragment"), Values("Input"), Values("%f32arr4"), Values("VUID-TessLevelOuter-TessLevelOuter-04390"), Values(TestResult(SPV_ERROR_INVALID_DATA, "to be used only with TessellationControl or " "TessellationEvaluation execution models.")))); INSTANTIATE_TEST_SUITE_P( TessLevelOuterOutputTese, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("TessLevelOuter"), Values("TessellationEvaluation"), Values("Output"), Values("%f32arr4"), Values("VUID-TessLevelOuter-TessLevelOuter-04392"), Values(TestResult( SPV_ERROR_INVALID_DATA, "Vulkan spec doesn't allow TessLevelOuter/TessLevelInner to be " "used for variables with Output storage class if execution " "model is TessellationEvaluation.")))); INSTANTIATE_TEST_SUITE_P( TessLevelOuterInputTesc, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("TessLevelOuter"), Values("TessellationControl"), Values("Input"), Values("%f32arr4"), Values("VUID-TessLevelOuter-TessLevelOuter-04391"), Values(TestResult( SPV_ERROR_INVALID_DATA, "Vulkan spec doesn't allow TessLevelOuter/TessLevelInner to be " "used for variables with Input storage class if execution " "model is TessellationControl.")))); INSTANTIATE_TEST_SUITE_P( TessLevelOuterNotArray, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("TessLevelOuter"), Values("TessellationEvaluation"), Values("Input"), Values("%f32vec4", "%f32"), Values("VUID-TessLevelOuter-TessLevelOuter-04393"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 4-component 32-bit float array", "is not an array")))); INSTANTIATE_TEST_SUITE_P( TessLevelOuterNotFloatArray, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("TessLevelOuter"), Values("TessellationEvaluation"), Values("Input"), Values("%u32arr4"), Values("VUID-TessLevelOuter-TessLevelOuter-04393"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 4-component 32-bit float array", "components are not float scalar")))); INSTANTIATE_TEST_SUITE_P( TessLevelOuterNotFloatArr4, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("TessLevelOuter"), Values("TessellationEvaluation"), Values("Input"), Values("%f32arr3"), Values("VUID-TessLevelOuter-TessLevelOuter-04393"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 4-component 32-bit float array", "has 3 components")))); INSTANTIATE_TEST_SUITE_P( TessLevelOuterNotF32Arr4, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("TessLevelOuter"), Values("TessellationEvaluation"), Values("Input"), Values("%f64arr4"), Values("VUID-TessLevelOuter-TessLevelOuter-04393"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 4-component 32-bit float array", "has components with bit width 64")))); INSTANTIATE_TEST_SUITE_P( TessLevelInnerTeseInputSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("TessLevelInner"), Values("TessellationEvaluation"), Values("Input"), Values("%f32arr2"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( TessLevelInnerTescOutputSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("TessLevelInner"), Values("TessellationControl"), Values("Output"), Values("%f32arr2"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( TessLevelInnerInvalidExecutionModel, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("TessLevelInner"), Values("Vertex", "GLCompute", "Geometry", "Fragment"), Values("Input"), Values("%f32arr2"), Values("VUID-TessLevelInner-TessLevelInner-04394"), Values(TestResult(SPV_ERROR_INVALID_DATA, "to be used only with TessellationControl or " "TessellationEvaluation execution models.")))); INSTANTIATE_TEST_SUITE_P( TessLevelInnerOutputTese, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("TessLevelInner"), Values("TessellationEvaluation"), Values("Output"), Values("%f32arr2"), Values("VUID-TessLevelInner-TessLevelInner-04396"), Values(TestResult( SPV_ERROR_INVALID_DATA, "Vulkan spec doesn't allow TessLevelOuter/TessLevelInner to be " "used for variables with Output storage class if execution " "model is TessellationEvaluation.")))); INSTANTIATE_TEST_SUITE_P( TessLevelInnerInputTesc, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("TessLevelInner"), Values("TessellationControl"), Values("Input"), Values("%f32arr2"), Values("VUID-TessLevelInner-TessLevelInner-04395"), Values(TestResult( SPV_ERROR_INVALID_DATA, "Vulkan spec doesn't allow TessLevelOuter/TessLevelInner to be " "used for variables with Input storage class if execution " "model is TessellationControl.")))); INSTANTIATE_TEST_SUITE_P( TessLevelInnerNotArray, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("TessLevelInner"), Values("TessellationEvaluation"), Values("Input"), Values("%f32vec2", "%f32"), Values("VUID-TessLevelInner-TessLevelInner-04397"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 2-component 32-bit float array", "is not an array")))); INSTANTIATE_TEST_SUITE_P( TessLevelInnerNotFloatArray, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("TessLevelInner"), Values("TessellationEvaluation"), Values("Input"), Values("%u32arr2"), Values("VUID-TessLevelInner-TessLevelInner-04397"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 2-component 32-bit float array", "components are not float scalar")))); INSTANTIATE_TEST_SUITE_P( TessLevelInnerNotFloatArr2, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("TessLevelInner"), Values("TessellationEvaluation"), Values("Input"), Values("%f32arr3"), Values("VUID-TessLevelInner-TessLevelInner-04397"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 2-component 32-bit float array", "has 3 components")))); INSTANTIATE_TEST_SUITE_P( TessLevelInnerNotF32Arr2, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("TessLevelInner"), Values("TessellationEvaluation"), Values("Input"), Values("%f64arr2"), Values("VUID-TessLevelInner-TessLevelInner-04397"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 2-component 32-bit float array", "has components with bit width 64")))); INSTANTIATE_TEST_SUITE_P( VertexIndexSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("VertexIndex"), Values("Vertex"), Values("Input"), Values("%u32"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( VertexIndexInvalidExecutionModel, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("VertexIndex"), Values("Fragment", "GLCompute", "Geometry", "TessellationControl", "TessellationEvaluation"), Values("Input"), Values("%u32"), Values("VUID-VertexIndex-VertexIndex-04398"), Values(TestResult(SPV_ERROR_INVALID_DATA, "to be used only with Vertex execution model")))); INSTANTIATE_TEST_SUITE_P( VertexIndexNotInput, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine( Values("VertexIndex"), Values("Vertex"), Values("Output"), Values("%u32"), Values("VUID-VertexIndex-VertexIndex-04399"), Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows BuiltIn VertexIndex to be only " "used for variables with Input storage class")))); INSTANTIATE_TEST_SUITE_P( VertexIndexNotIntScalar, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("VertexIndex"), Values("Vertex"), Values("Input"), Values("%f32", "%u32vec3"), Values("VUID-VertexIndex-VertexIndex-04400"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit int scalar", "is not an int scalar")))); INSTANTIATE_TEST_SUITE_P( VertexIndexNotInt32, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Combine(Values("VertexIndex"), Values("Vertex"), Values("Input"), Values("%u64"), Values("VUID-VertexIndex-VertexIndex-04400"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit int scalar", "has bit width 64")))); INSTANTIATE_TEST_SUITE_P( BaseInstanceOrVertexSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("BaseInstance", "BaseVertex"), Values("Vertex"), Values("Input"), Values("%u32"), Values("OpCapability DrawParameters\n"), Values("OpExtension \"SPV_KHR_shader_draw_parameters\"\n"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( BaseInstanceOrVertexInvalidExecutionModel, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("BaseInstance", "BaseVertex"), Values("Fragment", "GLCompute", "Geometry", "TessellationControl", "TessellationEvaluation"), Values("Input"), Values("%u32"), Values("OpCapability DrawParameters\n"), Values("OpExtension \"SPV_KHR_shader_draw_parameters\"\n"), Values("VUID-BaseInstance-BaseInstance-04181 " "VUID-BaseVertex-BaseVertex-04184"), Values(TestResult(SPV_ERROR_INVALID_DATA, "to be used only with Vertex execution model")))); INSTANTIATE_TEST_SUITE_P( BaseInstanceOrVertexNotInput, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("BaseInstance", "BaseVertex"), Values("Vertex"), Values("Output"), Values("%u32"), Values("OpCapability DrawParameters\n"), Values("OpExtension \"SPV_KHR_shader_draw_parameters\"\n"), Values("VUID-BaseInstance-BaseInstance-04182 " "VUID-BaseVertex-BaseVertex-04185"), Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows", "used for variables with Input storage class")))); INSTANTIATE_TEST_SUITE_P( BaseInstanceOrVertexNotIntScalar, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("BaseInstance", "BaseVertex"), Values("Vertex"), Values("Input"), Values("%f32", "%u32vec3"), Values("OpCapability DrawParameters\n"), Values("OpExtension \"SPV_KHR_shader_draw_parameters\"\n"), Values("VUID-BaseInstance-BaseInstance-04183 " "VUID-BaseVertex-BaseVertex-04186"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit int scalar", "is not an int scalar")))); INSTANTIATE_TEST_SUITE_P( DrawIndexSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("DrawIndex"), Values("Vertex"), Values("Input"), Values("%u32"), Values("OpCapability DrawParameters\n"), Values("OpExtension \"SPV_KHR_shader_draw_parameters\"\n"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( DrawIndexMeshSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine( Values("DrawIndex"), Values("MeshNV", "TaskNV"), Values("Input"), Values("%u32"), Values("OpCapability MeshShadingNV\n"), Values("OpExtension \"SPV_KHR_shader_draw_parameters\"\nOpExtension " "\"SPV_NV_mesh_shader\"\n"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( DrawIndexInvalidExecutionModel, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine( Values("DrawIndex"), Values("Fragment", "GLCompute", "Geometry", "TessellationControl", "TessellationEvaluation"), Values("Input"), Values("%u32"), Values("OpCapability DrawParameters\n"), Values("OpExtension \"SPV_KHR_shader_draw_parameters\"\n"), Values("VUID-DrawIndex-DrawIndex-04207"), Values(TestResult( SPV_ERROR_INVALID_DATA, "to be used only with Vertex, MeshNV, TaskNV , MeshEXT or TaskEXT " "execution model")))); INSTANTIATE_TEST_SUITE_P( DrawIndexNotInput, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("DrawIndex"), Values("Vertex"), Values("Output"), Values("%u32"), Values("OpCapability DrawParameters\n"), Values("OpExtension \"SPV_KHR_shader_draw_parameters\"\n"), Values("VUID-DrawIndex-DrawIndex-04208"), Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows", "used for variables with Input storage class")))); INSTANTIATE_TEST_SUITE_P( DrawIndexNotIntScalar, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("DrawIndex"), Values("Vertex"), Values("Input"), Values("%f32", "%u32vec3"), Values("OpCapability DrawParameters\n"), Values("OpExtension \"SPV_KHR_shader_draw_parameters\"\n"), Values("VUID-DrawIndex-DrawIndex-04209"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit int scalar", "is not an int scalar")))); INSTANTIATE_TEST_SUITE_P( ViewIndexSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("ViewIndex"), Values("Fragment", "Vertex", "Geometry", "TessellationControl", "TessellationEvaluation"), Values("Input"), Values("%u32"), Values("OpCapability MultiView\n"), Values("OpExtension \"SPV_KHR_multiview\"\n"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( ViewIndexInvalidExecutionModel, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("ViewIndex"), Values("GLCompute"), Values("Input"), Values("%u32"), Values("OpCapability MultiView\n"), Values("OpExtension \"SPV_KHR_multiview\"\n"), Values("VUID-ViewIndex-ViewIndex-04401"), Values(TestResult( SPV_ERROR_INVALID_DATA, "to be not be used with GLCompute execution model")))); INSTANTIATE_TEST_SUITE_P( ViewIndexNotInput, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("ViewIndex"), Values("Vertex"), Values("Output"), Values("%u32"), Values("OpCapability MultiView\n"), Values("OpExtension \"SPV_KHR_multiview\"\n"), Values("VUID-ViewIndex-ViewIndex-04402"), Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows", "used for variables with Input storage class")))); INSTANTIATE_TEST_SUITE_P( ViewIndexNotIntScalar, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("ViewIndex"), Values("Vertex"), Values("Input"), Values("%f32", "%u32vec3"), Values("OpCapability MultiView\n"), Values("OpExtension \"SPV_KHR_multiview\"\n"), Values("VUID-ViewIndex-ViewIndex-04403"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit int scalar", "is not an int scalar")))); INSTANTIATE_TEST_SUITE_P( DeviceIndexSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("DeviceIndex"), Values("Fragment", "Vertex", "Geometry", "TessellationControl", "TessellationEvaluation", "GLCompute"), Values("Input"), Values("%u32"), Values("OpCapability DeviceGroup\n"), Values("OpExtension \"SPV_KHR_device_group\"\n"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( DeviceIndexNotInput, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("DeviceIndex"), Values("Fragment", "Vertex", "GLCompute"), Values("Output"), Values("%u32"), Values("OpCapability DeviceGroup\n"), Values("OpExtension \"SPV_KHR_device_group\"\n"), Values("VUID-DeviceIndex-DeviceIndex-04205"), Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows", "used for variables with Input storage class")))); INSTANTIATE_TEST_SUITE_P( DeviceIndexNotIntScalar, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("DeviceIndex"), Values("Fragment", "Vertex", "GLCompute"), Values("Input"), Values("%f32", "%u32vec3"), Values("OpCapability DeviceGroup\n"), Values("OpExtension \"SPV_KHR_device_group\"\n"), Values("VUID-DeviceIndex-DeviceIndex-04206"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit int scalar", "is not an int scalar")))); // Test HitKind in NV RT shaders INSTANTIATE_TEST_SUITE_P( HitKindNVSuccess, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("HitKindNV"), Values("AnyHitNV", "ClosestHitNV"), Values("Input"), Values("%u32"), Values("OpCapability RayTracingNV\n"), Values("OpExtension \"SPV_NV_ray_tracing\"\n"), Values(nullptr), Values(TestResult()))); // HitKind is valid in AH, CH shaders as input i32 scalar INSTANTIATE_TEST_SUITE_P( HitKindSuccess, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("HitKindKHR"), Values("AnyHitKHR", "ClosestHitKHR"), Values("Input"), Values("%u32"), Values("OpCapability RayTracingKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( HitKindNotExecutionMode, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("HitKindKHR"), Values("Vertex", "Fragment", "TessellationControl", "TessellationEvaluation", "Geometry", "Fragment", "GLCompute", "RayGenerationKHR", "IntersectionKHR", "MissKHR", "CallableKHR"), Values("Input"), Values("%u32"), Values("OpCapability RayTracingKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values("VUID-HitKindKHR-HitKindKHR-04242"), Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec does not allow BuiltIn", "to be used with the execution model")))); INSTANTIATE_TEST_SUITE_P( HitKindNotInput, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("HitKindKHR"), Values("AnyHitKHR", "ClosestHitKHR"), Values("Output"), Values("%u32"), Values("OpCapability RayTracingKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values("VUID-HitKindKHR-HitKindKHR-04243"), Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows", "used for variables with Input storage class")))); INSTANTIATE_TEST_SUITE_P( HitKindNotIntScalar, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("HitKindKHR"), Values("AnyHitKHR", "ClosestHitKHR"), Values("Input"), Values("%f32", "%u32vec3"), Values("OpCapability RayTracingKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values("VUID-HitKindKHR-HitKindKHR-04244"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit int scalar", "is not an int scalar")))); // Ensure HitT is not supported in KHR RT shaders INSTANTIATE_TEST_SUITE_P( HitTNVNotSupportedInKHR, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("HitTNV"), Values("AnyHitKHR", "ClosestHitKHR"), Values("Input"), Values("%u32"), Values("OpCapability RayTracingKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values(nullptr), Values(TestResult( SPV_ERROR_INVALID_CAPABILITY, "of MemberDecorate requires one of these capabilities")))); // HitT is valid in AH, CH shaders as input f32 scalar (NV RT only) INSTANTIATE_TEST_SUITE_P( HitTNVSuccess, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("HitTNV"), Values("AnyHitNV", "ClosestHitNV"), Values("Input"), Values("%f32"), Values("OpCapability RayTracingNV\n"), Values("OpExtension \"SPV_NV_ray_tracing\"\n"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( HitTNVNotExecutionMode, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("HitTNV"), Values("Vertex", "Fragment", "TessellationControl", "TessellationEvaluation", "Geometry", "Fragment", "GLCompute", "RayGenerationNV", "IntersectionNV", "MissNV", "CallableNV"), Values("Input"), Values("%f32"), Values("OpCapability RayTracingNV\n"), Values("OpExtension \"SPV_NV_ray_tracing\"\n"), Values("VUID-HitTNV-HitTNV-04245"), Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec does not allow BuiltIn", "to be used with the execution model")))); INSTANTIATE_TEST_SUITE_P( HitTNVNotInput, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("HitTNV"), Values("AnyHitNV", "ClosestHitNV"), Values("Output"), Values("%f32"), Values("OpCapability RayTracingNV\n"), Values("OpExtension \"SPV_NV_ray_tracing\"\n"), Values("VUID-HitTNV-HitTNV-04246"), Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows", "used for variables with Input storage class")))); INSTANTIATE_TEST_SUITE_P( HitTNVNotIntScalar, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("HitTNV"), Values("AnyHitNV", "ClosestHitNV"), Values("Input"), Values("%u32", "%f32vec3"), Values("OpCapability RayTracingNV\n"), Values("OpExtension \"SPV_NV_ray_tracing\"\n"), Values("VUID-HitTNV-HitTNV-04247"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit float scalar", "is not a float scalar")))); // InstanceCustomIndexKHR, InstanceId, PrimitiveId, RayGeometryIndexKHR are // valid in IS, AH, CH shaders as input i32 scalars INSTANTIATE_TEST_SUITE_P( RTBuiltIn3StageI32Success, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("InstanceCustomIndexKHR", "RayGeometryIndexKHR", "InstanceId", "PrimitiveId"), Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR"), Values("Input"), Values("%u32"), Values("OpCapability RayTracingKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( RTBuiltIn3StageI32NotExecutionMode, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("InstanceCustomIndexKHR", "RayGeometryIndexKHR", "InstanceId"), Values("Vertex", "Fragment", "TessellationControl", "TessellationEvaluation", "Geometry", "Fragment", "GLCompute", "RayGenerationKHR", "MissKHR", "CallableKHR"), Values("Input"), Values("%u32"), Values("OpCapability RayTracingKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values("VUID-InstanceCustomIndexKHR-InstanceCustomIndexKHR-04251 " "VUID-RayGeometryIndexKHR-RayGeometryIndexKHR-04345 " "VUID-InstanceId-InstanceId-04254 "), Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec does not allow BuiltIn", "to be used with the execution model")))); INSTANTIATE_TEST_SUITE_P( RTBuiltIn3StageI32NotInput, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("InstanceCustomIndexKHR", "RayGeometryIndexKHR", "InstanceId"), Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR"), Values("Output"), Values("%u32"), Values("OpCapability RayTracingKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values("VUID-InstanceCustomIndexKHR-InstanceCustomIndexKHR-04252 " "VUID-RayGeometryIndexKHR-RayGeometryIndexKHR-04346 " "VUID-InstanceId-InstanceId-04255 "), Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows", "used for variables with Input storage class")))); INSTANTIATE_TEST_SUITE_P( RTBuiltIn3StageI32NotIntScalar, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("InstanceCustomIndexKHR", "RayGeometryIndexKHR", "InstanceId"), Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR"), Values("Input"), Values("%f32", "%u32vec3"), Values("OpCapability RayTracingKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values("VUID-InstanceCustomIndexKHR-InstanceCustomIndexKHR-04253 " "VUID-RayGeometryIndexKHR-RayGeometryIndexKHR-04347 " "VUID-InstanceId-InstanceId-04256 "), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit int scalar", "is not an int scalar")))); // PrimitiveId needs special negative testing because it has non-RT uses INSTANTIATE_TEST_SUITE_P( PrimitiveIdRTNotExecutionMode, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine( Values(SPV_ENV_VULKAN_1_2), Values("PrimitiveId"), Values("RayGenerationKHR", "MissKHR", "CallableKHR"), Values("Input"), Values("%u32"), Values("OpCapability RayTracingKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values("VUID-PrimitiveId-PrimitiveId-04330"), Values(TestResult(SPV_ERROR_INVALID_DATA, "to be used only with Fragment, TessellationControl, " "TessellationEvaluation, Geometry, MeshNV, MeshEXT, " "IntersectionKHR, " "AnyHitKHR, and ClosestHitKHR execution models")))); INSTANTIATE_TEST_SUITE_P( PrimitiveIdRTNotInput, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("PrimitiveId"), Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR"), Values("Output"), Values("%u32"), Values("OpCapability RayTracingKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values("VUID-PrimitiveId-PrimitiveId-04334"), Values(TestResult(SPV_ERROR_INVALID_DATA, "Output storage class if execution model is ")))); INSTANTIATE_TEST_SUITE_P( PrimitiveIdRTNotIntScalar, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("PrimitiveId"), Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR"), Values("Input"), Values("%f32", "%u32vec3"), Values("OpCapability RayTracingKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values("VUID-PrimitiveId-PrimitiveId-04337"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit int scalar", "is not an int scalar")))); // ObjectRayDirectionKHR and ObjectRayOriginKHR valid // in IS, AH, CH shaders as input 32-bit float vec3 INSTANTIATE_TEST_SUITE_P( ObjectRayDirectionAndOriginSuccess, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("ObjectRayDirectionKHR", "ObjectRayOriginKHR"), Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR"), Values("Input"), Values("%f32vec3"), Values("OpCapability RayTracingKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( ObjectRayDirectionAndOriginNotExecutionMode, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("ObjectRayDirectionKHR", "ObjectRayOriginKHR"), Values("Vertex", "Fragment", "TessellationControl", "TessellationEvaluation", "Geometry", "Fragment", "GLCompute", "RayGenerationKHR", "MissKHR", "CallableKHR"), Values("Input"), Values("%f32vec3"), Values("OpCapability RayTracingKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values("VUID-ObjectRayDirectionKHR-ObjectRayDirectionKHR-04299 " "VUID-ObjectRayOriginKHR-ObjectRayOriginKHR-04302 "), Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec does not allow BuiltIn", "to be used with the execution model")))); INSTANTIATE_TEST_SUITE_P( ObjectRayDirectionAndOriginNotInput, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("ObjectRayDirectionKHR", "ObjectRayOriginKHR"), Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR"), Values("Output"), Values("%f32vec3"), Values("OpCapability RayTracingKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values("VUID-ObjectRayDirectionKHR-ObjectRayDirectionKHR-04300 " "VUID-ObjectRayOriginKHR-ObjectRayOriginKHR-04303 "), Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows", "used for variables with Input storage class")))); INSTANTIATE_TEST_SUITE_P( ObjectRayDirectionAndOriginNotFloatVec3, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine( Values(SPV_ENV_VULKAN_1_2), Values("ObjectRayDirectionKHR", "ObjectRayOriginKHR"), Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR"), Values("Input"), Values("%u32vec3", "%f32", "%f32vec2", "%f32vec4"), Values("OpCapability RayTracingKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values("VUID-ObjectRayDirectionKHR-ObjectRayDirectionKHR-04301 " "VUID-ObjectRayOriginKHR-ObjectRayOriginKHR-04304 "), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 3-component 32-bit float vector")))); // ObjectToWorldKHR and WorldToObjectKHR valid // in IS, AH, CH shaders as input mat4x3 INSTANTIATE_TEST_SUITE_P( RTObjectMatrixSuccess, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("ObjectToWorldKHR", "WorldToObjectKHR"), Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR"), Values("Input"), Values("%f32mat34"), Values("OpCapability RayTracingKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( RTObjectMatrixNotExecutionMode, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("ObjectToWorldKHR", "WorldToObjectKHR"), Values("Vertex", "Fragment", "TessellationControl", "TessellationEvaluation", "Geometry", "Fragment", "GLCompute", "RayGenerationKHR", "MissKHR", "CallableKHR"), Values("Input"), Values("%f32mat34"), Values("OpCapability RayTracingKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values("VUID-ObjectToWorldKHR-ObjectToWorldKHR-04305 " "VUID-WorldToObjectKHR-WorldToObjectKHR-04434 "), Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec does not allow BuiltIn", "to be used with the execution model")))); INSTANTIATE_TEST_SUITE_P( RTObjectMatrixNotInput, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("ObjectToWorldKHR", "WorldToObjectKHR"), Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR"), Values("Output"), Values("%f32mat34"), Values("OpCapability RayTracingKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values("VUID-ObjectToWorldKHR-ObjectToWorldKHR-04306 " "VUID-WorldToObjectKHR-WorldToObjectKHR-04435 "), Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows", "used for variables with Input storage class")))); INSTANTIATE_TEST_SUITE_P( RTObjectMatrixNotMat4x3, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("ObjectToWorldKHR", "WorldToObjectKHR"), Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR"), Values("Input"), Values("%f32mat43", "%f32mat44", "%f32vec4"), Values("OpCapability RayTracingKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values("VUID-ObjectToWorldKHR-ObjectToWorldKHR-04307 " "VUID-WorldToObjectKHR-WorldToObjectKHR-04436 "), Values(TestResult( SPV_ERROR_INVALID_DATA, "variable needs to be a matrix with " "4 columns of 3-component vectors of 32-bit floats")))); // IncomingRayFlagsKHR is valid // in IS, AH, CH, MS shaders as an input i32 scalar INSTANTIATE_TEST_SUITE_P( IncomingRayFlagsSuccess, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("IncomingRayFlagsKHR"), Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR", "MissKHR"), Values("Input"), Values("%u32"), Values("OpCapability RayTracingKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( IncomingRayFlagsNotExecutionMode, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("IncomingRayFlagsKHR"), Values("Vertex", "Fragment", "TessellationControl", "TessellationEvaluation", "Geometry", "Fragment", "GLCompute", "RayGenerationKHR", "CallableKHR"), Values("Input"), Values("%u32"), Values("OpCapability RayTracingKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values("VUID-IncomingRayFlagsKHR-IncomingRayFlagsKHR-04248 " "VUID-RayTmaxKHR-RayTmaxKHR-04348 " "VUID-RayTminKHR-RayTminKHR-04351 "), Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec does not allow BuiltIn", "to be used with the execution model")))); INSTANTIATE_TEST_SUITE_P( IncomingRayFlagsNotInput, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("IncomingRayFlagsKHR"), Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR", "MissKHR"), Values("Output"), Values("%u32"), Values("OpCapability RayTracingKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values("VUID-IncomingRayFlagsKHR-IncomingRayFlagsKHR-04249 " "VUID-RayTmaxKHR-RayTmaxKHR-04349 " "VUID-RayTminKHR-RayTminKHR-04352 "), Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows", "used for variables with Input storage class")))); INSTANTIATE_TEST_SUITE_P( IncomingRayFlagsNotIntScalar, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("IncomingRayFlagsKHR"), Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR", "MissKHR"), Values("Input"), Values("%f32", "%u32vec3"), Values("OpCapability RayTracingKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values("VUID-IncomingRayFlagsKHR-IncomingRayFlagsKHR-04250 " "VUID-RayTmaxKHR-RayTmaxKHR-04350 " "VUID-RayTminKHR-RayTminKHR-04353 "), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit int scalar", "is not an int scalar")))); // CullMaskKHR is valid // in IS, AH, CH, MS shaders as an input i32 scalar INSTANTIATE_TEST_SUITE_P( CullMaskSuccess, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("CullMaskKHR"), Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR", "MissKHR"), Values("Input"), Values("%u32"), Values("OpCapability RayTracingKHR\nOpCapability RayCullMaskKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\nOpExtension " "\"SPV_KHR_ray_cull_mask\"\n"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( CullMaskNotExecutionMode, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("CullMaskKHR"), Values("Vertex", "Fragment", "TessellationControl", "TessellationEvaluation", "Geometry", "Fragment", "GLCompute", "RayGenerationKHR", "CallableKHR"), Values("Input"), Values("%u32"), Values("OpCapability RayTracingKHR\nOpCapability RayCullMaskKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\nOpExtension " "\"SPV_KHR_ray_cull_mask\"\n"), Values("VUID-CullMaskKHR-CullMaskKHR-06735 " "VUID-RayTmaxKHR-RayTmaxKHR-04348 " "VUID-RayTminKHR-RayTminKHR-04351 "), Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec does not allow BuiltIn", "to be used with the execution model")))); INSTANTIATE_TEST_SUITE_P( ICullMaskNotInput, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("CullMaskKHR"), Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR", "MissKHR"), Values("Output"), Values("%u32"), Values("OpCapability RayTracingKHR\nOpCapability RayCullMaskKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\nOpExtension " "\"SPV_KHR_ray_cull_mask\"\n"), Values("VUID-CullMaskKHR-CullMaskKHR-06736 " "VUID-RayTmaxKHR-RayTmaxKHR-04349 " "VUID-RayTminKHR-RayTminKHR-04352 "), Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows", "used for variables with Input storage class")))); INSTANTIATE_TEST_SUITE_P( CullMaskNotIntScalar, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("CullMaskKHR"), Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR", "MissKHR"), Values("Input"), Values("%f32", "%u32vec3"), Values("OpCapability RayTracingKHR\nOpCapability RayCullMaskKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\nOpExtension " "\"SPV_KHR_ray_cull_mask\"\n"), Values("VUID-CullMaskKHR-CullMaskKHR-06737 " "VUID-RayTmaxKHR-RayTmaxKHR-04350 " "VUID-RayTminKHR-RayTminKHR-04353 "), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit int scalar", "is not an int scalar")))); // RayTmaxKHR, RayTminKHR are all valid // in IS, AH, CH, MS shaders as input f32 scalars INSTANTIATE_TEST_SUITE_P( RayTSuccess, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("RayTmaxKHR", "RayTminKHR"), Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR", "MissKHR"), Values("Input"), Values("%f32"), Values("OpCapability RayTracingKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( RayTNotExecutionMode, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("RayTmaxKHR", "RayTminKHR"), Values("Vertex", "Fragment", "TessellationControl", "TessellationEvaluation", "Geometry", "Fragment", "GLCompute", "RayGenerationKHR", "CallableKHR"), Values("Input"), Values("%f32"), Values("OpCapability RayTracingKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values("VUID-IncomingRayFlagsKHR-IncomingRayFlagsKHR-04248 " "VUID-RayTmaxKHR-RayTmaxKHR-04348 " "VUID-RayTminKHR-RayTminKHR-04351 "), Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec does not allow BuiltIn", "to be used with the execution model")))); INSTANTIATE_TEST_SUITE_P( RayTNotInput, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("RayTmaxKHR", "RayTminKHR"), Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR", "MissKHR"), Values("Output"), Values("%f32"), Values("OpCapability RayTracingKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values("VUID-IncomingRayFlagsKHR-IncomingRayFlagsKHR-04249 " "VUID-RayTmaxKHR-RayTmaxKHR-04349 " "VUID-RayTminKHR-RayTminKHR-04352 "), Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows", "used for variables with Input storage class")))); INSTANTIATE_TEST_SUITE_P( RayTNotFloatScalar, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("RayTmaxKHR", "RayTminKHR"), Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR", "MissKHR"), Values("Input"), Values("%u32", "%f32vec3"), Values("OpCapability RayTracingKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values("VUID-IncomingRayFlagsKHR-IncomingRayFlagsKHR-04250 " "VUID-RayTmaxKHR-RayTmaxKHR-04350 " "VUID-RayTminKHR-RayTminKHR-04353 "), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit float scalar", "is not a float scalar")))); // WorldRayDirectionKHR and WorldRayOriginKHR are valid // in IS, AH, CH, MS shaders as input 32-bit float vec3 INSTANTIATE_TEST_SUITE_P( WorldRayDirectionAndOriginSuccess, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("WorldRayDirectionKHR", "WorldRayOriginKHR"), Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR", "MissKHR"), Values("Input"), Values("%f32vec3"), Values("OpCapability RayTracingKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( WorldRayDirectionAndOriginNotExecutionMode, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("WorldRayDirectionKHR", "WorldRayOriginKHR"), Values("Vertex", "Fragment", "TessellationControl", "TessellationEvaluation", "Geometry", "Fragment", "GLCompute", "RayGenerationKHR", "CallableKHR"), Values("Input"), Values("%f32vec3"), Values("OpCapability RayTracingKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values("VUID-WorldRayDirectionKHR-WorldRayDirectionKHR-04428 " "VUID-WorldRayOriginKHR-WorldRayOriginKHR-04431 "), Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec does not allow BuiltIn", "to be used with the execution model")))); INSTANTIATE_TEST_SUITE_P( WorldRayDirectionAndOriginNotInput, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("WorldRayDirectionKHR", "WorldRayOriginKHR"), Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR", "MissKHR"), Values("Output"), Values("%f32vec3"), Values("OpCapability RayTracingKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values("VUID-WorldRayDirectionKHR-WorldRayDirectionKHR-04429 " "VUID-WorldRayOriginKHR-WorldRayOriginKHR-04432 "), Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows", "used for variables with Input storage class")))); INSTANTIATE_TEST_SUITE_P( WorldRayDirectionAndOriginNotFloatVec3, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine( Values(SPV_ENV_VULKAN_1_2), Values("WorldRayDirectionKHR", "WorldRayOriginKHR"), Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR", "MissKHR"), Values("Input"), Values("%u32vec3", "%f32", "%f32vec2", "%f32vec4"), Values("OpCapability RayTracingKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values("VUID-WorldRayDirectionKHR-WorldRayDirectionKHR-04430 " "VUID-WorldRayOriginKHR-WorldRayOriginKHR-04433 "), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 3-component 32-bit float vector")))); // LaunchIdKHR and LaunchSizeKHR are valid // in RG, IS, AH, CH, MS shaders as input 32-bit ivec3 INSTANTIATE_TEST_SUITE_P( LaunchRTSuccess, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("LaunchIdKHR", "LaunchSizeKHR"), Values("RayGenerationKHR", "AnyHitKHR", "ClosestHitKHR", "IntersectionKHR", "MissKHR", "CallableKHR"), Values("Input"), Values("%u32vec3"), Values("OpCapability RayTracingKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( LaunchRTNotExecutionMode, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("LaunchIdKHR", "LaunchSizeKHR"), Values("Vertex", "Fragment", "TessellationControl", "TessellationEvaluation", "Geometry", "Fragment", "GLCompute"), Values("Input"), Values("%u32vec3"), Values("OpCapability RayTracingKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values("VUID-LaunchIdKHR-LaunchIdKHR-04266 " "VUID-LaunchSizeKHR-LaunchSizeKHR-04269 "), Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec does not allow BuiltIn", "to be used with the execution model")))); INSTANTIATE_TEST_SUITE_P( LaunchRTNotInput, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("LaunchIdKHR", "LaunchSizeKHR"), Values("RayGenerationKHR", "AnyHitKHR", "ClosestHitKHR", "IntersectionKHR", "MissKHR", "CallableKHR"), Values("Output"), Values("%u32vec3"), Values("OpCapability RayTracingKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values("VUID-LaunchIdKHR-LaunchIdKHR-04267 " "VUID-LaunchSizeKHR-LaunchSizeKHR-04270 "), Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows", "used for variables with Input storage class")))); INSTANTIATE_TEST_SUITE_P( LaunchRTNotIntVec3, ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values(SPV_ENV_VULKAN_1_2), Values("LaunchIdKHR", "LaunchSizeKHR"), Values("RayGenerationKHR", "AnyHitKHR", "ClosestHitKHR", "IntersectionKHR", "MissKHR", "CallableKHR"), Values("Input"), Values("%f32vec3", "%u32", "%u32vec2", "%u32vec4"), Values("OpCapability RayTracingKHR\n"), Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values("VUID-LaunchIdKHR-LaunchIdKHR-04268 " "VUID-LaunchSizeKHR-LaunchSizeKHR-04271 "), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 3-component 32-bit int vector")))); CodeGenerator GetArrayedVariableCodeGenerator(const char* const built_in, const char* const execution_model, const char* const storage_class, const char* const data_type) { CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator(); generator.before_types_ = "OpDecorate %built_in_var BuiltIn "; generator.before_types_ += built_in; generator.before_types_ += "\n"; std::ostringstream after_types; after_types << "%built_in_array = OpTypeArray " << data_type << " %u32_3\n"; if (InitializerRequired(storage_class)) { after_types << "%built_in_array_null = OpConstantNull %built_in_array\n"; } after_types << "%built_in_ptr = OpTypePointer " << storage_class << " %built_in_array\n"; after_types << "%built_in_var = OpVariable %built_in_ptr " << storage_class; if (InitializerRequired(storage_class)) { after_types << " %built_in_array_null"; } after_types << "\n"; generator.after_types_ = after_types.str(); EntryPoint entry_point; entry_point.name = "main"; entry_point.execution_model = execution_model; entry_point.interfaces = "%built_in_var"; // Any kind of reference would do. entry_point.body = R"( %val = OpBitcast %u32 %built_in_var )"; std::ostringstream execution_modes; if (0 == std::strcmp(execution_model, "Fragment")) { execution_modes << "OpExecutionMode %" << entry_point.name << " OriginUpperLeft\n"; if (0 == std::strcmp(built_in, "FragDepth")) { execution_modes << "OpExecutionMode %" << entry_point.name << " DepthReplacing\n"; } } if (0 == std::strcmp(execution_model, "Geometry")) { execution_modes << "OpExecutionMode %" << entry_point.name << " InputPoints\n"; execution_modes << "OpExecutionMode %" << entry_point.name << " OutputPoints\n"; } if (0 == std::strcmp(execution_model, "GLCompute")) { execution_modes << "OpExecutionMode %" << entry_point.name << " LocalSize 1 1 1\n"; } entry_point.execution_modes = execution_modes.str(); generator.entry_points_.push_back(std::move(entry_point)); return generator; } TEST_P(ValidateVulkanCombineBuiltInArrayedVariable, Variable) { const char* const built_in = std::get<0>(GetParam()); const char* const execution_model = std::get<1>(GetParam()); const char* const storage_class = std::get<2>(GetParam()); const char* const data_type = std::get<3>(GetParam()); const char* const vuid = std::get<4>(GetParam()); const TestResult& test_result = std::get<5>(GetParam()); CodeGenerator generator = GetArrayedVariableCodeGenerator( built_in, execution_model, storage_class, data_type); CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(test_result.validation_result, ValidateInstructions(SPV_ENV_VULKAN_1_0)); if (test_result.error_str) { EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str)); } if (test_result.error_str2) { EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str2)); } if (vuid) { EXPECT_THAT(getDiagnosticString(), AnyVUID(vuid)); } } INSTANTIATE_TEST_SUITE_P( PointSizeArrayedF32TessControl, ValidateVulkanCombineBuiltInArrayedVariable, Combine(Values("PointSize"), Values("TessellationControl"), Values("Input"), Values("%f32"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( PointSizeArrayedF64TessControl, ValidateVulkanCombineBuiltInArrayedVariable, Combine(Values("PointSize"), Values("TessellationControl"), Values("Input"), Values("%f64"), Values("VUID-PointSize-PointSize-04317"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit float scalar", "has bit width 64")))); INSTANTIATE_TEST_SUITE_P( PointSizeArrayedF32Vertex, ValidateVulkanCombineBuiltInArrayedVariable, Combine(Values("PointSize"), Values("Vertex"), Values("Output"), Values("%f32"), Values("VUID-PointSize-PointSize-04317"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit float scalar", "is not a float scalar")))); INSTANTIATE_TEST_SUITE_P(PositionArrayedF32Vec4TessControl, ValidateVulkanCombineBuiltInArrayedVariable, Combine(Values("Position"), Values("TessellationControl"), Values("Input"), Values("%f32vec4"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( PositionArrayedF32Vec3TessControl, ValidateVulkanCombineBuiltInArrayedVariable, Combine(Values("Position"), Values("TessellationControl"), Values("Input"), Values("%f32vec3"), Values("VUID-Position-Position-04321"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 4-component 32-bit float vector", "has 3 components")))); INSTANTIATE_TEST_SUITE_P( PositionArrayedF32Vec4Vertex, ValidateVulkanCombineBuiltInArrayedVariable, Combine(Values("Position"), Values("Vertex"), Values("Output"), Values("%f32vec4"), Values("VUID-Position-Position-04321"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 4-component 32-bit float vector", "is not a float vector")))); INSTANTIATE_TEST_SUITE_P( ClipAndCullDistanceOutputSuccess, ValidateVulkanCombineBuiltInArrayedVariable, Combine(Values("ClipDistance", "CullDistance"), Values("Geometry", "TessellationControl", "TessellationEvaluation"), Values("Output"), Values("%f32arr2", "%f32arr4"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( ClipAndCullDistanceVertexInput, ValidateVulkanCombineBuiltInArrayedVariable, Combine(Values("ClipDistance", "CullDistance"), Values("Fragment"), Values("Input"), Values("%f32arr4"), Values("VUID-ClipDistance-ClipDistance-04191 " "VUID-CullDistance-CullDistance-04200"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit float array", "components are not float scalar")))); INSTANTIATE_TEST_SUITE_P( ClipAndCullDistanceNotArray, ValidateVulkanCombineBuiltInArrayedVariable, Combine(Values("ClipDistance", "CullDistance"), Values("Geometry", "TessellationControl", "TessellationEvaluation"), Values("Input"), Values("%f32vec2", "%f32vec4"), Values("VUID-ClipDistance-ClipDistance-04191 " "VUID-CullDistance-CullDistance-04200"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit float array", "components are not float scalar")))); INSTANTIATE_TEST_SUITE_P( SMBuiltinsInputSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("SMCountNV", "SMIDNV", "WarpsPerSMNV", "WarpIDNV"), Values("Vertex", "Fragment", "TessellationControl", "TessellationEvaluation", "Geometry", "GLCompute"), Values("Input"), Values("%u32"), Values("OpCapability ShaderSMBuiltinsNV\n"), Values("OpExtension \"SPV_NV_shader_sm_builtins\"\n"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( SMBuiltinsInputMeshSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine( Values("SMCountNV", "SMIDNV", "WarpsPerSMNV", "WarpIDNV"), Values("MeshNV", "TaskNV"), Values("Input"), Values("%u32"), Values("OpCapability ShaderSMBuiltinsNV\nOpCapability MeshShadingNV\n"), Values("OpExtension \"SPV_NV_shader_sm_builtins\"\nOpExtension " "\"SPV_NV_mesh_shader\"\n"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( SMBuiltinsInputRaySuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine( Values("SMCountNV", "SMIDNV", "WarpsPerSMNV", "WarpIDNV"), Values("RayGenerationNV", "IntersectionNV", "AnyHitNV", "ClosestHitNV", "MissNV", "CallableNV"), Values("Input"), Values("%u32"), Values("OpCapability ShaderSMBuiltinsNV\nOpCapability RayTracingNV\n"), Values("OpExtension \"SPV_NV_shader_sm_builtins\"\nOpExtension " "\"SPV_NV_ray_tracing\"\n"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( SMBuiltinsNotInput, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("SMCountNV", "SMIDNV", "WarpsPerSMNV", "WarpIDNV"), Values("Vertex", "Fragment", "TessellationControl", "TessellationEvaluation", "Geometry", "GLCompute"), Values("Output"), Values("%u32"), Values("OpCapability ShaderSMBuiltinsNV\n"), Values("OpExtension \"SPV_NV_shader_sm_builtins\"\n"), Values(nullptr), Values(TestResult( SPV_ERROR_INVALID_DATA, "to be only used for variables with Input storage class", "uses storage class Output")))); INSTANTIATE_TEST_SUITE_P( SMBuiltinsNotIntScalar, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("SMCountNV", "SMIDNV", "WarpsPerSMNV", "WarpIDNV"), Values("Vertex", "Fragment", "TessellationControl", "TessellationEvaluation", "Geometry", "GLCompute"), Values("Input"), Values("%f32", "%u32vec3"), Values("OpCapability ShaderSMBuiltinsNV\n"), Values("OpExtension \"SPV_NV_shader_sm_builtins\"\n"), Values(nullptr), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit int scalar", "is not an int scalar")))); INSTANTIATE_TEST_SUITE_P( SMBuiltinsNotInt32, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("SMCountNV", "SMIDNV", "WarpsPerSMNV", "WarpIDNV"), Values("Vertex", "Fragment", "TessellationControl", "TessellationEvaluation", "Geometry", "GLCompute"), Values("Input"), Values("%u64"), Values("OpCapability ShaderSMBuiltinsNV\n"), Values("OpExtension \"SPV_NV_shader_sm_builtins\"\n"), Values(nullptr), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit int scalar", "has bit width 64")))); INSTANTIATE_TEST_SUITE_P( ArmCoreBuiltinsInputSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("CoreIDARM", "CoreCountARM", "CoreMaxIDARM", "WarpIDARM", "WarpMaxIDARM"), Values("Vertex", "Fragment", "TessellationControl", "TessellationEvaluation", "Geometry", "GLCompute"), Values("Input"), Values("%u32"), Values("OpCapability CoreBuiltinsARM\n"), Values("OpExtension \"SPV_ARM_core_builtins\"\n"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( ArmCoreBuiltinsNotInput, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("CoreIDARM", "CoreCountARM", "CoreMaxIDARM", "WarpIDARM", "WarpMaxIDARM"), Values("Vertex", "Fragment", "TessellationControl", "TessellationEvaluation", "Geometry", "GLCompute"), Values("Output"), Values("%u32"), Values("OpCapability CoreBuiltinsARM\n"), Values("OpExtension \"SPV_ARM_core_builtins\"\n"), Values(nullptr), Values(TestResult( SPV_ERROR_INVALID_DATA, "to be only used for variables with Input storage class", "uses storage class Output")))); INSTANTIATE_TEST_SUITE_P( ArmCoreBuiltinsNotIntScalar, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("CoreIDARM", "CoreCountARM", "CoreMaxIDARM", "WarpIDARM", "WarpMaxIDARM"), Values("Vertex", "Fragment", "TessellationControl", "TessellationEvaluation", "Geometry", "GLCompute"), Values("Input"), Values("%f32", "%u32vec3"), Values("OpCapability CoreBuiltinsARM\n"), Values("OpExtension \"SPV_ARM_core_builtins\"\n"), Values(nullptr), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit int scalar", "is not an int scalar")))); INSTANTIATE_TEST_SUITE_P( ArmCoreBuiltinsNotInt32, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("CoreIDARM", "CoreCountARM", "CoreMaxIDARM", "WarpIDARM", "WarpMaxIDARM"), Values("Vertex", "Fragment", "TessellationControl", "TessellationEvaluation", "Geometry", "GLCompute"), Values("Input"), Values("%u64"), Values("OpCapability CoreBuiltinsARM\n"), Values("OpExtension \"SPV_ARM_core_builtins\"\n"), Values(nullptr), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit int scalar", "has bit width 64")))); CodeGenerator GetWorkgroupSizeSuccessGenerator() { CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator(); generator.before_types_ = R"( OpDecorate %workgroup_size BuiltIn WorkgroupSize )"; generator.after_types_ = R"( %workgroup_size = OpConstantComposite %u32vec3 %u32_1 %u32_1 %u32_1 )"; EntryPoint entry_point; entry_point.name = "main"; entry_point.execution_model = "GLCompute"; entry_point.body = R"( %copy = OpCopyObject %u32vec3 %workgroup_size )"; generator.entry_points_.push_back(std::move(entry_point)); return generator; } TEST_F(ValidateBuiltIns, VulkanWorkgroupSizeSuccess) { CodeGenerator generator = GetWorkgroupSizeSuccessGenerator(); CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } CodeGenerator GetWorkgroupSizeFragmentGenerator() { CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator(); generator.before_types_ = R"( OpDecorate %workgroup_size BuiltIn WorkgroupSize )"; generator.after_types_ = R"( %workgroup_size = OpConstantComposite %u32vec3 %u32_1 %u32_1 %u32_1 )"; EntryPoint entry_point; entry_point.name = "main"; entry_point.execution_model = "Fragment"; entry_point.execution_modes = "OpExecutionMode %main OriginUpperLeft"; entry_point.body = R"( %copy = OpCopyObject %u32vec3 %workgroup_size )"; generator.entry_points_.push_back(std::move(entry_point)); return generator; } TEST_F(ValidateBuiltIns, VulkanWorkgroupSizeFragment) { CodeGenerator generator = GetWorkgroupSizeFragmentGenerator(); CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Vulkan spec allows BuiltIn WorkgroupSize to be used " "only with GLCompute, MeshNV, TaskNV, MeshEXT or " "TaskEXT execution model")); EXPECT_THAT(getDiagnosticString(), HasSubstr("is referencing ID <2> (OpConstantComposite) which is " "decorated with BuiltIn WorkgroupSize in function <1> " "called with execution model Fragment")); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-WorkgroupSize-WorkgroupSize-04425 " "VUID-WorkgroupSize-WorkgroupSize-04427")); } TEST_F(ValidateBuiltIns, WorkgroupSizeNotConstant) { CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator(); generator.before_types_ = R"( OpDecorate %copy BuiltIn WorkgroupSize )"; generator.after_types_ = R"( %workgroup_size = OpConstantComposite %u32vec3 %u32_1 %u32_1 %u32_1 )"; EntryPoint entry_point; entry_point.name = "main"; entry_point.execution_model = "GLCompute"; entry_point.body = R"( %copy = OpCopyObject %u32vec3 %workgroup_size )"; generator.entry_points_.push_back(std::move(entry_point)); CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("BuiltIns can only target variables, structure " "members or constants")); } CodeGenerator GetWorkgroupSizeNotVectorGenerator() { CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator(); generator.before_types_ = R"( OpDecorate %workgroup_size BuiltIn WorkgroupSize )"; generator.after_types_ = R"( %workgroup_size = OpConstant %u32 16 )"; EntryPoint entry_point; entry_point.name = "main"; entry_point.execution_model = "GLCompute"; entry_point.body = R"( %copy = OpCopyObject %u32 %workgroup_size )"; generator.entry_points_.push_back(std::move(entry_point)); return generator; } TEST_F(ValidateBuiltIns, VulkanWorkgroupSizeNotVector) { CodeGenerator generator = GetWorkgroupSizeNotVectorGenerator(); CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("According to the Vulkan spec BuiltIn WorkgroupSize " "variable needs to be a 3-component 32-bit int vector. " "ID <2> (OpConstant) is not an int vector.")); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-WorkgroupSize-WorkgroupSize-04427")); } CodeGenerator GetWorkgroupSizeNotIntVectorGenerator() { CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator(); generator.before_types_ = R"( OpDecorate %workgroup_size BuiltIn WorkgroupSize )"; generator.after_types_ = R"( %workgroup_size = OpConstantComposite %f32vec3 %f32_1 %f32_1 %f32_1 )"; EntryPoint entry_point; entry_point.name = "main"; entry_point.execution_model = "GLCompute"; entry_point.body = R"( %copy = OpCopyObject %f32vec3 %workgroup_size )"; generator.entry_points_.push_back(std::move(entry_point)); return generator; } TEST_F(ValidateBuiltIns, VulkanWorkgroupSizeNotIntVector) { CodeGenerator generator = GetWorkgroupSizeNotIntVectorGenerator(); CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("According to the Vulkan spec BuiltIn WorkgroupSize " "variable needs to be a 3-component 32-bit int vector. " "ID <2> (OpConstantComposite) is not an int vector.")); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-WorkgroupSize-WorkgroupSize-04427")); } CodeGenerator GetWorkgroupSizeNotVec3Generator() { CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator(); generator.before_types_ = R"( OpDecorate %workgroup_size BuiltIn WorkgroupSize )"; generator.after_types_ = R"( %workgroup_size = OpConstantComposite %u32vec2 %u32_1 %u32_1 )"; EntryPoint entry_point; entry_point.name = "main"; entry_point.execution_model = "GLCompute"; entry_point.body = R"( %copy = OpCopyObject %u32vec2 %workgroup_size )"; generator.entry_points_.push_back(std::move(entry_point)); return generator; } TEST_F(ValidateBuiltIns, VulkanWorkgroupSizeNotVec3) { CodeGenerator generator = GetWorkgroupSizeNotVec3Generator(); CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("According to the Vulkan spec BuiltIn WorkgroupSize " "variable needs to be a 3-component 32-bit int vector. " "ID <2> (OpConstantComposite) has 2 components.")); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-WorkgroupSize-WorkgroupSize-04427")); } TEST_F(ValidateBuiltIns, WorkgroupSizeNotInt32Vec) { CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator(); generator.before_types_ = R"( OpDecorate %workgroup_size BuiltIn WorkgroupSize )"; generator.after_types_ = R"( %workgroup_size = OpConstantComposite %u64vec3 %u64_1 %u64_1 %u64_1 )"; EntryPoint entry_point; entry_point.name = "main"; entry_point.execution_model = "GLCompute"; entry_point.body = R"( %copy = OpCopyObject %u64vec3 %workgroup_size )"; generator.entry_points_.push_back(std::move(entry_point)); CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr("According to the Vulkan spec BuiltIn WorkgroupSize variable " "needs to be a 3-component 32-bit int vector. ID <2> " "(OpConstantComposite) has components with bit width 64.")); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-WorkgroupSize-WorkgroupSize-04427")); } TEST_F(ValidateBuiltIns, WorkgroupSizePrivateVar) { CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator(); generator.before_types_ = R"( OpDecorate %workgroup_size BuiltIn WorkgroupSize )"; generator.after_types_ = R"( %workgroup_size = OpConstantComposite %u32vec3 %u32_1 %u32_1 %u32_1 %private_ptr_u32vec3 = OpTypePointer Private %u32vec3 %var = OpVariable %private_ptr_u32vec3 Private %workgroup_size )"; EntryPoint entry_point; entry_point.name = "main"; entry_point.execution_model = "GLCompute"; entry_point.body = R"( )"; generator.entry_points_.push_back(std::move(entry_point)); CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateBuiltIns, GeometryPositionInOutSuccess) { CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator(); generator.before_types_ = R"( OpDecorate %input_type Block OpMemberDecorate %input_type 0 BuiltIn Position OpDecorate %output_type Block OpMemberDecorate %output_type 0 BuiltIn Position )"; generator.after_types_ = R"( %input_type = OpTypeStruct %f32vec4 %arrayed_input_type = OpTypeArray %input_type %u32_3 %input_ptr = OpTypePointer Input %arrayed_input_type %input = OpVariable %input_ptr Input %input_f32vec4_ptr = OpTypePointer Input %f32vec4 %output_type = OpTypeStruct %f32vec4 %output_ptr = OpTypePointer Output %output_type %output = OpVariable %output_ptr Output %output_f32vec4_ptr = OpTypePointer Output %f32vec4 )"; EntryPoint entry_point; entry_point.name = "main"; entry_point.execution_model = "Geometry"; entry_point.interfaces = "%input %output"; entry_point.body = R"( %input_pos = OpAccessChain %input_f32vec4_ptr %input %u32_0 %u32_0 %output_pos = OpAccessChain %output_f32vec4_ptr %output %u32_0 %pos = OpLoad %f32vec4 %input_pos OpStore %output_pos %pos )"; generator.entry_points_.push_back(std::move(entry_point)); generator.entry_points_[0].execution_modes = "OpExecutionMode %main InputPoints\nOpExecutionMode %main OutputPoints\n"; CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateBuiltIns, WorkgroupIdNotVec3) { CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator(); generator.before_types_ = R"( OpDecorate %workgroup_size BuiltIn WorkgroupSize OpDecorate %workgroup_id BuiltIn WorkgroupId )"; generator.after_types_ = R"( %workgroup_size = OpConstantComposite %u32vec3 %u32_1 %u32_1 %u32_1 %input_ptr = OpTypePointer Input %u32vec2 %workgroup_id = OpVariable %input_ptr Input )"; EntryPoint entry_point; entry_point.name = "main"; entry_point.execution_model = "GLCompute"; entry_point.interfaces = "%workgroup_id"; entry_point.body = R"( %copy_size = OpCopyObject %u32vec3 %workgroup_size %load_id = OpLoad %u32vec2 %workgroup_id )"; generator.entry_points_.push_back(std::move(entry_point)); CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("According to the Vulkan spec BuiltIn WorkgroupId " "variable needs to be a 3-component 32-bit int vector. " "ID <2> (OpVariable) has 2 components.")); } TEST_F(ValidateBuiltIns, TwoBuiltInsFirstFails) { CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator(); generator.before_types_ = R"( OpDecorate %input_type Block OpDecorate %output_type Block OpMemberDecorate %input_type 0 BuiltIn FragCoord OpMemberDecorate %output_type 0 BuiltIn Position )"; generator.after_types_ = R"( %input_type = OpTypeStruct %f32vec4 %input_ptr = OpTypePointer Input %input_type %input = OpVariable %input_ptr Input %input_f32vec4_ptr = OpTypePointer Input %f32vec4 %output_type = OpTypeStruct %f32vec4 %output_ptr = OpTypePointer Output %output_type %output = OpVariable %output_ptr Output %output_f32vec4_ptr = OpTypePointer Output %f32vec4 )"; EntryPoint entry_point; entry_point.name = "main"; entry_point.execution_model = "Geometry"; entry_point.interfaces = "%input %output"; entry_point.body = R"( %input_pos = OpAccessChain %input_f32vec4_ptr %input %u32_0 %output_pos = OpAccessChain %output_f32vec4_ptr %output %u32_0 %pos = OpLoad %f32vec4 %input_pos OpStore %output_pos %pos )"; generator.entry_points_.push_back(std::move(entry_point)); generator.entry_points_[0].execution_modes = "OpExecutionMode %main InputPoints\nOpExecutionMode %main OutputPoints\n"; CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Vulkan spec allows BuiltIn FragCoord to be used only " "with Fragment execution model")); } TEST_F(ValidateBuiltIns, TwoBuiltInsSecondFails) { CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator(); generator.before_types_ = R"( OpDecorate %input_type Block OpDecorate %output_type Block OpMemberDecorate %input_type 0 BuiltIn Position OpMemberDecorate %output_type 0 BuiltIn FragCoord )"; generator.after_types_ = R"( %input_type = OpTypeStruct %f32vec4 %input_ptr = OpTypePointer Input %input_type %input = OpVariable %input_ptr Input %input_f32vec4_ptr = OpTypePointer Input %f32vec4 %output_type = OpTypeStruct %f32vec4 %output_ptr = OpTypePointer Output %output_type %output = OpVariable %output_ptr Output %output_f32vec4_ptr = OpTypePointer Output %f32vec4 )"; EntryPoint entry_point; entry_point.name = "main"; entry_point.execution_model = "Geometry"; entry_point.interfaces = "%input %output"; entry_point.body = R"( %input_pos = OpAccessChain %input_f32vec4_ptr %input %u32_0 %output_pos = OpAccessChain %output_f32vec4_ptr %output %u32_0 %pos = OpLoad %f32vec4 %input_pos OpStore %output_pos %pos )"; generator.entry_points_.push_back(std::move(entry_point)); generator.entry_points_[0].execution_modes = "OpExecutionMode %main InputPoints\nOpExecutionMode %main OutputPoints\n"; CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Vulkan spec allows BuiltIn FragCoord to be only used " "for variables with Input storage class")); } TEST_F(ValidateBuiltIns, VertexPositionVariableSuccess) { CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator(); generator.before_types_ = R"( OpDecorate %position BuiltIn Position )"; generator.after_types_ = R"( %f32vec4_ptr_output = OpTypePointer Output %f32vec4 %position = OpVariable %f32vec4_ptr_output Output )"; EntryPoint entry_point; entry_point.name = "main"; entry_point.execution_model = "Vertex"; entry_point.interfaces = "%position"; entry_point.body = R"( OpStore %position %f32vec4_0123 )"; generator.entry_points_.push_back(std::move(entry_point)); CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateBuiltIns, FragmentPositionTwoEntryPoints) { CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator(); generator.before_types_ = R"( OpDecorate %output_type Block OpMemberDecorate %output_type 0 BuiltIn Position )"; generator.after_types_ = R"( %output_type = OpTypeStruct %f32vec4 %output_ptr = OpTypePointer Output %output_type %output = OpVariable %output_ptr Output %output_f32vec4_ptr = OpTypePointer Output %f32vec4 )"; EntryPoint entry_point; entry_point.name = "vmain"; entry_point.execution_model = "Vertex"; entry_point.interfaces = "%output"; entry_point.body = R"( %val1 = OpFunctionCall %void %foo )"; generator.entry_points_.push_back(std::move(entry_point)); entry_point.name = "fmain"; entry_point.execution_model = "Fragment"; entry_point.interfaces = "%output"; entry_point.execution_modes = "OpExecutionMode %fmain OriginUpperLeft"; entry_point.body = R"( %val2 = OpFunctionCall %void %foo )"; generator.entry_points_.push_back(std::move(entry_point)); generator.add_at_the_end_ = R"( %foo = OpFunction %void None %func %foo_entry = OpLabel %position = OpAccessChain %output_f32vec4_ptr %output %u32_0 OpStore %position %f32vec4_0123 OpReturn OpFunctionEnd )"; CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Vulkan spec allows BuiltIn Position to be used only " "with Vertex, TessellationControl, " "TessellationEvaluation or Geometry execution models")); EXPECT_THAT(getDiagnosticString(), HasSubstr("called with execution model Fragment")); } CodeGenerator GetNoDepthReplacingGenerator() { CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator(); generator.before_types_ = R"( OpDecorate %output_type Block OpMemberDecorate %output_type 0 BuiltIn FragDepth )"; generator.after_types_ = R"( %output_type = OpTypeStruct %f32 %output_null = OpConstantNull %output_type %output_ptr = OpTypePointer Output %output_type %output = OpVariable %output_ptr Output %output_null %output_f32_ptr = OpTypePointer Output %f32 )"; EntryPoint entry_point; entry_point.name = "main"; entry_point.execution_model = "Fragment"; entry_point.interfaces = "%output"; entry_point.execution_modes = "OpExecutionMode %main OriginUpperLeft"; entry_point.body = R"( %val2 = OpFunctionCall %void %foo )"; generator.entry_points_.push_back(std::move(entry_point)); const std::string function_body = R"( %foo = OpFunction %void None %func %foo_entry = OpLabel %frag_depth = OpAccessChain %output_f32_ptr %output %u32_0 OpStore %frag_depth %f32_1 OpReturn OpFunctionEnd )"; generator.add_at_the_end_ = function_body; return generator; } TEST_F(ValidateBuiltIns, VulkanFragmentFragDepthNoDepthReplacing) { CodeGenerator generator = GetNoDepthReplacingGenerator(); CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Vulkan spec requires DepthReplacing execution mode to " "be declared when using BuiltIn FragDepth")); EXPECT_THAT(getDiagnosticString(), HasSubstr("VUID-FragDepth-FragDepth-04216")); } CodeGenerator GetOneMainHasDepthReplacingOtherHasntGenerator() { CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator(); generator.before_types_ = R"( OpDecorate %output_type Block OpMemberDecorate %output_type 0 BuiltIn FragDepth )"; generator.after_types_ = R"( %output_type = OpTypeStruct %f32 %output_null = OpConstantNull %output_type %output_ptr = OpTypePointer Output %output_type %output = OpVariable %output_ptr Output %output_null %output_f32_ptr = OpTypePointer Output %f32 )"; EntryPoint entry_point; entry_point.name = "main_d_r"; entry_point.execution_model = "Fragment"; entry_point.interfaces = "%output"; entry_point.execution_modes = "OpExecutionMode %main_d_r OriginUpperLeft\n" "OpExecutionMode %main_d_r DepthReplacing"; entry_point.body = R"( %val2 = OpFunctionCall %void %foo )"; generator.entry_points_.push_back(std::move(entry_point)); entry_point.name = "main_no_d_r"; entry_point.execution_model = "Fragment"; entry_point.interfaces = "%output"; entry_point.execution_modes = "OpExecutionMode %main_no_d_r OriginUpperLeft"; entry_point.body = R"( %val3 = OpFunctionCall %void %foo )"; generator.entry_points_.push_back(std::move(entry_point)); const std::string function_body = R"( %foo = OpFunction %void None %func %foo_entry = OpLabel %frag_depth = OpAccessChain %output_f32_ptr %output %u32_0 OpStore %frag_depth %f32_1 OpReturn OpFunctionEnd )"; generator.add_at_the_end_ = function_body; return generator; } TEST_F(ValidateBuiltIns, VulkanFragmentFragDepthOneMainHasDepthReplacingOtherHasnt) { CodeGenerator generator = GetOneMainHasDepthReplacingOtherHasntGenerator(); CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Vulkan spec requires DepthReplacing execution mode to " "be declared when using BuiltIn FragDepth")); EXPECT_THAT(getDiagnosticString(), HasSubstr("VUID-FragDepth-FragDepth-04216")); } TEST_F(ValidateBuiltIns, AllowInstanceIdWithIntersectionShader) { CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator(); generator.capabilities_ += R"( OpCapability RayTracingNV )"; generator.extensions_ = R"( OpExtension "SPV_NV_ray_tracing" )"; generator.before_types_ = R"( OpDecorate %input_type Block OpMemberDecorate %input_type 0 BuiltIn InstanceId )"; generator.after_types_ = R"( %input_type = OpTypeStruct %u32 %input_ptr = OpTypePointer Input %input_type %input = OpVariable %input_ptr Input )"; EntryPoint entry_point; entry_point.name = "main_d_r"; entry_point.execution_model = "IntersectionNV"; entry_point.interfaces = "%input"; entry_point.body = R"( %val2 = OpFunctionCall %void %foo )"; generator.entry_points_.push_back(std::move(entry_point)); generator.add_at_the_end_ = R"( %foo = OpFunction %void None %func %foo_entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0); EXPECT_THAT(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateBuiltIns, ValidBuiltinsForMeshShader) { CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator(); generator.capabilities_ += R"( OpCapability MeshShadingNV )"; generator.extensions_ = R"( OpExtension "SPV_NV_mesh_shader" )"; generator.before_types_ = R"( OpDecorate %gl_PrimitiveID BuiltIn PrimitiveId OpDecorate %gl_PrimitiveID PerPrimitiveNV OpDecorate %gl_Layer BuiltIn Layer OpDecorate %gl_Layer PerPrimitiveNV OpDecorate %gl_ViewportIndex BuiltIn ViewportIndex OpDecorate %gl_ViewportIndex PerPrimitiveNV )"; generator.after_types_ = R"( %u32_81 = OpConstant %u32 81 %_arr_int_uint_81 = OpTypeArray %i32 %u32_81 %_ptr_Output__arr_int_uint_81 = OpTypePointer Output %_arr_int_uint_81 %gl_PrimitiveID = OpVariable %_ptr_Output__arr_int_uint_81 Output %gl_Layer = OpVariable %_ptr_Output__arr_int_uint_81 Output %gl_ViewportIndex = OpVariable %_ptr_Output__arr_int_uint_81 Output )"; EntryPoint entry_point; entry_point.name = "main_d_r"; entry_point.execution_model = "MeshNV"; entry_point.interfaces = "%gl_PrimitiveID %gl_Layer %gl_ViewportIndex"; generator.entry_points_.push_back(std::move(entry_point)); CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_1); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_1)); } TEST_F(ValidateBuiltIns, InvalidBuiltinsForMeshShader) { CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator(); generator.capabilities_ += R"( OpCapability MeshShadingNV )"; generator.extensions_ = R"( OpExtension "SPV_NV_mesh_shader" )"; generator.before_types_ = R"( OpDecorate %gl_PrimitiveID BuiltIn PrimitiveId OpDecorate %gl_PrimitiveID PerPrimitiveNV OpDecorate %gl_Layer BuiltIn Layer OpDecorate %gl_Layer PerPrimitiveNV OpDecorate %gl_ViewportIndex BuiltIn ViewportIndex OpDecorate %gl_ViewportIndex PerPrimitiveNV )"; generator.after_types_ = R"( %u32_81 = OpConstant %u32 81 %_arr_float_uint_81 = OpTypeArray %f32 %u32_81 %_ptr_Output__arr_float_uint_81 = OpTypePointer Output %_arr_float_uint_81 %gl_PrimitiveID = OpVariable %_ptr_Output__arr_float_uint_81 Output %gl_Layer = OpVariable %_ptr_Output__arr_float_uint_81 Output %gl_ViewportIndex = OpVariable %_ptr_Output__arr_float_uint_81 Output )"; EntryPoint entry_point; entry_point.name = "main_d_r"; entry_point.execution_model = "MeshNV"; entry_point.interfaces = "%gl_PrimitiveID %gl_Layer %gl_ViewportIndex"; generator.entry_points_.push_back(std::move(entry_point)); CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_1); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), HasSubstr("needs to be a 32-bit int scalar")); EXPECT_THAT(getDiagnosticString(), HasSubstr("is not an int scalar")); } TEST_P(ValidateVulkanSubgroupBuiltIns, InMain) { const char* const built_in = std::get<0>(GetParam()); const char* const execution_model = std::get<1>(GetParam()); const char* const storage_class = std::get<2>(GetParam()); const char* const data_type = std::get<3>(GetParam()); const char* const vuid = std::get<4>(GetParam()); const TestResult& test_result = std::get<5>(GetParam()); CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator(); generator.capabilities_ += R"( OpCapability GroupNonUniformBallot )"; generator.before_types_ = "OpDecorate %built_in_var BuiltIn "; generator.before_types_ += built_in; generator.before_types_ += "\n"; std::ostringstream after_types; after_types << "%built_in_ptr = OpTypePointer " << storage_class << " " << data_type << "\n"; after_types << "%built_in_var = OpVariable %built_in_ptr " << storage_class; after_types << "\n"; generator.after_types_ = after_types.str(); EntryPoint entry_point; entry_point.name = "main"; entry_point.execution_model = execution_model; if (strncmp(storage_class, "Input", 5) == 0 || strncmp(storage_class, "Output", 6) == 0) { entry_point.interfaces = "%built_in_var"; } entry_point.body = std::string("%ld = OpLoad ") + data_type + " %built_in_var\n"; std::ostringstream execution_modes; if (0 == std::strcmp(execution_model, "Fragment")) { execution_modes << "OpExecutionMode %" << entry_point.name << " OriginUpperLeft\n"; if (0 == std::strcmp(built_in, "FragDepth")) { execution_modes << "OpExecutionMode %" << entry_point.name << " DepthReplacing\n"; } } if (0 == std::strcmp(execution_model, "Geometry")) { execution_modes << "OpExecutionMode %" << entry_point.name << " InputPoints\n"; execution_modes << "OpExecutionMode %" << entry_point.name << " OutputPoints\n"; } if (0 == std::strcmp(execution_model, "GLCompute")) { execution_modes << "OpExecutionMode %" << entry_point.name << " LocalSize 1 1 1\n"; } entry_point.execution_modes = execution_modes.str(); generator.entry_points_.push_back(std::move(entry_point)); CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_1); ASSERT_EQ(test_result.validation_result, ValidateInstructions(SPV_ENV_VULKAN_1_1)); if (test_result.error_str) { EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str)); } if (test_result.error_str2) { EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str2)); } if (vuid) { EXPECT_THAT(getDiagnosticString(), AnyVUID(vuid)); } } INSTANTIATE_TEST_SUITE_P( SubgroupMaskNotVec4, ValidateVulkanSubgroupBuiltIns, Combine(Values("SubgroupEqMask", "SubgroupGeMask", "SubgroupGtMask", "SubgroupLeMask", "SubgroupLtMask"), Values("GLCompute"), Values("Input"), Values("%u32vec3"), Values("VUID-SubgroupEqMask-SubgroupEqMask-04371 " "VUID-SubgroupGeMask-SubgroupGeMask-04373 " "VUID-SubgroupGtMask-SubgroupGtMask-04375 " "VUID-SubgroupLeMask-SubgroupLeMask-04377 " "VUID-SubgroupLtMask-SubgroupLtMask-04379"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 4-component 32-bit int vector")))); INSTANTIATE_TEST_SUITE_P( SubgroupMaskNotU32, ValidateVulkanSubgroupBuiltIns, Combine(Values("SubgroupEqMask", "SubgroupGeMask", "SubgroupGtMask", "SubgroupLeMask", "SubgroupLtMask"), Values("GLCompute"), Values("Input"), Values("%f32vec4"), Values("VUID-SubgroupEqMask-SubgroupEqMask-04371 " "VUID-SubgroupGeMask-SubgroupGeMask-04373 " "VUID-SubgroupGtMask-SubgroupGtMask-04375 " "VUID-SubgroupLeMask-SubgroupLeMask-04377 " "VUID-SubgroupLtMask-SubgroupLtMask-04379"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 4-component 32-bit int vector")))); INSTANTIATE_TEST_SUITE_P( SubgroupMaskNotInput, ValidateVulkanSubgroupBuiltIns, Combine(Values("SubgroupEqMask", "SubgroupGeMask", "SubgroupGtMask", "SubgroupLeMask", "SubgroupLtMask"), Values("GLCompute"), Values("Output", "Workgroup", "Private"), Values("%u32vec4"), Values("VUID-SubgroupEqMask-SubgroupEqMask-04370 " "VUID-SubgroupGeMask-SubgroupGeMask-04372 " "VUID-SubgroupGtMask-SubgroupGtMask-04374 " "VUID-SubgroupLeMask-SubgroupLeMask-04376 " "VUID-SubgroupLtMask-SubgroupLtMask-04378"), Values(TestResult( SPV_ERROR_INVALID_DATA, "to be only used for variables with Input storage class")))); INSTANTIATE_TEST_SUITE_P(SubgroupMaskOk, ValidateVulkanSubgroupBuiltIns, Combine(Values("SubgroupEqMask", "SubgroupGeMask", "SubgroupGtMask", "SubgroupLeMask", "SubgroupLtMask"), Values("GLCompute"), Values("Input"), Values("%u32vec4"), Values(nullptr), Values(TestResult(SPV_SUCCESS, "")))); TEST_F(ValidateBuiltIns, SubgroupMaskMemberDecorate) { const std::string text = R"( OpCapability Shader OpCapability GroupNonUniformBallot OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %foo "foo" OpExecutionMode %foo LocalSize 1 1 1 OpDecorate %struct Block OpMemberDecorate %struct 0 BuiltIn SubgroupEqMask %void = OpTypeVoid %int = OpTypeInt 32 0 %struct = OpTypeStruct %int %void_fn = OpTypeFunction %void %foo = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "BuiltIn SubgroupEqMask cannot be used as a member decoration")); } INSTANTIATE_TEST_SUITE_P( SubgroupInvocationIdAndSizeNotU32, ValidateVulkanSubgroupBuiltIns, Combine( Values("SubgroupLocalInvocationId", "SubgroupSize"), Values("GLCompute"), Values("Input"), Values("%f32"), Values("VUID-SubgroupLocalInvocationId-SubgroupLocalInvocationId-04381 " "VUID-SubgroupSize-SubgroupSize-04383"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit int")))); INSTANTIATE_TEST_SUITE_P( SubgroupInvocationIdAndSizeNotInput, ValidateVulkanSubgroupBuiltIns, Combine( Values("SubgroupLocalInvocationId", "SubgroupSize"), Values("GLCompute"), Values("Output", "Workgroup", "Private"), Values("%u32"), Values("VUID-SubgroupLocalInvocationId-SubgroupLocalInvocationId-04380 " "VUID-SubgroupSize-SubgroupSize-04382"), Values(TestResult( SPV_ERROR_INVALID_DATA, "to be only used for variables with Input storage class")))); INSTANTIATE_TEST_SUITE_P( SubgroupInvocationIdAndSizeOk, ValidateVulkanSubgroupBuiltIns, Combine(Values("SubgroupLocalInvocationId", "SubgroupSize"), Values("GLCompute"), Values("Input"), Values("%u32"), Values(nullptr), Values(TestResult(SPV_SUCCESS, "")))); TEST_F(ValidateBuiltIns, SubgroupSizeMemberDecorate) { const std::string text = R"( OpCapability Shader OpCapability GroupNonUniform OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %foo "foo" OpExecutionMode %foo LocalSize 1 1 1 OpDecorate %struct Block OpMemberDecorate %struct 0 BuiltIn SubgroupSize %void = OpTypeVoid %int = OpTypeInt 32 0 %struct = OpTypeStruct %int %void_fn = OpTypeFunction %void %foo = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT( getDiagnosticString(), HasSubstr("BuiltIn SubgroupSize cannot be used as a member decoration")); } INSTANTIATE_TEST_SUITE_P( SubgroupNumAndIdNotCompute, ValidateVulkanSubgroupBuiltIns, Combine(Values("SubgroupId", "NumSubgroups"), Values("Vertex"), Values("Input"), Values("%u32"), Values("VUID-SubgroupId-SubgroupId-04367 " "VUID-NumSubgroups-NumSubgroups-04293"), Values(TestResult(SPV_ERROR_INVALID_DATA, "to be used only with GLCompute, MeshNV, " "TaskNV, MeshEXT or TaskEXT execution model")))); INSTANTIATE_TEST_SUITE_P( SubgroupNumAndIdNotU32, ValidateVulkanSubgroupBuiltIns, Combine(Values("SubgroupId", "NumSubgroups"), Values("GLCompute"), Values("Input"), Values("%f32"), Values("VUID-SubgroupId-SubgroupId-04369 " "VUID-NumSubgroups-NumSubgroups-04295"), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 32-bit int")))); INSTANTIATE_TEST_SUITE_P( SubgroupNumAndIdNotInput, ValidateVulkanSubgroupBuiltIns, Combine(Values("SubgroupId", "NumSubgroups"), Values("GLCompute"), Values("Output", "Workgroup", "Private"), Values("%u32"), Values("VUID-SubgroupId-SubgroupId-04368 " "VUID-NumSubgroups-NumSubgroups-04294"), Values(TestResult( SPV_ERROR_INVALID_DATA, "to be only used for variables with Input storage class")))); INSTANTIATE_TEST_SUITE_P(SubgroupNumAndIdOk, ValidateVulkanSubgroupBuiltIns, Combine(Values("SubgroupId", "NumSubgroups"), Values("GLCompute"), Values("Input"), Values("%u32"), Values(nullptr), Values(TestResult(SPV_SUCCESS, "")))); TEST_F(ValidateBuiltIns, SubgroupIdMemberDecorate) { const std::string text = R"( OpCapability Shader OpCapability GroupNonUniform OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %foo "foo" OpExecutionMode %foo LocalSize 1 1 1 OpDecorate %struct Block OpMemberDecorate %struct 0 BuiltIn SubgroupId %void = OpTypeVoid %int = OpTypeInt 32 0 %struct = OpTypeStruct %int %void_fn = OpTypeFunction %void %foo = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT( getDiagnosticString(), HasSubstr("BuiltIn SubgroupId cannot be used as a member decoration")); } TEST_F(ValidateBuiltIns, TargetIsType) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %void BuiltIn Position %void = OpTypeVoid )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("BuiltIns can only target variables, structure members " "or constants")); } TEST_F(ValidateBuiltIns, TargetIsVariable) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %wg_var BuiltIn Position %int = OpTypeInt 32 0 %int_wg_ptr = OpTypePointer Workgroup %int %wg_var = OpVariable %int_wg_ptr Workgroup )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } INSTANTIATE_TEST_SUITE_P( PrimitiveShadingRateOutputSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("PrimitiveShadingRateKHR"), Values("Vertex", "Geometry"), Values("Output"), Values("%u32"), Values("OpCapability FragmentShadingRateKHR\n"), Values("OpExtension \"SPV_KHR_fragment_shading_rate\"\n"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( PrimitiveShadingRateMeshOutputSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("PrimitiveShadingRateKHR"), Values("MeshNV"), Values("Output"), Values("%u32"), Values("OpCapability FragmentShadingRateKHR\nOpCapability " "MeshShadingNV\n"), Values("OpExtension \"SPV_KHR_fragment_shading_rate\"\nOpExtension " "\"SPV_NV_mesh_shader\"\n"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( PrimitiveShadingRateInvalidExecutionModel, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine( Values("PrimitiveShadingRateKHR"), Values("Fragment"), Values("Output"), Values("%u32"), Values("OpCapability FragmentShadingRateKHR\n"), Values("OpExtension \"SPV_KHR_fragment_shading_rate\"\n"), Values("VUID-PrimitiveShadingRateKHR-PrimitiveShadingRateKHR-04484 "), Values(TestResult( SPV_ERROR_INVALID_DATA, "Vulkan spec allows BuiltIn PrimitiveShadingRateKHR to be used " "only with Vertex, Geometry, MeshNV or MeshEXT execution " "models.")))); INSTANTIATE_TEST_SUITE_P( PrimitiveShadingRateInvalidStorageClass, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine( Values("PrimitiveShadingRateKHR"), Values("Vertex"), Values("Input"), Values("%u32"), Values("OpCapability FragmentShadingRateKHR\n"), Values("OpExtension \"SPV_KHR_fragment_shading_rate\"\n"), Values("VUID-PrimitiveShadingRateKHR-PrimitiveShadingRateKHR-04485 "), Values(TestResult( SPV_ERROR_INVALID_DATA, "Vulkan spec allows BuiltIn PrimitiveShadingRateKHR to be only " "used for variables with Output storage class.")))); INSTANTIATE_TEST_SUITE_P( PrimitiveShadingRateInvalidType, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine( Values("PrimitiveShadingRateKHR"), Values("Vertex"), Values("Output"), Values("%f32"), Values("OpCapability FragmentShadingRateKHR\n"), Values("OpExtension \"SPV_KHR_fragment_shading_rate\"\n"), Values("VUID-PrimitiveShadingRateKHR-PrimitiveShadingRateKHR-04486 "), Values(TestResult( SPV_ERROR_INVALID_DATA, "According to the Vulkan spec BuiltIn PrimitiveShadingRateKHR " "variable needs to be a 32-bit int scalar.")))); INSTANTIATE_TEST_SUITE_P( ShadingRateInputSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("ShadingRateKHR"), Values("Fragment"), Values("Input"), Values("%u32"), Values("OpCapability FragmentShadingRateKHR\n"), Values("OpExtension \"SPV_KHR_fragment_shading_rate\"\n"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( ShadingRateInvalidExecutionModel, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("ShadingRateKHR"), Values("Vertex"), Values("Input"), Values("%u32"), Values("OpCapability FragmentShadingRateKHR\n"), Values("OpExtension \"SPV_KHR_fragment_shading_rate\"\n"), Values("VUID-ShadingRateKHR-ShadingRateKHR-04490 "), Values(TestResult( SPV_ERROR_INVALID_DATA, "Vulkan spec allows BuiltIn ShadingRateKHR to be used " "only with the Fragment execution model.")))); INSTANTIATE_TEST_SUITE_P( ShadingRateInvalidStorageClass, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("ShadingRateKHR"), Values("Fragment"), Values("Output"), Values("%u32"), Values("OpCapability FragmentShadingRateKHR\n"), Values("OpExtension \"SPV_KHR_fragment_shading_rate\"\n"), Values("VUID-ShadingRateKHR-ShadingRateKHR-04491 "), Values(TestResult( SPV_ERROR_INVALID_DATA, "Vulkan spec allows BuiltIn ShadingRateKHR to be only " "used for variables with Input storage class.")))); INSTANTIATE_TEST_SUITE_P( ShadingRateInvalidType, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine( Values("ShadingRateKHR"), Values("Fragment"), Values("Input"), Values("%f32"), Values("OpCapability FragmentShadingRateKHR\n"), Values("OpExtension \"SPV_KHR_fragment_shading_rate\"\n"), Values("VUID-ShadingRateKHR-ShadingRateKHR-04492 "), Values(TestResult(SPV_ERROR_INVALID_DATA, "According to the Vulkan spec BuiltIn ShadingRateKHR " "variable needs to be a 32-bit int scalar.")))); INSTANTIATE_TEST_SUITE_P( FragInvocationCountInputSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("FragInvocationCountEXT"), Values("Fragment"), Values("Input"), Values("%u32"), Values("OpCapability FragmentDensityEXT\n"), Values("OpExtension \"SPV_EXT_fragment_invocation_density\"\n"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( FragInvocationCountInvalidExecutionModel, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine( Values("FragInvocationCountEXT"), Values("Vertex"), Values("Input"), Values("%u32"), Values("OpCapability FragmentDensityEXT\n"), Values("OpExtension \"SPV_EXT_fragment_invocation_density\"\n"), Values("VUID-FragInvocationCountEXT-FragInvocationCountEXT-04217"), Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows BuiltIn FragInvocationCountEXT " "to be used only with Fragment execution model.")))); INSTANTIATE_TEST_SUITE_P( FragInvocationCountInvalidStorageClass, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("FragInvocationCountEXT"), Values("Fragment"), Values("Output"), Values("%u32"), Values("OpCapability FragmentDensityEXT\n"), Values("OpExtension \"SPV_EXT_fragment_invocation_density\"\n"), Values("VUID-FragInvocationCountEXT-FragInvocationCountEXT-04218"), Values(TestResult( SPV_ERROR_INVALID_DATA, "Vulkan spec allows BuiltIn FragInvocationCountEXT to be only " "used for variables with Input storage class.")))); INSTANTIATE_TEST_SUITE_P( FragInvocationCountInvalidType, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("FragInvocationCountEXT"), Values("Fragment"), Values("Input"), Values("%f32"), Values("OpCapability FragmentDensityEXT\n"), Values("OpExtension \"SPV_EXT_fragment_invocation_density\"\n"), Values("VUID-FragInvocationCountEXT-FragInvocationCountEXT-04219"), Values(TestResult( SPV_ERROR_INVALID_DATA, "According to the Vulkan spec BuiltIn FragInvocationCountEXT " "variable needs to be a 32-bit int scalar.")))); INSTANTIATE_TEST_SUITE_P( FragSizeInputSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("FragSizeEXT"), Values("Fragment"), Values("Input"), Values("%u32vec2"), Values("OpCapability FragmentDensityEXT\n"), Values("OpExtension \"SPV_EXT_fragment_invocation_density\"\n"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( FragSizeInvalidExecutionModel, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("FragSizeEXT"), Values("Vertex"), Values("Input"), Values("%u32vec2"), Values("OpCapability FragmentDensityEXT\n"), Values("OpExtension \"SPV_EXT_fragment_invocation_density\"\n"), Values("VUID-FragSizeEXT-FragSizeEXT-04220"), Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows BuiltIn FragSizeEXT to be " "used only with Fragment execution model.")))); INSTANTIATE_TEST_SUITE_P( FragSizeInvalidStorageClass, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine( Values("FragSizeEXT"), Values("Fragment"), Values("Output"), Values("%u32vec2"), Values("OpCapability FragmentDensityEXT\n"), Values("OpExtension \"SPV_EXT_fragment_invocation_density\"\n"), Values("VUID-FragSizeEXT-FragSizeEXT-04221"), Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows BuiltIn FragSizeEXT to be only " "used for variables with Input storage class.")))); INSTANTIATE_TEST_SUITE_P( FragSizeInvalidType, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("FragSizeEXT"), Values("Fragment"), Values("Input"), Values("%u32vec3"), Values("OpCapability FragmentDensityEXT\n"), Values("OpExtension \"SPV_EXT_fragment_invocation_density\"\n"), Values("VUID-FragSizeEXT-FragSizeEXT-04222"), Values(TestResult( SPV_ERROR_INVALID_DATA, "According to the Vulkan spec BuiltIn FragSizeEXT variable " "needs to be a 2-component 32-bit int vector.")))); INSTANTIATE_TEST_SUITE_P( FragStencilRefOutputSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("FragStencilRefEXT"), Values("Fragment"), Values("Output"), Values("%u32", "%u64"), Values("OpCapability StencilExportEXT\n"), Values("OpExtension \"SPV_EXT_shader_stencil_export\"\n"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( FragStencilRefInvalidExecutionModel, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("FragStencilRefEXT"), Values("Vertex"), Values("Output"), Values("%u32", "%u64"), Values("OpCapability StencilExportEXT\n"), Values("OpExtension \"SPV_EXT_shader_stencil_export\"\n"), Values("VUID-FragStencilRefEXT-FragStencilRefEXT-04223"), Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows BuiltIn FragStencilRefEXT to " "be used only with Fragment execution model.")))); INSTANTIATE_TEST_SUITE_P( FragStencilRefInvalidStorageClass, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("FragStencilRefEXT"), Values("Fragment"), Values("Input"), Values("%u32", "%u64"), Values("OpCapability StencilExportEXT\n"), Values("OpExtension \"SPV_EXT_shader_stencil_export\"\n"), Values("VUID-FragStencilRefEXT-FragStencilRefEXT-04224"), Values(TestResult( SPV_ERROR_INVALID_DATA, "Vulkan spec allows BuiltIn FragStencilRefEXT to be only used " "for variables with Output storage class.")))); INSTANTIATE_TEST_SUITE_P( FragStencilRefInvalidType, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("FragStencilRefEXT"), Values("Fragment"), Values("Output"), Values("%f32", "%f64", "%u32vec2"), Values("OpCapability StencilExportEXT\n"), Values("OpExtension \"SPV_EXT_shader_stencil_export\"\n"), Values("VUID-FragStencilRefEXT-FragStencilRefEXT-04225"), Values(TestResult( SPV_ERROR_INVALID_DATA, "According to the Vulkan spec BuiltIn FragStencilRefEXT " "variable needs to be a int scalar.")))); INSTANTIATE_TEST_SUITE_P( FullyCoveredEXTInputSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("FullyCoveredEXT"), Values("Fragment"), Values("Input"), Values("%bool"), Values("OpCapability FragmentFullyCoveredEXT\n"), Values("OpExtension \"SPV_EXT_fragment_fully_covered\"\n"), Values(nullptr), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( FullyCoveredEXTInvalidExecutionModel, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("FullyCoveredEXT"), Values("Vertex"), Values("Input"), Values("%bool"), Values("OpCapability FragmentFullyCoveredEXT\n"), Values("OpExtension \"SPV_EXT_fragment_fully_covered\"\n"), Values("VUID-FullyCoveredEXT-FullyCoveredEXT-04232"), Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows BuiltIn FullyCoveredEXT to " "be used only with Fragment execution model.")))); INSTANTIATE_TEST_SUITE_P( FullyCoveredEXTInvalidStorageClass, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("FullyCoveredEXT"), Values("Fragment"), Values("Output"), Values("%bool"), Values("OpCapability FragmentFullyCoveredEXT\n"), Values("OpExtension \"SPV_EXT_fragment_fully_covered\"\n"), Values("VUID-FullyCoveredEXT-FullyCoveredEXT-04233"), Values(TestResult( SPV_ERROR_INVALID_DATA, "Vulkan spec allows BuiltIn FullyCoveredEXT to be only used " "for variables with Input storage class.")))); INSTANTIATE_TEST_SUITE_P( FullyCoveredEXTInvalidType, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("FullyCoveredEXT"), Values("Fragment"), Values("Input"), Values("%f32"), Values("OpCapability FragmentFullyCoveredEXT\n"), Values("OpExtension \"SPV_EXT_fragment_fully_covered\"\n"), Values("VUID-FullyCoveredEXT-FullyCoveredEXT-04234"), Values(TestResult( SPV_ERROR_INVALID_DATA, "According to the Vulkan spec BuiltIn FullyCoveredEXT variable " "needs to be a bool scalar.")))); INSTANTIATE_TEST_SUITE_P( BaryCoordNotFragment, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine( Values("BaryCoordKHR", "BaryCoordNoPerspKHR"), Values("Vertex"), Values("Input"), Values("%f32vec3"), Values("OpCapability FragmentBarycentricKHR\n"), Values("OpExtension \"SPV_KHR_fragment_shader_barycentric\"\n"), Values("VUID-BaryCoordKHR-BaryCoordKHR-04154 " "VUID-BaryCoordNoPerspKHR-BaryCoordNoPerspKHR-04160 "), Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows BuiltIn", "to be used only with Fragment execution model")))); INSTANTIATE_TEST_SUITE_P( BaryCoordNotInput, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine(Values("BaryCoordKHR", "BaryCoordNoPerspKHR"), Values("Fragment"), Values("Output"), Values("%f32vec3"), Values("OpCapability FragmentBarycentricKHR\n"), Values("OpExtension \"SPV_KHR_fragment_shader_barycentric\"\n"), Values("VUID-BaryCoordKHR-BaryCoordKHR-04155 " "VUID-BaryCoordNoPerspKHR-BaryCoordNoPerspKHR-04161 "), Values(TestResult( SPV_ERROR_INVALID_DATA, "Vulkan spec allows BuiltIn", "to be only used for variables with Input storage class")))); INSTANTIATE_TEST_SUITE_P( BaryCoordNotFloatVector, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine( Values("BaryCoordKHR", "BaryCoordNoPerspKHR"), Values("Fragment"), Values("Output"), Values("%f32arr3", "%u32vec4"), Values("OpCapability FragmentBarycentricKHR\n"), Values("OpExtension \"SPV_KHR_fragment_shader_barycentric\"\n"), Values("VUID-BaryCoordKHR-BaryCoordKHR-04156 " "VUID-BaryCoordNoPerspKHR-BaryCoordNoPerspKHR-04162 "), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 3-component 32-bit float vector")))); INSTANTIATE_TEST_SUITE_P( BaryCoordNotFloatVec3, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine( Values("BaryCoordKHR", "BaryCoordNoPerspKHR"), Values("Fragment"), Values("Output"), Values("%f32vec2"), Values("OpCapability FragmentBarycentricKHR\n"), Values("OpExtension \"SPV_KHR_fragment_shader_barycentric\"\n"), Values("VUID-BaryCoordKHR-BaryCoordKHR-04156 " "VUID-BaryCoordNoPerspKHR-BaryCoordNoPerspKHR-04162 "), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 3-component 32-bit float vector")))); INSTANTIATE_TEST_SUITE_P( BaryCoordNotF32Vec3, ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, Combine( Values("BaryCoordKHR", "BaryCoordNoPerspKHR"), Values("Fragment"), Values("Output"), Values("%f64vec3"), Values("OpCapability FragmentBarycentricKHR\n"), Values("OpExtension \"SPV_KHR_fragment_shader_barycentric\"\n"), Values("VUID-BaryCoordKHR-BaryCoordKHR-04156 " "VUID-BaryCoordNoPerspKHR-BaryCoordNoPerspKHR-04162 "), Values(TestResult(SPV_ERROR_INVALID_DATA, "needs to be a 3-component 32-bit float vector")))); std::string GenerateMeshShadingCode(const std::string& built_in, const std::string& execution_mode, const std::string& body, const std::string& declarations = "") { std::ostringstream ss; ss << R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %main "main" %var OpExecutionMode %main LocalSize 1 1 1 OpExecutionMode %main OutputVertices 1 OpExecutionMode %main OutputPrimitivesEXT 16 )"; ss << "OpExecutionMode %main " << execution_mode << "\n"; ss << "OpDecorate %var BuiltIn " << built_in << "\n"; ss << R"( %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %v3uint = OpTypeVector %uint 3 %int_0 = OpConstant %int 0 %uint_16 = OpConstant %uint 16 )"; ss << declarations; ss << R"( %main = OpFunction %void None %func %main_entry = OpLabel )"; ss << body; ss << R"( OpReturn OpFunctionEnd)"; return ss.str(); } TEST_F(ValidateBuiltIns, VulkanPrimitiveTriangleIndicesEXTSuccess) { const std::string declarations = R"( %array = OpTypeArray %v3uint %uint_16 %array_ptr = OpTypePointer Output %array %var = OpVariable %array_ptr Output %ptr = OpTypePointer Output %v3uint )"; const std::string body = R"( %access = OpAccessChain %ptr %var %int_0 )"; CompileSuccessfully( GenerateMeshShadingCode("PrimitiveTriangleIndicesEXT", "OutputTrianglesEXT", body, declarations) .c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateBuiltIns, VulkanPrimitiveTriangleIndicesEXTInvalidExecutionMode) { const std::string declarations = R"( %array = OpTypeArray %v3uint %uint_16 %array_ptr = OpTypePointer Output %array %var = OpVariable %array_ptr Output %ptr = OpTypePointer Output %v3uint )"; const std::string body = R"( %access = OpAccessChain %ptr %var %int_0 )"; CompileSuccessfully( GenerateMeshShadingCode("PrimitiveTriangleIndicesEXT", "OutputPoints", body, declarations) .c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-PrimitiveTriangleIndicesEXT-" "PrimitiveTriangleIndicesEXT-07054")); } TEST_F(ValidateBuiltIns, VulkanPrimitiveTriangleIndicesEXTStorageClass) { const std::string declarations = R"( %array = OpTypeArray %v3uint %uint_16 %array_ptr = OpTypePointer Input %array %var = OpVariable %array_ptr Input %ptr = OpTypePointer Input %v3uint )"; const std::string body = R"( %access = OpAccessChain %ptr %var %int_0 )"; CompileSuccessfully( GenerateMeshShadingCode("PrimitiveTriangleIndicesEXT", "OutputTrianglesEXT", body, declarations) .c_str(), SPV_ENV_VULKAN_1_2); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-PrimitiveTriangleIndicesEXT-" "PrimitiveTriangleIndicesEXT-07055")); } TEST_F(ValidateBuiltIns, VulkanPrimitiveTriangleIndicesEXTVectorSize) { const std::string declarations = R"( %array = OpTypeArray %v2uint %uint_16 %array_ptr = OpTypePointer Output %array %var = OpVariable %array_ptr Output %ptr = OpTypePointer Output %v2uint )"; const std::string body = R"( %access = OpAccessChain %ptr %var %int_0 )"; CompileSuccessfully( GenerateMeshShadingCode("PrimitiveTriangleIndicesEXT", "OutputTrianglesEXT", body, declarations) .c_str(), SPV_ENV_VULKAN_1_2); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-PrimitiveTriangleIndicesEXT-" "PrimitiveTriangleIndicesEXT-07056")); } TEST_F(ValidateBuiltIns, VulkanPrimitiveTriangleIndicesEXTNonArray) { const std::string declarations = R"( %ptr = OpTypePointer Output %v3uint %var = OpVariable %ptr Output )"; const std::string body = R"( %load = OpLoad %v3uint %var )"; CompileSuccessfully( GenerateMeshShadingCode("PrimitiveTriangleIndicesEXT", "OutputTrianglesEXT", body, declarations) .c_str(), SPV_ENV_VULKAN_1_2); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-PrimitiveTriangleIndicesEXT-" "PrimitiveTriangleIndicesEXT-07056")); } TEST_F(ValidateBuiltIns, VulkanPrimitiveLineIndicesEXTSuccess) { const std::string declarations = R"( %array = OpTypeArray %v2uint %uint_16 %array_ptr = OpTypePointer Output %array %var = OpVariable %array_ptr Output %ptr = OpTypePointer Output %v2uint )"; const std::string body = R"( %access = OpAccessChain %ptr %var %int_0 )"; CompileSuccessfully( GenerateMeshShadingCode("PrimitiveLineIndicesEXT", "OutputLinesEXT", body, declarations) .c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateBuiltIns, VulkanPrimitiveLineIndicesEXTInvalidExecutionMode) { const std::string declarations = R"( %array = OpTypeArray %v2uint %uint_16 %array_ptr = OpTypePointer Output %array %var = OpVariable %array_ptr Output %ptr = OpTypePointer Output %v2uint )"; const std::string body = R"( %access = OpAccessChain %ptr %var %int_0 )"; CompileSuccessfully( GenerateMeshShadingCode("PrimitiveLineIndicesEXT", "OutputPoints", body, declarations) .c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT( getDiagnosticString(), AnyVUID("VUID-PrimitiveLineIndicesEXT-PrimitiveLineIndicesEXT-07048")); } TEST_F(ValidateBuiltIns, VulkanPrimitiveLineIndicesEXTStorageClass) { const std::string declarations = R"( %array = OpTypeArray %v2uint %uint_16 %array_ptr = OpTypePointer Input %array %var = OpVariable %array_ptr Input %ptr = OpTypePointer Input %v2uint )"; const std::string body = R"( %access = OpAccessChain %ptr %var %int_0 )"; CompileSuccessfully( GenerateMeshShadingCode("PrimitiveLineIndicesEXT", "OutputLinesEXT", body, declarations) .c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT( getDiagnosticString(), AnyVUID("VUID-PrimitiveLineIndicesEXT-PrimitiveLineIndicesEXT-07049")); } TEST_F(ValidateBuiltIns, VulkanPrimitiveLineIndicesEXTType) { const std::string declarations = R"( %array = OpTypeArray %v3uint %uint_16 %array_ptr = OpTypePointer Input %array %var = OpVariable %array_ptr Input %ptr = OpTypePointer Input %v3uint )"; const std::string body = R"( %access = OpAccessChain %ptr %var %int_0 )"; CompileSuccessfully( GenerateMeshShadingCode("PrimitiveLineIndicesEXT", "OutputLinesEXT", body, declarations) .c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT( getDiagnosticString(), AnyVUID("VUID-PrimitiveLineIndicesEXT-PrimitiveLineIndicesEXT-07050")); } TEST_F(ValidateBuiltIns, VulkanPrimitivePointIndicesEXTSuccess) { const std::string declarations = R"( %array = OpTypeArray %uint %uint_16 %array_ptr = OpTypePointer Output %array %var = OpVariable %array_ptr Output %ptr = OpTypePointer Output %uint )"; const std::string body = R"( %access = OpAccessChain %ptr %var %int_0 )"; CompileSuccessfully( GenerateMeshShadingCode("PrimitivePointIndicesEXT", "OutputPoints", body, declarations) .c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateBuiltIns, VulkanPrimitivePointIndicesEXTInvalidExecutionMode) { const std::string declarations = R"( %array = OpTypeArray %uint %uint_16 %array_ptr = OpTypePointer Output %array %var = OpVariable %array_ptr Output %ptr = OpTypePointer Output %uint )"; const std::string body = R"( %access = OpAccessChain %ptr %var %int_0 )"; CompileSuccessfully( GenerateMeshShadingCode("PrimitivePointIndicesEXT", "OutputTrianglesNV", body, declarations) .c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT( getDiagnosticString(), AnyVUID("VUID-PrimitivePointIndicesEXT-PrimitivePointIndicesEXT-07042")); } TEST_F(ValidateBuiltIns, VulkanPrimitivePointIndicesEXTStorageClass) { const std::string declarations = R"( %array = OpTypeArray %uint %uint_16 %array_ptr = OpTypePointer Input %array %var = OpVariable %array_ptr Input %ptr = OpTypePointer Input %uint )"; const std::string body = R"( %access = OpAccessChain %ptr %var %int_0 )"; CompileSuccessfully( GenerateMeshShadingCode("PrimitivePointIndicesEXT", "OutputPoints", body, declarations) .c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT( getDiagnosticString(), AnyVUID("VUID-PrimitivePointIndicesEXT-PrimitivePointIndicesEXT-07043")); } TEST_F(ValidateBuiltIns, VulkanPrimitivePointIndicesEXTType) { const std::string declarations = R"( %array = OpTypeArray %v3uint %uint_16 %array_ptr = OpTypePointer Output %array %var = OpVariable %array_ptr Output %ptr = OpTypePointer Output %v3uint )"; const std::string body = R"( %access = OpAccessChain %ptr %var %int_0 )"; CompileSuccessfully( GenerateMeshShadingCode("PrimitivePointIndicesEXT", "OutputPoints", body, declarations) .c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT( getDiagnosticString(), AnyVUID("VUID-PrimitivePointIndicesEXT-PrimitivePointIndicesEXT-07044")); } TEST_F(ValidateBuiltIns, VulkanBuiltinPrimtiveIDWithPerPrimitiveEXT) { const std::string text = R"( OpCapability MeshShadingEXT OpCapability Shader OpExtension "SPV_EXT_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %MainMesh "MainMesh" %gl_PrimitiveID OpExecutionMode %MainMesh OutputPrimitivesNV 1 OpExecutionMode %MainMesh OutputVertices 3 OpExecutionMode %MainMesh OutputTrianglesNV OpExecutionMode %MainMesh LocalSize 1 1 1 OpSource Slang 1 OpName %MainMesh "MainMesh" OpDecorate %gl_PrimitiveID BuiltIn PrimitiveId OpDecorate %gl_PrimitiveID PerPrimitiveNV %void = OpTypeVoid %9 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_3 = OpConstant %uint 3 %uint_1 = OpConstant %uint 1 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %int_3 = OpConstant %int 3 %_ptr_Output_v4float = OpTypePointer Output %v4float %uint_0 = OpConstant %uint 0 %v3float = OpTypeVector %float 3 %_ptr_Output_v3float = OpTypePointer Output %v3float %v3uint = OpTypeVector %uint 3 %_ptr_Output_v3uint = OpTypePointer Output %v3uint %_ptr_Output_int = OpTypePointer Output %int %_arr_int_int_1 = OpTypeArray %int %int_1 %_ptr_Output__arr_int_int_1 = OpTypePointer Output %_arr_int_int_1 %gl_PrimitiveID = OpVariable %_ptr_Output__arr_int_int_1 Output %MainMesh = OpFunction %void None %9 %25 = OpLabel OpSetMeshOutputsEXT %uint_3 %uint_1 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateBuiltIns, BadVulkanBuiltinPrimtiveIDWithPerPrimitiveEXT) { const std::string text = R"( OpCapability MeshShadingEXT OpCapability Shader OpExtension "SPV_EXT_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %MainMesh "MainMesh" %gl_PrimitiveID OpExecutionMode %MainMesh OutputPrimitivesNV 1 OpExecutionMode %MainMesh OutputVertices 3 OpExecutionMode %MainMesh OutputTrianglesNV OpExecutionMode %MainMesh LocalSize 1 1 1 OpSource Slang 1 OpName %MainMesh "MainMesh" OpDecorate %gl_PrimitiveID BuiltIn PrimitiveId %void = OpTypeVoid %9 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_3 = OpConstant %uint 3 %uint_1 = OpConstant %uint 1 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %int_3 = OpConstant %int 3 %_ptr_Output_v4float = OpTypePointer Output %v4float %uint_0 = OpConstant %uint 0 %v3float = OpTypeVector %float 3 %_ptr_Output_v3float = OpTypePointer Output %v3float %v3uint = OpTypeVector %uint 3 %_ptr_Output_v3uint = OpTypePointer Output %v3uint %_ptr_Output_int = OpTypePointer Output %int %_arr_int_int_1 = OpTypeArray %int %int_1 %_ptr_Output__arr_int_int_1 = OpTypePointer Output %_arr_int_int_1 %gl_PrimitiveID = OpVariable %_ptr_Output__arr_int_int_1 Output %MainMesh = OpFunction %void None %9 %25 = OpLabel OpSetMeshOutputsEXT %uint_3 %uint_1 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-PrimitiveId-PrimitiveId-07040")); } TEST_F(ValidateBuiltIns, BadVulkanBuiltinLayerWithPerPrimitiveEXT) { const std::string text = R"( OpCapability MeshShadingEXT OpCapability Shader OpExtension "SPV_EXT_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %MainMesh "MainMesh" %gl_Layer OpExecutionMode %MainMesh OutputPrimitivesNV 1 OpExecutionMode %MainMesh OutputVertices 3 OpExecutionMode %MainMesh OutputTrianglesNV OpExecutionMode %MainMesh LocalSize 1 1 1 OpSource Slang 1 OpName %MainMesh "MainMesh" OpDecorate %gl_Layer BuiltIn Layer %void = OpTypeVoid %9 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_3 = OpConstant %uint 3 %uint_1 = OpConstant %uint 1 %float = OpTypeFloat 32 %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %int_3 = OpConstant %int 3 %uint_0 = OpConstant %uint 0 %v3float = OpTypeVector %float 3 %_ptr_Output_v3float = OpTypePointer Output %v3float %v3uint = OpTypeVector %uint 3 %_ptr_Output_v3uint = OpTypePointer Output %v3uint %_ptr_Output_int = OpTypePointer Output %int %_arr_int_int_1 = OpTypeArray %int %int_1 %_ptr_Output__arr_int_int_1 = OpTypePointer Output %_arr_int_int_1 %gl_Layer = OpVariable %_ptr_Output__arr_int_int_1 Output %MainMesh = OpFunction %void None %9 %25 = OpLabel OpSetMeshOutputsEXT %uint_3 %uint_1 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-Layer-Layer-07039")); } TEST_F(ValidateBuiltIns, BadVulkanBuiltinViewportIndexWithPerPrimitiveEXT) { const std::string text = R"( OpCapability MeshShadingEXT OpCapability Shader OpExtension "SPV_EXT_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %MainMesh "MainMesh" %gl_ViewportIndex OpExecutionMode %MainMesh OutputPrimitivesNV 1 OpExecutionMode %MainMesh OutputVertices 3 OpExecutionMode %MainMesh OutputTrianglesNV OpExecutionMode %MainMesh LocalSize 1 1 1 OpSource Slang 1 OpName %MainMesh "MainMesh" OpDecorate %gl_ViewportIndex BuiltIn ViewportIndex %void = OpTypeVoid %9 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_3 = OpConstant %uint 3 %uint_1 = OpConstant %uint 1 %float = OpTypeFloat 32 %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %int_3 = OpConstant %int 3 %uint_0 = OpConstant %uint 0 %v3float = OpTypeVector %float 3 %_ptr_Output_v3float = OpTypePointer Output %v3float %v3uint = OpTypeVector %uint 3 %_ptr_Output_v3uint = OpTypePointer Output %v3uint %_ptr_Output_int = OpTypePointer Output %int %_arr_int_int_1 = OpTypeArray %int %int_1 %_ptr_Output__arr_int_int_1 = OpTypePointer Output %_arr_int_int_1 %gl_ViewportIndex = OpVariable %_ptr_Output__arr_int_int_1 Output %MainMesh = OpFunction %void None %9 %25 = OpLabel OpSetMeshOutputsEXT %uint_3 %uint_1 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-ViewportIndex-ViewportIndex-07060")); } TEST_F(ValidateBuiltIns, VulkanBuiltinPrimitivePointIndicesEXT) { const std::string text = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %main "main" %gl_PrimitivePointIndicesEXT OpExecutionMode %main LocalSize 32 1 1 OpExecutionMode %main OutputVertices 81 OpExecutionMode %main OutputPrimitivesEXT 32 OpExecutionMode %main OutputPoints OpSource GLSL 460 OpSourceExtension "GL_EXT_mesh_shader" OpName %main "main" OpName %gl_PrimitivePointIndicesEXT "gl_PrimitivePointIndicesEXT" OpDecorate %gl_PrimitivePointIndicesEXT BuiltIn PrimitivePointIndicesEXT OpDecorate %gl_WorkGroupSize BuiltIn WorkgroupSize %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %_arr_uint_uint_32 = OpTypeArray %uint %uint_32 %_ptr_Output__arr_uint_uint_32 = OpTypePointer Output %_arr_uint_uint_32 %gl_PrimitivePointIndicesEXT = OpVariable %_ptr_Output__arr_uint_uint_32 Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint_0 = OpConstant %uint 0 %_ptr_Output_uint = OpTypePointer Output %uint %v3uint = OpTypeVector %uint 3 %uint_1 = OpConstant %uint 1 %gl_WorkGroupSize = OpConstantComposite %v3uint %uint_32 %uint_1 %uint_1 %main = OpFunction %void None %3 %5 = OpLabel %15 = OpAccessChain %_ptr_Output_uint %gl_PrimitivePointIndicesEXT %int_0 OpStore %15 %uint_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateBuiltIns, VulkanBuiltinPrimitiveLineIndicesEXT) { const std::string text = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %main "main" %gl_PrimitiveLineIndicesEXT OpExecutionMode %main LocalSize 32 1 1 OpExecutionMode %main OutputVertices 81 OpExecutionMode %main OutputPrimitivesEXT 32 OpExecutionMode %main OutputLinesEXT OpSource GLSL 460 OpSourceExtension "GL_EXT_mesh_shader" OpName %main "main" OpName %gl_PrimitiveLineIndicesEXT "gl_PrimitiveLineIndicesEXT" OpDecorate %gl_PrimitiveLineIndicesEXT BuiltIn PrimitiveLineIndicesEXT OpDecorate %gl_WorkGroupSize BuiltIn WorkgroupSize %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %uint_32 = OpConstant %uint 32 %_arr_v2uint_uint_32 = OpTypeArray %v2uint %uint_32 %_ptr_Output__arr_v2uint_uint_32 = OpTypePointer Output %_arr_v2uint_uint_32 %gl_PrimitiveLineIndicesEXT = OpVariable %_ptr_Output__arr_v2uint_uint_32 Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint_0 = OpConstant %uint 0 %15 = OpConstantComposite %v2uint %uint_0 %uint_0 %_ptr_Output_v2uint = OpTypePointer Output %v2uint %v3uint = OpTypeVector %uint 3 %uint_1 = OpConstant %uint 1 %gl_WorkGroupSize = OpConstantComposite %v3uint %uint_32 %uint_1 %uint_1 %main = OpFunction %void None %3 %5 = OpLabel %17 = OpAccessChain %_ptr_Output_v2uint %gl_PrimitiveLineIndicesEXT %int_0 OpStore %17 %15 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateBuiltIns, BadVulkanBuiltinPrimitiveLineIndicesEXT) { const std::string text = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %main "main" %gl_PrimitiveLineIndicesEXT OpExecutionMode %main LocalSize 32 1 1 OpExecutionMode %main OutputVertices 81 OpExecutionMode %main OutputPrimitivesEXT 32 OpExecutionMode %main OutputPoints OpSource GLSL 460 OpSourceExtension "GL_EXT_mesh_shader" OpName %main "main" OpName %gl_PrimitiveLineIndicesEXT "gl_PrimitiveLineIndicesEXT" OpDecorate %gl_PrimitiveLineIndicesEXT BuiltIn PrimitiveLineIndicesEXT OpDecorate %gl_WorkGroupSize BuiltIn WorkgroupSize %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %uint_32 = OpConstant %uint 32 %_arr_v2uint_uint_32 = OpTypeArray %v2uint %uint_32 %_ptr_Output__arr_v2uint_uint_32 = OpTypePointer Output %_arr_v2uint_uint_32 %gl_PrimitiveLineIndicesEXT = OpVariable %_ptr_Output__arr_v2uint_uint_32 Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint_0 = OpConstant %uint 0 %15 = OpConstantComposite %v2uint %uint_0 %uint_0 %_ptr_Output_v2uint = OpTypePointer Output %v2uint %v3uint = OpTypeVector %uint 3 %uint_1 = OpConstant %uint 1 %gl_WorkGroupSize = OpConstantComposite %v3uint %uint_32 %uint_1 %uint_1 %main = OpFunction %void None %3 %5 = OpLabel %17 = OpAccessChain %_ptr_Output_v2uint %gl_PrimitiveLineIndicesEXT %int_0 OpStore %17 %15 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT( getDiagnosticString(), AnyVUID("VUID-PrimitiveLineIndicesEXT-PrimitiveLineIndicesEXT-07048")); } TEST_F(ValidateBuiltIns, BadVulkanBuiltinPrimitivePointIndicesEXT) { const std::string text = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %main "main" %gl_PrimitivePointIndicesEXT OpExecutionMode %main LocalSize 32 1 1 OpExecutionMode %main OutputVertices 81 OpExecutionMode %main OutputPrimitivesEXT 32 OpExecutionMode %main OutputTrianglesEXT OpSource GLSL 460 OpSourceExtension "GL_EXT_mesh_shader" OpName %main "main" OpName %gl_PrimitivePointIndicesEXT "gl_PrimitivePointIndicesEXT" OpDecorate %gl_PrimitivePointIndicesEXT BuiltIn PrimitivePointIndicesEXT OpDecorate %gl_WorkGroupSize BuiltIn WorkgroupSize %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %_arr_uint_uint_32 = OpTypeArray %uint %uint_32 %_ptr_Output__arr_uint_uint_32 = OpTypePointer Output %_arr_uint_uint_32 %gl_PrimitivePointIndicesEXT = OpVariable %_ptr_Output__arr_uint_uint_32 Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint_0 = OpConstant %uint 0 %_ptr_Output_uint = OpTypePointer Output %uint %v3uint = OpTypeVector %uint 3 %uint_1 = OpConstant %uint 1 %gl_WorkGroupSize = OpConstantComposite %v3uint %uint_32 %uint_1 %uint_1 %main = OpFunction %void None %3 %5 = OpLabel %15 = OpAccessChain %_ptr_Output_uint %gl_PrimitivePointIndicesEXT %int_0 OpStore %15 %uint_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT( getDiagnosticString(), AnyVUID("VUID-PrimitivePointIndicesEXT-PrimitivePointIndicesEXT-07042")); } TEST_F(ValidateBuiltIns, VulkanBuiltinPrimitiveTriangleIndicesEXT) { const std::string text = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %main "main" %gl_PrimitiveTriangleIndicesEXT OpExecutionModeId %main LocalSizeId %uint_32 %uint_1 %uint_1 OpExecutionMode %main OutputVertices 81 OpExecutionMode %main OutputPrimitivesEXT 32 OpExecutionMode %main OutputTrianglesEXT OpSource GLSL 460 OpSourceExtension "GL_EXT_mesh_shader" OpName %main "main" OpName %gl_PrimitiveTriangleIndicesEXT "gl_PrimitiveTriangleIndicesEXT" OpDecorate %gl_PrimitiveTriangleIndicesEXT BuiltIn PrimitiveTriangleIndicesEXT %void = OpTypeVoid %7 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %uint_1 = OpConstant %uint 1 %v3uint = OpTypeVector %uint 3 %_arr_v3uint_uint_32 = OpTypeArray %v3uint %uint_32 %_ptr_Output__arr_v3uint_uint_32 = OpTypePointer Output %_arr_v3uint_uint_32 %gl_PrimitiveTriangleIndicesEXT = OpVariable %_ptr_Output__arr_v3uint_uint_32 Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint_0 = OpConstant %uint 0 %15 = OpConstantComposite %v3uint %uint_0 %uint_0 %uint_0 %_ptr_Output_v3uint = OpTypePointer Output %v3uint %17 = OpConstantComposite %v3uint %uint_32 %uint_1 %uint_1 %main = OpFunction %void None %7 %18 = OpLabel %19 = OpAccessChain %_ptr_Output_v3uint %gl_PrimitiveTriangleIndicesEXT %int_0 OpStore %19 %15 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_3)); } TEST_F(ValidateBuiltIns, BadVulkanBuiltinPrimitiveTriangleIndicesEXT) { const std::string text = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %main "main" %gl_PrimitiveTriangleIndicesEXT OpExecutionModeId %main LocalSizeId %uint_32 %uint_1 %uint_1 OpExecutionMode %main OutputVertices 81 OpExecutionMode %main OutputPrimitivesEXT 32 OpExecutionMode %main OutputPoints OpSource GLSL 460 OpSourceExtension "GL_EXT_mesh_shader" OpName %main "main" OpName %gl_PrimitiveTriangleIndicesEXT "gl_PrimitiveTriangleIndicesEXT" OpDecorate %gl_PrimitiveTriangleIndicesEXT BuiltIn PrimitiveTriangleIndicesEXT %void = OpTypeVoid %7 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %uint_1 = OpConstant %uint 1 %v3uint = OpTypeVector %uint 3 %_arr_v3uint_uint_32 = OpTypeArray %v3uint %uint_32 %_ptr_Output__arr_v3uint_uint_32 = OpTypePointer Output %_arr_v3uint_uint_32 %gl_PrimitiveTriangleIndicesEXT = OpVariable %_ptr_Output__arr_v3uint_uint_32 Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint_0 = OpConstant %uint 0 %15 = OpConstantComposite %v3uint %uint_0 %uint_0 %uint_0 %_ptr_Output_v3uint = OpTypePointer Output %v3uint %17 = OpConstantComposite %v3uint %uint_32 %uint_1 %uint_1 %main = OpFunction %void None %7 %18 = OpLabel %19 = OpAccessChain %_ptr_Output_v3uint %gl_PrimitiveTriangleIndicesEXT %int_0 OpStore %19 %15 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_3)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-PrimitiveTriangleIndicesEXT-" "PrimitiveTriangleIndicesEXT-07054")); } TEST_F(ValidateBuiltIns, BadVulkanPrimitivePointIndicesArraySizeMeshEXT) { const std::string text = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %main "main" %gl_PrimitivePointIndicesEXT OpExecutionMode %main LocalSize 32 1 1 OpExecutionMode %main OutputVertices 81 OpExecutionMode %main OutputPrimitivesEXT 16 OpExecutionMode %main OutputPoints OpSource GLSL 460 OpSourceExtension "GL_EXT_mesh_shader" OpName %main "main" OpName %gl_PrimitivePointIndicesEXT "gl_PrimitivePointIndicesEXT" OpDecorate %gl_PrimitivePointIndicesEXT BuiltIn PrimitivePointIndicesEXT OpDecorate %gl_WorkGroupSize BuiltIn WorkgroupSize %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %_arr_uint_uint_32 = OpTypeArray %uint %uint_32 %_ptr_Output__arr_uint_uint_32 = OpTypePointer Output %_arr_uint_uint_32 %gl_PrimitivePointIndicesEXT = OpVariable %_ptr_Output__arr_uint_uint_32 Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint_0 = OpConstant %uint 0 %_ptr_Output_uint = OpTypePointer Output %uint %v3uint = OpTypeVector %uint 3 %uint_1 = OpConstant %uint 1 %gl_WorkGroupSize = OpConstantComposite %v3uint %uint_32 %uint_1 %uint_1 %main = OpFunction %void None %3 %5 = OpLabel %15 = OpAccessChain %_ptr_Output_uint %gl_PrimitivePointIndicesEXT %int_0 OpStore %15 %uint_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT( getDiagnosticString(), AnyVUID("VUID-PrimitivePointIndicesEXT-PrimitivePointIndicesEXT-07046")); } TEST_F(ValidateBuiltIns, BadVulkanPrimitiveLineIndicesArraySizeMeshEXT) { const std::string text = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %main "main" %gl_PrimitiveLineIndicesEXT OpExecutionMode %main LocalSize 32 1 1 OpExecutionMode %main OutputVertices 81 OpExecutionMode %main OutputPrimitivesEXT 16 OpExecutionMode %main OutputLinesEXT OpSource GLSL 460 OpSourceExtension "GL_EXT_mesh_shader" OpName %main "main" OpName %gl_PrimitiveLineIndicesEXT "gl_PrimitiveLineIndicesEXT" OpDecorate %gl_PrimitiveLineIndicesEXT BuiltIn PrimitiveLineIndicesEXT OpDecorate %gl_WorkGroupSize BuiltIn WorkgroupSize %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %uint_32 = OpConstant %uint 32 %_arr_v2uint_uint_32 = OpTypeArray %v2uint %uint_32 %_ptr_Output__arr_v2uint_uint_32 = OpTypePointer Output %_arr_v2uint_uint_32 %gl_PrimitiveLineIndicesEXT = OpVariable %_ptr_Output__arr_v2uint_uint_32 Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint_0 = OpConstant %uint 0 %15 = OpConstantComposite %v2uint %uint_0 %uint_0 %_ptr_Output_v2uint = OpTypePointer Output %v2uint %v3uint = OpTypeVector %uint 3 %uint_1 = OpConstant %uint 1 %gl_WorkGroupSize = OpConstantComposite %v3uint %uint_32 %uint_1 %uint_1 %main = OpFunction %void None %3 %5 = OpLabel %17 = OpAccessChain %_ptr_Output_v2uint %gl_PrimitiveLineIndicesEXT %int_0 OpStore %17 %15 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_3)); EXPECT_THAT( getDiagnosticString(), AnyVUID("VUID-PrimitiveLineIndicesEXT-PrimitiveLineIndicesEXT-07052")); } TEST_F(ValidateBuiltIns, BadVulkanPrimitiveTriangleIndicesArraySizeMeshEXT) { const std::string text = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %main "main" %gl_PrimitiveTriangleIndicesEXT OpExecutionModeId %main LocalSizeId %uint_32 %uint_1 %uint_1 OpExecutionMode %main OutputVertices 81 OpExecutionMode %main OutputPrimitivesEXT 16 OpExecutionMode %main OutputTrianglesEXT OpSource GLSL 460 OpSourceExtension "GL_EXT_mesh_shader" OpName %main "main" OpName %gl_PrimitiveTriangleIndicesEXT "gl_PrimitiveTriangleIndicesEXT" OpDecorate %gl_PrimitiveTriangleIndicesEXT BuiltIn PrimitiveTriangleIndicesEXT %void = OpTypeVoid %7 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %uint_1 = OpConstant %uint 1 %v3uint = OpTypeVector %uint 3 %_arr_v3uint_uint_32 = OpTypeArray %v3uint %uint_32 %_ptr_Output__arr_v3uint_uint_32 = OpTypePointer Output %_arr_v3uint_uint_32 %gl_PrimitiveTriangleIndicesEXT = OpVariable %_ptr_Output__arr_v3uint_uint_32 Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint_0 = OpConstant %uint 0 %15 = OpConstantComposite %v3uint %uint_0 %uint_0 %uint_0 %_ptr_Output_v3uint = OpTypePointer Output %v3uint %17 = OpConstantComposite %v3uint %uint_32 %uint_1 %uint_1 %main = OpFunction %void None %7 %18 = OpLabel %19 = OpAccessChain %_ptr_Output_v3uint %gl_PrimitiveTriangleIndicesEXT %int_0 OpStore %19 %15 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_3)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-PrimitiveTriangleIndicesEXT-" "PrimitiveTriangleIndicesEXT-07058")); } TEST_F(ValidateBuiltIns, BadExecModelVulkanPrimitivePointIndicesEXT) { const std::string text = R"( OpCapability MeshShadingNV OpCapability MeshShadingEXT OpExtension "SPV_NV_mesh_shader" OpExtension "SPV_EXT_mesh_shader" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint MeshNV %main "main" %gl_PrimitivePointIndicesEXT OpExecutionMode %main LocalSize 32 1 1 OpExecutionMode %main OutputVertices 81 OpExecutionMode %main OutputPrimitivesEXT 32 OpExecutionMode %main OutputPoints OpSource GLSL 460 OpSourceExtension "GL_EXT_mesh_shader" OpName %main "main" OpName %gl_PrimitivePointIndicesEXT "gl_PrimitivePointIndicesEXT" OpDecorate %gl_PrimitivePointIndicesEXT BuiltIn PrimitivePointIndicesEXT OpDecorate %gl_WorkGroupSize BuiltIn WorkgroupSize %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %_arr_uint_uint_32 = OpTypeArray %uint %uint_32 %_ptr_Output__arr_uint_uint_32 = OpTypePointer Output %_arr_uint_uint_32 %gl_PrimitivePointIndicesEXT = OpVariable %_ptr_Output__arr_uint_uint_32 Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint_0 = OpConstant %uint 0 %_ptr_Output_uint = OpTypePointer Output %uint %v3uint = OpTypeVector %uint 3 %uint_1 = OpConstant %uint 1 %gl_WorkGroupSize = OpConstantComposite %v3uint %uint_32 %uint_1 %uint_1 %main = OpFunction %void None %3 %5 = OpLabel %15 = OpAccessChain %_ptr_Output_uint %gl_PrimitivePointIndicesEXT %int_0 OpStore %15 %uint_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_3)); EXPECT_THAT( getDiagnosticString(), AnyVUID("VUID-PrimitivePointIndicesEXT-PrimitivePointIndicesEXT-07041")); } TEST_F(ValidateBuiltIns, VulkanBuiltinCullPrimitiveEXT) { const std::string text = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %main "main" %gl_MeshPrimitivesEXT OpExecutionModeId %main LocalSizeId %uint_32 %uint_1 %uint_1 OpExecutionMode %main OutputVertices 81 OpExecutionMode %main OutputPrimitivesEXT 32 OpExecutionMode %main OutputTrianglesEXT OpSource GLSL 450 OpSourceExtension "GL_EXT_mesh_shader" OpName %main "main" OpName %gl_MeshPerPrimitiveEXT "gl_MeshPerPrimitiveEXT" OpMemberName %gl_MeshPerPrimitiveEXT 0 "gl_CullPrimitiveEXT" OpName %gl_MeshPrimitivesEXT "gl_MeshPrimitivesEXT" OpDecorate %gl_MeshPerPrimitiveEXT Block OpMemberDecorate %gl_MeshPerPrimitiveEXT 0 BuiltIn CullPrimitiveEXT OpMemberDecorate %gl_MeshPerPrimitiveEXT 0 PerPrimitiveEXT %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %uint_1 = OpConstant %uint 1 %int = OpTypeInt 32 1 %bool = OpTypeBool %gl_MeshPerPrimitiveEXT = OpTypeStruct %bool %_arr_gl_MeshPerPrimitiveEXT_uint_32 = OpTypeArray %gl_MeshPerPrimitiveEXT %uint_32 %_ptr_Output__arr_gl_MeshPerPrimitiveEXT_uint_32 = OpTypePointer Output %_arr_gl_MeshPerPrimitiveEXT_uint_32 %gl_MeshPrimitivesEXT = OpVariable %_ptr_Output__arr_gl_MeshPerPrimitiveEXT_uint_32 Output %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_3)); } TEST_F(ValidateBuiltIns, BadVulkanBuiltinCullPrimitiveEXTType) { const std::string text = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %main "main" %gl_MeshPrimitivesEXT OpExecutionModeId %main LocalSizeId %uint_32 %uint_1 %uint_1 OpExecutionMode %main OutputVertices 81 OpExecutionMode %main OutputPrimitivesEXT 32 OpExecutionMode %main OutputTrianglesEXT OpSource GLSL 450 OpSourceExtension "GL_EXT_mesh_shader" OpName %main "main" OpName %gl_MeshPerPrimitiveEXT "gl_MeshPerPrimitiveEXT" OpMemberName %gl_MeshPerPrimitiveEXT 0 "gl_CullPrimitiveEXT" OpName %gl_MeshPrimitivesEXT "gl_MeshPrimitivesEXT" OpDecorate %gl_MeshPerPrimitiveEXT Block OpMemberDecorate %gl_MeshPerPrimitiveEXT 0 BuiltIn CullPrimitiveEXT OpMemberDecorate %gl_MeshPerPrimitiveEXT 0 PerPrimitiveEXT %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %uint_1 = OpConstant %uint 1 %int = OpTypeInt 32 1 %bool = OpTypeBool %gl_MeshPerPrimitiveEXT = OpTypeStruct %int %_arr_gl_MeshPerPrimitiveEXT_uint_32 = OpTypeArray %gl_MeshPerPrimitiveEXT %uint_32 %_ptr_Output__arr_gl_MeshPerPrimitiveEXT_uint_32 = OpTypePointer Output %_arr_gl_MeshPerPrimitiveEXT_uint_32 %gl_MeshPrimitivesEXT = OpVariable %_ptr_Output__arr_gl_MeshPerPrimitiveEXT_uint_32 Output %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_3)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-CullPrimitiveEXT-CullPrimitiveEXT-07036")); } TEST_F(ValidateBuiltIns, BadVulkanBuiltinCullPrimitiveEXTStorageClass) { const std::string text = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %main "main" %gl_MeshPrimitivesEXT OpExecutionModeId %main LocalSizeId %uint_32 %uint_1 %uint_1 OpExecutionMode %main OutputVertices 81 OpExecutionMode %main OutputPrimitivesEXT 32 OpExecutionMode %main OutputTrianglesEXT OpSource GLSL 450 OpSourceExtension "GL_EXT_mesh_shader" OpName %main "main" OpName %gl_MeshPerPrimitiveEXT "gl_MeshPerPrimitiveEXT" OpMemberName %gl_MeshPerPrimitiveEXT 0 "gl_CullPrimitiveEXT" OpName %gl_MeshPrimitivesEXT "gl_MeshPrimitivesEXT" OpDecorate %gl_MeshPerPrimitiveEXT Block OpMemberDecorate %gl_MeshPerPrimitiveEXT 0 BuiltIn CullPrimitiveEXT OpMemberDecorate %gl_MeshPerPrimitiveEXT 0 PerPrimitiveEXT %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %uint_1 = OpConstant %uint 1 %int = OpTypeInt 32 1 %bool = OpTypeBool %gl_MeshPerPrimitiveEXT = OpTypeStruct %bool %_arr_gl_MeshPerPrimitiveEXT_uint_32 = OpTypeArray %gl_MeshPerPrimitiveEXT %uint_32 %_ptr_Output__arr_gl_MeshPerPrimitiveEXT_uint_32 = OpTypePointer Input %_arr_gl_MeshPerPrimitiveEXT_uint_32 %gl_MeshPrimitivesEXT = OpVariable %_ptr_Output__arr_gl_MeshPerPrimitiveEXT_uint_32 Input %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_3)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-CullPrimitiveEXT-CullPrimitiveEXT-07035")); } TEST_F(ValidateBuiltIns, BadBuiltinCullPrimitiveEXTWithPerPrimitiveEXT) { const std::string text = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %main "main" %gl_MeshPrimitivesEXT OpExecutionModeId %main LocalSizeId %uint_32 %uint_1 %uint_1 OpExecutionMode %main OutputVertices 81 OpExecutionMode %main OutputPrimitivesEXT 32 OpExecutionMode %main OutputTrianglesEXT OpSource GLSL 450 OpSourceExtension "GL_EXT_mesh_shader" OpName %main "main" OpName %gl_MeshPerPrimitiveEXT "gl_MeshPerPrimitiveEXT" OpMemberName %gl_MeshPerPrimitiveEXT 0 "gl_CullPrimitiveEXT" OpName %gl_MeshPrimitivesEXT "gl_MeshPrimitivesEXT" OpDecorate %gl_MeshPerPrimitiveEXT Block OpMemberDecorate %gl_MeshPerPrimitiveEXT 0 BuiltIn CullPrimitiveEXT %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %uint_1 = OpConstant %uint 1 %int = OpTypeInt 32 1 %bool = OpTypeBool %gl_MeshPerPrimitiveEXT = OpTypeStruct %bool %_arr_gl_MeshPerPrimitiveEXT_uint_32 = OpTypeArray %gl_MeshPerPrimitiveEXT %uint_32 %_ptr_Output__arr_gl_MeshPerPrimitiveEXT_uint_32 = OpTypePointer Output %_arr_gl_MeshPerPrimitiveEXT_uint_32 %gl_MeshPrimitivesEXT = OpVariable %_ptr_Output__arr_gl_MeshPerPrimitiveEXT_uint_32 Output %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_3)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-CullPrimitiveEXT-CullPrimitiveEXT-07038")); } TEST_F(ValidateBuiltIns, BadBuiltinPrimitiveShadingRateWithPerPrimitiveEXT) { const std::string text = R"( OpCapability FragmentShadingRateKHR OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" OpExtension "SPV_KHR_fragment_shading_rate" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %main "main" %gl_MeshPrimitivesEXT OpExecutionModeId %main LocalSizeId %uint_32 %uint_1 %uint_1 OpExecutionMode %main OutputVertices 81 OpExecutionMode %main OutputPrimitivesEXT 32 OpExecutionMode %main OutputTrianglesEXT OpSource GLSL 450 OpSourceExtension "GL_EXT_mesh_shader" OpName %main "main" OpName %gl_MeshPerPrimitiveEXT "gl_MeshPerPrimitiveEXT" OpMemberName %gl_MeshPerPrimitiveEXT 0 "gl_PrimitiveShadingRateKHR" OpName %gl_MeshPrimitivesEXT "gl_MeshPrimitivesEXT" OpDecorate %gl_MeshPerPrimitiveEXT Block OpMemberDecorate %gl_MeshPerPrimitiveEXT 0 BuiltIn PrimitiveShadingRateKHR %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %uint_1 = OpConstant %uint 1 %int = OpTypeInt 32 1 %bool = OpTypeBool %gl_MeshPerPrimitiveEXT = OpTypeStruct %int %_arr_gl_MeshPerPrimitiveEXT_uint_32 = OpTypeArray %gl_MeshPerPrimitiveEXT %uint_32 %_ptr_Output__arr_gl_MeshPerPrimitiveEXT_uint_32 = OpTypePointer Output %_arr_gl_MeshPerPrimitiveEXT_uint_32 %gl_MeshPrimitivesEXT = OpVariable %_ptr_Output__arr_gl_MeshPerPrimitiveEXT_uint_32 Output %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_3)); EXPECT_THAT( getDiagnosticString(), AnyVUID("VUID-PrimitiveShadingRateKHR-PrimitiveShadingRateKHR-07059")); } TEST_F(ValidateBuiltIns, BadExecModelVulkanCullPrimitiveEXT) { const std::string text = R"( OpCapability MeshShadingNV OpCapability MeshShadingEXT OpExtension "SPV_NV_mesh_shader" OpExtension "SPV_EXT_mesh_shader" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint MeshNV %main "main" %gl_MeshPrimitivesEXT OpExecutionModeId %main LocalSizeId %uint_32 %uint_1 %uint_1 OpExecutionMode %main OutputVertices 81 OpExecutionMode %main OutputPrimitivesNV 32 OpExecutionMode %main OutputTrianglesNV OpSource GLSL 450 OpSourceExtension "GL_EXT_mesh_shader" OpMemberDecorate %gl_MeshPerPrimitiveEXT 0 PerPrimitiveEXT OpMemberDecorate %gl_MeshPerPrimitiveEXT 0 BuiltIn CullPrimitiveEXT OpDecorate %gl_MeshPerPrimitiveEXT Block %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %uint_1 = OpConstant %uint 1 %v3uint = OpTypeVector %uint 3 %bool = OpTypeBool %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %gl_MeshPerPrimitiveEXT = OpTypeStruct %bool %_ptr_Output_bool = OpTypePointer Output %bool %_arr_gl_MeshPerPrimitiveEXT_uint_32 = OpTypeArray %gl_MeshPerPrimitiveEXT %uint_32 %_ptr_Output__arr_gl_MeshPerPrimitiveEXT_uint_32 = OpTypePointer Output %_arr_gl_MeshPerPrimitiveEXT_uint_32 %gl_MeshPrimitivesEXT = OpVariable %_ptr_Output__arr_gl_MeshPerPrimitiveEXT_uint_32 Output %main = OpFunction %void None %3 %5 = OpLabel %18 = OpAccessChain %_ptr_Output_bool %gl_MeshPrimitivesEXT %int_0 %int_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_3)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-CullPrimitiveEXT-CullPrimitiveEXT-07034")); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_capability_test.cpp000066400000000000000000003350671475742701700250360ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validation tests for Logical Layout #include #include #include #include #include #include "gmock/gmock.h" #include "source/assembly_grammar.h" #include "source/spirv_target_env.h" #include "spirv-tools/libspirv.h" #include "test/test_fixture.h" #include "test/unit_spirv.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using spvtest::ScopedContext; using testing::Combine; using testing::Eq; using testing::HasSubstr; using testing::Values; using testing::ValuesIn; // Parameter for validation test fixtures. The first std::string is a // capability name that will begin the assembly under test, the second the // remainder assembly, and the std::vector at the end determines whether the // test expects success or failure. See below for details and convenience // methods to access each one. // // The assembly to test is composed from a variable top line and a fixed // remainder. The top line will be an OpCapability instruction, while the // remainder will be some assembly text that succeeds or fails to assemble // depending on which capability was chosen. For instance, the following will // succeed: // // OpCapability Pipes ; implies Kernel // OpLifetimeStop %1 0 ; requires Kernel // // and the following will fail: // // OpCapability Kernel // %1 = OpTypeNamedBarrier ; requires NamedBarrier // // So how does the test parameter capture which capabilities should cause // success and which shouldn't? The answer is in the last element: it's a // std::vector of capabilities that make the remainder assembly succeed. So if // the first-line capability exists in that std::vector, success is expected; // otherwise, failure is expected in the tests. // // We will use testing::Combine() to vary the first line: when we combine // AllCapabilities() with a single remainder assembly, we generate enough test // cases to try the assembly with every possible capability that could be // declared. However, Combine() only produces tuples -- it cannot produce, say, // a struct. Therefore, this type must be a tuple. using CapTestParameter = std::tuple>>; const std::string& Capability(const CapTestParameter& p) { return std::get<0>(p); } const std::string& Remainder(const CapTestParameter& p) { return std::get<1>(p).first; } const std::vector& MustSucceed(const CapTestParameter& p) { return std::get<1>(p).second; } // Creates assembly to test from p. std::string MakeAssembly(const CapTestParameter& p) { std::ostringstream ss; const std::string& capability = Capability(p); if (!capability.empty()) { ss << "OpCapability " << capability << "\n"; } ss << Remainder(p); return ss.str(); } // Expected validation result for p. spv_result_t ExpectedResult(const CapTestParameter& p) { const auto& caps = MustSucceed(p); auto found = find(begin(caps), end(caps), Capability(p)); return (found == end(caps)) ? SPV_ERROR_INVALID_CAPABILITY : SPV_SUCCESS; } // Assembles using v1.0, unless the parameter's capability requires v1.1. using ValidateCapability = spvtest::ValidateBase; // Always assembles using v1.1. using ValidateCapabilityV11 = spvtest::ValidateBase; // Always assembles using Vulkan 1.0. // TODO(dneto): Refactor all these tests to scale better across environments. using ValidateCapabilityVulkan10 = spvtest::ValidateBase; // Always assembles using OpenGL 4.0. using ValidateCapabilityOpenGL40 = spvtest::ValidateBase; // Always assembles using Vulkan 1.1. using ValidateCapabilityVulkan11 = spvtest::ValidateBase; // Always assembles using Vulkan 1.2. using ValidateCapabilityVulkan12 = spvtest::ValidateBase; TEST_F(ValidateCapability, Default) { const char str[] = R"( OpCapability Kernel OpCapability Linkage OpCapability Matrix OpMemoryModel Logical OpenCL %f32 = OpTypeFloat 32 %vec3 = OpTypeVector %f32 3 %mat33 = OpTypeMatrix %vec3 3 )"; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } // clang-format off const std::vector& AllCapabilities() { static const auto r = new std::vector{ "", "Matrix", "Shader", "Geometry", "Tessellation", "Addresses", "Linkage", "Kernel", "Vector16", "Float16Buffer", "Float16", "Float64", "Int64", "Int64Atomics", "ImageBasic", "ImageReadWrite", "ImageMipmap", "Pipes", "Groups", "DeviceEnqueue", "LiteralSampler", "AtomicStorage", "Int16", "TessellationPointSize", "GeometryPointSize", "ImageGatherExtended", "StorageImageMultisample", "UniformBufferArrayDynamicIndexing", "SampledImageArrayDynamicIndexing", "StorageBufferArrayDynamicIndexing", "StorageImageArrayDynamicIndexing", "ClipDistance", "CullDistance", "ImageCubeArray", "SampleRateShading", "ImageRect", "SampledRect", "GenericPointer", "Int8", "InputAttachment", "SparseResidency", "MinLod", "Sampled1D", "Image1D", "SampledCubeArray", "SampledBuffer", "ImageBuffer", "ImageMSArray", "StorageImageExtendedFormats", "ImageQuery", "DerivativeControl", "InterpolationFunction", "TransformFeedback", "GeometryStreams", "StorageImageReadWithoutFormat", "StorageImageWriteWithoutFormat", "MultiViewport", "SubgroupDispatch", "NamedBarrier", "PipeStorage", "GroupNonUniform", "GroupNonUniformVote", "GroupNonUniformArithmetic", "GroupNonUniformBallot", "GroupNonUniformShuffle", "GroupNonUniformShuffleRelative", "GroupNonUniformClustered", "GroupNonUniformQuad", "DrawParameters", "StorageBuffer16BitAccess", "StorageUniformBufferBlock16", "UniformAndStorageBuffer16BitAccess", "StorageUniform16", "StoragePushConstant16", "StorageInputOutput16", "DeviceGroup", "MultiView", "VariablePointersStorageBuffer", "VariablePointers"}; return *r; } const std::vector& AllSpirV15Capabilities() { static const auto r = new std::vector{ "", "Matrix", "Shader", "Geometry", "Tessellation", "Addresses", "Linkage", "Kernel", "Vector16", "Float16Buffer", "Float16", "Float64", "Int64", "Int64Atomics", "ImageBasic", "ImageReadWrite", "ImageMipmap", "Pipes", "Groups", "DeviceEnqueue", "LiteralSampler", "AtomicStorage", "Int16", "TessellationPointSize", "GeometryPointSize", "ImageGatherExtended", "StorageImageMultisample", "UniformBufferArrayDynamicIndexing", "SampledImageArrayDynamicIndexing", "StorageBufferArrayDynamicIndexing", "StorageImageArrayDynamicIndexing", "ClipDistance", "CullDistance", "ImageCubeArray", "SampleRateShading", "ImageRect", "SampledRect", "GenericPointer", "Int8", "InputAttachment", "SparseResidency", "MinLod", "Sampled1D", "Image1D", "SampledCubeArray", "SampledBuffer", "ImageBuffer", "ImageMSArray", "StorageImageExtendedFormats", "ImageQuery", "DerivativeControl", "InterpolationFunction", "TransformFeedback", "GeometryStreams", "StorageImageReadWithoutFormat", "StorageImageWriteWithoutFormat", "MultiViewport", "SubgroupDispatch", "NamedBarrier", "PipeStorage", "GroupNonUniform", "GroupNonUniformVote", "GroupNonUniformArithmetic", "GroupNonUniformBallot", "GroupNonUniformShuffle", "GroupNonUniformShuffleRelative", "GroupNonUniformClustered", "GroupNonUniformQuad", "DrawParameters", "StorageBuffer16BitAccess", "StorageUniformBufferBlock16", "UniformAndStorageBuffer16BitAccess", "StorageUniform16", "StoragePushConstant16", "StorageInputOutput16", "DeviceGroup", "MultiView", "VariablePointersStorageBuffer", "VariablePointers", "DenormPreserve", "DenormFlushToZero", "SignedZeroInfNanPreserve", "RoundingModeRTE", "RoundingModeRTZ", // Omitted due to extra validation requirements on memory model. //"VulkanMemoryModel", //"VulkanMemoryModelDeviceScope", "StorageBuffer8BitAccess", "UniformAndStorageBuffer8BitAccess", "StoragePushConstant8", "ShaderViewportIndex", "ShaderLayer", "PhysicalStorageBufferAddresses", "RuntimeDescriptorArray", "UniformTexelBufferArrayDynamicIndexing", "StorageTexelBufferArrayDynamicIndexing", "UniformBufferArrayNonUniformIndexing", "SampledImageArrayNonUniformIndexing", "StorageBufferArrayNonUniformIndexing", "StorageImageArrayNonUniformIndexing", "InputAttachmentArrayNonUniformIndexing", "UniformTexelBufferArrayNonUniformIndexing", "StorageTexelBufferArrayNonUniformIndexing"}; return *r; } const std::vector& AllSpirV10Capabilities() { static const auto r = new std::vector{ "", "Matrix", "Shader", "Geometry", "Tessellation", "Addresses", "Linkage", "Kernel", "Vector16", "Float16Buffer", "Float16", "Float64", "Int64", "Int64Atomics", "ImageBasic", "ImageReadWrite", "ImageMipmap", "Pipes", "Groups", "DeviceEnqueue", "LiteralSampler", "AtomicStorage", "Int16", "TessellationPointSize", "GeometryPointSize", "ImageGatherExtended", "StorageImageMultisample", "UniformBufferArrayDynamicIndexing", "SampledImageArrayDynamicIndexing", "StorageBufferArrayDynamicIndexing", "StorageImageArrayDynamicIndexing", "ClipDistance", "CullDistance", "ImageCubeArray", "SampleRateShading", "ImageRect", "SampledRect", "GenericPointer", "Int8", "InputAttachment", "SparseResidency", "MinLod", "Sampled1D", "Image1D", "SampledCubeArray", "SampledBuffer", "ImageBuffer", "ImageMSArray", "StorageImageExtendedFormats", "ImageQuery", "DerivativeControl", "InterpolationFunction", "TransformFeedback", "GeometryStreams", "StorageImageReadWithoutFormat", "StorageImageWriteWithoutFormat", "MultiViewport"}; return *r; } const std::vector& AllVulkan10Capabilities() { static const auto r = new std::vector{ "", "Matrix", "Shader", "InputAttachment", "Sampled1D", "Image1D", "SampledBuffer", "ImageBuffer", "ImageQuery", "DerivativeControl", "Geometry", "Tessellation", "Float16", "Float64", "Int64", "Int64Atomics", "Int16", "TessellationPointSize", "GeometryPointSize", "ImageGatherExtended", "StorageImageMultisample", "UniformBufferArrayDynamicIndexing", "SampledImageArrayDynamicIndexing", "StorageBufferArrayDynamicIndexing", "StorageImageArrayDynamicIndexing", "ClipDistance", "CullDistance", "ImageCubeArray", "SampleRateShading", "Int8", "SparseResidency", "MinLod", "SampledCubeArray", "ImageMSArray", "StorageImageExtendedFormats", "InterpolationFunction", "StorageImageReadWithoutFormat", "StorageImageWriteWithoutFormat", "MultiViewport", "TransformFeedback", "GeometryStreams"}; return *r; } const std::vector& AllVulkan11Capabilities() { static const auto r = new std::vector{ "", "Matrix", "Shader", "InputAttachment", "Sampled1D", "Image1D", "SampledBuffer", "ImageBuffer", "ImageQuery", "DerivativeControl", "Geometry", "Tessellation", "Float16", "Float64", "Int64", "Int64Atomics", "Int16", "TessellationPointSize", "GeometryPointSize", "ImageGatherExtended", "StorageImageMultisample", "UniformBufferArrayDynamicIndexing", "SampledImageArrayDynamicIndexing", "StorageBufferArrayDynamicIndexing", "StorageImageArrayDynamicIndexing", "ClipDistance", "CullDistance", "ImageCubeArray", "SampleRateShading", "Int8", "SparseResidency", "MinLod", "SampledCubeArray", "ImageMSArray", "StorageImageExtendedFormats", "InterpolationFunction", "StorageImageReadWithoutFormat", "StorageImageWriteWithoutFormat", "MultiViewport", "GroupNonUniform", "GroupNonUniformVote", "GroupNonUniformArithmetic", "GroupNonUniformBallot", "GroupNonUniformShuffle", "GroupNonUniformShuffleRelative", "GroupNonUniformClustered", "GroupNonUniformQuad", "DrawParameters", "StorageBuffer16BitAccess", "StorageUniformBufferBlock16", "UniformAndStorageBuffer16BitAccess", "StorageUniform16", "StoragePushConstant16", "StorageInputOutput16", "DeviceGroup", "MultiView", "VariablePointersStorageBuffer", "VariablePointers", "TransformFeedback", "GeometryStreams"}; return *r; } const std::vector& AllVulkan12Capabilities() { static const auto r = new std::vector{ "", "Matrix", "Shader", "InputAttachment", "Sampled1D", "Image1D", "SampledBuffer", "ImageBuffer", "ImageQuery", "DerivativeControl", "Geometry", "Tessellation", "Float16", "Float64", "Int64", "Int64Atomics", "Int16", "TessellationPointSize", "GeometryPointSize", "ImageGatherExtended", "StorageImageMultisample", "UniformBufferArrayDynamicIndexing", "SampledImageArrayDynamicIndexing", "StorageBufferArrayDynamicIndexing", "StorageImageArrayDynamicIndexing", "ClipDistance", "CullDistance", "ImageCubeArray", "SampleRateShading", "Int8", "SparseResidency", "MinLod", "SampledCubeArray", "ImageMSArray", "StorageImageExtendedFormats", "InterpolationFunction", "StorageImageReadWithoutFormat", "StorageImageWriteWithoutFormat", "MultiViewport", "GroupNonUniform", "GroupNonUniformVote", "GroupNonUniformArithmetic", "GroupNonUniformBallot", "GroupNonUniformShuffle", "GroupNonUniformShuffleRelative", "GroupNonUniformClustered", "GroupNonUniformQuad", "DrawParameters", "StorageBuffer16BitAccess", "StorageUniformBufferBlock16", "UniformAndStorageBuffer16BitAccess", "StorageUniform16", "StoragePushConstant16", "StorageInputOutput16", "DeviceGroup", "MultiView", "VariablePointersStorageBuffer", "VariablePointers", "TransformFeedback", "GeometryStreams", "DenormPreserve", "DenormFlushToZero", "SignedZeroInfNanPreserve", "RoundingModeRTE", "RoundingModeRTZ", "VulkanMemoryModel", "VulkanMemoryModelDeviceScope", "StorageBuffer8BitAccess", "UniformAndStorageBuffer8BitAccess", "StoragePushConstant8", "ShaderViewportIndex", "ShaderLayer", "PhysicalStorageBufferAddresses", "RuntimeDescriptorArray", "UniformTexelBufferArrayDynamicIndexing", "StorageTexelBufferArrayDynamicIndexing", "UniformBufferArrayNonUniformIndexing", "SampledImageArrayNonUniformIndexing", "StorageBufferArrayNonUniformIndexing", "StorageImageArrayNonUniformIndexing", "InputAttachmentArrayNonUniformIndexing", "UniformTexelBufferArrayNonUniformIndexing", "StorageTexelBufferArrayNonUniformIndexing"}; return *r; } const std::vector& MatrixDependencies() { static const auto r = new std::vector{ "Matrix", "Shader", "Geometry", "Tessellation", "AtomicStorage", "TessellationPointSize", "GeometryPointSize", "ImageGatherExtended", "StorageImageMultisample", "UniformBufferArrayDynamicIndexing", "SampledImageArrayDynamicIndexing", "StorageBufferArrayDynamicIndexing", "StorageImageArrayDynamicIndexing", "ClipDistance", "CullDistance", "ImageCubeArray", "SampleRateShading", "ImageRect", "SampledRect", "InputAttachment", "SparseResidency", "MinLod", "SampledCubeArray", "ImageMSArray", "StorageImageExtendedFormats", "ImageQuery", "DerivativeControl", "InterpolationFunction", "TransformFeedback", "GeometryStreams", "StorageImageReadWithoutFormat", "StorageImageWriteWithoutFormat", "MultiViewport", "DrawParameters", "MultiView", "VariablePointersStorageBuffer", "VariablePointers"}; return *r; } const std::vector& ShaderDependencies() { static const auto r = new std::vector{ "Shader", "Geometry", "Tessellation", "AtomicStorage", "TessellationPointSize", "GeometryPointSize", "ImageGatherExtended", "StorageImageMultisample", "UniformBufferArrayDynamicIndexing", "SampledImageArrayDynamicIndexing", "StorageBufferArrayDynamicIndexing", "StorageImageArrayDynamicIndexing", "ClipDistance", "CullDistance", "ImageCubeArray", "SampleRateShading", "ImageRect", "SampledRect", "InputAttachment", "SparseResidency", "MinLod", "SampledCubeArray", "ImageMSArray", "StorageImageExtendedFormats", "ImageQuery", "DerivativeControl", "InterpolationFunction", "TransformFeedback", "GeometryStreams", "StorageImageReadWithoutFormat", "StorageImageWriteWithoutFormat", "MultiViewport", "DrawParameters", "MultiView", "VariablePointersStorageBuffer", "VariablePointers"}; return *r; } const std::vector& TessellationDependencies() { static const auto r = new std::vector{ "Tessellation", "TessellationPointSize"}; return *r; } const std::vector& GeometryDependencies() { static const auto r = new std::vector{ "Geometry", "GeometryPointSize", "GeometryStreams", "MultiViewport"}; return *r; } const std::vector& GeometryTessellationDependencies() { static const auto r = new std::vector{ "Tessellation", "TessellationPointSize", "Geometry", "GeometryPointSize", "GeometryStreams", "MultiViewport"}; return *r; } // Returns the names of capabilities that directly depend on Kernel, // plus itself. const std::vector& KernelDependencies() { static const auto r = new std::vector{ "Kernel", "Vector16", "Float16Buffer", "ImageBasic", "ImageReadWrite", "ImageMipmap", "Pipes", "DeviceEnqueue", "LiteralSampler", "SubgroupDispatch", "NamedBarrier", "PipeStorage"}; return *r; } const std::vector& KernelAndGroupNonUniformDependencies() { static const auto r = new std::vector{ "Kernel", "Vector16", "Float16Buffer", "ImageBasic", "ImageReadWrite", "ImageMipmap", "Pipes", "DeviceEnqueue", "LiteralSampler", "SubgroupDispatch", "NamedBarrier", "PipeStorage", "GroupNonUniform", "GroupNonUniformVote", "GroupNonUniformArithmetic", "GroupNonUniformBallot", "GroupNonUniformShuffle", "GroupNonUniformShuffleRelative", "GroupNonUniformClustered", "GroupNonUniformQuad"}; return *r; } const std::vector& AddressesDependencies() { static const auto r = new std::vector{ "Addresses", "GenericPointer"}; return *r; } const std::vector& Sampled1DDependencies() { static const auto r = new std::vector{ "Sampled1D", "Image1D"}; return *r; } const std::vector& SampledRectDependencies() { static const auto r = new std::vector{ "SampledRect", "ImageRect"}; return *r; } const std::vector& SampledBufferDependencies() { static const auto r = new std::vector{ "SampledBuffer", "ImageBuffer"}; return *r; } const char kOpenCLMemoryModel[] = \ " OpCapability Kernel" " OpMemoryModel Logical OpenCL "; const char kGLSL450MemoryModel[] = \ " OpCapability Shader" " OpMemoryModel Logical GLSL450 "; const char kVoidFVoid[] = \ " %void = OpTypeVoid" " %void_f = OpTypeFunction %void" " %func = OpFunction %void None %void_f" " %label = OpLabel" " OpReturn" " OpFunctionEnd "; const char kVoidFVoid2[] = \ " %void_f = OpTypeFunction %voidt" " %func = OpFunction %voidt None %void_f" " %label = OpLabel" " OpReturn" " OpFunctionEnd "; INSTANTIATE_TEST_SUITE_P(ExecutionModel, ValidateCapability, Combine( ValuesIn(AllCapabilities()), Values( std::make_pair(std::string(kOpenCLMemoryModel) + " OpEntryPoint Vertex %func \"shader\"" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + " OpEntryPoint TessellationControl %func \"shader\"" + std::string(kVoidFVoid), TessellationDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + " OpEntryPoint TessellationEvaluation %func \"shader\"" + std::string(kVoidFVoid), TessellationDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + " OpEntryPoint Geometry %func \"shader\"" + " OpExecutionMode %func InputPoints" + " OpExecutionMode %func OutputPoints" + std::string(kVoidFVoid), GeometryDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + " OpEntryPoint Fragment %func \"shader\"" + " OpExecutionMode %func OriginUpperLeft" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + " OpEntryPoint GLCompute %func \"shader\"" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kGLSL450MemoryModel) + " OpEntryPoint Kernel %func \"shader\"" + std::string(kVoidFVoid), KernelDependencies()) ))); INSTANTIATE_TEST_SUITE_P(AddressingAndMemoryModel, ValidateCapability, Combine( ValuesIn(AllCapabilities()), Values( std::make_pair(" OpCapability Shader" " OpMemoryModel Logical Simple" " OpEntryPoint Vertex %func \"shader\"" + std::string(kVoidFVoid), AllCapabilities()), std::make_pair(" OpCapability Shader" " OpMemoryModel Logical GLSL450" " OpEntryPoint Vertex %func \"shader\"" + std::string(kVoidFVoid), AllCapabilities()), std::make_pair(" OpCapability Kernel" " OpMemoryModel Logical OpenCL" " OpEntryPoint Kernel %func \"compute\"" + std::string(kVoidFVoid), AllCapabilities()), std::make_pair(" OpCapability Shader" " OpMemoryModel Physical32 Simple" " OpEntryPoint Vertex %func \"shader\"" + std::string(kVoidFVoid), AddressesDependencies()), std::make_pair(" OpCapability Shader" " OpMemoryModel Physical32 GLSL450" " OpEntryPoint Vertex %func \"shader\"" + std::string(kVoidFVoid), AddressesDependencies()), std::make_pair(" OpCapability Kernel" " OpMemoryModel Physical32 OpenCL" " OpEntryPoint Kernel %func \"compute\"" + std::string(kVoidFVoid), AddressesDependencies()), std::make_pair(" OpCapability Shader" " OpMemoryModel Physical64 Simple" " OpEntryPoint Vertex %func \"shader\"" + std::string(kVoidFVoid), AddressesDependencies()), std::make_pair(" OpCapability Shader" " OpMemoryModel Physical64 GLSL450" " OpEntryPoint Vertex %func \"shader\"" + std::string(kVoidFVoid), AddressesDependencies()), std::make_pair(" OpCapability Kernel" " OpMemoryModel Physical64 OpenCL" " OpEntryPoint Kernel %func \"compute\"" + std::string(kVoidFVoid), AddressesDependencies()) ))); INSTANTIATE_TEST_SUITE_P(ExecutionMode, ValidateCapability, Combine( ValuesIn(AllCapabilities()), Values( std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Geometry %func \"shader\" " "OpExecutionMode %func Invocations 42" + " OpExecutionMode %func InputPoints" + " OpExecutionMode %func OutputPoints" + std::string(kVoidFVoid), GeometryDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint TessellationControl %func \"shader\" " "OpExecutionMode %func SpacingEqual" + std::string(kVoidFVoid), TessellationDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint TessellationControl %func \"shader\" " "OpExecutionMode %func SpacingFractionalEven" + std::string(kVoidFVoid), TessellationDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint TessellationControl %func \"shader\" " "OpExecutionMode %func SpacingFractionalOdd" + std::string(kVoidFVoid), TessellationDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint TessellationControl %func \"shader\" " "OpExecutionMode %func VertexOrderCw" + std::string(kVoidFVoid), TessellationDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint TessellationControl %func \"shader\" " "OpExecutionMode %func VertexOrderCcw" + std::string(kVoidFVoid), TessellationDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Fragment %func \"shader\" " "OpExecutionMode %func PixelCenterInteger" + " OpExecutionMode %func OriginUpperLeft" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Fragment %func \"shader\" " "OpExecutionMode %func OriginUpperLeft" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Fragment %func \"shader\" " "OpExecutionMode %func OriginLowerLeft" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Fragment %func \"shader\" " "OpExecutionMode %func EarlyFragmentTests" + " OpExecutionMode %func OriginUpperLeft" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint TessellationControl %func \"shader\" " "OpExecutionMode %func PointMode" + std::string(kVoidFVoid), TessellationDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Vertex %func \"shader\" " "OpExecutionMode %func Xfb" + std::string(kVoidFVoid), std::vector{"TransformFeedback"}), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Fragment %func \"shader\" " "OpExecutionMode %func DepthReplacing" + " OpExecutionMode %func OriginUpperLeft" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Fragment %func \"shader\" " "OpExecutionMode %func DepthGreater" + " OpExecutionMode %func OriginUpperLeft" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Fragment %func \"shader\" " "OpExecutionMode %func DepthLess" + " OpExecutionMode %func OriginUpperLeft" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Fragment %func \"shader\" " "OpExecutionMode %func DepthUnchanged" + " OpExecutionMode %func OriginUpperLeft" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"shader\" " "OpExecutionMode %func LocalSize 42 42 42" + std::string(kVoidFVoid), AllCapabilities()), std::make_pair(std::string(kGLSL450MemoryModel) + "OpEntryPoint Kernel %func \"shader\" " "OpExecutionMode %func LocalSizeHint 42 42 42" + std::string(kVoidFVoid), KernelDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Geometry %func \"shader\" " "OpExecutionMode %func InputPoints" + " OpExecutionMode %func OutputPoints" + std::string(kVoidFVoid), GeometryDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Geometry %func \"shader\" " "OpExecutionMode %func InputLines" + " OpExecutionMode %func OutputLineStrip" + std::string(kVoidFVoid), GeometryDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Geometry %func \"shader\" " "OpExecutionMode %func InputLinesAdjacency" + " OpExecutionMode %func OutputLineStrip" + std::string(kVoidFVoid), GeometryDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Geometry %func \"shader\" " "OpExecutionMode %func Triangles" + " OpExecutionMode %func OutputTriangleStrip" + std::string(kVoidFVoid), GeometryDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint TessellationControl %func \"shader\" " "OpExecutionMode %func Triangles" + std::string(kVoidFVoid), TessellationDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Geometry %func \"shader\" " "OpExecutionMode %func InputTrianglesAdjacency" + " OpExecutionMode %func OutputTriangleStrip" + std::string(kVoidFVoid), GeometryDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint TessellationControl %func \"shader\" " "OpExecutionMode %func Quads" + std::string(kVoidFVoid), TessellationDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint TessellationControl %func \"shader\" " "OpExecutionMode %func Isolines" + std::string(kVoidFVoid), TessellationDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Geometry %func \"shader\" " "OpExecutionMode %func OutputVertices 42" + " OpExecutionMode %func OutputPoints" + " OpExecutionMode %func InputPoints" + std::string(kVoidFVoid), GeometryDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint TessellationControl %func \"shader\" " "OpExecutionMode %func OutputVertices 42" + std::string(kVoidFVoid), TessellationDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Geometry %func \"shader\" " "OpExecutionMode %func OutputPoints" + " OpExecutionMode %func InputPoints" + std::string(kVoidFVoid), GeometryDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Geometry %func \"shader\" " "OpExecutionMode %func OutputLineStrip" + " OpExecutionMode %func InputLines" + std::string(kVoidFVoid), GeometryDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Geometry %func \"shader\" " "OpExecutionMode %func OutputTriangleStrip" + " OpExecutionMode %func Triangles" + std::string(kVoidFVoid), GeometryDependencies()), std::make_pair(std::string(kGLSL450MemoryModel) + "OpEntryPoint Kernel %func \"shader\" " "OpExecutionMode %func VecTypeHint 2" + std::string(kVoidFVoid), KernelDependencies()), std::make_pair(std::string(kGLSL450MemoryModel) + "OpEntryPoint Kernel %func \"shader\" " "OpExecutionMode %func ContractionOff" + std::string(kVoidFVoid), KernelDependencies())))); // clang-format on INSTANTIATE_TEST_SUITE_P( ExecutionModeV11, ValidateCapabilityV11, Combine(ValuesIn(AllCapabilities()), Values(std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"shader\" " "OpExecutionMode %func SubgroupSize 1" + std::string(kVoidFVoid), std::vector{"SubgroupDispatch"}), std::make_pair( std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"shader\" " "OpExecutionMode %func SubgroupsPerWorkgroup 65535" + std::string(kVoidFVoid), std::vector{"SubgroupDispatch"})))); // clang-format off INSTANTIATE_TEST_SUITE_P(StorageClass, ValidateCapability, Combine( ValuesIn(AllCapabilities()), Values( std::make_pair(std::string(kGLSL450MemoryModel) + " OpEntryPoint Vertex %func \"shader\"" + " %intt = OpTypeInt 32 0\n" " %ptrt = OpTypePointer UniformConstant %intt\n" " %var = OpVariable %ptrt UniformConstant\n" + std::string(kVoidFVoid), AllCapabilities()), std::make_pair(std::string(kOpenCLMemoryModel) + " OpEntryPoint Kernel %func \"compute\"" + " %intt = OpTypeInt 32 0\n" " %ptrt = OpTypePointer Input %intt" " %var = OpVariable %ptrt Input\n" + std::string(kVoidFVoid), AllCapabilities()), std::make_pair(std::string(kOpenCLMemoryModel) + " OpEntryPoint Vertex %func \"shader\"" + " %intt = OpTypeInt 32 0\n" " %ptrt = OpTypePointer Uniform %intt\n" " %var = OpVariable %ptrt Uniform\n" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + " OpEntryPoint Vertex %func \"shader\"" + " %intt = OpTypeInt 32 0\n" " %ptrt = OpTypePointer Output %intt\n" " %var = OpVariable %ptrt Output\n" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kGLSL450MemoryModel) + " OpEntryPoint Vertex %func \"shader\"" + " %intt = OpTypeInt 32 0\n" " %ptrt = OpTypePointer Workgroup %intt\n" " %var = OpVariable %ptrt Workgroup\n" + std::string(kVoidFVoid), AllCapabilities()), std::make_pair(std::string(kGLSL450MemoryModel) + " OpEntryPoint Vertex %func \"shader\"" + " %intt = OpTypeInt 32 0\n" " %ptrt = OpTypePointer CrossWorkgroup %intt\n" " %var = OpVariable %ptrt CrossWorkgroup\n" + std::string(kVoidFVoid), AllCapabilities()), std::make_pair(std::string(kOpenCLMemoryModel) + " OpEntryPoint Kernel %func \"compute\"" + " %intt = OpTypeInt 32 0\n" " %ptrt = OpTypePointer Private %intt\n" " %var = OpVariable %ptrt Private\n" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + " OpEntryPoint Kernel %func \"compute\"" + " %intt = OpTypeInt 32 0\n" " %ptrt = OpTypePointer PushConstant %intt\n" " %var = OpVariable %ptrt PushConstant\n" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kGLSL450MemoryModel) + " OpEntryPoint Vertex %func \"shader\"" + " %intt = OpTypeInt 32 0\n" " %ptrt = OpTypePointer AtomicCounter %intt\n" " %var = OpVariable %ptrt AtomicCounter\n" + std::string(kVoidFVoid), std::vector{"AtomicStorage"}), std::make_pair(std::string(kGLSL450MemoryModel) + " OpEntryPoint Vertex %func \"shader\"" + " %intt = OpTypeInt 32 0\n" " %ptrt = OpTypePointer Image %intt\n" " %var = OpVariable %ptrt Image\n" + std::string(kVoidFVoid), AllCapabilities()) ))); INSTANTIATE_TEST_SUITE_P(Dim, ValidateCapability, Combine( ValuesIn(AllCapabilities()), Values( std::make_pair(" OpCapability ImageBasic" + std::string(kOpenCLMemoryModel) + std::string(" OpEntryPoint Kernel %func \"compute\"") + " %voidt = OpTypeVoid" " %imgt = OpTypeImage %voidt 1D 0 0 0 0 Unknown" + std::string(kVoidFVoid2), Sampled1DDependencies()), std::make_pair(" OpCapability ImageBasic" + std::string(kOpenCLMemoryModel) + std::string(" OpEntryPoint Kernel %func \"compute\"") + " %voidt = OpTypeVoid" " %imgt = OpTypeImage %voidt 2D 0 0 0 0 Unknown" + std::string(kVoidFVoid2), AllCapabilities()), std::make_pair(" OpCapability ImageBasic" + std::string(kOpenCLMemoryModel) + std::string(" OpEntryPoint Kernel %func \"compute\"") + " %voidt = OpTypeVoid" " %imgt = OpTypeImage %voidt 3D 0 0 0 0 Unknown" + std::string(kVoidFVoid2), AllCapabilities()), std::make_pair(" OpCapability ImageBasic" + std::string(kOpenCLMemoryModel) + std::string(" OpEntryPoint Kernel %func \"compute\"") + " %voidt = OpTypeVoid" " %imgt = OpTypeImage %voidt Cube 0 0 0 0 Unknown" + std::string(kVoidFVoid2), ShaderDependencies()), std::make_pair(" OpCapability ImageBasic" + std::string(kOpenCLMemoryModel) + std::string(" OpEntryPoint Kernel %func \"compute\"") + " %voidt = OpTypeVoid" " %imgt = OpTypeImage %voidt Rect 0 0 0 0 Unknown" + std::string(kVoidFVoid2), SampledRectDependencies()), std::make_pair(" OpCapability ImageBasic" + std::string(kOpenCLMemoryModel) + std::string(" OpEntryPoint Kernel %func \"compute\"") + " %voidt = OpTypeVoid" " %imgt = OpTypeImage %voidt Buffer 0 0 0 0 Unknown" + std::string(kVoidFVoid2), SampledBufferDependencies()), std::make_pair(" OpCapability ImageBasic" + std::string(kOpenCLMemoryModel) + std::string(" OpEntryPoint Kernel %func \"compute\"") + " %voidt = OpTypeVoid" " %imgt = OpTypeImage %voidt SubpassData 0 0 0 2 Unknown" + std::string(kVoidFVoid2), std::vector{"InputAttachment"}) ))); // NOTE: All Sampler Address Modes require kernel capabilities but the // OpConstantSampler requires LiteralSampler which depends on Kernel INSTANTIATE_TEST_SUITE_P(SamplerAddressingMode, ValidateCapability, Combine( ValuesIn(AllCapabilities()), Values( std::make_pair(std::string(kGLSL450MemoryModel) + " OpEntryPoint Vertex %func \"shader\"" " %samplert = OpTypeSampler" " %sampler = OpConstantSampler %samplert None 1 Nearest" + std::string(kVoidFVoid), std::vector{"LiteralSampler"}), std::make_pair(std::string(kGLSL450MemoryModel) + " OpEntryPoint Vertex %func \"shader\"" " %samplert = OpTypeSampler" " %sampler = OpConstantSampler %samplert ClampToEdge 1 Nearest" + std::string(kVoidFVoid), std::vector{"LiteralSampler"}), std::make_pair(std::string(kGLSL450MemoryModel) + " OpEntryPoint Vertex %func \"shader\"" " %samplert = OpTypeSampler" " %sampler = OpConstantSampler %samplert Clamp 1 Nearest" + std::string(kVoidFVoid), std::vector{"LiteralSampler"}), std::make_pair(std::string(kGLSL450MemoryModel) + " OpEntryPoint Vertex %func \"shader\"" " %samplert = OpTypeSampler" " %sampler = OpConstantSampler %samplert Repeat 1 Nearest" + std::string(kVoidFVoid), std::vector{"LiteralSampler"}), std::make_pair(std::string(kGLSL450MemoryModel) + " OpEntryPoint Vertex %func \"shader\"" " %samplert = OpTypeSampler" " %sampler = OpConstantSampler %samplert RepeatMirrored 1 Nearest" + std::string(kVoidFVoid), std::vector{"LiteralSampler"}) ))); // TODO(umar): Sampler Filter Mode // TODO(umar): Image Format // TODO(umar): Image Channel Order // TODO(umar): Image Channel Data Type // TODO(umar): Image Operands // TODO(umar): FP Fast Math Mode // TODO(umar): FP Rounding Mode // TODO(umar): Linkage Type // TODO(umar): Access Qualifier // TODO(umar): Function Parameter Attribute INSTANTIATE_TEST_SUITE_P(Decoration, ValidateCapability, Combine( ValuesIn(AllCapabilities()), Values( std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" "OpDecorate %var RelaxedPrecision\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Private %intt\n" "%var = OpVariable %ptr Private\n" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + // Block applies to struct type. "OpEntryPoint Kernel %func \"compute\" \n" "OpDecorate %block Block\n" "%intt = OpTypeInt 32 0\n" "%block = OpTypeStruct %intt\n" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + // BufferBlock applies to struct type. "OpEntryPoint Kernel %func \"compute\" \n" "OpDecorate %block BufferBlock\n" "%intt = OpTypeInt 32 0\n" "%block = OpTypeStruct %intt\n" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" "OpMemberDecorate %structt 0 RowMajor\n" "%floatt = OpTypeFloat 32\n" "%float2 = OpTypeVector %floatt 2\n" "%mat2x2 = OpTypeMatrix %float2 2\n" "%structt = OpTypeStruct %mat2x2\n" + std::string(kVoidFVoid), MatrixDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" "OpMemberDecorate %structt 0 ColMajor\n" "%floatt = OpTypeFloat 32\n" "%float2 = OpTypeVector %floatt 2\n" "%mat2x2 = OpTypeMatrix %float2 2\n" "%structt = OpTypeStruct %mat2x2\n" + std::string(kVoidFVoid), MatrixDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" "OpDecorate %array ArrayStride 4\n" "%intt = OpTypeInt 32 0\n" "%array = OpTypeRuntimeArray %intt\n" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" "OpMemberDecorate %structt 0 MatrixStride 8\n" "%floatt = OpTypeFloat 32\n" "%float2 = OpTypeVector %floatt 2\n" "%mat2x2 = OpTypeMatrix %float2 2\n" "%structt = OpTypeStruct %mat2x2\n" + std::string(kVoidFVoid), MatrixDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" "OpDecorate %struct GLSLShared\n" "%struct = OpTypeStruct\n" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" "OpDecorate %struct GLSLPacked\n" "%struct = OpTypeStruct\n" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kGLSL450MemoryModel) + "OpEntryPoint Vertex %func \"shader\" \n" "OpDecorate %struct CPacked\n" "%struct = OpTypeStruct\n" + std::string(kVoidFVoid), KernelDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" "OpDecorate %var NoPerspective\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" "OpDecorate %var Flat\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" "OpDecorate %var Patch\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), TessellationDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" "OpDecorate %var Centroid\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" "OpDecorate %var Sample\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), std::vector{"SampleRateShading"}), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" "OpDecorate %var Invariant\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" "OpDecorate %var Restrict\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), AllCapabilities()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" "OpDecorate %var Aliased\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), AllCapabilities()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" "OpDecorate %var Volatile\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), AllCapabilities()), std::make_pair(std::string(kGLSL450MemoryModel) + "OpEntryPoint Vertex %func \"shader\" \n" "OpDecorate %var Constant\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), KernelDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" "OpDecorate %var Coherent\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), AllCapabilities()), std::make_pair(std::string(kOpenCLMemoryModel) + // NonWritable must target something valid, such as a storage image. "OpEntryPoint Kernel %func \"compute\" \n" "OpDecorate %var NonWritable " "%float = OpTypeFloat 32 " "%imstor = OpTypeImage %float 2D 0 0 0 2 Unknown " "%ptr = OpTypePointer UniformConstant %imstor " "%var = OpVariable %ptr UniformConstant " + std::string(kVoidFVoid), AllCapabilities()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" "OpDecorate %var NonReadable " "%float = OpTypeFloat 32 " "%imstor = OpTypeImage %float 2D 0 0 0 2 Unknown " "%ptr = OpTypePointer UniformConstant %imstor " "%var = OpVariable %ptr UniformConstant " + std::string(kVoidFVoid), AllCapabilities()), std::make_pair(std::string(kOpenCLMemoryModel) + // Uniform must target a non-void value. "OpEntryPoint Kernel %func \"compute\" \n" "OpDecorate %int0 Uniform\n" "%intt = OpTypeInt 32 0\n" + "%int0 = OpConstantNull %intt" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kGLSL450MemoryModel) + "OpEntryPoint Vertex %func \"shader\" \n" "OpDecorate %intt SaturatedConversion\n" "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid), KernelDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" "OpDecorate %var Stream 0\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Output %intt\n" "%var = OpVariable %ptr Output\n" + std::string(kVoidFVoid), std::vector{"GeometryStreams"}), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" "OpMemberDecorate %struct 0 Location 0\n" "%intt = OpTypeInt 32 0\n" "%struct = OpTypeStruct %intt\n" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" "OpDecorate %var Component 0\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" "OpDecorate %var Index 0\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" "OpDecorate %var Binding 0\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Uniform %intt\n" "%var = OpVariable %ptr Uniform\n" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" "OpDecorate %var DescriptorSet 0\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Uniform %intt\n" "%var = OpVariable %ptr Uniform\n" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" "OpMemberDecorate %structt 0 Offset 0\n" "%intt = OpTypeInt 32 0\n" "%structt = OpTypeStruct %intt\n" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" "OpDecorate %var XfbBuffer 0\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Uniform %intt\n" "%var = OpVariable %ptr Uniform\n" + std::string(kVoidFVoid), std::vector{"TransformFeedback"}), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" "OpDecorate %var XfbStride 0\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Uniform %intt\n" "%var = OpVariable %ptr Uniform\n" + std::string(kVoidFVoid), std::vector{"TransformFeedback"}), std::make_pair(std::string(kGLSL450MemoryModel) + "OpEntryPoint Vertex %func \"shader\" \n" "OpDecorate %intt FuncParamAttr Zext\n" "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid), KernelDependencies()), std::make_pair(std::string(kGLSL450MemoryModel) + "OpEntryPoint Vertex %func \"shader\" \n" "OpDecorate %intt FPFastMathMode Fast\n" "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid), KernelDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" "OpDecorate %intt LinkageAttributes \"other\" Import\n" "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid), std::vector{"Linkage"}), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" "OpDecorate %intt NoContraction\n" "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" "OpDecorate %var InputAttachmentIndex 0\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer UniformConstant %intt\n" "%var = OpVariable %ptr UniformConstant\n" + std::string(kVoidFVoid), std::vector{"InputAttachment"}), std::make_pair(std::string(kGLSL450MemoryModel) + "OpEntryPoint Vertex %func \"shader\" \n" "OpDecorate %intt Alignment 4\n" "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid), KernelDependencies()) ))); // clang-format on INSTANTIATE_TEST_SUITE_P( DecorationSpecId, ValidateCapability, Combine( ValuesIn(AllSpirV10Capabilities()), Values(std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Vertex %func \"shader\" \n" + "OpDecorate %1 SpecId 1\n" "%intt = OpTypeInt 32 0\n" "%1 = OpSpecConstant %intt 0\n" + std::string(kVoidFVoid), ShaderDependencies())))); INSTANTIATE_TEST_SUITE_P( DecorationV11, ValidateCapabilityV11, Combine(ValuesIn(AllCapabilities()), Values(std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" "OpDecorate %p MaxByteOffset 0 " "%i32 = OpTypeInt 32 0 " "%pi32 = OpTypePointer Workgroup %i32 " "%p = OpVariable %pi32 Workgroup " + std::string(kVoidFVoid), AddressesDependencies()), // Trying to test OpDecorate here, but if this fails due to // incorrect OpMemoryModel validation, that must also be // fixed. std::make_pair( std::string("OpMemoryModel Logical OpenCL " "OpEntryPoint Kernel %func \"compute\" \n" "OpDecorate %1 SpecId 1 " "%intt = OpTypeInt 32 0 " "%1 = OpSpecConstant %intt 0") + std::string(kVoidFVoid), KernelDependencies()), std::make_pair( std::string("OpMemoryModel Logical Simple " "OpEntryPoint Vertex %func \"shader\" \n" "OpDecorate %1 SpecId 1 " "%intt = OpTypeInt 32 0 " "%1 = OpSpecConstant %intt 0") + std::string(kVoidFVoid), ShaderDependencies())))); // clang-format off INSTANTIATE_TEST_SUITE_P(BuiltIn, ValidateCapability, Combine( ValuesIn(AllCapabilities()), Values( std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" + "OpDecorate %var BuiltIn Position\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), ShaderDependencies()), // Just mentioning PointSize, ClipDistance, or CullDistance as a BuiltIn does // not trigger the requirement for the associated capability. // See https://github.com/KhronosGroup/SPIRV-Tools/issues/365 std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" + "OpDecorate %var BuiltIn PointSize\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), AllCapabilities()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" + "OpDecorate %var BuiltIn ClipDistance\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), AllCapabilities()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" + "OpDecorate %var BuiltIn CullDistance\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), AllCapabilities()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" + "OpDecorate %var BuiltIn VertexId\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" + "OpDecorate %var BuiltIn InstanceId\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" + "OpDecorate %var BuiltIn PrimitiveId\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), GeometryTessellationDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" + "OpDecorate %var BuiltIn InvocationId\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), GeometryTessellationDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" + "OpDecorate %var BuiltIn Layer\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), GeometryDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" + "OpDecorate %var BuiltIn ViewportIndex\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), std::vector{"MultiViewport"}), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" + "OpDecorate %var BuiltIn TessLevelOuter\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), TessellationDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" + "OpDecorate %var BuiltIn TessLevelInner\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), TessellationDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" + "OpDecorate %var BuiltIn TessCoord\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), TessellationDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" + "OpDecorate %var BuiltIn PatchVertices\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), TessellationDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" + "OpDecorate %var BuiltIn FragCoord\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" + "OpDecorate %var BuiltIn PointCoord\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" + "OpDecorate %var BuiltIn FrontFacing\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" + "OpDecorate %var BuiltIn SampleId\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), std::vector{"SampleRateShading"}), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" + "OpDecorate %var BuiltIn SamplePosition\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), std::vector{"SampleRateShading"}), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" + "OpDecorate %var BuiltIn SampleMask\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" + "OpDecorate %var BuiltIn FragDepth\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" + "OpDecorate %var BuiltIn HelperInvocation\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" + "OpDecorate %var BuiltIn VertexIndex\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" + "OpDecorate %var BuiltIn InstanceIndex\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" + "OpDecorate %var BuiltIn NumWorkgroups\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), AllCapabilities()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" + "OpDecorate %var BuiltIn WorkgroupId\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), AllCapabilities()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" + "OpDecorate %var BuiltIn LocalInvocationId\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), AllCapabilities()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" + "OpDecorate %var BuiltIn GlobalInvocationId\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), AllCapabilities()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" + "OpDecorate %var BuiltIn LocalInvocationIndex\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), AllCapabilities()), std::make_pair(std::string(kGLSL450MemoryModel) + "OpEntryPoint Vertex %func \"shader\" \n" + "OpDecorate %var BuiltIn WorkDim\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), KernelDependencies()), std::make_pair(std::string(kGLSL450MemoryModel) + "OpEntryPoint Vertex %func \"shader\" \n" + "OpDecorate %var BuiltIn GlobalSize\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), KernelDependencies()), std::make_pair(std::string(kGLSL450MemoryModel) + "OpEntryPoint Vertex %func \"shader\" \n" + "OpDecorate %var BuiltIn EnqueuedWorkgroupSize\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), KernelDependencies()), std::make_pair(std::string(kGLSL450MemoryModel) + "OpEntryPoint Vertex %func \"shader\" \n" + "OpDecorate %var BuiltIn GlobalOffset\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), KernelDependencies()), std::make_pair(std::string(kGLSL450MemoryModel) + "OpEntryPoint Vertex %func \"shader\" \n" + "OpDecorate %var BuiltIn GlobalLinearId\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), KernelDependencies()), std::make_pair(std::string(kGLSL450MemoryModel) + "OpEntryPoint Vertex %func \"shader\" \n" + "OpDecorate %var BuiltIn SubgroupSize\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), KernelAndGroupNonUniformDependencies()), std::make_pair(std::string(kGLSL450MemoryModel) + "OpEntryPoint Vertex %func \"shader\" \n" + "OpDecorate %var BuiltIn SubgroupMaxSize\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), KernelDependencies()), std::make_pair(std::string(kGLSL450MemoryModel) + "OpEntryPoint Vertex %func \"shader\" \n" + "OpDecorate %var BuiltIn NumSubgroups\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), KernelAndGroupNonUniformDependencies()), std::make_pair(std::string(kGLSL450MemoryModel) + "OpEntryPoint Vertex %func \"shader\" \n" + "OpDecorate %var BuiltIn NumEnqueuedSubgroups\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), KernelDependencies()), std::make_pair(std::string(kGLSL450MemoryModel) + "OpEntryPoint Vertex %func \"shader\" \n" + "OpDecorate %var BuiltIn SubgroupId\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), KernelAndGroupNonUniformDependencies()), std::make_pair(std::string(kGLSL450MemoryModel) + "OpEntryPoint Vertex %func \"shader\" \n" + "OpDecorate %var BuiltIn SubgroupLocalInvocationId\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), KernelAndGroupNonUniformDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" + "OpDecorate %var BuiltIn VertexIndex\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), ShaderDependencies()), std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" + "OpDecorate %var BuiltIn InstanceIndex\n" "%intt = OpTypeInt 32 0\n" "%ptr = OpTypePointer Input %intt\n" "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid), ShaderDependencies()) ))); // Ensure that mere mention of PointSize, ClipDistance, or CullDistance as // BuiltIns does not trigger the requirement for the associated // capability. // See https://github.com/KhronosGroup/SPIRV-Tools/issues/365 INSTANTIATE_TEST_SUITE_P(BuiltIn, ValidateCapabilityVulkan10, Combine( // All capabilities to try. ValuesIn(AllSpirV10Capabilities()), Values( std::make_pair(std::string(kGLSL450MemoryModel) + "OpEntryPoint Vertex %func \"shader\" %var\n" + "OpDecorate %var BuiltIn PointSize\n" "%float = OpTypeFloat 32\n" "%ptr_output_float = OpTypePointer Output %float\n" "%var = OpVariable %ptr_output_float Output\n" + std::string(kVoidFVoid), // Capabilities which should succeed. AllVulkan10Capabilities()), std::make_pair(std::string(kGLSL450MemoryModel) + "OpEntryPoint Vertex %func \"shader\" \n" "OpMemberDecorate %block 0 BuiltIn ClipDistance\n" "%f32 = OpTypeFloat 32\n" "%intt = OpTypeInt 32 0\n" "%intt_4 = OpConstant %intt 4\n" "%f32arr4 = OpTypeArray %f32 %intt_4\n" "%block = OpTypeStruct %f32arr4\n" + std::string(kVoidFVoid), AllVulkan10Capabilities()), std::make_pair(std::string(kGLSL450MemoryModel) + "OpEntryPoint Vertex %func \"shader\" \n" "OpMemberDecorate %block 0 BuiltIn CullDistance\n" "%f32 = OpTypeFloat 32\n" "%intt = OpTypeInt 32 0\n" "%intt_4 = OpConstant %intt 4\n" "%f32arr4 = OpTypeArray %f32 %intt_4\n" "%block = OpTypeStruct %f32arr4\n" + std::string(kVoidFVoid), AllVulkan10Capabilities()) ))); INSTANTIATE_TEST_SUITE_P(BuiltIn, ValidateCapabilityOpenGL40, Combine( // OpenGL 4.0 is based on SPIR-V 1.0 ValuesIn(AllSpirV10Capabilities()), Values( std::make_pair(std::string(kGLSL450MemoryModel) + "OpEntryPoint Vertex %func \"shader\" %var\n" + "OpDecorate %var BuiltIn PointSize\n" "%float = OpTypeFloat 32\n" "%ptr_output_float = OpTypePointer Output %float\n" "%var = OpVariable %ptr_output_float Output\n" + std::string(kVoidFVoid), AllSpirV10Capabilities()), std::make_pair(std::string(kGLSL450MemoryModel) + "OpEntryPoint Vertex %func \"shader\" %var\n" + "OpDecorate %var BuiltIn ClipDistance\n" "%float = OpTypeFloat 32\n" "%int = OpTypeInt 32 0\n" "%int_1 = OpConstant %int 1\n" "%array = OpTypeArray %float %int_1\n" "%ptr = OpTypePointer Output %array\n" "%var = OpVariable %ptr Output\n" + std::string(kVoidFVoid), AllSpirV10Capabilities()), std::make_pair(std::string(kGLSL450MemoryModel) + "OpEntryPoint Vertex %func \"shader\" %var\n" + "OpDecorate %var BuiltIn CullDistance\n" "%float = OpTypeFloat 32\n" "%int = OpTypeInt 32 0\n" "%int_1 = OpConstant %int 1\n" "%array = OpTypeArray %float %int_1\n" "%ptr = OpTypePointer Output %array\n" "%var = OpVariable %ptr Output\n" + std::string(kVoidFVoid), AllSpirV10Capabilities()) ))); INSTANTIATE_TEST_SUITE_P(Capabilities, ValidateCapabilityVulkan11, Combine( // All capabilities to try. ValuesIn(AllCapabilities()), Values( std::make_pair(std::string(kGLSL450MemoryModel) + "OpEntryPoint Vertex %func \"shader\" %var\n" + "OpDecorate %var BuiltIn PointSize\n" "%float = OpTypeFloat 32\n" "%ptr_output_float = OpTypePointer Output %float\n" "%var = OpVariable %ptr_output_float Output\n" + std::string(kVoidFVoid), AllVulkan11Capabilities()), std::make_pair(std::string(kGLSL450MemoryModel) + "OpEntryPoint Vertex %func \"shader\" %var\n" + "OpDecorate %var BuiltIn CullDistance\n" "%float = OpTypeFloat 32\n" "%int = OpTypeInt 32 0\n" "%int_1 = OpConstant %int 1\n" "%array = OpTypeArray %float %int_1\n" "%ptr = OpTypePointer Output %array\n" "%var = OpVariable %ptr Output\n" + std::string(kVoidFVoid), AllVulkan11Capabilities()) ))); INSTANTIATE_TEST_SUITE_P(Capabilities, ValidateCapabilityVulkan12, Combine( // All capabilities to try. ValuesIn(AllSpirV15Capabilities()), Values( std::make_pair(std::string(kGLSL450MemoryModel) + "OpEntryPoint Vertex %func \"shader\" %var\n" + "OpDecorate %var BuiltIn PointSize\n" "%float = OpTypeFloat 32\n" "%ptr_output_float = OpTypePointer Output %float\n" "%var = OpVariable %ptr_output_float Output\n" + std::string(kVoidFVoid), AllVulkan12Capabilities()), std::make_pair(std::string(kGLSL450MemoryModel) + "OpEntryPoint Vertex %func \"shader\" %var\n" + "OpDecorate %var BuiltIn CullDistance\n" "%float = OpTypeFloat 32\n" "%int = OpTypeInt 32 0\n" "%int_1 = OpConstant %int 1\n" "%array = OpTypeArray %float %int_1\n" "%ptr = OpTypePointer Output %array\n" "%var = OpVariable %ptr Output\n" + std::string(kVoidFVoid), AllVulkan12Capabilities()) ))); // TODO(umar): Selection Control // TODO(umar): Loop Control // TODO(umar): Function Control // TODO(umar): Memory Semantics // TODO(umar): Memory Access // TODO(umar): Scope // TODO(umar): Group Operation // TODO(umar): Kernel Enqueue Flags // TODO(umar): Kernel Profiling Flags INSTANTIATE_TEST_SUITE_P(MatrixOp, ValidateCapability, Combine( ValuesIn(AllCapabilities()), Values( std::make_pair(std::string(kOpenCLMemoryModel) + "OpEntryPoint Kernel %func \"compute\" \n" + "%f32 = OpTypeFloat 32\n" "%vec3 = OpTypeVector %f32 3\n" "%mat33 = OpTypeMatrix %vec3 3\n" + std::string(kVoidFVoid), MatrixDependencies())))); // clang-format on #if 0 // TODO(atgoo@github.com) The following test is not valid as it generates // invalid combinations of images, instructions and image operands. // // Creates assembly containing an OpImageFetch instruction using operands for // the image-operands part. The assembly defines constants %fzero and %izero // that can be used for operands where IDs are required. The assembly is valid, // apart from not declaring any capabilities required by the operands. string ImageOperandsTemplate(const std::string& operands) { ostringstream ss; // clang-format off ss << R"( OpCapability Kernel OpCapability Linkage OpMemoryModel Logical OpenCL %i32 = OpTypeInt 32 0 %f32 = OpTypeFloat 32 %v4i32 = OpTypeVector %i32 4 %timg = OpTypeImage %i32 2D 0 0 0 0 Unknown %pimg = OpTypePointer UniformConstant %timg %tfun = OpTypeFunction %i32 %vimg = OpVariable %pimg UniformConstant %izero = OpConstant %i32 0 %fzero = OpConstant %f32 0. %main = OpFunction %i32 None %tfun %lbl = OpLabel %img = OpLoad %timg %vimg %r1 = OpImageFetch %v4i32 %img %izero )" << operands << R"( OpReturnValue %izero OpFunctionEnd )"; // clang-format on return ss.str(); } INSTANTIATE_TEST_SUITE_P( TwoImageOperandsMask, ValidateCapability, Combine( ValuesIn(AllCapabilities()), Values(std::make_pair(ImageOperandsTemplate("Bias|Lod %fzero %fzero"), ShaderDependencies()), std::make_pair(ImageOperandsTemplate("Lod|Offset %fzero %izero"), std::vector{"ImageGatherExtended"}), std::make_pair(ImageOperandsTemplate("Sample|MinLod %izero %fzero"), std::vector{"MinLod"}), std::make_pair(ImageOperandsTemplate("Lod|Sample %fzero %izero"), AllCapabilities()))), ); #endif // TODO(umar): Instruction capability checks spv_result_t spvCoreOperandTableNameLookup(spv_target_env env, const spv_operand_table table, const spv_operand_type_t type, const char* name, const size_t nameLength) { if (!table) return SPV_ERROR_INVALID_TABLE; if (!name) return SPV_ERROR_INVALID_POINTER; for (uint64_t typeIndex = 0; typeIndex < table->count; ++typeIndex) { const auto& group = table->types[typeIndex]; if (type != group.type) continue; for (uint64_t index = 0; index < group.count; ++index) { const auto& entry = group.entries[index]; // Check for min version only. if (spvVersionForTargetEnv(env) >= entry.minVersion && nameLength == strlen(entry.name) && !strncmp(entry.name, name, nameLength)) { return SPV_SUCCESS; } } } return SPV_ERROR_INVALID_LOOKUP; } // True if capability exists in core spec of env. bool Exists(const std::string& capability, spv_target_env env) { ScopedContext sc(env); return SPV_SUCCESS == spvCoreOperandTableNameLookup(env, sc.context->operand_table, SPV_OPERAND_TYPE_CAPABILITY, capability.c_str(), capability.size()); } TEST_P(ValidateCapability, Capability) { const std::string capability = Capability(GetParam()); spv_target_env env = SPV_ENV_UNIVERSAL_1_0; if (!capability.empty()) { if (Exists(capability, SPV_ENV_UNIVERSAL_1_0)) env = SPV_ENV_UNIVERSAL_1_0; else if (Exists(capability, SPV_ENV_UNIVERSAL_1_1)) env = SPV_ENV_UNIVERSAL_1_1; else if (Exists(capability, SPV_ENV_UNIVERSAL_1_2)) env = SPV_ENV_UNIVERSAL_1_2; else env = SPV_ENV_UNIVERSAL_1_3; } const std::string test_code = MakeAssembly(GetParam()); CompileSuccessfully(test_code, env); ASSERT_EQ(ExpectedResult(GetParam()), ValidateInstructions(env)) << "target env: " << spvTargetEnvDescription(env) << "\ntest code:\n" << test_code; } TEST_P(ValidateCapabilityV11, Capability) { const std::string capability = Capability(GetParam()); if (Exists(capability, SPV_ENV_UNIVERSAL_1_1)) { const std::string test_code = MakeAssembly(GetParam()); CompileSuccessfully(test_code, SPV_ENV_UNIVERSAL_1_1); ASSERT_EQ(ExpectedResult(GetParam()), ValidateInstructions(SPV_ENV_UNIVERSAL_1_1)) << test_code; } } TEST_P(ValidateCapabilityVulkan10, Capability) { const std::string capability = Capability(GetParam()); if (Exists(capability, SPV_ENV_VULKAN_1_0)) { const std::string test_code = MakeAssembly(GetParam()); CompileSuccessfully(test_code, SPV_ENV_VULKAN_1_0); ASSERT_EQ(ExpectedResult(GetParam()), ValidateInstructions(SPV_ENV_VULKAN_1_0)) << test_code; } } TEST_P(ValidateCapabilityVulkan11, Capability) { const std::string capability = Capability(GetParam()); if (Exists(capability, SPV_ENV_VULKAN_1_1)) { const std::string test_code = MakeAssembly(GetParam()); CompileSuccessfully(test_code, SPV_ENV_VULKAN_1_1); ASSERT_EQ(ExpectedResult(GetParam()), ValidateInstructions(SPV_ENV_VULKAN_1_1)) << test_code; } } TEST_P(ValidateCapabilityVulkan12, Capability) { const std::string capability = Capability(GetParam()); if (Exists(capability, SPV_ENV_VULKAN_1_2)) { const std::string test_code = MakeAssembly(GetParam()); CompileSuccessfully(test_code, SPV_ENV_VULKAN_1_2); ASSERT_EQ(ExpectedResult(GetParam()), ValidateInstructions(SPV_ENV_VULKAN_1_2)) << test_code; } } TEST_P(ValidateCapabilityOpenGL40, Capability) { const std::string capability = Capability(GetParam()); if (Exists(capability, SPV_ENV_OPENGL_4_0)) { const std::string test_code = MakeAssembly(GetParam()); CompileSuccessfully(test_code, SPV_ENV_OPENGL_4_0); ASSERT_EQ(ExpectedResult(GetParam()), ValidateInstructions(SPV_ENV_OPENGL_4_0)) << test_code; } } TEST_F(ValidateCapability, SemanticsIdIsAnIdNotALiteral) { // From https://github.com/KhronosGroup/SPIRV-Tools/issues/248 // The validator was interpreting the memory semantics ID number // as the value to be checked rather than an ID that references // another value to be checked. // In this case a raw ID of 64 was mistaken to mean a literal // semantic value of UniformMemory, which would require the Shader // capability. const char str[] = R"( OpCapability Kernel OpCapability Linkage OpMemoryModel Logical OpenCL ; %i32 has ID 1 %i32 = OpTypeInt 32 0 %tf = OpTypeFunction %i32 %pi32 = OpTypePointer CrossWorkgroup %i32 %var = OpVariable %pi32 CrossWorkgroup %c = OpConstant %i32 100 %scope = OpConstant %i32 1 ; Device scope ; Fake an instruction with 64 as the result id. ; !64 = OpConstantNull %i32 !0x3002e !1 !64 %f = OpFunction %i32 None %tf %l = OpLabel %result = OpAtomicIAdd %i32 %var %scope !64 %c OpReturnValue %result OpFunctionEnd )"; CompileSuccessfully(str); // Since we are forcing usage of 64, the "id bound" in the binary header // must be overwritten so that 64 is considered within bound. // ID Bound is at index 3 of the binary. Set it to 65. OverwriteAssembledBinary(3, 65); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCapability, IntSignednessKernelGood) { const std::string spirv = R"( OpCapability Kernel OpCapability Linkage OpMemoryModel Logical OpenCL %i32 = OpTypeInt 32 0 )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCapability, IntSignednessKernelBad) { const std::string spirv = R"( OpCapability Kernel OpCapability Linkage OpMemoryModel Logical OpenCL %i32 = OpTypeInt 32 1 )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_BINARY, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("The Signedness in OpTypeInt must always be 0 when " "Kernel capability is used.")); } TEST_F(ValidateCapability, IntSignednessShaderGood) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %u32 = OpTypeInt 32 0 %i32 = OpTypeInt 32 1 )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCapability, NonVulkan10Capability) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %u32 = OpTypeInt 32 0 %i32 = OpTypeInt 32 1 )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Capability Linkage is not allowed by Vulkan 1.0")); } TEST_F(ValidateCapability, Vulkan10EnabledByExtension) { const std::string spirv = R"( OpCapability Shader OpCapability DrawParameters OpExtension "SPV_KHR_shader_draw_parameters" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %func "shader" OpMemberDecorate %block 0 BuiltIn PointSize %f32 = OpTypeFloat 32 %block = OpTypeStruct %f32 )" + std::string(kVoidFVoid); CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateCapability, Vulkan10NotEnabledByExtension) { const std::string spirv = R"( OpCapability Shader OpCapability DrawParameters OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %func "shader" OpDecorate %intt BuiltIn PointSize %intt = OpTypeInt 32 0 )" + std::string(kVoidFVoid); CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Capability DrawParameters is not allowed by Vulkan 1.0")); } TEST_F(ValidateCapability, NonOpenCL12FullCapability) { const std::string spirv = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpCapability Pipes OpMemoryModel Physical64 OpenCL %u32 = OpTypeInt 32 0 )"; CompileSuccessfully(spirv, SPV_ENV_OPENCL_1_2); EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY, ValidateInstructions(SPV_ENV_OPENCL_1_2)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Capability Pipes is not allowed by OpenCL 1.2 Full Profile")); } TEST_F(ValidateCapability, OpenCL12FullEnabledByCapability) { const std::string spirv = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpCapability ImageBasic OpCapability Sampled1D OpMemoryModel Physical64 OpenCL %u32 = OpTypeInt 32 0 )" + std::string(kVoidFVoid); CompileSuccessfully(spirv, SPV_ENV_OPENCL_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_OPENCL_1_2)); } TEST_F(ValidateCapability, OpenCL12FullNotEnabledByCapability) { const std::string spirv = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpCapability Sampled1D OpMemoryModel Physical64 OpenCL %u32 = OpTypeInt 32 0 )" + std::string(kVoidFVoid); CompileSuccessfully(spirv, SPV_ENV_OPENCL_1_2); EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY, ValidateInstructions(SPV_ENV_OPENCL_1_2)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Capability Sampled1D is not allowed by OpenCL 1.2 Full Profile")); } TEST_F(ValidateCapability, NonOpenCL12EmbeddedCapability) { const std::string spirv = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpCapability Int64 OpMemoryModel Physical64 OpenCL %u32 = OpTypeInt 32 0 )"; CompileSuccessfully(spirv, SPV_ENV_OPENCL_EMBEDDED_1_2); EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY, ValidateInstructions(SPV_ENV_OPENCL_EMBEDDED_1_2)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Capability Int64 is not allowed by OpenCL 1.2 Embedded Profile")); } TEST_F(ValidateCapability, OpenCL12EmbeddedEnabledByCapability) { const std::string spirv = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpCapability ImageBasic OpCapability Sampled1D OpMemoryModel Physical64 OpenCL %u32 = OpTypeInt 32 0 )" + std::string(kVoidFVoid); CompileSuccessfully(spirv, SPV_ENV_OPENCL_EMBEDDED_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_OPENCL_EMBEDDED_1_2)); } TEST_F(ValidateCapability, OpenCL12EmbeddedNotEnabledByCapability) { const std::string spirv = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpCapability Sampled1D OpMemoryModel Physical64 OpenCL %u32 = OpTypeInt 32 0 )" + std::string(kVoidFVoid); CompileSuccessfully(spirv, SPV_ENV_OPENCL_EMBEDDED_1_2); EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY, ValidateInstructions(SPV_ENV_OPENCL_EMBEDDED_1_2)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Capability Sampled1D is not allowed by OpenCL 1.2 " "Embedded Profile")); } TEST_F(ValidateCapability, OpenCL12EmbeddedNoLongerEnabledByCapability) { const std::string spirv = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpCapability Pipes OpMemoryModel Physical64 OpenCL %u32 = OpTypeInt 32 0 )" + std::string(kVoidFVoid); CompileSuccessfully(spirv, SPV_ENV_OPENCL_EMBEDDED_1_2); EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY, ValidateInstructions(SPV_ENV_OPENCL_EMBEDDED_1_2)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Capability Pipes is not allowed by OpenCL 1.2 " "Embedded Profile")); } TEST_F(ValidateCapability, OpenCL20FullCapability) { const std::string spirv = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpCapability Groups OpCapability Pipes OpMemoryModel Physical64 OpenCL %u32 = OpTypeInt 32 0 )"; CompileSuccessfully(spirv, SPV_ENV_OPENCL_2_0); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_OPENCL_2_0)); } TEST_F(ValidateCapability, NonOpenCL20FullCapability) { const std::string spirv = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpCapability Matrix OpMemoryModel Physical64 OpenCL %u32 = OpTypeInt 32 0 )"; CompileSuccessfully(spirv, SPV_ENV_OPENCL_2_0); EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY, ValidateInstructions(SPV_ENV_OPENCL_2_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Capability Matrix is not allowed by OpenCL 2.0/2.1 Full Profile")); } TEST_F(ValidateCapability, OpenCL20FullEnabledByCapability) { const std::string spirv = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpCapability ImageBasic OpCapability Sampled1D OpMemoryModel Physical64 OpenCL %u32 = OpTypeInt 32 0 )" + std::string(kVoidFVoid); CompileSuccessfully(spirv, SPV_ENV_OPENCL_2_0); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_OPENCL_2_0)); } TEST_F(ValidateCapability, OpenCL20FullNotEnabledByCapability) { const std::string spirv = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpCapability Sampled1D OpMemoryModel Physical64 OpenCL %u32 = OpTypeInt 32 0 )" + std::string(kVoidFVoid); CompileSuccessfully(spirv, SPV_ENV_OPENCL_2_0); EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY, ValidateInstructions(SPV_ENV_OPENCL_2_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Capability Sampled1D is not allowed by OpenCL 2.0/2.1 " "Full Profile")); } TEST_F(ValidateCapability, NonOpenCL20EmbeddedCapability) { const std::string spirv = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpCapability Int64 OpMemoryModel Physical64 OpenCL %u32 = OpTypeInt 32 0 )"; CompileSuccessfully(spirv, SPV_ENV_OPENCL_EMBEDDED_2_0); EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY, ValidateInstructions(SPV_ENV_OPENCL_EMBEDDED_2_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Capability Int64 is not allowed by OpenCL 2.0/2.1 " "Embedded Profile")); } TEST_F(ValidateCapability, OpenCL20EmbeddedEnabledByCapability) { const std::string spirv = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpCapability ImageBasic OpCapability Sampled1D OpMemoryModel Physical64 OpenCL %u32 = OpTypeInt 32 0 )" + std::string(kVoidFVoid); CompileSuccessfully(spirv, SPV_ENV_OPENCL_EMBEDDED_2_0); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_OPENCL_EMBEDDED_2_0)); } TEST_F(ValidateCapability, OpenCL20EmbeddedNotEnabledByCapability) { const std::string spirv = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpCapability Sampled1D OpMemoryModel Physical64 OpenCL %u32 = OpTypeInt 32 0 )" + std::string(kVoidFVoid); CompileSuccessfully(spirv, SPV_ENV_OPENCL_EMBEDDED_2_0); EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY, ValidateInstructions(SPV_ENV_OPENCL_EMBEDDED_2_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Capability Sampled1D is not allowed by OpenCL 2.0/2.1 " "Embedded Profile")); } TEST_F(ValidateCapability, OpenCL22FullCapability) { const std::string spirv = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpCapability PipeStorage OpMemoryModel Physical64 OpenCL %u32 = OpTypeInt 32 0 )"; CompileSuccessfully(spirv, SPV_ENV_OPENCL_2_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_OPENCL_2_2)); } TEST_F(ValidateCapability, NonOpenCL22FullCapability) { const std::string spirv = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpCapability Matrix OpMemoryModel Physical64 OpenCL %u32 = OpTypeInt 32 0 )"; CompileSuccessfully(spirv, SPV_ENV_OPENCL_2_2); EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY, ValidateInstructions(SPV_ENV_OPENCL_2_2)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Capability Matrix is not allowed by OpenCL 2.2 Full Profile")); } TEST_F(ValidateCapability, OpenCL22FullEnabledByCapability) { const std::string spirv = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpCapability ImageBasic OpCapability Sampled1D OpMemoryModel Physical64 OpenCL %u32 = OpTypeInt 32 0 )" + std::string(kVoidFVoid); CompileSuccessfully(spirv, SPV_ENV_OPENCL_2_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_OPENCL_2_2)); } TEST_F(ValidateCapability, OpenCL22FullNotEnabledByCapability) { const std::string spirv = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpCapability Sampled1D OpMemoryModel Physical64 OpenCL %u32 = OpTypeInt 32 0 )" + std::string(kVoidFVoid); CompileSuccessfully(spirv, SPV_ENV_OPENCL_2_2); EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY, ValidateInstructions(SPV_ENV_OPENCL_2_2)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Capability Sampled1D is not allowed by OpenCL 2.2 Full Profile")); } TEST_F(ValidateCapability, NonOpenCL22EmbeddedCapability) { const std::string spirv = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpCapability Int64 OpMemoryModel Physical64 OpenCL %u32 = OpTypeInt 32 0 )"; CompileSuccessfully(spirv, SPV_ENV_OPENCL_EMBEDDED_2_2); EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY, ValidateInstructions(SPV_ENV_OPENCL_EMBEDDED_2_2)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Capability Int64 is not allowed by OpenCL 2.2 Embedded Profile")); } TEST_F(ValidateCapability, OpenCL22EmbeddedEnabledByCapability) { const std::string spirv = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpCapability ImageBasic OpCapability Sampled1D OpMemoryModel Physical64 OpenCL %u32 = OpTypeInt 32 0 )" + std::string(kVoidFVoid); CompileSuccessfully(spirv, SPV_ENV_OPENCL_EMBEDDED_2_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_OPENCL_EMBEDDED_2_2)); } TEST_F(ValidateCapability, OpenCL22EmbeddedNotEnabledByCapability) { const std::string spirv = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpCapability Sampled1D OpMemoryModel Physical64 OpenCL %u32 = OpTypeInt 32 0 )" + std::string(kVoidFVoid); CompileSuccessfully(spirv, SPV_ENV_OPENCL_EMBEDDED_2_2); EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY, ValidateInstructions(SPV_ENV_OPENCL_EMBEDDED_2_2)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Capability Sampled1D is not allowed by OpenCL 2.2 " "Embedded Profile")); } // Three tests to check enablement of an enum (a decoration) which is not // in core, and is directly enabled by a capability, but not directly enabled // by an extension. See https://github.com/KhronosGroup/SPIRV-Tools/issues/1596 TEST_F(ValidateCapability, DecorationFromExtensionMissingEnabledByCapability) { // Decoration ViewportRelativeNV is enabled by ShaderViewportMaskNV, which in // turn is enabled by SPV_NV_viewport_array2. const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical Simple OpDecorate %void ViewportRelativeNV )" + std::string(kVoidFVoid); CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_0); EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY, ValidateInstructions(SPV_ENV_UNIVERSAL_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Operand 2 of Decorate requires one of these " "capabilities: ShaderViewportMaskNV")); } TEST_F(ValidateCapability, CapabilityEnabledByMissingExtension) { // Capability ShaderViewportMaskNV is enabled by SPV_NV_viewport_array2. const std::string spirv = R"( OpCapability Shader OpCapability ShaderViewportMaskNV OpMemoryModel Logical Simple )" + std::string(kVoidFVoid); CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_0); EXPECT_EQ(SPV_ERROR_MISSING_EXTENSION, ValidateInstructions(SPV_ENV_UNIVERSAL_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("operand ShaderViewportMaskNV(5255) requires one of " "these extensions: SPV_NV_viewport_array2")); } TEST_F(ValidateCapability, DecorationEnabledByCapabilityEnabledByPresentExtension) { // Decoration ViewportRelativeNV is enabled by ShaderViewportMaskNV, which in // turn is enabled by SPV_NV_viewport_array2. const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability ShaderViewportMaskNV OpExtension "SPV_NV_viewport_array2" OpMemoryModel Logical Simple OpDecorate %void ViewportRelativeNV %void = OpTypeVoid )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_0); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_0)) << getDiagnosticString(); } // Three tests to check enablement of an instruction which is not in core, and // is directly enabled by a capability, but not directly enabled by an // extension. See https://github.com/KhronosGroup/SPIRV-Tools/issues/1624 // Instruction OpSubgroupShuffleINTEL is enabled by SubgroupShuffleINTEL, which // in turn is enabled by SPV_INTEL_subgroups. TEST_F(ValidateCapability, InstructionFromExtensionMissingEnabledByCapability) { // Decoration ViewportRelativeNV is enabled by ShaderViewportMaskNV, which in // turn is enabled by SPV_NV_viewport_array2. const std::string spirv = R"( OpCapability Kernel OpCapability Addresses ; OpCapability SubgroupShuffleINTEL OpExtension "SPV_INTEL_subgroups" OpMemoryModel Physical32 OpenCL OpEntryPoint Kernel %main "main" %void = OpTypeVoid %uint = OpTypeInt 32 0 %voidfn = OpTypeFunction %void %zero = OpConstant %uint 0 %main = OpFunction %void None %voidfn %entry = OpLabel %foo = OpSubgroupShuffleINTEL %uint %zero %zero OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_0); EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY, ValidateInstructions(SPV_ENV_UNIVERSAL_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Opcode SubgroupShuffleINTEL requires one of these " "capabilities: SubgroupShuffleINTEL")); } TEST_F(ValidateCapability, InstructionEnablingCapabilityEnabledByMissingExtension) { const std::string spirv = R"( OpCapability Kernel OpCapability Addresses OpCapability SubgroupShuffleINTEL ; OpExtension "SPV_INTEL_subgroups" OpMemoryModel Physical32 OpenCL OpEntryPoint Kernel %main "main" %void = OpTypeVoid %uint = OpTypeInt 32 0 %voidfn = OpTypeFunction %void %zero = OpConstant %uint 0 %main = OpFunction %void None %voidfn %entry = OpLabel %foo = OpSubgroupShuffleINTEL %uint %zero %zero OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_0); EXPECT_EQ(SPV_ERROR_MISSING_EXTENSION, ValidateInstructions(SPV_ENV_UNIVERSAL_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("operand SubgroupShuffleINTEL(5568) requires one of " "these extensions: SPV_INTEL_subgroups")); } TEST_F(ValidateCapability, InstructionEnabledByCapabilityEnabledByPresentExtension) { const std::string spirv = R"( OpCapability Kernel OpCapability Addresses OpCapability SubgroupShuffleINTEL OpExtension "SPV_INTEL_subgroups" OpMemoryModel Physical32 OpenCL OpEntryPoint Kernel %main "main" %void = OpTypeVoid %uint = OpTypeInt 32 0 %voidfn = OpTypeFunction %void %zero = OpConstant %uint 0 %main = OpFunction %void None %voidfn %entry = OpLabel %foo = OpSubgroupShuffleINTEL %uint %zero %zero OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_0); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_0)) << getDiagnosticString(); } TEST_F(ValidateCapability, VulkanMemoryModelWithVulkanKHR) { const std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability Linkage OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)) << getDiagnosticString(); } TEST_F(ValidateCapability, VulkanMemoryModelWithGLSL450) { const std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability Linkage OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical GLSL450 )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("VulkanMemoryModelKHR capability must only be " "specified if the VulkanKHR memory model is used")); } // In the grammar, SubgroupEqMask and SubgroupMaskKHR have different enabling // lists of extensions. TEST_F(ValidateCapability, SubgroupEqMaskEnabledByExtension) { const std::string spirv = R"( OpCapability Shader OpCapability SubgroupBallotKHR OpExtension "SPV_KHR_shader_ballot" OpMemoryModel Logical Simple OpEntryPoint GLCompute %main "main" OpDecorate %var BuiltIn SubgroupEqMask %void = OpTypeVoid %uint = OpTypeInt 32 0 %ptr_uint = OpTypePointer Private %uint %var = OpVariable %ptr_uint Private %fn = OpTypeFunction %void %main = OpFunction %void None %fn %entry = OpLabel %val = OpLoad %uint %var OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_0); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_0)) << getDiagnosticString(); } // Test that extensions incorporated into SPIR-V 1.5 no longer require // the associated OpExtension instruction. Test one capability per extension. struct CapabilityExtensionVersionCase { std::string capability; std::string capability_new_name; std::string extension; spv_target_env last_version_requiring_extension; spv_target_env first_version_in_core; }; using ValidateCapabilityExtensionVersionTest = spvtest::ValidateBase; // Returns a minimal shader module with the given capability instruction. std::string MinimalShaderModuleWithCapability(std::string cap) { std::string mem_model = (cap.find("VulkanMemory") == 0) ? "VulkanKHR" : "GLSL450"; std::string extra_cap = (cap.find("VulkanMemoryModelDeviceScope") == 0) ? "\nOpCapability VulkanMemoryModelKHR\n" : ""; return std::string("OpCapability ") + cap + extra_cap + R"( OpCapability Shader OpMemoryModel Logical )" + mem_model + R"( OpEntryPoint Vertex %main "main" %void = OpTypeVoid %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; } TEST_P(ValidateCapabilityExtensionVersionTest, FailsInOlderSpirvVersion) { const auto spirv = MinimalShaderModuleWithCapability(GetParam().capability); CompileSuccessfully(spirv, GetParam().last_version_requiring_extension); EXPECT_EQ(SPV_ERROR_MISSING_EXTENSION, ValidateInstructions(GetParam().last_version_requiring_extension)); EXPECT_THAT(getDiagnosticString(), HasSubstr(std::string("1st operand of Capability: operand ") + GetParam().capability_new_name)) << spirv << "\n"; EXPECT_THAT(getDiagnosticString(), HasSubstr(std::string("requires one of these extensions: ") + GetParam().extension)); } TEST_P(ValidateCapabilityExtensionVersionTest, SucceedsInNewerSpirvVersionWithOldName) { const auto spirv = MinimalShaderModuleWithCapability(GetParam().capability); CompileSuccessfully(spirv, GetParam().first_version_in_core); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(GetParam().first_version_in_core)); EXPECT_THAT(getDiagnosticString(), Eq("")) << spirv << "\n"; } TEST_P(ValidateCapabilityExtensionVersionTest, SucceedsInNewerSpirvVersionWithNewName) { const auto spirv = MinimalShaderModuleWithCapability(GetParam().capability_new_name); CompileSuccessfully(spirv, GetParam().first_version_in_core); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(GetParam().first_version_in_core)); EXPECT_THAT(getDiagnosticString(), Eq("")) << spirv << "\n"; } std::vector CapVersionCases1_5() { #define IN15NOSUFFIX(C, E) \ { C, C, E, SPV_ENV_UNIVERSAL_1_4, SPV_ENV_UNIVERSAL_1_5 } #define IN15(C, C_WITHOUT_SUFFIX, E) \ { C, C_WITHOUT_SUFFIX, E, SPV_ENV_UNIVERSAL_1_4, SPV_ENV_UNIVERSAL_1_5 } return std::vector{ // SPV_KHR_8bit_storage IN15NOSUFFIX("StorageBuffer8BitAccess", "SPV_KHR_8bit_storage"), IN15NOSUFFIX("UniformAndStorageBuffer8BitAccess", "SPV_KHR_8bit_storage"), IN15NOSUFFIX("StoragePushConstant8", "SPV_KHR_8bit_storage"), // SPV_EXT_descriptor_indexing IN15("ShaderNonUniformEXT", "ShaderNonUniform", "SPV_EXT_descriptor_indexing"), IN15("RuntimeDescriptorArrayEXT", "RuntimeDescriptorArray", "SPV_EXT_descriptor_indexing"), IN15("InputAttachmentArrayDynamicIndexingEXT", "InputAttachmentArrayDynamicIndexing", "SPV_EXT_descriptor_indexing"), IN15("UniformTexelBufferArrayDynamicIndexingEXT", "UniformTexelBufferArrayDynamicIndexing", "SPV_EXT_descriptor_indexing"), IN15("StorageTexelBufferArrayDynamicIndexingEXT", "StorageTexelBufferArrayDynamicIndexing", "SPV_EXT_descriptor_indexing"), IN15("UniformBufferArrayNonUniformIndexingEXT", "UniformBufferArrayNonUniformIndexing", "SPV_EXT_descriptor_indexing"), IN15("SampledImageArrayNonUniformIndexingEXT", "SampledImageArrayNonUniformIndexing", "SPV_EXT_descriptor_indexing"), IN15("StorageBufferArrayNonUniformIndexingEXT", "StorageBufferArrayNonUniformIndexing", "SPV_EXT_descriptor_indexing"), IN15("StorageImageArrayNonUniformIndexingEXT", "StorageImageArrayNonUniformIndexing", "SPV_EXT_descriptor_indexing"), IN15("InputAttachmentArrayNonUniformIndexingEXT", "InputAttachmentArrayNonUniformIndexing", "SPV_EXT_descriptor_indexing"), IN15("UniformTexelBufferArrayNonUniformIndexingEXT", "UniformTexelBufferArrayNonUniformIndexing", "SPV_EXT_descriptor_indexing"), IN15("StorageTexelBufferArrayNonUniformIndexingEXT", "StorageTexelBufferArrayNonUniformIndexing", "SPV_EXT_descriptor_indexing"), // SPV_EXT_physical_storage_buffer IN15("PhysicalStorageBufferAddresses", "PhysicalStorageBufferAddresses", "SPV_EXT_physical_storage_buffer"), // SPV_KHR_vulkan_memory_model IN15("VulkanMemoryModelKHR", "VulkanMemoryModel", "SPV_KHR_vulkan_memory_model"), IN15("VulkanMemoryModelDeviceScopeKHR", "VulkanMemoryModelDeviceScope", "SPV_KHR_vulkan_memory_model"), }; #undef IN15 } INSTANTIATE_TEST_SUITE_P(NewInSpirv1_5, ValidateCapabilityExtensionVersionTest, ValuesIn(CapVersionCases1_5())); TEST_P(ValidateCapability, CapShaderViewportIndexLayerFailsInOlderSpirvVersion) { const auto spirv = MinimalShaderModuleWithCapability("ShaderViewportIndexLayerEXT"); CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_MISSING_EXTENSION, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "1st operand of Capability: operand ShaderViewportIndexLayerEXT")); EXPECT_THAT(getDiagnosticString(), HasSubstr("requires one of these extensions: " "SPV_EXT_shader_viewport_index_layer")); } TEST_P(ValidateCapability, CapShaderViewportIndexLayerFailsInNewSpirvVersion) { const auto spirv = MinimalShaderModuleWithCapability("ShaderViewportIndexLayerEXT"); CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_5); EXPECT_EQ(SPV_ERROR_MISSING_EXTENSION, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "1st operand of Capability: operand ShaderViewportIndexLayerEXT")); EXPECT_THAT(getDiagnosticString(), HasSubstr("requires one of these extensions: " "SPV_EXT_shader_viewport_index_layer")); } TEST_F(ValidateCapability, CapShaderViewportIndexSucceedsInNewSpirvVersion) { const auto spirv = MinimalShaderModuleWithCapability("ShaderViewportIndex"); CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_5); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateCapability, CapShaderLayerSucceedsInNewSpirvVersion) { const auto spirv = MinimalShaderModuleWithCapability("ShaderLayer"); CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_5); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); EXPECT_THAT(getDiagnosticString(), Eq("")); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_cfg_test.cpp000066400000000000000000004353651475742701700234560ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validation tests for Control Flow Graph #include #include #include #include #include #include #include "gmock/gmock.h" #include "source/spirv_target_env.h" #include "source/val/validate.h" #include "test/test_fixture.h" #include "test/unit_spirv.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::HasSubstr; using ::testing::MatchesRegex; using ValidateCFG = spvtest::ValidateBase; using spvtest::ScopedContext; std::string nameOps() { return ""; } template std::string nameOps(std::pair head, Args... names) { return "OpName %" + head.first + " \"" + head.second + "\"\n" + nameOps(names...); } template std::string nameOps(std::string head, Args... names) { return "OpName %" + head + " \"" + head + "\"\n" + nameOps(names...); } /// This class allows the easy creation of complex control flow without writing /// SPIR-V. This class is used in the test cases below. class Block { std::string label_; std::string body_; spv::Op type_; std::vector successors_; public: /// Creates a Block with a given label /// /// @param[in]: label the label id of the block /// @param[in]: type the branch instruction that ends the block explicit Block(std::string label, spv::Op type = spv::Op::OpBranch) : label_(label), body_(), type_(type), successors_() {} /// Sets the instructions which will appear in the body of the block Block& SetBody(std::string body) { body_ = body; return *this; } Block& AppendBody(std::string body) { body_ += body; return *this; } /// Converts the block into a SPIR-V string operator std::string() { std::stringstream out; out << std::setw(8) << "%" + label_ + " = OpLabel \n"; if (!body_.empty()) { out << body_; } switch (type_) { case spv::Op::OpBranchConditional: out << "OpBranchConditional %cond "; for (Block& b : successors_) { out << "%" + b.label_ + " "; } break; case spv::Op::OpSwitch: { out << "OpSwitch %one %" + successors_.front().label_; std::stringstream ss; for (size_t i = 1; i < successors_.size(); i++) { ss << " " << i << " %" << successors_[i].label_; } out << ss.str(); } break; case spv::Op::OpLoopMerge: { assert(successors_.size() == 2); out << "OpLoopMerge %" + successors_[0].label_ + " %" + successors_[0].label_ + "None"; } break; case spv::Op::OpReturn: assert(successors_.size() == 0); out << "OpReturn\n"; break; case spv::Op::OpUnreachable: assert(successors_.size() == 0); out << "OpUnreachable\n"; break; case spv::Op::OpBranch: assert(successors_.size() == 1); out << "OpBranch %" + successors_.front().label_; break; case spv::Op::OpKill: assert(successors_.size() == 0); out << "OpKill\n"; break; default: assert(1 == 0 && "Unhandled"); } out << "\n"; return out.str(); } friend Block& operator>>(Block& curr, std::vector successors); friend Block& operator>>(Block& lhs, Block& successor); }; /// Assigns the successors for the Block on the lhs Block& operator>>(Block& lhs, std::vector successors) { if (lhs.type_ == spv::Op::OpBranchConditional) { assert(successors.size() == 2); } else if (lhs.type_ == spv::Op::OpSwitch) { assert(successors.size() > 1); } lhs.successors_ = successors; return lhs; } /// Assigns the successor for the Block on the lhs Block& operator>>(Block& lhs, Block& successor) { assert(lhs.type_ == spv::Op::OpBranch); lhs.successors_.push_back(successor); return lhs; } const std::string& GetDefaultHeader(spv::Capability cap) { static const std::string shader_header = "OpCapability Shader\n" "OpCapability Linkage\n" "OpMemoryModel Logical GLSL450\n"; static const std::string kernel_header = "OpCapability Kernel\n" "OpCapability Linkage\n" "OpMemoryModel Logical OpenCL\n"; return (cap == spv::Capability::Shader) ? shader_header : kernel_header; } const std::string& types_consts() { static const std::string types = "%voidt = OpTypeVoid\n" "%boolt = OpTypeBool\n" "%intt = OpTypeInt 32 0\n" "%one = OpConstant %intt 1\n" "%two = OpConstant %intt 2\n" "%ptrt = OpTypePointer Function %intt\n" "%funct = OpTypeFunction %voidt\n"; return types; } INSTANTIATE_TEST_SUITE_P(StructuredControlFlow, ValidateCFG, ::testing::Values(spv::Capability::Shader, spv::Capability::Kernel)); TEST_P(ValidateCFG, LoopReachableFromEntryButNeverLeadingToReturn) { // In this case, the loop is reachable from a node without a predecessor, // but never reaches a node with a return. // // This motivates the need for the pseudo-exit node to have a node // from a cycle in its predecessors list. Otherwise the validator's // post-dominance calculation will go into an infinite loop. // // For more motivation, see // https://github.com/KhronosGroup/SPIRV-Tools/issues/279 std::string str = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %entry "entry" OpName %loop "loop" OpName %exit "exit" %voidt = OpTypeVoid %funct = OpTypeFunction %voidt %main = OpFunction %voidt None %funct %entry = OpLabel OpBranch %loop %loop = OpLabel OpLoopMerge %exit %loop None OpBranch %loop %exit = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()) << str; } TEST_P(ValidateCFG, LoopUnreachableFromEntryButLeadingToReturn) { // In this case, the loop is not reachable from a node without a // predecessor, but eventually reaches a node with a return. // // This motivates the need for the pseudo-entry node to have a node // from a cycle in its successors list. Otherwise the validator's // dominance calculation will go into an infinite loop. // // For more motivation, see // https://github.com/KhronosGroup/SPIRV-Tools/issues/279 // Before that fix, we'd have an infinite loop when calculating // post-dominators. std::string str = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %entry "entry" OpName %loop "loop" OpName %cont "cont" OpName %exit "exit" %voidt = OpTypeVoid %funct = OpTypeFunction %voidt %boolt = OpTypeBool %false = OpConstantFalse %boolt %main = OpFunction %voidt None %funct %entry = OpLabel OpReturn %loop = OpLabel OpLoopMerge %exit %cont None OpBranch %cont %cont = OpLabel OpBranchConditional %false %loop %exit %exit = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()) << str << getDiagnosticString(); } TEST_P(ValidateCFG, Simple) { bool is_shader = GetParam() == spv::Capability::Shader; Block entry("entry"); Block loop("loop", spv::Op::OpBranchConditional); Block cont("cont"); Block merge("merge", spv::Op::OpReturn); entry.SetBody("%cond = OpSLessThan %boolt %one %two\n"); if (is_shader) { loop.SetBody("OpLoopMerge %merge %cont None\n"); } std::string str = GetDefaultHeader(GetParam()) + nameOps("loop", "entry", "cont", "merge", std::make_pair("func", "Main")) + types_consts() + "%func = OpFunction %voidt None %funct\n"; str += entry >> loop; str += loop >> std::vector({cont, merge}); str += cont >> loop; str += merge; str += "OpFunctionEnd\n"; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateCFG, Variable) { Block entry("entry"); Block cont("cont"); Block exit("exit", spv::Op::OpReturn); entry.SetBody("%var = OpVariable %ptrt Function\n"); std::string str = GetDefaultHeader(GetParam()) + nameOps(std::make_pair("func", "Main")) + types_consts() + " %func = OpFunction %voidt None %funct\n"; str += entry >> cont; str += cont >> exit; str += exit; str += "OpFunctionEnd\n"; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateCFG, VariableNotInFirstBlockBad) { Block entry("entry"); Block cont("cont"); Block exit("exit", spv::Op::OpReturn); // This operation should only be performed in the entry block cont.SetBody("%var = OpVariable %ptrt Function\n"); std::string str = GetDefaultHeader(GetParam()) + nameOps(std::make_pair("func", "Main")) + types_consts() + " %func = OpFunction %voidt None %funct\n"; str += entry >> cont; str += cont >> exit; str += exit; str += "OpFunctionEnd\n"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("All OpVariable instructions in a function must be the " "first instructions in the first block")); } TEST_P(ValidateCFG, BlockSelfLoopIsOk) { bool is_shader = GetParam() == spv::Capability::Shader; Block entry("entry"); Block loop("loop", spv::Op::OpBranchConditional); Block merge("merge", spv::Op::OpReturn); entry.SetBody("%cond = OpSLessThan %boolt %one %two\n"); if (is_shader) loop.SetBody("OpLoopMerge %merge %loop None\n"); std::string str = GetDefaultHeader(GetParam()) + nameOps("loop", "merge", std::make_pair("func", "Main")) + types_consts() + "%func = OpFunction %voidt None %funct\n"; str += entry >> loop; // loop branches to itself, but does not trigger an error. str += loop >> std::vector({merge, loop}); str += merge; str += "OpFunctionEnd\n"; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()) << getDiagnosticString(); } TEST_P(ValidateCFG, BlockAppearsBeforeDominatorBad) { bool is_shader = GetParam() == spv::Capability::Shader; Block entry("entry"); Block cont("cont"); Block branch("branch", spv::Op::OpBranchConditional); Block merge("merge", spv::Op::OpReturn); entry.SetBody("%cond = OpSLessThan %boolt %one %two\n"); if (is_shader) branch.SetBody("OpSelectionMerge %merge None\n"); std::string str = GetDefaultHeader(GetParam()) + nameOps("cont", "branch", std::make_pair("func", "Main")) + types_consts() + "%func = OpFunction %voidt None %funct\n"; str += entry >> branch; str += cont >> merge; // cont appears before its dominator str += branch >> std::vector({cont, merge}); str += merge; str += "OpFunctionEnd\n"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), MatchesRegex("Block '.\\[%cont\\]' appears in the binary " "before its dominator '.\\[%branch\\]'\n" " %branch = OpLabel\n")); } TEST_P(ValidateCFG, MergeBlockTargetedByMultipleHeaderBlocksBad) { bool is_shader = GetParam() == spv::Capability::Shader; Block entry("entry"); Block loop("loop"); Block selection("selection", spv::Op::OpBranchConditional); Block merge("merge", spv::Op::OpReturn); entry.SetBody("%cond = OpSLessThan %boolt %one %two\n"); if (is_shader) loop.SetBody(" OpLoopMerge %merge %loop None\n"); // cannot share the same merge if (is_shader) selection.SetBody("OpSelectionMerge %merge None\n"); std::string str = GetDefaultHeader(GetParam()) + nameOps("merge", std::make_pair("func", "Main")) + types_consts() + "%func = OpFunction %voidt None %funct\n"; str += entry >> loop; str += loop >> selection; str += selection >> std::vector({loop, merge}); str += merge; str += "OpFunctionEnd\n"; CompileSuccessfully(str); if (is_shader) { ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), MatchesRegex("Block '.\\[%merge\\]' is already a merge block " "for another header\n" " %Main = OpFunction %void None %9\n")); } else { ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } } TEST_P(ValidateCFG, MergeBlockTargetedByMultipleHeaderBlocksSelectionBad) { bool is_shader = GetParam() == spv::Capability::Shader; Block entry("entry"); Block loop("loop", spv::Op::OpBranchConditional); Block selection("selection", spv::Op::OpBranchConditional); Block merge("merge", spv::Op::OpReturn); entry.SetBody("%cond = OpSLessThan %boolt %one %two\n"); if (is_shader) selection.SetBody(" OpSelectionMerge %merge None\n"); // cannot share the same merge if (is_shader) loop.SetBody(" OpLoopMerge %merge %loop None\n"); std::string str = GetDefaultHeader(GetParam()) + nameOps("merge", std::make_pair("func", "Main")) + types_consts() + "%func = OpFunction %voidt None %funct\n"; str += entry >> selection; str += selection >> std::vector({merge, loop}); str += loop >> std::vector({loop, merge}); str += merge; str += "OpFunctionEnd\n"; CompileSuccessfully(str); if (is_shader) { ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), MatchesRegex("Block '.\\[%merge\\]' is already a merge block " "for another header\n" " %Main = OpFunction %void None %9\n")); } else { ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } } TEST_P(ValidateCFG, BranchTargetFirstBlockBadSinceEntryBlock) { Block entry("entry"); Block bad("bad"); Block end("end", spv::Op::OpReturn); std::string str = GetDefaultHeader(GetParam()) + nameOps("entry", "bad", std::make_pair("func", "Main")) + types_consts() + "%func = OpFunction %voidt None %funct\n"; str += entry >> bad; str += bad >> entry; // Cannot target entry block str += end; str += "OpFunctionEnd\n"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), MatchesRegex("First block '.\\[%entry\\]' of function " "'.\\[%Main\\]' is targeted by block '.\\[%bad\\]'\n" " %Main = OpFunction %void None %10\n")); } TEST_P(ValidateCFG, BranchTargetFirstBlockBadSinceValue) { Block entry("entry"); entry.SetBody("%undef = OpUndef %boolt\n"); Block bad("bad"); Block end("end", spv::Op::OpReturn); Block badvalue("undef"); // This references the OpUndef. std::string str = GetDefaultHeader(GetParam()) + nameOps("entry", "bad", std::make_pair("func", "Main")) + types_consts() + "%func = OpFunction %voidt None %funct\n"; str += entry >> bad; str += bad >> badvalue; // Check branch to a function value (it's not a block!) str += end; str += "OpFunctionEnd\n"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("'Target Label' operands for OpBranch must " "be the ID of an OpLabel instruction")); } TEST_P(ValidateCFG, BranchConditionalTrueTargetFirstBlockBad) { Block entry("entry"); Block bad("bad", spv::Op::OpBranchConditional); Block exit("exit", spv::Op::OpReturn); entry.SetBody("%cond = OpSLessThan %boolt %one %two\n"); bad.SetBody(" OpLoopMerge %entry %exit None\n"); std::string str = GetDefaultHeader(GetParam()) + nameOps("entry", "bad", std::make_pair("func", "Main")) + types_consts() + "%func = OpFunction %voidt None %funct\n"; str += entry >> bad; str += bad >> std::vector({entry, exit}); // cannot target entry block str += exit; str += "OpFunctionEnd\n"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), MatchesRegex("First block '.\\[%entry\\]' of function '.\\[%Main\\]' " "is targeted by block '.\\[%bad\\]'\n" " %Main = OpFunction %void None %10\n")); } TEST_P(ValidateCFG, BranchConditionalFalseTargetFirstBlockBad) { Block entry("entry"); Block bad("bad", spv::Op::OpBranchConditional); Block t("t"); Block merge("merge"); Block end("end", spv::Op::OpReturn); entry.SetBody("%cond = OpSLessThan %boolt %one %two\n"); bad.SetBody("OpLoopMerge %merge %cont None\n"); std::string str = GetDefaultHeader(GetParam()) + nameOps("entry", "bad", std::make_pair("func", "Main")) + types_consts() + "%func = OpFunction %voidt None %funct\n"; str += entry >> bad; str += bad >> std::vector({t, entry}); str += merge >> end; str += end; str += "OpFunctionEnd\n"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), MatchesRegex("First block '.\\[%entry\\]' of function '.\\[%Main\\]' " "is targeted by block '.\\[%bad\\]'\n" " %Main = OpFunction %void None %10\n")); } TEST_P(ValidateCFG, SwitchTargetFirstBlockBad) { Block entry("entry"); Block bad("bad", spv::Op::OpSwitch); Block block1("block1"); Block block2("block2"); Block block3("block3"); Block def("def"); // default block Block merge("merge"); Block end("end", spv::Op::OpReturn); entry.SetBody("%cond = OpSLessThan %boolt %one %two\n"); bad.SetBody("OpSelectionMerge %merge None\n"); std::string str = GetDefaultHeader(GetParam()) + nameOps("entry", "bad", std::make_pair("func", "Main")) + types_consts() + "%func = OpFunction %voidt None %funct\n"; str += entry >> bad; str += bad >> std::vector({def, block1, block2, block3, entry}); str += def >> merge; str += block1 >> merge; str += block2 >> merge; str += block3 >> merge; str += merge >> end; str += end; str += "OpFunctionEnd\n"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), MatchesRegex("First block '.\\[%entry\\]' of function '.\\[%Main\\]' " "is targeted by block '.\\[%bad\\]'\n" " %Main = OpFunction %void None %10\n")); } TEST_P(ValidateCFG, BranchToBlockInOtherFunctionBad) { Block entry("entry"); Block middle("middle", spv::Op::OpBranchConditional); Block end("end", spv::Op::OpReturn); entry.SetBody("%cond = OpSLessThan %boolt %one %two\n"); middle.SetBody("OpSelectionMerge %end None\n"); Block entry2("entry2"); Block middle2("middle2"); Block end2("end2", spv::Op::OpReturn); std::string str = GetDefaultHeader(GetParam()) + nameOps("middle2", std::make_pair("func", "Main")) + types_consts() + "%func = OpFunction %voidt None %funct\n"; str += entry >> middle; str += middle >> std::vector({end, middle2}); str += end; str += "OpFunctionEnd\n"; str += "%func2 = OpFunction %voidt None %funct\n"; str += entry2 >> middle2; str += middle2 >> end2; str += end2; str += "OpFunctionEnd\n"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), MatchesRegex( "Block\\(s\\) \\{'.\\[%middle2\\]'\\} are referenced but not " "defined in function '.\\[%Main\\]'\n" " %Main = OpFunction %void None %9\n")); } TEST_P(ValidateCFG, HeaderDoesntStrictlyDominateMergeBad) { // If a merge block is reachable, then it must be strictly dominated by // its header block. bool is_shader = GetParam() == spv::Capability::Shader; Block head("head", spv::Op::OpBranchConditional); Block exit("exit", spv::Op::OpReturn); head.SetBody("%cond = OpSLessThan %boolt %one %two\n"); if (is_shader) head.AppendBody("OpSelectionMerge %head None\n"); std::string str = GetDefaultHeader(GetParam()) + nameOps("head", "exit", std::make_pair("func", "Main")) + types_consts() + "%func = OpFunction %voidt None %funct\n"; str += head >> std::vector({exit, exit}); str += exit; str += "OpFunctionEnd\n"; CompileSuccessfully(str); if (is_shader) { ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), MatchesRegex( "The selection construct with the selection header " "'.\\[%head\\]' does not strictly structurally dominate the " "merge block " "'.\\[%head\\]'\n %head = OpLabel\n")); } else { ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()) << str; } } std::string GetUnreachableMergeNoMergeInst(spv::Capability cap) { std::string header = GetDefaultHeader(cap); Block entry("entry"); Block branch("branch", spv::Op::OpBranchConditional); Block t("t", spv::Op::OpReturn); Block f("f", spv::Op::OpReturn); Block merge("merge", spv::Op::OpReturn); entry.SetBody("%cond = OpSLessThan %boolt %one %two\n"); if (cap == spv::Capability::Shader) branch.AppendBody("OpSelectionMerge %merge None\n"); std::string str = header; str += nameOps("branch", "merge", std::make_pair("func", "Main")); str += types_consts() + "%func = OpFunction %voidt None %funct\n"; str += entry >> branch; str += branch >> std::vector({t, f}); str += t; str += f; str += merge; str += "OpFunctionEnd\n"; return str; } TEST_P(ValidateCFG, UnreachableMergeNoMergeInst) { CompileSuccessfully(GetUnreachableMergeNoMergeInst(GetParam())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } std::string GetUnreachableMergeTerminatedBy(spv::Capability cap, spv::Op op) { std::string header = GetDefaultHeader(cap); Block entry("entry"); Block branch("branch", spv::Op::OpBranchConditional); Block t("t", spv::Op::OpReturn); Block f("f", spv::Op::OpReturn); Block merge("merge", op); entry.SetBody("%cond = OpSLessThan %boolt %one %two\n"); std::string str = header; if (cap == spv::Capability::Shader) branch.AppendBody("OpSelectionMerge %merge None\n"); str += nameOps("branch", "merge", std::make_pair("func", "Main")); str += types_consts(); str += "%func = OpFunction %voidt None %funct\n"; str += entry >> branch; str += branch >> std::vector({t, f}); str += t; str += f; str += merge; str += "OpFunctionEnd\n"; return str; } TEST_P(ValidateCFG, UnreachableMergeTerminatedByOpUnreachable) { CompileSuccessfully( GetUnreachableMergeTerminatedBy(GetParam(), spv::Op::OpUnreachable)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, UnreachableMergeTerminatedByOpKill) { CompileSuccessfully(GetUnreachableMergeTerminatedBy(spv::Capability::Shader, spv::Op::OpKill)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateCFG, UnreachableMergeTerminatedByOpReturn) { CompileSuccessfully( GetUnreachableMergeTerminatedBy(GetParam(), spv::Op::OpReturn)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } std::string GetUnreachableContinueTerminatedBy(spv::Capability cap, spv::Op op) { std::string header = GetDefaultHeader(cap); Block entry("entry"); Block branch("branch", spv::Op::OpBranch); Block merge("merge", spv::Op::OpReturn); Block target("target", op); if (op == spv::Op::OpBranch) target >> branch; std::string str = header; if (cap == spv::Capability::Shader) branch.AppendBody("OpLoopMerge %merge %target None\n"); str += nameOps("branch", "merge", "target", std::make_pair("func", "Main")); str += types_consts(); str += "%func = OpFunction %voidt None %funct\n"; str += entry >> branch; str += branch >> std::vector({merge}); str += merge; str += target; str += "OpFunctionEnd\n"; return str; } TEST_P(ValidateCFG, UnreachableContinueTerminatedByOpUnreachable) { CompileSuccessfully( GetUnreachableContinueTerminatedBy(GetParam(), spv::Op::OpUnreachable)); if (GetParam() == spv::Capability::Shader) { ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("targeted by 0 back-edge blocks")); } else { ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } } TEST_F(ValidateCFG, UnreachableContinueTerminatedByOpKill) { CompileSuccessfully(GetUnreachableContinueTerminatedBy( spv::Capability::Shader, spv::Op::OpKill)); ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("targeted by 0 back-edge blocks")); } TEST_P(ValidateCFG, UnreachableContinueTerminatedByOpReturn) { CompileSuccessfully( GetUnreachableContinueTerminatedBy(GetParam(), spv::Op::OpReturn)); if (GetParam() == spv::Capability::Shader) { ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("targeted by 0 back-edge blocks")); } else { ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } } TEST_P(ValidateCFG, UnreachableContinueTerminatedByOpBranch) { CompileSuccessfully( GetUnreachableContinueTerminatedBy(GetParam(), spv::Op::OpBranch)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } std::string GetUnreachableMergeUnreachableMergeInst(spv::Capability cap) { std::string header = GetDefaultHeader(cap); Block body("body", spv::Op::OpReturn); Block entry("entry"); Block branch("branch", spv::Op::OpBranchConditional); Block t("t", spv::Op::OpReturn); Block f("f", spv::Op::OpReturn); Block merge("merge", spv::Op::OpUnreachable); entry.SetBody("%cond = OpSLessThan %boolt %one %two\n"); std::string str = header; if (cap == spv::Capability::Shader) branch.AppendBody("OpSelectionMerge %merge None\n"); str += nameOps("branch", "merge", std::make_pair("func", "Main")); str += types_consts(); str += "%func = OpFunction %voidt None %funct\n"; str += body; str += merge; str += entry >> branch; str += branch >> std::vector({t, f}); str += t; str += f; str += "OpFunctionEnd\n"; return str; } TEST_P(ValidateCFG, UnreachableMergeUnreachableMergeInst) { CompileSuccessfully(GetUnreachableMergeUnreachableMergeInst(GetParam())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } std::string GetUnreachableContinueUnreachableLoopInst(spv::Capability cap) { std::string header = GetDefaultHeader(cap); Block body("body", spv::Op::OpReturn); Block entry("entry"); Block branch("branch", spv::Op::OpBranch); Block merge("merge", spv::Op::OpReturn); Block target("target", spv::Op::OpBranch); target >> branch; std::string str = header; if (cap == spv::Capability::Shader) branch.AppendBody("OpLoopMerge %merge %target None\n"); str += nameOps("branch", "merge", "target", std::make_pair("func", "Main")); str += types_consts(); str += "%func = OpFunction %voidt None %funct\n"; str += body; str += target; str += merge; str += entry >> branch; str += branch >> std::vector({merge}); str += "OpFunctionEnd\n"; return str; } TEST_P(ValidateCFG, UnreachableContinueUnreachableLoopInst) { CompileSuccessfully(GetUnreachableContinueUnreachableLoopInst(GetParam())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } std::string GetUnreachableMergeWithComplexBody(spv::Capability cap) { std::string header = GetDefaultHeader(cap); Block entry("entry"); Block branch("branch", spv::Op::OpBranchConditional); Block t("t", spv::Op::OpReturn); Block f("f", spv::Op::OpReturn); Block merge("merge", spv::Op::OpUnreachable); entry.AppendBody("%placeholder = OpVariable %intptrt Function\n"); entry.AppendBody("%cond = OpSLessThan %boolt %one %two\n"); merge.AppendBody("OpStore %placeholder %one\n"); std::string str = header; if (cap == spv::Capability::Shader) branch.AppendBody("OpSelectionMerge %merge None\n"); str += nameOps("branch", "merge", std::make_pair("func", "Main")); str += types_consts(); str += "%intptrt = OpTypePointer Function %intt\n"; str += "%func = OpFunction %voidt None %funct\n"; str += entry >> branch; str += branch >> std::vector({t, f}); str += t; str += f; str += merge; str += "OpFunctionEnd\n"; return str; } TEST_P(ValidateCFG, UnreachableMergeWithComplexBody) { CompileSuccessfully(GetUnreachableMergeWithComplexBody(GetParam())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } std::string GetUnreachableContinueWithComplexBody(spv::Capability cap) { std::string header = GetDefaultHeader(cap); Block entry("entry"); Block branch("branch", spv::Op::OpBranch); Block merge("merge", spv::Op::OpReturn); Block target("target", spv::Op::OpBranch); target >> branch; entry.AppendBody("%placeholder = OpVariable %intptrt Function\n"); target.AppendBody("OpStore %placeholder %one\n"); std::string str = header; if (cap == spv::Capability::Shader) branch.AppendBody("OpLoopMerge %merge %target None\n"); str += nameOps("branch", "merge", "target", std::make_pair("func", "Main")); str += types_consts(); str += "%intptrt = OpTypePointer Function %intt\n"; str += "%func = OpFunction %voidt None %funct\n"; str += entry >> branch; str += branch >> std::vector({merge}); str += merge; str += target; str += "OpFunctionEnd\n"; return str; } TEST_P(ValidateCFG, UnreachableContinueWithComplexBody) { CompileSuccessfully(GetUnreachableContinueWithComplexBody(GetParam())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } std::string GetUnreachableMergeWithBranchUse(spv::Capability cap) { std::string header = GetDefaultHeader(cap); Block entry("entry"); Block branch("branch", spv::Op::OpBranchConditional); Block t("t", spv::Op::OpBranch); Block f("f", spv::Op::OpReturn); Block merge("merge", spv::Op::OpUnreachable); entry.AppendBody("%cond = OpSLessThan %boolt %one %two\n"); std::string str = header; if (cap == spv::Capability::Shader) branch.AppendBody("OpSelectionMerge %merge None\n"); str += nameOps("branch", "merge", std::make_pair("func", "Main")); str += types_consts(); str += "%func = OpFunction %voidt None %funct\n"; str += entry >> branch; str += branch >> std::vector({t, f}); str += t >> merge; str += f; str += merge; str += "OpFunctionEnd\n"; return str; } TEST_P(ValidateCFG, UnreachableMergeWithBranchUse) { CompileSuccessfully(GetUnreachableMergeWithBranchUse(GetParam())); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } std::string GetUnreachableMergeWithMultipleUses(spv::Capability cap) { std::string header = GetDefaultHeader(cap); Block entry("entry"); Block branch("branch", spv::Op::OpBranchConditional); Block t("t", spv::Op::OpReturn); Block f("f", spv::Op::OpReturn); Block merge("merge", spv::Op::OpUnreachable); Block duplicate("duplicate", spv::Op::OpBranchConditional); entry.AppendBody("%cond = OpSLessThan %boolt %one %two\n"); std::string str = header; if (cap == spv::Capability::Shader) { branch.AppendBody("OpSelectionMerge %merge None\n"); duplicate.AppendBody("OpSelectionMerge %merge None\n"); } str += nameOps("branch", "merge", std::make_pair("func", "Main")); str += types_consts(); str += "%func = OpFunction %voidt None %funct\n"; str += entry >> branch; str += branch >> std::vector({t, f}); str += duplicate >> std::vector({t, f}); str += t; str += f; str += merge; str += "OpFunctionEnd\n"; return str; } TEST_P(ValidateCFG, UnreachableMergeWithMultipleUses) { CompileSuccessfully(GetUnreachableMergeWithMultipleUses(GetParam())); if (GetParam() == spv::Capability::Shader) { ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("is already a merge block for another header")); } else { ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } } std::string GetUnreachableContinueWithBranchUse(spv::Capability cap) { std::string header = GetDefaultHeader(cap); Block entry("entry"); Block branch("branch", spv::Op::OpBranch); Block merge("merge", spv::Op::OpReturn); Block target("target", spv::Op::OpBranch); target >> branch; entry.AppendBody("%placeholder = OpVariable %intptrt Function\n"); std::string str = header; if (cap == spv::Capability::Shader) branch.AppendBody("OpLoopMerge %merge %target None\n"); str += nameOps("branch", "merge", "target", std::make_pair("func", "Main")); str += types_consts(); str += "%intptrt = OpTypePointer Function %intt\n"; str += "%func = OpFunction %voidt None %funct\n"; str += entry >> branch; str += branch >> std::vector({merge}); str += merge; str += target; str += "OpFunctionEnd\n"; return str; } TEST_P(ValidateCFG, UnreachableContinueWithBranchUse) { CompileSuccessfully(GetUnreachableContinueWithBranchUse(GetParam())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } std::string GetReachableMergeAndContinue(spv::Capability cap) { std::string header = GetDefaultHeader(cap); Block entry("entry"); Block branch("branch", spv::Op::OpBranch); Block merge("merge", spv::Op::OpReturn); Block target("target", spv::Op::OpBranch); Block body("body", spv::Op::OpBranchConditional); Block t("t", spv::Op::OpBranch); Block f("f", spv::Op::OpBranch); target >> branch; body.SetBody("%cond = OpSLessThan %boolt %one %two\n"); t >> merge; f >> target; std::string str = header; if (cap == spv::Capability::Shader) { branch.AppendBody("OpLoopMerge %merge %target None\n"); body.AppendBody("OpSelectionMerge %f None\n"); } str += nameOps("branch", "merge", "target", "body", "t", "f", std::make_pair("func", "Main")); str += types_consts(); str += "%func = OpFunction %voidt None %funct\n"; str += entry >> branch; str += branch >> std::vector({body}); str += body >> std::vector({t, f}); str += t; str += f; str += merge; str += target; str += "OpFunctionEnd\n"; return str; } TEST_P(ValidateCFG, ReachableMergeAndContinue) { CompileSuccessfully(GetReachableMergeAndContinue(GetParam())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } std::string GetUnreachableMergeAndContinue(spv::Capability cap) { std::string header = GetDefaultHeader(cap); Block entry("entry"); Block branch("branch", spv::Op::OpBranch); Block merge("merge", spv::Op::OpReturn); Block target("target", spv::Op::OpBranch); Block body("body", spv::Op::OpBranchConditional); Block t("t", spv::Op::OpReturn); Block f("f", spv::Op::OpReturn); Block pre_target("pre_target", spv::Op::OpBranch); target >> branch; body.SetBody("%cond = OpSLessThan %boolt %one %two\n"); std::string str = header; if (cap == spv::Capability::Shader) { branch.AppendBody("OpLoopMerge %merge %target None\n"); body.AppendBody("OpSelectionMerge %pre_target None\n"); } str += nameOps("branch", "merge", "pre_target", "target", "body", "t", "f", std::make_pair("func", "Main")); str += types_consts(); str += "%func = OpFunction %voidt None %funct\n"; str += entry >> branch; str += branch >> std::vector({body}); str += body >> std::vector({t, f}); str += t; str += f; str += merge; str += pre_target >> target; str += target; str += "OpFunctionEnd\n"; return str; } TEST_P(ValidateCFG, UnreachableMergeAndContinue) { CompileSuccessfully(GetUnreachableMergeAndContinue(GetParam())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } std::string GetUnreachableBlock(spv::Capability cap) { std::string header = GetDefaultHeader(cap); Block entry("entry"); Block unreachable("unreachable"); Block exit("exit", spv::Op::OpReturn); std::string str = header; str += nameOps("unreachable", "exit", std::make_pair("func", "Main")); str += types_consts(); str += "%func = OpFunction %voidt None %funct\n"; str += entry >> exit; str += unreachable >> exit; str += exit; str += "OpFunctionEnd\n"; return str; } TEST_P(ValidateCFG, UnreachableBlock) { CompileSuccessfully(GetUnreachableBlock(GetParam())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } std::string GetUnreachableBranch(spv::Capability cap) { std::string header = GetDefaultHeader(cap); Block entry("entry"); Block unreachable("unreachable", spv::Op::OpBranchConditional); Block unreachablechildt("unreachablechildt"); Block unreachablechildf("unreachablechildf"); Block merge("merge"); Block exit("exit", spv::Op::OpReturn); unreachable.SetBody("%cond = OpSLessThan %boolt %one %two\n"); if (cap == spv::Capability::Shader) unreachable.AppendBody("OpSelectionMerge %merge None\n"); std::string str = header; str += nameOps("unreachable", "exit", std::make_pair("func", "Main")); str += types_consts(); str += "%func = OpFunction %voidt None %funct\n"; str += entry >> exit; str += unreachable >> std::vector({unreachablechildt, unreachablechildf}); str += unreachablechildt >> merge; str += unreachablechildf >> merge; str += merge >> exit; str += exit; str += "OpFunctionEnd\n"; return str; } TEST_P(ValidateCFG, UnreachableBranch) { CompileSuccessfully(GetUnreachableBranch(GetParam())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateCFG, EmptyFunction) { std::string str = GetDefaultHeader(GetParam()) + std::string(types_consts()) + R"(%func = OpFunction %voidt None %funct %l = OpLabel OpReturn OpFunctionEnd)"; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateCFG, SingleBlockLoop) { bool is_shader = GetParam() == spv::Capability::Shader; Block entry("entry"); Block loop("loop", spv::Op::OpBranchConditional); Block exit("exit", spv::Op::OpReturn); entry.SetBody("%cond = OpSLessThan %boolt %one %two\n"); if (is_shader) loop.AppendBody("OpLoopMerge %exit %loop None\n"); std::string str = GetDefaultHeader(GetParam()) + std::string(types_consts()) + "%func = OpFunction %voidt None %funct\n"; str += entry >> loop; str += loop >> std::vector({loop, exit}); str += exit; str += "OpFunctionEnd"; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateCFG, NestedLoops) { bool is_shader = GetParam() == spv::Capability::Shader; Block entry("entry"); Block loop1("loop1"); Block loop1_cont_break_block("loop1_cont_break_block", spv::Op::OpBranchConditional); Block loop2("loop2", spv::Op::OpBranchConditional); Block loop2_merge("loop2_merge"); Block loop1_merge("loop1_merge"); Block exit("exit", spv::Op::OpReturn); entry.SetBody("%cond = OpSLessThan %boolt %one %two\n"); if (is_shader) { loop1.SetBody("OpLoopMerge %loop1_merge %loop2 None\n"); loop2.SetBody("OpLoopMerge %loop2_merge %loop2 None\n"); } std::string str = GetDefaultHeader(GetParam()) + nameOps("loop1", "loop1_cont_break_block", "loop2", "loop2_merge") + types_consts() + "%func = OpFunction %voidt None %funct\n"; str += entry >> loop1; str += loop1 >> loop1_cont_break_block; str += loop1_cont_break_block >> std::vector({loop1_merge, loop2}); str += loop2 >> std::vector({loop2, loop2_merge}); str += loop2_merge >> loop1; str += loop1_merge >> exit; str += exit; str += "OpFunctionEnd"; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateCFG, NestedSelection) { bool is_shader = GetParam() == spv::Capability::Shader; Block entry("entry"); const int N = 256; std::vector if_blocks; std::vector merge_blocks; Block inner("inner"); entry.SetBody("%cond = OpSLessThan %boolt %one %two\n"); if_blocks.emplace_back("if0", spv::Op::OpBranchConditional); if (is_shader) if_blocks[0].SetBody("OpSelectionMerge %if_merge0 None\n"); merge_blocks.emplace_back("if_merge0", spv::Op::OpReturn); for (int i = 1; i < N; i++) { std::stringstream ss; ss << i; if_blocks.emplace_back("if" + ss.str(), spv::Op::OpBranchConditional); if (is_shader) if_blocks[i].SetBody("OpSelectionMerge %if_merge" + ss.str() + " None\n"); merge_blocks.emplace_back("if_merge" + ss.str(), spv::Op::OpBranch); } std::string str = GetDefaultHeader(GetParam()) + std::string(types_consts()) + "%func = OpFunction %voidt None %funct\n"; str += entry >> if_blocks[0]; for (int i = 0; i < N - 1; i++) { str += if_blocks[i] >> std::vector({if_blocks[i + 1], merge_blocks[i]}); } str += if_blocks.back() >> std::vector({inner, merge_blocks.back()}); str += inner >> merge_blocks.back(); for (int i = N - 1; i > 0; i--) { str += merge_blocks[i] >> merge_blocks[i - 1]; } str += merge_blocks[0]; str += "OpFunctionEnd"; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateCFG, BackEdgeBlockDoesntPostDominateContinueTargetBad) { bool is_shader = GetParam() == spv::Capability::Shader; Block entry("entry"); Block loop1("loop1", spv::Op::OpBranchConditional); Block loop2("loop2", spv::Op::OpBranchConditional); Block loop2_merge("loop2_merge"); Block loop1_cont("loop1_cont", spv::Op::OpBranchConditional); Block be_block("be_block"); Block exit("exit", spv::Op::OpReturn); entry.SetBody("%cond = OpSLessThan %boolt %one %two\n"); if (is_shader) { loop1.SetBody("OpLoopMerge %exit %loop1_cont None\n"); loop2.SetBody("OpLoopMerge %loop2_merge %loop2 None\n"); } std::string str = GetDefaultHeader(GetParam()) + nameOps("loop1", "loop2", "be_block", "loop1_cont", "loop2_merge") + types_consts() + "%func = OpFunction %voidt None %funct\n"; str += entry >> loop1; str += loop1 >> std::vector({loop2, exit}); str += loop2 >> std::vector({loop2, loop2_merge}); str += loop2_merge >> loop1_cont; str += loop1_cont >> std::vector({be_block, exit}); str += be_block >> loop1; str += exit; str += "OpFunctionEnd"; CompileSuccessfully(str); if (GetParam() == spv::Capability::Shader) { ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), MatchesRegex( "The continue construct with the continue target " "'.\\[%loop1_cont\\]' is not structurally post dominated by the " "back-edge block '.\\[%be_block\\]'\n" " %be_block = OpLabel\n")); } else { ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } } TEST_P(ValidateCFG, BranchingToNonLoopHeaderBlockBad) { bool is_shader = GetParam() == spv::Capability::Shader; Block entry("entry"); Block split("split", spv::Op::OpBranchConditional); Block t("t"); Block f("f"); Block exit("exit", spv::Op::OpReturn); entry.SetBody("%cond = OpSLessThan %boolt %one %two\n"); if (is_shader) split.SetBody("OpSelectionMerge %exit None\n"); std::string str = GetDefaultHeader(GetParam()) + nameOps("split", "f") + types_consts() + "%func = OpFunction %voidt None %funct\n"; str += entry >> split; str += split >> std::vector({t, f}); str += t >> exit; str += f >> split; str += exit; str += "OpFunctionEnd"; CompileSuccessfully(str); if (is_shader) { ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), MatchesRegex("Back-edges \\('.\\[%f\\]' -> '.\\[%split\\]'\\) can only " "be formed between a block and a loop header.\n" " %f = OpLabel\n")); } else { ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } } TEST_P(ValidateCFG, BranchingToSameNonLoopHeaderBlockBad) { bool is_shader = GetParam() == spv::Capability::Shader; Block entry("entry"); Block split("split", spv::Op::OpBranchConditional); Block exit("exit", spv::Op::OpReturn); entry.SetBody("%cond = OpSLessThan %boolt %one %two\n"); if (is_shader) split.SetBody("OpSelectionMerge %exit None\n"); std::string str = GetDefaultHeader(GetParam()) + nameOps("split") + types_consts() + "%func = OpFunction %voidt None %funct\n"; str += entry >> split; str += split >> std::vector({split, exit}); str += exit; str += "OpFunctionEnd"; CompileSuccessfully(str); if (is_shader) { ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), MatchesRegex( "Back-edges \\('.\\[%split\\]' -> '.\\[%split\\]'\\) can only be " "formed between a block and a loop header.\n %split = OpLabel\n")); } else { ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } } TEST_P(ValidateCFG, MultipleBackEdgeBlocksToLoopHeaderBad) { bool is_shader = GetParam() == spv::Capability::Shader; Block entry("entry"); Block loop("loop", spv::Op::OpBranchConditional); Block back0("back0"); Block back1("back1"); Block merge("merge", spv::Op::OpReturn); entry.SetBody("%cond = OpSLessThan %boolt %one %two\n"); if (is_shader) loop.SetBody("OpLoopMerge %merge %back0 None\n"); std::string str = GetDefaultHeader(GetParam()) + nameOps("loop", "back0", "back1") + types_consts() + "%func = OpFunction %voidt None %funct\n"; str += entry >> loop; str += loop >> std::vector({back0, back1}); str += back0 >> loop; str += back1 >> loop; str += merge; str += "OpFunctionEnd"; CompileSuccessfully(str); if (is_shader) { ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), MatchesRegex( "Loop header '.\\[%loop\\]' is targeted by 2 back-edge blocks but " "the standard requires exactly one\n %loop = OpLabel\n")) << str; } else { ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } } TEST_P(ValidateCFG, ContinueTargetMustBePostDominatedByBackEdge) { bool is_shader = GetParam() == spv::Capability::Shader; Block entry("entry"); Block loop("loop", spv::Op::OpBranchConditional); Block cheader("cheader", spv::Op::OpBranchConditional); Block be_block("be_block"); Block merge("merge", spv::Op::OpReturn); Block exit("exit", spv::Op::OpReturn); entry.SetBody("%cond = OpSLessThan %boolt %one %two\n"); if (is_shader) loop.SetBody("OpLoopMerge %merge %cheader None\n"); std::string str = GetDefaultHeader(GetParam()) + nameOps("cheader", "be_block") + types_consts() + "%func = OpFunction %voidt None %funct\n"; str += entry >> loop; str += loop >> std::vector({cheader, merge}); str += cheader >> std::vector({exit, be_block}); str += exit; // Branches out of a continue construct str += be_block >> loop; str += merge; str += "OpFunctionEnd"; CompileSuccessfully(str); if (is_shader) { ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), MatchesRegex( "The continue construct with the continue target " "'.\\[%cheader\\]' is not structurally post dominated by the " "back-edge block '.\\[%be_block\\]'\n" " %be_block = OpLabel\n")); } else { ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } } TEST_P(ValidateCFG, BranchOutOfConstructToMergeBad) { bool is_shader = GetParam() == spv::Capability::Shader; Block entry("entry"); Block loop("loop", spv::Op::OpBranchConditional); Block cont("cont", spv::Op::OpBranchConditional); Block merge("merge", spv::Op::OpReturn); entry.SetBody("%cond = OpSLessThan %boolt %one %two\n"); if (is_shader) loop.SetBody("OpLoopMerge %merge %loop None\n"); std::string str = GetDefaultHeader(GetParam()) + nameOps("cont", "loop") + types_consts() + "%func = OpFunction %voidt None %funct\n"; str += entry >> loop; str += loop >> std::vector({cont, merge}); str += cont >> std::vector({loop, merge}); str += merge; str += "OpFunctionEnd"; CompileSuccessfully(str); if (is_shader) { ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), MatchesRegex("The continue construct with the continue target " "'.\\[%loop\\]' is not structurally post dominated by the " "back-edge block '.\\[%cont\\]'\n" " %cont = OpLabel\n")) << str; } else { ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } } TEST_P(ValidateCFG, BranchOutOfConstructBad) { bool is_shader = GetParam() == spv::Capability::Shader; Block entry("entry"); Block loop("loop", spv::Op::OpBranchConditional); Block cont("cont", spv::Op::OpBranchConditional); Block merge("merge"); Block exit("exit", spv::Op::OpReturn); entry.SetBody("%cond = OpSLessThan %boolt %one %two\n"); if (is_shader) loop.SetBody("OpLoopMerge %merge %loop None\n"); std::string str = GetDefaultHeader(GetParam()) + nameOps("cont", "loop") + types_consts() + "%func = OpFunction %voidt None %funct\n"; str += entry >> loop; str += loop >> std::vector({cont, merge}); str += cont >> std::vector({loop, exit}); str += merge >> exit; str += exit; str += "OpFunctionEnd"; CompileSuccessfully(str); if (is_shader) { ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), MatchesRegex("The continue construct with the continue target " "'.\\[%loop\\]' is not structurally post dominated by the " "back-edge block '.\\[%cont\\]'\n" " %cont = OpLabel\n")); } else { ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } } TEST_F(ValidateCFG, OpSwitchToUnreachableBlock) { Block entry("entry", spv::Op::OpSwitch); Block case0("case0"); Block case1("case1"); Block case2("case2"); Block def("default", spv::Op::OpUnreachable); Block phi("phi", spv::Op::OpReturn); std::string str = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %id OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 430 OpName %main "main" OpDecorate %id BuiltIn GlobalInvocationId %void = OpTypeVoid %voidf = OpTypeFunction %void %u32 = OpTypeInt 32 0 %f32 = OpTypeFloat 32 %uvec3 = OpTypeVector %u32 3 %fvec3 = OpTypeVector %f32 3 %uvec3ptr = OpTypePointer Input %uvec3 %id = OpVariable %uvec3ptr Input %one = OpConstant %u32 1 %three = OpConstant %u32 3 %main = OpFunction %void None %voidf )"; entry.SetBody( "%idval = OpLoad %uvec3 %id\n" "%x = OpCompositeExtract %u32 %idval 0\n" "%selector = OpUMod %u32 %x %three\n" "OpSelectionMerge %phi None\n"); str += entry >> std::vector({def, case0, case1, case2}); str += case1 >> phi; str += def; str += phi; str += case0 >> phi; str += case2 >> phi; str += "OpFunctionEnd"; CompileSuccessfully(str); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, LoopWithZeroBackEdgesBad) { std::string str = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpName %loop "loop" %voidt = OpTypeVoid %funct = OpTypeFunction %voidt %main = OpFunction %voidt None %funct %loop = OpLabel OpLoopMerge %exit %loop None OpBranch %exit %exit = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), MatchesRegex("Loop header '.\\[%loop\\]' is targeted by " "0 back-edge blocks but the standard requires exactly " "one\n %loop = OpLabel\n")); } TEST_F(ValidateCFG, LoopWithBackEdgeFromUnreachableContinueConstructGood) { std::string str = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpName %loop "loop" %voidt = OpTypeVoid %funct = OpTypeFunction %voidt %floatt = OpTypeFloat 32 %boolt = OpTypeBool %one = OpConstant %floatt 1 %two = OpConstant %floatt 2 %main = OpFunction %voidt None %funct %entry = OpLabel OpBranch %loop %loop = OpLabel OpLoopMerge %exit %cont None OpBranch %16 %16 = OpLabel %cond = OpFOrdLessThan %boolt %one %two OpBranchConditional %cond %body %exit %body = OpLabel OpReturn %cont = OpLabel ; Reachable only from OpLoopMerge ContinueTarget parameter OpBranch %loop ; Should be considered a back-edge %exit = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()) << getDiagnosticString(); } TEST_P(ValidateCFG, NestedConstructWithUnreachableMergeBlockBranchingToOuterMergeBlock) { // Test for https://github.com/KhronosGroup/SPIRV-Tools/issues/297 // The nested construct has an unreachable merge block. In the // augmented CFG that merge block // we still determine that the bool is_shader = GetParam() == spv::Capability::Shader; Block entry("entry", spv::Op::OpBranchConditional); Block inner_head("inner_head", spv::Op::OpBranchConditional); Block inner_true("inner_true", spv::Op::OpReturn); Block inner_false("inner_false", spv::Op::OpReturn); Block inner_merge("inner_merge"); Block exit("exit", spv::Op::OpReturn); entry.SetBody("%cond = OpSLessThan %boolt %one %two\n"); if (is_shader) { entry.AppendBody("OpSelectionMerge %exit None\n"); inner_head.SetBody("OpSelectionMerge %inner_merge None\n"); } std::string str = GetDefaultHeader(GetParam()) + nameOps("entry", "inner_merge", "exit") + types_consts() + "%func = OpFunction %voidt None %funct\n"; str += entry >> std::vector({inner_head, exit}); str += inner_head >> std::vector({inner_true, inner_false}); str += inner_true; str += inner_false; str += inner_merge >> exit; str += exit; str += "OpFunctionEnd"; CompileSuccessfully(str); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()) << getDiagnosticString(); } TEST_P(ValidateCFG, ContinueTargetCanBeMergeBlockForNestedStructure) { // The continue construct cannot be the merge target of a nested selection // because the loop construct must contain "if_merge" because it contains // "if_head". bool is_shader = GetParam() == spv::Capability::Shader; Block entry("entry"); Block loop("loop"); Block if_head("if_head", spv::Op::OpBranchConditional); Block if_true("if_true"); Block if_merge("if_merge", spv::Op::OpBranchConditional); Block merge("merge", spv::Op::OpReturn); entry.SetBody("%cond = OpSLessThan %boolt %one %two\n"); if (is_shader) { loop.SetBody("OpLoopMerge %merge %if_merge None\n"); if_head.SetBody("OpSelectionMerge %if_merge None\n"); } std::string str = GetDefaultHeader(GetParam()) + nameOps("entry", "loop", "if_head", "if_true", "if_merge", "merge") + types_consts() + "%func = OpFunction %voidt None %funct\n"; str += entry >> loop; str += loop >> if_head; str += if_head >> std::vector({if_true, if_merge}); str += if_true >> if_merge; str += if_merge >> std::vector({loop, merge}); str += merge; str += "OpFunctionEnd"; CompileSuccessfully(str); if (is_shader) { EXPECT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Header block '3[%if_head]' is contained in the loop construct " "headed " "by '2[%loop]', but its merge block '5[%if_merge]' is not")); } else { EXPECT_THAT(SPV_SUCCESS, ValidateInstructions()); } } TEST_P(ValidateCFG, SingleLatchBlockMultipleBranchesToLoopHeader) { // This test case ensures we allow both branches of a loop latch block // to go back to the loop header. It still counts as a single back edge. bool is_shader = GetParam() == spv::Capability::Shader; Block entry("entry"); Block loop("loop", spv::Op::OpBranchConditional); Block latch("latch", spv::Op::OpBranchConditional); Block merge("merge", spv::Op::OpReturn); entry.SetBody("%cond = OpSLessThan %boolt %one %two\n"); if (is_shader) { loop.SetBody("OpLoopMerge %merge %latch None\n"); } std::string str = GetDefaultHeader(GetParam()) + nameOps("entry", "loop", "latch", "merge") + types_consts() + "%func = OpFunction %voidt None %funct\n"; str += entry >> loop; str += loop >> std::vector({latch, merge}); str += latch >> std::vector({loop, loop}); // This is the key str += merge; str += "OpFunctionEnd"; CompileSuccessfully(str); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()) << str << getDiagnosticString(); } // Unit test to check the case where a basic block is the entry block of 2 // different constructs. In this case, the basic block is the entry block of a // continue construct as well as a selection construct. See issue# 517 for more // details. TEST_F(ValidateCFG, BasicBlockIsEntryBlockOfTwoConstructsGood) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %bool = OpTypeBool %int = OpTypeInt 32 1 %void_func = OpTypeFunction %void %int_0 = OpConstant %int 0 %testfun = OpFunction %void None %void_func %label_1 = OpLabel OpBranch %start %start = OpLabel %cond = OpSLessThan %bool %int_0 %int_0 ; ; Note: In this case, the "target" block is both the entry block of ; the continue construct of the loop as well as the entry block of ; the selection construct. ; OpLoopMerge %loop_merge %target None OpBranchConditional %cond %target %loop_merge %loop_merge = OpLabel OpReturn %target = OpLabel OpSelectionMerge %selection_merge None OpBranchConditional %cond %do_stuff %do_other_stuff %do_other_stuff = OpLabel OpBranch %selection_merge %selection_merge = OpLabel OpBranch %start %do_stuff = OpLabel OpBranch %selection_merge OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, OpReturnInNonVoidFunc) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %int = OpTypeInt 32 1 %int_func = OpTypeFunction %int %testfun = OpFunction %int None %int_func %label_1 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpReturn can only be called from a function with void return type.\n" " OpReturn")); } TEST_F(ValidateCFG, StructuredCFGBranchIntoSelectionBody) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %functy = OpTypeFunction %void %func = OpFunction %void None %functy %entry = OpLabel OpSelectionMerge %merge None OpBranchConditional %true %then %merge %merge = OpLabel OpBranch %then %then = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("branches to the selection construct, but not to the " "selection header 6\n %7 = OpLabel")); } TEST_F(ValidateCFG, SwitchDefaultOnly) { std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpConstant %2 0 %4 = OpTypeFunction %1 %5 = OpFunction %1 None %4 %6 = OpLabel OpSelectionMerge %7 None OpSwitch %3 %7 %7 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, SwitchSingleCase) { std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpConstant %2 0 %4 = OpTypeFunction %1 %5 = OpFunction %1 None %4 %6 = OpLabel OpSelectionMerge %7 None OpSwitch %3 %7 0 %8 %8 = OpLabel OpBranch %7 %7 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, MultipleFallThroughBlocks) { std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpConstant %2 0 %4 = OpTypeFunction %1 %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpFunction %1 None %4 %8 = OpLabel OpSelectionMerge %9 None OpSwitch %3 %10 0 %11 1 %12 %10 = OpLabel OpBranchConditional %6 %11 %12 %11 = OpLabel OpBranch %9 %12 = OpLabel OpBranch %9 %9 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Case construct that targets '10[%10]' has branches to multiple " "other " "case construct targets '12[%12]' and '11[%11]'\n %10 = OpLabel")); } TEST_F(ValidateCFG, MultipleFallThroughToDefault) { std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpConstant %2 0 %4 = OpTypeFunction %1 %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpFunction %1 None %4 %8 = OpLabel OpSelectionMerge %9 None OpSwitch %3 %10 0 %11 1 %12 %10 = OpLabel OpBranch %9 %11 = OpLabel OpBranch %10 %12 = OpLabel OpBranch %10 %9 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Multiple case constructs have branches to the case construct " "that targets '10[%10]'\n %10 = OpLabel")); } TEST_F(ValidateCFG, MultipleFallThroughToNonDefault) { std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpConstant %2 0 %4 = OpTypeFunction %1 %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpFunction %1 None %4 %8 = OpLabel OpSelectionMerge %9 None OpSwitch %3 %10 0 %11 1 %12 %10 = OpLabel OpBranch %12 %11 = OpLabel OpBranch %12 %12 = OpLabel OpBranch %9 %9 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Multiple case constructs have branches to the case construct " "that targets '12[%12]'\n %12 = OpLabel")); } TEST_F(ValidateCFG, DuplicateTargetWithFallThrough) { std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpConstant %2 0 %4 = OpTypeFunction %1 %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpFunction %1 None %4 %8 = OpLabel OpSelectionMerge %9 None OpSwitch %3 %10 0 %10 1 %11 %10 = OpLabel OpBranch %11 %11 = OpLabel OpBranch %9 %9 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, OpSwitchTargetCannotBeOuterLoopMergeBlock) { std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpTypeBool %4 = OpUndef %3 %5 = OpTypeInt 32 0 %6 = OpConstant %5 0 %7 = OpFunction %1 None %2 %8 = OpLabel OpBranch %9 %9 = OpLabel OpLoopMerge %10 %11 None OpBranch %12 %12 = OpLabel OpSelectionMerge %13 None OpSwitch %6 %13 0 %10 1 %14 %14 = OpLabel OpBranch %13 %13 = OpLabel OpBranch %11 %11 = OpLabel OpBranch %9 %10 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Switch header '12[%12]' does not structurally dominate its case construct '10[%10]'\n" " %12 = OpLabel")); } TEST_F(ValidateCFG, OpSwitchTargetCannotBeOuterLoopContinueBlock) { std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpTypeBool %4 = OpUndef %3 %5 = OpTypeInt 32 0 %6 = OpConstant %5 0 %7 = OpFunction %1 None %2 %8 = OpLabel OpBranch %9 %9 = OpLabel OpLoopMerge %10 %11 None OpBranch %12 %12 = OpLabel OpSelectionMerge %13 None OpSwitch %6 %13 0 %11 1 %14 %14 = OpLabel OpBranch %13 %13 = OpLabel OpBranch %11 %11 = OpLabel OpBranch %9 %10 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Switch header '12[%12]' does not structurally dominate its case construct '11[%11]'\n" " %12 = OpLabel")); } TEST_F(ValidateCFG, WrongOperandList) { std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpConstant %2 0 %4 = OpTypeFunction %1 %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpFunction %1 None %4 %8 = OpLabel OpSelectionMerge %9 None OpSwitch %3 %10 0 %11 1 %12 %10 = OpLabel OpBranch %9 %12 = OpLabel OpBranch %11 %11 = OpLabel OpBranch %9 %9 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Case construct that targets '12[%12]' has branches to the case " "construct that targets '11[%11]', but does not immediately " "precede it in the OpSwitch's target list\n" " OpSwitch %uint_0 %10 0 %11 1 %12")); } TEST_F(ValidateCFG, WrongOperandListThroughDefault) { std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpConstant %2 0 %4 = OpTypeFunction %1 %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpFunction %1 None %4 %8 = OpLabel OpSelectionMerge %9 None OpSwitch %3 %10 0 %11 1 %12 %10 = OpLabel OpBranch %11 %12 = OpLabel OpBranch %10 %11 = OpLabel OpBranch %9 %9 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Case construct that targets '12[%12]' has branches to the case " "construct that targets '11[%11]', but does not immediately " "precede it in the OpSwitch's target list\n" " OpSwitch %uint_0 %10 0 %11 1 %12")); } TEST_F(ValidateCFG, WrongOperandListNotLast) { std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpConstant %2 0 %4 = OpTypeFunction %1 %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpFunction %1 None %4 %8 = OpLabel OpSelectionMerge %9 None OpSwitch %3 %10 0 %11 1 %12 2 %13 %10 = OpLabel OpBranch %9 %12 = OpLabel OpBranch %11 %11 = OpLabel OpBranch %9 %13 = OpLabel OpBranch %9 %9 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Case construct that targets '12[%12]' has branches to the case " "construct that targets '11[%11]', but does not immediately " "precede it in the OpSwitch's target list\n" " OpSwitch %uint_0 %10 0 %11 1 %12 2 %13")); } TEST_F(ValidateCFG, GoodUnreachableSwitch) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft %3 = OpTypeVoid %4 = OpTypeFunction %3 %5 = OpTypeBool %6 = OpConstantTrue %5 %7 = OpTypeInt 32 1 %9 = OpConstant %7 0 %2 = OpFunction %3 None %4 %10 = OpLabel OpSelectionMerge %11 None OpBranchConditional %6 %12 %13 %12 = OpLabel OpReturn %13 = OpLabel OpReturn %11 = OpLabel OpSelectionMerge %14 None OpSwitch %9 %14 0 %15 %15 = OpLabel OpBranch %14 %14 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_THAT(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, InvalidCaseExit) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" OpExecutionMode %1 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeInt 32 0 %4 = OpTypeFunction %2 %5 = OpConstant %3 0 %1 = OpFunction %2 None %4 %6 = OpLabel OpSelectionMerge %7 None OpSwitch %5 %7 0 %8 1 %9 %8 = OpLabel OpBranch %10 %9 = OpLabel OpBranch %10 %10 = OpLabel OpReturn %7 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Case construct that targets '8[%8]' has invalid branch " "to block '10[%10]' (not another case construct, " "corresponding merge, outer loop merge or outer loop " "continue)")); } TEST_F(ValidateCFG, GoodCaseExitsToOuterConstructs) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %int = OpTypeInt 32 0 %int0 = OpConstant %int 0 %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel OpBranch %2 %2 = OpLabel OpLoopMerge %7 %6 None OpBranch %3 %3 = OpLabel OpSelectionMerge %5 None OpSwitch %int0 %5 0 %4 %4 = OpLabel OpBranchConditional %true %6 %7 %5 = OpLabel OpBranchConditional %true %6 %7 %6 = OpLabel OpBranch %2 %7 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, SwitchCaseOrderingBad1) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %default "default" OpName %other "other" %void = OpTypeVoid %int = OpTypeInt 32 0 %undef = OpUndef %int %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel OpSelectionMerge %merge None OpSwitch %undef %default 0 %other 1 %default %default = OpLabel OpBranch %other %other = OpLabel OpBranch %merge %merge = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Case construct that targets '1[%default]' has branches to the " "case construct that targets '2[%other]', but does not " "immediately precede it in the OpSwitch's target list")); } TEST_F(ValidateCFG, SwitchCaseOrderingBad2) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %default "default" OpName %other "other" %void = OpTypeVoid %int = OpTypeInt 32 0 %undef = OpUndef %int %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel OpSelectionMerge %merge None OpSwitch %undef %default 0 %default 1 %other %other = OpLabel OpBranch %default %default = OpLabel OpBranch %merge %merge = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Case construct that targets '2[%other]' has branches to the " "case construct that targets '1[%default]', but does not " "immediately precede it in the OpSwitch's target list")); } TEST_F(ValidateCFG, SwitchMultipleDefaultWithFallThroughGood) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %first "first" OpName %second "second" OpName %third "third" %void = OpTypeVoid %int = OpTypeInt 32 0 %undef = OpUndef %int %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel OpSelectionMerge %merge None OpSwitch %undef %second 0 %first 1 %second 2 %third %first = OpLabel OpBranch %second %second = OpLabel OpBranch %third %third = OpLabel OpBranch %merge %merge = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, SwitchMultipleDefaultWithFallThroughBad) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %first "first" OpName %second "second" OpName %third "third" %void = OpTypeVoid %int = OpTypeInt 32 0 %undef = OpUndef %int %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel OpSelectionMerge %merge None OpSwitch %undef %second 0 %second 1 %first 2 %third %first = OpLabel OpBranch %second %second = OpLabel OpBranch %third %third = OpLabel OpBranch %merge %merge = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); } TEST_F(ValidateCFG, GoodUnreachableSelection) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %8 = OpTypeFunction %void %bool = OpTypeBool %false = OpConstantFalse %bool %main = OpFunction %void None %8 %15 = OpLabel OpBranch %16 %16 = OpLabel OpLoopMerge %17 %18 None OpBranch %19 %19 = OpLabel OpBranchConditional %false %21 %17 %21 = OpLabel OpSelectionMerge %22 None OpBranchConditional %false %23 %22 %23 = OpLabel OpBranch %24 %24 = OpLabel OpLoopMerge %25 %26 None OpBranch %27 %27 = OpLabel OpReturn %26 = OpLabel OpBranchConditional %false %24 %25 %25 = OpLabel OpSelectionMerge %28 None OpBranchConditional %false %18 %28 %28 = OpLabel OpBranch %22 %22 = OpLabel OpBranch %18 %18 = OpLabel OpBranch %16 %17 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, ShaderWithPhiPtr) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 OpSource HLSL 600 %bool = OpTypeBool %_ptr_Function_bool = OpTypePointer Function %bool %void = OpTypeVoid %5 = OpTypeFunction %void %1 = OpFunction %void None %5 %6 = OpLabel %7 = OpVariable %_ptr_Function_bool Function %8 = OpVariable %_ptr_Function_bool Function %9 = OpUndef %bool OpSelectionMerge %10 None OpBranchConditional %9 %11 %10 %11 = OpLabel OpBranch %10 %10 = OpLabel %12 = OpPhi %_ptr_Function_bool %7 %6 %8 %11 OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Using pointers with OpPhi requires capability " "VariablePointers or VariablePointersStorageBuffer")); } TEST_F(ValidateCFG, VarPtrShaderWithPhiPtr) { const std::string text = R"( OpCapability Shader OpCapability VariablePointers OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 OpSource HLSL 600 %bool = OpTypeBool %_ptr_Function_bool = OpTypePointer Function %bool %void = OpTypeVoid %5 = OpTypeFunction %void %1 = OpFunction %void None %5 %6 = OpLabel %7 = OpVariable %_ptr_Function_bool Function %8 = OpVariable %_ptr_Function_bool Function %9 = OpUndef %bool OpSelectionMerge %10 None OpBranchConditional %9 %11 %10 %11 = OpLabel OpBranch %10 %10 = OpLabel %12 = OpPhi %_ptr_Function_bool %7 %6 %8 %11 OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, VarPtrStgBufShaderWithPhiStgBufPtr) { const std::string text = R"( OpCapability Shader OpCapability VariablePointersStorageBuffer OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 OpSource HLSL 600 %bool = OpTypeBool %float = OpTypeFloat 32 %_ptr_StorageBuffer_float = OpTypePointer StorageBuffer %float %7 = OpVariable %_ptr_StorageBuffer_float StorageBuffer %8 = OpVariable %_ptr_StorageBuffer_float StorageBuffer %void = OpTypeVoid %5 = OpTypeFunction %void %1 = OpFunction %void None %5 %6 = OpLabel %9 = OpUndef %bool OpSelectionMerge %10 None OpBranchConditional %9 %11 %10 %11 = OpLabel OpBranch %10 %10 = OpLabel %12 = OpPhi %_ptr_StorageBuffer_float %7 %6 %8 %11 OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, KernelWithPhiPtr) { const std::string text = R"( OpCapability Kernel OpCapability Addresses OpMemoryModel Physical32 OpenCL OpEntryPoint Kernel %1 "main" OpExecutionMode %1 LocalSize 1 1 1 OpSource HLSL 600 %bool = OpTypeBool %_ptr_Function_bool = OpTypePointer Function %bool %void = OpTypeVoid %5 = OpTypeFunction %void %1 = OpFunction %void None %5 %6 = OpLabel %7 = OpVariable %_ptr_Function_bool Function %8 = OpVariable %_ptr_Function_bool Function %9 = OpUndef %bool OpSelectionMerge %10 None OpBranchConditional %9 %11 %10 %11 = OpLabel OpBranch %10 %10 = OpLabel %12 = OpPhi %_ptr_Function_bool %7 %6 %8 %11 OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, SwitchTargetMustBeLabel) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "foo" %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %void = OpTypeVoid %5 = OpTypeFunction %void %1 = OpFunction %void None %5 %6 = OpLabel %7 = OpCopyObject %uint %uint_0 OpSelectionMerge %8 None OpSwitch %uint_0 %8 0 %7 %8 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("'Target Label' operands for OpSwitch must " "be IDs of an OpLabel instruction")); } TEST_F(ValidateCFG, BranchTargetMustBeLabel) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "foo" %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %void = OpTypeVoid %5 = OpTypeFunction %void %1 = OpFunction %void None %5 %2 = OpLabel %7 = OpCopyObject %uint %uint_0 OpBranch %7 %8 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("'Target Label' operands for OpBranch must " "be the ID of an OpLabel instruction")); } TEST_F(ValidateCFG, ReachableOpUnreachableOneBlock) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel OpUnreachable OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, ReachableOpUnreachableOpBranch) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel OpBranch %block %block = OpLabel OpUnreachable OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, ReachableOpUnreachableOpBranchConditional) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %void_fn = OpTypeFunction %void %bool = OpTypeBool %undef = OpUndef %bool %func = OpFunction %void None %void_fn %entry = OpLabel OpSelectionMerge %block None OpBranchConditional %undef %block %unreachable %block = OpLabel OpReturn %unreachable = OpLabel OpUnreachable OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, ReachableOpUnreachableOpSwitch) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %void_fn = OpTypeFunction %void %int = OpTypeInt 32 0 %undef = OpUndef %int %func = OpFunction %void None %void_fn %entry = OpLabel OpSelectionMerge %block1 None OpSwitch %undef %block1 0 %unreachable 1 %block2 %block1 = OpLabel OpReturn %unreachable = OpLabel OpUnreachable %block2 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, ReachableOpUnreachableLoop) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %void_fn = OpTypeFunction %void %bool = OpTypeBool %undef = OpUndef %bool %func = OpFunction %void None %void_fn %entry = OpLabel OpBranch %loop %loop = OpLabel OpLoopMerge %unreachable %loop None OpBranchConditional %undef %loop %unreachable %unreachable = OpLabel OpUnreachable OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, UnreachableLoopBadBackedge) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft %4 = OpTypeVoid %5 = OpTypeFunction %4 %8 = OpTypeBool %13 = OpConstantTrue %8 %2 = OpFunction %4 None %5 %14 = OpLabel OpSelectionMerge %15 None OpBranchConditional %13 %15 %15 %16 = OpLabel OpLoopMerge %17 %18 None OpBranch %17 %18 = OpLabel OpBranch %17 %17 = OpLabel OpBranch %15 %15 = OpLabel OpReturn OpFunctionEnd )"; // The back-edge in this test is bad, but the validator fails to identify it // because it is in an entirely unreachable section of code. Prior to #2488 // this code failed an assert in Construct::blocks(). CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, OneContinueTwoBackedges) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 %void = OpTypeVoid %bool = OpTypeBool %true = OpConstantTrue %bool %5 = OpTypeFunction %void %1 = OpFunction %void None %5 %6 = OpLabel OpBranch %7 %7 = OpLabel OpLoopMerge %8 %9 None OpBranch %10 %10 = OpLabel OpLoopMerge %11 %9 None OpBranchConditional %true %11 %9 %9 = OpLabel OpBranchConditional %true %10 %7 %11 = OpLabel OpBranch %8 %8 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Back-edges ('10[%10]' -> '9[%9]') can only be formed " "between a block and a loop header")); } TEST_F(ValidateCFG, LoopMergeMergeBlockNotLabel) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %undef "undef" %void = OpTypeVoid %bool = OpTypeBool %undef = OpUndef %bool %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %1 = OpLabel OpLoopMerge %undef %2 None OpBranchConditional %undef %2 %2 %2 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Merge Block '1[%undef]' must be an OpLabel")); } TEST_F(ValidateCFG, LoopMergeContinueTargetNotLabel) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %undef "undef" %void = OpTypeVoid %bool = OpTypeBool %undef = OpUndef %bool %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %1 = OpLabel OpLoopMerge %2 %undef None OpBranchConditional %undef %2 %2 %2 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Continue Target '1[%undef]' must be an OpLabel")); } TEST_F(ValidateCFG, LoopMergeMergeBlockContinueTargetSameLabel) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %undef "undef" %void = OpTypeVoid %bool = OpTypeBool %undef = OpUndef %bool %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %1 = OpLabel OpLoopMerge %2 %2 None OpBranchConditional %undef %2 %2 %2 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Merge Block and Continue Target must be different ids")); } TEST_F(ValidateCFG, LoopMergeUnrollAndDontUnroll) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %undef "undef" %void = OpTypeVoid %bool = OpTypeBool %undef = OpUndef %bool %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %5 = OpLabel OpBranch %1 %1 = OpLabel OpLoopMerge %2 %3 Unroll|DontUnroll OpBranchConditional %undef %2 %3 %3 = OpLabel OpBranch %1 %2 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Unroll and DontUnroll loop controls must not both be specified")); } TEST_F(ValidateCFG, LoopMergePeelCountAndDontUnroll) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %undef "undef" %void = OpTypeVoid %bool = OpTypeBool %undef = OpUndef %bool %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %5 = OpLabel OpBranch %1 %1 = OpLabel OpLoopMerge %2 %3 DontUnroll|PeelCount 1 OpBranchConditional %undef %2 %3 %3 = OpLabel OpBranch %1 %2 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "PeelCount and DontUnroll loop controls must not both be specified")); } TEST_F(ValidateCFG, LoopMergePartialCountAndDontUnroll) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %undef "undef" %void = OpTypeVoid %bool = OpTypeBool %undef = OpUndef %bool %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %5 = OpLabel OpBranch %1 %1 = OpLabel OpLoopMerge %2 %3 DontUnroll|PartialCount 1 OpBranchConditional %undef %2 %3 %3 = OpLabel OpBranch %1 %2 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("PartialCount and DontUnroll loop controls must not " "both be specified")); } TEST_F(ValidateCFG, LoopMergeIterationMultipleZero) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %undef "undef" %void = OpTypeVoid %bool = OpTypeBool %undef = OpUndef %bool %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %5 = OpLabel OpBranch %1 %1 = OpLabel OpLoopMerge %2 %3 IterationMultiple 0 OpBranchConditional %undef %2 %3 %3 = OpLabel OpBranch %1 %2 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "IterationMultiple loop control operand must be greater than zero")); } TEST_F(ValidateCFG, LoopMergeIterationMultipleZeroMoreOperands) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %undef "undef" %void = OpTypeVoid %bool = OpTypeBool %undef = OpUndef %bool %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %5 = OpLabel OpBranch %1 %1 = OpLabel OpLoopMerge %2 %3 MaxIterations|IterationMultiple 4 0 OpBranchConditional %undef %2 %3 %3 = OpLabel OpBranch %1 %2 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "IterationMultiple loop control operand must be greater than zero")); } TEST_F(ValidateCFG, LoopMergeTargetsHeader) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %bool = OpTypeBool %undef = OpUndef %bool %void_fn = OpTypeFunction %void %fn = OpFunction %void None %void_fn %entry = OpLabel OpBranch %loop %loop = OpLabel OpLoopMerge %loop %continue None OpBranch %body %continue = OpLabel OpBranch %loop %body = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Merge Block may not be the block containing the OpLoopMerge")); } TEST_F(ValidateCFG, InvalidSelectionExit) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeBool %4 = OpConstantTrue %3 %5 = OpTypeFunction %2 %1 = OpFunction %2 None %5 %6 = OpLabel OpSelectionMerge %7 None OpBranchConditional %4 %7 %8 %8 = OpLabel OpSelectionMerge %9 None OpBranchConditional %4 %10 %9 %10 = OpLabel OpBranch %7 %9 = OpLabel OpBranch %7 %7 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("block '10[%10]' exits the selection headed by " "'8[%8]', but not via a structured exit")); } TEST_F(ValidateCFG, InvalidLoopExit) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeBool %4 = OpConstantTrue %3 %5 = OpTypeFunction %2 %1 = OpFunction %2 None %5 %6 = OpLabel OpSelectionMerge %7 None OpBranchConditional %4 %7 %8 %8 = OpLabel OpLoopMerge %9 %10 None OpBranchConditional %4 %9 %11 %11 = OpLabel OpBranchConditional %4 %7 %10 %10 = OpLabel OpBranch %8 %9 = OpLabel OpBranch %7 %7 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("block '11[%11]' exits the loop headed by " "'8[%8]', but not via a structured exit")); } TEST_F(ValidateCFG, InvalidContinueExit) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeBool %4 = OpConstantTrue %3 %5 = OpTypeFunction %2 %1 = OpFunction %2 None %5 %6 = OpLabel OpSelectionMerge %7 None OpBranchConditional %4 %7 %8 %8 = OpLabel OpLoopMerge %9 %10 None OpBranchConditional %4 %9 %10 %10 = OpLabel OpBranch %11 %11 = OpLabel OpBranchConditional %4 %8 %7 %9 = OpLabel OpBranch %7 %7 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("block '11[%11]' exits the continue headed by " "'10[%10]', but not via a structured exit")); } TEST_F(ValidateCFG, InvalidSelectionExitBackedge) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeVoid %2 = OpTypeBool %3 = OpUndef %2 %4 = OpTypeFunction %1 %5 = OpFunction %1 None %4 %6 = OpLabel OpBranch %7 %7 = OpLabel OpLoopMerge %8 %9 None OpBranchConditional %3 %8 %9 %9 = OpLabel OpSelectionMerge %10 None OpBranchConditional %3 %11 %12 %11 = OpLabel OpBranch %13 %12 = OpLabel OpBranch %13 %13 = OpLabel OpBranch %7 %10 = OpLabel OpUnreachable %8 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "The continue construct with the continue target '9[%9]' is not " "structurally post dominated by the back-edge block '13[%13]'")); } TEST_F(ValidateCFG, BreakFromSwitch) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeVoid %2 = OpTypeBool %3 = OpTypeInt 32 0 %4 = OpUndef %2 %5 = OpUndef %3 %6 = OpTypeFunction %1 %7 = OpFunction %1 None %6 %8 = OpLabel OpSelectionMerge %9 None OpSwitch %5 %9 0 %10 %10 = OpLabel OpSelectionMerge %11 None OpBranchConditional %4 %11 %12 %12 = OpLabel OpBranch %9 %11 = OpLabel OpBranch %9 %9 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, InvalidBreakFromSwitch) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeVoid %2 = OpTypeBool %3 = OpTypeInt 32 0 %4 = OpUndef %2 %5 = OpUndef %3 %6 = OpTypeFunction %1 %7 = OpFunction %1 None %6 %8 = OpLabel OpSelectionMerge %9 None OpSwitch %5 %9 0 %10 %10 = OpLabel OpSelectionMerge %11 None OpSwitch %5 %11 0 %12 %12 = OpLabel OpBranch %9 %11 = OpLabel OpBranch %9 %9 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("block '12[%12]' exits the selection headed by " "'10[%10]', but not via a structured exit")); } TEST_F(ValidateCFG, BreakToOuterSwitch) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeVoid %2 = OpTypeBool %3 = OpTypeInt 32 0 %4 = OpUndef %2 %5 = OpUndef %3 %6 = OpTypeFunction %1 %7 = OpFunction %1 None %6 %8 = OpLabel OpSelectionMerge %9 None OpSwitch %5 %9 0 %10 %10 = OpLabel OpSelectionMerge %11 None OpSwitch %5 %11 0 %12 %12 = OpLabel OpSelectionMerge %13 None OpBranchConditional %4 %13 %14 %14 = OpLabel OpBranch %9 %13 = OpLabel OpBranch %11 %11 = OpLabel OpBranch %9 %9 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("block '14[%14]' exits the selection headed by " "'10[%10]', but not via a structured exit")); } TEST_F(ValidateCFG, BreakToOuterLoop) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeVoid %2 = OpTypeBool %3 = OpUndef %2 %4 = OpTypeFunction %1 %5 = OpFunction %1 None %4 %6 = OpLabel OpBranch %7 %7 = OpLabel OpLoopMerge %8 %9 None OpBranch %10 %10 = OpLabel OpLoopMerge %11 %12 None OpBranch %13 %13 = OpLabel OpSelectionMerge %14 None OpBranchConditional %3 %14 %15 %15 = OpLabel OpBranch %8 %14 = OpLabel OpBranch %12 %12 = OpLabel OpBranchConditional %3 %10 %11 %11 = OpLabel OpBranch %9 %9 = OpLabel OpBranchConditional %3 %7 %8 %8 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("block '15[%15]' exits the loop headed by " "'10[%10]', but not via a structured exit")); } TEST_F(ValidateCFG, ContinueFromNestedSelection) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %void_fn = OpTypeFunction %void %bool = OpTypeBool %undef = OpUndef %bool %4 = OpFunction %void None %void_fn %5 = OpLabel OpBranch %48 %48 = OpLabel OpLoopMerge %47 %50 None OpBranch %10 %10 = OpLabel OpLoopMerge %12 %37 None OpBranchConditional %undef %11 %12 %11 = OpLabel OpSelectionMerge %31 None OpBranchConditional %undef %30 %31 %30 = OpLabel OpSelectionMerge %38 None OpBranchConditional %undef %36 %38 %36 = OpLabel OpBranch %38 %38 = OpLabel OpBranch %37 %37 = OpLabel OpBranch %10 %31 = OpLabel OpBranch %12 %12 = OpLabel OpSelectionMerge %55 None OpBranchConditional %undef %47 %55 %55 = OpLabel OpBranch %47 %50 = OpLabel OpBranch %48 %47 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, MissingMergeConditionalBranchBad) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %void_fn = OpTypeFunction %void %bool = OpTypeBool %undef = OpUndef %bool %func = OpFunction %void None %void_fn %entry = OpLabel OpBranchConditional %undef %then %else %then = OpLabel OpReturn %else = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Selection must be structured")); } TEST_F(ValidateCFG, LoopConditionalBranchWithoutExitBad) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %void_fn = OpTypeFunction %void %bool = OpTypeBool %undef = OpUndef %bool %func = OpFunction %void None %void_fn %entry = OpLabel OpBranch %loop %loop = OpLabel OpLoopMerge %exit %continue None OpBranchConditional %undef %then %else %then = OpLabel OpBranch %continue %else = OpLabel OpBranch %exit %continue = OpLabel OpBranch %loop %exit = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Selection must be structured")); } TEST_F(ValidateCFG, MissingMergeSwitchBad) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %void_fn = OpTypeFunction %void %int = OpTypeInt 32 0 %undef = OpUndef %int %func = OpFunction %void None %void_fn %entry = OpLabel OpSwitch %undef %then 0 %else %then = OpLabel OpReturn %else = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpSwitch must be preceded by an OpSelectionMerge instruction")); } TEST_F(ValidateCFG, MissingMergeSwitchBad2) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %void_fn = OpTypeFunction %void %int = OpTypeInt 32 0 %undef = OpUndef %int %func = OpFunction %void None %void_fn %entry = OpLabel OpSwitch %undef %then 0 %then 1 %then 2 %else %then = OpLabel OpReturn %else = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpSwitch must be preceded by an OpSelectionMerge instruction")); } TEST_F(ValidateCFG, MissingMergeOneBranchToMergeGood) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %void_fn = OpTypeFunction %void %bool = OpTypeBool %undef = OpUndef %bool %func = OpFunction %void None %void_fn %entry = OpLabel OpSelectionMerge %b3 None OpBranchConditional %undef %b1 %b2 %b1 = OpLabel OpBranchConditional %undef %b2 %b3 %b2 = OpLabel OpBranch %b3 %b3 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, MissingMergeSameTargetConditionalBranchGood) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %void_fn = OpTypeFunction %void %bool = OpTypeBool %undef = OpUndef %bool %func = OpFunction %void None %void_fn %entry = OpLabel OpBranchConditional %undef %then %then %then = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, MissingMergeOneTargetSwitchBad) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %void_fn = OpTypeFunction %void %int = OpTypeInt 32 0 %undef = OpUndef %int %func = OpFunction %void None %void_fn %entry = OpLabel OpSwitch %undef %then 0 %then 1 %then %then = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpSwitch must be preceded by an OpSelectionMerge instruction")); } TEST_F(ValidateCFG, MissingMergeOneUnseenTargetSwitchBad) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %void_fn = OpTypeFunction %void %int = OpTypeInt 32 0 %undef_int = OpUndef %int %bool = OpTypeBool %undef_bool = OpUndef %bool %func = OpFunction %void None %void_fn %entry = OpLabel OpSelectionMerge %merge None OpBranchConditional %undef_bool %merge %b1 %b1 = OpLabel OpSwitch %undef_int %b2 0 %b2 1 %merge 2 %b2 %b2 = OpLabel OpBranch %merge %merge = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpSwitch must be preceded by an OpSelectionMerge instruction")); } TEST_F(ValidateCFG, MissingMergeLoopBreakGood) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %void_fn = OpTypeFunction %void %bool = OpTypeBool %undef = OpUndef %bool %func = OpFunction %void None %void_fn %entry = OpLabel OpBranch %loop %loop = OpLabel OpLoopMerge %exit %continue None OpBranch %body %body = OpLabel OpBranchConditional %undef %body2 %exit %body2 = OpLabel OpBranch %continue %continue = OpLabel OpBranch %loop %exit = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, MissingMergeLoopContinueGood) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %void_fn = OpTypeFunction %void %bool = OpTypeBool %undef = OpUndef %bool %func = OpFunction %void None %void_fn %entry = OpLabel OpBranch %loop %loop = OpLabel OpLoopMerge %exit %continue None OpBranch %body %body = OpLabel OpBranchConditional %undef %body2 %continue %body2 = OpLabel OpBranch %continue %continue = OpLabel OpBranch %loop %exit = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, MissingMergeSwitchBreakGood) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %void_fn = OpTypeFunction %void %bool = OpTypeBool %undef = OpUndef %bool %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %func = OpFunction %void None %void_fn %entry = OpLabel OpSelectionMerge %merge None OpSwitch %int_0 %merge 1 %b1 %b1 = OpLabel OpBranchConditional %undef %merge %b2 %b2 = OpLabel OpBranch %merge %merge = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, MissingMergeSwitchFallThroughGood) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %void_fn = OpTypeFunction %void %bool = OpTypeBool %undef = OpUndef %bool %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %func = OpFunction %void None %void_fn %entry = OpLabel OpSelectionMerge %merge None OpSwitch %int_0 %b1 1 %b2 %b1 = OpLabel OpBranchConditional %undef %b3 %b2 %b2 = OpLabel OpBranch %merge %b3 = OpLabel OpBranch %merge %merge = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, MissingMergeInALoopBad) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %void_fn = OpTypeFunction %void %bool = OpTypeBool %undef = OpUndef %bool %func = OpFunction %void None %void_fn %entry = OpLabel OpBranch %loop %loop = OpLabel OpLoopMerge %exit %continue None OpBranch %body %body = OpLabel OpBranchConditional %undef %b1 %b2 %b1 = OpLabel OpBranch %exit %b2 = OpLabel OpBranch %continue %continue = OpLabel OpBranch %loop %exit = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Selection must be structured")); } TEST_F(ValidateCFG, MissingMergeCrissCrossBad) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %void_fn = OpTypeFunction %void %bool = OpTypeBool %undef = OpUndef %bool %func = OpFunction %void None %void_fn %entry = OpLabel OpSelectionMerge %merge None OpBranchConditional %undef %b1 %b2 %b1 = OpLabel OpBranchConditional %undef %b3 %b4 %b2 = OpLabel OpBranchConditional %undef %b3 %b4 %b3 = OpLabel OpBranch %merge %b4 = OpLabel OpBranch %merge %merge = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Selection must be structured")); } TEST_F(ValidateCFG, ContinueCannotBeSelectionMergeTarget) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %loop "loop" OpName %continue "continue" OpName %body "body" %void = OpTypeVoid %void_fn = OpTypeFunction %void %bool = OpTypeBool %undef = OpUndef %bool %func = OpFunction %void None %void_fn %entry = OpLabel OpBranch %loop %loop = OpLabel OpLoopMerge %exit %continue None OpBranch %body %body = OpLabel OpSelectionMerge %continue None OpBranchConditional %undef %exit %continue %continue = OpLabel OpBranch %loop %exit = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Header block '3[%body]' is contained in the loop construct " "headed by " "'1[%loop]', but its merge block '2[%continue]' is not")); } TEST_F(ValidateCFG, ContinueCannotBeLoopMergeTarget) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %loop "loop" OpName %continue "continue" OpName %inner "inner" %void = OpTypeVoid %void_fn = OpTypeFunction %void %bool = OpTypeBool %undef = OpUndef %bool %func = OpFunction %void None %void_fn %entry = OpLabel OpBranch %loop %loop = OpLabel OpLoopMerge %exit %continue None OpBranchConditional %undef %exit %inner %inner = OpLabel OpLoopMerge %continue %inner None OpBranchConditional %undef %inner %continue %continue = OpLabel OpBranch %loop %exit = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Header block '3[%inner]' is contained in the loop construct " "headed by " "'1[%loop]', but its merge block '2[%continue]' is not")); } TEST_F(ValidateCFG, ExitFromConstructWhoseHeaderIsAMerge) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %2 = OpTypeFunction %void %int = OpTypeInt 32 1 %4 = OpUndef %int %bool = OpTypeBool %6 = OpUndef %bool %7 = OpFunction %void None %2 %8 = OpLabel OpSelectionMerge %9 None OpSwitch %4 %10 0 %11 %10 = OpLabel OpBranch %9 %11 = OpLabel OpBranch %12 %12 = OpLabel OpLoopMerge %13 %14 None OpBranch %15 %15 = OpLabel OpSelectionMerge %16 None OpSwitch %4 %17 1 %18 2 %19 %17 = OpLabel OpBranch %16 %18 = OpLabel OpBranch %14 %19 = OpLabel OpBranch %16 %16 = OpLabel OpBranch %14 %14 = OpLabel OpBranchConditional %6 %12 %13 %13 = OpLabel OpSelectionMerge %20 None OpBranchConditional %6 %21 %20 %21 = OpLabel OpBranch %9 %20 = OpLabel OpBranch %10 %9 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, ExitFromConstructWhoseHeaderIsAMerge2) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" OpExecutionMode %2 OriginUpperLeft %void = OpTypeVoid %4 = OpTypeFunction %void %int = OpTypeInt 32 1 %6 = OpUndef %int %bool = OpTypeBool %8 = OpUndef %bool %2 = OpFunction %void None %4 %9 = OpLabel OpSelectionMerge %10 None OpSwitch %6 %11 0 %12 %11 = OpLabel OpBranch %10 %12 = OpLabel OpBranch %13 %13 = OpLabel OpLoopMerge %14 %15 None OpBranch %16 %16 = OpLabel OpSelectionMerge %17 None OpSwitch %6 %18 1 %19 2 %20 %18 = OpLabel OpBranch %17 %19 = OpLabel OpBranch %15 %20 = OpLabel OpBranch %17 %17 = OpLabel OpBranch %15 %15 = OpLabel OpBranchConditional %8 %13 %14 %14 = OpLabel OpSelectionMerge %21 None OpBranchConditional %8 %22 %21 %22 = OpLabel OpSelectionMerge %23 None OpBranchConditional %8 %24 %23 %24 = OpLabel OpBranch %10 %23 = OpLabel OpBranch %21 %21 = OpLabel OpBranch %11 %10 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, PhiResultInvalidSampler) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %bool = OpTypeBool %f32 = OpTypeFloat 32 %sampler = OpTypeSampler %ptr_uc_sampler = OpTypePointer UniformConstant %sampler %sampler_var = OpVariable %ptr_uc_sampler UniformConstant %undef_bool = OpUndef %bool %undef_sampler = OpUndef %sampler %void_fn = OpTypeFunction %void %fn = OpFunction %void None %void_fn %entry = OpLabel %ld_sampler = OpLoad %sampler %sampler_var OpBranch %loop %loop = OpLabel %phi = OpPhi %sampler %undef_sampler %entry %ld_sampler %loop OpLoopMerge %exit %loop None OpBranchConditional %undef_bool %exit %loop %exit = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Result type cannot be OpTypeSampler")); } TEST_F(ValidateCFG, PhiResultInvalidImage) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %bool = OpTypeBool %f32 = OpTypeFloat 32 %image = OpTypeImage %f32 2D 0 0 0 1 Rgba32f %ptr_uc_image = OpTypePointer UniformConstant %image %image_var = OpVariable %ptr_uc_image UniformConstant %undef_bool = OpUndef %bool %undef_image = OpUndef %image %void_fn = OpTypeFunction %void %fn = OpFunction %void None %void_fn %entry = OpLabel %ld_image = OpLoad %image %image_var OpBranch %loop %loop = OpLabel %phi = OpPhi %image %undef_image %entry %ld_image %loop OpLoopMerge %exit %loop None OpBranchConditional %undef_bool %exit %loop %exit = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Result type cannot be OpTypeImage")); } TEST_F(ValidateCFG, PhiResultInvalidSampledImage) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %bool = OpTypeBool %f32 = OpTypeFloat 32 %sampler = OpTypeSampler %ptr_uc_sampler = OpTypePointer UniformConstant %sampler %sampler_var = OpVariable %ptr_uc_sampler UniformConstant %image = OpTypeImage %f32 2D 0 0 0 1 Rgba32f %ptr_uc_image = OpTypePointer UniformConstant %image %image_var = OpVariable %ptr_uc_image UniformConstant %sampled_image = OpTypeSampledImage %image %undef_bool = OpUndef %bool %undef_sampled_image = OpUndef %sampled_image %void_fn = OpTypeFunction %void %fn = OpFunction %void None %void_fn %entry = OpLabel %ld_image = OpLoad %image %image_var %ld_sampler = OpLoad %sampler %sampler_var OpBranch %loop %loop = OpLabel %phi = OpPhi %sampled_image %undef_sampled_image %entry %sample %loop %sample = OpSampledImage %sampled_image %ld_image %ld_sampler OpLoopMerge %exit %loop None OpBranchConditional %undef_bool %exit %loop %exit = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Result type cannot be OpTypeSampledImage")); } TEST_F(ValidateCFG, PhiResultValidPreLegalizationSampler) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %bool = OpTypeBool %f32 = OpTypeFloat 32 %sampler = OpTypeSampler %ptr_uc_sampler = OpTypePointer UniformConstant %sampler %sampler_var = OpVariable %ptr_uc_sampler UniformConstant %undef_bool = OpUndef %bool %undef_sampler = OpUndef %sampler %void_fn = OpTypeFunction %void %fn = OpFunction %void None %void_fn %entry = OpLabel %ld_sampler = OpLoad %sampler %sampler_var OpBranch %loop %loop = OpLabel %phi = OpPhi %sampler %undef_sampler %entry %ld_sampler %loop OpLoopMerge %exit %loop None OpBranchConditional %undef_bool %exit %loop %exit = OpLabel OpReturn OpFunctionEnd )"; options_->before_hlsl_legalization = true; CompileSuccessfully(text); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, PhiResultValidPreLegalizationImage) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %bool = OpTypeBool %f32 = OpTypeFloat 32 %image = OpTypeImage %f32 2D 0 0 0 1 Rgba32f %ptr_uc_image = OpTypePointer UniformConstant %image %image_var = OpVariable %ptr_uc_image UniformConstant %undef_bool = OpUndef %bool %undef_image = OpUndef %image %void_fn = OpTypeFunction %void %fn = OpFunction %void None %void_fn %entry = OpLabel %ld_image = OpLoad %image %image_var OpBranch %loop %loop = OpLabel %phi = OpPhi %image %undef_image %entry %ld_image %loop OpLoopMerge %exit %loop None OpBranchConditional %undef_bool %exit %loop %exit = OpLabel OpReturn OpFunctionEnd )"; options_->before_hlsl_legalization = true; CompileSuccessfully(text); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, PhiResultValidPreLegalizationSampledImage) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %bool = OpTypeBool %f32 = OpTypeFloat 32 %sampler = OpTypeSampler %ptr_uc_sampler = OpTypePointer UniformConstant %sampler %sampler_var = OpVariable %ptr_uc_sampler UniformConstant %image = OpTypeImage %f32 2D 0 0 0 1 Rgba32f %ptr_uc_image = OpTypePointer UniformConstant %image %image_var = OpVariable %ptr_uc_image UniformConstant %sampled_image = OpTypeSampledImage %image %undef_bool = OpUndef %bool %undef_sampled_image = OpUndef %sampled_image %void_fn = OpTypeFunction %void %fn = OpFunction %void None %void_fn %entry = OpLabel %ld_image = OpLoad %image %image_var %ld_sampler = OpLoad %sampler %sampler_var OpBranch %loop %loop = OpLabel %phi = OpPhi %sampled_image %undef_sampled_image %entry %sample %loop %sample = OpSampledImage %sampled_image %ld_image %ld_sampler OpLoopMerge %exit %loop None OpBranchConditional %undef_bool %exit %loop %exit = OpLabel OpReturn OpFunctionEnd )"; options_->before_hlsl_legalization = true; CompileSuccessfully(text); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, StructuredSelections_RegisterBothTrueAndFalse) { // In this test, we try to make a case where the false branches // to %20 and %60 from blocks %10 and %50 must be registered // during the validity check for sturctured selections. // However, an error is caught earlier in the flow, that the // branches from %100 to %20 and %60 violate dominance. const std::string text = R"( OpCapability Shader OpMemoryModel Logical Simple OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %void_fn = OpTypeFunction %void %bool = OpTypeBool %cond = OpUndef %bool %main = OpFunction %void None %void_fn %1 = OpLabel OpSelectionMerge %999 None OpBranchConditional %cond %10 %100 %10 = OpLabel OpSelectionMerge %30 None ; force registration of %30 OpBranchConditional %cond %30 %20 ; %20 should be registered too %20 = OpLabel OpBranch %30 %30 = OpLabel ; merge for first if OpBranch %50 %50 = OpLabel OpSelectionMerge %70 None ; force registration of %70 OpBranchConditional %cond %70 %60 ; %60 should be registered %60 = OpLabel OpBranch %70 %70 = OpLabel ; merge for second if OpBranch %999 %100 = OpLabel OpBranchConditional %cond %20 %60 ; should require a merge %999 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_NE(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("The selection construct with the selection header " "'8[%8]' does not structurally dominate the merge " "block '10[%10]'\n")); } TEST_F(ValidateCFG, UnreachableIsStaticallyReachable) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpFunction %1 None %2 %4 = OpLabel OpBranch %5 %5 = OpLabel OpUnreachable OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()); auto f = vstate_->function(3); auto entry = f->GetBlock(4).first; ASSERT_TRUE(entry->reachable()); auto end = f->GetBlock(5).first; ASSERT_TRUE(end->reachable()); } TEST_F(ValidateCFG, BlockOrderDoesNotAffectReachability) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpTypeBool %4 = OpUndef %3 %5 = OpFunction %1 None %2 %6 = OpLabel OpBranch %7 %7 = OpLabel OpSelectionMerge %8 None OpBranchConditional %4 %9 %10 %8 = OpLabel OpReturn %9 = OpLabel OpBranch %8 %10 = OpLabel OpBranch %8 %11 = OpLabel OpUnreachable OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()); auto f = vstate_->function(5); auto b6 = f->GetBlock(6).first; auto b7 = f->GetBlock(7).first; auto b8 = f->GetBlock(8).first; auto b9 = f->GetBlock(9).first; auto b10 = f->GetBlock(10).first; auto b11 = f->GetBlock(11).first; ASSERT_TRUE(b6->reachable()); ASSERT_TRUE(b7->reachable()); ASSERT_TRUE(b8->reachable()); ASSERT_TRUE(b9->reachable()); ASSERT_TRUE(b10->reachable()); ASSERT_FALSE(b11->reachable()); } TEST_F(ValidateCFG, PhiInstructionWithDuplicateIncomingEdges) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantTrue %6 %4 = OpFunction %2 None %3 %5 = OpLabel OpSelectionMerge %10 None OpBranchConditional %7 %8 %9 %8 = OpLabel OpBranch %10 %9 = OpLabel OpBranch %10 %10 = OpLabel %11 = OpPhi %6 %7 %8 %7 %8 OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpPhi references incoming basic block ")); EXPECT_THAT(getDiagnosticString(), HasSubstr("multiple times.")); } TEST_F(ValidateCFG, PhiOnVoid) { const std::string text = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpName %4 "main" OpName %6 "foo(" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpFunctionCall %2 %6 OpBranch %20 %20 = OpLabel %21 = OpPhi %2 %8 %20 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpPhi must not have void result type")); } TEST_F(ValidateCFG, InvalidExitSingleBlockLoop) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %5 "BAD" %void = OpTypeVoid %bool = OpTypeBool %undef = OpUndef %bool %void_fn = OpTypeFunction %void %fn = OpFunction %void None %void_fn %1 = OpLabel OpBranch %2 %2 = OpLabel OpLoopMerge %3 %4 None OpBranchConditional %undef %3 %5 %5 = OpLabel OpLoopMerge %6 %5 None OpBranchConditional %undef %5 %4 %6 = OpLabel OpReturn %4 = OpLabel OpBranch %2 %3 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("block '1[%BAD]' exits the continue headed by " "'1[%BAD]', but not via a structured exit")); } TEST_F(ValidateCFG, SwitchSelectorNotAnInt) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %float = OpTypeFloat 32 %float_1 = OpConstant %float 1 %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpSelectionMerge %default None OpSwitch %float_1 %default %default = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Selector type must be OpTypeInt")); } TEST_F(ValidateCFG, SwitchDefaultNotALabel) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_1 = OpConstant %int 1 %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpSelectionMerge %default None OpSwitch %int_1 %int_1 %default = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Default must be an OpLabel instruction")); } TEST_F(ValidateCFG, BlockDepthRecursion) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %bool = OpTypeBool %undef = OpUndef %bool %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %1 = OpLabel OpBranch %2 %2 = OpLabel OpLoopMerge %3 %4 None OpBranchConditional %undef %3 %4 %4 = OpLabel OpBranch %2 %3 = OpLabel OpBranch %5 %5 = OpLabel OpSelectionMerge %2 None OpBranchConditional %undef %6 %7 %6 = OpLabel OpReturn %7 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); } TEST_F(ValidateCFG, BadStructuredExitBackwardsMerge) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %bool = OpTypeBool %undef = OpUndef %bool %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %1 = OpLabel OpBranch %2 %2 = OpLabel OpLoopMerge %4 %5 None OpBranchConditional %undef %4 %6 %6 = OpLabel OpSelectionMerge %7 None OpBranchConditional %undef %8 %9 %7 = OpLabel OpReturn %8 = OpLabel OpBranch %5 %9 = OpLabel OpSelectionMerge %6 None OpBranchConditional %undef %5 %5 %5 = OpLabel OpBranch %2 %4 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); } TEST_F(ValidateCFG, BranchConditionalDifferentTargetsPre1p6) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %bool = OpTypeBool %undef = OpUndef %bool %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel OpBranchConditional %undef %target %target %target = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_5); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); } TEST_F(ValidateCFG, BranchConditionalDifferentTargetsPost1p6) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %bool = OpTypeBool %undef = OpUndef %bool %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel OpBranchConditional %undef %target %target %target = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_6); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_6)); EXPECT_THAT(getDiagnosticString(), HasSubstr("In SPIR-V 1.6 or later, True Label and False Label " "must be different labels")); } TEST_F(ValidateCFG, BadBackEdgeUnreachableContinue) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpFunction %1 None %2 %4 = OpLabel OpBranch %5 %5 = OpLabel OpLoopMerge %6 %7 None OpBranch %8 %8 = OpLabel OpBranch %5 %7 = OpLabel OpUnreachable %6 = OpLabel OpUnreachable OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("The continue construct with the continue target '7[%7]' " "does not structurally dominate the back-edge block '8[%8]'")); } TEST_F(ValidateCFG, BadLoop) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical Simple OpEntryPoint Fragment %2 " " OpExecutionMode %2 OriginUpperLeft OpName %49 "loop" %void = OpTypeVoid %12 = OpTypeFunction %void %2 = OpFunction %void None %12 %33 = OpLabel OpBranch %49 %50 = OpLabel OpBranch %49 %49 = OpLabel OpLoopMerge %33 %50 Unroll OpBranch %49 OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Loop header '2[%loop]' is targeted by 2 back-edge " "blocks but the standard requires exactly one")); } TEST_F(ValidateCFG, BadSwitch) { const std::string text = R"( OpCapability StorageImageExtendedFormats OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "blah" %58 OpExecutionMode %2 OriginUpperLeft OpName %BAD "BAD" %11 = OpTypeVoid %12 = OpTypeFunction %11 %19 = OpTypeInt 32 1 %21 = OpConstant %19 555758549 %2 = OpFunction %11 None %12 %4 = OpLabel OpBranch %33 %33 = OpLabel OpLoopMerge %34 %35 None OpBranch %55 %BAD = OpLabel OpSelectionMerge %53 None OpSwitch %21 %34 196153896 %53 20856160 %34 33570306 %34 593494531 %52 %55 = OpLabel OpLoopMerge %52 %58 DontUnroll OpBranch %35 %58 = OpLabel OpSelectionMerge %58 None OpSwitch %21 %52 178168 %55 608223677 %34 604111047 %34 -553516825 %34 -106432813 %BAD 6946864 %55 1257373689 %55 973090296 %35 -113180668 %55 537002232 %BAD 13762553 %BAD 1030172152 %35 -553516825 %55 -262137 %35 -1091822332 %BAD 131320 %52 131321 %35 131320 %52 131321 %35 -1091822332 %BAD %53 = OpLabel OpBranch %35 %52 = OpLabel OpBranch %34 %35 = OpLabel OpBranch %33 %34 = OpLabel OpKill OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("exits the selection headed by '3[%BAD]', but not " "via a structured exit")); } TEST_F(ValidateCFG, MaximalReconvergenceBranchConditionalSameTargetNotInCallTree) { const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_maximal_reconvergence" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpExecutionMode %main MaximallyReconvergesKHR %void = OpTypeVoid %bool = OpTypeBool %cond = OpUndef %bool %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %func_entry = OpLabel OpBranchConditional %cond %func_exit %func_exit %func_exit = OpLabel OpReturn OpFunctionEnd %main = OpFunction %void None %void_fn %main_entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateCFG, MaximalReconvergenceBranchConditionalSameTargetInCallTree) { const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_maximal_reconvergence" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpExecutionMode %main MaximallyReconvergesKHR %void = OpTypeVoid %bool = OpTypeBool %cond = OpUndef %bool %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %func_entry = OpLabel OpBranchConditional %cond %func_exit %func_exit %func_exit = OpLabel OpReturn OpFunctionEnd %main = OpFunction %void None %void_fn %main_entry = OpLabel %call = OpFunctionCall %void %func OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("In entry points using the MaximallyReconvergesKHR " "execution mode, True " "Label and False Label must be different labels")); } TEST_F(ValidateCFG, MaximalReconvergenceEarlyReconvergenceNotInCallTree) { const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_maximal_reconvergence" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpExecutionMode %main MaximallyReconvergesKHR %void = OpTypeVoid %bool = OpTypeBool %cond = OpUndef %bool %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %func_entry = OpLabel OpSelectionMerge %func_exit None OpBranchConditional %cond %then %else %then = OpLabel OpBranch %merge %else = OpLabel OpBranch %merge %merge = OpLabel OpBranch %func_exit %func_exit = OpLabel OpReturn OpFunctionEnd %main = OpFunction %void None %void_fn %main_entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, MaximalReconvergenceEarlyReconvergenceInCallTree) { const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_maximal_reconvergence" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpExecutionMode %main MaximallyReconvergesKHR %void = OpTypeVoid %bool = OpTypeBool %cond = OpUndef %bool %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %func_entry = OpLabel OpSelectionMerge %func_exit None OpBranchConditional %cond %then %else %then = OpLabel OpBranch %merge %else = OpLabel OpBranch %merge %merge = OpLabel OpBranch %func_exit %func_exit = OpLabel OpReturn OpFunctionEnd %main = OpFunction %void None %void_fn %main_entry = OpLabel %call = OpFunctionCall %void %func OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "In entry points using the MaximallyReconvergesKHR execution mode, " "this basic block must not have multiple unique predecessors")); } TEST_F(ValidateCFG, MaximalReconvergenceLoopMultiplePredsOk) { const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_maximal_reconvergence" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpExecutionMode %main MaximallyReconvergesKHR %void = OpTypeVoid %bool = OpTypeBool %cond = OpUndef %bool %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %main_entry = OpLabel OpBranch %loop %loop = OpLabel OpLoopMerge %merge %loop None OpBranchConditional %cond %loop %merge %merge = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, MaximalReconvergenceLoopMultiplePredsOk2) { const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_maximal_reconvergence" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpExecutionMode %main MaximallyReconvergesKHR %void = OpTypeVoid %bool = OpTypeBool %cond = OpUndef %bool %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %main_entry = OpLabel OpBranch %loop %loop = OpLabel OpLoopMerge %merge %cont None OpBranch %body %body = OpLabel OpBranch %cont %cont = OpLabel OpBranchConditional %cond %loop %merge %merge = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, MaximalReconvergenceSelectionMergeMultiplePredsOk) { const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_maximal_reconvergence" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpExecutionMode %main MaximallyReconvergesKHR %void = OpTypeVoid %bool = OpTypeBool %cond = OpUndef %bool %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %main_entry = OpLabel OpSelectionMerge %merge None OpBranchConditional %cond %then %else %then = OpLabel OpBranch %merge %else = OpLabel OpBranch %merge %merge = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, MaximalReconvergenceSelectionMergeMultiplePredsOk2) { const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_maximal_reconvergence" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpExecutionMode %main MaximallyReconvergesKHR OpName %merge "merge" %void = OpTypeVoid %bool = OpTypeBool %cond = OpUndef %bool %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %main_entry = OpLabel OpSelectionMerge %merge None OpBranchConditional %cond %then %else %then = OpLabel OpBranch %merge %else = OpLabel OpBranch %merge %merge = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, MaximalReconvergenceLoopMergeMultiplePredsOk) { const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_maximal_reconvergence" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpExecutionMode %main MaximallyReconvergesKHR %void = OpTypeVoid %bool = OpTypeBool %cond = OpUndef %bool %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %main_entry = OpLabel OpBranch %loop %loop = OpLabel OpLoopMerge %merge %continue None OpBranchConditional %cond %merge %continue %continue = OpLabel OpBranchConditional %cond %loop %merge %merge = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, MaximalReconvergenceCaseFallthroughMultiplePredsOk) { const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_maximal_reconvergence" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpExecutionMode %main MaximallyReconvergesKHR %void = OpTypeVoid %bool = OpTypeBool %cond = OpUndef %bool %int = OpTypeInt 32 0 %val = OpUndef %int %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %main_entry = OpLabel OpSelectionMerge %merge None OpSwitch %val %merge 0 %case1 1 %case2 %case1 = OpLabel OpBranch %case2 %case2 = OpLabel OpBranch %merge %merge = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, StructurallyUnreachableContinuePredecessor) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource ESSL 310 OpName %main "main" %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %int_n7 = OpConstant %int -7 %bool = OpTypeBool %main = OpFunction %void None %3 %8 = OpLabel OpBranch %9 %9 = OpLabel %10 = OpPhi %int %int_1 %8 %int_n7 %15 %12 = OpSGreaterThan %bool %10 %int_n7 OpLoopMerge %13 %15 None OpBranchConditional %12 %14 %13 %14 = OpLabel OpBranch %15 %15 = OpLabel OpBranch %9 %17 = OpLabel OpBranch %15 %13 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, FullyLoopPrecedingSwitchToContinue) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpName %main "main" %void = OpTypeVoid %3 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %main = OpFunction %void None %3 %4 = OpLabel OpBranch %7 %7 = OpLabel OpLoopMerge %8 %6 None OpBranch %5 %5 = OpLabel OpSelectionMerge %9 None OpBranchConditional %true %10 %9 %10 = OpLabel OpSelectionMerge %16 None OpSwitch %int_0 %13 %13 = OpLabel OpBranch %19 %19 = OpLabel OpLoopMerge %20 %18 None OpBranch %17 %17 = OpLabel OpReturn %18 = OpLabel OpBranch %19 %20 = OpLabel OpSelectionMerge %23 None OpSwitch %int_1 %21 %21 = OpLabel OpBranch %6 %23 = OpLabel OpBranch %16 %16 = OpLabel OpBranch %9 %9 = OpLabel OpBranch %6 %6 = OpLabel OpBranch %7 %8 = OpLabel OpUnreachable OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateCFG, CaseBreak) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpName %main "main" %void = OpTypeVoid %3 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %main = OpFunction %void None %3 %4 = OpLabel OpSelectionMerge %merge None OpSwitch %int_1 %case 2 %merge %case = OpLabel OpBranch %merge %merge = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_code_generator.cpp000066400000000000000000000115051475742701700246220ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "test/val/val_code_generator.h" #include namespace spvtools { namespace val { namespace { std::string GetDefaultShaderCapabilities() { return R"( OpCapability Shader OpCapability Geometry OpCapability Tessellation OpCapability Float64 OpCapability Int64 OpCapability MultiViewport OpCapability SampleRateShading )"; } std::string GetDefaultShaderTypes() { return R"( %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f32 = OpTypeFloat 32 %f64 = OpTypeFloat 64 %i32 = OpTypeInt 32 1 %i64 = OpTypeInt 64 1 %u32 = OpTypeInt 32 0 %u64 = OpTypeInt 64 0 %f32vec2 = OpTypeVector %f32 2 %f32vec3 = OpTypeVector %f32 3 %f32vec4 = OpTypeVector %f32 4 %f64vec2 = OpTypeVector %f64 2 %f64vec3 = OpTypeVector %f64 3 %f64vec4 = OpTypeVector %f64 4 %u32vec2 = OpTypeVector %u32 2 %u32vec3 = OpTypeVector %u32 3 %u64vec3 = OpTypeVector %u64 3 %u32vec4 = OpTypeVector %u32 4 %u64vec2 = OpTypeVector %u64 2 %f32_0 = OpConstant %f32 0 %f32_1 = OpConstant %f32 1 %f32_2 = OpConstant %f32 2 %f32_3 = OpConstant %f32 3 %f32_4 = OpConstant %f32 4 %f32_h = OpConstant %f32 0.5 %f32vec2_01 = OpConstantComposite %f32vec2 %f32_0 %f32_1 %f32vec2_12 = OpConstantComposite %f32vec2 %f32_1 %f32_2 %f32vec3_012 = OpConstantComposite %f32vec3 %f32_0 %f32_1 %f32_2 %f32vec3_123 = OpConstantComposite %f32vec3 %f32_1 %f32_2 %f32_3 %f32vec4_0123 = OpConstantComposite %f32vec4 %f32_0 %f32_1 %f32_2 %f32_3 %f32vec4_1234 = OpConstantComposite %f32vec4 %f32_1 %f32_2 %f32_3 %f32_4 %f64_0 = OpConstant %f64 0 %f64_1 = OpConstant %f64 1 %f64_2 = OpConstant %f64 2 %f64_3 = OpConstant %f64 3 %f64vec2_01 = OpConstantComposite %f64vec2 %f64_0 %f64_1 %f64vec3_012 = OpConstantComposite %f64vec3 %f64_0 %f64_1 %f64_2 %f64vec4_0123 = OpConstantComposite %f64vec4 %f64_0 %f64_1 %f64_2 %f64_3 %u32_0 = OpConstant %u32 0 %u32_1 = OpConstant %u32 1 %u32_2 = OpConstant %u32 2 %u32_3 = OpConstant %u32 3 %u32_4 = OpConstant %u32 4 %u64_0 = OpConstant %u64 0 %u64_1 = OpConstant %u64 1 %u64_2 = OpConstant %u64 2 %u64_3 = OpConstant %u64 3 %u32vec2_01 = OpConstantComposite %u32vec2 %u32_0 %u32_1 %u32vec2_12 = OpConstantComposite %u32vec2 %u32_1 %u32_2 %u32vec4_0123 = OpConstantComposite %u32vec4 %u32_0 %u32_1 %u32_2 %u32_3 %u64vec2_01 = OpConstantComposite %u64vec2 %u64_0 %u64_1 %u32arr2 = OpTypeArray %u32 %u32_2 %u32arr3 = OpTypeArray %u32 %u32_3 %u32arr4 = OpTypeArray %u32 %u32_4 %u64arr2 = OpTypeArray %u64 %u32_2 %u64arr3 = OpTypeArray %u64 %u32_3 %u64arr4 = OpTypeArray %u64 %u32_4 %f32arr2 = OpTypeArray %f32 %u32_2 %f32arr3 = OpTypeArray %f32 %u32_3 %f32arr4 = OpTypeArray %f32 %u32_4 %f64arr2 = OpTypeArray %f64 %u32_2 %f64arr3 = OpTypeArray %f64 %u32_3 %f64arr4 = OpTypeArray %f64 %u32_4 %f32vec3arr3 = OpTypeArray %f32vec3 %u32_3 %f32vec4arr3 = OpTypeArray %f32vec4 %u32_3 %f64vec4arr3 = OpTypeArray %f64vec4 %u32_3 %f32mat22 = OpTypeMatrix %f32vec2 2 %f32mat23 = OpTypeMatrix %f32vec2 3 %f32mat32 = OpTypeMatrix %f32vec3 2 %f32mat33 = OpTypeMatrix %f32vec3 3 %f64mat22 = OpTypeMatrix %f64vec2 2 %f32mat34 = OpTypeMatrix %f32vec3 4 %f32mat43 = OpTypeMatrix %f32vec4 3 %f32mat44 = OpTypeMatrix %f32vec4 4 )"; } } // namespace CodeGenerator CodeGenerator::GetDefaultShaderCodeGenerator() { CodeGenerator generator; generator.capabilities_ = GetDefaultShaderCapabilities(); generator.memory_model_ = "OpMemoryModel Logical GLSL450\n"; generator.types_ = GetDefaultShaderTypes(); return generator; } std::string CodeGenerator::Build() const { std::ostringstream ss; ss << capabilities_; ss << extensions_; ss << memory_model_; for (const EntryPoint& entry_point : entry_points_) { ss << "OpEntryPoint " << entry_point.execution_model << " %" << entry_point.name << " \"" << entry_point.name << "\" " << entry_point.interfaces << "\n"; } for (const EntryPoint& entry_point : entry_points_) { ss << entry_point.execution_modes << "\n"; } ss << before_types_; ss << types_; ss << after_types_; for (const EntryPoint& entry_point : entry_points_) { ss << "\n"; ss << "%" << entry_point.name << " = OpFunction %void None %func\n"; ss << "%" << entry_point.name << "_entry = OpLabel\n"; ss << entry_point.body; ss << "\nOpReturn\nOpFunctionEnd\n"; } ss << add_at_the_end_; return ss.str(); } } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_code_generator.h000066400000000000000000000024101475742701700242620ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Utility class used to generate SPIR-V code strings for tests #include #include namespace spvtools { namespace val { struct EntryPoint { std::string name; std::string execution_model; std::string execution_modes; std::string body; std::string interfaces; }; class CodeGenerator { public: static CodeGenerator GetDefaultShaderCodeGenerator(); std::string Build() const; std::vector entry_points_; std::string capabilities_; std::string extensions_; std::string memory_model_; std::string before_types_; std::string types_; std::string after_types_; std::string add_at_the_end_; }; } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_composites_test.cpp000066400000000000000000002311501475742701700250660ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gmock/gmock.h" #include "test/unit_spirv.h" #include "test/val/val_code_generator.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::HasSubstr; using ::testing::Not; using ::testing::Values; using ValidateComposites = spvtest::ValidateBase; std::string GenerateShaderCode( const std::string& body, const std::string& capabilities_and_extensions = "", const std::string& execution_model = "Fragment") { std::ostringstream ss; ss << R"( OpCapability Shader OpCapability Float64 )"; ss << capabilities_and_extensions; ss << "OpMemoryModel Logical GLSL450\n"; ss << "OpEntryPoint " << execution_model << " %main \"main\"\n"; if (execution_model == "Fragment") { ss << "OpExecutionMode %main OriginUpperLeft\n"; } ss << R"( %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f32 = OpTypeFloat 32 %f64 = OpTypeFloat 64 %u32 = OpTypeInt 32 0 %s32 = OpTypeInt 32 1 %f32vec2 = OpTypeVector %f32 2 %f32vec3 = OpTypeVector %f32 3 %f32vec4 = OpTypeVector %f32 4 %f64vec2 = OpTypeVector %f64 2 %u32vec2 = OpTypeVector %u32 2 %u32vec4 = OpTypeVector %u32 4 %f64mat22 = OpTypeMatrix %f64vec2 2 %f32mat22 = OpTypeMatrix %f32vec2 2 %f32mat23 = OpTypeMatrix %f32vec2 3 %f32mat32 = OpTypeMatrix %f32vec3 2 %f32_0 = OpConstant %f32 0 %f32_1 = OpConstant %f32 1 %f32_2 = OpConstant %f32 2 %f32_3 = OpConstant %f32 3 %f32vec2_01 = OpConstantComposite %f32vec2 %f32_0 %f32_1 %f32vec2_12 = OpConstantComposite %f32vec2 %f32_1 %f32_2 %f32vec4_0123 = OpConstantComposite %f32vec4 %f32_0 %f32_1 %f32_2 %f32_3 %u32_0 = OpConstant %u32 0 %u32_1 = OpConstant %u32 1 %u32_2 = OpConstant %u32 2 %u32_3 = OpConstant %u32 3 %u32vec2_01 = OpConstantComposite %u32vec2 %u32_0 %u32_1 %u32vec4_0123 = OpConstantComposite %u32vec4 %u32_0 %u32_1 %u32_2 %u32_3 %f32mat22_1212 = OpConstantComposite %f32mat22 %f32vec2_12 %f32vec2_12 %f32mat23_121212 = OpConstantComposite %f32mat23 %f32vec2_12 %f32vec2_12 %f32vec2_12 %f32vec2arr3 = OpTypeArray %f32vec2 %u32_3 %f32vec2arr2 = OpTypeArray %f32vec2 %u32_2 %f32u32struct = OpTypeStruct %f32 %u32 %big_struct = OpTypeStruct %f32 %f32vec4 %f32mat23 %f32vec2arr3 %f32vec2arr2 %f32u32struct %ptr_big_struct = OpTypePointer Uniform %big_struct %var_big_struct = OpVariable %ptr_big_struct Uniform %main = OpFunction %void None %func %main_entry = OpLabel )"; ss << body; ss << R"( OpReturn OpFunctionEnd)"; return ss.str(); } // Returns header for legacy tests taken from val_id_test.cpp. std::string GetHeaderForTestsFromValId() { return R"( OpCapability Shader OpCapability Linkage OpCapability Addresses OpCapability Pipes OpCapability LiteralSampler OpCapability DeviceEnqueue OpCapability Vector16 OpCapability Int8 OpCapability Int16 OpCapability Int64 OpCapability Float64 OpMemoryModel Logical GLSL450 %void = OpTypeVoid %void_f = OpTypeFunction %void %int = OpTypeInt 32 0 %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %mat4x3 = OpTypeMatrix %v3float 4 %_ptr_Private_mat4x3 = OpTypePointer Private %mat4x3 %_ptr_Private_float = OpTypePointer Private %float %my_matrix = OpVariable %_ptr_Private_mat4x3 Private %my_float_var = OpVariable %_ptr_Private_float Private %_ptr_Function_float = OpTypePointer Function %float %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %int_3 = OpConstant %int 3 %int_5 = OpConstant %int 5 ; Making the following nested structures. ; ; struct S { ; bool b; ; vec4 v[5]; ; int i; ; mat4x3 m[5]; ; } ; uniform blockName { ; S s; ; bool cond; ; } %f32arr = OpTypeRuntimeArray %float %v4float = OpTypeVector %float 4 %array5_mat4x3 = OpTypeArray %mat4x3 %int_5 %array5_vec4 = OpTypeArray %v4float %int_5 %_ptr_Uniform_float = OpTypePointer Uniform %float %_ptr_Function_vec4 = OpTypePointer Function %v4float %_ptr_Uniform_vec4 = OpTypePointer Uniform %v4float %struct_s = OpTypeStruct %int %array5_vec4 %int %array5_mat4x3 %struct_blockName = OpTypeStruct %struct_s %int %_ptr_Uniform_blockName = OpTypePointer Uniform %struct_blockName %_ptr_Uniform_struct_s = OpTypePointer Uniform %struct_s %_ptr_Uniform_array5_mat4x3 = OpTypePointer Uniform %array5_mat4x3 %_ptr_Uniform_mat4x3 = OpTypePointer Uniform %mat4x3 %_ptr_Uniform_v3float = OpTypePointer Uniform %v3float %blockName_var = OpVariable %_ptr_Uniform_blockName Uniform %spec_int = OpSpecConstant %int 2 %func = OpFunction %void None %void_f %my_label = OpLabel )"; } TEST_F(ValidateComposites, VectorExtractDynamicSuccess) { const std::string body = R"( %val1 = OpVectorExtractDynamic %f32 %f32vec4_0123 %u32_0 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateComposites, VectorExtractDynamicWrongResultType) { const std::string body = R"( %val1 = OpVectorExtractDynamic %f32vec4 %f32vec4_0123 %u32_0 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be a scalar type")); } TEST_F(ValidateComposites, VectorExtractDynamicNotVector) { const std::string body = R"( %val1 = OpVectorExtractDynamic %f32 %f32mat22_1212 %u32_0 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Vector type to be OpTypeVector")); } TEST_F(ValidateComposites, VectorExtractDynamicWrongVectorComponent) { const std::string body = R"( %val1 = OpVectorExtractDynamic %f32 %u32vec4_0123 %u32_0 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Vector component type to be equal to Result Type")); } TEST_F(ValidateComposites, VectorExtractDynamicWrongIndexType) { const std::string body = R"( %val1 = OpVectorExtractDynamic %f32 %f32vec4_0123 %f32_0 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Index to be int scalar")); } TEST_F(ValidateComposites, VectorInsertDynamicSuccess) { const std::string body = R"( %val1 = OpVectorInsertDynamic %f32vec4 %f32vec4_0123 %f32_1 %u32_0 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateComposites, VectorInsertDynamicWrongResultType) { const std::string body = R"( %val1 = OpVectorInsertDynamic %f32 %f32vec4_0123 %f32_1 %u32_0 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be OpTypeVector")); } TEST_F(ValidateComposites, VectorInsertDynamicNotVector) { const std::string body = R"( %val1 = OpVectorInsertDynamic %f32vec4 %f32mat22_1212 %f32_1 %u32_0 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Vector type to be equal to Result Type")); } TEST_F(ValidateComposites, VectorInsertDynamicWrongComponentType) { const std::string body = R"( %val1 = OpVectorInsertDynamic %f32vec4 %f32vec4_0123 %u32_1 %u32_0 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Component type to be equal to Result Type " "component type")); } TEST_F(ValidateComposites, VectorInsertDynamicWrongIndexType) { const std::string body = R"( %val1 = OpVectorInsertDynamic %f32vec4 %f32vec4_0123 %f32_1 %f32_0 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Index to be int scalar")); } TEST_F(ValidateComposites, CompositeConstructNotComposite) { const std::string body = R"( %val1 = OpCompositeConstruct %f32 %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be a composite type")); } TEST_F(ValidateComposites, CompositeConstructVectorSuccess) { const std::string body = R"( %val1 = OpCompositeConstruct %f32vec4 %f32vec2_12 %f32vec2_12 %val2 = OpCompositeConstruct %f32vec4 %f32vec2_12 %f32_0 %f32_0 %val3 = OpCompositeConstruct %f32vec4 %f32_0 %f32_0 %f32vec2_12 %val4 = OpCompositeConstruct %f32vec4 %f32_0 %f32_1 %f32_2 %f32_3 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateComposites, CompositeConstructVectorOnlyOneConstituent) { const std::string body = R"( %val1 = OpCompositeConstruct %f32vec4 %f32vec4_0123 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected number of constituents to be at least 2")); } TEST_F(ValidateComposites, CompositeConstructVectorWrongConsituent1) { const std::string body = R"( %val1 = OpCompositeConstruct %f32vec4 %f32 %f32vec2_12 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Operand '5[%float]' cannot be a " "type")); } TEST_F(ValidateComposites, CompositeConstructVectorWrongConsituent2) { const std::string body = R"( %val1 = OpCompositeConstruct %f32vec4 %f32vec2_12 %u32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Constituents to be scalars or vectors of the same " "type as Result Type components")); } TEST_F(ValidateComposites, CompositeConstructVectorWrongConsituent3) { const std::string body = R"( %val1 = OpCompositeConstruct %f32vec4 %f32vec2_12 %u32_0 %f32_0 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Constituents to be scalars or vectors of the same " "type as Result Type components")); } TEST_F(ValidateComposites, CompositeConstructVectorWrongComponentNumber1) { const std::string body = R"( %val1 = OpCompositeConstruct %f32vec4 %f32vec2_12 %f32_0 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected total number of given components to be equal to the " "size of Result Type vector")); } TEST_F(ValidateComposites, CompositeConstructVectorWrongComponentNumber2) { const std::string body = R"( %val1 = OpCompositeConstruct %f32vec4 %f32vec2_12 %f32vec2_12 %f32_0 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected total number of given components to be equal to the " "size of Result Type vector")); } TEST_F(ValidateComposites, CompositeConstructMatrixSuccess) { const std::string body = R"( %val1 = OpCompositeConstruct %f32mat22 %f32vec2_12 %f32vec2_12 %val2 = OpCompositeConstruct %f32mat23 %f32vec2_12 %f32vec2_12 %f32vec2_12 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateComposites, CompositeConstructVectorWrongConsituentNumber1) { const std::string body = R"( %val1 = OpCompositeConstruct %f32mat22 %f32vec2_12 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected total number of Constituents to be equal to the " "number of columns of Result Type matrix")); } TEST_F(ValidateComposites, CompositeConstructVectorWrongConsituentNumber2) { const std::string body = R"( %val1 = OpCompositeConstruct %f32mat22 %f32vec2_12 %f32vec2_12 %f32vec2_12 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected total number of Constituents to be equal to the " "number of columns of Result Type matrix")); } TEST_F(ValidateComposites, CompositeConstructVectorWrongConsituent) { const std::string body = R"( %val1 = OpCompositeConstruct %f32mat22 %f32vec2_12 %u32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Constituent type to be equal to the column type " "Result Type matrix")); } TEST_F(ValidateComposites, CompositeConstructArraySuccess) { const std::string body = R"( %val1 = OpCompositeConstruct %f32vec2arr3 %f32vec2_12 %f32vec2_12 %f32vec2_12 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateComposites, CompositeConstructArrayWrongConsituentNumber1) { const std::string body = R"( %val1 = OpCompositeConstruct %f32vec2arr3 %f32vec2_12 %f32vec2_12 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected total number of Constituents to be equal to the " "number of elements of Result Type array")); } TEST_F(ValidateComposites, CompositeConstructArrayWrongConsituentNumber2) { const std::string body = R"( %val1 = OpCompositeConstruct %f32vec2arr3 %f32vec2_12 %f32vec2_12 %f32vec2_12 %f32vec2_12 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected total number of Constituents to be equal to the " "number of elements of Result Type array")); } TEST_F(ValidateComposites, CompositeConstructArrayWrongConsituent) { const std::string body = R"( %val1 = OpCompositeConstruct %f32vec2arr3 %f32vec2_12 %u32vec2_01 %f32vec2_12 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Constituent type to be equal to the column type " "Result Type array")); } TEST_F(ValidateComposites, CompositeConstructStructSuccess) { const std::string body = R"( %val1 = OpCompositeConstruct %f32u32struct %f32_0 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateComposites, CompositeConstructStructWrongConstituentNumber1) { const std::string body = R"( %val1 = OpCompositeConstruct %f32u32struct %f32_0 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected total number of Constituents to be equal to the " "number of members of Result Type struct")); } TEST_F(ValidateComposites, CompositeConstructStructWrongConstituentNumber2) { const std::string body = R"( %val1 = OpCompositeConstruct %f32u32struct %f32_0 %u32_1 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected total number of Constituents to be equal to the " "number of members of Result Type struct")); } TEST_F(ValidateComposites, CompositeConstructStructWrongConstituent) { const std::string body = R"( %val1 = OpCompositeConstruct %f32u32struct %f32_0 %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Constituent type to be equal to the " "corresponding member type of Result Type struct")); } TEST_F(ValidateComposites, CopyObjectSuccess) { const std::string body = R"( %val1 = OpCopyObject %f32 %f32_0 %val2 = OpCopyObject %f32vec4 %f32vec4_0123 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateComposites, CopyObjectResultTypeNotType) { const std::string body = R"( %val1 = OpCopyObject %f32_0 %f32_0 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("ID '19[%float_0]' is not a type id")); } TEST_F(ValidateComposites, CopyObjectWrongOperandType) { const std::string body = R"( %val1 = OpCopyObject %f32 %u32_0 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Result Type and Operand type to be the same")); } TEST_F(ValidateComposites, TransposeSuccess) { const std::string body = R"( %val1 = OpTranspose %f32mat32 %f32mat23_121212 %val2 = OpTranspose %f32mat22 %f32mat22_1212 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateComposites, TransposeResultTypeNotMatrix) { const std::string body = R"( %val1 = OpTranspose %f32vec4 %f32mat22_1212 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be a matrix type")); } TEST_F(ValidateComposites, TransposeDifferentComponentTypes) { const std::string body = R"( %val1 = OpTranspose %f64mat22 %f32mat22_1212 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected component types of Matrix and Result Type to be " "identical")); } TEST_F(ValidateComposites, TransposeIncompatibleDimensions1) { const std::string body = R"( %val1 = OpTranspose %f32mat23 %f32mat22_1212 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected number of columns and the column size " "of Matrix to be the reverse of those of Result Type")); } TEST_F(ValidateComposites, TransposeIncompatibleDimensions2) { const std::string body = R"( %val1 = OpTranspose %f32mat32 %f32mat22_1212 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected number of columns and the column size " "of Matrix to be the reverse of those of Result Type")); } TEST_F(ValidateComposites, TransposeIncompatibleDimensions3) { const std::string body = R"( %val1 = OpTranspose %f32mat23 %f32mat23_121212 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected number of columns and the column size " "of Matrix to be the reverse of those of Result Type")); } TEST_F(ValidateComposites, CompositeExtractSuccess) { const std::string body = R"( %val1 = OpCompositeExtract %f32 %f32vec4_0123 1 %val2 = OpCompositeExtract %u32 %u32vec4_0123 0 %val3 = OpCompositeExtract %f32 %f32mat22_1212 0 1 %val4 = OpCompositeExtract %f32vec2 %f32mat22_1212 0 %array = OpCompositeConstruct %f32vec2arr3 %f32vec2_12 %f32vec2_12 %f32vec2_12 %val5 = OpCompositeExtract %f32vec2 %array 2 %val6 = OpCompositeExtract %f32 %array 2 1 %struct = OpLoad %big_struct %var_big_struct %val7 = OpCompositeExtract %f32 %struct 0 %val8 = OpCompositeExtract %f32vec4 %struct 1 %val9 = OpCompositeExtract %f32 %struct 1 2 %val10 = OpCompositeExtract %f32mat23 %struct 2 %val11 = OpCompositeExtract %f32vec2 %struct 2 2 %val12 = OpCompositeExtract %f32 %struct 2 2 1 %val13 = OpCompositeExtract %f32vec2 %struct 3 2 %val14 = OpCompositeExtract %f32 %struct 3 2 1 %val15 = OpCompositeExtract %f32vec2 %struct 4 1 %val16 = OpCompositeExtract %f32 %struct 4 0 1 %val17 = OpCompositeExtract %f32 %struct 5 0 %val18 = OpCompositeExtract %u32 %struct 5 1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateComposites, CompositeExtractNotObject) { const std::string body = R"( %val1 = OpCompositeExtract %f32 %f32vec4 1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Operand '11[%v4float]' cannot " "be a type")); } TEST_F(ValidateComposites, CompositeExtractNotComposite) { const std::string body = R"( %val1 = OpCompositeExtract %f32 %f32_1 0 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Reached non-composite type while indexes still remain " "to be traversed.")); } TEST_F(ValidateComposites, CompositeExtractVectorOutOfBounds) { const std::string body = R"( %val1 = OpCompositeExtract %f32 %f32vec4_0123 4 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Vector access is out of bounds, " "vector size is 4, but access index is 4")); } TEST_F(ValidateComposites, CompositeExtractMatrixOutOfCols) { const std::string body = R"( %val1 = OpCompositeExtract %f32 %f32mat23_121212 3 1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Matrix access is out of bounds, " "matrix has 3 columns, but access index is 3")); } TEST_F(ValidateComposites, CompositeExtractMatrixOutOfRows) { const std::string body = R"( %val1 = OpCompositeExtract %f32 %f32mat23_121212 2 5 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Vector access is out of bounds, " "vector size is 2, but access index is 5")); } TEST_F(ValidateComposites, CompositeExtractArrayOutOfBounds) { const std::string body = R"( %array = OpCompositeConstruct %f32vec2arr3 %f32vec2_12 %f32vec2_12 %f32vec2_12 %val1 = OpCompositeExtract %f32vec2 %array 3 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Array access is out of bounds, " "array size is 3, but access index is 3")); } TEST_F(ValidateComposites, CompositeExtractStructOutOfBounds) { const std::string body = R"( %struct = OpLoad %big_struct %var_big_struct %val1 = OpCompositeExtract %f32 %struct 6 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Index is out of bounds, can not find index 6 in the " "structure '37'. This structure has 6 members. " "Largest valid index is 5.")); } TEST_F(ValidateComposites, CompositeExtractNestedVectorOutOfBounds) { const std::string body = R"( %struct = OpLoad %big_struct %var_big_struct %val1 = OpCompositeExtract %f32 %struct 3 1 5 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Vector access is out of bounds, " "vector size is 2, but access index is 5")); } TEST_F(ValidateComposites, CompositeExtractTooManyIndices) { const std::string body = R"( %struct = OpLoad %big_struct %var_big_struct %val1 = OpCompositeExtract %f32 %struct 3 1 1 2 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Reached non-composite type while " "indexes still remain to be traversed.")); } TEST_F(ValidateComposites, CompositeExtractNoIndices) { const std::string body = R"( %struct = OpLoad %big_struct %var_big_struct %val1 = OpCompositeExtract %big_struct %struct )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected at least one index to OpCompositeExtract")); } TEST_F(ValidateComposites, CompositeExtractWrongType1) { const std::string body = R"( %struct = OpLoad %big_struct %var_big_struct %val1 = OpCompositeExtract %f32vec2 %struct 3 1 1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Result type (OpTypeVector) does not match the type that results " "from indexing into the composite (OpTypeFloat).")); } TEST_F(ValidateComposites, CompositeExtractWrongType2) { const std::string body = R"( %struct = OpLoad %big_struct %var_big_struct %val1 = OpCompositeExtract %f32 %struct 3 1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Result type (OpTypeFloat) does not match the type " "that results from indexing into the composite " "(OpTypeVector).")); } TEST_F(ValidateComposites, CompositeExtractWrongType3) { const std::string body = R"( %struct = OpLoad %big_struct %var_big_struct %val1 = OpCompositeExtract %f32 %struct 2 1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Result type (OpTypeFloat) does not match the type " "that results from indexing into the composite " "(OpTypeVector).")); } TEST_F(ValidateComposites, CompositeExtractWrongType4) { const std::string body = R"( %struct = OpLoad %big_struct %var_big_struct %val1 = OpCompositeExtract %f32 %struct 4 1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Result type (OpTypeFloat) does not match the type " "that results from indexing into the composite " "(OpTypeVector).")); } TEST_F(ValidateComposites, CompositeExtractWrongType5) { const std::string body = R"( %struct = OpLoad %big_struct %var_big_struct %val1 = OpCompositeExtract %f32 %struct 5 1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Result type (OpTypeFloat) does not match the " "type that results from indexing into the composite (OpTypeInt).")); } TEST_F(ValidateComposites, CompositeInsertSuccess) { const std::string body = R"( %val1 = OpCompositeInsert %f32vec4 %f32_1 %f32vec4_0123 0 %val2 = OpCompositeInsert %u32vec4 %u32_1 %u32vec4_0123 0 %val3 = OpCompositeInsert %f32mat22 %f32_2 %f32mat22_1212 0 1 %val4 = OpCompositeInsert %f32mat22 %f32vec2_01 %f32mat22_1212 0 %array = OpCompositeConstruct %f32vec2arr3 %f32vec2_12 %f32vec2_12 %f32vec2_12 %val5 = OpCompositeInsert %f32vec2arr3 %f32vec2_01 %array 2 %val6 = OpCompositeInsert %f32vec2arr3 %f32_3 %array 2 1 %struct = OpLoad %big_struct %var_big_struct %val7 = OpCompositeInsert %big_struct %f32_3 %struct 0 %val8 = OpCompositeInsert %big_struct %f32vec4_0123 %struct 1 %val9 = OpCompositeInsert %big_struct %f32_3 %struct 1 2 %val10 = OpCompositeInsert %big_struct %f32mat23_121212 %struct 2 %val11 = OpCompositeInsert %big_struct %f32vec2_01 %struct 2 2 %val12 = OpCompositeInsert %big_struct %f32_3 %struct 2 2 1 %val13 = OpCompositeInsert %big_struct %f32vec2_01 %struct 3 2 %val14 = OpCompositeInsert %big_struct %f32_3 %struct 3 2 1 %val15 = OpCompositeInsert %big_struct %f32vec2_01 %struct 4 1 %val16 = OpCompositeInsert %big_struct %f32_3 %struct 4 0 1 %val17 = OpCompositeInsert %big_struct %f32_3 %struct 5 0 %val18 = OpCompositeInsert %big_struct %u32_3 %struct 5 1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateComposites, CompositeInsertResultTypeDifferentFromComposite) { const std::string body = R"( %val1 = OpCompositeInsert %f32 %f32_1 %f32vec4_0123 0 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("The Result Type must be the same as Composite type in " "OpCompositeInsert yielding Result Id 5.")); } TEST_F(ValidateComposites, CompositeInsertNotComposite) { const std::string body = R"( %val1 = OpCompositeInsert %f32 %f32_1 %f32_0 0 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Reached non-composite type while indexes still remain " "to be traversed.")); } TEST_F(ValidateComposites, CompositeInsertVectorOutOfBounds) { const std::string body = R"( %val1 = OpCompositeInsert %f32vec4 %f32_1 %f32vec4_0123 4 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Vector access is out of bounds, " "vector size is 4, but access index is 4")); } TEST_F(ValidateComposites, CompositeInsertMatrixOutOfCols) { const std::string body = R"( %val1 = OpCompositeInsert %f32mat23 %f32_1 %f32mat23_121212 3 1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Matrix access is out of bounds, " "matrix has 3 columns, but access index is 3")); } TEST_F(ValidateComposites, CompositeInsertMatrixOutOfRows) { const std::string body = R"( %val1 = OpCompositeInsert %f32mat23 %f32_1 %f32mat23_121212 2 5 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Vector access is out of bounds, " "vector size is 2, but access index is 5")); } TEST_F(ValidateComposites, CompositeInsertArrayOutOfBounds) { const std::string body = R"( %array = OpCompositeConstruct %f32vec2arr3 %f32vec2_12 %f32vec2_12 %f32vec2_12 %val1 = OpCompositeInsert %f32vec2arr3 %f32vec2_01 %array 3 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Array access is out of bounds, array " "size is 3, but access index is 3")); } TEST_F(ValidateComposites, CompositeInsertStructOutOfBounds) { const std::string body = R"( %struct = OpLoad %big_struct %var_big_struct %val1 = OpCompositeInsert %big_struct %f32_1 %struct 6 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Index is out of bounds, can not find index 6 in the " "structure '37'. This structure has 6 members. " "Largest valid index is 5.")); } TEST_F(ValidateComposites, CompositeInsertNestedVectorOutOfBounds) { const std::string body = R"( %struct = OpLoad %big_struct %var_big_struct %val1 = OpCompositeInsert %big_struct %f32_1 %struct 3 1 5 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Vector access is out of bounds, " "vector size is 2, but access index is 5")); } TEST_F(ValidateComposites, CompositeInsertTooManyIndices) { const std::string body = R"( %struct = OpLoad %big_struct %var_big_struct %val1 = OpCompositeInsert %big_struct %f32_1 %struct 3 1 1 2 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Reached non-composite type while indexes still remain " "to be traversed.")); } TEST_F(ValidateComposites, CompositeInsertWrongType1) { const std::string body = R"( %struct = OpLoad %big_struct %var_big_struct %val1 = OpCompositeInsert %big_struct %f32vec2_01 %struct 3 1 1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("The Object type (OpTypeVector) does not match the " "type that results from indexing into the Composite " "(OpTypeFloat).")); } TEST_F(ValidateComposites, CompositeInsertWrongType2) { const std::string body = R"( %struct = OpLoad %big_struct %var_big_struct %val1 = OpCompositeInsert %big_struct %f32_1 %struct 3 1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("The Object type (OpTypeFloat) does not match the type " "that results from indexing into the Composite " "(OpTypeVector).")); } TEST_F(ValidateComposites, CompositeInsertWrongType3) { const std::string body = R"( %struct = OpLoad %big_struct %var_big_struct %val1 = OpCompositeInsert %big_struct %f32_1 %struct 2 1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("The Object type (OpTypeFloat) does not match the type " "that results from indexing into the Composite " "(OpTypeVector).")); } TEST_F(ValidateComposites, CompositeInsertWrongType4) { const std::string body = R"( %struct = OpLoad %big_struct %var_big_struct %val1 = OpCompositeInsert %big_struct %f32_1 %struct 4 1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("The Object type (OpTypeFloat) does not match the type " "that results from indexing into the Composite " "(OpTypeVector).")); } TEST_F(ValidateComposites, CompositeInsertWrongType5) { const std::string body = R"( %struct = OpLoad %big_struct %var_big_struct %val1 = OpCompositeInsert %big_struct %f32_1 %struct 5 1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("The Object type (OpTypeFloat) does not match the type " "that results from indexing into the Composite " "(OpTypeInt).")); } // Tests ported from val_id_test.cpp. // Valid. Tests both CompositeExtract and CompositeInsert with 255 indexes. TEST_F(ValidateComposites, CompositeExtractInsertLimitsGood) { int depth = 255; std::string header = GetHeaderForTestsFromValId(); header.erase(header.find("%func")); std::ostringstream spirv; spirv << header << std::endl; // Build nested structures. Struct 'i' contains struct 'i-1' spirv << "%s_depth_1 = OpTypeStruct %float\n"; for (int i = 2; i <= depth; ++i) { spirv << "%s_depth_" << i << " = OpTypeStruct %s_depth_" << i - 1 << "\n"; } // Define Pointer and Variable to use for CompositeExtract/Insert. spirv << "%_ptr_Uniform_deep_struct = OpTypePointer Uniform %s_depth_" << depth << "\n"; spirv << "%deep_var = OpVariable %_ptr_Uniform_deep_struct Uniform\n"; // Function Start spirv << R"( %func = OpFunction %void None %void_f %my_label = OpLabel )"; // OpCompositeExtract/Insert with 'n' indexes (n = depth) spirv << "%deep = OpLoad %s_depth_" << depth << " %deep_var" << std::endl; spirv << "%entry = OpCompositeExtract %float %deep"; for (int i = 0; i < depth; ++i) { spirv << " 0"; } spirv << std::endl; spirv << "%new_composite = OpCompositeInsert %s_depth_" << depth << " %entry %deep"; for (int i = 0; i < depth; ++i) { spirv << " 0"; } spirv << std::endl; // Function end spirv << R"( OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // Invalid: 256 indexes passed to OpCompositeExtract. Limit is 255. TEST_F(ValidateComposites, CompositeExtractArgCountExceededLimitBad) { std::ostringstream spirv; spirv << GetHeaderForTestsFromValId() << std::endl; spirv << "%matrix = OpLoad %mat4x3 %my_matrix" << std::endl; spirv << "%entry = OpCompositeExtract %float %matrix"; for (int i = 0; i < 256; ++i) { spirv << " 0"; } spirv << R"( OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("The number of indexes in OpCompositeExtract may not " "exceed 255. Found 256 indexes.")); } // Invalid: 256 indexes passed to OpCompositeInsert. Limit is 255. TEST_F(ValidateComposites, CompositeInsertArgCountExceededLimitBad) { std::ostringstream spirv; spirv << GetHeaderForTestsFromValId() << std::endl; spirv << "%matrix = OpLoad %mat4x3 %my_matrix" << std::endl; spirv << "%new_composite = OpCompositeInsert %mat4x3 %int_0 %matrix"; for (int i = 0; i < 256; ++i) { spirv << " 0"; } spirv << R"( OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("The number of indexes in OpCompositeInsert may not " "exceed 255. Found 256 indexes.")); } // Invalid: In OpCompositeInsert, result type must be the same as composite type TEST_F(ValidateComposites, CompositeInsertWrongResultTypeBad) { std::ostringstream spirv; spirv << GetHeaderForTestsFromValId() << std::endl; spirv << "%matrix = OpLoad %mat4x3 %my_matrix" << std::endl; spirv << "%float_entry = OpCompositeExtract %float %matrix 0 1" << std::endl; spirv << "%new_composite = OpCompositeInsert %float %float_entry %matrix 0 1" << std::endl; spirv << R"(OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("The Result Type must be the same as Composite type")); } // Invalid: No Indexes were passed to OpCompositeExtract. TEST_F(ValidateComposites, CompositeExtractNoIndices2) { std::ostringstream spirv; spirv << GetHeaderForTestsFromValId() << std::endl; spirv << "%matrix = OpLoad %mat4x3 %my_matrix" << std::endl; spirv << "%float_entry = OpCompositeExtract %mat4x3 %matrix" << std::endl; spirv << R"(OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected at least one index to OpCompositeExtract, zero found")); } // Invalid: No Indexes were passed to OpCompositeExtract. TEST_F(ValidateComposites, CompositeExtractNoIndicesWrongResultType) { std::ostringstream spirv; spirv << GetHeaderForTestsFromValId() << std::endl; spirv << "%matrix = OpLoad %mat4x3 %my_matrix" << std::endl; spirv << "%float_entry = OpCompositeExtract %float %matrix" << std::endl; spirv << R"(OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected at least one index to OpCompositeExtract, zero found")); } // Invalid: No Indices were passed to OpCompositeInsert, and the type of the // Object argument matches the Composite type. TEST_F(ValidateComposites, CompositeInsertMissingIndices) { std::ostringstream spirv; spirv << GetHeaderForTestsFromValId() << std::endl; spirv << "%matrix = OpLoad %mat4x3 %my_matrix" << std::endl; spirv << "%matrix_2 = OpLoad %mat4x3 %my_matrix" << std::endl; spirv << "%new_composite = OpCompositeInsert %mat4x3 %matrix_2 %matrix"; spirv << R"( OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected at least one index to OpCompositeInsert, zero found")); } // Invalid: No Indices were passed to OpCompositeInsert, but the type of the // Object argument does not match the Composite type. TEST_F(ValidateComposites, CompositeInsertMissingIndices2) { std::ostringstream spirv; spirv << GetHeaderForTestsFromValId() << std::endl; spirv << "%matrix = OpLoad %mat4x3 %my_matrix" << std::endl; spirv << "%new_composite = OpCompositeInsert %mat4x3 %int_0 %matrix"; spirv << R"( OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected at least one index to OpCompositeInsert, zero found")); } // Valid: Tests that we can index into Struct, Array, Matrix, and Vector! TEST_F(ValidateComposites, CompositeExtractInsertIndexIntoAllTypesGood) { // indexes that we are passing are: 0, 3, 1, 2, 0 // 0 will select the struct_s within the base struct (blockName) // 3 will select the Array that contains 5 matrices // 1 will select the Matrix that is at index 1 of the array // 2 will select the column (which is a vector) within the matrix at index 2 // 0 will select the element at the index 0 of the vector. (which is a float). std::ostringstream spirv; spirv << GetHeaderForTestsFromValId() << R"( %myblock = OpLoad %struct_blockName %blockName_var %ss = OpCompositeExtract %struct_s %myblock 0 %sa = OpCompositeExtract %array5_mat4x3 %myblock 0 3 %sm = OpCompositeExtract %mat4x3 %myblock 0 3 1 %sc = OpCompositeExtract %v3float %myblock 0 3 1 2 %fl = OpCompositeExtract %float %myblock 0 3 1 2 0 ; ; Now let's insert back at different levels... ; %b1 = OpCompositeInsert %struct_blockName %ss %myblock 0 %b2 = OpCompositeInsert %struct_blockName %sa %myblock 0 3 %b3 = OpCompositeInsert %struct_blockName %sm %myblock 0 3 1 %b4 = OpCompositeInsert %struct_blockName %sc %myblock 0 3 1 2 %b5 = OpCompositeInsert %struct_blockName %fl %myblock 0 3 1 2 0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // Invalid. More indexes are provided than needed for OpCompositeExtract. TEST_F(ValidateComposites, CompositeExtractReachedScalarBad) { // indexes that we are passing are: 0, 3, 1, 2, 0 // 0 will select the struct_s within the base struct (blockName) // 3 will select the Array that contains 5 matrices // 1 will select the Matrix that is at index 1 of the array // 2 will select the column (which is a vector) within the matrix at index 2 // 0 will select the element at the index 0 of the vector. (which is a float). std::ostringstream spirv; spirv << GetHeaderForTestsFromValId() << R"( %myblock = OpLoad %struct_blockName %blockName_var %fl = OpCompositeExtract %float %myblock 0 3 1 2 0 1 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Reached non-composite type while indexes still remain " "to be traversed.")); } // Invalid. More indexes are provided than needed for OpCompositeInsert. TEST_F(ValidateComposites, CompositeInsertReachedScalarBad) { // indexes that we are passing are: 0, 3, 1, 2, 0 // 0 will select the struct_s within the base struct (blockName) // 3 will select the Array that contains 5 matrices // 1 will select the Matrix that is at index 1 of the array // 2 will select the column (which is a vector) within the matrix at index 2 // 0 will select the element at the index 0 of the vector. (which is a float). std::ostringstream spirv; spirv << GetHeaderForTestsFromValId() << R"( %myblock = OpLoad %struct_blockName %blockName_var %fl = OpCompositeExtract %float %myblock 0 3 1 2 0 %b5 = OpCompositeInsert %struct_blockName %fl %myblock 0 3 1 2 0 1 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Reached non-composite type while indexes still remain " "to be traversed.")); } // Invalid. Result type doesn't match the type we get from indexing into // the composite. TEST_F(ValidateComposites, CompositeExtractResultTypeDoesntMatchIndexedTypeBad) { // indexes that we are passing are: 0, 3, 1, 2, 0 // 0 will select the struct_s within the base struct (blockName) // 3 will select the Array that contains 5 matrices // 1 will select the Matrix that is at index 1 of the array // 2 will select the column (which is a vector) within the matrix at index 2 // 0 will select the element at the index 0 of the vector. (which is a float). std::ostringstream spirv; spirv << GetHeaderForTestsFromValId() << R"( %myblock = OpLoad %struct_blockName %blockName_var %fl = OpCompositeExtract %int %myblock 0 3 1 2 0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Result type (OpTypeInt) does not match the type that " "results from indexing into the composite " "(OpTypeFloat).")); } // Invalid. Given object type doesn't match the type we get from indexing into // the composite. TEST_F(ValidateComposites, CompositeInsertObjectTypeDoesntMatchIndexedTypeBad) { // indexes that we are passing are: 0, 3, 1, 2, 0 // 0 will select the struct_s within the base struct (blockName) // 3 will select the Array that contains 5 matrices // 1 will select the Matrix that is at index 1 of the array // 2 will select the column (which is a vector) within the matrix at index 2 // 0 will select the element at the index 0 of the vector. (which is a float). // We are trying to insert an integer where we should be inserting a float. std::ostringstream spirv; spirv << GetHeaderForTestsFromValId() << R"( %myblock = OpLoad %struct_blockName %blockName_var %b5 = OpCompositeInsert %struct_blockName %int_0 %myblock 0 3 1 2 0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("The Object type (OpTypeInt) does not match the type " "that results from indexing into the Composite " "(OpTypeFloat).")); } // Invalid. Index into a struct is larger than the number of struct members. TEST_F(ValidateComposites, CompositeExtractStructIndexOutOfBoundBad) { // struct_blockName has 3 members (index 0,1,2). We'll try to access index 3. std::ostringstream spirv; spirv << GetHeaderForTestsFromValId() << R"( %myblock = OpLoad %struct_blockName %blockName_var %ss = OpCompositeExtract %struct_s %myblock 3 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Index is out of bounds, can not find index 3 in the " "structure '25'. This structure has 2 members. " "Largest valid index is 1.")); } // Invalid. Index into a struct is larger than the number of struct members. TEST_F(ValidateComposites, CompositeInsertStructIndexOutOfBoundBad) { // struct_blockName has 3 members (index 0,1,2). We'll try to access index 3. std::ostringstream spirv; spirv << GetHeaderForTestsFromValId() << R"( %myblock = OpLoad %struct_blockName %blockName_var %ss = OpCompositeExtract %struct_s %myblock 0 %new_composite = OpCompositeInsert %struct_blockName %ss %myblock 3 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Index is out of bounds, can not find index 3 in the structure " " '25'. This structure has 2 members. Largest valid index " "is 1.")); } // #1403: Ensure that the default spec constant value is not used to check the // extract index. TEST_F(ValidateComposites, ExtractFromSpecConstantSizedArray) { std::string spirv = R"( OpCapability Kernel OpCapability Linkage OpMemoryModel Logical OpenCL OpDecorate %spec_const SpecId 1 %void = OpTypeVoid %uint = OpTypeInt 32 0 %spec_const = OpSpecConstant %uint 3 %uint_array = OpTypeArray %uint %spec_const %undef = OpUndef %uint_array %voidf = OpTypeFunction %void %func = OpFunction %void None %voidf %1 = OpLabel %2 = OpCompositeExtract %uint %undef 4 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // #1403: Ensure that spec constant ops do not produce false positives. TEST_F(ValidateComposites, ExtractFromSpecConstantOpSizedArray) { std::string spirv = R"( OpCapability Kernel OpCapability Linkage OpMemoryModel Logical OpenCL OpDecorate %spec_const SpecId 1 %void = OpTypeVoid %uint = OpTypeInt 32 0 %const = OpConstant %uint 1 %spec_const = OpSpecConstant %uint 3 %spec_const_op = OpSpecConstantOp %uint IAdd %spec_const %const %uint_array = OpTypeArray %uint %spec_const_op %undef = OpUndef %uint_array %voidf = OpTypeFunction %void %func = OpFunction %void None %voidf %1 = OpLabel %2 = OpCompositeExtract %uint %undef 4 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // #1403: Ensure that the default spec constant value is not used to check the // size of the array for a composite construct. This code has limited actual // value as it is incorrect unless the specialization constant is assigned the // value of 2, but it is still a valid module. TEST_F(ValidateComposites, CompositeConstructSpecConstantSizedArray) { std::string spirv = R"( OpCapability Kernel OpCapability Linkage OpMemoryModel Logical OpenCL OpDecorate %spec_const SpecId 1 %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %spec_const = OpSpecConstant %uint 3 %uint_array = OpTypeArray %uint %spec_const %voidf = OpTypeFunction %void %func = OpFunction %void None %voidf %1 = OpLabel %2 = OpCompositeConstruct %uint_array %uint_0 %uint_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateComposites, CoopMatConstantCompositeMismatchFail) { const std::string body = R"( OpCapability Shader OpCapability Float16 OpCapability CooperativeMatrixNV OpExtension "SPV_NV_cooperative_matrix" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f16 = OpTypeFloat 16 %f32 = OpTypeFloat 32 %u32 = OpTypeInt 32 0 %u32_8 = OpConstant %u32 8 %subgroup = OpConstant %u32 3 %f16mat = OpTypeCooperativeMatrixNV %f16 %subgroup %u32_8 %u32_8 %f32_1 = OpConstant %f32 1 %f16mat_1 = OpConstantComposite %f16mat %f32_1 %main = OpFunction %void None %func %main_entry = OpLabel OpReturn OpFunctionEnd)"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpConstantComposite Constituent '11[%float_1]' type does " "not match the Result Type '10[%10]'s component type.")); } TEST_F(ValidateComposites, CoopMatCompositeConstructMismatchFail) { const std::string body = R"( OpCapability Shader OpCapability Float16 OpCapability CooperativeMatrixNV OpExtension "SPV_NV_cooperative_matrix" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f16 = OpTypeFloat 16 %f32 = OpTypeFloat 32 %u32 = OpTypeInt 32 0 %u32_8 = OpConstant %u32 8 %subgroup = OpConstant %u32 3 %f16mat = OpTypeCooperativeMatrixNV %f16 %subgroup %u32_8 %u32_8 %f32_1 = OpConstant %f32 1 %main = OpFunction %void None %func %main_entry = OpLabel %f16mat_1 = OpCompositeConstruct %f16mat %f32_1 OpReturn OpFunctionEnd)"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Constituent type to be equal to the component type")); } TEST_F(ValidateComposites, CoopMatKHRConstantCompositeMismatchFail) { const std::string body = R"( OpCapability Shader OpCapability Float16 OpCapability CooperativeMatrixKHR OpExtension "SPV_KHR_cooperative_matrix" OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f16 = OpTypeFloat 16 %f32 = OpTypeFloat 32 %u32 = OpTypeInt 32 0 %u32_16 = OpConstant %u32 16 %useA = OpConstant %u32 0 %subgroup = OpConstant %u32 3 %f16mat = OpTypeCooperativeMatrixKHR %f16 %subgroup %u32_16 %u32_16 %useA %f32_1 = OpConstant %f32 1 %f16mat_1 = OpConstantComposite %f16mat %f32_1 %main = OpFunction %void None %func %main_entry = OpLabel OpReturn OpFunctionEnd)"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpConstantComposite Constituent '12[%float_1]' type " "does not match the Result Type '11[%11]'s component type.")); } TEST_F(ValidateComposites, CoopMatKHRCompositeConstructMismatchFail) { const std::string body = R"( OpCapability Shader OpCapability Float16 OpCapability CooperativeMatrixKHR OpExtension "SPV_KHR_cooperative_matrix" OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f16 = OpTypeFloat 16 %f32 = OpTypeFloat 32 %u32 = OpTypeInt 32 0 %u32_16 = OpConstant %u32 16 %useA = OpConstant %u32 0 %subgroup = OpConstant %u32 3 %f16mat = OpTypeCooperativeMatrixKHR %f16 %subgroup %u32_16 %u32_16 %useA %f32_1 = OpConstant %f32 1 %main = OpFunction %void None %func %main_entry = OpLabel %f16mat_1 = OpCompositeConstruct %f16mat %f32_1 OpReturn OpFunctionEnd)"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Constituent type to be equal to the component type")); } TEST_F(ValidateComposites, ExtractDynamicLabelIndex) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %void_fn = OpTypeFunction %void %float_0 = OpConstant %float 0 %v4float_0 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %func = OpFunction %void None %void_fn %1 = OpLabel %ex = OpVectorExtractDynamic %float %v4float_0 %v4float_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Index to be int scalar")); } TEST_F(ValidateComposites, CopyLogicalSameType) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %struct = OpTypeStruct %const_struct = OpConstantComposite %struct %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %1 = OpLabel %copy = OpCopyLogical %struct %const_struct OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Result Type must not equal the Operand type")); } TEST_F(ValidateComposites, CopyLogicalSameStructDifferentId) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %struct1 = OpTypeStruct %struct2 = OpTypeStruct %const_struct = OpConstantComposite %struct1 %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %1 = OpLabel %copy = OpCopyLogical %struct2 %const_struct OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); } TEST_F(ValidateComposites, CopyLogicalArrayDifferentLength) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_4 = OpConstant %int 4 %int_5 = OpConstant %int 5 %array1 = OpTypeArray %int %int_4 %array2 = OpTypeArray %int %int_5 %const_array = OpConstantComposite %array1 %int_4 %int_4 %int_4 %int_4 %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %1 = OpLabel %copy = OpCopyLogical %array2 %const_array OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Result Type does not logically match the Operand type")); } TEST_F(ValidateComposites, CopyLogicalArrayDifferentElement) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %float = OpTypeFloat 32 %int = OpTypeInt 32 0 %int_4 = OpConstant %int 4 %array1 = OpTypeArray %int %int_4 %array2 = OpTypeArray %float %int_4 %const_array = OpConstantComposite %array1 %int_4 %int_4 %int_4 %int_4 %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %1 = OpLabel %copy = OpCopyLogical %array2 %const_array OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Result Type does not logically match the Operand type")); } TEST_F(ValidateComposites, CopyLogicalArrayLogicallyMatchedElement) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %float = OpTypeFloat 32 %int = OpTypeInt 32 0 %int_1 = OpConstant %int 1 %inner1 = OpTypeArray %int %int_1 %inner2 = OpTypeArray %int %int_1 %array1 = OpTypeArray %inner1 %int_1 %array2 = OpTypeArray %inner2 %int_1 %const_inner = OpConstantComposite %inner1 %int_1 %const_array = OpConstantComposite %array1 %const_inner %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %1 = OpLabel %copy = OpCopyLogical %array2 %const_array OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); } TEST_F(ValidateComposites, CopyLogicalStructDifferentNumberElements) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %int = OpTypeInt 32 0 %struct1 = OpTypeStruct %struct2 = OpTypeStruct %int %const_struct = OpConstantComposite %struct1 %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %1 = OpLabel %copy = OpCopyLogical %struct2 %const_struct OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Result Type does not logically match the Operand type")); } TEST_F(ValidateComposites, CopyLogicalStructDifferentElement) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %uint = OpTypeInt 32 0 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint_0 = OpConstant %uint 0 %struct1 = OpTypeStruct %int %uint %struct2 = OpTypeStruct %int %int %const_struct = OpConstantComposite %struct1 %int_0 %uint_0 %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %1 = OpLabel %copy = OpCopyLogical %struct2 %const_struct OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Result Type does not logically match the Operand type")); } TEST_F(ValidateComposites, CopyLogicalStructLogicallyMatch) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_1 = OpConstant %int 1 %array1 = OpTypeArray %int %int_1 %array2 = OpTypeArray %int %int_1 %struct1 = OpTypeStruct %int %array1 %struct2 = OpTypeStruct %int %array2 %const_array = OpConstantComposite %array1 %int_1 %const_struct = OpConstantComposite %struct1 %int_1 %const_array %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %1 = OpLabel %copy = OpCopyLogical %struct2 %const_struct OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); } using ValidateSmallComposites = spvtest::ValidateBase; CodeGenerator GetSmallCompositesCodeGenerator() { CodeGenerator generator; generator.capabilities_ = R"( OpCapability Shader OpCapability Linkage OpCapability UniformAndStorageBuffer16BitAccess OpCapability UniformAndStorageBuffer8BitAccess )"; generator.extensions_ = R"( OpExtension "SPV_KHR_16bit_storage" OpExtension "SPV_KHR_8bit_storage" )"; generator.memory_model_ = "OpMemoryModel Logical GLSL450\n"; generator.before_types_ = R"( OpDecorate %char_block Block OpMemberDecorate %char_block 0 Offset 0 OpDecorate %short_block Block OpMemberDecorate %short_block 0 Offset 0 OpDecorate %half_block Block OpMemberDecorate %half_block 0 Offset 0 )"; generator.types_ = R"( %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %char = OpTypeInt 8 0 %char2 = OpTypeVector %char 2 %short = OpTypeInt 16 0 %short2 = OpTypeVector %short 2 %half = OpTypeFloat 16 %half2 = OpTypeVector %half 2 %char_block = OpTypeStruct %char2 %short_block = OpTypeStruct %short2 %half_block = OpTypeStruct %half2 %ptr_ssbo_char_block = OpTypePointer StorageBuffer %char_block %ptr_ssbo_char2 = OpTypePointer StorageBuffer %char2 %ptr_ssbo_char = OpTypePointer StorageBuffer %char %ptr_ssbo_short_block = OpTypePointer StorageBuffer %short_block %ptr_ssbo_short2 = OpTypePointer StorageBuffer %short2 %ptr_ssbo_short = OpTypePointer StorageBuffer %short %ptr_ssbo_half_block = OpTypePointer StorageBuffer %half_block %ptr_ssbo_half2 = OpTypePointer StorageBuffer %half2 %ptr_ssbo_half = OpTypePointer StorageBuffer %half %void_fn = OpTypeFunction %void %char_var = OpVariable %ptr_ssbo_char_block StorageBuffer %short_var = OpVariable %ptr_ssbo_short_block StorageBuffer %half_var = OpVariable %ptr_ssbo_half_block StorageBuffer )"; generator.after_types_ = R"( %func = OpFunction %void None %void_fn %entry = OpLabel %char2_gep = OpAccessChain %ptr_ssbo_char2 %char_var %int_0 %ld_char2 = OpLoad %char2 %char2_gep %char_gep = OpAccessChain %ptr_ssbo_char %char_var %int_0 %int_0 %ld_char = OpLoad %char %char_gep %short2_gep = OpAccessChain %ptr_ssbo_short2 %short_var %int_0 %ld_short2 = OpLoad %short2 %short2_gep %short_gep = OpAccessChain %ptr_ssbo_short %short_var %int_0 %int_0 %ld_short = OpLoad %short %short_gep %half2_gep = OpAccessChain %ptr_ssbo_half2 %half_var %int_0 %ld_half2 = OpLoad %half2 %half2_gep %half_gep = OpAccessChain %ptr_ssbo_half %half_var %int_0 %int_0 %ld_half = OpLoad %half %half_gep )"; generator.add_at_the_end_ = R"( OpReturn OpFunctionEnd )"; return generator; } TEST_P(ValidateSmallComposites, VectorExtractDynamic) { std::string type = GetParam(); CodeGenerator generator = GetSmallCompositesCodeGenerator(); std::string inst = "%inst = OpVectorExtractDynamic %" + type + " %ld_" + type + "2 %int_0\n"; generator.after_types_ += inst; CompileSuccessfully(generator.Build(), SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Cannot extract from a vector of 8- or 16-bit types")); } TEST_P(ValidateSmallComposites, VectorInsertDynamic) { std::string type = GetParam(); CodeGenerator generator = GetSmallCompositesCodeGenerator(); std::string inst = "%inst = OpVectorInsertDynamic %" + type + "2 %ld_" + type + "2 %ld_" + type + " %int_0\n"; generator.after_types_ += inst; CompileSuccessfully(generator.Build(), SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Cannot insert into a vector of 8- or 16-bit types")); } TEST_P(ValidateSmallComposites, VectorShuffle) { std::string type = GetParam(); CodeGenerator generator = GetSmallCompositesCodeGenerator(); std::string inst = "%inst = OpVectorShuffle %" + type + "2 %ld_" + type + "2 %ld_" + type + "2 0 0\n"; generator.after_types_ += inst; CompileSuccessfully(generator.Build(), SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Cannot shuffle a vector of 8- or 16-bit types")); } TEST_P(ValidateSmallComposites, CompositeConstruct) { std::string type = GetParam(); CodeGenerator generator = GetSmallCompositesCodeGenerator(); std::string inst = "%inst = OpCompositeConstruct %" + type + "2 %ld_" + type + " %ld_" + type + "\n"; generator.after_types_ += inst; CompileSuccessfully(generator.Build(), SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Cannot create a composite containing 8- or 16-bit types")); } TEST_P(ValidateSmallComposites, CompositeExtract) { std::string type = GetParam(); CodeGenerator generator = GetSmallCompositesCodeGenerator(); std::string inst = "%inst = OpCompositeExtract %" + type + " %ld_" + type + "2 0\n"; generator.after_types_ += inst; CompileSuccessfully(generator.Build(), SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Cannot extract from a composite of 8- or 16-bit types")); } TEST_P(ValidateSmallComposites, CompositeInsert) { std::string type = GetParam(); CodeGenerator generator = GetSmallCompositesCodeGenerator(); std::string inst = "%inst = OpCompositeInsert %" + type + "2 %ld_" + type + " %ld_" + type + "2 0\n"; generator.after_types_ += inst; CompileSuccessfully(generator.Build(), SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Cannot insert into a composite of 8- or 16-bit types")); } TEST_P(ValidateSmallComposites, CopyObject) { std::string type = GetParam(); CodeGenerator generator = GetSmallCompositesCodeGenerator(); std::string inst = "%inst = OpCopyObject %" + type + "2 %ld_" + type + "2\n"; generator.after_types_ += inst; CompileSuccessfully(generator.Build(), SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } INSTANTIATE_TEST_SUITE_P(SmallCompositeInstructions, ValidateSmallComposites, Values("char", "short", "half")); TEST_F(ValidateComposites, HalfMatrixCannotTranspose) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability UniformAndStorageBuffer16BitAccess OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpDecorate %block Block OpMemberDecorate %block 0 Offset 0 OpMemberDecorate %block 0 RowMajor OpMemberDecorate %block 0 MatrixStride 8 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %float = OpTypeFloat 16 %float2 = OpTypeVector %float 2 %mat2x2 = OpTypeMatrix %float2 2 %block = OpTypeStruct %mat2x2 %ptr_ssbo_block = OpTypePointer StorageBuffer %block %ptr_ssbo_mat2x2 = OpTypePointer StorageBuffer %mat2x2 %var = OpVariable %ptr_ssbo_block StorageBuffer %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel %gep = OpAccessChain %ptr_ssbo_mat2x2 %var %int_0 %ld = OpLoad %mat2x2 %gep %inst = OpTranspose %mat2x2 %ld OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Cannot transpose matrices of 16-bit floats")); } TEST_F(ValidateComposites, CopyObjectVoid) { const std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpName %4 "main" OpName %6 "foo(" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpFunctionCall %2 %6 %20 = OpCopyObject %2 %8 OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpCopyObject cannot have void result type")); } TEST_F(ValidateComposites, CoopVecConstantCompositePass) { const std::string body = R"( OpCapability Shader OpCapability Float16 OpCapability CooperativeVectorNV OpExtension "SPV_NV_cooperative_vector" OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f16 = OpTypeFloat 16 %f32 = OpTypeFloat 32 %u32 = OpTypeInt 32 0 %u32_16 = OpConstant %u32 16 %useA = OpConstant %u32 0 %subgroup = OpConstant %u32 3 %f16vec = OpTypeCooperativeVectorNV %f16 %u32_16 %f16_1 = OpConstant %f16 1 %f16vec_1 = OpConstantComposite %f16vec %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %main = OpFunction %void None %func %main_entry = OpLabel OpReturn OpFunctionEnd)"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateComposites, CoopVecConstantCompositeMismatchFail) { const std::string body = R"( OpCapability Shader OpCapability Float16 OpCapability CooperativeVectorNV OpExtension "SPV_NV_cooperative_vector" OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f16 = OpTypeFloat 16 %f32 = OpTypeFloat 32 %u32 = OpTypeInt 32 0 %u32_16 = OpConstant %u32 16 %useA = OpConstant %u32 0 %subgroup = OpConstant %u32 3 %f16vec = OpTypeCooperativeVectorNV %f16 %u32_16 %f32_1 = OpConstant %f32 1 %f16vec_1 = OpConstantComposite %f16vec %f32_1 %main = OpFunction %void None %func %main_entry = OpLabel OpReturn OpFunctionEnd)"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpConstantComposite Constituent count does not match " "Result Type '11[%11]'s vector component count")); } TEST_F(ValidateComposites, CoopVecCompositeConstructPass) { const std::string body = R"( OpCapability Shader OpCapability Float16 OpCapability CooperativeVectorNV OpExtension "SPV_NV_cooperative_vector" OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f16 = OpTypeFloat 16 %f32 = OpTypeFloat 32 %u32 = OpTypeInt 32 0 %u32_16 = OpConstant %u32 16 %useA = OpConstant %u32 0 %subgroup = OpConstant %u32 3 %f16vec = OpTypeCooperativeVectorNV %f16 %u32_16 %f16_1 = OpConstant %f16 1 %main = OpFunction %void None %func %main_entry = OpLabel %f16vec_1 = OpCompositeConstruct %f16vec %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 OpReturn OpFunctionEnd)"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateComposites, CoopVecCompositeConstructMismatchFail) { const std::string body = R"( OpCapability Shader OpCapability Float16 OpCapability CooperativeVectorNV OpExtension "SPV_NV_cooperative_vector" OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f16 = OpTypeFloat 16 %f32 = OpTypeFloat 32 %u32 = OpTypeInt 32 0 %u32_16 = OpConstant %u32 16 %useA = OpConstant %u32 0 %subgroup = OpConstant %u32 3 %f16vec = OpTypeCooperativeVectorNV %f16 %u32_16 %f32_1 = OpConstant %f32 1 %main = OpFunction %void None %func %main_entry = OpLabel %f16vec_1 = OpCompositeConstruct %f16vec %f32_1 OpReturn OpFunctionEnd)"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Constituents to be scalars or vectors of the " "same type as Result Type components")); } TEST_F(ValidateComposites, CoopVecInsertExtractDynamicPass) { const std::string body = R"( OpCapability Shader OpCapability Float16 OpCapability CooperativeVectorNV OpExtension "SPV_NV_cooperative_vector" OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f16 = OpTypeFloat 16 %f32 = OpTypeFloat 32 %u32 = OpTypeInt 32 0 %u32_1 = OpConstant %u32 1 %u32_16 = OpConstant %u32 16 %useA = OpConstant %u32 0 %subgroup = OpConstant %u32 3 %f16vec = OpTypeCooperativeVectorNV %f16 %u32_16 %f16_1 = OpConstant %f16 1 %f16vec_1 = OpConstantComposite %f16vec %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %f16_1 %main = OpFunction %void None %func %main_entry = OpLabel %insert = OpVectorInsertDynamic %f16vec %f16vec_1 %f16_1 %u32_1 %extract = OpVectorExtractDynamic %f16 %insert %u32_1 OpReturn OpFunctionEnd)"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_constants_test.cpp000066400000000000000000000514221475742701700247170ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Test validation of constants. // // This file contains newer tests. Older tests may be in other files such as // val_id_test.cpp. #include #include #include "gmock/gmock.h" #include "test/unit_spirv.h" #include "test/val/val_code_generator.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::Combine; using ::testing::Eq; using ::testing::HasSubstr; using ::testing::Values; using ::testing::ValuesIn; using ValidateConstant = spvtest::ValidateBase; #define kBasicTypes \ "%bool = OpTypeBool " \ "%uint = OpTypeInt 32 0 " \ "%uint2 = OpTypeVector %uint 2 " \ "%float = OpTypeFloat 32 " \ "%_ptr_uint = OpTypePointer Workgroup %uint " \ "%uint_0 = OpConstantNull %uint " \ "%uint2_0 = OpConstantNull %uint " \ "%float_0 = OpConstantNull %float " \ "%false = OpConstantFalse %bool " \ "%true = OpConstantTrue %bool " \ "%null = OpConstantNull %_ptr_uint " #define kShaderPreamble \ "OpCapability Shader\n" \ "OpCapability Linkage\n" \ "OpMemoryModel Logical Simple\n" #define kKernelPreamble \ "OpCapability Kernel\n" \ "OpCapability Linkage\n" \ "OpCapability Addresses\n" \ "OpMemoryModel Physical32 OpenCL\n" struct ConstantOpCase { spv_target_env env; std::string assembly; bool expect_success; std::string expect_err; }; using ValidateConstantOp = spvtest::ValidateBase; TEST_P(ValidateConstantOp, Samples) { const auto env = GetParam().env; CompileSuccessfully(GetParam().assembly, env); const auto result = ValidateInstructions(env); if (GetParam().expect_success) { EXPECT_EQ(SPV_SUCCESS, result); EXPECT_THAT(getDiagnosticString(), Eq("")); } else { EXPECT_EQ(SPV_ERROR_INVALID_ID, result); EXPECT_THAT(getDiagnosticString(), HasSubstr(GetParam().expect_err)); } } #define GOOD_SHADER_10(STR) \ { SPV_ENV_UNIVERSAL_1_0, kShaderPreamble kBasicTypes STR, true, "" } #define GOOD_KERNEL_10(STR) \ { SPV_ENV_UNIVERSAL_1_0, kKernelPreamble kBasicTypes STR, true, "" } INSTANTIATE_TEST_SUITE_P( UniversalInShader, ValidateConstantOp, ValuesIn(std::vector{ // TODO(dneto): Conversions must change width. GOOD_SHADER_10("%v = OpSpecConstantOp %uint SConvert %uint_0"), GOOD_SHADER_10("%v = OpSpecConstantOp %float FConvert %float_0"), GOOD_SHADER_10("%v = OpSpecConstantOp %uint SNegate %uint_0"), GOOD_SHADER_10("%v = OpSpecConstantOp %uint Not %uint_0"), GOOD_SHADER_10("%v = OpSpecConstantOp %uint IAdd %uint_0 %uint_0"), GOOD_SHADER_10("%v = OpSpecConstantOp %uint ISub %uint_0 %uint_0"), GOOD_SHADER_10("%v = OpSpecConstantOp %uint IMul %uint_0 %uint_0"), GOOD_SHADER_10("%v = OpSpecConstantOp %uint UDiv %uint_0 %uint_0"), GOOD_SHADER_10("%v = OpSpecConstantOp %uint SDiv %uint_0 %uint_0"), GOOD_SHADER_10("%v = OpSpecConstantOp %uint UMod %uint_0 %uint_0"), GOOD_SHADER_10("%v = OpSpecConstantOp %uint SRem %uint_0 %uint_0"), GOOD_SHADER_10("%v = OpSpecConstantOp %uint SMod %uint_0 %uint_0"), GOOD_SHADER_10( "%v = OpSpecConstantOp %uint ShiftRightLogical %uint_0 %uint_0"), GOOD_SHADER_10( "%v = OpSpecConstantOp %uint ShiftRightArithmetic %uint_0 %uint_0"), GOOD_SHADER_10( "%v = OpSpecConstantOp %uint ShiftLeftLogical %uint_0 %uint_0"), GOOD_SHADER_10("%v = OpSpecConstantOp %uint BitwiseOr %uint_0 %uint_0"), GOOD_SHADER_10( "%v = OpSpecConstantOp %uint BitwiseXor %uint_0 %uint_0"), GOOD_SHADER_10( "%v = OpSpecConstantOp %uint2 VectorShuffle %uint2_0 %uint2_0 1 3"), GOOD_SHADER_10( "%v = OpSpecConstantOp %uint CompositeExtract %uint2_0 1"), GOOD_SHADER_10( "%v = OpSpecConstantOp %uint2 CompositeInsert %uint_0 %uint2_0 1"), GOOD_SHADER_10("%v = OpSpecConstantOp %bool LogicalOr %true %false"), GOOD_SHADER_10("%v = OpSpecConstantOp %bool LogicalNot %true"), GOOD_SHADER_10("%v = OpSpecConstantOp %bool LogicalAnd %true %false"), GOOD_SHADER_10("%v = OpSpecConstantOp %bool LogicalEqual %true %false"), GOOD_SHADER_10( "%v = OpSpecConstantOp %bool LogicalNotEqual %true %false"), GOOD_SHADER_10( "%v = OpSpecConstantOp %uint Select %true %uint_0 %uint_0"), GOOD_SHADER_10("%v = OpSpecConstantOp %bool IEqual %uint_0 %uint_0"), GOOD_SHADER_10("%v = OpSpecConstantOp %bool INotEqual %uint_0 %uint_0"), GOOD_SHADER_10("%v = OpSpecConstantOp %bool ULessThan %uint_0 %uint_0"), GOOD_SHADER_10("%v = OpSpecConstantOp %bool SLessThan %uint_0 %uint_0"), GOOD_SHADER_10( "%v = OpSpecConstantOp %bool ULessThanEqual %uint_0 %uint_0"), GOOD_SHADER_10( "%v = OpSpecConstantOp %bool SLessThanEqual %uint_0 %uint_0"), GOOD_SHADER_10( "%v = OpSpecConstantOp %bool UGreaterThan %uint_0 %uint_0"), GOOD_SHADER_10( "%v = OpSpecConstantOp %bool UGreaterThanEqual %uint_0 %uint_0"), GOOD_SHADER_10( "%v = OpSpecConstantOp %bool SGreaterThan %uint_0 %uint_0"), GOOD_SHADER_10( "%v = OpSpecConstantOp %bool SGreaterThanEqual %uint_0 %uint_0"), })); INSTANTIATE_TEST_SUITE_P( UniversalInKernel, ValidateConstantOp, ValuesIn(std::vector{ // TODO(dneto): Conversions must change width. GOOD_KERNEL_10("%v = OpSpecConstantOp %uint SConvert %uint_0"), GOOD_KERNEL_10("%v = OpSpecConstantOp %float FConvert %float_0"), GOOD_KERNEL_10("%v = OpSpecConstantOp %uint SNegate %uint_0"), GOOD_KERNEL_10("%v = OpSpecConstantOp %uint Not %uint_0"), GOOD_KERNEL_10("%v = OpSpecConstantOp %uint IAdd %uint_0 %uint_0"), GOOD_KERNEL_10("%v = OpSpecConstantOp %uint ISub %uint_0 %uint_0"), GOOD_KERNEL_10("%v = OpSpecConstantOp %uint IMul %uint_0 %uint_0"), GOOD_KERNEL_10("%v = OpSpecConstantOp %uint UDiv %uint_0 %uint_0"), GOOD_KERNEL_10("%v = OpSpecConstantOp %uint SDiv %uint_0 %uint_0"), GOOD_KERNEL_10("%v = OpSpecConstantOp %uint UMod %uint_0 %uint_0"), GOOD_KERNEL_10("%v = OpSpecConstantOp %uint SRem %uint_0 %uint_0"), GOOD_KERNEL_10("%v = OpSpecConstantOp %uint SMod %uint_0 %uint_0"), GOOD_KERNEL_10( "%v = OpSpecConstantOp %uint ShiftRightLogical %uint_0 %uint_0"), GOOD_KERNEL_10( "%v = OpSpecConstantOp %uint ShiftRightArithmetic %uint_0 %uint_0"), GOOD_KERNEL_10( "%v = OpSpecConstantOp %uint ShiftLeftLogical %uint_0 %uint_0"), GOOD_KERNEL_10("%v = OpSpecConstantOp %uint BitwiseOr %uint_0 %uint_0"), GOOD_KERNEL_10( "%v = OpSpecConstantOp %uint BitwiseXor %uint_0 %uint_0"), GOOD_KERNEL_10( "%v = OpSpecConstantOp %uint2 VectorShuffle %uint2_0 %uint2_0 1 3"), GOOD_KERNEL_10( "%v = OpSpecConstantOp %uint CompositeExtract %uint2_0 1"), GOOD_KERNEL_10( "%v = OpSpecConstantOp %uint2 CompositeInsert %uint_0 %uint2_0 1"), GOOD_KERNEL_10("%v = OpSpecConstantOp %bool LogicalOr %true %false"), GOOD_KERNEL_10("%v = OpSpecConstantOp %bool LogicalNot %true"), GOOD_KERNEL_10("%v = OpSpecConstantOp %bool LogicalAnd %true %false"), GOOD_KERNEL_10("%v = OpSpecConstantOp %bool LogicalEqual %true %false"), GOOD_KERNEL_10( "%v = OpSpecConstantOp %bool LogicalNotEqual %true %false"), GOOD_KERNEL_10( "%v = OpSpecConstantOp %uint Select %true %uint_0 %uint_0"), GOOD_KERNEL_10("%v = OpSpecConstantOp %bool IEqual %uint_0 %uint_0"), GOOD_KERNEL_10("%v = OpSpecConstantOp %bool INotEqual %uint_0 %uint_0"), GOOD_KERNEL_10("%v = OpSpecConstantOp %bool ULessThan %uint_0 %uint_0"), GOOD_KERNEL_10("%v = OpSpecConstantOp %bool SLessThan %uint_0 %uint_0"), GOOD_KERNEL_10( "%v = OpSpecConstantOp %bool ULessThanEqual %uint_0 %uint_0"), GOOD_KERNEL_10( "%v = OpSpecConstantOp %bool SLessThanEqual %uint_0 %uint_0"), GOOD_KERNEL_10( "%v = OpSpecConstantOp %bool UGreaterThan %uint_0 %uint_0"), GOOD_KERNEL_10( "%v = OpSpecConstantOp %bool UGreaterThanEqual %uint_0 %uint_0"), GOOD_KERNEL_10( "%v = OpSpecConstantOp %bool SGreaterThan %uint_0 %uint_0"), GOOD_KERNEL_10( "%v = OpSpecConstantOp %bool SGreaterThanEqual %uint_0 %uint_0"), })); INSTANTIATE_TEST_SUITE_P( UConvert, ValidateConstantOp, ValuesIn(std::vector{ // TODO(dneto): Conversions must change width. {SPV_ENV_UNIVERSAL_1_0, kKernelPreamble kBasicTypes "%v = OpSpecConstantOp %uint UConvert %uint_0", true, ""}, {SPV_ENV_UNIVERSAL_1_1, kKernelPreamble kBasicTypes "%v = OpSpecConstantOp %uint UConvert %uint_0", true, ""}, {SPV_ENV_UNIVERSAL_1_3, kKernelPreamble kBasicTypes "%v = OpSpecConstantOp %uint UConvert %uint_0", true, ""}, {SPV_ENV_UNIVERSAL_1_3, kKernelPreamble kBasicTypes "%v = OpSpecConstantOp %uint UConvert %uint_0", true, ""}, {SPV_ENV_UNIVERSAL_1_4, kKernelPreamble kBasicTypes "%v = OpSpecConstantOp %uint UConvert %uint_0", true, ""}, {SPV_ENV_UNIVERSAL_1_0, kShaderPreamble kBasicTypes "%v = OpSpecConstantOp %uint UConvert %uint_0", false, "Prior to SPIR-V 1.4, specialization constant operation " "UConvert requires Kernel capability"}, {SPV_ENV_UNIVERSAL_1_1, kShaderPreamble kBasicTypes "%v = OpSpecConstantOp %uint UConvert %uint_0", false, "Prior to SPIR-V 1.4, specialization constant operation " "UConvert requires Kernel capability"}, {SPV_ENV_UNIVERSAL_1_3, kShaderPreamble kBasicTypes "%v = OpSpecConstantOp %uint UConvert %uint_0", false, "Prior to SPIR-V 1.4, specialization constant operation " "UConvert requires Kernel capability"}, {SPV_ENV_UNIVERSAL_1_3, kShaderPreamble kBasicTypes "%v = OpSpecConstantOp %uint UConvert %uint_0", false, "Prior to SPIR-V 1.4, specialization constant operation " "UConvert requires Kernel capability"}, {SPV_ENV_UNIVERSAL_1_4, kShaderPreamble kBasicTypes "%v = OpSpecConstantOp %uint UConvert %uint_0", true, ""}, })); INSTANTIATE_TEST_SUITE_P( KernelInKernel, ValidateConstantOp, ValuesIn(std::vector{ // TODO(dneto): Conversions must change width. GOOD_KERNEL_10("%v = OpSpecConstantOp %uint ConvertFToS %float_0"), GOOD_KERNEL_10("%v = OpSpecConstantOp %float ConvertSToF %uint_0"), GOOD_KERNEL_10("%v = OpSpecConstantOp %uint ConvertFToU %float_0"), GOOD_KERNEL_10("%v = OpSpecConstantOp %float ConvertUToF %uint_0"), GOOD_KERNEL_10("%v = OpSpecConstantOp %uint UConvert %uint_0"), GOOD_KERNEL_10( "%v = OpSpecConstantOp %_ptr_uint GenericCastToPtr %null"), GOOD_KERNEL_10( "%v = OpSpecConstantOp %_ptr_uint PtrCastToGeneric %null"), GOOD_KERNEL_10("%v = OpSpecConstantOp %uint Bitcast %uint_0"), GOOD_KERNEL_10("%v = OpSpecConstantOp %float FNegate %float_0"), GOOD_KERNEL_10("%v = OpSpecConstantOp %float FAdd %float_0 %float_0"), GOOD_KERNEL_10("%v = OpSpecConstantOp %float FSub %float_0 %float_0"), GOOD_KERNEL_10("%v = OpSpecConstantOp %float FMul %float_0 %float_0"), GOOD_KERNEL_10("%v = OpSpecConstantOp %float FDiv %float_0 %float_0"), GOOD_KERNEL_10("%v = OpSpecConstantOp %float FRem %float_0 %float_0"), GOOD_KERNEL_10("%v = OpSpecConstantOp %float FMod %float_0 %float_0"), GOOD_KERNEL_10( "%v = OpSpecConstantOp %_ptr_uint AccessChain %null %uint_0"), GOOD_KERNEL_10("%v = OpSpecConstantOp %_ptr_uint InBoundsAccessChain " "%null %uint_0"), GOOD_KERNEL_10( "%v = OpSpecConstantOp %_ptr_uint PtrAccessChain %null %uint_0"), GOOD_KERNEL_10("%v = OpSpecConstantOp %_ptr_uint " "InBoundsPtrAccessChain %null %uint_0"), })); #define BAD_SHADER_10(STR, NAME) \ { \ SPV_ENV_UNIVERSAL_1_0, kShaderPreamble kBasicTypes STR, false, \ "Specialization constant operation " NAME \ " requires Kernel capability" \ } INSTANTIATE_TEST_SUITE_P( KernelInShader, ValidateConstantOp, ValuesIn(std::vector{ // TODO(dneto): Conversions must change width. BAD_SHADER_10("%v = OpSpecConstantOp %uint ConvertFToS %float_0", "ConvertFToS"), BAD_SHADER_10("%v = OpSpecConstantOp %float ConvertSToF %uint_0", "ConvertSToF"), BAD_SHADER_10("%v = OpSpecConstantOp %uint ConvertFToU %float_0", "ConvertFToU"), BAD_SHADER_10("%v = OpSpecConstantOp %float ConvertUToF %uint_0", "ConvertUToF"), BAD_SHADER_10("%v = OpSpecConstantOp %_ptr_uint GenericCastToPtr %null", "GenericCastToPtr"), BAD_SHADER_10("%v = OpSpecConstantOp %_ptr_uint PtrCastToGeneric %null", "PtrCastToGeneric"), BAD_SHADER_10("%v = OpSpecConstantOp %uint Bitcast %uint_0", "Bitcast"), BAD_SHADER_10("%v = OpSpecConstantOp %float FNegate %float_0", "FNegate"), BAD_SHADER_10("%v = OpSpecConstantOp %float FAdd %float_0 %float_0", "FAdd"), BAD_SHADER_10("%v = OpSpecConstantOp %float FSub %float_0 %float_0", "FSub"), BAD_SHADER_10("%v = OpSpecConstantOp %float FMul %float_0 %float_0", "FMul"), BAD_SHADER_10("%v = OpSpecConstantOp %float FDiv %float_0 %float_0", "FDiv"), BAD_SHADER_10("%v = OpSpecConstantOp %float FRem %float_0 %float_0", "FRem"), BAD_SHADER_10("%v = OpSpecConstantOp %float FMod %float_0 %float_0", "FMod"), BAD_SHADER_10( "%v = OpSpecConstantOp %_ptr_uint AccessChain %null %uint_0", "AccessChain"), BAD_SHADER_10("%v = OpSpecConstantOp %_ptr_uint InBoundsAccessChain " "%null %uint_0", "InBoundsAccessChain"), BAD_SHADER_10( "%v = OpSpecConstantOp %_ptr_uint PtrAccessChain %null %uint_0", "PtrAccessChain"), BAD_SHADER_10("%v = OpSpecConstantOp %_ptr_uint " "InBoundsPtrAccessChain %null %uint_0", "InBoundsPtrAccessChain"), })); INSTANTIATE_TEST_SUITE_P( UConvertInAMD_gpu_shader_int16, ValidateConstantOp, ValuesIn(std::vector{ // SPV_AMD_gpu_shader_int16 should enable UConvert for OpSpecConstantOp // https://github.com/KhronosGroup/glslang/issues/848 {SPV_ENV_UNIVERSAL_1_0, "OpCapability Shader " "OpCapability Linkage ; So we don't need to define a function\n" "OpExtension \"SPV_AMD_gpu_shader_int16\" " "OpMemoryModel Logical Simple " kBasicTypes "%v = OpSpecConstantOp %uint UConvert %uint_0", true, ""}, })); TEST_F(ValidateConstant, SpecConstantUConvert1p3Binary1p4EnvBad) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %int = OpTypeInt 32 0 %int0 = OpConstant %int 0 %const = OpSpecConstantOp %int UConvert %int0 )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Prior to SPIR-V 1.4, specialization constant operation UConvert " "requires Kernel capability or extension SPV_AMD_gpu_shader_int16")); } using SmallStorageConstants = spvtest::ValidateBase; CodeGenerator GetSmallStorageCodeGenerator() { CodeGenerator generator; generator.capabilities_ = R"( OpCapability Shader OpCapability Linkage OpCapability UniformAndStorageBuffer16BitAccess OpCapability StoragePushConstant16 OpCapability StorageInputOutput16 OpCapability UniformAndStorageBuffer8BitAccess OpCapability StoragePushConstant8 )"; generator.extensions_ = R"( OpExtension "SPV_KHR_16bit_storage" OpExtension "SPV_KHR_8bit_storage" )"; generator.memory_model_ = "OpMemoryModel Logical GLSL450\n"; generator.types_ = R"( %short = OpTypeInt 16 0 %short2 = OpTypeVector %short 2 %char = OpTypeInt 8 0 %char2 = OpTypeVector %char 2 %half = OpTypeFloat 16 %half2 = OpTypeVector %half 2 %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 )"; return generator; } TEST_P(SmallStorageConstants, SmallConstant) { std::string constant = GetParam(); CodeGenerator generator = GetSmallStorageCodeGenerator(); generator.after_types_ += constant + "\n"; CompileSuccessfully(generator.Build(), SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Cannot form constants of 8- or 16-bit types")); } // Constant composites would be caught through scalar constants. INSTANTIATE_TEST_SUITE_P( SmallConstants, SmallStorageConstants, Values("%c = OpConstant %char 0", "%c = OpConstantNull %char2", "%c = OpConstant %short 0", "%c = OpConstantNull %short", "%c = OpConstant %half 0", "%c = OpConstantNull %half", "%c = OpSpecConstant %char 0", "%c = OpSpecConstant %short 0", "%c = OpSpecConstant %half 0", "%c = OpSpecConstantOp %char SConvert %int_0", "%c = OpSpecConstantOp %short SConvert %int_0", "%c = OpSpecConstantOp %half FConvert %float_0")); TEST_F(ValidateConstant, NullPointerTo16BitStorageOk) { std::string spirv = R"( OpCapability Shader OpCapability VariablePointersStorageBuffer OpCapability UniformAndStorageBuffer16BitAccess OpCapability Linkage OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 %half = OpTypeFloat 16 %ptr_ssbo_half = OpTypePointer StorageBuffer %half %null_ptr = OpConstantNull %ptr_ssbo_half )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateConstant, NullMatrix) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %mat2x2 = OpTypeMatrix %v2float 2 %null_vector = OpConstantNull %v2float %null_matrix = OpConstantComposite %mat2x2 %null_vector %null_vector )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateConstant, NullPhysicalStorageBuffer) { std::string spirv = R"( OpCapability Shader OpCapability PhysicalStorageBufferAddresses OpCapability Linkage OpExtension "SPV_KHR_physical_storage_buffer" OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpName %ptr "ptr" %int = OpTypeInt 32 0 %ptr = OpTypePointer PhysicalStorageBuffer %int %null = OpConstantNull %ptr )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpConstantNull Result Type '1[%ptr]' cannot have " "a null value")); } TEST_F(ValidateConstant, VectorMismatchedConstituents) { std::string spirv = kShaderPreamble kBasicTypes R"( %int = OpTypeInt 32 1 %int_0 = OpConstantNull %int %const_vector = OpConstantComposite %uint2 %uint_0 %int_0 )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpConstantComposite Constituent '13[%13]'s type " "does not match Result Type '3[%v2uint]'s vector element type")); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_conversion_test.cpp000066400000000000000000002354651475742701700251030ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Tests for unique type declaration rules validator. #include #include "gmock/gmock.h" #include "test/unit_spirv.h" #include "test/val/val_code_generator.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::HasSubstr; using ::testing::Not; using ::testing::Values; using ValidateConversion = spvtest::ValidateBase; std::string GenerateShaderCode( const std::string& body, const std::string& capabilities_and_extensions = "", const std::string& decorations = "", const std::string& types = "", const std::string& variables = "") { const std::string capabilities = R"( OpCapability Shader OpCapability Int64 OpCapability Float64)"; const std::string after_extension_before_decorations = R"( OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft)"; const std::string after_decorations_before_types = R"( %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f32 = OpTypeFloat 32 %u32 = OpTypeInt 32 0 %s32 = OpTypeInt 32 1 %f64 = OpTypeFloat 64 %u64 = OpTypeInt 64 0 %s64 = OpTypeInt 64 1 %boolvec2 = OpTypeVector %bool 2 %s32vec2 = OpTypeVector %s32 2 %u32vec2 = OpTypeVector %u32 2 %u64vec2 = OpTypeVector %u64 2 %f32vec2 = OpTypeVector %f32 2 %f64vec2 = OpTypeVector %f64 2 %boolvec3 = OpTypeVector %bool 3 %u32vec3 = OpTypeVector %u32 3 %u64vec3 = OpTypeVector %u64 3 %s32vec3 = OpTypeVector %s32 3 %f32vec3 = OpTypeVector %f32 3 %f64vec3 = OpTypeVector %f64 3 %boolvec4 = OpTypeVector %bool 4 %u32vec4 = OpTypeVector %u32 4 %u64vec4 = OpTypeVector %u64 4 %s32vec4 = OpTypeVector %s32 4 %f32vec4 = OpTypeVector %f32 4 %f64vec4 = OpTypeVector %f64 4 %f32_0 = OpConstant %f32 0 %f32_1 = OpConstant %f32 1 %f32_2 = OpConstant %f32 2 %f32_3 = OpConstant %f32 3 %f32_4 = OpConstant %f32 4 %s32_0 = OpConstant %s32 0 %s32_1 = OpConstant %s32 1 %s32_2 = OpConstant %s32 2 %s32_3 = OpConstant %s32 3 %s32_4 = OpConstant %s32 4 %s32_m1 = OpConstant %s32 -1 %u32_0 = OpConstant %u32 0 %u32_1 = OpConstant %u32 1 %u32_2 = OpConstant %u32 2 %u32_3 = OpConstant %u32 3 %u32_4 = OpConstant %u32 4 %f64_0 = OpConstant %f64 0 %f64_1 = OpConstant %f64 1 %f64_2 = OpConstant %f64 2 %f64_3 = OpConstant %f64 3 %f64_4 = OpConstant %f64 4 %s64_0 = OpConstant %s64 0 %s64_1 = OpConstant %s64 1 %s64_2 = OpConstant %s64 2 %s64_3 = OpConstant %s64 3 %s64_4 = OpConstant %s64 4 %s64_m1 = OpConstant %s64 -1 %u64_0 = OpConstant %u64 0 %u64_1 = OpConstant %u64 1 %u64_2 = OpConstant %u64 2 %u64_3 = OpConstant %u64 3 %u64_4 = OpConstant %u64 4 %u32vec2_01 = OpConstantComposite %u32vec2 %u32_0 %u32_1 %u32vec2_12 = OpConstantComposite %u32vec2 %u32_1 %u32_2 %u32vec3_012 = OpConstantComposite %u32vec3 %u32_0 %u32_1 %u32_2 %u32vec3_123 = OpConstantComposite %u32vec3 %u32_1 %u32_2 %u32_3 %u32vec4_0123 = OpConstantComposite %u32vec4 %u32_0 %u32_1 %u32_2 %u32_3 %u32vec4_1234 = OpConstantComposite %u32vec4 %u32_1 %u32_2 %u32_3 %u32_4 %s32vec2_01 = OpConstantComposite %s32vec2 %s32_0 %s32_1 %s32vec2_12 = OpConstantComposite %s32vec2 %s32_1 %s32_2 %s32vec3_012 = OpConstantComposite %s32vec3 %s32_0 %s32_1 %s32_2 %s32vec3_123 = OpConstantComposite %s32vec3 %s32_1 %s32_2 %s32_3 %s32vec4_0123 = OpConstantComposite %s32vec4 %s32_0 %s32_1 %s32_2 %s32_3 %s32vec4_1234 = OpConstantComposite %s32vec4 %s32_1 %s32_2 %s32_3 %s32_4 %f32vec2_01 = OpConstantComposite %f32vec2 %f32_0 %f32_1 %f32vec2_12 = OpConstantComposite %f32vec2 %f32_1 %f32_2 %f32vec3_012 = OpConstantComposite %f32vec3 %f32_0 %f32_1 %f32_2 %f32vec3_123 = OpConstantComposite %f32vec3 %f32_1 %f32_2 %f32_3 %f32vec4_0123 = OpConstantComposite %f32vec4 %f32_0 %f32_1 %f32_2 %f32_3 %f32vec4_1234 = OpConstantComposite %f32vec4 %f32_1 %f32_2 %f32_3 %f32_4 %f64vec2_01 = OpConstantComposite %f64vec2 %f64_0 %f64_1 %f64vec2_12 = OpConstantComposite %f64vec2 %f64_1 %f64_2 %f64vec3_012 = OpConstantComposite %f64vec3 %f64_0 %f64_1 %f64_2 %f64vec3_123 = OpConstantComposite %f64vec3 %f64_1 %f64_2 %f64_3 %f64vec4_0123 = OpConstantComposite %f64vec4 %f64_0 %f64_1 %f64_2 %f64_3 %f64vec4_1234 = OpConstantComposite %f64vec4 %f64_1 %f64_2 %f64_3 %f64_4 %true = OpConstantTrue %bool %false = OpConstantFalse %bool %f32ptr_func = OpTypePointer Function %f32)"; const std::string after_variables_before_body = R"( %main = OpFunction %void None %func %main_entry = OpLabel)"; const std::string after_body = R"( OpReturn OpFunctionEnd)"; return capabilities + capabilities_and_extensions + after_extension_before_decorations + decorations + after_decorations_before_types + types + variables + after_variables_before_body + body + after_body; } std::string GenerateKernelCode( const std::string& body, const std::string& capabilities_and_extensions = "") { const std::string capabilities = R"( OpCapability Addresses OpCapability Kernel OpCapability Linkage OpCapability GenericPointer OpCapability Int64 OpCapability Float64)"; const std::string after_extension_before_body = R"( OpMemoryModel Physical32 OpenCL %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f32 = OpTypeFloat 32 %u32 = OpTypeInt 32 0 %f64 = OpTypeFloat 64 %u64 = OpTypeInt 64 0 %boolvec2 = OpTypeVector %bool 2 %u32vec2 = OpTypeVector %u32 2 %u64vec2 = OpTypeVector %u64 2 %f32vec2 = OpTypeVector %f32 2 %f64vec2 = OpTypeVector %f64 2 %boolvec3 = OpTypeVector %bool 3 %u32vec3 = OpTypeVector %u32 3 %u64vec3 = OpTypeVector %u64 3 %f32vec3 = OpTypeVector %f32 3 %f64vec3 = OpTypeVector %f64 3 %boolvec4 = OpTypeVector %bool 4 %u32vec4 = OpTypeVector %u32 4 %u64vec4 = OpTypeVector %u64 4 %f32vec4 = OpTypeVector %f32 4 %f64vec4 = OpTypeVector %f64 4 %f32_0 = OpConstant %f32 0 %f32_1 = OpConstant %f32 1 %f32_2 = OpConstant %f32 2 %f32_3 = OpConstant %f32 3 %f32_4 = OpConstant %f32 4 %u32_0 = OpConstant %u32 0 %u32_1 = OpConstant %u32 1 %u32_2 = OpConstant %u32 2 %u32_3 = OpConstant %u32 3 %u32_4 = OpConstant %u32 4 %f64_0 = OpConstant %f64 0 %f64_1 = OpConstant %f64 1 %f64_2 = OpConstant %f64 2 %f64_3 = OpConstant %f64 3 %f64_4 = OpConstant %f64 4 %u64_0 = OpConstant %u64 0 %u64_1 = OpConstant %u64 1 %u64_2 = OpConstant %u64 2 %u64_3 = OpConstant %u64 3 %u64_4 = OpConstant %u64 4 %u32vec2_01 = OpConstantComposite %u32vec2 %u32_0 %u32_1 %u32vec2_12 = OpConstantComposite %u32vec2 %u32_1 %u32_2 %u32vec3_012 = OpConstantComposite %u32vec3 %u32_0 %u32_1 %u32_2 %u32vec3_123 = OpConstantComposite %u32vec3 %u32_1 %u32_2 %u32_3 %u32vec4_0123 = OpConstantComposite %u32vec4 %u32_0 %u32_1 %u32_2 %u32_3 %u32vec4_1234 = OpConstantComposite %u32vec4 %u32_1 %u32_2 %u32_3 %u32_4 %f32vec2_01 = OpConstantComposite %f32vec2 %f32_0 %f32_1 %f32vec2_12 = OpConstantComposite %f32vec2 %f32_1 %f32_2 %f32vec3_012 = OpConstantComposite %f32vec3 %f32_0 %f32_1 %f32_2 %f32vec3_123 = OpConstantComposite %f32vec3 %f32_1 %f32_2 %f32_3 %f32vec4_0123 = OpConstantComposite %f32vec4 %f32_0 %f32_1 %f32_2 %f32_3 %f32vec4_1234 = OpConstantComposite %f32vec4 %f32_1 %f32_2 %f32_3 %f32_4 %f64vec2_01 = OpConstantComposite %f64vec2 %f64_0 %f64_1 %f64vec2_12 = OpConstantComposite %f64vec2 %f64_1 %f64_2 %f64vec3_012 = OpConstantComposite %f64vec3 %f64_0 %f64_1 %f64_2 %f64vec3_123 = OpConstantComposite %f64vec3 %f64_1 %f64_2 %f64_3 %f64vec4_0123 = OpConstantComposite %f64vec4 %f64_0 %f64_1 %f64_2 %f64_3 %f64vec4_1234 = OpConstantComposite %f64vec4 %f64_1 %f64_2 %f64_3 %f64_4 %u64vec2_01 = OpConstantComposite %u64vec2 %u64_0 %u64_1 %true = OpConstantTrue %bool %false = OpConstantFalse %bool %f32ptr_func = OpTypePointer Function %f32 %u32ptr_func = OpTypePointer Function %u32 %f32ptr_gen = OpTypePointer Generic %f32 %f32ptr_inp = OpTypePointer Input %f32 %f32ptr_wg = OpTypePointer Workgroup %f32 %f32ptr_cwg = OpTypePointer CrossWorkgroup %f32 %f32inp = OpVariable %f32ptr_inp Input %main = OpFunction %void None %func %main_entry = OpLabel)"; const std::string after_body = R"( OpReturn OpFunctionEnd)"; return capabilities + capabilities_and_extensions + after_extension_before_body + body + after_body; } TEST_F(ValidateConversion, ConvertFToUSuccess) { const std::string body = R"( %val1 = OpConvertFToU %u32 %f32_1 %val2 = OpConvertFToU %u32 %f64_0 %val3 = OpConvertFToU %u32vec2 %f32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateConversion, ConvertFToUWrongResultType) { const std::string body = R"( %val = OpConvertFToU %s32 %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected unsigned int scalar or vector type as Result " "Type: ConvertFToU")); } TEST_F(ValidateConversion, ConvertFToUWrongInputType) { const std::string body = R"( %val = OpConvertFToU %u32 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected input to be float scalar or vector: ConvertFToU")); } TEST_F(ValidateConversion, ConvertFToUDifferentDimension) { const std::string body = R"( %val = OpConvertFToU %u32 %f32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected input to have the same dimension as Result " "Type: ConvertFToU")); } TEST_F(ValidateConversion, ConvertFToSSuccess) { const std::string body = R"( %val1 = OpConvertFToS %s32 %f32_1 %val2 = OpConvertFToS %u32 %f64_0 %val3 = OpConvertFToS %s32vec2 %f32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateConversion, ConvertFToSWrongResultType) { const std::string body = R"( %val = OpConvertFToS %bool %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected int scalar or vector type as Result Type: ConvertFToS")); } TEST_F(ValidateConversion, ConvertFToSWrongInputType) { const std::string body = R"( %val = OpConvertFToS %s32 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected input to be float scalar or vector: ConvertFToS")); } TEST_F(ValidateConversion, ConvertFToSDifferentDimension) { const std::string body = R"( %val = OpConvertFToS %u32 %f32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected input to have the same dimension as Result " "Type: ConvertFToS")); } TEST_F(ValidateConversion, ConvertSToFSuccess) { const std::string body = R"( %val1 = OpConvertSToF %f32 %u32_1 %val2 = OpConvertSToF %f32 %s64_0 %val3 = OpConvertSToF %f32vec2 %s32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateConversion, ConvertSToFWrongResultType) { const std::string body = R"( %val = OpConvertSToF %u32 %s32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected float scalar or vector type as Result Type: ConvertSToF")); } TEST_F(ValidateConversion, ConvertSToFWrongInputType) { const std::string body = R"( %val = OpConvertSToF %f32 %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected input to be int scalar or vector: ConvertSToF")); } TEST_F(ValidateConversion, ConvertSToFDifferentDimension) { const std::string body = R"( %val = OpConvertSToF %f32 %u32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected input to have the same dimension as Result " "Type: ConvertSToF")); } TEST_F(ValidateConversion, UConvertSuccess) { const std::string body = R"( %val1 = OpUConvert %u32 %u64_1 %val2 = OpUConvert %u64 %s32_0 %val3 = OpUConvert %u64vec2 %s32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateConversion, UConvertWrongResultType) { const std::string body = R"( %val = OpUConvert %s32 %s32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected unsigned int scalar or vector type as Result " "Type: UConvert")); } TEST_F(ValidateConversion, UConvertWrongInputType) { const std::string body = R"( %val = OpUConvert %u32 %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected input to be int scalar or vector: UConvert")); } TEST_F(ValidateConversion, UConvertDifferentDimension) { const std::string body = R"( %val = OpUConvert %u32 %u32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected input to have the same dimension as Result " "Type: UConvert")); } TEST_F(ValidateConversion, UConvertSameBitWidth) { const std::string body = R"( %val = OpUConvert %u32 %s32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected input to have different bit width from " "Result Type: UConvert")); } TEST_F(ValidateConversion, SConvertSuccess) { const std::string body = R"( %val1 = OpSConvert %s32 %u64_1 %val2 = OpSConvert %s64 %s32_0 %val3 = OpSConvert %u64vec2 %s32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateConversion, SConvertWrongResultType) { const std::string body = R"( %val = OpSConvert %f32 %s32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected int scalar or vector type as Result Type: SConvert")); } TEST_F(ValidateConversion, SConvertWrongInputType) { const std::string body = R"( %val = OpSConvert %u32 %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected input to be int scalar or vector: SConvert")); } TEST_F(ValidateConversion, SConvertDifferentDimension) { const std::string body = R"( %val = OpSConvert %s32 %u32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected input to have the same dimension as Result " "Type: SConvert")); } TEST_F(ValidateConversion, SConvertSameBitWidth) { const std::string body = R"( %val = OpSConvert %u32 %s32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected input to have different bit width from " "Result Type: SConvert")); } TEST_F(ValidateConversion, FConvertSuccess) { const std::string body = R"( %val1 = OpFConvert %f32 %f64_1 %val2 = OpFConvert %f64 %f32_0 %val3 = OpFConvert %f64vec2 %f32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateConversion, FConvertWrongResultType) { const std::string body = R"( %val = OpFConvert %u32 %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected float scalar or vector type as Result Type: FConvert")); } TEST_F(ValidateConversion, FConvertWrongInputType) { const std::string body = R"( %val = OpFConvert %f32 %u64_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected input to be float scalar or vector: FConvert")); } TEST_F(ValidateConversion, FConvertDifferentDimension) { const std::string body = R"( %val = OpFConvert %f64 %f32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected input to have the same dimension as Result " "Type: FConvert")); } TEST_F(ValidateConversion, FConvertSameBitWidth) { const std::string body = R"( %val = OpFConvert %f32 %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected input to have different bit width from " "Result Type: FConvert")); } TEST_F(ValidateConversion, QuantizeToF16Success) { const std::string body = R"( %val1 = OpQuantizeToF16 %f32 %f32_1 %val2 = OpQuantizeToF16 %f32 %f32_0 %val3 = OpQuantizeToF16 %f32vec2 %f32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateConversion, QuantizeToF16WrongResultType) { const std::string body = R"( %val = OpQuantizeToF16 %u32 %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected 32-bit float scalar or vector type as Result Type: " "QuantizeToF16")); } TEST_F(ValidateConversion, QuantizeToF16WrongResultTypeBitWidth) { const std::string body = R"( %val = OpQuantizeToF16 %u64 %f64_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected 32-bit float scalar or vector type as Result Type: " "QuantizeToF16")); } TEST_F(ValidateConversion, QuantizeToF16WrongInputType) { const std::string body = R"( %val = OpQuantizeToF16 %f32 %f64_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected input type to be equal to Result Type: QuantizeToF16")); } TEST_F(ValidateConversion, ConvertPtrToUSuccess) { const std::string body = R"( %ptr = OpVariable %f32ptr_func Function %val1 = OpConvertPtrToU %u32 %ptr %val2 = OpConvertPtrToU %u64 %ptr )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateConversion, ConvertPtrToUWrongResultType) { const std::string body = R"( %ptr = OpVariable %f32ptr_func Function %val = OpConvertPtrToU %f32 %ptr )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected unsigned int scalar type as Result Type: " "ConvertPtrToU")); } TEST_F(ValidateConversion, ConvertPtrToUNotPointer) { const std::string body = R"( %val = OpConvertPtrToU %u32 %f32_1 )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected input to be a pointer: ConvertPtrToU")); } TEST_F(ValidateConversion, SatConvertSToUSuccess) { const std::string body = R"( %val1 = OpSatConvertSToU %u32 %u64_2 %val2 = OpSatConvertSToU %u64 %u32_1 %val3 = OpSatConvertSToU %u64vec2 %u32vec2_12 )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateConversion, SatConvertSToUWrongResultType) { const std::string body = R"( %val = OpSatConvertSToU %f32 %u32_1 )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected int scalar or vector type as Result Type: " "SatConvertSToU")); } TEST_F(ValidateConversion, SatConvertSToUWrongInputType) { const std::string body = R"( %val = OpSatConvertSToU %u32 %f32_1 )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected int scalar or vector as input: SatConvertSToU")); } TEST_F(ValidateConversion, SatConvertSToUDifferentDimension) { const std::string body = R"( %val = OpSatConvertSToU %u32 %u32vec2_12 )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected input to have the same dimension as Result Type: " "SatConvertSToU")); } TEST_F(ValidateConversion, ConvertUToPtrSuccess) { const std::string body = R"( %val1 = OpConvertUToPtr %f32ptr_func %u32_1 %val2 = OpConvertUToPtr %f32ptr_func %u64_1 )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateConversion, ConvertUToPtrWrongResultType) { const std::string body = R"( %val = OpConvertUToPtr %f32 %u32_1 )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be a pointer: ConvertUToPtr")); } TEST_F(ValidateConversion, ConvertUToPtrNotInt) { const std::string body = R"( %val = OpConvertUToPtr %f32ptr_func %f32_1 )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected int scalar as input: ConvertUToPtr")); } TEST_F(ValidateConversion, ConvertUToPtrNotIntScalar) { const std::string body = R"( %val = OpConvertUToPtr %f32ptr_func %u32vec2_12 )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected int scalar as input: ConvertUToPtr")); } TEST_F(ValidateConversion, PtrCastToGenericSuccess) { const std::string body = R"( %ptr_func = OpVariable %f32ptr_func Function %val = OpPtrCastToGeneric %f32ptr_gen %ptr_func )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateConversion, PtrCastToGenericWrongResultType) { const std::string body = R"( %ptr_func = OpVariable %f32ptr_func Function %val = OpPtrCastToGeneric %f32 %ptr_func )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Result Type to be a pointer: PtrCastToGeneric")); } TEST_F(ValidateConversion, PtrCastToGenericWrongResultStorageClass) { const std::string body = R"( %ptr_func = OpVariable %f32ptr_func Function %val = OpPtrCastToGeneric %f32ptr_func %ptr_func )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to have storage class Generic: " "PtrCastToGeneric")); } TEST_F(ValidateConversion, PtrCastToGenericWrongInputType) { const std::string body = R"( %ptr_func = OpVariable %f32ptr_func Function %val = OpPtrCastToGeneric %f32ptr_gen %f32 )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Operand '4[%float]' cannot be a " "type")); } TEST_F(ValidateConversion, PtrCastToGenericWrongInputStorageClass) { const std::string body = R"( %val = OpPtrCastToGeneric %f32ptr_gen %f32inp )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected input to have storage class Workgroup, " "CrossWorkgroup or Function: PtrCastToGeneric")); } TEST_F(ValidateConversion, PtrCastToGenericPointToDifferentType) { const std::string body = R"( %ptr_func = OpVariable %u32ptr_func Function %val = OpPtrCastToGeneric %f32ptr_gen %ptr_func )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected input and Result Type to point to the same type: " "PtrCastToGeneric")); } TEST_F(ValidateConversion, GenericCastToPtrSuccess) { const std::string body = R"( %ptr_func = OpVariable %f32ptr_func Function %ptr_gen = OpPtrCastToGeneric %f32ptr_gen %ptr_func %ptr_func2 = OpGenericCastToPtr %f32ptr_func %ptr_gen %ptr_wg = OpGenericCastToPtr %f32ptr_wg %ptr_gen %ptr_cwg = OpGenericCastToPtr %f32ptr_cwg %ptr_gen )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateConversion, GenericCastToPtrWrongResultType) { const std::string body = R"( %ptr_func = OpVariable %f32ptr_func Function %ptr_gen = OpPtrCastToGeneric %f32ptr_gen %ptr_func %ptr_func2 = OpGenericCastToPtr %f32 %ptr_gen )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Result Type to be a pointer: GenericCastToPtr")); } TEST_F(ValidateConversion, GenericCastToPtrWrongResultStorageClass) { const std::string body = R"( %ptr_func = OpVariable %f32ptr_func Function %ptr_gen = OpPtrCastToGeneric %f32ptr_gen %ptr_func %ptr_func2 = OpGenericCastToPtr %f32ptr_gen %ptr_gen )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to have storage class Workgroup, " "CrossWorkgroup or Function: GenericCastToPtr")); } TEST_F(ValidateConversion, GenericCastToPtrWrongInputType) { const std::string body = R"( %ptr_func = OpVariable %f32ptr_func Function %ptr_gen = OpPtrCastToGeneric %f32ptr_gen %ptr_func %ptr_func2 = OpGenericCastToPtr %f32ptr_func %f32_1 )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected input to be a pointer: GenericCastToPtr")); } TEST_F(ValidateConversion, GenericCastToPtrWrongInputStorageClass) { const std::string body = R"( %ptr_func = OpVariable %f32ptr_func Function %ptr_func2 = OpGenericCastToPtr %f32ptr_func %ptr_func )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected input to have storage class Generic: " "GenericCastToPtr")); } TEST_F(ValidateConversion, GenericCastToPtrPointToDifferentType) { const std::string body = R"( %ptr_func = OpVariable %f32ptr_func Function %ptr_gen = OpPtrCastToGeneric %f32ptr_gen %ptr_func %ptr_func2 = OpGenericCastToPtr %u32ptr_func %ptr_gen )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected input and Result Type to point to the same type: " "GenericCastToPtr")); } TEST_F(ValidateConversion, GenericCastToPtrExplicitSuccess) { const std::string body = R"( %ptr_func = OpVariable %f32ptr_func Function %ptr_gen = OpPtrCastToGeneric %f32ptr_gen %ptr_func %ptr_func2 = OpGenericCastToPtrExplicit %f32ptr_func %ptr_gen Function %ptr_wg = OpGenericCastToPtrExplicit %f32ptr_wg %ptr_gen Workgroup %ptr_cwg = OpGenericCastToPtrExplicit %f32ptr_cwg %ptr_gen CrossWorkgroup )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateConversion, GenericCastToPtrExplicitWrongResultType) { const std::string body = R"( %ptr_func = OpVariable %f32ptr_func Function %ptr_gen = OpPtrCastToGeneric %f32ptr_gen %ptr_func %ptr_func2 = OpGenericCastToPtrExplicit %f32 %ptr_gen Function )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected Result Type to be a pointer: GenericCastToPtrExplicit")); } TEST_F(ValidateConversion, GenericCastToPtrExplicitResultStorageClassDiffers) { const std::string body = R"( %ptr_func = OpVariable %f32ptr_func Function %ptr_gen = OpPtrCastToGeneric %f32ptr_gen %ptr_func %ptr_func2 = OpGenericCastToPtrExplicit %f32ptr_func %ptr_gen Workgroup )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be of target storage class: " "GenericCastToPtrExplicit")); } TEST_F(ValidateConversion, GenericCastToPtrExplicitWrongResultStorageClass) { const std::string body = R"( %ptr_func = OpVariable %f32ptr_func Function %ptr_gen = OpPtrCastToGeneric %f32ptr_gen %ptr_func %ptr_func2 = OpGenericCastToPtrExplicit %f32ptr_gen %ptr_gen Generic )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected target storage class to be Workgroup, " "CrossWorkgroup or Function: GenericCastToPtrExplicit")); } TEST_F(ValidateConversion, GenericCastToPtrExplicitWrongInputType) { const std::string body = R"( %ptr_func = OpVariable %f32ptr_func Function %ptr_gen = OpPtrCastToGeneric %f32ptr_gen %ptr_func %ptr_func2 = OpGenericCastToPtrExplicit %f32ptr_func %f32_1 Function )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected input to be a pointer: GenericCastToPtrExplicit")); } TEST_F(ValidateConversion, GenericCastToPtrExplicitWrongInputStorageClass) { const std::string body = R"( %ptr_func = OpVariable %f32ptr_func Function %ptr_func2 = OpGenericCastToPtrExplicit %f32ptr_func %ptr_func Function )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected input to have storage class Generic: " "GenericCastToPtrExplicit")); } TEST_F(ValidateConversion, GenericCastToPtrExplicitPointToDifferentType) { const std::string body = R"( %ptr_func = OpVariable %f32ptr_func Function %ptr_gen = OpPtrCastToGeneric %f32ptr_gen %ptr_func %ptr_func2 = OpGenericCastToPtrExplicit %u32ptr_func %ptr_gen Function )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected input and Result Type to point to the same type: " "GenericCastToPtrExplicit")); } TEST_F(ValidateConversion, CoopMatConversionSuccess) { const std::string body = R"( OpCapability Shader OpCapability Float16 OpCapability Int16 OpCapability CooperativeMatrixNV OpExtension "SPV_NV_cooperative_matrix" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f16 = OpTypeFloat 16 %f32 = OpTypeFloat 32 %u16 = OpTypeInt 16 0 %u32 = OpTypeInt 32 0 %s16 = OpTypeInt 16 1 %s32 = OpTypeInt 32 1 %u32_8 = OpConstant %u32 8 %subgroup = OpConstant %u32 3 %f16mat = OpTypeCooperativeMatrixNV %f16 %subgroup %u32_8 %u32_8 %f32mat = OpTypeCooperativeMatrixNV %f32 %subgroup %u32_8 %u32_8 %u16mat = OpTypeCooperativeMatrixNV %u16 %subgroup %u32_8 %u32_8 %u32mat = OpTypeCooperativeMatrixNV %u32 %subgroup %u32_8 %u32_8 %s16mat = OpTypeCooperativeMatrixNV %s16 %subgroup %u32_8 %u32_8 %s32mat = OpTypeCooperativeMatrixNV %s32 %subgroup %u32_8 %u32_8 %f16_1 = OpConstant %f16 1 %f32_1 = OpConstant %f32 1 %u16_1 = OpConstant %u16 1 %u32_1 = OpConstant %u32 1 %s16_1 = OpConstant %s16 1 %s32_1 = OpConstant %s32 1 %f16mat_1 = OpConstantComposite %f16mat %f16_1 %f32mat_1 = OpConstantComposite %f32mat %f32_1 %u16mat_1 = OpConstantComposite %u16mat %u16_1 %u32mat_1 = OpConstantComposite %u32mat %u32_1 %s16mat_1 = OpConstantComposite %s16mat %s16_1 %s32mat_1 = OpConstantComposite %s32mat %s32_1 %main = OpFunction %void None %func %main_entry = OpLabel %val11 = OpConvertFToU %u16mat %f16mat_1 %val12 = OpConvertFToU %u32mat %f16mat_1 %val13 = OpConvertFToS %s16mat %f16mat_1 %val14 = OpConvertFToS %s32mat %f16mat_1 %val15 = OpFConvert %f32mat %f16mat_1 %val21 = OpConvertFToU %u16mat %f32mat_1 %val22 = OpConvertFToU %u32mat %f32mat_1 %val23 = OpConvertFToS %s16mat %f32mat_1 %val24 = OpConvertFToS %s32mat %f32mat_1 %val25 = OpFConvert %f16mat %f32mat_1 %val31 = OpConvertUToF %f16mat %u16mat_1 %val32 = OpConvertUToF %f32mat %u16mat_1 %val33 = OpUConvert %u32mat %u16mat_1 %val34 = OpSConvert %s32mat %u16mat_1 %val41 = OpConvertSToF %f16mat %s16mat_1 %val42 = OpConvertSToF %f32mat %s16mat_1 %val43 = OpUConvert %u32mat %s16mat_1 %val44 = OpSConvert %s32mat %s16mat_1 OpReturn OpFunctionEnd)"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateConversion, CoopMatConversionShapesMismatchFail) { const std::string body = R"( OpCapability Shader OpCapability Float16 OpCapability Int16 OpCapability CooperativeMatrixNV OpExtension "SPV_NV_cooperative_matrix" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f16 = OpTypeFloat 16 %f32 = OpTypeFloat 32 %u16 = OpTypeInt 16 0 %u32 = OpTypeInt 32 0 %s16 = OpTypeInt 16 1 %s32 = OpTypeInt 32 1 %u32_8 = OpConstant %u32 8 %u32_4 = OpConstant %u32 4 %subgroup = OpConstant %u32 3 %f16mat = OpTypeCooperativeMatrixNV %f16 %subgroup %u32_8 %u32_8 %f32mat = OpTypeCooperativeMatrixNV %f32 %subgroup %u32_4 %u32_4 %f16_1 = OpConstant %f16 1 %f16mat_1 = OpConstantComposite %f16mat %f16_1 %main = OpFunction %void None %func %main_entry = OpLabel %val15 = OpFConvert %f32mat %f16mat_1 OpReturn OpFunctionEnd)"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected rows of Matrix type and Result Type to be identical")); } TEST_F(ValidateConversion, CoopMatConversionShapesMismatchPass) { const std::string body = R"( OpCapability Shader OpCapability Float16 OpCapability Int16 OpCapability CooperativeMatrixNV OpExtension "SPV_NV_cooperative_matrix" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f16 = OpTypeFloat 16 %f32 = OpTypeFloat 32 %u16 = OpTypeInt 16 0 %u32 = OpTypeInt 32 0 %s16 = OpTypeInt 16 1 %s32 = OpTypeInt 32 1 %u32_8 = OpConstant %u32 8 %u32_4 = OpSpecConstant %u32 4 %subgroup = OpConstant %u32 3 %f16mat = OpTypeCooperativeMatrixNV %f16 %subgroup %u32_8 %u32_8 %f32mat = OpTypeCooperativeMatrixNV %f32 %subgroup %u32_4 %u32_4 %f16_1 = OpConstant %f16 1 %f16mat_1 = OpConstantComposite %f16mat %f16_1 %main = OpFunction %void None %func %main_entry = OpLabel %val15 = OpFConvert %f32mat %f16mat_1 OpReturn OpFunctionEnd)"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateConversion, CoopMatKHRConversionSuccess) { const std::string body = R"( OpCapability Shader OpCapability Float16 OpCapability Int16 OpCapability CooperativeMatrixKHR OpExtension "SPV_KHR_cooperative_matrix" OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f16 = OpTypeFloat 16 %f32 = OpTypeFloat 32 %u16 = OpTypeInt 16 0 %u32 = OpTypeInt 32 0 %s16 = OpTypeInt 16 1 %s32 = OpTypeInt 32 1 %u32_8 = OpConstant %u32 8 %use_A = OpConstant %u32 0 %subgroup = OpConstant %u32 3 %f16mat = OpTypeCooperativeMatrixKHR %f16 %subgroup %u32_8 %u32_8 %use_A %f32mat = OpTypeCooperativeMatrixKHR %f32 %subgroup %u32_8 %u32_8 %use_A %u16mat = OpTypeCooperativeMatrixKHR %u16 %subgroup %u32_8 %u32_8 %use_A %u32mat = OpTypeCooperativeMatrixKHR %u32 %subgroup %u32_8 %u32_8 %use_A %s16mat = OpTypeCooperativeMatrixKHR %s16 %subgroup %u32_8 %u32_8 %use_A %s32mat = OpTypeCooperativeMatrixKHR %s32 %subgroup %u32_8 %u32_8 %use_A %f16_1 = OpConstant %f16 1 %f32_1 = OpConstant %f32 1 %u16_1 = OpConstant %u16 1 %u32_1 = OpConstant %u32 1 %s16_1 = OpConstant %s16 1 %s32_1 = OpConstant %s32 1 %f16mat_1 = OpConstantComposite %f16mat %f16_1 %f32mat_1 = OpConstantComposite %f32mat %f32_1 %u16mat_1 = OpConstantComposite %u16mat %u16_1 %u32mat_1 = OpConstantComposite %u32mat %u32_1 %s16mat_1 = OpConstantComposite %s16mat %s16_1 %s32mat_1 = OpConstantComposite %s32mat %s32_1 %main = OpFunction %void None %func %main_entry = OpLabel %val11 = OpConvertFToU %u16mat %f16mat_1 %val12 = OpConvertFToU %u32mat %f16mat_1 %val13 = OpConvertFToS %s16mat %f16mat_1 %val14 = OpConvertFToS %s32mat %f16mat_1 %val15 = OpFConvert %f32mat %f16mat_1 %val21 = OpConvertFToU %u16mat %f32mat_1 %val22 = OpConvertFToU %u32mat %f32mat_1 %val23 = OpConvertFToS %s16mat %f32mat_1 %val24 = OpConvertFToS %s32mat %f32mat_1 %val25 = OpFConvert %f16mat %f32mat_1 %val31 = OpConvertUToF %f16mat %u16mat_1 %val32 = OpConvertUToF %f32mat %u16mat_1 %val33 = OpUConvert %u32mat %u16mat_1 %val34 = OpSConvert %s32mat %u16mat_1 %val41 = OpConvertSToF %f16mat %s16mat_1 %val42 = OpConvertSToF %f32mat %s16mat_1 %val43 = OpUConvert %u32mat %s16mat_1 %val44 = OpSConvert %s32mat %s16mat_1 OpReturn OpFunctionEnd)"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateConversion, CoopMatKHRConversionUseMismatchFail) { const std::string body = R"( OpCapability Shader OpCapability Float16 OpCapability Int16 OpCapability CooperativeMatrixKHR OpExtension "SPV_KHR_cooperative_matrix" OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f16 = OpTypeFloat 16 %f32 = OpTypeFloat 32 %u16 = OpTypeInt 16 0 %u32 = OpTypeInt 32 0 %s16 = OpTypeInt 16 1 %s32 = OpTypeInt 32 1 %u32_8 = OpConstant %u32 8 %u32_4 = OpConstant %u32 4 %subgroup = OpConstant %u32 3 %use_A = OpConstant %u32 0 %use_B = OpConstant %u32 1 %f16mat = OpTypeCooperativeMatrixKHR %f16 %subgroup %u32_8 %u32_8 %use_A %f32mat = OpTypeCooperativeMatrixKHR %f32 %subgroup %u32_8 %u32_8 %use_B %f16_1 = OpConstant %f16 1 %f16mat_1 = OpConstantComposite %f16mat %f16_1 %main = OpFunction %void None %func %main_entry = OpLabel %val1 = OpFConvert %f32mat %f16mat_1 OpReturn OpFunctionEnd)"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Use of Matrix type and Result Type to be identical")); } TEST_F(ValidateConversion, CoopMatKHRConversionScopeMismatchFail) { const std::string body = R"( OpCapability Shader OpCapability Float16 OpCapability Int16 OpCapability CooperativeMatrixKHR OpExtension "SPV_KHR_cooperative_matrix" OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f16 = OpTypeFloat 16 %f32 = OpTypeFloat 32 %u16 = OpTypeInt 16 0 %u32 = OpTypeInt 32 0 %s16 = OpTypeInt 16 1 %s32 = OpTypeInt 32 1 %u32_8 = OpConstant %u32 8 %u32_4 = OpConstant %u32 4 %subgroup = OpConstant %u32 3 %device = OpConstant %u32 1 %use_A = OpConstant %u32 0 %f16mat = OpTypeCooperativeMatrixKHR %f16 %subgroup %u32_8 %u32_8 %use_A %f32mat = OpTypeCooperativeMatrixKHR %f32 %device %u32_8 %u32_8 %use_A %f16_1 = OpConstant %f16 1 %f16mat_1 = OpConstantComposite %f16mat %f16_1 %main = OpFunction %void None %func %main_entry = OpLabel %val1 = OpFConvert %f32mat %f16mat_1 OpReturn OpFunctionEnd)"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected scopes of Matrix and Result Type to be identical")); } TEST_F(ValidateConversion, BitcastSuccess) { const std::string body = R"( %ptr = OpVariable %f32ptr_func Function %val1 = OpBitcast %u32 %ptr %val2 = OpBitcast %u64 %ptr %val3 = OpBitcast %f32ptr_func %u32_1 %val4 = OpBitcast %f32ptr_wg %u64_1 %val5 = OpBitcast %f32 %u32_1 %val6 = OpBitcast %f32vec2 %u32vec2_12 %val7 = OpBitcast %f32vec2 %u64_1 %val8 = OpBitcast %f64 %u32vec2_12 %val9 = OpBitcast %f32vec4 %f64vec2_12 )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateConversion, BitcastSuccessSPV1p5) { const std::string body = R"( %ptr = OpVariable %f32ptr_func Function %val1 = OpBitcast %u32 %ptr %val2 = OpBitcast %u64 %ptr %val3 = OpBitcast %f32ptr_func %u32_1 %val4 = OpBitcast %f32ptr_wg %u64_1 %val5 = OpBitcast %f32 %u32_1 %val6 = OpBitcast %f32vec2 %u32vec2_12 %val7 = OpBitcast %f32vec2 %u64_1 %val8 = OpBitcast %f64 %u32vec2_12 %val9 = OpBitcast %f32vec4 %f64vec2_12 %val10 = OpBitcast %u32ptr_func %u32vec2_01 %val11 = OpBitcast %u32vec2 %ptr )"; CompileSuccessfully(GenerateKernelCode(body).c_str(), SPV_ENV_UNIVERSAL_1_5); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); } TEST_F(ValidateConversion, BitcastSuccessPhysicalStorageBufferKHR) { const std::string body = R"( %ptr = OpVariable %f32ptr_func Function %val1 = OpBitcast %u32 %ptr %val2 = OpBitcast %u64 %ptr %val3 = OpBitcast %f32ptr_func %u32_1 %val4 = OpBitcast %f32ptr_wg %u64_1 %val5 = OpBitcast %f32 %u32_1 %val6 = OpBitcast %f32vec2 %u32vec2_12 %val7 = OpBitcast %f32vec2 %u64_1 %val8 = OpBitcast %f64 %u32vec2_12 %val9 = OpBitcast %f32vec4 %f64vec2_12 %val10 = OpBitcast %u32ptr_func %u32vec2_01 %val11 = OpBitcast %u32vec2 %ptr )"; CompileSuccessfully( GenerateKernelCode(body, "\nOpExtension \"SPV_KHR_physical_storage_buffer\"") .c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateConversion, BitcastInputHasNoType) { const std::string body = R"( %val = OpBitcast %u32 %f32 )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Operand '4[%float]' cannot be a " "type")); } TEST_F(ValidateConversion, BitcastWrongResultType) { const std::string body = R"( %val = OpBitcast %bool %f32_1 )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Result Type to be a pointer or int or float vector " "or scalar type: Bitcast")); } TEST_F(ValidateConversion, BitcastWrongInputType) { const std::string body = R"( %val = OpBitcast %u32 %true )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected input to be a pointer or int or float vector " "or scalar: Bitcast")); } TEST_F(ValidateConversion, BitcastPtrWrongInputType) { const std::string body = R"( %val = OpBitcast %u32ptr_func %f32_1 )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected input to be a pointer or int scalar if " "Result Type is pointer: Bitcast")); } TEST_F(ValidateConversion, BitcastPtrWrongInputTypeSPV1p5) { const std::string body = R"( %val = OpBitcast %u32ptr_func %f32_1 )"; CompileSuccessfully(GenerateKernelCode(body).c_str(), SPV_ENV_UNIVERSAL_1_5); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected input to be a pointer, int scalar or 32-bit " "int vector if Result Type is pointer: Bitcast")); } TEST_F(ValidateConversion, BitcastPtrWrongInputTypePhysicalStorageBufferKHR) { const std::string body = R"( %val = OpBitcast %u32ptr_func %f32_1 )"; CompileSuccessfully( GenerateKernelCode(body, "\nOpExtension \"SPV_KHR_physical_storage_buffer\"") .c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected input to be a pointer, int scalar or 32-bit " "int vector if Result Type is pointer: Bitcast")); } TEST_F(ValidateConversion, BitcastPtrWrongInputTypeIntVectorSPV1p5) { const std::string body = R"( %val = OpBitcast %u32ptr_func %u64vec2_01 )"; CompileSuccessfully(GenerateKernelCode(body).c_str(), SPV_ENV_UNIVERSAL_1_5); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected input to be a pointer, int scalar or 32-bit " "int vector if Result Type is pointer: Bitcast")); } TEST_F(ValidateConversion, BitcastPtrWrongInputTypeIntVectorPhysicalStorageBufferKHR) { const std::string body = R"( %val = OpBitcast %u32ptr_func %u64vec2_01 )"; CompileSuccessfully( GenerateKernelCode(body, "\nOpExtension \"SPV_KHR_physical_storage_buffer\"") .c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected input to be a pointer, int scalar or 32-bit " "int vector if Result Type is pointer: Bitcast")); } TEST_F(ValidateConversion, BitcastPtrWrongResultType) { const std::string body = R"( %val = OpBitcast %f32 %f32inp )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Pointer can only be converted to another pointer or " "int scalar: Bitcast")); } TEST_F(ValidateConversion, BitcastPtrWrongResultTypeSPV1p5) { const std::string body = R"( %val = OpBitcast %f32 %f32inp )"; CompileSuccessfully(GenerateKernelCode(body).c_str(), SPV_ENV_UNIVERSAL_1_5); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Pointer can only be converted to another pointer, int " "scalar or 32-bit int vector: Bitcast")); } TEST_F(ValidateConversion, BitcastPtrWrongResultTypePhysicalStorageBufferKHR) { const std::string body = R"( %val = OpBitcast %f32 %f32inp )"; CompileSuccessfully( GenerateKernelCode(body, "\nOpExtension \"SPV_KHR_physical_storage_buffer\"") .c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Pointer can only be converted to another pointer, int " "scalar or 32-bit int vector: Bitcast")); } TEST_F(ValidateConversion, BitcastPtrWrongResultTypeIntVectorSPV1p5) { const std::string body = R"( %val = OpBitcast %u64vec2 %f32inp )"; CompileSuccessfully(GenerateKernelCode(body).c_str(), SPV_ENV_UNIVERSAL_1_5); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Pointer can only be converted to another pointer, int " "scalar or 32-bit int vector: Bitcast")); } TEST_F(ValidateConversion, BitcastPtrWrongResultTypeIntVectorPhysicalStorageBufferKHR) { const std::string body = R"( %val = OpBitcast %u64vec2 %f32inp )"; CompileSuccessfully( GenerateKernelCode(body, "\nOpExtension \"SPV_KHR_physical_storage_buffer\"") .c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Pointer can only be converted to another pointer, int " "scalar or 32-bit int vector: Bitcast")); } TEST_F(ValidateConversion, BitcastDifferentTotalBitWidth) { const std::string body = R"( %val = OpBitcast %f32 %u64_1 )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected input to have the same total bit width as Result Type: " "Bitcast")); } TEST_F(ValidateConversion, ConvertUToPtrInputIsAType) { const std::string spirv = R"( OpCapability Addresses OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %int = OpTypeInt 32 0 %ptr_int = OpTypePointer Function %int %void = OpTypeVoid %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel %1 = OpConvertUToPtr %ptr_int %int OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Operand '1[%uint]' cannot be a " "type")); } TEST_F(ValidateConversion, ConvertUToPtrPSBSuccess) { const std::string body = R"( OpCapability PhysicalStorageBufferAddresses OpCapability Int64 OpCapability Shader OpExtension "SPV_EXT_physical_storage_buffer" OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %uint64 = OpTypeInt 64 0 %u64_1 = OpConstant %uint64 1 %ptr = OpTypePointer PhysicalStorageBuffer %uint64 %void = OpTypeVoid %voidfn = OpTypeFunction %void %main = OpFunction %void None %voidfn %entry = OpLabel %val1 = OpConvertUToPtr %ptr %u64_1 OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateConversion, ConvertUToPtrPSBStorageClass) { const std::string body = R"( OpCapability PhysicalStorageBufferAddresses OpCapability Int64 OpCapability Shader OpExtension "SPV_EXT_physical_storage_buffer" OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %uint64 = OpTypeInt 64 0 %u64_1 = OpConstant %uint64 1 %ptr = OpTypePointer Function %uint64 %void = OpTypeVoid %voidfn = OpTypeFunction %void %main = OpFunction %void None %voidfn %entry = OpLabel %val1 = OpConvertUToPtr %ptr %u64_1 %val2 = OpConvertPtrToU %uint64 %val1 OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Pointer storage class must be " "PhysicalStorageBuffer: ConvertUToPtr")); } TEST_F(ValidateConversion, ConvertUToPtrVulkanWrongWidth) { const std::string body = R"( OpCapability PhysicalStorageBufferAddresses OpCapability Int64 OpCapability Shader OpExtension "SPV_EXT_physical_storage_buffer" OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %uint32 = OpTypeInt 32 0 %uint64 = OpTypeInt 64 0 %u32_1 = OpConstant %uint32 1 %ptr = OpTypePointer PhysicalStorageBuffer %uint64 %void = OpTypeVoid %voidfn = OpTypeFunction %void %main = OpFunction %void None %voidfn %entry = OpLabel %val1 = OpConvertUToPtr %ptr %u32_1 OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-PhysicalStorageBuffer64-04710")); EXPECT_THAT( getDiagnosticString(), HasSubstr("PhysicalStorageBuffer64 addressing mode requires the input " "integer to have a 64-bit width for Vulkan environment.")); } TEST_F(ValidateConversion, ConvertPtrToUPSBSuccess) { const std::string body = R"( OpCapability PhysicalStorageBufferAddresses OpCapability Int64 OpCapability Shader OpExtension "SPV_EXT_physical_storage_buffer" OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpDecorate %val1 RestrictPointer %uint64 = OpTypeInt 64 0 %u64_1 = OpConstant %uint64 1 %ptr = OpTypePointer PhysicalStorageBuffer %uint64 %pptr_f = OpTypePointer Function %ptr %void = OpTypeVoid %voidfn = OpTypeFunction %void %main = OpFunction %void None %voidfn %entry = OpLabel %val1 = OpVariable %pptr_f Function %val2 = OpLoad %ptr %val1 %val3 = OpConvertPtrToU %uint64 %val2 OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateConversion, ConvertPtrToUPSBStorageClass) { const std::string body = R"( OpCapability PhysicalStorageBufferAddresses OpCapability Int64 OpCapability Shader OpExtension "SPV_EXT_physical_storage_buffer" OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %uint64 = OpTypeInt 64 0 %u64_1 = OpConstant %uint64 1 %ptr = OpTypePointer Function %uint64 %void = OpTypeVoid %voidfn = OpTypeFunction %void %main = OpFunction %void None %voidfn %entry = OpLabel %val1 = OpVariable %ptr Function %val2 = OpConvertPtrToU %uint64 %val1 OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Pointer storage class must be " "PhysicalStorageBuffer: ConvertPtrToU")); } TEST_F(ValidateConversion, ConvertPtrToUVulkanWrongWidth) { const std::string body = R"( OpCapability PhysicalStorageBufferAddresses OpCapability Int64 OpCapability Shader OpExtension "SPV_EXT_physical_storage_buffer" OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpDecorate %val1 RestrictPointer %uint32 = OpTypeInt 32 0 %uint64 = OpTypeInt 64 0 %ptr = OpTypePointer PhysicalStorageBuffer %uint64 %pptr_f = OpTypePointer Function %ptr %void = OpTypeVoid %voidfn = OpTypeFunction %void %main = OpFunction %void None %voidfn %entry = OpLabel %val1 = OpVariable %pptr_f Function %val2 = OpLoad %ptr %val1 %val3 = OpConvertPtrToU %uint32 %val2 OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-PhysicalStorageBuffer64-04710")); EXPECT_THAT( getDiagnosticString(), HasSubstr("PhysicalStorageBuffer64 addressing mode requires the result " "integer type to have a 64-bit width for Vulkan environment.")); } TEST_F(ValidateConversion, ConvertUToAccelerationStructureU32Vec2) { const std::string extensions = R"( OpCapability RayQueryKHR OpExtension "SPV_KHR_ray_query" )"; const std::string types = R"( %u32vec2ptr_func = OpTypePointer Function %u32vec2 %typeAS = OpTypeAccelerationStructureKHR )"; const std::string body = R"( %asHandle = OpVariable %u32vec2ptr_func Function %load = OpLoad %u32vec2 %asHandle %val = OpConvertUToAccelerationStructureKHR %typeAS %load )"; CompileSuccessfully(GenerateShaderCode(body, extensions, "", types).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateConversion, ConvertUToAccelerationStructureSuccessU64) { const std::string extensions = R"( OpCapability RayQueryKHR OpExtension "SPV_KHR_ray_query" )"; const std::string types = R"( %u64_func = OpTypePointer Function %u64 %typeAS = OpTypeAccelerationStructureKHR )"; const std::string body = R"( %asHandle = OpVariable %u64_func Function %load = OpLoad %u64 %asHandle %val = OpConvertUToAccelerationStructureKHR %typeAS %load )"; CompileSuccessfully(GenerateShaderCode(body, extensions, "", types).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateConversion, ConvertUToAccelerationStructureResult) { const std::string extensions = R"( OpCapability RayQueryKHR OpExtension "SPV_KHR_ray_query" )"; const std::string types = R"( %u32vec2ptr_func = OpTypePointer Function %u32vec2 %typeRQ = OpTypeRayQueryKHR )"; const std::string body = R"( %asHandle = OpVariable %u32vec2ptr_func Function %load = OpLoad %u32vec2 %asHandle %val = OpConvertUToAccelerationStructureKHR %typeRQ %load )"; CompileSuccessfully(GenerateShaderCode(body, extensions, "", types).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be a Acceleration Structure")); } TEST_F(ValidateConversion, ConvertUToAccelerationStructureU32) { const std::string extensions = R"( OpCapability RayQueryKHR OpExtension "SPV_KHR_ray_query" )"; const std::string types = R"( %u32ptr_func = OpTypePointer Function %u32 %typeAS = OpTypeAccelerationStructureKHR )"; const std::string body = R"( %asHandle = OpVariable %u32ptr_func Function %load = OpLoad %u32 %asHandle %val = OpConvertUToAccelerationStructureKHR %typeAS %load )"; CompileSuccessfully(GenerateShaderCode(body, extensions, "", types).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected 64-bit uint scalar or 2-component 32-bit " "uint vector as input")); } TEST_F(ValidateConversion, ConvertUToAccelerationStructureS64) { const std::string extensions = R"( OpCapability RayQueryKHR OpExtension "SPV_KHR_ray_query" )"; const std::string types = R"( %s64ptr_func = OpTypePointer Function %s64 %typeAS = OpTypeAccelerationStructureKHR )"; const std::string body = R"( %asHandle = OpVariable %s64ptr_func Function %load = OpLoad %s64 %asHandle %val = OpConvertUToAccelerationStructureKHR %typeAS %load )"; CompileSuccessfully(GenerateShaderCode(body, extensions, "", types).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected 64-bit uint scalar or 2-component 32-bit " "uint vector as input")); } TEST_F(ValidateConversion, ConvertUToAccelerationStructureS32Vec2) { const std::string extensions = R"( OpCapability RayQueryKHR OpExtension "SPV_KHR_ray_query" )"; const std::string types = R"( %s32vec2ptr_func = OpTypePointer Function %s32vec2 %typeAS = OpTypeAccelerationStructureKHR )"; const std::string body = R"( %asHandle = OpVariable %s32vec2ptr_func Function %load = OpLoad %s32vec2 %asHandle %val = OpConvertUToAccelerationStructureKHR %typeAS %load )"; CompileSuccessfully(GenerateShaderCode(body, extensions, "", types).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected 64-bit uint scalar or 2-component 32-bit " "uint vector as input")); } TEST_F(ValidateConversion, BitcastUntypedPointerInput) { const std::string spirv = R"( OpCapability Shader OpCapability VariablePointers OpCapability UntypedPointersKHR OpCapability WorkgroupMemoryExplicitLayoutKHR OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpExtension "SPV_KHR_variable_pointers" OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %var OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %struct = OpTypeStruct %int %ptr = OpTypeUntypedPointerKHR Workgroup %var = OpUntypedVariableKHR %ptr Workgroup %struct %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %cast = OpBitcast %int %var OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); } TEST_F(ValidateConversion, BitcastUntypedPointerOutput) { const std::string spirv = R"( OpCapability Shader OpCapability VariablePointers OpCapability UntypedPointersKHR OpCapability WorkgroupMemoryExplicitLayoutKHR OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpExtension "SPV_KHR_variable_pointers" OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %ptr = OpTypeUntypedPointerKHR Workgroup %var = OpUntypedVariableKHR %ptr Workgroup %int %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %cast = OpBitcast %ptr %int_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); } using ValidateSmallConversions = spvtest::ValidateBase; CodeGenerator GetSmallConversionsCodeGenerator() { CodeGenerator generator; generator.capabilities_ = R"( OpCapability Shader OpCapability Linkage OpCapability UniformAndStorageBuffer16BitAccess OpCapability UniformAndStorageBuffer8BitAccess )"; generator.extensions_ = R"( OpExtension "SPV_KHR_16bit_storage" OpExtension "SPV_KHR_8bit_storage" )"; generator.memory_model_ = "OpMemoryModel Logical GLSL450\n"; generator.before_types_ = R"( OpDecorate %char_block Block OpMemberDecorate %char_block 0 Offset 0 OpDecorate %short_block Block OpMemberDecorate %short_block 0 Offset 0 OpDecorate %half_block Block OpMemberDecorate %half_block 0 Offset 0 OpDecorate %int_block Block OpMemberDecorate %int_block 0 Offset 0 OpDecorate %float_block Block OpMemberDecorate %float_block 0 Offset 0 )"; generator.types_ = R"( %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %int2 = OpTypeVector %int 2 %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %float2 = OpTypeVector %float 2 %char = OpTypeInt 8 0 %char2 = OpTypeVector %char 2 %short = OpTypeInt 16 0 %short2 = OpTypeVector %short 2 %half = OpTypeFloat 16 %half2 = OpTypeVector %half 2 %char_block = OpTypeStruct %char2 %short_block = OpTypeStruct %short2 %half_block = OpTypeStruct %half2 %int_block = OpTypeStruct %int2 %float_block = OpTypeStruct %float2 %ptr_ssbo_char_block = OpTypePointer StorageBuffer %char_block %ptr_ssbo_char2 = OpTypePointer StorageBuffer %char2 %ptr_ssbo_char = OpTypePointer StorageBuffer %char %ptr_ssbo_short_block = OpTypePointer StorageBuffer %short_block %ptr_ssbo_short2 = OpTypePointer StorageBuffer %short2 %ptr_ssbo_short = OpTypePointer StorageBuffer %short %ptr_ssbo_half_block = OpTypePointer StorageBuffer %half_block %ptr_ssbo_half2 = OpTypePointer StorageBuffer %half2 %ptr_ssbo_half = OpTypePointer StorageBuffer %half %ptr_ssbo_int_block = OpTypePointer StorageBuffer %int_block %ptr_ssbo_int2 = OpTypePointer StorageBuffer %int2 %ptr_ssbo_int = OpTypePointer StorageBuffer %int %ptr_ssbo_float_block = OpTypePointer StorageBuffer %float_block %ptr_ssbo_float2 = OpTypePointer StorageBuffer %float2 %ptr_ssbo_float = OpTypePointer StorageBuffer %float %void_fn = OpTypeFunction %void %char_var = OpVariable %ptr_ssbo_char_block StorageBuffer %short_var = OpVariable %ptr_ssbo_short_block StorageBuffer %half_var = OpVariable %ptr_ssbo_half_block StorageBuffer %int_var = OpVariable %ptr_ssbo_int_block StorageBuffer %float_var = OpVariable %ptr_ssbo_float_block StorageBuffer )"; generator.after_types_ = R"( %func = OpFunction %void None %void_fn %entry = OpLabel %char2_gep = OpAccessChain %ptr_ssbo_char2 %char_var %int_0 %ld_char2 = OpLoad %char2 %char2_gep %char_gep = OpAccessChain %ptr_ssbo_char %char_var %int_0 %int_0 %ld_char = OpLoad %char %char_gep %short2_gep = OpAccessChain %ptr_ssbo_short2 %short_var %int_0 %ld_short2 = OpLoad %short2 %short2_gep %short_gep = OpAccessChain %ptr_ssbo_short %short_var %int_0 %int_0 %ld_short = OpLoad %short %short_gep %half2_gep = OpAccessChain %ptr_ssbo_half2 %half_var %int_0 %ld_half2 = OpLoad %half2 %half2_gep %half_gep = OpAccessChain %ptr_ssbo_half %half_var %int_0 %int_0 %ld_half = OpLoad %half %half_gep %int2_gep = OpAccessChain %ptr_ssbo_int2 %int_var %int_0 %ld_int2 = OpLoad %int2 %int2_gep %int_gep = OpAccessChain %ptr_ssbo_int %int_var %int_0 %int_0 %ld_int = OpLoad %int %int_gep %float2_gep = OpAccessChain %ptr_ssbo_float2 %float_var %int_0 %ld_float2 = OpLoad %float2 %float2_gep %float_gep = OpAccessChain %ptr_ssbo_float %float_var %int_0 %int_0 %ld_float = OpLoad %float %float_gep )"; generator.add_at_the_end_ = R"( OpReturn OpFunctionEnd )"; return generator; } TEST_P(ValidateSmallConversions, Instruction) { CodeGenerator generator = GetSmallConversionsCodeGenerator(); generator.after_types_ += GetParam() + "\n"; CompileSuccessfully(generator.Build(), SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "8- or 16-bit types can only be used with width-only conversions")); } INSTANTIATE_TEST_SUITE_P(SmallConversionInstructions, ValidateSmallConversions, Values("%inst = OpConvertFToU %char %ld_float", "%inst = OpConvertFToU %char2 %ld_float2", "%inst = OpConvertFToU %short %ld_float", "%inst = OpConvertFToU %short2 %ld_float2", "%inst = OpConvertFToU %int %ld_half", "%inst = OpConvertFToU %int2 %ld_half2", "%inst = OpConvertFToS %char %ld_float", "%inst = OpConvertFToS %char2 %ld_float2", "%inst = OpConvertFToS %short %ld_float", "%inst = OpConvertFToS %short2 %ld_float2", "%inst = OpConvertFToS %int %ld_half", "%inst = OpConvertFToS %int2 %ld_half2", "%inst = OpConvertSToF %float %ld_char", "%inst = OpConvertSToF %float2 %ld_char2", "%inst = OpConvertSToF %float %ld_short", "%inst = OpConvertSToF %float2 %ld_short2", "%inst = OpConvertSToF %half %ld_int", "%inst = OpConvertSToF %half2 %ld_int2", "%inst = OpConvertUToF %float %ld_char", "%inst = OpConvertUToF %float2 %ld_char2", "%inst = OpConvertUToF %float %ld_short", "%inst = OpConvertUToF %float2 %ld_short2", "%inst = OpConvertUToF %half %ld_int", "%inst = OpConvertUToF %half2 %ld_int2", "%inst = OpBitcast %half %ld_short", "%inst = OpBitcast %half2 %ld_short2", "%inst = OpBitcast %short %ld_half", "%inst = OpBitcast %short2 %ld_half2")); TEST_F(ValidateConversion, CoopMat2ConversionSuccess) { const std::string body = R"( OpCapability Shader OpCapability Float16 OpCapability Int16 OpCapability CooperativeMatrixConversionsNV OpCapability CooperativeMatrixKHR OpExtension "SPV_KHR_cooperative_matrix" OpExtension "SPV_NV_cooperative_matrix2" OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f16 = OpTypeFloat 16 %f32 = OpTypeFloat 32 %u16 = OpTypeInt 16 0 %u32 = OpTypeInt 32 0 %s16 = OpTypeInt 16 1 %s32 = OpTypeInt 32 1 %u32_8 = OpConstant %u32 8 %u32_16 = OpConstant %u32 16 %use_A = OpConstant %u32 0 %use_B = OpConstant %u32 1 %use_Acc = OpConstant %u32 2 %subgroup = OpConstant %u32 3 %f16matA = OpTypeCooperativeMatrixKHR %f16 %subgroup %u32_8 %u32_8 %use_A %f32matA = OpTypeCooperativeMatrixKHR %f32 %subgroup %u32_8 %u32_8 %use_A %u16matA = OpTypeCooperativeMatrixKHR %u16 %subgroup %u32_8 %u32_8 %use_A %u32matA = OpTypeCooperativeMatrixKHR %u32 %subgroup %u32_8 %u32_8 %use_A %s16matA = OpTypeCooperativeMatrixKHR %s16 %subgroup %u32_8 %u32_8 %use_A %s32matA = OpTypeCooperativeMatrixKHR %s32 %subgroup %u32_8 %u32_8 %use_A %f16matB = OpTypeCooperativeMatrixKHR %f16 %subgroup %u32_8 %u32_8 %use_B %f32matB = OpTypeCooperativeMatrixKHR %f32 %subgroup %u32_8 %u32_8 %use_B %u16matB = OpTypeCooperativeMatrixKHR %u16 %subgroup %u32_8 %u32_8 %use_B %u32matB = OpTypeCooperativeMatrixKHR %u32 %subgroup %u32_8 %u32_8 %use_B %s16matB = OpTypeCooperativeMatrixKHR %s16 %subgroup %u32_8 %u32_8 %use_B %s32matB = OpTypeCooperativeMatrixKHR %s32 %subgroup %u32_8 %u32_8 %use_B %f16matAcc = OpTypeCooperativeMatrixKHR %f16 %subgroup %u32_8 %u32_8 %use_Acc %f32matAcc = OpTypeCooperativeMatrixKHR %f32 %subgroup %u32_8 %u32_8 %use_Acc %u16matAcc = OpTypeCooperativeMatrixKHR %u16 %subgroup %u32_8 %u32_8 %use_Acc %u32matAcc = OpTypeCooperativeMatrixKHR %u32 %subgroup %u32_8 %u32_8 %use_Acc %s16matAcc = OpTypeCooperativeMatrixKHR %s16 %subgroup %u32_8 %u32_8 %use_Acc %s32matAcc = OpTypeCooperativeMatrixKHR %s32 %subgroup %u32_8 %u32_8 %use_Acc %f16matAcc16x8 = OpTypeCooperativeMatrixKHR %f16 %subgroup %u32_16 %u32_8 %use_Acc %f16matB8x16 = OpTypeCooperativeMatrixKHR %f16 %subgroup %u32_8 %u32_16 %use_B %f16_1 = OpConstant %f16 1 %f32_1 = OpConstant %f32 1 %u16_1 = OpConstant %u16 1 %u32_1 = OpConstant %u32 1 %s16_1 = OpConstant %s16 1 %s32_1 = OpConstant %s32 1 %f16matAcc_1 = OpConstantComposite %f16matAcc %f16_1 %f32matAcc_1 = OpConstantComposite %f32matAcc %f32_1 %u16matAcc_1 = OpConstantComposite %u16matAcc %u16_1 %u32matAcc_1 = OpConstantComposite %u32matAcc %u32_1 %s16matAcc_1 = OpConstantComposite %s16matAcc %s16_1 %s32matAcc_1 = OpConstantComposite %s32matAcc %s32_1 %f16matAcc16x8_1 = OpConstantComposite %f16matAcc16x8 %f16_1 %main = OpFunction %void None %func %main_entry = OpLabel %val11A = OpConvertFToU %u16matA %f16matAcc_1 %val12A = OpConvertFToU %u32matA %f16matAcc_1 %val13A = OpConvertFToS %s16matA %f16matAcc_1 %val14A = OpConvertFToS %s32matA %f16matAcc_1 %val15A = OpFConvert %f32matA %f16matAcc_1 %val11B = OpConvertFToU %u16matB %f16matAcc_1 %val12B = OpConvertFToU %u32matB %f16matAcc_1 %val13B = OpConvertFToS %s16matB %f16matAcc_1 %val14B = OpConvertFToS %s32matB %f16matAcc_1 %val15B = OpFConvert %f32matB %f16matAcc_1 %val21A = OpConvertFToU %u16matA %f32matAcc_1 %val22A = OpConvertFToU %u32matA %f32matAcc_1 %val23A = OpConvertFToS %s16matA %f32matAcc_1 %val24A = OpConvertFToS %s32matA %f32matAcc_1 %val25A = OpFConvert %f16matA %f32matAcc_1 %val21B = OpConvertFToU %u16matB %f32matAcc_1 %val22B = OpConvertFToU %u32matB %f32matAcc_1 %val23B = OpConvertFToS %s16matB %f32matAcc_1 %val24B = OpConvertFToS %s32matB %f32matAcc_1 %val25B = OpFConvert %f16matB %f32matAcc_1 %val31A = OpConvertUToF %f16matA %u16matAcc_1 %val32A = OpConvertUToF %f32matA %u16matAcc_1 %val33A = OpUConvert %u32matA %u16matAcc_1 %val34A = OpSConvert %s32matA %u16matAcc_1 %val31B = OpConvertUToF %f16matB %u16matAcc_1 %val32B = OpConvertUToF %f32matB %u16matAcc_1 %val33B = OpUConvert %u32matB %u16matAcc_1 %val34B = OpSConvert %s32matB %u16matAcc_1 %val41A = OpConvertSToF %f16matA %s16matAcc_1 %val42A = OpConvertSToF %f32matA %s16matAcc_1 %val43A = OpUConvert %u32matA %s16matAcc_1 %val44A = OpSConvert %s32matA %s16matAcc_1 %val41B = OpConvertSToF %f16matB %s16matAcc_1 %val42B = OpConvertSToF %f32matB %s16matAcc_1 %val43B = OpUConvert %u32matB %s16matAcc_1 %val44B = OpSConvert %s32matB %s16matAcc_1 %val51A = OpCooperativeMatrixConvertNV %f16matA %f16matAcc_1 %val52A = OpCooperativeMatrixConvertNV %f32matA %f32matAcc_1 %val53A = OpCooperativeMatrixConvertNV %u16matA %u16matAcc_1 %val54A = OpCooperativeMatrixConvertNV %s16matA %s16matAcc_1 %val51B = OpCooperativeMatrixConvertNV %f16matB %f16matAcc_1 %val52B = OpCooperativeMatrixConvertNV %f32matB %f32matAcc_1 %val53B = OpCooperativeMatrixConvertNV %u16matB %u16matAcc_1 %val54B = OpCooperativeMatrixConvertNV %s16matB %s16matAcc_1 %val61B = OpCooperativeMatrixTransposeNV %f16matB %f16matAcc_1 %val62B = OpCooperativeMatrixTransposeNV %f32matB %f32matAcc_1 %val63B = OpCooperativeMatrixTransposeNV %u16matB %u16matAcc_1 %val64B = OpCooperativeMatrixTransposeNV %s16matB %s16matAcc_1 %val71B = OpCooperativeMatrixTransposeNV %f16matB8x16 %f16matAcc16x8_1 OpReturn OpFunctionEnd)"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateConversion, CoopMat2TransposeShapeFail) { const std::string body = R"( OpCapability Shader OpCapability Float16 OpCapability Int16 OpCapability CooperativeMatrixConversionsNV OpCapability CooperativeMatrixKHR OpExtension "SPV_KHR_cooperative_matrix" OpExtension "SPV_NV_cooperative_matrix2" OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f16 = OpTypeFloat 16 %u32 = OpTypeInt 32 0 %u32_8 = OpConstant %u32 8 %u32_16 = OpConstant %u32 16 %use_B = OpConstant %u32 1 %use_Acc = OpConstant %u32 2 %subgroup = OpConstant %u32 3 %f16matAcc16x8 = OpTypeCooperativeMatrixKHR %f16 %subgroup %u32_16 %u32_8 %use_Acc %f16matB16x8 = OpTypeCooperativeMatrixKHR %f16 %subgroup %u32_16 %u32_8 %use_B %f16_1 = OpConstant %f16 1 %f16matAcc16x8_1 = OpConstantComposite %f16matAcc16x8 %f16_1 %main = OpFunction %void None %func %main_entry = OpLabel %val71B = OpCooperativeMatrixTransposeNV %f16matB16x8 %f16matAcc16x8_1 OpReturn OpFunctionEnd)"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected rows of Matrix type and Result Type to be " "swapped with columns")); } TEST_F(ValidateConversion, CoopVecConversionSuccess) { const std::string body = R"( OpCapability Shader OpCapability Float16 OpCapability Int16 OpCapability CooperativeVectorNV OpCapability ReplicatedCompositesEXT OpExtension "SPV_NV_cooperative_vector" OpExtension "SPV_EXT_replicated_composites" OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f16 = OpTypeFloat 16 %f32 = OpTypeFloat 32 %u16 = OpTypeInt 16 0 %u32 = OpTypeInt 32 0 %s16 = OpTypeInt 16 1 %s32 = OpTypeInt 32 1 %u32_8 = OpConstant %u32 8 %use_A = OpConstant %u32 0 %subgroup = OpConstant %u32 3 %f16vec = OpTypeCooperativeVectorNV %f16 %u32_8 %f32vec = OpTypeCooperativeVectorNV %f32 %u32_8 %u16vec = OpTypeCooperativeVectorNV %u16 %u32_8 %u32vec = OpTypeCooperativeVectorNV %u32 %u32_8 %s16vec = OpTypeCooperativeVectorNV %s16 %u32_8 %s32vec = OpTypeCooperativeVectorNV %s32 %u32_8 %f16_1 = OpConstant %f16 1 %f32_1 = OpConstant %f32 1 %u16_1 = OpConstant %u16 1 %u32_1 = OpConstant %u32 1 %s16_1 = OpConstant %s16 1 %s32_1 = OpConstant %s32 1 %f16vec_1 = OpConstantCompositeReplicateEXT %f16vec %f16_1 %f32vec_1 = OpConstantCompositeReplicateEXT %f32vec %f32_1 %u16vec_1 = OpConstantCompositeReplicateEXT %u16vec %u16_1 %u32vec_1 = OpConstantCompositeReplicateEXT %u32vec %u32_1 %s16vec_1 = OpConstantCompositeReplicateEXT %s16vec %s16_1 %s32vec_1 = OpConstantCompositeReplicateEXT %s32vec %s32_1 %main = OpFunction %void None %func %main_entry = OpLabel %val11 = OpConvertFToU %u16vec %f16vec_1 %val12 = OpConvertFToU %u32vec %f16vec_1 %val13 = OpConvertFToS %s16vec %f16vec_1 %val14 = OpConvertFToS %s32vec %f16vec_1 %val15 = OpFConvert %f32vec %f16vec_1 %val21 = OpConvertFToU %u16vec %f32vec_1 %val22 = OpConvertFToU %u32vec %f32vec_1 %val23 = OpConvertFToS %s16vec %f32vec_1 %val24 = OpConvertFToS %s32vec %f32vec_1 %val25 = OpFConvert %f16vec %f32vec_1 %val31 = OpConvertUToF %f16vec %u16vec_1 %val32 = OpConvertUToF %f32vec %u16vec_1 %val33 = OpUConvert %u32vec %u16vec_1 %val34 = OpSConvert %s32vec %u16vec_1 %val41 = OpConvertSToF %f16vec %s16vec_1 %val42 = OpConvertSToF %f32vec %s16vec_1 %val43 = OpUConvert %u32vec %s16vec_1 %val44 = OpSConvert %s32vec %s16vec_1 OpReturn OpFunctionEnd)"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateConversion, CoopVecConversionDimMismatchFail) { const std::string body = R"( OpCapability Shader OpCapability Float16 OpCapability Int16 OpCapability CooperativeVectorNV OpCapability ReplicatedCompositesEXT OpExtension "SPV_NV_cooperative_vector" OpExtension "SPV_EXT_replicated_composites" OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f16 = OpTypeFloat 16 %f32 = OpTypeFloat 32 %u16 = OpTypeInt 16 0 %u32 = OpTypeInt 32 0 %s16 = OpTypeInt 16 1 %s32 = OpTypeInt 32 1 %u32_8 = OpConstant %u32 8 %u32_4 = OpConstant %u32 4 %subgroup = OpConstant %u32 3 %use_A = OpConstant %u32 0 %use_B = OpConstant %u32 1 %f16vec = OpTypeCooperativeVectorNV %f16 %u32_8 %f32vec = OpTypeCooperativeVectorNV %f32 %u32_4 %f16_1 = OpConstant %f16 1 %f16vec_1 = OpConstantCompositeReplicateEXT %f16vec %f16_1 %main = OpFunction %void None %func %main_entry = OpLabel %val1 = OpFConvert %f32vec %f16vec_1 OpReturn OpFunctionEnd)"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected number of components to be identical")); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_data_test.cpp000066400000000000000000000653371475742701700236260ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validation tests for Data Rules. #include #include #include "gmock/gmock.h" #include "test/unit_spirv.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::HasSubstr; using ::testing::MatchesRegex; using ValidateData = spvtest::ValidateBase>; std::string HeaderWith(std::string cap) { return std::string("OpCapability Shader OpCapability Linkage OpCapability ") + cap + " OpMemoryModel Logical GLSL450 "; } std::string header = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 )"; std::string header_with_addresses = R"( OpCapability Addresses OpCapability Kernel OpCapability GenericPointer OpCapability Linkage OpMemoryModel Physical32 OpenCL )"; std::string header_with_vec16_cap = R"( OpCapability Shader OpCapability Vector16 OpCapability Linkage OpMemoryModel Logical GLSL450 )"; std::string header_with_int8 = R"( OpCapability Shader OpCapability Linkage OpCapability Int8 OpMemoryModel Logical GLSL450 )"; std::string header_with_int16 = R"( OpCapability Shader OpCapability Linkage OpCapability Int16 OpMemoryModel Logical GLSL450 )"; std::string header_with_int64 = R"( OpCapability Shader OpCapability Linkage OpCapability Int64 OpMemoryModel Logical GLSL450 )"; std::string header_with_float16 = R"( OpCapability Shader OpCapability Linkage OpCapability Float16 OpMemoryModel Logical GLSL450 )"; std::string header_with_float16_buffer = R"( OpCapability Shader OpCapability Linkage OpCapability Float16Buffer OpMemoryModel Logical GLSL450 )"; std::string header_with_float64 = R"( OpCapability Shader OpCapability Linkage OpCapability Float64 OpMemoryModel Logical GLSL450 )"; std::string invalid_comp_error = "Illegal number of components"; std::string missing_cap_error = "requires the Vector16 capability"; std::string missing_int8_cap_error = "requires the Int8 capability"; std::string missing_int16_cap_error = "requires the Int16 capability," " or an extension that explicitly enables 16-bit integers."; std::string missing_int64_cap_error = "requires the Int64 capability"; std::string missing_float16_cap_error = "requires the Float16 or Float16Buffer capability," " or an extension that explicitly enables 16-bit floating point."; std::string missing_float64_cap_error = "requires the Float64 capability"; std::string invalid_num_bits_error = "Invalid number of bits"; TEST_F(ValidateData, vec0) { std::string str = header + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 0 )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(invalid_comp_error)); } TEST_F(ValidateData, vec1) { std::string str = header + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 1 )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(invalid_comp_error)); } TEST_F(ValidateData, vec2) { std::string str = header + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 2 )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateData, vec3) { std::string str = header + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 3 )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateData, vec4) { std::string str = header + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateData, vec5) { std::string str = header + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 5 )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(invalid_comp_error)); } TEST_F(ValidateData, vec8) { std::string str = header + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 8 )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(missing_cap_error)); } TEST_F(ValidateData, vec8_with_capability) { std::string str = header_with_vec16_cap + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 8 )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateData, vec16) { std::string str = header + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 8 )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(missing_cap_error)); } TEST_F(ValidateData, vec16_with_capability) { std::string str = header_with_vec16_cap + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 16 )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateData, vec15) { std::string str = header + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 15 )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(invalid_comp_error)); } TEST_F(ValidateData, int8_good) { std::string str = header_with_int8 + "%2 = OpTypeInt 8 0"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateData, int8_bad) { std::string str = header + "%2 = OpTypeInt 8 1"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(missing_int8_cap_error)); } TEST_F(ValidateData, int8_with_storage_buffer_8bit_access_good) { std::string str = HeaderWith( "StorageBuffer8BitAccess " "OpExtension \"SPV_KHR_8bit_storage\"") + " %2 = OpTypeInt 8 0"; CompileSuccessfully(str.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()) << getDiagnosticString(); } TEST_F(ValidateData, int8_with_uniform_and_storage_buffer_8bit_access_good) { std::string str = HeaderWith( "UniformAndStorageBuffer8BitAccess " "OpExtension \"SPV_KHR_8bit_storage\"") + " %2 = OpTypeInt 8 0"; CompileSuccessfully(str.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()) << getDiagnosticString(); } TEST_F(ValidateData, int8_with_storage_push_constant_8_good) { std::string str = HeaderWith( "StoragePushConstant8 " "OpExtension \"SPV_KHR_8bit_storage\"") + " %2 = OpTypeInt 8 0"; CompileSuccessfully(str.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()) << getDiagnosticString(); } TEST_F(ValidateData, int16_good) { std::string str = header_with_int16 + "%2 = OpTypeInt 16 1"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateData, storage_uniform_buffer_block_16_good) { std::string str = HeaderWith( "StorageUniformBufferBlock16 " "OpExtension \"SPV_KHR_16bit_storage\"") + "%2 = OpTypeInt 16 1 %3 = OpTypeFloat 16"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateData, storage_uniform_16_good) { std::string str = HeaderWith("StorageUniform16 OpExtension \"SPV_KHR_16bit_storage\"") + "%2 = OpTypeInt 16 1 %3 = OpTypeFloat 16"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateData, storage_push_constant_16_good) { std::string str = HeaderWith( "StoragePushConstant16 " "OpExtension \"SPV_KHR_16bit_storage\"") + "%2 = OpTypeInt 16 1 %3 = OpTypeFloat 16"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateData, storage_input_output_16_good) { std::string str = HeaderWith( "StorageInputOutput16 " "OpExtension \"SPV_KHR_16bit_storage\"") + "%2 = OpTypeInt 16 1 %3 = OpTypeFloat 16"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateData, amd_gpu_shader_half_float_fetch_16_good) { std::string str = R"( OpCapability Shader OpCapability Linkage OpExtension "SPV_AMD_gpu_shader_half_float_fetch" OpMemoryModel Logical GLSL450 %2 = OpTypeFloat 16)"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateData, int16_bad) { std::string str = header + "%2 = OpTypeInt 16 1"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(missing_int16_cap_error)); } TEST_F(ValidateData, int64_good) { std::string str = header_with_int64 + "%2 = OpTypeInt 64 1"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateData, int64_bad) { std::string str = header + "%2 = OpTypeInt 64 1"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(missing_int64_cap_error)); } // Number of bits in an integer may be only one of: {8,16,32,64} TEST_F(ValidateData, int_invalid_num_bits) { std::string str = header + "%2 = OpTypeInt 48 1"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(invalid_num_bits_error)); } TEST_F(ValidateData, float16_good) { std::string str = header_with_float16 + "%2 = OpTypeFloat 16"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateData, float16_buffer_good) { std::string str = header_with_float16_buffer + "%2 = OpTypeFloat 16"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateData, float16_bad) { std::string str = header + "%2 = OpTypeFloat 16"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(missing_float16_cap_error)); } TEST_F(ValidateData, float64_good) { std::string str = header_with_float64 + "%2 = OpTypeFloat 64"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateData, float64_bad) { std::string str = header + "%2 = OpTypeFloat 64"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(missing_float64_cap_error)); } // Number of bits in a float may be only one of: {16,32,64} TEST_F(ValidateData, float_invalid_num_bits) { std::string str = header + "%2 = OpTypeFloat 48"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(invalid_num_bits_error)); } TEST_F(ValidateData, matrix_data_type_float) { std::string str = header + R"( %f32 = OpTypeFloat 32 %vec3 = OpTypeVector %f32 3 %mat33 = OpTypeMatrix %vec3 3 )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateData, ids_should_be_validated_before_data) { std::string str = header + R"( %f32 = OpTypeFloat 32 %mat33 = OpTypeMatrix %vec3 3 )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Operand '3[%3]' requires a previous definition")); } TEST_F(ValidateData, matrix_bad_column_type) { std::string str = header + R"( %f32 = OpTypeFloat 32 %mat33 = OpTypeMatrix %f32 3 )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Columns in a matrix must be of type vector")); } TEST_F(ValidateData, matrix_data_type_int) { std::string str = header + R"( %int32 = OpTypeInt 32 1 %vec3 = OpTypeVector %int32 3 %mat33 = OpTypeMatrix %vec3 3 )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("can only be parameterized with floating-point types")); } TEST_F(ValidateData, matrix_data_type_bool) { std::string str = header + R"( %boolt = OpTypeBool %vec3 = OpTypeVector %boolt 3 %mat33 = OpTypeMatrix %vec3 3 )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("can only be parameterized with floating-point types")); } TEST_F(ValidateData, matrix_with_0_columns) { std::string str = header + R"( %f32 = OpTypeFloat 32 %vec3 = OpTypeVector %f32 3 %mat33 = OpTypeMatrix %vec3 0 )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("can only be parameterized as having only 2, 3, or 4 columns")); } TEST_F(ValidateData, matrix_with_1_column) { std::string str = header + R"( %f32 = OpTypeFloat 32 %vec3 = OpTypeVector %f32 3 %mat33 = OpTypeMatrix %vec3 1 )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("can only be parameterized as having only 2, 3, or 4 columns")); } TEST_F(ValidateData, matrix_with_2_columns) { std::string str = header + R"( %f32 = OpTypeFloat 32 %vec3 = OpTypeVector %f32 3 %mat33 = OpTypeMatrix %vec3 2 )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateData, matrix_with_3_columns) { std::string str = header + R"( %f32 = OpTypeFloat 32 %vec3 = OpTypeVector %f32 3 %mat33 = OpTypeMatrix %vec3 3 )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateData, matrix_with_4_columns) { std::string str = header + R"( %f32 = OpTypeFloat 32 %vec3 = OpTypeVector %f32 3 %mat33 = OpTypeMatrix %vec3 4 )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateData, matrix_with_5_column) { std::string str = header + R"( %f32 = OpTypeFloat 32 %vec3 = OpTypeVector %f32 3 %mat33 = OpTypeMatrix %vec3 5 )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("can only be parameterized as having only 2, 3, or 4 columns")); } TEST_F(ValidateData, specialize_int) { std::string str = header + R"( %i32 = OpTypeInt 32 1 %len = OpSpecConstant %i32 2)"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateData, specialize_float) { std::string str = header + R"( %f32 = OpTypeFloat 32 %len = OpSpecConstant %f32 2)"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateData, specialize_boolean) { std::string str = header + R"( %2 = OpTypeBool %3 = OpSpecConstantTrue %2 %4 = OpSpecConstantFalse %2)"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateData, specialize_boolean_true_to_int) { std::string str = header + R"( %2 = OpTypeInt 32 1 %3 = OpSpecConstantTrue %2)"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpSpecConstantTrue Result Type '1[%int]' is not " "a boolean type")); } TEST_F(ValidateData, specialize_boolean_false_to_int) { std::string str = header + R"( %2 = OpTypeInt 32 1 %4 = OpSpecConstantFalse %2)"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpSpecConstantFalse Result Type '1[%int]' is not " "a boolean type")); } TEST_F(ValidateData, missing_forward_pointer_decl) { std::string str = header_with_addresses + R"( %uintt = OpTypeInt 32 0 %3 = OpTypeStruct %fwd_ptrt %uintt )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Operand '3[%3]' requires a previous definition")); } TEST_F(ValidateData, missing_forward_pointer_decl_self_reference) { std::string str = header_with_addresses + R"( %uintt = OpTypeInt 32 0 %3 = OpTypeStruct %3 %uintt )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Operand '2[%_struct_2]' requires a previous definition")); } TEST_F(ValidateData, forward_pointer_missing_definition) { std::string str = header_with_addresses + R"( OpTypeForwardPointer %_ptr_Generic_struct_A Generic %uintt = OpTypeInt 32 0 %struct_B = OpTypeStruct %uintt %_ptr_Generic_struct_A )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("forward referenced IDs have not been defined")); } TEST_F(ValidateData, forward_ref_bad_type) { std::string str = header_with_addresses + R"( OpTypeForwardPointer %_ptr_Generic_struct_A Generic %uintt = OpTypeInt 32 0 %struct_B = OpTypeStruct %uintt %_ptr_Generic_struct_A %_ptr_Generic_struct_A = OpTypeFloat 32 )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Pointer type in OpTypeForwardPointer is not a pointer " "type.\n OpTypeForwardPointer %float Generic\n")); } TEST_F(ValidateData, forward_ref_points_to_non_struct) { std::string str = header_with_addresses + R"( OpTypeForwardPointer %_ptr_Generic_struct_A Generic %uintt = OpTypeInt 32 0 %struct_B = OpTypeStruct %uintt %_ptr_Generic_struct_A %_ptr_Generic_struct_A = OpTypePointer Generic %uintt )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Forward pointers must point to a structure")); } TEST_F(ValidateData, struct_forward_pointer_good) { std::string str = header_with_addresses + R"( OpTypeForwardPointer %_ptr_Generic_struct_A Generic %uintt = OpTypeInt 32 0 %struct_B = OpTypeStruct %uintt %_ptr_Generic_struct_A %struct_C = OpTypeStruct %uintt %struct_B %struct_A = OpTypeStruct %uintt %struct_C %_ptr_Generic_struct_A = OpTypePointer Generic %struct_C )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateData, ext_16bit_storage_caps_allow_free_fp_rounding_mode) { for (const char* cap : {"StorageUniform16", "StorageUniformBufferBlock16"}) { for (const char* mode : {"RTE", "RTZ", "RTP", "RTN"}) { std::string str = std::string(R"( OpCapability Shader OpCapability Linkage OpCapability )") + cap + R"( OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_KHR_variable_pointers" OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpDecorate %_ FPRoundingMode )" + mode + R"( %half = OpTypeFloat 16 %float = OpTypeFloat 32 %float_1_25 = OpConstant %float 1.25 %half_ptr = OpTypePointer StorageBuffer %half %half_ptr_var = OpVariable %half_ptr StorageBuffer %void = OpTypeVoid %func = OpTypeFunction %void %main = OpFunction %void None %func %main_entry = OpLabel %_ = OpFConvert %half %float_1_25 OpStore %half_ptr_var %_ OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } } } TEST_F(ValidateData, vulkan_disallow_free_fp_rounding_mode) { for (const char* mode : {"RTE", "RTZ"}) { for (const auto env : {SPV_ENV_VULKAN_1_0, SPV_ENV_VULKAN_1_1}) { std::string str = std::string(R"( OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 OpDecorate %_ FPRoundingMode )") + mode + R"( %half = OpTypeFloat 16 %float = OpTypeFloat 32 %float_1_25 = OpConstant %float 1.25 %half_ptr = OpTypePointer StorageBuffer %half %half_ptr_var = OpVariable %half_ptr StorageBuffer %void = OpTypeVoid %func = OpTypeFunction %void %main = OpFunction %void None %func %main_entry = OpLabel %_ = OpFConvert %half %float_1_25 OpStore %half_ptr_var %_ OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_CAPABILITY, ValidateInstructions(env)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Operand 2 of Decorate requires one of these capabilities: " "StorageBuffer16BitAccess UniformAndStorageBuffer16BitAccess " "StoragePushConstant16 StorageInputOutput16")); } } } TEST_F(ValidateData, void_array) { std::string str = header + R"( %void = OpTypeVoid %int = OpTypeInt 32 0 %int_5 = OpConstant %int 5 %array = OpTypeArray %void %int_5 )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpTypeArray Element Type '1[%void]' is a void type.")); } TEST_F(ValidateData, void_runtime_array) { std::string str = header + R"( %void = OpTypeVoid %array = OpTypeRuntimeArray %void )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpTypeRuntimeArray Element Type '1[%void]' is a void type.")); } TEST_F(ValidateData, vulkan_RTA_array_at_end_of_struct) { std::string str = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft OpDecorate %array_t ArrayStride 4 OpMemberDecorate %struct_t 0 Offset 0 OpMemberDecorate %struct_t 1 Offset 4 OpDecorate %struct_t Block %uint_t = OpTypeInt 32 0 %array_t = OpTypeRuntimeArray %uint_t %struct_t = OpTypeStruct %uint_t %array_t %struct_ptr = OpTypePointer StorageBuffer %struct_t %2 = OpVariable %struct_ptr StorageBuffer %void = OpTypeVoid %func_t = OpTypeFunction %void %func = OpFunction %void None %func_t %1 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str(), SPV_ENV_VULKAN_1_1); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_1)); } TEST_F(ValidateData, vulkan_RTA_not_at_end_of_struct) { std::string str = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft OpDecorate %array_t ArrayStride 4 OpMemberDecorate %struct_t 0 Offset 0 OpMemberDecorate %struct_t 1 Offset 4 OpDecorate %struct_t Block %uint_t = OpTypeInt 32 0 %array_t = OpTypeRuntimeArray %uint_t %struct_t = OpTypeStruct %array_t %uint_t %struct_ptr = OpTypePointer StorageBuffer %struct_t %2 = OpVariable %struct_ptr StorageBuffer %void = OpTypeVoid %func_t = OpTypeFunction %void %func = OpFunction %void None %func_t %1 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str(), SPV_ENV_VULKAN_1_1); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpTypeRuntimeArray-04680")); EXPECT_THAT(getDiagnosticString(), HasSubstr("In Vulkan, OpTypeRuntimeArray must only be used for " "the last member of an OpTypeStruct\n %_struct_3 = " "OpTypeStruct %_runtimearr_uint %uint\n")); } TEST_F(ValidateData, TypeForwardReference) { std::string test = R"( OpCapability Shader OpCapability PhysicalStorageBufferAddresses OpCapability Linkage OpMemoryModel Logical GLSL450 OpTypeForwardPointer %1 PhysicalStorageBuffer %2 = OpTypeStruct %3 = OpTypeRuntimeArray %1 %1 = OpTypePointer PhysicalStorageBuffer %2 )"; CompileSuccessfully(test, SPV_ENV_UNIVERSAL_1_5); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); } TEST_F(ValidateData, VulkanTypeForwardStorageClass) { std::string test = R"( OpCapability Shader OpCapability PhysicalStorageBufferAddresses OpMemoryModel Logical GLSL450 OpTypeForwardPointer %1 Uniform %2 = OpTypeStruct %3 = OpTypeRuntimeArray %1 %1 = OpTypePointer Uniform %2 )"; CompileSuccessfully(test, SPV_ENV_VULKAN_1_2); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpTypeForwardPointer-04711")); EXPECT_THAT(getDiagnosticString(), HasSubstr("In Vulkan, OpTypeForwardPointer must have " "a storage class of PhysicalStorageBuffer.")); } TEST_F(ValidateData, TypeForwardReferenceMustBeForwardPointer) { std::string test = R"( OpCapability Shader OpCapability PhysicalStorageBufferAddresses OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeStruct %2 = OpTypeRuntimeArray %3 %3 = OpTypePointer PhysicalStorageBuffer %1 )"; CompileSuccessfully(test, SPV_ENV_UNIVERSAL_1_5); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Operand '3[%_ptr_PhysicalStorageBuffer__struct_1]' " "requires a previous definition")); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_decoration_test.cpp000066400000000000000000013547331475742701700250460ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // Modifications Copyright (C) 2024 Advanced Micro Devices, Inc. All rights // reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validation tests for decorations #include #include #include "gmock/gmock.h" #include "source/val/decoration.h" #include "test/unit_spirv.h" #include "test/val/val_code_generator.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::Combine; using ::testing::Eq; using ::testing::HasSubstr; using ::testing::Values; struct TestResult { TestResult(spv_result_t in_validation_result = SPV_SUCCESS, const std::string& in_error_str = "") : validation_result(in_validation_result), error_str(in_error_str) {} spv_result_t validation_result; const std::string error_str; }; using ValidateDecorations = spvtest::ValidateBase; using ValidateDecorationString = spvtest::ValidateBase; using ValidateVulkanCombineDecorationResult = spvtest::ValidateBase>; TEST_F(ValidateDecorations, ValidateOpDecorateRegistration) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 Location 4 OpDecorate %1 Centroid %2 = OpTypeFloat 32 %3 = OpTypePointer Output %2 %1 = OpVariable %3 Output ; Since %1 is used first in Decoration, it gets id 1. )"; const uint32_t id = 1; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()); // Must have 2 decorations. EXPECT_THAT( vstate_->id_decorations(id), Eq(std::set{Decoration(spv::Decoration::Location, {4}), Decoration(spv::Decoration::Centroid)})); } TEST_F(ValidateDecorations, ValidateOpMemberDecorateRegistration) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %_arr_double_uint_6 ArrayStride 4 OpMemberDecorate %_struct_115 2 NonReadable OpMemberDecorate %_struct_115 2 Offset 2 OpDecorate %_struct_115 BufferBlock %float = OpTypeFloat 32 %uint = OpTypeInt 32 0 %uint_6 = OpConstant %uint 6 %_arr_double_uint_6 = OpTypeArray %float %uint_6 %_struct_115 = OpTypeStruct %float %float %_arr_double_uint_6 )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()); // The array must have 1 decoration. const uint32_t arr_id = 1; EXPECT_THAT( vstate_->id_decorations(arr_id), Eq(std::set{Decoration(spv::Decoration::ArrayStride, {4})})); // The struct must have 3 decorations. const uint32_t struct_id = 2; EXPECT_THAT( vstate_->id_decorations(struct_id), Eq(std::set{Decoration(spv::Decoration::NonReadable, {}, 2), Decoration(spv::Decoration::Offset, {2}, 2), Decoration(spv::Decoration::BufferBlock)})); } TEST_F(ValidateDecorations, ValidateOpMemberDecorateOutOfBound) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "Main" OpExecutionMode %1 OriginUpperLeft OpMemberDecorate %_struct_2 1 RelaxedPrecision %void = OpTypeVoid %4 = OpTypeFunction %void %float = OpTypeFloat 32 %_struct_2 = OpTypeStruct %float %1 = OpFunction %void None %4 %6 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Index 1 provided in OpMemberDecorate for struct " "'2[%_struct_2]' is out of bounds. The structure has 1 " "members. Largest valid index is 0.")); } TEST_F(ValidateDecorations, ValidateGroupDecorateRegistration) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 DescriptorSet 0 OpDecorate %1 RelaxedPrecision OpDecorate %1 Restrict %1 = OpDecorationGroup OpGroupDecorate %1 %2 %3 OpGroupDecorate %1 %4 %float = OpTypeFloat 32 %_runtimearr_float = OpTypeRuntimeArray %float %_struct_9 = OpTypeStruct %_runtimearr_float %_ptr_Uniform__struct_9 = OpTypePointer Uniform %_struct_9 %2 = OpVariable %_ptr_Uniform__struct_9 Uniform %_struct_10 = OpTypeStruct %_runtimearr_float %_ptr_Uniform__struct_10 = OpTypePointer Uniform %_struct_10 %3 = OpVariable %_ptr_Uniform__struct_10 Uniform %_struct_11 = OpTypeStruct %_runtimearr_float %_ptr_Uniform__struct_11 = OpTypePointer Uniform %_struct_11 %4 = OpVariable %_ptr_Uniform__struct_11 Uniform )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()); // Decoration group has 3 decorations. auto expected_decorations = std::set{Decoration(spv::Decoration::DescriptorSet, {0}), Decoration(spv::Decoration::RelaxedPrecision), Decoration(spv::Decoration::Restrict)}; // Decoration group is applied to id 1, 2, 3, and 4. Note that id 1 (which is // the decoration group id) also has all the decorations. EXPECT_THAT(vstate_->id_decorations(1), Eq(expected_decorations)); EXPECT_THAT(vstate_->id_decorations(2), Eq(expected_decorations)); EXPECT_THAT(vstate_->id_decorations(3), Eq(expected_decorations)); EXPECT_THAT(vstate_->id_decorations(4), Eq(expected_decorations)); } TEST_F(ValidateDecorations, ValidateGroupMemberDecorateRegistration) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 Offset 3 %1 = OpDecorationGroup OpGroupMemberDecorate %1 %_struct_1 3 %_struct_2 3 %_struct_3 3 %float = OpTypeFloat 32 %_runtimearr = OpTypeRuntimeArray %float %_struct_1 = OpTypeStruct %float %float %float %_runtimearr %_struct_2 = OpTypeStruct %float %float %float %_runtimearr %_struct_3 = OpTypeStruct %float %float %float %_runtimearr )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()); // Decoration group has 1 decoration. auto expected_decorations = std::set{Decoration(spv::Decoration::Offset, {3}, 3)}; // Decoration group is applied to id 2, 3, and 4. EXPECT_THAT(vstate_->id_decorations(2), Eq(expected_decorations)); EXPECT_THAT(vstate_->id_decorations(3), Eq(expected_decorations)); EXPECT_THAT(vstate_->id_decorations(4), Eq(expected_decorations)); } TEST_F(ValidateDecorations, LinkageImportUsedForInitializedVariableBad) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %target LinkageAttributes "link_ptr" Import %float = OpTypeFloat 32 %_ptr_float = OpTypePointer Uniform %float %zero = OpConstantNull %float %target = OpVariable %_ptr_float Uniform %zero )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState()); EXPECT_THAT(getDiagnosticString(), HasSubstr("A module-scope OpVariable with initialization value " "cannot be marked with the Import Linkage Type.")); } TEST_F(ValidateDecorations, LinkageExportUsedForInitializedVariableGood) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %target LinkageAttributes "link_ptr" Export %float = OpTypeFloat 32 %_ptr_float = OpTypePointer Uniform %float %zero = OpConstantNull %float %target = OpVariable %_ptr_float Uniform %zero )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()); } TEST_F(ValidateDecorations, StructAllMembersHaveBuiltInDecorationsGood) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %_struct_1 Block OpMemberDecorate %_struct_1 0 BuiltIn Position OpMemberDecorate %_struct_1 1 BuiltIn Position OpMemberDecorate %_struct_1 2 BuiltIn Position OpMemberDecorate %_struct_1 3 BuiltIn Position %float = OpTypeFloat 32 %_runtimearr = OpTypeRuntimeArray %float %_struct_1 = OpTypeStruct %float %float %float %_runtimearr )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()); } TEST_F(ValidateDecorations, MixedBuiltInDecorationsBad) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %_struct_1 Block OpMemberDecorate %_struct_1 0 BuiltIn Position OpMemberDecorate %_struct_1 1 BuiltIn Position %float = OpTypeFloat 32 %_runtimearr = OpTypeRuntimeArray %float %_struct_1 = OpTypeStruct %float %float %float %_runtimearr )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState()); EXPECT_THAT( getDiagnosticString(), HasSubstr("When BuiltIn decoration is applied to a structure-type " "member, all members of that structure type must also be " "decorated with BuiltIn (No allowed mixing of built-in " "variables and non-built-in variables within a single " "structure). Structure id 1 does not meet this requirement.")); } TEST_F(ValidateDecorations, StructContainsBuiltInStructBad) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %_struct_1 Block OpMemberDecorate %_struct_1 0 BuiltIn Position OpMemberDecorate %_struct_1 1 BuiltIn Position OpMemberDecorate %_struct_1 2 BuiltIn Position OpMemberDecorate %_struct_1 3 BuiltIn Position %float = OpTypeFloat 32 %_runtimearr = OpTypeRuntimeArray %float %_struct_1 = OpTypeStruct %float %float %float %_runtimearr %_struct_2 = OpTypeStruct %_struct_1 )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Structure '1[%_struct_1]' contains members with " "BuiltIn decoration. Therefore this structure may not " "be contained as a member of another structure type. " "Structure '4[%_struct_4]' contains structure " "'1[%_struct_1]'.")); } TEST_F(ValidateDecorations, StructContainsNonBuiltInStructGood) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %float = OpTypeFloat 32 %_struct_1 = OpTypeStruct %float %_struct_2 = OpTypeStruct %_struct_1 )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()); } TEST_F(ValidateDecorations, MultipleBuiltInObjectsConsumedByOpEntryPointBad) { std::string spirv = R"( OpCapability Shader OpCapability Geometry OpMemoryModel Logical GLSL450 OpEntryPoint Geometry %main "main" %in_1 %in_2 OpExecutionMode %main InputPoints OpExecutionMode %main OutputPoints OpDecorate %struct_1 Block OpDecorate %struct_2 Block OpMemberDecorate %struct_1 0 BuiltIn InvocationId OpMemberDecorate %struct_2 0 BuiltIn Position %int = OpTypeInt 32 1 %void = OpTypeVoid %func = OpTypeFunction %void %float = OpTypeFloat 32 %struct_1 = OpTypeStruct %int %struct_2 = OpTypeStruct %float %ptr_builtin_1 = OpTypePointer Input %struct_1 %ptr_builtin_2 = OpTypePointer Input %struct_2 %in_1 = OpVariable %ptr_builtin_1 Input %in_2 = OpVariable %ptr_builtin_2 Input %main = OpFunction %void None %func %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_BINARY, ValidateAndRetrieveValidationState()); EXPECT_THAT(getDiagnosticString(), HasSubstr("There must be at most one object per Storage Class " "that can contain a structure type containing members " "decorated with BuiltIn, consumed per entry-point.")); } TEST_F(ValidateDecorations, OneBuiltInObjectPerStorageClassConsumedByOpEntryPointGood) { std::string spirv = R"( OpCapability Shader OpCapability Geometry OpMemoryModel Logical GLSL450 OpEntryPoint Geometry %main "main" %in_1 %out_1 OpExecutionMode %main InputPoints OpExecutionMode %main OutputPoints OpDecorate %struct_1 Block OpDecorate %struct_2 Block OpMemberDecorate %struct_1 0 BuiltIn InvocationId OpMemberDecorate %struct_2 0 BuiltIn Position %int = OpTypeInt 32 1 %void = OpTypeVoid %func = OpTypeFunction %void %float = OpTypeFloat 32 %struct_1 = OpTypeStruct %int %struct_2 = OpTypeStruct %float %ptr_builtin_1 = OpTypePointer Input %struct_1 %ptr_builtin_2 = OpTypePointer Output %struct_2 %in_1 = OpVariable %ptr_builtin_1 Input %out_1 = OpVariable %ptr_builtin_2 Output %main = OpFunction %void None %func %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()); } TEST_F(ValidateDecorations, NoBuiltInObjectsConsumedByOpEntryPointGood) { std::string spirv = R"( OpCapability Shader OpCapability Geometry OpMemoryModel Logical GLSL450 OpEntryPoint Geometry %main "main" %in_1 %out_1 OpExecutionMode %main InputPoints OpExecutionMode %main OutputPoints %int = OpTypeInt 32 1 %void = OpTypeVoid %func = OpTypeFunction %void %float = OpTypeFloat 32 %struct_1 = OpTypeStruct %int %struct_2 = OpTypeStruct %float %ptr_builtin_1 = OpTypePointer Input %struct_1 %ptr_builtin_2 = OpTypePointer Output %struct_2 %in_1 = OpVariable %ptr_builtin_1 Input %out_1 = OpVariable %ptr_builtin_2 Output %main = OpFunction %void None %func %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()); } TEST_F(ValidateDecorations, EntryPointFunctionHasLinkageAttributeBad) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpDecorate %main LinkageAttributes "import_main" Import %1 = OpTypeVoid %2 = OpTypeFunction %1 %main = OpFunction %1 None %2 %4 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_BINARY, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("The LinkageAttributes Decoration (Linkage name: import_main) " "cannot be applied to function id 1 because it is targeted by " "an OpEntryPoint instruction.")); } TEST_F(ValidateDecorations, FunctionDeclarationWithoutImportLinkageBad) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %func = OpTypeFunction %void %main = OpFunction %void None %func OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_BINARY, ValidateAndRetrieveValidationState()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Function declaration (id 3) must have a LinkageAttributes " "decoration with the Import Linkage type.")); } TEST_F(ValidateDecorations, FunctionDeclarationWithImportLinkageGood) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %main LinkageAttributes "link_fn" Import %void = OpTypeVoid %func = OpTypeFunction %void %main = OpFunction %void None %func OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()); } TEST_F(ValidateDecorations, FunctionDeclarationWithExportLinkageBad) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %main LinkageAttributes "link_fn" Export %void = OpTypeVoid %func = OpTypeFunction %void %main = OpFunction %void None %func OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_BINARY, ValidateAndRetrieveValidationState()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Function declaration (id 1) must have a LinkageAttributes " "decoration with the Import Linkage type.")); } TEST_F(ValidateDecorations, FunctionDefinitionWithImportLinkageBad) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %main LinkageAttributes "link_fn" Import %void = OpTypeVoid %func = OpTypeFunction %void %main = OpFunction %void None %func %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_BINARY, ValidateAndRetrieveValidationState()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Function definition (id 1) may not be decorated with " "Import Linkage type.")); } TEST_F(ValidateDecorations, FunctionDefinitionWithoutImportLinkageGood) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %func = OpTypeFunction %void %main = OpFunction %void None %func %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()); } TEST_F(ValidateDecorations, BuiltinVariablesGoodVulkan) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragCoord %_entryPointOutput OpExecutionMode %main OriginUpperLeft OpSource HLSL 500 OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorate %_entryPointOutput Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %float_0 = OpConstant %float 0 %14 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %_ptr_Input_v4float = OpTypePointer Input %v4float %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %3 %5 = OpLabel OpStore %_entryPointOutput %14 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(env)); } TEST_F(ValidateDecorations, BuiltinVariablesWithLocationDecorationVulkan) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragCoord %_entryPointOutput OpExecutionMode %main OriginUpperLeft OpSource HLSL 500 OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorate %gl_FragCoord Location 0 OpDecorate %_entryPointOutput Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %float_0 = OpConstant %float 0 %14 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %_ptr_Input_v4float = OpTypePointer Input %v4float %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %3 %5 = OpLabel OpStore %_entryPointOutput %14 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(env)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Location-04915")); EXPECT_THAT(getDiagnosticString(), HasSubstr("A BuiltIn variable (id 2) cannot have any Location or " "Component decorations")); } TEST_F(ValidateDecorations, BuiltinVariablesWithComponentDecorationVulkan) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragCoord %_entryPointOutput OpExecutionMode %main OriginUpperLeft OpSource HLSL 500 OpDecorate %gl_FragCoord BuiltIn FragCoord OpDecorate %gl_FragCoord Component 0 OpDecorate %_entryPointOutput Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %float_0 = OpConstant %float 0 %14 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %_ptr_Input_v4float = OpTypePointer Input %v4float %gl_FragCoord = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %_entryPointOutput = OpVariable %_ptr_Output_v4float Output %main = OpFunction %void None %3 %5 = OpLabel OpStore %_entryPointOutput %14 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(env)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Location-04915")); EXPECT_THAT(getDiagnosticString(), HasSubstr("A BuiltIn variable (id 2) cannot have any Location or " "Component decorations")); } TEST_F(ValidateDecorations, LocationDecorationOnNumericTypeBad) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %fragCoord OpExecutionMode %main OriginUpperLeft OpDecorate %fragCoord Location 0 OpDecorate %v4float Location 1 %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %ptr_v4float = OpTypePointer Output %v4float %fragCoord = OpVariable %ptr_v4float Output %non_interface = OpVariable %ptr_v4float Output %main = OpFunction %void None %voidfn %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(env)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Location decoration on target '3[%v4float]' must " "be a variable")); } TEST_F(ValidateDecorations, LocationDecorationOnStructBad) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %fragCoord OpExecutionMode %main OriginUpperLeft OpDecorate %fragCoord Location 0 OpDecorate %struct Location 1 %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %struct = OpTypeStruct %float %v4float = OpTypeVector %float 4 %ptr_v4float = OpTypePointer Output %v4float %fragCoord = OpVariable %ptr_v4float Output %non_interface = OpVariable %ptr_v4float Output %main = OpFunction %void None %voidfn %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(env)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Location decoration on target '3[%_struct_3]' " "must be a variable")); } TEST_F(ValidateDecorations, LocationDecorationUnusedNonInterfaceVariableVulkan_Ignored) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %fragCoord OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpDecorate %fragCoord Location 0 OpDecorate %non_interface Location 1 %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %ptr_v4float = OpTypePointer Output %v4float %fragCoord = OpVariable %ptr_v4float Output %non_interface = OpVariable %ptr_v4float Output %main = OpFunction %void None %voidfn %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(env)); EXPECT_EQ(getDiagnosticString(), ""); } TEST_F(ValidateDecorations, LocationDecorationNonInterfaceStructVulkan_Ignored) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %fragCoord OpExecutionMode %main OriginUpperLeft OpDecorate %fragCoord Location 0 OpMemberDecorate %block 0 Location 2 OpMemberDecorate %block 0 Component 1 OpDecorate %block Block %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %vec3 = OpTypeVector %float 3 %outvar_ptr = OpTypePointer Output %vec3 %fragCoord = OpVariable %outvar_ptr Output %block = OpTypeStruct %vec3 %invar_ptr = OpTypePointer Input %block %non_interface = OpVariable %invar_ptr Input %main = OpFunction %void None %voidfn %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(env)); EXPECT_EQ(getDiagnosticString(), ""); } TEST_F(ValidateDecorations, LocationDecorationNonInterfaceStructVulkanGood) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %fragCoord %interface OpExecutionMode %main OriginUpperLeft OpDecorate %fragCoord Location 0 OpMemberDecorate %block 0 Location 2 OpMemberDecorate %block 0 Component 1 OpDecorate %block Block %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %vec3 = OpTypeVector %float 3 %outvar_ptr = OpTypePointer Output %vec3 %fragCoord = OpVariable %outvar_ptr Output %block = OpTypeStruct %vec3 %invar_ptr = OpTypePointer Input %block %interface = OpVariable %invar_ptr Input ;; this variable is unused. Ignore it %main = OpFunction %void None %voidfn %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(env)); } TEST_F(ValidateDecorations, LocationDecorationVariableNonStructVulkanBad) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %fragCoord %nonblock_var OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpDecorate %fragCoord Location 0 %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %ptr_v4float = OpTypePointer Output %v4float %fragCoord = OpVariable %ptr_v4float Output %nonblock_var = OpVariable %ptr_v4float Output %main = OpFunction %void None %voidfn %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateAndRetrieveValidationState(env)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Location-04916")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Variable must be decorated with a location")); } TEST_F(ValidateDecorations, LocationDecorationVariableStructNoBlockVulkanBad) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %fragCoord %block_var OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpDecorate %fragCoord Location 0 %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %ptr_v4float = OpTypePointer Output %v4float %fragCoord = OpVariable %ptr_v4float Output %block = OpTypeStruct %v4float %block_ptr = OpTypePointer Output %block %block_var = OpVariable %block_ptr Output %main = OpFunction %void None %voidfn %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateAndRetrieveValidationState(env)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Location-04917")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Variable must be decorated with a location")); } TEST_F(ValidateDecorations, LocationDecorationVariableNoBlockVulkanGood) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %fragCoord %block_var OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpDecorate %fragCoord Location 0 OpDecorate %block_var Location 1 %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %ptr_v4float = OpTypePointer Output %v4float %fragCoord = OpVariable %ptr_v4float Output %block = OpTypeStruct %v4float %block_ptr = OpTypePointer Output %block %block_var = OpVariable %block_ptr Output %main = OpFunction %void None %voidfn %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()); } TEST_F(ValidateDecorations, LocationDecorationVariableExtraMemeberVulkan) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %fragCoord %block_var OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpDecorate %fragCoord Location 0 OpDecorate %block Block OpDecorate %block_var Location 1 OpMemberDecorate %block 0 Location 1 %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %ptr_v4float = OpTypePointer Output %v4float %fragCoord = OpVariable %ptr_v4float Output %block = OpTypeStruct %v4float %block_ptr = OpTypePointer Output %block %block_var = OpVariable %block_ptr Output %main = OpFunction %void None %voidfn %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateAndRetrieveValidationState(env)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Location-04918")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Members cannot be assigned a location")); } TEST_F(ValidateDecorations, LocationDecorationVariableMissingMemeberVulkan) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %fragCoord %block_var OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpDecorate %fragCoord Location 0 OpDecorate %block Block OpMemberDecorate %block 0 Location 1 %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %ptr_v4float = OpTypePointer Output %v4float %fragCoord = OpVariable %ptr_v4float Output %block = OpTypeStruct %v4float %v4float %block_ptr = OpTypePointer Output %block %block_var = OpVariable %block_ptr Output %main = OpFunction %void None %voidfn %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateAndRetrieveValidationState(env)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Location-04919")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Member index 1 is missing a location assignment")); } TEST_F(ValidateDecorations, LocationDecorationVariableOnlyMemeberVulkanGood) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %fragCoord %block_var OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpDecorate %fragCoord Location 0 OpDecorate %block Block OpMemberDecorate %block 0 Location 1 OpMemberDecorate %block 1 Location 4 %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %ptr_v4float = OpTypePointer Output %v4float %fragCoord = OpVariable %ptr_v4float Output %block = OpTypeStruct %v4float %v4float %block_ptr = OpTypePointer Output %block %block_var = OpVariable %block_ptr Output %main = OpFunction %void None %voidfn %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()); } // #version 440 // #extension GL_EXT_nonuniform_qualifier : enable // layout(binding = 1) uniform sampler2D s2d[]; // layout(location = 0) in nonuniformEXT int i; // void main() // { // vec4 v = texture(s2d[i], vec2(0.3)); // } TEST_F(ValidateDecorations, RuntimeArrayOfDescriptorSetsIsAllowed) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = R"( OpCapability Shader OpCapability ShaderNonUniformEXT OpCapability RuntimeDescriptorArrayEXT OpCapability SampledImageArrayNonUniformIndexingEXT OpExtension "SPV_EXT_descriptor_indexing" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %i OpSource GLSL 440 OpSourceExtension "GL_EXT_nonuniform_qualifier" OpName %main "main" OpName %v "v" OpName %s2d "s2d" OpName %i "i" OpDecorate %s2d DescriptorSet 0 OpDecorate %s2d Binding 1 OpDecorate %i Location 0 OpDecorate %i NonUniformEXT OpDecorate %18 NonUniformEXT OpDecorate %21 NonUniformEXT %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %10 = OpTypeImage %float 2D 0 0 0 1 Unknown %11 = OpTypeSampledImage %10 %_runtimearr_11 = OpTypeRuntimeArray %11 %_ptr_Uniform__runtimearr_11 = OpTypePointer Uniform %_runtimearr_11 %s2d = OpVariable %_ptr_Uniform__runtimearr_11 Uniform %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %i = OpVariable %_ptr_Input_int Input %_ptr_Uniform_11 = OpTypePointer Uniform %11 %v2float = OpTypeVector %float 2 %float_0_300000012 = OpConstant %float 0.300000012 %24 = OpConstantComposite %v2float %float_0_300000012 %float_0_300000012 %float_0 = OpConstant %float 0 %main = OpFunction %void None %3 %5 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %18 = OpLoad %int %i %20 = OpAccessChain %_ptr_Uniform_11 %s2d %18 %21 = OpLoad %11 %20 %26 = OpImageSampleExplicitLod %v4float %21 %24 Lod %float_0 OpStore %v %26 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()); } TEST_F(ValidateDecorations, BlockDecoratingArrayBad) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 430 OpDecorate %Output Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %int = OpTypeInt 32 1 %int_3 = OpConstant %int 3 %Output = OpTypeArray %float %int_3 %_ptr_Uniform_Output = OpTypePointer Uniform %Output %dataOutput = OpVariable %_ptr_Uniform_Output Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be a structure type")); } TEST_F(ValidateDecorations, BlockDecoratingIntBad) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 430 OpDecorate %Output Block %void = OpTypeVoid %3 = OpTypeFunction %void %Output = OpTypeInt 32 1 %_ptr_Uniform_Output = OpTypePointer Uniform %Output %dataOutput = OpVariable %_ptr_Uniform_Output Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be a structure type")); } TEST_F(ValidateDecorations, BlockMissingOffsetBad) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 430 OpDecorate %Output Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %Output = OpTypeStruct %float %_ptr_Uniform_Output = OpTypePointer Uniform %Output %dataOutput = OpVariable %_ptr_Uniform_Output Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be explicitly laid out with Offset decorations")); } TEST_F(ValidateDecorations, BufferBlockMissingOffsetBad) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 430 OpDecorate %Output BufferBlock %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %Output = OpTypeStruct %float %_ptr_Uniform_Output = OpTypePointer Uniform %Output %dataOutput = OpVariable %_ptr_Uniform_Output Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be explicitly laid out with Offset decorations")); } TEST_F(ValidateDecorations, BlockNestedStructMissingOffsetBad) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 430 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %Output 0 Offset 0 OpMemberDecorate %Output 1 Offset 16 OpMemberDecorate %Output 2 Offset 32 OpDecorate %Output Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %v3float = OpTypeVector %float 3 %int = OpTypeInt 32 1 %S = OpTypeStruct %v3float %int %Output = OpTypeStruct %float %v4float %S %_ptr_Uniform_Output = OpTypePointer Uniform %Output %dataOutput = OpVariable %_ptr_Uniform_Output Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be explicitly laid out with Offset decorations")); } TEST_F(ValidateDecorations, BufferBlockNestedStructMissingOffsetBad) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 430 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %Output 0 Offset 0 OpMemberDecorate %Output 1 Offset 16 OpMemberDecorate %Output 2 Offset 32 OpDecorate %Output BufferBlock %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %v3float = OpTypeVector %float 3 %int = OpTypeInt 32 1 %S = OpTypeStruct %v3float %int %Output = OpTypeStruct %float %v4float %S %_ptr_Uniform_Output = OpTypePointer Uniform %Output %dataOutput = OpVariable %_ptr_Uniform_Output Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be explicitly laid out with Offset decorations")); } TEST_F(ValidateDecorations, BlockGLSLSharedBad) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 430 OpDecorate %Output Block OpDecorate %Output GLSLShared OpMemberDecorate %Output 0 Offset 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %Output = OpTypeStruct %float %_ptr_Uniform_Output = OpTypePointer Uniform %Output %dataOutput = OpVariable %_ptr_Uniform_Output Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "'GLSLShared' is not valid for the Vulkan execution environment")); EXPECT_THAT(getDiagnosticString(), HasSubstr("[VUID-StandaloneSpirv-GLSLShared-04669]")); } TEST_F(ValidateDecorations, BufferBlockGLSLSharedBad) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 430 OpDecorate %Output BufferBlock OpDecorate %Output GLSLShared OpMemberDecorate %Output 0 Offset 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %Output = OpTypeStruct %float %_ptr_Uniform_Output = OpTypePointer Uniform %Output %dataOutput = OpVariable %_ptr_Uniform_Output Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "'GLSLShared' is not valid for the Vulkan execution environment")); EXPECT_THAT(getDiagnosticString(), HasSubstr("[VUID-StandaloneSpirv-GLSLShared-04669]")); } TEST_F(ValidateDecorations, BlockNestedStructGLSLSharedBad) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 430 OpMemberDecorate %S 0 Offset 0 OpDecorate %S GLSLShared OpMemberDecorate %Output 0 Offset 0 OpMemberDecorate %Output 1 Offset 16 OpMemberDecorate %Output 2 Offset 32 OpDecorate %Output Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %int = OpTypeInt 32 1 %S = OpTypeStruct %int %Output = OpTypeStruct %float %v4float %S %_ptr_Uniform_Output = OpTypePointer Uniform %Output %dataOutput = OpVariable %_ptr_Uniform_Output Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "'GLSLShared' is not valid for the Vulkan execution environment")); EXPECT_THAT(getDiagnosticString(), HasSubstr("[VUID-StandaloneSpirv-GLSLShared-04669]")); } TEST_F(ValidateDecorations, BufferBlockNestedStructGLSLSharedBad) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 430 OpMemberDecorate %S 0 Offset 0 OpDecorate %S GLSLShared OpMemberDecorate %Output 0 Offset 0 OpMemberDecorate %Output 1 Offset 16 OpMemberDecorate %Output 2 Offset 32 OpDecorate %Output BufferBlock %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %int = OpTypeInt 32 1 %S = OpTypeStruct %int %Output = OpTypeStruct %float %v4float %S %_ptr_Uniform_Output = OpTypePointer Uniform %Output %dataOutput = OpVariable %_ptr_Uniform_Output Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "'GLSLShared' is not valid for the Vulkan execution environment")); EXPECT_THAT(getDiagnosticString(), HasSubstr("[VUID-StandaloneSpirv-GLSLShared-04669]")); } TEST_F(ValidateDecorations, BlockGLSLPackedBad) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 430 OpDecorate %Output Block OpDecorate %Output GLSLPacked OpMemberDecorate %Output 0 Offset 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %Output = OpTypeStruct %float %_ptr_Uniform_Output = OpTypePointer Uniform %Output %dataOutput = OpVariable %_ptr_Uniform_Output Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "'GLSLPacked' is not valid for the Vulkan execution environment")); EXPECT_THAT(getDiagnosticString(), HasSubstr("[VUID-StandaloneSpirv-GLSLShared-04669]")); } TEST_F(ValidateDecorations, BufferBlockGLSLPackedBad) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 430 OpDecorate %Output BufferBlock OpDecorate %Output GLSLPacked OpMemberDecorate %Output 0 Offset 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %Output = OpTypeStruct %float %_ptr_Uniform_Output = OpTypePointer Uniform %Output %dataOutput = OpVariable %_ptr_Uniform_Output Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "'GLSLPacked' is not valid for the Vulkan execution environment")); EXPECT_THAT(getDiagnosticString(), HasSubstr("[VUID-StandaloneSpirv-GLSLShared-04669]")); } TEST_F(ValidateDecorations, BlockNestedStructGLSLPackedBad) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 430 OpMemberDecorate %S 0 Offset 0 OpDecorate %S GLSLPacked OpMemberDecorate %Output 0 Offset 0 OpMemberDecorate %Output 1 Offset 16 OpMemberDecorate %Output 2 Offset 32 OpDecorate %Output Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %int = OpTypeInt 32 1 %S = OpTypeStruct %int %Output = OpTypeStruct %float %v4float %S %_ptr_Uniform_Output = OpTypePointer Uniform %Output %dataOutput = OpVariable %_ptr_Uniform_Output Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "'GLSLPacked' is not valid for the Vulkan execution environment")); EXPECT_THAT(getDiagnosticString(), HasSubstr("[VUID-StandaloneSpirv-GLSLShared-04669]")); } TEST_F(ValidateDecorations, BufferBlockNestedStructGLSLPackedBad) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 430 OpMemberDecorate %S 0 Offset 0 OpDecorate %S GLSLPacked OpMemberDecorate %Output 0 Offset 0 OpMemberDecorate %Output 1 Offset 16 OpMemberDecorate %Output 2 Offset 32 OpDecorate %Output BufferBlock %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %int = OpTypeInt 32 1 %S = OpTypeStruct %int %Output = OpTypeStruct %float %v4float %S %_ptr_Uniform_Output = OpTypePointer Uniform %Output %dataOutput = OpVariable %_ptr_Uniform_Output Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "'GLSLPacked' is not valid for the Vulkan execution environment")); EXPECT_THAT(getDiagnosticString(), HasSubstr("[VUID-StandaloneSpirv-GLSLShared-04669]")); } TEST_F(ValidateDecorations, BlockMissingArrayStrideBad) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 430 OpDecorate %Output Block OpMemberDecorate %Output 0 Offset 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %int = OpTypeInt 32 1 %int_3 = OpConstant %int 3 %array = OpTypeArray %float %int_3 %Output = OpTypeStruct %array %_ptr_Uniform_Output = OpTypePointer Uniform %Output %dataOutput = OpVariable %_ptr_Uniform_Output Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState()); EXPECT_THAT( getDiagnosticString(), HasSubstr("must be explicitly laid out with ArrayStride decorations")); } TEST_F(ValidateDecorations, BufferBlockMissingArrayStrideBad) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 430 OpDecorate %Output BufferBlock OpMemberDecorate %Output 0 Offset 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %int = OpTypeInt 32 1 %int_3 = OpConstant %int 3 %array = OpTypeArray %float %int_3 %Output = OpTypeStruct %array %_ptr_Uniform_Output = OpTypePointer Uniform %Output %dataOutput = OpVariable %_ptr_Uniform_Output Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState()); EXPECT_THAT( getDiagnosticString(), HasSubstr("must be explicitly laid out with ArrayStride decorations")); } TEST_F(ValidateDecorations, BlockNestedStructMissingArrayStrideBad) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 430 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %Output 0 Offset 0 OpMemberDecorate %Output 1 Offset 16 OpMemberDecorate %Output 2 Offset 32 OpDecorate %Output Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %int = OpTypeInt 32 1 %int_3 = OpConstant %int 3 %array = OpTypeArray %float %int_3 %S = OpTypeStruct %array %Output = OpTypeStruct %float %v4float %S %_ptr_Uniform_Output = OpTypePointer Uniform %Output %dataOutput = OpVariable %_ptr_Uniform_Output Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState()); EXPECT_THAT( getDiagnosticString(), HasSubstr("must be explicitly laid out with ArrayStride decorations")); } TEST_F(ValidateDecorations, BufferBlockNestedStructMissingArrayStrideBad) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 430 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %Output 0 Offset 0 OpMemberDecorate %Output 1 Offset 16 OpMemberDecorate %Output 2 Offset 32 OpDecorate %Output BufferBlock %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %int = OpTypeInt 32 1 %int_3 = OpConstant %int 3 %array = OpTypeArray %float %int_3 %S = OpTypeStruct %array %Output = OpTypeStruct %float %v4float %S %_ptr_Uniform_Output = OpTypePointer Uniform %Output %dataOutput = OpVariable %_ptr_Uniform_Output Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState()); EXPECT_THAT( getDiagnosticString(), HasSubstr("must be explicitly laid out with ArrayStride decorations")); } TEST_F(ValidateDecorations, BlockMissingMatrixStrideBad) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 430 OpDecorate %Output Block OpMemberDecorate %Output 0 Offset 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %matrix = OpTypeMatrix %v3float 4 %Output = OpTypeStruct %matrix %_ptr_Uniform_Output = OpTypePointer Uniform %Output %dataOutput = OpVariable %_ptr_Uniform_Output Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState()); EXPECT_THAT( getDiagnosticString(), HasSubstr("must be explicitly laid out with MatrixStride decorations")); } TEST_F(ValidateDecorations, BufferBlockMissingMatrixStrideBad) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 430 OpDecorate %Output BufferBlock OpMemberDecorate %Output 0 Offset 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %matrix = OpTypeMatrix %v3float 4 %Output = OpTypeStruct %matrix %_ptr_Uniform_Output = OpTypePointer Uniform %Output %dataOutput = OpVariable %_ptr_Uniform_Output Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState()); EXPECT_THAT( getDiagnosticString(), HasSubstr("must be explicitly laid out with MatrixStride decorations")); } TEST_F(ValidateDecorations, BlockMissingMatrixStrideArrayBad) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 430 OpDecorate %Output Block OpMemberDecorate %Output 0 Offset 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %matrix = OpTypeMatrix %v3float 4 %int = OpTypeInt 32 1 %int_3 = OpConstant %int 3 %array = OpTypeArray %matrix %int_3 %Output = OpTypeStruct %matrix %_ptr_Uniform_Output = OpTypePointer Uniform %Output %dataOutput = OpVariable %_ptr_Uniform_Output Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState()); EXPECT_THAT( getDiagnosticString(), HasSubstr("must be explicitly laid out with MatrixStride decorations")); } TEST_F(ValidateDecorations, BufferBlockMissingMatrixStrideArrayBad) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 430 OpDecorate %Output BufferBlock OpMemberDecorate %Output 0 Offset 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %matrix = OpTypeMatrix %v3float 4 %int = OpTypeInt 32 1 %int_3 = OpConstant %int 3 %array = OpTypeArray %matrix %int_3 %Output = OpTypeStruct %matrix %_ptr_Uniform_Output = OpTypePointer Uniform %Output %dataOutput = OpVariable %_ptr_Uniform_Output Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState()); EXPECT_THAT( getDiagnosticString(), HasSubstr("must be explicitly laid out with MatrixStride decorations")); } TEST_F(ValidateDecorations, BlockNestedStructMissingMatrixStrideBad) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 430 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %Output 0 Offset 0 OpMemberDecorate %Output 1 Offset 16 OpMemberDecorate %Output 2 Offset 32 OpDecorate %Output Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %v4float = OpTypeVector %float 4 %matrix = OpTypeMatrix %v3float 4 %S = OpTypeStruct %matrix %Output = OpTypeStruct %float %v4float %S %_ptr_Uniform_Output = OpTypePointer Uniform %Output %dataOutput = OpVariable %_ptr_Uniform_Output Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState()); EXPECT_THAT( getDiagnosticString(), HasSubstr("must be explicitly laid out with MatrixStride decorations")); } TEST_F(ValidateDecorations, BufferBlockNestedStructMissingMatrixStrideBad) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 430 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %Output 0 Offset 0 OpMemberDecorate %Output 1 Offset 16 OpMemberDecorate %Output 2 Offset 32 OpDecorate %Output BufferBlock %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %v4float = OpTypeVector %float 4 %matrix = OpTypeMatrix %v3float 4 %S = OpTypeStruct %matrix %Output = OpTypeStruct %float %v4float %S %_ptr_Uniform_Output = OpTypePointer Uniform %Output %dataOutput = OpVariable %_ptr_Uniform_Output Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState()); EXPECT_THAT( getDiagnosticString(), HasSubstr("must be explicitly laid out with MatrixStride decorations")); } TEST_F(ValidateDecorations, BlockStandardUniformBufferLayout) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 430 OpMemberDecorate %F 0 Offset 0 OpMemberDecorate %F 1 Offset 8 OpDecorate %_arr_float_uint_2 ArrayStride 16 OpDecorate %_arr_mat3v3float_uint_2 ArrayStride 48 OpMemberDecorate %O 0 Offset 0 OpMemberDecorate %O 1 Offset 16 OpMemberDecorate %O 2 Offset 32 OpMemberDecorate %O 3 Offset 64 OpMemberDecorate %O 4 ColMajor OpMemberDecorate %O 4 Offset 80 OpMemberDecorate %O 4 MatrixStride 16 OpDecorate %_arr_O_uint_2 ArrayStride 176 OpMemberDecorate %Output 0 Offset 0 OpMemberDecorate %Output 1 Offset 8 OpMemberDecorate %Output 2 Offset 16 OpMemberDecorate %Output 3 Offset 32 OpMemberDecorate %Output 4 Offset 48 OpMemberDecorate %Output 5 Offset 64 OpMemberDecorate %Output 6 ColMajor OpMemberDecorate %Output 6 Offset 96 OpMemberDecorate %Output 6 MatrixStride 16 OpMemberDecorate %Output 7 Offset 128 OpDecorate %Output Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %v3float = OpTypeVector %float 3 %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %F = OpTypeStruct %int %v2uint %uint_2 = OpConstant %uint 2 %_arr_float_uint_2 = OpTypeArray %float %uint_2 %mat2v3float = OpTypeMatrix %v3float 2 %v3uint = OpTypeVector %uint 3 %mat3v3float = OpTypeMatrix %v3float 3 %_arr_mat3v3float_uint_2 = OpTypeArray %mat3v3float %uint_2 %O = OpTypeStruct %v3uint %v2float %_arr_float_uint_2 %v2float %_arr_mat3v3float_uint_2 %_arr_O_uint_2 = OpTypeArray %O %uint_2 %Output = OpTypeStruct %float %v2float %v3float %F %float %_arr_float_uint_2 %mat2v3float %_arr_O_uint_2 %_ptr_Uniform_Output = OpTypePointer Uniform %Output %dataOutput = OpVariable %_ptr_Uniform_Output Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateDecorations, BlockLayoutPermitsTightVec3ScalarPackingGood) { // See https://github.com/KhronosGroup/SPIRV-Tools/issues/1666 std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %S 1 Offset 12 OpDecorate %S Block OpDecorate %B DescriptorSet 0 OpDecorate %B Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %S = OpTypeStruct %v3float %float %_ptr_Uniform_S = OpTypePointer Uniform %S %B = OpVariable %_ptr_Uniform_S Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)) << getDiagnosticString(); } TEST_F(ValidateDecorations, BlockCantAppearWithinABlockBad) { // See https://github.com/KhronosGroup/SPIRV-Tools/issues/1587 std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %S 1 Offset 16 OpMemberDecorate %S2 0 Offset 0 OpMemberDecorate %S2 1 Offset 12 OpDecorate %S Block OpDecorate %S2 Block OpDecorate %B DescriptorSet 0 OpDecorate %B Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %S2 = OpTypeStruct %float %float %S = OpTypeStruct %float %S2 %_ptr_Uniform_S = OpTypePointer Uniform %S %B = OpVariable %_ptr_Uniform_S Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState()); EXPECT_THAT(getDiagnosticString(), HasSubstr("rules: A Block or BufferBlock cannot be nested within " "another Block or BufferBlock.")); } TEST_F(ValidateDecorations, BufferblockCantAppearWithinABufferblockBad) { // See https://github.com/KhronosGroup/SPIRV-Tools/issues/1587 std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %S 1 Offset 16 OpMemberDecorate %S2 0 Offset 0 OpMemberDecorate %S2 1 Offset 16 OpMemberDecorate %S3 0 Offset 0 OpMemberDecorate %S3 1 Offset 12 OpDecorate %S BufferBlock OpDecorate %S3 BufferBlock OpDecorate %B DescriptorSet 0 OpDecorate %B Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %S3 = OpTypeStruct %float %float %S2 = OpTypeStruct %float %S3 %S = OpTypeStruct %float %S2 %_ptr_Uniform_S = OpTypePointer Uniform %S %B = OpVariable %_ptr_Uniform_S Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState()); EXPECT_THAT(getDiagnosticString(), HasSubstr("rules: A Block or BufferBlock cannot be nested within " "another Block or BufferBlock.")); } TEST_F(ValidateDecorations, BufferblockCantAppearWithinABlockBad) { // See https://github.com/KhronosGroup/SPIRV-Tools/issues/1587 std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %S 1 Offset 16 OpMemberDecorate %S2 0 Offset 0 OpMemberDecorate %S2 1 Offset 16 OpMemberDecorate %S3 0 Offset 0 OpMemberDecorate %S3 1 Offset 12 OpDecorate %S Block OpDecorate %S3 BufferBlock OpDecorate %B DescriptorSet 0 OpDecorate %B Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %S3 = OpTypeStruct %float %float %S2 = OpTypeStruct %float %S3 %S = OpTypeStruct %float %S2 %_ptr_Uniform_S = OpTypePointer Uniform %S %B = OpVariable %_ptr_Uniform_S Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState()); EXPECT_THAT(getDiagnosticString(), HasSubstr("rules: A Block or BufferBlock cannot be nested within " "another Block or BufferBlock.")); } TEST_F(ValidateDecorations, BlockCantAppearWithinABufferblockBad) { // See https://github.com/KhronosGroup/SPIRV-Tools/issues/1587 std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %S 1 Offset 16 OpMemberDecorate %S2 0 Offset 0 OpMemberDecorate %S2 1 Offset 16 OpMemberDecorate %S3 0 Offset 0 OpMemberDecorate %S3 1 Offset 16 OpMemberDecorate %S4 0 Offset 0 OpMemberDecorate %S4 1 Offset 12 OpDecorate %S BufferBlock OpDecorate %S4 Block OpDecorate %B DescriptorSet 0 OpDecorate %B Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %S4 = OpTypeStruct %float %float %S3 = OpTypeStruct %float %S4 %S2 = OpTypeStruct %float %S3 %S = OpTypeStruct %float %S2 %_ptr_Uniform_S = OpTypePointer Uniform %S %B = OpVariable %_ptr_Uniform_S Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState()); EXPECT_THAT(getDiagnosticString(), HasSubstr("rules: A Block or BufferBlock cannot be nested within " "another Block or BufferBlock.")); } TEST_F(ValidateDecorations, BlockCannotAppearWithinBlockArray) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpMemberDecorate %outer 0 Offset 0 OpMemberDecorate %outer 1 Offset 4 OpMemberDecorate %outer 2 Offset 20 OpDecorate %outer Block OpMemberDecorate %inner 0 Offset 0 OpDecorate %inner Block %void = OpTypeVoid %void_fn = OpTypeFunction %void %int = OpTypeInt 32 0 %int_4 = OpConstant %int 4 %inner = OpTypeStruct %int %array = OpTypeArray %inner %int_4 %outer = OpTypeStruct %int %array %int %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("rules: A Block or BufferBlock cannot be nested within " "another Block or BufferBlock.")); } TEST_F(ValidateDecorations, BlockCannotAppearWithinBlockMultiArray) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpMemberDecorate %outer 0 Offset 0 OpMemberDecorate %outer 1 Offset 4 OpDecorate %outer Block OpMemberDecorate %inner 0 Offset 0 OpDecorate %inner Block %void = OpTypeVoid %void_fn = OpTypeFunction %void %int = OpTypeInt 32 0 %int_4 = OpConstant %int 4 %inner = OpTypeStruct %int %array1 = OpTypeArray %inner %int_4 %array2 = OpTypeArray %array1 %int_4 %outer = OpTypeStruct %int %array2 %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("rules: A Block or BufferBlock cannot be nested within " "another Block or BufferBlock.")); } TEST_F(ValidateDecorations, BlockLayoutForbidsTightScalarVec3PackingBad) { // See https://github.com/KhronosGroup/SPIRV-Tools/issues/1666 std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %S 1 Offset 4 OpDecorate %S Block OpDecorate %B DescriptorSet 0 OpDecorate %B Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %S = OpTypeStruct %float %v3float %_ptr_Uniform_S = OpTypePointer Uniform %S %B = OpVariable %_ptr_Uniform_S Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Structure id 2 decorated as Block for variable in Uniform " "storage class must follow standard uniform buffer layout " "rules: member 1 at offset 4 is not aligned to 16")); } TEST_F(ValidateDecorations, BlockLayoutPermitsTightScalarVec3PackingWithRelaxedLayoutGood) { // Same as previous test, but with explicit option to relax block layout. std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %S 1 Offset 4 OpDecorate %S Block OpDecorate %B DescriptorSet 0 OpDecorate %B Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %S = OpTypeStruct %float %v3float %_ptr_Uniform_S = OpTypePointer Uniform %S %B = OpVariable %_ptr_Uniform_S Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); spvValidatorOptionsSetRelaxBlockLayout(getValidatorOptions(), true); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, BlockLayoutPermitsTightScalarVec3PackingBadOffsetWithRelaxedLayoutBad) { // Same as previous test, but with the vector not aligned to its scalar // element. Use offset 5 instead of a multiple of 4. std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %S 1 Offset 5 OpDecorate %S Block OpDecorate %B DescriptorSet 0 OpDecorate %B Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %S = OpTypeStruct %float %v3float %_ptr_Uniform_S = OpTypePointer Uniform %S %B = OpVariable %_ptr_Uniform_S Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); spvValidatorOptionsSetRelaxBlockLayout(getValidatorOptions(), true); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Structure id 2 decorated as Block for variable in Uniform storage " "class must follow relaxed uniform buffer layout rules: member 1 at " "offset 5 is not aligned to scalar element size 4")); } TEST_F(ValidateDecorations, BlockLayoutPermitsTightScalarVec3PackingWithVulkan1_1Good) { // Same as previous test, but with Vulkan 1.1. Vulkan 1.1 included // VK_KHR_relaxed_block_layout in core. std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %S 1 Offset 4 OpDecorate %S Block OpDecorate %B DescriptorSet 0 OpDecorate %B Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %S = OpTypeStruct %float %v3float %_ptr_Uniform_S = OpTypePointer Uniform %S %B = OpVariable %_ptr_Uniform_S Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, BlockLayoutPermitsTightScalarVec3PackingWithScalarLayoutGood) { // Same as previous test, but with scalar block layout. std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %S 1 Offset 4 OpDecorate %S Block OpDecorate %B DescriptorSet 0 OpDecorate %B Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %S = OpTypeStruct %float %v3float %_ptr_Uniform_S = OpTypePointer Uniform %S %B = OpVariable %_ptr_Uniform_S Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); spvValidatorOptionsSetScalarBlockLayout(getValidatorOptions(), true); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, BlockLayoutPermitsScalarAlignedArrayWithScalarLayoutGood) { // The array at offset 4 is ok with scalar block layout. std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %S 1 Offset 4 OpDecorate %S Block OpDecorate %B DescriptorSet 0 OpDecorate %B Binding 0 OpDecorate %arr_float ArrayStride 4 %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_3 = OpConstant %uint 3 %float = OpTypeFloat 32 %arr_float = OpTypeArray %float %uint_3 %S = OpTypeStruct %float %arr_float %_ptr_Uniform_S = OpTypePointer Uniform %S %B = OpVariable %_ptr_Uniform_S Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); spvValidatorOptionsSetScalarBlockLayout(getValidatorOptions(), true); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, BlockLayoutPermitsScalarAlignedArrayOfVec3WithScalarLayoutGood) { // The array at offset 4 is ok with scalar block layout, even though // its elements are vec3. // This is the same as the previous case, but the array elements are vec3 // instead of float. std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %S 1 Offset 4 OpDecorate %S Block OpDecorate %B DescriptorSet 0 OpDecorate %B Binding 0 OpDecorate %arr_vec3 ArrayStride 12 %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_3 = OpConstant %uint 3 %float = OpTypeFloat 32 %vec3 = OpTypeVector %float 3 %arr_vec3 = OpTypeArray %vec3 %uint_3 %S = OpTypeStruct %float %arr_vec3 %_ptr_Uniform_S = OpTypePointer Uniform %S %B = OpVariable %_ptr_Uniform_S Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); spvValidatorOptionsSetScalarBlockLayout(getValidatorOptions(), true); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, BlockLayoutPermitsScalarAlignedStructWithScalarLayoutGood) { // Scalar block layout permits the struct at offset 4, even though // it contains a vector with base alignment 8 and scalar alignment 4. std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %S 1 Offset 4 OpMemberDecorate %st 0 Offset 0 OpMemberDecorate %st 1 Offset 8 OpDecorate %S Block OpDecorate %B DescriptorSet 0 OpDecorate %B Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %vec2 = OpTypeVector %float 2 %st = OpTypeStruct %vec2 %float %S = OpTypeStruct %float %st %_ptr_Uniform_S = OpTypePointer Uniform %S %B = OpVariable %_ptr_Uniform_S Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); spvValidatorOptionsSetScalarBlockLayout(getValidatorOptions(), true); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F( ValidateDecorations, BlockLayoutPermitsFieldsInBaseAlignmentPaddingAtEndOfStructWithScalarLayoutGood) { // Scalar block layout permits fields in what would normally be the padding at // the end of a struct. std::string spirv = R"( OpCapability Shader OpCapability Float64 OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpMemberDecorate %st 0 Offset 0 OpMemberDecorate %st 1 Offset 8 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %S 1 Offset 12 OpDecorate %S Block OpDecorate %B DescriptorSet 0 OpDecorate %B Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %double = OpTypeFloat 64 %st = OpTypeStruct %double %float %S = OpTypeStruct %st %float %_ptr_Uniform_S = OpTypePointer Uniform %S %B = OpVariable %_ptr_Uniform_S Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); spvValidatorOptionsSetScalarBlockLayout(getValidatorOptions(), true); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F( ValidateDecorations, BlockLayoutPermitsStraddlingVectorWithScalarLayoutOverrideRelaxBlockLayoutGood) { // Same as previous, but set relaxed block layout first. Scalar layout always // wins. std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %S 1 Offset 4 OpDecorate %S Block OpDecorate %B DescriptorSet 0 OpDecorate %B Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %vec4 = OpTypeVector %float 4 %S = OpTypeStruct %float %vec4 %_ptr_Uniform_S = OpTypePointer Uniform %S %B = OpVariable %_ptr_Uniform_S Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); spvValidatorOptionsSetRelaxBlockLayout(getValidatorOptions(), true); spvValidatorOptionsSetScalarBlockLayout(getValidatorOptions(), true); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F( ValidateDecorations, BlockLayoutPermitsStraddlingVectorWithRelaxedLayoutOverridenByScalarBlockLayoutGood) { // Same as previous, but set scalar block layout first. Scalar layout always // wins. std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %S 1 Offset 4 OpDecorate %S Block OpDecorate %B DescriptorSet 0 OpDecorate %B Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %vec4 = OpTypeVector %float 4 %S = OpTypeStruct %float %vec4 %_ptr_Uniform_S = OpTypePointer Uniform %S %B = OpVariable %_ptr_Uniform_S Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); spvValidatorOptionsSetScalarBlockLayout(getValidatorOptions(), true); spvValidatorOptionsSetRelaxBlockLayout(getValidatorOptions(), true); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, BufferBlock16bitStandardStorageBufferLayout) { std::string spirv = R"( OpCapability Shader OpCapability StorageUniform16 OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %f32arr ArrayStride 4 OpDecorate %f16arr ArrayStride 2 OpMemberDecorate %SSBO32 0 Offset 0 OpMemberDecorate %SSBO16 0 Offset 0 OpDecorate %SSBO32 BufferBlock OpDecorate %SSBO16 BufferBlock %void = OpTypeVoid %voidf = OpTypeFunction %void %u32 = OpTypeInt 32 0 %i32 = OpTypeInt 32 1 %f32 = OpTypeFloat 32 %uvec3 = OpTypeVector %u32 3 %c_i32_32 = OpConstant %i32 32 %c_i32_128 = OpConstant %i32 128 %f32arr = OpTypeArray %f32 %c_i32_128 %f16 = OpTypeFloat 16 %f16arr = OpTypeArray %f16 %c_i32_128 %SSBO32 = OpTypeStruct %f32arr %SSBO16 = OpTypeStruct %f16arr %_ptr_Uniform_SSBO32 = OpTypePointer Uniform %SSBO32 %varSSBO32 = OpVariable %_ptr_Uniform_SSBO32 Uniform %_ptr_Uniform_SSBO16 = OpTypePointer Uniform %SSBO16 %varSSBO16 = OpVariable %_ptr_Uniform_SSBO16 Uniform %main = OpFunction %void None %voidf %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateDecorations, BlockArrayExtendedAlignmentGood) { // For uniform buffer, Array base alignment is 16, and ArrayStride // must be a multiple of 16. std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpDecorate %_arr_float_uint_2 ArrayStride 16 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %S 1 Offset 16 OpDecorate %S Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_arr_float_uint_2 = OpTypeArray %float %uint_2 %S = OpTypeStruct %v2float %_arr_float_uint_2 %_ptr_PushConstant_S = OpTypePointer PushConstant %S %u = OpVariable %_ptr_PushConstant_S PushConstant %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()) << getDiagnosticString(); } TEST_F(ValidateDecorations, BlockArrayBaseAlignmentBad) { // For uniform buffer, Array base alignment is 16. std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpDecorate %_arr_float_uint_2 ArrayStride 16 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %S 1 Offset 8 OpDecorate %S Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_arr_float_uint_2 = OpTypeArray %float %uint_2 %S = OpTypeStruct %v2float %_arr_float_uint_2 %_ptr_Uniform_S = OpTypePointer Uniform %S %u = OpVariable %_ptr_Uniform_S Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Structure id 3 decorated as Block for variable in Uniform " "storage class must follow standard uniform buffer layout rules: " "member 1 at offset 8 is not aligned to 16")); } TEST_F(ValidateDecorations, BlockArrayBaseAlignmentWithRelaxedLayoutStillBad) { // For uniform buffer, Array base alignment is 16, and ArrayStride // must be a multiple of 16. This case uses relaxed block layout. Relaxed // layout only relaxes rules for vector alignment, not array alignment. std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpDecorate %_arr_float_uint_2 ArrayStride 16 OpDecorate %u DescriptorSet 0 OpDecorate %u Binding 0 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %S 1 Offset 8 OpDecorate %S Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_arr_float_uint_2 = OpTypeArray %float %uint_2 %S = OpTypeStruct %v2float %_arr_float_uint_2 %_ptr_Uniform_S = OpTypePointer Uniform %S %u = OpVariable %_ptr_Uniform_S Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); spvValidatorOptionsSetRelaxBlockLayout(getValidatorOptions(), true); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Structure id 4 decorated as Block for variable in Uniform " "storage class must follow standard uniform buffer layout rules: " "member 1 at offset 8 is not aligned to 16")); } TEST_F(ValidateDecorations, BlockArrayBaseAlignmentWithVulkan1_1StillBad) { // Same as previous test, but with Vulkan 1.1, which includes // VK_KHR_relaxed_block_layout in core. std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpDecorate %_arr_float_uint_2 ArrayStride 16 OpDecorate %u DescriptorSet 0 OpDecorate %u Binding 0 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %S 1 Offset 8 OpDecorate %S Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_arr_float_uint_2 = OpTypeArray %float %uint_2 %S = OpTypeStruct %v2float %_arr_float_uint_2 %_ptr_Uniform_S = OpTypePointer Uniform %S %u = OpVariable %_ptr_Uniform_S Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_1)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Structure id 4 decorated as Block for variable in Uniform " "storage class must follow relaxed uniform buffer layout rules: " "member 1 at offset 8 is not aligned to 16")); } TEST_F(ValidateDecorations, BlockArrayBaseAlignmentWithBlockStandardLayoutGood) { // Same as previous test, but with VK_KHR_uniform_buffer_standard_layout std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpDecorate %_arr_float_uint_2 ArrayStride 16 OpDecorate %u DescriptorSet 0 OpDecorate %u Binding 0 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %S 1 Offset 8 OpDecorate %S Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_arr_float_uint_2 = OpTypeArray %float %uint_2 %S = OpTypeStruct %v2float %_arr_float_uint_2 %_ptr_Uniform_S = OpTypePointer Uniform %S %u = OpVariable %_ptr_Uniform_S Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); spvValidatorOptionsSetUniformBufferStandardLayout(getValidatorOptions(), true); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, VulkanBufferBlockOnStorageBufferBad) { std::string spirv = R"( OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpDecorate %struct BufferBlock %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %struct = OpTypeStruct %float %ptr = OpTypePointer StorageBuffer %struct %var = OpVariable %ptr StorageBuffer %1 = OpFunction %void None %voidfn %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-PushConstant-06675")); EXPECT_THAT(getDiagnosticString(), HasSubstr("In Vulkan, BufferBlock is disallowed on variables in " "the StorageBuffer storage class")); } TEST_F(ValidateDecorations, PushConstantArrayBaseAlignmentGood) { // Tests https://github.com/KhronosGroup/SPIRV-Tools/issues/1664 // From GLSL vertex shader: // #version 450 // layout(push_constant) uniform S { vec2 v; float arr[2]; } u; // void main() { } std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpDecorate %_arr_float_uint_2 ArrayStride 4 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %S 1 Offset 8 OpDecorate %S Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_arr_float_uint_2 = OpTypeArray %float %uint_2 %S = OpTypeStruct %v2float %_arr_float_uint_2 %_ptr_PushConstant_S = OpTypePointer PushConstant %S %u = OpVariable %_ptr_PushConstant_S PushConstant %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)) << getDiagnosticString(); } TEST_F(ValidateDecorations, PushConstantArrayBadAlignmentBad) { // Like the previous test, but with offset 7 instead of 8. std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpDecorate %_arr_float_uint_2 ArrayStride 4 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %S 1 Offset 7 OpDecorate %S Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_arr_float_uint_2 = OpTypeArray %float %uint_2 %S = OpTypeStruct %v2float %_arr_float_uint_2 %_ptr_PushConstant_S = OpTypePointer PushConstant %S %u = OpVariable %_ptr_PushConstant_S PushConstant %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Structure id 3 decorated as Block for variable in PushConstant " "storage class must follow standard storage buffer layout rules: " "member 1 at offset 7 is not aligned to 4")); } TEST_F(ValidateDecorations, PushConstantLayoutPermitsTightVec3ScalarPackingGood) { // See https://github.com/KhronosGroup/SPIRV-Tools/issues/1666 std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %S 1 Offset 12 OpDecorate %S Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %S = OpTypeStruct %v3float %float %_ptr_PushConstant_S = OpTypePointer PushConstant %S %B = OpVariable %_ptr_PushConstant_S PushConstant %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)) << getDiagnosticString(); } TEST_F(ValidateDecorations, PushConstantLayoutForbidsTightScalarVec3PackingBad) { // See https://github.com/KhronosGroup/SPIRV-Tools/issues/1666 std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %S 1 Offset 4 OpDecorate %S Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %S = OpTypeStruct %float %v3float %_ptr_Uniform_S = OpTypePointer PushConstant %S %B = OpVariable %_ptr_Uniform_S PushConstant %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Structure id 2 decorated as Block for variable in PushConstant " "storage class must follow standard storage buffer layout " "rules: member 1 at offset 4 is not aligned to 16")); } TEST_F(ValidateDecorations, PushConstantMissingBlockGood) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %struct = OpTypeStruct %float %ptr = OpTypePointer PushConstant %struct %pc = OpVariable %ptr PushConstant %1 = OpFunction %void None %voidfn %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()) << getDiagnosticString(); } TEST_F(ValidateDecorations, VulkanPushConstantMissingBlockBad) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %struct = OpTypeStruct %float %ptr = OpTypePointer PushConstant %struct %pc = OpVariable %ptr PushConstant %1 = OpFunction %void None %voidfn %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-PushConstant-06675")); EXPECT_THAT(getDiagnosticString(), HasSubstr("PushConstant id '2' is missing Block decoration.\n" "From Vulkan spec:\n" "Such variables must be identified with a Block " "decoration")); } TEST_F(ValidateDecorations, MultiplePushConstantsSingleEntryPointGood) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %struct = OpTypeStruct %float %ptr = OpTypePointer PushConstant %struct %ptr_float = OpTypePointer PushConstant %float %pc1 = OpVariable %ptr PushConstant %pc2 = OpVariable %ptr PushConstant %1 = OpFunction %void None %voidfn %label = OpLabel %2 = OpAccessChain %ptr_float %pc1 %int_0 %3 = OpLoad %float %2 %4 = OpAccessChain %ptr_float %pc2 %int_0 %5 = OpLoad %float %4 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()) << getDiagnosticString(); } TEST_F(ValidateDecorations, VulkanMultiplePushConstantsDifferentEntryPointGood) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "func1" OpEntryPoint Fragment %2 "func2" OpExecutionMode %2 OriginUpperLeft OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %struct = OpTypeStruct %float %ptr = OpTypePointer PushConstant %struct %ptr_float = OpTypePointer PushConstant %float %pc1 = OpVariable %ptr PushConstant %pc2 = OpVariable %ptr PushConstant %1 = OpFunction %void None %voidfn %label1 = OpLabel %3 = OpAccessChain %ptr_float %pc1 %int_0 %4 = OpLoad %float %3 OpReturn OpFunctionEnd %2 = OpFunction %void None %voidfn %label2 = OpLabel %5 = OpAccessChain %ptr_float %pc2 %int_0 %6 = OpLoad %float %5 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_1)) << getDiagnosticString(); } TEST_F(ValidateDecorations, VulkanMultiplePushConstantsUnusedSingleEntryPointGood) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %struct = OpTypeStruct %float %ptr = OpTypePointer PushConstant %struct %ptr_float = OpTypePointer PushConstant %float %pc1 = OpVariable %ptr PushConstant %pc2 = OpVariable %ptr PushConstant %1 = OpFunction %void None %voidfn %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_1)) << getDiagnosticString(); } TEST_F(ValidateDecorations, VulkanMultiplePushConstantsSingleEntryPointBad) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %struct = OpTypeStruct %float %ptr = OpTypePointer PushConstant %struct %ptr_float = OpTypePointer PushConstant %float %pc1 = OpVariable %ptr PushConstant %pc2 = OpVariable %ptr PushConstant %1 = OpFunction %void None %voidfn %label = OpLabel %2 = OpAccessChain %ptr_float %pc1 %int_0 %3 = OpLoad %float %2 %4 = OpAccessChain %ptr_float %pc2 %int_0 %5 = OpLoad %float %4 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpEntryPoint-06674")); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Entry point id '1' uses more than one PushConstant interface.\n" "From Vulkan spec:\n" "There must be no more than one push constant block " "statically used per shader entry point.")); } TEST_F(ValidateDecorations, VulkanMultiplePushConstantsDifferentEntryPointSubFunctionGood) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "func1" OpEntryPoint Fragment %2 "func2" OpExecutionMode %2 OriginUpperLeft OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %struct = OpTypeStruct %float %ptr = OpTypePointer PushConstant %struct %ptr_float = OpTypePointer PushConstant %float %pc1 = OpVariable %ptr PushConstant %pc2 = OpVariable %ptr PushConstant %sub1 = OpFunction %void None %voidfn %label_sub1 = OpLabel %3 = OpAccessChain %ptr_float %pc1 %int_0 %4 = OpLoad %float %3 OpReturn OpFunctionEnd %sub2 = OpFunction %void None %voidfn %label_sub2 = OpLabel %5 = OpAccessChain %ptr_float %pc2 %int_0 %6 = OpLoad %float %5 OpReturn OpFunctionEnd %1 = OpFunction %void None %voidfn %label1 = OpLabel %call1 = OpFunctionCall %void %sub1 OpReturn OpFunctionEnd %2 = OpFunction %void None %voidfn %label2 = OpLabel %call2 = OpFunctionCall %void %sub2 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_1)) << getDiagnosticString(); } TEST_F(ValidateDecorations, VulkanMultiplePushConstantsSingleEntryPointSubFunctionBad) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %struct = OpTypeStruct %float %ptr = OpTypePointer PushConstant %struct %ptr_float = OpTypePointer PushConstant %float %pc1 = OpVariable %ptr PushConstant %pc2 = OpVariable %ptr PushConstant %sub1 = OpFunction %void None %voidfn %label_sub1 = OpLabel %3 = OpAccessChain %ptr_float %pc1 %int_0 %4 = OpLoad %float %3 OpReturn OpFunctionEnd %sub2 = OpFunction %void None %voidfn %label_sub2 = OpLabel %5 = OpAccessChain %ptr_float %pc2 %int_0 %6 = OpLoad %float %5 OpReturn OpFunctionEnd %1 = OpFunction %void None %voidfn %label1 = OpLabel %call1 = OpFunctionCall %void %sub1 %call2 = OpFunctionCall %void %sub2 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpEntryPoint-06674")); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Entry point id '1' uses more than one PushConstant interface.\n" "From Vulkan spec:\n" "There must be no more than one push constant block " "statically used per shader entry point.")); } TEST_F(ValidateDecorations, VulkanMultiplePushConstantsSingleEntryPointInterfaceBad) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %func1 "func1" %pc1 %pc2 OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %struct = OpTypeStruct %float %ptr = OpTypePointer PushConstant %struct %ptr_float = OpTypePointer PushConstant %float %pc1 = OpVariable %ptr PushConstant %pc2 = OpVariable %ptr PushConstant %func1 = OpFunction %void None %voidfn %label1 = OpLabel %access1 = OpAccessChain %ptr_float %pc1 %int_0 %load1 = OpLoad %float %access1 OpReturn OpFunctionEnd %func2 = OpFunction %void None %voidfn %label2 = OpLabel %access2 = OpAccessChain %ptr_float %pc2 %int_0 %load2 = OpLoad %float %access2 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpVariable-06673")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Entry-point has more than one variable with the " "PushConstant storage class in the interface")); } TEST_F(ValidateDecorations, VulkanUniformMissingDescriptorSetBad) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 OpDecorate %var Binding 0 %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %struct = OpTypeStruct %float %ptr = OpTypePointer Uniform %struct %ptr_float = OpTypePointer Uniform %float %var = OpVariable %ptr Uniform %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %1 = OpFunction %void None %voidfn %label = OpLabel %2 = OpAccessChain %ptr_float %var %int_0 %3 = OpLoad %float %2 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-UniformConstant-06677")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Uniform id '3' is missing DescriptorSet decoration.\n" "From Vulkan spec:\n" "These variables must have DescriptorSet and Binding " "decorations specified")); } TEST_F(ValidateDecorations, VulkanUniformMissingBindingBad) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 OpDecorate %var DescriptorSet 0 %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %struct = OpTypeStruct %float %ptr = OpTypePointer Uniform %struct %ptr_float = OpTypePointer Uniform %float %var = OpVariable %ptr Uniform %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %1 = OpFunction %void None %voidfn %label = OpLabel %2 = OpAccessChain %ptr_float %var %int_0 %3 = OpLoad %float %2 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-UniformConstant-06677")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Uniform id '3' is missing Binding decoration.\n" "From Vulkan spec:\n" "These variables must have DescriptorSet and Binding " "decorations specified")); } TEST_F(ValidateDecorations, VulkanUniformConstantMissingDescriptorSetBad) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpDecorate %var Binding 0 %void = OpTypeVoid %voidfn = OpTypeFunction %void %sampler = OpTypeSampler %ptr = OpTypePointer UniformConstant %sampler %var = OpVariable %ptr UniformConstant %1 = OpFunction %void None %voidfn %label = OpLabel %2 = OpLoad %sampler %var OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-UniformConstant-06677")); EXPECT_THAT( getDiagnosticString(), HasSubstr("UniformConstant id '2' is missing DescriptorSet decoration.\n" "From Vulkan spec:\n" "These variables must have DescriptorSet and Binding " "decorations specified")); } TEST_F(ValidateDecorations, VulkanUniformConstantMissingBindingBad) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpDecorate %var DescriptorSet 0 %void = OpTypeVoid %voidfn = OpTypeFunction %void %sampler = OpTypeSampler %ptr = OpTypePointer UniformConstant %sampler %var = OpVariable %ptr UniformConstant %1 = OpFunction %void None %voidfn %label = OpLabel %2 = OpLoad %sampler %var OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-UniformConstant-06677")); EXPECT_THAT( getDiagnosticString(), HasSubstr("UniformConstant id '2' is missing Binding decoration.\n" "From Vulkan spec:\n" "These variables must have DescriptorSet and Binding " "decorations specified")); } TEST_F(ValidateDecorations, VulkanStorageBufferMissingDescriptorSetBad) { std::string spirv = R"( OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpDecorate %struct Block OpDecorate %var Binding 0 %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %struct = OpTypeStruct %float %ptr = OpTypePointer StorageBuffer %struct %var = OpVariable %ptr StorageBuffer %ptr_float = OpTypePointer StorageBuffer %float %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %1 = OpFunction %void None %voidfn %label = OpLabel %2 = OpAccessChain %ptr_float %var %int_0 %3 = OpLoad %float %2 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-UniformConstant-06677")); EXPECT_THAT( getDiagnosticString(), HasSubstr("StorageBuffer id '3' is missing DescriptorSet decoration.\n" "From Vulkan spec:\n" "These variables must have DescriptorSet and Binding " "decorations specified")); } TEST_F(ValidateDecorations, VulkanStorageBufferMissingBindingBad) { std::string spirv = R"( OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpDecorate %struct Block OpDecorate %var DescriptorSet 0 %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %struct = OpTypeStruct %float %ptr = OpTypePointer StorageBuffer %struct %var = OpVariable %ptr StorageBuffer %ptr_float = OpTypePointer StorageBuffer %float %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %1 = OpFunction %void None %voidfn %label = OpLabel %2 = OpAccessChain %ptr_float %var %int_0 %3 = OpLoad %float %2 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-UniformConstant-06677")); EXPECT_THAT(getDiagnosticString(), HasSubstr("StorageBuffer id '3' is missing Binding decoration.\n" "From Vulkan spec:\n" "These variables must have DescriptorSet and Binding " "decorations specified")); } TEST_F(ValidateDecorations, VulkanStorageBufferMissingDescriptorSetSubFunctionBad) { std::string spirv = R"( OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpDecorate %struct Block OpDecorate %var Binding 0 %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %struct = OpTypeStruct %float %ptr = OpTypePointer StorageBuffer %struct %var = OpVariable %ptr StorageBuffer %ptr_float = OpTypePointer StorageBuffer %float %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %1 = OpFunction %void None %voidfn %label = OpLabel %call = OpFunctionCall %void %2 OpReturn OpFunctionEnd %2 = OpFunction %void None %voidfn %label2 = OpLabel %3 = OpAccessChain %ptr_float %var %int_0 %4 = OpLoad %float %3 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-UniformConstant-06677")); EXPECT_THAT( getDiagnosticString(), HasSubstr("StorageBuffer id '3' is missing DescriptorSet decoration.\n" "From Vulkan spec:\n" "These variables must have DescriptorSet and Binding " "decorations specified")); } TEST_F(ValidateDecorations, VulkanStorageBufferMissingDescriptorAndBindingUnusedGood) { std::string spirv = R"( OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %struct = OpTypeStruct %float %ptr = OpTypePointer StorageBuffer %struct %var = OpVariable %ptr StorageBuffer %1 = OpFunction %void None %voidfn %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_1)); } TEST_F(ValidateDecorations, UniformMissingDescriptorSetGood) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 OpDecorate %var Binding 0 %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %struct = OpTypeStruct %float %ptr = OpTypePointer Uniform %struct %var = OpVariable %ptr Uniform %1 = OpFunction %void None %voidfn %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()) << getDiagnosticString(); } TEST_F(ValidateDecorations, UniformMissingBindingGood) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 OpDecorate %var DescriptorSet 0 %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %struct = OpTypeStruct %float %ptr = OpTypePointer Uniform %struct %var = OpVariable %ptr Uniform %1 = OpFunction %void None %voidfn %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()) << getDiagnosticString(); } TEST_F(ValidateDecorations, UniformConstantMissingDescriptorSetGood) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpDecorate %var Binding 0 %void = OpTypeVoid %voidfn = OpTypeFunction %void %sampler = OpTypeSampler %ptr = OpTypePointer UniformConstant %sampler %var = OpVariable %ptr UniformConstant %1 = OpFunction %void None %voidfn %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()) << getDiagnosticString(); } TEST_F(ValidateDecorations, UniformConstantMissingBindingGood) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpDecorate %var DescriptorSet 0 %void = OpTypeVoid %voidfn = OpTypeFunction %void %sampler = OpTypeSampler %ptr = OpTypePointer UniformConstant %sampler %var = OpVariable %ptr UniformConstant %1 = OpFunction %void None %voidfn %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()) << getDiagnosticString(); } TEST_F(ValidateDecorations, StorageBufferMissingDescriptorSetGood) { std::string spirv = R"( OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpDecorate %struct BufferBlock OpDecorate %var Binding 0 %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %struct = OpTypeStruct %float %ptr = OpTypePointer StorageBuffer %struct %var = OpVariable %ptr StorageBuffer %1 = OpFunction %void None %voidfn %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()) << getDiagnosticString(); } TEST_F(ValidateDecorations, StorageBufferMissingBindingGood) { std::string spirv = R"( OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpDecorate %struct BufferBlock OpDecorate %var DescriptorSet 0 %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %struct = OpTypeStruct %float %ptr = OpTypePointer StorageBuffer %struct %var = OpVariable %ptr StorageBuffer %1 = OpFunction %void None %voidfn %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()) << getDiagnosticString(); } TEST_F(ValidateDecorations, StorageBufferStorageClassArrayBaseAlignmentGood) { // Spot check buffer rules when using StorageBuffer storage class with Block // decoration. std::string spirv = R"( OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpDecorate %_arr_float_uint_2 ArrayStride 4 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %S 1 Offset 8 OpDecorate %S Block OpDecorate %u DescriptorSet 0 OpDecorate %u Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_arr_float_uint_2 = OpTypeArray %float %uint_2 %S = OpTypeStruct %v2float %_arr_float_uint_2 %_ptr_Uniform_S = OpTypePointer StorageBuffer %S %u = OpVariable %_ptr_Uniform_S StorageBuffer %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)) << getDiagnosticString(); } TEST_F(ValidateDecorations, StorageBufferStorageClassArrayBadAlignmentBad) { // Like the previous test, but with offset 7. std::string spirv = R"( OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpDecorate %_arr_float_uint_2 ArrayStride 4 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %S 1 Offset 7 OpDecorate %S Block OpDecorate %u DescriptorSet 0 OpDecorate %u Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_arr_float_uint_2 = OpTypeArray %float %uint_2 %S = OpTypeStruct %v2float %_arr_float_uint_2 %_ptr_Uniform_S = OpTypePointer StorageBuffer %S %u = OpVariable %_ptr_Uniform_S StorageBuffer %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Structure id 3 decorated as Block for variable in StorageBuffer " "storage class must follow standard storage buffer layout rules: " "member 1 at offset 7 is not aligned to 4")); } TEST_F(ValidateDecorations, BufferBlockStandardStorageBufferLayout) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 430 OpMemberDecorate %F 0 Offset 0 OpMemberDecorate %F 1 Offset 8 OpDecorate %_arr_float_uint_2 ArrayStride 4 OpDecorate %_arr_mat3v3float_uint_2 ArrayStride 48 OpMemberDecorate %O 0 Offset 0 OpMemberDecorate %O 1 Offset 16 OpMemberDecorate %O 2 Offset 24 OpMemberDecorate %O 3 Offset 32 OpMemberDecorate %O 4 ColMajor OpMemberDecorate %O 4 Offset 48 OpMemberDecorate %O 4 MatrixStride 16 OpDecorate %_arr_O_uint_2 ArrayStride 144 OpMemberDecorate %Output 0 Offset 0 OpMemberDecorate %Output 1 Offset 8 OpMemberDecorate %Output 2 Offset 16 OpMemberDecorate %Output 3 Offset 32 OpMemberDecorate %Output 4 Offset 48 OpMemberDecorate %Output 5 Offset 52 OpMemberDecorate %Output 6 ColMajor OpMemberDecorate %Output 6 Offset 64 OpMemberDecorate %Output 6 MatrixStride 16 OpMemberDecorate %Output 7 Offset 96 OpDecorate %Output BufferBlock %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %v3float = OpTypeVector %float 3 %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %F = OpTypeStruct %int %v2uint %uint_2 = OpConstant %uint 2 %_arr_float_uint_2 = OpTypeArray %float %uint_2 %mat2v3float = OpTypeMatrix %v3float 2 %v3uint = OpTypeVector %uint 3 %mat3v3float = OpTypeMatrix %v3float 3 %_arr_mat3v3float_uint_2 = OpTypeArray %mat3v3float %uint_2 %O = OpTypeStruct %v3uint %v2float %_arr_float_uint_2 %v2float %_arr_mat3v3float_uint_2 %_arr_O_uint_2 = OpTypeArray %O %uint_2 %Output = OpTypeStruct %float %v2float %v3float %F %float %_arr_float_uint_2 %mat2v3float %_arr_O_uint_2 %_ptr_Uniform_Output = OpTypePointer Uniform %Output %dataOutput = OpVariable %_ptr_Uniform_Output Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateDecorations, StorageBufferLayoutPermitsTightVec3ScalarPackingGood) { // See https://github.com/KhronosGroup/SPIRV-Tools/issues/1666 std::string spirv = R"( OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %S 1 Offset 12 OpDecorate %S Block OpDecorate %B DescriptorSet 0 OpDecorate %B Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %S = OpTypeStruct %v3float %float %_ptr_StorageBuffer_S = OpTypePointer StorageBuffer %S %B = OpVariable %_ptr_StorageBuffer_S StorageBuffer %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)) << getDiagnosticString(); } TEST_F(ValidateDecorations, StorageBufferLayoutForbidsTightScalarVec3PackingBad) { // See https://github.com/KhronosGroup/SPIRV-Tools/issues/1666 std::string spirv = R"( OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %S 1 Offset 4 OpDecorate %S Block OpDecorate %B DescriptorSet 0 OpDecorate %B Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %S = OpTypeStruct %float %v3float %_ptr_StorageBuffer_S = OpTypePointer StorageBuffer %S %B = OpVariable %_ptr_StorageBuffer_S StorageBuffer %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Structure id 2 decorated as Block for variable in StorageBuffer " "storage class must follow standard storage buffer layout " "rules: member 1 at offset 4 is not aligned to 16")); } TEST_F(ValidateDecorations, BlockStandardUniformBufferLayoutIncorrectOffset0Bad) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 430 OpMemberDecorate %F 0 Offset 0 OpMemberDecorate %F 1 Offset 8 OpDecorate %_arr_float_uint_2 ArrayStride 16 OpDecorate %_arr_mat3v3float_uint_2 ArrayStride 48 OpMemberDecorate %O 0 Offset 0 OpMemberDecorate %O 1 Offset 16 OpMemberDecorate %O 2 Offset 24 OpMemberDecorate %O 3 Offset 33 OpMemberDecorate %O 4 ColMajor OpMemberDecorate %O 4 Offset 80 OpMemberDecorate %O 4 MatrixStride 16 OpDecorate %_arr_O_uint_2 ArrayStride 176 OpMemberDecorate %Output 0 Offset 0 OpMemberDecorate %Output 1 Offset 8 OpMemberDecorate %Output 2 Offset 16 OpMemberDecorate %Output 3 Offset 32 OpMemberDecorate %Output 4 Offset 48 OpMemberDecorate %Output 5 Offset 64 OpMemberDecorate %Output 6 ColMajor OpMemberDecorate %Output 6 Offset 96 OpMemberDecorate %Output 6 MatrixStride 16 OpMemberDecorate %Output 7 Offset 128 OpDecorate %Output Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %v3float = OpTypeVector %float 3 %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %F = OpTypeStruct %int %v2uint %uint_2 = OpConstant %uint 2 %_arr_float_uint_2 = OpTypeArray %float %uint_2 %mat2v3float = OpTypeMatrix %v3float 2 %v3uint = OpTypeVector %uint 3 %mat3v3float = OpTypeMatrix %v3float 3 %_arr_mat3v3float_uint_2 = OpTypeArray %mat3v3float %uint_2 %O = OpTypeStruct %v3uint %v2float %_arr_float_uint_2 %v2float %_arr_mat3v3float_uint_2 %_arr_O_uint_2 = OpTypeArray %O %uint_2 %Output = OpTypeStruct %float %v2float %v3float %F %float %_arr_float_uint_2 %mat2v3float %_arr_O_uint_2 %_ptr_Uniform_Output = OpTypePointer Uniform %Output %dataOutput = OpVariable %_ptr_Uniform_Output Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Structure id 6 decorated as Block for variable in Uniform " "storage class must follow standard uniform buffer layout " "rules: member 2 at offset 152 is not aligned to 16")); } TEST_F(ValidateDecorations, BlockStandardUniformBufferLayoutIncorrectOffset1Bad) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 430 OpMemberDecorate %F 0 Offset 0 OpMemberDecorate %F 1 Offset 8 OpDecorate %_arr_float_uint_2 ArrayStride 16 OpDecorate %_arr_mat3v3float_uint_2 ArrayStride 48 OpMemberDecorate %O 0 Offset 0 OpMemberDecorate %O 1 Offset 16 OpMemberDecorate %O 2 Offset 32 OpMemberDecorate %O 3 Offset 64 OpMemberDecorate %O 4 ColMajor OpMemberDecorate %O 4 Offset 80 OpMemberDecorate %O 4 MatrixStride 16 OpDecorate %_arr_O_uint_2 ArrayStride 176 OpMemberDecorate %Output 0 Offset 0 OpMemberDecorate %Output 1 Offset 8 OpMemberDecorate %Output 2 Offset 16 OpMemberDecorate %Output 3 Offset 32 OpMemberDecorate %Output 4 Offset 48 OpMemberDecorate %Output 5 Offset 71 OpMemberDecorate %Output 6 ColMajor OpMemberDecorate %Output 6 Offset 96 OpMemberDecorate %Output 6 MatrixStride 16 OpMemberDecorate %Output 7 Offset 128 OpDecorate %Output Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %v3float = OpTypeVector %float 3 %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %F = OpTypeStruct %int %v2uint %uint_2 = OpConstant %uint 2 %_arr_float_uint_2 = OpTypeArray %float %uint_2 %mat2v3float = OpTypeMatrix %v3float 2 %v3uint = OpTypeVector %uint 3 %mat3v3float = OpTypeMatrix %v3float 3 %_arr_mat3v3float_uint_2 = OpTypeArray %mat3v3float %uint_2 %O = OpTypeStruct %v3uint %v2float %_arr_float_uint_2 %v2float %_arr_mat3v3float_uint_2 %_arr_O_uint_2 = OpTypeArray %O %uint_2 %Output = OpTypeStruct %float %v2float %v3float %F %float %_arr_float_uint_2 %mat2v3float %_arr_O_uint_2 %_ptr_Uniform_Output = OpTypePointer Uniform %Output %dataOutput = OpVariable %_ptr_Uniform_Output Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Structure id 8 decorated as Block for variable in Uniform " "storage class must follow standard uniform buffer layout " "rules: member 5 at offset 71 is not aligned to 16")); } TEST_F(ValidateDecorations, BlockUniformBufferLayoutIncorrectArrayStrideBad) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 430 OpMemberDecorate %F 0 Offset 0 OpMemberDecorate %F 1 Offset 8 OpDecorate %_arr_float_uint_2 ArrayStride 16 OpDecorate %_arr_mat3v3float_uint_2 ArrayStride 49 OpMemberDecorate %O 0 Offset 0 OpMemberDecorate %O 1 Offset 16 OpMemberDecorate %O 2 Offset 32 OpMemberDecorate %O 3 Offset 64 OpMemberDecorate %O 4 ColMajor OpMemberDecorate %O 4 Offset 80 OpMemberDecorate %O 4 MatrixStride 16 OpDecorate %_arr_O_uint_2 ArrayStride 176 OpMemberDecorate %Output 0 Offset 0 OpMemberDecorate %Output 1 Offset 8 OpMemberDecorate %Output 2 Offset 16 OpMemberDecorate %Output 3 Offset 32 OpMemberDecorate %Output 4 Offset 48 OpMemberDecorate %Output 5 Offset 64 OpMemberDecorate %Output 6 ColMajor OpMemberDecorate %Output 6 Offset 96 OpMemberDecorate %Output 6 MatrixStride 16 OpMemberDecorate %Output 7 Offset 128 OpDecorate %Output Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %v3float = OpTypeVector %float 3 %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %F = OpTypeStruct %int %v2uint %uint_2 = OpConstant %uint 2 %_arr_float_uint_2 = OpTypeArray %float %uint_2 %mat2v3float = OpTypeMatrix %v3float 2 %v3uint = OpTypeVector %uint 3 %mat3v3float = OpTypeMatrix %v3float 3 %_arr_mat3v3float_uint_2 = OpTypeArray %mat3v3float %uint_2 %O = OpTypeStruct %v3uint %v2float %_arr_float_uint_2 %v2float %_arr_mat3v3float_uint_2 %_arr_O_uint_2 = OpTypeArray %O %uint_2 %Output = OpTypeStruct %float %v2float %v3float %F %float %_arr_float_uint_2 %mat2v3float %_arr_O_uint_2 %_ptr_Uniform_Output = OpTypePointer Uniform %Output %dataOutput = OpVariable %_ptr_Uniform_Output Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Structure id 6 decorated as Block for variable in Uniform storage " "class must follow standard uniform buffer layout rules: member 4 " "contains " "an array with stride 49 not satisfying alignment to 16")); } TEST_F(ValidateDecorations, BufferBlockStandardStorageBufferLayoutImproperStraddleBad) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 430 OpMemberDecorate %Output 0 Offset 0 OpMemberDecorate %Output 1 Offset 8 OpDecorate %Output BufferBlock %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %Output = OpTypeStruct %float %v3float %_ptr_Uniform_Output = OpTypePointer Uniform %Output %dataOutput = OpVariable %_ptr_Uniform_Output Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Structure id 3 decorated as BufferBlock for variable in " "Uniform storage class must follow standard storage buffer " "layout rules: member 1 at offset 8 is not aligned to 16")); } TEST_F(ValidateDecorations, BlockUniformBufferLayoutOffsetInsideArrayPaddingBad) { // In this case the 2nd member fits entirely within the padding. std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 430 OpDecorate %_arr_float_uint_2 ArrayStride 16 OpMemberDecorate %Output 0 Offset 0 OpMemberDecorate %Output 1 Offset 20 OpDecorate %Output Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %uint_2 = OpConstant %uint 2 %_arr_float_uint_2 = OpTypeArray %float %uint_2 %Output = OpTypeStruct %_arr_float_uint_2 %float %_ptr_Uniform_Output = OpTypePointer Uniform %Output %dataOutput = OpVariable %_ptr_Uniform_Output Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Structure id 4 decorated as Block for variable in Uniform storage " "class must follow standard uniform buffer layout rules: member 1 at " "offset 20 overlaps previous member ending at offset 31")); } TEST_F(ValidateDecorations, BlockUniformBufferLayoutOffsetInsideStructPaddingBad) { // In this case the 2nd member fits entirely within the padding. std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 OpMemberDecorate %_struct_6 0 Offset 0 OpMemberDecorate %_struct_2 0 Offset 0 OpMemberDecorate %_struct_2 1 Offset 4 OpDecorate %_struct_2 Block %void = OpTypeVoid %4 = OpTypeFunction %void %float = OpTypeFloat 32 %_struct_6 = OpTypeStruct %float %_struct_2 = OpTypeStruct %_struct_6 %float %_ptr_Uniform__struct_2 = OpTypePointer Uniform %_struct_2 %8 = OpVariable %_ptr_Uniform__struct_2 Uniform %1 = OpFunction %void None %4 %9 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Structure id 3 decorated as Block for variable in Uniform storage " "class must follow standard uniform buffer layout rules: member 1 at " "offset 4 overlaps previous member ending at offset 15")); } TEST_F(ValidateDecorations, BlockLayoutOffsetOutOfOrderGoodUniversal1_0) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpMemberDecorate %Outer 0 Offset 4 OpMemberDecorate %Outer 1 Offset 0 OpDecorate %Outer Block OpDecorate %O DescriptorSet 0 OpDecorate %O Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %Outer = OpTypeStruct %uint %uint %_ptr_Uniform_Outer = OpTypePointer Uniform %Outer %O = OpVariable %_ptr_Uniform_Outer Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_UNIVERSAL_1_0)); } TEST_F(ValidateDecorations, BlockLayoutOffsetOutOfOrderGoodOpenGL4_5) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpMemberDecorate %Outer 0 Offset 4 OpMemberDecorate %Outer 1 Offset 0 OpDecorate %Outer Block OpDecorate %O DescriptorSet 0 OpDecorate %O Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %Outer = OpTypeStruct %uint %uint %_ptr_Uniform_Outer = OpTypePointer Uniform %Outer %O = OpVariable %_ptr_Uniform_Outer Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_OPENGL_4_5)); } TEST_F(ValidateDecorations, BlockLayoutOffsetOutOfOrderGoodVulkan1_1) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpMemberDecorate %Outer 0 Offset 4 OpMemberDecorate %Outer 1 Offset 0 OpDecorate %Outer Block OpDecorate %O DescriptorSet 0 OpDecorate %O Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %Outer = OpTypeStruct %uint %uint %_ptr_Uniform_Outer = OpTypePointer Uniform %Outer %O = OpVariable %_ptr_Uniform_Outer Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_1)) << getDiagnosticString(); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, BlockLayoutOffsetOverlapBad) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpMemberDecorate %Outer 0 Offset 0 OpMemberDecorate %Outer 1 Offset 16 OpMemberDecorate %Inner 0 Offset 0 OpMemberDecorate %Inner 1 Offset 16 OpDecorate %Outer Block OpDecorate %O DescriptorSet 0 OpDecorate %O Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %Inner = OpTypeStruct %uint %uint %Outer = OpTypeStruct %Inner %uint %_ptr_Uniform_Outer = OpTypePointer Uniform %Outer %O = OpVariable %_ptr_Uniform_Outer Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Structure id 3 decorated as Block for variable in Uniform storage " "class must follow standard uniform buffer layout rules: member 1 at " "offset 16 overlaps previous member ending at offset 31")); } TEST_F(ValidateDecorations, BufferBlockEmptyStruct) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 430 OpMemberDecorate %Output 0 Offset 0 OpDecorate %Output BufferBlock %void = OpTypeVoid %3 = OpTypeFunction %void %S = OpTypeStruct %Output = OpTypeStruct %S %_ptr_Uniform_Output = OpTypePointer Uniform %Output %dataOutput = OpVariable %_ptr_Uniform_Output Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()); } TEST_F(ValidateDecorations, RowMajorMatrixTightPackingGood) { // Row major matrix rule: // A row-major matrix of C columns has a base alignment equal to // the base alignment of a vector of C matrix components. // Note: The "matrix component" is the scalar element type. // The matrix has 3 columns and 2 rows (C=3, R=2). // So the base alignment of b is the same as a vector of 3 floats, which is 16 // bytes. The matrix consists of two of these, and therefore occupies 2 x 16 // bytes, or 32 bytes. // // So the offsets can be: // a -> 0 // b -> 16 // c -> 48 // d -> 60 ; d fits at bytes 12-15 after offset of c. Tight (vec3;float) // packing std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "main" OpSource GLSL 450 OpMemberDecorate %_struct_2 0 Offset 0 OpMemberDecorate %_struct_2 1 RowMajor OpMemberDecorate %_struct_2 1 Offset 16 OpMemberDecorate %_struct_2 1 MatrixStride 16 OpMemberDecorate %_struct_2 2 Offset 48 OpMemberDecorate %_struct_2 3 Offset 60 OpDecorate %_struct_2 Block OpDecorate %3 DescriptorSet 0 OpDecorate %3 Binding 0 %void = OpTypeVoid %5 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %v2float = OpTypeVector %float 2 %mat3v2float = OpTypeMatrix %v2float 3 %v3float = OpTypeVector %float 3 %_struct_2 = OpTypeStruct %v4float %mat3v2float %v3float %float %_ptr_Uniform__struct_2 = OpTypePointer Uniform %_struct_2 %3 = OpVariable %_ptr_Uniform__struct_2 Uniform %1 = OpFunction %void None %5 %12 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()) << getDiagnosticString(); } TEST_F(ValidateDecorations, ArrayArrayRowMajorMatrixTightPackingGood) { // Like the previous case, but we have an array of arrays of matrices. // The RowMajor decoration goes on the struct member (surprisingly). std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "main" OpSource GLSL 450 OpMemberDecorate %_struct_2 0 Offset 0 OpMemberDecorate %_struct_2 1 RowMajor OpMemberDecorate %_struct_2 1 Offset 16 OpMemberDecorate %_struct_2 1 MatrixStride 16 OpMemberDecorate %_struct_2 2 Offset 80 OpMemberDecorate %_struct_2 3 Offset 92 OpDecorate %arr_mat ArrayStride 32 OpDecorate %arr_arr_mat ArrayStride 32 OpDecorate %_struct_2 Block OpDecorate %3 DescriptorSet 0 OpDecorate %3 Binding 0 %void = OpTypeVoid %5 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %v2float = OpTypeVector %float 2 %mat3v2float = OpTypeMatrix %v2float 3 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %arr_mat = OpTypeArray %mat3v2float %uint_1 %arr_arr_mat = OpTypeArray %arr_mat %uint_2 %v3float = OpTypeVector %float 3 %_struct_2 = OpTypeStruct %v4float %arr_arr_mat %v3float %float %_ptr_Uniform__struct_2 = OpTypePointer Uniform %_struct_2 %3 = OpVariable %_ptr_Uniform__struct_2 Uniform %1 = OpFunction %void None %5 %12 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)) << getDiagnosticString(); } TEST_F(ValidateDecorations, ArrayArrayRowMajorMatrixNextMemberOverlapsBad) { // Like the previous case, but the offset of member 2 overlaps the matrix. std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "main" OpSource GLSL 450 OpMemberDecorate %_struct_2 0 Offset 0 OpMemberDecorate %_struct_2 1 RowMajor OpMemberDecorate %_struct_2 1 Offset 16 OpMemberDecorate %_struct_2 1 MatrixStride 16 OpMemberDecorate %_struct_2 2 Offset 64 OpMemberDecorate %_struct_2 3 Offset 92 OpDecorate %arr_mat ArrayStride 32 OpDecorate %arr_arr_mat ArrayStride 32 OpDecorate %_struct_2 Block OpDecorate %3 DescriptorSet 0 OpDecorate %3 Binding 0 %void = OpTypeVoid %5 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %v2float = OpTypeVector %float 2 %mat3v2float = OpTypeMatrix %v2float 3 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %arr_mat = OpTypeArray %mat3v2float %uint_1 %arr_arr_mat = OpTypeArray %arr_mat %uint_2 %v3float = OpTypeVector %float 3 %_struct_2 = OpTypeStruct %v4float %arr_arr_mat %v3float %float %_ptr_Uniform__struct_2 = OpTypePointer Uniform %_struct_2 %3 = OpVariable %_ptr_Uniform__struct_2 Uniform %1 = OpFunction %void None %5 %12 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Structure id 2 decorated as Block for variable in Uniform storage " "class must follow standard uniform buffer layout rules: member 2 at " "offset 64 overlaps previous member ending at offset 79")); } TEST_F(ValidateDecorations, StorageBufferArraySizeCalculationPackGood) { // Original GLSL // #version 450 // layout (set=0,binding=0) buffer S { // uvec3 arr[2][2]; // first 3 elements are 16 bytes, last is 12 // uint i; // Can't have offset 60 = 3x16 + 12 // } B; // void main() {} std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "main" OpDecorate %_arr_v3uint_uint_2 ArrayStride 16 OpDecorate %_arr__arr_v3uint_uint_2_uint_2 ArrayStride 32 OpMemberDecorate %_struct_4 0 Offset 0 OpMemberDecorate %_struct_4 1 Offset 64 OpDecorate %_struct_4 BufferBlock OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 0 %void = OpTypeVoid %7 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v3uint = OpTypeVector %uint 3 %uint_2 = OpConstant %uint 2 %_arr_v3uint_uint_2 = OpTypeArray %v3uint %uint_2 %_arr__arr_v3uint_uint_2_uint_2 = OpTypeArray %_arr_v3uint_uint_2 %uint_2 %_struct_4 = OpTypeStruct %_arr__arr_v3uint_uint_2_uint_2 %uint %_ptr_Uniform__struct_4 = OpTypePointer Uniform %_struct_4 %5 = OpVariable %_ptr_Uniform__struct_4 Uniform %1 = OpFunction %void None %7 %12 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateDecorations, StorageBufferArraySizeCalculationPackGoodScalar) { // Original GLSL // #version 450 // layout (set=0,binding=0) buffer S { // uvec3 arr[2][2]; // first 3 elements are 16 bytes, last is 12 // uint i; // Can have offset 60 = 3x16 + 12 // } B; // void main() {} std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "main" OpDecorate %_arr_v3uint_uint_2 ArrayStride 16 OpDecorate %_arr__arr_v3uint_uint_2_uint_2 ArrayStride 32 OpMemberDecorate %_struct_4 0 Offset 0 OpMemberDecorate %_struct_4 1 Offset 60 OpDecorate %_struct_4 BufferBlock OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 0 %void = OpTypeVoid %7 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v3uint = OpTypeVector %uint 3 %uint_2 = OpConstant %uint 2 %_arr_v3uint_uint_2 = OpTypeArray %v3uint %uint_2 %_arr__arr_v3uint_uint_2_uint_2 = OpTypeArray %_arr_v3uint_uint_2 %uint_2 %_struct_4 = OpTypeStruct %_arr__arr_v3uint_uint_2_uint_2 %uint %_ptr_Uniform__struct_4 = OpTypePointer Uniform %_struct_4 %5 = OpVariable %_ptr_Uniform__struct_4 Uniform %1 = OpFunction %void None %7 %12 = OpLabel OpReturn OpFunctionEnd )"; options_->scalar_block_layout = true; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateDecorations, StorageBufferArraySizeCalculationPackBad) { // Like previous but, the offset of the second member is too small. std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "main" OpDecorate %_arr_v3uint_uint_2 ArrayStride 16 OpDecorate %_arr__arr_v3uint_uint_2_uint_2 ArrayStride 32 OpMemberDecorate %_struct_4 0 Offset 0 OpMemberDecorate %_struct_4 1 Offset 60 OpDecorate %_struct_4 BufferBlock OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 0 %void = OpTypeVoid %7 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v3uint = OpTypeVector %uint 3 %uint_2 = OpConstant %uint 2 %_arr_v3uint_uint_2 = OpTypeArray %v3uint %uint_2 %_arr__arr_v3uint_uint_2_uint_2 = OpTypeArray %_arr_v3uint_uint_2 %uint_2 %_struct_4 = OpTypeStruct %_arr__arr_v3uint_uint_2_uint_2 %uint %_ptr_Uniform__struct_4 = OpTypePointer Uniform %_struct_4 %5 = OpVariable %_ptr_Uniform__struct_4 Uniform %1 = OpFunction %void None %7 %12 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Structure id 4 decorated as BufferBlock for variable " "in Uniform storage class must follow standard storage " "buffer layout rules: member 1 at offset 60 overlaps " "previous member ending at offset 63")); } TEST_F(ValidateDecorations, UniformBufferArraySizeCalculationPackGood) { // Like the corresponding buffer block case, but the array padding must // count for the last element as well, and so the offset of the second // member must be at least 64. std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "main" OpDecorate %_arr_v3uint_uint_2 ArrayStride 16 OpDecorate %_arr__arr_v3uint_uint_2_uint_2 ArrayStride 32 OpMemberDecorate %_struct_4 0 Offset 0 OpMemberDecorate %_struct_4 1 Offset 64 OpDecorate %_struct_4 Block OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 0 %void = OpTypeVoid %7 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v3uint = OpTypeVector %uint 3 %uint_2 = OpConstant %uint 2 %_arr_v3uint_uint_2 = OpTypeArray %v3uint %uint_2 %_arr__arr_v3uint_uint_2_uint_2 = OpTypeArray %_arr_v3uint_uint_2 %uint_2 %_struct_4 = OpTypeStruct %_arr__arr_v3uint_uint_2_uint_2 %uint %_ptr_Uniform__struct_4 = OpTypePointer Uniform %_struct_4 %5 = OpVariable %_ptr_Uniform__struct_4 Uniform %1 = OpFunction %void None %7 %12 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateDecorations, UniformBufferArraySizeCalculationPackBad) { // Like previous but, the offset of the second member is too small. std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "main" OpDecorate %_arr_v3uint_uint_2 ArrayStride 16 OpDecorate %_arr__arr_v3uint_uint_2_uint_2 ArrayStride 32 OpMemberDecorate %_struct_4 0 Offset 0 OpMemberDecorate %_struct_4 1 Offset 60 OpDecorate %_struct_4 Block OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 0 %void = OpTypeVoid %7 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v3uint = OpTypeVector %uint 3 %uint_2 = OpConstant %uint 2 %_arr_v3uint_uint_2 = OpTypeArray %v3uint %uint_2 %_arr__arr_v3uint_uint_2_uint_2 = OpTypeArray %_arr_v3uint_uint_2 %uint_2 %_struct_4 = OpTypeStruct %_arr__arr_v3uint_uint_2_uint_2 %uint %_ptr_Uniform__struct_4 = OpTypePointer Uniform %_struct_4 %5 = OpVariable %_ptr_Uniform__struct_4 Uniform %1 = OpFunction %void None %7 %12 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Structure id 4 decorated as Block for variable in Uniform storage " "class must follow standard uniform buffer layout rules: member 1 at " "offset 60 overlaps previous member ending at offset 63")); } TEST_F(ValidateDecorations, LayoutNotCheckedWhenSkipBlockLayout) { // Checks that block layout is not verified in skipping block layout mode. // Even for obviously wrong layout. std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 450 OpMemberDecorate %S 0 Offset 3 ; wrong alignment OpMemberDecorate %S 1 Offset 3 ; same offset as before! OpDecorate %S Block OpDecorate %B DescriptorSet 0 OpDecorate %B Binding 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %S = OpTypeStruct %float %v3float %_ptr_Uniform_S = OpTypePointer Uniform %S %B = OpVariable %_ptr_Uniform_S Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); spvValidatorOptionsSetSkipBlockLayout(getValidatorOptions(), true); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, EntryPointVariableWrongStorageClass) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" %var OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr_int_Workgroup = OpTypePointer Workgroup %int %var = OpVariable %ptr_int_Workgroup Workgroup %func_ty = OpTypeFunction %void %1 = OpFunction %void None %func_ty %2 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpEntryPoint interfaces must be OpVariables with " "Storage Class of Input(1) or Output(3). Found Storage " "Class 4 for Entry Point id 1.")); } TEST_F(ValidateDecorations, VulkanMemoryModelNonCoherent) { const std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability Linkage OpExtension "SPV_KHR_vulkan_memory_model" OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical VulkanKHR OpDecorate %1 Coherent %2 = OpTypeInt 32 0 %3 = OpTypePointer StorageBuffer %2 %1 = OpVariable %3 StorageBuffer )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Coherent decoration targeting '1[%1]' is " "banned when using the Vulkan memory model.")); } TEST_F(ValidateDecorations, VulkanMemoryModelNoCoherentMember) { const std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability Linkage OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR OpMemberDecorate %1 0 Coherent %2 = OpTypeInt 32 0 %1 = OpTypeStruct %2 %2 )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Coherent decoration targeting '1[%_struct_1]' (member index 0) " "is banned when using the Vulkan memory model.")); } TEST_F(ValidateDecorations, VulkanMemoryModelNoVolatile) { const std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability Linkage OpExtension "SPV_KHR_vulkan_memory_model" OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical VulkanKHR OpDecorate %1 Volatile %2 = OpTypeInt 32 0 %3 = OpTypePointer StorageBuffer %2 %1 = OpVariable %3 StorageBuffer )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Volatile decoration targeting '1[%1]' is banned when " "using the Vulkan memory model.")); } TEST_F(ValidateDecorations, VulkanMemoryModelNoVolatileMember) { const std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability Linkage OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR OpMemberDecorate %1 1 Volatile %2 = OpTypeInt 32 0 %1 = OpTypeStruct %2 %2 )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Volatile decoration targeting '1[%_struct_1]' (member " "index 1) is banned when using the Vulkan memory " "model.")); } TEST_F(ValidateDecorations, FPRoundingModeGood) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability StorageBuffer16BitAccess OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_KHR_variable_pointers" OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpDecorate %_ FPRoundingMode RTE %half = OpTypeFloat 16 %float = OpTypeFloat 32 %float_1_25 = OpConstant %float 1.25 %half_ptr = OpTypePointer StorageBuffer %half %half_ptr_var = OpVariable %half_ptr StorageBuffer %void = OpTypeVoid %func = OpTypeFunction %void %main = OpFunction %void None %func %main_entry = OpLabel %_ = OpFConvert %half %float_1_25 OpStore %half_ptr_var %_ OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()); } TEST_F(ValidateDecorations, FPRoundingModeVectorGood) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability StorageBuffer16BitAccess OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_KHR_variable_pointers" OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpDecorate %_ FPRoundingMode RTE %half = OpTypeFloat 16 %float = OpTypeFloat 32 %v2half = OpTypeVector %half 2 %v2float = OpTypeVector %float 2 %float_1_25 = OpConstant %float 1.25 %floats = OpConstantComposite %v2float %float_1_25 %float_1_25 %halfs_ptr = OpTypePointer StorageBuffer %v2half %halfs_ptr_var = OpVariable %halfs_ptr StorageBuffer %void = OpTypeVoid %func = OpTypeFunction %void %main = OpFunction %void None %func %main_entry = OpLabel %_ = OpFConvert %v2half %floats OpStore %halfs_ptr_var %_ OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()); } TEST_F(ValidateDecorations, FPRoundingModeNotOpFConvert) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability StorageBuffer16BitAccess OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_KHR_variable_pointers" OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpDecorate %_ FPRoundingMode RTE %short = OpTypeInt 16 1 %int = OpTypeInt 32 1 %int_17 = OpConstant %int 17 %short_ptr = OpTypePointer StorageBuffer %short %short_ptr_var = OpVariable %short_ptr StorageBuffer %void = OpTypeVoid %func = OpTypeFunction %void %main = OpFunction %void None %func %main_entry = OpLabel %_ = OpSConvert %short %int_17 OpStore %short_ptr_var %_ OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState()); EXPECT_THAT(getDiagnosticString(), HasSubstr("FPRoundingMode decoration can be applied only to a " "width-only conversion instruction for floating-point " "object.")); } TEST_F(ValidateDecorations, FPRoundingModeNoOpStoreGood) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability StorageBuffer16BitAccess OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_KHR_variable_pointers" OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpDecorate %_ FPRoundingMode RTE %half = OpTypeFloat 16 %float = OpTypeFloat 32 %float_1_25 = OpConstant %float 1.25 %half_ptr = OpTypePointer StorageBuffer %half %half_ptr_var = OpVariable %half_ptr StorageBuffer %void = OpTypeVoid %func = OpTypeFunction %void %main = OpFunction %void None %func %main_entry = OpLabel %_ = OpFConvert %half %float_1_25 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()); } TEST_F(ValidateDecorations, FPRoundingModeFConvert64to16Good) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability StorageBuffer16BitAccess OpCapability Float64 OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_KHR_variable_pointers" OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpDecorate %_ FPRoundingMode RTE %half = OpTypeFloat 16 %double = OpTypeFloat 64 %double_1_25 = OpConstant %double 1.25 %half_ptr = OpTypePointer StorageBuffer %half %half_ptr_var = OpVariable %half_ptr StorageBuffer %void = OpTypeVoid %func = OpTypeFunction %void %main = OpFunction %void None %func %main_entry = OpLabel %_ = OpFConvert %half %double_1_25 OpStore %half_ptr_var %_ OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()); } TEST_F(ValidateDecorations, FPRoundingModeNotStoreInFloat16) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability StorageBuffer16BitAccess OpCapability Float64 OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_KHR_variable_pointers" OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpDecorate %_ FPRoundingMode RTE %float = OpTypeFloat 32 %double = OpTypeFloat 64 %double_1_25 = OpConstant %double 1.25 %float_ptr = OpTypePointer StorageBuffer %float %float_ptr_var = OpVariable %float_ptr StorageBuffer %void = OpTypeVoid %func = OpTypeFunction %void %main = OpFunction %void None %func %main_entry = OpLabel %_ = OpFConvert %float %double_1_25 OpStore %float_ptr_var %_ OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState()); EXPECT_THAT( getDiagnosticString(), HasSubstr("FPRoundingMode decoration can be applied only to the " "Object operand of an OpStore storing through a " "pointer to a 16-bit floating-point scalar or vector object.")); } TEST_F(ValidateDecorations, FPRoundingModeMultipleOpStoreGood) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability StorageBuffer16BitAccess OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_KHR_variable_pointers" OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpDecorate %_ FPRoundingMode RTE %half = OpTypeFloat 16 %float = OpTypeFloat 32 %float_1_25 = OpConstant %float 1.25 %half_ptr = OpTypePointer StorageBuffer %half %half_ptr_var_0 = OpVariable %half_ptr StorageBuffer %half_ptr_var_1 = OpVariable %half_ptr StorageBuffer %half_ptr_var_2 = OpVariable %half_ptr StorageBuffer %void = OpTypeVoid %func = OpTypeFunction %void %main = OpFunction %void None %func %main_entry = OpLabel %_ = OpFConvert %half %float_1_25 OpStore %half_ptr_var_0 %_ OpStore %half_ptr_var_1 %_ OpStore %half_ptr_var_2 %_ OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()); } TEST_F(ValidateDecorations, FPRoundingModeMultipleUsesBad) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability StorageBuffer16BitAccess OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_KHR_variable_pointers" OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpDecorate %_ FPRoundingMode RTE %half = OpTypeFloat 16 %float = OpTypeFloat 32 %float_1_25 = OpConstant %float 1.25 %half_ptr = OpTypePointer StorageBuffer %half %half_ptr_var_0 = OpVariable %half_ptr StorageBuffer %half_ptr_var_1 = OpVariable %half_ptr StorageBuffer %void = OpTypeVoid %func = OpTypeFunction %void %main = OpFunction %void None %func %main_entry = OpLabel %_ = OpFConvert %half %float_1_25 OpStore %half_ptr_var_0 %_ %result = OpFAdd %half %_ %_ OpStore %half_ptr_var_1 %_ OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState()); EXPECT_THAT(getDiagnosticString(), HasSubstr("FPRoundingMode decoration can be applied only to the " "Object operand of an OpStore.")); } TEST_F(ValidateDecorations, VulkanFPRoundingModeGood) { std::string spirv = R"( OpCapability Shader OpCapability StorageBuffer16BitAccess %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %_ OpExecutionMode %main LocalSize 1 1 1 OpMemberDecorate %ssbo 0 Offset 0 OpDecorate %ssbo Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %17 FPRoundingMode RTE %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_1 = OpConstant %float 1 %half = OpTypeFloat 16 %ssbo = OpTypeStruct %half %_ptr_StorageBuffer_ssbo = OpTypePointer StorageBuffer %ssbo %_ = OpVariable %_ptr_StorageBuffer_ssbo StorageBuffer %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_StorageBuffer_half = OpTypePointer StorageBuffer %half %main = OpFunction %void None %3 %5 = OpLabel %b = OpVariable %_ptr_Function_float Function OpStore %b %float_1 %16 = OpLoad %float %b %17 = OpFConvert %half %16 %19 = OpAccessChain %_ptr_StorageBuffer_half %_ %int_0 OpStore %19 %17 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateDecorations, VulkanFPRoundingModeBadMode) { std::string spirv = R"( OpCapability Shader OpCapability StorageBuffer16BitAccess %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %_ OpExecutionMode %main LocalSize 1 1 1 OpMemberDecorate %ssbo 0 Offset 0 OpDecorate %ssbo Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %17 FPRoundingMode RTP %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %float_1 = OpConstant %float 1 %half = OpTypeFloat 16 %ssbo = OpTypeStruct %half %_ptr_StorageBuffer_ssbo = OpTypePointer StorageBuffer %ssbo %_ = OpVariable %_ptr_StorageBuffer_ssbo StorageBuffer %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_StorageBuffer_half = OpTypePointer StorageBuffer %half %main = OpFunction %void None %3 %5 = OpLabel %b = OpVariable %_ptr_Function_float Function OpStore %b %float_1 %16 = OpLoad %float %b %17 = OpFConvert %half %16 %19 = OpAccessChain %_ptr_StorageBuffer_half %_ %int_0 OpStore %19 %17 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-FPRoundingMode-04675")); EXPECT_THAT( getDiagnosticString(), HasSubstr("In Vulkan, the FPRoundingMode mode must only by RTE or RTZ.")); } TEST_F(ValidateDecorations, GroupDecorateTargetsDecorationGroup) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpDecorationGroup OpGroupDecorate %1 %1 )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpGroupDecorate may not target OpDecorationGroup " "'1[%1]'")); } TEST_F(ValidateDecorations, GroupDecorateTargetsDecorationGroup2) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpDecorationGroup OpGroupDecorate %1 %2 %1 %2 = OpTypeVoid )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpGroupDecorate may not target OpDecorationGroup " "'1[%1]'")); } TEST_F(ValidateDecorations, RecurseThroughRuntimeArray) { const std::string spirv = R"( OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %outer Block OpMemberDecorate %inner 0 Offset 0 OpMemberDecorate %inner 1 Offset 1 OpDecorate %runtime ArrayStride 16 OpMemberDecorate %outer 0 Offset 0 %int = OpTypeInt 32 0 %inner = OpTypeStruct %int %int %runtime = OpTypeRuntimeArray %inner %outer = OpTypeStruct %runtime %outer_ptr = OpTypePointer StorageBuffer %outer %var = OpVariable %outer_ptr StorageBuffer %void = OpTypeVoid %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Structure id 3 decorated as Block for variable in StorageBuffer " "storage class must follow standard storage buffer layout " "rules: member 1 at offset 1 is not aligned to 4")); } TEST_F(ValidateDecorations, VulkanStructWithoutDecorationWithRuntimeArray) { std::string str = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft OpDecorate %array_t ArrayStride 4 OpMemberDecorate %struct_t 0 Offset 0 OpMemberDecorate %struct_t 1 Offset 4 %uint_t = OpTypeInt 32 0 %array_t = OpTypeRuntimeArray %uint_t %struct_t = OpTypeStruct %uint_t %array_t %struct_ptr = OpTypePointer StorageBuffer %struct_t %2 = OpVariable %struct_ptr StorageBuffer %void = OpTypeVoid %func_t = OpTypeFunction %void %func = OpFunction %void None %func_t %1 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str(), SPV_ENV_VULKAN_1_1); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpTypeRuntimeArray-04680")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Vulkan, OpTypeStruct containing an OpTypeRuntimeArray " "must be decorated with Block or BufferBlock.")); } TEST_F(ValidateDecorations, EmptyStructAtNonZeroOffsetGood) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 OpMemberDecorate %struct 1 Offset 16 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 %void = OpTypeVoid %float = OpTypeFloat 32 %empty = OpTypeStruct %struct = OpTypeStruct %float %empty %ptr_struct_ubo = OpTypePointer Uniform %struct %var = OpVariable %ptr_struct_ubo Uniform %voidfn = OpTypeFunction %void %main = OpFunction %void None %voidfn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // Uniform and UniformId decorations TEST_F(ValidateDecorations, UniformDecorationGood) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical Simple OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %int0 Uniform OpDecorate %var Uniform OpDecorate %val Uniform %void = OpTypeVoid %int = OpTypeInt 32 1 %int0 = OpConstantNull %int %intptr = OpTypePointer Private %int %var = OpVariable %intptr Private %fn = OpTypeFunction %void %main = OpFunction %void None %fn %entry = OpLabel %val = OpLoad %int %var OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), Eq("")); } // Returns SPIR-V assembly for a shader that uses a given decoration // instruction. std::string ShaderWithUniformLikeDecoration(const std::string& inst) { return std::string(R"( OpCapability Shader OpMemoryModel Logical Simple OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpName %subgroupscope "subgroupscope" OpName %call "call" OpName %myfunc "myfunc" OpName %int0 "int0" OpName %float0 "float0" OpName %fn "fn" )") + inst + R"( %void = OpTypeVoid %float = OpTypeFloat 32 %int = OpTypeInt 32 1 %int0 = OpConstantNull %int %int_99 = OpConstant %int 99 %subgroupscope = OpConstant %int 3 %float0 = OpConstantNull %float %fn = OpTypeFunction %void %myfunc = OpFunction %void None %fn %myfuncentry = OpLabel OpReturn OpFunctionEnd %main = OpFunction %void None %fn %entry = OpLabel %call = OpFunctionCall %void %myfunc OpReturn OpFunctionEnd )"; } TEST_F(ValidateDecorations, UniformIdDecorationWithScopeIdV13Bad) { const std::string spirv = ShaderWithUniformLikeDecoration( "OpDecorateId %int0 UniformId %subgroupscope"); CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_WRONG_VERSION, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("requires SPIR-V version 1.4 or later\n" " OpDecorateId %int0 UniformId %subgroupscope")) << spirv; } TEST_F(ValidateDecorations, UniformIdDecorationWithScopeIdV13BadTargetV14) { const std::string spirv = ShaderWithUniformLikeDecoration( "OpDecorateId %int0 UniformId %subgroupscope"); CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_WRONG_VERSION, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("requires SPIR-V version 1.4 or later")); } TEST_F(ValidateDecorations, UniformIdDecorationWithScopeIdV14Good) { const std::string spirv = ShaderWithUniformLikeDecoration( "OpDecorateId %int0 UniformId %subgroupscope"); CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, UniformDecorationTargetsTypeBad) { const std::string spirv = ShaderWithUniformLikeDecoration("OpDecorate %fn Uniform"); CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Uniform decoration applied to a non-object")); EXPECT_THAT(getDiagnosticString(), HasSubstr("%fn = OpTypeFunction %void")); } TEST_F(ValidateDecorations, UniformIdDecorationTargetsTypeBad) { const std::string spirv = ShaderWithUniformLikeDecoration( "OpDecorateId %fn UniformId %subgroupscope"); CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("UniformId decoration applied to a non-object")); EXPECT_THAT(getDiagnosticString(), HasSubstr("%fn = OpTypeFunction %void")); } TEST_F(ValidateDecorations, UniformDecorationTargetsVoidValueBad) { const std::string spirv = ShaderWithUniformLikeDecoration("OpDecorate %call Uniform"); CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Uniform decoration applied to a value with void type\n" " %call = OpFunctionCall %void %myfunc")); } TEST_F(ValidateDecorations, UniformIdDecorationTargetsVoidValueBad) { const std::string spirv = ShaderWithUniformLikeDecoration( "OpDecorateId %call UniformId %subgroupscope"); CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)) << spirv; EXPECT_THAT( getDiagnosticString(), HasSubstr("UniformId decoration applied to a value with void type\n" " %call = OpFunctionCall %void %myfunc")); } TEST_F(ValidateDecorations, UniformDecorationWithScopeIdV14IdIsFloatValueIsBad) { const std::string spirv = ShaderWithUniformLikeDecoration("OpDecorateId %int0 UniformId %float0"); CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("ConstantNull: expected scope to be a 32-bit int")); } TEST_F(ValidateDecorations, UniformDecorationWithScopeIdV14IdIsInvalidIntValueBad) { const std::string spirv = ShaderWithUniformLikeDecoration("OpDecorateId %int0 UniformId %int_99"); CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Invalid scope value:\n %int_99 = OpConstant %int 99\n")); } TEST_F(ValidateDecorations, UniformDecorationWithScopeIdV14VulkanEnv) { const std::string spirv = ShaderWithUniformLikeDecoration("OpDecorateId %int0 UniformId %int0"); CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1_SPIRV_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_1_SPIRV_1_4)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-None-04636")); EXPECT_THAT(getDiagnosticString(), HasSubstr(": in Vulkan environment Execution Scope is limited to " "Workgroup and Subgroup")); } TEST_F(ValidateDecorations, UniformDecorationWithWrongInstructionBad) { const std::string spirv = ShaderWithUniformLikeDecoration("OpDecorateId %int0 Uniform"); CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_2); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_2)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Decorations that don't take ID parameters may not be " "used with OpDecorateId\n" " OpDecorateId %int0 Uniform")); } TEST_F(ValidateDecorations, UniformIdDecorationWithWrongInstructionBad) { const std::string spirv = ShaderWithUniformLikeDecoration( "OpDecorate %int0 UniformId %subgroupscope"); CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Decorations taking ID parameters may not be used with OpDecorateId\n" " OpDecorate %int0 UniformId %subgroupscope")); } TEST_F(ValidateDecorations, MultipleOffsetDecorationsOnSameID) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpMemberDecorate %struct 0 Offset 0 OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %struct = OpTypeStruct %float %1 = OpFunction %void None %voidfn %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState()); EXPECT_THAT(getDiagnosticString(), HasSubstr("ID '2', member '0' decorated with Offset multiple " "times is not allowed.")); } TEST_F(ValidateDecorations, MultipleArrayStrideDecorationsOnSameID) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpDecorate %array ArrayStride 4 OpDecorate %array ArrayStride 4 %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %uint = OpTypeInt 32 0 %uint_4 = OpConstant %uint 4 %array = OpTypeArray %float %uint_4 %1 = OpFunction %void None %voidfn %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState()); EXPECT_THAT(getDiagnosticString(), HasSubstr("ID '2' decorated with ArrayStride multiple " "times is not allowed.")); } TEST_F(ValidateDecorations, MultipleMatrixStrideDecorationsOnSameID) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpMemberDecorate %struct 0 Offset 0 OpMemberDecorate %struct 0 ColMajor OpMemberDecorate %struct 0 MatrixStride 16 OpMemberDecorate %struct 0 MatrixStride 16 %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %fvec4 = OpTypeVector %float 4 %fmat4 = OpTypeMatrix %fvec4 4 %struct = OpTypeStruct %fmat4 %1 = OpFunction %void None %voidfn %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState()); EXPECT_THAT(getDiagnosticString(), HasSubstr("ID '2', member '0' decorated with MatrixStride " "multiple times is not allowed.")); } TEST_F(ValidateDecorations, MultipleRowMajorDecorationsOnSameID) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpMemberDecorate %struct 0 Offset 0 OpMemberDecorate %struct 0 MatrixStride 16 OpMemberDecorate %struct 0 RowMajor OpMemberDecorate %struct 0 RowMajor %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %fvec4 = OpTypeVector %float 4 %fmat4 = OpTypeMatrix %fvec4 4 %struct = OpTypeStruct %fmat4 %1 = OpFunction %void None %voidfn %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState()); EXPECT_THAT(getDiagnosticString(), HasSubstr("ID '2', member '0' decorated with RowMajor multiple " "times is not allowed.")); } TEST_F(ValidateDecorations, MultipleColMajorDecorationsOnSameID) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpMemberDecorate %struct 0 Offset 0 OpMemberDecorate %struct 0 MatrixStride 16 OpMemberDecorate %struct 0 ColMajor OpMemberDecorate %struct 0 ColMajor %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %fvec4 = OpTypeVector %float 4 %fmat4 = OpTypeMatrix %fvec4 4 %struct = OpTypeStruct %fmat4 %1 = OpFunction %void None %voidfn %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState()); EXPECT_THAT(getDiagnosticString(), HasSubstr("ID '2', member '0' decorated with ColMajor multiple " "times is not allowed.")); } TEST_F(ValidateDecorations, RowMajorAndColMajorDecorationsOnSameID) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpMemberDecorate %struct 0 Offset 0 OpMemberDecorate %struct 0 MatrixStride 16 OpMemberDecorate %struct 0 ColMajor OpMemberDecorate %struct 0 RowMajor %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %fvec4 = OpTypeVector %float 4 %fmat4 = OpTypeMatrix %fvec4 4 %struct = OpTypeStruct %fmat4 %1 = OpFunction %void None %voidfn %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState()); EXPECT_THAT(getDiagnosticString(), HasSubstr("ID '2', member '0' decorated with both RowMajor and " "ColMajor is not allowed.")); } TEST_F(ValidateDecorations, BlockAndBufferBlockDecorationsOnSameID) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpDecorate %struct Block OpDecorate %struct BufferBlock OpMemberDecorate %struct 0 Offset 0 OpMemberDecorate %struct 0 MatrixStride 16 OpMemberDecorate %struct 0 RowMajor %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %fvec4 = OpTypeVector %float 4 %fmat4 = OpTypeMatrix %fvec4 4 %struct = OpTypeStruct %fmat4 %1 = OpFunction %void None %voidfn %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "ID '2' decorated with both BufferBlock and Block is not allowed.")); } std::string MakeIntegerShader( const std::string& decoration, const std::string& inst, const std::string& extension = "OpExtension \"SPV_KHR_no_integer_wrap_decoration\"") { return R"( OpCapability Shader OpCapability Linkage )" + extension + R"( %glsl = OpExtInstImport "GLSL.std.450" %opencl = OpExtInstImport "OpenCL.std" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpName %entry "entry" )" + decoration + R"( %void = OpTypeVoid %voidfn = OpTypeFunction %void %int = OpTypeInt 32 1 %zero = OpConstantNull %int %float = OpTypeFloat 32 %float0 = OpConstantNull %float %main = OpFunction %void None %voidfn %entry = OpLabel )" + inst + R"( OpReturn OpFunctionEnd)"; } // NoSignedWrap TEST_F(ValidateDecorations, NoSignedWrapOnTypeBad) { std::string spirv = MakeIntegerShader("OpDecorate %void NoSignedWrap", ""); CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("NoSignedWrap decoration may not be applied to TypeVoid")); } TEST_F(ValidateDecorations, NoSignedWrapOnLabelBad) { std::string spirv = MakeIntegerShader("OpDecorate %entry NoSignedWrap", ""); CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("NoSignedWrap decoration may not be applied to Label")); } TEST_F(ValidateDecorations, NoSignedWrapRequiresExtensionBad) { std::string spirv = MakeIntegerShader("OpDecorate %val NoSignedWrap", "%val = OpIAdd %int %zero %zero", ""); CompileSuccessfully(spirv); EXPECT_NE(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("requires one of these extensions: " "SPV_KHR_no_integer_wrap_decoration")); } TEST_F(ValidateDecorations, NoSignedWrapRequiresExtensionV13Bad) { std::string spirv = MakeIntegerShader("OpDecorate %val NoSignedWrap", "%val = OpIAdd %int %zero %zero", ""); CompileSuccessfully(spirv); EXPECT_NE(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("requires one of these extensions: " "SPV_KHR_no_integer_wrap_decoration")); } TEST_F(ValidateDecorations, NoSignedWrapOkInSPV14Good) { std::string spirv = MakeIntegerShader("OpDecorate %val NoSignedWrap", "%val = OpIAdd %int %zero %zero", ""); CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, NoSignedWrapIAddGood) { std::string spirv = MakeIntegerShader("OpDecorate %val NoSignedWrap", "%val = OpIAdd %int %zero %zero"); CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, NoSignedWrapISubGood) { std::string spirv = MakeIntegerShader("OpDecorate %val NoSignedWrap", "%val = OpISub %int %zero %zero"); CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, NoSignedWrapIMulGood) { std::string spirv = MakeIntegerShader("OpDecorate %val NoSignedWrap", "%val = OpIMul %int %zero %zero"); CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, NoSignedWrapShiftLeftLogicalGood) { std::string spirv = MakeIntegerShader("OpDecorate %val NoSignedWrap", "%val = OpShiftLeftLogical %int %zero %zero"); CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, NoSignedWrapSNegateGood) { std::string spirv = MakeIntegerShader("OpDecorate %val NoSignedWrap", "%val = OpSNegate %int %zero"); CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, NoSignedWrapSRemBad) { std::string spirv = MakeIntegerShader("OpDecorate %val NoSignedWrap", "%val = OpSRem %int %zero %zero"); CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("NoSignedWrap decoration may not be applied to SRem")); } TEST_F(ValidateDecorations, NoSignedWrapFAddBad) { std::string spirv = MakeIntegerShader("OpDecorate %val NoSignedWrap", "%val = OpFAdd %float %float0 %float0"); CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("NoSignedWrap decoration may not be applied to FAdd")); } TEST_F(ValidateDecorations, NoSignedWrapExtInstOpenCLGood) { std::string spirv = MakeIntegerShader("OpDecorate %val NoSignedWrap", "%val = OpExtInst %int %opencl s_abs %zero"); CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, NoSignedWrapExtInstGLSLGood) { std::string spirv = MakeIntegerShader( "OpDecorate %val NoSignedWrap", "%val = OpExtInst %int %glsl SAbs %zero"); CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), Eq("")); } // TODO(dneto): For NoSignedWrap and NoUnsignedWrap, permit // "OpExtInst for instruction numbers specified in the extended // instruction-set specifications as accepting this decoration." // NoUnignedWrap TEST_F(ValidateDecorations, NoUnsignedWrapOnTypeBad) { std::string spirv = MakeIntegerShader("OpDecorate %void NoUnsignedWrap", ""); CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("NoUnsignedWrap decoration may not be applied to TypeVoid")); } TEST_F(ValidateDecorations, NoUnsignedWrapOnLabelBad) { std::string spirv = MakeIntegerShader("OpDecorate %entry NoUnsignedWrap", ""); CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("NoUnsignedWrap decoration may not be applied to Label")); } TEST_F(ValidateDecorations, NoUnsignedWrapRequiresExtensionBad) { std::string spirv = MakeIntegerShader("OpDecorate %val NoUnsignedWrap", "%val = OpIAdd %int %zero %zero", ""); CompileSuccessfully(spirv); EXPECT_NE(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("requires one of these extensions: " "SPV_KHR_no_integer_wrap_decoration")); } TEST_F(ValidateDecorations, NoUnsignedWrapRequiresExtensionV13Bad) { std::string spirv = MakeIntegerShader("OpDecorate %val NoUnsignedWrap", "%val = OpIAdd %int %zero %zero", ""); CompileSuccessfully(spirv); EXPECT_NE(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("requires one of these extensions: " "SPV_KHR_no_integer_wrap_decoration")); } TEST_F(ValidateDecorations, NoUnsignedWrapOkInSPV14Good) { std::string spirv = MakeIntegerShader("OpDecorate %val NoUnsignedWrap", "%val = OpIAdd %int %zero %zero", ""); CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, NoUnsignedWrapIAddGood) { std::string spirv = MakeIntegerShader("OpDecorate %val NoUnsignedWrap", "%val = OpIAdd %int %zero %zero"); CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, NoUnsignedWrapISubGood) { std::string spirv = MakeIntegerShader("OpDecorate %val NoUnsignedWrap", "%val = OpISub %int %zero %zero"); CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, NoUnsignedWrapIMulGood) { std::string spirv = MakeIntegerShader("OpDecorate %val NoUnsignedWrap", "%val = OpIMul %int %zero %zero"); CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, NoUnsignedWrapShiftLeftLogicalGood) { std::string spirv = MakeIntegerShader("OpDecorate %val NoUnsignedWrap", "%val = OpShiftLeftLogical %int %zero %zero"); CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, NoUnsignedWrapSNegateGood) { std::string spirv = MakeIntegerShader("OpDecorate %val NoUnsignedWrap", "%val = OpSNegate %int %zero"); CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, NoUnsignedWrapSRemBad) { std::string spirv = MakeIntegerShader("OpDecorate %val NoUnsignedWrap", "%val = OpSRem %int %zero %zero"); CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("NoUnsignedWrap decoration may not be applied to SRem")); } TEST_F(ValidateDecorations, NoUnsignedWrapFAddBad) { std::string spirv = MakeIntegerShader("OpDecorate %val NoUnsignedWrap", "%val = OpFAdd %float %float0 %float0"); CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("NoUnsignedWrap decoration may not be applied to FAdd")); } TEST_F(ValidateDecorations, NoUnsignedWrapExtInstOpenCLGood) { std::string spirv = MakeIntegerShader("OpDecorate %val NoUnsignedWrap", "%val = OpExtInst %int %opencl s_abs %zero"); CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, NoUnsignedWrapExtInstGLSLGood) { std::string spirv = MakeIntegerShader("OpDecorate %val NoUnsignedWrap", "%val = OpExtInst %int %glsl SAbs %zero"); CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, AliasedandRestrictBad) { const std::string body = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 430 OpMemberDecorate %Output 0 Offset 0 OpDecorate %Output BufferBlock OpDecorate %dataOutput Restrict OpDecorate %dataOutput Aliased %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %Output = OpTypeStruct %float %_ptr_Uniform_Output = OpTypePointer Uniform %Output %dataOutput = OpVariable %_ptr_Uniform_Output Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("decorated with both Aliased and Restrict is not allowed")); } // TODO(dneto): For NoUnsignedWrap and NoUnsignedWrap, permit // "OpExtInst for instruction numbers specified in the extended // instruction-set specifications as accepting this decoration." TEST_F(ValidateDecorations, PSBAliasedRestrictPointerSuccess) { const std::string body = R"( OpCapability PhysicalStorageBufferAddresses OpCapability Int64 OpCapability Shader OpExtension "SPV_EXT_physical_storage_buffer" OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpDecorate %val1 RestrictPointer %uint64 = OpTypeInt 64 0 %ptr = OpTypePointer PhysicalStorageBuffer %uint64 %pptr_f = OpTypePointer Function %ptr %void = OpTypeVoid %voidfn = OpTypeFunction %void %main = OpFunction %void None %voidfn %entry = OpLabel %val1 = OpVariable %pptr_f Function OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateDecorations, PSBAliasedRestrictPointerBoth) { const std::string body = R"( OpCapability PhysicalStorageBufferAddresses OpCapability Int64 OpCapability Shader OpExtension "SPV_EXT_physical_storage_buffer" OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpDecorate %val1 RestrictPointer OpDecorate %val1 AliasedPointer %uint64 = OpTypeInt 64 0 %ptr = OpTypePointer PhysicalStorageBuffer %uint64 %pptr_f = OpTypePointer Function %ptr %void = OpTypeVoid %voidfn = OpTypeFunction %void %main = OpFunction %void None %voidfn %entry = OpLabel %val1 = OpVariable %pptr_f Function OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("decorated with both AliasedPointer and " "RestrictPointer is not allowed")); } TEST_F(ValidateDecorations, PSBAliasedRestrictFunctionParamSuccess) { const std::string body = R"( OpCapability PhysicalStorageBufferAddresses OpCapability Int64 OpCapability Shader OpExtension "SPV_EXT_physical_storage_buffer" OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpDecorate %fparam Restrict %uint64 = OpTypeInt 64 0 %ptr = OpTypePointer PhysicalStorageBuffer %uint64 %void = OpTypeVoid %voidfn = OpTypeFunction %void %fnptr = OpTypeFunction %void %ptr %main = OpFunction %void None %voidfn %entry = OpLabel OpReturn OpFunctionEnd %fn = OpFunction %void None %fnptr %fparam = OpFunctionParameter %ptr %lab = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateDecorations, PSBAliasedRestrictFunctionParamBoth) { const std::string body = R"( OpCapability PhysicalStorageBufferAddresses OpCapability Int64 OpCapability Shader OpExtension "SPV_EXT_physical_storage_buffer" OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpDecorate %fparam Restrict OpDecorate %fparam Aliased %uint64 = OpTypeInt 64 0 %ptr = OpTypePointer PhysicalStorageBuffer %uint64 %void = OpTypeVoid %voidfn = OpTypeFunction %void %fnptr = OpTypeFunction %void %ptr %main = OpFunction %void None %voidfn %entry = OpLabel OpReturn OpFunctionEnd %fn = OpFunction %void None %fnptr %fparam = OpFunctionParameter %ptr %lab = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("decorated with both Aliased and Restrict is not allowed")); } TEST_F(ValidateDecorations, PSBFPRoundingModeSuccess) { std::string spirv = R"( OpCapability PhysicalStorageBufferAddresses OpCapability Shader OpCapability Linkage OpCapability StorageBuffer16BitAccess OpExtension "SPV_EXT_physical_storage_buffer" OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_KHR_variable_pointers" OpExtension "SPV_KHR_16bit_storage" OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint GLCompute %main "main" OpDecorate %_ FPRoundingMode RTE OpDecorate %half_ptr_var AliasedPointer %half = OpTypeFloat 16 %float = OpTypeFloat 32 %float_1_25 = OpConstant %float 1.25 %half_ptr = OpTypePointer PhysicalStorageBuffer %half %half_pptr_f = OpTypePointer Function %half_ptr %void = OpTypeVoid %func = OpTypeFunction %void %main = OpFunction %void None %func %main_entry = OpLabel %half_ptr_var = OpVariable %half_pptr_f Function %val1 = OpLoad %half_ptr %half_ptr_var %_ = OpFConvert %half %float_1_25 OpStore %val1 %_ Aligned 2 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()); } TEST_F(ValidateDecorations, InvalidStraddle) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpMemberDecorate %inner_struct 0 Offset 0 OpMemberDecorate %inner_struct 1 Offset 4 OpDecorate %outer_struct Block OpMemberDecorate %outer_struct 0 Offset 0 OpMemberDecorate %outer_struct 1 Offset 8 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 %void = OpTypeVoid %float = OpTypeFloat 32 %float2 = OpTypeVector %float 2 %inner_struct = OpTypeStruct %float %float2 %outer_struct = OpTypeStruct %float2 %inner_struct %ptr_ssbo_outer = OpTypePointer StorageBuffer %outer_struct %var = OpVariable %ptr_ssbo_outer StorageBuffer %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Structure id 2 decorated as Block for variable in " "StorageBuffer storage class must follow relaxed " "storage buffer layout rules: member 1 is an " "improperly straddling vector at offset 12")); } TEST_F(ValidateDecorations, DescriptorArray) { const std::string spirv = R"( OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 OpMemberDecorate %struct 1 Offset 1 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 %void = OpTypeVoid %float = OpTypeFloat 32 %int = OpTypeInt 32 0 %int_2 = OpConstant %int 2 %float2 = OpTypeVector %float 2 %struct = OpTypeStruct %float %float2 %struct_array = OpTypeArray %struct %int_2 %ptr_ssbo_array = OpTypePointer StorageBuffer %struct_array %var = OpVariable %ptr_ssbo_array StorageBuffer %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Structure id 2 decorated as Block for variable in " "StorageBuffer storage class must follow standard " "storage buffer layout rules: member 1 at offset 1 is " "not aligned to 8")); } TEST_F(ValidateDecorations, DescriptorRuntimeArray) { const std::string spirv = R"( OpCapability Shader OpCapability RuntimeDescriptorArrayEXT OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_EXT_descriptor_indexing" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 OpMemberDecorate %struct 1 Offset 1 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 %void = OpTypeVoid %float = OpTypeFloat 32 %int = OpTypeInt 32 0 %float2 = OpTypeVector %float 2 %struct = OpTypeStruct %float %float2 %struct_array = OpTypeRuntimeArray %struct %ptr_ssbo_array = OpTypePointer StorageBuffer %struct_array %var = OpVariable %ptr_ssbo_array StorageBuffer %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Structure id 2 decorated as Block for variable in " "StorageBuffer storage class must follow standard " "storage buffer layout rules: member 1 at offset 1 is " "not aligned to 8")); } TEST_F(ValidateDecorations, MultiDimensionalArray) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 OpDecorate %array_4 ArrayStride 4 OpDecorate %array_3 ArrayStride 48 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_3 = OpConstant %int 3 %int_4 = OpConstant %int 4 %array_4 = OpTypeArray %int %int_4 %array_3 = OpTypeArray %array_4 %int_3 %struct = OpTypeStruct %array_3 %ptr_struct = OpTypePointer Uniform %struct %var = OpVariable %ptr_struct Uniform %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Structure id 2 decorated as Block for variable in " "Uniform storage class must follow standard uniform " "buffer layout rules: member 0 contains an array with " "stride 4 not satisfying alignment to 16")); } TEST_F(ValidateDecorations, ImproperStraddleInArray) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 OpDecorate %array ArrayStride 24 OpMemberDecorate %inner 0 Offset 0 OpMemberDecorate %inner 1 Offset 4 OpMemberDecorate %inner 2 Offset 12 OpMemberDecorate %inner 3 Offset 16 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_2 = OpConstant %int 2 %int2 = OpTypeVector %int 2 %inner = OpTypeStruct %int %int2 %int %int %array = OpTypeArray %inner %int_2 %struct = OpTypeStruct %array %ptr_struct = OpTypePointer StorageBuffer %struct %var = OpVariable %ptr_struct StorageBuffer %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Structure id 4 decorated as Block for variable in " "StorageBuffer storage class must follow relaxed " "storage buffer layout rules: member 1 is an " "improperly straddling vector at offset 28")); } TEST_F(ValidateDecorations, LargeArray) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 OpDecorate %array ArrayStride 24 OpMemberDecorate %inner 0 Offset 0 OpMemberDecorate %inner 1 Offset 8 OpMemberDecorate %inner 2 Offset 16 OpMemberDecorate %inner 3 Offset 20 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_2000000 = OpConstant %int 2000000 %int2 = OpTypeVector %int 2 %inner = OpTypeStruct %int %int2 %int %int %array = OpTypeArray %inner %int_2000000 %struct = OpTypeStruct %array %ptr_struct = OpTypePointer StorageBuffer %struct %var = OpVariable %ptr_struct StorageBuffer %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_1)); } // NonWritable // Returns a SPIR-V shader module with variables in various storage classes, // parameterizable by which ID should be decorated as NonWritable. std::string ShaderWithNonWritableTarget(const std::string& target, bool member_decorate = false) { const std::string decoration_inst = std::string(member_decorate ? "OpMemberDecorate " : "OpDecorate ") + target + (member_decorate ? " 0" : ""); return std::string(R"( OpCapability Shader OpCapability RuntimeDescriptorArrayEXT OpExtension "SPV_EXT_descriptor_indexing" OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpName %label "label" OpName %param_f "param_f" OpName %param_p "param_p" OpName %_ptr_imstor "_ptr_imstor" OpName %_ptr_imsam "_ptr_imsam" OpName %var_wg "var_wg" OpName %var_imsam "var_imsam" OpName %var_priv "var_priv" OpName %var_func "var_func" OpName %simple_struct "simple_struct" OpDecorate %struct_b Block OpDecorate %struct_b_rtarr Block OpMemberDecorate %struct_b 0 Offset 0 OpMemberDecorate %struct_b_rtarr 0 Offset 0 OpDecorate %rtarr ArrayStride 4 )") + decoration_inst + R"( NonWritable %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %int = OpTypeInt 32 0 %int_2 = OpConstant %int 2 %struct_b = OpTypeStruct %float %rtarr = OpTypeRuntimeArray %float %struct_b_rtarr = OpTypeStruct %rtarr %simple_struct = OpTypeStruct %float ; storage image %imstor = OpTypeImage %float 2D 0 0 0 2 R32f ; sampled image %imsam = OpTypeImage %float 2D 0 0 0 1 R32f %array_imstor = OpTypeArray %imstor %int_2 %rta_imstor = OpTypeRuntimeArray %imstor %_ptr_Uniform_stb = OpTypePointer Uniform %struct_b %_ptr_StorageBuffer_stb = OpTypePointer StorageBuffer %struct_b %_ptr_StorageBuffer_stb_rtarr = OpTypePointer StorageBuffer %struct_b_rtarr %_ptr_Workgroup = OpTypePointer Workgroup %float %_ptr_Private = OpTypePointer Private %float %_ptr_Function = OpTypePointer Function %float %_ptr_imstor = OpTypePointer UniformConstant %imstor %_ptr_imsam = OpTypePointer UniformConstant %imsam %_ptr_array_imstor = OpTypePointer UniformConstant %array_imstor %_ptr_rta_imstor = OpTypePointer UniformConstant %rta_imstor %extra_fn = OpTypeFunction %void %float %_ptr_Private %_ptr_imstor %var_ubo = OpVariable %_ptr_Uniform_stb Uniform %var_ssbo_sb = OpVariable %_ptr_StorageBuffer_stb StorageBuffer %var_ssbo_sb_rtarr = OpVariable %_ptr_StorageBuffer_stb_rtarr StorageBuffer %var_wg = OpVariable %_ptr_Workgroup Workgroup %var_priv = OpVariable %_ptr_Private Private %var_imstor = OpVariable %_ptr_imstor UniformConstant %var_imsam = OpVariable %_ptr_imsam UniformConstant %var_array_imstor = OpVariable %_ptr_array_imstor UniformConstant %var_rta_imstor = OpVariable %_ptr_rta_imstor UniformConstant %helper = OpFunction %void None %extra_fn %param_f = OpFunctionParameter %float %param_p = OpFunctionParameter %_ptr_Private %param_pimstor = OpFunctionParameter %_ptr_imstor %helper_label = OpLabel %helper_func_var = OpVariable %_ptr_Function Function OpReturn OpFunctionEnd %main = OpFunction %void None %void_fn %label = OpLabel %var_func = OpVariable %_ptr_Function Function OpReturn OpFunctionEnd )"; } TEST_F(ValidateDecorations, NonWritableLabelTargetBad) { std::string spirv = ShaderWithNonWritableTarget("%label"); CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be a memory object declaration")); } TEST_F(ValidateDecorations, NonWritableTypeTargetBad) { std::string spirv = ShaderWithNonWritableTarget("%void"); CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be a memory object declaration")); } TEST_F(ValidateDecorations, NonWritableValueTargetBad) { std::string spirv = ShaderWithNonWritableTarget("%float_0"); CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be a memory object declaration")); } TEST_F(ValidateDecorations, NonWritableValueParamBad) { std::string spirv = ShaderWithNonWritableTarget("%param_f"); CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be a pointer type")); } TEST_F(ValidateDecorations, NonWritablePointerParamButWrongTypeBad) { std::string spirv = ShaderWithNonWritableTarget("%param_p"); CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Target of NonWritable decoration is invalid: must " "point to a storage image, uniform block, or storage " "buffer\n %param_p = OpFunctionParameter %_ptr_Private_float")); } TEST_F(ValidateDecorations, NonWritablePointerParamStorageImageGood) { std::string spirv = ShaderWithNonWritableTarget("%param_pimstor"); CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, NonWritableVarStorageImageGood) { std::string spirv = ShaderWithNonWritableTarget("%var_imstor"); CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, NonWritableVarSampledImageBad) { std::string spirv = ShaderWithNonWritableTarget("%var_imsam"); CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Target of NonWritable decoration is invalid: must " "point to a storage image, uniform block, or storage " "buffer\n %var_imsam")); } TEST_F(ValidateDecorations, NonWritableVarUboGood) { std::string spirv = ShaderWithNonWritableTarget("%var_ubo"); CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, NonWritableVarSsboInUniformGood) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpDecorate %struct_bb BufferBlock OpMemberDecorate %struct_bb 0 Offset 0 OpDecorate %var_ssbo_u NonWritable %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %struct_bb = OpTypeStruct %float %_ptr_Uniform_stbb = OpTypePointer Uniform %struct_bb %var_ssbo_u = OpVariable %_ptr_Uniform_stbb Uniform %main = OpFunction %void None %void_fn %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, NonWritableVarSsboInStorageBufferGood) { std::string spirv = ShaderWithNonWritableTarget("%var_ssbo_sb"); CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, NonWritableMemberOfSsboInStorageBufferGood) { std::string spirv = ShaderWithNonWritableTarget("%struct_b_rtarr", true); CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, NonWritableMemberOfStructGood) { std::string spirv = ShaderWithNonWritableTarget("%simple_struct", true); CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateDecorations, NonWritableVarWorkgroupBad) { std::string spirv = ShaderWithNonWritableTarget("%var_wg"); CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Target of NonWritable decoration is invalid: must " "point to a storage image, uniform block, or storage " "buffer\n %var_wg")); } TEST_F(ValidateDecorations, NonWritableVarWorkgroupV14Bad) { std::string spirv = ShaderWithNonWritableTarget("%var_wg"); CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Target of NonWritable decoration is invalid: must " "point to a storage image, uniform block, storage " "buffer, or variable in Private or Function storage " "class\n %var_wg")); } TEST_F(ValidateDecorations, NonWritableVarPrivateBad) { std::string spirv = ShaderWithNonWritableTarget("%var_priv"); CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Target of NonWritable decoration is invalid: must " "point to a storage image, uniform block, or storage " "buffer\n %var_priv")); } TEST_F(ValidateDecorations, NonWritableVarPrivateV13Bad) { std::string spirv = ShaderWithNonWritableTarget("%var_priv"); CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Target of NonWritable decoration is invalid: must " "point to a storage image, uniform block, or storage " "buffer\n %var_priv")); } TEST_F(ValidateDecorations, NonWritableVarPrivateV14Good) { std::string spirv = ShaderWithNonWritableTarget("%var_priv"); CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, NonWritableVarPrivateV13TargetV14Bad) { std::string spirv = ShaderWithNonWritableTarget("%var_priv"); CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Target of NonWritable decoration is invalid: must " "point to a storage image, uniform block, or storage " "buffer\n %var_priv")); } TEST_F(ValidateDecorations, NonWritableVarFunctionBad) { std::string spirv = ShaderWithNonWritableTarget("%var_func"); CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Target of NonWritable decoration is invalid: must " "point to a storage image, uniform block, or storage " "buffer\n %var_func")); } TEST_F(ValidateDecorations, NonWritableArrayGood) { std::string spirv = ShaderWithNonWritableTarget("%var_array_imstor"); CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateDecorations, NonWritableRuntimeArrayGood) { std::string spirv = ShaderWithNonWritableTarget("%var_rta_imstor"); CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateVulkanCombineDecorationResult, Decorate) { const char* const decoration = std::get<0>(GetParam()); const char* const vuid = std::get<1>(GetParam()); const TestResult& test_result = std::get<2>(GetParam()); CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator(); generator.before_types_ = "OpDecorate %u32 "; generator.before_types_ += decoration; generator.before_types_ += "\n"; EntryPoint entry_point; entry_point.name = "main"; entry_point.execution_model = "Vertex"; generator.entry_points_.push_back(std::move(entry_point)); CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(test_result.validation_result, ValidateInstructions(SPV_ENV_VULKAN_1_0)); if (!test_result.error_str.empty()) { EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str)); } if (vuid) { EXPECT_THAT(getDiagnosticString(), AnyVUID(vuid)); } } INSTANTIATE_TEST_SUITE_P( DecorationAllowListFailure, ValidateVulkanCombineDecorationResult, Combine(Values("GLSLShared", "GLSLPacked"), Values("VUID-StandaloneSpirv-GLSLShared-04669"), Values(TestResult( SPV_ERROR_INVALID_ID, "is not valid for the Vulkan execution environment.")))); TEST_F(ValidateDecorations, NonWritableVarFunctionV13Bad) { std::string spirv = ShaderWithNonWritableTarget("%var_func"); CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Target of NonWritable decoration is invalid: must " "point to a storage image, uniform block, or storage " "buffer\n %var_func")); } TEST_F(ValidateDecorations, NonWritableVarFunctionV14Good) { std::string spirv = ShaderWithNonWritableTarget("%var_func"); CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, NonWritableVarFunctionV13TargetV14Bad) { std::string spirv = ShaderWithNonWritableTarget("%var_func"); CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Target of NonWritable decoration is invalid: must " "point to a storage image, uniform block, or storage " "buffer\n %var_func")); } TEST_F(ValidateDecorations, BufferBlockV13ValV14Good) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 BufferBlock %1 = OpTypeStruct )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); } TEST_F(ValidateDecorations, BufferBlockV14Bad) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %1 BufferBlock %1 = OpTypeStruct )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_WRONG_VERSION, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("2nd operand of Decorate: operand BufferBlock(3) " "requires SPIR-V version 1.3 or earlier")); } // Component TEST_F(ValidateDecorations, ComponentDecorationBadTarget) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpDecorate %t Component 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %t = OpTypeVector %float 2 %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be a memory object declaration")); } TEST_F(ValidateDecorations, ComponentDecorationBadStorageClass) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpDecorate %v Component 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %t = OpTypeVector %float 2 %ptr_private = OpTypePointer Private %t %v = OpVariable %ptr_private Private %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Target of Component decoration is invalid: must " "point to a Storage Class of Input(1) or Output(3)")); } TEST_F(ValidateDecorations, ComponentDecorationBadTypeVulkan) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = R"( OpCapability Shader OpCapability Matrix OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpDecorate %v Component 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %vtype = OpTypeVector %float 4 %t = OpTypeMatrix %vtype 4 %ptr_input = OpTypePointer Input %t %v = OpVariable %ptr_input Input %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(env)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Component-10583")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Component decoration specified for type")); EXPECT_THAT(getDiagnosticString(), HasSubstr("is not a scalar or vector")); } std::string ShaderWithComponentDecoration(const std::string& type, const std::string& decoration) { return R"( OpCapability Shader OpCapability Int64 OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %entryPointOutput OpExecutionMode %main OriginUpperLeft OpDecorate %entryPointOutput Location 0 OpDecorate %entryPointOutput )" + decoration + R"( %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint64 = OpTypeInt 64 0 %v2uint64 = OpTypeVector %uint64 2 %v3uint64 = OpTypeVector %uint64 3 %uint_2 = OpConstant %uint 2 %arr_v3float_uint_2 = OpTypeArray %v3float %uint_2 %float_0 = OpConstant %float 0 %_ptr_Output_type = OpTypePointer Output %)" + type + R"( %entryPointOutput = OpVariable %_ptr_Output_type Output %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; } TEST_F(ValidateDecorations, ComponentDecorationIntGood0Vulkan) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = ShaderWithComponentDecoration("uint", "Component 0"); CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(env)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, ComponentDecorationIntGood1Vulkan) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = ShaderWithComponentDecoration("uint", "Component 1"); CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(env)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, ComponentDecorationIntGood2Vulkan) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = ShaderWithComponentDecoration("uint", "Component 2"); CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(env)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, ComponentDecorationIntGood3Vulkan) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = ShaderWithComponentDecoration("uint", "Component 3"); CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(env)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, ComponentDecorationIntBad4Vulkan) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = ShaderWithComponentDecoration("uint", "Component 4"); CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(env)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Component-04920")); EXPECT_THAT( getDiagnosticString(), HasSubstr("Component decoration value must not be greater than 3")); } TEST_F(ValidateDecorations, ComponentDecorationVector3GoodVulkan) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = ShaderWithComponentDecoration("v3float", "Component 1"); CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(env)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, ComponentDecorationVector4GoodVulkan) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = ShaderWithComponentDecoration("v4float", "Component 0"); CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(env)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, ComponentDecorationVector4Bad1Vulkan) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = ShaderWithComponentDecoration("v4float", "Component 1"); CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(env)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Component-04921")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Sequence of components starting with 1 " "and ending with 4 gets larger than 3")); } TEST_F(ValidateDecorations, ComponentDecorationVector4Bad3Vulkan) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = ShaderWithComponentDecoration("v4float", "Component 3"); CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(env)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Component-04921")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Sequence of components starting with 3 " "and ending with 6 gets larger than 3")); } TEST_F(ValidateDecorations, ComponentDecorationArrayGoodVulkan) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = ShaderWithComponentDecoration("arr_v3float_uint_2", "Component 1"); CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(env)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, ComponentDecorationArrayBadVulkan) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = ShaderWithComponentDecoration("arr_v3float_uint_2", "Component 2"); CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(env)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Component-04921")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Sequence of components starting with 2 " "and ending with 4 gets larger than 3")); } TEST_F(ValidateDecorations, ComponentDecoration64ScalarGoodVulkan) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = ShaderWithComponentDecoration("uint64", "Component 0"); CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(env)); } TEST_F(ValidateDecorations, ComponentDecoration64Scalar1BadVulkan) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = ShaderWithComponentDecoration("uint64", "Component 1"); CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(env)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Component-04923")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Component decoration value must not be 1 or 3 for " "64-bit data types")); } TEST_F(ValidateDecorations, ComponentDecoration64Scalar2GoodVulkan) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = ShaderWithComponentDecoration("uint64", "Component 2"); CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(env)); } TEST_F(ValidateDecorations, ComponentDecoration64Scalar3BadVulkan) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = ShaderWithComponentDecoration("uint64", "Component 3"); CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(env)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Component-04923")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Component decoration value must not be 1 or 3 for " "64-bit data types")); } TEST_F(ValidateDecorations, ComponentDecoration64Vec0GoodVulkan) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = ShaderWithComponentDecoration("v2uint64", "Component 0"); CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(env)); } TEST_F(ValidateDecorations, ComponentDecoration64Vec1BadVulkan) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = ShaderWithComponentDecoration("v2uint64", "Component 1"); CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(env)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Component-04923")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Component decoration value must not be 1 or 3 for " "64-bit data types")); } TEST_F(ValidateDecorations, ComponentDecoration64Vec2BadVulkan) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = ShaderWithComponentDecoration("v2uint64", "Component 2"); CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(env)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Component-04922")); HasSubstr( "Sequence of components starting with 2 " "and ending with 6 gets larger than 3"); } TEST_F(ValidateDecorations, ComponentDecoration64VecWideBadVulkan) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = ShaderWithComponentDecoration("v3uint64", "Component 0"); CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(env)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Component-07703")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Component decoration only allowed on 64-bit scalar " "and 2-component vector")); } TEST_F(ValidateDecorations, ComponentDecorationBlockGood) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %9 %12 OpExecutionMode %4 OriginUpperLeft OpDecorate %9 Location 0 OpMemberDecorate %block 0 Location 2 OpMemberDecorate %block 0 Component 1 OpDecorate %block Block %2 = OpTypeVoid %3 = OpTypeFunction %2 %float = OpTypeFloat 32 %vec3 = OpTypeVector %float 3 %8 = OpTypePointer Output %vec3 %9 = OpVariable %8 Output %block = OpTypeStruct %vec3 %11 = OpTypePointer Input %block %12 = OpVariable %11 Input %int = OpTypeInt 32 1 %14 = OpConstant %int 0 %15 = OpTypePointer Input %vec3 %4 = OpFunction %2 None %3 %5 = OpLabel %16 = OpAccessChain %15 %12 %14 %17 = OpLoad %vec3 %16 OpStore %9 %17 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateDecorations, ComponentDecorationBlockBadVulkan) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %9 %12 OpExecutionMode %4 OriginUpperLeft OpDecorate %9 Location 0 OpMemberDecorate %block 0 Location 2 OpMemberDecorate %block 0 Component 2 OpDecorate %block Block %2 = OpTypeVoid %3 = OpTypeFunction %2 %float = OpTypeFloat 32 %vec3 = OpTypeVector %float 3 %8 = OpTypePointer Output %vec3 %9 = OpVariable %8 Output %block = OpTypeStruct %vec3 %11 = OpTypePointer Input %block %12 = OpVariable %11 Input %int = OpTypeInt 32 1 %14 = OpConstant %int 0 %15 = OpTypePointer Input %vec3 %4 = OpFunction %2 None %3 %5 = OpLabel %16 = OpAccessChain %15 %12 %14 %17 = OpLoad %vec3 %16 OpStore %9 %17 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(env)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Component-04921")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Sequence of components starting with 2 " "and ending with 4 gets larger than 3")); } TEST_F(ValidateDecorations, ComponentDecorationFunctionParameter) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpDecorate %param_f Component 0 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %int = OpTypeInt 32 0 %int_2 = OpConstant %int 2 %struct_b = OpTypeStruct %float %extra_fn = OpTypeFunction %void %float %helper = OpFunction %void None %extra_fn %param_f = OpFunctionParameter %float %helper_label = OpLabel OpReturn OpFunctionEnd %main = OpFunction %void None %void_fn %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be a pointer type")); } TEST_F(ValidateDecorations, VulkanStorageBufferBlock) { const std::string spirv = R"( OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %uint = OpTypeInt 32 0 %struct = OpTypeStruct %uint %ptr_ssbo = OpTypePointer StorageBuffer %struct %var = OpVariable %ptr_ssbo StorageBuffer %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateDecorations, VulkanStorageBufferMissingBlock) { const std::string spirv = R"( OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %uint = OpTypeInt 32 0 %struct = OpTypeStruct %uint %ptr_ssbo = OpTypePointer StorageBuffer %struct %var = OpVariable %ptr_ssbo StorageBuffer %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-PushConstant-06675")); EXPECT_THAT(getDiagnosticString(), HasSubstr("From Vulkan spec:\nSuch variables " "must be identified with a Block decoration")); } TEST_F(ValidateDecorations, VulkanStorageBufferArrayMissingBlock) { const std::string spirv = R"( OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_4 = OpConstant %uint 4 %struct = OpTypeStruct %uint %array = OpTypeArray %struct %uint_4 %ptr_ssbo = OpTypePointer StorageBuffer %array %var = OpVariable %ptr_ssbo StorageBuffer %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-PushConstant-06675")); EXPECT_THAT(getDiagnosticString(), HasSubstr("From Vulkan spec:\nSuch variables " "must be identified with a Block decoration")); } TEST_F(ValidateDecorations, VulkanStorageBufferRuntimeArrayMissingBlock) { const std::string spirv = R"( OpCapability Shader OpCapability RuntimeDescriptorArrayEXT OpExtension "SPV_EXT_descriptor_indexing" OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %uint = OpTypeInt 32 0 %struct = OpTypeStruct %uint %array = OpTypeRuntimeArray %struct %ptr_ssbo = OpTypePointer StorageBuffer %array %var = OpVariable %ptr_ssbo StorageBuffer %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-PushConstant-06675")); EXPECT_THAT(getDiagnosticString(), HasSubstr("From Vulkan spec:\nSuch variables " "must be identified with a Block decoration")); } TEST_F(ValidateDecorations, VulkanUniformBlock) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %uint = OpTypeInt 32 0 %struct = OpTypeStruct %uint %ptr_ubo = OpTypePointer Uniform %struct %var = OpVariable %ptr_ubo Uniform %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateDecorations, VulkanUniformBufferBlock) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %struct BufferBlock OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %uint = OpTypeInt 32 0 %struct = OpTypeStruct %uint %ptr_ubo = OpTypePointer Uniform %struct %var = OpVariable %ptr_ubo Uniform %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateDecorations, VulkanUniformMissingBlock) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %uint = OpTypeInt 32 0 %struct = OpTypeStruct %uint %ptr_ubo = OpTypePointer Uniform %struct %var = OpVariable %ptr_ubo Uniform %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Uniform-06676")); EXPECT_THAT(getDiagnosticString(), HasSubstr("From Vulkan spec:\nSuch variables must be " "identified with a Block or BufferBlock decoration")); } TEST_F(ValidateDecorations, VulkanUniformArrayMissingBlock) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_4 = OpConstant %uint 4 %struct = OpTypeStruct %uint %array = OpTypeArray %struct %uint_4 %ptr_ubo = OpTypePointer Uniform %array %var = OpVariable %ptr_ubo Uniform %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Uniform-06676")); EXPECT_THAT(getDiagnosticString(), HasSubstr("From Vulkan spec:\nSuch variables must be " "identified with a Block or BufferBlock decoration")); } TEST_F(ValidateDecorations, VulkanUniformRuntimeArrayMissingBlock) { const std::string spirv = R"( OpCapability Shader OpCapability RuntimeDescriptorArrayEXT OpExtension "SPV_EXT_descriptor_indexing" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %uint = OpTypeInt 32 0 %struct = OpTypeStruct %uint %array = OpTypeRuntimeArray %struct %ptr_ubo = OpTypePointer Uniform %array %var = OpVariable %ptr_ubo Uniform %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Uniform-06676")); EXPECT_THAT(getDiagnosticString(), HasSubstr("From Vulkan spec:\nSuch variables must be " "identified with a Block or BufferBlock decoration")); } TEST_F(ValidateDecorations, VulkanArrayStrideZero) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 OpDecorate %array ArrayStride 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_4 = OpConstant %int 4 %array = OpTypeArray %int %int_4 %struct = OpTypeStruct %array %ptr_ssbo_struct = OpTypePointer StorageBuffer %struct %var = OpVariable %ptr_ssbo_struct StorageBuffer %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), HasSubstr("contains an array with stride 0")); } TEST_F(ValidateDecorations, VulkanArrayStrideTooSmall) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 OpDecorate %inner ArrayStride 4 OpDecorate %outer ArrayStride 4 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_4 = OpConstant %int 4 %inner = OpTypeArray %int %int_4 %outer = OpTypeArray %inner %int_4 %struct = OpTypeStruct %outer %ptr_ssbo_struct = OpTypePointer StorageBuffer %struct %var = OpVariable %ptr_ssbo_struct StorageBuffer %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "contains an array with stride 4, but with an element size of 16")); } TEST_F(ValidateDecorations, FunctionsWithOpGroupDecorate) { std::string spirv = R"( OpCapability Addresses OpCapability Linkage OpCapability Kernel OpCapability Int8 %1 = OpExtInstImport "OpenCL.std" OpMemoryModel Physical32 OpenCL OpName %foo "foo" OpName %entry "entry" OpName %bar "bar" OpName %entry_0 "entry" OpName %k "k" OpName %entry_1 "entry" OpName %b "b" OpDecorate %28 FuncParamAttr Zext %28 = OpDecorationGroup OpDecorate %k LinkageAttributes "k" Export OpDecorate %foo LinkageAttributes "foo" Export OpDecorate %bar LinkageAttributes "bar" Export OpDecorate %b Alignment 1 OpGroupDecorate %28 %foo %bar %uchar = OpTypeInt 8 0 %bool = OpTypeBool %3 = OpTypeFunction %bool %void = OpTypeVoid %10 = OpTypeFunction %void %_ptr_Function_uchar = OpTypePointer Function %uchar %true = OpConstantTrue %bool %foo = OpFunction %bool DontInline %3 %entry = OpLabel OpReturnValue %true OpFunctionEnd %bar = OpFunction %bool DontInline %3 %entry_0 = OpLabel OpReturnValue %true OpFunctionEnd %k = OpFunction %void DontInline %10 %entry_1 = OpLabel %b = OpVariable %_ptr_Function_uchar Function OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()); } TEST_F(ValidateDecorations, LocationVariableGood) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %in_var Location 0 %float = OpTypeFloat 32 %ptr_input_float = OpTypePointer Input %float %in_var = OpVariable %ptr_input_float Input )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateDecorations, LocationStructMemberGood) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpMemberDecorate %struct 0 Location 0 %float = OpTypeFloat 32 %struct = OpTypeStruct %float )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateDecorations, LocationStructBad) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %struct Location 0 %float = OpTypeFloat 32 %struct = OpTypeStruct %float )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be a variable")); } TEST_F(ValidateDecorations, LocationFloatBad) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %float Location 0 %float = OpTypeFloat 32 )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be a variable")); } TEST_F(ValidateDecorations, WorkgroupSingleBlockVariable) { std::string spirv = R"( OpCapability Shader OpCapability WorkgroupMemoryExplicitLayoutKHR OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %_ OpExecutionMode %main LocalSize 8 1 1 OpMemberDecorate %first 0 Offset 0 OpDecorate %first Block %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %first = OpTypeStruct %int %_ptr_Workgroup_first = OpTypePointer Workgroup %first %_ = OpVariable %_ptr_Workgroup_first Workgroup %int_0 = OpConstant %int 0 %int_2 = OpConstant %int 2 %_ptr_Workgroup_int = OpTypePointer Workgroup %int %main = OpFunction %void None %3 %5 = OpLabel %13 = OpAccessChain %_ptr_Workgroup_int %_ %int_0 OpStore %13 %int_2 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_UNIVERSAL_1_4)); } TEST_F(ValidateDecorations, WorkgroupBlockVariableRequiresV14) { std::string spirv = R"( OpCapability Shader OpCapability WorkgroupMemoryExplicitLayoutKHR OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %_ OpExecutionMode %main LocalSize 8 1 1 OpMemberDecorate %first 0 Offset 0 OpDecorate %first Block %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %first = OpTypeStruct %int %_ptr_Workgroup_first = OpTypePointer Workgroup %first %_ = OpVariable %_ptr_Workgroup_first Workgroup %int_0 = OpConstant %int 0 %int_2 = OpConstant %int 2 %_ptr_Workgroup_int = OpTypePointer Workgroup %int %main = OpFunction %void None %3 %5 = OpLabel %13 = OpAccessChain %_ptr_Workgroup_int %_ %int_0 OpStore %13 %int_2 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_WRONG_VERSION, ValidateAndRetrieveValidationState(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("requires SPIR-V version 1.4 or later")); } TEST_F(ValidateDecorations, WorkgroupSingleNonBlockVariable) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %a OpExecutionMode %main LocalSize 8 1 1 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Workgroup_int = OpTypePointer Workgroup %int %a = OpVariable %_ptr_Workgroup_int Workgroup %int_2 = OpConstant %int 2 %main = OpFunction %void None %3 %5 = OpLabel OpStore %a %int_2 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_UNIVERSAL_1_4)); } TEST_F(ValidateDecorations, WorkgroupMultiBlockVariable) { std::string spirv = R"( OpCapability Shader OpCapability WorkgroupMemoryExplicitLayoutKHR OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %_ %__0 OpExecutionMode %main LocalSize 8 1 1 OpMemberDecorate %first 0 Offset 0 OpDecorate %first Block OpMemberDecorate %second 0 Offset 0 OpDecorate %second Block OpDecorate %_ Aliased OpDecorate %__0 Aliased %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %first = OpTypeStruct %int %_ptr_Workgroup_first = OpTypePointer Workgroup %first %_ = OpVariable %_ptr_Workgroup_first Workgroup %int_0 = OpConstant %int 0 %int_2 = OpConstant %int 2 %_ptr_Workgroup_int = OpTypePointer Workgroup %int %second = OpTypeStruct %int %_ptr_Workgroup_second = OpTypePointer Workgroup %second %__0 = OpVariable %_ptr_Workgroup_second Workgroup %int_3 = OpConstant %int 3 %main = OpFunction %void None %3 %5 = OpLabel %13 = OpAccessChain %_ptr_Workgroup_int %_ %int_0 OpStore %13 %int_2 %18 = OpAccessChain %_ptr_Workgroup_int %__0 %int_0 OpStore %18 %int_3 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_UNIVERSAL_1_4)); } TEST_F(ValidateDecorations, WorkgroupBlockVariableWith8BitType) { std::string spirv = R"( OpCapability Shader OpCapability Int8 OpCapability WorkgroupMemoryExplicitLayout8BitAccessKHR OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %_ OpExecutionMode %main LocalSize 2 1 1 OpMemberDecorate %first 0 Offset 0 OpDecorate %first Block %void = OpTypeVoid %3 = OpTypeFunction %void %char = OpTypeInt 8 1 %first = OpTypeStruct %char %_ptr_Workgroup_first = OpTypePointer Workgroup %first %_ = OpVariable %_ptr_Workgroup_first Workgroup %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %char_2 = OpConstant %char 2 %_ptr_Workgroup_char = OpTypePointer Workgroup %char %main = OpFunction %void None %3 %5 = OpLabel %14 = OpAccessChain %_ptr_Workgroup_char %_ %int_0 OpStore %14 %char_2 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_UNIVERSAL_1_4)); } TEST_F(ValidateDecorations, WorkgroupMultiNonBlockVariable) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %a %b OpExecutionMode %main LocalSize 8 1 1 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Workgroup_int = OpTypePointer Workgroup %int %a = OpVariable %_ptr_Workgroup_int Workgroup %int_2 = OpConstant %int 2 %b = OpVariable %_ptr_Workgroup_int Workgroup %int_3 = OpConstant %int 3 %main = OpFunction %void None %3 %5 = OpLabel OpStore %a %int_2 OpStore %b %int_3 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_UNIVERSAL_1_4)); } TEST_F(ValidateDecorations, WorkgroupBlockVariableWith16BitType) { std::string spirv = R"( OpCapability Shader OpCapability Float16 OpCapability Int16 OpCapability WorkgroupMemoryExplicitLayoutKHR OpCapability WorkgroupMemoryExplicitLayout16BitAccessKHR OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %_ OpExecutionMode %main LocalSize 2 1 1 OpMemberDecorate %first 0 Offset 0 OpMemberDecorate %first 1 Offset 2 OpDecorate %first Block %void = OpTypeVoid %3 = OpTypeFunction %void %short = OpTypeInt 16 1 %half = OpTypeFloat 16 %first = OpTypeStruct %short %half %_ptr_Workgroup_first = OpTypePointer Workgroup %first %_ = OpVariable %_ptr_Workgroup_first Workgroup %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %short_3 = OpConstant %short 3 %_ptr_Workgroup_short = OpTypePointer Workgroup %short %int_1 = OpConstant %int 1 %half_0x1_898p_3 = OpConstant %half 0x1.898p+3 %_ptr_Workgroup_half = OpTypePointer Workgroup %half %main = OpFunction %void None %3 %5 = OpLabel %15 = OpAccessChain %_ptr_Workgroup_short %_ %int_0 OpStore %15 %short_3 %19 = OpAccessChain %_ptr_Workgroup_half %_ %int_1 OpStore %19 %half_0x1_898p_3 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_UNIVERSAL_1_4)); } TEST_F(ValidateDecorations, WorkgroupBlockVariableScalarLayout) { std::string spirv = R"( OpCapability Shader OpCapability WorkgroupMemoryExplicitLayoutKHR OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %B OpSource GLSL 450 OpMemberDecorate %S 0 Offset 0 OpMemberDecorate %S 1 Offset 4 OpMemberDecorate %S 2 Offset 16 OpMemberDecorate %S 3 Offset 28 OpDecorate %S Block OpDecorate %B Aliased %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %S = OpTypeStruct %float %v3float %v3float %v3float %_ptr_Workgroup_S = OpTypePointer Workgroup %S %B = OpVariable %_ptr_Workgroup_S Workgroup %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); spvValidatorOptionsSetWorkgroupScalarBlockLayout(getValidatorOptions(), true); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_UNIVERSAL_1_4)) << getDiagnosticString(); } TEST_F(ValidateDecorations, WorkgroupMixBlockAndNonBlockBad) { std::string spirv = R"( OpCapability Shader OpCapability WorkgroupMemoryExplicitLayoutKHR OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %_ %b OpExecutionMode %main LocalSize 8 1 1 OpMemberDecorate %first 0 Offset 0 OpDecorate %first Block OpDecorate %_ Aliased OpDecorate %b Aliased %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %first = OpTypeStruct %int %_ptr_Workgroup_first = OpTypePointer Workgroup %first %_ = OpVariable %_ptr_Workgroup_first Workgroup %int_0 = OpConstant %int 0 %int_2 = OpConstant %int 2 %_ptr_Workgroup_int = OpTypePointer Workgroup %int %b = OpVariable %_ptr_Workgroup_int Workgroup %int_3 = OpConstant %int 3 %main = OpFunction %void None %3 %5 = OpLabel %13 = OpAccessChain %_ptr_Workgroup_int %_ %int_0 OpStore %13 %int_2 OpStore %b %int_3 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_BINARY, ValidateAndRetrieveValidationState(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("either all or none of the Workgroup Storage Class variables " "in the entry point interface must point to struct types " "decorated with Block")); } TEST_F(ValidateDecorations, WorkgroupMultiBlockVariableMissingAliased) { std::string spirv = R"( OpCapability Shader OpCapability WorkgroupMemoryExplicitLayoutKHR OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %_ %__0 OpExecutionMode %main LocalSize 8 1 1 OpMemberDecorate %first 0 Offset 0 OpDecorate %first Block OpMemberDecorate %second 0 Offset 0 OpDecorate %second Block OpDecorate %_ Aliased %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %first = OpTypeStruct %int %_ptr_Workgroup_first = OpTypePointer Workgroup %first %_ = OpVariable %_ptr_Workgroup_first Workgroup %int_0 = OpConstant %int 0 %int_2 = OpConstant %int 2 %_ptr_Workgroup_int = OpTypePointer Workgroup %int %second = OpTypeStruct %int %_ptr_Workgroup_second = OpTypePointer Workgroup %second %__0 = OpVariable %_ptr_Workgroup_second Workgroup %int_3 = OpConstant %int 3 %main = OpFunction %void None %3 %5 = OpLabel %13 = OpAccessChain %_ptr_Workgroup_int %_ %int_0 OpStore %13 %int_2 %18 = OpAccessChain %_ptr_Workgroup_int %__0 %int_0 OpStore %18 %int_3 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_BINARY, ValidateAndRetrieveValidationState(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("more than one Workgroup Storage Class variable in the " "entry point interface point to a type decorated with Block, " "all of them must be decorated with Aliased")); } TEST_F(ValidateDecorations, WorkgroupSingleBlockVariableNotAStruct) { std::string spirv = R"( OpCapability Shader OpCapability WorkgroupMemoryExplicitLayoutKHR OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %_ OpExecutionMode %main LocalSize 8 1 1 OpDecorate %first Block %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %int_3 = OpConstant %int 3 %first = OpTypeArray %int %int_3 %_ptr_Workgroup_first = OpTypePointer Workgroup %first %_ = OpVariable %_ptr_Workgroup_first Workgroup %int_0 = OpConstant %int 0 %int_2 = OpConstant %int 2 %_ptr_Workgroup_int = OpTypePointer Workgroup %int %main = OpFunction %void None %3 %5 = OpLabel %13 = OpAccessChain %_ptr_Workgroup_int %_ %int_0 OpStore %13 %int_2 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be a structure type")); } TEST_F(ValidateDecorations, WorkgroupSingleBlockVariableMissingLayout) { std::string spirv = R"( OpCapability Shader OpCapability WorkgroupMemoryExplicitLayoutKHR OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %_ OpExecutionMode %main LocalSize 8 1 1 OpDecorate %first Block %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %first = OpTypeStruct %int %_ptr_Workgroup_first = OpTypePointer Workgroup %first %_ = OpVariable %_ptr_Workgroup_first Workgroup %int_0 = OpConstant %int 0 %int_2 = OpConstant %int 2 %_ptr_Workgroup_int = OpTypePointer Workgroup %int %main = OpFunction %void None %3 %5 = OpLabel %13 = OpAccessChain %_ptr_Workgroup_int %_ %int_0 OpStore %13 %int_2 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_1_SPIRV_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Block must be explicitly laid out with Offset decorations")); } TEST_F(ValidateDecorations, WorkgroupSingleBlockVariableBadLayout) { std::string spirv = R"( OpCapability Shader OpCapability WorkgroupMemoryExplicitLayoutKHR OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %_ OpExecutionMode %main LocalSize 8 1 1 OpMemberDecorate %first 0 Offset 1 OpDecorate %first Block %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %first = OpTypeStruct %int %_ptr_Workgroup_first = OpTypePointer Workgroup %first %_ = OpVariable %_ptr_Workgroup_first Workgroup %int_0 = OpConstant %int 0 %int_2 = OpConstant %int 2 %_ptr_Workgroup_int = OpTypePointer Workgroup %int %main = OpFunction %void None %3 %5 = OpLabel %13 = OpAccessChain %_ptr_Workgroup_int %_ %int_0 OpStore %13 %int_2 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_1_SPIRV_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Block for variable in Workgroup storage class must follow " "relaxed storage buffer layout rules: " "member 0 at offset 1 is not aligned to 4")); } TEST_F(ValidateDecorations, WorkgroupBlockNoCapability) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %_ OpExecutionMode %main LocalSize 1 1 1 OpMemberDecorate %struct 0 Offset 0 OpMemberDecorate %struct 1 Offset 4 OpDecorate %struct Block %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %struct = OpTypeStruct %int %int %ptr_workgroup = OpTypePointer Workgroup %struct %_ = OpVariable %ptr_workgroup Workgroup %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_BINARY, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_1_SPIRV_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Workgroup Storage Class variables can't be decorated with Block " "unless declaring the WorkgroupMemoryExplicitLayoutKHR capability")); } TEST_F(ValidateDecorations, BadMatrixStrideUniform) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %block Block OpMemberDecorate %block 0 Offset 0 OpMemberDecorate %block 0 MatrixStride 3 OpMemberDecorate %block 0 ColMajor OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 %void = OpTypeVoid %float = OpTypeFloat 32 %float4 = OpTypeVector %float 4 %matrix4x4 = OpTypeMatrix %float4 4 %block = OpTypeStruct %matrix4x4 %block_ptr = OpTypePointer Uniform %block %var = OpVariable %block_ptr Uniform %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Structure id 2 decorated as Block for variable in Uniform storage " "class must follow standard uniform buffer layout rules: member 0 is " "a matrix with stride 3 not satisfying alignment to 16")); } TEST_F(ValidateDecorations, BadMatrixStrideStorageBuffer) { const std::string spirv = R"( OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %block Block OpMemberDecorate %block 0 Offset 0 OpMemberDecorate %block 0 MatrixStride 3 OpMemberDecorate %block 0 ColMajor OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 %void = OpTypeVoid %float = OpTypeFloat 32 %float4 = OpTypeVector %float 4 %matrix4x4 = OpTypeMatrix %float4 4 %block = OpTypeStruct %matrix4x4 %block_ptr = OpTypePointer StorageBuffer %block %var = OpVariable %block_ptr StorageBuffer %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Structure id 2 decorated as Block for variable in StorageBuffer " "storage class must follow standard storage buffer layout rules: " "member 0 is a matrix with stride 3 not satisfying alignment to 16")); } TEST_F(ValidateDecorations, BadMatrixStridePushConstant) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %block Block OpMemberDecorate %block 0 Offset 0 OpMemberDecorate %block 0 MatrixStride 3 OpMemberDecorate %block 0 ColMajor %void = OpTypeVoid %float = OpTypeFloat 32 %float4 = OpTypeVector %float 4 %matrix4x4 = OpTypeMatrix %float4 4 %block = OpTypeStruct %matrix4x4 %block_ptr = OpTypePointer PushConstant %block %var = OpVariable %block_ptr PushConstant %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Structure id 2 decorated as Block for variable in PushConstant " "storage class must follow standard storage buffer layout rules: " "member 0 is a matrix with stride 3 not satisfying alignment to 16")); } TEST_F(ValidateDecorations, BadMatrixStrideStorageBufferScalarLayout) { const std::string spirv = R"( OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %block Block OpMemberDecorate %block 0 Offset 0 OpMemberDecorate %block 0 MatrixStride 3 OpMemberDecorate %block 0 RowMajor OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 %void = OpTypeVoid %float = OpTypeFloat 32 %float4 = OpTypeVector %float 4 %matrix4x4 = OpTypeMatrix %float4 4 %block = OpTypeStruct %matrix4x4 %block_ptr = OpTypePointer StorageBuffer %block %var = OpVariable %block_ptr StorageBuffer %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; options_->scalar_block_layout = true; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Structure id 2 decorated as Block for variable in StorageBuffer " "storage class must follow scalar storage buffer layout rules: " "member 0 is a matrix with stride 3 not satisfying alignment to 4")); } TEST_F(ValidateDecorations, MissingOffsetStructNestedInArray) { const std::string spirv = R"( OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %array ArrayStride 4 OpDecorate %outer Block OpMemberDecorate %outer 0 Offset 0 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_4 = OpConstant %int 4 %inner = OpTypeStruct %int %array = OpTypeArray %inner %int_4 %outer = OpTypeStruct %array %ptr_ssbo_outer = OpTypePointer StorageBuffer %outer %var = OpVariable %ptr_ssbo_outer StorageBuffer %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Structure id 3 decorated as Block must be explicitly " "laid out with Offset decorations")); } TEST_F(ValidateDecorations, AllOnesOffset) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 OpDecorate %outer Block OpMemberDecorate %outer 0 Offset 0 OpMemberDecorate %struct 0 Offset 4294967295 %void = OpTypeVoid %int = OpTypeInt 32 0 %struct = OpTypeStruct %int %outer = OpTypeStruct %struct %ptr = OpTypePointer Uniform %outer %var = OpVariable %ptr Uniform %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("decorated as Block must be explicitly laid out with " "Offset decorations")); } TEST_F(ValidateDecorations, PerVertexVulkanGood) { const std::string spirv = R"( OpCapability Shader OpCapability FragmentBarycentricKHR OpExtension "SPV_KHR_fragment_shader_barycentric" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %vertexIDs OpExecutionMode %main OriginUpperLeft OpDecorate %vertexIDs Location 0 OpDecorate %vertexIDs PerVertexKHR %void = OpTypeVoid %func = OpTypeFunction %void %float = OpTypeFloat 32 %uint = OpTypeInt 32 0 %ptrFloat = OpTypePointer Input %float %uint_3 = OpConstant %uint 3 %floatArray = OpTypeArray %float %uint_3 %ptrFloatArray = OpTypePointer Input %floatArray %vertexIDs = OpVariable %ptrFloatArray Input %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %main = OpFunction %void None %func %label = OpLabel %access = OpAccessChain %ptrFloat %vertexIDs %int_0 %load = OpLoad %float %access OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateDecorations, PerVertexVulkanOutput) { const std::string spirv = R"( OpCapability Shader OpCapability FragmentBarycentricKHR OpExtension "SPV_KHR_fragment_shader_barycentric" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %vertexIDs OpExecutionMode %main OriginUpperLeft OpDecorate %vertexIDs Location 0 OpDecorate %vertexIDs PerVertexKHR %void = OpTypeVoid %func = OpTypeFunction %void %float = OpTypeFloat 32 %uint = OpTypeInt 32 0 %ptrFloat = OpTypePointer Output %float %uint_3 = OpConstant %uint 3 %floatArray = OpTypeArray %float %uint_3 %ptrFloatArray = OpTypePointer Output %floatArray %vertexIDs = OpVariable %ptrFloatArray Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %main = OpFunction %void None %func %label = OpLabel %access = OpAccessChain %ptrFloat %vertexIDs %int_0 %load = OpLoad %float %access OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-PerVertexKHR-06777")); EXPECT_THAT(getDiagnosticString(), HasSubstr("storage class must be Input")); } TEST_F(ValidateDecorations, PerVertexVulkanNonFragment) { const std::string spirv = R"( OpCapability Shader OpCapability FragmentBarycentricKHR OpExtension "SPV_KHR_fragment_shader_barycentric" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %vertexIDs OpDecorate %vertexIDs Location 0 OpDecorate %vertexIDs PerVertexKHR %void = OpTypeVoid %func = OpTypeFunction %void %float = OpTypeFloat 32 %uint = OpTypeInt 32 0 %ptrFloat = OpTypePointer Input %float %uint_3 = OpConstant %uint 3 %floatArray = OpTypeArray %float %uint_3 %ptrFloatArray = OpTypePointer Input %floatArray %vertexIDs = OpVariable %ptrFloatArray Input %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %main = OpFunction %void None %func %label = OpLabel %access = OpAccessChain %ptrFloat %vertexIDs %int_0 %load = OpLoad %float %access OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-PerVertexKHR-06777")); EXPECT_THAT( getDiagnosticString(), HasSubstr( "PerVertexKHR can only be applied to Fragment Execution Models")); } TEST_F(ValidateDecorations, PerVertexVulkanNonArray) { const std::string spirv = R"( OpCapability Shader OpCapability FragmentBarycentricKHR OpExtension "SPV_KHR_fragment_shader_barycentric" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %vertexIDs OpExecutionMode %main OriginUpperLeft OpDecorate %vertexIDs Location 0 OpDecorate %vertexIDs PerVertexKHR %void = OpTypeVoid %func = OpTypeFunction %void %float = OpTypeFloat 32 %ptrFloat = OpTypePointer Input %float %vertexIDs = OpVariable %ptrFloat Input %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %main = OpFunction %void None %func %label = OpLabel %load = OpLoad %float %vertexIDs OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Input-06778")); EXPECT_THAT(getDiagnosticString(), HasSubstr("PerVertexKHR must be declared as arrays")); } TEST_F(ValidateDecorations, RelaxedPrecisionDecorationOnNumericTypeBad) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpDecorate %float RelaxedPrecision %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %main = OpFunction %void None %voidfn %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(env)); EXPECT_THAT( getDiagnosticString(), HasSubstr("RelaxPrecision decoration cannot be applied to a type")); } TEST_F(ValidateDecorations, RelaxedPrecisionDecorationOnStructMember) { const spv_target_env env = SPV_ENV_VULKAN_1_0; std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpMemberDecorate %struct 0 RelaxedPrecision %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %struct = OpTypeStruct %float %main = OpFunction %void None %voidfn %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(env)); } TEST_F(ValidateDecorations, VulkanFlatMultipleInterfaceGood) { std::string spirv = R"( OpCapability Shader OpCapability Geometry %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %layer %gl_Layer OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpDecorate %layer Location 0 OpDecorate %gl_Layer Flat OpDecorate %gl_Layer BuiltIn Layer %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Output_int = OpTypePointer Output %int %layer = OpVariable %_ptr_Output_int Output %_ptr_Input_int = OpTypePointer Input %int %gl_Layer = OpVariable %_ptr_Input_int Input %main = OpFunction %void None %3 %5 = OpLabel %11 = OpLoad %int %gl_Layer OpStore %layer %11 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateDecorations, VulkanFlatMultipleInterfaceBad) { std::string spirv = R"( OpCapability Shader OpCapability Geometry %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %layer %gl_Layer OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpDecorate %layer Location 0 OpDecorate %gl_Layer BuiltIn Layer %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Output_int = OpTypePointer Output %int %layer = OpVariable %_ptr_Output_int Output %_ptr_Input_int = OpTypePointer Input %int %gl_Layer = OpVariable %_ptr_Input_int Input %main = OpFunction %void None %3 %5 = OpLabel %11 = OpLoad %int %gl_Layer OpStore %layer %11 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Flat-04744")); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Fragment OpEntryPoint operand 4 with Input interfaces with integer " "or float type must have a Flat decoration for Entry Point id 2.")); } TEST_F(ValidateDecorations, VulkanNoFlatFloat32) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpDecorate %in Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %_ptr_Input_float = OpTypePointer Input %float %in = OpVariable %_ptr_Input_float Input %main = OpFunction %void None %3 %5 = OpLabel %b = OpVariable %_ptr_Function_float Function %11 = OpLoad %float %in OpStore %b %11 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateDecorations, VulkanNoFlatFloat64) { std::string spirv = R"( OpCapability Shader OpCapability Float64 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpDecorate %in Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %double = OpTypeFloat 64 %_ptr_Function_double = OpTypePointer Function %double %_ptr_Input_double = OpTypePointer Input %double %in = OpVariable %_ptr_Input_double Input %main = OpFunction %void None %3 %5 = OpLabel %b = OpVariable %_ptr_Function_double Function %11 = OpLoad %double %in OpStore %b %11 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Flat-04744")); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Fragment OpEntryPoint operand 3 with Input interfaces with integer " "or float type must have a Flat decoration for Entry Point id 2.")); } TEST_F(ValidateDecorations, VulkanNoFlatVectorFloat64) { std::string spirv = R"( OpCapability Shader OpCapability Float64 %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpDecorate %in Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %double = OpTypeFloat 64 %v2double = OpTypeVector %double 2 %_ptr_Function_v2double = OpTypePointer Function %v2double %_ptr_Input_v2double = OpTypePointer Input %v2double %in = OpVariable %_ptr_Input_v2double Input %main = OpFunction %void None %3 %5 = OpLabel %b = OpVariable %_ptr_Function_v2double Function %11 = OpLoad %v2double %in OpStore %b %11 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateDecorations, VulkanNoFlatIntVector) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpDecorate %in Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %v2int = OpTypeVector %int 2 %_ptr_Function_v2int = OpTypePointer Function %v2int %_ptr_Input_v2int = OpTypePointer Input %v2int %in = OpVariable %_ptr_Input_v2int Input %main = OpFunction %void None %3 %5 = OpLabel %b = OpVariable %_ptr_Function_v2int Function %12 = OpLoad %v2int %in OpStore %b %12 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Flat-04744")); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Fragment OpEntryPoint operand 3 with Input interfaces with integer " "or float type must have a Flat decoration for Entry Point id 2.")); } TEST_P(ValidateDecorationString, VulkanOutputInvalidInterface) { const std::string decoration = GetParam(); std::stringstream ss; ss << R"( OpCapability Shader OpCapability SampleRateShading %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %out OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpDecorate %out )" << decoration << R"( OpDecorate %out Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Output_int = OpTypePointer Output %int %out = OpVariable %_ptr_Output_int Output %int_1 = OpConstant %int 1 %main = OpFunction %void None %3 %5 = OpLabel OpStore %out %int_1 OpReturn OpFunctionEnd )"; CompileSuccessfully(ss.str(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Flat-06201")); EXPECT_THAT( getDiagnosticString(), HasSubstr("decorated variable must not be used in fragment execution " "model as an Output storage class for Entry Point id 2.")); } TEST_P(ValidateDecorationString, VulkanVertexInputInvalidInterface) { const std::string decoration = GetParam(); std::stringstream ss; ss << R"( OpCapability Shader OpCapability SampleRateShading %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %out %in OpSource GLSL 450 OpDecorate %in )" << decoration << R"( OpDecorate %out Location 0 OpDecorate %in Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Output_int = OpTypePointer Output %int %out = OpVariable %_ptr_Output_int Output %_ptr_Input_int = OpTypePointer Input %int %in = OpVariable %_ptr_Input_int Input %main = OpFunction %void None %3 %5 = OpLabel %11 = OpLoad %int %in OpStore %out %11 OpReturn OpFunctionEnd )"; CompileSuccessfully(ss.str(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Flat-06202")); EXPECT_THAT( getDiagnosticString(), HasSubstr("decorated variable must not be used in vertex execution model " "as an Input storage class for Entry Point id 2.")); } INSTANTIATE_TEST_SUITE_P(FragmentInputInterface, ValidateDecorationString, ::testing::Values("Flat", "NoPerspective", "Sample", "Centroid")); TEST_F(ValidateDecorations, NVBindlessSamplerArrayInBlock) { const std::string spirv = R"( OpCapability Shader OpCapability BindlessTextureNV OpExtension "SPV_NV_bindless_texture" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpSamplerImageAddressingModeNV 64 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %UBO "UBO" OpMemberName %UBO 0 "uboSampler" OpName %_ "" OpDecorate %array ArrayStride 16 OpMemberDecorate %UBO 0 Offset 0 OpDecorate %UBO Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 2 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %7 = OpTypeImage %float 2D 0 0 0 1 Unknown %8 = OpTypeSampledImage %7 %uint = OpTypeInt 32 0 %uint_3 = OpConstant %uint 3 %array = OpTypeArray %8 %uint_3 %UBO = OpTypeStruct %array %pointer = OpTypePointer Uniform %UBO %_ = OpVariable %pointer Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateDecorations, Std140ColMajorMat2x2) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %block Block OpMemberDecorate %block 0 Offset 0 OpMemberDecorate %block 0 ColMajor OpMemberDecorate %block 0 MatrixStride 8 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %float2 = OpTypeVector %float 2 %matrix = OpTypeMatrix %float2 2 %block = OpTypeStruct %matrix %ptr_block = OpTypePointer Uniform %block %var = OpVariable %ptr_block Uniform %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "member 0 is a matrix with stride 8 not satisfying alignment to 16")); } TEST_F(ValidateDecorations, Std140RowMajorMat2x2) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %block Block OpMemberDecorate %block 0 Offset 0 OpMemberDecorate %block 0 RowMajor OpMemberDecorate %block 0 MatrixStride 8 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %float2 = OpTypeVector %float 2 %matrix = OpTypeMatrix %float2 2 %block = OpTypeStruct %matrix %ptr_block = OpTypePointer Uniform %block %var = OpVariable %ptr_block Uniform %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "member 0 is a matrix with stride 8 not satisfying alignment to 16")); } TEST_F(ValidateDecorations, Std140ColMajorMat4x2) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %block Block OpMemberDecorate %block 0 Offset 0 OpMemberDecorate %block 0 ColMajor OpMemberDecorate %block 0 MatrixStride 8 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %float2 = OpTypeVector %float 2 %matrix = OpTypeMatrix %float2 4 %block = OpTypeStruct %matrix %ptr_block = OpTypePointer Uniform %block %var = OpVariable %ptr_block Uniform %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "member 0 is a matrix with stride 8 not satisfying alignment to 16")); } TEST_F(ValidateDecorations, Std140ColMajorMat2x3) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %block Block OpMemberDecorate %block 0 Offset 0 OpMemberDecorate %block 0 ColMajor OpMemberDecorate %block 0 MatrixStride 12 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %float3 = OpTypeVector %float 3 %matrix = OpTypeMatrix %float3 2 %block = OpTypeStruct %matrix %ptr_block = OpTypePointer Uniform %block %var = OpVariable %ptr_block Uniform %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("member 0 is a matrix with stride 12 not satisfying " "alignment to 16")); } TEST_F(ValidateDecorations, MatrixMissingMajornessUniform) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %block Block OpMemberDecorate %block 0 Offset 0 OpMemberDecorate %block 0 MatrixStride 16 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %float2 = OpTypeVector %float 2 %matrix = OpTypeMatrix %float2 2 %block = OpTypeStruct %matrix %ptr_block = OpTypePointer Uniform %block %var = OpVariable %ptr_block Uniform %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "must be explicitly laid out with RowMajor or ColMajor decorations")); } TEST_F(ValidateDecorations, MatrixMissingMajornessStorageBuffer) { const std::string spirv = R"( OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %block Block OpMemberDecorate %block 0 Offset 0 OpMemberDecorate %block 0 MatrixStride 16 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %float2 = OpTypeVector %float 2 %matrix = OpTypeMatrix %float2 2 %block = OpTypeStruct %matrix %ptr_block = OpTypePointer StorageBuffer %block %var = OpVariable %ptr_block StorageBuffer %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "must be explicitly laid out with RowMajor or ColMajor decorations")); } TEST_F(ValidateDecorations, MatrixMissingMajornessPushConstant) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %block Block OpMemberDecorate %block 0 Offset 0 OpMemberDecorate %block 0 MatrixStride 16 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %float2 = OpTypeVector %float 2 %matrix = OpTypeMatrix %float2 2 %block = OpTypeStruct %matrix %ptr_block = OpTypePointer PushConstant %block %var = OpVariable %ptr_block PushConstant %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "must be explicitly laid out with RowMajor or ColMajor decorations")); } TEST_F(ValidateDecorations, StructWithRowAndColMajor) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %block Block OpMemberDecorate %block 0 Offset 0 OpMemberDecorate %block 0 MatrixStride 16 OpMemberDecorate %block 0 ColMajor OpMemberDecorate %block 1 Offset 32 OpMemberDecorate %block 1 MatrixStride 16 OpMemberDecorate %block 1 RowMajor %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %float2 = OpTypeVector %float 2 %matrix = OpTypeMatrix %float2 2 %block = OpTypeStruct %matrix %matrix %ptr_block = OpTypePointer PushConstant %block %var = OpVariable %ptr_block PushConstant %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateDecorations, PhysicalStorageBufferWithOffset) { const std::string spirv = R"( OpCapability Shader OpCapability Int64 OpCapability PhysicalStorageBufferAddresses OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint GLCompute %main "main" %pc OpExecutionMode %main LocalSize 1 1 1 OpDecorate %pc_block Block OpMemberDecorate %pc_block 0 Offset 0 OpMemberDecorate %pssbo_struct 0 Offset 0 %void = OpTypeVoid %long = OpTypeInt 64 0 %float = OpTypeFloat 32 %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %pc_block = OpTypeStruct %long %pc_block_ptr = OpTypePointer PushConstant %pc_block %pc_long_ptr = OpTypePointer PushConstant %long %pc = OpVariable %pc_block_ptr PushConstant %pssbo_struct = OpTypeStruct %float %pssbo_ptr = OpTypePointer PhysicalStorageBuffer %pssbo_struct %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %pc_gep = OpAccessChain %pc_long_ptr %pc %int_0 %addr = OpLoad %long %pc_gep %ptr = OpConvertUToPtr %pssbo_ptr %addr OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_3)); } TEST_F(ValidateDecorations, UntypedVariableDuplicateInterface) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpCapability WorkgroupMemoryExplicitLayoutKHR OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %var %var OpName %var "var" OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %struct = OpTypeStruct %int %ptr = OpTypeUntypedPointerKHR Workgroup %var = OpUntypedVariableKHR %ptr Workgroup %struct %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Non-unique OpEntryPoint interface '2[%var]' is disallowed")); } TEST_F(ValidateDecorations, PhysicalStorageBufferMissingOffset) { const std::string spirv = R"( OpCapability Shader OpCapability Int64 OpCapability PhysicalStorageBufferAddresses OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint GLCompute %main "main" %pc OpExecutionMode %main LocalSize 1 1 1 OpDecorate %pc_block Block OpMemberDecorate %pc_block 0 Offset 0 %void = OpTypeVoid %long = OpTypeInt 64 0 %float = OpTypeFloat 32 %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %pc_block = OpTypeStruct %long %pc_block_ptr = OpTypePointer PushConstant %pc_block %pc_long_ptr = OpTypePointer PushConstant %long %pc = OpVariable %pc_block_ptr PushConstant %pssbo_struct = OpTypeStruct %float %pssbo_ptr = OpTypePointer PhysicalStorageBuffer %pssbo_struct %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %pc_gep = OpAccessChain %pc_long_ptr %pc %int_0 %addr = OpLoad %long %pc_gep %ptr = OpConvertUToPtr %pssbo_ptr %addr OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("decorated as Block for variable in PhysicalStorageBuffer " "storage class must follow relaxed storage buffer layout " "rules: member 0 is missing an Offset decoration")); } TEST_F(ValidateDecorations, PhysicalStorageBufferMissingArrayStride) { const std::string spirv = R"( OpCapability Shader OpCapability Int64 OpCapability PhysicalStorageBufferAddresses OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint GLCompute %main "main" %pc OpExecutionMode %main LocalSize 1 1 1 OpDecorate %pc_block Block OpMemberDecorate %pc_block 0 Offset 0 %void = OpTypeVoid %long = OpTypeInt 64 0 %float = OpTypeFloat 32 %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int_4 = OpConstant %int 4 %pc_block = OpTypeStruct %long %pc_block_ptr = OpTypePointer PushConstant %pc_block %pc_long_ptr = OpTypePointer PushConstant %long %pc = OpVariable %pc_block_ptr PushConstant %pssbo_array = OpTypeArray %float %int_4 %pssbo_ptr = OpTypePointer PhysicalStorageBuffer %pssbo_array %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %pc_gep = OpAccessChain %pc_long_ptr %pc %int_0 %addr = OpLoad %long %pc_gep %ptr = OpConvertUToPtr %pssbo_ptr %addr OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "decorated as Block for variable in PhysicalStorageBuffer storage " "class must follow relaxed storage buffer layout rules: member 0 " "contains an array with stride 0, but with an element size of 4")); } TEST_F(ValidateDecorations, MatrixArrayMissingMajorness) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 OpDecorate %block Block OpMemberDecorate %block 0 Offset 0 OpMemberDecorate %block 0 MatrixStride 16 OpDecorate %array ArrayStride 32 %void = OpTypeVoid %float = OpTypeFloat 32 %int = OpTypeInt 32 0 %int_2 = OpConstant %int 2 %vec = OpTypeVector %float 2 %mat = OpTypeMatrix %vec 2 %array = OpTypeArray %mat %int_2 %block = OpTypeStruct %array %ptr = OpTypePointer Uniform %block %var = OpVariable %ptr Uniform %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "must be explicitly laid out with RowMajor or ColMajor decorations")); } TEST_F(ValidateDecorations, MatrixArrayMissingStride) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 OpDecorate %block Block OpMemberDecorate %block 0 Offset 0 OpMemberDecorate %block 0 ColMajor OpDecorate %array ArrayStride 32 %void = OpTypeVoid %float = OpTypeFloat 32 %int = OpTypeInt 32 0 %int_2 = OpConstant %int 2 %vec = OpTypeVector %float 2 %mat = OpTypeMatrix %vec 2 %array = OpTypeArray %mat %int_2 %block = OpTypeStruct %array %ptr = OpTypePointer Uniform %block %var = OpVariable %ptr Uniform %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT( getDiagnosticString(), HasSubstr("must be explicitly laid out with MatrixStride decorations")); } TEST_F(ValidateDecorations, MatrixArrayBadStride) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 OpDecorate %block Block OpMemberDecorate %block 0 Offset 0 OpMemberDecorate %block 0 ColMajor OpMemberDecorate %block 0 MatrixStride 8 OpDecorate %array ArrayStride 32 %void = OpTypeVoid %float = OpTypeFloat 32 %int = OpTypeInt 32 0 %int_2 = OpConstant %int 2 %vec = OpTypeVector %float 2 %mat = OpTypeMatrix %vec 2 %array = OpTypeArray %mat %int_2 %block = OpTypeStruct %array %ptr = OpTypePointer Uniform %block %var = OpVariable %ptr Uniform %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT( getDiagnosticString(), HasSubstr("is a matrix with stride 8 not satisfying alignment to 16")); } TEST_F(ValidateDecorations, MatrixArrayArrayMissingMajorness) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 OpDecorate %block Block OpMemberDecorate %block 0 Offset 0 OpMemberDecorate %block 0 MatrixStride 16 OpDecorate %array ArrayStride 32 OpDecorate %rta ArrayStride 64 %void = OpTypeVoid %float = OpTypeFloat 32 %int = OpTypeInt 32 0 %int_2 = OpConstant %int 2 %vec = OpTypeVector %float 2 %mat = OpTypeMatrix %vec 2 %array = OpTypeArray %mat %int_2 %rta = OpTypeRuntimeArray %array %block = OpTypeStruct %rta %ptr = OpTypePointer StorageBuffer %block %var = OpVariable %ptr StorageBuffer %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "must be explicitly laid out with RowMajor or ColMajor decorations")); } TEST_F(ValidateDecorations, MatrixArrayArrayMissingStride) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 OpDecorate %block Block OpMemberDecorate %block 0 Offset 0 OpMemberDecorate %block 0 ColMajor OpDecorate %array ArrayStride 32 OpDecorate %rta ArrayStride 64 %void = OpTypeVoid %float = OpTypeFloat 32 %int = OpTypeInt 32 0 %int_2 = OpConstant %int 2 %vec = OpTypeVector %float 2 %mat = OpTypeMatrix %vec 2 %array = OpTypeArray %mat %int_2 %rta = OpTypeRuntimeArray %array %block = OpTypeStruct %rta %ptr = OpTypePointer StorageBuffer %block %var = OpVariable %ptr StorageBuffer %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT( getDiagnosticString(), HasSubstr("must be explicitly laid out with MatrixStride decorations")); } TEST_F(ValidateDecorations, MatrixArrayArrayBadStride) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 OpDecorate %block Block OpMemberDecorate %block 0 Offset 0 OpMemberDecorate %block 0 ColMajor OpMemberDecorate %block 0 MatrixStride 8 OpDecorate %array ArrayStride 32 OpDecorate %a ArrayStride 64 %void = OpTypeVoid %float = OpTypeFloat 32 %int = OpTypeInt 32 0 %int_2 = OpConstant %int 2 %vec = OpTypeVector %float 2 %mat = OpTypeMatrix %vec 2 %array = OpTypeArray %mat %int_2 %a = OpTypeArray %array %int_2 %block = OpTypeStruct %a %ptr = OpTypePointer Uniform %block %var = OpVariable %ptr Uniform %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT( getDiagnosticString(), HasSubstr("is a matrix with stride 8 not satisfying alignment to 16")); } TEST_F(ValidateDecorations, MultipleBuiltinsInputVertex) { const std::string body = R"( OpCapability Shader OpCapability DrawParameters OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %_ %gl_BaseInstance1 %gl_BaseInstance2 OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex 3 BuiltIn CullDistance OpDecorate %gl_PerVertex Block OpDecorate %gl_BaseInstance1 BuiltIn BaseInstance OpDecorate %gl_BaseInstance2 BuiltIn BaseInstance %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex %_ = OpVariable %_ptr_Output_gl_PerVertex Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float_0 = OpConstant %float 0 %17 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %_ptr_Input_int = OpTypePointer Input %int %gl_BaseInstance1 = OpVariable %_ptr_Input_int Input %gl_BaseInstance2 = OpVariable %_ptr_Input_int Input %_ptr_Output_v4float = OpTypePointer Output %v4float %main = OpFunction %void None %3 %5 = OpLabel %20 = OpLoad %int %gl_BaseInstance1 %21 = OpConvertSToF %float %20 %22 = OpVectorTimesScalar %v4float %17 %21 %24 = OpAccessChain %_ptr_Output_v4float %_ %int_0 OpStore %24 %22 OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str(), SPV_ENV_VULKAN_1_2); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpEntryPoint contains duplicate input variables with " "BaseInstance builtin")); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpEntryPoint-09658")); } TEST_F(ValidateDecorations, MultipleBuiltinsInputMesh) { const std::string body = R"( OpCapability DrawParameters OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %main "main" %gl_DrawID_1 %gl_DrawID_2 OpExecutionMode %main LocalSize 1 1 1 OpExecutionMode %main OutputVertices 32 OpExecutionMode %main OutputPrimitivesEXT 32 OpExecutionMode %main OutputTrianglesEXT OpDecorate %gl_DrawID_1 BuiltIn DrawIndex OpDecorate %gl_DrawID_2 BuiltIn DrawIndex %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %gl_DrawID_1 = OpVariable %_ptr_Input_int Input %gl_DrawID_2 = OpVariable %_ptr_Input_int Input %uint = OpTypeInt 32 0 %main = OpFunction %void None %3 %5 = OpLabel %9 = OpLoad %int %gl_DrawID_1 %11 = OpBitcast %uint %9 %12 = OpLoad %int %gl_DrawID_2 %13 = OpBitcast %uint %12 OpSetMeshOutputsEXT %11 %13 OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str(), SPV_ENV_VULKAN_1_2); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpEntryPoint contains duplicate input variables with " "DrawIndex builtin")); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpEntryPoint-09658")); } TEST_F(ValidateDecorations, MultipleBuiltinsInputCompute) { const std::string body = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %_ %gl_WorkGroupID_1 %gl_WorkGroupID_2 OpExecutionMode %main LocalSize 1 1 1 OpMemberDecorate %Buffers 0 Offset 0 OpDecorate %Buffers Block OpDecorate %_ DescriptorSet 0 OpDecorate %_ Binding 0 OpDecorate %gl_WorkGroupID_1 BuiltIn WorkgroupId OpDecorate %gl_WorkGroupID_2 BuiltIn WorkgroupId %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v3uint = OpTypeVector %uint 3 %Buffers = OpTypeStruct %v3uint %_ptr_StorageBuffer_Buffers = OpTypePointer StorageBuffer %Buffers %_ = OpVariable %_ptr_StorageBuffer_Buffers StorageBuffer %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %gl_WorkGroupID_1 = OpVariable %_ptr_Input_v3uint Input %gl_WorkGroupID_2 = OpVariable %_ptr_Input_v3uint Input %_ptr_StorageBuffer_v3uint = OpTypePointer StorageBuffer %v3uint %main = OpFunction %void None %3 %5 = OpLabel %15 = OpLoad %v3uint %gl_WorkGroupID_1 %16 = OpLoad %v3uint %gl_WorkGroupID_2 %17 = OpIAdd %v3uint %15 %16 %19 = OpAccessChain %_ptr_StorageBuffer_v3uint %_ %int_0 OpStore %19 %17 OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str(), SPV_ENV_VULKAN_1_2); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpEntryPoint contains duplicate input variables with " "WorkgroupId builtin")); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpEntryPoint-09658")); } TEST_F(ValidateDecorations, MultipleBuiltinsOutputFragment) { const std::string body = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragDepth_1 %gl_FragDepth_2 OpExecutionMode %main OriginUpperLeft OpExecutionMode %main DepthReplacing OpDecorate %gl_FragDepth_1 BuiltIn FragDepth OpDecorate %gl_FragDepth_2 BuiltIn FragDepth %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Output_float = OpTypePointer Output %float %gl_FragDepth_1 = OpVariable %_ptr_Output_float Output %gl_FragDepth_2 = OpVariable %_ptr_Output_float Output %float_1 = OpConstant %float 1 %main = OpFunction %void None %3 %5 = OpLabel OpStore %gl_FragDepth_1 %float_1 %10 = OpLoad %float %gl_FragDepth_1 %11 = OpFAdd %float %10 %float_1 OpStore %gl_FragDepth_2 %11 OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str(), SPV_ENV_VULKAN_1_2); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpEntryPoint contains duplicate output variables with " "FragDepth builtin")); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpEntryPoint-09659")); } TEST_F(ValidateDecorations, MultipleBuiltinsRayTmaxKHR) { const std::string body = R"( OpCapability RayTracingKHR OpExtension "SPV_KHR_ray_tracing" OpMemoryModel Logical GLSL450 OpEntryPoint AnyHitKHR %main "main" %gl_RayTmaxEXT %gl_HitTEXT %incomingPayload OpDecorate %gl_RayTmaxEXT BuiltIn RayTmaxKHR OpDecorate %gl_HitTEXT BuiltIn RayTmaxKHR %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float %_ptr_Input_float = OpTypePointer Input %float %gl_RayTmaxEXT = OpVariable %_ptr_Input_float Input %gl_HitTEXT = OpVariable %_ptr_Input_float Input %v4float = OpTypeVector %float 4 %_ptr_IncomingRayPayloadKHR_v4float = OpTypePointer IncomingRayPayloadKHR %v4float %incomingPayload = OpVariable %_ptr_IncomingRayPayloadKHR_v4float IncomingRayPayloadKHR %main = OpFunction %void None %3 %5 = OpLabel %a = OpVariable %_ptr_Function_float Function %b = OpVariable %_ptr_Function_float Function %11 = OpLoad %float %gl_RayTmaxEXT OpStore %a %11 %14 = OpLoad %float %gl_HitTEXT OpStore %b %14 %18 = OpLoad %float %a %19 = OpLoad %float %b %22 = OpCompositeConstruct %v4float %18 %18 %19 %19 OpStore %incomingPayload %22 OpTerminateRayKHR OpFunctionEnd )"; CompileSuccessfully(body.c_str(), SPV_ENV_VULKAN_1_2); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpEntryPoint contains duplicate input variables with RayTmax")); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpEntryPoint-09658")); } TEST_F(ValidateDecorations, MultipleBuiltinsBlock) { const std::string body = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %var OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn Position OpDecorate %gl_PerVertex Block %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %gl_PerVertex = OpTypeStruct %v4float %v4float %_ptr_gl_PerVertex = OpTypePointer Output %gl_PerVertex %var = OpVariable %_ptr_gl_PerVertex Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %float_0 = OpConstant %float 0 %17 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %ptr_vec4 = OpTypePointer Output %v4float %main = OpFunction %void None %3 %5 = OpLabel %19 = OpAccessChain %ptr_vec4 %var %int_0 OpStore %19 %17 %22 = OpAccessChain %ptr_vec4 %var %int_1 OpStore %22 %17 OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpEntryPoint contains duplicate output variables with Position")); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpEntryPoint-09659")); } TEST_F(ValidateDecorations, MultipleBuiltinsBlockMixed) { const std::string body = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %var %position OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpDecorate %gl_PerVertex Block OpDecorate %position BuiltIn Position %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %gl_PerVertex = OpTypeStruct %v4float %_ptr_gl_PerVertex = OpTypePointer Output %gl_PerVertex %var = OpVariable %_ptr_gl_PerVertex Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %float_0 = OpConstant %float 0 %17 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %ptr_vec4 = OpTypePointer Output %v4float %position = OpVariable %ptr_vec4 Output %main = OpFunction %void None %3 %5 = OpLabel %19 = OpAccessChain %ptr_vec4 %var %int_0 OpStore %19 %17 OpStore %position %17 OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpEntryPoint contains duplicate output variables with Position")); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpEntryPoint-09659")); } TEST_F(ValidateDecorations, UntypedVariableWorkgroupRequiresStruct) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpCapability WorkgroupMemoryExplicitLayoutKHR OpExtension "SPV_KHR_untyped_pointers" OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %var %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr = OpTypeUntypedPointerKHR Workgroup %var = OpUntypedVariableKHR %ptr Workgroup %int %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Untyped workgroup variables in shaders must be block " "decorated structs")); } TEST_F(ValidateDecorations, UntypedVariableWorkgroupRequiresBlockStruct) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpCapability WorkgroupMemoryExplicitLayoutKHR OpExtension "SPV_KHR_untyped_pointers" OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %var %void = OpTypeVoid %int = OpTypeInt 32 0 %struct = OpTypeStruct %int %ptr = OpTypeUntypedPointerKHR Workgroup %var = OpUntypedVariableKHR %ptr Workgroup %struct %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Untyped workgroup variables in shaders must be block " "decorated")); } TEST_F(ValidateDecorations, UntypedVariableStorageBufferMissingBlock) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpName %struct "struct" %void = OpTypeVoid %int = OpTypeInt 32 0 %struct = OpTypeStruct %int %ptr = OpTypeUntypedPointerKHR StorageBuffer %var = OpUntypedVariableKHR %ptr StorageBuffer %struct %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("StorageBuffer id '2' is missing Block decoration")); } TEST_F(ValidateDecorations, UntypedVariableUniformMissingBlock) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpName %struct "struct" %void = OpTypeVoid %int = OpTypeInt 32 0 %struct = OpTypeStruct %int %ptr = OpTypeUntypedPointerKHR Uniform %var = OpUntypedVariableKHR %ptr Uniform %struct %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Uniform id '2' is missing Block or BufferBlock decoration")); } TEST_F(ValidateDecorations, UntypedVariablePushConstantMissingBlock) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpName %struct "struct" %void = OpTypeVoid %int = OpTypeInt 32 0 %struct = OpTypeStruct %int %ptr = OpTypeUntypedPointerKHR PushConstant %var = OpUntypedVariableKHR %ptr PushConstant %struct %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("PushConstant id '2' is missing Block decoration")); } using UntypedVariableSetAndBinding = spvtest::ValidateBase; TEST_P(UntypedVariableSetAndBinding, MissingSet) { const auto sc = GetParam(); const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpName %var "var" OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 OpDecorate %var Binding 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %struct = OpTypeStruct %int %ptr = OpTypeUntypedPointerKHR )" + sc + R"( %var = OpUntypedVariableKHR %ptr )" + sc + R"( %struct %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %load = OpLoad %struct %var OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr(sc + " id '2' is missing DescriptorSet decoration")); } TEST_P(UntypedVariableSetAndBinding, MissingBinding) { const auto sc = GetParam(); const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpName %var "var" OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 OpDecorate %var DescriptorSet 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %struct = OpTypeStruct %int %ptr = OpTypeUntypedPointerKHR )" + sc + R"( %var = OpUntypedVariableKHR %ptr )" + sc + R"( %struct %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %load = OpLoad %struct %var OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr(sc + " id '2' is missing Binding decoration")); } INSTANTIATE_TEST_SUITE_P(ValidateUntypedVariableSetAndBinding, UntypedVariableSetAndBinding, Values("StorageBuffer", "Uniform")); using UntypedPointerLayout = spvtest::ValidateBase>; TEST_P(UntypedPointerLayout, BadOffset) { const auto sc = std::get<0>(GetParam()); const auto op = std::get<1>(GetParam()); const std::string set = (sc == "StorageBuffer" || sc == "Uniform" ? R"(OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 )" : R"()"); const std::string spirv = R"( OpCapability Shader OpCapability VariablePointers OpCapability UntypedPointersKHR OpCapability WorkgroupMemoryExplicitLayoutKHR OpExtension "SPV_KHR_untyped_pointers" OpExtension "SPV_KHR_variable_pointers" OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %var OpExecutionMode %main LocalSize 1 1 1 OpName %var "var" OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 OpMemberDecorate %struct 1 Offset 4 )" + set + R"(OpMemberDecorate %test_type 0 Offset 0 OpMemberDecorate %test_type 1 Offset 1 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %struct = OpTypeStruct %int %int %test_type = OpTypeStruct %int %int %test_val = OpConstantNull %test_type %ptr = OpTypeUntypedPointerKHR )" + sc + R"( %var = OpUntypedVariableKHR %ptr )" + sc + R"( %struct %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel )" + op + R"( OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_2)); const bool read_only = sc == "Uniform" || sc == "PushConstant"; if (!read_only || op.find("OpStore") == std::string::npos) { EXPECT_THAT(getDiagnosticString(), HasSubstr("member 1 at offset 1 is not aligned to")); } } TEST_P(UntypedPointerLayout, BadStride) { const auto sc = std::get<0>(GetParam()); const auto op = std::get<1>(GetParam()); const std::string set = (sc == "StorageBuffer" || sc == "Uniform" ? R"(OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 )" : R"()"); const std::string spirv = R"( OpCapability Shader OpCapability VariablePointers OpCapability UntypedPointersKHR OpCapability WorkgroupMemoryExplicitLayoutKHR OpExtension "SPV_KHR_untyped_pointers" OpExtension "SPV_KHR_variable_pointers" OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %var OpExecutionMode %main LocalSize 1 1 1 OpName %var "var" OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 OpMemberDecorate %struct 1 Offset 4 )" + set + R"(OpDecorate %test_type ArrayStride 4 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int_4 = OpConstant %int 4 %int4 = OpTypeVector %int 4 %test_type = OpTypeArray %int4 %int_4 %test_val = OpConstantNull %test_type %struct = OpTypeStruct %int %int %ptr = OpTypeUntypedPointerKHR )" + sc + R"( %var = OpUntypedVariableKHR %ptr )" + sc + R"( %struct %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel )" + op + R"( OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_2)); const bool read_only = sc == "Uniform" || sc == "PushConstant"; if (!read_only || op.find("OpStore") == std::string::npos) { EXPECT_THAT( getDiagnosticString(), HasSubstr("array with stride 4 not satisfying alignment to 16")); } } INSTANTIATE_TEST_SUITE_P( ValidateUntypedPointerLayout, UntypedPointerLayout, Combine(Values("StorageBuffer", "Uniform", "PushConstant", "Workgroup"), Values("%gep = OpUntypedAccessChainKHR %ptr %test_type %var %int_0", "%gep = OpUntypedInBoundsAccessChainKHR %ptr %test_type " "%var %int_0", "%gep = OpUntypedPtrAccessChainKHR %ptr %test_type %var " "%int_0 %int_0", "%ld = OpLoad %test_type %var", "OpStore %var %test_val"))); TEST_F(ValidateDecorations, UntypedArrayLengthMissingOffset) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %struct Block OpDecorate %block Block OpMemberDecorate %block 0 Offset 0 OpDecorate %array ArrayStride 4 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %array = OpTypeRuntimeArray %int %struct = OpTypeStruct %array %block = OpTypeStruct %array %ptr = OpTypeUntypedPointerKHR StorageBuffer %var = OpUntypedVariableKHR %ptr StorageBuffer %block %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %len = OpUntypedArrayLengthKHR %int %struct %var 0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), HasSubstr("member 0 is missing an Offset decoration")); } TEST_F(ValidateDecorations, ComponentMultipleArrays) { const std::string spirv = R"( OpCapability Tessellation %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint TessellationEvaluation %main "main" %_ %FOO %FOO0 OpExecutionMode %main Triangles OpExecutionMode %main SpacingEqual OpExecutionMode %main VertexOrderCcw OpSource GLSL 460 OpSourceExtension "GL_EXT_nonuniform_qualifier" OpName %main "main" OpName %gl_PerVertex "gl_PerVertex" OpMemberName %gl_PerVertex 0 "gl_Position" OpMemberName %gl_PerVertex 1 "gl_PointSize" OpMemberName %gl_PerVertex 2 "gl_ClipDistance" OpMemberName %gl_PerVertex 3 "gl_CullDistance" OpName %_ "" OpName %FOO "FOO" OpMemberDecorate %gl_PerVertex 0 BuiltIn Position OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance OpMemberDecorate %gl_PerVertex 3 BuiltIn CullDistance OpDecorate %gl_PerVertex Block OpDecorate %FOO Component 2 OpDecorate %FOO Location 1 OpDecorate %FOO0 Location 1 OpDecorate %FOO0 Component 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_float_uint_1 = OpTypeArray %float %uint_1 %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1 %_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex %_ = OpVariable %_ptr_Output_gl_PerVertex Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %v2float = OpTypeVector %float 2 %uint_2 = OpConstant %uint 2 %_arr_v2float_uint_2 = OpTypeArray %v2float %uint_2 %uint_32 = OpConstant %uint 32 %_arr__arr_v2float_uint_2_uint_32 = OpTypeArray %_arr_v2float_uint_2 %uint_32 %_ptr_Input__arr__arr_v2float_uint_2_uint_32 = OpTypePointer Input %_arr__arr_v2float_uint_2_uint_32 %FOO = OpVariable %_ptr_Input__arr__arr_v2float_uint_2_uint_32 Input %FOO0 = OpVariable %_ptr_Input__arr__arr_v2float_uint_2_uint_32 Input %_ptr_Input_v2float = OpTypePointer Input %v2float %int_1 = OpConstant %int 1 %uint_0 = OpConstant %uint 0 %_ptr_Output_float = OpTypePointer Output %float %main = OpFunction %void None %3 %5 = OpLabel %24 = OpAccessChain %_ptr_Input_v2float %FOO %int_0 %int_0 %25 = OpLoad %v2float %24 %27 = OpAccessChain %_ptr_Input_v2float %FOO0 %int_1 %int_1 %28 = OpLoad %v2float %27 %29 = OpFAdd %v2float %25 %28 %32 = OpAccessChain %_ptr_Output_float %_ %int_0 %uint_0 %33 = OpCompositeExtract %float %29 0 OpStore %32 %33 %34 = OpAccessChain %_ptr_Output_float %_ %int_0 %uint_1 %35 = OpCompositeExtract %float %29 1 OpStore %34 %35 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } const std::string kNodeShaderPrelude = R"( OpCapability Shader OpCapability ShaderEnqueueAMDX OpExtension "SPV_AMDX_shader_enqueue" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpEntryPoint GLCompute %other "other" )"; const std::string kNodeShaderPostlude = R"( %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %node0 = OpConstantStringAMDX "node0" %node1 = OpConstantStringAMDX "node1" %node2 = OpConstantStringAMDX "node2" %S = OpTypeStruct %_payloadarr_S = OpTypeNodePayloadArrayAMDX %S %_payloadarr_S_0 = OpTypeNodePayloadArrayAMDX %S %bool = OpTypeBool %true = OpConstantTrue %bool %void = OpTypeVoid %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd %other = OpFunction %void None %void_fn %entry0 = OpLabel OpReturn OpFunctionEnd )"; TEST_F(ValidateDecorations, NodeShader) { const std::string spirv = kNodeShaderPrelude + R"( OpExecutionModeId %main ShaderIndexAMDX %uint_0 OpExecutionModeId %main IsApiEntryAMDX %true OpExecutionModeId %main MaxNodeRecursionAMDX %uint_1 OpExecutionModeId %main MaxNumWorkgroupsAMDX %uint_1 %uint_1 %uint_1 OpExecutionModeId %main SharesInputWithAMDX %node0 %uint_0 OpExecutionModeId %other ShaderIndexAMDX %uint_0 OpExecutionModeId %other StaticNumWorkgroupsAMDX %uint_1 %uint_1 %uint_1 OpDecorateId %_payloadarr_S PayloadNodeNameAMDX %node1 OpDecorateId %_payloadarr_S_0 PayloadNodeNameAMDX %node2 OpDecorateId %_payloadarr_S PayloadNodeBaseIndexAMDX %uint_0 OpDecorateId %_payloadarr_S PayloadNodeArraySizeAMDX %uint_1 OpDecorateId %_payloadarr_S NodeSharesPayloadLimitsWithAMDX %_payloadarr_S_0 )" + kNodeShaderPostlude; spv_target_env env = SPV_ENV_UNIVERSAL_1_3; CompileSuccessfully(spirv, env); EXPECT_THAT(SPV_SUCCESS, ValidateInstructions(env)); } TEST_F(ValidateDecorations, NodeShaderDecoratePayloadNodeName) { const std::string spirv = kNodeShaderPrelude + R"( OpExecutionModeId %main ShaderIndexAMDX %uint_0 OpExecutionModeId %main IsApiEntryAMDX %true OpExecutionModeId %main MaxNodeRecursionAMDX %uint_1 OpExecutionModeId %main MaxNumWorkgroupsAMDX %uint_1 %uint_1 %uint_1 OpExecutionModeId %main SharesInputWithAMDX %node0 %uint_0 OpExecutionModeId %other ShaderIndexAMDX %uint_0 OpExecutionModeId %other StaticNumWorkgroupsAMDX %uint_1 %uint_1 %uint_1 OpDecorate %_payloadarr_S PayloadNodeNameAMDX %node1 OpDecorate %_payloadarr_S_0 PayloadNodeNameAMDX %node2 OpDecorateId %_payloadarr_S PayloadNodeBaseIndexAMDX %uint_0 OpDecorateId %_payloadarr_S PayloadNodeArraySizeAMDX %uint_1 OpDecorateId %_payloadarr_S NodeSharesPayloadLimitsWithAMDX %_payloadarr_S_0 )" + kNodeShaderPostlude; spv_target_env env = SPV_ENV_UNIVERSAL_1_3; CompileSuccessfully(spirv, env); EXPECT_THAT(SPV_ERROR_INVALID_ID, ValidateInstructions(env)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Decorations taking ID parameters may not be used with OpDecorate")); } TEST_F(ValidateDecorations, NodeShaderDecoratePayloadNodeBaseIndex) { const std::string spirv = kNodeShaderPrelude + R"( OpExecutionModeId %main ShaderIndexAMDX %uint_0 OpExecutionModeId %main IsApiEntryAMDX %true OpExecutionModeId %main MaxNodeRecursionAMDX %uint_1 OpExecutionModeId %main MaxNumWorkgroupsAMDX %uint_1 %uint_1 %uint_1 OpExecutionModeId %main SharesInputWithAMDX %node0 %uint_0 OpExecutionModeId %other ShaderIndexAMDX %uint_0 OpExecutionModeId %other StaticNumWorkgroupsAMDX %uint_1 %uint_1 %uint_1 OpDecorateId %_payloadarr_S PayloadNodeNameAMDX %node1 OpDecorateId %_payloadarr_S_0 PayloadNodeNameAMDX %node2 OpDecorate %_payloadarr_S PayloadNodeBaseIndexAMDX %uint_0 OpDecorateId %_payloadarr_S PayloadNodeArraySizeAMDX %uint_1 OpDecorateId %_payloadarr_S NodeSharesPayloadLimitsWithAMDX %_payloadarr_S_0 )" + kNodeShaderPostlude; spv_target_env env = SPV_ENV_UNIVERSAL_1_3; CompileSuccessfully(spirv, env); EXPECT_THAT(SPV_ERROR_INVALID_ID, ValidateInstructions(env)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Decorations taking ID parameters may not be used with OpDecorate")); } TEST_F(ValidateDecorations, NodeShaderDecoratePayloadNodeArraySize) { const std::string spirv = kNodeShaderPrelude + R"( OpExecutionModeId %main ShaderIndexAMDX %uint_0 OpExecutionModeId %main IsApiEntryAMDX %true OpExecutionModeId %main MaxNodeRecursionAMDX %uint_1 OpExecutionModeId %main MaxNumWorkgroupsAMDX %uint_1 %uint_1 %uint_1 OpExecutionModeId %main SharesInputWithAMDX %node0 %uint_0 OpExecutionModeId %other ShaderIndexAMDX %uint_0 OpExecutionModeId %other StaticNumWorkgroupsAMDX %uint_1 %uint_1 %uint_1 OpDecorateId %_payloadarr_S PayloadNodeNameAMDX %node1 OpDecorateId %_payloadarr_S_0 PayloadNodeNameAMDX %node2 OpDecorateId %_payloadarr_S PayloadNodeBaseIndexAMDX %uint_0 OpDecorate %_payloadarr_S PayloadNodeArraySizeAMDX %uint_1 OpDecorateId %_payloadarr_S NodeSharesPayloadLimitsWithAMDX %_payloadarr_S_0 )" + kNodeShaderPostlude; spv_target_env env = SPV_ENV_UNIVERSAL_1_3; CompileSuccessfully(spirv, env); EXPECT_THAT(SPV_ERROR_INVALID_ID, ValidateInstructions(env)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Decorations taking ID parameters may not be used with OpDecorate")); } TEST_F(ValidateDecorations, NodeShaderDecorateNodeSharesPayloadLimitsWith) { const std::string spirv = kNodeShaderPrelude + R"( OpExecutionModeId %main ShaderIndexAMDX %uint_0 OpExecutionModeId %main IsApiEntryAMDX %true OpExecutionModeId %main MaxNodeRecursionAMDX %uint_1 OpExecutionModeId %main MaxNumWorkgroupsAMDX %uint_1 %uint_1 %uint_1 OpExecutionModeId %main SharesInputWithAMDX %node0 %uint_0 OpExecutionModeId %other ShaderIndexAMDX %uint_0 OpExecutionModeId %other StaticNumWorkgroupsAMDX %uint_1 %uint_1 %uint_1 OpDecorateId %_payloadarr_S PayloadNodeNameAMDX %node1 OpDecorateId %_payloadarr_S_0 PayloadNodeNameAMDX %node2 OpDecorateId %_payloadarr_S PayloadNodeBaseIndexAMDX %uint_0 OpDecorateId %_payloadarr_S PayloadNodeArraySizeAMDX %uint_1 OpDecorate %_payloadarr_S NodeSharesPayloadLimitsWithAMDX %_payloadarr_S_0 )" + kNodeShaderPostlude; spv_target_env env = SPV_ENV_UNIVERSAL_1_3; CompileSuccessfully(spirv, env); EXPECT_THAT(SPV_ERROR_INVALID_ID, ValidateInstructions(env)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Decorations taking ID parameters may not be used with OpDecorate")); } TEST_F(ValidateDecorations, BlockArrayWithStride) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 OpDecorate %array ArrayStride 4 %int = OpTypeInt 32 0 %int_4 = OpConstant %int 4 %struct = OpTypeStruct %int %array = OpTypeArray %struct %int_4 )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Array containing a Block or BufferBlock must not be " "decorated with ArrayStride")); } TEST_F(ValidateDecorations, BufferBlockRuntimeArrayWithStride) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %struct BufferBlock OpMemberDecorate %struct 0 Offset 0 OpDecorate %array ArrayStride 4 %int = OpTypeInt 32 0 %struct = OpTypeStruct %int %array = OpTypeRuntimeArray %struct )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Array containing a Block or BufferBlock must not be " "decorated with ArrayStride")); } TEST_F(ValidateDecorations, BlockArrayWithoutStride) { const std::string spirv = R"( OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 %int = OpTypeInt 32 0 %int_4 = OpConstant %int 4 %struct = OpTypeStruct %int %array = OpTypeArray %struct %int_4 %ptr = OpTypePointer StorageBuffer %array %var = OpVariable %ptr StorageBuffer %void = OpTypeVoid %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateDecorations, BlockArrayWithoutStrideUntypedAccessChain) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 %int = OpTypeInt 32 0 %int_4 = OpConstant %int 4 %struct = OpTypeStruct %int %array = OpTypeArray %struct %int_4 %void = OpTypeVoid %ptr = OpTypeUntypedPointerKHR StorageBuffer %var = OpUntypedVariableKHR %ptr StorageBuffer %array %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %gep = OpUntypedAccessChainKHR %ptr %array %var OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_derivatives_test.cpp000066400000000000000000000153571475742701700252370ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gmock/gmock.h" #include "test/unit_spirv.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::HasSubstr; using ::testing::Not; using ValidateDerivatives = spvtest::ValidateBase; std::string GenerateShaderCode( const std::string& body, const std::string& capabilities_and_extensions = "", const std::string& execution_model = "Fragment") { std::stringstream ss; ss << R"( OpCapability Shader OpCapability DerivativeControl )"; ss << capabilities_and_extensions; ss << "OpMemoryModel Logical GLSL450\n"; ss << "OpEntryPoint " << execution_model << " %main \"main\"" << " %f32_var_input" << " %f32vec4_var_input" << "\n"; if (execution_model == "Fragment") { ss << "OpExecutionMode %main OriginUpperLeft\n"; } ss << R"( %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f32 = OpTypeFloat 32 %u32 = OpTypeInt 32 0 %s32 = OpTypeInt 32 1 %f32vec4 = OpTypeVector %f32 4 %f32_ptr_input = OpTypePointer Input %f32 %f32_var_input = OpVariable %f32_ptr_input Input %f32vec4_ptr_input = OpTypePointer Input %f32vec4 %f32vec4_var_input = OpVariable %f32vec4_ptr_input Input )"; if (capabilities_and_extensions.find("OpCapability Float16") != std::string::npos) { ss << "%f16 = OpTypeFloat 16\n" << "%f16vec4 = OpTypeVector %f16 4\n" << "%f16_0 = OpConstantNull %f16\n" << "%f16vec4_0 = OpConstantNull %f16vec4\n"; } ss << R"( %main = OpFunction %void None %func %main_entry = OpLabel )"; ss << body; ss << R"( OpReturn OpFunctionEnd)"; return ss.str(); } TEST_F(ValidateDerivatives, ScalarSuccess) { const std::string body = R"( %f32_var = OpLoad %f32 %f32_var_input %val1 = OpDPdx %f32 %f32_var %val2 = OpDPdy %f32 %f32_var %val3 = OpFwidth %f32 %f32_var %val4 = OpDPdxFine %f32 %f32_var %val5 = OpDPdyFine %f32 %f32_var %val6 = OpFwidthFine %f32 %f32_var %val7 = OpDPdxCoarse %f32 %f32_var %val8 = OpDPdyCoarse %f32 %f32_var %val9 = OpFwidthCoarse %f32 %f32_var )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateDerivatives, VectorSuccess) { const std::string body = R"( %f32vec4_var = OpLoad %f32vec4 %f32vec4_var_input %val1 = OpDPdx %f32vec4 %f32vec4_var %val2 = OpDPdy %f32vec4 %f32vec4_var %val3 = OpFwidth %f32vec4 %f32vec4_var %val4 = OpDPdxFine %f32vec4 %f32vec4_var %val5 = OpDPdyFine %f32vec4 %f32vec4_var %val6 = OpFwidthFine %f32vec4 %f32vec4_var %val7 = OpDPdxCoarse %f32vec4 %f32vec4_var %val8 = OpDPdyCoarse %f32vec4 %f32vec4_var %val9 = OpFwidthCoarse %f32vec4 %f32vec4_var )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateDerivatives, OpDPdxWrongResultType) { const std::string body = R"( %f32_var = OpLoad %f32 %f32_var_input %val1 = OpDPdx %u32 %f32vec4 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Operand '10[%v4float]' cannot " "be a type")); } TEST_F(ValidateDerivatives, OpDPdxWrongPType) { const std::string body = R"( %f32vec4_var = OpLoad %f32vec4 %f32vec4_var_input %val1 = OpDPdx %f32 %f32vec4_var )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected P type and Result Type to be the same: " "DPdx")); } TEST_F(ValidateDerivatives, OpDPdxWrongExecutionModel) { const std::string body = R"( %f32vec4_var = OpLoad %f32vec4 %f32vec4_var_input %val1 = OpDPdx %f32vec4 %f32vec4_var )"; CompileSuccessfully(GenerateShaderCode(body, "", "Vertex").c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Derivative instructions require Fragment, GLCompute, " "MeshEXT or TaskEXT execution model: DPdx")); } TEST_F(ValidateDerivatives, NoExecutionModeGLCompute) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %float = OpTypeFloat 32 %float4 = OpTypeVector %float 4 %undef = OpUndef %float4 %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %derivative = OpDPdy %float4 %undef OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Derivative instructions require " "DerivativeGroupQuadsKHR or DerivativeGroupLinearKHR " "execution mode for GLCompute, MeshEXT or TaskEXT " "execution model")); } using ValidateHalfDerivatives = spvtest::ValidateBase; TEST_P(ValidateHalfDerivatives, ScalarFailure) { const std::string op = GetParam(); const std::string body = "%val = " + op + " %f16 %f16_0\n"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability Float16\n").c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Result type component width must be 32 bits")); } TEST_P(ValidateHalfDerivatives, VectorFailure) { const std::string op = GetParam(); const std::string body = "%val = " + op + " %f16vec4 %f16vec4_0\n"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability Float16\n").c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Result type component width must be 32 bits")); } INSTANTIATE_TEST_SUITE_P(HalfDerivatives, ValidateHalfDerivatives, ::testing::Values("OpDPdx", "OpDPdy", "OpFwidth", "OpDPdxFine", "OpDPdyFine", "OpFwidthFine", "OpDPdxCoarse", "OpDPdyCoarse", "OpFwidthCoarse")); } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_entry_point_test.cpp000066400000000000000000000035561475742701700252620ustar00rootroot00000000000000// Copyright (c) 2019 Samsung Inc // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gmock/gmock.h" #include "test/unit_spirv.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace { using ::testing::Eq; using ::testing::HasSubstr; using ValidateEntryPoints = spvtest::ValidateBase; TEST_F(ValidateEntryPoints, DuplicateEntryPoints) { const std::string body = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %3 "foo" OpEntryPoint GLCompute %4 "foo" %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpFunction %1 None %2 %20 = OpLabel OpReturn OpFunctionEnd %4 = OpFunction %1 None %2 %21 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(body); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Entry points cannot share the same name")); } TEST_F(ValidateEntryPoints, UniqueEntryPoints) { const std::string body = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %3 "foo" OpEntryPoint GLCompute %4 "foo2" %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpFunction %1 None %2 %20 = OpLabel OpReturn OpFunctionEnd %4 = OpFunction %1 None %2 %21 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(body); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } } // namespace } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_explicit_reserved_test.cpp000066400000000000000000000100541475742701700264170ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validation tests for illegal instructions #include #include "gmock/gmock.h" #include "test/unit_spirv.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::Eq; using ::testing::HasSubstr; using ReservedSamplingInstTest = spvtest::ValidateBase; // Generate a shader for use with validation tests for sparse sampling // instructions. std::string ShaderAssembly(const std::string& instruction_under_test) { std::ostringstream os; os << R"( OpCapability Shader OpCapability SparseResidency OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpSource GLSL 450 OpDecorate %2 DescriptorSet 0 OpDecorate %2 Binding 0 %void = OpTypeVoid %4 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %float_0 = OpConstant %float 0 %8 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %9 = OpTypeImage %float 2D 0 0 0 1 Unknown %10 = OpTypeSampledImage %9 %_ptr_UniformConstant_10 = OpTypePointer UniformConstant %10 %2 = OpVariable %_ptr_UniformConstant_10 UniformConstant %v2float = OpTypeVector %float 2 %13 = OpConstantComposite %v2float %float_0 %float_0 %int = OpTypeInt 32 1 %_struct_15 = OpTypeStruct %int %v4float %1 = OpFunction %void None %4 %16 = OpLabel %17 = OpLoad %10 %2 )" << instruction_under_test << R"( OpReturn OpFunctionEnd )"; return os.str(); } TEST_F(ReservedSamplingInstTest, OpImageSparseSampleProjImplicitLod) { const std::string input = ShaderAssembly( "%result = OpImageSparseSampleProjImplicitLod %_struct_15 %17 %13"); CompileSuccessfully(input); EXPECT_THAT(ValidateInstructions(), Eq(SPV_ERROR_INVALID_BINARY)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Invalid Opcode name 'OpImageSparseSampleProjImplicitLod'")); } TEST_F(ReservedSamplingInstTest, OpImageSparseSampleProjExplicitLod) { const std::string input = ShaderAssembly( "%result = OpImageSparseSampleProjExplicitLod %_struct_15 %17 %13 Lod " "%float_0\n"); CompileSuccessfully(input); EXPECT_THAT(ValidateInstructions(), Eq(SPV_ERROR_INVALID_BINARY)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Invalid Opcode name 'OpImageSparseSampleProjExplicitLod'")); } TEST_F(ReservedSamplingInstTest, OpImageSparseSampleProjDrefImplicitLod) { const std::string input = ShaderAssembly( "%result = OpImageSparseSampleProjDrefImplicitLod %_struct_15 %17 %13 " "%float_0\n"); CompileSuccessfully(input); EXPECT_THAT(ValidateInstructions(), Eq(SPV_ERROR_INVALID_BINARY)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Invalid Opcode name 'OpImageSparseSampleProjDrefImplicitLod'")); } TEST_F(ReservedSamplingInstTest, OpImageSparseSampleProjDrefExplicitLod) { const std::string input = ShaderAssembly( "%result = OpImageSparseSampleProjDrefExplicitLod %_struct_15 %17 %13 " "%float_0 Lod " "%float_0\n"); CompileSuccessfully(input); EXPECT_THAT(ValidateInstructions(), Eq(SPV_ERROR_INVALID_BINARY)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Invalid Opcode name 'OpImageSparseSampleProjDrefExplicitLod'")); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_ext_inst_debug_test.cpp000066400000000000000000006012461475742701700257130ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Tests validation rules of GLSL.450.std and OpenCL.std extended instructions. // Doesn't test OpenCL.std vector size 2, 3, 4, 8 or 16 rules (not supported // by standard SPIR-V). #include #include #include #include "gmock/gmock.h" #include "spirv-tools/libspirv.h" #include "test/unit_spirv.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::Eq; using ::testing::HasSubstr; using ::testing::Not; using ValidateOldDebugInfo = spvtest::ValidateBase; using ValidateOpenCL100DebugInfo = spvtest::ValidateBase; using ValidateXDebugInfo = spvtest::ValidateBase; using ValidateLocalDebugInfoOutOfFunction = spvtest::ValidateBase; using ValidateOpenCL100DebugInfoDebugTypedef = spvtest::ValidateBase>; using ValidateVulkan100DebugInfoDebugTypedef = spvtest::ValidateBase>; using ValidateOpenCL100DebugInfoDebugTypeEnum = spvtest::ValidateBase>; using ValidateVulkan100DebugInfoDebugTypeEnum = spvtest::ValidateBase>; using ValidateOpenCL100DebugInfoDebugTypeComposite = spvtest::ValidateBase>; using ValidateVulkan100DebugInfoDebugTypeComposite = spvtest::ValidateBase>; using ValidateOpenCL100DebugInfoDebugTypeMember = spvtest::ValidateBase>; using ValidateVulkan100DebugInfoDebugTypeMember = spvtest::ValidateBase>; using ValidateOpenCL100DebugInfoDebugTypeInheritance = spvtest::ValidateBase>; using ValidateOpenCL100DebugInfoDebugFunction = spvtest::ValidateBase>; using ValidateVulkan100DebugInfoDebugFunction = spvtest::ValidateBase>; using ValidateOpenCL100DebugInfoDebugFunctionDeclaration = spvtest::ValidateBase>; using ValidateVulkan100DebugInfoDebugFunctionDeclaration = spvtest::ValidateBase>; using ValidateOpenCL100DebugInfoDebugLexicalBlock = spvtest::ValidateBase>; using ValidateVulkan100DebugInfoDebugLexicalBlock = spvtest::ValidateBase>; using ValidateOpenCL100DebugInfoDebugLocalVariable = spvtest::ValidateBase>; using ValidateVulkan100DebugInfoDebugLocalVariable = spvtest::ValidateBase>; using ValidateOpenCL100DebugInfoDebugGlobalVariable = spvtest::ValidateBase>; using ValidateVulkan100DebugInfoDebugGlobalVariable = spvtest::ValidateBase>; using ValidateOpenCL100DebugInfoDebugDeclare = spvtest::ValidateBase>; using ValidateVulkan100DebugInfoDebugDeclare = spvtest::ValidateBase>; using ValidateOpenCL100DebugInfoDebugValue = spvtest::ValidateBase>; using ValidateVulkan100DebugInfoDebugValue = spvtest::ValidateBase>; using ValidateVulkan100DebugInfo = spvtest::ValidateBase; const static std::string shader_extension = R"( OpExtension "SPV_KHR_non_semantic_info" %DbgExt = OpExtInstImport "NonSemantic.Shader.DebugInfo.100" )"; const static std::string opencl_extension = R"( %DbgExt = OpExtInstImport "OpenCL.DebugInfo.100" )"; std::string GenerateShaderCodeForDebugInfo( const std::string& op_string_instructions, const std::string& op_const_instructions, const std::string& debug_instructions_before_main, const std::string& body, const std::string& capabilities_and_extensions = "", const std::string& execution_model = "Fragment") { std::ostringstream ss; ss << R"( OpCapability Shader OpCapability Float16 OpCapability Float64 OpCapability Int16 OpCapability Int64 )"; ss << capabilities_and_extensions; ss << "%extinst = OpExtInstImport \"GLSL.std.450\"\n"; ss << "OpMemoryModel Logical GLSL450\n"; ss << "OpEntryPoint " << execution_model << " %main \"main\"" << " %f32_output" << " %f32vec2_output" << " %u32_output" << " %u32vec2_output" << " %u64_output" << " %f32_input" << " %f32vec2_input" << " %u32_input" << " %u32vec2_input" << " %u64_input" << "\n"; if (execution_model == "Fragment") { ss << "OpExecutionMode %main OriginUpperLeft\n"; } ss << "%main_name = OpString \"main\"\n"; ss << op_string_instructions; ss << R"( %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f16 = OpTypeFloat 16 %f32 = OpTypeFloat 32 %f64 = OpTypeFloat 64 %u32 = OpTypeInt 32 0 %s32 = OpTypeInt 32 1 %u64 = OpTypeInt 64 0 %s64 = OpTypeInt 64 1 %u16 = OpTypeInt 16 0 %s16 = OpTypeInt 16 1 %f32vec2 = OpTypeVector %f32 2 %f32vec3 = OpTypeVector %f32 3 %f32vec4 = OpTypeVector %f32 4 %f64vec2 = OpTypeVector %f64 2 %f64vec3 = OpTypeVector %f64 3 %f64vec4 = OpTypeVector %f64 4 %u32vec2 = OpTypeVector %u32 2 %u32vec3 = OpTypeVector %u32 3 %s32vec2 = OpTypeVector %s32 2 %u32vec4 = OpTypeVector %u32 4 %s32vec4 = OpTypeVector %s32 4 %u64vec2 = OpTypeVector %u64 2 %s64vec2 = OpTypeVector %s64 2 %f64mat22 = OpTypeMatrix %f64vec2 2 %f32mat22 = OpTypeMatrix %f32vec2 2 %f32mat23 = OpTypeMatrix %f32vec2 3 %f32mat32 = OpTypeMatrix %f32vec3 2 %f32mat33 = OpTypeMatrix %f32vec3 3 %f32_0 = OpConstant %f32 0 %f32_1 = OpConstant %f32 1 %f32_2 = OpConstant %f32 2 %f32_3 = OpConstant %f32 3 %f32_4 = OpConstant %f32 4 %f32_h = OpConstant %f32 0.5 %f32vec2_01 = OpConstantComposite %f32vec2 %f32_0 %f32_1 %f32vec2_12 = OpConstantComposite %f32vec2 %f32_1 %f32_2 %f32vec3_012 = OpConstantComposite %f32vec3 %f32_0 %f32_1 %f32_2 %f32vec3_123 = OpConstantComposite %f32vec3 %f32_1 %f32_2 %f32_3 %f32vec4_0123 = OpConstantComposite %f32vec4 %f32_0 %f32_1 %f32_2 %f32_3 %f32vec4_1234 = OpConstantComposite %f32vec4 %f32_1 %f32_2 %f32_3 %f32_4 %f64_0 = OpConstant %f64 0 %f64_1 = OpConstant %f64 1 %f64_2 = OpConstant %f64 2 %f64_3 = OpConstant %f64 3 %f64vec2_01 = OpConstantComposite %f64vec2 %f64_0 %f64_1 %f64vec3_012 = OpConstantComposite %f64vec3 %f64_0 %f64_1 %f64_2 %f64vec4_0123 = OpConstantComposite %f64vec4 %f64_0 %f64_1 %f64_2 %f64_3 %f16_0 = OpConstant %f16 0 %f16_1 = OpConstant %f16 1 %f16_h = OpConstant %f16 0.5 %u32_0 = OpConstant %u32 0 %u32_1 = OpConstant %u32 1 %u32_2 = OpConstant %u32 2 %u32_3 = OpConstant %u32 3 %u32_4 = OpConstant %u32 4 %u32_5 = OpConstant %u32 5 %u32_32 = OpConstant %u32 32 %s32_0 = OpConstant %s32 0 %s32_1 = OpConstant %s32 1 %s32_2 = OpConstant %s32 2 %s32_3 = OpConstant %s32 3 %u64_0 = OpConstant %u64 0 %u64_1 = OpConstant %u64 1 %u64_2 = OpConstant %u64 2 %u64_3 = OpConstant %u64 3 %s64_0 = OpConstant %s64 0 %s64_1 = OpConstant %s64 1 %s64_2 = OpConstant %s64 2 %s64_3 = OpConstant %s64 3 )"; ss << op_const_instructions; ss << R"( %s32vec2_01 = OpConstantComposite %s32vec2 %s32_0 %s32_1 %u32vec2_01 = OpConstantComposite %u32vec2 %u32_0 %u32_1 %s32vec2_12 = OpConstantComposite %s32vec2 %s32_1 %s32_2 %u32vec2_12 = OpConstantComposite %u32vec2 %u32_1 %u32_2 %s32vec4_0123 = OpConstantComposite %s32vec4 %s32_0 %s32_1 %s32_2 %s32_3 %u32vec4_0123 = OpConstantComposite %u32vec4 %u32_0 %u32_1 %u32_2 %u32_3 %s64vec2_01 = OpConstantComposite %s64vec2 %s64_0 %s64_1 %u64vec2_01 = OpConstantComposite %u64vec2 %u64_0 %u64_1 %f32mat22_1212 = OpConstantComposite %f32mat22 %f32vec2_12 %f32vec2_12 %f32mat23_121212 = OpConstantComposite %f32mat23 %f32vec2_12 %f32vec2_12 %f32vec2_12 %f32_ptr_output = OpTypePointer Output %f32 %f32vec2_ptr_output = OpTypePointer Output %f32vec2 %u32_ptr_output = OpTypePointer Output %u32 %u32vec2_ptr_output = OpTypePointer Output %u32vec2 %u64_ptr_output = OpTypePointer Output %u64 %f32_output = OpVariable %f32_ptr_output Output %f32vec2_output = OpVariable %f32vec2_ptr_output Output %u32_output = OpVariable %u32_ptr_output Output %u32vec2_output = OpVariable %u32vec2_ptr_output Output %u64_output = OpVariable %u64_ptr_output Output %f32_ptr_input = OpTypePointer Input %f32 %f32vec2_ptr_input = OpTypePointer Input %f32vec2 %u32_ptr_input = OpTypePointer Input %u32 %u32vec2_ptr_input = OpTypePointer Input %u32vec2 %u64_ptr_input = OpTypePointer Input %u64 %f32_ptr_function = OpTypePointer Function %f32 %f32_input = OpVariable %f32_ptr_input Input %f32vec2_input = OpVariable %f32vec2_ptr_input Input %u32_input = OpVariable %u32_ptr_input Input %u32vec2_input = OpVariable %u32vec2_ptr_input Input %u64_input = OpVariable %u64_ptr_input Input %u32_ptr_function = OpTypePointer Function %u32 %struct_f16_u16 = OpTypeStruct %f16 %u16 %struct_f32_f32 = OpTypeStruct %f32 %f32 %struct_f32_f32_f32 = OpTypeStruct %f32 %f32 %f32 %struct_f32_u32 = OpTypeStruct %f32 %u32 %struct_f32_u32_f32 = OpTypeStruct %f32 %u32 %f32 %struct_u32_f32 = OpTypeStruct %u32 %f32 %struct_u32_u32 = OpTypeStruct %u32 %u32 %struct_f32_f64 = OpTypeStruct %f32 %f64 %struct_f32vec2_f32vec2 = OpTypeStruct %f32vec2 %f32vec2 %struct_f32vec2_u32vec2 = OpTypeStruct %f32vec2 %u32vec2 )"; ss << debug_instructions_before_main; ss << R"( %main = OpFunction %void None %func %main_entry = OpLabel )"; ss << body; ss << R"( OpReturn OpFunctionEnd)"; return ss.str(); } TEST_F(ValidateOldDebugInfo, UseDebugInstructionOutOfFunction) { const std::string src = R"( %code = OpString "main() {}" )"; const std::string dbg_inst = R"( %cu = OpExtInst %void %DbgExt DebugCompilationUnit %code 1 1 )"; const std::string extension = R"( %DbgExt = OpExtInstImport "DebugInfo" )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo(src, "", dbg_inst, "", extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateOpenCL100DebugInfo, UseDebugInstructionOutOfFunction) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" )"; const std::string dbg_inst = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateOpenCL100DebugInfo, DebugSourceInFunction) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" )"; const std::string dbg_inst = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", "", dbg_inst, opencl_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Debug info extension instructions other than DebugScope, " "DebugNoScope, DebugDeclare, DebugValue must appear between " "section 9 (types, constants, global variables) and section 10 " "(function declarations)")); } TEST_F(ValidateVulkan100DebugInfo, DebugSourceInFunction) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" )"; const std::string dbg_inst = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", "", dbg_inst, shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Debug info extension instructions other than DebugScope, " "DebugNoScope, DebugDeclare, DebugValue must appear between " "section 9 (types, constants, global variables) and section 10 " "(function declarations)")); } TEST_P(ValidateLocalDebugInfoOutOfFunction, OpenCLDebugInfo100DebugScope) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "void main() {}" %void_name = OpString "void" %int_name = OpString "int" %foo_name = OpString "foo" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %int_info = OpExtInst %void %DbgExt DebugTypeBasic %int_name %u32_0 Signed %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction FlagIsPublic %void %main_info = OpExtInst %void %DbgExt DebugFunction %main_name %main_type_info %dbg_src 1 1 %comp_unit %main_name FlagIsPublic 1 %main %foo_info = OpExtInst %void %DbgExt DebugLocalVariable %foo_name %int_info %dbg_src 1 1 %main_info FlagIsLocal %expr = OpExtInst %void %DbgExt DebugExpression )"; const std::string body = R"( %foo = OpVariable %u32_ptr_function Function %foo_val = OpLoad %u32 %foo )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header + GetParam(), body, opencl_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("DebugScope, DebugNoScope, DebugDeclare, DebugValue " "of debug info extension must appear in a function " "body")); } TEST_P(ValidateLocalDebugInfoOutOfFunction, VulkanDebugInfo100DebugScope) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "void main() {}" %void_name = OpString "void" %int_name = OpString "int" %foo_name = OpString "foo" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %int_info = OpExtInst %void %DbgExt DebugTypeBasic %int_name %u32_0 %u32_1 %u32_0 %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction %u32_3 %void %main_info = OpExtInst %void %DbgExt DebugFunction %main_name %main_type_info %dbg_src %u32_1 %u32_1 %comp_unit %main_name %u32_3 %u32_1 %foo_info = OpExtInst %void %DbgExt DebugLocalVariable %foo_name %int_info %dbg_src %u32_1 %u32_1 %main_info %u32_4 %expr = OpExtInst %void %DbgExt DebugExpression )"; const std::string body = R"( %foo = OpVariable %u32_ptr_function Function %main_def = OpExtInst %void %DbgExt DebugFunctionDefinition %main_info %main %foo_val = OpLoad %u32 %foo )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header + GetParam(), body, shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("DebugScope, DebugNoScope, DebugDeclare, DebugValue " "of debug info extension must appear in a function " "body")); } INSTANTIATE_TEST_SUITE_P( AllLocalDebugInfo, ValidateLocalDebugInfoOutOfFunction, ::testing::ValuesIn(std::vector{ "%main_scope = OpExtInst %void %DbgExt DebugScope %main_info", "%no_scope = OpExtInst %void %DbgExt DebugNoScope", })); TEST_F(ValidateOpenCL100DebugInfo, DebugFunctionForwardReference) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "void main() {}" %void_name = OpString "void" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction FlagIsPublic %void %main_info = OpExtInst %void %DbgExt DebugFunction %main_name %main_type_info %dbg_src 1 1 %comp_unit %main_name FlagIsPublic 1 %main )"; const std::string body = R"( %main_scope = OpExtInst %void %DbgExt DebugScope %main_info )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, body, opencl_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateOpenCL100DebugInfo, DebugFunctionMissingOpFunction) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "void main() {}" %void_name = OpString "void" )"; const std::string dbg_inst_header = R"( %dbgNone = OpExtInst %void %DbgExt DebugInfoNone %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction FlagIsPublic %void %main_info = OpExtInst %void %DbgExt DebugFunction %main_name %main_type_info %dbg_src 1 1 %comp_unit %main_name FlagIsPublic 1 %dbgNone )"; const std::string body = R"( %main_scope = OpExtInst %void %DbgExt DebugScope %main_info )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, body, opencl_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateOpenCL100DebugInfo, DebugScopeBeforeOpVariableInFunction) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "float4 main(float arg) { float foo; return float4(0, 0, 0, 0); } " %float_name = OpString "float" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %v4float_info = OpExtInst %void %DbgExt DebugTypeVector %float_info 4 %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction FlagIsPublic %v4float_info %float_info %main_info = OpExtInst %void %DbgExt DebugFunction %main_name %main_type_info %dbg_src 12 1 %comp_unit %main_name FlagIsPublic 13 %main )"; const std::string body = R"( %main_scope = OpExtInst %void %DbgExt DebugScope %main_info %foo = OpVariable %f32_ptr_function Function )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, body, opencl_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateOpenCL100DebugInfo, DebugTypeCompositeSizeDebugInfoNone) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "OpaqueType foo; main() {} " %ty_name = OpString "struct VS_OUTPUT" )"; const std::string dbg_inst_header = R"( %dbg_none = OpExtInst %void %DbgExt DebugInfoNone %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %opaque = OpExtInst %void %DbgExt DebugTypeComposite %ty_name Class %dbg_src 1 1 %comp_unit %ty_name %dbg_none FlagIsPublic )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateOpenCL100DebugInfo, DebugTypeCompositeForwardReference) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "struct VS_OUTPUT { float4 pos : SV_POSITION; float4 color : COLOR; }; main() {} " %VS_OUTPUT_name = OpString "struct VS_OUTPUT" %float_name = OpString "float" %VS_OUTPUT_pos_name = OpString "pos : SV_POSITION" %VS_OUTPUT_color_name = OpString "color : COLOR" %VS_OUTPUT_linkage_name = OpString "VS_OUTPUT" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 %int_128 = OpConstant %u32 128 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %VS_OUTPUT_info = OpExtInst %void %DbgExt DebugTypeComposite %VS_OUTPUT_name Structure %dbg_src 1 1 %comp_unit %VS_OUTPUT_linkage_name %int_128 FlagIsPublic %VS_OUTPUT_pos_info %VS_OUTPUT_color_info %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %v4float_info = OpExtInst %void %DbgExt DebugTypeVector %float_info 4 %VS_OUTPUT_pos_info = OpExtInst %void %DbgExt DebugTypeMember %VS_OUTPUT_pos_name %v4float_info %dbg_src 2 3 %VS_OUTPUT_info %u32_0 %int_128 FlagIsPublic %VS_OUTPUT_color_info = OpExtInst %void %DbgExt DebugTypeMember %VS_OUTPUT_color_name %v4float_info %dbg_src 3 3 %VS_OUTPUT_info %int_128 %int_128 FlagIsPublic )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateOpenCL100DebugInfo, DebugTypeCompositeMissingReference) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "struct VS_OUTPUT { float4 pos : SV_POSITION; float4 color : COLOR; }; main() {} " %VS_OUTPUT_name = OpString "struct VS_OUTPUT" %float_name = OpString "float" %VS_OUTPUT_pos_name = OpString "pos : SV_POSITION" %VS_OUTPUT_color_name = OpString "color : COLOR" %VS_OUTPUT_linkage_name = OpString "VS_OUTPUT" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 %int_128 = OpConstant %u32 128 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %VS_OUTPUT_info = OpExtInst %void %DbgExt DebugTypeComposite %VS_OUTPUT_name Structure %dbg_src 1 1 %comp_unit %VS_OUTPUT_linkage_name %int_128 FlagIsPublic %VS_OUTPUT_pos_info %VS_OUTPUT_color_info %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %v4float_info = OpExtInst %void %DbgExt DebugTypeVector %float_info 4 %VS_OUTPUT_pos_info = OpExtInst %void %DbgExt DebugTypeMember %VS_OUTPUT_pos_name %v4float_info %dbg_src 2 3 %VS_OUTPUT_info %u32_0 %int_128 FlagIsPublic )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("forward referenced IDs have not been defined")); } TEST_P(ValidateXDebugInfo, DebugSourceWrongResultType) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" )"; const std::string dbg_inst = R"( %dbg_src = OpExtInst %bool %DbgExt DebugSource %src %code )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo(src, "", dbg_inst, "", GetParam(), "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected result type must be a result id of " "OpTypeVoid")); } TEST_P(ValidateXDebugInfo, DebugSourceFailFile) { const std::string src = R"( %code = OpString "main() {}" )"; const std::string dbg_inst = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %DbgExt %code )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo(src, "", dbg_inst, "", GetParam(), "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand File must be a result id of " "OpString")); } TEST_P(ValidateXDebugInfo, DebugSourceFailSource) { const std::string src = R"( %src = OpString "simple.hlsl" )"; const std::string dbg_inst = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %DbgExt )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo(src, "", dbg_inst, "", GetParam(), "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand Text must be a result id of " "OpString")); } TEST_P(ValidateXDebugInfo, DebugSourceNoText) { const std::string src = R"( %src = OpString "simple.hlsl" )"; const std::string dbg_inst = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo(src, "", dbg_inst, "", GetParam(), "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } INSTANTIATE_TEST_SUITE_P(OpenCLAndVkDebugInfo100, ValidateXDebugInfo, ::testing::ValuesIn(std::vector{ R"( %DbgExt = OpExtInstImport "OpenCL.DebugInfo.100" )", R"( OpExtension "SPV_KHR_non_semantic_info" %DbgExt = OpExtInstImport "NonSemantic.Shader.DebugInfo.100" )", })); TEST_F(ValidateOpenCL100DebugInfo, DebugCompilationUnit) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" )"; const std::string dbg_inst = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateOpenCL100DebugInfo, DebugCompilationUnitFail) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" )"; const std::string dbg_inst = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %src HLSL )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand Source must be a result id of " "DebugSource")); } TEST_F(ValidateVulkan100DebugInfo, DebugCompilationUnitFail) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" )"; const std::string dbg_inst = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %src %u32_5 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand Source must be a result id of " "DebugSource")); } TEST_F(ValidateOpenCL100DebugInfo, DebugTypeBasicFailName) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "float4 main(float arg) { float foo; return float4(0, 0, 0, 0); } " %float_name = OpString "float" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %float_info = OpExtInst %void %DbgExt DebugTypeBasic %int_32 %int_32 Float )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand Name must be a result id of " "OpString")); } TEST_F(ValidateVulkan100DebugInfo, DebugTypeBasicFailName) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "float4 main(float arg) { float foo; return float4(0, 0, 0, 0); } " %float_name = OpString "float" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %u32_32 %u32_32 %u32_3 %u32_0 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand Name must be a result id of " "OpString")); } TEST_F(ValidateOpenCL100DebugInfo, DebugTypeBasicFailSize) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "float4 main(float arg) { float foo; return float4(0, 0, 0, 0); } " %float_name = OpString "float" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %float_name Float )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand Size must be a result id of " "OpConstant")); } TEST_F(ValidateVulkan100DebugInfo, DebugTypeBasicFailSize) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "float4 main(float arg) { float foo; return float4(0, 0, 0, 0); } " %float_name = OpString "float" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %float_name %u32_3 %u32_0 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand Size must be a result id of " "OpConstant")); } TEST_F(ValidateVulkan100DebugInfo, DebugTypeBasicFailFlags) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "int main() {}" %float_name = OpString "float" )"; const std::string constants = R"( %f32_32 = OpConstant %f32 32 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_3 %u32_3 %f32_32 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, constants, dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand Flags must be a result id of 32-bit " "unsigned OpConstant")); } TEST_F(ValidateOpenCL100DebugInfo, DebugTypePointer) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "float4 main(float arg) { float foo; return float4(0, 0, 0, 0); } " %float_name = OpString "float" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %pfloat_info = OpExtInst %void %DbgExt DebugTypePointer %float_info Function FlagIsLocal )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateOpenCL100DebugInfo, DebugTypePointerFail) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "float4 main(float arg) { float foo; return float4(0, 0, 0, 0); } " %float_name = OpString "float" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %pfloat_info = OpExtInst %void %DbgExt DebugTypePointer %dbg_src Function FlagIsLocal )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("expected operand Base Type is not a valid debug type")); } TEST_F(ValidateOpenCL100DebugInfo, DebugTypeQualifier) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "float4 main(float arg) { float foo; return float4(0, 0, 0, 0); } " %float_name = OpString "float" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %cfloat_info = OpExtInst %void %DbgExt DebugTypeQualifier %float_info ConstType )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateOpenCL100DebugInfo, DebugTypeQualifierFail) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "float4 main(float arg) { float foo; return float4(0, 0, 0, 0); } " %float_name = OpString "float" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %cfloat_info = OpExtInst %void %DbgExt DebugTypeQualifier %comp_unit ConstType )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("expected operand Base Type is not a valid debug type")); } TEST_F(ValidateVulkan100DebugInfo, DebugTypeQualifier) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "float4 main(float arg) { float foo; return float4(0, 0, 0, 0); } " %float_name = OpString "float" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %cfloat_info = OpExtInst %void %DbgExt DebugTypeQualifier %float_info %u32_0 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateVulkan100DebugInfo, DebugTypeQualifierFail) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "float4 main(float arg) { float foo; return float4(0, 0, 0, 0); } " %float_name = OpString "float" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %cfloat_info = OpExtInst %void %DbgExt DebugTypeQualifier %comp_unit %u32_0 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("expected operand Base Type is not a valid debug type")); } TEST_F(ValidateOpenCL100DebugInfo, DebugTypeArray) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %float_arr_info = OpExtInst %void %DbgExt DebugTypeArray %float_info %int_32 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateOpenCL100DebugInfo, DebugTypeArrayWithVariableSize) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" %int_name = OpString "int" %foo_name = OpString "foo" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %uint_info = OpExtInst %void %DbgExt DebugTypeBasic %int_name %int_32 Unsigned %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction FlagIsPublic %void %main_info = OpExtInst %void %DbgExt DebugFunction %main_name %main_type_info %dbg_src 1 1 %comp_unit %main_name FlagIsPublic 1 %main %foo_info = OpExtInst %void %DbgExt DebugLocalVariable %foo_name %uint_info %dbg_src 1 1 %main_info FlagIsLocal %float_arr_info = OpExtInst %void %DbgExt DebugTypeArray %float_info %foo_info )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateOpenCL100DebugInfo, DebugTypeArrayFailBaseType) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %float_arr_info = OpExtInst %void %DbgExt DebugTypeArray %comp_unit %int_32 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand Base Type is not a valid debug " "type")); } TEST_F(ValidateOpenCL100DebugInfo, DebugTypeArrayFailComponentCount) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %float_arr_info = OpExtInst %void %DbgExt DebugTypeArray %float_info %float_info )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Component Count must be OpConstant with a 32- or " "64-bits integer scalar type or DebugGlobalVariable or " "DebugLocalVariable with a 32- or 64-bits unsigned " "integer scalar type")); } TEST_F(ValidateOpenCL100DebugInfo, DebugTypeArrayFailComponentCountFloat) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %float_arr_info = OpExtInst %void %DbgExt DebugTypeArray %float_info %f32_4 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Component Count must be OpConstant with a 32- or " "64-bits integer scalar type or DebugGlobalVariable or " "DebugLocalVariable with a 32- or 64-bits unsigned " "integer scalar type")); } TEST_F(ValidateOpenCL100DebugInfo, DebugTypeArrayFailComponentCountZero) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %float_arr_info = OpExtInst %void %DbgExt DebugTypeArray %float_info %u32_0 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Component Count must be OpConstant with a 32- or " "64-bits integer scalar type or DebugGlobalVariable or " "DebugLocalVariable with a 32- or 64-bits unsigned " "integer scalar type")); } TEST_F(ValidateOpenCL100DebugInfo, DebugTypeArrayFailVariableSizeTypeFloat) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" %foo_name = OpString "foo" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction FlagIsPublic %void %main_info = OpExtInst %void %DbgExt DebugFunction %main_name %main_type_info %dbg_src 1 1 %comp_unit %main_name FlagIsPublic 1 %main %foo_info = OpExtInst %void %DbgExt DebugLocalVariable %foo_name %float_info %dbg_src 1 1 %main_info FlagIsLocal %float_arr_info = OpExtInst %void %DbgExt DebugTypeArray %float_info %foo_info )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Component Count must be OpConstant with a 32- or " "64-bits integer scalar type or DebugGlobalVariable or " "DebugLocalVariable with a 32- or 64-bits unsigned " "integer scalar type")); } TEST_F(ValidateVulkan100DebugInfo, DebugTypeArray) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %float_arr_info = OpExtInst %void %DbgExt DebugTypeArray %float_info %u32_32 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateVulkan100DebugInfo, DebugTypeArrayWithVariableSize) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" %uint_name = OpString "uint" %foo_name = OpString "foo" )"; const std::string constants = R"( %u32_6 = OpConstant %u32 6 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %uint_info = OpExtInst %void %DbgExt DebugTypeBasic %uint_name %u32_32 %u32_6 %u32_0 %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction %u32_3 %void %main_info = OpExtInst %void %DbgExt DebugFunction %main_name %main_type_info %dbg_src %u32_1 %u32_1 %comp_unit %main_name %u32_3 %u32_1 %foo_info = OpExtInst %void %DbgExt DebugLocalVariable %foo_name %uint_info %dbg_src %u32_1 %u32_1 %main_info %u32_4 %float_arr_info = OpExtInst %void %DbgExt DebugTypeArray %float_info %foo_info )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, constants, dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateVulkan100DebugInfo, DebugTypeArrayFailBaseType) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %float_arr_info = OpExtInst %void %DbgExt DebugTypeArray %comp_unit %u32_32 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand Base Type is not a valid debug " "type")); } TEST_F(ValidateVulkan100DebugInfo, DebugTypeArrayFailComponentCount) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %float_arr_info = OpExtInst %void %DbgExt DebugTypeArray %float_info %float_info )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Component Count must be OpConstant with a 32- or " "64-bits integer scalar type or DebugGlobalVariable or " "DebugLocalVariable with a 32- or 64-bits unsigned " "integer scalar type")); } TEST_F(ValidateVulkan100DebugInfo, DebugTypeArrayFailComponentCountFloat) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %float_arr_info = OpExtInst %void %DbgExt DebugTypeArray %float_info %f32_4 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Component Count must be OpConstant with a 32- or " "64-bits integer scalar type or DebugGlobalVariable or " "DebugLocalVariable with a 32- or 64-bits unsigned " "integer scalar type")); } TEST_F(ValidateVulkan100DebugInfo, DebugTypeArrayComponentCountZero) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %float_arr_info = OpExtInst %void %DbgExt DebugTypeArray %float_info %u32_0 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateVulkan100DebugInfo, DebugTypeArrayFailVariableSizeTypeFloat) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" %foo_name = OpString "foo" )"; const std::string constants = R"( %u32_6 = OpConstant %u32 6 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction %u32_3 %void %main_info = OpExtInst %void %DbgExt DebugFunction %main_name %main_type_info %dbg_src %u32_1 %u32_1 %comp_unit %main_name %u32_3 %u32_1 %foo_info = OpExtInst %void %DbgExt DebugLocalVariable %foo_name %float_info %dbg_src %u32_1 %u32_1 %main_info %u32_4 %float_arr_info = OpExtInst %void %DbgExt DebugTypeArray %float_info %foo_info )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, constants, dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Component Count must be OpConstant with a 32- or " "64-bits integer scalar type or DebugGlobalVariable or " "DebugLocalVariable with a 32- or 64-bits unsigned " "integer scalar type")); } TEST_F(ValidateOpenCL100DebugInfo, DebugTypeVector) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %vfloat_info = OpExtInst %void %DbgExt DebugTypeVector %float_info 4 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateOpenCL100DebugInfo, DebugTypeVectorFail) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %vfloat_info = OpExtInst %void %DbgExt DebugTypeVector %dbg_src 4 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand Base Type must be a result id of " "DebugTypeBasic")); } TEST_F(ValidateOpenCL100DebugInfo, DebugTypeVectorFailComponentZero) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %vfloat_info = OpExtInst %void %DbgExt DebugTypeVector %dbg_src 0 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand Base Type must be a result id of " "DebugTypeBasic")); } TEST_F(ValidateOpenCL100DebugInfo, DebugTypeVectorFailComponentFive) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %vfloat_info = OpExtInst %void %DbgExt DebugTypeVector %dbg_src 5 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand Base Type must be a result id of " "DebugTypeBasic")); } TEST_F(ValidateVulkan100DebugInfo, DebugTypeVector) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %vfloat_info = OpExtInst %void %DbgExt DebugTypeVector %float_info %u32_4 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateVulkan100DebugInfo, DebugTypeVectorFail) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %vfloat_info = OpExtInst %void %DbgExt DebugTypeVector %dbg_src %u32_4 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand Base Type must be a result id of " "DebugTypeBasic")); } TEST_F(ValidateVulkan100DebugInfo, DebugTypeVectorFailComponentZero) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %vfloat_info = OpExtInst %void %DbgExt DebugTypeVector %float_info %u32_0 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Component Count must be positive " "integer less than or equal to 4")); } TEST_F(ValidateVulkan100DebugInfo, DebugTypeVectorFailComponentFive) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %vfloat_info = OpExtInst %void %DbgExt DebugTypeVector %float_info %u32_5 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Component Count must be positive " "integer less than or equal to 4")); } TEST_F(ValidateVulkan100DebugInfo, DebugTypeMatrix) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" )"; const std::string constants = R"( %true = OpConstantTrue %bool )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %vfloat_info = OpExtInst %void %DbgExt DebugTypeVector %float_info %u32_4 %mfloat_info = OpExtInst %void %DbgExt DebugTypeMatrix %vfloat_info %u32_4 %true )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, constants, dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateVulkan100DebugInfo, DebugTypeMatrixFailVectorTypeType) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" )"; const std::string constants = R"( %true = OpConstantTrue %bool )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %vfloat_info = OpExtInst %void %DbgExt DebugTypeVector %float_info %u32_4 %mfloat_info = OpExtInst %void %DbgExt DebugTypeMatrix %dbg_src %u32_4 %true )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, constants, dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand Vector Type must be a result id of " "DebugTypeVector")); } TEST_F(ValidateVulkan100DebugInfo, DebugTypeMatrixFailVectorCountType) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" )"; const std::string constants = R"( %true = OpConstantTrue %bool )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %vfloat_info = OpExtInst %void %DbgExt DebugTypeVector %float_info %u32_4 %mfloat_info = OpExtInst %void %DbgExt DebugTypeMatrix %vfloat_info %dbg_src %true )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, constants, dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand Vector Count must be a result id of " "32-bit unsigned OpConstant")); } TEST_F(ValidateVulkan100DebugInfo, DebugTypeMatrixFailVectorCountZero) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" )"; const std::string constants = R"( %true = OpConstantTrue %bool )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %vfloat_info = OpExtInst %void %DbgExt DebugTypeVector %float_info %u32_4 %mfloat_info = OpExtInst %void %DbgExt DebugTypeMatrix %vfloat_info %u32_0 %true )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, constants, dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Vector Count must be positive " "integer less than or equal to 4")); } TEST_F(ValidateVulkan100DebugInfo, DebugTypeMatrixFailVectorCountFive) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" )"; const std::string constants = R"( %true = OpConstantTrue %bool )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %vfloat_info = OpExtInst %void %DbgExt DebugTypeVector %float_info %u32_4 %mfloat_info = OpExtInst %void %DbgExt DebugTypeMatrix %vfloat_info %u32_5 %true )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, constants, dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Vector Count must be positive " "integer less than or equal to 4")); } TEST_F(ValidateOpenCL100DebugInfo, DebugTypedef) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" %foo_name = OpString "foo" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %foo_info = OpExtInst %void %DbgExt DebugTypedef %foo_name %float_info %dbg_src 1 1 %comp_unit )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateOpenCL100DebugInfoDebugTypedef, Fail) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" %foo_name = OpString "foo" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 )"; const auto& param = GetParam(); std::ostringstream ss; ss << R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %foo_info = OpExtInst %void %DbgExt DebugTypedef )"; ss << param.first; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, ss.str(), "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand " + param.second + " must be a result id of ")); } INSTANTIATE_TEST_SUITE_P( AllOpenCL100DebugInfoFail, ValidateOpenCL100DebugInfoDebugTypedef, ::testing::ValuesIn(std::vector>{ std::make_pair(R"(%dbg_src %float_info %dbg_src 1 1 %comp_unit)", "Name"), std::make_pair(R"(%foo_name %dbg_src %dbg_src 1 1 %comp_unit)", "Base Type"), std::make_pair(R"(%foo_name %float_info %comp_unit 1 1 %comp_unit)", "Source"), std::make_pair(R"(%foo_name %float_info %dbg_src 1 1 %dbg_src)", "Parent"), })); TEST_F(ValidateVulkan100DebugInfo, DebugTypedef) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" %foo_name = OpString "foo" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %foo_info = OpExtInst %void %DbgExt DebugTypedef %foo_name %float_info %dbg_src %u32_1 %u32_1 %comp_unit )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateVulkan100DebugInfoDebugTypedef, Fail) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" %foo_name = OpString "foo" )"; const auto& param = GetParam(); std::ostringstream ss; ss << R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %foo_info = OpExtInst %void %DbgExt DebugTypedef )"; ss << param.first; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", ss.str(), "", shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand " + param.second + " must be a result id of ")); } INSTANTIATE_TEST_SUITE_P( AllVulkan100DebugInfoFail, ValidateVulkan100DebugInfoDebugTypedef, ::testing::ValuesIn(std::vector>{ std::make_pair( R"(%dbg_src %float_info %dbg_src %u32_1 %u32_1 %comp_unit)", "Name"), std::make_pair( R"(%foo_name %dbg_src %dbg_src %u32_1 %u32_1 %comp_unit)", "Base Type"), std::make_pair( R"(%foo_name %float_info %comp_unit %u32_1 %u32_1 %comp_unit)", "Source"), std::make_pair( R"(%foo_name %float_info %dbg_src %u32_1 %u32_1 %dbg_src)", "Parent"), })); TEST_F(ValidateOpenCL100DebugInfo, DebugTypeFunction) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %main_type_info1 = OpExtInst %void %DbgExt DebugTypeFunction FlagIsPublic %void %main_type_info2 = OpExtInst %void %DbgExt DebugTypeFunction FlagIsPublic %float_info %main_type_info3 = OpExtInst %void %DbgExt DebugTypeFunction FlagIsPublic %float_info %float_info %main_type_info4 = OpExtInst %void %DbgExt DebugTypeFunction FlagIsPublic %void %float_info %float_info )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateOpenCL100DebugInfo, DebugTypeFunctionFailReturn) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction FlagIsPublic %dbg_src %float_info )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("expected operand Return Type is not a valid debug type")); } TEST_F(ValidateOpenCL100DebugInfo, DebugTypeFunctionFailParam) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction FlagIsPublic %float_info %void )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("expected operand Parameter Types is not a valid debug type")); } TEST_F(ValidateVulkan100DebugInfo, DebugTypeFunctionAndParams) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %main_type_info1 = OpExtInst %void %DbgExt DebugTypeFunction %u32_3 %void %main_type_info2 = OpExtInst %void %DbgExt DebugTypeFunction %u32_3 %float_info %main_type_info3 = OpExtInst %void %DbgExt DebugTypeFunction %u32_3 %float_info %float_info %main_type_info4 = OpExtInst %void %DbgExt DebugTypeFunction %u32_3 %void %float_info %float_info )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateVulkan100DebugInfo, DebugTypeFunctionFailReturn) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction %u32_3 %dbg_src %float_info )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("expected operand Return Type is not a valid debug type")); } TEST_F(ValidateVulkan100DebugInfo, DebugTypeFunctionFailParam) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction %u32_3 %float_info %void )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("expected operand Parameter Types is not a valid debug type")); } TEST_F(ValidateOpenCL100DebugInfo, DebugTypeEnum) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" %foo_name = OpString "foo" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %none = OpExtInst %void %DbgExt DebugInfoNone %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %foo_info1 = OpExtInst %void %DbgExt DebugTypeEnum %foo_name %float_info %dbg_src 1 1 %comp_unit %int_32 FlagIsPublic %u32_0 %foo_name %u32_1 %foo_name %foo_info2 = OpExtInst %void %DbgExt DebugTypeEnum %foo_name %none %dbg_src 1 1 %comp_unit %int_32 FlagIsPublic %u32_0 %foo_name %u32_1 %foo_name %foo_info3 = OpExtInst %void %DbgExt DebugTypeEnum %foo_name %none %dbg_src 1 1 %comp_unit %int_32 FlagIsPublic )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateOpenCL100DebugInfoDebugTypeEnum, Fail) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" %foo_name = OpString "foo" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 )"; const auto& param = GetParam(); std::ostringstream ss; ss << R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %foo_info = OpExtInst %void %DbgExt DebugTypeEnum )"; ss << param.first; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, ss.str(), "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand " + param.second)); } INSTANTIATE_TEST_SUITE_P( AllOpenCL100DebugInfoFail, ValidateOpenCL100DebugInfoDebugTypeEnum, ::testing::ValuesIn(std::vector>{ std::make_pair( R"(%dbg_src %float_info %dbg_src 1 1 %comp_unit %int_32 FlagIsPublic %u32_0 %foo_name)", "Name"), std::make_pair( R"(%foo_name %dbg_src %dbg_src 1 1 %comp_unit %int_32 FlagIsPublic %u32_0 %foo_name)", "Underlying Types"), std::make_pair( R"(%foo_name %float_info %comp_unit 1 1 %comp_unit %int_32 FlagIsPublic %u32_0 %foo_name)", "Source"), std::make_pair( R"(%foo_name %float_info %dbg_src 1 1 %dbg_src %int_32 FlagIsPublic %u32_0 %foo_name)", "Parent"), std::make_pair( R"(%foo_name %float_info %dbg_src 1 1 %comp_unit %void FlagIsPublic %u32_0 %foo_name)", "Size"), std::make_pair( R"(%foo_name %float_info %dbg_src 1 1 %comp_unit %u32_0 FlagIsPublic %u32_0 %foo_name)", "Size"), std::make_pair( R"(%foo_name %float_info %dbg_src 1 1 %comp_unit %int_32 FlagIsPublic %foo_name %foo_name)", "Value"), std::make_pair( R"(%foo_name %float_info %dbg_src 1 1 %comp_unit %int_32 FlagIsPublic %u32_0 %u32_1)", "Name"), })); TEST_F(ValidateVulkan100DebugInfo, DebugTypeEnum) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" %foo_name = OpString "foo" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %none = OpExtInst %void %DbgExt DebugInfoNone %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %foo_info1 = OpExtInst %void %DbgExt DebugTypeEnum %foo_name %float_info %dbg_src %u32_1 %u32_1 %comp_unit %u32_32 %u32_3 %u32_0 %foo_name %u32_1 %foo_name %foo_info2 = OpExtInst %void %DbgExt DebugTypeEnum %foo_name %none %dbg_src %u32_1 %u32_1 %comp_unit %u32_32 %u32_3 %u32_0 %foo_name %u32_1 %foo_name %foo_info3 = OpExtInst %void %DbgExt DebugTypeEnum %foo_name %none %dbg_src %u32_1 %u32_1 %comp_unit %u32_32 %u32_3 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateVulkan100DebugInfoDebugTypeEnum, Fail) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" %foo_name = OpString "foo" )"; const auto& param = GetParam(); std::ostringstream ss; ss << R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %foo_info = OpExtInst %void %DbgExt DebugTypeEnum )"; ss << param.first; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", ss.str(), "", shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand " + param.second)); } INSTANTIATE_TEST_SUITE_P( AllVulkan100DebugInfoFail, ValidateVulkan100DebugInfoDebugTypeEnum, ::testing::ValuesIn(std::vector>{ std::make_pair( R"(%dbg_src %float_info %dbg_src %u32_1 %u32_1 %comp_unit %u32_32 %u32_3 %u32_0 %foo_name)", "Name"), std::make_pair( R"(%foo_name %dbg_src %dbg_src %u32_1 %u32_1 %comp_unit %u32_32 %u32_3 %u32_0 %foo_name)", "Underlying Types"), std::make_pair( R"(%foo_name %float_info %comp_unit %u32_1 %u32_1 %comp_unit %u32_32 %u32_3 %u32_0 %foo_name)", "Source"), std::make_pair( R"(%foo_name %float_info %dbg_src %u32_1 %u32_1 %dbg_src %u32_32 %u32_3 %u32_0 %foo_name)", "Parent"), std::make_pair( R"(%foo_name %float_info %dbg_src %u32_1 %u32_1 %comp_unit %void %u32_3 %u32_0 %foo_name)", "Size"), std::make_pair( R"(%foo_name %float_info %dbg_src %u32_1 %u32_1 %comp_unit %u32_0 %u32_3 %u32_0 %foo_name)", "Size"), std::make_pair( R"(%foo_name %float_info %dbg_src %u32_1 %u32_1 %comp_unit %u32_32 %u32_3 %foo_name %foo_name)", "Value"), std::make_pair( R"(%foo_name %float_info %dbg_src %u32_1 %u32_1 %comp_unit %u32_32 %u32_3 %u32_0 %u32_1)", "Name"), })); TEST_F(ValidateOpenCL100DebugInfo, DebugTypeCompositeFunctionAndInheritance) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "struct VS_OUTPUT { float4 pos : SV_POSITION; }; struct foo : VS_OUTPUT { }; main() {} " %VS_OUTPUT_name = OpString "struct VS_OUTPUT" %float_name = OpString "float" %foo_name = OpString "foo" %VS_OUTPUT_pos_name = OpString "pos : SV_POSITION" %VS_OUTPUT_linkage_name = OpString "VS_OUTPUT" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 %int_128 = OpConstant %u32 128 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %VS_OUTPUT_info = OpExtInst %void %DbgExt DebugTypeComposite %VS_OUTPUT_name Structure %dbg_src 1 1 %comp_unit %VS_OUTPUT_linkage_name %int_128 FlagIsPublic %VS_OUTPUT_pos_info %main_info %child %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %v4float_info = OpExtInst %void %DbgExt DebugTypeVector %float_info 4 %VS_OUTPUT_pos_info = OpExtInst %void %DbgExt DebugTypeMember %VS_OUTPUT_pos_name %v4float_info %dbg_src 2 3 %VS_OUTPUT_info %u32_0 %int_128 FlagIsPublic %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction FlagIsPublic %v4float_info %float_info %main_info = OpExtInst %void %DbgExt DebugFunction %main_name %main_type_info %dbg_src 12 1 %comp_unit %main_name FlagIsPublic 13 %main %foo_info = OpExtInst %void %DbgExt DebugTypeComposite %foo_name Structure %dbg_src 1 1 %comp_unit %foo_name %u32_0 FlagIsPublic %child = OpExtInst %void %DbgExt DebugTypeInheritance %foo_info %VS_OUTPUT_info %int_128 %int_128 FlagIsPublic )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateOpenCL100DebugInfoDebugTypeComposite, Fail) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "struct VS_OUTPUT { float4 pos : SV_POSITION; }; struct foo : VS_OUTPUT { }; main() {} " %VS_OUTPUT_name = OpString "struct VS_OUTPUT" %float_name = OpString "float" %foo_name = OpString "foo" %VS_OUTPUT_pos_name = OpString "pos : SV_POSITION" %VS_OUTPUT_linkage_name = OpString "VS_OUTPUT" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 %int_128 = OpConstant %u32 128 )"; const auto& param = GetParam(); std::ostringstream ss; ss << R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %VS_OUTPUT_info = OpExtInst %void %DbgExt DebugTypeComposite )"; ss << param.first; ss << R"( %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %v4float_info = OpExtInst %void %DbgExt DebugTypeVector %float_info 4 %VS_OUTPUT_pos_info = OpExtInst %void %DbgExt DebugTypeMember %VS_OUTPUT_pos_name %v4float_info %dbg_src 2 3 %VS_OUTPUT_info %u32_0 %int_128 FlagIsPublic %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction FlagIsPublic %v4float_info %float_info %main_info = OpExtInst %void %DbgExt DebugFunction %main_name %main_type_info %dbg_src 12 1 %comp_unit %main_name FlagIsPublic 13 %main %foo_info = OpExtInst %void %DbgExt DebugTypeComposite %foo_name Structure %dbg_src 1 1 %comp_unit %foo_name %u32_0 FlagIsPublic %child = OpExtInst %void %DbgExt DebugTypeInheritance %foo_info %VS_OUTPUT_info %int_128 %int_128 FlagIsPublic )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, ss.str(), "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand " + param.second + " must be ")); } INSTANTIATE_TEST_SUITE_P( AllOpenCL100DebugInfoFail, ValidateOpenCL100DebugInfoDebugTypeComposite, ::testing::ValuesIn(std::vector>{ std::make_pair( R"(%dbg_src Structure %dbg_src 1 1 %comp_unit %VS_OUTPUT_linkage_name %int_128 FlagIsPublic %VS_OUTPUT_pos_info %main_info %child)", "Name"), std::make_pair( R"(%VS_OUTPUT_name Structure %comp_unit 1 1 %comp_unit %VS_OUTPUT_linkage_name %int_128 FlagIsPublic %VS_OUTPUT_pos_info %main_info %child)", "Source"), std::make_pair( R"(%VS_OUTPUT_name Structure %dbg_src 1 1 %dbg_src %VS_OUTPUT_linkage_name %int_128 FlagIsPublic %VS_OUTPUT_pos_info %main_info %child)", "Parent"), std::make_pair( R"(%VS_OUTPUT_name Structure %dbg_src 1 1 %comp_unit %int_128 %int_128 FlagIsPublic %VS_OUTPUT_pos_info %main_info %child)", "Linkage Name"), std::make_pair( R"(%VS_OUTPUT_name Structure %dbg_src 1 1 %comp_unit %VS_OUTPUT_linkage_name %dbg_src FlagIsPublic %VS_OUTPUT_pos_info %main_info %child)", "Size"), std::make_pair( R"(%VS_OUTPUT_name Structure %dbg_src 1 1 %comp_unit %VS_OUTPUT_linkage_name %int_128 FlagIsPublic %dbg_src %main_info %child)", "Members"), std::make_pair( R"(%VS_OUTPUT_name Structure %dbg_src 1 1 %comp_unit %VS_OUTPUT_linkage_name %int_128 FlagIsPublic %VS_OUTPUT_pos_info %dbg_src %child)", "Members"), std::make_pair( R"(%VS_OUTPUT_name Structure %dbg_src 1 1 %comp_unit %VS_OUTPUT_linkage_name %int_128 FlagIsPublic %VS_OUTPUT_pos_info %main_info %dbg_src)", "Members"), })); TEST_P(ValidateOpenCL100DebugInfoDebugTypeMember, Fail) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "struct VS_OUTPUT { float pos : SV_POSITION; }; main() {} " %VS_OUTPUT_name = OpString "struct VS_OUTPUT" %float_name = OpString "float" %VS_OUTPUT_pos_name = OpString "pos : SV_POSITION" %VS_OUTPUT_linkage_name = OpString "VS_OUTPUT" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 )"; const auto& param = GetParam(); std::ostringstream ss; ss << R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %VS_OUTPUT_info = OpExtInst %void %DbgExt DebugTypeComposite %VS_OUTPUT_name Structure %dbg_src 1 1 %comp_unit %VS_OUTPUT_linkage_name %int_32 FlagIsPublic %VS_OUTPUT_pos_info %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %VS_OUTPUT_pos_info = OpExtInst %void %DbgExt DebugTypeMember )"; ss << param.first; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, ss.str(), "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); if (!param.second.empty()) { EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand " + param.second + " must be a result id of ")); } } INSTANTIATE_TEST_SUITE_P( AllOpenCL100DebugInfoFail, ValidateOpenCL100DebugInfoDebugTypeMember, ::testing::ValuesIn(std::vector>{ std::make_pair( R"(%dbg_src %float_info %dbg_src 2 3 %VS_OUTPUT_info %u32_0 %int_32 FlagIsPublic)", "Name"), std::make_pair( R"(%VS_OUTPUT_pos_name %dbg_src %dbg_src 2 3 %VS_OUTPUT_info %u32_0 %int_32 FlagIsPublic)", ""), std::make_pair( R"(%VS_OUTPUT_pos_name %float_info %float_info 2 3 %VS_OUTPUT_info %u32_0 %int_32 FlagIsPublic)", "Source"), std::make_pair( R"(%VS_OUTPUT_pos_name %float_info %dbg_src 2 3 %float_info %u32_0 %int_32 FlagIsPublic)", "Parent"), std::make_pair( R"(%VS_OUTPUT_pos_name %float_info %dbg_src 2 3 %VS_OUTPUT_info %void %int_32 FlagIsPublic)", "Offset"), std::make_pair( R"(%VS_OUTPUT_pos_name %float_info %dbg_src 2 3 %VS_OUTPUT_info %u32_0 %void FlagIsPublic)", "Size"), })); TEST_P(ValidateOpenCL100DebugInfoDebugTypeInheritance, Fail) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "struct VS_OUTPUT {}; struct foo : VS_OUTPUT {}; " %VS_OUTPUT_name = OpString "struct VS_OUTPUT" %foo_name = OpString "foo" )"; const auto& param = GetParam(); std::ostringstream ss; ss << R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %VS_OUTPUT_info = OpExtInst %void %DbgExt DebugTypeComposite %VS_OUTPUT_name Structure %dbg_src 1 1 %comp_unit %VS_OUTPUT_name %u32_0 FlagIsPublic %child %foo_info = OpExtInst %void %DbgExt DebugTypeComposite %foo_name Structure %dbg_src 1 1 %comp_unit %foo_name %u32_0 FlagIsPublic %bar_info = OpExtInst %void %DbgExt DebugTypeComposite %foo_name Union %dbg_src 1 1 %comp_unit %foo_name %u32_0 FlagIsPublic %child = OpExtInst %void %DbgExt DebugTypeInheritance )" << param.first; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", ss.str(), "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand " + param.second)); } INSTANTIATE_TEST_SUITE_P( AllOpenCL100DebugInfoFail, ValidateOpenCL100DebugInfoDebugTypeInheritance, ::testing::ValuesIn(std::vector>{ std::make_pair(R"(%dbg_src %VS_OUTPUT_info %u32_0 %u32_0 FlagIsPublic)", "Child must be a result id of"), std::make_pair(R"(%foo_info %dbg_src %u32_0 %u32_0 FlagIsPublic)", "Parent must be a result id of"), std::make_pair( R"(%bar_info %VS_OUTPUT_info %u32_0 %u32_0 FlagIsPublic)", "Child must be class or struct debug type"), std::make_pair(R"(%foo_info %bar_info %u32_0 %u32_0 FlagIsPublic)", "Parent must be class or struct debug type"), std::make_pair(R"(%foo_info %VS_OUTPUT_info %void %u32_0 FlagIsPublic)", "Offset"), std::make_pair(R"(%foo_info %VS_OUTPUT_info %u32_0 %void FlagIsPublic)", "Size"), })); TEST_F(ValidateVulkan100DebugInfo, DebugTypeComposite) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "struct VS_OUTPUT { float4 pos : SV_POSITION; }; struct foo : VS_OUTPUT { }; main() {} " %VS_OUTPUT_name = OpString "struct VS_OUTPUT" %float_name = OpString "float" %foo_name = OpString "foo" %VS_OUTPUT_pos_name = OpString "pos : SV_POSITION" %VS_OUTPUT_linkage_name = OpString "VS_OUTPUT" )"; const std::string constants = R"( %u32_128 = OpConstant %u32 128 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %v4float_info = OpExtInst %void %DbgExt DebugTypeVector %float_info %u32_4 %VS_OUTPUT_pos_info = OpExtInst %void %DbgExt DebugTypeMember %VS_OUTPUT_pos_name %v4float_info %dbg_src %u32_2 %u32_3 %u32_0 %u32_128 %u32_3 %VS_OUTPUT_info = OpExtInst %void %DbgExt DebugTypeComposite %VS_OUTPUT_name %u32_1 %dbg_src %u32_1 %u32_1 %comp_unit %VS_OUTPUT_linkage_name %u32_128 %u32_3 %VS_OUTPUT_pos_info %foo_info = OpExtInst %void %DbgExt DebugTypeComposite %foo_name %u32_1 %dbg_src %u32_1 %u32_1 %comp_unit %foo_name %u32_0 %u32_3 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, constants, dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateVulkan100DebugInfoDebugTypeComposite, Fail) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "struct VS_OUTPUT { float4 pos : SV_POSITION; }; struct foo : VS_OUTPUT { }; main() {} " %VS_OUTPUT_name = OpString "struct VS_OUTPUT" %float_name = OpString "float" %foo_name = OpString "foo" %VS_OUTPUT_pos_name = OpString "pos : SV_POSITION" %VS_OUTPUT_linkage_name = OpString "VS_OUTPUT" )"; const std::string constants = R"( %u32_128 = OpConstant %u32 128 )"; const auto& param = GetParam(); std::ostringstream ss; ss << R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %v4float_info = OpExtInst %void %DbgExt DebugTypeVector %float_info %u32_4 %VS_OUTPUT_pos_info = OpExtInst %void %DbgExt DebugTypeMember %VS_OUTPUT_pos_name %v4float_info %dbg_src %u32_2 %u32_3 %u32_0 %u32_128 %u32_3 %VS_OUTPUT_info = OpExtInst %void %DbgExt DebugTypeComposite )"; ss << param.first; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, constants, ss.str(), "", shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand " + param.second + " must be ")); } INSTANTIATE_TEST_SUITE_P( AllVulkan100DebugInfoFail, ValidateVulkan100DebugInfoDebugTypeComposite, ::testing::ValuesIn(std::vector>{ std::make_pair( R"(%dbg_src %u32_1 %dbg_src %u32_1 %u32_1 %comp_unit %VS_OUTPUT_linkage_name %u32_128 %u32_3 %VS_OUTPUT_pos_info)", "Name"), std::make_pair( R"(%VS_OUTPUT_name %u32_1 %comp_unit %u32_1 %u32_1 %comp_unit %VS_OUTPUT_linkage_name %u32_128 %u32_3 %VS_OUTPUT_pos_info)", "Source"), std::make_pair( R"(%VS_OUTPUT_name %u32_1 %dbg_src %u32_1 %u32_1 %dbg_src %VS_OUTPUT_linkage_name %u32_128 %u32_3 %VS_OUTPUT_pos_info)", "Parent"), std::make_pair( R"(%VS_OUTPUT_name %u32_1 %dbg_src %u32_1 %u32_1 %comp_unit %u32_128 %u32_128 %u32_3 %VS_OUTPUT_pos_info)", "Linkage Name"), std::make_pair( R"(%VS_OUTPUT_name %u32_1 %dbg_src %u32_1 %u32_1 %comp_unit %VS_OUTPUT_linkage_name %dbg_src %u32_3 %VS_OUTPUT_pos_info)", "Size"), std::make_pair( R"(%VS_OUTPUT_name %u32_1 %dbg_src %u32_1 %u32_1 %comp_unit %VS_OUTPUT_linkage_name %u32_128 %dbg_src %VS_OUTPUT_pos_info)", "Flags"), std::make_pair( R"(%VS_OUTPUT_name %u32_1 %dbg_src %u32_1 %u32_1 %comp_unit %VS_OUTPUT_linkage_name %u32_128 %u32_3 %dbg_src)", "Members"), })); TEST_P(ValidateVulkan100DebugInfoDebugTypeMember, Fail) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "struct VS_OUTPUT { float pos : SV_POSITION; }; main() {} " %VS_OUTPUT_name = OpString "struct VS_OUTPUT" %float_name = OpString "float" %VS_OUTPUT_pos_name = OpString "pos : SV_POSITION" %VS_OUTPUT_linkage_name = OpString "VS_OUTPUT" )"; const std::string constants = R"( %u32_128 = OpConstant %u32 128 )"; const auto& param = GetParam(); std::ostringstream ss; ss << R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %VS_OUTPUT_pos_info = OpExtInst %void %DbgExt DebugTypeMember )"; ss << param.first; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, constants, ss.str(), "", shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); if (!param.second.empty()) { EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand " + param.second + " must be a result id of ")); } } INSTANTIATE_TEST_SUITE_P( AllVulkan100DebugInfoFail, ValidateVulkan100DebugInfoDebugTypeMember, ::testing::ValuesIn(std::vector>{ std::make_pair( R"(%dbg_src %float_info %dbg_src %u32_2 %u32_3 %u32_0 %u32_32 %u32_3)", "Name"), std::make_pair( R"(%VS_OUTPUT_pos_name %dbg_src %dbg_src %u32_2 %u32_3 %u32_0 %u32_32 %u32_3)", ""), std::make_pair( R"(%VS_OUTPUT_pos_name %float_info %float_info %u32_2 %u32_3 %u32_0 %u32_32 %u32_3)", "Source"), std::make_pair( R"(%VS_OUTPUT_pos_name %float_info %dbg_src %u32_2 %u32_3 %void %u32_32 %u32_3)", "Offset"), std::make_pair( R"(%VS_OUTPUT_pos_name %float_info %dbg_src %u32_2 %u32_3 %u32_0 %void %u32_3)", "Size"), std::make_pair( R"(%VS_OUTPUT_pos_name %float_info %dbg_src %u32_2 %u32_3 %u32_0 %u32_32 %void)", "Flags"), })); TEST_F(ValidateOpenCL100DebugInfo, DebugFunctionDeclaration) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "struct VS_OUTPUT { float4 pos : SV_POSITION; }; main() {} " )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction FlagIsPublic %void %main_decl = OpExtInst %void %DbgExt DebugFunctionDeclaration %main_name %main_type_info %dbg_src 12 1 %comp_unit %main_name FlagIsPublic %main_info = OpExtInst %void %DbgExt DebugFunction %main_name %main_type_info %dbg_src 12 1 %comp_unit %main_name FlagIsPublic 13 %main)"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateOpenCL100DebugInfoDebugFunction, Fail) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "struct VS_OUTPUT { float4 pos : SV_POSITION; }; main() {} " )"; const auto& param = GetParam(); std::ostringstream ss; ss << R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction FlagIsPublic %void %main_decl = OpExtInst %void %DbgExt DebugFunctionDeclaration %main_name %main_type_info %dbg_src 12 1 %comp_unit %main_name FlagIsPublic %main_info = OpExtInst %void %DbgExt DebugFunction )" << param.first; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", ss.str(), "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand " + param.second)); } INSTANTIATE_TEST_SUITE_P( AllOpenCL100DebugInfoFail, ValidateOpenCL100DebugInfoDebugFunction, ::testing::ValuesIn(std::vector>{ std::make_pair( R"(%u32_0 %main_type_info %dbg_src 12 1 %comp_unit %main_name FlagIsPublic 13 %main)", "Name"), std::make_pair( R"(%main_name %dbg_src %dbg_src 12 1 %comp_unit %main_name FlagIsPublic 13 %main)", "Type"), std::make_pair( R"(%main_name %main_type_info %comp_unit 12 1 %comp_unit %main_name FlagIsPublic 13 %main)", "Source"), std::make_pair( R"(%main_name %main_type_info %dbg_src 12 1 %dbg_src %main_name FlagIsPublic 13 %main)", "Parent"), std::make_pair( R"(%main_name %main_type_info %dbg_src 12 1 %comp_unit %void FlagIsPublic 13 %main)", "Linkage Name"), std::make_pair( R"(%main_name %main_type_info %dbg_src 12 1 %comp_unit %main_name FlagIsPublic 13 %void)", "Function"), std::make_pair( R"(%main_name %main_type_info %dbg_src 12 1 %comp_unit %main_name FlagIsPublic 13 %main %dbg_src)", "Declaration"), })); TEST_P(ValidateOpenCL100DebugInfoDebugFunctionDeclaration, Fail) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "struct VS_OUTPUT { float4 pos : SV_POSITION; }; main() {} " )"; const auto& param = GetParam(); std::ostringstream ss; ss << R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction FlagIsPublic %void %main_decl = OpExtInst %void %DbgExt DebugFunctionDeclaration )" << param.first; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", ss.str(), "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand " + param.second)); } INSTANTIATE_TEST_SUITE_P( AllOpenCL100DebugInfoFail, ValidateOpenCL100DebugInfoDebugFunctionDeclaration, ::testing::ValuesIn(std::vector>{ std::make_pair( R"(%u32_0 %main_type_info %dbg_src 12 1 %comp_unit %main_name FlagIsPublic)", "Name"), std::make_pair( R"(%main_name %dbg_src %dbg_src 12 1 %comp_unit %main_name FlagIsPublic)", "Type"), std::make_pair( R"(%main_name %main_type_info %comp_unit 12 1 %comp_unit %main_name FlagIsPublic)", "Source"), std::make_pair( R"(%main_name %main_type_info %dbg_src 12 1 %dbg_src %main_name FlagIsPublic)", "Parent"), std::make_pair( R"(%main_name %main_type_info %dbg_src 12 1 %comp_unit %void FlagIsPublic)", "Linkage Name"), })); TEST_F(ValidateVulkan100DebugInfo, DebugFunctionDeclaration) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "struct VS_OUTPUT { float4 pos : SV_POSITION; }; main() {} " )"; const std::string constants = R"( %u32_12 = OpConstant %u32 12 %u32_13 = OpConstant %u32 13 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction %u32_3 %void %main_decl = OpExtInst %void %DbgExt DebugFunctionDeclaration %main_name %main_type_info %dbg_src %u32_12 %u32_1 %comp_unit %main_name %u32_3 %main_info = OpExtInst %void %DbgExt DebugFunction %main_name %main_type_info %dbg_src %u32_12 %u32_1 %comp_unit %main_name %u32_3 %u32_13 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, constants, dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateVulkan100DebugInfoDebugFunction, Fail) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "struct VS_OUTPUT { float4 pos : SV_POSITION; }; main() {} " )"; const std::string constants = R"( %u32_12 = OpConstant %u32 12 %u32_13 = OpConstant %u32 13 )"; const auto& param = GetParam(); std::ostringstream ss; ss << R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction %u32_3 %void %main_decl = OpExtInst %void %DbgExt DebugFunctionDeclaration %main_name %main_type_info %dbg_src %u32_12 %u32_1 %comp_unit %main_name %u32_3 %main_info = OpExtInst %void %DbgExt DebugFunction )" << param.first; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, constants, ss.str(), "", shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand " + param.second)); } INSTANTIATE_TEST_SUITE_P( AllVulkan100DebugInfoFail, ValidateVulkan100DebugInfoDebugFunction, ::testing::ValuesIn(std::vector>{ std::make_pair( R"(%u32_0 %main_type_info %dbg_src %u32_12 %u32_1 %comp_unit %main_name %u32_3 %u32_13)", "Name"), std::make_pair( R"(%main_name %dbg_src %dbg_src %u32_12 %u32_1 %comp_unit %main_name %u32_3 %u32_13)", "Type"), std::make_pair( R"(%main_name %main_type_info %comp_unit %u32_12 %u32_1 %comp_unit %main_name %u32_3 %u32_13)", "Source"), std::make_pair( R"(%main_name %main_type_info %dbg_src %u32_12 %u32_1 %dbg_src %main_name %u32_3 %u32_13)", "Parent"), std::make_pair( R"(%main_name %main_type_info %dbg_src %u32_12 %u32_1 %comp_unit %void %u32_3 %u32_13)", "Linkage Name"), std::make_pair( R"(%main_name %main_type_info %dbg_src %u32_12 %u32_1 %comp_unit %main_name %u32_3 %u32_13 %dbg_src)", "Declaration"), })); TEST_P(ValidateVulkan100DebugInfoDebugFunctionDeclaration, Fail) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "struct VS_OUTPUT { float4 pos : SV_POSITION; }; main() {} " )"; const std::string constants = R"( %u32_12 = OpConstant %u32 12 %u32_13 = OpConstant %u32 13 )"; const auto& param = GetParam(); std::ostringstream ss; ss << R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction %u32_3 %void %main_decl = OpExtInst %void %DbgExt DebugFunctionDeclaration )" << param.first; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, constants, ss.str(), "", shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand " + param.second)); } INSTANTIATE_TEST_SUITE_P( AllVulkan100DebugInfoFail, ValidateVulkan100DebugInfoDebugFunctionDeclaration, ::testing::ValuesIn(std::vector>{ std::make_pair( R"(%u32_0 %main_type_info %dbg_src %u32_12 %u32_1 %comp_unit %main_name %u32_3)", "Name"), std::make_pair( R"(%main_name %dbg_src %dbg_src %u32_12 %u32_1 %comp_unit %main_name %u32_3)", "Type"), std::make_pair( R"(%main_name %main_type_info %comp_unit %u32_12 %u32_1 %comp_unit %main_name %u32_3)", "Source"), std::make_pair( R"(%main_name %main_type_info %dbg_src %u32_12 %u32_1 %dbg_src %main_name %u32_3)", "Parent"), std::make_pair( R"(%main_name %main_type_info %dbg_src %u32_12 %u32_1 %comp_unit %void %u32_3)", "Linkage Name"), })); TEST_F(ValidateVulkan100DebugInfo, DebugFunctionType) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" %float_name = OpString "float" %uint_name = OpString "uint" )"; const std::string constants = R"( %u32_6 = OpConstant %u32 6 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %uint_info = OpExtInst %void %DbgExt DebugTypeBasic %uint_name %u32_32 %u32_6 %u32_0 %main_info = OpExtInst %void %DbgExt DebugFunction %main_name %uint_info %dbg_src %u32_1 %u32_1 %comp_unit %main_name %u32_3 %u32_1 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, constants, dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("DebugFunction: expected operand Type must be a result " "id of DebugTypeFunction")); } TEST_F(ValidateOpenCL100DebugInfo, DebugLexicalBlock) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %main_block = OpExtInst %void %DbgExt DebugLexicalBlock %dbg_src 1 1 %comp_unit %main_name)"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateOpenCL100DebugInfoDebugLexicalBlock, Fail) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" )"; const auto& param = GetParam(); std::ostringstream ss; ss << R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %main_block = OpExtInst %void %DbgExt DebugLexicalBlock )" << param.first; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", ss.str(), "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand " + param.second)); } INSTANTIATE_TEST_SUITE_P( AllOpenCL100DebugInfoFail, ValidateOpenCL100DebugInfoDebugLexicalBlock, ::testing::ValuesIn(std::vector>{ std::make_pair(R"(%comp_unit 1 1 %comp_unit %main_name)", "Source"), std::make_pair(R"(%dbg_src 1 1 %dbg_src %main_name)", "Parent"), std::make_pair(R"(%dbg_src 1 1 %comp_unit %void)", "Name"), })); TEST_F(ValidateOpenCL100DebugInfo, DebugScopeFailScope) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "void main() {}" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL )"; const std::string body = R"( %main_scope = OpExtInst %void %DbgExt DebugScope %dbg_src )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, body, opencl_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand Scope")); } TEST_F(ValidateOpenCL100DebugInfo, DebugScopeFailInlinedAt) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "void main() {}" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL )"; const std::string body = R"( %main_scope = OpExtInst %void %DbgExt DebugScope %comp_unit %dbg_src )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, body, opencl_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand Inlined At")); } TEST_F(ValidateVulkan100DebugInfo, DebugLexicalBlock) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %main_block = OpExtInst %void %DbgExt DebugLexicalBlock %dbg_src %u32_1 %u32_1 %comp_unit %main_name )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateVulkan100DebugInfoDebugLexicalBlock, Fail) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "main() {}" )"; const auto& param = GetParam(); std::ostringstream ss; ss << R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %main_block = OpExtInst %void %DbgExt DebugLexicalBlock )" << param.first; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", ss.str(), "", shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand " + param.second)); } INSTANTIATE_TEST_SUITE_P( AllVulkan100DebugInfoFail, ValidateVulkan100DebugInfoDebugLexicalBlock, ::testing::ValuesIn(std::vector>{ std::make_pair(R"(%comp_unit %u32_1 %u32_1 %comp_unit %main_name)", "Source"), std::make_pair(R"(%dbg_src %u32_1 %u32_1 %dbg_src %main_name)", "Parent"), std::make_pair(R"(%dbg_src %u32_1 %u32_1 %comp_unit %void)", "Name"), })); TEST_F(ValidateVulkan100DebugInfo, DebugScopeFailScope) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "void main() {}" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 )"; const std::string body = R"( %main_scope = OpExtInst %void %DbgExt DebugScope %dbg_src )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, body, shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand Scope")); } TEST_F(ValidateVulkan100DebugInfo, DebugScopeFailInlinedAt) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "void main() {}" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 )"; const std::string body = R"( %main_scope = OpExtInst %void %DbgExt DebugScope %comp_unit %dbg_src )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, body, shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand Inlined At")); } TEST_F(ValidateOpenCL100DebugInfo, DebugLocalVariable) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "void main() { float foo; }" %float_name = OpString "float" %foo_name = OpString "foo" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %foo = OpExtInst %void %DbgExt DebugLocalVariable %foo_name %float_info %dbg_src 1 10 %comp_unit FlagIsLocal 0 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateOpenCL100DebugInfoDebugLocalVariable, Fail) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "void main() { float foo; }" %float_name = OpString "float" %foo_name = OpString "foo" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 )"; const auto& param = GetParam(); std::ostringstream ss; ss << R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %foo = OpExtInst %void %DbgExt DebugLocalVariable )" << param.first; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, ss.str(), "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand " + param.second)); } INSTANTIATE_TEST_SUITE_P( AllOpenCL100DebugInfoFail, ValidateOpenCL100DebugInfoDebugLocalVariable, ::testing::ValuesIn(std::vector>{ std::make_pair( R"(%void %float_info %dbg_src 1 10 %comp_unit FlagIsLocal 0)", "Name"), std::make_pair( R"(%foo_name %dbg_src %dbg_src 1 10 %comp_unit FlagIsLocal 0)", "Type"), std::make_pair( R"(%foo_name %float_info %comp_unit 1 10 %comp_unit FlagIsLocal 0)", "Source"), std::make_pair( R"(%foo_name %float_info %dbg_src 1 10 %dbg_src FlagIsLocal 0)", "Parent"), })); TEST_F(ValidateVulkan100DebugInfo, DebugLocalVariable) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "void main() { float foo; }" %float_name = OpString "float" %foo_name = OpString "foo" )"; const std::string constants = R"( %u32_10 = OpConstant %u32 10 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %foo = OpExtInst %void %DbgExt DebugLocalVariable %foo_name %float_info %dbg_src %u32_1 %u32_10 %comp_unit %u32_4 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, constants, dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateVulkan100DebugInfoDebugLocalVariable, Fail) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "void main() { float foo; }" %float_name = OpString "float" %foo_name = OpString "foo" )"; const std::string constants = R"( %u32_10 = OpConstant %u32 10 )"; const auto& param = GetParam(); std::ostringstream ss; ss << R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %foo = OpExtInst %void %DbgExt DebugLocalVariable )" << param.first; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, constants, ss.str(), "", shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand " + param.second)); } INSTANTIATE_TEST_SUITE_P( AllVulkan100DebugInfoFail, ValidateVulkan100DebugInfoDebugLocalVariable, ::testing::ValuesIn(std::vector>{ std::make_pair( R"(%void %float_info %dbg_src %u32_1 %u32_10 %comp_unit %u32_3 %u32_0)", "Name"), std::make_pair( R"(%foo_name %dbg_src %dbg_src %u32_1 %u32_10 %comp_unit %u32_3 %u32_0)", "Type"), std::make_pair( R"(%foo_name %float_info %comp_unit %u32_1 %u32_10 %comp_unit %u32_3 %u32_0)", "Source"), std::make_pair( R"(%foo_name %float_info %dbg_src %u32_1 %u32_10 %dbg_src %u32_3 %u32_0)", "Parent"), })); TEST_F(ValidateOpenCL100DebugInfo, DebugDeclare) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "void main() { float foo; }" %float_name = OpString "float" %foo_name = OpString "foo" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %null_expr = OpExtInst %void %DbgExt DebugExpression %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %foo_info = OpExtInst %void %DbgExt DebugLocalVariable %foo_name %float_info %dbg_src 1 10 %comp_unit FlagIsLocal 0 )"; const std::string body = R"( %foo = OpVariable %f32_ptr_function Function %decl = OpExtInst %void %DbgExt DebugDeclare %foo_info %foo %null_expr )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, body, opencl_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateOpenCL100DebugInfo, DebugDeclareParam) { CompileSuccessfully(R"( OpCapability Shader %1 = OpExtInstImport "OpenCL.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %in_var_COLOR %4 = OpString "test.hlsl" OpSource HLSL 620 %4 "#line 1 \"test.hlsl\" void main(float foo:COLOR) {} " %11 = OpString "#line 1 \"test.hlsl\" void main(float foo:COLOR) {} " %14 = OpString "float" %17 = OpString "src.main" %20 = OpString "foo" OpName %in_var_COLOR "in.var.COLOR" OpName %main "main" OpName %param_var_foo "param.var.foo" OpName %src_main "src.main" OpName %foo "foo" OpName %bb_entry "bb.entry" OpDecorate %in_var_COLOR Location 0 %uint = OpTypeInt 32 0 %uint_32 = OpConstant %uint 32 %float = OpTypeFloat 32 %_ptr_Input_float = OpTypePointer Input %float %void = OpTypeVoid %23 = OpTypeFunction %void %_ptr_Function_float = OpTypePointer Function %float %29 = OpTypeFunction %void %_ptr_Function_float OpLine %4 1 21 %in_var_COLOR = OpVariable %_ptr_Input_float Input %10 = OpExtInst %void %1 DebugExpression %12 = OpExtInst %void %1 DebugSource %4 %11 %13 = OpExtInst %void %1 DebugCompilationUnit 1 4 %12 HLSL %15 = OpExtInst %void %1 DebugTypeBasic %14 %uint_32 Float %16 = OpExtInst %void %1 DebugTypeFunction FlagIsProtected|FlagIsPrivate %void %15 %18 = OpExtInst %void %1 DebugFunction %17 %16 %12 1 1 %13 %17 FlagIsProtected|FlagIsPrivate 1 %src_main %21 = OpExtInst %void %1 DebugLocalVariable %20 %15 %12 1 17 %18 FlagIsLocal 0 %22 = OpExtInst %void %1 DebugLexicalBlock %12 1 28 %18 OpLine %4 1 1 %main = OpFunction %void None %23 %24 = OpLabel OpLine %4 1 17 %param_var_foo = OpVariable %_ptr_Function_float Function %27 = OpLoad %float %in_var_COLOR OpLine %4 1 1 %28 = OpFunctionCall %void %src_main %param_var_foo OpReturn OpFunctionEnd %src_main = OpFunction %void None %29 OpLine %4 1 17 %foo = OpFunctionParameter %_ptr_Function_float %31 = OpExtInst %void %1 DebugDeclare %21 %foo %10 %bb_entry = OpLabel OpLine %4 1 29 OpReturn OpFunctionEnd )"); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateOpenCL100DebugInfoDebugDeclare, Fail) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "void main() { float foo; }" %float_name = OpString "float" %foo_name = OpString "foo" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %null_expr = OpExtInst %void %DbgExt DebugExpression %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %foo_info = OpExtInst %void %DbgExt DebugLocalVariable %foo_name %float_info %dbg_src 1 10 %comp_unit FlagIsLocal 0 )"; const auto& param = GetParam(); std::ostringstream ss; ss << R"( %foo = OpVariable %f32_ptr_function Function %decl = OpExtInst %void %DbgExt DebugDeclare )" << param.first; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, ss.str(), opencl_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand " + param.second)); } INSTANTIATE_TEST_SUITE_P( AllOpenCL100DebugInfoFail, ValidateOpenCL100DebugInfoDebugDeclare, ::testing::ValuesIn(std::vector>{ std::make_pair(R"(%dbg_src %foo %null_expr)", "Local Variable"), std::make_pair(R"(%foo_info %void %null_expr)", "Variable"), std::make_pair(R"(%foo_info %foo %dbg_src)", "Expression"), })); TEST_F(ValidateVulkan100DebugInfo, DebugDeclare) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "void main() { float foo; }" %float_name = OpString "float" %foo_name = OpString "foo" )"; const std::string constants = R"( %u32_10 = OpConstant %u32 10 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %null_expr = OpExtInst %void %DbgExt DebugExpression %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %foo_info = OpExtInst %void %DbgExt DebugLocalVariable %foo_name %float_info %dbg_src %u32_1 %u32_10 %comp_unit %u32_4 )"; const std::string body = R"( %foo = OpVariable %f32_ptr_function Function %decl = OpExtInst %void %DbgExt DebugDeclare %foo_info %foo %null_expr )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, constants, dbg_inst_header, body, shader_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateVulkan100DebugInfo, DebugDeclareParam) { CompileSuccessfully(R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %1 = OpExtInstImport "NonSemantic.Shader.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %in_var_COLOR %4 = OpString "test.hlsl" OpSource HLSL 620 %4 "#line 1 \"test.hlsl\" void main(float foo:COLOR) {} " %11 = OpString "#line 1 \"test.hlsl\" void main(float foo:COLOR) {} " %14 = OpString "float" %17 = OpString "src.main" %20 = OpString "foo" OpName %in_var_COLOR "in.var.COLOR" OpName %main "main" OpName %param_var_foo "param.var.foo" OpName %src_main "src.main" OpName %foo "foo" OpName %bb_entry "bb.entry" OpDecorate %in_var_COLOR Location 0 %uint = OpTypeInt 32 0 %u32_0 = OpConstant %uint 0 %u32_1 = OpConstant %uint 1 %u32_2 = OpConstant %uint 2 %u32_3 = OpConstant %uint 3 %u32_4 = OpConstant %uint 4 %u32_5 = OpConstant %uint 5 %u32_10 = OpConstant %uint 10 %u32_17 = OpConstant %uint 17 %u32_28 = OpConstant %uint 28 %u32_32 = OpConstant %uint 32 %uint_32 = OpConstant %uint 32 %float = OpTypeFloat 32 %_ptr_Input_float = OpTypePointer Input %float %void = OpTypeVoid %23 = OpTypeFunction %void %_ptr_Function_float = OpTypePointer Function %float %29 = OpTypeFunction %void %_ptr_Function_float OpLine %4 1 21 %in_var_COLOR = OpVariable %_ptr_Input_float Input %10 = OpExtInst %void %1 DebugExpression %12 = OpExtInst %void %1 DebugSource %4 %11 %13 = OpExtInst %void %1 DebugCompilationUnit %u32_1 %u32_4 %12 %u32_5 %15 = OpExtInst %void %1 DebugTypeBasic %14 %uint_32 %u32_3 %u32_0 %16 = OpExtInst %void %1 DebugTypeFunction %u32_3 %void %15 %18 = OpExtInst %void %1 DebugFunction %17 %16 %12 %u32_1 %u32_1 %13 %17 %u32_3 %u32_1 %21 = OpExtInst %void %1 DebugLocalVariable %20 %15 %12 %u32_1 %u32_17 %18 %u32_4 %u32_0 %22 = OpExtInst %void %1 DebugLexicalBlock %12 %u32_1 %u32_28 %18 %main = OpFunction %void None %23 %24 = OpLabel %param_var_foo = OpVariable %_ptr_Function_float Function %27 = OpLoad %float %in_var_COLOR %28 = OpFunctionCall %void %src_main %param_var_foo OpReturn OpFunctionEnd %src_main = OpFunction %void None %29 %foo = OpFunctionParameter %_ptr_Function_float %31 = OpExtInst %void %1 DebugDeclare %21 %foo %10 %bb_entry = OpLabel OpReturn OpFunctionEnd )"); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateVulkan100DebugInfoDebugDeclare, Fail) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "void main() { float foo; }" %float_name = OpString "float" %foo_name = OpString "foo" )"; const std::string constants = R"( %u32_10 = OpConstant %u32 10 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %null_expr = OpExtInst %void %DbgExt DebugExpression %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %foo_info = OpExtInst %void %DbgExt DebugLocalVariable %foo_name %float_info %dbg_src %u32_1 %u32_10 %comp_unit %u32_4 )"; const auto& param = GetParam(); std::ostringstream ss; ss << R"( %foo = OpVariable %f32_ptr_function Function %decl = OpExtInst %void %DbgExt DebugDeclare )" << param.first; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, constants, dbg_inst_header, ss.str(), shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand " + param.second)); } INSTANTIATE_TEST_SUITE_P( AllVulkan100DebugInfoFail, ValidateVulkan100DebugInfoDebugDeclare, ::testing::ValuesIn(std::vector>{ std::make_pair(R"(%dbg_src %foo %null_expr)", "Local Variable"), std::make_pair(R"(%foo_info %void %null_expr)", "Variable"), std::make_pair(R"(%foo_info %foo %dbg_src)", "Expression"), })); TEST_F(ValidateOpenCL100DebugInfo, DebugExpression) { const std::string dbg_inst_header = R"( %op0 = OpExtInst %void %DbgExt DebugOperation Deref %op1 = OpExtInst %void %DbgExt DebugOperation Plus %null_expr = OpExtInst %void %DbgExt DebugExpression %op0 %op1 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( "", "", dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateOpenCL100DebugInfo, DebugExpressionFail) { const std::string dbg_inst_header = R"( %op = OpExtInst %void %DbgExt DebugOperation Deref %null_expr = OpExtInst %void %DbgExt DebugExpression %op %void )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( "", "", dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "expected operand Operation must be a result id of DebugOperation")); } TEST_F(ValidateVulkan100DebugInfo, DebugExpression) { const std::string dbg_inst_header = R"( %op0 = OpExtInst %void %DbgExt DebugOperation %u32_0 %op1 = OpExtInst %void %DbgExt DebugOperation %u32_1 %null_expr = OpExtInst %void %DbgExt DebugExpression %op0 %op1 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( "", "", dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateVulkan100DebugInfo, DebugExpressionFail) { const std::string dbg_inst_header = R"( %op = OpExtInst %void %DbgExt DebugOperation %u32_0 %null_expr = OpExtInst %void %DbgExt DebugExpression %op %void )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( "", "", dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "expected operand Operation must be a result id of DebugOperation")); } TEST_F(ValidateOpenCL100DebugInfo, DebugTypeTemplate) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "OpaqueType foo; main() {} " %float_name = OpString "float" %ty_name = OpString "Texture" %t_name = OpString "T" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 %int_128 = OpConstant %u32 128 )"; const std::string dbg_inst_header = R"( %dbg_none = OpExtInst %void %DbgExt DebugInfoNone %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %opaque = OpExtInst %void %DbgExt DebugTypeComposite %ty_name Class %dbg_src 1 1 %comp_unit %ty_name %dbg_none FlagIsPublic %param = OpExtInst %void %DbgExt DebugTypeTemplateParameter %t_name %float_info %dbg_none %dbg_src 0 0 %temp = OpExtInst %void %DbgExt DebugTypeTemplate %opaque %param )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateOpenCL100DebugInfo, DebugTypeTemplateUsedForVariableType) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "OpaqueType foo; main() {} " %float_name = OpString "float" %ty_name = OpString "Texture" %t_name = OpString "T" %foo_name = OpString "foo" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 %int_128 = OpConstant %u32 128 )"; const std::string dbg_inst_header = R"( %dbg_none = OpExtInst %void %DbgExt DebugInfoNone %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %opaque = OpExtInst %void %DbgExt DebugTypeComposite %ty_name Class %dbg_src 1 1 %comp_unit %ty_name %dbg_none FlagIsPublic %param = OpExtInst %void %DbgExt DebugTypeTemplateParameter %t_name %float_info %dbg_none %dbg_src 0 0 %temp = OpExtInst %void %DbgExt DebugTypeTemplate %opaque %param %foo = OpExtInst %void %DbgExt DebugGlobalVariable %foo_name %temp %dbg_src 0 0 %comp_unit %foo_name %f32_input FlagIsProtected|FlagIsPrivate )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateOpenCL100DebugInfo, DebugTypeTemplateFunction) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "OpaqueType foo; main() {} " %float_name = OpString "float" %ty_name = OpString "Texture" %t_name = OpString "T" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 %int_128 = OpConstant %u32 128 )"; const std::string dbg_inst_header = R"( %dbg_none = OpExtInst %void %DbgExt DebugInfoNone %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %param = OpExtInst %void %DbgExt DebugTypeTemplateParameter %t_name %float_info %dbg_none %dbg_src 0 0 %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction FlagIsPublic %param %param %main_info = OpExtInst %void %DbgExt DebugFunction %main_name %main_type_info %dbg_src 1 1 %comp_unit %main_name FlagIsPublic 1 %main %temp = OpExtInst %void %DbgExt DebugTypeTemplate %main_info %param )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateOpenCL100DebugInfo, DebugTypeTemplateFailTarget) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "OpaqueType foo; main() {} " %float_name = OpString "float" %ty_name = OpString "Texture" %t_name = OpString "T" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 %int_128 = OpConstant %u32 128 )"; const std::string dbg_inst_header = R"( %dbg_none = OpExtInst %void %DbgExt DebugInfoNone %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %param = OpExtInst %void %DbgExt DebugTypeTemplateParameter %t_name %float_info %dbg_none %dbg_src 0 0 %temp = OpExtInst %void %DbgExt DebugTypeTemplate %float_info %param )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand Target must be DebugTypeComposite or " "DebugFunction")); } TEST_F(ValidateOpenCL100DebugInfo, DebugTypeTemplateFailParam) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "OpaqueType foo; main() {} " %float_name = OpString "float" %ty_name = OpString "Texture" %t_name = OpString "T" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 %int_128 = OpConstant %u32 128 )"; const std::string dbg_inst_header = R"( %dbg_none = OpExtInst %void %DbgExt DebugInfoNone %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %param = OpExtInst %void %DbgExt DebugTypeTemplateParameter %t_name %float_info %dbg_none %dbg_src 0 0 %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction FlagIsPublic %param %param %main_info = OpExtInst %void %DbgExt DebugFunction %main_name %main_type_info %dbg_src 1 1 %comp_unit %main_name FlagIsPublic 1 %main %temp = OpExtInst %void %DbgExt DebugTypeTemplate %main_info %float_info )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "expected operand Parameters must be DebugTypeTemplateParameter or " "DebugTypeTemplateTemplateParameter")); } TEST_F(ValidateVulkan100DebugInfo, DebugTypeTemplate) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "OpaqueType foo; main() {} " %float_name = OpString "float" %ty_name = OpString "Texture" %t_name = OpString "T" )"; const std::string dbg_inst_header = R"( %dbg_none = OpExtInst %void %DbgExt DebugInfoNone %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %opaque = OpExtInst %void %DbgExt DebugTypeComposite %ty_name %u32_1 %dbg_src %u32_1 %u32_1 %comp_unit %ty_name %dbg_none %u32_3 %param = OpExtInst %void %DbgExt DebugTypeTemplateParameter %t_name %float_info %dbg_none %dbg_src %u32_0 %u32_0 %temp = OpExtInst %void %DbgExt DebugTypeTemplate %opaque %param )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateVulkan100DebugInfo, DebugTypeTemplateUsedForVariableType) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "OpaqueType foo; main() {} " %float_name = OpString "float" %ty_name = OpString "Texture" %t_name = OpString "T" %foo_name = OpString "foo" )"; const std::string dbg_inst_header = R"( %dbg_none = OpExtInst %void %DbgExt DebugInfoNone %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %opaque = OpExtInst %void %DbgExt DebugTypeComposite %ty_name %u32_1 %dbg_src %u32_1 %u32_1 %comp_unit %ty_name %dbg_none %u32_3 %param = OpExtInst %void %DbgExt DebugTypeTemplateParameter %t_name %float_info %dbg_none %dbg_src %u32_0 %u32_0 %temp = OpExtInst %void %DbgExt DebugTypeTemplate %opaque %param %foo = OpExtInst %void %DbgExt DebugGlobalVariable %foo_name %temp %dbg_src %u32_0 %u32_0 %comp_unit %foo_name %f32_input %u32_3 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateVulkan100DebugInfo, DebugTypeTemplateFunction) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "OpaqueType foo; main() {} " %float_name = OpString "float" %ty_name = OpString "Texture" %t_name = OpString "T" )"; const std::string dbg_inst_header = R"( %dbg_none = OpExtInst %void %DbgExt DebugInfoNone %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %param = OpExtInst %void %DbgExt DebugTypeTemplateParameter %t_name %float_info %dbg_none %dbg_src %u32_0 %u32_0 %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction %u32_3 %param %param %main_info = OpExtInst %void %DbgExt DebugFunction %main_name %main_type_info %dbg_src %u32_1 %u32_1 %comp_unit %main_name %u32_3 %u32_1 %temp = OpExtInst %void %DbgExt DebugTypeTemplate %main_info %param )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateVulkan100DebugInfo, DebugTypeTemplateFailTarget) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "OpaqueType foo; main() {} " %float_name = OpString "float" %ty_name = OpString "Texture" %t_name = OpString "T" )"; const std::string dbg_inst_header = R"( %dbg_none = OpExtInst %void %DbgExt DebugInfoNone %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %param = OpExtInst %void %DbgExt DebugTypeTemplateParameter %t_name %float_info %dbg_none %dbg_src %u32_0 %u32_0 %temp = OpExtInst %void %DbgExt DebugTypeTemplate %float_info %param )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand Target must be DebugTypeComposite or " "DebugFunction")); } TEST_F(ValidateVulkan100DebugInfo, DebugTypeTemplateFailParam) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "OpaqueType foo; main() {} " %float_name = OpString "float" %ty_name = OpString "Texture" %t_name = OpString "T" )"; const std::string dbg_inst_header = R"( %dbg_none = OpExtInst %void %DbgExt DebugInfoNone %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %opaque = OpExtInst %void %DbgExt DebugTypeComposite %ty_name %u32_1 %dbg_src %u32_1 %u32_1 %comp_unit %ty_name %dbg_none %u32_3 %param = OpExtInst %void %DbgExt DebugTypeTemplateParameter %t_name %float_info %dbg_none %dbg_src %u32_0 %u32_0 %temp = OpExtInst %void %DbgExt DebugTypeTemplate %opaque %float_info )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "expected operand Parameters must be DebugTypeTemplateParameter or " "DebugTypeTemplateTemplateParameter")); } TEST_F(ValidateOpenCL100DebugInfo, DebugGlobalVariable) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "float foo; void main() {}" %float_name = OpString "float" %foo_name = OpString "foo" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %foo = OpExtInst %void %DbgExt DebugGlobalVariable %foo_name %float_info %dbg_src 0 0 %comp_unit %foo_name %f32_input FlagIsProtected|FlagIsPrivate )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateOpenCL100DebugInfo, DebugGlobalVariableStaticMember) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "float foo; void main() {}" %float_name = OpString "float" %foo_name = OpString "foo" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %t = OpExtInst %void %DbgExt DebugTypeComposite %foo_name Class %dbg_src 0 0 %comp_unit %foo_name %int_32 FlagIsPublic %a %a = OpExtInst %void %DbgExt DebugTypeMember %foo_name %float_info %dbg_src 0 0 %t %u32_0 %int_32 FlagIsPublic %foo = OpExtInst %void %DbgExt DebugGlobalVariable %foo_name %float_info %dbg_src 0 0 %comp_unit %foo_name %f32_input FlagIsProtected|FlagIsPrivate %a )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateOpenCL100DebugInfo, DebugGlobalVariableDebugInfoNone) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "float foo; void main() {}" %float_name = OpString "float" %foo_name = OpString "foo" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 )"; const std::string dbg_inst_header = R"( %dbgNone = OpExtInst %void %DbgExt DebugInfoNone %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %foo = OpExtInst %void %DbgExt DebugGlobalVariable %foo_name %float_info %dbg_src 0 0 %comp_unit %foo_name %dbgNone FlagIsProtected|FlagIsPrivate )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateOpenCL100DebugInfo, DebugGlobalVariableConst) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "float foo; void main() {}" %float_name = OpString "float" %foo_name = OpString "foo" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %foo = OpExtInst %void %DbgExt DebugGlobalVariable %foo_name %float_info %dbg_src 0 0 %comp_unit %foo_name %int_32 FlagIsProtected|FlagIsPrivate )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateOpenCL100DebugInfoDebugGlobalVariable, Fail) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "float foo; void main() {}" %float_name = OpString "float" %foo_name = OpString "foo" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 )"; const auto& param = GetParam(); std::ostringstream ss; ss << R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %foo = OpExtInst %void %DbgExt DebugGlobalVariable )" << param.first; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, ss.str(), "", opencl_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand " + param.second)); } INSTANTIATE_TEST_SUITE_P( AllOpenCL100DebugInfoFail, ValidateOpenCL100DebugInfoDebugGlobalVariable, ::testing::ValuesIn(std::vector>{ std::make_pair( R"(%void %float_info %dbg_src 0 0 %comp_unit %foo_name %f32_input FlagIsProtected|FlagIsPrivate)", "Name"), std::make_pair( R"(%foo_name %dbg_src %dbg_src 0 0 %comp_unit %foo_name %f32_input FlagIsProtected|FlagIsPrivate)", "Type"), std::make_pair( R"(%foo_name %float_info %comp_unit 0 0 %comp_unit %foo_name %f32_input FlagIsProtected|FlagIsPrivate)", "Source"), std::make_pair( R"(%foo_name %float_info %dbg_src 0 0 %dbg_src %foo_name %f32_input FlagIsProtected|FlagIsPrivate)", "Scope"), std::make_pair( R"(%foo_name %float_info %dbg_src 0 0 %comp_unit %void %f32_input FlagIsProtected|FlagIsPrivate)", "Linkage Name"), std::make_pair( R"(%foo_name %float_info %dbg_src 0 0 %comp_unit %foo_name %void FlagIsProtected|FlagIsPrivate)", "Variable"), })); TEST_F(ValidateVulkan100DebugInfo, DebugGlobalVariable) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "float foo; void main() {}" %float_name = OpString "float" %foo_name = OpString "foo" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %foo = OpExtInst %void %DbgExt DebugGlobalVariable %foo_name %float_info %dbg_src %u32_0 %u32_0 %comp_unit %foo_name %f32_input %u32_3 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateVulkan100DebugInfo, DebugGlobalVariableStaticMember) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "float foo; void main() {}" %float_name = OpString "float" %foo_name = OpString "foo" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %a = OpExtInst %void %DbgExt DebugTypeMember %foo_name %float_info %dbg_src %u32_0 %u32_0 %u32_0 %u32_32 %u32_3 %t = OpExtInst %void %DbgExt DebugTypeComposite %foo_name %u32_1 %dbg_src %u32_0 %u32_0 %comp_unit %foo_name %u32_32 %u32_3 %a %foo = OpExtInst %void %DbgExt DebugGlobalVariable %foo_name %t %dbg_src %u32_0 %u32_0 %comp_unit %foo_name %f32_input %u32_3 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateVulkan100DebugInfo, DebugGlobalVariableDebugInfoNone) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "float foo; void main() {}" %float_name = OpString "float" %foo_name = OpString "foo" )"; const std::string dbg_inst_header = R"( %dbgNone = OpExtInst %void %DbgExt DebugInfoNone %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %foo = OpExtInst %void %DbgExt DebugGlobalVariable %foo_name %float_info %dbg_src %u32_0 %u32_0 %comp_unit %foo_name %dbgNone %u32_3 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateVulkan100DebugInfo, DebugGlobalVariableConst) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "float foo; void main() {}" %float_name = OpString "float" %foo_name = OpString "foo" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %foo = OpExtInst %void %DbgExt DebugGlobalVariable %foo_name %float_info %dbg_src %u32_0 %u32_0 %comp_unit %foo_name %u32_32 %u32_3 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateVulkan100DebugInfoDebugGlobalVariable, Fail) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "float foo; void main() {}" %float_name = OpString "float" %foo_name = OpString "foo" )"; const auto& param = GetParam(); std::ostringstream ss; ss << R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %foo = OpExtInst %void %DbgExt DebugGlobalVariable )" << param.first; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", ss.str(), "", shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand " + param.second)); } INSTANTIATE_TEST_SUITE_P( AllOpenCL100DebugInfoFail, ValidateVulkan100DebugInfoDebugGlobalVariable, ::testing::ValuesIn(std::vector>{ std::make_pair( R"(%void %float_info %dbg_src %u32_0 %u32_0 %comp_unit %foo_name %f32_input %u32_3)", "Name"), std::make_pair( R"(%foo_name %dbg_src %dbg_src %u32_0 %u32_0 %comp_unit %foo_name %f32_input %u32_3)", "Type"), std::make_pair( R"(%foo_name %float_info %comp_unit %u32_0 %u32_0 %comp_unit %foo_name %f32_input %u32_3)", "Source"), std::make_pair( R"(%foo_name %float_info %dbg_src %u32_0 %u32_0 %dbg_src %foo_name %f32_input %u32_3)", "Scope"), std::make_pair( R"(%foo_name %float_info %dbg_src %u32_0 %u32_0 %comp_unit %void %f32_input %u32_3)", "Linkage Name"), std::make_pair( R"(%foo_name %float_info %dbg_src %u32_0 %u32_0 %comp_unit %foo_name %void %u32_3)", "Variable"), })); TEST_F(ValidateOpenCL100DebugInfo, DebugInlinedAt) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "void main() {}" %void_name = OpString "void" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction FlagIsPublic %void %main_info = OpExtInst %void %DbgExt DebugFunction %main_name %main_type_info %dbg_src 1 1 %comp_unit %main_name FlagIsPublic 1 %main %inlined_at = OpExtInst %void %DbgExt DebugInlinedAt 0 %main_info %inlined_at_recursive = OpExtInst %void %DbgExt DebugInlinedAt 0 %main_info %inlined_at )"; const std::string body = R"( %main_scope = OpExtInst %void %DbgExt DebugScope %main_info %inlined_at )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, body, opencl_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateOpenCL100DebugInfo, DebugInlinedAtFail) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "void main() {}" %void_name = OpString "void" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction FlagIsPublic %void %main_info = OpExtInst %void %DbgExt DebugFunction %main_name %main_type_info %dbg_src 1 1 %comp_unit %main_name FlagIsPublic 1 %main %inlined_at = OpExtInst %void %DbgExt DebugInlinedAt 0 %main_info %inlined_at_recursive = OpExtInst %void %DbgExt DebugInlinedAt 0 %inlined_at )"; const std::string body = R"( %main_scope = OpExtInst %void %DbgExt DebugScope %main_info %inlined_at )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, body, opencl_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand Scope")); } TEST_F(ValidateOpenCL100DebugInfo, DebugInlinedAtFail2) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "void main() {}" %void_name = OpString "void" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction FlagIsPublic %void %main_info = OpExtInst %void %DbgExt DebugFunction %main_name %main_type_info %dbg_src 1 1 %comp_unit %main_name FlagIsPublic 1 %main %inlined_at = OpExtInst %void %DbgExt DebugInlinedAt 0 %main_info %inlined_at_recursive = OpExtInst %void %DbgExt DebugInlinedAt 0 %main_info %main_info )"; const std::string body = R"( %main_scope = OpExtInst %void %DbgExt DebugScope %main_info %inlined_at )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, body, opencl_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand Inlined")); } TEST_F(ValidateVulkan100DebugInfo, DebugInlinedAt) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "void main() {}" %void_name = OpString "void" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction %u32_3 %void %main_info = OpExtInst %void %DbgExt DebugFunction %main_name %main_type_info %dbg_src %u32_1 %u32_1 %comp_unit %main_name %u32_3 %u32_1 %inlined_at = OpExtInst %void %DbgExt DebugInlinedAt %u32_0 %main_info %inlined_at_recursive = OpExtInst %void %DbgExt DebugInlinedAt %u32_0 %main_info %inlined_at )"; const std::string body = R"( %main_scope = OpExtInst %void %DbgExt DebugScope %main_info %inlined_at )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, body, shader_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateVulkan100DebugInfo, DebugInlinedAtFail) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "void main() {}" %void_name = OpString "void" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction %u32_3 %void %main_info = OpExtInst %void %DbgExt DebugFunction %main_name %main_type_info %dbg_src %u32_1 %u32_1 %comp_unit %main_name %u32_3 %u32_1 %inlined_at = OpExtInst %void %DbgExt DebugInlinedAt %u32_0 %main_info %inlined_at_recursive = OpExtInst %void %DbgExt DebugInlinedAt %u32_0 %inlined_at %inlined_at )"; const std::string body = R"( %main_scope = OpExtInst %void %DbgExt DebugScope %main_info %inlined_at )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, body, shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand Scope")); } TEST_F(ValidateVulkan100DebugInfo, DebugInlinedAtFail2) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "void main() {}" %void_name = OpString "void" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction %u32_3 %void %main_info = OpExtInst %void %DbgExt DebugFunction %main_name %main_type_info %dbg_src %u32_1 %u32_1 %comp_unit %main_name %u32_3 %u32_1 %inlined_at = OpExtInst %void %DbgExt DebugInlinedAt %u32_0 %main_info %inlined_at_recursive = OpExtInst %void %DbgExt DebugInlinedAt %u32_0 %main_info %main_info )"; const std::string body = R"( %main_scope = OpExtInst %void %DbgExt DebugScope %main_info %inlined_at )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, body, shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand Inlined")); } TEST_F(ValidateOpenCL100DebugInfo, DebugValue) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "void main() { float foo; }" %float_name = OpString "float" %foo_name = OpString "foo" )"; const std::string size_const = R"( %int_3 = OpConstant %u32 3 %int_32 = OpConstant %u32 32 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %null_expr = OpExtInst %void %DbgExt DebugExpression %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %v4float_info = OpExtInst %void %DbgExt DebugTypeVector %float_info 4 %foo_info = OpExtInst %void %DbgExt DebugLocalVariable %foo_name %v4float_info %dbg_src 1 10 %comp_unit FlagIsLocal 0 )"; const std::string body = R"( %value = OpExtInst %void %DbgExt DebugValue %foo_info %int_32 %null_expr %int_3 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, body, opencl_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateOpenCL100DebugInfo, DebugValueWithVariableIndex) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "void main() { float foo; }" %float_name = OpString "float" %int_name = OpString "int" %foo_name = OpString "foo" %len_name = OpString "length" )"; const std::string size_const = R"( %int_3 = OpConstant %u32 3 %int_32 = OpConstant %u32 32 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %null_expr = OpExtInst %void %DbgExt DebugExpression %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %int_info = OpExtInst %void %DbgExt DebugTypeBasic %int_name %int_32 Signed %v4float_info = OpExtInst %void %DbgExt DebugTypeVector %float_info 4 %foo_info = OpExtInst %void %DbgExt DebugLocalVariable %foo_name %v4float_info %dbg_src 1 10 %comp_unit FlagIsLocal %len_info = OpExtInst %void %DbgExt DebugLocalVariable %len_name %int_info %dbg_src 0 0 %comp_unit FlagIsLocal )"; const std::string body = R"( %value = OpExtInst %void %DbgExt DebugValue %foo_info %int_32 %null_expr %len_info )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, body, opencl_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateOpenCL100DebugInfoDebugValue, Fail) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "void main() { float foo; }" %float_name = OpString "float" %foo_name = OpString "foo" )"; const std::string size_const = R"( %int_32 = OpConstant %u32 32 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit 2 4 %dbg_src HLSL %null_expr = OpExtInst %void %DbgExt DebugExpression %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %int_32 Float %foo_info = OpExtInst %void %DbgExt DebugLocalVariable %foo_name %float_info %dbg_src 1 10 %comp_unit FlagIsLocal 0 )"; const auto& param = GetParam(); std::ostringstream ss; ss << R"( %decl = OpExtInst %void %DbgExt DebugValue )" << param.first; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, size_const, dbg_inst_header, ss.str(), opencl_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand " + param.second)); } INSTANTIATE_TEST_SUITE_P( AllOpenCL100DebugInfoFail, ValidateOpenCL100DebugInfoDebugValue, ::testing::ValuesIn(std::vector>{ std::make_pair(R"(%dbg_src %int_32 %null_expr)", "Local Variable"), std::make_pair(R"(%foo_info %int_32 %dbg_src)", "Expression"), std::make_pair(R"(%foo_info %int_32 %null_expr %dbg_src)", "Indexes"), })); TEST_F(ValidateVulkan100DebugInfo, DebugValue) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "void main() { float foo; }" %float_name = OpString "float" %foo_name = OpString "foo" )"; const std::string constants = R"( %u32_10 = OpConstant %u32 10 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %null_expr = OpExtInst %void %DbgExt DebugExpression %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %v4float_info = OpExtInst %void %DbgExt DebugTypeVector %float_info %u32_4 %foo_info = OpExtInst %void %DbgExt DebugLocalVariable %foo_name %v4float_info %dbg_src %u32_1 %u32_10 %comp_unit %u32_4 )"; const std::string body = R"( %value = OpExtInst %void %DbgExt DebugValue %foo_info %u32_32 %null_expr %u32_3 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, constants, dbg_inst_header, body, shader_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateVulkan100DebugInfo, DebugValueWithVariableIndex) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "void main() { float foo; }" %float_name = OpString "float" %int_name = OpString "int" %foo_name = OpString "foo" %len_name = OpString "length" )"; const std::string constants = R"( %u32_10 = OpConstant %u32 10 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %null_expr = OpExtInst %void %DbgExt DebugExpression %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %int_info = OpExtInst %void %DbgExt DebugTypeBasic %int_name %u32_32 %u32_4 %u32_0 %v4float_info = OpExtInst %void %DbgExt DebugTypeVector %float_info %u32_4 %foo_info = OpExtInst %void %DbgExt DebugLocalVariable %foo_name %v4float_info %dbg_src %u32_1 %u32_10 %comp_unit %u32_4 %u32_0 %len_info = OpExtInst %void %DbgExt DebugLocalVariable %len_name %int_info %dbg_src %u32_0 %u32_0 %comp_unit %u32_4 )"; const std::string body = R"( %value = OpExtInst %void %DbgExt DebugValue %foo_info %u32_32 %null_expr %len_info )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, constants, dbg_inst_header, body, shader_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateVulkan100DebugInfoDebugValue, Fail) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "void main() { float foo; }" %float_name = OpString "float" %foo_name = OpString "foo" )"; const std::string constants = R"( %u32_10 = OpConstant %u32 10 )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %null_expr = OpExtInst %void %DbgExt DebugExpression %float_info = OpExtInst %void %DbgExt DebugTypeBasic %float_name %u32_32 %u32_3 %u32_0 %v4float_info = OpExtInst %void %DbgExt DebugTypeVector %float_info %u32_4 %foo_info = OpExtInst %void %DbgExt DebugLocalVariable %foo_name %v4float_info %dbg_src %u32_1 %u32_10 %comp_unit %u32_4 %u32_0 )"; const auto& param = GetParam(); std::ostringstream ss; ss << R"( %decl = OpExtInst %void %DbgExt DebugValue )" << param.first; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, constants, dbg_inst_header, ss.str(), shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected operand " + param.second)); } INSTANTIATE_TEST_SUITE_P( AllOpenCL100DebugInfoFail, ValidateVulkan100DebugInfoDebugValue, ::testing::ValuesIn(std::vector>{ std::make_pair(R"(%dbg_src %u32_32 %null_expr %u32_3)", "Local Variable"), std::make_pair(R"(%foo_info %u32_32 %dbg_src %u32_3)", "Expression"), std::make_pair(R"(%foo_info %u32_32 %null_expr %dbg_src)", "Indexes"), })); TEST_F(ValidateVulkan100DebugInfo, VulkanDebugInfoSample) { std::ostringstream ss; ss << R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %id_1 = OpExtInstImport "NonSemantic.Shader.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %id_MainPs "MainPs" %id_in_var_TEXCOORD2 %id_out_var_SV_Target0 OpExecutionMode %id_MainPs OriginUpperLeft %id_7 = OpString "foo.frag" %id_27 = OpString "float" %id_32 = OpString "vColor" %id_36 = OpString "PS_OUTPUT" %id_42 = OpString "vTextureCoords" %id_46 = OpString "PS_INPUT" %id_49 = OpString "MainPs" %id_50 = OpString "" %id_55 = OpString "ps_output" %id_59 = OpString "i" %id_63 = OpString "@type.sampler" %id_64 = OpString "type.sampler" %id_66 = OpString "g_sAniso" %id_69 = OpString "@type.2d.image" %id_70 = OpString "type.2d.image" %id_72 = OpString "TemplateParam" %id_75 = OpString "g_tColor" OpName %id_type_2d_image "type.2d.image" OpName %id_g_tColor "g_tColor" OpName %id_type_sampler "type.sampler" OpName %id_g_sAniso "g_sAniso" OpName %id_in_var_TEXCOORD2 "in.var.TEXCOORD2" OpName %id_out_var_SV_Target0 "out.var.SV_Target0" OpName %id_MainPs "MainPs" OpName %id_PS_INPUT "PS_INPUT" OpMemberName %id_PS_INPUT 0 "vTextureCoords" OpName %id_param_var_i "param.var.i" OpName %id_PS_OUTPUT "PS_OUTPUT" OpMemberName %id_PS_OUTPUT 0 "vColor" OpName %id_src_MainPs "src.MainPs" OpName %id_i "i" OpName %id_bb_entry "bb.entry" OpName %id_ps_output "ps_output" OpName %id_type_sampled_image "type.sampled.image" OpDecorate %id_in_var_TEXCOORD2 Location 0 OpDecorate %id_out_var_SV_Target0 Location 0 OpDecorate %id_g_tColor DescriptorSet 0 OpDecorate %id_g_tColor Binding 0 OpDecorate %id_g_sAniso DescriptorSet 0 OpDecorate %id_g_sAniso Binding 1 %id_int = OpTypeInt 32 1 %id_int_0 = OpConstant %id_int 0 %id_uint = OpTypeInt 32 0 %id_uint_32 = OpConstant %id_uint 32 %id_float = OpTypeFloat 32 %id_type_2d_image = OpTypeImage %id_float 2D 2 0 0 1 Unknown %id__ptr_UniformConstant_type_2d_image = OpTypePointer UniformConstant %id_type_2d_image %id_type_sampler = OpTypeSampler %id__ptr_UniformConstant_type_sampler = OpTypePointer UniformConstant %id_type_sampler %id_v2float = OpTypeVector %id_float 2 %id__ptr_Input_v2float = OpTypePointer Input %id_v2float %id_v4float = OpTypeVector %id_float 4 %id__ptr_Output_v4float = OpTypePointer Output %id_v4float %id_void = OpTypeVoid %id_uint_1 = OpConstant %id_uint 1 %id_uint_4 = OpConstant %id_uint 4 %id_uint_5 = OpConstant %id_uint 5 %id_uint_3 = OpConstant %id_uint 3 %id_uint_0 = OpConstant %id_uint 0 %id_uint_128 = OpConstant %id_uint 128 %id_uint_12 = OpConstant %id_uint 12 %id_uint_10 = OpConstant %id_uint 10 %id_uint_8 = OpConstant %id_uint 8 %id_uint_2 = OpConstant %id_uint 2 %id_uint_64 = OpConstant %id_uint 64 %id_uint_7 = OpConstant %id_uint 7 %id_uint_15 = OpConstant %id_uint 15 %id_uint_16 = OpConstant %id_uint 16 %id_uint_17 = OpConstant %id_uint 17 %id_uint_29 = OpConstant %id_uint 29 %id_uint_14 = OpConstant %id_uint 14 %id_uint_11 = OpConstant %id_uint 11 %id_78 = OpTypeFunction %id_void %id_PS_INPUT = OpTypeStruct %id_v2float %id__ptr_Function_PS_INPUT = OpTypePointer Function %id_PS_INPUT %id_PS_OUTPUT = OpTypeStruct %id_v4float %id_89 = OpTypeFunction %id_PS_OUTPUT %id__ptr_Function_PS_INPUT %id__ptr_Function_PS_OUTPUT = OpTypePointer Function %id_PS_OUTPUT %id_uint_20 = OpConstant %id_uint 20 %id_uint_19 = OpConstant %id_uint 19 %id_uint_26 = OpConstant %id_uint 26 %id_uint_46 = OpConstant %id_uint 46 %id__ptr_Function_v2float = OpTypePointer Function %id_v2float %id_uint_57 = OpConstant %id_uint 57 %id_uint_78 = OpConstant %id_uint 78 %id_type_sampled_image = OpTypeSampledImage %id_type_2d_image %id_uint_81 = OpConstant %id_uint 81 %id__ptr_Function_v4float = OpTypePointer Function %id_v4float %id_g_tColor = OpVariable %id__ptr_UniformConstant_type_2d_image UniformConstant %id_g_sAniso = OpVariable %id__ptr_UniformConstant_type_sampler UniformConstant %id_in_var_TEXCOORD2 = OpVariable %id__ptr_Input_v2float Input %id_out_var_SV_Target0 = OpVariable %id__ptr_Output_v4float Output %id_22 = OpExtInst %id_void %id_1 DebugSource %id_7 %id_23 = OpExtInst %id_void %id_1 DebugCompilationUnit %id_uint_1 %id_uint_4 %id_22 %id_uint_5 %id_28 = OpExtInst %id_void %id_1 DebugTypeBasic %id_27 %id_uint_32 %id_uint_3 %id_uint_0 %id_31 = OpExtInst %id_void %id_1 DebugTypeVector %id_28 %id_uint_4 %id_34 = OpExtInst %id_void %id_1 DebugTypeMember %id_32 %id_31 %id_22 %id_uint_12 %id_uint_12 %id_uint_0 %id_uint_128 %id_uint_3 %id_37 = OpExtInst %id_void %id_1 DebugTypeComposite %id_36 %id_uint_1 %id_22 %id_uint_10 %id_uint_8 %id_23 %id_36 %id_uint_128 %id_uint_3 %id_34 %id_40 = OpExtInst %id_void %id_1 DebugTypeVector %id_28 %id_uint_2 %id_44 = OpExtInst %id_void %id_1 DebugTypeMember %id_42 %id_40 %id_22 %id_uint_7 %id_uint_12 %id_uint_0 %id_uint_64 %id_uint_3 %id_47 = OpExtInst %id_void %id_1 DebugTypeComposite %id_46 %id_uint_1 %id_22 %id_uint_5 %id_uint_8 %id_23 %id_46 %id_uint_64 %id_uint_3 %id_44 %id_48 = OpExtInst %id_void %id_1 DebugTypeFunction %id_uint_3 %id_37 %id_47 %id_51 = OpExtInst %id_void %id_1 DebugFunction %id_49 %id_48 %id_22 %id_uint_15 %id_uint_1 %id_23 %id_50 %id_uint_3 %id_uint_16 %id_54 = OpExtInst %id_void %id_1 DebugLexicalBlock %id_22 %id_uint_16 %id_uint_1 %id_51 %id_56 = OpExtInst %id_void %id_1 DebugLocalVariable %id_55 %id_37 %id_22 %id_uint_17 %id_uint_15 %id_54 %id_uint_4 %id_58 = OpExtInst %id_void %id_1 DebugExpression %id_60 = OpExtInst %id_void %id_1 DebugLocalVariable %id_59 %id_47 %id_22 %id_uint_15 %id_uint_29 %id_51 %id_uint_4 %id_uint_1 %id_62 = OpExtInst %id_void %id_1 DebugInfoNone %id_65 = OpExtInst %id_void %id_1 DebugTypeComposite %id_63 %id_uint_1 %id_22 %id_uint_0 %id_uint_0 %id_23 %id_64 %id_62 %id_uint_3 %id_67 = OpExtInst %id_void %id_1 DebugGlobalVariable %id_66 %id_65 %id_22 %id_uint_3 %id_uint_14 %id_23 %id_66 %id_g_sAniso %id_uint_8 %id_71 = OpExtInst %id_void %id_1 DebugTypeComposite %id_69 %id_uint_0 %id_22 %id_uint_0 %id_uint_0 %id_23 %id_70 %id_62 %id_uint_3 %id_73 = OpExtInst %id_void %id_1 DebugTypeTemplateParameter %id_72 %id_31 %id_62 %id_22 %id_uint_0 %id_uint_0 %id_74 = OpExtInst %id_void %id_1 DebugTypeTemplate %id_71 %id_73 %id_76 = OpExtInst %id_void %id_1 DebugGlobalVariable %id_75 %id_74 %id_22 %id_uint_1 %id_uint_11 %id_23 %id_75 %id_g_tColor %id_uint_8 %id_MainPs = OpFunction %id_void None %id_78 %id_79 = OpLabel %id_param_var_i = OpVariable %id__ptr_Function_PS_INPUT Function %id_83 = OpLoad %id_v2float %id_in_var_TEXCOORD2 %id_84 = OpCompositeConstruct %id_PS_INPUT %id_83 OpStore %id_param_var_i %id_84 %id_86 = OpFunctionCall %id_PS_OUTPUT %id_src_MainPs %id_param_var_i %id_88 = OpCompositeExtract %id_v4float %id_86 0 OpStore %id_out_var_SV_Target0 %id_88 OpReturn OpFunctionEnd %id_src_MainPs = OpFunction %id_PS_OUTPUT None %id_89 %id_i = OpFunctionParameter %id__ptr_Function_PS_INPUT %id_bb_entry = OpLabel %id_ps_output = OpVariable %id__ptr_Function_PS_OUTPUT Function %id_94 = OpExtInst %id_void %id_1 DebugScope %id_51 %id_97 = OpExtInst %id_void %id_1 DebugDeclare %id_60 %id_i %id_58 %id_99 = OpExtInst %id_void %id_1 DebugFunctionDefinition %id_51 %id_src_MainPs %id_100 = OpExtInst %id_void %id_1 DebugScope %id_54 %id_102 = OpExtInst %id_void %id_1 DebugDeclare %id_56 %id_ps_output %id_58 %id_106 = OpLoad %id_type_2d_image %id_g_tColor %id_109 = OpLoad %id_type_sampler %id_g_sAniso %id_114 = OpAccessChain %id__ptr_Function_v2float %id_i %id_int_0 %id_115 = OpLoad %id_v2float %id_114 %id_119 = OpSampledImage %id_type_sampled_image %id_106 %id_109 %id_120 = OpImageSampleImplicitLod %id_v4float %id_119 %id_115 None %id_123 = OpAccessChain %id__ptr_Function_v4float %id_ps_output %id_int_0 OpStore %id_123 %id_120 %id_125 = OpLoad %id_PS_OUTPUT %id_ps_output OpReturnValue %id_125 OpFunctionEnd )"; CompileSuccessfully(ss.str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateVulkan100DebugInfo, DebugFunctionDefinition) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "int main() { }" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction %u32_3 %void %main_info = OpExtInst %void %DbgExt DebugFunction %main_name %main_type_info %dbg_src %u32_1 %u32_1 %comp_unit %main_name %u32_3 %u32_1 )"; const std::string body = R"( %main_def = OpExtInst %void %DbgExt DebugFunctionDefinition %main_info %main )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, body, shader_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateVulkan100DebugInfo, DebugFunctionDefinitionFailFunction) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "int main() { }" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction %u32_3 %void %main_info = OpExtInst %void %DbgExt DebugFunction %main_name %main_type_info %dbg_src %u32_1 %u32_1 %comp_unit %main_name %u32_3 %u32_1 )"; const std::string body = R"( %main_def = OpExtInst %void %DbgExt DebugFunctionDefinition %main_type_info %main )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, body, shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("DebugFunctionDefinition: expected operand Function " "must be a result id of DebugFunction")); } TEST_F(ValidateVulkan100DebugInfo, DebugFunctionDefinitionFailDefinition) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "int main() { }" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction %u32_3 %void %main_info = OpExtInst %void %DbgExt DebugFunction %main_name %main_type_info %dbg_src %u32_1 %u32_1 %comp_unit %main_name %u32_3 %u32_1 )"; const std::string body = R"( %main_def = OpExtInst %void %DbgExt DebugFunctionDefinition %main_info %main_name )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, body, shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("DebugFunctionDefinition: expected operand Definition " "must be a result id of OpFunction")); } // TODO - Need to track in function scope TEST_F(ValidateVulkan100DebugInfo, DISABLED_DebugFunctionDefinitionDuplicate) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "int main() { }" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction %u32_3 %void %main_info1 = OpExtInst %void %DbgExt DebugFunction %main_name %main_type_info %dbg_src %u32_1 %u32_1 %comp_unit %main_name %u32_3 %u32_1 %main_info2 = OpExtInst %void %DbgExt DebugFunction %main_name %main_type_info %dbg_src %u32_1 %u32_1 %comp_unit %main_name %u32_3 %u32_1 )"; const std::string body = R"( %main_def1 = OpExtInst %void %DbgExt DebugFunctionDefinition %main_info1 %main %main_def2 = OpExtInst %void %DbgExt DebugFunctionDefinition %main_info2 %main )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, body, shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("DebugFunctionDefinition: Was used multiple times in " "single function block")); } // TODO - Need to track in function scope TEST_F(ValidateVulkan100DebugInfo, DISABLED_DebugFunctionDefinitionDuplicateReference) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "int main() { }" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction %u32_3 %void %main_info = OpExtInst %void %DbgExt DebugFunction %main_name %main_type_info %dbg_src %u32_1 %u32_1 %comp_unit %main_name %u32_3 %u32_1 )"; const std::string body = R"( %main_def = OpExtInst %void %DbgExt DebugFunctionDefinition %main_info %main OpReturn OpFunctionEnd %foo = OpFunction %void None %func %foo_entry = OpLabel %foo_def = OpExtInst %void %DbgExt DebugFunctionDefinition %main_info %foo )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, body, shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("DebugFunctionDefinition: Was referenced a " "DebugFunction that was already referenced before")); } TEST_F(ValidateVulkan100DebugInfo, DebugFunctionDefinitionWrongDefinition) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "int main() { }" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction %u32_3 %void %main_info = OpExtInst %void %DbgExt DebugFunction %main_name %main_type_info %dbg_src %u32_1 %u32_1 %comp_unit %main_name %u32_3 %u32_1 %foo_info = OpExtInst %void %DbgExt DebugFunction %main_name %main_type_info %dbg_src %u32_1 %u32_1 %comp_unit %main_name %u32_3 %u32_1 )"; const std::string body = R"( %main_def = OpExtInst %void %DbgExt DebugFunctionDefinition %main_info %main OpReturn OpFunctionEnd %foo = OpFunction %void None %func %foo_entry = OpLabel %foo_def = OpExtInst %void %DbgExt DebugFunctionDefinition %foo_info %main )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, body, shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("DebugFunctionDefinition: operand Definition must " "point to the OpFunction it is inside")); } TEST_F(ValidateVulkan100DebugInfo, DebugFunctionDefinitionNonEntryBlock) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "int main() { }" )"; const std::string constants = R"( %false = OpConstantFalse %bool )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction %u32_3 %void %main_info = OpExtInst %void %DbgExt DebugFunction %main_name %main_type_info %dbg_src %u32_1 %u32_1 %comp_unit %main_name %u32_3 %u32_1 )"; const std::string body = R"( OpSelectionMerge %merge_block None OpBranchConditional %false %second_block %merge_block %second_block = OpLabel OpReturn %merge_block = OpLabel %main_def = OpExtInst %void %DbgExt DebugFunctionDefinition %main_info %main )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, constants, dbg_inst_header, body, shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("DebugFunctionDefinition: must be in the entry basic " "block of the function")); } TEST_F(ValidateVulkan100DebugInfo, DebugFunctionDefinitionMultiFunctions) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "int main() { }" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %comp_unit = OpExtInst %void %DbgExt DebugCompilationUnit %u32_2 %u32_4 %dbg_src %u32_5 %main_type_info = OpExtInst %void %DbgExt DebugTypeFunction %u32_3 %void %main_info = OpExtInst %void %DbgExt DebugFunction %main_name %main_type_info %dbg_src %u32_1 %u32_1 %comp_unit %main_name %u32_3 %u32_1 %foo_info = OpExtInst %void %DbgExt DebugFunction %main_name %main_type_info %dbg_src %u32_1 %u32_1 %comp_unit %main_name %u32_3 %u32_1 )"; const std::string body = R"( %main_def = OpExtInst %void %DbgExt DebugFunctionDefinition %main_info %main OpReturn OpFunctionEnd %foo = OpFunction %void None %func %foo_entry = OpLabel %foo_def = OpExtInst %void %DbgExt DebugFunctionDefinition %foo_info %foo )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, body, shader_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateVulkan100DebugInfo, DebugLine) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "int main() { }" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code )"; const std::string body = R"( %line1 = OpExtInst %void %DbgExt DebugLine %dbg_src %u32_1 %u32_2 %u32_0 %u32_0 %line2 = OpExtInst %void %DbgExt DebugLine %dbg_src %u32_1 %u32_2 %u32_0 %u32_0 %no_line = OpExtInst %void %DbgExt DebugNoLine %line3 = OpExtInst %void %DbgExt DebugLine %dbg_src %u32_1 %u32_2 %u32_0 %u32_0 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, body, shader_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateVulkan100DebugInfo, DebugNoLineOutOfBlock) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "int main() { }" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %no_line = OpExtInst %void %DbgExt DebugNoLine )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("debug info extension must appear in a function body")); } TEST_F(ValidateVulkan100DebugInfo, DebugLineOutOfBlock) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "int main() { }" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %line = OpExtInst %void %DbgExt DebugLine %dbg_src %u32_1 %u32_2 %u32_0 %u32_0 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, "", shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("debug info extension must appear in a function body")); } TEST_F(ValidateVulkan100DebugInfo, DebugLineSource) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "int main() { }" %int_name = OpString "int" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %int_info = OpExtInst %void %DbgExt DebugTypeBasic %int_name %u32_0 %u32_1 %u32_0 )"; const std::string body = R"( %line = OpExtInst %void %DbgExt DebugLine %int_info %u32_2 %u32_2 %u32_0 %u32_0 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, body, shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("DebugLine: expected operand Source must be a result " "id of DebugSource")); } TEST_F(ValidateVulkan100DebugInfo, DebugLineFloat) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "int main() { }" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code )"; const std::string body = R"( %line1 = OpExtInst %void %DbgExt DebugLine %dbg_src %f32_1 %u32_2 %u32_0 %u32_0 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, body, shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("DebugLine: expected operand Line Start must be a " "result id of 32-bit unsigned OpConstant")); } TEST_F(ValidateVulkan100DebugInfo, DebugLineInt64) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "int main() { }" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code )"; const std::string body = R"( %line1 = OpExtInst %void %DbgExt DebugLine %dbg_src %u64_1 %u64_1 %u32_0 %u32_0 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, body, shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("DebugLine: expected operand Line Start must be a " "result id of 32-bit unsigned OpConstant")); } TEST_F(ValidateVulkan100DebugInfo, DebugLineSpecConstant) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "int main() { }" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code %spec_int = OpSpecConstant %u32 2 )"; const std::string body = R"( %line1 = OpExtInst %void %DbgExt DebugLine %dbg_src %spec_int %u32_1 %u32_0 %u32_0 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, body, shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("DebugLine: expected operand Line Start must be a " "result id of 32-bit unsigned OpConstant")); } TEST_F(ValidateVulkan100DebugInfo, DebugLineLineEndSmaller) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "int main() { }" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code )"; const std::string body = R"( %line1 = OpExtInst %void %DbgExt DebugLine %dbg_src %u32_2 %u32_1 %u32_0 %u32_0 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, body, shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("DebugLine: operand Line End (1) is less than Line Start (2)")); } TEST_F(ValidateVulkan100DebugInfo, DebugLineColumnEndSmaller) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "int main() { }" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code )"; const std::string body = R"( %line1 = OpExtInst %void %DbgExt DebugLine %dbg_src %u32_1 %u32_1 %u32_1 %u32_0 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, body, shader_extension, "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("DebugLine: operand Column End (0) is less than Column " "Start (1) when Line Start equals Line End")); } TEST_F(ValidateVulkan100DebugInfo, DebugLineColumnEndSmallerMultiline) { const std::string src = R"( %src = OpString "simple.hlsl" %code = OpString "int main() { }" )"; const std::string dbg_inst_header = R"( %dbg_src = OpExtInst %void %DbgExt DebugSource %src %code )"; const std::string body = R"( %line1 = OpExtInst %void %DbgExt DebugLine %dbg_src %u32_1 %u32_2 %u32_1 %u32_0 )"; CompileSuccessfully(GenerateShaderCodeForDebugInfo( src, "", dbg_inst_header, body, shader_extension, "Vertex")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_ext_inst_test.cpp000066400000000000000000011032021475742701700245330ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Tests validation rules of GLSL.450.std and OpenCL.std extended instructions. // Doesn't test OpenCL.std vector size 2, 3, 4, 8 or 16 rules (not supported // by standard SPIR-V). #include #include #include #include "gmock/gmock.h" #include "test/unit_spirv.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::Eq; using ::testing::HasSubstr; using ::testing::Not; using ValidateExtInst = spvtest::ValidateBase; using ValidateGlslStd450SqrtLike = spvtest::ValidateBase; using ValidateGlslStd450FMinLike = spvtest::ValidateBase; using ValidateGlslStd450FClampLike = spvtest::ValidateBase; using ValidateGlslStd450SAbsLike = spvtest::ValidateBase; using ValidateGlslStd450UMinLike = spvtest::ValidateBase; using ValidateGlslStd450UClampLike = spvtest::ValidateBase; using ValidateGlslStd450SinLike = spvtest::ValidateBase; using ValidateGlslStd450PowLike = spvtest::ValidateBase; using ValidateGlslStd450Pack = spvtest::ValidateBase; using ValidateGlslStd450Unpack = spvtest::ValidateBase; using ValidateOpenCLStdSqrtLike = spvtest::ValidateBase; using ValidateOpenCLStdFMinLike = spvtest::ValidateBase; using ValidateOpenCLStdFClampLike = spvtest::ValidateBase; using ValidateOpenCLStdSAbsLike = spvtest::ValidateBase; using ValidateOpenCLStdUMinLike = spvtest::ValidateBase; using ValidateOpenCLStdUClampLike = spvtest::ValidateBase; using ValidateOpenCLStdUMul24Like = spvtest::ValidateBase; using ValidateOpenCLStdUMad24Like = spvtest::ValidateBase; using ValidateOpenCLStdLengthLike = spvtest::ValidateBase; using ValidateOpenCLStdDistanceLike = spvtest::ValidateBase; using ValidateOpenCLStdNormalizeLike = spvtest::ValidateBase; using ValidateOpenCLStdVStoreHalfLike = spvtest::ValidateBase; using ValidateOpenCLStdVLoadHalfLike = spvtest::ValidateBase; using ValidateOpenCLStdFractLike = spvtest::ValidateBase; using ValidateOpenCLStdFrexpLike = spvtest::ValidateBase; using ValidateOpenCLStdLdexpLike = spvtest::ValidateBase; using ValidateOpenCLStdUpsampleLike = spvtest::ValidateBase; using ValidateClspvReflection = spvtest::ValidateBase; // Returns number of components in Pack/Unpack extended instructions. // |ext_inst_name| is expected to be of the format "PackHalf2x16". // Number of components is assumed to be single-digit. uint32_t GetPackedNumComponents(const std::string& ext_inst_name) { const size_t x_index = ext_inst_name.find_last_of('x'); const std::string num_components_str = ext_inst_name.substr(x_index - 1, x_index); return uint32_t(std::stoul(num_components_str)); } // Returns packed bit width in Pack/Unpack extended instructions. // |ext_inst_name| is expected to be of the format "PackHalf2x16". uint32_t GetPackedBitWidth(const std::string& ext_inst_name) { const size_t x_index = ext_inst_name.find_last_of('x'); const std::string packed_bit_width_str = ext_inst_name.substr(x_index + 1); return uint32_t(std::stoul(packed_bit_width_str)); } std::string GenerateShaderCode( const std::string& body, const std::string& capabilities_and_extensions = "", const std::string& execution_model = "Fragment") { std::ostringstream ss; ss << R"( OpCapability Shader OpCapability Float16 OpCapability Float64 OpCapability Int16 OpCapability Int64 )"; ss << capabilities_and_extensions; ss << "%extinst = OpExtInstImport \"GLSL.std.450\"\n"; ss << "OpMemoryModel Logical GLSL450\n"; ss << "OpEntryPoint " << execution_model << " %main \"main\"" << " %f32_output" << " %f32vec2_output" << " %u32_output" << " %u32vec2_output" << " %u64_output" << " %f32_input" << " %f32vec2_input" << " %u32_input" << " %u32vec2_input" << " %u64_input" << "\n"; if (execution_model == "Fragment") { ss << "OpExecutionMode %main OriginUpperLeft\n"; } ss << R"( %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f16 = OpTypeFloat 16 %f32 = OpTypeFloat 32 %f64 = OpTypeFloat 64 %u32 = OpTypeInt 32 0 %s32 = OpTypeInt 32 1 %u64 = OpTypeInt 64 0 %s64 = OpTypeInt 64 1 %u16 = OpTypeInt 16 0 %s16 = OpTypeInt 16 1 %f32vec2 = OpTypeVector %f32 2 %f32vec3 = OpTypeVector %f32 3 %f32vec4 = OpTypeVector %f32 4 %f64vec2 = OpTypeVector %f64 2 %f64vec3 = OpTypeVector %f64 3 %f64vec4 = OpTypeVector %f64 4 %u32vec2 = OpTypeVector %u32 2 %u32vec3 = OpTypeVector %u32 3 %s32vec2 = OpTypeVector %s32 2 %u32vec4 = OpTypeVector %u32 4 %s32vec4 = OpTypeVector %s32 4 %u64vec2 = OpTypeVector %u64 2 %s64vec2 = OpTypeVector %s64 2 %f64mat22 = OpTypeMatrix %f64vec2 2 %f32mat22 = OpTypeMatrix %f32vec2 2 %f32mat23 = OpTypeMatrix %f32vec2 3 %f32mat32 = OpTypeMatrix %f32vec3 2 %f32mat33 = OpTypeMatrix %f32vec3 3 %f32_0 = OpConstant %f32 0 %f32_1 = OpConstant %f32 1 %f32_2 = OpConstant %f32 2 %f32_3 = OpConstant %f32 3 %f32_4 = OpConstant %f32 4 %f32_h = OpConstant %f32 0.5 %f32vec2_01 = OpConstantComposite %f32vec2 %f32_0 %f32_1 %f32vec2_12 = OpConstantComposite %f32vec2 %f32_1 %f32_2 %f32vec3_012 = OpConstantComposite %f32vec3 %f32_0 %f32_1 %f32_2 %f32vec3_123 = OpConstantComposite %f32vec3 %f32_1 %f32_2 %f32_3 %f32vec4_0123 = OpConstantComposite %f32vec4 %f32_0 %f32_1 %f32_2 %f32_3 %f32vec4_1234 = OpConstantComposite %f32vec4 %f32_1 %f32_2 %f32_3 %f32_4 %f64_0 = OpConstant %f64 0 %f64_1 = OpConstant %f64 1 %f64_2 = OpConstant %f64 2 %f64_3 = OpConstant %f64 3 %f64vec2_01 = OpConstantComposite %f64vec2 %f64_0 %f64_1 %f64vec3_012 = OpConstantComposite %f64vec3 %f64_0 %f64_1 %f64_2 %f64vec4_0123 = OpConstantComposite %f64vec4 %f64_0 %f64_1 %f64_2 %f64_3 %f16_0 = OpConstant %f16 0 %f16_1 = OpConstant %f16 1 %f16_h = OpConstant %f16 0.5 %u32_0 = OpConstant %u32 0 %u32_1 = OpConstant %u32 1 %u32_2 = OpConstant %u32 2 %u32_3 = OpConstant %u32 3 %s32_0 = OpConstant %s32 0 %s32_1 = OpConstant %s32 1 %s32_2 = OpConstant %s32 2 %s32_3 = OpConstant %s32 3 %u64_0 = OpConstant %u64 0 %u64_1 = OpConstant %u64 1 %u64_2 = OpConstant %u64 2 %u64_3 = OpConstant %u64 3 %s64_0 = OpConstant %s64 0 %s64_1 = OpConstant %s64 1 %s64_2 = OpConstant %s64 2 %s64_3 = OpConstant %s64 3 %s32vec2_01 = OpConstantComposite %s32vec2 %s32_0 %s32_1 %u32vec2_01 = OpConstantComposite %u32vec2 %u32_0 %u32_1 %s32vec2_12 = OpConstantComposite %s32vec2 %s32_1 %s32_2 %u32vec2_12 = OpConstantComposite %u32vec2 %u32_1 %u32_2 %s32vec4_0123 = OpConstantComposite %s32vec4 %s32_0 %s32_1 %s32_2 %s32_3 %u32vec4_0123 = OpConstantComposite %u32vec4 %u32_0 %u32_1 %u32_2 %u32_3 %s64vec2_01 = OpConstantComposite %s64vec2 %s64_0 %s64_1 %u64vec2_01 = OpConstantComposite %u64vec2 %u64_0 %u64_1 %f32mat22_1212 = OpConstantComposite %f32mat22 %f32vec2_12 %f32vec2_12 %f32mat23_121212 = OpConstantComposite %f32mat23 %f32vec2_12 %f32vec2_12 %f32vec2_12 %f32_ptr_output = OpTypePointer Output %f32 %f32vec2_ptr_output = OpTypePointer Output %f32vec2 %u32_ptr_output = OpTypePointer Output %u32 %u32vec2_ptr_output = OpTypePointer Output %u32vec2 %u64_ptr_output = OpTypePointer Output %u64 %f32_output = OpVariable %f32_ptr_output Output %f32vec2_output = OpVariable %f32vec2_ptr_output Output %u32_output = OpVariable %u32_ptr_output Output %u32vec2_output = OpVariable %u32vec2_ptr_output Output %u64_output = OpVariable %u64_ptr_output Output %f32_ptr_input = OpTypePointer Input %f32 %f32vec2_ptr_input = OpTypePointer Input %f32vec2 %u32_ptr_input = OpTypePointer Input %u32 %u32vec2_ptr_input = OpTypePointer Input %u32vec2 %u64_ptr_input = OpTypePointer Input %u64 %f32_input = OpVariable %f32_ptr_input Input %f32vec2_input = OpVariable %f32vec2_ptr_input Input %u32_input = OpVariable %u32_ptr_input Input %u32vec2_input = OpVariable %u32vec2_ptr_input Input %u64_input = OpVariable %u64_ptr_input Input %struct_f16_u16 = OpTypeStruct %f16 %u16 %struct_f32_f32 = OpTypeStruct %f32 %f32 %struct_f32_f32_f32 = OpTypeStruct %f32 %f32 %f32 %struct_f32_u32 = OpTypeStruct %f32 %u32 %struct_f32_u32_f32 = OpTypeStruct %f32 %u32 %f32 %struct_u32_f32 = OpTypeStruct %u32 %f32 %struct_u32_u32 = OpTypeStruct %u32 %u32 %struct_f32_f64 = OpTypeStruct %f32 %f64 %struct_f32vec2_f32vec2 = OpTypeStruct %f32vec2 %f32vec2 %struct_f32vec2_u32vec2 = OpTypeStruct %f32vec2 %u32vec2 %main = OpFunction %void None %func %main_entry = OpLabel )"; ss << body; ss << R"( OpReturn OpFunctionEnd)"; return ss.str(); } std::string GenerateKernelCode( const std::string& body, const std::string& capabilities_and_extensions = "", const std::string& memory_model = "Physical32") { std::ostringstream ss; ss << R"( OpCapability Addresses OpCapability Kernel OpCapability Linkage OpCapability GenericPointer OpCapability Int8 OpCapability Int16 OpCapability Int64 OpCapability Float16 OpCapability Float64 OpCapability Vector16 OpCapability Matrix )"; ss << capabilities_and_extensions; ss << "%extinst = OpExtInstImport \"OpenCL.std\"\n"; ss << "OpMemoryModel " << memory_model << " OpenCL\n"; ss << R"( %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f16 = OpTypeFloat 16 %f32 = OpTypeFloat 32 %f64 = OpTypeFloat 64 %u32 = OpTypeInt 32 0 %u64 = OpTypeInt 64 0 %u16 = OpTypeInt 16 0 %u8 = OpTypeInt 8 0 %f32vec2 = OpTypeVector %f32 2 %f32vec3 = OpTypeVector %f32 3 %f32vec4 = OpTypeVector %f32 4 %f32vec8 = OpTypeVector %f32 8 %f16vec8 = OpTypeVector %f16 8 %f32vec16 = OpTypeVector %f32 16 %f64vec2 = OpTypeVector %f64 2 %f64vec3 = OpTypeVector %f64 3 %f64vec4 = OpTypeVector %f64 4 %u32vec2 = OpTypeVector %u32 2 %u32vec3 = OpTypeVector %u32 3 %u32vec4 = OpTypeVector %u32 4 %u32vec8 = OpTypeVector %u32 8 %u64vec2 = OpTypeVector %u64 2 %f64mat22 = OpTypeMatrix %f64vec2 2 %f32mat22 = OpTypeMatrix %f32vec2 2 %f32mat23 = OpTypeMatrix %f32vec2 3 %f32mat32 = OpTypeMatrix %f32vec3 2 %f32mat33 = OpTypeMatrix %f32vec3 3 %f32_0 = OpConstant %f32 0 %f32_1 = OpConstant %f32 1 %f32_2 = OpConstant %f32 2 %f32_3 = OpConstant %f32 3 %f32_4 = OpConstant %f32 4 %f32_h = OpConstant %f32 0.5 %f32vec2_01 = OpConstantComposite %f32vec2 %f32_0 %f32_1 %f32vec2_12 = OpConstantComposite %f32vec2 %f32_1 %f32_2 %f32vec3_012 = OpConstantComposite %f32vec3 %f32_0 %f32_1 %f32_2 %f32vec3_123 = OpConstantComposite %f32vec3 %f32_1 %f32_2 %f32_3 %f32vec4_0123 = OpConstantComposite %f32vec4 %f32_0 %f32_1 %f32_2 %f32_3 %f32vec4_1234 = OpConstantComposite %f32vec4 %f32_1 %f32_2 %f32_3 %f32_4 %f32vec8_01010101 = OpConstantComposite %f32vec8 %f32_0 %f32_1 %f32_0 %f32_1 %f32_0 %f32_1 %f32_0 %f32_1 %f64_0 = OpConstant %f64 0 %f64_1 = OpConstant %f64 1 %f64_2 = OpConstant %f64 2 %f64_3 = OpConstant %f64 3 %f64vec2_01 = OpConstantComposite %f64vec2 %f64_0 %f64_1 %f64vec3_012 = OpConstantComposite %f64vec3 %f64_0 %f64_1 %f64_2 %f64vec4_0123 = OpConstantComposite %f64vec4 %f64_0 %f64_1 %f64_2 %f64_3 %f16_0 = OpConstant %f16 0 %f16_1 = OpConstant %f16 1 %u8_0 = OpConstant %u8 0 %u8_1 = OpConstant %u8 1 %u8_2 = OpConstant %u8 2 %u8_3 = OpConstant %u8 3 %u16_0 = OpConstant %u16 0 %u16_1 = OpConstant %u16 1 %u16_2 = OpConstant %u16 2 %u16_3 = OpConstant %u16 3 %u32_0 = OpConstant %u32 0 %u32_1 = OpConstant %u32 1 %u32_2 = OpConstant %u32 2 %u32_3 = OpConstant %u32 3 %u32_256 = OpConstant %u32 256 %u64_0 = OpConstant %u64 0 %u64_1 = OpConstant %u64 1 %u64_2 = OpConstant %u64 2 %u64_3 = OpConstant %u64 3 %u64_256 = OpConstant %u64 256 %u32vec2_01 = OpConstantComposite %u32vec2 %u32_0 %u32_1 %u32vec2_12 = OpConstantComposite %u32vec2 %u32_1 %u32_2 %u32vec3_012 = OpConstantComposite %u32vec3 %u32_0 %u32_1 %u32_2 %u32vec4_0123 = OpConstantComposite %u32vec4 %u32_0 %u32_1 %u32_2 %u32_3 %u64vec2_01 = OpConstantComposite %u64vec2 %u64_0 %u64_1 %f32mat22_1212 = OpConstantComposite %f32mat22 %f32vec2_12 %f32vec2_12 %f32mat23_121212 = OpConstantComposite %f32mat23 %f32vec2_12 %f32vec2_12 %f32vec2_12 %struct_f32_f32 = OpTypeStruct %f32 %f32 %struct_f32_f32_f32 = OpTypeStruct %f32 %f32 %f32 %struct_f32_u32 = OpTypeStruct %f32 %u32 %struct_f32_u32_f32 = OpTypeStruct %f32 %u32 %f32 %struct_u32_f32 = OpTypeStruct %u32 %f32 %struct_u32_u32 = OpTypeStruct %u32 %u32 %struct_f32_f64 = OpTypeStruct %f32 %f64 %struct_f32vec2_f32vec2 = OpTypeStruct %f32vec2 %f32vec2 %struct_f32vec2_u32vec2 = OpTypeStruct %f32vec2 %u32vec2 %f16vec8_ptr_workgroup = OpTypePointer Workgroup %f16vec8 %f16vec8_workgroup = OpVariable %f16vec8_ptr_workgroup Workgroup %f16_ptr_workgroup = OpTypePointer Workgroup %f16 %u32vec8_ptr_workgroup = OpTypePointer Workgroup %u32vec8 %u32vec8_workgroup = OpVariable %u32vec8_ptr_workgroup Workgroup %u32_ptr_workgroup = OpTypePointer Workgroup %u32 %f32vec8_ptr_workgroup = OpTypePointer Workgroup %f32vec8 %f32vec8_workgroup = OpVariable %f32vec8_ptr_workgroup Workgroup %f32_ptr_workgroup = OpTypePointer Workgroup %f32 %u32arr = OpTypeArray %u32 %u32_256 %u32arr_ptr_cross_workgroup = OpTypePointer CrossWorkgroup %u32arr %u32arr_cross_workgroup = OpVariable %u32arr_ptr_cross_workgroup CrossWorkgroup %u32_ptr_cross_workgroup = OpTypePointer CrossWorkgroup %u32 %f32arr = OpTypeArray %f32 %u32_256 %f32arr_ptr_cross_workgroup = OpTypePointer CrossWorkgroup %f32arr %f32arr_cross_workgroup = OpVariable %f32arr_ptr_cross_workgroup CrossWorkgroup %f32_ptr_cross_workgroup = OpTypePointer CrossWorkgroup %f32 %f32vec2arr = OpTypeArray %f32vec2 %u32_256 %f32vec2arr_ptr_cross_workgroup = OpTypePointer CrossWorkgroup %f32vec2arr %f32vec2arr_cross_workgroup = OpVariable %f32vec2arr_ptr_cross_workgroup CrossWorkgroup %f32vec2_ptr_cross_workgroup = OpTypePointer CrossWorkgroup %f32vec2 %struct_arr = OpTypeArray %struct_f32_f32 %u32_256 %struct_arr_ptr_cross_workgroup = OpTypePointer CrossWorkgroup %struct_arr %struct_arr_cross_workgroup = OpVariable %struct_arr_ptr_cross_workgroup CrossWorkgroup %struct_ptr_cross_workgroup = OpTypePointer CrossWorkgroup %struct_f32_f32 %f16vec8_ptr_uniform_constant = OpTypePointer UniformConstant %f16vec8 %f16vec8_uniform_constant = OpVariable %f16vec8_ptr_uniform_constant UniformConstant %f16_ptr_uniform_constant = OpTypePointer UniformConstant %f16 %u32vec8_ptr_uniform_constant = OpTypePointer UniformConstant %u32vec8 %u32vec8_uniform_constant = OpVariable %u32vec8_ptr_uniform_constant UniformConstant %u32_ptr_uniform_constant = OpTypePointer UniformConstant %u32 %f32vec8_ptr_uniform_constant = OpTypePointer UniformConstant %f32vec8 %f32vec8_uniform_constant = OpVariable %f32vec8_ptr_uniform_constant UniformConstant %f32_ptr_uniform_constant = OpTypePointer UniformConstant %f32 %f16vec8_ptr_input = OpTypePointer Input %f16vec8 %f16vec8_input = OpVariable %f16vec8_ptr_input Input %f16_ptr_input = OpTypePointer Input %f16 %u32vec8_ptr_input = OpTypePointer Input %u32vec8 %u32vec8_input = OpVariable %u32vec8_ptr_input Input %u32_ptr_input = OpTypePointer Input %u32 %f32_ptr_generic = OpTypePointer Generic %f32 %u32_ptr_generic = OpTypePointer Generic %u32 %f32_ptr_function = OpTypePointer Function %f32 %f32vec2_ptr_function = OpTypePointer Function %f32vec2 %u32_ptr_function = OpTypePointer Function %u32 %u64_ptr_function = OpTypePointer Function %u64 %u32vec2_ptr_function = OpTypePointer Function %u32vec2 %u8arr = OpTypeArray %u8 %u32_256 %u8arr_ptr_uniform_constant = OpTypePointer UniformConstant %u8arr %u8arr_uniform_constant = OpVariable %u8arr_ptr_uniform_constant UniformConstant %u8_ptr_uniform_constant = OpTypePointer UniformConstant %u8 %u8_ptr_generic = OpTypePointer Generic %u8 %u8_ptr_input = OpTypePointer Input %u8 %main = OpFunction %void None %func %main_entry = OpLabel )"; ss << body; ss << R"( OpReturn OpFunctionEnd)"; return ss.str(); } TEST_P(ValidateGlslStd450SqrtLike, Success) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%val1 = OpExtInst %f32 %extinst " << ext_inst_name << " %f32_0\n"; ss << "%val2 = OpExtInst %f32vec2 %extinst " << ext_inst_name << " %f32vec2_01\n"; ss << "%val3 = OpExtInst %f64 %extinst " << ext_inst_name << " %f64_0\n"; CompileSuccessfully(GenerateShaderCode(ss.str())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateGlslStd450SqrtLike, IntResultType) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %u32 %extinst " + ext_inst_name + " %f32_0\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected Result Type to be a float scalar " "or vector type")); } TEST_P(ValidateGlslStd450SqrtLike, IntOperand) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %f32 %extinst " + ext_inst_name + " %u32_0\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected types of all operands to be equal to " "Result Type")); } INSTANTIATE_TEST_SUITE_P(AllSqrtLike, ValidateGlslStd450SqrtLike, ::testing::ValuesIn(std::vector{ "Round", "RoundEven", "FAbs", "Trunc", "FSign", "Floor", "Ceil", "Fract", "Sqrt", "InverseSqrt", "Normalize", })); TEST_P(ValidateGlslStd450FMinLike, Success) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%val1 = OpExtInst %f32 %extinst " << ext_inst_name << " %f32_0 %f32_1\n"; ss << "%val2 = OpExtInst %f32vec2 %extinst " << ext_inst_name << " %f32vec2_01 %f32vec2_12\n"; ss << "%val3 = OpExtInst %f64 %extinst " << ext_inst_name << " %f64_0 %f64_0\n"; CompileSuccessfully(GenerateShaderCode(ss.str())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateGlslStd450FMinLike, IntResultType) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %u32 %extinst " + ext_inst_name + " %f32_0 %f32_1\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected Result Type to be a float scalar " "or vector type")); } TEST_P(ValidateGlslStd450FMinLike, IntOperand1) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %f32 %extinst " + ext_inst_name + " %u32_0 %f32_1\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected types of all operands to be equal to " "Result Type")); } TEST_P(ValidateGlslStd450FMinLike, IntOperand2) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %f32 %extinst " + ext_inst_name + " %f32_0 %u32_1\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected types of all operands to be equal to " "Result Type")); } INSTANTIATE_TEST_SUITE_P(AllFMinLike, ValidateGlslStd450FMinLike, ::testing::ValuesIn(std::vector{ "FMin", "FMax", "Step", "Reflect", "NMin", "NMax", })); TEST_P(ValidateGlslStd450FClampLike, Success) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%val1 = OpExtInst %f32 %extinst " << ext_inst_name << " %f32_0 %f32_1 %f32_2\n"; ss << "%val2 = OpExtInst %f32vec2 %extinst " << ext_inst_name << " %f32vec2_01 %f32vec2_01 %f32vec2_12\n"; ss << "%val3 = OpExtInst %f64 %extinst " << ext_inst_name << " %f64_0 %f64_0 %f64_1\n"; CompileSuccessfully(GenerateShaderCode(ss.str())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateGlslStd450FClampLike, IntResultType) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %u32 %extinst " + ext_inst_name + " %f32_0 %f32_1 %f32_2\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected Result Type to be a float scalar " "or vector type")); } TEST_P(ValidateGlslStd450FClampLike, IntOperand1) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %f32 %extinst " + ext_inst_name + " %u32_0 %f32_0 %f32_1\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected types of all operands to be equal to " "Result Type")); } TEST_P(ValidateGlslStd450FClampLike, IntOperand2) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %f32 %extinst " + ext_inst_name + " %f32_0 %u32_0 %f32_1\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected types of all operands to be equal to " "Result Type")); } TEST_P(ValidateGlslStd450FClampLike, IntOperand3) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %f32 %extinst " + ext_inst_name + " %f32_1 %f32_0 %u32_2\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected types of all operands to be equal to " "Result Type")); } INSTANTIATE_TEST_SUITE_P(AllFClampLike, ValidateGlslStd450FClampLike, ::testing::ValuesIn(std::vector{ "FClamp", "FMix", "SmoothStep", "Fma", "FaceForward", "NClamp", })); TEST_P(ValidateGlslStd450SAbsLike, Success) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%val1 = OpExtInst %s32 %extinst " << ext_inst_name << " %u32_1\n"; ss << "%val2 = OpExtInst %s32 %extinst " << ext_inst_name << " %s32_1\n"; ss << "%val3 = OpExtInst %u32 %extinst " << ext_inst_name << " %u32_1\n"; ss << "%val4 = OpExtInst %u32 %extinst " << ext_inst_name << " %s32_1\n"; ss << "%val5 = OpExtInst %s32vec2 %extinst " << ext_inst_name << " %s32vec2_01\n"; ss << "%val6 = OpExtInst %u32vec2 %extinst " << ext_inst_name << " %u32vec2_01\n"; ss << "%val7 = OpExtInst %u32vec2 %extinst " << ext_inst_name << " %s32vec2_01\n"; ss << "%val8 = OpExtInst %s32vec2 %extinst " << ext_inst_name << " %u32vec2_01\n"; CompileSuccessfully(GenerateShaderCode(ss.str())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateGlslStd450SAbsLike, FloatResultType) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %f32 %extinst " + ext_inst_name + " %u32_0\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected Result Type to be an int scalar " "or vector type")); } TEST_P(ValidateGlslStd450SAbsLike, FloatOperand) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %s32 %extinst " + ext_inst_name + " %f32_0\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected all operands to be int scalars or " "vectors")); } TEST_P(ValidateGlslStd450SAbsLike, WrongDimOperand) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %s32 %extinst " + ext_inst_name + " %s32vec2_01\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected all operands to have the same dimension as " "Result Type")); } TEST_P(ValidateGlslStd450SAbsLike, WrongBitWidthOperand) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %s64 %extinst " + ext_inst_name + " %s32_0\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected all operands to have the same bit width as " "Result Type")); } TEST_P(ValidateGlslStd450SAbsLike, TypelessOperand) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %s64 %extinst " + ext_inst_name + " %main_entry\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected all operands to be int scalars or vectors")); } INSTANTIATE_TEST_SUITE_P(AllSAbsLike, ValidateGlslStd450SAbsLike, ::testing::ValuesIn(std::vector{ "SAbs", "SSign", "FindILsb", "FindUMsb", "FindSMsb", })); TEST_F(ValidateExtInst, FindUMsbNot32Bit) { const std::string body = R"( %val1 = OpExtInst %s64 %extinst FindUMsb %u64_1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 FindUMsb: this instruction is currently " "limited to 32-bit width components")); } TEST_F(ValidateExtInst, FindSMsbNot32Bit) { const std::string body = R"( %val1 = OpExtInst %s64 %extinst FindSMsb %u64_1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 FindSMsb: this instruction is currently " "limited to 32-bit width components")); } TEST_P(ValidateGlslStd450UMinLike, Success) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%val1 = OpExtInst %s32 %extinst " << ext_inst_name << " %u32_1 %s32_2\n"; ss << "%val2 = OpExtInst %s32 %extinst " << ext_inst_name << " %s32_1 %u32_2\n"; ss << "%val3 = OpExtInst %u32 %extinst " << ext_inst_name << " %u32_1 %s32_2\n"; ss << "%val4 = OpExtInst %u32 %extinst " << ext_inst_name << " %s32_1 %u32_2\n"; ss << "%val5 = OpExtInst %s32vec2 %extinst " << ext_inst_name << " %s32vec2_01 %u32vec2_01\n"; ss << "%val6 = OpExtInst %u32vec2 %extinst " << ext_inst_name << " %u32vec2_01 %s32vec2_01\n"; ss << "%val7 = OpExtInst %u32vec2 %extinst " << ext_inst_name << " %s32vec2_01 %u32vec2_01\n"; ss << "%val8 = OpExtInst %s32vec2 %extinst " << ext_inst_name << " %u32vec2_01 %s32vec2_01\n"; ss << "%val9 = OpExtInst %s64 %extinst " << ext_inst_name << " %u64_1 %s64_0\n"; CompileSuccessfully(GenerateShaderCode(ss.str())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateGlslStd450UMinLike, FloatResultType) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %f32 %extinst " + ext_inst_name + " %u32_0 %u32_0\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected Result Type to be an int scalar " "or vector type")); } TEST_P(ValidateGlslStd450UMinLike, FloatOperand1) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %s32 %extinst " + ext_inst_name + " %f32_0 %u32_0\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected all operands to be int scalars or " "vectors")); } TEST_P(ValidateGlslStd450UMinLike, FloatOperand2) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %s32 %extinst " + ext_inst_name + " %u32_0 %f32_0\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected all operands to be int scalars or " "vectors")); } TEST_P(ValidateGlslStd450UMinLike, WrongDimOperand1) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %s32 %extinst " + ext_inst_name + " %s32vec2_01 %s32_0\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected all operands to have the same dimension as " "Result Type")); } TEST_P(ValidateGlslStd450UMinLike, WrongDimOperand2) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %s32 %extinst " + ext_inst_name + " %s32_0 %s32vec2_01\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected all operands to have the same dimension as " "Result Type")); } TEST_P(ValidateGlslStd450UMinLike, WrongBitWidthOperand1) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %s64 %extinst " + ext_inst_name + " %s32_0 %s64_0\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected all operands to have the same bit width as " "Result Type")); } TEST_P(ValidateGlslStd450UMinLike, WrongBitWidthOperand2) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %s64 %extinst " + ext_inst_name + " %s64_0 %s32_0\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected all operands to have the same bit width as " "Result Type")); } TEST_P(ValidateGlslStd450UMinLike, TypelessOperand) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %s64 %extinst " + ext_inst_name + " %s64_0 %main_entry\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected all operands to be int scalars or vectors")); } INSTANTIATE_TEST_SUITE_P(AllUMinLike, ValidateGlslStd450UMinLike, ::testing::ValuesIn(std::vector{ "UMin", "SMin", "UMax", "SMax", })); TEST_P(ValidateGlslStd450UClampLike, Success) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%val1 = OpExtInst %s32 %extinst " << ext_inst_name << " %s32_0 %u32_1 %s32_2\n"; ss << "%val2 = OpExtInst %s32 %extinst " << ext_inst_name << " %u32_0 %s32_1 %u32_2\n"; ss << "%val3 = OpExtInst %u32 %extinst " << ext_inst_name << " %s32_0 %u32_1 %s32_2\n"; ss << "%val4 = OpExtInst %u32 %extinst " << ext_inst_name << " %u32_0 %s32_1 %u32_2\n"; ss << "%val5 = OpExtInst %s32vec2 %extinst " << ext_inst_name << " %s32vec2_01 %u32vec2_01 %u32vec2_12\n"; ss << "%val6 = OpExtInst %u32vec2 %extinst " << ext_inst_name << " %u32vec2_01 %s32vec2_01 %s32vec2_12\n"; ss << "%val7 = OpExtInst %u32vec2 %extinst " << ext_inst_name << " %s32vec2_01 %u32vec2_01 %u32vec2_12\n"; ss << "%val8 = OpExtInst %s32vec2 %extinst " << ext_inst_name << " %u32vec2_01 %s32vec2_01 %s32vec2_12\n"; ss << "%val9 = OpExtInst %s64 %extinst " << ext_inst_name << " %u64_1 %s64_0 %s64_1\n"; CompileSuccessfully(GenerateShaderCode(ss.str())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateGlslStd450UClampLike, FloatResultType) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %f32 %extinst " + ext_inst_name + " %u32_0 %u32_0 %u32_1\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected Result Type to be an int scalar " "or vector type")); } TEST_P(ValidateGlslStd450UClampLike, FloatOperand1) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %s32 %extinst " + ext_inst_name + " %f32_0 %u32_0 %u32_1\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected all operands to be int scalars or " "vectors")); } TEST_P(ValidateGlslStd450UClampLike, FloatOperand2) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %s32 %extinst " + ext_inst_name + " %u32_0 %f32_0 %u32_1\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected all operands to be int scalars or " "vectors")); } TEST_P(ValidateGlslStd450UClampLike, FloatOperand3) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %s32 %extinst " + ext_inst_name + " %u32_0 %u32_0 %f32_1\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected all operands to be int scalars or " "vectors")); } TEST_P(ValidateGlslStd450UClampLike, WrongDimOperand1) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %s32 %extinst " + ext_inst_name + " %s32vec2_01 %s32_0 %u32_1\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected all operands to have the same dimension as " "Result Type")); } TEST_P(ValidateGlslStd450UClampLike, WrongDimOperand2) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %s32 %extinst " + ext_inst_name + " %s32_0 %s32vec2_01 %u32_1\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected all operands to have the same dimension as " "Result Type")); } TEST_P(ValidateGlslStd450UClampLike, WrongDimOperand3) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %s32 %extinst " + ext_inst_name + " %s32_0 %u32_1 %s32vec2_01\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected all operands to have the same dimension as " "Result Type")); } TEST_P(ValidateGlslStd450UClampLike, WrongBitWidthOperand1) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %s64 %extinst " + ext_inst_name + " %s32_0 %s64_0 %s64_1\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected all operands to have the same bit width as " "Result Type")); } TEST_P(ValidateGlslStd450UClampLike, WrongBitWidthOperand2) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %s64 %extinst " + ext_inst_name + " %s64_0 %s32_0 %s64_1\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected all operands to have the same bit width as " "Result Type")); } TEST_P(ValidateGlslStd450UClampLike, WrongBitWidthOperand3) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %s64 %extinst " + ext_inst_name + " %s64_0 %s64_0 %s32_1\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected all operands to have the same bit width as " "Result Type")); } TEST_P(ValidateGlslStd450UClampLike, TypelessOperand) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %s64 %extinst " + ext_inst_name + " %main_entry %s64_0 %s64_0\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected all operands to be int scalars or vectors")); } INSTANTIATE_TEST_SUITE_P(AllUClampLike, ValidateGlslStd450UClampLike, ::testing::ValuesIn(std::vector{ "UClamp", "SClamp", })); TEST_P(ValidateGlslStd450SinLike, Success) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%val1 = OpExtInst %f32 %extinst " << ext_inst_name << " %f32_0\n"; ss << "%val2 = OpExtInst %f32vec2 %extinst " << ext_inst_name << " %f32vec2_01\n"; CompileSuccessfully(GenerateShaderCode(ss.str())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateGlslStd450SinLike, IntResultType) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %u32 %extinst " + ext_inst_name + " %f32_0\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected Result Type to be a 16 or 32-bit scalar " "or vector float type")); } TEST_P(ValidateGlslStd450SinLike, F64ResultType) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %f64 %extinst " + ext_inst_name + " %f32_0\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected Result Type to be a 16 or 32-bit scalar " "or vector float type")); } TEST_P(ValidateGlslStd450SinLike, IntOperand) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %f32 %extinst " + ext_inst_name + " %u32_0\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected types of all operands to be equal to " "Result Type")); } INSTANTIATE_TEST_SUITE_P(AllSinLike, ValidateGlslStd450SinLike, ::testing::ValuesIn(std::vector{ "Radians", "Degrees", "Sin", "Cos", "Tan", "Asin", "Acos", "Atan", "Sinh", "Cosh", "Tanh", "Asinh", "Acosh", "Atanh", "Exp", "Exp2", "Log", "Log2", })); TEST_P(ValidateGlslStd450PowLike, Success) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%val1 = OpExtInst %f32 %extinst " << ext_inst_name << " %f32_1 %f32_1\n"; ss << "%val2 = OpExtInst %f32vec2 %extinst " << ext_inst_name << " %f32vec2_01 %f32vec2_12\n"; CompileSuccessfully(GenerateShaderCode(ss.str())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateGlslStd450PowLike, IntResultType) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %u32 %extinst " + ext_inst_name + " %f32_1 %f32_0\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected Result Type to be a 16 or 32-bit scalar " "or vector float type")); } TEST_P(ValidateGlslStd450PowLike, F64ResultType) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %f64 %extinst " + ext_inst_name + " %f32_1 %f32_0\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected Result Type to be a 16 or 32-bit scalar " "or vector float type")); } TEST_P(ValidateGlslStd450PowLike, IntOperand1) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %f32 %extinst " + ext_inst_name + " %u32_0 %f32_1\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected types of all operands to be equal to " "Result Type")); } TEST_P(ValidateGlslStd450PowLike, IntOperand2) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %f32 %extinst " + ext_inst_name + " %f32_0 %u32_1\n"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 " + ext_inst_name + ": expected types of all operands to be equal to " "Result Type")); } INSTANTIATE_TEST_SUITE_P(AllPowLike, ValidateGlslStd450PowLike, ::testing::ValuesIn(std::vector{ "Atan2", "Pow", })); TEST_F(ValidateExtInst, GlslStd450DeterminantSuccess) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst Determinant %f32mat22_1212 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, GlslStd450DeterminantIncompatibleResultType) { const std::string body = R"( %val1 = OpExtInst %f64 %extinst Determinant %f32mat22_1212 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 Determinant: " "expected operand X component type to be equal to " "Result Type")); } TEST_F(ValidateExtInst, GlslStd450DeterminantNotMatrix) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst Determinant %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 Determinant: " "expected operand X to be a square matrix")); } TEST_F(ValidateExtInst, GlslStd450DeterminantMatrixNotSquare) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst Determinant %f32mat23_121212 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 Determinant: " "expected operand X to be a square matrix")); } TEST_F(ValidateExtInst, GlslStd450MatrixInverseSuccess) { const std::string body = R"( %val1 = OpExtInst %f32mat22 %extinst MatrixInverse %f32mat22_1212 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, GlslStd450MatrixInverseIncompatibleResultType) { const std::string body = R"( %val1 = OpExtInst %f32mat33 %extinst MatrixInverse %f32mat22_1212 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 MatrixInverse: " "expected operand X type to be equal to " "Result Type")); } TEST_F(ValidateExtInst, GlslStd450MatrixInverseNotMatrix) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst MatrixInverse %f32mat22_1212 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 MatrixInverse: " "expected Result Type to be a square matrix")); } TEST_F(ValidateExtInst, GlslStd450MatrixInverseMatrixNotSquare) { const std::string body = R"( %val1 = OpExtInst %f32mat23 %extinst MatrixInverse %f32mat23_121212 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 MatrixInverse: " "expected Result Type to be a square matrix")); } TEST_F(ValidateExtInst, GlslStd450ModfSuccess) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst Modf %f32_h %f32_output %val2 = OpExtInst %f32vec2 %extinst Modf %f32vec2_01 %f32vec2_output )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, GlslStd450ModfIntResultType) { const std::string body = R"( %val1 = OpExtInst %u32 %extinst Modf %f32_h %f32_output )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 Modf: " "expected Result Type to be a scalar or vector " "float type")); } TEST_F(ValidateExtInst, GlslStd450ModfXNotOfResultType) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst Modf %f64_0 %f32_output )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 Modf: " "expected operand X type to be equal to Result Type")); } TEST_F(ValidateExtInst, GlslStd450ModfINotPointer) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst Modf %f32_h %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 Modf: " "expected operand I to be a pointer")); } TEST_F(ValidateExtInst, GlslStd450ModfIDataNotOfResultType) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst Modf %f32_h %f32vec2_output )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 Modf: " "expected operand I data type to be equal to " "Result Type")); } TEST_F(ValidateExtInst, GlslStd450ModfStructSuccess) { const std::string body = R"( %val1 = OpExtInst %struct_f32_f32 %extinst ModfStruct %f32_h %val2 = OpExtInst %struct_f32vec2_f32vec2 %extinst ModfStruct %f32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, GlslStd450ModfStructResultTypeNotStruct) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst ModfStruct %f32_h )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 ModfStruct: " "expected Result Type to be a struct with two " "identical scalar or vector float type members")); } TEST_F(ValidateExtInst, GlslStd450ModfStructResultTypeStructWrongSize) { const std::string body = R"( %val1 = OpExtInst %struct_f32_f32_f32 %extinst ModfStruct %f32_h )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 ModfStruct: " "expected Result Type to be a struct with two " "identical scalar or vector float type members")); } TEST_F(ValidateExtInst, GlslStd450ModfStructResultTypeStructWrongFirstMember) { const std::string body = R"( %val1 = OpExtInst %struct_u32_f32 %extinst ModfStruct %f32_h )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 ModfStruct: " "expected Result Type to be a struct with two " "identical scalar or vector float type members")); } TEST_F(ValidateExtInst, GlslStd450ModfStructResultTypeStructMembersNotEqual) { const std::string body = R"( %val1 = OpExtInst %struct_f32_f64 %extinst ModfStruct %f32_h )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 ModfStruct: " "expected Result Type to be a struct with two " "identical scalar or vector float type members")); } TEST_F(ValidateExtInst, GlslStd450ModfStructXWrongType) { const std::string body = R"( %val1 = OpExtInst %struct_f32_f32 %extinst ModfStruct %f64_0 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 ModfStruct: " "expected operand X type to be equal to members of " "Result Type struct")); } TEST_F(ValidateExtInst, GlslStd450FrexpSuccess) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst Frexp %f32_h %u32_output %val2 = OpExtInst %f32vec2 %extinst Frexp %f32vec2_01 %u32vec2_output )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, GlslStd450FrexpIntResultType) { const std::string body = R"( %val1 = OpExtInst %u32 %extinst Frexp %f32_h %u32_output )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 Frexp: " "expected Result Type to be a scalar or vector " "float type")); } TEST_F(ValidateExtInst, GlslStd450FrexpWrongXType) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst Frexp %u32_1 %u32_output )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 Frexp: " "expected operand X type to be equal to Result Type")); } TEST_F(ValidateExtInst, GlslStd450FrexpExpNotPointer) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst Frexp %f32_1 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 Frexp: " "expected operand Exp to be a pointer")); } TEST_F(ValidateExtInst, GlslStd450FrexpExpNotInt32Pointer) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst Frexp %f32_1 %f32_output )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 Frexp: " "expected operand Exp data type to be a 32-bit int " "scalar or vector type")); } TEST_F(ValidateExtInst, GlslStd450FrexpExpWrongComponentNumber) { const std::string body = R"( %val1 = OpExtInst %f32vec2 %extinst Frexp %f32vec2_01 %u32_output )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 Frexp: " "expected operand Exp data type to have the same " "component number as Result Type")); } TEST_F(ValidateExtInst, GlslStd450LdexpSuccess) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst Ldexp %f32_h %u32_2 %val2 = OpExtInst %f32vec2 %extinst Ldexp %f32vec2_01 %u32vec2_12 %val3 = OpExtInst %f32 %extinst Ldexp %f32_h %u64_1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, GlslStd450LdexpIntResultType) { const std::string body = R"( %val1 = OpExtInst %u32 %extinst Ldexp %f32_h %u32_2 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 Ldexp: " "expected Result Type to be a scalar or vector " "float type")); } TEST_F(ValidateExtInst, GlslStd450LdexpWrongXType) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst Ldexp %u32_1 %u32_2 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 Ldexp: " "expected operand X type to be equal to Result Type")); } TEST_F(ValidateExtInst, GlslStd450LdexpFloatExp) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst Ldexp %f32_1 %f32_2 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 Ldexp: " "expected operand Exp to be a 32-bit int scalar " "or vector type")); } TEST_F(ValidateExtInst, GlslStd450LdexpExpWrongSize) { const std::string body = R"( %val1 = OpExtInst %f32vec2 %extinst Ldexp %f32vec2_12 %u32_2 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 Ldexp: " "expected operand Exp to have the same component " "number as Result Type")); } TEST_F(ValidateExtInst, GlslStd450LdexpExpNoType) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst Ldexp %f32_1 %main_entry )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 Ldexp: " "expected operand Exp to be a 32-bit int scalar " "or vector type")); } TEST_F(ValidateExtInst, GlslStd450FrexpStructSuccess) { const std::string body = R"( %val1 = OpExtInst %struct_f32_u32 %extinst FrexpStruct %f32_h %val2 = OpExtInst %struct_f32vec2_u32vec2 %extinst FrexpStruct %f32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, GlslStd450FrexpStructResultTypeNotStruct) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst FrexpStruct %f32_h )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 FrexpStruct: " "expected Result Type to be a struct with two members, " "first member a float scalar or vector, second member " "a 32-bit int scalar or vector with the same number of " "components as the first member")); } TEST_F(ValidateExtInst, GlslStd450FrexpStructResultTypeStructWrongSize) { const std::string body = R"( %val1 = OpExtInst %struct_f32_u32_f32 %extinst FrexpStruct %f32_h )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 FrexpStruct: " "expected Result Type to be a struct with two members, " "first member a float scalar or vector, second member " "a 32-bit int scalar or vector with the same number of " "components as the first member")); } TEST_F(ValidateExtInst, GlslStd450FrexpStructResultTypeStructWrongMember1) { const std::string body = R"( %val1 = OpExtInst %struct_u32_u32 %extinst FrexpStruct %f32_h )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 FrexpStruct: " "expected Result Type to be a struct with two members, " "first member a float scalar or vector, second member " "a 32-bit int scalar or vector with the same number of " "components as the first member")); } TEST_F(ValidateExtInst, GlslStd450FrexpStructResultTypeStructWrongMember2) { const std::string body = R"( %val1 = OpExtInst %struct_f32_f32 %extinst FrexpStruct %f32_h )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 FrexpStruct: " "expected Result Type to be a struct with two members, " "first member a float scalar or vector, second member " "a 32-bit int scalar or vector with the same number of " "components as the first member")); } TEST_F(ValidateExtInst, GlslStd450FrexpStructXWrongType) { const std::string body = R"( %val1 = OpExtInst %struct_f32_u32 %extinst FrexpStruct %f64_0 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 FrexpStruct: " "expected operand X type to be equal to the first " "member of Result Type struct")); } TEST_F(ValidateExtInst, GlslStd450FrexpStructResultTypeStructRightInt16Member2) { const std::string body = R"( %val1 = OpExtInst %struct_f16_u16 %extinst FrexpStruct %f16_h )"; const std::string extension = R"( OpExtension "SPV_AMD_gpu_shader_int16" )"; CompileSuccessfully(GenerateShaderCode(body, extension)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, GlslStd450FrexpStructResultTypeStructWrongInt16Member2) { const std::string body = R"( %val1 = OpExtInst %struct_f16_u16 %extinst FrexpStruct %f16_h )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 FrexpStruct: " "expected Result Type to be a struct with two members, " "first member a float scalar or vector, second member " "a 32-bit int scalar or vector with the same number of " "components as the first member")); } TEST_P(ValidateGlslStd450Pack, Success) { const std::string ext_inst_name = GetParam(); const uint32_t num_components = GetPackedNumComponents(ext_inst_name); const uint32_t packed_bit_width = GetPackedBitWidth(ext_inst_name); const uint32_t total_bit_width = num_components * packed_bit_width; const std::string vec_str = num_components == 2 ? " %f32vec2_01\n" : " %f32vec4_0123\n"; std::ostringstream body; body << "%val1 = OpExtInst %u" << total_bit_width << " %extinst " << ext_inst_name << vec_str; body << "%val2 = OpExtInst %s" << total_bit_width << " %extinst " << ext_inst_name << vec_str; CompileSuccessfully(GenerateShaderCode(body.str())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateGlslStd450Pack, Float32ResultType) { const std::string ext_inst_name = GetParam(); const uint32_t num_components = GetPackedNumComponents(ext_inst_name); const uint32_t packed_bit_width = GetPackedBitWidth(ext_inst_name); const uint32_t total_bit_width = num_components * packed_bit_width; const std::string vec_str = num_components == 2 ? " %f32vec2_01\n" : " %f32vec4_0123\n"; std::ostringstream body; body << "%val1 = OpExtInst %f" << total_bit_width << " %extinst " << ext_inst_name << vec_str; std::ostringstream expected; expected << "GLSL.std.450 " << ext_inst_name << ": expected Result Type to be " << total_bit_width << "-bit int scalar type"; CompileSuccessfully(GenerateShaderCode(body.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(expected.str())); } TEST_P(ValidateGlslStd450Pack, Int16ResultType) { const std::string ext_inst_name = GetParam(); const uint32_t num_components = GetPackedNumComponents(ext_inst_name); const uint32_t packed_bit_width = GetPackedBitWidth(ext_inst_name); const uint32_t total_bit_width = num_components * packed_bit_width; const std::string vec_str = num_components == 2 ? " %f32vec2_01\n" : " %f32vec4_0123\n"; std::ostringstream body; body << "%val1 = OpExtInst %u16 %extinst " << ext_inst_name << vec_str; std::ostringstream expected; expected << "GLSL.std.450 " << ext_inst_name << ": expected Result Type to be " << total_bit_width << "-bit int scalar type"; CompileSuccessfully(GenerateShaderCode(body.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(expected.str())); } TEST_P(ValidateGlslStd450Pack, VNotVector) { const std::string ext_inst_name = GetParam(); const uint32_t num_components = GetPackedNumComponents(ext_inst_name); const uint32_t packed_bit_width = GetPackedBitWidth(ext_inst_name); const uint32_t total_bit_width = num_components * packed_bit_width; std::ostringstream body; body << "%val1 = OpExtInst %u" << total_bit_width << " %extinst " << ext_inst_name << " %f32_1\n"; std::ostringstream expected; expected << "GLSL.std.450 " << ext_inst_name << ": expected operand V to be a 32-bit float vector of size " << num_components; CompileSuccessfully(GenerateShaderCode(body.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(expected.str())); } TEST_P(ValidateGlslStd450Pack, VNotFloatVector) { const std::string ext_inst_name = GetParam(); const uint32_t num_components = GetPackedNumComponents(ext_inst_name); const uint32_t packed_bit_width = GetPackedBitWidth(ext_inst_name); const uint32_t total_bit_width = num_components * packed_bit_width; const std::string vec_str = num_components == 2 ? " %u32vec2_01\n" : " %u32vec4_0123\n"; std::ostringstream body; body << "%val1 = OpExtInst %u" << total_bit_width << " %extinst " << ext_inst_name << vec_str; std::ostringstream expected; expected << "GLSL.std.450 " << ext_inst_name << ": expected operand V to be a 32-bit float vector of size " << num_components; CompileSuccessfully(GenerateShaderCode(body.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(expected.str())); } TEST_P(ValidateGlslStd450Pack, VNotFloat32Vector) { const std::string ext_inst_name = GetParam(); const uint32_t num_components = GetPackedNumComponents(ext_inst_name); const uint32_t packed_bit_width = GetPackedBitWidth(ext_inst_name); const uint32_t total_bit_width = num_components * packed_bit_width; const std::string vec_str = num_components == 2 ? " %f64vec2_01\n" : " %f64vec4_0123\n"; std::ostringstream body; body << "%val1 = OpExtInst %u" << total_bit_width << " %extinst " << ext_inst_name << vec_str; std::ostringstream expected; expected << "GLSL.std.450 " << ext_inst_name << ": expected operand V to be a 32-bit float vector of size " << num_components; CompileSuccessfully(GenerateShaderCode(body.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(expected.str())); } TEST_P(ValidateGlslStd450Pack, VWrongSizeVector) { const std::string ext_inst_name = GetParam(); const uint32_t num_components = GetPackedNumComponents(ext_inst_name); const uint32_t packed_bit_width = GetPackedBitWidth(ext_inst_name); const uint32_t total_bit_width = num_components * packed_bit_width; const std::string vec_str = num_components == 4 ? " %f32vec2_01\n" : " %f32vec4_0123\n"; std::ostringstream body; body << "%val1 = OpExtInst %u" << total_bit_width << " %extinst " << ext_inst_name << vec_str; std::ostringstream expected; expected << "GLSL.std.450 " << ext_inst_name << ": expected operand V to be a 32-bit float vector of size " << num_components; CompileSuccessfully(GenerateShaderCode(body.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(expected.str())); } INSTANTIATE_TEST_SUITE_P(AllPack, ValidateGlslStd450Pack, ::testing::ValuesIn(std::vector{ "PackSnorm4x8", "PackUnorm4x8", "PackSnorm2x16", "PackUnorm2x16", "PackHalf2x16", })); TEST_F(ValidateExtInst, PackDouble2x32Success) { const std::string body = R"( %val1 = OpExtInst %f64 %extinst PackDouble2x32 %u32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, PackDouble2x32Float32ResultType) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst PackDouble2x32 %u32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 PackDouble2x32: expected Result Type to " "be 64-bit float scalar type")); } TEST_F(ValidateExtInst, PackDouble2x32Int64ResultType) { const std::string body = R"( %val1 = OpExtInst %u64 %extinst PackDouble2x32 %u32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 PackDouble2x32: expected Result Type to " "be 64-bit float scalar type")); } TEST_F(ValidateExtInst, PackDouble2x32VNotVector) { const std::string body = R"( %val1 = OpExtInst %f64 %extinst PackDouble2x32 %u64_1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 PackDouble2x32: expected operand V to be " "a 32-bit int vector of size 2")); } TEST_F(ValidateExtInst, PackDouble2x32VNotIntVector) { const std::string body = R"( %val1 = OpExtInst %f64 %extinst PackDouble2x32 %f32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 PackDouble2x32: expected operand V to be " "a 32-bit int vector of size 2")); } TEST_F(ValidateExtInst, PackDouble2x32VNotInt32Vector) { const std::string body = R"( %val1 = OpExtInst %f64 %extinst PackDouble2x32 %u64vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 PackDouble2x32: expected operand V to be " "a 32-bit int vector of size 2")); } TEST_F(ValidateExtInst, PackDouble2x32VWrongSize) { const std::string body = R"( %val1 = OpExtInst %f64 %extinst PackDouble2x32 %u32vec4_0123 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 PackDouble2x32: expected operand V to be " "a 32-bit int vector of size 2")); } TEST_P(ValidateGlslStd450Unpack, Success) { const std::string ext_inst_name = GetParam(); const uint32_t num_components = GetPackedNumComponents(ext_inst_name); const uint32_t packed_bit_width = GetPackedBitWidth(ext_inst_name); const uint32_t total_bit_width = num_components * packed_bit_width; const std::string result_type_str = num_components == 2 ? "%f32vec2" : " %f32vec4"; std::ostringstream body; body << "%val1 = OpExtInst " << result_type_str << " %extinst " << ext_inst_name << " %u" << total_bit_width << "_1\n"; body << "%val2 = OpExtInst " << result_type_str << " %extinst " << ext_inst_name << " %s" << total_bit_width << "_1\n"; CompileSuccessfully(GenerateShaderCode(body.str())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateGlslStd450Unpack, ResultTypeNotVector) { const std::string ext_inst_name = GetParam(); const uint32_t num_components = GetPackedNumComponents(ext_inst_name); const uint32_t packed_bit_width = GetPackedBitWidth(ext_inst_name); const uint32_t total_bit_width = num_components * packed_bit_width; const std::string result_type_str = "%f32"; std::ostringstream body; body << "%val1 = OpExtInst " << result_type_str << " %extinst " << ext_inst_name << " %u" << total_bit_width << "_1\n"; std::ostringstream expected; expected << "GLSL.std.450 " << ext_inst_name << ": expected Result Type to be a 32-bit float vector of size " << num_components; CompileSuccessfully(GenerateShaderCode(body.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(expected.str())); } TEST_P(ValidateGlslStd450Unpack, ResultTypeNotFloatVector) { const std::string ext_inst_name = GetParam(); const uint32_t num_components = GetPackedNumComponents(ext_inst_name); const uint32_t packed_bit_width = GetPackedBitWidth(ext_inst_name); const uint32_t total_bit_width = num_components * packed_bit_width; const std::string result_type_str = num_components == 2 ? "%u32vec2" : " %u32vec4"; std::ostringstream body; body << "%val1 = OpExtInst " << result_type_str << " %extinst " << ext_inst_name << " %u" << total_bit_width << "_1\n"; std::ostringstream expected; expected << "GLSL.std.450 " << ext_inst_name << ": expected Result Type to be a 32-bit float vector of size " << num_components; CompileSuccessfully(GenerateShaderCode(body.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(expected.str())); } TEST_P(ValidateGlslStd450Unpack, ResultTypeNotFloat32Vector) { const std::string ext_inst_name = GetParam(); const uint32_t num_components = GetPackedNumComponents(ext_inst_name); const uint32_t packed_bit_width = GetPackedBitWidth(ext_inst_name); const uint32_t total_bit_width = num_components * packed_bit_width; const std::string result_type_str = num_components == 2 ? "%f64vec2" : " %f64vec4"; std::ostringstream body; body << "%val1 = OpExtInst " << result_type_str << " %extinst " << ext_inst_name << " %u" << total_bit_width << "_1\n"; std::ostringstream expected; expected << "GLSL.std.450 " << ext_inst_name << ": expected Result Type to be a 32-bit float vector of size " << num_components; CompileSuccessfully(GenerateShaderCode(body.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(expected.str())); } TEST_P(ValidateGlslStd450Unpack, ResultTypeWrongSize) { const std::string ext_inst_name = GetParam(); const uint32_t num_components = GetPackedNumComponents(ext_inst_name); const uint32_t packed_bit_width = GetPackedBitWidth(ext_inst_name); const uint32_t total_bit_width = num_components * packed_bit_width; const std::string result_type_str = num_components == 4 ? "%f32vec2" : " %f32vec4"; std::ostringstream body; body << "%val1 = OpExtInst " << result_type_str << " %extinst " << ext_inst_name << " %u" << total_bit_width << "_1\n"; std::ostringstream expected; expected << "GLSL.std.450 " << ext_inst_name << ": expected Result Type to be a 32-bit float vector of size " << num_components; CompileSuccessfully(GenerateShaderCode(body.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(expected.str())); } TEST_P(ValidateGlslStd450Unpack, ResultPNotInt) { const std::string ext_inst_name = GetParam(); const uint32_t num_components = GetPackedNumComponents(ext_inst_name); const uint32_t packed_bit_width = GetPackedBitWidth(ext_inst_name); const uint32_t total_bit_width = num_components * packed_bit_width; const std::string result_type_str = num_components == 2 ? "%f32vec2" : " %f32vec4"; std::ostringstream body; body << "%val1 = OpExtInst " << result_type_str << " %extinst " << ext_inst_name << " %f" << total_bit_width << "_1\n"; std::ostringstream expected; expected << "GLSL.std.450 " << ext_inst_name << ": expected operand P to be a " << total_bit_width << "-bit int scalar"; CompileSuccessfully(GenerateShaderCode(body.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(expected.str())); } TEST_P(ValidateGlslStd450Unpack, ResultPWrongBitWidth) { const std::string ext_inst_name = GetParam(); const uint32_t num_components = GetPackedNumComponents(ext_inst_name); const uint32_t packed_bit_width = GetPackedBitWidth(ext_inst_name); const uint32_t total_bit_width = num_components * packed_bit_width; const uint32_t wrong_bit_width = total_bit_width == 32 ? 64 : 32; const std::string result_type_str = num_components == 2 ? "%f32vec2" : " %f32vec4"; std::ostringstream body; body << "%val1 = OpExtInst " << result_type_str << " %extinst " << ext_inst_name << " %u" << wrong_bit_width << "_1\n"; std::ostringstream expected; expected << "GLSL.std.450 " << ext_inst_name << ": expected operand P to be a " << total_bit_width << "-bit int scalar"; CompileSuccessfully(GenerateShaderCode(body.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(expected.str())); } INSTANTIATE_TEST_SUITE_P(AllUnpack, ValidateGlslStd450Unpack, ::testing::ValuesIn(std::vector{ "UnpackSnorm4x8", "UnpackUnorm4x8", "UnpackSnorm2x16", "UnpackUnorm2x16", "UnpackHalf2x16", })); TEST_F(ValidateExtInst, UnpackDouble2x32Success) { const std::string body = R"( %val1 = OpExtInst %u32vec2 %extinst UnpackDouble2x32 %f64_1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, UnpackDouble2x32ResultTypeNotVector) { const std::string body = R"( %val1 = OpExtInst %u64 %extinst UnpackDouble2x32 %f64_1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 UnpackDouble2x32: expected Result Type " "to be a 32-bit int vector of size 2")); } TEST_F(ValidateExtInst, UnpackDouble2x32ResultTypeNotIntVector) { const std::string body = R"( %val1 = OpExtInst %f32vec2 %extinst UnpackDouble2x32 %f64_1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 UnpackDouble2x32: expected Result Type " "to be a 32-bit int vector of size 2")); } TEST_F(ValidateExtInst, UnpackDouble2x32ResultTypeNotInt32Vector) { const std::string body = R"( %val1 = OpExtInst %u64vec2 %extinst UnpackDouble2x32 %f64_1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 UnpackDouble2x32: expected Result Type " "to be a 32-bit int vector of size 2")); } TEST_F(ValidateExtInst, UnpackDouble2x32ResultTypeWrongSize) { const std::string body = R"( %val1 = OpExtInst %u32vec4 %extinst UnpackDouble2x32 %f64_1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 UnpackDouble2x32: expected Result Type " "to be a 32-bit int vector of size 2")); } TEST_F(ValidateExtInst, UnpackDouble2x32VNotFloat) { const std::string body = R"( %val1 = OpExtInst %u32vec2 %extinst UnpackDouble2x32 %u64_1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 UnpackDouble2x32: expected operand V to " "be a 64-bit float scalar")); } TEST_F(ValidateExtInst, UnpackDouble2x32VNotFloat64) { const std::string body = R"( %val1 = OpExtInst %u32vec2 %extinst UnpackDouble2x32 %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 UnpackDouble2x32: expected operand V to " "be a 64-bit float scalar")); } TEST_F(ValidateExtInst, GlslStd450LengthSuccess) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst Length %f32_1 %val2 = OpExtInst %f32 %extinst Length %f32vec2_01 %val3 = OpExtInst %f32 %extinst Length %f32vec4_0123 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, GlslStd450LengthIntResultType) { const std::string body = R"( %val1 = OpExtInst %u32 %extinst Length %f32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 Length: " "expected Result Type to be a float scalar type")); } TEST_F(ValidateExtInst, GlslStd450LengthIntX) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst Length %u32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 Length: " "expected operand X to be of float scalar or " "vector type")); } TEST_F(ValidateExtInst, GlslStd450LengthDifferentType) { const std::string body = R"( %val1 = OpExtInst %f64 %extinst Length %f32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 Length: " "expected operand X component type to be equal to " "Result Type")); } TEST_F(ValidateExtInst, GlslStd450DistanceSuccess) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst Distance %f32_0 %f32_1 %val2 = OpExtInst %f32 %extinst Distance %f32vec2_01 %f32vec2_12 %val3 = OpExtInst %f32 %extinst Distance %f32vec4_0123 %f32vec4_1234 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, GlslStd450DistanceIntResultType) { const std::string body = R"( %val1 = OpExtInst %u32 %extinst Distance %f32vec2_01 %f32vec2_12 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 Distance: " "expected Result Type to be a float scalar type")); } TEST_F(ValidateExtInst, GlslStd450DistanceIntP0) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst Distance %u32_0 %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 Distance: " "expected operand P0 to be of float scalar or " "vector type")); } TEST_F(ValidateExtInst, GlslStd450DistanceF64VectorP0) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst Distance %f64vec2_01 %f32vec2_12 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 Distance: " "expected operand P0 component type to be equal to " "Result Type")); } TEST_F(ValidateExtInst, GlslStd450DistanceIntP1) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst Distance %f32_0 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 Distance: " "expected operand P1 to be of float scalar or " "vector type")); } TEST_F(ValidateExtInst, GlslStd450DistanceF64VectorP1) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst Distance %f32vec2_12 %f64vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 Distance: " "expected operand P1 component type to be equal to " "Result Type")); } TEST_F(ValidateExtInst, GlslStd450DistanceDifferentSize) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst Distance %f32vec2_01 %f32vec4_0123 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 Distance: " "expected operands P0 and P1 to have the same number " "of components")); } TEST_F(ValidateExtInst, GlslStd450CrossSuccess) { const std::string body = R"( %val1 = OpExtInst %f32vec3 %extinst Cross %f32vec3_012 %f32vec3_123 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, GlslStd450CrossIntVectorResultType) { const std::string body = R"( %val1 = OpExtInst %u32vec3 %extinst Cross %f32vec3_012 %f32vec3_123 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 Cross: " "expected Result Type to be a float vector type")); } TEST_F(ValidateExtInst, GlslStd450CrossResultTypeWrongSize) { const std::string body = R"( %val1 = OpExtInst %f32vec2 %extinst Cross %f32vec3_012 %f32vec3_123 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 Cross: " "expected Result Type to have 3 components")); } TEST_F(ValidateExtInst, GlslStd450CrossXWrongType) { const std::string body = R"( %val1 = OpExtInst %f32vec3 %extinst Cross %f64vec3_012 %f32vec3_123 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 Cross: " "expected operand X type to be equal to Result Type")); } TEST_F(ValidateExtInst, GlslStd450CrossYWrongType) { const std::string body = R"( %val1 = OpExtInst %f32vec3 %extinst Cross %f32vec3_123 %f64vec3_012 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 Cross: " "expected operand Y type to be equal to Result Type")); } TEST_F(ValidateExtInst, GlslStd450RefractSuccess) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst Refract %f32_1 %f32_1 %f32_1 %val2 = OpExtInst %f32vec2 %extinst Refract %f32vec2_01 %f32vec2_01 %f16_1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, GlslStd450RefractIntVectorResultType) { const std::string body = R"( %val1 = OpExtInst %u32vec2 %extinst Refract %f32vec2_01 %f32vec2_01 %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 Refract: " "expected Result Type to be a float scalar or " "vector type")); } TEST_F(ValidateExtInst, GlslStd450RefractIntVectorI) { const std::string body = R"( %val1 = OpExtInst %f32vec2 %extinst Refract %u32vec2_01 %f32vec2_01 %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 Refract: " "expected operand I to be of type equal to " "Result Type")); } TEST_F(ValidateExtInst, GlslStd450RefractIntVectorN) { const std::string body = R"( %val1 = OpExtInst %f32vec2 %extinst Refract %f32vec2_01 %u32vec2_01 %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 Refract: " "expected operand N to be of type equal to " "Result Type")); } TEST_F(ValidateExtInst, GlslStd450RefractIntEta) { const std::string body = R"( %val1 = OpExtInst %f32vec2 %extinst Refract %f32vec2_01 %f32vec2_01 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 Refract: " "expected operand Eta to be a float scalar")); } TEST_F(ValidateExtInst, GlslStd450RefractFloat64Eta) { // SPIR-V issue 337: Eta can be 64-bit float scalar. const std::string body = R"( %val1 = OpExtInst %f32vec2 %extinst Refract %f32vec2_01 %f32vec2_01 %f64_1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateExtInst, GlslStd450RefractVectorEta) { const std::string body = R"( %val1 = OpExtInst %f32vec2 %extinst Refract %f32vec2_01 %f32vec2_01 %f32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 Refract: " "expected operand Eta to be a float scalar")); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtCentroidSuccess) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst InterpolateAtCentroid %f32_input %val2 = OpExtInst %f32vec2 %extinst InterpolateAtCentroid %f32vec2_input )"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability InterpolationFunction\n")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtCentroidInternalSuccess) { const std::string body = R"( %ld1 = OpLoad %f32 %f32_input %val1 = OpExtInst %f32 %extinst InterpolateAtCentroid %ld1 %ld2 = OpLoad %f32vec2 %f32vec2_input %val2 = OpExtInst %f32vec2 %extinst InterpolateAtCentroid %ld2 )"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability InterpolationFunction\n")); getValidatorOptions()->before_hlsl_legalization = true; ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtCentroidInternalInvalidDataF32) { const std::string body = R"( %ld1 = OpLoad %f32 %f32_input %val1 = OpExtInst %f32 %extinst InterpolateAtCentroid %ld1 )"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability InterpolationFunction\n")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 InterpolateAtCentroid: " "expected Interpolant to be a pointer")); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtCentroidInternalInvalidDataF32Vec2) { const std::string body = R"( %ld2 = OpLoad %f32vec2 %f32vec2_input %val2 = OpExtInst %f32vec2 %extinst InterpolateAtCentroid %ld2 )"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability InterpolationFunction\n")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 InterpolateAtCentroid: " "expected Interpolant to be a pointer")); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtCentroidNoCapability) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst InterpolateAtCentroid %f32_input )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_CAPABILITY, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 InterpolateAtCentroid requires " "capability InterpolationFunction")); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtCentroidIntResultType) { const std::string body = R"( %val1 = OpExtInst %u32 %extinst InterpolateAtCentroid %f32_input )"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability InterpolationFunction\n")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 InterpolateAtCentroid: " "expected Result Type to be a 32-bit float scalar " "or vector type")); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtCentroidF64ResultType) { const std::string body = R"( %val1 = OpExtInst %f64 %extinst InterpolateAtCentroid %f32_input )"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability InterpolationFunction\n")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 InterpolateAtCentroid: " "expected Result Type to be a 32-bit float scalar " "or vector type")); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtCentroidNotPointer) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst InterpolateAtCentroid %f32_1 )"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability InterpolationFunction\n")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 InterpolateAtCentroid: " "expected Interpolant to be a pointer")); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtCentroidWrongDataType) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst InterpolateAtCentroid %f32vec2_input )"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability InterpolationFunction\n")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 InterpolateAtCentroid: " "expected Interpolant data type to be equal to " "Result Type")); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtCentroidWrongStorageClass) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst InterpolateAtCentroid %f32_output )"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability InterpolationFunction\n")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 InterpolateAtCentroid: " "expected Interpolant storage class to be Input")); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtCentroidWrongExecutionModel) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst InterpolateAtCentroid %f32_input )"; CompileSuccessfully(GenerateShaderCode( body, "OpCapability InterpolationFunction\n", "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 InterpolateAtCentroid requires " "Fragment execution model")); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtSampleSuccess) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst InterpolateAtSample %f32_input %u32_1 %val2 = OpExtInst %f32vec2 %extinst InterpolateAtSample %f32vec2_input %u32_1 )"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability InterpolationFunction\n")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtSampleInternalSuccess) { const std::string body = R"( %ld1 = OpLoad %f32 %f32_input %val1 = OpExtInst %f32 %extinst InterpolateAtSample %ld1 %u32_1 %ld2 = OpLoad %f32vec2 %f32vec2_input %val2 = OpExtInst %f32vec2 %extinst InterpolateAtSample %ld2 %u32_1 )"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability InterpolationFunction\n")); getValidatorOptions()->before_hlsl_legalization = true; ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtSampleInternalInvalidDataF32) { const std::string body = R"( %ld1 = OpLoad %f32 %f32_input %val1 = OpExtInst %f32 %extinst InterpolateAtSample %ld1 %u32_1 )"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability InterpolationFunction\n")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 InterpolateAtSample: " "expected Interpolant to be a pointer")); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtSampleInternalInvalidDataF32Vec2) { const std::string body = R"( %ld2 = OpLoad %f32vec2 %f32vec2_input %val2 = OpExtInst %f32vec2 %extinst InterpolateAtSample %ld2 %u32_1 )"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability InterpolationFunction\n")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 InterpolateAtSample: " "expected Interpolant to be a pointer")); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtSampleNoCapability) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst InterpolateAtSample %f32_input %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_CAPABILITY, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 InterpolateAtSample requires " "capability InterpolationFunction")); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtSampleIntResultType) { const std::string body = R"( %val1 = OpExtInst %u32 %extinst InterpolateAtSample %f32_input %u32_1 )"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability InterpolationFunction\n")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 InterpolateAtSample: " "expected Result Type to be a 32-bit float scalar " "or vector type")); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtSampleF64ResultType) { const std::string body = R"( %val1 = OpExtInst %f64 %extinst InterpolateAtSample %f32_input %u32_1 )"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability InterpolationFunction\n")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 InterpolateAtSample: " "expected Result Type to be a 32-bit float scalar " "or vector type")); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtSampleNotPointer) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst InterpolateAtSample %f32_1 %u32_1 )"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability InterpolationFunction\n")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 InterpolateAtSample: " "expected Interpolant to be a pointer")); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtSampleWrongDataType) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst InterpolateAtSample %f32vec2_input %u32_1 )"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability InterpolationFunction\n")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 InterpolateAtSample: " "expected Interpolant data type to be equal to " "Result Type")); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtSampleWrongStorageClass) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst InterpolateAtSample %f32_output %u32_1 )"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability InterpolationFunction\n")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 InterpolateAtSample: " "expected Interpolant storage class to be Input")); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtSampleFloatSample) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst InterpolateAtSample %f32_input %f32_1 )"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability InterpolationFunction\n")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 InterpolateAtSample: " "expected Sample to be 32-bit integer")); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtSampleU64Sample) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst InterpolateAtSample %f32_input %u64_1 )"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability InterpolationFunction\n")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 InterpolateAtSample: " "expected Sample to be 32-bit integer")); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtSampleWrongExecutionModel) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst InterpolateAtSample %f32_input %u32_1 )"; CompileSuccessfully(GenerateShaderCode( body, "OpCapability InterpolationFunction\n", "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 InterpolateAtSample requires " "Fragment execution model")); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtOffsetSuccess) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst InterpolateAtOffset %f32_input %f32vec2_01 %val2 = OpExtInst %f32vec2 %extinst InterpolateAtOffset %f32vec2_input %f32vec2_01 )"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability InterpolationFunction\n")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtOffsetInternalSuccess) { const std::string body = R"( %ld1 = OpLoad %f32 %f32_input %val1 = OpExtInst %f32 %extinst InterpolateAtOffset %ld1 %f32vec2_01 %ld2 = OpLoad %f32vec2 %f32vec2_input %val2 = OpExtInst %f32vec2 %extinst InterpolateAtOffset %ld2 %f32vec2_01 )"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability InterpolationFunction\n")); getValidatorOptions()->before_hlsl_legalization = true; ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtOffsetInternalInvalidDataF32) { const std::string body = R"( %ld1 = OpLoad %f32 %f32_input %val1 = OpExtInst %f32 %extinst InterpolateAtOffset %ld1 %f32vec2_01 )"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability InterpolationFunction\n")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 InterpolateAtOffset: " "expected Interpolant to be a pointer")); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtOffsetInternalInvalidDataF32Vec2) { const std::string body = R"( %ld2 = OpLoad %f32vec2 %f32vec2_input %val2 = OpExtInst %f32vec2 %extinst InterpolateAtOffset %ld2 %f32vec2_01 )"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability InterpolationFunction\n")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 InterpolateAtOffset: " "expected Interpolant to be a pointer")); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtOffsetNoCapability) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst InterpolateAtOffset %f32_input %f32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_CAPABILITY, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 InterpolateAtOffset requires " "capability InterpolationFunction")); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtOffsetIntResultType) { const std::string body = R"( %val1 = OpExtInst %u32 %extinst InterpolateAtOffset %f32_input %f32vec2_01 )"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability InterpolationFunction\n")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 InterpolateAtOffset: " "expected Result Type to be a 32-bit float scalar " "or vector type")); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtOffsetF64ResultType) { const std::string body = R"( %val1 = OpExtInst %f64 %extinst InterpolateAtOffset %f32_input %f32vec2_01 )"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability InterpolationFunction\n")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 InterpolateAtOffset: " "expected Result Type to be a 32-bit float scalar " "or vector type")); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtOffsetNotPointer) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst InterpolateAtOffset %f32_1 %f32vec2_01 )"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability InterpolationFunction\n")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 InterpolateAtOffset: " "expected Interpolant to be a pointer")); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtOffsetWrongDataType) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst InterpolateAtOffset %f32vec2_input %f32vec2_01 )"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability InterpolationFunction\n")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 InterpolateAtOffset: " "expected Interpolant data type to be equal to " "Result Type")); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtOffsetWrongStorageClass) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst InterpolateAtOffset %f32_output %f32vec2_01 )"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability InterpolationFunction\n")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 InterpolateAtOffset: " "expected Interpolant storage class to be Input")); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtOffsetOffsetNotVector) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst InterpolateAtOffset %f32_input %f32_0 )"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability InterpolationFunction\n")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 InterpolateAtOffset: " "expected Offset to be a vector of 2 32-bit floats")); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtOffsetOffsetNotVector2) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst InterpolateAtOffset %f32_input %f32vec3_012 )"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability InterpolationFunction\n")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 InterpolateAtOffset: " "expected Offset to be a vector of 2 32-bit floats")); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtOffsetOffsetNotFloatVector) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst InterpolateAtOffset %f32_input %u32vec2_01 )"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability InterpolationFunction\n")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 InterpolateAtOffset: " "expected Offset to be a vector of 2 32-bit floats")); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtOffsetOffsetNotFloat32Vector) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst InterpolateAtOffset %f32_input %f64vec2_01 )"; CompileSuccessfully( GenerateShaderCode(body, "OpCapability InterpolationFunction\n")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 InterpolateAtOffset: " "expected Offset to be a vector of 2 32-bit floats")); } TEST_F(ValidateExtInst, GlslStd450InterpolateAtOffsetWrongExecutionModel) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst InterpolateAtOffset %f32_input %f32vec2_01 )"; CompileSuccessfully(GenerateShaderCode( body, "OpCapability InterpolationFunction\n", "Vertex")); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("GLSL.std.450 InterpolateAtOffset requires " "Fragment execution model")); } TEST_P(ValidateOpenCLStdSqrtLike, Success) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%val1 = OpExtInst %f32 %extinst " << ext_inst_name << " %f32_0\n"; ss << "%val2 = OpExtInst %f32vec2 %extinst " << ext_inst_name << " %f32vec2_01\n"; ss << "%val3 = OpExtInst %f32vec4 %extinst " << ext_inst_name << " %f32vec4_0123\n"; ss << "%val4 = OpExtInst %f64 %extinst " << ext_inst_name << " %f64_0\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateOpenCLStdSqrtLike, IntResultType) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %u32 %extinst " + ext_inst_name + " %f32_0\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected Result Type to be a float scalar " "or vector type")); } TEST_P(ValidateOpenCLStdSqrtLike, IntOperand) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %f32 %extinst " + ext_inst_name + " %u32_0\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected types of all operands to be equal to " "Result Type")); } INSTANTIATE_TEST_SUITE_P( AllSqrtLike, ValidateOpenCLStdSqrtLike, ::testing::ValuesIn(std::vector{ "acos", "acosh", "acospi", "asin", "asinh", "asinpi", "atan", "atanh", "atanpi", "cbrt", "ceil", "cos", "cosh", "cospi", "erfc", "erf", "exp", "exp2", "exp10", "expm1", "fabs", "floor", "log", "log2", "log10", "log1p", "logb", "rint", "round", "rsqrt", "sin", "sinh", "sinpi", "sqrt", "tan", "tanh", "tanpi", "tgamma", "trunc", "half_cos", "half_exp", "half_exp2", "half_exp10", "half_log", "half_log2", "half_log10", "half_recip", "half_rsqrt", "half_sin", "half_sqrt", "half_tan", "lgamma", "native_cos", "native_exp", "native_exp2", "native_exp10", "native_log", "native_log2", "native_log10", "native_recip", "native_rsqrt", "native_sin", "native_sqrt", "native_tan", "degrees", "radians", "sign", })); TEST_P(ValidateOpenCLStdFMinLike, Success) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%val1 = OpExtInst %f32 %extinst " << ext_inst_name << " %f32_0 %f32_1\n"; ss << "%val2 = OpExtInst %f32vec2 %extinst " << ext_inst_name << " %f32vec2_01 %f32vec2_12\n"; ss << "%val3 = OpExtInst %f64 %extinst " << ext_inst_name << " %f64_0 %f64_0\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateOpenCLStdFMinLike, IntResultType) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %u32 %extinst " + ext_inst_name + " %f32_0 %f32_1\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected Result Type to be a float scalar " "or vector type")); } TEST_P(ValidateOpenCLStdFMinLike, IntOperand1) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %f32 %extinst " + ext_inst_name + " %u32_0 %f32_1\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected types of all operands to be equal to " "Result Type")); } TEST_P(ValidateOpenCLStdFMinLike, IntOperand2) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %f32 %extinst " + ext_inst_name + " %f32_0 %u32_1\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected types of all operands to be equal to " "Result Type")); } INSTANTIATE_TEST_SUITE_P(AllFMinLike, ValidateOpenCLStdFMinLike, ::testing::ValuesIn(std::vector{ "atan2", "atan2pi", "copysign", "fdim", "fmax", "fmin", "fmod", "maxmag", "minmag", "hypot", "nextafter", "pow", "powr", "remainder", "half_divide", "half_powr", "native_divide", "native_powr", "step", "fmax_common", "fmin_common", })); TEST_P(ValidateOpenCLStdFClampLike, Success) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%val1 = OpExtInst %f32 %extinst " << ext_inst_name << " %f32_0 %f32_1 %f32_2\n"; ss << "%val2 = OpExtInst %f32vec2 %extinst " << ext_inst_name << " %f32vec2_01 %f32vec2_01 %f32vec2_12\n"; ss << "%val3 = OpExtInst %f64 %extinst " << ext_inst_name << " %f64_0 %f64_0 %f64_1\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateOpenCLStdFClampLike, IntResultType) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %u32 %extinst " + ext_inst_name + " %f32_0 %f32_1 %f32_2\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected Result Type to be a float scalar " "or vector type")); } TEST_P(ValidateOpenCLStdFClampLike, IntOperand1) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %f32 %extinst " + ext_inst_name + " %u32_0 %f32_0 %f32_1\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected types of all operands to be equal to " "Result Type")); } TEST_P(ValidateOpenCLStdFClampLike, IntOperand2) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %f32 %extinst " + ext_inst_name + " %f32_0 %u32_0 %f32_1\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected types of all operands to be equal to " "Result Type")); } TEST_P(ValidateOpenCLStdFClampLike, IntOperand3) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %f32 %extinst " + ext_inst_name + " %f32_1 %f32_0 %u32_2\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected types of all operands to be equal to " "Result Type")); } INSTANTIATE_TEST_SUITE_P(AllFClampLike, ValidateOpenCLStdFClampLike, ::testing::ValuesIn(std::vector{ "fma", "mad", "fclamp", "mix", "smoothstep", })); TEST_P(ValidateOpenCLStdSAbsLike, Success) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%val1 = OpExtInst %u32 %extinst " << ext_inst_name << " %u32_1\n"; ss << "%val2 = OpExtInst %u32 %extinst " << ext_inst_name << " %u32_1\n"; ss << "%val3 = OpExtInst %u32 %extinst " << ext_inst_name << " %u32_1\n"; ss << "%val4 = OpExtInst %u32 %extinst " << ext_inst_name << " %u32_1\n"; ss << "%val5 = OpExtInst %u32vec2 %extinst " << ext_inst_name << " %u32vec2_01\n"; ss << "%val6 = OpExtInst %u32vec2 %extinst " << ext_inst_name << " %u32vec2_01\n"; ss << "%val7 = OpExtInst %u32vec2 %extinst " << ext_inst_name << " %u32vec2_01\n"; ss << "%val8 = OpExtInst %u32vec2 %extinst " << ext_inst_name << " %u32vec2_01\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateOpenCLStdSAbsLike, FloatResultType) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %f32 %extinst " + ext_inst_name + " %u32_0\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected Result Type to be an int scalar " "or vector type")); } TEST_P(ValidateOpenCLStdSAbsLike, FloatOperand) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %u32 %extinst " + ext_inst_name + " %f32_0\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected types of all operands to be equal to Result Type")); } TEST_P(ValidateOpenCLStdSAbsLike, U64Operand) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %u32 %extinst " + ext_inst_name + " %u64_0\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected types of all operands to be equal to Result Type")); } INSTANTIATE_TEST_SUITE_P(AllSAbsLike, ValidateOpenCLStdSAbsLike, ::testing::ValuesIn(std::vector{ "s_abs", "clz", "ctz", "popcount", "u_abs", })); TEST_P(ValidateOpenCLStdUMinLike, Success) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%val1 = OpExtInst %u32 %extinst " << ext_inst_name << " %u32_1 %u32_2\n"; ss << "%val2 = OpExtInst %u32 %extinst " << ext_inst_name << " %u32_1 %u32_2\n"; ss << "%val3 = OpExtInst %u32 %extinst " << ext_inst_name << " %u32_1 %u32_2\n"; ss << "%val4 = OpExtInst %u32 %extinst " << ext_inst_name << " %u32_1 %u32_2\n"; ss << "%val5 = OpExtInst %u32vec2 %extinst " << ext_inst_name << " %u32vec2_01 %u32vec2_01\n"; ss << "%val6 = OpExtInst %u32vec2 %extinst " << ext_inst_name << " %u32vec2_01 %u32vec2_01\n"; ss << "%val7 = OpExtInst %u32vec2 %extinst " << ext_inst_name << " %u32vec2_01 %u32vec2_01\n"; ss << "%val8 = OpExtInst %u32vec2 %extinst " << ext_inst_name << " %u32vec2_01 %u32vec2_01\n"; ss << "%val9 = OpExtInst %u64 %extinst " << ext_inst_name << " %u64_1 %u64_0\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateOpenCLStdUMinLike, FloatResultType) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %f32 %extinst " + ext_inst_name + " %u32_0 %u32_0\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected Result Type to be an int scalar " "or vector type")); } TEST_P(ValidateOpenCLStdUMinLike, FloatOperand1) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %u32 %extinst " + ext_inst_name + " %f32_0 %u32_0\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected types of all operands to be equal to Result Type")); } TEST_P(ValidateOpenCLStdUMinLike, FloatOperand2) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %u32 %extinst " + ext_inst_name + " %u32_0 %f32_0\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected types of all operands to be equal to Result Type")); } TEST_P(ValidateOpenCLStdUMinLike, U64Operand1) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %u32 %extinst " + ext_inst_name + " %u64_0 %u32_0\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected types of all operands to be equal to Result Type")); } TEST_P(ValidateOpenCLStdUMinLike, U64Operand2) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %u32 %extinst " + ext_inst_name + " %u32_0 %u64_0\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected types of all operands to be equal to Result Type")); } INSTANTIATE_TEST_SUITE_P(AllUMinLike, ValidateOpenCLStdUMinLike, ::testing::ValuesIn(std::vector{ "s_max", "u_max", "s_min", "u_min", "s_abs_diff", "s_add_sat", "u_add_sat", "s_mul_hi", "rotate", "s_sub_sat", "u_sub_sat", "s_hadd", "u_hadd", "s_rhadd", "u_rhadd", "u_abs_diff", "u_mul_hi", })); TEST_P(ValidateOpenCLStdUClampLike, Success) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%val1 = OpExtInst %u32 %extinst " << ext_inst_name << " %u32_0 %u32_1 %u32_2\n"; ss << "%val2 = OpExtInst %u32 %extinst " << ext_inst_name << " %u32_0 %u32_1 %u32_2\n"; ss << "%val3 = OpExtInst %u32 %extinst " << ext_inst_name << " %u32_0 %u32_1 %u32_2\n"; ss << "%val4 = OpExtInst %u32 %extinst " << ext_inst_name << " %u32_0 %u32_1 %u32_2\n"; ss << "%val5 = OpExtInst %u32vec2 %extinst " << ext_inst_name << " %u32vec2_01 %u32vec2_01 %u32vec2_12\n"; ss << "%val6 = OpExtInst %u32vec2 %extinst " << ext_inst_name << " %u32vec2_01 %u32vec2_01 %u32vec2_12\n"; ss << "%val7 = OpExtInst %u32vec2 %extinst " << ext_inst_name << " %u32vec2_01 %u32vec2_01 %u32vec2_12\n"; ss << "%val8 = OpExtInst %u32vec2 %extinst " << ext_inst_name << " %u32vec2_01 %u32vec2_01 %u32vec2_12\n"; ss << "%val9 = OpExtInst %u64 %extinst " << ext_inst_name << " %u64_1 %u64_0 %u64_1\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateOpenCLStdUClampLike, FloatResultType) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %f32 %extinst " + ext_inst_name + " %u32_0 %u32_0 %u32_1\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected Result Type to be an int scalar " "or vector type")); } TEST_P(ValidateOpenCLStdUClampLike, FloatOperand1) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %u32 %extinst " + ext_inst_name + " %f32_0 %u32_0 %u32_1\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected types of all operands to be equal to Result Type")); } TEST_P(ValidateOpenCLStdUClampLike, FloatOperand2) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %u32 %extinst " + ext_inst_name + " %u32_0 %f32_0 %u32_1\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected types of all operands to be equal to Result Type")); } TEST_P(ValidateOpenCLStdUClampLike, FloatOperand3) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %u32 %extinst " + ext_inst_name + " %u32_0 %u32_0 %f32_1\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected types of all operands to be equal to Result Type")); } TEST_P(ValidateOpenCLStdUClampLike, U64Operand1) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %u32 %extinst " + ext_inst_name + " %f32_0 %u32_0 %u64_1\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected types of all operands to be equal to Result Type")); } TEST_P(ValidateOpenCLStdUClampLike, U64Operand2) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %u32 %extinst " + ext_inst_name + " %u32_0 %f32_0 %u64_1\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected types of all operands to be equal to Result Type")); } TEST_P(ValidateOpenCLStdUClampLike, U64Operand3) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %u32 %extinst " + ext_inst_name + " %u32_0 %u32_0 %u64_1\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected types of all operands to be equal to Result Type")); } INSTANTIATE_TEST_SUITE_P(AllUClampLike, ValidateOpenCLStdUClampLike, ::testing::ValuesIn(std::vector{ "s_clamp", "u_clamp", "s_mad_hi", "u_mad_sat", "s_mad_sat", "u_mad_hi", })); // ------------------------------------------------------------- TEST_P(ValidateOpenCLStdUMul24Like, Success) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%val1 = OpExtInst %u32 %extinst " << ext_inst_name << " %u32_1 %u32_2\n"; ss << "%val2 = OpExtInst %u32 %extinst " << ext_inst_name << " %u32_1 %u32_2\n"; ss << "%val3 = OpExtInst %u32 %extinst " << ext_inst_name << " %u32_1 %u32_2\n"; ss << "%val4 = OpExtInst %u32 %extinst " << ext_inst_name << " %u32_1 %u32_2\n"; ss << "%val5 = OpExtInst %u32vec2 %extinst " << ext_inst_name << " %u32vec2_01 %u32vec2_01\n"; ss << "%val6 = OpExtInst %u32vec2 %extinst " << ext_inst_name << " %u32vec2_01 %u32vec2_01\n"; ss << "%val7 = OpExtInst %u32vec2 %extinst " << ext_inst_name << " %u32vec2_01 %u32vec2_01\n"; ss << "%val8 = OpExtInst %u32vec2 %extinst " << ext_inst_name << " %u32vec2_01 %u32vec2_01\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateOpenCLStdUMul24Like, FloatResultType) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %f32 %extinst " + ext_inst_name + " %u32_0 %u32_0\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpenCL.std " + ext_inst_name + ": expected Result Type to be a 32-bit int scalar or vector type")); } TEST_P(ValidateOpenCLStdUMul24Like, U64ResultType) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %u64 %extinst " + ext_inst_name + " %u64_0 %u64_0\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpenCL.std " + ext_inst_name + ": expected Result Type to be a 32-bit int scalar or vector type")); } TEST_P(ValidateOpenCLStdUMul24Like, FloatOperand1) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %u32 %extinst " + ext_inst_name + " %f32_0 %u32_0\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected types of all operands to be equal to Result Type")); } TEST_P(ValidateOpenCLStdUMul24Like, FloatOperand2) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %u32 %extinst " + ext_inst_name + " %u32_0 %f32_0\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected types of all operands to be equal to Result Type")); } TEST_P(ValidateOpenCLStdUMul24Like, U64Operand1) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %u32 %extinst " + ext_inst_name + " %u64_0 %u32_0\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected types of all operands to be equal to Result Type")); } TEST_P(ValidateOpenCLStdUMul24Like, U64Operand2) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %u32 %extinst " + ext_inst_name + " %u32_0 %u64_0\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected types of all operands to be equal to Result Type")); } INSTANTIATE_TEST_SUITE_P(AllUMul24Like, ValidateOpenCLStdUMul24Like, ::testing::ValuesIn(std::vector{ "s_mul24", "u_mul24", })); TEST_P(ValidateOpenCLStdUMad24Like, Success) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%val1 = OpExtInst %u32 %extinst " << ext_inst_name << " %u32_0 %u32_1 %u32_2\n"; ss << "%val2 = OpExtInst %u32 %extinst " << ext_inst_name << " %u32_0 %u32_1 %u32_2\n"; ss << "%val3 = OpExtInst %u32 %extinst " << ext_inst_name << " %u32_0 %u32_1 %u32_2\n"; ss << "%val4 = OpExtInst %u32 %extinst " << ext_inst_name << " %u32_0 %u32_1 %u32_2\n"; ss << "%val5 = OpExtInst %u32vec2 %extinst " << ext_inst_name << " %u32vec2_01 %u32vec2_01 %u32vec2_12\n"; ss << "%val6 = OpExtInst %u32vec2 %extinst " << ext_inst_name << " %u32vec2_01 %u32vec2_01 %u32vec2_12\n"; ss << "%val7 = OpExtInst %u32vec2 %extinst " << ext_inst_name << " %u32vec2_01 %u32vec2_01 %u32vec2_12\n"; ss << "%val8 = OpExtInst %u32vec2 %extinst " << ext_inst_name << " %u32vec2_01 %u32vec2_01 %u32vec2_12\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateOpenCLStdUMad24Like, FloatResultType) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %f32 %extinst " + ext_inst_name + " %u32_0 %u32_0 %u32_1\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpenCL.std " + ext_inst_name + ": expected Result Type to be a 32-bit int scalar or vector type")); } TEST_P(ValidateOpenCLStdUMad24Like, U64ResultType) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %u64 %extinst " + ext_inst_name + " %u64_0 %u64_0 %u64_1\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpenCL.std " + ext_inst_name + ": expected Result Type to be a 32-bit int scalar or vector type")); } TEST_P(ValidateOpenCLStdUMad24Like, FloatOperand1) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %u32 %extinst " + ext_inst_name + " %f32_0 %u32_0 %u32_1\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected types of all operands to be equal to Result Type")); } TEST_P(ValidateOpenCLStdUMad24Like, FloatOperand2) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %u32 %extinst " + ext_inst_name + " %u32_0 %f32_0 %u32_1\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected types of all operands to be equal to Result Type")); } TEST_P(ValidateOpenCLStdUMad24Like, FloatOperand3) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %u32 %extinst " + ext_inst_name + " %u32_0 %u32_0 %f32_1\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected types of all operands to be equal to Result Type")); } TEST_P(ValidateOpenCLStdUMad24Like, U64Operand1) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %u32 %extinst " + ext_inst_name + " %f32_0 %u32_0 %u64_1\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected types of all operands to be equal to Result Type")); } TEST_P(ValidateOpenCLStdUMad24Like, U64Operand2) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %u32 %extinst " + ext_inst_name + " %u32_0 %f32_0 %u64_1\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected types of all operands to be equal to Result Type")); } TEST_P(ValidateOpenCLStdUMad24Like, U64Operand3) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %u32 %extinst " + ext_inst_name + " %u32_0 %u32_0 %u64_1\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected types of all operands to be equal to Result Type")); } INSTANTIATE_TEST_SUITE_P(AllUMad24Like, ValidateOpenCLStdUMad24Like, ::testing::ValuesIn(std::vector{ "s_mad24", "u_mad24", })); TEST_F(ValidateExtInst, OpenCLStdCrossSuccess) { const std::string body = R"( %val1 = OpExtInst %f32vec3 %extinst cross %f32vec3_012 %f32vec3_123 %val2 = OpExtInst %f32vec4 %extinst cross %f32vec4_0123 %f32vec4_0123 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, OpenCLStdCrossIntVectorResultType) { const std::string body = R"( %val1 = OpExtInst %u32vec3 %extinst cross %f32vec3_012 %f32vec3_123 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std cross: " "expected Result Type to be a float vector type")); } TEST_F(ValidateExtInst, OpenCLStdCrossResultTypeWrongSize) { const std::string body = R"( %val1 = OpExtInst %f32vec2 %extinst cross %f32vec3_012 %f32vec3_123 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std cross: " "expected Result Type to have 3 or 4 components")); } TEST_F(ValidateExtInst, OpenCLStdCrossXWrongType) { const std::string body = R"( %val1 = OpExtInst %f32vec3 %extinst cross %f64vec3_012 %f32vec3_123 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std cross: " "expected operand X type to be equal to Result Type")); } TEST_F(ValidateExtInst, OpenCLStdCrossYWrongType) { const std::string body = R"( %val1 = OpExtInst %f32vec3 %extinst cross %f32vec3_123 %f64vec3_012 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std cross: " "expected operand Y type to be equal to Result Type")); } TEST_P(ValidateOpenCLStdLengthLike, Success) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%val1 = OpExtInst %f32 %extinst " << ext_inst_name << " %f32vec2_01\n"; ss << "%val2 = OpExtInst %f32 %extinst " << ext_inst_name << " %f32vec4_0123\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateOpenCLStdLengthLike, IntResultType) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %u32 %extinst " + ext_inst_name + " %f32vec2_01\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": " "expected Result Type to be a float scalar type")); } TEST_P(ValidateOpenCLStdLengthLike, IntX) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %f32 %extinst " + ext_inst_name + " %u32vec2_01\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": " "expected operand P to be a float scalar or vector")); } TEST_P(ValidateOpenCLStdLengthLike, VectorTooBig) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %f32 %extinst " + ext_inst_name + " %f32vec8_01010101\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": " "expected operand P to have no more than 4 components")); } TEST_P(ValidateOpenCLStdLengthLike, DifferentType) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %f64 %extinst " + ext_inst_name + " %f32vec2_01\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": " "expected operand P component type to be equal to " "Result Type")); } INSTANTIATE_TEST_SUITE_P(AllLengthLike, ValidateOpenCLStdLengthLike, ::testing::ValuesIn(std::vector{ "length", "fast_length", })); TEST_P(ValidateOpenCLStdDistanceLike, Success) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%val1 = OpExtInst %f32 %extinst " << ext_inst_name << " %f32vec2_01 %f32vec2_01\n"; ss << "%val2 = OpExtInst %f32 %extinst " << ext_inst_name << " %f32vec4_0123 %f32vec4_1234\n"; ss << "%val3 = OpExtInst %f32 %extinst " << ext_inst_name << " %f32_0 %f32_1\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateOpenCLStdDistanceLike, IntResultType) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %u32 %extinst " + ext_inst_name + " %f32vec2_01 %f32vec2_12\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": " "expected Result Type to be a float scalar type")); } TEST_P(ValidateOpenCLStdDistanceLike, IntP0) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %f32 %extinst " + ext_inst_name + " %u32vec2_01 %f32vec2_12\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": " "expected operand P0 to be of float scalar or vector type")); } TEST_P(ValidateOpenCLStdDistanceLike, VectorTooBig) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %f32 %extinst " + ext_inst_name + " %f32vec8_01010101 %f32vec8_01010101\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": " "expected operand P0 to have no more than 4 components")); } TEST_P(ValidateOpenCLStdDistanceLike, F64P0) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %f32 %extinst " + ext_inst_name + " %f64vec2_01 %f32vec2_12\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpenCL.std " + ext_inst_name + ": " "expected operand P0 component type to be equal to Result Type")); } TEST_P(ValidateOpenCLStdDistanceLike, DifferentOperands) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %f64 %extinst " + ext_inst_name + " %f64vec2_01 %f32vec2_12\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": " "expected operands P0 and P1 to be of the same type")); } INSTANTIATE_TEST_SUITE_P(AllDistanceLike, ValidateOpenCLStdDistanceLike, ::testing::ValuesIn(std::vector{ "distance", "fast_distance", })); TEST_P(ValidateOpenCLStdNormalizeLike, Success) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%val1 = OpExtInst %f32vec2 %extinst " << ext_inst_name << " %f32vec2_01\n"; ss << "%val2 = OpExtInst %f32vec4 %extinst " << ext_inst_name << " %f32vec4_0123\n"; ss << "%val3 = OpExtInst %f32 %extinst " << ext_inst_name << " %f32_2\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateOpenCLStdNormalizeLike, IntResultType) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %u32 %extinst " + ext_inst_name + " %f32_2\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": " "expected Result Type to be a float scalar or vector type")); } TEST_P(ValidateOpenCLStdNormalizeLike, VectorTooBig) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %f32vec8 %extinst " + ext_inst_name + " %f32vec8_01010101\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": " "expected Result Type to have no more than 4 components")); } TEST_P(ValidateOpenCLStdNormalizeLike, DifferentType) { const std::string ext_inst_name = GetParam(); const std::string body = "%val1 = OpExtInst %f64vec2 %extinst " + ext_inst_name + " %f32vec2_01\n"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": " "expected operand P type to be equal to Result Type")); } INSTANTIATE_TEST_SUITE_P(AllNormalizeLike, ValidateOpenCLStdNormalizeLike, ::testing::ValuesIn(std::vector{ "normalize", "fast_normalize", })); TEST_F(ValidateExtInst, OpenCLStdBitselectSuccess) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst bitselect %f32_2 %f32_1 %f32_1 %val2 = OpExtInst %f32vec4 %extinst bitselect %f32vec4_0123 %f32vec4_1234 %f32vec4_0123 %val3 = OpExtInst %u32 %extinst bitselect %u32_2 %u32_1 %u32_1 %val4 = OpExtInst %u32vec4 %extinst bitselect %u32vec4_0123 %u32vec4_0123 %u32vec4_0123 %val5 = OpExtInst %u64 %extinst bitselect %u64_2 %u64_1 %u64_1 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, OpenCLStdBitselectWrongResultType) { const std::string body = R"( %val3 = OpExtInst %struct_f32_f32 %extinst bitselect %u32_2 %u32_1 %u32_1 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpenCL.std bitselect: " "expected Result Type to be an int or float scalar or vector type")); } TEST_F(ValidateExtInst, OpenCLStdBitselectAWrongType) { const std::string body = R"( %val3 = OpExtInst %u32 %extinst bitselect %f32_2 %u32_1 %u32_1 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std bitselect: " "expected types of all operands to be equal to Result Type")); } TEST_F(ValidateExtInst, OpenCLStdBitselectBWrongType) { const std::string body = R"( %val3 = OpExtInst %u32 %extinst bitselect %u32_2 %f32_1 %u32_1 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std bitselect: " "expected types of all operands to be equal to Result Type")); } TEST_F(ValidateExtInst, OpenCLStdBitselectCWrongType) { const std::string body = R"( %val3 = OpExtInst %u32 %extinst bitselect %u32_2 %u32_1 %f32_1 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std bitselect: " "expected types of all operands to be equal to Result Type")); } TEST_F(ValidateExtInst, OpenCLStdSelectSuccess) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst select %f32_2 %f32_1 %u32_1 %val2 = OpExtInst %f32vec4 %extinst select %f32vec4_0123 %f32vec4_1234 %u32vec4_0123 %val3 = OpExtInst %u32 %extinst select %u32_2 %u32_1 %u32_1 %val4 = OpExtInst %u32vec4 %extinst select %u32vec4_0123 %u32vec4_0123 %u32vec4_0123 %val5 = OpExtInst %u64 %extinst select %u64_2 %u64_1 %u64_1 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, OpenCLStdSelectWrongResultType) { const std::string body = R"( %val3 = OpExtInst %struct_f32_f32 %extinst select %u32_2 %u32_1 %u32_1 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpenCL.std select: " "expected Result Type to be an int or float scalar or vector type")); } TEST_F(ValidateExtInst, OpenCLStdSelectAWrongType) { const std::string body = R"( %val3 = OpExtInst %u32 %extinst select %f32_2 %u32_1 %u32_1 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std select: " "expected operand A type to be equal to Result Type")); } TEST_F(ValidateExtInst, OpenCLStdSelectBWrongType) { const std::string body = R"( %val3 = OpExtInst %u32 %extinst select %u32_2 %f32_1 %u32_1 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std select: " "expected operand B type to be equal to Result Type")); } TEST_F(ValidateExtInst, OpenCLStdSelectCWrongType) { const std::string body = R"( %val3 = OpExtInst %f32 %extinst select %f32_2 %f32_1 %f32_1 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std select: " "expected operand C to be an int scalar or vector")); } TEST_F(ValidateExtInst, OpenCLStdSelectCWrongComponentNumber) { const std::string body = R"( %val3 = OpExtInst %f32vec2 %extinst select %f32vec2_12 %f32vec2_01 %u32_1 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std select: " "expected operand C to have the same number of " "components as Result Type")); } TEST_F(ValidateExtInst, OpenCLStdSelectCWrongBitWidth) { const std::string body = R"( %val3 = OpExtInst %f32vec2 %extinst select %f32vec2_12 %f32vec2_01 %u64vec2_01 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpenCL.std select: " "expected operand C to have the same bit width as Result Type")); } TEST_P(ValidateOpenCLStdVStoreHalfLike, SuccessPhysical32) { const std::string ext_inst_name = GetParam(); const std::string rounding_mode = ext_inst_name.substr(ext_inst_name.length() - 2) == "_r" ? " RTE" : ""; std::ostringstream ss; ss << "%ptr = OpAccessChain %f16_ptr_workgroup %f16vec8_workgroup %u32_1\n"; if (std::string::npos == ext_inst_name.find("halfn")) { ss << "%val1 = OpExtInst %void %extinst " << ext_inst_name << " %f32_1 %u32_1 %ptr" << rounding_mode << "\n"; ss << "%val2 = OpExtInst %void %extinst " << ext_inst_name << " %f64_0 %u32_2 %ptr" << rounding_mode << "\n"; } else { ss << "%val1 = OpExtInst %void %extinst " << ext_inst_name << " %f32vec2_01 %u32_1 %ptr" << rounding_mode << "\n"; ss << "%val2 = OpExtInst %void %extinst " << ext_inst_name << " %f32vec4_0123 %u32_0 %ptr" << rounding_mode << "\n"; ss << "%val3 = OpExtInst %void %extinst " << ext_inst_name << " %f64vec2_01 %u32_2 %ptr" << rounding_mode << "\n"; } CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateOpenCLStdVStoreHalfLike, SuccessPhysical64) { const std::string ext_inst_name = GetParam(); const std::string rounding_mode = ext_inst_name.substr(ext_inst_name.length() - 2) == "_r" ? " RTE" : ""; std::ostringstream ss; ss << "%ptr = OpAccessChain %f16_ptr_workgroup %f16vec8_workgroup %u32_1\n"; if (std::string::npos == ext_inst_name.find("halfn")) { ss << "%val1 = OpExtInst %void %extinst " << ext_inst_name << " %f32_1 %u64_1 %ptr" << rounding_mode << "\n"; ss << "%val2 = OpExtInst %void %extinst " << ext_inst_name << " %f64_0 %u64_2 %ptr" << rounding_mode << "\n"; } else { ss << "%val1 = OpExtInst %void %extinst " << ext_inst_name << " %f32vec2_01 %u64_1 %ptr" << rounding_mode << "\n"; ss << "%val2 = OpExtInst %void %extinst " << ext_inst_name << " %f32vec4_0123 %u64_0 %ptr" << rounding_mode << "\n"; ss << "%val3 = OpExtInst %void %extinst " << ext_inst_name << " %f64vec2_01 %u64_2 %ptr" << rounding_mode << "\n"; } CompileSuccessfully(GenerateKernelCode(ss.str(), "", "Physical64")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateOpenCLStdVStoreHalfLike, NonVoidResultType) { const std::string ext_inst_name = GetParam(); const std::string rounding_mode = ext_inst_name.substr(ext_inst_name.length() - 2) == "_r" ? " RTE" : ""; std::ostringstream ss; ss << "%ptr = OpAccessChain %f16_ptr_workgroup %f16vec8_workgroup %u32_1\n"; if (std::string::npos == ext_inst_name.find("halfn")) { ss << "%val1 = OpExtInst %f32 %extinst " << ext_inst_name << " %f32_1 %u32_1 %ptr" << rounding_mode << "\n"; } else { ss << "%val1 = OpExtInst %f32 %extinst " << ext_inst_name << " %f32vec2_01 %u32_1 %ptr" << rounding_mode << "\n"; } CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected Result Type to be void")); } TEST_P(ValidateOpenCLStdVStoreHalfLike, WrongDataType) { const std::string ext_inst_name = GetParam(); const std::string rounding_mode = ext_inst_name.substr(ext_inst_name.length() - 2) == "_r" ? " RTE" : ""; std::ostringstream ss; ss << "%ptr = OpAccessChain %f16_ptr_workgroup %f16vec8_workgroup %u32_1\n"; if (std::string::npos == ext_inst_name.find("halfn")) { ss << "%val1 = OpExtInst %void %extinst " << ext_inst_name << " %f64vec2_01 %u32_1 %ptr" << rounding_mode << "\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected Data to be a 32 or 64-bit float scalar")); } else { ss << "%val1 = OpExtInst %void %extinst " << ext_inst_name << " %f64_0 %u32_1 %ptr" << rounding_mode << "\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected Data to be a 32 or 64-bit float vector")); } } TEST_P(ValidateOpenCLStdVStoreHalfLike, AddressingModelLogical) { const std::string ext_inst_name = GetParam(); const std::string rounding_mode = ext_inst_name.substr(ext_inst_name.length() - 2) == "_r" ? " RTE" : ""; std::ostringstream ss; ss << "%ptr = OpAccessChain %f16_ptr_workgroup %f16vec8_workgroup %u32_1\n"; if (std::string::npos == ext_inst_name.find("halfn")) { ss << "%val1 = OpExtInst %void %extinst " << ext_inst_name << " %f32_0 %u32_1 %ptr" << rounding_mode << "\n"; } else { ss << "%val1 = OpExtInst %void %extinst " << ext_inst_name << " %f32vec2_01 %u32_1 %ptr" << rounding_mode << "\n"; } CompileSuccessfully(GenerateKernelCode(ss.str(), "", "Logical")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + " can only be used with physical addressing models")); } TEST_P(ValidateOpenCLStdVStoreHalfLike, OffsetNotSizeT) { const std::string ext_inst_name = GetParam(); const std::string rounding_mode = ext_inst_name.substr(ext_inst_name.length() - 2) == "_r" ? " RTE" : ""; std::ostringstream ss; ss << "%ptr = OpAccessChain %f16_ptr_workgroup %f16vec8_workgroup %u32_1\n"; if (std::string::npos == ext_inst_name.find("halfn")) { ss << "%val1 = OpExtInst %void %extinst " << ext_inst_name << " %f32_0 %u32_1 %ptr" << rounding_mode << "\n"; } else { ss << "%val1 = OpExtInst %void %extinst " << ext_inst_name << " %f32vec2_01 %u32_1 %ptr" << rounding_mode << "\n"; } CompileSuccessfully(GenerateKernelCode(ss.str(), "", "Physical64")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": " "expected operand Offset to be of type size_t (64-bit integer " "for the addressing model used in the module)")); } TEST_P(ValidateOpenCLStdVStoreHalfLike, PNotPointer) { const std::string ext_inst_name = GetParam(); const std::string rounding_mode = ext_inst_name.substr(ext_inst_name.length() - 2) == "_r" ? " RTE" : ""; std::ostringstream ss; if (std::string::npos == ext_inst_name.find("halfn")) { ss << "%val1 = OpExtInst %void %extinst " << ext_inst_name << " %f32_0 %u32_1 %f16_ptr_workgroup" << rounding_mode << "\n"; } else { ss << "%val1 = OpExtInst %void %extinst " << ext_inst_name << " %f32vec2_01 %u32_1 %f16_ptr_workgroup" << rounding_mode << "\n"; } CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Operand '89[%_ptr_Workgroup_half]' cannot be a type")); } TEST_P(ValidateOpenCLStdVStoreHalfLike, ConstPointer) { const std::string ext_inst_name = GetParam(); const std::string rounding_mode = ext_inst_name.substr(ext_inst_name.length() - 2) == "_r" ? " RTE" : ""; std::ostringstream ss; ss << "%ptr = OpAccessChain %f16_ptr_uniform_constant " "%f16vec8_uniform_constant %u32_1\n"; if (std::string::npos == ext_inst_name.find("halfn")) { ss << "%val1 = OpExtInst %void %extinst " << ext_inst_name << " %f32_0 %u32_1 %ptr" << rounding_mode << "\n"; } else { ss << "%val1 = OpExtInst %void %extinst " << ext_inst_name << " %f32vec2_01 %u32_1 %ptr" << rounding_mode << "\n"; } CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected operand P storage class to be Generic, " "CrossWorkgroup, Workgroup or Function")); } TEST_P(ValidateOpenCLStdVStoreHalfLike, PDataTypeInt) { const std::string ext_inst_name = GetParam(); const std::string rounding_mode = ext_inst_name.substr(ext_inst_name.length() - 2) == "_r" ? " RTE" : ""; std::ostringstream ss; ss << "%ptr = OpAccessChain %u32_ptr_workgroup %u32vec8_workgroup %u32_1\n"; if (std::string::npos == ext_inst_name.find("halfn")) { ss << "%val1 = OpExtInst %void %extinst " << ext_inst_name << " %f32_0 %u32_1 %ptr" << rounding_mode << "\n"; } else { ss << "%val1 = OpExtInst %void %extinst " << ext_inst_name << " %f32vec2_01 %u32_1 %ptr" << rounding_mode << "\n"; } CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected operand P data type to be 16-bit float scalar")); } TEST_P(ValidateOpenCLStdVStoreHalfLike, PDataTypeFloat32) { const std::string ext_inst_name = GetParam(); const std::string rounding_mode = ext_inst_name.substr(ext_inst_name.length() - 2) == "_r" ? " RTE" : ""; std::ostringstream ss; ss << "%ptr = OpAccessChain %f32_ptr_workgroup %f32vec8_workgroup %u32_1\n"; if (std::string::npos == ext_inst_name.find("halfn")) { ss << "%val1 = OpExtInst %void %extinst " << ext_inst_name << " %f32_0 %u32_1 %ptr" << rounding_mode << "\n"; } else { ss << "%val1 = OpExtInst %void %extinst " << ext_inst_name << " %f32vec2_01 %u32_1 %ptr" << rounding_mode << "\n"; } CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected operand P data type to be 16-bit float scalar")); } INSTANTIATE_TEST_SUITE_P(AllVStoreHalfLike, ValidateOpenCLStdVStoreHalfLike, ::testing::ValuesIn(std::vector{ "vstore_half", "vstore_half_r", "vstore_halfn", "vstore_halfn_r", "vstorea_halfn", "vstorea_halfn_r", })); TEST_P(ValidateOpenCLStdVLoadHalfLike, SuccessPhysical32) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%ptr = OpAccessChain %f16_ptr_workgroup %f16vec8_workgroup %u32_1\n"; ss << "%val1 = OpExtInst %f32vec2 %extinst " << ext_inst_name << " %u32_1 %ptr 2\n"; ss << "%val2 = OpExtInst %f32vec3 %extinst " << ext_inst_name << " %u32_1 %ptr 3\n"; ss << "%val3 = OpExtInst %f32vec4 %extinst " << ext_inst_name << " %u32_1 %ptr 4\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateOpenCLStdVLoadHalfLike, SuccessPhysical64) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%ptr = OpAccessChain %f16_ptr_workgroup %f16vec8_workgroup %u32_1\n"; ss << "%val1 = OpExtInst %f32vec2 %extinst " << ext_inst_name << " %u64_1 %ptr 2\n"; ss << "%val2 = OpExtInst %f32vec3 %extinst " << ext_inst_name << " %u64_1 %ptr 3\n"; ss << "%val3 = OpExtInst %f32vec4 %extinst " << ext_inst_name << " %u64_1 %ptr 4\n"; CompileSuccessfully(GenerateKernelCode(ss.str(), "", "Physical64")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateOpenCLStdVLoadHalfLike, ResultTypeNotFloatVector) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%ptr = OpAccessChain %f16_ptr_workgroup %f16vec8_workgroup %u32_1\n"; ss << "%val1 = OpExtInst %f32 %extinst " << ext_inst_name << " %u32_1 %ptr 1\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected Result Type to be a float vector type")); } TEST_P(ValidateOpenCLStdVLoadHalfLike, AddressingModelLogical) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%ptr = OpAccessChain %f16_ptr_workgroup %f16vec8_workgroup %u32_1\n"; ss << "%val1 = OpExtInst %f32vec2 %extinst " << ext_inst_name << " %u32_1 %ptr 2\n"; CompileSuccessfully(GenerateKernelCode(ss.str(), "", "Logical")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + " can only be used with physical addressing models")); } TEST_P(ValidateOpenCLStdVLoadHalfLike, OffsetNotSizeT) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%ptr = OpAccessChain %f16_ptr_workgroup %f16vec8_workgroup %u32_1\n"; ss << "%val1 = OpExtInst %f32vec2 %extinst " << ext_inst_name << " %u64_1 %ptr 2\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected operand Offset to be of type size_t (32-bit " "integer for the addressing model used in the module)")); } TEST_P(ValidateOpenCLStdVLoadHalfLike, PNotPointer) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%val1 = OpExtInst %f32vec2 %extinst " << ext_inst_name << " %u32_1 %f16_ptr_workgroup 2\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Operand '89[%_ptr_Workgroup_half]' cannot be a type")); } TEST_P(ValidateOpenCLStdVLoadHalfLike, OffsetWrongStorageType) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%ptr = OpAccessChain %f16_ptr_input %f16vec8_input %u32_1\n"; ss << "%val1 = OpExtInst %f32vec2 %extinst " << ext_inst_name << " %u32_1 %ptr 2\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected operand P storage class to be UniformConstant, " "Generic, CrossWorkgroup, Workgroup or Function")); } TEST_P(ValidateOpenCLStdVLoadHalfLike, PDataTypeInt) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%ptr = OpAccessChain %u32_ptr_workgroup %u32vec8_workgroup %u32_1\n"; ss << "%val1 = OpExtInst %f32vec2 %extinst " << ext_inst_name << " %u32_1 %ptr 2\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected operand P data type to be 16-bit float scalar")); } TEST_P(ValidateOpenCLStdVLoadHalfLike, PDataTypeFloat32) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%ptr = OpAccessChain %f32_ptr_workgroup %f32vec8_workgroup %u32_1\n"; ss << "%val1 = OpExtInst %f32vec2 %extinst " << ext_inst_name << " %u32_1 %ptr 2\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected operand P data type to be 16-bit float scalar")); } TEST_P(ValidateOpenCLStdVLoadHalfLike, WrongN) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%ptr = OpAccessChain %f16_ptr_workgroup %f16vec8_workgroup %u32_1\n"; ss << "%val1 = OpExtInst %f32vec2 %extinst " << ext_inst_name << " %u32_1 %ptr 3\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected literal N to be equal to the number of " "components of Result Type")); } INSTANTIATE_TEST_SUITE_P(AllVLoadHalfLike, ValidateOpenCLStdVLoadHalfLike, ::testing::ValuesIn(std::vector{ "vload_halfn", "vloada_halfn", })); TEST_F(ValidateExtInst, VLoadNSuccessFloatPhysical32) { std::ostringstream ss; ss << "%ptr = OpAccessChain %f32_ptr_uniform_constant " "%f32vec8_uniform_constant %u32_1\n"; ss << "%val1 = OpExtInst %f32vec2 %extinst vloadn %u32_1 %ptr 2\n"; ss << "%val2 = OpExtInst %f32vec3 %extinst vloadn %u32_1 %ptr 3\n"; ss << "%val3 = OpExtInst %f32vec4 %extinst vloadn %u32_1 %ptr 4\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, VLoadNSuccessIntPhysical32) { std::ostringstream ss; ss << "%ptr = OpAccessChain %u32_ptr_uniform_constant " "%u32vec8_uniform_constant %u32_1\n"; ss << "%val1 = OpExtInst %u32vec2 %extinst vloadn %u32_1 %ptr 2\n"; ss << "%val2 = OpExtInst %u32vec3 %extinst vloadn %u32_1 %ptr 3\n"; ss << "%val3 = OpExtInst %u32vec4 %extinst vloadn %u32_1 %ptr 4\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, VLoadNSuccessFloatPhysical64) { std::ostringstream ss; ss << "%ptr = OpAccessChain %f32_ptr_uniform_constant " "%f32vec8_uniform_constant %u32_1\n"; ss << "%val1 = OpExtInst %f32vec2 %extinst vloadn %u64_1 %ptr 2\n"; ss << "%val2 = OpExtInst %f32vec3 %extinst vloadn %u64_1 %ptr 3\n"; ss << "%val3 = OpExtInst %f32vec4 %extinst vloadn %u64_1 %ptr 4\n"; CompileSuccessfully(GenerateKernelCode(ss.str(), "", "Physical64")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, VLoadNSuccessIntPhysical64) { std::ostringstream ss; ss << "%ptr = OpAccessChain %u32_ptr_uniform_constant " "%u32vec8_uniform_constant %u32_1\n"; ss << "%val1 = OpExtInst %u32vec2 %extinst vloadn %u64_1 %ptr 2\n"; ss << "%val2 = OpExtInst %u32vec3 %extinst vloadn %u64_1 %ptr 3\n"; ss << "%val3 = OpExtInst %u32vec4 %extinst vloadn %u64_1 %ptr 4\n"; CompileSuccessfully(GenerateKernelCode(ss.str(), "", "Physical64")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, VLoadNWrongResultType) { std::ostringstream ss; ss << "%ptr = OpAccessChain %f32_ptr_uniform_constant " "%f32vec8_uniform_constant %u32_1\n"; ss << "%val1 = OpExtInst %f32 %extinst vloadn %u32_1 %ptr 2\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std vloadn: " "expected Result Type to be an int or float vector type")); } TEST_F(ValidateExtInst, VLoadNAddressingModelLogical) { std::ostringstream ss; ss << "%ptr = OpAccessChain %f32_ptr_uniform_constant " "%f32vec8_uniform_constant %u32_1\n"; ss << "%val1 = OpExtInst %f32vec2 %extinst vloadn %u32_1 %ptr 2\n"; CompileSuccessfully(GenerateKernelCode(ss.str(), "", "Logical")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std vloadn can only be used with physical " "addressing models")); } TEST_F(ValidateExtInst, VLoadNOffsetNotSizeT) { std::ostringstream ss; ss << "%ptr = OpAccessChain %f32_ptr_uniform_constant " "%f32vec8_uniform_constant %u32_1\n"; ss << "%val1 = OpExtInst %f32vec2 %extinst vloadn %u64_1 %ptr 2\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpenCL.std vloadn: expected operand Offset to be of type size_t " "(32-bit integer for the addressing model used in the module)")); } TEST_F(ValidateExtInst, VLoadNPNotPointer) { std::ostringstream ss; ss << "%val1 = OpExtInst %f32vec2 %extinst vloadn %u32_1 " "%f32_ptr_uniform_constant 2\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Operand '120[%_ptr_UniformConstant_float]' cannot be a " "type")); } TEST_F(ValidateExtInst, VLoadNWrongStorageClass) { std::ostringstream ss; ss << "%ptr = OpAccessChain %u32_ptr_input %u32vec8_input %u32_1\n"; ss << "%val1 = OpExtInst %u32vec2 %extinst vloadn %u32_1 %ptr 2\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std vloadn: expected operand P storage class " "to be UniformConstant, Generic, CrossWorkgroup, " "Workgroup or Function")); } TEST_F(ValidateExtInst, VLoadNWrongComponentType) { std::ostringstream ss; ss << "%ptr = OpAccessChain %f32_ptr_uniform_constant " "%f32vec8_uniform_constant %u32_1\n"; ss << "%val1 = OpExtInst %u32vec2 %extinst vloadn %u32_1 %ptr 2\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std vloadn: expected operand P data type to be " "equal to component type of Result Type")); } TEST_F(ValidateExtInst, VLoadNWrongN) { std::ostringstream ss; ss << "%ptr = OpAccessChain %f32_ptr_uniform_constant " "%f32vec8_uniform_constant %u32_1\n"; ss << "%val1 = OpExtInst %f32vec2 %extinst vloadn %u32_1 %ptr 3\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std vloadn: expected literal N to be equal to " "the number of components of Result Type")); } TEST_F(ValidateExtInst, VLoadHalfSuccessPhysical32) { std::ostringstream ss; ss << "%ptr = OpAccessChain %f16_ptr_uniform_constant " "%f16vec8_uniform_constant %u32_1\n"; ss << "%val1 = OpExtInst %f32 %extinst vload_half %u32_1 %ptr\n"; ss << "%val2 = OpExtInst %f64 %extinst vload_half %u32_1 %ptr\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, VLoadHalfSuccessPhysical64) { std::ostringstream ss; ss << "%ptr = OpAccessChain %f16_ptr_uniform_constant " "%f16vec8_uniform_constant %u32_1\n"; ss << "%val1 = OpExtInst %f32 %extinst vload_half %u64_1 %ptr\n"; ss << "%val2 = OpExtInst %f64 %extinst vload_half %u64_1 %ptr\n"; CompileSuccessfully(GenerateKernelCode(ss.str(), "", "Physical64")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, VLoadHalfWrongResultType) { std::ostringstream ss; ss << "%ptr = OpAccessChain %f16_ptr_uniform_constant " "%f16vec8_uniform_constant %u32_1\n"; ss << "%val1 = OpExtInst %u32 %extinst vload_half %u32_1 %ptr\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std vload_half: " "expected Result Type to be a float scalar type")); } TEST_F(ValidateExtInst, VLoadHalfAddressingModelLogical) { std::ostringstream ss; ss << "%ptr = OpAccessChain %f16_ptr_uniform_constant " "%f16vec8_uniform_constant %u32_1\n"; ss << "%val1 = OpExtInst %f32 %extinst vload_half %u32_1 %ptr\n"; CompileSuccessfully(GenerateKernelCode(ss.str(), "", "Logical")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std vload_half can only be used with physical " "addressing models")); } TEST_F(ValidateExtInst, VLoadHalfOffsetNotSizeT) { std::ostringstream ss; ss << "%ptr = OpAccessChain %f16_ptr_uniform_constant " "%f16vec8_uniform_constant %u32_1\n"; ss << "%val1 = OpExtInst %f32 %extinst vload_half %u64_1 %ptr\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpenCL.std vload_half: expected operand Offset to be of type size_t " "(32-bit integer for the addressing model used in the module)")); } TEST_F(ValidateExtInst, VLoadHalfPNotPointer) { std::ostringstream ss; ss << "%val1 = OpExtInst %f32 %extinst vload_half %u32_1 " "%f16_ptr_uniform_constant\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Operand '114[%_ptr_UniformConstant_half]' cannot be a " "type")); } TEST_F(ValidateExtInst, VLoadHalfWrongStorageClass) { std::ostringstream ss; ss << "%ptr = OpAccessChain %f16_ptr_input %f16vec8_input %u32_1\n"; ss << "%val1 = OpExtInst %f32 %extinst vload_half %u32_1 %ptr\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpenCL.std vload_half: expected operand P storage class to be " "UniformConstant, Generic, CrossWorkgroup, Workgroup or Function")); } TEST_F(ValidateExtInst, VLoadHalfPDataTypeInt) { std::ostringstream ss; ss << "%ptr = OpAccessChain %u32_ptr_uniform_constant " "%u32vec8_uniform_constant %u32_1\n"; ss << "%val1 = OpExtInst %f32 %extinst vload_half %u32_1 %ptr\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std vload_half: expected operand P data type " "to be 16-bit float scalar")); } TEST_F(ValidateExtInst, VLoadHalfPDataTypeFloat32) { std::ostringstream ss; ss << "%ptr = OpAccessChain %f32_ptr_uniform_constant " "%f32vec8_uniform_constant %u32_1\n"; ss << "%val1 = OpExtInst %f32 %extinst vload_half %u32_1 %ptr\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std vload_half: expected operand P data type " "to be 16-bit float scalar")); } TEST_F(ValidateExtInst, VStoreNSuccessFloatPhysical32) { std::ostringstream ss; ss << "%ptr_w = OpAccessChain %f32_ptr_workgroup %f32vec8_workgroup %u32_1\n"; ss << "%ptr_g = OpPtrCastToGeneric %f32_ptr_generic %ptr_w\n"; ss << "%val1 = OpExtInst %void %extinst vstoren %f32vec2_01 %u32_1 %ptr_g\n"; ss << "%val2 = OpExtInst %void %extinst vstoren %f32vec4_0123 %u32_1 " "%ptr_g\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, VStoreNSuccessFloatPhysical64) { std::ostringstream ss; ss << "%ptr_w = OpAccessChain %f32_ptr_workgroup %f32vec8_workgroup %u32_1\n"; ss << "%ptr_g = OpPtrCastToGeneric %f32_ptr_generic %ptr_w\n"; ss << "%val1 = OpExtInst %void %extinst vstoren %f32vec2_01 %u64_1 %ptr_g\n"; ss << "%val2 = OpExtInst %void %extinst vstoren %f32vec4_0123 %u64_1 " "%ptr_g\n"; CompileSuccessfully(GenerateKernelCode(ss.str(), "", "Physical64")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, VStoreNSuccessIntPhysical32) { std::ostringstream ss; ss << "%ptr_w = OpAccessChain %u32_ptr_workgroup %u32vec8_workgroup %u32_1\n"; ss << "%ptr_g = OpPtrCastToGeneric %u32_ptr_generic %ptr_w\n"; ss << "%val1 = OpExtInst %void %extinst vstoren %u32vec2_01 %u32_1 %ptr_g\n"; ss << "%val2 = OpExtInst %void %extinst vstoren %u32vec4_0123 %u32_1 " "%ptr_g\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, VStoreNSuccessIntPhysical64) { std::ostringstream ss; ss << "%ptr_w = OpAccessChain %u32_ptr_workgroup %u32vec8_workgroup %u32_1\n"; ss << "%ptr_g = OpPtrCastToGeneric %u32_ptr_generic %ptr_w\n"; ss << "%val1 = OpExtInst %void %extinst vstoren %u32vec2_01 %u64_1 %ptr_g\n"; ss << "%val2 = OpExtInst %void %extinst vstoren %u32vec4_0123 %u64_1 " "%ptr_g\n"; CompileSuccessfully(GenerateKernelCode(ss.str(), "", "Physical64")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, VStoreNResultTypeNotVoid) { std::ostringstream ss; ss << "%ptr_w = OpAccessChain %f32_ptr_workgroup %f32vec8_workgroup %u32_1\n"; ss << "%ptr_g = OpPtrCastToGeneric %f32_ptr_generic %ptr_w\n"; ss << "%val1 = OpExtInst %f32 %extinst vstoren %f32vec2_01 %u32_1 %ptr_g\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std vstoren: expected Result Type to be void")); } TEST_F(ValidateExtInst, VStoreNDataWrongType) { std::ostringstream ss; ss << "%ptr_w = OpAccessChain %f32_ptr_workgroup %f32vec8_workgroup %u32_1\n"; ss << "%ptr_g = OpPtrCastToGeneric %f32_ptr_generic %ptr_w\n"; ss << "%val1 = OpExtInst %void %extinst vstoren %f32_1 %u32_1 %ptr_g\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpenCL.std vstoren: expected Data to be an int or float vector")); } TEST_F(ValidateExtInst, VStoreNAddressingModelLogical) { std::ostringstream ss; ss << "%ptr_w = OpAccessChain %f32_ptr_workgroup %f32vec8_workgroup %u32_1\n"; ss << "%ptr_g = OpPtrCastToGeneric %f32_ptr_generic %ptr_w\n"; ss << "%val1 = OpExtInst %void %extinst vstoren %f32vec2_01 %u32_1 %ptr_g\n"; CompileSuccessfully(GenerateKernelCode(ss.str(), "", "Logical")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std vstoren can only be used with physical " "addressing models")); } TEST_F(ValidateExtInst, VStoreNOffsetNotSizeT) { std::ostringstream ss; ss << "%ptr_w = OpAccessChain %f32_ptr_workgroup %f32vec8_workgroup %u32_1\n"; ss << "%ptr_g = OpPtrCastToGeneric %f32_ptr_generic %ptr_w\n"; ss << "%val1 = OpExtInst %void %extinst vstoren %f32vec2_01 %u32_1 %ptr_g\n"; CompileSuccessfully(GenerateKernelCode(ss.str(), "", "Physical64")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpenCL.std vstoren: expected operand Offset to be of type size_t " "(64-bit integer for the addressing model used in the module)")); } TEST_F(ValidateExtInst, VStoreNPNotPointer) { std::ostringstream ss; ss << "%val1 = OpExtInst %void %extinst vstoren %f32vec2_01 %u32_1 " "%f32_ptr_generic\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Operand '127[%_ptr_Generic_float]' cannot be a type")); } TEST_F(ValidateExtInst, VStoreNWrongStorageClass) { std::ostringstream ss; ss << "%ptr_w = OpAccessChain %f32_ptr_uniform_constant " "%f32vec8_uniform_constant %u32_1\n"; ss << "%val1 = OpExtInst %void %extinst vstoren %f32vec2_01 %u32_1 %ptr_w\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std vstoren: expected operand P storage class " "to be Generic, CrossWorkgroup, Workgroup or Function")); } TEST_F(ValidateExtInst, VStorePWrongDataType) { std::ostringstream ss; ss << "%ptr_w = OpAccessChain %f32_ptr_workgroup %f32vec8_workgroup %u32_1\n"; ss << "%ptr_g = OpPtrCastToGeneric %f32_ptr_generic %ptr_w\n"; ss << "%val1 = OpExtInst %void %extinst vstoren %u32vec2_01 %u32_1 %ptr_g\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std vstoren: expected operand P data type to " "be equal to the type of operand Data components")); } TEST_F(ValidateExtInst, OpenCLStdShuffleSuccess) { const std::string body = R"( %val1 = OpExtInst %f32vec2 %extinst shuffle %f32vec4_0123 %u32vec2_01 %val2 = OpExtInst %f32vec4 %extinst shuffle %f32vec4_0123 %u32vec4_0123 %val3 = OpExtInst %u32vec2 %extinst shuffle %u32vec4_0123 %u32vec2_01 %val4 = OpExtInst %u32vec4 %extinst shuffle %u32vec4_0123 %u32vec4_0123 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, OpenCLStdShuffleWrongResultType) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst shuffle %f32vec4_0123 %u32vec2_01 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std shuffle: " "expected Result Type to be an int or float vector type")); } TEST_F(ValidateExtInst, OpenCLStdShuffleResultTypeInvalidNumComponents) { const std::string body = R"( %val1 = OpExtInst %f32vec3 %extinst shuffle %f32vec4_0123 %u32vec3_012 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std shuffle: " "expected Result Type to have 2, 4, 8 or 16 components")); } TEST_F(ValidateExtInst, OpenCLStdShuffleXWrongType) { const std::string body = R"( %val1 = OpExtInst %f32vec2 %extinst shuffle %f32_0 %u32vec2_01 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std shuffle: " "expected operand X to be an int or float vector")); } TEST_F(ValidateExtInst, OpenCLStdShuffleXInvalidNumComponents) { const std::string body = R"( %val1 = OpExtInst %f32vec2 %extinst shuffle %f32vec3_012 %u32vec2_01 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std shuffle: " "expected operand X to have 2, 4, 8 or 16 components")); } TEST_F(ValidateExtInst, OpenCLStdShuffleXInvalidComponentType) { const std::string body = R"( %val1 = OpExtInst %f32vec2 %extinst shuffle %f64vec4_0123 %u32vec2_01 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpenCL.std shuffle: " "expected operand X and Result Type to have equal component types")); } TEST_F(ValidateExtInst, OpenCLStdShuffleShuffleMaskNotIntVector) { const std::string body = R"( %val1 = OpExtInst %f32vec2 %extinst shuffle %f32vec4_0123 %f32vec2_01 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std shuffle: " "expected operand Shuffle Mask to be an int vector")); } TEST_F(ValidateExtInst, OpenCLStdShuffleShuffleMaskInvalidNumComponents) { const std::string body = R"( %val1 = OpExtInst %f32vec4 %extinst shuffle %f32vec4_0123 %u32vec2_01 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std shuffle: " "expected operand Shuffle Mask to have the same number " "of components as Result Type")); } TEST_F(ValidateExtInst, OpenCLStdShuffleShuffleMaskInvalidBitWidth) { const std::string body = R"( %val1 = OpExtInst %f64vec2 %extinst shuffle %f64vec4_0123 %u32vec2_01 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std shuffle: " "expected operand Shuffle Mask components to have the " "same bit width as Result Type components")); } TEST_F(ValidateExtInst, OpenCLStdShuffle2Success) { const std::string body = R"( %val1 = OpExtInst %f32vec2 %extinst shuffle2 %f32vec4_0123 %f32vec4_0123 %u32vec2_01 %val2 = OpExtInst %f32vec4 %extinst shuffle2 %f32vec4_0123 %f32vec4_0123 %u32vec4_0123 %val3 = OpExtInst %u32vec2 %extinst shuffle2 %u32vec4_0123 %u32vec4_0123 %u32vec2_01 %val4 = OpExtInst %u32vec4 %extinst shuffle2 %u32vec4_0123 %u32vec4_0123 %u32vec4_0123 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, OpenCLStdShuffle2WrongResultType) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst shuffle2 %f32vec4_0123 %f32vec4_0123 %u32vec2_01 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std shuffle2: " "expected Result Type to be an int or float vector type")); } TEST_F(ValidateExtInst, OpenCLStdShuffle2ResultTypeInvalidNumComponents) { const std::string body = R"( %val1 = OpExtInst %f32vec3 %extinst shuffle2 %f32vec4_0123 %f32vec4_0123 %u32vec3_012 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std shuffle2: " "expected Result Type to have 2, 4, 8 or 16 components")); } TEST_F(ValidateExtInst, OpenCLStdShuffle2XWrongType) { const std::string body = R"( %val1 = OpExtInst %f32vec2 %extinst shuffle2 %f32_0 %f32_0 %u32vec2_01 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std shuffle2: " "expected operand X to be an int or float vector")); } TEST_F(ValidateExtInst, OpenCLStdShuffle2YTypeDifferentFromX) { const std::string body = R"( %val1 = OpExtInst %f32vec2 %extinst shuffle2 %f32vec2_01 %f32vec4_0123 %u32vec2_01 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std shuffle2: " "expected operands X and Y to be of the same type")); } TEST_F(ValidateExtInst, OpenCLStdShuffle2XInvalidNumComponents) { const std::string body = R"( %val1 = OpExtInst %f32vec2 %extinst shuffle2 %f32vec3_012 %f32vec3_012 %u32vec2_01 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std shuffle2: " "expected operand X to have 2, 4, 8 or 16 components")); } TEST_F(ValidateExtInst, OpenCLStdShuffle2XInvalidComponentType) { const std::string body = R"( %val1 = OpExtInst %f32vec2 %extinst shuffle2 %f64vec4_0123 %f64vec4_0123 %u32vec2_01 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpenCL.std shuffle2: " "expected operand X and Result Type to have equal component types")); } TEST_F(ValidateExtInst, OpenCLStdShuffle2ShuffleMaskNotIntVector) { const std::string body = R"( %val1 = OpExtInst %f32vec2 %extinst shuffle2 %f32vec4_0123 %f32vec4_0123 %f32vec2_01 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std shuffle2: " "expected operand Shuffle Mask to be an int vector")); } TEST_F(ValidateExtInst, OpenCLStdShuffle2ShuffleMaskInvalidNumComponents) { const std::string body = R"( %val1 = OpExtInst %f32vec4 %extinst shuffle2 %f32vec4_0123 %f32vec4_0123 %u32vec2_01 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std shuffle2: " "expected operand Shuffle Mask to have the same number " "of components as Result Type")); } TEST_F(ValidateExtInst, OpenCLStdShuffle2ShuffleMaskInvalidBitWidth) { const std::string body = R"( %val1 = OpExtInst %f64vec2 %extinst shuffle2 %f64vec4_0123 %f64vec4_0123 %u32vec2_01 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std shuffle2: " "expected operand Shuffle Mask components to have the " "same bit width as Result Type components")); } TEST_F(ValidateExtInst, OpenCLStdPrintfSuccess) { const std::string body = R"( %format = OpAccessChain %u8_ptr_uniform_constant %u8arr_uniform_constant %u32_0 %val1 = OpExtInst %u32 %extinst printf %format %u32_0 %u32_1 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, OpenCLStdPrintfBoolResultType) { const std::string body = R"( %format = OpAccessChain %u8_ptr_uniform_constant %u8arr_uniform_constant %u32_0 %val1 = OpExtInst %bool %extinst printf %format %u32_0 %u32_1 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpenCL.std printf: expected Result Type to be a 32-bit int type")); } TEST_F(ValidateExtInst, OpenCLStdPrintfU64ResultType) { const std::string body = R"( %format = OpAccessChain %u8_ptr_uniform_constant %u8arr_uniform_constant %u32_0 %val1 = OpExtInst %u64 %extinst printf %format %u32_0 %u32_1 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpenCL.std printf: expected Result Type to be a 32-bit int type")); } TEST_F(ValidateExtInst, OpenCLStdPrintfFormatNotPointer) { const std::string body = R"( %val1 = OpExtInst %u32 %extinst printf %u8_ptr_uniform_constant %u32_0 %u32_1 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Operand '137[%_ptr_UniformConstant_uchar]' cannot be a " "type")); } TEST_F(ValidateExtInst, OpenCLStdPrintfFormatNotUniformConstStorageClass) { const std::string body = R"( %format_const = OpAccessChain %u8_ptr_uniform_constant %u8arr_uniform_constant %u32_0 %format = OpBitcast %u8_ptr_generic %format_const %val1 = OpExtInst %u32 %extinst printf %format %u32_0 %u32_1 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std printf: expected Format storage class to " "be UniformConstant")); } TEST_F(ValidateExtInst, OpenCLStdPrintfFormatWithExtensionNotAllowedStorageClass) { const std::string body = R"( %format_const = OpAccessChain %u8_ptr_uniform_constant %u8arr_uniform_constant %u32_0 %format = OpBitcast %u8_ptr_input %format_const %val1 = OpExtInst %u32 %extinst printf %format %u32_0 %u32_1 )"; const std::string extension = R"( OpExtension "SPV_EXT_relaxed_printf_string_address_space" )"; CompileSuccessfully(GenerateKernelCode(body, extension)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std printf: expected Format storage class to " "be UniformConstant, Crossworkgroup, Workgroup, " "Function, or Generic")); } TEST_F(ValidateExtInst, OpenCLStdPrintfFormatNotU8Pointer) { const std::string body = R"( %format = OpAccessChain %u32_ptr_uniform_constant %u32vec8_uniform_constant %u32_0 %val1 = OpExtInst %u32 %extinst printf %format %u32_0 %u32_1 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpenCL.std printf: expected Format data type to be 8-bit int")); } TEST_F(ValidateExtInst, OpenCLStdPrefetchU32Success) { const std::string body = R"( %ptr = OpAccessChain %u32_ptr_cross_workgroup %u32arr_cross_workgroup %u32_0 %val1 = OpExtInst %void %extinst prefetch %ptr %u32_256 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, OpenCLStdPrefetchU32Physical64Success) { const std::string body = R"( %ptr = OpAccessChain %u32_ptr_cross_workgroup %u32arr_cross_workgroup %u32_0 %val1 = OpExtInst %void %extinst prefetch %ptr %u64_256 )"; CompileSuccessfully(GenerateKernelCode(body, "", "Physical64")); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, OpenCLStdPrefetchF32Success) { const std::string body = R"( %ptr = OpAccessChain %f32_ptr_cross_workgroup %f32arr_cross_workgroup %u32_0 %val1 = OpExtInst %void %extinst prefetch %ptr %u32_256 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, OpenCLStdPrefetchF32Vec2Success) { const std::string body = R"( %ptr = OpAccessChain %f32vec2_ptr_cross_workgroup %f32vec2arr_cross_workgroup %u32_0 %val1 = OpExtInst %void %extinst prefetch %ptr %u32_256 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, OpenCLStdPrefetchResultTypeNotVoid) { const std::string body = R"( %ptr = OpAccessChain %u32_ptr_cross_workgroup %u32arr_cross_workgroup %u32_0 %val1 = OpExtInst %u32 %extinst prefetch %ptr %u32_256 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std prefetch: expected Result Type to be void")); } TEST_F(ValidateExtInst, OpenCLStdPrefetchPtrNotPointer) { const std::string body = R"( %val1 = OpExtInst %void %extinst prefetch %u32_ptr_cross_workgroup %u32_256 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Operand '99[%_ptr_CrossWorkgroup_uint]' cannot be a " "type")); } TEST_F(ValidateExtInst, OpenCLStdPrefetchPtrNotCrossWorkgroup) { const std::string body = R"( %ptr = OpAccessChain %u8_ptr_uniform_constant %u8arr_uniform_constant %u32_0 %val1 = OpExtInst %void %extinst prefetch %ptr %u32_256 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std prefetch: expected operand Ptr storage " "class to be CrossWorkgroup")); } TEST_F(ValidateExtInst, OpenCLStdPrefetchInvalidDataType) { const std::string body = R"( %ptr = OpAccessChain %struct_ptr_cross_workgroup %struct_arr_cross_workgroup %u32_0 %val1 = OpExtInst %void %extinst prefetch %ptr %u32_256 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std prefetch: expected Ptr data type to be int " "or float scalar or vector")); } TEST_F(ValidateExtInst, OpenCLStdPrefetchAddressingModelLogical) { const std::string body = R"( %ptr = OpAccessChain %u32_ptr_cross_workgroup %u32arr_cross_workgroup %u32_0 %val1 = OpExtInst %void %extinst prefetch %ptr %u32_256 )"; CompileSuccessfully(GenerateKernelCode(body, "", "Logical")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std prefetch can only be used with physical " "addressing models")); } TEST_F(ValidateExtInst, OpenCLStdPrefetchNumElementsNotSizeT) { const std::string body = R"( %ptr = OpAccessChain %f32_ptr_cross_workgroup %f32arr_cross_workgroup %u32_0 %val1 = OpExtInst %void %extinst prefetch %ptr %u32_256 )"; CompileSuccessfully(GenerateKernelCode(body, "", "Physical64")); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std prefetch: expected operand Num Elements to " "be of type size_t (64-bit integer for the addressing " "model used in the module)")); } TEST_P(ValidateOpenCLStdFractLike, Success) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%var_f32 = OpVariable %f32_ptr_function Function\n"; ss << "%var_f32vec2 = OpVariable %f32vec2_ptr_function Function\n"; ss << "%val1 = OpExtInst %f32 %extinst " << ext_inst_name << " %f32_0 %var_f32\n"; ss << "%val2 = OpExtInst %f32vec2 %extinst " << ext_inst_name << " %f32vec2_01 %var_f32vec2\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateOpenCLStdFractLike, IntResultType) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%var_f32 = OpVariable %f32_ptr_function Function\n"; ss << "%val1 = OpExtInst %u32 %extinst " << ext_inst_name << " %f32_0 %var_f32\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected Result Type to be a float scalar or vector type")); } TEST_P(ValidateOpenCLStdFractLike, XWrongType) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%var_f32 = OpVariable %f32_ptr_function Function\n"; ss << "%val1 = OpExtInst %f32 %extinst " << ext_inst_name << " %f64_0 %var_f32\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected type of operand X to be equal to Result Type")); } TEST_P(ValidateOpenCLStdFractLike, NotPointer) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%var_f32 = OpVariable %f32_ptr_function Function\n"; ss << "%val1 = OpExtInst %f32 %extinst " << ext_inst_name << " %f32_0 %f32_1\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected the last operand to be a pointer")); } TEST_P(ValidateOpenCLStdFractLike, PointerInvalidStorageClass) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%ptr = OpAccessChain %f32_ptr_uniform_constant " "%f32vec8_uniform_constant %u32_1\n"; ss << "%val1 = OpExtInst %f32 %extinst " << ext_inst_name << " %f32_0 %ptr\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected storage class of the pointer to be " "Generic, CrossWorkgroup, Workgroup or Function")); } TEST_P(ValidateOpenCLStdFractLike, PointerWrongDataType) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%var_u32 = OpVariable %u32_ptr_function Function\n"; ss << "%val1 = OpExtInst %f32 %extinst " << ext_inst_name << " %f32_0 %var_u32\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpenCL.std " + ext_inst_name + ": expected data type of the pointer to be equal to Result Type")); } INSTANTIATE_TEST_SUITE_P(AllFractLike, ValidateOpenCLStdFractLike, ::testing::ValuesIn(std::vector{ "fract", "modf", "sincos", })); TEST_F(ValidateExtInst, OpenCLStdRemquoSuccess) { const std::string body = R"( %var_u32 = OpVariable %u32_ptr_function Function %var_u32vec2 = OpVariable %u32vec2_ptr_function Function %val1 = OpExtInst %f32 %extinst remquo %f32_3 %f32_2 %var_u32 %val2 = OpExtInst %f32vec2 %extinst remquo %f32vec2_01 %f32vec2_12 %var_u32vec2 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, OpenCLStdRemquoIntResultType) { const std::string body = R"( %var_u32 = OpVariable %u32_ptr_function Function %val1 = OpExtInst %u32 %extinst remquo %f32_3 %f32_2 %var_u32 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std remquo: " "expected Result Type to be a float scalar or vector type")); } TEST_F(ValidateExtInst, OpenCLStdRemquoXWrongType) { const std::string body = R"( %var_u32 = OpVariable %f32_ptr_function Function %val1 = OpExtInst %f32 %extinst remquo %u32_3 %f32_2 %var_u32 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std remquo: " "expected type of operand X to be equal to Result Type")); } TEST_F(ValidateExtInst, OpenCLStdRemquoYWrongType) { const std::string body = R"( %var_u32 = OpVariable %f32_ptr_function Function %val1 = OpExtInst %f32 %extinst remquo %f32_3 %u32_2 %var_u32 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std remquo: " "expected type of operand Y to be equal to Result Type")); } TEST_F(ValidateExtInst, OpenCLStdRemquoNotPointer) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst remquo %f32_3 %f32_2 %f32_1 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std remquo: " "expected the last operand to be a pointer")); } TEST_F(ValidateExtInst, OpenCLStdRemquoPointerWrongStorageClass) { const std::string body = R"( %ptr = OpAccessChain %f32_ptr_uniform_constant %f32vec8_uniform_constant %u32_1 %val1 = OpExtInst %f32 %extinst remquo %f32_3 %f32_2 %ptr )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std remquo: " "expected storage class of the pointer to be Generic, " "CrossWorkgroup, Workgroup or Function")); } TEST_F(ValidateExtInst, OpenCLStdRemquoPointerWrongDataType) { const std::string body = R"( %var_f32 = OpVariable %f32_ptr_function Function %val1 = OpExtInst %f32 %extinst remquo %f32_3 %f32_2 %var_f32 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std remquo: " "expected data type of the pointer to be a 32-bit int " "scalar or vector type")); } TEST_F(ValidateExtInst, OpenCLStdRemquoPointerWrongDataTypeWidth) { const std::string body = R"( %var_u64 = OpVariable %u64_ptr_function Function %val1 = OpExtInst %f32 %extinst remquo %f32_3 %f32_2 %var_u64 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std remquo: " "expected data type of the pointer to be a 32-bit int " "scalar or vector type")); } TEST_F(ValidateExtInst, OpenCLStdRemquoPointerWrongNumberOfComponents) { const std::string body = R"( %var_u32vec2 = OpVariable %u32vec2_ptr_function Function %val1 = OpExtInst %f32 %extinst remquo %f32_3 %f32_2 %var_u32vec2 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std remquo: " "expected data type of the pointer to have the same number " "of components as Result Type")); } TEST_P(ValidateOpenCLStdFrexpLike, Success) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%var_u32 = OpVariable %u32_ptr_function Function\n"; ss << "%var_u32vec2 = OpVariable %u32vec2_ptr_function Function\n"; ss << "%val1 = OpExtInst %f32 %extinst " << ext_inst_name << " %f32_0 %var_u32\n"; ss << "%val2 = OpExtInst %f32vec2 %extinst " << ext_inst_name << " %f32vec2_01 %var_u32vec2\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateOpenCLStdFrexpLike, IntResultType) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%var_u32 = OpVariable %u32_ptr_function Function\n"; ss << "%val1 = OpExtInst %u32 %extinst " << ext_inst_name << " %f32_0 %var_u32\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected Result Type to be a float scalar or vector type")); } TEST_P(ValidateOpenCLStdFrexpLike, XWrongType) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%var_u32 = OpVariable %u32_ptr_function Function\n"; ss << "%val1 = OpExtInst %f32 %extinst " << ext_inst_name << " %f64_0 %var_u32\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected type of operand X to be equal to Result Type")); } TEST_P(ValidateOpenCLStdFrexpLike, NotPointer) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%val1 = OpExtInst %f32 %extinst " << ext_inst_name << " %f32_0 %u32_1\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected the last operand to be a pointer")); } TEST_P(ValidateOpenCLStdFrexpLike, PointerInvalidStorageClass) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%ptr = OpAccessChain %f32_ptr_uniform_constant " "%f32vec8_uniform_constant %u32_1\n"; ss << "%val1 = OpExtInst %f32 %extinst " << ext_inst_name << " %f32_0 %ptr\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected storage class of the pointer to be " "Generic, CrossWorkgroup, Workgroup or Function")); } TEST_P(ValidateOpenCLStdFrexpLike, PointerDataTypeFloat) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%var_f32 = OpVariable %f32_ptr_function Function\n"; ss << "%val1 = OpExtInst %f32 %extinst " << ext_inst_name << " %f32_0 %var_f32\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected data type of the pointer to be a 32-bit " "int scalar or vector type")); } TEST_P(ValidateOpenCLStdFrexpLike, PointerDataTypeU64) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%var_u64 = OpVariable %u64_ptr_function Function\n"; ss << "%val1 = OpExtInst %f32 %extinst " << ext_inst_name << " %f32_0 %var_u64\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected data type of the pointer to be a 32-bit " "int scalar or vector type")); } TEST_P(ValidateOpenCLStdFrexpLike, PointerDataTypeDiffSize) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%var_u32 = OpVariable %u32_ptr_function Function\n"; ss << "%val1 = OpExtInst %f32vec2 %extinst " << ext_inst_name << " %f32vec2_01 %var_u32\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected data type of the pointer to have the same " "number of components as Result Type")); } INSTANTIATE_TEST_SUITE_P(AllFrexpLike, ValidateOpenCLStdFrexpLike, ::testing::ValuesIn(std::vector{ "frexp", "lgamma_r", })); TEST_F(ValidateExtInst, OpenCLStdIlogbSuccess) { const std::string body = R"( %val1 = OpExtInst %u32 %extinst ilogb %f32_3 %val2 = OpExtInst %u32vec2 %extinst ilogb %f32vec2_12 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, OpenCLStdIlogbFloatResultType) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst ilogb %f32_3 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpenCL.std ilogb: " "expected Result Type to be a 32-bit int scalar or vector type")); } TEST_F(ValidateExtInst, OpenCLStdIlogbIntX) { const std::string body = R"( %val1 = OpExtInst %u32 %extinst ilogb %u32_3 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std ilogb: " "expected operand X to be a float scalar or vector")); } TEST_F(ValidateExtInst, OpenCLStdIlogbDiffSize) { const std::string body = R"( %val2 = OpExtInst %u32vec2 %extinst ilogb %f32_1 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std ilogb: " "expected operand X to have the same number of " "components as Result Type")); } TEST_F(ValidateExtInst, OpenCLStdNanSuccess) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst nan %u32_3 %val2 = OpExtInst %f32vec2 %extinst nan %u32vec2_12 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtInst, OpenCLStdNanIntResultType) { const std::string body = R"( %val1 = OpExtInst %u32 %extinst nan %u32_3 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std nan: " "expected Result Type to be a float scalar or vector type")); } TEST_F(ValidateExtInst, OpenCLStdNanFloatNancode) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst nan %f32_3 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std nan: " "expected Nancode to be an int scalar or vector type")); } TEST_F(ValidateExtInst, OpenCLStdNanFloatDiffSize) { const std::string body = R"( %val1 = OpExtInst %f32 %extinst nan %u32vec2_12 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std nan: " "expected Nancode to have the same number of " "components as Result Type")); } TEST_F(ValidateExtInst, OpenCLStdNanFloatDiffBitWidth) { const std::string body = R"( %val1 = OpExtInst %f64 %extinst nan %u32_2 )"; CompileSuccessfully(GenerateKernelCode(body)); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std nan: " "expected Nancode to have the same bit width as Result Type")); } TEST_P(ValidateOpenCLStdLdexpLike, Success) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%val1 = OpExtInst %f32 %extinst " << ext_inst_name << " %f32_0 %u32_1\n"; ss << "%val2 = OpExtInst %f32vec2 %extinst " << ext_inst_name << " %f32vec2_12 %u32vec2_12\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateOpenCLStdLdexpLike, IntResultType) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%val1 = OpExtInst %u32 %extinst " << ext_inst_name << " %f32_0 %u32_1\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected Result Type to be a float scalar or vector type")); } TEST_P(ValidateOpenCLStdLdexpLike, XWrongType) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%val1 = OpExtInst %f32 %extinst " << ext_inst_name << " %u32_0 %u32_1\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected type of operand X to be equal to Result Type")); } TEST_P(ValidateOpenCLStdLdexpLike, ExponentNotInt) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%val1 = OpExtInst %f32 %extinst " << ext_inst_name << " %f32_0 %f32_1\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected the exponent to be a 32-bit int scalar or vector")); } TEST_P(ValidateOpenCLStdLdexpLike, ExponentNotInt32) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%val1 = OpExtInst %f32 %extinst " << ext_inst_name << " %f32_0 %u64_1\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected the exponent to be a 32-bit int scalar or vector")); } TEST_P(ValidateOpenCLStdLdexpLike, ExponentWrongSize) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%val1 = OpExtInst %f32 %extinst " << ext_inst_name << " %f32_0 %u32vec2_01\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected the exponent to have the same number of " "components as Result Type")); } INSTANTIATE_TEST_SUITE_P(AllLdexpLike, ValidateOpenCLStdLdexpLike, ::testing::ValuesIn(std::vector{ "ldexp", "pown", "rootn", })); TEST_P(ValidateOpenCLStdUpsampleLike, Success) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%val1 = OpExtInst %u16 %extinst " << ext_inst_name << " %u8_1 %u8_2\n"; ss << "%val2 = OpExtInst %u32 %extinst " << ext_inst_name << " %u16_1 %u16_2\n"; ss << "%val3 = OpExtInst %u64 %extinst " << ext_inst_name << " %u32_1 %u32_2\n"; ss << "%val4 = OpExtInst %u64vec2 %extinst " << ext_inst_name << " %u32vec2_01 %u32vec2_01\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateOpenCLStdUpsampleLike, FloatResultType) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%val1 = OpExtInst %f64 %extinst " << ext_inst_name << " %u32_1 %u32_2\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected Result Type to be an int scalar or vector type")); } TEST_P(ValidateOpenCLStdUpsampleLike, InvalidResultTypeBitWidth) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%val1 = OpExtInst %u8 %extinst " << ext_inst_name << " %u8_1 %u8_2\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpenCL.std " + ext_inst_name + ": expected bit width of Result Type components to be 16, 32 or 64")); } TEST_P(ValidateOpenCLStdUpsampleLike, LoHiDiffType) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%val1 = OpExtInst %u64 %extinst " << ext_inst_name << " %u32_1 %u16_2\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected Hi and Lo operands to have the same type")); } TEST_P(ValidateOpenCLStdUpsampleLike, DiffNumberOfComponents) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%val1 = OpExtInst %u64vec2 %extinst " << ext_inst_name << " %u32_1 %u32_2\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected Hi and Lo operands to have the same number " "of components as Result Type")); } TEST_P(ValidateOpenCLStdUpsampleLike, HiLoWrongBitWidth) { const std::string ext_inst_name = GetParam(); std::ostringstream ss; ss << "%val1 = OpExtInst %u64 %extinst " << ext_inst_name << " %u16_1 %u16_2\n"; CompileSuccessfully(GenerateKernelCode(ss.str())); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpenCL.std " + ext_inst_name + ": expected bit width of components of Hi and Lo operands to " "be half of the bit width of components of Result Type")); } INSTANTIATE_TEST_SUITE_P(AllUpsampleLike, ValidateOpenCLStdUpsampleLike, ::testing::ValuesIn(std::vector{ "u_upsample", "s_upsample", })); TEST_F(ValidateClspvReflection, RequiresNonSemanticExtension) { const std::string text = R"( OpCapability Shader OpCapability Linkage %1 = OpExtInstImport "NonSemantic.ClspvReflection.1" OpMemoryModel Logical GLSL450 )"; CompileSuccessfully(text); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("NonSemantic extended instruction sets cannot be " "declared without SPV_KHR_non_semantic_info")); } TEST_F(ValidateClspvReflection, DoesNotRequiresNonSemanticExtensionPost1p6) { const std::string text = R"( OpCapability Shader OpCapability Linkage %1 = OpExtInstImport "NonSemantic.ClspvReflection.1" OpMemoryModel Logical GLSL450 )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_6); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_6)); } TEST_F(ValidateClspvReflection, MissingVersion) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpExtension "SPV_KHR_non_semantic_info" %1 = OpExtInstImport "NonSemantic.ClspvReflection." OpMemoryModel Logical GLSL450 %2 = OpTypeVoid %3 = OpTypeInt 32 0 %4 = OpConstant %3 1 %5 = OpExtInst %2 %1 SpecConstantWorkDim %4 )"; CompileSuccessfully(text); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing NonSemantic.ClspvReflection import version")); } TEST_F(ValidateClspvReflection, BadVersion0) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpExtension "SPV_KHR_non_semantic_info" %1 = OpExtInstImport "NonSemantic.ClspvReflection.0" OpMemoryModel Logical GLSL450 %2 = OpTypeVoid %3 = OpTypeInt 32 0 %4 = OpConstant %3 1 %5 = OpExtInst %2 %1 SpecConstantWorkDim %4 )"; CompileSuccessfully(text); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Unknown NonSemantic.ClspvReflection import version")); } TEST_F(ValidateClspvReflection, BadVersionNotANumber) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpExtension "SPV_KHR_non_semantic_info" %1 = OpExtInstImport "NonSemantic.ClspvReflection.1a" OpMemoryModel Logical GLSL450 %2 = OpTypeVoid %3 = OpTypeInt 32 0 %4 = OpConstant %3 1 %5 = OpExtInst %2 %1 SpecConstantWorkDim %4 )"; CompileSuccessfully(text); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("NonSemantic.ClspvReflection import does not encode " "the version correctly")); } TEST_F(ValidateClspvReflection, Kernel) { const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %ext = OpExtInstImport "NonSemantic.ClspvReflection.1" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %foo "foo" OpExecutionMode %foo LocalSize 1 1 1 %foo_name = OpString "foo" %void = OpTypeVoid %void_fn = OpTypeFunction %void %foo = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd %decl = OpExtInst %void %ext Kernel %foo %foo_name )"; CompileSuccessfully(text); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateClspvReflection, KernelNotAFunction) { const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %ext = OpExtInstImport "NonSemantic.ClspvReflection.1" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %foo "foo" OpExecutionMode %foo LocalSize 1 1 1 %foo_name = OpString "foo" %void = OpTypeVoid %void_fn = OpTypeFunction %void %foo = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd %decl = OpExtInst %void %ext Kernel %foo_name %foo_name )"; CompileSuccessfully(text); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Kernel does not reference a function")); } TEST_F(ValidateClspvReflection, KernelNotAnEntryPoint) { const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %ext = OpExtInstImport "NonSemantic.ClspvReflection.1" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %foo "foo" OpExecutionMode %foo LocalSize 1 1 1 %foo_name = OpString "foo" %void = OpTypeVoid %void_fn = OpTypeFunction %void %foo = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd %bar = OpFunction %void None %void_fn %bar_entry = OpLabel OpReturn OpFunctionEnd %decl = OpExtInst %void %ext Kernel %bar %foo_name )"; CompileSuccessfully(text); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Kernel does not reference an entry-point")); } TEST_F(ValidateClspvReflection, KernelNotGLCompute) { const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %ext = OpExtInstImport "NonSemantic.ClspvReflection.1" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %foo "foo" OpExecutionMode %foo OriginUpperLeft %foo_name = OpString "foo" %void = OpTypeVoid %void_fn = OpTypeFunction %void %foo = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd %decl = OpExtInst %void %ext Kernel %foo %foo_name )"; CompileSuccessfully(text); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Kernel must refer only to GLCompute entry-points")); } TEST_F(ValidateClspvReflection, KernelNameMismatch) { const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %ext = OpExtInstImport "NonSemantic.ClspvReflection.1" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %foo "foo" OpExecutionMode %foo LocalSize 1 1 1 %foo_name = OpString "bar" %void = OpTypeVoid %void_fn = OpTypeFunction %void %foo = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd %decl = OpExtInst %void %ext Kernel %foo %foo_name )"; CompileSuccessfully(text); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Name must match an entry-point for Kernel")); } TEST_F(ValidateClspvReflection, KernelArgumentsVersionGood) { const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %ext = OpExtInstImport "NonSemantic.ClspvReflection.5" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %foo "foo" OpExecutionMode %foo LocalSize 1 1 1 %foo_name = OpString "foo" %void = OpTypeVoid %void_fn = OpTypeFunction %void %int = OpTypeInt 32 0 %int_1 = OpConstant %int 1 %foo = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd %decl = OpExtInst %void %ext Kernel %foo %foo_name %int_1 )"; CompileSuccessfully(text); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateClspvReflection, KernelArgumentsVersionBad) { const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %ext = OpExtInstImport "NonSemantic.ClspvReflection.4" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %foo "foo" OpExecutionMode %foo LocalSize 1 1 1 %foo_name = OpString "foo" %void = OpTypeVoid %void_fn = OpTypeFunction %void %int = OpTypeInt 32 0 %int_1 = OpConstant %int 1 %foo = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd %decl = OpExtInst %void %ext Kernel %foo %foo_name %int_1 )"; CompileSuccessfully(text); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Version 4 of the Kernel instruction can only have 2 " "additional operands")); } TEST_F(ValidateClspvReflection, KernelNumArgumentsNotInt) { const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %ext = OpExtInstImport "NonSemantic.ClspvReflection.5" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %foo "foo" OpExecutionMode %foo LocalSize 1 1 1 %foo_name = OpString "foo" %void = OpTypeVoid %void_fn = OpTypeFunction %void %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %foo = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd %decl = OpExtInst %void %ext Kernel %foo %foo_name %float_0 )"; CompileSuccessfully(text); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("NumArguments must be a 32-bit unsigned integer OpConstant")); } TEST_F(ValidateClspvReflection, KernelNumArgumentsNotConstant) { const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %ext = OpExtInstImport "NonSemantic.ClspvReflection.5" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %foo "foo" OpExecutionMode %foo LocalSize 1 1 1 %foo_name = OpString "foo" %void = OpTypeVoid %void_fn = OpTypeFunction %void %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %null = OpConstantNull %int %foo = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd %decl = OpExtInst %void %ext Kernel %foo %foo_name %null )"; CompileSuccessfully(text); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("NumArguments must be a 32-bit unsigned integer OpConstant")); } TEST_F(ValidateClspvReflection, KernelFlagsNotInt) { const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %ext = OpExtInstImport "NonSemantic.ClspvReflection.5" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %foo "foo" OpExecutionMode %foo LocalSize 1 1 1 %foo_name = OpString "foo" %void = OpTypeVoid %void_fn = OpTypeFunction %void %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %foo = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd %decl = OpExtInst %void %ext Kernel %foo %foo_name %int_0 %float_0 )"; CompileSuccessfully(text); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Flags must be a 32-bit unsigned integer OpConstant")); } TEST_F(ValidateClspvReflection, KernelFlagsNotConstant) { const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %ext = OpExtInstImport "NonSemantic.ClspvReflection.5" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %foo "foo" OpExecutionMode %foo LocalSize 1 1 1 %foo_name = OpString "foo" %void = OpTypeVoid %void_fn = OpTypeFunction %void %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %null = OpConstantNull %int %foo = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd %decl = OpExtInst %void %ext Kernel %foo %foo_name %int_0 %null )"; CompileSuccessfully(text); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Flags must be a 32-bit unsigned integer OpConstant")); } TEST_F(ValidateClspvReflection, KernelAttributesNotString) { const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %ext = OpExtInstImport "NonSemantic.ClspvReflection.5" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %foo "foo" OpExecutionMode %foo LocalSize 1 1 1 %foo_name = OpString "foo" %void = OpTypeVoid %void_fn = OpTypeFunction %void %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %foo = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd %decl = OpExtInst %void %ext Kernel %foo %foo_name %int_0 %int_0 %int_0 )"; CompileSuccessfully(text); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Attributes must be an OpString")); } using ArgumentBasics = spvtest::ValidateBase>; INSTANTIATE_TEST_SUITE_P( ValidateClspvReflectionArgumentKernel, ArgumentBasics, ::testing::ValuesIn(std::vector>{ std::make_pair("ArgumentStorageBuffer", "%int_0 %int_0"), std::make_pair("ArgumentUniform", "%int_0 %int_0"), std::make_pair("ArgumentPodStorageBuffer", "%int_0 %int_0 %int_0 %int_4"), std::make_pair("ArgumentPodUniform", "%int_0 %int_0 %int_0 %int_4"), std::make_pair("ArgumentPodPushConstant", "%int_0 %int_4"), std::make_pair("ArgumentSampledImage", "%int_0 %int_0"), std::make_pair("ArgumentStorageImage", "%int_0 %int_0"), std::make_pair("ArgumentSampler", "%int_0 %int_0"), std::make_pair("ArgumentWorkgroup", "%int_0 %int_0"), std::make_pair("ArgumentPointerPushConstant", "%int_0 %int_4"), std::make_pair("ArgumentPointerUniform", "%int_0 %int_0 %int_0 %int_4"), std::make_pair("ArgumentStorageTexelBuffer", "%int_0 %int_0"), std::make_pair("ArgumentUniformTexelBuffer", "%int_0 %int_0")})); TEST_P(ArgumentBasics, KernelNotAnExtendedInstruction) { const std::string ext_inst = std::get<0>(GetParam()); const std::string extra = std::get<1>(GetParam()); const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %ext = OpExtInstImport "NonSemantic.ClspvReflection.5" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %foo "foo" OpExecutionMode %foo LocalSize 1 1 1 %foo_name = OpString "foo" %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int_4 = OpConstant %int 4 %void_fn = OpTypeFunction %void %foo = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd %in = OpExtInst %void %ext )" + ext_inst + " %int_0 %int_0 " + extra; CompileSuccessfully(text); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Kernel must be a Kernel extended instruction")); } TEST_P(ArgumentBasics, KernelFromDifferentImport) { const std::string ext_inst = std::get<0>(GetParam()); const std::string extra = std::get<1>(GetParam()); const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %ext = OpExtInstImport "NonSemantic.ClspvReflection.5" %ext2 = OpExtInstImport "NonSemantic.ClspvReflection.5" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %foo "foo" OpExecutionMode %foo LocalSize 1 1 1 %foo_name = OpString "foo" %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int_4 = OpConstant %int 4 %void_fn = OpTypeFunction %void %foo = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd %decl = OpExtInst %void %ext2 Kernel %foo %foo_name %in = OpExtInst %void %ext )" + ext_inst + " %decl %int_0 " + extra; CompileSuccessfully(text); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Kernel must be from the same extended instruction import")); } TEST_P(ArgumentBasics, KernelWrongExtendedInstruction) { const std::string ext_inst = std::get<0>(GetParam()); const std::string extra = std::get<1>(GetParam()); const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %ext = OpExtInstImport "NonSemantic.ClspvReflection.5" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %foo "foo" OpExecutionMode %foo LocalSize 1 1 1 %foo_name = OpString "foo" %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int_4 = OpConstant %int 4 %void_fn = OpTypeFunction %void %foo = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd %decl = OpExtInst %void %ext ArgumentInfo %foo_name %in = OpExtInst %void %ext )" + ext_inst + " %decl %int_0 " + extra; CompileSuccessfully(text); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Kernel must be a Kernel extended instruction")); } TEST_P(ArgumentBasics, ArgumentInfo) { const std::string ext_inst = std::get<0>(GetParam()); const std::string operands = std::get<1>(GetParam()); const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %ext = OpExtInstImport "NonSemantic.ClspvReflection.5" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %foo "foo" OpExecutionMode %foo LocalSize 1 1 1 %foo_name = OpString "foo" %in_name = OpString "in" %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int_4 = OpConstant %int 4 %void_fn = OpTypeFunction %void %foo = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd %decl = OpExtInst %void %ext Kernel %foo %foo_name %info = OpExtInst %void %ext ArgumentInfo %in_name %in = OpExtInst %void %ext )" + ext_inst + " %decl %int_0 " + operands + " %info"; CompileSuccessfully(text); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ArgumentBasics, ArgumentInfoNotAnExtendedInstruction) { const std::string ext_inst = std::get<0>(GetParam()); const std::string operands = std::get<1>(GetParam()); const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %ext = OpExtInstImport "NonSemantic.ClspvReflection.5" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %foo "foo" OpExecutionMode %foo LocalSize 1 1 1 %foo_name = OpString "foo" %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int_4 = OpConstant %int 4 %void_fn = OpTypeFunction %void %foo = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd %decl = OpExtInst %void %ext Kernel %foo %foo_name %in = OpExtInst %void %ext )" + ext_inst + " %decl %int_0 " + operands + " %int_0"; CompileSuccessfully(text); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("ArgInfo must be an ArgumentInfo extended instruction")); } TEST_P(ArgumentBasics, ArgumentInfoFromDifferentImport) { const std::string ext_inst = std::get<0>(GetParam()); const std::string operands = std::get<1>(GetParam()); const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %ext = OpExtInstImport "NonSemantic.ClspvReflection.5" %ext2 = OpExtInstImport "NonSemantic.ClspvReflection.5" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %foo "foo" OpExecutionMode %foo LocalSize 1 1 1 %foo_name = OpString "foo" %in_name = OpString "in" %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int_4 = OpConstant %int 4 %void_fn = OpTypeFunction %void %foo = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd %decl = OpExtInst %void %ext Kernel %foo %foo_name %info = OpExtInst %void %ext2 ArgumentInfo %in_name %in = OpExtInst %void %ext )" + ext_inst + " %decl %int_0 " + operands + " %info"; CompileSuccessfully(text); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("ArgInfo must be from the same extended instruction import")); } using Uint32Constant = spvtest::ValidateBase>; INSTANTIATE_TEST_SUITE_P( ValidateClspvReflectionUint32Constants, Uint32Constant, ::testing::ValuesIn(std::vector>{ std::make_pair("ArgumentStorageBuffer %decl %float_0 %int_0 %int_0", "Ordinal"), std::make_pair("ArgumentStorageBuffer %decl %null %int_0 %int_0", "Ordinal"), std::make_pair("ArgumentStorageBuffer %decl %int_0 %float_0 %int_0", "DescriptorSet"), std::make_pair("ArgumentStorageBuffer %decl %int_0 %null %int_0", "DescriptorSet"), std::make_pair("ArgumentStorageBuffer %decl %int_0 %int_0 %float_0", "Binding"), std::make_pair("ArgumentStorageBuffer %decl %int_0 %int_0 %null", "Binding"), std::make_pair("ArgumentUniform %decl %float_0 %int_0 %int_0", "Ordinal"), std::make_pair("ArgumentUniform %decl %null %int_0 %int_0", "Ordinal"), std::make_pair("ArgumentUniform %decl %int_0 %float_0 %int_0", "DescriptorSet"), std::make_pair("ArgumentUniform %decl %int_0 %null %int_0", "DescriptorSet"), std::make_pair("ArgumentUniform %decl %int_0 %int_0 %float_0", "Binding"), std::make_pair("ArgumentUniform %decl %int_0 %int_0 %null", "Binding"), std::make_pair("ArgumentSampledImage %decl %float_0 %int_0 %int_0", "Ordinal"), std::make_pair("ArgumentSampledImage %decl %null %int_0 %int_0", "Ordinal"), std::make_pair("ArgumentSampledImage %decl %int_0 %float_0 %int_0", "DescriptorSet"), std::make_pair("ArgumentSampledImage %decl %int_0 %null %int_0", "DescriptorSet"), std::make_pair("ArgumentSampledImage %decl %int_0 %int_0 %float_0", "Binding"), std::make_pair("ArgumentSampledImage %decl %int_0 %int_0 %null", "Binding"), std::make_pair("ArgumentStorageImage %decl %float_0 %int_0 %int_0", "Ordinal"), std::make_pair("ArgumentStorageImage %decl %null %int_0 %int_0", "Ordinal"), std::make_pair("ArgumentStorageImage %decl %int_0 %float_0 %int_0", "DescriptorSet"), std::make_pair("ArgumentStorageImage %decl %int_0 %null %int_0", "DescriptorSet"), std::make_pair("ArgumentStorageImage %decl %int_0 %int_0 %float_0", "Binding"), std::make_pair("ArgumentStorageImage %decl %int_0 %int_0 %null", "Binding"), std::make_pair("ArgumentSampler %decl %float_0 %int_0 %int_0", "Ordinal"), std::make_pair("ArgumentSampler %decl %null %int_0 %int_0", "Ordinal"), std::make_pair("ArgumentSampler %decl %int_0 %float_0 %int_0", "DescriptorSet"), std::make_pair("ArgumentSampler %decl %int_0 %null %int_0", "DescriptorSet"), std::make_pair("ArgumentSampler %decl %int_0 %int_0 %float_0", "Binding"), std::make_pair("ArgumentSampler %decl %int_0 %int_0 %null", "Binding"), std::make_pair("ArgumentPodStorageBuffer %decl %float_0 %int_0 %int_0 " "%int_0 %int_4", "Ordinal"), std::make_pair( "ArgumentPodStorageBuffer %decl %null %int_0 %int_0 %int_0 %int_4", "Ordinal"), std::make_pair("ArgumentPodStorageBuffer %decl %int_0 %float_0 %int_0 " "%int_0 %int_4", "DescriptorSet"), std::make_pair( "ArgumentPodStorageBuffer %decl %int_0 %null %int_0 %int_0 %int_4", "DescriptorSet"), std::make_pair("ArgumentPodStorageBuffer %decl %int_0 %int_0 %float_0 " "%int_0 %int_4", "Binding"), std::make_pair( "ArgumentPodStorageBuffer %decl %int_0 %int_0 %null %int_0 %int_4", "Binding"), std::make_pair("ArgumentPodStorageBuffer %decl %int_0 %int_0 %int_0 " "%float_0 %int_4", "Offset"), std::make_pair( "ArgumentPodStorageBuffer %decl %int_0 %int_0 %int_0 %null %int_4", "Offset"), std::make_pair("ArgumentPodStorageBuffer %decl %int_0 %int_0 %int_0 " "%int_0 %float_0", "Size"), std::make_pair( "ArgumentPodStorageBuffer %decl %int_0 %int_0 %int_0 %int_0 %null", "Size"), std::make_pair( "ArgumentPodUniform %decl %float_0 %int_0 %int_0 %int_0 %int_4", "Ordinal"), std::make_pair( "ArgumentPodUniform %decl %null %int_0 %int_0 %int_0 %int_4", "Ordinal"), std::make_pair( "ArgumentPodUniform %decl %int_0 %float_0 %int_0 %int_0 %int_4", "DescriptorSet"), std::make_pair( "ArgumentPodUniform %decl %int_0 %null %int_0 %int_0 %int_4", "DescriptorSet"), std::make_pair( "ArgumentPodUniform %decl %int_0 %int_0 %float_0 %int_0 %int_4", "Binding"), std::make_pair( "ArgumentPodUniform %decl %int_0 %int_0 %null %int_0 %int_4", "Binding"), std::make_pair( "ArgumentPodUniform %decl %int_0 %int_0 %int_0 %float_0 %int_4", "Offset"), std::make_pair( "ArgumentPodUniform %decl %int_0 %int_0 %int_0 %null %int_4", "Offset"), std::make_pair( "ArgumentPodUniform %decl %int_0 %int_0 %int_0 %int_0 %float_0", "Size"), std::make_pair( "ArgumentPodUniform %decl %int_0 %int_0 %int_0 %int_0 %null", "Size"), std::make_pair("ArgumentPodPushConstant %decl %float_0 %int_0 %int_4", "Ordinal"), std::make_pair("ArgumentPodPushConstant %decl %null %int_0 %int_4", "Ordinal"), std::make_pair("ArgumentPodPushConstant %decl %int_0 %float_0 %int_4", "Offset"), std::make_pair("ArgumentPodPushConstant %decl %int_0 %null %int_4", "Offset"), std::make_pair("ArgumentPodPushConstant %decl %int_0 %int_0 %float_0", "Size"), std::make_pair("ArgumentPodPushConstant %decl %int_0 %int_0 %null", "Size"), std::make_pair("ArgumentWorkgroup %decl %float_0 %int_0 %int_4", "Ordinal"), std::make_pair("ArgumentWorkgroup %decl %null %int_0 %int_4", "Ordinal"), std::make_pair("ArgumentWorkgroup %decl %int_0 %float_0 %int_4", "SpecId"), std::make_pair("ArgumentWorkgroup %decl %int_0 %null %int_4", "SpecId"), std::make_pair("ArgumentWorkgroup %decl %int_0 %int_0 %float_0", "ElemSize"), std::make_pair("ArgumentWorkgroup %decl %int_0 %int_0 %null", "ElemSize"), std::make_pair("SpecConstantWorkgroupSize %float_0 %int_0 %int_4", "X"), std::make_pair("SpecConstantWorkgroupSize %null %int_0 %int_4", "X"), std::make_pair("SpecConstantWorkgroupSize %int_0 %float_0 %int_4", "Y"), std::make_pair("SpecConstantWorkgroupSize %int_0 %null %int_4", "Y"), std::make_pair("SpecConstantWorkgroupSize %int_0 %int_0 %float_0", "Z"), std::make_pair("SpecConstantWorkgroupSize %int_0 %int_0 %null", "Z"), std::make_pair("SpecConstantGlobalOffset %float_0 %int_0 %int_4", "X"), std::make_pair("SpecConstantGlobalOffset %null %int_0 %int_4", "X"), std::make_pair("SpecConstantGlobalOffset %int_0 %float_0 %int_4", "Y"), std::make_pair("SpecConstantGlobalOffset %int_0 %null %int_4", "Y"), std::make_pair("SpecConstantGlobalOffset %int_0 %int_0 %float_0", "Z"), std::make_pair("SpecConstantGlobalOffset %int_0 %int_0 %null", "Z"), std::make_pair("SpecConstantWorkDim %float_0", "Dim"), std::make_pair("SpecConstantWorkDim %null", "Dim"), std::make_pair("PushConstantGlobalOffset %float_0 %int_0", "Offset"), std::make_pair("PushConstantGlobalOffset %null %int_0", "Offset"), std::make_pair("PushConstantGlobalOffset %int_0 %float_0", "Size"), std::make_pair("PushConstantGlobalOffset %int_0 %null", "Size"), std::make_pair("PushConstantEnqueuedLocalSize %float_0 %int_0", "Offset"), std::make_pair("PushConstantEnqueuedLocalSize %null %int_0", "Offset"), std::make_pair("PushConstantEnqueuedLocalSize %int_0 %float_0", "Size"), std::make_pair("PushConstantEnqueuedLocalSize %int_0 %null", "Size"), std::make_pair("PushConstantGlobalSize %float_0 %int_0", "Offset"), std::make_pair("PushConstantGlobalSize %null %int_0", "Offset"), std::make_pair("PushConstantGlobalSize %int_0 %float_0", "Size"), std::make_pair("PushConstantGlobalSize %int_0 %null", "Size"), std::make_pair("PushConstantRegionOffset %float_0 %int_0", "Offset"), std::make_pair("PushConstantRegionOffset %null %int_0", "Offset"), std::make_pair("PushConstantRegionOffset %int_0 %float_0", "Size"), std::make_pair("PushConstantRegionOffset %int_0 %null", "Size"), std::make_pair("PushConstantNumWorkgroups %float_0 %int_0", "Offset"), std::make_pair("PushConstantNumWorkgroups %null %int_0", "Offset"), std::make_pair("PushConstantNumWorkgroups %int_0 %float_0", "Size"), std::make_pair("PushConstantNumWorkgroups %int_0 %null", "Size"), std::make_pair("PushConstantRegionGroupOffset %float_0 %int_0", "Offset"), std::make_pair("PushConstantRegionGroupOffset %null %int_0", "Offset"), std::make_pair("PushConstantRegionGroupOffset %int_0 %float_0", "Size"), std::make_pair("PushConstantRegionGroupOffset %int_0 %null", "Size"), std::make_pair("ConstantDataStorageBuffer %float_0 %int_0 %data", "DescriptorSet"), std::make_pair("ConstantDataStorageBuffer %null %int_0 %data", "DescriptorSet"), std::make_pair("ConstantDataStorageBuffer %int_0 %float_0 %data", "Binding"), std::make_pair("ConstantDataStorageBuffer %int_0 %null %data", "Binding"), std::make_pair("ConstantDataUniform %float_0 %int_0 %data", "DescriptorSet"), std::make_pair("ConstantDataUniform %null %int_0 %data", "DescriptorSet"), std::make_pair("ConstantDataUniform %int_0 %float_0 %data", "Binding"), std::make_pair("ConstantDataUniform %int_0 %null %data", "Binding"), std::make_pair("LiteralSampler %float_0 %int_0 %int_4", "DescriptorSet"), std::make_pair("LiteralSampler %null %int_0 %int_4", "DescriptorSet"), std::make_pair("LiteralSampler %int_0 %float_0 %int_4", "Binding"), std::make_pair("LiteralSampler %int_0 %null %int_4", "Binding"), std::make_pair("LiteralSampler %int_0 %int_0 %float_0", "Mask"), std::make_pair("LiteralSampler %int_0 %int_0 %null", "Mask"), std::make_pair( "PropertyRequiredWorkgroupSize %decl %float_0 %int_1 %int_4", "X"), std::make_pair( "PropertyRequiredWorkgroupSize %decl %null %int_1 %int_4", "X"), std::make_pair( "PropertyRequiredWorkgroupSize %decl %int_1 %float_0 %int_4", "Y"), std::make_pair( "PropertyRequiredWorkgroupSize %decl %int_1 %null %int_4", "Y"), std::make_pair( "PropertyRequiredWorkgroupSize %decl %int_1 %int_1 %float_0", "Z"), std::make_pair( "PropertyRequiredWorkgroupSize %decl %int_1 %int_1 %null", "Z"), std::make_pair("SpecConstantSubgroupMaxSize %float_0", "Size"), std::make_pair("SpecConstantSubgroupMaxSize %null", "Size"), std::make_pair( "ArgumentPointerPushConstant %decl %float_0 %int_0 %int_0", "Ordinal"), std::make_pair("ArgumentPointerPushConstant %decl %null %int_0 %int_0", "Ordinal"), std::make_pair( "ArgumentPointerPushConstant %decl %int_0 %float_0 %int_0", "Offset"), std::make_pair("ArgumentPointerPushConstant %decl %int_0 %null %int_0", "Offset"), std::make_pair( "ArgumentPointerPushConstant %decl %int_0 %int_0 %float_0", "Size"), std::make_pair("ArgumentPointerPushConstant %decl %int_0 %int_0 %null", "Size"), std::make_pair( "ArgumentPointerUniform %decl %float_0 %int_0 %int_0 %int_0 %int_4", "Ordinal"), std::make_pair( "ArgumentPointerUniform %decl %null %int_0 %int_0 %int_0 %int_4", "Ordinal"), std::make_pair( "ArgumentPointerUniform %decl %int_0 %float_0 %int_0 %int_0 %int_4", "DescriptorSet"), std::make_pair( "ArgumentPointerUniform %decl %int_0 %null %int_0 %int_0 %int_4", "DescriptorSet"), std::make_pair( "ArgumentPointerUniform %decl %int_0 %int_0 %float_0 %int_0 %int_4", "Binding"), std::make_pair( "ArgumentPointerUniform %decl %int_0 %int_0 %null %int_0 %int_4", "Binding"), std::make_pair( "ArgumentPointerUniform %decl %int_0 %int_0 %int_0 %float_0 %int_4", "Offset"), std::make_pair( "ArgumentPointerUniform %decl %int_0 %int_0 %int_0 %null %int_4", "Offset"), std::make_pair( "ArgumentPointerUniform %decl %int_0 %int_0 %int_0 %int_0 %float_0", "Size"), std::make_pair( "ArgumentPointerUniform %decl %int_0 %int_0 %int_0 %int_0 %null", "Size"), std::make_pair( "ProgramScopeVariablesStorageBuffer %float_0 %int_0 %data", "DescriptorSet"), std::make_pair("ProgramScopeVariablesStorageBuffer %null %int_0 %data", "DescriptorSet"), std::make_pair( "ProgramScopeVariablesStorageBuffer %int_0 %float_0 %data", "Binding"), std::make_pair("ProgramScopeVariablesStorageBuffer %int_0 %null %data", "Binding"), std::make_pair( "ProgramScopeVariablePointerRelocation %float_0 %int_0 %int_4", "ObjectOffset"), std::make_pair( "ProgramScopeVariablePointerRelocation %null %int_0 %int_4", "ObjectOffset"), std::make_pair( "ProgramScopeVariablePointerRelocation %int_0 %float_0 %int_4", "PointerOffset"), std::make_pair( "ProgramScopeVariablePointerRelocation %int_0 %null %int_4", "PointerOffset"), std::make_pair( "ProgramScopeVariablePointerRelocation %int_0 %int_0 %float_0", "PointerSize"), std::make_pair( "ProgramScopeVariablePointerRelocation %int_0 %int_0 %null", "PointerSize"), std::make_pair("ImageArgumentInfoChannelOrderPushConstant %decl " "%float_0 %int_0 %int_4", "Ordinal"), std::make_pair("ImageArgumentInfoChannelOrderPushConstant %decl %null " "%int_0 %int_4", "Ordinal"), std::make_pair("ImageArgumentInfoChannelOrderPushConstant %decl %int_0 " "%float_0 %int_4", "Offset"), std::make_pair("ImageArgumentInfoChannelOrderPushConstant %decl %int_0 " "%null %int_4", "Offset"), std::make_pair("ImageArgumentInfoChannelOrderPushConstant %decl %int_0 " "%int_0 %float_0", "Size"), std::make_pair("ImageArgumentInfoChannelOrderPushConstant %decl %int_0 " "%int_0 %null", "Size"), std::make_pair("ImageArgumentInfoChannelDataTypePushConstant %decl " "%float_0 %int_0 %int_4", "Ordinal"), std::make_pair("ImageArgumentInfoChannelDataTypePushConstant %decl " "%null %int_0 %int_4", "Ordinal"), std::make_pair("ImageArgumentInfoChannelDataTypePushConstant %decl " "%int_0 %float_0 %int_4", "Offset"), std::make_pair("ImageArgumentInfoChannelDataTypePushConstant %decl " "%int_0 %null %int_4", "Offset"), std::make_pair("ImageArgumentInfoChannelDataTypePushConstant %decl " "%int_0 %int_0 %float_0", "Size"), std::make_pair("ImageArgumentInfoChannelDataTypePushConstant %decl " "%int_0 %int_0 %null", "Size"), std::make_pair("ImageArgumentInfoChannelOrderUniform %decl %float_0 " "%int_0 %int_0 %int_0 %int_4", "Ordinal"), std::make_pair("ImageArgumentInfoChannelOrderUniform %decl %null " "%int_0 %int_0 %int_0 %int_4", "Ordinal"), std::make_pair("ImageArgumentInfoChannelOrderUniform %decl %int_0 " "%float_0 %int_0 %int_0 %int_4", "DescriptorSet"), std::make_pair("ImageArgumentInfoChannelOrderUniform %decl %int_0 " "%null %int_0 %int_0 %int_4", "DescriptorSet"), std::make_pair("ImageArgumentInfoChannelOrderUniform %decl %int_0 " "%int_0 %float_0 %int_0 %int_4", "Binding"), std::make_pair("ImageArgumentInfoChannelOrderUniform %decl %int_0 " "%int_0 %null %int_0 %int_4", "Binding"), std::make_pair("ImageArgumentInfoChannelOrderUniform %decl %int_0 " "%int_0 %int_0 %float_0 %int_4", "Offset"), std::make_pair("ImageArgumentInfoChannelOrderUniform %decl %int_0 " "%int_0 %int_0 %null %int_4", "Offset"), std::make_pair("ImageArgumentInfoChannelOrderUniform %decl %int_0 " "%int_0 %int_0 %int_0 %float_0", "Size"), std::make_pair("ImageArgumentInfoChannelOrderUniform %decl %int_0 " "%int_0 %int_0 %int_0 %null", "Size"), std::make_pair("ImageArgumentInfoChannelDataTypeUniform %decl %float_0 " "%int_0 %int_0 %int_0 %int_4", "Ordinal"), std::make_pair("ImageArgumentInfoChannelDataTypeUniform %decl %null " "%int_0 %int_0 %int_0 %int_4", "Ordinal"), std::make_pair("ImageArgumentInfoChannelDataTypeUniform %decl %int_0 " "%float_0 %int_0 %int_0 %int_4", "DescriptorSet"), std::make_pair("ImageArgumentInfoChannelDataTypeUniform %decl %int_0 " "%null %int_0 %int_0 %int_4", "DescriptorSet"), std::make_pair("ImageArgumentInfoChannelDataTypeUniform %decl %int_0 " "%int_0 %float_0 %int_0 %int_4", "Binding"), std::make_pair("ImageArgumentInfoChannelDataTypeUniform %decl %int_0 " "%int_0 %null %int_0 %int_4", "Binding"), std::make_pair("ImageArgumentInfoChannelDataTypeUniform %decl %int_0 " "%int_0 %int_0 %float_0 %int_4", "Offset"), std::make_pair("ImageArgumentInfoChannelDataTypeUniform %decl %int_0 " "%int_0 %int_0 %null %int_4", "Offset"), std::make_pair("ImageArgumentInfoChannelDataTypeUniform %decl %int_0 " "%int_0 %int_0 %int_0 %float_0", "Size"), std::make_pair("ImageArgumentInfoChannelDataTypeUniform %decl %int_0 " "%int_0 %int_0 %int_0 %null", "Size"), std::make_pair( "ArgumentStorageTexelBuffer %decl %float_0 %int_0 %int_0", "Ordinal"), std::make_pair("ArgumentStorageTexelBuffer %decl %null %int_0 %int_0", "Ordinal"), std::make_pair( "ArgumentStorageTexelBuffer %decl %int_0 %float_0 %int_0", "DescriptorSet"), std::make_pair("ArgumentStorageTexelBuffer %decl %int_0 %null %int_0", "DescriptorSet"), std::make_pair( "ArgumentStorageTexelBuffer %decl %int_0 %int_0 %float_0", "Binding"), std::make_pair("ArgumentStorageTexelBuffer %decl %int_0 %int_0 %null", "Binding"), std::make_pair( "ArgumentUniformTexelBuffer %decl %float_0 %int_0 %int_0", "Ordinal"), std::make_pair("ArgumentUniformTexelBuffer %decl %null %int_0 %int_0", "Ordinal"), std::make_pair( "ArgumentUniformTexelBuffer %decl %int_0 %float_0 %int_0", "DescriptorSet"), std::make_pair("ArgumentUniformTexelBuffer %decl %int_0 %null %int_0", "DescriptorSet"), std::make_pair( "ArgumentUniformTexelBuffer %decl %int_0 %int_0 %float_0", "Binding"), std::make_pair("ArgumentUniformTexelBuffer %decl %int_0 %int_0 %null", "Binding"), std::make_pair("ConstantDataPointerPushConstant %float_0 %int_4 %data", "Offset"), std::make_pair("ConstantDataPointerPushConstant %null %int_4 %data", "Offset"), std::make_pair("ConstantDataPointerPushConstant %int_0 %float_0 %data", "Size"), std::make_pair("ConstantDataPointerPushConstant %int_0 %null %data", "Size"), std::make_pair( "ProgramScopeVariablePointerPushConstant %float_0 %int_4 %data", "Offset"), std::make_pair( "ProgramScopeVariablePointerPushConstant %null %int_4 %data", "Offset"), std::make_pair( "ProgramScopeVariablePointerPushConstant %int_0 %float_0 %data", "Size"), std::make_pair( "ProgramScopeVariablePointerPushConstant %int_0 %null %data", "Size"), std::make_pair("PrintfInfo %float_0 %data %int_0 %int_0 %int_0", "PrintfID"), std::make_pair("PrintfInfo %null %data %int_0 %int_0 %int_0", "PrintfID"), std::make_pair("PrintfInfo %int_0 %data %float_0 %int_0 %int_0", "ArgumentSizes"), std::make_pair("PrintfInfo %int_0 %data %null %int_0 %int_0", "ArgumentSizes"), std::make_pair("PrintfInfo %int_0 %data %int_0 %float_0 %int_0", "ArgumentSizes"), std::make_pair("PrintfInfo %int_0 %data %int_0 %null %int_0", "ArgumentSizes"), std::make_pair("PrintfInfo %int_0 %data %int_0 %int_0 %null", "ArgumentSizes"), std::make_pair("PrintfInfo %int_0 %data %int_0 %int_0 %float_0", "ArgumentSizes"), std::make_pair("PrintfInfo %int_0 %data %int_0 %float_0", "ArgumentSizes"), std::make_pair("PrintfInfo %int_0 %data %int_0 %null", "ArgumentSizes"), std::make_pair("PrintfBufferStorageBuffer %float_0 %int_0 %int_4", "DescriptorSet"), std::make_pair("PrintfBufferStorageBuffer %null %int_0 %int_4", "DescriptorSet"), std::make_pair("PrintfBufferStorageBuffer %int_0 %float_0 %int_4", "Binding"), std::make_pair("PrintfBufferStorageBuffer %int_0 %null %int_4", "Binding"), std::make_pair("PrintfBufferStorageBuffer %int_0 %int_0 %float_0", "Size"), std::make_pair("PrintfBufferStorageBuffer %int_0 %int_0 %null", "Size"), std::make_pair("PrintfBufferPointerPushConstant %float_0 %int_0 %int_4", "Offset"), std::make_pair("PrintfBufferPointerPushConstant %null %int_0 %int_4", "Offset"), std::make_pair("PrintfBufferPointerPushConstant %int_0 %float_0 %int_4", "Size"), std::make_pair("PrintfBufferPointerPushConstant %int_0 %null %int_4", "Size"), std::make_pair("PrintfBufferPointerPushConstant %int_0 %int_0 %float_0", "BufferSize"), std::make_pair("PrintfBufferPointerPushConstant %int_0 %int_0 %null", "BufferSize")})); TEST_P(Uint32Constant, Invalid) { const std::string ext_inst = std::get<0>(GetParam()); const std::string name = std::get<1>(GetParam()); const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %ext = OpExtInstImport "NonSemantic.ClspvReflection.5" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %foo "foo" OpExecutionMode %foo LocalSize 1 1 1 %foo_name = OpString "foo" %data = OpString "1234" %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %int_4 = OpConstant %int 4 %null = OpConstantNull %int %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %void_fn = OpTypeFunction %void %foo = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd %decl = OpExtInst %void %ext Kernel %foo %foo_name %inst = OpExtInst %void %ext )" + ext_inst; CompileSuccessfully(text); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(name + " must be a 32-bit unsigned integer OpConstant")); } using StringOperand = spvtest::ValidateBase>; INSTANTIATE_TEST_SUITE_P( ValidateClspvReflectionStringOperands, StringOperand, ::testing::ValuesIn(std::vector>{ std::make_pair("ConstantDataStorageBuffer %int_0 %int_0 %int_0", "Data"), std::make_pair("ConstantDataUniform %int_0 %int_0 %int_0", "Data"), std::make_pair( "ProgramScopeVariablesStorageBuffer %int_0 %int_0 %int_0", "Data"), std::make_pair("ConstantDataPointerPushConstant %int_0 %int_0 %int_0", "Data"), std::make_pair( "ProgramScopeVariablePointerPushConstant %int_0 %int_0 %int_0", "Data"), std::make_pair("PrintfInfo %int_0 %int_0", "FormatString")})); TEST_P(StringOperand, Invalid) { const std::string ext_inst = std::get<0>(GetParam()); const std::string name = std::get<1>(GetParam()); const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %ext = OpExtInstImport "NonSemantic.ClspvReflection.5" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %foo "foo" OpExecutionMode %foo LocalSize 1 1 1 %foo_name = OpString "foo" %data = OpString "1234" %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %int_4 = OpConstant %int 4 %null = OpConstantNull %int %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %void_fn = OpTypeFunction %void %foo = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd %decl = OpExtInst %void %ext Kernel %foo %foo_name %inst = OpExtInst %void %ext )" + ext_inst; CompileSuccessfully(text); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(name + " must be an OpString")); } using VersionCheck = spvtest::ValidateBase>; INSTANTIATE_TEST_SUITE_P( ValidateClspvReflectionVersionCheck, VersionCheck, ::testing::ValuesIn(std::vector>{ std::make_pair("ArgumentStorageBuffer %decl %int_0 %int_0 %int_0", 1), std::make_pair("ArgumentUniform %decl %int_0 %int_0 %int_0", 1), std::make_pair( "ArgumentPodStorageBuffer %decl %int_0 %int_0 %int_0 %int_0 %int_0", 1), std::make_pair( "ArgumentPodUniform %decl %int_0 %int_0 %int_0 %int_0 %int_0", 1), std::make_pair("ArgumentPodPushConstant %decl %int_0 %int_0 %int_0", 1), std::make_pair("ArgumentSampledImage %decl %int_0 %int_0 %int_0", 1), std::make_pair("ArgumentStorageImage %decl %int_0 %int_0 %int_0", 1), std::make_pair("ArgumentSampler %decl %int_0 %int_0 %int_0", 1), std::make_pair("ArgumentWorkgroup %decl %int_0 %int_0 %int_0", 1), std::make_pair("SpecConstantWorkgroupSize %int_0 %int_0 %int_0", 1), std::make_pair("SpecConstantGlobalOffset %int_0 %int_0 %int_0", 1), std::make_pair("SpecConstantWorkDim %int_0", 1), std::make_pair("PushConstantGlobalOffset %int_0 %int_0", 1), std::make_pair("PushConstantEnqueuedLocalSize %int_0 %int_0", 1), std::make_pair("PushConstantGlobalSize %int_0 %int_0", 1), std::make_pair("PushConstantRegionOffset %int_0 %int_0", 1), std::make_pair("PushConstantNumWorkgroups %int_0 %int_0", 1), std::make_pair("PushConstantRegionGroupOffset %int_0 %int_0", 1), std::make_pair("ConstantDataStorageBuffer %int_0 %int_0 %data", 1), std::make_pair("ConstantDataUniform %int_0 %int_0 %data", 1), std::make_pair("LiteralSampler %int_0 %int_0 %int_0", 1), std::make_pair( "PropertyRequiredWorkgroupSize %decl %int_0 %int_0 %int_0", 1), std::make_pair("SpecConstantSubgroupMaxSize %int_0", 2), std::make_pair("ArgumentPointerPushConstant %decl %int_0 %int_0 %int_0", 3), std::make_pair( "ArgumentPointerUniform %decl %int_0 %int_0 %int_0 %int_0 %int_0", 3), std::make_pair("ProgramScopeVariablesStorageBuffer %int_0 %int_0 %data", 3), std::make_pair( "ProgramScopeVariablePointerRelocation %int_0 %int_0 %int_0", 3), std::make_pair("ImageArgumentInfoChannelOrderPushConstant %decl %int_0 " "%int_0 %int_0", 3), std::make_pair("ImageArgumentInfoChannelDataTypePushConstant %decl " "%int_0 %int_0 %int_0", 3), std::make_pair("ImageArgumentInfoChannelOrderUniform %decl %int_0 " "%int_0 %int_0 %int_0 %int_0", 3), std::make_pair("ImageArgumentInfoChannelDataTypeUniform %decl %int_0 " "%int_0 %int_0 %int_0 %int_0", 3), std::make_pair("ArgumentStorageTexelBuffer %decl %int_0 %int_0 %int_0", 4), std::make_pair("ArgumentUniformTexelBuffer %decl %int_0 %int_0 %int_0", 4), std::make_pair("ConstantDataPointerPushConstant %int_0 %int_0 %data", 5), std::make_pair( "ProgramScopeVariablePointerPushConstant %int_0 %int_0 %data", 5), std::make_pair("PrintfInfo %int_0 %data", 5), std::make_pair("PrintfBufferStorageBuffer %int_0 %int_0 %int_0", 5), std::make_pair("PrintfBufferPointerPushConstant %int_0 %int_0 %int_0", 5)})); TEST_P(VersionCheck, V1) { const std::string ext_inst = std::get<0>(GetParam()); const uint32_t version = std::get<1>(GetParam()); const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %ext = OpExtInstImport "NonSemantic.ClspvReflection.1" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %foo "foo" OpExecutionMode %foo LocalSize 1 1 1 %foo_name = OpString "foo" %data = OpString "1234" %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %int_4 = OpConstant %int 4 %null = OpConstantNull %int %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %void_fn = OpTypeFunction %void %foo = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd %decl = OpExtInst %void %ext Kernel %foo %foo_name %inst = OpExtInst %void %ext )" + ext_inst; CompileSuccessfully(text); if (version <= 1) { EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } else { EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("requires version " + std::to_string(version) + ", but parsed version is 1")); } } TEST_P(VersionCheck, V2) { const std::string ext_inst = std::get<0>(GetParam()); const uint32_t version = std::get<1>(GetParam()); const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %ext = OpExtInstImport "NonSemantic.ClspvReflection.2" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %foo "foo" OpExecutionMode %foo LocalSize 1 1 1 %foo_name = OpString "foo" %data = OpString "1234" %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %int_4 = OpConstant %int 4 %null = OpConstantNull %int %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %void_fn = OpTypeFunction %void %foo = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd %decl = OpExtInst %void %ext Kernel %foo %foo_name %inst = OpExtInst %void %ext )" + ext_inst; CompileSuccessfully(text); if (version <= 2) { EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } else { EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("requires version " + std::to_string(version) + ", but parsed version is 2")); } } TEST_P(VersionCheck, V3) { const std::string ext_inst = std::get<0>(GetParam()); const uint32_t version = std::get<1>(GetParam()); const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %ext = OpExtInstImport "NonSemantic.ClspvReflection.3" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %foo "foo" OpExecutionMode %foo LocalSize 1 1 1 %foo_name = OpString "foo" %data = OpString "1234" %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %int_4 = OpConstant %int 4 %null = OpConstantNull %int %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %void_fn = OpTypeFunction %void %foo = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd %decl = OpExtInst %void %ext Kernel %foo %foo_name %inst = OpExtInst %void %ext )" + ext_inst; CompileSuccessfully(text); if (version <= 3) { EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } else { EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("requires version " + std::to_string(version) + ", but parsed version is 3")); } } TEST_P(VersionCheck, V4) { const std::string ext_inst = std::get<0>(GetParam()); const uint32_t version = std::get<1>(GetParam()); const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %ext = OpExtInstImport "NonSemantic.ClspvReflection.4" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %foo "foo" OpExecutionMode %foo LocalSize 1 1 1 %foo_name = OpString "foo" %data = OpString "1234" %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %int_4 = OpConstant %int 4 %null = OpConstantNull %int %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %void_fn = OpTypeFunction %void %foo = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd %decl = OpExtInst %void %ext Kernel %foo %foo_name %inst = OpExtInst %void %ext )" + ext_inst; CompileSuccessfully(text); if (version <= 4) { EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } else { EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("requires version " + std::to_string(version) + ", but parsed version is 4")); } } TEST_P(VersionCheck, V5) { const std::string ext_inst = std::get<0>(GetParam()); const uint32_t version = std::get<1>(GetParam()); const std::string text = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %ext = OpExtInstImport "NonSemantic.ClspvReflection.5" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %foo "foo" OpExecutionMode %foo LocalSize 1 1 1 %foo_name = OpString "foo" %data = OpString "1234" %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %int_4 = OpConstant %int 4 %null = OpConstantNull %int %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %void_fn = OpTypeFunction %void %foo = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd %decl = OpExtInst %void %ext Kernel %foo %foo_name %inst = OpExtInst %void %ext )" + ext_inst; CompileSuccessfully(text); if (version <= 5) { EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } else { EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("requires version " + std::to_string(version) + ", but parsed version is 1")); } } TEST_F(ValidateExtInst, OpExtInstWithForwardNotAllowedSemantic) { const std::string body = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" OpExtension "SPV_KHR_relaxed_extended_instruction" %1 = OpExtInstImport "NonSemantic.Shader.DebugInfo.100" %extinst = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" OpExecutionMode %2 LocalSize 1 1 1 %3 = OpString "sample" %void = OpTypeVoid %uint = OpTypeInt 32 0 %f32 = OpTypeFloat 32 %uint_0 = OpConstant %uint 0 %f32_0 = OpConstant %f32 0 %f32_1 = OpConstant %f32 1 %7 = OpTypeFunction %void %8 = OpExtInst %void %1 DebugSource %3 %3 %9 = OpExtInst %void %1 DebugCompilationUnit %uint_0 %uint_0 %8 %uint_0 %10 = OpExtInstWithForwardRefsKHR %void %1 DebugTypeFunction %uint_0 %11 %12 = OpExtInstWithForwardRefsKHR %void %1 DebugFunction %3 %10 %8 %uint_0 %uint_0 %11 %3 %uint_0 %uint_0 %11 = OpExtInst %void %1 DebugTypeComposite %3 %uint_0 %8 %uint_0 %uint_0 %9 %3 %uint_0 %uint_0 %12 %2 = OpFunction %void None %7 %13 = OpLabel %18 = OpExtInstWithForwardRefsKHR %f32 %extinst FMin %f32_0 %19 %19 = OpExtInst %f32 %extinst FMin %f32_0 %f32_1 OpReturn OpFunctionEnd )"; CompileSuccessfully(body); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpExtInstWithForwardRefsKHR is only allowed with non-semantic " "instructions.\n" " %18 = OpExtInstWithForwardRefsKHR %float %2 FMin %float_0 %19\n")); } TEST_F(ValidateExtInst, OpExtInstRequiresNonSemanticBefore16) { const std::string body = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %1 = OpExtInstImport "NonSemantic.Shader.DebugInfo.100" %extinst = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" OpExecutionMode %2 LocalSize 1 1 1 %3 = OpString "sample" %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %7 = OpTypeFunction %void %8 = OpExtInst %void %1 DebugSource %3 %3 %9 = OpExtInst %void %1 DebugCompilationUnit %uint_0 %uint_0 %8 %uint_0 %10 = OpExtInstWithForwardRefsKHR %void %1 DebugTypeFunction %uint_0 %11 %12 = OpExtInstWithForwardRefsKHR %void %1 DebugFunction %3 %10 %8 %uint_0 %uint_0 %11 %3 %uint_0 %uint_0 %11 = OpExtInst %void %1 DebugTypeComposite %3 %uint_0 %8 %uint_0 %uint_0 %9 %3 %uint_0 %uint_0 %12 %2 = OpFunction %void None %7 %13 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(body); ASSERT_EQ(SPV_ERROR_MISSING_EXTENSION, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("ExtInstWithForwardRefsKHR requires one of the following " "extensions: SPV_KHR_relaxed_extended_instruction \n" " %11 = OpExtInstWithForwardRefsKHR %void %1 " "DebugTypeFunction %uint_0 %12\n")); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_extension_spv_khr_bit_instructions_test.cpp000066400000000000000000000063151475742701700321360ustar00rootroot00000000000000// Copyright (c) 2021 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Tests for OpExtension validator rules. #include #include #include "gmock/gmock.h" #include "source/spirv_target_env.h" #include "test/unit_spirv.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::HasSubstr; using ::testing::Values; using ::testing::ValuesIn; using ValidateSpvKHRBitInstructions = spvtest::ValidateBase; TEST_F(ValidateSpvKHRBitInstructions, Valid) { const std::string str = R"( OpCapability Kernel OpCapability Addresses OpCapability BitInstructions OpExtension "SPV_KHR_bit_instructions" OpMemoryModel Physical32 OpenCL OpEntryPoint Kernel %main "main" %void = OpTypeVoid %void_fn = OpTypeFunction %void %u32 = OpTypeInt 32 0 %u32_1 = OpConstant %u32 1 %main = OpFunction %void None %void_fn %entry = OpLabel %unused = OpBitReverse %u32 %u32_1 OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateSpvKHRBitInstructions, RequiresExtension) { const std::string str = R"( OpCapability Kernel OpCapability Addresses OpCapability BitInstructions OpMemoryModel Physical32 OpenCL OpEntryPoint Kernel %main "main" %void = OpTypeVoid %void_fn = OpTypeFunction %void %u32 = OpTypeInt 32 0 %u32_1 = OpConstant %u32 1 %main = OpFunction %void None %void_fn %entry = OpLabel %unused = OpBitReverse %u32 %u32_1 OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str()); EXPECT_NE(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("1st operand of Capability: operand BitInstructions(6025) " "requires one of these extensions: SPV_KHR_bit_instructions")); } TEST_F(ValidateSpvKHRBitInstructions, RequiresCapability) { const std::string str = R"( OpCapability Kernel OpCapability Addresses OpExtension "SPV_KHR_bit_instructions" OpMemoryModel Physical32 OpenCL OpEntryPoint Kernel %main "main" %void = OpTypeVoid %void_fn = OpTypeFunction %void %u32 = OpTypeInt 32 0 %u32_1 = OpConstant %u32 1 %main = OpFunction %void None %void_fn %entry = OpLabel %unused = OpBitReverse %u32 %u32_1 OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str()); EXPECT_NE(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Opcode BitReverse requires one of these capabilities: " "Shader BitInstructions")); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_extension_spv_khr_expect_assume_test.cpp000066400000000000000000000213111475742701700313720ustar00rootroot00000000000000// Copyright (c) 2020 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Tests for OpExtension validator rules. #include #include #include "gmock/gmock.h" #include "source/spirv_target_env.h" #include "test/unit_spirv.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::HasSubstr; using ::testing::Values; using ::testing::ValuesIn; using ValidateSpvExpectAssumeKHR = spvtest::ValidateBase; TEST_F(ValidateSpvExpectAssumeKHR, Valid) { const std::string str = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpCapability ExpectAssumeKHR OpExtension "SPV_KHR_expect_assume" OpMemoryModel Physical32 OpenCL %void = OpTypeVoid %voidfn = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %undef = OpUndef %bool %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %v2bool = OpTypeVector %bool 2 %v2uint = OpTypeVector %uint 2 %null_v2bool = OpConstantNull %v2bool %null_v2uint = OpConstantNull %v2uint %main = OpFunction %void None %voidfn %entry = OpLabel OpAssumeTrueKHR %true OpAssumeTrueKHR %undef ; probably undefined behaviour %bool_val = OpExpectKHR %bool %true %true %uint_val = OpExpectKHR %uint %uint_1 %uint_2 ; a bad expectation %v2bool_val = OpExpectKHR %v2bool %null_v2bool %null_v2bool %v2uint_val = OpExpectKHR %v2uint %null_v2uint %null_v2uint OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateSpvExpectAssumeKHR, RequiresExtension) { const std::string str = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpCapability ExpectAssumeKHR OpMemoryModel Physical32 OpenCL %void = OpTypeVoid %voidfn = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %undef = OpUndef %bool %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %main = OpFunction %void None %voidfn %entry = OpLabel OpAssumeTrueKHR %true OpAssumeTrueKHR %undef ; probably undefined behaviour %val = OpExpectKHR %uint %uint_1 %uint_2 ; a bad expectation OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str()); EXPECT_NE(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Capability: operand ExpectAssumeKHR(5629) requires " "one of these extensions: SPV_KHR_expect_assume")); } TEST_F(ValidateSpvExpectAssumeKHR, AssumeTrueKHR_RequiresExpectAssumeCapability) { const std::string str = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpExtension "SPV_KHR_expect_assume" OpMemoryModel Physical32 OpenCL %void = OpTypeVoid %voidfn = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %undef = OpUndef %bool %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %main = OpFunction %void None %voidfn %entry = OpLabel OpAssumeTrueKHR %true OpAssumeTrueKHR %undef ; probably undefined behaviour OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str()); EXPECT_NE(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Opcode AssumeTrueKHR requires one of these " "capabilities: ExpectAssumeKHR \n" " OpAssumeTrueKHR %true\n")); } TEST_F(ValidateSpvExpectAssumeKHR, AssumeTrueKHR_OperandMustBeBool) { const std::string str = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpCapability ExpectAssumeKHR OpExtension "SPV_KHR_expect_assume" OpMemoryModel Physical32 OpenCL %void = OpTypeVoid %voidfn = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %undef = OpUndef %bool %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %main = OpFunction %void None %voidfn %entry = OpLabel OpAssumeTrueKHR %uint_1 ; bad type OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str()); EXPECT_NE(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Value operand of OpAssumeTrueKHR must be a boolean scalar\n" " OpAssumeTrueKHR %uint_1\n")); } TEST_F(ValidateSpvExpectAssumeKHR, ExpectKHR_RequiresExpectAssumeCapability) { const std::string str = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpExtension "SPV_KHR_expect_assume" OpMemoryModel Physical32 OpenCL %void = OpTypeVoid %voidfn = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool %undef = OpUndef %bool %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %main = OpFunction %void None %voidfn %entry = OpLabel %val = OpExpectKHR %uint %uint_1 %uint_2 ; a bad expectation OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str()); EXPECT_NE(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Opcode ExpectKHR requires one of these capabilities: " "ExpectAssumeKHR \n" " %11 = OpExpectKHR %uint %uint_1 %uint_2\n")); } TEST_F(ValidateSpvExpectAssumeKHR, ExpectKHR_ResultMustBeBoolOrIntScalar) { const std::string str = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpCapability ExpectAssumeKHR OpExtension "SPV_KHR_expect_assume" OpMemoryModel Physical32 OpenCL %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %main = OpFunction %void None %voidfn %entry = OpLabel %val = OpExpectKHR %float %float_0 %float_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str()); EXPECT_NE(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Result of OpExpectKHR must be a scalar or vector of " "integer type or boolean type\n" " %7 = OpExpectKHR %float %float_0 %float_0\n")); } TEST_F(ValidateSpvExpectAssumeKHR, ExpectKHR_Value0MustMatchResultType) { const std::string str = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpCapability ExpectAssumeKHR OpExtension "SPV_KHR_expect_assume" OpMemoryModel Physical32 OpenCL %void = OpTypeVoid %voidfn = OpTypeFunction %void %uint = OpTypeInt 32 0 %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %main = OpFunction %void None %voidfn %entry = OpLabel %val = OpExpectKHR %uint %float_0 %float_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str()); EXPECT_NE(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Type of Value operand of OpExpectKHR does not match " "the result type \n" " %8 = OpExpectKHR %uint %float_0 %float_0\n")); } TEST_F(ValidateSpvExpectAssumeKHR, ExpectKHR_Value1MustMatchResultType) { const std::string str = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpCapability ExpectAssumeKHR OpExtension "SPV_KHR_expect_assume" OpMemoryModel Physical32 OpenCL %void = OpTypeVoid %voidfn = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %main = OpFunction %void None %voidfn %entry = OpLabel %val = OpExpectKHR %uint %uint_0 %float_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str()); EXPECT_NE(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Type of ExpectedValue operand of OpExpectKHR does not " "match the result type \n" " %9 = OpExpectKHR %uint %uint_0 %float_0\n")); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_extension_spv_khr_integer_dot_product_test.cpp000066400000000000000000001471501475742701700326020ustar00rootroot00000000000000// Copyright (c) 2020 Google Inc. // Copyright (c) 2021 Arm Ltd. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include "gmock/gmock.h" #include "source/extensions.h" #include "source/spirv_target_env.h" #include "test/unit_spirv.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::HasSubstr; using ::testing::Values; struct Case { std::vector caps; std::string inst; std::string result_type; std::string op0_type; std::string op1_type; std::string acc_type; // can be empty bool packed; std::string expected_error; // empty for no error. }; inline std::ostream& operator<<(std::ostream& out, Case c) { out << "\nSPV_KHR_integer_dot_product Case{{"; bool first = true; for (const auto& cap : c.caps) { if (!first) { out << " "; } first = false; out << cap; } out << "} "; out << c.inst << " "; out << c.result_type << " "; out << c.op0_type << " "; out << c.op1_type << " "; out << "'" << c.acc_type << "' "; out << (c.packed ? "packed " : "unpacked "); out << "err'" << c.expected_error << "'"; return out; } std::string AssemblyForCase(const Case& c) { std::ostringstream ss; ss << "OpCapability Shader\n"; for (auto& cap : c.caps) { ss << "OpCapability " << cap << "\n"; } ss << R"( OpExtension "SPV_KHR_integer_dot_product" OpMemoryModel Logical Simple OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %voidfn = OpTypeFunction %void %uint = OpTypeInt 32 0 %int = OpTypeInt 32 1 %v2uint = OpTypeVector %uint 2 %v3uint = OpTypeVector %uint 3 %v4uint = OpTypeVector %uint 4 %v2int = OpTypeVector %int 2 %v3int = OpTypeVector %int 3 %v4int = OpTypeVector %int 4 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %v2uint_0 = OpConstantComposite %v2uint %uint_0 %uint_0 %v2uint_1 = OpConstantComposite %v2uint %uint_1 %uint_1 %v3uint_0 = OpConstantComposite %v3uint %uint_0 %uint_0 %uint_0 %v3uint_1 = OpConstantComposite %v3uint %uint_1 %uint_1 %uint_1 %v4uint_0 = OpConstantComposite %v4uint %uint_0 %uint_0 %uint_0 %uint_0 %v4uint_1 = OpConstantComposite %v4uint %uint_1 %uint_1 %uint_1 %uint_1 %v2int_0 = OpConstantComposite %v2int %int_0 %int_0 %v2int_1 = OpConstantComposite %v2int %int_1 %int_1 %v3int_0 = OpConstantComposite %v3int %int_0 %int_0 %int_0 %v3int_1 = OpConstantComposite %v3int %int_1 %int_1 %int_1 %v4int_0 = OpConstantComposite %v4int %int_0 %int_0 %int_0 %int_0 %v4int_1 = OpConstantComposite %v4int %int_1 %int_1 %int_1 %int_1 )"; bool use8bit = false; for (auto& cap : c.caps) { if (cap == "DotProductInput4x8BitKHR") { use8bit = true; } if (cap == "Int8") { use8bit = true; } } if (use8bit) { ss << R"( %uchar = OpTypeInt 8 0 %char = OpTypeInt 8 1 %v4uchar = OpTypeVector %uchar 4 %v4char = OpTypeVector %char 4 %uchar_0 = OpConstant %uchar 0 %uchar_1 = OpConstant %uchar 1 %char_0 = OpConstant %char 0 %char_1 = OpConstant %char 1 %v4uchar_0 = OpConstantComposite %v4uchar %uchar_0 %uchar_0 %uchar_0 %uchar_0 %v4uchar_1 = OpConstantComposite %v4uchar %uchar_1 %uchar_1 %uchar_1 %uchar_1 %v4char_0 = OpConstantComposite %v4char %char_0 %char_0 %char_0 %char_0 %v4char_1 = OpConstantComposite %v4char %char_1 %char_1 %char_1 %char_1 )"; } ss << R"( %main = OpFunction %void None %voidfn %entry = OpLabel %result = )" << c.inst << " " << c.result_type << " "; ss << c.op0_type << "_0 "; ss << c.op1_type << "_1 "; if (!c.acc_type.empty()) { ss << c.acc_type << "_0 "; } if (c.packed) { ss << "PackedVectorFormat4x8BitKHR"; } ss << "\nOpReturn\nOpFunctionEnd\n\n"; return ss.str(); } using ValidateSpvKHRIntegerDotProduct = spvtest::ValidateBase; TEST_P(ValidateSpvKHRIntegerDotProduct, Valid) { const auto& c = GetParam(); const auto& assembly = AssemblyForCase(c); CompileSuccessfully(assembly); if (c.expected_error.empty()) { EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()) << getDiagnosticString(); } else { EXPECT_NE(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(c.expected_error)); } } // UDot INSTANTIATE_TEST_SUITE_P( Valid_UDot, ValidateSpvKHRIntegerDotProduct, ::testing::Values(Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpUDotKHR", "%uint", "%v2uint", "%v2uint", "", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpUDotKHR", "%uint", "%v3uint", "%v3uint", "", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpUDotKHR", "%uint", "%v4uint", "%v4uint", "", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR", "Int8"}, "OpUDotKHR", "%uchar", // match width "%v4uchar", "%v4uchar", "", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR", "Int8"}, "OpUDotKHR", "%uint", // wider width "%v4uchar", "%v4uchar", "", false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitKHR"}, "OpUDotKHR", "%uchar", // match width "%v4uchar", "%v4uchar", "", false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitKHR"}, "OpUDotKHR", "%uint", // wider width "%v4uchar", "%v4uchar", "", false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitPackedKHR", "Int8"}, "OpUDotKHR", "%uchar", // matches packed component type "%uint", "%uint", "", true, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitPackedKHR"}, "OpUDotKHR", "%uint", "%uint", "%uint", "", true, ""})); // SDot result signed args signed signed INSTANTIATE_TEST_SUITE_P( Valid_SDot_signed_signed_signed, ValidateSpvKHRIntegerDotProduct, ::testing::Values(Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpSDotKHR", "%int", "%v2int", "%v2int", "", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpSDotKHR", "%int", "%v3int", "%v3int", "", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpSDotKHR", "%int", "%v4int", "%v4int", "", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR", "Int8"}, "OpSDotKHR", "%char", // match width "%v4char", "%v4char", "", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR", "Int8"}, "OpSDotKHR", "%int", // wider width "%v4char", "%v4char", "", false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitKHR"}, "OpSDotKHR", "%char", // match width "%v4char", "%v4char", "", false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitKHR"}, "OpSDotKHR", "%int", // wider width "%v4char", "%v4char", "", false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitPackedKHR", "Int8"}, "OpSDotKHR", "%char", // matches packed component type "%int", "%int", "", true, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitPackedKHR"}, "OpSDotKHR", "%int", "%int", "%int", "", true, ""})); // SDot result unsigned args signed unsigned INSTANTIATE_TEST_SUITE_P( Valid_SDot_unsigned_signed_unsigned, ValidateSpvKHRIntegerDotProduct, ::testing::Values(Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpSDotKHR", "%uint", "%v2int", "%v2uint", "", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpSDotKHR", "%uint", "%v3int", "%v3uint", "", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpSDotKHR", "%uint", "%v4int", "%v4uint", "", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR", "Int8"}, "OpSDotKHR", "%uchar", // match width "%v4char", "%v4uchar", "", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR", "Int8"}, "OpSDotKHR", "%uint", // wider width "%v4char", "%v4uchar", "", false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitKHR"}, "OpSDotKHR", "%uchar", // match width "%v4char", "%v4uchar", "", false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitKHR"}, "OpSDotKHR", "%uint", // wider width "%v4char", "%v4uchar", "", false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitPackedKHR", "Int8"}, "OpSDotKHR", "%uchar", // matches packed component type "%int", "%uint", "", true, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitPackedKHR"}, "OpSDotKHR", "%uint", "%int", "%uint", "", true, ""})); // SDot result signed args signed unsigned INSTANTIATE_TEST_SUITE_P( Valid_SDot_signed_signed_unsigned, ValidateSpvKHRIntegerDotProduct, ::testing::Values(Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpSDotKHR", "%int", "%v2int", "%v2uint", "", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpSDotKHR", "%int", "%v3int", "%v3uint", "", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpSDotKHR", "%int", "%v4int", "%v4uint", "", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR", "Int8"}, "OpSDotKHR", "%char", // match width "%v4char", "%v4uchar", "", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR", "Int8"}, "OpSDotKHR", "%int", // wider width "%v4char", "%v4uchar", "", false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitKHR"}, "OpSDotKHR", "%char", // match width "%v4char", "%v4uchar", "", false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitKHR"}, "OpSDotKHR", "%int", // wider width "%v4char", "%v4uchar", "", false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitPackedKHR", "Int8"}, "OpSDotKHR", "%char", // matches packed component type "%int", "%uint", "", true, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitPackedKHR"}, "OpSDotKHR", "%int", "%int", "%uint", "", true, ""})); // SUDot result signed args unsigned unsigned INSTANTIATE_TEST_SUITE_P( Valid_SUDot_signed_unsigned_unsigned, ValidateSpvKHRIntegerDotProduct, ::testing::Values(Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpSUDotKHR", "%int", "%v2uint", "%v2uint", "", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpSUDotKHR", "%int", "%v3uint", "%v3uint", "", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpSUDotKHR", "%int", "%v4uint", "%v4uint", "", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR", "Int8"}, "OpSUDotKHR", "%char", // match width "%v4uchar", "%v4uchar", "", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR", "Int8"}, "OpSUDotKHR", "%int", // wider width "%v4uchar", "%v4uchar", "", false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitKHR"}, "OpSUDotKHR", "%char", // match width "%v4uchar", "%v4uchar", "", false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitKHR"}, "OpSUDotKHR", "%int", // wider width "%v4uchar", "%v4uchar", "", false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitPackedKHR", "Int8"}, "OpSUDotKHR", "%char", // matches packed component type "%uint", "%uint", "", true, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitPackedKHR"}, "OpSUDotKHR", "%int", "%uint", "%uint", "", true, ""})); // SUDot result signed args signed unsigned INSTANTIATE_TEST_SUITE_P( Valid_SUDot_signed_signed_unsigned, ValidateSpvKHRIntegerDotProduct, ::testing::Values(Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpSUDotKHR", "%int", "%v2int", "%v2uint", "", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpSUDotKHR", "%int", "%v3int", "%v3uint", "", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpSUDotKHR", "%int", "%v4int", "%v4uint", "", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR", "Int8"}, "OpSUDotKHR", "%char", // match width "%v4char", "%v4uchar", "", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR", "Int8"}, "OpSUDotKHR", "%int", // wider width "%v4char", "%v4uchar", "", false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitKHR"}, "OpSUDotKHR", "%char", // match width "%v4char", "%v4uchar", "", false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitKHR"}, "OpSUDotKHR", "%int", // wider width "%v4char", "%v4uchar", "", false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitPackedKHR", "Int8"}, "OpSUDotKHR", "%char", // matches packed component type "%int", "%uint", "", true, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitPackedKHR"}, "OpSUDotKHR", "%int", "%int", "%uint", "", true, ""})); // SUDot result unsigned args unsigned unsigned INSTANTIATE_TEST_SUITE_P( Valid_SUDot_unsigned_unsigned_unsigned, ValidateSpvKHRIntegerDotProduct, ::testing::Values(Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpSUDotKHR", "%uint", "%v2uint", "%v2uint", "", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpSUDotKHR", "%uint", "%v3uint", "%v3uint", "", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpSUDotKHR", "%uint", "%v4uint", "%v4uint", "", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR", "Int8"}, "OpSUDotKHR", "%uchar", // match width "%v4uchar", "%v4uchar", "", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR", "Int8"}, "OpSUDotKHR", "%uint", // wider width "%v4uchar", "%v4uchar", "", false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitKHR"}, "OpSUDotKHR", "%uchar", // match width "%v4uchar", "%v4uchar", "", false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitKHR"}, "OpSUDotKHR", "%uint", // wider width "%v4uchar", "%v4uchar", "", false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitPackedKHR", "Int8"}, "OpSUDotKHR", "%uchar", // matches packed component type "%uint", "%uint", "", true, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitPackedKHR"}, "OpSUDotKHR", "%uint", "%uint", "%uint", "", true, ""})); // UDotAccSat INSTANTIATE_TEST_SUITE_P( Valid_UDotAccSat, ValidateSpvKHRIntegerDotProduct, ::testing::Values(Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpUDotAccSatKHR", "%uint", "%v2uint", "%v2uint", "%uint", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpUDotAccSatKHR", "%uint", "%v3uint", "%v3uint", "%uint", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpUDotAccSatKHR", "%uint", "%v4uint", "%v4uint", "%uint", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR", "Int8"}, "OpUDotAccSatKHR", "%uchar", // match width "%v4uchar", "%v4uchar", "%uint", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR", "Int8"}, "OpUDotAccSatKHR", "%uint", // wider width "%v4uchar", "%v4uchar", "%uint", false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitKHR"}, "OpUDotAccSatKHR", "%uchar", // match width "%v4uchar", "%v4uchar", "%uchar", false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitKHR"}, "OpUDotAccSatKHR", "%uint", // wider width "%v4uchar", "%v4uchar", "%uint", false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitPackedKHR", "Int8"}, "OpUDotAccSatKHR", "%uchar", // matches packed component type "%uint", "%uint", "%uchar", true, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitPackedKHR"}, "OpUDotAccSatKHR", "%uint", "%uint", "%uint", "%uint", true, ""})); // SDotAccSat result signed args signed signed INSTANTIATE_TEST_SUITE_P( Valid_SDotAccSat_signed_signed_signed, ValidateSpvKHRIntegerDotProduct, ::testing::Values(Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpSDotAccSatKHR", "%int", "%v2int", "%v2int", "%int", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpSDotAccSatKHR", "%int", "%v3int", "%v3int", "%int", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpSDotAccSatKHR", "%int", "%v4int", "%v4int", "%int", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR", "Int8"}, "OpSDotAccSatKHR", "%char", // match width "%v4char", "%v4char", "%char", // match width false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR", "Int8"}, "OpSDotAccSatKHR", "%int", // wider width "%v4char", "%v4char", "%int", // wider width false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitKHR"}, "OpSDotAccSatKHR", "%char", // match width "%v4char", "%v4char", "%char", // match width false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitKHR"}, "OpSDotAccSatKHR", "%int", // wider width "%v4char", "%v4char", "%int", // wider width false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitPackedKHR", "Int8"}, "OpSDotAccSatKHR", "%char", // matches packed component type "%int", "%int", "%char", // matches packed component type true, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitPackedKHR"}, "OpSDotAccSatKHR", "%int", "%int", "%int", "%int", true, ""})); // SDotAccSat result unsigned args signed unsigned INSTANTIATE_TEST_SUITE_P( Valid_SDotAccSat_unsigned_signed_unsigned, ValidateSpvKHRIntegerDotProduct, ::testing::Values(Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpSDotAccSatKHR", "%uint", "%v2int", "%v2uint", "%uint", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpSDotAccSatKHR", "%uint", "%v3int", "%v3uint", "%uint", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpSDotAccSatKHR", "%uint", "%v4int", "%v4uint", "%uint", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR", "Int8"}, "OpSDotAccSatKHR", "%uchar", // match width "%v4char", "%v4uchar", "%uchar", // match width false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR", "Int8"}, "OpSDotAccSatKHR", "%uint", // wider width "%v4char", "%v4uchar", "%uint", // wider width false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitKHR"}, "OpSDotAccSatKHR", "%uchar", // match width "%v4char", "%v4uchar", "%uchar", // match width false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitKHR"}, "OpSDotAccSatKHR", "%uint", // wider width "%v4char", "%v4uchar", "%uint", // wider width false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitPackedKHR", "Int8"}, "OpSDotAccSatKHR", "%uchar", // matches packed component type "%int", "%uint", "%uchar", // matches packed component type true, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitPackedKHR"}, "OpSDotAccSatKHR", "%uint", "%int", "%uint", "%uint", true, ""})); // SDotAccSat result signed args signed unsigned INSTANTIATE_TEST_SUITE_P( Valid_SDotAccSat_signed_signed_unsigned, ValidateSpvKHRIntegerDotProduct, ::testing::Values(Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpSDotAccSatKHR", "%int", "%v2int", "%v2uint", "%int", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpSDotAccSatKHR", "%int", "%v3int", "%v3uint", "%int", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpSDotAccSatKHR", "%int", "%v4int", "%v4uint", "%int", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR", "Int8"}, "OpSDotAccSatKHR", "%char", // match width "%v4char", "%v4uchar", "%char", // match width false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR", "Int8"}, "OpSDotAccSatKHR", "%int", // wider width "%v4char", "%v4uchar", "%int", // wider width false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitKHR"}, "OpSDotAccSatKHR", "%char", // match width "%v4char", "%v4uchar", "%char", // match width false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitKHR"}, "OpSDotAccSatKHR", "%int", // wider width "%v4char", "%v4uchar", "%int", // wider width false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitPackedKHR", "Int8"}, "OpSDotAccSatKHR", "%char", // matches packed component type "%int", "%uint", "%char", // matches packed component type true, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitPackedKHR"}, "OpSDotAccSatKHR", "%int", "%int", "%uint", "%int", true, ""})); // SUDotAccSat result signed args unsigned unsigned INSTANTIATE_TEST_SUITE_P( Valid_SUDotAccSat_signed_unsigned_unsigned, ValidateSpvKHRIntegerDotProduct, ::testing::Values(Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpSUDotAccSatKHR", "%int", "%v2uint", "%v2uint", "%int", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpSUDotAccSatKHR", "%int", "%v3uint", "%v3uint", "%int", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpSUDotAccSatKHR", "%int", "%v4uint", "%v4uint", "%int", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR", "Int8"}, "OpSUDotAccSatKHR", "%char", // match width "%v4uchar", "%v4uchar", "%char", // match width false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR", "Int8"}, "OpSUDotAccSatKHR", "%int", // wider width "%v4uchar", "%v4uchar", "%int", // wider width false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitKHR"}, "OpSUDotAccSatKHR", "%char", // match width "%v4uchar", "%v4uchar", "%char", // match width false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitKHR"}, "OpSUDotAccSatKHR", "%int", // wider width "%v4uchar", "%v4uchar", "%int", // wider width false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitPackedKHR", "Int8"}, "OpSUDotAccSatKHR", "%char", // matches packed component type "%uint", "%uint", "%char", // matches packed component type true, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitPackedKHR"}, "OpSUDotAccSatKHR", "%int", "%uint", "%uint", "%int", true, ""})); // SUDotAccSat result signed args signed unsigned INSTANTIATE_TEST_SUITE_P( Valid_SUDotAccSat_signed_signed_unsigned, ValidateSpvKHRIntegerDotProduct, ::testing::Values(Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpSUDotAccSatKHR", "%int", "%v2int", "%v2uint", "%int", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpSUDotAccSatKHR", "%int", "%v3int", "%v3uint", "%int", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpSUDotAccSatKHR", "%int", "%v4int", "%v4uint", "%int", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR", "Int8"}, "OpSUDotAccSatKHR", "%char", // match width "%v4char", "%v4uchar", "%char", // match width false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR", "Int8"}, "OpSUDotAccSatKHR", "%int", // wider width "%v4char", "%v4uchar", "%int", // wider width false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitKHR"}, "OpSUDotAccSatKHR", "%char", // match width "%v4char", "%v4uchar", "%char", // match width false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitKHR"}, "OpSUDotAccSatKHR", "%int", // wider width "%v4char", "%v4uchar", "%int", // wider width false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitPackedKHR", "Int8"}, "OpSUDotAccSatKHR", "%char", // matches packed component type "%int", "%uint", "%char", // matches packed component type true, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitPackedKHR"}, "OpSUDotAccSatKHR", "%int", "%int", "%uint", "%int", true, ""})); // SUDotAccSat result unsigned args unsigned unsigned INSTANTIATE_TEST_SUITE_P( Valid_SUDotAccSat_unsigned_unsigned_unsigned, ValidateSpvKHRIntegerDotProduct, ::testing::Values(Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpSUDotAccSatKHR", "%uint", "%v2uint", "%v2uint", "%uint", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpSUDotAccSatKHR", "%uint", "%v3uint", "%v3uint", "%uint", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR"}, "OpSUDotAccSatKHR", "%uint", "%v4uint", "%v4uint", "%uint", false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR", "Int8"}, "OpSUDotAccSatKHR", "%uchar", // match width "%v4uchar", "%v4uchar", "%uchar", // match width false, ""}, Case{{"DotProductKHR", "DotProductInputAllKHR", "Int8"}, "OpSUDotAccSatKHR", "%uint", // wider width "%v4uchar", "%v4uchar", "%uint", // wider width false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitKHR"}, "OpSUDotAccSatKHR", "%uchar", // match width "%v4uchar", "%v4uchar", "%uchar", // match width false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitKHR"}, "OpSUDotAccSatKHR", "%uint", // wider width "%v4uchar", "%v4uchar", "%uint", // wider width false, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitPackedKHR", "Int8"}, "OpSUDotAccSatKHR", "%uchar", // matches packed component type "%uint", "%uint", "%uchar", // matches packed component type true, ""}, Case{{"DotProductKHR", "DotProductInput4x8BitPackedKHR"}, "OpSUDotAccSatKHR", "%uint", "%uint", "%uint", "%uint", true, ""})); using ValidateSpvKHRIntegerDotProductSimple = ::testing::Test; TEST(ValidateSpvKHRIntegerDotProductSimple, DISABLED_RequiresExtension) { FAIL(); } TEST(ValidateSpvKHRIntegerDotProductSimple, DISABLED_Invalid_ResultTooNarrow) { // Test across all the instructions. FAIL(); } TEST(ValidateSpvKHRIntegerDotProductSimple, DISABLED_Invalid_UDot_OperandTypesMatch) { FAIL(); } TEST(ValidateSpvKHRIntegerDotProductSimple, DISABLED_Invalid_SDot_OperandTypesMatchExceptSignedness) { FAIL(); } TEST(ValidateSpvKHRIntegerDotProductSimple, DISABLED_Invalid_SUDot_OperandTypesMatchExceptSignedness) { FAIL(); } TEST(ValidateSpvKHRIntegerDotProductSimple, DISABLED_Invalid_UDotAccSat_OperandTypesMatch) { FAIL(); } TEST(ValidateSpvKHRIntegerDotProductSimple, DISABLED_Invalid_SDotAccSat_OperandTypesMatchExceptSignedness) { FAIL(); } TEST(ValidateSpvKHRIntegerDotProductSimple, DISABLED_Invalid_SUDotAccSat_OperandTypesMatchExceptSignedness) { FAIL(); } TEST(ValidateSpvKHRIntegerDotProductSimple, DISABLED_Invalid_UDot_RequiresUnsigned) { FAIL(); } TEST(ValidateSpvKHRIntegerDotProductSimple, DISABLED_Invalid_SUDot_RequiresUnsignedSecondArg) { FAIL(); } TEST(ValidateSpvKHRIntegerDotProductSimple, DISABLED_Invalid_UDotAccSat_RequiresUnsigned) { FAIL(); } TEST(ValidateSpvKHRIntegerDotProductSimple, DISABLED_Invalid_SUDotAccSat_RequiresUnsignedSecondArg) { FAIL(); } TEST(ValidateSpvKHRIntegerDotProductSimple, DISABLED_Invalid_VectorOperandsDisallowPackedFormat) { FAIL(); } TEST(ValidateSpvKHRIntegerDotProductSimple, DISABLED_Invalid_ScalarOperandsRequirePackedFormat) { FAIL(); } // TODO(dneto): Test valid cases with other scalar integer types // TODO(dneto): Test valid cases of length-8 vectors // TODO(dneto): Test valid cases of length-16 vectors } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_extension_spv_khr_linkonce_odr_test.cpp000066400000000000000000000056461475742701700312100ustar00rootroot00000000000000// Copyright (c) 2020 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Tests for OpExtension validator rules. #include #include #include "gmock/gmock.h" #include "source/spirv_target_env.h" #include "test/unit_spirv.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::HasSubstr; using ::testing::Values; using ::testing::ValuesIn; using ValidateSpvKHRLinkOnceODR = spvtest::ValidateBase; TEST_F(ValidateSpvKHRLinkOnceODR, Valid) { const std::string str = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpExtension "SPV_KHR_linkonce_odr" OpMemoryModel Physical32 OpenCL OpDecorate %var LinkageAttributes "foobar" LinkOnceODR %uint = OpTypeInt 32 0 %ptr = OpTypePointer CrossWorkgroup %uint %var = OpVariable %ptr CrossWorkgroup )"; CompileSuccessfully(str.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateSpvKHRLinkOnceODR, RequiresExtension) { const std::string str = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Physical32 OpenCL OpDecorate %var LinkageAttributes "foobar" LinkOnceODR %uint = OpTypeInt 32 0 %ptr = OpTypePointer CrossWorkgroup %uint %var = OpVariable %ptr CrossWorkgroup )"; CompileSuccessfully(str.c_str()); EXPECT_NE(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("4th operand of Decorate: operand LinkOnceODR(2) requires one " "of these extensions: SPV_KHR_linkonce_odr \n" " OpDecorate %1 LinkageAttributes \"foobar\" LinkOnceODR\n")); } TEST_F(ValidateSpvKHRLinkOnceODR, RequiresLinkageCapability) { const std::string str = R"( OpCapability Kernel OpCapability Addresses OpExtension "SPV_KHR_linkonce_odr" OpMemoryModel Physical32 OpenCL OpDecorate %var LinkageAttributes "foobar" LinkOnceODR %uint = OpTypeInt 32 0 %ptr = OpTypePointer CrossWorkgroup %uint %var = OpVariable %ptr CrossWorkgroup )"; CompileSuccessfully(str.c_str()); EXPECT_NE(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Operand 2 of Decorate requires one of these capabilities: Linkage \n" " OpDecorate %1 LinkageAttributes \"foobar\" LinkOnceODR")); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_extension_spv_khr_subgroup_rotate_test.cpp000066400000000000000000000251321475742701700317560ustar00rootroot00000000000000// Copyright (c) 2022 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gmock/gmock.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::HasSubstr; using ::testing::Values; using ::testing::ValuesIn; struct Case { std::vector caps; bool shader; std::string result_type; std::string scope; std::string delta; std::string cluster_size; std::string expected_error; // empty for no error. }; inline std::ostream& operator<<(std::ostream& out, Case c) { out << "\nSPV_KHR_subgroup_rotate Case{{"; for (auto& cap : c.caps) { out << cap; } out << "} "; out << (c.shader ? "shader " : "kernel "); out << c.result_type + " "; out << c.scope + " "; out << c.delta + " "; out << c.cluster_size + " "; out << "err'" << c.expected_error << "'"; out << "}"; return out; } std::string AssemblyForCase(const Case& c) { std::ostringstream ss; if (c.shader) { ss << "OpCapability Shader\n"; } else { ss << "OpCapability Kernel\n"; ss << "OpCapability Addresses\n"; } for (auto& cap : c.caps) { ss << "OpCapability " << cap << "\n"; } ss << "OpExtension \"SPV_KHR_subgroup_rotate\"\n"; if (c.shader) { ss << "OpMemoryModel Logical GLSL450\n"; ss << "OpEntryPoint GLCompute %main \"main\"\n"; } else { ss << "OpMemoryModel Physical32 OpenCL\n"; ss << "OpEntryPoint Kernel %main \"main\"\n"; } ss << R"( %void = OpTypeVoid %void_fn = OpTypeFunction %void %u32 = OpTypeInt 32 0 %float = OpTypeFloat 32 %ptr = OpTypePointer Function %u32 )"; if (c.shader) { ss << "%i32 = OpTypeInt 32 1\n"; } ss << R"( %u32_0 = OpConstant %u32 0 %u32_1 = OpConstant %u32 1 %u32_15 = OpConstant %u32 15 %u32_16 = OpConstant %u32 16 %u32_undef = OpUndef %u32 %u32_spec_1 = OpSpecConstant %u32 1 %u32_spec_16 = OpSpecConstant %u32 16 %f32_1 = OpConstant %float 1.0 %subgroup = OpConstant %u32 3 %workgroup = OpConstant %u32 2 %invalid_scope = OpConstant %u32 1 %val = OpConstant %u32 42 )"; if (c.shader) { ss << "%i32_1 = OpConstant %i32 1\n"; } ss << R"( %main = OpFunction %void None %void_fn %entry = OpLabel )"; ss << "%unused = OpGroupNonUniformRotateKHR "; ss << c.result_type + " "; ss << c.scope; ss << " %val "; ss << c.delta; ss << " " + c.cluster_size; ss << "\n"; ss << R"( OpReturn OpFunctionEnd )"; return ss.str(); } using ValidateSpvKHRSubgroupRotate = spvtest::ValidateBase; TEST_P(ValidateSpvKHRSubgroupRotate, Base) { const auto& c = GetParam(); const auto& assembly = AssemblyForCase(c); CompileSuccessfully(assembly); if (c.expected_error.empty()) { EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()) << getDiagnosticString(); } else { EXPECT_NE(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(c.expected_error)); } } INSTANTIATE_TEST_SUITE_P( Valid, ValidateSpvKHRSubgroupRotate, ::testing::Values( Case{ {"GroupNonUniformRotateKHR"}, false, "%u32", "%subgroup", "%u32_1"}, Case{{"GroupNonUniformRotateKHR"}, true, "%u32", "%subgroup", "%u32_1"}, Case{{"GroupNonUniformRotateKHR"}, false, "%u32", "%subgroup", "%u32_1", "%u32_16"}, Case{{"GroupNonUniformRotateKHR"}, true, "%u32", "%subgroup", "%u32_1", "%u32_16"}, Case{{"GroupNonUniformRotateKHR"}, false, "%u32", "%subgroup", "%u32_spec_1", "%u32_16"}, Case{{"GroupNonUniformRotateKHR"}, true, "%u32", "%subgroup", "%u32_1", "%u32_spec_16"}, Case{{"GroupNonUniformRotateKHR"}, false, "%u32", "%workgroup", "%u32_1"}, Case{ {"GroupNonUniformRotateKHR"}, true, "%u32", "%workgroup", "%u32_1"}, Case{{"GroupNonUniformRotateKHR"}, false, "%u32", "%workgroup", "%u32_spec_1"}, Case{{"GroupNonUniformRotateKHR"}, true, "%u32", "%workgroup", "%u32_spec_1"})); INSTANTIATE_TEST_SUITE_P( RequiresCapability, ValidateSpvKHRSubgroupRotate, ::testing::Values(Case{{}, false, "%u32", "%subgroup", "%u32_1", "", "Opcode GroupNonUniformRotateKHR requires one of " "these capabilities: " "GroupNonUniformRotateKHR"}, Case{{}, true, "%u32", "%subgroup", "%u32_1", "", "Opcode GroupNonUniformRotateKHR requires one of " "these capabilities: " "GroupNonUniformRotateKHR"})); TEST_F(ValidateSpvKHRSubgroupRotate, RequiresExtension) { const std::string str = R"( OpCapability GroupNonUniformRotateKHR )"; CompileSuccessfully(str.c_str()); EXPECT_NE(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "1st operand of Capability: operand GroupNonUniformRotateKHR(6026) " "requires one of these extensions: SPV_KHR_subgroup_rotate")); } INSTANTIATE_TEST_SUITE_P( InvalidExecutionScope, ValidateSpvKHRSubgroupRotate, ::testing::Values( Case{{"GroupNonUniformRotateKHR"}, false, "%u32", "%invalid_scope", "%u32_1", "", "Execution scope is limited to Subgroup or Workgroup"}, Case{{"GroupNonUniformRotateKHR"}, true, "%u32", "%invalid_scope", "%u32_1", "", "Execution scope is limited to Subgroup or Workgroup"})); INSTANTIATE_TEST_SUITE_P( InvalidResultType, ValidateSpvKHRSubgroupRotate, ::testing::Values(Case{{"GroupNonUniformRotateKHR"}, false, "%ptr", "%subgroup", "%u32_1", "", "Expected Result Type to be a scalar or vector of " "floating-point, integer or boolean type"}, Case{{"GroupNonUniformRotateKHR"}, true, "%ptr", "%subgroup", "%u32_1", "", "Expected Result Type to be a scalar or vector of " "floating-point, integer or boolean type"})); INSTANTIATE_TEST_SUITE_P( MismatchedResultAndValueTypes, ValidateSpvKHRSubgroupRotate, ::testing::Values( Case{{"GroupNonUniformRotateKHR"}, false, "%float", "%subgroup", "%u32_1", "", "Result Type must be the same as the type of Value"}, Case{{"GroupNonUniformRotateKHR"}, true, "%float", "%subgroup", "%u32_1", "", "Result Type must be the same as the type of Value"})); INSTANTIATE_TEST_SUITE_P( InvalidDelta, ValidateSpvKHRSubgroupRotate, ::testing::Values(Case{{"GroupNonUniformRotateKHR"}, false, "%u32", "%subgroup", "%f32_1", "", "Delta must be a scalar of integer type, whose " "Signedness operand is 0"}, Case{{"GroupNonUniformRotateKHR"}, true, "%u32", "%subgroup", "%f32_1", "", "Delta must be a scalar of integer type, whose " "Signedness operand is 0"}, Case{{"GroupNonUniformRotateKHR"}, true, "%u32", "%subgroup", "%i32_1", "", "Delta must be a scalar of integer type, whose " "Signedness operand is 0"})); INSTANTIATE_TEST_SUITE_P( InvalidClusterSize, ValidateSpvKHRSubgroupRotate, ::testing::Values( Case{{"GroupNonUniformRotateKHR"}, false, "%u32", "%subgroup", "%u32_1", "%f32_1", "ClusterSize must be a scalar of integer type, whose Signedness " "operand is 0"}, Case{{"GroupNonUniformRotateKHR"}, true, "%u32", "%subgroup", "%u32_1", "%i32_1", "ClusterSize must be a scalar of integer type, whose Signedness " "operand is 0"}, Case{{"GroupNonUniformRotateKHR"}, true, "%u32", "%subgroup", "%u32_1", "%u32_0", "Behavior is undefined unless ClusterSize is at least 1 and a " "power of 2"}, Case{{"GroupNonUniformRotateKHR"}, true, "%u32", "%subgroup", "%u32_1", "%u32_15", "Behavior is undefined unless ClusterSize is at least 1 and a " "power of 2"}, Case{{"GroupNonUniformRotateKHR"}, true, "%u32", "%subgroup", "%u32_1", "%u32_undef", "ClusterSize must come from a constant instruction"})); } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_extension_spv_khr_subgroup_uniform_control_flow.cpp000066400000000000000000000064561475742701700336770ustar00rootroot00000000000000// Copyright (c) 2021 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Tests for OpExtension validator rules. #include #include #include "gmock/gmock.h" #include "source/enum_string_mapping.h" #include "source/extensions.h" #include "source/spirv_target_env.h" #include "test/test_fixture.h" #include "test/unit_spirv.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::HasSubstr; using ::testing::Values; using ::testing::ValuesIn; using ValidateSpvKHRSubgroupUniformControlFlow = spvtest::ValidateBase; TEST_F(ValidateSpvKHRSubgroupUniformControlFlow, Valid) { const std::string str = R"( OpCapability Shader OpExtension "SPV_KHR_subgroup_uniform_control_flow" OpMemoryModel Logical Simple OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpExecutionMode %main SubgroupUniformControlFlowKHR %void = OpTypeVoid %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateSpvKHRSubgroupUniformControlFlow, RequiresExtension) { const std::string str = R"( OpCapability Shader OpMemoryModel Logical Simple OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpExecutionMode %main SubgroupUniformControlFlowKHR %void = OpTypeVoid %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str()); EXPECT_NE(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("2nd operand of ExecutionMode: operand " "SubgroupUniformControlFlowKHR(4421) " "requires one of these extensions: " "SPV_KHR_subgroup_uniform_control_flow")); } TEST_F(ValidateSpvKHRSubgroupUniformControlFlow, RequiresShaderCapability) { const std::string str = R"( OpCapability Kernel OpCapability Addresses OpExtension "SPV_KHR_subgroup_uniform_control_flow" OpMemoryModel Physical32 OpenCL OpEntryPoint Kernel %main "main" OpExecutionMode %main SubgroupUniformControlFlowKHR %void = OpTypeVoid %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str()); EXPECT_NE(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Operand 2 of ExecutionMode requires one of these " "capabilities: Shader")); } } // namespace } // namespace val } // namespace spvtools val_extension_spv_khr_subgroup_uniform_control_flow_test.cpp000066400000000000000000000063101475742701700346440ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/val// Copyright (c) 2021 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Tests for OpExtension validator rules. #include #include #include "gmock/gmock.h" #include "source/spirv_target_env.h" #include "test/unit_spirv.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::HasSubstr; using ::testing::Values; using ::testing::ValuesIn; using ValidateSpvKHRSubgroupUniformControlFlow = spvtest::ValidateBase; TEST_F(ValidateSpvKHRSubgroupUniformControlFlow, Valid) { const std::string str = R"( OpCapability Shader OpExtension "SPV_KHR_subgroup_uniform_control_flow" OpMemoryModel Logical Simple OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpExecutionMode %main SubgroupUniformControlFlowKHR %void = OpTypeVoid %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateSpvKHRSubgroupUniformControlFlow, RequiresExtension) { const std::string str = R"( OpCapability Shader OpMemoryModel Logical Simple OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpExecutionMode %main SubgroupUniformControlFlowKHR %void = OpTypeVoid %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str()); EXPECT_NE(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("2nd operand of ExecutionMode: operand " "SubgroupUniformControlFlowKHR(4421) " "requires one of these extensions: " "SPV_KHR_subgroup_uniform_control_flow")); } TEST_F(ValidateSpvKHRSubgroupUniformControlFlow, RequiresShaderCapability) { const std::string str = R"( OpCapability Kernel OpCapability Addresses OpExtension "SPV_KHR_subgroup_uniform_control_flow" OpMemoryModel Physical32 OpenCL OpEntryPoint Kernel %main "main" OpExecutionMode %main SubgroupUniformControlFlowKHR %void = OpTypeVoid %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str()); EXPECT_NE(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Operand 2 of ExecutionMode requires one of these " "capabilities: Shader")); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_extension_spv_khr_terminate_invocation_test.cpp000066400000000000000000000113051475742701700327500ustar00rootroot00000000000000// Copyright (c) 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Tests for OpExtension validator rules. #include #include #include "gmock/gmock.h" #include "source/spirv_target_env.h" #include "test/unit_spirv.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::HasSubstr; using ::testing::Values; using ::testing::ValuesIn; using ValidateSpvKHRTerminateInvocation = spvtest::ValidateBase; TEST_F(ValidateSpvKHRTerminateInvocation, Valid) { const std::string str = R"( OpCapability Shader OpExtension "SPV_KHR_terminate_invocation" OpMemoryModel Logical Simple OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpTerminateInvocation OpFunctionEnd )"; CompileSuccessfully(str.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateSpvKHRTerminateInvocation, RequiresExtensionPre1p6) { const std::string str = R"( OpCapability Shader OpMemoryModel Logical Simple OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpTerminateInvocation OpFunctionEnd )"; CompileSuccessfully(str.c_str()); EXPECT_NE(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "TerminateInvocation requires SPIR-V version 1.6 at minimum or one " "of the following extensions: SPV_KHR_terminate_invocation")); } TEST_F(ValidateSpvKHRTerminateInvocation, RequiresNoExtensionPost1p6) { const std::string str = R"( OpCapability Shader OpMemoryModel Logical Simple OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpTerminateInvocation OpFunctionEnd )"; CompileSuccessfully(str.c_str(), SPV_ENV_UNIVERSAL_1_6); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_6)); } TEST_F(ValidateSpvKHRTerminateInvocation, RequiresShaderCapability) { const std::string str = R"( OpCapability Kernel OpCapability Addresses OpExtension "SPV_KHR_terminate_invocation" OpMemoryModel Physical32 OpenCL OpEntryPoint Kernel %main "main" %void = OpTypeVoid %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpTerminateInvocation OpFunctionEnd )"; CompileSuccessfully(str.c_str()); EXPECT_NE(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "TerminateInvocation requires one of these capabilities: Shader \n")); } TEST_F(ValidateSpvKHRTerminateInvocation, RequiresFragmentShader) { const std::string str = R"( OpCapability Shader OpExtension "SPV_KHR_terminate_invocation" OpMemoryModel Logical Simple OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpTerminateInvocation OpFunctionEnd )"; CompileSuccessfully(str.c_str()); EXPECT_NE(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpTerminateInvocation requires Fragment execution model")); } TEST_F(ValidateSpvKHRTerminateInvocation, IsTerminatorInstruction) { const std::string str = R"( OpCapability Shader OpExtension "SPV_KHR_terminate_invocation" OpMemoryModel Logical Simple OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpTerminateInvocation OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str()); EXPECT_NE(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Return must appear in a block")); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_extension_spv_nv_raw_access_chains.cpp000066400000000000000000000400351475742701700307700ustar00rootroot00000000000000// Copyright (c) 2024 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gmock/gmock.h" #include "source/spirv_target_env.h" #include "test/unit_spirv.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::HasSubstr; using ValidateSpvNVRawAccessChains = spvtest::ValidateBase; TEST_F(ValidateSpvNVRawAccessChains, Valid) { const std::string str = R"( OpCapability Shader OpCapability RawAccessChainsNV OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_NV_raw_access_chains" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %intStruct Block OpMemberDecorate %intStruct 0 Offset 0 OpDecorate %ssbo DescriptorSet 0 OpDecorate %ssbo Binding 0 %int = OpTypeInt 32 1 %void = OpTypeVoid %mainFunctionType = OpTypeFunction %void %intStruct = OpTypeStruct %int %intStructPtr = OpTypePointer StorageBuffer %intStruct %ssbo = OpVariable %intStructPtr StorageBuffer %intPtr = OpTypePointer StorageBuffer %int %int_0 = OpConstant %int 0 %int_16 = OpConstant %int 16 %main = OpFunction %void None %mainFunctionType %label = OpLabel %rawChain = OpRawAccessChainNV %intPtr %ssbo %int_16 %int_0 %int_0 RobustnessPerComponentNV %unused = OpLoad %int %rawChain OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateSpvNVRawAccessChains, NoCapability) { const std::string str = R"( OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_NV_raw_access_chains" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %intStruct Block OpMemberDecorate %intStruct 0 Offset 0 OpDecorate %ssbo DescriptorSet 0 OpDecorate %ssbo Binding 0 %int = OpTypeInt 32 1 %void = OpTypeVoid %mainFunctionType = OpTypeFunction %void %intStruct = OpTypeStruct %int %intStructPtr = OpTypePointer StorageBuffer %intStruct %ssbo = OpVariable %intStructPtr StorageBuffer %intPtr = OpTypePointer StorageBuffer %int %int_0 = OpConstant %int 0 %int_16 = OpConstant %int 16 %main = OpFunction %void None %mainFunctionType %label = OpLabel %rawChain = OpRawAccessChainNV %intPtr %ssbo %int_16 %int_0 %int_0 RobustnessPerComponentNV %unused = OpLoad %int %rawChain OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("requires one of these capabilities: RawAccessChainsNV")); } TEST_F(ValidateSpvNVRawAccessChains, NoExtension) { const std::string str = R"( OpCapability Shader OpCapability RawAccessChainsNV OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %intStruct Block OpMemberDecorate %intStruct 0 Offset 0 OpDecorate %ssbo DescriptorSet 0 OpDecorate %ssbo Binding 0 %int = OpTypeInt 32 1 %void = OpTypeVoid %mainFunctionType = OpTypeFunction %void %intStruct = OpTypeStruct %int %intStructPtr = OpTypePointer StorageBuffer %intStruct %ssbo = OpVariable %intStructPtr StorageBuffer %intPtr = OpTypePointer StorageBuffer %int %int_0 = OpConstant %int 0 %int_16 = OpConstant %int 16 %main = OpFunction %void None %mainFunctionType %label = OpLabel %rawChain = OpRawAccessChainNV %intPtr %ssbo %int_16 %int_0 %int_0 RobustnessPerComponentNV %unused = OpLoad %int %rawChain OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str()); EXPECT_EQ(SPV_ERROR_MISSING_EXTENSION, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("requires one of these extensions: SPV_NV_raw_access_chains")); } TEST_F(ValidateSpvNVRawAccessChains, ReturnTypeNotPointer) { const std::string str = R"( OpCapability Shader OpCapability RawAccessChainsNV OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_NV_raw_access_chains" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %intStruct Block OpMemberDecorate %intStruct 0 Offset 0 OpDecorate %ssbo DescriptorSet 0 OpDecorate %ssbo Binding 0 %int = OpTypeInt 32 1 %void = OpTypeVoid %mainFunctionType = OpTypeFunction %void %intStruct = OpTypeStruct %int %intStructPtr = OpTypePointer StorageBuffer %intStruct %ssbo = OpVariable %intStructPtr StorageBuffer %int_0 = OpConstant %int 0 %int_16 = OpConstant %int 16 %main = OpFunction %void None %mainFunctionType %label = OpLabel %rawChain = OpRawAccessChainNV %int %ssbo %int_16 %int_0 %int_0 RobustnessPerComponentNV OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be OpTypePointer. Found OpTypeInt")); } TEST_F(ValidateSpvNVRawAccessChains, Workgroup) { const std::string str = R"( OpCapability Shader OpCapability RawAccessChainsNV OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_NV_raw_access_chains" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %intStruct Block OpMemberDecorate %intStruct 0 Offset 0 %int = OpTypeInt 32 1 %void = OpTypeVoid %mainFunctionType = OpTypeFunction %void %intStruct = OpTypeStruct %int %intStructPtr = OpTypePointer Workgroup %intStruct %ssbo = OpVariable %intStructPtr Workgroup %intPtr = OpTypePointer Workgroup %int %int_0 = OpConstant %int 0 %int_16 = OpConstant %int 16 %main = OpFunction %void None %mainFunctionType %label = OpLabel %rawChain = OpRawAccessChainNV %intPtr %ssbo %int_16 %int_0 %int_0 RobustnessPerComponentNV %unused = OpLoad %int %rawChain OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must point to a storage class of")); } TEST_F(ValidateSpvNVRawAccessChains, ReturnTypeArray) { const std::string str = R"( OpCapability Shader OpCapability RawAccessChainsNV OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_NV_raw_access_chains" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %intStruct Block OpMemberDecorate %intStruct 0 Offset 0 OpDecorate %ssbo DescriptorSet 0 OpDecorate %ssbo Binding 0 %int = OpTypeInt 32 1 %void = OpTypeVoid %mainFunctionType = OpTypeFunction %void %intStruct = OpTypeStruct %int %intStructPtr = OpTypePointer StorageBuffer %intStruct %ssbo = OpVariable %intStructPtr StorageBuffer %int_1 = OpConstant %int 1 %intArray = OpTypeArray %int %int_1 %intArrayPtr = OpTypePointer StorageBuffer %intArray %int_0 = OpConstant %int 0 %int_16 = OpConstant %int 16 %main = OpFunction %void None %mainFunctionType %label = OpLabel %rawChain = OpRawAccessChainNV %intArrayPtr %ssbo %int_16 %int_0 %int_0 RobustnessPerComponentNV OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must not point to")); } TEST_F(ValidateSpvNVRawAccessChains, VariableStride) { const std::string str = R"( OpCapability Shader OpCapability RawAccessChainsNV OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_NV_raw_access_chains" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %intStruct Block OpMemberDecorate %intStruct 0 Offset 0 OpDecorate %ssbo DescriptorSet 0 OpDecorate %ssbo Binding 0 %int = OpTypeInt 32 1 %void = OpTypeVoid %mainFunctionType = OpTypeFunction %void %intStruct = OpTypeStruct %int %intStructPtr = OpTypePointer StorageBuffer %intStruct %ssbo = OpVariable %intStructPtr StorageBuffer %intPtr = OpTypePointer StorageBuffer %int %int_0 = OpConstant %int 0 %main = OpFunction %void None %mainFunctionType %label = OpLabel %stride = OpIAdd %int %int_0 %int_0 %rawChain = OpRawAccessChainNV %intPtr %ssbo %stride %int_0 %int_0 RobustnessPerComponentNV %unused = OpLoad %int %rawChain OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be OpConstant")); } TEST_F(ValidateSpvNVRawAccessChains, RobustnessPerElementZeroStride) { const std::string str = R"( OpCapability Shader OpCapability RawAccessChainsNV OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_NV_raw_access_chains" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %intStruct Block OpMemberDecorate %intStruct 0 Offset 0 OpDecorate %ssbo DescriptorSet 0 OpDecorate %ssbo Binding 0 %int = OpTypeInt 32 1 %void = OpTypeVoid %mainFunctionType = OpTypeFunction %void %intStruct = OpTypeStruct %int %intStructPtr = OpTypePointer StorageBuffer %intStruct %ssbo = OpVariable %intStructPtr StorageBuffer %intPtr = OpTypePointer StorageBuffer %int %int_0 = OpConstant %int 0 %main = OpFunction %void None %mainFunctionType %label = OpLabel %rawChain = OpRawAccessChainNV %intPtr %ssbo %int_0 %int_0 %int_0 RobustnessPerElementNV %unused = OpLoad %int %rawChain OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Stride must not be zero when per-element robustness is used")); } TEST_F(ValidateSpvNVRawAccessChains, BothRobustness) { const std::string str = R"( OpCapability Shader OpCapability RawAccessChainsNV OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_NV_raw_access_chains" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %intStruct Block OpMemberDecorate %intStruct 0 Offset 0 OpDecorate %ssbo DescriptorSet 0 OpDecorate %ssbo Binding 0 %int = OpTypeInt 32 1 %void = OpTypeVoid %mainFunctionType = OpTypeFunction %void %intStruct = OpTypeStruct %int %intStructPtr = OpTypePointer StorageBuffer %intStruct %ssbo = OpVariable %intStructPtr StorageBuffer %intPtr = OpTypePointer StorageBuffer %int %int_0 = OpConstant %int 0 %int_16 = OpConstant %int 16 %main = OpFunction %void None %mainFunctionType %label = OpLabel %rawChain = OpRawAccessChainNV %intPtr %ssbo %int_16 %int_0 %int_0 RobustnessPerElementNV|RobustnessPerComponentNV %unused = OpLoad %int %rawChain OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Per-component robustness and per-element robustness " "are mutually exclusive")); } TEST_F(ValidateSpvNVRawAccessChains, StrideFloat) { const std::string str = R"( OpCapability Shader OpCapability RawAccessChainsNV OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_NV_raw_access_chains" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %intStruct Block OpMemberDecorate %intStruct 0 Offset 0 OpDecorate %ssbo DescriptorSet 0 OpDecorate %ssbo Binding 0 %int = OpTypeInt 32 1 %float = OpTypeFloat 32 %void = OpTypeVoid %mainFunctionType = OpTypeFunction %void %intStruct = OpTypeStruct %int %intStructPtr = OpTypePointer StorageBuffer %intStruct %ssbo = OpVariable %intStructPtr StorageBuffer %intPtr = OpTypePointer StorageBuffer %int %int_0 = OpConstant %int 0 %float_16 = OpConstant %float 16 %main = OpFunction %void None %mainFunctionType %label = OpLabel %rawChain = OpRawAccessChainNV %intPtr %ssbo %float_16 %int_0 %int_0 RobustnessPerComponentNV %unused = OpLoad %int %rawChain OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be OpTypeInt")); } TEST_F(ValidateSpvNVRawAccessChains, IndexType) { const std::string str = R"( OpCapability Shader OpCapability RawAccessChainsNV OpCapability Int64 OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_NV_raw_access_chains" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %intStruct Block OpMemberDecorate %intStruct 0 Offset 0 OpDecorate %ssbo DescriptorSet 0 OpDecorate %ssbo Binding 0 %int = OpTypeInt 32 1 %long = OpTypeInt 64 1 %void = OpTypeVoid %mainFunctionType = OpTypeFunction %void %intStruct = OpTypeStruct %int %intStructPtr = OpTypePointer StorageBuffer %intStruct %ssbo = OpVariable %intStructPtr StorageBuffer %intPtr = OpTypePointer StorageBuffer %int %int_0 = OpConstant %int 0 %int_16 = OpConstant %int 16 %long_0 = OpConstant %long 0 %main = OpFunction %void None %mainFunctionType %label = OpLabel %rawChain = OpRawAccessChainNV %intPtr %ssbo %int_16 %long_0 %int_0 RobustnessPerComponentNV %unused = OpLoad %int %rawChain OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("The integer width of Index")); } TEST_F(ValidateSpvNVRawAccessChains, OffsetType) { const std::string str = R"( OpCapability Shader OpCapability RawAccessChainsNV OpCapability Int64 OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_NV_raw_access_chains" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %intStruct Block OpMemberDecorate %intStruct 0 Offset 0 OpDecorate %ssbo DescriptorSet 0 OpDecorate %ssbo Binding 0 %int = OpTypeInt 32 1 %long = OpTypeInt 64 1 %void = OpTypeVoid %mainFunctionType = OpTypeFunction %void %intStruct = OpTypeStruct %int %intStructPtr = OpTypePointer StorageBuffer %intStruct %ssbo = OpVariable %intStructPtr StorageBuffer %intPtr = OpTypePointer StorageBuffer %int %int_0 = OpConstant %int 0 %int_16 = OpConstant %int 16 %long_0 = OpConstant %long 0 %main = OpFunction %void None %mainFunctionType %label = OpLabel %rawChain = OpRawAccessChainNV %intPtr %ssbo %int_16 %int_0 %long_0 RobustnessPerComponentNV %unused = OpLoad %int %rawChain OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("The integer width of Offset")); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_extensions_test.cpp000066400000000000000000000633441475742701700251100ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Tests for OpExtension validator rules. #include #include #include "gmock/gmock.h" #include "source/extensions.h" #include "source/spirv_target_env.h" #include "test/unit_spirv.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::HasSubstr; using ::testing::Not; using ::testing::Values; using ::testing::ValuesIn; using ValidateKnownExtensions = spvtest::ValidateBase; using ValidateUnknownExtensions = spvtest::ValidateBase; using ValidateExtensionCapabilities = spvtest::ValidateBase; // Returns expected error string if |extension| is not recognized. std::string GetErrorString(const std::string& extension) { return "Found unrecognized extension " + extension; } INSTANTIATE_TEST_SUITE_P( ExpectSuccess, ValidateKnownExtensions, Values( // Match the order as published on the SPIR-V Registry. "SPV_AMD_shader_explicit_vertex_parameter", "SPV_AMD_shader_trinary_minmax", "SPV_AMD_gcn_shader", "SPV_KHR_shader_ballot", "SPV_AMD_shader_ballot", "SPV_AMD_gpu_shader_half_float", "SPV_KHR_shader_draw_parameters", "SPV_KHR_subgroup_vote", "SPV_KHR_16bit_storage", "SPV_KHR_device_group", "SPV_KHR_multiview", "SPV_NVX_multiview_per_view_attributes", "SPV_NV_viewport_array2", "SPV_NV_stereo_view_rendering", "SPV_NV_sample_mask_override_coverage", "SPV_NV_geometry_shader_passthrough", "SPV_AMD_texture_gather_bias_lod", "SPV_KHR_storage_buffer_storage_class", "SPV_KHR_variable_pointers", "SPV_AMD_gpu_shader_int16", "SPV_KHR_post_depth_coverage", "SPV_KHR_shader_atomic_counter_ops", "SPV_EXT_shader_stencil_export", "SPV_EXT_shader_viewport_index_layer", "SPV_AMD_shader_image_load_store_lod", "SPV_AMD_shader_fragment_mask", "SPV_GOOGLE_decorate_string", "SPV_GOOGLE_hlsl_functionality1", "SPV_NV_shader_subgroup_partitioned", "SPV_EXT_descriptor_indexing", "SPV_KHR_terminate_invocation", "SPV_KHR_relaxed_extended_instruction")); INSTANTIATE_TEST_SUITE_P(FailSilently, ValidateUnknownExtensions, Values("ERROR_unknown_extension", "SPV_KHR_", "SPV_KHR_shader_ballot_ERROR")); TEST_P(ValidateKnownExtensions, ExpectSuccess) { const std::string extension = GetParam(); const std::string str = "OpCapability Shader\nOpCapability Linkage\nOpExtension \"" + extension + "\"\nOpMemoryModel Logical GLSL450"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), Not(HasSubstr(GetErrorString(extension)))); } TEST_P(ValidateUnknownExtensions, FailSilently) { const std::string extension = GetParam(); const std::string str = "OpCapability Shader\nOpCapability Linkage\nOpExtension \"" + extension + "\"\nOpMemoryModel Logical GLSL450"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(GetErrorString(extension))); } TEST_F(ValidateUnknownExtensions, HitMaxNumOfWarnings) { const std::string str = std::string("OpCapability Shader\n") + "OpCapability Linkage\n" + "OpExtension \"bad_ext\"\n" + "OpExtension \"bad_ext\"\n" + "OpExtension \"bad_ext\"\n" + "OpExtension \"bad_ext\"\n" + "OpExtension \"bad_ext\"\n" + "OpExtension \"bad_ext\"\n" + "OpExtension \"bad_ext\"\n" + "OpExtension \"bad_ext\"\n" + "OpExtension \"bad_ext\"\n" + "OpExtension \"bad_ext\"\n" + "OpExtension \"bad_ext\"\n" + "OpExtension \"bad_ext\"\n" + "OpExtension \"bad_ext\"\n" + "OpExtension \"bad_ext\"\n" + "OpExtension \"bad_ext\"\n" + "OpExtension \"bad_ext\"\n" + "OpExtension \"bad_ext\"\n" + "OpExtension \"bad_ext\"\n" + "OpExtension \"bad_ext\"\n" + "OpExtension \"bad_ext\"\n" + "OpExtension \"bad_ext\"\n" + "OpExtension \"bad_ext\"\n" + "OpExtension \"bad_ext\"\n" + "OpExtension \"bad_ext\"\n" + "OpExtension \"bad_ext\"\n" + "OpExtension \"bad_ext\"\n" + "OpMemoryModel Logical GLSL450"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Other warnings have been suppressed.")); } TEST_F(ValidateExtensionCapabilities, DeclCapabilitySuccess) { const std::string str = "OpCapability Shader\nOpCapability Linkage\nOpCapability DeviceGroup\n" "OpExtension \"SPV_KHR_device_group\"" "\nOpMemoryModel Logical GLSL450"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateExtensionCapabilities, DeclCapabilityFailure) { const std::string str = "OpCapability Shader\nOpCapability Linkage\nOpCapability DeviceGroup\n" "\nOpMemoryModel Logical GLSL450"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_ERROR_MISSING_EXTENSION, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("1st operand of Capability")); EXPECT_THAT(getDiagnosticString(), HasSubstr("requires one of these extensions")); EXPECT_THAT(getDiagnosticString(), HasSubstr("SPV_KHR_device_group")); } TEST_F(ValidateExtensionCapabilities, DeclCapabilityFailureBlockMatchWIndowSAD) { const std::string str = R"( OpCapability Shader OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %v_texcoord %fragColor %target_samp %ref_samp OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpSourceExtension "GL_QCOM_image_processing" OpSourceExtension "GL_QCOM_image_processing2" OpName %main "main" OpName %tgt_coords "tgt_coords" OpName %v_texcoord "v_texcoord" OpName %ref_coords "ref_coords" OpName %blockSize "blockSize" OpName %fragColor "fragColor" OpName %target_samp "target_samp" OpName %ref_samp "ref_samp" OpDecorate %v_texcoord Location 0 OpDecorate %fragColor Location 0 OpDecorate %target_samp DescriptorSet 0 OpDecorate %target_samp Binding 4 OpDecorate %ref_samp DescriptorSet 0 OpDecorate %ref_samp Binding 5 OpDecorate %target_samp BlockMatchTextureQCOM OpDecorate %target_samp BlockMatchSamplerQCOM OpDecorate %ref_samp BlockMatchTextureQCOM OpDecorate %ref_samp BlockMatchSamplerQCOM %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %v_texcoord = OpVariable %_ptr_Input_v4float Input %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %_ptr_Function_uint = OpTypePointer Function %uint %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %uint_3 = OpConstant %uint 3 %uint_4 = OpConstant %uint 4 %39 = OpConstantComposite %v2uint %uint_4 %uint_4 %_ptr_Output_v4float = OpTypePointer Output %v4float %fragColor = OpVariable %_ptr_Output_v4float Output %42 = OpTypeImage %float 2D 0 0 0 1 Unknown %43 = OpTypeSampledImage %42 %_ptr_UniformConstant_43 = OpTypePointer UniformConstant %43 %target_samp = OpVariable %_ptr_UniformConstant_43 UniformConstant %ref_samp = OpVariable %_ptr_UniformConstant_43 UniformConstant %main = OpFunction %void None %3 %5 = OpLabel %tgt_coords = OpVariable %_ptr_Function_v2uint Function %ref_coords = OpVariable %_ptr_Function_v2uint Function %blockSize = OpVariable %_ptr_Function_v2uint Function %16 = OpAccessChain %_ptr_Input_float %v_texcoord %uint_0 %17 = OpLoad %float %16 %18 = OpConvertFToU %uint %17 %20 = OpAccessChain %_ptr_Function_uint %tgt_coords %uint_0 OpStore %20 %18 %22 = OpAccessChain %_ptr_Input_float %v_texcoord %uint_1 %23 = OpLoad %float %22 %24 = OpConvertFToU %uint %23 %25 = OpAccessChain %_ptr_Function_uint %tgt_coords %uint_0 OpStore %25 %24 %28 = OpAccessChain %_ptr_Input_float %v_texcoord %uint_2 %29 = OpLoad %float %28 %30 = OpConvertFToU %uint %29 %31 = OpAccessChain %_ptr_Function_uint %ref_coords %uint_0 OpStore %31 %30 %33 = OpAccessChain %_ptr_Input_float %v_texcoord %uint_3 %34 = OpLoad %float %33 %35 = OpConvertFToU %uint %34 %36 = OpAccessChain %_ptr_Function_uint %ref_coords %uint_1 OpStore %36 %35 OpStore %blockSize %39 %46 = OpLoad %43 %target_samp %47 = OpLoad %v2uint %tgt_coords %49 = OpLoad %43 %ref_samp %50 = OpLoad %v2uint %ref_coords %51 = OpLoad %v2uint %blockSize %52 = OpImageBlockMatchWindowSADQCOM %v4float %46 %47 %49 %50 %51 OpStore %fragColor %52 OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_ERROR_MISSING_EXTENSION, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("2nd operand of Decorate")); EXPECT_THAT(getDiagnosticString(), HasSubstr("requires one of these extensions")); EXPECT_THAT(getDiagnosticString(), HasSubstr("SPV_QCOM_image_processing")); } TEST_F(ValidateExtensionCapabilities, DeclCapabilityFailureBlockMatchWIndowSSD) { const std::string str = R"( OpCapability Shader OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %v_texcoord %fragColor %tex2D_src1 %samp %tex2D_src2 OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpSourceExtension "GL_QCOM_image_processing" OpSourceExtension "GL_QCOM_image_processing2" OpName %main "main" OpName %tgt_coords "tgt_coords" OpName %v_texcoord "v_texcoord" OpName %ref_coords "ref_coords" OpName %blockSize "blockSize" OpName %fragColor "fragColor" OpName %tex2D_src1 "tex2D_src1" OpName %samp "samp" OpName %tex2D_src2 "tex2D_src2" OpDecorate %v_texcoord Location 0 OpDecorate %fragColor Location 0 OpDecorate %tex2D_src1 DescriptorSet 0 OpDecorate %tex2D_src1 Binding 1 OpDecorate %samp DescriptorSet 0 OpDecorate %samp Binding 3 OpDecorate %tex2D_src2 DescriptorSet 0 OpDecorate %tex2D_src2 Binding 2 OpDecorate %tex2D_src1 BlockMatchTextureQCOM OpDecorate %samp BlockMatchSamplerQCOM OpDecorate %tex2D_src2 BlockMatchTextureQCOM OpDecorate %samp BlockMatchSamplerQCOM %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %v_texcoord = OpVariable %_ptr_Input_v4float Input %uint_0 = OpConstant %uint 0 %_ptr_Input_float = OpTypePointer Input %float %_ptr_Function_uint = OpTypePointer Function %uint %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %uint_3 = OpConstant %uint 3 %uint_4 = OpConstant %uint 4 %39 = OpConstantComposite %v2uint %uint_4 %uint_4 %_ptr_Output_v4float = OpTypePointer Output %v4float %fragColor = OpVariable %_ptr_Output_v4float Output %42 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_42 = OpTypePointer UniformConstant %42 %tex2D_src1 = OpVariable %_ptr_UniformConstant_42 UniformConstant %46 = OpTypeSampler %_ptr_UniformConstant_46 = OpTypePointer UniformConstant %46 %samp = OpVariable %_ptr_UniformConstant_46 UniformConstant %50 = OpTypeSampledImage %42 %tex2D_src2 = OpVariable %_ptr_UniformConstant_42 UniformConstant %main = OpFunction %void None %3 %5 = OpLabel %tgt_coords = OpVariable %_ptr_Function_v2uint Function %ref_coords = OpVariable %_ptr_Function_v2uint Function %blockSize = OpVariable %_ptr_Function_v2uint Function %16 = OpAccessChain %_ptr_Input_float %v_texcoord %uint_0 %17 = OpLoad %float %16 %18 = OpConvertFToU %uint %17 %20 = OpAccessChain %_ptr_Function_uint %tgt_coords %uint_0 OpStore %20 %18 %22 = OpAccessChain %_ptr_Input_float %v_texcoord %uint_1 %23 = OpLoad %float %22 %24 = OpConvertFToU %uint %23 %25 = OpAccessChain %_ptr_Function_uint %tgt_coords %uint_0 OpStore %25 %24 %28 = OpAccessChain %_ptr_Input_float %v_texcoord %uint_2 %29 = OpLoad %float %28 %30 = OpConvertFToU %uint %29 %31 = OpAccessChain %_ptr_Function_uint %ref_coords %uint_0 OpStore %31 %30 %33 = OpAccessChain %_ptr_Input_float %v_texcoord %uint_3 %34 = OpLoad %float %33 %35 = OpConvertFToU %uint %34 %36 = OpAccessChain %_ptr_Function_uint %ref_coords %uint_1 OpStore %36 %35 OpStore %blockSize %39 %45 = OpLoad %42 %tex2D_src1 %49 = OpLoad %46 %samp %51 = OpSampledImage %50 %45 %49 %52 = OpLoad %v2uint %tgt_coords %54 = OpLoad %42 %tex2D_src2 %55 = OpLoad %46 %samp %56 = OpSampledImage %50 %54 %55 %57 = OpLoad %v2uint %ref_coords %58 = OpLoad %v2uint %blockSize %59 = OpImageBlockMatchWindowSSDQCOM %v4float %51 %52 %56 %57 %58 OpStore %fragColor %59 OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_ERROR_MISSING_EXTENSION, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("2nd operand of Decorate")); EXPECT_THAT(getDiagnosticString(), HasSubstr("requires one of these extensions")); EXPECT_THAT(getDiagnosticString(), HasSubstr("SPV_QCOM_image_processing")); } using ValidateAMDShaderBallotCapabilities = spvtest::ValidateBase; // Returns a vector of strings for the prefix of a SPIR-V assembly shader // that can use the group instructions introduced by SPV_AMD_shader_ballot. std::vector ShaderPartsForAMDShaderBallot() { return std::vector{R"( OpCapability Shader OpCapability Linkage )", R"( OpMemoryModel Logical GLSL450 %float = OpTypeFloat 32 %uint = OpTypeInt 32 0 %int = OpTypeInt 32 1 %scope = OpConstant %uint 3 %uint_const = OpConstant %uint 42 %int_const = OpConstant %uint 45 %float_const = OpConstant %float 3.5 %void = OpTypeVoid %fn_ty = OpTypeFunction %void %fn = OpFunction %void None %fn_ty %entry = OpLabel )"}; } // Returns a list of SPIR-V assembly strings, where each uses only types // and IDs that can fit with a shader made from parts from the result // of ShaderPartsForAMDShaderBallot. std::vector AMDShaderBallotGroupInstructions() { return std::vector{ "%iadd_reduce = OpGroupIAddNonUniformAMD %uint %scope Reduce %uint_const", "%iadd_iscan = OpGroupIAddNonUniformAMD %uint %scope InclusiveScan " "%uint_const", "%iadd_escan = OpGroupIAddNonUniformAMD %uint %scope ExclusiveScan " "%uint_const", "%fadd_reduce = OpGroupFAddNonUniformAMD %float %scope Reduce " "%float_const", "%fadd_iscan = OpGroupFAddNonUniformAMD %float %scope InclusiveScan " "%float_const", "%fadd_escan = OpGroupFAddNonUniformAMD %float %scope ExclusiveScan " "%float_const", "%fmin_reduce = OpGroupFMinNonUniformAMD %float %scope Reduce " "%float_const", "%fmin_iscan = OpGroupFMinNonUniformAMD %float %scope InclusiveScan " "%float_const", "%fmin_escan = OpGroupFMinNonUniformAMD %float %scope ExclusiveScan " "%float_const", "%umin_reduce = OpGroupUMinNonUniformAMD %uint %scope Reduce %uint_const", "%umin_iscan = OpGroupUMinNonUniformAMD %uint %scope InclusiveScan " "%uint_const", "%umin_escan = OpGroupUMinNonUniformAMD %uint %scope ExclusiveScan " "%uint_const", "%smin_reduce = OpGroupUMinNonUniformAMD %int %scope Reduce %int_const", "%smin_iscan = OpGroupUMinNonUniformAMD %int %scope InclusiveScan " "%int_const", "%smin_escan = OpGroupUMinNonUniformAMD %int %scope ExclusiveScan " "%int_const", "%fmax_reduce = OpGroupFMaxNonUniformAMD %float %scope Reduce " "%float_const", "%fmax_iscan = OpGroupFMaxNonUniformAMD %float %scope InclusiveScan " "%float_const", "%fmax_escan = OpGroupFMaxNonUniformAMD %float %scope ExclusiveScan " "%float_const", "%umax_reduce = OpGroupUMaxNonUniformAMD %uint %scope Reduce %uint_const", "%umax_iscan = OpGroupUMaxNonUniformAMD %uint %scope InclusiveScan " "%uint_const", "%umax_escan = OpGroupUMaxNonUniformAMD %uint %scope ExclusiveScan " "%uint_const", "%smax_reduce = OpGroupUMaxNonUniformAMD %int %scope Reduce %int_const", "%smax_iscan = OpGroupUMaxNonUniformAMD %int %scope InclusiveScan " "%int_const", "%smax_escan = OpGroupUMaxNonUniformAMD %int %scope ExclusiveScan " "%int_const"}; } TEST_P(ValidateAMDShaderBallotCapabilities, ExpectSuccess) { // Succeed because the module specifies the SPV_AMD_shader_ballot extension. auto parts = ShaderPartsForAMDShaderBallot(); const std::string assembly = parts[0] + "OpExtension \"SPV_AMD_shader_ballot\"\n" + parts[1] + GetParam() + "\nOpReturn OpFunctionEnd"; CompileSuccessfully(assembly.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()) << getDiagnosticString(); } INSTANTIATE_TEST_SUITE_P(ExpectSuccess, ValidateAMDShaderBallotCapabilities, ValuesIn(AMDShaderBallotGroupInstructions())); TEST_P(ValidateAMDShaderBallotCapabilities, ExpectFailure) { // Fail because the module does not specify the SPV_AMD_shader_ballot // extension. auto parts = ShaderPartsForAMDShaderBallot(); const std::string assembly = parts[0] + parts[1] + GetParam() + "\nOpReturn OpFunctionEnd"; CompileSuccessfully(assembly.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY, ValidateInstructions()); // Make sure we get an appropriate error message. // Find just the opcode name, skipping over the "Op" part. auto prefix_with_opcode = GetParam().substr(GetParam().find("Group")); auto opcode = prefix_with_opcode.substr(0, prefix_with_opcode.find(' ')); EXPECT_THAT( getDiagnosticString(), HasSubstr(std::string("Opcode " + opcode + " requires one of these capabilities: Groups"))); } INSTANTIATE_TEST_SUITE_P(ExpectFailure, ValidateAMDShaderBallotCapabilities, ValuesIn(AMDShaderBallotGroupInstructions())); struct ExtIntoCoreCase { const char* ext; const char* cap; const char* builtin; spv_target_env env; bool success; }; using ValidateExtIntoCore = spvtest::ValidateBase; // Make sure that we don't panic about missing extensions for using // functionalities that introduced in extensions but became core SPIR-V later. TEST_P(ValidateExtIntoCore, DoNotAskForExtensionInLaterVersion) { const std::string code = std::string(R"( OpCapability Shader OpCapability )") + GetParam().cap + R"( OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %builtin OpDecorate %builtin BuiltIn )" + GetParam().builtin + R"( %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %builtin = OpVariable %_ptr_Input_int Input %main = OpFunction %void None %3 %5 = OpLabel %18 = OpLoad %int %builtin OpReturn OpFunctionEnd)"; CompileSuccessfully(code.c_str(), GetParam().env); if (GetParam().success) { ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(GetParam().env)) << getDiagnosticString(); } else { ASSERT_NE(SPV_SUCCESS, ValidateInstructions(GetParam().env)) << " in " << spvTargetEnvDescription(GetParam().env) << ":\n" << code; const std::string message = getDiagnosticString(); if (spvIsVulkanEnv(GetParam().env)) { EXPECT_THAT(message, HasSubstr(std::string(GetParam().cap) + " is not allowed by Vulkan")); EXPECT_THAT(message, HasSubstr(std::string("or requires extension"))); } else { EXPECT_THAT(message, HasSubstr(std::string("requires one of these extensions: ") + GetParam().ext)); } } } // clang-format off INSTANTIATE_TEST_SUITE_P( KHR_extensions, ValidateExtIntoCore, ValuesIn(std::vector{ // SPV_KHR_shader_draw_parameters became core SPIR-V 1.3 {"SPV_KHR_shader_draw_parameters", "DrawParameters", "BaseVertex", SPV_ENV_UNIVERSAL_1_3, true}, {"SPV_KHR_shader_draw_parameters", "DrawParameters", "BaseVertex", SPV_ENV_UNIVERSAL_1_2, false}, {"SPV_KHR_shader_draw_parameters", "DrawParameters", "BaseVertex", SPV_ENV_UNIVERSAL_1_1, false}, {"SPV_KHR_shader_draw_parameters", "DrawParameters", "BaseVertex", SPV_ENV_UNIVERSAL_1_0, false}, {"SPV_KHR_shader_draw_parameters", "DrawParameters", "BaseVertex", SPV_ENV_VULKAN_1_1, true}, {"SPV_KHR_shader_draw_parameters", "DrawParameters", "BaseVertex", SPV_ENV_VULKAN_1_0, false}, {"SPV_KHR_shader_draw_parameters", "DrawParameters", "BaseInstance", SPV_ENV_UNIVERSAL_1_3, true}, {"SPV_KHR_shader_draw_parameters", "DrawParameters", "BaseInstance", SPV_ENV_VULKAN_1_0, false}, {"SPV_KHR_shader_draw_parameters", "DrawParameters", "DrawIndex", SPV_ENV_UNIVERSAL_1_3, true}, {"SPV_KHR_shader_draw_parameters", "DrawParameters", "DrawIndex", SPV_ENV_UNIVERSAL_1_1, false}, // SPV_KHR_multiview became core SPIR-V 1.3 {"SPV_KHR_multiview", "MultiView", "ViewIndex", SPV_ENV_UNIVERSAL_1_3, true}, {"SPV_KHR_multiview", "MultiView", "ViewIndex", SPV_ENV_UNIVERSAL_1_2, false}, {"SPV_KHR_multiview", "MultiView", "ViewIndex", SPV_ENV_UNIVERSAL_1_1, false}, {"SPV_KHR_multiview", "MultiView", "ViewIndex", SPV_ENV_UNIVERSAL_1_0, false}, {"SPV_KHR_multiview", "MultiView", "ViewIndex", SPV_ENV_VULKAN_1_1, true}, {"SPV_KHR_multiview", "MultiView", "ViewIndex", SPV_ENV_VULKAN_1_0, false}, // SPV_KHR_device_group became core SPIR-V 1.3 {"SPV_KHR_device_group", "DeviceGroup", "DeviceIndex", SPV_ENV_UNIVERSAL_1_3, true}, {"SPV_KHR_device_group", "DeviceGroup", "DeviceIndex", SPV_ENV_UNIVERSAL_1_2, false}, {"SPV_KHR_device_group", "DeviceGroup", "DeviceIndex", SPV_ENV_UNIVERSAL_1_1, false}, {"SPV_KHR_device_group", "DeviceGroup", "DeviceIndex", SPV_ENV_UNIVERSAL_1_0, false}, {"SPV_KHR_device_group", "DeviceGroup", "DeviceIndex", SPV_ENV_VULKAN_1_1, true}, {"SPV_KHR_device_group", "DeviceGroup", "DeviceIndex", SPV_ENV_VULKAN_1_0, false}, })); // clang-format on using ValidateRelaxedExtendedInstructionExt = spvtest::ValidateBase; TEST_F(ValidateRelaxedExtendedInstructionExt, RequiresExtension) { const std::string str = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %1 = OpExtInstImport "NonSemantic.Shader.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" OpExecutionMode %2 LocalSize 1 1 1 %3 = OpString "sample" %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %7 = OpTypeFunction %void %8 = OpExtInst %void %1 DebugSource %3 %3 %9 = OpExtInst %void %1 DebugCompilationUnit %uint_0 %uint_0 %8 %uint_0 %10 = OpExtInstWithForwardRefsKHR %void %1 DebugTypeFunction %uint_0 %11 %12 = OpExtInstWithForwardRefsKHR %void %1 DebugFunction %3 %10 %8 %uint_0 %uint_0 %11 %3 %uint_0 %uint_0 %11 = OpExtInst %void %1 DebugTypeComposite %3 %uint_0 %8 %uint_0 %uint_0 %9 %3 %uint_0 %uint_0 %12 %2 = OpFunction %void None %7 %13 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str()); EXPECT_NE(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "ExtInstWithForwardRefsKHR requires one of the following extensions:" " SPV_KHR_relaxed_extended_instruction \n" " %10 = OpExtInstWithForwardRefsKHR %void %1 DebugTypeFunction " "%uint_0 " "%11\n")); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_fixtures.h000066400000000000000000000174611475742701700231670ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Common validation fixtures for unit tests #ifndef TEST_VAL_VAL_FIXTURES_H_ #define TEST_VAL_VAL_FIXTURES_H_ #include #include #include "source/val/validation_state.h" #include "spirv-tools/libspirv.h" #include "test/test_fixture.h" #include "test/unit_spirv.h" namespace spvtest { template class ValidateBase : public ::testing::Test, public ::testing::WithParamInterface { public: ValidateBase(); virtual void TearDown(); // Returns the a spv_const_binary struct spv_const_binary get_const_binary(); // Assembles the given SPIR-V text, checks that it fails to assemble, // and returns resulting diagnostic. No internal state is updated. // Setting the desired_result to SPV_SUCCESS is used to allow all results std::string CompileFailure(std::string code, spv_target_env env = SPV_ENV_UNIVERSAL_1_0, spv_result_t desired_result = SPV_SUCCESS); // Checks that 'code' is valid SPIR-V text representation and stores the // binary version for further method calls. void CompileSuccessfully(std::string code, spv_target_env env = SPV_ENV_UNIVERSAL_1_0); // Overwrites the word at index 'index' with the given word. // For testing purposes, it is often useful to be able to manipulate the // assembled binary before running the validator on it. // This function overwrites the word at the given index with a new word. void OverwriteAssembledBinary(uint32_t index, uint32_t word); // Performs validation on the SPIR-V code. spv_result_t ValidateInstructions(spv_target_env env = SPV_ENV_UNIVERSAL_1_0); // Performs validation. Returns the status and stores validation state into // the vstate_ member. spv_result_t ValidateAndRetrieveValidationState( spv_target_env env = SPV_ENV_UNIVERSAL_1_0); // Destroys the stored binary. void DestroyBinary() { spvBinaryDestroy(binary_); binary_ = nullptr; } // Destroys the stored diagnostic. void DestroyDiagnostic() { spvDiagnosticDestroy(diagnostic_); diagnostic_ = nullptr; } void SetAssembleOptions(uint32_t options) { assemble_options_ = options; } std::string getDiagnosticString(); spv_position_t getErrorPosition(); spv_validator_options getValidatorOptions(); spv_binary binary_; spv_diagnostic diagnostic_; spv_validator_options options_; std::unique_ptr vstate_; uint32_t assemble_options_ = SPV_TEXT_TO_BINARY_OPTION_NONE; }; template ValidateBase::ValidateBase() : binary_(nullptr), diagnostic_(nullptr) { // Initialize to default command line options. Different tests can then // specialize specific options as necessary. options_ = spvValidatorOptionsCreate(); } template spv_const_binary ValidateBase::get_const_binary() { return spv_const_binary(binary_); } template void ValidateBase::TearDown() { if (diagnostic_) { spvDiagnosticPrint(diagnostic_); } DestroyBinary(); DestroyDiagnostic(); spvValidatorOptionsDestroy(options_); } template std::string ValidateBase::CompileFailure(std::string code, spv_target_env env, spv_result_t desired_result) { spv_diagnostic diagnostic = nullptr; spv_result_t actual_result = spvTextToBinary(ScopedContext(env).context, code.c_str(), code.size(), &binary_, &diagnostic); EXPECT_NE(SPV_SUCCESS, actual_result); // optional check for exact result if (desired_result != SPV_SUCCESS) { EXPECT_EQ(actual_result, desired_result); } std::string result(diagnostic->error); spvDiagnosticDestroy(diagnostic); return result; } template void ValidateBase::CompileSuccessfully(std::string code, spv_target_env env) { DestroyBinary(); spv_diagnostic diagnostic = nullptr; ScopedContext context(env); auto status = spvTextToBinaryWithOptions(context.context, code.c_str(), code.size(), assemble_options_, &binary_, &diagnostic); EXPECT_EQ(SPV_SUCCESS, status) << "ERROR: " << diagnostic->error << "\nSPIR-V could not be compiled into binary:\n" << code; ASSERT_EQ(SPV_SUCCESS, status); spvDiagnosticDestroy(diagnostic); } template void ValidateBase::OverwriteAssembledBinary(uint32_t index, uint32_t word) { ASSERT_TRUE(index < binary_->wordCount) << "OverwriteAssembledBinary: The given index is larger than the binary " "word count."; binary_->code[index] = word; } template spv_result_t ValidateBase::ValidateInstructions(spv_target_env env) { DestroyDiagnostic(); if (binary_ == nullptr) { fprintf(stderr, "ERROR: Attempting to validate a null binary, did you forget to " "call CompileSuccessfully?"); fflush(stderr); } assert(binary_ != nullptr); return spvValidateWithOptions(ScopedContext(env).context, options_, get_const_binary(), &diagnostic_); } template spv_result_t ValidateBase::ValidateAndRetrieveValidationState( spv_target_env env) { DestroyDiagnostic(); return spvtools::val::ValidateBinaryAndKeepValidationState( ScopedContext(env).context, options_, get_const_binary()->code, get_const_binary()->wordCount, &diagnostic_, &vstate_); } template std::string ValidateBase::getDiagnosticString() { return diagnostic_ == nullptr ? std::string() : std::string(diagnostic_->error); } template spv_validator_options ValidateBase::getValidatorOptions() { return options_; } template spv_position_t ValidateBase::getErrorPosition() { return diagnostic_ == nullptr ? spv_position_t() : diagnostic_->position; } } // namespace spvtest // For Vulkan testing. // Allows test parameter test to list all possible VUIDs with a delimiter that // is then split here to check if one VUID was in the error message MATCHER_P(AnyVUID, vuid_set, "VUID from the set is in error message") { // use space as delimiter because clang-format will properly line break VUID // strings which is important the entire VUID is in a single line for script // to scan std::string delimiter = " "; std::string token; std::string vuids = std::string(vuid_set); size_t position; // Catch case were someone accidentally left spaces by trimming string // clang-format off vuids.erase(std::find_if(vuids.rbegin(), vuids.rend(), [](unsigned char c) { return (c != ' '); }).base(), vuids.end()); vuids.erase(vuids.begin(), std::find_if(vuids.begin(), vuids.end(), [](unsigned char c) { return (c != ' '); })); // clang-format on do { position = vuids.find(delimiter); if (position != std::string::npos) { token = vuids.substr(0, position); vuids.erase(0, position + delimiter.length()); } else { token = vuids.substr(0); // last item } // arg contains diagnostic message if (arg.find(token) != std::string::npos) { return true; } } while (position != std::string::npos); return false; } #endif // TEST_VAL_VAL_FIXTURES_H_ KhronosGroup-SPIRV-Tools-f289d04/test/val/val_function_test.cpp000066400000000000000000001030101475742701700245170ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gmock/gmock.h" #include "test/unit_spirv.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::Combine; using ::testing::HasSubstr; using ::testing::Values; using ValidateFunctionCall = spvtest::ValidateBase; std::string GenerateShader(const std::string& storage_class, const std::string& capabilities, const std::string& extensions) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability AtomicStorage )" + capabilities + R"( OpExtension "SPV_KHR_storage_buffer_storage_class" )" + extensions + R"( OpMemoryModel Logical GLSL450 OpName %var "var" %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr = OpTypePointer )" + storage_class + R"( %int %caller_ty = OpTypeFunction %void %callee_ty = OpTypeFunction %void %ptr )"; if (storage_class != "Function") { spirv += "%var = OpVariable %ptr " + storage_class; } spirv += R"( %caller = OpFunction %void None %caller_ty %1 = OpLabel )"; if (storage_class == "Function") { spirv += "%var = OpVariable %ptr Function"; } spirv += R"( %call = OpFunctionCall %void %callee %var OpReturn OpFunctionEnd %callee = OpFunction %void None %callee_ty %param = OpFunctionParameter %ptr %2 = OpLabel OpReturn OpFunctionEnd )"; return spirv; } std::string GenerateShaderParameter(const std::string& storage_class, const std::string& capabilities, const std::string& extensions) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability AtomicStorage )" + capabilities + R"( OpExtension "SPV_KHR_storage_buffer_storage_class" )" + extensions + R"( OpMemoryModel Logical GLSL450 OpName %p "p" %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr = OpTypePointer )" + storage_class + R"( %int %func_ty = OpTypeFunction %void %ptr %caller = OpFunction %void None %func_ty %p = OpFunctionParameter %ptr %1 = OpLabel %call = OpFunctionCall %void %callee %p OpReturn OpFunctionEnd %callee = OpFunction %void None %func_ty %param = OpFunctionParameter %ptr %2 = OpLabel OpReturn OpFunctionEnd )"; return spirv; } std::string GenerateShaderAccessChain(const std::string& storage_class, const std::string& capabilities, const std::string& extensions) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability AtomicStorage )" + capabilities + R"( OpExtension "SPV_KHR_storage_buffer_storage_class" )" + extensions + R"( OpMemoryModel Logical GLSL450 OpName %var "var" OpName %gep "gep" %void = OpTypeVoid %int = OpTypeInt 32 0 %int2 = OpTypeVector %int 2 %int_0 = OpConstant %int 0 %ptr = OpTypePointer )" + storage_class + R"( %int2 %ptr2 = OpTypePointer )" + storage_class + R"( %int %caller_ty = OpTypeFunction %void %callee_ty = OpTypeFunction %void %ptr2 )"; if (storage_class != "Function") { spirv += "%var = OpVariable %ptr " + storage_class; } spirv += R"( %caller = OpFunction %void None %caller_ty %1 = OpLabel )"; if (storage_class == "Function") { spirv += "%var = OpVariable %ptr Function"; } spirv += R"( %gep = OpAccessChain %ptr2 %var %int_0 %call = OpFunctionCall %void %callee %gep OpReturn OpFunctionEnd %callee = OpFunction %void None %callee_ty %param = OpFunctionParameter %ptr2 %2 = OpLabel OpReturn OpFunctionEnd )"; return spirv; } TEST_P(ValidateFunctionCall, VariableNoVariablePointers) { const std::string storage_class = GetParam(); std::string spirv = GenerateShader(storage_class, "", ""); const std::vector valid_storage_classes = { "UniformConstant", "Function", "Private", "Workgroup", "AtomicCounter"}; bool valid = std::find(valid_storage_classes.begin(), valid_storage_classes.end(), storage_class) != valid_storage_classes.end(); CompileSuccessfully(spirv); if (valid) { EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } else { EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); if (storage_class == "StorageBuffer") { EXPECT_THAT( getDiagnosticString(), HasSubstr("StorageBuffer pointer operand '1[%var]' requires a " "variable pointers capability")); } else { EXPECT_THAT( getDiagnosticString(), HasSubstr("Invalid storage class for pointer operand '1[%var]'")); } } } TEST_P(ValidateFunctionCall, VariableVariablePointersStorageClass) { const std::string storage_class = GetParam(); std::string spirv = GenerateShader( storage_class, "OpCapability VariablePointersStorageBuffer", "OpExtension \"SPV_KHR_variable_pointers\""); const std::vector valid_storage_classes = { "UniformConstant", "Function", "Private", "Workgroup", "StorageBuffer", "AtomicCounter"}; bool valid = std::find(valid_storage_classes.begin(), valid_storage_classes.end(), storage_class) != valid_storage_classes.end(); CompileSuccessfully(spirv); if (valid) { EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } else { EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Invalid storage class for pointer operand '1[%var]'")); } } TEST_P(ValidateFunctionCall, VariableVariablePointers) { const std::string storage_class = GetParam(); std::string spirv = GenerateShader(storage_class, "OpCapability VariablePointers", "OpExtension \"SPV_KHR_variable_pointers\""); const std::vector valid_storage_classes = { "UniformConstant", "Function", "Private", "Workgroup", "StorageBuffer", "AtomicCounter"}; bool valid = std::find(valid_storage_classes.begin(), valid_storage_classes.end(), storage_class) != valid_storage_classes.end(); CompileSuccessfully(spirv); if (valid) { EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } else { EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Invalid storage class for pointer operand '1[%var]'")); } } TEST_P(ValidateFunctionCall, ParameterNoVariablePointers) { const std::string storage_class = GetParam(); std::string spirv = GenerateShaderParameter(storage_class, "", ""); const std::vector valid_storage_classes = { "UniformConstant", "Function", "Private", "Workgroup", "AtomicCounter"}; bool valid = std::find(valid_storage_classes.begin(), valid_storage_classes.end(), storage_class) != valid_storage_classes.end(); CompileSuccessfully(spirv); if (valid) { EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } else { EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); if (storage_class == "StorageBuffer") { EXPECT_THAT(getDiagnosticString(), HasSubstr("StorageBuffer pointer operand '1[%p]' requires a " "variable pointers capability")); } else { EXPECT_THAT( getDiagnosticString(), HasSubstr("Invalid storage class for pointer operand '1[%p]'")); } } } TEST_P(ValidateFunctionCall, ParameterVariablePointersStorageBuffer) { const std::string storage_class = GetParam(); std::string spirv = GenerateShaderParameter( storage_class, "OpCapability VariablePointersStorageBuffer", "OpExtension \"SPV_KHR_variable_pointers\""); const std::vector valid_storage_classes = { "UniformConstant", "Function", "Private", "Workgroup", "StorageBuffer", "AtomicCounter"}; bool valid = std::find(valid_storage_classes.begin(), valid_storage_classes.end(), storage_class) != valid_storage_classes.end(); CompileSuccessfully(spirv); if (valid) { EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } else { EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Invalid storage class for pointer operand '1[%p]'")); } } TEST_P(ValidateFunctionCall, ParameterVariablePointers) { const std::string storage_class = GetParam(); std::string spirv = GenerateShaderParameter(storage_class, "OpCapability VariablePointers", "OpExtension \"SPV_KHR_variable_pointers\""); const std::vector valid_storage_classes = { "UniformConstant", "Function", "Private", "Workgroup", "StorageBuffer", "AtomicCounter"}; bool valid = std::find(valid_storage_classes.begin(), valid_storage_classes.end(), storage_class) != valid_storage_classes.end(); CompileSuccessfully(spirv); if (valid) { EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } else { EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Invalid storage class for pointer operand '1[%p]'")); } } TEST_P(ValidateFunctionCall, NonMemoryObjectDeclarationNoVariablePointers) { const std::string storage_class = GetParam(); std::string spirv = GenerateShaderAccessChain(storage_class, "", ""); const std::vector valid_storage_classes = { "Function", "Private", "Workgroup", "AtomicCounter"}; bool valid_sc = std::find(valid_storage_classes.begin(), valid_storage_classes.end(), storage_class) != valid_storage_classes.end(); CompileSuccessfully(spirv); spv_result_t expected_result = storage_class == "UniformConstant" ? SPV_SUCCESS : SPV_ERROR_INVALID_ID; EXPECT_EQ(expected_result, ValidateInstructions()); if (valid_sc) { EXPECT_THAT( getDiagnosticString(), HasSubstr( "Pointer operand '2[%gep]' must be a memory object declaration")); } else { if (storage_class == "StorageBuffer") { EXPECT_THAT( getDiagnosticString(), HasSubstr("StorageBuffer pointer operand '2[%gep]' requires a " "variable pointers capability")); } else if (storage_class != "UniformConstant") { EXPECT_THAT( getDiagnosticString(), HasSubstr("Invalid storage class for pointer operand '2[%gep]'")); } } } TEST_P(ValidateFunctionCall, NonMemoryObjectDeclarationVariablePointersStorageBuffer) { const std::string storage_class = GetParam(); std::string spirv = GenerateShaderAccessChain( storage_class, "OpCapability VariablePointersStorageBuffer", "OpExtension \"SPV_KHR_variable_pointers\""); const std::vector valid_storage_classes = { "Function", "Private", "Workgroup", "StorageBuffer", "AtomicCounter"}; bool valid_sc = std::find(valid_storage_classes.begin(), valid_storage_classes.end(), storage_class) != valid_storage_classes.end(); bool validate = storage_class == "StorageBuffer" || storage_class == "UniformConstant"; CompileSuccessfully(spirv); if (validate) { EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } else { EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); if (valid_sc) { EXPECT_THAT( getDiagnosticString(), HasSubstr( "Pointer operand '2[%gep]' must be a memory object declaration")); } else { EXPECT_THAT( getDiagnosticString(), HasSubstr("Invalid storage class for pointer operand '2[%gep]'")); } } } TEST_P(ValidateFunctionCall, NonMemoryObjectDeclarationVariablePointers) { const std::string storage_class = GetParam(); std::string spirv = GenerateShaderAccessChain(storage_class, "OpCapability VariablePointers", "OpExtension \"SPV_KHR_variable_pointers\""); const std::vector valid_storage_classes = { "Function", "Private", "Workgroup", "StorageBuffer", "AtomicCounter"}; bool valid_sc = std::find(valid_storage_classes.begin(), valid_storage_classes.end(), storage_class) != valid_storage_classes.end(); bool validate = storage_class == "StorageBuffer" || storage_class == "Workgroup" || storage_class == "UniformConstant"; CompileSuccessfully(spirv); if (validate) { EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } else { EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); if (valid_sc) { EXPECT_THAT( getDiagnosticString(), HasSubstr( "Pointer operand '2[%gep]' must be a memory object declaration")); } else { EXPECT_THAT( getDiagnosticString(), HasSubstr("Invalid storage class for pointer operand '2[%gep]'")); } } } TEST_F(ValidateFunctionCall, LogicallyMatchingPointers) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 OpSource HLSL 600 OpDecorate %2 DescriptorSet 0 OpDecorate %2 Binding 0 OpMemberDecorate %_struct_3 0 Offset 0 OpDecorate %_runtimearr__struct_3 ArrayStride 4 OpMemberDecorate %_struct_5 0 Offset 0 OpDecorate %_struct_5 BufferBlock %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_struct_3 = OpTypeStruct %int %_runtimearr__struct_3 = OpTypeRuntimeArray %_struct_3 %_struct_5 = OpTypeStruct %_runtimearr__struct_3 %_ptr_Uniform__struct_5 = OpTypePointer Uniform %_struct_5 %void = OpTypeVoid %14 = OpTypeFunction %void %_struct_15 = OpTypeStruct %int %_ptr_Function__struct_15 = OpTypePointer Function %_struct_15 %_ptr_Uniform__struct_3 = OpTypePointer Uniform %_struct_3 %18 = OpTypeFunction %void %_ptr_Function__struct_15 %2 = OpVariable %_ptr_Uniform__struct_5 Uniform %1 = OpFunction %void None %14 %19 = OpLabel %20 = OpAccessChain %_ptr_Uniform__struct_3 %2 %int_0 %uint_0 %21 = OpFunctionCall %void %22 %20 OpReturn OpFunctionEnd %22 = OpFunction %void None %18 %23 = OpFunctionParameter %_ptr_Function__struct_15 %24 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); spvValidatorOptionsSetBeforeHlslLegalization(getValidatorOptions(), true); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateFunctionCall, LogicallyMatchingPointersNestedStruct) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 OpSource HLSL 600 OpDecorate %2 DescriptorSet 0 OpDecorate %2 Binding 0 OpMemberDecorate %_struct_3 0 Offset 0 OpMemberDecorate %_struct_4 0 Offset 0 OpDecorate %_runtimearr__struct_4 ArrayStride 4 OpMemberDecorate %_struct_6 0 Offset 0 OpDecorate %_struct_6 BufferBlock %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_struct_3 = OpTypeStruct %int %_struct_4 = OpTypeStruct %_struct_3 %_runtimearr__struct_4 = OpTypeRuntimeArray %_struct_4 %_struct_6 = OpTypeStruct %_runtimearr__struct_4 %_ptr_Uniform__struct_6 = OpTypePointer Uniform %_struct_6 %void = OpTypeVoid %13 = OpTypeFunction %void %_struct_14 = OpTypeStruct %int %_struct_15 = OpTypeStruct %_struct_14 %_ptr_Function__struct_15 = OpTypePointer Function %_struct_15 %_ptr_Uniform__struct_4 = OpTypePointer Uniform %_struct_4 %18 = OpTypeFunction %void %_ptr_Function__struct_15 %2 = OpVariable %_ptr_Uniform__struct_6 Uniform %1 = OpFunction %void None %13 %19 = OpLabel %20 = OpVariable %_ptr_Function__struct_15 Function %21 = OpAccessChain %_ptr_Uniform__struct_4 %2 %int_0 %uint_0 %22 = OpFunctionCall %void %23 %21 OpReturn OpFunctionEnd %23 = OpFunction %void None %18 %24 = OpFunctionParameter %_ptr_Function__struct_15 %25 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); spvValidatorOptionsSetBeforeHlslLegalization(getValidatorOptions(), true); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateFunctionCall, LogicallyMatchingPointersNestedArray) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 OpSource HLSL 600 OpDecorate %2 DescriptorSet 0 OpDecorate %2 Binding 0 OpDecorate %_arr_int_uint_10 ArrayStride 4 OpMemberDecorate %_struct_4 0 Offset 0 OpDecorate %_runtimearr__struct_4 ArrayStride 40 OpMemberDecorate %_struct_6 0 Offset 0 OpDecorate %_struct_6 BufferBlock %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_10 = OpConstant %uint 10 %_arr_int_uint_10 = OpTypeArray %int %uint_10 %_struct_4 = OpTypeStruct %_arr_int_uint_10 %_runtimearr__struct_4 = OpTypeRuntimeArray %_struct_4 %_struct_6 = OpTypeStruct %_runtimearr__struct_4 %_ptr_Uniform__struct_6 = OpTypePointer Uniform %_struct_6 %void = OpTypeVoid %14 = OpTypeFunction %void %_ptr_Uniform__struct_4 = OpTypePointer Uniform %_struct_4 %_arr_int_uint_10_0 = OpTypeArray %int %uint_10 %_struct_17 = OpTypeStruct %_arr_int_uint_10_0 %_ptr_Function__struct_17 = OpTypePointer Function %_struct_17 %19 = OpTypeFunction %void %_ptr_Function__struct_17 %2 = OpVariable %_ptr_Uniform__struct_6 Uniform %1 = OpFunction %void None %14 %20 = OpLabel %21 = OpAccessChain %_ptr_Uniform__struct_4 %2 %int_0 %uint_0 %22 = OpFunctionCall %void %23 %21 OpReturn OpFunctionEnd %23 = OpFunction %void None %19 %24 = OpFunctionParameter %_ptr_Function__struct_17 %25 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); spvValidatorOptionsSetBeforeHlslLegalization(getValidatorOptions(), true); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateFunctionCall, LogicallyMismatchedPointersMissingMember) { // Validation should fail because the formal parameter type has two members, // while the actual parameter only has 1. std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 OpSource HLSL 600 OpDecorate %2 DescriptorSet 0 OpDecorate %2 Binding 0 OpMemberDecorate %_struct_3 0 Offset 0 OpDecorate %_runtimearr__struct_3 ArrayStride 4 OpMemberDecorate %_struct_5 0 Offset 0 OpDecorate %_struct_5 BufferBlock %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_struct_3 = OpTypeStruct %int %_runtimearr__struct_3 = OpTypeRuntimeArray %_struct_3 %_struct_5 = OpTypeStruct %_runtimearr__struct_3 %_ptr_Uniform__struct_5 = OpTypePointer Uniform %_struct_5 %void = OpTypeVoid %14 = OpTypeFunction %void %_struct_15 = OpTypeStruct %int %int %_ptr_Function__struct_15 = OpTypePointer Function %_struct_15 %_ptr_Uniform__struct_3 = OpTypePointer Uniform %_struct_3 %18 = OpTypeFunction %void %_ptr_Function__struct_15 %2 = OpVariable %_ptr_Uniform__struct_5 Uniform %1 = OpFunction %void None %14 %19 = OpLabel %20 = OpAccessChain %_ptr_Uniform__struct_3 %2 %int_0 %uint_0 %21 = OpFunctionCall %void %22 %20 OpReturn OpFunctionEnd %22 = OpFunction %void None %18 %23 = OpFunctionParameter %_ptr_Function__struct_15 %24 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); spvValidatorOptionsSetBeforeHlslLegalization(getValidatorOptions(), true); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpFunctionCall Argument ")); EXPECT_THAT(getDiagnosticString(), HasSubstr("type does not match Function ")); } TEST_F(ValidateFunctionCall, LogicallyMismatchedPointersDifferentMemberType) { // Validation should fail because the formal parameter has a member that is // a different type than the actual parameter. std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 OpSource HLSL 600 OpDecorate %2 DescriptorSet 0 OpDecorate %2 Binding 0 OpMemberDecorate %_struct_3 0 Offset 0 OpDecorate %_runtimearr__struct_3 ArrayStride 4 OpMemberDecorate %_struct_5 0 Offset 0 OpDecorate %_struct_5 BufferBlock %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_struct_3 = OpTypeStruct %uint %_runtimearr__struct_3 = OpTypeRuntimeArray %_struct_3 %_struct_5 = OpTypeStruct %_runtimearr__struct_3 %_ptr_Uniform__struct_5 = OpTypePointer Uniform %_struct_5 %void = OpTypeVoid %14 = OpTypeFunction %void %_struct_15 = OpTypeStruct %int %_ptr_Function__struct_15 = OpTypePointer Function %_struct_15 %_ptr_Uniform__struct_3 = OpTypePointer Uniform %_struct_3 %18 = OpTypeFunction %void %_ptr_Function__struct_15 %2 = OpVariable %_ptr_Uniform__struct_5 Uniform %1 = OpFunction %void None %14 %19 = OpLabel %20 = OpAccessChain %_ptr_Uniform__struct_3 %2 %int_0 %uint_0 %21 = OpFunctionCall %void %22 %20 OpReturn OpFunctionEnd %22 = OpFunction %void None %18 %23 = OpFunctionParameter %_ptr_Function__struct_15 %24 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); spvValidatorOptionsSetBeforeHlslLegalization(getValidatorOptions(), true); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpFunctionCall Argument ")); EXPECT_THAT(getDiagnosticString(), HasSubstr("type does not match Function ")); } TEST_F(ValidateFunctionCall, LogicallyMismatchedPointersIncompatableDecorations) { // Validation should fail because the formal parameter has an incompatible // decoration. std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 OpSource HLSL 600 OpDecorate %2 DescriptorSet 0 OpDecorate %2 Binding 0 OpMemberDecorate %_struct_3 0 Offset 0 OpDecorate %_runtimearr__struct_3 ArrayStride 4 OpMemberDecorate %_struct_5 0 Offset 0 OpDecorate %_struct_5 Block OpMemberDecorate %_struct_15 0 NonWritable %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_struct_3 = OpTypeStruct %int %_runtimearr__struct_3 = OpTypeRuntimeArray %_struct_3 %_struct_5 = OpTypeStruct %_runtimearr__struct_3 %_ptr_StorageBuffer__struct_5 = OpTypePointer StorageBuffer %_struct_5 %void = OpTypeVoid %14 = OpTypeFunction %void %_struct_15 = OpTypeStruct %int %_ptr_Function__struct_15 = OpTypePointer Function %_struct_15 %_ptr_StorageBuffer__struct_3 = OpTypePointer StorageBuffer %_struct_3 %18 = OpTypeFunction %void %_ptr_Function__struct_15 %2 = OpVariable %_ptr_StorageBuffer__struct_5 StorageBuffer %1 = OpFunction %void None %14 %19 = OpLabel %20 = OpAccessChain %_ptr_StorageBuffer__struct_3 %2 %int_0 %uint_0 %21 = OpFunctionCall %void %22 %20 OpReturn OpFunctionEnd %22 = OpFunction %void None %18 %23 = OpFunctionParameter %_ptr_Function__struct_15 %24 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); spvValidatorOptionsSetBeforeHlslLegalization(getValidatorOptions(), true); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpFunctionCall Argument ")); EXPECT_THAT(getDiagnosticString(), HasSubstr("type does not match Function ")); } TEST_F(ValidateFunctionCall, LogicallyMismatchedPointersIncompatableDecorations2) { // Validation should fail because the formal parameter has an incompatible // decoration. std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 OpSource HLSL 600 OpDecorate %2 DescriptorSet 0 OpDecorate %2 Binding 0 OpMemberDecorate %_struct_3 0 Offset 0 OpDecorate %_runtimearr__struct_3 ArrayStride 4 OpMemberDecorate %_struct_5 0 Offset 0 OpDecorate %_struct_5 BufferBlock OpDecorate %_ptr_Uniform__struct_3 ArrayStride 4 OpDecorate %_ptr_Uniform__struct_3_0 ArrayStride 8 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_struct_3 = OpTypeStruct %int %_runtimearr__struct_3 = OpTypeRuntimeArray %_struct_3 %_struct_5 = OpTypeStruct %_runtimearr__struct_3 %_ptr_Uniform__struct_5 = OpTypePointer Uniform %_struct_5 %void = OpTypeVoid %14 = OpTypeFunction %void %_ptr_Uniform__struct_3 = OpTypePointer Uniform %_struct_3 %_ptr_Uniform__struct_3_0 = OpTypePointer Uniform %_struct_3 %18 = OpTypeFunction %void %_ptr_Uniform__struct_3_0 %2 = OpVariable %_ptr_Uniform__struct_5 Uniform %1 = OpFunction %void None %14 %19 = OpLabel %20 = OpAccessChain %_ptr_Uniform__struct_3 %2 %int_0 %uint_0 %21 = OpFunctionCall %void %22 %20 OpReturn OpFunctionEnd %22 = OpFunction %void None %18 %23 = OpFunctionParameter %_ptr_Uniform__struct_3_0 %24 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); spvValidatorOptionsSetBeforeHlslLegalization(getValidatorOptions(), true); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpFunctionCall Argument ")); EXPECT_THAT(getDiagnosticString(), HasSubstr("type does not match Function ")); } TEST_F(ValidateFunctionCall, LogicallyMismatchedPointersArraySize) { // Validation should fail because the formal parameter array has a different // number of element than the actual parameter. std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "main" OpExecutionMode %1 LocalSize 1 1 1 OpSource HLSL 600 OpDecorate %2 DescriptorSet 0 OpDecorate %2 Binding 0 OpDecorate %_arr_int_uint_10 ArrayStride 4 OpMemberDecorate %_struct_4 0 Offset 0 OpDecorate %_runtimearr__struct_4 ArrayStride 40 OpMemberDecorate %_struct_6 0 Offset 0 OpDecorate %_struct_6 BufferBlock %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_5 = OpConstant %uint 5 %uint_10 = OpConstant %uint 10 %_arr_int_uint_10 = OpTypeArray %int %uint_10 %_struct_4 = OpTypeStruct %_arr_int_uint_10 %_runtimearr__struct_4 = OpTypeRuntimeArray %_struct_4 %_struct_6 = OpTypeStruct %_runtimearr__struct_4 %_ptr_Uniform__struct_6 = OpTypePointer Uniform %_struct_6 %void = OpTypeVoid %14 = OpTypeFunction %void %_ptr_Uniform__struct_4 = OpTypePointer Uniform %_struct_4 %_arr_int_uint_5 = OpTypeArray %int %uint_5 %_struct_17 = OpTypeStruct %_arr_int_uint_5 %_ptr_Function__struct_17 = OpTypePointer Function %_struct_17 %19 = OpTypeFunction %void %_ptr_Function__struct_17 %2 = OpVariable %_ptr_Uniform__struct_6 Uniform %1 = OpFunction %void None %14 %20 = OpLabel %21 = OpAccessChain %_ptr_Uniform__struct_4 %2 %int_0 %uint_0 %22 = OpFunctionCall %void %23 %21 OpReturn OpFunctionEnd %23 = OpFunction %void None %19 %24 = OpFunctionParameter %_ptr_Function__struct_17 %25 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); spvValidatorOptionsSetBeforeHlslLegalization(getValidatorOptions(), true); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpFunctionCall Argument ")); EXPECT_THAT(getDiagnosticString(), HasSubstr("type does not match Function ")); } TEST_F(ValidateFunctionCall, UntypedPointerParameterMismatch) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpName %var "var" OpName %ptr2 "ptr2" %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr = OpTypeUntypedPointerKHR Private %ptr2 = OpTypeUntypedPointerKHR Private %var = OpUntypedVariableKHR %ptr Private %int %void_fn = OpTypeFunction %void %ptr_fn = OpTypeFunction %void %ptr2 %foo = OpFunction %void None %ptr_fn %param = OpFunctionParameter %ptr2 %first = OpLabel OpReturn OpFunctionEnd %main = OpFunction %void None %void_fn %entry = OpLabel %call = OpFunctionCall %void %foo %var OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpFunctionCall Argument '2[%var]'s type does not " "match Function '3[%ptr2]'s parameter type")); } TEST_F(ValidateFunctionCall, UntypedPointerParameterGood) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpName %var "var" %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr = OpTypeUntypedPointerKHR Private %var = OpUntypedVariableKHR %ptr Private %int %void_fn = OpTypeFunction %void %ptr_fn = OpTypeFunction %void %ptr %foo = OpFunction %void None %ptr_fn %param = OpFunctionParameter %ptr %first = OpLabel OpReturn OpFunctionEnd %main = OpFunction %void None %void_fn %entry = OpLabel %call = OpFunctionCall %void %foo %var OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateFunctionCall, UntypedPointerParameterNotMemoryObjectDeclaration) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpName %var "var" OpName %gep "gep" %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %struct = OpTypeStruct %int %ptr = OpTypeUntypedPointerKHR Private %var = OpUntypedVariableKHR %ptr Private %int %void_fn = OpTypeFunction %void %ptr_fn = OpTypeFunction %void %ptr %foo = OpFunction %void None %ptr_fn %param = OpFunctionParameter %ptr %first = OpLabel OpReturn OpFunctionEnd %main = OpFunction %void None %void_fn %entry = OpLabel %gep = OpUntypedAccessChainKHR %ptr %struct %var %int_0 %call = OpFunctionCall %void %foo %gep OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Pointer operand '3[%gep]' must be a memory object declaration")); } INSTANTIATE_TEST_SUITE_P(StorageClass, ValidateFunctionCall, Values("UniformConstant", "Input", "Uniform", "Output", "Workgroup", "Private", "Function", "PushConstant", "Image", "StorageBuffer", "AtomicCounter")); } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_id_test.cpp000066400000000000000000007205051475742701700233040ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // Modifications Copyright (C) 2024 Advanced Micro Devices, Inc. All rights // reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include "gmock/gmock.h" #include "test/test_fixture.h" #include "test/unit_spirv.h" #include "test/val/val_fixtures.h" // NOTE: The tests in this file are ONLY testing ID usage, there for the input // SPIR-V does not follow the logical layout rules from the spec in all cases in // order to makes the tests smaller. Validation of the whole module is handled // in stages, ID validation is only one of these stages. All validation stages // are stand alone. namespace spvtools { namespace val { namespace { using spvtest::ScopedContext; using ::testing::HasSubstr; using ::testing::ValuesIn; class ValidateIdWithMessage : public spvtest::ValidateBase { public: ValidateIdWithMessage() { const bool use_friendly_names = GetParam(); spvValidatorOptionsSetFriendlyNames(options_, use_friendly_names); } std::string make_message(const char* msg); }; std::string kOpCapabilitySetupWithoutVector16 = R"( OpCapability Shader OpCapability Linkage OpCapability Addresses OpCapability Int8 OpCapability Int16 OpCapability Int64 OpCapability Float64 OpCapability LiteralSampler OpCapability Pipes OpCapability DeviceEnqueue )"; std::string kOpCapabilitySetup = R"( OpCapability Shader OpCapability Linkage OpCapability Addresses OpCapability Int8 OpCapability Int16 OpCapability Int64 OpCapability Float64 OpCapability LiteralSampler OpCapability Pipes OpCapability DeviceEnqueue OpCapability Vector16 )"; std::string kOpVariablePtrSetUp = R"( OpCapability VariablePointers OpExtension "SPV_KHR_variable_pointers" )"; std::string kGLSL450MemoryModel = kOpCapabilitySetup + kOpVariablePtrSetUp + R"( OpMemoryModel Logical GLSL450 )"; std::string kGLSL450MemoryModelWithoutVector16 = kOpCapabilitySetupWithoutVector16 + kOpVariablePtrSetUp + R"( OpMemoryModel Logical GLSL450 )"; std::string kNoKernelGLSL450MemoryModel = R"( OpCapability Shader OpCapability Linkage OpCapability Addresses OpCapability Int8 OpCapability Int16 OpCapability Int64 OpCapability Float64 OpMemoryModel Logical GLSL450 )"; std::string kOpenCLMemoryModel32 = R"( OpCapability Addresses OpCapability Linkage OpCapability Kernel %1 = OpExtInstImport "OpenCL.std" OpMemoryModel Physical32 OpenCL )"; std::string kOpenCLMemoryModel64 = R"( OpCapability Addresses OpCapability Linkage OpCapability Kernel OpCapability Int64 %1 = OpExtInstImport "OpenCL.std" OpMemoryModel Physical64 OpenCL )"; std::string sampledImageSetup = R"( %void = OpTypeVoid %typeFuncVoid = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %image_type = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_img = OpTypePointer UniformConstant %image_type %tex = OpVariable %_ptr_UniformConstant_img UniformConstant %sampler_type = OpTypeSampler %_ptr_UniformConstant_sam = OpTypePointer UniformConstant %sampler_type %s = OpVariable %_ptr_UniformConstant_sam UniformConstant %sampled_image_type = OpTypeSampledImage %image_type %v2float = OpTypeVector %float 2 %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %const_vec_1_1 = OpConstantComposite %v2float %float_1 %float_1 %const_vec_2_2 = OpConstantComposite %v2float %float_2 %float_2 %bool_type = OpTypeBool %spec_true = OpSpecConstantTrue %bool_type %main = OpFunction %void None %typeFuncVoid %label_1 = OpLabel %image_inst = OpLoad %image_type %tex %sampler_inst = OpLoad %sampler_type %s )"; std::string BranchConditionalSetup = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 140 OpName %main "main" ; type definitions %bool = OpTypeBool %uint = OpTypeInt 32 0 %int = OpTypeInt 32 1 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 ; constants %true = OpConstantTrue %bool %i0 = OpConstant %int 0 %i1 = OpConstant %int 1 %f0 = OpConstant %float 0 %f1 = OpConstant %float 1 ; main function header %void = OpTypeVoid %voidfunc = OpTypeFunction %void %main = OpFunction %void None %voidfunc %lmain = OpLabel )"; std::string BranchConditionalTail = R"( %target_t = OpLabel OpNop OpBranch %end %target_f = OpLabel OpNop OpBranch %end %end = OpLabel OpReturn OpFunctionEnd )"; // Transform an expected validation message to either use friendly names (as // provided in the message) or replace the friendly names by the corresponding // id. The same flag used to configure the validator to output friendly names // or not is used here. std::string ValidateIdWithMessage::make_message(const char* msg) { const bool use_friendly_names = GetParam(); if (use_friendly_names) { return msg; } std::string message(msg); std::ostringstream result; size_t next = 0; while (next < message.size()) { // Parse 'num[%name]' size_t open_quote = message.find('\'', next); if (open_quote == std::string::npos) { break; } // Copy up to the first quote result.write(msg + next, open_quote - next); // Handle apostrophes if (!isdigit(message[open_quote + 1])) { result << '\''; next = open_quote + 1; continue; } size_t open_bracket = message.find('[', open_quote + 1); assert(open_bracket != std::string::npos); size_t close_bracket = message.find(']', open_bracket + 1); assert(close_bracket != std::string::npos); size_t close_quote = close_bracket + 1; assert(close_quote < message.size() && message[close_quote] == '\''); // Change to 'num[%num]' because friendly names are not being used. result.write(msg + open_quote, open_bracket - open_quote + 1); result << '%'; result.write(msg + open_quote + 1, open_bracket - open_quote - 1); result << "]'"; // Continue to the next id, or end of string. next = close_quote + 1; } return result.str(); } // TODO: OpUndef TEST_P(ValidateIdWithMessage, OpName) { std::string spirv = kGLSL450MemoryModel + R"( OpName %2 "name" %1 = OpTypeInt 32 0 %2 = OpTypePointer UniformConstant %1 %3 = OpVariable %2 UniformConstant)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpMemberNameGood) { std::string spirv = kGLSL450MemoryModel + R"( OpMemberName %2 0 "foo" %1 = OpTypeInt 32 0 %2 = OpTypeStruct %1)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpMemberNameTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( OpMemberName %1 0 "foo" %1 = OpTypeInt 32 0)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpMemberName Type '1[%uint]' is not a struct type."))); } TEST_P(ValidateIdWithMessage, OpMemberNameMemberBad) { std::string spirv = kGLSL450MemoryModel + R"( OpMemberName %1 1 "foo" %2 = OpTypeInt 32 0 %1 = OpTypeStruct %2)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpMemberName Member '1[%_struct_1]' index is larger " "than Type '1[%_struct_1]'s member count."))); } TEST_P(ValidateIdWithMessage, OpLineGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpString "/path/to/source.file" OpLine %1 0 0 %2 = OpTypeInt 32 0 %3 = OpTypePointer Input %2 %4 = OpVariable %3 Input)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpLineFileBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 OpLine %1 0 0 )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpLine Target '1[%uint]' is not an OpString."))); } TEST_P(ValidateIdWithMessage, OpDecorateGood) { std::string spirv = kGLSL450MemoryModel + R"( OpDecorate %2 GLSLShared %1 = OpTypeInt 64 0 %2 = OpTypeStruct %1 %1)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpDecorateBad) { std::string spirv = kGLSL450MemoryModel + R"( OpDecorate %1 GLSLShared)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("forward referenced IDs have not been defined"))); } TEST_P(ValidateIdWithMessage, OpMemberDecorateGood) { std::string spirv = kGLSL450MemoryModel + R"( OpMemberDecorate %2 0 RelaxedPrecision %1 = OpTypeInt 32 0 %2 = OpTypeStruct %1 %1)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpMemberDecorateBad) { std::string spirv = kGLSL450MemoryModel + R"( OpMemberDecorate %1 0 RelaxedPrecision %1 = OpTypeInt 32 0)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpMemberDecorate Structure type '1[%uint]' is " "not a struct type."))); } TEST_P(ValidateIdWithMessage, OpMemberDecorateMemberBad) { std::string spirv = kGLSL450MemoryModel + R"( OpMemberDecorate %1 3 RelaxedPrecision %int = OpTypeInt 32 0 %1 = OpTypeStruct %int %int)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "Index 3 provided in OpMemberDecorate for struct " "'1[%_struct_1]' is out of bounds. The structure has 2 " "members. Largest valid index is 1."))); } TEST_P(ValidateIdWithMessage, OpGroupDecorateGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpDecorationGroup OpDecorate %1 RelaxedPrecision OpDecorate %1 GLSLShared OpGroupDecorate %1 %3 %4 %2 = OpTypeInt 32 0 %3 = OpConstant %2 42 %4 = OpConstant %2 23)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpDecorationGroupBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpDecorationGroup OpDecorate %1 RelaxedPrecision OpDecorate %1 GLSLShared OpMemberDecorate %1 0 Constant )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "Result id of OpDecorationGroup can only " "be targeted by OpName, OpGroupDecorate, " "OpDecorate, OpDecorateId, and OpGroupMemberDecorate"))); } TEST_P(ValidateIdWithMessage, OpGroupDecorateDecorationGroupBad) { std::string spirv = R"( OpCapability Shader OpCapability Linkage %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpGroupDecorate %1 %2 %3 %2 = OpTypeInt 32 0 %3 = OpConstant %2 42)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpGroupDecorate Decoration group '1[%1]' is not " "a decoration group."))); } TEST_P(ValidateIdWithMessage, OpGroupDecorateTargetBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpDecorationGroup OpDecorate %1 RelaxedPrecision OpDecorate %1 GLSLShared OpGroupDecorate %1 %3 %2 = OpTypeInt 32 0)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("forward referenced IDs have not been defined"))); } TEST_P(ValidateIdWithMessage, OpGroupMemberDecorateDecorationGroupBad) { std::string spirv = R"( OpCapability Shader OpCapability Linkage %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpGroupMemberDecorate %1 %2 0 %2 = OpTypeInt 32 0)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpGroupMemberDecorate Decoration group '1[%1]' " "is not a decoration group."))); } TEST_P(ValidateIdWithMessage, OpGroupMemberDecorateIdNotStructBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpDecorationGroup OpGroupMemberDecorate %1 %2 0 %2 = OpTypeInt 32 0)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpGroupMemberDecorate Structure type '2[%uint]' " "is not a struct type."))); } TEST_P(ValidateIdWithMessage, OpGroupMemberDecorateIndexOutOfBoundBad) { std::string spirv = kGLSL450MemoryModel + R"( OpDecorate %1 Offset 0 %1 = OpDecorationGroup OpGroupMemberDecorate %1 %struct 3 %float = OpTypeFloat 32 %struct = OpTypeStruct %float %float %float )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "Index 3 provided in OpGroupMemberDecorate for struct " " '2[%_struct_2]' is out of bounds. The structure " "has 3 members. Largest valid index is 2."))); } // TODO: OpExtInst TEST_P(ValidateIdWithMessage, OpEntryPointGood) { std::string spirv = kGLSL450MemoryModel + R"( OpEntryPoint GLCompute %3 "" %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpFunction %1 None %2 %4 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpEntryPointFunctionBad) { std::string spirv = kGLSL450MemoryModel + R"( OpEntryPoint GLCompute %1 "" %1 = OpTypeVoid)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpEntryPoint Entry Point '1[%void]' is not a " "function."))); } TEST_P(ValidateIdWithMessage, OpEntryPointParameterCountBad) { std::string spirv = kGLSL450MemoryModel + R"( OpEntryPoint GLCompute %1 "" %2 = OpTypeVoid %3 = OpTypeFunction %2 %2 %1 = OpFunction %2 None %3 %4 = OpLabel OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("OpEntryPoint Entry Point '1[%1]'s function " "parameter count is not zero"))); } TEST_P(ValidateIdWithMessage, OpEntryPointReturnTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( OpEntryPoint GLCompute %1 "" %2 = OpTypeInt 32 0 %ret = OpConstant %2 0 %3 = OpTypeFunction %2 %1 = OpFunction %2 None %3 %4 = OpLabel OpReturnValue %ret OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("OpEntryPoint Entry Point '1[%1]'s function " "return type is not void."))); } TEST_P(ValidateIdWithMessage, OpEntryPointParameterCountBadInVulkan) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "" %2 = OpTypeVoid %3 = OpTypeFunction %2 %2 %1 = OpFunction %2 None %3 %4 = OpLabel OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-None-04633")); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("OpEntryPoint Entry Point '1[%1]'s function " "parameter count is not zero"))); } TEST_P(ValidateIdWithMessage, OpEntryPointReturnTypeBadInVulkan) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %1 "" %2 = OpTypeInt 32 0 %ret = OpConstant %2 0 %3 = OpTypeFunction %2 %1 = OpFunction %2 None %3 %4 = OpLabel OpReturnValue %ret OpFunctionEnd)"; CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-None-04633")); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("OpEntryPoint Entry Point '1[%1]'s function " "return type is not void."))); } TEST_P(ValidateIdWithMessage, OpEntryPointInterfaceIsNotVariableTypeBad) { std::string spirv = R"( OpCapability Shader OpCapability Geometry OpMemoryModel Logical GLSL450 OpEntryPoint Geometry %main "main" %ptr_builtin_1 OpExecutionMode %main InputPoints OpExecutionMode %main OutputPoints OpMemberDecorate %struct_1 0 BuiltIn InvocationId %int = OpTypeInt 32 1 %void = OpTypeVoid %func = OpTypeFunction %void %struct_1 = OpTypeStruct %int %ptr_builtin_1 = OpTypePointer Input %struct_1 %main = OpFunction %void None %func %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Interfaces passed to OpEntryPoint must be variables. " "Found OpTypePointer.")); } TEST_P(ValidateIdWithMessage, OpEntryPointInterfaceStorageClassBad) { std::string spirv = R"( OpCapability Shader OpCapability Geometry OpMemoryModel Logical GLSL450 OpEntryPoint Geometry %main "main" %in_1 OpExecutionMode %main InputPoints OpExecutionMode %main OutputPoints OpMemberDecorate %struct_1 0 BuiltIn InvocationId %int = OpTypeInt 32 1 %void = OpTypeVoid %func = OpTypeFunction %void %struct_1 = OpTypeStruct %int %ptr_builtin_1 = OpTypePointer Uniform %struct_1 %in_1 = OpVariable %ptr_builtin_1 Uniform %main = OpFunction %void None %func %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpEntryPoint interfaces must be OpVariables with " "Storage Class of Input(1) or Output(3). Found Storage " "Class 2 for Entry Point id 1."))); } TEST_P(ValidateIdWithMessage, OpExecutionModeGood) { std::string spirv = kGLSL450MemoryModel + R"( OpEntryPoint GLCompute %3 "" OpExecutionMode %3 LocalSize 1 1 1 %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpFunction %1 None %2 %4 = OpLabel OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpExecutionModeEntryPointMissing) { std::string spirv = kGLSL450MemoryModel + R"( OpExecutionMode %3 LocalSize 1 1 1 %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpFunction %1 None %2 %4 = OpLabel OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpExecutionMode Entry Point '1[%1]' is not the " "Entry Point operand of an OpEntryPoint."))); } TEST_P(ValidateIdWithMessage, OpExecutionModeEntryPointBad) { std::string spirv = kGLSL450MemoryModel + R"( OpEntryPoint GLCompute %3 "" %a OpExecutionMode %a LocalSize 1 1 1 %void = OpTypeVoid %ptr = OpTypePointer Input %void %a = OpVariable %ptr Input %2 = OpTypeFunction %void %3 = OpFunction %void None %2 %4 = OpLabel OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpExecutionMode Entry Point '2[%2]' is not the " "Entry Point operand of an OpEntryPoint."))); } TEST_P(ValidateIdWithMessage, OpTypeVectorFloat) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpTypeVectorInt) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpTypeVector %1 4)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpTypeVectorUInt) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 64 0 %2 = OpTypeVector %1 4)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpTypeVectorBool) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeBool %2 = OpTypeVector %1 4)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpTypeVectorComponentTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeFloat 32 %2 = OpTypePointer UniformConstant %1 %3 = OpTypeVector %2 4)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpTypeVector Component Type " "'2[%_ptr_UniformConstant_float]' is not a scalar type."))); } TEST_P(ValidateIdWithMessage, OpTypeVectorColumnCountLessThanTwoBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 1)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message( "Illegal number of components (1) for TypeVector\n %v1float = " "OpTypeVector %float 1\n"))); } TEST_P(ValidateIdWithMessage, OpTypeVectorColumnCountGreaterThanFourBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 5)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message( "Illegal number of components (5) for TypeVector\n %v5float = " "OpTypeVector %float 5\n"))); } TEST_P(ValidateIdWithMessage, OpTypeVectorColumnCountEightWithoutVector16Bad) { std::string spirv = kGLSL450MemoryModelWithoutVector16 + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 8)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "Having 8 components for TypeVector requires the Vector16 " "capability\n %v8float = OpTypeVector %float 8\n"))); } TEST_P(ValidateIdWithMessage, OpTypeVectorColumnCountSixteenWithoutVector16Bad) { std::string spirv = kGLSL450MemoryModelWithoutVector16 + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 16)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "Having 16 components for TypeVector requires the Vector16 " "capability\n %v16float = OpTypeVector %float 16\n"))); } TEST_P(ValidateIdWithMessage, OpTypeVectorColumnCountOfEightWithVector16Good) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 8)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpTypeVectorColumnCountOfSixteenWithVector16Good) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 16)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpTypeMatrixGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 2 %3 = OpTypeMatrix %2 3)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpTypeMatrixColumnTypeNonVectorBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeFloat 32 %2 = OpTypeMatrix %1 3)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "olumns in a matrix must be of type vector.\n %mat3float = " "OpTypeMatrix %float 3\n"))); } TEST_P(ValidateIdWithMessage, OpTypeMatrixVectorTypeNonFloatBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 16 0 %2 = OpTypeVector %1 2 %3 = OpTypeMatrix %2 2)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "Matrix types can only be parameterized with floating-point " "types.\n %mat2v2ushort = OpTypeMatrix %v2ushort 2\n"))); } TEST_P(ValidateIdWithMessage, OpTypeMatrixColumnCountLessThanTwoBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 2 %3 = OpTypeMatrix %2 1)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message( "Matrix types can only be parameterized as having only 2, 3, " "or 4 columns.\n %mat1v2float = OpTypeMatrix %v2float 1\n"))); } TEST_P(ValidateIdWithMessage, OpTypeMatrixColumnCountGreaterThanFourBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 2 %3 = OpTypeMatrix %2 8)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message( "Matrix types can only be parameterized as having only 2, 3, " "or 4 columns.\n %mat8v2float = OpTypeMatrix %v2float 8\n"))); } TEST_P(ValidateIdWithMessage, OpTypeSamplerGood) { // In Rev31, OpTypeSampler takes no arguments. std::string spirv = kGLSL450MemoryModel + R"( %s = OpTypeSampler)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpTypeArrayGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpConstant %1 1 %3 = OpTypeArray %1 %2)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpTypeArrayElementTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpConstant %1 1 %3 = OpTypeArray %2 %2)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpTypeArray Element Type '2[%uint_1]' is not a " "type."))); } // Signed or unsigned. enum Signed { kSigned, kUnsigned }; // Creates an assembly module declaring OpTypeArray with the given length. std::string MakeArrayLength(const std::string& len, Signed isSigned, int width, int max_int_width = 64, bool use_vulkan_memory_model = false) { std::ostringstream ss; ss << R"( OpCapability Shader )"; if (use_vulkan_memory_model) { ss << " OpCapability VulkanMemoryModel\n"; } if (width == 16) { ss << " OpCapability Int16\n"; } if (max_int_width > 32) { ss << "\n OpCapability Int64\n"; } if (use_vulkan_memory_model) { ss << " OpExtension \"SPV_KHR_vulkan_memory_model\"\n"; ss << "OpMemoryModel Logical Vulkan\n"; } else { ss << "OpMemoryModel Logical GLSL450\n"; } ss << "OpEntryPoint GLCompute %main \"main\"\n"; ss << "OpExecutionMode %main LocalSize 1 1 1\n"; ss << " %t = OpTypeInt " << width << (isSigned == kSigned ? " 1" : " 0"); ss << " %l = OpConstant %t " << len; ss << " %a = OpTypeArray %t %l"; ss << " %void = OpTypeVoid \n" " %voidfn = OpTypeFunction %void \n" " %main = OpFunction %void None %voidfn \n" " %entry = OpLabel\n" " OpReturn\n" " OpFunctionEnd\n"; return ss.str(); } // Tests OpTypeArray. Parameter is the width (in bits) of the array-length's // type. class OpTypeArrayLengthTest : public spvtest::TextToBinaryTestBase<::testing::TestWithParam> { protected: OpTypeArrayLengthTest() : env_(SPV_ENV_UNIVERSAL_1_0), position_(spv_position_t{0, 0, 0}), diagnostic_(spvDiagnosticCreate(&position_, "")) {} ~OpTypeArrayLengthTest() override { spvDiagnosticDestroy(diagnostic_); } // Runs spvValidate() on v, printing any errors via spvDiagnosticPrint(). spv_result_t Val(const SpirvVector& v, const std::string& expected_err = "") { spv_const_binary_t cbinary{v.data(), v.size()}; spvDiagnosticDestroy(diagnostic_); diagnostic_ = nullptr; const auto status = spvValidate(ScopedContext(env_).context, &cbinary, &diagnostic_); if (status != SPV_SUCCESS) { spvDiagnosticPrint(diagnostic_); EXPECT_THAT(std::string(diagnostic_->error), testing::ContainsRegex(expected_err)); } return status; } protected: spv_target_env env_; private: spv_position_t position_; // For creating diagnostic_. spv_diagnostic diagnostic_; }; TEST_P(OpTypeArrayLengthTest, LengthPositiveSmall) { const int width = GetParam(); EXPECT_EQ(SPV_SUCCESS, Val(CompileSuccessfully(MakeArrayLength("1", kSigned, width)))); EXPECT_EQ(SPV_SUCCESS, Val(CompileSuccessfully(MakeArrayLength("1", kUnsigned, width)))); EXPECT_EQ(SPV_SUCCESS, Val(CompileSuccessfully(MakeArrayLength("2", kSigned, width)))); EXPECT_EQ(SPV_SUCCESS, Val(CompileSuccessfully(MakeArrayLength("2", kUnsigned, width)))); EXPECT_EQ(SPV_SUCCESS, Val(CompileSuccessfully(MakeArrayLength("55", kSigned, width)))); EXPECT_EQ(SPV_SUCCESS, Val(CompileSuccessfully(MakeArrayLength("55", kUnsigned, width)))); const std::string fpad(width / 4 - 1, 'F'); EXPECT_EQ( SPV_SUCCESS, Val(CompileSuccessfully(MakeArrayLength("0x7" + fpad, kSigned, width)))) << MakeArrayLength("0x7" + fpad, kSigned, width); } TEST_P(OpTypeArrayLengthTest, LengthZero) { const int width = GetParam(); EXPECT_EQ(SPV_ERROR_INVALID_ID, Val(CompileSuccessfully(MakeArrayLength("0", kSigned, width)), "OpTypeArray Length '3\\[%.*\\]' default value must be at " "least 1.")); EXPECT_EQ(SPV_ERROR_INVALID_ID, Val(CompileSuccessfully(MakeArrayLength("0", kUnsigned, width)), "OpTypeArray Length '3\\[%.*\\]' default value must be at " "least 1.")); } TEST_P(OpTypeArrayLengthTest, LengthNegative) { const int width = GetParam(); EXPECT_EQ(SPV_ERROR_INVALID_ID, Val(CompileSuccessfully(MakeArrayLength("-1", kSigned, width)), "OpTypeArray Length '3\\[%.*\\]' default value must be at " "least 1.")); EXPECT_EQ(SPV_ERROR_INVALID_ID, Val(CompileSuccessfully(MakeArrayLength("-2", kSigned, width)), "OpTypeArray Length '3\\[%.*\\]' default value must be at " "least 1.")); EXPECT_EQ(SPV_ERROR_INVALID_ID, Val(CompileSuccessfully(MakeArrayLength("-123", kSigned, width)), "OpTypeArray Length '3\\[%.*\\]' default value must be at " "least 1.")); const std::string neg_max = "0x8" + std::string(width / 4 - 1, '0'); EXPECT_EQ(SPV_ERROR_INVALID_ID, Val(CompileSuccessfully(MakeArrayLength(neg_max, kSigned, width)), "OpTypeArray Length '3\\[%.*\\]' default value must be at " "least 1.")); } // Returns the string form of an integer of the form 0x80....0 of the // given bit width. std::string big_num_ending_0(int bit_width) { return "0x8" + std::string(bit_width / 4 - 1, '0'); } // Returns the string form of an integer of the form 0x80..001 of the // given bit width. std::string big_num_ending_1(int bit_width) { return "0x8" + std::string(bit_width / 4 - 2, '0') + "1"; } TEST_P(OpTypeArrayLengthTest, LengthPositiveHugeEnding0InVulkan) { env_ = SPV_ENV_VULKAN_1_0; const int width = GetParam(); for (int max_int_width : {32, 64}) { if (width > max_int_width) { // Not valid to even make the OpConstant in this case. continue; } const auto module = CompileSuccessfully(MakeArrayLength( big_num_ending_0(width), kUnsigned, width, max_int_width)); EXPECT_EQ(SPV_SUCCESS, Val(module)); } } TEST_P(OpTypeArrayLengthTest, LengthPositiveHugeEnding1InVulkan) { env_ = SPV_ENV_VULKAN_1_0; const int width = GetParam(); for (int max_int_width : {32, 64}) { if (width > max_int_width) { // Not valid to even make the OpConstant in this case. continue; } const auto module = CompileSuccessfully(MakeArrayLength( big_num_ending_1(width), kUnsigned, width, max_int_width)); EXPECT_EQ(SPV_SUCCESS, Val(module)); } } // The only valid widths for integers are 8, 16, 32, and 64. // Since the Int8 capability requires the Kernel capability, and the Kernel // capability prohibits usage of signed integers, we can skip 8-bit integers // here since the purpose of these tests is to check the validity of // OpTypeArray, not OpTypeInt. INSTANTIATE_TEST_SUITE_P(Widths, OpTypeArrayLengthTest, ValuesIn(std::vector{16, 32, 64})); TEST_P(ValidateIdWithMessage, OpTypeArrayLengthNull) { std::string spirv = kGLSL450MemoryModel + R"( %i32 = OpTypeInt 32 0 %len = OpConstantNull %i32 %ary = OpTypeArray %i32 %len)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message("OpTypeArray Length '2[%2]' default " "value must be at least 1: found 0"))); } TEST_P(ValidateIdWithMessage, OpTypeArrayLengthSpecConst) { std::string spirv = kGLSL450MemoryModel + R"( %i32 = OpTypeInt 32 0 %len = OpSpecConstant %i32 2 %ary = OpTypeArray %i32 %len)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpTypeArrayLengthSpecConstOp) { std::string spirv = kGLSL450MemoryModel + R"( %i32 = OpTypeInt 32 0 %c1 = OpConstant %i32 1 %c2 = OpConstant %i32 2 %len = OpSpecConstantOp %i32 IAdd %c1 %c2 %ary = OpTypeArray %i32 %len)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpTypeRuntimeArrayGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpTypeRuntimeArray %1)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpTypeRuntimeArrayBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpConstant %1 0 %3 = OpTypeRuntimeArray %2)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpTypeRuntimeArray Element Type '2[%uint_0]' is not a " "type."))); } // TODO: Object of this type can only be created with OpVariable using the // Uniform Storage Class TEST_P(ValidateIdWithMessage, OpTypeStructGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpTypeFloat 64 %3 = OpTypePointer Input %1 %4 = OpTypeStruct %1 %2 %3)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpTypeStructMemberTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpTypeFloat 64 %3 = OpConstant %2 0.0 %4 = OpTypeStruct %1 %2 %3)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpTypeStruct Member Type '3[%double_0]' is not " "a type."))); } TEST_P(ValidateIdWithMessage, OpTypeStructOpaqueTypeBad) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %1 = OpTypeSampler %2 = OpTypeStruct %1 %void = OpTypeVoid %3 = OpTypeFunction %void %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-None-04667")); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("OpTypeStruct must not contain an opaque type"))); } TEST_P(ValidateIdWithMessage, OpTypePointerGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpTypePointer Input %1)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpTypePointerBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpConstant %1 0 %3 = OpTypePointer Input %2)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("OpTypePointer Type '2[%uint_0]' is not a " "type."))); } TEST_P(ValidateIdWithMessage, OpTypePointerCanHaveUntypedPointer) { const std::string spirv = R"( OpCapability Kernel OpCapability Linkage OpCapability UntypedPointersKHR OpCapability WorkgroupMemoryExplicitLayoutKHR OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical OpenCL %ptr = OpTypeUntypedPointerKHR Workgroup %ptr2 = OpTypePointer Private %ptr )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); } TEST_P(ValidateIdWithMessage, OpTypeUntypedPointerWorkgroupGood) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability UntypedPointersKHR OpCapability WorkgroupMemoryExplicitLayoutKHR OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 %ptr = OpTypeUntypedPointerKHR Workgroup )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); } TEST_P(ValidateIdWithMessage, OpTypeUntypedPointerWorkgroupMissingExplicitLayout) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %ptr = OpTypeUntypedPointerKHR Workgroup %void = OpTypeVoid %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Workgroup storage class untyped pointers in Vulkan require " "WorkgroupMemoryExplicitLayoutKHR be declared")); } TEST_P(ValidateIdWithMessage, OpTypeUntypedPointerWorkgroupGoodAll) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 %ptr = OpTypeUntypedPointerKHR Workgroup )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpTypeUntypedPointerStorageBufferGood) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability UntypedPointersKHR OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 %ptr = OpTypeUntypedPointerKHR StorageBuffer )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpTypeUntypedPointerUniformGood) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 %ptr = OpTypeUntypedPointerKHR Uniform )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpTypeUntypedPointerPushConstantGood) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 %ptr = OpTypeUntypedPointerKHR PushConstant )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpTypeUntypedPointerCrossWorkgroupGood) { const std::string spirv = R"( OpCapability Kernel OpCapability Linkage OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical OpenCL %ptr = OpTypeUntypedPointerKHR CrossWorkgroup )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpTypeUntypedPointerVulkanInvalidStorageClass) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %void_fn = OpTypeFunction %void %ptr = OpTypeUntypedPointerKHR Private %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("In Vulkan, untyped pointers can only be used in an " "explicitly laid out storage class")); } TEST_P(ValidateIdWithMessage, OpTypeFunctionGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeFunction %1)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpTypeFunctionReturnTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpConstant %1 0 %3 = OpTypeFunction %2)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpTypeFunction Return Type '2[%uint_0]' is not " "a type."))); } TEST_P(ValidateIdWithMessage, OpTypeFunctionParameterBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpConstant %2 0 %4 = OpTypeFunction %1 %2 %3)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpTypeFunction Parameter Type '3[%uint_0]' is not a " "type."))); } TEST_P(ValidateIdWithMessage, OpTypeFunctionParameterTypeVoidBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %4 = OpTypeFunction %1 %2 %1)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpTypeFunction Parameter Type '1[%void]' cannot " "be OpTypeVoid."))); } TEST_P(ValidateIdWithMessage, OpTypePipeGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 16 %3 = OpTypePipe ReadOnly)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpConstantTrueGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeBool %2 = OpConstantTrue %1)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpConstantTrueBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpConstantTrue %1)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpConstantTrue Result Type '1[%void]' is not a boolean " "type."))); } TEST_P(ValidateIdWithMessage, OpConstantFalseGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeBool %2 = OpConstantTrue %1)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpConstantFalseBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpConstantFalse %1)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message( "OpConstantFalse Result Type '1[%void]' is not a boolean " "type."))); } TEST_P(ValidateIdWithMessage, OpConstantGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpConstant %1 1)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpConstantBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpConstant !1 !0)"; // The expected failure code is implementation dependent (currently // INVALID_BINARY because the binary parser catches these cases) and may // change over time, but this must always fail. CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_BINARY, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpConstantCompositeVectorGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %3 = OpConstant %1 3.14 %4 = OpConstantComposite %2 %3 %3 %3 %3)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpConstantCompositeVectorWithUndefGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %3 = OpConstant %1 3.14 %9 = OpUndef %1 %4 = OpConstantComposite %2 %3 %3 %3 %9)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpConstantCompositeVectorResultTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %3 = OpConstant %1 3.14 %4 = OpConstantComposite %1 %3 %3 %3 %3)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpConstantComposite Result Type '1[%float]' is not a " "composite type."))); } TEST_P(ValidateIdWithMessage, OpConstantCompositeVectorConstituentTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %4 = OpTypeInt 32 0 %3 = OpConstant %1 3.14 %5 = OpConstant %4 42 ; bad type for constant value %6 = OpConstantComposite %2 %3 %5 %3 %3)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpConstantComposite Constituent '5[%uint_42]'s type " "does not match Result Type '2[%v4float]'s vector " "element type."))); } TEST_P(ValidateIdWithMessage, OpConstantCompositeVectorConstituentUndefTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %4 = OpTypeInt 32 0 %3 = OpConstant %1 3.14 %5 = OpUndef %4 ; bad type for undef value %6 = OpConstantComposite %2 %3 %5 %3 %3)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message( "OpConstantComposite Constituent '5[%5]'s type does not " "match Result Type '2[%v4float]'s vector element type."))); } TEST_P(ValidateIdWithMessage, OpConstantCompositeMatrixGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %3 = OpTypeMatrix %2 4 %4 = OpConstant %1 1.0 %5 = OpConstant %1 0.0 %6 = OpConstantComposite %2 %4 %5 %5 %5 %7 = OpConstantComposite %2 %5 %4 %5 %5 %8 = OpConstantComposite %2 %5 %5 %4 %5 %9 = OpConstantComposite %2 %5 %5 %5 %4 %10 = OpConstantComposite %3 %6 %7 %8 %9)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpConstantCompositeMatrixUndefGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %3 = OpTypeMatrix %2 4 %4 = OpConstant %1 1.0 %5 = OpConstant %1 0.0 %6 = OpConstantComposite %2 %4 %5 %5 %5 %7 = OpConstantComposite %2 %5 %4 %5 %5 %8 = OpConstantComposite %2 %5 %5 %4 %5 %9 = OpUndef %2 %10 = OpConstantComposite %3 %6 %7 %8 %9)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpConstantCompositeMatrixConstituentTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %11 = OpTypeVector %1 3 %3 = OpTypeMatrix %2 4 %4 = OpConstant %1 1.0 %5 = OpConstant %1 0.0 %6 = OpConstantComposite %2 %4 %5 %5 %5 %7 = OpConstantComposite %2 %5 %4 %5 %5 %8 = OpConstantComposite %2 %5 %5 %4 %5 %9 = OpConstantComposite %11 %5 %5 %5 %10 = OpConstantComposite %3 %6 %7 %8 %9)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpConstantComposite Constituent '10[%10]' vector " "component count does not match Result Type " "'4[%mat4v4float]'s vector component count."))); } TEST_P(ValidateIdWithMessage, OpConstantCompositeMatrixConstituentUndefTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %11 = OpTypeVector %1 3 %3 = OpTypeMatrix %2 4 %4 = OpConstant %1 1.0 %5 = OpConstant %1 0.0 %6 = OpConstantComposite %2 %4 %5 %5 %5 %7 = OpConstantComposite %2 %5 %4 %5 %5 %8 = OpConstantComposite %2 %5 %5 %4 %5 %9 = OpUndef %11 %10 = OpConstantComposite %3 %6 %7 %8 %9)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpConstantComposite Constituent '10[%10]' vector " "component count does not match Result Type " "'4[%mat4v4float]'s vector component count."))); } TEST_P(ValidateIdWithMessage, OpConstantCompositeArrayGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpConstant %1 4 %3 = OpTypeArray %1 %2 %4 = OpConstantComposite %3 %2 %2 %2 %2)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpConstantCompositeArrayWithUndefGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpConstant %1 4 %9 = OpUndef %1 %3 = OpTypeArray %1 %2 %4 = OpConstantComposite %3 %2 %2 %2 %9)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpConstantCompositeArrayConstConstituentTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpConstant %1 4 %3 = OpTypeArray %1 %2 %4 = OpConstantComposite %3 %2 %2 %2 %1)"; // Uses a type as operand CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message("Operand '1[%uint]' cannot be a " "type"))); } TEST_P(ValidateIdWithMessage, OpConstantCompositeArrayConstConstituentBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpConstant %1 4 %3 = OpTypeArray %1 %2 %4 = OpTypePointer Uniform %1 %5 = OpVariable %4 Uniform %6 = OpConstantComposite %3 %2 %2 %2 %5)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpConstantComposite Constituent '5[%5]' is not a " "constant or undef."))); } TEST_P(ValidateIdWithMessage, OpConstantCompositeArrayConstituentTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpConstant %1 4 %3 = OpTypeArray %1 %2 %5 = OpTypeFloat 32 %6 = OpConstant %5 3.14 ; bad type for const value %4 = OpConstantComposite %3 %2 %2 %2 %6)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpConstantComposite Constituent " "'5[%float_3_1400001]'s type does not match Result " "Type '3[%_arr_uint_uint_4]'s array element " "type."))); } TEST_P(ValidateIdWithMessage, OpConstantCompositeArrayConstituentUndefTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpConstant %1 4 %3 = OpTypeArray %1 %2 %5 = OpTypeFloat 32 %6 = OpUndef %5 ; bad type for undef %4 = OpConstantComposite %3 %2 %2 %2 %6)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("OpConstantComposite Constituent " "'5[%5]'s type does not match Result " "Type '3[%_arr_uint_uint_4]'s array element " "type."))); } TEST_P(ValidateIdWithMessage, OpConstantCompositeStructGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpTypeInt 64 0 %3 = OpTypeStruct %1 %1 %2 %4 = OpConstant %1 42 %5 = OpConstant %2 4300000000 %6 = OpConstantComposite %3 %4 %4 %5)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpConstantCompositeStructUndefGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpTypeInt 64 0 %3 = OpTypeStruct %1 %1 %2 %4 = OpConstant %1 42 %5 = OpUndef %2 %6 = OpConstantComposite %3 %4 %4 %5)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpConstantCompositeStructMemberTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpTypeInt 64 0 %3 = OpTypeStruct %1 %1 %2 %4 = OpConstant %1 42 %5 = OpConstant %2 4300000000 %6 = OpConstantComposite %3 %4 %5 %4)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpConstantComposite Constituent " "'5[%ulong_4300000000]' type does not match the " "Result Type '3[%_struct_3]'s member type."))); } TEST_P(ValidateIdWithMessage, OpConstantCompositeStructMemberUndefTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpTypeInt 64 0 %3 = OpTypeStruct %1 %1 %2 %4 = OpConstant %1 42 %5 = OpUndef %2 %6 = OpConstantComposite %3 %4 %5 %4)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpConstantComposite Constituent '5[%5]' type " "does not match the Result Type '3[%_struct_3]'s " "member type."))); } TEST_P(ValidateIdWithMessage, OpConstantSamplerGood) { std::string spirv = kGLSL450MemoryModel + R"( %float = OpTypeFloat 32 %samplerType = OpTypeSampler %3 = OpConstantSampler %samplerType ClampToEdge 0 Nearest)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpConstantSamplerResultTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeFloat 32 %2 = OpConstantSampler %1 Clamp 0 Nearest)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message( "OpConstantSampler Result Type '1[%float]' is not a sampler " "type."))); } TEST_P(ValidateIdWithMessage, OpConstantNullGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeBool %2 = OpConstantNull %1 %3 = OpTypeInt 32 0 %4 = OpConstantNull %3 %5 = OpTypeFloat 32 %6 = OpConstantNull %5 %7 = OpTypePointer UniformConstant %3 %8 = OpConstantNull %7 %9 = OpTypeEvent %10 = OpConstantNull %9 %11 = OpTypeDeviceEvent %12 = OpConstantNull %11 %13 = OpTypeReserveId %14 = OpConstantNull %13 %15 = OpTypeQueue %16 = OpConstantNull %15 %17 = OpTypeVector %5 2 %18 = OpConstantNull %17 %19 = OpTypeMatrix %17 2 %20 = OpConstantNull %19 %25 = OpConstant %3 8 %21 = OpTypeArray %3 %25 %22 = OpConstantNull %21 %23 = OpTypeStruct %3 %5 %1 %24 = OpConstantNull %23 %26 = OpTypeArray %17 %25 %27 = OpConstantNull %26 %28 = OpTypeStruct %7 %26 %26 %1 %29 = OpConstantNull %28 )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpConstantNullBasicBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpConstantNull %1)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message( "OpConstantNull Result Type '1[%void]' cannot have a null " "value."))); } TEST_P(ValidateIdWithMessage, OpConstantNullArrayBad) { std::string spirv = kGLSL450MemoryModel + R"( %2 = OpTypeInt 32 0 %3 = OpTypeSampler %4 = OpConstant %2 4 %5 = OpTypeArray %3 %4 %6 = OpConstantNull %5)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message( "OpConstantNull Result Type '4[%_arr_2_uint_4]' cannot have a " "null value."))); } TEST_P(ValidateIdWithMessage, OpConstantNullStructBad) { std::string spirv = kGLSL450MemoryModel + R"( %2 = OpTypeSampler %3 = OpTypeStruct %2 %2 %4 = OpConstantNull %3)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("OpConstantNull Result Type '2[%_struct_2]' " "cannot have a null value."))); } TEST_P(ValidateIdWithMessage, OpConstantNullRuntimeArrayBad) { std::string spirv = kGLSL450MemoryModel + R"( %bool = OpTypeBool %array = OpTypeRuntimeArray %bool %null = OpConstantNull %array)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message( "OpConstantNull Result Type '2[%_runtimearr_bool]' cannot have " "a null value."))); } TEST_P(ValidateIdWithMessage, OpSpecConstantTrueGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeBool %2 = OpSpecConstantTrue %1)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpSpecConstantTrueBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpSpecConstantTrue %1)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpSpecConstantTrue Result Type '1[%void]' is not " "a boolean type"))); } TEST_P(ValidateIdWithMessage, OpSpecConstantFalseGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeBool %2 = OpSpecConstantFalse %1)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpSpecConstantFalseBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpSpecConstantFalse %1)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpSpecConstantFalse Result Type '1[%void]' is not " "a boolean type"))); } TEST_P(ValidateIdWithMessage, OpSpecConstantGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeFloat 32 %2 = OpSpecConstant %1 42)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpSpecConstantBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpSpecConstant !1 !4)"; // The expected failure code is implementation dependent (currently // INVALID_BINARY because the binary parser catches these cases) and may // change over time, but this must always fail. CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_BINARY, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("Type Id 1 is not a scalar numeric type"))); } // Valid: SpecConstantComposite specializes to a vector. TEST_P(ValidateIdWithMessage, OpSpecConstantCompositeVectorGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %3 = OpSpecConstant %1 3.14 %4 = OpConstant %1 3.14 %5 = OpSpecConstantComposite %2 %3 %3 %4 %4)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // Valid: Vector of floats and Undefs. TEST_P(ValidateIdWithMessage, OpSpecConstantCompositeVectorWithUndefGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %3 = OpSpecConstant %1 3.14 %5 = OpConstant %1 3.14 %9 = OpUndef %1 %4 = OpSpecConstantComposite %2 %3 %5 %3 %9)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // Invalid: result type is float. TEST_P(ValidateIdWithMessage, OpSpecConstantCompositeVectorResultTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %3 = OpSpecConstant %1 3.14 %4 = OpSpecConstantComposite %1 %3 %3 %3 %3)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message("is not a composite type"))); } // Invalid: Vector contains a mix of Int and Float. TEST_P(ValidateIdWithMessage, OpSpecConstantCompositeVectorConstituentTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %4 = OpTypeInt 32 0 %3 = OpSpecConstant %1 3.14 %5 = OpConstant %4 42 ; bad type for constant value %6 = OpSpecConstantComposite %2 %3 %5 %3 %3)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpSpecConstantComposite Constituent " "'5[%uint_42]'s type does not match Result Type " "'2[%v4float]'s vector element type."))); } // Invalid: Constituent is not a constant TEST_P(ValidateIdWithMessage, OpSpecConstantCompositeVectorConstituentNotConstantBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %3 = OpTypeInt 32 0 %4 = OpSpecConstant %1 3.14 %5 = OpTypePointer Uniform %1 %6 = OpVariable %5 Uniform %7 = OpSpecConstantComposite %2 %6 %4 %4 %4)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpSpecConstantComposite Constituent '6[%6]' is " "not a constant or undef."))); } // Invalid: Vector contains a mix of Undef-int and Float. TEST_P(ValidateIdWithMessage, OpSpecConstantCompositeVectorConstituentUndefTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %4 = OpTypeInt 32 0 %3 = OpSpecConstant %1 3.14 %5 = OpUndef %4 ; bad type for undef value %6 = OpSpecConstantComposite %2 %3 %5 %3 %3)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpSpecConstantComposite Constituent '5[%5]'s " "type does not match Result Type '2[%v4float]'s " "vector element type."))); } // Invalid: Vector expects 3 components, but 4 specified. TEST_P(ValidateIdWithMessage, OpSpecConstantCompositeVectorNumComponentsBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 3 %3 = OpConstant %1 3.14 %5 = OpSpecConstant %1 4.0 %6 = OpSpecConstantComposite %2 %3 %5 %3 %3)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpSpecConstantComposite Constituent count does " "not match Result Type '2[%v3float]'s vector " "component count."))); } // Valid: 4x4 matrix of floats TEST_P(ValidateIdWithMessage, OpSpecConstantCompositeMatrixGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %3 = OpTypeMatrix %2 4 %4 = OpConstant %1 1.0 %5 = OpSpecConstant %1 0.0 %6 = OpSpecConstantComposite %2 %4 %5 %5 %5 %7 = OpSpecConstantComposite %2 %5 %4 %5 %5 %8 = OpSpecConstantComposite %2 %5 %5 %4 %5 %9 = OpSpecConstantComposite %2 %5 %5 %5 %4 %10 = OpSpecConstantComposite %3 %6 %7 %8 %9)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // Valid: Matrix in which one column is Undef TEST_P(ValidateIdWithMessage, OpSpecConstantCompositeMatrixUndefGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %3 = OpTypeMatrix %2 4 %4 = OpConstant %1 1.0 %5 = OpSpecConstant %1 0.0 %6 = OpSpecConstantComposite %2 %4 %5 %5 %5 %7 = OpSpecConstantComposite %2 %5 %4 %5 %5 %8 = OpSpecConstantComposite %2 %5 %5 %4 %5 %9 = OpUndef %2 %10 = OpSpecConstantComposite %3 %6 %7 %8 %9)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // Invalid: Matrix in which the sizes of column vectors are not equal. TEST_P(ValidateIdWithMessage, OpSpecConstantCompositeMatrixConstituentTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %3 = OpTypeVector %1 3 %4 = OpTypeMatrix %2 4 %5 = OpSpecConstant %1 1.0 %6 = OpConstant %1 0.0 %7 = OpSpecConstantComposite %2 %5 %6 %6 %6 %8 = OpSpecConstantComposite %2 %6 %5 %6 %6 %9 = OpSpecConstantComposite %2 %6 %6 %5 %6 %10 = OpSpecConstantComposite %3 %6 %6 %6 %11 = OpSpecConstantComposite %4 %7 %8 %9 %10)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpSpecConstantComposite Constituent '10[%10]' " "vector component count does not match Result Type " " '4[%mat4v4float]'s vector component count."))); } // Invalid: Matrix type expects 4 columns but only 3 specified. TEST_P(ValidateIdWithMessage, OpSpecConstantCompositeMatrixNumColsBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %3 = OpTypeMatrix %2 4 %4 = OpSpecConstant %1 1.0 %5 = OpConstant %1 0.0 %6 = OpSpecConstantComposite %2 %4 %5 %5 %5 %7 = OpSpecConstantComposite %2 %5 %4 %5 %5 %8 = OpSpecConstantComposite %2 %5 %5 %4 %5 %10 = OpSpecConstantComposite %3 %6 %7 %8)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpSpecConstantComposite Constituent count does " "not match Result Type '3[%mat4v4float]'s matrix column " "count."))); } // Invalid: Composite contains a non-const/undef component TEST_P(ValidateIdWithMessage, OpSpecConstantCompositeMatrixConstituentNotConstBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeFloat 32 %2 = OpConstant %1 0.0 %3 = OpTypeVector %1 4 %4 = OpTypeMatrix %3 4 %5 = OpSpecConstantComposite %3 %2 %2 %2 %2 %6 = OpTypePointer Uniform %1 %7 = OpVariable %6 Uniform %8 = OpSpecConstantComposite %4 %5 %5 %5 %7)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpSpecConstantComposite Constituent '7[%7]' is " "not a constant or undef."))); } // Invalid: Composite contains a column that is *not* a vector (it's an array) TEST_P(ValidateIdWithMessage, OpSpecConstantCompositeMatrixColTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeFloat 32 %2 = OpTypeInt 32 0 %3 = OpSpecConstant %2 4 %4 = OpConstant %1 0.0 %5 = OpTypeVector %1 4 %6 = OpTypeArray %2 %3 %7 = OpTypeMatrix %5 4 %8 = OpSpecConstantComposite %6 %3 %3 %3 %3 %9 = OpSpecConstantComposite %5 %4 %4 %4 %4 %10 = OpSpecConstantComposite %7 %9 %9 %9 %8)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpSpecConstantComposite Constituent '8[%8]' type " "does not match Result Type '7[%mat4v4float]'s " "matrix column type."))); } // Invalid: Matrix with an Undef column of the wrong size. TEST_P(ValidateIdWithMessage, OpSpecConstantCompositeMatrixConstituentUndefTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeFloat 32 %2 = OpTypeVector %1 4 %3 = OpTypeVector %1 3 %4 = OpTypeMatrix %2 4 %5 = OpSpecConstant %1 1.0 %6 = OpSpecConstant %1 0.0 %7 = OpSpecConstantComposite %2 %5 %6 %6 %6 %8 = OpSpecConstantComposite %2 %6 %5 %6 %6 %9 = OpSpecConstantComposite %2 %6 %6 %5 %6 %10 = OpUndef %3 %11 = OpSpecConstantComposite %4 %7 %8 %9 %10)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpSpecConstantComposite Constituent '10[%10]' " "vector component count does not match Result Type " " '4[%mat4v4float]'s vector component count."))); } // Invalid: Matrix in which some columns are Int and some are Float. TEST_P(ValidateIdWithMessage, OpSpecConstantCompositeMatrixColumnTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpTypeFloat 32 %3 = OpTypeVector %1 2 %4 = OpTypeVector %2 2 %5 = OpTypeMatrix %4 2 %6 = OpSpecConstant %1 42 %7 = OpConstant %2 3.14 %8 = OpSpecConstantComposite %3 %6 %6 %9 = OpSpecConstantComposite %4 %7 %7 %10 = OpSpecConstantComposite %5 %8 %9)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpSpecConstantComposite Constituent '8[%8]' " "component type does not match Result Type " "'5[%mat2v2float]'s matrix column component type."))); } // Valid: Array of integers TEST_P(ValidateIdWithMessage, OpSpecConstantCompositeArrayGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpSpecConstant %1 4 %5 = OpConstant %1 5 %3 = OpTypeArray %1 %2 %6 = OpTypeArray %1 %5 %4 = OpSpecConstantComposite %3 %2 %2 %2 %2 %7 = OpSpecConstantComposite %3 %5 %5 %5 %5)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // Invalid: Expecting an array of 4 components, but 3 specified. TEST_P(ValidateIdWithMessage, OpSpecConstantCompositeArrayNumComponentsBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpConstant %1 4 %3 = OpTypeArray %1 %2 %4 = OpSpecConstantComposite %3 %2 %2 %2)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpSpecConstantComposite Constituent count does not " "match Result Type '3[%_arr_uint_uint_4]'s array " "length."))); } // Valid: Array of Integers and Undef-int TEST_P(ValidateIdWithMessage, OpSpecConstantCompositeArrayWithUndefGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpSpecConstant %1 4 %9 = OpUndef %1 %3 = OpTypeArray %1 %2 %4 = OpSpecConstantComposite %3 %2 %2 %2 %9)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // Invalid: Array uses a type as operand. TEST_P(ValidateIdWithMessage, OpSpecConstantCompositeArrayConstConstituentBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpConstant %1 4 %3 = OpTypeArray %1 %2 %4 = OpTypePointer Uniform %1 %5 = OpVariable %4 Uniform %6 = OpSpecConstantComposite %3 %2 %2 %2 %5)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpSpecConstantComposite Constituent '5[%5]' is " "not a constant or undef."))); } // Invalid: Array has a mix of Int and Float components. TEST_P(ValidateIdWithMessage, OpSpecConstantCompositeArrayConstituentTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpConstant %1 4 %3 = OpTypeArray %1 %2 %4 = OpTypeFloat 32 %5 = OpSpecConstant %4 3.14 ; bad type for const value %6 = OpSpecConstantComposite %3 %2 %2 %2 %5)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpSpecConstantComposite Constituent '5[%5]'s " "type does not match Result Type " "'3[%_arr_uint_uint_4]'s array element type."))); } // Invalid: Array has a mix of Int and Undef-float. TEST_P(ValidateIdWithMessage, OpSpecConstantCompositeArrayConstituentUndefTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpSpecConstant %1 4 %3 = OpTypeArray %1 %2 %5 = OpTypeFloat 32 %6 = OpUndef %5 ; bad type for undef %4 = OpSpecConstantComposite %3 %2 %2 %2 %6)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpSpecConstantComposite Constituent '5[%5]'s " "type does not match Result Type " "'3[%_arr_uint_2]'s array element type."))); } // Valid: Struct of {Int32,Int32,Int64}. TEST_P(ValidateIdWithMessage, OpSpecConstantCompositeStructGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpTypeInt 64 0 %3 = OpTypeStruct %1 %1 %2 %4 = OpConstant %1 42 %5 = OpSpecConstant %2 4300000000 %6 = OpSpecConstantComposite %3 %4 %4 %5)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // Invalid: missing one int32 struct member. TEST_P(ValidateIdWithMessage, OpSpecConstantCompositeStructMissingComponentBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %3 = OpTypeStruct %1 %1 %1 %4 = OpConstant %1 42 %5 = OpSpecConstant %1 430 %6 = OpSpecConstantComposite %3 %4 %5)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("OpSpecConstantComposite Constituent " "'2[%_struct_2]' count does not match Result Type " " '2[%_struct_2]'s struct member count."))); } // Valid: Struct uses Undef-int64. TEST_P(ValidateIdWithMessage, OpSpecConstantCompositeStructUndefGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpTypeInt 64 0 %3 = OpTypeStruct %1 %1 %2 %4 = OpSpecConstant %1 42 %5 = OpUndef %2 %6 = OpSpecConstantComposite %3 %4 %4 %5)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // Invalid: Composite contains non-const/undef component. TEST_P(ValidateIdWithMessage, OpSpecConstantCompositeStructNonConstBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpTypeInt 64 0 %3 = OpTypeStruct %1 %1 %2 %4 = OpSpecConstant %1 42 %5 = OpUndef %2 %6 = OpTypePointer Uniform %1 %7 = OpVariable %6 Uniform %8 = OpSpecConstantComposite %3 %4 %7 %5)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpSpecConstantComposite Constituent '7[%7]' is " "not a constant or undef."))); } // Invalid: Struct component type does not match expected specialization type. // Second component was expected to be Int32, but got Int64. TEST_P(ValidateIdWithMessage, OpSpecConstantCompositeStructMemberTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpTypeInt 64 0 %3 = OpTypeStruct %1 %1 %2 %4 = OpConstant %1 42 %5 = OpSpecConstant %2 4300000000 %6 = OpSpecConstantComposite %3 %4 %5 %4)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpSpecConstantComposite Constituent '5[%5]' type " "does not match the Result Type '3[%_struct_3]'s " "member type."))); } // Invalid: Undef-int64 used when Int32 was expected. TEST_P(ValidateIdWithMessage, OpSpecConstantCompositeStructMemberUndefTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpTypeInt 64 0 %3 = OpTypeStruct %1 %1 %2 %4 = OpSpecConstant %1 42 %5 = OpUndef %2 %6 = OpSpecConstantComposite %3 %4 %5 %4)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpSpecConstantComposite Constituent '5[%5]' type " "does not match the Result Type '3[%_struct_3]'s " "member type."))); } // TODO: OpSpecConstantOp TEST_P(ValidateIdWithMessage, OpVariableGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpTypePointer Input %1 %3 = OpVariable %2 Input)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpVariableInitializerConstantGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpTypePointer Output %1 %3 = OpConstant %1 42 %4 = OpVariable %2 Output %3)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpVariableInitializerGlobalVariableGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpTypePointer Uniform %1 %3 = OpVariable %2 Uniform %4 = OpTypePointer Private %2 ; pointer to pointer %5 = OpVariable %4 Private %3 )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // TODO: Positive test OpVariable with OpConstantNull of OpTypePointer TEST_P(ValidateIdWithMessage, OpVariableResultTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpVariable %1 Input)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpVariable Result Type '1[%uint]' is not a pointer " "type."))); } TEST_P(ValidateIdWithMessage, OpVariableInitializerIsTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpTypePointer Input %1 %3 = OpVariable %2 Input %2)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message("Operand '2[%_ptr_Input_uint]' " "cannot be a type"))); } TEST_P(ValidateIdWithMessage, OpVariableInitializerIsFunctionVarBad) { std::string spirv = kGLSL450MemoryModel + R"( %int = OpTypeInt 32 0 %ptrint = OpTypePointer Function %int %ptrptrint = OpTypePointer Function %ptrint %void = OpTypeVoid %fnty = OpTypeFunction %void %main = OpFunction %void None %fnty %entry = OpLabel %var = OpVariable %ptrint Function %varinit = OpVariable %ptrptrint Function %var ; Can't initialize function variable. OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Variable Initializer '8[%8]' is not a constant " "or module-scope variable")); } TEST_P(ValidateIdWithMessage, OpVariableInitializerIsModuleVarGood) { std::string spirv = kGLSL450MemoryModel + R"( %int = OpTypeInt 32 0 %ptrint = OpTypePointer Uniform %int %mvar = OpVariable %ptrint Uniform %ptrptrint = OpTypePointer Function %ptrint %void = OpTypeVoid %fnty = OpTypeFunction %void %main = OpFunction %void None %fnty %entry = OpLabel %goodvar = OpVariable %ptrptrint Function %mvar ; This is ok OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpVariableContainsBoolBad) { std::string spirv = kGLSL450MemoryModel + R"( %bool = OpTypeBool %int = OpTypeInt 32 0 %block = OpTypeStruct %bool %int %_ptr_Uniform_block = OpTypePointer Uniform %block %var = OpVariable %_ptr_Uniform_block Uniform %void = OpTypeVoid %fnty = OpTypeFunction %void %main = OpFunction %void None %fnty %entry = OpLabel %load = OpLoad %block %var OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message( "If OpTypeBool is stored in conjunction with OpVariable, it can only " "be used with non-externally visible shader Storage Classes: " "Workgroup, CrossWorkgroup, Private, Function, Input, Output, " "RayPayloadKHR, IncomingRayPayloadKHR, HitAttributeKHR, " "CallableDataKHR, IncomingCallableDataKHR, NodePayloadAMDX, or " "UniformConstant"))); } TEST_P(ValidateIdWithMessage, OpVariableContainsBoolPrivateGood) { std::string spirv = kGLSL450MemoryModel + R"( %bool = OpTypeBool %int = OpTypeInt 32 0 %block = OpTypeStruct %bool %int %_ptr_Private_block = OpTypePointer Private %block %var = OpVariable %_ptr_Private_block Private %void = OpTypeVoid %fnty = OpTypeFunction %void %main = OpFunction %void None %fnty %entry = OpLabel %load = OpLoad %block %var OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpVariableContainsBoolUniformConstantGood) { std::string spirv = kGLSL450MemoryModel + R"( %bool = OpTypeBool %int = OpTypeInt 32 0 %block = OpTypeStruct %bool %int %_ptr_UniformConstant_block = OpTypePointer UniformConstant %block %var = OpVariable %_ptr_UniformConstant_block UniformConstant %void = OpTypeVoid %fnty = OpTypeFunction %void %main = OpFunction %void None %fnty %entry = OpLabel %load = OpLoad %block %var OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpVariableContainsBoolPointerGood) { std::string spirv = kGLSL450MemoryModel + R"( %bool = OpTypeBool %boolptr = OpTypePointer Uniform %bool %int = OpTypeInt 32 0 %block = OpTypeStruct %boolptr %int %_ptr_Uniform_block = OpTypePointer Uniform %block %var = OpVariable %_ptr_Uniform_block Uniform %void = OpTypeVoid %fnty = OpTypeFunction %void %main = OpFunction %void None %fnty %entry = OpLabel %load = OpLoad %block %var OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpVariableContainsBuiltinBoolGood) { std::string spirv = kGLSL450MemoryModel + R"( OpMemberDecorate %input 0 BuiltIn FrontFacing %bool = OpTypeBool %input = OpTypeStruct %bool %_ptr_input = OpTypePointer Input %input %var = OpVariable %_ptr_input Input %void = OpTypeVoid %fnty = OpTypeFunction %void %main = OpFunction %void None %fnty %entry = OpLabel %load = OpLoad %input %var OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpVariableContainsNoBuiltinBoolBad) { std::string spirv = kGLSL450MemoryModel + R"( %bool = OpTypeBool %input = OpTypeStruct %bool %_ptr_input = OpTypePointer Input %input %var = OpVariable %_ptr_input Input %void = OpTypeVoid %fnty = OpTypeFunction %void %main = OpFunction %void None %fnty %entry = OpLabel %load = OpLoad %input %var OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message( "If OpTypeBool is stored in conjunction with OpVariable using Input " "or Output Storage Classes it requires a BuiltIn decoration"))); } TEST_P(ValidateIdWithMessage, OpVariableContainsNoBuiltinBoolBadVulkan) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %var OpExecutionMode %main OriginUpperLeft %bool = OpTypeBool %input = OpTypeStruct %bool %_ptr_input = OpTypePointer Input %input %var = OpVariable %_ptr_input Input %void = OpTypeVoid %fnty = OpTypeFunction %void %main = OpFunction %void None %fnty %entry = OpLabel %load = OpLoad %input %var OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Input-07290")); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message( "If OpTypeBool is stored in conjunction with OpVariable using Input " "or Output Storage Classes it requires a BuiltIn decoration"))); } TEST_P(ValidateIdWithMessage, OpVariableContainsRayPayloadBoolGood) { std::string spirv = R"( OpCapability RayTracingNV OpCapability Shader OpCapability Linkage OpExtension "SPV_NV_ray_tracing" OpMemoryModel Logical GLSL450 %bool = OpTypeBool %PerRayData = OpTypeStruct %bool %_ptr_PerRayData = OpTypePointer RayPayloadNV %PerRayData %var = OpVariable %_ptr_PerRayData RayPayloadNV %void = OpTypeVoid %fnty = OpTypeFunction %void %main = OpFunction %void None %fnty %entry = OpLabel %load = OpLoad %PerRayData %var OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpVariablePointerNoVariablePointersBad) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %int = OpTypeInt 32 0 %_ptr_workgroup_int = OpTypePointer Workgroup %int %_ptr_function_ptr = OpTypePointer Function %_ptr_workgroup_int %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel %var = OpVariable %_ptr_function_ptr Function OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message( "In Logical addressing, variables may not allocate a pointer type"))); } TEST_P(ValidateIdWithMessage, OpVariablePointerNoVariablePointersRelaxedLogicalGood) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %int = OpTypeInt 32 0 %_ptr_workgroup_int = OpTypePointer Workgroup %int %_ptr_function_ptr = OpTypePointer Function %_ptr_workgroup_int %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel %var = OpVariable %_ptr_function_ptr Function OpReturn OpFunctionEnd )"; auto options = getValidatorOptions(); options->relax_logical_pointer = true; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpFunctionWithNonMemoryObject) { // DXC generates code that looks like when given something like: // T t; // t.s.fn_1(); // This needs to be accepted before legalization takes place, so we // will include it with the relaxed logical pointer. const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %1 "main" OpSource HLSL 600 %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %void = OpTypeVoid %9 = OpTypeFunction %void %_struct_5 = OpTypeStruct %_struct_6 = OpTypeStruct %_struct_5 %_ptr_Function__struct_6 = OpTypePointer Function %_struct_6 %_ptr_Function__struct_5 = OpTypePointer Function %_struct_5 %23 = OpTypeFunction %void %_ptr_Function__struct_5 %1 = OpFunction %void None %9 %10 = OpLabel %11 = OpVariable %_ptr_Function__struct_6 Function %20 = OpAccessChain %_ptr_Function__struct_5 %11 %int_0 %21 = OpFunctionCall %void %12 %20 OpReturn OpFunctionEnd %12 = OpFunction %void None %23 %13 = OpFunctionParameter %_ptr_Function__struct_5 %14 = OpLabel OpReturn OpFunctionEnd )"; auto options = getValidatorOptions(); options->relax_logical_pointer = true; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpVariablePointerVariablePointersStorageBufferGood) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability VariablePointersStorageBuffer OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 %void = OpTypeVoid %int = OpTypeInt 32 0 %_ptr_workgroup_int = OpTypePointer Workgroup %int %_ptr_function_ptr = OpTypePointer Function %_ptr_workgroup_int %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel %var = OpVariable %_ptr_function_ptr Function OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpVariablePointerVariablePointersGood) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability VariablePointers OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 %void = OpTypeVoid %int = OpTypeInt 32 0 %_ptr_workgroup_int = OpTypePointer Workgroup %int %_ptr_function_ptr = OpTypePointer Function %_ptr_workgroup_int %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel %var = OpVariable %_ptr_function_ptr Function OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpVariablePointerVariablePointersBad) { const std::string spirv = R"( OpCapability Shader OpCapability VariablePointers OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 %void = OpTypeVoid %int = OpTypeInt 32 0 %_ptr_workgroup_int = OpTypePointer Workgroup %int %_ptr_uniform_ptr = OpTypePointer Uniform %_ptr_workgroup_int %var = OpVariable %_ptr_uniform_ptr Uniform )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "In Logical addressing with variable pointers, " "variables that allocate pointers must be in Function " "or Private storage classes"))); } TEST_P(ValidateIdWithMessage, OpLoadGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer UniformConstant %2 %4 = OpTypeFunction %1 %5 = OpVariable %3 UniformConstant %6 = OpFunction %1 None %4 %7 = OpLabel %8 = OpLoad %2 %5 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // TODO: Add tests that exercise VariablePointersStorageBuffer instead of // VariablePointers. void createVariablePointerSpirvProgram(std::ostringstream* spirv, std::string result_strategy, bool use_varptr_cap, bool add_helper_function) { *spirv << "OpCapability Shader "; if (use_varptr_cap) { *spirv << "OpCapability VariablePointers "; *spirv << "OpExtension \"SPV_KHR_variable_pointers\" "; } *spirv << "OpExtension \"SPV_KHR_storage_buffer_storage_class\" "; *spirv << R"( OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %voidf = OpTypeFunction %void %bool = OpTypeBool %i32 = OpTypeInt 32 1 %f32 = OpTypeFloat 32 %f32ptr = OpTypePointer StorageBuffer %f32 %i = OpConstant %i32 1 %zero = OpConstant %i32 0 %float_1 = OpConstant %f32 1.0 %ptr1 = OpVariable %f32ptr StorageBuffer %ptr2 = OpVariable %f32ptr StorageBuffer )"; if (add_helper_function) { *spirv << R"( ; //////////////////////////////////////////////////////////// ;;;; Function that returns a pointer ; //////////////////////////////////////////////////////////// %selector_func_type = OpTypeFunction %f32ptr %bool %f32ptr %f32ptr %choose_input_func = OpFunction %f32ptr None %selector_func_type %is_neg_param = OpFunctionParameter %bool %first_ptr_param = OpFunctionParameter %f32ptr %second_ptr_param = OpFunctionParameter %f32ptr %selector_func_begin = OpLabel %result_ptr = OpSelect %f32ptr %is_neg_param %first_ptr_param %second_ptr_param OpReturnValue %result_ptr OpFunctionEnd )"; } *spirv << R"( %main = OpFunction %void None %voidf %label = OpLabel )"; *spirv << result_strategy; *spirv << R"( OpReturn OpFunctionEnd )"; } // With the VariablePointer Capability, OpLoad should allow loading a // VaiablePointer. In this test the variable pointer is obtained by an OpSelect TEST_P(ValidateIdWithMessage, OpLoadVarPtrOpSelectGood) { std::string result_strategy = R"( %isneg = OpSLessThan %bool %i %zero %varptr = OpSelect %f32ptr %isneg %ptr1 %ptr2 %result = OpLoad %f32 %varptr )"; std::ostringstream spirv; createVariablePointerSpirvProgram(&spirv, result_strategy, true /* Add VariablePointers Capability? */, false /* Use Helper Function? */); CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // Without the VariablePointers Capability, OpLoad will not allow loading // through a variable pointer. // Disabled since using OpSelect with pointers without VariablePointers will // fail LogicalsPass. TEST_P(ValidateIdWithMessage, DISABLED_OpLoadVarPtrOpSelectBad) { std::string result_strategy = R"( %isneg = OpSLessThan %bool %i %zero %varptr = OpSelect %f32ptr %isneg %ptr1 %ptr2 %result = OpLoad %f32 %varptr )"; std::ostringstream spirv; createVariablePointerSpirvProgram(&spirv, result_strategy, false /* Add VariablePointers Capability?*/, false /* Use Helper Function? */); CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message("is not a logical pointer."))); } // With the VariablePointer Capability, OpLoad should allow loading a // VaiablePointer. In this test the variable pointer is obtained by an OpPhi TEST_P(ValidateIdWithMessage, OpLoadVarPtrOpPhiGood) { std::string result_strategy = R"( %is_neg = OpSLessThan %bool %i %zero OpSelectionMerge %end_label None OpBranchConditional %is_neg %take_ptr_1 %take_ptr_2 %take_ptr_1 = OpLabel OpBranch %end_label %take_ptr_2 = OpLabel OpBranch %end_label %end_label = OpLabel %varptr = OpPhi %f32ptr %ptr1 %take_ptr_1 %ptr2 %take_ptr_2 %result = OpLoad %f32 %varptr )"; std::ostringstream spirv; createVariablePointerSpirvProgram(&spirv, result_strategy, true /* Add VariablePointers Capability?*/, false /* Use Helper Function? */); CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // Without the VariablePointers Capability, OpPhi can have a pointer result // type. TEST_P(ValidateIdWithMessage, OpPhiBad) { std::string result_strategy = R"( %is_neg = OpSLessThan %bool %i %zero OpSelectionMerge %end_label None OpBranchConditional %is_neg %take_ptr_1 %take_ptr_2 %take_ptr_1 = OpLabel OpBranch %end_label %take_ptr_2 = OpLabel OpBranch %end_label %end_label = OpLabel %varptr = OpPhi %f32ptr %ptr1 %take_ptr_1 %ptr2 %take_ptr_2 %result = OpLoad %f32 %varptr )"; std::ostringstream spirv; createVariablePointerSpirvProgram(&spirv, result_strategy, false /* Add VariablePointers Capability?*/, false /* Use Helper Function? */); CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "Using pointers with OpPhi requires capability " "VariablePointers or VariablePointersStorageBuffer"))); } // With the VariablePointer Capability, OpLoad should allow loading through a // VaiablePointer. In this test the variable pointer is obtained from an // OpFunctionCall (return value from a function) TEST_P(ValidateIdWithMessage, OpLoadVarPtrOpFunctionCallGood) { std::ostringstream spirv; std::string result_strategy = R"( %isneg = OpSLessThan %bool %i %zero %varptr = OpFunctionCall %f32ptr %choose_input_func %isneg %ptr1 %ptr2 %result = OpLoad %f32 %varptr )"; createVariablePointerSpirvProgram(&spirv, result_strategy, true /* Add VariablePointers Capability?*/, true /* Use Helper Function? */); CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpLoadResultTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer UniformConstant %2 %4 = OpTypeFunction %1 %5 = OpVariable %3 UniformConstant %6 = OpFunction %1 None %4 %7 = OpLabel %8 = OpLoad %3 %5 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("OpLoad Result Type " "'3[%_ptr_UniformConstant_uint]' does not match " "Pointer '5[%5]'s type."))); } TEST_P(ValidateIdWithMessage, OpLoadPointerBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer UniformConstant %2 %4 = OpTypeFunction %1 %5 = OpFunction %1 None %4 %6 = OpLabel %7 = OpLoad %2 %8 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); // Prove that SSA checks trigger for a bad Id value. // The next test case show the not-a-logical-pointer case. EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message("ID '8[%8]' has not been " "defined"))); } // Disabled as bitcasting type to object is now not valid. TEST_P(ValidateIdWithMessage, DISABLED_OpLoadLogicalPointerBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypeFloat 32 %4 = OpTypePointer UniformConstant %2 %5 = OpTypePointer UniformConstant %3 %6 = OpTypeFunction %1 %7 = OpFunction %1 None %6 %8 = OpLabel %9 = OpBitcast %5 %4 ; Not valid in logical addressing %10 = OpLoad %3 %9 ; Should trigger message OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); // Once we start checking bitcasts, we might catch that // as the error first, instead of catching it here. // I don't know if it's possible to generate a bad case // if/when the validator is complete. EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpLoad Pointer '9' is not a logical pointer."))); } TEST_P(ValidateIdWithMessage, OpStoreGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer Uniform %2 %4 = OpTypeFunction %1 %5 = OpConstant %2 42 %6 = OpVariable %3 Uniform %7 = OpFunction %1 None %4 %8 = OpLabel OpStore %6 %5 OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpStorePointerBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer UniformConstant %2 %4 = OpTypeFunction %1 %5 = OpConstant %2 42 %6 = OpVariable %3 UniformConstant %7 = OpConstant %2 0 %8 = OpFunction %1 None %4 %9 = OpLabel OpStore %7 %5 OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpStore Pointer '7[%uint_0]' is not a logical " "pointer."))); } // Disabled as bitcasting type to object is now not valid. TEST_P(ValidateIdWithMessage, DISABLED_OpStoreLogicalPointerBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypeFloat 32 %4 = OpTypePointer UniformConstant %2 %5 = OpTypePointer UniformConstant %3 %6 = OpTypeFunction %1 %7 = OpConstantNull %5 %8 = OpFunction %1 None %6 %9 = OpLabel %10 = OpBitcast %5 %4 ; Not valid in logical addressing %11 = OpStore %10 %7 ; Should trigger message OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpStore Pointer '10' is not a logical pointer."))); } // Without the VariablePointer Capability, OpStore should may not store // through a variable pointer. // Disabled since using OpSelect with pointers without VariablePointers will // fail LogicalsPass. TEST_P(ValidateIdWithMessage, DISABLED_OpStoreVarPtrBad) { std::string result_strategy = R"( %isneg = OpSLessThan %bool %i %zero %varptr = OpSelect %f32ptr %isneg %ptr1 %ptr2 OpStore %varptr %float_1 )"; std::ostringstream spirv; createVariablePointerSpirvProgram( &spirv, result_strategy, false /* Add VariablePointers Capability? */, false /* Use Helper Function? */); CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message("is not a logical pointer."))); } // With the VariablePointer Capability, OpStore should allow storing through a // variable pointer. TEST_P(ValidateIdWithMessage, OpStoreVarPtrGood) { std::string result_strategy = R"( %isneg = OpSLessThan %bool %i %zero %varptr = OpSelect %f32ptr %isneg %ptr1 %ptr2 OpStore %varptr %float_1 )"; std::ostringstream spirv; createVariablePointerSpirvProgram(&spirv, result_strategy, true /* Add VariablePointers Capability? */, false /* Use Helper Function? */); CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpStoreObjectGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer Uniform %2 %4 = OpTypeFunction %1 %5 = OpConstant %2 42 %6 = OpVariable %3 Uniform %7 = OpFunction %1 None %4 %8 = OpLabel %9 = OpFunctionCall %1 %10 OpStore %6 %9 OpReturn OpFunctionEnd %10 = OpFunction %1 None %4 %11 = OpLabel OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("OpStore Object '9[%9]'s type is void."))); } TEST_P(ValidateIdWithMessage, OpStoreTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %9 = OpTypeFloat 32 %3 = OpTypePointer Uniform %2 %4 = OpTypeFunction %1 %5 = OpConstant %9 3.14 %6 = OpVariable %3 Uniform %7 = OpFunction %1 None %4 %8 = OpLabel OpStore %6 %5 OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpStore Pointer '7[%7]'s type does not match " "Object '6[%float_3_1400001]'s type."))); } // The next series of test check test a relaxation of the rules for stores to // structs. The first test checks that we get a failure when the option is not // set to relax the rule. // TODO: Add tests for layout compatible arrays and matricies when the validator // relaxes the rules for them as well. Also need test to check for layout // decorations specific to those types. TEST_P(ValidateIdWithMessage, OpStoreTypeBadStruct) { std::string spirv = kGLSL450MemoryModel + R"( OpMemberDecorate %1 0 Offset 0 OpMemberDecorate %1 1 Offset 4 OpMemberDecorate %2 0 Offset 0 OpMemberDecorate %2 1 Offset 4 %3 = OpTypeVoid %4 = OpTypeFloat 32 %1 = OpTypeStruct %4 %4 %5 = OpTypePointer Uniform %1 %2 = OpTypeStruct %4 %4 %6 = OpTypeFunction %3 %7 = OpConstant %4 3.14 %8 = OpVariable %5 Uniform %9 = OpFunction %3 None %6 %10 = OpLabel %11 = OpCompositeConstruct %2 %7 %7 OpStore %8 %11 OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpStore Pointer '8[%8]'s type does not match " "Object '11[%11]'s type."))); } // Same code as the last test. The difference is that we relax the rule. // Because the structs %3 and %5 are defined the same way. TEST_P(ValidateIdWithMessage, OpStoreTypeRelaxedStruct) { std::string spirv = kGLSL450MemoryModel + R"( OpMemberDecorate %1 0 Offset 0 OpMemberDecorate %1 1 Offset 4 OpMemberDecorate %2 0 Offset 0 OpMemberDecorate %2 1 Offset 4 %3 = OpTypeVoid %4 = OpTypeFloat 32 %1 = OpTypeStruct %4 %4 %5 = OpTypePointer Uniform %1 %2 = OpTypeStruct %4 %4 %6 = OpTypeFunction %3 %7 = OpConstant %4 3.14 %8 = OpVariable %5 Uniform %9 = OpFunction %3 None %6 %10 = OpLabel %11 = OpCompositeConstruct %2 %7 %7 OpStore %8 %11 OpReturn OpFunctionEnd)"; spvValidatorOptionsSetRelaxStoreStruct(options_, true); CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // Same code as the last test except for an extra decoration on one of the // members. With the relaxed rules, the code is still valid. TEST_P(ValidateIdWithMessage, OpStoreTypeRelaxedStructWithExtraDecoration) { std::string spirv = kGLSL450MemoryModel + R"( OpMemberDecorate %1 0 Offset 0 OpMemberDecorate %1 1 Offset 4 OpMemberDecorate %1 0 RelaxedPrecision OpMemberDecorate %2 0 Offset 0 OpMemberDecorate %2 1 Offset 4 %3 = OpTypeVoid %4 = OpTypeFloat 32 %1 = OpTypeStruct %4 %4 %5 = OpTypePointer Uniform %1 %2 = OpTypeStruct %4 %4 %6 = OpTypeFunction %3 %7 = OpConstant %4 3.14 %8 = OpVariable %5 Uniform %9 = OpFunction %3 None %6 %10 = OpLabel %11 = OpCompositeConstruct %2 %7 %7 OpStore %8 %11 OpReturn OpFunctionEnd)"; spvValidatorOptionsSetRelaxStoreStruct(options_, true); CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // This test check that we recursively traverse the struct to check if they are // interchangable. TEST_P(ValidateIdWithMessage, OpStoreTypeRelaxedNestedStruct) { std::string spirv = kGLSL450MemoryModel + R"( OpMemberDecorate %1 0 Offset 0 OpMemberDecorate %1 1 Offset 4 OpMemberDecorate %2 0 Offset 0 OpMemberDecorate %2 1 Offset 8 OpMemberDecorate %3 0 Offset 0 OpMemberDecorate %3 1 Offset 4 OpMemberDecorate %4 0 Offset 0 OpMemberDecorate %4 1 Offset 8 %5 = OpTypeVoid %6 = OpTypeInt 32 0 %7 = OpTypeFloat 32 %1 = OpTypeStruct %7 %6 %2 = OpTypeStruct %1 %1 %8 = OpTypePointer Uniform %2 %3 = OpTypeStruct %7 %6 %4 = OpTypeStruct %3 %3 %9 = OpTypeFunction %5 %10 = OpConstant %6 7 %11 = OpConstant %7 3.14 %12 = OpConstantComposite %3 %11 %10 %13 = OpVariable %8 Uniform %14 = OpFunction %5 None %9 %15 = OpLabel %16 = OpCompositeConstruct %4 %12 %12 OpStore %13 %16 OpReturn OpFunctionEnd)"; spvValidatorOptionsSetRelaxStoreStruct(options_, true); CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // This test check that the even with the relaxed rules an error is identified // if the members of the struct are in a different order. TEST_P(ValidateIdWithMessage, OpStoreTypeBadRelaxedStruct1) { std::string spirv = kGLSL450MemoryModel + R"( OpMemberDecorate %1 0 Offset 0 OpMemberDecorate %1 1 Offset 4 OpMemberDecorate %2 0 Offset 0 OpMemberDecorate %2 1 Offset 8 OpMemberDecorate %3 0 Offset 0 OpMemberDecorate %3 1 Offset 4 OpMemberDecorate %4 0 Offset 0 OpMemberDecorate %4 1 Offset 8 %5 = OpTypeVoid %6 = OpTypeInt 32 0 %7 = OpTypeFloat 32 %1 = OpTypeStruct %6 %7 %2 = OpTypeStruct %1 %1 %8 = OpTypePointer Uniform %2 %3 = OpTypeStruct %7 %6 %4 = OpTypeStruct %3 %3 %9 = OpTypeFunction %5 %10 = OpConstant %6 7 %11 = OpConstant %7 3.14 %12 = OpConstantComposite %3 %11 %10 %13 = OpVariable %8 Uniform %14 = OpFunction %5 None %9 %15 = OpLabel %16 = OpCompositeConstruct %4 %12 %12 OpStore %13 %16 OpReturn OpFunctionEnd)"; spvValidatorOptionsSetRelaxStoreStruct(options_, true); CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message( "OpStore Pointer '13[%13]'s layout does not match Object " " '16[%16]'s layout."))); } // This test check that the even with the relaxed rules an error is identified // if the members of the struct are at different offsets. TEST_P(ValidateIdWithMessage, OpStoreTypeBadRelaxedStruct2) { std::string spirv = kGLSL450MemoryModel + R"( OpMemberDecorate %1 0 Offset 4 OpMemberDecorate %1 1 Offset 0 OpMemberDecorate %2 0 Offset 0 OpMemberDecorate %2 1 Offset 8 OpMemberDecorate %3 0 Offset 0 OpMemberDecorate %3 1 Offset 4 OpMemberDecorate %4 0 Offset 0 OpMemberDecorate %4 1 Offset 8 %5 = OpTypeVoid %6 = OpTypeInt 32 0 %7 = OpTypeFloat 32 %1 = OpTypeStruct %7 %6 %2 = OpTypeStruct %1 %1 %8 = OpTypePointer Uniform %2 %3 = OpTypeStruct %7 %6 %4 = OpTypeStruct %3 %3 %9 = OpTypeFunction %5 %10 = OpConstant %6 7 %11 = OpConstant %7 3.14 %12 = OpConstantComposite %3 %11 %10 %13 = OpVariable %8 Uniform %14 = OpFunction %5 None %9 %15 = OpLabel %16 = OpCompositeConstruct %4 %12 %12 OpStore %13 %16 OpReturn OpFunctionEnd)"; spvValidatorOptionsSetRelaxStoreStruct(options_, true); CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message( "OpStore Pointer '13[%13]'s layout does not match Object " " '16[%16]'s layout."))); } TEST_P(ValidateIdWithMessage, OpStoreTypeRelaxedLogicalPointerReturnPointer) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeInt 32 1 %2 = OpTypePointer Function %1 %3 = OpTypeFunction %2 %2 %4 = OpFunction %2 None %3 %5 = OpFunctionParameter %2 %6 = OpLabel OpReturnValue %5 OpFunctionEnd)"; spvValidatorOptionsSetRelaxLogicalPointer(options_, true); CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpStoreTypeRelaxedLogicalPointerAllocPointer) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeVoid %2 = OpTypeInt 32 1 %3 = OpTypeFunction %1 ; void(void) %4 = OpTypePointer Uniform %2 ; int* %5 = OpTypePointer Private %4 ; int** (Private) %6 = OpTypePointer Function %4 ; int** (Function) %7 = OpVariable %5 Private %8 = OpFunction %1 None %3 %9 = OpLabel %10 = OpVariable %6 Function OpReturn OpFunctionEnd)"; spvValidatorOptionsSetRelaxLogicalPointer(options_, true); CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpStoreVoid) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer Uniform %2 %4 = OpTypeFunction %1 %6 = OpVariable %3 Uniform %7 = OpFunction %1 None %4 %8 = OpLabel %9 = OpFunctionCall %1 %7 OpStore %6 %9 OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("OpStore Object '8[%8]'s type is void."))); } TEST_P(ValidateIdWithMessage, OpStoreLabel) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer Uniform %2 %4 = OpTypeFunction %1 %6 = OpVariable %3 Uniform %7 = OpFunction %1 None %4 %8 = OpLabel OpStore %6 %8 OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message("Operand '7[%7]' requires a type"))); } // TODO: enable when this bug is fixed: // https://cvs.khronos.org/bugzilla/show_bug.cgi?id=15404 TEST_P(ValidateIdWithMessage, DISABLED_OpStoreFunction) { std::string spirv = kGLSL450MemoryModel + R"( %2 = OpTypeInt 32 0 %3 = OpTypePointer UniformConstant %2 %4 = OpTypeFunction %2 %5 = OpConstant %2 123 %6 = OpVariable %3 UniformConstant %7 = OpFunction %2 None %4 %8 = OpLabel OpStore %6 %7 OpReturnValue %5 OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpStoreBuiltin) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %gl_GlobalInvocationID OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 450 OpName %main "main" OpName %gl_GlobalInvocationID "gl_GlobalInvocationID" OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input %zero = OpConstant %uint 0 %v3uint_000 = OpConstantComposite %v3uint %zero %zero %zero %void = OpTypeVoid %voidfunc = OpTypeFunction %void %main = OpFunction %void None %voidfunc %lmain = OpLabel OpStore %gl_GlobalInvocationID %v3uint_000 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message("storage class is read-only"))); } TEST_P(ValidateIdWithMessage, OpCopyMemoryGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer UniformConstant %2 %4 = OpConstant %2 42 %5 = OpVariable %3 UniformConstant %4 %6 = OpTypePointer Function %2 %7 = OpTypeFunction %1 %8 = OpFunction %1 None %7 %9 = OpLabel %10 = OpVariable %6 Function OpCopyMemory %10 %5 None OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpCopyMemoryNonPointerTarget) { const std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer Uniform %2 %4 = OpTypeFunction %1 %2 %3 %5 = OpFunction %1 None %4 %6 = OpFunctionParameter %2 %7 = OpFunctionParameter %3 %8 = OpLabel OpCopyMemory %6 %7 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("Target operand '6[%6]' is not a pointer."))); } TEST_P(ValidateIdWithMessage, OpCopyMemoryNonPointerSource) { const std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer Uniform %2 %4 = OpTypeFunction %1 %2 %3 %5 = OpFunction %1 None %4 %6 = OpFunctionParameter %2 %7 = OpFunctionParameter %3 %8 = OpLabel OpCopyMemory %7 %6 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("Source operand '6[%6]' is not a pointer."))); } TEST_P(ValidateIdWithMessage, OpCopyMemoryBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer UniformConstant %2 %4 = OpConstant %2 42 %5 = OpVariable %3 UniformConstant %4 %11 = OpTypeFloat 32 %6 = OpTypePointer Function %11 %7 = OpTypeFunction %1 %8 = OpFunction %1 None %7 %9 = OpLabel %10 = OpVariable %6 Function OpCopyMemory %10 %5 None OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message("Target '5[%5]'s type does not match " "Source '2[%uint]'s type."))); } TEST_P(ValidateIdWithMessage, OpCopyMemoryVoidTarget) { const std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer Uniform %1 %4 = OpTypePointer Uniform %2 %5 = OpTypeFunction %1 %3 %4 %6 = OpFunction %1 None %5 %7 = OpFunctionParameter %3 %8 = OpFunctionParameter %4 %9 = OpLabel OpCopyMemory %7 %8 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("Target operand '7[%7]' cannot be a void " "pointer."))); } TEST_P(ValidateIdWithMessage, OpCopyMemoryVoidSource) { const std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer Uniform %1 %4 = OpTypePointer Uniform %2 %5 = OpTypeFunction %1 %3 %4 %6 = OpFunction %1 None %5 %7 = OpFunctionParameter %3 %8 = OpFunctionParameter %4 %9 = OpLabel OpCopyMemory %8 %7 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("Source operand '7[%7]' cannot be a void " "pointer."))); } TEST_P(ValidateIdWithMessage, OpCopyMemorySizedGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer UniformConstant %2 %4 = OpTypePointer Function %2 %5 = OpConstant %2 4 %6 = OpVariable %3 UniformConstant %5 %7 = OpTypeFunction %1 %8 = OpFunction %1 None %7 %9 = OpLabel %10 = OpVariable %4 Function OpCopyMemorySized %10 %6 %5 None OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpCopyMemorySizedTargetBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer UniformConstant %2 %4 = OpTypePointer Function %2 %5 = OpConstant %2 4 %6 = OpVariable %3 UniformConstant %5 %7 = OpTypeFunction %1 %8 = OpFunction %1 None %7 %9 = OpLabel OpCopyMemorySized %5 %5 %5 None OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "Target operand '5[%uint_4]' is not a pointer."))); } TEST_P(ValidateIdWithMessage, OpCopyMemorySizedSourceBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer UniformConstant %2 %4 = OpTypePointer Function %2 %5 = OpConstant %2 4 %6 = OpTypeFunction %1 %7 = OpFunction %1 None %6 %8 = OpLabel %9 = OpVariable %4 Function OpCopyMemorySized %9 %5 %5 None OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "Source operand '5[%uint_4]' is not a pointer."))); } TEST_P(ValidateIdWithMessage, OpCopyMemorySizedSizeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer UniformConstant %2 %4 = OpTypePointer Function %2 %5 = OpConstant %2 4 %6 = OpVariable %3 UniformConstant %5 %7 = OpTypeFunction %1 %8 = OpFunction %1 None %7 %9 = OpLabel %10 = OpVariable %4 Function OpCopyMemorySized %10 %6 %6 None OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "Size operand '6[%6]' must be a scalar integer type."))); } TEST_P(ValidateIdWithMessage, OpCopyMemorySizedSizeTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer UniformConstant %2 %4 = OpTypePointer Function %2 %5 = OpConstant %2 4 %6 = OpVariable %3 UniformConstant %5 %7 = OpTypeFunction %1 %11 = OpTypeFloat 32 %12 = OpConstant %11 1.0 %8 = OpFunction %1 None %7 %9 = OpLabel %10 = OpVariable %4 Function OpCopyMemorySized %10 %6 %12 None OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "Size operand '9[%float_1]' must be a scalar integer " "type."))); } TEST_P(ValidateIdWithMessage, OpCopyMemorySizedSizeConstantNull) { const std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpConstantNull %2 %4 = OpTypePointer Uniform %2 %5 = OpTypeFloat 32 %6 = OpTypePointer UniformConstant %5 %7 = OpTypeFunction %1 %4 %6 %8 = OpFunction %1 None %7 %9 = OpFunctionParameter %4 %10 = OpFunctionParameter %6 %11 = OpLabel OpCopyMemorySized %9 %10 %3 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("Size operand '3[%3]' cannot be a constant " "zero."))); } TEST_P(ValidateIdWithMessage, OpCopyMemorySizedSizeConstantZero) { const std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpConstant %2 0 %4 = OpTypePointer Uniform %2 %5 = OpTypeFloat 32 %6 = OpTypePointer UniformConstant %5 %7 = OpTypeFunction %1 %4 %6 %8 = OpFunction %1 None %7 %9 = OpFunctionParameter %4 %10 = OpFunctionParameter %6 %11 = OpLabel OpCopyMemorySized %9 %10 %3 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "Size operand '3[%uint_0]' cannot be a constant " "zero."))); } TEST_P(ValidateIdWithMessage, OpCopyMemorySizedSizeConstantZero64) { const std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 64 0 %3 = OpConstant %2 0 %4 = OpTypePointer Uniform %2 %5 = OpTypeFloat 32 %6 = OpTypePointer UniformConstant %5 %7 = OpTypeFunction %1 %4 %6 %8 = OpFunction %1 None %7 %9 = OpFunctionParameter %4 %10 = OpFunctionParameter %6 %11 = OpLabel OpCopyMemorySized %9 %10 %3 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "Size operand '3[%ulong_0]' cannot be a constant " "zero."))); } TEST_P(ValidateIdWithMessage, OpCopyMemorySizedSizeConstantNegative) { const std::string spirv = kNoKernelGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 1 %3 = OpConstant %2 -1 %4 = OpTypePointer Uniform %2 %5 = OpTypeFloat 32 %6 = OpTypePointer UniformConstant %5 %7 = OpTypeFunction %1 %4 %6 %8 = OpFunction %1 None %7 %9 = OpFunctionParameter %4 %10 = OpFunctionParameter %6 %11 = OpLabel OpCopyMemorySized %9 %10 %3 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "Size operand '3[%int_n1]' cannot have the sign bit set " "to 1."))); } TEST_P(ValidateIdWithMessage, OpCopyMemorySizedSizeConstantNegative64) { const std::string spirv = kNoKernelGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 64 1 %3 = OpConstant %2 -1 %4 = OpTypePointer Uniform %2 %5 = OpTypeFloat 32 %6 = OpTypePointer UniformConstant %5 %7 = OpTypeFunction %1 %4 %6 %8 = OpFunction %1 None %7 %9 = OpFunctionParameter %4 %10 = OpFunctionParameter %6 %11 = OpLabel OpCopyMemorySized %9 %10 %3 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message( "Size operand '3[%long_n1]' cannot have the sign bit set " "to 1."))); } TEST_P(ValidateIdWithMessage, OpCopyMemorySizedSizeUnsignedNegative) { const std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpConstant %2 2147483648 %4 = OpTypePointer Uniform %2 %5 = OpTypeFloat 32 %6 = OpTypePointer UniformConstant %5 %7 = OpTypeFunction %1 %4 %6 %8 = OpFunction %1 None %7 %9 = OpFunctionParameter %4 %10 = OpFunctionParameter %6 %11 = OpLabel OpCopyMemorySized %9 %10 %3 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpCopyMemorySizedSizeUnsignedNegative64) { const std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 64 0 %3 = OpConstant %2 9223372036854775808 %4 = OpTypePointer Uniform %2 %5 = OpTypeFloat 32 %6 = OpTypePointer UniformConstant %5 %7 = OpTypeFunction %1 %4 %6 %8 = OpFunction %1 None %7 %9 = OpFunctionParameter %4 %10 = OpFunctionParameter %6 %11 = OpLabel OpCopyMemorySized %9 %10 %3 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } const char kDeeplyNestedStructureSetup[] = R"( %void = OpTypeVoid %void_f = OpTypeFunction %void %int = OpTypeInt 32 0 %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %mat4x3 = OpTypeMatrix %v3float 4 %_ptr_Private_mat4x3 = OpTypePointer Private %mat4x3 %_ptr_Private_float = OpTypePointer Private %float %my_matrix = OpVariable %_ptr_Private_mat4x3 Private %my_float_var = OpVariable %_ptr_Private_float Private %_ptr_Function_float = OpTypePointer Function %float %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %int_3 = OpConstant %int 3 %int_5 = OpConstant %int 5 ; Making the following nested structures. ; ; struct S { ; bool b; ; vec4 v[5]; ; int i; ; mat4x3 m[5]; ; } ; uniform blockName { ; S s; ; bool cond; ; RunTimeArray arr; ; } %f32arr = OpTypeRuntimeArray %float %v4float = OpTypeVector %float 4 %array5_mat4x3 = OpTypeArray %mat4x3 %int_5 %array5_vec4 = OpTypeArray %v4float %int_5 %_ptr_Uniform_float = OpTypePointer Uniform %float %_ptr_Function_vec4 = OpTypePointer Function %v4float %_ptr_Uniform_vec4 = OpTypePointer Uniform %v4float %struct_s = OpTypeStruct %int %array5_vec4 %int %array5_mat4x3 %struct_blockName = OpTypeStruct %struct_s %int %f32arr %_ptr_Uniform_blockName = OpTypePointer Uniform %struct_blockName %_ptr_Uniform_struct_s = OpTypePointer Uniform %struct_s %_ptr_Uniform_array5_mat4x3 = OpTypePointer Uniform %array5_mat4x3 %_ptr_Uniform_mat4x3 = OpTypePointer Uniform %mat4x3 %_ptr_Uniform_v3float = OpTypePointer Uniform %v3float %blockName_var = OpVariable %_ptr_Uniform_blockName Uniform %spec_int = OpSpecConstant %int 2 %float_0 = OpConstant %float 0 %func = OpFunction %void None %void_f %my_label = OpLabel )"; // In what follows, Access Chain Instruction refers to one of the following: // OpAccessChain, OpInBoundsAccessChain, OpPtrAccessChain, and // OpInBoundsPtrAccessChain using AccessChainInstructionTest = spvtest::ValidateBase; // Determines whether the access chain instruction requires the 'element id' // argument. bool AccessChainRequiresElemId(const std::string& instr) { return (instr == "OpPtrAccessChain" || instr == "OpInBoundsPtrAccessChain"); } // Valid: Access a float in a matrix using an access chain instruction. TEST_P(AccessChainInstructionTest, AccessChainGood) { const std::string instr = GetParam(); const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : ""; std::string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + "%float_entry = " + instr + R"( %_ptr_Private_float %my_matrix )" + elem + R"(%int_0 %int_1 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // Invalid. The result type of an access chain instruction must be a pointer. TEST_P(AccessChainInstructionTest, AccessChainResultTypeBad) { const std::string instr = GetParam(); const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : ""; std::string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"( %float_entry = )" + instr + R"( %float %my_matrix )" + elem + R"(%int_0 %int_1 OpReturn OpFunctionEnd )"; const std::string expected_err = "The Result Type of " + instr + " '36[%36]' must be " "OpTypePointer. Found OpTypeFloat."; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err)); } // Invalid. The base type of an access chain instruction must be a pointer. TEST_P(AccessChainInstructionTest, AccessChainBaseTypeVoidBad) { const std::string instr = GetParam(); const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : ""; std::string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"( %float_entry = )" + instr + " %_ptr_Private_float %void " + elem + R"(%int_0 %int_1 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Operand '1[%void]' cannot be a " "type")); } // Invalid. The base type of an access chain instruction must be a pointer. TEST_P(AccessChainInstructionTest, AccessChainBaseTypeNonPtrVariableBad) { const std::string instr = GetParam(); const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : ""; std::string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"( %entry = )" + instr + R"( %_ptr_Private_float %_ptr_Private_float )" + elem + R"(%int_0 %int_1 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Operand '8[%_ptr_Private_float]' cannot be a type")); } // Invalid: The storage class of Base and Result do not match. TEST_P(AccessChainInstructionTest, AccessChainResultAndBaseStorageClassDoesntMatchBad) { const std::string instr = GetParam(); const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : ""; std::string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"( %entry = )" + instr + R"( %_ptr_Function_float %my_matrix )" + elem + R"(%int_0 %int_1 OpReturn OpFunctionEnd )"; const std::string expected_err = "The result pointer storage class and base pointer storage class in " + instr + " do not match."; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err)); } // Invalid. The base type of an access chain instruction must point to a // composite object. TEST_P(AccessChainInstructionTest, AccessChainBasePtrNotPointingToCompositeBad) { const std::string instr = GetParam(); const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : ""; std::string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"( %entry = )" + instr + R"( %_ptr_Private_float %my_float_var )" + elem + R"(%int_0 OpReturn OpFunctionEnd )"; const std::string expected_err = instr + " reached non-composite type while " "indexes still remain to be traversed."; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err)); } // Valid. No Indexes were passed to the access chain instruction. The Result // Type is the same as the Base type. TEST_P(AccessChainInstructionTest, AccessChainNoIndexesGood) { const std::string instr = GetParam(); const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : ""; std::string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"( %entry = )" + instr + R"( %_ptr_Private_float %my_float_var )" + elem + R"( OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // Invalid. No Indexes were passed to the access chain instruction, but the // Result Type is different from the Base type. TEST_P(AccessChainInstructionTest, AccessChainNoIndexesBad) { const std::string instr = GetParam(); const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : ""; std::string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"( %entry = )" + instr + R"( %_ptr_Private_mat4x3 %my_float_var )" + elem + R"( OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("result type (OpTypeMatrix) does not match the type that " "results from indexing into the base (OpTypeFloat).")); } // Valid: 255 indexes passed to the access chain instruction. Limit is 255. TEST_P(AccessChainInstructionTest, AccessChainTooManyIndexesGood) { const std::string instr = GetParam(); const std::string elem = AccessChainRequiresElemId(instr) ? " %int_0 " : ""; const std::string arrayStride = " OpDecorate %_ptr_Uniform_deep_struct ArrayStride 8 "; int depth = 255; std::string header = kGLSL450MemoryModel + arrayStride + kDeeplyNestedStructureSetup; header.erase(header.find("%func")); std::ostringstream spirv; spirv << header << "\n"; // Build nested structures. Struct 'i' contains struct 'i-1' spirv << "%s_depth_1 = OpTypeStruct %float\n"; for (int i = 2; i <= depth; ++i) { spirv << "%s_depth_" << i << " = OpTypeStruct %s_depth_" << i - 1 << "\n"; } // Define Pointer and Variable to use for the AccessChain instruction. spirv << "%_ptr_Uniform_deep_struct = OpTypePointer Uniform %s_depth_" << depth << "\n"; spirv << "%deep_var = OpVariable %_ptr_Uniform_deep_struct Uniform\n"; // Function Start spirv << R"( %func = OpFunction %void None %void_f %my_label = OpLabel )"; // AccessChain with 'n' indexes (n = depth) spirv << "%entry = " << instr << " %_ptr_Uniform_float %deep_var" << elem; for (int i = 0; i < depth; ++i) { spirv << " %int_0"; } // Function end spirv << R"( OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // Invalid: 256 indexes passed to the access chain instruction. Limit is 255. TEST_P(AccessChainInstructionTest, AccessChainTooManyIndexesBad) { const std::string instr = GetParam(); const std::string elem = AccessChainRequiresElemId(instr) ? " %int_0 " : ""; std::ostringstream spirv; spirv << kGLSL450MemoryModel << kDeeplyNestedStructureSetup; spirv << "%entry = " << instr << " %_ptr_Private_float %my_matrix" << elem; for (int i = 0; i < 256; ++i) { spirv << " %int_0"; } spirv << R"( OpReturn OpFunctionEnd )"; const std::string expected_err = "The number of indexes in " + instr + " may not exceed 255. Found 256 indexes."; CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err)); } // Valid: 10 indexes passed to the access chain instruction. (Custom limit: 10) TEST_P(AccessChainInstructionTest, CustomizedAccessChainTooManyIndexesGood) { const std::string instr = GetParam(); const std::string elem = AccessChainRequiresElemId(instr) ? " %int_0 " : ""; const std::string arrayStride = " OpDecorate %_ptr_Uniform_deep_struct ArrayStride 8 "; int depth = 10; std::string header = kGLSL450MemoryModel + arrayStride + kDeeplyNestedStructureSetup; header.erase(header.find("%func")); std::ostringstream spirv; spirv << header << "\n"; // Build nested structures. Struct 'i' contains struct 'i-1' spirv << "%s_depth_1 = OpTypeStruct %float\n"; for (int i = 2; i <= depth; ++i) { spirv << "%s_depth_" << i << " = OpTypeStruct %s_depth_" << i - 1 << "\n"; } // Define Pointer and Variable to use for the AccessChain instruction. spirv << "%_ptr_Uniform_deep_struct = OpTypePointer Uniform %s_depth_" << depth << "\n"; spirv << "%deep_var = OpVariable %_ptr_Uniform_deep_struct Uniform\n"; // Function Start spirv << R"( %func = OpFunction %void None %void_f %my_label = OpLabel )"; // AccessChain with 'n' indexes (n = depth) spirv << "%entry = " << instr << " %_ptr_Uniform_float %deep_var" << elem; for (int i = 0; i < depth; ++i) { spirv << " %int_0"; } // Function end spirv << R"( OpReturn OpFunctionEnd )"; spvValidatorOptionsSetUniversalLimit( options_, spv_validator_limit_max_access_chain_indexes, 10u); CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // Invalid: 11 indexes passed to the access chain instruction. Custom Limit:10 TEST_P(AccessChainInstructionTest, CustomizedAccessChainTooManyIndexesBad) { const std::string instr = GetParam(); const std::string elem = AccessChainRequiresElemId(instr) ? " %int_0 " : ""; std::ostringstream spirv; spirv << kGLSL450MemoryModel << kDeeplyNestedStructureSetup; spirv << "%entry = " << instr << " %_ptr_Private_float %my_matrix" << elem; for (int i = 0; i < 11; ++i) { spirv << " %int_0"; } spirv << R"( OpReturn OpFunctionEnd )"; const std::string expected_err = "The number of indexes in " + instr + " may not exceed 10. Found 11 indexes."; spvValidatorOptionsSetUniversalLimit( options_, spv_validator_limit_max_access_chain_indexes, 10u); CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err)); } // Invalid: Index passed to the access chain instruction is float (must be // integer). TEST_P(AccessChainInstructionTest, AccessChainUndefinedIndexBad) { const std::string instr = GetParam(); const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : ""; std::string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"( %entry = )" + instr + R"( %_ptr_Private_float %my_matrix )" + elem + R"(%float_0 %int_1 OpReturn OpFunctionEnd )"; const std::string expected_err = "Indexes passed to " + instr + " must be of type integer."; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err)); } // Invalid: The index argument that indexes into a struct must be of type // OpConstant. TEST_P(AccessChainInstructionTest, AccessChainStructIndexNotConstantBad) { const std::string instr = GetParam(); const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : ""; std::string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"( %f = )" + instr + R"( %_ptr_Uniform_float %blockName_var )" + elem + R"(%int_0 %spec_int %int_2 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("The passed to " + instr)); EXPECT_THAT(getDiagnosticString(), HasSubstr("into a structure must be an OpConstant")); } // Invalid: Indexing up to a vec4 granularity, but result type expected float. TEST_P(AccessChainInstructionTest, AccessChainStructResultTypeDoesntMatchIndexedTypeBad) { const std::string instr = GetParam(); const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : ""; std::string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"( %entry = )" + instr + R"( %_ptr_Uniform_float %blockName_var )" + elem + R"(%int_0 %int_1 %int_2 OpReturn OpFunctionEnd )"; const std::string expected_err = instr + " result type (OpTypeFloat) does not match " "the type that results from indexing into " "the base (OpTypeVector)."; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err)); } // Invalid: Reach non-composite type (bool) when unused indexes remain. TEST_P(AccessChainInstructionTest, AccessChainStructTooManyIndexesBad) { const std::string instr = GetParam(); const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : ""; std::string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"( %entry = )" + instr + R"( %_ptr_Uniform_float %blockName_var )" + elem + R"(%int_0 %int_2 %int_2 OpReturn OpFunctionEnd )"; const std::string expected_err = instr + " reached non-composite type while " "indexes still remain to be traversed."; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err)); } // Invalid: Trying to find index 3 of the struct that has only 3 members. TEST_P(AccessChainInstructionTest, AccessChainStructIndexOutOfBoundBad) { const std::string instr = GetParam(); const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : ""; std::string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"( %entry = )" + instr + R"( %_ptr_Uniform_float %blockName_var )" + elem + R"(%int_3 %int_2 %int_2 OpReturn OpFunctionEnd )"; const std::string expected_err = "is out of bounds: " + instr + " cannot find index 3 into the structure " " '25[%_struct_25]'. This structure " "has 3 members. Largest valid index is 2."; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err)); } // Valid: Tests that we can index into Struct, Array, Matrix, and Vector! TEST_P(AccessChainInstructionTest, AccessChainIndexIntoAllTypesGood) { // indexes that we are passing are: 0, 3, 1, 2, 0 // 0 will select the struct_s within the base struct (blockName) // 3 will select the Array that contains 5 matrices // 1 will select the Matrix that is at index 1 of the array // 2 will select the column (which is a vector) within the matrix at index 2 // 0 will select the element at the index 0 of the vector. (which is a float). const std::string instr = GetParam(); const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : ""; const std::string arrayStride = " OpDecorate %_ptr_Uniform_blockName ArrayStride 8 "; std::ostringstream spirv; spirv << kGLSL450MemoryModel << arrayStride << kDeeplyNestedStructureSetup << std::endl; spirv << "%ss = " << instr << " %_ptr_Uniform_struct_s %blockName_var " << elem << "%int_0" << std::endl; spirv << "%sa = " << instr << " %_ptr_Uniform_array5_mat4x3 %blockName_var " << elem << "%int_0 %int_3" << std::endl; spirv << "%sm = " << instr << " %_ptr_Uniform_mat4x3 %blockName_var " << elem << "%int_0 %int_3 %int_1" << std::endl; spirv << "%sc = " << instr << " %_ptr_Uniform_v3float %blockName_var " << elem << "%int_0 %int_3 %int_1 %int_2" << std::endl; spirv << "%entry = " << instr << " %_ptr_Uniform_float %blockName_var " << elem << "%int_0 %int_3 %int_1 %int_2 %int_0" << std::endl; spirv << R"( OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // Valid: Access an element of OpTypeRuntimeArray. TEST_P(AccessChainInstructionTest, AccessChainIndexIntoRuntimeArrayGood) { const std::string instr = GetParam(); const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : ""; const std::string arrayStride = " OpDecorate %_ptr_Uniform_blockName ArrayStride 8 "; std::string spirv = kGLSL450MemoryModel + arrayStride + kDeeplyNestedStructureSetup + R"( %runtime_arr_entry = )" + instr + R"( %_ptr_Uniform_float %blockName_var )" + elem + R"(%int_2 %int_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // Invalid: Unused index when accessing OpTypeRuntimeArray. TEST_P(AccessChainInstructionTest, AccessChainIndexIntoRuntimeArrayBad) { const std::string instr = GetParam(); const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : ""; std::string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"( %runtime_arr_entry = )" + instr + R"( %_ptr_Uniform_float %blockName_var )" + elem + R"(%int_2 %int_0 %int_1 OpReturn OpFunctionEnd )"; const std::string expected_err = instr + " reached non-composite type while indexes still remain to be traversed."; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err)); } // Invalid: Reached scalar type before arguments to the access chain instruction // finished. TEST_P(AccessChainInstructionTest, AccessChainMatrixMoreArgsThanNeededBad) { const std::string instr = GetParam(); const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : ""; std::string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"( %entry = )" + instr + R"( %_ptr_Private_float %my_matrix )" + elem + R"(%int_0 %int_1 %int_0 OpReturn OpFunctionEnd )"; const std::string expected_err = instr + " reached non-composite type while " "indexes still remain to be traversed."; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err)); } // Invalid: The result type and the type indexed into do not match. TEST_P(AccessChainInstructionTest, AccessChainResultTypeDoesntMatchIndexedTypeBad) { const std::string instr = GetParam(); const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : ""; std::string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"( %entry = )" + instr + R"( %_ptr_Private_mat4x3 %my_matrix )" + elem + R"(%int_0 %int_1 OpReturn OpFunctionEnd )"; const std::string expected_err = instr + " result type (OpTypeMatrix) does not match " "the type that results from indexing into " "the base (OpTypeFloat)."; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err)); } // Run tests for Access Chain Instructions. INSTANTIATE_TEST_SUITE_P( CheckAccessChainInstructions, AccessChainInstructionTest, ::testing::Values("OpAccessChain", "OpInBoundsAccessChain", "OpPtrAccessChain", "OpInBoundsPtrAccessChain")); // TODO: OpArrayLength // TODO: OpImagePointer // TODO: OpGenericPtrMemSemantics TEST_P(ValidateIdWithMessage, OpFunctionGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypeFunction %1 %2 %2 %4 = OpFunction %1 None %3 %5 = OpLabel OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpFunctionResultTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpConstant %2 42 %4 = OpTypeFunction %1 %2 %2 %5 = OpFunction %2 None %4 %6 = OpLabel OpReturnValue %3 OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("OpFunction Result Type '2[%uint]' does not " "match the Function Type's return type " "'1[%void]'."))); } TEST_P(ValidateIdWithMessage, OpReturnValueTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeInt 32 0 %2 = OpTypeFloat 32 %3 = OpConstant %2 0 %4 = OpTypeFunction %1 %5 = OpFunction %1 None %4 %6 = OpLabel OpReturnValue %3 OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpReturnValue Value '3[%float_0]'s type does " "not match OpFunction's return type."))); } TEST_P(ValidateIdWithMessage, OpFunctionFunctionTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %4 = OpFunction %1 None %2 %5 = OpLabel OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpFunction Function Type '2[%uint]' is not a function " "type."))); } TEST_P(ValidateIdWithMessage, OpFunctionUseBad) { const std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeFloat 32 %2 = OpTypeFunction %1 %3 = OpFunction %1 None %2 %4 = OpLabel OpReturnValue %3 OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("Invalid use of function result id '3[%3]'."))); } TEST_P(ValidateIdWithMessage, OpFunctionParameterGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypeFunction %1 %2 %4 = OpFunction %1 None %3 %5 = OpFunctionParameter %2 %6 = OpLabel OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpFunctionParameterMultipleGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypeFunction %1 %2 %2 %4 = OpFunction %1 None %3 %5 = OpFunctionParameter %2 %6 = OpFunctionParameter %2 %7 = OpLabel OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpFunctionParameterResultTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypeFunction %1 %2 %4 = OpFunction %1 None %3 %5 = OpFunctionParameter %1 %6 = OpLabel OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message( "OpFunctionParameter Result Type '1[%void]' does not " "match the OpTypeFunction parameter type of the same index."))); } TEST_P(ValidateIdWithMessage, OpFunctionCallGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypeFunction %2 %2 %4 = OpTypeFunction %1 %5 = OpConstant %2 42 ;21 %6 = OpFunction %2 None %3 %7 = OpFunctionParameter %2 %8 = OpLabel OpReturnValue %7 OpFunctionEnd %10 = OpFunction %1 None %4 %11 = OpLabel %12 = OpFunctionCall %2 %6 %5 OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpFunctionCallResultTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypeFunction %2 %2 %4 = OpTypeFunction %1 %5 = OpConstant %2 42 ;21 %6 = OpFunction %2 None %3 %7 = OpFunctionParameter %2 %8 = OpLabel %9 = OpIAdd %2 %7 %7 OpReturnValue %9 OpFunctionEnd %10 = OpFunction %1 None %4 %11 = OpLabel %12 = OpFunctionCall %1 %6 %5 OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("OpFunctionCall Result Type '1[%void]'s type " "does not match Function '2[%uint]'s return " "type."))); } TEST_P(ValidateIdWithMessage, OpFunctionCallFunctionBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypeFunction %2 %2 %4 = OpTypeFunction %1 %5 = OpConstant %2 42 ;21 %10 = OpFunction %1 None %4 %11 = OpLabel %12 = OpFunctionCall %2 %5 %5 OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpFunctionCall Function '5[%uint_42]' is not a " "function."))); } TEST_P(ValidateIdWithMessage, OpFunctionCallArgumentTypeBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypeFunction %2 %2 %4 = OpTypeFunction %1 %5 = OpConstant %2 42 %13 = OpTypeFloat 32 %14 = OpConstant %13 3.14 %6 = OpFunction %2 None %3 %7 = OpFunctionParameter %2 %8 = OpLabel %9 = OpIAdd %2 %7 %7 OpReturnValue %9 OpFunctionEnd %10 = OpFunction %1 None %4 %11 = OpLabel %12 = OpFunctionCall %2 %6 %14 OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpFunctionCall Argument '7[%float_3_1400001]'s " "type does not match Function '2[%uint]'s " "parameter type."))); } // Valid: OpSampledImage result is used in the same block by // OpImageSampleImplictLod TEST_P(ValidateIdWithMessage, OpSampledImageGood) { std::string spirv = kGLSL450MemoryModel + sampledImageSetup + R"( %smpld_img = OpSampledImage %sampled_image_type %image_inst %sampler_inst %si_lod = OpImageSampleImplicitLod %v4float %smpld_img %const_vec_1_1 OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // Invalid: OpSampledImage result is defined in one block and used in a // different block. TEST_P(ValidateIdWithMessage, OpSampledImageUsedInDifferentBlockBad) { std::string spirv = kGLSL450MemoryModel + sampledImageSetup + R"( %smpld_img = OpSampledImage %sampled_image_type %image_inst %sampler_inst OpBranch %label_2 %label_2 = OpLabel %si_lod = OpImageSampleImplicitLod %v4float %smpld_img %const_vec_1_1 OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message( "All OpSampledImage instructions must be in the same block in " "which their Result are consumed. OpSampledImage Result " "Type '23[%23]' has a consumer in a different basic " "block. The consumer instruction is '25[%25]'."))); } // Invalid: OpSampledImage result is used by OpSelect // Note: According to the Spec, OpSelect parameters must be either a scalar or a // vector. Therefore, OpTypeSampledImage is an illegal parameter for OpSelect. // However, the OpSelect validation does not catch this today. Therefore, it is // caught by the OpSampledImage validation. If the OpSelect validation code is // updated, the error message for this test may change. // // Disabled since OpSelect catches this now. TEST_P(ValidateIdWithMessage, DISABLED_OpSampledImageUsedInOpSelectBad) { std::string spirv = kGLSL450MemoryModel + sampledImageSetup + R"( %smpld_img = OpSampledImage %sampled_image_type %image_inst %sampler_inst %select_img = OpSelect %sampled_image_type %spec_true %smpld_img %smpld_img OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "Result from OpSampledImage instruction must not " "appear as operands of OpSelect. Found result " "'23' as an operand of '24'."))); } TEST_P(ValidateIdWithMessage, OpCopyObjectSampledImageGood) { std::string spirv = kGLSL450MemoryModel + sampledImageSetup + R"( %smpld_img = OpSampledImage %sampled_image_type %image_inst %sampler_inst %smpld_img2 = OpCopyObject %sampled_image_type %smpld_img %image_inst2 = OpCopyObject %image_type %image_inst OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // Valid: Get a float in a matrix using CompositeExtract. // Valid: Insert float into a matrix using CompositeInsert. TEST_P(ValidateIdWithMessage, CompositeExtractInsertGood) { std::ostringstream spirv; spirv << kGLSL450MemoryModel << kDeeplyNestedStructureSetup << std::endl; spirv << "%matrix = OpLoad %mat4x3 %my_matrix" << std::endl; spirv << "%float_entry = OpCompositeExtract %float %matrix 0 1" << std::endl; // To test CompositeInsert, insert the object back in after extraction. spirv << "%new_composite = OpCompositeInsert %mat4x3 %float_entry %matrix 0 1" << std::endl; spirv << R"(OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } #if 0 TEST_P(ValidateIdWithMessage, OpFunctionCallArgumentCountBar) { const char *spirv = R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypeFunction %2 %2 %4 = OpTypeFunction %1 %5 = OpConstant %2 42 ;21 %6 = OpFunction %2 None %3 %7 = OpFunctionParameter %2 %8 = OpLabel %9 = OpLoad %2 %7 OpReturnValue %9 OpFunctionEnd %10 = OpFunction %1 None %4 %11 = OpLabel OpReturn %12 = OpFunctionCall %2 %6 %5 OpFunctionEnd)"; CHECK(spirv, SPV_ERROR_INVALID_ID); } #endif // TODO: The many things that changed with how images are used. // TODO: OpTextureSample // TODO: OpTextureSampleDref // TODO: OpTextureSampleLod // TODO: OpTextureSampleProj // TODO: OpTextureSampleGrad // TODO: OpTextureSampleOffset // TODO: OpTextureSampleProjLod // TODO: OpTextureSampleProjGrad // TODO: OpTextureSampleLodOffset // TODO: OpTextureSampleProjOffset // TODO: OpTextureSampleGradOffset // TODO: OpTextureSampleProjLodOffset // TODO: OpTextureSampleProjGradOffset // TODO: OpTextureFetchTexelLod // TODO: OpTextureFetchTexelOffset // TODO: OpTextureFetchSample // TODO: OpTextureFetchTexel // TODO: OpTextureGather // TODO: OpTextureGatherOffset // TODO: OpTextureGatherOffsets // TODO: OpTextureQuerySizeLod // TODO: OpTextureQuerySize // TODO: OpTextureQueryLevels // TODO: OpTextureQuerySamples // TODO: OpConvertUToF // TODO: OpConvertFToS // TODO: OpConvertSToF // TODO: OpConvertUToF // TODO: OpUConvert // TODO: OpSConvert // TODO: OpFConvert // TODO: OpConvertPtrToU // TODO: OpConvertUToPtr // TODO: OpPtrCastToGeneric // TODO: OpGenericCastToPtr // TODO: OpBitcast // TODO: OpGenericCastToPtrExplicit // TODO: OpSatConvertSToU // TODO: OpSatConvertUToS // TODO: OpVectorExtractDynamic // TODO: OpVectorInsertDynamic TEST_P(ValidateIdWithMessage, OpVectorShuffleIntGood) { std::string spirv = kGLSL450MemoryModel + R"( %int = OpTypeInt 32 0 %ivec3 = OpTypeVector %int 3 %ivec4 = OpTypeVector %int 4 %ptr_ivec3 = OpTypePointer Function %ivec3 %undef = OpUndef %ivec4 %int_42 = OpConstant %int 42 %int_0 = OpConstant %int 0 %int_2 = OpConstant %int 2 %1 = OpConstantComposite %ivec3 %int_42 %int_0 %int_2 %2 = OpTypeFunction %ivec3 %3 = OpFunction %ivec3 None %2 %4 = OpLabel %var = OpVariable %ptr_ivec3 Function %1 %5 = OpLoad %ivec3 %var %6 = OpVectorShuffle %ivec3 %5 %undef 2 1 0 OpReturnValue %6 OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpVectorShuffleFloatGood) { std::string spirv = kGLSL450MemoryModel + R"( %float = OpTypeFloat 32 %vec2 = OpTypeVector %float 2 %vec3 = OpTypeVector %float 3 %vec4 = OpTypeVector %float 4 %ptr_vec2 = OpTypePointer Function %vec2 %ptr_vec3 = OpTypePointer Function %vec3 %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %1 = OpConstantComposite %vec2 %float_2 %float_1 %2 = OpConstantComposite %vec3 %float_1 %float_2 %float_2 %3 = OpTypeFunction %vec4 %4 = OpFunction %vec4 None %3 %5 = OpLabel %var = OpVariable %ptr_vec2 Function %1 %var2 = OpVariable %ptr_vec3 Function %2 %6 = OpLoad %vec2 %var %7 = OpLoad %vec3 %var2 %8 = OpVectorShuffle %vec4 %6 %7 4 3 1 0xffffffff OpReturnValue %8 OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpVectorShuffleScalarResultType) { std::string spirv = kGLSL450MemoryModel + R"( %float = OpTypeFloat 32 %vec2 = OpTypeVector %float 2 %ptr_vec2 = OpTypePointer Function %vec2 %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %1 = OpConstantComposite %vec2 %float_2 %float_1 %2 = OpTypeFunction %float %3 = OpFunction %float None %2 %4 = OpLabel %var = OpVariable %ptr_vec2 Function %1 %5 = OpLoad %vec2 %var %6 = OpVectorShuffle %float %5 %5 0 OpReturnValue %6 OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "Result Type of OpVectorShuffle must be OpTypeVector."))); } TEST_P(ValidateIdWithMessage, OpVectorShuffleComponentCount) { std::string spirv = kGLSL450MemoryModel + R"( %int = OpTypeInt 32 0 %ivec3 = OpTypeVector %int 3 %ptr_ivec3 = OpTypePointer Function %ivec3 %int_42 = OpConstant %int 42 %int_0 = OpConstant %int 0 %int_2 = OpConstant %int 2 %1 = OpConstantComposite %ivec3 %int_42 %int_0 %int_2 %2 = OpTypeFunction %ivec3 %3 = OpFunction %ivec3 None %2 %4 = OpLabel %var = OpVariable %ptr_ivec3 Function %1 %5 = OpLoad %ivec3 %var %6 = OpVectorShuffle %ivec3 %5 %5 0 1 OpReturnValue %6 OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpVectorShuffle component literals count does not match " "Result Type '2[%v3uint]'s vector component count."))); } TEST_P(ValidateIdWithMessage, OpVectorShuffleVector1Type) { std::string spirv = kGLSL450MemoryModel + R"( %int = OpTypeInt 32 0 %ivec2 = OpTypeVector %int 2 %ptr_int = OpTypePointer Function %int %undef = OpUndef %ivec2 %int_42 = OpConstant %int 42 %2 = OpTypeFunction %ivec2 %3 = OpFunction %ivec2 None %2 %4 = OpLabel %var = OpVariable %ptr_int Function %int_42 %5 = OpLoad %int %var %6 = OpVectorShuffle %ivec2 %5 %undef 0 0 OpReturnValue %6 OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("The type of Vector 1 must be OpTypeVector."))); } TEST_P(ValidateIdWithMessage, OpVectorShuffleVector2Type) { std::string spirv = kGLSL450MemoryModel + R"( %int = OpTypeInt 32 0 %ivec2 = OpTypeVector %int 2 %ptr_ivec2 = OpTypePointer Function %ivec2 %undef = OpUndef %int %int_42 = OpConstant %int 42 %1 = OpConstantComposite %ivec2 %int_42 %int_42 %2 = OpTypeFunction %ivec2 %3 = OpFunction %ivec2 None %2 %4 = OpLabel %var = OpVariable %ptr_ivec2 Function %1 %5 = OpLoad %ivec2 %var %6 = OpVectorShuffle %ivec2 %5 %undef 0 1 OpReturnValue %6 OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("The type of Vector 2 must be OpTypeVector."))); } TEST_P(ValidateIdWithMessage, OpVectorShuffleVector1ComponentType) { std::string spirv = kGLSL450MemoryModel + R"( %int = OpTypeInt 32 0 %ivec3 = OpTypeVector %int 3 %ptr_ivec3 = OpTypePointer Function %ivec3 %int_42 = OpConstant %int 42 %int_0 = OpConstant %int 0 %int_2 = OpConstant %int 2 %float = OpTypeFloat 32 %vec3 = OpTypeVector %float 3 %vec4 = OpTypeVector %float 4 %ptr_vec3 = OpTypePointer Function %vec3 %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %1 = OpConstantComposite %ivec3 %int_42 %int_0 %int_2 %2 = OpConstantComposite %vec3 %float_1 %float_2 %float_2 %3 = OpTypeFunction %vec4 %4 = OpFunction %vec4 None %3 %5 = OpLabel %var = OpVariable %ptr_ivec3 Function %1 %var2 = OpVariable %ptr_vec3 Function %2 %6 = OpLoad %ivec3 %var %7 = OpLoad %vec3 %var2 %8 = OpVectorShuffle %vec4 %6 %7 4 3 1 0 OpReturnValue %8 OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "The Component Type of Vector 1 must be the same as " "ResultType."))); } TEST_P(ValidateIdWithMessage, OpVectorShuffleVector2ComponentType) { std::string spirv = kGLSL450MemoryModel + R"( %int = OpTypeInt 32 0 %ivec3 = OpTypeVector %int 3 %ptr_ivec3 = OpTypePointer Function %ivec3 %int_42 = OpConstant %int 42 %int_0 = OpConstant %int 0 %int_2 = OpConstant %int 2 %float = OpTypeFloat 32 %vec3 = OpTypeVector %float 3 %vec4 = OpTypeVector %float 4 %ptr_vec3 = OpTypePointer Function %vec3 %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %1 = OpConstantComposite %ivec3 %int_42 %int_0 %int_2 %2 = OpConstantComposite %vec3 %float_1 %float_2 %float_2 %3 = OpTypeFunction %vec4 %4 = OpFunction %vec4 None %3 %5 = OpLabel %var = OpVariable %ptr_ivec3 Function %1 %var2 = OpVariable %ptr_vec3 Function %2 %6 = OpLoad %vec3 %var2 %7 = OpLoad %ivec3 %var %8 = OpVectorShuffle %vec4 %6 %7 4 3 1 0 OpReturnValue %8 OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "The Component Type of Vector 2 must be the same as " "ResultType."))); } TEST_P(ValidateIdWithMessage, OpVectorShuffleLiterals) { std::string spirv = kGLSL450MemoryModel + R"( %float = OpTypeFloat 32 %vec2 = OpTypeVector %float 2 %vec3 = OpTypeVector %float 3 %vec4 = OpTypeVector %float 4 %ptr_vec2 = OpTypePointer Function %vec2 %ptr_vec3 = OpTypePointer Function %vec3 %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %1 = OpConstantComposite %vec2 %float_2 %float_1 %2 = OpConstantComposite %vec3 %float_1 %float_2 %float_2 %3 = OpTypeFunction %vec4 %4 = OpFunction %vec4 None %3 %5 = OpLabel %var = OpVariable %ptr_vec2 Function %1 %var2 = OpVariable %ptr_vec3 Function %2 %6 = OpLoad %vec2 %var %7 = OpLoad %vec3 %var2 %8 = OpVectorShuffle %vec4 %6 %7 0 8 2 6 OpReturnValue %8 OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message( "Component index 8 is out of bounds for combined (Vector1 + Vector2) " "size of 5."))); } // TODO: OpCompositeConstruct // TODO: OpCompositeExtract // TODO: OpCompositeInsert // TODO: OpCopyObject // TODO: OpTranspose // TODO: OpSNegate // TODO: OpFNegate // TODO: OpNot // TODO: OpIAdd // TODO: OpFAdd // TODO: OpISub // TODO: OpFSub // TODO: OpIMul // TODO: OpFMul // TODO: OpUDiv // TODO: OpSDiv // TODO: OpFDiv // TODO: OpUMod // TODO: OpSRem // TODO: OpSMod // TODO: OpFRem // TODO: OpFMod // TODO: OpVectorTimesScalar // TODO: OpMatrixTimesScalar // TODO: OpVectorTimesMatrix // TODO: OpMatrixTimesVector // TODO: OpMatrixTimesMatrix // TODO: OpOuterProduct // TODO: OpDot // TODO: OpShiftRightLogical // TODO: OpShiftRightArithmetic // TODO: OpShiftLeftLogical // TODO: OpBitwiseOr // TODO: OpBitwiseXor // TODO: OpBitwiseAnd // TODO: OpAny // TODO: OpAll // TODO: OpIsNan // TODO: OpIsInf // TODO: OpIsFinite // TODO: OpIsNormal // TODO: OpSignBitSet // TODO: OpLessOrGreater // TODO: OpOrdered // TODO: OpUnordered // TODO: OpLogicalOr // TODO: OpLogicalXor // TODO: OpLogicalAnd // TODO: OpSelect // TODO: OpIEqual // TODO: OpFOrdEqual // TODO: OpFUnordEqual // TODO: OpINotEqual // TODO: OpFOrdNotEqual // TODO: OpFUnordNotEqual // TODO: OpULessThan // TODO: OpSLessThan // TODO: OpFOrdLessThan // TODO: OpFUnordLessThan // TODO: OpUGreaterThan // TODO: OpSGreaterThan // TODO: OpFOrdGreaterThan // TODO: OpFUnordGreaterThan // TODO: OpULessThanEqual // TODO: OpSLessThanEqual // TODO: OpFOrdLessThanEqual // TODO: OpFUnordLessThanEqual // TODO: OpUGreaterThanEqual // TODO: OpSGreaterThanEqual // TODO: OpFOrdGreaterThanEqual // TODO: OpFUnordGreaterThanEqual // TODO: OpDPdx // TODO: OpDPdy // TODO: OpFWidth // TODO: OpDPdxFine // TODO: OpDPdyFine // TODO: OpFwidthFine // TODO: OpDPdxCoarse // TODO: OpDPdyCoarse // TODO: OpFwidthCoarse // TODO: OpLoopMerge // TODO: OpSelectionMerge // TODO: OpBranch TEST_P(ValidateIdWithMessage, OpPhiNotAType) { std::string spirv = kOpenCLMemoryModel32 + R"( %2 = OpTypeBool %3 = OpConstantTrue %2 %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpFunction %4 None %5 %7 = OpLabel OpBranch %8 %8 = OpLabel %9 = OpPhi %3 %3 %7 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message("ID '3[%true]' is not a type " "id"))); } TEST_P(ValidateIdWithMessage, OpPhiSamePredecessor) { std::string spirv = kOpenCLMemoryModel32 + R"( %2 = OpTypeBool %3 = OpConstantTrue %2 %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpFunction %4 None %5 %7 = OpLabel OpBranchConditional %3 %8 %8 %8 = OpLabel %9 = OpPhi %2 %3 %7 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpPhiOddArgumentNumber) { std::string spirv = kOpenCLMemoryModel32 + R"( %2 = OpTypeBool %3 = OpConstantTrue %2 %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpFunction %4 None %5 %7 = OpLabel OpBranch %8 %8 = OpLabel %9 = OpPhi %2 %3 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("OpPhi does not have an equal number of incoming " "values and basic blocks."))); } TEST_P(ValidateIdWithMessage, OpPhiTooFewPredecessors) { std::string spirv = kOpenCLMemoryModel32 + R"( %2 = OpTypeBool %3 = OpConstantTrue %2 %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpFunction %4 None %5 %7 = OpLabel OpBranch %8 %8 = OpLabel %9 = OpPhi %2 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpPhi's number of incoming blocks (0) does not match " "block's predecessor count (1)."))); } TEST_P(ValidateIdWithMessage, OpPhiTooManyPredecessors) { std::string spirv = kOpenCLMemoryModel32 + R"( %2 = OpTypeBool %3 = OpConstantTrue %2 %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpFunction %4 None %5 %7 = OpLabel OpBranch %8 %9 = OpLabel OpReturn %8 = OpLabel %10 = OpPhi %2 %3 %7 %3 %9 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpPhi's number of incoming blocks (2) does not match " "block's predecessor count (1)."))); } TEST_P(ValidateIdWithMessage, OpPhiMismatchedTypes) { std::string spirv = kOpenCLMemoryModel32 + R"( %2 = OpTypeBool %3 = OpConstantTrue %2 %4 = OpTypeVoid %5 = OpTypeInt 32 0 %6 = OpConstant %5 0 %7 = OpTypeFunction %4 %8 = OpFunction %4 None %7 %9 = OpLabel OpBranchConditional %3 %10 %11 %11 = OpLabel OpBranch %10 %10 = OpLabel %12 = OpPhi %2 %3 %9 %6 %11 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpPhi's result type '2[%bool]' does not match " "incoming value '6[%uint_0]' type " "'5[%uint]'."))); } TEST_P(ValidateIdWithMessage, OpPhiPredecessorNotABlock) { std::string spirv = kOpenCLMemoryModel32 + R"( %2 = OpTypeBool %3 = OpConstantTrue %2 %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpFunction %4 None %5 %7 = OpLabel OpBranchConditional %3 %8 %9 %9 = OpLabel OpBranch %11 %11 = OpLabel OpBranch %8 %8 = OpLabel %10 = OpPhi %2 %3 %7 %3 %3 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpPhi's incoming basic block '3[%true]' is not an " "OpLabel."))); } TEST_P(ValidateIdWithMessage, OpPhiNotAPredecessor) { std::string spirv = kOpenCLMemoryModel32 + R"( %2 = OpTypeBool %3 = OpConstantTrue %2 %4 = OpTypeVoid %5 = OpTypeFunction %4 %6 = OpFunction %4 None %5 %7 = OpLabel OpBranchConditional %3 %8 %9 %9 = OpLabel OpBranch %11 %11 = OpLabel OpBranch %8 %8 = OpLabel %10 = OpPhi %2 %3 %7 %3 %9 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpPhi's incoming basic block '9[%9]' is not a " "predecessor of '8[%8]'."))); } TEST_P(ValidateIdWithMessage, OpBranchConditionalGood) { std::string spirv = BranchConditionalSetup + R"( %branch_cond = OpINotEqual %bool %i0 %i1 OpSelectionMerge %end None OpBranchConditional %branch_cond %target_t %target_f )" + BranchConditionalTail; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()); } TEST_P(ValidateIdWithMessage, OpBranchConditionalWithWeightsGood) { std::string spirv = BranchConditionalSetup + R"( %branch_cond = OpINotEqual %bool %i0 %i1 OpSelectionMerge %end None OpBranchConditional %branch_cond %target_t %target_f 1 1 )" + BranchConditionalTail; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()); } TEST_P(ValidateIdWithMessage, OpBranchConditional_CondIsScalarInt) { std::string spirv = BranchConditionalSetup + R"( OpSelectionMerge %end None OpBranchConditional %i0 %target_t %target_f )" + BranchConditionalTail; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("Condition operand for OpBranchConditional must " "be of boolean type"))); } TEST_P(ValidateIdWithMessage, OpBranchConditional_TrueTargetIsNotLabel) { std::string spirv = BranchConditionalSetup + R"( OpSelectionMerge %end None OpBranchConditional %true %i0 %target_f )" + BranchConditionalTail; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "The 'True Label' operand for OpBranchConditional must " "be the ID of an OpLabel instruction"))); } TEST_P(ValidateIdWithMessage, OpBranchConditional_FalseTargetIsNotLabel) { std::string spirv = BranchConditionalSetup + R"( OpSelectionMerge %end None OpBranchConditional %true %target_t %i0 )" + BranchConditionalTail; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "The 'False Label' operand for OpBranchConditional " "must be the ID of an OpLabel instruction"))); } TEST_P(ValidateIdWithMessage, OpBranchConditional_NotEnoughWeights) { std::string spirv = BranchConditionalSetup + R"( %branch_cond = OpINotEqual %bool %i0 %i1 OpSelectionMerge %end None OpBranchConditional %branch_cond %target_t %target_f 1 )" + BranchConditionalTail; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpBranchConditional requires either 3 or 5 parameters"))); } TEST_P(ValidateIdWithMessage, OpBranchConditional_TooManyWeights) { std::string spirv = BranchConditionalSetup + R"( %branch_cond = OpINotEqual %bool %i0 %i1 OpSelectionMerge %end None OpBranchConditional %branch_cond %target_t %target_f 1 2 3 )" + BranchConditionalTail; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpBranchConditional requires either 3 or 5 parameters"))); } TEST_P(ValidateIdWithMessage, OpBranchConditional_ConditionIsAType) { std::string spirv = BranchConditionalSetup + R"( OpBranchConditional %bool %target_t %target_f )" + BranchConditionalTail; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message("Operand '3[%bool]' cannot be a " "type"))); } // TODO: OpSwitch TEST_P(ValidateIdWithMessage, OpReturnValueConstantGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypeFunction %2 %4 = OpConstant %2 42 %5 = OpFunction %2 None %3 %6 = OpLabel OpReturnValue %4 OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpReturnValueVariableGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 ;10 %3 = OpTypeFunction %2 %8 = OpTypePointer Function %2 ;18 %4 = OpConstant %2 42 ;22 %5 = OpFunction %2 None %3 ;27 %6 = OpLabel ;29 %7 = OpVariable %8 Function %4 ;34 %9 = OpLoad %2 %7 OpReturnValue %9 ;36 OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpReturnValueExpressionGood) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypeFunction %2 %4 = OpConstant %2 42 %5 = OpFunction %2 None %3 %6 = OpLabel %7 = OpIAdd %2 %4 %4 OpReturnValue %7 OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpReturnValueIsType) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypeFunction %2 %5 = OpFunction %2 None %3 %6 = OpLabel OpReturnValue %1 OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message("Operand '1[%void]' cannot be a " "type"))); } TEST_P(ValidateIdWithMessage, OpReturnValueIsLabel) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypeFunction %2 %5 = OpFunction %2 None %3 %6 = OpLabel OpReturnValue %6 OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message("Operand '5[%5]' requires a type"))); } TEST_P(ValidateIdWithMessage, OpReturnValueIsVoid) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypeFunction %1 %5 = OpFunction %1 None %3 %6 = OpLabel %7 = OpFunctionCall %1 %5 OpReturnValue %7 OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpReturnValue value's type '1[%void]' is missing or " "void."))); } TEST_P(ValidateIdWithMessage, OpReturnValueIsVariableInPhysical) { // It's valid to return a pointer in a physical addressing model. std::string spirv = kOpCapabilitySetup + R"( OpMemoryModel Physical32 OpenCL %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer Function %2 %4 = OpTypeFunction %3 %5 = OpFunction %3 None %4 %6 = OpLabel %7 = OpVariable %3 Function OpReturnValue %7 OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpReturnValueIsVariableInLogical) { // It's invalid to return a pointer in a physical addressing model. std::string spirv = kOpCapabilitySetup + R"( OpMemoryModel Logical GLSL450 %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer Function %2 %4 = OpTypeFunction %3 %5 = OpFunction %3 None %4 %6 = OpLabel %7 = OpVariable %3 Function OpReturnValue %7 OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("OpReturnValue value's type " "'3[%_ptr_Function_uint]' is a pointer, which is " "invalid in the Logical addressing model."))); } // With the VariablePointer Capability, the return value of a function is // allowed to be a pointer. TEST_P(ValidateIdWithMessage, OpReturnValueVarPtrGood) { std::ostringstream spirv; createVariablePointerSpirvProgram(&spirv, "" /* Instructions to add to "main" */, true /* Add VariablePointers Capability?*/, true /* Use Helper Function? */); CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // Without the VariablePointer Capability, the return value of a function is // *not* allowed to be a pointer. // Disabled since using OpSelect with pointers without VariablePointers will // fail LogicalsPass. TEST_P(ValidateIdWithMessage, DISABLED_OpReturnValueVarPtrBad) { std::ostringstream spirv; createVariablePointerSpirvProgram(&spirv, "" /* Instructions to add to "main" */, false /* Add VariablePointers Capability?*/, true /* Use Helper Function? */); CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpReturnValue value's type '7' is a pointer, " "which is invalid in the Logical addressing model."))); } // TODO: enable when this bug is fixed: // https://cvs.khronos.org/bugzilla/show_bug.cgi?id=15404 TEST_P(ValidateIdWithMessage, DISABLED_OpReturnValueIsFunction) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypeFunction %2 %5 = OpFunction %2 None %3 %6 = OpLabel OpReturnValue %5 OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, UndefinedTypeId) { std::string spirv = kGLSL450MemoryModel + R"( %s = OpTypeStruct %i32 )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "Operand '2[%2]' requires a previous definition"))); } TEST_P(ValidateIdWithMessage, UndefinedIdScope) { std::string spirv = kGLSL450MemoryModel + R"( %u32 = OpTypeInt 32 0 %memsem = OpConstant %u32 0 %void = OpTypeVoid %void_f = OpTypeFunction %void %f = OpFunction %void None %void_f %l = OpLabel OpMemoryBarrier %undef %memsem OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message("ID '7[%7]' has not been " "defined"))); } TEST_P(ValidateIdWithMessage, UndefinedIdMemSem) { std::string spirv = kGLSL450MemoryModel + R"( %u32 = OpTypeInt 32 0 %scope = OpConstant %u32 0 %void = OpTypeVoid %void_f = OpTypeFunction %void %f = OpFunction %void None %void_f %l = OpLabel OpMemoryBarrier %scope %undef OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message("ID '7[%7]' has not been " "defined"))); } TEST_P(ValidateIdWithMessage, KernelOpEntryPointAndOpInBoundsPtrAccessChainGood) { std::string spirv = kOpenCLMemoryModel32 + R"( OpEntryPoint Kernel %2 "simple_kernel" OpSource OpenCL_C 200000 OpDecorate %3 BuiltIn GlobalInvocationId OpDecorate %3 Constant OpDecorate %4 FuncParamAttr NoCapture OpDecorate %3 LinkageAttributes "__spirv_GlobalInvocationId" Import %5 = OpTypeInt 32 0 %6 = OpTypeVector %5 3 %7 = OpTypePointer UniformConstant %6 %3 = OpVariable %7 UniformConstant %8 = OpTypeVoid %9 = OpTypeStruct %5 %10 = OpTypePointer CrossWorkgroup %9 %11 = OpTypeFunction %8 %10 %12 = OpConstant %5 0 %13 = OpTypePointer CrossWorkgroup %5 %14 = OpConstant %5 42 %2 = OpFunction %8 None %11 %4 = OpFunctionParameter %10 %15 = OpLabel %16 = OpLoad %6 %3 Aligned 0 %17 = OpCompositeExtract %5 %16 0 %18 = OpInBoundsPtrAccessChain %13 %4 %17 %12 OpStore %18 %14 Aligned 4 OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpPtrAccessChainGood) { std::string spirv = kOpenCLMemoryModel64 + R"( OpEntryPoint Kernel %2 "another_kernel" OpSource OpenCL_C 200000 OpDecorate %3 BuiltIn GlobalInvocationId OpDecorate %3 Constant OpDecorate %4 FuncParamAttr NoCapture OpDecorate %3 LinkageAttributes "__spirv_GlobalInvocationId" Import %5 = OpTypeInt 64 0 %6 = OpTypeVector %5 3 %7 = OpTypePointer UniformConstant %6 %3 = OpVariable %7 UniformConstant %8 = OpTypeVoid %9 = OpTypeInt 32 0 %10 = OpTypeStruct %9 %11 = OpTypePointer CrossWorkgroup %10 %12 = OpTypeFunction %8 %11 %13 = OpConstant %5 4294967295 %14 = OpConstant %9 0 %15 = OpTypePointer CrossWorkgroup %9 %16 = OpConstant %9 42 %2 = OpFunction %8 None %12 %4 = OpFunctionParameter %11 %17 = OpLabel %18 = OpLoad %6 %3 Aligned 0 %19 = OpCompositeExtract %5 %18 0 %20 = OpBitwiseAnd %5 %19 %13 %21 = OpPtrAccessChain %15 %4 %20 %14 OpStore %21 %16 Aligned 4 OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, StgBufOpPtrAccessChainGood) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability VariablePointersStorageBuffer OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %3 "" OpDecorate %ptr ArrayStride 8 %int = OpTypeInt 32 0 %int_2 = OpConstant %int 2 %int_4 = OpConstant %int 4 %struct = OpTypeStruct %int %array = OpTypeArray %struct %int_4 %ptr = OpTypePointer StorageBuffer %array %var = OpVariable %ptr StorageBuffer %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpFunction %1 None %2 %4 = OpLabel %5 = OpPtrAccessChain %ptr %var %int_2 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpLoadBitcastPointerGood) { std::string spirv = kOpenCLMemoryModel64 + R"( %2 = OpTypeVoid %3 = OpTypeInt 32 0 %4 = OpTypeFloat 32 %5 = OpTypePointer UniformConstant %3 %6 = OpTypePointer UniformConstant %4 %7 = OpVariable %5 UniformConstant %8 = OpTypeFunction %2 %9 = OpFunction %2 None %8 %10 = OpLabel %11 = OpBitcast %6 %7 %12 = OpLoad %4 %11 OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpLoadBitcastNonPointerBad) { std::string spirv = kOpenCLMemoryModel64 + R"( %2 = OpTypeVoid %3 = OpTypeInt 32 0 %4 = OpTypeFloat 32 %5 = OpTypePointer UniformConstant %3 %6 = OpTypeFunction %2 %7 = OpVariable %5 UniformConstant %8 = OpFunction %2 None %6 %9 = OpLabel %10 = OpLoad %3 %7 %11 = OpBitcast %4 %10 %12 = OpLoad %3 %11 OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpLoad type for pointer '11[%11]' is not a pointer " "type."))); } TEST_P(ValidateIdWithMessage, OpStoreBitcastPointerGood) { std::string spirv = kOpenCLMemoryModel64 + R"( %2 = OpTypeVoid %3 = OpTypeInt 32 0 %4 = OpTypeFloat 32 %5 = OpTypePointer Function %3 %6 = OpTypePointer Function %4 %7 = OpTypeFunction %2 %8 = OpConstant %3 42 %9 = OpFunction %2 None %7 %10 = OpLabel %11 = OpVariable %6 Function %12 = OpBitcast %5 %11 OpStore %12 %8 OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateIdWithMessage, OpStoreBitcastNonPointerBad) { std::string spirv = kOpenCLMemoryModel64 + R"( %2 = OpTypeVoid %3 = OpTypeInt 32 0 %4 = OpTypeFloat 32 %5 = OpTypePointer Function %4 %6 = OpTypeFunction %2 %7 = OpConstant %4 42 %8 = OpFunction %2 None %6 %9 = OpLabel %10 = OpVariable %5 Function %11 = OpBitcast %3 %7 OpStore %11 %7 OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "OpStore type for pointer '11[%11]' is not a pointer " "type."))); } // Result resulting from an instruction within a function may not be used // outside that function. TEST_P(ValidateIdWithMessage, ResultIdUsedOutsideOfFunctionBad) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpTypeInt 32 0 %4 = OpTypePointer Function %3 %5 = OpFunction %1 None %2 %6 = OpLabel %7 = OpVariable %4 Function OpReturn OpFunctionEnd %8 = OpFunction %1 None %2 %9 = OpLabel %10 = OpLoad %3 %7 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message("ID '7[%7]' defined in block '6[%6]' does " "not dominate its use in block " "'9[%9]'"))); } TEST_P(ValidateIdWithMessage, SpecIdTargetNotSpecializationConstant) { std::string spirv = kGLSL450MemoryModel + R"( OpDecorate %1 SpecId 200 %void = OpTypeVoid %2 = OpTypeFunction %void %int = OpTypeInt 32 0 %1 = OpConstant %int 3 %main = OpFunction %void None %2 %4 = OpLabel OpReturnValue %1 OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("SpecId decoration on target " "'1[%uint_3]' must be a scalar specialization " "constant"))); } TEST_P(ValidateIdWithMessage, SpecIdTargetOpSpecConstantOpBad) { std::string spirv = kGLSL450MemoryModel + R"( OpDecorate %1 SpecId 200 %void = OpTypeVoid %2 = OpTypeFunction %void %int = OpTypeInt 32 0 %3 = OpConstant %int 1 %4 = OpConstant %int 2 %1 = OpSpecConstantOp %int IAdd %3 %4 %main = OpFunction %void None %2 %6 = OpLabel OpReturnValue %3 OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("SpecId decoration on target '1[%1]' " "must be a scalar specialization constant"))); } TEST_P(ValidateIdWithMessage, SpecIdTargetOpSpecConstantCompositeBad) { std::string spirv = kGLSL450MemoryModel + R"( OpDecorate %1 SpecId 200 %void = OpTypeVoid %2 = OpTypeFunction %void %int = OpTypeInt 32 0 %3 = OpConstant %int 1 %1 = OpSpecConstantComposite %int %main = OpFunction %void None %2 %4 = OpLabel OpReturnValue %3 OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("SpecId decoration on target '1[%1]' " "must be a scalar specialization constant"))); } TEST_P(ValidateIdWithMessage, SpecIdTargetGood) { std::string spirv = kGLSL450MemoryModel + R"( OpDecorate %3 SpecId 200 OpDecorate %4 SpecId 201 OpDecorate %5 SpecId 202 %1 = OpTypeVoid %2 = OpTypeFunction %1 %int = OpTypeInt 32 0 %bool = OpTypeBool %3 = OpSpecConstant %int 3 %4 = OpSpecConstantTrue %bool %5 = OpSpecConstantFalse %bool %main = OpFunction %1 None %2 %6 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()); } TEST_P(ValidateIdWithMessage, CorrectErrorForShuffle) { std::string spirv = kGLSL450MemoryModel + R"( %uint = OpTypeInt 32 0 %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %v2float = OpTypeVector %float 2 %void = OpTypeVoid %548 = OpTypeFunction %void %CS = OpFunction %void None %548 %550 = OpLabel %6275 = OpUndef %v2float %6280 = OpUndef %v2float %6282 = OpVectorShuffle %v4float %6275 %6280 0 1 4 5 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message( "Component index 4 is out of bounds for combined (Vector1 + Vector2) " "size of 4."))); EXPECT_EQ(25, getErrorPosition().index); } TEST_P(ValidateIdWithMessage, VoidStructMember) { const std::string spirv = kGLSL450MemoryModel + R"( %void = OpTypeVoid %struct = OpTypeStruct %void )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("Structures cannot contain a void type."))); } TEST_P(ValidateIdWithMessage, TypeFunctionBadUse) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpTypePointer Function %2 %4 = OpFunction %1 None %2 %5 = OpLabel OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "Invalid use of function type result id '2[%2]'."))); } TEST_P(ValidateIdWithMessage, BadTypeId) { std::string spirv = kGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpTypeFloat 32 %4 = OpConstant %3 0 %5 = OpFunction %1 None %2 %6 = OpLabel %7 = OpUndef %4 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message("ID '4[%float_0]' is not a type " "id"))); } TEST_P(ValidateIdWithMessage, VulkanMemoryModelLoadMakePointerVisibleGood) { std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability Linkage OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer Workgroup %2 %4 = OpVariable %3 Workgroup %5 = OpTypeFunction %1 %6 = OpConstant %2 2 %7 = OpFunction %1 None %5 %8 = OpLabel %9 = OpLoad %2 %4 NonPrivatePointerKHR|MakePointerVisibleKHR %6 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_P(ValidateIdWithMessage, VulkanMemoryModelLoadMakePointerVisibleMissingNonPrivatePointer) { std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability Linkage OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer Workgroup %2 %4 = OpVariable %3 Workgroup %5 = OpTypeFunction %1 %6 = OpConstant %2 2 %7 = OpFunction %1 None %5 %8 = OpLabel %9 = OpLoad %2 %4 MakePointerVisibleKHR %6 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("NonPrivatePointerKHR must be specified if " "MakePointerVisibleKHR is specified."))); } TEST_P(ValidateIdWithMessage, VulkanMemoryModelLoadNonPrivatePointerBadStorageClass) { std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability Linkage OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer Private %2 %4 = OpVariable %3 Private %5 = OpTypeFunction %1 %6 = OpConstant %2 2 %7 = OpFunction %1 None %5 %8 = OpLabel %9 = OpLoad %2 %4 NonPrivatePointerKHR OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "NonPrivatePointerKHR requires a pointer in Uniform, " "Workgroup, CrossWorkgroup, Generic, Image or " "StorageBuffer storage classes."))); } TEST_P(ValidateIdWithMessage, VulkanMemoryModelLoadMakePointerAvailableCannotBeUsed) { std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability Linkage OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer Workgroup %2 %4 = OpVariable %3 Workgroup %5 = OpTypeFunction %1 %6 = OpConstant %2 2 %7 = OpFunction %1 None %5 %8 = OpLabel %9 = OpLoad %2 %4 NonPrivatePointerKHR|MakePointerAvailableKHR %6 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "MakePointerAvailableKHR cannot be used with OpLoad"))); } TEST_P(ValidateIdWithMessage, VulkanMemoryModelStoreMakePointerAvailableGood) { std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability Linkage OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer Uniform %2 %4 = OpVariable %3 Uniform %5 = OpTypeFunction %1 %6 = OpConstant %2 5 %7 = OpFunction %1 None %5 %8 = OpLabel OpStore %4 %6 NonPrivatePointerKHR|MakePointerAvailableKHR %6 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_P(ValidateIdWithMessage, VulkanMemoryModelStoreMakePointerAvailableMissingNonPrivatePointer) { std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability Linkage OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer Uniform %2 %4 = OpVariable %3 Uniform %5 = OpTypeFunction %1 %6 = OpConstant %2 5 %7 = OpFunction %1 None %5 %8 = OpLabel OpStore %4 %6 MakePointerAvailableKHR %6 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("NonPrivatePointerKHR must be specified if " "MakePointerAvailableKHR is specified."))); } TEST_P(ValidateIdWithMessage, VulkanMemoryModelStoreNonPrivatePointerBadStorageClass) { std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability Linkage OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer Output %2 %4 = OpVariable %3 Output %5 = OpTypeFunction %1 %6 = OpConstant %2 5 %7 = OpFunction %1 None %5 %8 = OpLabel OpStore %4 %6 NonPrivatePointerKHR OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "NonPrivatePointerKHR requires a pointer in Uniform, " "Workgroup, CrossWorkgroup, Generic, Image or " "StorageBuffer storage classes."))); } TEST_P(ValidateIdWithMessage, VulkanMemoryModelStoreMakePointerVisibleCannotBeUsed) { std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability Linkage OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer Uniform %2 %4 = OpVariable %3 Uniform %5 = OpTypeFunction %1 %6 = OpConstant %2 5 %7 = OpFunction %1 None %5 %8 = OpLabel OpStore %4 %6 NonPrivatePointerKHR|MakePointerVisibleKHR %6 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "MakePointerVisibleKHR cannot be used with OpStore."))); } TEST_P(ValidateIdWithMessage, VulkanMemoryModelCopyMemoryAvailable) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer Workgroup %2 %4 = OpVariable %3 Workgroup %5 = OpTypePointer Uniform %2 %6 = OpVariable %5 Uniform %7 = OpConstant %2 2 %8 = OpConstant %2 5 %9 = OpTypeFunction %1 %10 = OpFunction %1 None %9 %11 = OpLabel OpCopyMemory %4 %6 NonPrivatePointerKHR|MakePointerAvailableKHR %7 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_P(ValidateIdWithMessage, VulkanMemoryModelCopyMemoryVisible) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer Workgroup %2 %4 = OpVariable %3 Workgroup %5 = OpTypePointer Uniform %2 %6 = OpVariable %5 Uniform %7 = OpConstant %2 2 %8 = OpConstant %2 5 %9 = OpTypeFunction %1 %10 = OpFunction %1 None %9 %11 = OpLabel OpCopyMemory %4 %6 NonPrivatePointerKHR|MakePointerVisibleKHR %8 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_P(ValidateIdWithMessage, VulkanMemoryModelCopyMemoryAvailableAndVisible) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer Workgroup %2 %4 = OpVariable %3 Workgroup %5 = OpTypePointer Uniform %2 %6 = OpVariable %5 Uniform %7 = OpConstant %2 2 %8 = OpConstant %2 5 %9 = OpTypeFunction %1 %10 = OpFunction %1 None %9 %11 = OpLabel OpCopyMemory %4 %6 NonPrivatePointerKHR|MakePointerAvailableKHR|MakePointerVisibleKHR %7 %8 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_P(ValidateIdWithMessage, VulkanMemoryModelCopyMemoryAvailableMissingNonPrivatePointer) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer Workgroup %2 %4 = OpVariable %3 Workgroup %5 = OpTypePointer Uniform %2 %6 = OpVariable %5 Uniform %7 = OpConstant %2 2 %8 = OpConstant %2 5 %9 = OpTypeFunction %1 %10 = OpFunction %1 None %9 %11 = OpLabel OpCopyMemory %4 %6 MakePointerAvailableKHR %7 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("NonPrivatePointerKHR must be specified if " "MakePointerAvailableKHR is specified."))); } TEST_P(ValidateIdWithMessage, VulkanMemoryModelCopyMemoryVisibleMissingNonPrivatePointer) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer Workgroup %2 %4 = OpVariable %3 Workgroup %5 = OpTypePointer Uniform %2 %6 = OpVariable %5 Uniform %7 = OpConstant %2 2 %8 = OpConstant %2 5 %9 = OpTypeFunction %1 %10 = OpFunction %1 None %9 %11 = OpLabel OpCopyMemory %4 %6 MakePointerVisibleKHR %8 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("NonPrivatePointerKHR must be specified if " "MakePointerVisibleKHR is specified."))); } TEST_P(ValidateIdWithMessage, VulkanMemoryModelCopyMemoryAvailableBadStorageClass) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer Output %2 %4 = OpVariable %3 Output %5 = OpTypePointer Uniform %2 %6 = OpVariable %5 Uniform %7 = OpConstant %2 2 %8 = OpConstant %2 5 %9 = OpTypeFunction %1 %10 = OpFunction %1 None %9 %11 = OpLabel OpCopyMemory %4 %6 NonPrivatePointerKHR OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "NonPrivatePointerKHR requires a pointer in Uniform, " "Workgroup, CrossWorkgroup, Generic, Image or " "StorageBuffer storage classes."))); } TEST_P(ValidateIdWithMessage, VulkanMemoryModelCopyMemoryVisibleBadStorageClass) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer Workgroup %2 %4 = OpVariable %3 Workgroup %5 = OpTypePointer Input %2 %6 = OpVariable %5 Input %7 = OpConstant %2 2 %8 = OpConstant %2 5 %9 = OpTypeFunction %1 %10 = OpFunction %1 None %9 %11 = OpLabel OpCopyMemory %4 %6 NonPrivatePointerKHR OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "NonPrivatePointerKHR requires a pointer in Uniform, " "Workgroup, CrossWorkgroup, Generic, Image or " "StorageBuffer storage classes."))); } TEST_P(ValidateIdWithMessage, VulkanMemoryModelCopyMemorySizedAvailable) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability Addresses OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer Workgroup %2 %4 = OpVariable %3 Workgroup %5 = OpTypePointer Uniform %2 %6 = OpVariable %5 Uniform %7 = OpConstant %2 2 %8 = OpConstant %2 5 %9 = OpTypeFunction %1 %12 = OpConstant %2 4 %10 = OpFunction %1 None %9 %11 = OpLabel OpCopyMemorySized %4 %6 %12 NonPrivatePointerKHR|MakePointerAvailableKHR %7 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_P(ValidateIdWithMessage, VulkanMemoryModelCopyMemorySizedVisible) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability Addresses OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer Workgroup %2 %4 = OpVariable %3 Workgroup %5 = OpTypePointer Uniform %2 %6 = OpVariable %5 Uniform %7 = OpConstant %2 2 %8 = OpConstant %2 5 %12 = OpConstant %2 4 %9 = OpTypeFunction %1 %10 = OpFunction %1 None %9 %11 = OpLabel OpCopyMemorySized %4 %6 %12 NonPrivatePointerKHR|MakePointerVisibleKHR %8 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_P(ValidateIdWithMessage, VulkanMemoryModelCopyMemorySizedAvailableAndVisible) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability Addresses OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer Workgroup %2 %4 = OpVariable %3 Workgroup %5 = OpTypePointer Uniform %2 %6 = OpVariable %5 Uniform %7 = OpConstant %2 2 %8 = OpConstant %2 5 %12 = OpConstant %2 4 %9 = OpTypeFunction %1 %10 = OpFunction %1 None %9 %11 = OpLabel OpCopyMemorySized %4 %6 %12 NonPrivatePointerKHR|MakePointerAvailableKHR|MakePointerVisibleKHR %7 %8 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_P(ValidateIdWithMessage, VulkanMemoryModelCopyMemorySizedAvailableMissingNonPrivatePointer) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability Addresses OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer Workgroup %2 %4 = OpVariable %3 Workgroup %5 = OpTypePointer Uniform %2 %6 = OpVariable %5 Uniform %7 = OpConstant %2 2 %8 = OpConstant %2 5 %12 = OpConstant %2 4 %9 = OpTypeFunction %1 %10 = OpFunction %1 None %9 %11 = OpLabel OpCopyMemorySized %4 %6 %12 MakePointerAvailableKHR %7 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("NonPrivatePointerKHR must be specified if " "MakePointerAvailableKHR is specified."))); } TEST_P(ValidateIdWithMessage, VulkanMemoryModelCopyMemorySizedVisibleMissingNonPrivatePointer) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability Addresses OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer Workgroup %2 %4 = OpVariable %3 Workgroup %5 = OpTypePointer Uniform %2 %6 = OpVariable %5 Uniform %7 = OpConstant %2 2 %8 = OpConstant %2 5 %12 = OpConstant %2 4 %9 = OpTypeFunction %1 %10 = OpFunction %1 None %9 %11 = OpLabel OpCopyMemorySized %4 %6 %12 MakePointerVisibleKHR %8 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("NonPrivatePointerKHR must be specified if " "MakePointerVisibleKHR is specified."))); } TEST_P(ValidateIdWithMessage, VulkanMemoryModelCopyMemorySizedAvailableBadStorageClass) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability Addresses OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer Output %2 %4 = OpVariable %3 Output %5 = OpTypePointer Uniform %2 %6 = OpVariable %5 Uniform %7 = OpConstant %2 2 %8 = OpConstant %2 5 %12 = OpConstant %2 4 %9 = OpTypeFunction %1 %10 = OpFunction %1 None %9 %11 = OpLabel OpCopyMemorySized %4 %6 %12 NonPrivatePointerKHR OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "NonPrivatePointerKHR requires a pointer in Uniform, " "Workgroup, CrossWorkgroup, Generic, Image or " "StorageBuffer storage classes."))); } TEST_P(ValidateIdWithMessage, VulkanMemoryModelCopyMemorySizedVisibleBadStorageClass) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability Addresses OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %1 = OpTypeVoid %2 = OpTypeInt 32 0 %3 = OpTypePointer Workgroup %2 %4 = OpVariable %3 Workgroup %5 = OpTypePointer Input %2 %6 = OpVariable %5 Input %7 = OpConstant %2 2 %8 = OpConstant %2 5 %12 = OpConstant %2 4 %9 = OpTypeFunction %1 %10 = OpFunction %1 None %9 %11 = OpLabel OpCopyMemorySized %4 %6 %12 NonPrivatePointerKHR OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "NonPrivatePointerKHR requires a pointer in Uniform, " "Workgroup, CrossWorkgroup, Generic, Image or " "StorageBuffer storage classes."))); } TEST_P(ValidateIdWithMessage, IdDefInUnreachableBlock1) { const std::string spirv = kNoKernelGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpTypeFloat 32 %4 = OpTypeFunction %3 %5 = OpFunction %1 None %2 %6 = OpLabel OpReturn %7 = OpLabel %8 = OpFunctionCall %3 %9 OpUnreachable OpFunctionEnd %9 = OpFunction %3 None %4 %10 = OpLabel OpReturnValue %8 OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "ID '8[%8]' defined in block '7[%7]' does not dominate its " "use in block '10[%10]'\n %10 = OpLabel"))); } TEST_P(ValidateIdWithMessage, IdDefInUnreachableBlock2) { const std::string spirv = kNoKernelGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpTypeFloat 32 %4 = OpTypeFunction %3 %5 = OpFunction %1 None %2 %6 = OpLabel OpReturn %7 = OpLabel %8 = OpFunctionCall %3 %9 OpUnreachable OpFunctionEnd %9 = OpFunction %3 None %4 %10 = OpLabel OpReturnValue %8 OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "ID '8[%8]' defined in block '7[%7]' does not dominate its " "use in block '10[%10]'\n %10 = OpLabel"))); } TEST_P(ValidateIdWithMessage, IdDefInUnreachableBlock3) { const std::string spirv = kNoKernelGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpTypeFloat 32 %4 = OpTypeFunction %3 %5 = OpFunction %1 None %2 %6 = OpLabel OpReturn %7 = OpLabel %8 = OpFunctionCall %3 %9 OpReturn OpFunctionEnd %9 = OpFunction %3 None %4 %10 = OpLabel OpReturnValue %8 OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "ID '8[%8]' defined in block '7[%7]' does not dominate its " "use in block '10[%10]'\n %10 = OpLabel"))); } TEST_P(ValidateIdWithMessage, IdDefInUnreachableBlock4) { const std::string spirv = kNoKernelGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpTypeFloat 32 %4 = OpTypeFunction %3 %5 = OpFunction %1 None %2 %6 = OpLabel OpReturn %7 = OpLabel %8 = OpUndef %3 %9 = OpCopyObject %3 %8 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_P(ValidateIdWithMessage, IdDefInUnreachableBlock5) { const std::string spirv = kNoKernelGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpTypeFloat 32 %4 = OpTypeFunction %3 %5 = OpFunction %1 None %2 %6 = OpLabel OpReturn %7 = OpLabel %8 = OpUndef %3 OpBranch %9 %9 = OpLabel %10 = OpCopyObject %3 %8 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_P(ValidateIdWithMessage, IdDefInUnreachableBlock6) { const std::string spirv = kNoKernelGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpTypeFloat 32 %4 = OpTypeFunction %3 %5 = OpFunction %1 None %2 %6 = OpLabel OpBranch %7 %8 = OpLabel %9 = OpUndef %3 OpBranch %7 %7 = OpLabel %10 = OpCopyObject %3 %9 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "ID '9[%9]' defined in block '8[%8]' does not dominate its " "use in block '7[%7]'\n %7 = OpLabel"))); } TEST_P(ValidateIdWithMessage, ReachableDefUnreachableUse) { const std::string spirv = kNoKernelGLSL450MemoryModel + R"( %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpTypeFloat 32 %4 = OpTypeFunction %3 %5 = OpFunction %1 None %2 %6 = OpLabel %7 = OpUndef %3 OpReturn %8 = OpLabel %9 = OpCopyObject %3 %7 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_P(ValidateIdWithMessage, UnreachableDefUsedInPhi) { const std::string spirv = kNoKernelGLSL450MemoryModel + R"( %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %bool = OpTypeBool %6 = OpTypeFunction %float %1 = OpFunction %void None %3 %7 = OpLabel %8 = OpUndef %bool OpSelectionMerge %9 None OpBranchConditional %8 %10 %9 %10 = OpLabel %11 = OpUndef %float OpBranch %9 %12 = OpLabel %13 = OpUndef %float OpUnreachable %9 = OpLabel %14 = OpPhi %float %11 %10 %13 %7 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message( "In OpPhi instruction '14[%14]', ID '13[%13]' definition does not " "dominate its parent '7[%7]'\n %14 = OpPhi %float %11 %10 %13 " "%7"))); } TEST_P(ValidateIdWithMessage, OpTypeForwardPointerNotAPointerType) { std::string spirv = R"( OpCapability GenericPointer OpCapability VariablePointersStorageBuffer OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginLowerLeft OpTypeForwardPointer %2 CrossWorkgroup %2 = OpTypeVoid %3 = OpTypeFunction %2 %1 = OpFunction %2 DontInline %3 %4 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "Pointer type in OpTypeForwardPointer is not a pointer " "type.\n OpTypeForwardPointer %void CrossWorkgroup"))); } TEST_P(ValidateIdWithMessage, OpTypeForwardPointerWrongStorageClass) { std::string spirv = R"( OpCapability GenericPointer OpCapability VariablePointersStorageBuffer OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginLowerLeft OpTypeForwardPointer %2 CrossWorkgroup %int = OpTypeInt 32 1 %2 = OpTypePointer Function %int %void = OpTypeVoid %3 = OpTypeFunction %void %1 = OpFunction %void None %3 %4 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message( "Storage class in OpTypeForwardPointer does not match the " "pointer definition.\n OpTypeForwardPointer " "%_ptr_Function_int CrossWorkgroup"))); } TEST_P(ValidateIdWithMessage, MissingForwardPointer) { const std::string spirv = R"( OpCapability Linkage OpCapability Shader OpMemoryModel Logical Simple %float = OpTypeFloat 32 %_struct_9 = OpTypeStruct %float %_ptr_Uniform__struct_9 %_ptr_Uniform__struct_9 = OpTypePointer Uniform %_struct_9 %1278 = OpVariable %_ptr_Uniform__struct_9 Uniform )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message("Operand '3[%_ptr_Uniform__struct_2]' " "requires a previous definition"))); } TEST_P(ValidateIdWithMessage, NVBindlessSamplerInStruct) { std::string spirv = R"( OpCapability Shader OpCapability BindlessTextureNV OpExtension "SPV_NV_bindless_texture" OpMemoryModel Logical GLSL450 OpSamplerImageAddressingModeNV 64 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %7 = OpTypeImage %float 2D 0 0 0 1 Unknown %8 = OpTypeSampledImage %7 %9 = OpTypeImage %float 2D 0 0 0 2 Rgba32f %10 = OpTypeSampler %UBO = OpTypeStruct %8 %9 %10 %_ptr_Uniform_UBO = OpTypePointer Uniform %UBO %_ = OpVariable %_ptr_Uniform_UBO Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_P(ValidateIdWithMessage, OpExtInstWithForwardRefsKHRDisallowedNoForwardRef) { std::string spirv = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" OpExtension "SPV_KHR_relaxed_extended_instruction" %1 = OpExtInstImport "NonSemantic.Shader.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %main_type = OpTypeFunction %void %4 = OpExtInstWithForwardRefsKHR %void %1 DebugInfoNone %main = OpFunction %void None %main_type %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_6); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_6)); EXPECT_THAT( getDiagnosticString(), HasSubstr(make_message("Opcode OpExtInstWithForwardRefsKHR must have at " "least one forward declared ID."))); } TEST_P(ValidateIdWithMessage, OpExtInstNoForwardRef) { std::string spirv = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" OpExtension "SPV_KHR_relaxed_extended_instruction" %1 = OpExtInstImport "NonSemantic.Shader.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %main_type = OpTypeFunction %void %4 = OpExtInst %void %1 DebugInfoNone %main = OpFunction %void None %main_type %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_6); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_6)); } TEST_P(ValidateIdWithMessage, OpExtInstWithForwardRefsKHRAllowedForwardReferenceInNonSemantic) { std::string spirv = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" OpExtension "SPV_KHR_relaxed_extended_instruction" %1 = OpExtInstImport "NonSemantic.Shader.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" OpExecutionMode %2 LocalSize 1 1 1 %3 = OpString "sample" %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %7 = OpTypeFunction %void %8 = OpExtInst %void %1 DebugSource %3 %3 %9 = OpExtInst %void %1 DebugCompilationUnit %uint_0 %uint_0 %8 %uint_0 %10 = OpExtInstWithForwardRefsKHR %void %1 DebugTypeFunction %uint_0 %11 %12 = OpExtInstWithForwardRefsKHR %void %1 DebugFunction %3 %10 %8 %uint_0 %uint_0 %11 %3 %uint_0 %uint_0 %11 = OpExtInst %void %1 DebugTypeComposite %3 %uint_0 %8 %uint_0 %uint_0 %9 %3 %uint_0 %uint_0 %12 %2 = OpFunction %void None %7 %13 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_6); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_6)); } TEST_P(ValidateIdWithMessage, OpExtInstNoForwardDeclAllowed) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "NonSemantic.Shader.DebugInfo.100" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 "main" OpExecutionMode %2 LocalSize 1 1 1 %3 = OpString "sample" %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %7 = OpTypeFunction %void %8 = OpExtInst %void %1 DebugSource %3 %3 %9 = OpExtInst %void %1 DebugCompilationUnit %uint_0 %uint_0 %8 %uint_0 %10 = OpExtInst %void %1 DebugTypeFunction %uint_0 %11 %12 = OpExtInst %void %1 DebugFunction %3 %10 %8 %uint_0 %uint_0 %11 %3 %uint_0 %uint_0 %11 = OpExtInst %void %1 DebugTypeComposite %3 %uint_0 %8 %uint_0 %uint_0 %9 %3 %uint_0 %uint_0 %12 %2 = OpFunction %void None %7 %13 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_6); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_6)); EXPECT_THAT(getDiagnosticString(), HasSubstr(make_message("ID '11[%11]' has not been defined"))); } INSTANTIATE_TEST_SUITE_P(, ValidateIdWithMessage, ::testing::Bool()); } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_image_test.cpp000066400000000000000000015172211475742701700237720ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights // reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Tests for unique type declaration rules validator. #include #include #include "gmock/gmock.h" #include "spirv-tools/libspirv.h" #include "test/unit_spirv.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::Eq; using ::testing::HasSubstr; using ::testing::Not; using ValidateImage = spvtest::ValidateBase; std::string GenerateShaderCode( const std::string& body, const std::string& capabilities_and_extensions = "", const std::string& execution_model = "Fragment", const std::string& execution_mode = "", const spv_target_env env = SPV_ENV_UNIVERSAL_1_0, const std::string& memory_model = "GLSL450", const std::string& declarations = "") { std::ostringstream ss; ss << R"( OpCapability Shader OpCapability InputAttachment OpCapability ImageGatherExtended OpCapability MinLod OpCapability Sampled1D OpCapability ImageQuery OpCapability Int64 OpCapability Float64 OpCapability SparseResidency OpCapability ImageBuffer )"; if (env == SPV_ENV_UNIVERSAL_1_0) { ss << "OpCapability SampledRect\n"; } // In 1.4, the entry point must list all module-scope variables used. Just // list all of them. // // For Vulkan, anything Location decoration needs to be an interface variable std::string interface_vars = (env != SPV_ENV_UNIVERSAL_1_4) ? "%input_flat_u32" : R"( %uniform_image_f32_1d_0001 %uniform_image_f32_1d_0002_rgba32f %uniform_image_f32_2d_0001 %uniform_image_f32_2d_0011 ; multisampled sampled %uniform_image_u32_2d_0001 %uniform_image_u32_2d_0002 %uniform_image_s32_3d_0001 %uniform_image_f32_2d_0002 %uniform_image_s32_2d_0002 %uniform_image_f32_spd_0002 %uniform_image_f32_3d_0111 %uniform_image_f32_cube_0101 %uniform_image_f32_cube_0102_rgba32f %uniform_sampler %private_image_u32_buffer_0002_r32ui %private_image_u32_spd_0002 %private_image_f32_buffer_0002_r32ui %input_flat_u32 )"; ss << capabilities_and_extensions; ss << "OpMemoryModel Logical " << memory_model << "\n"; ss << "OpEntryPoint " << execution_model << " %main \"main\" " + interface_vars + "\n"; if (execution_model == "Fragment") { ss << "OpExecutionMode %main OriginUpperLeft\n"; } ss << execution_mode; if (env == SPV_ENV_VULKAN_1_0) { ss << R"( OpDecorate %uniform_image_f32_1d_0001 DescriptorSet 0 OpDecorate %uniform_image_f32_1d_0001 Binding 0 OpDecorate %uniform_image_f32_1d_0002_rgba32f DescriptorSet 0 OpDecorate %uniform_image_f32_1d_0002_rgba32f Binding 1 OpDecorate %uniform_image_f32_2d_0001 DescriptorSet 0 OpDecorate %uniform_image_f32_2d_0001 Binding 2 OpDecorate %uniform_image_f32_2d_0011 DescriptorSet 0 OpDecorate %uniform_image_f32_2d_0011 Binding 3 OpDecorate %uniform_image_u32_2d_0001 DescriptorSet 1 OpDecorate %uniform_image_u32_2d_0001 Binding 0 OpDecorate %uniform_image_u32_2d_0002 DescriptorSet 1 OpDecorate %uniform_image_u32_2d_0002 Binding 1 OpDecorate %uniform_image_s32_3d_0001 DescriptorSet 1 OpDecorate %uniform_image_s32_3d_0001 Binding 2 OpDecorate %uniform_image_f32_2d_0002 DescriptorSet 1 OpDecorate %uniform_image_f32_2d_0002 Binding 3 OpDecorate %uniform_image_s32_2d_0002 DescriptorSet 1 OpDecorate %uniform_image_s32_2d_0002 Binding 4 OpDecorate %uniform_image_f32_spd_0002 DescriptorSet 2 OpDecorate %uniform_image_f32_spd_0002 Binding 0 OpDecorate %uniform_image_f32_3d_0111 DescriptorSet 2 OpDecorate %uniform_image_f32_3d_0111 Binding 1 OpDecorate %uniform_image_f32_cube_0101 DescriptorSet 2 OpDecorate %uniform_image_f32_cube_0101 Binding 2 OpDecorate %uniform_image_f32_cube_0102_rgba32f DescriptorSet 2 OpDecorate %uniform_image_f32_cube_0102_rgba32f Binding 3 OpDecorate %uniform_sampler DescriptorSet 3 OpDecorate %uniform_sampler Binding 0 OpDecorate %input_flat_u32 Flat OpDecorate %input_flat_u32 Location 0 )"; } ss << R"( %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f32 = OpTypeFloat 32 %f64 = OpTypeFloat 64 %u32 = OpTypeInt 32 0 %s32 = OpTypeInt 32 1 %u64 = OpTypeInt 64 0 %s64 = OpTypeInt 64 1 %s32vec2 = OpTypeVector %s32 2 %u32vec2 = OpTypeVector %u32 2 %f32vec2 = OpTypeVector %f32 2 %u32vec3 = OpTypeVector %u32 3 %s32vec3 = OpTypeVector %s32 3 %f32vec3 = OpTypeVector %f32 3 %u32vec4 = OpTypeVector %u32 4 %s32vec4 = OpTypeVector %s32 4 %f32vec4 = OpTypeVector %f32 4 %boolvec4 = OpTypeVector %bool 4 %f32_0 = OpConstant %f32 0 %f32_1 = OpConstant %f32 1 %f32_0_5 = OpConstant %f32 0.5 %f32_0_25 = OpConstant %f32 0.25 %f32_0_75 = OpConstant %f32 0.75 %f64_0 = OpConstant %f64 0 %f64_1 = OpConstant %f64 1 %s32_0 = OpConstant %s32 0 %s32_1 = OpConstant %s32 1 %s32_2 = OpConstant %s32 2 %s32_3 = OpConstant %s32 3 %s32_4 = OpConstant %s32 4 %s32_m1 = OpConstant %s32 -1 %u32_0 = OpConstant %u32 0 %u32_1 = OpConstant %u32 1 %u32_2 = OpConstant %u32 2 %u32_3 = OpConstant %u32 3 %u32_4 = OpConstant %u32 4 %u64_0 = OpConstant %u64 0 %u64_1 = OpConstant %u64 1 %bool_t = OpConstantTrue %bool %u32vec2arr4 = OpTypeArray %u32vec2 %u32_4 %u32vec2arr3 = OpTypeArray %u32vec2 %u32_3 %u32arr4 = OpTypeArray %u32 %u32_4 %u32vec3arr4 = OpTypeArray %u32vec3 %u32_4 %struct_u32_f32vec4 = OpTypeStruct %u32 %f32vec4 %struct_u64_f32vec4 = OpTypeStruct %u64 %f32vec4 %struct_u32_u32vec4 = OpTypeStruct %u32 %u32vec4 %struct_u32_f32vec3 = OpTypeStruct %u32 %f32vec3 %struct_f32_f32vec4 = OpTypeStruct %f32 %f32vec4 %struct_u32_u32 = OpTypeStruct %u32 %u32 %struct_f32_f32 = OpTypeStruct %f32 %f32 %struct_u32 = OpTypeStruct %u32 %struct_u32_f32_u32 = OpTypeStruct %u32 %f32 %u32 %struct_u32_f32vec4_u32 = OpTypeStruct %u32 %f32vec4 %u32 %struct_u32_u32arr4 = OpTypeStruct %u32 %u32arr4 %u32vec2_01 = OpConstantComposite %u32vec2 %u32_0 %u32_1 %u32vec2_12 = OpConstantComposite %u32vec2 %u32_1 %u32_2 %u32vec3_012 = OpConstantComposite %u32vec3 %u32_0 %u32_1 %u32_2 %u32vec3_123 = OpConstantComposite %u32vec3 %u32_1 %u32_2 %u32_3 %u32vec4_0123 = OpConstantComposite %u32vec4 %u32_0 %u32_1 %u32_2 %u32_3 %u32vec4_1234 = OpConstantComposite %u32vec4 %u32_1 %u32_2 %u32_3 %u32_4 %s32vec2_01 = OpConstantComposite %s32vec2 %s32_0 %s32_1 %s32vec2_12 = OpConstantComposite %s32vec2 %s32_1 %s32_2 %s32vec3_012 = OpConstantComposite %s32vec3 %s32_0 %s32_1 %s32_2 %s32vec3_123 = OpConstantComposite %s32vec3 %s32_1 %s32_2 %s32_3 %s32vec4_0123 = OpConstantComposite %s32vec4 %s32_0 %s32_1 %s32_2 %s32_3 %s32vec4_1234 = OpConstantComposite %s32vec4 %s32_1 %s32_2 %s32_3 %s32_4 %f32vec2_00 = OpConstantComposite %f32vec2 %f32_0 %f32_0 %f32vec2_01 = OpConstantComposite %f32vec2 %f32_0 %f32_1 %f32vec2_10 = OpConstantComposite %f32vec2 %f32_1 %f32_0 %f32vec2_11 = OpConstantComposite %f32vec2 %f32_1 %f32_1 %f32vec2_hh = OpConstantComposite %f32vec2 %f32_0_5 %f32_0_5 %f32vec3_000 = OpConstantComposite %f32vec3 %f32_0 %f32_0 %f32_0 %f32vec3_hhh = OpConstantComposite %f32vec3 %f32_0_5 %f32_0_5 %f32_0_5 %f32vec4_0000 = OpConstantComposite %f32vec4 %f32_0 %f32_0 %f32_0 %f32_0 %boolvec4_tttt = OpConstantComposite %boolvec4 %bool_t %bool_t %bool_t %bool_t %const_offsets = OpConstantComposite %u32vec2arr4 %u32vec2_01 %u32vec2_12 %u32vec2_01 %u32vec2_12 %const_offsets3x2 = OpConstantComposite %u32vec2arr3 %u32vec2_01 %u32vec2_12 %u32vec2_01 %const_offsets4xu = OpConstantComposite %u32arr4 %u32_0 %u32_0 %u32_0 %u32_0 %const_offsets4x3 = OpConstantComposite %u32vec3arr4 %u32vec3_012 %u32vec3_012 %u32vec3_012 %u32vec3_012 %type_image_f32_1d_0001 = OpTypeImage %f32 1D 0 0 0 1 Unknown %ptr_image_f32_1d_0001 = OpTypePointer UniformConstant %type_image_f32_1d_0001 %uniform_image_f32_1d_0001 = OpVariable %ptr_image_f32_1d_0001 UniformConstant %type_sampled_image_f32_1d_0001 = OpTypeSampledImage %type_image_f32_1d_0001 %type_image_f32_1d_0002_rgba32f = OpTypeImage %f32 1D 0 0 0 2 Rgba32f %ptr_image_f32_1d_0002_rgba32f = OpTypePointer UniformConstant %type_image_f32_1d_0002_rgba32f %uniform_image_f32_1d_0002_rgba32f = OpVariable %ptr_image_f32_1d_0002_rgba32f UniformConstant %type_image_f32_2d_0001 = OpTypeImage %f32 2D 0 0 0 1 Unknown %ptr_image_f32_2d_0001 = OpTypePointer UniformConstant %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 = OpVariable %ptr_image_f32_2d_0001 UniformConstant %type_sampled_image_f32_2d_0001 = OpTypeSampledImage %type_image_f32_2d_0001 %type_image_f32_2d_0011 = OpTypeImage %f32 2D 0 0 1 1 Unknown %ptr_image_f32_2d_0011 = OpTypePointer UniformConstant %type_image_f32_2d_0011 %uniform_image_f32_2d_0011 = OpVariable %ptr_image_f32_2d_0011 UniformConstant %type_sampled_image_f32_2d_0011 = OpTypeSampledImage %type_image_f32_2d_0011 %type_image_u32_2d_0001 = OpTypeImage %u32 2D 0 0 0 1 Unknown %ptr_image_u32_2d_0001 = OpTypePointer UniformConstant %type_image_u32_2d_0001 %uniform_image_u32_2d_0001 = OpVariable %ptr_image_u32_2d_0001 UniformConstant %type_sampled_image_u32_2d_0001 = OpTypeSampledImage %type_image_u32_2d_0001 %type_image_u32_3d_0001 = OpTypeImage %u32 3D 0 0 0 1 Unknown %ptr_image_u32_3d_0001 = OpTypePointer UniformConstant %type_image_u32_3d_0001 %uniform_image_u32_3d_0001 = OpVariable %ptr_image_u32_3d_0001 UniformConstant %type_sampled_image_u32_3d_0001 = OpTypeSampledImage %type_image_u32_3d_0001 %type_image_u32_2d_0002 = OpTypeImage %u32 2D 0 0 0 2 Unknown %ptr_image_u32_2d_0002 = OpTypePointer UniformConstant %type_image_u32_2d_0002 %uniform_image_u32_2d_0002 = OpVariable %ptr_image_u32_2d_0002 UniformConstant %type_image_s32_3d_0001 = OpTypeImage %s32 3D 0 0 0 1 Unknown %ptr_image_s32_3d_0001 = OpTypePointer UniformConstant %type_image_s32_3d_0001 %uniform_image_s32_3d_0001 = OpVariable %ptr_image_s32_3d_0001 UniformConstant %type_sampled_image_s32_3d_0001 = OpTypeSampledImage %type_image_s32_3d_0001 %type_image_f32_2d_0002 = OpTypeImage %f32 2D 0 0 0 2 Unknown %ptr_image_f32_2d_0002 = OpTypePointer UniformConstant %type_image_f32_2d_0002 %uniform_image_f32_2d_0002 = OpVariable %ptr_image_f32_2d_0002 UniformConstant %type_image_s32_2d_0002 = OpTypeImage %s32 2D 0 0 0 2 Unknown %ptr_image_s32_2d_0002 = OpTypePointer UniformConstant %type_image_s32_2d_0002 %uniform_image_s32_2d_0002 = OpVariable %ptr_image_s32_2d_0002 UniformConstant %type_image_f32_spd_0002 = OpTypeImage %f32 SubpassData 0 0 0 2 Unknown %ptr_image_f32_spd_0002 = OpTypePointer UniformConstant %type_image_f32_spd_0002 %uniform_image_f32_spd_0002 = OpVariable %ptr_image_f32_spd_0002 UniformConstant %type_image_f32_3d_0111 = OpTypeImage %f32 3D 0 1 1 1 Unknown %ptr_image_f32_3d_0111 = OpTypePointer UniformConstant %type_image_f32_3d_0111 %uniform_image_f32_3d_0111 = OpVariable %ptr_image_f32_3d_0111 UniformConstant %type_sampled_image_f32_3d_0111 = OpTypeSampledImage %type_image_f32_3d_0111 %type_image_f32_3d_0001 = OpTypeImage %f32 3D 0 0 0 1 Unknown %ptr_image_f32_3d_0001 = OpTypePointer UniformConstant %type_image_f32_3d_0001 %uniform_image_f32_3d_0001 = OpVariable %ptr_image_f32_3d_0001 UniformConstant %type_sampled_image_f32_3d_0001 = OpTypeSampledImage %type_image_f32_3d_0001 %type_image_f32_cube_0101 = OpTypeImage %f32 Cube 0 1 0 1 Unknown %ptr_image_f32_cube_0101 = OpTypePointer UniformConstant %type_image_f32_cube_0101 %uniform_image_f32_cube_0101 = OpVariable %ptr_image_f32_cube_0101 UniformConstant %type_sampled_image_f32_cube_0101 = OpTypeSampledImage %type_image_f32_cube_0101 %type_image_f32_cube_0102_rgba32f = OpTypeImage %f32 Cube 0 1 0 2 Rgba32f %ptr_image_f32_cube_0102_rgba32f = OpTypePointer UniformConstant %type_image_f32_cube_0102_rgba32f %uniform_image_f32_cube_0102_rgba32f = OpVariable %ptr_image_f32_cube_0102_rgba32f UniformConstant %type_sampler = OpTypeSampler %ptr_sampler = OpTypePointer UniformConstant %type_sampler %uniform_sampler = OpVariable %ptr_sampler UniformConstant %type_image_u32_buffer_0002_r32ui = OpTypeImage %u32 Buffer 0 0 0 2 R32ui %ptr_Image_u32 = OpTypePointer Image %u32 %ptr_image_u32_buffer_0002_r32ui = OpTypePointer Private %type_image_u32_buffer_0002_r32ui %private_image_u32_buffer_0002_r32ui = OpVariable %ptr_image_u32_buffer_0002_r32ui Private %ptr_Image_u32arr4 = OpTypePointer Image %u32arr4 %type_image_u32_spd_0002 = OpTypeImage %u32 SubpassData 0 0 0 2 Unknown %ptr_image_u32_spd_0002 = OpTypePointer Private %type_image_u32_spd_0002 %private_image_u32_spd_0002 = OpVariable %ptr_image_u32_spd_0002 Private %type_image_f32_buffer_0002_r32ui = OpTypeImage %f32 Buffer 0 0 0 2 R32ui %ptr_Image_f32 = OpTypePointer Image %f32 %ptr_image_f32_buffer_0002_r32ui = OpTypePointer Private %type_image_f32_buffer_0002_r32ui %private_image_f32_buffer_0002_r32ui = OpVariable %ptr_image_f32_buffer_0002_r32ui Private %ptr_input_flat_u32 = OpTypePointer Input %u32 %input_flat_u32 = OpVariable %ptr_input_flat_u32 Input )"; if (env == SPV_ENV_UNIVERSAL_1_0) { ss << R"( %type_image_void_2d_0001 = OpTypeImage %void 2D 0 0 0 1 Unknown %ptr_image_void_2d_0001 = OpTypePointer UniformConstant %type_image_void_2d_0001 %uniform_image_void_2d_0001 = OpVariable %ptr_image_void_2d_0001 UniformConstant %type_sampled_image_void_2d_0001 = OpTypeSampledImage %type_image_void_2d_0001 %type_image_void_2d_0002 = OpTypeImage %void 2D 0 0 0 2 Unknown %ptr_image_void_2d_0002 = OpTypePointer UniformConstant %type_image_void_2d_0002 %uniform_image_void_2d_0002 = OpVariable %ptr_image_void_2d_0002 UniformConstant %type_image_f32_rect_0001 = OpTypeImage %f32 Rect 0 0 0 1 Unknown %ptr_image_f32_rect_0001 = OpTypePointer UniformConstant %type_image_f32_rect_0001 %uniform_image_f32_rect_0001 = OpVariable %ptr_image_f32_rect_0001 UniformConstant %type_sampled_image_f32_rect_0001 = OpTypeSampledImage %type_image_f32_rect_0001 )"; } ss << declarations; ss << R"( %main = OpFunction %void None %func %main_entry = OpLabel )"; ss << body; ss << R"( OpReturn OpFunctionEnd)"; return ss.str(); } std::string GenerateKernelCode( const std::string& body, const std::string& capabilities_and_extensions = "", const std::string& declarations = "") { std::ostringstream ss; ss << R"( OpCapability Addresses OpCapability Kernel OpCapability Linkage OpCapability ImageQuery OpCapability ImageGatherExtended OpCapability InputAttachment OpCapability SampledRect )"; ss << capabilities_and_extensions; ss << R"( OpMemoryModel Physical32 OpenCL %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f32 = OpTypeFloat 32 %u32 = OpTypeInt 32 0 %u32vec2 = OpTypeVector %u32 2 %f32vec2 = OpTypeVector %f32 2 %u32vec3 = OpTypeVector %u32 3 %f32vec3 = OpTypeVector %f32 3 %u32vec4 = OpTypeVector %u32 4 %f32vec4 = OpTypeVector %f32 4 %f32_0 = OpConstant %f32 0 %f32_1 = OpConstant %f32 1 %f32_0_5 = OpConstant %f32 0.5 %f32_0_25 = OpConstant %f32 0.25 %f32_0_75 = OpConstant %f32 0.75 %u32_0 = OpConstant %u32 0 %u32_1 = OpConstant %u32 1 %u32_2 = OpConstant %u32 2 %u32_3 = OpConstant %u32 3 %u32_4 = OpConstant %u32 4 %u32vec2_01 = OpConstantComposite %u32vec2 %u32_0 %u32_1 %u32vec2_12 = OpConstantComposite %u32vec2 %u32_1 %u32_2 %u32vec3_012 = OpConstantComposite %u32vec3 %u32_0 %u32_1 %u32_2 %u32vec3_123 = OpConstantComposite %u32vec3 %u32_1 %u32_2 %u32_3 %u32vec4_0123 = OpConstantComposite %u32vec4 %u32_0 %u32_1 %u32_2 %u32_3 %u32vec4_1234 = OpConstantComposite %u32vec4 %u32_1 %u32_2 %u32_3 %u32_4 %f32vec2_00 = OpConstantComposite %f32vec2 %f32_0 %f32_0 %f32vec2_01 = OpConstantComposite %f32vec2 %f32_0 %f32_1 %f32vec2_10 = OpConstantComposite %f32vec2 %f32_1 %f32_0 %f32vec2_11 = OpConstantComposite %f32vec2 %f32_1 %f32_1 %f32vec2_hh = OpConstantComposite %f32vec2 %f32_0_5 %f32_0_5 %f32vec3_000 = OpConstantComposite %f32vec3 %f32_0 %f32_0 %f32_0 %f32vec3_hhh = OpConstantComposite %f32vec3 %f32_0_5 %f32_0_5 %f32_0_5 %f32vec4_0000 = OpConstantComposite %f32vec4 %f32_0 %f32_0 %f32_0 %f32_0 %type_image_f32_2d_0001 = OpTypeImage %f32 2D 0 0 0 1 Unknown %ptr_image_f32_2d_0001 = OpTypePointer UniformConstant %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 = OpVariable %ptr_image_f32_2d_0001 UniformConstant %type_sampled_image_f32_2d_0001 = OpTypeSampledImage %type_image_f32_2d_0001 %type_image_f32_2d_0011 = OpTypeImage %f32 2D 0 0 1 1 Unknown %ptr_image_f32_2d_0011 = OpTypePointer UniformConstant %type_image_f32_2d_0011 %uniform_image_f32_2d_0011 = OpVariable %ptr_image_f32_2d_0011 UniformConstant %type_sampled_image_f32_2d_0011 = OpTypeSampledImage %type_image_f32_2d_0011 %type_image_f32_3d_0011 = OpTypeImage %f32 3D 0 0 1 1 Unknown %ptr_image_f32_3d_0011 = OpTypePointer UniformConstant %type_image_f32_3d_0011 %uniform_image_f32_3d_0011 = OpVariable %ptr_image_f32_3d_0011 UniformConstant %type_sampled_image_f32_3d_0011 = OpTypeSampledImage %type_image_f32_3d_0011 %type_image_f32_rect_0001 = OpTypeImage %f32 Rect 0 0 0 1 Unknown %ptr_image_f32_rect_0001 = OpTypePointer UniformConstant %type_image_f32_rect_0001 %uniform_image_f32_rect_0001 = OpVariable %ptr_image_f32_rect_0001 UniformConstant %type_sampled_image_f32_rect_0001 = OpTypeSampledImage %type_image_f32_rect_0001 %type_sampler = OpTypeSampler %ptr_sampler = OpTypePointer UniformConstant %type_sampler %uniform_sampler = OpVariable %ptr_sampler UniformConstant )"; ss << declarations; ss << R"( %main = OpFunction %void None %func %main_entry = OpLabel )"; ss << body; ss << R"( OpReturn OpFunctionEnd)"; return ss.str(); } std::string GetKernelHeader() { return R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Physical32 OpenCL %void = OpTypeVoid %func = OpTypeFunction %void %f32 = OpTypeFloat 32 %u32 = OpTypeInt 32 0 )"; } std::string TrivialMain() { return R"( %main = OpFunction %void None %func %entry = OpLabel OpReturn OpFunctionEnd )"; } std::string GetShaderHeader(const std::string& capabilities_and_extensions = "", bool include_entry_point = true) { std::ostringstream ss; ss << R"( OpCapability Shader OpCapability Int64 OpCapability Float64 )"; if (!include_entry_point) { ss << "OpCapability Linkage\n"; } ss << capabilities_and_extensions; ss << R"( OpMemoryModel Logical GLSL450 )"; if (include_entry_point) { ss << "OpEntryPoint Fragment %main \"main\"\n"; ss << "OpExecutionMode %main OriginUpperLeft"; } ss << R"( %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f32 = OpTypeFloat 32 %f64 = OpTypeFloat 64 %u32 = OpTypeInt 32 0 %u64 = OpTypeInt 64 0 %s32 = OpTypeInt 32 1 %s64 = OpTypeInt 64 1 )"; return ss.str(); } TEST_F(ValidateImage, TypeImageWrongSampledType) { const std::string code = GetShaderHeader("", false) + R"( %img_type = OpTypeImage %bool 2D 0 0 0 1 Unknown )"; CompileSuccessfully(code.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Sampled Type to be either void or " "numerical scalar " "type")); } TEST_F(ValidateImage, TypeImageVoidSampledTypeVulkan) { const std::string code = GetShaderHeader() + R"( %img_type = OpTypeImage %void 2D 0 0 0 1 Unknown %main = OpFunction %void None %func %main_lab = OpLabel OpReturn OpFunctionEnd )"; const spv_target_env env = SPV_ENV_VULKAN_1_0; CompileSuccessfully(code, env); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(env)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpTypeImage-04656")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Sampled Type to be a 32-bit int, 64-bit int " "or 32-bit float scalar type for Vulkan environment")); } TEST_F(ValidateImage, TypeImageU32SampledTypeVulkan) { const std::string code = GetShaderHeader() + R"( %img_type = OpTypeImage %u32 2D 0 0 0 1 Unknown %main = OpFunction %void None %func %main_lab = OpLabel OpReturn OpFunctionEnd )"; const spv_target_env env = SPV_ENV_VULKAN_1_0; CompileSuccessfully(code, env); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(env)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateImage, TypeImageI32SampledTypeVulkan) { const std::string code = GetShaderHeader() + R"( %img_type = OpTypeImage %s32 2D 0 0 0 1 Unknown %main = OpFunction %void None %func %main_lab = OpLabel OpReturn OpFunctionEnd )"; const spv_target_env env = SPV_ENV_VULKAN_1_0; CompileSuccessfully(code, env); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(env)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateImage, TypeImageI64SampledTypeNoCapabilityVulkan) { const std::string code = GetShaderHeader() + R"( %img_type = OpTypeImage %s64 2D 0 0 0 1 Unknown %main = OpFunction %void None %func %main_lab = OpLabel OpReturn OpFunctionEnd )"; const spv_target_env env = SPV_ENV_VULKAN_1_0; CompileSuccessfully(code, env); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(env)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Capability Int64ImageEXT is required when using " "Sampled Type of 64-bit int")); } TEST_F(ValidateImage, TypeImageI64SampledTypeVulkan) { const std::string code = GetShaderHeader( "OpCapability Int64ImageEXT\nOpExtension " "\"SPV_EXT_shader_image_int64\"\n") + R"( %img_type = OpTypeImage %s64 2D 0 0 0 1 Unknown %main = OpFunction %void None %func %main_lab = OpLabel OpReturn OpFunctionEnd )"; const spv_target_env env = SPV_ENV_VULKAN_1_0; CompileSuccessfully(code, env); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(env)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateImage, TypeImageU64SampledTypeNoCapabilityVulkan) { const std::string code = GetShaderHeader() + R"( %img_type = OpTypeImage %u64 2D 0 0 0 1 Unknown %main = OpFunction %void None %func %main_lab = OpLabel OpReturn OpFunctionEnd )"; const spv_target_env env = SPV_ENV_VULKAN_1_0; CompileSuccessfully(code, env); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(env)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Capability Int64ImageEXT is required when using " "Sampled Type of 64-bit int")); } TEST_F(ValidateImage, TypeImageU64SampledTypeVulkan) { const std::string code = GetShaderHeader( "OpCapability Int64ImageEXT\nOpExtension " "\"SPV_EXT_shader_image_int64\"\n") + R"( %img_type = OpTypeImage %u64 2D 0 0 0 1 Unknown %main = OpFunction %void None %func %main_lab = OpLabel OpReturn OpFunctionEnd )"; const spv_target_env env = SPV_ENV_VULKAN_1_0; CompileSuccessfully(code, env); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(env)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateImage, TypeImageF32SampledTypeVulkan) { const std::string code = GetShaderHeader() + R"( %img_type = OpTypeImage %f32 2D 0 0 0 1 Unknown %main = OpFunction %void None %func %main_lab = OpLabel OpReturn OpFunctionEnd )"; const spv_target_env env = SPV_ENV_VULKAN_1_0; CompileSuccessfully(code, env); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(env)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateImage, TypeImageF64SampledTypeVulkan) { const std::string code = GetShaderHeader() + R"( %img_type = OpTypeImage %f64 2D 0 0 0 1 Unknown %main = OpFunction %void None %func %main_lab = OpLabel OpReturn OpFunctionEnd )"; const spv_target_env env = SPV_ENV_VULKAN_1_0; CompileSuccessfully(code, env); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(env)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpTypeImage-04656")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Sampled Type to be a 32-bit int, 64-bit int " "or 32-bit float scalar type for Vulkan environment")); } TEST_F(ValidateImage, TypeImageF64SampledTypeWithInt64Vulkan) { const std::string code = GetShaderHeader( "OpCapability Int64ImageEXT\nOpExtension " "\"SPV_EXT_shader_image_int64\"\n") + R"( %img_type = OpTypeImage %f64 2D 0 0 0 1 Unknown %main = OpFunction %void None %func %main_lab = OpLabel OpReturn OpFunctionEnd )"; const spv_target_env env = SPV_ENV_VULKAN_1_0; CompileSuccessfully(code, env); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(env)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpTypeImage-04656")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Sampled Type to be a 32-bit int, 64-bit int " "or 32-bit float scalar type for Vulkan environment")); } TEST_F(ValidateImage, TypeImageWrongDepth) { const std::string code = GetShaderHeader("", false) + R"( %img_type = OpTypeImage %f32 2D 3 0 0 1 Unknown )"; CompileSuccessfully(code.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Invalid Depth 3 (must be 0, 1 or 2)")); } TEST_F(ValidateImage, TypeImageWrongArrayed) { const std::string code = GetShaderHeader("", false) + R"( %img_type = OpTypeImage %f32 2D 0 2 0 1 Unknown )"; CompileSuccessfully(code.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Invalid Arrayed 2 (must be 0 or 1)")); } TEST_F(ValidateImage, TypeImageWrongMS) { const std::string code = GetShaderHeader("", false) + R"( %img_type = OpTypeImage %f32 2D 0 0 2 1 Unknown )"; CompileSuccessfully(code.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Invalid MS 2 (must be 0 or 1)")); } TEST_F(ValidateImage, TypeImageWrongSampled) { const std::string code = GetShaderHeader("", false) + R"( %img_type = OpTypeImage %f32 2D 0 0 0 3 Unknown )"; CompileSuccessfully(code.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Invalid Sampled 3 (must be 0, 1 or 2)")); } TEST_F(ValidateImage, TypeImageWrongSampledForSubpassData) { const std::string code = GetShaderHeader("OpCapability InputAttachment\n", false) + R"( %img_type = OpTypeImage %f32 SubpassData 0 0 0 1 Unknown )"; CompileSuccessfully(code.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Dim SubpassData requires Sampled to be 2")); } TEST_F(ValidateImage, TypeImageWrongSampledForSubpassDataVulkan) { const std::string code = GetShaderHeader("OpCapability InputAttachment\n") + R"( %img_type = OpTypeImage %f32 SubpassData 0 0 0 1 Unknown )" + TrivialMain(); CompileSuccessfully(code.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpTypeImage-06214")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Dim SubpassData requires Sampled to be 2")); } TEST_F(ValidateImage, TypeImageWrongArrayForSubpassDataVulkan) { const std::string code = GetShaderHeader("OpCapability InputAttachment\n") + R"( %img_type = OpTypeImage %f32 SubpassData 0 1 0 2 Unknown )" + TrivialMain(); CompileSuccessfully(code.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpTypeImage-06214")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Dim SubpassData requires Arrayed to be 0")); } TEST_F(ValidateImage, TypeImageDimRectVulkan) { const std::string code = GetShaderHeader("OpCapability InputAttachment\n") + R"( %img_type = OpTypeImage %f32 Rect 0 1 0 2 Unknown )" + TrivialMain(); CompileSuccessfully(code.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_CAPABILITY, ValidateInstructions(SPV_ENV_VULKAN_1_0)); // Can't actually hit VUID-StandaloneSpirv-OpTypeImage-09638 EXPECT_THAT( getDiagnosticString(), AnyVUID("TypeImage requires one of these capabilities: SampledRect")); } TEST_F(ValidateImage, TypeImageWrongSampledTypeForTileImageDataEXT) { const std::string code = GetShaderHeader( "OpCapability TileImageColorReadAccessEXT\n" "OpExtension \"SPV_EXT_shader_tile_image\"\n", false) + R"( %img_type = OpTypeImage %void TileImageDataEXT 0 0 0 2 Unknown )"; CompileSuccessfully(code.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Dim TileImageDataEXT requires Sampled Type to be not OpTypeVoid")); } TEST_F(ValidateImage, TypeImageWrongSampledForTileImageDataEXT) { const std::string code = GetShaderHeader( "OpCapability TileImageColorReadAccessEXT\n" "OpExtension \"SPV_EXT_shader_tile_image\"\n", false) + R"( %img_type = OpTypeImage %f32 TileImageDataEXT 0 0 0 1 Unknown )"; CompileSuccessfully(code.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Dim TileImageDataEXT requires Sampled to be 2")); } TEST_F(ValidateImage, TypeImageWrongFormatForTileImageDataEXT) { const std::string code = GetShaderHeader( "OpCapability TileImageColorReadAccessEXT\n" "OpExtension \"SPV_EXT_shader_tile_image\"\n", false) + R"( %img_type = OpTypeImage %f32 TileImageDataEXT 0 0 0 2 Rgba32f )"; CompileSuccessfully(code.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Dim TileImageDataEXT requires format Unknown")); } TEST_F(ValidateImage, TypeImageWrongDepthForTileImageDataEXT) { const std::string code = GetShaderHeader( "OpCapability TileImageColorReadAccessEXT\n" "OpExtension \"SPV_EXT_shader_tile_image\"\n", false) + R"( %img_type = OpTypeImage %f32 TileImageDataEXT 1 0 0 2 Unknown )"; CompileSuccessfully(code.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Dim TileImageDataEXT requires Depth to be 0")); } TEST_F(ValidateImage, TypeImageWrongArrayedForTileImageDataEXT) { const std::string code = GetShaderHeader( "OpCapability TileImageColorReadAccessEXT\n" "OpExtension \"SPV_EXT_shader_tile_image\"\n", false) + R"( %img_type = OpTypeImage %f32 TileImageDataEXT 0 1 0 2 Unknown )"; CompileSuccessfully(code.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Dim TileImageDataEXT requires Arrayed to be 0")); } TEST_F(ValidateImage, TypeSampledImage_TileImageDataEXT_Error) { const std::string code = GetShaderHeader( "OpCapability TileImageColorReadAccessEXT\n" "OpExtension \"SPV_EXT_shader_tile_image\"\n", false) + R"( %img_type = OpTypeImage %f32 TileImageDataEXT 0 0 0 2 Unknown %simg_type = OpTypeSampledImage %img_type )"; CompileSuccessfully(code.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Sampled image type requires an image type with " "\"Sampled\" operand set to 0 or 1")); } TEST_F(ValidateImage, ImageTexelPointerImageDimTileImageDataEXTBad) { const std::string body = R"( %texel_ptr = OpImageTexelPointer %ptr_Image_u32 %tile_image_u32_tid_0002 %u32_0 %u32_0 %sum = OpAtomicIAdd %u32 %texel_ptr %u32_1 %u32_0 %u32_1 )"; const std::string decl = R"( %type_image_u32_tid_0002 = OpTypeImage %u32 TileImageDataEXT 0 0 0 2 Unknown %ptr_image_u32_tid_0002 = OpTypePointer TileImageEXT %type_image_u32_tid_0002 %tile_image_u32_tid_0002 = OpVariable %ptr_image_u32_tid_0002 TileImageEXT )"; const std::string extra = R"( OpCapability TileImageColorReadAccessEXT OpExtension "SPV_EXT_shader_tile_image" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_5, "GLSL450", decl) .c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Image Dim TileImageDataEXT cannot be used with " "OpImageTexelPointer")); } TEST_F(ValidateImage, ReadTileImageDataEXT) { const std::string body = R"( %img = OpLoad %type_image_f32_tid_0002 %uniform_image_f32_tid_0002 %res1 = OpImageRead %f32vec4 %img %u32vec2_01 )"; const std::string decl = R"( %type_image_f32_tid_0002 = OpTypeImage %f32 TileImageDataEXT 0 0 0 2 Unknown %ptr_image_f32_tid_0002 = OpTypePointer UniformConstant %type_image_f32_tid_0002 %uniform_image_f32_tid_0002 = OpVariable %ptr_image_f32_tid_0002 UniformConstant )"; const std::string extra = R"( OpCapability StorageImageReadWithoutFormat OpCapability TileImageColorReadAccessEXT OpExtension "SPV_EXT_shader_tile_image" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_5, "GLSL450", decl) .c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Image Dim TileImageDataEXT cannot be used with ImageRead")); } TEST_F(ValidateImage, WriteTileImageDataEXT) { const std::string body = R"( %img = OpLoad %type_image_f32_tid_0002 %uniform_image_f32_tid_0002 OpImageWrite %img %u32vec2_01 %f32vec4_0000 )"; const std::string decl = R"( %type_image_f32_tid_0002 = OpTypeImage %f32 TileImageDataEXT 0 0 0 2 Unknown %ptr_image_f32_tid_0002 = OpTypePointer UniformConstant %type_image_f32_tid_0002 %uniform_image_f32_tid_0002 = OpVariable %ptr_image_f32_tid_0002 UniformConstant )"; const std::string extra = R"( OpCapability TileImageColorReadAccessEXT OpExtension "SPV_EXT_shader_tile_image" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_5, "GLSL450", decl) .c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Image 'Dim' cannot be TileImageDataEXT")); } TEST_F(ValidateImage, QueryFormatTileImageDataEXT) { const std::string body = R"( %img = OpLoad %type_image_f32_tid_0002 %uniform_image_f32_tid_0002 %res1 = OpImageQueryFormat %u32 %img )"; const std::string decl = R"( %type_image_f32_tid_0002 = OpTypeImage %f32 TileImageDataEXT 0 0 0 2 Unknown %ptr_image_f32_tid_0002 = OpTypePointer UniformConstant %type_image_f32_tid_0002 %uniform_image_f32_tid_0002 = OpVariable %ptr_image_f32_tid_0002 UniformConstant )"; const std::string extra = R"( OpCapability TileImageColorReadAccessEXT OpExtension "SPV_EXT_shader_tile_image" )"; CompileSuccessfully(GenerateKernelCode(body, extra, decl).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Image 'Dim' cannot be TileImageDataEXT")); } TEST_F(ValidateImage, QueryOrderTileImageDataEXT) { const std::string body = R"( %img = OpLoad %type_image_f32_tid_0002 %uniform_image_f32_tid_0002 %res1 = OpImageQueryOrder %u32 %img )"; const std::string decl = R"( %type_image_f32_tid_0002 = OpTypeImage %f32 TileImageDataEXT 0 0 0 2 Unknown %ptr_image_f32_tid_0002 = OpTypePointer UniformConstant %type_image_f32_tid_0002 %uniform_image_f32_tid_0002 = OpVariable %ptr_image_f32_tid_0002 UniformConstant )"; const std::string extra = R"( OpCapability TileImageColorReadAccessEXT OpExtension "SPV_EXT_shader_tile_image" )"; CompileSuccessfully(GenerateKernelCode(body, extra, decl).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Image 'Dim' cannot be TileImageDataEXT")); } TEST_F(ValidateImage, SparseFetchTileImageDataEXT) { const std::string body = R"( %img = OpLoad %type_image_f32_tid_0002 %uniform_image_f32_tid_0002 %res1 = OpImageSparseFetch %struct_u32_f32vec4 %img %u32vec2_01 )"; const std::string decl = R"( %type_image_f32_tid_0002 = OpTypeImage %f32 TileImageDataEXT 0 0 0 2 Unknown %ptr_image_f32_tid_0002 = OpTypePointer UniformConstant %type_image_f32_tid_0002 %uniform_image_f32_tid_0002 = OpVariable %ptr_image_f32_tid_0002 UniformConstant )"; const std::string extra = R"( OpCapability StorageImageReadWithoutFormat OpCapability TileImageColorReadAccessEXT OpExtension "SPV_EXT_shader_tile_image" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_5, "GLSL450", decl) .c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Image 'Sampled' parameter to be 1")); } TEST_F(ValidateImage, SparseReadTileImageDataEXT) { const std::string body = R"( %img = OpLoad %type_image_f32_tid_0002 %uniform_image_f32_tid_0002 %res1 = OpImageSparseRead %struct_u32_f32vec4 %img %u32vec2_01 )"; const std::string decl = R"( %type_image_f32_tid_0002 = OpTypeImage %f32 TileImageDataEXT 0 0 0 2 Unknown %ptr_image_f32_tid_0002 = OpTypePointer UniformConstant %type_image_f32_tid_0002 %uniform_image_f32_tid_0002 = OpVariable %ptr_image_f32_tid_0002 UniformConstant )"; const std::string extra = R"( OpCapability StorageImageReadWithoutFormat OpCapability TileImageColorReadAccessEXT OpExtension "SPV_EXT_shader_tile_image" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_5, "GLSL450", decl) .c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Image Dim TileImageDataEXT cannot be used with ImageSparseRead")); } TEST_F(ValidateImage, TypeImage_OpenCL_Sampled0_OK) { const std::string code = GetKernelHeader() + R"( %img_type = OpTypeImage %void 2D 0 0 0 0 Unknown ReadOnly )"; CompileSuccessfully(code.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_OPENCL_2_1)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateImage, TypeImage_OpenCL_Sampled1_Invalid) { const std::string code = GetKernelHeader() + R"( %img_type = OpTypeImage %void 2D 0 0 0 1 Unknown ReadOnly )"; CompileSuccessfully(code.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_OPENCL_2_1)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Sampled must be 0 in the OpenCL environment.")); } TEST_F(ValidateImage, TypeImage_OpenCL_Sampled2_Invalid) { const std::string code = GetKernelHeader() + R"( %img_type = OpTypeImage %void 2D 0 0 0 2 Unknown ReadOnly )"; CompileSuccessfully(code.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_OPENCL_2_1)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Sampled must be 0 in the OpenCL environment.")); } TEST_F(ValidateImage, TypeImage_OpenCL_AccessQualifierMissing) { const std::string code = GetKernelHeader() + R"( %img_type = OpTypeImage %void 2D 0 0 0 0 Unknown )"; CompileSuccessfully(code.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_OPENCL_2_1)); EXPECT_THAT(getDiagnosticString(), HasSubstr("In the OpenCL environment, the optional Access " "Qualifier must be present")); } TEST_F(ValidateImage, TypeImage_Vulkan_Sampled1_OK) { const std::string code = GetShaderHeader() + R"( %img_type = OpTypeImage %f32 2D 0 0 0 1 Unknown )" + TrivialMain(); CompileSuccessfully(code.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateImage, TypeImage_Vulkan_Sampled2_OK) { const std::string code = GetShaderHeader() + R"( %img_type = OpTypeImage %f32 2D 0 0 0 2 Rgba32f )" + TrivialMain(); CompileSuccessfully(code.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateImage, TypeImage_Vulkan_Sampled0_Invalid) { const std::string code = GetShaderHeader() + R"( %img_type = OpTypeImage %f32 2D 0 0 0 0 Unknown )" + TrivialMain(); CompileSuccessfully(code.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpTypeImage-04657")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Sampled must be 1 or 2 in the Vulkan environment.")); } TEST_F(ValidateImage, TypeImageWrongFormatForSubpassData) { const std::string code = GetShaderHeader("OpCapability InputAttachment\n", false) + R"( %img_type = OpTypeImage %f32 SubpassData 0 0 0 2 Rgba32f )"; CompileSuccessfully(code.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Dim SubpassData requires format Unknown")); } TEST_F(ValidateImage, TypeImageMultisampleStorageImage_MissingCapability) { const std::string code = GetShaderHeader("", false) + R"( %img_type = OpTypeImage %f32 2D 0 0 1 2 Rgba32f )"; CompileSuccessfully(code.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()) << code; EXPECT_THAT(getDiagnosticString(), HasSubstr("Capability StorageImageMultisample is required when " "using multisampled storage image")); } TEST_F(ValidateImage, TypeImageMultisampleStorageImage_UsesCapability) { const std::string code = GetShaderHeader("OpCapability StorageImageMultisample\n", false) + R"( %img_type = OpTypeImage %f32 2D 0 0 1 2 Rgba32f )"; CompileSuccessfully(code.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()) << code; EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateImage, TypeImageMultisampleSubpassData_OK) { const std::string code = GetShaderHeader("OpCapability InputAttachment\n", false) + R"( %img_type = OpTypeImage %f32 SubpassData 0 0 1 2 Unknown )"; CompileSuccessfully(code.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()) << code; EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateImage, TypeSampledImage_NotImage_Error) { const std::string code = GetShaderHeader("", false) + R"( %simg_type = OpTypeSampledImage %f32 )"; CompileSuccessfully(code.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Image to be of type OpTypeImage")); } TEST_F(ValidateImage, TypeSampledImage_Sampled0_Success) { // This is ok in the OpenCL and universal environments. // Vulkan will reject an OpTypeImage with Sampled=0, checked elsewhere. const std::string code = GetShaderHeader() + R"( %imty = OpTypeImage %f32 2D 0 0 0 0 Unknown %simg_type = OpTypeSampledImage %imty )" + TrivialMain(); CompileSuccessfully(code.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); EXPECT_EQ(getDiagnosticString(), ""); } TEST_F(ValidateImage, TypeSampledImage_Sampled2_Error) { const std::string code = GetShaderHeader() + R"( %storage_image = OpTypeImage %f32 2D 0 0 0 2 Rgba32f %simg_type = OpTypeSampledImage %storage_image )" + TrivialMain(); CompileSuccessfully(code.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Sampled image type requires an image type with " "\"Sampled\" operand set to 0 or 1")); } TEST_F(ValidateImage, TypeSampledImage_Sampled1_Success) { const std::string code = GetShaderHeader() + R"( %im = OpTypeImage %f32 2D 0 0 0 1 Unknown %simg_type = OpTypeSampledImage %im )" + TrivialMain(); CompileSuccessfully(code.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); EXPECT_EQ(getDiagnosticString(), ""); } TEST_F(ValidateImage, SampledImageSuccess) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, SampledImageVulkanSuccess) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler )"; const spv_target_env env = SPV_ENV_VULKAN_1_0; CompileSuccessfully(GenerateShaderCode(body, "", "Fragment", "", env), env); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(env)); } TEST_F(ValidateImage, SampledImageWrongResultType) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_image_f32_2d_0001 %img %sampler )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be OpTypeSampledImage")); } TEST_F(ValidateImage, SampledImageNotImage) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg1 = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %simg2 = OpSampledImage %type_sampled_image_f32_2d_0001 %simg1 %sampler )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Image to be of type OpTypeImage")); } TEST_F(ValidateImage, SampledImageImageNotForSampling) { const std::string code = GetShaderHeader() + R"( %im_ty = OpTypeImage %f32 2D 0 0 0 2 Unknown %sampler_ty = OpTypeSampler %sampled_image_ty = OpTypeSampledImage %im_ty ; will fail here first! %ptr_im_ty = OpTypePointer UniformConstant %im_ty %var_im = OpVariable %ptr_im_ty UniformConstant %ptr_sampler_ty = OpTypePointer UniformConstant %sampler_ty %var_sampler = OpVariable %ptr_sampler_ty UniformConstant %main = OpFunction %void None %func %entry = OpLabel %im = OpLoad %im_ty %var_im %sampler = OpLoad %sampler_ty %var_sampler %sampled_image = OpSampledImage %sampled_image_ty %im %sampler OpReturn OpFunctionEnd )"; CompileSuccessfully(code.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Sampled image type requires an image type with " "\"Sampled\" operand set to 0 or 1")) << code; } TEST_F(ValidateImage, SampledImageNotSampler) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %img )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Sampler to be of type OpTypeSampler")); } TEST_F(ValidateImage, SampledImageIsStorage) { const std::string declarations = R"( %type_sampled_image_f32_2d_0002 = OpTypeSampledImage %type_image_f32_2d_0002 )"; const std::string body = R"( %img = OpLoad %type_image_f32_2d_0002 %uniform_image_f32_2d_0002 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0002 %img %sampler )"; CompileSuccessfully(GenerateShaderCode(body, "", "Fragment", "", SPV_ENV_UNIVERSAL_1_0, "GLSL450", declarations) .c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Sampled image type requires an image type with " "\"Sampled\" operand set to 0 or 1")); } TEST_F(ValidateImage, ImageTexelPointerSuccess) { const std::string body = R"( %texel_ptr = OpImageTexelPointer %ptr_Image_u32 %private_image_u32_buffer_0002_r32ui %u32_0 %u32_0 %sum = OpAtomicIAdd %u32 %texel_ptr %u32_1 %u32_0 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, ImageTexelPointerResultTypeNotPointer) { const std::string body = R"( %texel_ptr = OpImageTexelPointer %type_image_u32_buffer_0002_r32ui %private_image_u32_buffer_0002_r32ui %u32_0 %u32_0 %sum = OpAtomicIAdd %u32 %texel_ptr %u32_1 %u32_0 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be a pointer")); } TEST_F(ValidateImage, ImageTexelPointerResultTypeNotImageClass) { const std::string body = R"( %texel_ptr = OpImageTexelPointer %ptr_image_f32_cube_0101 %private_image_u32_buffer_0002_r32ui %u32_0 %u32_0 %sum = OpAtomicIAdd %u32 %texel_ptr %u32_1 %u32_0 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be a pointer whose " "Storage Class operand is Image")); } TEST_F(ValidateImage, ImageTexelPointerResultTypeNotNumericNorVoid) { const std::string body = R"( %texel_ptr = OpImageTexelPointer %ptr_Image_u32arr4 %private_image_u32_buffer_0002_r32ui %u32_0 %u32_0 %sum = OpAtomicIAdd %u32 %texel_ptr %u32_1 %u32_0 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Result Type to be a pointer whose Type operand " "must be a scalar numerical type or OpTypeVoid")); } TEST_F(ValidateImage, ImageTexelPointerImageNotResultTypePointer) { const std::string body = R"( %texel_ptr = OpImageTexelPointer %ptr_Image_u32 %type_image_f32_buffer_0002_r32ui %u32_0 %u32_0 %sum = OpAtomicIAdd %u32 %texel_ptr %u32_1 %u32_0 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Operand '148[%148]' cannot be a " "type")); } TEST_F(ValidateImage, ImageTexelPointerImageNotImage) { const std::string body = R"( %texel_ptr = OpImageTexelPointer %ptr_Image_u32 %uniform_sampler %u32_0 %u32_0 %sum = OpAtomicIAdd %u32 %texel_ptr %u32_1 %u32_0 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Image to be OpTypePointer with Type OpTypeImage")); } TEST_F(ValidateImage, ImageTexelPointerImageSampledNotResultType) { const std::string body = R"( %texel_ptr = OpImageTexelPointer %ptr_Image_u32 %uniform_image_f32_cube_0101 %u32_0 %u32_0 %sum = OpAtomicIAdd %u32 %texel_ptr %u32_1 %u32_0 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Image 'Sampled Type' to be the same as the " "Type pointed to by Result Type")); } TEST_F(ValidateImage, ImageTexelPointerImageDimSubpassDataBad) { const std::string body = R"( %texel_ptr = OpImageTexelPointer %ptr_Image_u32 %private_image_u32_spd_0002 %u32_0 %u32_0 %sum = OpAtomicIAdd %u32 %texel_ptr %u32_1 %u32_0 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Image Dim SubpassData cannot be used with OpImageTexelPointer")); } TEST_F(ValidateImage, ImageTexelPointerImageCoordTypeBad) { const std::string body = R"( %texel_ptr = OpImageTexelPointer %ptr_Image_f32 %private_image_f32_buffer_0002_r32ui %f32_0 %f32_0 %sum = OpAtomicIAdd %f32 %texel_ptr %f32_1 %f32_0 %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Coordinate to be integer scalar or vector")); } TEST_F(ValidateImage, ImageTexelPointerImageCoordSizeBad) { const std::string body = R"( %texel_ptr = OpImageTexelPointer %ptr_Image_u32 %uniform_image_u32_2d_0002 %u32vec3_012 %u32_0 %sum = OpAtomicIAdd %u32 %texel_ptr %u32_1 %u32_0 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Coordinate to have 2 components, but given 3")); } TEST_F(ValidateImage, ImageTexelPointerSampleNotIntScalar) { const std::string body = R"( %texel_ptr = OpImageTexelPointer %ptr_Image_u32 %private_image_u32_buffer_0002_r32ui %u32_0 %f32_0 %sum = OpAtomicIAdd %u32 %texel_ptr %u32_1 %u32_0 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Sample to be integer scalar")); } TEST_F(ValidateImage, ImageTexelPointerSampleNotZeroForImageWithMSZero) { const std::string body = R"( %texel_ptr = OpImageTexelPointer %ptr_Image_u32 %private_image_u32_buffer_0002_r32ui %u32_0 %u32_1 %sum = OpAtomicIAdd %u32 %texel_ptr %u32_1 %u32_0 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Sample for Image with MS 0 to be a valid " " for the value 0")); } TEST_F(ValidateImage, SampleImplicitLodSuccess) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_hh %res2 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_hh Bias %f32_0_25 %res4 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_hh ConstOffset %s32vec2_01 %res5 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_hh Offset %s32vec2_01 %res6 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_hh MinLod %f32_0_5 %res7 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_hh Bias|Offset|MinLod %f32_0_25 %s32vec2_01 %f32_0_5 %res8 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_hh NonPrivateTexelKHR )"; const std::string extra = R"( OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_3, "VulkanKHR") .c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateImage, SampleImplicitLodWrongResultType) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleImplicitLod %f32 %simg %f32vec2_hh )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be int or float vector type")); } TEST_F(ValidateImage, SampleImplicitLodWrongNumComponentsResultType) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleImplicitLod %f32vec3 %simg %f32vec2_hh )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to have 4 components")); } TEST_F(ValidateImage, SampleImplicitLodNotSampledImage) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %res1 = OpImageSampleImplicitLod %f32vec4 %img %f32vec2_hh )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Sampled Image to be of type OpTypeSampledImage")); } TEST_F(ValidateImage, SampleImplicitLodMultisampleError) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0011 %uniform_image_f32_2d_0011 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0011 %img %sampler %res1 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec2_hh Sample %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Sampling operation is invalid for multisample image")); } TEST_F(ValidateImage, SampleImplicitLodWrongSampledType) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleImplicitLod %u32vec4 %simg %f32vec2_00 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Image 'Sampled Type' to be the same as " "Result Type components")); } TEST_F(ValidateImage, SampleImplicitLodVoidSampledType) { const std::string body = R"( %img = OpLoad %type_image_void_2d_0001 %uniform_image_void_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_void_2d_0001 %img %sampler %res1 = OpImageSampleImplicitLod %u32vec4 %simg %f32vec2_00 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, SampleImplicitLodWrongCoordinateType) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleImplicitLod %f32vec4 %simg %img )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Coordinate to be float scalar or vector")); } TEST_F(ValidateImage, SampleImplicitLodCoordinateSizeTooSmall) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleImplicitLod %f32vec4 %simg %f32_0_5 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Coordinate to have at least 2 components, " "but given only 1")); } TEST_F(ValidateImage, SampleExplicitLodSuccessShader) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec4_0000 Lod %f32_1 %res2 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec2_hh Grad %f32vec2_10 %f32vec2_01 %res3 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec2_hh ConstOffset %s32vec2_01 %res4 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec3_hhh Offset %s32vec2_01 %res5 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec2_hh Grad|Offset|MinLod %f32vec2_10 %f32vec2_01 %s32vec2_01 %f32_0_5 %res6 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec4_0000 Lod|NonPrivateTexelKHR %f32_1 )"; const std::string extra = R"( OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_3, "VulkanKHR") .c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateImage, SampleExplicitLodSuccessKernel) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleExplicitLod %f32vec4 %simg %u32vec4_0123 Lod %f32_1 %res2 = OpImageSampleExplicitLod %f32vec4 %simg %u32vec2_01 Grad %f32vec2_10 %f32vec2_01 %res3 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec2_hh ConstOffset %u32vec2_01 %res4 = OpImageSampleExplicitLod %f32vec4 %simg %u32vec2_01 Offset %u32vec2_01 %res5 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec2_hh Grad|Offset %f32vec2_10 %f32vec2_01 %u32vec2_01 )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, SampleExplicitLodSuccessCubeArrayed) { const std::string body = R"( %img = OpLoad %type_image_f32_cube_0101 %uniform_image_f32_cube_0101 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_cube_0101 %img %sampler %res1 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec4_0000 Grad %f32vec3_hhh %f32vec3_hhh )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, SampleExplicitLodWrongResultType) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleExplicitLod %f32 %simg %f32vec2_hh Lod %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be int or float vector type")); } TEST_F(ValidateImage, SampleExplicitLodWrongNumComponentsResultType) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleExplicitLod %f32vec3 %simg %f32vec2_hh Lod %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to have 4 components")); } TEST_F(ValidateImage, SampleExplicitLodNotSampledImage) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %res1 = OpImageSampleExplicitLod %f32vec4 %img %f32vec2_hh Lod %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Sampled Image to be of type OpTypeSampledImage")); } TEST_F(ValidateImage, SampleExplicitLodMultisampleError) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0011 %uniform_image_f32_2d_0011 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0011 %img %sampler %res1 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_hh Lod|Sample %f32_0 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Sampling operation is invalid for multisample image")); } TEST_F(ValidateImage, SampleExplicitLodWrongSampledType) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleExplicitLod %u32vec4 %simg %f32vec2_00 Lod %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Image 'Sampled Type' to be the same as " "Result Type components")); } TEST_F(ValidateImage, SampleExplicitLodVoidSampledType) { const std::string body = R"( %img = OpLoad %type_image_void_2d_0001 %uniform_image_void_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_void_2d_0001 %img %sampler %res1 = OpImageSampleExplicitLod %u32vec4 %simg %f32vec2_00 Lod %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, SampleExplicitLodWrongCoordinateType) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleExplicitLod %f32vec4 %simg %img Lod %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Coordinate to be float scalar or vector")); } TEST_F(ValidateImage, SampleExplicitLodCoordinateSizeTooSmall) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleExplicitLod %f32vec4 %simg %f32_0_5 Lod %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Coordinate to have at least 2 components, " "but given only 1")); } TEST_F(ValidateImage, SampleExplicitLodBias) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec2_00 Bias|Lod %f32_1 %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Image Operand Bias can only be used with ImplicitLod opcodes")); } TEST_F(ValidateImage, LodAndGrad) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec2_00 Lod|Grad %f32_1 %f32vec2_hh %f32vec2_hh )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Image Operand bits Lod and Grad cannot be set at the same time")); } TEST_F(ValidateImage, ImplicitLodWithLod) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res2 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_hh Lod %f32_0_5 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Image Operand Lod can only be used with ExplicitLod opcodes " "and OpImageFetch")); } TEST_F(ValidateImage, LodWrongType) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec2_00 Lod %f32vec2_hh)"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Image Operand Lod to be float scalar when " "used with ExplicitLod")); } TEST_F(ValidateImage, LodWrongDim) { const std::string body = R"( %img = OpLoad %type_image_f32_rect_0001 %uniform_image_f32_rect_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_rect_0001 %img %sampler %res1 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec2_00 Lod %f32_0)"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Image Operand Lod requires 'Dim' parameter to be 1D, " "2D, 3D or Cube")); } TEST_F(ValidateImage, MinLodIncompatible) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec2_00 Lod|MinLod %f32_0 %f32_0)"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Image Operand MinLod can only be used with ImplicitLod opcodes or " "together with Image Operand Grad")); } TEST_F(ValidateImage, ImplicitLodWithGrad) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res2 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_hh Grad %f32vec2_hh %f32vec2_hh )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Image Operand Grad can only be used with ExplicitLod opcodes")); } TEST_F(ValidateImage, SampleImplicitLodCubeArrayedSuccess) { const std::string body = R"( %img = OpLoad %type_image_f32_cube_0101 %uniform_image_f32_cube_0101 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_cube_0101 %img %sampler %res1 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec4_0000 %res2 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec4_0000 Bias %f32_0_25 %res4 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec4_0000 MinLod %f32_0_5 %res5 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec4_0000 Bias|MinLod %f32_0_25 %f32_0_5 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, SampleImplicitLodBiasWrongType) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res2 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_hh Bias %u32_0 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Image Operand Bias to be float scalar")); } TEST_F(ValidateImage, SampleImplicitLodBiasWrongDim) { const std::string body = R"( %img = OpLoad %type_image_f32_rect_0001 %uniform_image_f32_rect_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_rect_0001 %img %sampler %res2 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_hh Bias %f32_0 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Image Operand Bias requires 'Dim' parameter to be 1D, " "2D, 3D or Cube")); } TEST_F(ValidateImage, SampleExplicitLodGradDxWrongType) { const std::string body = R"( %img = OpLoad %type_image_f32_cube_0101 %uniform_image_f32_cube_0101 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_cube_0101 %img %sampler %res1 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec4_0000 Grad %s32vec3_012 %f32vec3_hhh )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected both Image Operand Grad ids to be float " "scalars or vectors")); } TEST_F(ValidateImage, SampleExplicitLodGradDyWrongType) { const std::string body = R"( %img = OpLoad %type_image_f32_cube_0101 %uniform_image_f32_cube_0101 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_cube_0101 %img %sampler %res1 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec4_0000 Grad %f32vec3_hhh %s32vec3_012 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected both Image Operand Grad ids to be float " "scalars or vectors")); } TEST_F(ValidateImage, SampleExplicitLodGradDxWrongSize) { const std::string body = R"( %img = OpLoad %type_image_f32_cube_0101 %uniform_image_f32_cube_0101 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_cube_0101 %img %sampler %res1 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec4_0000 Grad %f32vec2_00 %f32vec3_hhh )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected Image Operand Grad dx to have 3 components, but given 2")); } TEST_F(ValidateImage, SampleExplicitLodGradDyWrongSize) { const std::string body = R"( %img = OpLoad %type_image_f32_cube_0101 %uniform_image_f32_cube_0101 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_cube_0101 %img %sampler %res1 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec4_0000 Grad %f32vec3_hhh %f32vec2_00 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected Image Operand Grad dy to have 3 components, but given 2")); } TEST_F(ValidateImage, SampleImplicitLodConstOffsetCubeDim) { const std::string body = R"( %img = OpLoad %type_image_f32_cube_0101 %uniform_image_f32_cube_0101 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_cube_0101 %img %sampler %res4 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec4_0000 ConstOffset %s32vec3_012 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Image Operand ConstOffset cannot be used with Cube Image 'Dim'")); } TEST_F(ValidateImage, SampleImplicitLodConstOffsetWrongType) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res4 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_00 ConstOffset %f32vec2_00 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected Image Operand ConstOffset to be int scalar or vector")); } TEST_F(ValidateImage, SampleImplicitLodConstOffsetWrongSize) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res4 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_00 ConstOffset %s32vec3_012 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Image Operand ConstOffset to have 2 " "components, but given 3")); } TEST_F(ValidateImage, SampleImplicitLodConstOffsetNotConst) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %offset = OpSNegate %s32vec3 %s32vec3_012 %res4 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_00 ConstOffset %offset )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Image Operand ConstOffset to be a const object")); } TEST_F(ValidateImage, SampleImplicitLodOffsetCubeDim) { const std::string body = R"( %img = OpLoad %type_image_f32_cube_0101 %uniform_image_f32_cube_0101 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_cube_0101 %img %sampler %res4 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec4_0000 Offset %s32vec3_012 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Image Operand Offset cannot be used with Cube Image 'Dim'")); } TEST_F(ValidateImage, SampleImplicitLodOffsetWrongType) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res4 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec4_0000 Offset %f32vec2_00 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Image Operand Offset to be int scalar or vector")); } TEST_F(ValidateImage, SampleImplicitLodOffsetWrongSize) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res4 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec4_0000 Offset %s32vec3_012 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected Image Operand Offset to have 2 components, but given 3")); } TEST_F(ValidateImage, SampleImplicitLodVulkanOffsetWrongSize) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res4 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec4_0000 Offset %s32vec2_01 )"; CompileSuccessfully( GenerateShaderCode(body, "", "Fragment", "", SPV_ENV_VULKAN_1_0).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-RuntimeSpirv-Offset-10213")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Image Operand Offset can only be used with " "OpImage*Gather operations")); } TEST_F(ValidateImage, SampleImplicitLodVulkanOffsetMaintenance8) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res4 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec4_0000 Offset %s32vec2_01 )"; CompileSuccessfully( GenerateShaderCode(body, "", "Fragment", "", SPV_ENV_VULKAN_1_0).c_str()); spvValidatorOptionsSetAllowOffsetTextureOperand(getValidatorOptions(), true); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateImage, SampleImplicitLodVulkanOffsetWrongBeforeLegalization) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res4 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec4_0000 Offset %s32vec2_01 )"; CompileSuccessfully( GenerateShaderCode(body, "", "Fragment", "", SPV_ENV_VULKAN_1_0).c_str()); getValidatorOptions()->before_hlsl_legalization = true; ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateImage, SampleImplicitLodMoreThanOneOffset) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res4 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec4_0000 ConstOffset|Offset %s32vec2_01 %s32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Image Operands Offset, ConstOffset, ConstOffsets, Offsets " "cannot be used together")); } TEST_F(ValidateImage, SampleImplicitLodVulkanMoreThanOneOffset) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res4 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec4_0000 ConstOffset|Offset %s32vec2_01 %s32vec2_01 )"; CompileSuccessfully( GenerateShaderCode(body, "", "Fragment", "", SPV_ENV_VULKAN_1_0).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Image Operands Offset, ConstOffset, ConstOffsets, Offsets " "cannot be used together")); } TEST_F(ValidateImage, SampleImplicitLodMinLodWrongType) { const std::string body = R"( %img = OpLoad %type_image_f32_cube_0101 %uniform_image_f32_cube_0101 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_cube_0101 %img %sampler %res1 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec4_0000 MinLod %s32_0 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Image Operand MinLod to be float scalar")); } TEST_F(ValidateImage, SampleImplicitLodMinLodWrongDim) { const std::string body = R"( %img = OpLoad %type_image_f32_rect_0001 %uniform_image_f32_rect_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_rect_0001 %img %sampler %res2 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_hh MinLod %f32_0_25 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Image Operand MinLod requires 'Dim' parameter to be " "1D, 2D, 3D or Cube")); } TEST_F(ValidateImage, SampleProjExplicitLodSuccess2D) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleProjExplicitLod %f32vec4 %simg %f32vec3_hhh Lod %f32_1 %res3 = OpImageSampleProjExplicitLod %f32vec4 %simg %f32vec3_hhh Grad %f32vec2_10 %f32vec2_01 %res4 = OpImageSampleProjExplicitLod %f32vec4 %simg %f32vec3_hhh ConstOffset %s32vec2_01 %res5 = OpImageSampleProjExplicitLod %f32vec4 %simg %f32vec3_hhh Offset %s32vec2_01 %res7 = OpImageSampleProjExplicitLod %f32vec4 %simg %f32vec3_hhh Grad|Offset %f32vec2_10 %f32vec2_01 %s32vec2_01 %res8 = OpImageSampleProjExplicitLod %f32vec4 %simg %f32vec3_hhh Lod|NonPrivateTexelKHR %f32_1 )"; const std::string extra = R"( OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_3, "VulkanKHR") .c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateImage, SampleProjExplicitLodSuccessRect) { const std::string body = R"( %img = OpLoad %type_image_f32_rect_0001 %uniform_image_f32_rect_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_rect_0001 %img %sampler %res1 = OpImageSampleProjExplicitLod %f32vec4 %simg %f32vec3_hhh Grad %f32vec2_10 %f32vec2_01 %res2 = OpImageSampleProjExplicitLod %f32vec4 %simg %f32vec3_hhh Grad|Offset %f32vec2_10 %f32vec2_01 %s32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, SampleProjExplicitLodWrongResultType) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleProjExplicitLod %f32 %simg %f32vec3_hhh Lod %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be int or float vector type")); } TEST_F(ValidateImage, SampleProjExplicitLodWrongNumComponentsResultType) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleProjExplicitLod %f32vec3 %simg %f32vec3_hhh Lod %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to have 4 components")); } TEST_F(ValidateImage, SampleProjExplicitLodNotSampledImage) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %res1 = OpImageSampleProjExplicitLod %f32vec4 %img %f32vec3_hhh Lod %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Sampled Image to be of type OpTypeSampledImage")); } TEST_F(ValidateImage, SampleProjExplicitLodMultisampleError) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0011 %uniform_image_f32_2d_0011 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0011 %img %sampler %res1 = OpImageSampleProjExplicitLod %f32vec4 %simg %f32vec2_hh Lod|Sample %f32_1 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Image 'MS' parameter to be 0")); } TEST_F(ValidateImage, SampleProjExplicitLodWrongSampledType) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleProjExplicitLod %u32vec4 %simg %f32vec3_hhh Lod %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Image 'Sampled Type' to be the same as " "Result Type components")); } TEST_F(ValidateImage, SampleProjExplicitLodVoidSampledType) { const std::string body = R"( %img = OpLoad %type_image_void_2d_0001 %uniform_image_void_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_void_2d_0001 %img %sampler %res1 = OpImageSampleProjExplicitLod %u32vec4 %simg %f32vec3_hhh Lod %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, SampleProjExplicitLodWrongCoordinateType) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleProjExplicitLod %f32vec4 %simg %img Lod %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Coordinate to be float scalar or vector")); } TEST_F(ValidateImage, SampleProjExplicitLodCoordinateSizeTooSmall) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleProjExplicitLod %f32vec4 %simg %f32vec2_hh Lod %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Coordinate to have at least 3 components, " "but given only 2")); } TEST_F(ValidateImage, SampleProjImplicitLodSuccess) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleProjImplicitLod %f32vec4 %simg %f32vec3_hhh %res2 = OpImageSampleProjImplicitLod %f32vec4 %simg %f32vec3_hhh Bias %f32_0_25 %res4 = OpImageSampleProjImplicitLod %f32vec4 %simg %f32vec3_hhh ConstOffset %s32vec2_01 %res5 = OpImageSampleProjImplicitLod %f32vec4 %simg %f32vec3_hhh Offset %s32vec2_01 %res6 = OpImageSampleProjImplicitLod %f32vec4 %simg %f32vec3_hhh MinLod %f32_0_5 %res7 = OpImageSampleProjImplicitLod %f32vec4 %simg %f32vec3_hhh Bias|Offset|MinLod %f32_0_25 %s32vec2_01 %f32_0_5 %res8 = OpImageSampleProjImplicitLod %f32vec4 %simg %f32vec3_hhh NonPrivateTexelKHR )"; const std::string extra = R"( OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_3, "VulkanKHR") .c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateImage, SampleProjImplicitLodWrongResultType) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleProjImplicitLod %f32 %simg %f32vec3_hhh )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be int or float vector type")); } TEST_F(ValidateImage, SampleProjImplicitLodWrongNumComponentsResultType) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleProjImplicitLod %f32vec3 %simg %f32vec3_hhh )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to have 4 components")); } TEST_F(ValidateImage, SampleProjImplicitLodNotSampledImage) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %res1 = OpImageSampleProjImplicitLod %f32vec4 %img %f32vec3_hhh )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Sampled Image to be of type OpTypeSampledImage")); } TEST_F(ValidateImage, SampleProjImplicitLodMultisampleError) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0011 %uniform_image_f32_2d_0011 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0011 %img %sampler %res1 = OpImageSampleProjImplicitLod %f32vec4 %simg %f32vec2_hh Sample %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Image 'MS' parameter to be 0")); } TEST_F(ValidateImage, SampleProjImplicitLodWrongSampledType) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleProjImplicitLod %u32vec4 %simg %f32vec3_hhh )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Image 'Sampled Type' to be the same as " "Result Type components")); } TEST_F(ValidateImage, SampleProjImplicitLodVoidSampledType) { const std::string body = R"( %img = OpLoad %type_image_void_2d_0001 %uniform_image_void_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_void_2d_0001 %img %sampler %res1 = OpImageSampleProjImplicitLod %u32vec4 %simg %f32vec3_hhh )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, SampleProjImplicitLodWrongCoordinateType) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleProjImplicitLod %f32vec4 %simg %img )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Coordinate to be float scalar or vector")); } TEST_F(ValidateImage, SampleProjImplicitLodCoordinateSizeTooSmall) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleProjImplicitLod %f32vec4 %simg %f32vec2_hh )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Coordinate to have at least 3 components, " "but given only 2")); } TEST_F(ValidateImage, SampleDrefImplicitLodSuccess) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0001 %uniform_image_u32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_u32_2d_0001 %img %sampler %res1 = OpImageSampleDrefImplicitLod %u32 %simg %f32vec2_hh %f32_1 %res2 = OpImageSampleDrefImplicitLod %u32 %simg %f32vec2_hh %f32_1 Bias %f32_0_25 %res4 = OpImageSampleDrefImplicitLod %u32 %simg %f32vec2_hh %f32_1 ConstOffset %s32vec2_01 %res5 = OpImageSampleDrefImplicitLod %u32 %simg %f32vec2_hh %f32_1 Offset %s32vec2_01 %res6 = OpImageSampleDrefImplicitLod %u32 %simg %f32vec2_hh %f32_1 MinLod %f32_0_5 %res7 = OpImageSampleDrefImplicitLod %u32 %simg %f32vec2_hh %f32_1 Bias|Offset|MinLod %f32_0_25 %s32vec2_01 %f32_0_5 %res8 = OpImageSampleDrefImplicitLod %u32 %simg %f32vec2_hh %f32_1 NonPrivateTexelKHR )"; const std::string extra = R"( OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_3, "VulkanKHR") .c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateImage, SampleDrefImplicitLodWrongResultType) { const std::string body = R"( %img = OpLoad %type_image_void_2d_0001 %uniform_image_void_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_void_2d_0001 %img %sampler %res1 = OpImageSampleDrefImplicitLod %void %simg %f32vec2_hh %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be int or float scalar type")); } TEST_F(ValidateImage, SampleDrefImplicitLodNotSampledImage) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0001 %uniform_image_u32_2d_0001 %res1 = OpImageSampleDrefImplicitLod %u32 %img %f32vec2_hh %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Sampled Image to be of type OpTypeSampledImage")); } TEST_F(ValidateImage, SampleDrefImplicitLodMultisampleError) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0011 %uniform_image_f32_2d_0011 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0011 %img %sampler %res1 = OpImageSampleDrefImplicitLod %f32 %simg %f32vec2_hh %f32_1 Sample %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Dref sampling operation is invalid for multisample image")); } TEST_F(ValidateImage, SampleDrefImplicitLodWrongSampledType) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0001 %uniform_image_u32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_u32_2d_0001 %img %sampler %res1 = OpImageSampleDrefImplicitLod %f32 %simg %f32vec2_00 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Image 'Sampled Type' to be the same as Result Type")); } TEST_F(ValidateImage, SampleDrefImplicitLodVoidSampledType) { const std::string body = R"( %img = OpLoad %type_image_void_2d_0001 %uniform_image_void_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_void_2d_0001 %img %sampler %res1 = OpImageSampleDrefImplicitLod %u32 %simg %f32vec2_00 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Image 'Sampled Type' to be the same as Result Type")); } TEST_F(ValidateImage, SampleDrefImplicitLodWrongCoordinateType) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0001 %uniform_image_u32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_u32_2d_0001 %img %sampler %res1 = OpImageSampleDrefImplicitLod %u32 %simg %img %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Coordinate to be float scalar or vector")); } TEST_F(ValidateImage, SampleDrefImplicitLodCoordinateSizeTooSmall) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleDrefImplicitLod %f32 %simg %f32_0_5 %f32_0_5 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Coordinate to have at least 2 components, " "but given only 1")); } TEST_F(ValidateImage, SampleDrefImplicitLodWrongDrefType) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0001 %uniform_image_u32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_u32_2d_0001 %img %sampler %res1 = OpImageSampleDrefImplicitLod %u32 %simg %f32vec2_00 %f64_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Dref to be of 32-bit float type")); } TEST_F(ValidateImage, SampleDrefImplicitLodWrongDimVulkan) { const std::string body = R"( %img = OpLoad %type_image_u32_3d_0001 %uniform_image_u32_3d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_u32_3d_0001 %img %sampler %res1 = OpImageSampleDrefImplicitLod %u32 %simg %f32vec3_hhh %f32_1 )"; CompileSuccessfully( GenerateShaderCode(body, "", "Fragment", "", SPV_ENV_VULKAN_1_0).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpImage-04777")); EXPECT_THAT(getDiagnosticString(), HasSubstr("In Vulkan, OpImage*Dref* instructions must not use " "images with a 3D Dim")); } TEST_F(ValidateImage, SampleDrefExplicitLodSuccess) { const std::string body = R"( %img = OpLoad %type_image_s32_3d_0001 %uniform_image_s32_3d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_s32_3d_0001 %img %sampler %res1 = OpImageSampleDrefExplicitLod %s32 %simg %f32vec4_0000 %f32_1 Lod %f32_1 %res3 = OpImageSampleDrefExplicitLod %s32 %simg %f32vec3_hhh %f32_1 Grad %f32vec3_hhh %f32vec3_hhh %res4 = OpImageSampleDrefExplicitLod %s32 %simg %f32vec3_hhh %f32_1 ConstOffset %s32vec3_012 %res5 = OpImageSampleDrefExplicitLod %s32 %simg %f32vec4_0000 %f32_1 Offset %s32vec3_012 %res7 = OpImageSampleDrefExplicitLod %s32 %simg %f32vec3_hhh %f32_1 Grad|Offset %f32vec3_hhh %f32vec3_hhh %s32vec3_012 %res8 = OpImageSampleDrefExplicitLod %s32 %simg %f32vec4_0000 %f32_1 Lod|NonPrivateTexelKHR %f32_1 )"; const std::string extra = R"( OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_3, "VulkanKHR") .c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateImage, SampleDrefExplicitLodWrongResultType) { const std::string body = R"( %img = OpLoad %type_image_s32_3d_0001 %uniform_image_s32_3d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_s32_3d_0001 %img %sampler %res1 = OpImageSampleDrefExplicitLod %bool %simg %f32vec3_hhh %s32_1 Lod %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be int or float scalar type")); } TEST_F(ValidateImage, SampleDrefExplicitLodNotSampledImage) { const std::string body = R"( %img = OpLoad %type_image_s32_3d_0001 %uniform_image_s32_3d_0001 %res1 = OpImageSampleDrefExplicitLod %s32 %img %f32vec3_hhh %s32_1 Lod %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Sampled Image to be of type OpTypeSampledImage")); } TEST_F(ValidateImage, SampleDrefExplicitLodMultisampleError) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0011 %uniform_image_f32_2d_0011 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0011 %img %sampler %res1 = OpImageSampleDrefExplicitLod %f32 %simg %f32vec2_hh %f32_1 Lod|Sample %f32_1 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Dref sampling operation is invalid for multisample image")); } TEST_F(ValidateImage, SampleDrefExplicitLodWrongSampledType) { const std::string body = R"( %img = OpLoad %type_image_s32_3d_0001 %uniform_image_s32_3d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_s32_3d_0001 %img %sampler %res1 = OpImageSampleDrefExplicitLod %f32 %simg %f32vec3_hhh %s32_1 Lod %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Image 'Sampled Type' to be the same as Result Type")); } TEST_F(ValidateImage, SampleDrefExplicitLodVoidSampledType) { const std::string body = R"( %img = OpLoad %type_image_void_2d_0001 %uniform_image_void_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_void_2d_0001 %img %sampler %res1 = OpImageSampleDrefExplicitLod %u32 %simg %f32vec2_00 %s32_1 Lod %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Image 'Sampled Type' to be the same as Result Type")); } TEST_F(ValidateImage, SampleDrefExplicitLodWrongCoordinateType) { const std::string body = R"( %img = OpLoad %type_image_s32_3d_0001 %uniform_image_s32_3d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_s32_3d_0001 %img %sampler %res1 = OpImageSampleDrefExplicitLod %s32 %simg %img %s32_1 Lod %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Coordinate to be float scalar or vector")); } TEST_F(ValidateImage, SampleDrefExplicitLodCoordinateSizeTooSmall) { const std::string body = R"( %img = OpLoad %type_image_s32_3d_0001 %uniform_image_s32_3d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_s32_3d_0001 %img %sampler %res1 = OpImageSampleDrefExplicitLod %s32 %simg %f32vec2_hh %s32_1 Lod %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Coordinate to have at least 3 components, " "but given only 2")); } TEST_F(ValidateImage, SampleDrefExplicitLodWrongDrefType) { const std::string body = R"( %img = OpLoad %type_image_s32_3d_0001 %uniform_image_s32_3d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_s32_3d_0001 %img %sampler %res1 = OpImageSampleDrefExplicitLod %s32 %simg %f32vec3_hhh %u32_1 Lod %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Dref to be of 32-bit float type")); } TEST_F(ValidateImage, SampleProjDrefImplicitLodSuccess) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleProjDrefImplicitLod %f32 %simg %f32vec3_hhh %f32_0_5 %res2 = OpImageSampleProjDrefImplicitLod %f32 %simg %f32vec3_hhh %f32_0_5 Bias %f32_0_25 %res4 = OpImageSampleProjDrefImplicitLod %f32 %simg %f32vec3_hhh %f32_0_5 ConstOffset %s32vec2_01 %res5 = OpImageSampleProjDrefImplicitLod %f32 %simg %f32vec3_hhh %f32_0_5 Offset %s32vec2_01 %res6 = OpImageSampleProjDrefImplicitLod %f32 %simg %f32vec3_hhh %f32_0_5 MinLod %f32_0_5 %res7 = OpImageSampleProjDrefImplicitLod %f32 %simg %f32vec3_hhh %f32_0_5 Bias|Offset|MinLod %f32_0_25 %s32vec2_01 %f32_0_5 %res8 = OpImageSampleProjDrefImplicitLod %f32 %simg %f32vec3_hhh %f32_0_5 NonPrivateTexelKHR )"; const std::string extra = R"( OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_3, "VulkanKHR") .c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateImage, SampleProjDrefImplicitLodWrongResultType) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleProjDrefImplicitLod %void %simg %f32vec3_hhh %f32_0_5 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be int or float scalar type")); } TEST_F(ValidateImage, SampleProjDrefImplicitLodNotSampledImage) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %res1 = OpImageSampleProjDrefImplicitLod %f32 %img %f32vec3_hhh %f32_0_5 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Sampled Image to be of type OpTypeSampledImage")); } TEST_F(ValidateImage, SampleProjDrefImplicitLodMultisampleError) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0011 %uniform_image_f32_2d_0011 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0011 %img %sampler %res1 = OpImageSampleDrefExplicitLod %f32 %simg %f32vec2_hh %f32_1 Sample %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Dref sampling operation is invalid for multisample image")); } TEST_F(ValidateImage, SampleProjDrefImplicitLodWrongSampledType) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleProjDrefImplicitLod %u32 %simg %f32vec3_hhh %f32_0_5 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Image 'Sampled Type' to be the same as Result Type")); } TEST_F(ValidateImage, SampleProjDrefImplicitLodVoidSampledType) { const std::string body = R"( %img = OpLoad %type_image_void_2d_0001 %uniform_image_void_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_void_2d_0001 %img %sampler %res1 = OpImageSampleProjDrefImplicitLod %u32 %simg %f32vec3_hhh %f32_0_5 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Image 'Sampled Type' to be the same as Result Type")); } TEST_F(ValidateImage, SampleProjDrefImplicitLodWrongCoordinateType) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleProjDrefImplicitLod %f32 %simg %img %f32_0_5 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Coordinate to be float scalar or vector")); } TEST_F(ValidateImage, SampleProjDrefImplicitLodCoordinateSizeTooSmall) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleProjDrefImplicitLod %f32 %simg %f32vec2_hh %f32_0_5 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Coordinate to have at least 3 components, " "but given only 2")); } TEST_F(ValidateImage, SampleProjDrefImplicitLodWrongDrefType) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0001 %uniform_image_u32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_u32_2d_0001 %img %sampler %res1 = OpImageSampleProjDrefImplicitLod %u32 %simg %f32vec3_hhh %f32vec4_0000 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Dref to be of 32-bit float type")); } TEST_F(ValidateImage, SampleProjDrefExplicitLodSuccess) { const std::string body = R"( %img = OpLoad %type_image_f32_1d_0001 %uniform_image_f32_1d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_1d_0001 %img %sampler %res1 = OpImageSampleProjDrefExplicitLod %f32 %simg %f32vec2_hh %f32_0_5 Lod %f32_1 %res2 = OpImageSampleProjDrefExplicitLod %f32 %simg %f32vec3_hhh %f32_0_5 Grad %f32_0_5 %f32_0_5 %res3 = OpImageSampleProjDrefExplicitLod %f32 %simg %f32vec2_hh %f32_0_5 ConstOffset %s32_1 %res4 = OpImageSampleProjDrefExplicitLod %f32 %simg %f32vec2_hh %f32_0_5 Offset %s32_1 %res5 = OpImageSampleProjDrefExplicitLod %f32 %simg %f32vec2_hh %f32_0_5 Grad|Offset %f32_0_5 %f32_0_5 %s32_1 %res6 = OpImageSampleProjDrefExplicitLod %f32 %simg %f32vec2_hh %f32_0_5 Lod|NonPrivateTexelKHR %f32_1 )"; const std::string extra = R"( OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_3, "VulkanKHR") .c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateImage, SampleProjDrefExplicitLodWrongResultType) { const std::string body = R"( %img = OpLoad %type_image_f32_1d_0001 %uniform_image_f32_1d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_1d_0001 %img %sampler %res1 = OpImageSampleProjDrefExplicitLod %bool %simg %f32vec2_hh %f32_0_5 Lod %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be int or float scalar type")); } TEST_F(ValidateImage, SampleProjDrefExplicitLodNotSampledImage) { const std::string body = R"( %img = OpLoad %type_image_f32_1d_0001 %uniform_image_f32_1d_0001 %res1 = OpImageSampleProjDrefExplicitLod %f32 %img %f32vec2_hh %f32_0_5 Lod %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Sampled Image to be of type OpTypeSampledImage")); } TEST_F(ValidateImage, SampleProjDrefExplicitLodMultisampleError) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0011 %uniform_image_f32_2d_0011 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0011 %img %sampler %res1 = OpImageSampleDrefExplicitLod %f32 %simg %f32vec2_hh %f32_1 Lod|Sample %f32_1 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Dref sampling operation is invalid for multisample image")); } TEST_F(ValidateImage, SampleProjDrefExplicitLodWrongSampledType) { const std::string body = R"( %img = OpLoad %type_image_f32_1d_0001 %uniform_image_f32_1d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_1d_0001 %img %sampler %res1 = OpImageSampleProjDrefExplicitLod %u32 %simg %f32vec2_hh %f32_0_5 Lod %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Image 'Sampled Type' to be the same as Result Type")); } TEST_F(ValidateImage, SampleProjDrefExplicitLodVoidSampledType) { const std::string body = R"( %img = OpLoad %type_image_void_2d_0001 %uniform_image_void_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_void_2d_0001 %img %sampler %res1 = OpImageSampleProjDrefExplicitLod %u32 %simg %f32vec3_hhh %f32_0_5 Lod %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Image 'Sampled Type' to be the same as Result Type")); } TEST_F(ValidateImage, SampleProjDrefExplicitLodWrongCoordinateType) { const std::string body = R"( %img = OpLoad %type_image_f32_1d_0001 %uniform_image_f32_1d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_1d_0001 %img %sampler %res1 = OpImageSampleProjDrefExplicitLod %f32 %simg %img %f32_0_5 Lod %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Coordinate to be float scalar or vector")); } TEST_F(ValidateImage, SampleProjDrefExplicitLodCoordinateSizeTooSmall) { const std::string body = R"( %img = OpLoad %type_image_f32_1d_0001 %uniform_image_f32_1d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_1d_0001 %img %sampler %res1 = OpImageSampleProjDrefExplicitLod %f32 %simg %f32_0_5 %f32_0_5 Lod %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Coordinate to have at least 2 components, " "but given only 1")); } TEST_F(ValidateImage, FetchSuccess) { const std::string body = R"( %img = OpLoad %type_image_f32_1d_0001 %uniform_image_f32_1d_0001 %res1 = OpImageFetch %f32vec4 %img %u32vec2_01 %res2 = OpImageFetch %f32vec4 %img %u32vec2_01 NonPrivateTexelKHR )"; const std::string extra = R"( OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_3, "VulkanKHR") .c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateImage, FetchMultisampledSuccess) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0011 %uniform_image_f32_2d_0011 %res1 = OpImageFetch %f32vec4 %img %u32vec2_01 Sample %u32_1 %res2 = OpImageFetch %f32vec4 %img %u32vec2_01 Sample|NonPrivateTexelKHR %u32_1 )"; const std::string extra = R"( OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_3, "VulkanKHR") .c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateImage, FetchWrongResultType) { const std::string body = R"( %img = OpLoad %type_image_f32_rect_0001 %uniform_image_f32_rect_0001 %res1 = OpImageFetch %f32 %img %u32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be int or float vector type")); } TEST_F(ValidateImage, FetchWrongNumComponentsResultType) { const std::string body = R"( %img = OpLoad %type_image_f32_rect_0001 %uniform_image_f32_rect_0001 %res1 = OpImageFetch %f32vec3 %img %u32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to have 4 components")); } TEST_F(ValidateImage, FetchNotImage) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageFetch %f32vec4 %sampler %u32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Image to be of type OpTypeImage")); } TEST_F(ValidateImage, FetchSampledImageDirectly) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageFetch %f32vec4 %simg %u32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpSampledImage instruction must not appear as operand " "for OpImageFetch")); } TEST_F(ValidateImage, FetchNotSampled) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0002 %uniform_image_u32_2d_0002 %res1 = OpImageFetch %u32vec4 %img %u32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Image 'Sampled' parameter to be 1")); } TEST_F(ValidateImage, FetchCube) { const std::string body = R"( %img = OpLoad %type_image_f32_cube_0101 %uniform_image_f32_cube_0101 %res1 = OpImageFetch %f32vec4 %img %u32vec3_012 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Image 'Dim' cannot be Cube")); } TEST_F(ValidateImage, FetchWrongSampledType) { const std::string body = R"( %img = OpLoad %type_image_f32_rect_0001 %uniform_image_f32_rect_0001 %res1 = OpImageFetch %u32vec4 %img %u32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Image 'Sampled Type' to be the same as " "Result Type components")); } TEST_F(ValidateImage, FetchVoidSampledType) { const std::string body = R"( %img = OpLoad %type_image_void_2d_0001 %uniform_image_void_2d_0001 %res1 = OpImageFetch %f32vec4 %img %u32vec2_01 %res2 = OpImageFetch %u32vec4 %img %u32vec2_01 %res3 = OpImageFetch %s32vec4 %img %u32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, FetchWrongCoordinateType) { const std::string body = R"( %img = OpLoad %type_image_f32_rect_0001 %uniform_image_f32_rect_0001 %res1 = OpImageFetch %f32vec4 %img %f32vec2_00 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Coordinate to be int scalar or vector")); } TEST_F(ValidateImage, FetchCoordinateSizeTooSmall) { const std::string body = R"( %img = OpLoad %type_image_f32_rect_0001 %uniform_image_f32_rect_0001 %res1 = OpImageFetch %f32vec4 %img %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Coordinate to have at least 2 components, " "but given only 1")); } TEST_F(ValidateImage, FetchLodNotInt) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %res1 = OpImageFetch %f32vec4 %img %u32vec2_01 Lod %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Image Operand Lod to be int scalar when used " "with OpImageFetch")); } TEST_F(ValidateImage, FetchMultisampledMissingSample) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0011 %uniform_image_f32_2d_0011 %res1 = OpImageFetch %f32vec4 %img %u32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()) << GenerateShaderCode(body); EXPECT_THAT(getDiagnosticString(), HasSubstr("Image Operand Sample is required for operation on " "multi-sampled image")) << getDiagnosticString(); } TEST_F(ValidateImage, GatherSuccess) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageGather %f32vec4 %simg %f32vec4_0000 %u32_1 %res2 = OpImageGather %f32vec4 %simg %f32vec4_0000 %u32_1 ConstOffsets %const_offsets %res3 = OpImageGather %f32vec4 %simg %f32vec4_0000 %u32_1 NonPrivateTexelKHR )"; const std::string extra = R"( OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_3, "VulkanKHR") .c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateImage, GatherWrongResultType) { const std::string body = R"( %img = OpLoad %type_image_f32_cube_0101 %uniform_image_f32_cube_0101 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_cube_0101 %img %sampler %res1 = OpImageGather %f32 %simg %f32vec4_0000 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be int or float vector type")); } TEST_F(ValidateImage, GatherWrongNumComponentsResultType) { const std::string body = R"( %img = OpLoad %type_image_f32_cube_0101 %uniform_image_f32_cube_0101 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_cube_0101 %img %sampler %res1 = OpImageGather %f32vec3 %simg %f32vec4_0000 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to have 4 components")); } TEST_F(ValidateImage, GatherNotSampledImage) { const std::string body = R"( %img = OpLoad %type_image_f32_cube_0101 %uniform_image_f32_cube_0101 %res1 = OpImageGather %f32vec4 %img %f32vec4_0000 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Sampled Image to be of type OpTypeSampledImage")); } TEST_F(ValidateImage, GatherMultisampleError) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0011 %uniform_image_f32_2d_0011 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0011 %img %sampler %res1 = OpImageGather %f32vec4 %simg %f32vec4_0000 %u32_1 Sample %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Gather operation is invalid for multisample image")); } TEST_F(ValidateImage, GatherWrongSampledType) { const std::string body = R"( %img = OpLoad %type_image_f32_cube_0101 %uniform_image_f32_cube_0101 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_cube_0101 %img %sampler %res1 = OpImageGather %u32vec4 %simg %f32vec4_0000 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Image 'Sampled Type' to be the same as " "Result Type components")); } TEST_F(ValidateImage, GatherVoidSampledType) { const std::string body = R"( %img = OpLoad %type_image_void_2d_0001 %uniform_image_void_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_void_2d_0001 %img %sampler %res1 = OpImageGather %u32vec4 %simg %f32vec2_00 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, GatherWrongCoordinateType) { const std::string body = R"( %img = OpLoad %type_image_f32_cube_0101 %uniform_image_f32_cube_0101 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_cube_0101 %img %sampler %res1 = OpImageGather %f32vec4 %simg %u32vec4_0123 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Coordinate to be float scalar or vector")); } TEST_F(ValidateImage, GatherCoordinateSizeTooSmall) { const std::string body = R"( %img = OpLoad %type_image_f32_cube_0101 %uniform_image_f32_cube_0101 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_cube_0101 %img %sampler %res1 = OpImageGather %f32vec4 %simg %f32_0_5 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Coordinate to have at least 4 components, " "but given only 1")); } TEST_F(ValidateImage, GatherWrongComponentType) { const std::string body = R"( %img = OpLoad %type_image_f32_cube_0101 %uniform_image_f32_cube_0101 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_cube_0101 %img %sampler %res1 = OpImageGather %f32vec4 %simg %f32vec4_0000 %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Component to be 32-bit int scalar")); } TEST_F(ValidateImage, GatherComponentNot32Bit) { const std::string body = R"( %img = OpLoad %type_image_f32_cube_0101 %uniform_image_f32_cube_0101 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_cube_0101 %img %sampler %res1 = OpImageGather %f32vec4 %simg %f32vec4_0000 %u64_0 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Component to be 32-bit int scalar")); } TEST_F(ValidateImage, GatherComponentSuccessVulkan) { const std::string body = R"( %img = OpLoad %type_image_f32_cube_0101 %uniform_image_f32_cube_0101 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_cube_0101 %img %sampler %res1 = OpImageGather %f32vec4 %simg %f32vec4_0000 %u32_0 )"; spv_target_env env = SPV_ENV_VULKAN_1_0; CompileSuccessfully(GenerateShaderCode(body, "", "Fragment", "", env).c_str(), env); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(env)); } TEST_F(ValidateImage, GatherComponentNotConstantVulkan) { const std::string body = R"( %input_u32 = OpLoad %u32 %input_flat_u32 %img = OpLoad %type_image_f32_cube_0101 %uniform_image_f32_cube_0101 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_cube_0101 %img %sampler %res1 = OpImageGather %f32vec4 %simg %f32vec4_0000 %input_u32 )"; spv_target_env env = SPV_ENV_VULKAN_1_0; CompileSuccessfully(GenerateShaderCode(body, "", "Fragment", "", env).c_str(), env); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(env)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpImageGather-04664")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Component Operand to be a const object for " "Vulkan environment")); } TEST_F(ValidateImage, GatherDimCube) { const std::string body = R"( %img = OpLoad %type_image_f32_cube_0101 %uniform_image_f32_cube_0101 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_cube_0101 %img %sampler %res1 = OpImageGather %f32vec4 %simg %f32vec4_0000 %u32_1 ConstOffsets %const_offsets )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Image Operand ConstOffsets cannot be used with Cube Image 'Dim'")); } TEST_F(ValidateImage, GatherConstOffsetsNotArray) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageGather %f32vec4 %simg %f32vec4_0000 %u32_1 ConstOffsets %u32vec4_0123 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected Image Operand ConstOffsets to be an array of size 4")); } TEST_F(ValidateImage, GatherConstOffsetsArrayWrongSize) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageGather %f32vec4 %simg %f32vec4_0000 %u32_1 ConstOffsets %const_offsets3x2 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected Image Operand ConstOffsets to be an array of size 4")); } TEST_F(ValidateImage, GatherConstOffsetsArrayNotVector) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageGather %f32vec4 %simg %f32vec4_0000 %u32_1 ConstOffsets %const_offsets4xu )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Image Operand ConstOffsets array components " "to be int vectors of size 2")); } TEST_F(ValidateImage, GatherConstOffsetsArrayVectorWrongSize) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageGather %f32vec4 %simg %f32vec4_0000 %u32_1 ConstOffsets %const_offsets4x3 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Image Operand ConstOffsets array components " "to be int vectors of size 2")); } TEST_F(ValidateImage, GatherConstOffsetsArrayNotConst) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %offsets = OpUndef %u32vec2arr4 %res1 = OpImageGather %f32vec4 %simg %f32vec4_0000 %u32_1 ConstOffsets %offsets )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Image Operand ConstOffsets to be a const object")); } TEST_F(ValidateImage, NotGatherWithConstOffsets) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res2 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_hh ConstOffsets %const_offsets )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Image Operand ConstOffsets can only be used with OpImageGather " "and OpImageDrefGather")); } TEST_F(ValidateImage, DrefGatherSuccess) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageDrefGather %f32vec4 %simg %f32vec4_0000 %f32_0_5 %res2 = OpImageDrefGather %f32vec4 %simg %f32vec4_0000 %f32_0_5 ConstOffsets %const_offsets %res3 = OpImageDrefGather %f32vec4 %simg %f32vec4_0000 %f32_0_5 NonPrivateTexelKHR )"; const std::string extra = R"( OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_3, "VulkanKHR") .c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateImage, DrefGatherMultisampleError) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0011 %uniform_image_f32_2d_0011 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0011 %img %sampler %res1 = OpImageDrefGather %f32vec4 %simg %f32vec4_0000 %f32_1 Sample %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Gather operation is invalid for multisample image")); } TEST_F(ValidateImage, DrefGatherVoidSampledType) { const std::string body = R"( %img = OpLoad %type_image_void_2d_0001 %uniform_image_void_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_void_2d_0001 %img %sampler %res1 = OpImageDrefGather %u32vec4 %simg %f32vec2_00 %f32_0_5 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Image 'Sampled Type' to be the same as " "Result Type components")); } TEST_F(ValidateImage, DrefGatherWrongDrefType) { const std::string body = R"( %img = OpLoad %type_image_f32_cube_0101 %uniform_image_f32_cube_0101 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_cube_0101 %img %sampler %res1 = OpImageDrefGather %f32vec4 %simg %f32vec4_0000 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Dref to be of 32-bit float type")); } TEST_F(ValidateImage, DrefGatherWrongDimVulkan) { const std::string body = R"( %img = OpLoad %type_image_f32_3d_0001 %uniform_image_f32_3d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_3d_0001 %img %sampler %res1 = OpImageDrefGather %f32vec4 %simg %f32vec4_0000 %f32_0_5 )"; CompileSuccessfully( GenerateShaderCode(body, "", "Fragment", "", SPV_ENV_VULKAN_1_0).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpImage-04777")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Image 'Dim' to be 2D, Cube, or Rect")); } TEST_F(ValidateImage, ReadSuccess1) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0002 %uniform_image_u32_2d_0002 %res1 = OpImageRead %u32vec4 %img %u32vec2_01 )"; const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n"; CompileSuccessfully(GenerateShaderCode(body, extra).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, ReadSuccess2) { const std::string body = R"( %img = OpLoad %type_image_f32_1d_0002_rgba32f %uniform_image_f32_1d_0002_rgba32f %res1 = OpImageRead %f32vec4 %img %u32vec2_01 )"; const std::string extra = "\nOpCapability Image1D\n"; CompileSuccessfully(GenerateShaderCode(body, extra).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, ReadSuccess3) { const std::string body = R"( %img = OpLoad %type_image_f32_cube_0102_rgba32f %uniform_image_f32_cube_0102_rgba32f %res1 = OpImageRead %f32vec4 %img %u32vec3_012 )"; const std::string extra = "\nOpCapability ImageCubeArray\n"; CompileSuccessfully(GenerateShaderCode(body, extra).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, ReadSuccess4) { const std::string body = R"( %img = OpLoad %type_image_f32_spd_0002 %uniform_image_f32_spd_0002 %res1 = OpImageRead %f32vec4 %img %u32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, ReadNeedCapabilityStorageImageReadWithoutFormat) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0002 %uniform_image_u32_2d_0002 %res1 = OpImageRead %u32vec4 %img %u32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, ReadNeedCapabilityStorageImageReadWithoutFormatVulkan) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0002 %uniform_image_u32_2d_0002 %res1 = OpImageRead %u32vec4 %img %u32vec2_01 )"; spv_target_env env = SPV_ENV_VULKAN_1_0; CompileSuccessfully(GenerateShaderCode(body, "", "Fragment", "", env).c_str(), env); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(env)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Capability StorageImageReadWithoutFormat is required " "to read storage image")); } TEST_F(ValidateImage, ReadNeedCapabilityImage1D) { const std::string body = R"( %img = OpLoad %type_image_f32_1d_0002_rgba32f %uniform_image_f32_1d_0002_rgba32f %res1 = OpImageRead %f32vec4 %img %u32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Capability Image1D is required to access storage image")); } TEST_F(ValidateImage, ReadNeedCapabilityImageCubeArray) { const std::string body = R"( %img = OpLoad %type_image_f32_cube_0102_rgba32f %uniform_image_f32_cube_0102_rgba32f %res1 = OpImageRead %f32vec4 %img %u32vec3_012 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Capability ImageCubeArray is required to access storage image")); } // TODO(atgoo@github.com) Disabled until the spec is clarified. TEST_F(ValidateImage, DISABLED_ReadWrongResultType) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0002 %uniform_image_u32_2d_0002 %res1 = OpImageRead %f32 %img %u32vec2_01 )"; const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n"; CompileSuccessfully(GenerateShaderCode(body, extra).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be int or float vector type")); } TEST_F(ValidateImage, ReadScalarResultType_Universal) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0002 %uniform_image_u32_2d_0002 %res1 = OpImageRead %u32 %img %u32vec2_01 )"; const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n"; CompileSuccessfully(GenerateShaderCode(body, extra).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_0)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateImage, ReadUnusualNumComponentsResultType_Universal) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0002 %uniform_image_u32_2d_0002 %res1 = OpImageRead %u32vec3 %img %u32vec2_01 )"; const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n"; CompileSuccessfully(GenerateShaderCode(body, extra).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_0)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateImage, ReadWrongNumComponentsResultType_Vulkan) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0002 %uniform_image_u32_2d_0002 %res1 = OpImageRead %u32vec3 %img %u32vec2_01 )"; const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n"; CompileSuccessfully( GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_VULKAN_1_0) .c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Result-04780")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to have 4 components")); } TEST_F(ValidateImage, ReadNotImage) { const std::string body = R"( %sampler = OpLoad %type_sampler %uniform_sampler %res1 = OpImageRead %f32vec4 %sampler %u32vec2_01 )"; const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n"; CompileSuccessfully(GenerateShaderCode(body, extra).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Image to be of type OpTypeImage")); } TEST_F(ValidateImage, ReadImageSampled) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %res1 = OpImageRead %f32vec4 %img %u32vec2_01 )"; const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n"; CompileSuccessfully(GenerateShaderCode(body, extra).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Image 'Sampled' parameter to be 0 or 2")); } TEST_F(ValidateImage, ReadWrongSampledType) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0002 %uniform_image_u32_2d_0002 %res1 = OpImageRead %f32vec4 %img %u32vec2_01 )"; const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n"; CompileSuccessfully(GenerateShaderCode(body, extra).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Image 'Sampled Type' to be the same as " "Result Type components")); } TEST_F(ValidateImage, ReadVoidSampledType) { const std::string body = R"( %img = OpLoad %type_image_void_2d_0002 %uniform_image_void_2d_0002 %res1 = OpImageRead %f32vec4 %img %u32vec2_01 %res2 = OpImageRead %u32vec4 %img %u32vec2_01 %res3 = OpImageRead %s32vec4 %img %u32vec2_01 )"; const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n"; CompileSuccessfully(GenerateShaderCode(body, extra).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, ReadWrongCoordinateType) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0002 %uniform_image_u32_2d_0002 %res1 = OpImageRead %u32vec4 %img %f32vec2_00 )"; const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n"; CompileSuccessfully(GenerateShaderCode(body, extra).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Coordinate to be int scalar or vector")); } TEST_F(ValidateImage, ReadCoordinateSizeTooSmall) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0002 %uniform_image_u32_2d_0002 %res1 = OpImageRead %u32vec4 %img %u32_1 )"; const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n"; CompileSuccessfully(GenerateShaderCode(body, extra).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Coordinate to have at least 2 components, " "but given only 1")); } TEST_F(ValidateImage, WriteSuccess1) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0002 %uniform_image_u32_2d_0002 OpImageWrite %img %u32vec2_01 %u32vec4_0123 )"; const std::string extra = "\nOpCapability StorageImageWriteWithoutFormat\n"; CompileSuccessfully(GenerateShaderCode(body, extra).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, WriteSuccess2) { const std::string body = R"( %img = OpLoad %type_image_f32_1d_0002_rgba32f %uniform_image_f32_1d_0002_rgba32f OpImageWrite %img %u32_1 %f32vec4_0000 )"; const std::string extra = "\nOpCapability Image1D\n"; CompileSuccessfully(GenerateShaderCode(body, extra).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, WriteSuccess3) { const std::string body = R"( %img = OpLoad %type_image_f32_cube_0102_rgba32f %uniform_image_f32_cube_0102_rgba32f OpImageWrite %img %u32vec3_012 %f32vec4_0000 )"; const std::string extra = "\nOpCapability ImageCubeArray\n"; CompileSuccessfully(GenerateShaderCode(body, extra).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, WriteSuccess4) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0012 %uniform_image_f32_2d_0012 OpImageWrite %img %u32vec2_01 %f32vec4_0000 Sample %u32_1 )"; const std::string extra = R"( OpCapability StorageImageWriteWithoutFormat OpCapability StorageImageMultisample )"; const std::string declarations = R"( %type_image_f32_2d_0012 = OpTypeImage %f32 2D 0 0 1 2 Unknown %ptr_image_f32_2d_0012 = OpTypePointer UniformConstant %type_image_f32_2d_0012 %uniform_image_f32_2d_0012 = OpVariable %ptr_image_f32_2d_0012 UniformConstant )"; CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_0, "GLSL450", declarations) .c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, WriteSubpassData) { const std::string body = R"( %img = OpLoad %type_image_f32_spd_0002 %uniform_image_f32_spd_0002 OpImageWrite %img %u32vec2_01 %f32vec4_0000 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Image 'Dim' cannot be SubpassData")); } TEST_F(ValidateImage, WriteNeedCapabilityStorageImageWriteWithoutFormat) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0002 %uniform_image_u32_2d_0002 OpImageWrite %img %u32vec2_01 %u32vec4_0123 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, WriteNeedCapabilityStorageImageWriteWithoutFormatVulkan) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0002 %uniform_image_u32_2d_0002 OpImageWrite %img %u32vec2_01 %u32vec4_0123 )"; spv_target_env env = SPV_ENV_VULKAN_1_0; CompileSuccessfully(GenerateShaderCode(body, "", "Fragment", "", env).c_str(), env); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(env)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Capability StorageImageWriteWithoutFormat is required to write to " "storage image")); } TEST_F(ValidateImage, WriteNeedCapabilityImage1D) { const std::string body = R"( %img = OpLoad %type_image_f32_1d_0002_rgba32f %uniform_image_f32_1d_0002_rgba32f OpImageWrite %img %u32vec2_01 %f32vec4_0000 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Capability Image1D is required to access storage " "image")); } TEST_F(ValidateImage, WriteNeedCapabilityImageCubeArray) { const std::string body = R"( %img = OpLoad %type_image_f32_cube_0102_rgba32f %uniform_image_f32_cube_0102_rgba32f OpImageWrite %img %u32vec3_012 %f32vec4_0000 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Capability ImageCubeArray is required to access storage image")); } TEST_F(ValidateImage, WriteNotImage) { const std::string body = R"( %sampler = OpLoad %type_sampler %uniform_sampler OpImageWrite %sampler %u32vec2_01 %f32vec4_0000 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Image to be of type OpTypeImage")); } TEST_F(ValidateImage, WriteImageSampled) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 OpImageWrite %img %u32vec2_01 %f32vec4_0000 )"; const std::string extra = "\nOpCapability StorageImageWriteWithoutFormat\n"; CompileSuccessfully(GenerateShaderCode(body, extra).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Image 'Sampled' parameter to be 0 or 2")); } TEST_F(ValidateImage, WriteWrongCoordinateType) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0002 %uniform_image_u32_2d_0002 OpImageWrite %img %f32vec2_00 %u32vec4_0123 )"; const std::string extra = "\nOpCapability StorageImageWriteWithoutFormat\n"; CompileSuccessfully(GenerateShaderCode(body, extra).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Coordinate to be int scalar or vector")); } TEST_F(ValidateImage, WriteCoordinateSizeTooSmall) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0002 %uniform_image_u32_2d_0002 OpImageWrite %img %u32_1 %u32vec4_0123 )"; const std::string extra = "\nOpCapability StorageImageWriteWithoutFormat\n"; CompileSuccessfully(GenerateShaderCode(body, extra).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Coordinate to have at least 2 components, " "but given only 1")); } TEST_F(ValidateImage, WriteTexelScalarSuccess) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0002 %uniform_image_u32_2d_0002 OpImageWrite %img %u32vec2_01 %u32_2 )"; const std::string extra = "\nOpCapability StorageImageWriteWithoutFormat\n"; CompileSuccessfully(GenerateShaderCode(body, extra).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, WriteTexelWrongType) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0002 %uniform_image_u32_2d_0002 OpImageWrite %img %u32vec2_01 %img )"; const std::string extra = "\nOpCapability StorageImageWriteWithoutFormat\n"; CompileSuccessfully(GenerateShaderCode(body, extra).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Texel to be int or float vector or scalar")); } TEST_F(ValidateImage, WriteTexelNonNumericalType) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0002 %uniform_image_u32_2d_0002 OpImageWrite %img %u32vec2_01 %boolvec4_tttt )"; const std::string extra = "\nOpCapability StorageImageWriteWithoutFormat\n"; CompileSuccessfully(GenerateShaderCode(body, extra).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Texel to be int or float vector or scalar")); } TEST_F(ValidateImage, WriteTexelWrongComponentType) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0002 %uniform_image_u32_2d_0002 OpImageWrite %img %u32vec2_01 %f32vec4_0000 )"; const std::string extra = "\nOpCapability StorageImageWriteWithoutFormat\n"; CompileSuccessfully(GenerateShaderCode(body, extra).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected Image 'Sampled Type' to be the same as Texel components")); } TEST_F(ValidateImage, WriteSampleNotInteger) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0012 %uniform_image_f32_2d_0012 OpImageWrite %img %u32vec2_01 %f32vec4_0000 Sample %f32_1 )"; const std::string extra = R"( OpCapability StorageImageWriteWithoutFormat OpCapability StorageImageMultisample )"; const std::string declarations = R"( %type_image_f32_2d_0012 = OpTypeImage %f32 2D 0 0 1 2 Unknown %ptr_image_f32_2d_0012 = OpTypePointer UniformConstant %type_image_f32_2d_0012 %uniform_image_f32_2d_0012 = OpVariable %ptr_image_f32_2d_0012 UniformConstant )"; CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_0, "GLSL450", declarations) .c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Image Operand Sample to be int scalar")); } TEST_F(ValidateImage, WriteSampleNotMultisampled) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0002 %uniform_image_f32_2d_0002 OpImageWrite %img %u32vec2_01 %f32vec4_0000 Sample %u32_1 )"; const std::string extra = "\nOpCapability StorageImageWriteWithoutFormat\n"; CompileSuccessfully(GenerateShaderCode(body, extra).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Image Operand Sample requires non-zero 'MS' parameter")); } TEST_F(ValidateImage, SampleWrongOpcode) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0011 %uniform_image_f32_2d_0011 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0011 %img %sampler %res1 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec2_00 Sample %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Sampling operation is invalid for multisample image")); } TEST_F(ValidateImage, SampleImageToImageSuccess) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %img2 = OpImage %type_image_f32_2d_0001 %simg )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, SampleImageToImageWrongResultType) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %img2 = OpImage %type_sampled_image_f32_2d_0001 %simg )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be OpTypeImage")); } TEST_F(ValidateImage, SampleImageToImageNotSampledImage) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %img2 = OpImage %type_image_f32_2d_0001 %img )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Sample Image to be of type OpTypeSampleImage")); } TEST_F(ValidateImage, SampleImageToImageNotTheSameImageType) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %img2 = OpImage %type_image_f32_2d_0002 %simg )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Sample Image image type to be equal to " "Result Type")); } TEST_F(ValidateImage, QueryFormatSuccess) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %res1 = OpImageQueryFormat %u32 %img )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, QueryFormatWrongResultType) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %res1 = OpImageQueryFormat %bool %img )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be int scalar type")); } TEST_F(ValidateImage, QueryFormatNotImage) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageQueryFormat %u32 %sampler )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected operand to be of type OpTypeImage")); } TEST_F(ValidateImage, QueryOrderSuccess) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %res1 = OpImageQueryOrder %u32 %img )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, QueryOrderWrongResultType) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %res1 = OpImageQueryOrder %bool %img )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be int scalar type")); } TEST_F(ValidateImage, QueryOrderNotImage) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageQueryOrder %u32 %sampler )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected operand to be of type OpTypeImage")); } TEST_F(ValidateImage, QuerySizeLodSuccess) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %res1 = OpImageQuerySizeLod %u32vec2 %img %u32_1 )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, QuerySizeLodWrongResultType) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %res1 = OpImageQuerySizeLod %f32vec2 %img %u32_1 )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Result Type to be int scalar or vector type")); } TEST_F(ValidateImage, QuerySizeLodResultTypeWrongSize) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %res1 = OpImageQuerySizeLod %u32 %img %u32_1 )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Result Type has 1 components, but 2 expected")); } TEST_F(ValidateImage, QuerySizeLodNotImage) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageQuerySizeLod %u32vec2 %sampler %u32_1 )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Image to be of type OpTypeImage")); } TEST_F(ValidateImage, QuerySizeLodSampledImageDirectly) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageQuerySizeLod %u32vec2 %simg %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpSampledImage instruction must not appear as operand " "for OpImageQuerySizeLod")); } TEST_F(ValidateImage, QuerySizeLodMultisampledError) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0011 %uniform_image_f32_2d_0011 %res1 = OpImageQuerySizeLod %u32vec2 %img %u32_1 )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Image 'MS' must be 0")); } TEST_F(ValidateImage, QuerySizeLodNonSampledUniversalSuccess) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0002 %uniform_image_f32_2d_0002 %res1 = OpImageQuerySizeLod %u32vec2 %img %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); EXPECT_EQ(getDiagnosticString(), ""); } TEST_F(ValidateImage, QuerySizeLodVulkanNonSampledError) { // Create a whole shader module. Avoid Vulkan incompatibility with // SampledRrect images inserted by helper function GenerateShaderCode. const std::string body = R"( OpCapability Shader OpCapability ImageQuery OpMemoryModel Logical Simple OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %f32 = OpTypeFloat 32 %u32 = OpTypeInt 32 0 %u32_0 = OpConstant %u32 0 %u32vec2 = OpTypeVector %u32 2 %void = OpTypeVoid %voidfn = OpTypeFunction %void ; Test with a storage image. %type_image_f32_2d_0002 = OpTypeImage %f32 2D 0 0 0 2 Rgba32f %ptr_image_f32_2d_0002 = OpTypePointer UniformConstant %type_image_f32_2d_0002 %uniform_image_f32_2d_0002 = OpVariable %ptr_image_f32_2d_0002 UniformConstant %main = OpFunction %void None %voidfn %entry = OpLabel %img = OpLoad %type_image_f32_2d_0002 %uniform_image_f32_2d_0002 %res1 = OpImageQuerySizeLod %u32vec2 %img %u32_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpImageQuerySizeLod-04659")); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpImageQuerySizeLod must only consume an \"Image\" operand whose " "type has its \"Sampled\" operand set to 1")); } TEST_F(ValidateImage, QuerySizeLodWrongImageDim) { const std::string body = R"( %img = OpLoad %type_image_f32_rect_0001 %uniform_image_f32_rect_0001 %res1 = OpImageQuerySizeLod %u32vec2 %img %u32_1 )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Image 'Dim' must be 1D, 2D, 3D or Cube")); } TEST_F(ValidateImage, QuerySizeLodWrongLodType) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %res1 = OpImageQuerySizeLod %u32vec2 %img %f32_0 )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Level of Detail to be int scalar")); } TEST_F(ValidateImage, QuerySizeSuccess) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0011 %uniform_image_f32_2d_0011 %res1 = OpImageQuerySize %u32vec2 %img )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, QuerySizeWrongResultType) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0011 %uniform_image_f32_2d_0011 %res1 = OpImageQuerySize %f32vec2 %img )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Result Type to be int scalar or vector type")); } TEST_F(ValidateImage, QuerySizeNotImage) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0011 %uniform_image_f32_2d_0011 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0011 %img %sampler %res1 = OpImageQuerySize %u32vec2 %sampler )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Image to be of type OpTypeImage")); } TEST_F(ValidateImage, QuerySizeSampledImageDirectly) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0011 %uniform_image_f32_2d_0011 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0011 %img %sampler %res1 = OpImageQuerySize %u32vec2 %simg )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpSampledImage instruction must not appear as operand " "for OpImageQuerySize")); } TEST_F(ValidateImage, QuerySizeDimSubpassDataBad) { const std::string body = R"( %img = OpLoad %type_image_f32_spd_0002 %uniform_image_f32_spd_0002 %res1 = OpImageQuerySize %u32vec2 %img )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Image 'Dim' must be 1D, Buffer, 2D, Cube, 3D or Rect")); } TEST_F(ValidateImage, QuerySizeWrongSampling) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %res1 = OpImageQuerySize %u32vec2 %img )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Image must have either 'MS'=1 or 'Sampled'=0 or 'Sampled'=2")); } TEST_F(ValidateImage, QuerySizeWrongNumberOfComponents) { const std::string body = R"( %img = OpLoad %type_image_f32_3d_0111 %uniform_image_f32_3d_0111 %res1 = OpImageQuerySize %u32vec2 %img )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Result Type has 2 components, but 4 expected")); } TEST_F(ValidateImage, QueryLodSuccessKernel) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageQueryLod %f32vec2 %simg %f32vec2_hh %res2 = OpImageQueryLod %f32vec2 %simg %u32vec2_01 )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, QueryLodSuccessShader) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageQueryLod %f32vec2 %simg %f32vec2_hh )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, QueryLodWrongResultType) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageQueryLod %u32vec2 %simg %f32vec2_hh )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be float vector type")); } TEST_F(ValidateImage, QueryLodResultTypeWrongSize) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageQueryLod %f32vec3 %simg %f32vec2_hh )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to have 2 components")); } TEST_F(ValidateImage, QueryLodNotSampledImage) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %res1 = OpImageQueryLod %f32vec2 %img %f32vec2_hh )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Image operand to be of type OpTypeSampledImage")); } TEST_F(ValidateImage, QueryLodWrongDim) { const std::string body = R"( %img = OpLoad %type_image_f32_rect_0001 %uniform_image_f32_rect_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_rect_0001 %img %sampler %res1 = OpImageQueryLod %f32vec2 %simg %f32vec2_hh )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Image 'Dim' must be 1D, 2D, 3D or Cube")); } TEST_F(ValidateImage, QueryLodWrongCoordinateType) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageQueryLod %f32vec2 %simg %u32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Coordinate to be float scalar or vector")); } TEST_F(ValidateImage, QueryLodCoordinateSizeTooSmall) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageQueryLod %f32vec2 %simg %f32_0 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Coordinate to have at least 2 components, " "but given only 1")); } TEST_F(ValidateImage, QueryLevelsSuccess) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %res1 = OpImageQueryLevels %u32 %img )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, QueryLevelsWrongResultType) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %res1 = OpImageQueryLevels %f32 %img )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be int scalar type")); } TEST_F(ValidateImage, QueryLevelsNotImage) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageQueryLevels %u32 %sampler )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Image to be of type OpTypeImage")); } TEST_F(ValidateImage, QueryLevelsSampledImageDirectly) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageQueryLevels %u32 %simg )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpSampledImage instruction must not appear as operand " "for OpImageQueryLevels")); } TEST_F(ValidateImage, QueryLevelsWrongDim) { const std::string body = R"( %img = OpLoad %type_image_f32_rect_0001 %uniform_image_f32_rect_0001 %res1 = OpImageQueryLevels %u32 %img )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Image 'Dim' must be 1D, 2D, 3D or Cube")); } TEST_F(ValidateImage, QuerySizeLevelsNonSampledUniversalSuccess) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0002 %uniform_image_f32_2d_0002 %res1 = OpImageQueryLevels %u32 %img )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); EXPECT_EQ(getDiagnosticString(), ""); } TEST_F(ValidateImage, QuerySizeLevelsVulkanNonSampledError) { // Create a whole shader module. Avoid Vulkan incompatibility with // SampledRrect images inserted by helper function GenerateShaderCode. const std::string body = R"( OpCapability Shader OpCapability ImageQuery OpMemoryModel Logical Simple OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %f32 = OpTypeFloat 32 %u32 = OpTypeInt 32 0 %void = OpTypeVoid %voidfn = OpTypeFunction %void ; Test with a storage image. %type_image_f32_2d_0002 = OpTypeImage %f32 2D 0 0 0 2 Rgba32f %ptr_image_f32_2d_0002 = OpTypePointer UniformConstant %type_image_f32_2d_0002 %uniform_image_f32_2d_0002 = OpVariable %ptr_image_f32_2d_0002 UniformConstant %main = OpFunction %void None %voidfn %entry = OpLabel %img = OpLoad %type_image_f32_2d_0002 %uniform_image_f32_2d_0002 %res1 = OpImageQueryLevels %u32 %img OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpImageQuerySizeLod-04659")); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpImageQueryLevels must only consume an \"Image\" operand " "whose type has its \"Sampled\" operand set to 1")); } TEST_F(ValidateImage, QuerySamplesSuccess) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0011 %uniform_image_f32_2d_0011 %res1 = OpImageQuerySamples %u32 %img )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, QuerySamplesNot2D) { const std::string body = R"( %img = OpLoad %type_image_f32_3d_0011 %uniform_image_f32_3d_0011 %res1 = OpImageQuerySamples %u32 %img )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Image 'Dim' must be 2D")); } TEST_F(ValidateImage, QuerySamplesNotMultisampled) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %res1 = OpImageQuerySamples %u32 %img )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Image 'MS' must be 1")); } TEST_F(ValidateImage, QueryLodWrongExecutionModel) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageQueryLod %f32vec2 %simg %f32vec2_hh )"; CompileSuccessfully(GenerateShaderCode(body, "", "Vertex").c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpImageQueryLod requires Fragment, GLCompute, MeshEXT or TaskEXT " "execution model")); } TEST_F(ValidateImage, QueryLodWrongExecutionModelWithFunc) { const std::string body = R"( %call_ret = OpFunctionCall %void %my_func OpReturn OpFunctionEnd %my_func = OpFunction %void None %func %my_func_entry = OpLabel %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageQueryLod %f32vec2 %simg %f32vec2_hh )"; CompileSuccessfully(GenerateShaderCode(body, "", "Vertex").c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpImageQueryLod requires Fragment, GLCompute, MeshEXT or TaskEXT " "execution model")); } TEST_F(ValidateImage, QueryLodComputeShaderDerivatives) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageQueryLod %f32vec2 %simg %f32vec2_hh )"; const std::string extra = R"( OpCapability ComputeDerivativeGroupLinearKHR OpExtension "SPV_KHR_compute_shader_derivatives" )"; const std::string mode = R"( OpExecutionMode %main LocalSize 8 8 1 OpExecutionMode %main DerivativeGroupLinearKHR )"; CompileSuccessfully( GenerateShaderCode(body, extra, "GLCompute", mode).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, QueryLodUniversalSuccess) { // Create a whole shader module. Avoid Vulkan incompatibility with // SampledRrect images inserted by helper function GenerateShaderCode. const std::string body = R"( OpCapability Shader OpCapability ImageQuery OpMemoryModel Logical Simple OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpDecorate %uniform_image_f32_2d_0000 DescriptorSet 0 OpDecorate %uniform_image_f32_2d_0000 Binding 0 OpDecorate %sampler DescriptorSet 0 OpDecorate %sampler Binding 1 %f32 = OpTypeFloat 32 %f32vec2 = OpTypeVector %f32 2 %f32vec2_null = OpConstantNull %f32vec2 %u32 = OpTypeInt 32 0 %u32vec2 = OpTypeVector %u32 2 %void = OpTypeVoid %voidfn = OpTypeFunction %void ; Test with an image with sampled = 0 %type_image_f32_2d_0000 = OpTypeImage %f32 2D 0 0 0 0 Rgba32f %ptr_image_f32_2d_0000 = OpTypePointer UniformConstant %type_image_f32_2d_0000 %uniform_image_f32_2d_0000 = OpVariable %ptr_image_f32_2d_0000 UniformConstant %sampled_image_ty = OpTypeSampledImage %type_image_f32_2d_0000 %sampler_ty = OpTypeSampler %ptr_sampler_ty = OpTypePointer UniformConstant %sampler_ty %sampler = OpVariable %ptr_sampler_ty UniformConstant %main = OpFunction %void None %voidfn %entry = OpLabel %img = OpLoad %type_image_f32_2d_0000 %uniform_image_f32_2d_0000 %s = OpLoad %sampler_ty %sampler %simg = OpSampledImage %sampled_image_ty %img %s %res1 = OpImageQueryLod %f32vec2 %simg %f32vec2_null OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, QueryLodVulkanNonSampledError) { // Create a whole shader module. Avoid Vulkan incompatibility with // SampledRrect images inserted by helper function GenerateShaderCode. const std::string body = R"( OpCapability Shader OpCapability ImageQuery OpMemoryModel Logical Simple OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpDecorate %sampled_image DescriptorSet 0 OpDecorate %sampled_image Binding 0 %f32 = OpTypeFloat 32 %f32vec2 = OpTypeVector %f32 2 %f32vec2_null = OpConstantNull %f32vec2 %u32 = OpTypeInt 32 0 %u32vec2 = OpTypeVector %u32 2 %void = OpTypeVoid %voidfn = OpTypeFunction %void ; Test with an image with Sampled = 2 ; In Vulkan it Sampled must be 1 or 2, checked in another part of the ; validation flow. %type_image_f32_2d_0002 = OpTypeImage %f32 2D 0 0 0 2 Rgba32f ; Expect to fail here. %sampled_image_ty = OpTypeSampledImage %type_image_f32_2d_0002 %ptr_sampled_image_ty = OpTypePointer UniformConstant %sampled_image_ty %sampled_image = OpVariable %ptr_sampled_image_ty UniformConstant %main = OpFunction %void None %voidfn %entry = OpLabel %simg = OpLoad %sampled_image_ty %sampled_image %res1 = OpImageQueryLod %f32vec2 %simg %f32vec2_null OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpTypeImage-04657")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Sampled image type requires an image type with " "\"Sampled\" operand set to 0 or 1")); } TEST_F(ValidateImage, QueryLodComputeShaderDerivativesMissingMode) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageQueryLod %f32vec2 %simg %f32vec2_hh )"; const std::string extra = R"( OpCapability ComputeDerivativeGroupLinearKHR OpExtension "SPV_KHR_compute_shader_derivatives" )"; const std::string mode = R"( OpExecutionMode %main LocalSize 8 8 1 )"; CompileSuccessfully( GenerateShaderCode(body, extra, "GLCompute", mode).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpImageQueryLod requires DerivativeGroupQuadsKHR or " "DerivativeGroupLinearKHR execution mode for " "GLCompute, MeshEXT or TaskEXT execution model")); } TEST_F(ValidateImage, ImplicitLodWrongExecutionModel) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_hh )"; CompileSuccessfully(GenerateShaderCode(body, "", "Vertex").c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("ImplicitLod instructions require Fragment, " "GLCompute, MeshEXT or TaskEXT execution model")); } TEST_F(ValidateImage, ImplicitLodComputeShaderDerivatives) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_hh )"; const std::string extra = R"( OpCapability ComputeDerivativeGroupLinearKHR OpExtension "SPV_KHR_compute_shader_derivatives" )"; const std::string mode = R"( OpExecutionMode %main LocalSize 8 8 1 OpExecutionMode %main DerivativeGroupLinearKHR )"; CompileSuccessfully( GenerateShaderCode(body, extra, "GLCompute", mode).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, ImplicitLodComputeShaderDerivativesMissingMode) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_hh )"; const std::string extra = R"( OpCapability ComputeDerivativeGroupLinearKHR OpExtension "SPV_KHR_compute_shader_derivatives" )"; const std::string mode = R"( OpExecutionMode %main LocalSize 8 8 1 )"; CompileSuccessfully( GenerateShaderCode(body, extra, "GLCompute", mode).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("ImplicitLod instructions require DerivativeGroupQuadsKHR or " "DerivativeGroupLinearKHR execution mode for GLCompute, " "MeshEXT or TaskEXT execution model")); } TEST_F(ValidateImage, ReadSubpassDataWrongExecutionModel) { const std::string body = R"( %img = OpLoad %type_image_f32_spd_0002 %uniform_image_f32_spd_0002 %res1 = OpImageRead %f32vec4 %img %u32vec2_01 )"; const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n"; CompileSuccessfully(GenerateShaderCode(body, extra, "Vertex").c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Dim SubpassData requires Fragment execution model")); } TEST_F(ValidateImage, SparseSampleImplicitLodSuccess) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSparseSampleImplicitLod %struct_u32_f32vec4 %simg %f32vec2_hh %res2 = OpImageSparseSampleImplicitLod %struct_u32_f32vec4 %simg %f32vec2_hh Bias %f32_0_25 %res4 = OpImageSparseSampleImplicitLod %struct_u32_f32vec4 %simg %f32vec2_hh ConstOffset %s32vec2_01 %res5 = OpImageSparseSampleImplicitLod %struct_u32_f32vec4 %simg %f32vec2_hh Offset %s32vec2_01 %res6 = OpImageSparseSampleImplicitLod %struct_u32_f32vec4 %simg %f32vec2_hh MinLod %f32_0_5 %res7 = OpImageSparseSampleImplicitLod %struct_u64_f32vec4 %simg %f32vec2_hh Bias|Offset|MinLod %f32_0_25 %s32vec2_01 %f32_0_5 %res8 = OpImageSparseSampleImplicitLod %struct_u32_f32vec4 %simg %f32vec2_hh NonPrivateTexelKHR )"; const std::string extra = R"( OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_3, "VulkanKHR") .c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateImage, SparseSampleImplicitLodResultTypeNotStruct) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSparseSampleImplicitLod %f32 %simg %f32vec2_hh )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be OpTypeStruct")); } TEST_F(ValidateImage, SparseSampleImplicitLodResultTypeNotTwoMembers1) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSparseSampleImplicitLod %struct_u32 %simg %f32vec2_hh )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be a struct containing an int " "scalar and a texel")); } TEST_F(ValidateImage, SparseSampleImplicitLodResultTypeNotTwoMembers2) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSparseSampleImplicitLod %struct_u32_f32vec4_u32 %simg %f32vec2_hh )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be a struct containing an " "int scalar and a texel")); } TEST_F(ValidateImage, SparseSampleImplicitLodResultTypeFirstMemberNotInt) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSparseSampleImplicitLod %struct_f32_f32vec4 %simg %f32vec2_hh )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be a struct containing an " "int scalar and a texel")); } TEST_F(ValidateImage, SparseSampleImplicitLodResultTypeTexelNotVector) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSparseSampleImplicitLod %struct_u32_u32 %simg %f32vec2_hh )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type's second member to be int or " "float vector type")); } TEST_F(ValidateImage, SparseSampleImplicitLodWrongNumComponentsTexel) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSparseSampleImplicitLod %struct_u32_f32vec3 %simg %f32vec2_hh )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type's second member to have 4 " "components")); } TEST_F(ValidateImage, SparseSampleImplicitLodWrongComponentTypeTexel) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSparseSampleImplicitLod %struct_u32_u32vec4 %simg %f32vec2_hh )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Image 'Sampled Type' to be the same as " "Result Type's second member components")); } TEST_F(ValidateImage, SparseSampleDrefImplicitLodSuccess) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0001 %uniform_image_u32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_u32_2d_0001 %img %sampler %res1 = OpImageSparseSampleDrefImplicitLod %struct_u32_u32 %simg %f32vec2_hh %f32_1 %res2 = OpImageSparseSampleDrefImplicitLod %struct_u32_u32 %simg %f32vec2_hh %f32_1 Bias %f32_0_25 %res4 = OpImageSparseSampleDrefImplicitLod %struct_u32_u32 %simg %f32vec2_hh %f32_1 ConstOffset %s32vec2_01 %res5 = OpImageSparseSampleDrefImplicitLod %struct_u32_u32 %simg %f32vec2_hh %f32_1 Offset %s32vec2_01 %res6 = OpImageSparseSampleDrefImplicitLod %struct_u32_u32 %simg %f32vec2_hh %f32_1 MinLod %f32_0_5 %res7 = OpImageSparseSampleDrefImplicitLod %struct_u32_u32 %simg %f32vec2_hh %f32_1 Bias|Offset|MinLod %f32_0_25 %s32vec2_01 %f32_0_5 %res8 = OpImageSparseSampleDrefImplicitLod %struct_u32_u32 %simg %f32vec2_hh %f32_1 NonPrivateTexelKHR )"; const std::string extra = R"( OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_3, "VulkanKHR") .c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateImage, SparseSampleDrefImplicitLodResultTypeNotStruct) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSparseSampleDrefImplicitLod %f32 %simg %f32vec2_hh %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be OpTypeStruct")); } TEST_F(ValidateImage, SparseSampleDrefImplicitLodResultTypeNotTwoMembers1) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSparseSampleDrefImplicitLod %struct_u32 %simg %f32vec2_hh %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Result Type to be a struct containing an int scalar " "and a texel")); } TEST_F(ValidateImage, SparseSampleDrefImplicitLodResultTypeNotTwoMembers2) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSparseSampleDrefImplicitLod %struct_u32_f32_u32 %simg %f32vec2_hh %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Result Type to be a struct containing an int scalar " "and a texel")); } TEST_F(ValidateImage, SparseSampleDrefImplicitLodResultTypeFirstMemberNotInt) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSparseSampleDrefImplicitLod %struct_f32_f32 %simg %f32vec2_hh %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected Result Type to be a struct containing an int scalar " "and a texel")); } TEST_F(ValidateImage, SparseSampleDrefImplicitLodDifferentSampledType) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSparseSampleDrefImplicitLod %struct_u32_u32 %simg %f32vec2_hh %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Image 'Sampled Type' to be the same as " "Result Type's second member")); } TEST_F(ValidateImage, SparseFetchSuccess) { const std::string body = R"( %img = OpLoad %type_image_f32_1d_0001 %uniform_image_f32_1d_0001 %res1 = OpImageSparseFetch %struct_u32_f32vec4 %img %u32vec2_01 %res2 = OpImageSparseFetch %struct_u32_f32vec4 %img %u32vec2_01 NonPrivateTexelKHR )"; const std::string extra = R"( OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_3, "VulkanKHR") .c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateImage, SparseFetchResultTypeNotStruct) { const std::string body = R"( %img = OpLoad %type_image_f32_rect_0001 %uniform_image_f32_rect_0001 %res1 = OpImageSparseFetch %f32 %img %u32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be OpTypeStruct")); } TEST_F(ValidateImage, SparseFetchResultTypeNotTwoMembers1) { const std::string body = R"( %img = OpLoad %type_image_f32_rect_0001 %uniform_image_f32_rect_0001 %res1 = OpImageSparseFetch %struct_u32 %img %u32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be a struct containing an " "int scalar and a texel")); } TEST_F(ValidateImage, SparseFetchResultTypeNotTwoMembers2) { const std::string body = R"( %img = OpLoad %type_image_f32_rect_0001 %uniform_image_f32_rect_0001 %res1 = OpImageSparseFetch %struct_u32_f32vec4_u32 %img %u32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be a struct containing an " "int scalar and a texel")); } TEST_F(ValidateImage, SparseFetchResultTypeFirstMemberNotInt) { const std::string body = R"( %img = OpLoad %type_image_f32_rect_0001 %uniform_image_f32_rect_0001 %res1 = OpImageSparseFetch %struct_f32_f32vec4 %img %u32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be a struct containing an " "int scalar and a texel")); } TEST_F(ValidateImage, SparseFetchResultTypeTexelNotVector) { const std::string body = R"( %img = OpLoad %type_image_f32_rect_0001 %uniform_image_f32_rect_0001 %res1 = OpImageSparseFetch %struct_u32_u32 %img %u32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type's second member to be int or " "float vector type")); } TEST_F(ValidateImage, SparseFetchWrongNumComponentsTexel) { const std::string body = R"( %img = OpLoad %type_image_f32_rect_0001 %uniform_image_f32_rect_0001 %res1 = OpImageSparseFetch %struct_u32_f32vec3 %img %u32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type's second member to have 4 " "components")); } TEST_F(ValidateImage, SparseFetchWrongComponentTypeTexel) { const std::string body = R"( %img = OpLoad %type_image_f32_rect_0001 %uniform_image_f32_rect_0001 %res1 = OpImageSparseFetch %struct_u32_u32vec4 %img %u32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Image 'Sampled Type' to be the same as " "Result Type's second member components")); } TEST_F(ValidateImage, SparseReadSuccess) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0002 %uniform_image_f32_2d_0002 %res1 = OpImageSparseRead %struct_u32_f32vec4 %img %u32vec2_01 )"; const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n"; CompileSuccessfully(GenerateShaderCode(body, extra).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, SparseReadResultTypeNotStruct) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0002 %uniform_image_f32_2d_0002 %res1 = OpImageSparseRead %f32 %img %u32vec2_01 )"; const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n"; CompileSuccessfully(GenerateShaderCode(body, extra).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be OpTypeStruct")); } TEST_F(ValidateImage, SparseReadResultTypeNotTwoMembers1) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0002 %uniform_image_f32_2d_0002 %res1 = OpImageSparseRead %struct_u32 %img %u32vec2_01 )"; const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n"; CompileSuccessfully(GenerateShaderCode(body, extra).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be a struct containing an " "int scalar and a texel")); } TEST_F(ValidateImage, SparseReadResultTypeNotTwoMembers2) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0002 %uniform_image_f32_2d_0002 %res1 = OpImageSparseRead %struct_u32_f32vec4_u32 %img %u32vec2_01 )"; const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n"; CompileSuccessfully(GenerateShaderCode(body, extra).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be a struct containing an " "int scalar and a texel")); } TEST_F(ValidateImage, SparseReadResultTypeFirstMemberNotInt) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0002 %uniform_image_f32_2d_0002 %res1 = OpImageSparseRead %struct_f32_f32vec4 %img %u32vec2_01 )"; const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n"; CompileSuccessfully(GenerateShaderCode(body, extra).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be a struct containing an " "int scalar and a texel")); } TEST_F(ValidateImage, SparseReadResultTypeTexelWrongType) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0002 %uniform_image_f32_2d_0002 %res1 = OpImageSparseRead %struct_u32_u32arr4 %img %u32vec2_01 )"; const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n"; CompileSuccessfully(GenerateShaderCode(body, extra).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type's second member to be int or " "float scalar or vector type")); } TEST_F(ValidateImage, SparseReadWrongComponentTypeTexel) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0002 %uniform_image_f32_2d_0002 %res1 = OpImageSparseRead %struct_u32_u32vec4 %img %u32vec2_01 )"; const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n"; CompileSuccessfully(GenerateShaderCode(body, extra).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Image 'Sampled Type' to be the same as " "Result Type's second member components")); } TEST_F(ValidateImage, SparseReadSubpassDataNotAllowed) { const std::string body = R"( %img = OpLoad %type_image_f32_spd_0002 %uniform_image_f32_spd_0002 %res1 = OpImageSparseRead %struct_u32_f32vec4 %img %u32vec2_01 )"; const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n"; CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment").c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Image Dim SubpassData cannot be used with ImageSparseRead")); } TEST_F(ValidateImage, SparseGatherSuccess) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSparseGather %struct_u32_f32vec4 %simg %f32vec4_0000 %u32_1 %res2 = OpImageSparseGather %struct_u32_f32vec4 %simg %f32vec4_0000 %u32_1 NonPrivateTexelKHR )"; const std::string extra = R"( OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_3, "VulkanKHR") .c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateImage, SparseGatherResultTypeNotStruct) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSparseGather %f32 %simg %f32vec2_hh %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be OpTypeStruct")); } TEST_F(ValidateImage, SparseGatherResultTypeNotTwoMembers1) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSparseGather %struct_u32 %simg %f32vec2_hh %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be a struct containing an int " "scalar and a texel")); } TEST_F(ValidateImage, SparseGatherResultTypeNotTwoMembers2) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSparseGather %struct_u32_f32vec4_u32 %simg %f32vec2_hh %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be a struct containing an int " "scalar and a texel")); } TEST_F(ValidateImage, SparseGatherResultTypeFirstMemberNotInt) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSparseGather %struct_f32_f32vec4 %simg %f32vec2_hh %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be a struct containing an " "int scalar and a texel")); } TEST_F(ValidateImage, SparseGatherResultTypeTexelNotVector) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSparseGather %struct_u32_u32 %simg %f32vec2_hh %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type's second member to be int or " "float vector type")); } TEST_F(ValidateImage, SparseGatherWrongNumComponentsTexel) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSparseGather %struct_u32_f32vec3 %simg %f32vec2_hh %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type's second member to have 4 " "components")); } TEST_F(ValidateImage, SparseGatherWrongComponentTypeTexel) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSparseGather %struct_u32_u32vec4 %simg %f32vec2_hh %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Image 'Sampled Type' to be the same as " "Result Type's second member components")); } TEST_F(ValidateImage, SparseTexelsResidentSuccess) { const std::string body = R"( %res1 = OpImageSparseTexelsResident %bool %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, SparseTexelsResidentResultTypeNotBool) { const std::string body = R"( %res1 = OpImageSparseTexelsResident %u32 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be bool scalar type")); } TEST_F(ValidateImage, MakeTexelVisibleKHRSuccessImageRead) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0002 %uniform_image_u32_2d_0002 %res1 = OpImageRead %u32vec4 %img %u32vec2_01 MakeTexelVisibleKHR|NonPrivateTexelKHR %u32_2 )"; const std::string extra = R"( OpCapability StorageImageReadWithoutFormat OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_3, "VulkanKHR") .c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateImage, MakeTexelVisibleKHRSuccessImageSparseRead) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0002 %uniform_image_f32_2d_0002 %res1 = OpImageSparseRead %struct_u32_f32vec4 %img %u32vec2_01 MakeTexelVisibleKHR|NonPrivateTexelKHR %u32_2 )"; const std::string extra = R"( OpCapability StorageImageReadWithoutFormat OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_3, "VulkanKHR") .c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateImage, MakeTexelVisibleKHRFailureOpcode) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_hh MakeTexelVisibleKHR|NonPrivateTexelKHR %u32_1 )"; const std::string extra = R"( OpCapability StorageImageReadWithoutFormat OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_3, "VulkanKHR") .c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Image Operand MakeTexelVisibleKHR can only be used with " "OpImageRead or OpImageSparseRead: OpImageSampleImplicitLod")); } TEST_F(ValidateImage, MakeTexelVisibleKHRFailureMissingNonPrivate) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0002 %uniform_image_u32_2d_0002 %res1 = OpImageRead %u32vec4 %img %u32vec2_01 MakeTexelVisibleKHR %u32_1 )"; const std::string extra = R"( OpCapability StorageImageReadWithoutFormat OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_3, "VulkanKHR") .c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Image Operand MakeTexelVisibleKHR requires " "NonPrivateTexelKHR is also specified: OpImageRead")); } TEST_F(ValidateImage, MakeTexelAvailableKHRSuccessImageWrite) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0002 %uniform_image_u32_2d_0002 OpImageWrite %img %u32vec2_01 %u32vec4_0123 MakeTexelAvailableKHR|NonPrivateTexelKHR %u32_2 )"; const std::string extra = R"( OpCapability StorageImageWriteWithoutFormat OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_3, "VulkanKHR") .c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateImage, MakeTexelAvailableKHRFailureOpcode) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_hh MakeTexelAvailableKHR|NonPrivateTexelKHR %u32_1 )"; const std::string extra = R"( OpCapability StorageImageReadWithoutFormat OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_3, "VulkanKHR") .c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Image Operand MakeTexelAvailableKHR can only be used " "with OpImageWrite: OpImageSampleImplicitLod")); } TEST_F(ValidateImage, MakeTexelAvailableKHRFailureMissingNonPrivate) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0002 %uniform_image_u32_2d_0002 OpImageWrite %img %u32vec2_01 %u32vec4_0123 MakeTexelAvailableKHR %u32_1 )"; const std::string extra = R"( OpCapability StorageImageWriteWithoutFormat OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_3, "VulkanKHR") .c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Image Operand MakeTexelAvailableKHR requires " "NonPrivateTexelKHR is also specified: OpImageWrite")); } TEST_F(ValidateImage, VulkanMemoryModelDeviceScopeImageWriteBad) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0002 %uniform_image_u32_2d_0002 OpImageWrite %img %u32vec2_01 %u32vec4_0123 MakeTexelAvailableKHR|NonPrivateTexelKHR %u32_1 )"; const std::string extra = R"( OpCapability StorageImageWriteWithoutFormat OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_3, "VulkanKHR") .c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Use of device scope with VulkanKHR memory model requires the " "VulkanMemoryModelDeviceScopeKHR capability")); } TEST_F(ValidateImage, VulkanMemoryModelDeviceScopeImageWriteGood) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0002 %uniform_image_u32_2d_0002 OpImageWrite %img %u32vec2_01 %u32vec4_0123 MakeTexelAvailableKHR|NonPrivateTexelKHR %u32_1 )"; const std::string extra = R"( OpCapability StorageImageWriteWithoutFormat OpCapability VulkanMemoryModelKHR OpCapability VulkanMemoryModelDeviceScopeKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_3, "VulkanKHR") .c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateImage, VulkanMemoryModelDeviceScopeImageReadBad) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0002 %uniform_image_u32_2d_0002 %res1 = OpImageRead %u32vec4 %img %u32vec2_01 MakeTexelVisibleKHR|NonPrivateTexelKHR %u32_1 )"; const std::string extra = R"( OpCapability StorageImageReadWithoutFormat OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_3, "VulkanKHR") .c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Use of device scope with VulkanKHR memory model requires the " "VulkanMemoryModelDeviceScopeKHR capability")); } TEST_F(ValidateImage, VulkanMemoryModelDeviceScopeImageReadGood) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0002 %uniform_image_u32_2d_0002 %res1 = OpImageRead %u32vec4 %img %u32vec2_01 MakeTexelVisibleKHR|NonPrivateTexelKHR %u32_1 )"; const std::string extra = R"( OpCapability StorageImageReadWithoutFormat OpCapability VulkanMemoryModelKHR OpCapability VulkanMemoryModelDeviceScopeKHR OpExtension "SPV_KHR_vulkan_memory_model" )"; CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_3, "VulkanKHR") .c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } // This example used to cause a seg fault on OpReturnValue, verifying it doesn't // anymore. TEST_F(ValidateImage, Issue2463NoSegFault) { const std::string spirv = R"( OpCapability Linkage OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 %void = OpTypeVoid %6 = OpTypeFunction %void %float = OpTypeFloat 32 %8 = OpTypeImage %float 3D 0 0 0 1 Unknown %_ptr_UniformConstant_8 = OpTypePointer UniformConstant %8 %10 = OpTypeSampler %_ptr_UniformConstant_10 = OpTypePointer UniformConstant %10 %12 = OpTypeSampledImage %8 %13 = OpTypeFunction %12 %_ptr_UniformConstant_8 %_ptr_UniformConstant_10 %23 = OpFunction %12 None %13 %24 = OpFunctionParameter %_ptr_UniformConstant_8 %25 = OpFunctionParameter %_ptr_UniformConstant_10 %26 = OpLabel %27 = OpLoad %8 %24 %28 = OpLoad %10 %25 %29 = OpSampledImage %12 %27 %28 OpReturnValue %29 OpFunctionEnd )"; CompileSuccessfully(spirv); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpSampledImage instruction must not appear as operand " "for OpReturnValue")); } TEST_F(ValidateImage, SignExtendV13Bad) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0002 %uniform_image_u32_2d_0002 %res1 = OpImageRead %u32vec4 %img %u32vec2_01 SignExtend )"; CompileSuccessfully( GenerateShaderCode(body, "", "Fragment", "", SPV_ENV_UNIVERSAL_1_3)); ASSERT_EQ(SPV_ERROR_WRONG_VERSION, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("SignExtend(4096) requires SPIR-V version 1.4 or later")); } TEST_F(ValidateImage, ZeroExtendV13Bad) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0002 %uniform_image_u32_2d_0002 %res1 = OpImageRead %u32vec4 %img %u32vec2_01 ZeroExtend )"; CompileSuccessfully( GenerateShaderCode(body, "", "Fragment", "", SPV_ENV_UNIVERSAL_1_3)); ASSERT_EQ(SPV_ERROR_WRONG_VERSION, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("ZeroExtend(8192) requires SPIR-V version 1.4 or later")); } TEST_F(ValidateImage, SignExtendScalarUIntTexelV14Good) { // Unsigned int sampled type const std::string body = R"( %img = OpLoad %type_image_u32_2d_0002 %uniform_image_u32_2d_0002 %res1 = OpImageRead %u32 %img %u32vec2_01 SignExtend )"; const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n"; CompileSuccessfully( GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_4), SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateImage, SignExtendScalarSIntTexelV14Good) { // Signed int sampled type const std::string body = R"( %img = OpLoad %type_image_s32_2d_0002 %uniform_image_s32_2d_0002 %res1 = OpImageRead %s32 %img %u32vec2_01 SignExtend )"; const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n"; CompileSuccessfully( GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_4), SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateImage, SignExtendScalarVectorUIntTexelV14Good) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0002 %uniform_image_u32_2d_0002 %res1 = OpImageRead %u32vec4 %img %u32vec2_01 SignExtend )"; const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n"; CompileSuccessfully( GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_4), SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateImage, SignExtendVectorSIntTexelV14Good) { const std::string body = R"( %img = OpLoad %type_image_s32_2d_0002 %uniform_image_s32_2d_0002 %res1 = OpImageRead %s32vec4 %img %u32vec2_01 SignExtend )"; const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n"; CompileSuccessfully( GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_4), SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), Eq("")); } // No negative tests for SignExtend since we don't truly know the // texel format. TEST_F(ValidateImage, ZeroExtendScalarUIntTexelV14Good) { // Unsigned int sampled type const std::string body = R"( %img = OpLoad %type_image_u32_2d_0002 %uniform_image_u32_2d_0002 %res1 = OpImageRead %u32 %img %u32vec2_01 ZeroExtend )"; const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n"; CompileSuccessfully( GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_4), SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateImage, ZeroExtendScalarSIntTexelV14Good) { // Zeroed int sampled type const std::string body = R"( %img = OpLoad %type_image_s32_2d_0002 %uniform_image_s32_2d_0002 %res1 = OpImageRead %s32 %img %u32vec2_01 ZeroExtend )"; const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n"; CompileSuccessfully( GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_4), SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateImage, ZeroExtendScalarVectorUIntTexelV14Good) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0002 %uniform_image_u32_2d_0002 %res1 = OpImageRead %u32vec4 %img %u32vec2_01 ZeroExtend )"; const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n"; CompileSuccessfully( GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_4), SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateImage, ZeroExtendVectorSIntTexelV14Good) { const std::string body = R"( %img = OpLoad %type_image_s32_2d_0002 %uniform_image_s32_2d_0002 %res1 = OpImageRead %s32vec4 %img %u32vec2_01 ZeroExtend )"; const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n"; CompileSuccessfully( GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_4), SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateImage, ReadLodAMDSuccess1) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0002 %uniform_image_u32_2d_0002 %res1 = OpImageRead %u32vec4 %img %u32vec2_01 Lod %u32_0 )"; const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n" "OpCapability ImageReadWriteLodAMD\n" "OpExtension \"SPV_AMD_shader_image_load_store_lod\"\n"; CompileSuccessfully( GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_1), SPV_ENV_UNIVERSAL_1_1); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_1)); } TEST_F(ValidateImage, ReadLodAMDSuccess2) { const std::string body = R"( %img = OpLoad %type_image_f32_1d_0002_rgba32f %uniform_image_f32_1d_0002_rgba32f %res1 = OpImageRead %f32vec4 %img %u32vec2_01 Lod %u32_0 )"; const std::string extra = "\nOpCapability Image1D\n" "OpCapability ImageReadWriteLodAMD\n" "OpExtension \"SPV_AMD_shader_image_load_store_lod\"\n"; CompileSuccessfully( GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_1), SPV_ENV_UNIVERSAL_1_1); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_1)); } TEST_F(ValidateImage, ReadLodAMDSuccess3) { const std::string body = R"( %img = OpLoad %type_image_f32_cube_0102_rgba32f %uniform_image_f32_cube_0102_rgba32f %res1 = OpImageRead %f32vec4 %img %u32vec3_012 Lod %u32_0 )"; const std::string extra = "\nOpCapability ImageCubeArray\n" "OpCapability ImageReadWriteLodAMD\n" "OpExtension \"SPV_AMD_shader_image_load_store_lod\"\n"; CompileSuccessfully( GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_1), SPV_ENV_UNIVERSAL_1_1); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_1)); } TEST_F(ValidateImage, ReadLodAMDNeedCapability) { const std::string body = R"( %img = OpLoad %type_image_f32_cube_0102_rgba32f %uniform_image_f32_cube_0102_rgba32f %res1 = OpImageRead %f32vec4 %img %u32vec3_012 Lod %u32_0 )"; const std::string extra = "\nOpCapability ImageCubeArray\n"; CompileSuccessfully( GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_1), SPV_ENV_UNIVERSAL_1_1); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_1)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Image Operand Lod can only be used with ExplicitLod " "opcodes and OpImageFetch")); } TEST_F(ValidateImage, WriteLodAMDSuccess1) { const std::string body = R"( %img = OpLoad %type_image_u32_2d_0002 %uniform_image_u32_2d_0002 OpImageWrite %img %u32vec2_01 %u32vec4_0123 Lod %u32_0 )"; const std::string extra = "\nOpCapability StorageImageWriteWithoutFormat\n" "OpCapability ImageReadWriteLodAMD\n" "OpExtension \"SPV_AMD_shader_image_load_store_lod\"\n"; CompileSuccessfully( GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_1), SPV_ENV_UNIVERSAL_1_1); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_1)); } TEST_F(ValidateImage, WriteLodAMDSuccess2) { const std::string body = R"( %img = OpLoad %type_image_f32_1d_0002_rgba32f %uniform_image_f32_1d_0002_rgba32f OpImageWrite %img %u32_1 %f32vec4_0000 Lod %u32_0 )"; const std::string extra = "\nOpCapability Image1D\n" "OpCapability ImageReadWriteLodAMD\n" "OpExtension \"SPV_AMD_shader_image_load_store_lod\"\n"; CompileSuccessfully( GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_1), SPV_ENV_UNIVERSAL_1_1); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_1)); } TEST_F(ValidateImage, WriteLodAMDSuccess3) { const std::string body = R"( %img = OpLoad %type_image_f32_cube_0102_rgba32f %uniform_image_f32_cube_0102_rgba32f OpImageWrite %img %u32vec3_012 %f32vec4_0000 Lod %u32_0 )"; const std::string extra = "\nOpCapability ImageCubeArray\n" "OpCapability ImageReadWriteLodAMD\n" "OpExtension \"SPV_AMD_shader_image_load_store_lod\"\n"; CompileSuccessfully( GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_1), SPV_ENV_UNIVERSAL_1_1); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_1)); } TEST_F(ValidateImage, WriteLodAMDNeedCapability) { const std::string body = R"( %img = OpLoad %type_image_f32_cube_0102_rgba32f %uniform_image_f32_cube_0102_rgba32f OpImageWrite %img %u32vec3_012 %f32vec4_0000 Lod %u32_0 )"; const std::string extra = "\nOpCapability ImageCubeArray\n"; CompileSuccessfully( GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_1), SPV_ENV_UNIVERSAL_1_1); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_1)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Image Operand Lod can only be used with ExplicitLod " "opcodes and OpImageFetch")); } TEST_F(ValidateImage, SparseReadLodAMDSuccess) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0002 %uniform_image_f32_2d_0002 %res1 = OpImageSparseRead %struct_u32_f32vec4 %img %u32vec2_01 Lod %u32_0 )"; const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n" "OpCapability ImageReadWriteLodAMD\n" "OpExtension \"SPV_AMD_shader_image_load_store_lod\"\n"; CompileSuccessfully( GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_1), SPV_ENV_UNIVERSAL_1_1); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_1)); } TEST_F(ValidateImage, SparseReadLodAMDNeedCapability) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0002 %uniform_image_f32_2d_0002 %res1 = OpImageSparseRead %struct_u32_f32vec4 %img %u32vec2_01 Lod %u32_0 )"; const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n"; CompileSuccessfully( GenerateShaderCode(body, extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_1), SPV_ENV_UNIVERSAL_1_1); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_1)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Image Operand Lod can only be used with ExplicitLod " "opcodes and OpImageFetch")); } TEST_F(ValidateImage, GatherBiasAMDSuccess) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageGather %f32vec4 %simg %f32vec4_0000 %u32_1 Bias %f32_1 )"; const std::string extra = R"( OpCapability ImageGatherBiasLodAMD OpExtension "SPV_AMD_texture_gather_bias_lod" )"; CompileSuccessfully(GenerateShaderCode(body, extra).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, GatherLodAMDSuccess) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageGather %f32vec4 %simg %f32vec4_0000 %u32_1 Lod %f32_1 )"; const std::string extra = R"( OpCapability ImageGatherBiasLodAMD OpExtension "SPV_AMD_texture_gather_bias_lod" )"; CompileSuccessfully(GenerateShaderCode(body, extra).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, SparseGatherBiasAMDSuccess) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSparseGather %struct_u32_f32vec4 %simg %f32vec4_0000 %u32_1 Bias %f32_1 )"; const std::string extra = R"( OpCapability ImageGatherBiasLodAMD OpExtension "SPV_AMD_texture_gather_bias_lod" )"; CompileSuccessfully(GenerateShaderCode(body, extra).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, SparseGatherLodAMDSuccess) { const std::string body = R"( %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 %sampler = OpLoad %type_sampler %uniform_sampler %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler %res1 = OpImageSparseGather %struct_u32_f32vec4 %simg %f32vec4_0000 %u32_1 Lod %f32_1 )"; const std::string extra = R"( OpCapability ImageGatherBiasLodAMD OpExtension "SPV_AMD_texture_gather_bias_lod" )"; CompileSuccessfully(GenerateShaderCode(body, extra).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } // No negative tests for ZeroExtend since we don't truly know the // texel format. // Tests for 64-bit images static const std::string capabilities_and_extensions_image64 = R"( OpCapability Int64ImageEXT OpExtension "SPV_EXT_shader_image_int64" )"; static const std::string capabilities_and_extensions_image64_atomic = R"( OpCapability Int64Atomics OpCapability Int64ImageEXT OpExtension "SPV_EXT_shader_image_int64" )"; static const std::string declarations_image64 = R"( %type_image_u64_buffer_0002_r64ui = OpTypeImage %u64 Buffer 0 0 0 2 R64ui %ptr_Image_u64 = OpTypePointer Image %u64 %ptr_image_u64_buffer_0002_r64ui = OpTypePointer Private %type_image_u64_buffer_0002_r64ui %private_image_u64_buffer_0002_r64ui = OpVariable %ptr_image_u64_buffer_0002_r64ui Private )"; static const std::string declarations_image64i = R"( %type_image_s64_buffer_0002_r64i = OpTypeImage %s64 Buffer 0 0 0 2 R64i %ptr_Image_s64 = OpTypePointer Image %s64 %ptr_image_s64_buffer_0002_r64i = OpTypePointer Private %type_image_s64_buffer_0002_r64i %private_image_s64_buffer_0002_r64i = OpVariable %ptr_image_s64_buffer_0002_r64i Private )"; TEST_F(ValidateImage, Image64MissingCapability) { CompileSuccessfully(GenerateShaderCode("", "", "Fragment", "", SPV_ENV_UNIVERSAL_1_3, "GLSL450", declarations_image64) .c_str()); ASSERT_EQ(SPV_ERROR_INVALID_CAPABILITY, ValidateInstructions()); } TEST_F(ValidateImage, Image64MissingExtension) { const std::string extra = R"( OpCapability Int64ImageEXT )"; CompileSuccessfully(GenerateShaderCode("", extra, "Fragment", "", SPV_ENV_UNIVERSAL_1_3, "GLSL450", declarations_image64) .c_str()); ASSERT_EQ(SPV_ERROR_MISSING_EXTENSION, ValidateInstructions()); } TEST_F(ValidateImage, ImageTexelPointer64Success) { const std::string body = R"( %texel_ptr = OpImageTexelPointer %ptr_Image_u64 %private_image_u64_buffer_0002_r64ui %u32_0 %u32_0 %sum = OpAtomicIAdd %u64 %texel_ptr %u32_1 %u32_0 %u64_1 )"; CompileSuccessfully( GenerateShaderCode(body, capabilities_and_extensions_image64_atomic, "Fragment", "", SPV_ENV_UNIVERSAL_1_3, "GLSL450", declarations_image64) .c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateImage, ImageTexelPointer64ResultTypeNotPointer) { const std::string body = R"( %texel_ptr = OpImageTexelPointer %type_image_u64_buffer_0002_r64ui %private_image_u64_buffer_0002_r64ui %u32_0 %u32_0 %sum = OpAtomicIAdd %u64 %texel_ptr %u32_1 %u32_0 %u64_1 )"; CompileSuccessfully( GenerateShaderCode(body, capabilities_and_extensions_image64_atomic, "Fragment", "", SPV_ENV_UNIVERSAL_1_3, "GLSL450", declarations_image64) .c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be a pointer")); } TEST_F(ValidateImage, ImageTexelPointer64ResultTypeNotImageClass) { const std::string body = R"( %texel_ptr = OpImageTexelPointer %ptr_image_f32_cube_0101 %private_image_u64_buffer_0002_r64ui %u32_0 %u32_0 %sum = OpAtomicIAdd %u64 %texel_ptr %u32_1 %u32_0 %u64_1 )"; CompileSuccessfully( GenerateShaderCode(body, capabilities_and_extensions_image64_atomic, "Fragment", "", SPV_ENV_UNIVERSAL_1_3, "GLSL450", declarations_image64) .c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be a pointer whose " "Storage Class operand is Image")); } TEST_F(ValidateImage, ImageTexelPointer64SampleNotZeroForImageWithMSZero) { const std::string body = R"( %texel_ptr = OpImageTexelPointer %ptr_Image_u64 %private_image_u64_buffer_0002_r64ui %u32_0 %u32_1 %sum = OpAtomicIAdd %u64 %texel_ptr %u32_1 %u32_0 %u64_1 )"; CompileSuccessfully( GenerateShaderCode(body, capabilities_and_extensions_image64_atomic, "Fragment", "", SPV_ENV_UNIVERSAL_1_3, "GLSL450", declarations_image64) .c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Sample for Image with MS 0 to be a valid " " for the value 0")); } TEST_F(ValidateImage, ImageTexelPointerR32uiSuccessVulkan) { const std::string body = R"( %texel_ptr = OpImageTexelPointer %ptr_Image_u32 %private_image_u32_buffer_0002_r32ui %u32_0 %u32_0 )"; spv_target_env env = SPV_ENV_VULKAN_1_0; CompileSuccessfully(GenerateShaderCode(body, "", "Fragment", "", env).c_str(), env); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(env)); } TEST_F(ValidateImage, ImageTexelPointerR32iSuccessVulkan) { const std::string& declarations = R"( %type_image_s32_buffer_0002_r32i = OpTypeImage %s32 Buffer 0 0 0 2 R32i %ptr_Image_s32 = OpTypePointer Image %s32 %ptr_image_s32_buffer_0002_r32i = OpTypePointer Private %type_image_s32_buffer_0002_r32i %private_image_s32_buffer_0002_r32i = OpVariable %ptr_image_s32_buffer_0002_r32i Private )"; const std::string body = R"( %texel_ptr = OpImageTexelPointer %ptr_Image_s32 %private_image_s32_buffer_0002_r32i %u32_0 %u32_0 )"; spv_target_env env = SPV_ENV_VULKAN_1_0; CompileSuccessfully( GenerateShaderCode(body, "", "Fragment", "", env, "GLSL450", declarations) .c_str(), env); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(env)); } TEST_F(ValidateImage, ImageTexelPointerR64uiSuccessVulkan) { const std::string body = R"( %texel_ptr = OpImageTexelPointer %ptr_Image_u64 %private_image_u64_buffer_0002_r64ui %u32_0 %u32_0 )"; spv_target_env env = SPV_ENV_VULKAN_1_0; CompileSuccessfully( GenerateShaderCode(body, capabilities_and_extensions_image64, "Fragment", "", env, "GLSL450", declarations_image64) .c_str(), env); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(env)); } TEST_F(ValidateImage, ImageTexelPointerR64iSuccessVulkan) { const std::string body = R"( %texel_ptr = OpImageTexelPointer %ptr_Image_s64 %private_image_s64_buffer_0002_r64i %u32_0 %u32_0 )"; spv_target_env env = SPV_ENV_VULKAN_1_0; CompileSuccessfully( GenerateShaderCode(body, capabilities_and_extensions_image64, "Fragment", "", env, "GLSL450", declarations_image64i) .c_str(), env); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(env)); } TEST_F(ValidateImage, ImageTexelPointerR32fSuccessVulkan) { const std::string& declarations = R"( %type_image_f32_buffer_0002_r32f = OpTypeImage %f32 Buffer 0 0 0 2 R32f %ptr_image_f32_buffer_0002_r32f = OpTypePointer Private %type_image_f32_buffer_0002_r32f %private_image_f32_buffer_0002_r32f = OpVariable %ptr_image_f32_buffer_0002_r32f Private )"; const std::string body = R"( %texel_ptr = OpImageTexelPointer %ptr_Image_f32 %private_image_f32_buffer_0002_r32f %u32_0 %u32_0 )"; spv_target_env env = SPV_ENV_VULKAN_1_0; CompileSuccessfully( GenerateShaderCode(body, "", "Fragment", "", env, "GLSL450", declarations) .c_str(), env); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(env)); } TEST_F(ValidateImage, ImageTexelPointerRgba32iVulkan) { const std::string& declarations = R"( %type_image_s32_buffer_0002_rgba32i = OpTypeImage %s32 Buffer 0 0 0 2 Rgba32i %ptr_Image_s32 = OpTypePointer Image %s32 %ptr_image_s32_buffer_0002_rgba32i = OpTypePointer Private %type_image_s32_buffer_0002_rgba32i %private_image_s32_buffer_0002_rgba32i = OpVariable %ptr_image_s32_buffer_0002_rgba32i Private )"; const std::string body = R"( %texel_ptr = OpImageTexelPointer %ptr_Image_s32 %private_image_s32_buffer_0002_rgba32i %u32_0 %u32_0 )"; spv_target_env env = SPV_ENV_VULKAN_1_0; CompileSuccessfully( GenerateShaderCode(body, "", "Fragment", "", env, "GLSL450", declarations) .c_str(), env); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(env)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpImageTexelPointer-04658")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected the Image Format in Image to be R64i, R64ui, " "R32f, R32i, or R32ui for Vulkan environment")); } TEST_F(ValidateImage, ImageTexelPointerRgba16fVulkan) { const std::string& declarations = R"( %type_image_s32_buffer_0002_rgba16f = OpTypeImage %s32 Buffer 0 0 0 2 Rgba16f %ptr_Image_s32 = OpTypePointer Image %s32 %ptr_image_s32_buffer_0002_rgba16f = OpTypePointer Private %type_image_s32_buffer_0002_rgba16f %private_image_s32_buffer_0002_rgba16f = OpVariable %ptr_image_s32_buffer_0002_rgba16f Private )"; const std::string body = R"( %texel_ptr = OpImageTexelPointer %ptr_Image_s32 %private_image_s32_buffer_0002_rgba16f %u32_0 %u32_0 )"; spv_target_env env = SPV_ENV_VULKAN_1_0; CompileSuccessfully( GenerateShaderCode(body, "", "Fragment", "", env, "GLSL450", declarations) .c_str(), env); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(env)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpImageTexelPointer-04658")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected the Image Format in Image to be R64i, R64ui, " "R32f, R32i, or R32ui for Vulkan environment")); } TEST_F(ValidateImage, ImageExecutionModeLimitationNoMode) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %2 " " %4 %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %12 = OpTypeImage %float 2D 0 0 0 1 Rgba8ui %13 = OpTypeSampledImage %12 %_ptr_UniformConstant_13 = OpTypePointer UniformConstant %13 %5 = OpVariable %_ptr_UniformConstant_13 UniformConstant %_ptr_Input_v4float = OpTypePointer Input %v4float %4 = OpVariable %_ptr_Input_v4float Input %v2float = OpTypeVector %float 2 %float_1_35631564en19 = OpConstant %float 1.35631564e-19 %2 = OpFunction %void None %8 %8224 = OpLabel %6 = OpLoad %13 %5 %19 = OpLoad %v4float %4 %20 = OpVectorShuffle %v2float %19 %19 0 1 %21 = OpVectorTimesScalar %v2float %20 %float_1_35631564en19 %65312 = OpImageSampleImplicitLod %v4float %6 %21 OpUnreachable OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("ImplicitLod instructions require " "DerivativeGroupQuadsKHR or DerivativeGroupLinearKHR " "execution mode for GLCompute, MeshEXT or TaskEXT " "execution model")); } TEST_F(ValidateImage, TypeSampledImageNotBufferPost1p6) { const std::string text = R"( OpCapability Shader OpCapability Linkage OpCapability SampledBuffer OpMemoryModel Logical GLSL450 %float = OpTypeFloat 32 %image = OpTypeImage %float Buffer 0 0 0 1 Unknown %sampled = OpTypeSampledImage %image )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_6); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_6)); EXPECT_THAT(getDiagnosticString(), HasSubstr("In SPIR-V 1.6 or later, sampled image dimension must " "not be Buffer")); } TEST_F(ValidateImage, NonTemporalImage) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 " " %4 %5 OpExecutionMode %2 OriginUpperLeft %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %12 = OpTypeImage %float 2D 0 0 0 1 Rgba8ui %13 = OpTypeSampledImage %12 %_ptr_UniformConstant_13 = OpTypePointer UniformConstant %13 %5 = OpVariable %_ptr_UniformConstant_13 UniformConstant %_ptr_Input_v4float = OpTypePointer Input %v4float %4 = OpVariable %_ptr_Input_v4float Input %v2float = OpTypeVector %float 2 %float_1_35631564en19 = OpConstant %float 1.35631564e-19 %2 = OpFunction %void None %8 %8224 = OpLabel %6 = OpLoad %13 %5 %19 = OpLoad %v4float %4 %20 = OpVectorShuffle %v2float %19 %19 0 1 %21 = OpVectorTimesScalar %v2float %20 %float_1_35631564en19 %65312 = OpImageSampleImplicitLod %v4float %6 %21 Nontemporal OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_6); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_6)); } TEST_F(ValidateImage, NVBindlessSamplerBuiltins) { const std::string text = R"( OpCapability Shader OpCapability Int64 OpCapability Image1D OpCapability BindlessTextureNV OpExtension "SPV_NV_bindless_texture" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpSamplerImageAddressingModeNV 64 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpName %main "main" OpName %s2D "s2D" OpName %textureHandle "textureHandle" OpName %i1D "i1D" OpName %s "s" OpName %temp "temp" %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %7 = OpTypeImage %float 2D 0 0 0 1 Unknown %8 = OpTypeSampledImage %7 %_ptr_Function_8 = OpTypePointer Function %8 %ulong = OpTypeInt 64 0 %_ptr_Private_ulong = OpTypePointer Private %ulong %textureHandle = OpVariable %_ptr_Private_ulong Private %16 = OpTypeImage %float 1D 0 0 0 2 Rgba32f %_ptr_Function_16 = OpTypePointer Function %16 %21 = OpTypeSampler %_ptr_Function_21 = OpTypePointer Function %21 %_ptr_Function_ulong = OpTypePointer Function %ulong %main = OpFunction %void None %3 %5 = OpLabel %s2D = OpVariable %_ptr_Function_8 Function %i1D = OpVariable %_ptr_Function_16 Function %s = OpVariable %_ptr_Function_21 Function %temp = OpVariable %_ptr_Function_ulong Function %14 = OpLoad %ulong %textureHandle %15 = OpConvertUToSampledImageNV %8 %14 OpStore %s2D %15 %19 = OpLoad %ulong %textureHandle %20 = OpConvertUToImageNV %16 %19 OpStore %i1D %20 %24 = OpLoad %ulong %textureHandle %25 = OpConvertUToSamplerNV %21 %24 OpStore %s %25 %28 = OpLoad %8 %s2D %29 = OpConvertSampledImageToUNV %ulong %28 OpStore %temp %29 %30 = OpLoad %16 %i1D %31 = OpConvertImageToUNV %ulong %30 OpStore %temp %31 %32 = OpLoad %21 %s %33 = OpConvertSamplerToUNV %ulong %32 OpStore %temp %33 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateImage, NVBindlessAddressingMode64) { std::string text = R"( OpCapability Shader OpCapability BindlessTextureNV OpExtension "SPV_NV_bindless_texture" OpMemoryModel Logical GLSL450 OpSamplerImageAddressingModeNV 64 OpEntryPoint GLCompute %func "main" %voidt = OpTypeVoid %uintt = OpTypeInt 32 0 %funct = OpTypeFunction %voidt %func = OpFunction %voidt None %funct %entry = OpLabel %udef = OpUndef %uintt OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateImage, NVBindlessAddressingMode32) { std::string text = R"( OpCapability Shader OpCapability BindlessTextureNV OpExtension "SPV_NV_bindless_texture" OpMemoryModel Logical GLSL450 OpSamplerImageAddressingModeNV 32 OpEntryPoint GLCompute %func "main" %voidt = OpTypeVoid %uintt = OpTypeInt 32 0 %funct = OpTypeFunction %voidt %func = OpFunction %voidt None %funct %entry = OpLabel %udef = OpUndef %uintt OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateImage, NVBindlessInvalidAddressingMode) { std::string text = R"( OpCapability Shader OpCapability BindlessTextureNV OpExtension "SPV_NV_bindless_texture" OpMemoryModel Logical GLSL450 OpSamplerImageAddressingModeNV 0 OpEntryPoint GLCompute %func "main" %voidt = OpTypeVoid %uintt = OpTypeInt 32 0 %funct = OpTypeFunction %voidt %func = OpFunction %voidt None %funct %entry = OpLabel %udef = OpUndef %uintt OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpSamplerImageAddressingModeNV bitwidth should be 64 or 32")); } TEST_F(ValidateImage, QCOMImageProcessingBlockMatchSADNoDecorationA) { std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpExtension "SPV_QCOM_image_processing" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 %6 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 1 OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 3 OpDecorate %6 DescriptorSet 0 OpDecorate %6 Binding 2 OpDecorate %6 BlockMatchTextureQCOM %void = OpTypeVoid %8 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_float = OpTypePointer Input %float %_ptr_Function_uint = OpTypePointer Function %uint %uint_4 = OpConstant %uint 4 %17 = OpConstantComposite %v2uint %uint_4 %uint_4 %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %19 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %4 = OpVariable %_ptr_UniformConstant_19 UniformConstant %21 = OpTypeSampler %_ptr_UniformConstant_21 = OpTypePointer UniformConstant %21 %5 = OpVariable %_ptr_UniformConstant_21 UniformConstant %23 = OpTypeSampledImage %19 %6 = OpVariable %_ptr_UniformConstant_19 UniformConstant %2 = OpFunction %void None %8 %24 = OpLabel %25 = OpVariable %_ptr_Function_v2uint Function %26 = OpLoad %19 %4 %27 = OpLoad %21 %5 %28 = OpSampledImage %23 %26 %27 %29 = OpLoad %v2uint %25 %30 = OpLoad %19 %6 %31 = OpLoad %21 %5 %32 = OpSampledImage %23 %30 %31 %33 = OpImageBlockMatchSADQCOM %v4float %28 %29 %32 %29 %29 OpStore %3 %33 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing decoration BlockMatchTextureQCOM")); } TEST_F(ValidateImage, QCOMImageProcessingBlockMatchSADNoDecorationB) { std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpExtension "SPV_QCOM_image_processing" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 %6 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 1 OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 3 OpDecorate %5 BlockMatchTextureQCOM OpDecorate %6 DescriptorSet 0 OpDecorate %6 Binding 2 %void = OpTypeVoid %8 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_float = OpTypePointer Input %float %_ptr_Function_uint = OpTypePointer Function %uint %uint_4 = OpConstant %uint 4 %17 = OpConstantComposite %v2uint %uint_4 %uint_4 %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %19 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %4 = OpVariable %_ptr_UniformConstant_19 UniformConstant %21 = OpTypeSampler %_ptr_UniformConstant_21 = OpTypePointer UniformConstant %21 %5 = OpVariable %_ptr_UniformConstant_21 UniformConstant %23 = OpTypeSampledImage %19 %6 = OpVariable %_ptr_UniformConstant_19 UniformConstant %2 = OpFunction %void None %8 %24 = OpLabel %25 = OpVariable %_ptr_Function_v2uint Function %26 = OpLoad %19 %4 %27 = OpLoad %21 %5 %28 = OpSampledImage %23 %26 %27 %29 = OpLoad %v2uint %25 %30 = OpLoad %19 %6 %31 = OpLoad %21 %5 %32 = OpSampledImage %23 %30 %31 %33 = OpImageBlockMatchSADQCOM %v4float %28 %29 %32 %29 %29 OpStore %3 %33 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing decoration BlockMatchTextureQCOM")); } TEST_F(ValidateImage, QCOMImageProcessingBlockMatchSADNoDecorationC) { std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpExtension "SPV_QCOM_image_processing" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 4 OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 5 OpDecorate %5 BlockMatchTextureQCOM %void = OpTypeVoid %7 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Input_float = OpTypePointer Input %float %_ptr_Function_uint = OpTypePointer Function %uint %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %18 = OpTypeImage %float 2D 0 0 0 1 Unknown %19 = OpTypeSampledImage %18 %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %4 = OpVariable %_ptr_UniformConstant_19 UniformConstant %5 = OpVariable %_ptr_UniformConstant_19 UniformConstant %21 = OpTypeImage %float 2D 0 1 0 1 Unknown %2 = OpFunction %void None %7 %22 = OpLabel %23 = OpVariable %_ptr_Function_v2uint Function %24 = OpLoad %19 %4 %25 = OpLoad %v2uint %23 %26 = OpLoad %19 %5 %27 = OpLoad %v2uint %23 %28 = OpLoad %v2uint %23 %29 = OpImageBlockMatchSADQCOM %v4float %24 %25 %26 %27 %28 OpStore %3 %29 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing decoration BlockMatchTextureQCOM")); } TEST_F(ValidateImage, QCOMImageProcessingBlockMatchSADNoDecorationD) { std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpExtension "SPV_QCOM_image_processing" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 4 OpDecorate %4 BlockMatchTextureQCOM OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 5 %void = OpTypeVoid %7 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Input_float = OpTypePointer Input %float %_ptr_Function_uint = OpTypePointer Function %uint %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %18 = OpTypeImage %float 2D 0 0 0 1 Unknown %19 = OpTypeSampledImage %18 %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %4 = OpVariable %_ptr_UniformConstant_19 UniformConstant %5 = OpVariable %_ptr_UniformConstant_19 UniformConstant %21 = OpTypeImage %float 2D 0 1 0 1 Unknown %2 = OpFunction %void None %7 %22 = OpLabel %23 = OpVariable %_ptr_Function_v2uint Function %24 = OpLoad %19 %4 %25 = OpLoad %v2uint %23 %26 = OpLoad %19 %5 %27 = OpLoad %v2uint %23 %28 = OpLoad %v2uint %23 %29 = OpImageBlockMatchSADQCOM %v4float %24 %25 %26 %27 %28 OpStore %3 %29 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing decoration BlockMatchTextureQCOM")); } TEST_F(ValidateImage, QCOMImageProcessingBlockMatchSSDNoDecorationA) { std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpExtension "SPV_QCOM_image_processing" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 %6 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 1 OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 3 OpDecorate %6 DescriptorSet 0 OpDecorate %6 Binding 2 OpDecorate %6 BlockMatchTextureQCOM %void = OpTypeVoid %8 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_float = OpTypePointer Input %float %_ptr_Function_uint = OpTypePointer Function %uint %uint_4 = OpConstant %uint 4 %17 = OpConstantComposite %v2uint %uint_4 %uint_4 %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %19 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %4 = OpVariable %_ptr_UniformConstant_19 UniformConstant %21 = OpTypeSampler %_ptr_UniformConstant_21 = OpTypePointer UniformConstant %21 %5 = OpVariable %_ptr_UniformConstant_21 UniformConstant %23 = OpTypeSampledImage %19 %6 = OpVariable %_ptr_UniformConstant_19 UniformConstant %2 = OpFunction %void None %8 %24 = OpLabel %25 = OpVariable %_ptr_Function_v2uint Function %26 = OpLoad %19 %4 %27 = OpLoad %21 %5 %28 = OpSampledImage %23 %26 %27 %29 = OpLoad %v2uint %25 %30 = OpLoad %19 %6 %31 = OpLoad %21 %5 %32 = OpSampledImage %23 %30 %31 %33 = OpImageBlockMatchSSDQCOM %v4float %28 %29 %32 %29 %29 OpStore %3 %33 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing decoration BlockMatchTextureQCOM")); } TEST_F(ValidateImage, QCOMImageProcessingBlockMatchSSDNoDecorationB) { std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpExtension "SPV_QCOM_image_processing" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 %6 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 1 OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 3 OpDecorate %5 BlockMatchTextureQCOM OpDecorate %6 DescriptorSet 0 OpDecorate %6 Binding 2 %void = OpTypeVoid %8 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_float = OpTypePointer Input %float %_ptr_Function_uint = OpTypePointer Function %uint %uint_4 = OpConstant %uint 4 %17 = OpConstantComposite %v2uint %uint_4 %uint_4 %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %19 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %4 = OpVariable %_ptr_UniformConstant_19 UniformConstant %21 = OpTypeSampler %_ptr_UniformConstant_21 = OpTypePointer UniformConstant %21 %5 = OpVariable %_ptr_UniformConstant_21 UniformConstant %23 = OpTypeSampledImage %19 %6 = OpVariable %_ptr_UniformConstant_19 UniformConstant %2 = OpFunction %void None %8 %24 = OpLabel %25 = OpVariable %_ptr_Function_v2uint Function %26 = OpLoad %19 %4 %27 = OpLoad %21 %5 %28 = OpSampledImage %23 %26 %27 %29 = OpLoad %v2uint %25 %30 = OpLoad %19 %6 %31 = OpLoad %21 %5 %32 = OpSampledImage %23 %30 %31 %33 = OpImageBlockMatchSSDQCOM %v4float %28 %29 %32 %29 %29 OpStore %3 %33 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing decoration BlockMatchTextureQCOM")); } TEST_F(ValidateImage, QCOMImageProcessingBlockMatchSSDNoDecorationC) { std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpExtension "SPV_QCOM_image_processing" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 4 OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 5 OpDecorate %5 BlockMatchTextureQCOM %void = OpTypeVoid %7 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Input_float = OpTypePointer Input %float %_ptr_Function_uint = OpTypePointer Function %uint %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %18 = OpTypeImage %float 2D 0 0 0 1 Unknown %19 = OpTypeSampledImage %18 %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %4 = OpVariable %_ptr_UniformConstant_19 UniformConstant %5 = OpVariable %_ptr_UniformConstant_19 UniformConstant %21 = OpTypeImage %float 2D 0 1 0 1 Unknown %2 = OpFunction %void None %7 %22 = OpLabel %23 = OpVariable %_ptr_Function_v2uint Function %24 = OpLoad %19 %4 %25 = OpLoad %v2uint %23 %26 = OpLoad %19 %5 %27 = OpLoad %v2uint %23 %28 = OpLoad %v2uint %23 %29 = OpImageBlockMatchSSDQCOM %v4float %24 %25 %26 %27 %28 OpStore %3 %29 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing decoration BlockMatchTextureQCOM")); } TEST_F(ValidateImage, QCOMImageProcessingBlockMatchSSDNoDecorationD) { std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpExtension "SPV_QCOM_image_processing" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 4 OpDecorate %4 BlockMatchTextureQCOM OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 5 %void = OpTypeVoid %7 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Input_float = OpTypePointer Input %float %_ptr_Function_uint = OpTypePointer Function %uint %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %18 = OpTypeImage %float 2D 0 0 0 1 Unknown %19 = OpTypeSampledImage %18 %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %4 = OpVariable %_ptr_UniformConstant_19 UniformConstant %5 = OpVariable %_ptr_UniformConstant_19 UniformConstant %21 = OpTypeImage %float 2D 0 1 0 1 Unknown %2 = OpFunction %void None %7 %22 = OpLabel %23 = OpVariable %_ptr_Function_v2uint Function %24 = OpLoad %19 %4 %25 = OpLoad %v2uint %23 %26 = OpLoad %19 %5 %27 = OpLoad %v2uint %23 %28 = OpLoad %v2uint %23 %29 = OpImageBlockMatchSSDQCOM %v4float %24 %25 %26 %27 %28 OpStore %3 %29 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing decoration BlockMatchTextureQCOM")); } TEST_F(ValidateImage, QCOMImageProcessingSampleWeightedNoDecorationA) { std::string text = R"( OpCapability Shader OpCapability TextureSampleWeightedQCOM OpExtension "SPV_QCOM_image_processing" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 %6 %7 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 1 OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 3 OpDecorate %6 Location 0 OpDecorate %7 DescriptorSet 0 OpDecorate %7 Binding 0 %void = OpTypeVoid %9 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %13 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_13 = OpTypePointer UniformConstant %13 %4 = OpVariable %_ptr_UniformConstant_13 UniformConstant %15 = OpTypeSampler %_ptr_UniformConstant_15 = OpTypePointer UniformConstant %15 %5 = OpVariable %_ptr_UniformConstant_15 UniformConstant %17 = OpTypeSampledImage %13 %_ptr_Input_v4float = OpTypePointer Input %v4float %6 = OpVariable %_ptr_Input_v4float Input %v2float = OpTypeVector %float 2 %20 = OpTypeImage %float 2D 0 1 0 1 Unknown %_ptr_UniformConstant_20 = OpTypePointer UniformConstant %20 %7 = OpVariable %_ptr_UniformConstant_20 UniformConstant %22 = OpTypeSampledImage %20 %_ptr_UniformConstant_17 = OpTypePointer UniformConstant %17 %2 = OpFunction %void None %9 %24 = OpLabel %25 = OpLoad %13 %4 %26 = OpLoad %15 %5 %27 = OpSampledImage %17 %25 %26 %28 = OpLoad %v4float %6 %29 = OpVectorShuffle %v2float %28 %28 0 1 %30 = OpLoad %20 %7 %31 = OpLoad %15 %5 %32 = OpSampledImage %22 %30 %31 %33 = OpImageSampleWeightedQCOM %v4float %27 %29 %32 OpStore %3 %33 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing decoration WeightTextureQCOM")); } TEST_F(ValidateImage, QCOMImageProcessingSampleWeightedNoDecorationB) { std::string text = R"( OpCapability Shader OpCapability TextureSampleWeightedQCOM OpExtension "SPV_QCOM_image_processing" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 %6 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 Location 0 OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 4 OpDecorate %6 DescriptorSet 0 OpDecorate %6 Binding 5 %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %12 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_12 = OpTypePointer UniformConstant %12 %14 = OpTypeSampler %_ptr_UniformConstant_14 = OpTypePointer UniformConstant %14 %16 = OpTypeSampledImage %12 %_ptr_Input_v4float = OpTypePointer Input %v4float %4 = OpVariable %_ptr_Input_v4float Input %v2float = OpTypeVector %float 2 %19 = OpTypeImage %float 2D 0 1 0 1 Unknown %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %21 = OpTypeSampledImage %19 %_ptr_UniformConstant_16 = OpTypePointer UniformConstant %16 %5 = OpVariable %_ptr_UniformConstant_16 UniformConstant %_ptr_UniformConstant_21 = OpTypePointer UniformConstant %21 %6 = OpVariable %_ptr_UniformConstant_21 UniformConstant %2 = OpFunction %void None %8 %24 = OpLabel %25 = OpLoad %16 %5 %26 = OpLoad %v4float %4 %27 = OpVectorShuffle %v2float %26 %26 0 1 %28 = OpLoad %21 %6 %29 = OpImageSampleWeightedQCOM %v4float %25 %27 %28 OpStore %3 %29 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing decoration WeightTextureQCOM")); } TEST_F(ValidateImage, QCOMImageProcessingBlockMatchWindowSADInvalidUseA) { std::string text = R"( ; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 11 ; Bound: 79 ; Schema: 0 OpCapability Shader OpCapability TextureBlockMatchQCOM OpExtension "SPV_QCOM_image_processing" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %100 %101 %102 %103 %104 OpExecutionMode %main OriginUpperLeft OpDecorate %100 Location 0 OpDecorate %101 Location 0 OpDecorate %102 DescriptorSet 0 OpDecorate %102 Binding 1 OpDecorate %103 DescriptorSet 0 OpDecorate %103 Binding 3 OpDecorate %104 DescriptorSet 0 OpDecorate %104 Binding 2 OpDecorate %102 BlockMatchTextureQCOM OpDecorate %104 BlockMatchTextureQCOM %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %100 = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %101 = OpVariable %_ptr_Output_v4float Output %42 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_42 = OpTypePointer UniformConstant %42 %102 = OpVariable %_ptr_UniformConstant_42 UniformConstant %46 = OpTypeSampler %_ptr_UniformConstant_46 = OpTypePointer UniformConstant %46 %103 = OpVariable %_ptr_UniformConstant_46 UniformConstant %50 = OpTypeSampledImage %42 %104 = OpVariable %_ptr_UniformConstant_42 UniformConstant %v2float = OpTypeVector %float 2 %main = OpFunction %void None %3 %5 = OpLabel %15 = OpVariable %_ptr_Function_v2uint Function %45 = OpLoad %42 %102 %49 = OpLoad %46 %103 %51 = OpSampledImage %50 %45 %49 %52 = OpLoad %v2uint %15 %54 = OpLoad %42 %104 %55 = OpLoad %46 %103 %56 = OpSampledImage %50 %54 %55 %57 = OpLoad %v2uint %15 %58 = OpLoad %v2uint %15 %59 = OpImageBlockMatchSADQCOM %v4float %51 %52 %56 %57 %58 OpStore %101 %59 %69 = OpLoad %42 %102 %70 = OpLoad %46 %103 %71 = OpSampledImage %50 %69 %70 %73 = OpLoad %v4float %100 %74 = OpVectorShuffle %v2float %73 %73 0 0 %75 = OpImageSampleImplicitLod %v4float %71 %74 OpStore %101 %75 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Illegal use of QCOM image processing decorated texture")); } TEST_F(ValidateImage, QCOMImageProcessingBlockMatchSADInvalidUseB) { std::string text = R"( ; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 11 ; Bound: 79 ; Schema: 0 OpCapability Shader OpCapability TextureBlockMatchQCOM OpExtension "SPV_QCOM_image_processing" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %100 %101 %102 %103 %104 OpExecutionMode %main OriginUpperLeft OpDecorate %100 Location 0 OpDecorate %101 Location 0 OpDecorate %102 DescriptorSet 0 OpDecorate %102 Binding 1 OpDecorate %103 DescriptorSet 0 OpDecorate %103 Binding 3 OpDecorate %104 DescriptorSet 0 OpDecorate %104 Binding 2 OpDecorate %102 BlockMatchTextureQCOM OpDecorate %104 BlockMatchTextureQCOM %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %100 = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %101 = OpVariable %_ptr_Output_v4float Output %42 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_42 = OpTypePointer UniformConstant %42 %102 = OpVariable %_ptr_UniformConstant_42 UniformConstant %46 = OpTypeSampler %_ptr_UniformConstant_46 = OpTypePointer UniformConstant %46 %103 = OpVariable %_ptr_UniformConstant_46 UniformConstant %50 = OpTypeSampledImage %42 %104 = OpVariable %_ptr_UniformConstant_42 UniformConstant %v2float = OpTypeVector %float 2 %main = OpFunction %void None %3 %5 = OpLabel %15 = OpVariable %_ptr_Function_v2uint Function %45 = OpLoad %42 %102 %49 = OpLoad %46 %103 %51 = OpSampledImage %50 %45 %49 %52 = OpLoad %v2uint %15 %54 = OpLoad %42 %104 %55 = OpLoad %46 %103 %56 = OpSampledImage %50 %54 %55 %57 = OpLoad %v2uint %15 %58 = OpLoad %v2uint %15 %59 = OpImageBlockMatchSADQCOM %v4float %51 %52 %56 %57 %58 OpStore %101 %59 %69 = OpLoad %42 %104 %70 = OpLoad %46 %103 %71 = OpSampledImage %50 %69 %70 %73 = OpLoad %v4float %100 %74 = OpVectorShuffle %v2float %73 %73 0 0 %75 = OpImageSampleImplicitLod %v4float %71 %74 OpStore %101 %75 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Illegal use of QCOM image processing decorated texture")); } TEST_F(ValidateImage, QCOMImageProcessingBlockMatchSADInvalidUseC) { std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpExtension "SPV_QCOM_image_processing" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 %6 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 Location 0 OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 4 OpDecorate %6 DescriptorSet 0 OpDecorate %6 Binding 5 OpDecorate %5 BlockMatchTextureQCOM OpDecorate %6 BlockMatchTextureQCOM %void = OpTypeVoid %8 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %3 = OpVariable %_ptr_Input_v4float Input %uint_4 = OpConstant %uint 4 %16 = OpConstantComposite %v2uint %uint_4 %uint_4 %_ptr_Output_v4float = OpTypePointer Output %v4float %4 = OpVariable %_ptr_Output_v4float Output %18 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_18 = OpTypePointer UniformConstant %18 %20 = OpTypeSampledImage %18 %_ptr_UniformConstant_20 = OpTypePointer UniformConstant %20 %5 = OpVariable %_ptr_UniformConstant_20 UniformConstant %6 = OpVariable %_ptr_UniformConstant_20 UniformConstant %v2float = OpTypeVector %float 2 %23 = OpTypeImage %float 2D 0 1 0 1 Unknown %2 = OpFunction %void None %8 %24 = OpLabel %25 = OpVariable %_ptr_Function_v2uint Function OpStore %25 %16 %26 = OpLoad %20 %5 %27 = OpLoad %v2uint %25 %28 = OpLoad %20 %6 %29 = OpLoad %v2uint %25 %30 = OpLoad %v2uint %25 %31 = OpImageBlockMatchSADQCOM %v4float %26 %27 %28 %29 %30 OpStore %4 %31 %32 = OpLoad %20 %5 %33 = OpLoad %v4float %3 %34 = OpVectorShuffle %v2float %33 %33 0 2 %35 = OpImageSampleImplicitLod %v4float %32 %34 OpStore %4 %35 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Illegal use of QCOM image processing decorated texture")); } TEST_F(ValidateImage, QCOMImageProcessingBlockMatchSADInvalidUseD) { std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpExtension "SPV_QCOM_image_processing" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 %6 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 Location 0 OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 4 OpDecorate %6 DescriptorSet 0 OpDecorate %6 Binding 5 OpDecorate %5 BlockMatchTextureQCOM OpDecorate %6 BlockMatchTextureQCOM %void = OpTypeVoid %8 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %3 = OpVariable %_ptr_Input_v4float Input %uint_4 = OpConstant %uint 4 %16 = OpConstantComposite %v2uint %uint_4 %uint_4 %_ptr_Output_v4float = OpTypePointer Output %v4float %4 = OpVariable %_ptr_Output_v4float Output %18 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_18 = OpTypePointer UniformConstant %18 %20 = OpTypeSampledImage %18 %_ptr_UniformConstant_20 = OpTypePointer UniformConstant %20 %5 = OpVariable %_ptr_UniformConstant_20 UniformConstant %6 = OpVariable %_ptr_UniformConstant_20 UniformConstant %v2float = OpTypeVector %float 2 %23 = OpTypeImage %float 2D 0 1 0 1 Unknown %2 = OpFunction %void None %8 %24 = OpLabel %25 = OpVariable %_ptr_Function_v2uint Function OpStore %25 %16 %26 = OpLoad %20 %5 %27 = OpLoad %v2uint %25 %28 = OpLoad %20 %6 %29 = OpLoad %v2uint %25 %30 = OpLoad %v2uint %25 %31 = OpImageBlockMatchSADQCOM %v4float %26 %27 %28 %29 %30 OpStore %4 %31 %32 = OpLoad %20 %6 %33 = OpLoad %v4float %3 %34 = OpVectorShuffle %v2float %33 %33 0 2 %35 = OpImageSampleImplicitLod %v4float %32 %34 OpStore %4 %35 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Illegal use of QCOM image processing decorated texture")); } TEST_F(ValidateImage, QCOMImageProcessingBlockMatchSSDInvalidUseA) { std::string text = R"( ; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 11 ; Bound: 79 ; Schema: 0 OpCapability Shader OpCapability TextureBlockMatchQCOM OpExtension "SPV_QCOM_image_processing" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %100 %101 %102 %103 %104 OpExecutionMode %main OriginUpperLeft OpDecorate %100 Location 0 OpDecorate %101 Location 0 OpDecorate %102 DescriptorSet 0 OpDecorate %102 Binding 1 OpDecorate %103 DescriptorSet 0 OpDecorate %103 Binding 3 OpDecorate %104 DescriptorSet 0 OpDecorate %104 Binding 2 OpDecorate %102 BlockMatchTextureQCOM OpDecorate %104 BlockMatchTextureQCOM %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %100 = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %101 = OpVariable %_ptr_Output_v4float Output %42 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_42 = OpTypePointer UniformConstant %42 %102 = OpVariable %_ptr_UniformConstant_42 UniformConstant %46 = OpTypeSampler %_ptr_UniformConstant_46 = OpTypePointer UniformConstant %46 %103 = OpVariable %_ptr_UniformConstant_46 UniformConstant %50 = OpTypeSampledImage %42 %104 = OpVariable %_ptr_UniformConstant_42 UniformConstant %v2float = OpTypeVector %float 2 %main = OpFunction %void None %3 %5 = OpLabel %15 = OpVariable %_ptr_Function_v2uint Function %45 = OpLoad %42 %102 %49 = OpLoad %46 %103 %51 = OpSampledImage %50 %45 %49 %52 = OpLoad %v2uint %15 %54 = OpLoad %42 %104 %55 = OpLoad %46 %103 %56 = OpSampledImage %50 %54 %55 %57 = OpLoad %v2uint %15 %58 = OpLoad %v2uint %15 %59 = OpImageBlockMatchSSDQCOM %v4float %51 %52 %56 %57 %58 OpStore %101 %59 %69 = OpLoad %42 %102 %70 = OpLoad %46 %103 %71 = OpSampledImage %50 %69 %70 %73 = OpLoad %v4float %100 %74 = OpVectorShuffle %v2float %73 %73 0 0 %75 = OpImageSampleImplicitLod %v4float %71 %74 OpStore %101 %75 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Illegal use of QCOM image processing decorated texture")); } TEST_F(ValidateImage, QCOMImageProcessingBlockMatchSSDInvalidUseB) { std::string text = R"( ; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 11 ; Bound: 79 ; Schema: 0 OpCapability Shader OpCapability TextureBlockMatchQCOM OpExtension "SPV_QCOM_image_processing" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %100 %101 %102 %103 %104 OpExecutionMode %main OriginUpperLeft OpDecorate %100 Location 0 OpDecorate %101 Location 0 OpDecorate %102 DescriptorSet 0 OpDecorate %102 Binding 1 OpDecorate %103 DescriptorSet 0 OpDecorate %103 Binding 3 OpDecorate %104 DescriptorSet 0 OpDecorate %104 Binding 2 OpDecorate %102 BlockMatchTextureQCOM OpDecorate %104 BlockMatchTextureQCOM %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %100 = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %101 = OpVariable %_ptr_Output_v4float Output %42 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_42 = OpTypePointer UniformConstant %42 %102 = OpVariable %_ptr_UniformConstant_42 UniformConstant %46 = OpTypeSampler %_ptr_UniformConstant_46 = OpTypePointer UniformConstant %46 %103 = OpVariable %_ptr_UniformConstant_46 UniformConstant %50 = OpTypeSampledImage %42 %104 = OpVariable %_ptr_UniformConstant_42 UniformConstant %v2float = OpTypeVector %float 2 %main = OpFunction %void None %3 %5 = OpLabel %15 = OpVariable %_ptr_Function_v2uint Function %45 = OpLoad %42 %102 %49 = OpLoad %46 %103 %51 = OpSampledImage %50 %45 %49 %52 = OpLoad %v2uint %15 %54 = OpLoad %42 %104 %55 = OpLoad %46 %103 %56 = OpSampledImage %50 %54 %55 %57 = OpLoad %v2uint %15 %58 = OpLoad %v2uint %15 %59 = OpImageBlockMatchSSDQCOM %v4float %51 %52 %56 %57 %58 OpStore %101 %59 %69 = OpLoad %42 %104 %70 = OpLoad %46 %103 %71 = OpSampledImage %50 %69 %70 %73 = OpLoad %v4float %100 %74 = OpVectorShuffle %v2float %73 %73 0 0 %75 = OpImageSampleImplicitLod %v4float %71 %74 OpStore %101 %75 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Illegal use of QCOM image processing decorated texture")); } TEST_F(ValidateImage, QCOMImageProcessingBlockMatchSSDInvalidUseC) { std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpExtension "SPV_QCOM_image_processing" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 %6 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 Location 0 OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 4 OpDecorate %6 DescriptorSet 0 OpDecorate %6 Binding 5 OpDecorate %5 BlockMatchTextureQCOM OpDecorate %6 BlockMatchTextureQCOM %void = OpTypeVoid %8 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %3 = OpVariable %_ptr_Input_v4float Input %uint_4 = OpConstant %uint 4 %16 = OpConstantComposite %v2uint %uint_4 %uint_4 %_ptr_Output_v4float = OpTypePointer Output %v4float %4 = OpVariable %_ptr_Output_v4float Output %18 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_18 = OpTypePointer UniformConstant %18 %20 = OpTypeSampledImage %18 %_ptr_UniformConstant_20 = OpTypePointer UniformConstant %20 %5 = OpVariable %_ptr_UniformConstant_20 UniformConstant %6 = OpVariable %_ptr_UniformConstant_20 UniformConstant %v2float = OpTypeVector %float 2 %23 = OpTypeImage %float 2D 0 1 0 1 Unknown %2 = OpFunction %void None %8 %24 = OpLabel %25 = OpVariable %_ptr_Function_v2uint Function OpStore %25 %16 %26 = OpLoad %20 %5 %27 = OpLoad %v2uint %25 %28 = OpLoad %20 %6 %29 = OpLoad %v2uint %25 %30 = OpLoad %v2uint %25 %31 = OpImageBlockMatchSSDQCOM %v4float %26 %27 %28 %29 %30 OpStore %4 %31 %32 = OpLoad %20 %5 %33 = OpLoad %v4float %3 %34 = OpVectorShuffle %v2float %33 %33 0 2 %35 = OpImageSampleImplicitLod %v4float %32 %34 OpStore %4 %35 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Illegal use of QCOM image processing decorated texture")); } TEST_F(ValidateImage, QCOMImageProcessingBlockMatchSSDInvalidUseD) { std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpExtension "SPV_QCOM_image_processing" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 %6 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 Location 0 OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 4 OpDecorate %6 DescriptorSet 0 OpDecorate %6 Binding 5 OpDecorate %5 BlockMatchTextureQCOM OpDecorate %6 BlockMatchTextureQCOM %void = OpTypeVoid %8 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %3 = OpVariable %_ptr_Input_v4float Input %uint_4 = OpConstant %uint 4 %16 = OpConstantComposite %v2uint %uint_4 %uint_4 %_ptr_Output_v4float = OpTypePointer Output %v4float %4 = OpVariable %_ptr_Output_v4float Output %18 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_18 = OpTypePointer UniformConstant %18 %20 = OpTypeSampledImage %18 %_ptr_UniformConstant_20 = OpTypePointer UniformConstant %20 %5 = OpVariable %_ptr_UniformConstant_20 UniformConstant %6 = OpVariable %_ptr_UniformConstant_20 UniformConstant %v2float = OpTypeVector %float 2 %23 = OpTypeImage %float 2D 0 1 0 1 Unknown %2 = OpFunction %void None %8 %24 = OpLabel %25 = OpVariable %_ptr_Function_v2uint Function OpStore %25 %16 %26 = OpLoad %20 %5 %27 = OpLoad %v2uint %25 %28 = OpLoad %20 %6 %29 = OpLoad %v2uint %25 %30 = OpLoad %v2uint %25 %31 = OpImageBlockMatchSSDQCOM %v4float %26 %27 %28 %29 %30 OpStore %4 %31 %32 = OpLoad %20 %6 %33 = OpLoad %v4float %3 %34 = OpVectorShuffle %v2float %33 %33 0 2 %35 = OpImageSampleImplicitLod %v4float %32 %34 OpStore %4 %35 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Illegal use of QCOM image processing decorated texture")); } TEST_F(ValidateImage, QCOMImageProcessingSampleWeightedInvalidUseA) { std::string text = R"( OpCapability Shader OpCapability TextureSampleWeightedQCOM OpExtension "SPV_QCOM_image_processing" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 %6 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 Location 0 OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 4 OpDecorate %6 DescriptorSet 0 OpDecorate %6 Binding 5 OpDecorate %6 WeightTextureQCOM %void = OpTypeVoid %8 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %12 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_12 = OpTypePointer UniformConstant %12 %14 = OpTypeSampledImage %12 %_ptr_Input_v4float = OpTypePointer Input %v4float %4 = OpVariable %_ptr_Input_v4float Input %v2float = OpTypeVector %float 2 %17 = OpTypeImage %float 2D 0 1 0 1 Unknown %_ptr_UniformConstant_17 = OpTypePointer UniformConstant %17 %19 = OpTypeSampledImage %17 %_ptr_UniformConstant_14 = OpTypePointer UniformConstant %14 %5 = OpVariable %_ptr_UniformConstant_14 UniformConstant %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %6 = OpVariable %_ptr_UniformConstant_19 UniformConstant %v3float = OpTypeVector %float 3 %2 = OpFunction %void None %8 %23 = OpLabel %24 = OpLoad %v4float %4 %25 = OpVectorShuffle %v2float %24 %24 0 1 %26 = OpLoad %14 %5 %27 = OpLoad %v4float %4 %28 = OpVectorShuffle %v2float %27 %27 0 1 %29 = OpLoad %19 %6 %30 = OpImageSampleWeightedQCOM %v4float %26 %28 %29 OpStore %3 %30 %31 = OpLoad %19 %6 %32 = OpLoad %v4float %4 %33 = OpVectorShuffle %v3float %32 %32 0 1 0 %34 = OpCompositeExtract %float %33 0 %35 = OpCompositeExtract %float %33 1 %36 = OpCompositeExtract %float %33 2 %37 = OpCompositeConstruct %v3float %34 %35 %36 %38 = OpImageSampleImplicitLod %v4float %31 %37 OpStore %3 %38 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Illegal use of QCOM image processing decorated texture")); } TEST_F(ValidateImage, QCOMImageProcessingSampleWeightedInvalidUseB) { std::string text = R"( OpCapability Shader OpCapability TextureSampleWeightedQCOM OpExtension "SPV_QCOM_image_processing" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 %6 %7 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 1 OpDecorate %6 DescriptorSet 0 OpDecorate %6 Binding 3 OpDecorate %4 Location 0 OpDecorate %7 DescriptorSet 0 OpDecorate %7 Binding 0 OpDecorate %7 WeightTextureQCOM %void = OpTypeVoid %9 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %13 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_13 = OpTypePointer UniformConstant %13 %5 = OpVariable %_ptr_UniformConstant_13 UniformConstant %15 = OpTypeSampler %_ptr_UniformConstant_15 = OpTypePointer UniformConstant %15 %6 = OpVariable %_ptr_UniformConstant_15 UniformConstant %17 = OpTypeSampledImage %13 %_ptr_Input_v4float = OpTypePointer Input %v4float %4 = OpVariable %_ptr_Input_v4float Input %v2float = OpTypeVector %float 2 %20 = OpTypeImage %float 2D 0 1 0 1 Unknown %_ptr_UniformConstant_20 = OpTypePointer UniformConstant %20 %7 = OpVariable %_ptr_UniformConstant_20 UniformConstant %22 = OpTypeSampledImage %20 %v3float = OpTypeVector %float 3 %2 = OpFunction %void None %9 %24 = OpLabel %25 = OpLoad %13 %5 %26 = OpLoad %15 %6 %27 = OpSampledImage %17 %25 %26 %28 = OpLoad %v4float %4 %29 = OpVectorShuffle %v2float %28 %28 0 1 %30 = OpLoad %20 %7 %31 = OpLoad %15 %6 %32 = OpSampledImage %22 %30 %31 %33 = OpImageSampleWeightedQCOM %v4float %27 %29 %32 OpStore %3 %33 %34 = OpLoad %20 %7 %35 = OpLoad %15 %6 %36 = OpSampledImage %22 %34 %35 %37 = OpLoad %v4float %4 %38 = OpVectorShuffle %v3float %37 %37 0 1 0 %39 = OpCompositeExtract %float %38 0 %40 = OpCompositeExtract %float %38 1 %41 = OpCompositeExtract %float %38 2 %42 = OpCompositeConstruct %v3float %39 %40 %41 %43 = OpImageSampleImplicitLod %v4float %36 %42 OpStore %3 %43 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Illegal use of QCOM image processing decorated texture")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchWindowSADNoDecorTargetIT) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 4 OpDecorate %4 BlockMatchSamplerQCOM OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 5 OpDecorate %5 BlockMatchTextureQCOM OpDecorate %5 BlockMatchSamplerQCOM %void = OpTypeVoid %7 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Input_float = OpTypePointer Input %float %_ptr_Function_uint = OpTypePointer Function %uint %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %18 = OpTypeImage %float 2D 0 0 0 1 Unknown %19 = OpTypeSampledImage %18 %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %4 = OpVariable %_ptr_UniformConstant_19 UniformConstant %5 = OpVariable %_ptr_UniformConstant_19 UniformConstant %21 = OpTypeImage %float 2D 0 1 0 1 Unknown %2 = OpFunction %void None %7 %22 = OpLabel %23 = OpVariable %_ptr_Function_v2uint Function %24 = OpLoad %19 %4 %25 = OpLoad %v2uint %23 %26 = OpLoad %19 %5 %27 = OpLoad %v2uint %23 %28 = OpLoad %v2uint %23 %29 = OpImageBlockMatchWindowSADQCOM %v4float %24 %25 %26 %27 %28 OpStore %3 %29 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing decoration BlockMatchTextureQCOM")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchWindowSADNoDecorTargetIS) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 4 OpDecorate %4 BlockMatchTextureQCOM OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 5 OpDecorate %5 BlockMatchTextureQCOM OpDecorate %5 BlockMatchSamplerQCOM %void = OpTypeVoid %7 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Input_float = OpTypePointer Input %float %_ptr_Function_uint = OpTypePointer Function %uint %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %18 = OpTypeImage %float 2D 0 0 0 1 Unknown %19 = OpTypeSampledImage %18 %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %4 = OpVariable %_ptr_UniformConstant_19 UniformConstant %5 = OpVariable %_ptr_UniformConstant_19 UniformConstant %21 = OpTypeImage %float 2D 0 1 0 1 Unknown %2 = OpFunction %void None %7 %22 = OpLabel %23 = OpVariable %_ptr_Function_v2uint Function %24 = OpLoad %19 %4 %25 = OpLoad %v2uint %23 %26 = OpLoad %19 %5 %27 = OpLoad %v2uint %23 %28 = OpLoad %v2uint %23 %29 = OpImageBlockMatchWindowSADQCOM %v4float %24 %25 %26 %27 %28 OpStore %3 %29 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing decoration BlockMatchSamplerQCOM")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchWindowSADNoDecorRefIT) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 4 OpDecorate %4 BlockMatchTextureQCOM OpDecorate %4 BlockMatchSamplerQCOM OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 5 OpDecorate %5 BlockMatchSamplerQCOM %void = OpTypeVoid %7 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Input_float = OpTypePointer Input %float %_ptr_Function_uint = OpTypePointer Function %uint %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %18 = OpTypeImage %float 2D 0 0 0 1 Unknown %19 = OpTypeSampledImage %18 %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %4 = OpVariable %_ptr_UniformConstant_19 UniformConstant %5 = OpVariable %_ptr_UniformConstant_19 UniformConstant %21 = OpTypeImage %float 2D 0 1 0 1 Unknown %2 = OpFunction %void None %7 %22 = OpLabel %23 = OpVariable %_ptr_Function_v2uint Function %24 = OpLoad %19 %4 %25 = OpLoad %v2uint %23 %26 = OpLoad %19 %5 %27 = OpLoad %v2uint %23 %28 = OpLoad %v2uint %23 %29 = OpImageBlockMatchWindowSADQCOM %v4float %24 %25 %26 %27 %28 OpStore %3 %29 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing decoration BlockMatchTextureQCOM")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchWindowSADNoDecorRefIS) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 4 OpDecorate %4 BlockMatchTextureQCOM OpDecorate %4 BlockMatchSamplerQCOM OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 5 OpDecorate %5 BlockMatchTextureQCOM %void = OpTypeVoid %7 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Input_float = OpTypePointer Input %float %_ptr_Function_uint = OpTypePointer Function %uint %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %18 = OpTypeImage %float 2D 0 0 0 1 Unknown %19 = OpTypeSampledImage %18 %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %4 = OpVariable %_ptr_UniformConstant_19 UniformConstant %5 = OpVariable %_ptr_UniformConstant_19 UniformConstant %21 = OpTypeImage %float 2D 0 1 0 1 Unknown %2 = OpFunction %void None %7 %22 = OpLabel %23 = OpVariable %_ptr_Function_v2uint Function %24 = OpLoad %19 %4 %25 = OpLoad %v2uint %23 %26 = OpLoad %19 %5 %27 = OpLoad %v2uint %23 %28 = OpLoad %v2uint %23 %29 = OpImageBlockMatchWindowSADQCOM %v4float %24 %25 %26 %27 %28 OpStore %3 %29 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing decoration BlockMatchSamplerQCOM")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchWindowSADNoDecorTargetNIT) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 %6 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 1 OpDecorate %4 BlockMatchSamplerQCOM OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 3 OpDecorate %6 DescriptorSet 0 OpDecorate %6 Binding 2 OpDecorate %6 BlockMatchTextureQCOM OpDecorate %6 BlockMatchSamplerQCOM %void = OpTypeVoid %8 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_float = OpTypePointer Input %float %_ptr_Function_uint = OpTypePointer Function %uint %uint_4 = OpConstant %uint 4 %17 = OpConstantComposite %v2uint %uint_4 %uint_4 %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %19 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %4 = OpVariable %_ptr_UniformConstant_19 UniformConstant %21 = OpTypeSampler %_ptr_UniformConstant_21 = OpTypePointer UniformConstant %21 %5 = OpVariable %_ptr_UniformConstant_21 UniformConstant %23 = OpTypeSampledImage %19 %6 = OpVariable %_ptr_UniformConstant_19 UniformConstant %2 = OpFunction %void None %8 %24 = OpLabel %25 = OpVariable %_ptr_Function_v2uint Function %26 = OpLoad %19 %4 %27 = OpLoad %21 %5 %28 = OpSampledImage %23 %26 %27 %29 = OpLoad %v2uint %25 %30 = OpLoad %19 %6 %31 = OpLoad %21 %5 %32 = OpSampledImage %23 %30 %31 %33 = OpImageBlockMatchWindowSADQCOM %v4float %28 %29 %32 %29 %29 OpStore %3 %33 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing decoration BlockMatchTextureQCOM")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchWindowSADNoDecorTargetNIS) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 %6 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 1 OpDecorate %4 BlockMatchTextureQCOM OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 3 OpDecorate %6 DescriptorSet 0 OpDecorate %6 Binding 2 OpDecorate %6 BlockMatchTextureQCOM OpDecorate %6 BlockMatchSamplerQCOM %void = OpTypeVoid %8 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_float = OpTypePointer Input %float %_ptr_Function_uint = OpTypePointer Function %uint %uint_4 = OpConstant %uint 4 %17 = OpConstantComposite %v2uint %uint_4 %uint_4 %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %19 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %4 = OpVariable %_ptr_UniformConstant_19 UniformConstant %21 = OpTypeSampler %_ptr_UniformConstant_21 = OpTypePointer UniformConstant %21 %5 = OpVariable %_ptr_UniformConstant_21 UniformConstant %23 = OpTypeSampledImage %19 %6 = OpVariable %_ptr_UniformConstant_19 UniformConstant %2 = OpFunction %void None %8 %24 = OpLabel %25 = OpVariable %_ptr_Function_v2uint Function %26 = OpLoad %19 %4 %27 = OpLoad %21 %5 %28 = OpSampledImage %23 %26 %27 %29 = OpLoad %v2uint %25 %30 = OpLoad %19 %6 %31 = OpLoad %21 %5 %32 = OpSampledImage %23 %30 %31 %33 = OpImageBlockMatchWindowSADQCOM %v4float %28 %29 %32 %29 %29 OpStore %3 %33 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing decoration BlockMatchSamplerQCOM")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchWindowSADNoDecorRefNIT) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 %6 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 1 OpDecorate %4 BlockMatchTextureQCOM OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 3 OpDecorate %5 BlockMatchSamplerQCOM OpDecorate %6 DescriptorSet 0 OpDecorate %6 Binding 2 OpDecorate %6 BlockMatchSamplerQCOM %void = OpTypeVoid %8 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_float = OpTypePointer Input %float %_ptr_Function_uint = OpTypePointer Function %uint %uint_4 = OpConstant %uint 4 %17 = OpConstantComposite %v2uint %uint_4 %uint_4 %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %19 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %4 = OpVariable %_ptr_UniformConstant_19 UniformConstant %21 = OpTypeSampler %_ptr_UniformConstant_21 = OpTypePointer UniformConstant %21 %5 = OpVariable %_ptr_UniformConstant_21 UniformConstant %23 = OpTypeSampledImage %19 %6 = OpVariable %_ptr_UniformConstant_19 UniformConstant %2 = OpFunction %void None %8 %24 = OpLabel %25 = OpVariable %_ptr_Function_v2uint Function %26 = OpLoad %19 %4 %27 = OpLoad %21 %5 %28 = OpSampledImage %23 %26 %27 %29 = OpLoad %v2uint %25 %30 = OpLoad %19 %6 %31 = OpLoad %21 %5 %32 = OpSampledImage %23 %30 %31 %33 = OpImageBlockMatchWindowSADQCOM %v4float %28 %29 %32 %29 %29 OpStore %3 %33 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing decoration BlockMatchTextureQCOM")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchWindowSADNoDecorRefNIS) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 %6 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 1 OpDecorate %4 BlockMatchTextureQCOM OpDecorate %4 BlockMatchSamplerQCOM OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 3 OpDecorate %6 DescriptorSet 0 OpDecorate %6 Binding 2 OpDecorate %6 BlockMatchTextureQCOM %void = OpTypeVoid %8 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_float = OpTypePointer Input %float %_ptr_Function_uint = OpTypePointer Function %uint %uint_4 = OpConstant %uint 4 %17 = OpConstantComposite %v2uint %uint_4 %uint_4 %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %19 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %4 = OpVariable %_ptr_UniformConstant_19 UniformConstant %21 = OpTypeSampler %_ptr_UniformConstant_21 = OpTypePointer UniformConstant %21 %5 = OpVariable %_ptr_UniformConstant_21 UniformConstant %23 = OpTypeSampledImage %19 %6 = OpVariable %_ptr_UniformConstant_19 UniformConstant %2 = OpFunction %void None %8 %24 = OpLabel %25 = OpVariable %_ptr_Function_v2uint Function %26 = OpLoad %19 %4 %27 = OpLoad %21 %5 %28 = OpSampledImage %23 %26 %27 %29 = OpLoad %v2uint %25 %30 = OpLoad %19 %6 %31 = OpLoad %21 %5 %32 = OpSampledImage %23 %30 %31 %33 = OpImageBlockMatchWindowSADQCOM %v4float %28 %29 %32 %29 %29 OpStore %3 %33 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing decoration BlockMatchSamplerQCOM")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchWindowSSDNoDecorTargetIT) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 4 OpDecorate %4 BlockMatchSamplerQCOM OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 5 OpDecorate %5 BlockMatchTextureQCOM OpDecorate %5 BlockMatchSamplerQCOM %void = OpTypeVoid %7 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Input_float = OpTypePointer Input %float %_ptr_Function_uint = OpTypePointer Function %uint %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %18 = OpTypeImage %float 2D 0 0 0 1 Unknown %19 = OpTypeSampledImage %18 %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %4 = OpVariable %_ptr_UniformConstant_19 UniformConstant %5 = OpVariable %_ptr_UniformConstant_19 UniformConstant %21 = OpTypeImage %float 2D 0 1 0 1 Unknown %2 = OpFunction %void None %7 %22 = OpLabel %23 = OpVariable %_ptr_Function_v2uint Function %24 = OpLoad %19 %4 %25 = OpLoad %v2uint %23 %26 = OpLoad %19 %5 %27 = OpLoad %v2uint %23 %28 = OpLoad %v2uint %23 %29 = OpImageBlockMatchWindowSSDQCOM %v4float %24 %25 %26 %27 %28 OpStore %3 %29 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing decoration BlockMatchTextureQCOM")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchWindowSSDNoDecorTargetIS) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 4 OpDecorate %4 BlockMatchTextureQCOM OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 5 OpDecorate %5 BlockMatchTextureQCOM OpDecorate %5 BlockMatchSamplerQCOM %void = OpTypeVoid %7 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Input_float = OpTypePointer Input %float %_ptr_Function_uint = OpTypePointer Function %uint %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %18 = OpTypeImage %float 2D 0 0 0 1 Unknown %19 = OpTypeSampledImage %18 %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %4 = OpVariable %_ptr_UniformConstant_19 UniformConstant %5 = OpVariable %_ptr_UniformConstant_19 UniformConstant %21 = OpTypeImage %float 2D 0 1 0 1 Unknown %2 = OpFunction %void None %7 %22 = OpLabel %23 = OpVariable %_ptr_Function_v2uint Function %24 = OpLoad %19 %4 %25 = OpLoad %v2uint %23 %26 = OpLoad %19 %5 %27 = OpLoad %v2uint %23 %28 = OpLoad %v2uint %23 %29 = OpImageBlockMatchWindowSSDQCOM %v4float %24 %25 %26 %27 %28 OpStore %3 %29 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing decoration BlockMatchSamplerQCOM")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchWindowSSDNoDecorRefIT) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 4 OpDecorate %4 BlockMatchTextureQCOM OpDecorate %4 BlockMatchSamplerQCOM OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 5 OpDecorate %5 BlockMatchSamplerQCOM %void = OpTypeVoid %7 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Input_float = OpTypePointer Input %float %_ptr_Function_uint = OpTypePointer Function %uint %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %18 = OpTypeImage %float 2D 0 0 0 1 Unknown %19 = OpTypeSampledImage %18 %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %4 = OpVariable %_ptr_UniformConstant_19 UniformConstant %5 = OpVariable %_ptr_UniformConstant_19 UniformConstant %21 = OpTypeImage %float 2D 0 1 0 1 Unknown %2 = OpFunction %void None %7 %22 = OpLabel %23 = OpVariable %_ptr_Function_v2uint Function %24 = OpLoad %19 %4 %25 = OpLoad %v2uint %23 %26 = OpLoad %19 %5 %27 = OpLoad %v2uint %23 %28 = OpLoad %v2uint %23 %29 = OpImageBlockMatchWindowSSDQCOM %v4float %24 %25 %26 %27 %28 OpStore %3 %29 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing decoration BlockMatchTextureQCOM")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchWindowSSDNoDecorRefIS) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 4 OpDecorate %4 BlockMatchTextureQCOM OpDecorate %4 BlockMatchSamplerQCOM OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 5 OpDecorate %5 BlockMatchTextureQCOM %void = OpTypeVoid %7 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Input_float = OpTypePointer Input %float %_ptr_Function_uint = OpTypePointer Function %uint %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %18 = OpTypeImage %float 2D 0 0 0 1 Unknown %19 = OpTypeSampledImage %18 %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %4 = OpVariable %_ptr_UniformConstant_19 UniformConstant %5 = OpVariable %_ptr_UniformConstant_19 UniformConstant %21 = OpTypeImage %float 2D 0 1 0 1 Unknown %2 = OpFunction %void None %7 %22 = OpLabel %23 = OpVariable %_ptr_Function_v2uint Function %24 = OpLoad %19 %4 %25 = OpLoad %v2uint %23 %26 = OpLoad %19 %5 %27 = OpLoad %v2uint %23 %28 = OpLoad %v2uint %23 %29 = OpImageBlockMatchWindowSSDQCOM %v4float %24 %25 %26 %27 %28 OpStore %3 %29 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing decoration BlockMatchSamplerQCOM")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchWindowSSDNoDecorTargetNIT) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 %6 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 1 OpDecorate %4 BlockMatchSamplerQCOM OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 3 OpDecorate %6 DescriptorSet 0 OpDecorate %6 Binding 2 OpDecorate %6 BlockMatchTextureQCOM OpDecorate %6 BlockMatchSamplerQCOM %void = OpTypeVoid %8 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_float = OpTypePointer Input %float %_ptr_Function_uint = OpTypePointer Function %uint %uint_4 = OpConstant %uint 4 %17 = OpConstantComposite %v2uint %uint_4 %uint_4 %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %19 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %4 = OpVariable %_ptr_UniformConstant_19 UniformConstant %21 = OpTypeSampler %_ptr_UniformConstant_21 = OpTypePointer UniformConstant %21 %5 = OpVariable %_ptr_UniformConstant_21 UniformConstant %23 = OpTypeSampledImage %19 %6 = OpVariable %_ptr_UniformConstant_19 UniformConstant %2 = OpFunction %void None %8 %24 = OpLabel %25 = OpVariable %_ptr_Function_v2uint Function %26 = OpLoad %19 %4 %27 = OpLoad %21 %5 %28 = OpSampledImage %23 %26 %27 %29 = OpLoad %v2uint %25 %30 = OpLoad %19 %6 %31 = OpLoad %21 %5 %32 = OpSampledImage %23 %30 %31 %33 = OpImageBlockMatchWindowSSDQCOM %v4float %28 %29 %32 %29 %29 OpStore %3 %33 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing decoration BlockMatchTextureQCOM")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchWindowSSDNoDecorTargetNIS) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 %6 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 1 OpDecorate %4 BlockMatchTextureQCOM OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 3 OpDecorate %6 DescriptorSet 0 OpDecorate %6 Binding 2 OpDecorate %6 BlockMatchTextureQCOM OpDecorate %6 BlockMatchSamplerQCOM %void = OpTypeVoid %8 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_float = OpTypePointer Input %float %_ptr_Function_uint = OpTypePointer Function %uint %uint_4 = OpConstant %uint 4 %17 = OpConstantComposite %v2uint %uint_4 %uint_4 %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %19 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %4 = OpVariable %_ptr_UniformConstant_19 UniformConstant %21 = OpTypeSampler %_ptr_UniformConstant_21 = OpTypePointer UniformConstant %21 %5 = OpVariable %_ptr_UniformConstant_21 UniformConstant %23 = OpTypeSampledImage %19 %6 = OpVariable %_ptr_UniformConstant_19 UniformConstant %2 = OpFunction %void None %8 %24 = OpLabel %25 = OpVariable %_ptr_Function_v2uint Function %26 = OpLoad %19 %4 %27 = OpLoad %21 %5 %28 = OpSampledImage %23 %26 %27 %29 = OpLoad %v2uint %25 %30 = OpLoad %19 %6 %31 = OpLoad %21 %5 %32 = OpSampledImage %23 %30 %31 %33 = OpImageBlockMatchWindowSSDQCOM %v4float %28 %29 %32 %29 %29 OpStore %3 %33 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing decoration BlockMatchSamplerQCOM")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchWindowSSDNoDecorRefNIT) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 %6 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 1 OpDecorate %4 BlockMatchTextureQCOM OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 3 OpDecorate %5 BlockMatchSamplerQCOM OpDecorate %6 DescriptorSet 0 OpDecorate %6 Binding 2 OpDecorate %6 BlockMatchSamplerQCOM %void = OpTypeVoid %8 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_float = OpTypePointer Input %float %_ptr_Function_uint = OpTypePointer Function %uint %uint_4 = OpConstant %uint 4 %17 = OpConstantComposite %v2uint %uint_4 %uint_4 %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %19 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %4 = OpVariable %_ptr_UniformConstant_19 UniformConstant %21 = OpTypeSampler %_ptr_UniformConstant_21 = OpTypePointer UniformConstant %21 %5 = OpVariable %_ptr_UniformConstant_21 UniformConstant %23 = OpTypeSampledImage %19 %6 = OpVariable %_ptr_UniformConstant_19 UniformConstant %2 = OpFunction %void None %8 %24 = OpLabel %25 = OpVariable %_ptr_Function_v2uint Function %26 = OpLoad %19 %4 %27 = OpLoad %21 %5 %28 = OpSampledImage %23 %26 %27 %29 = OpLoad %v2uint %25 %30 = OpLoad %19 %6 %31 = OpLoad %21 %5 %32 = OpSampledImage %23 %30 %31 %33 = OpImageBlockMatchWindowSSDQCOM %v4float %28 %29 %32 %29 %29 OpStore %3 %33 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing decoration BlockMatchTextureQCOM")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchWindowSSDNoDecorRefNIS) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 %6 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 1 OpDecorate %4 BlockMatchTextureQCOM OpDecorate %4 BlockMatchSamplerQCOM OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 3 OpDecorate %6 DescriptorSet 0 OpDecorate %6 Binding 2 OpDecorate %6 BlockMatchTextureQCOM %void = OpTypeVoid %8 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_float = OpTypePointer Input %float %_ptr_Function_uint = OpTypePointer Function %uint %uint_4 = OpConstant %uint 4 %17 = OpConstantComposite %v2uint %uint_4 %uint_4 %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %19 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %4 = OpVariable %_ptr_UniformConstant_19 UniformConstant %21 = OpTypeSampler %_ptr_UniformConstant_21 = OpTypePointer UniformConstant %21 %5 = OpVariable %_ptr_UniformConstant_21 UniformConstant %23 = OpTypeSampledImage %19 %6 = OpVariable %_ptr_UniformConstant_19 UniformConstant %2 = OpFunction %void None %8 %24 = OpLabel %25 = OpVariable %_ptr_Function_v2uint Function %26 = OpLoad %19 %4 %27 = OpLoad %21 %5 %28 = OpSampledImage %23 %26 %27 %29 = OpLoad %v2uint %25 %30 = OpLoad %19 %6 %31 = OpLoad %21 %5 %32 = OpSampledImage %23 %30 %31 %33 = OpImageBlockMatchWindowSSDQCOM %v4float %28 %29 %32 %29 %29 OpStore %3 %33 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing decoration BlockMatchSamplerQCOM")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchGatherSADNoDecorTargetIT) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 4 OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 5 OpDecorate %5 BlockMatchTextureQCOM %void = OpTypeVoid %7 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Input_float = OpTypePointer Input %float %_ptr_Function_uint = OpTypePointer Function %uint %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %18 = OpTypeImage %float 2D 0 0 0 1 Unknown %19 = OpTypeSampledImage %18 %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %4 = OpVariable %_ptr_UniformConstant_19 UniformConstant %5 = OpVariable %_ptr_UniformConstant_19 UniformConstant %21 = OpTypeImage %float 2D 0 1 0 1 Unknown %2 = OpFunction %void None %7 %22 = OpLabel %23 = OpVariable %_ptr_Function_v2uint Function %24 = OpLoad %19 %4 %25 = OpLoad %v2uint %23 %26 = OpLoad %19 %5 %27 = OpLoad %v2uint %23 %28 = OpLoad %v2uint %23 %29 = OpImageBlockMatchGatherSADQCOM %v4float %24 %25 %26 %27 %28 OpStore %3 %29 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing decoration BlockMatchTextureQCOM")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchGatherSADNoDecorRefIT) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 4 OpDecorate %4 BlockMatchTextureQCOM OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 5 %void = OpTypeVoid %7 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Input_float = OpTypePointer Input %float %_ptr_Function_uint = OpTypePointer Function %uint %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %18 = OpTypeImage %float 2D 0 0 0 1 Unknown %19 = OpTypeSampledImage %18 %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %4 = OpVariable %_ptr_UniformConstant_19 UniformConstant %5 = OpVariable %_ptr_UniformConstant_19 UniformConstant %21 = OpTypeImage %float 2D 0 1 0 1 Unknown %2 = OpFunction %void None %7 %22 = OpLabel %23 = OpVariable %_ptr_Function_v2uint Function %24 = OpLoad %19 %4 %25 = OpLoad %v2uint %23 %26 = OpLoad %19 %5 %27 = OpLoad %v2uint %23 %28 = OpLoad %v2uint %23 %29 = OpImageBlockMatchGatherSADQCOM %v4float %24 %25 %26 %27 %28 OpStore %3 %29 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing decoration BlockMatchTextureQCOM")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchGatherSADNoDecorTargetNIT) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 %6 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 1 OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 3 OpDecorate %6 DescriptorSet 0 OpDecorate %6 Binding 2 OpDecorate %6 BlockMatchTextureQCOM %void = OpTypeVoid %8 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_float = OpTypePointer Input %float %_ptr_Function_uint = OpTypePointer Function %uint %uint_4 = OpConstant %uint 4 %17 = OpConstantComposite %v2uint %uint_4 %uint_4 %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %19 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %4 = OpVariable %_ptr_UniformConstant_19 UniformConstant %21 = OpTypeSampler %_ptr_UniformConstant_21 = OpTypePointer UniformConstant %21 %5 = OpVariable %_ptr_UniformConstant_21 UniformConstant %23 = OpTypeSampledImage %19 %6 = OpVariable %_ptr_UniformConstant_19 UniformConstant %2 = OpFunction %void None %8 %24 = OpLabel %25 = OpVariable %_ptr_Function_v2uint Function %26 = OpLoad %19 %4 %27 = OpLoad %21 %5 %28 = OpSampledImage %23 %26 %27 %29 = OpLoad %v2uint %25 %30 = OpLoad %19 %6 %31 = OpLoad %21 %5 %32 = OpSampledImage %23 %30 %31 %33 = OpImageBlockMatchGatherSADQCOM %v4float %28 %29 %32 %29 %29 OpStore %3 %33 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing decoration BlockMatchTextureQCOM")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchGatherSADNoDecorRefNIT) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 %6 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 1 OpDecorate %4 BlockMatchTextureQCOM OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 3 OpDecorate %6 DescriptorSet 0 OpDecorate %6 Binding 2 %void = OpTypeVoid %8 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_float = OpTypePointer Input %float %_ptr_Function_uint = OpTypePointer Function %uint %uint_4 = OpConstant %uint 4 %17 = OpConstantComposite %v2uint %uint_4 %uint_4 %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %19 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %4 = OpVariable %_ptr_UniformConstant_19 UniformConstant %21 = OpTypeSampler %_ptr_UniformConstant_21 = OpTypePointer UniformConstant %21 %5 = OpVariable %_ptr_UniformConstant_21 UniformConstant %23 = OpTypeSampledImage %19 %6 = OpVariable %_ptr_UniformConstant_19 UniformConstant %2 = OpFunction %void None %8 %24 = OpLabel %25 = OpVariable %_ptr_Function_v2uint Function %26 = OpLoad %19 %4 %27 = OpLoad %21 %5 %28 = OpSampledImage %23 %26 %27 %29 = OpLoad %v2uint %25 %30 = OpLoad %19 %6 %31 = OpLoad %21 %5 %32 = OpSampledImage %23 %30 %31 %33 = OpImageBlockMatchGatherSADQCOM %v4float %28 %29 %32 %29 %29 OpStore %3 %33 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing decoration BlockMatchTextureQCOM")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchGatherSSDNoDecorTargetIT) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 4 OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 5 OpDecorate %5 BlockMatchTextureQCOM %void = OpTypeVoid %7 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Input_float = OpTypePointer Input %float %_ptr_Function_uint = OpTypePointer Function %uint %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %18 = OpTypeImage %float 2D 0 0 0 1 Unknown %19 = OpTypeSampledImage %18 %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %4 = OpVariable %_ptr_UniformConstant_19 UniformConstant %5 = OpVariable %_ptr_UniformConstant_19 UniformConstant %21 = OpTypeImage %float 2D 0 1 0 1 Unknown %2 = OpFunction %void None %7 %22 = OpLabel %23 = OpVariable %_ptr_Function_v2uint Function %24 = OpLoad %19 %4 %25 = OpLoad %v2uint %23 %26 = OpLoad %19 %5 %27 = OpLoad %v2uint %23 %28 = OpLoad %v2uint %23 %29 = OpImageBlockMatchGatherSSDQCOM %v4float %24 %25 %26 %27 %28 OpStore %3 %29 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing decoration BlockMatchTextureQCOM")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchGatherSSDNoDecorRefIT) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 4 OpDecorate %4 BlockMatchTextureQCOM OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 5 %void = OpTypeVoid %7 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %_ptr_Input_float = OpTypePointer Input %float %_ptr_Function_uint = OpTypePointer Function %uint %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %18 = OpTypeImage %float 2D 0 0 0 1 Unknown %19 = OpTypeSampledImage %18 %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %4 = OpVariable %_ptr_UniformConstant_19 UniformConstant %5 = OpVariable %_ptr_UniformConstant_19 UniformConstant %21 = OpTypeImage %float 2D 0 1 0 1 Unknown %2 = OpFunction %void None %7 %22 = OpLabel %23 = OpVariable %_ptr_Function_v2uint Function %24 = OpLoad %19 %4 %25 = OpLoad %v2uint %23 %26 = OpLoad %19 %5 %27 = OpLoad %v2uint %23 %28 = OpLoad %v2uint %23 %29 = OpImageBlockMatchGatherSSDQCOM %v4float %24 %25 %26 %27 %28 OpStore %3 %29 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing decoration BlockMatchTextureQCOM")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchGatherSSDNoDecorTargetNIT) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 %6 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 1 OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 3 OpDecorate %6 DescriptorSet 0 OpDecorate %6 Binding 2 OpDecorate %6 BlockMatchTextureQCOM %void = OpTypeVoid %8 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_float = OpTypePointer Input %float %_ptr_Function_uint = OpTypePointer Function %uint %uint_4 = OpConstant %uint 4 %17 = OpConstantComposite %v2uint %uint_4 %uint_4 %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %19 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %4 = OpVariable %_ptr_UniformConstant_19 UniformConstant %21 = OpTypeSampler %_ptr_UniformConstant_21 = OpTypePointer UniformConstant %21 %5 = OpVariable %_ptr_UniformConstant_21 UniformConstant %23 = OpTypeSampledImage %19 %6 = OpVariable %_ptr_UniformConstant_19 UniformConstant %2 = OpFunction %void None %8 %24 = OpLabel %25 = OpVariable %_ptr_Function_v2uint Function %26 = OpLoad %19 %4 %27 = OpLoad %21 %5 %28 = OpSampledImage %23 %26 %27 %29 = OpLoad %v2uint %25 %30 = OpLoad %19 %6 %31 = OpLoad %21 %5 %32 = OpSampledImage %23 %30 %31 %33 = OpImageBlockMatchGatherSSDQCOM %v4float %28 %29 %32 %29 %29 OpStore %3 %33 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing decoration BlockMatchTextureQCOM")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchGatherSSDNoDecorRefNIT) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 %6 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 DescriptorSet 0 OpDecorate %4 Binding 1 OpDecorate %4 BlockMatchTextureQCOM OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 3 OpDecorate %6 DescriptorSet 0 OpDecorate %6 Binding 2 %void = OpTypeVoid %8 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_float = OpTypePointer Input %float %_ptr_Function_uint = OpTypePointer Function %uint %uint_4 = OpConstant %uint 4 %17 = OpConstantComposite %v2uint %uint_4 %uint_4 %_ptr_Output_v4float = OpTypePointer Output %v4float %3 = OpVariable %_ptr_Output_v4float Output %19 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_19 = OpTypePointer UniformConstant %19 %4 = OpVariable %_ptr_UniformConstant_19 UniformConstant %21 = OpTypeSampler %_ptr_UniformConstant_21 = OpTypePointer UniformConstant %21 %5 = OpVariable %_ptr_UniformConstant_21 UniformConstant %23 = OpTypeSampledImage %19 %6 = OpVariable %_ptr_UniformConstant_19 UniformConstant %2 = OpFunction %void None %8 %24 = OpLabel %25 = OpVariable %_ptr_Function_v2uint Function %26 = OpLoad %19 %4 %27 = OpLoad %21 %5 %28 = OpSampledImage %23 %26 %27 %29 = OpLoad %v2uint %25 %30 = OpLoad %19 %6 %31 = OpLoad %21 %5 %32 = OpSampledImage %23 %30 %31 %33 = OpImageBlockMatchGatherSSDQCOM %v4float %28 %29 %32 %29 %29 OpStore %3 %33 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing decoration BlockMatchTextureQCOM")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchWindowSADInvalidUseTargetI) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 %6 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 Location 0 OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 4 OpDecorate %6 DescriptorSet 0 OpDecorate %6 Binding 5 OpDecorate %5 BlockMatchTextureQCOM OpDecorate %5 BlockMatchSamplerQCOM OpDecorate %6 BlockMatchTextureQCOM OpDecorate %6 BlockMatchSamplerQCOM %void = OpTypeVoid %8 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %3 = OpVariable %_ptr_Input_v4float Input %uint_4 = OpConstant %uint 4 %16 = OpConstantComposite %v2uint %uint_4 %uint_4 %_ptr_Output_v4float = OpTypePointer Output %v4float %4 = OpVariable %_ptr_Output_v4float Output %18 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_18 = OpTypePointer UniformConstant %18 %20 = OpTypeSampledImage %18 %_ptr_UniformConstant_20 = OpTypePointer UniformConstant %20 %5 = OpVariable %_ptr_UniformConstant_20 UniformConstant %6 = OpVariable %_ptr_UniformConstant_20 UniformConstant %v2float = OpTypeVector %float 2 %23 = OpTypeImage %float 2D 0 1 0 1 Unknown %2 = OpFunction %void None %8 %24 = OpLabel %25 = OpVariable %_ptr_Function_v2uint Function OpStore %25 %16 %26 = OpLoad %20 %5 %27 = OpLoad %v2uint %25 %28 = OpLoad %20 %6 %29 = OpLoad %v2uint %25 %30 = OpLoad %v2uint %25 %31 = OpImageBlockMatchWindowSADQCOM %v4float %26 %27 %28 %29 %30 OpStore %4 %31 %32 = OpLoad %20 %5 %33 = OpLoad %v4float %3 %34 = OpVectorShuffle %v2float %33 %33 0 2 %35 = OpImageSampleImplicitLod %v4float %32 %34 OpStore %4 %35 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Illegal use of QCOM image processing decorated texture")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchWindowSADInvalidUseRefI) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 %6 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 Location 0 OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 4 OpDecorate %6 DescriptorSet 0 OpDecorate %6 Binding 5 OpDecorate %5 BlockMatchTextureQCOM OpDecorate %5 BlockMatchSamplerQCOM OpDecorate %6 BlockMatchTextureQCOM OpDecorate %6 BlockMatchSamplerQCOM %void = OpTypeVoid %8 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %3 = OpVariable %_ptr_Input_v4float Input %uint_4 = OpConstant %uint 4 %16 = OpConstantComposite %v2uint %uint_4 %uint_4 %_ptr_Output_v4float = OpTypePointer Output %v4float %4 = OpVariable %_ptr_Output_v4float Output %18 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_18 = OpTypePointer UniformConstant %18 %20 = OpTypeSampledImage %18 %_ptr_UniformConstant_20 = OpTypePointer UniformConstant %20 %5 = OpVariable %_ptr_UniformConstant_20 UniformConstant %6 = OpVariable %_ptr_UniformConstant_20 UniformConstant %v2float = OpTypeVector %float 2 %23 = OpTypeImage %float 2D 0 1 0 1 Unknown %2 = OpFunction %void None %8 %24 = OpLabel %25 = OpVariable %_ptr_Function_v2uint Function OpStore %25 %16 %26 = OpLoad %20 %5 %27 = OpLoad %v2uint %25 %28 = OpLoad %20 %6 %29 = OpLoad %v2uint %25 %30 = OpLoad %v2uint %25 %31 = OpImageBlockMatchWindowSADQCOM %v4float %26 %27 %28 %29 %30 OpStore %4 %31 %32 = OpLoad %20 %6 %33 = OpLoad %v4float %3 %34 = OpVectorShuffle %v2float %33 %33 0 2 %35 = OpImageSampleImplicitLod %v4float %32 %34 OpStore %4 %35 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Illegal use of QCOM image processing decorated texture")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchWindowSADInvalidUseTargetNI) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %100 %101 %102 %103 %104 OpExecutionMode %main OriginUpperLeft OpDecorate %100 Location 0 OpDecorate %101 Location 0 OpDecorate %102 DescriptorSet 0 OpDecorate %102 Binding 1 OpDecorate %103 DescriptorSet 0 OpDecorate %103 Binding 3 OpDecorate %104 DescriptorSet 0 OpDecorate %104 Binding 2 OpDecorate %102 BlockMatchTextureQCOM OpDecorate %103 BlockMatchSamplerQCOM OpDecorate %104 BlockMatchTextureQCOM %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %100 = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %101 = OpVariable %_ptr_Output_v4float Output %42 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_42 = OpTypePointer UniformConstant %42 %102 = OpVariable %_ptr_UniformConstant_42 UniformConstant %46 = OpTypeSampler %_ptr_UniformConstant_46 = OpTypePointer UniformConstant %46 %103 = OpVariable %_ptr_UniformConstant_46 UniformConstant %50 = OpTypeSampledImage %42 %104 = OpVariable %_ptr_UniformConstant_42 UniformConstant %v2float = OpTypeVector %float 2 %main = OpFunction %void None %3 %5 = OpLabel %15 = OpVariable %_ptr_Function_v2uint Function %45 = OpLoad %42 %102 %49 = OpLoad %46 %103 %51 = OpSampledImage %50 %45 %49 %52 = OpLoad %v2uint %15 %54 = OpLoad %42 %104 %55 = OpLoad %46 %103 %56 = OpSampledImage %50 %54 %55 %57 = OpLoad %v2uint %15 %58 = OpLoad %v2uint %15 %59 = OpImageBlockMatchWindowSADQCOM %v4float %51 %52 %56 %57 %58 OpStore %101 %59 %69 = OpLoad %42 %102 %70 = OpLoad %46 %103 %71 = OpSampledImage %50 %69 %70 %73 = OpLoad %v4float %100 %74 = OpVectorShuffle %v2float %73 %73 0 0 %75 = OpImageSampleImplicitLod %v4float %71 %74 OpStore %101 %75 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Illegal use of QCOM image processing decorated texture")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchWindowSADInvalidUseRefNI) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %100 %101 %102 %103 %104 OpExecutionMode %main OriginUpperLeft OpDecorate %100 Location 0 OpDecorate %101 Location 0 OpDecorate %102 DescriptorSet 0 OpDecorate %102 Binding 1 OpDecorate %103 DescriptorSet 0 OpDecorate %103 Binding 3 OpDecorate %104 DescriptorSet 0 OpDecorate %104 Binding 2 OpDecorate %102 BlockMatchTextureQCOM OpDecorate %103 BlockMatchSamplerQCOM OpDecorate %104 BlockMatchTextureQCOM %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %100 = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %101 = OpVariable %_ptr_Output_v4float Output %42 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_42 = OpTypePointer UniformConstant %42 %102 = OpVariable %_ptr_UniformConstant_42 UniformConstant %46 = OpTypeSampler %_ptr_UniformConstant_46 = OpTypePointer UniformConstant %46 %103 = OpVariable %_ptr_UniformConstant_46 UniformConstant %50 = OpTypeSampledImage %42 %104 = OpVariable %_ptr_UniformConstant_42 UniformConstant %v2float = OpTypeVector %float 2 %main = OpFunction %void None %3 %5 = OpLabel %15 = OpVariable %_ptr_Function_v2uint Function %45 = OpLoad %42 %102 %49 = OpLoad %46 %103 %51 = OpSampledImage %50 %45 %49 %52 = OpLoad %v2uint %15 %54 = OpLoad %42 %104 %55 = OpLoad %46 %103 %56 = OpSampledImage %50 %54 %55 %57 = OpLoad %v2uint %15 %58 = OpLoad %v2uint %15 %59 = OpImageBlockMatchWindowSADQCOM %v4float %51 %52 %56 %57 %58 OpStore %101 %59 %69 = OpLoad %42 %104 %70 = OpLoad %46 %103 %71 = OpSampledImage %50 %69 %70 %73 = OpLoad %v4float %100 %74 = OpVectorShuffle %v2float %73 %73 0 0 %75 = OpImageSampleImplicitLod %v4float %71 %74 OpStore %101 %75 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Illegal use of QCOM image processing decorated texture")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchWindowSSDInvalidUseTargetI) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 %6 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 Location 0 OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 4 OpDecorate %6 DescriptorSet 0 OpDecorate %6 Binding 5 OpDecorate %5 BlockMatchTextureQCOM OpDecorate %5 BlockMatchSamplerQCOM OpDecorate %6 BlockMatchTextureQCOM OpDecorate %6 BlockMatchSamplerQCOM %void = OpTypeVoid %8 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %3 = OpVariable %_ptr_Input_v4float Input %uint_4 = OpConstant %uint 4 %16 = OpConstantComposite %v2uint %uint_4 %uint_4 %_ptr_Output_v4float = OpTypePointer Output %v4float %4 = OpVariable %_ptr_Output_v4float Output %18 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_18 = OpTypePointer UniformConstant %18 %20 = OpTypeSampledImage %18 %_ptr_UniformConstant_20 = OpTypePointer UniformConstant %20 %5 = OpVariable %_ptr_UniformConstant_20 UniformConstant %6 = OpVariable %_ptr_UniformConstant_20 UniformConstant %v2float = OpTypeVector %float 2 %23 = OpTypeImage %float 2D 0 1 0 1 Unknown %2 = OpFunction %void None %8 %24 = OpLabel %25 = OpVariable %_ptr_Function_v2uint Function OpStore %25 %16 %26 = OpLoad %20 %5 %27 = OpLoad %v2uint %25 %28 = OpLoad %20 %6 %29 = OpLoad %v2uint %25 %30 = OpLoad %v2uint %25 %31 = OpImageBlockMatchWindowSSDQCOM %v4float %26 %27 %28 %29 %30 OpStore %4 %31 %32 = OpLoad %20 %5 %33 = OpLoad %v4float %3 %34 = OpVectorShuffle %v2float %33 %33 0 2 %35 = OpImageSampleImplicitLod %v4float %32 %34 OpStore %4 %35 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Illegal use of QCOM image processing decorated texture")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchWindowSSDInvalidUseRefI) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 %6 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 Location 0 OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 4 OpDecorate %6 DescriptorSet 0 OpDecorate %6 Binding 5 OpDecorate %5 BlockMatchTextureQCOM OpDecorate %5 BlockMatchSamplerQCOM OpDecorate %6 BlockMatchTextureQCOM OpDecorate %6 BlockMatchSamplerQCOM %void = OpTypeVoid %8 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %3 = OpVariable %_ptr_Input_v4float Input %uint_4 = OpConstant %uint 4 %16 = OpConstantComposite %v2uint %uint_4 %uint_4 %_ptr_Output_v4float = OpTypePointer Output %v4float %4 = OpVariable %_ptr_Output_v4float Output %18 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_18 = OpTypePointer UniformConstant %18 %20 = OpTypeSampledImage %18 %_ptr_UniformConstant_20 = OpTypePointer UniformConstant %20 %5 = OpVariable %_ptr_UniformConstant_20 UniformConstant %6 = OpVariable %_ptr_UniformConstant_20 UniformConstant %v2float = OpTypeVector %float 2 %23 = OpTypeImage %float 2D 0 1 0 1 Unknown %2 = OpFunction %void None %8 %24 = OpLabel %25 = OpVariable %_ptr_Function_v2uint Function OpStore %25 %16 %26 = OpLoad %20 %5 %27 = OpLoad %v2uint %25 %28 = OpLoad %20 %6 %29 = OpLoad %v2uint %25 %30 = OpLoad %v2uint %25 %31 = OpImageBlockMatchWindowSSDQCOM %v4float %26 %27 %28 %29 %30 OpStore %4 %31 %32 = OpLoad %20 %6 %33 = OpLoad %v4float %3 %34 = OpVectorShuffle %v2float %33 %33 0 2 %35 = OpImageSampleImplicitLod %v4float %32 %34 OpStore %4 %35 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Illegal use of QCOM image processing decorated texture")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchWindowSSDInvalidUseTargetNI) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %100 %101 %102 %103 %104 OpExecutionMode %main OriginUpperLeft OpDecorate %100 Location 0 OpDecorate %101 Location 0 OpDecorate %102 DescriptorSet 0 OpDecorate %102 Binding 1 OpDecorate %103 DescriptorSet 0 OpDecorate %103 Binding 3 OpDecorate %104 DescriptorSet 0 OpDecorate %104 Binding 2 OpDecorate %102 BlockMatchTextureQCOM OpDecorate %103 BlockMatchSamplerQCOM OpDecorate %104 BlockMatchTextureQCOM %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %100 = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %101 = OpVariable %_ptr_Output_v4float Output %42 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_42 = OpTypePointer UniformConstant %42 %102 = OpVariable %_ptr_UniformConstant_42 UniformConstant %46 = OpTypeSampler %_ptr_UniformConstant_46 = OpTypePointer UniformConstant %46 %103 = OpVariable %_ptr_UniformConstant_46 UniformConstant %50 = OpTypeSampledImage %42 %104 = OpVariable %_ptr_UniformConstant_42 UniformConstant %v2float = OpTypeVector %float 2 %main = OpFunction %void None %3 %5 = OpLabel %15 = OpVariable %_ptr_Function_v2uint Function %45 = OpLoad %42 %102 %49 = OpLoad %46 %103 %51 = OpSampledImage %50 %45 %49 %52 = OpLoad %v2uint %15 %54 = OpLoad %42 %104 %55 = OpLoad %46 %103 %56 = OpSampledImage %50 %54 %55 %57 = OpLoad %v2uint %15 %58 = OpLoad %v2uint %15 %59 = OpImageBlockMatchWindowSSDQCOM %v4float %51 %52 %56 %57 %58 OpStore %101 %59 %69 = OpLoad %42 %102 %70 = OpLoad %46 %103 %71 = OpSampledImage %50 %69 %70 %73 = OpLoad %v4float %100 %74 = OpVectorShuffle %v2float %73 %73 0 0 %75 = OpImageSampleImplicitLod %v4float %71 %74 OpStore %101 %75 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Illegal use of QCOM image processing decorated texture")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchWindowSSDInvalidUseRefNI) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %100 %101 %102 %103 %104 OpExecutionMode %main OriginUpperLeft OpDecorate %100 Location 0 OpDecorate %101 Location 0 OpDecorate %102 DescriptorSet 0 OpDecorate %102 Binding 1 OpDecorate %103 DescriptorSet 0 OpDecorate %103 Binding 3 OpDecorate %104 DescriptorSet 0 OpDecorate %104 Binding 2 OpDecorate %102 BlockMatchTextureQCOM OpDecorate %103 BlockMatchSamplerQCOM OpDecorate %104 BlockMatchTextureQCOM %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %100 = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %101 = OpVariable %_ptr_Output_v4float Output %42 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_42 = OpTypePointer UniformConstant %42 %102 = OpVariable %_ptr_UniformConstant_42 UniformConstant %46 = OpTypeSampler %_ptr_UniformConstant_46 = OpTypePointer UniformConstant %46 %103 = OpVariable %_ptr_UniformConstant_46 UniformConstant %50 = OpTypeSampledImage %42 %104 = OpVariable %_ptr_UniformConstant_42 UniformConstant %v2float = OpTypeVector %float 2 %main = OpFunction %void None %3 %5 = OpLabel %15 = OpVariable %_ptr_Function_v2uint Function %45 = OpLoad %42 %102 %49 = OpLoad %46 %103 %51 = OpSampledImage %50 %45 %49 %52 = OpLoad %v2uint %15 %54 = OpLoad %42 %104 %55 = OpLoad %46 %103 %56 = OpSampledImage %50 %54 %55 %57 = OpLoad %v2uint %15 %58 = OpLoad %v2uint %15 %59 = OpImageBlockMatchWindowSSDQCOM %v4float %51 %52 %56 %57 %58 OpStore %101 %59 %69 = OpLoad %42 %104 %70 = OpLoad %46 %103 %71 = OpSampledImage %50 %69 %70 %73 = OpLoad %v4float %100 %74 = OpVectorShuffle %v2float %73 %73 0 0 %75 = OpImageSampleImplicitLod %v4float %71 %74 OpStore %101 %75 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Illegal use of QCOM image processing decorated texture")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchGatherSADInvalidUseTargetI) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 %6 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 Location 0 OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 4 OpDecorate %6 DescriptorSet 0 OpDecorate %6 Binding 5 OpDecorate %5 BlockMatchTextureQCOM OpDecorate %6 BlockMatchTextureQCOM %void = OpTypeVoid %8 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %3 = OpVariable %_ptr_Input_v4float Input %uint_4 = OpConstant %uint 4 %16 = OpConstantComposite %v2uint %uint_4 %uint_4 %_ptr_Output_v4float = OpTypePointer Output %v4float %4 = OpVariable %_ptr_Output_v4float Output %18 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_18 = OpTypePointer UniformConstant %18 %20 = OpTypeSampledImage %18 %_ptr_UniformConstant_20 = OpTypePointer UniformConstant %20 %5 = OpVariable %_ptr_UniformConstant_20 UniformConstant %6 = OpVariable %_ptr_UniformConstant_20 UniformConstant %v2float = OpTypeVector %float 2 %23 = OpTypeImage %float 2D 0 1 0 1 Unknown %2 = OpFunction %void None %8 %24 = OpLabel %25 = OpVariable %_ptr_Function_v2uint Function OpStore %25 %16 %26 = OpLoad %20 %5 %27 = OpLoad %v2uint %25 %28 = OpLoad %20 %6 %29 = OpLoad %v2uint %25 %30 = OpLoad %v2uint %25 %31 = OpImageBlockMatchGatherSADQCOM %v4float %26 %27 %28 %29 %30 OpStore %4 %31 %32 = OpLoad %20 %5 %33 = OpLoad %v4float %3 %34 = OpVectorShuffle %v2float %33 %33 0 2 %35 = OpImageSampleImplicitLod %v4float %32 %34 OpStore %4 %35 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Illegal use of QCOM image processing decorated texture")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchGatherSADInvalidUseRefI) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 %6 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 Location 0 OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 4 OpDecorate %6 DescriptorSet 0 OpDecorate %6 Binding 5 OpDecorate %5 BlockMatchTextureQCOM OpDecorate %6 BlockMatchTextureQCOM %void = OpTypeVoid %8 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %3 = OpVariable %_ptr_Input_v4float Input %uint_4 = OpConstant %uint 4 %16 = OpConstantComposite %v2uint %uint_4 %uint_4 %_ptr_Output_v4float = OpTypePointer Output %v4float %4 = OpVariable %_ptr_Output_v4float Output %18 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_18 = OpTypePointer UniformConstant %18 %20 = OpTypeSampledImage %18 %_ptr_UniformConstant_20 = OpTypePointer UniformConstant %20 %5 = OpVariable %_ptr_UniformConstant_20 UniformConstant %6 = OpVariable %_ptr_UniformConstant_20 UniformConstant %v2float = OpTypeVector %float 2 %23 = OpTypeImage %float 2D 0 1 0 1 Unknown %2 = OpFunction %void None %8 %24 = OpLabel %25 = OpVariable %_ptr_Function_v2uint Function OpStore %25 %16 %26 = OpLoad %20 %5 %27 = OpLoad %v2uint %25 %28 = OpLoad %20 %6 %29 = OpLoad %v2uint %25 %30 = OpLoad %v2uint %25 %31 = OpImageBlockMatchGatherSADQCOM %v4float %26 %27 %28 %29 %30 OpStore %4 %31 %32 = OpLoad %20 %6 %33 = OpLoad %v4float %3 %34 = OpVectorShuffle %v2float %33 %33 0 2 %35 = OpImageSampleImplicitLod %v4float %32 %34 OpStore %4 %35 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Illegal use of QCOM image processing decorated texture")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchGatherSADInvalidUseTargetNI) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %100 %101 %102 %103 %104 OpExecutionMode %main OriginUpperLeft OpDecorate %100 Location 0 OpDecorate %101 Location 0 OpDecorate %102 DescriptorSet 0 OpDecorate %102 Binding 1 OpDecorate %103 DescriptorSet 0 OpDecorate %103 Binding 3 OpDecorate %104 DescriptorSet 0 OpDecorate %104 Binding 2 OpDecorate %102 BlockMatchTextureQCOM OpDecorate %104 BlockMatchTextureQCOM %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %100 = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %101 = OpVariable %_ptr_Output_v4float Output %42 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_42 = OpTypePointer UniformConstant %42 %102 = OpVariable %_ptr_UniformConstant_42 UniformConstant %46 = OpTypeSampler %_ptr_UniformConstant_46 = OpTypePointer UniformConstant %46 %103 = OpVariable %_ptr_UniformConstant_46 UniformConstant %50 = OpTypeSampledImage %42 %104 = OpVariable %_ptr_UniformConstant_42 UniformConstant %v2float = OpTypeVector %float 2 %main = OpFunction %void None %3 %5 = OpLabel %15 = OpVariable %_ptr_Function_v2uint Function %45 = OpLoad %42 %102 %49 = OpLoad %46 %103 %51 = OpSampledImage %50 %45 %49 %52 = OpLoad %v2uint %15 %54 = OpLoad %42 %104 %55 = OpLoad %46 %103 %56 = OpSampledImage %50 %54 %55 %57 = OpLoad %v2uint %15 %58 = OpLoad %v2uint %15 %59 = OpImageBlockMatchGatherSADQCOM %v4float %51 %52 %56 %57 %58 OpStore %101 %59 %69 = OpLoad %42 %102 %70 = OpLoad %46 %103 %71 = OpSampledImage %50 %69 %70 %73 = OpLoad %v4float %100 %74 = OpVectorShuffle %v2float %73 %73 0 0 %75 = OpImageSampleImplicitLod %v4float %71 %74 OpStore %101 %75 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Illegal use of QCOM image processing decorated texture")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchGatherSADInvalidUseRefNI) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %100 %101 %102 %103 %104 OpExecutionMode %main OriginUpperLeft OpDecorate %100 Location 0 OpDecorate %101 Location 0 OpDecorate %102 DescriptorSet 0 OpDecorate %102 Binding 1 OpDecorate %103 DescriptorSet 0 OpDecorate %103 Binding 3 OpDecorate %104 DescriptorSet 0 OpDecorate %104 Binding 2 OpDecorate %102 BlockMatchTextureQCOM OpDecorate %104 BlockMatchTextureQCOM %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %100 = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %101 = OpVariable %_ptr_Output_v4float Output %42 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_42 = OpTypePointer UniformConstant %42 %102 = OpVariable %_ptr_UniformConstant_42 UniformConstant %46 = OpTypeSampler %_ptr_UniformConstant_46 = OpTypePointer UniformConstant %46 %103 = OpVariable %_ptr_UniformConstant_46 UniformConstant %50 = OpTypeSampledImage %42 %104 = OpVariable %_ptr_UniformConstant_42 UniformConstant %v2float = OpTypeVector %float 2 %main = OpFunction %void None %3 %5 = OpLabel %15 = OpVariable %_ptr_Function_v2uint Function %45 = OpLoad %42 %102 %49 = OpLoad %46 %103 %51 = OpSampledImage %50 %45 %49 %52 = OpLoad %v2uint %15 %54 = OpLoad %42 %104 %55 = OpLoad %46 %103 %56 = OpSampledImage %50 %54 %55 %57 = OpLoad %v2uint %15 %58 = OpLoad %v2uint %15 %59 = OpImageBlockMatchGatherSADQCOM %v4float %51 %52 %56 %57 %58 OpStore %101 %59 %69 = OpLoad %42 %104 %70 = OpLoad %46 %103 %71 = OpSampledImage %50 %69 %70 %73 = OpLoad %v4float %100 %74 = OpVectorShuffle %v2float %73 %73 0 0 %75 = OpImageSampleImplicitLod %v4float %71 %74 OpStore %101 %75 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Illegal use of QCOM image processing decorated texture")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchGatherSSDInvalidUseTargetI) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 %6 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 Location 0 OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 4 OpDecorate %6 DescriptorSet 0 OpDecorate %6 Binding 5 OpDecorate %5 BlockMatchTextureQCOM OpDecorate %6 BlockMatchTextureQCOM %void = OpTypeVoid %8 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %3 = OpVariable %_ptr_Input_v4float Input %uint_4 = OpConstant %uint 4 %16 = OpConstantComposite %v2uint %uint_4 %uint_4 %_ptr_Output_v4float = OpTypePointer Output %v4float %4 = OpVariable %_ptr_Output_v4float Output %18 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_18 = OpTypePointer UniformConstant %18 %20 = OpTypeSampledImage %18 %_ptr_UniformConstant_20 = OpTypePointer UniformConstant %20 %5 = OpVariable %_ptr_UniformConstant_20 UniformConstant %6 = OpVariable %_ptr_UniformConstant_20 UniformConstant %v2float = OpTypeVector %float 2 %23 = OpTypeImage %float 2D 0 1 0 1 Unknown %2 = OpFunction %void None %8 %24 = OpLabel %25 = OpVariable %_ptr_Function_v2uint Function OpStore %25 %16 %26 = OpLoad %20 %5 %27 = OpLoad %v2uint %25 %28 = OpLoad %20 %6 %29 = OpLoad %v2uint %25 %30 = OpLoad %v2uint %25 %31 = OpImageBlockMatchGatherSSDQCOM %v4float %26 %27 %28 %29 %30 OpStore %4 %31 %32 = OpLoad %20 %5 %33 = OpLoad %v4float %3 %34 = OpVectorShuffle %v2float %33 %33 0 2 %35 = OpImageSampleImplicitLod %v4float %32 %34 OpStore %4 %35 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Illegal use of QCOM image processing decorated texture")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchGatherSSDInvalidUseRefI) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "main" %3 %4 %5 %6 OpExecutionMode %2 OriginUpperLeft OpDecorate %3 Location 0 OpDecorate %4 Location 0 OpDecorate %5 DescriptorSet 0 OpDecorate %5 Binding 4 OpDecorate %6 DescriptorSet 0 OpDecorate %6 Binding 5 OpDecorate %5 BlockMatchTextureQCOM OpDecorate %6 BlockMatchTextureQCOM %void = OpTypeVoid %8 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %3 = OpVariable %_ptr_Input_v4float Input %uint_4 = OpConstant %uint 4 %16 = OpConstantComposite %v2uint %uint_4 %uint_4 %_ptr_Output_v4float = OpTypePointer Output %v4float %4 = OpVariable %_ptr_Output_v4float Output %18 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_18 = OpTypePointer UniformConstant %18 %20 = OpTypeSampledImage %18 %_ptr_UniformConstant_20 = OpTypePointer UniformConstant %20 %5 = OpVariable %_ptr_UniformConstant_20 UniformConstant %6 = OpVariable %_ptr_UniformConstant_20 UniformConstant %v2float = OpTypeVector %float 2 %23 = OpTypeImage %float 2D 0 1 0 1 Unknown %2 = OpFunction %void None %8 %24 = OpLabel %25 = OpVariable %_ptr_Function_v2uint Function OpStore %25 %16 %26 = OpLoad %20 %5 %27 = OpLoad %v2uint %25 %28 = OpLoad %20 %6 %29 = OpLoad %v2uint %25 %30 = OpLoad %v2uint %25 %31 = OpImageBlockMatchGatherSSDQCOM %v4float %26 %27 %28 %29 %30 OpStore %4 %31 %32 = OpLoad %20 %6 %33 = OpLoad %v4float %3 %34 = OpVectorShuffle %v2float %33 %33 0 2 %35 = OpImageSampleImplicitLod %v4float %32 %34 OpStore %4 %35 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Illegal use of QCOM image processing decorated texture")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchGatherSSDInvalidUseTargetNI) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %100 %101 %102 %103 %104 OpExecutionMode %main OriginUpperLeft OpDecorate %100 Location 0 OpDecorate %101 Location 0 OpDecorate %102 DescriptorSet 0 OpDecorate %102 Binding 1 OpDecorate %103 DescriptorSet 0 OpDecorate %103 Binding 3 OpDecorate %104 DescriptorSet 0 OpDecorate %104 Binding 2 OpDecorate %102 BlockMatchTextureQCOM OpDecorate %104 BlockMatchTextureQCOM %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %100 = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %101 = OpVariable %_ptr_Output_v4float Output %42 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_42 = OpTypePointer UniformConstant %42 %102 = OpVariable %_ptr_UniformConstant_42 UniformConstant %46 = OpTypeSampler %_ptr_UniformConstant_46 = OpTypePointer UniformConstant %46 %103 = OpVariable %_ptr_UniformConstant_46 UniformConstant %50 = OpTypeSampledImage %42 %104 = OpVariable %_ptr_UniformConstant_42 UniformConstant %v2float = OpTypeVector %float 2 %main = OpFunction %void None %3 %5 = OpLabel %15 = OpVariable %_ptr_Function_v2uint Function %45 = OpLoad %42 %102 %49 = OpLoad %46 %103 %51 = OpSampledImage %50 %45 %49 %52 = OpLoad %v2uint %15 %54 = OpLoad %42 %104 %55 = OpLoad %46 %103 %56 = OpSampledImage %50 %54 %55 %57 = OpLoad %v2uint %15 %58 = OpLoad %v2uint %15 %59 = OpImageBlockMatchGatherSSDQCOM %v4float %51 %52 %56 %57 %58 OpStore %101 %59 %69 = OpLoad %42 %102 %70 = OpLoad %46 %103 %71 = OpSampledImage %50 %69 %70 %73 = OpLoad %v4float %100 %74 = OpVectorShuffle %v2float %73 %73 0 0 %75 = OpImageSampleImplicitLod %v4float %71 %74 OpStore %101 %75 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Illegal use of QCOM image processing decorated texture")); } TEST_F(ValidateImage, QCOMImageProcessing2BlockMatchGatherSSDInvalidUseRefNI) { const std::string text = R"( OpCapability Shader OpCapability TextureBlockMatchQCOM OpCapability TextureBlockMatch2QCOM OpExtension "SPV_QCOM_image_processing" OpExtension "SPV_QCOM_image_processing2" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %100 %101 %102 %103 %104 OpExecutionMode %main OriginUpperLeft OpDecorate %100 Location 0 OpDecorate %101 Location 0 OpDecorate %102 DescriptorSet 0 OpDecorate %102 Binding 1 OpDecorate %103 DescriptorSet 0 OpDecorate %103 Binding 3 OpDecorate %104 DescriptorSet 0 OpDecorate %104 Binding 2 OpDecorate %102 BlockMatchTextureQCOM OpDecorate %104 BlockMatchTextureQCOM %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %100 = OpVariable %_ptr_Input_v4float Input %_ptr_Output_v4float = OpTypePointer Output %v4float %101 = OpVariable %_ptr_Output_v4float Output %42 = OpTypeImage %float 2D 0 0 0 1 Unknown %_ptr_UniformConstant_42 = OpTypePointer UniformConstant %42 %102 = OpVariable %_ptr_UniformConstant_42 UniformConstant %46 = OpTypeSampler %_ptr_UniformConstant_46 = OpTypePointer UniformConstant %46 %103 = OpVariable %_ptr_UniformConstant_46 UniformConstant %50 = OpTypeSampledImage %42 %104 = OpVariable %_ptr_UniformConstant_42 UniformConstant %v2float = OpTypeVector %float 2 %main = OpFunction %void None %3 %5 = OpLabel %15 = OpVariable %_ptr_Function_v2uint Function %45 = OpLoad %42 %102 %49 = OpLoad %46 %103 %51 = OpSampledImage %50 %45 %49 %52 = OpLoad %v2uint %15 %54 = OpLoad %42 %104 %55 = OpLoad %46 %103 %56 = OpSampledImage %50 %54 %55 %57 = OpLoad %v2uint %15 %58 = OpLoad %v2uint %15 %59 = OpImageBlockMatchGatherSSDQCOM %v4float %51 %52 %56 %57 %58 OpStore %101 %59 %69 = OpLoad %42 %104 %70 = OpLoad %46 %103 %71 = OpSampledImage %50 %69 %70 %73 = OpLoad %v4float %100 %74 = OpVectorShuffle %v2float %73 %73 0 0 %75 = OpImageSampleImplicitLod %v4float %71 %74 OpStore %101 %75 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Illegal use of QCOM image processing decorated texture")); } TEST_F(ValidateImage, ImageMSArray_ArrayedSampledTypeRequiresCapability) { const std::string code = R"( OpCapability Shader OpCapability StorageImageMultisample OpCapability StorageImageReadWithoutFormat OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpDecorate %var_image DescriptorSet 0 OpDecorate %var_image Binding 1 %void = OpTypeVoid %func = OpTypeFunction %void %f32 = OpTypeFloat 32 %u32 = OpTypeInt 32 0 %uint_2 = OpConstant %u32 2 %uint_1 = OpConstant %u32 1 %v2uint = OpTypeVector %u32 2 %v4float = OpTypeVector %f32 4 %image = OpTypeImage %f32 2D 2 1 1 2 Unknown %ptr_image = OpTypePointer UniformConstant %image %10 = OpConstantComposite %v2uint %uint_1 %uint_2 %var_image = OpVariable %ptr_image UniformConstant %main = OpFunction %void None %func %main_lab = OpLabel %18 = OpLoad %image %var_image %19 = OpImageRead %v4float %18 %10 Sample %uint_2 OpReturn OpFunctionEnd )"; const spv_target_env env = SPV_ENV_VULKAN_1_0; CompileSuccessfully(code, env); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(env)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Capability ImageMSArray is required to access storage image")); } TEST_F(ValidateImage, ImageMSArray_SampledTypeDoesNotRequireCapability) { const std::string code = R"( OpCapability Shader OpCapability StorageImageMultisample OpCapability StorageImageReadWithoutFormat OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpDecorate %var_image DescriptorSet 0 OpDecorate %var_image Binding 1 %void = OpTypeVoid %func = OpTypeFunction %void %f32 = OpTypeFloat 32 %u32 = OpTypeInt 32 0 %uint_2 = OpConstant %u32 2 %uint_1 = OpConstant %u32 1 %v2uint = OpTypeVector %u32 2 %v4float = OpTypeVector %f32 4 %image = OpTypeImage %f32 2D 2 0 1 2 Unknown %ptr_image = OpTypePointer UniformConstant %image %10 = OpConstantComposite %v2uint %uint_1 %uint_2 %var_image = OpVariable %ptr_image UniformConstant %main = OpFunction %void None %func %main_lab = OpLabel %18 = OpLoad %image %var_image %19 = OpImageRead %v4float %18 %10 Sample %uint_2 OpReturn OpFunctionEnd )"; const spv_target_env env = SPV_ENV_VULKAN_1_0; CompileSuccessfully(code, env); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(env)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateImage, ImageMSArray_ArrayedTypeDoesNotRequireCapability) { const std::string code = R"( OpCapability Shader OpCapability StorageImageReadWithoutFormat OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpDecorate %var_image DescriptorSet 0 OpDecorate %var_image Binding 1 %void = OpTypeVoid %func = OpTypeFunction %void %f32 = OpTypeFloat 32 %u32 = OpTypeInt 32 0 %uint_3 = OpConstant %u32 3 %uint_2 = OpConstant %u32 2 %uint_1 = OpConstant %u32 1 %v3uint = OpTypeVector %u32 3 %v4float = OpTypeVector %f32 4 %image = OpTypeImage %f32 2D 2 1 0 2 Unknown %ptr_image = OpTypePointer UniformConstant %image %10 = OpConstantComposite %v3uint %uint_1 %uint_2 %uint_3 %var_image = OpVariable %ptr_image UniformConstant %main = OpFunction %void None %func %main_lab = OpLabel %18 = OpLoad %image %var_image %19 = OpImageRead %v4float %18 %10 OpReturn OpFunctionEnd )"; const spv_target_env env = SPV_ENV_VULKAN_1_0; CompileSuccessfully(code, env); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(env)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateImage, SampledImageTypeDepthMismatch) { const std::string code = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %im_var DescriptorSet 0 OpDecorate %im_var Binding 0 OpDecorate %s_var DescriptorSet 1 OpDecorate %s_var Binding 0 %void = OpTypeVoid %float = OpTypeFloat 32 %im1_ty = OpTypeImage %float 2D 0 0 0 1 Unknown %im2_ty = OpTypeImage %float 2D 1 0 0 1 Unknown %s_ty = OpTypeSampler %s_im_ty = OpTypeSampledImage %im2_ty %ptr_im = OpTypePointer UniformConstant %im1_ty %ptr_s = OpTypePointer UniformConstant %s_ty %im_var = OpVariable %ptr_im UniformConstant %s_var = OpVariable %ptr_s UniformConstant %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %im_ld = OpLoad %im1_ty %im_var %s_ld = OpLoad %s_ty %s_var %sampled_image = OpSampledImage %s_im_ty %im_ld %s_ld OpReturn OpFunctionEnd )"; const spv_target_env env = SPV_ENV_VULKAN_1_0; CompileSuccessfully(code, env); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(env)); } TEST_F(ValidateImage, SampledImageTypeArrayedMismatch) { const std::string code = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %im_var DescriptorSet 0 OpDecorate %im_var Binding 0 OpDecorate %s_var DescriptorSet 1 OpDecorate %s_var Binding 0 %void = OpTypeVoid %float = OpTypeFloat 32 %im1_ty = OpTypeImage %float 2D 0 0 0 1 Unknown %im2_ty = OpTypeImage %float 2D 0 1 0 1 Unknown %s_ty = OpTypeSampler %s_im_ty = OpTypeSampledImage %im2_ty %ptr_im = OpTypePointer UniformConstant %im1_ty %ptr_s = OpTypePointer UniformConstant %s_ty %im_var = OpVariable %ptr_im UniformConstant %s_var = OpVariable %ptr_s UniformConstant %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %im_ld = OpLoad %im1_ty %im_var %s_ld = OpLoad %s_ty %s_var %sampled_image = OpSampledImage %s_im_ty %im_ld %s_ld OpReturn OpFunctionEnd )"; const spv_target_env env = SPV_ENV_VULKAN_1_0; CompileSuccessfully(code, env); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(env)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Image operands must match result image operands except for depth")); } TEST_F(ValidateImage, SampledImageTypeMultisampledMismatch) { const std::string code = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %im_var DescriptorSet 0 OpDecorate %im_var Binding 0 OpDecorate %s_var DescriptorSet 1 OpDecorate %s_var Binding 0 %void = OpTypeVoid %float = OpTypeFloat 32 %im1_ty = OpTypeImage %float 2D 0 0 0 1 Unknown %im2_ty = OpTypeImage %float 2D 0 0 1 1 Unknown %s_ty = OpTypeSampler %s_im_ty = OpTypeSampledImage %im2_ty %ptr_im = OpTypePointer UniformConstant %im1_ty %ptr_s = OpTypePointer UniformConstant %s_ty %im_var = OpVariable %ptr_im UniformConstant %s_var = OpVariable %ptr_s UniformConstant %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %im_ld = OpLoad %im1_ty %im_var %s_ld = OpLoad %s_ty %s_var %sampled_image = OpSampledImage %s_im_ty %im_ld %s_ld OpReturn OpFunctionEnd )"; const spv_target_env env = SPV_ENV_VULKAN_1_0; CompileSuccessfully(code, env); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(env)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Image operands must match result image operands except for depth")); } TEST_F(ValidateImage, SampledImageTypeSampledMismatch) { const std::string code = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %im_var DescriptorSet 0 OpDecorate %im_var Binding 0 OpDecorate %s_var DescriptorSet 1 OpDecorate %s_var Binding 0 %void = OpTypeVoid %float = OpTypeFloat 32 %im1_ty = OpTypeImage %float 2D 0 0 0 1 Unknown %im2_ty = OpTypeImage %float 2D 0 0 0 0 Unknown %s_ty = OpTypeSampler %s_im_ty = OpTypeSampledImage %im2_ty %ptr_im = OpTypePointer UniformConstant %im1_ty %ptr_s = OpTypePointer UniformConstant %s_ty %im_var = OpVariable %ptr_im UniformConstant %s_var = OpVariable %ptr_s UniformConstant %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %im_ld = OpLoad %im1_ty %im_var %s_ld = OpLoad %s_ty %s_var %sampled_image = OpSampledImage %s_im_ty %im_ld %s_ld OpReturn OpFunctionEnd )"; const spv_target_env env = SPV_ENV_UNIVERSAL_1_0; CompileSuccessfully(code, env); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(env)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Image operands must match result image operands except for depth")); } TEST_F(ValidateImage, SampledImageTypeFormatMismatch) { const std::string code = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %im_var DescriptorSet 0 OpDecorate %im_var Binding 0 OpDecorate %s_var DescriptorSet 1 OpDecorate %s_var Binding 0 %void = OpTypeVoid %float = OpTypeFloat 32 %im1_ty = OpTypeImage %float 2D 0 0 0 1 Unknown %im2_ty = OpTypeImage %float 2D 0 0 0 1 R32f %s_ty = OpTypeSampler %s_im_ty = OpTypeSampledImage %im2_ty %ptr_im = OpTypePointer UniformConstant %im1_ty %ptr_s = OpTypePointer UniformConstant %s_ty %im_var = OpVariable %ptr_im UniformConstant %s_var = OpVariable %ptr_s UniformConstant %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %im_ld = OpLoad %im1_ty %im_var %s_ld = OpLoad %s_ty %s_var %sampled_image = OpSampledImage %s_im_ty %im_ld %s_ld OpReturn OpFunctionEnd )"; const spv_target_env env = SPV_ENV_UNIVERSAL_1_0; CompileSuccessfully(code, env); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(env)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Image operands must match result image operands except for depth")); } TEST_F(ValidateImage, SampledImageTypeAccessQualifierMismatch) { const std::string code = R"( OpCapability Kernel OpCapability Linkage OpMemoryModel Logical OpenCL %void = OpTypeVoid %float = OpTypeFloat 32 %im1_ty = OpTypeImage %float 2D 0 0 0 0 Unknown ReadWrite %im2_ty = OpTypeImage %float 2D 0 0 0 0 Unknown ReadOnly %s_ty = OpTypeSampler %s_im_ty = OpTypeSampledImage %im2_ty %ptr_im = OpTypePointer UniformConstant %im1_ty %ptr_s = OpTypePointer UniformConstant %s_ty %im_var = OpVariable %ptr_im UniformConstant %s_var = OpVariable %ptr_s UniformConstant %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %im_ld = OpLoad %im1_ty %im_var %s_ld = OpLoad %s_ty %s_var %sampled_image = OpSampledImage %s_im_ty %im_ld %s_ld OpReturn OpFunctionEnd )"; const spv_target_env env = SPV_ENV_UNIVERSAL_1_0; CompileSuccessfully(code, env); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(env)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Image operands must match result image operands except for depth")); } TEST_F(ValidateImage, ImageTexelPointerNotAPointer) { const std::string code = R"( OpCapability ClipDistance OpMemoryModel Logical Simple %void = OpTypeVoid %57 = OpTypeFunction %void %int = OpTypeInt 32 1 %int_538976288 = OpConstant %int 538976288 %int_538976288_0 = OpConstant %int 538976288 %8224 = OpFunction %void None %57 %65312 = OpLabel %2097184 = OpImageTexelPointer %void %int_538976288 %int_538976288 %int_538976288_0 OpUnreachable OpFunctionEnd )"; CompileSuccessfully(code); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to be a pointer")); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_interfaces_test.cpp000066400000000000000000001600751475742701700250330ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "gmock/gmock.h" #include "test/unit_spirv.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::HasSubstr; using ValidateInterfacesTest = spvtest::ValidateBase; TEST_F(ValidateInterfacesTest, EntryPointMissingInput) { std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" OpExecutionMode %1 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeInt 32 0 %4 = OpTypePointer Input %3 %5 = OpVariable %4 Input %6 = OpTypeFunction %2 %1 = OpFunction %2 None %6 %7 = OpLabel %8 = OpLoad %3 %5 OpReturn OpFunctionEnd )"; CompileSuccessfully(text); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Interface variable id <5> is used by entry point 'func' id <1>, " "but is not listed as an interface")); } TEST_F(ValidateInterfacesTest, EntryPointMissingOutput) { std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" OpExecutionMode %1 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeInt 32 0 %4 = OpTypePointer Output %3 %5 = OpVariable %4 Output %6 = OpTypeFunction %2 %1 = OpFunction %2 None %6 %7 = OpLabel %8 = OpLoad %3 %5 OpReturn OpFunctionEnd )"; CompileSuccessfully(text); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Interface variable id <5> is used by entry point 'func' id <1>, " "but is not listed as an interface")); } TEST_F(ValidateInterfacesTest, InterfaceMissingUseInSubfunction) { std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" OpExecutionMode %1 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeInt 32 0 %4 = OpTypePointer Input %3 %5 = OpVariable %4 Input %6 = OpTypeFunction %2 %1 = OpFunction %2 None %6 %7 = OpLabel %8 = OpFunctionCall %2 %9 OpReturn OpFunctionEnd %9 = OpFunction %2 None %6 %10 = OpLabel %11 = OpLoad %3 %5 OpReturn OpFunctionEnd )"; CompileSuccessfully(text); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Interface variable id <5> is used by entry point 'func' id <1>, " "but is not listed as an interface")); } TEST_F(ValidateInterfacesTest, TwoEntryPointsOneFunction) { std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" %2 OpEntryPoint Fragment %1 "func2" OpExecutionMode %1 OriginUpperLeft %3 = OpTypeVoid %4 = OpTypeInt 32 0 %5 = OpTypePointer Input %4 %2 = OpVariable %5 Input %6 = OpTypeFunction %3 %1 = OpFunction %3 None %6 %7 = OpLabel %8 = OpLoad %4 %2 OpReturn OpFunctionEnd )"; CompileSuccessfully(text); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Interface variable id <2> is used by entry point 'func2' id <1>, " "but is not listed as an interface")); } TEST_F(ValidateInterfacesTest, MissingInterfaceThroughInitializer) { const std::string text = R"( OpCapability Shader OpCapability VariablePointers OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "func" OpExecutionMode %1 OriginUpperLeft %2 = OpTypeVoid %3 = OpTypeInt 32 0 %4 = OpTypePointer Input %3 %5 = OpTypePointer Function %4 %6 = OpVariable %4 Input %7 = OpTypeFunction %2 %1 = OpFunction %2 None %7 %8 = OpLabel %9 = OpVariable %5 Function %6 OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_3); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Interface variable id <6> is used by entry point 'func' id <1>, " "but is not listed as an interface")); } TEST_F(ValidateInterfacesTest, NonUniqueInterfacesSPV1p3) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %var %var OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint3 = OpTypeVector %uint 3 %struct = OpTypeStruct %uint3 %ptr_struct = OpTypePointer Input %struct %var = OpVariable %ptr_struct Input %func_ty = OpTypeFunction %void %main = OpFunction %void None %func_ty %1 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateInterfacesTest, NonUniqueInterfacesSPV1p4) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %var %var OpExecutionMode %main LocalSize 1 1 1 OpName %main "main" OpName %var "var" %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint3 = OpTypeVector %uint 3 %struct = OpTypeStruct %uint3 %ptr_struct = OpTypePointer Input %struct %var = OpVariable %ptr_struct Input %func_ty = OpTypeFunction %void %main = OpFunction %void None %func_ty %1 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Non-unique OpEntryPoint interface '2[%var]' is disallowed")); } TEST_F(ValidateInterfacesTest, MissingGlobalVarSPV1p3) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint3 = OpTypeVector %uint 3 %struct = OpTypeStruct %uint3 %ptr_struct = OpTypePointer StorageBuffer %struct %var = OpVariable %ptr_struct StorageBuffer %func_ty = OpTypeFunction %void %main = OpFunction %void None %func_ty %1 = OpLabel %ld = OpLoad %struct %var OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateInterfacesTest, MissingGlobalVarSPV1p4) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpName %var "var" %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint3 = OpTypeVector %uint 3 %struct = OpTypeStruct %uint3 %ptr_struct = OpTypePointer StorageBuffer %struct %var = OpVariable %ptr_struct StorageBuffer %func_ty = OpTypeFunction %void %main = OpFunction %void None %func_ty %1 = OpLabel %ld = OpLoad %struct %var OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Interface variable id <2> is used by entry point " "'main' id <1>, but is not listed as an interface")); } TEST_F(ValidateInterfacesTest, FunctionInterfaceVarSPV1p3) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %var OpExecutionMode %main LocalSize 1 1 1 OpName %var "var" %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint3 = OpTypeVector %uint 3 %struct = OpTypeStruct %uint3 %ptr_struct = OpTypePointer Function %struct %func_ty = OpTypeFunction %void %main = OpFunction %void None %func_ty %1 = OpLabel %var = OpVariable %ptr_struct Function OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpEntryPoint interfaces must be OpVariables with " "Storage Class of Input(1) or Output(3). Found Storage " "Class 7 for Entry Point id 1.")); } TEST_F(ValidateInterfacesTest, FunctionInterfaceVarSPV1p4) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %var OpExecutionMode %main LocalSize 1 1 1 OpName %var "var" %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint3 = OpTypeVector %uint 3 %struct = OpTypeStruct %uint3 %ptr_struct = OpTypePointer Function %struct %func_ty = OpTypeFunction %void %main = OpFunction %void None %func_ty %1 = OpLabel %var = OpVariable %ptr_struct Function OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpEntryPoint interfaces should only list global variables")); } TEST_F(ValidateInterfacesTest, ModuleSPV1p3ValidateSPV1p4_NotAllUsedGlobals) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpName %var "var" %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint3 = OpTypeVector %uint 3 %struct = OpTypeStruct %uint3 %ptr_struct = OpTypePointer StorageBuffer %struct %var = OpVariable %ptr_struct StorageBuffer %func_ty = OpTypeFunction %void %main = OpFunction %void None %func_ty %1 = OpLabel %ld = OpLoad %struct %var OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); } TEST_F(ValidateInterfacesTest, ModuleSPV1p3ValidateSPV1p4_DuplicateInterface) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %gid %gid OpExecutionMode %main LocalSize 1 1 1 OpDecorate %gid BuiltIn GlobalInvocationId %void = OpTypeVoid %int = OpTypeInt 32 0 %int3 = OpTypeVector %int 3 %ptr_input_int3 = OpTypePointer Input %int3 %gid = OpVariable %ptr_input_int3 Input %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); } TEST_F(ValidateInterfacesTest, SPV14MultipleEntryPointsSameFunction) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main1" %gid OpEntryPoint GLCompute %main "main2" %gid OpExecutionMode %main LocalSize 1 1 1 OpDecorate %gid BuiltIn GlobalInvocationId %void = OpTypeVoid %int = OpTypeInt 32 0 %int3 = OpTypeVector %int 3 %ptr_input_int3 = OpTypePointer Input %int3 %gid = OpVariable %ptr_input_int3 Input %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); } TEST_F(ValidateInterfacesTest, VulkanLocationsDoubleAssignmentVariable) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %var OpExecutionMode %main OriginUpperLeft OpDecorate %var Location 0 OpDecorate %var Location 1 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %ptr_input_float = OpTypePointer Input %float %var = OpVariable %ptr_input_float Input %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr("decorated with Location multiple times is not allowed")); } TEST_F(ValidateInterfacesTest, VulkanLocationsVariableAndMemberAssigned) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %var OpExecutionMode %main OriginUpperLeft OpDecorate %var Location 0 OpDecorate %struct Block OpMemberDecorate %struct 0 Location 0 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %struct = OpTypeStruct %float %ptr_input_struct = OpTypePointer Input %struct %var = OpVariable %ptr_input_struct Input %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Location-04918")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Members cannot be assigned a location")); } TEST_F(ValidateInterfacesTest, VulkanLocationsMemberAndSubMemberAssigned) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %var OpExecutionMode %main OriginUpperLeft OpDecorate %outer Block OpMemberDecorate %outer 0 Location 0 OpMemberDecorate %struct 0 Location 0 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %struct = OpTypeStruct %float %outer = OpTypeStruct %struct %ptr_input_outer = OpTypePointer Input %outer %var = OpVariable %ptr_input_outer Input %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Location-04918")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Members cannot be assigned a location")); } TEST_F(ValidateInterfacesTest, VulkanLocationsDoubleAssignmentStructMember) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %var OpExecutionMode %main OriginUpperLeft OpDecorate %struct Block OpMemberDecorate %struct 1 Location 0 OpMemberDecorate %struct 1 Location 1 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %struct = OpTypeStruct %float %float %ptr_input_struct = OpTypePointer Input %struct %var = OpVariable %ptr_input_struct Input %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr("decorated with Location multiple times is not allowed")); } TEST_F(ValidateInterfacesTest, VulkanLocationsMissingAssignmentStructMember) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %var OpExecutionMode %main OriginUpperLeft OpDecorate %struct Block OpMemberDecorate %struct 1 Location 1 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %struct = OpTypeStruct %float %float %ptr_input_struct = OpTypePointer Input %struct %var = OpVariable %ptr_input_struct Input %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Member index 0 is missing a location assignment")); } TEST_F(ValidateInterfacesTest, VulkanLocationsMissingAssignmentNonBlockStruct) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %var OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %struct = OpTypeStruct %float %float %ptr_input_struct = OpTypePointer Input %struct %var = OpVariable %ptr_input_struct Input %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Variable must be decorated with a location")); } TEST_F(ValidateInterfacesTest, VulkanLocationsVariableConflictInput) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %var1 %var2 OpExecutionMode %main OriginUpperLeft OpDecorate %var1 Location 0 OpDecorate %var2 Location 0 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %struct = OpTypeStruct %float %float %ptr_input_struct = OpTypePointer Input %struct %var1 = OpVariable %ptr_input_struct Input %var2 = OpVariable %ptr_input_struct Input %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpEntryPoint-08721")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Entry-point has conflicting input location assignment " "at location 0")); } TEST_F(ValidateInterfacesTest, VulkanLocationsVariableConflictOutput) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %var1 %var2 OpExecutionMode %main OriginUpperLeft OpDecorate %var1 Location 1 OpDecorate %var2 Location 1 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %struct = OpTypeStruct %float %float %ptr_output_struct = OpTypePointer Output %struct %var1 = OpVariable %ptr_output_struct Output %var2 = OpVariable %ptr_output_struct Output %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpEntryPoint-08722")); EXPECT_THAT( getDiagnosticString(), HasSubstr("Entry-point has conflicting output location assignment " "at location 1")); } TEST_F(ValidateInterfacesTest, VulkanPatchAndNonPatchOverlap) { const std::string text = R"( OpCapability Tessellation OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %main "main" %a %b OpExecutionMode %main OutputVertices 4 OpDecorate %a Location 0 OpDecorate %b Patch OpDecorate %b Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %uint = OpTypeInt 32 0 %uint_4 = OpConstant %uint 4 %_arr_float_uint_4 = OpTypeArray %float %uint_4 %_ptr_Output__arr_float_uint_4 = OpTypePointer Output %_arr_float_uint_4 %a = OpVariable %_ptr_Output__arr_float_uint_4 Output %_ptr_Output_float = OpTypePointer Output %float %b = OpVariable %_ptr_Output_float Output %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateInterfacesTest, VulkanPatchOverlap) { const std::string text = R"( OpCapability Tessellation OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %main "main" %a %b %c OpExecutionMode %main OutputVertices 4 OpDecorate %a Location 0 OpDecorate %b Patch OpDecorate %b Location 6 OpDecorate %c Patch OpDecorate %c Location 6 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %uint = OpTypeInt 32 0 %uint_4 = OpConstant %uint 4 %_arr_float_uint_4 = OpTypeArray %float %uint_4 %_ptr_Output__arr_float_uint_4 = OpTypePointer Output %_arr_float_uint_4 %a = OpVariable %_ptr_Output__arr_float_uint_4 Output %_ptr_Output_float = OpTypePointer Output %float %b = OpVariable %_ptr_Output_float Output %c = OpVariable %_ptr_Output_float Output %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpEntryPoint-08722")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Entry-point has conflicting output location " "assignment at location 6, component 0")); } TEST_F(ValidateInterfacesTest, VulkanLocationsSameLocationInputAndOutputNoConflict) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %var1 %var2 OpExecutionMode %main OriginUpperLeft OpDecorate %var1 Location 1 OpDecorate %var2 Location 1 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %struct = OpTypeStruct %float %float %ptr_input_struct = OpTypePointer Input %struct %ptr_output_struct = OpTypePointer Output %struct %var1 = OpVariable %ptr_input_struct Input %var2 = OpVariable %ptr_output_struct Output %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateInterfacesTest, VulkanLocationsVariableInGap) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %var1 %var2 OpExecutionMode %main OriginUpperLeft OpDecorate %struct Block OpMemberDecorate %struct 0 Location 0 OpMemberDecorate %struct 1 Location 2 OpDecorate %var2 Location 1 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %struct = OpTypeStruct %float %float %ptr_input_struct = OpTypePointer Input %struct %ptr_input_float = OpTypePointer Input %float %var1 = OpVariable %ptr_input_struct Input %var2 = OpVariable %ptr_input_float Input %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateInterfacesTest, VulkanLocationsLargeFloatVectorConflict) { const std::string text = R"( OpCapability Shader OpCapability Float64 OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %var1 %var2 OpExecutionMode %main OriginUpperLeft OpDecorate %var1 Location 0 OpDecorate %var2 Location 1 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %double = OpTypeFloat 64 %vector = OpTypeVector %double 3 %ptr_input_float = OpTypePointer Input %float %ptr_input_vector = OpTypePointer Input %vector %var1 = OpVariable %ptr_input_vector Input %var2 = OpVariable %ptr_input_float Input %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpEntryPoint-08721")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Entry-point has conflicting input location assignment " "at location 1")); } TEST_F(ValidateInterfacesTest, VulkanLocationsLargeIntVectorConflict) { const std::string text = R"( OpCapability Shader OpCapability Int64 OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %var1 %var2 OpExecutionMode %main OriginUpperLeft OpDecorate %var1 Location 0 OpDecorate %var1 Flat OpDecorate %var2 Location 1 OpDecorate %var2 Flat %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %long = OpTypeInt 64 0 %vector = OpTypeVector %long 4 %ptr_input_float = OpTypePointer Input %float %ptr_input_vector = OpTypePointer Input %vector %var1 = OpVariable %ptr_input_vector Input %var2 = OpVariable %ptr_input_float Input %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpEntryPoint-08721")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Entry-point has conflicting input location assignment " "at location 1")); } TEST_F(ValidateInterfacesTest, VulkanLocationsMatrix2x2Conflict) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %var1 %var2 OpExecutionMode %main OriginUpperLeft OpDecorate %var1 Location 0 OpDecorate %var2 Location 1 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %vector = OpTypeVector %float 2 %matrix = OpTypeMatrix %vector 2 %ptr_input_float = OpTypePointer Input %float %ptr_input_matrix = OpTypePointer Input %matrix %var1 = OpVariable %ptr_input_matrix Input %var2 = OpVariable %ptr_input_float Input %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpEntryPoint-08721")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Entry-point has conflicting input location assignment " "at location 1")); } TEST_F(ValidateInterfacesTest, VulkanLocationsMatrix3x3Conflict) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %var1 %var2 OpExecutionMode %main OriginUpperLeft OpDecorate %var1 Location 0 OpDecorate %var2 Location 2 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %vector = OpTypeVector %float 3 %matrix = OpTypeMatrix %vector 3 %ptr_input_float = OpTypePointer Input %float %ptr_input_matrix = OpTypePointer Input %matrix %var1 = OpVariable %ptr_input_matrix Input %var2 = OpVariable %ptr_input_float Input %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpEntryPoint-08721")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Entry-point has conflicting input location assignment " "at location 2")); } TEST_F(ValidateInterfacesTest, VulkanLocationsMatrix4x4Conflict) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %var1 %var2 OpExecutionMode %main OriginUpperLeft OpDecorate %var1 Location 0 OpDecorate %var2 Location 3 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %vector = OpTypeVector %float 4 %matrix = OpTypeMatrix %vector 4 %ptr_input_float = OpTypePointer Input %float %ptr_input_matrix = OpTypePointer Input %matrix %var1 = OpVariable %ptr_input_matrix Input %var2 = OpVariable %ptr_input_float Input %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpEntryPoint-08721")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Entry-point has conflicting input location assignment " "at location 3")); } TEST_F(ValidateInterfacesTest, VulkanLocationsLargeMatrix2x2Conflict) { const std::string text = R"( OpCapability Shader OpCapability Float64 OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %var1 %var2 OpExecutionMode %main OriginUpperLeft OpDecorate %var1 Location 0 OpDecorate %var2 Location 1 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %double = OpTypeFloat 64 %vector = OpTypeVector %double 2 %matrix = OpTypeMatrix %vector 2 %ptr_input_float = OpTypePointer Input %float %ptr_input_matrix = OpTypePointer Input %matrix %var1 = OpVariable %ptr_input_matrix Input %var2 = OpVariable %ptr_input_float Input %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpEntryPoint-08721")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Entry-point has conflicting input location assignment " "at location 1")); } TEST_F(ValidateInterfacesTest, VulkanLocationsLargeMatrix3x3Conflict) { const std::string text = R"( OpCapability Shader OpCapability Float64 OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %var1 %var2 OpExecutionMode %main OriginUpperLeft OpDecorate %var1 Location 0 OpDecorate %var2 Location 5 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %double = OpTypeFloat 64 %vector = OpTypeVector %double 3 %matrix = OpTypeMatrix %vector 3 %ptr_input_float = OpTypePointer Input %float %ptr_input_matrix = OpTypePointer Input %matrix %var1 = OpVariable %ptr_input_matrix Input %var2 = OpVariable %ptr_input_float Input %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpEntryPoint-08721")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Entry-point has conflicting input location assignment " "at location 5")); } TEST_F(ValidateInterfacesTest, VulkanLocationsLargeMatrix4x4Conflict) { const std::string text = R"( OpCapability Shader OpCapability Float64 OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %var1 %var2 OpExecutionMode %main OriginUpperLeft OpDecorate %var1 Location 0 OpDecorate %var2 Location 7 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %double = OpTypeFloat 64 %vector = OpTypeVector %double 4 %matrix = OpTypeMatrix %vector 4 %ptr_input_float = OpTypePointer Input %float %ptr_input_matrix = OpTypePointer Input %matrix %var1 = OpVariable %ptr_input_matrix Input %var2 = OpVariable %ptr_input_float Input %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpEntryPoint-08721")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Entry-point has conflicting input location assignment " "at location 7")); } TEST_F(ValidateInterfacesTest, VulkanLocationsArray2Conflict) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %var1 %var2 OpExecutionMode %main OriginUpperLeft OpDecorate %var1 Location 0 OpDecorate %var2 Location 1 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %int = OpTypeInt 32 0 %int_2 = OpConstant %int 2 %array = OpTypeArray %int %int_2 %struct = OpTypeStruct %array %ptr_input_float = OpTypePointer Input %float %ptr_input_struct = OpTypePointer Input %struct %var1 = OpVariable %ptr_input_struct Input %var2 = OpVariable %ptr_input_float Input %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpEntryPoint-08721")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Entry-point has conflicting input location assignment " "at location 1")); } TEST_F(ValidateInterfacesTest, VulkanLocationsArray4Conflict) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %var1 %var2 OpExecutionMode %main OriginUpperLeft OpDecorate %var1 Location 0 OpDecorate %var2 Location 3 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %int = OpTypeInt 32 0 %int_4 = OpConstant %int 4 %array = OpTypeArray %int %int_4 %struct = OpTypeStruct %array %ptr_input_float = OpTypePointer Input %float %ptr_input_struct = OpTypePointer Input %struct %var1 = OpVariable %ptr_input_struct Input %var2 = OpVariable %ptr_input_float Input %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpEntryPoint-08721")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Entry-point has conflicting input location assignment " "at location 3")); } TEST_F(ValidateInterfacesTest, VulkanLocationsMatrix4x4Array4Conflict) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %var1 %var2 OpExecutionMode %main OriginUpperLeft OpDecorate %var1 Location 0 OpDecorate %var2 Location 15 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %int = OpTypeInt 32 0 %int_4 = OpConstant %int 4 %vector = OpTypeVector %float 4 %matrix = OpTypeMatrix %vector 4 %array = OpTypeArray %matrix %int_4 %struct = OpTypeStruct %array %ptr_input_float = OpTypePointer Input %float %ptr_input_struct = OpTypePointer Input %struct %var1 = OpVariable %ptr_input_struct Input %var2 = OpVariable %ptr_input_float Input %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpEntryPoint-08721")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Entry-point has conflicting input location assignment " "at location 15")); } TEST_F(ValidateInterfacesTest, VulkanLocationsComponentDisambiguates) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %var1 OpExecutionMode %main OriginUpperLeft OpDecorate %struct Block OpMemberDecorate %struct 0 Location 0 OpMemberDecorate %struct 0 Component 0 OpMemberDecorate %struct 1 Location 0 OpMemberDecorate %struct 1 Component 1 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %struct = OpTypeStruct %float %float %ptr_input_struct = OpTypePointer Input %struct %var1 = OpVariable %ptr_input_struct Input %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateInterfacesTest, VulkanLocationsComponentIn64BitVec3) { const std::string text = R"( OpCapability Shader OpCapability Float64 OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %var OpExecutionMode %main OriginUpperLeft OpDecorate %struct Block OpMemberDecorate %struct 0 Location 0 OpMemberDecorate %struct 1 Location 1 OpMemberDecorate %struct 1 Component 1 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %double = OpTypeFloat 64 %double3 = OpTypeVector %double 3 %struct = OpTypeStruct %double3 %float %ptr_input_struct = OpTypePointer Input %struct %var = OpVariable %ptr_input_struct Input %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpEntryPoint-08721")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Entry-point has conflicting input location assignment " "at location 1, component 1")); } TEST_F(ValidateInterfacesTest, VulkanLocationsComponentAfter64BitVec3) { const std::string text = R"( OpCapability Shader OpCapability Float64 OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %var OpExecutionMode %main OriginUpperLeft OpDecorate %struct Block OpMemberDecorate %struct 0 Location 0 OpMemberDecorate %struct 1 Location 1 OpMemberDecorate %struct 1 Component 2 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %double = OpTypeFloat 64 %double3 = OpTypeVector %double 3 %struct = OpTypeStruct %double3 %float %ptr_input_struct = OpTypePointer Input %struct %var = OpVariable %ptr_input_struct Input %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateInterfacesTest, VulkanLocationsConflictingComponentVariable) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %var OpExecutionMode %main OriginUpperLeft OpDecorate %var Location 0 OpDecorate %var Component 0 OpDecorate %var Component 1 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %ptr_input_float = OpTypePointer Input %float %var = OpVariable %ptr_input_float Input %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr("decorated with Component multiple times is not allowed")); } TEST_F(ValidateInterfacesTest, VulkanLocationsConflictingComponentStructMember) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %var OpExecutionMode %main OriginUpperLeft OpDecorate %struct Block OpMemberDecorate %struct 0 Location 0 OpMemberDecorate %struct 0 Component 0 OpMemberDecorate %struct 0 Component 1 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %struct = OpTypeStruct %float %ptr_input_struct = OpTypePointer Input %struct %var = OpVariable %ptr_input_struct Input %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr("decorated with Component multiple times is not allowed")); } TEST_F(ValidateInterfacesTest, VulkanLocationsVariableConflictOutputIndex1) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %var1 %var2 OpExecutionMode %main OriginUpperLeft OpDecorate %var1 Location 1 OpDecorate %var1 Index 1 OpDecorate %var2 Location 1 OpDecorate %var2 Index 1 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %struct = OpTypeStruct %float %float %ptr_output_struct = OpTypePointer Output %struct %var1 = OpVariable %ptr_output_struct Output %var2 = OpVariable %ptr_output_struct Output %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpEntryPoint-08722")); EXPECT_THAT( getDiagnosticString(), HasSubstr("Entry-point has conflicting output location assignment " "at location 1")); } TEST_F(ValidateInterfacesTest, VulkanLocationsVariableNoConflictDifferentIndex) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %var1 %var2 OpExecutionMode %main OriginUpperLeft OpDecorate %var1 Location 1 OpDecorate %var1 Index 0 OpDecorate %var2 Location 1 OpDecorate %var2 Index 1 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %struct = OpTypeStruct %float %float %ptr_output_struct = OpTypePointer Output %struct %var1 = OpVariable %ptr_output_struct Output %var2 = OpVariable %ptr_output_struct Output %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateInterfacesTest, VulkanLocationsIndexGLCompute) { const std::string text = R"( OpCapability Shader OpCapability Geometry OpMemoryModel Logical GLSL450 OpEntryPoint Geometry %main "main" %var1 OpExecutionMode %main Triangles OpExecutionMode %main OutputPoints OpDecorate %var1 Location 1 OpDecorate %var1 Index 1 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %struct = OpTypeStruct %float %float %ptr_output_struct = OpTypePointer Output %struct %var1 = OpVariable %ptr_output_struct Output %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Index can only be applied to Fragment output variables")); } TEST_F(ValidateInterfacesTest, VulkanLocationsIndexInput) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %var1 OpExecutionMode %main OriginUpperLeft OpDecorate %var1 Location 1 OpDecorate %var1 Index 1 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %struct = OpTypeStruct %float %float %ptr_input_struct = OpTypePointer Input %struct %var1 = OpVariable %ptr_input_struct Input %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be in the Output storage class")); } TEST_F(ValidateInterfacesTest, VulkanLocationsArrayWithComponent) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %11 %18 %28 %36 %40 OpExecutionMode %4 OriginUpperLeft OpDecorate %11 Location 0 OpDecorate %18 Component 0 OpDecorate %18 Location 0 OpDecorate %28 Component 1 OpDecorate %28 Location 0 OpDecorate %36 Location 1 OpDecorate %40 Component 0 OpDecorate %40 Location 1 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %11 = OpVariable %_ptr_Input_v4float Input %_ptr_Output_float = OpTypePointer Output %float %18 = OpVariable %_ptr_Output_float Output %uint = OpTypeInt 32 0 %v3float = OpTypeVector %float 3 %uint_2 = OpConstant %uint 2 %_arr_v3float_uint_2 = OpTypeArray %v3float %uint_2 %_ptr_Output__arr_v3float_uint_2 = OpTypePointer Output %_arr_v3float_uint_2 %28 = OpVariable %_ptr_Output__arr_v3float_uint_2 Output %_ptr_Output_v3float = OpTypePointer Output %v3float %36 = OpVariable %_ptr_Input_v4float Input %40 = OpVariable %_ptr_Output_float Output %4 = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateInterfacesTest, VulkanLocationsArrayWithComponentBad) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %11 %18 %28 %36 %40 OpExecutionMode %4 OriginUpperLeft OpDecorate %11 Location 0 OpDecorate %18 Component 0 OpDecorate %18 Location 0 OpDecorate %28 Component 1 OpDecorate %28 Location 0 OpDecorate %36 Location 1 OpDecorate %40 Component 1 OpDecorate %40 Location 1 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Input_v4float = OpTypePointer Input %v4float %11 = OpVariable %_ptr_Input_v4float Input %_ptr_Output_float = OpTypePointer Output %float %18 = OpVariable %_ptr_Output_float Output %uint = OpTypeInt 32 0 %v3float = OpTypeVector %float 3 %uint_2 = OpConstant %uint 2 %_arr_v3float_uint_2 = OpTypeArray %v3float %uint_2 %_ptr_Output__arr_v3float_uint_2 = OpTypePointer Output %_arr_v3float_uint_2 %28 = OpVariable %_ptr_Output__arr_v3float_uint_2 Output %_ptr_Output_v3float = OpTypePointer Output %v3float %36 = OpVariable %_ptr_Input_v4float Input %40 = OpVariable %_ptr_Output_float Output %4 = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpEntryPoint-08722")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Entry-point has conflicting output location " "assignment at location 1, component 1")); } TEST_F(ValidateInterfacesTest, VulkanLocationsLargeLocation) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "????????" %17 OpExecutionMode %4 OriginUpperLeft OpDecorate %17 Location 4227868160 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %_ptr_Input_v3float = OpTypePointer Input %v3float %17 = OpVariable %_ptr_Input_v3float Input %4 = OpFunction %void None %3 %5 = OpLabel OpUnreachable OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateInterfacesTest, VulkanLocationMeshShader) { const std::string text = R"( OpCapability Shader OpCapability MeshShadingNV OpExtension "SPV_NV_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint MeshNV %foo "foo" %in OpExecutionMode %foo LocalSize 1 1 1 OpDecorate %block Block OpMemberDecorate %block 0 PerTaskNV OpMemberDecorate %block 0 Offset 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_32 = OpConstant %int 32 %array = OpTypeArray %int %int_32 %block = OpTypeStruct %array %ptr_input_block = OpTypePointer Input %block %in = OpVariable %ptr_input_block Input %void_fn = OpTypeFunction %void %foo = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateInterfacesTest, VulkanLocationArrayWithComponent1) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in OpExecutionMode %main OriginUpperLeft OpDecorate %struct Block OpMemberDecorate %struct 0 Location 0 OpMemberDecorate %struct 0 Component 0 OpMemberDecorate %struct 1 Location 0 OpMemberDecorate %struct 1 Component 1 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %int = OpTypeInt 32 0 %int_2 = OpConstant %int 2 %float_arr = OpTypeArray %float %int_2 %struct = OpTypeStruct %float_arr %float_arr %ptr = OpTypePointer Input %struct %in = OpVariable %ptr Input %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateInterfacesTest, VulkanLocationArrayWithComponent2) { const std::string text = R"( OpCapability Shader OpCapability Float64 OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in OpExecutionMode %main OriginUpperLeft OpDecorate %struct Block OpMemberDecorate %struct 0 Location 0 OpMemberDecorate %struct 0 Component 0 OpMemberDecorate %struct 1 Location 0 OpMemberDecorate %struct 1 Component 2 %void = OpTypeVoid %void_fn = OpTypeFunction %void %float = OpTypeFloat 32 %double = OpTypeFloat 64 %int = OpTypeInt 32 0 %int_2 = OpConstant %int 2 %double_arr = OpTypeArray %double %int_2 %struct = OpTypeStruct %float %double_arr %ptr = OpTypePointer Input %struct %in = OpVariable %ptr Input %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateInterfacesTest, DuplicateInterfaceVariableSuccess) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in %out %in OpExecutionMode %main OriginUpperLeft OpDecorate %in Location 0 OpDecorate %out Location 0 %void = OpTypeVoid %float = OpTypeFloat 32 %in_ptr = OpTypePointer Input %float %out_ptr = OpTypePointer Output %float %in = OpVariable %in_ptr Input %out = OpVariable %out_ptr Output %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateInterfacesTest, StructWithBuiltinsMissingBlock_Bad) { // See https://github.com/KhronosGroup/SPIRV-Registry/issues/134 // // When a shader input or output is a struct that does not have Block, // then it must have a Location. // But BuiltIns must not have locations. const std::string text = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %in OpExecutionMode %main OriginUpperLeft ; %struct needs a Block decoration OpMemberDecorate %struct 0 BuiltIn Position %void = OpTypeVoid %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %struct = OpTypeStruct %v4float %in_ptr = OpTypePointer Input %struct %in = OpVariable %in_ptr Input %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Location-04919")); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Interface struct has no Block decoration but has BuiltIn members.")); } TEST_F(ValidateInterfacesTest, InvalidLocationTypePointer) { const std::string text = R"( OpCapability Shader OpMemoryModel Logical Simple OpEntryPoint Vertex %1 "Aiqn0" %2 %3 OpDecorate %2 Location 0 %void = OpTypeVoid %5 = OpTypeFunction %void %float = OpTypeFloat 32 %_ptr_Private_void = OpTypePointer Private %void %uint = OpTypeInt 32 0 %uint_4278132784 = OpConstant %uint 4278132784 %_arr__ptr_Private_void_uint_4278132784 = OpTypeArray %_ptr_Private_void %uint_4278132784 %_ptr_Output__arr__ptr_Private_void_uint_4278132784 = OpTypePointer Output %_arr__ptr_Private_void_uint_4278132784 %2 = OpVariable %_ptr_Output__arr__ptr_Private_void_uint_4278132784 Output %_ptr_Output__ptr_Private_void = OpTypePointer Output %_ptr_Private_void %3 = OpVariable %_ptr_Output__arr__ptr_Private_void_uint_4278132784 Output %1 = OpFunction %void None %5 %15 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Invalid type to assign a location")); } TEST_F(ValidateInterfacesTest, ValidLocationTypePhysicalStorageBufferPointer) { const std::string text = R"( OpCapability Shader OpCapability PhysicalStorageBufferAddresses OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint Vertex %main "main" %var OpDecorate %var Location 0 OpDecorate %var RestrictPointer %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr = OpTypePointer PhysicalStorageBuffer %int %ptr2 = OpTypePointer Input %ptr %var = OpVariable %ptr2 Input %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_VULKAN_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_3)); } TEST_F(ValidateInterfacesTest, UntypedVariableInputMissing) { const std::string text = R"( OpCapability Kernel OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical OpenCL OpEntryPoint Kernel %main "main" OpExecutionMode %main LocalSize 1 1 1 OpName %var "var" OpDecorate %var BuiltIn LocalInvocationId %void = OpTypeVoid %int = OpTypeInt 32 0 %int3 = OpTypeVector %int 3 %ptr = OpTypeUntypedPointerKHR Input %var = OpUntypedVariableKHR %ptr Input %int3 %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %load = OpLoad %int3 %var OpReturn OpFunctionEnd )"; CompileSuccessfully(text); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Interface variable id <2> is used by entry point " "'main' id <1>, but is not listed as an interface")); } TEST_F(ValidateInterfacesTest, UntypedVariableWorkgroupMissingSpv1p4) { const std::string text = R"( OpCapability Shader OpCapability UntypedPointersKHR OpCapability WorkgroupMemoryExplicitLayoutKHR OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpName %var "var" %void = OpTypeVoid %int = OpTypeInt 32 0 %ptr = OpTypeUntypedPointerKHR Workgroup %var = OpUntypedVariableKHR %ptr Workgroup %int %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %load = OpLoad %int %var OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Interface variable id <2> is used by entry point " "'main' id <1>, but is not listed as an interface")); } TEST_F(ValidateInterfacesTest, UntypedIdMatchesInputVulkan1p3) { const std::string text = R"( OpCapability Shader OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %var OpExecutionMode %main OriginUpperLeft OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 OpDecorate %1 Block OpMemberDecorate %1 0 Offset 0 %void = OpTypeVoid %float = OpTypeFloat 32 %1 = OpTypeStruct %float ; this id matches Input storage class %ptr = OpTypeUntypedPointerKHR Uniform %var = OpUntypedVariableKHR %ptr Uniform %1 %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); CompileSuccessfully(text, SPV_ENV_VULKAN_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_3)); } TEST_F(ValidateInterfacesTest, UntypedIdMatchesPushConstantVulkan1p3) { const std::string text = R"( OpCapability Shader OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %var OpExecutionMode %main OriginUpperLeft OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 OpDecorate %9 Block OpMemberDecorate %9 0 Offset 0 %void = OpTypeVoid %float = OpTypeFloat 32 %9 = OpTypeStruct %float ; this id matches PushConstant storage class %ptr = OpTypeUntypedPointerKHR Uniform %var = OpUntypedVariableKHR %ptr Uniform %9 %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); CompileSuccessfully(text, SPV_ENV_VULKAN_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_3)); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_layout_test.cpp000066400000000000000000000646361475742701700242330ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validation tests for Logical Layout #include #include #include #include #include #include "gmock/gmock.h" #include "source/diagnostic.h" #include "test/unit_spirv.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::Eq; using ::testing::HasSubstr; using ::testing::StrEq; using pred_type = std::function; using ValidateLayout = spvtest::ValidateBase< std::tuple>>; // returns true if order is equal to VAL template spv_result_t Equals(int order) { return order == VAL ? SPV_SUCCESS : RET; } // returns true if order is between MIN and MAX(inclusive) template struct Range { explicit Range(bool inverse = false) : inverse_(inverse) {} spv_result_t operator()(int order) { return (inverse_ ^ (order >= MIN && order <= MAX)) ? SPV_SUCCESS : RET; } private: bool inverse_; }; // SPIRV source used to test the logical layout const std::vector& getInstructions() { // clang-format off static const std::vector instructions = { "OpCapability Shader", "OpExtension \"TestExtension\"", "%inst = OpExtInstImport \"GLSL.std.450\"", "OpMemoryModel Logical GLSL450", "OpEntryPoint GLCompute %func \"\"", "OpExecutionMode %func LocalSize 1 1 1", "OpExecutionModeId %func LocalSizeId %one %one %one", "%str = OpString \"Test String\"", "%str2 = OpString \"blabla\"", "OpSource GLSL 450 %str \"uniform vec3 var = vec3(4.0);\"", "OpSourceContinued \"void main(){return;}\"", "OpSourceExtension \"Test extension\"", "OpName %func \"MyFunction\"", "OpMemberName %struct 1 \"my_member\"", "OpDecorate %dgrp RowMajor", "OpMemberDecorate %struct 1 RowMajor", "%dgrp = OpDecorationGroup", "OpGroupDecorate %dgrp %mat33 %mat44", "%intt = OpTypeInt 32 1", "%floatt = OpTypeFloat 32", "%voidt = OpTypeVoid", "%boolt = OpTypeBool", "%vec4 = OpTypeVector %floatt 4", "%vec3 = OpTypeVector %floatt 3", "%mat33 = OpTypeMatrix %vec3 3", "%mat44 = OpTypeMatrix %vec4 4", "%struct = OpTypeStruct %intt %mat33", "%vfunct = OpTypeFunction %voidt", "%viifunct = OpTypeFunction %voidt %intt %intt", "%one = OpConstant %intt 1", // TODO(umar): OpConstant fails because the type is not defined // TODO(umar): OpGroupMemberDecorate "OpLine %str 3 4", "OpNoLine", "%func = OpFunction %voidt None %vfunct", "%l = OpLabel", "OpReturn ; %func return", "OpFunctionEnd ; %func end", "%func2 = OpFunction %voidt None %viifunct", "%funcp1 = OpFunctionParameter %intt", "%funcp2 = OpFunctionParameter %intt", "%fLabel = OpLabel", "OpNop", "OpReturn ; %func2 return", "OpFunctionEnd" }; return instructions; } static const int kRangeEnd = 1000; pred_type All = Range<0, kRangeEnd>(); INSTANTIATE_TEST_SUITE_P(InstructionsOrder, ValidateLayout, ::testing::Combine(::testing::Range((int)0, (int)getInstructions().size()), // Note: Because of ID dependencies between instructions, some instructions // are not free to be placed anywhere without triggering an non-layout // validation error. Therefore, "Lines to compile" for some instructions // are not "All" in the below. // // | Instruction | Line(s) valid | Lines to compile ::testing::Values(std::make_tuple(std::string("OpCapability") , Equals<0> , Range<0, 2>()) , std::make_tuple(std::string("OpExtension") , Equals<1> , All) , std::make_tuple(std::string("OpExtInstImport") , Equals<2> , All) , std::make_tuple(std::string("OpMemoryModel") , Equals<3> , Range<1, kRangeEnd>()) , std::make_tuple(std::string("OpEntryPoint") , Equals<4> , All) , std::make_tuple(std::string("OpExecutionMode ") , Range<5, 6>() , All) , std::make_tuple(std::string("OpExecutionModeId") , Range<5, 6>() , All) , std::make_tuple(std::string("OpSource ") , Range<7, 11>() , Range<8, kRangeEnd>()) , std::make_tuple(std::string("OpSourceContinued ") , Range<7, 11>() , All) , std::make_tuple(std::string("OpSourceExtension ") , Range<7, 11>() , All) , std::make_tuple(std::string("%str2 = OpString ") , Range<7, 11>() , All) , std::make_tuple(std::string("OpName ") , Range<12, 13>() , All) , std::make_tuple(std::string("OpMemberName ") , Range<12, 13>() , All) , std::make_tuple(std::string("OpDecorate ") , Range<14, 17>() , All) , std::make_tuple(std::string("OpMemberDecorate ") , Range<14, 17>() , All) , std::make_tuple(std::string("OpGroupDecorate ") , Range<14, 17>() , Range<17, kRangeEnd>()) , std::make_tuple(std::string("OpDecorationGroup") , Range<14, 17>() , Range<0, 16>()) , std::make_tuple(std::string("OpTypeBool") , Range<18, 31>() , All) , std::make_tuple(std::string("OpTypeVoid") , Range<18, 31>() , Range<0, 26>()) , std::make_tuple(std::string("OpTypeFloat") , Range<18, 31>() , Range<0,21>()) , std::make_tuple(std::string("OpTypeInt") , Range<18, 31>() , Range<0, 21>()) , std::make_tuple(std::string("OpTypeVector %floatt 4") , Range<18, 31>() , Range<20, 24>()) , std::make_tuple(std::string("OpTypeMatrix %vec4 4") , Range<18, 31>() , Range<23, kRangeEnd>()) , std::make_tuple(std::string("OpTypeStruct") , Range<18, 31>() , Range<25, kRangeEnd>()) , std::make_tuple(std::string("%vfunct = OpTypeFunction"), Range<18, 31>() , Range<21, 31>()) , std::make_tuple(std::string("OpConstant") , Range<18, 31>() , Range<21, kRangeEnd>()) , std::make_tuple(std::string("OpLine ") , Range<18, kRangeEnd>() , Range<8, kRangeEnd>()) , std::make_tuple(std::string("OpNoLine") , Range<18, kRangeEnd>() , All) , std::make_tuple(std::string("%fLabel = OpLabel") , Equals<39> , All) , std::make_tuple(std::string("OpNop") , Equals<40> , Range<40,kRangeEnd>()) , std::make_tuple(std::string("OpReturn ; %func2 return") , Equals<41> , All) ))); // clang-format on // Creates a new vector which removes the string if the substr is found in the // instructions vector and reinserts it in the location specified by order. // NOTE: This will not work correctly if there are two instances of substr in // instructions std::vector GenerateCode(std::string substr, int order) { std::vector code(getInstructions().size()); std::vector inst(1); partition_copy(std::begin(getInstructions()), std::end(getInstructions()), std::begin(code), std::begin(inst), [=](const std::string& str) { return std::string::npos == str.find(substr); }); code.insert(std::begin(code) + order, inst.front()); return code; } // This test will check the logical layout of a binary by removing each // instruction in the pair of the INSTANTIATE_TEST_SUITE_P call and moving it in // the SPIRV source formed by combining the vector "instructions". TEST_P(ValidateLayout, Layout) { int order; std::string instruction; pred_type pred; pred_type test_pred; // Predicate to determine if the test should be build std::tuple testCase; std::tie(order, testCase) = GetParam(); std::tie(instruction, pred, test_pred) = testCase; // Skip test which break the code generation if (test_pred(order)) return; std::vector code = GenerateCode(instruction, order); std::stringstream ss; std::copy(std::begin(code), std::end(code), std::ostream_iterator(ss, "\n")); const auto env = SPV_ENV_UNIVERSAL_1_3; // printf("code: \n%s\n", ss.str().c_str()); CompileSuccessfully(ss.str(), env); spv_result_t result; // clang-format off ASSERT_EQ(pred(order), result = ValidateInstructions(env)) << "Actual: " << spvResultToString(result) << "\nExpected: " << spvResultToString(pred(order)) << "\nOrder: " << order << "\nInstruction: " << instruction << "\nCode: \n" << ss.str(); // clang-format on } TEST_F(ValidateLayout, MemoryModelMissingBeforeEntryPoint) { std::string str = R"( OpCapability Matrix OpExtension "TestExtension" %inst = OpExtInstImport "GLSL.std.450" OpEntryPoint GLCompute %func "" OpExecutionMode %func LocalSize 1 1 1 )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "EntryPoint cannot appear before the memory model instruction")); } TEST_F(ValidateLayout, MemoryModelMissing) { char str[] = R"(OpCapability Linkage)"; CompileSuccessfully(str, SPV_ENV_UNIVERSAL_1_1); ASSERT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions(SPV_ENV_UNIVERSAL_1_1)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Missing required OpMemoryModel instruction")); } TEST_F(ValidateLayout, MemoryModelSpecifiedTwice) { char str[] = R"( OpCapability Linkage OpCapability Shader OpMemoryModel Logical Simple OpMemoryModel Logical Simple )"; CompileSuccessfully(str, SPV_ENV_UNIVERSAL_1_1); ASSERT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions(SPV_ENV_UNIVERSAL_1_1)); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpMemoryModel should only be provided once")); } TEST_F(ValidateLayout, FunctionDefinitionBeforeDeclarationBad) { char str[] = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpDecorate %var Restrict %intt = OpTypeInt 32 1 %voidt = OpTypeVoid %vfunct = OpTypeFunction %voidt %vifunct = OpTypeFunction %voidt %intt %ptrt = OpTypePointer Function %intt %func = OpFunction %voidt None %vfunct %funcl = OpLabel OpNop OpReturn OpFunctionEnd %func2 = OpFunction %voidt None %vifunct ; must appear before definition %func2p = OpFunctionParameter %intt OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Function declarations must appear before function definitions.")); } // TODO(umar): Passes but gives incorrect error message. Should be fixed after // type checking TEST_F(ValidateLayout, LabelBeforeFunctionParameterBad) { char str[] = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpDecorate %var Restrict %intt = OpTypeInt 32 1 %voidt = OpTypeVoid %vfunct = OpTypeFunction %voidt %vifunct = OpTypeFunction %voidt %intt %ptrt = OpTypePointer Function %intt %func = OpFunction %voidt None %vifunct %funcl = OpLabel ; Label appears before function parameter %func2p = OpFunctionParameter %intt OpNop OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Function parameters must only appear immediately " "after the function definition")); } TEST_F(ValidateLayout, FuncParameterNotImmediatlyAfterFuncBad) { char str[] = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpDecorate %var Restrict %intt = OpTypeInt 32 1 %voidt = OpTypeVoid %vfunct = OpTypeFunction %voidt %vifunct = OpTypeFunction %voidt %intt %ptrt = OpTypePointer Function %intt %func = OpFunction %voidt None %vifunct %funcl = OpLabel OpNop OpBranch %next %func2p = OpFunctionParameter %intt ;FunctionParameter appears in a function but not immediately afterwards %next = OpLabel OpNop OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Function parameters must only appear immediately " "after the function definition")); } TEST_F(ValidateLayout, OpUndefCanAppearInTypeDeclarationSection) { std::string str = R"( OpCapability Kernel OpCapability Linkage OpMemoryModel Logical OpenCL %voidt = OpTypeVoid %uintt = OpTypeInt 32 0 %funct = OpTypeFunction %voidt %udef = OpUndef %uintt %func = OpFunction %voidt None %funct %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateLayout, OpUndefCanAppearInBlock) { std::string str = R"( OpCapability Kernel OpCapability Linkage OpMemoryModel Logical OpenCL %voidt = OpTypeVoid %uintt = OpTypeInt 32 0 %funct = OpTypeFunction %voidt %func = OpFunction %voidt None %funct %entry = OpLabel %udef = OpUndef %uintt OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateLayout, MissingFunctionEndForFunctionWithBody) { const auto s = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %tf = OpTypeFunction %void %f = OpFunction %void None %tf %l = OpLabel OpReturn )"; CompileSuccessfully(s); ASSERT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), StrEq("Missing OpFunctionEnd at end of module.")); } TEST_F(ValidateLayout, MissingFunctionEndForFunctionPrototype) { const auto s = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %tf = OpTypeFunction %void %f = OpFunction %void None %tf )"; CompileSuccessfully(s); ASSERT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), StrEq("Missing OpFunctionEnd at end of module.")); } using ValidateOpFunctionParameter = spvtest::ValidateBase; TEST_F(ValidateOpFunctionParameter, OpLineBetweenParameters) { const auto s = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %foo_frag = OpString "foo.frag" %i32 = OpTypeInt 32 1 %tf = OpTypeFunction %i32 %i32 %i32 %c = OpConstant %i32 123 %f = OpFunction %i32 None %tf OpLine %foo_frag 1 1 %p1 = OpFunctionParameter %i32 OpNoLine %p2 = OpFunctionParameter %i32 %l = OpLabel OpReturnValue %c OpFunctionEnd )"; CompileSuccessfully(s); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateOpFunctionParameter, TooManyParameters) { const auto s = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %i32 = OpTypeInt 32 1 %tf = OpTypeFunction %i32 %i32 %i32 %c = OpConstant %i32 123 %f = OpFunction %i32 None %tf %p1 = OpFunctionParameter %i32 %p2 = OpFunctionParameter %i32 %xp3 = OpFunctionParameter %i32 %xp4 = OpFunctionParameter %i32 %xp5 = OpFunctionParameter %i32 %xp6 = OpFunctionParameter %i32 %xp7 = OpFunctionParameter %i32 %l = OpLabel OpReturnValue %c OpFunctionEnd )"; CompileSuccessfully(s); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); } using ValidateEntryPoint = spvtest::ValidateBase; // Tests that not having OpEntryPoint causes an error. TEST_F(ValidateEntryPoint, NoEntryPointBad) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450)"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_BINARY, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("No OpEntryPoint instruction was found. This is only " "allowed if the Linkage capability is being used.")); } // Invalid. A function may not be a target of both OpEntryPoint and // OpFunctionCall. TEST_F(ValidateEntryPoint, FunctionIsTargetOfEntryPointAndFunctionCallBad) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %foo "foo" OpExecutionMode %foo OriginUpperLeft %voidt = OpTypeVoid %funct = OpTypeFunction %voidt %foo = OpFunction %voidt None %funct %entry = OpLabel %recurse = OpFunctionCall %voidt %foo OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_BINARY, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("A function (1) may not be targeted by both an OpEntryPoint " "instruction and an OpFunctionCall instruction.")); } // Invalid. Must be within a function to make a function call. TEST_F(ValidateEntryPoint, FunctionCallOutsideFunctionBody) { std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpName %variableName "variableName" %34 = OpFunctionCall %variableName %1 )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("FunctionCall must happen within a function body.")); } // Valid. Module with a function but no entry point is valid when Linkage // Capability is used. TEST_F(ValidateEntryPoint, NoEntryPointWithLinkageCapGood) { std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %voidt = OpTypeVoid %funct = OpTypeFunction %voidt %foo = OpFunction %voidt None %funct %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateLayout, ModuleProcessedInvalidIn10) { char str[] = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %void "void" OpModuleProcessed "this is ok in 1.1 and later" %void = OpTypeVoid )"; CompileSuccessfully(str, SPV_ENV_UNIVERSAL_1_1); ASSERT_EQ(SPV_ERROR_WRONG_VERSION, ValidateInstructions(SPV_ENV_UNIVERSAL_1_0)); // In a 1.0 environment the version check fails. EXPECT_THAT(getDiagnosticString(), HasSubstr("Invalid SPIR-V binary version 1.1 for target " "environment SPIR-V 1.0.")); } TEST_F(ValidateLayout, ModuleProcessedValidIn11) { char str[] = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %void "void" OpModuleProcessed "this is ok in 1.1 and later" %void = OpTypeVoid )"; CompileSuccessfully(str, SPV_ENV_UNIVERSAL_1_1); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_1)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateLayout, LayoutOrderMixedUp) { char str[] = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %fragmentFloat "fragmentFloat" OpExecutionMode %fragmentFloat OriginUpperLeft OpEntryPoint Fragment %fragmentUint "fragmentUint" OpExecutionMode %fragmentUint OriginUpperLeft )"; CompileSuccessfully(str, SPV_ENV_UNIVERSAL_1_1); ASSERT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions(SPV_ENV_UNIVERSAL_1_1)); // By the mechanics of the validator, we assume ModuleProcessed is in the // right spot, but then that OpName is in the wrong spot. EXPECT_THAT(getDiagnosticString(), HasSubstr("EntryPoint is in an invalid layout section")); } TEST_F(ValidateLayout, ModuleProcessedBeforeLastNameIsTooEarly) { char str[] = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpModuleProcessed "this is too early" OpName %void "void" %void = OpTypeVoid )"; CompileSuccessfully(str, SPV_ENV_UNIVERSAL_1_1); ASSERT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions(SPV_ENV_UNIVERSAL_1_1)); // By the mechanics of the validator, we assume ModuleProcessed is in the // right spot, but then that OpName is in the wrong spot. EXPECT_THAT(getDiagnosticString(), HasSubstr("Name is in an invalid layout section")); } TEST_F(ValidateLayout, ModuleProcessedInvalidAfterFirstAnnotation) { char str[] = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %void Volatile ; this is bogus, but keeps the example short OpModuleProcessed "this is too late" %void = OpTypeVoid )"; CompileSuccessfully(str, SPV_ENV_UNIVERSAL_1_1); ASSERT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions(SPV_ENV_UNIVERSAL_1_1)); EXPECT_THAT(getDiagnosticString(), HasSubstr("ModuleProcessed is in an invalid layout section")); } TEST_F(ValidateLayout, ModuleProcessedInvalidInFunctionBeforeLabel) { char str[] = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %voidfn = OpTypeFunction %void %main = OpFunction %void None %voidfn OpModuleProcessed "this is too late, in function before label" %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str, SPV_ENV_UNIVERSAL_1_1); ASSERT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions(SPV_ENV_UNIVERSAL_1_1)); EXPECT_THAT( getDiagnosticString(), HasSubstr("ModuleProcessed cannot appear in a function declaration")); } TEST_F(ValidateLayout, ModuleProcessedInvalidInBasicBlock) { char str[] = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %voidfn = OpTypeFunction %void %main = OpFunction %void None %voidfn %entry = OpLabel OpModuleProcessed "this is too late, in basic block" OpReturn OpFunctionEnd )"; CompileSuccessfully(str, SPV_ENV_UNIVERSAL_1_1); ASSERT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions(SPV_ENV_UNIVERSAL_1_1)); EXPECT_THAT( getDiagnosticString(), HasSubstr("ModuleProcessed cannot appear in a function declaration")); } // TODO(umar): Test optional instructions TEST_F(ValidateLayout, ValidNVBindlessTexturelayout) { std::string str = R"( OpCapability Shader OpCapability BindlessTextureNV OpExtension "SPV_NV_bindless_texture" OpMemoryModel Logical GLSL450 OpSamplerImageAddressingModeNV 64 OpEntryPoint GLCompute %func "main" %voidt = OpTypeVoid %uintt = OpTypeInt 32 0 %funct = OpTypeFunction %voidt %func = OpFunction %voidt None %funct %entry = OpLabel %udef = OpUndef %uintt OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateLayout, InvalidValidNVBindlessTexturelayout) { std::string str = R"( OpCapability Shader OpCapability BindlessTextureNV OpExtension "SPV_NV_bindless_texture" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %func "main" OpSamplerImageAddressingModeNV 64 %voidt = OpTypeVoid %uintt = OpTypeInt 32 0 %funct = OpTypeFunction %voidt %func = OpFunction %voidt None %funct %entry = OpLabel %udef = OpUndef %uintt OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "SamplerImageAddressingModeNV is in an invalid layout section")); } TEST_F(ValidateLayout, MissingNVBindlessAddressModeFromLayout) { std::string str = R"( OpCapability Shader OpCapability BindlessTextureNV OpExtension "SPV_NV_bindless_texture" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %func "main" %voidt = OpTypeVoid %uintt = OpTypeInt 32 0 %funct = OpTypeFunction %voidt %func = OpFunction %voidt None %funct %entry = OpLabel %udef = OpUndef %uintt OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Missing required OpSamplerImageAddressingModeNV instruction")); } TEST_F(ValidateLayout, NVBindlessAddressModeFromLayoutSpecifiedTwice) { std::string str = R"( OpCapability Shader OpCapability BindlessTextureNV OpExtension "SPV_NV_bindless_texture" OpMemoryModel Logical GLSL450 OpSamplerImageAddressingModeNV 64 OpSamplerImageAddressingModeNV 64 )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpSamplerImageAddressingModeNV should only be provided once")); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_limits_test.cpp000066400000000000000000000554641475742701700242160ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validation tests for Universal Limits. (Section 2.17 of the SPIR-V Spec) #include #include #include "gmock/gmock.h" #include "test/unit_spirv.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::HasSubstr; using ::testing::MatchesRegex; using ValidateLimits = spvtest::ValidateBase; std::string header = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 )"; TEST_F(ValidateLimits, IdLargerThanBoundBad) { std::string str = header + R"( ; %i32 has ID 1 %i32 = OpTypeInt 32 1 %c = OpConstant %i32 100 ; Fake an instruction with 64 as the result id. ; !64 = OpConstantNull %i32 !0x3002e !1 !64 )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_BINARY, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Result '64' must be less than the ID bound '3'.")); } TEST_F(ValidateLimits, IdEqualToBoundBad) { std::string str = header + R"( ; %i32 has ID 1 %i32 = OpTypeInt 32 1 %c = OpConstant %i32 100 ; Fake an instruction with 64 as the result id. ; !64 = OpConstantNull %i32 !0x3002e !1 !64 )"; CompileSuccessfully(str); // The largest ID used in this program is 64. Let's overwrite the ID bound in // the header to be 64. This should result in an error because all IDs must // satisfy: 0 < id < bound. OverwriteAssembledBinary(3, 64); ASSERT_EQ(SPV_ERROR_INVALID_BINARY, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Result '64' must be less than the ID bound '64'.")); } TEST_F(ValidateLimits, IdBoundTooBigDeaultLimit) { std::string str = header; CompileSuccessfully(str); // The largest ID used in this program is 64. Let's overwrite the ID bound in // the header to be 64. This should result in an error because all IDs must // satisfy: 0 < id < bound. OverwriteAssembledBinary(3, 0x4FFFFF); ASSERT_EQ(SPV_ERROR_INVALID_BINARY, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Invalid SPIR-V. The id bound is larger than the max " "id bound 4194303.")); } TEST_F(ValidateLimits, IdBoundAtSetLimit) { std::string str = header; CompileSuccessfully(str); // The largest ID used in this program is 64. Let's overwrite the ID bound in // the header to be 64. This should result in an error because all IDs must // satisfy: 0 < id < bound. uint32_t id_bound = 0x4FFFFF; OverwriteAssembledBinary(3, id_bound); getValidatorOptions()->universal_limits_.max_id_bound = id_bound; ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateLimits, IdBoundJustAboveSetLimit) { std::string str = header; CompileSuccessfully(str); // The largest ID used in this program is 64. Let's overwrite the ID bound in // the header to be 64. This should result in an error because all IDs must // satisfy: 0 < id < bound. uint32_t id_bound = 5242878; OverwriteAssembledBinary(3, id_bound); getValidatorOptions()->universal_limits_.max_id_bound = id_bound - 1; ASSERT_EQ(SPV_ERROR_INVALID_BINARY, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Invalid SPIR-V. The id bound is larger than the max " "id bound 5242877.")); } TEST_F(ValidateLimits, IdBoundAtInMaxLimit) { std::string str = header; CompileSuccessfully(str); uint32_t id_bound = std::numeric_limits::max(); OverwriteAssembledBinary(3, id_bound); getValidatorOptions()->universal_limits_.max_id_bound = id_bound; ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateLimits, StructNumMembersGood) { std::ostringstream spirv; spirv << header << R"( %1 = OpTypeInt 32 0 %2 = OpTypeStruct)"; for (int i = 0; i < 16383; ++i) { spirv << " %1"; } CompileSuccessfully(spirv.str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateLimits, StructNumMembersExceededBad) { std::ostringstream spirv; spirv << header << R"( %1 = OpTypeInt 32 0 %2 = OpTypeStruct)"; for (int i = 0; i < 16384; ++i) { spirv << " %1"; } CompileSuccessfully(spirv.str()); ASSERT_EQ(SPV_ERROR_INVALID_BINARY, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Number of OpTypeStruct members (16384) has exceeded " "the limit (16383).")); } TEST_F(ValidateLimits, CustomizedStructNumMembersGood) { std::ostringstream spirv; spirv << header << R"( %1 = OpTypeInt 32 0 %2 = OpTypeStruct)"; for (int i = 0; i < 32000; ++i) { spirv << " %1"; } spvValidatorOptionsSetUniversalLimit( options_, spv_validator_limit_max_struct_members, 32000u); CompileSuccessfully(spirv.str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateLimits, CustomizedStructNumMembersBad) { std::ostringstream spirv; spirv << header << R"( %1 = OpTypeInt 32 0 %2 = OpTypeStruct)"; for (int i = 0; i < 32001; ++i) { spirv << " %1"; } spvValidatorOptionsSetUniversalLimit( options_, spv_validator_limit_max_struct_members, 32000u); CompileSuccessfully(spirv.str()); ASSERT_EQ(SPV_ERROR_INVALID_BINARY, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Number of OpTypeStruct members (32001) has exceeded " "the limit (32000).")); } // Valid: Switch statement has 16,383 branches. TEST_F(ValidateLimits, SwitchNumBranchesGood) { std::ostringstream spirv; spirv << header << R"( %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpTypeInt 32 0 %4 = OpConstant %3 1234 %5 = OpFunction %1 None %2 %7 = OpLabel %8 = OpIAdd %3 %4 %4 OpSelectionMerge %10 None OpSwitch %4 %10)"; // Now add the (literal, label) pairs for (int i = 0; i < 16383; ++i) { spirv << " 1 %10"; } spirv << R"( %10 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } // Invalid: Switch statement has 16,384 branches. TEST_F(ValidateLimits, SwitchNumBranchesBad) { std::ostringstream spirv; spirv << header << R"( %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpTypeInt 32 0 %4 = OpConstant %3 1234 %5 = OpFunction %1 None %2 %7 = OpLabel %8 = OpIAdd %3 %4 %4 OpSelectionMerge %10 None OpSwitch %4 %10)"; // Now add the (literal, label) pairs for (int i = 0; i < 16384; ++i) { spirv << " 1 %10"; } spirv << R"( %10 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.str()); ASSERT_EQ(SPV_ERROR_INVALID_BINARY, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Number of (literal, label) pairs in OpSwitch (16384) " "exceeds the limit (16383).")); } // Valid: Switch statement has 10 branches (limit is 10) TEST_F(ValidateLimits, CustomizedSwitchNumBranchesGood) { std::ostringstream spirv; spirv << header << R"( %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpTypeInt 32 0 %4 = OpConstant %3 1234 %5 = OpFunction %1 None %2 %7 = OpLabel %8 = OpIAdd %3 %4 %4 OpSelectionMerge %10 None OpSwitch %4 %10)"; // Now add the (literal, label) pairs for (int i = 0; i < 10; ++i) { spirv << " 1 %10"; } spirv << R"( %10 = OpLabel OpReturn OpFunctionEnd )"; spvValidatorOptionsSetUniversalLimit( options_, spv_validator_limit_max_switch_branches, 10u); CompileSuccessfully(spirv.str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } // Invalid: Switch statement has 11 branches (limit is 10) TEST_F(ValidateLimits, CustomizedSwitchNumBranchesBad) { std::ostringstream spirv; spirv << header << R"( %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpTypeInt 32 0 %4 = OpConstant %3 1234 %5 = OpFunction %1 None %2 %7 = OpLabel %8 = OpIAdd %3 %4 %4 OpSelectionMerge %10 None OpSwitch %4 %10)"; // Now add the (literal, label) pairs for (int i = 0; i < 11; ++i) { spirv << " 1 %10"; } spirv << R"( %10 = OpLabel OpReturn OpFunctionEnd )"; spvValidatorOptionsSetUniversalLimit( options_, spv_validator_limit_max_switch_branches, 10u); CompileSuccessfully(spirv.str()); ASSERT_EQ(SPV_ERROR_INVALID_BINARY, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Number of (literal, label) pairs in OpSwitch (11) " "exceeds the limit (10).")); } // Valid: OpTypeFunction with 255 arguments. TEST_F(ValidateLimits, OpTypeFunctionGood) { int num_args = 255; std::ostringstream spirv; spirv << header << R"( %1 = OpTypeInt 32 0 %2 = OpTypeFunction %1)"; // add parameters for (int i = 0; i < num_args; ++i) { spirv << " %1"; } CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // Invalid: OpTypeFunction with 256 arguments. (limit is 255 according to the // spec Universal Limits (2.17). TEST_F(ValidateLimits, OpTypeFunctionBad) { int num_args = 256; std::ostringstream spirv; spirv << header << R"( %1 = OpTypeInt 32 0 %2 = OpTypeFunction %1)"; for (int i = 0; i < num_args; ++i) { spirv << " %1"; } CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpTypeFunction may not take more than 255 arguments. " "OpTypeFunction '2[%2]' has 256 arguments.")); } // Valid: OpTypeFunction with 100 arguments (Custom limit: 100) TEST_F(ValidateLimits, CustomizedOpTypeFunctionGood) { int num_args = 100; std::ostringstream spirv; spirv << header << R"( %1 = OpTypeInt 32 0 %2 = OpTypeFunction %1)"; // add parameters for (int i = 0; i < num_args; ++i) { spirv << " %1"; } spvValidatorOptionsSetUniversalLimit( options_, spv_validator_limit_max_function_args, 100u); CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // Invalid: OpTypeFunction with 101 arguments. (Custom limit: 100) TEST_F(ValidateLimits, CustomizedOpTypeFunctionBad) { int num_args = 101; std::ostringstream spirv; spirv << header << R"( %1 = OpTypeInt 32 0 %2 = OpTypeFunction %1)"; for (int i = 0; i < num_args; ++i) { spirv << " %1"; } spvValidatorOptionsSetUniversalLimit( options_, spv_validator_limit_max_function_args, 100u); CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpTypeFunction may not take more than 100 arguments. " "OpTypeFunction '2[%2]' has 101 arguments.")); } // Valid: module has 65,535 global variables. TEST_F(ValidateLimits, NumGlobalVarsGood) { int num_globals = 65535; std::ostringstream spirv; spirv << header << R"( %int = OpTypeInt 32 0 %_ptr_int = OpTypePointer Input %int )"; for (int i = 0; i < num_globals; ++i) { spirv << "%var_" << i << " = OpVariable %_ptr_int Input\n"; } CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // Invalid: module has 65,536 global variables (limit is 65,535). TEST_F(ValidateLimits, NumGlobalVarsBad) { int num_globals = 65536; std::ostringstream spirv; spirv << header << R"( %int = OpTypeInt 32 0 %_ptr_int = OpTypePointer Input %int )"; for (int i = 0; i < num_globals; ++i) { spirv << "%var_" << i << " = OpVariable %_ptr_int Input\n"; } CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_ERROR_INVALID_BINARY, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Number of Global Variables (Storage Class other than " "'Function') exceeded the valid limit (65535).")); } // Valid: module has 50 global variables (limit is 50) TEST_F(ValidateLimits, CustomizedNumGlobalVarsGood) { int num_globals = 50; std::ostringstream spirv; spirv << header << R"( %int = OpTypeInt 32 0 %_ptr_int = OpTypePointer Input %int )"; for (int i = 0; i < num_globals; ++i) { spirv << "%var_" << i << " = OpVariable %_ptr_int Input\n"; } spvValidatorOptionsSetUniversalLimit( options_, spv_validator_limit_max_global_variables, 50u); CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // Invalid: module has 51 global variables (limit is 50). TEST_F(ValidateLimits, CustomizedNumGlobalVarsBad) { int num_globals = 51; std::ostringstream spirv; spirv << header << R"( %int = OpTypeInt 32 0 %_ptr_int = OpTypePointer Input %int )"; for (int i = 0; i < num_globals; ++i) { spirv << "%var_" << i << " = OpVariable %_ptr_int Input\n"; } spvValidatorOptionsSetUniversalLimit( options_, spv_validator_limit_max_global_variables, 50u); CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_ERROR_INVALID_BINARY, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Number of Global Variables (Storage Class other than " "'Function') exceeded the valid limit (50).")); } // Valid: module has 524,287 local variables. // Note: AppVeyor limits process time to 300s. For a VisualStudio Debug // build, going up to 524287 local variables gets too close to that // limit. So test with an artificially lowered limit. TEST_F(ValidateLimits, NumLocalVarsGoodArtificiallyLowLimit5K) { int num_locals = 5000; std::ostringstream spirv; spirv << header << R"( %int = OpTypeInt 32 0 %_ptr_int = OpTypePointer Function %int %voidt = OpTypeVoid %funct = OpTypeFunction %voidt %main = OpFunction %voidt None %funct %entry = OpLabel )"; for (int i = 0; i < num_locals; ++i) { spirv << "%var_" << i << " = OpVariable %_ptr_int Function\n"; } spirv << R"( OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.str()); // Artificially limit it. spvValidatorOptionsSetUniversalLimit( options_, spv_validator_limit_max_local_variables, num_locals); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // Invalid: module has 524,288 local variables (limit is 524,287). // Artificially limit the check to 5001. TEST_F(ValidateLimits, NumLocalVarsBadArtificiallyLowLimit5K) { int num_locals = 5001; std::ostringstream spirv; spirv << header << R"( %int = OpTypeInt 32 0 %_ptr_int = OpTypePointer Function %int %voidt = OpTypeVoid %funct = OpTypeFunction %voidt %main = OpFunction %voidt None %funct %entry = OpLabel )"; for (int i = 0; i < num_locals; ++i) { spirv << "%var_" << i << " = OpVariable %_ptr_int Function\n"; } spirv << R"( OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.str()); spvValidatorOptionsSetUniversalLimit( options_, spv_validator_limit_max_local_variables, 5000u); EXPECT_EQ(SPV_ERROR_INVALID_BINARY, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Number of local variables ('Function' Storage Class) " "exceeded the valid limit (5000).")); } // Valid: module has 100 local variables (limit is 100). TEST_F(ValidateLimits, CustomizedNumLocalVarsGood) { int num_locals = 100; std::ostringstream spirv; spirv << header << R"( %int = OpTypeInt 32 0 %_ptr_int = OpTypePointer Function %int %voidt = OpTypeVoid %funct = OpTypeFunction %voidt %main = OpFunction %voidt None %funct %entry = OpLabel )"; for (int i = 0; i < num_locals; ++i) { spirv << "%var_" << i << " = OpVariable %_ptr_int Function\n"; } spirv << R"( OpReturn OpFunctionEnd )"; spvValidatorOptionsSetUniversalLimit( options_, spv_validator_limit_max_local_variables, 100u); CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // Invalid: module has 101 local variables (limit is 100). TEST_F(ValidateLimits, CustomizedNumLocalVarsBad) { int num_locals = 101; std::ostringstream spirv; spirv << header << R"( %int = OpTypeInt 32 0 %_ptr_int = OpTypePointer Function %int %voidt = OpTypeVoid %funct = OpTypeFunction %voidt %main = OpFunction %voidt None %funct %entry = OpLabel )"; for (int i = 0; i < num_locals; ++i) { spirv << "%var_" << i << " = OpVariable %_ptr_int Function\n"; } spirv << R"( OpReturn OpFunctionEnd )"; spvValidatorOptionsSetUniversalLimit( options_, spv_validator_limit_max_local_variables, 100u); CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_ERROR_INVALID_BINARY, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Number of local variables ('Function' Storage Class) " "exceeded the valid limit (100).")); } // Valid: Structure nesting depth of 255. TEST_F(ValidateLimits, StructNestingDepthGood) { std::ostringstream spirv; spirv << header << R"( %int = OpTypeInt 32 0 %s_depth_1 = OpTypeStruct %int )"; for (auto i = 2; i <= 255; ++i) { spirv << "%s_depth_" << i << " = OpTypeStruct %int %s_depth_" << i - 1; spirv << "\n"; } CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // Invalid: Structure nesting depth of 256. TEST_F(ValidateLimits, StructNestingDepthBad) { std::ostringstream spirv; spirv << header << R"( %int = OpTypeInt 32 0 %s_depth_1 = OpTypeStruct %int )"; for (auto i = 2; i <= 256; ++i) { spirv << "%s_depth_" << i << " = OpTypeStruct %int %s_depth_" << i - 1; spirv << "\n"; } CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_ERROR_INVALID_BINARY, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Structure Nesting Depth may not be larger than 255. Found 256.")); } // Valid: Structure nesting depth of 100 (limit is 100). TEST_F(ValidateLimits, CustomizedStructNestingDepthGood) { std::ostringstream spirv; spirv << header << R"( %int = OpTypeInt 32 0 %s_depth_1 = OpTypeStruct %int )"; for (auto i = 2; i <= 100; ++i) { spirv << "%s_depth_" << i << " = OpTypeStruct %int %s_depth_" << i - 1; spirv << "\n"; } spvValidatorOptionsSetUniversalLimit( options_, spv_validator_limit_max_struct_depth, 100u); CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // Invalid: Structure nesting depth of 101 (limit is 100). TEST_F(ValidateLimits, CustomizedStructNestingDepthBad) { std::ostringstream spirv; spirv << header << R"( %int = OpTypeInt 32 0 %s_depth_1 = OpTypeStruct %int )"; for (auto i = 2; i <= 101; ++i) { spirv << "%s_depth_" << i << " = OpTypeStruct %int %s_depth_" << i - 1; spirv << "\n"; } spvValidatorOptionsSetUniversalLimit( options_, spv_validator_limit_max_struct_depth, 100u); CompileSuccessfully(spirv.str()); EXPECT_EQ(SPV_ERROR_INVALID_BINARY, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Structure Nesting Depth may not be larger than 100. Found 101.")); } // clang-format off // Generates an SPIRV program with the given control flow nesting depth void GenerateSpirvProgramWithCfgNestingDepth(std::string& str, int depth) { std::ostringstream spirv; spirv << header << R"( %void = OpTypeVoid %3 = OpTypeFunction %void %bool = OpTypeBool %12 = OpConstantTrue %bool %main = OpFunction %void None %3 %5 = OpLabel OpBranch %6 %6 = OpLabel OpLoopMerge %8 %9 None OpBranch %10 %10 = OpLabel OpBranchConditional %12 %7 %8 %7 = OpLabel )"; int first_id = 13; int last_id = 14; // We already have 1 level of nesting due to the Loop. int num_if_conditions = depth-1; int largest_index = first_id + 2*num_if_conditions - 2; for (int i = first_id; i <= largest_index; i = i + 2) { spirv << "OpSelectionMerge %" << i+1 << " None" << "\n"; spirv << "OpBranchConditional %12 " << "%" << i << " %" << i+1 << "\n"; spirv << "%" << i << " = OpLabel" << "\n"; } spirv << "OpBranch %9" << "\n"; for (int i = largest_index+1; i > last_id; i = i - 2) { spirv << "%" << i << " = OpLabel" << "\n"; spirv << "OpBranch %" << i-2 << "\n"; } spirv << "%" << last_id << " = OpLabel" << "\n"; spirv << "OpBranch %9" << "\n"; spirv << R"( %9 = OpLabel OpBranch %6 %8 = OpLabel OpReturn OpFunctionEnd )"; str = spirv.str(); } // clang-format on // Invalid: Control Flow Nesting depth is 1024. (limit is 1023). TEST_F(ValidateLimits, ControlFlowDepthBad) { std::string spirv; GenerateSpirvProgramWithCfgNestingDepth(spirv, 1024); CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Maximum Control Flow nesting depth exceeded.")); } // Valid: Control Flow Nesting depth is 10 (custom limit: 10). TEST_F(ValidateLimits, CustomizedControlFlowDepthGood) { std::string spirv; GenerateSpirvProgramWithCfgNestingDepth(spirv, 10); spvValidatorOptionsSetUniversalLimit( options_, spv_validator_limit_max_control_flow_nesting_depth, 10u); CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } // Invalid: Control Flow Nesting depth is 11. (custom limit: 10). TEST_F(ValidateLimits, CustomizedControlFlowDepthBad) { std::string spirv; GenerateSpirvProgramWithCfgNestingDepth(spirv, 11); spvValidatorOptionsSetUniversalLimit( options_, spv_validator_limit_max_control_flow_nesting_depth, 10u); CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Maximum Control Flow nesting depth exceeded.")); } // Valid. The purpose here is to test the CFG depth calculation code when a loop // continue target is the loop itself. It also exercises the case where a loop // is unreachable. TEST_F(ValidateLimits, ControlFlowNoEntryToLoopGood) { std::string str = header + R"( OpName %entry "entry" OpName %loop "loop" OpName %exit "exit" %voidt = OpTypeVoid %boolt = OpTypeBool %undef = OpUndef %boolt %funct = OpTypeFunction %voidt %main = OpFunction %voidt None %funct %entry = OpLabel OpBranch %exit %loop = OpLabel OpLoopMerge %dead %loop None OpBranchConditional %undef %loop %loop %dead = OpLabel OpUnreachable %exit = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_literals_test.cpp000066400000000000000000000116441475742701700245240ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validation tests for illegal literals #include #include #include "gmock/gmock.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::HasSubstr; using ValidateLiterals = spvtest::ValidateBase; using ValidateLiteralsShader = spvtest::ValidateBase; using ValidateLiteralsKernel = spvtest::ValidateBase; std::string GenerateShaderCode() { std::string str = R"( OpCapability Shader OpCapability Linkage OpCapability Int16 OpCapability Int64 OpCapability Float16 OpCapability Float64 OpMemoryModel Logical GLSL450 %int16 = OpTypeInt 16 1 %uint16 = OpTypeInt 16 0 %int32 = OpTypeInt 32 1 %uint32 = OpTypeInt 32 0 %int64 = OpTypeInt 64 1 %uint64 = OpTypeInt 64 0 %half = OpTypeFloat 16 %float = OpTypeFloat 32 %double = OpTypeFloat 64 %10 = OpTypeVoid )"; return str; } std::string GenerateKernelCode() { std::string str = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpCapability Int8 OpMemoryModel Physical64 OpenCL %uint8 = OpTypeInt 8 0 )"; return str; } TEST_F(ValidateLiterals, LiteralsShaderGood) { std::string str = GenerateShaderCode() + R"( %11 = OpConstant %int16 !0x00007FFF %12 = OpConstant %int16 !0xFFFF8000 %13 = OpConstant %int16 !0xFFFFABCD %14 = OpConstant %uint16 !0x0000ABCD %15 = OpConstant %int16 -32768 %16 = OpConstant %uint16 65535 %17 = OpConstant %int32 -2147483648 %18 = OpConstant %uint32 4294967295 %19 = OpConstant %int64 -9223372036854775808 %20 = OpConstant %uint64 18446744073709551615 %21 = OpConstant %half !0x0000FFFF %22 = OpConstant %float !0xFFFFFFFF %23 = OpConstant %double !0xFFFFFFFF !0xFFFFFFFF )"; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateLiterals, InvalidInt) { std::string str = GenerateShaderCode() + R"( %11 = OpTypeInt 32 90 )"; CompileSuccessfully(str); EXPECT_EQ(SPV_ERROR_INVALID_VALUE, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpTypeInt has invalid signedness:")); } TEST_P(ValidateLiteralsShader, LiteralsShaderBad) { std::string str = GenerateShaderCode() + GetParam(); std::string inst_id = "11"; CompileSuccessfully(str); EXPECT_EQ(SPV_ERROR_INVALID_VALUE, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("The high-order bits of a literal number in instruction " + inst_id + " must be 0 for a floating-point type, " "or 0 for an integer type with Signedness of 0, " "or sign extended when Signedness is 1")); } INSTANTIATE_TEST_SUITE_P( LiteralsShaderCases, ValidateLiteralsShader, ::testing::Values("%11 = OpConstant %int16 !0xFFFF0000", // Sign bit is 0 "%11 = OpConstant %int16 !0x00008000", // Sign bit is 1 "%11 = OpConstant %int16 !0xABCD8000", // Sign bit is 1 "%11 = OpConstant %int16 !0xABCD0000", "%11 = OpConstant %uint16 !0xABCD0000", "%11 = OpConstant %half !0xABCD0000", "%11 = OpConstant %half !0x00010000")); TEST_F(ValidateLiterals, LiteralsKernelGood) { std::string str = GenerateKernelCode() + R"( %4 = OpConstant %uint8 !0x000000AB %6 = OpConstant %uint8 255 )"; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateLiteralsKernel, LiteralsKernelBad) { std::string str = GenerateKernelCode() + GetParam(); std::string inst_id = "2"; CompileSuccessfully(str); EXPECT_EQ(SPV_ERROR_INVALID_VALUE, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("The high-order bits of a literal number in instruction " + inst_id + " must be 0 for a floating-point type, " "or 0 for an integer type with Signedness of 0, " "or sign extended when Signedness is 1")); } INSTANTIATE_TEST_SUITE_P( LiteralsKernelCases, ValidateLiteralsKernel, ::testing::Values("%2 = OpConstant %uint8 !0xABCDEF00", "%2 = OpConstant %uint8 !0xABCDEFFF")); } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_logicals_test.cpp000066400000000000000000001142341475742701700245010ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Tests for unique type declaration rules validator. #include #include "gmock/gmock.h" #include "test/unit_spirv.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::Eq; using ::testing::HasSubstr; using ::testing::Not; using ValidateLogicals = spvtest::ValidateBase; std::string GenerateShaderCode( const std::string& body, const std::string& capabilities_and_extensions = "") { const std::string capabilities = R"( OpCapability Shader OpCapability Int64 OpCapability Float64)"; const std::string after_extension_before_body = R"( %ext_inst = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f32 = OpTypeFloat 32 %u32 = OpTypeInt 32 0 %s32 = OpTypeInt 32 1 %f64 = OpTypeFloat 64 %u64 = OpTypeInt 64 0 %s64 = OpTypeInt 64 1 %boolvec2 = OpTypeVector %bool 2 %s32vec2 = OpTypeVector %s32 2 %u32vec2 = OpTypeVector %u32 2 %u64vec2 = OpTypeVector %u64 2 %f32vec2 = OpTypeVector %f32 2 %f64vec2 = OpTypeVector %f64 2 %boolvec3 = OpTypeVector %bool 3 %u32vec3 = OpTypeVector %u32 3 %u64vec3 = OpTypeVector %u64 3 %s32vec3 = OpTypeVector %s32 3 %f32vec3 = OpTypeVector %f32 3 %f64vec3 = OpTypeVector %f64 3 %boolvec4 = OpTypeVector %bool 4 %u32vec4 = OpTypeVector %u32 4 %u64vec4 = OpTypeVector %u64 4 %s32vec4 = OpTypeVector %s32 4 %f32vec4 = OpTypeVector %f32 4 %f64vec4 = OpTypeVector %f64 4 %f32_0 = OpConstant %f32 0 %f32_1 = OpConstant %f32 1 %f32_2 = OpConstant %f32 2 %f32_3 = OpConstant %f32 3 %f32_4 = OpConstant %f32 4 %s32_0 = OpConstant %s32 0 %s32_1 = OpConstant %s32 1 %s32_2 = OpConstant %s32 2 %s32_3 = OpConstant %s32 3 %s32_4 = OpConstant %s32 4 %s32_m1 = OpConstant %s32 -1 %u32_0 = OpConstant %u32 0 %u32_1 = OpConstant %u32 1 %u32_2 = OpConstant %u32 2 %u32_3 = OpConstant %u32 3 %u32_4 = OpConstant %u32 4 %f64_0 = OpConstant %f64 0 %f64_1 = OpConstant %f64 1 %f64_2 = OpConstant %f64 2 %f64_3 = OpConstant %f64 3 %f64_4 = OpConstant %f64 4 %s64_0 = OpConstant %s64 0 %s64_1 = OpConstant %s64 1 %s64_2 = OpConstant %s64 2 %s64_3 = OpConstant %s64 3 %s64_4 = OpConstant %s64 4 %s64_m1 = OpConstant %s64 -1 %u64_0 = OpConstant %u64 0 %u64_1 = OpConstant %u64 1 %u64_2 = OpConstant %u64 2 %u64_3 = OpConstant %u64 3 %u64_4 = OpConstant %u64 4 %u32vec2_01 = OpConstantComposite %u32vec2 %u32_0 %u32_1 %u32vec2_12 = OpConstantComposite %u32vec2 %u32_1 %u32_2 %u32vec3_012 = OpConstantComposite %u32vec3 %u32_0 %u32_1 %u32_2 %u32vec3_123 = OpConstantComposite %u32vec3 %u32_1 %u32_2 %u32_3 %u32vec4_0123 = OpConstantComposite %u32vec4 %u32_0 %u32_1 %u32_2 %u32_3 %u32vec4_1234 = OpConstantComposite %u32vec4 %u32_1 %u32_2 %u32_3 %u32_4 %s32vec2_01 = OpConstantComposite %s32vec2 %s32_0 %s32_1 %s32vec2_12 = OpConstantComposite %s32vec2 %s32_1 %s32_2 %s32vec3_012 = OpConstantComposite %s32vec3 %s32_0 %s32_1 %s32_2 %s32vec3_123 = OpConstantComposite %s32vec3 %s32_1 %s32_2 %s32_3 %s32vec4_0123 = OpConstantComposite %s32vec4 %s32_0 %s32_1 %s32_2 %s32_3 %s32vec4_1234 = OpConstantComposite %s32vec4 %s32_1 %s32_2 %s32_3 %s32_4 %f32vec2_01 = OpConstantComposite %f32vec2 %f32_0 %f32_1 %f32vec2_12 = OpConstantComposite %f32vec2 %f32_1 %f32_2 %f32vec3_012 = OpConstantComposite %f32vec3 %f32_0 %f32_1 %f32_2 %f32vec3_123 = OpConstantComposite %f32vec3 %f32_1 %f32_2 %f32_3 %f32vec4_0123 = OpConstantComposite %f32vec4 %f32_0 %f32_1 %f32_2 %f32_3 %f32vec4_1234 = OpConstantComposite %f32vec4 %f32_1 %f32_2 %f32_3 %f32_4 %f64vec2_01 = OpConstantComposite %f64vec2 %f64_0 %f64_1 %f64vec2_12 = OpConstantComposite %f64vec2 %f64_1 %f64_2 %f64vec3_012 = OpConstantComposite %f64vec3 %f64_0 %f64_1 %f64_2 %f64vec3_123 = OpConstantComposite %f64vec3 %f64_1 %f64_2 %f64_3 %f64vec4_0123 = OpConstantComposite %f64vec4 %f64_0 %f64_1 %f64_2 %f64_3 %f64vec4_1234 = OpConstantComposite %f64vec4 %f64_1 %f64_2 %f64_3 %f64_4 %true = OpConstantTrue %bool %false = OpConstantFalse %bool %boolvec2_tf = OpConstantComposite %boolvec2 %true %false %boolvec3_tft = OpConstantComposite %boolvec3 %true %false %true %boolvec4_tftf = OpConstantComposite %boolvec4 %true %false %true %false %arr_u32_2 = OpTypeArray %u32 %u32_2 %st_u32_u32 = OpTypeStruct %u32 %u32 %mat_f32_2_2 = OpTypeMatrix %f32vec2 2 %nul_arr_u32_2 = OpConstantNull %arr_u32_2 %nul_st_u32_u32 = OpConstantNull %st_u32_u32 %nul_mat_f32_2_2 = OpConstantNull %mat_f32_2_2 %arr_u32_2_1_2 = OpConstantComposite %arr_u32_2 %u32_1 %u32_2 %st_u32_u32_1_2 = OpConstantComposite %st_u32_u32 %u32_1 %u32_2 %mat_f32_2_2_01_12 = OpConstantComposite %mat_f32_2_2 %f32vec2_01 %f32vec2_12 %f32vec4ptr = OpTypePointer Function %f32vec4 %main = OpFunction %void None %func %main_entry = OpLabel)"; const std::string after_body = R"( OpReturn OpFunctionEnd)"; return capabilities + capabilities_and_extensions + after_extension_before_body + body + after_body; } std::string GenerateKernelCode( const std::string& body, const std::string& capabilities_and_extensions = "") { const std::string capabilities = R"( OpCapability Addresses OpCapability Kernel OpCapability Linkage OpCapability Int64 OpCapability Float64)"; const std::string after_extension_before_body = R"( OpMemoryModel Physical32 OpenCL %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f32 = OpTypeFloat 32 %u32 = OpTypeInt 32 0 %f64 = OpTypeFloat 64 %u64 = OpTypeInt 64 0 %boolvec2 = OpTypeVector %bool 2 %u32vec2 = OpTypeVector %u32 2 %u64vec2 = OpTypeVector %u64 2 %f32vec2 = OpTypeVector %f32 2 %f64vec2 = OpTypeVector %f64 2 %boolvec3 = OpTypeVector %bool 3 %u32vec3 = OpTypeVector %u32 3 %u64vec3 = OpTypeVector %u64 3 %f32vec3 = OpTypeVector %f32 3 %f64vec3 = OpTypeVector %f64 3 %boolvec4 = OpTypeVector %bool 4 %u32vec4 = OpTypeVector %u32 4 %u64vec4 = OpTypeVector %u64 4 %f32vec4 = OpTypeVector %f32 4 %f64vec4 = OpTypeVector %f64 4 %f32_0 = OpConstant %f32 0 %f32_1 = OpConstant %f32 1 %f32_2 = OpConstant %f32 2 %f32_3 = OpConstant %f32 3 %f32_4 = OpConstant %f32 4 %u32_0 = OpConstant %u32 0 %u32_1 = OpConstant %u32 1 %u32_2 = OpConstant %u32 2 %u32_3 = OpConstant %u32 3 %u32_4 = OpConstant %u32 4 %f64_0 = OpConstant %f64 0 %f64_1 = OpConstant %f64 1 %f64_2 = OpConstant %f64 2 %f64_3 = OpConstant %f64 3 %f64_4 = OpConstant %f64 4 %u64_0 = OpConstant %u64 0 %u64_1 = OpConstant %u64 1 %u64_2 = OpConstant %u64 2 %u64_3 = OpConstant %u64 3 %u64_4 = OpConstant %u64 4 %u32vec2_01 = OpConstantComposite %u32vec2 %u32_0 %u32_1 %u32vec2_12 = OpConstantComposite %u32vec2 %u32_1 %u32_2 %u32vec3_012 = OpConstantComposite %u32vec3 %u32_0 %u32_1 %u32_2 %u32vec3_123 = OpConstantComposite %u32vec3 %u32_1 %u32_2 %u32_3 %u32vec4_0123 = OpConstantComposite %u32vec4 %u32_0 %u32_1 %u32_2 %u32_3 %u32vec4_1234 = OpConstantComposite %u32vec4 %u32_1 %u32_2 %u32_3 %u32_4 %f32vec2_01 = OpConstantComposite %f32vec2 %f32_0 %f32_1 %f32vec2_12 = OpConstantComposite %f32vec2 %f32_1 %f32_2 %f32vec3_012 = OpConstantComposite %f32vec3 %f32_0 %f32_1 %f32_2 %f32vec3_123 = OpConstantComposite %f32vec3 %f32_1 %f32_2 %f32_3 %f32vec4_0123 = OpConstantComposite %f32vec4 %f32_0 %f32_1 %f32_2 %f32_3 %f32vec4_1234 = OpConstantComposite %f32vec4 %f32_1 %f32_2 %f32_3 %f32_4 %f64vec2_01 = OpConstantComposite %f64vec2 %f64_0 %f64_1 %f64vec2_12 = OpConstantComposite %f64vec2 %f64_1 %f64_2 %f64vec3_012 = OpConstantComposite %f64vec3 %f64_0 %f64_1 %f64_2 %f64vec3_123 = OpConstantComposite %f64vec3 %f64_1 %f64_2 %f64_3 %f64vec4_0123 = OpConstantComposite %f64vec4 %f64_0 %f64_1 %f64_2 %f64_3 %f64vec4_1234 = OpConstantComposite %f64vec4 %f64_1 %f64_2 %f64_3 %f64_4 %true = OpConstantTrue %bool %false = OpConstantFalse %bool %boolvec2_tf = OpConstantComposite %boolvec2 %true %false %boolvec3_tft = OpConstantComposite %boolvec3 %true %false %true %boolvec4_tftf = OpConstantComposite %boolvec4 %true %false %true %false %f32vec4ptr = OpTypePointer Function %f32vec4 %main = OpFunction %void None %func %main_entry = OpLabel)"; const std::string after_body = R"( OpReturn OpFunctionEnd)"; return capabilities + capabilities_and_extensions + after_extension_before_body + body + after_body; } TEST_F(ValidateLogicals, OpAnySuccess) { const std::string body = R"( %val1 = OpAny %bool %boolvec2_tf %val2 = OpAny %bool %boolvec3_tft %val3 = OpAny %bool %boolvec4_tftf )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateLogicals, OpAnyWrongTypeId) { const std::string body = R"( %val = OpAny %u32 %boolvec2_tf )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected bool scalar type as Result Type: Any")); } TEST_F(ValidateLogicals, OpAnyWrongOperand) { const std::string body = R"( %val = OpAny %bool %u32vec3_123 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected operand to be vector bool: Any")); } TEST_F(ValidateLogicals, OpIsNanSuccess) { const std::string body = R"( %val1 = OpIsNan %bool %f32_1 %val2 = OpIsNan %bool %f64_0 %val3 = OpIsNan %boolvec2 %f32vec2_12 %val4 = OpIsNan %boolvec3 %f32vec3_123 %val5 = OpIsNan %boolvec4 %f32vec4_1234 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateLogicals, OpIsNanWrongTypeId) { const std::string body = R"( %val1 = OpIsNan %u32 %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected bool scalar or vector type as Result Type: IsNan")); } TEST_F(ValidateLogicals, OpIsNanOperandNotFloat) { const std::string body = R"( %val1 = OpIsNan %bool %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected operand to be scalar or vector float: IsNan")); } TEST_F(ValidateLogicals, OpIsNanOperandWrongSize) { const std::string body = R"( %val1 = OpIsNan %bool %f32vec2_12 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected vector sizes of Result Type and the operand to be equal: " "IsNan")); } TEST_F(ValidateLogicals, OpLessOrGreaterSuccess) { const std::string body = R"( %val1 = OpLessOrGreater %bool %f32_0 %f32_1 %val2 = OpLessOrGreater %bool %f64_0 %f64_0 %val3 = OpLessOrGreater %boolvec2 %f32vec2_12 %f32vec2_12 %val4 = OpLessOrGreater %boolvec3 %f32vec3_123 %f32vec3_123 %val5 = OpLessOrGreater %boolvec4 %f32vec4_1234 %f32vec4_1234 )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateLogicals, OpLessOrGreaterWrongTypeId) { const std::string body = R"( %val1 = OpLessOrGreater %u32 %f32_1 %f32_1 )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected bool scalar or vector type as Result Type: LessOrGreater")); } TEST_F(ValidateLogicals, OpLessOrGreaterLeftOperandNotFloat) { const std::string body = R"( %val1 = OpLessOrGreater %bool %u32_1 %f32_1 )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected operands to be scalar or vector float: LessOrGreater")); } TEST_F(ValidateLogicals, OpLessOrGreaterLeftOperandWrongSize) { const std::string body = R"( %val1 = OpLessOrGreater %bool %f32vec2_12 %f32_1 )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected vector sizes of Result Type and the operands to be equal: " "LessOrGreater")); } TEST_F(ValidateLogicals, OpLessOrGreaterOperandsDifferentType) { const std::string body = R"( %val1 = OpLessOrGreater %bool %f32_1 %f64_1 )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected left and right operands to have the same type: " "LessOrGreater")); } TEST_F(ValidateLogicals, OpFOrdEqualSuccess) { const std::string body = R"( %val1 = OpFOrdEqual %bool %f32_0 %f32_1 %val2 = OpFOrdEqual %bool %f64_0 %f64_0 %val3 = OpFOrdEqual %boolvec2 %f32vec2_12 %f32vec2_12 %val4 = OpFOrdEqual %boolvec3 %f32vec3_123 %f32vec3_123 %val5 = OpFOrdEqual %boolvec4 %f32vec4_1234 %f32vec4_1234 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateLogicals, OpFOrdEqualWrongTypeId) { const std::string body = R"( %val1 = OpFOrdEqual %u32 %f32_1 %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected bool scalar or vector type as Result Type: FOrdEqual")); } TEST_F(ValidateLogicals, OpFOrdEqualLeftOperandNotFloat) { const std::string body = R"( %val1 = OpFOrdEqual %bool %u32_1 %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected operands to be scalar or vector float: FOrdEqual")); } TEST_F(ValidateLogicals, OpFOrdEqualLeftOperandWrongSize) { const std::string body = R"( %val1 = OpFOrdEqual %bool %f32vec2_12 %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected vector sizes of Result Type and the operands to be equal: " "FOrdEqual")); } TEST_F(ValidateLogicals, OpFOrdEqualOperandsDifferentType) { const std::string body = R"( %val1 = OpFOrdEqual %bool %f32_1 %f64_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected left and right operands to have the same type: " "FOrdEqual")); } TEST_F(ValidateLogicals, OpLogicalEqualSuccess) { const std::string body = R"( %val1 = OpLogicalEqual %bool %true %false %val2 = OpLogicalEqual %boolvec2 %boolvec2_tf %boolvec2_tf %val3 = OpLogicalEqual %boolvec3 %boolvec3_tft %boolvec3_tft %val4 = OpLogicalEqual %boolvec4 %boolvec4_tftf %boolvec4_tftf )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateLogicals, OpLogicalEqualWrongTypeId) { const std::string body = R"( %val1 = OpLogicalEqual %u32 %true %false )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected bool scalar or vector type as Result Type: LogicalEqual")); } TEST_F(ValidateLogicals, OpLogicalEqualWrongLeftOperand) { const std::string body = R"( %val1 = OpLogicalEqual %bool %boolvec2_tf %false )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected both operands to be of Result Type: LogicalEqual")); } TEST_F(ValidateLogicals, OpLogicalEqualWrongRightOperand) { const std::string body = R"( %val1 = OpLogicalEqual %boolvec2 %boolvec2_tf %false )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected both operands to be of Result Type: LogicalEqual")); } TEST_F(ValidateLogicals, OpLogicalNotSuccess) { const std::string body = R"( %val1 = OpLogicalNot %bool %true %val2 = OpLogicalNot %boolvec2 %boolvec2_tf %val3 = OpLogicalNot %boolvec3 %boolvec3_tft %val4 = OpLogicalNot %boolvec4 %boolvec4_tftf )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateLogicals, OpLogicalNotWrongTypeId) { const std::string body = R"( %val1 = OpLogicalNot %u32 %true )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected bool scalar or vector type as Result Type: LogicalNot")); } TEST_F(ValidateLogicals, OpLogicalNotWrongOperand) { const std::string body = R"( %val1 = OpLogicalNot %bool %boolvec2_tf )"; CompileSuccessfully(GenerateKernelCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected operand to be of Result Type: LogicalNot")); } TEST_F(ValidateLogicals, OpSelectSuccess) { const std::string body = R"( %val1 = OpSelect %u32 %true %u32_0 %u32_1 %val2 = OpSelect %f32 %true %f32_0 %f32_1 %val3 = OpSelect %f64 %true %f64_0 %f64_1 %val4 = OpSelect %f32vec2 %boolvec2_tf %f32vec2_01 %f32vec2_12 %val5 = OpSelect %f32vec4 %boolvec4_tftf %f32vec4_0123 %f32vec4_1234 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateLogicals, OpSelectWrongTypeId) { const std::string body = R"( %val1 = OpSelect %void %true %u32_0 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected scalar or vector type as Result Type: Select")); } TEST_F(ValidateLogicals, OpSelectWrongTypeIdV14) { // In 1.4, the message changes to allow composites. const std::string body = R"( %val1 = OpSelect %void %true %u32_0 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str(), SPV_ENV_UNIVERSAL_1_4); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected scalar or composite type as Result Type: Select")); } TEST_F(ValidateLogicals, OpSelectPointerNoCapability) { const std::string body = R"( %x = OpVariable %f32vec4ptr Function %y = OpVariable %f32vec4ptr Function OpStore %x %f32vec4_0123 OpStore %y %f32vec4_1234 %val1 = OpSelect %f32vec4ptr %true %x %y )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Using pointers with OpSelect requires capability VariablePointers " "or VariablePointersStorageBuffer")); } TEST_F(ValidateLogicals, OpSelectPointerWithCapability1) { const std::string body = R"( %x = OpVariable %f32vec4ptr Function %y = OpVariable %f32vec4ptr Function OpStore %x %f32vec4_0123 OpStore %y %f32vec4_1234 %val1 = OpSelect %f32vec4ptr %true %x %y )"; const std::string extra_cap_ext = R"( OpCapability VariablePointers OpExtension "SPV_KHR_variable_pointers" )"; CompileSuccessfully(GenerateShaderCode(body, extra_cap_ext).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateLogicals, OpSelectPointerWithCapability2) { const std::string body = R"( %x = OpVariable %f32vec4ptr Function %y = OpVariable %f32vec4ptr Function OpStore %x %f32vec4_0123 OpStore %y %f32vec4_1234 %val1 = OpSelect %f32vec4ptr %true %x %y )"; const std::string extra_cap_ext = R"( OpCapability VariablePointersStorageBuffer OpExtension "SPV_KHR_variable_pointers" )"; CompileSuccessfully(GenerateShaderCode(body, extra_cap_ext).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateLogicals, OpSelectWrongCondition) { const std::string body = R"( %val1 = OpSelect %u32 %u32_1 %u32_0 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected bool scalar or vector type as condition: Select")); } TEST_F(ValidateLogicals, OpSelectWrongConditionDimension) { const std::string body = R"( %val1 = OpSelect %u32vec2 %true %u32vec2_01 %u32vec2_12 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected vector sizes of Result Type and the condition to be equal: " "Select")); } TEST_F(ValidateLogicals, OpSelectWrongLeftObject) { const std::string body = R"( %val1 = OpSelect %bool %true %u32vec2_01 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected both objects to be of Result Type: Select")); } TEST_F(ValidateLogicals, OpSelectWrongRightObject) { const std::string body = R"( %val1 = OpSelect %bool %true %u32_1 %u32vec2_01 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected both objects to be of Result Type: Select")); } TEST_F(ValidateLogicals, OpSelectArrayV13Bad) { const std::string body = R"( %val1 = OpSelect %arr_u32_2 %true %nul_arr_u32_2 %arr_u32_2_1_2 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected scalar or vector type as Result Type: Select")); } TEST_F(ValidateLogicals, OpSelectArrayV13TargetV14Bad) { const std::string body = R"( %val1 = OpSelect %arr_u32_2 %true %nul_arr_u32_2 %arr_u32_2_1_2 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected scalar or vector type as Result Type")); } TEST_F(ValidateLogicals, OpSelectArrayV14Good) { const std::string body = R"( %val1 = OpSelect %arr_u32_2 %true %nul_arr_u32_2 %arr_u32_2_1_2 )"; CompileSuccessfully(GenerateShaderCode(body).c_str(), SPV_ENV_UNIVERSAL_1_4); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateLogicals, OpSelectStructV13Bad) { const std::string body = R"( %val1 = OpSelect %st_u32_u32 %true %nul_st_u32_u32 %st_u32_u32_1_2 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected scalar or vector type as Result Type: Select")); } TEST_F(ValidateLogicals, OpSelectStructV13TargetV14Bad) { const std::string body = R"( %val1 = OpSelect %st_u32_u32 %true %nul_st_u32_u32 %st_u32_u32_1_2 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected scalar or vector type as Result Type")); } TEST_F(ValidateLogicals, OpSelectStructV14Good) { const std::string body = R"( %val1 = OpSelect %st_u32_u32 %true %nul_st_u32_u32 %st_u32_u32_1_2 )"; CompileSuccessfully(GenerateShaderCode(body).c_str(), SPV_ENV_UNIVERSAL_1_4); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateLogicals, OpSelectMatrixV13Bad) { const std::string body = R"( %val1 = OpSelect %mat_f32_2_2 %true %nul_mat_f32_2_2 %mat_f32_2_2_01_12 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected scalar or vector type as Result Type: Select")); } TEST_F(ValidateLogicals, OpSelectMatrixV13TargetV14Bad) { const std::string body = R"( %val1 = OpSelect %mat_f32_2_2 %true %nul_mat_f32_2_2 %mat_f32_2_2_01_12 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected scalar or vector type as Result Type")); } TEST_F(ValidateLogicals, OpSelectMatrixV14Good) { const std::string body = R"( %val1 = OpSelect %mat_f32_2_2 %true %nul_mat_f32_2_2 %mat_f32_2_2_01_12 )"; CompileSuccessfully(GenerateShaderCode(body).c_str(), SPV_ENV_UNIVERSAL_1_4); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateLogicals, OpIEqualSuccess) { const std::string body = R"( %val1 = OpIEqual %bool %u32_0 %s32_1 %val2 = OpIEqual %bool %s64_0 %u64_0 %val3 = OpIEqual %boolvec2 %s32vec2_12 %u32vec2_12 %val4 = OpIEqual %boolvec3 %s32vec3_123 %u32vec3_123 %val5 = OpIEqual %boolvec4 %s32vec4_1234 %u32vec4_1234 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateLogicals, OpIEqualWrongTypeId) { const std::string body = R"( %val1 = OpIEqual %u32 %s32_1 %s32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected bool scalar or vector type as Result Type: IEqual")); } TEST_F(ValidateLogicals, OpIEqualLeftOperandNotInt) { const std::string body = R"( %val1 = OpIEqual %bool %f32_1 %s32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected operands to be scalar or vector int: IEqual")); } TEST_F(ValidateLogicals, OpIEqualLeftOperandWrongSize) { const std::string body = R"( %val1 = OpIEqual %bool %s32vec2_12 %s32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected vector sizes of Result Type and the operands to be equal: " "IEqual")); } TEST_F(ValidateLogicals, OpIEqualRightOperandNotInt) { const std::string body = R"( %val1 = OpIEqual %bool %u32_1 %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected operands to be scalar or vector int: IEqual")); } TEST_F(ValidateLogicals, OpIEqualDifferentBitWidth) { const std::string body = R"( %val1 = OpIEqual %bool %u32_1 %u64_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected both operands to have the same component bit " "width: IEqual")); } TEST_F(ValidateLogicals, OpUGreaterThanSuccess) { const std::string body = R"( %val1 = OpUGreaterThan %bool %u32_0 %u32_1 %val2 = OpUGreaterThan %bool %s32_0 %u32_1 %val3 = OpUGreaterThan %bool %u64_0 %u64_0 %val4 = OpUGreaterThan %bool %u64_0 %s64_0 %val5 = OpUGreaterThan %boolvec2 %u32vec2_12 %u32vec2_12 %val6 = OpUGreaterThan %boolvec3 %s32vec3_123 %u32vec3_123 %val7 = OpUGreaterThan %boolvec4 %u32vec4_1234 %u32vec4_1234 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateLogicals, OpUGreaterThanWrongTypeId) { const std::string body = R"( %val1 = OpUGreaterThan %u32 %u32_1 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected bool scalar or vector type as Result Type: UGreaterThan")); } TEST_F(ValidateLogicals, OpUGreaterThanLeftOperandNotInt) { const std::string body = R"( %val1 = OpUGreaterThan %bool %f32_1 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected operands to be scalar or vector int: UGreaterThan")); } TEST_F(ValidateLogicals, OpUGreaterThanLeftOperandWrongSize) { const std::string body = R"( %val1 = OpUGreaterThan %bool %u32vec2_12 %u32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected vector sizes of Result Type and the operands to be equal: " "UGreaterThan")); } TEST_F(ValidateLogicals, OpUGreaterThanRightOperandNotInt) { const std::string body = R"( %val1 = OpUGreaterThan %bool %u32_1 %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected operands to be scalar or vector int: UGreaterThan")); } TEST_F(ValidateLogicals, OpUGreaterThanDifferentBitWidth) { const std::string body = R"( %val1 = OpUGreaterThan %bool %u32_1 %u64_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected both operands to have the same component bit width: " "UGreaterThan")); } TEST_F(ValidateLogicals, OpSGreaterThanSuccess) { const std::string body = R"( %val1 = OpSGreaterThan %bool %s32_0 %s32_1 %val2 = OpSGreaterThan %bool %u32_0 %s32_1 %val3 = OpSGreaterThan %bool %s64_0 %s64_0 %val4 = OpSGreaterThan %bool %s64_0 %u64_0 %val5 = OpSGreaterThan %boolvec2 %s32vec2_12 %s32vec2_12 %val6 = OpSGreaterThan %boolvec3 %s32vec3_123 %u32vec3_123 %val7 = OpSGreaterThan %boolvec4 %s32vec4_1234 %s32vec4_1234 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateLogicals, OpSGreaterThanWrongTypeId) { const std::string body = R"( %val1 = OpSGreaterThan %s32 %s32_1 %s32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected bool scalar or vector type as Result Type: SGreaterThan")); } TEST_F(ValidateLogicals, OpSGreaterThanLeftOperandNotInt) { const std::string body = R"( %val1 = OpSGreaterThan %bool %f32_1 %s32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected operands to be scalar or vector int: SGreaterThan")); } TEST_F(ValidateLogicals, OpSGreaterThanLeftOperandWrongSize) { const std::string body = R"( %val1 = OpSGreaterThan %bool %s32vec2_12 %s32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Expected vector sizes of Result Type and the operands to be equal: " "SGreaterThan")); } TEST_F(ValidateLogicals, OpSGreaterThanRightOperandNotInt) { const std::string body = R"( %val1 = OpSGreaterThan %bool %s32_1 %f32_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Expected operands to be scalar or vector int: SGreaterThan")); } TEST_F(ValidateLogicals, OpSGreaterThanDifferentBitWidth) { const std::string body = R"( %val1 = OpSGreaterThan %bool %s32_1 %s64_1 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected both operands to have the same component bit " "width: SGreaterThan")); } TEST_F(ValidateLogicals, PSBSelectSuccess) { const std::string body = R"( OpCapability PhysicalStorageBufferAddresses OpCapability Int64 OpCapability Shader OpExtension "SPV_EXT_physical_storage_buffer" OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpDecorate %val1 AliasedPointer %uint64 = OpTypeInt 64 0 %bool = OpTypeBool %true = OpConstantTrue %bool %ptr = OpTypePointer PhysicalStorageBuffer %uint64 %pptr_f = OpTypePointer Function %ptr %void = OpTypeVoid %voidfn = OpTypeFunction %void %main = OpFunction %void None %voidfn %entry = OpLabel %val1 = OpVariable %pptr_f Function %val2 = OpLoad %ptr %val1 %val3 = OpSelect %ptr %true %val2 %val2 OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateLogicals, SelectVectorsScalarCondition) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %bool = OpTypeBool %int = OpTypeInt 32 0 %int4 = OpTypeVector %int 4 %int4_0 = OpConstantNull %int4 %true = OpConstantTrue %bool %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %1 = OpLabel %select = OpSelect %int4 %true %int4_0 %int4_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected vector sizes of Result Type and the " "condition to be equal: Select")); } TEST_F(ValidateLogicals, SelectVectorsScalarCondition1p4) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %bool = OpTypeBool %int = OpTypeInt 32 0 %int4 = OpTypeVector %int 4 %int4_0 = OpConstantNull %int4 %true = OpConstantTrue %bool %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %1 = OpLabel %select = OpSelect %int4 %true %int4_0 %int4_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); } TEST_F(ValidateLogicals, SelectVectorsVectorConditionMismatchedDimensions1p4) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %bool = OpTypeBool %bool3 = OpTypeVector %bool 3 %int = OpTypeInt 32 0 %int4 = OpTypeVector %int 4 %int4_0 = OpConstantNull %int4 %bool3_null = OpConstantNull %bool3 %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %1 = OpLabel %select = OpSelect %int4 %bool3_null %int4_0 %int4_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected vector sizes of Result Type and the " "condition to be equal: Select")); } TEST_F(ValidateLogicals, SelectNVBindlessSamplers) { const std::string spirv = R"( OpCapability Shader OpCapability BindlessTextureNV OpExtension "SPV_NV_bindless_texture" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpSamplerImageAddressingModeNV 64 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpSourceExtension "GL_NV_bindless_texture" OpName %main "main" OpName %s2D "s2D" OpName %pickhandle "pickhandle" OpName %Sampler1 "Sampler1" OpName %Sampler2 "Sampler2" OpDecorate %pickhandle Flat OpDecorate %Sampler1 DescriptorSet 0 OpDecorate %Sampler1 Binding 0 OpDecorate %Sampler1 BindlessSamplerNV OpDecorate %Sampler2 DescriptorSet 0 OpDecorate %Sampler2 Binding 1 OpDecorate %Sampler2 BindlessSamplerNV %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %7 = OpTypeImage %float 2D 0 0 0 1 Unknown %8 = OpTypeSampledImage %7 %_ptr_Function_8 = OpTypePointer Function %8 %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %int_0 = OpConstant %int 0 %bool = OpTypeBool %_ptr_UniformConstant_8 = OpTypePointer UniformConstant %8 %Sampler1 = OpVariable %_ptr_UniformConstant_8 UniformConstant %Sampler2 = OpVariable %_ptr_UniformConstant_8 UniformConstant %main = OpFunction %void None %3 %5 = OpLabel %s2D = OpVariable %_ptr_Function_8 Function %pickhandle = OpVariable %_ptr_Function_int Function %14 = OpLoad %int %pickhandle %17 = OpIEqual %bool %14 %int_0 %20 = OpLoad %8 %Sampler1 %22 = OpLoad %8 %Sampler2 %23 = OpSelect %8 %17 %20 %22 OpStore %s2D %23 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_memory_test.cpp000066400000000000000000010333651475742701700242220ustar00rootroot00000000000000// Copyright (c) 2018 Google Inc. // Modifications Copyright (C) 2024 Advanced Micro Devices, Inc. All rights // reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validation tests for memory/storage #include #include #include "gmock/gmock.h" #include "test/unit_spirv.h" #include "test/val/val_code_generator.h" #include "test/val/val_fixtures.h" // For pretty-printing tuples with spv_target_env. std::ostream& operator<<(std::ostream& stream, spv_target_env target) { switch (target) { case SPV_ENV_UNIVERSAL_1_3: return stream << "SPV_ENV_UNIVERSAL_1_3"; case SPV_ENV_UNIVERSAL_1_4: return stream << "SPV_ENV_UNIVERSAL_1_4"; default: return stream << (unsigned)target; } } namespace spvtools { namespace val { namespace { using ::testing::Combine; using ::testing::Eq; using ::testing::HasSubstr; using ::testing::Values; using ValidateMemory = spvtest::ValidateBase; TEST_F(ValidateMemory, VulkanUniformConstantOnNonOpaqueResourceBad) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %float = OpTypeFloat 32 %float_ptr = OpTypePointer UniformConstant %float %2 = OpVariable %float_ptr UniformConstant %void = OpTypeVoid %functy = OpTypeFunction %void %func = OpFunction %void None %functy %1 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-UniformConstant-04655")); EXPECT_THAT( getDiagnosticString(), HasSubstr("Variables identified with the UniformConstant storage class " "are used only as handles to refer to opaque resources. Such " "variables must be typed as OpTypeImage, OpTypeSampler, " "OpTypeSampledImage, OpTypeAccelerationStructureKHR, " "or an array of one of these types.")); } TEST_F(ValidateMemory, VulkanUniformConstantOnOpaqueResourceGood) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft OpDecorate %2 DescriptorSet 0 OpDecorate %2 Binding 0 %sampler = OpTypeSampler %sampler_ptr = OpTypePointer UniformConstant %sampler %2 = OpVariable %sampler_ptr UniformConstant %void = OpTypeVoid %functy = OpTypeFunction %void %func = OpFunction %void None %functy %1 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_1)); } TEST_F(ValidateMemory, VulkanUniformConstantOnNonOpaqueResourceArrayBad) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %float = OpTypeFloat 32 %uint = OpTypeInt 32 0 %array_size = OpConstant %uint 5 %array = OpTypeArray %float %array_size %array_ptr = OpTypePointer UniformConstant %array %2 = OpVariable %array_ptr UniformConstant %void = OpTypeVoid %functy = OpTypeFunction %void %func = OpFunction %void None %functy %1 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-UniformConstant-04655")); EXPECT_THAT( getDiagnosticString(), HasSubstr("Variables identified with the UniformConstant storage class " "are used only as handles to refer to opaque resources. Such " "variables must be typed as OpTypeImage, OpTypeSampler, " "OpTypeSampledImage, OpTypeAccelerationStructureKHR, " "or an array of one of these types.")); } TEST_F(ValidateMemory, VulkanUniformConstantOnOpaqueResourceArrayGood) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft OpDecorate %2 DescriptorSet 0 OpDecorate %2 Binding 0 %sampler = OpTypeSampler %uint = OpTypeInt 32 0 %array_size = OpConstant %uint 5 %array = OpTypeArray %sampler %array_size %array_ptr = OpTypePointer UniformConstant %array %2 = OpVariable %array_ptr UniformConstant %void = OpTypeVoid %functy = OpTypeFunction %void %func = OpFunction %void None %functy %1 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_1)); } TEST_F(ValidateMemory, VulkanUniformConstantOnOpaqueResourceRuntimeArrayGood) { std::string spirv = R"( OpCapability RuntimeDescriptorArrayEXT OpCapability Shader OpExtension "SPV_EXT_descriptor_indexing" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft OpDecorate %2 DescriptorSet 0 OpDecorate %2 Binding 0 %sampler = OpTypeSampler %uint = OpTypeInt 32 0 %array = OpTypeRuntimeArray %sampler %array_ptr = OpTypePointer UniformConstant %array %2 = OpVariable %array_ptr UniformConstant %void = OpTypeVoid %functy = OpTypeFunction %void %func = OpFunction %void None %functy %1 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_1)); } TEST_F(ValidateMemory, VulkanUniformOnIntBad) { char src[] = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %kernel "main" OpExecutionMode %kernel LocalSize 1 1 1 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 %voidty = OpTypeVoid %kernelty = OpTypeFunction %voidty %intty = OpTypeInt 32 0 %varty = OpTypePointer Uniform %intty %value = OpConstant %intty 42 %var = OpVariable %varty Uniform %kernel = OpFunction %voidty None %kernelty %label = OpLabel OpStore %var %value OpReturn OpFunctionEnd )"; CompileSuccessfully(src, SPV_ENV_VULKAN_1_1); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Uniform-06807")); EXPECT_THAT( getDiagnosticString(), HasSubstr("From Vulkan spec:\n" "Variables identified with the Uniform storage class are used " "to access transparent buffer backed resources. Such variables " "must be typed as OpTypeStruct, or an array of this type")); } // #version 440 // #extension GL_EXT_nonuniform_qualifier : enable // layout(binding = 1) uniform sampler2D s2d[][2]; // layout(location = 0) in nonuniformEXT int i; // void main() // { // vec4 v = texture(s2d[i][i], vec2(0.3)); // } TEST_F(ValidateMemory, VulkanUniformOnRuntimeArrayOfArrayBad) { char src[] = R"( OpCapability Shader OpCapability ShaderNonUniformEXT OpCapability RuntimeDescriptorArrayEXT OpCapability SampledImageArrayNonUniformIndexingEXT OpExtension "SPV_EXT_descriptor_indexing" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %i OpSource GLSL 440 OpSourceExtension "GL_EXT_nonuniform_qualifier" OpName %main "main" OpName %v "v" OpName %s2d "s2d" OpName %i "i" OpDecorate %s2d DescriptorSet 0 OpDecorate %s2d Binding 1 OpDecorate %i Location 0 OpDecorate %i NonUniformEXT OpDecorate %21 NonUniformEXT OpDecorate %22 NonUniformEXT OpDecorate %25 NonUniformEXT %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Function_v4float = OpTypePointer Function %v4float %10 = OpTypeImage %float 2D 0 0 0 1 Unknown %11 = OpTypeSampledImage %10 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_arr_11_uint_2 = OpTypeArray %11 %uint_2 %_runtimearr__arr_11_uint_2 = OpTypeRuntimeArray %_arr_11_uint_2 %_ptr_Uniform__runtimearr__arr_11_uint_2 = OpTypePointer Uniform %_runtimearr__arr_11_uint_2 %s2d = OpVariable %_ptr_Uniform__runtimearr__arr_11_uint_2 Uniform %int = OpTypeInt 32 1 %_ptr_Input_int = OpTypePointer Input %int %i = OpVariable %_ptr_Input_int Input %_ptr_Uniform_11 = OpTypePointer Uniform %11 %v2float = OpTypeVector %float 2 %float_0_300000012 = OpConstant %float 0.300000012 %28 = OpConstantComposite %v2float %float_0_300000012 %float_0_300000012 %float_0 = OpConstant %float 0 %main = OpFunction %void None %3 %5 = OpLabel %v = OpVariable %_ptr_Function_v4float Function %21 = OpLoad %int %i %22 = OpLoad %int %i %24 = OpAccessChain %_ptr_Uniform_11 %s2d %21 %22 %25 = OpLoad %11 %24 %30 = OpImageSampleExplicitLod %v4float %25 %28 Lod %float_0 OpStore %v %30 OpReturn OpFunctionEnd )"; CompileSuccessfully(src, SPV_ENV_VULKAN_1_1); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Uniform-06807")); EXPECT_THAT( getDiagnosticString(), HasSubstr("From Vulkan spec:\n" "Variables identified with the Uniform storage class are used " "to access transparent buffer backed resources. Such variables " "must be typed as OpTypeStruct, or an array of this type")); } // #version 440 // layout (set=1, binding=1) uniform sampler2D variableName[2][2]; // void main() { // } TEST_F(ValidateMemory, VulkanUniformOnArrayOfArrayBad) { char src[] = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpSource GLSL 440 OpName %main "main" OpName %variableName "variableName" OpDecorate %variableName DescriptorSet 1 OpDecorate %variableName Binding 1 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %7 = OpTypeImage %float 2D 0 0 0 1 Unknown %8 = OpTypeSampledImage %7 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %_arr_8_uint_2 = OpTypeArray %8 %uint_2 %_arr__arr_8_uint_2_uint_2 = OpTypeArray %_arr_8_uint_2 %uint_2 %_ptr_Uniform__arr__arr_8_uint_2_uint_2 = OpTypePointer Uniform %_arr__arr_8_uint_2_uint_2 %variableName = OpVariable %_ptr_Uniform__arr__arr_8_uint_2_uint_2 Uniform %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(src, SPV_ENV_VULKAN_1_1); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Uniform-06807")); EXPECT_THAT( getDiagnosticString(), HasSubstr("From Vulkan spec:\n" "Variables identified with the Uniform storage class are used " "to access transparent buffer backed resources. Such variables " "must be typed as OpTypeStruct, or an array of this type")); } TEST_F(ValidateMemory, MismatchingStorageClassesBad) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %float = OpTypeFloat 32 %float_ptr = OpTypePointer Uniform %float %void = OpTypeVoid %functy = OpTypeFunction %void %func = OpFunction %void None %functy %1 = OpLabel %2 = OpVariable %float_ptr Function OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Storage class must match result type storage class")); } TEST_F(ValidateMemory, MatchingStorageClassesGood) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %float = OpTypeFloat 32 %float_ptr = OpTypePointer Function %float %void = OpTypeVoid %functy = OpTypeFunction %void %func = OpFunction %void None %functy %1 = OpLabel %2 = OpVariable %float_ptr Function OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateMemory, VulkanInitializerWithOutputStorageClassesGood) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %float = OpTypeFloat 32 %float_ptr = OpTypePointer Output %float %init_val = OpConstant %float 1.0 %1 = OpVariable %float_ptr Output %init_val %void = OpTypeVoid %functy = OpTypeFunction %void %func = OpFunction %void None %functy %2 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_1)); } TEST_F(ValidateMemory, VulkanInitializerWithFunctionStorageClassesGood) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %float = OpTypeFloat 32 %float_ptr = OpTypePointer Function %float %init_val = OpConstant %float 1.0 %void = OpTypeVoid %functy = OpTypeFunction %void %func = OpFunction %void None %functy %1 = OpLabel %2 = OpVariable %float_ptr Function %init_val OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_1)); } TEST_F(ValidateMemory, VulkanInitializerWithPrivateStorageClassesGood) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %float = OpTypeFloat 32 %float_ptr = OpTypePointer Private %float %init_val = OpConstant %float 1.0 %1 = OpVariable %float_ptr Private %init_val %void = OpTypeVoid %functy = OpTypeFunction %void %func = OpFunction %void None %functy %2 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_1)); } TEST_F(ValidateMemory, VulkanInitializerWithDisallowedStorageClassesBad) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %float = OpTypeFloat 32 %float_ptr = OpTypePointer Input %float %init_val = OpConstant %float 1.0 %1 = OpVariable %float_ptr Input %init_val %void = OpTypeVoid %functy = OpTypeFunction %void %func = OpFunction %void None %functy %2 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpVariable-04651")); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpVariable, '5[%5]', has a disallowed initializer & " "storage class combination.\nFrom Vulkan spec:\nVariable " "declarations that include initializers must have one of the " "following storage classes: Output, Private, Function or " "Workgroup\n %5 " "= OpVariable %_ptr_Input_float Input %float_1\n")); } TEST_F(ValidateMemory, UniversalInitializerWithDisallowedStorageClassesBad) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %float = OpTypeFloat 32 %float_ptr = OpTypePointer Input %float %init_val = OpConstant %float 1.0 %1 = OpVariable %float_ptr Input %init_val %void = OpTypeVoid %functy = OpTypeFunction %void %func = OpFunction %void None %functy %2 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str(), SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpVariable, '5[%5]', initializer are not allowed for Input")); } TEST_F(ValidateMemory, InitializerWithTaskPayloadWorkgroupEXT) { std::string spirv = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint TaskEXT %main "main" %payload %void = OpTypeVoid %func = OpTypeFunction %void %uint = OpTypeInt 32 0 %_ptr_TaskPayloadWorkgroupEXT = OpTypePointer TaskPayloadWorkgroupEXT %uint %uint_1 = OpConstant %uint 1 %payload = OpVariable %_ptr_TaskPayloadWorkgroupEXT TaskPayloadWorkgroupEXT %uint_1 %main = OpFunction %void None %func %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str(), SPV_ENV_UNIVERSAL_1_5); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpVariable, '2[%2]', initializer are not allowed " "for TaskPayloadWorkgroupEXT")); } TEST_F(ValidateMemory, ArrayLenCorrectResultType) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %uint = OpTypeInt 32 0 %_runtimearr_float = OpTypeRuntimeArray %float %_struct_7 = OpTypeStruct %_runtimearr_float %_ptr_Function__struct_7 = OpTypePointer Function %_struct_7 %1 = OpFunction %void None %3 %9 = OpLabel %10 = OpVariable %_ptr_Function__struct_7 Function %11 = OpArrayLength %uint %10 0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateMemory, ArrayLenIndexCorrectWith2Members) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %uint = OpTypeInt 32 0 %_runtimearr_float = OpTypeRuntimeArray %float %_struct_7 = OpTypeStruct %float %_runtimearr_float %_ptr_Function__struct_7 = OpTypePointer Function %_struct_7 %1 = OpFunction %void None %3 %9 = OpLabel %10 = OpVariable %_ptr_Function__struct_7 Function %11 = OpArrayLength %uint %10 1 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateMemory, ArrayLenResultNotIntType) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %_runtimearr_float = OpTypeRuntimeArray %float %_struct_6 = OpTypeStruct %_runtimearr_float %_ptr_Function__struct_6 = OpTypePointer Function %_struct_6 %1 = OpFunction %void None %3 %8 = OpLabel %9 = OpVariable %_ptr_Function__struct_6 Function %10 = OpArrayLength %float %9 0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "The Result Type of OpArrayLength '10[%10]' must be OpTypeInt " "with width 32 and signedness 0.\n %10 = OpArrayLength %float %9 " "0\n")); } TEST_F(ValidateMemory, ArrayLenResultNot32bits) { std::string spirv = R"( OpCapability Shader OpCapability Int16 OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %ushort = OpTypeInt 16 0 %_runtimearr_float = OpTypeRuntimeArray %float %_struct_7 = OpTypeStruct %_runtimearr_float %_ptr_Function__struct_7 = OpTypePointer Function %_struct_7 %1 = OpFunction %void None %3 %9 = OpLabel %10 = OpVariable %_ptr_Function__struct_7 Function %11 = OpArrayLength %ushort %10 0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "The Result Type of OpArrayLength '11[%11]' must be OpTypeInt " "with width 32 and signedness 0.\n %11 = OpArrayLength %ushort %10 " "0\n")); } TEST_F(ValidateMemory, ArrayLenResultSigned) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %int = OpTypeInt 32 1 %_runtimearr_float = OpTypeRuntimeArray %float %_struct_7 = OpTypeStruct %_runtimearr_float %_ptr_Function__struct_7 = OpTypePointer Function %_struct_7 %1 = OpFunction %void None %3 %9 = OpLabel %10 = OpVariable %_ptr_Function__struct_7 Function %11 = OpArrayLength %int %10 0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "The Result Type of OpArrayLength '11[%11]' must be OpTypeInt " "with width 32 and signedness 0.\n %11 = OpArrayLength %int %10 " "0\n")); } TEST_F(ValidateMemory, ArrayLenInputNotStruct) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %uint = OpTypeInt 32 0 %_runtimearr_float = OpTypeRuntimeArray %float %_struct_7 = OpTypeStruct %_runtimearr_float %_ptr_Function_float = OpTypePointer Function %float %1 = OpFunction %void None %3 %9 = OpLabel %10 = OpVariable %_ptr_Function_float Function %11 = OpArrayLength %uint %10 0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("The Structure's type in OpArrayLength '11[%11]' " "must be a pointer to an OpTypeStruct.")); } TEST_F(ValidateMemory, ArrayLenInputLastMemberNoRTA) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %uint = OpTypeInt 32 0 %_runtimearr_float = OpTypeRuntimeArray %float %_struct_7 = OpTypeStruct %float %_ptr_Function__struct_7 = OpTypePointer Function %_struct_7 %1 = OpFunction %void None %3 %9 = OpLabel %10 = OpVariable %_ptr_Function__struct_7 Function %11 = OpArrayLength %uint %10 0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("The Structure's last member in OpArrayLength '11[%11]' " "must be an OpTypeRuntimeArray.\n %11 = OpArrayLength %uint " "%10 0\n")); } TEST_F(ValidateMemory, ArrayLenInputLastMemberNoRTA2) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %uint = OpTypeInt 32 0 %_runtimearr_float = OpTypeRuntimeArray %float %_struct_7 = OpTypeStruct %_runtimearr_float %float %_ptr_Function__struct_7 = OpTypePointer Function %_struct_7 %1 = OpFunction %void None %3 %9 = OpLabel %10 = OpVariable %_ptr_Function__struct_7 Function %11 = OpArrayLength %uint %10 1 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("The Structure's last member in OpArrayLength '11[%11]' " "must be an OpTypeRuntimeArray.\n %11 = OpArrayLength %uint " "%10 1\n")); } TEST_F(ValidateMemory, ArrayLenIndexNotLastMember) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %uint = OpTypeInt 32 0 %_runtimearr_float = OpTypeRuntimeArray %float %_struct_7 = OpTypeStruct %float %_runtimearr_float %_ptr_Function__struct_7 = OpTypePointer Function %_struct_7 %1 = OpFunction %void None %3 %9 = OpLabel %10 = OpVariable %_ptr_Function__struct_7 Function %11 = OpArrayLength %uint %10 0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "The array member in OpArrayLength '11[%11]' must be the " "last member of the struct.\n %11 = OpArrayLength %uint %10 0\n")); } TEST_F(ValidateMemory, ArrayLenIndexNotPointerToStruct) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %uint = OpTypeInt 32 0 %_runtimearr_float = OpTypeRuntimeArray %float %_struct_7 = OpTypeStruct %float %_ptr_Function__struct_7 = OpTypePointer Function %_struct_7 %1 = OpFunction %void None %3 %9 = OpLabel %10 = OpVariable %_ptr_Function__struct_7 Function %11 = OpLoad %_struct_7 %10 %12 = OpArrayLength %uint %11 0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "The Structure's type in OpArrayLength '12[%12]' must be a " "pointer to an OpTypeStruct.\n %12 = OpArrayLength %uint %11 0\n")); } TEST_F(ValidateMemory, ArrayLenPointerIsAType) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %uint = OpTypeInt 32 0 %1 = OpFunction %void None %3 %9 = OpLabel %12 = OpArrayLength %uint %float 0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Operand '4[%float]' cannot be a " "type")); } TEST_F(ValidateMemory, PushConstantNotStructGood) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %ptr = OpTypePointer PushConstant %float %pc = OpVariable %ptr PushConstant %1 = OpFunction %void None %voidfn %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateMemory, VulkanPushConstantNotStructBad) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %ptr = OpTypePointer PushConstant %float %pc = OpVariable %ptr PushConstant %1 = OpFunction %void None %voidfn %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-PushConstant-06808")); EXPECT_THAT( getDiagnosticString(), HasSubstr("PushConstant OpVariable '6[%6]' has illegal " "type.\nFrom Vulkan spec, Push Constant Interface section:\n" "Such variables must be typed as OpTypeStruct")); } TEST_F(ValidateMemory, VulkanPushConstantArrayOfStructBad) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %int = OpTypeInt 32 0 %int_1 = OpConstant %int 1 %struct = OpTypeStruct %float %array = OpTypeArray %struct %int_1 %ptr = OpTypePointer PushConstant %array %pc = OpVariable %ptr PushConstant %1 = OpFunction %void None %voidfn %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-PushConstant-06808")); EXPECT_THAT( getDiagnosticString(), HasSubstr("PushConstant OpVariable '10[%10]' has illegal " "type.\nFrom Vulkan spec, Push Constant Interface section:\n" "Such variables must be typed as OpTypeStruct")); } TEST_F(ValidateMemory, VulkanPushConstant) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %struct = OpTypeStruct %float %ptr = OpTypePointer PushConstant %struct %pc = OpVariable %ptr PushConstant %1 = OpFunction %void None %voidfn %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_1)); } TEST_F(ValidateMemory, VulkanMemoryModelDeviceScopeLoadBad1) { const std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability Linkage OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %void = OpTypeVoid %int = OpTypeInt 32 0 %device = OpConstant %int 1 %int_ptr_ssbo = OpTypePointer StorageBuffer %int %var = OpVariable %int_ptr_ssbo StorageBuffer %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel %load = OpLoad %int %var MakePointerVisibleKHR|NonPrivatePointerKHR %device OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Use of device scope with VulkanKHR memory model requires the " "VulkanMemoryModelDeviceScopeKHR capability")); } TEST_F(ValidateMemory, VulkanMemoryModelDeviceScopeLoadBad2) { const std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability Linkage OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %void = OpTypeVoid %int = OpTypeInt 32 0 %device = OpConstant %int 1 %int_ptr_ssbo = OpTypePointer StorageBuffer %int %var = OpVariable %int_ptr_ssbo StorageBuffer %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel %load = OpLoad %int %var Aligned|MakePointerVisibleKHR|NonPrivatePointerKHR 4 %device OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Use of device scope with VulkanKHR memory model requires the " "VulkanMemoryModelDeviceScopeKHR capability")); } TEST_F(ValidateMemory, VulkanMemoryModelDeviceScopeLoadGood1) { const std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability VulkanMemoryModelDeviceScopeKHR OpCapability Linkage OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %void = OpTypeVoid %int = OpTypeInt 32 0 %device = OpConstant %int 1 %int_ptr_ssbo = OpTypePointer StorageBuffer %int %var = OpVariable %int_ptr_ssbo StorageBuffer %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel %load = OpLoad %int %var MakePointerVisibleKHR|NonPrivatePointerKHR %device OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateMemory, VulkanMemoryModelDeviceScopeLoadGood2) { const std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability VulkanMemoryModelDeviceScopeKHR OpCapability Linkage OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %void = OpTypeVoid %int = OpTypeInt 32 0 %device = OpConstant %int 1 %int_ptr_ssbo = OpTypePointer StorageBuffer %int %var = OpVariable %int_ptr_ssbo StorageBuffer %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel %load = OpLoad %int %var Aligned|MakePointerVisibleKHR|NonPrivatePointerKHR 4 %device OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateMemory, VulkanMemoryModelDeviceScopeStoreBad1) { const std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability Linkage OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %void = OpTypeVoid %int = OpTypeInt 32 0 %device = OpConstant %int 1 %int_ptr_ssbo = OpTypePointer StorageBuffer %int %var = OpVariable %int_ptr_ssbo StorageBuffer %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel OpStore %var %device MakePointerAvailableKHR|NonPrivatePointerKHR %device OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Use of device scope with VulkanKHR memory model requires the " "VulkanMemoryModelDeviceScopeKHR capability")); } TEST_F(ValidateMemory, VulkanMemoryModelDeviceScopeStoreBad2) { const std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability Linkage OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %void = OpTypeVoid %int = OpTypeInt 32 0 %device = OpConstant %int 1 %int_ptr_ssbo = OpTypePointer StorageBuffer %int %var = OpVariable %int_ptr_ssbo StorageBuffer %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel OpStore %var %device Aligned|MakePointerAvailableKHR|NonPrivatePointerKHR 4 %device OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Use of device scope with VulkanKHR memory model requires the " "VulkanMemoryModelDeviceScopeKHR capability")); } TEST_F(ValidateMemory, VulkanMemoryModelDeviceScopeStoreGood1) { const std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability VulkanMemoryModelDeviceScopeKHR OpCapability Linkage OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %void = OpTypeVoid %int = OpTypeInt 32 0 %device = OpConstant %int 1 %int_ptr_ssbo = OpTypePointer StorageBuffer %int %var = OpVariable %int_ptr_ssbo StorageBuffer %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel OpStore %var %device MakePointerAvailableKHR|NonPrivatePointerKHR %device OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateMemory, VulkanMemoryModelDeviceScopeStoreGood2) { const std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability VulkanMemoryModelDeviceScopeKHR OpCapability Linkage OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %void = OpTypeVoid %int = OpTypeInt 32 0 %device = OpConstant %int 1 %int_ptr_ssbo = OpTypePointer StorageBuffer %int %var = OpVariable %int_ptr_ssbo StorageBuffer %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel OpStore %var %device Aligned|MakePointerAvailableKHR|NonPrivatePointerKHR 4 %device OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateMemory, VulkanMemoryModelDeviceScopeCopyMemoryBad1) { const std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability Linkage OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %void = OpTypeVoid %int = OpTypeInt 32 0 %device = OpConstant %int 1 %int_ptr_ssbo = OpTypePointer StorageBuffer %int %var1 = OpVariable %int_ptr_ssbo StorageBuffer %var2 = OpVariable %int_ptr_ssbo StorageBuffer %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel OpCopyMemory %var1 %var2 MakePointerAvailableKHR|NonPrivatePointerKHR %device OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Use of device scope with VulkanKHR memory model requires the " "VulkanMemoryModelDeviceScopeKHR capability")); } TEST_F(ValidateMemory, VulkanMemoryModelDeviceScopeCopyMemoryBad2) { const std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability Linkage OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %void = OpTypeVoid %int = OpTypeInt 32 0 %device = OpConstant %int 1 %workgroup = OpConstant %int 1 %int_ptr_ssbo = OpTypePointer StorageBuffer %int %var1 = OpVariable %int_ptr_ssbo StorageBuffer %var2 = OpVariable %int_ptr_ssbo StorageBuffer %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel OpCopyMemory %var1 %var2 Aligned|MakePointerVisibleKHR|MakePointerAvailableKHR|NonPrivatePointerKHR 4 %device %workgroup OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Use of device scope with VulkanKHR memory model requires the " "VulkanMemoryModelDeviceScopeKHR capability")); } TEST_F(ValidateMemory, VulkanMemoryModelDeviceScopeCopyMemoryBad3) { const std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability Linkage OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %void = OpTypeVoid %int = OpTypeInt 32 0 %device = OpConstant %int 1 %workgroup = OpConstant %int 1 %int_ptr_ssbo = OpTypePointer StorageBuffer %int %var1 = OpVariable %int_ptr_ssbo StorageBuffer %var2 = OpVariable %int_ptr_ssbo StorageBuffer %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel OpCopyMemory %var1 %var2 Aligned|MakePointerVisibleKHR|MakePointerAvailableKHR|NonPrivatePointerKHR 4 %workgroup %device OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Use of device scope with VulkanKHR memory model requires the " "VulkanMemoryModelDeviceScopeKHR capability")); } TEST_F(ValidateMemory, VulkanMemoryModelDeviceScopeCopyMemoryGood2) { const std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability VulkanMemoryModelDeviceScopeKHR OpCapability Linkage OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %void = OpTypeVoid %int = OpTypeInt 32 0 %device = OpConstant %int 1 %workgroup = OpConstant %int 2 %int_ptr_ssbo = OpTypePointer StorageBuffer %int %var1 = OpVariable %int_ptr_ssbo StorageBuffer %var2 = OpVariable %int_ptr_ssbo StorageBuffer %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel OpCopyMemory %var1 %var2 Aligned|MakePointerVisibleKHR|MakePointerAvailableKHR|NonPrivatePointerKHR 4 %device %workgroup OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateMemory, VulkanMemoryModelDeviceScopeCopyMemoryGood3) { const std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability VulkanMemoryModelDeviceScopeKHR OpCapability Linkage OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %void = OpTypeVoid %int = OpTypeInt 32 0 %device = OpConstant %int 1 %workgroup = OpConstant %int 2 %int_ptr_ssbo = OpTypePointer StorageBuffer %int %var1 = OpVariable %int_ptr_ssbo StorageBuffer %var2 = OpVariable %int_ptr_ssbo StorageBuffer %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel OpCopyMemory %var1 %var2 Aligned|MakePointerVisibleKHR|MakePointerAvailableKHR|NonPrivatePointerKHR 4 %workgroup %device OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateMemory, VulkanMemoryModelCopyMemoryTwoAccessAvVisBadBinaryV13) { const std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability VulkanMemoryModelDeviceScopeKHR OpCapability Linkage OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %void = OpTypeVoid %int = OpTypeInt 32 0 %device = OpConstant %int 1 %int_ptr_ssbo = OpTypePointer StorageBuffer %int %var1 = OpVariable %int_ptr_ssbo StorageBuffer %var2 = OpVariable %int_ptr_ssbo StorageBuffer %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel OpCopyMemory %var1 %var2 MakePointerAvailableKHR|NonPrivatePointerKHR %device MakePointerVisibleKHR|NonPrivatePointerKHR %device OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "with two memory access operands requires SPIR-V 1.4 or later")); } TEST_F(ValidateMemory, VulkanMemoryModelCopyMemoryTwoAccessAvVisGood) { const std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability VulkanMemoryModelDeviceScopeKHR OpCapability Linkage OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %void = OpTypeVoid %int = OpTypeInt 32 0 %device = OpConstant %int 1 %int_ptr_ssbo = OpTypePointer StorageBuffer %int %var1 = OpVariable %int_ptr_ssbo StorageBuffer %var2 = OpVariable %int_ptr_ssbo StorageBuffer %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel OpCopyMemory %var1 %var2 MakePointerAvailableKHR|NonPrivatePointerKHR %device MakePointerVisibleKHR|NonPrivatePointerKHR %device OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateMemory, VulkanMemoryModelCopyMemoryTwoAccessFirstWithAvBad) { const std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability VulkanMemoryModelDeviceScopeKHR OpCapability Linkage OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %void = OpTypeVoid %int = OpTypeInt 32 0 %device = OpConstant %int 1 %int_ptr_ssbo = OpTypePointer StorageBuffer %int %var1 = OpVariable %int_ptr_ssbo StorageBuffer %var2 = OpVariable %int_ptr_ssbo StorageBuffer %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel OpCopyMemory %var1 %var2 MakePointerAvailableKHR|NonPrivatePointerKHR %device MakePointerAvailableKHR|NonPrivatePointerKHR %device OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Source memory access must not include MakePointerAvailableKHR\n" " OpCopyMemory %5 %6 MakePointerAvailable|NonPrivatePointer" " %uint_1 MakePointerAvailable|NonPrivatePointer %uint_1")); } TEST_F(ValidateMemory, VulkanMemoryModelCopyMemoryTwoAccessSecondWithVisBad) { const std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability VulkanMemoryModelDeviceScopeKHR OpCapability Linkage OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %void = OpTypeVoid %int = OpTypeInt 32 0 %device = OpConstant %int 1 %int_ptr_ssbo = OpTypePointer StorageBuffer %int %var1 = OpVariable %int_ptr_ssbo StorageBuffer %var2 = OpVariable %int_ptr_ssbo StorageBuffer %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel OpCopyMemory %var1 %var2 MakePointerVisibleKHR|NonPrivatePointerKHR %device MakePointerVisibleKHR|NonPrivatePointerKHR %device OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Target memory access must not include MakePointerVisibleKHR\n" " OpCopyMemory %5 %6 MakePointerVisible|NonPrivatePointer" " %uint_1 MakePointerVisible|NonPrivatePointer %uint_1")); } TEST_F(ValidateMemory, VulkanMemoryModelDeviceScopeCopyMemorySizedBad1) { const std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability Linkage OpCapability Addresses OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %void = OpTypeVoid %int = OpTypeInt 32 0 %int_4 = OpConstant %int 4 %device = OpConstant %int 1 %int_ptr_ssbo = OpTypePointer StorageBuffer %int %var1 = OpVariable %int_ptr_ssbo StorageBuffer %var2 = OpVariable %int_ptr_ssbo StorageBuffer %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel OpCopyMemorySized %var1 %var2 %int_4 MakePointerAvailableKHR|NonPrivatePointerKHR %device OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Use of device scope with VulkanKHR memory model requires the " "VulkanMemoryModelDeviceScopeKHR capability")); } TEST_F(ValidateMemory, VulkanMemoryModelDeviceScopeCopyMemorySizedBad2) { const std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability Linkage OpCapability Addresses OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %void = OpTypeVoid %int = OpTypeInt 32 0 %int_4 = OpConstant %int 4 %device = OpConstant %int 1 %workgroup = OpConstant %int 1 %int_ptr_ssbo = OpTypePointer StorageBuffer %int %var1 = OpVariable %int_ptr_ssbo StorageBuffer %var2 = OpVariable %int_ptr_ssbo StorageBuffer %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel OpCopyMemorySized %var1 %var2 %int_4 Aligned|MakePointerVisibleKHR|MakePointerAvailableKHR|NonPrivatePointerKHR 4 %device %workgroup OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Use of device scope with VulkanKHR memory model requires the " "VulkanMemoryModelDeviceScopeKHR capability")); } TEST_F(ValidateMemory, VulkanMemoryModelDeviceScopeCopyMemorySizedBad3) { const std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability Linkage OpCapability Addresses OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %void = OpTypeVoid %int = OpTypeInt 32 0 %int_4 = OpConstant %int 4 %device = OpConstant %int 1 %workgroup = OpConstant %int 1 %int_ptr_ssbo = OpTypePointer StorageBuffer %int %var1 = OpVariable %int_ptr_ssbo StorageBuffer %var2 = OpVariable %int_ptr_ssbo StorageBuffer %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel OpCopyMemorySized %var1 %var2 %int_4 Aligned|MakePointerVisibleKHR|MakePointerAvailableKHR|NonPrivatePointerKHR 4 %workgroup %device OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Use of device scope with VulkanKHR memory model requires the " "VulkanMemoryModelDeviceScopeKHR capability")); } TEST_F(ValidateMemory, VulkanMemoryModelDeviceScopeCopyMemorySizedGood1) { const std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability VulkanMemoryModelDeviceScopeKHR OpCapability Linkage OpCapability Addresses OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %void = OpTypeVoid %int = OpTypeInt 32 0 %int_4 = OpConstant %int 4 %device = OpConstant %int 1 %int_ptr_ssbo = OpTypePointer StorageBuffer %int %var1 = OpVariable %int_ptr_ssbo StorageBuffer %var2 = OpVariable %int_ptr_ssbo StorageBuffer %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel OpCopyMemorySized %var1 %var2 %int_4 MakePointerAvailableKHR|NonPrivatePointerKHR %device OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateMemory, VulkanMemoryModelDeviceScopeCopyMemorySizedGood2) { const std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability VulkanMemoryModelDeviceScopeKHR OpCapability Linkage OpCapability Addresses OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %void = OpTypeVoid %int = OpTypeInt 32 0 %int_4 = OpConstant %int 4 %device = OpConstant %int 1 %workgroup = OpConstant %int 2 %int_ptr_ssbo = OpTypePointer StorageBuffer %int %var1 = OpVariable %int_ptr_ssbo StorageBuffer %var2 = OpVariable %int_ptr_ssbo StorageBuffer %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel OpCopyMemorySized %var1 %var2 %int_4 Aligned|MakePointerVisibleKHR|MakePointerAvailableKHR|NonPrivatePointerKHR 4 %device %workgroup OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateMemory, VulkanMemoryModelDeviceScopeCopyMemorySizedGood3) { const std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpCapability VulkanMemoryModelDeviceScopeKHR OpCapability Linkage OpCapability Addresses OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR %void = OpTypeVoid %int = OpTypeInt 32 0 %int_4 = OpConstant %int 4 %device = OpConstant %int 1 %workgroup = OpConstant %int 2 %int_ptr_ssbo = OpTypePointer StorageBuffer %int %var1 = OpVariable %int_ptr_ssbo StorageBuffer %var2 = OpVariable %int_ptr_ssbo StorageBuffer %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel OpCopyMemorySized %var1 %var2 %int_4 Aligned|MakePointerVisibleKHR|MakePointerAvailableKHR|NonPrivatePointerKHR 4 %workgroup %device OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateMemory, ArrayLengthStructIsLabel) { const std::string spirv = R"( OpCapability Tessellation OpMemoryModel Logical GLSL450 OpName %20 "incorrect" %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %uint = OpTypeInt 32 0 %4 = OpFunction %void None %3 %20 = OpLabel %24 = OpArrayLength %uint %20 0 %25 = OpLoad %v4float %24 OpReturnValue %25 OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Operand '1[%incorrect]' requires a type")); } TEST_F(ValidateMemory, PSBLoadAlignedSuccess) { const std::string body = R"( OpCapability PhysicalStorageBufferAddresses OpCapability Int64 OpCapability Shader OpExtension "SPV_EXT_physical_storage_buffer" OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpDecorate %val1 AliasedPointer %uint64 = OpTypeInt 64 0 %ptr = OpTypePointer PhysicalStorageBuffer %uint64 %pptr_f = OpTypePointer Function %ptr %void = OpTypeVoid %voidfn = OpTypeFunction %void %main = OpFunction %void None %voidfn %entry = OpLabel %val1 = OpVariable %pptr_f Function %val2 = OpLoad %ptr %val1 %val3 = OpLoad %uint64 %val2 Aligned 8 OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str(), SPV_ENV_VULKAN_1_2); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateMemory, PSBLoadAlignedMissing) { const std::string body = R"( OpCapability PhysicalStorageBufferAddresses OpCapability Int64 OpCapability Shader OpExtension "SPV_EXT_physical_storage_buffer" OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpDecorate %val1 AliasedPointer %uint64 = OpTypeInt 64 0 %ptr = OpTypePointer PhysicalStorageBuffer %uint64 %pptr_f = OpTypePointer Function %ptr %void = OpTypeVoid %voidfn = OpTypeFunction %void %main = OpFunction %void None %voidfn %entry = OpLabel %val1 = OpVariable %pptr_f Function %val2 = OpLoad %ptr %val1 %val3 = OpLoad %uint64 %val2 OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str(), SPV_ENV_VULKAN_1_2); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-PhysicalStorageBuffer64-04708")); EXPECT_THAT( getDiagnosticString(), HasSubstr("Memory accesses with PhysicalStorageBuffer must use Aligned")); } TEST_F(ValidateMemory, PSBLoadAlignedMissingWithOtherOperand) { const std::string body = R"( OpCapability PhysicalStorageBufferAddresses OpCapability Int64 OpCapability Shader OpExtension "SPV_EXT_physical_storage_buffer" OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpDecorate %val1 AliasedPointer %uint64 = OpTypeInt 64 0 %ptr = OpTypePointer PhysicalStorageBuffer %uint64 %pptr_f = OpTypePointer Function %ptr %void = OpTypeVoid %voidfn = OpTypeFunction %void %main = OpFunction %void None %voidfn %entry = OpLabel %val1 = OpVariable %pptr_f Function %val2 = OpLoad %ptr %val1 %val3 = OpLoad %uint64 %val2 Volatile OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str(), SPV_ENV_VULKAN_1_2); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-PhysicalStorageBuffer64-04708")); EXPECT_THAT( getDiagnosticString(), HasSubstr("Memory accesses with PhysicalStorageBuffer must use Aligned")); } TEST_F(ValidateMemory, PSBStoreAlignedSuccess) { const std::string body = R"( OpCapability PhysicalStorageBufferAddresses OpCapability Int64 OpCapability Shader OpExtension "SPV_EXT_physical_storage_buffer" OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpDecorate %val1 AliasedPointer %uint64 = OpTypeInt 64 0 %u64_1 = OpConstant %uint64 1 %ptr = OpTypePointer PhysicalStorageBuffer %uint64 %pptr_f = OpTypePointer Function %ptr %void = OpTypeVoid %voidfn = OpTypeFunction %void %main = OpFunction %void None %voidfn %entry = OpLabel %val1 = OpVariable %pptr_f Function %val2 = OpLoad %ptr %val1 OpStore %val2 %u64_1 Aligned 8 OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str(), SPV_ENV_VULKAN_1_2); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateMemory, PSBStoreAlignedMissing) { const std::string body = R"( OpCapability PhysicalStorageBufferAddresses OpCapability Int64 OpCapability Shader OpExtension "SPV_EXT_physical_storage_buffer" OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpDecorate %val1 AliasedPointer %uint64 = OpTypeInt 64 0 %u64_1 = OpConstant %uint64 1 %ptr = OpTypePointer PhysicalStorageBuffer %uint64 %pptr_f = OpTypePointer Function %ptr %void = OpTypeVoid %voidfn = OpTypeFunction %void %main = OpFunction %void None %voidfn %entry = OpLabel %val1 = OpVariable %pptr_f Function %val2 = OpLoad %ptr %val1 OpStore %val2 %u64_1 None OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str(), SPV_ENV_VULKAN_1_2); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-PhysicalStorageBuffer64-04708")); EXPECT_THAT( getDiagnosticString(), HasSubstr("Memory accesses with PhysicalStorageBuffer must use Aligned")); } TEST_F(ValidateMemory, PSBCopyMemoryAlignedSuccess) { const std::string body = R"( OpCapability PhysicalStorageBufferAddresses OpCapability Int64 OpCapability Shader OpExtension "SPV_EXT_physical_storage_buffer" OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpDecorate %val1 AliasedPointer %int = OpTypeInt 32 0 %uint64 = OpTypeInt 64 0 %u64_1 = OpConstant %uint64 1 %ptr = OpTypePointer PhysicalStorageBuffer %uint64 %pptr_f = OpTypePointer Function %ptr %void = OpTypeVoid %voidfn = OpTypeFunction %void %main = OpFunction %void None %voidfn %entry = OpLabel %val1 = OpVariable %pptr_f Function %val2 = OpLoad %ptr %val1 %val3 = OpLoad %ptr %val1 OpCopyMemory %val2 %val3 Aligned 4 OpCopyMemory %val3 %val2 Aligned 4 Aligned 4 OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateMemory, PSBCopyMemoryAlignedMissingTarget) { const std::string body = R"( OpCapability PhysicalStorageBufferAddresses OpCapability Int64 OpCapability Shader OpExtension "SPV_EXT_physical_storage_buffer" OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpDecorate %val1 AliasedPointer %int = OpTypeInt 32 0 %uint64 = OpTypeInt 64 0 %u64_1 = OpConstant %uint64 1 %ptr = OpTypePointer PhysicalStorageBuffer %uint64 %pptr_f = OpTypePointer Function %ptr %void = OpTypeVoid %voidfn = OpTypeFunction %void %main = OpFunction %void None %voidfn %entry = OpLabel %val1 = OpVariable %pptr_f Function %val2 = OpLoad %ptr %val1 %val3 = OpLoad %ptr %val1 OpCopyMemory %val2 %val3 Volatile Aligned 4 OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str(), SPV_ENV_VULKAN_1_2); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-PhysicalStorageBuffer64-04708")); EXPECT_THAT( getDiagnosticString(), HasSubstr("Memory accesses with PhysicalStorageBuffer must use Aligned")); } TEST_F(ValidateMemory, PSBCopyMemoryAlignedMissingSource) { const std::string body = R"( OpCapability PhysicalStorageBufferAddresses OpCapability Int64 OpCapability Shader OpExtension "SPV_EXT_physical_storage_buffer" OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpDecorate %val1 AliasedPointer %int = OpTypeInt 32 0 %uint64 = OpTypeInt 64 0 %u64_1 = OpConstant %uint64 1 %ptr = OpTypePointer PhysicalStorageBuffer %uint64 %pptr_f = OpTypePointer Function %ptr %void = OpTypeVoid %voidfn = OpTypeFunction %void %main = OpFunction %void None %voidfn %entry = OpLabel %val1 = OpVariable %pptr_f Function %val2 = OpLoad %ptr %val1 %val3 = OpLoad %ptr %val1 OpCopyMemory %val2 %val3 Aligned 4 Volatile OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str(), SPV_ENV_VULKAN_1_2); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-PhysicalStorageBuffer64-04708")); EXPECT_THAT( getDiagnosticString(), HasSubstr("Memory accesses with PhysicalStorageBuffer must use Aligned")); } TEST_F(ValidateMemory, PSBCopyMemoryAlignedMissingBoth) { const std::string body = R"( OpCapability PhysicalStorageBufferAddresses OpCapability Int64 OpCapability Shader OpExtension "SPV_EXT_physical_storage_buffer" OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpDecorate %val1 AliasedPointer %int = OpTypeInt 32 0 %uint64 = OpTypeInt 64 0 %u64_1 = OpConstant %uint64 1 %ptr = OpTypePointer PhysicalStorageBuffer %uint64 %pptr_f = OpTypePointer Function %ptr %void = OpTypeVoid %voidfn = OpTypeFunction %void %main = OpFunction %void None %voidfn %entry = OpLabel %val1 = OpVariable %pptr_f Function %val2 = OpLoad %ptr %val1 %val3 = OpLoad %ptr %val1 OpCopyMemory %val2 %val3 Volatile OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str(), SPV_ENV_VULKAN_1_2); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-PhysicalStorageBuffer64-04708")); EXPECT_THAT( getDiagnosticString(), HasSubstr("Memory accesses with PhysicalStorageBuffer must use Aligned")); } TEST_F(ValidateMemory, PSBVariable) { const std::string body = R"( OpCapability PhysicalStorageBufferAddresses OpCapability Int64 OpCapability Shader OpExtension "SPV_EXT_physical_storage_buffer" OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpDecorate %val1 AliasedPointer %uint64 = OpTypeInt 64 0 %ptr = OpTypePointer PhysicalStorageBuffer %uint64 %val1 = OpVariable %ptr PhysicalStorageBuffer %void = OpTypeVoid %voidfn = OpTypeFunction %void %main = OpFunction %void None %voidfn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(body); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("PhysicalStorageBuffer must not be used with OpVariable")); } std::string GenCoopMatLoadStoreShader(const std::string& storeMemoryAccess, const std::string& loadMemoryAccess) { std::string s = R"( OpCapability Shader OpCapability GroupNonUniform OpCapability VulkanMemoryModelKHR OpCapability CooperativeMatrixNV OpExtension "SPV_KHR_vulkan_memory_model" OpExtension "SPV_NV_cooperative_matrix" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical VulkanKHR OpEntryPoint GLCompute %4 "main" %11 %21 OpExecutionMode %4 LocalSize 1 1 1 OpDecorate %11 BuiltIn SubgroupId OpDecorate %21 BuiltIn WorkgroupId OpDecorate %74 ArrayStride 4 OpMemberDecorate %75 0 Offset 0 OpDecorate %75 Block OpDecorate %77 DescriptorSet 0 OpDecorate %77 Binding 0 OpDecorate %92 ArrayStride 4 OpMemberDecorate %93 0 Offset 0 OpDecorate %93 Block OpDecorate %95 DescriptorSet 0 OpDecorate %95 Binding 1 OpDecorate %102 ArrayStride 4 OpMemberDecorate %103 0 Offset 0 OpDecorate %103 Block OpDecorate %105 DescriptorSet 0 OpDecorate %105 Binding 2 OpDecorate %117 ArrayStride 4 OpMemberDecorate %118 0 Offset 0 OpDecorate %118 Block OpDecorate %120 DescriptorSet 0 OpDecorate %120 Binding 3 OpDecorate %123 SpecId 2 OpDecorate %124 SpecId 3 OpDecorate %125 SpecId 4 OpDecorate %126 SpecId 5 OpDecorate %127 SpecId 0 OpDecorate %128 SpecId 1 OpDecorate %129 BuiltIn WorkgroupSize %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpTypeVector %6 2 %8 = OpTypePointer Function %7 %10 = OpTypePointer Input %6 %11 = OpVariable %10 Input %13 = OpConstant %6 2 %19 = OpTypeVector %6 3 %20 = OpTypePointer Input %19 %21 = OpVariable %20 Input %27 = OpConstantComposite %7 %13 %13 %31 = OpTypePointer Function %6 %33 = OpConstant %6 1024 %34 = OpConstant %6 1 %38 = OpConstant %6 8 %39 = OpConstant %6 0 %68 = OpTypeFloat 32 %69 = OpConstant %6 16 %70 = OpConstant %6 3 %71 = OpTypeCooperativeMatrixNV %68 %70 %69 %38 %72 = OpTypePointer Function %71 %74 = OpTypeRuntimeArray %68 %75 = OpTypeStruct %74 %76 = OpTypePointer StorageBuffer %75 %77 = OpVariable %76 StorageBuffer %78 = OpTypeInt 32 1 %79 = OpConstant %78 0 %81 = OpConstant %6 5 %82 = OpTypePointer StorageBuffer %68 %84 = OpConstant %6 64 %85 = OpTypeBool %86 = OpConstantFalse %85 %88 = OpTypePointer Private %71 %89 = OpVariable %88 Private %92 = OpTypeRuntimeArray %68 %93 = OpTypeStruct %92 %94 = OpTypePointer StorageBuffer %93 %95 = OpVariable %94 StorageBuffer %99 = OpVariable %88 Private %102 = OpTypeRuntimeArray %68 %103 = OpTypeStruct %102 %104 = OpTypePointer StorageBuffer %103 %105 = OpVariable %104 StorageBuffer %109 = OpVariable %88 Private %111 = OpVariable %88 Private %112 = OpSpecConstantOp %6 CooperativeMatrixLengthNV %71 %113 = OpSpecConstantOp %78 IAdd %112 %79 %117 = OpTypeRuntimeArray %68 %118 = OpTypeStruct %117 %119 = OpTypePointer StorageBuffer %118 %120 = OpVariable %119 StorageBuffer %123 = OpSpecConstant %78 1 %124 = OpSpecConstant %78 1 %125 = OpSpecConstant %78 1 %126 = OpSpecConstant %78 1 %127 = OpSpecConstant %6 1 %128 = OpSpecConstant %6 1 %129 = OpSpecConstantComposite %19 %127 %128 %34 %4 = OpFunction %2 None %3 %5 = OpLabel %9 = OpVariable %8 Function %18 = OpVariable %8 Function %32 = OpVariable %31 Function %44 = OpVariable %31 Function %52 = OpVariable %31 Function %60 = OpVariable %31 Function %73 = OpVariable %72 Function %91 = OpVariable %72 Function %101 = OpVariable %72 Function %12 = OpLoad %6 %11 %14 = OpUMod %6 %12 %13 %15 = OpLoad %6 %11 %16 = OpUDiv %6 %15 %13 %17 = OpCompositeConstruct %7 %14 %16 OpStore %9 %17 %22 = OpLoad %19 %21 %23 = OpVectorShuffle %7 %22 %22 0 1 %24 = OpCompositeExtract %6 %23 0 %25 = OpCompositeExtract %6 %23 1 %26 = OpCompositeConstruct %7 %24 %25 %28 = OpIMul %7 %26 %27 %29 = OpLoad %7 %9 %30 = OpIAdd %7 %28 %29 OpStore %18 %30 %35 = OpAccessChain %31 %18 %34 %36 = OpLoad %6 %35 %37 = OpIMul %6 %33 %36 %40 = OpAccessChain %31 %18 %39 %41 = OpLoad %6 %40 %42 = OpIMul %6 %38 %41 %43 = OpIAdd %6 %37 %42 OpStore %32 %43 %45 = OpAccessChain %31 %18 %34 %46 = OpLoad %6 %45 %47 = OpIMul %6 %33 %46 %48 = OpAccessChain %31 %18 %39 %49 = OpLoad %6 %48 %50 = OpIMul %6 %38 %49 %51 = OpIAdd %6 %47 %50 OpStore %44 %51 %53 = OpAccessChain %31 %18 %34 %54 = OpLoad %6 %53 %55 = OpIMul %6 %33 %54 %56 = OpAccessChain %31 %18 %39 %57 = OpLoad %6 %56 %58 = OpIMul %6 %38 %57 %59 = OpIAdd %6 %55 %58 OpStore %52 %59 %61 = OpAccessChain %31 %18 %34 %62 = OpLoad %6 %61 %63 = OpIMul %6 %33 %62 %64 = OpAccessChain %31 %18 %39 %65 = OpLoad %6 %64 %66 = OpIMul %6 %38 %65 %67 = OpIAdd %6 %63 %66 OpStore %60 %67 %80 = OpLoad %6 %32 %83 = OpAccessChain %82 %77 %79 %80 %87 = OpCooperativeMatrixLoadNV %71 %83 %84 %86 )" + loadMemoryAccess + R"( %81 OpStore %73 %87 %90 = OpLoad %71 %73 OpStore %89 %90 %96 = OpLoad %6 %44 %97 = OpAccessChain %82 %95 %79 %96 %98 = OpCooperativeMatrixLoadNV %71 %97 %84 %86 MakePointerVisibleKHR|NonPrivatePointerKHR %81 OpStore %91 %98 %100 = OpLoad %71 %91 OpStore %99 %100 %106 = OpLoad %6 %52 %107 = OpAccessChain %82 %105 %79 %106 %108 = OpCooperativeMatrixLoadNV %71 %107 %84 %86 MakePointerVisibleKHR|NonPrivatePointerKHR %81 OpStore %101 %108 %110 = OpLoad %71 %101 OpStore %109 %110 %114 = OpConvertSToF %68 %113 %115 = OpCompositeConstruct %71 %114 OpStore %111 %115 %116 = OpLoad %71 %111 %121 = OpLoad %6 %60 %122 = OpAccessChain %82 %120 %79 %121 OpCooperativeMatrixStoreNV %122 %116 %84 %86 )" + storeMemoryAccess + R"( %81 OpReturn OpFunctionEnd )"; return s; } TEST_F(ValidateMemory, CoopMatLoadStoreSuccess) { std::string spirv = GenCoopMatLoadStoreShader("MakePointerAvailableKHR|NonPrivatePointerKHR", "MakePointerVisibleKHR|NonPrivatePointerKHR"); CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_1)); } TEST_F(ValidateMemory, CoopMatStoreMemoryAccessFail) { std::string spirv = GenCoopMatLoadStoreShader("MakePointerVisibleKHR|NonPrivatePointerKHR", "MakePointerVisibleKHR|NonPrivatePointerKHR"); CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), HasSubstr("MakePointerVisibleKHR cannot be used with OpStore")); } TEST_F(ValidateMemory, CoopMatLoadMemoryAccessFail) { std::string spirv = GenCoopMatLoadStoreShader("MakePointerAvailableKHR|NonPrivatePointerKHR", "MakePointerAvailableKHR|NonPrivatePointerKHR"); CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), HasSubstr("MakePointerAvailableKHR cannot be used with OpLoad")); } TEST_F(ValidateMemory, CoopMatInvalidStorageClassFail) { const std::string body = R"( OpCapability Shader OpCapability Float16 OpCapability CooperativeMatrixNV OpExtension "SPV_NV_cooperative_matrix" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %f16 = OpTypeFloat 16 %u32 = OpTypeInt 32 0 %u32_8 = OpConstant %u32 8 %subgroup = OpConstant %u32 3 %f16mat = OpTypeCooperativeMatrixNV %f16 %subgroup %u32_8 %u32_8 %str = OpTypeStruct %f16mat %str_ptr = OpTypePointer Workgroup %str %sh = OpVariable %str_ptr Workgroup %main = OpFunction %void None %func %main_entry = OpLabel OpReturn OpFunctionEnd)"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Cooperative matrix types (or types containing them) can only be " "allocated in Function or Private storage classes or as function " "parameters")); } TEST_F(ValidateMemory, CoopMatMatrixLengthResultTypeBad) { const std::string body = R"( OpCapability Shader OpCapability Float16 OpCapability CooperativeMatrixNV OpExtension "SPV_NV_cooperative_matrix" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %f16 = OpTypeFloat 16 %u32 = OpTypeInt 32 0 %i32 = OpTypeInt 32 1 %u32_8 = OpConstant %u32 8 %subgroup = OpConstant %u32 3 %f16mat = OpTypeCooperativeMatrixNV %f16 %subgroup %u32_8 %u32_8 %main = OpFunction %void None %func %main_entry = OpLabel %1 = OpCooperativeMatrixLengthNV %i32 %f16mat OpReturn OpFunctionEnd)"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("The Result Type of OpCooperativeMatrixLengthNV " "'11[%11]' must be OpTypeInt with width 32 and signedness 0")); } TEST_F(ValidateMemory, CoopMatMatrixLengthOperandTypeBad) { const std::string body = R"( OpCapability Shader OpCapability Float16 OpCapability CooperativeMatrixNV OpExtension "SPV_NV_cooperative_matrix" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %f16 = OpTypeFloat 16 %u32 = OpTypeInt 32 0 %i32 = OpTypeInt 32 1 %u32_8 = OpConstant %u32 8 %subgroup = OpConstant %u32 3 %f16mat = OpTypeCooperativeMatrixNV %f16 %subgroup %u32_8 %u32_8 %main = OpFunction %void None %func %main_entry = OpLabel %1 = OpCooperativeMatrixLengthNV %u32 %u32 OpReturn OpFunctionEnd)"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("The type in OpCooperativeMatrixLengthNV '5[%uint]' " "must be OpTypeCooperativeMatrixNV")); } TEST_F(ValidateMemory, CoopMatMatrixLengthGood) { const std::string body = R"( OpCapability Shader OpCapability Float16 OpCapability CooperativeMatrixNV OpExtension "SPV_NV_cooperative_matrix" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %f16 = OpTypeFloat 16 %u32 = OpTypeInt 32 0 %i32 = OpTypeInt 32 1 %u32_8 = OpConstant %u32 8 %subgroup = OpConstant %u32 3 %f16mat = OpTypeCooperativeMatrixNV %f16 %subgroup %u32_8 %u32_8 %main = OpFunction %void None %func %main_entry = OpLabel %1 = OpCooperativeMatrixLengthNV %u32 %f16mat OpReturn OpFunctionEnd)"; CompileSuccessfully(body.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } std::string GenCoopMatLoadStoreShaderKHR(const std::string& storeMemoryAccess, const std::string& loadMemoryAccess, unsigned layout = 0, bool useSpecConstantLayout = false, bool useStoreStride = true, bool useLoadStride = true) { std::string s = R"( OpCapability Shader OpCapability GroupNonUniform OpCapability VulkanMemoryModelKHR OpCapability CooperativeMatrixKHR OpExtension "SPV_KHR_vulkan_memory_model" OpExtension "SPV_KHR_cooperative_matrix" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical VulkanKHR OpEntryPoint GLCompute %4 "main" %11 %21 OpExecutionMode %4 LocalSize 1 1 1 OpDecorate %11 BuiltIn SubgroupId OpDecorate %21 BuiltIn WorkgroupId OpDecorate %74 ArrayStride 4 OpMemberDecorate %75 0 Offset 0 OpDecorate %75 Block OpDecorate %77 DescriptorSet 0 OpDecorate %77 Binding 0 OpDecorate %92 ArrayStride 4 OpMemberDecorate %93 0 Offset 0 OpDecorate %93 Block OpDecorate %95 DescriptorSet 0 OpDecorate %95 Binding 1 OpDecorate %102 ArrayStride 4 OpMemberDecorate %103 0 Offset 0 OpDecorate %103 Block OpDecorate %105 DescriptorSet 0 OpDecorate %105 Binding 2 OpDecorate %117 ArrayStride 4 OpMemberDecorate %118 0 Offset 0 OpDecorate %118 Block OpDecorate %120 DescriptorSet 0 OpDecorate %120 Binding 3 OpDecorate %123 SpecId 2 OpDecorate %124 SpecId 3 OpDecorate %125 SpecId 4 OpDecorate %126 SpecId 5 OpDecorate %127 SpecId 0 OpDecorate %128 SpecId 1 OpDecorate %129 BuiltIn WorkgroupSize %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpTypeVector %6 2 %8 = OpTypePointer Function %7 %10 = OpTypePointer Input %6 %11 = OpVariable %10 Input %13 = OpConstant %6 2 %19 = OpTypeVector %6 3 %20 = OpTypePointer Input %19 %21 = OpVariable %20 Input %27 = OpConstantComposite %7 %13 %13 %31 = OpTypePointer Function %6 %33 = OpConstant %6 1024 %34 = OpConstant %6 1 %38 = OpConstant %6 8 %uint_0 = OpConstant %6 0 )"; if (useSpecConstantLayout) { s += "%layout = OpSpecConstant %6 " + std::to_string(layout); } else { s += "%layout = OpConstant %6 " + std::to_string(layout); } s += R"( %68 = OpTypeFloat 32 %69 = OpConstant %6 16 %70 = OpConstant %6 3 %71 = OpTypeCooperativeMatrixKHR %68 %70 %69 %38 %uint_0 %72 = OpTypePointer Function %71 %74 = OpTypeRuntimeArray %68 %75 = OpTypeStruct %74 %76 = OpTypePointer StorageBuffer %75 %77 = OpVariable %76 StorageBuffer %78 = OpTypeInt 32 1 %79 = OpConstant %78 0 %81 = OpConstant %6 5 %82 = OpTypePointer StorageBuffer %68 %stride = OpConstant %6 64 %88 = OpTypePointer Private %71 %89 = OpVariable %88 Private %92 = OpTypeRuntimeArray %68 %93 = OpTypeStruct %92 %94 = OpTypePointer StorageBuffer %93 %95 = OpVariable %94 StorageBuffer %99 = OpVariable %88 Private %102 = OpTypeRuntimeArray %68 %103 = OpTypeStruct %102 %104 = OpTypePointer StorageBuffer %103 %105 = OpVariable %104 StorageBuffer %109 = OpVariable %88 Private %111 = OpVariable %88 Private %112 = OpSpecConstantOp %6 CooperativeMatrixLengthKHR %71 %113 = OpSpecConstantOp %78 IAdd %112 %79 %117 = OpTypeRuntimeArray %68 %118 = OpTypeStruct %117 %119 = OpTypePointer StorageBuffer %118 %120 = OpVariable %119 StorageBuffer %123 = OpSpecConstant %78 1 %124 = OpSpecConstant %78 1 %125 = OpSpecConstant %78 1 %126 = OpSpecConstant %78 1 %127 = OpSpecConstant %6 1 %128 = OpSpecConstant %6 1 %129 = OpSpecConstantComposite %19 %127 %128 %34 %4 = OpFunction %2 None %3 %5 = OpLabel %9 = OpVariable %8 Function %18 = OpVariable %8 Function %32 = OpVariable %31 Function %44 = OpVariable %31 Function %52 = OpVariable %31 Function %60 = OpVariable %31 Function %73 = OpVariable %72 Function %91 = OpVariable %72 Function %101 = OpVariable %72 Function %12 = OpLoad %6 %11 %14 = OpUMod %6 %12 %13 %15 = OpLoad %6 %11 %16 = OpUDiv %6 %15 %13 %17 = OpCompositeConstruct %7 %14 %16 OpStore %9 %17 %22 = OpLoad %19 %21 %23 = OpVectorShuffle %7 %22 %22 0 1 %24 = OpCompositeExtract %6 %23 0 %25 = OpCompositeExtract %6 %23 1 %26 = OpCompositeConstruct %7 %24 %25 %28 = OpIMul %7 %26 %27 %29 = OpLoad %7 %9 %30 = OpIAdd %7 %28 %29 OpStore %18 %30 %35 = OpAccessChain %31 %18 %34 %36 = OpLoad %6 %35 %37 = OpIMul %6 %33 %36 %40 = OpAccessChain %31 %18 %uint_0 %41 = OpLoad %6 %40 %42 = OpIMul %6 %38 %41 %43 = OpIAdd %6 %37 %42 OpStore %32 %43 %45 = OpAccessChain %31 %18 %34 %46 = OpLoad %6 %45 %47 = OpIMul %6 %33 %46 %48 = OpAccessChain %31 %18 %uint_0 %49 = OpLoad %6 %48 %50 = OpIMul %6 %38 %49 %51 = OpIAdd %6 %47 %50 OpStore %44 %51 %53 = OpAccessChain %31 %18 %34 %54 = OpLoad %6 %53 %55 = OpIMul %6 %33 %54 %56 = OpAccessChain %31 %18 %uint_0 %57 = OpLoad %6 %56 %58 = OpIMul %6 %38 %57 %59 = OpIAdd %6 %55 %58 OpStore %52 %59 %61 = OpAccessChain %31 %18 %34 %62 = OpLoad %6 %61 %63 = OpIMul %6 %33 %62 %64 = OpAccessChain %31 %18 %uint_0 %65 = OpLoad %6 %64 %66 = OpIMul %6 %38 %65 %67 = OpIAdd %6 %63 %66 OpStore %60 %67 %80 = OpLoad %6 %32 %83 = OpAccessChain %82 %77 %79 %80 )"; if (useLoadStride) { s += "%87 = OpCooperativeMatrixLoadKHR %71 %83 %layout %stride " + loadMemoryAccess + " %81"; } else { s += "%87 = OpCooperativeMatrixLoadKHR %71 %83 %layout"; } s += R"( OpStore %73 %87 %90 = OpLoad %71 %73 OpStore %89 %90 %96 = OpLoad %6 %44 %97 = OpAccessChain %82 %95 %79 %96 %98 = OpCooperativeMatrixLoadKHR %71 %97 %layout %stride MakePointerVisibleKHR|NonPrivatePointerKHR %81 OpStore %91 %98 %100 = OpLoad %71 %91 OpStore %99 %100 %106 = OpLoad %6 %52 %107 = OpAccessChain %82 %105 %79 %106 %108 = OpCooperativeMatrixLoadKHR %71 %107 %layout %stride MakePointerVisibleKHR|NonPrivatePointerKHR %81 OpStore %101 %108 %110 = OpLoad %71 %101 OpStore %109 %110 %114 = OpConvertSToF %68 %113 %115 = OpCompositeConstruct %71 %114 OpStore %111 %115 %116 = OpLoad %71 %111 %121 = OpLoad %6 %60 %122 = OpAccessChain %82 %120 %79 %121 )"; if (useStoreStride) { s += "OpCooperativeMatrixStoreKHR %122 %116 %layout %stride " + storeMemoryAccess + " %81"; } else { s += "OpCooperativeMatrixStoreKHR %122 %116 %layout"; } s += R"( OpReturn OpFunctionEnd )"; return s; } TEST_F(ValidateMemory, CoopMatKHRLoadStoreSuccess) { std::string spirv = GenCoopMatLoadStoreShaderKHR( "MakePointerAvailableKHR|NonPrivatePointerKHR", "MakePointerVisibleKHR|NonPrivatePointerKHR"); CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_1)); } struct StrideMissingCase { unsigned layout; bool useLoadStride; bool useStoreStride; }; using ValidateCoopMatrixStrideMissing = spvtest::ValidateBase; INSTANTIATE_TEST_SUITE_P( CoopMatrixStrideMissing, ValidateCoopMatrixStrideMissing, Values( StrideMissingCase{(unsigned)spv::CooperativeMatrixLayout::RowMajorKHR, false, true}, StrideMissingCase{(unsigned)spv::CooperativeMatrixLayout::RowMajorKHR, true, false}, StrideMissingCase{ (unsigned)spv::CooperativeMatrixLayout::ColumnMajorKHR, false, true}, StrideMissingCase{ (unsigned)spv::CooperativeMatrixLayout::ColumnMajorKHR, true, false})); TEST_P(ValidateCoopMatrixStrideMissing, CoopMatKHRLoadStrideMissingFail) { const StrideMissingCase& param = GetParam(); std::string spirv = GenCoopMatLoadStoreShaderKHR( "MakePointerAvailableKHR|NonPrivatePointerKHR", "MakePointerVisibleKHR|NonPrivatePointerKHR", param.layout, false /*useSpecConstantLayout*/, param.useStoreStride, param.useLoadStride); CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), HasSubstr("MemoryLayout " + std::to_string(param.layout) + " requires a Stride")); } TEST_F(ValidateMemory, CoopMatKHRMemoryLayoutFromSpecConstantSuccess) { std::string spirv = GenCoopMatLoadStoreShaderKHR( "MakePointerAvailableKHR|NonPrivatePointerKHR", "MakePointerVisibleKHR|NonPrivatePointerKHR", (unsigned)spv::CooperativeMatrixLayout::RowMajorKHR, true /*useSpecConstantLayout*/); CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_1)); } TEST_F(ValidateMemory, CoopMatKHRStoreMemoryAccessFail) { std::string spirv = GenCoopMatLoadStoreShaderKHR( "MakePointerVisibleKHR|NonPrivatePointerKHR", "MakePointerVisibleKHR|NonPrivatePointerKHR"); CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), HasSubstr("MakePointerVisibleKHR cannot be used with OpStore")); } TEST_F(ValidateMemory, CoopMatKHRLoadMemoryAccessFail) { std::string spirv = GenCoopMatLoadStoreShaderKHR( "MakePointerAvailableKHR|NonPrivatePointerKHR", "MakePointerAvailableKHR|NonPrivatePointerKHR"); CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), HasSubstr("MakePointerAvailableKHR cannot be used with OpLoad")); } TEST_F(ValidateMemory, CoopMatKHRInvalidStorageClassFail) { const std::string body = R"( OpCapability Shader OpCapability Float16 OpCapability CooperativeMatrixKHR OpExtension "SPV_KHR_cooperative_matrix" OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %f16 = OpTypeFloat 16 %u32 = OpTypeInt 32 0 %u32_8 = OpConstant %u32 8 %use_A = OpConstant %u32 0 %subgroup = OpConstant %u32 3 %f16mat = OpTypeCooperativeMatrixKHR %f16 %subgroup %u32_8 %u32_8 %use_A %str = OpTypeStruct %f16mat %str_ptr = OpTypePointer Workgroup %str %sh = OpVariable %str_ptr Workgroup %main = OpFunction %void None %func %main_entry = OpLabel OpReturn OpFunctionEnd)"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Cooperative matrix types (or types containing them) can only be " "allocated in Function or Private storage classes or as function " "parameters")); } TEST_F(ValidateMemory, CoopMatMatrixKHRLengthResultTypeBad) { const std::string body = R"( OpCapability Shader OpCapability Float16 OpCapability CooperativeMatrixKHR OpExtension "SPV_KHR_cooperative_matrix" OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %f16 = OpTypeFloat 16 %u32 = OpTypeInt 32 0 %i32 = OpTypeInt 32 1 %u32_8 = OpConstant %u32 8 %use_A = OpConstant %u32 0 %subgroup = OpConstant %u32 3 %f16mat = OpTypeCooperativeMatrixKHR %f16 %subgroup %u32_8 %u32_8 %use_A %main = OpFunction %void None %func %main_entry = OpLabel %1 = OpCooperativeMatrixLengthKHR %i32 %f16mat OpReturn OpFunctionEnd)"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("The Result Type of OpCooperativeMatrixLengthKHR " "'12[%12]' must be OpTypeInt with width 32 and signedness 0")); } TEST_F(ValidateMemory, CoopMatMatrixKHRLengthOperandTypeBad) { const std::string body = R"( OpCapability Shader OpCapability Float16 OpCapability CooperativeMatrixKHR OpExtension "SPV_KHR_cooperative_matrix" OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %f16 = OpTypeFloat 16 %u32 = OpTypeInt 32 0 %i32 = OpTypeInt 32 1 %u32_8 = OpConstant %u32 8 %use_A = OpConstant %u32 0 %subgroup = OpConstant %u32 3 %f16mat = OpTypeCooperativeMatrixKHR %f16 %subgroup %u32_8 %u32_8 %use_A %main = OpFunction %void None %func %main_entry = OpLabel %1 = OpCooperativeMatrixLengthKHR %u32 %u32 OpReturn OpFunctionEnd)"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("The type in OpCooperativeMatrixLengthKHR '5[%uint]' " "must be OpTypeCooperativeMatrixKHR")); } TEST_F(ValidateMemory, CoopMatMatrixKHRLengthGood) { const std::string body = R"( OpCapability Shader OpCapability Float16 OpCapability CooperativeMatrixKHR OpExtension "SPV_KHR_cooperative_matrix" OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %f16 = OpTypeFloat 16 %u32 = OpTypeInt 32 0 %i32 = OpTypeInt 32 1 %u32_8 = OpConstant %u32 8 %use_A = OpConstant %u32 0 %subgroup = OpConstant %u32 3 %f16mat = OpTypeCooperativeMatrixKHR %f16 %subgroup %u32_8 %u32_8 %use_A %main = OpFunction %void None %func %main_entry = OpLabel %1 = OpCooperativeMatrixLengthKHR %u32 %f16mat OpReturn OpFunctionEnd)"; CompileSuccessfully(body.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateMemory, VulkanRTAOutsideOfStructBad) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %sampler_t = OpTypeSampler %array_t = OpTypeRuntimeArray %sampler_t %array_ptr = OpTypePointer UniformConstant %array_t %2 = OpVariable %array_ptr UniformConstant %void = OpTypeVoid %func_t = OpTypeFunction %void %func = OpFunction %void None %func_t %1 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpTypeRuntimeArray-04680")); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpVariable, '5[%5]', is attempting to create memory for an " "illegal type, OpTypeRuntimeArray.\nFor Vulkan OpTypeRuntimeArray " "can only appear as the final member of an OpTypeStruct, thus cannot " "be instantiated via OpVariable\n %5 = OpVariable " "%_ptr_UniformConstant__runtimearr_2 UniformConstant\n")); } TEST_F(ValidateMemory, VulkanRTAOutsideOfStructWithRuntimeDescriptorArrayGood) { std::string spirv = R"( OpCapability Shader OpCapability RuntimeDescriptorArrayEXT OpExtension "SPV_EXT_descriptor_indexing" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %sampler_t = OpTypeSampler %uint = OpTypeInt 32 0 %array_t = OpTypeRuntimeArray %sampler_t %struct = OpTypeStruct %uint %sb_array_t = OpTypeRuntimeArray %struct %array_sb_ptr = OpTypePointer StorageBuffer %sb_array_t %2 = OpVariable %array_sb_ptr StorageBuffer %array_uc_ptr = OpTypePointer UniformConstant %array_t %3 = OpVariable %array_uc_ptr UniformConstant %void = OpTypeVoid %func_t = OpTypeFunction %void %func = OpFunction %void None %func_t %1 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_1)); } TEST_F( ValidateMemory, VulkanRTAOutsideOfStructWithRuntimeDescriptorArrayAndWrongStorageClassBad) { std::string spirv = R"( OpCapability Shader OpCapability RuntimeDescriptorArrayEXT OpExtension "SPV_EXT_descriptor_indexing" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %uint_t = OpTypeInt 32 0 %array_t = OpTypeRuntimeArray %uint_t %array_ptr = OpTypePointer Workgroup %array_t %2 = OpVariable %array_ptr Workgroup %void = OpTypeVoid %func_t = OpTypeFunction %void %func = OpFunction %void None %func_t %1 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpTypeRuntimeArray-04680")); EXPECT_THAT( getDiagnosticString(), HasSubstr("For Vulkan with RuntimeDescriptorArrayEXT, a variable " "containing OpTypeRuntimeArray must have storage class of " "StorageBuffer, Uniform, or UniformConstant.\n %5 = " "OpVariable %_ptr_Workgroup__runtimearr_uint Workgroup\n")); } TEST_F(ValidateMemory, VulkanRTAInsideStorageBufferStructGood) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft OpDecorate %array_t ArrayStride 4 OpMemberDecorate %struct_t 0 Offset 0 OpDecorate %struct_t Block %uint_t = OpTypeInt 32 0 %array_t = OpTypeRuntimeArray %uint_t %struct_t = OpTypeStruct %array_t %struct_ptr = OpTypePointer StorageBuffer %struct_t %2 = OpVariable %struct_ptr StorageBuffer %void = OpTypeVoid %func_t = OpTypeFunction %void %func = OpFunction %void None %func_t %1 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_1)); } TEST_F(ValidateMemory, VulkanRTAInsideWrongStorageClassStructBad) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft OpDecorate %struct_t Block %uint_t = OpTypeInt 32 0 %array_t = OpTypeRuntimeArray %uint_t %struct_t = OpTypeStruct %array_t %struct_ptr = OpTypePointer Workgroup %struct_t %2 = OpVariable %struct_ptr Workgroup %void = OpTypeVoid %func_t = OpTypeFunction %void %func = OpFunction %void None %func_t %1 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpTypeRuntimeArray-04680")); EXPECT_THAT( getDiagnosticString(), HasSubstr( "For Vulkan, OpTypeStruct variables containing OpTypeRuntimeArray " "must have storage class of StorageBuffer, PhysicalStorageBuffer, or " "Uniform.\n %6 = " "OpVariable %_ptr_Workgroup__struct_2 Workgroup\n")); } TEST_F(ValidateMemory, VulkanRTAInsideStorageBufferStructWithoutBlockBad) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft OpDecorate %struct_t BufferBlock %uint_t = OpTypeInt 32 0 %array_t = OpTypeRuntimeArray %uint_t %struct_t = OpTypeStruct %array_t %struct_ptr = OpTypePointer StorageBuffer %struct_t %2 = OpVariable %struct_ptr StorageBuffer %void = OpTypeVoid %func_t = OpTypeFunction %void %func = OpFunction %void None %func_t %1 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpTypeRuntimeArray-04680")); EXPECT_THAT(getDiagnosticString(), HasSubstr("For Vulkan, an OpTypeStruct variable containing an " "OpTypeRuntimeArray must be decorated with Block if it " "has storage class StorageBuffer or " "PhysicalStorageBuffer.\n %6 = OpVariable " "%_ptr_StorageBuffer__struct_2 StorageBuffer\n")); } TEST_F(ValidateMemory, VulkanRTAInsideUniformStructGood) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft OpDecorate %array_t ArrayStride 4 OpMemberDecorate %struct_t 0 Offset 0 OpDecorate %struct_t BufferBlock %uint_t = OpTypeInt 32 0 %array_t = OpTypeRuntimeArray %uint_t %struct_t = OpTypeStruct %array_t %struct_ptr = OpTypePointer Uniform %struct_t %2 = OpVariable %struct_ptr Uniform %void = OpTypeVoid %func_t = OpTypeFunction %void %func = OpFunction %void None %func_t %1 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_1)); } TEST_F(ValidateMemory, VulkanRTAInsideUniformStructWithoutBufferBlockBad) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft OpDecorate %struct_t Block %uint_t = OpTypeInt 32 0 %array_t = OpTypeRuntimeArray %uint_t %struct_t = OpTypeStruct %array_t %struct_ptr = OpTypePointer Uniform %struct_t %2 = OpVariable %struct_ptr Uniform %void = OpTypeVoid %func_t = OpTypeFunction %void %func = OpFunction %void None %func_t %1 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpTypeRuntimeArray-04680")); EXPECT_THAT(getDiagnosticString(), HasSubstr("For Vulkan, an OpTypeStruct variable containing an " "OpTypeRuntimeArray must be decorated with BufferBlock " "if it has storage class Uniform.\n %6 = OpVariable " "%_ptr_Uniform__struct_2 Uniform\n")); } TEST_F(ValidateMemory, VulkanRTAInsideRTABad) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %sampler_t = OpTypeSampler %inner_array_t = OpTypeRuntimeArray %sampler_t %array_t = OpTypeRuntimeArray %inner_array_t %array_ptr = OpTypePointer UniformConstant %array_t %2 = OpVariable %array_ptr UniformConstant %void = OpTypeVoid %func_t = OpTypeFunction %void %func = OpFunction %void None %func_t %1 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpTypeRuntimeArray-04680")); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpTypeRuntimeArray Element Type '3[%_runtimearr_2]' is not " "valid in Vulkan environments.\n %_runtimearr__runtimearr_2 = " "OpTypeRuntimeArray %_runtimearr_2\n")); } TEST_F(ValidateMemory, VulkanRTAInsideRTAWithRuntimeDescriptorArrayBad) { std::string spirv = R"( OpCapability RuntimeDescriptorArrayEXT OpCapability Shader OpExtension "SPV_EXT_descriptor_indexing" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft OpDecorate %struct Block %uint_t = OpTypeInt 32 0 %inner_array_t = OpTypeRuntimeArray %uint_t %array_t = OpTypeRuntimeArray %inner_array_t %struct = OpTypeStruct %array_t %array_ptr = OpTypePointer StorageBuffer %struct %2 = OpVariable %array_ptr StorageBuffer %void = OpTypeVoid %func_t = OpTypeFunction %void %func = OpFunction %void None %func_t %1 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpTypeRuntimeArray-04680")); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpTypeRuntimeArray Element Type '4[%_runtimearr_uint]' is not " "valid in Vulkan environments.\n %_runtimearr__runtimearr_uint = " "OpTypeRuntimeArray %_runtimearr_uint\n")); } TEST_F(ValidateMemory, VulkanUniformStructInsideRTAWithRuntimeDescriptorArrayGood) { std::string spirv = R"( OpCapability RuntimeDescriptorArrayEXT OpCapability Shader OpExtension "SPV_EXT_descriptor_indexing" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft OpMemberDecorate %struct_t 0 Offset 0 OpDecorate %struct_t Block %uint_t = OpTypeInt 32 0 %struct_t = OpTypeStruct %uint_t %array_t = OpTypeRuntimeArray %struct_t %array_ptr = OpTypePointer Uniform %array_t %2 = OpVariable %array_ptr Uniform %void = OpTypeVoid %func_t = OpTypeFunction %void %func = OpFunction %void None %func_t %1 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_1)); } TEST_F(ValidateMemory, VulkanRTAInsideRTAInsideStructBad) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft OpDecorate %array_t ArrayStride 4 OpMemberDecorate %struct_t 0 Offset 0 OpDecorate %struct_t Block %uint_t = OpTypeInt 32 0 %inner_array_t = OpTypeRuntimeArray %uint_t %array_t = OpTypeRuntimeArray %inner_array_t %struct_t = OpTypeStruct %array_t %struct_ptr = OpTypePointer StorageBuffer %struct_t %2 = OpVariable %struct_ptr StorageBuffer %void = OpTypeVoid %func_t = OpTypeFunction %void %func = OpFunction %void None %func_t %1 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpTypeRuntimeArray-04680")); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpTypeRuntimeArray Element Type '5[%_runtimearr_uint]' is not " "valid in Vulkan environments.\n %_runtimearr__runtimearr_uint = " "OpTypeRuntimeArray %_runtimearr_uint\n")); } TEST_F(ValidateMemory, VulkanRTAInsideRTAInsideStructWithRuntimeDescriptorArrayBad) { std::string spirv = R"( OpCapability RuntimeDescriptorArrayEXT OpCapability Shader OpExtension "SPV_EXT_descriptor_indexing" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft OpDecorate %array_t ArrayStride 4 OpMemberDecorate %struct_t 0 Offset 0 OpDecorate %struct_t Block %uint_t = OpTypeInt 32 0 %inner_array_t = OpTypeRuntimeArray %uint_t %array_t = OpTypeRuntimeArray %inner_array_t %struct_t = OpTypeStruct %array_t %struct_ptr = OpTypePointer StorageBuffer %struct_t %2 = OpVariable %struct_ptr StorageBuffer %void = OpTypeVoid %func_t = OpTypeFunction %void %func = OpFunction %void None %func_t %1 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpTypeRuntimeArray-04680")); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpTypeRuntimeArray Element Type '5[%_runtimearr_uint]' is not " "valid in Vulkan environments.\n %_runtimearr__runtimearr_uint = " "OpTypeRuntimeArray %_runtimearr_uint\n")); } TEST_F(ValidateMemory, VulkanRTAInsideArrayBad) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %uint_t = OpTypeInt 32 0 %dim = OpConstant %uint_t 1 %sampler_t = OpTypeSampler %inner_array_t = OpTypeRuntimeArray %sampler_t %array_t = OpTypeArray %inner_array_t %dim %array_ptr = OpTypePointer UniformConstant %array_t %2 = OpVariable %array_ptr UniformConstant %void = OpTypeVoid %func_t = OpTypeFunction %void %func = OpFunction %void None %func_t %1 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpTypeRuntimeArray-04680")); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpTypeArray Element Type '5[%_runtimearr_4]' is not " "valid in Vulkan environments.\n %_arr__runtimearr_4_uint_1 = " "OpTypeArray %_runtimearr_4 %uint_1\n")); } TEST_F(ValidateMemory, VulkanRTAInsideArrayWithRuntimeDescriptorArrayBad) { std::string spirv = R"( OpCapability RuntimeDescriptorArrayEXT OpCapability Shader OpExtension "SPV_EXT_descriptor_indexing" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft OpDecorate %struct Block %uint_t = OpTypeInt 32 0 %dim = OpConstant %uint_t 1 %sampler_t = OpTypeSampler %inner_array_t = OpTypeRuntimeArray %uint_t %array_t = OpTypeRuntimeArray %inner_array_t %struct = OpTypeStruct %array_t %array_ptr = OpTypePointer StorageBuffer %struct %2 = OpVariable %array_ptr StorageBuffer %void = OpTypeVoid %func_t = OpTypeFunction %void %func = OpFunction %void None %func_t %1 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpTypeRuntimeArray-04680")); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpTypeRuntimeArray Element Type '6[%_runtimearr_uint]' is not " "valid in Vulkan environments.\n %_runtimearr__runtimearr_uint = " "OpTypeRuntimeArray %_runtimearr_uint\n")); } TEST_F(ValidateMemory, VulkanRTAInsideArrayInsideStructBad) { std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft OpDecorate %array_t ArrayStride 4 OpMemberDecorate %struct_t 0 Offset 0 OpDecorate %struct_t Block %uint_t = OpTypeInt 32 0 %dim = OpConstant %uint_t 1 %inner_array_t = OpTypeRuntimeArray %uint_t %array_t = OpTypeArray %inner_array_t %dim %struct_t = OpTypeStruct %array_t %struct_ptr = OpTypePointer StorageBuffer %struct_t %2 = OpVariable %struct_ptr StorageBuffer %void = OpTypeVoid %func_t = OpTypeFunction %void %func = OpFunction %void None %func_t %1 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpTypeRuntimeArray-04680")); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpTypeArray Element Type '6[%_runtimearr_uint]' is not " "valid in Vulkan environments.\n %_arr__runtimearr_uint_uint_1 " "= OpTypeArray %_runtimearr_uint %uint_1\n")); } TEST_F(ValidateMemory, VulkanRTAInsideArrayInsideStructWithRuntimeDescriptorArrayBad) { std::string spirv = R"( OpCapability RuntimeDescriptorArrayEXT OpCapability Shader OpExtension "SPV_EXT_descriptor_indexing" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft OpDecorate %array_t ArrayStride 4 OpMemberDecorate %struct_t 0 Offset 0 OpDecorate %struct_t Block %uint_t = OpTypeInt 32 0 %dim = OpConstant %uint_t 1 %inner_array_t = OpTypeRuntimeArray %uint_t %array_t = OpTypeArray %inner_array_t %dim %struct_t = OpTypeStruct %array_t %struct_ptr = OpTypePointer StorageBuffer %struct_t %2 = OpVariable %struct_ptr StorageBuffer %void = OpTypeVoid %func_t = OpTypeFunction %void %func = OpFunction %void None %func_t %1 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpTypeRuntimeArray-04680")); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpTypeArray Element Type '6[%_runtimearr_uint]' is not " "valid in Vulkan environments.\n %_arr__runtimearr_uint_uint_1 " "= OpTypeArray %_runtimearr_uint %uint_1\n")); } TEST_F(ValidateMemory, VulkanRTAStructInsideRTAWithRuntimeDescriptorArrayGood) { std::string spirv = R"( OpCapability RuntimeDescriptorArrayEXT OpCapability Shader OpExtension "SPV_EXT_descriptor_indexing" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft OpDecorate %inner_array_t ArrayStride 4 OpMemberDecorate %struct_t 0 Offset 0 OpDecorate %struct_t Block %uint_t = OpTypeInt 32 0 %inner_array_t = OpTypeRuntimeArray %uint_t %struct_t = OpTypeStruct %inner_array_t %array_t = OpTypeRuntimeArray %struct_t %array_ptr = OpTypePointer StorageBuffer %array_t %2 = OpVariable %array_ptr StorageBuffer %void = OpTypeVoid %func_t = OpTypeFunction %void %func = OpFunction %void None %func_t %1 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_1)); } TEST_F(ValidateMemory, VulkanRTAStructInsideArrayGood) { std::string spirv = R"( OpCapability RuntimeDescriptorArrayEXT OpCapability Shader OpExtension "SPV_EXT_descriptor_indexing" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft OpDecorate %inner_array_t ArrayStride 4 OpMemberDecorate %struct_t 0 Offset 0 OpDecorate %struct_t Block %uint_t = OpTypeInt 32 0 %inner_array_t = OpTypeRuntimeArray %uint_t %struct_t = OpTypeStruct %inner_array_t %array_size = OpConstant %uint_t 5 %array_t = OpTypeArray %struct_t %array_size %array_ptr = OpTypePointer StorageBuffer %array_t %2 = OpVariable %array_ptr StorageBuffer %void = OpTypeVoid %func_t = OpTypeFunction %void %func = OpFunction %void None %func_t %1 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_1)); } TEST_F(ValidateMemory, CopyMemoryNoAccessGood) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_ptr_priv = OpTypePointer Private %int %var1 = OpVariable %int_ptr_priv Private %var2 = OpVariable %int_ptr_priv Private %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel OpCopyMemory %var1 %var2 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateMemory, CopyMemorySimpleMixedAccessGood) { // Test one memory access operand using features that don't require the // Vulkan memory model. const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_ptr_priv = OpTypePointer Private %int %var1 = OpVariable %int_ptr_priv Private %var2 = OpVariable %int_ptr_priv Private %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel OpCopyMemory %var1 %var2 Volatile|Aligned|Nontemporal 4 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateMemory, CopyMemorySimpleTwoMixedAccessV13Bad) { // Two memory access operands is invalid up to SPIR-V 1.3 const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_ptr_priv = OpTypePointer Private %int %var1 = OpVariable %int_ptr_priv Private %var2 = OpVariable %int_ptr_priv Private %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel OpCopyMemory %var1 %var2 Volatile Volatile OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("CopyMemory with two memory access operands requires " "SPIR-V 1.4 or later")); } TEST_F(ValidateMemory, CopyMemorySimpleTwoMixedAccessV14Good) { // Two memory access operands is valid in SPIR-V 1.4 const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_ptr_priv = OpTypePointer Private %int %var1 = OpVariable %int_ptr_priv Private %var2 = OpVariable %int_ptr_priv Private %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel OpCopyMemory %var1 %var2 Volatile Volatile OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateMemory, CopyMemorySizedNoAccessGood) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability Addresses OpMemoryModel Logical GLSL450 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_16 = OpConstant %int 16 %int_ptr_priv = OpTypePointer Private %int %var1 = OpVariable %int_ptr_priv Private %var2 = OpVariable %int_ptr_priv Private %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel OpCopyMemorySized %var1 %var2 %int_16 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateMemory, CopyMemorySizedSimpleMixedAccessGood) { // Test one memory access operand using features that don't require the // Vulkan memory model. const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability Addresses OpMemoryModel Logical GLSL450 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_16 = OpConstant %int 16 %int_ptr_priv = OpTypePointer Private %int %var1 = OpVariable %int_ptr_priv Private %var2 = OpVariable %int_ptr_priv Private %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel OpCopyMemorySized %var1 %var2 %int_16 Volatile|Aligned|Nontemporal 4 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateMemory, CopyMemorySizedSimpleTwoMixedAccessV13Bad) { // Two memory access operands is invalid up to SPIR-V 1.3 const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability Addresses OpMemoryModel Logical GLSL450 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_16 = OpConstant %int 16 %int_ptr_priv = OpTypePointer Private %int %var1 = OpVariable %int_ptr_priv Private %var2 = OpVariable %int_ptr_priv Private %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel OpCopyMemorySized %var1 %var2 %int_16 Volatile Volatile OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("CopyMemorySized with two memory access operands requires " "SPIR-V 1.4 or later")); } TEST_F(ValidateMemory, CopyMemorySizedSimpleTwoMixedAccessV14Good) { // Two memory access operands is valid in SPIR-V 1.4 const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability Addresses OpMemoryModel Logical GLSL450 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_16 = OpConstant %int 16 %int_ptr_priv = OpTypePointer Private %int %var1 = OpVariable %int_ptr_priv Private %var2 = OpVariable %int_ptr_priv Private %voidfn = OpTypeFunction %void %func = OpFunction %void None %voidfn %entry = OpLabel OpCopyMemorySized %var1 %var2 %int_16 Volatile Volatile OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), Eq("")); } using ValidatePointerComparisons = spvtest::ValidateBase; TEST_P(ValidatePointerComparisons, Good) { const std::string operation = GetParam(); std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability VariablePointersStorageBuffer OpMemoryModel Logical GLSL450 %void = OpTypeVoid %bool = OpTypeBool %int = OpTypeInt 32 0 %ptr_int = OpTypePointer StorageBuffer %int %var = OpVariable %ptr_int StorageBuffer %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel %equal = )" + operation; if (operation == "OpPtrDiff") { spirv += " %int "; } else { spirv += " %bool "; } spirv += R"(%var %var OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); } TEST_P(ValidatePointerComparisons, GoodWorkgroup) { const std::string operation = GetParam(); std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability VariablePointers OpMemoryModel Logical GLSL450 %void = OpTypeVoid %bool = OpTypeBool %int = OpTypeInt 32 0 %ptr_int = OpTypePointer Workgroup %int %var = OpVariable %ptr_int Workgroup %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel %equal = )" + operation; if (operation == "OpPtrDiff") { spirv += " %int "; } else { spirv += " %bool "; } spirv += R"(%var %var OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); } TEST_P(ValidatePointerComparisons, BadResultType) { const std::string operation = GetParam(); std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability VariablePointersStorageBuffer OpMemoryModel Logical GLSL450 %void = OpTypeVoid %bool = OpTypeBool %int = OpTypeInt 32 0 %ptr_int = OpTypePointer StorageBuffer %int %var = OpVariable %ptr_int StorageBuffer %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel %equal = )" + operation; if (operation == "OpPtrDiff") { spirv += " %bool "; } else { spirv += " %int "; } spirv += R"(%var %var OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); if (operation == "OpPtrDiff") { EXPECT_THAT(getDiagnosticString(), HasSubstr("Result Type must be an integer scalar")); } else { EXPECT_THAT(getDiagnosticString(), HasSubstr("Result Type must be OpTypeBool")); } } TEST_P(ValidatePointerComparisons, BadCapabilities) { const std::string operation = GetParam(); std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %bool = OpTypeBool %int = OpTypeInt 32 0 %ptr_int = OpTypePointer StorageBuffer %int %var = OpVariable %ptr_int StorageBuffer %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel %equal = )" + operation; if (operation == "OpPtrDiff") { spirv += " %int "; } else { spirv += " %bool "; } spirv += R"(%var %var OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); if (operation == "OpPtrDiff") { // Gets caught by the grammar. EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); } else { EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Instruction cannot for logical addressing model be " "used without a variable pointers capability")); } } TEST_P(ValidatePointerComparisons, BadOperandType) { const std::string operation = GetParam(); std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability VariablePointersStorageBuffer OpMemoryModel Logical GLSL450 %void = OpTypeVoid %bool = OpTypeBool %int = OpTypeInt 32 0 %ptr_int = OpTypePointer StorageBuffer %int %var = OpVariable %ptr_int StorageBuffer %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel %ld = OpLoad %int %var %equal = )" + operation; if (operation == "OpPtrDiff") { spirv += " %int "; } else { spirv += " %bool "; } spirv += R"(%ld %ld OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Operand type must be a pointer")); } TEST_P(ValidatePointerComparisons, BadStorageClassWorkgroup) { const std::string operation = GetParam(); std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability VariablePointersStorageBuffer OpMemoryModel Logical GLSL450 %void = OpTypeVoid %bool = OpTypeBool %int = OpTypeInt 32 0 %ptr_int = OpTypePointer Workgroup %int %var = OpVariable %ptr_int Workgroup %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel %equal = )" + operation; if (operation == "OpPtrDiff") { spirv += " %int "; } else { spirv += " %bool "; } spirv += R"(%var %var OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Workgroup storage class pointer requires " "VariablePointers capability to be specified")); } TEST_P(ValidatePointerComparisons, BadStorageClass) { const std::string operation = GetParam(); std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability VariablePointersStorageBuffer OpMemoryModel Logical GLSL450 %void = OpTypeVoid %bool = OpTypeBool %int = OpTypeInt 32 0 %ptr_int = OpTypePointer Private %int %var = OpVariable %ptr_int Private %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel %equal = )" + operation; if (operation == "OpPtrDiff") { spirv += " %int "; } else { spirv += " %bool "; } spirv += R"(%var %var OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Invalid pointer storage class")); } TEST_P(ValidatePointerComparisons, BadDiffOperandTypes) { const std::string operation = GetParam(); std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability VariablePointersStorageBuffer OpMemoryModel Logical GLSL450 %void = OpTypeVoid %bool = OpTypeBool %int = OpTypeInt 32 0 %float = OpTypeFloat 32 %ptr_int = OpTypePointer Private %int %var = OpVariable %ptr_int Private %ptr_float = OpTypePointer Private %float %var2 = OpVariable %ptr_float Private %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel %ld = OpLoad %int %var %equal = )" + operation; if (operation == "OpPtrDiff") { spirv += " %int "; } else { spirv += " %bool "; } spirv += R"(%var %var2 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("The types of Operand 1 and Operand 2 must match")); } TEST_P(ValidatePointerComparisons, GoodUntypedPointerSameType) { const std::string operation = GetParam(); std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability VariablePointersStorageBuffer OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 %void = OpTypeVoid %bool = OpTypeBool %int = OpTypeInt 32 0 %ptr = OpTypeUntypedPointerKHR StorageBuffer %var = OpUntypedVariableKHR %ptr StorageBuffer %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel %equal = )" + operation; if (operation == "OpPtrDiff") { spirv += " %int "; } else { spirv += " %bool "; } spirv += R"(%var %var OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); } TEST_P(ValidatePointerComparisons, GoodUntypedPointerSameStorageClass) { const std::string operation = GetParam(); std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability VariablePointersStorageBuffer OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 %void = OpTypeVoid %bool = OpTypeBool %int = OpTypeInt 32 0 %ptr1 = OpTypeUntypedPointerKHR StorageBuffer %var = OpUntypedVariableKHR %ptr1 StorageBuffer %ptr2 = OpTypeUntypedPointerKHR StorageBuffer %var2 = OpUntypedVariableKHR %ptr2 StorageBuffer %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel %equal = )" + operation; if (operation == "OpPtrDiff") { spirv += " %int "; } else { spirv += " %bool "; } spirv += R"(%var %var2 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); if (operation == "OpPtrDiff") { EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("The types of Operand 1 and Operand 2 must match")); } else { EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); } } TEST_P(ValidatePointerComparisons, BadUntypedPointerDiffStorageClass) { const std::string operation = GetParam(); std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability VariablePointers OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 %void = OpTypeVoid %bool = OpTypeBool %int = OpTypeInt 32 0 %ptr1 = OpTypeUntypedPointerKHR StorageBuffer %var1 = OpUntypedVariableKHR %ptr1 StorageBuffer %ptr2 = OpTypeUntypedPointerKHR Workgroup %var2 = OpUntypedVariableKHR %ptr2 Workgroup %int %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel %equal = )" + operation; if (operation == "OpPtrDiff") { spirv += " %int "; } else { spirv += " %bool "; } spirv += R"(%var1 %var2 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); if (operation == "OpPtrDiff") { EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("The types of Operand 1 and Operand 2 must match")); } else { EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Pointer storage classes must match")); } } TEST_P(ValidatePointerComparisons, GoodMixedPointerSameStorageClass) { const std::string operation = GetParam(); std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability VariablePointersStorageBuffer OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 %void = OpTypeVoid %bool = OpTypeBool %int = OpTypeInt 32 0 %ptr1 = OpTypeUntypedPointerKHR StorageBuffer %var = OpUntypedVariableKHR %ptr1 StorageBuffer %ptr2 = OpTypePointer StorageBuffer %int %var2 = OpVariable %ptr2 StorageBuffer %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel %equal = )" + operation; if (operation == "OpPtrDiff") { spirv += " %int "; } else { spirv += " %bool "; } spirv += R"(%var %var2 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); if (operation == "OpPtrDiff") { EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("The types of Operand 1 and Operand 2 must match")); } else { EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); } } TEST_P(ValidatePointerComparisons, BadMixedPointerDiffStorageClass) { const std::string operation = GetParam(); std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability VariablePointers OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 %void = OpTypeVoid %bool = OpTypeBool %int = OpTypeInt 32 0 %ptr1 = OpTypeUntypedPointerKHR StorageBuffer %var1 = OpUntypedVariableKHR %ptr1 StorageBuffer %ptr2 = OpTypePointer Workgroup %int %var2 = OpVariable %ptr2 Workgroup %func_ty = OpTypeFunction %void %func = OpFunction %void None %func_ty %1 = OpLabel %equal = )" + operation; if (operation == "OpPtrDiff") { spirv += " %int "; } else { spirv += " %bool "; } spirv += R"(%var1 %var2 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); if (operation == "OpPtrDiff") { EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("The types of Operand 1 and Operand 2 must match")); } else { EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Pointer storage classes must match")); } } INSTANTIATE_TEST_SUITE_P(PointerComparisons, ValidatePointerComparisons, Values("OpPtrEqual", "OpPtrNotEqual", "OpPtrDiff")); TEST_F(ValidateMemory, VariableInitializerWrongType) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability VariablePointersStorageBuffer OpMemoryModel Logical GLSL450 %void = OpTypeVoid %int = OpTypeInt 32 0 %float = OpTypeFloat 32 %ptr_wg_int = OpTypePointer Workgroup %int %ptr_wg_float = OpTypePointer Workgroup %int %wg_var = OpVariable %ptr_wg_int Workgroup %ptr_private_wg_float = OpTypePointer Private %ptr_wg_float %priv_var = OpVariable %ptr_private_wg_float Private %wg_var )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Initializer type must match the data type")); } TEST_F(ValidateMemory, StoreToImage) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %int = OpTypeInt 32 0 %img = OpTypeImage %int 2D 2 0 0 2 R32i %ptr_img = OpTypePointer Function %img %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %var = OpVariable %ptr_img Function %value = OpLoad %img %var OpStore %var %value OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpTypeImage-06924")); EXPECT_THAT( getDiagnosticString(), HasSubstr("Cannot store to OpTypeImage, OpTypeSampler, " "OpTypeSampledImage, or OpTypeAccelerationStructureKHR")); } TEST_F(ValidateMemory, StoreToImageArray) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %int = OpTypeInt 32 0 %img = OpTypeImage %int 2D 2 0 0 2 R32i %arr_size = OpConstant %int 5 %i = OpConstant %int 2 %arr_img = OpTypeArray %img %arr_size %ptr_img = OpTypePointer Function %img %ptr_arr_img = OpTypePointer Function %arr_img %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %var = OpVariable %ptr_arr_img Function %value = OpLoad %arr_img %var OpStore %var %value OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpTypeImage-06924")); EXPECT_THAT( getDiagnosticString(), HasSubstr("Cannot store to OpTypeImage, OpTypeSampler, " "OpTypeSampledImage, or OpTypeAccelerationStructureKHR")); } TEST_F(ValidateMemory, StoreToSampler) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %smp = OpTypeSampler %ptr_smp = OpTypePointer Function %smp %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %var = OpVariable %ptr_smp Function %value = OpLoad %smp %var OpStore %var %value OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpTypeImage-06924")); EXPECT_THAT( getDiagnosticString(), HasSubstr("Cannot store to OpTypeImage, OpTypeSampler, " "OpTypeSampledImage, or OpTypeAccelerationStructureKHR")); } TEST_F(ValidateMemory, StoreToSampledImage) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %int = OpTypeInt 32 0 %img = OpTypeImage %int 2D 2 0 0 1 R32i %samp_img = OpTypeSampledImage %img %ptr_samp_img = OpTypePointer Function %samp_img %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %var = OpVariable %ptr_samp_img Function %value = OpLoad %samp_img %var OpStore %var %value OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpTypeImage-06924")); EXPECT_THAT( getDiagnosticString(), HasSubstr("Cannot store to OpTypeImage, OpTypeSampler, " "OpTypeSampledImage, or OpTypeAccelerationStructureKHR")); } TEST_F(ValidateMemory, StoreToAccelarationStructureKHR) { const std::string spirv = R"( OpCapability Shader OpCapability RayQueryKHR OpExtension "SPV_KHR_ray_query" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %as = OpTypeAccelerationStructureKHR %ptr_as = OpTypePointer Function %as %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %var = OpVariable %ptr_as Function %value = OpLoad %as %var OpStore %var %value OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpTypeImage-06924")); EXPECT_THAT( getDiagnosticString(), HasSubstr("Cannot store to OpTypeImage, OpTypeSampler, " "OpTypeSampledImage, or OpTypeAccelerationStructureKHR")); } TEST_F(ValidateMemory, StoreToUniformBlock) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int4 = OpTypeVector %int 4 %struct = OpTypeStruct %int4 %ptr_uniform_struct = OpTypePointer Uniform %struct %ptr_uniform_int4 = OpTypePointer Uniform %int4 %ptr_uniform_int = OpTypePointer Uniform %int %var = OpVariable %ptr_uniform_struct Uniform %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %gep1 = OpAccessChain %ptr_uniform_int4 %var %int_0 %gep2 = OpAccessChain %ptr_uniform_int %gep1 %int_0 OpStore %gep2 %int_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateMemory, StoreToUniformBlockVulkan) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int4 = OpTypeVector %int 4 %struct = OpTypeStruct %int4 %ptr_uniform_struct = OpTypePointer Uniform %struct %ptr_uniform_int4 = OpTypePointer Uniform %int4 %ptr_uniform_int = OpTypePointer Uniform %int %var = OpVariable %ptr_uniform_struct Uniform %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %gep1 = OpAccessChain %ptr_uniform_int4 %var %int_0 %gep2 = OpAccessChain %ptr_uniform_int %gep1 %int_0 OpStore %gep2 %int_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Uniform-06925")); EXPECT_THAT( getDiagnosticString(), HasSubstr("In the Vulkan environment, cannot store to Uniform Blocks")); } // This test requires that the struct is not id 2. TEST_F(ValidateMemory, StoreToUniformBlockVulkan2) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %gid_var OpExecutionMode %main LocalSize 1 1 1 OpDecorate %3 Block OpMemberDecorate %3 0 Offset 0 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 OpDecorate %gid_var BuiltIn GlobalInvocationId %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int3 = OpTypeVector %int 3 %int4 = OpTypeVector %int 4 %3 = OpTypeStruct %int4 %ptr_uniform_struct = OpTypePointer Uniform %3 %ptr_uniform_int4 = OpTypePointer Uniform %int4 %ptr_uniform_int = OpTypePointer Uniform %int %var = OpVariable %ptr_uniform_struct Uniform %ptr_input_int3 = OpTypePointer Input %int3 %gid_var = OpVariable %ptr_input_int3 Input %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %gep1 = OpAccessChain %ptr_uniform_int4 %var %int_0 %gep2 = OpAccessChain %ptr_uniform_int %gep1 %int_0 OpStore %gep2 %int_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Uniform-06925")); EXPECT_THAT( getDiagnosticString(), HasSubstr("In the Vulkan environment, cannot store to Uniform Blocks")); } TEST_F(ValidateMemory, StoreToUniformBufferBlockVulkan) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %struct BufferBlock OpMemberDecorate %struct 0 Offset 0 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int4 = OpTypeVector %int 4 %struct = OpTypeStruct %int4 %ptr_uniform_struct = OpTypePointer Uniform %struct %ptr_uniform_int4 = OpTypePointer Uniform %int4 %ptr_uniform_int = OpTypePointer Uniform %int %var = OpVariable %ptr_uniform_struct Uniform %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %gep1 = OpAccessChain %ptr_uniform_int4 %var %int_0 %gep2 = OpAccessChain %ptr_uniform_int %gep1 %int_0 OpStore %gep2 %int_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_1)); } TEST_F(ValidateMemory, StoreToUniformBlockVulkanArray) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %int4 = OpTypeVector %int 4 %struct = OpTypeStruct %int4 %array_struct = OpTypeArray %struct %int_1 %ptr_uniform_array = OpTypePointer Uniform %array_struct %ptr_uniform_struct = OpTypePointer Uniform %struct %ptr_uniform_int4 = OpTypePointer Uniform %int4 %ptr_uniform_int = OpTypePointer Uniform %int %var = OpVariable %ptr_uniform_array Uniform %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %gep1 = OpAccessChain %ptr_uniform_int %var %int_0 %int_0 %int_0 %gep2 = OpCopyObject %ptr_uniform_int %gep1 OpStore %gep2 %int_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Uniform-06925")); EXPECT_THAT( getDiagnosticString(), HasSubstr("In the Vulkan environment, cannot store to Uniform Blocks")); } // This test requires that the struct is not id 2. TEST_F(ValidateMemory, StoreToUniformBlockVulkanArray2) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %gid_var OpExecutionMode %main LocalSize 1 1 1 OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 OpDecorate %gid_var BuiltIn GlobalInvocationId %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %int3 = OpTypeVector %int 3 %int4 = OpTypeVector %int 4 %struct = OpTypeStruct %int4 %array_struct = OpTypeArray %struct %int_1 %ptr_uniform_array = OpTypePointer Uniform %array_struct %ptr_uniform_struct = OpTypePointer Uniform %struct %ptr_uniform_int4 = OpTypePointer Uniform %int4 %ptr_uniform_int = OpTypePointer Uniform %int %var = OpVariable %ptr_uniform_array Uniform %ptr_input_int3 = OpTypePointer Input %int3 %gid_var = OpVariable %ptr_input_int3 Input %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %gep1 = OpAccessChain %ptr_uniform_int %var %int_0 %int_0 %int_0 %gep2 = OpCopyObject %ptr_uniform_int %gep1 OpStore %gep2 %int_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Uniform-06925")); EXPECT_THAT( getDiagnosticString(), HasSubstr("In the Vulkan environment, cannot store to Uniform Blocks")); } TEST_F(ValidateMemory, StoreToUniformBlockVulkanRuntimeArray) { const std::string spirv = R"( OpCapability Shader OpCapability RuntimeDescriptorArrayEXT OpExtension "SPV_EXT_descriptor_indexing" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int4 = OpTypeVector %int 4 %struct = OpTypeStruct %int4 %array_struct = OpTypeRuntimeArray %struct %ptr_uniform_array = OpTypePointer Uniform %array_struct %ptr_uniform_struct = OpTypePointer Uniform %struct %ptr_uniform_int4 = OpTypePointer Uniform %int4 %ptr_uniform_int = OpTypePointer Uniform %int %var = OpVariable %ptr_uniform_array Uniform %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %gep1 = OpAccessChain %ptr_uniform_int4 %var %int_0 %int_0 %gep2 = OpInBoundsAccessChain %ptr_uniform_int %gep1 %int_0 OpStore %gep2 %int_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Uniform-06925")); EXPECT_THAT( getDiagnosticString(), HasSubstr("In the Vulkan environment, cannot store to Uniform Blocks")); } using ValidateSizedVariable = spvtest::ValidateBase< std::tuple>; CodeGenerator GetSizedVariableCodeGenerator(bool is_8bit, bool buffer_block) { CodeGenerator generator; generator.capabilities_ = "OpCapability Shader\nOpCapability Linkage\n"; generator.extensions_ = "OpExtension \"SPV_KHR_16bit_storage\"\nOpExtension " "\"SPV_KHR_8bit_storage\"\n"; generator.memory_model_ = "OpMemoryModel Logical GLSL450\n"; if (is_8bit) { generator.before_types_ = "OpMemberDecorate %char_buffer_block 0 Offset 0\n"; if (buffer_block) generator.before_types_ += "OpDecorate %char_buffer_block BufferBlock\n"; generator.types_ = R"(%void = OpTypeVoid %char = OpTypeInt 8 0 %char4 = OpTypeVector %char 4 %char_buffer_block = OpTypeStruct %char )"; } else { generator.before_types_ = "OpMemberDecorate %half_buffer_block 0 Offset 0\n" "OpMemberDecorate %short_buffer_block 0 Offset 0\n"; if (buffer_block) { generator.before_types_ += "OpDecorate %half_buffer_block BufferBlock\n" "OpDecorate %short_buffer_block BufferBlock\n"; } generator.types_ = R"(%void = OpTypeVoid %short = OpTypeInt 16 0 %half = OpTypeFloat 16 %short4 = OpTypeVector %short 4 %half4 = OpTypeVector %half 4 %mat4x4 = OpTypeMatrix %half4 4 %short_buffer_block = OpTypeStruct %short %half_buffer_block = OpTypeStruct %half )"; } generator.after_types_ = R"(%void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel )"; generator.add_at_the_end_ = "OpReturn\nOpFunctionEnd\n"; return generator; } TEST_P(ValidateSizedVariable, Capability) { const std::string storage_class = std::get<0>(GetParam()); const std::string capability = std::get<1>(GetParam()); const std::string var_type = std::get<2>(GetParam()); const spv_target_env target = std::get<3>(GetParam()); ASSERT_TRUE(target == SPV_ENV_UNIVERSAL_1_3 || target == SPV_ENV_UNIVERSAL_1_4); bool type_8bit = false; if (var_type == "%char" || var_type == "%char4" || var_type == "%char_buffer_block") { type_8bit = true; } const bool buffer_block = var_type.find("buffer_block") != std::string::npos; auto generator = GetSizedVariableCodeGenerator(type_8bit, buffer_block); if (capability == "WorkgroupMemoryExplicitLayout8BitAccessKHR" || capability == "WorkgroupMemoryExplicitLayout16BitAccessKHR") { generator.extensions_ += "OpExtension \"SPV_KHR_workgroup_memory_explicit_layout\"\n"; } generator.types_ += "%ptr_type = OpTypePointer " + storage_class + " " + var_type + "\n%var = OpVariable %ptr_type " + storage_class + "\n"; generator.capabilities_ += "OpCapability " + capability + "\n"; bool capability_ok = false; bool storage_class_ok = false; if (storage_class == "Input" || storage_class == "Output") { if (!type_8bit) { capability_ok = capability == "StorageInputOutput16"; storage_class_ok = true; } } else if (storage_class == "StorageBuffer") { if (type_8bit) { capability_ok = capability == "StorageBuffer8BitAccess" || capability == "UniformAndStorageBuffer8BitAccess"; } else { capability_ok = capability == "StorageBuffer16BitAccess" || capability == "UniformAndStorageBuffer16BitAccess"; } storage_class_ok = true; } else if (storage_class == "PushConstant") { if (type_8bit) { capability_ok = capability == "StoragePushConstant8"; } else { capability_ok = capability == "StoragePushConstant16"; } storage_class_ok = true; } else if (storage_class == "Uniform") { if (type_8bit) { capability_ok = capability == "UniformAndStorageBuffer8BitAccess" || (capability == "StorageBuffer8BitAccess" && buffer_block); } else { capability_ok = capability == "UniformAndStorageBuffer16BitAccess" || (capability == "StorageBuffer16BitAccess" && buffer_block); } storage_class_ok = true; } else if (storage_class == "Workgroup") { if (type_8bit) { capability_ok = capability == "WorkgroupMemoryExplicitLayout8BitAccessKHR"; } else { capability_ok = capability == "WorkgroupMemoryExplicitLayout16BitAccessKHR"; } storage_class_ok = true; } CompileSuccessfully(generator.Build(), target); spv_result_t result = ValidateInstructions(target); if (target < SPV_ENV_UNIVERSAL_1_4 && (capability == "WorkgroupMemoryExplicitLayout8BitAccessKHR" || capability == "WorkgroupMemoryExplicitLayout16BitAccessKHR")) { EXPECT_EQ(SPV_ERROR_WRONG_VERSION, result); EXPECT_THAT(getDiagnosticString(), HasSubstr("requires SPIR-V version 1.4 or later")); } else if (buffer_block && target > SPV_ENV_UNIVERSAL_1_3) { EXPECT_EQ(SPV_ERROR_WRONG_VERSION, result); EXPECT_THAT(getDiagnosticString(), HasSubstr("requires SPIR-V version 1.3 or earlier")); } else if (capability_ok) { EXPECT_EQ(SPV_SUCCESS, result); } else { EXPECT_EQ(SPV_ERROR_INVALID_ID, result); if (storage_class_ok) { std::string message = std::string("Allocating a variable containing a ") + (type_8bit ? "8" : "16") + "-bit element in " + storage_class + " storage class requires an additional capability"; EXPECT_THAT(getDiagnosticString(), HasSubstr(message)); } else { std::string message = std::string("Cannot allocate a variable containing a ") + (type_8bit ? "8" : "16") + "-bit type in " + storage_class + " storage class"; EXPECT_THAT(getDiagnosticString(), HasSubstr(message)); } } } INSTANTIATE_TEST_SUITE_P( Storage8, ValidateSizedVariable, Combine(Values("UniformConstant", "Input", "Output", "Workgroup", "CrossWorkgroup", "Private", "StorageBuffer", "Uniform"), Values("StorageBuffer8BitAccess", "UniformAndStorageBuffer8BitAccess", "StoragePushConstant8", "WorkgroupMemoryExplicitLayout8BitAccessKHR"), Values("%char", "%char4", "%char_buffer_block"), Values(SPV_ENV_UNIVERSAL_1_3, SPV_ENV_UNIVERSAL_1_4))); INSTANTIATE_TEST_SUITE_P( Storage16, ValidateSizedVariable, Combine(Values("UniformConstant", "Input", "Output", "Workgroup", "CrossWorkgroup", "Private", "StorageBuffer", "Uniform"), Values("StorageBuffer16BitAccess", "UniformAndStorageBuffer16BitAccess", "StoragePushConstant16", "StorageInputOutput16", "WorkgroupMemoryExplicitLayout16BitAccessKHR"), Values("%short", "%half", "%short4", "%half4", "%mat4x4", "%short_buffer_block", "%half_buffer_block"), Values(SPV_ENV_UNIVERSAL_1_3, SPV_ENV_UNIVERSAL_1_4))); using ValidateSizedLoadStore = spvtest::ValidateBase>; CodeGenerator GetSizedLoadStoreCodeGenerator(const std::string& base_type, uint32_t width) { CodeGenerator generator; generator.capabilities_ = "OpCapability Shader\nOpCapability Linkage\n"; if (width == 8) { generator.capabilities_ += "OpCapability UniformAndStorageBuffer8BitAccess\n"; generator.extensions_ = "OpExtension \"SPV_KHR_8bit_storage\"\n"; } else { generator.capabilities_ += "OpCapability UniformAndStorageBuffer16BitAccess\n"; generator.extensions_ = "OpExtension \"SPV_KHR_16bit_storage\"\n"; } generator.memory_model_ = "OpMemoryModel Logical GLSL450\n"; generator.before_types_ = R"(OpDecorate %block Block OpMemberDecorate %block 0 Offset 0 OpMemberDecorate %struct 0 Offset 0 )"; generator.types_ = R"(%void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %int_3 = OpConstant %int 3 )"; if (width == 8) { generator.types_ += R"(%scalar = OpTypeInt 8 0 %vector = OpTypeVector %scalar 4 %struct = OpTypeStruct %vector )"; } else if (base_type == "int") { generator.types_ += R"(%scalar = OpTypeInt 16 0 %vector = OpTypeVector %scalar 4 %struct = OpTypeStruct %vector )"; } else { generator.types_ += R"(%scalar = OpTypeFloat 16 %vector = OpTypeVector %scalar 4 %matrix = OpTypeMatrix %vector 4 %struct = OpTypeStruct %matrix %ptr_ssbo_matrix = OpTypePointer StorageBuffer %matrix )"; generator.before_types_ += R"(OpMemberDecorate %struct 0 RowMajor OpMemberDecorate %struct 0 MatrixStride 16 )"; } generator.types_ += R"(%block = OpTypeStruct %struct %ptr_ssbo_block = OpTypePointer StorageBuffer %block %ptr_ssbo_struct = OpTypePointer StorageBuffer %struct %ptr_ssbo_vector = OpTypePointer StorageBuffer %vector %ptr_ssbo_scalar = OpTypePointer StorageBuffer %scalar %ld_var = OpVariable %ptr_ssbo_block StorageBuffer %st_var = OpVariable %ptr_ssbo_block StorageBuffer )"; generator.after_types_ = R"(%void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel )"; generator.add_at_the_end_ = "OpReturn\nOpFunctionEnd\n"; return generator; } TEST_P(ValidateSizedLoadStore, Load) { std::string base_type = std::get<0>(GetParam()); uint32_t width = std::get<1>(GetParam()); std::string mem_type = std::get<2>(GetParam()); CodeGenerator generator = GetSizedLoadStoreCodeGenerator(base_type, width); generator.after_types_ += "%ld_gep = OpAccessChain %ptr_ssbo_" + mem_type + " %ld_var %int_0"; if (mem_type != "struct") { generator.after_types_ += " %int_0"; if (mem_type != "matrix" && base_type == "float") { generator.after_types_ += " %int_0"; } if (mem_type == "scalar") { generator.after_types_ += " %int_0"; } } generator.after_types_ += "\n"; generator.after_types_ += "%ld = OpLoad %" + mem_type + " %ld_gep\n"; CompileSuccessfully(generator.Build(), SPV_ENV_UNIVERSAL_1_3); if (mem_type == "struct") { EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "8- or 16-bit loads must be a scalar, vector or matrix type")); } else { EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } } TEST_P(ValidateSizedLoadStore, Store) { std::string base_type = std::get<0>(GetParam()); uint32_t width = std::get<1>(GetParam()); std::string mem_type = std::get<2>(GetParam()); CodeGenerator generator = GetSizedLoadStoreCodeGenerator(base_type, width); generator.after_types_ += "%ld_gep = OpAccessChain %ptr_ssbo_" + mem_type + " %ld_var %int_0"; if (mem_type != "struct") { generator.after_types_ += " %int_0"; if (mem_type != "matrix" && base_type == "float") { generator.after_types_ += " %int_0"; } if (mem_type == "scalar") { generator.after_types_ += " %int_0"; } } generator.after_types_ += "\n"; generator.after_types_ += "%ld = OpLoad %" + mem_type + " %ld_gep\n"; generator.after_types_ += "%st_gep = OpAccessChain %ptr_ssbo_" + mem_type + " %st_var %int_0"; if (mem_type != "struct") { generator.after_types_ += " %int_0"; if (mem_type != "matrix" && base_type == "float") { generator.after_types_ += " %int_0"; } if (mem_type == "scalar") { generator.after_types_ += " %int_0"; } } generator.after_types_ += "\n"; generator.after_types_ += "OpStore %st_gep %ld\n"; CompileSuccessfully(generator.Build(), SPV_ENV_UNIVERSAL_1_3); if (mem_type == "struct") { EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); // Can only catch the load. EXPECT_THAT( getDiagnosticString(), HasSubstr( "8- or 16-bit loads must be a scalar, vector or matrix type")); } else { EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } } INSTANTIATE_TEST_SUITE_P(LoadStoreInt8, ValidateSizedLoadStore, Combine(Values("int"), Values(8u), Values("scalar", "vector", "struct"))); INSTANTIATE_TEST_SUITE_P(LoadStoreInt16, ValidateSizedLoadStore, Combine(Values("int"), Values(16u), Values("scalar", "vector", "struct"))); INSTANTIATE_TEST_SUITE_P(LoadStoreFloat16, ValidateSizedLoadStore, Combine(Values("float"), Values(16u), Values("scalar", "vector", "matrix", "struct"))); TEST_F(ValidateMemory, SmallStorageCopyMemoryChar) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability UniformAndStorageBuffer8BitAccess OpExtension "SPV_KHR_8bit_storage" OpMemoryModel Logical GLSL450 OpDecorate %block Block OpMemberDecorate %block 0 Offset 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %char = OpTypeInt 8 0 %block = OpTypeStruct %char %ptr_ssbo_block = OpTypePointer StorageBuffer %block %in = OpVariable %ptr_ssbo_block StorageBuffer %out = OpVariable %ptr_ssbo_block StorageBuffer %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel OpCopyMemory %out %in OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Cannot copy memory of objects containing 8- or 16-bit types")); } TEST_F(ValidateMemory, SmallStorageCopyMemoryShort) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability UniformAndStorageBuffer16BitAccess OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpDecorate %block Block OpMemberDecorate %block 0 Offset 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %short = OpTypeInt 16 0 %block = OpTypeStruct %short %ptr_ssbo_block = OpTypePointer StorageBuffer %block %in = OpVariable %ptr_ssbo_block StorageBuffer %out = OpVariable %ptr_ssbo_block StorageBuffer %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel OpCopyMemory %out %in OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Cannot copy memory of objects containing 8- or 16-bit types")); } TEST_F(ValidateMemory, SmallStorageCopyMemoryHalf) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability UniformAndStorageBuffer16BitAccess OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpDecorate %block Block OpMemberDecorate %block 0 Offset 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %half = OpTypeFloat 16 %block = OpTypeStruct %half %ptr_ssbo_block = OpTypePointer StorageBuffer %block %in = OpVariable %ptr_ssbo_block StorageBuffer %out = OpVariable %ptr_ssbo_block StorageBuffer %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entry = OpLabel OpCopyMemory %out %in OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Cannot copy memory of objects containing 8- or 16-bit types")); } TEST_F(ValidateMemory, SmallStorageVariableArrayBufferBlockShort) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability StorageBuffer16BitAccess OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpDecorate %block BufferBlock OpMemberDecorate %block 0 Offset 0 %void = OpTypeVoid %short = OpTypeInt 16 0 %int = OpTypeInt 32 0 %int_4 = OpConstant %int 4 %block = OpTypeStruct %short %block_array = OpTypeArray %block %int_4 %ptr_block_array = OpTypePointer Uniform %block_array %var = OpVariable %ptr_block_array Uniform )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateMemory, SmallStorageVariableArrayBufferBlockChar) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability StorageBuffer8BitAccess OpExtension "SPV_KHR_8bit_storage" OpMemoryModel Logical GLSL450 OpDecorate %block BufferBlock OpMemberDecorate %block 0 Offset 0 %void = OpTypeVoid %char = OpTypeInt 8 0 %int = OpTypeInt 32 0 %int_4 = OpConstant %int 4 %block = OpTypeStruct %char %block_array = OpTypeArray %block %int_4 %ptr_block_array = OpTypePointer Uniform %block_array %var = OpVariable %ptr_block_array Uniform )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateMemory, SmallStorageVariableArrayBufferBlockHalf) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability StorageBuffer16BitAccess OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 OpDecorate %block BufferBlock OpMemberDecorate %block 0 Offset 0 %void = OpTypeVoid %half = OpTypeFloat 16 %int = OpTypeInt 32 0 %int_4 = OpConstant %int 4 %block = OpTypeStruct %half %block_array = OpTypeArray %block %int_4 %ptr_block_array = OpTypePointer Uniform %block_array %var = OpVariable %ptr_block_array Uniform )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateMemory, VulkanStorageBufferNotAStruct) { const std::string spirv = R"( OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %uint = OpTypeInt 32 0 %ptr_ssbo = OpTypePointer StorageBuffer %uint %var = OpVariable %ptr_ssbo StorageBuffer %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Uniform-06807")); EXPECT_THAT( getDiagnosticString(), HasSubstr("From Vulkan spec:\nVariables identified with " "the StorageBuffer storage class are used to access " "transparent buffer backed resources. Such variables must be " "typed as OpTypeStruct, or an array of this type")); } TEST_F(ValidateMemory, VulkanStorageBufferRuntimeArrayNotAStruct) { const std::string spirv = R"( OpCapability Shader OpCapability RuntimeDescriptorArrayEXT OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_EXT_descriptor_indexing" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %uint = OpTypeInt 32 0 %array = OpTypeRuntimeArray %uint %ptr_ssbo = OpTypePointer StorageBuffer %array %var = OpVariable %ptr_ssbo StorageBuffer %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Uniform-06807")); EXPECT_THAT( getDiagnosticString(), HasSubstr("From Vulkan spec:\nVariables identified with " "the StorageBuffer storage class are used to access " "transparent buffer backed resources. Such variables must be " "typed as OpTypeStruct, or an array of this type")); } TEST_F(ValidateMemory, VulkanStorageBufferArrayNotAStruct) { const std::string spirv = R"( OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %uint = OpTypeInt 32 0 %uint_4 = OpConstant %uint 4 %array = OpTypeArray %uint %uint_4 %ptr_ssbo = OpTypePointer StorageBuffer %array %var = OpVariable %ptr_ssbo StorageBuffer %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Uniform-06807")); EXPECT_THAT( getDiagnosticString(), HasSubstr("From Vulkan spec:\nVariables identified with " "the StorageBuffer storage class are used to access " "transparent buffer backed resources. Such variables must be " "typed as OpTypeStruct, or an array of this type")); } TEST_F(ValidateMemory, VulkanInvariantOutputSuccess) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %var OpDecorate %var Location 0 OpDecorate %var Invariant %void = OpTypeVoid %f32 = OpTypeFloat 32 %ptr_output = OpTypePointer Output %f32 %var = OpVariable %ptr_output Output %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateMemory, VulkanInvariantInputStructSuccess) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %var OpExecutionMode %main OriginUpperLeft OpDecorate %var Location 0 OpMemberDecorate %struct 1 Invariant %void = OpTypeVoid %f32 = OpTypeFloat 32 %struct = OpTypeStruct %f32 %f32 %ptr_input = OpTypePointer Input %struct %var = OpVariable %ptr_input Input %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateMemory, VulkanInvariantWrongStorageClass) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpDecorate %var Invariant %void = OpTypeVoid %f32 = OpTypeFloat 32 %ptr_private = OpTypePointer Private %f32 %var = OpVariable %ptr_private Private %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Invariant-04677")); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Variable decorated with Invariant must only be identified with the " "Input or Output storage class in Vulkan environment.")); } TEST_F(ValidateMemory, VulkanInvariantMemberWrongStorageClass) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpMemberDecorate %struct 1 Invariant %void = OpTypeVoid %f32 = OpTypeFloat 32 %struct = OpTypeStruct %f32 %f32 %ptr_private = OpTypePointer Private %struct %var = OpVariable %ptr_private Private %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Invariant-04677")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Variable struct member decorated with Invariant must " "only be identified with the Input or Output storage " "class in Vulkan environment.")); } TEST_F(ValidateMemory, PhysicalStorageBufferPtrEqual) { const std::string spirv = R"( OpCapability Shader OpCapability Int64 OpCapability PhysicalStorageBufferAddresses OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %bool = OpTypeBool %long = OpTypeInt 64 0 %long_0 = OpConstant %long 0 %ptr_pssbo_long = OpTypePointer PhysicalStorageBuffer %long %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %conv = OpConvertUToPtr %ptr_pssbo_long %long_0 %eq = OpPtrEqual %bool %conv %conv OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_5); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Cannot use a pointer in the PhysicalStorageBuffer storage class")); } TEST_F(ValidateMemory, PhysicalStorageBufferPtrNotEqual) { const std::string spirv = R"( OpCapability Shader OpCapability Int64 OpCapability PhysicalStorageBufferAddresses OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %bool = OpTypeBool %long = OpTypeInt 64 0 %long_0 = OpConstant %long 0 %ptr_pssbo_long = OpTypePointer PhysicalStorageBuffer %long %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %conv = OpConvertUToPtr %ptr_pssbo_long %long_0 %neq = OpPtrNotEqual %bool %conv %conv OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_5); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Cannot use a pointer in the PhysicalStorageBuffer storage class")); } TEST_F(ValidateMemory, PhysicalStorageBufferPtrDiff) { const std::string spirv = R"( OpCapability Shader OpCapability Int64 OpCapability PhysicalStorageBufferAddresses OpCapability VariablePointers OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %long = OpTypeInt 64 0 %long_0 = OpConstant %long 0 %ptr_pssbo_long = OpTypePointer PhysicalStorageBuffer %long %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %conv = OpConvertUToPtr %ptr_pssbo_long %long_0 %diff = OpPtrDiff %long %conv %conv OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_5); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Cannot use a pointer in the PhysicalStorageBuffer storage class")); } TEST_F(ValidateMemory, VulkanInitializerWithWorkgroupStorageClassBad) { std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %float = OpTypeFloat 32 %float_ptr = OpTypePointer Workgroup %float %init_val = OpConstant %float 1.0 %1 = OpVariable %float_ptr Workgroup %init_val %void = OpTypeVoid %functy = OpTypeFunction %void %func = OpFunction %void None %functy %2 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID(" VUID-StandaloneSpirv-OpVariable-04734")); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpVariable, '5[%5]', initializers are limited to " "OpConstantNull in Workgroup storage class")); } TEST_F(ValidateMemory, VulkanInitializerWithWorkgroupStorageClassGood) { std::string spirv = R"( OpCapability Shader OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %float = OpTypeFloat 32 %float_ptr = OpTypePointer Workgroup %float %init_val = OpConstantNull %float %1 = OpVariable %float_ptr Workgroup %init_val %void = OpTypeVoid %functy = OpTypeFunction %void %func = OpFunction %void None %functy %2 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateMemory, LoadRuntimeArray) { const std::string spirv = R"( OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %rta = OpTypeRuntimeArray %int %block = OpTypeStruct %rta %ptr_rta = OpTypePointer StorageBuffer %rta %ptr_block = OpTypePointer StorageBuffer %block %var = OpVariable %ptr_block StorageBuffer %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %gep = OpAccessChain %ptr_rta %var %int_0 %ld = OpLoad %rta %gep OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Cannot load a runtime-sized array")); } TEST_F(ValidateMemory, LoadRuntimeArrayInStruct) { const std::string spirv = R"( OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %rta = OpTypeRuntimeArray %int %block = OpTypeStruct %rta %ptr_rta = OpTypePointer StorageBuffer %rta %ptr_block = OpTypePointer StorageBuffer %block %var = OpVariable %ptr_block StorageBuffer %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %ld = OpLoad %block %var OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Cannot load a runtime-sized array")); } TEST_F(ValidateMemory, LoadRuntimeArrayInArray) { const std::string spirv = R"( OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %int_4 = OpConstant %int 4 %rta = OpTypeRuntimeArray %int %block = OpTypeStruct %rta %array = OpTypeArray %block %int_4 %ptr_rta = OpTypePointer StorageBuffer %rta %ptr_block = OpTypePointer StorageBuffer %block %ptr_array = OpTypePointer StorageBuffer %array %var = OpVariable %ptr_array StorageBuffer %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %ld = OpLoad %array %var OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Cannot load a runtime-sized array")); } TEST_F(ValidateMemory, Pre1p4WorkgroupMemoryBadLayoutOk) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %bool = OpTypeBool %struct = OpTypeStruct %bool %ptr = OpTypePointer Workgroup %struct %var = OpVariable %ptr Workgroup %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateMemory, UntypedVariableGood) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %ptr = OpTypeUntypedPointerKHR Private %var = OpUntypedVariableKHR %ptr Private %int %int_0 )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateMemory, UntypedVariableNoDataType) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %ptr = OpTypeUntypedPointerKHR StorageBuffer %var = OpUntypedVariableKHR %ptr StorageBuffer )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateMemory, UntypedVariableNoDataTypeFunction) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %ptr = OpTypeUntypedPointerKHR Function %var = OpUntypedVariableKHR %ptr Function )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Data type must be specified for Function, " "Private, and Workgroup storage classes")); } TEST_F(ValidateMemory, UntypedVariableNoDataTypePrivate) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %ptr = OpTypeUntypedPointerKHR Private %var = OpUntypedVariableKHR %ptr Private )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Data type must be specified for Function, " "Private, and Workgroup storage classes")); } TEST_F(ValidateMemory, UntypedVariableNoDataTypeWorkgroup) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %ptr = OpTypeUntypedPointerKHR Workgroup %var = OpUntypedVariableKHR %ptr Workgroup )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Data type must be specified for Function, " "Private, and Workgroup storage classes")); } TEST_F(ValidateMemory, UntypedVariableNoDataTypeVulkan) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %ptr = OpTypeUntypedPointerKHR StorageBuffer %var = OpUntypedVariableKHR %ptr StorageBuffer %void = OpTypeVoid %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Vulkan requires that data type be specified")); } TEST_F(ValidateMemory, PtrAccessChainArrayStrideBad) { const std::string spirv = R"( OpCapability Shader OpCapability VariablePointersStorageBuffer OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "foo" %var OpExecutionMode %main LocalSize 1 1 1 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %ptr = OpTypePointer StorageBuffer %uint %void = OpTypeVoid %func = OpTypeFunction %void %var = OpVariable %ptr StorageBuffer %main = OpFunction %void None %func %label = OpLabel %access = OpAccessChain %ptr %var %ptr_access = OpPtrAccessChain %ptr %access %uint_1 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_5); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpPtrAccessChain must have a Base whose type is " "decorated with ArrayStride")); } TEST_F(ValidateMemory, PtrAccessChainArrayStrideSuccess) { const std::string spirv = R"( OpCapability Shader OpCapability VariablePointersStorageBuffer OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "foo" %var OpExecutionMode %main LocalSize 1 1 1 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 00 OpDecorate %ptr ArrayStride 4 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %ptr = OpTypePointer StorageBuffer %uint %void = OpTypeVoid %func = OpTypeFunction %void %var = OpVariable %ptr StorageBuffer %main = OpFunction %void None %func %label = OpLabel %access = OpAccessChain %ptr %var %ptr_access = OpPtrAccessChain %ptr %access %uint_1 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_5); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); } TEST_F(ValidateMemory, VulkanPtrAccessChainStorageBufferSuccess) { const std::string spirv = R"( OpCapability Shader OpCapability VariablePointersStorageBuffer OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "foo" %var OpExecutionMode %main LocalSize 1 1 1 OpDecorate %_runtimearr_uint ArrayStride 4 OpMemberDecorate %_struct_10 0 Offset 0 OpDecorate %_struct_10 Block OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 OpDecorate %_ptr_StorageBuffer_uint ArrayStride 4 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %_runtimearr_uint = OpTypeRuntimeArray %uint %_struct_10 = OpTypeStruct %_runtimearr_uint %_ptr_StorageBuffer__struct_10 = OpTypePointer StorageBuffer %_struct_10 %_ptr_StorageBuffer_uint = OpTypePointer StorageBuffer %uint %void = OpTypeVoid %func2 = OpTypeFunction %void %_ptr_StorageBuffer_uint %func1 = OpTypeFunction %void %var = OpVariable %_ptr_StorageBuffer__struct_10 StorageBuffer %called = OpFunction %void None %func2 %param = OpFunctionParameter %_ptr_StorageBuffer_uint %label2 = OpLabel %ptr_access = OpPtrAccessChain %_ptr_StorageBuffer_uint %param %uint_1 OpReturn OpFunctionEnd %main = OpFunction %void None %func1 %label1 = OpLabel %access = OpAccessChain %_ptr_StorageBuffer_uint %var %uint_0 %uint_0 %call = OpFunctionCall %void %called %access OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateMemory, VulkanPtrAccessChainStorageBufferCapability) { const std::string spirv = R"( OpCapability Shader OpCapability PhysicalStorageBufferAddresses OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_KHR_variable_pointers" OpMemoryModel PhysicalStorageBuffer64 GLSL450 OpEntryPoint GLCompute %main "foo" %var OpExecutionMode %main LocalSize 1 1 1 OpDecorate %_runtimearr_uint ArrayStride 4 OpMemberDecorate %_struct_10 0 Offset 0 OpDecorate %_struct_10 Block OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 OpDecorate %_ptr_StorageBuffer_uint ArrayStride 4 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %_runtimearr_uint = OpTypeRuntimeArray %uint %_struct_10 = OpTypeStruct %_runtimearr_uint %_ptr_StorageBuffer__struct_10 = OpTypePointer StorageBuffer %_struct_10 %_ptr_StorageBuffer_uint = OpTypePointer StorageBuffer %uint %void = OpTypeVoid %func = OpTypeFunction %void %var = OpVariable %_ptr_StorageBuffer__struct_10 StorageBuffer %main = OpFunction %void None %func %label = OpLabel %access = OpAccessChain %_ptr_StorageBuffer_uint %var %uint_0 %uint_0 %ptr_access = OpPtrAccessChain %_ptr_StorageBuffer_uint %access %uint_1 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Base-07652")); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpPtrAccessChain Base operand pointing to " "StorageBuffer storage class must use VariablePointers " "or VariablePointersStorageBuffer capability")); } TEST_F(ValidateMemory, VulkanPtrAccessChainWorkgroupCapability) { const std::string spirv = R"( OpCapability Shader OpCapability VariablePointersStorageBuffer OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "foo" %var OpExecutionMode %main LocalSize 1 1 1 OpDecorate %_ptr_Workgroup_uint ArrayStride 4 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %_arr_uint = OpTypeArray %uint %uint_1 %_ptr_Workgroup__arr_uint = OpTypePointer Workgroup %_arr_uint %_ptr_Workgroup_uint = OpTypePointer Workgroup %uint %void = OpTypeVoid %func = OpTypeFunction %void %var = OpVariable %_ptr_Workgroup__arr_uint Workgroup %main = OpFunction %void None %func %label = OpLabel %access = OpAccessChain %_ptr_Workgroup_uint %var %uint_0 %ptr_access = OpPtrAccessChain %_ptr_Workgroup_uint %access %uint_1 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-Base-07651")); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpPtrAccessChain Base operand pointing to Workgroup " "storage class must use VariablePointers capability")); } TEST_F(ValidateMemory, VulkanPtrAccessChainWorkgroupNoArrayStrideSuccess) { const std::string spirv = R"( OpCapability Shader OpCapability VariablePointers OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "foo" %var OpExecutionMode %main LocalSize 1 1 1 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %_arr_uint = OpTypeArray %uint %uint_1 %_ptr_Workgroup__arr_uint = OpTypePointer Workgroup %_arr_uint %_ptr_Workgroup_uint = OpTypePointer Workgroup %uint %void = OpTypeVoid %func = OpTypeFunction %void %var = OpVariable %_ptr_Workgroup__arr_uint Workgroup %main = OpFunction %void None %func %label = OpLabel %access = OpAccessChain %_ptr_Workgroup_uint %var %uint_0 %ptr_access = OpPtrAccessChain %_ptr_Workgroup_uint %access %uint_1 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateMemory, AccessChainNegativeStructIndex32) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %void = OpTypeVoid %void_fn = OpTypeFunction %void %int = OpTypeInt 32 1 %_struct_4 = OpTypeStruct %int %int %int %_ptr_Function__struct_4 = OpTypePointer Function %_struct_4 %_ptr_Function_int = OpTypePointer Function %int %int_n224 = OpConstant %int -224 %fn = OpFunction %void Inline %void_fn %entry = OpLabel %var = OpVariable %_ptr_Function__struct_4 Function %gep = OpInBoundsAccessChain %_ptr_Function_int %var %int_n224 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("is out of bounds")); EXPECT_THAT(getDiagnosticString(), HasSubstr("cannot find index -224")); } TEST_F(ValidateMemory, AccessChainNegativeStructIndex64) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability Int64 OpMemoryModel Logical GLSL450 %void = OpTypeVoid %void_fn = OpTypeFunction %void %int = OpTypeInt 32 1 %long = OpTypeInt 64 1 %_struct_4 = OpTypeStruct %int %int %int %_ptr_Function__struct_4 = OpTypePointer Function %_struct_4 %_ptr_Function_int = OpTypePointer Function %int %long_n224 = OpConstant %long -224 %fn = OpFunction %void Inline %void_fn %entry = OpLabel %var = OpVariable %_ptr_Function__struct_4 Function %gep = OpInBoundsAccessChain %_ptr_Function_int %var %long_n224 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("is out of bounds")); EXPECT_THAT(getDiagnosticString(), HasSubstr("cannot find index -224")); } TEST_F(ValidateMemory, UntypedVariableFunctionOutsideFunction) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %ptr = OpTypeUntypedPointerKHR Function %var = OpUntypedVariableKHR %ptr Function %int )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Variables can not have a function[7] storage class " "outside of a function")); } TEST_F(ValidateMemory, UntypedVariableBadResultType) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %ptr = OpTypeUntypedPointerKHR Workgroup %var = OpUntypedVariableKHR %int Workgroup %int )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Result type must be an untyped pointer")); } TEST_F(ValidateMemory, UntypedVariableBadDataType) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %ptr = OpTypeUntypedPointerKHR Workgroup %var = OpUntypedVariableKHR %ptr Workgroup %int_0 )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Data type must be a type instruction")); } TEST_F(ValidateMemory, UntypedVariableBadStorageClass) { const std::string spirv = R"( OpCapability Kernel OpCapability GenericPointer OpCapability Linkage OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical OpenCL %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %ptr = OpTypeUntypedPointerKHR Generic %var = OpUntypedVariableKHR %ptr Generic %int )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_2); EXPECT_EQ(SPV_ERROR_INVALID_BINARY, ValidateInstructions(SPV_ENV_UNIVERSAL_1_2)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Variable storage class cannot be Generic")); } TEST_F(ValidateMemory, UntypedVariableMismatchedStorageClass) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %ptr = OpTypeUntypedPointerKHR Workgroup %var = OpUntypedVariableKHR %ptr Private %int )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Storage class must match result type storage class")); } TEST_F(ValidateMemory, UntypedVariableBadInitializer) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 %int = OpTypeInt 32 0 %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %ptr = OpTypeUntypedPointerKHR Private %var = OpUntypedVariableKHR %ptr Private %int %float_0 )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Initializer type must match the data type")); } TEST_F(ValidateMemory, AccessChainBaseUntypedPointer) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpName %var "var" %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %block = OpTypeStruct %int %ptr_ssbo = OpTypePointer StorageBuffer %block %ptr_ssbo_int = OpTypePointer StorageBuffer %int %ptr = OpTypeUntypedPointerKHR StorageBuffer %var = OpUntypedVariableKHR %ptr StorageBuffer %int %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %gep = OpAccessChain %ptr_ssbo_int %var %int_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("The Base '2[%var]' in OpAccessChain " "instruction must be a pointer")); } using ValidateMemoryUntypedAccessChain = spvtest::ValidateBase; TEST_P(ValidateMemoryUntypedAccessChain, GoodTypedPointerBase) { const std::string opcode = GetParam(); const bool ptr = opcode == "OpUntypedPtrAccessChainKHR" || opcode == "OpUntypedInBoundsPtrAccessChainKHR"; const std::string extra_param = ptr ? "%int_0" : ""; const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpCapability VariablePointers OpExtension "SPV_KHR_variable_pointers" OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %block = OpTypeStruct %int %ptr_ssbo = OpTypePointer StorageBuffer %block %var = OpVariable %ptr_ssbo StorageBuffer %ptr = OpTypeUntypedPointerKHR StorageBuffer %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %gep = )" + opcode + R"( %ptr %block %var )" + extra_param + R"( %int_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateMemoryUntypedAccessChain, GoodUntypedPointerBase) { const std::string opcode = GetParam(); const bool ptr = opcode == "OpUntypedPtrAccessChainKHR" || opcode == "OpUntypedInBoundsPtrAccessChainKHR"; const std::string extra_param = ptr ? "%int_0" : ""; const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpCapability VariablePointers OpExtension "SPV_KHR_variable_pointers" OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %block = OpTypeStruct %int %ptr_ssbo = OpTypePointer StorageBuffer %block %ptr = OpTypeUntypedPointerKHR StorageBuffer %var = OpUntypedVariableKHR %ptr StorageBuffer %int %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %gep = )" + opcode + R"( %ptr %block %var )" + extra_param + R"( %int_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateMemoryUntypedAccessChain, ResultTypedPointer) { const std::string opcode = GetParam(); const bool ptr = opcode == "OpUntypedPtrAccessChainKHR" || opcode == "OpUntypedInBoundsPtrAccessChainKHR"; const std::string extra_param = ptr ? "%int_0" : ""; const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpCapability VariablePointers OpExtension "SPV_KHR_variable_pointers" OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpName %gep "gep" %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %block = OpTypeStruct %int %ptr_ssbo = OpTypePointer StorageBuffer %block %var = OpVariable %ptr_ssbo StorageBuffer %ptr = OpTypeUntypedPointerKHR StorageBuffer %ptr_int = OpTypePointer StorageBuffer %int %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %gep = )" + opcode + R"( %ptr_int %block %var )" + extra_param + R"( %int_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("The Result Type of " + opcode + " '2[%gep]' must be OpTypeUntypedPointer")); } TEST_P(ValidateMemoryUntypedAccessChain, BaseTypeNotAType) { const std::string opcode = GetParam(); const bool ptr = opcode == "OpUntypedPtrAccessChainKHR" || opcode == "OpUntypedInBoundsPtrAccessChainKHR"; const std::string extra_param = ptr ? "%int_0" : ""; const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpCapability VariablePointers OpExtension "SPV_KHR_variable_pointers" OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpName %gep "gep" %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %block = OpTypeStruct %int %ptr_ssbo = OpTypePointer StorageBuffer %block %var = OpVariable %ptr_ssbo StorageBuffer %ptr = OpTypeUntypedPointerKHR StorageBuffer %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %gep = )" + opcode + R"( %ptr %int_0 %var )" + extra_param + R"( %int_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Base type must be a non-pointer type")); } TEST_P(ValidateMemoryUntypedAccessChain, BaseTypedPointer) { const std::string opcode = GetParam(); const bool ptr = opcode == "OpUntypedPtrAccessChainKHR" || opcode == "OpUntypedInBoundsPtrAccessChainKHR"; const std::string extra_param = ptr ? "%int_0" : ""; const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpCapability VariablePointers OpExtension "SPV_KHR_variable_pointers" OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpName %gep "gep" %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %block = OpTypeStruct %int %ptr_ssbo = OpTypePointer StorageBuffer %block %var = OpVariable %ptr_ssbo StorageBuffer %ptr = OpTypeUntypedPointerKHR StorageBuffer %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %gep = )" + opcode + R"( %ptr %ptr_ssbo %var )" + extra_param + R"( %int_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Base type must be a non-pointer type")); } TEST_P(ValidateMemoryUntypedAccessChain, BaseUntypedPointer) { const std::string opcode = GetParam(); const bool ptr = opcode == "OpUntypedPtrAccessChainKHR" || opcode == "OpUntypedInBoundsPtrAccessChainKHR"; const std::string extra_param = ptr ? "%int_0" : ""; const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpCapability VariablePointers OpExtension "SPV_KHR_variable_pointers" OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpName %gep "gep" %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %block = OpTypeStruct %int %ptr_ssbo = OpTypePointer StorageBuffer %block %var = OpVariable %ptr_ssbo StorageBuffer %ptr = OpTypeUntypedPointerKHR StorageBuffer %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %gep = )" + opcode + R"( %ptr %ptr %var )" + extra_param + R"( %int_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Base type must be a non-pointer type")); } TEST_P(ValidateMemoryUntypedAccessChain, BaseNotAPointer) { const std::string opcode = GetParam(); const bool ptr = opcode == "OpUntypedPtrAccessChainKHR" || opcode == "OpUntypedInBoundsPtrAccessChainKHR"; const std::string extra_param = ptr ? "%int_0" : ""; const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpCapability VariablePointers OpExtension "SPV_KHR_variable_pointers" OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpName %int_0 "int_0" %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %block = OpTypeStruct %int %ptr_ssbo = OpTypePointer StorageBuffer %block %var = OpVariable %ptr_ssbo StorageBuffer %ptr = OpTypeUntypedPointerKHR StorageBuffer %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %gep = )" + opcode + R"( %ptr %int %int_0 )" + extra_param + R"( %int_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("The Base '2[%int_0]' in " + opcode + " instruction must be a pointer")); } TEST_P(ValidateMemoryUntypedAccessChain, StorageClassMismatch) { const std::string opcode = GetParam(); const bool ptr = opcode == "OpUntypedPtrAccessChainKHR" || opcode == "OpUntypedInBoundsPtrAccessChainKHR"; const std::string extra_param = ptr ? "%int_0" : ""; const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpCapability VariablePointers OpExtension "SPV_KHR_variable_pointers" OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpName %int_0 "int_0" %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %block = OpTypeStruct %int %ptr_wg = OpTypePointer Workgroup %block %var = OpVariable %ptr_wg Workgroup %ptr = OpTypeUntypedPointerKHR StorageBuffer %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %gep = )" + opcode + R"( %ptr %block %var )" + extra_param + R"( %int_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("The result pointer storage class and base pointer storage " "class in " + opcode + " do not match")); } TEST_P(ValidateMemoryUntypedAccessChain, NonCompositeBase) { const std::string opcode = GetParam(); const bool ptr = opcode == "OpUntypedPtrAccessChainKHR" || opcode == "OpUntypedInBoundsPtrAccessChainKHR"; const std::string extra_param = ptr ? "%int_0" : ""; const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpCapability VariablePointers OpExtension "SPV_KHR_variable_pointers" OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpName %int_0 "int_0" %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %block = OpTypeStruct %int %ptr_wg = OpTypePointer StorageBuffer %block %var = OpVariable %ptr_wg StorageBuffer %ptr = OpTypeUntypedPointerKHR StorageBuffer %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %gep = )" + opcode + R"( %ptr %int %var )" + extra_param + R"( %int_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(opcode + " reached non-composite type while indexes " "still remain to be traversed")); } TEST_P(ValidateMemoryUntypedAccessChain, TooManyIndices) { const std::string opcode = GetParam(); const bool ptr = opcode == "OpUntypedPtrAccessChainKHR" || opcode == "OpUntypedInBoundsPtrAccessChainKHR"; const std::string extra_param = ptr ? "%int_0" : ""; const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpCapability VariablePointers OpExtension "SPV_KHR_variable_pointers" OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpName %int_0 "int_0" %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %block = OpTypeStruct %int %ptr_wg = OpTypePointer StorageBuffer %block %var = OpVariable %ptr_wg StorageBuffer %ptr = OpTypeUntypedPointerKHR StorageBuffer %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %gep = )" + opcode + R"( %ptr %block %var )" + extra_param + R"( %int_0 %int_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(opcode + " reached non-composite type while indexes " "still remain to be traversed")); } INSTANTIATE_TEST_SUITE_P( ValidateUntypedAccessChains, ValidateMemoryUntypedAccessChain, Values("OpUntypedAccessChainKHR", "OpUntypedInBoundsAccessChainKHR", "OpUntypedPtrAccessChainKHR", "OpUntypedInBoundsPtrAccessChainKHR")); TEST_F(ValidateMemory, LoadUntypedPointerGood) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpCapability WorkgroupMemoryExplicitLayoutKHR OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %var OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %float = OpTypeFloat 32 %struct = OpTypeStruct %int %ptr = OpTypeUntypedPointerKHR Workgroup %var = OpUntypedVariableKHR %ptr Workgroup %struct %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %load = OpLoad %float %var OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); } TEST_F(ValidateMemory, StoreUntypedPointerGood) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpCapability WorkgroupMemoryExplicitLayoutKHR OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %var OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %float = OpTypeFloat 32 %float_0 = OpConstant %float 0 %struct = OpTypeStruct %int %ptr = OpTypeUntypedPointerKHR Workgroup %var = OpUntypedVariableKHR %ptr Workgroup %struct %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpStore %var %float_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); } TEST_F(ValidateMemory, CopyMemoryUntypedPointerSourceGood) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpCapability WorkgroupMemoryExplicitLayoutKHR OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %var1 %var2 OpName %var1 "var1" OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %struct = OpTypeStruct %int %ptr = OpTypeUntypedPointerKHR Workgroup %var1 = OpUntypedVariableKHR %ptr Workgroup %struct %ptr_wg = OpTypePointer Workgroup %int %var2 = OpVariable %ptr_wg Workgroup %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpCopyMemory %var2 %var1 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); } TEST_F(ValidateMemory, CopyMemoryUntypedPointerTargetGood) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpCapability WorkgroupMemoryExplicitLayoutKHR OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %var1 %var2 OpName %var1 "var1" OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %struct = OpTypeStruct %int %ptr = OpTypeUntypedPointerKHR Workgroup %var1 = OpUntypedVariableKHR %ptr Workgroup %struct %ptr_wg = OpTypePointer Workgroup %int %var2 = OpVariable %ptr_wg Workgroup %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpCopyMemory %var1 %var2 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); } TEST_F(ValidateMemory, CopyMemoryUntypedPointerTargetAndSourceBad) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpCapability WorkgroupMemoryExplicitLayoutKHR OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %var1 %var2 OpName %var1 "var1" OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %struct = OpTypeStruct %int %ptr = OpTypeUntypedPointerKHR Workgroup %var1 = OpUntypedVariableKHR %ptr Workgroup %struct %var2 = OpUntypedVariableKHR %ptr Workgroup %struct %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpCopyMemory %var1 %var2 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("One of Source or Target must be a typed pointer")); } TEST_F(ValidateMemory, CopyMemorySizedUntypedPointersGood) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpCapability WorkgroupMemoryExplicitLayoutKHR OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %v1 %v2 OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_4 = OpConstant %int 4 %struct = OpTypeStruct %int %ptr = OpTypeUntypedPointerKHR Workgroup %v1 = OpUntypedVariableKHR %ptr Workgroup %struct %v2 = OpUntypedVariableKHR %ptr Workgroup %struct %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpCopyMemorySized %v2 %v1 %int_4 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); } TEST_F(ValidateMemory, CopyMemorySizedUntypedPointersSizeBad1) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpCapability StorageBuffer16BitAccess OpCapability WorkgroupMemoryExplicitLayoutKHR OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %var_wg %var_ssbo OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %short = OpTypeInt 16 0 %int_2 = OpConstant %int 2 %struct = OpTypeStruct %int %ptr_ssbo = OpTypeUntypedPointerKHR StorageBuffer %ptr_wg = OpTypeUntypedPointerKHR Workgroup %var_ssbo = OpUntypedVariableKHR %ptr_ssbo StorageBuffer %struct %var_wg = OpUntypedVariableKHR %ptr_wg Workgroup %struct %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpCopyMemorySized %var_ssbo %var_wg %int_2 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Size must be a multiple of 4")); } TEST_F(ValidateMemory, CopyMemorySizedUntypedPointersSizeBad2) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpCapability StorageBuffer16BitAccess OpCapability WorkgroupMemoryExplicitLayoutKHR OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %var_ssbo %var_wg OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %short = OpTypeInt 16 0 %int_2 = OpConstant %int 2 %struct = OpTypeStruct %int %ptr_ssbo = OpTypeUntypedPointerKHR StorageBuffer %ptr_wg = OpTypeUntypedPointerKHR Workgroup %var_ssbo = OpUntypedVariableKHR %ptr_ssbo StorageBuffer %struct %var_wg = OpUntypedVariableKHR %ptr_wg Workgroup %struct %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpCopyMemorySized %var_wg %var_ssbo %int_2 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Size must be a multiple of 4")); } TEST_F(ValidateMemory, CopyMemorySizedUntypedPointersSizeBad3) { const std::string spirv = R"( OpCapability Shader OpCapability Int16 OpCapability UntypedPointersKHR OpCapability StorageBuffer8BitAccess OpCapability WorkgroupMemoryExplicitLayoutKHR OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpExtension "SPV_KHR_8bit_storage" OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %var_ssbo %var_wg OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %short = OpTypeInt 16 0 %int_1 = OpConstant %int 1 %struct = OpTypeStruct %int %ptr_ssbo = OpTypeUntypedPointerKHR StorageBuffer %ptr_wg = OpTypeUntypedPointerKHR Workgroup %var_ssbo = OpUntypedVariableKHR %ptr_ssbo StorageBuffer %struct %var_wg = OpUntypedVariableKHR %ptr_wg Workgroup %struct %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpCopyMemorySized %var_ssbo %var_wg %int_1 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Size must be a multiple of 2")); } TEST_F(ValidateMemory, CopyMemorySizedUntypedPointersSizeBad4) { const std::string spirv = R"( OpCapability Shader OpCapability Int16 OpCapability UntypedPointersKHR OpCapability StorageBuffer8BitAccess OpCapability WorkgroupMemoryExplicitLayoutKHR OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpExtension "SPV_KHR_8bit_storage" OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %var_ssbo %var_wg OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %short = OpTypeInt 16 0 %int_1 = OpConstant %int 1 %struct = OpTypeStruct %int %ptr_ssbo = OpTypeUntypedPointerKHR StorageBuffer %ptr_wg = OpTypeUntypedPointerKHR Workgroup %var_ssbo = OpUntypedVariableKHR %ptr_ssbo StorageBuffer %struct %var_wg = OpUntypedVariableKHR %ptr_wg Workgroup %struct %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpCopyMemorySized %var_wg %var_ssbo %int_1 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Size must be a multiple of 2")); } TEST_F(ValidateMemory, PtrEqualUntypedPointersGood) { const std::string spirv = R"( OpCapability Shader OpCapability VariablePointers OpCapability UntypedPointersKHR OpCapability WorkgroupMemoryExplicitLayoutKHR OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %v1 %v2 OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %bool = OpTypeBool %int = OpTypeInt 32 0 %struct = OpTypeStruct %int %ptr = OpTypeUntypedPointerKHR Workgroup %v1 = OpUntypedVariableKHR %ptr Workgroup %struct %v2 = OpUntypedVariableKHR %ptr Workgroup %struct %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %res = OpPtrEqual %bool %v1 %v2 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); } TEST_F(ValidateMemory, PtrNotEqualUntypedPointersGood) { const std::string spirv = R"( OpCapability Shader OpCapability VariablePointers OpCapability UntypedPointersKHR OpCapability WorkgroupMemoryExplicitLayoutKHR OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %v1 %v2 OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %bool = OpTypeBool %int = OpTypeInt 32 0 %struct = OpTypeStruct %int %ptr = OpTypeUntypedPointerKHR Workgroup %v1 = OpUntypedVariableKHR %ptr Workgroup %struct %v2 = OpUntypedVariableKHR %ptr Workgroup %struct %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %res = OpPtrNotEqual %bool %v1 %v2 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); } TEST_F(ValidateMemory, PtrDiffUntypedPointersGood) { const std::string spirv = R"( OpCapability Shader OpCapability VariablePointers OpCapability UntypedPointersKHR OpCapability WorkgroupMemoryExplicitLayoutKHR OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %v1 OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %struct = OpTypeStruct %int %ptr = OpTypeUntypedPointerKHR Workgroup %v1 = OpUntypedVariableKHR %ptr Workgroup %struct %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %res = OpPtrDiff %int %v1 %v1 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); } TEST_F(ValidateMemory, UntypedVariableVulkanPushConstantGood) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %struct = OpTypeStruct %int %ptr = OpTypeUntypedPointerKHR PushConstant %var = OpUntypedVariableKHR %ptr PushConstant %struct %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateMemory, UntypedVariableVulkanStorageBufferGood) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %struct = OpTypeStruct %int %ptr = OpTypeUntypedPointerKHR StorageBuffer %var = OpUntypedVariableKHR %ptr StorageBuffer %struct %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateMemory, UntypedVariableVulkanUniformGood) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %struct = OpTypeStruct %int %ptr = OpTypeUntypedPointerKHR Uniform %var = OpUntypedVariableKHR %ptr Uniform %struct %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); } TEST_F(ValidateMemory, UntypedVariableVulkanWorkgroupGood) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpCapability WorkgroupMemoryExplicitLayoutKHR OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %struct = OpTypeStruct %int %ptr = OpTypeUntypedPointerKHR Workgroup %var = OpUntypedVariableKHR %ptr Workgroup %struct %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1_SPIRV_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_1_SPIRV_1_4)); } TEST_F(ValidateMemory, UntypedPointerAsVariableType) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability VariablePointers OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 %void = OpTypeVoid %float = OpTypeFloat 32 %ptr = OpTypeUntypedPointerKHR StorageBuffer %priv_ptr = OpTypePointer Private %ptr %var = OpVariable %priv_ptr Private )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateMemory, UntypedArrayLengthGood) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 OpDecorate %block Block OpMemberDecorate %block 0 Offset 0 OpDecorate %array ArrayStride 4 %void = OpTypeVoid %int = OpTypeInt 32 0 %array = OpTypeRuntimeArray %int %block = OpTypeStruct %array %ptr = OpTypeUntypedPointerKHR StorageBuffer %var = OpUntypedVariableKHR %ptr StorageBuffer %block %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %length = OpUntypedArrayLengthKHR %int %block %var 0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateMemory, UntypedArrayLengthBadResultType) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 OpDecorate %block Block OpMemberDecorate %block 0 Offset 0 OpDecorate %array ArrayStride 4 %void = OpTypeVoid %int = OpTypeInt 32 0 %float = OpTypeFloat 32 %array = OpTypeRuntimeArray %int %block = OpTypeStruct %array %ptr = OpTypeUntypedPointerKHR StorageBuffer %var = OpUntypedVariableKHR %ptr StorageBuffer %block %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %length = OpUntypedArrayLengthKHR %float %block %var 0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be OpTypeInt with width 32 and signedness 0")); } TEST_F(ValidateMemory, UntypedArrayLengthBadPointer) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 OpDecorate %block Block OpMemberDecorate %block 0 Offset 0 OpDecorate %array ArrayStride 4 %void = OpTypeVoid %int = OpTypeInt 32 0 %array = OpTypeRuntimeArray %int %block = OpTypeStruct %array %ptr = OpTypeUntypedPointerKHR StorageBuffer %typed_ptr = OpTypePointer StorageBuffer %block %var = OpVariable %typed_ptr StorageBuffer %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %length = OpUntypedArrayLengthKHR %int %block %var 0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Pointer must be an untyped pointer")); } TEST_F(ValidateMemory, UntypedArrayLengtBadStruct) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 OpDecorate %block Block OpMemberDecorate %block 0 Offset 0 OpDecorate %array ArrayStride 4 %void = OpTypeVoid %int = OpTypeInt 32 0 %array = OpTypeRuntimeArray %int %block = OpTypeStruct %array %ptr = OpTypeUntypedPointerKHR StorageBuffer %var = OpUntypedVariableKHR %ptr StorageBuffer %block %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %length = OpUntypedArrayLengthKHR %int %int %var 0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("to an OpTypeStruct")); } TEST_F(ValidateMemory, UntypedArrayLengthLastMemberNotArray) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 OpDecorate %block Block OpMemberDecorate %block 0 Offset 0 OpDecorate %array ArrayStride 4 %void = OpTypeVoid %int = OpTypeInt 32 0 %array = OpTypeRuntimeArray %int %block = OpTypeStruct %int %ptr = OpTypeUntypedPointerKHR StorageBuffer %var = OpUntypedVariableKHR %ptr StorageBuffer %block %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %length = OpUntypedArrayLengthKHR %int %block %var 0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be an OpTypeRuntimeArray")); } TEST_F(ValidateMemory, UntypedArrayLengthBadIndex) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 OpDecorate %block Block OpMemberDecorate %block 0 Offset 0 OpDecorate %array ArrayStride 4 %void = OpTypeVoid %int = OpTypeInt 32 0 %array = OpTypeRuntimeArray %int %block = OpTypeStruct %array %ptr = OpTypeUntypedPointerKHR StorageBuffer %var = OpUntypedVariableKHR %ptr StorageBuffer %block %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %length = OpUntypedArrayLengthKHR %int %block %var 1 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be the last member of the struct")); } TEST_F(ValidateMemory, UntypedCooperativeMatrixLoad) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpCapability CooperativeMatrixKHR OpCapability VulkanMemoryModel OpExtension "SPV_KHR_untyped_pointers" OpExtension "SPV_KHR_cooperative_matrix" OpMemoryModel Logical Vulkan OpEntryPoint GLCompute %main "main" %var OpExecutionMode %main LocalSize 1 1 1 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 OpDecorate %block Block OpMemberDecorate %block 0 Offset 0 OpDecorate %array ArrayStride 4 %void = OpTypeVoid %void_fn = OpTypeFunction %void %untyped = OpTypeUntypedPointerKHR StorageBuffer %float = OpTypeFloat 32 %array = OpTypeRuntimeArray %float %block = OpTypeStruct %array %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %subgroup = OpConstant %int 3 %rows = OpSpecConstant %int 1 %cols = OpSpecConstant %int 1 %matrix_a = OpConstant %int 1 %stride = OpConstant %int 42 %matrix = OpTypeCooperativeMatrixKHR %float %subgroup %rows %cols %matrix_a %var = OpUntypedVariableKHR %untyped StorageBuffer %block %main = OpFunction %void None %void_fn %entry = OpLabel %ld = OpCooperativeMatrixLoadKHR %matrix %var %int_0 %stride OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_3)); } TEST_F(ValidateMemory, UntypedCooperativeMatrixLoad2) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpCapability CooperativeMatrixKHR OpCapability VulkanMemoryModel OpExtension "SPV_KHR_untyped_pointers" OpExtension "SPV_KHR_cooperative_matrix" OpMemoryModel Logical Vulkan OpEntryPoint GLCompute %main "main" %var OpExecutionMode %main LocalSize 1 1 1 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 OpDecorate %block Block OpMemberDecorate %block 0 Offset 0 OpDecorate %array ArrayStride 4 %void = OpTypeVoid %void_fn = OpTypeFunction %void %untyped = OpTypeUntypedPointerKHR StorageBuffer %float = OpTypeFloat 32 %array = OpTypeRuntimeArray %float %block = OpTypeStruct %array %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %subgroup = OpConstant %int 3 %rows = OpSpecConstant %int 1 %cols = OpSpecConstant %int 1 %matrix_a = OpConstant %int 1 %stride = OpConstant %int 42 %matrix = OpTypeCooperativeMatrixKHR %float %subgroup %rows %cols %matrix_a %var = OpUntypedVariableKHR %untyped StorageBuffer %block %main = OpFunction %void None %void_fn %entry = OpLabel %gep = OpUntypedAccessChainKHR %untyped %block %var %int_0 %int_0 %ld = OpCooperativeMatrixLoadKHR %matrix %gep %int_0 %stride OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_3)); } TEST_F(ValidateMemory, UntypedCooperativeMatrixStore) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpCapability CooperativeMatrixKHR OpCapability VulkanMemoryModel OpExtension "SPV_KHR_untyped_pointers" OpExtension "SPV_KHR_cooperative_matrix" OpMemoryModel Logical Vulkan OpEntryPoint GLCompute %main "main" %var1 %var2 OpExecutionMode %main LocalSize 1 1 1 OpDecorate %var1 DescriptorSet 0 OpDecorate %var1 Binding 0 OpDecorate %var2 DescriptorSet 0 OpDecorate %var2 Binding 1 OpDecorate %block Block OpMemberDecorate %block 0 Offset 0 OpDecorate %array ArrayStride 4 %void = OpTypeVoid %void_fn = OpTypeFunction %void %untyped = OpTypeUntypedPointerKHR StorageBuffer %float = OpTypeFloat 32 %array = OpTypeRuntimeArray %float %block = OpTypeStruct %array %ptr = OpTypePointer StorageBuffer %block %ptr_float = OpTypePointer StorageBuffer %float %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %subgroup = OpConstant %int 3 %rows = OpSpecConstant %int 1 %cols = OpSpecConstant %int 1 %matrix_a = OpConstant %int 1 %stride = OpConstant %int 42 %matrix = OpTypeCooperativeMatrixKHR %float %subgroup %rows %cols %matrix_a %var1 = OpVariable %ptr StorageBuffer %var2 = OpUntypedVariableKHR %untyped StorageBuffer %block %main = OpFunction %void None %void_fn %entry = OpLabel %gep = OpAccessChain %ptr_float %var1 %int_0 %int_0 %ld = OpCooperativeMatrixLoadKHR %matrix %gep %int_0 %stride OpCooperativeMatrixStoreKHR %var2 %ld %int_0 %stride OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_3)); } TEST_F(ValidateMemory, UntypedCooperativeMatrixStore2) { const std::string spirv = R"( OpCapability Shader OpCapability UntypedPointersKHR OpCapability CooperativeMatrixKHR OpCapability VulkanMemoryModel OpExtension "SPV_KHR_untyped_pointers" OpExtension "SPV_KHR_cooperative_matrix" OpMemoryModel Logical Vulkan OpEntryPoint GLCompute %main "main" %var1 %var2 OpExecutionMode %main LocalSize 1 1 1 OpDecorate %var1 DescriptorSet 0 OpDecorate %var1 Binding 0 OpDecorate %var2 DescriptorSet 0 OpDecorate %var2 Binding 1 OpDecorate %block Block OpMemberDecorate %block 0 Offset 0 OpDecorate %array ArrayStride 4 %void = OpTypeVoid %void_fn = OpTypeFunction %void %untyped = OpTypeUntypedPointerKHR StorageBuffer %float = OpTypeFloat 32 %array = OpTypeRuntimeArray %float %block = OpTypeStruct %array %ptr = OpTypePointer StorageBuffer %block %ptr_float = OpTypePointer StorageBuffer %float %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %subgroup = OpConstant %int 3 %rows = OpSpecConstant %int 1 %cols = OpSpecConstant %int 1 %matrix_a = OpConstant %int 1 %stride = OpConstant %int 42 %matrix = OpTypeCooperativeMatrixKHR %float %subgroup %rows %cols %matrix_a %var1 = OpVariable %ptr StorageBuffer %var2 = OpUntypedVariableKHR %untyped StorageBuffer %block %main = OpFunction %void None %void_fn %entry = OpLabel %gep = OpAccessChain %ptr_float %var1 %int_0 %int_0 %ld = OpCooperativeMatrixLoadKHR %matrix %gep %int_0 %stride %gep2 = OpUntypedAccessChainKHR %untyped %block %var2 %int_0 %int_0 OpCooperativeMatrixStoreKHR %gep2 %ld %int_0 %stride OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_3)); } std::string GenCoopMat2Shader(const std::string& extra_types, const std::string& main_body, const std::string& after_main = "", const std::string& extra_decorations = "") { const std::string prefix = R"( OpCapability Shader OpCapability Float16 OpCapability PhysicalStorageBufferAddresses OpCapability VulkanMemoryModel OpCapability CooperativeMatrixKHR OpCapability TensorAddressingNV OpCapability CooperativeMatrixTensorAddressingNV OpCapability CooperativeMatrixBlockLoadsNV OpExtension "SPV_KHR_physical_storage_buffer" OpExtension "SPV_KHR_storage_buffer_storage_class" OpExtension "SPV_NV_tensor_addressing" OpExtension "SPV_NV_cooperative_matrix2" OpExtension "SPV_KHR_cooperative_matrix" OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical VulkanKHR OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %f16_arr ArrayStride 2 OpDecorate %46 Block OpMemberDecorate %46 0 Offset 0 OpDecorate %48 Binding 0 OpDecorate %48 DescriptorSet 0 OpDecorate %psb Restrict )" + extra_decorations + R"( %void = OpTypeVoid %bool = OpTypeBool %func = OpTypeFunction %void %f16 = OpTypeFloat 16 %f32 = OpTypeFloat 32 %u32 = OpTypeInt 32 0 %s32 = OpTypeInt 32 1 %s32_0 = OpConstant %s32 0 %f16_0 = OpConstant %f16 0 %u32_2 = OpConstant %u32 2 %u32_8 = OpConstant %u32 8 %use_A = OpConstant %u32 0 %workgroup = OpConstant %u32 2 %subgroup = OpConstant %u32 3 %f16_arr = OpTypeRuntimeArray %f16 %46 = OpTypeStruct %f16_arr %47 = OpTypePointer StorageBuffer %46 %48 = OpVariable %47 StorageBuffer %51 = OpTypePointer StorageBuffer %f16_arr %psbptr = OpTypePointer PhysicalStorageBuffer %f16_arr %f16mat = OpTypeCooperativeMatrixKHR %f16 %workgroup %u32_8 %u32_8 %use_A %f32mat = OpTypeCooperativeMatrixKHR %f32 %subgroup %u32_8 %u32_8 %use_A %arr2 = OpTypeArray %u32 %u32_2 %functy = OpTypeFunction %f16 %psbptr %arr2 %arr2 )"; const std::string decode_func = R"( %decodefunc = OpFunction %f16 None %functy %psb = OpFunctionParameter %psbptr %c0 = OpFunctionParameter %arr2 %c1 = OpFunctionParameter %arr2 %entry2 = OpLabel OpReturnValue %f16_0 OpFunctionEnd )"; const std::string func_begin = R"( %main = OpFunction %void None %func %main_entry = OpLabel %array_ptr = OpAccessChain %51 %48 %s32_0 )"; const std::string suffix = R"( OpReturn OpFunctionEnd)"; return prefix + extra_types + func_begin + main_body + suffix + decode_func + after_main; } TEST_F(ValidateMemory, CoopMat2TensorLayoutAndViewSuccess) { std::string spirv = GenCoopMat2Shader( R"( %clamp = OpConstant %u32 0 %dim = OpConstant %u32 2 %p0 = OpConstant %u32 0 %p1 = OpConstant %u32 1 %hasdim = OpConstantFalse %bool %layout = OpTypeTensorLayoutNV %dim %clamp %view = OpTypeTensorViewNV %dim %hasdim %p0 %p1 )", R"( )"); CompileSuccessfully(spirv.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateMemory, CoopMat2TensorLayoutInvalidDimFail) { std::string spirv = GenCoopMat2Shader( R"( %clamp = OpConstant %u32 0 %dim = OpConstant %u32 6 %layout = OpTypeTensorLayoutNV %dim %clamp )", R"( )"); CompileSuccessfully(spirv.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be between 1 and 5")); } TEST_F(ValidateMemory, CoopMat2TensorLayoutInvalidClampFail) { std::string spirv = GenCoopMat2Shader( R"( %clamp = OpConstant %u32 6 %dim = OpConstant %u32 2 %layout = OpTypeTensorLayoutNV %dim %clamp )", R"( )"); CompileSuccessfully(spirv.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be a valid TensorClampMode")); } TEST_F(ValidateMemory, CoopMat2TensorViewInvalidDimFail) { std::string spirv = GenCoopMat2Shader( R"( %dim = OpConstant %u32 6 %p0 = OpConstant %u32 0 %p1 = OpConstant %u32 1 %hasdim = OpConstantFalse %bool %view = OpTypeTensorViewNV %dim %hasdim %p0 %p1 )", R"( )"); CompileSuccessfully(spirv.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be between 1 and 5")); } TEST_F(ValidateMemory, CoopMat2TensorViewInvalidPermutationFail) { std::string spirv = GenCoopMat2Shader( R"( %dim = OpConstant %u32 3 %p0 = OpConstant %u32 0 %p1 = OpConstant %u32 1 %hasdim = OpConstantFalse %bool %view = OpTypeTensorViewNV %dim %hasdim %p0 %p1 %p1 )", R"( )"); CompileSuccessfully(spirv.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Permutation values don't form a valid permutation")); } TEST_F(ValidateMemory, CoopMat2TensorViewInvalidPermutation2Fail) { std::string spirv = GenCoopMat2Shader( R"( %dim = OpConstant %u32 3 %p0 = OpConstant %u32 0 %p1 = OpConstant %u32 1 %hasdim = OpConstantFalse %bool %view = OpTypeTensorViewNV %dim %hasdim %p0 %p1 )", R"( )"); CompileSuccessfully(spirv.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Incorrect number of permutation values.")); } TEST_F(ValidateMemory, CoopMat2TensorLayoutBlockSizePass) { std::string spirv = GenCoopMat2Shader( R"( %clamp = OpConstant %u32 0 %dim = OpConstant %u32 3 %b = OpConstant %u32 1 %layout = OpTypeTensorLayoutNV %dim %clamp )", R"( %tl = OpCreateTensorLayoutNV %layout %tl2 = OpTensorLayoutSetBlockSizeNV %layout %tl %b %b %b )"); CompileSuccessfully(spirv.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateMemory, CoopMat2TensorLayoutBlockSizeFail) { std::string spirv = GenCoopMat2Shader( R"( %clamp = OpConstant %u32 0 %dim = OpConstant %u32 3 %b = OpConstant %u32 1 %layout = OpTypeTensorLayoutNV %dim %clamp )", R"( %tl = OpCreateTensorLayoutNV %layout %tl2 = OpTensorLayoutSetBlockSizeNV %layout %tl %b %b %b %b )"); CompileSuccessfully(spirv.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("unexpected number of operands")); } TEST_F(ValidateMemory, CoopMat2TensorLayoutDimensionPass) { std::string spirv = GenCoopMat2Shader( R"( %clamp = OpConstant %u32 0 %dim = OpConstant %u32 3 %b = OpConstant %u32 1 %layout = OpTypeTensorLayoutNV %dim %clamp )", R"( %tl = OpCreateTensorLayoutNV %layout %tl2 = OpTensorLayoutSetDimensionNV %layout %tl %b %b %b )"); CompileSuccessfully(spirv.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateMemory, CoopMat2TensorLayoutDimensionFail) { std::string spirv = GenCoopMat2Shader( R"( %clamp = OpConstant %u32 0 %dim = OpConstant %u32 3 %b = OpConstant %u32 1 %layout = OpTypeTensorLayoutNV %dim %clamp )", R"( %tl = OpCreateTensorLayoutNV %layout %tl2 = OpTensorLayoutSetDimensionNV %layout %tl %b %b %b %b )"); CompileSuccessfully(spirv.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("unexpected number of operands")); } TEST_F(ValidateMemory, CoopMat2TensorLayoutStridePass) { std::string spirv = GenCoopMat2Shader( R"( %clamp = OpConstant %u32 0 %dim = OpConstant %u32 3 %b = OpConstant %u32 1 %layout = OpTypeTensorLayoutNV %dim %clamp )", R"( %tl = OpCreateTensorLayoutNV %layout %tl2 = OpTensorLayoutSetStrideNV %layout %tl %b %b %b )"); CompileSuccessfully(spirv.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateMemory, CoopMat2TensorLayoutStrideFail) { std::string spirv = GenCoopMat2Shader( R"( %clamp = OpConstant %u32 0 %dim = OpConstant %u32 3 %b = OpConstant %u32 1 %layout = OpTypeTensorLayoutNV %dim %clamp )", R"( %tl = OpCreateTensorLayoutNV %layout %tl2 = OpTensorLayoutSetStrideNV %layout %tl %b %b %b %b )"); CompileSuccessfully(spirv.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("unexpected number of operands")); } TEST_F(ValidateMemory, CoopMat2TensorLayoutSlicePass) { std::string spirv = GenCoopMat2Shader( R"( %clamp = OpConstant %u32 0 %dim = OpConstant %u32 3 %b = OpConstant %u32 1 %layout = OpTypeTensorLayoutNV %dim %clamp )", R"( %tl = OpCreateTensorLayoutNV %layout %tl2 = OpTensorLayoutSliceNV %layout %tl %b %b %b %b %b %b )"); CompileSuccessfully(spirv.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateMemory, CoopMat2TensorLayoutSliceFail) { std::string spirv = GenCoopMat2Shader( R"( %clamp = OpConstant %u32 0 %dim = OpConstant %u32 3 %b = OpConstant %u32 1 %layout = OpTypeTensorLayoutNV %dim %clamp )", R"( %tl = OpCreateTensorLayoutNV %layout %tl2 = OpTensorLayoutSliceNV %layout %tl %b %b %b )"); CompileSuccessfully(spirv.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("unexpected number of operands")); } TEST_F(ValidateMemory, CoopMat2TensorLayoutSetClampValuePass) { std::string spirv = GenCoopMat2Shader( R"( %clamp = OpConstant %u32 0 %dim = OpConstant %u32 3 %b = OpConstant %u32 1 %layout = OpTypeTensorLayoutNV %dim %clamp )", R"( %tl = OpCreateTensorLayoutNV %layout %tl2 = OpTensorLayoutSetClampValueNV %layout %tl %b )"); CompileSuccessfully(spirv.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateMemory, CoopMat2TensorViewDimensionPass) { std::string spirv = GenCoopMat2Shader( R"( %dim = OpConstant %u32 3 %hasdim = OpConstantFalse %bool %p0 = OpConstant %u32 0 %p1 = OpConstant %u32 1 %p2 = OpConstant %u32 2 %view = OpTypeTensorViewNV %dim %hasdim %p0 %p1 %p2 %b = OpConstant %u32 1 )", R"( %tv = OpCreateTensorViewNV %view %tv2 = OpTensorViewSetDimensionNV %view %tv %b %b %b )"); CompileSuccessfully(spirv.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateMemory, CoopMat2TensorViewDimensionFail) { std::string spirv = GenCoopMat2Shader( R"( %dim = OpConstant %u32 3 %hasdim = OpConstantFalse %bool %p0 = OpConstant %u32 0 %p1 = OpConstant %u32 1 %p2 = OpConstant %u32 2 %view = OpTypeTensorViewNV %dim %hasdim %p0 %p1 %p2 %b = OpConstant %u32 1 )", R"( %tv = OpCreateTensorViewNV %view %tv2 = OpTensorViewSetDimensionNV %view %tv %b %b %b %b )"); CompileSuccessfully(spirv.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("unexpected number of operands")); } TEST_F(ValidateMemory, CoopMat2TensorViewStridePass) { std::string spirv = GenCoopMat2Shader( R"( %dim = OpConstant %u32 3 %hasdim = OpConstantFalse %bool %p0 = OpConstant %u32 0 %p1 = OpConstant %u32 1 %p2 = OpConstant %u32 2 %view = OpTypeTensorViewNV %dim %hasdim %p0 %p1 %p2 %b = OpConstant %u32 1 )", R"( %tv = OpCreateTensorViewNV %view %tv2 = OpTensorViewSetStrideNV %view %tv %b %b %b )"); CompileSuccessfully(spirv.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateMemory, CoopMat2TensorViewStrideFail) { std::string spirv = GenCoopMat2Shader( R"( %dim = OpConstant %u32 3 %hasdim = OpConstantFalse %bool %p0 = OpConstant %u32 0 %p1 = OpConstant %u32 1 %p2 = OpConstant %u32 2 %view = OpTypeTensorViewNV %dim %hasdim %p0 %p1 %p2 %b = OpConstant %u32 1 )", R"( %tv = OpCreateTensorViewNV %view %tv2 = OpTensorViewSetStrideNV %view %tv %b %b %b %b )"); CompileSuccessfully(spirv.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("unexpected number of operands")); } TEST_F(ValidateMemory, CoopMat2TensorViewClipPass) { std::string spirv = GenCoopMat2Shader( R"( %dim = OpConstant %u32 3 %hasdim = OpConstantFalse %bool %p0 = OpConstant %u32 0 %p1 = OpConstant %u32 1 %p2 = OpConstant %u32 2 %view = OpTypeTensorViewNV %dim %hasdim %p0 %p1 %p2 %b = OpConstant %u32 1 )", R"( %tv = OpCreateTensorViewNV %view %tv2 = OpTensorViewSetClipNV %view %tv %b %b %b %b )"); CompileSuccessfully(spirv.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateMemory, CoopMat2LoadStoreTensorPass) { std::string spirv = GenCoopMat2Shader( R"( %clamp = OpConstant %u32 0 %dim = OpConstant %u32 2 %p0 = OpConstant %u32 0 %p1 = OpConstant %u32 1 %hasdim = OpConstantFalse %bool %layout = OpTypeTensorLayoutNV %dim %clamp %view = OpTypeTensorViewNV %dim %hasdim %p0 %p1 )", R"( %mat = OpUndef %f16mat %tl = OpCreateTensorLayoutNV %layout %tv = OpCreateTensorViewNV %view %mat2 = OpCooperativeMatrixLoadTensorNV %f16mat %array_ptr %mat %tl None None %mat3 = OpCooperativeMatrixLoadTensorNV %f16mat %array_ptr %mat %tl Aligned 4 None %mat4 = OpCooperativeMatrixLoadTensorNV %f16mat %array_ptr %mat %tl None TensorView %tv %mat5 = OpCooperativeMatrixLoadTensorNV %f16mat %array_ptr %mat %tl None DecodeFunc %decodefunc %mat6 = OpCooperativeMatrixLoadTensorNV %f16mat %array_ptr %mat %tl None TensorView|DecodeFunc %tv %decodefunc %mat7 = OpCooperativeMatrixLoadTensorNV %f16mat %array_ptr %mat %tl Aligned 4 TensorView|DecodeFunc %tv %decodefunc OpCooperativeMatrixStoreTensorNV %array_ptr %mat %tl None None OpCooperativeMatrixStoreTensorNV %array_ptr %mat %tl Aligned 4 None OpCooperativeMatrixStoreTensorNV %array_ptr %mat %tl None TensorView %tv OpCooperativeMatrixStoreTensorNV %array_ptr %mat %tl Aligned 4 TensorView %tv )"); CompileSuccessfully(spirv.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateMemory, CoopMat2LoadTensorWrongLayoutTypeFail) { std::string spirv = GenCoopMat2Shader( R"( %clamp = OpConstant %u32 0 %dim = OpConstant %u32 2 %p0 = OpConstant %u32 0 %p1 = OpConstant %u32 1 %hasdim = OpConstantFalse %bool %layout = OpTypeTensorLayoutNV %dim %clamp %view = OpTypeTensorViewNV %dim %hasdim %p0 %p1 )", R"( %mat = OpUndef %f16mat %tl = OpCreateTensorLayoutNV %layout %tv = OpCreateTensorViewNV %view %mat2 = OpCooperativeMatrixLoadTensorNV %f16mat %array_ptr %mat %tv None None )"); CompileSuccessfully(spirv.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("does not have a tensor layout type")); } TEST_F(ValidateMemory, CoopMat2LoadTensorWrongObjectTypeFail) { std::string spirv = GenCoopMat2Shader( R"( %clamp = OpConstant %u32 0 %dim = OpConstant %u32 2 %p0 = OpConstant %u32 0 %p1 = OpConstant %u32 1 %hasdim = OpConstantFalse %bool %layout = OpTypeTensorLayoutNV %dim %clamp %view = OpTypeTensorViewNV %dim %hasdim %p0 %p1 )", R"( %mat = OpUndef %f32mat %tl = OpCreateTensorLayoutNV %layout %tv = OpCreateTensorViewNV %view %mat2 = OpCooperativeMatrixLoadTensorNV %f16mat %array_ptr %mat %tl None None )"); CompileSuccessfully(spirv.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("type does not match Result Type")); } TEST_F(ValidateMemory, CoopMat2LoadTensorDecodeFuncTypeFail) { std::string spirv = GenCoopMat2Shader( R"( %clamp = OpConstant %u32 0 %dim = OpConstant %u32 2 %p0 = OpConstant %u32 0 %p1 = OpConstant %u32 1 %hasdim = OpConstantFalse %bool %layout = OpTypeTensorLayoutNV %dim %clamp %view = OpTypeTensorViewNV %dim %hasdim %p0 %p1 )", R"( %mat = OpUndef %f32mat %tl = OpCreateTensorLayoutNV %layout %tv = OpCreateTensorViewNV %view %mat2 = OpCooperativeMatrixLoadTensorNV %f32mat %array_ptr %mat %tl None DecodeFunc %decodefunc )"); CompileSuccessfully(spirv.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("return type must match matrix component type")); } TEST_F(ValidateMemory, CoopMat2LoadTensorDecodeFuncArrayTypeFail) { std::string spirv = GenCoopMat2Shader( R"( %clamp = OpConstant %u32 0 %dim = OpConstant %u32 2 %u32_3 = OpConstant %u32 3 %p0 = OpConstant %u32 0 %p1 = OpConstant %u32 1 %hasdim = OpConstantFalse %bool %layout = OpTypeTensorLayoutNV %dim %clamp %view = OpTypeTensorViewNV %dim %hasdim %p0 %p1 %arr3 = OpTypeArray %u32 %u32_3 %functy2 = OpTypeFunction %f16 %psbptr %arr3 %arr3 )", R"( %mat = OpUndef %f16mat %tl = OpCreateTensorLayoutNV %layout %tv = OpCreateTensorViewNV %view %mat2 = OpCooperativeMatrixLoadTensorNV %f16mat %array_ptr %mat %tl None DecodeFunc %decodefunc2 )", R"( %decodefunc2 = OpFunction %f16 None %functy2 %psb2 = OpFunctionParameter %psbptr %c02 = OpFunctionParameter %arr3 %c12 = OpFunctionParameter %arr3 %entry3 = OpLabel OpReturnValue %f16_0 OpFunctionEnd )", R"( OpDecorate %psb2 Restrict )"); CompileSuccessfully(spirv.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("dimension equal to the tensor dimension")); } TEST_F(ValidateMemory, CoopMat2LoadTensorDecodeFuncPointerTypeFail) { std::string spirv = GenCoopMat2Shader( R"( %clamp = OpConstant %u32 0 %dim = OpConstant %u32 2 %p0 = OpConstant %u32 0 %p1 = OpConstant %u32 1 %hasdim = OpConstantFalse %bool %layout = OpTypeTensorLayoutNV %dim %clamp %view = OpTypeTensorViewNV %dim %hasdim %p0 %p1 %sbptr = OpTypePointer StorageBuffer %f16_arr %functy2 = OpTypeFunction %f16 %sbptr %arr2 %arr2 )", R"( %mat = OpUndef %f16mat %tl = OpCreateTensorLayoutNV %layout %tv = OpCreateTensorViewNV %view %mat2 = OpCooperativeMatrixLoadTensorNV %f16mat %array_ptr %mat %tl None DecodeFunc %decodefunc2 )", R"( %decodefunc2 = OpFunction %f16 None %functy2 %sb = OpFunctionParameter %sbptr %c02 = OpFunctionParameter %arr2 %c12 = OpFunctionParameter %arr2 %entry3 = OpLabel OpReturnValue %f16_0 OpFunctionEnd )"); CompileSuccessfully(spirv.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("first parameter must be pointer to PhysicalStorageBuffer")); } TEST_F(ValidateMemory, PtrAccessChainNodePayloadArray) { const std::string spirv = R"( OpCapability Shader OpCapability ShaderEnqueueAMDX OpExtension "SPV_AMDX_shader_enqueue" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %input %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %node0 = OpConstantStringAMDX "node0" %node1 = OpConstantStringAMDX "node1" %node2 = OpConstantStringAMDX "node2" %S = OpTypeStruct %uint %_payloadarr_S = OpTypeNodePayloadArrayAMDX %S %_ptr_NodePayloadAMDX__payloadarr_S = OpTypePointer NodePayloadAMDX %_payloadarr_S %_ptr_NodePayloadAMDX_uint = OpTypePointer NodePayloadAMDX %uint %void = OpTypeVoid %void_fn = OpTypeFunction %void %input = OpVariable %_ptr_NodePayloadAMDX__payloadarr_S NodePayloadAMDX %main = OpFunction %void None %void_fn %entry = OpLabel %x = OpAccessChain %_ptr_NodePayloadAMDX_uint %input %uint_0 %uint_0 OpReturn OpFunctionEnd )"; spv_target_env env = SPV_ENV_UNIVERSAL_1_4; CompileSuccessfully(spirv, env); EXPECT_THAT(SPV_SUCCESS, ValidateInstructions(env)); } std::string GenCoopVecLoadStoreShader(const std::string& storeMemoryAccess, const std::string& loadMemoryAccess) { std::string s = R"( OpCapability Shader OpCapability Float16 OpCapability StorageBuffer16BitAccess OpCapability VulkanMemoryModel OpCapability CooperativeVectorNV OpCapability ReplicatedCompositesEXT OpExtension "SPV_EXT_replicated_composites" OpExtension "SPV_KHR_vulkan_memory_model" OpExtension "SPV_NV_cooperative_vector" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical Vulkan OpEntryPoint GLCompute %4 "main" %48 %73 OpExecutionMode %4 LocalSize 1 1 1 OpDecorate %45 ArrayStride 2 OpDecorate %46 Block OpMemberDecorate %46 0 Offset 0 OpDecorate %48 Binding 0 OpDecorate %48 DescriptorSet 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %49 = OpTypeInt 32 1 %41 = OpTypeFloat 16 %14 = OpConstant %6 1 %50 = OpConstant %49 0 %82 = OpConstant %6 5 %42 = OpTypeCooperativeVectorNV %41 %14 %43 = OpTypePointer Function %42 %45 = OpTypeRuntimeArray %41 %46 = OpTypeStruct %45 %47 = OpTypePointer StorageBuffer %46 %48 = OpVariable %47 StorageBuffer %51 = OpTypePointer StorageBuffer %45 %57 = OpTypePointer Private %42 %73 = OpVariable %57 Private %4 = OpFunction %2 None %3 %5 = OpLabel %52 = OpAccessChain %51 %48 %50 %56 = OpCooperativeVectorLoadNV %42 %52 %50 )" + loadMemoryAccess + R"( %82 %77 = OpLoad %42 %73 OpCooperativeVectorStoreNV %52 %50 %77 )" + storeMemoryAccess + R"( %82 OpReturn OpFunctionEnd )"; return s; } TEST_F(ValidateMemory, CoopVecLoadStoreSuccess) { std::string spirv = GenCoopVecLoadStoreShader("MakePointerAvailableKHR|NonPrivatePointerKHR", "MakePointerVisibleKHR|NonPrivatePointerKHR"); CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1_SPIRV_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_1_SPIRV_1_4)); } TEST_F(ValidateMemory, CoopVecStoreMemoryAccessFail) { std::string spirv = GenCoopVecLoadStoreShader("MakePointerVisibleKHR|NonPrivatePointerKHR", "MakePointerVisibleKHR|NonPrivatePointerKHR"); CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1_SPIRV_1_4); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1_SPIRV_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("MakePointerVisibleKHR cannot be used with OpStore")); } TEST_F(ValidateMemory, CoopVecLoadMemoryAccessFail) { std::string spirv = GenCoopVecLoadStoreShader("MakePointerAvailableKHR|NonPrivatePointerKHR", "MakePointerAvailableKHR|NonPrivatePointerKHR"); CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1_SPIRV_1_4); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1_SPIRV_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("MakePointerAvailableKHR cannot be used with OpLoad")); } TEST_F(ValidateMemory, CoopVecInvalidStorageClassFail) { const std::string body = R"( OpCapability Shader OpCapability Float16 OpCapability CooperativeVectorNV OpCapability ReplicatedCompositesEXT OpExtension "SPV_NV_cooperative_vector" OpExtension "SPV_EXT_replicated_composites" OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %f16 = OpTypeFloat 16 %u32 = OpTypeInt 32 0 %u32_8 = OpConstant %u32 8 %use_A = OpConstant %u32 0 %subgroup = OpConstant %u32 3 %f16vec = OpTypeCooperativeVectorNV %f16 %u32_8 %str = OpTypeStruct %f16vec %str_ptr = OpTypePointer Workgroup %str %sh = OpVariable %str_ptr Workgroup %main = OpFunction %void None %func %main_entry = OpLabel OpReturn OpFunctionEnd)"; CompileSuccessfully(body.c_str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Cooperative vector types (or types containing them) can only be " "allocated in Function or Private storage classes or as function " "parameters")); } std::string GenCoopVecShader(const std::string& extra_types, const std::string& main_body) { const std::string prefix = R"( OpCapability Shader OpCapability Float16 OpCapability Int64 OpCapability StorageBuffer16BitAccess OpCapability VulkanMemoryModel OpCapability CooperativeVectorNV OpCapability CooperativeVectorTrainingNV OpCapability ReplicatedCompositesEXT OpExtension "SPV_EXT_replicated_composites" OpExtension "SPV_KHR_vulkan_memory_model" OpExtension "SPV_NV_cooperative_vector" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical Vulkan OpEntryPoint GLCompute %main "main" %48 %73 OpExecutionMode %main LocalSize 1 1 1 OpDecorate %f16_arr ArrayStride 2 OpDecorate %46 Block OpMemberDecorate %46 0 Offset 0 OpDecorate %48 Binding 0 OpDecorate %48 DescriptorSet 0 %void = OpTypeVoid %func = OpTypeFunction %void %u32 = OpTypeInt 32 0 %s32 = OpTypeInt 32 1 %f16 = OpTypeFloat 16 %bool = OpTypeBool %false = OpConstantFalse %bool %u32_4 = OpConstant %u32 4 %u32_8 = OpConstant %u32 8 %s32_0 = OpConstant %s32 0 %f16_0 = OpConstant %f16 0 %f16vec4 = OpTypeCooperativeVectorNV %f16 %u32_4 %f16vec8 = OpTypeCooperativeVectorNV %f16 %u32_8 %f16_arr = OpTypeRuntimeArray %f16 %46 = OpTypeStruct %f16_arr %47 = OpTypePointer StorageBuffer %46 %48 = OpVariable %47 StorageBuffer %51 = OpTypePointer StorageBuffer %f16_arr %57 = OpTypePointer Private %f16vec4 %73 = OpVariable %57 Private %u32ptr = OpTypePointer Function %u32 %input4 = OpConstantCompositeReplicateEXT %f16vec4 %f16_0 %input8 = OpConstantCompositeReplicateEXT %f16vec8 %f16_0 %interp = OpConstant %u32 0 %offset = OpConstant %u32 0 )"; const std::string func_begin = R"( %main = OpFunction %void None %func %main_entry = OpLabel %u32var = OpVariable %u32ptr Function %array_ptr = OpAccessChain %51 %48 %s32_0 )"; const std::string suffix = R"( OpReturn OpFunctionEnd)"; return prefix + extra_types + func_begin + main_body + suffix; } TEST_F(ValidateMemory, CoopVecMatMulSuccess) { std::string spirv = GenCoopVecShader("", R"( %result0 = OpCooperativeVectorMatrixMulAddNV %f16vec4 %input4 %interp %array_ptr %offset %interp %array_ptr %offset %interp %u32_4 %u32_4 %s32_0 %false %result1 = OpCooperativeVectorMatrixMulAddNV %f16vec4 %input8 %interp %array_ptr %offset %interp %array_ptr %offset %interp %u32_4 %u32_8 %s32_0 %false %result2 = OpCooperativeVectorMatrixMulAddNV %f16vec8 %input4 %interp %array_ptr %offset %interp %array_ptr %offset %interp %u32_8 %u32_4 %s32_0 %false %result3 = OpCooperativeVectorMatrixMulNV %f16vec4 %input4 %interp %array_ptr %offset %interp %u32_4 %u32_4 %s32_0 %false %result4 = OpCooperativeVectorMatrixMulNV %f16vec4 %input8 %interp %array_ptr %offset %interp %u32_4 %u32_8 %s32_0 %false %result5 = OpCooperativeVectorMatrixMulNV %f16vec8 %input4 %interp %array_ptr %offset %interp %u32_8 %u32_4 %s32_0 %false OpCooperativeVectorReduceSumAccumulateNV %array_ptr %offset %input4 OpCooperativeVectorOuterProductAccumulateNV %array_ptr %offset %input4 %input8 %interp %interp )"); CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1_SPIRV_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_1_SPIRV_1_4)); } TEST_F(ValidateMemory, CoopVecMatMulKMismatchFail) { std::string spirv = GenCoopVecShader(R"()", R"( %result1 = OpCooperativeVectorMatrixMulAddNV %f16vec4 %input8 %interp %array_ptr %offset %interp %array_ptr %offset %interp %u32_4 %u32_4 %s32_0 %false )"); CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1_SPIRV_1_4); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1_SPIRV_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpCooperativeVectorMatrixMulAddNV input number of " "components 8 does not match K 4")); } TEST_F(ValidateMemory, CoopVecMatMulPackedKMismatchPass) { std::string spirv = GenCoopVecShader( R"( %packed = OpConstant %u32 1000491001 )", R"( %result1 = OpCooperativeVectorMatrixMulAddNV %f16vec4 %input8 %packed %array_ptr %offset %interp %array_ptr %offset %interp %u32_4 %u32_4 %s32_0 %false )"); CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1_SPIRV_1_4); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_1_SPIRV_1_4)); } TEST_F(ValidateMemory, CoopVecMatMulMMismatchFail) { std::string spirv = GenCoopVecShader(R"()", R"( %result1 = OpCooperativeVectorMatrixMulAddNV %f16vec8 %input8 %interp %array_ptr %offset %interp %array_ptr %offset %interp %u32_4 %u32_8 %s32_0 %false )"); CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1_SPIRV_1_4); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1_SPIRV_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpCooperativeVectorMatrixMulAddNV result type number " "of components 8 does not match M 4")); } TEST_F(ValidateMemory, CoopVecMatMulTransposeTypeFail) { std::string spirv = GenCoopVecShader(R"()", R"( %result0 = OpCooperativeVectorMatrixMulAddNV %f16vec4 %input4 %interp %array_ptr %offset %interp %array_ptr %offset %interp %u32_4 %u32_4 %s32_0 %s32_0 )"); CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1_SPIRV_1_4); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1_SPIRV_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpCooperativeVectorMatrixMulAddNV Transpose " "'16[%int_0]' is not a scalar boolean")); } TEST_F(ValidateMemory, CoopVecMatMulInputInterpretationNotConstantFail) { std::string spirv = GenCoopVecShader( R"( )", R"( %u32val = OpLoad %u32 %u32var %result0 = OpCooperativeVectorMatrixMulAddNV %f16vec4 %input4 %u32val %array_ptr %offset %interp %array_ptr %offset %interp %u32_4 %u32_4 %s32_0 %false )"); CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1_SPIRV_1_4); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1_SPIRV_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpCooperativeVectorMatrixMulAddNV InputInterpretation " " '31[%31]' is not a constant instruction")); } TEST_F(ValidateMemory, CoopVecMatMulMatrixInterpretationNotConstantFail) { std::string spirv = GenCoopVecShader( R"( )", R"( %u32val = OpLoad %u32 %u32var %result0 = OpCooperativeVectorMatrixMulAddNV %f16vec4 %input4 %interp %array_ptr %offset %u32val %array_ptr %offset %interp %u32_4 %u32_4 %s32_0 %false )"); CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1_SPIRV_1_4); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1_SPIRV_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpCooperativeVectorMatrixMulAddNV MatrixInterpretation " "'31[%31]' is not a constant instruction")); } TEST_F(ValidateMemory, CoopVecMatMulBiasInterpretationNotConstantFail) { std::string spirv = GenCoopVecShader( R"( )", R"( %u32val = OpLoad %u32 %u32var %result0 = OpCooperativeVectorMatrixMulAddNV %f16vec4 %input4 %interp %array_ptr %offset %interp %array_ptr %offset %u32val %u32_4 %u32_4 %s32_0 %false )"); CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1_SPIRV_1_4); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1_SPIRV_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpCooperativeVectorMatrixMulAddNV BiasInterpretation " " '31[%31]' is not a constant instruction")); } TEST_F(ValidateMemory, CoopVecMatMulInputInterpretationNotInt32Fail) { std::string spirv = GenCoopVecShader( R"( )", R"( %result0 = OpCooperativeVectorMatrixMulAddNV %f16vec4 %input4 %false %array_ptr %offset %interp %array_ptr %offset %interp %u32_4 %u32_4 %s32_0 %false )"); CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1_SPIRV_1_4); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1_SPIRV_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpCooperativeVectorMatrixMulAddNV InputInterpretation " "type '12[%bool]' is not a 32 bit integer")); } TEST_F(ValidateMemory, CoopVecOuterProductABMismatchFail) { std::string spirv = GenCoopVecShader( R"( %f32 = OpTypeFloat 32 %f32vec8 = OpTypeCooperativeVectorNV %f32 %u32_8 %f32_0 = OpConstant %f32 0 %input8f32 = OpConstantCompositeReplicateEXT %f32vec8 %f32_0 )", R"( OpCooperativeVectorOuterProductAccumulateNV %array_ptr %offset %input4 %input8f32 %interp %interp )"); CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1_SPIRV_1_4); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1_SPIRV_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpCooperativeVectorOuterProductAccumulateNV A and B component " "types '11[%half]' and '28[%float]' do not match")); } TEST_F(ValidateMemory, CoopVecOuterProductInt32OffsetFail) { std::string spirv = GenCoopVecShader( R"( %u64 = OpTypeInt 64 0 %u64_0 = OpConstant %u64 0 )", R"( OpCooperativeVectorOuterProductAccumulateNV %array_ptr %u64_0 %input4 %input8 %interp %interp )"); CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1_SPIRV_1_4); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1_SPIRV_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpCooperativeVectorOuterProductAccumulateNV Offset " "type '28[%ulong]' is not a 32 bit integer")); } TEST_F(ValidateMemory, CoopVecOuterProductInt32MatrixStrideFail) { std::string spirv = GenCoopVecShader( R"( %u64 = OpTypeInt 64 0 %u64_0 = OpConstant %u64 0 )", R"( OpCooperativeVectorOuterProductAccumulateNV %array_ptr %offset %input4 %input8 %interp %interp %u64_0 )"); CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1_SPIRV_1_4); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1_SPIRV_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpCooperativeVectorOuterProductAccumulateNV MatrixStride type " " '28[%ulong]' is not a 32 bit integer")); } TEST_F(ValidateMemory, CoopVecOuterProductVectorTypeFail) { std::string spirv = GenCoopVecShader( R"( %f16v4 = OpTypeVector %f16 4 %f16c = OpConstantCompositeReplicateEXT %f16v4 %f16_0 )", R"( OpCooperativeVectorOuterProductAccumulateNV %array_ptr %offset %f16c %input8 %interp %interp )"); CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1_SPIRV_1_4); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1_SPIRV_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpCooperativeVectorOuterProductAccumulateNV A type " " '28[%v4half]' is not a cooperative vector type")); } TEST_F(ValidateMemory, CoopVecReduceSumInt32OffsetFail) { std::string spirv = GenCoopVecShader( R"( %u64 = OpTypeInt 64 0 %u64_0 = OpConstant %u64 0 )", R"( OpCooperativeVectorReduceSumAccumulateNV %array_ptr %u64_0 %input4 )"); CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1_SPIRV_1_4); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1_SPIRV_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpCooperativeVectorReduceSumAccumulateNV Offset type " " '28[%ulong]' is not a 32 bit integer")); } TEST_F(ValidateMemory, CoopVecReduceSumVectorTypeFail) { std::string spirv = GenCoopVecShader( R"( %f16v4 = OpTypeVector %f16 4 %f16c = OpConstantCompositeReplicateEXT %f16v4 %f16_0 )", R"( OpCooperativeVectorReduceSumAccumulateNV %array_ptr %offset %f16c )"); CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_1_SPIRV_1_4); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_1_SPIRV_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpCooperativeVectorReduceSumAccumulateNV V type " "'28[%v4half]' is not a cooperative vector type.")); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_mesh_shading_test.cpp000066400000000000000000001133131475742701700253320ustar00rootroot00000000000000// Copyright (c) 2022 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Tests instructions from SPV_EXT_mesh_shader #include #include "gmock/gmock.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::HasSubstr; using ::testing::Values; using ValidateMeshShading = spvtest::ValidateBase; TEST_F(ValidateMeshShading, EmitMeshTasksEXTNotLastInstructionUniversal) { const std::string body = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint TaskEXT %main "main" %p OpExecutionModeId %main LocalSizeId %uint_1 %uint_1 %uint_1 %void = OpTypeVoid %func = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %float = OpTypeFloat 32 %arr_float = OpTypeArray %float %uint_1 %Payload = OpTypeStruct %arr_float %ptr_Payload = OpTypePointer TaskPayloadWorkgroupEXT %Payload %p = OpVariable %ptr_Payload TaskPayloadWorkgroupEXT %main = OpFunction %void None %func %label1 = OpLabel OpEmitMeshTasksEXT %uint_1 %uint_1 %uint_1 %p OpBranch %label2 %label2 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(body, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Branch must appear in a block")); } TEST_F(ValidateMeshShading, EmitMeshTasksEXTNotLastInstructionVulkan) { const std::string body = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint TaskEXT %main "main" %p OpExecutionModeId %main LocalSizeId %uint_1 %uint_1 %uint_1 %void = OpTypeVoid %func = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %float = OpTypeFloat 32 %arr_float = OpTypeArray %float %uint_1 %Payload = OpTypeStruct %arr_float %ptr_Payload = OpTypePointer TaskPayloadWorkgroupEXT %Payload %p = OpVariable %ptr_Payload TaskPayloadWorkgroupEXT %main = OpFunction %void None %func %label1 = OpLabel OpEmitMeshTasksEXT %uint_1 %uint_1 %uint_1 %p OpReturn OpFunctionEnd )"; CompileSuccessfully(body, SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Return must appear in a block")); } TEST_F(ValidateMeshShading, BasicTaskSuccess) { const std::string body = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint TaskEXT %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %main = OpFunction %void None %func %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(body, SPV_ENV_UNIVERSAL_1_5); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); } TEST_F(ValidateMeshShading, BasicMeshSuccess) { const std::string body = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %main "main" OpExecutionMode %main OutputVertices 1 OpExecutionMode %main OutputPrimitivesEXT 1 OpExecutionMode %main OutputTrianglesEXT %void = OpTypeVoid %func = OpTypeFunction %void %main = OpFunction %void None %func %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(body, SPV_ENV_UNIVERSAL_1_5); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); } TEST_F(ValidateMeshShading, VulkanBasicMeshAndTaskSuccess) { const std::string body = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" OpExtension "SPV_NV_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %mainMesh "mainMesh" OpEntryPoint TaskEXT %mainTask "mainTask" OpExecutionMode %mainMesh OutputVertices 1 OpExecutionMode %mainMesh OutputPrimitivesEXT 1 OpExecutionMode %mainMesh OutputTrianglesEXT %void = OpTypeVoid %func = OpTypeFunction %void %mainMesh = OpFunction %void None %func %labelMesh = OpLabel OpReturn OpFunctionEnd %mainTask = OpFunction %void None %func %labelTask = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(body, SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateMeshShading, VulkanBasicMeshAndTaskBad) { const std::string body = R"( OpCapability MeshShadingEXT OpCapability MeshShadingNV OpExtension "SPV_EXT_mesh_shader" OpExtension "SPV_NV_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %mainMesh "mainMesh" OpEntryPoint TaskNV %mainTask "mainTask" OpExecutionMode %mainMesh OutputVertices 1 OpExecutionMode %mainMesh OutputPrimitivesEXT 1 OpExecutionMode %mainMesh OutputTrianglesEXT %void = OpTypeVoid %func = OpTypeFunction %void %mainMesh = OpFunction %void None %func %labelMesh = OpLabel OpReturn OpFunctionEnd %mainTask = OpFunction %void None %func %labelTask = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(body, SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-MeshEXT-07102")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Module can't mix MeshEXT/TaskEXT with MeshNV/TaskNV " "Execution Model.")); } TEST_F(ValidateMeshShading, MeshMissingOutputVertices) { const std::string body = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %main "main" OpExecutionMode %main OutputPrimitivesEXT 1 OpExecutionMode %main OutputTrianglesEXT %void = OpTypeVoid %func = OpTypeFunction %void %main = OpFunction %void None %func %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(body, SPV_ENV_UNIVERSAL_1_5); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); EXPECT_THAT( getDiagnosticString(), HasSubstr("MeshEXT execution model entry points must specify both " "OutputPrimitivesEXT and OutputVertices Execution Modes.")); } TEST_F(ValidateMeshShading, MeshMissingOutputPrimitivesEXT) { const std::string body = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %main "main" OpExecutionMode %main OutputVertices 1 OpExecutionMode %main OutputTrianglesEXT %void = OpTypeVoid %func = OpTypeFunction %void %main = OpFunction %void None %func %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(body, SPV_ENV_UNIVERSAL_1_5); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); EXPECT_THAT( getDiagnosticString(), HasSubstr("MeshEXT execution model entry points must specify both " "OutputPrimitivesEXT and OutputVertices Execution Modes.")); } TEST_F(ValidateMeshShading, MeshMissingOutputType) { const std::string body = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %main "main" OpExecutionMode %main OutputVertices 1 OpExecutionMode %main OutputPrimitivesEXT 1 %void = OpTypeVoid %func = OpTypeFunction %void %main = OpFunction %void None %func %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(body, SPV_ENV_UNIVERSAL_1_5); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); EXPECT_THAT(getDiagnosticString(), HasSubstr("MeshEXT execution model entry points must specify " "exactly one of OutputPoints, OutputLinesEXT, or " "OutputTrianglesEXT Execution Modes.")); } TEST_F(ValidateMeshShading, MeshMultipleOutputType) { const std::string body = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %main "main" OpExecutionMode %main OutputVertices 1 OpExecutionMode %main OutputPrimitivesEXT 1 OpExecutionMode %main OutputLinesEXT OpExecutionMode %main OutputTrianglesEXT %void = OpTypeVoid %func = OpTypeFunction %void %main = OpFunction %void None %func %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(body, SPV_ENV_UNIVERSAL_1_5); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); EXPECT_THAT(getDiagnosticString(), HasSubstr("MeshEXT execution model entry points must specify " "exactly one of OutputPoints, OutputLinesEXT, or " "OutputTrianglesEXT Execution Modes.")); } TEST_F(ValidateMeshShading, BadExecutionModelOutputLinesEXT) { const std::string body = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main OutputLinesEXT %void = OpTypeVoid %func = OpTypeFunction %void %main = OpFunction %void None %func %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(body, SPV_ENV_UNIVERSAL_1_5); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Execution mode can only be used with the MeshEXT or " "MeshNV execution model.")); } TEST_F(ValidateMeshShading, BadExecutionModelOutputTrianglesEXT) { const std::string body = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main OutputTrianglesEXT %void = OpTypeVoid %func = OpTypeFunction %void %main = OpFunction %void None %func %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(body, SPV_ENV_UNIVERSAL_1_5); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Execution mode can only be used with the MeshEXT or " "MeshNV execution model.")); } TEST_F(ValidateMeshShading, BadExecutionModelOutputPrimitivesEXT) { const std::string body = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main OutputPrimitivesEXT 1 %void = OpTypeVoid %func = OpTypeFunction %void %main = OpFunction %void None %func %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(body, SPV_ENV_UNIVERSAL_1_5); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Execution mode can only be used with the MeshEXT or " "MeshNV execution model.")); } TEST_F(ValidateMeshShading, OpEmitMeshTasksBadGroupCountSignedInt) { const std::string body = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint TaskEXT %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %int_1 = OpConstant %int 1 %uint_1 = OpConstant %uint 1 %main = OpFunction %void None %func %label = OpLabel OpEmitMeshTasksEXT %int_1 %uint_1 %uint_1 OpFunctionEnd )"; CompileSuccessfully(body, SPV_ENV_UNIVERSAL_1_5); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Group Count X must be a 32-bit unsigned int scalar")); } TEST_F(ValidateMeshShading, OpEmitMeshTasksBadGroupCountVector) { const std::string body = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint TaskEXT %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_v2uint = OpTypePointer Function %v2uint %uint_1 = OpConstant %uint 1 %composite = OpConstantComposite %v2uint %uint_1 %uint_1 %_ptr_uint = OpTypePointer Function %uint %main = OpFunction %void None %func %label = OpLabel %x = OpVariable %_ptr_v2uint Function OpStore %x %composite %13 = OpAccessChain %_ptr_uint %x %uint_1 %14 = OpLoad %uint %13 OpEmitMeshTasksEXT %14 %composite %uint_1 OpFunctionEnd )"; CompileSuccessfully(body, SPV_ENV_UNIVERSAL_1_5); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Group Count Y must be a 32-bit unsigned int scalar")); } TEST_F(ValidateMeshShading, OpEmitMeshTasksBadPayload) { const std::string body = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint TaskEXT %main "main" %payload %void = OpTypeVoid %func = OpTypeFunction %void %uint = OpTypeInt 32 0 %task = OpTypeStruct %uint %_ptr_Uniform = OpTypePointer Uniform %task %payload = OpVariable %_ptr_Uniform Uniform %uint_1 = OpConstant %uint 1 %main = OpFunction %void None %func %label = OpLabel OpEmitMeshTasksEXT %uint_1 %uint_1 %uint_1 %payload OpFunctionEnd )"; CompileSuccessfully(body, SPV_ENV_UNIVERSAL_1_5); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Payload OpVariable must have a storage class of " "TaskPayloadWorkgroupEXT")); } TEST_F(ValidateMeshShading, TaskPayloadWorkgroupBadExecutionModel) { const std::string body = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %payload %void = OpTypeVoid %func = OpTypeFunction %void %uint = OpTypeInt 32 0 %_ptr_TaskPayloadWorkgroupEXT = OpTypePointer TaskPayloadWorkgroupEXT %uint %payload = OpVariable %_ptr_TaskPayloadWorkgroupEXT TaskPayloadWorkgroupEXT %main = OpFunction %void None %func %label = OpLabel %load = OpLoad %uint %payload OpReturn OpFunctionEnd )"; CompileSuccessfully(body, SPV_ENV_UNIVERSAL_1_5); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); EXPECT_THAT(getDiagnosticString(), HasSubstr("TaskPayloadWorkgroupEXT Storage Class is limited to " "TaskEXT and MeshKHR execution model")); } TEST_F(ValidateMeshShading, BadMultipleTaskPayloadWorkgroupEXT) { const std::string body = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint TaskEXT %main "main" %payload %payload1 %void = OpTypeVoid %func = OpTypeFunction %void %uint = OpTypeInt 32 0 %_ptr_TaskPayloadWorkgroupEXT = OpTypePointer TaskPayloadWorkgroupEXT %uint %payload = OpVariable %_ptr_TaskPayloadWorkgroupEXT TaskPayloadWorkgroupEXT %payload1 = OpVariable %_ptr_TaskPayloadWorkgroupEXT TaskPayloadWorkgroupEXT %main = OpFunction %void None %func %label = OpLabel %load = OpLoad %uint %payload OpReturn OpFunctionEnd )"; CompileSuccessfully(body, SPV_ENV_UNIVERSAL_1_5); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); EXPECT_THAT(getDiagnosticString(), HasSubstr("There can be at most one OpVariable with storage " "class TaskPayloadWorkgroupEXT associated with " "an OpEntryPoint")); } TEST_F(ValidateMeshShading, TaskPayloadWorkgroupTaskExtExecutionModel) { const std::string body = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint TaskEXT %main "main" %payload %void = OpTypeVoid %func = OpTypeFunction %void %uint = OpTypeInt 32 0 %_ptr_TaskPayloadWorkgroupEXT = OpTypePointer TaskPayloadWorkgroupEXT %uint %payload = OpVariable %_ptr_TaskPayloadWorkgroupEXT TaskPayloadWorkgroupEXT %main = OpFunction %void None %func %label = OpLabel %load = OpLoad %uint %payload OpReturn OpFunctionEnd )"; CompileSuccessfully(body, SPV_ENV_UNIVERSAL_1_5); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); } TEST_F(ValidateMeshShading, TaskPayloadWorkgroupMeshExtExecutionModel) { const std::string body = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %main "main" %payload OpExecutionMode %main OutputVertices 1 OpExecutionMode %main OutputPrimitivesEXT 1 OpExecutionMode %main OutputTrianglesEXT %void = OpTypeVoid %func = OpTypeFunction %void %uint = OpTypeInt 32 0 %_ptr_TaskPayloadWorkgroupEXT = OpTypePointer TaskPayloadWorkgroupEXT %uint %payload = OpVariable %_ptr_TaskPayloadWorkgroupEXT TaskPayloadWorkgroupEXT %main = OpFunction %void None %func %label = OpLabel %load = OpLoad %uint %payload OpReturn OpFunctionEnd )"; CompileSuccessfully(body, SPV_ENV_UNIVERSAL_1_5); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); } TEST_F(ValidateMeshShading, OpSetMeshOutputsBadVertexCount) { const std::string body = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %main "main" OpExecutionMode %main OutputVertices 1 OpExecutionMode %main OutputPrimitivesNV 1 OpExecutionMode %main OutputTrianglesNV %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %_ptr_int = OpTypePointer Function %int %int_1 = OpConstant %int 1 %uint_1 = OpConstant %uint 1 %main = OpFunction %void None %3 %5 = OpLabel %x = OpVariable %_ptr_int Function OpStore %x %int_1 %load = OpLoad %int %x OpSetMeshOutputsEXT %load %uint_1 OpReturn OpFunctionEnd )"; CompileSuccessfully(body, SPV_ENV_UNIVERSAL_1_5); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Vertex Count must be a 32-bit unsigned int scalar")); } TEST_F(ValidateMeshShading, OpSetMeshOutputsBadPrimitiveCount) { const std::string body = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %main "main" OpExecutionMode %main OutputVertices 1 OpExecutionMode %main OutputPrimitivesNV 1 OpExecutionMode %main OutputTrianglesNV %void = OpTypeVoid %3 = OpTypeFunction %void %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %int_1 = OpConstant %int 1 %uint_1 = OpConstant %uint 1 %main = OpFunction %void None %3 %5 = OpLabel OpSetMeshOutputsEXT %uint_1 %int_1 OpReturn OpFunctionEnd )"; CompileSuccessfully(body, SPV_ENV_UNIVERSAL_1_5); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Primitive Count must be a 32-bit unsigned int scalar")); } TEST_F(ValidateMeshShading, OpSetMeshOutputsBadExecutionModel) { const std::string body = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint TaskEXT %main "main" %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %main = OpFunction %void None %3 %5 = OpLabel OpSetMeshOutputsEXT %uint_1 %uint_1 OpReturn OpFunctionEnd )"; CompileSuccessfully(body, SPV_ENV_UNIVERSAL_1_5); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpSetMeshOutputsEXT requires MeshEXT execution model")); } TEST_F(ValidateMeshShading, OpSetMeshOutputsZeroSuccess) { const std::string body = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %main "main" OpExecutionMode %main OutputVertices 1 OpExecutionMode %main OutputPrimitivesNV 1 OpExecutionMode %main OutputTrianglesNV %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %main = OpFunction %void None %3 %5 = OpLabel OpSetMeshOutputsEXT %uint_0 %uint_0 OpReturn OpFunctionEnd )"; CompileSuccessfully(body, SPV_ENV_UNIVERSAL_1_5); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); } TEST_F(ValidateMeshShading, OpEmitMeshTasksZeroSuccess) { const std::string body = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint TaskEXT %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 1 %main = OpFunction %void None %func %label = OpLabel OpEmitMeshTasksEXT %uint_0 %uint_0 %uint_0 OpFunctionEnd )"; CompileSuccessfully(body, SPV_ENV_UNIVERSAL_1_5); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); } TEST_F(ValidateMeshShading, BadPerPrimitiveEXTStorageClassInMeshEXT) { const std::string body = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %main "main" %gl_LocalInvocationID %blk %triangleNormal OpExecutionMode %main LocalSize 32 1 1 OpExecutionMode %main OutputVertices 81 OpExecutionMode %main OutputPrimitivesNV 32 OpExecutionMode %main OutputTrianglesNV OpSource GLSL 450 OpSourceExtension "GL_EXT_mesh_shader" OpName %main "main" OpName %iid "iid" OpName %gl_LocalInvocationID "gl_LocalInvocationID" OpName %myblock "myblock" OpMemberName %myblock 0 "f" OpName %blk "blk" OpName %triangleNormal "triangleNormal" OpDecorate %gl_LocalInvocationID BuiltIn LocalInvocationId OpMemberDecorate %myblock 0 PerPrimitiveEXT OpDecorate %myblock Block OpDecorate %blk Location 0 OpDecorate %triangleNormal PerPrimitiveEXT OpDecorate %triangleNormal Location 0 OpDecorate %gl_WorkGroupSize BuiltIn WorkgroupSize %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_ptr_Function_uint = OpTypePointer Function %uint %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %gl_LocalInvocationID = OpVariable %_ptr_Input_v3uint Input %uint_0 = OpConstant %uint 0 %_ptr_Input_uint = OpTypePointer Input %uint %float = OpTypeFloat 32 %myblock = OpTypeStruct %float %uint_32 = OpConstant %uint 32 %_arr_myblock_uint_32 = OpTypeArray %myblock %uint_32 %_ptr_Output__arr_myblock_uint_32 = OpTypePointer Output %_arr_myblock_uint_32 %blk = OpVariable %_ptr_Output__arr_myblock_uint_32 Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float_11 = OpConstant %float 11 %_ptr_Output_float = OpTypePointer Output %float %v3float = OpTypeVector %float 3 %_arr_v3float_uint_32 = OpTypeArray %v3float %uint_32 %_ptr_Output__arr_v3float_uint_32 = OpTypePointer Input %_arr_v3float_uint_32 %triangleNormal = OpVariable %_ptr_Output__arr_v3float_uint_32 Input %33 = OpConstantComposite %v3float %float_11 %float_11 %float_11 %_ptr_Output_v3float = OpTypePointer Output %v3float %uint_1 = OpConstant %uint 1 %gl_WorkGroupSize = OpConstantComposite %v3uint %uint_32 %uint_1 %uint_1 %main = OpFunction %void None %3 %5 = OpLabel %iid = OpVariable %_ptr_Function_uint Function %14 = OpAccessChain %_ptr_Input_uint %gl_LocalInvocationID %uint_0 %15 = OpLoad %uint %14 OpStore %iid %15 %22 = OpLoad %uint %iid %27 = OpAccessChain %_ptr_Output_float %blk %22 %int_0 OpStore %27 %float_11 OpReturn OpFunctionEnd )"; CompileSuccessfully(body, SPV_ENV_UNIVERSAL_1_5); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); EXPECT_THAT(getDiagnosticString(), HasSubstr("PerPrimitiveEXT decoration must be applied only to " "variables in the Output Storage Class in the Storage " "Class in the MeshEXT Execution Model.")); } TEST_F(ValidateMeshShading, VulkanPerPrimitiveEXTStorageClassInMeshEXT) { const std::string body = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %main "main" %gl_LocalInvocationID %blk %triangleNormal OpExecutionMode %main LocalSize 32 1 1 OpExecutionMode %main OutputVertices 81 OpExecutionMode %main OutputPrimitivesNV 32 OpExecutionMode %main OutputTrianglesNV OpSource GLSL 450 OpSourceExtension "GL_EXT_mesh_shader" OpName %main "main" OpName %iid "iid" OpName %gl_LocalInvocationID "gl_LocalInvocationID" OpName %myblock "myblock" OpMemberName %myblock 0 "f" OpName %blk "blk" OpName %triangleNormal "triangleNormal" OpDecorate %gl_LocalInvocationID BuiltIn LocalInvocationId OpMemberDecorate %myblock 0 PerPrimitiveEXT OpDecorate %myblock Block OpDecorate %blk Location 0 OpDecorate %triangleNormal PerPrimitiveEXT OpDecorate %triangleNormal Location 0 OpDecorate %gl_WorkGroupSize BuiltIn WorkgroupSize %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_ptr_Function_uint = OpTypePointer Function %uint %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %gl_LocalInvocationID = OpVariable %_ptr_Input_v3uint Input %uint_0 = OpConstant %uint 0 %_ptr_Input_uint = OpTypePointer Input %uint %float = OpTypeFloat 32 %myblock = OpTypeStruct %float %uint_32 = OpConstant %uint 32 %_arr_myblock_uint_32 = OpTypeArray %myblock %uint_32 %_ptr_Output__arr_myblock_uint_32 = OpTypePointer Output %_arr_myblock_uint_32 %blk = OpVariable %_ptr_Output__arr_myblock_uint_32 Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float_11 = OpConstant %float 11 %_ptr_Output_float = OpTypePointer Output %float %v3float = OpTypeVector %float 3 %_arr_v3float_uint_32 = OpTypeArray %v3float %uint_32 %_ptr_Output__arr_v3float_uint_32 = OpTypePointer Input %_arr_v3float_uint_32 %triangleNormal = OpVariable %_ptr_Output__arr_v3float_uint_32 Input %33 = OpConstantComposite %v3float %float_11 %float_11 %float_11 %_ptr_Output_v3float = OpTypePointer Output %v3float %uint_1 = OpConstant %uint 1 %gl_WorkGroupSize = OpConstantComposite %v3uint %uint_32 %uint_1 %uint_1 %main = OpFunction %void None %3 %5 = OpLabel %iid = OpVariable %_ptr_Function_uint Function %14 = OpAccessChain %_ptr_Input_uint %gl_LocalInvocationID %uint_0 %15 = OpLoad %uint %14 OpStore %iid %15 %22 = OpLoad %uint %iid %27 = OpAccessChain %_ptr_Output_float %blk %22 %int_0 OpStore %27 %float_11 OpReturn OpFunctionEnd )"; CompileSuccessfully(body, SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-PrimitiveId-PrimitiveId-04336")); } TEST_F(ValidateMeshShading, BadPerPrimitiveEXTStorageClassInFrag) { const std::string body = R"( OpCapability Shader OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %triangleNormal OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpSourceExtension "GL_EXT_mesh_shader" OpName %main "main" OpName %triangleNormal "triangleNormal" OpDecorate %triangleNormal PerPrimitiveNV OpDecorate %triangleNormal Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %uint = OpTypeInt 32 0 %uint_3 = OpConstant %uint 3 %_arr_v3float_uint_3 = OpTypeArray %v3float %uint_3 %_ptr_Input__arr_v3float_uint_3 = OpTypePointer Output %_arr_v3float_uint_3 %triangleNormal = OpVariable %_ptr_Input__arr_v3float_uint_3 Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Input_v3float = OpTypePointer Input %v3float %main = OpFunction %void None %3 %5 = OpLabel %18 = OpAccessChain %_ptr_Input_v3float %triangleNormal %int_0 %19 = OpLoad %v3float %18 OpReturn OpFunctionEnd )"; CompileSuccessfully(body, SPV_ENV_UNIVERSAL_1_5); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); EXPECT_THAT(getDiagnosticString(), HasSubstr("PerPrimitiveEXT decoration must be applied only to " "variables in the Input Storage Class in the Fragment " "Execution Model.")); } TEST_F(ValidateMeshShading, PerPrimitiveEXTStorageClassInFrag) { const std::string body = R"( OpCapability Shader OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %res3 %triangleNormal OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpSourceExtension "GL_EXT_mesh_shader" OpName %main "main" OpName %res3 "res3" OpName %triangleNormal "triangleNormal" OpDecorate %res3 Location 0 OpDecorate %triangleNormal PerPrimitiveNV OpDecorate %triangleNormal Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %_ptr_Output_v3float = OpTypePointer Output %v3float %res3 = OpVariable %_ptr_Output_v3float Output %uint = OpTypeInt 32 0 %uint_3 = OpConstant %uint 3 %_arr_v3float_uint_3 = OpTypeArray %v3float %uint_3 %_ptr_Input__arr_v3float_uint_3 = OpTypePointer Input %_arr_v3float_uint_3 %triangleNormal = OpVariable %_ptr_Input__arr_v3float_uint_3 Input %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %_ptr_Input_v3float = OpTypePointer Input %v3float %main = OpFunction %void None %3 %5 = OpLabel %18 = OpAccessChain %_ptr_Input_v3float %triangleNormal %int_0 %19 = OpLoad %v3float %18 OpStore %res3 %19 OpReturn OpFunctionEnd )"; CompileSuccessfully(body, SPV_ENV_UNIVERSAL_1_5); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); } TEST_F(ValidateMeshShading, PerPrimitiveEXTStorageClassInMeshEXT) { const std::string body = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %main "main" %gl_LocalInvocationID %blk %triangleNormal OpExecutionMode %main LocalSize 32 1 1 OpExecutionMode %main OutputVertices 81 OpExecutionMode %main OutputPrimitivesNV 32 OpExecutionMode %main OutputTrianglesNV OpSource GLSL 450 OpSourceExtension "GL_EXT_mesh_shader" OpName %main "main" OpName %iid "iid" OpName %gl_LocalInvocationID "gl_LocalInvocationID" OpName %myblock "myblock" OpMemberName %myblock 0 "f" OpName %blk "blk" OpName %triangleNormal "triangleNormal" OpDecorate %gl_LocalInvocationID BuiltIn LocalInvocationId OpMemberDecorate %myblock 0 PerPrimitiveNV OpDecorate %myblock Block OpDecorate %blk Location 0 OpDecorate %triangleNormal PerPrimitiveNV OpDecorate %triangleNormal Location 0 OpDecorate %gl_WorkGroupSize BuiltIn WorkgroupSize %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_ptr_Function_uint = OpTypePointer Function %uint %v3uint = OpTypeVector %uint 3 %_ptr_Input_v3uint = OpTypePointer Input %v3uint %gl_LocalInvocationID = OpVariable %_ptr_Input_v3uint Input %uint_0 = OpConstant %uint 0 %_ptr_Input_uint = OpTypePointer Input %uint %float = OpTypeFloat 32 %myblock = OpTypeStruct %float %uint_32 = OpConstant %uint 32 %_arr_myblock_uint_32 = OpTypeArray %myblock %uint_32 %_ptr_Output__arr_myblock_uint_32 = OpTypePointer Output %_arr_myblock_uint_32 %blk = OpVariable %_ptr_Output__arr_myblock_uint_32 Output %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float_11 = OpConstant %float 11 %_ptr_Output_float = OpTypePointer Output %float %v3float = OpTypeVector %float 3 %_arr_v3float_uint_32 = OpTypeArray %v3float %uint_32 %_ptr_Output__arr_v3float_uint_32 = OpTypePointer Output %_arr_v3float_uint_32 %triangleNormal = OpVariable %_ptr_Output__arr_v3float_uint_32 Output %33 = OpConstantComposite %v3float %float_11 %float_11 %float_11 %_ptr_Output_v3float = OpTypePointer Output %v3float %uint_1 = OpConstant %uint 1 %gl_WorkGroupSize = OpConstantComposite %v3uint %uint_32 %uint_1 %uint_1 %main = OpFunction %void None %3 %5 = OpLabel %iid = OpVariable %_ptr_Function_uint Function %14 = OpAccessChain %_ptr_Input_uint %gl_LocalInvocationID %uint_0 %15 = OpLoad %uint %14 OpStore %iid %15 %22 = OpLoad %uint %iid %27 = OpAccessChain %_ptr_Output_float %blk %22 %int_0 OpStore %27 %float_11 %32 = OpLoad %uint %iid %35 = OpAccessChain %_ptr_Output_v3float %triangleNormal %32 OpStore %35 %33 OpReturn OpFunctionEnd )"; CompileSuccessfully(body, SPV_ENV_UNIVERSAL_1_5); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_misc_test.cpp000066400000000000000000000317151475742701700236410ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validation tests for misc instructions #include #include #include "gmock/gmock.h" #include "test/unit_spirv.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::Eq; using ::testing::HasSubstr; using ValidateMisc = spvtest::ValidateBase; TEST_F(ValidateMisc, UndefRestrictedShort) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability StorageBuffer16BitAccess OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 %short = OpTypeInt 16 0 %undef = OpUndef %short )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Cannot create undefined values with 8- or 16-bit types")); } TEST_F(ValidateMisc, UndefRestrictedChar) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability StorageBuffer8BitAccess OpExtension "SPV_KHR_8bit_storage" OpMemoryModel Logical GLSL450 %char = OpTypeInt 8 0 %undef = OpUndef %char )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Cannot create undefined values with 8- or 16-bit types")); } TEST_F(ValidateMisc, UndefRestrictedHalf) { const std::string spirv = R"( OpCapability Shader OpCapability Linkage OpCapability StorageBuffer16BitAccess OpExtension "SPV_KHR_16bit_storage" OpMemoryModel Logical GLSL450 %half = OpTypeFloat 16 %undef = OpUndef %half )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Cannot create undefined values with 8- or 16-bit types")); } TEST_F(ValidateMisc, SizeOfValid) { const std::string spirv = R"( OpCapability Addresses OpCapability Kernel OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %f "f" %void = OpTypeVoid %i32 = OpTypeInt 32 0 %ptr = OpTypePointer CrossWorkgroup %i32 %fnTy = OpTypeFunction %void %f = OpFunction %void None %fnTy %entry = OpLabel %s = OpSizeOf %i32 %ptr OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_1); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_1)); } const std::string ShaderClockSpirv = R"( OpCapability Shader OpCapability Int64 OpCapability ShaderClockKHR OpExtension "SPV_KHR_shader_clock" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 450 OpSourceExtension "GL_ARB_gpu_shader_int64" OpSourceExtension "GL_ARB_shader_clock" OpSourceExtension "GL_EXT_shader_realtime_clock" OpName %main "main" OpName %time1 "time1" %void = OpTypeVoid )"; TEST_F(ValidateMisc, ShaderClockInt64) { const std::string spirv = ShaderClockSpirv + R"( %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %_ptr_Function_uint = OpTypePointer Function %uint %uint_3 = OpConstant %uint 3 %uint_1 = OpConstant %uint 1 %main = OpFunction %void None %3 %5 = OpLabel %time1 = OpVariable %_ptr_Function_uint Function %11 = OpReadClockKHR %uint %uint_3 OpStore %time1 %11 OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("or 64bit unsigned integer")); } TEST_F(ValidateMisc, ShaderClockVec2) { const std::string spirv = ShaderClockSpirv + R"( %3 = OpTypeFunction %void %ulong = OpTypeInt 64 0 %_ptr_Function_ulong = OpTypePointer Function %ulong %uint = OpTypeInt 32 0 %uint_3 = OpConstant %uint 3 %v2uint = OpTypeVector %ulong 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint %main = OpFunction %void None %3 %5 = OpLabel %time1 = OpVariable %_ptr_Function_v2uint Function %15 = OpReadClockKHR %v2uint %uint_3 OpStore %time1 %15 OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("vector of two components")); } TEST_F(ValidateMisc, ShaderClockInvalidScopeValue) { const std::string spirv = ShaderClockSpirv + R"( %3 = OpTypeFunction %void %ulong = OpTypeInt 64 0 %uint = OpTypeInt 32 0 %_ptr_Function_ulong = OpTypePointer Function %ulong %uint_10 = OpConstant %uint 10 %uint_1 = OpConstant %uint 1 %main = OpFunction %void None %3 %5 = OpLabel %time1 = OpVariable %_ptr_Function_ulong Function %11 = OpReadClockKHR %ulong %uint_10 OpStore %time1 %11 OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Invalid scope value")); } TEST_F(ValidateMisc, ShaderClockSubgroupScope) { const std::string spirv = ShaderClockSpirv + R"( %3 = OpTypeFunction %void %ulong = OpTypeInt 64 0 %uint = OpTypeInt 32 0 %_ptr_Function_ulong = OpTypePointer Function %ulong %subgroup = OpConstant %uint 3 %uint_1 = OpConstant %uint 1 %main = OpFunction %void None %3 %5 = OpLabel %time1 = OpVariable %_ptr_Function_ulong Function %11 = OpReadClockKHR %ulong %subgroup OpStore %time1 %11 OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateMisc, ShaderClockDeviceScope) { const std::string spirv = ShaderClockSpirv + R"( %3 = OpTypeFunction %void %ulong = OpTypeInt 64 0 %uint = OpTypeInt 32 0 %_ptr_Function_ulong = OpTypePointer Function %ulong %device = OpConstant %uint 1 %uint_1 = OpConstant %uint 1 %main = OpFunction %void None %3 %5 = OpLabel %time1 = OpVariable %_ptr_Function_ulong Function %11 = OpReadClockKHR %ulong %device OpStore %time1 %11 OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateMisc, ShaderClockWorkgroupScope) { const std::string spirv = ShaderClockSpirv + R"( %3 = OpTypeFunction %void %ulong = OpTypeInt 64 0 %uint = OpTypeInt 32 0 %_ptr_Function_ulong = OpTypePointer Function %ulong %workgroup = OpConstant %uint 2 %uint_1 = OpConstant %uint 1 %main = OpFunction %void None %3 %5 = OpLabel %time1 = OpVariable %_ptr_Function_ulong Function %11 = OpReadClockKHR %ulong %workgroup OpStore %time1 %11 OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Scope must be Subgroup or Device")); } TEST_F(ValidateMisc, VulkanShaderClockWorkgroupScope) { const std::string spirv = ShaderClockSpirv + R"( %3 = OpTypeFunction %void %ulong = OpTypeInt 64 0 %uint = OpTypeInt 32 0 %_ptr_Function_ulong = OpTypePointer Function %ulong %workgroup = OpConstant %uint 2 %uint_1 = OpConstant %uint 1 %main = OpFunction %void None %3 %5 = OpLabel %time1 = OpVariable %_ptr_Function_ulong Function %11 = OpReadClockKHR %ulong %workgroup OpStore %time1 %11 OpReturn OpFunctionEnd)"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpReadClockKHR-04652")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Scope must be Subgroup or Device")); } std::string GenKernelClockSpirv(const std::string& scope) { const std::string s = R"( OpCapability Kernel OpCapability Addresses OpCapability Int64 OpCapability ShaderClockKHR OpExtension "SPV_KHR_shader_clock" OpMemoryModel Physical32 OpenCL OpEntryPoint Kernel %main "main" OpExecutionMode %main ContractionOff OpSource OpenCL_C 200000 OpName %main "main" OpName %time1 "time1" %void = OpTypeVoid %3 = OpTypeFunction %void %ulong = OpTypeInt 64 0 %uint = OpTypeInt 32 0 %_ptr_Function_ulong = OpTypePointer Function %ulong %scope = OpConstant %uint )" + scope + R"( %main = OpFunction %void None %3 %5 = OpLabel %time1 = OpVariable %_ptr_Function_ulong Function %11 = OpReadClockKHR %ulong %scope OpStore %time1 %11 OpReturn OpFunctionEnd )"; return s; } TEST_F(ValidateMisc, KernelClockScopeDevice) { CompileSuccessfully(GenKernelClockSpirv("1"), SPV_ENV_OPENCL_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_OPENCL_1_2)); } TEST_F(ValidateMisc, KernelClockScopeWorkgroup) { CompileSuccessfully(GenKernelClockSpirv("2"), SPV_ENV_OPENCL_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_OPENCL_1_2)); } TEST_F(ValidateMisc, KernelClockScopeSubgroup) { CompileSuccessfully(GenKernelClockSpirv("3"), SPV_ENV_OPENCL_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_OPENCL_1_2)); } TEST_F(ValidateMisc, KernelClockScopeInvalid) { CompileSuccessfully(GenKernelClockSpirv("0"), SPV_ENV_OPENCL_1_2); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_OPENCL_1_2)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Scope must be Subgroup, Workgroup, or Device")); } TEST_F(ValidateMisc, UndefVoid) { const std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %10 = OpUndef %2 %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Cannot create undefined values with void type")); } TEST_F(ValidateMisc, VulkanInvalidStorageClass) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %func "shader" %int = OpTypeInt 32 0 %ptr = OpTypePointer CrossWorkgroup %int %var = OpVariable %ptr CrossWorkgroup %void = OpTypeVoid %void_f = OpTypeFunction %void %func = OpFunction %void None %void_f %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_BINARY, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-None-04643")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Invalid storage class for target environment")); } TEST_F(ValidateMisc, CoopMat2WorkgroupLocalSizeIdPass) { const std::string body = R"( OpCapability Shader OpCapability Float16 OpCapability Int16 OpCapability CooperativeMatrixKHR OpExtension "SPV_KHR_cooperative_matrix" OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionModeId %main LocalSizeId %u32_16 %u32_16 %u32_16 %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f16 = OpTypeFloat 16 %u32 = OpTypeInt 32 0 %u32_16 = OpConstant %u32 16 %use_Acc = OpConstant %u32 2 %workgroup = OpConstant %u32 2 %f16mat = OpTypeCooperativeMatrixKHR %f16 %workgroup %u32_16 %u32_16 %use_Acc %main = OpFunction %void None %func %main_entry = OpLabel OpReturn OpFunctionEnd)"; CompileSuccessfully(body.c_str(), SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateMisc, CoopMat2WorkgroupLocalSizeIdConstantNotDeclaredYetFail) { const std::string body = R"( OpCapability Shader OpCapability Float16 OpCapability Int16 OpCapability CooperativeMatrixKHR OpExtension "SPV_KHR_cooperative_matrix" OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionModeId %main LocalSizeId %u32_16 %u32_8 %u32_16 %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f16 = OpTypeFloat 16 %u32 = OpTypeInt 32 0 %u32_16 = OpConstant %u32 16 %use_Acc = OpConstant %u32 2 %workgroup = OpConstant %u32 2 %f16mat = OpTypeCooperativeMatrixKHR %f16 %workgroup %u32_16 %u32_16 %use_Acc %u32_8 = OpConstant %u32 8 %main = OpFunction %void None %func %main_entry = OpLabel OpReturn OpFunctionEnd)"; CompileSuccessfully(body.c_str(), SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpTypeCooperativeMatrixKHR with ScopeWorkgroup used " "before LocalSizeId constant value")); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_modes_test.cpp000066400000000000000000002655611475742701700240250ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // Modifications Copyright (C) 2024 Advanced Micro Devices, Inc. All rights // reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include "gmock/gmock.h" #include "source/spirv_target_env.h" #include "test/unit_spirv.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::Combine; using ::testing::HasSubstr; using ::testing::Values; using ::testing::ValuesIn; using ValidateMode = spvtest::ValidateBase; const std::string kVoidFunction = R"(%void = OpTypeVoid %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; TEST_F(ValidateMode, GLComputeNoMode) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" )" + kVoidFunction; CompileSuccessfully(spirv); EXPECT_THAT(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateMode, GLComputeNoModeVulkan) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" )" + kVoidFunction; spv_target_env env = SPV_ENV_VULKAN_1_0; CompileSuccessfully(spirv, env); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions(env)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-LocalSize-06426")); EXPECT_THAT( getDiagnosticString(), HasSubstr( "In the Vulkan environment, GLCompute execution model entry " "points require either the LocalSize or LocalSizeId execution mode " "or an object decorated with WorkgroupSize must be specified.")); } TEST_F(ValidateMode, GLComputeNoModeVulkanWorkgroupSize) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpDecorate %int3_1 BuiltIn WorkgroupSize %int = OpTypeInt 32 0 %int3 = OpTypeVector %int 3 %int_1 = OpConstant %int 1 %int3_1 = OpConstantComposite %int3 %int_1 %int_1 %int_1 )" + kVoidFunction; spv_target_env env = SPV_ENV_VULKAN_1_0; CompileSuccessfully(spirv, env); EXPECT_THAT(SPV_SUCCESS, ValidateInstructions(env)); } TEST_F(ValidateMode, GLComputeZeroWorkgroupSize) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpDecorate %int3_1 BuiltIn WorkgroupSize %int = OpTypeInt 32 0 %int3 = OpTypeVector %int 3 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %int3_1 = OpConstantComposite %int3 %int_1 %int_0 %int_0 )" + kVoidFunction; CompileSuccessfully(spirv); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "WorkgroupSize decorations must not have a static product of zero")); } TEST_F(ValidateMode, GLComputeZeroSpecWorkgroupSize) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpDecorate %int3_1 BuiltIn WorkgroupSize %int = OpTypeInt 32 0 %int3 = OpTypeVector %int 3 %int_0 = OpSpecConstant %int 0 %int_1 = OpConstant %int 1 %int3_1 = OpConstantComposite %int3 %int_1 %int_0 %int_0 )" + kVoidFunction; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateMode, GLComputeZeroSpecCompositeWorkgroupSize) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpDecorate %int3_1 BuiltIn WorkgroupSize %int = OpTypeInt 32 0 %int3 = OpTypeVector %int 3 %int_0 = OpSpecConstant %int 0 %int_1 = OpSpecConstant %int 1 %int3_1 = OpSpecConstantComposite %int3 %int_1 %int_0 %int_0 )" + kVoidFunction; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateMode, KernelZeroWorkgroupSizeConstant) { const std::string spirv = R"( OpCapability Addresses OpCapability Linkage OpCapability Kernel OpMemoryModel Physical32 OpenCL OpEntryPoint Kernel %main "main" OpDecorate %int3_1 BuiltIn WorkgroupSize %int = OpTypeInt 32 0 %int3 = OpTypeVector %int 3 %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %int3_1 = OpConstantComposite %int3 %int_1 %int_0 %int_0 )" + kVoidFunction; CompileSuccessfully(spirv); EXPECT_THAT(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("must be a variable")); } TEST_F(ValidateMode, KernelZeroWorkgroupSizeVariable) { const std::string spirv = R"( OpCapability Addresses OpCapability Linkage OpCapability Kernel OpMemoryModel Physical32 OpenCL OpEntryPoint Kernel %main "main" OpDecorate %var BuiltIn WorkgroupSize %int = OpTypeInt 32 0 %int3 = OpTypeVector %int 3 %ptr = OpTypePointer Input %int3 %var = OpVariable %ptr Input )" + kVoidFunction; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateMode, GLComputeVulkanLocalSize) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 )" + kVoidFunction; spv_target_env env = SPV_ENV_VULKAN_1_0; CompileSuccessfully(spirv, env); EXPECT_THAT(SPV_SUCCESS, ValidateInstructions(env)); } TEST_F(ValidateMode, GLComputeZeroLocalSize) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 0 )" + kVoidFunction; CompileSuccessfully(spirv); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Local Size execution mode must not have a product of zero")); } TEST_F(ValidateMode, KernelZeroLocalSize) { const std::string spirv = R"( OpCapability Addresses OpCapability Linkage OpCapability Kernel OpMemoryModel Physical32 OpenCL OpEntryPoint Kernel %main "main" OpExecutionMode %main LocalSize 1 1 0 )" + kVoidFunction; CompileSuccessfully(spirv); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Local Size execution mode must not have a product of zero")); } TEST_F(ValidateMode, GLComputeVulkanLocalSizeIdBad) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionModeId %main LocalSizeId %int_1 %int_1 %int_1 %int = OpTypeInt 32 0 %int_1 = OpConstant %int 1 )" + kVoidFunction; spv_target_env env = SPV_ENV_VULKAN_1_1; // need SPIR-V 1.2 CompileSuccessfully(spirv, env); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions(env)); EXPECT_THAT( getDiagnosticString(), HasSubstr("LocalSizeId mode is not allowed by the current environment.")); } TEST_F(ValidateMode, GLComputeVulkanLocalSizeIdGood) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionModeId %main LocalSizeId %int_1 %int_1 %int_1 %int = OpTypeInt 32 0 %int_1 = OpConstant %int 1 )" + kVoidFunction; spv_target_env env = SPV_ENV_VULKAN_1_1; // need SPIR-V 1.2 CompileSuccessfully(spirv, env); spvValidatorOptionsSetAllowLocalSizeId(getValidatorOptions(), true); EXPECT_THAT(SPV_SUCCESS, ValidateInstructions(env)); } TEST_F(ValidateMode, GLComputeZeroLocalSizeId) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionModeId %main LocalSizeId %int_1 %int_0 %int_1 %int = OpTypeInt 32 0 %int_1 = OpConstant %int 1 %int_0 = OpConstant %int 0 )" + kVoidFunction; spv_target_env env = SPV_ENV_UNIVERSAL_1_3; CompileSuccessfully(spirv, env); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions(env)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Local Size Id execution mode must not have a product of zero")); } TEST_F(ValidateMode, GLComputeZeroSpecLocalSizeId) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionModeId %main LocalSizeId %int_1 %int_0 %int_1 %int = OpTypeInt 32 0 %int_1 = OpConstant %int 1 %int_0 = OpSpecConstant %int 0 )" + kVoidFunction; spv_target_env env = SPV_ENV_UNIVERSAL_1_3; CompileSuccessfully(spirv, env); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(env)); } TEST_F(ValidateMode, KernelZeroLocalSizeId) { const std::string spirv = R"( OpCapability Addresses OpCapability Linkage OpCapability Kernel OpMemoryModel Physical32 OpenCL OpEntryPoint Kernel %main "main" OpExecutionModeId %main LocalSizeId %int_1 %int_0 %int_1 %int = OpTypeInt 32 0 %int_1 = OpConstant %int 1 %int_0 = OpConstant %int 0 )" + kVoidFunction; spv_target_env env = SPV_ENV_UNIVERSAL_1_3; CompileSuccessfully(spirv, env); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions(env)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Local Size Id execution mode must not have a product of zero")); } // https://github.com/KhronosGroup/SPIRV-Tools/issues/5939 TEST_F(ValidateMode, KernelZeroLocalSize64) { const std::string spirv = R"( OpCapability Kernel OpCapability Addresses OpCapability Int64 OpCapability Linkage OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %test "test" %__spirv_BuiltInWorkgroupSize OpExecutionMode %test ContractionOff OpDecorate %__spirv_BuiltInWorkgroupSize Constant OpDecorate %__spirv_BuiltInWorkgroupSize LinkageAttributes "__spirv_BuiltInWorkgroupSize" Import OpDecorate %__spirv_BuiltInWorkgroupSize BuiltIn WorkgroupSize %void = OpTypeVoid %ulong = OpTypeInt 64 0 %v3ulong = OpTypeVector %ulong 3 %_ptr_Input_v3ulong = OpTypePointer Input %v3ulong %8 = OpTypeFunction %void %__spirv_BuiltInWorkgroupSize = OpVariable %_ptr_Input_v3ulong Input %test = OpFunction %void None %8 %entry = OpLabel %11 = OpLoad %v3ulong %__spirv_BuiltInWorkgroupSize Aligned 1 %12 = OpCompositeExtract %ulong %11 0 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateMode, FragmentOriginLowerLeftVulkan) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginLowerLeft )" + kVoidFunction; spv_target_env env = SPV_ENV_VULKAN_1_0; CompileSuccessfully(spirv, env); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions(env)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OriginLowerLeft-04653")); EXPECT_THAT(getDiagnosticString(), HasSubstr("In the Vulkan environment, the OriginLowerLeft " "execution mode must not be used.")); } TEST_F(ValidateMode, FragmentPixelCenterIntegerVulkan) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpExecutionMode %main PixelCenterInteger )" + kVoidFunction; spv_target_env env = SPV_ENV_VULKAN_1_0; CompileSuccessfully(spirv, env); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions(env)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-PixelCenterInteger-04654")); EXPECT_THAT(getDiagnosticString(), HasSubstr("In the Vulkan environment, the PixelCenterInteger " "execution mode must not be used.")); } TEST_F(ValidateMode, GeometryNoOutputMode) { const std::string spirv = R"( OpCapability Geometry OpMemoryModel Logical GLSL450 OpEntryPoint Geometry %main "main" OpExecutionMode %main InputPoints )" + kVoidFunction; CompileSuccessfully(spirv); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Geometry execution model entry points must specify " "exactly one of OutputPoints, OutputLineStrip or " "OutputTriangleStrip execution modes.")); } TEST_F(ValidateMode, GeometryNoInputMode) { const std::string spirv = R"( OpCapability Geometry OpMemoryModel Logical GLSL450 OpEntryPoint Geometry %main "main" OpExecutionMode %main OutputPoints )" + kVoidFunction; CompileSuccessfully(spirv); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Geometry execution model entry points must specify exactly " "one of InputPoints, InputLines, InputLinesAdjacency, " "Triangles or InputTrianglesAdjacency execution modes.")); } TEST_F(ValidateMode, FragmentNoOrigin) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" )" + kVoidFunction; CompileSuccessfully(spirv); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Fragment execution model entry points require either an " "OriginUpperLeft or OriginLowerLeft execution mode.")); } TEST_F(ValidateMode, FragmentBothOrigins) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpExecutionMode %main OriginLowerLeft )" + kVoidFunction; CompileSuccessfully(spirv); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Fragment execution model entry points can only specify one of " "OriginUpperLeft or OriginLowerLeft execution modes.")); } TEST_F(ValidateMode, FragmentDepthGreaterAndLess) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpExecutionMode %main DepthGreater OpExecutionMode %main DepthLess )" + kVoidFunction; CompileSuccessfully(spirv); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Fragment execution model entry points can specify at " "most one of DepthGreater, DepthLess or DepthUnchanged " "execution modes.")); } TEST_F(ValidateMode, FragmentDepthGreaterAndUnchanged) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpExecutionMode %main DepthGreater OpExecutionMode %main DepthUnchanged )" + kVoidFunction; CompileSuccessfully(spirv); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Fragment execution model entry points can specify at " "most one of DepthGreater, DepthLess or DepthUnchanged " "execution modes.")); } TEST_F(ValidateMode, FragmentDepthLessAndUnchanged) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpExecutionMode %main DepthLess OpExecutionMode %main DepthUnchanged )" + kVoidFunction; CompileSuccessfully(spirv); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Fragment execution model entry points can specify at " "most one of DepthGreater, DepthLess or DepthUnchanged " "execution modes.")); } TEST_F(ValidateMode, FragmentAllDepths) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpExecutionMode %main DepthGreater OpExecutionMode %main DepthLess OpExecutionMode %main DepthUnchanged )" + kVoidFunction; CompileSuccessfully(spirv); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Fragment execution model entry points can specify at " "most one of DepthGreater, DepthLess or DepthUnchanged " "execution modes.")); } TEST_F(ValidateMode, TessellationControlSpacingEqualAndFractionalOdd) { const std::string spirv = R"( OpCapability Tessellation OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %main "main" OpExecutionMode %main SpacingEqual OpExecutionMode %main SpacingFractionalOdd )" + kVoidFunction; CompileSuccessfully(spirv); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Tessellation execution model entry points can specify " "at most one of SpacingEqual, SpacingFractionalOdd or " "SpacingFractionalEven execution modes.")); } TEST_F(ValidateMode, TessellationControlSpacingEqualAndSpacingFractionalEven) { const std::string spirv = R"( OpCapability Tessellation OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %main "main" OpExecutionMode %main SpacingEqual OpExecutionMode %main SpacingFractionalEven )" + kVoidFunction; CompileSuccessfully(spirv); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Tessellation execution model entry points can specify " "at most one of SpacingEqual, SpacingFractionalOdd or " "SpacingFractionalEven execution modes.")); } TEST_F(ValidateMode, TessellationControlSpacingFractionalOddAndSpacingFractionalEven) { const std::string spirv = R"( OpCapability Tessellation OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %main "main" OpExecutionMode %main SpacingFractionalOdd OpExecutionMode %main SpacingFractionalEven )" + kVoidFunction; CompileSuccessfully(spirv); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Tessellation execution model entry points can specify " "at most one of SpacingEqual, SpacingFractionalOdd or " "SpacingFractionalEven execution modes.")); } TEST_F(ValidateMode, TessellationControlAllSpacing) { const std::string spirv = R"( OpCapability Tessellation OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %main "main" OpExecutionMode %main SpacingEqual OpExecutionMode %main SpacingFractionalOdd OpExecutionMode %main SpacingFractionalEven )" + kVoidFunction; CompileSuccessfully(spirv); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Tessellation execution model entry points can specify " "at most one of SpacingEqual, SpacingFractionalOdd or " "SpacingFractionalEven execution modes.")); } TEST_F(ValidateMode, TessellationEvaluationSpacingEqualAndSpacingFractionalOdd) { const std::string spirv = R"( OpCapability Tessellation OpMemoryModel Logical GLSL450 OpEntryPoint TessellationEvaluation %main "main" OpExecutionMode %main SpacingEqual OpExecutionMode %main SpacingFractionalOdd )" + kVoidFunction; CompileSuccessfully(spirv); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Tessellation execution model entry points can specify " "at most one of SpacingEqual, SpacingFractionalOdd or " "SpacingFractionalEven execution modes.")); } TEST_F(ValidateMode, TessellationEvaluationSpacingEqualAndSpacingFractionalEven) { const std::string spirv = R"( OpCapability Tessellation OpMemoryModel Logical GLSL450 OpEntryPoint TessellationEvaluation %main "main" OpExecutionMode %main SpacingEqual OpExecutionMode %main SpacingFractionalEven )" + kVoidFunction; CompileSuccessfully(spirv); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Tessellation execution model entry points can specify " "at most one of SpacingEqual, SpacingFractionalOdd or " "SpacingFractionalEven execution modes.")); } TEST_F(ValidateMode, TessellationEvaluationSpacingFractionalOddAndSpacingFractionalEven) { const std::string spirv = R"( OpCapability Tessellation OpMemoryModel Logical GLSL450 OpEntryPoint TessellationEvaluation %main "main" OpExecutionMode %main SpacingFractionalOdd OpExecutionMode %main SpacingFractionalEven )" + kVoidFunction; CompileSuccessfully(spirv); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Tessellation execution model entry points can specify " "at most one of SpacingEqual, SpacingFractionalOdd or " "SpacingFractionalEven execution modes.")); } TEST_F(ValidateMode, TessellationEvaluationAllSpacing) { const std::string spirv = R"( OpCapability Tessellation OpMemoryModel Logical GLSL450 OpEntryPoint TessellationEvaluation %main "main" OpExecutionMode %main SpacingEqual OpExecutionMode %main SpacingFractionalOdd OpExecutionMode %main SpacingFractionalEven )" + kVoidFunction; CompileSuccessfully(spirv); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Tessellation execution model entry points can specify " "at most one of SpacingEqual, SpacingFractionalOdd or " "SpacingFractionalEven execution modes.")); } TEST_F(ValidateMode, TessellationControlBothVertex) { const std::string spirv = R"( OpCapability Tessellation OpMemoryModel Logical GLSL450 OpEntryPoint TessellationControl %main "main" OpExecutionMode %main VertexOrderCw OpExecutionMode %main VertexOrderCcw )" + kVoidFunction; CompileSuccessfully(spirv); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Tessellation execution model entry points can specify at most " "one of VertexOrderCw or VertexOrderCcw execution modes.")); } TEST_F(ValidateMode, TessellationEvaluationBothVertex) { const std::string spirv = R"( OpCapability Tessellation OpMemoryModel Logical GLSL450 OpEntryPoint TessellationEvaluation %main "main" OpExecutionMode %main VertexOrderCw OpExecutionMode %main VertexOrderCcw )" + kVoidFunction; CompileSuccessfully(spirv); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Tessellation execution model entry points can specify at most " "one of VertexOrderCw or VertexOrderCcw execution modes.")); } using ValidateModeGeometry = spvtest::ValidateBase, std::tuple>>; TEST_P(ValidateModeGeometry, ExecutionMode) { std::vector input_modes; std::vector output_modes; input_modes.push_back(std::get<0>(std::get<0>(GetParam()))); input_modes.push_back(std::get<1>(std::get<0>(GetParam()))); input_modes.push_back(std::get<2>(std::get<0>(GetParam()))); input_modes.push_back(std::get<3>(std::get<0>(GetParam()))); input_modes.push_back(std::get<4>(std::get<0>(GetParam()))); output_modes.push_back(std::get<0>(std::get<1>(GetParam()))); output_modes.push_back(std::get<1>(std::get<1>(GetParam()))); output_modes.push_back(std::get<2>(std::get<1>(GetParam()))); std::ostringstream sstr; sstr << "OpCapability Geometry\n"; sstr << "OpMemoryModel Logical GLSL450\n"; sstr << "OpEntryPoint Geometry %main \"main\"\n"; size_t num_input_modes = 0; for (auto input : input_modes) { if (!input.empty()) { num_input_modes++; sstr << "OpExecutionMode %main " << input << "\n"; } } size_t num_output_modes = 0; for (auto output : output_modes) { if (!output.empty()) { num_output_modes++; sstr << "OpExecutionMode %main " << output << "\n"; } } sstr << "%void = OpTypeVoid\n"; sstr << "%void_fn = OpTypeFunction %void\n"; sstr << "%int = OpTypeInt 32 0\n"; sstr << "%int1 = OpConstant %int 1\n"; sstr << "%main = OpFunction %void None %void_fn\n"; sstr << "%entry = OpLabel\n"; sstr << "OpReturn\n"; sstr << "OpFunctionEnd\n"; CompileSuccessfully(sstr.str()); if (num_input_modes == 1 && num_output_modes == 1) { EXPECT_THAT(SPV_SUCCESS, ValidateInstructions()); } else { EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions()); if (num_input_modes != 1) { EXPECT_THAT(getDiagnosticString(), HasSubstr("Geometry execution model entry points must " "specify exactly one of InputPoints, InputLines, " "InputLinesAdjacency, Triangles or " "InputTrianglesAdjacency execution modes.")); } else { EXPECT_THAT( getDiagnosticString(), HasSubstr("Geometry execution model entry points must specify " "exactly one of OutputPoints, OutputLineStrip or " "OutputTriangleStrip execution modes.")); } } } INSTANTIATE_TEST_SUITE_P( GeometryRequiredModes, ValidateModeGeometry, Combine(Combine(Values("InputPoints", ""), Values("InputLines", ""), Values("InputLinesAdjacency", ""), Values("Triangles", ""), Values("InputTrianglesAdjacency", "")), Combine(Values("OutputPoints", ""), Values("OutputLineStrip", ""), Values("OutputTriangleStrip", "")))); using ValidateModeExecution = spvtest::ValidateBase>; TEST_P(ValidateModeExecution, ExecutionMode) { const spv_result_t expectation = std::get<0>(GetParam()); const std::string error = std::get<1>(GetParam()); const std::string model = std::get<2>(GetParam()); const std::string mode = std::get<3>(GetParam()); const spv_target_env env = std::get<4>(GetParam()); std::ostringstream sstr; sstr << "OpCapability Shader\n"; sstr << "OpCapability Geometry\n"; sstr << "OpCapability Tessellation\n"; sstr << "OpCapability TransformFeedback\n"; if (!spvIsVulkanEnv(env)) { sstr << "OpCapability Kernel\n"; if (env == SPV_ENV_UNIVERSAL_1_3) { sstr << "OpCapability SubgroupDispatch\n"; } else if (env == SPV_ENV_UNIVERSAL_1_5) { sstr << "OpCapability TileImageColorReadAccessEXT\n"; sstr << "OpCapability TileImageDepthReadAccessEXT\n"; sstr << "OpCapability TileImageStencilReadAccessEXT\n"; sstr << "OpExtension \"SPV_EXT_shader_tile_image\"\n"; } } sstr << "OpMemoryModel Logical GLSL450\n"; sstr << "OpEntryPoint " << model << " %main \"main\"\n"; if (mode.find("LocalSizeId") == 0 || mode.find("LocalSizeHintId") == 0 || mode.find("SubgroupsPerWorkgroupId") == 0) { sstr << "OpExecutionModeId %main " << mode << "\n"; } else { sstr << "OpExecutionMode %main " << mode << "\n"; } if (model == "Geometry") { if (!(mode.find("InputPoints") == 0 || mode.find("InputLines") == 0 || mode.find("InputLinesAdjacency") == 0 || mode.find("Triangles") == 0 || mode.find("InputTrianglesAdjacency") == 0)) { // Exactly one of the above modes is required for Geometry shaders. sstr << "OpExecutionMode %main InputPoints\n"; } if (!(mode.find("OutputPoints") == 0 || mode.find("OutputLineStrip") == 0 || mode.find("OutputTriangleStrip") == 0)) { // Exactly one of the above modes is required for Geometry shaders. sstr << "OpExecutionMode %main OutputPoints\n"; } } else if (model == "Fragment") { if (!(mode.find("OriginUpperLeft") == 0 || mode.find("OriginLowerLeft") == 0)) { // Exactly one of the above modes is required for Fragment shaders. sstr << "OpExecutionMode %main OriginUpperLeft\n"; } } sstr << "%void = OpTypeVoid\n"; sstr << "%void_fn = OpTypeFunction %void\n"; sstr << "%int = OpTypeInt 32 0\n"; sstr << "%int1 = OpConstant %int 1\n"; sstr << "%main = OpFunction %void None %void_fn\n"; sstr << "%entry = OpLabel\n"; sstr << "OpReturn\n"; sstr << "OpFunctionEnd\n"; CompileSuccessfully(sstr.str(), env); EXPECT_THAT(expectation, ValidateInstructions(env)); if (expectation != SPV_SUCCESS) { EXPECT_THAT(getDiagnosticString(), HasSubstr(error)); } } INSTANTIATE_TEST_SUITE_P( ValidateModeGeometryOnlyGoodSpv10, ValidateModeExecution, Combine(Values(SPV_SUCCESS), Values(""), Values("Geometry"), Values("Invocations 3", "InputPoints", "InputLines", "InputLinesAdjacency", "InputTrianglesAdjacency", "OutputPoints", "OutputLineStrip", "OutputTriangleStrip"), Values(SPV_ENV_UNIVERSAL_1_0))); INSTANTIATE_TEST_SUITE_P( ValidateModeGeometryOnlyBadSpv10, ValidateModeExecution, Combine(Values(SPV_ERROR_INVALID_DATA), Values("Execution mode can only be used with the Geometry " "execution model."), Values("Fragment", "TessellationEvaluation", "TessellationControl", "GLCompute", "Vertex", "Kernel"), Values("Invocations 3", "InputPoints", "InputLines", "InputLinesAdjacency", "InputTrianglesAdjacency", "OutputPoints", "OutputLineStrip", "OutputTriangleStrip"), Values(SPV_ENV_UNIVERSAL_1_0))); INSTANTIATE_TEST_SUITE_P( ValidateModeTessellationOnlyGoodSpv10, ValidateModeExecution, Combine(Values(SPV_SUCCESS), Values(""), Values("TessellationControl", "TessellationEvaluation"), Values("SpacingEqual", "SpacingFractionalEven", "SpacingFractionalOdd", "VertexOrderCw", "VertexOrderCcw", "PointMode", "Quads", "Isolines"), Values(SPV_ENV_UNIVERSAL_1_0))); INSTANTIATE_TEST_SUITE_P( ValidateModeTessellationOnlyBadSpv10, ValidateModeExecution, Combine(Values(SPV_ERROR_INVALID_DATA), Values("Execution mode can only be used with a tessellation " "execution model."), Values("Fragment", "Geometry", "GLCompute", "Vertex", "Kernel"), Values("SpacingEqual", "SpacingFractionalEven", "SpacingFractionalOdd", "VertexOrderCw", "VertexOrderCcw", "PointMode", "Quads", "Isolines"), Values(SPV_ENV_UNIVERSAL_1_0))); INSTANTIATE_TEST_SUITE_P(ValidateModeGeometryAndTessellationGoodSpv10, ValidateModeExecution, Combine(Values(SPV_SUCCESS), Values(""), Values("TessellationControl", "TessellationEvaluation", "Geometry"), Values("Triangles", "OutputVertices 3"), Values(SPV_ENV_UNIVERSAL_1_0))); INSTANTIATE_TEST_SUITE_P( ValidateModeGeometryAndTessellationBadSpv10, ValidateModeExecution, Combine(Values(SPV_ERROR_INVALID_DATA), Values("Execution mode can only be used with a Geometry or " "tessellation execution model."), Values("Fragment", "GLCompute", "Vertex", "Kernel"), Values("Triangles", "OutputVertices 3"), Values(SPV_ENV_UNIVERSAL_1_0))); INSTANTIATE_TEST_SUITE_P( ValidateModeFragmentOnlyGoodSpv10, ValidateModeExecution, Combine(Values(SPV_SUCCESS), Values(""), Values("Fragment"), Values("PixelCenterInteger", "OriginUpperLeft", "OriginLowerLeft", "EarlyFragmentTests", "DepthReplacing", "DepthLess", "DepthUnchanged"), Values(SPV_ENV_UNIVERSAL_1_0))); INSTANTIATE_TEST_SUITE_P( ValidateModeFragmentOnlyBadSpv10, ValidateModeExecution, Combine(Values(SPV_ERROR_INVALID_DATA), Values("Execution mode can only be used with the Fragment " "execution model."), Values("Geometry", "TessellationControl", "TessellationEvaluation", "GLCompute", "Vertex", "Kernel"), Values("PixelCenterInteger", "OriginUpperLeft", "OriginLowerLeft", "EarlyFragmentTests", "DepthReplacing", "DepthGreater", "DepthLess", "DepthUnchanged"), Values(SPV_ENV_UNIVERSAL_1_0))); INSTANTIATE_TEST_SUITE_P(ValidateModeFragmentOnlyGoodSpv15, ValidateModeExecution, Combine(Values(SPV_SUCCESS), Values(""), Values("Fragment"), Values("NonCoherentColorAttachmentReadEXT", "NonCoherentDepthAttachmentReadEXT", "NonCoherentStencilAttachmentReadEXT"), Values(SPV_ENV_UNIVERSAL_1_5))); INSTANTIATE_TEST_SUITE_P( ValidateModeFragmentOnlyBadSpv15, ValidateModeExecution, Combine(Values(SPV_ERROR_INVALID_DATA), Values("Execution mode can only be used with the Fragment " "execution model."), Values("Geometry", "TessellationControl", "TessellationEvaluation", "GLCompute", "Vertex", "Kernel"), Values("NonCoherentColorAttachmentReadEXT", "NonCoherentDepthAttachmentReadEXT", "NonCoherentStencilAttachmentReadEXT"), Values(SPV_ENV_UNIVERSAL_1_5))); INSTANTIATE_TEST_SUITE_P(ValidateModeKernelOnlyGoodSpv13, ValidateModeExecution, Combine(Values(SPV_SUCCESS), Values(""), Values("Kernel"), Values("LocalSizeHint 1 1 1", "VecTypeHint 4", "ContractionOff", "LocalSizeHintId %int1 %int1 %int1"), Values(SPV_ENV_UNIVERSAL_1_3))); INSTANTIATE_TEST_SUITE_P( ValidateModeKernelOnlyBadSpv13, ValidateModeExecution, Combine( Values(SPV_ERROR_INVALID_DATA), Values( "Execution mode can only be used with the Kernel execution model."), Values("Geometry", "TessellationControl", "TessellationEvaluation", "GLCompute", "Vertex", "Fragment"), Values("LocalSizeHint 1 1 1", "VecTypeHint 4", "ContractionOff", "LocalSizeHintId %int1 %int1 %int1"), Values(SPV_ENV_UNIVERSAL_1_3))); INSTANTIATE_TEST_SUITE_P( ValidateModeGLComputeAndKernelGoodSpv13, ValidateModeExecution, Combine(Values(SPV_SUCCESS), Values(""), Values("Kernel", "GLCompute"), Values("LocalSize 1 1 1", "LocalSizeId %int1 %int1 %int1"), Values(SPV_ENV_UNIVERSAL_1_3))); INSTANTIATE_TEST_SUITE_P( ValidateModeGLComputeAndKernelBadSpv13, ValidateModeExecution, Combine(Values(SPV_ERROR_INVALID_DATA), Values("Execution mode can only be used with a Kernel or GLCompute " "execution model."), Values("Geometry", "TessellationControl", "TessellationEvaluation", "Fragment", "Vertex"), Values("LocalSize 1 1 1", "LocalSizeId %int1 %int1 %int1"), Values(SPV_ENV_UNIVERSAL_1_3))); INSTANTIATE_TEST_SUITE_P( ValidateModeAllGoodSpv13, ValidateModeExecution, Combine(Values(SPV_SUCCESS), Values(""), Values("Kernel", "GLCompute", "Geometry", "TessellationControl", "TessellationEvaluation", "Fragment", "Vertex"), Values("Xfb", "Initializer", "Finalizer", "SubgroupSize 1", "SubgroupsPerWorkgroup 1", "SubgroupsPerWorkgroupId %int1"), Values(SPV_ENV_UNIVERSAL_1_3))); TEST_F(ValidateModeExecution, MeshNVLocalSize) { const std::string spirv = R"( OpCapability Shader OpCapability MeshShadingNV OpExtension "SPV_NV_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint MeshNV %main "main" OpExecutionMode %main LocalSize 1 1 1 )" + kVoidFunction; CompileSuccessfully(spirv); EXPECT_THAT(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateModeExecution, TaskNVLocalSize) { const std::string spirv = R"( OpCapability Shader OpCapability MeshShadingNV OpExtension "SPV_NV_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint TaskNV %main "main" OpExecutionMode %main LocalSize 1 1 1 )" + kVoidFunction; CompileSuccessfully(spirv); EXPECT_THAT(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateModeExecution, MeshNVOutputPoints) { const std::string spirv = R"( OpCapability Shader OpCapability MeshShadingNV OpExtension "SPV_NV_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint MeshNV %main "main" OpExecutionMode %main OutputPoints )" + kVoidFunction; CompileSuccessfully(spirv); EXPECT_THAT(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateModeExecution, MeshEXTOutputVertices) { const std::string spirv = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %main "main" OpExecutionMode %main LocalSize 1 1 1 OpExecutionMode %main OutputVertices 3 OpExecutionMode %main OutputPrimitivesNV 1 OpExecutionMode %main OutputTrianglesNV OpSource GLSL 460 OpSourceExtension "GL_EXT_mesh_shader" OpName %main "main" OpDecorate %gl_WorkGroupSize BuiltIn WorkgroupSize %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_3 = OpConstant %uint 3 %uint_1 = OpConstant %uint 1 %v3uint = OpTypeVector %uint 3 %gl_WorkGroupSize = OpConstantComposite %v3uint %uint_1 %uint_1 %uint_1 %main = OpFunction %void None %3 %5 = OpLabel OpSetMeshOutputsEXT %uint_3 %uint_1 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4); EXPECT_THAT(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); } TEST_F(ValidateModeExecution, VulkanBadMeshEXTOutputVertices) { const std::string spirv = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %main "main" OpExecutionMode %main LocalSize 1 1 1 OpExecutionMode %main OutputVertices 0 OpExecutionMode %main OutputPrimitivesNV 1 OpExecutionMode %main OutputTrianglesNV OpSource GLSL 460 OpSourceExtension "GL_EXT_mesh_shader" OpName %main "main" OpDecorate %gl_WorkGroupSize BuiltIn WorkgroupSize %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_3 = OpConstant %uint 3 %uint_1 = OpConstant %uint 1 %v3uint = OpTypeVector %uint 3 %gl_WorkGroupSize = OpConstantComposite %v3uint %uint_1 %uint_1 %uint_1 %main = OpFunction %void None %3 %5 = OpLabel OpSetMeshOutputsEXT %uint_3 %uint_1 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_2); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-MeshEXT-07330")); } TEST_F(ValidateModeExecution, VulkanBadMeshEXTOutputOutputPrimitivesEXT) { const std::string spirv = R"( OpCapability MeshShadingEXT OpExtension "SPV_EXT_mesh_shader" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint MeshEXT %main "main" OpExecutionMode %main LocalSize 1 1 1 OpExecutionMode %main OutputVertices 1 OpExecutionMode %main OutputPrimitivesNV 0 OpExecutionMode %main OutputTrianglesNV OpSource GLSL 460 OpSourceExtension "GL_EXT_mesh_shader" OpName %main "main" OpDecorate %gl_WorkGroupSize BuiltIn WorkgroupSize %void = OpTypeVoid %3 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_3 = OpConstant %uint 3 %uint_1 = OpConstant %uint 1 %v3uint = OpTypeVector %uint 3 %gl_WorkGroupSize = OpConstantComposite %v3uint %uint_1 %uint_1 %uint_1 %main = OpFunction %void None %3 %5 = OpLabel OpSetMeshOutputsEXT %uint_3 %uint_1 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_2); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-MeshEXT-07331")); } TEST_F(ValidateModeExecution, MeshNVOutputVertices) { const std::string spirv = R"( OpCapability Shader OpCapability MeshShadingNV OpExtension "SPV_NV_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint MeshNV %main "main" OpExecutionMode %main OutputVertices 42 )" + kVoidFunction; CompileSuccessfully(spirv); EXPECT_THAT(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateModeExecution, MeshNVLocalSizeId) { const std::string spirv = R"( OpCapability Shader OpCapability MeshShadingNV OpExtension "SPV_NV_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint MeshNV %main "main" OpExecutionModeId %main LocalSizeId %int_1 %int_1 %int_1 %int = OpTypeInt 32 0 %int_1 = OpConstant %int 1 )" + kVoidFunction; spv_target_env env = SPV_ENV_UNIVERSAL_1_3; CompileSuccessfully(spirv, env); EXPECT_THAT(SPV_SUCCESS, ValidateInstructions(env)); } TEST_F(ValidateModeExecution, TaskNVLocalSizeId) { const std::string spirv = R"( OpCapability Shader OpCapability MeshShadingNV OpExtension "SPV_NV_mesh_shader" OpMemoryModel Logical GLSL450 OpEntryPoint TaskNV %main "main" OpExecutionModeId %main LocalSizeId %int_1 %int_1 %int_1 %int = OpTypeInt 32 0 %int_1 = OpConstant %int 1 )" + kVoidFunction; spv_target_env env = SPV_ENV_UNIVERSAL_1_3; CompileSuccessfully(spirv, env); EXPECT_THAT(SPV_SUCCESS, ValidateInstructions(env)); } TEST_F(ValidateModeExecution, ExecModeSubgroupsPerWorkgroupIdBad) { const std::string spirv = R"( OpCapability Shader OpCapability SubgroupDispatch OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpExecutionMode %main SubgroupsPerWorkgroupId %int_1 %int = OpTypeInt 32 0 %int_1 = OpConstant %int 1 )" + kVoidFunction; spv_target_env env = SPV_ENV_UNIVERSAL_1_3; CompileSuccessfully(spirv, env); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions(env)); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpExecutionMode is only valid when the Mode operand " "is an execution mode that takes no Extra Operands")); } TEST_F(ValidateModeExecution, ExecModeIdSubgroupsPerWorkgroupIdGood) { const std::string spirv = R"( OpCapability Shader OpCapability SubgroupDispatch OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpExecutionModeId %main SubgroupsPerWorkgroupId %int_1 %int = OpTypeInt 32 0 %int_1 = OpConstant %int 1 )" + kVoidFunction; spv_target_env env = SPV_ENV_UNIVERSAL_1_3; CompileSuccessfully(spirv, env); EXPECT_THAT(SPV_SUCCESS, ValidateInstructions(env)); } TEST_F(ValidateModeExecution, ExecModeIdSubgroupsPerWorkgroupIdNonConstantBad) { const std::string spirv = R"( OpCapability Shader OpCapability SubgroupDispatch OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpExecutionModeId %main SubgroupsPerWorkgroupId %int_1 %int = OpTypeInt 32 0 %int_ptr = OpTypePointer Private %int %int_1 = OpVariable %int_ptr Private )" + kVoidFunction; spv_target_env env = SPV_ENV_UNIVERSAL_1_3; CompileSuccessfully(spirv, env); EXPECT_THAT(SPV_ERROR_INVALID_ID, ValidateInstructions(env)); EXPECT_THAT(getDiagnosticString(), HasSubstr("For OpExecutionModeId all Extra Operand ids must be " "constant instructions.")); } TEST_F(ValidateModeExecution, ExecModeLocalSizeHintIdBad) { const std::string spirv = R"( OpCapability Kernel OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Kernel %main "main" OpExecutionMode %main LocalSizeHintId %int_1 %int_1 %int_1 %int = OpTypeInt 32 0 %int_1 = OpConstant %int 1 )" + kVoidFunction; spv_target_env env = SPV_ENV_UNIVERSAL_1_3; CompileSuccessfully(spirv, env); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions(env)); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpExecutionMode is only valid when the Mode operand " "is an execution mode that takes no Extra Operands")); } TEST_F(ValidateModeExecution, ExecModeIdLocalSizeHintIdGood) { const std::string spirv = R"( OpCapability Kernel OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Kernel %main "main" OpExecutionModeId %main LocalSizeHintId %int_1 %int_1 %int_1 %int = OpTypeInt 32 0 %int_1 = OpConstant %int 1 )" + kVoidFunction; spv_target_env env = SPV_ENV_UNIVERSAL_1_3; CompileSuccessfully(spirv, env); EXPECT_THAT(SPV_SUCCESS, ValidateInstructions(env)); } TEST_F(ValidateModeExecution, ExecModeIdLocalSizeHintIdNonConstantBad) { const std::string spirv = R"( OpCapability Kernel OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpExecutionModeId %main LocalSizeHintId %int_1 %int_1 %int_1 %int = OpTypeInt 32 0 %int_ptr = OpTypePointer Private %int %int_1 = OpVariable %int_ptr Private )" + kVoidFunction; spv_target_env env = SPV_ENV_UNIVERSAL_1_3; CompileSuccessfully(spirv, env); EXPECT_THAT(SPV_ERROR_INVALID_ID, ValidateInstructions(env)); EXPECT_THAT(getDiagnosticString(), HasSubstr("For OpExecutionModeId all Extra Operand ids must be " "constant instructions.")); } TEST_F(ValidateModeExecution, ExecModeLocalSizeIdBad) { const std::string spirv = R"( OpCapability Kernel OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Kernel %main "main" OpExecutionMode %main LocalSizeId %int_1 %int_1 %int_1 %int = OpTypeInt 32 0 %int_1 = OpConstant %int 1 )" + kVoidFunction; spv_target_env env = SPV_ENV_UNIVERSAL_1_3; CompileSuccessfully(spirv, env); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions(env)); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpExecutionMode is only valid when the Mode operand " "is an execution mode that takes no Extra Operands")); } TEST_F(ValidateModeExecution, ExecModeIdLocalSizeIdGood) { const std::string spirv = R"( OpCapability Kernel OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Kernel %main "main" OpExecutionModeId %main LocalSizeId %int_1 %int_1 %int_1 %int = OpTypeInt 32 0 %int_1 = OpConstant %int 1 )" + kVoidFunction; spv_target_env env = SPV_ENV_UNIVERSAL_1_3; CompileSuccessfully(spirv, env); EXPECT_THAT(SPV_SUCCESS, ValidateInstructions(env)); } TEST_F(ValidateModeExecution, ExecModeIdLocalSizeIdNonConstantBad) { const std::string spirv = R"( OpCapability Kernel OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpExecutionModeId %main LocalSizeId %int_1 %int_1 %int_1 %int = OpTypeInt 32 0 %int_ptr = OpTypePointer Private %int %int_1 = OpVariable %int_ptr Private )" + kVoidFunction; spv_target_env env = SPV_ENV_UNIVERSAL_1_3; CompileSuccessfully(spirv, env); EXPECT_THAT(SPV_ERROR_INVALID_ID, ValidateInstructions(env)); EXPECT_THAT(getDiagnosticString(), HasSubstr("For OpExecutionModeId all Extra Operand ids must be " "constant instructions.")); } using AllowMultipleExecutionModes = spvtest::ValidateBase; TEST_P(AllowMultipleExecutionModes, DifferentOperand) { const std::string mode = GetParam(); const std::string spirv = R"( OpCapability Shader OpCapability DenormPreserve OpCapability DenormFlushToZero OpCapability SignedZeroInfNanPreserve OpCapability RoundingModeRTE OpCapability RoundingModeRTZ OpExtension "SPV_KHR_float_controls" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpExecutionMode %main )" + mode + R"( 16 OpExecutionMode %main )" + mode + R"( 32 %void = OpTypeVoid %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(AllowMultipleExecutionModes, SameOperand) { const std::string mode = GetParam(); const std::string spirv = R"( OpCapability Shader OpCapability DenormPreserve OpCapability DenormFlushToZero OpCapability SignedZeroInfNanPreserve OpCapability RoundingModeRTE OpCapability RoundingModeRTZ OpExtension "SPV_KHR_float_controls" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpExecutionMode %main )" + mode + R"( 32 OpExecutionMode %main )" + mode + R"( 32 %void = OpTypeVoid %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("execution mode must not be specified multiple times " "for the same entry point and operands")); } INSTANTIATE_TEST_SUITE_P(MultipleFloatControlsExecModes, AllowMultipleExecutionModes, Values("DenormPreserve", "DenormFlushToZero", "SignedZeroInfNanPreserve", "RoundingModeRTE", "RoundingModeRTZ")); using MultipleExecModes = spvtest::ValidateBase; TEST_P(MultipleExecModes, DuplicateMode) { const std::string mode = GetParam(); const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpExecutionMode %main )" + mode + R"( OpExecutionMode %main )" + mode + R"( %void = OpTypeVoid %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("execution mode must not be specified multiple times " "per entry point")); } INSTANTIATE_TEST_SUITE_P(MultipleFragmentExecMode, MultipleExecModes, Values("DepthReplacing", "DepthGreater", "DepthLess", "DepthUnchanged")); TEST_F(ValidateMode, FloatControls2FPFastMathDefaultSameOperand) { const std::string spirv = R"( OpCapability Shader OpCapability FloatControls2 OpExtension "SPV_KHR_float_controls2" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpExecutionModeId %main FPFastMathDefault %float %none OpExecutionModeId %main FPFastMathDefault %float %none %void = OpTypeVoid %float = OpTypeFloat 32 %int = OpTypeInt 32 0 %none = OpConstant %int 0 %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_2); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_2)); EXPECT_THAT(getDiagnosticString(), HasSubstr("execution mode must not be specified multiple times " "for the same entry point and operands")); } TEST_F(ValidateMode, FloatControls2FPFastMathDefaultDifferentOperand) { const std::string spirv = R"( OpCapability Shader OpCapability Float16 OpCapability FloatControls2 OpExtension "SPV_KHR_float_controls2" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpExecutionModeId %main FPFastMathDefault %float %none OpExecutionModeId %main FPFastMathDefault %half %none %void = OpTypeVoid %float = OpTypeFloat 32 %int = OpTypeInt 32 0 %none = OpConstant %int 0 %half = OpTypeFloat 16 %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_2)); } TEST_F(ValidateMode, FragmentShaderInterlockVertexBad) { const std::string spirv = R"( OpCapability Shader OpCapability FragmentShaderPixelInterlockEXT OpExtension "SPV_EXT_fragment_shader_interlock" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" OpExecutionMode %main PixelInterlockOrderedEXT )" + kVoidFunction; CompileSuccessfully(spirv); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Execution mode can only be used with the Fragment execution model")); } TEST_F(ValidateMode, FragmentShaderInterlockTooManyModesBad) { const std::string spirv = R"( OpCapability Shader OpCapability FragmentShaderPixelInterlockEXT OpCapability FragmentShaderSampleInterlockEXT OpExtension "SPV_EXT_fragment_shader_interlock" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpExecutionMode %main PixelInterlockOrderedEXT OpExecutionMode %main SampleInterlockOrderedEXT )" + kVoidFunction; CompileSuccessfully(spirv); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Fragment execution model entry points can specify at most " "one fragment shader interlock execution mode")); } TEST_F(ValidateMode, FragmentShaderInterlockNoModeBad) { const std::string spirv = R"( OpCapability Shader OpCapability FragmentShaderPixelInterlockEXT OpExtension "SPV_EXT_fragment_shader_interlock" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entryf = OpLabel OpBeginInvocationInterlockEXT OpEndInvocationInterlockEXT OpReturn OpFunctionEnd %main = OpFunction %void None %void_fn %entry = OpLabel %1 = OpFunctionCall %void %func OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_THAT(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpBeginInvocationInterlockEXT/OpEndInvocationInterlockEXT require a " "fragment shader interlock execution mode")); } TEST_F(ValidateMode, FragmentShaderInterlockGood) { const std::string spirv = R"( OpCapability Shader OpCapability FragmentShaderPixelInterlockEXT OpExtension "SPV_EXT_fragment_shader_interlock" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpExecutionMode %main PixelInterlockOrderedEXT %void = OpTypeVoid %void_fn = OpTypeFunction %void %func = OpFunction %void None %void_fn %entryf = OpLabel OpBeginInvocationInterlockEXT OpEndInvocationInterlockEXT OpReturn OpFunctionEnd %main = OpFunction %void None %void_fn %entry = OpLabel %1 = OpFunctionCall %void %func OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_THAT(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateMode, FragmentShaderStencilRefFrontTooManyModesBad) { const std::string spirv = R"( OpCapability Shader OpCapability StencilExportEXT OpExtension "SPV_AMD_shader_early_and_late_fragment_tests" OpExtension "SPV_EXT_shader_stencil_export" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpExecutionMode %main EarlyAndLateFragmentTestsAMD OpExecutionMode %main StencilRefLessFrontAMD OpExecutionMode %main StencilRefGreaterFrontAMD )" + kVoidFunction; CompileSuccessfully(spirv); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Fragment execution model entry points can specify at most " "one of StencilRefUnchangedFrontAMD, " "StencilRefLessFrontAMD or StencilRefGreaterFrontAMD " "execution modes.")); } TEST_F(ValidateMode, FragmentShaderStencilRefBackTooManyModesBad) { const std::string spirv = R"( OpCapability Shader OpCapability StencilExportEXT OpExtension "SPV_AMD_shader_early_and_late_fragment_tests" OpExtension "SPV_EXT_shader_stencil_export" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpExecutionMode %main EarlyAndLateFragmentTestsAMD OpExecutionMode %main StencilRefLessBackAMD OpExecutionMode %main StencilRefGreaterBackAMD )" + kVoidFunction; CompileSuccessfully(spirv); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Fragment execution model entry points can specify at most " "one of StencilRefUnchangedBackAMD, " "StencilRefLessBackAMD or StencilRefGreaterBackAMD " "execution modes.")); } TEST_F(ValidateMode, FragmentShaderStencilRefFrontGood) { const std::string spirv = R"( OpCapability Shader OpCapability StencilExportEXT OpExtension "SPV_AMD_shader_early_and_late_fragment_tests" OpExtension "SPV_EXT_shader_stencil_export" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpExecutionMode %main EarlyAndLateFragmentTestsAMD OpExecutionMode %main StencilRefLessFrontAMD )" + kVoidFunction; CompileSuccessfully(spirv); EXPECT_THAT(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateMode, FragmentShaderStencilRefBackGood) { const std::string spirv = R"( OpCapability Shader OpCapability StencilExportEXT OpExtension "SPV_AMD_shader_early_and_late_fragment_tests" OpExtension "SPV_EXT_shader_stencil_export" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpExecutionMode %main EarlyAndLateFragmentTestsAMD OpExecutionMode %main StencilRefLessBackAMD )" + kVoidFunction; CompileSuccessfully(spirv); EXPECT_THAT(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateMode, FragmentShaderDemoteVertexBad) { const std::string spirv = R"( OpCapability Shader OpCapability DemoteToHelperInvocationEXT OpExtension "SPV_EXT_demote_to_helper_invocation" OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" %bool = OpTypeBool %void = OpTypeVoid %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpDemoteToHelperInvocationEXT %1 = OpIsHelperInvocationEXT %bool OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_THAT(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpDemoteToHelperInvocationEXT requires Fragment execution model")); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpIsHelperInvocationEXT requires Fragment execution model")); } TEST_F(ValidateMode, FragmentShaderDemoteGood) { const std::string spirv = R"( OpCapability Shader OpCapability DemoteToHelperInvocationEXT OpExtension "SPV_EXT_demote_to_helper_invocation" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %bool = OpTypeBool %void = OpTypeVoid %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpDemoteToHelperInvocationEXT %1 = OpIsHelperInvocationEXT %bool OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_THAT(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateMode, FragmentShaderDemoteBadType) { const std::string spirv = R"( OpCapability Shader OpCapability DemoteToHelperInvocationEXT OpExtension "SPV_EXT_demote_to_helper_invocation" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %u32 = OpTypeInt 32 0 %void = OpTypeVoid %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpDemoteToHelperInvocationEXT %1 = OpIsHelperInvocationEXT %u32 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected bool scalar type as Result Type")); } TEST_F(ValidateMode, LocalSizeIdVulkan1p3DoesNotRequireOption) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionModeId %main LocalSizeId %int_1 %int_1 %int_1 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_1 = OpConstant %int 1 %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_3)); } TEST_F(ValidateMode, MaximalReconvergenceRequiresExtension) { const std::string spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpExecutionMode %main MaximallyReconvergesKHR %void = OpTypeVoid %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_MISSING_EXTENSION, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("(6023) requires one of these extensions: " "SPV_KHR_maximal_reconvergence ")); } TEST_F(ValidateMode, FPFastMathDefaultNotExecutionModeId) { const std::string spirv = R"( OpCapability Shader OpCapability FloatControls2 OpExtension "SPV_KHR_float_controls2" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpExecutionMode %main FPFastMathDefault %int_0 %int_0 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpExecutionMode is only valid when the Mode operand " "is an execution mode that takes no Extra Operands, or " "takes Extra Operands that are not id operands")); } TEST_F(ValidateMode, FPFastMathDefaultNotAType) { const std::string spirv = R"( OpCapability Shader OpCapability FloatControls2 OpExtension "SPV_KHR_float_controls2" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpExecutionModeId %main FPFastMathDefault %int_0 %int_0 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "The Target Type operand must be a floating-point scalar type")); } TEST_F(ValidateMode, FPFastMathDefaultNotAFloatType) { const std::string spirv = R"( OpCapability Shader OpCapability FloatControls2 OpExtension "SPV_KHR_float_controls2" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpExecutionModeId %main FPFastMathDefault %int %int_0 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "The Target Type operand must be a floating-point scalar type")); } TEST_F(ValidateMode, FPFastMathDefaultNotAFloatScalarType) { const std::string spirv = R"( OpCapability Shader OpCapability FloatControls2 OpExtension "SPV_KHR_float_controls2" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpExecutionModeId %main FPFastMathDefault %float2 %int_0 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %float = OpTypeFloat 32 %float2 = OpTypeVector %float 2 %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "The Target Type operand must be a floating-point scalar type")); } TEST_F(ValidateMode, FPFastMathDefaultSpecConstant) { const std::string spirv = R"( OpCapability Shader OpCapability FloatControls2 OpExtension "SPV_KHR_float_controls2" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpExecutionModeId %main FPFastMathDefault %float %int_0 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpSpecConstant %int 0 %float = OpTypeFloat 32 %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("The Fast Math Default operand must be a " "non-specialization constant")); } TEST_F(ValidateMode, FPFastMathDefaultInvalidMask) { const std::string spirv = R"( OpCapability Shader OpCapability FloatControls2 OpExtension "SPV_KHR_float_controls2" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpExecutionModeId %main FPFastMathDefault %float %constant %void = OpTypeVoid %int = OpTypeInt 32 0 %constant = OpConstant %int 524288 %float = OpTypeFloat 32 %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("The Fast Math Default operand is an invalid bitmask value")); } TEST_F(ValidateMode, FPFastMathDefaultContainsFast) { const std::string spirv = R"( OpCapability Shader OpCapability FloatControls2 OpExtension "SPV_KHR_float_controls2" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpExecutionModeId %main FPFastMathDefault %float %constant %void = OpTypeVoid %int = OpTypeInt 32 0 %constant = OpConstant %int 16 %float = OpTypeFloat 32 %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("The Fast Math Default operand must not include Fast")); } TEST_F(ValidateMode, FPFastMathDefaultAllowTransformMissingAllowReassoc) { const std::string spirv = R"( OpCapability Shader OpCapability FloatControls2 OpExtension "SPV_KHR_float_controls2" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpExecutionModeId %main FPFastMathDefault %float %constant %void = OpTypeVoid %int = OpTypeInt 32 0 %constant = OpConstant %int 327680 %float = OpTypeFloat 32 %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("The Fast Math Default operand must include AllowContract and " "AllowReassoc when AllowTransform is specified")); } TEST_F(ValidateMode, FPFastMathDefaultAllowTransformMissingAllowContract) { const std::string spirv = R"( OpCapability Shader OpCapability FloatControls2 OpExtension "SPV_KHR_float_controls2" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpExecutionModeId %main FPFastMathDefault %float %constant %void = OpTypeVoid %int = OpTypeInt 32 0 %constant = OpConstant %int 393216 %float = OpTypeFloat 32 %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("The Fast Math Default operand must include AllowContract and " "AllowReassoc when AllowTransform is specified")); } TEST_F(ValidateMode, FPFastMathDefaultAllowTransformMissingContractAndReassoc) { const std::string spirv = R"( OpCapability Shader OpCapability FloatControls2 OpExtension "SPV_KHR_float_controls2" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpExecutionModeId %main FPFastMathDefault %float %constant %void = OpTypeVoid %int = OpTypeInt 32 0 %constant = OpConstant %int 262144 %float = OpTypeFloat 32 %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("The Fast Math Default operand must include AllowContract and " "AllowReassoc when AllowTransform is specified")); } TEST_F(ValidateMode, FPFastMathDefaultSignedZeroInfNanPreserve) { const std::string spirv = R"( OpCapability Shader OpCapability FloatControls2 OpCapability SignedZeroInfNanPreserve OpExtension "SPV_KHR_float_controls2" OpExtension "SPV_KHR_float_controls" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpExecutionModeId %main FPFastMathDefault %float %constant OpExecutionMode %main SignedZeroInfNanPreserve 32 %void = OpTypeVoid %int = OpTypeInt 32 0 %constant = OpConstant %int 0 %float = OpTypeFloat 32 %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr("FPFastMathDefault and SignedZeroInfNanPreserve execution " "modes cannot be applied to the same entry point")); } TEST_F(ValidateMode, FPFastMathDefaultConractionOff) { const std::string spirv = R"( OpCapability Kernel OpCapability Addresses OpCapability FloatControls2 OpCapability SignedZeroInfNanPreserve OpExtension "SPV_KHR_float_controls2" OpExtension "SPV_KHR_float_controls" OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %main "main" OpExecutionModeId %main FPFastMathDefault %float %constant OpExecutionMode %main ContractionOff %void = OpTypeVoid %int = OpTypeInt 32 0 %constant = OpConstant %int 0 %float = OpTypeFloat 32 %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("FPFastMathDefault and ContractionOff execution modes " "cannot be applied to the same entry point")); } TEST_F(ValidateMode, FPFastMathDefaultNoContractionNotInCallTree) { const std::string spirv = R"( OpCapability Shader OpCapability FloatControls2 OpExtension "SPV_KHR_float_controls2" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionModeId %main FPFastMathDefault %float %constant OpExecutionMode %main LocalSize 1 1 1 OpDecorate %add NoContraction %void = OpTypeVoid %int = OpTypeInt 32 0 %constant = OpConstant %int 0 %float = OpTypeFloat 32 %zero = OpConstant %float 0 %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd %func = OpFunction %void None %void_fn %func_entry = OpLabel %add = OpFAdd %float %zero %zero OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateMode, FPFastMathDefaultNoContractionInCallTree) { const std::string spirv = R"( OpCapability Shader OpCapability FloatControls2 OpExtension "SPV_KHR_float_controls2" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionModeId %main FPFastMathDefault %float %constant OpExecutionMode %main LocalSize 1 1 1 OpDecorate %add NoContraction %void = OpTypeVoid %int = OpTypeInt 32 0 %constant = OpConstant %int 0 %float = OpTypeFloat 32 %zero = OpConstant %float 0 %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %call = OpFunctionCall %void %func OpReturn OpFunctionEnd %func = OpFunction %void None %void_fn %func_entry = OpLabel %add = OpFAdd %float %zero %zero OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("NoContraction cannot be used by an entry point with " "the FPFastMathDefault execution mode")); } TEST_F(ValidateMode, FPFastMathDefaultNoContractionInCallTree2) { const std::string spirv = R"( OpCapability Shader OpCapability Kernel OpCapability Addresses OpCapability FloatControls2 OpExtension "SPV_KHR_float_controls2" OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %main "main" OpExecutionModeId %main FPFastMathDefault %float %constant OpDecorate %const NoContraction %void = OpTypeVoid %int = OpTypeInt 32 0 %constant = OpConstant %int 0 %float = OpTypeFloat 32 %zero = OpConstant %float 0 %const = OpSpecConstantOp %float FAdd %zero %zero %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %call = OpFunctionCall %void %func OpReturn OpFunctionEnd %func = OpFunction %void None %void_fn %func_entry = OpLabel %add = OpFAdd %float %const %zero OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("NoContraction cannot be used by an entry point with " "the FPFastMathDefault execution mode")); } TEST_F(ValidateMode, FPFastMathDefaultFastMathFastNotInCallTree) { const std::string spirv = R"( OpCapability Shader OpCapability FloatControls2 OpExtension "SPV_KHR_float_controls2" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionModeId %main FPFastMathDefault %float %constant OpExecutionMode %main LocalSize 1 1 1 OpDecorate %add FPFastMathMode Fast %void = OpTypeVoid %int = OpTypeInt 32 0 %constant = OpConstant %int 0 %float = OpTypeFloat 32 %zero = OpConstant %float 0 %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd %func = OpFunction %void None %void_fn %func_entry = OpLabel %add = OpFAdd %float %zero %zero OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); } TEST_F(ValidateMode, FPFastMathDefaultFastMathFastInCallTree) { const std::string spirv = R"( OpCapability Shader OpCapability FloatControls2 OpExtension "SPV_KHR_float_controls2" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionModeId %main FPFastMathDefault %float %constant OpExecutionMode %main LocalSize 1 1 1 OpDecorate %add FPFastMathMode Fast %void = OpTypeVoid %int = OpTypeInt 32 0 %constant = OpConstant %int 0 %float = OpTypeFloat 32 %zero = OpConstant %float 0 %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %call = OpFunctionCall %void %func OpReturn OpFunctionEnd %func = OpFunction %void None %void_fn %func_entry = OpLabel %add = OpFAdd %float %zero %zero OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("FPFastMathMode Fast cannot be used by an entry point " "with the FPFastMathDefault execution mode")); } TEST_F(ValidateMode, FPFastMathDefaultFastMathFastInCallTree2) { const std::string spirv = R"( OpCapability Kernel OpCapability Addresses OpCapability FloatControls2 OpExtension "SPV_KHR_float_controls2" OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %main "main" OpExecutionModeId %main FPFastMathDefault %float %constant OpDecorate %const FPFastMathMode Fast %void = OpTypeVoid %int = OpTypeInt 32 0 %constant = OpConstant %int 0 %float = OpTypeFloat 32 %zero = OpConstant %float 0 %const = OpSpecConstantOp %float FAdd %zero %zero %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %call = OpFunctionCall %void %func OpReturn OpFunctionEnd %func = OpFunction %void None %void_fn %func_entry = OpLabel %add = OpFAdd %float %const %zero OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT(getDiagnosticString(), HasSubstr("FPFastMathMode Fast cannot be used by an entry point " "with the FPFastMathDefault execution mode")); } TEST_F(ValidateMode, FragmentShaderRequireFullQuadsKHR) { const std::string spirv = R"( OpCapability Shader OpCapability GroupNonUniform OpCapability GroupNonUniformVote OpCapability GroupNonUniformBallot OpCapability QuadControlKHR OpExtension "SPV_KHR_quad_control" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 OriginUpperLeft OpExecutionMode %4 RequireFullQuadsKHR OpDecorate %17 Location 0 OpDecorate %31 BuiltIn HelperInvocation OpDecorate %40 Location 0 OpDecorate %44 DescriptorSet 0 OpDecorate %44 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpTypeVector %6 4 %8 = OpTypePointer Function %7 %10 = OpTypeBool %11 = OpConstantTrue %10 %12 = OpConstant %6 7 %14 = OpTypeFloat 32 %15 = OpTypeVector %14 4 %16 = OpTypePointer Output %15 %17 = OpVariable %16 Output %18 = OpConstant %14 1 %19 = OpConstant %14 0 %20 = OpConstantComposite %15 %18 %19 %19 %18 %23 = OpConstant %6 4 %27 = OpConstant %6 1 %28 = OpTypePointer Output %14 %30 = OpTypePointer Input %10 %31 = OpVariable %30 Input %36 = OpConstant %6 2 %38 = OpTypeVector %14 2 %39 = OpTypePointer Input %38 %40 = OpVariable %39 Input %41 = OpTypeImage %14 2D 0 0 0 1 Unknown %42 = OpTypeSampledImage %41 %43 = OpTypePointer UniformConstant %42 %44 = OpVariable %43 UniformConstant %4 = OpFunction %2 None %3 %5 = OpLabel %9 = OpVariable %8 Function %13 = OpGroupNonUniformBallot %7 %12 %11 OpStore %9 %13 OpStore %17 %20 %21 = OpLoad %7 %9 %22 = OpGroupNonUniformBallotBitCount %6 %12 Reduce %21 %24 = OpIEqual %10 %22 %23 OpSelectionMerge %26 None OpBranchConditional %24 %25 %26 %25 = OpLabel %29 = OpAccessChain %28 %17 %27 OpStore %29 %18 OpBranch %26 %26 = OpLabel %32 = OpLoad %10 %31 %33 = OpGroupNonUniformAny %10 %12 %32 OpSelectionMerge %35 None OpBranchConditional %33 %34 %35 %34 = OpLabel %37 = OpAccessChain %28 %17 %36 OpStore %37 %18 OpBranch %35 %35 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Execution mode can only be used with the Fragment execution model")); } TEST_F(ValidateMode, FragmentShaderQuadDerivativesKHR) { const std::string spirv = R"( OpCapability Shader OpCapability GroupNonUniform OpCapability GroupNonUniformVote OpCapability QuadControlKHR OpExtension "SPV_KHR_quad_control" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 OriginUpperLeft OpExecutionMode %4 QuadDerivativesKHR OpDecorate %12 BuiltIn FragCoord OpDecorate %41 Location 0 OpDecorate %45 DescriptorSet 0 OpDecorate %45 Binding 0 OpDecorate %49 Location 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpTypePointer Function %6 %9 = OpTypeFloat 32 %10 = OpTypeVector %9 4 %11 = OpTypePointer Input %10 %12 = OpVariable %11 Input %13 = OpTypeInt 32 0 %14 = OpConstant %13 1 %15 = OpTypePointer Input %9 %18 = OpConstant %9 8.5 %21 = OpConstant %9 0.100000001 %25 = OpConstant %13 0 %28 = OpConstant %9 3.5 %30 = OpConstant %9 6 %36 = OpConstant %13 7 %40 = OpTypePointer Output %10 %41 = OpVariable %40 Output %42 = OpTypeImage %9 2D 0 0 0 1 Unknown %43 = OpTypeSampledImage %42 %44 = OpTypePointer UniformConstant %43 %45 = OpVariable %44 UniformConstant %47 = OpTypeVector %9 2 %48 = OpTypePointer Input %47 %49 = OpVariable %48 Input %53 = OpConstant %9 0.899999976 %54 = OpConstant %9 0.200000003 %55 = OpConstant %9 1 %56 = OpConstantComposite %10 %53 %54 %54 %55 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %16 = OpAccessChain %15 %12 %14 %17 = OpLoad %9 %16 %19 = OpFSub %9 %17 %18 %20 = OpExtInst %9 %1 FAbs %19 %22 = OpFOrdLessThan %6 %20 %21 OpSelectionMerge %24 None OpBranchConditional %22 %23 %24 %23 = OpLabel %26 = OpAccessChain %15 %12 %25 %27 = OpLoad %9 %26 %29 = OpFSub %9 %27 %28 %31 = OpFMod %9 %29 %30 %33 = OpFOrdLessThan %6 %31 %21 OpBranch %24 %24 = OpLabel %34 = OpPhi %6 %22 %5 %33 %23 OpStore %8 %34 %35 = OpLoad %6 %8 %37 = OpGroupNonUniformAny %6 %36 %35 OpSelectionMerge %39 None OpBranchConditional %37 %38 %52 %38 = OpLabel %46 = OpLoad %43 %45 %50 = OpLoad %47 %49 %51 = OpImageSampleImplicitLod %10 %46 %50 OpStore %41 %51 OpBranch %39 %52 = OpLabel OpStore %41 %56 OpBranch %39 %39 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Execution mode can only be used with the Fragment execution model")); } const std::string kNodeShaderPrelude = R"( OpCapability Shader OpCapability ShaderEnqueueAMDX OpExtension "SPV_AMDX_shader_enqueue" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpEntryPoint GLCompute %other "other" )"; const std::string kNodeShaderPostlude = R"( %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %uint_1 = OpConstant %uint 1 %node0 = OpConstantStringAMDX "node0" %node1 = OpConstantStringAMDX "node1" %node2 = OpConstantStringAMDX "node2" %S = OpTypeStruct %_payloadarr_S = OpTypeNodePayloadArrayAMDX %S %_payloadarr_S_0 = OpTypeNodePayloadArrayAMDX %S %bool = OpTypeBool %true = OpConstantTrue %bool %void = OpTypeVoid %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd %other = OpFunction %void None %void_fn %entry0 = OpLabel OpReturn OpFunctionEnd )"; TEST_F(ValidateMode, NodeShader) { const std::string spirv = kNodeShaderPrelude + R"( OpExecutionModeId %main ShaderIndexAMDX %uint_0 OpExecutionModeId %main IsApiEntryAMDX %true OpExecutionModeId %main MaxNodeRecursionAMDX %uint_1 OpExecutionModeId %main MaxNumWorkgroupsAMDX %uint_1 %uint_1 %uint_1 OpExecutionModeId %main SharesInputWithAMDX %node0 %uint_0 OpExecutionModeId %other ShaderIndexAMDX %uint_0 OpExecutionModeId %other StaticNumWorkgroupsAMDX %uint_1 %uint_1 %uint_1 OpDecorateId %_payloadarr_S PayloadNodeNameAMDX %node1 OpDecorateId %_payloadarr_S_0 PayloadNodeNameAMDX %node2 OpDecorateId %_payloadarr_S PayloadNodeBaseIndexAMDX %uint_0 OpDecorateId %_payloadarr_S PayloadNodeArraySizeAMDX %uint_1 OpDecorateId %_payloadarr_S NodeSharesPayloadLimitsWithAMDX %_payloadarr_S_0 )" + kNodeShaderPostlude; spv_target_env env = SPV_ENV_UNIVERSAL_1_3; CompileSuccessfully(spirv, env); EXPECT_THAT(SPV_SUCCESS, ValidateInstructions(env)); } TEST_F(ValidateMode, NodeShaderModeShaderIndex) { const std::string spirv = kNodeShaderPrelude + R"( OpExecutionMode %main ShaderIndexAMDX %uint_0 OpExecutionModeId %main IsApiEntryAMDX %true OpExecutionModeId %main MaxNodeRecursionAMDX %uint_1 OpExecutionModeId %main MaxNumWorkgroupsAMDX %uint_1 %uint_1 %uint_1 OpExecutionModeId %main SharesInputWithAMDX %node0 %uint_0 OpExecutionMode %other ShaderIndexAMDX %uint_0 OpExecutionModeId %other StaticNumWorkgroupsAMDX %uint_1 %uint_1 %uint_1 OpDecorateId %_payloadarr_S PayloadNodeNameAMDX %node1 OpDecorateId %_payloadarr_S_0 PayloadNodeNameAMDX %node2 OpDecorateId %_payloadarr_S PayloadNodeBaseIndexAMDX %uint_0 OpDecorateId %_payloadarr_S PayloadNodeArraySizeAMDX %uint_1 OpDecorateId %_payloadarr_S NodeSharesPayloadLimitsWithAMDX %_payloadarr_S_0 )" + kNodeShaderPostlude; spv_target_env env = SPV_ENV_UNIVERSAL_1_3; CompileSuccessfully(spirv, env); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions(env)); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpExecutionMode is only valid when the Mode operand is an " "execution mode that takes no Extra Operands, or takes Extra " "Operands that are not id operands")); } TEST_F(ValidateMode, NodeShaderModeIsApiEntry) { const std::string spirv = kNodeShaderPrelude + R"( OpExecutionModeId %main ShaderIndexAMDX %uint_0 OpExecutionMode %main IsApiEntryAMDX %true OpExecutionModeId %main MaxNodeRecursionAMDX %uint_1 OpExecutionModeId %main MaxNumWorkgroupsAMDX %uint_1 %uint_1 %uint_1 OpExecutionModeId %main SharesInputWithAMDX %node0 %uint_0 OpExecutionModeId %other ShaderIndexAMDX %uint_0 OpExecutionModeId %other StaticNumWorkgroupsAMDX %uint_1 %uint_1 %uint_1 OpDecorateId %_payloadarr_S PayloadNodeNameAMDX %node1 OpDecorateId %_payloadarr_S_0 PayloadNodeNameAMDX %node2 OpDecorateId %_payloadarr_S PayloadNodeBaseIndexAMDX %uint_0 OpDecorateId %_payloadarr_S PayloadNodeArraySizeAMDX %uint_1 OpDecorateId %_payloadarr_S NodeSharesPayloadLimitsWithAMDX %_payloadarr_S_0 )" + kNodeShaderPostlude; spv_target_env env = SPV_ENV_UNIVERSAL_1_3; CompileSuccessfully(spirv, env); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions(env)); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpExecutionMode is only valid when the Mode operand is an " "execution mode that takes no Extra Operands, or takes Extra " "Operands that are not id operands")); } TEST_F(ValidateMode, NodeShaderModeMaxNodeRecursion) { const std::string spirv = kNodeShaderPrelude + R"( OpExecutionModeId %main ShaderIndexAMDX %uint_0 OpExecutionModeId %main IsApiEntryAMDX %true OpExecutionMode %main MaxNodeRecursionAMDX %uint_1 OpExecutionModeId %main MaxNumWorkgroupsAMDX %uint_1 %uint_1 %uint_1 OpExecutionModeId %main SharesInputWithAMDX %node0 %uint_0 OpExecutionModeId %other ShaderIndexAMDX %uint_0 OpExecutionModeId %other StaticNumWorkgroupsAMDX %uint_1 %uint_1 %uint_1 OpDecorateId %_payloadarr_S PayloadNodeNameAMDX %node1 OpDecorateId %_payloadarr_S_0 PayloadNodeNameAMDX %node2 OpDecorateId %_payloadarr_S PayloadNodeBaseIndexAMDX %uint_0 OpDecorateId %_payloadarr_S PayloadNodeArraySizeAMDX %uint_1 OpDecorateId %_payloadarr_S NodeSharesPayloadLimitsWithAMDX %_payloadarr_S_0 )" + kNodeShaderPostlude; spv_target_env env = SPV_ENV_UNIVERSAL_1_3; CompileSuccessfully(spirv, env); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions(env)); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpExecutionMode is only valid when the Mode operand is an " "execution mode that takes no Extra Operands, or takes Extra " "Operands that are not id operands")); } TEST_F(ValidateMode, NodeShaderModeMaxNumWorkgroups) { const std::string spirv = kNodeShaderPrelude + R"( OpExecutionModeId %main ShaderIndexAMDX %uint_0 OpExecutionModeId %main IsApiEntryAMDX %true OpExecutionModeId %main MaxNodeRecursionAMDX %uint_1 OpExecutionMode %main MaxNumWorkgroupsAMDX %uint_1 %uint_1 %uint_1 OpExecutionModeId %main SharesInputWithAMDX %node0 %uint_0 OpExecutionModeId %other ShaderIndexAMDX %uint_0 OpExecutionModeId %other StaticNumWorkgroupsAMDX %uint_1 %uint_1 %uint_1 OpDecorateId %_payloadarr_S PayloadNodeNameAMDX %node1 OpDecorateId %_payloadarr_S_0 PayloadNodeNameAMDX %node2 OpDecorateId %_payloadarr_S PayloadNodeBaseIndexAMDX %uint_0 OpDecorateId %_payloadarr_S PayloadNodeArraySizeAMDX %uint_1 OpDecorateId %_payloadarr_S NodeSharesPayloadLimitsWithAMDX %_payloadarr_S_0 )" + kNodeShaderPostlude; spv_target_env env = SPV_ENV_UNIVERSAL_1_3; CompileSuccessfully(spirv, env); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions(env)); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpExecutionMode is only valid when the Mode operand is an " "execution mode that takes no Extra Operands, or takes Extra " "Operands that are not id operands")); } TEST_F(ValidateMode, NodeShaderModeStaticNumWorkgroups) { const std::string spirv = kNodeShaderPrelude + R"( OpExecutionModeId %main ShaderIndexAMDX %uint_0 OpExecutionModeId %main IsApiEntryAMDX %true OpExecutionModeId %main MaxNodeRecursionAMDX %uint_1 OpExecutionModeId %main MaxNumWorkgroupsAMDX %uint_1 %uint_1 %uint_1 OpExecutionModeId %main SharesInputWithAMDX %node0 %uint_0 OpExecutionModeId %other ShaderIndexAMDX %uint_0 OpExecutionMode %other StaticNumWorkgroupsAMDX %uint_1 %uint_1 %uint_1 OpDecorateId %_payloadarr_S PayloadNodeNameAMDX %node1 OpDecorateId %_payloadarr_S_0 PayloadNodeNameAMDX %node2 OpDecorateId %_payloadarr_S PayloadNodeBaseIndexAMDX %uint_0 OpDecorateId %_payloadarr_S PayloadNodeArraySizeAMDX %uint_1 OpDecorateId %_payloadarr_S NodeSharesPayloadLimitsWithAMDX %_payloadarr_S_0 )" + kNodeShaderPostlude; spv_target_env env = SPV_ENV_UNIVERSAL_1_3; CompileSuccessfully(spirv, env); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions(env)); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpExecutionMode is only valid when the Mode operand is an " "execution mode that takes no Extra Operands, or takes Extra " "Operands that are not id operands")); } TEST_F(ValidateMode, NodeShaderModeSharesInputWith) { const std::string spirv = kNodeShaderPrelude + R"( OpExecutionModeId %main ShaderIndexAMDX %uint_0 OpExecutionModeId %main IsApiEntryAMDX %true OpExecutionModeId %main MaxNodeRecursionAMDX %uint_1 OpExecutionModeId %main MaxNumWorkgroupsAMDX %uint_1 %uint_1 %uint_1 OpExecutionMode %main SharesInputWithAMDX %node0 %uint_0 OpExecutionModeId %other ShaderIndexAMDX %uint_0 OpExecutionModeId %other StaticNumWorkgroupsAMDX %uint_1 %uint_1 %uint_1 OpDecorateId %_payloadarr_S PayloadNodeNameAMDX %node1 OpDecorateId %_payloadarr_S_0 PayloadNodeNameAMDX %node2 OpDecorateId %_payloadarr_S PayloadNodeBaseIndexAMDX %uint_0 OpDecorateId %_payloadarr_S PayloadNodeArraySizeAMDX %uint_1 OpDecorateId %_payloadarr_S NodeSharesPayloadLimitsWithAMDX %_payloadarr_S_0 )" + kNodeShaderPostlude; spv_target_env env = SPV_ENV_UNIVERSAL_1_3; CompileSuccessfully(spirv, env); EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions(env)); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpExecutionMode is only valid when the Mode operand is an " "execution mode that takes no Extra Operands, or takes Extra " "Operands that are not id operands")); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_non_semantic_test.cpp000066400000000000000000000172341475742701700253630ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validation tests for non-semantic instructions #include #include #include "gmock/gmock.h" #include "test/unit_spirv.h" #include "test/val/val_code_generator.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { struct TestResult { TestResult(spv_result_t in_validation_result = SPV_SUCCESS, const char* in_error_str = nullptr, const char* in_error_str2 = nullptr) : validation_result(in_validation_result), error_str(in_error_str), error_str2(in_error_str2) {} spv_result_t validation_result; const char* error_str; const char* error_str2; }; using ::testing::Combine; using ::testing::HasSubstr; using ::testing::Values; using ::testing::ValuesIn; using ValidateNonSemanticGenerated = spvtest::ValidateBase< std::tuple>; using ValidateNonSemanticString = spvtest::ValidateBase; CodeGenerator GetNonSemanticCodeGenerator(const bool declare_ext, const bool declare_extinst, const char* const global_extinsts, const char* const function_extinsts) { CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator(); if (declare_ext) { generator.extensions_ += "OpExtension \"SPV_KHR_non_semantic_info\"\n"; } if (declare_extinst) { generator.extensions_ += "%extinst = OpExtInstImport \"NonSemantic.Testing.Set\"\n"; } generator.after_types_ = global_extinsts; generator.before_types_ = "%decorate_group = OpDecorationGroup"; EntryPoint entry_point; entry_point.name = "main"; entry_point.execution_model = "Vertex"; entry_point.body = R"( )"; entry_point.body += function_extinsts; generator.entry_points_.push_back(std::move(entry_point)); return generator; } TEST_P(ValidateNonSemanticGenerated, InTest) { const bool declare_ext = std::get<0>(GetParam()); const bool declare_extinst = std::get<1>(GetParam()); const char* const global_extinsts = std::get<2>(GetParam()); const char* const function_extinsts = std::get<3>(GetParam()); const TestResult& test_result = std::get<4>(GetParam()); CodeGenerator generator = GetNonSemanticCodeGenerator( declare_ext, declare_extinst, global_extinsts, function_extinsts); CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(test_result.validation_result, ValidateInstructions(SPV_ENV_VULKAN_1_0)); if (test_result.error_str) { EXPECT_THAT(getDiagnosticString(), testing::ContainsRegex(test_result.error_str)); } if (test_result.error_str2) { EXPECT_THAT(getDiagnosticString(), testing::ContainsRegex(test_result.error_str2)); } } INSTANTIATE_TEST_SUITE_P(OnlyOpExtension, ValidateNonSemanticGenerated, Combine(Values(true), Values(false), Values(""), Values(""), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( MissingOpExtensionPre1p6, ValidateNonSemanticGenerated, Combine(Values(false), Values(true), Values(""), Values(""), Values(TestResult( SPV_ERROR_INVALID_DATA, "NonSemantic extended instruction sets cannot be declared " "without SPV_KHR_non_semantic_info.")))); INSTANTIATE_TEST_SUITE_P(NoExtInst, ValidateNonSemanticGenerated, Combine(Values(true), Values(true), Values(""), Values(""), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( SimpleGlobalExtInst, ValidateNonSemanticGenerated, Combine(Values(true), Values(true), Values("%result = OpExtInst %void %extinst 123 %i32"), Values(""), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( ComplexGlobalExtInst, ValidateNonSemanticGenerated, Combine(Values(true), Values(true), Values("%result = OpExtInst %void %extinst 123 %i32 %u32_2 " "%f32vec4_1234 %u32_0"), Values(""), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( SimpleFunctionLevelExtInst, ValidateNonSemanticGenerated, Combine(Values(true), Values(true), Values(""), Values("%result = OpExtInst %void %extinst 123 %i32"), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( FunctionTypeReference, ValidateNonSemanticGenerated, Combine(Values(true), Values(true), Values("%result = OpExtInst %void %extinst 123 %func"), Values(""), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( EntryPointReference, ValidateNonSemanticGenerated, Combine(Values(true), Values(true), Values(""), Values("%result = OpExtInst %void %extinst 123 %main"), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( DecorationGroupReference, ValidateNonSemanticGenerated, Combine(Values(true), Values(true), Values(""), Values("%result = OpExtInst %void %extinst 123 %decorate_group"), Values(TestResult()))); INSTANTIATE_TEST_SUITE_P( UnknownIDReference, ValidateNonSemanticGenerated, Combine(Values(true), Values(true), Values("%result = OpExtInst %void %extinst 123 %undefined_id"), Values(""), Values(TestResult(SPV_ERROR_INVALID_ID, "ID .* has not been defined")))); INSTANTIATE_TEST_SUITE_P( NonSemanticUseInSemantic, ValidateNonSemanticGenerated, Combine(Values(true), Values(true), Values("%result = OpExtInst %f32 %extinst 123 %i32\n" "%invalid = OpConstantComposite %f32vec2 %f32_0 %result"), Values(""), Values(TestResult(SPV_ERROR_INVALID_ID, "in semantic instruction cannot be a " "non-semantic instruction")))); TEST_F(ValidateNonSemanticString, InvalidSectionOpExtInst) { const std::string spirv = R"( OpCapability Shader OpExtension "SPV_KHR_non_semantic_info" %extinst = OpExtInstImport "NonSemantic.Testing.Set" %test = OpExtInst %void %extinst 4 %void OpMemoryModel Logical GLSL450 OpEntryPoint Vertex %main "main" )"; CompileSuccessfully(spirv); EXPECT_THAT(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); // there's no specific error for using an OpExtInst too early, it requires a // type so by definition any use of a type in it will be an undefined ID EXPECT_THAT(getDiagnosticString(), HasSubstr("ID '2[%2]' has not been defined")); } TEST_F(ValidateNonSemanticString, MissingOpExtensionPost1p6) { const std::string spirv = R"( OpCapability Shader %extinst = OpExtInstImport "NonSemantic.Testing.Set" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft %void = OpTypeVoid %test = OpExtInst %void %extinst 3 %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_6); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_6)); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_non_uniform_test.cpp000066400000000000000000001357711475742701700252460ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include "gmock/gmock.h" #include "test/unit_spirv.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::Combine; using ::testing::HasSubstr; using ::testing::Values; using ::testing::ValuesIn; std::string GenerateShaderCode( const std::string& body, const std::string& capabilities_and_extensions = "", const std::string& execution_model = "GLCompute") { std::ostringstream ss; ss << R"( OpCapability Shader OpCapability GroupNonUniform OpCapability GroupNonUniformVote OpCapability GroupNonUniformBallot OpCapability GroupNonUniformShuffle OpCapability GroupNonUniformShuffleRelative OpCapability GroupNonUniformArithmetic OpCapability GroupNonUniformClustered OpCapability GroupNonUniformQuad OpCapability GroupNonUniformPartitionedNV OpCapability QuadControlKHR OpExtension "SPV_NV_shader_subgroup_partitioned" OpExtension "SPV_KHR_quad_control" )"; ss << capabilities_and_extensions; ss << "OpMemoryModel Logical GLSL450\n"; ss << "OpEntryPoint " << execution_model << " %main \"main\"\n"; if (execution_model == "GLCompute") { ss << "OpExecutionMode %main LocalSize 1 1 1\n"; } ss << R"( %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %u32 = OpTypeInt 32 0 %int = OpTypeInt 32 1 %float = OpTypeFloat 32 %u32vec4 = OpTypeVector %u32 4 %u32vec3 = OpTypeVector %u32 3 %v2bool = OpTypeVector %bool 2 %v4float = OpTypeVector %float 4 %struct = OpTypeStruct %int %v4int = OpTypeVector %int 4 %true = OpConstantTrue %bool %false = OpConstantFalse %bool %u32_0 = OpConstant %u32 0 %int_0 = OpConstant %int 0 %float_0 = OpConstant %float 0 %u32vec4_null = OpConstantComposite %u32vec4 %u32_0 %u32_0 %u32_0 %u32_0 %u32vec3_null = OpConstantComposite %u32vec3 %u32_0 %u32_0 %u32_0 %v2bool_false = OpConstantNull %v2bool %v4float_null = OpConstantNull %v4float %struct_null = OpConstantNull %struct %v4int_null = OpConstantComposite %v4int %int_0 %int_0 %int_0 %int_0 %u32_undef = OpUndef %u32 %cross_device = OpConstant %u32 0 %device = OpConstant %u32 1 %workgroup = OpConstant %u32 2 %subgroup = OpConstant %u32 3 %invocation = OpConstant %u32 4 %reduce = OpConstant %u32 0 %inclusive_scan = OpConstant %u32 1 %exclusive_scan = OpConstant %u32 2 %clustered_reduce = OpConstant %u32 3 %main = OpFunction %void None %func %main_entry = OpLabel )"; ss << body; ss << R"( OpReturn OpFunctionEnd)"; return ss.str(); } spv::Scope scopes[] = {spv::Scope::CrossDevice, spv::Scope::Device, spv::Scope::Workgroup, spv::Scope::Subgroup, spv::Scope::Invocation}; using ValidateGroupNonUniform = spvtest::ValidateBase; using GroupNonUniform = spvtest::ValidateBase< std::tuple>; std::string ConvertScope(spv::Scope scope) { switch (scope) { case spv::Scope::CrossDevice: return "%cross_device"; case spv::Scope::Device: return "%device"; case spv::Scope::Workgroup: return "%workgroup"; case spv::Scope::Subgroup: return "%subgroup"; case spv::Scope::Invocation: return "%invocation"; default: return ""; } } std::string ConvertMatch(const std::string& type) { if (type == "%bool") { return "%true"; } else if (type == "%u32") { return "%u32_0"; } else if (type == "%int") { return "%int_0"; } else if (type == "%float") { return "%float_0"; } else if (type == "%u32vec4") { return "%u32vec4_null"; } else if (type == "%u32vec3") { return "%u32vec3_null"; } else if (type == "%v2bool") { return "%v2bool_false"; } else if (type == "%v4float") { return "%v4float_null"; } else if (type == "%struct") { return "%struct_null"; } else if (type == "%v4int") { return "%v4int_null"; } return "INVALID"; } TEST_P(GroupNonUniform, Vulkan1p1) { std::string opcode = std::get<0>(GetParam()); std::string type = std::get<1>(GetParam()); spv::Scope execution_scope = std::get<2>(GetParam()); std::string args = std::get<3>(GetParam()); std::string error = std::get<4>(GetParam()); const std::string match = "match_res"; size_t pos = std::string::npos; while ((pos = args.find(match)) != std::string::npos) { const std::string replace = ConvertMatch(type); args = args.substr(0, pos) + replace + args.substr(pos + match.size()); } std::ostringstream sstr; sstr << "%result = " << opcode << " "; sstr << type << " "; if (opcode != "OpGroupNonUniformQuadAllKHR" && opcode != "OpGroupNonUniformQuadAnyKHR") { sstr << ConvertScope(execution_scope) << " "; } sstr << args << "\n"; CompileSuccessfully(GenerateShaderCode(sstr.str()), SPV_ENV_VULKAN_1_1); spv_result_t result = ValidateInstructions(SPV_ENV_VULKAN_1_1); if (error == "") { if (execution_scope == spv::Scope::Subgroup) { EXPECT_EQ(SPV_SUCCESS, result); } else { EXPECT_EQ(SPV_ERROR_INVALID_DATA, result); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-None-04642")); EXPECT_THAT( getDiagnosticString(), HasSubstr( "in Vulkan environment Execution scope is limited to Subgroup")); } } else { EXPECT_EQ(SPV_ERROR_INVALID_DATA, result); EXPECT_THAT(getDiagnosticString(), HasSubstr(error)); } } TEST_P(GroupNonUniform, Spirv1p3) { std::string opcode = std::get<0>(GetParam()); std::string type = std::get<1>(GetParam()); spv::Scope execution_scope = std::get<2>(GetParam()); std::string args = std::get<3>(GetParam()); std::string error = std::get<4>(GetParam()); const std::string match = "match_res"; size_t pos = std::string::npos; while ((pos = args.find(match)) != std::string::npos) { const std::string replace = ConvertMatch(type); args = args.substr(0, pos) + replace + args.substr(pos + match.size()); } std::ostringstream sstr; sstr << "%result = " << opcode << " "; sstr << type << " "; if (opcode != "OpGroupNonUniformQuadAllKHR" && opcode != "OpGroupNonUniformQuadAnyKHR") { sstr << ConvertScope(execution_scope) << " "; } sstr << args << "\n"; CompileSuccessfully(GenerateShaderCode(sstr.str()), SPV_ENV_UNIVERSAL_1_3); spv_result_t result = ValidateInstructions(SPV_ENV_UNIVERSAL_1_3); if (error == "") { if (execution_scope == spv::Scope::Subgroup || execution_scope == spv::Scope::Workgroup) { EXPECT_EQ(SPV_SUCCESS, result); } else { EXPECT_EQ(SPV_ERROR_INVALID_DATA, result); EXPECT_THAT( getDiagnosticString(), HasSubstr("Execution scope is limited to Subgroup or Workgroup")); } } else { EXPECT_EQ(SPV_ERROR_INVALID_DATA, result); EXPECT_THAT(getDiagnosticString(), HasSubstr(error)); } } INSTANTIATE_TEST_SUITE_P(GroupNonUniformElect, GroupNonUniform, Combine(Values("OpGroupNonUniformElect"), Values("%bool"), ValuesIn(scopes), Values(""), Values(""))); INSTANTIATE_TEST_SUITE_P(GroupNonUniformVote, GroupNonUniform, Combine(Values("OpGroupNonUniformAll", "OpGroupNonUniformAny", "OpGroupNonUniformAllEqual"), Values("%bool"), ValuesIn(scopes), Values("%true"), Values(""))); INSTANTIATE_TEST_SUITE_P(GroupNonUniformBroadcast, GroupNonUniform, Combine(Values("OpGroupNonUniformBroadcast"), Values("%bool"), ValuesIn(scopes), Values("%true %u32_0"), Values(""))); INSTANTIATE_TEST_SUITE_P(GroupNonUniformBroadcastFirst, GroupNonUniform, Combine(Values("OpGroupNonUniformBroadcastFirst"), Values("%bool"), ValuesIn(scopes), Values("%true"), Values(""))); INSTANTIATE_TEST_SUITE_P(GroupNonUniformBallot, GroupNonUniform, Combine(Values("OpGroupNonUniformBallot"), Values("%u32vec4"), ValuesIn(scopes), Values("%true"), Values(""))); INSTANTIATE_TEST_SUITE_P(GroupNonUniformInverseBallot, GroupNonUniform, Combine(Values("OpGroupNonUniformInverseBallot"), Values("%bool"), ValuesIn(scopes), Values("%u32vec4_null"), Values(""))); INSTANTIATE_TEST_SUITE_P(GroupNonUniformBallotBitExtract, GroupNonUniform, Combine(Values("OpGroupNonUniformBallotBitExtract"), Values("%bool"), ValuesIn(scopes), Values("%u32vec4_null %u32_0"), Values(""))); INSTANTIATE_TEST_SUITE_P(GroupNonUniformBallotBitCount, GroupNonUniform, Combine(Values("OpGroupNonUniformBallotBitCount"), Values("%u32"), ValuesIn(scopes), Values("Reduce %u32vec4_null"), Values(""))); INSTANTIATE_TEST_SUITE_P(GroupNonUniformBallotFind, GroupNonUniform, Combine(Values("OpGroupNonUniformBallotFindLSB", "OpGroupNonUniformBallotFindMSB"), Values("%u32"), ValuesIn(scopes), Values("%u32vec4_null"), Values(""))); INSTANTIATE_TEST_SUITE_P(GroupNonUniformShuffle, GroupNonUniform, Combine(Values("OpGroupNonUniformShuffle", "OpGroupNonUniformShuffleXor", "OpGroupNonUniformShuffleUp", "OpGroupNonUniformShuffleDown"), Values("%u32"), ValuesIn(scopes), Values("%u32_0 %u32_0"), Values(""))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformIntegerArithmetic, GroupNonUniform, Combine(Values("OpGroupNonUniformIAdd", "OpGroupNonUniformIMul", "OpGroupNonUniformSMin", "OpGroupNonUniformUMin", "OpGroupNonUniformSMax", "OpGroupNonUniformUMax", "OpGroupNonUniformBitwiseAnd", "OpGroupNonUniformBitwiseOr", "OpGroupNonUniformBitwiseXor"), Values("%u32"), ValuesIn(scopes), Values("Reduce %u32_0"), Values(""))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformFloatArithmetic, GroupNonUniform, Combine(Values("OpGroupNonUniformFAdd", "OpGroupNonUniformFMul", "OpGroupNonUniformFMin", "OpGroupNonUniformFMax"), Values("%float"), ValuesIn(scopes), Values("Reduce %float_0"), Values(""))); INSTANTIATE_TEST_SUITE_P(GroupNonUniformLogicalArithmetic, GroupNonUniform, Combine(Values("OpGroupNonUniformLogicalAnd", "OpGroupNonUniformLogicalOr", "OpGroupNonUniformLogicalXor"), Values("%bool"), ValuesIn(scopes), Values("Reduce %true"), Values(""))); INSTANTIATE_TEST_SUITE_P(GroupNonUniformQuad, GroupNonUniform, Combine(Values("OpGroupNonUniformQuadBroadcast", "OpGroupNonUniformQuadSwap"), Values("%u32"), ValuesIn(scopes), Values("%u32_0 %u32_0"), Values(""))); INSTANTIATE_TEST_SUITE_P(GroupNonUniformBallotBitCountScope, GroupNonUniform, Combine(Values("OpGroupNonUniformBallotBitCount"), Values("%u32"), ValuesIn(scopes), Values("Reduce %u32vec4_null"), Values(""))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformBallotBitCountBadResultType, GroupNonUniform, Combine( Values("OpGroupNonUniformBallotBitCount"), Values("%float", "%int"), Values(spv::Scope::Subgroup), Values("Reduce %u32vec4_null"), Values("Expected Result Type to be an unsigned integer type scalar."))); INSTANTIATE_TEST_SUITE_P(GroupNonUniformBallotBitCountBadValue, GroupNonUniform, Combine(Values("OpGroupNonUniformBallotBitCount"), Values("%u32"), Values(spv::Scope::Subgroup), Values("Reduce %u32vec3_null", "Reduce %u32_0", "Reduce %float_0"), Values("Expected Value to be a vector of four " "components of integer type scalar"))); INSTANTIATE_TEST_SUITE_P(GroupNonUniformElectGood, GroupNonUniform, Combine(Values("OpGroupNonUniformElect"), Values("%bool"), Values(spv::Scope::Subgroup), Values(""), Values(""))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformElectBadResultType, GroupNonUniform, Combine(Values("OpGroupNonUniformElect"), Values("%void", "%u32", "%int", "%float", "%u32vec4", "%u32vec3", "%v2bool", "%v4float", "%struct"), Values(spv::Scope::Subgroup), Values(""), Values("Result must be a boolean scalar type"))); INSTANTIATE_TEST_SUITE_P(GroupNonUniformAnyAllGood, GroupNonUniform, Combine(Values("OpGroupNonUniformAny", "OpGroupNonUniformAll"), Values("%bool"), Values(spv::Scope::Subgroup), Values("%true", "%false"), Values(""))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformAnyAllBadResultType, GroupNonUniform, Combine(Values("OpGroupNonUniformAny", "OpGroupNonUniformAll"), Values("%void", "%u32", "%int", "%float", "%u32vec4", "%u32vec3", "%v2bool", "%v4float", "%struct"), Values(spv::Scope::Subgroup), Values("%true"), Values("Result must be a boolean scalar type"))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformAnyAllBadOperand, GroupNonUniform, Combine(Values("OpGroupNonUniformAny", "OpGroupNonUniformAll"), Values("%bool"), Values(spv::Scope::Subgroup), Values("%u32_0", "%int_0", "%float_0", "%u32vec4_null", "%u32vec3_null", "%v2bool_false", "%v4float_null", "%struct_null"), Values("Predicate must be a boolean scalar type"))); INSTANTIATE_TEST_SUITE_P(GroupNonUniformAllEqualGood, GroupNonUniform, Combine(Values("OpGroupNonUniformAllEqual"), Values("%bool"), Values(spv::Scope::Subgroup), Values("%true", "%false"), Values(""))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformAllEqualBadResultType, GroupNonUniform, Combine(Values("OpGroupNonUniformAllEqual"), Values("%void", "%u32", "%int", "%float", "%u32vec4", "%u32vec3", "%v2bool", "%v4float", "%struct"), Values(spv::Scope::Subgroup), Values("%true"), Values("Result must be a boolean scalar type"))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformAllEqualBadOperand, GroupNonUniform, Combine(Values("OpGroupNonUniformAllEqual"), Values("%bool"), Values(spv::Scope::Subgroup), Values("%struct_null"), Values("Value must be a scalar or vector of integer, " "floating-point, or boolean type"))); INSTANTIATE_TEST_SUITE_P(GroupNonUniformBroadcastGood, GroupNonUniform, Combine(Values("OpGroupNonUniformBroadcast", "OpGroupNonUniformQuadBroadcast", "OpGroupNonUniformQuadSwap"), Values("%bool", "%u32", "%int", "%float", "%u32vec4", "%u32vec3", "%v2bool", "%v4float", "%v4int"), Values(spv::Scope::Subgroup), Values("match_res %u32_0"), Values(""))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformBroadcastShuffleBadResultType, GroupNonUniform, Combine(Values("OpGroupNonUniformBroadcast", "OpGroupNonUniformShuffle", "OpGroupNonUniformShuffleXor", "OpGroupNonUniformShuffleUp", "OpGroupNonUniformShuffleDown", "OpGroupNonUniformQuadBroadcast", "OpGroupNonUniformQuadSwap"), Values("%void", "%struct"), Values(spv::Scope::Subgroup), Values("%u32_0 %u32_0"), Values("Result must be a scalar or vector of integer, " "floating-point, or boolean type"))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformBroadcastShuffleBadOperand1, GroupNonUniform, Combine(Values("OpGroupNonUniformBroadcast", "OpGroupNonUniformShuffle", "OpGroupNonUniformShuffleXor", "OpGroupNonUniformShuffleUp", "OpGroupNonUniformShuffleDown", "OpGroupNonUniformQuadBroadcast", "OpGroupNonUniformQuadSwap"), Values("%bool"), Values(spv::Scope::Subgroup), Values("%u32_0 %u32_0", "%int_0 %u32_0", "%float_0 %u32_0", "%u32vec4_null %u32_0", "%u32vec3_null %u32_0", "%v2bool_false %u32_0", "%v4float_null %u32_0", "%struct_null %u32_0", "%v4int_null %u32_0"), Values("The type of Value must match the Result type"))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformBroadcastShuffleBadOperand2, GroupNonUniform, Combine(Values("OpGroupNonUniformBroadcast", "OpGroupNonUniformShuffle", "OpGroupNonUniformShuffleXor", "OpGroupNonUniformShuffleUp", "OpGroupNonUniformShuffleDown", "OpGroupNonUniformQuadBroadcast", "OpGroupNonUniformQuadSwap"), Values("%bool"), Values(spv::Scope::Subgroup), Values("%true %true", "%true %int_0", "%true %float_0", "%true %u32vec4_null", "%true %u32vec3_null", "%true %v4float_null", "%true %v2bool_false", "%true %struct_null", "%true %v4int_null"), Values("must be an unsigned integer scalar"))); INSTANTIATE_TEST_SUITE_P(GroupNonUniformBroadcastShuffleOperand2NotConstant, GroupNonUniform, Combine(Values("OpGroupNonUniformBroadcast", "OpGroupNonUniformQuadBroadcast", "OpGroupNonUniformQuadSwap"), Values("%bool"), Values(spv::Scope::Subgroup), Values("%true %u32_undef"), Values("must be a constant instruction"))); INSTANTIATE_TEST_SUITE_P(GroupNonUniformBroadcastFirstGood, GroupNonUniform, Combine(Values("OpGroupNonUniformBroadcastFirst"), Values("%bool", "%u32", "%int", "%float", "%u32vec4", "%u32vec3", "%v2bool", "%v4float", "%v4int"), Values(spv::Scope::Subgroup), Values("match_res"), Values(""))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformBroadcasFirsttBadResultType, GroupNonUniform, Combine(Values("OpGroupNonUniformBroadcastFirst"), Values("%void", "%struct"), Values(spv::Scope::Subgroup), Values("%u32_0"), Values("Result must be a scalar or vector of integer, " "floating-point, or boolean type"))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformBroadcastBadOperand, GroupNonUniform, Combine(Values("OpGroupNonUniformBroadcastFirst"), Values("%bool"), Values(spv::Scope::Subgroup), Values("%u32_0", "%int_0", "%float_0", "%u32vec4_null", "%u32vec3_null", "%v2bool_false", "%v4float_null", "%struct_null", "%v4int_null"), Values("The type of Value must match the Result type"))); INSTANTIATE_TEST_SUITE_P(GroupNonUniformBallotGood, GroupNonUniform, Combine(Values("OpGroupNonUniformBallot"), Values("%u32vec4"), Values(spv::Scope::Subgroup), Values("%true", "%false"), Values(""))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformBallotBadResultType, GroupNonUniform, Combine(Values("OpGroupNonUniformBallot"), Values("%void", "%bool", "%u32", "%int", "%float", "%u32vec3", "%v2bool", "%v4float", "%struct", "%v4int"), Values(spv::Scope::Subgroup), Values("%true", "%false"), Values("Result must be a 4-component unsigned integer vector"))); INSTANTIATE_TEST_SUITE_P(GroupNonUniformBallotBadOperand, GroupNonUniform, Combine(Values("OpGroupNonUniformBallot"), Values("%u32vec4"), Values(spv::Scope::Subgroup), Values("%u32_0", "%int_0", "%float_0", "%u32vec4_null", "%u32vec3_null", "%v2bool_false", "%v4float_null", "%struct_null", "%v4int_null"), Values("Predicate must be a boolean scalar"))); INSTANTIATE_TEST_SUITE_P(GroupNonUniformInverseBallotGood, GroupNonUniform, Combine(Values("OpGroupNonUniformInverseBallot"), Values("%bool"), Values(spv::Scope::Subgroup), Values("%u32vec4_null"), Values(""))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformInverseBallotBadResultType, GroupNonUniform, Combine(Values("OpGroupNonUniformInverseBallot"), Values("%void", "%u32", "%int", "%float", "%u32vec4", "%u32vec3", "%v2bool", "%v4float", "%struct", "%v4int"), Values(spv::Scope::Subgroup), Values("%u32vec4_null"), Values("Result must be a boolean scalar"))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformInverseBallotBadOperand, GroupNonUniform, Combine(Values("OpGroupNonUniformInverseBallot"), Values("%bool"), Values(spv::Scope::Subgroup), Values("%true", "%false", "%u32_0", "%int_0", "%float_0", "%u32vec3_null", "%v2bool_false", "%v4float_null", "%struct_null", "%v4int_null"), Values("Value must be a 4-component unsigned integer vector"))); INSTANTIATE_TEST_SUITE_P(GroupNonUniformBallotBitExtractGood, GroupNonUniform, Combine(Values("OpGroupNonUniformBallotBitExtract"), Values("%bool"), Values(spv::Scope::Subgroup), Values("%u32vec4_null %u32_0"), Values(""))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformBallotBitExtractBadResultType, GroupNonUniform, Combine(Values("OpGroupNonUniformBallotBitExtract"), Values("%void", "%u32", "%int", "%float", "%u32vec4", "%u32vec3", "%v2bool", "%v4float", "%struct", "%v4int"), Values(spv::Scope::Subgroup), Values("%u32vec4_null %u32_0"), Values("Result must be a boolean scalar"))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformBallotBitExtractBadOperand1, GroupNonUniform, Combine(Values("OpGroupNonUniformBallotBitExtract"), Values("%bool"), Values(spv::Scope::Subgroup), Values("%true %u32_0", "%false %u32_0", "%u32_0 %u32_0", "%int_0 %u32_0", "%float_0 %u32_0", "%u32vec3_null %u32_0", "%v2bool_false %u32_0", "%v4float_null %u32_0", "%struct_null %u32_0", "%v4int_null %u32_0"), Values("Value must be a 4-component unsigned integer vector"))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformBallotBitExtractBadOperand2, GroupNonUniform, Combine(Values("OpGroupNonUniformBallotBitExtract"), Values("%bool"), Values(spv::Scope::Subgroup), Values("%u32vec4_null %true", "%u32vec4_null %false", "%u32vec4_null %int_0", "%u32vec4_null %float_0", "%u32vec4_null %u32vec3_null", "%u32vec4_null %v2bool_false", "%u32vec4_null %v4float_null", "%u32vec4_null %struct_null", "%u32vec4_null %v4int_null"), Values("Id must be an unsigned integer scalar"))); INSTANTIATE_TEST_SUITE_P(GroupNonUniformBallotFindGood, GroupNonUniform, Combine(Values("OpGroupNonUniformBallotFindLSB", "OpGroupNonUniformBallotFindMSB"), Values("%u32"), Values(spv::Scope::Subgroup), Values("%u32vec4_null"), Values(""))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformBallotFindBadResultType, GroupNonUniform, Combine(Values("OpGroupNonUniformBallotFindLSB", "OpGroupNonUniformBallotFindMSB"), Values("%void", "%bool", "%int", "%float", "%u32vec4", "%u32vec3", "%v2bool", "%v4float", "%struct", "%v4int"), Values(spv::Scope::Subgroup), Values("%u32vec4_null"), Values("Result must be an unsigned integer scalar"))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformBallotFindBadOperand, GroupNonUniform, Combine(Values("OpGroupNonUniformBallotFindLSB", "OpGroupNonUniformBallotFindMSB"), Values("%u32"), Values(spv::Scope::Subgroup), Values("%true", "%false", "%u32_0", "%int_0", "%float_0", "%u32vec3_null", "%v2bool_false", "%v4float_null", "%struct_null", "%v4int_null"), Values("Value must be a 4-component unsigned integer vector"))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformIntegerArithmeticGood, GroupNonUniform, Combine(Values("OpGroupNonUniformIAdd", "OpGroupNonUniformIMul", "OpGroupNonUniformSMin", "OpGroupNonUniformSMax", "OpGroupNonUniformBitwiseAnd", "OpGroupNonUniformBitwiseOr", "OpGroupNonUniformBitwiseXor"), Values("%u32", "%int", "%u32vec4", "%u32vec3", "%v4int"), Values(spv::Scope::Subgroup), Values("Reduce match_res", "InclusiveScan match_res", "ExclusiveScan match_res", "ClusteredReduce match_res %u32_0", "PartitionedReduceNV match_res %u32vec4_null", "PartitionedInclusiveScanNV match_res %u32vec4_null", "PartitionedExclusiveScanNV match_res %v4int_null"), Values(""))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformIntegerArithmeticBadResultType, GroupNonUniform, Combine(Values("OpGroupNonUniformIAdd", "OpGroupNonUniformIMul", "OpGroupNonUniformSMin", "OpGroupNonUniformSMax", "OpGroupNonUniformBitwiseAnd", "OpGroupNonUniformBitwiseOr", "OpGroupNonUniformBitwiseXor"), Values("%bool", "%float", "%v4float", "%struct"), Values(spv::Scope::Subgroup), Values("Reduce match_res", "InclusiveScan match_res", "ExclusiveScan match_res", "ClusteredReduce match_res %u32_0"), Values("Result must be an integer scalar or vector"))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformIntegerArithmeticBadValue, GroupNonUniform, Combine(Values("OpGroupNonUniformIAdd", "OpGroupNonUniformIMul", "OpGroupNonUniformSMin", "OpGroupNonUniformSMax", "OpGroupNonUniformBitwiseAnd", "OpGroupNonUniformBitwiseOr", "OpGroupNonUniformBitwiseXor"), Values("%int", "%u32vec4", "%u32vec3", "%v4int"), Values(spv::Scope::Subgroup), Values("Reduce %u32_0", "InclusiveScan %u32_0", "ExclusiveScan %u32_0", "ClusteredReduce %u32_0 %u32_0"), Values("The type of Value must match the Result type"))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformIntegerArithmeticMissingClusterSize, GroupNonUniform, Combine( Values("OpGroupNonUniformIAdd", "OpGroupNonUniformIMul", "OpGroupNonUniformSMin", "OpGroupNonUniformUMin", "OpGroupNonUniformSMax", "OpGroupNonUniformUMax", "OpGroupNonUniformBitwiseAnd", "OpGroupNonUniformBitwiseOr", "OpGroupNonUniformBitwiseXor"), Values("%u32"), Values(spv::Scope::Subgroup), Values("ClusteredReduce match_res"), Values( "ClusterSize must be present when Operation is ClusteredReduce"))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformIntegerArithmeticMissingBallot, GroupNonUniform, Combine( Values("OpGroupNonUniformIAdd", "OpGroupNonUniformIMul", "OpGroupNonUniformSMin", "OpGroupNonUniformUMin", "OpGroupNonUniformSMax", "OpGroupNonUniformUMax", "OpGroupNonUniformBitwiseAnd", "OpGroupNonUniformBitwiseOr", "OpGroupNonUniformBitwiseXor"), Values("%u32"), Values(spv::Scope::Subgroup), Values("PartitionedReduceNV match_res", "PartitionedInclusiveScanNV match_res", "PartitionedExclusiveScanNV match_res"), Values("Ballot must be present when Operation is PartitionedReduceNV, " "PartitionedInclusiveScanNV, or PartitionedExclusiveScanNV"))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformIntegerArithmeticBadClusterSizeType, GroupNonUniform, Combine(Values("OpGroupNonUniformIAdd", "OpGroupNonUniformIMul", "OpGroupNonUniformSMin", "OpGroupNonUniformUMin", "OpGroupNonUniformSMax", "OpGroupNonUniformUMax", "OpGroupNonUniformBitwiseAnd", "OpGroupNonUniformBitwiseOr", "OpGroupNonUniformBitwiseXor"), Values("%u32"), Values(spv::Scope::Subgroup), Values("ClusteredReduce match_res %true", "ClusteredReduce match_res %false", "ClusteredReduce match_res %int_0", "ClusteredReduce match_res %float_0", "ClusteredReduce match_res %u32vec4_null", "ClusteredReduce match_res %u32vec3_null", "ClusteredReduce match_res %v2bool_false", "ClusteredReduce match_res %v4float_null", "ClusteredReduce match_res %struct_null", "ClusteredReduce match_res %v4int_null"), Values("ClusterSize must be an unsigned integer scalar"))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformIntegerArithmeticBadBallotType, GroupNonUniform, Combine(Values("OpGroupNonUniformIAdd", "OpGroupNonUniformIMul", "OpGroupNonUniformSMin", "OpGroupNonUniformUMin", "OpGroupNonUniformSMax", "OpGroupNonUniformUMax", "OpGroupNonUniformBitwiseAnd", "OpGroupNonUniformBitwiseOr", "OpGroupNonUniformBitwiseXor"), Values("%u32"), Values(spv::Scope::Subgroup), Values("PartitionedReduceNV match_res %true", "PartitionedReduceNV match_res %false", "PartitionedReduceNV match_res %int_0", "PartitionedReduceNV match_res %float_0", "PartitionedReduceNV match_res %u32_0", "PartitionedReduceNV match_res %u32vec3_null", "PartitionedReduceNV match_res %v2bool_false", "PartitionedReduceNV match_res %v4float_null", "PartitionedReduceNV match_res %struct_null"), Values("Ballot must be a 4-component integer vector"))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformIntegerArithmeticClusterSizeNotConstant, GroupNonUniform, Combine(Values("OpGroupNonUniformIAdd", "OpGroupNonUniformIMul", "OpGroupNonUniformSMin", "OpGroupNonUniformUMin", "OpGroupNonUniformSMax", "OpGroupNonUniformUMax", "OpGroupNonUniformBitwiseAnd", "OpGroupNonUniformBitwiseOr", "OpGroupNonUniformBitwiseXor"), Values("%u32"), Values(spv::Scope::Subgroup), Values("ClusteredReduce match_res %u32_undef"), Values("ClusterSize must be a constant instruction"))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformUnsignedIntegerArithmeticGood, GroupNonUniform, Combine(Values("OpGroupNonUniformUMin", "OpGroupNonUniformUMax"), Values("%u32", "%u32vec4", "%u32vec3"), Values(spv::Scope::Subgroup), Values("Reduce match_res", "InclusiveScan match_res", "ExclusiveScan match_res", "ClusteredReduce match_res %u32_0"), Values(""))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformUnsignedIntegerArithmeticBadResultType, GroupNonUniform, Combine(Values("OpGroupNonUniformUMin", "OpGroupNonUniformUMax"), Values("%bool", "%int", "%float", "%v4float", "%struct", "%v4int"), Values(spv::Scope::Subgroup), Values("Reduce match_res", "InclusiveScan match_res", "ExclusiveScan match_res", "ClusteredReduce match_res %u32_0"), Values("Result must be an unsigned integer scalar or vector"))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformUnsignedIntegerArithmeticBadValue, GroupNonUniform, Combine(Values("OpGroupNonUniformUMin", "OpGroupNonUniformUMax"), Values("%u32vec4", "%u32vec3"), Values(spv::Scope::Subgroup), Values("Reduce %u32_0", "InclusiveScan %u32_0", "ExclusiveScan %u32_0", "ClusteredReduce %u32_0 %u32_0"), Values("The type of Value must match the Result type"))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformFloatArithmeticGood, GroupNonUniform, Combine(Values("OpGroupNonUniformFAdd", "OpGroupNonUniformFMul", "OpGroupNonUniformFMin", "OpGroupNonUniformFMax"), Values("%float", "%v4float"), Values(spv::Scope::Subgroup), Values("Reduce match_res", "InclusiveScan match_res", "ExclusiveScan match_res", "ClusteredReduce match_res %u32_0"), Values(""))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformFloatArithmeticBadResultType, GroupNonUniform, Combine(Values("OpGroupNonUniformFAdd", "OpGroupNonUniformFMul", "OpGroupNonUniformFMin", "OpGroupNonUniformFMax"), Values("%bool", "%u32", "%int", "%u32vec4", "%u32vec3", "%struct", "%v4int"), Values(spv::Scope::Subgroup), Values("Reduce match_res", "InclusiveScan match_res", "ExclusiveScan match_res", "ClusteredReduce match_res %u32_0"), Values("Result must be a floating-point scalar or vector"))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformFloatArithmeticBadValue, GroupNonUniform, Combine(Values("OpGroupNonUniformFAdd", "OpGroupNonUniformFMul", "OpGroupNonUniformFMin", "OpGroupNonUniformFMax"), Values("%v4float"), Values(spv::Scope::Subgroup), Values("Reduce %float_0", "InclusiveScan %float_0", "ExclusiveScan %float_0", "ClusteredReduce %float_0 %u32_0"), Values("The type of Value must match the Result type"))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformFloatArithmeticMissingClusterSize, GroupNonUniform, Combine( Values("OpGroupNonUniformFAdd", "OpGroupNonUniformFMul", "OpGroupNonUniformFMin", "OpGroupNonUniformFMax"), Values("%float"), Values(spv::Scope::Subgroup), Values("ClusteredReduce match_res"), Values( "ClusterSize must be present when Operation is ClusteredReduce"))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformFloatArithmeticBadClusterSizeType, GroupNonUniform, Combine(Values("OpGroupNonUniformFAdd", "OpGroupNonUniformFMul", "OpGroupNonUniformFMin", "OpGroupNonUniformFMax"), Values("%float"), Values(spv::Scope::Subgroup), Values("ClusteredReduce match_res %true", "ClusteredReduce match_res %false", "ClusteredReduce match_res %int_0", "ClusteredReduce match_res %float_0", "ClusteredReduce match_res %u32vec4_null", "ClusteredReduce match_res %u32vec3_null", "ClusteredReduce match_res %v2bool_false", "ClusteredReduce match_res %v4float_null", "ClusteredReduce match_res %struct_null", "ClusteredReduce match_res %v4int_null"), Values("ClusterSize must be an unsigned integer scalar"))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformFloatArithmeticClusterSizeNotConstant, GroupNonUniform, Combine(Values("OpGroupNonUniformFAdd", "OpGroupNonUniformFMul", "OpGroupNonUniformFMin", "OpGroupNonUniformFMax"), Values("%float"), Values(spv::Scope::Subgroup), Values("ClusteredReduce match_res %u32_undef"), Values("ClusterSize must be a constant instruction"))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformBooleanArithmeticGood, GroupNonUniform, Combine(Values("OpGroupNonUniformLogicalAnd", "OpGroupNonUniformLogicalOr", "OpGroupNonUniformLogicalXor"), Values("%bool", "%v2bool"), Values(spv::Scope::Subgroup), Values("Reduce match_res", "InclusiveScan match_res", "ExclusiveScan match_res", "ClusteredReduce match_res %u32_0"), Values(""))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformBooleanArithmeticBadResultType, GroupNonUniform, Combine(Values("OpGroupNonUniformLogicalAnd", "OpGroupNonUniformLogicalOr", "OpGroupNonUniformLogicalXor"), Values("%u32", "%int", "%float", "%u32vec4", "%u32vec3", "%struct", "%v4float", "%v4int"), Values(spv::Scope::Subgroup), Values("Reduce match_res", "InclusiveScan match_res", "ExclusiveScan match_res", "ClusteredReduce match_res %u32_0"), Values("Result must be a boolean scalar or vector"))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformBooleanArithmeticBadValue, GroupNonUniform, Combine(Values("OpGroupNonUniformLogicalAnd", "OpGroupNonUniformLogicalOr", "OpGroupNonUniformLogicalXor"), Values("%v2bool"), Values(spv::Scope::Subgroup), Values("Reduce %true", "InclusiveScan %true", "ExclusiveScan %false", "ClusteredReduce %false %u32_0"), Values("The type of Value must match the Result type"))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformBooleanArithmeticMissingClusterSize, GroupNonUniform, Combine( Values("OpGroupNonUniformLogicalAnd", "OpGroupNonUniformLogicalOr", "OpGroupNonUniformLogicalXor"), Values("%bool"), Values(spv::Scope::Subgroup), Values("ClusteredReduce match_res"), Values( "ClusterSize must be present when Operation is ClusteredReduce"))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformBooleanArithmeticBadClusterSizeType, GroupNonUniform, Combine(Values("OpGroupNonUniformLogicalAnd", "OpGroupNonUniformLogicalOr", "OpGroupNonUniformLogicalXor"), Values("%bool"), Values(spv::Scope::Subgroup), Values("ClusteredReduce match_res %true", "ClusteredReduce match_res %false", "ClusteredReduce match_res %int_0", "ClusteredReduce match_res %float_0", "ClusteredReduce match_res %u32vec4_null", "ClusteredReduce match_res %u32vec3_null", "ClusteredReduce match_res %v2bool_false", "ClusteredReduce match_res %v4float_null", "ClusteredReduce match_res %struct_null", "ClusteredReduce match_res %v4int_null"), Values("ClusterSize must be an unsigned integer scalar"))); INSTANTIATE_TEST_SUITE_P( GroupNonUniformBooleanArithmeticClusterSizeNotConstant, GroupNonUniform, Combine(Values("OpGroupNonUniformLogicalAnd", "OpGroupNonUniformLogicalOr", "OpGroupNonUniformLogicalXor"), Values("%bool"), Values(spv::Scope::Subgroup), Values("ClusteredReduce match_res %u32_undef"), Values("ClusterSize must be a constant instruction"))); // Subgroup scope is not actual parameter, but used for test expectations, INSTANTIATE_TEST_SUITE_P(GroupNonUniformQuadAllKHR, GroupNonUniform, Combine(Values("OpGroupNonUniformQuadAllKHR"), Values("%bool"), Values(spv::Scope::Subgroup), Values("%true"), Values(""))); // Subgroup scope is not actual parameter, but used for test expectations, INSTANTIATE_TEST_SUITE_P(GroupNonUniformQuadAnyKHR, GroupNonUniform, Combine(Values("OpGroupNonUniformQuadAnyKHR"), Values("%bool"), Values(spv::Scope::Subgroup), Values("%true"), Values(""))); TEST_F(ValidateGroupNonUniform, VulkanGroupNonUniformBallotBitCountOperation) { std::string test = R"( OpCapability Shader OpCapability GroupNonUniform OpCapability GroupNonUniformBallot OpCapability GroupNonUniformClustered OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 %void = OpTypeVoid %func = OpTypeFunction %void %u32 = OpTypeInt 32 0 %u32vec4 = OpTypeVector %u32 4 %u32_0 = OpConstant %u32 0 %u32vec4_null = OpConstantComposite %u32vec4 %u32_0 %u32_0 %u32_0 %u32_0 %subgroup = OpConstant %u32 3 %main = OpFunction %void None %func %main_entry = OpLabel %result = OpGroupNonUniformBallotBitCount %u32 %subgroup ClusteredReduce %u32vec4_null OpReturn OpFunctionEnd )"; CompileSuccessfully(test, SPV_ENV_VULKAN_1_1); ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_1)); EXPECT_THAT( getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-OpGroupNonUniformBallotBitCount-04685")); EXPECT_THAT( getDiagnosticString(), HasSubstr( "In Vulkan: The OpGroupNonUniformBallotBitCount group operation must " "be only: Reduce, InclusiveScan, or ExclusiveScan.")); } TEST_F(ValidateGroupNonUniform, BroadcastNonConstantSpv1p4) { const std::string text = R"( OpCapability Shader OpCapability GroupNonUniformBallot OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %var OpExecutionMode %main LocalSize 1 1 1 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %subgroup = OpConstant %int 3 %struct = OpTypeStruct %int %ptr_struct = OpTypePointer StorageBuffer %struct %ptr_int = OpTypePointer StorageBuffer %int %var = OpVariable %ptr_struct StorageBuffer %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %gep = OpAccessChain %ptr_int %var %int_0 %ld = OpLoad %int %gep %broadcast = OpGroupNonUniformBroadcast %int %subgroup %int_0 %ld OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Before SPIR-V 1.5, Id must be a constant instruction")); } TEST_F(ValidateGroupNonUniform, BroadcastNonConstantSpv1p5) { const std::string text = R"( OpCapability Shader OpCapability GroupNonUniformBallot OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %var OpExecutionMode %main LocalSize 1 1 1 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %subgroup = OpConstant %int 3 %struct = OpTypeStruct %int %ptr_struct = OpTypePointer StorageBuffer %struct %ptr_int = OpTypePointer StorageBuffer %int %var = OpVariable %ptr_struct StorageBuffer %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %gep = OpAccessChain %ptr_int %var %int_0 %ld = OpLoad %int %gep %broadcast = OpGroupNonUniformBroadcast %int %subgroup %int_0 %ld OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_5); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); } TEST_F(ValidateGroupNonUniform, QuadBroadcastNonConstantSpv1p4) { const std::string text = R"( OpCapability Shader OpCapability GroupNonUniformQuad OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %var OpExecutionMode %main LocalSize 1 1 1 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %subgroup = OpConstant %int 3 %struct = OpTypeStruct %int %ptr_struct = OpTypePointer StorageBuffer %struct %ptr_int = OpTypePointer StorageBuffer %int %var = OpVariable %ptr_struct StorageBuffer %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %gep = OpAccessChain %ptr_int %var %int_0 %ld = OpLoad %int %gep %broadcast = OpGroupNonUniformQuadBroadcast %int %subgroup %int_0 %ld OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_4); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Before SPIR-V 1.5, Index must be a constant instruction")); } TEST_F(ValidateGroupNonUniform, QuadBroadcastNonConstantSpv1p5) { const std::string text = R"( OpCapability Shader OpCapability GroupNonUniformQuad OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %var OpExecutionMode %main LocalSize 1 1 1 OpDecorate %var DescriptorSet 0 OpDecorate %var Binding 0 OpDecorate %struct Block OpMemberDecorate %struct 0 Offset 0 %void = OpTypeVoid %int = OpTypeInt 32 0 %int_0 = OpConstant %int 0 %subgroup = OpConstant %int 3 %struct = OpTypeStruct %int %ptr_struct = OpTypePointer StorageBuffer %struct %ptr_int = OpTypePointer StorageBuffer %int %var = OpVariable %ptr_struct StorageBuffer %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel %gep = OpAccessChain %ptr_int %var %int_0 %ld = OpLoad %int %gep %broadcast = OpGroupNonUniformQuadBroadcast %int %subgroup %int_0 %ld OpReturn OpFunctionEnd )"; CompileSuccessfully(text, SPV_ENV_UNIVERSAL_1_5); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5)); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_opencl_test.cpp000066400000000000000000000424141475742701700241640ustar00rootroot00000000000000// Copyright (c) 2019 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validation tests for OpenCL env specific checks #include #include "gmock/gmock.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using testing::Eq; using testing::HasSubstr; using ValidateOpenCL = spvtest::ValidateBase; TEST_F(ValidateOpenCL, NonPhysicalAddressingModelBad) { std::string spirv = R"( OpCapability Kernel OpMemoryModel Logical OpenCL )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_OPENCL_1_2)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Addressing model must be Physical32 or Physical64 " "in the OpenCL environment.\n OpMemoryModel Logical " "OpenCL\n")); } TEST_F(ValidateOpenCL, NonOpenCLMemoryModelBad) { std::string spirv = R"( OpCapability Kernel OpCapability Addresses OpCapability VulkanMemoryModelKHR OpExtension "SPV_KHR_vulkan_memory_model" OpMemoryModel Physical32 VulkanKHR )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_OPENCL_1_2)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Memory model must be OpenCL in the OpenCL environment.")); } TEST_F(ValidateOpenCL, NonVoidSampledTypeImageBad) { std::string spirv = R"( OpCapability Addresses OpCapability Kernel OpMemoryModel Physical32 OpenCL %1 = OpTypeInt 32 0 %2 = OpTypeImage %1 2D 0 0 0 0 Unknown ReadOnly )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_OPENCL_1_2)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Sampled Type must be OpTypeVoid in the OpenCL environment." "\n %2 = OpTypeImage %uint 2D 0 0 0 0 Unknown ReadOnly\n")); } TEST_F(ValidateOpenCL, NonZeroMSImageBad) { std::string spirv = R"( OpCapability Addresses OpCapability Kernel OpMemoryModel Physical32 OpenCL %1 = OpTypeVoid %2 = OpTypeImage %1 2D 0 0 1 0 Unknown ReadOnly )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_OPENCL_1_2)); EXPECT_THAT( getDiagnosticString(), HasSubstr("MS must be 0 in the OpenCL environment." "\n %2 = OpTypeImage %void 2D 0 0 1 0 Unknown ReadOnly\n")); } TEST_F(ValidateOpenCL, Non1D2DArrayedImageBad) { std::string spirv = R"( OpCapability Addresses OpCapability Kernel OpMemoryModel Physical32 OpenCL %1 = OpTypeVoid %2 = OpTypeImage %1 3D 0 1 0 0 Unknown ReadOnly )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_OPENCL_1_2)); EXPECT_THAT( getDiagnosticString(), HasSubstr("In the OpenCL environment, Arrayed may only be set to 1 " "when Dim is either 1D or 2D." "\n %2 = OpTypeImage %void 3D 0 1 0 0 Unknown ReadOnly\n")); } TEST_F(ValidateOpenCL, NonZeroSampledImageBad) { std::string spirv = R"( OpCapability Addresses OpCapability Kernel OpMemoryModel Physical32 OpenCL %1 = OpTypeVoid %2 = OpTypeImage %1 3D 0 0 0 1 Unknown ReadOnly )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_OPENCL_1_2)); EXPECT_THAT( getDiagnosticString(), HasSubstr("Sampled must be 0 in the OpenCL environment." "\n %2 = OpTypeImage %void 3D 0 0 0 1 Unknown ReadOnly\n")); } TEST_F(ValidateOpenCL, NoAccessQualifierImageBad) { std::string spirv = R"( OpCapability Addresses OpCapability Kernel OpMemoryModel Physical32 OpenCL %1 = OpTypeVoid %2 = OpTypeImage %1 3D 0 0 0 0 Unknown )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_OPENCL_1_2)); EXPECT_THAT(getDiagnosticString(), HasSubstr("In the OpenCL environment, the optional " "Access Qualifier must be present." "\n %2 = OpTypeImage %void 3D 0 0 0 0 Unknown\n")); } TEST_F(ValidateOpenCL, ImageWriteWithOptionalImageOperandsBad) { std::string spirv = R"( OpCapability Addresses OpCapability Kernel OpCapability ImageBasic OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %5 "test" %uint = OpTypeInt 32 0 %uint_7 = OpConstant %uint 7 %uint_3 = OpConstant %uint 3 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %uint_4 = OpConstant %uint 4 %void = OpTypeVoid %3 = OpTypeImage %void 2D 0 0 0 0 Unknown WriteOnly %4 = OpTypeFunction %void %3 %v2uint = OpTypeVector %uint 2 %v4uint = OpTypeVector %uint 4 %12 = OpConstantComposite %v2uint %uint_7 %uint_3 %17 = OpConstantComposite %v4uint %uint_1 %uint_2 %uint_3 %uint_4 %5 = OpFunction %void None %4 %img = OpFunctionParameter %3 %entry = OpLabel OpImageWrite %img %12 %17 ConstOffset %12 OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_OPENCL_1_2)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Optional Image Operands are not allowed in the " "OpenCL environment." "\n OpImageWrite %15 %13 %14 ConstOffset %13\n")); } TEST_F(ValidateOpenCL, ImageReadWithConstOffsetBad) { std::string spirv = R"( OpCapability Addresses OpCapability Kernel OpCapability ImageBasic OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %5 "image_kernel" OpName %img "img" OpName %coord "coord" OpName %call "call" %uint = OpTypeInt 32 0 %uint_7 = OpConstant %uint 7 %uint_3 = OpConstant %uint 3 %void = OpTypeVoid %3 = OpTypeImage %void 2D 0 0 0 0 Unknown ReadOnly %4 = OpTypeFunction %void %3 %v4uint = OpTypeVector %uint 4 %v2uint = OpTypeVector %uint 2 %coord = OpConstantComposite %v2uint %uint_7 %uint_3 %5 = OpFunction %void None %4 %img = OpFunctionParameter %3 %entry = OpLabel %call = OpImageRead %v4uint %img %coord ConstOffset %coord OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_OPENCL_1_2)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "ConstOffset image operand not allowed in the OpenCL environment." "\n %call = OpImageRead %v4uint %img %coord ConstOffset %coord\n")); } TEST_F(ValidateOpenCL, ImageRead_NonDepthScalarFloatResult_Bad) { std::string spirv = R"( OpCapability Addresses OpCapability Kernel OpCapability ImageBasic OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %5 "image_kernel" OpName %img "img" OpName %coord "coord" OpName %call "call" %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %coord = OpConstantNull %v2uint %void = OpTypeVoid %float = OpTypeFloat 32 %3 = OpTypeImage %void 2D 0 0 0 0 Unknown ReadOnly %4 = OpTypeFunction %void %3 %5 = OpFunction %void None %4 %img = OpFunctionParameter %3 %entry = OpLabel %call = OpImageRead %float %img %coord OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_OPENCL_1_2)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to have 4 components")); } TEST_F(ValidateOpenCL, ImageRead_NonDepthScalarIntResult_Bad) { std::string spirv = R"( OpCapability Addresses OpCapability Kernel OpCapability ImageBasic OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %5 "image_kernel" OpName %img "img" OpName %coord "coord" OpName %call "call" %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %coord = OpConstantNull %v2uint %void = OpTypeVoid %float = OpTypeFloat 32 %3 = OpTypeImage %void 2D 0 0 0 0 Unknown ReadOnly %4 = OpTypeFunction %void %3 %5 = OpFunction %void None %4 %img = OpFunctionParameter %3 %entry = OpLabel %call = OpImageRead %uint %img %coord OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_OPENCL_1_2)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to have 4 components")); } TEST_F(ValidateOpenCL, ImageRead_NonDepthVector3FloatResult_Bad) { std::string spirv = R"( OpCapability Addresses OpCapability Kernel OpCapability ImageBasic OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %5 "image_kernel" OpName %img "img" OpName %coord "coord" OpName %call "call" %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %coord = OpConstantNull %v2uint %void = OpTypeVoid %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %3 = OpTypeImage %void 2D 0 0 0 0 Unknown ReadOnly %4 = OpTypeFunction %void %3 %5 = OpFunction %void None %4 %img = OpFunctionParameter %3 %entry = OpLabel %call = OpImageRead %v3float %img %coord OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_OPENCL_1_2)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type to have 4 components")); } TEST_F(ValidateOpenCL, ImageRead_NonDepthVector4FloatResult_Ok) { std::string spirv = R"( OpCapability Addresses OpCapability Kernel OpCapability ImageBasic OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %5 "image_kernel" OpName %img "img" OpName %coord "coord" OpName %call "call" %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %coord = OpConstantNull %v2uint %void = OpTypeVoid %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %3 = OpTypeImage %void 2D 0 0 0 0 Unknown ReadOnly %4 = OpTypeFunction %void %3 %5 = OpFunction %void None %4 %img = OpFunctionParameter %3 %entry = OpLabel %call = OpImageRead %v4float %img %coord OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_OPENCL_1_2)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateOpenCL, ImageRead_NonDepthVector4IntResult_Ok) { std::string spirv = R"( OpCapability Addresses OpCapability Kernel OpCapability ImageBasic OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %5 "image_kernel" OpName %img "img" OpName %coord "coord" OpName %call "call" %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %coord = OpConstantNull %v2uint %void = OpTypeVoid %v4uint = OpTypeVector %uint 4 %3 = OpTypeImage %void 2D 0 0 0 0 Unknown ReadOnly %4 = OpTypeFunction %void %3 %5 = OpFunction %void None %4 %img = OpFunctionParameter %3 %entry = OpLabel %call = OpImageRead %v4uint %img %coord OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_OPENCL_1_2)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateOpenCL, ImageRead_DepthScalarFloatResult_Ok) { std::string spirv = R"( OpCapability Addresses OpCapability Kernel OpCapability ImageBasic OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %5 "image_kernel" OpName %img "img" OpName %coord "coord" OpName %call "call" %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %coord = OpConstantNull %v2uint %void = OpTypeVoid %float = OpTypeFloat 32 %3 = OpTypeImage %void 2D 1 0 0 0 Unknown ReadOnly %4 = OpTypeFunction %void %3 %5 = OpFunction %void None %4 %img = OpFunctionParameter %3 %entry = OpLabel %call = OpImageRead %float %img %coord OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_OPENCL_1_2)); EXPECT_THAT(getDiagnosticString(), Eq("")); } TEST_F(ValidateOpenCL, ImageRead_DepthScalarIntResult_Bad) { std::string spirv = R"( OpCapability Addresses OpCapability Kernel OpCapability ImageBasic OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %5 "image_kernel" OpName %img "img" OpName %coord "coord" OpName %call "call" %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %coord = OpConstantNull %v2uint %void = OpTypeVoid %float = OpTypeFloat 32 %3 = OpTypeImage %void 2D 1 0 0 0 Unknown ReadOnly %4 = OpTypeFunction %void %3 %5 = OpFunction %void None %4 %img = OpFunctionParameter %3 %entry = OpLabel %call = OpImageRead %uint %img %coord OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_OPENCL_1_2)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type from a depth image " "read to result in a scalar float value")); } TEST_F(ValidateOpenCL, ImageRead_DepthVectorFloatResult_Bad) { std::string spirv = R"( OpCapability Addresses OpCapability Kernel OpCapability ImageBasic OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %5 "image_kernel" OpName %img "img" OpName %coord "coord" OpName %call "call" %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %coord = OpConstantNull %v2uint %void = OpTypeVoid %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %3 = OpTypeImage %void 2D 1 0 0 0 Unknown ReadOnly %4 = OpTypeFunction %void %3 %5 = OpFunction %void None %4 %img = OpFunctionParameter %3 %entry = OpLabel %call = OpImageRead %v4float %img %coord OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_OPENCL_1_2)); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Result Type from a depth image " "read to result in a scalar float value")); } TEST_F(ValidateOpenCL, ImageSampleExplicitLodWithConstOffsetBad) { std::string spirv = R"( OpCapability Addresses OpCapability Kernel OpCapability ImageBasic OpCapability LiteralSampler OpMemoryModel Physical64 OpenCL OpEntryPoint Kernel %5 "image_kernel" OpName %img "img" OpName %coord "coord" OpName %call "call" %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %coord = OpConstantNull %v2uint %void = OpTypeVoid %3 = OpTypeImage %void 2D 0 0 0 0 Unknown ReadOnly %4 = OpTypeFunction %void %3 %8 = OpTypeSampler %10 = OpTypeSampledImage %3 %v4uint = OpTypeVector %uint 4 %float = OpTypeFloat 32 %9 = OpConstantSampler %8 None 0 Nearest %float_0 = OpConstant %float 0 %5 = OpFunction %void None %4 %6 = OpFunctionParameter %3 %entry = OpLabel %img = OpSampledImage %10 %6 %9 %call = OpImageSampleExplicitLod %v4uint %img %coord Lod|ConstOffset %float_0 %coord OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_OPENCL_1_2)); EXPECT_THAT( getDiagnosticString(), HasSubstr( "ConstOffset image operand not allowed in the OpenCL environment." "\n %call = OpImageSampleExplicitLod %v4uint %img " "%coord Lod|ConstOffset %float_0 %coord\n")); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_primitives_test.cpp000066400000000000000000000251661475742701700251040ustar00rootroot00000000000000// Copyright (c) 2017 LunarG Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gmock/gmock.h" #include "test/unit_spirv.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::HasSubstr; using ::testing::Not; using ValidatePrimitives = spvtest::ValidateBase; std::string GenerateShaderCode( const std::string& body, const std::string& capabilities_and_extensions = "OpCapability GeometryStreams", const std::string& execution_model = "Geometry") { std::ostringstream ss; ss << capabilities_and_extensions << "\n"; ss << "OpMemoryModel Logical GLSL450\n"; ss << "OpEntryPoint " << execution_model << " %main \"main\"\n"; if (execution_model == "Geometry") { ss << "OpExecutionMode %main InputPoints\n"; ss << "OpExecutionMode %main OutputPoints\n"; } ss << R"( %void = OpTypeVoid %func = OpTypeFunction %void %f32 = OpTypeFloat 32 %u32 = OpTypeInt 32 0 %u32vec4 = OpTypeVector %u32 4 %f32_0 = OpConstant %f32 0 %u32_0 = OpConstant %u32 0 %u32_1 = OpConstant %u32 1 %u32_2 = OpConstant %u32 2 %u32_3 = OpConstant %u32 3 %u32vec4_0123 = OpConstantComposite %u32vec4 %u32_0 %u32_1 %u32_2 %u32_3 %main = OpFunction %void None %func %main_entry = OpLabel )"; ss << body; ss << R"( OpReturn OpFunctionEnd)"; return ss.str(); } // Returns SPIR-V assembly fragment representing a function call, // the end of the callee body, and the preamble and body of the called // function with the given body, but missing the final return and // function-end. The result is of the form where it can be used in the // |body| argument to GenerateShaderCode. std::string CallAndCallee(const std::string& body) { std::ostringstream ss; ss << R"( %placeholder = OpFunctionCall %void %foo OpReturn OpFunctionEnd %foo = OpFunction %void None %func %foo_entry = OpLabel )"; ss << body; return ss.str(); } // OpEmitVertex doesn't have any parameters, so other validation // is handled by the binary parser, and generic dominance checks. TEST_F(ValidatePrimitives, EmitVertexSuccess) { CompileSuccessfully( GenerateShaderCode("OpEmitVertex", "OpCapability Geometry")); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidatePrimitives, EmitVertexFailMissingCapability) { CompileSuccessfully( GenerateShaderCode("OpEmitVertex", "OpCapability Shader", "Vertex")); EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Opcode EmitVertex requires one of these capabilities: Geometry")); } TEST_F(ValidatePrimitives, EmitVertexFailWrongExecutionMode) { CompileSuccessfully( GenerateShaderCode("OpEmitVertex", "OpCapability Geometry", "Vertex")); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("EmitVertex instructions require Geometry execution model")); } TEST_F(ValidatePrimitives, EmitVertexFailWrongExecutionModeNestedFunction) { CompileSuccessfully(GenerateShaderCode(CallAndCallee("OpEmitVertex"), "OpCapability Geometry", "Vertex")); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("EmitVertex instructions require Geometry execution model")); } // OpEndPrimitive doesn't have any parameters, so other validation // is handled by the binary parser, and generic dominance checks. TEST_F(ValidatePrimitives, EndPrimitiveSuccess) { CompileSuccessfully( GenerateShaderCode("OpEndPrimitive", "OpCapability Geometry")); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidatePrimitives, EndPrimitiveFailMissingCapability) { CompileSuccessfully( GenerateShaderCode("OpEndPrimitive", "OpCapability Shader", "Vertex")); EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "Opcode EndPrimitive requires one of these capabilities: Geometry")); } TEST_F(ValidatePrimitives, EndPrimitiveFailWrongExecutionMode) { CompileSuccessfully( GenerateShaderCode("OpEndPrimitive", "OpCapability Geometry", "Vertex")); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("EndPrimitive instructions require Geometry execution model")); } TEST_F(ValidatePrimitives, EndPrimitiveFailWrongExecutionModeNestedFunction) { CompileSuccessfully(GenerateShaderCode(CallAndCallee("OpEndPrimitive"), "OpCapability Geometry", "Vertex")); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("EndPrimitive instructions require Geometry execution model")); } TEST_F(ValidatePrimitives, EmitStreamVertexSuccess) { const std::string body = R"( OpEmitStreamVertex %u32_0 )"; CompileSuccessfully(GenerateShaderCode(body)); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidatePrimitives, EmitStreamVertexFailMissingCapability) { CompileSuccessfully(GenerateShaderCode("OpEmitStreamVertex %u32_0", "OpCapability Shader", "Vertex")); EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Opcode EmitStreamVertex requires one of these " "capabilities: GeometryStreams")); } TEST_F(ValidatePrimitives, EmitStreamVertexFailWrongExecutionMode) { CompileSuccessfully(GenerateShaderCode( "OpEmitStreamVertex %u32_0", "OpCapability GeometryStreams", "Vertex")); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "EmitStreamVertex instructions require Geometry execution model")); } TEST_F(ValidatePrimitives, EmitStreamVertexFailWrongExecutionModeNestedFunction) { CompileSuccessfully( GenerateShaderCode(CallAndCallee("OpEmitStreamVertex %u32_0"), "OpCapability GeometryStreams", "Vertex")); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "EmitStreamVertex instructions require Geometry execution model")); } TEST_F(ValidatePrimitives, EmitStreamVertexNonInt) { const std::string body = R"( OpEmitStreamVertex %f32_0 )"; CompileSuccessfully(GenerateShaderCode(body)); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("EmitStreamVertex: " "expected Stream to be int scalar")); } TEST_F(ValidatePrimitives, EmitStreamVertexNonScalar) { const std::string body = R"( OpEmitStreamVertex %u32vec4_0123 )"; CompileSuccessfully(GenerateShaderCode(body)); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("EmitStreamVertex: " "expected Stream to be int scalar")); } TEST_F(ValidatePrimitives, EmitStreamVertexNonConstant) { const std::string body = R"( %val1 = OpIAdd %u32 %u32_0 %u32_1 OpEmitStreamVertex %val1 )"; CompileSuccessfully(GenerateShaderCode(body)); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("EmitStreamVertex: " "expected Stream to be constant instruction")); } TEST_F(ValidatePrimitives, EndStreamPrimitiveSuccess) { const std::string body = R"( OpEndStreamPrimitive %u32_0 )"; CompileSuccessfully(GenerateShaderCode(body)); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidatePrimitives, EndStreamPrimitiveFailMissingCapability) { CompileSuccessfully(GenerateShaderCode("OpEndStreamPrimitive %u32_0", "OpCapability Shader", "Vertex")); EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Opcode EndStreamPrimitive requires one of these " "capabilities: GeometryStreams")); } TEST_F(ValidatePrimitives, EndStreamPrimitiveFailWrongExecutionMode) { CompileSuccessfully(GenerateShaderCode( "OpEndStreamPrimitive %u32_0", "OpCapability GeometryStreams", "Vertex")); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "EndStreamPrimitive instructions require Geometry execution model")); } TEST_F(ValidatePrimitives, EndStreamPrimitiveFailWrongExecutionModeNestedFunction) { CompileSuccessfully( GenerateShaderCode(CallAndCallee("OpEndStreamPrimitive %u32_0"), "OpCapability GeometryStreams", "Vertex")); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "EndStreamPrimitive instructions require Geometry execution model")); } TEST_F(ValidatePrimitives, EndStreamPrimitiveNonInt) { const std::string body = R"( OpEndStreamPrimitive %f32_0 )"; CompileSuccessfully(GenerateShaderCode(body)); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("EndStreamPrimitive: " "expected Stream to be int scalar")); } TEST_F(ValidatePrimitives, EndStreamPrimitiveNonScalar) { const std::string body = R"( OpEndStreamPrimitive %u32vec4_0123 )"; CompileSuccessfully(GenerateShaderCode(body)); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("EndStreamPrimitive: " "expected Stream to be int scalar")); } TEST_F(ValidatePrimitives, EndStreamPrimitiveNonConstant) { const std::string body = R"( %val1 = OpIAdd %u32 %u32_0 %u32_1 OpEndStreamPrimitive %val1 )"; CompileSuccessfully(GenerateShaderCode(body)); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("EndStreamPrimitive: " "expected Stream to be constant instruction")); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_ray_query_test.cpp000066400000000000000000000641451475742701700247310ustar00rootroot00000000000000// Copyright (c) 2022 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Tests ray query instructions from SPV_KHR_ray_query. #include #include #include "gmock/gmock.h" #include "spirv-tools/libspirv.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::HasSubstr; using ::testing::Values; using ValidateRayQuery = spvtest::ValidateBase; std::string GenerateShaderCode(const std::string& body, const std::string& capabilities = "", const std::string& extensions = "", const std::string& declarations = "") { std::ostringstream ss; ss << R"( OpCapability Shader OpCapability Int64 OpCapability Float64 OpCapability RayQueryKHR )"; ss << capabilities; ss << R"( OpExtension "SPV_KHR_ray_query" )"; ss << extensions; ss << R"( OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpDecorate %top_level_as DescriptorSet 0 OpDecorate %top_level_as Binding 0 %void = OpTypeVoid %func = OpTypeFunction %void %bool = OpTypeBool %f32 = OpTypeFloat 32 %f64 = OpTypeFloat 64 %u32 = OpTypeInt 32 0 %s32 = OpTypeInt 32 1 %u64 = OpTypeInt 64 0 %s64 = OpTypeInt 64 1 %type_rq = OpTypeRayQueryKHR %type_as = OpTypeAccelerationStructureKHR %s32vec2 = OpTypeVector %s32 2 %u32vec2 = OpTypeVector %u32 2 %f32vec2 = OpTypeVector %f32 2 %u32vec3 = OpTypeVector %u32 3 %s32vec3 = OpTypeVector %s32 3 %f32vec3 = OpTypeVector %f32 3 %u32vec4 = OpTypeVector %u32 4 %s32vec4 = OpTypeVector %s32 4 %f32vec4 = OpTypeVector %f32 4 %mat4x3 = OpTypeMatrix %f32vec3 4 %f32_0 = OpConstant %f32 0 %f64_0 = OpConstant %f64 0 %s32_0 = OpConstant %s32 0 %u32_0 = OpConstant %u32 0 %u64_0 = OpConstant %u64 0 %u32_2 = OpConstant %u32 2 %arr2v3 = OpTypeArray %f32vec3 %u32_2 %arr2f3 = OpTypeArray %f32 %u32_2 %u32vec3_0 = OpConstantComposite %u32vec3 %u32_0 %u32_0 %u32_0 %f32vec3_0 = OpConstantComposite %f32vec3 %f32_0 %f32_0 %f32_0 %f32vec4_0 = OpConstantComposite %f32vec4 %f32_0 %f32_0 %f32_0 %f32_0 %ptr_rq = OpTypePointer Function %type_rq %ptr_as = OpTypePointer UniformConstant %type_as %top_level_as = OpVariable %ptr_as UniformConstant %ptr_function_u32 = OpTypePointer Function %u32 %ptr_function_f32 = OpTypePointer Function %f32 %ptr_function_f32vec3 = OpTypePointer Function %f32vec3 )"; ss << declarations; ss << R"( %main = OpFunction %void None %func %main_entry = OpLabel %ray_query = OpVariable %ptr_rq Function )"; ss << body; ss << R"( OpReturn OpFunctionEnd)"; return ss.str(); } std::string RayQueryResult(std::string opcode) { if (opcode.compare("OpRayQueryProceedKHR") == 0 || opcode.compare("OpRayQueryGetIntersectionTypeKHR") == 0 || opcode.compare("OpRayQueryGetRayTMinKHR") == 0 || opcode.compare("OpRayQueryGetRayFlagsKHR") == 0 || opcode.compare("OpRayQueryGetIntersectionTKHR") == 0 || opcode.compare("OpRayQueryGetIntersectionInstanceCustomIndexKHR") == 0 || opcode.compare("OpRayQueryGetIntersectionInstanceIdKHR") == 0 || opcode.compare("OpRayQueryGetIntersectionInstanceShaderBindingTableRecord" "OffsetKHR") == 0 || opcode.compare("OpRayQueryGetIntersectionGeometryIndexKHR") == 0 || opcode.compare("OpRayQueryGetIntersectionPrimitiveIndexKHR") == 0 || opcode.compare("OpRayQueryGetIntersectionBarycentricsKHR") == 0 || opcode.compare("OpRayQueryGetIntersectionFrontFaceKHR") == 0 || opcode.compare("OpRayQueryGetIntersectionCandidateAABBOpaqueKHR") == 0 || opcode.compare("OpRayQueryGetIntersectionObjectRayDirectionKHR") == 0 || opcode.compare("OpRayQueryGetIntersectionObjectRayOriginKHR") == 0 || opcode.compare("OpRayQueryGetWorldRayDirectionKHR") == 0 || opcode.compare("OpRayQueryGetWorldRayOriginKHR") == 0 || opcode.compare("OpRayQueryGetIntersectionObjectToWorldKHR") == 0 || opcode.compare("OpRayQueryGetIntersectionWorldToObjectKHR") == 0) { return "%result ="; } return ""; } std::string RayQueryResultType(std::string opcode, bool valid) { if (opcode.compare("OpRayQueryGetIntersectionTypeKHR") == 0 || opcode.compare("OpRayQueryGetRayFlagsKHR") == 0 || opcode.compare("OpRayQueryGetIntersectionInstanceCustomIndexKHR") == 0 || opcode.compare("OpRayQueryGetIntersectionInstanceIdKHR") == 0 || opcode.compare("OpRayQueryGetIntersectionInstanceShaderBindingTableRecord" "OffsetKHR") == 0 || opcode.compare("OpRayQueryGetIntersectionGeometryIndexKHR") == 0 || opcode.compare("OpRayQueryGetIntersectionPrimitiveIndexKHR") == 0) { return valid ? "%u32" : "%f64"; } if (opcode.compare("OpRayQueryGetRayTMinKHR") == 0 || opcode.compare("OpRayQueryGetIntersectionTKHR") == 0) { return valid ? "%f32" : "%f64"; } if (opcode.compare("OpRayQueryGetIntersectionBarycentricsKHR") == 0) { return valid ? "%f32vec2" : "%f64"; } if (opcode.compare("OpRayQueryGetIntersectionObjectRayDirectionKHR") == 0 || opcode.compare("OpRayQueryGetIntersectionObjectRayOriginKHR") == 0 || opcode.compare("OpRayQueryGetWorldRayDirectionKHR") == 0 || opcode.compare("OpRayQueryGetWorldRayOriginKHR") == 0) { return valid ? "%f32vec3" : "%f64"; } if (opcode.compare("OpRayQueryProceedKHR") == 0 || opcode.compare("OpRayQueryGetIntersectionFrontFaceKHR") == 0 || opcode.compare("OpRayQueryGetIntersectionCandidateAABBOpaqueKHR") == 0) { return valid ? "%bool" : "%f64"; } if (opcode.compare("OpRayQueryGetIntersectionObjectToWorldKHR") == 0 || opcode.compare("OpRayQueryGetIntersectionWorldToObjectKHR") == 0) { return valid ? "%mat4x3" : "%f64"; } return ""; } std::string RayQueryIntersection(std::string opcode, bool valid) { if (opcode.compare("OpRayQueryGetIntersectionTypeKHR") == 0 || opcode.compare("OpRayQueryGetIntersectionTKHR") == 0 || opcode.compare("OpRayQueryGetIntersectionInstanceCustomIndexKHR") == 0 || opcode.compare("OpRayQueryGetIntersectionInstanceIdKHR") == 0 || opcode.compare("OpRayQueryGetIntersectionInstanceShaderBindingTableRecord" "OffsetKHR") == 0 || opcode.compare("OpRayQueryGetIntersectionGeometryIndexKHR") == 0 || opcode.compare("OpRayQueryGetIntersectionPrimitiveIndexKHR") == 0 || opcode.compare("OpRayQueryGetIntersectionBarycentricsKHR") == 0 || opcode.compare("OpRayQueryGetIntersectionFrontFaceKHR") == 0 || opcode.compare("OpRayQueryGetIntersectionObjectRayDirectionKHR") == 0 || opcode.compare("OpRayQueryGetIntersectionObjectRayOriginKHR") == 0 || opcode.compare("OpRayQueryGetIntersectionObjectToWorldKHR") == 0 || opcode.compare("OpRayQueryGetIntersectionWorldToObjectKHR") == 0) { return valid ? "%s32_0" : "%f32_0"; } return ""; } using RayQueryCommon = spvtest::ValidateBase; TEST_P(RayQueryCommon, Success) { std::string opcode = GetParam(); std::ostringstream ss; ss << RayQueryResult(opcode); ss << " " << opcode << " "; ss << RayQueryResultType(opcode, true); ss << " %ray_query "; ss << RayQueryIntersection(opcode, true); CompileSuccessfully(GenerateShaderCode(ss.str()).c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(RayQueryCommon, BadQuery) { std::string opcode = GetParam(); std::ostringstream ss; ss << RayQueryResult(opcode); ss << " " << opcode << " "; ss << RayQueryResultType(opcode, true); ss << " %top_level_as "; ss << RayQueryIntersection(opcode, true); CompileSuccessfully(GenerateShaderCode(ss.str()).c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Ray Query must be a pointer to OpTypeRayQueryKHR")); } TEST_P(RayQueryCommon, BadResult) { std::string opcode = GetParam(); std::string result_type = RayQueryResultType(opcode, false); if (!result_type.empty()) { std::ostringstream ss; ss << RayQueryResult(opcode); ss << " " << opcode << " "; ss << result_type; ss << " %ray_query "; ss << RayQueryIntersection(opcode, true); CompileSuccessfully(GenerateShaderCode(ss.str()).c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); std::string correct_result_type = RayQueryResultType(opcode, true); if (correct_result_type.compare("%u32") == 0) { EXPECT_THAT( getDiagnosticString(), HasSubstr("expected Result Type to be 32-bit int scalar type")); } else if (correct_result_type.compare("%f32") == 0) { EXPECT_THAT( getDiagnosticString(), HasSubstr("expected Result Type to be 32-bit float scalar type")); } else if (correct_result_type.compare("%f32vec2") == 0) { EXPECT_THAT(getDiagnosticString(), HasSubstr("expected Result Type to be 32-bit float " "2-component vector type")); } else if (correct_result_type.compare("%f32vec3") == 0) { EXPECT_THAT(getDiagnosticString(), HasSubstr("expected Result Type to be 32-bit float " "3-component vector type")); } else if (correct_result_type.compare("%bool") == 0) { EXPECT_THAT(getDiagnosticString(), HasSubstr("expected Result Type to be bool scalar type")); } else if (correct_result_type.compare("%mat4x3") == 0) { EXPECT_THAT(getDiagnosticString(), HasSubstr("expected matrix type as Result Type")); } } } TEST_P(RayQueryCommon, BadIntersection) { std::string opcode = GetParam(); std::string intersection = RayQueryIntersection(opcode, false); if (!intersection.empty()) { std::ostringstream ss; ss << RayQueryResult(opcode); ss << " " << opcode << " "; ss << RayQueryResultType(opcode, true); ss << " %ray_query "; ss << intersection; CompileSuccessfully(GenerateShaderCode(ss.str()).c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "expected Intersection ID to be a constant 32-bit int scalar")); } } INSTANTIATE_TEST_SUITE_P( ValidateRayQueryCommon, RayQueryCommon, Values("OpRayQueryTerminateKHR", "OpRayQueryConfirmIntersectionKHR", "OpRayQueryProceedKHR", "OpRayQueryGetIntersectionTypeKHR", "OpRayQueryGetRayTMinKHR", "OpRayQueryGetRayFlagsKHR", "OpRayQueryGetWorldRayDirectionKHR", "OpRayQueryGetWorldRayOriginKHR", "OpRayQueryGetIntersectionTKHR", "OpRayQueryGetIntersectionInstanceCustomIndexKHR", "OpRayQueryGetIntersectionInstanceIdKHR", "OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR", "OpRayQueryGetIntersectionGeometryIndexKHR", "OpRayQueryGetIntersectionPrimitiveIndexKHR", "OpRayQueryGetIntersectionBarycentricsKHR", "OpRayQueryGetIntersectionFrontFaceKHR", "OpRayQueryGetIntersectionCandidateAABBOpaqueKHR", "OpRayQueryGetIntersectionObjectRayDirectionKHR", "OpRayQueryGetIntersectionObjectRayOriginKHR", "OpRayQueryGetIntersectionObjectToWorldKHR", "OpRayQueryGetIntersectionWorldToObjectKHR")); // tests various Intersection operand types TEST_F(ValidateRayQuery, IntersectionSuccess) { const std::string body = R"( %result_1 = OpRayQueryGetIntersectionFrontFaceKHR %bool %ray_query %s32_0 %result_2 = OpRayQueryGetIntersectionFrontFaceKHR %bool %ray_query %u32_0 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateRayQuery, IntersectionVector) { const std::string body = R"( %result = OpRayQueryGetIntersectionFrontFaceKHR %bool %ray_query %u32vec3_0 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("expected Intersection ID to be a constant 32-bit int scalar")); } TEST_F(ValidateRayQuery, IntersectionNonConstantVariable) { const std::string body = R"( %var = OpVariable %ptr_function_u32 Function %result = OpRayQueryGetIntersectionFrontFaceKHR %bool %ray_query %var )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("expected Intersection ID to be a constant 32-bit int scalar")); } TEST_F(ValidateRayQuery, IntersectionNonConstantLoad) { const std::string body = R"( %var = OpVariable %ptr_function_u32 Function %load = OpLoad %u32 %var %result = OpRayQueryGetIntersectionFrontFaceKHR %bool %ray_query %load )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("expected Intersection ID to be a constant 32-bit int scalar")); } TEST_F(ValidateRayQuery, InitializeSuccess) { const std::string body = R"( %var_u32 = OpVariable %ptr_function_u32 Function %var_f32 = OpVariable %ptr_function_f32 Function %var_f32vec3 = OpVariable %ptr_function_f32vec3 Function %as = OpLoad %type_as %top_level_as OpRayQueryInitializeKHR %ray_query %as %u32_0 %u32_0 %f32vec3_0 %f32_0 %f32vec3_0 %f32_0 %_u32 = OpLoad %u32 %var_u32 %_f32 = OpLoad %f32 %var_f32 %_f32vec3 = OpLoad %f32vec3 %var_f32vec3 OpRayQueryInitializeKHR %ray_query %as %_u32 %_u32 %_f32vec3 %_f32 %_f32vec3 %_f32 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateRayQuery, InitializeFunctionSuccess) { const std::string declaration = R"( %rq_ptr = OpTypePointer Private %type_rq %rq_func_type = OpTypeFunction %void %rq_ptr %rq_var_1 = OpVariable %rq_ptr Private %rq_var_2 = OpVariable %rq_ptr Private )"; const std::string body = R"( %fcall_1 = OpFunctionCall %void %rq_func %rq_var_1 %as_1 = OpLoad %type_as %top_level_as OpRayQueryInitializeKHR %rq_var_1 %as_1 %u32_0 %u32_0 %f32vec3_0 %f32_0 %f32vec3_0 %f32_0 %fcall_2 = OpFunctionCall %void %rq_func %rq_var_2 OpReturn OpFunctionEnd %rq_func = OpFunction %void None %rq_func_type %rq_param = OpFunctionParameter %rq_ptr %label = OpLabel %as_2 = OpLoad %type_as %top_level_as OpRayQueryInitializeKHR %rq_param %as_2 %u32_0 %u32_0 %f32vec3_0 %f32_0 %f32vec3_0 %f32_0 )"; CompileSuccessfully(GenerateShaderCode(body, "", "", declaration).c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateRayQuery, InitializeBadRayQuery) { const std::string body = R"( %load = OpLoad %type_as %top_level_as OpRayQueryInitializeKHR %top_level_as %load %u32_0 %u32_0 %f32vec3_0 %f32_0 %f32vec3_0 %f32_0 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Ray Query must be a pointer to OpTypeRayQueryKHR")); } TEST_F(ValidateRayQuery, InitializeBadAS) { const std::string body = R"( OpRayQueryInitializeKHR %ray_query %ray_query %u32_0 %u32_0 %f32vec3_0 %f32_0 %f32vec3_0 %f32_0 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Acceleration Structure to be of type " "OpTypeAccelerationStructureKHR")); } TEST_F(ValidateRayQuery, InitializeBadRayFlags64) { const std::string body = R"( %load = OpLoad %type_as %top_level_as OpRayQueryInitializeKHR %ray_query %load %u64_0 %u32_0 %f32vec3_0 %f32_0 %f32vec3_0 %f32_0 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Ray Flags must be a 32-bit int scalar")); } TEST_F(ValidateRayQuery, InitializeBadRayFlagsVector) { const std::string body = R"( %load = OpLoad %type_as %top_level_as OpRayQueryInitializeKHR %ray_query %load %u32vec2 %u32_0 %f32vec3_0 %f32_0 %f32vec3_0 %f32_0 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Operand '15[%v2uint]' cannot be a type")); } TEST_F(ValidateRayQuery, InitializeBadCullMask) { const std::string body = R"( %load = OpLoad %type_as %top_level_as OpRayQueryInitializeKHR %ray_query %load %u32_0 %f32_0 %f32vec3_0 %f32_0 %f32vec3_0 %f32_0 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Cull Mask must be a 32-bit int scalar")); } TEST_F(ValidateRayQuery, InitializeBadRayOriginVec4) { const std::string body = R"( %load = OpLoad %type_as %top_level_as OpRayQueryInitializeKHR %ray_query %load %u32_0 %u32_0 %f32vec4_0 %f32_0 %f32vec3_0 %f32_0 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Ray Origin must be a 32-bit float 3-component vector")); } TEST_F(ValidateRayQuery, InitializeBadRayOriginFloat) { const std::string body = R"( %var_f32 = OpVariable %ptr_function_f32 Function %_f32 = OpLoad %f32 %var_f32 %load = OpLoad %type_as %top_level_as OpRayQueryInitializeKHR %ray_query %load %u32_0 %u32_0 %_f32 %f32_0 %f32vec3_0 %f32_0 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Ray Origin must be a 32-bit float 3-component vector")); } TEST_F(ValidateRayQuery, InitializeBadRayOriginInt) { const std::string body = R"( %load = OpLoad %type_as %top_level_as OpRayQueryInitializeKHR %ray_query %load %u32_0 %u32_0 %u32vec3_0 %f32_0 %f32vec3_0 %f32_0 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Ray Origin must be a 32-bit float 3-component vector")); } TEST_F(ValidateRayQuery, InitializeBadRayTMin) { const std::string body = R"( %load = OpLoad %type_as %top_level_as OpRayQueryInitializeKHR %ray_query %load %u32_0 %u32_0 %f32vec3_0 %u32_0 %f32vec3_0 %f32_0 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Ray TMin must be a 32-bit float scalar")); } TEST_F(ValidateRayQuery, InitializeBadRayDirection) { const std::string body = R"( %load = OpLoad %type_as %top_level_as OpRayQueryInitializeKHR %ray_query %load %u32_0 %u32_0 %f32vec3_0 %f32_0 %f32vec4_0 %f32_0 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Ray Direction must be a 32-bit float 3-component vector")); } TEST_F(ValidateRayQuery, InitializeBadRayTMax) { const std::string body = R"( %load = OpLoad %type_as %top_level_as OpRayQueryInitializeKHR %ray_query %load %u32_0 %u32_0 %f32vec3_0 %f32_0 %f32vec3_0 %f64_0 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Ray TMax must be a 32-bit float scalar")); } TEST_F(ValidateRayQuery, GenerateIntersectionSuccess) { const std::string body = R"( %var = OpVariable %ptr_function_f32 Function %load = OpLoad %f32 %var OpRayQueryGenerateIntersectionKHR %ray_query %f32_0 OpRayQueryGenerateIntersectionKHR %ray_query %load )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateRayQuery, GenerateIntersectionBadRayQuery) { const std::string body = R"( OpRayQueryGenerateIntersectionKHR %top_level_as %f32_0 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Ray Query must be a pointer to OpTypeRayQueryKHR")); } TEST_F(ValidateRayQuery, GenerateIntersectionBadHitT) { const std::string body = R"( OpRayQueryGenerateIntersectionKHR %ray_query %u32_0 )"; CompileSuccessfully(GenerateShaderCode(body).c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Hit T must be a 32-bit float scalar")); } TEST_F(ValidateRayQuery, RayQueryArraySuccess) { // This shader is slightly different to the ones above, so it doesn't reuse // the shader code generator. const std::string shader = R"( OpCapability Shader OpCapability RayQueryKHR OpExtension "SPV_KHR_ray_query" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" OpExecutionMode %main LocalSize 1 1 1 OpSource GLSL 460 OpDecorate %topLevelAS DescriptorSet 0 OpDecorate %topLevelAS Binding 0 OpDecorate %gl_WorkGroupSize BuiltIn WorkgroupSize %void = OpTypeVoid %func = OpTypeFunction %void %ray_query = OpTypeRayQueryKHR %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %ray_query_array = OpTypeArray %ray_query %uint_2 %ptr_ray_query_array = OpTypePointer Private %ray_query_array %rayQueries = OpVariable %ptr_ray_query_array Private %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %ptr_ray_query = OpTypePointer Private %ray_query %accel_struct = OpTypeAccelerationStructureKHR %ptr_accel_struct = OpTypePointer UniformConstant %accel_struct %topLevelAS = OpVariable %ptr_accel_struct UniformConstant %uint_0 = OpConstant %uint 0 %uint_255 = OpConstant %uint 255 %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %float_0 = OpConstant %float 0 %vec3_zero = OpConstantComposite %v3float %float_0 %float_0 %float_0 %float_1 = OpConstant %float 1 %vec3_xy_0_z_1 = OpConstantComposite %v3float %float_0 %float_0 %float_1 %float_10 = OpConstant %float 10 %v3uint = OpTypeVector %uint 3 %uint_1 = OpConstant %uint 1 %gl_WorkGroupSize = OpConstantComposite %v3uint %uint_1 %uint_1 %uint_1 %main = OpFunction %void None %func %main_label = OpLabel %first_ray_query = OpAccessChain %ptr_ray_query %rayQueries %int_0 %topLevelAS_val = OpLoad %accel_struct %topLevelAS OpRayQueryInitializeKHR %first_ray_query %topLevelAS_val %uint_0 %uint_255 %vec3_zero %float_0 %vec3_xy_0_z_1 %float_10 OpReturn OpFunctionEnd )"; CompileSuccessfully(shader); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateRayQuery, ClusterASNV) { const std::string cap = R"( OpCapability RayTracingClusterAccelerationStructureNV )"; const std::string ext = R"( OpExtension "SPV_NV_cluster_acceleration_structure" )"; const std::string body = R"( %clusterid = OpRayQueryGetClusterIdNV %s32 %ray_query %s32_0 )"; CompileSuccessfully(GenerateShaderCode(body, cap, ext).c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } using RayQueryLSSNVCommon = spvtest::ValidateBase; std::string RayQueryLSSNVResultType(std::string opcode, bool valid) { if (opcode.compare("OpRayQueryGetIntersectionLSSPositionsNV") == 0) return valid ? "%arr2v3" : "%f64"; if (opcode.compare("OpRayQueryGetIntersectionLSSRadiiNV") == 0) return valid ? "%arr2f3" : "%f64"; if (opcode.compare("OpRayQueryGetIntersectionSphereRadiusNV") == 0 || opcode.compare("OpRayQueryGetIntersectionLSSHitValueNV") == 0) { return valid ? "%f32" : "%f64"; } if (opcode.compare("OpRayQueryGetIntersectionSpherePositionNV") == 0) { return valid ? "%f32vec3" : "%f64"; } if (opcode.compare("OpRayQueryIsSphereHitNV") == 0 || opcode.compare("OpRayQueryIsLSSHitNV") == 0) { return valid ? "%bool" : "%f64"; } return ""; } TEST_P(RayQueryLSSNVCommon, Success) { const std::string cap = R"( OpCapability RayTracingSpheresGeometryNV OpCapability RayTracingLinearSweptSpheresGeometryNV )"; const std::string ext = R"( OpExtension "SPV_NV_linear_swept_spheres" )"; std::string opcode = GetParam(); std::ostringstream ss; ss << "%result = "; ss << " " << opcode << " "; ss << RayQueryLSSNVResultType(opcode, true); ss << " %ray_query "; ss << " %s32_0 "; CompileSuccessfully(GenerateShaderCode(ss.str(), cap, ext).c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } INSTANTIATE_TEST_SUITE_P(ValidateRayQueryLSSNVCommon, RayQueryLSSNVCommon, Values("OpRayQueryGetIntersectionSpherePositionNV", "OpRayQueryGetIntersectionLSSPositionsNV", "OpRayQueryGetIntersectionSphereRadiusNV", "OpRayQueryGetIntersectionLSSRadiiNV", "OpRayQueryGetIntersectionLSSHitValueNV", "OpRayQueryIsSphereHitNV", "OpRayQueryIsLSSHitNV")); } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_ray_tracing_reorder_test.cpp000066400000000000000000000646471475742701700267440ustar00rootroot00000000000000// Copyright (c) 2022 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Tests instructions from SPV_NV_shader_invocation_reorder. #include #include #include "gmock/gmock.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::HasSubstr; using ::testing::Values; using ValidateRayTracingReorderNV = spvtest::ValidateBase; std::string GenerateReorderThreadCode(const std::string& body = "", const std::string& declarations = "", const std::string& extensions = "", const std::string& capabilities = "") { std::ostringstream ss; ss << R"( OpCapability RayTracingKHR OpCapability ShaderInvocationReorderNV )"; ss << capabilities; ss << R"( OpExtension "SPV_KHR_ray_tracing" OpExtension "SPV_NV_shader_invocation_reorder" )"; ss << extensions; ss << R"( %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint RayGenerationNV %main "main" %hObj OpSourceExtension "GL_EXT_ray_tracing" OpSourceExtension "GL_NV_shader_invocation_reorder" OpName %main "main" %void = OpTypeVoid %3 = OpTypeFunction %void %6 = OpTypeHitObjectNV %_ptr_Private_6 = OpTypePointer Private %6 %hObj = OpVariable %_ptr_Private_6 Private )"; ss << declarations; ss << R"( %main = OpFunction %void None %3 %5 = OpLabel )"; ss << body; ss << R"( OpReturn OpFunctionEnd )"; return ss.str(); } TEST_F(ValidateRayTracingReorderNV, ReorderThreadWithHintNV) { const std::string declarations = R"( %uint = OpTypeInt 32 0 %uint_4 = OpConstant %uint 4 )"; const std::string body = R"( OpReorderThreadWithHintNV %uint_4 %uint_4 )"; CompileSuccessfully(GenerateReorderThreadCode(body, declarations).c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateRayTracingReorderNV, ReorderThreadWithHitObjectNV) { const std::string declarations = R"( %uint = OpTypeInt 32 0 %uint_4 = OpConstant %uint 4 %uint_2 = OpConstant %uint 2 )"; const std::string body = R"( OpReorderThreadWithHitObjectNV %hObj OpReorderThreadWithHitObjectNV %hObj %uint_4 %uint_2 )"; CompileSuccessfully(GenerateReorderThreadCode(body, declarations).c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } std::string GenerateReorderShaderCode( const std::string& body = "", const std::string& declarations = "", const std::string execution_model = "RayGenerationKHR") { std::ostringstream ss; ss << R"( OpCapability RayTracingKHR OpCapability ShaderInvocationReorderNV OpExtension "SPV_KHR_ray_tracing" OpExtension "SPV_NV_shader_invocation_reorder" %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint )" << execution_model << R"( %main "main" %attr %_ %hObj %payload %__0 %as %__1 OpSource GLSL 460 OpSourceExtension "GL_EXT_ray_tracing" OpSourceExtension "GL_NV_shader_invocation_reorder" OpName %main "main" OpName %attr "attr" OpName %hBlock "hBlock" OpMemberName %hBlock 0 "attrval" OpName %_ "" OpName %hObj "hObj" OpName %payload "payload" OpName %pBlock "pBlock" OpMemberName %pBlock 0 "val1" OpMemberName %pBlock 1 "val2" OpName %__0 "" OpName %as "as" OpName %block "block" OpMemberName %block 0 "op" OpName %__1 "" OpDecorate %hBlock Block OpDecorate %pBlock Block OpDecorate %as DescriptorSet 0 OpDecorate %as Binding 0 OpMemberDecorate %block 0 Offset 0 OpDecorate %block Block OpDecorate %__1 DescriptorSet 0 OpDecorate %__1 Binding 1 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %_ptr_HitObjectAttributeNV_v2float = OpTypePointer HitObjectAttributeNV %v2float %attr = OpVariable %_ptr_HitObjectAttributeNV_v2float HitObjectAttributeNV %float_1 = OpConstant %float 1 %11 = OpConstantComposite %v2float %float_1 %float_1 %hBlock = OpTypeStruct %float %_ptr_HitObjectAttributeNV_hBlock = OpTypePointer HitObjectAttributeNV %hBlock %_ = OpVariable %_ptr_HitObjectAttributeNV_hBlock HitObjectAttributeNV %int = OpTypeInt 32 1 %int_0 = OpConstant %int 0 %float_2 = OpConstant %float 2 %_ptr_HitObjectAttributeNV_float = OpTypePointer HitObjectAttributeNV %float %20 = OpTypeHitObjectNV %_ptr_Private_20 = OpTypePointer Private %20 %hObj = OpVariable %_ptr_Private_20 Private %23 = OpTypeAccelerationStructureKHR %_ptr_UniformConstant_23 = OpTypePointer UniformConstant %23 %as = OpVariable %_ptr_UniformConstant_23 UniformConstant %v4float = OpTypeVector %float 4 %_ptr_RayPayloadNV_v4float = OpTypePointer RayPayloadNV %v4float %payload = OpVariable %_ptr_RayPayloadNV_v4float RayPayloadNV %pBlock = OpTypeStruct %v2float %v2float %_ptr_RayPayloadNV_pBlock = OpTypePointer RayPayloadNV %pBlock %__0 = OpVariable %_ptr_RayPayloadNV_pBlock RayPayloadNV %block = OpTypeStruct %float %_ptr_StorageBuffer_block = OpTypePointer StorageBuffer %block %__1 = OpVariable %_ptr_StorageBuffer_block StorageBuffer )"; ss << declarations; ss << R"( %main = OpFunction %void None %3 %5 = OpLabel )"; ss << body; ss << R"( OpReturn OpFunctionEnd)"; return ss.str(); } TEST_F(ValidateRayTracingReorderNV, HitObjectTraceRayNV) { const std::string declarations = R"( %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %v3float = OpTypeVector %float 3 %float_0_5 = OpConstant %float 0.5 %31 = OpConstantComposite %v3float %float_0_5 %float_0_5 %float_0_5 %32 = OpConstantComposite %v3float %float_1 %float_1 %float_1 %int_1 = OpConstant %int 1 )"; const std::string body = R"( OpStore %attr %11 %26 = OpLoad %23 %as OpHitObjectTraceRayNV %hObj %26 %uint_1 %uint_1 %uint_1 %uint_1 %uint_1 %31 %float_0_5 %32 %float_1 %payload )"; CompileSuccessfully(GenerateReorderShaderCode(body, declarations).c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateRayTracingReorderNV, HitObjectTraceRayMotionNV) { const std::string declarations = R"( %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %v3float = OpTypeVector %float 3 %float_0_5 = OpConstant %float 0.5 %31 = OpConstantComposite %v3float %float_0_5 %float_0_5 %float_0_5 %32 = OpConstantComposite %v3float %float_1 %float_1 %float_1 %float_10 = OpConstant %float 10 %int_2 = OpConstant %int 2 )"; const std::string body = R"( OpStore %attr %11 %26 = OpLoad %23 %as OpHitObjectTraceRayMotionNV %hObj %26 %uint_1 %uint_1 %uint_1 %uint_1 %uint_1 %31 %float_0_5 %32 %float_1 %float_10 %__0 )"; CompileSuccessfully(GenerateReorderShaderCode(body, declarations).c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateRayTracingReorderNV, HitObjectRecordHitNV) { const std::string declarations = R"( %int_1 = OpConstant %int 1 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %v3float = OpTypeVector %float 3 %float_0_5 = OpConstant %float 0.5 %31 = OpConstantComposite %v3float %float_0_5 %float_0_5 %float_0_5 %32 = OpConstantComposite %v3float %float_1 %float_1 %float_1 %float_10 = OpConstant %float 10 %int_2 = OpConstant %int 2 )"; const std::string body = R"( OpStore %attr %11 %26 = OpLoad %23 %as OpHitObjectRecordHitNV %hObj %26 %int_1 %int_1 %int_1 %uint_2 %uint_2 %uint_2 %31 %float_1 %32 %float_2 %attr )"; CompileSuccessfully(GenerateReorderShaderCode(body, declarations).c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateRayTracingReorderNV, HitObjectRecordHitWithIndexNV) { const std::string declarations = R"( %int_1 = OpConstant %int 1 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %v3float = OpTypeVector %float 3 %float_0_5 = OpConstant %float 0.5 %31 = OpConstantComposite %v3float %float_0_5 %float_0_5 %float_0_5 %32 = OpConstantComposite %v3float %float_1 %float_1 %float_1 %float_10 = OpConstant %float 10 %int_2 = OpConstant %int 2 )"; const std::string body = R"( OpStore %attr %11 %26 = OpLoad %23 %as OpHitObjectRecordHitWithIndexNV %hObj %26 %int_1 %int_1 %int_1 %uint_2 %uint_2 %31 %float_1 %32 %float_2 %_ )"; CompileSuccessfully(GenerateReorderShaderCode(body, declarations).c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateRayTracingReorderNV, HitObjectRecordEmptyNV) { const std::string body = R"( OpHitObjectRecordEmptyNV %hObj )"; CompileSuccessfully(GenerateReorderShaderCode(body).c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateRayTracingReorderNV, HitObjectRecordMissNV) { const std::string declarations = R"( %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %v3float = OpTypeVector %float 3 %float_0_5 = OpConstant %float 0.5 %29 = OpConstantComposite %v3float %float_0_5 %float_0_5 %float_0_5 %float_1_5 = OpConstant %float 1.5 %31 = OpConstantComposite %v3float %float_1_5 %float_1_5 %float_1_5 %float_5 = OpConstant %float 5 )"; const std::string body = R"( OpHitObjectRecordMissNV %hObj %uint_1 %29 %float_2 %31 %float_5 )"; CompileSuccessfully(GenerateReorderShaderCode(body, declarations).c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateRayTracingReorderNV, HitObjectIsHitNV) { const std::string declarations = R"( %bool = OpTypeBool %_ptr_StorageBuffer_float = OpTypePointer StorageBuffer %float )"; const std::string body = R"( %26 = OpHitObjectIsHitNV %bool %hObj OpSelectionMerge %28 None OpBranchConditional %26 %27 %28 %27 = OpLabel %33 = OpAccessChain %_ptr_StorageBuffer_float %__1 %int_0 OpStore %33 %float_1 OpBranch %28 %28 = OpLabel )"; CompileSuccessfully(GenerateReorderShaderCode(body, declarations).c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateRayTracingReorderNV, HitObjectGetRayTMaxNV) { const std::string declarations = R"( %_ptr_Function_float = OpTypePointer Function %float )"; const std::string body = R"( %tmin = OpVariable %_ptr_Function_float Function %12 = OpHitObjectGetRayTMaxNV %float %hObj OpStore %tmin %12 )"; CompileSuccessfully(GenerateReorderShaderCode(body, declarations).c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateRayTracingReorderNV, HitObjectGetRayTMinNV) { const std::string declarations = R"( %_ptr_Function_float = OpTypePointer Function %float )"; const std::string body = R"( %tmin = OpVariable %_ptr_Function_float Function %12 = OpHitObjectGetRayTMinNV %float %hObj OpStore %tmin %12 )"; CompileSuccessfully(GenerateReorderShaderCode(body, declarations).c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateRayTracingReorderNV, HitObjectGetWorldRayOriginNV) { const std::string declarations = R"( %v3float = OpTypeVector %float 3 %_ptr_Function_v3float = OpTypePointer Function %v3float )"; const std::string body = R"( %orig = OpVariable %_ptr_Function_v3float Function %13 = OpHitObjectGetWorldRayOriginNV %v3float %hObj OpStore %orig %13 )"; CompileSuccessfully(GenerateReorderShaderCode(body, declarations).c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateRayTracingReorderNV, HitObjectGetObjectRayOriginNV) { const std::string declarations = R"( %v3float = OpTypeVector %float 3 %_ptr_Function_v3float = OpTypePointer Function %v3float )"; const std::string body = R"( %oorig = OpVariable %_ptr_Function_v3float Function %13 = OpHitObjectGetObjectRayOriginNV %v3float %hObj OpStore %oorig %13 )"; CompileSuccessfully(GenerateReorderShaderCode(body, declarations).c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateRayTracingReorderNV, HitObjectGetWorldRayDirectionNV) { const std::string declarations = R"( %v3float = OpTypeVector %float 3 %_ptr_Function_v3float = OpTypePointer Function %v3float )"; const std::string body = R"( %dir = OpVariable %_ptr_Function_v3float Function %13 = OpHitObjectGetWorldRayDirectionNV %v3float %hObj OpStore %dir %13 )"; CompileSuccessfully(GenerateReorderShaderCode(body, declarations).c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateRayTracingReorderNV, HitObjectGetObjectRayDirectionNV) { const std::string declarations = R"( %v3float = OpTypeVector %float 3 %_ptr_Function_v3float = OpTypePointer Function %v3float )"; const std::string body = R"( %odir = OpVariable %_ptr_Function_v3float Function %13 = OpHitObjectGetObjectRayDirectionNV %v3float %hObj OpStore %odir %13 )"; CompileSuccessfully(GenerateReorderShaderCode(body, declarations).c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateRayTracingReorderNV, HitObjectGetObjectToWorldNV) { const std::string declarations = R"( %v3float = OpTypeVector %float 3 %mat4v3float = OpTypeMatrix %v3float 4 %_ptr_Function_mat4v3float = OpTypePointer Function %mat4v3float )"; const std::string body = R"( %otw = OpVariable %_ptr_Function_mat4v3float Function %14 = OpHitObjectGetObjectToWorldNV %mat4v3float %hObj OpStore %otw %14 )"; CompileSuccessfully(GenerateReorderShaderCode(body, declarations).c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateRayTracingReorderNV, HitObjectGetWorldToObjectNV) { const std::string declarations = R"( %v3float = OpTypeVector %float 3 %mat4v3float = OpTypeMatrix %v3float 4 %_ptr_Function_mat4v3float = OpTypePointer Function %mat4v3float )"; const std::string body = R"( %wto = OpVariable %_ptr_Function_mat4v3float Function %14 = OpHitObjectGetWorldToObjectNV %mat4v3float %hObj OpStore %wto %14 )"; CompileSuccessfully(GenerateReorderShaderCode(body, declarations).c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateRayTracingReorderNV, HitObjectGetInstanceCustomIndexNV) { const std::string declarations = R"( %_ptr_Function_int = OpTypePointer Function %int )"; const std::string body = R"( %id = OpVariable %_ptr_Function_int Function %12 = OpHitObjectGetInstanceCustomIndexNV %int %hObj OpStore %id %12 )"; CompileSuccessfully(GenerateReorderShaderCode(body, declarations).c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateRayTracingReorderNV, HitObjectGetInstanceIdNV) { const std::string declarations = R"( %_ptr_Function_int = OpTypePointer Function %int )"; const std::string body = R"( %id = OpVariable %_ptr_Function_int Function %12 = OpHitObjectGetInstanceIdNV %int %hObj OpStore %id %12 )"; CompileSuccessfully(GenerateReorderShaderCode(body, declarations).c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateRayTracingReorderNV, HitObjectGetPrimitiveIndexNV) { const std::string declarations = R"( %_ptr_Function_int = OpTypePointer Function %int )"; const std::string body = R"( %id = OpVariable %_ptr_Function_int Function %12 = OpHitObjectGetPrimitiveIndexNV %int %hObj OpStore %id %12 )"; CompileSuccessfully(GenerateReorderShaderCode(body, declarations).c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateRayTracingReorderNV, HitObjectGetGeometryIndexNV) { const std::string declarations = R"( %_ptr_Function_int = OpTypePointer Function %int )"; const std::string body = R"( %id = OpVariable %_ptr_Function_int Function %12 = OpHitObjectGetGeometryIndexNV %int %hObj OpStore %id %12 )"; CompileSuccessfully(GenerateReorderShaderCode(body, declarations).c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateRayTracingReorderNV, HitObjectGetHitKindNV) { const std::string declarations = R"( %uint = OpTypeInt 32 0 %_ptr_Function_uint = OpTypePointer Function %uint )"; const std::string body = R"( %uid = OpVariable %_ptr_Function_uint Function %12 = OpHitObjectGetHitKindNV %uint %hObj OpStore %uid %12 )"; CompileSuccessfully(GenerateReorderShaderCode(body, declarations).c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateRayTracingReorderNV, HitObjectGetAttributesNV) { const std::string body = R"( OpHitObjectGetAttributesNV %hObj %attr )"; CompileSuccessfully(GenerateReorderShaderCode(body).c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateRayTracingReorderNV, HitObjectGetShaderRecordBufferHandleNV) { const std::string declarations = R"( %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint )"; const std::string body = R"( %handle = OpVariable %_ptr_Function_v2uint Function %13 = OpHitObjectGetShaderRecordBufferHandleNV %v2uint %hObj OpStore %handle %13 )"; CompileSuccessfully(GenerateReorderShaderCode(body, declarations).c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateRayTracingReorderNV, HitObjectGetShaderBindingTableRecordIndexNV) { const std::string declarations = R"( %uint = OpTypeInt 32 0 %_ptr_Function_uint = OpTypePointer Function %uint )"; const std::string body = R"( %rid = OpVariable %_ptr_Function_uint Function %12 = OpHitObjectGetShaderBindingTableRecordIndexNV %uint %hObj OpStore %rid %12 )"; CompileSuccessfully(GenerateReorderShaderCode(body, declarations).c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateRayTracingReorderNV, ClusterASNV) { const std::string cap = R"( OpCapability RayTracingClusterAccelerationStructureNV )"; const std::string ext = R"( OpExtension "SPV_NV_cluster_acceleration_structure" )"; const std::string declarations = R"( %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int )"; const std::string body = R"( %id = OpVariable %_ptr_Function_int Function %12 = OpHitObjectGetClusterIdNV %int %hObj OpStore %id %12 )"; CompileSuccessfully( GenerateReorderThreadCode(body, declarations, ext, cap).c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateRayTracingReorderNV, LSSGetSpherePositionNV) { const std::string cap = R"( OpCapability RayTracingSpheresGeometryNV )"; const std::string ext = R"( OpExtension "SPV_NV_linear_swept_spheres" )"; const std::string declarations = R"( %float = OpTypeFloat 32 %v3float = OpTypeVector %float 3 %_ptr_Function_v3float = OpTypePointer Function %v3float )"; const std::string body = R"( %pos = OpVariable %_ptr_Function_v3float Function %result = OpHitObjectGetSpherePositionNV %v3float %hObj OpStore %pos %result )"; CompileSuccessfully( GenerateReorderThreadCode(body, declarations, ext, cap).c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateRayTracingReorderNV, LSSGetLSSPositionsNV) { const std::string cap = R"( OpCapability RayTracingSpheresGeometryNV OpCapability RayTracingLinearSweptSpheresGeometryNV )"; const std::string ext = R"( OpExtension "SPV_NV_linear_swept_spheres" )"; const std::string declarations = R"( %float = OpTypeFloat 32 %uint = OpTypeInt 32 0 %v3float = OpTypeVector %float 3 %uint_2 = OpConstant %uint 2 %arr = OpTypeArray %v3float %uint_2 %_ptr_Function_v3float = OpTypePointer Function %arr )"; const std::string body = R"( %lsspos = OpVariable %_ptr_Function_v3float Function %result = OpHitObjectGetLSSPositionsNV %arr %hObj OpStore %lsspos %result )"; CompileSuccessfully( GenerateReorderThreadCode(body, declarations, ext, cap).c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateRayTracingReorderNV, LSSGetSphereRadiusNV) { const std::string cap = R"( OpCapability RayTracingSpheresGeometryNV )"; const std::string ext = R"( OpExtension "SPV_NV_linear_swept_spheres" )"; const std::string declarations = R"( %float = OpTypeFloat 32 %_ptr_Function_float = OpTypePointer Function %float )"; const std::string body = R"( %rad = OpVariable %_ptr_Function_float Function %result = OpHitObjectGetSphereRadiusNV %float %hObj OpStore %rad %result )"; CompileSuccessfully( GenerateReorderThreadCode(body, declarations, ext, cap).c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateRayTracingReorderNV, LSSGetLSSRadiiNV) { const std::string cap = R"( OpCapability RayTracingLinearSweptSpheresGeometryNV )"; const std::string ext = R"( OpExtension "SPV_NV_linear_swept_spheres" )"; const std::string declarations = R"( %float = OpTypeFloat 32 %uint = OpTypeInt 32 0 %uint_2 = OpConstant %uint 2 %arr = OpTypeArray %float %uint_2 %_ptr_Function_float = OpTypePointer Function %arr )"; const std::string body = R"( %rad = OpVariable %_ptr_Function_float Function %result = OpHitObjectGetLSSRadiiNV %arr %hObj OpStore %rad %result )"; CompileSuccessfully( GenerateReorderThreadCode(body, declarations, ext, cap).c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateRayTracingReorderNV, LSSIsSphereHitNV) { const std::string cap = R"( OpCapability RayTracingSpheresGeometryNV )"; const std::string ext = R"( OpExtension "SPV_NV_linear_swept_spheres" )"; const std::string declarations = R"( %bool = OpTypeBool %_ptr_Function_bool = OpTypePointer Function %bool )"; const std::string body = R"( %ishit = OpVariable %_ptr_Function_bool Function %result = OpHitObjectIsSphereHitNV %bool %hObj OpStore %ishit %result )"; CompileSuccessfully( GenerateReorderThreadCode(body, declarations, ext, cap).c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } TEST_F(ValidateRayTracingReorderNV, LSSIsLSSHitNV) { const std::string cap = R"( OpCapability RayTracingLinearSweptSpheresGeometryNV )"; const std::string ext = R"( OpExtension "SPV_NV_linear_swept_spheres" )"; const std::string declarations = R"( %bool = OpTypeBool %_ptr_Function_bool = OpTypePointer Function %bool )"; const std::string body = R"( %ishit = OpVariable %_ptr_Function_bool Function %result = OpHitObjectIsLSSHitNV %bool %hObj OpStore %ishit %result )"; CompileSuccessfully( GenerateReorderThreadCode(body, declarations, ext, cap).c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_ray_tracing_test.cpp000066400000000000000000000515231475742701700252070ustar00rootroot00000000000000// Copyright (c) 2022 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Tests ray tracing instructions from SPV_KHR_ray_tracing. #include #include #include "gmock/gmock.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::HasSubstr; using ::testing::Values; using ValidateRayTracing = spvtest::ValidateBase; TEST_F(ValidateRayTracing, IgnoreIntersectionSuccess) { const std::string body = R"( OpCapability RayTracingKHR OpExtension "SPV_KHR_ray_tracing" OpMemoryModel Logical GLSL450 OpEntryPoint AnyHitKHR %main "main" OpName %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %main = OpFunction %void None %func %label = OpLabel OpIgnoreIntersectionKHR OpFunctionEnd )"; CompileSuccessfully(body.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateRayTracing, IgnoreIntersectionExecutionModel) { const std::string body = R"( OpCapability RayTracingKHR OpExtension "SPV_KHR_ray_tracing" OpMemoryModel Logical GLSL450 OpEntryPoint CallableKHR %main "main" OpName %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %main = OpFunction %void None %func %label = OpLabel OpIgnoreIntersectionKHR OpFunctionEnd )"; CompileSuccessfully(body.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpIgnoreIntersectionKHR requires AnyHitKHR execution model")); } TEST_F(ValidateRayTracing, TerminateRaySuccess) { const std::string body = R"( OpCapability RayTracingKHR OpExtension "SPV_KHR_ray_tracing" OpMemoryModel Logical GLSL450 OpEntryPoint AnyHitKHR %main "main" OpName %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %main = OpFunction %void None %func %label = OpLabel OpIgnoreIntersectionKHR OpFunctionEnd )"; CompileSuccessfully(body.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateRayTracing, TerminateRayExecutionModel) { const std::string body = R"( OpCapability RayTracingKHR OpExtension "SPV_KHR_ray_tracing" OpMemoryModel Logical GLSL450 OpEntryPoint MissKHR %main "main" OpName %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %main = OpFunction %void None %func %label = OpLabel OpTerminateRayKHR OpFunctionEnd )"; CompileSuccessfully(body.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpTerminateRayKHR requires AnyHitKHR execution model")); } TEST_F(ValidateRayTracing, ReportIntersectionRaySuccess) { const std::string body = R"( OpCapability RayTracingKHR OpExtension "SPV_KHR_ray_tracing" OpMemoryModel Logical GLSL450 OpEntryPoint IntersectionKHR %main "main" OpName %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %float = OpTypeFloat 32 %float_1 = OpConstant %float 1 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %bool = OpTypeBool %main = OpFunction %void None %func %label = OpLabel %report = OpReportIntersectionKHR %bool %float_1 %uint_1 OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateRayTracing, ReportIntersectionExecutionModel) { const std::string body = R"( OpCapability RayTracingKHR OpExtension "SPV_KHR_ray_tracing" OpMemoryModel Logical GLSL450 OpEntryPoint MissKHR %main "main" OpName %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %float = OpTypeFloat 32 %float_1 = OpConstant %float 1 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %bool = OpTypeBool %main = OpFunction %void None %func %label = OpLabel %report = OpReportIntersectionKHR %bool %float_1 %uint_1 OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr( "OpReportIntersectionKHR requires IntersectionKHR execution model")); } TEST_F(ValidateRayTracing, ReportIntersectionReturnType) { const std::string body = R"( OpCapability RayTracingKHR OpExtension "SPV_KHR_ray_tracing" OpMemoryModel Logical GLSL450 OpEntryPoint IntersectionKHR %main "main" OpName %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %float = OpTypeFloat 32 %float_1 = OpConstant %float 1 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %main = OpFunction %void None %func %label = OpLabel %report = OpReportIntersectionKHR %uint %float_1 %uint_1 OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("expected Result Type to be bool scalar type")); } TEST_F(ValidateRayTracing, ReportIntersectionHit) { const std::string body = R"( OpCapability RayTracingKHR OpCapability Float64 OpExtension "SPV_KHR_ray_tracing" OpMemoryModel Logical GLSL450 OpEntryPoint IntersectionKHR %main "main" OpName %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %float64 = OpTypeFloat 64 %float64_1 = OpConstant %float64 1 %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %bool = OpTypeBool %main = OpFunction %void None %func %label = OpLabel %report = OpReportIntersectionKHR %bool %float64_1 %uint_1 OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Hit must be a 32-bit int scalar")); } TEST_F(ValidateRayTracing, ReportIntersectionHitKind) { const std::string body = R"( OpCapability RayTracingKHR OpExtension "SPV_KHR_ray_tracing" OpMemoryModel Logical GLSL450 OpEntryPoint IntersectionKHR %main "main" OpName %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %float = OpTypeFloat 32 %float_1 = OpConstant %float 1 %sint = OpTypeInt 32 1 %sint_1 = OpConstant %sint 1 %bool = OpTypeBool %main = OpFunction %void None %func %label = OpLabel %report = OpReportIntersectionKHR %bool %float_1 %sint_1 OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Hit Kind must be a 32-bit unsigned int scalar")); } TEST_F(ValidateRayTracing, ExecuteCallableSuccess) { const std::string body = R"( OpCapability RayTracingKHR OpExtension "SPV_KHR_ray_tracing" OpMemoryModel Logical GLSL450 OpEntryPoint CallableKHR %main "main" OpName %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %data_ptr = OpTypePointer CallableDataKHR %int %data = OpVariable %data_ptr CallableDataKHR %inData_ptr = OpTypePointer IncomingCallableDataKHR %int %inData = OpVariable %inData_ptr IncomingCallableDataKHR %main = OpFunction %void None %func %label = OpLabel OpExecuteCallableKHR %uint_0 %data OpExecuteCallableKHR %uint_0 %inData OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateRayTracing, ExecuteCallableExecutionModel) { const std::string body = R"( OpCapability RayTracingKHR OpExtension "SPV_KHR_ray_tracing" OpMemoryModel Logical GLSL450 OpEntryPoint AnyHitKHR %main "main" OpName %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %data_ptr = OpTypePointer CallableDataKHR %int %data = OpVariable %data_ptr CallableDataKHR %inData_ptr = OpTypePointer IncomingCallableDataKHR %int %inData = OpVariable %inData_ptr IncomingCallableDataKHR %main = OpFunction %void None %func %label = OpLabel OpExecuteCallableKHR %uint_0 %data OpExecuteCallableKHR %uint_0 %inData OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("OpExecuteCallableKHR requires RayGenerationKHR, " "ClosestHitKHR, MissKHR and CallableKHR execution models")); } TEST_F(ValidateRayTracing, ExecuteCallableStorageClass) { const std::string body = R"( OpCapability RayTracingKHR OpExtension "SPV_KHR_ray_tracing" OpMemoryModel Logical GLSL450 OpEntryPoint RayGenerationKHR %main "main" OpName %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %data_ptr = OpTypePointer RayPayloadKHR %int %data = OpVariable %data_ptr RayPayloadKHR %main = OpFunction %void None %func %label = OpLabel OpExecuteCallableKHR %uint_0 %data OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Callable Data must have storage class CallableDataKHR " "or IncomingCallableDataKHR")); } TEST_F(ValidateRayTracing, ExecuteCallableSbtIndex) { const std::string body = R"( OpCapability RayTracingKHR OpExtension "SPV_KHR_ray_tracing" OpMemoryModel Logical GLSL450 OpEntryPoint CallableKHR %main "main" OpName %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %int = OpTypeInt 32 1 %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %int_1 = OpConstant %int 1 %data_ptr = OpTypePointer CallableDataKHR %int %data = OpVariable %data_ptr CallableDataKHR %main = OpFunction %void None %func %label = OpLabel OpExecuteCallableKHR %int_1 %data OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("SBT Index must be a 32-bit unsigned int scalar")); } std::string GenerateRayTraceCode( const std::string& body, const std::string execution_model = "RayGenerationKHR") { std::ostringstream ss; ss << R"( OpCapability RayTracingKHR OpCapability Float64 OpExtension "SPV_KHR_ray_tracing" OpMemoryModel Logical GLSL450 OpEntryPoint )" << execution_model << R"( %main "main" OpDecorate %top_level_as DescriptorSet 0 OpDecorate %top_level_as Binding 0 %void = OpTypeVoid %func = OpTypeFunction %void %type_as = OpTypeAccelerationStructureKHR %as_uc_ptr = OpTypePointer UniformConstant %type_as %top_level_as = OpVariable %as_uc_ptr UniformConstant %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %float = OpTypeFloat 32 %float64 = OpTypeFloat 64 %f32vec3 = OpTypeVector %float 3 %f32vec4 = OpTypeVector %float 4 %float_0 = OpConstant %float 0 %float64_0 = OpConstant %float64 0 %v3composite = OpConstantComposite %f32vec3 %float_0 %float_0 %float_0 %v4composite = OpConstantComposite %f32vec4 %float_0 %float_0 %float_0 %float_0 %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %payload_ptr = OpTypePointer RayPayloadKHR %int %payload = OpVariable %payload_ptr RayPayloadKHR %callable_ptr = OpTypePointer CallableDataKHR %int %callable = OpVariable %callable_ptr CallableDataKHR %ptr_uint = OpTypePointer Private %uint %var_uint = OpVariable %ptr_uint Private %ptr_float = OpTypePointer Private %float %var_float = OpVariable %ptr_float Private %ptr_f32vec3 = OpTypePointer Private %f32vec3 %var_f32vec3 = OpVariable %ptr_f32vec3 Private %main = OpFunction %void None %func %label = OpLabel )"; ss << body; ss << R"( OpReturn OpFunctionEnd)"; return ss.str(); } TEST_F(ValidateRayTracing, TraceRaySuccess) { const std::string body = R"( %as = OpLoad %type_as %top_level_as OpTraceRayKHR %as %uint_1 %uint_1 %uint_1 %uint_1 %uint_1 %v3composite %float_0 %v3composite %float_0 %payload %_uint = OpLoad %uint %var_uint %_float = OpLoad %float %var_float %_f32vec3 = OpLoad %f32vec3 %var_f32vec3 OpTraceRayKHR %as %_uint %_uint %_uint %_uint %_uint %_f32vec3 %_float %_f32vec3 %_float %payload )"; CompileSuccessfully(GenerateRayTraceCode(body).c_str()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateRayTracing, TraceRayExecutionModel) { const std::string body = R"( %as = OpLoad %type_as %top_level_as OpTraceRayKHR %as %uint_1 %uint_1 %uint_1 %uint_1 %uint_1 %v3composite %float_0 %v3composite %float_0 %payload )"; CompileSuccessfully(GenerateRayTraceCode(body, "CallableKHR").c_str()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpTraceRayKHR requires RayGenerationKHR, " "ClosestHitKHR and MissKHR execution models")); } TEST_F(ValidateRayTracing, TraceRayAccelerationStructure) { const std::string body = R"( %_uint = OpLoad %uint %var_uint OpTraceRayKHR %_uint %uint_1 %uint_1 %uint_1 %uint_1 %uint_1 %v3composite %float_0 %v3composite %float_0 %payload )"; CompileSuccessfully(GenerateRayTraceCode(body).c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Expected Acceleration Structure to be of type " "OpTypeAccelerationStructureKHR")); } TEST_F(ValidateRayTracing, TraceRayRayFlags) { const std::string body = R"( %as = OpLoad %type_as %top_level_as OpTraceRayKHR %as %float_0 %uint_1 %uint_1 %uint_1 %uint_1 %v3composite %float_0 %v3composite %float_0 %payload )"; CompileSuccessfully(GenerateRayTraceCode(body).c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Ray Flags must be a 32-bit int scalar")); } TEST_F(ValidateRayTracing, TraceRayCullMask) { const std::string body = R"( %as = OpLoad %type_as %top_level_as OpTraceRayKHR %as %uint_1 %float_0 %uint_1 %uint_1 %uint_1 %v3composite %float_0 %v3composite %float_0 %payload )"; CompileSuccessfully(GenerateRayTraceCode(body).c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Cull Mask must be a 32-bit int scalar")); } TEST_F(ValidateRayTracing, TraceRaySbtOffest) { const std::string body = R"( %as = OpLoad %type_as %top_level_as OpTraceRayKHR %as %uint_1 %uint_1 %float_0 %uint_1 %uint_1 %v3composite %float_0 %v3composite %float_0 %payload )"; CompileSuccessfully(GenerateRayTraceCode(body).c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("SBT Offset must be a 32-bit int scalar")); } TEST_F(ValidateRayTracing, TraceRaySbtStride) { const std::string body = R"( %as = OpLoad %type_as %top_level_as OpTraceRayKHR %as %uint_1 %uint_1 %uint_1 %float_0 %uint_1 %v3composite %float_0 %v3composite %float_0 %payload )"; CompileSuccessfully(GenerateRayTraceCode(body).c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("SBT Stride must be a 32-bit int scalar")); } TEST_F(ValidateRayTracing, TraceRayMissIndex) { const std::string body = R"( %as = OpLoad %type_as %top_level_as OpTraceRayKHR %as %uint_1 %uint_1 %uint_1 %uint_1 %float_0 %v3composite %float_0 %v3composite %float_0 %payload )"; CompileSuccessfully(GenerateRayTraceCode(body).c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Miss Index must be a 32-bit int scalar")); } TEST_F(ValidateRayTracing, TraceRayRayOrigin) { const std::string body = R"( %as = OpLoad %type_as %top_level_as OpTraceRayKHR %as %uint_1 %uint_1 %uint_1 %uint_1 %uint_1 %float_0 %float_0 %v3composite %float_0 %payload )"; CompileSuccessfully(GenerateRayTraceCode(body).c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Ray Origin must be a 32-bit float 3-component vector")); } TEST_F(ValidateRayTracing, TraceRayRayTMin) { const std::string body = R"( %as = OpLoad %type_as %top_level_as OpTraceRayKHR %as %uint_1 %uint_1 %uint_1 %uint_1 %uint_1 %v3composite %uint_1 %v3composite %float_0 %payload )"; CompileSuccessfully(GenerateRayTraceCode(body).c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Ray TMin must be a 32-bit float scalar")); } TEST_F(ValidateRayTracing, TraceRayRayDirection) { const std::string body = R"( %as = OpLoad %type_as %top_level_as OpTraceRayKHR %as %uint_1 %uint_1 %uint_1 %uint_1 %uint_1 %v3composite %float_0 %v4composite %float_0 %payload )"; CompileSuccessfully(GenerateRayTraceCode(body).c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), HasSubstr("Ray Direction must be a 32-bit float 3-component vector")); } TEST_F(ValidateRayTracing, TraceRayRayTMax) { const std::string body = R"( %as = OpLoad %type_as %top_level_as OpTraceRayKHR %as %uint_1 %uint_1 %uint_1 %uint_1 %uint_1 %v3composite %float_0 %v3composite %float64_0 %payload )"; CompileSuccessfully(GenerateRayTraceCode(body).c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Ray TMax must be a 32-bit float scalar")); } TEST_F(ValidateRayTracing, TraceRayPayload) { const std::string body = R"( %as = OpLoad %type_as %top_level_as OpTraceRayKHR %as %uint_1 %uint_1 %uint_1 %uint_1 %uint_1 %v3composite %float_0 %v3composite %float_0 %callable )"; CompileSuccessfully(GenerateRayTraceCode(body).c_str()); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Payload must have storage class RayPayloadKHR or " "IncomingRayPayloadKHR")); } TEST_F(ValidateRayTracing, InterfaceIncomingRayPayload) { const std::string body = R"( OpCapability RayTracingKHR OpExtension "SPV_KHR_ray_tracing" OpMemoryModel Logical GLSL450 OpEntryPoint CallableKHR %main "main" %inData1 %inData2 OpName %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %int = OpTypeInt 32 1 %inData_ptr = OpTypePointer IncomingRayPayloadKHR %int %inData1 = OpVariable %inData_ptr IncomingRayPayloadKHR %inData2 = OpVariable %inData_ptr IncomingRayPayloadKHR %main = OpFunction %void None %func %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-IncomingRayPayloadKHR-04700")); EXPECT_THAT( getDiagnosticString(), HasSubstr("Entry-point has more than one variable with the " "IncomingRayPayloadKHR storage class in the interface")); } TEST_F(ValidateRayTracing, InterfaceHitAttribute) { const std::string body = R"( OpCapability RayTracingKHR OpExtension "SPV_KHR_ray_tracing" OpMemoryModel Logical GLSL450 OpEntryPoint CallableKHR %main "main" %inData1 %inData2 OpName %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %int = OpTypeInt 32 1 %inData_ptr = OpTypePointer HitAttributeKHR %int %inData1 = OpVariable %inData_ptr HitAttributeKHR %inData2 = OpVariable %inData_ptr HitAttributeKHR %main = OpFunction %void None %func %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-HitAttributeKHR-04702")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Entry-point has more than one variable with the " "HitAttributeKHR storage class in the interface")); } TEST_F(ValidateRayTracing, InterfaceIncomingCallableData) { const std::string body = R"( OpCapability RayTracingKHR OpExtension "SPV_KHR_ray_tracing" OpMemoryModel Logical GLSL450 OpEntryPoint CallableKHR %main "main" %inData1 %inData2 OpName %main "main" %void = OpTypeVoid %func = OpTypeFunction %void %int = OpTypeInt 32 1 %inData_ptr = OpTypePointer IncomingCallableDataKHR %int %inData1 = OpVariable %inData_ptr IncomingCallableDataKHR %inData2 = OpVariable %inData_ptr IncomingCallableDataKHR %main = OpFunction %void None %func %label = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(body.c_str(), SPV_ENV_VULKAN_1_2); EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-IncomingCallableDataKHR-04706")); EXPECT_THAT( getDiagnosticString(), HasSubstr("Entry-point has more than one variable with the " "IncomingCallableDataKHR storage class in the interface")); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_small_type_uses_test.cpp000066400000000000000000000324221475742701700261120ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validation tests for 8- and 16-bit type uses. #include #include #include "gmock/gmock.h" #include "test/unit_spirv.h" #include "test/val/val_code_generator.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::Eq; using ::testing::HasSubstr; using ::testing::Values; using ValidateSmallTypeUses = spvtest::ValidateBase; CodeGenerator GetSmallTypesGenerator() { CodeGenerator generator; generator.capabilities_ = R"( OpCapability Shader OpCapability StorageBuffer16BitAccess OpCapability StorageBuffer8BitAccess )"; generator.extensions_ = R"( OpExtension "SPV_KHR_16bit_storage" OpExtension "SPV_KHR_8bit_storage" OpExtension "SPV_KHR_storage_buffer_storage_class" %ext = OpExtInstImport "GLSL.std.450" )"; generator.memory_model_ = "OpMemoryModel Logical GLSL450\n"; std::string body = R"( %short_gep = OpAccessChain %ptr_ssbo_short %var %int_0 %int_0 %ld_short = OpLoad %short %short_gep %short_to_int = OpSConvert %int %ld_short %short_to_uint = OpUConvert %int %ld_short %short_to_char = OpSConvert %char %ld_short %short_to_uchar = OpSConvert %char %ld_short %short2_gep = OpAccessChain %ptr_ssbo_short2 %var %int_0 %ld_short2 = OpLoad %short2 %short2_gep %short2_to_int2 = OpSConvert %int2 %ld_short2 %short2_to_uint2 = OpUConvert %int2 %ld_short2 %short2_to_char2 = OpSConvert %char2 %ld_short2 %short2_to_uchar2 = OpSConvert %char2 %ld_short2 %char_gep = OpAccessChain %ptr_ssbo_char %var %int_2 %int_0 %ld_char = OpLoad %char %char_gep %char_to_int = OpSConvert %int %ld_char %char_to_uint = OpUConvert %int %ld_char %char_to_short = OpSConvert %short %ld_char %char_to_ushort = OpSConvert %short %ld_char %char2_gep = OpAccessChain %ptr_ssbo_char2 %var %int_2 %ld_char2 = OpLoad %char2 %char2_gep %char2_to_int2 = OpSConvert %int2 %ld_char2 %char2_to_uint2 = OpUConvert %int2 %ld_char2 %char2_to_short2 = OpSConvert %short2 %ld_char2 %char2_to_ushort2 = OpSConvert %short2 %ld_char2 %half_gep = OpAccessChain %ptr_ssbo_half %var %int_1 %int_0 %ld_half = OpLoad %half %half_gep %half_to_float = OpFConvert %float %ld_half %half2_gep = OpAccessChain %ptr_ssbo_half2 %var %int_1 %ld_half2 = OpLoad %half2 %half2_gep %half2_to_float2 = OpFConvert %float2 %ld_half2 %int_to_short = OpSConvert %short %int_0 %int_to_ushort = OpUConvert %short %int_0 %int_to_char = OpSConvert %char %int_0 %int_to_uchar = OpUConvert %char %int_0 %int2_to_short2 = OpSConvert %short2 %int2_0 %int2_to_ushort2 = OpUConvert %short2 %int2_0 %int2_to_char2 = OpSConvert %char2 %int2_0 %int2_to_uchar2 = OpUConvert %char2 %int2_0 %int_gep = OpAccessChain %ptr_ssbo_int %var %int_3 %int_0 %int2_gep = OpAccessChain %ptr_ssbo_int2 %var %int_3 %float_to_half = OpFConvert %half %float_0 %float2_to_half2 = OpFConvert %half2 %float2_0 %float_gep = OpAccessChain %ptr_ssbo_float %var %int_4 %int_0 %float2_gep = OpAccessChain %ptr_ssbo_float2 %var %int_4 )"; generator.entry_points_.push_back( {"foo", "GLCompute", "OpExecutionMode %foo LocalSize 1 1 1", body, ""}); generator.before_types_ = R"( OpDecorate %block Block OpMemberDecorate %block 0 Offset 0 OpMemberDecorate %block 1 Offset 8 OpMemberDecorate %block 2 Offset 16 OpMemberDecorate %block 3 Offset 32 OpMemberDecorate %block 4 Offset 64 )"; generator.types_ = R"( %void = OpTypeVoid %int = OpTypeInt 32 0 %int2 = OpTypeVector %int 2 %float = OpTypeFloat 32 %float2 = OpTypeVector %float 2 %bool = OpTypeBool %bool2 = OpTypeVector %bool 2 %char = OpTypeInt 8 0 %char2 = OpTypeVector %char 2 %ptr_ssbo_char = OpTypePointer StorageBuffer %char %ptr_ssbo_char2 = OpTypePointer StorageBuffer %char2 %short = OpTypeInt 16 0 %short2 = OpTypeVector %short 2 %ptr_ssbo_short = OpTypePointer StorageBuffer %short %ptr_ssbo_short2 = OpTypePointer StorageBuffer %short2 %half = OpTypeFloat 16 %half2 = OpTypeVector %half 2 %ptr_ssbo_half = OpTypePointer StorageBuffer %half %ptr_ssbo_half2 = OpTypePointer StorageBuffer %half2 %ptr_ssbo_int = OpTypePointer StorageBuffer %int %ptr_ssbo_int2 = OpTypePointer StorageBuffer %int2 %ptr_ssbo_float = OpTypePointer StorageBuffer %float %ptr_ssbo_float2 = OpTypePointer StorageBuffer %float2 %block = OpTypeStruct %short2 %half2 %char2 %int2 %float2 %ptr_ssbo_block = OpTypePointer StorageBuffer %block %func = OpTypeFunction %void )"; generator.after_types_ = R"( %var = OpVariable %ptr_ssbo_block StorageBuffer %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %int_3 = OpConstant %int 3 %int_4 = OpConstant %int 4 %int2_0 = OpConstantComposite %int2 %int_0 %int_0 %float_0 = OpConstant %float 0 %float2_0 = OpConstantComposite %float2 %float_0 %float_0 %short_func_ty = OpTypeFunction %void %short %char_func_ty = OpTypeFunction %void %char %half_func_ty = OpTypeFunction %void %half )"; generator.add_at_the_end_ = R"( %short_func = OpFunction %void None %short_func_ty %short_param = OpFunctionParameter %short %short_func_entry = OpLabel OpReturn OpFunctionEnd %char_func = OpFunction %void None %char_func_ty %char_param = OpFunctionParameter %char %char_func_entry = OpLabel OpReturn OpFunctionEnd %half_func = OpFunction %void None %half_func_ty %half_param = OpFunctionParameter %half %half_func_entry = OpLabel OpReturn OpFunctionEnd )"; return generator; } TEST_F(ValidateSmallTypeUses, BadCharPhi) { CodeGenerator generator = GetSmallTypesGenerator(); generator.entry_points_[0].body += R"( OpBranch %next_block %next_block = OpLabel %phi = OpPhi %char %ld_char %foo_entry )"; CompileSuccessfully(generator.Build()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Invalid use of 8- or 16-bit result")); } TEST_F(ValidateSmallTypeUses, BadShortPhi) { CodeGenerator generator = GetSmallTypesGenerator(); generator.entry_points_[0].body += R"( OpBranch %next_block %next_block = OpLabel %phi = OpPhi %short %ld_short %foo_entry )"; CompileSuccessfully(generator.Build()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Invalid use of 8- or 16-bit result")); } TEST_F(ValidateSmallTypeUses, BadHalfPhi) { CodeGenerator generator = GetSmallTypesGenerator(); generator.entry_points_[0].body += R"( OpBranch %next_block %next_block = OpLabel %phi = OpPhi %half %ld_half %foo_entry )"; CompileSuccessfully(generator.Build()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Invalid use of 8- or 16-bit result")); } using ValidateGoodUses = spvtest::ValidateBase; TEST_P(ValidateGoodUses, Inst) { const std::string inst = GetParam(); CodeGenerator generator = GetSmallTypesGenerator(); generator.entry_points_[0].body += inst + "\n"; CompileSuccessfully(generator.Build()); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); } INSTANTIATE_TEST_SUITE_P( SmallTypeUsesValid, ValidateGoodUses, Values( "%inst = OpIAdd %int %short_to_int %int_0", "%inst = OpIAdd %int %short_to_uint %int_0", "%inst = OpIAdd %int2 %short2_to_int2 %int2_0", "%inst = OpIAdd %int2 %short2_to_uint2 %int2_0", "%inst = OpIAdd %int %char_to_int %int_0", "%inst = OpIAdd %int %char_to_uint %int_0", "%inst = OpIAdd %int2 %char2_to_int2 %int2_0", "%inst = OpIAdd %int2 %char2_to_uint2 %int2_0", "%inst = OpUConvert %int %ld_short", "%inst = OpSConvert %int %ld_short", "%inst = OpUConvert %char %ld_short", "%inst = OpSConvert %char %ld_short", "%inst = OpUConvert %int %ld_char", "%inst = OpSConvert %int %ld_char", "%inst = OpUConvert %short %ld_char", "%inst = OpSConvert %short %ld_char", "%inst = OpUConvert %int2 %ld_short2", "%inst = OpSConvert %int2 %ld_short2", "%inst = OpUConvert %char2 %ld_short2", "%inst = OpSConvert %char2 %ld_short2", "%inst = OpUConvert %int2 %ld_char2", "%inst = OpSConvert %int2 %ld_char2", "%inst = OpUConvert %short2 %ld_char2", "%inst = OpSConvert %short2 %ld_char2", "OpStore %short_gep %int_to_short", "OpStore %short_gep %int_to_ushort", "OpStore %short_gep %char_to_short", "OpStore %short_gep %char_to_ushort", "OpStore %short2_gep %int2_to_short2", "OpStore %short2_gep %int2_to_ushort2", "OpStore %short2_gep %char2_to_short2", "OpStore %short2_gep %char2_to_ushort2", "OpStore %char_gep %int_to_char", "OpStore %char_gep %int_to_uchar", "OpStore %char_gep %short_to_char", "OpStore %char_gep %short_to_uchar", "OpStore %char2_gep %int2_to_char2", "OpStore %char2_gep %int2_to_uchar2", "OpStore %char2_gep %short2_to_char2", "OpStore %char2_gep %short2_to_uchar2", "OpStore %int_gep %short_to_int", "OpStore %int_gep %short_to_uint", "OpStore %int_gep %char_to_int", "OpStore %int2_gep %char2_to_uint2", "OpStore %int2_gep %short2_to_int2", "OpStore %int2_gep %short2_to_uint2", "OpStore %int2_gep %char2_to_int2", "OpStore %int2_gep %char2_to_uint2", "%inst = OpFAdd %float %half_to_float %float_0", "%inst = OpFAdd %float2 %half2_to_float2 %float2_0", "%inst = OpFConvert %float %ld_half", "%inst = OpFConvert %float2 %ld_half2", "OpStore %half_gep %float_to_half", "OpStore %half_gep %ld_half", "OpStore %half2_gep %float2_to_half2", "OpStore %half2_gep %ld_half2", "OpStore %float_gep %half_to_float", "OpStore %float2_gep %half2_to_float2")); using ValidateBadUses = spvtest::ValidateBase; TEST_P(ValidateBadUses, Inst) { const std::string inst = GetParam(); CodeGenerator generator = GetSmallTypesGenerator(); generator.entry_points_[0].body += inst + "\n"; CompileSuccessfully(generator.Build()); EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Invalid use of 8- or 16-bit result")); } // A smattering of unacceptable use cases. Far too vast to cover exhaustively. INSTANTIATE_TEST_SUITE_P( SmallTypeUsesInvalid, ValidateBadUses, Values("%inst = OpIAdd %short %ld_short %ld_short", "%inst = OpIAdd %short %char_to_short %char_to_short", "%inst = OpIAdd %short %char_to_ushort %char_to_ushort", "%inst = OpIAdd %short %int_to_short %int_to_short", "%inst = OpIAdd %short %int_to_ushort %int_to_ushort", "%inst = OpIAdd %short2 %ld_short2 %ld_short2", "%inst = OpIAdd %short2 %char2_to_short2 %char2_to_short2", "%inst = OpIAdd %short2 %char2_to_ushort2 %char2_to_ushort2", "%inst = OpIAdd %short2 %int2_to_short2 %int2_to_short2", "%inst = OpIAdd %short2 %int2_to_ushort2 %int2_to_ushort2", "%inst = OpIEqual %bool %ld_short %ld_short", "%inst = OpIEqual %bool %char_to_short %char_to_short", "%inst = OpIEqual %bool %char_to_ushort %char_to_ushort", "%inst = OpIEqual %bool %int_to_short %int_to_short", "%inst = OpIEqual %bool %int_to_ushort %int_to_ushort", "%inst = OpIEqual %bool2 %ld_short2 %ld_short2", "%inst = OpIEqual %bool2 %char2_to_short2 %char2_to_short2", "%inst = OpIEqual %bool2 %char2_to_ushort2 %char2_to_ushort2", "%inst = OpIEqual %bool2 %int2_to_short2 %int2_to_short2", "%inst = OpIEqual %bool2 %int2_to_ushort2 %int2_to_ushort2", "%inst = OpFAdd %half %ld_half %ld_half", "%inst = OpFAdd %half %float_to_half %float_to_half", "%inst = OpFAdd %half2 %ld_half2 %ld_half2", "%inst = OpFAdd %half2 %float2_to_half2 %float2_to_half2", "%inst = OpFOrdGreaterThan %bool %ld_half %ld_half", "%inst = OpFOrdGreaterThan %bool %float_to_half %float_to_half", "%inst = OpFOrdGreaterThan %bool2 %ld_half2 %ld_half2", "%inst = OpFOrdGreaterThan %bool2 %float2_to_half2 %float2_to_half2", "%inst = OpFunctionCall %void %short_func %ld_short", "%inst = OpFunctionCall %void %short_func %char_to_short", "%inst = OpFunctionCall %void %short_func %char_to_ushort", "%inst = OpFunctionCall %void %short_func %int_to_short", "%inst = OpFunctionCall %void %short_func %int_to_ushort", "%inst = OpFunctionCall %void %char_func %ld_char", "%inst = OpFunctionCall %void %char_func %short_to_char", "%inst = OpFunctionCall %void %char_func %short_to_uchar", "%inst = OpFunctionCall %void %char_func %int_to_char", "%inst = OpFunctionCall %void %char_func %int_to_uchar", "%inst = OpFunctionCall %void %half_func %ld_half", "%inst = OpFunctionCall %void %half_func %float_to_half")); } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_ssa_test.cpp000066400000000000000000001345561475742701700235030ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validation tests for SSA #include #include #include #include "gmock/gmock.h" #include "test/unit_spirv.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::HasSubstr; using ::testing::MatchesRegex; using ValidateSSA = spvtest::ValidateBase>; TEST_F(ValidateSSA, Default) { char str[] = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %3 "" OpExecutionMode %3 LocalSize 1 1 1 %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpFunction %1 None %2 %4 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateSSA, IdUndefinedBad) { char str[] = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %missing "missing" %voidt = OpTypeVoid %vfunct = OpTypeFunction %voidt %func = OpFunction %vfunct None %missing %flabel = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("missing")); } TEST_F(ValidateSSA, IdRedefinedBad) { char str[] = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %2 "redefined" %1 = OpTypeVoid %2 = OpTypeFunction %1 %2 = OpFunction %1 None %2 %4 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); } TEST_F(ValidateSSA, DominateUsageBad) { char str[] = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %1 "not_dominant" %2 = OpTypeFunction %1 ; uses %1 before it's definition %1 = OpTypeVoid )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("not_dominant")); } TEST_F(ValidateSSA, DominateUsageWithinBlockBad) { char str[] = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %bad "bad" %voidt = OpTypeVoid %funct = OpTypeFunction %voidt %uintt = OpTypeInt 32 0 %one = OpConstant %uintt 1 %func = OpFunction %voidt None %funct %entry = OpLabel %sum = OpIAdd %uintt %one %bad %bad = OpCopyObject %uintt %sum OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), MatchesRegex("ID '.\\[%bad\\]' has not been defined\n" " %8 = OpIAdd %uint %uint_1 %bad\n")); } TEST_F(ValidateSSA, DominateUsageSameInstructionBad) { char str[] = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %sum "sum" %voidt = OpTypeVoid %funct = OpTypeFunction %voidt %uintt = OpTypeInt 32 0 %one = OpConstant %uintt 1 %func = OpFunction %voidt None %funct %entry = OpLabel %sum = OpIAdd %uintt %one %sum OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), MatchesRegex("ID '.\\[%sum\\]' has not been defined\n" " %sum = OpIAdd %uint %uint_1 %sum\n")); } TEST_F(ValidateSSA, ForwardNameGood) { char str[] = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %3 "main" %1 = OpTypeVoid %2 = OpTypeFunction %1 %3 = OpFunction %1 None %2 %4 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateSSA, ForwardNameMissingTargetBad) { char str[] = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %5 "main" ; Target never defined )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("main")); } TEST_F(ValidateSSA, ForwardMemberNameGood) { char str[] = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpMemberName %struct 0 "value" OpMemberName %struct 1 "size" %intt = OpTypeInt 32 1 %uintt = OpTypeInt 32 0 %struct = OpTypeStruct %intt %uintt )"; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateSSA, ForwardMemberNameMissingTargetBad) { char str[] = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpMemberName %struct 0 "value" OpMemberName %bad 1 "size" ; Target is not defined %intt = OpTypeInt 32 1 %uintt = OpTypeInt 32 0 %struct = OpTypeStruct %intt %uintt )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("The following forward referenced IDs have not been " "defined:\n'2[%2]'")); } TEST_F(ValidateSSA, ForwardDecorateGood) { char str[] = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %var Restrict %intt = OpTypeInt 32 1 %ptrt = OpTypePointer UniformConstant %intt %var = OpVariable %ptrt UniformConstant )"; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateSSA, ForwardDecorateInvalidIDBad) { char str[] = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %missing "missing" OpDecorate %missing Restrict ;Missing ID %voidt = OpTypeVoid %intt = OpTypeInt 32 1 %ptrt = OpTypePointer UniformConstant %intt %var = OpVariable %ptrt UniformConstant %2 = OpTypeFunction %voidt %3 = OpFunction %voidt None %2 %4 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("missing")); } TEST_F(ValidateSSA, ForwardMemberDecorateGood) { char str[] = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpMemberDecorate %struct 1 RowMajor %intt = OpTypeInt 32 1 %f32 = OpTypeFloat 32 %vec3 = OpTypeVector %f32 3 %mat33 = OpTypeMatrix %vec3 3 %struct = OpTypeStruct %intt %mat33 )"; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateSSA, ForwardMemberDecorateInvalidIdBad) { char str[] = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %missing "missing" OpMemberDecorate %missing 1 RowMajor ; Target not defined %intt = OpTypeInt 32 1 %f32 = OpTypeFloat 32 %vec3 = OpTypeVector %f32 3 %mat33 = OpTypeMatrix %vec3 3 %struct = OpTypeStruct %intt %mat33 )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("missing")); } TEST_F(ValidateSSA, ForwardGroupDecorateGood) { char str[] = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %dgrp RowMajor %dgrp = OpDecorationGroup OpGroupDecorate %dgrp %mat33 %mat44 %f32 = OpTypeFloat 32 %vec3 = OpTypeVector %f32 3 %vec4 = OpTypeVector %f32 4 %mat33 = OpTypeMatrix %vec3 3 %mat44 = OpTypeMatrix %vec4 4 )"; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateSSA, ForwardGroupDecorateMissingGroupBad) { char str[] = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %missing "missing" OpDecorate %dgrp RowMajor %dgrp = OpDecorationGroup OpGroupDecorate %missing %mat33 %mat44 ; Target not defined %intt = OpTypeInt 32 1 %vec3 = OpTypeVector %intt 3 %vec4 = OpTypeVector %intt 4 %mat33 = OpTypeMatrix %vec3 3 %mat44 = OpTypeMatrix %vec4 4 )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("missing")); } TEST_F(ValidateSSA, ForwardGroupDecorateMissingTargetBad) { char str[] = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %missing "missing" OpDecorate %dgrp RowMajor %dgrp = OpDecorationGroup OpGroupDecorate %dgrp %missing %mat44 ; Target not defined %f32 = OpTypeFloat 32 %vec3 = OpTypeVector %f32 3 %vec4 = OpTypeVector %f32 4 %mat33 = OpTypeMatrix %vec3 3 %mat44 = OpTypeMatrix %vec4 4 )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("missing")); } TEST_F(ValidateSSA, ForwardGroupDecorateDecorationGroupDominateBad) { char str[] = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %dgrp "group" OpDecorate %dgrp RowMajor OpGroupDecorate %dgrp %mat33 %mat44 ; Decoration group does not dominate usage %dgrp = OpDecorationGroup %intt = OpTypeInt 32 1 %vec3 = OpTypeVector %intt 3 %vec4 = OpTypeVector %intt 4 %mat33 = OpTypeMatrix %vec3 3 %mat44 = OpTypeMatrix %vec4 4 )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("group")); } TEST_F(ValidateSSA, ForwardDecorateInvalidIdBad) { char str[] = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %missing "missing" OpDecorate %missing Restrict ; Missing target %voidt = OpTypeVoid %intt = OpTypeInt 32 1 %ptrt = OpTypePointer UniformConstant %intt %var = OpVariable %ptrt UniformConstant %2 = OpTypeFunction %voidt %3 = OpFunction %voidt None %2 %4 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("missing")); } TEST_F(ValidateSSA, FunctionCallGood) { char str[] = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeVoid %2 = OpTypeInt 32 1 %3 = OpTypeInt 32 0 %4 = OpTypeFunction %1 %8 = OpTypeFunction %1 %2 %3 %four = OpConstant %2 4 %five = OpConstant %3 5 %9 = OpFunction %1 None %8 %10 = OpFunctionParameter %2 %11 = OpFunctionParameter %3 %12 = OpLabel OpReturn OpFunctionEnd %5 = OpFunction %1 None %4 %6 = OpLabel %7 = OpFunctionCall %1 %9 %four %five OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateSSA, ForwardFunctionCallGood) { char str[] = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %1 = OpTypeVoid %2 = OpTypeInt 32 1 %3 = OpTypeInt 32 0 %four = OpConstant %2 4 %five = OpConstant %3 5 %8 = OpTypeFunction %1 %2 %3 %4 = OpTypeFunction %1 %5 = OpFunction %1 None %4 %6 = OpLabel %7 = OpFunctionCall %1 %9 %four %five OpReturn OpFunctionEnd %9 = OpFunction %1 None %8 %10 = OpFunctionParameter %2 %11 = OpFunctionParameter %3 %12 = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateSSA, ForwardBranchConditionalGood) { char str[] = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %voidt = OpTypeVoid %boolt = OpTypeBool %vfunct = OpTypeFunction %voidt %true = OpConstantTrue %boolt %main = OpFunction %voidt None %vfunct %mainl = OpLabel OpSelectionMerge %endl None OpBranchConditional %true %truel %falsel %truel = OpLabel OpNop OpBranch %endl %falsel = OpLabel OpNop OpBranch %endl %endl = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateSSA, ForwardBranchConditionalWithWeightsGood) { char str[] = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %voidt = OpTypeVoid %boolt = OpTypeBool %vfunct = OpTypeFunction %voidt %true = OpConstantTrue %boolt %main = OpFunction %voidt None %vfunct %mainl = OpLabel OpSelectionMerge %endl None OpBranchConditional %true %truel %falsel 1 9 %truel = OpLabel OpNop OpBranch %endl %falsel = OpLabel OpNop OpBranch %endl %endl = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateSSA, ForwardBranchConditionalNonDominantConditionBad) { char str[] = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %tcpy "conditional" %voidt = OpTypeVoid %boolt = OpTypeBool %vfunct = OpTypeFunction %voidt %true = OpConstantTrue %boolt %main = OpFunction %voidt None %vfunct %mainl = OpLabel OpSelectionMerge %endl None OpBranchConditional %tcpy %truel %falsel ; %truel = OpLabel OpNop OpBranch %endl %falsel = OpLabel OpNop OpBranch %endl %endl = OpLabel %tcpy = OpCopyObject %boolt %true OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("conditional")); } TEST_F(ValidateSSA, ForwardBranchConditionalMissingTargetBad) { char str[] = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpName %missing "missing" %voidt = OpTypeVoid %boolt = OpTypeBool %vfunct = OpTypeFunction %voidt %true = OpConstantTrue %boolt %main = OpFunction %voidt None %vfunct %mainl = OpLabel OpSelectionMerge %endl None OpBranchConditional %true %missing %falsel %truel = OpLabel OpNop OpBranch %endl %falsel = OpLabel OpNop OpBranch %endl %endl = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("missing")); } // Since Int8 requires the Kernel capability, the signedness of int types may // not be "1". const std::string kHeader = R"( OpCapability Int8 OpCapability DeviceEnqueue OpCapability Linkage OpMemoryModel Logical OpenCL )"; const std::string kBasicTypes = R"( %voidt = OpTypeVoid %boolt = OpTypeBool %int8t = OpTypeInt 8 0 %uintt = OpTypeInt 32 0 %vfunct = OpTypeFunction %voidt %intptrt = OpTypePointer UniformConstant %uintt %zero = OpConstant %uintt 0 %one = OpConstant %uintt 1 %ten = OpConstant %uintt 10 %false = OpConstantFalse %boolt )"; const std::string kKernelTypesAndConstants = R"( %queuet = OpTypeQueue %three = OpConstant %uintt 3 %arr3t = OpTypeArray %uintt %three %ndt = OpTypeStruct %uintt %arr3t %arr3t %arr3t %eventt = OpTypeEvent %offset = OpConstant %uintt 0 %local = OpConstant %uintt 1 %gl = OpConstant %uintt 1 %nevent = OpConstant %uintt 0 %event = OpConstantNull %eventt %firstp = OpConstant %int8t 0 %psize = OpConstant %uintt 0 %palign = OpConstant %uintt 32 %lsize = OpConstant %uintt 1 %flags = OpConstant %uintt 0 ; NoWait %kfunct = OpTypeFunction %voidt %intptrt )"; const std::string kKernelSetup = R"( %dqueue = OpGetDefaultQueue %queuet %ndval = OpBuildNDRange %ndt %gl %local %offset %revent = OpUndef %eventt )"; const std::string kKernelDefinition = R"( %kfunc = OpFunction %voidt None %kfunct %iparam = OpFunctionParameter %intptrt %kfuncl = OpLabel OpNop OpReturn OpFunctionEnd )"; TEST_F(ValidateSSA, EnqueueKernelGood) { std::string str = kHeader + kBasicTypes + kKernelTypesAndConstants + kKernelDefinition + R"( %main = OpFunction %voidt None %vfunct %mainl = OpLabel )" + kKernelSetup + R"( %err = OpEnqueueKernel %uintt %dqueue %flags %ndval %nevent %event %revent %kfunc %firstp %psize %palign %lsize OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateSSA, ForwardEnqueueKernelGood) { std::string str = kHeader + kBasicTypes + kKernelTypesAndConstants + R"( %main = OpFunction %voidt None %vfunct %mainl = OpLabel )" + kKernelSetup + R"( %err = OpEnqueueKernel %uintt %dqueue %flags %ndval %nevent %event %revent %kfunc %firstp %psize %palign %lsize OpReturn OpFunctionEnd )" + kKernelDefinition; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateSSA, EnqueueMissingFunctionBad) { std::string str = kHeader + "OpName %kfunc \"kfunc\"" + kBasicTypes + kKernelTypesAndConstants + R"( %main = OpFunction %voidt None %vfunct %mainl = OpLabel )" + kKernelSetup + R"( %err = OpEnqueueKernel %uintt %dqueue %flags %ndval %nevent %event %revent %kfunc %firstp %psize %palign %lsize OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("kfunc")); } std::string forwardKernelNonDominantParameterBaseCode( std::string name = std::string()) { std::string op_name; if (name.empty()) { op_name = ""; } else { op_name = "\nOpName %" + name + " \"" + name + "\"\n"; } std::string out = kHeader + op_name + kBasicTypes + kKernelTypesAndConstants + kKernelDefinition + R"( %main = OpFunction %voidt None %vfunct %mainl = OpLabel )" + kKernelSetup; return out; } TEST_F(ValidateSSA, ForwardEnqueueKernelMissingParameter1Bad) { std::string str = forwardKernelNonDominantParameterBaseCode("missing") + R"( %err = OpEnqueueKernel %missing %dqueue %flags %ndval %nevent %event %revent %kfunc %firstp %psize %palign %lsize OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("missing")); } TEST_F(ValidateSSA, ForwardEnqueueKernelNonDominantParameter2Bad) { std::string str = forwardKernelNonDominantParameterBaseCode("dqueue2") + R"( %err = OpEnqueueKernel %uintt %dqueue2 %flags %ndval %nevent %event %revent %kfunc %firstp %psize %palign %lsize %dqueue2 = OpGetDefaultQueue %queuet OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("dqueue2")); } TEST_F(ValidateSSA, ForwardEnqueueKernelNonDominantParameter3Bad) { std::string str = forwardKernelNonDominantParameterBaseCode("ndval2") + R"( %err = OpEnqueueKernel %uintt %dqueue %flags %ndval2 %nevent %event %revent %kfunc %firstp %psize %palign %lsize %ndval2 = OpBuildNDRange %ndt %gl %local %offset OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("ndval2")); } TEST_F(ValidateSSA, ForwardEnqueueKernelNonDominantParameter4Bad) { std::string str = forwardKernelNonDominantParameterBaseCode("nevent2") + R"( %err = OpEnqueueKernel %uintt %dqueue %flags %ndval %nevent2 %event %revent %kfunc %firstp %psize %palign %lsize %nevent2 = OpCopyObject %uintt %nevent OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("nevent2")); } TEST_F(ValidateSSA, ForwardEnqueueKernelNonDominantParameter5Bad) { std::string str = forwardKernelNonDominantParameterBaseCode("event2") + R"( %err = OpEnqueueKernel %uintt %dqueue %flags %ndval %nevent %event2 %revent %kfunc %firstp %psize %palign %lsize %event2 = OpCopyObject %eventt %event OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("event2")); } TEST_F(ValidateSSA, ForwardEnqueueKernelNonDominantParameter6Bad) { std::string str = forwardKernelNonDominantParameterBaseCode("revent2") + R"( %err = OpEnqueueKernel %uintt %dqueue %flags %ndval %nevent %event %revent2 %kfunc %firstp %psize %palign %lsize %revent2 = OpCopyObject %eventt %revent OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("revent2")); } TEST_F(ValidateSSA, ForwardEnqueueKernelNonDominantParameter8Bad) { std::string str = forwardKernelNonDominantParameterBaseCode("firstp2") + R"( %err = OpEnqueueKernel %uintt %dqueue %flags %ndval %nevent %event %revent %kfunc %firstp2 %psize %palign %lsize %firstp2 = OpCopyObject %int8t %firstp OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("firstp2")); } TEST_F(ValidateSSA, ForwardEnqueueKernelNonDominantParameter9Bad) { std::string str = forwardKernelNonDominantParameterBaseCode("psize2") + R"( %err = OpEnqueueKernel %uintt %dqueue %flags %ndval %nevent %event %revent %kfunc %firstp %psize2 %palign %lsize %psize2 = OpCopyObject %uintt %psize OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("psize2")); } TEST_F(ValidateSSA, ForwardEnqueueKernelNonDominantParameter10Bad) { std::string str = forwardKernelNonDominantParameterBaseCode("palign2") + R"( %err = OpEnqueueKernel %uintt %dqueue %flags %ndval %nevent %event %revent %kfunc %firstp %psize %palign2 %lsize %palign2 = OpCopyObject %uintt %palign OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("palign2")); } TEST_F(ValidateSSA, ForwardEnqueueKernelNonDominantParameter11Bad) { std::string str = forwardKernelNonDominantParameterBaseCode("lsize2") + R"( %err = OpEnqueueKernel %uintt %dqueue %flags %ndval %nevent %event %revent %kfunc %firstp %psize %palign %lsize2 %lsize2 = OpCopyObject %uintt %lsize OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("lsize2")); } static const bool kWithNDrange = true; static const bool kNoNDrange = false; std::pair cases[] = { {"OpGetKernelNDrangeSubGroupCount", kWithNDrange}, {"OpGetKernelNDrangeMaxSubGroupSize", kWithNDrange}, {"OpGetKernelWorkGroupSize", kNoNDrange}, {"OpGetKernelPreferredWorkGroupSizeMultiple", kNoNDrange}}; INSTANTIATE_TEST_SUITE_P(KernelArgs, ValidateSSA, ::testing::ValuesIn(cases)); static const std::string return_instructions = R"( OpReturn OpFunctionEnd )"; TEST_P(ValidateSSA, GetKernelGood) { std::string instruction = GetParam().first; bool with_ndrange = GetParam().second; std::string ndrange_param = with_ndrange ? " %ndval " : " "; std::stringstream ss; // clang-format off ss << forwardKernelNonDominantParameterBaseCode() + " %numsg = " << instruction + " %uintt" + ndrange_param + "%kfunc %firstp %psize %palign" << return_instructions; // clang-format on CompileSuccessfully(ss.str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateSSA, ForwardGetKernelGood) { std::string instruction = GetParam().first; bool with_ndrange = GetParam().second; std::string ndrange_param = with_ndrange ? " %ndval " : " "; // clang-format off std::string str = kHeader + kBasicTypes + kKernelTypesAndConstants + R"( %main = OpFunction %voidt None %vfunct %mainl = OpLabel )" + kKernelSetup + " %numsg = " + instruction + " %uintt" + ndrange_param + "%kfunc %firstp %psize %palign" + return_instructions + kKernelDefinition; // clang-format on CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_P(ValidateSSA, ForwardGetKernelMissingDefinitionBad) { std::string instruction = GetParam().first; bool with_ndrange = GetParam().second; std::string ndrange_param = with_ndrange ? " %ndval " : " "; std::stringstream ss; // clang-format off ss << forwardKernelNonDominantParameterBaseCode("missing") + " %numsg = " << instruction + " %uintt" + ndrange_param + "%missing %firstp %psize %palign" << return_instructions; // clang-format on CompileSuccessfully(ss.str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("missing")); } TEST_P(ValidateSSA, ForwardGetKernelNDrangeSubGroupCountMissingParameter1Bad) { std::string instruction = GetParam().first; bool with_ndrange = GetParam().second; std::string ndrange_param = with_ndrange ? " %ndval " : " "; std::stringstream ss; // clang-format off ss << forwardKernelNonDominantParameterBaseCode("missing") + " %numsg = " << instruction + " %missing" + ndrange_param + "%kfunc %firstp %psize %palign" << return_instructions; // clang-format on CompileSuccessfully(ss.str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("missing")); } TEST_P(ValidateSSA, ForwardGetKernelNDrangeSubGroupCountNonDominantParameter2Bad) { std::string instruction = GetParam().first; bool with_ndrange = GetParam().second; std::string ndrange_param = with_ndrange ? " %ndval2 " : " "; std::stringstream ss; // clang-format off ss << forwardKernelNonDominantParameterBaseCode("ndval2") + " %numsg = " << instruction + " %uintt" + ndrange_param + "%kfunc %firstp %psize %palign" << "\n %ndval2 = OpBuildNDRange %ndt %gl %local %offset" << return_instructions; // clang-format on if (GetParam().second) { CompileSuccessfully(ss.str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("ndval2")); } } TEST_P(ValidateSSA, ForwardGetKernelNDrangeSubGroupCountNonDominantParameter4Bad) { std::string instruction = GetParam().first; bool with_ndrange = GetParam().second; std::string ndrange_param = with_ndrange ? " %ndval " : " "; std::stringstream ss; // clang-format off ss << forwardKernelNonDominantParameterBaseCode("firstp2") + " %numsg = " << instruction + " %uintt" + ndrange_param + "%kfunc %firstp2 %psize %palign" << "\n %firstp2 = OpCopyObject %int8t %firstp" << return_instructions; // clang-format on CompileSuccessfully(ss.str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("firstp2")); } TEST_P(ValidateSSA, ForwardGetKernelNDrangeSubGroupCountNonDominantParameter5Bad) { std::string instruction = GetParam().first; bool with_ndrange = GetParam().second; std::string ndrange_param = with_ndrange ? " %ndval " : " "; std::stringstream ss; // clang-format off ss << forwardKernelNonDominantParameterBaseCode("psize2") + " %numsg = " << instruction + " %uintt" + ndrange_param + "%kfunc %firstp %psize2 %palign" << "\n %psize2 = OpCopyObject %uintt %psize" << return_instructions; // clang-format on CompileSuccessfully(ss.str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("psize2")); } TEST_P(ValidateSSA, ForwardGetKernelNDrangeSubGroupCountNonDominantParameter6Bad) { std::string instruction = GetParam().first; bool with_ndrange = GetParam().second; std::string ndrange_param = with_ndrange ? " %ndval " : " "; std::stringstream ss; // clang-format off ss << forwardKernelNonDominantParameterBaseCode("palign2") + " %numsg = " << instruction + " %uintt" + ndrange_param + "%kfunc %firstp %psize %palign2" << "\n %palign2 = OpCopyObject %uintt %palign" << return_instructions; // clang-format on if (GetParam().second) { CompileSuccessfully(ss.str()); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("palign2")); } } TEST_F(ValidateSSA, PhiGood) { std::string str = kHeader + kBasicTypes + R"( %func = OpFunction %voidt None %vfunct %preheader = OpLabel %init = OpCopyObject %uintt %zero OpBranch %loop %loop = OpLabel %i = OpPhi %uintt %init %preheader %loopi %loop %loopi = OpIAdd %uintt %i %one OpNop %cond = OpSLessThan %boolt %i %ten OpLoopMerge %endl %loop None OpBranchConditional %cond %loop %endl %endl = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateSSA, PhiMissingTypeBad) { std::string str = kHeader + "OpName %missing \"missing\"" + kBasicTypes + R"( %func = OpFunction %voidt None %vfunct %preheader = OpLabel %init = OpCopyObject %uintt %zero OpBranch %loop %loop = OpLabel %i = OpPhi %missing %init %preheader %loopi %loop %loopi = OpIAdd %uintt %i %one OpNop %cond = OpSLessThan %boolt %i %ten OpLoopMerge %endl %loop None OpBranchConditional %cond %loop %endl %endl = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("missing")); } TEST_F(ValidateSSA, PhiMissingIdBad) { std::string str = kHeader + "OpName %missing \"missing\"" + kBasicTypes + R"( %func = OpFunction %voidt None %vfunct %preheader = OpLabel %init = OpCopyObject %uintt %zero OpBranch %loop %loop = OpLabel %i = OpPhi %uintt %missing %preheader %loopi %loop %loopi = OpIAdd %uintt %i %one OpNop %cond = OpSLessThan %boolt %i %ten OpLoopMerge %endl %loop None OpBranchConditional %cond %loop %endl %endl = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("missing")); } TEST_F(ValidateSSA, PhiMissingLabelBad) { std::string str = kHeader + "OpName %missing \"missing\"" + kBasicTypes + R"( %func = OpFunction %voidt None %vfunct %preheader = OpLabel %init = OpCopyObject %uintt %zero OpBranch %loop %loop = OpLabel %i = OpPhi %uintt %init %missing %loopi %loop %loopi = OpIAdd %uintt %i %one OpNop %cond = OpSLessThan %boolt %i %ten OpLoopMerge %endl %loop None OpBranchConditional %cond %loop %endl %endl = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("missing")); } TEST_F(ValidateSSA, IdDominatesItsUseGood) { std::string str = kHeader + kBasicTypes + R"( %func = OpFunction %voidt None %vfunct %entry = OpLabel %cond = OpSLessThan %boolt %one %ten %eleven = OpIAdd %uintt %one %ten OpSelectionMerge %merge None OpBranchConditional %cond %t %f %t = OpLabel %twelve = OpIAdd %uintt %eleven %one OpBranch %merge %f = OpLabel %twentytwo = OpIAdd %uintt %eleven %ten OpBranch %merge %merge = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateSSA, IdDoesNotDominateItsUseBad) { std::string str = kHeader + "OpName %eleven \"eleven\"\n" "OpName %true_block \"true_block\"\n" "OpName %false_block \"false_block\"" + kBasicTypes + R"( %func = OpFunction %voidt None %vfunct %entry = OpLabel %cond = OpSLessThan %boolt %one %ten OpSelectionMerge %merge None OpBranchConditional %cond %true_block %false_block %true_block = OpLabel %eleven = OpIAdd %uintt %one %ten %twelve = OpIAdd %uintt %eleven %one OpBranch %merge %false_block = OpLabel %twentytwo = OpIAdd %uintt %eleven %ten OpBranch %merge %merge = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT( getDiagnosticString(), MatchesRegex("ID '.\\[%eleven\\]' defined in block '.\\[%true_block\\]' " "does not dominate its use in block '.\\[%false_block\\]'\n" " %false_block = OpLabel\n")); } TEST_F(ValidateSSA, PhiUseDoesntDominateDefinitionGood) { std::string str = kHeader + kBasicTypes + R"( %funcintptrt = OpTypePointer Function %uintt %func = OpFunction %voidt None %vfunct %entry = OpLabel %var_one = OpVariable %funcintptrt Function %one %one_val = OpLoad %uintt %var_one OpBranch %loop %loop = OpLabel %i = OpPhi %uintt %one_val %entry %inew %cont %cond = OpSLessThan %boolt %one %ten OpLoopMerge %merge %cont None OpBranchConditional %cond %body %merge %body = OpLabel OpBranch %cont %cont = OpLabel %inew = OpIAdd %uintt %i %one OpBranch %loop %merge = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateSSA, PhiUseDoesntDominateUseOfPhiOperandUsedBeforeDefinitionBad) { std::string str = kHeader + "OpName %inew \"inew\"" + kBasicTypes + R"( %func = OpFunction %voidt None %vfunct %entry = OpLabel %var_one = OpVariable %intptrt Function %one %one_val = OpLoad %uintt %var_one OpBranch %loop %loop = OpLabel %i = OpPhi %uintt %one_val %entry %inew %cont %bad = OpIAdd %uintt %inew %one %cond = OpSLessThan %boolt %one %ten OpLoopMerge %merge %cont None OpBranchConditional %cond %body %merge %body = OpLabel OpBranch %cont %cont = OpLabel %inew = OpIAdd %uintt %i %one OpBranch %loop %merge = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), MatchesRegex("ID '.\\[%inew\\]' has not been defined\n" " %19 = OpIAdd %uint %inew %uint_1\n")); } TEST_F(ValidateSSA, PhiUseMayComeFromNonDominatingBlockGood) { std::string str = kHeader + "OpName %if_true \"if_true\"\n" + "OpName %exit \"exit\"\n" + "OpName %copy \"copy\"\n" + kBasicTypes + R"( %func = OpFunction %voidt None %vfunct %entry = OpLabel OpBranchConditional %false %if_true %exit %if_true = OpLabel %copy = OpCopyObject %boolt %false OpBranch %exit ; The use of %copy here is ok, even though it was defined ; in a block that does not dominate %exit. That's the point ; of an OpPhi. %exit = OpLabel %value = OpPhi %boolt %false %entry %copy %if_true OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()) << getDiagnosticString(); } TEST_F(ValidateSSA, PhiUsesItsOwnDefinitionGood) { // See https://github.com/KhronosGroup/SPIRV-Tools/issues/415 // // Non-phi instructions can't use their own definitions, as // already checked in test DominateUsageSameInstructionBad. std::string str = kHeader + "OpName %loop \"loop\"\n" + "OpName %value \"value\"\n" + kBasicTypes + R"( %func = OpFunction %voidt None %vfunct %entry = OpLabel OpBranch %loop %loop = OpLabel %value = OpPhi %boolt %false %entry %value %loop OpBranch %loop OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()) << getDiagnosticString(); } TEST_F(ValidateSSA, PhiVariableDefNotDominatedByParentBlockBad) { std::string str = kHeader + "OpName %if_true \"if_true\"\n" + "OpName %if_false \"if_false\"\n" + "OpName %exit \"exit\"\n" + "OpName %value \"phi\"\n" + "OpName %true_copy \"true_copy\"\n" + "OpName %false_copy \"false_copy\"\n" + kBasicTypes + R"( %func = OpFunction %voidt None %vfunct %entry = OpLabel OpBranchConditional %false %if_true %if_false %if_true = OpLabel %true_copy = OpCopyObject %boolt %false OpBranch %exit %if_false = OpLabel %false_copy = OpCopyObject %boolt %false OpBranch %exit ; The (variable,Id) pairs are swapped. %exit = OpLabel %value = OpPhi %boolt %true_copy %if_false %false_copy %if_true OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), MatchesRegex( "In OpPhi instruction '.\\[%phi\\]', ID '.\\[%true_copy\\]' " "definition does not dominate its parent '.\\[%if_false\\]'\n" " %phi = OpPhi %bool %true_copy %if_false %false_copy " "%if_true\n")); } TEST_F(ValidateSSA, PhiVariableDefDominatesButNotDefinedInParentBlock) { std::string str = kHeader + "OpName %if_true \"if_true\"\n" + kBasicTypes + R"( %func = OpFunction %voidt None %vfunct %entry = OpLabel OpBranchConditional %false %if_true %if_false %if_true = OpLabel %true_copy = OpCopyObject %boolt %false OpBranch %if_tnext %if_tnext = OpLabel OpBranch %exit %if_false = OpLabel %false_copy = OpCopyObject %boolt %false OpBranch %if_fnext %if_fnext = OpLabel OpBranch %exit %exit = OpLabel %value = OpPhi %boolt %true_copy %if_tnext %false_copy %if_fnext OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateSSA, DominanceCheckIgnoresUsesInUnreachableBlocksDefInBlockGood) { std::string str = kHeader + kBasicTypes + R"( %func = OpFunction %voidt None %vfunct %entry = OpLabel %def = OpCopyObject %boolt %false OpReturn %unreach = OpLabel %use = OpCopyObject %boolt %def OpReturn OpFunctionEnd )"; CompileSuccessfully(str); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()) << getDiagnosticString(); } TEST_F(ValidateSSA, PhiVariableUnreachableDefNotInParentBlock) { std::string str = kHeader + "OpName %unreachable \"unreachable\"\n" + kBasicTypes + R"( %func = OpFunction %voidt None %vfunct %entry = OpLabel OpBranch %if_false %unreachable = OpLabel %copy = OpCopyObject %boolt %false OpBranch %if_tnext %if_tnext = OpLabel OpBranch %exit %if_false = OpLabel %false_copy = OpCopyObject %boolt %false OpBranch %if_fnext %if_fnext = OpLabel OpBranch %exit %exit = OpLabel %value = OpPhi %boolt %copy %if_tnext %false_copy %if_fnext OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateSSA, DominanceCheckIgnoresUsesInUnreachableBlocksDefIsParamGood) { std::string str = kHeader + kBasicTypes + R"( %void_fn_int = OpTypeFunction %voidt %uintt %func = OpFunction %voidt None %void_fn_int %int_param = OpFunctionParameter %uintt %entry = OpLabel OpReturn %unreach = OpLabel %use = OpCopyObject %uintt %int_param OpReturn OpFunctionEnd )"; CompileSuccessfully(str); EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()) << getDiagnosticString(); } TEST_F(ValidateSSA, UseFunctionParameterFromOtherFunctionBad) { std::string str = kHeader + "OpName %first \"first\"\n" "OpName %func \"func\"\n" + "OpName %func2 \"func2\"\n" + kBasicTypes + R"( %viifunct = OpTypeFunction %voidt %uintt %uintt %func = OpFunction %voidt None %viifunct %first = OpFunctionParameter %uintt %second = OpFunctionParameter %uintt OpFunctionEnd %func2 = OpFunction %voidt None %viifunct %first2 = OpFunctionParameter %uintt %second2 = OpFunctionParameter %uintt %entry2 = OpLabel %baduse = OpIAdd %uintt %first %first2 OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), MatchesRegex( "ID '.\\[%first\\]' used in function '.\\[%func2\\]' is used " "outside of it's defining function '.\\[%func\\]'\n" " %func = OpFunction %void None %14\n")); } TEST_F(ValidateSSA, TypeForwardPointerForwardReference) { // See https://github.com/KhronosGroup/SPIRV-Tools/issues/429 // // ForwardPointers can references instructions that have not been defined std::string str = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpName %intptrt "intptrt" OpTypeForwardPointer %intptrt UniformConstant %uint = OpTypeInt 32 0 %struct = OpTypeStruct %uint %intptrt = OpTypePointer UniformConstant %struct )"; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateSSA, TypeStructForwardReference) { std::string str = R"( OpCapability Kernel OpCapability Addresses OpCapability Linkage OpMemoryModel Logical OpenCL OpName %structptr "structptr" OpTypeForwardPointer %structptr UniformConstant %uint = OpTypeInt 32 0 %structt1 = OpTypeStruct %structptr %uint %structt2 = OpTypeStruct %uint %structptr %structt3 = OpTypeStruct %uint %uint %structptr %structt4 = OpTypeStruct %uint %uint %uint %structptr %structptr = OpTypePointer UniformConstant %structt1 )"; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } // TODO(umar): OpGroupMemberDecorate } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_state_test.cpp000066400000000000000000000173311475742701700240240ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Unit tests for ValidationState_t. #include #include "gtest/gtest.h" #include "source/enum_set.h" #include "source/extensions.h" #include "source/latest_version_spirv_header.h" #include "source/spirv_validator_options.h" #include "source/val/validation_state.h" namespace spvtools { namespace val { namespace { // This is all we need for these tests. static uint32_t kFakeBinary[] = {0}; // A test with a ValidationState_t member transparently. class ValidationStateTest : public testing::Test { public: ValidationStateTest() : context_(spvContextCreate(SPV_ENV_UNIVERSAL_1_0)), options_(spvValidatorOptionsCreate()), state_(context_, options_, kFakeBinary, 0, 1) {} ~ValidationStateTest() override { spvContextDestroy(context_); spvValidatorOptionsDestroy(options_); } protected: spv_context context_; spv_validator_options options_; ValidationState_t state_; }; // A test of ValidationState_t::HasAnyOfCapabilities(). using ValidationState_HasAnyOfCapabilities = ValidationStateTest; TEST_F(ValidationState_HasAnyOfCapabilities, EmptyMask) { EXPECT_TRUE(state_.HasAnyOfCapabilities({})); state_.RegisterCapability(spv::Capability::Matrix); EXPECT_TRUE(state_.HasAnyOfCapabilities({})); state_.RegisterCapability(spv::Capability::ImageMipmap); EXPECT_TRUE(state_.HasAnyOfCapabilities({})); state_.RegisterCapability(spv::Capability::Pipes); EXPECT_TRUE(state_.HasAnyOfCapabilities({})); state_.RegisterCapability(spv::Capability::StorageImageArrayDynamicIndexing); EXPECT_TRUE(state_.HasAnyOfCapabilities({})); state_.RegisterCapability(spv::Capability::ClipDistance); EXPECT_TRUE(state_.HasAnyOfCapabilities({})); state_.RegisterCapability(spv::Capability::StorageImageWriteWithoutFormat); EXPECT_TRUE(state_.HasAnyOfCapabilities({})); } TEST_F(ValidationState_HasAnyOfCapabilities, SingleCapMask) { EXPECT_FALSE(state_.HasAnyOfCapabilities({spv::Capability::Matrix})); EXPECT_FALSE(state_.HasAnyOfCapabilities({spv::Capability::ImageMipmap})); state_.RegisterCapability(spv::Capability::Matrix); EXPECT_TRUE(state_.HasAnyOfCapabilities({spv::Capability::Matrix})); EXPECT_FALSE(state_.HasAnyOfCapabilities({spv::Capability::ImageMipmap})); state_.RegisterCapability(spv::Capability::ImageMipmap); EXPECT_TRUE(state_.HasAnyOfCapabilities({spv::Capability::Matrix})); EXPECT_TRUE(state_.HasAnyOfCapabilities({spv::Capability::ImageMipmap})); } TEST_F(ValidationState_HasAnyOfCapabilities, MultiCapMask) { const auto set1 = CapabilitySet{spv::Capability::SampledRect, spv::Capability::ImageBuffer}; const auto set2 = CapabilitySet{spv::Capability::StorageImageWriteWithoutFormat, spv::Capability::StorageImageReadWithoutFormat, spv::Capability::GeometryStreams}; EXPECT_FALSE(state_.HasAnyOfCapabilities(set1)); EXPECT_FALSE(state_.HasAnyOfCapabilities(set2)); state_.RegisterCapability(spv::Capability::ImageBuffer); EXPECT_TRUE(state_.HasAnyOfCapabilities(set1)); EXPECT_FALSE(state_.HasAnyOfCapabilities(set2)); } // A test of ValidationState_t::HasAnyOfExtensions(). using ValidationState_HasAnyOfExtensions = ValidationStateTest; TEST_F(ValidationState_HasAnyOfExtensions, EmptyMask) { EXPECT_TRUE(state_.HasAnyOfExtensions({})); state_.RegisterExtension(Extension::kSPV_KHR_shader_ballot); EXPECT_TRUE(state_.HasAnyOfExtensions({})); state_.RegisterExtension(Extension::kSPV_KHR_16bit_storage); EXPECT_TRUE(state_.HasAnyOfExtensions({})); state_.RegisterExtension(Extension::kSPV_NV_viewport_array2); EXPECT_TRUE(state_.HasAnyOfExtensions({})); } TEST_F(ValidationState_HasAnyOfExtensions, SingleCapMask) { EXPECT_FALSE(state_.HasAnyOfExtensions({Extension::kSPV_KHR_shader_ballot})); EXPECT_FALSE(state_.HasAnyOfExtensions({Extension::kSPV_KHR_16bit_storage})); state_.RegisterExtension(Extension::kSPV_KHR_shader_ballot); EXPECT_TRUE(state_.HasAnyOfExtensions({Extension::kSPV_KHR_shader_ballot})); EXPECT_FALSE(state_.HasAnyOfExtensions({Extension::kSPV_KHR_16bit_storage})); state_.RegisterExtension(Extension::kSPV_KHR_16bit_storage); EXPECT_TRUE(state_.HasAnyOfExtensions({Extension::kSPV_KHR_shader_ballot})); EXPECT_TRUE(state_.HasAnyOfExtensions({Extension::kSPV_KHR_16bit_storage})); } TEST_F(ValidationState_HasAnyOfExtensions, MultiCapMask) { const auto set1 = ExtensionSet{Extension::kSPV_KHR_multiview, Extension::kSPV_KHR_16bit_storage}; const auto set2 = ExtensionSet{Extension::kSPV_KHR_shader_draw_parameters, Extension::kSPV_NV_stereo_view_rendering, Extension::kSPV_KHR_shader_ballot}; EXPECT_FALSE(state_.HasAnyOfExtensions(set1)); EXPECT_FALSE(state_.HasAnyOfExtensions(set2)); state_.RegisterExtension(Extension::kSPV_KHR_multiview); EXPECT_TRUE(state_.HasAnyOfExtensions(set1)); EXPECT_FALSE(state_.HasAnyOfExtensions(set2)); } // A test of ValidationState_t::IsOpcodeInCurrentLayoutSection(). using ValidationState_InLayoutState = ValidationStateTest; TEST_F(ValidationState_InLayoutState, Variable) { state_.SetCurrentLayoutSectionForTesting(kLayoutTypes); EXPECT_TRUE(state_.IsOpcodeInCurrentLayoutSection(spv::Op::OpVariable)); state_.SetCurrentLayoutSectionForTesting(kLayoutFunctionDefinitions); EXPECT_TRUE(state_.IsOpcodeInCurrentLayoutSection(spv::Op::OpVariable)); } TEST_F(ValidationState_InLayoutState, ExtInst) { state_.SetCurrentLayoutSectionForTesting(kLayoutTypes); EXPECT_TRUE(state_.IsOpcodeInCurrentLayoutSection(spv::Op::OpExtInst)); state_.SetCurrentLayoutSectionForTesting(kLayoutFunctionDefinitions); EXPECT_TRUE(state_.IsOpcodeInCurrentLayoutSection(spv::Op::OpExtInst)); } TEST_F(ValidationState_InLayoutState, Undef) { state_.SetCurrentLayoutSectionForTesting(kLayoutTypes); EXPECT_TRUE(state_.IsOpcodeInCurrentLayoutSection(spv::Op::OpUndef)); state_.SetCurrentLayoutSectionForTesting(kLayoutFunctionDefinitions); EXPECT_TRUE(state_.IsOpcodeInCurrentLayoutSection(spv::Op::OpUndef)); } TEST_F(ValidationState_InLayoutState, Function) { state_.SetCurrentLayoutSectionForTesting(kLayoutFunctionDeclarations); EXPECT_TRUE(state_.IsOpcodeInCurrentLayoutSection(spv::Op::OpFunction)); state_.SetCurrentLayoutSectionForTesting(kLayoutFunctionDefinitions); EXPECT_TRUE(state_.IsOpcodeInCurrentLayoutSection(spv::Op::OpFunction)); } TEST_F(ValidationState_InLayoutState, FunctionParameter) { state_.SetCurrentLayoutSectionForTesting(kLayoutFunctionDeclarations); EXPECT_TRUE( state_.IsOpcodeInCurrentLayoutSection(spv::Op::OpFunctionParameter)); state_.SetCurrentLayoutSectionForTesting(kLayoutFunctionDefinitions); EXPECT_TRUE( state_.IsOpcodeInCurrentLayoutSection(spv::Op::OpFunctionParameter)); } TEST_F(ValidationState_InLayoutState, FunctionEnd) { state_.SetCurrentLayoutSectionForTesting(kLayoutFunctionDeclarations); EXPECT_TRUE(state_.IsOpcodeInCurrentLayoutSection(spv::Op::OpFunctionEnd)); state_.SetCurrentLayoutSectionForTesting(kLayoutFunctionDefinitions); EXPECT_TRUE(state_.IsOpcodeInCurrentLayoutSection(spv::Op::OpFunctionEnd)); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_storage_test.cpp000066400000000000000000000517121475742701700243510ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Validation tests for OpVariable storage class #include #include #include #include "gmock/gmock.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::HasSubstr; using ::testing::Values; using ValidateStorage = spvtest::ValidateBase; using ValidateStorageExecutionModel = spvtest::ValidateBase; TEST_F(ValidateStorage, FunctionStorageInsideFunction) { char str[] = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %intt = OpTypeInt 32 1 %voidt = OpTypeVoid %vfunct = OpTypeFunction %voidt %ptrt = OpTypePointer Function %intt %func = OpFunction %voidt None %vfunct %funcl = OpLabel %var = OpVariable %ptrt Function OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateStorage, FunctionStorageOutsideFunction) { char str[] = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %intt = OpTypeInt 32 1 %voidt = OpTypeVoid %vfunct = OpTypeFunction %voidt %ptrt = OpTypePointer Function %intt %var = OpVariable %ptrt Function %func = OpFunction %voidt None %vfunct %funcl = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Variables can not have a function[7] storage class " "outside of a function")); } TEST_F(ValidateStorage, OtherStorageOutsideFunction) { char str[] = R"( OpCapability Shader OpCapability Kernel OpCapability AtomicStorage OpCapability Linkage OpMemoryModel Logical GLSL450 %intt = OpTypeInt 32 0 %voidt = OpTypeVoid %vfunct = OpTypeFunction %voidt %uniconptrt = OpTypePointer UniformConstant %intt %unicon = OpVariable %uniconptrt UniformConstant %inputptrt = OpTypePointer Input %intt %input = OpVariable %inputptrt Input %unifptrt = OpTypePointer Uniform %intt %unif = OpVariable %unifptrt Uniform %outputptrt = OpTypePointer Output %intt %output = OpVariable %outputptrt Output %wgroupptrt = OpTypePointer Workgroup %intt %wgroup = OpVariable %wgroupptrt Workgroup %xwgrpptrt = OpTypePointer CrossWorkgroup %intt %xwgrp = OpVariable %xwgrpptrt CrossWorkgroup %privptrt = OpTypePointer Private %intt %priv = OpVariable %privptrt Private %pushcoptrt = OpTypePointer PushConstant %intt %pushco = OpVariable %pushcoptrt PushConstant %atomcptrt = OpTypePointer AtomicCounter %intt %atomct = OpVariable %atomcptrt AtomicCounter %imageptrt = OpTypePointer Image %intt %image = OpVariable %imageptrt Image %func = OpFunction %voidt None %vfunct %funcl = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } // clang-format off TEST_P(ValidateStorage, OtherStorageInsideFunction) { std::stringstream ss; ss << R"( OpCapability Shader OpCapability Kernel OpCapability AtomicStorage OpCapability Linkage OpMemoryModel Logical GLSL450 %intt = OpTypeInt 32 0 %voidt = OpTypeVoid %vfunct = OpTypeFunction %voidt %ptrt = OpTypePointer Function %intt %func = OpFunction %voidt None %vfunct %funcl = OpLabel %var = OpVariable %ptrt )" << GetParam() << R"( OpReturn OpFunctionEnd )"; CompileSuccessfully(ss.str()); ASSERT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr( "Variables must have a function[7] storage class inside of a function")); } INSTANTIATE_TEST_SUITE_P(MatrixOp, ValidateStorage, ::testing::Values( "Input", "Uniform", "Output", "Workgroup", "CrossWorkgroup", "Private", "PushConstant", "AtomicCounter", "Image")); // clang-format on TEST_F(ValidateStorage, GenericVariableOutsideFunction) { const auto str = R"( OpCapability Kernel OpCapability Linkage OpCapability GenericPointer OpMemoryModel Logical OpenCL %intt = OpTypeInt 32 0 %ptrt = OpTypePointer Function %intt %var = OpVariable %ptrt Generic )"; CompileSuccessfully(str); ASSERT_EQ(SPV_ERROR_INVALID_BINARY, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Variable storage class cannot be Generic")); } TEST_F(ValidateStorage, GenericVariableInsideFunction) { const auto str = R"( OpCapability Shader OpCapability Linkage OpCapability GenericPointer OpMemoryModel Logical GLSL450 %intt = OpTypeInt 32 1 %voidt = OpTypeVoid %vfunct = OpTypeFunction %voidt %ptrt = OpTypePointer Function %intt %func = OpFunction %voidt None %vfunct %funcl = OpLabel %var = OpVariable %ptrt Generic OpReturn OpFunctionEnd )"; CompileSuccessfully(str); EXPECT_EQ(SPV_ERROR_INVALID_BINARY, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("Variable storage class cannot be Generic")); } TEST_F(ValidateStorage, RelaxedLogicalPointerFunctionParam) { const auto str = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %intt = OpTypeInt 32 1 %voidt = OpTypeVoid %ptrt = OpTypePointer Function %intt %vfunct = OpTypeFunction %voidt %vifunct = OpTypeFunction %voidt %ptrt %wgroupptrt = OpTypePointer Workgroup %intt %wgroup = OpVariable %wgroupptrt Workgroup %main = OpFunction %voidt None %vfunct %mainl = OpLabel %ret = OpFunctionCall %voidt %func %wgroup OpReturn OpFunctionEnd %func = OpFunction %voidt None %vifunct %arg = OpFunctionParameter %ptrt %funcl = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str); getValidatorOptions()->before_hlsl_legalization = true; ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateStorage, RelaxedLogicalPointerFunctionParamBad) { const auto str = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %floatt = OpTypeFloat 32 %intt = OpTypeInt 32 1 %voidt = OpTypeVoid %ptrt = OpTypePointer Function %intt %vfunct = OpTypeFunction %voidt %vifunct = OpTypeFunction %voidt %ptrt %wgroupptrt = OpTypePointer Workgroup %floatt %wgroup = OpVariable %wgroupptrt Workgroup %main = OpFunction %voidt None %vfunct %mainl = OpLabel %ret = OpFunctionCall %voidt %func %wgroup OpReturn OpFunctionEnd %func = OpFunction %voidt None %vifunct %arg = OpFunctionParameter %ptrt %funcl = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str); getValidatorOptions()->relax_logical_pointer = true; ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr("OpFunctionCall Argument '")); } std::string GenerateExecutionModelCode(const std::string& execution_model, const std::string& storage_class, bool store) { const std::string mode = (execution_model.compare("GLCompute") == 0) ? "OpExecutionMode %func LocalSize 1 1 1" : ""; const std::string operation = (store) ? "OpStore %var %int0" : "%load = OpLoad %intt %var"; std::ostringstream ss; ss << R"( OpCapability Shader OpCapability RayTracingKHR OpExtension "SPV_KHR_ray_tracing" OpMemoryModel Logical GLSL450 OpEntryPoint )" << execution_model << R"( %func "func" %var )" << mode << R"( OpDecorate %var Location 0 %intt = OpTypeInt 32 0 %int0 = OpConstant %intt 0 %voidt = OpTypeVoid %vfunct = OpTypeFunction %voidt %ptr = OpTypePointer )" << storage_class << R"( %intt %var = OpVariable %ptr )" << storage_class << R"( %func = OpFunction %voidt None %vfunct %funcl = OpLabel )" << operation << R"( OpReturn OpFunctionEnd )"; return ss.str(); } TEST_P(ValidateStorageExecutionModel, VulkanOutsideStoreFailure) { std::string execution_model = GetParam(); CompileSuccessfully( GenerateExecutionModelCode(execution_model, "Output", true).c_str(), SPV_ENV_VULKAN_1_0); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-None-04644")); EXPECT_THAT( getDiagnosticString(), HasSubstr("in Vulkan environment, Output Storage Class must not be used " "in GLCompute, RayGenerationKHR, IntersectionKHR, AnyHitKHR, " "ClosestHitKHR, MissKHR, or CallableKHR execution models")); } TEST_P(ValidateStorageExecutionModel, CallableDataStore) { std::string execution_model = GetParam(); CompileSuccessfully( GenerateExecutionModelCode(execution_model, "CallableDataKHR", true) .c_str(), SPV_ENV_VULKAN_1_2); if (execution_model.compare("RayGenerationKHR") == 0 || execution_model.compare("ClosestHitKHR") == 0 || execution_model.compare("CallableKHR") == 0 || execution_model.compare("MissKHR") == 0) { ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } else { ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-CallableDataKHR-04704")); EXPECT_THAT( getDiagnosticString(), HasSubstr( "CallableDataKHR Storage Class is limited to RayGenerationKHR, " "ClosestHitKHR, CallableKHR, and MissKHR execution model")); } } TEST_P(ValidateStorageExecutionModel, CallableDataLoad) { std::string execution_model = GetParam(); CompileSuccessfully( GenerateExecutionModelCode(execution_model, "CallableDataKHR", false) .c_str(), SPV_ENV_VULKAN_1_2); if (execution_model.compare("RayGenerationKHR") == 0 || execution_model.compare("ClosestHitKHR") == 0 || execution_model.compare("CallableKHR") == 0 || execution_model.compare("MissKHR") == 0) { ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } else { ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-CallableDataKHR-04704")); EXPECT_THAT( getDiagnosticString(), HasSubstr( "CallableDataKHR Storage Class is limited to RayGenerationKHR, " "ClosestHitKHR, CallableKHR, and MissKHR execution model")); } } TEST_P(ValidateStorageExecutionModel, IncomingCallableDataStore) { std::string execution_model = GetParam(); CompileSuccessfully(GenerateExecutionModelCode( execution_model, "IncomingCallableDataKHR", true) .c_str(), SPV_ENV_VULKAN_1_2); if (execution_model.compare("CallableKHR") == 0) { ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } else { ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-IncomingCallableDataKHR-04705")); EXPECT_THAT(getDiagnosticString(), HasSubstr("IncomingCallableDataKHR Storage Class is limited to " "CallableKHR execution model")); } } TEST_P(ValidateStorageExecutionModel, IncomingCallableDataLoad) { std::string execution_model = GetParam(); CompileSuccessfully(GenerateExecutionModelCode( execution_model, "IncomingCallableDataKHR", false) .c_str(), SPV_ENV_VULKAN_1_2); if (execution_model.compare("CallableKHR") == 0) { ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } else { ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-IncomingCallableDataKHR-04705")); EXPECT_THAT(getDiagnosticString(), HasSubstr("IncomingCallableDataKHR Storage Class is limited to " "CallableKHR execution model")); } } TEST_P(ValidateStorageExecutionModel, RayPayloadStore) { std::string execution_model = GetParam(); CompileSuccessfully( GenerateExecutionModelCode(execution_model, "RayPayloadKHR", true) .c_str(), SPV_ENV_VULKAN_1_2); if (execution_model.compare("RayGenerationKHR") == 0 || execution_model.compare("ClosestHitKHR") == 0 || execution_model.compare("MissKHR") == 0) { ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } else { ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-RayPayloadKHR-04698")); EXPECT_THAT( getDiagnosticString(), HasSubstr("RayPayloadKHR Storage Class is limited to RayGenerationKHR, " "ClosestHitKHR, and MissKHR execution model")); } } TEST_P(ValidateStorageExecutionModel, RayPayloadLoad) { std::string execution_model = GetParam(); CompileSuccessfully( GenerateExecutionModelCode(execution_model, "RayPayloadKHR", false) .c_str(), SPV_ENV_VULKAN_1_2); if (execution_model.compare("RayGenerationKHR") == 0 || execution_model.compare("ClosestHitKHR") == 0 || execution_model.compare("MissKHR") == 0) { ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } else { ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-RayPayloadKHR-04698")); EXPECT_THAT( getDiagnosticString(), HasSubstr("RayPayloadKHR Storage Class is limited to RayGenerationKHR, " "ClosestHitKHR, and MissKHR execution model")); } } TEST_P(ValidateStorageExecutionModel, HitAttributeStore) { std::string execution_model = GetParam(); CompileSuccessfully( GenerateExecutionModelCode(execution_model, "HitAttributeKHR", true) .c_str(), SPV_ENV_VULKAN_1_2); if (execution_model.compare("IntersectionKHR") == 0) { ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } else if (execution_model.compare("AnyHitKHR") == 0 || execution_model.compare("ClosestHitKHR") == 0) { ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-HitAttributeKHR-04703")); EXPECT_THAT(getDiagnosticString(), HasSubstr("HitAttributeKHR Storage Class variables are read " "only with AnyHitKHR and ClosestHitKHR")); } else { ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-HitAttributeKHR-04701")); EXPECT_THAT( getDiagnosticString(), HasSubstr( "HitAttributeKHR Storage Class is limited to IntersectionKHR, " "AnyHitKHR, sand ClosestHitKHR execution model")); } } TEST_P(ValidateStorageExecutionModel, HitAttributeLoad) { std::string execution_model = GetParam(); CompileSuccessfully( GenerateExecutionModelCode(execution_model, "HitAttributeKHR", false) .c_str(), SPV_ENV_VULKAN_1_2); if (execution_model.compare("IntersectionKHR") == 0 || execution_model.compare("AnyHitKHR") == 0 || execution_model.compare("ClosestHitKHR") == 0) { ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } else { ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-HitAttributeKHR-04701")); EXPECT_THAT( getDiagnosticString(), HasSubstr( "HitAttributeKHR Storage Class is limited to IntersectionKHR, " "AnyHitKHR, sand ClosestHitKHR execution model")); } } TEST_P(ValidateStorageExecutionModel, IncomingRayPayloadStore) { std::string execution_model = GetParam(); CompileSuccessfully( GenerateExecutionModelCode(execution_model, "IncomingRayPayloadKHR", true) .c_str(), SPV_ENV_VULKAN_1_2); if (execution_model.compare("AnyHitKHR") == 0 || execution_model.compare("ClosestHitKHR") == 0 || execution_model.compare("MissKHR") == 0) { ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } else { ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-IncomingRayPayloadKHR-04699")); EXPECT_THAT( getDiagnosticString(), HasSubstr("IncomingRayPayloadKHR Storage Class is limited to " "AnyHitKHR, ClosestHitKHR, and MissKHR execution model")); } } TEST_P(ValidateStorageExecutionModel, IncomingRayPayloadLoad) { std::string execution_model = GetParam(); CompileSuccessfully(GenerateExecutionModelCode(execution_model, "IncomingRayPayloadKHR", false) .c_str(), SPV_ENV_VULKAN_1_2); if (execution_model.compare("AnyHitKHR") == 0 || execution_model.compare("ClosestHitKHR") == 0 || execution_model.compare("MissKHR") == 0) { ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } else { ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-IncomingRayPayloadKHR-04699")); EXPECT_THAT( getDiagnosticString(), HasSubstr("IncomingRayPayloadKHR Storage Class is limited to " "AnyHitKHR, ClosestHitKHR, and MissKHR execution model")); } } TEST_P(ValidateStorageExecutionModel, ShaderRecordBufferStore) { std::string execution_model = GetParam(); CompileSuccessfully( GenerateExecutionModelCode(execution_model, "ShaderRecordBufferKHR", true) .c_str(), SPV_ENV_VULKAN_1_2); ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT( getDiagnosticString(), HasSubstr("ShaderRecordBufferKHR Storage Class variables are read only")); } TEST_P(ValidateStorageExecutionModel, ShaderRecordBufferLoad) { std::string execution_model = GetParam(); CompileSuccessfully(GenerateExecutionModelCode(execution_model, "ShaderRecordBufferKHR", false) .c_str(), SPV_ENV_VULKAN_1_2); if (execution_model.compare("RayGenerationKHR") == 0 || execution_model.compare("IntersectionKHR") == 0 || execution_model.compare("AnyHitKHR") == 0 || execution_model.compare("ClosestHitKHR") == 0 || execution_model.compare("CallableKHR") == 0 || execution_model.compare("MissKHR") == 0) { ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_2)); } else { ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_2)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-ShaderRecordBufferKHR-07119")); EXPECT_THAT( getDiagnosticString(), HasSubstr("ShaderRecordBufferKHR Storage Class is limited to " "RayGenerationKHR, IntersectionKHR, AnyHitKHR, " "ClosestHitKHR, CallableKHR, and MissKHR execution model")); } } INSTANTIATE_TEST_SUITE_P(MatrixExecutionModel, ValidateStorageExecutionModel, ::testing::Values("RayGenerationKHR", "IntersectionKHR", "AnyHitKHR", "ClosestHitKHR", "MissKHR", "CallableKHR", "GLCompute")); } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_type_unique_test.cpp000066400000000000000000000222121475742701700252450ustar00rootroot00000000000000// Copyright (c) 2017 Google Inc. // Modifications Copyright (C) 2024 Advanced Micro Devices, Inc. All rights // reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Tests for unique type declaration rules validator. #include #include "gmock/gmock.h" #include "test/unit_spirv.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::HasSubstr; using ::testing::Not; using ValidateTypeUnique = spvtest::ValidateBase; const spv_result_t kDuplicateTypeError = SPV_ERROR_INVALID_DATA; const std::string& GetHeader() { static const std::string header = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %floatt = OpTypeFloat 32 %vec2t = OpTypeVector %floatt 2 %vec3t = OpTypeVector %floatt 3 %vec4t = OpTypeVector %floatt 4 %mat22t = OpTypeMatrix %vec2t 2 %mat33t = OpTypeMatrix %vec3t 3 %mat44t = OpTypeMatrix %vec4t 4 %intt = OpTypeInt 32 1 %uintt = OpTypeInt 32 0 %num3 = OpConstant %uintt 3 %const3 = OpConstant %uintt 3 %val3 = OpConstant %uintt 3 %array = OpTypeArray %vec3t %num3 %struct = OpTypeStruct %floatt %floatt %vec3t %boolt = OpTypeBool %array2 = OpTypeArray %vec3t %num3 %voidt = OpTypeVoid %vfunct = OpTypeFunction %voidt %struct2 = OpTypeStruct %floatt %floatt %vec3t %false = OpConstantFalse %boolt %true = OpConstantTrue %boolt %runtime_arrayt = OpTypeRuntimeArray %floatt %runtime_arrayt2 = OpTypeRuntimeArray %floatt )"; return header; } const std::string& GetBody() { static const std::string body = R"( %main = OpFunction %voidt None %vfunct %mainl = OpLabel %a = OpIAdd %uintt %const3 %val3 %b = OpIAdd %uintt %const3 %val3 OpSelectionMerge %endl None OpBranchConditional %true %truel %falsel %truel = OpLabel %add1 = OpIAdd %uintt %a %b %add2 = OpIAdd %uintt %a %b OpBranch %endl %falsel = OpLabel %sub1 = OpISub %uintt %a %b %sub2 = OpISub %uintt %a %b OpBranch %endl %endl = OpLabel OpReturn OpFunctionEnd )"; return body; } // Returns expected error string if |opcode| produces a duplicate type // declaration. std::string GetErrorString(spv::Op opcode) { return "Duplicate non-aggregate type declarations are not allowed. Opcode: " + std::string(spvOpcodeString(opcode)); } TEST_F(ValidateTypeUnique, success) { std::string str = GetHeader() + GetBody(); CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateTypeUnique, duplicate_void) { std::string str = GetHeader() + R"( %boolt2 = OpTypeVoid )" + GetBody(); CompileSuccessfully(str.c_str()); ASSERT_EQ(kDuplicateTypeError, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(GetErrorString(spv::Op::OpTypeVoid))); } TEST_F(ValidateTypeUnique, duplicate_bool) { std::string str = GetHeader() + R"( %boolt2 = OpTypeBool )" + GetBody(); CompileSuccessfully(str.c_str()); ASSERT_EQ(kDuplicateTypeError, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(GetErrorString(spv::Op::OpTypeBool))); } TEST_F(ValidateTypeUnique, duplicate_int) { std::string str = GetHeader() + R"( %uintt2 = OpTypeInt 32 0 )" + GetBody(); CompileSuccessfully(str.c_str()); ASSERT_EQ(kDuplicateTypeError, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(GetErrorString(spv::Op::OpTypeInt))); } TEST_F(ValidateTypeUnique, duplicate_float) { std::string str = GetHeader() + R"( %floatt2 = OpTypeFloat 32 )" + GetBody(); CompileSuccessfully(str.c_str()); ASSERT_EQ(kDuplicateTypeError, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(GetErrorString(spv::Op::OpTypeFloat))); } TEST_F(ValidateTypeUnique, duplicate_vec3) { std::string str = GetHeader() + R"( %vec3t2 = OpTypeVector %floatt 3 )" + GetBody(); CompileSuccessfully(str.c_str()); ASSERT_EQ(kDuplicateTypeError, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(GetErrorString(spv::Op::OpTypeVector))); } TEST_F(ValidateTypeUnique, duplicate_mat33) { std::string str = GetHeader() + R"( %mat33t2 = OpTypeMatrix %vec3t 3 )" + GetBody(); CompileSuccessfully(str.c_str()); ASSERT_EQ(kDuplicateTypeError, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(GetErrorString(spv::Op::OpTypeMatrix))); } TEST_F(ValidateTypeUnique, duplicate_vfunc) { std::string str = GetHeader() + R"( %vfunct2 = OpTypeFunction %voidt )" + GetBody(); CompileSuccessfully(str.c_str()); ASSERT_EQ(kDuplicateTypeError, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), HasSubstr(GetErrorString(spv::Op::OpTypeFunction))); } TEST_F(ValidateTypeUnique, duplicate_pipe_storage) { std::string str = R"( OpCapability Addresses OpCapability Kernel OpCapability Linkage OpCapability Pipes OpCapability PipeStorage OpMemoryModel Physical32 OpenCL %ps = OpTypePipeStorage %ps2 = OpTypePipeStorage )"; CompileSuccessfully(str.c_str(), SPV_ENV_UNIVERSAL_1_1); ASSERT_EQ(kDuplicateTypeError, ValidateInstructions(SPV_ENV_UNIVERSAL_1_1)); EXPECT_THAT(getDiagnosticString(), HasSubstr(GetErrorString(spv::Op::OpTypePipeStorage))); } TEST_F(ValidateTypeUnique, duplicate_named_barrier) { std::string str = R"( OpCapability Addresses OpCapability Kernel OpCapability Linkage OpCapability NamedBarrier OpMemoryModel Physical32 OpenCL %nb = OpTypeNamedBarrier %nb2 = OpTypeNamedBarrier )"; CompileSuccessfully(str.c_str(), SPV_ENV_UNIVERSAL_1_1); ASSERT_EQ(kDuplicateTypeError, ValidateInstructions(SPV_ENV_UNIVERSAL_1_1)); EXPECT_THAT(getDiagnosticString(), HasSubstr(GetErrorString(spv::Op::OpTypeNamedBarrier))); } TEST_F(ValidateTypeUnique, duplicate_forward_pointer) { std::string str = R"( OpCapability Addresses OpCapability Kernel OpCapability GenericPointer OpCapability Linkage OpMemoryModel Physical32 OpenCL OpTypeForwardPointer %ptr Generic OpTypeForwardPointer %ptr2 Generic %intt = OpTypeInt 32 0 %int_struct = OpTypeStruct %intt %floatt = OpTypeFloat 32 %ptr = OpTypePointer Generic %int_struct %float_struct = OpTypeStruct %floatt %ptr2 = OpTypePointer Generic %float_struct )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateTypeUnique, duplicate_void_with_extension) { std::string str = R"( OpCapability Addresses OpCapability Kernel OpCapability Linkage OpCapability Pipes OpExtension "SPV_VALIDATOR_ignore_type_decl_unique" OpMemoryModel Physical32 OpenCL %voidt = OpTypeVoid %voidt2 = OpTypeVoid )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), Not(HasSubstr(GetErrorString(spv::Op::OpTypeVoid)))); } TEST_F(ValidateTypeUnique, DuplicatePointerTypesNoExtension) { std::string str = R"( OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %u32 = OpTypeInt 32 0 %ptr1 = OpTypePointer Input %u32 %ptr2 = OpTypePointer Input %u32 )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); } TEST_F(ValidateTypeUnique, DuplicatePointerTypesWithExtension) { std::string str = R"( OpCapability Shader OpCapability Linkage OpExtension "SPV_KHR_variable_pointers" OpMemoryModel Logical GLSL450 %u32 = OpTypeInt 32 0 %ptr1 = OpTypePointer Input %u32 %ptr2 = OpTypePointer Input %u32 )"; CompileSuccessfully(str.c_str()); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); EXPECT_THAT(getDiagnosticString(), Not(HasSubstr(GetErrorString(spv::Op::OpTypePointer)))); } TEST_F(ValidateTypeUnique, DuplicateUntypedPointer) { std::string str = R"( OpCapability Shader OpCapability Linkage OpCapability UntypedPointersKHR OpCapability WorkgroupMemoryExplicitLayoutKHR OpExtension "SPV_KHR_workgroup_memory_explicit_layout" OpExtension "SPV_KHR_untyped_pointers" OpMemoryModel Logical GLSL450 %u32 = OpTypeInt 32 0 %ptr1 = OpTypeUntypedPointerKHR Workgroup %ptr2 = OpTypeUntypedPointerKHR Workgroup )"; CompileSuccessfully(str.c_str(), SPV_ENV_UNIVERSAL_1_4); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); } TEST_F(ValidateTypeUnique, DuplicateNodePayloadArrayType) { std::string str = R"( OpCapability Shader OpCapability ShaderEnqueueAMDX OpCapability Linkage OpExtension "SPV_AMDX_shader_enqueue" OpMemoryModel Logical GLSL450 %floatt = OpTypeFloat 32 %struct = OpTypeStruct %floatt %npat1 = OpTypeNodePayloadArrayAMDX %struct %npat2 = OpTypeNodePayloadArrayAMDX %struct %void = OpTypeVoid %void_fn = OpTypeFunction %void %main = OpFunction %void None %void_fn %entry = OpLabel OpReturn OpFunctionEnd )"; CompileSuccessfully(str.c_str(), SPV_ENV_UNIVERSAL_1_4); ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_4)); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_validation_state_test.cpp000066400000000000000000000230071475742701700262330ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Basic tests for the ValidationState_t datastructure. #include #include "gmock/gmock.h" #include "source/spirv_validator_options.h" #include "test/unit_spirv.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::HasSubstr; using ValidationStateTest = spvtest::ValidateBase; const char kHeader[] = " OpCapability Shader" " OpCapability Linkage" " OpMemoryModel Logical GLSL450 "; const char kVulkanMemoryHeader[] = " OpCapability Shader" " OpCapability VulkanMemoryModelKHR" " OpExtension \"SPV_KHR_vulkan_memory_model\"" " OpMemoryModel Logical VulkanKHR "; const char kVoidFVoid[] = " %void = OpTypeVoid" " %void_f = OpTypeFunction %void" " %func = OpFunction %void None %void_f" " %label = OpLabel" " OpReturn" " OpFunctionEnd "; // k*RecursiveBody examples originally from test/opt/function_test.cpp const char* kNonRecursiveBody = R"( OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %4 = OpTypeFunction %void %float = OpTypeFloat 32 %_struct_6 = OpTypeStruct %float %float %null = OpConstantNull %_struct_6 %7 = OpTypeFunction %_struct_6 %12 = OpFunction %_struct_6 None %7 %13 = OpLabel OpReturnValue %null OpFunctionEnd %9 = OpFunction %_struct_6 None %7 %10 = OpLabel %11 = OpFunctionCall %_struct_6 %12 OpReturnValue %null OpFunctionEnd %1 = OpFunction %void Pure|Const %4 %8 = OpLabel %2 = OpFunctionCall %_struct_6 %9 OpKill OpFunctionEnd )"; const char* kDirectlyRecursiveBody = R"( OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %4 = OpTypeFunction %void %float = OpTypeFloat 32 %_struct_6 = OpTypeStruct %float %float %7 = OpTypeFunction %_struct_6 %9 = OpFunction %_struct_6 None %7 %10 = OpLabel %11 = OpFunctionCall %_struct_6 %9 OpKill OpFunctionEnd %1 = OpFunction %void Pure|Const %4 %8 = OpLabel %2 = OpFunctionCall %_struct_6 %9 OpReturn OpFunctionEnd )"; const char* kIndirectlyRecursiveBody = R"( OpEntryPoint Fragment %1 "main" OpExecutionMode %1 OriginUpperLeft %void = OpTypeVoid %4 = OpTypeFunction %void %float = OpTypeFloat 32 %_struct_6 = OpTypeStruct %float %float %null = OpConstantNull %_struct_6 %7 = OpTypeFunction %_struct_6 %9 = OpFunction %_struct_6 None %7 %10 = OpLabel %11 = OpFunctionCall %_struct_6 %12 OpReturnValue %null OpFunctionEnd %12 = OpFunction %_struct_6 None %7 %13 = OpLabel %14 = OpFunctionCall %_struct_6 %9 OpReturnValue %null OpFunctionEnd %1 = OpFunction %void Pure|Const %4 %8 = OpLabel %2 = OpFunctionCall %_struct_6 %9 OpKill OpFunctionEnd )"; // Tests that the instruction count in ValidationState is correct. TEST_F(ValidationStateTest, CheckNumInstructions) { std::string spirv = std::string(kHeader) + "%int = OpTypeInt 32 0"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()); EXPECT_EQ(size_t(4), vstate_->ordered_instructions().size()); } // Tests that the number of global variables in ValidationState is correct. TEST_F(ValidationStateTest, CheckNumGlobalVars) { std::string spirv = std::string(kHeader) + R"( %int = OpTypeInt 32 0 %_ptr_int = OpTypePointer Input %int %var_1 = OpVariable %_ptr_int Input %var_2 = OpVariable %_ptr_int Input )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()); EXPECT_EQ(unsigned(2), vstate_->num_global_vars()); } // Tests that the number of local variables in ValidationState is correct. TEST_F(ValidationStateTest, CheckNumLocalVars) { std::string spirv = std::string(kHeader) + R"( %int = OpTypeInt 32 0 %_ptr_int = OpTypePointer Function %int %voidt = OpTypeVoid %funct = OpTypeFunction %voidt %main = OpFunction %voidt None %funct %entry = OpLabel %var_1 = OpVariable %_ptr_int Function %var_2 = OpVariable %_ptr_int Function %var_3 = OpVariable %_ptr_int Function OpReturn OpFunctionEnd )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()); EXPECT_EQ(unsigned(3), vstate_->num_local_vars()); } // Tests that the "id bound" in ValidationState is correct. TEST_F(ValidationStateTest, CheckIdBound) { std::string spirv = std::string(kHeader) + R"( %int = OpTypeInt 32 0 %voidt = OpTypeVoid )"; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()); EXPECT_EQ(unsigned(3), vstate_->getIdBound()); } // Tests that the entry_points in ValidationState is correct. TEST_F(ValidationStateTest, CheckEntryPoints) { std::string spirv = std::string(kHeader) + " OpEntryPoint Vertex %func \"shader\"" + std::string(kVoidFVoid); CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()); EXPECT_EQ(size_t(1), vstate_->entry_points().size()); EXPECT_EQ(spv::Op::OpFunction, vstate_->FindDef(vstate_->entry_points()[0])->opcode()); } TEST_F(ValidationStateTest, CheckStructMemberLimitOption) { spvValidatorOptionsSetUniversalLimit( options_, spv_validator_limit_max_struct_members, 32000u); EXPECT_EQ(32000u, options_->universal_limits_.max_struct_members); } TEST_F(ValidationStateTest, CheckNumGlobalVarsLimitOption) { spvValidatorOptionsSetUniversalLimit( options_, spv_validator_limit_max_global_variables, 100u); EXPECT_EQ(100u, options_->universal_limits_.max_global_variables); } TEST_F(ValidationStateTest, CheckNumLocalVarsLimitOption) { spvValidatorOptionsSetUniversalLimit( options_, spv_validator_limit_max_local_variables, 100u); EXPECT_EQ(100u, options_->universal_limits_.max_local_variables); } TEST_F(ValidationStateTest, CheckStructDepthLimitOption) { spvValidatorOptionsSetUniversalLimit( options_, spv_validator_limit_max_struct_depth, 100u); EXPECT_EQ(100u, options_->universal_limits_.max_struct_depth); } TEST_F(ValidationStateTest, CheckSwitchBranchesLimitOption) { spvValidatorOptionsSetUniversalLimit( options_, spv_validator_limit_max_switch_branches, 100u); EXPECT_EQ(100u, options_->universal_limits_.max_switch_branches); } TEST_F(ValidationStateTest, CheckFunctionArgsLimitOption) { spvValidatorOptionsSetUniversalLimit( options_, spv_validator_limit_max_function_args, 100u); EXPECT_EQ(100u, options_->universal_limits_.max_function_args); } TEST_F(ValidationStateTest, CheckCFGDepthLimitOption) { spvValidatorOptionsSetUniversalLimit( options_, spv_validator_limit_max_control_flow_nesting_depth, 100u); EXPECT_EQ(100u, options_->universal_limits_.max_control_flow_nesting_depth); } TEST_F(ValidationStateTest, CheckAccessChainIndexesLimitOption) { spvValidatorOptionsSetUniversalLimit( options_, spv_validator_limit_max_access_chain_indexes, 100u); EXPECT_EQ(100u, options_->universal_limits_.max_access_chain_indexes); } TEST_F(ValidationStateTest, CheckNonRecursiveBodyGood) { std::string spirv = std::string(kHeader) + kNonRecursiveBody; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()); } TEST_F(ValidationStateTest, CheckVulkanNonRecursiveBodyGood) { std::string spirv = std::string(kVulkanMemoryHeader) + kNonRecursiveBody; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_1)); } TEST_F(ValidationStateTest, CheckDirectlyRecursiveBodyGood) { std::string spirv = std::string(kHeader) + kDirectlyRecursiveBody; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()); } TEST_F(ValidationStateTest, CheckVulkanDirectlyRecursiveBodyBad) { std::string spirv = std::string(kVulkanMemoryHeader) + kDirectlyRecursiveBody; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_BINARY, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-None-04634")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Entry points may not have a call graph with cycles.\n " " %1 = OpFunction %void Pure|Const %3\n")); } TEST_F(ValidationStateTest, CheckIndirectlyRecursiveBodyGood) { std::string spirv = std::string(kHeader) + kIndirectlyRecursiveBody; CompileSuccessfully(spirv); EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState()); } TEST_F(ValidationStateTest, CheckVulkanIndirectlyRecursiveBodyBad) { std::string spirv = std::string(kVulkanMemoryHeader) + kIndirectlyRecursiveBody; CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1); EXPECT_EQ(SPV_ERROR_INVALID_BINARY, ValidateAndRetrieveValidationState(SPV_ENV_VULKAN_1_1)); EXPECT_THAT(getDiagnosticString(), AnyVUID("VUID-StandaloneSpirv-None-04634")); EXPECT_THAT(getDiagnosticString(), HasSubstr("Entry points may not have a call graph with cycles.\n " " %1 = OpFunction %void Pure|Const %3\n")); } } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/val/val_version_test.cpp000066400000000000000000000772261475742701700244020ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "gmock/gmock.h" #include "test/val/val_fixtures.h" namespace spvtools { namespace val { namespace { using ::testing::HasSubstr; using ValidateVersion = spvtest::ValidateBase< std::tuple>; const std::string vulkan_spirv = R"( OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %func "func" OpExecutionMode %func OriginUpperLeft %void = OpTypeVoid %functy = OpTypeFunction %void %func = OpFunction %void None %functy %1 = OpLabel OpReturn OpFunctionEnd )"; const std::string opencl_spirv = R"( OpCapability Addresses OpCapability Kernel OpCapability Linkage OpMemoryModel Physical32 OpenCL )"; std::string version(spv_target_env env) { switch (env) { case SPV_ENV_UNIVERSAL_1_0: case SPV_ENV_VULKAN_1_0: case SPV_ENV_OPENGL_4_0: case SPV_ENV_OPENGL_4_1: case SPV_ENV_OPENGL_4_2: case SPV_ENV_OPENGL_4_3: case SPV_ENV_OPENGL_4_5: case SPV_ENV_OPENCL_1_2: case SPV_ENV_OPENCL_2_0: case SPV_ENV_OPENCL_EMBEDDED_2_0: return "1.0"; case SPV_ENV_UNIVERSAL_1_1: case SPV_ENV_OPENCL_2_1: case SPV_ENV_OPENCL_EMBEDDED_2_1: return "1.1"; case SPV_ENV_UNIVERSAL_1_2: case SPV_ENV_OPENCL_2_2: case SPV_ENV_OPENCL_EMBEDDED_2_2: return "1.2"; case SPV_ENV_UNIVERSAL_1_3: case SPV_ENV_VULKAN_1_1: return "1.3"; case SPV_ENV_UNIVERSAL_1_4: case SPV_ENV_VULKAN_1_1_SPIRV_1_4: return "1.4"; case SPV_ENV_UNIVERSAL_1_5: case SPV_ENV_VULKAN_1_2: return "1.5"; case SPV_ENV_UNIVERSAL_1_6: case SPV_ENV_VULKAN_1_3: case SPV_ENV_VULKAN_1_4: return "1.6"; default: return "0"; } } TEST_P(ValidateVersion, version) { CompileSuccessfully(std::get<2>(GetParam()), std::get<0>(GetParam())); spv_result_t res = ValidateInstructions(std::get<1>(GetParam())); if (std::get<3>(GetParam())) { ASSERT_EQ(SPV_SUCCESS, res); } else { ASSERT_EQ(SPV_ERROR_WRONG_VERSION, res); std::string msg = "Invalid SPIR-V binary version "; msg += version(std::get<0>(GetParam())); msg += " for target environment "; msg += spvTargetEnvDescription(std::get<1>(GetParam())); EXPECT_THAT(getDiagnosticString(), HasSubstr(msg)); } } // clang-format off INSTANTIATE_TEST_SUITE_P(Universal, ValidateVersion, ::testing::Values( // Binary version, Target environment std::make_tuple(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_0, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_2, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_3, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_4, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_5, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_6, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_VULKAN_1_0, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_VULKAN_1_1, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_VULKAN_1_1_SPIRV_1_4,vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_VULKAN_1_2, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_VULKAN_1_3, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_VULKAN_1_4, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_OPENGL_4_0, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_OPENGL_4_1, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_OPENGL_4_2, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_OPENGL_4_3, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_OPENGL_4_5, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_1, SPV_ENV_UNIVERSAL_1_0, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_1, SPV_ENV_UNIVERSAL_1_1, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_1, SPV_ENV_UNIVERSAL_1_2, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_1, SPV_ENV_UNIVERSAL_1_3, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_1, SPV_ENV_UNIVERSAL_1_4, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_1, SPV_ENV_UNIVERSAL_1_5, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_1, SPV_ENV_UNIVERSAL_1_6, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_1, SPV_ENV_VULKAN_1_0, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_1, SPV_ENV_VULKAN_1_1, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_1, SPV_ENV_VULKAN_1_1_SPIRV_1_4, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_1, SPV_ENV_VULKAN_1_2, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_1, SPV_ENV_VULKAN_1_3, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_1, SPV_ENV_VULKAN_1_4, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_1, SPV_ENV_OPENGL_4_0, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_1, SPV_ENV_OPENGL_4_1, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_1, SPV_ENV_OPENGL_4_2, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_1, SPV_ENV_OPENGL_4_3, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_1, SPV_ENV_OPENGL_4_5, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_2, SPV_ENV_UNIVERSAL_1_0, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_2, SPV_ENV_UNIVERSAL_1_1, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_2, SPV_ENV_UNIVERSAL_1_2, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_2, SPV_ENV_UNIVERSAL_1_3, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_2, SPV_ENV_UNIVERSAL_1_4, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_2, SPV_ENV_UNIVERSAL_1_5, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_2, SPV_ENV_UNIVERSAL_1_6, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_2, SPV_ENV_VULKAN_1_0, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_2, SPV_ENV_VULKAN_1_1, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_2, SPV_ENV_VULKAN_1_1_SPIRV_1_4, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_2, SPV_ENV_VULKAN_1_2, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_2, SPV_ENV_VULKAN_1_3, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_2, SPV_ENV_VULKAN_1_4, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_2, SPV_ENV_OPENGL_4_0, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_2, SPV_ENV_OPENGL_4_1, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_2, SPV_ENV_OPENGL_4_2, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_2, SPV_ENV_OPENGL_4_3, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_2, SPV_ENV_OPENGL_4_5, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_3, SPV_ENV_UNIVERSAL_1_0, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_3, SPV_ENV_UNIVERSAL_1_1, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_3, SPV_ENV_UNIVERSAL_1_2, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_3, SPV_ENV_UNIVERSAL_1_3, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_3, SPV_ENV_UNIVERSAL_1_4, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_3, SPV_ENV_UNIVERSAL_1_5, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_3, SPV_ENV_UNIVERSAL_1_6, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_3, SPV_ENV_VULKAN_1_0, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_3, SPV_ENV_VULKAN_1_1, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_3, SPV_ENV_VULKAN_1_1_SPIRV_1_4, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_3, SPV_ENV_VULKAN_1_2, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_3, SPV_ENV_VULKAN_1_3, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_3, SPV_ENV_VULKAN_1_4, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_3, SPV_ENV_OPENGL_4_0, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_3, SPV_ENV_OPENGL_4_1, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_3, SPV_ENV_OPENGL_4_2, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_3, SPV_ENV_OPENGL_4_3, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_3, SPV_ENV_OPENGL_4_5, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_4, SPV_ENV_UNIVERSAL_1_0, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_4, SPV_ENV_UNIVERSAL_1_1, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_4, SPV_ENV_UNIVERSAL_1_2, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_4, SPV_ENV_UNIVERSAL_1_3, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_4, SPV_ENV_UNIVERSAL_1_4, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_4, SPV_ENV_UNIVERSAL_1_5, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_4, SPV_ENV_UNIVERSAL_1_6, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_4, SPV_ENV_VULKAN_1_0, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_4, SPV_ENV_VULKAN_1_1, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_4, SPV_ENV_VULKAN_1_1_SPIRV_1_4, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_4, SPV_ENV_VULKAN_1_2, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_4, SPV_ENV_VULKAN_1_3, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_4, SPV_ENV_VULKAN_1_4, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_4, SPV_ENV_OPENGL_4_0, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_4, SPV_ENV_OPENGL_4_1, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_4, SPV_ENV_OPENGL_4_2, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_4, SPV_ENV_OPENGL_4_3, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_4, SPV_ENV_OPENGL_4_5, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_5, SPV_ENV_UNIVERSAL_1_0, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_5, SPV_ENV_UNIVERSAL_1_1, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_5, SPV_ENV_UNIVERSAL_1_2, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_5, SPV_ENV_UNIVERSAL_1_3, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_5, SPV_ENV_UNIVERSAL_1_4, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_5, SPV_ENV_UNIVERSAL_1_5, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_5, SPV_ENV_UNIVERSAL_1_6, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_5, SPV_ENV_VULKAN_1_0, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_5, SPV_ENV_VULKAN_1_1, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_5, SPV_ENV_VULKAN_1_1_SPIRV_1_4, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_5, SPV_ENV_VULKAN_1_2, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_5, SPV_ENV_VULKAN_1_3, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_5, SPV_ENV_VULKAN_1_4, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_5, SPV_ENV_OPENGL_4_0, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_5, SPV_ENV_OPENGL_4_1, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_5, SPV_ENV_OPENGL_4_2, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_5, SPV_ENV_OPENGL_4_3, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_5, SPV_ENV_OPENGL_4_5, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_6, SPV_ENV_UNIVERSAL_1_0, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_6, SPV_ENV_UNIVERSAL_1_1, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_6, SPV_ENV_UNIVERSAL_1_2, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_6, SPV_ENV_UNIVERSAL_1_3, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_6, SPV_ENV_UNIVERSAL_1_4, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_6, SPV_ENV_UNIVERSAL_1_5, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_6, SPV_ENV_UNIVERSAL_1_6, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_6, SPV_ENV_VULKAN_1_0, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_6, SPV_ENV_VULKAN_1_1, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_6, SPV_ENV_VULKAN_1_1_SPIRV_1_4, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_6, SPV_ENV_VULKAN_1_2, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_6, SPV_ENV_VULKAN_1_3, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_6, SPV_ENV_VULKAN_1_4, vulkan_spirv, true), std::make_tuple(SPV_ENV_UNIVERSAL_1_6, SPV_ENV_OPENGL_4_0, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_6, SPV_ENV_OPENGL_4_1, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_6, SPV_ENV_OPENGL_4_2, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_6, SPV_ENV_OPENGL_4_3, vulkan_spirv, false), std::make_tuple(SPV_ENV_UNIVERSAL_1_6, SPV_ENV_OPENGL_4_5, vulkan_spirv, false) ) ); INSTANTIATE_TEST_SUITE_P(Vulkan, ValidateVersion, ::testing::Values( // Binary version, Target environment std::make_tuple(SPV_ENV_VULKAN_1_0, SPV_ENV_UNIVERSAL_1_0, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_0, SPV_ENV_UNIVERSAL_1_1, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_0, SPV_ENV_UNIVERSAL_1_2, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_0, SPV_ENV_UNIVERSAL_1_3, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_0, SPV_ENV_UNIVERSAL_1_4, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_0, SPV_ENV_UNIVERSAL_1_5, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_0, SPV_ENV_UNIVERSAL_1_6, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_0, SPV_ENV_VULKAN_1_0, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_0, SPV_ENV_VULKAN_1_1, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_0, SPV_ENV_VULKAN_1_1_SPIRV_1_4, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_0, SPV_ENV_VULKAN_1_2, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_0, SPV_ENV_VULKAN_1_3, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_0, SPV_ENV_VULKAN_1_4, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_0, SPV_ENV_OPENGL_4_0, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_0, SPV_ENV_OPENGL_4_1, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_0, SPV_ENV_OPENGL_4_2, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_0, SPV_ENV_OPENGL_4_3, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_0, SPV_ENV_OPENGL_4_5, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_1, SPV_ENV_UNIVERSAL_1_0, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_1, SPV_ENV_UNIVERSAL_1_1, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_1, SPV_ENV_UNIVERSAL_1_2, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_1, SPV_ENV_UNIVERSAL_1_3, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_1, SPV_ENV_UNIVERSAL_1_4, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_1, SPV_ENV_UNIVERSAL_1_5, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_1, SPV_ENV_UNIVERSAL_1_6, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_1, SPV_ENV_VULKAN_1_0, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_1, SPV_ENV_VULKAN_1_1, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_1, SPV_ENV_VULKAN_1_1_SPIRV_1_4, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_1, SPV_ENV_VULKAN_1_2, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_1, SPV_ENV_VULKAN_1_3, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_1, SPV_ENV_VULKAN_1_4, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_1, SPV_ENV_OPENGL_4_0, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_1, SPV_ENV_OPENGL_4_1, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_1, SPV_ENV_OPENGL_4_2, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_1, SPV_ENV_OPENGL_4_3, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_1, SPV_ENV_OPENGL_4_5, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_1_SPIRV_1_4, SPV_ENV_UNIVERSAL_1_0, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_1_SPIRV_1_4, SPV_ENV_UNIVERSAL_1_1, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_1_SPIRV_1_4, SPV_ENV_UNIVERSAL_1_2, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_1_SPIRV_1_4, SPV_ENV_UNIVERSAL_1_3, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_1_SPIRV_1_4, SPV_ENV_UNIVERSAL_1_4, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_1_SPIRV_1_4, SPV_ENV_UNIVERSAL_1_5, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_1_SPIRV_1_4, SPV_ENV_UNIVERSAL_1_6, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_1_SPIRV_1_4, SPV_ENV_VULKAN_1_0, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_1_SPIRV_1_4, SPV_ENV_VULKAN_1_1, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_1_SPIRV_1_4, SPV_ENV_VULKAN_1_1_SPIRV_1_4, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_1_SPIRV_1_4, SPV_ENV_VULKAN_1_2, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_1_SPIRV_1_4, SPV_ENV_VULKAN_1_3, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_1_SPIRV_1_4, SPV_ENV_VULKAN_1_4, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_1_SPIRV_1_4, SPV_ENV_OPENGL_4_0, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_1_SPIRV_1_4, SPV_ENV_OPENGL_4_1, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_1_SPIRV_1_4, SPV_ENV_OPENGL_4_2, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_1_SPIRV_1_4, SPV_ENV_OPENGL_4_3, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_1_SPIRV_1_4, SPV_ENV_OPENGL_4_5, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_2, SPV_ENV_UNIVERSAL_1_0, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_2, SPV_ENV_UNIVERSAL_1_1, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_2, SPV_ENV_UNIVERSAL_1_2, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_2, SPV_ENV_UNIVERSAL_1_3, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_2, SPV_ENV_UNIVERSAL_1_4, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_2, SPV_ENV_UNIVERSAL_1_5, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_2, SPV_ENV_UNIVERSAL_1_6, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_2, SPV_ENV_VULKAN_1_0, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_2, SPV_ENV_VULKAN_1_1, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_2, SPV_ENV_VULKAN_1_1_SPIRV_1_4, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_2, SPV_ENV_VULKAN_1_2, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_2, SPV_ENV_VULKAN_1_3, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_2, SPV_ENV_VULKAN_1_4, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_2, SPV_ENV_OPENGL_4_0, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_2, SPV_ENV_OPENGL_4_1, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_2, SPV_ENV_OPENGL_4_2, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_2, SPV_ENV_OPENGL_4_3, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_2, SPV_ENV_OPENGL_4_5, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_3, SPV_ENV_UNIVERSAL_1_0, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_3, SPV_ENV_UNIVERSAL_1_1, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_3, SPV_ENV_UNIVERSAL_1_2, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_3, SPV_ENV_UNIVERSAL_1_3, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_3, SPV_ENV_UNIVERSAL_1_4, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_3, SPV_ENV_UNIVERSAL_1_5, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_3, SPV_ENV_UNIVERSAL_1_6, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_3, SPV_ENV_VULKAN_1_0, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_3, SPV_ENV_VULKAN_1_1, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_3, SPV_ENV_VULKAN_1_1_SPIRV_1_4, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_3, SPV_ENV_VULKAN_1_2, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_3, SPV_ENV_VULKAN_1_3, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_3, SPV_ENV_VULKAN_1_4, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_3, SPV_ENV_OPENGL_4_0, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_3, SPV_ENV_OPENGL_4_1, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_3, SPV_ENV_OPENGL_4_2, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_3, SPV_ENV_OPENGL_4_3, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_3, SPV_ENV_OPENGL_4_5, vulkan_spirv, false), // Assembling for Vulkan 1.4 produces SPIR-V 1.6 std::make_tuple(SPV_ENV_VULKAN_1_4, SPV_ENV_UNIVERSAL_1_0, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_4, SPV_ENV_UNIVERSAL_1_1, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_4, SPV_ENV_UNIVERSAL_1_2, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_4, SPV_ENV_UNIVERSAL_1_3, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_4, SPV_ENV_UNIVERSAL_1_4, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_4, SPV_ENV_UNIVERSAL_1_5, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_4, SPV_ENV_UNIVERSAL_1_6, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_4, SPV_ENV_VULKAN_1_0, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_4, SPV_ENV_VULKAN_1_1, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_4, SPV_ENV_VULKAN_1_1_SPIRV_1_4, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_4, SPV_ENV_VULKAN_1_2, vulkan_spirv, false), // Vulkan 1.3 accepts SPIR-V 1.6 std::make_tuple(SPV_ENV_VULKAN_1_4, SPV_ENV_VULKAN_1_3, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_4, SPV_ENV_VULKAN_1_4, vulkan_spirv, true), std::make_tuple(SPV_ENV_VULKAN_1_4, SPV_ENV_OPENGL_4_0, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_4, SPV_ENV_OPENGL_4_1, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_4, SPV_ENV_OPENGL_4_2, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_4, SPV_ENV_OPENGL_4_3, vulkan_spirv, false), std::make_tuple(SPV_ENV_VULKAN_1_4, SPV_ENV_OPENGL_4_5, vulkan_spirv, false) ) ); INSTANTIATE_TEST_SUITE_P(OpenCL, ValidateVersion, ::testing::Values( // Binary version, Target environment std::make_tuple(SPV_ENV_OPENCL_2_0, SPV_ENV_UNIVERSAL_1_0, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_2_0, SPV_ENV_UNIVERSAL_1_1, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_2_0, SPV_ENV_UNIVERSAL_1_2, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_2_0, SPV_ENV_UNIVERSAL_1_3, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_2_0, SPV_ENV_UNIVERSAL_1_4, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_2_0, SPV_ENV_UNIVERSAL_1_5, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_2_0, SPV_ENV_UNIVERSAL_1_6, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_2_0, SPV_ENV_OPENCL_2_0, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_2_0, SPV_ENV_OPENCL_2_1, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_2_0, SPV_ENV_OPENCL_2_2, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_2_0, SPV_ENV_OPENCL_EMBEDDED_2_0, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_2_0, SPV_ENV_OPENCL_EMBEDDED_2_1, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_2_0, SPV_ENV_OPENCL_EMBEDDED_2_2, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_2_0, SPV_ENV_OPENCL_1_2, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_2_1, SPV_ENV_UNIVERSAL_1_0, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_2_1, SPV_ENV_UNIVERSAL_1_1, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_2_1, SPV_ENV_UNIVERSAL_1_2, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_2_1, SPV_ENV_UNIVERSAL_1_3, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_2_1, SPV_ENV_UNIVERSAL_1_4, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_2_1, SPV_ENV_UNIVERSAL_1_5, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_2_1, SPV_ENV_UNIVERSAL_1_6, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_2_1, SPV_ENV_OPENCL_2_0, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_2_1, SPV_ENV_OPENCL_2_1, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_2_1, SPV_ENV_OPENCL_2_2, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_2_1, SPV_ENV_OPENCL_EMBEDDED_2_0, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_2_1, SPV_ENV_OPENCL_EMBEDDED_2_1, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_2_1, SPV_ENV_OPENCL_EMBEDDED_2_2, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_2_1, SPV_ENV_OPENCL_1_2, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_2_2, SPV_ENV_UNIVERSAL_1_0, opencl_spirv, false), std::make_tuple(SPV_ENV_OPENCL_2_2, SPV_ENV_UNIVERSAL_1_1, opencl_spirv, false), std::make_tuple(SPV_ENV_OPENCL_2_2, SPV_ENV_UNIVERSAL_1_2, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_2_2, SPV_ENV_UNIVERSAL_1_3, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_2_2, SPV_ENV_UNIVERSAL_1_4, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_2_2, SPV_ENV_UNIVERSAL_1_5, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_2_2, SPV_ENV_UNIVERSAL_1_6, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_2_2, SPV_ENV_OPENCL_2_0, opencl_spirv, false), std::make_tuple(SPV_ENV_OPENCL_2_2, SPV_ENV_OPENCL_2_1, opencl_spirv, false), std::make_tuple(SPV_ENV_OPENCL_2_2, SPV_ENV_OPENCL_2_2, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_2_2, SPV_ENV_OPENCL_EMBEDDED_2_0, opencl_spirv, false), std::make_tuple(SPV_ENV_OPENCL_2_2, SPV_ENV_OPENCL_EMBEDDED_2_1, opencl_spirv, false), std::make_tuple(SPV_ENV_OPENCL_2_2, SPV_ENV_OPENCL_EMBEDDED_2_2, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_2_2, SPV_ENV_OPENCL_1_2, opencl_spirv, false), std::make_tuple(SPV_ENV_OPENCL_1_2, SPV_ENV_UNIVERSAL_1_0, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_1_2, SPV_ENV_UNIVERSAL_1_1, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_1_2, SPV_ENV_UNIVERSAL_1_2, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_1_2, SPV_ENV_UNIVERSAL_1_3, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_1_2, SPV_ENV_UNIVERSAL_1_4, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_1_2, SPV_ENV_UNIVERSAL_1_5, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_1_2, SPV_ENV_UNIVERSAL_1_6, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_1_2, SPV_ENV_OPENCL_2_0, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_1_2, SPV_ENV_OPENCL_2_1, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_1_2, SPV_ENV_OPENCL_2_2, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_1_2, SPV_ENV_OPENCL_EMBEDDED_2_0, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_1_2, SPV_ENV_OPENCL_EMBEDDED_2_1, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_1_2, SPV_ENV_OPENCL_EMBEDDED_2_2, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_1_2, SPV_ENV_OPENCL_1_2, opencl_spirv, true) ) ); INSTANTIATE_TEST_SUITE_P(OpenCLEmbedded, ValidateVersion, ::testing::Values( // Binary version, Target environment std::make_tuple(SPV_ENV_OPENCL_EMBEDDED_2_0, SPV_ENV_UNIVERSAL_1_0, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_EMBEDDED_2_0, SPV_ENV_UNIVERSAL_1_1, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_EMBEDDED_2_0, SPV_ENV_UNIVERSAL_1_2, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_EMBEDDED_2_0, SPV_ENV_UNIVERSAL_1_3, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_EMBEDDED_2_0, SPV_ENV_OPENCL_2_0, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_EMBEDDED_2_0, SPV_ENV_OPENCL_2_1, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_EMBEDDED_2_0, SPV_ENV_OPENCL_2_2, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_EMBEDDED_2_0, SPV_ENV_OPENCL_EMBEDDED_2_0, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_EMBEDDED_2_0, SPV_ENV_OPENCL_EMBEDDED_2_1, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_EMBEDDED_2_0, SPV_ENV_OPENCL_EMBEDDED_2_2, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_EMBEDDED_2_0, SPV_ENV_OPENCL_1_2, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_EMBEDDED_2_1, SPV_ENV_UNIVERSAL_1_0, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_EMBEDDED_2_1, SPV_ENV_UNIVERSAL_1_1, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_EMBEDDED_2_1, SPV_ENV_UNIVERSAL_1_2, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_EMBEDDED_2_1, SPV_ENV_UNIVERSAL_1_3, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_EMBEDDED_2_1, SPV_ENV_OPENCL_2_0, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_EMBEDDED_2_1, SPV_ENV_OPENCL_2_1, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_EMBEDDED_2_1, SPV_ENV_OPENCL_2_2, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_EMBEDDED_2_1, SPV_ENV_OPENCL_EMBEDDED_2_0, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_EMBEDDED_2_1, SPV_ENV_OPENCL_EMBEDDED_2_1, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_EMBEDDED_2_1, SPV_ENV_OPENCL_EMBEDDED_2_2, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_EMBEDDED_2_1, SPV_ENV_OPENCL_1_2, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_EMBEDDED_2_2, SPV_ENV_UNIVERSAL_1_0, opencl_spirv, false), std::make_tuple(SPV_ENV_OPENCL_EMBEDDED_2_2, SPV_ENV_UNIVERSAL_1_1, opencl_spirv, false), std::make_tuple(SPV_ENV_OPENCL_EMBEDDED_2_2, SPV_ENV_UNIVERSAL_1_2, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_EMBEDDED_2_2, SPV_ENV_UNIVERSAL_1_3, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_EMBEDDED_2_2, SPV_ENV_OPENCL_2_0, opencl_spirv, false), std::make_tuple(SPV_ENV_OPENCL_EMBEDDED_2_2, SPV_ENV_OPENCL_2_1, opencl_spirv, false), std::make_tuple(SPV_ENV_OPENCL_EMBEDDED_2_2, SPV_ENV_OPENCL_2_2, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_EMBEDDED_2_2, SPV_ENV_OPENCL_EMBEDDED_2_0, opencl_spirv, false), std::make_tuple(SPV_ENV_OPENCL_EMBEDDED_2_2, SPV_ENV_OPENCL_EMBEDDED_2_1, opencl_spirv, false), std::make_tuple(SPV_ENV_OPENCL_EMBEDDED_2_2, SPV_ENV_OPENCL_EMBEDDED_2_2, opencl_spirv, true), std::make_tuple(SPV_ENV_OPENCL_EMBEDDED_2_2, SPV_ENV_OPENCL_1_2, opencl_spirv, false) ) ); // clang-format on } // namespace } // namespace val } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/test/wasm/000077500000000000000000000000001475742701700204575ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/test/wasm/test.js000066400000000000000000000037211475742701700217770ustar00rootroot00000000000000// Copyright (c) 2020 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. const spirvTools = require("../../out/web/spirv-tools"); const fs = require("fs"); const util = require("util"); const readFile = util.promisify(fs.readFile); const SPV_PATH = "./test/fuzzers/corpora/spv/simple.spv"; const test = async () => { const spv = await spirvTools(); // disassemble from file const buffer = await readFile(SPV_PATH); const disFileResult = spv.dis( buffer, spv.SPV_ENV_UNIVERSAL_1_3, spv.SPV_BINARY_TO_TEXT_OPTION_INDENT | spv.SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES | spv.SPV_BINARY_TO_TEXT_OPTION_COLOR ); console.log("dis from file:\n", disFileResult); // assemble const source = ` OpCapability Linkage OpCapability Shader OpMemoryModel Logical GLSL450 OpSource GLSL 450 OpDecorate %spec SpecId 1 %int = OpTypeInt 32 1 %spec = OpSpecConstant %int 0 %const = OpConstant %int 42`; const asResult = spv.as( source, spv.SPV_ENV_UNIVERSAL_1_3, spv.SPV_TEXT_TO_BINARY_OPTION_NONE ); console.log(`as returned ${asResult.byteLength} bytes`); // re-disassemble const disResult = spv.dis( asResult, spv.SPV_ENV_UNIVERSAL_1_3, spv.SPV_BINARY_TO_TEXT_OPTION_INDENT | spv.SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES | spv.SPV_BINARY_TO_TEXT_OPTION_COLOR ); console.log("dis:\n", disResult); }; test(); KhronosGroup-SPIRV-Tools-f289d04/tools/000077500000000000000000000000001475742701700176715ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/tools/CMakeLists.txt000066400000000000000000000124651475742701700224410ustar00rootroot00000000000000# Copyright (c) 2015-2016 The Khronos Group Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. if (NOT ${SPIRV_SKIP_EXECUTABLES}) add_subdirectory(lesspipe) endif() add_subdirectory(emacs) # Add a SPIR-V Tools command line tool. Signature: # add_spvtools_tool( # TARGET target_name # SRCS src_file1.cpp src_file2.cpp # LIBS lib_target1 lib_target2 # ) function(add_spvtools_tool) set(one_value_args TARGET) set(multi_value_args SRCS LIBS) cmake_parse_arguments( ARG "" "${one_value_args}" "${multi_value_args}" ${ARGN}) add_executable(${ARG_TARGET} ${ARG_SRCS}) spvtools_default_compile_options(${ARG_TARGET}) target_link_libraries(${ARG_TARGET} PRIVATE ${ARG_LIBS}) target_include_directories(${ARG_TARGET} PRIVATE ${spirv-tools_SOURCE_DIR} ${spirv-tools_BINARY_DIR} ) set_property(TARGET ${ARG_TARGET} PROPERTY FOLDER "SPIRV-Tools executables") endfunction() set(COMMON_TOOLS_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/util/flags.cpp") if (NOT ${SPIRV_SKIP_EXECUTABLES}) add_spvtools_tool(TARGET spirv-diff SRCS ${COMMON_TOOLS_SRCS} diff/diff.cpp util/cli_consumer.cpp io.cpp LIBS SPIRV-Tools-diff SPIRV-Tools-opt ${SPIRV_TOOLS_FULL_VISIBILITY}) add_spvtools_tool(TARGET spirv-dis SRCS ${COMMON_TOOLS_SRCS} dis/dis.cpp io.cpp LIBS ${SPIRV_TOOLS_FULL_VISIBILITY}) add_spvtools_tool(TARGET spirv-val SRCS ${COMMON_TOOLS_SRCS} val/val.cpp util/cli_consumer.cpp io.cpp LIBS ${SPIRV_TOOLS_FULL_VISIBILITY}) add_spvtools_tool(TARGET spirv-opt SRCS ${COMMON_TOOLS_SRCS} opt/opt.cpp util/cli_consumer.cpp io.cpp LIBS SPIRV-Tools-opt ${SPIRV_TOOLS_FULL_VISIBILITY}) if(NOT (${CMAKE_SYSTEM_NAME} STREQUAL "iOS")) # iOS does not allow std::system calls which spirv-reduce requires add_spvtools_tool(TARGET spirv-reduce SRCS ${COMMON_TOOLS_SRCS} reduce/reduce.cpp util/cli_consumer.cpp io.cpp LIBS SPIRV-Tools-reduce ${SPIRV_TOOLS_FULL_VISIBILITY}) endif() add_spvtools_tool(TARGET spirv-link SRCS ${COMMON_TOOLS_SRCS} link/linker.cpp io.cpp LIBS SPIRV-Tools-link ${SPIRV_TOOLS_FULL_VISIBILITY}) add_spvtools_tool(TARGET spirv-lint SRCS ${COMMON_TOOLS_SRCS} lint/lint.cpp util/cli_consumer.cpp io.cpp LIBS SPIRV-Tools-lint SPIRV-Tools-opt ${SPIRV_TOOLS_FULL_VISIBILITY}) add_spvtools_tool(TARGET spirv-as SRCS as/as.cpp io.cpp ${COMMON_TOOLS_SRCS} LIBS ${SPIRV_TOOLS_FULL_VISIBILITY}) target_include_directories(spirv-as PRIVATE ${spirv-tools_SOURCE_DIR} ${SPIRV_HEADER_INCLUDE_DIR}) add_spvtools_tool(TARGET spirv-cfg SRCS cfg/cfg.cpp cfg/bin_to_dot.h cfg/bin_to_dot.cpp io.cpp ${COMMON_TOOLS_SRCS} LIBS ${SPIRV_TOOLS_FULL_VISIBILITY}) target_include_directories(spirv-cfg PRIVATE ${spirv-tools_SOURCE_DIR} ${SPIRV_HEADER_INCLUDE_DIR}) set(SPIRV_INSTALL_TARGETS spirv-as spirv-dis spirv-val spirv-opt spirv-cfg spirv-link spirv-lint) if(NOT (${CMAKE_SYSTEM_NAME} STREQUAL "Android")) add_spvtools_tool(TARGET spirv-objdump SRCS objdump/objdump.cpp objdump/extract_source.cpp util/cli_consumer.cpp io.cpp ${COMMON_TOOLS_SRCS} LIBS ${SPIRV_TOOLS_FULL_VISIBILITY}) target_include_directories(spirv-objdump PRIVATE ${spirv-tools_SOURCE_DIR} ${SPIRV_HEADER_INCLUDE_DIR}) set(SPIRV_INSTALL_TARGETS ${SPIRV_INSTALL_TARGETS} spirv-objdump) endif() if(NOT (${CMAKE_SYSTEM_NAME} STREQUAL "iOS")) set(SPIRV_INSTALL_TARGETS ${SPIRV_INSTALL_TARGETS} spirv-reduce) endif() if(SPIRV_BUILD_FUZZER) add_spvtools_tool(TARGET spirv-fuzz SRCS fuzz/fuzz.cpp util/cli_consumer.cpp io.cpp LIBS SPIRV-Tools-fuzz ${SPIRV_TOOLS_FULL_VISIBILITY}) set(SPIRV_INSTALL_TARGETS ${SPIRV_INSTALL_TARGETS} spirv-fuzz) endif(SPIRV_BUILD_FUZZER) if(ENABLE_SPIRV_TOOLS_INSTALL) install(TARGETS ${SPIRV_INSTALL_TARGETS} EXPORT SPIRV-Tools-toolsTargets) export(EXPORT SPIRV-Tools-toolsTargets FILE SPIRV-Tools-toolsTargets.cmake) spvtools_config_package_dir(SPIRV-Tools-tools PACKAGE_DIR) install(EXPORT SPIRV-Tools-toolsTargets FILE SPIRV-Tools-toolsTargets.cmake DESTINATION ${PACKAGE_DIR}) file(WRITE ${CMAKE_BINARY_DIR}/SPIRV-Tools-toolsConfig.cmake "include(CMakeFindDependencyMacro)\n" "find_dependency(${SPIRV_TOOLS})\n" "include(\${CMAKE_CURRENT_LIST_DIR}/SPIRV-Tools-toolsTargets.cmake)\n" ) install(FILES ${CMAKE_BINARY_DIR}/SPIRV-Tools-toolsConfig.cmake DESTINATION ${PACKAGE_DIR}) endif(ENABLE_SPIRV_TOOLS_INSTALL) endif() KhronosGroup-SPIRV-Tools-f289d04/tools/as/000077500000000000000000000000001475742701700202745ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/tools/as/as.cpp000066400000000000000000000103471475742701700214100ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include #include "source/spirv_target_env.h" #include "spirv-tools/libspirv.h" #include "tools/io.h" #include "tools/util/flags.h" constexpr auto kDefaultTarget = SPV_ENV_UNIVERSAL_1_6; static const std::string kHelpText = R"(%s - Create a SPIR-V binary module from SPIR-V assembly text Usage: %s [options] [] The SPIR-V assembly text is read from . If no file is specified, or if the filename is "-", then the assembly text is read from standard input. The SPIR-V binary module is written to file "out.spv", unless the -o option is used. Options: -h, --help Print this help. -o Set the output filename. Use '-' to mean stdout. --version Display assembler version information. --preserve-numeric-ids Numeric IDs in the binary will have the same values as in the source. Non-numeric IDs are allocated by filling in the gaps, starting with 1 and going up. --target-env %s Use specified environment. )"; // clang-format off // flag name= default_value= required= FLAG_SHORT_bool( h, false, false); FLAG_LONG_bool( help, false, false); FLAG_LONG_bool( version, false, false); FLAG_LONG_bool( preserve_numeric_ids, false, false); FLAG_SHORT_string(o, "", false); FLAG_LONG_string( target_env, "", false); // clang-format on int main(int, const char** argv) { if (!flags::Parse(argv)) { return 1; } if (flags::h.value() || flags::help.value()) { const std::string target_env_list = spvTargetEnvList(19, 80); printf(kHelpText.c_str(), argv[0], argv[0], target_env_list.c_str()); return 0; } if (flags::version.value()) { printf("%s\n", spvSoftwareVersionDetailsString()); printf("Target: %s\n", spvTargetEnvDescription(kDefaultTarget)); return 0; } std::string outFile = flags::o.value(); if (outFile.empty()) { outFile = "out.spv"; } uint32_t options = 0; if (flags::preserve_numeric_ids.value()) { options |= SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS; } if (flags::positional_arguments.size() != 1) { fprintf(stderr, "error: exactly one input file must be specified.\n"); return 1; } std::string inFile = flags::positional_arguments[0]; std::vector contents; if (!ReadTextFile(inFile.c_str(), &contents)) return 1; // Can only deduce target after the file has been read spv_target_env target_env; if (flags::target_env.value().empty()) { if (!spvReadEnvironmentFromText(contents, &target_env)) { // Revert to default version since deduction failed target_env = kDefaultTarget; } } else if (!spvParseTargetEnv(flags::target_env.value().c_str(), &target_env)) { fprintf(stderr, "error: Unrecognized target env: %s\n", flags::target_env.value().c_str()); return 1; } spv_binary binary; spv_diagnostic diagnostic = nullptr; spv_context context = spvContextCreate(target_env); spv_result_t error = spvTextToBinaryWithOptions( context, contents.data(), contents.size(), options, &binary, &diagnostic); spvContextDestroy(context); if (error) { spvDiagnosticPrint(diagnostic); spvDiagnosticDestroy(diagnostic); return error; } if (!WriteFile(outFile.c_str(), "wb", binary->code, binary->wordCount)) { spvBinaryDestroy(binary); return 1; } spvBinaryDestroy(binary); return 0; } KhronosGroup-SPIRV-Tools-f289d04/tools/cfg/000077500000000000000000000000001475742701700204305ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/tools/cfg/bin_to_dot.cpp000066400000000000000000000135661475742701700232670ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "tools/cfg/bin_to_dot.h" #include #include #include #include #include "source/assembly_grammar.h" #include "source/name_mapper.h" namespace { const char* kMergeStyle = "style=dashed"; const char* kContinueStyle = "style=dotted"; // A DotConverter can be used to dump the GraphViz "dot" graph for // a SPIR-V module. class DotConverter { public: DotConverter(spvtools::NameMapper name_mapper, std::iostream* out) : name_mapper_(std::move(name_mapper)), out_(*out) {} // Emits the graph preamble. void Begin() const { out_ << "digraph {\n"; // Emit a simple legend out_ << "legend_merge_src [shape=plaintext, label=\"\"];\n" << "legend_merge_dest [shape=plaintext, label=\"\"];\n" << "legend_merge_src -> legend_merge_dest [label=\" merge\"," << kMergeStyle << "];\n" << "legend_continue_src [shape=plaintext, label=\"\"];\n" << "legend_continue_dest [shape=plaintext, label=\"\"];\n" << "legend_continue_src -> legend_continue_dest [label=\" continue\"," << kContinueStyle << "];\n"; } // Emits the graph postamble. void End() const { out_ << "}\n"; } // Emits the Dot commands for the given instruction. spv_result_t HandleInstruction(const spv_parsed_instruction_t& inst); private: // Ends processing for the current block, emitting its dot code. void FlushBlock(const std::vector& successors); // The ID of the current function, or 0 if outside of a function. uint32_t current_function_id_ = 0; // The ID of the current basic block, or 0 if outside of a block. uint32_t current_block_id_ = 0; // Have we completed processing for the entry block to this function? bool seen_function_entry_block_ = false; // The Id of the merge block for this block if it exists, or 0 otherwise. uint32_t merge_ = 0; // The Id of the continue target block for this block if it exists, or 0 // otherwise. uint32_t continue_target_ = 0; // An object for mapping Ids to names. spvtools::NameMapper name_mapper_; // The output stream. std::ostream& out_; }; spv_result_t DotConverter::HandleInstruction( const spv_parsed_instruction_t& inst) { switch (spv::Op(inst.opcode)) { case spv::Op::OpFunction: current_function_id_ = inst.result_id; seen_function_entry_block_ = false; break; case spv::Op::OpFunctionEnd: current_function_id_ = 0; break; case spv::Op::OpLabel: current_block_id_ = inst.result_id; break; case spv::Op::OpBranch: FlushBlock({inst.words[1]}); break; case spv::Op::OpBranchConditional: FlushBlock({inst.words[2], inst.words[3]}); break; case spv::Op::OpSwitch: { std::vector successors{inst.words[2]}; for (size_t i = 3; i < inst.num_operands; i += 2) { successors.push_back(inst.words[inst.operands[i].offset]); } FlushBlock(successors); } break; case spv::Op::OpKill: case spv::Op::OpReturn: case spv::Op::OpUnreachable: case spv::Op::OpReturnValue: FlushBlock({}); break; case spv::Op::OpLoopMerge: merge_ = inst.words[1]; continue_target_ = inst.words[2]; break; case spv::Op::OpSelectionMerge: merge_ = inst.words[1]; break; default: break; } return SPV_SUCCESS; } void DotConverter::FlushBlock(const std::vector& successors) { out_ << current_block_id_; if (!seen_function_entry_block_) { out_ << " [label=\"" << name_mapper_(current_block_id_) << "\nFn " << name_mapper_(current_function_id_) << " entry\", shape=box];\n"; } else { out_ << " [label=\"" << name_mapper_(current_block_id_) << "\"];\n"; } for (auto successor : successors) { out_ << current_block_id_ << " -> " << successor << ";\n"; } if (merge_) { out_ << current_block_id_ << " -> " << merge_ << " [" << kMergeStyle << "];\n"; } if (continue_target_) { out_ << current_block_id_ << " -> " << continue_target_ << " [" << kContinueStyle << "];\n"; } // Reset the book-keeping for a block. seen_function_entry_block_ = true; merge_ = 0; continue_target_ = 0; } spv_result_t HandleInstruction( void* user_data, const spv_parsed_instruction_t* parsed_instruction) { assert(user_data); auto converter = static_cast(user_data); return converter->HandleInstruction(*parsed_instruction); } } // anonymous namespace spv_result_t BinaryToDot(const spv_const_context context, const uint32_t* words, size_t num_words, std::iostream* out, spv_diagnostic* diagnostic) { // Invalid arguments return error codes, but don't necessarily generate // diagnostics. These are programmer errors, not user errors. if (!diagnostic) return SPV_ERROR_INVALID_DIAGNOSTIC; const spvtools::AssemblyGrammar grammar(context); if (!grammar.isValid()) return SPV_ERROR_INVALID_TABLE; spvtools::FriendlyNameMapper friendly_mapper(context, words, num_words); DotConverter converter(friendly_mapper.GetNameMapper(), out); converter.Begin(); if (auto error = spvBinaryParse(context, &converter, words, num_words, nullptr, HandleInstruction, diagnostic)) { return error; } converter.End(); return SPV_SUCCESS; } KhronosGroup-SPIRV-Tools-f289d04/tools/cfg/bin_to_dot.h000066400000000000000000000020421475742701700227170ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef TOOLS_CFG_BIN_TO_DOT_H_ #define TOOLS_CFG_BIN_TO_DOT_H_ #include #include "spirv-tools/libspirv.h" // Dumps the control flow graph for the given module to the output stream. // Returns SPV_SUCCESS on success. spv_result_t BinaryToDot(const spv_const_context context, const uint32_t* words, size_t num_words, std::iostream* out, spv_diagnostic* diagnostic); #endif // TOOLS_CFG_BIN_TO_DOT_H_ KhronosGroup-SPIRV-Tools-f289d04/tools/cfg/cfg.cpp000066400000000000000000000060741475742701700217020ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include #include #include "spirv-tools/libspirv.h" #include "tools/cfg/bin_to_dot.h" #include "tools/io.h" #include "tools/util/flags.h" static const auto kDefaultEnvironment = SPV_ENV_UNIVERSAL_1_6; static const std::string kHelpText = R"(%s - Show the control flow graph in GraphiViz "dot" form. EXPERIMENTAL Usage: %s [options] [] The SPIR-V binary is read from . If no file is specified, or if the filename is "-", then the binary is read from standard input. Options: -h, --help Print this help. --version Display version information. -o Set the output filename. Output goes to standard output if this option is not specified, or if the filename is "-". )"; // clang-format off FLAG_SHORT_bool( h, /* default_value= */ false, /* required= */ false); FLAG_LONG_bool( help, /* default_value= */ false, /* required= */false); FLAG_LONG_bool( version, /* default_value= */ false, /* required= */ false); FLAG_SHORT_string(o, /* default_value= */ "", /* required= */ false); // clang-format on int main(int, const char** argv) { if (!flags::Parse(argv)) { return 1; } if (flags::h.value() || flags::help.value()) { printf(kHelpText.c_str(), argv[0], argv[0]); return 0; } if (flags::version.value()) { printf("%s EXPERIMENTAL\n", spvSoftwareVersionDetailsString()); printf("Target: %s\n", spvTargetEnvDescription(kDefaultEnvironment)); return 0; } if (flags::positional_arguments.size() != 1) { fprintf(stderr, "error: exactly one input file must be specified.\n"); return 1; } std::string inFile = flags::positional_arguments[0]; std::string outFile = flags::o.value(); // Read the input binary. std::vector contents; if (!ReadBinaryFile(inFile.c_str(), &contents)) return 1; spv_context context = spvContextCreate(kDefaultEnvironment); spv_diagnostic diagnostic = nullptr; std::stringstream ss; auto error = BinaryToDot(context, contents.data(), contents.size(), &ss, &diagnostic); if (error) { spvDiagnosticPrint(diagnostic); spvDiagnosticDestroy(diagnostic); spvContextDestroy(context); return error; } std::string str = ss.str(); WriteFile(outFile.empty() ? nullptr : outFile.c_str(), "w", str.data(), str.size()); spvDiagnosticDestroy(diagnostic); spvContextDestroy(context); return 0; } KhronosGroup-SPIRV-Tools-f289d04/tools/diff/000077500000000000000000000000001475742701700206015ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/tools/diff/diff.cpp000066400000000000000000000133631475742701700222230ustar00rootroot00000000000000// Copyright (c) 2022 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__)) #include #endif #include "source/diff/diff.h" #include "source/opt/build_module.h" #include "source/opt/ir_context.h" #include "spirv-tools/libspirv.hpp" #include "tools/io.h" #include "tools/util/cli_consumer.h" #include "tools/util/flags.h" namespace { constexpr auto kDefaultEnvironment = SPV_ENV_UNIVERSAL_1_6; constexpr bool kColorIsPossible = #if SPIRV_COLOR_TERMINAL true; #else false; #endif void print_usage(const char* argv0) { printf(R"(%s - Compare two SPIR-V files Usage: %s The SPIR-V binary is read from and . If either file ends in .spvasm, the SPIR-V is read as text and disassembled. The contents of the SPIR-V modules are analyzed and a diff is produced showing a logical transformation from src to dst, in src's id-space. -h, --help Print this help. --version Display diff version information. --color Force color output. The default when printing to a terminal. If both --color and --no-color is present, --no-color prevails. --no-color Don't print in color. The default when output goes to something other than a terminal (e.g. a pipe, or a shell redirection). If both --color and --no-color is present, --no-color prevails. --no-indent Don't indent instructions. --no-header Don't output the header as leading comments. --with-id-map Also output the mapping between src and dst outputs. --ignore-set-binding Don't use set/binding decorations for variable matching. --ignore-location Don't use location decorations for variable matching. )", argv0, argv0); } bool is_assembly(const char* path) { const char* suffix = strrchr(path, '.'); if (suffix == nullptr) { return false; } return strcmp(suffix, ".spvasm") == 0; } std::unique_ptr load_module(const char* path) { if (is_assembly(path)) { std::vector contents; if (!ReadTextFile(path, &contents)) return {}; return spvtools::BuildModule( kDefaultEnvironment, spvtools::utils::CLIMessageConsumer, std::string(contents.begin(), contents.end()), spvtools::SpirvTools::kDefaultAssembleOption | SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); } std::vector contents; if (!ReadBinaryFile(path, &contents)) return {}; return spvtools::BuildModule(kDefaultEnvironment, spvtools::utils::CLIMessageConsumer, contents.data(), contents.size()); } } // namespace // clang-format off FLAG_SHORT_bool(h, /* default_value= */ false, /* required= */ false); FLAG_LONG_bool( help, /* default_value= */ false, /* required= */false); FLAG_LONG_bool( version, /* default_value= */ false, /* required= */ false); FLAG_LONG_bool( color, /* default_value= */ false, /* required= */ false); FLAG_LONG_bool( no_color, /* default_value= */ false, /* required= */ false); FLAG_LONG_bool( no_indent, /* default_value= */ false, /* required= */ false); FLAG_LONG_bool( no_header, /* default_value= */ false, /* required= */ false); FLAG_LONG_bool( with_id_map, /* default_value= */ false, /* required= */ false); FLAG_LONG_bool( ignore_set_binding, /* default_value= */ false, /* required= */ false); FLAG_LONG_bool( ignore_location, /* default_value= */ false, /* required= */ false); // clang-format on int main(int, const char* argv[]) { if (!flags::Parse(argv)) { return 1; } if (flags::h.value() || flags::help.value()) { print_usage(argv[0]); return 0; } if (flags::version.value()) { printf("%s\n", spvSoftwareVersionDetailsString()); printf("Target: %s\n", spvTargetEnvDescription(kDefaultEnvironment)); return 0; } if (flags::positional_arguments.size() != 2) { fprintf(stderr, "error: two input files required.\n"); return 1; } #if defined(_POSIX_VERSION) const bool output_is_tty = isatty(fileno(stdout)); #else const bool output_is_tty = true; #endif const std::string& src_file = flags::positional_arguments[0]; const std::string& dst_file = flags::positional_arguments[1]; spvtools::diff::Options options; options.color_output = (output_is_tty || flags::color.value()) && !flags::no_color.value() && kColorIsPossible; options.indent = !flags::no_indent.value(); options.no_header = flags::no_header.value(); options.dump_id_map = flags::with_id_map.value(); options.ignore_set_binding = flags::ignore_set_binding.value(); options.ignore_location = flags::ignore_location.value(); std::unique_ptr src = load_module(src_file.c_str()); std::unique_ptr dst = load_module(dst_file.c_str()); if (!src) { fprintf(stderr, "error: Loading src file\n"); } if (!dst) { fprintf(stderr, "error: Loading dst file\n"); } if (!src || !dst) { return 1; } spvtools::diff::Diff(src.get(), dst.get(), std::cout, options); return 0; } KhronosGroup-SPIRV-Tools-f289d04/tools/dis/000077500000000000000000000000001475742701700204505ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/tools/dis/dis.cpp000066400000000000000000000156421475742701700217430ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__)) #include // Need fileno #include #endif #include #include #include #include #include "spirv-tools/libspirv.h" #include "tools/io.h" #include "tools/util/flags.h" static const std::string kHelpText = R"(%s - Disassemble a SPIR-V binary module Usage: %s [options] [] The SPIR-V binary is read from . If no file is specified, or if the filename is "-", then the binary is read from standard input. A text-based hex stream is also accepted as binary input, which should either consist of 32-bit words or 8-bit bytes. The 0x or x prefix is optional, but should be consistently present in the stream. Options: -h, --help Print this help. --version Display disassembler version information. -o Set the output filename. Output goes to standard output if this option is not specified, or if the filename is "-". --color Force color output. The default when printing to a terminal. Overrides a previous --no-color option. --no-color Don't print in color. Overrides a previous --color option. The default when output goes to something other than a terminal (e.g. a file, a pipe, or a shell redirection). --no-indent Don't indent instructions. --no-header Don't output the header as leading comments. --raw-id Show raw Id values instead of friendly names. --nested-indent Indentation is adjusted to indicate nesting in structured control flow. --reorder-blocks Reorder blocks to match the structured control flow of SPIR-V. With this option, the order of instructions will no longer match the input binary, but the result will be more readable. --offsets Show byte offsets for each instruction. --comment Add comments to make reading easier )"; // clang-format off FLAG_SHORT_bool (h, /* default_value= */ false, /* required= */ false); FLAG_SHORT_string(o, /* default_value= */ "-", /* required= */ false); FLAG_LONG_bool (help, /* default_value= */ false, /* required= */false); FLAG_LONG_bool (version, /* default_value= */ false, /* required= */ false); FLAG_LONG_bool (color, /* default_value= */ false, /* required= */ false); FLAG_LONG_bool (no_color, /* default_value= */ false, /* required= */ false); FLAG_LONG_bool (no_indent, /* default_value= */ false, /* required= */ false); FLAG_LONG_bool (no_header, /* default_value= */ false, /* required= */ false); FLAG_LONG_bool (raw_id, /* default_value= */ false, /* required= */ false); FLAG_LONG_bool (nested_indent, /* default_value= */ false, /* required= */ false); FLAG_LONG_bool (reorder_blocks, /* default_value= */ false, /* required= */ false); FLAG_LONG_bool (offsets, /* default_value= */ false, /* required= */ false); FLAG_LONG_bool (comment, /* default_value= */ false, /* required= */ false); // clang-format on static const auto kDefaultEnvironment = SPV_ENV_UNIVERSAL_1_5; int main(int, const char** argv) { if (!flags::Parse(argv)) { return 1; } if (flags::h.value() || flags::help.value()) { printf(kHelpText.c_str(), argv[0], argv[0]); return 0; } if (flags::version.value()) { printf("%s\n", spvSoftwareVersionDetailsString()); printf("Target: %s\n", spvTargetEnvDescription(kDefaultEnvironment)); return 0; } if (flags::positional_arguments.size() > 1) { fprintf(stderr, "error: more than one input file specified.\n"); return 1; } const std::string inFile = flags::positional_arguments.size() == 0 ? "-" : flags::positional_arguments[0]; const std::string outFile = flags::o.value(); bool color_is_possible = #if SPIRV_COLOR_TERMINAL true; #else false; #endif uint32_t options = SPV_BINARY_TO_TEXT_OPTION_NONE; if (!flags::no_indent.value()) options |= SPV_BINARY_TO_TEXT_OPTION_INDENT; if (flags::offsets.value()) options |= SPV_BINARY_TO_TEXT_OPTION_SHOW_BYTE_OFFSET; if (flags::no_header.value()) options |= SPV_BINARY_TO_TEXT_OPTION_NO_HEADER; if (!flags::raw_id.value()) options |= SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES; if (flags::nested_indent.value()) options |= SPV_BINARY_TO_TEXT_OPTION_NESTED_INDENT; if (flags::reorder_blocks.value()) options |= SPV_BINARY_TO_TEXT_OPTION_REORDER_BLOCKS; if (flags::comment.value()) options |= SPV_BINARY_TO_TEXT_OPTION_COMMENT; if (flags::o.value() == "-") { // Print to standard output. options |= SPV_BINARY_TO_TEXT_OPTION_PRINT; if (color_is_possible && !flags::no_color.value()) { bool output_is_tty = true; #if defined(_POSIX_VERSION) output_is_tty = isatty(fileno(stdout)); #endif if (output_is_tty || flags::color.value()) { options |= SPV_BINARY_TO_TEXT_OPTION_COLOR; } } } // Read the input binary. std::vector contents; if (!ReadBinaryFile(inFile.c_str(), &contents)) return 1; // If printing to standard output, then spvBinaryToText should // do the printing. In particular, colour printing on Windows is // controlled by modifying console objects synchronously while // outputting to the stream rather than by injecting escape codes // into the output stream. // If the printing option is off, then save the text in memory, so // it can be emitted later in this function. const bool print_to_stdout = SPV_BINARY_TO_TEXT_OPTION_PRINT & options; spv_text text = nullptr; spv_text* textOrNull = print_to_stdout ? nullptr : &text; spv_diagnostic diagnostic = nullptr; spv_context context = spvContextCreate(kDefaultEnvironment); spv_result_t error = spvBinaryToText(context, contents.data(), contents.size(), options, textOrNull, &diagnostic); spvContextDestroy(context); if (error) { spvDiagnosticPrint(diagnostic); spvDiagnosticDestroy(diagnostic); return error; } if (!print_to_stdout) { if (!WriteFile(outFile.c_str(), "w", text->str, text->length)) { spvTextDestroy(text); return 1; } } spvTextDestroy(text); return 0; } KhronosGroup-SPIRV-Tools-f289d04/tools/emacs/000077500000000000000000000000001475742701700207615ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/tools/emacs/50spirv-tools.el000066400000000000000000000031661475742701700237570ustar00rootroot00000000000000;; Copyright (c) 2016 LunarG Inc. ;; ;; Licensed under the Apache License, Version 2.0 (the "License"); ;; you may not use this file except in compliance with the License. ;; You may obtain a copy of the License at ;; ;; http://www.apache.org/licenses/LICENSE-2.0 ;; ;; Unless required by applicable law or agreed to in writing, software ;; distributed under the License is distributed on an "AS IS" BASIS, ;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ;; See the License for the specific language governing permissions and ;; limitations under the License. ;; Upon loading a file with the .spv extension into emacs, the file ;; will be disassembled using spirv-dis, and the result colorized with ;; asm-mode in emacs. The file may be edited within the constraints ;; of validity, and when re-saved will be re-assembled using spirv-as. ;; Note that symbol IDs are not preserved through a load/edit/save operation. ;; This may change if the ability is added to spirv-as. ;; It is required that those tools be in your PATH. If that is not the case ;; when starting emacs, the path can be modified as in this example: ;; (setenv "PATH" (concat (getenv "PATH") ":/path/to/spirv/tools")) ;; ;; See https://github.com/KhronosGroup/SPIRV-Tools/issues/359 (require 'jka-compr) (require 'asm-mode) (add-to-list 'jka-compr-compression-info-list '["\\.spv\\'" "Assembling SPIRV" "spirv-as" ("-o" "-") "Disassembling SPIRV" "spirv-dis" ("--no-color" "--raw-id") t nil "\003\002\043\007"]) (add-to-list 'auto-mode-alist '("\\.spv\\'" . asm-mode)) (jka-compr-update) KhronosGroup-SPIRV-Tools-f289d04/tools/emacs/CMakeLists.txt000066400000000000000000000041671475742701700235310ustar00rootroot00000000000000# Copyright (c) 2016 LunarG Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Install a script for use with the auto-compression feature of emacs(1). # Upon loading a file with the .spv extension, the file will be disassembled # using spirv-dis, and the result colorized with asm-mode in emacs. The file # may be edited within the constraints of validity, and when re-saved will be # re-assembled using spirv-as. # It is required that those tools be in your PATH. If that is not the case # when starting emacs, the path can be modified as in this example: # (setenv "PATH" (concat (getenv "PATH") ":/path/to/spirv/tools")) # # See https://github.com/KhronosGroup/SPIRV-Tools/issues/359 # This is an absolute directory, and ignores CMAKE_INSTALL_PREFIX, or # it will not be found by emacs upon startup. It is only installed if # both of the following are true: # 1. SPIRV_TOOLS_INSTALL_EMACS_HELPERS is defined # 2. The directory /etc/emacs/site-start.d already exists at the time of # cmake invocation (not at the time of make install). This is # typically true if emacs is installed on the system. # Note that symbol IDs are not preserved through a load/edit/save operation. # This may change if the ability is added to spirv-as. option(SPIRV_TOOLS_INSTALL_EMACS_HELPERS "Install Emacs helper to disassemble/assemble SPIR-V binaries on file load/save." ${SPIRV_TOOLS_INSTALL_EMACS_HELPERS}) if (${SPIRV_TOOLS_INSTALL_EMACS_HELPERS}) if(EXISTS /etc/emacs/site-start.d) if(ENABLE_SPIRV_TOOLS_INSTALL) install(FILES 50spirv-tools.el DESTINATION /etc/emacs/site-start.d) endif(ENABLE_SPIRV_TOOLS_INSTALL) endif() endif() KhronosGroup-SPIRV-Tools-f289d04/tools/fuzz/000077500000000000000000000000001475742701700206675ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/tools/fuzz/fuzz.cpp000066400000000000000000001056631475742701700224040ustar00rootroot00000000000000// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include #include #include #include #include #include "source/fuzz/force_render_red.h" #include "source/fuzz/fuzzer.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/protobufs/spirvfuzz_protobufs.h" #include "source/fuzz/pseudo_random_generator.h" #include "source/fuzz/replayer.h" #include "source/fuzz/shrinker.h" #include "source/opt/build_module.h" #include "source/opt/ir_context.h" #include "source/opt/log.h" #include "source/spirv_fuzzer_options.h" #include "source/util/make_unique.h" #include "source/util/string_utils.h" #include "tools/io.h" #include "tools/util/cli_consumer.h" namespace { enum class FuzzingTarget { kSpirv, kWgsl }; // Execute a command using the shell. // Returns true if and only if the command's exit status was 0. bool ExecuteCommand(const std::string& command) { errno = 0; int status = std::system(command.c_str()); assert(errno == 0 && "failed to execute command"); // The result returned by 'system' is implementation-defined, but is // usually the case that the returned value is 0 when the command's exit // code was 0. We are assuming that here, and that's all we depend on. return status == 0; } // Status and actions to perform after parsing command-line arguments. enum class FuzzActions { FORCE_RENDER_RED, // Turn the shader into a form such that it is guaranteed // to render a red image. FUZZ, // Run the fuzzer to apply transformations in a randomized fashion. REPLAY, // Replay an existing sequence of transformations. SHRINK, // Shrink an existing sequence of transformations with respect to an // interestingness function. STOP // Do nothing. }; struct FuzzStatus { FuzzActions action; int code; }; void PrintUsage(const char* program) { // NOTE: Please maintain flags in lexicographical order. printf( R"(%s - Fuzzes an equivalent SPIR-V binary based on a given binary. USAGE: %s [options] -o \ --donors= USAGE: %s [options] -o \ --shrink= -- [args...] The SPIR-V binary is read from . If is also present, facts about the SPIR-V binary are read from this file. The transformed SPIR-V binary is written to . Human-readable and binary representations of the transformations that were applied are written to and , respectively. When passing --shrink= an must also be provided; this is the path to a script that returns 0 if and only if a given SPIR-V binary is interesting. The SPIR-V binary will be passed to the script as an argument after any other provided arguments [args...]. The "--" characters are optional but denote that all arguments that follow are positional arguments and thus will be forwarded to the interestingness script, and not parsed by %s. NOTE: The fuzzer is a work in progress. Options (in lexicographical order): -h, --help Print this help. --donors= File specifying a series of donor files, one per line. Must be provided if the tool is invoked in fuzzing mode; incompatible with replay and shrink modes. The file should be empty if no donors are to be used. --enable-all-passes By default, spirv-fuzz follows the philosophy of "swarm testing" (Groce et al., 2012): only a subset of fuzzer passes are enabled on any given fuzzer run, with the subset being chosen randomly. This flag instead forces *all* fuzzer passes to be enabled. When running spirv-fuzz many times this is likely to produce *less* diverse fuzzed modules than when swarm testing is used. The purpose of the flag is to allow that hypothesis to be tested. --force-render-red Transforms the input shader into a shader that writes red to the output buffer, and then captures the original shader as the body of a conditional with a dynamically false guard. Exploits input facts to make the guard non-obviously false. This option is a helper for massaging crash-inducing tests into a runnable format; it does not perform any fuzzing. --fuzzer-pass-validation Run the validator after applying each fuzzer pass during fuzzing. Aborts fuzzing early if an invalid binary is created. Useful for debugging spirv-fuzz. --repeated-pass-strategy= Available strategies are: - looped (the default): a sequence of fuzzer passes is chosen at the start of fuzzing, via randomly choosing enabled passes, and augmenting these choices with fuzzer passes that it is recommended to run subsequently. Fuzzing then involves repeatedly applying this fixed sequence of passes. - random: each time a fuzzer pass is requested, this strategy either provides one at random from the set of enabled passes, or provides a pass that has been recommended based on a pass that was used previously. - simple: each time a fuzzer pass is requested, one is provided at random from the set of enabled passes. --fuzzing-target= This option will adjust probabilities of applying certain transformations s.t. the module always remains valid according to the semantics of some fuzzing target. Available targets: - spir-v - module is valid according to the SPIR-V spec. - wgsl - module is valid according to the WGSL spec. --replay File from which to read a sequence of transformations to replay (instead of fuzzing) --replay-range= Signed 32-bit integer. If set to a positive value N, only the first N transformations will be applied during replay. If set to a negative value -N, all but the final N transformations will be applied during replay. If set to 0 (the default), all transformations will be applied during replay. Ignored unless --replay is used. --replay-validation Run the validator after applying each transformation during replay (including the replay that occurs during shrinking). Aborts if an invalid binary is created. Useful for debugging spirv-fuzz. --seed= Unsigned 32-bit integer seed to control random number generation. --shrink= File from which to read a sequence of transformations to shrink (instead of fuzzing) --shrinker-step-limit= Unsigned 32-bit integer specifying maximum number of steps the shrinker will take before giving up. Ignored unless --shrink is used. --shrinker-temp-file-prefix= Specifies a temporary file prefix that will be used to output temporary shader files during shrinking. A number and .spv extension will be added. The default is "temp_", which will cause files like "temp_0001.spv" to be output to the current directory. Ignored unless --shrink is used. --version Display fuzzer version information. Supported validator options are as follows. See `spirv-val --help` for details. --before-hlsl-legalization --relax-block-layout --relax-logical-pointer --relax-struct-store --scalar-block-layout --skip-block-layout )", program, program, program, program); } // Message consumer for this tool. Used to emit diagnostics during // initialization and setup. Note that |source| and |position| are irrelevant // here because we are still not processing a SPIR-V input file. void FuzzDiagnostic(spv_message_level_t level, const char* /*source*/, const spv_position_t& /*position*/, const char* message) { if (level == SPV_MSG_ERROR) { fprintf(stderr, "error: "); } fprintf(stderr, "%s\n", message); } FuzzStatus ParseFlags( int argc, const char** argv, std::string* in_binary_file, std::string* out_binary_file, std::string* donors_file, std::string* replay_transformations_file, std::vector* interestingness_test, std::string* shrink_transformations_file, std::string* shrink_temp_file_prefix, spvtools::fuzz::RepeatedPassStrategy* repeated_pass_strategy, FuzzingTarget* fuzzing_target, spvtools::FuzzerOptions* fuzzer_options, spvtools::ValidatorOptions* validator_options) { uint32_t positional_arg_index = 0; bool only_positional_arguments_remain = false; bool force_render_red = false; *repeated_pass_strategy = spvtools::fuzz::RepeatedPassStrategy::kLoopedWithRecommendations; for (int argi = 1; argi < argc; ++argi) { const char* cur_arg = argv[argi]; if ('-' == cur_arg[0] && !only_positional_arguments_remain) { if (0 == strcmp(cur_arg, "--version")) { spvtools::Logf(FuzzDiagnostic, SPV_MSG_INFO, nullptr, {}, "%s\n", spvSoftwareVersionDetailsString()); return {FuzzActions::STOP, 0}; } else if (0 == strcmp(cur_arg, "--help") || 0 == strcmp(cur_arg, "-h")) { PrintUsage(argv[0]); return {FuzzActions::STOP, 0}; } else if (0 == strcmp(cur_arg, "-o")) { if (out_binary_file->empty() && argi + 1 < argc) { *out_binary_file = std::string(argv[++argi]); } else { PrintUsage(argv[0]); return {FuzzActions::STOP, 1}; } } else if (0 == strncmp(cur_arg, "--donors=", sizeof("--donors=") - 1)) { const auto split_flag = spvtools::utils::SplitFlagArgs(cur_arg); *donors_file = std::string(split_flag.second); } else if (0 == strncmp(cur_arg, "--enable-all-passes", sizeof("--enable-all-passes") - 1)) { fuzzer_options->enable_all_passes(); } else if (0 == strncmp(cur_arg, "--force-render-red", sizeof("--force-render-red") - 1)) { force_render_red = true; } else if (0 == strncmp(cur_arg, "--fuzzer-pass-validation", sizeof("--fuzzer-pass-validation") - 1)) { fuzzer_options->enable_fuzzer_pass_validation(); } else if (0 == strncmp(cur_arg, "--replay=", sizeof("--replay=") - 1)) { const auto split_flag = spvtools::utils::SplitFlagArgs(cur_arg); *replay_transformations_file = std::string(split_flag.second); } else if (0 == strncmp(cur_arg, "--repeated-pass-strategy=", sizeof("--repeated-pass-strategy=") - 1)) { std::string strategy = spvtools::utils::SplitFlagArgs(cur_arg).second; if (strategy == "looped") { *repeated_pass_strategy = spvtools::fuzz::RepeatedPassStrategy::kLoopedWithRecommendations; } else if (strategy == "random") { *repeated_pass_strategy = spvtools::fuzz::RepeatedPassStrategy::kRandomWithRecommendations; } else if (strategy == "simple") { *repeated_pass_strategy = spvtools::fuzz::RepeatedPassStrategy::kSimple; } else { std::stringstream ss; ss << "Unknown repeated pass strategy '" << strategy << "'" << std::endl; ss << "Valid options are 'looped', 'random' and 'simple'."; spvtools::Error(FuzzDiagnostic, nullptr, {}, ss.str().c_str()); return {FuzzActions::STOP, 1}; } } else if (0 == strncmp(cur_arg, "--fuzzing-target=", sizeof("--fuzzing-target=") - 1)) { std::string target = spvtools::utils::SplitFlagArgs(cur_arg).second; if (target == "spir-v") { *fuzzing_target = FuzzingTarget::kSpirv; } else if (target == "wgsl") { *fuzzing_target = FuzzingTarget::kWgsl; } else { std::stringstream ss; ss << "Unknown fuzzing target '" << target << "'" << std::endl; ss << "Valid options are 'spir-v' and 'wgsl'."; spvtools::Error(FuzzDiagnostic, nullptr, {}, ss.str().c_str()); return {FuzzActions::STOP, 1}; } } else if (0 == strncmp(cur_arg, "--replay-range=", sizeof("--replay-range=") - 1)) { const auto split_flag = spvtools::utils::SplitFlagArgs(cur_arg); char* end = nullptr; errno = 0; const auto replay_range = static_cast(strtol(split_flag.second.c_str(), &end, 10)); assert(end != split_flag.second.c_str() && errno == 0); fuzzer_options->set_replay_range(replay_range); } else if (0 == strncmp(cur_arg, "--replay-validation", sizeof("--replay-validation") - 1)) { fuzzer_options->enable_replay_validation(); } else if (0 == strncmp(cur_arg, "--shrink=", sizeof("--shrink=") - 1)) { const auto split_flag = spvtools::utils::SplitFlagArgs(cur_arg); *shrink_transformations_file = std::string(split_flag.second); } else if (0 == strncmp(cur_arg, "--seed=", sizeof("--seed=") - 1)) { const auto split_flag = spvtools::utils::SplitFlagArgs(cur_arg); char* end = nullptr; errno = 0; const auto seed = static_cast(strtol(split_flag.second.c_str(), &end, 10)); assert(end != split_flag.second.c_str() && errno == 0); fuzzer_options->set_random_seed(seed); } else if (0 == strncmp(cur_arg, "--shrinker-step-limit=", sizeof("--shrinker-step-limit=") - 1)) { const auto split_flag = spvtools::utils::SplitFlagArgs(cur_arg); char* end = nullptr; errno = 0; const auto step_limit = static_cast(strtol(split_flag.second.c_str(), &end, 10)); assert(end != split_flag.second.c_str() && errno == 0); fuzzer_options->set_shrinker_step_limit(step_limit); } else if (0 == strncmp(cur_arg, "--shrinker-temp-file-prefix=", sizeof("--shrinker-temp-file-prefix=") - 1)) { const auto split_flag = spvtools::utils::SplitFlagArgs(cur_arg); *shrink_temp_file_prefix = std::string(split_flag.second); } else if (0 == strcmp(cur_arg, "--before-hlsl-legalization")) { validator_options->SetBeforeHlslLegalization(true); } else if (0 == strcmp(cur_arg, "--relax-logical-pointer")) { validator_options->SetRelaxLogicalPointer(true); } else if (0 == strcmp(cur_arg, "--relax-block-layout")) { validator_options->SetRelaxBlockLayout(true); } else if (0 == strcmp(cur_arg, "--scalar-block-layout")) { validator_options->SetScalarBlockLayout(true); } else if (0 == strcmp(cur_arg, "--skip-block-layout")) { validator_options->SetSkipBlockLayout(true); } else if (0 == strcmp(cur_arg, "--relax-struct-store")) { validator_options->SetRelaxStructStore(true); } else if (0 == strcmp(cur_arg, "--")) { only_positional_arguments_remain = true; } else { std::stringstream ss; ss << "Unrecognized argument: " << cur_arg << std::endl; spvtools::Error(FuzzDiagnostic, nullptr, {}, ss.str().c_str()); PrintUsage(argv[0]); return {FuzzActions::STOP, 1}; } } else if (positional_arg_index == 0) { // Binary input file name assert(in_binary_file->empty()); *in_binary_file = std::string(cur_arg); positional_arg_index++; } else { interestingness_test->push_back(std::string(cur_arg)); } } if (in_binary_file->empty()) { spvtools::Error(FuzzDiagnostic, nullptr, {}, "No input file specified"); return {FuzzActions::STOP, 1}; } if (out_binary_file->empty()) { spvtools::Error(FuzzDiagnostic, nullptr, {}, "-o required"); return {FuzzActions::STOP, 1}; } auto const_fuzzer_options = static_cast(*fuzzer_options); if (force_render_red) { if (!replay_transformations_file->empty() || !shrink_transformations_file->empty() || const_fuzzer_options->replay_validation_enabled) { spvtools::Error(FuzzDiagnostic, nullptr, {}, "The --force-render-red argument cannot be used with any " "other arguments except -o."); return {FuzzActions::STOP, 1}; } return {FuzzActions::FORCE_RENDER_RED, 0}; } if (replay_transformations_file->empty() && shrink_transformations_file->empty() && static_cast(*fuzzer_options) ->replay_validation_enabled) { spvtools::Error(FuzzDiagnostic, nullptr, {}, "The --replay-validation argument can only be used with " "one of the --replay or --shrink arguments."); return {FuzzActions::STOP, 1}; } if (shrink_transformations_file->empty() && !interestingness_test->empty()) { spvtools::Error(FuzzDiagnostic, nullptr, {}, "Too many positional arguments specified; extra positional " "arguments are used as the interestingness function, which " "are only valid with the --shrink option."); return {FuzzActions::STOP, 1}; } if (!shrink_transformations_file->empty() && interestingness_test->empty()) { spvtools::Error( FuzzDiagnostic, nullptr, {}, "The --shrink option requires an interestingness function."); return {FuzzActions::STOP, 1}; } if (!replay_transformations_file->empty() || !shrink_transformations_file->empty()) { // Donors should not be provided when replaying or shrinking: they only make // sense during fuzzing. if (!donors_file->empty()) { spvtools::Error(FuzzDiagnostic, nullptr, {}, "The --donors argument is not compatible with --replay " "nor --shrink."); return {FuzzActions::STOP, 1}; } } if (!replay_transformations_file->empty()) { // A replay transformations file was given, thus the tool is being invoked // in replay mode. if (!shrink_transformations_file->empty()) { spvtools::Error( FuzzDiagnostic, nullptr, {}, "The --replay and --shrink arguments are mutually exclusive."); return {FuzzActions::STOP, 1}; } return {FuzzActions::REPLAY, 0}; } if (!shrink_transformations_file->empty()) { // The tool is being invoked in shrink mode. assert(!interestingness_test->empty() && "An error should have been raised if --shrink was provided without " "an interestingness test."); return {FuzzActions::SHRINK, 0}; } // The tool is being invoked in fuzz mode. if (donors_file->empty()) { spvtools::Error(FuzzDiagnostic, nullptr, {}, "Fuzzing requires that the --donors option is used."); return {FuzzActions::STOP, 1}; } return {FuzzActions::FUZZ, 0}; } bool ParseTransformations( const std::string& transformations_file, spvtools::fuzz::protobufs::TransformationSequence* transformations) { std::ifstream transformations_stream; transformations_stream.open(transformations_file, std::ios::in | std::ios::binary); auto parse_success = transformations->ParseFromIstream(&transformations_stream); transformations_stream.close(); if (!parse_success) { spvtools::Error(FuzzDiagnostic, nullptr, {}, ("Error reading transformations from file '" + transformations_file + "'") .c_str()); return false; } return true; } bool Replay(const spv_target_env& target_env, spv_const_fuzzer_options fuzzer_options, spv_validator_options validator_options, const std::vector& binary_in, const spvtools::fuzz::protobufs::FactSequence& initial_facts, const std::string& replay_transformations_file, std::vector* binary_out, spvtools::fuzz::protobufs::TransformationSequence* transformations_applied) { spvtools::fuzz::protobufs::TransformationSequence transformation_sequence; if (!ParseTransformations(replay_transformations_file, &transformation_sequence)) { return false; } uint32_t num_transformations_to_apply; if (fuzzer_options->replay_range > 0) { // We have a positive replay range, N. We would like transformations // [0, N), truncated to the number of available transformations if N is too // large. num_transformations_to_apply = static_cast( std::min(fuzzer_options->replay_range, transformation_sequence.transformation_size())); } else { // We have non-positive replay range, -N (where N may be 0). We would like // transformations [0, num_transformations - N), or no transformations if N // is too large. num_transformations_to_apply = static_cast( std::max(0, transformation_sequence.transformation_size() + fuzzer_options->replay_range)); } auto replay_result = spvtools::fuzz::Replayer( target_env, spvtools::utils::CLIMessageConsumer, binary_in, initial_facts, transformation_sequence, num_transformations_to_apply, fuzzer_options->replay_validation_enabled, validator_options) .Run(); replay_result.transformed_module->module()->ToBinary(binary_out, false); *transformations_applied = std::move(replay_result.applied_transformations); return replay_result.status == spvtools::fuzz::Replayer::ReplayerResultStatus::kComplete; } bool Shrink(const spv_target_env& target_env, spv_const_fuzzer_options fuzzer_options, spv_validator_options validator_options, const std::vector& binary_in, const spvtools::fuzz::protobufs::FactSequence& initial_facts, const std::string& shrink_transformations_file, const std::string& shrink_temp_file_prefix, const std::vector& interestingness_command, std::vector* binary_out, spvtools::fuzz::protobufs::TransformationSequence* transformations_applied) { spvtools::fuzz::protobufs::TransformationSequence transformation_sequence; if (!ParseTransformations(shrink_transformations_file, &transformation_sequence)) { return false; } assert(!interestingness_command.empty() && "An error should have been raised because the interestingness_command " "is empty."); std::stringstream joined; joined << interestingness_command[0]; for (size_t i = 1, size = interestingness_command.size(); i < size; ++i) { joined << " " << interestingness_command[i]; } std::string interestingness_command_joined = joined.str(); spvtools::fuzz::Shrinker::InterestingnessFunction interestingness_function = [interestingness_command_joined, shrink_temp_file_prefix]( std::vector binary, uint32_t reductions_applied) -> bool { std::stringstream ss; ss << shrink_temp_file_prefix << std::setw(4) << std::setfill('0') << reductions_applied << ".spv"; const auto spv_file = ss.str(); const std::string command = interestingness_command_joined + " " + spv_file; auto write_file_succeeded = WriteFile(spv_file.c_str(), "wb", &binary[0], binary.size()); (void)(write_file_succeeded); assert(write_file_succeeded); return ExecuteCommand(command); }; auto shrink_result = spvtools::fuzz::Shrinker( target_env, spvtools::utils::CLIMessageConsumer, binary_in, initial_facts, transformation_sequence, interestingness_function, fuzzer_options->shrinker_step_limit, fuzzer_options->replay_validation_enabled, validator_options) .Run(); *binary_out = std::move(shrink_result.transformed_binary); *transformations_applied = std::move(shrink_result.applied_transformations); return spvtools::fuzz::Shrinker::ShrinkerResultStatus::kComplete == shrink_result.status || spvtools::fuzz::Shrinker::ShrinkerResultStatus::kStepLimitReached == shrink_result.status; } bool Fuzz(const spv_target_env& target_env, spv_const_fuzzer_options fuzzer_options, spv_validator_options validator_options, const std::vector& binary_in, const spvtools::fuzz::protobufs::FactSequence& initial_facts, const std::string& donors, spvtools::fuzz::RepeatedPassStrategy repeated_pass_strategy, FuzzingTarget fuzzing_target, std::vector* binary_out, spvtools::fuzz::protobufs::TransformationSequence* transformations_applied) { auto message_consumer = spvtools::utils::CLIMessageConsumer; std::vector donor_suppliers; std::ifstream donors_file(donors); if (!donors_file) { spvtools::Error(FuzzDiagnostic, nullptr, {}, "Error opening donors file"); return false; } std::string donor_filename; while (std::getline(donors_file, donor_filename)) { donor_suppliers.emplace_back( [donor_filename, message_consumer, target_env]() -> std::unique_ptr { std::vector donor_binary; if (!ReadBinaryFile(donor_filename.c_str(), &donor_binary)) { return nullptr; } return spvtools::BuildModule(target_env, message_consumer, donor_binary.data(), donor_binary.size()); }); } std::unique_ptr ir_context; if (!spvtools::fuzz::fuzzerutil::BuildIRContext(target_env, message_consumer, binary_in, validator_options, &ir_context)) { spvtools::Error(FuzzDiagnostic, nullptr, {}, "Initial binary is invalid"); return false; } assert((fuzzing_target == FuzzingTarget::kWgsl || fuzzing_target == FuzzingTarget::kSpirv) && "Not all fuzzing targets are handled"); auto fuzzer_context = spvtools::MakeUnique( spvtools::MakeUnique( fuzzer_options->has_random_seed ? fuzzer_options->random_seed : static_cast(std::random_device()())), spvtools::fuzz::FuzzerContext::GetMinFreshId(ir_context.get()), fuzzing_target == FuzzingTarget::kWgsl); auto transformation_context = spvtools::MakeUnique( spvtools::MakeUnique(ir_context.get()), validator_options); transformation_context->GetFactManager()->AddInitialFacts(message_consumer, initial_facts); spvtools::fuzz::Fuzzer fuzzer( std::move(ir_context), std::move(transformation_context), std::move(fuzzer_context), message_consumer, donor_suppliers, fuzzer_options->all_passes_enabled, repeated_pass_strategy, fuzzer_options->fuzzer_pass_validation_enabled, validator_options, false); auto fuzz_result = fuzzer.Run(0); if (fuzz_result.status == spvtools::fuzz::Fuzzer::Status::kFuzzerPassLedToInvalidModule) { spvtools::Error(FuzzDiagnostic, nullptr, {}, "Error running fuzzer"); return false; } fuzzer.GetIRContext()->module()->ToBinary(binary_out, true); *transformations_applied = fuzzer.GetTransformationSequence(); return true; } } // namespace // Dumps |binary| to file |filename|. Useful for interactive debugging. void DumpShader(const std::vector& binary, const char* filename) { auto write_file_succeeded = WriteFile(filename, "wb", &binary[0], binary.size()); if (!write_file_succeeded) { std::cerr << "Failed to dump shader" << std::endl; } } // Dumps the SPIRV-V module in |context| to file |filename|. Useful for // interactive debugging. void DumpShader(spvtools::opt::IRContext* context, const char* filename) { std::vector binary; context->module()->ToBinary(&binary, false); DumpShader(binary, filename); } // Dumps |transformations| to file |filename| in binary format. Useful for // interactive debugging. void DumpTransformationsBinary( const spvtools::fuzz::protobufs::TransformationSequence& transformations, const char* filename) { std::ofstream transformations_file; transformations_file.open(filename, std::ios::out | std::ios::binary); transformations.SerializeToOstream(&transformations_file); transformations_file.close(); } // Dumps |transformations| to file |filename| in JSON format. Useful for // interactive debugging. void DumpTransformationsJson( const spvtools::fuzz::protobufs::TransformationSequence& transformations, const char* filename) { std::string json_string; auto json_options = google::protobuf::util::JsonPrintOptions(); json_options.add_whitespace = true; auto json_generation_status = google::protobuf::util::MessageToJsonString( transformations, &json_string, json_options); if (json_generation_status.ok()) { std::ofstream transformations_json_file(filename); transformations_json_file << json_string; transformations_json_file.close(); } } const auto kDefaultEnvironment = SPV_ENV_UNIVERSAL_1_3; int main(int argc, const char** argv) { std::string in_binary_file; std::string out_binary_file; std::string donors_file; std::string replay_transformations_file; std::vector interestingness_test; std::string shrink_transformations_file; std::string shrink_temp_file_prefix = "temp_"; spvtools::fuzz::RepeatedPassStrategy repeated_pass_strategy; auto fuzzing_target = FuzzingTarget::kSpirv; spvtools::FuzzerOptions fuzzer_options; spvtools::ValidatorOptions validator_options; FuzzStatus status = ParseFlags(argc, argv, &in_binary_file, &out_binary_file, &donors_file, &replay_transformations_file, &interestingness_test, &shrink_transformations_file, &shrink_temp_file_prefix, &repeated_pass_strategy, &fuzzing_target, &fuzzer_options, &validator_options); if (status.action == FuzzActions::STOP) { return status.code; } std::vector binary_in; if (!ReadBinaryFile(in_binary_file.c_str(), &binary_in)) { return 1; } spvtools::fuzz::protobufs::FactSequence initial_facts; // If not found, dot_pos will be std::string::npos, which can be used in // substr to mean "the end of the string"; there is no need to check the // result. size_t dot_pos = in_binary_file.rfind('.'); std::string in_facts_file = in_binary_file.substr(0, dot_pos) + ".facts"; std::ifstream facts_input(in_facts_file); if (facts_input) { std::string facts_json_string((std::istreambuf_iterator(facts_input)), std::istreambuf_iterator()); facts_input.close(); if (!google::protobuf::util::JsonStringToMessage(facts_json_string, &initial_facts) .ok()) { spvtools::Error(FuzzDiagnostic, nullptr, {}, "Error reading facts data"); return 1; } } std::vector binary_out; spvtools::fuzz::protobufs::TransformationSequence transformations_applied; spv_target_env target_env = kDefaultEnvironment; switch (status.action) { case FuzzActions::FORCE_RENDER_RED: if (!spvtools::fuzz::ForceRenderRed( target_env, validator_options, binary_in, initial_facts, spvtools::utils::CLIMessageConsumer, &binary_out)) { return 1; } break; case FuzzActions::FUZZ: if (!Fuzz(target_env, fuzzer_options, validator_options, binary_in, initial_facts, donors_file, repeated_pass_strategy, fuzzing_target, &binary_out, &transformations_applied)) { return 1; } break; case FuzzActions::REPLAY: if (!Replay(target_env, fuzzer_options, validator_options, binary_in, initial_facts, replay_transformations_file, &binary_out, &transformations_applied)) { return 1; } break; case FuzzActions::SHRINK: { if (!Shrink(target_env, fuzzer_options, validator_options, binary_in, initial_facts, shrink_transformations_file, shrink_temp_file_prefix, interestingness_test, &binary_out, &transformations_applied)) { return 1; } } break; default: assert(false && "Unknown fuzzer action."); break; } if (!WriteFile(out_binary_file.c_str(), "wb", binary_out.data(), binary_out.size())) { spvtools::Error(FuzzDiagnostic, nullptr, {}, "Error writing out binary"); return 1; } if (status.action != FuzzActions::FORCE_RENDER_RED) { // If not found, dot_pos will be std::string::npos, which can be used in // substr to mean "the end of the string"; there is no need to check the // result. dot_pos = out_binary_file.rfind('.'); std::string output_file_prefix = out_binary_file.substr(0, dot_pos); std::ofstream transformations_file; transformations_file.open(output_file_prefix + ".transformations", std::ios::out | std::ios::binary); bool success = transformations_applied.SerializeToOstream(&transformations_file); transformations_file.close(); if (!success) { spvtools::Error(FuzzDiagnostic, nullptr, {}, "Error writing out transformations binary"); return 1; } std::string json_string; auto json_options = google::protobuf::util::JsonPrintOptions(); json_options.add_whitespace = true; auto json_generation_status = google::protobuf::util::MessageToJsonString( transformations_applied, &json_string, json_options); if (!json_generation_status.ok()) { spvtools::Error(FuzzDiagnostic, nullptr, {}, "Error writing out transformations in JSON format"); return 1; } std::ofstream transformations_json_file(output_file_prefix + ".transformations_json"); transformations_json_file << json_string; transformations_json_file.close(); } return 0; } KhronosGroup-SPIRV-Tools-f289d04/tools/io.cpp000066400000000000000000000322571475742701700210150ustar00rootroot00000000000000// Copyright (c) 2024 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "io.h" #include #include #include #if defined(SPIRV_WINDOWS) #include #include #define SET_STDIN_TO_BINARY_MODE() _setmode(_fileno(stdin), O_BINARY); #define SET_STDIN_TO_TEXT_MODE() _setmode(_fileno(stdin), O_TEXT); #define SET_STDOUT_TO_BINARY_MODE() _setmode(_fileno(stdout), O_BINARY); #define SET_STDOUT_TO_TEXT_MODE() _setmode(_fileno(stdout), O_TEXT); #define SET_STDOUT_MODE(mode) _setmode(_fileno(stdout), mode); #else #define SET_STDIN_TO_BINARY_MODE() #define SET_STDIN_TO_TEXT_MODE() #define SET_STDOUT_TO_BINARY_MODE() 0 #define SET_STDOUT_TO_TEXT_MODE() 0 #define SET_STDOUT_MODE(mode) #endif namespace { // Appends the contents of the |file| to |data|, assuming each element in the // file is of type |T|. template void ReadFile(FILE* file, std::vector* data) { if (file == nullptr) return; const int buf_size = 4096 / sizeof(T); T buf[buf_size]; while (size_t len = fread(buf, sizeof(T), buf_size, file)) { data->insert(data->end(), buf, buf + len); } } // Returns true if |file| has encountered an error opening the file or reading // from it. If there was an error, writes an error message to standard error. bool WasFileCorrectlyRead(FILE* file, const char* filename) { if (file == nullptr) { fprintf(stderr, "error: file does not exist '%s'\n", filename); return false; } if (ftell(file) == -1L) { if (ferror(file)) { fprintf(stderr, "error: error reading file '%s'\n", filename); return false; } } return true; } // Ensure the file contained an exact number of elements, whose size is given in // |alignment|. bool WasFileSizeAligned(const char* filename, size_t read_size, size_t alignment) { assert(alignment != 1); if ((read_size % alignment) != 0) { fprintf(stderr, "error: file size should be a multiple of %zd; file '%s' corrupt\n", alignment, filename); return false; } return true; } // Different formats the hex is expected to be in. enum class HexMode { // 0x07230203, ... Words, // 0x07, 0x23, 0x02, 0x03, ... BytesBigEndian, // 0x03, 0x02, 0x23, 0x07, ... BytesLittleEndian, // 07 23 02 03 ... StreamBigEndian, // 03 02 23 07 ... StreamLittleEndian, }; // Whether a character should be skipped as whitespace / separator / // end-of-file. bool IsSpace(char c) { return isspace(c) || c == ',' || c == '\0'; } bool IsHexStream(const std::vector& stream) { for (char c : stream) { if (IsSpace(c)) { continue; } // Every possible case of a SPIR-V hex stream starts with either '0' or 'x' // (see |HexMode| values). Make a decision upon inspecting the first // non-space character. return c == '0' || c == 'x' || c == 'X'; } return false; } bool MatchIgnoreCase(const char* token, const char* expect, size_t len) { for (size_t i = 0; i < len; ++i) { if (tolower(token[i]) != tolower(expect[i])) { return false; } } return true; } // Helper class to tokenize a hex stream class HexTokenizer { public: HexTokenizer(const char* filename, const std::vector& stream, std::vector* data) : filename_(filename), stream_(stream), data_(data) { DetermineMode(); } bool Parse() { while (current_ < stream_.size() && !encountered_error_) { data_->push_back(GetNextWord()); // Make sure trailing space does not lead to parse error by skipping it // and exiting the loop. SkipSpace(); } return !encountered_error_; } private: void ParseError(const char* reason) { if (!encountered_error_) { fprintf(stderr, "error: hex stream parse error at character %zu: %s in '%s'\n", current_, reason, filename_); encountered_error_ = true; } } // Skip whitespace until the next non-whitespace non-comma character. void SkipSpace() { while (current_ < stream_.size()) { char c = stream_[current_]; if (!IsSpace(c)) { return; } ++current_; } } // Skip the 0x or x at the beginning of a hex value. void Skip0x() { // The first character must be 0 or x. const char first = Next(); if (first != '0' && first != 'x' && first != 'X') { ParseError("expected 0x or x"); } else if (first == '0') { const char second = Next(); if (second != 'x' && second != 'X') { ParseError("expected 0x"); } } } // Consume the next character. char Next() { return current_ < stream_.size() ? stream_[current_++] : '\0'; } // Determine how to read the hex stream based on the first token. void DetermineMode() { SkipSpace(); // Read 11 bytes, that is the size of the biggest token (10) + one more. char first_token[11]; for (uint32_t i = 0; i < 11; ++i) { first_token[i] = Next(); } // Table of how to match the first token with a mode. struct { const char* expect; bool must_have_delimiter; HexMode mode; } parse_info[] = { {"0x07230203", true, HexMode::Words}, {"0x7230203", true, HexMode::Words}, {"x07230203", true, HexMode::Words}, {"x7230203", true, HexMode::Words}, {"0x07", true, HexMode::BytesBigEndian}, {"0x7", true, HexMode::BytesBigEndian}, {"x07", true, HexMode::BytesBigEndian}, {"x7", true, HexMode::BytesBigEndian}, {"0x03", true, HexMode::BytesLittleEndian}, {"0x3", true, HexMode::BytesLittleEndian}, {"x03", true, HexMode::BytesLittleEndian}, {"x3", true, HexMode::BytesLittleEndian}, {"07", false, HexMode::StreamBigEndian}, {"03", false, HexMode::StreamLittleEndian}, }; // Check to see if any of the possible first tokens are matched. If not, // this is not a recognized hex stream. encountered_error_ = true; for (const auto& info : parse_info) { const size_t expect_len = strlen(info.expect); const bool matches_expect = MatchIgnoreCase(first_token, info.expect, expect_len); const bool satisfies_delimeter = !info.must_have_delimiter || IsSpace(first_token[expect_len]); if (matches_expect && satisfies_delimeter) { mode_ = info.mode; encountered_error_ = false; break; } } if (encountered_error_) { fprintf(stderr, "error: hex format detected, but pattern '%.11s' is not " "recognized '%s'\n", first_token, filename_); } // Reset the position to restart parsing with the determined mode. current_ = 0; } // Consume up to |max_len| characters and put them in |token_chars|. A // delimiter is expected. The resulting string is NUL-terminated. void NextN(char token_chars[9], size_t max_len) { assert(max_len < 9); for (size_t i = 0; i <= max_len; ++i) { char c = Next(); if (IsSpace(c)) { token_chars[i] = '\0'; return; } token_chars[i] = c; if (!isxdigit(c)) { ParseError("encountered non-hex character"); } } // If space is not reached before the maximum number of characters where // consumed, that's an error. ParseError("expected delimiter (space or comma)"); token_chars[max_len] = '\0'; } // Consume one hex digit. char NextHexDigit() { char c = Next(); if (!isxdigit(c)) { ParseError("encountered non-hex character"); } return c; } // Extract a token out of the stream. It could be either a word or a byte, // based on |mode_|. uint32_t GetNextToken() { SkipSpace(); // The longest token can be 8 chars (for |HexMode::Words|), add one for // '\0'. char token_chars[9]; switch (mode_) { case HexMode::Words: case HexMode::BytesBigEndian: case HexMode::BytesLittleEndian: // Start with 0x, followed by up to 8 (for Word) or 2 (for Byte*) // digits. Skip0x(); NextN(token_chars, mode_ == HexMode::Words ? 8 : 2); break; case HexMode::StreamBigEndian: case HexMode::StreamLittleEndian: // Always expected to see two consecutive hex digits. token_chars[0] = NextHexDigit(); token_chars[1] = NextHexDigit(); token_chars[2] = '\0'; break; } if (encountered_error_) { return 0; } // Parse the hex value that was just read. return static_cast(strtol(token_chars, nullptr, 16)); } // Construct a word out of tokens uint32_t GetNextWord() { if (mode_ == HexMode::Words) { return GetNextToken(); } uint32_t tokens[4] = { GetNextToken(), GetNextToken(), GetNextToken(), GetNextToken(), }; switch (mode_) { case HexMode::BytesBigEndian: case HexMode::StreamBigEndian: return tokens[0] << 24 | tokens[1] << 16 | tokens[2] << 8 | tokens[3]; case HexMode::BytesLittleEndian: case HexMode::StreamLittleEndian: return tokens[3] << 24 | tokens[2] << 16 | tokens[1] << 8 | tokens[0]; default: assert(false); return 0; } } const char* filename_; const std::vector& stream_; std::vector* data_; HexMode mode_ = HexMode::Words; size_t current_ = 0; bool encountered_error_ = false; }; } // namespace bool ReadBinaryFile(const char* filename, std::vector* data) { assert(data->empty()); const bool use_file = filename && strcmp("-", filename); FILE* fp = nullptr; if (use_file) { fp = fopen(filename, "rb"); } else { SET_STDIN_TO_BINARY_MODE(); fp = stdin; } // Read into a char vector first. If this is a hex stream, it needs to be // processed as such. std::vector data_raw; ReadFile(fp, &data_raw); bool succeeded = WasFileCorrectlyRead(fp, filename); if (use_file && fp) fclose(fp); if (!succeeded) { return false; } if (IsHexStream(data_raw)) { // If a hex stream, parse it and fill |data|. HexTokenizer tokenizer(filename, data_raw, data); succeeded = tokenizer.Parse(); } else { // If not a hex stream, convert it to uint32_t via memcpy. succeeded = WasFileSizeAligned(filename, data_raw.size(), sizeof(uint32_t)); if (succeeded) { data->resize(data_raw.size() / sizeof(uint32_t), 0); memcpy(data->data(), data_raw.data(), data_raw.size()); } } return succeeded; } bool ConvertHexToBinary(const std::vector& stream, std::vector* data) { HexTokenizer tokenizer("", stream, data); return tokenizer.Parse(); } bool ReadTextFile(const char* filename, std::vector* data) { assert(data->empty()); const bool use_file = filename && strcmp("-", filename); FILE* fp = nullptr; if (use_file) { fp = fopen(filename, "r"); } else { SET_STDIN_TO_TEXT_MODE(); fp = stdin; } ReadFile(fp, data); bool succeeded = WasFileCorrectlyRead(fp, filename); if (use_file && fp) fclose(fp); return succeeded; } namespace { // A class to create and manage a file for outputting data. class OutputFile { public: // Opens |filename| in the given mode. If |filename| is nullptr, the empty // string or "-", stdout will be set to the given mode. OutputFile(const char* filename, const char* mode) : old_mode_(0) { const bool use_stdout = !filename || (filename[0] == '-' && filename[1] == '\0'); if (use_stdout) { if (strchr(mode, 'b')) { old_mode_ = SET_STDOUT_TO_BINARY_MODE(); } else { old_mode_ = SET_STDOUT_TO_TEXT_MODE(); } fp_ = stdout; } else { fp_ = fopen(filename, mode); } } ~OutputFile() { if (fp_ == stdout) { fflush(stdout); SET_STDOUT_MODE(old_mode_); } else if (fp_ != nullptr) { fclose(fp_); } } // Returns a file handle to the file. FILE* GetFileHandle() const { return fp_; } private: FILE* fp_; int old_mode_; }; } // namespace template bool WriteFile(const char* filename, const char* mode, const T* data, size_t count) { OutputFile file(filename, mode); FILE* fp = file.GetFileHandle(); if (fp == nullptr) { fprintf(stderr, "error: could not open file '%s'\n", filename); return false; } size_t written = fwrite(data, sizeof(T), count, fp); if (count != written) { fprintf(stderr, "error: could not write to file '%s'\n", filename); return false; } return true; } template bool WriteFile(const char* filename, const char* mode, const uint32_t* data, size_t count); template bool WriteFile(const char* filename, const char* mode, const char* data, size_t count); KhronosGroup-SPIRV-Tools-f289d04/tools/io.h000066400000000000000000000056361475742701700204630ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef TOOLS_IO_H_ #define TOOLS_IO_H_ #include #include #include #include // Sets the contents of the file named |filename| in |data|, assuming each // element in the file is of type |uint32_t|. The file is opened as a binary // file. If |filename| is nullptr or "-", reads from the standard input, but // reopened as a binary file. If any error occurs, writes error messages to // standard error and returns false. // // If the given input is detected to be in ascii hex, it is converted to binary // automatically. In that case, the shape of the input data is determined based // on the representation of the magic number: // // * "[0]x[0]7230203": Every following "0x..." represents a word. // * "[0]x[0]7[,] [0]x23...": Every following "0x..." represents a byte, stored // in big-endian order // * "[0]x[0]3[,] [0]x[0]2...": Every following "0x..." represents a byte, // stored in little-endian order // * "07[, ]23...": Every following "XY" represents a byte, stored in // big-endian order // * "03[, ]02...": Every following "XY" represents a byte, stored in // little-endian order bool ReadBinaryFile(const char* filename, std::vector* data); // The hex->binary logic of |ReadBinaryFile| applied to a pre-loaded stream of // bytes. Used by tests to avoid having to call |ReadBinaryFile| with temp // files. Returns false in case of parse errors. bool ConvertHexToBinary(const std::vector& stream, std::vector* data); // Sets the contents of the file named |filename| in |data|, assuming each // element in the file is of type |char|. The file is opened as a text file. If // |filename| is nullptr or "-", reads from the standard input, but reopened as // a text file. If any error occurs, writes error messages to standard error and // returns false. bool ReadTextFile(const char* filename, std::vector* data); // Writes the given |data| into the file named as |filename| using the given // |mode|, assuming |data| is an array of |count| elements of type |T|. If // |filename| is nullptr or "-", writes to standard output. If any error occurs, // returns false and outputs error message to standard error. template bool WriteFile(const char* filename, const char* mode, const T* data, size_t count); #endif // TOOLS_IO_H_ KhronosGroup-SPIRV-Tools-f289d04/tools/lesspipe/000077500000000000000000000000001475742701700215155ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/tools/lesspipe/CMakeLists.txt000066400000000000000000000022011475742701700242500ustar00rootroot00000000000000# Copyright (c) 2016 Google Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Install a script for use with the LESSOPEN of less(1). # For example, after installation into /usr/local do: # export LESSOPEN='|/usr/local/bin "%s"' # less -R foo.spv # # See https://github.com/KhronosGroup/SPIRV-Tools/issues/359 # The script will be installed with everyone having read and execute # permissions. # We have a .sh extension because Windows users often configure # executable settings via filename extension. if(ENABLE_SPIRV_TOOLS_INSTALL) install(PROGRAMS spirv-lesspipe.sh DESTINATION ${CMAKE_INSTALL_BINDIR}) endif(ENABLE_SPIRV_TOOLS_INSTALL) KhronosGroup-SPIRV-Tools-f289d04/tools/lesspipe/spirv-lesspipe.sh000066400000000000000000000015421475742701700250400ustar00rootroot00000000000000#!/usr/bin/env sh # Copyright (c) 2016 The Khronos Group Inc. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # A script for automatically disassembling a .spv file # for less(1). This assumes spirv-dis is on our PATH. # # See https://github.com/KhronosGroup/SPIRV-Tools/issues/359 case "$1" in *.spv) spirv-dis "$@" 2>/dev/null;; *) exit 1;; esac exit $? KhronosGroup-SPIRV-Tools-f289d04/tools/link/000077500000000000000000000000001475742701700206265ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/tools/link/linker.cpp000066400000000000000000000156311475742701700226240ustar00rootroot00000000000000// Copyright (c) 2017 Pierre Moreau // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "spirv-tools/linker.hpp" #include #include #include #include #include "source/spirv_target_env.h" #include "source/table.h" #include "spirv-tools/libspirv.hpp" #include "tools/io.h" #include "tools/util/flags.h" namespace { constexpr auto kDefaultEnvironment = "spv1.6"; void print_usage(const char* program) { std::string target_env_list = spvTargetEnvList(16, 80); // NOTE: Please maintain flags in lexicographical order. printf( R"(%s - Link SPIR-V binary files together. USAGE: %s [options] [-o ] ... The SPIR-V binaries are read from the different (s). The SPIR-V resulting linked binary module is written to the file "out.spv" unless the -o option is used; if is "-", it is written to the standard output. NOTE: The linker is a work in progress. Options (in lexicographical order): --allow-partial-linkage Allow partial linkage by accepting imported symbols to be unresolved. --allow-pointer-mismatch Allow pointer function parameters to mismatch the target link target. This is useful to workaround lost correct parameter type information due to LLVM's opaque pointers. --create-library Link the binaries into a library, keeping all exported symbols. -h, --help Print this help. --target-env Set the environment used for interpreting the inputs. Without this option the environment defaults to spv1.6. must be one of {%s}. NOTE: The SPIR-V version used by the linked binary module depends only on the version of the inputs, and is not affected by this option. --use-highest-version Upgrade the output SPIR-V version to the highest of the input files, instead of requiring all of them to have the same version. NOTE: If one of the older input files uses an instruction that is deprecated in the highest SPIR-V version, the output will be invalid. --verify-ids Verify that IDs in the resulting modules are truly unique. --version Display linker version information. )", program, program, target_env_list.c_str()); } } // namespace // clang-format off FLAG_SHORT_bool( h, /* default_value= */ false, /* required= */ false); FLAG_LONG_bool( help, /* default_value= */ false, /* required= */ false); FLAG_LONG_bool( version, /* default_value= */ false, /* required= */ false); FLAG_LONG_bool( verify_ids, /* default_value= */ false, /* required= */ false); FLAG_LONG_bool( create_library, /* default_value= */ false, /* required= */ false); FLAG_LONG_bool( allow_partial_linkage, /* default_value= */ false, /* required= */ false); FLAG_LONG_bool( allow_pointer_mismatch, /* default_value= */ false, /* required= */ false); FLAG_SHORT_string(o, /* default_value= */ "", /* required= */ false); FLAG_LONG_string( target_env, /* default_value= */ kDefaultEnvironment, /* required= */ false); FLAG_LONG_bool( use_highest_version, /* default_value= */ false, /* required= */ false); // clang-format on int main(int, const char* argv[]) { if (!flags::Parse(argv)) { return 1; } if (flags::h.value() || flags::help.value()) { print_usage(argv[0]); return 0; } if (flags::version.value()) { spv_target_env target_env; bool success = spvParseTargetEnv(kDefaultEnvironment, &target_env); assert(success && "Default environment should always parse."); if (!success) { fprintf(stderr, "error: invalid default target environment. Please report this " "issue."); return 1; } printf("%s\n", spvSoftwareVersionDetailsString()); printf("Target: %s\n", spvTargetEnvDescription(target_env)); return 0; } spv_target_env target_env; if (!spvParseTargetEnv(flags::target_env.value().c_str(), &target_env)) { fprintf(stderr, "error: Unrecognized target env: %s\n", flags::target_env.value().c_str()); return 1; } const std::string outFile = flags::o.value().empty() ? "out.spv" : flags::o.value(); const std::vector& inFiles = flags::positional_arguments; spvtools::LinkerOptions options; options.SetAllowPartialLinkage(flags::allow_partial_linkage.value()); options.SetAllowPtrTypeMismatch(flags::allow_pointer_mismatch.value()); options.SetCreateLibrary(flags::create_library.value()); options.SetVerifyIds(flags::verify_ids.value()); options.SetUseHighestVersion(flags::use_highest_version.value()); if (inFiles.empty()) { fprintf(stderr, "error: No input file specified\n"); return 1; } std::vector> contents(inFiles.size()); for (size_t i = 0u; i < inFiles.size(); ++i) { if (!ReadBinaryFile(inFiles[i].c_str(), &contents[i])) return 1; } const spvtools::MessageConsumer consumer = [](spv_message_level_t level, const char*, const spv_position_t& position, const char* message) { switch (level) { case SPV_MSG_FATAL: case SPV_MSG_INTERNAL_ERROR: case SPV_MSG_ERROR: std::cerr << "error: " << position.index << ": " << message << std::endl; break; case SPV_MSG_WARNING: std::cout << "warning: " << position.index << ": " << message << std::endl; break; case SPV_MSG_INFO: std::cout << "info: " << position.index << ": " << message << std::endl; break; default: break; } }; spvtools::Context context(target_env); context.SetMessageConsumer(consumer); std::vector linkingResult; spv_result_t status = Link(context, contents, &linkingResult, options); if (status != SPV_SUCCESS && status != SPV_WARNING) return 1; if (!WriteFile(outFile.c_str(), "wb", linkingResult.data(), linkingResult.size())) return 1; return 0; } KhronosGroup-SPIRV-Tools-f289d04/tools/lint/000077500000000000000000000000001475742701700206375ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/tools/lint/lint.cpp000066400000000000000000000041341475742701700223130ustar00rootroot00000000000000// Copyright (c) 2021 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "source/opt/log.h" #include "spirv-tools/linter.hpp" #include "tools/io.h" #include "tools/util/cli_consumer.h" #include "tools/util/flags.h" namespace { constexpr auto kDefaultEnvironment = SPV_ENV_UNIVERSAL_1_6; constexpr auto kHelpTextFmt = R"(%s - Lint a SPIR-V binary module. Usage: %s [options] Options: -h, --help Print this help. --version Display assembler version information. )"; } // namespace // clang-format off FLAG_SHORT_bool( h, /* default_value= */ false, /* required= */ false); FLAG_LONG_bool( help, /* default_value= */ false, /* required= */ false); FLAG_LONG_bool( version, /* default_value= */ false, /* required= */ false); // clang-format on int main(int, const char** argv) { if (!flags::Parse(argv)) { return 1; } if (flags::h.value() || flags::help.value()) { printf(kHelpTextFmt, argv[0], argv[0]); return 0; } if (flags::version.value()) { printf("%s\n", spvSoftwareVersionDetailsString()); return 0; } if (flags::positional_arguments.size() != 1) { spvtools::Error(spvtools::utils::CLIMessageConsumer, nullptr, {}, "expected exactly one input file."); return 1; } spvtools::Linter linter(kDefaultEnvironment); linter.SetMessageConsumer(spvtools::utils::CLIMessageConsumer); std::vector binary; if (!ReadBinaryFile(flags::positional_arguments[0].c_str(), &binary)) { return 1; } return linter.Run(binary.data(), binary.size()) ? 0 : 1; } KhronosGroup-SPIRV-Tools-f289d04/tools/objdump/000077500000000000000000000000001475742701700213315ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/tools/objdump/extract_source.cpp000066400000000000000000000166341475742701700251010ustar00rootroot00000000000000// Copyright (c) 2023 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "extract_source.h" #include #include #include #include #include "source/opt/log.h" #include "spirv-tools/libspirv.hpp" #include "spirv/unified1/spirv.hpp" #include "tools/util/cli_consumer.h" namespace { constexpr auto kDefaultEnvironment = SPV_ENV_UNIVERSAL_1_6; // Extract a string literal from a given range. // Copies all the characters from `begin` to the first '\0' it encounters, while // removing escape patterns. // Not finding a '\0' before reaching `end` fails the extraction. // // Returns `true` if the extraction succeeded. // `output` value is undefined if false is returned. spv_result_t ExtractStringLiteral(const spv_position_t& loc, const char* begin, const char* end, std::string* output) { size_t sourceLength = std::distance(begin, end); std::string escapedString; escapedString.resize(sourceLength); size_t writeIndex = 0; size_t readIndex = 0; for (; readIndex < sourceLength; writeIndex++, readIndex++) { const char read = begin[readIndex]; if (read == '\0') { escapedString.resize(writeIndex); output->append(escapedString); return SPV_SUCCESS; } if (read == '\\') { ++readIndex; } escapedString[writeIndex] = begin[readIndex]; } spvtools::Error(spvtools::utils::CLIMessageConsumer, "", loc, "Missing NULL terminator for literal string."); return SPV_ERROR_INVALID_BINARY; } spv_result_t extractOpString(const spv_position_t& loc, const spv_parsed_instruction_t& instruction, std::string* output) { assert(output != nullptr); assert(instruction.opcode == spv::Op::OpString); if (instruction.num_operands != 2) { spvtools::Error(spvtools::utils::CLIMessageConsumer, "", loc, "Missing operands for OpString."); return SPV_ERROR_INVALID_BINARY; } const auto& operand = instruction.operands[1]; const char* stringBegin = reinterpret_cast(instruction.words + operand.offset); const char* stringEnd = reinterpret_cast( instruction.words + operand.offset + operand.num_words); return ExtractStringLiteral(loc, stringBegin, stringEnd, output); } spv_result_t extractOpSourceContinued( const spv_position_t& loc, const spv_parsed_instruction_t& instruction, std::string* output) { assert(output != nullptr); assert(instruction.opcode == spv::Op::OpSourceContinued); if (instruction.num_operands != 1) { spvtools::Error(spvtools::utils::CLIMessageConsumer, "", loc, "Missing operands for OpSourceContinued."); return SPV_ERROR_INVALID_BINARY; } const auto& operand = instruction.operands[0]; const char* stringBegin = reinterpret_cast(instruction.words + operand.offset); const char* stringEnd = reinterpret_cast( instruction.words + operand.offset + operand.num_words); return ExtractStringLiteral(loc, stringBegin, stringEnd, output); } spv_result_t extractOpSource(const spv_position_t& loc, const spv_parsed_instruction_t& instruction, spv::Id* filename, std::string* code) { assert(filename != nullptr && code != nullptr); assert(instruction.opcode == spv::Op::OpSource); // OpCode [ Source Language | Version | File (optional) | Source (optional) ] if (instruction.num_words < 3) { spvtools::Error(spvtools::utils::CLIMessageConsumer, "", loc, "Missing operands for OpSource."); return SPV_ERROR_INVALID_BINARY; } *filename = 0; *code = ""; if (instruction.num_words < 4) { return SPV_SUCCESS; } *filename = instruction.words[3]; if (instruction.num_words < 5) { return SPV_SUCCESS; } const char* stringBegin = reinterpret_cast(instruction.words + 4); const char* stringEnd = reinterpret_cast(instruction.words + instruction.num_words); return ExtractStringLiteral(loc, stringBegin, stringEnd, code); } } // namespace bool ExtractSourceFromModule( const std::vector& binary, std::unordered_map* output) { auto context = spvtools::SpirvTools(kDefaultEnvironment); context.SetMessageConsumer(spvtools::utils::CLIMessageConsumer); // There is nothing valuable in the header. spvtools::HeaderParser headerParser = [](const spv_endianness_t, const spv_parsed_header_t&) { return SPV_SUCCESS; }; std::unordered_map stringMap; std::vector> sources; spv::Op lastOpcode = spv::Op::OpMax; size_t instructionIndex = 0; spvtools::InstructionParser instructionParser = [&stringMap, &sources, &lastOpcode, &instructionIndex](const spv_parsed_instruction_t& instruction) { const spv_position_t loc = {0, 0, instructionIndex + 1}; spv_result_t result = SPV_SUCCESS; if (instruction.opcode == spv::Op::OpString) { std::string content; result = extractOpString(loc, instruction, &content); if (result == SPV_SUCCESS) { stringMap.emplace(instruction.result_id, std::move(content)); } } else if (instruction.opcode == spv::Op::OpSource) { spv::Id filenameId; std::string code; result = extractOpSource(loc, instruction, &filenameId, &code); if (result == SPV_SUCCESS) { sources.emplace_back(std::make_pair(filenameId, std::move(code))); } } else if (instruction.opcode == spv::Op::OpSourceContinued) { if (lastOpcode != spv::Op::OpSource) { spvtools::Error(spvtools::utils::CLIMessageConsumer, "", loc, "OpSourceContinued MUST follow an OpSource."); return SPV_ERROR_INVALID_BINARY; } assert(sources.size() > 0); result = extractOpSourceContinued(loc, instruction, &sources.back().second); } ++instructionIndex; lastOpcode = static_cast(instruction.opcode); return result; }; if (!context.Parse(binary, headerParser, instructionParser)) { return false; } std::string defaultName = "unnamed-"; size_t unnamedCount = 0; for (auto & [ id, code ] : sources) { std::string filename; const auto it = stringMap.find(id); if (it == stringMap.cend() || it->second.empty()) { filename = "unnamed-" + std::to_string(unnamedCount) + ".hlsl"; ++unnamedCount; } else { filename = it->second; } if (output->count(filename) != 0) { spvtools::Error(spvtools::utils::CLIMessageConsumer, "", {}, "Source file name conflict."); return false; } output->insert({filename, code}); } return true; } KhronosGroup-SPIRV-Tools-f289d04/tools/objdump/extract_source.h000066400000000000000000000030371475742701700245370ustar00rootroot00000000000000// Copyright (c) 2023 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef INCLUDE_SPIRV_TOOLS_EXTRACT_SOURCE_HPP_ #define INCLUDE_SPIRV_TOOLS_EXTRACT_SOURCE_HPP_ #include #include #include #include // Parse a SPIR-V module, and extracts all HLSL source code from it. // This function doesn't lift the SPIR-V code, but only relies on debug symbols. // This means if the compiler didn't include some files, they won't show up. // // Returns a map of extracted from it. // - `binary`: a vector containing the whole SPIR-V binary to extract source // from. // - `output`: mapping, mapping each filename // (if defined) to its code. // // Returns `true` if the extraction succeeded, `false` otherwise. // `output` value is undefined if `false` is returned. bool ExtractSourceFromModule( const std::vector& binary, std::unordered_map* output); #endif // INCLUDE_SPIRV_TOOLS_EXTRACT_SOURCE_HPP_ KhronosGroup-SPIRV-Tools-f289d04/tools/objdump/objdump.cpp000066400000000000000000000135551475742701700235060ustar00rootroot00000000000000// Copyright (c) 2023 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "extract_source.h" #include "source/opt/log.h" #include "tools/io.h" #include "tools/util/cli_consumer.h" #include "tools/util/flags.h" namespace { constexpr auto kHelpTextFmt = R"(%s - Dumps information from a SPIR-V binary. Usage: %s [options] one of the following switches must be given: --source Extract source files obtained from debug symbols, output to stdout. --entrypoint Extracts the entrypoint name of the module, output to stdout. --compiler-cmd Extracts the command line used to compile this module, output to stdout. General options: -h, --help Print this help. --version Display assembler version information. -f,--force Allow output file overwrite. Source dump options: --list Do not extract source code, only print filenames to stdout. --outdir Where shall the exrtacted HLSL/HLSL files be written to? File written to stdout if '-' is given. Default is `-`. )"; // Removes trailing '/' from `input`. // A behavior difference has been observed between libc++ implementations. // Fixing path to prevent this edge case to be reached. // (https://github.com/llvm/llvm-project/issues/60634) std::string fixPathForLLVM(std::string input) { while (!input.empty() && input.back() == '/') input.resize(input.size() - 1); return input; } // Write each HLSL file described in `sources` in a file in `outdirPath`. // Doesn't ovewrite existing files, unless `overwrite` is set to true. The // created HLSL file's filename is the path's filename obtained from `sources`. // Returns true if all files could be written. False otherwise. bool OutputSourceFiles( const std::unordered_map& sources, const std::string& outdirPath, bool overwrite) { std::filesystem::path outdir(fixPathForLLVM(outdirPath)); if (!std::filesystem::is_directory(outdir)) { if (!std::filesystem::create_directories(outdir)) { std::cerr << "error: could not create output directory " << outdir << std::endl; return false; } } for (const auto & [ filepath, code ] : sources) { if (code.empty()) { std::cout << "Ignoring source for " << filepath << ": no code source in debug infos." << std::endl; continue; } std::filesystem::path old_path(filepath); std::filesystem::path new_path = outdir / old_path.filename(); if (!overwrite && std::filesystem::exists(new_path)) { std::cerr << "file " << filepath << " already exists, aborting (use --overwrite to allow it)." << std::endl; return false; } std::cout << "Exporting " << new_path << std::endl; if (!WriteFile(new_path.string().c_str(), "w", code.c_str(), code.size())) { return false; } } return true; } } // namespace // clang-format off FLAG_SHORT_bool( h, /* default_value= */ false, /* required= */ false); FLAG_LONG_bool( help, /* default_value= */ false, /* required= */ false); FLAG_LONG_bool( version, /* default_value= */ false, /* required= */ false); FLAG_LONG_bool( source, /* default_value= */ false, /* required= */ false); FLAG_LONG_bool( entrypoint, /* default_value= */ false, /* required= */ false); FLAG_LONG_bool( compiler_cmd, /* default_value= */ false, /* required= */ false); FLAG_SHORT_bool( f, /* default_value= */ false, /* required= */ false); FLAG_LONG_bool( force, /* default_value= */ false, /* required= */ false); FLAG_LONG_string( outdir, /* default_value= */ "-", /* required= */ false); FLAG_LONG_bool( list, /* default_value= */ false, /* required= */ false); // clang-format on int main(int, const char** argv) { if (!flags::Parse(argv)) { return 1; } if (flags::h.value() || flags::help.value()) { printf(kHelpTextFmt, argv[0], argv[0]); return 0; } if (flags::version.value()) { printf("%s\n", spvSoftwareVersionDetailsString()); return 0; } if (flags::positional_arguments.size() != 1) { std::cerr << "Expected exactly one input file." << std::endl; return 1; } if (flags::entrypoint.value() || flags::compiler_cmd.value()) { std::cerr << "Unimplemented flags." << std::endl; return 1; } std::vector binary; if (!ReadBinaryFile(flags::positional_arguments[0].c_str(), &binary)) { return 1; } if (flags::source.value()) { std::unordered_map sourceCode; if (!ExtractSourceFromModule(binary, &sourceCode)) { return 1; } if (flags::list.value()) { for (const auto & [ filename, source ] : sourceCode) { printf("%s\n", filename.c_str()); } return 0; } const bool outputToConsole = flags::outdir.value() == "-"; if (outputToConsole) { for (const auto & [ filename, source ] : sourceCode) { std::cout << filename << ":" << std::endl << source << std::endl << std::endl; } return 0; } const std::filesystem::path outdirPath(flags::outdir.value()); if (!OutputSourceFiles(sourceCode, outdirPath.string(), flags::force.value())) { return 1; } } // FIXME: implement logic. return 0; } KhronosGroup-SPIRV-Tools-f289d04/tools/opt/000077500000000000000000000000001475742701700204735ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/tools/opt/opt.cpp000066400000000000000000001135561475742701700220140ustar00rootroot00000000000000// Copyright (c) 2016 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include #include #include #include #include #include #include "source/opt/log.h" #include "source/spirv_target_env.h" #include "source/util/string_utils.h" #include "spirv-tools/libspirv.hpp" #include "spirv-tools/optimizer.hpp" #include "tools/io.h" #include "tools/util/cli_consumer.h" namespace { // Status and actions to perform after parsing command-line arguments. enum OptActions { OPT_CONTINUE, OPT_STOP }; struct OptStatus { OptActions action; int code; }; // Message consumer for this tool. Used to emit diagnostics during // initialization and setup. Note that |source| and |position| are irrelevant // here because we are still not processing a SPIR-V input file. void opt_diagnostic(spv_message_level_t level, const char* /*source*/, const spv_position_t& /*position*/, const char* message) { if (level == SPV_MSG_ERROR) { fprintf(stderr, "error: "); } fprintf(stderr, "%s\n", message); } std::string GetListOfPassesAsString(const spvtools::Optimizer& optimizer) { std::stringstream ss; for (const auto& name : optimizer.GetPassNames()) { ss << "\n\t\t" << name; } return ss.str(); } const auto kDefaultEnvironment = SPV_ENV_UNIVERSAL_1_6; std::string GetLegalizationPasses() { spvtools::Optimizer optimizer(kDefaultEnvironment); optimizer.RegisterLegalizationPasses(); return GetListOfPassesAsString(optimizer); } std::string GetOptimizationPasses() { spvtools::Optimizer optimizer(kDefaultEnvironment); optimizer.RegisterPerformancePasses(); return GetListOfPassesAsString(optimizer); } std::string GetSizePasses() { spvtools::Optimizer optimizer(kDefaultEnvironment); optimizer.RegisterSizePasses(); return GetListOfPassesAsString(optimizer); } void PrintUsage(const char* program) { std::string target_env_list = spvTargetEnvList(16, 80); // NOTE: Please maintain flags in lexicographical order. printf( R"(%s - Optimize a SPIR-V binary file. USAGE: %s [options] [] -o The SPIR-V binary is read from . If no file is specified, or if is "-", then the binary is read from standard input. if is "-", then the optimized output is written to standard output. NOTE: The optimizer is a work in progress. Options (in lexicographical order):)", program, program); printf(R"( --amd-ext-to-khr Replaces the extensions VK_AMD_shader_ballot, VK_AMD_gcn_shader, and VK_AMD_shader_trinary_minmax with equivalent code using core instructions and capabilities.)"); printf(R"( --before-hlsl-legalization Forwards this option to the validator. See the validator help for details.)"); printf(R"( --ccp Apply the conditional constant propagation transform. This will propagate constant values throughout the program, and simplify expressions and conditional jumps with known predicate values. Performed on entry point call tree functions and exported functions.)"); printf(R"( --cfg-cleanup Cleanup the control flow graph. This will remove any unnecessary code from the CFG like unreachable code. Performed on entry point call tree functions and exported functions.)"); printf(R"( --combine-access-chains Combines chained access chains to produce a single instruction where possible.)"); printf(R"( --compact-ids Remap result ids to a compact range starting from %%1 and without any gaps.)"); printf(R"( --convert-local-access-chains Convert constant index access chain loads/stores into equivalent load/stores with inserts and extracts. Performed on function scope variables referenced only with load, store, and constant index access chains in entry point call tree functions.)"); printf(R"( --convert-relaxed-to-half Convert all RelaxedPrecision arithmetic operations to half precision, inserting conversion operations where needed. Run after function scope variable load and store elimination for better results. Simplify-instructions, redundancy-elimination and DCE should be run after this pass to eliminate excess conversions. This conversion is useful when the target platform does not support RelaxedPrecision or ignores it. This pass also removes all RelaxedPrecision decorations.)"); printf(R"( --convert-to-sampled-image ": ..." convert images and/or samplers with the given pairs of descriptor set and binding to sampled images. If a pair of an image and a sampler have the same pair of descriptor set and binding that is one of the given pairs, they will be converted to a sampled image. In addition, if only an image or a sampler has the descriptor set and binding that is one of the given pairs, it will be converted to a sampled image.)"); printf(R"( --copy-propagate-arrays Does propagation of memory references when an array is a copy of another. It will only propagate an array if the source is never written to, and the only store to the target is the copy.)"); printf(R"( --replace-desc-array-access-using-var-index Replaces accesses to descriptor arrays based on a variable index with a switch that has a case for every possible value of the index.)"); printf(R"( --spread-volatile-semantics Spread Volatile semantics to variables with SMIDNV, WarpIDNV, SubgroupSize, SubgroupLocalInvocationId, SubgroupEqMask, SubgroupGeMask, SubgroupGtMask, SubgroupLeMask, or SubgroupLtMask BuiltIn decorations or OpLoad for them when the shader model is ray generation, closest hit, miss, intersection, or callable. For the SPIR-V version is 1.6 or above, it also spreads Volatile semantics to a variable with HelperInvocation BuiltIn decoration in the fragement shader.)"); printf(R"( --descriptor-scalar-replacement Replaces every array variable |desc| that has a DescriptorSet and Binding decorations with a new variable for each element of the array. Suppose |desc| was bound at binding |b|. Then the variable corresponding to |desc[i]| will have binding |b+i|. The descriptor set will be the same. All accesses to |desc| must be in OpAccessChain instructions with a literal index for the first index.)"); printf(R"( --descriptor-composite-scalar-replacement Same as descriptor-scalar-replacement, but only impacts composite/structs. For details, see --descriptor-scalar-replacement help.)"); printf(R"( --descriptor-array-scalar-replacement Same as descriptor-scalar-replacement, but only impacts arrays. For details, see --descriptor-scalar-replacement help.)"); printf(R"( --eliminate-dead-branches Convert conditional branches with constant condition to the indicated unconditional branch. Delete all resulting dead code. Performed only on entry point call tree functions.)"); printf(R"( --eliminate-dead-code-aggressive Delete instructions which do not contribute to a function's output. Performed only on entry point call tree functions.)"); printf(R"( --eliminate-dead-const Eliminate dead constants.)"); printf(R"( --eliminate-dead-functions Deletes functions that cannot be reached from entry points or exported functions.)"); printf(R"( --eliminate-dead-inserts Deletes unreferenced inserts into composites, most notably unused stores to vector components, that are not removed by aggressive dead code elimination.)"); printf(R"( --eliminate-dead-input-components Deletes unused components from input variables. Currently deletes trailing unused elements from input arrays.)"); printf(R"( --eliminate-dead-variables Deletes module scope variables that are not referenced.)"); printf(R"( --eliminate-insert-extract DEPRECATED. This pass has been replaced by the simplification pass, and that pass will be run instead. See --simplify-instructions.)"); printf(R"( --eliminate-local-multi-store Replace stores and loads of function scope variables that are stored multiple times. Performed on variables referenceed only with loads and stores. Performed only on entry point call tree functions.)"); printf(R"( --eliminate-local-single-block Perform single-block store/load and load/load elimination. Performed only on function scope variables in entry point call tree functions.)"); printf(R"( --eliminate-local-single-store Replace stores and loads of function scope variables that are only stored once. Performed on variables referenceed only with loads and stores. Performed only on entry point call tree functions.)"); printf(R"( --fix-func-call-param fix non memory argument for the function call, replace accesschain pointer argument with a variable.)"); printf(R"( --flatten-decorations Replace decoration groups with repeated OpDecorate and OpMemberDecorate instructions.)"); printf(R"( --fold-spec-const-op-composite Fold the spec constants defined by OpSpecConstantOp or OpSpecConstantComposite instructions to front-end constants when possible.)"); printf(R"( --freeze-spec-const Freeze the values of specialization constants to their default values.)"); printf(R"( --graphics-robust-access Clamp indices used to access buffers and internal composite values, providing guarantees that satisfy Vulkan's robustBufferAccess rules.)"); printf(R"( --if-conversion Convert if-then-else like assignments into OpSelect.)"); printf(R"( --inline-entry-points-exhaustive Exhaustively inline all function calls in entry point call tree functions. Currently does not inline calls to functions with early return in a loop.)"); printf(R"( --legalize-hlsl Runs a series of optimizations that attempts to take SPIR-V generated by an HLSL front-end and generates legal Vulkan SPIR-V. The optimizations are: %s Note this does not guarantee legal code. This option passes the option --relax-logical-pointer to the validator.)", GetLegalizationPasses().c_str()); printf(R"( --local-redundancy-elimination Looks for instructions in the same basic block that compute the same value, and deletes the redundant ones.)"); printf(R"( --loop-fission Splits any top level loops in which the register pressure has exceeded a given threshold. The threshold must follow the use of this flag and must be a positive integer value.)"); printf(R"( --loop-fusion Identifies adjacent loops with the same lower and upper bound. If this is legal, then merge the loops into a single loop. Includes heuristics to ensure it does not increase number of registers too much, while reducing the number of loads from memory. Takes an additional positive integer argument to set the maximum number of registers.)"); printf(R"( --loop-invariant-code-motion Identifies code in loops that has the same value for every iteration of the loop, and move it to the loop pre-header.)"); printf(R"( --loop-unroll Fully unrolls loops marked with the Unroll flag)"); printf(R"( --loop-unroll-partial Partially unrolls loops marked with the Unroll flag. Takes an additional non-0 integer argument to set the unroll factor, or how many times a loop body should be duplicated)"); printf(R"( --loop-peeling Execute few first (respectively last) iterations before (respectively after) the loop if it can elide some branches.)"); printf(R"( --loop-peeling-threshold Takes a non-0 integer argument to set the loop peeling code size growth threshold. The threshold prevents the loop peeling from happening if the code size increase created by the optimization is above the threshold.)"); printf(R"( --max-id-bound= Sets the maximum value for the id bound for the module. The default is the minimum value for this limit, 0x3FFFFF. See section 2.17 of the Spir-V specification.)"); printf(R"( --merge-blocks Join two blocks into a single block if the second has the first as its only predecessor. Performed only on entry point call tree functions.)"); printf(R"( --merge-return Changes functions that have multiple return statements so they have a single return statement. For structured control flow it is assumed that the only unreachable blocks in the function are trivial merge and continue blocks. A trivial merge block contains the label and an OpUnreachable instructions, nothing else. A trivial continue block contain a label and an OpBranch to the header, nothing else. These conditions are guaranteed to be met after running dead-branch elimination.)"); printf(R"( --modify-maximal-reconvergence=[add|remove] Add or remove the MaximallyReconvergesKHR execution mode to all entry points in the module. Note: when adding the execution mode, no attempt is made to determine if any ray tracing repack instructions are used.)"); printf(R"( --loop-unswitch Hoists loop-invariant conditionals out of loops by duplicating the loop on each branch of the conditional and adjusting each copy of the loop.)"); printf(R"( -O Optimize for performance. Apply a sequence of transformations in an attempt to improve the performance of the generated code. For this version of the optimizer, this flag is equivalent to specifying the following optimization code names: %s)", GetOptimizationPasses().c_str()); printf(R"( -Os Optimize for size. Apply a sequence of transformations in an attempt to minimize the size of the generated code. For this version of the optimizer, this flag is equivalent to specifying the following optimization code names: %s NOTE: The specific transformations done by -O and -Os change from release to release.)", GetSizePasses().c_str()); printf(R"( -Oconfig= Apply the sequence of transformations indicated in . This file contains a sequence of strings separated by whitespace (tabs, newlines or blanks). Each string is one of the flags accepted by spirv-opt. Optimizations will be applied in the sequence they appear in the file. This is equivalent to specifying all the flags on the command line. For example, given the file opts.cfg with the content: --inline-entry-points-exhaustive --eliminate-dead-code-aggressive The following two invocations to spirv-opt are equivalent: $ spirv-opt -Oconfig=opts.cfg program.spv $ spirv-opt --inline-entry-points-exhaustive \ --eliminate-dead-code-aggressive program.spv Lines starting with the character '#' in the configuration file indicate a comment and will be ignored. The -O, -Os, and -Oconfig flags act as macros. Using one of them is equivalent to explicitly inserting the underlying flags at that position in the command line. For example, the invocation 'spirv-opt --merge-blocks -O ...' applies the transformation --merge-blocks followed by all the transformations implied by -O.)"); printf(R"( --preserve-bindings Ensure that the optimizer preserves all bindings declared within the module, even when those bindings are unused.)"); printf(R"( --preserve-interface Ensure that input and output variables are not removed from the shader, even if they are unused. Note that this option applies to all passes that will be run regardless of the order of the flags.)"); printf(R"( --preserve-spec-constants Ensure that the optimizer preserves all specialization constants declared within the module, even when those constants are unused.)"); printf(R"( --print-all Print SPIR-V assembly to standard error output before each pass and after the last pass.)"); printf(R"( --private-to-local Change the scope of private variables that are used in a single function to that function.)"); printf(R"( --reduce-load-size[=] Replaces loads of composite objects where not every component is used by loads of just the elements that are used. If the ratio of the used components of the load is less than the , we replace the load. is a double type number. If it is bigger than 1.0, we always replaces the load.)"); printf(R"( --redundancy-elimination Looks for instructions in the same function that compute the same value, and deletes the redundant ones.)"); printf(R"( --relax-block-layout Forwards this option to the validator. See the validator help for details.)"); printf(R"( --relax-float-ops Decorate all float operations with RelaxedPrecision if not already so decorated. This does not decorate types or variables.)"); printf(R"( --relax-logical-pointer Forwards this option to the validator. See the validator help for details.)"); printf(R"( --relax-struct-store Forwards this option to the validator. See the validator help for details.)"); printf(R"( --remove-duplicates Removes duplicate types, decorations, capabilities and extension instructions.)"); printf(R"( --remove-unused-interface-variables Removes variables referenced on the |OpEntryPoint| instruction that are not referenced in the entry point function or any function in its call tree. Note that this could cause the shader interface to no longer match other shader stages.)"); printf(R"( --replace-invalid-opcode Replaces instructions whose opcode is valid for shader modules, but not for the current shader stage. To have an effect, all entry points must have the same execution model.)"); printf(R"( --ssa-rewrite Replace loads and stores to function local variables with operations on SSA IDs.)"); printf(R"( --scalar-block-layout Forwards this option to the validator. See the validator help for details.)"); printf(R"( --scalar-replacement[=] Replace aggregate function scope variables that are only accessed via their elements with new function variables representing each element. is a limit on the size of the aggregates that will be replaced. 0 means there is no limit. The default value is 100.)"); printf(R"( --set-spec-const-default-value ": ..." Set the default values of the specialization constants with : pairs specified in a double-quoted string. : pairs must be separated by blank spaces, and in each pair, spec id and default value must be separated with colon ':' without any blank spaces in between. e.g.: --set-spec-const-default-value "1:100 2:400")"); printf(R"( --simplify-instructions Will simplify all instructions in the function as much as possible.)"); printf(R"( --skip-block-layout Forwards this option to the validator. See the validator help for details.)"); printf(R"( --skip-validation Will not validate the SPIR-V before optimizing. If the SPIR-V is invalid, the optimizer may fail or generate incorrect code. This options should be used rarely, and with caution.)"); printf(R"( --strength-reduction Replaces instructions with equivalent and less expensive ones.)"); printf(R"( --strip-debug Remove all debug instructions.)"); printf(R"( --strip-nonsemantic Remove all reflection and nonsemantic information.)"); printf(R"( --strip-reflect DEPRECATED. Remove all reflection information. For now, this covers reflection information defined by SPV_GOOGLE_hlsl_functionality1 and SPV_KHR_non_semantic_info)"); printf(R"( --struct-packing=name:rule Re-assign layout offsets to a given struct according to its packing rules.)"); printf(R"( --switch-descriptorset=: Switch any DescriptoSet decorations using the value to the new value .)"); printf(R"( --target-env= Set the target environment. Without this flag the target environment defaults to spv1.5. must be one of {%s})", target_env_list.c_str()); printf(R"( --time-report Print the resource utilization of each pass (e.g., CPU time, RSS) to standard error output. Currently it supports only Unix systems. This option is the same as -ftime-report in GCC. It prints CPU/WALL/USR/SYS time (and RSS if possible), but note that USR/SYS time are returned by getrusage() and can have a small error.)"); printf(R"( --trim-capabilities Remove unnecessary capabilities and extensions declared within the module.)"); printf(R"( --upgrade-memory-model Upgrades the Logical GLSL450 memory model to Logical VulkanKHR. Transforms memory, image, atomic and barrier operations to conform to that model's requirements.)"); printf(R"( --vector-dce This pass looks for components of vectors that are unused, and removes them from the vector. Note this would still leave around lots of dead code that a pass of ADCE will be able to remove.)"); printf(R"( --workaround-1209 Rewrites instructions for which there are known driver bugs to avoid triggering those bugs. Current workarounds: Avoid OpUnreachable in loops.)"); printf(R"( --workgroup-scalar-block-layout Forwards this option to the validator. See the validator help for details.)"); printf(R"( --wrap-opkill Replaces all OpKill instructions in functions that can be called from a continue construct with a function call to a function whose only instruction is an OpKill. This is done to enable inlining on these functions. )"); printf(R"( --unify-const Remove the duplicated constants.)"); printf(R"( --validate-after-all Validate the module after each pass is performed.)"); printf(R"( -h, --help Print this help.)"); printf(R"( --version Display optimizer version information. )"); } // Reads command-line flags the file specified in |oconfig_flag|. This string // is assumed to have the form "-Oconfig=FILENAME". This function parses the // string and extracts the file name after the '=' sign. // // Flags found in |FILENAME| are pushed at the end of the vector |file_flags|. // // This function returns true on success, false on failure. bool ReadFlagsFromFile(const char* oconfig_flag, std::vector* file_flags) { const char* fname = strchr(oconfig_flag, '='); if (fname == nullptr || fname[0] != '=') { spvtools::Errorf(opt_diagnostic, nullptr, {}, "Invalid -Oconfig flag %s", oconfig_flag); return false; } fname++; std::ifstream input_file; input_file.open(fname); if (input_file.fail()) { spvtools::Errorf(opt_diagnostic, nullptr, {}, "Could not open file '%s'", fname); return false; } std::string line; while (std::getline(input_file, line)) { // Ignore empty lines and lines starting with the comment marker '#'. if (line.length() == 0 || line[0] == '#') { continue; } // Tokenize the line. Add all found tokens to the list of found flags. This // mimics the way the shell will parse whitespace on the command line. NOTE: // This does not support quoting and it is not intended to. std::istringstream iss(line); while (!iss.eof()) { std::string flag; iss >> flag; file_flags->push_back(flag); } } return true; } OptStatus ParseFlags(int argc, const char** argv, spvtools::Optimizer* optimizer, const char** in_file, const char** out_file, spvtools::ValidatorOptions* validator_options, spvtools::OptimizerOptions* optimizer_options); // Parses and handles the -Oconfig flag. |prog_name| contains the name of // the spirv-opt binary (used to build a new argv vector for the recursive // invocation to ParseFlags). |opt_flag| contains the -Oconfig=FILENAME flag. // |optimizer|, |in_file|, |out_file|, |validator_options|, and // |optimizer_options| are as in ParseFlags. // // This returns the same OptStatus instance returned by ParseFlags. OptStatus ParseOconfigFlag(const char* prog_name, const char* opt_flag, spvtools::Optimizer* optimizer, const char** in_file, const char** out_file, spvtools::ValidatorOptions* validator_options, spvtools::OptimizerOptions* optimizer_options) { std::vector flags; flags.push_back(prog_name); std::vector file_flags; if (!ReadFlagsFromFile(opt_flag, &file_flags)) { spvtools::Error(opt_diagnostic, nullptr, {}, "Could not read optimizer flags from configuration file"); return {OPT_STOP, 1}; } flags.insert(flags.end(), file_flags.begin(), file_flags.end()); const char** new_argv = new const char*[flags.size()]; for (size_t i = 0; i < flags.size(); i++) { if (flags[i].find("-Oconfig=") != std::string::npos) { spvtools::Error( opt_diagnostic, nullptr, {}, "Flag -Oconfig= may not be used inside the configuration file"); return {OPT_STOP, 1}; } new_argv[i] = flags[i].c_str(); } auto ret_val = ParseFlags(static_cast(flags.size()), new_argv, optimizer, in_file, out_file, validator_options, optimizer_options); delete[] new_argv; return ret_val; } // Canonicalize the flag in |argv[argi]| of the form '--pass arg' into // '--pass=arg'. The optimizer only accepts arguments to pass names that use the // form '--pass_name=arg'. Since spirv-opt also accepts the other form, this // function makes the necessary conversion. // // Pass flags that require additional arguments should be handled here. Note // that additional arguments should be given as a single string. If the flag // requires more than one argument, the pass creator in // Optimizer::GetPassFromFlag() should parse it accordingly (e.g., see the // handler for --set-spec-const-default-value). // // If the argument requests one of the passes that need an additional argument, // |argi| is modified to point past the current argument, and the string // "argv[argi]=argv[argi + 1]" is returned. Otherwise, |argi| is unmodified and // the string "|argv[argi]|" is returned. std::string CanonicalizeFlag(const char** argv, int argc, int* argi) { const char* cur_arg = argv[*argi]; const char* next_arg = (*argi + 1 < argc) ? argv[*argi + 1] : nullptr; std::ostringstream canonical_arg; canonical_arg << cur_arg; // NOTE: DO NOT ADD NEW FLAGS HERE. // // These flags are supported for backwards compatibility. When adding new // passes that need extra arguments in its command-line flag, please make them // use the syntax "--pass_name[=pass_arg]. if (0 == strcmp(cur_arg, "--set-spec-const-default-value") || 0 == strcmp(cur_arg, "--loop-fission") || 0 == strcmp(cur_arg, "--loop-fusion") || 0 == strcmp(cur_arg, "--loop-unroll-partial") || 0 == strcmp(cur_arg, "--loop-peeling-threshold")) { if (next_arg) { canonical_arg << "=" << next_arg; ++(*argi); } } return canonical_arg.str(); } // Parses command-line flags. |argc| contains the number of command-line flags. // |argv| points to an array of strings holding the flags. |optimizer| is the // Optimizer instance used to optimize the program. // // On return, this function stores the name of the input program in |in_file|. // The name of the output file in |out_file|. The return value indicates whether // optimization should continue and a status code indicating an error or // success. OptStatus ParseFlags(int argc, const char** argv, spvtools::Optimizer* optimizer, const char** in_file, const char** out_file, spvtools::ValidatorOptions* validator_options, spvtools::OptimizerOptions* optimizer_options) { std::vector pass_flags; bool preserve_interface = true; for (int argi = 1; argi < argc; ++argi) { const char* cur_arg = argv[argi]; if ('-' == cur_arg[0]) { if (0 == strcmp(cur_arg, "--version")) { spvtools::Logf(opt_diagnostic, SPV_MSG_INFO, nullptr, {}, "%s\n", spvSoftwareVersionDetailsString()); return {OPT_STOP, 0}; } else if (0 == strcmp(cur_arg, "--help") || 0 == strcmp(cur_arg, "-h")) { PrintUsage(argv[0]); return {OPT_STOP, 0}; } else if (0 == strcmp(cur_arg, "-o")) { if (!*out_file && argi + 1 < argc) { *out_file = argv[++argi]; } else { PrintUsage(argv[0]); return {OPT_STOP, 1}; } } else if ('\0' == cur_arg[1]) { // Setting a filename of "-" to indicate stdin. if (!*in_file) { *in_file = cur_arg; } else { spvtools::Error(opt_diagnostic, nullptr, {}, "More than one input file specified"); return {OPT_STOP, 1}; } } else if (0 == strncmp(cur_arg, "-Oconfig=", sizeof("-Oconfig=") - 1)) { OptStatus status = ParseOconfigFlag(argv[0], cur_arg, optimizer, in_file, out_file, validator_options, optimizer_options); if (status.action != OPT_CONTINUE) { return status; } } else if (0 == strcmp(cur_arg, "--skip-validation")) { optimizer_options->set_run_validator(false); } else if (0 == strcmp(cur_arg, "--print-all")) { optimizer->SetPrintAll(&std::cerr); } else if (0 == strcmp(cur_arg, "--preserve-bindings")) { optimizer_options->set_preserve_bindings(true); } else if (0 == strcmp(cur_arg, "--preserve-spec-constants")) { optimizer_options->set_preserve_spec_constants(true); } else if (0 == strcmp(cur_arg, "--time-report")) { optimizer->SetTimeReport(&std::cerr); } else if (0 == strcmp(cur_arg, "--relax-struct-store")) { validator_options->SetRelaxStructStore(true); } else if (0 == strncmp(cur_arg, "--max-id-bound=", sizeof("--max-id-bound=") - 1)) { auto split_flag = spvtools::utils::SplitFlagArgs(cur_arg); // Will not allow values in the range [2^31,2^32). uint32_t max_id_bound = static_cast(atoi(split_flag.second.c_str())); // That SPIR-V mandates the minimum value for max id bound but // implementations may allow higher minimum bounds. if (max_id_bound < kDefaultMaxIdBound) { spvtools::Error(opt_diagnostic, nullptr, {}, "The max id bound must be at least 0x3FFFFF"); return {OPT_STOP, 1}; } optimizer_options->set_max_id_bound(max_id_bound); validator_options->SetUniversalLimit(spv_validator_limit_max_id_bound, max_id_bound); } else if (0 == strncmp(cur_arg, "--target-env=", sizeof("--target-env=") - 1)) { const auto split_flag = spvtools::utils::SplitFlagArgs(cur_arg); const auto target_env_str = split_flag.second.c_str(); spv_target_env target_env; if (!spvParseTargetEnv(target_env_str, &target_env)) { spvtools::Error(opt_diagnostic, nullptr, {}, "Invalid value passed to --target-env"); return {OPT_STOP, 1}; } optimizer->SetTargetEnv(target_env); } else if (0 == strcmp(cur_arg, "--validate-after-all")) { optimizer->SetValidateAfterAll(true); } else if (0 == strcmp(cur_arg, "--before-hlsl-legalization")) { validator_options->SetBeforeHlslLegalization(true); } else if (0 == strcmp(cur_arg, "--relax-logical-pointer")) { validator_options->SetRelaxLogicalPointer(true); } else if (0 == strcmp(cur_arg, "--relax-block-layout")) { validator_options->SetRelaxBlockLayout(true); } else if (0 == strcmp(cur_arg, "--scalar-block-layout")) { validator_options->SetScalarBlockLayout(true); } else if (0 == strcmp(cur_arg, "--workgroup-scalar-block-layout")) { validator_options->SetWorkgroupScalarBlockLayout(true); } else if (0 == strcmp(cur_arg, "--skip-block-layout")) { validator_options->SetSkipBlockLayout(true); } else if (0 == strcmp(cur_arg, "--relax-struct-store")) { validator_options->SetRelaxStructStore(true); } else if (0 == strcmp(cur_arg, "--preserve-interface")) { preserve_interface = true; } else { // Some passes used to accept the form '--pass arg', canonicalize them // to '--pass=arg'. pass_flags.push_back(CanonicalizeFlag(argv, argc, &argi)); // If we were requested to legalize SPIR-V generated from the HLSL // front-end, skip validation. if (0 == strcmp(cur_arg, "--legalize-hlsl")) { validator_options->SetBeforeHlslLegalization(true); } } } else { if (!*in_file) { *in_file = cur_arg; } else { spvtools::Error(opt_diagnostic, nullptr, {}, "More than one input file specified"); return {OPT_STOP, 1}; } } } if (!optimizer->RegisterPassesFromFlags(pass_flags, preserve_interface)) { return {OPT_STOP, 1}; } return {OPT_CONTINUE, 0}; } } // namespace int main(int argc, const char** argv) { const char* in_file = nullptr; const char* out_file = nullptr; spv_target_env target_env = kDefaultEnvironment; spvtools::Optimizer optimizer(target_env); optimizer.SetMessageConsumer(spvtools::utils::CLIMessageConsumer); spvtools::ValidatorOptions validator_options; spvtools::OptimizerOptions optimizer_options; OptStatus status = ParseFlags(argc, argv, &optimizer, &in_file, &out_file, &validator_options, &optimizer_options); optimizer_options.set_validator_options(validator_options); if (status.action == OPT_STOP) { return status.code; } if (out_file == nullptr) { spvtools::Error(opt_diagnostic, nullptr, {}, "-o required"); return 1; } std::vector binary; if (!ReadBinaryFile(in_file, &binary)) { return 1; } // By using the same vector as input and output, we save time in the case // that there was no change. bool ok = optimizer.Run(binary.data(), binary.size(), &binary, optimizer_options); if (!WriteFile(out_file, "wb", binary.data(), binary.size())) { return 1; } return ok ? 0 : 1; } KhronosGroup-SPIRV-Tools-f289d04/tools/reduce/000077500000000000000000000000001475742701700211405ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/tools/reduce/reduce.cpp000066400000000000000000000333331475742701700231200ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include #include #include #include "source/opt/build_module.h" #include "source/opt/ir_context.h" #include "source/opt/log.h" #include "source/reduce/reducer.h" #include "source/spirv_reducer_options.h" #include "source/util/string_utils.h" #include "tools/io.h" #include "tools/util/cli_consumer.h" namespace { // Execute a command using the shell. // Returns true if and only if the command's exit status was 0. bool ExecuteCommand(const std::string& command) { errno = 0; int status = std::system(command.c_str()); assert(errno == 0 && "failed to execute command"); // The result returned by 'system' is implementation-defined, but is // usually the case that the returned value is 0 when the command's exit // code was 0. We are assuming that here, and that's all we depend on. return status == 0; } // Status and actions to perform after parsing command-line arguments. enum ReduceActions { REDUCE_CONTINUE, REDUCE_STOP }; struct ReduceStatus { ReduceActions action; int code; }; void PrintUsage(const char* program) { // NOTE: Please maintain flags in lexicographical order. printf( R"(%s - Reduce a SPIR-V binary file with respect to a user-provided interestingness test. USAGE: %s [options] -o -- [args...] The SPIR-V binary is read from . The reduced SPIR-V binary is written to . Whether a binary is interesting is determined by , which should be the path to a script. The "--" characters are optional but denote that all arguments that follow are positional arguments and thus will be forwarded to the interestingness test, and not parsed by %s. * The script must be executable. * The script should take the path to a SPIR-V binary file (.spv) as an argument, and exit with code 0 if and only if the binary file is interesting. The binary will be passed to the script as an argument after any other provided arguments [args...]. * Example: an interestingness test for reducing a SPIR-V binary file that causes tool "foo" to exit with error code 1 and print "Fatal error: bar" to standard error should: - invoke "foo" on the binary passed as the script argument; - capture the return code and standard error from "bar"; - exit with code 0 if and only if the return code of "foo" was 1 and the standard error from "bar" contained "Fatal error: bar". * The reducer does not place a time limit on how long the interestingness test takes to run, so it is advisable to use per-command timeouts inside the script when invoking SPIR-V-processing tools (such as "foo" in the above example). NOTE: The reducer is a work in progress. Options (in lexicographical order): --fail-on-validation-error Stop reduction with an error if any reduction step produces a SPIR-V module that fails to validate. -h, --help Print this help. --step-limit= 32-bit unsigned integer specifying maximum number of steps the reducer will take before giving up. --target-function= 32-bit unsigned integer specifying the id of a function in the input module. The reducer will restrict attention to this function, and will not make changes to other functions or to instructions outside of functions, except that some global instructions may be added in support of reducing the target function. If 0 is specified (the default) then all functions are reduced. --temp-file-prefix= Specifies a temporary file prefix that will be used to output temporary shader files during reduction. A number and .spv extension will be added. The default is "temp_", which will cause files like "temp_0001.spv" to be output to the current directory. --version Display reducer version information. Supported validator options are as follows. See `spirv-val --help` for details. --before-hlsl-legalization --relax-block-layout --relax-logical-pointer --relax-struct-store --scalar-block-layout --skip-block-layout )", program, program, program); } // Message consumer for this tool. Used to emit diagnostics during // initialization and setup. Note that |source| and |position| are irrelevant // here because we are still not processing a SPIR-V input file. void ReduceDiagnostic(spv_message_level_t level, const char* /*source*/, const spv_position_t& /*position*/, const char* message) { if (level == SPV_MSG_ERROR) { fprintf(stderr, "error: "); } fprintf(stderr, "%s\n", message); } ReduceStatus ParseFlags(int argc, const char** argv, std::string* in_binary_file, std::string* out_binary_file, std::vector* interestingness_test, std::string* temp_file_prefix, spvtools::ReducerOptions* reducer_options, spvtools::ValidatorOptions* validator_options) { uint32_t positional_arg_index = 0; bool only_positional_arguments_remain = false; for (int argi = 1; argi < argc; ++argi) { const char* cur_arg = argv[argi]; if ('-' == cur_arg[0] && !only_positional_arguments_remain) { if (0 == strcmp(cur_arg, "--version")) { spvtools::Logf(ReduceDiagnostic, SPV_MSG_INFO, nullptr, {}, "%s\n", spvSoftwareVersionDetailsString()); return {REDUCE_STOP, 0}; } else if (0 == strcmp(cur_arg, "--help") || 0 == strcmp(cur_arg, "-h")) { PrintUsage(argv[0]); return {REDUCE_STOP, 0}; } else if (0 == strcmp(cur_arg, "-o")) { if (out_binary_file->empty() && argi + 1 < argc) { *out_binary_file = std::string(argv[++argi]); } else { PrintUsage(argv[0]); return {REDUCE_STOP, 1}; } } else if (0 == strncmp(cur_arg, "--step-limit=", sizeof("--step-limit=") - 1)) { const auto split_flag = spvtools::utils::SplitFlagArgs(cur_arg); char* end = nullptr; errno = 0; const auto step_limit = static_cast(strtol(split_flag.second.c_str(), &end, 10)); assert(end != split_flag.second.c_str() && errno == 0); reducer_options->set_step_limit(step_limit); } else if (0 == strncmp(cur_arg, "--target-function=", sizeof("--target-function=") - 1)) { const auto split_flag = spvtools::utils::SplitFlagArgs(cur_arg); char* end = nullptr; errno = 0; const auto target_function = static_cast(strtol(split_flag.second.c_str(), &end, 10)); assert(end != split_flag.second.c_str() && errno == 0); reducer_options->set_target_function(target_function); } else if (0 == strcmp(cur_arg, "--fail-on-validation-error")) { reducer_options->set_fail_on_validation_error(true); } else if (0 == strcmp(cur_arg, "--before-hlsl-legalization")) { validator_options->SetBeforeHlslLegalization(true); } else if (0 == strcmp(cur_arg, "--relax-logical-pointer")) { validator_options->SetRelaxLogicalPointer(true); } else if (0 == strcmp(cur_arg, "--relax-block-layout")) { validator_options->SetRelaxBlockLayout(true); } else if (0 == strcmp(cur_arg, "--scalar-block-layout")) { validator_options->SetScalarBlockLayout(true); } else if (0 == strcmp(cur_arg, "--skip-block-layout")) { validator_options->SetSkipBlockLayout(true); } else if (0 == strcmp(cur_arg, "--relax-struct-store")) { validator_options->SetRelaxStructStore(true); } else if (0 == strncmp(cur_arg, "--temp-file-prefix=", sizeof("--temp-file-prefix=") - 1)) { const auto split_flag = spvtools::utils::SplitFlagArgs(cur_arg); *temp_file_prefix = std::string(split_flag.second); } else if (0 == strcmp(cur_arg, "--")) { only_positional_arguments_remain = true; } else { std::stringstream ss; ss << "Unrecognized argument: " << cur_arg << std::endl; spvtools::Error(ReduceDiagnostic, nullptr, {}, ss.str().c_str()); PrintUsage(argv[0]); return {REDUCE_STOP, 1}; } } else if (positional_arg_index == 0) { // Binary input file name assert(in_binary_file->empty()); *in_binary_file = std::string(cur_arg); positional_arg_index++; } else { interestingness_test->push_back(std::string(cur_arg)); } } if (in_binary_file->empty()) { spvtools::Error(ReduceDiagnostic, nullptr, {}, "No input file specified"); return {REDUCE_STOP, 1}; } if (out_binary_file->empty()) { spvtools::Error(ReduceDiagnostic, nullptr, {}, "-o required"); return {REDUCE_STOP, 1}; } if (interestingness_test->empty()) { spvtools::Error(ReduceDiagnostic, nullptr, {}, "No interestingness test specified"); return {REDUCE_STOP, 1}; } return {REDUCE_CONTINUE, 0}; } } // namespace // Dumps |binary| to file |filename|. Useful for interactive debugging. void DumpShader(const std::vector& binary, const char* filename) { auto write_file_succeeded = WriteFile(filename, "wb", &binary[0], binary.size()); if (!write_file_succeeded) { std::cerr << "Failed to dump shader" << std::endl; } } // Dumps the SPIRV-V module in |context| to file |filename|. Useful for // interactive debugging. void DumpShader(spvtools::opt::IRContext* context, const char* filename) { std::vector binary; context->module()->ToBinary(&binary, false); DumpShader(binary, filename); } const auto kDefaultEnvironment = SPV_ENV_UNIVERSAL_1_6; int main(int argc, const char** argv) { std::string in_binary_file; std::string out_binary_file; std::vector interestingness_test; std::string temp_file_prefix = "temp_"; spv_target_env target_env = kDefaultEnvironment; spvtools::ReducerOptions reducer_options; spvtools::ValidatorOptions validator_options; ReduceStatus status = ParseFlags( argc, argv, &in_binary_file, &out_binary_file, &interestingness_test, &temp_file_prefix, &reducer_options, &validator_options); if (status.action == REDUCE_STOP) { return status.code; } spvtools::reduce::Reducer reducer(target_env); std::stringstream joined; joined << interestingness_test[0]; for (size_t i = 1, size = interestingness_test.size(); i < size; ++i) { joined << " " << interestingness_test[i]; } std::string interestingness_command_joined = joined.str(); reducer.SetInterestingnessFunction( [interestingness_command_joined, temp_file_prefix]( std::vector binary, uint32_t reductions_applied) -> bool { std::stringstream ss; ss << temp_file_prefix << std::setw(4) << std::setfill('0') << reductions_applied << ".spv"; const auto spv_file = ss.str(); const std::string command = interestingness_command_joined + " " + spv_file; auto write_file_succeeded = WriteFile(spv_file.c_str(), "wb", &binary[0], binary.size()); (void)(write_file_succeeded); assert(write_file_succeeded); return ExecuteCommand(command); }); reducer.AddDefaultReductionPasses(); reducer.SetMessageConsumer(spvtools::utils::CLIMessageConsumer); std::vector binary_in; if (!ReadBinaryFile(in_binary_file.c_str(), &binary_in)) { return 1; } const uint32_t target_function = (*reducer_options).target_function; if (target_function) { // A target function was specified; check that it exists. std::unique_ptr context = spvtools::BuildModule( kDefaultEnvironment, spvtools::utils::CLIMessageConsumer, binary_in.data(), binary_in.size()); bool found_target_function = false; for (auto& function : *context->module()) { if (function.result_id() == target_function) { found_target_function = true; break; } } if (!found_target_function) { std::stringstream strstr; strstr << "Target function with id " << target_function << " was requested, but not found in the module; stopping."; spvtools::utils::CLIMessageConsumer(SPV_MSG_ERROR, nullptr, {}, strstr.str().c_str()); return 1; } } std::vector binary_out; const auto reduction_status = reducer.Run(std::move(binary_in), &binary_out, reducer_options, validator_options); // Always try to write the output file, even if the reduction failed. if (!WriteFile(out_binary_file.c_str(), "wb", binary_out.data(), binary_out.size())) { return 1; } // These are the only successful statuses. switch (reduction_status) { case spvtools::reduce::Reducer::ReductionResultStatus::kComplete: case spvtools::reduce::Reducer::ReductionResultStatus::kReachedStepLimit: return 0; default: break; } return 1; } KhronosGroup-SPIRV-Tools-f289d04/tools/sva/000077500000000000000000000000001475742701700204625ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/tools/sva/.eslintrc.json000066400000000000000000000012021475742701700232510ustar00rootroot00000000000000{ "env": { "browser": true, "es6": true, "node": true, "mocha": true }, "extends": "eslint:recommended", "parserOptions": { "ecmaVersion": 2018, "sourceType": "module" }, "rules": { "block-scoped-var": "error", "consistent-return": "error", "eqeqeq": ["error", "always"], "indent": [ "error", 2 ], "linebreak-style": [ "error", "unix" ], "no-eval": "error", "no-shadow": "error", "no-shadow-restricted-names": "error", "quotes": [ "error", "double" ], "semi": [ "error", "always" ] } } KhronosGroup-SPIRV-Tools-f289d04/tools/sva/.gitignore000066400000000000000000000001141475742701700224460ustar00rootroot00000000000000.DS_Store node_modules third_party/spirv-headers o.sva build yarn-error.log KhronosGroup-SPIRV-Tools-f289d04/tools/sva/README.md000066400000000000000000000021301475742701700217350ustar00rootroot00000000000000# SVA SPIR-V Assembler for WebGPU. The SPIR-V Assembler is a JavaScript library to convert SPIR-V assembly (as produced by spirv-dis in SPIR-V Tools) into a SPIR-V binary. The assembler assumes it is generating WebGPU SPIR-V and thus has the following limitations. * Only 32 bit integers and floats supported * Only GLSL accepted as an extended instruction set * Doesn't support ! syntax for integers * Doesn't support hex encoding for float ```shell yarn install yarn test ``` You can also use `yarn watch` to watch all of the files and re-run tests as needed. ## Webserver Using `yarn serve` will start a webserver on localhost:5000. If you load the `tests/index.html` file this will load the SVA files into browser. ## Command Line There is a simple assembler binary with can be executed from the command line. ```shell yarn sva tests/simple.spv_asm ``` The above will generate a `o.sva` file in the current directory. ## Update spirv.data.json If there is a new spirv-headers release update the externals folder checkout and then: ```shell ./tools/process_grammar.rb > src/spirv.data.json ``` KhronosGroup-SPIRV-Tools-f289d04/tools/sva/bin/000077500000000000000000000000001475742701700212325ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/tools/sva/bin/sva.js000077500000000000000000000016421475742701700223670ustar00rootroot00000000000000#!/usr/bin/env node // // Copyright 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. "use strict"; const fs = require("fs"); import SVA from "../src/sva.js"; let input = fs.readFileSync(process.argv[2], "utf-8"); let u = SVA.assemble(input); if (typeof u === "string") { console.log(u); } else { fs.writeFileSync("o.sva", new Buffer(u.buffer), (err) => { console.log(["ERROR", err]); }); } KhronosGroup-SPIRV-Tools-f289d04/tools/sva/mocha.opts000066400000000000000000000000141475742701700224530ustar00rootroot00000000000000--recursive KhronosGroup-SPIRV-Tools-f289d04/tools/sva/package.json000066400000000000000000000012121475742701700227440ustar00rootroot00000000000000{ "name": "sva", "version": "0.1.0", "description": "SPIR-V Assembler", "main": "index.js", "author": "dan sinclair ", "license": "Apache-2.0", "private": true, "scripts": { "sva": "node -r esm bin/sva.js", "lint": "eslint --fix --ext .js .", "test": "mocha --require esm src/**/*_test.js", "watch": "mocha --require esm --watch --watch-extension js \"src/**/*_test.js\"", "serve": "serve", "bundle": "rollup -c" }, "devDependencies": { "chai": "^4.3.7", "eslint": "^8.41.0", "esm": "^3.2.25", "mocha": "^10.2.0", "rollup": "^3.29.5", "serve": "^14.2.0" } } KhronosGroup-SPIRV-Tools-f289d04/tools/sva/rollup.config.js000066400000000000000000000001471475742701700236030ustar00rootroot00000000000000export default { input: 'src/sva.js', output: { file: 'build/sva.js', format: 'esm', } } KhronosGroup-SPIRV-Tools-f289d04/tools/sva/src/000077500000000000000000000000001475742701700212515ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/tools/sva/src/assembler.js000066400000000000000000000047231475742701700235720ustar00rootroot00000000000000// Copyright 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. export default class Assembler { static get GENERATOR_ID() { return 0; } /** * @param {AST} the AST to build the SPIR-V from */ constructor(ast) { this.ast_ = ast; } /** * Assembles the AST into binary SPIR-V. * @return {Uint32Array} The SPIR-V binary data. */ assemble() { let total_size = 5; for (const inst of this.ast_.instructions()) { total_size += 1; for (const op of inst.operands()) { total_size += op.length(); } } let u = new Uint32Array(total_size); u[0] = 0x07230203; // Magic u[1] = 0x00010500; // Version 1.5 u[2] = Assembler.GENERATOR_ID; // Generator magic number u[3] = this.ast_.getIdBounds(); // ID bounds u[4] = 0; // Reserved let idx = 5; for (const inst of this.ast_.instructions()) { let op_size = 1; for (const op of inst.operands()) { op_size += op.length(); } u[idx++] = op_size << 16 | inst.opcode(); for (const op of inst.operands()) { idx = this.processOp(u, idx, op); } } return u; } processOp(u, idx, op) { if (op.type() === "string") { let len = 0; let v = 0; for (const ch of op.value()) { v = v | (ch.charCodeAt(0) << (len * 8)); len += 1; if (len === 4) { u[idx++] = v; len = 0; v = 0; } } // Make sure either the terminating 0 byte is written or the last // partial word is written. u[idx++] = v; } else if (op.type() === "float") { // TODO(dsinclair): Handle 64 bit floats ... let b = new ArrayBuffer(4); let f = new Float32Array(b); f[0] = op.value(); let u2 = new Uint32Array(b); u[idx++] = u2[0]; } else { u[idx++] = op.value(); } for (const param of op.params()) { idx = this.processOp(u, idx, param); } return idx; } } KhronosGroup-SPIRV-Tools-f289d04/tools/sva/src/assembler_test.js000066400000000000000000000116061475742701700246270ustar00rootroot00000000000000// Copyright 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. import { assert } from "chai"; import Lexer from "./lexer"; import Parser from "./parser"; import grammar from "./spirv.data.js"; import Assembler from "./assembler"; describe("assembler", () => { it("generates SPIR-V magic number", () => { let input = `; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 6 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 440 OpName %main "main" %void = OpTypeVoid %3 = OpTypeFunction %void %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd`; let l = new Lexer(input); let p = new Parser(grammar, l); let ast = p.parse(); assert.exists(ast, p.error); let a = new Assembler(ast); let res = a.assemble(); assert.equal(res[0], 0x07230203); }); it("assembles enumerant params", () => { let input = "OpExecutionMode %main LocalSize 2 3 4"; let l = new Lexer(input); let p = new Parser(grammar, l); let ast = p.parse(); assert.exists(ast, p.error); let a = new Assembler(ast); let res = a.assemble(); assert.lengthOf(res, 11); assert.equal(res[5], (6 /* word count */ << 16) | 16 /* opcode */); assert.equal(res[6], 1 /* %main */); assert.equal(res[7], 17 /* LocalSize */); assert.equal(res[8], 2); assert.equal(res[9], 3); assert.equal(res[10], 4); }); it("assembles float 32 values", () => { let input = `%float = OpTypeFloat 32 %float1 = OpConstant %float 0.400000006`; let l = new Lexer(input); let p = new Parser(grammar, l); let ast = p.parse(); assert.exists(ast, p.error); let a = new Assembler(ast); let res = a.assemble(); assert.lengthOf(res, 12); assert.equal(res[8], (4 /* word count */ << 16) | 43 /* opcode */); assert.equal(res[9], 1 /* %float */); assert.equal(res[10], 2 /* %float */); assert.equal(res[11], 0x3ecccccd /* 0.400000006 */); }); describe("strings", () => { it("assembles 'abcd'", () => { let input = `OpName %mains "abcd"`; let l = new Lexer(input); let p = new Parser(grammar, l); let ast = p.parse(); assert.exists(ast, p.error); let a = new Assembler(ast); let res = a.assemble(); assert.lengthOf(res, 9); assert.equal(res[5], (4 /* word count */ << 16) | 5 /* opcode */); assert.equal(res[6], 1 /* %mains */); assert.equal(res[7], 0x64636261 /* food */); assert.equal(res[8], 0x00000000 /* null byte */); }); it("assembles 'abcde'", () => { let input = `OpName %mains "abcde"`; let l = new Lexer(input); let p = new Parser(grammar, l); let ast = p.parse(); assert.exists(ast, p.error); let a = new Assembler(ast); let res = a.assemble(); assert.lengthOf(res, 9); assert.equal(res[5], (4 /* word count */ << 16) | 5 /* opcode */); assert.equal(res[6], 1 /* %mains */); assert.equal(res[7], 0x64636261 /* abcd */); assert.equal(res[8], 0x00000065 /* e */); }); it("assembles 'abcdef'", () => { let input = `OpName %mains "abcdef"`; let l = new Lexer(input); let p = new Parser(grammar, l); let ast = p.parse(); assert.exists(ast, p.error); let a = new Assembler(ast); let res = a.assemble(); assert.lengthOf(res, 9); assert.equal(res[5], (4 /* word count */ << 16) | 5 /* opcode */); assert.equal(res[6], 1 /* %mains */); assert.equal(res[7], 0x64636261 /* abcd */); assert.equal(res[8], 0x00006665 /* ef */); }); it("assembles 'abcdefg'", () => { let input = `OpName %mains "abcdefg"`; let l = new Lexer(input); let p = new Parser(grammar, l); let ast = p.parse(); assert.exists(ast, p.error); let a = new Assembler(ast); let res = a.assemble(); assert.lengthOf(res, 9); assert.equal(res[5], (4 /* word count */ << 16) | 5 /* opcode */); assert.equal(res[6], 1 /* %mains */); assert.equal(res[7], 0x64636261 /* abcd */); assert.equal(res[8], 0x00676665 /* efg */); }); }); }); KhronosGroup-SPIRV-Tools-f289d04/tools/sva/src/ast.js000066400000000000000000000065651475742701700224120ustar00rootroot00000000000000// Copyright 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. class Module { constructor() { this.instructions_ = []; this.next_id_ = 1; /** * Maps {string, hash} where the string is the type name and the hash is: * type- 'float' or 'int' * width- number of bits needed to store number * signed- the sign of the number */ this.types_ = {}; /** * Maps {string, number} where the string is the type name and the number is * the id value. */ this.assigned_ids_ = {}; } instructions() { return this.instructions_; } instruction(val) { return this.instructions_[val]; } addInstruction(inst) { this.instructions_.push(inst); // Record type information if (inst.name() === "OpTypeInt" || inst.name() === "OpTypeFloat") { let is_int = inst.name() === "OpTypeInt"; this.types_[inst.operand(0).name()] = { type: is_int ? "int" : "float", width: inst.operand(1).value(), signed: is_int ? inst.operand(2).value() : 1 }; } // Record operand result id's inst.operands().forEach((op) => { if (op.rawValue() !== undefined && op.type() === "result_id") { this.next_id_ = Math.max(this.next_id_, op.rawValue() + 1); } }); } getType(name) { return this.types_[name]; } getId(name) { if (this.assigned_ids_[name] !== undefined) { return this.assigned_ids_[name]; } let next = this.next_id_; this.assigned_ids_[name] = next; this.next_id_ += 1; return next; } getIdBounds() { return this.next_id_; } } class Instruction { constructor(name, opcode, operands) { this.name_ = name; this.opcode_ = opcode; this.operands_ = operands; } name() { return this.name_; } opcode() { return this.opcode_; } operands() { return this.operands_; } operand(val) { return this.operands_[val]; } } class Operand { constructor(mod, name, type, value, params) { this.module_ = mod; this.name_ = name; this.type_ = type; this.value_ = value; this.params_ = params; } name() { return this.name_; } length() { // Get the value just to force it to be filled. this.value(); if (this.type_ === "string") { return Math.ceil((this.value_.length + 1) / 4); } let size = 1; for (const param of this.params_) { size += param.length(); } return size; } type() { return this.type_; } rawValue() { return this.value_; } // This method should only be called on ResultId's after the full parse is // complete. This is because the AST will only have the maximum seen numeric // ResultId when the parse is done. value() { if (this.value_ === undefined) { this.value_ = this.module_.getId(this.name_); } return this.value_; } params() { return this.params_; } } export { Module, Instruction, Operand }; KhronosGroup-SPIRV-Tools-f289d04/tools/sva/src/lexer.js000066400000000000000000000214211475742701700227260ustar00rootroot00000000000000// Copyright 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. import { Token, TokenType } from "./token.js"; export default class Lexer { /** * @param {String} input The input string to tokenize. */ constructor(input) { this.input_ = input; this.len_ = input.length; this.cur_pos_ = 0; this.cur_line_ = 1; this.num_regex_ = /^[0-9]+$/; this.alpha_regex_ = /^[a-zA-Z_]+$/; this.op_regex_ = /^Op[A-Z][^\s]*$/; this.hex_regex_ = /^[0-9a-fA-F]$/; } /** * Parses the next token from the input stream. * @return {Token} the next token. */ next() { this.skipWhitespace(); this.skipComments(); if (this.cur_pos_ >= this.len_) return new Token(TokenType.kEOF, this.cur_line_); let n = this.tryHexInteger(); if (n !== undefined) return n; n = this.tryFloat(); if (n !== undefined) return n; n = this.tryInteger(); if (n !== undefined) return n; n = this.tryString(); if (n !== undefined) return n; n = this.tryOp(); if (n !== undefined) return n; n = this.tryPunctuation(); if (n !== undefined) return n; n = this.tryResultId(); if (n !== undefined) return n; n = this.tryIdent(); if (n !== undefined) return n; return new Token(TokenType.kError, this.cur_line_, "Failed to match token"); } is(str) { if (this.len_ <= this.cur_pos_ + (str.length - 1)) return false; for (let i = 0; i < str.length; ++i) { if (this.input_[this.cur_pos_ + i] !== str[i]) return false; } return true; } isNum(ch) { return ch.match(this.num_regex_); } isAlpha(ch) { return ch.match(this.alpha_regex_); } isAlphaNum(ch) { return this.isNum(ch) || this.isAlpha(ch); } isHex(char) { return char.match(this.hex_regex_); } isCurWhitespace() { return this.is(" ") || this.is("\t") || this.is("\r") || this.is("\n"); } skipWhitespace() { for(;;) { let cur_pos = this.cur_pos_; while (this.cur_pos_ < this.len_ && this.isCurWhitespace()) { if (this.is("\n")) this.cur_line_ += 1; this.cur_pos_ += 1; } this.skipComments(); // Cursor didn't move so no whitespace matched. if (cur_pos === this.cur_pos_) break; } } skipComments() { if (!this.is(";")) return; while (this.cur_pos_ < this.len_ && !this.is("\n")) this.cur_pos_ += 1; } /** * Attempt to parse the next part of the input as a float. * @return {Token|undefined} returns a Token if a float is matched, * undefined otherwise. */ tryFloat() { let start = this.cur_pos_; let end = start; if (this.cur_pos_ >= this.len_) return undefined; if (this.input_[end] === "-") end += 1; while (end < this.len_ && this.isNum(this.input_[end])) end += 1; // Must have a "." in a float if (end >= this.len_ || this.input_[end] !== ".") return undefined; end += 1; while (end < this.len_ && this.isNum(this.input_[end])) end += 1; let substr = this.input_.substr(start, end - start); if (substr === "." || substr === "-.") return undefined; this.cur_pos_ = end; return new Token(TokenType.kFloatLiteral, this.cur_line_, parseFloat(substr)); } /** * Attempt to parse a hex encoded integer. * @return {Token|undefined} returns a Token if a Hex number is matched, * undefined otherwise. */ tryHexInteger() { let start = this.cur_pos_; let end = start; if (this.cur_pos_ >= this.len_) return undefined; if (end + 2 >= this.len_ || this.input_[end] !== "0" || this.input_[end + 1] !== "x") { return undefined; } end += 2; while (end < this.len_ && this.isHex(this.input_[end])) end += 1; this.cur_pos_ = end; let val = parseInt(this.input_.substr(start, end - start), 16); return new Token(TokenType.kIntegerLiteral, this.cur_line_, val); } /** * Attempt to parse an encoded integer. * @return {Token|undefined} returns a Token if a number is matched, * undefined otherwise. */ tryInteger() { let start = this.cur_pos_; let end = start; if (this.cur_pos_ >= this.len_) return undefined; if (this.input_[end] === "-") end += 1; if (end >= this.len_ || !this.isNum(this.input_[end])) return undefined; while (end < this.len_ && this.isNum(this.input_[end])) end += 1; this.cur_pos_ = end; let val = parseInt(this.input_.substr(start, end - start), 10); return new Token(TokenType.kIntegerLiteral, this.cur_line_, val); } /** * Attempt to parse a result id. * @return {Token|undefined} returns a Token if a result id is matched, * undefined otherwise. */ tryResultId() { let start = this.cur_pos_; if (start >= this.len_) return undefined; if (!this.is("%")) return undefined; start += 1; this.cur_pos_ += 1; while (this.cur_pos_ < this.len_ && (this.isAlphaNum(this.input_[this.cur_pos_]) || this.is("_"))) { this.cur_pos_ += 1; } let ident = this.input_.substr(start, this.cur_pos_ - start); let value = undefined; if (ident.match(this.num_regex_)) value = parseInt(ident, 10); return new Token(TokenType.kResultId, this.cur_line_, { name: ident, val: value }); } /** * Attempt to parse an identifier. * @return {Token|undefined} returns a Token if an identifier is matched, * undefined otherwise. */ tryIdent() { let start = this.cur_pos_; if (start >= this.len_) return undefined; while (this.cur_pos_ < this.len_ && (this.isAlphaNum(this.input_[this.cur_pos_]) || this.is("_"))) { this.cur_pos_ += 1; } let ident = this.input_.substr(start, this.cur_pos_ - start); return new Token(TokenType.kIdentifier, this.cur_line_, ident); } /** * Attempt to parse an Op command. * @return {Token|undefined} returns a Token if an Op command is matched, * undefined otherwise. */ tryOp() { let start = this.cur_pos_; if (this.cur_pos_ >= this.len_ || (this.cur_pos_ + 1 >= this.len_)) return undefined; if (this.input_[this.cur_pos_] !== "O" || this.input_[this.cur_pos_ + 1] !== "p") { return undefined; } while (this.cur_pos_ < this.len_ && !this.isCurWhitespace()) { this.cur_pos_ += 1; } return new Token(TokenType.kOp, this.cur_line_, { name: this.input_.substr(start, this.cur_pos_ - start) }); } /** * Attempts to match punctuation strings against the input * @return {Token|undefined} Returns the Token for the punctuation or * undefined if no matches found. */ tryPunctuation() { let type = undefined; if (this.is("=")) type = TokenType.kEqual; else if (this.is("|")) type = TokenType.kPipe; if (type === undefined) return undefined; this.cur_pos_ += type.length; return new Token(type, this.cur_line_, type); } /** * Attempts to match strings against the input * @return {Token|undefined} Returns the Token for the string or undefined * if no match found. */ tryString() { let start = this.cur_pos_; // Must have at least 2 chars for a string. if (this.cur_pos_ >= this.len_ || (this.cur_pos_ + 1 >= this.len_)) return undefined; if (!this.is("\"")) return undefined; this.cur_pos_ += 1; let str = ""; while (this.cur_pos_ <= this.len_) { if (this.is("\"")) break; if (this.is("\\")) { this.cur_pos_ += 1; if (this.cur_pos_ >= this.len_) return undefined; if (this.is("\\")) { str += "\\"; } else if (this.is("\"")) { str += '"'; } else { str += this.input_[this.cur_pos_]; } } else { str += this.input_[this.cur_pos_]; } this.cur_pos_ += 1; } if (this.cur_pos_ >= this.len_) return undefined; this.cur_pos_ += 1; return new Token(TokenType.kStringLiteral, this.cur_line_, str); } } KhronosGroup-SPIRV-Tools-f289d04/tools/sva/src/lexer_test.js000066400000000000000000000123441475742701700237710ustar00rootroot00000000000000// Copyright 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. import { assert } from "chai"; import Lexer from "./lexer"; import { TokenType } from "./token"; describe("lexer", () => { describe("skipped content", () => { it("skips whitespace", () => { let input = " \t\r\n\t \tOpKill\t\n\t \r "; let l = new Lexer(input); let t = l.next(); assert.equal(t.type, TokenType.kOp); assert.equal(t.line, 2); assert.equal(t.data.name, "OpKill"); t = l.next(); assert.equal(t.type, TokenType.kEOF); assert.equal(t.line, 3); }); it("skips ; comments", () => { let input = `; start with comment OpKill ; end of line comment ; another comment %1`; let l = new Lexer(input); let t = l.next(); assert.equal(t.type, TokenType.kOp); assert.equal(t.data.name, "OpKill"); assert.equal(t.line, 2); t = l.next(); assert.equal(t.type, TokenType.kResultId); assert.equal(t.data.name, "1"); assert.equal(t.data.val, 1); assert.equal(t.line, 4); }); }); describe("numerics", () => { it("parses floats", () => { let input = ["0.0", "0.", ".0", "5.7", "5.", ".7", "-0.0", "-.0", "-0.", "-5.7", "-5.", "-.7"]; let results = [0.0, 0.0, 0.0, 5.7, 5.0, 0.7, 0.0, 0.0, 0.0, -5.7, -5.0, -0.7]; input.forEach((val, idx) => { let l = new Lexer(val); let t = l.next(); assert.equal(t.type, TokenType.kFloatLiteral, `expected ${val} to be a float got ${t.type}`); assert.equal(t.data, results[idx], `expected ${results[idx]} === ${t.data}`); t = l.next(); assert.equal(t.type, TokenType.kEOF); assert.equal(t.data, undefined); }); }); it("handles invalid floats", () => { let input = [".", "-."]; input.forEach((val) => { let l = new Lexer(val); let t = l.next(); assert.notEqual(t.type, TokenType.kFloatLiteral, `expect ${val} to not match type float`); }); }); it("parses integers", () => { let input = ["0", "-0", "123", "-123", "2147483647", "-2147483648", "4294967295", "0x00", "0x24"]; let results = [0, 0, 123, -123,2147483647, -2147483648, 4294967295, 0x0, 0x24]; input.forEach((val, idx) => { let l = new Lexer(val); let t = l.next(); assert.equal(t.type, TokenType.kIntegerLiteral, `expected ${val} to be an integer got ${t.type}`); assert.equal(t.data, results[idx], `expected ${results[idx]} === ${t.data}`); t = l.next(); assert.equal(t.type, TokenType.kEOF); assert.equal(t.data, undefined); }); }); }); it("matches result_ids", () => { let input = `%123 %001 %main %_a_b_c`; let result = [ {name: "123", val: 123}, {name: "001", val: 1}, {name: "main", val: undefined}, {name: "_a_b_c", val: undefined} ]; let l = new Lexer(input); for (let i = 0; i < result.length; ++i) { let t = l.next(); assert.equal(t.type, TokenType.kResultId); assert.equal(t.data.name, result[i].name); assert.equal(t.data.val, result[i].val); } }); it("matches punctuation", () => { let input = "="; let results = [TokenType.kEqual]; let l = new Lexer(input); for (let i = 0; i < results.length; ++i) { let t = l.next(); assert.equal(t.type, results[i]); assert.equal(t.line, i + 1); } let t = l.next(); assert.equal(t.type, TokenType.kEOF); }); describe("strings", () => { it("matches strings", () => { let input = "\"GLSL.std.450\""; let l = new Lexer(input); let t = l.next(); assert.equal(t.type, TokenType.kStringLiteral); assert.equal(t.data, "GLSL.std.450"); }); it("handles unfinished strings", () => { let input = "\"GLSL.std.450"; let l = new Lexer(input); let t = l.next(); assert.equal(t.type, TokenType.kError); }); it("handles escapes", () => { let input = `"embedded\\"quote" "embedded\\\\slash" "embedded\\nchar"`; let results = [`embedded\"quote`, `embedded\\slash`, `embeddednchar`]; let l = new Lexer(input); for (let i = 0; i < results.length; ++i) { let t = l.next(); assert.equal(t.type, TokenType.kStringLiteral, results[i]); assert.equal(t.data, results[i]); } }); }); it("matches keywords", () => { let input = "GLSL Function"; let results = ["GLSL", "Function"]; let l = new Lexer(input); for (let i = 0; i < results.length; ++i) { let t = l.next(); assert.equal(t.type, TokenType.kIdentifier, results[i]); assert.equal(t.data, results[i]); } }); }); KhronosGroup-SPIRV-Tools-f289d04/tools/sva/src/parser.js000066400000000000000000000175751475742701700231220ustar00rootroot00000000000000// Copyright 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. import { TokenType } from "./token.js"; import * as AST from "./ast.js"; export default class Parser { /** * @param {Hash} The SPIR-V grammar * @param {Lexer} The lexer * @return {AST} Attempts to build an AST from the tokens returned by the * given lexer */ constructor(grammar, lexer) { this.grammar_ = grammar; this.lexer_ = lexer; this.peek_ = []; this.error_ = ""; } get error() { return this.error_; } next() { return this.peek_.shift() || this.lexer_.next(); } peek(idx) { while (this.peek_.length <= idx) { this.peek_.push(this.lexer_.next()); } return this.peek_[idx]; } /** * Executes the parser. * * @return {AST|undefined} returns a parsed AST on success or undefined * on error. The error message can be retrieved by * calling error(). */ parse() { let ast = new AST.Module(); for(;;) { let token = this.next(); if (token === TokenType.kError) { this.error_ = token.line() + ": " + token.data(); return undefined; } if (token.type === TokenType.kEOF) break; let result_id = undefined; if (token.type === TokenType.kResultId) { result_id = token; token = this.next(); if (token.type !== TokenType.kEqual) { this.error_ = token.line + ": expected = after result id"; return undefined; } token = this.next(); } if (token.type !== TokenType.kOp) { this.error_ = token.line + ": expected Op got " + token.type; return undefined; } let name = token.data.name; let data = this.getInstructionData(name); let operands = []; let result_type = undefined; for (let operand of data.operands) { if (operand.kind === "IdResult") { if (result_id === undefined) { this.error_ = token.line + ": expected result id"; return undefined; } let o = new AST.Operand(ast, result_id.data.name, "result_id", result_id.data.val, []); if (o === undefined) { return undefined; } operands.push(o); } else { if (operand.quantifier === "?") { if (this.nextIsNewInstr()) { break; } } else if (operand.quantifier === "*") { while (!this.nextIsNewInstr()) { let o = this.extractOperand(ast, result_type, operand); if (o === undefined) { return undefined; } operands.push(o); } break; } let o = this.extractOperand(ast, result_type, operand); if (o === undefined) { return undefined; } // Store the result type away so we can use it for context dependent // numbers if needed. if (operand.kind === "IdResultType") { result_type = ast.getType(o.name()); } operands.push(o); } } // Verify only GLSL extended instructions are used if (name === "OpExtInstImport" && operands[1].value() !== "GLSL.std.450") { this.error_ = token.line + ": Only GLSL.std.450 external instructions supported"; return undefined; } let inst = new AST.Instruction(name, data.opcode, operands); ast.addInstruction(inst); } return ast; } getInstructionData(name) { return this.grammar_["instructions"][name]; } nextIsNewInstr() { let n0 = this.peek(0); if (n0.type === TokenType.kOp || n0.type === TokenType.kEOF) { return true; } let n1 = this.peek(1); if (n1.type === TokenType.kEOF) { return false; } if (n0.type === TokenType.kResultId && n1.type === TokenType.kEqual) return true; return false; } extractOperand(ast, result_type, data) { let t = this.next(); let name = undefined; let kind = undefined; let value = undefined; let params = []; // TODO(dsinclair): There are a bunch of missing types here. See // https://github.com/KhronosGroup/SPIRV-Tools/blob/master/source/text.cpp#L210 // // LiteralSpecConstantOpInteger // PairLiteralIntegerIdRef // PairIdRefLiteralInteger // PairIdRefIdRef if (data.kind === "IdResult" || data.kind === "IdRef" || data.kind === "IdResultType" || data.kind === "IdScope" || data.kind === "IdMemorySemantics") { if (t.type !== TokenType.kResultId) { this.error_ = t.line + ": expected result id"; return undefined; } name = t.data.name; kind = "result_id"; value = t.data.val; } else if (data.kind === "LiteralString") { if (t.type !== TokenType.kStringLiteral) { this.error_ = t.line + ": expected string not found"; return undefined; } name = t.data; kind = "string"; value = t.data; } else if (data.kind === "LiteralInteger") { if (t.type !== TokenType.kIntegerLiteral) { this.error_ = t.line + ": expected integer not found"; return undefined; } name = "" + t.data; kind = t.type; value = t.data; } else if (data.kind === "LiteralContextDependentNumber") { if (result_type === undefined) { this.error_ = t.line + ": missing result type for context dependent number"; return undefined; } if (t.type !== TokenType.kIntegerLiteral && t.type !== TokenType.kFloatLiteral) { this.error_ = t.line + ": expected number not found"; return undefined; } name = "" + t.data; kind = result_type.type; value = t.data; } else if (data.kind === "LiteralExtInstInteger") { if (t.type !== TokenType.kIdentifier) { this.error_ = t.line + ": expected instruction identifier"; return undefined; } if (this.grammar_.ext[t.data] === undefined) { this.error_ = t.line + `: unable to find extended instruction (${t.data})`; return undefined; } name = t.data; kind = "integer"; value = this.grammar_.ext[t.data]; } else { let d = this.grammar_.operand_kinds[data.kind]; if (d === undefined) { this.error_ = t.line + ": expected " + data.kind + " not found"; return undefined; } let val = d.values[t.data]["value"]; let names = [t.data]; if (d.type === "BitEnum") { for(;;) { let tmp = this.peek(0); if (tmp.type !== TokenType.kPipe) { break; } this.next(); // skip pipe tmp = this.next(); if (tmp.type !== TokenType.kIdentifier) { this.error_ = tmp.line() + ": expected identifier"; return undefined; } val |= d.values[tmp.data]["value"]; names.push(tmp.data); } } name = names.join("|"); kind = d.type; value = val; for (const op_name of names) { if (d.values[op_name]['params'] === undefined) { continue; } for (const param of d.values[op_name]["params"]) { params.push(this.extractOperand(ast, result_type, { kind: param })); } } } return new AST.Operand(ast, name, kind, value, params); } } KhronosGroup-SPIRV-Tools-f289d04/tools/sva/src/parser_test.js000066400000000000000000000344601475742701700241510ustar00rootroot00000000000000// Copyright 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. import { assert } from "chai"; import Lexer from "./lexer"; import Parser from "./parser"; import grammar from "./spirv.data.js"; describe("parser", () => { it("parses an opcode", () => { let input = "OpKill"; let l = new Lexer(input); let p = new Parser(grammar, l); let ast = p.parse(); assert.exists(ast); assert.lengthOf(ast.instructions(), 1); let inst = ast.instruction(0); assert.equal(inst.name(), "OpKill"); assert.equal(inst.opcode(), 252); assert.lengthOf(inst.operands, 0); }); it("parses an opcode with an identifier", () => { let input = "OpCapability Shader"; let l = new Lexer(input); let p = new Parser(grammar, l); let ast = p.parse(); assert.exists(ast, p.error); assert.lengthOf(ast.instructions(), 1); let inst = ast.instruction(0); assert.equal(inst.name(), "OpCapability"); assert.equal(inst.opcode(), 17); assert.lengthOf(inst.operands(), 1); let op = inst.operand(0); assert.equal(op.name(), "Shader"); assert.equal(op.type(), "ValueEnum"); assert.equal(op.value(), 1); }); it("parses an opcode with a result", () => { let input = "%void = OpTypeVoid"; let l = new Lexer(input); let p = new Parser(grammar, l); let ast = p.parse(); assert.exists(ast); assert.lengthOf(ast.instructions(), 1); let inst = ast.instruction(0); assert.equal(inst.name(), "OpTypeVoid"); assert.equal(inst.opcode(), 19); assert.lengthOf(inst.operands(), 1); let op = inst.operand(0); assert.equal(op.name(), "void"); assert.equal(op.value(), 1); }); it("sets module bounds based on numeric result", () => { let input = "%3 = OpTypeVoid"; let l = new Lexer(input); let p = new Parser(grammar, l); let ast = p.parse(); assert.exists(ast); assert.equal(ast.getId("next"), 4); }); it("returns the same value for a named result_id", () => { let input = "%3 = OpTypeFunction %int %int"; let l = new Lexer(input); let p = new Parser(grammar, l); let ast = p.parse(); assert.exists(ast); assert.lengthOf(ast.instructions(), 1); let inst = ast.instruction(0); let op1 = inst.operand(1); assert.equal(op1.name(), "int"); assert.equal(op1.value(), 4); let op2 = inst.operand(2); assert.equal(op2.name(), "int"); assert.equal(op2.value(), 4); }); it("parses an opcode with a string", () => { let input = "OpEntryPoint Fragment %main \"main\""; let l = new Lexer(input); let p = new Parser(grammar, l); let ast = p.parse(); assert.exists(ast); assert.lengthOf(ast.instructions(), 1); let inst = ast.instruction(0); let op = inst.operand(2); assert.equal(op.name(), "main"); assert.equal(op.value(), "main"); }); describe("numerics", () => { describe("integers", () => { it("parses an opcode with an integer", () => { let input = "OpSource GLSL 440"; let l = new Lexer(input); let p = new Parser(grammar, l); let ast = p.parse(); assert.exists(ast); assert.lengthOf(ast.instructions(), 1); let inst = ast.instruction(0); let op0 = inst.operand(0); assert.equal(op0.name(), "GLSL"); assert.equal(op0.type(), "ValueEnum"); assert.equal(op0.value(), 2); let op1 = inst.operand(1); assert.equal(op1.name(), "440"); assert.equal(op1.value(), 440); }); it("parses an opcode with a hex integer", () => { let input = "OpSource GLSL 0x440"; let l = new Lexer(input); let p = new Parser(grammar, l); let ast = p.parse(); assert.exists(ast); assert.lengthOf(ast.instructions(), 1); let inst = ast.instruction(0); let op0 = inst.operand(0); assert.equal(op0.name(), "GLSL"); assert.equal(op0.type(), "ValueEnum"); assert.equal(op0.value(), 2); let op1 = inst.operand(1); assert.equal(op1.name(), "1088"); assert.equal(op1.value(), 0x440); }); it.skip("parses immediate integers", () => { // TODO(dsinclair): Support or skip? }); }); describe("floats", () => { it("parses floats", () => { let input = `%float = OpTypeFloat 32 %float1 = OpConstant %float 0.400000006`; let l = new Lexer(input); let p = new Parser(grammar, l); let ast = p.parse(); assert.exists(ast, p.error); assert.lengthOf(ast.instructions(), 2); let inst = ast.instruction(1); let op2 = inst.operand(2); assert.equal(op2.value(), 0.400000006); }); // TODO(dsinclair): Make hex encoded floats parse ... it.skip("parses hex floats", () => { let input = `%float = OpTypeFloat 32 %nfloat = OpConstant %float -0.4p+2 %pfloat = OpConstant %float 0.4p-2 %inf = OpConstant %float32 0x1p+128 %neginf = OpConstant %float32 -0x1p+128 %aNaN = OpConstant %float32 0x1.8p+128 %moreNaN = OpConstant %float32 -0x1.0002p+128`; let results = [-40.0, .004, 0x00000, 0x00000, 0x7fc00000, 0xff800100]; let l = new Lexer(input); let p = new Parser(grammar, l); let ast = p.parse(); assert.exists(ast, p.error); assert.lengthOf(ast.instructions(), 7); for (const idx in results) { let inst = ast.instruction(idx); let op2 = inst.operand(2); assert.equal(op2.value(), results[idx]); } }); it("parses a float that looks like an int", () => { let input = `%float = OpTypeFloat 32 %float1 = OpConstant %float 1`; let l = new Lexer(input); let p = new Parser(grammar, l); let ast = p.parse(); assert.exists(ast, p.error); assert.lengthOf(ast.instructions(), 2); let inst = ast.instruction(1); let op2 = inst.operand(2); assert.equal(op2.value(), 1); assert.equal(op2.type(), "float"); }); }); }); describe("enums", () => { it("parses enum values", () => { let input = `%1 = OpTypeFloat 32 %30 = OpImageSampleExplicitLod %1 %20 %18 Grad|ConstOffset %22 %24 %29`; let vals = [{val: 1, name: "1"}, {val: 30, name: "30"}, {val: 20, name: "20"}, {val: 18, name: "18"}, {val: 12, name: "Grad|ConstOffset"}]; let l = new Lexer(input); let p = new Parser(grammar, l); let ast = p.parse(); assert.exists(ast, p.error); assert.lengthOf(ast.instructions(), 2); let inst = ast.instruction(1); for (let idx in vals) { let op = inst.operand(idx); assert.equal(op.name(), vals[idx].name); assert.equal(op.value(), vals[idx].val); } // BitEnum let params = inst.operand(4).params(); assert.lengthOf(params, 3); assert.equal(params[0].name(), "22"); assert.equal(params[0].value(), 22); assert.equal(params[1].name(), "24"); assert.equal(params[1].value(), 24); assert.equal(params[2].name(), "29"); assert.equal(params[2].value(), 29); }); it("parses enumerants with parameters", () => { let input ="OpExecutionMode %main LocalSize 2 3 4"; let l = new Lexer(input); let p = new Parser(grammar, l); let ast = p.parse(); assert.exists(ast, p.error); assert.lengthOf(ast.instructions(), 1); let inst = ast.instruction(0); assert.equal(inst.name(), "OpExecutionMode"); assert.lengthOf(inst.operands(), 2); assert.equal(inst.operand(0).name(), "main"); assert.equal(inst.operand(1).name(), "LocalSize"); let params = inst.operand(1).params(); assert.lengthOf(params, 3); assert.equal(params[0].name(), "2"); assert.equal(params[1].name(), "3"); assert.equal(params[2].name(), "4"); }); }); it("parses result into second operand if needed", () => { let input = `%int = OpTypeInt 32 1 %int_3 = OpConstant %int 3`; let l = new Lexer(input); let p = new Parser(grammar, l); let ast = p.parse(); assert.exists(ast); assert.lengthOf(ast.instructions(), 2); let inst = ast.instruction(1); assert.equal(inst.name(), "OpConstant"); assert.equal(inst.opcode(), 43); assert.lengthOf(inst.operands(), 3); let op0 = inst.operand(0); assert.equal(op0.name(), "int"); assert.equal(op0.value(), 1); let op1 = inst.operand(1); assert.equal(op1.name(), "int_3"); assert.equal(op1.value(), 2); let op2 = inst.operand(2); assert.equal(op2.name(), "3"); assert.equal(op2.value(), 3); }); describe("quantifiers", () => { describe("?", () => { it("skips if missing", () => { let input = `OpImageWrite %1 %2 %3 OpKill`; let l = new Lexer(input); let p = new Parser(grammar, l); let ast = p.parse(); assert.exists(ast); assert.lengthOf(ast.instructions(), 2); let inst = ast.instruction(0); assert.equal(inst.name(), "OpImageWrite"); assert.lengthOf(inst.operands(), 3); }); it("skips if missing at EOF", () => { let input = "OpImageWrite %1 %2 %3"; let l = new Lexer(input); let p = new Parser(grammar, l); let ast = p.parse(); assert.exists(ast); assert.lengthOf(ast.instructions(), 1); let inst = ast.instruction(0); assert.equal(inst.name(), "OpImageWrite"); assert.lengthOf(inst.operands(), 3); }); it("extracts if available", () => { let input = `OpImageWrite %1 %2 %3 ConstOffset %2 OpKill`; let l = new Lexer(input); let p = new Parser(grammar, l); let ast = p.parse(); assert.exists(ast); assert.lengthOf(ast.instructions(), 2); let inst = ast.instruction(0); assert.equal(inst.name(), "OpImageWrite"); assert.lengthOf(inst.operands(), 4); assert.equal(inst.operand(3).name(), "ConstOffset"); }); }); describe("*", () => { it("skips if missing", () => { let input = `OpEntryPoint Fragment %main "main" OpKill`; let l = new Lexer(input); let p = new Parser(grammar, l); let ast = p.parse(); assert.exists(ast); assert.lengthOf(ast.instructions(), 2); let inst = ast.instruction(0); assert.equal(inst.name(), "OpEntryPoint"); assert.lengthOf(inst.operands(), 3); assert.equal(inst.operand(2).name(), "main"); }); it("extracts one if available", () => { let input = `OpEntryPoint Fragment %main "main" %2 OpKill`; let l = new Lexer(input); let p = new Parser(grammar, l); let ast = p.parse(); assert.exists(ast); assert.lengthOf(ast.instructions(), 2); let inst = ast.instruction(0); assert.equal(inst.name(), "OpEntryPoint"); assert.lengthOf(inst.operands(), 4); assert.equal(inst.operand(3).name(), "2"); }); it("extracts multiple if available", () => { let input = `OpEntryPoint Fragment %main "main" %2 %3 %4 %5 OpKill`; let l = new Lexer(input); let p = new Parser(grammar, l); let ast = p.parse(); assert.exists(ast); assert.lengthOf(ast.instructions(), 2); let inst = ast.instruction(0); assert.equal(inst.name(), "OpEntryPoint"); assert.lengthOf(inst.operands(), 7); assert.equal(inst.operand(3).name(), "2"); assert.equal(inst.operand(4).name(), "3"); assert.equal(inst.operand(5).name(), "4"); assert.equal(inst.operand(6).name(), "5"); }); }); }); describe("extended instructions", () => { it("errors on non-glsl extensions", () => { let input = "%1 = OpExtInstImport \"OpenCL.std.100\""; let l = new Lexer(input); let p = new Parser(grammar, l); assert.isUndefined(p.parse()); }); it("handles extended instructions", () => { let input = `%1 = OpExtInstImport "GLSL.std.450" %44 = OpExtInst %7 %1 Sqrt %43`; let l = new Lexer(input); let p = new Parser(grammar, l); let ast = p.parse(); assert.exists(ast, p.error); assert.lengthOf(ast.instructions(), 2); let inst = ast.instruction(1); assert.lengthOf(inst.operands(), 5); assert.equal(inst.operand(3).value(), 31); assert.equal(inst.operand(3).name(), "Sqrt"); assert.equal(inst.operand(4).value(), 43); assert.equal(inst.operand(4).name(), "43"); }); }); it.skip("handles spec constant ops", () => { // let input = "%sum = OpSpecConstantOp %i32 IAdd %a %b"; }); it("handles OpCopyMemory", () => { let input = "OpCopyMemory %1 %2 " + "Volatile|Nontemporal|MakePointerVisible %3 " + "Aligned|MakePointerAvailable|NonPrivatePointer 16 %4"; let l = new Lexer(input); let p = new Parser(grammar, l); let ast = p.parse(); assert.exists(ast, p.error); assert.lengthOf(ast.instructions(), 1); let inst = ast.instruction(0); assert.lengthOf(inst.operands(), 4); assert.equal(inst.operand(0).value(), 1); assert.equal(inst.operand(1).value(), 2); assert.equal(inst.operand(2).name(), "Volatile|Nontemporal|MakePointerVisible"); assert.equal(inst.operand(2).value(), 21); assert.lengthOf(inst.operand(2).params(), 1); assert.equal(inst.operand(2).params()[0].value(), 3); assert.equal(inst.operand(3).name(), "Aligned|MakePointerAvailable|NonPrivatePointer"); assert.equal(inst.operand(3).value(), 42); assert.lengthOf(inst.operand(3).params(), 2); assert.equal(inst.operand(3).params()[0].value(), 16); assert.equal(inst.operand(3).params()[1].value(), 4); }); }); KhronosGroup-SPIRV-Tools-f289d04/tools/sva/src/spirv.data.js000066400000000000000000002346631475742701700237000ustar00rootroot00000000000000/*Copyright (c) 2014-2016 The Khronos Group Inc. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and/or associated documentation files (the "Materials"), to deal in the Materials without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Materials, and to permit persons to whom the Materials are furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Materials. MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.*/ // THIS FILE IS GENERATED WITH tools/process_grammar.rb export default { "magic": "0x07230203", "version": [ 1, 5 ], "instructions": { "OpNop": { "opcode": 0, "operands": [ ] }, "OpUndef": { "opcode": 1, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" } ] }, "OpSourceContinued": { "opcode": 2, "operands": [ { "kind": "LiteralString" } ] }, "OpSource": { "opcode": 3, "operands": [ { "kind": "SourceLanguage" }, { "kind": "LiteralInteger" }, { "kind": "IdRef", "quantifier": "?" }, { "kind": "LiteralString", "quantifier": "?" } ] }, "OpSourceExtension": { "opcode": 4, "operands": [ { "kind": "LiteralString" } ] }, "OpName": { "opcode": 5, "operands": [ { "kind": "IdRef" }, { "kind": "LiteralString" } ] }, "OpMemberName": { "opcode": 6, "operands": [ { "kind": "IdRef" }, { "kind": "LiteralInteger" }, { "kind": "LiteralString" } ] }, "OpString": { "opcode": 7, "operands": [ { "kind": "IdResult" }, { "kind": "LiteralString" } ] }, "OpLine": { "opcode": 8, "operands": [ { "kind": "IdRef" }, { "kind": "LiteralInteger" }, { "kind": "LiteralInteger" } ] }, "OpExtension": { "opcode": 10, "operands": [ { "kind": "LiteralString" } ] }, "OpExtInstImport": { "opcode": 11, "operands": [ { "kind": "IdResult" }, { "kind": "LiteralString" } ] }, "OpExtInst": { "opcode": 12, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "LiteralExtInstInteger" }, { "kind": "IdRef", "quantifier": "*" } ] }, "OpMemoryModel": { "opcode": 14, "operands": [ { "kind": "AddressingModel" }, { "kind": "MemoryModel" } ] }, "OpEntryPoint": { "opcode": 15, "operands": [ { "kind": "ExecutionModel" }, { "kind": "IdRef" }, { "kind": "LiteralString" }, { "kind": "IdRef", "quantifier": "*" } ] }, "OpExecutionMode": { "opcode": 16, "operands": [ { "kind": "IdRef" }, { "kind": "ExecutionMode" } ] }, "OpCapability": { "opcode": 17, "operands": [ { "kind": "Capability" } ] }, "OpTypeVoid": { "opcode": 19, "operands": [ { "kind": "IdResult" } ] }, "OpTypeBool": { "opcode": 20, "operands": [ { "kind": "IdResult" } ] }, "OpTypeInt": { "opcode": 21, "operands": [ { "kind": "IdResult" }, { "kind": "LiteralInteger" }, { "kind": "LiteralInteger" } ] }, "OpTypeFloat": { "opcode": 22, "operands": [ { "kind": "IdResult" }, { "kind": "LiteralInteger" } ] }, "OpTypeVector": { "opcode": 23, "operands": [ { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "LiteralInteger" } ] }, "OpTypeMatrix": { "opcode": 24, "operands": [ { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "LiteralInteger" } ] }, "OpTypeImage": { "opcode": 25, "operands": [ { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "Dim" }, { "kind": "LiteralInteger" }, { "kind": "LiteralInteger" }, { "kind": "LiteralInteger" }, { "kind": "LiteralInteger" }, { "kind": "ImageFormat" }, { "kind": "AccessQualifier", "quantifier": "?" } ] }, "OpTypeSampler": { "opcode": 26, "operands": [ { "kind": "IdResult" } ] }, "OpTypeSampledImage": { "opcode": 27, "operands": [ { "kind": "IdResult" }, { "kind": "IdRef" } ] }, "OpTypeArray": { "opcode": 28, "operands": [ { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpTypeRuntimeArray": { "opcode": 29, "operands": [ { "kind": "IdResult" }, { "kind": "IdRef" } ] }, "OpTypeStruct": { "opcode": 30, "operands": [ { "kind": "IdResult" }, { "kind": "IdRef", "quantifier": "*" } ] }, "OpTypePointer": { "opcode": 32, "operands": [ { "kind": "IdResult" }, { "kind": "StorageClass" }, { "kind": "IdRef" } ] }, "OpTypeFunction": { "opcode": 33, "operands": [ { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef", "quantifier": "*" } ] }, "OpConstantTrue": { "opcode": 41, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" } ] }, "OpConstantFalse": { "opcode": 42, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" } ] }, "OpConstant": { "opcode": 43, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "LiteralContextDependentNumber" } ] }, "OpConstantComposite": { "opcode": 44, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef", "quantifier": "*" } ] }, "OpConstantNull": { "opcode": 46, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" } ] }, "OpSpecConstantTrue": { "opcode": 48, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" } ] }, "OpSpecConstantFalse": { "opcode": 49, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" } ] }, "OpSpecConstant": { "opcode": 50, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "LiteralContextDependentNumber" } ] }, "OpSpecConstantComposite": { "opcode": 51, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef", "quantifier": "*" } ] }, "OpSpecConstantOp": { "opcode": 52, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "LiteralSpecConstantOpInteger" } ] }, "OpFunction": { "opcode": 54, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "FunctionControl" }, { "kind": "IdRef" } ] }, "OpFunctionParameter": { "opcode": 55, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" } ] }, "OpFunctionEnd": { "opcode": 56, "operands": [ ] }, "OpFunctionCall": { "opcode": 57, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef", "quantifier": "*" } ] }, "OpVariable": { "opcode": 59, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "StorageClass" }, { "kind": "IdRef", "quantifier": "?" } ] }, "OpImageTexelPointer": { "opcode": 60, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpLoad": { "opcode": 61, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "MemoryAccess", "quantifier": "?" } ] }, "OpStore": { "opcode": 62, "operands": [ { "kind": "IdRef" }, { "kind": "IdRef" }, { "kind": "MemoryAccess", "quantifier": "?" } ] }, "OpCopyMemory": { "opcode": 63, "operands": [ { "kind": "IdRef" }, { "kind": "IdRef" }, { "kind": "MemoryAccess", "quantifier": "?" }, { "kind": "MemoryAccess", "quantifier": "?" } ] }, "OpAccessChain": { "opcode": 65, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef", "quantifier": "*" } ] }, "OpInBoundsAccessChain": { "opcode": 66, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef", "quantifier": "*" } ] }, "OpArrayLength": { "opcode": 68, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "LiteralInteger" } ] }, "OpDecorate": { "opcode": 71, "operands": [ { "kind": "IdRef" }, { "kind": "Decoration" } ] }, "OpMemberDecorate": { "opcode": 72, "operands": [ { "kind": "IdRef" }, { "kind": "LiteralInteger" }, { "kind": "Decoration" } ] }, "OpDecorationGroup": { "opcode": 73, "operands": [ { "kind": "IdResult" } ] }, "OpGroupDecorate": { "opcode": 74, "operands": [ { "kind": "IdRef" }, { "kind": "IdRef", "quantifier": "*" } ] }, "OpGroupMemberDecorate": { "opcode": 75, "operands": [ { "kind": "IdRef" }, { "kind": "PairIdRefLiteralInteger", "quantifier": "*" } ] }, "OpVectorExtractDynamic": { "opcode": 77, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpVectorInsertDynamic": { "opcode": 78, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpVectorShuffle": { "opcode": 79, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" }, { "kind": "LiteralInteger", "quantifier": "*" } ] }, "OpCompositeConstruct": { "opcode": 80, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef", "quantifier": "*" } ] }, "OpCompositeExtract": { "opcode": 81, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "LiteralInteger", "quantifier": "*" } ] }, "OpCompositeInsert": { "opcode": 82, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" }, { "kind": "LiteralInteger", "quantifier": "*" } ] }, "OpCopyObject": { "opcode": 83, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" } ] }, "OpTranspose": { "opcode": 84, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" } ] }, "OpSampledImage": { "opcode": 86, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpImageSampleImplicitLod": { "opcode": 87, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" }, { "kind": "ImageOperands", "quantifier": "?" } ] }, "OpImageSampleExplicitLod": { "opcode": 88, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" }, { "kind": "ImageOperands" } ] }, "OpImageSampleDrefImplicitLod": { "opcode": 89, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" }, { "kind": "IdRef" }, { "kind": "ImageOperands", "quantifier": "?" } ] }, "OpImageSampleDrefExplicitLod": { "opcode": 90, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" }, { "kind": "IdRef" }, { "kind": "ImageOperands" } ] }, "OpImageSampleProjImplicitLod": { "opcode": 91, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" }, { "kind": "ImageOperands", "quantifier": "?" } ] }, "OpImageSampleProjExplicitLod": { "opcode": 92, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" }, { "kind": "ImageOperands" } ] }, "OpImageSampleProjDrefImplicitLod": { "opcode": 93, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" }, { "kind": "IdRef" }, { "kind": "ImageOperands", "quantifier": "?" } ] }, "OpImageSampleProjDrefExplicitLod": { "opcode": 94, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" }, { "kind": "IdRef" }, { "kind": "ImageOperands" } ] }, "OpImageFetch": { "opcode": 95, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" }, { "kind": "ImageOperands", "quantifier": "?" } ] }, "OpImageGather": { "opcode": 96, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" }, { "kind": "IdRef" }, { "kind": "ImageOperands", "quantifier": "?" } ] }, "OpImageDrefGather": { "opcode": 97, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" }, { "kind": "IdRef" }, { "kind": "ImageOperands", "quantifier": "?" } ] }, "OpImageRead": { "opcode": 98, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" }, { "kind": "ImageOperands", "quantifier": "?" } ] }, "OpImageWrite": { "opcode": 99, "operands": [ { "kind": "IdRef" }, { "kind": "IdRef" }, { "kind": "IdRef" }, { "kind": "ImageOperands", "quantifier": "?" } ] }, "OpImage": { "opcode": 100, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" } ] }, "OpImageQuerySizeLod": { "opcode": 103, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpImageQuerySize": { "opcode": 104, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" } ] }, "OpImageQueryLod": { "opcode": 105, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpImageQueryLevels": { "opcode": 106, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" } ] }, "OpImageQuerySamples": { "opcode": 107, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" } ] }, "OpConvertFToU": { "opcode": 109, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" } ] }, "OpConvertFToS": { "opcode": 110, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" } ] }, "OpConvertSToF": { "opcode": 111, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" } ] }, "OpConvertUToF": { "opcode": 112, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" } ] }, "OpUConvert": { "opcode": 113, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" } ] }, "OpSConvert": { "opcode": 114, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" } ] }, "OpFConvert": { "opcode": 115, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" } ] }, "OpQuantizeToF16": { "opcode": 116, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" } ] }, "OpBitcast": { "opcode": 124, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" } ] }, "OpSNegate": { "opcode": 126, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" } ] }, "OpFNegate": { "opcode": 127, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" } ] }, "OpIAdd": { "opcode": 128, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpFAdd": { "opcode": 129, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpISub": { "opcode": 130, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpFSub": { "opcode": 131, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpIMul": { "opcode": 132, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpFMul": { "opcode": 133, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpUDiv": { "opcode": 134, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpSDiv": { "opcode": 135, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpFDiv": { "opcode": 136, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpUMod": { "opcode": 137, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpSRem": { "opcode": 138, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpSMod": { "opcode": 139, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpFRem": { "opcode": 140, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpFMod": { "opcode": 141, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpVectorTimesScalar": { "opcode": 142, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpMatrixTimesScalar": { "opcode": 143, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpVectorTimesMatrix": { "opcode": 144, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpMatrixTimesVector": { "opcode": 145, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpMatrixTimesMatrix": { "opcode": 146, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpOuterProduct": { "opcode": 147, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpDot": { "opcode": 148, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpIAddCarry": { "opcode": 149, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpISubBorrow": { "opcode": 150, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpUMulExtended": { "opcode": 151, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpSMulExtended": { "opcode": 152, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpAny": { "opcode": 154, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" } ] }, "OpAll": { "opcode": 155, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" } ] }, "OpIsNan": { "opcode": 156, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" } ] }, "OpIsInf": { "opcode": 157, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" } ] }, "OpLogicalEqual": { "opcode": 164, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpLogicalNotEqual": { "opcode": 165, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpLogicalOr": { "opcode": 166, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpLogicalAnd": { "opcode": 167, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpLogicalNot": { "opcode": 168, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" } ] }, "OpSelect": { "opcode": 169, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpIEqual": { "opcode": 170, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpINotEqual": { "opcode": 171, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpUGreaterThan": { "opcode": 172, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpSGreaterThan": { "opcode": 173, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpUGreaterThanEqual": { "opcode": 174, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpSGreaterThanEqual": { "opcode": 175, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpULessThan": { "opcode": 176, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpSLessThan": { "opcode": 177, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpULessThanEqual": { "opcode": 178, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpSLessThanEqual": { "opcode": 179, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpFOrdEqual": { "opcode": 180, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpFUnordEqual": { "opcode": 181, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpFOrdNotEqual": { "opcode": 182, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpFUnordNotEqual": { "opcode": 183, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpFOrdLessThan": { "opcode": 184, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpFUnordLessThan": { "opcode": 185, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpFOrdGreaterThan": { "opcode": 186, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpFUnordGreaterThan": { "opcode": 187, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpFOrdLessThanEqual": { "opcode": 188, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpFUnordLessThanEqual": { "opcode": 189, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpFOrdGreaterThanEqual": { "opcode": 190, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpFUnordGreaterThanEqual": { "opcode": 191, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpShiftRightLogical": { "opcode": 194, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpShiftRightArithmetic": { "opcode": 195, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpShiftLeftLogical": { "opcode": 196, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpBitwiseOr": { "opcode": 197, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpBitwiseXor": { "opcode": 198, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpBitwiseAnd": { "opcode": 199, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpNot": { "opcode": 200, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" } ] }, "OpBitFieldInsert": { "opcode": 201, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpBitFieldSExtract": { "opcode": 202, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpBitFieldUExtract": { "opcode": 203, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpBitReverse": { "opcode": 204, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" } ] }, "OpBitCount": { "opcode": 205, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" } ] }, "OpDPdx": { "opcode": 207, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" } ] }, "OpDPdy": { "opcode": 208, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" } ] }, "OpFwidth": { "opcode": 209, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" } ] }, "OpDPdxFine": { "opcode": 210, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" } ] }, "OpDPdyFine": { "opcode": 211, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" } ] }, "OpFwidthFine": { "opcode": 212, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" } ] }, "OpDPdxCoarse": { "opcode": 213, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" } ] }, "OpDPdyCoarse": { "opcode": 214, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" } ] }, "OpFwidthCoarse": { "opcode": 215, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" } ] }, "OpControlBarrier": { "opcode": 224, "operands": [ { "kind": "IdScope" }, { "kind": "IdScope" }, { "kind": "IdMemorySemantics" } ] }, "OpMemoryBarrier": { "opcode": 225, "operands": [ { "kind": "IdScope" }, { "kind": "IdMemorySemantics" } ] }, "OpAtomicLoad": { "opcode": 227, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdScope" }, { "kind": "IdMemorySemantics" } ] }, "OpAtomicStore": { "opcode": 228, "operands": [ { "kind": "IdRef" }, { "kind": "IdScope" }, { "kind": "IdMemorySemantics" }, { "kind": "IdRef" } ] }, "OpAtomicExchange": { "opcode": 229, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdScope" }, { "kind": "IdMemorySemantics" }, { "kind": "IdRef" } ] }, "OpAtomicCompareExchange": { "opcode": 230, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdScope" }, { "kind": "IdMemorySemantics" }, { "kind": "IdMemorySemantics" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpAtomicIIncrement": { "opcode": 232, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdScope" }, { "kind": "IdMemorySemantics" } ] }, "OpAtomicIDecrement": { "opcode": 233, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdScope" }, { "kind": "IdMemorySemantics" } ] }, "OpAtomicIAdd": { "opcode": 234, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdScope" }, { "kind": "IdMemorySemantics" }, { "kind": "IdRef" } ] }, "OpAtomicISub": { "opcode": 235, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdScope" }, { "kind": "IdMemorySemantics" }, { "kind": "IdRef" } ] }, "OpAtomicSMin": { "opcode": 236, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdScope" }, { "kind": "IdMemorySemantics" }, { "kind": "IdRef" } ] }, "OpAtomicUMin": { "opcode": 237, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdScope" }, { "kind": "IdMemorySemantics" }, { "kind": "IdRef" } ] }, "OpAtomicSMax": { "opcode": 238, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdScope" }, { "kind": "IdMemorySemantics" }, { "kind": "IdRef" } ] }, "OpAtomicUMax": { "opcode": 239, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdScope" }, { "kind": "IdMemorySemantics" }, { "kind": "IdRef" } ] }, "OpAtomicAnd": { "opcode": 240, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdScope" }, { "kind": "IdMemorySemantics" }, { "kind": "IdRef" } ] }, "OpAtomicOr": { "opcode": 241, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdScope" }, { "kind": "IdMemorySemantics" }, { "kind": "IdRef" } ] }, "OpAtomicXor": { "opcode": 242, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdScope" }, { "kind": "IdMemorySemantics" }, { "kind": "IdRef" } ] }, "OpPhi": { "opcode": 245, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "PairIdRefIdRef", "quantifier": "*" } ] }, "OpLoopMerge": { "opcode": 246, "operands": [ { "kind": "IdRef" }, { "kind": "IdRef" }, { "kind": "LoopControl" } ] }, "OpSelectionMerge": { "opcode": 247, "operands": [ { "kind": "IdRef" }, { "kind": "SelectionControl" } ] }, "OpLabel": { "opcode": 248, "operands": [ { "kind": "IdResult" } ] }, "OpBranch": { "opcode": 249, "operands": [ { "kind": "IdRef" } ] }, "OpBranchConditional": { "opcode": 250, "operands": [ { "kind": "IdRef" }, { "kind": "IdRef" }, { "kind": "IdRef" }, { "kind": "LiteralInteger", "quantifier": "*" } ] }, "OpSwitch": { "opcode": 251, "operands": [ { "kind": "IdRef" }, { "kind": "IdRef" }, { "kind": "PairLiteralIntegerIdRef", "quantifier": "*" } ] }, "OpKill": { "opcode": 252, "operands": [ ] }, "OpReturn": { "opcode": 253, "operands": [ ] }, "OpReturnValue": { "opcode": 254, "operands": [ { "kind": "IdRef" } ] }, "OpUnreachable": { "opcode": 255, "operands": [ ] }, "OpNoLine": { "opcode": 317, "operands": [ ] }, "OpModuleProcessed": { "opcode": 330, "operands": [ { "kind": "LiteralString" } ] }, "OpExecutionModeId": { "opcode": 331, "operands": [ { "kind": "IdRef" }, { "kind": "ExecutionMode" } ] }, "OpDecorateId": { "opcode": 332, "operands": [ { "kind": "IdRef" }, { "kind": "Decoration" } ] }, "OpCopyLogical": { "opcode": 400, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" } ] }, "OpPtrEqual": { "opcode": 401, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpPtrNotEqual": { "opcode": 402, "operands": [ { "kind": "IdResultType" }, { "kind": "IdResult" }, { "kind": "IdRef" }, { "kind": "IdRef" } ] }, "OpDecorateString": { "opcode": 5632, "operands": [ { "kind": "IdRef" }, { "kind": "Decoration" } ] }, "OpDecorateStringGOOGLE": { "opcode": 5632, "operands": [ { "kind": "IdRef" }, { "kind": "Decoration" } ] }, "OpMemberDecorateString": { "opcode": 5633, "operands": [ { "kind": "IdRef" }, { "kind": "LiteralInteger" }, { "kind": "Decoration" } ] }, "OpMemberDecorateStringGOOGLE": { "opcode": 5633, "operands": [ { "kind": "IdRef" }, { "kind": "LiteralInteger" }, { "kind": "Decoration" } ] } }, "operand_kinds": { "ImageOperands": { "type": "BitEnum", "values": { "None": { "value": 0 }, "Bias": { "value": 1, "params": [ "IdRef" ] }, "Lod": { "value": 2, "params": [ "IdRef" ] }, "Grad": { "value": 4, "params": [ "IdRef", "IdRef" ] }, "ConstOffset": { "value": 8, "params": [ "IdRef" ] }, "Sample": { "value": 64, "params": [ "IdRef" ] }, "MakeTexelAvailable": { "value": 256, "params": [ "IdScope" ] }, "MakeTexelAvailableKHR": { "value": 256, "params": [ "IdScope" ] }, "MakeTexelVisible": { "value": 512, "params": [ "IdScope" ] }, "MakeTexelVisibleKHR": { "value": 512, "params": [ "IdScope" ] }, "NonPrivateTexel": { "value": 1024 }, "NonPrivateTexelKHR": { "value": 1024 }, "VolatileTexel": { "value": 2048 }, "VolatileTexelKHR": { "value": 2048 }, "SignExtend": { "value": 4096 }, "ZeroExtend": { "value": 8192 } } }, "FPFastMathMode": { "type": "BitEnum", "values": { "None": { "value": 0 } } }, "SelectionControl": { "type": "BitEnum", "values": { "None": { "value": 0 }, "Flatten": { "value": 1 }, "DontFlatten": { "value": 2 } } }, "LoopControl": { "type": "BitEnum", "values": { "None": { "value": 0 }, "Unroll": { "value": 1 }, "DontUnroll": { "value": 2 }, "DependencyInfinite": { "value": 4 }, "DependencyLength": { "value": 8, "params": [ "LiteralInteger" ] }, "MinIterations": { "value": 16, "params": [ "LiteralInteger" ] }, "MaxIterations": { "value": 32, "params": [ "LiteralInteger" ] }, "IterationMultiple": { "value": 64, "params": [ "LiteralInteger" ] }, "PeelCount": { "value": 128, "params": [ "LiteralInteger" ] }, "PartialCount": { "value": 256, "params": [ "LiteralInteger" ] } } }, "FunctionControl": { "type": "BitEnum", "values": { "None": { "value": 0 }, "Inline": { "value": 1 }, "DontInline": { "value": 2 }, "Pure": { "value": 4 }, "Const": { "value": 8 } } }, "MemorySemantics": { "type": "BitEnum", "values": { "Relaxed": { "value": 0 }, "None": { "value": 0 }, "Acquire": { "value": 2 }, "Release": { "value": 4 }, "AcquireRelease": { "value": 8 }, "SequentiallyConsistent": { "value": 16 }, "UniformMemory": { "value": 64 }, "SubgroupMemory": { "value": 128 }, "WorkgroupMemory": { "value": 256 }, "CrossWorkgroupMemory": { "value": 512 }, "ImageMemory": { "value": 2048 }, "OutputMemory": { "value": 4096 }, "OutputMemoryKHR": { "value": 4096 }, "MakeAvailable": { "value": 8192 }, "MakeAvailableKHR": { "value": 8192 }, "MakeVisible": { "value": 16384 }, "MakeVisibleKHR": { "value": 16384 }, "Volatile": { "value": 32768 } } }, "MemoryAccess": { "type": "BitEnum", "values": { "None": { "value": 0 }, "Volatile": { "value": 1 }, "Aligned": { "value": 2, "params": [ "LiteralInteger" ] }, "Nontemporal": { "value": 4 }, "MakePointerAvailable": { "value": 8, "params": [ "IdScope" ] }, "MakePointerAvailableKHR": { "value": 8, "params": [ "IdScope" ] }, "MakePointerVisible": { "value": 16, "params": [ "IdScope" ] }, "MakePointerVisibleKHR": { "value": 16, "params": [ "IdScope" ] }, "NonPrivatePointer": { "value": 32 }, "NonPrivatePointerKHR": { "value": 32 } } }, "KernelProfilingInfo": { "type": "BitEnum", "values": { "None": { "value": 0 } } }, "SourceLanguage": { "type": "ValueEnum", "values": { "Unknown": { "value": 0 }, "ESSL": { "value": 1 }, "GLSL": { "value": 2 }, "OpenCL_C": { "value": 3 }, "OpenCL_CPP": { "value": 4 }, "HLSL": { "value": 5 } } }, "ExecutionModel": { "type": "ValueEnum", "values": { "Vertex": { "value": 0 }, "Fragment": { "value": 4 }, "GLCompute": { "value": 5 } } }, "AddressingModel": { "type": "ValueEnum", "values": { "Logical": { "value": 0 } } }, "MemoryModel": { "type": "ValueEnum", "values": { "Simple": { "value": 0 }, "GLSL450": { "value": 1 }, "Vulkan": { "value": 3 }, "VulkanKHR": { "value": 3 } } }, "ExecutionMode": { "type": "ValueEnum", "values": { "PixelCenterInteger": { "value": 6 }, "OriginUpperLeft": { "value": 7 }, "OriginLowerLeft": { "value": 8 }, "EarlyFragmentTests": { "value": 9 }, "DepthReplacing": { "value": 12 }, "DepthGreater": { "value": 14 }, "DepthLess": { "value": 15 }, "DepthUnchanged": { "value": 16 }, "LocalSize": { "value": 17, "params": [ "LiteralInteger", "LiteralInteger", "LiteralInteger" ] }, "LocalSizeId": { "value": 38, "params": [ "IdRef", "IdRef", "IdRef" ] } } }, "StorageClass": { "type": "ValueEnum", "values": { "UniformConstant": { "value": 0 }, "Input": { "value": 1 }, "Uniform": { "value": 2 }, "Output": { "value": 3 }, "Workgroup": { "value": 4 }, "CrossWorkgroup": { "value": 5 }, "Private": { "value": 6 }, "Function": { "value": 7 }, "PushConstant": { "value": 9 }, "Image": { "value": 11 }, "StorageBuffer": { "value": 12 } } }, "Dim": { "type": "ValueEnum", "values": { "1D": { "value": 0 }, "2D": { "value": 1 }, "3D": { "value": 2 }, "Cube": { "value": 3 } } }, "ImageFormat": { "type": "ValueEnum", "values": { "Unknown": { "value": 0 }, "Rgba32f": { "value": 1 }, "Rgba16f": { "value": 2 }, "R32f": { "value": 3 }, "Rgba8": { "value": 4 }, "Rgba8Snorm": { "value": 5 }, "Rgba32i": { "value": 21 }, "Rgba16i": { "value": 22 }, "Rgba8i": { "value": 23 }, "R32i": { "value": 24 }, "Rgba32ui": { "value": 30 }, "Rgba16ui": { "value": 31 }, "Rgba8ui": { "value": 32 }, "R32ui": { "value": 33 } } }, "FPRoundingMode": { "type": "ValueEnum", "values": { "RTE": { "value": 0 }, "RTZ": { "value": 1 }, "RTP": { "value": 2 }, "RTN": { "value": 3 } } }, "Decoration": { "type": "ValueEnum", "values": { "RelaxedPrecision": { "value": 0 }, "SpecId": { "value": 1, "params": [ "LiteralInteger" ] }, "Block": { "value": 2 }, "BufferBlock": { "value": 3 }, "RowMajor": { "value": 4 }, "ColMajor": { "value": 5 }, "ArrayStride": { "value": 6, "params": [ "LiteralInteger" ] }, "MatrixStride": { "value": 7, "params": [ "LiteralInteger" ] }, "GLSLShared": { "value": 8 }, "GLSLPacked": { "value": 9 }, "BuiltIn": { "value": 11, "params": [ "BuiltIn" ] }, "NoPerspective": { "value": 13 }, "Flat": { "value": 14 }, "Centroid": { "value": 16 }, "Invariant": { "value": 18 }, "Restrict": { "value": 19 }, "Aliased": { "value": 20 }, "Volatile": { "value": 21 }, "Coherent": { "value": 23 }, "NonWritable": { "value": 24 }, "NonReadable": { "value": 25 }, "Uniform": { "value": 26 }, "UniformId": { "value": 27, "params": [ "IdScope" ] }, "Location": { "value": 30, "params": [ "LiteralInteger" ] }, "Component": { "value": 31, "params": [ "LiteralInteger" ] }, "Index": { "value": 32, "params": [ "LiteralInteger" ] }, "Binding": { "value": 33, "params": [ "LiteralInteger" ] }, "DescriptorSet": { "value": 34, "params": [ "LiteralInteger" ] }, "Offset": { "value": 35, "params": [ "LiteralInteger" ] }, "FPRoundingMode": { "value": 39, "params": [ "FPRoundingMode" ] }, "NoContraction": { "value": 42 }, "NoSignedWrap": { "value": 4469 }, "NoUnsignedWrap": { "value": 4470 }, "ExplicitInterpAMD": { "value": 4999 }, "CounterBuffer": { "value": 5634, "params": [ "IdRef" ] }, "HlslCounterBufferGOOGLE": { "value": 5634, "params": [ "IdRef" ] }, "UserSemantic": { "value": 5635, "params": [ "LiteralString" ] }, "HlslSemanticGOOGLE": { "value": 5635, "params": [ "LiteralString" ] }, "UserTypeGOOGLE": { "value": 5636, "params": [ "LiteralString" ] } } }, "BuiltIn": { "type": "ValueEnum", "values": { "Position": { "value": 0 }, "PointSize": { "value": 1 }, "VertexId": { "value": 5 }, "InstanceId": { "value": 6 }, "FragCoord": { "value": 15 }, "PointCoord": { "value": 16 }, "FrontFacing": { "value": 17 }, "SampleMask": { "value": 20 }, "FragDepth": { "value": 22 }, "HelperInvocation": { "value": 23 }, "NumWorkgroups": { "value": 24 }, "WorkgroupSize": { "value": 25 }, "WorkgroupId": { "value": 26 }, "LocalInvocationId": { "value": 27 }, "GlobalInvocationId": { "value": 28 }, "LocalInvocationIndex": { "value": 29 }, "VertexIndex": { "value": 42 }, "InstanceIndex": { "value": 43 }, "BaryCoordNoPerspAMD": { "value": 4992 }, "BaryCoordNoPerspCentroidAMD": { "value": 4993 }, "BaryCoordNoPerspSampleAMD": { "value": 4994 }, "BaryCoordSmoothAMD": { "value": 4995 }, "BaryCoordSmoothCentroidAMD": { "value": 4996 }, "BaryCoordSmoothSampleAMD": { "value": 4997 }, "BaryCoordPullModelAMD": { "value": 4998 } } }, "Scope": { "type": "ValueEnum", "values": { "CrossDevice": { "value": 0 }, "Device": { "value": 1 }, "Workgroup": { "value": 2 }, "Subgroup": { "value": 3 }, "Invocation": { "value": 4 }, "QueueFamily": { "value": 5 }, "QueueFamilyKHR": { "value": 5 } } }, "Capability": { "type": "ValueEnum", "values": { "Matrix": { "value": 0 }, "Shader": { "value": 1 }, "Geometry": { "value": 2 }, "Tessellation": { "value": 3 }, "Addresses": { "value": 4 }, "Linkage": { "value": 5 }, "Kernel": { "value": 6 }, "Float16": { "value": 9 }, "Float64": { "value": 10 }, "Int64": { "value": 11 }, "Groups": { "value": 18 }, "AtomicStorage": { "value": 21 }, "Int16": { "value": 22 }, "ImageGatherExtended": { "value": 25 }, "StorageImageMultisample": { "value": 27 }, "UniformBufferArrayDynamicIndexing": { "value": 28 }, "SampledImageArrayDynamicIndexing": { "value": 29 }, "StorageBufferArrayDynamicIndexing": { "value": 30 }, "StorageImageArrayDynamicIndexing": { "value": 31 }, "ClipDistance": { "value": 32 }, "CullDistance": { "value": 33 }, "SampleRateShading": { "value": 35 }, "SampledRect": { "value": 37 }, "Int8": { "value": 39 }, "InputAttachment": { "value": 40 }, "SparseResidency": { "value": 41 }, "MinLod": { "value": 42 }, "Sampled1D": { "value": 43 }, "Image1D": { "value": 44 }, "SampledCubeArray": { "value": 45 }, "SampledBuffer": { "value": 46 }, "ImageMSArray": { "value": 48 }, "StorageImageExtendedFormats": { "value": 49 }, "ImageQuery": { "value": 50 }, "DerivativeControl": { "value": 51 }, "InterpolationFunction": { "value": 52 }, "TransformFeedback": { "value": 53 }, "StorageImageReadWithoutFormat": { "value": 55 }, "StorageImageWriteWithoutFormat": { "value": 56 }, "GroupNonUniform": { "value": 61 }, "ShaderLayer": { "value": 69 }, "ShaderViewportIndex": { "value": 70 }, "SubgroupBallotKHR": { "value": 4423 }, "DrawParameters": { "value": 4427 }, "SubgroupVoteKHR": { "value": 4431 }, "StorageBuffer16BitAccess": { "value": 4433 }, "StorageUniformBufferBlock16": { "value": 4433 }, "StoragePushConstant16": { "value": 4435 }, "StorageInputOutput16": { "value": 4436 }, "DeviceGroup": { "value": 4437 }, "MultiView": { "value": 4439 }, "VariablePointersStorageBuffer": { "value": 4441 }, "AtomicStorageOps": { "value": 4445 }, "SampleMaskPostDepthCoverage": { "value": 4447 }, "StorageBuffer8BitAccess": { "value": 4448 }, "StoragePushConstant8": { "value": 4450 }, "DenormPreserve": { "value": 4464 }, "DenormFlushToZero": { "value": 4465 }, "SignedZeroInfNanPreserve": { "value": 4466 }, "RoundingModeRTE": { "value": 4467 }, "RoundingModeRTZ": { "value": 4468 }, "Float16ImageAMD": { "value": 5008 }, "ImageGatherBiasLodAMD": { "value": 5009 }, "FragmentMaskAMD": { "value": 5010 }, "StencilExportEXT": { "value": 5013 }, "ImageReadWriteLodAMD": { "value": 5015 }, "ShaderClockKHR": { "value": 5055 }, "QuadControlKHR": { "value": 5087 }, "FragmentFullyCoveredEXT": { "value": 5265 }, "MeshShadingNV": { "value": 5266 }, "ImageFootprintNV": { "value": 5282 }, "FragmentBarycentricNV": { "value": 5284 }, "ComputeDerivativeGroupQuadsNV": { "value": 5288 }, "FragmentDensityEXT": { "value": 5291 }, "ShadingRateNV": { "value": 5291 }, "GroupNonUniformPartitionedNV": { "value": 5297 }, "ShaderNonUniform": { "value": 5301 }, "ShaderNonUniformEXT": { "value": 5301 }, "RuntimeDescriptorArray": { "value": 5302 }, "RuntimeDescriptorArrayEXT": { "value": 5302 }, "RayTracingNV": { "value": 5340 }, "VulkanMemoryModel": { "value": 5345 }, "VulkanMemoryModelKHR": { "value": 5345 }, "VulkanMemoryModelDeviceScope": { "value": 5346 }, "VulkanMemoryModelDeviceScopeKHR": { "value": 5346 }, "PhysicalStorageBufferAddresses": { "value": 5347 }, "PhysicalStorageBufferAddressesEXT": { "value": 5347 }, "ComputeDerivativeGroupLinearNV": { "value": 5350 }, "CooperativeMatrixNV": { "value": 5357 }, "FragmentShaderSampleInterlockEXT": { "value": 5363 }, "FragmentShaderShadingRateInterlockEXT": { "value": 5372 }, "ShaderSMBuiltinsNV": { "value": 5373 }, "FragmentShaderPixelInterlockEXT": { "value": 5378 }, "DemoteToHelperInvocationEXT": { "value": 5379 }, "SubgroupShuffleINTEL": { "value": 5568 }, "SubgroupBufferBlockIOINTEL": { "value": 5569 }, "SubgroupImageBlockIOINTEL": { "value": 5570 }, "SubgroupImageMediaBlockIOINTEL": { "value": 5579 }, "IntegerFunctions2INTEL": { "value": 5584 }, "SubgroupAvcMotionEstimationINTEL": { "value": 5696 }, "SubgroupAvcMotionEstimationIntraINTEL": { "value": 5697 }, "SubgroupAvcMotionEstimationChromaINTEL": { "value": 5698 } } } }, "ext": { "Round": 1, "RoundEven": 2, "Trunc": 3, "FAbs": 4, "SAbs": 5, "FSign": 6, "SSign": 7, "Floor": 8, "Ceil": 9, "Fract": 10, "Radians": 11, "Degrees": 12, "Sin": 13, "Cos": 14, "Tan": 15, "Asin": 16, "Acos": 17, "Atan": 18, "Sinh": 19, "Cosh": 20, "Tanh": 21, "Asinh": 22, "Acosh": 23, "Atanh": 24, "Atan2": 25, "Pow": 26, "Exp": 27, "Log": 28, "Exp2": 29, "Log2": 30, "Sqrt": 31, "InverseSqrt": 32, "Determinant": 33, "MatrixInverse": 34, "Modf": 35, "ModfStruct": 36, "FMin": 37, "UMin": 38, "SMin": 39, "FMax": 40, "UMax": 41, "SMax": 42, "FClamp": 43, "UClamp": 44, "SClamp": 45, "FMix": 46, "IMix": 47, "Step": 48, "SmoothStep": 49, "Fma": 50, "Frexp": 51, "FrexpStruct": 52, "Ldexp": 53, "PackSnorm4x8": 54, "PackUnorm4x8": 55, "PackSnorm2x16": 56, "PackUnorm2x16": 57, "PackHalf2x16": 58, "PackDouble2x32": 59, "UnpackSnorm2x16": 60, "UnpackUnorm2x16": 61, "UnpackHalf2x16": 62, "UnpackSnorm4x8": 63, "UnpackUnorm4x8": 64, "UnpackDouble2x32": 65, "Length": 66, "Distance": 67, "Cross": 68, "Normalize": 69, "FaceForward": 70, "Reflect": 71, "Refract": 72, "FindILsb": 73, "FindSMsb": 74, "FindUMsb": 75, "InterpolateAtCentroid": 76, "InterpolateAtSample": 77, "InterpolateAtOffset": 78, "NMin": 79, "NMax": 80, "NClamp": 81 } } KhronosGroup-SPIRV-Tools-f289d04/tools/sva/src/sva.js000066400000000000000000000024021475742701700223760ustar00rootroot00000000000000// Copyright 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. import Parser from "./parser.js"; import Lexer from "./lexer.js"; import Assembler from "./assembler.js"; import grammar from "./spirv.data.js"; export default class SVA { /** * Attempts to convert |input| SPIR-V assembly into SPIR-V binary. * * @param {String} the input string containing the assembly * @return {Uint32Array|string} returns a Uint32Array containing the binary * SPIR-V or a string on error. */ static assemble(input) { let l = new Lexer(input); let p = new Parser(grammar, l); let ast = p.parse(); if (ast === undefined) return p.error; let a = new Assembler(ast); return a.assemble(); } } KhronosGroup-SPIRV-Tools-f289d04/tools/sva/src/token.js000066400000000000000000000027351475742701700227360ustar00rootroot00000000000000// Copyright 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. const TokenType = { kEOF: "end of file", kError: "error", kIdentifier: "identifier", kIntegerLiteral: "integer_literal", kFloatLiteral: "float_literal", kStringLiteral: "string_literal", kResultId: "result_id", kOp: "Op", kEqual: "=", kPipe: "|", }; class Token { /** * @param {TokenType} type The type of token * @param {Integer} line The line number this token was on * @param {Any} data Data attached to the token * @param {Integer} bits If the type is a float or integer the bit width */ constructor(type, line, data) { this.type_ = type; this.line_ = line; this.data_ = data; this.bits_ = 0; } get type() { return this.type_; } get line() { return this.line_; } get data() { return this.data_; } set data(val) { this.data_ = val; } get bits() { return this.bits_; } set bits(val) { this.bits_ = val; } } export {Token, TokenType}; KhronosGroup-SPIRV-Tools-f289d04/tools/sva/tests/000077500000000000000000000000001475742701700216245ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/tools/sva/tests/empty_main.spv_asm000066400000000000000000000010761475742701700253640ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 6 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" OpExecutionMode %main OriginUpperLeft OpSource GLSL 440 OpName %main "main" %void = OpTypeVoid %3 = OpTypeFunction %void %main = OpFunction %void None %3 %5 = OpLabel OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/tools/sva/tests/index.html000066400000000000000000000007551475742701700236300ustar00rootroot00000000000000
KhronosGroup-SPIRV-Tools-f289d04/tools/sva/tests/simple.spv_asm000066400000000000000000000022031475742701700245040ustar00rootroot00000000000000; SPIR-V ; Version: 1.0 ; Generator: Khronos Glslang Reference Front End; 7 ; Bound: 14 ; Schema: 0 OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragColor OpExecutionMode %main OriginUpperLeft OpSource GLSL 330 OpName %main "main" OpName %gl_FragColor "gl_FragColor" OpDecorate %gl_FragColor Location 0 %void = OpTypeVoid %3 = OpTypeFunction %void %float = OpTypeFloat 32 %v4float = OpTypeVector %float 4 %_ptr_Output_v4float = OpTypePointer Output %v4float %gl_FragColor = OpVariable %_ptr_Output_v4float Output %float_0_400000006 = OpConstant %float 0.400000006 %float_0_800000012 = OpConstant %float 0.800000012 %float_1 = OpConstant %float 1 %13 = OpConstantComposite %v4float %float_0_400000006 %float_0_400000006 %float_0_800000012 %float_1 %main = OpFunction %void None %3 %5 = OpLabel OpStore %gl_FragColor %13 OpReturn OpFunctionEnd KhronosGroup-SPIRV-Tools-f289d04/tools/sva/tools/000077500000000000000000000000001475742701700216225ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/tools/sva/tools/process_grammar.rb000077500000000000000000000055051475742701700253430ustar00rootroot00000000000000#!/usr/bin/env ruby # Copyright 2019 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. require 'json' GRAMMAR = "../../external/spirv-headers/include/spirv/unified1/spirv.core.grammar.json" GLSL = "../../external/spirv-headers/include/spirv/unified1/extinst.glsl.std.450.grammar.json" CAPABILITIES = %w( Matrix Shader Sampled1D Image1D DerivativeControl ImageQuery VulkanMemoryModel ) g = JSON.parse(File.open(GRAMMAR).read) magic = g['magic_number'] vers = [g['major_version'], g['minor_version']] instructions = {} g['instructions'].each do |inst| if (inst.has_key?('capabilities')) skip = true inst['capabilities'].each do |cap| if CAPABILITIES.include?(cap) skip = false break end end next if skip end op = { opcode: inst['opcode'], operands: [] } if !inst['operands'].nil? inst['operands'].each do |operand| operand.delete('name') op[:operands] << operand end end instructions[inst['opname']] = op end operand_kinds = {} g['operand_kinds'].each do |op_kind| next if op_kind['category'] !~ /Enum/ kind = { type: op_kind['category'], values: {} } op_kind['enumerants'].each do |enum| if (enum.has_key?('capabilities')) skip = true enum['capabilities'].each do |cap| if CAPABILITIES.include?(cap) skip = false break end end next if skip end v = if op_kind['category'] == 'BitEnum' enum['value'].to_i(16) else enum['value'].to_i end params = [] if enum.has_key?('parameters') enum['parameters'].each do |param| params << param['kind'] end end kind[:values][enum['enumerant']] = {value: v} kind[:values][enum['enumerant']][:params] = params unless params.empty? end next if kind[:values].empty? operand_kinds[op_kind['kind']] = kind end # We only support GLSL extensions at the moment. ext = {} glsl = JSON.parse(File.open(GLSL).read) glsl['instructions'].each do |inst| ext[inst['opname']] = inst['opcode'] end puts "/*#{g['copyright'].join("\n")}*/" puts "\n// THIS FILE IS GENERATED WITH tools/process_grammar.rb\n\n" puts "export default " + JSON.pretty_generate({ magic: magic, version: vers, instructions: instructions, operand_kinds: operand_kinds, ext: ext }) KhronosGroup-SPIRV-Tools-f289d04/tools/sva/yarn.lock000066400000000000000000002027351475742701700223160ustar00rootroot00000000000000# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY. # yarn lockfile v1 "@eslint-community/eslint-utils@^4.2.0": version "4.4.0" resolved "https://registry.yarnpkg.com/@eslint-community/eslint-utils/-/eslint-utils-4.4.0.tgz#a23514e8fb9af1269d5f7788aa556798d61c6b59" integrity sha512-1/sA4dwrzBAyeUoQ6oxahHKmrZvsnLCg4RfxW3ZFGGmQkSNQPFNLV9CUEFQP1x9EYXHTo5p6xdhZM1Ne9p/AfA== dependencies: eslint-visitor-keys "^3.3.0" "@eslint-community/regexpp@^4.4.0": version "4.5.1" resolved "https://registry.yarnpkg.com/@eslint-community/regexpp/-/regexpp-4.5.1.tgz#cdd35dce4fa1a89a4fd42b1599eb35b3af408884" integrity sha512-Z5ba73P98O1KUYCCJTUeVpja9RcGoMdncZ6T49FCUl2lN38JtCJ+3WgIDBv0AuY4WChU5PmtJmOCTlN6FZTFKQ== "@eslint/eslintrc@^2.0.3": version "2.0.3" resolved "https://registry.yarnpkg.com/@eslint/eslintrc/-/eslintrc-2.0.3.tgz#4910db5505f4d503f27774bf356e3704818a0331" integrity sha512-+5gy6OQfk+xx3q0d6jGZZC3f3KzAkXc/IanVxd1is/VIIziRqqt3ongQz0FiTUXqTk0c7aDB3OaFuKnuSoJicQ== dependencies: ajv "^6.12.4" debug "^4.3.2" espree "^9.5.2" globals "^13.19.0" ignore "^5.2.0" import-fresh "^3.2.1" js-yaml "^4.1.0" minimatch "^3.1.2" strip-json-comments "^3.1.1" "@eslint/js@8.41.0": version "8.41.0" resolved "https://registry.yarnpkg.com/@eslint/js/-/js-8.41.0.tgz#080321c3b68253522f7646b55b577dd99d2950b3" integrity sha512-LxcyMGxwmTh2lY9FwHPGWOHmYFCZvbrFCBZL4FzSSsxsRPuhrYUg/49/0KDfW8tnIEaEHtfmn6+NPN+1DqaNmA== "@humanwhocodes/config-array@^0.11.8": version "0.11.8" resolved "https://registry.yarnpkg.com/@humanwhocodes/config-array/-/config-array-0.11.8.tgz#03595ac2075a4dc0f191cc2131de14fbd7d410b9" integrity sha512-UybHIJzJnR5Qc/MsD9Kr+RpO2h+/P1GhOwdiLPXK5TWk5sgTdu88bTD9UP+CKbPPh5Rni1u0GjAdYQLemG8g+g== dependencies: "@humanwhocodes/object-schema" "^1.2.1" debug "^4.1.1" minimatch "^3.0.5" "@humanwhocodes/module-importer@^1.0.1": version "1.0.1" resolved "https://registry.yarnpkg.com/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz#af5b2691a22b44be847b0ca81641c5fb6ad0172c" integrity sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA== "@humanwhocodes/object-schema@^1.2.1": version "1.2.1" resolved "https://registry.yarnpkg.com/@humanwhocodes/object-schema/-/object-schema-1.2.1.tgz#b520529ec21d8e5945a1851dfd1c32e94e39ff45" integrity sha512-ZnQMnLV4e7hDlUvw8H+U8ASL02SS2Gn6+9Ac3wGGLIe7+je2AeAOxPY+izIPJDfFDb7eDjev0Us8MO1iFRN8hA== "@nodelib/fs.scandir@2.1.5": version "2.1.5" resolved "https://registry.yarnpkg.com/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz#7619c2eb21b25483f6d167548b4cfd5a7488c3d5" integrity sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g== dependencies: "@nodelib/fs.stat" "2.0.5" run-parallel "^1.1.9" "@nodelib/fs.stat@2.0.5": version "2.0.5" resolved "https://registry.yarnpkg.com/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz#5bd262af94e9d25bd1e71b05deed44876a222e8b" integrity sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A== "@nodelib/fs.walk@^1.2.8": version "1.2.8" resolved "https://registry.yarnpkg.com/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz#e95737e8bb6746ddedf69c556953494f196fe69a" integrity sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg== dependencies: "@nodelib/fs.scandir" "2.1.5" fastq "^1.6.0" "@zeit/schemas@2.29.0": version "2.29.0" resolved "https://registry.yarnpkg.com/@zeit/schemas/-/schemas-2.29.0.tgz#a59ae6ebfdf4ddc66a876872dd736baa58b6696c" integrity sha512-g5QiLIfbg3pLuYUJPlisNKY+epQJTcMDsOnVNkscrDP1oi7vmJnzOANYJI/1pZcVJ6umUkBv3aFtlg1UvUHGzA== accepts@~1.3.5: version "1.3.8" resolved "https://registry.yarnpkg.com/accepts/-/accepts-1.3.8.tgz#0bf0be125b67014adcb0b0921e62db7bffe16b2e" integrity sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw== dependencies: mime-types "~2.1.34" negotiator "0.6.3" acorn-jsx@^5.3.2: version "5.3.2" resolved "https://registry.yarnpkg.com/acorn-jsx/-/acorn-jsx-5.3.2.tgz#7ed5bb55908b3b2f1bc55c6af1653bada7f07937" integrity sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ== acorn@^8.8.0: version "8.8.2" resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.8.2.tgz#1b2f25db02af965399b9776b0c2c391276d37c4a" integrity sha512-xjIYgE8HBrkpd/sJqOGNspf8uHG+NOHGOw6a/Urj8taM2EXfdNAH2oFcPeIFfsv3+kz/mJrS5VuMqbNLjCa2vw== ajv@8.11.0: version "8.11.0" resolved "https://registry.yarnpkg.com/ajv/-/ajv-8.11.0.tgz#977e91dd96ca669f54a11e23e378e33b884a565f" integrity sha512-wGgprdCvMalC0BztXvitD2hC04YffAvtsUn93JbGXYLAtCUO4xd17mCCZQxUOItiBwZvJScWo8NIvQMQ71rdpg== dependencies: fast-deep-equal "^3.1.1" json-schema-traverse "^1.0.0" require-from-string "^2.0.2" uri-js "^4.2.2" ajv@^6.10.0, ajv@^6.12.4: version "6.12.6" resolved "https://registry.yarnpkg.com/ajv/-/ajv-6.12.6.tgz#baf5a62e802b07d977034586f8c3baf5adf26df4" integrity sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g== dependencies: fast-deep-equal "^3.1.1" fast-json-stable-stringify "^2.0.0" json-schema-traverse "^0.4.1" uri-js "^4.2.2" ansi-align@^3.0.1: version "3.0.1" resolved "https://registry.yarnpkg.com/ansi-align/-/ansi-align-3.0.1.tgz#0cdf12e111ace773a86e9a1fad1225c43cb19a59" integrity sha512-IOfwwBF5iczOjp/WeY4YxyjqAFMQoZufdQWDd19SEExbVLNXqvpzSJ/M7Za4/sCPmQ0+GRquoA7bGcINcxew6w== dependencies: string-width "^4.1.0" ansi-colors@4.1.1: version "4.1.1" resolved "https://registry.yarnpkg.com/ansi-colors/-/ansi-colors-4.1.1.tgz#cbb9ae256bf750af1eab344f229aa27fe94ba348" integrity sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA== ansi-regex@^5.0.1: version "5.0.1" resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-5.0.1.tgz#082cb2c89c9fe8659a311a53bd6a4dc5301db304" integrity sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ== ansi-regex@^6.0.1: version "6.0.1" resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-6.0.1.tgz#3183e38fae9a65d7cb5e53945cd5897d0260a06a" integrity sha512-n5M855fKb2SsfMIiFFoVrABHJC8QtHwVx+mHWP3QcEqBHYienj5dHSgjbxtC0WEZXYt4wcD6zrQElDPhFuZgfA== ansi-styles@^4.0.0, ansi-styles@^4.1.0: version "4.3.0" resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-4.3.0.tgz#edd803628ae71c04c85ae7a0906edad34b648937" integrity sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg== dependencies: color-convert "^2.0.1" ansi-styles@^6.1.0: version "6.2.1" resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-6.2.1.tgz#0e62320cf99c21afff3b3012192546aacbfb05c5" integrity sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug== anymatch@~3.1.2: version "3.1.3" resolved "https://registry.yarnpkg.com/anymatch/-/anymatch-3.1.3.tgz#790c58b19ba1720a84205b57c618d5ad8524973e" integrity sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw== dependencies: normalize-path "^3.0.0" picomatch "^2.0.4" arch@^2.2.0: version "2.2.0" resolved "https://registry.yarnpkg.com/arch/-/arch-2.2.0.tgz#1bc47818f305764f23ab3306b0bfc086c5a29d11" integrity sha512-Of/R0wqp83cgHozfIYLbBMnej79U/SVGOOyuB3VVFv1NRM/PSFMK12x9KVtiYzJqmnU5WR2qp0Z5rHb7sWGnFQ== arg@5.0.2: version "5.0.2" resolved "https://registry.yarnpkg.com/arg/-/arg-5.0.2.tgz#c81433cc427c92c4dcf4865142dbca6f15acd59c" integrity sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg== argparse@^2.0.1: version "2.0.1" resolved "https://registry.yarnpkg.com/argparse/-/argparse-2.0.1.tgz#246f50f3ca78a3240f6c997e8a9bd1eac49e4b38" integrity sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q== assertion-error@^1.1.0: version "1.1.0" resolved "https://registry.yarnpkg.com/assertion-error/-/assertion-error-1.1.0.tgz#e60b6b0e8f301bd97e5375215bda406c85118c0b" integrity sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw== balanced-match@^1.0.0: version "1.0.2" resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.2.tgz#e83e3a7e3f300b34cb9d87f615fa0cbf357690ee" integrity sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw== binary-extensions@^2.0.0: version "2.2.0" resolved "https://registry.yarnpkg.com/binary-extensions/-/binary-extensions-2.2.0.tgz#75f502eeaf9ffde42fc98829645be4ea76bd9e2d" integrity sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA== boxen@7.0.0: version "7.0.0" resolved "https://registry.yarnpkg.com/boxen/-/boxen-7.0.0.tgz#9e5f8c26e716793fc96edcf7cf754cdf5e3fbf32" integrity sha512-j//dBVuyacJbvW+tvZ9HuH03fZ46QcaKvvhZickZqtB271DxJ7SNRSNxrV/dZX0085m7hISRZWbzWlJvx/rHSg== dependencies: ansi-align "^3.0.1" camelcase "^7.0.0" chalk "^5.0.1" cli-boxes "^3.0.0" string-width "^5.1.2" type-fest "^2.13.0" widest-line "^4.0.1" wrap-ansi "^8.0.1" brace-expansion@^1.1.7: version "1.1.11" resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-1.1.11.tgz#3c7fcbf529d87226f3d2f52b966ff5271eb441dd" integrity sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA== dependencies: balanced-match "^1.0.0" concat-map "0.0.1" brace-expansion@^2.0.1: version "2.0.1" resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-2.0.1.tgz#1edc459e0f0c548486ecf9fc99f2221364b9a0ae" integrity sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA== dependencies: balanced-match "^1.0.0" braces@~3.0.2: version "3.0.3" resolved "https://registry.yarnpkg.com/braces/-/braces-3.0.3.tgz#490332f40919452272d55a8480adc0c441358789" integrity sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA== dependencies: fill-range "^7.1.1" browser-stdout@1.3.1: version "1.3.1" resolved "https://registry.yarnpkg.com/browser-stdout/-/browser-stdout-1.3.1.tgz#baa559ee14ced73452229bad7326467c61fabd60" integrity sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw== bytes@3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/bytes/-/bytes-3.0.0.tgz#d32815404d689699f85a4ea4fa8755dd13a96048" integrity sha512-pMhOfFDPiv9t5jjIXkHosWmkSyQbvsgEVNkz0ERHbuLh2T/7j4Mqqpz523Fe8MVY89KC6Sh/QfS2sM+SjgFDcw== callsites@^3.0.0: version "3.1.0" resolved "https://registry.yarnpkg.com/callsites/-/callsites-3.1.0.tgz#b3630abd8943432f54b3f0519238e33cd7df2f73" integrity sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ== camelcase@^6.0.0: version "6.3.0" resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-6.3.0.tgz#5685b95eb209ac9c0c177467778c9c84df58ba9a" integrity sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA== camelcase@^7.0.0: version "7.0.1" resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-7.0.1.tgz#f02e50af9fd7782bc8b88a3558c32fd3a388f048" integrity sha512-xlx1yCK2Oc1APsPXDL2LdlNP6+uu8OCDdhOBSVT279M/S+y75O30C2VuD8T2ogdePBBl7PfPF4504tnLgX3zfw== chai@^4.3.7: version "4.3.7" resolved "https://registry.yarnpkg.com/chai/-/chai-4.3.7.tgz#ec63f6df01829088e8bf55fca839bcd464a8ec51" integrity sha512-HLnAzZ2iupm25PlN0xFreAlBA5zaBSv3og0DdeGA4Ar6h6rJ3A0rolRUKJhSF2V10GZKDgWF/VmAEsNWjCRB+A== dependencies: assertion-error "^1.1.0" check-error "^1.0.2" deep-eql "^4.1.2" get-func-name "^2.0.0" loupe "^2.3.1" pathval "^1.1.1" type-detect "^4.0.5" chalk-template@0.4.0: version "0.4.0" resolved "https://registry.yarnpkg.com/chalk-template/-/chalk-template-0.4.0.tgz#692c034d0ed62436b9062c1707fadcd0f753204b" integrity sha512-/ghrgmhfY8RaSdeo43hNXxpoHAtxdbskUHjPpfqUWGttFgycUhYPGx3YZBCnUCvOa7Doivn1IZec3DEGFoMgLg== dependencies: chalk "^4.1.2" chalk@5.0.1: version "5.0.1" resolved "https://registry.yarnpkg.com/chalk/-/chalk-5.0.1.tgz#ca57d71e82bb534a296df63bbacc4a1c22b2a4b6" integrity sha512-Fo07WOYGqMfCWHOzSXOt2CxDbC6skS/jO9ynEcmpANMoPrD+W1r1K6Vx7iNm+AQmETU1Xr2t+n8nzkV9t6xh3w== chalk@^4.0.0, chalk@^4.1.0, chalk@^4.1.2: version "4.1.2" resolved "https://registry.yarnpkg.com/chalk/-/chalk-4.1.2.tgz#aac4e2b7734a740867aeb16bf02aad556a1e7a01" integrity sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA== dependencies: ansi-styles "^4.1.0" supports-color "^7.1.0" chalk@^5.0.1: version "5.2.0" resolved "https://registry.yarnpkg.com/chalk/-/chalk-5.2.0.tgz#249623b7d66869c673699fb66d65723e54dfcfb3" integrity sha512-ree3Gqw/nazQAPuJJEy+avdl7QfZMcUvmHIKgEZkGL+xOBzRvup5Hxo6LHuMceSxOabuJLJm5Yp/92R9eMmMvA== check-error@^1.0.2: version "1.0.2" resolved "https://registry.yarnpkg.com/check-error/-/check-error-1.0.2.tgz#574d312edd88bb5dd8912e9286dd6c0aed4aac82" integrity sha512-BrgHpW9NURQgzoNyjfq0Wu6VFO6D7IZEmJNdtgNqpzGG8RuNFHt2jQxWlAs4HMe119chBnv+34syEZtc6IhLtA== chokidar@3.5.3: version "3.5.3" resolved "https://registry.yarnpkg.com/chokidar/-/chokidar-3.5.3.tgz#1cf37c8707b932bd1af1ae22c0432e2acd1903bd" integrity sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw== dependencies: anymatch "~3.1.2" braces "~3.0.2" glob-parent "~5.1.2" is-binary-path "~2.1.0" is-glob "~4.0.1" normalize-path "~3.0.0" readdirp "~3.6.0" optionalDependencies: fsevents "~2.3.2" cli-boxes@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/cli-boxes/-/cli-boxes-3.0.0.tgz#71a10c716feeba005e4504f36329ef0b17cf3145" integrity sha512-/lzGpEWL/8PfI0BmBOPRwp0c/wFNX1RdUML3jK/RcSBA9T8mZDdQpqYBKtCFTOfQbwPqWEOpjqW+Fnayc0969g== clipboardy@3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/clipboardy/-/clipboardy-3.0.0.tgz#f3876247404d334c9ed01b6f269c11d09a5e3092" integrity sha512-Su+uU5sr1jkUy1sGRpLKjKrvEOVXgSgiSInwa/qeID6aJ07yh+5NWc3h2QfjHjBnfX4LhtFcuAWKUsJ3r+fjbg== dependencies: arch "^2.2.0" execa "^5.1.1" is-wsl "^2.2.0" cliui@^7.0.2: version "7.0.4" resolved "https://registry.yarnpkg.com/cliui/-/cliui-7.0.4.tgz#a0265ee655476fc807aea9df3df8df7783808b4f" integrity sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ== dependencies: string-width "^4.2.0" strip-ansi "^6.0.0" wrap-ansi "^7.0.0" color-convert@^2.0.1: version "2.0.1" resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-2.0.1.tgz#72d3a68d598c9bdb3af2ad1e84f21d896abd4de3" integrity sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ== dependencies: color-name "~1.1.4" color-name@~1.1.4: version "1.1.4" resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.4.tgz#c2a09a87acbde69543de6f63fa3995c826c536a2" integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA== compressible@~2.0.16: version "2.0.18" resolved "https://registry.yarnpkg.com/compressible/-/compressible-2.0.18.tgz#af53cca6b070d4c3c0750fbd77286a6d7cc46fba" integrity sha512-AF3r7P5dWxL8MxyITRMlORQNaOA2IkAFaTr4k7BUumjPtRpGDTZpl0Pb1XCO6JeDCBdp126Cgs9sMxqSjgYyRg== dependencies: mime-db ">= 1.43.0 < 2" compression@1.7.4: version "1.7.4" resolved "https://registry.yarnpkg.com/compression/-/compression-1.7.4.tgz#95523eff170ca57c29a0ca41e6fe131f41e5bb8f" integrity sha512-jaSIDzP9pZVS4ZfQ+TzvtiWhdpFhE2RDHz8QJkpX9SIpLq88VueF5jJw6t+6CUQcAoA6t+x89MLrWAqpfDE8iQ== dependencies: accepts "~1.3.5" bytes "3.0.0" compressible "~2.0.16" debug "2.6.9" on-headers "~1.0.2" safe-buffer "5.1.2" vary "~1.1.2" concat-map@0.0.1: version "0.0.1" resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b" integrity sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg== content-disposition@0.5.2: version "0.5.2" resolved "https://registry.yarnpkg.com/content-disposition/-/content-disposition-0.5.2.tgz#0cf68bb9ddf5f2be7961c3a85178cb85dba78cb4" integrity sha512-kRGRZw3bLlFISDBgwTSA1TMBFN6J6GWDeubmDE3AF+3+yXL8hTWv8r5rkLbqYXY4RjPk/EzHnClI3zQf1cFmHA== cross-spawn@^7.0.2, cross-spawn@^7.0.3: version "7.0.3" resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-7.0.3.tgz#f73a85b9d5d41d045551c177e2882d4ac85728a6" integrity sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w== dependencies: path-key "^3.1.0" shebang-command "^2.0.0" which "^2.0.1" debug@2.6.9: version "2.6.9" resolved "https://registry.yarnpkg.com/debug/-/debug-2.6.9.tgz#5d128515df134ff327e90a4c93f4e077a536341f" integrity sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA== dependencies: ms "2.0.0" debug@4.3.4, debug@^4.1.1, debug@^4.3.2: version "4.3.4" resolved "https://registry.yarnpkg.com/debug/-/debug-4.3.4.tgz#1319f6579357f2338d3337d2cdd4914bb5dcc865" integrity sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ== dependencies: ms "2.1.2" decamelize@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/decamelize/-/decamelize-4.0.0.tgz#aa472d7bf660eb15f3494efd531cab7f2a709837" integrity sha512-9iE1PgSik9HeIIw2JO94IidnE3eBoQrFJ3w7sFuzSX4DpmZ3v5sZpUiV5Swcf6mQEF+Y0ru8Neo+p+nyh2J+hQ== deep-eql@^4.1.2: version "4.1.3" resolved "https://registry.yarnpkg.com/deep-eql/-/deep-eql-4.1.3.tgz#7c7775513092f7df98d8df9996dd085eb668cc6d" integrity sha512-WaEtAOpRA1MQ0eohqZjpGD8zdI0Ovsm8mmFhaDN8dvDZzyoUMcYDnf5Y6iu7HTXxf8JDS23qWa4a+hKCDyOPzw== dependencies: type-detect "^4.0.0" deep-extend@^0.6.0: version "0.6.0" resolved "https://registry.yarnpkg.com/deep-extend/-/deep-extend-0.6.0.tgz#c4fa7c95404a17a9c3e8ca7e1537312b736330ac" integrity sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA== deep-is@^0.1.3: version "0.1.4" resolved "https://registry.yarnpkg.com/deep-is/-/deep-is-0.1.4.tgz#a6f2dce612fadd2ef1f519b73551f17e85199831" integrity sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ== diff@5.0.0: version "5.0.0" resolved "https://registry.yarnpkg.com/diff/-/diff-5.0.0.tgz#7ed6ad76d859d030787ec35855f5b1daf31d852b" integrity sha512-/VTCrvm5Z0JGty/BWHljh+BAiw3IK+2j87NGMu8Nwc/f48WoDAC395uomO9ZD117ZOBaHmkX1oyLvkVM/aIT3w== doctrine@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/doctrine/-/doctrine-3.0.0.tgz#addebead72a6574db783639dc87a121773973961" integrity sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w== dependencies: esutils "^2.0.2" eastasianwidth@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/eastasianwidth/-/eastasianwidth-0.2.0.tgz#696ce2ec0aa0e6ea93a397ffcf24aa7840c827cb" integrity sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA== emoji-regex@^8.0.0: version "8.0.0" resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-8.0.0.tgz#e818fd69ce5ccfcb404594f842963bf53164cc37" integrity sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A== emoji-regex@^9.2.2: version "9.2.2" resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-9.2.2.tgz#840c8803b0d8047f4ff0cf963176b32d4ef3ed72" integrity sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg== escalade@^3.1.1: version "3.1.1" resolved "https://registry.yarnpkg.com/escalade/-/escalade-3.1.1.tgz#d8cfdc7000965c5a0174b4a82eaa5c0552742e40" integrity sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw== escape-string-regexp@4.0.0, escape-string-regexp@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz#14ba83a5d373e3d311e5afca29cf5bfad965bf34" integrity sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA== eslint-scope@^7.2.0: version "7.2.0" resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-7.2.0.tgz#f21ebdafda02352f103634b96dd47d9f81ca117b" integrity sha512-DYj5deGlHBfMt15J7rdtyKNq/Nqlv5KfU4iodrQ019XESsRnwXH9KAE0y3cwtUHDo2ob7CypAnCqefh6vioWRw== dependencies: esrecurse "^4.3.0" estraverse "^5.2.0" eslint-visitor-keys@^3.3.0, eslint-visitor-keys@^3.4.1: version "3.4.1" resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-3.4.1.tgz#c22c48f48942d08ca824cc526211ae400478a994" integrity sha512-pZnmmLwYzf+kWaM/Qgrvpen51upAktaaiI01nsJD/Yr3lMOdNtq0cxkrrg16w64VtisN6okbs7Q8AfGqj4c9fA== eslint@^8.41.0: version "8.41.0" resolved "https://registry.yarnpkg.com/eslint/-/eslint-8.41.0.tgz#3062ca73363b4714b16dbc1e60f035e6134b6f1c" integrity sha512-WQDQpzGBOP5IrXPo4Hc0814r4/v2rrIsB0rhT7jtunIalgg6gYXWhRMOejVO8yH21T/FGaxjmFjBMNqcIlmH1Q== dependencies: "@eslint-community/eslint-utils" "^4.2.0" "@eslint-community/regexpp" "^4.4.0" "@eslint/eslintrc" "^2.0.3" "@eslint/js" "8.41.0" "@humanwhocodes/config-array" "^0.11.8" "@humanwhocodes/module-importer" "^1.0.1" "@nodelib/fs.walk" "^1.2.8" ajv "^6.10.0" chalk "^4.0.0" cross-spawn "^7.0.2" debug "^4.3.2" doctrine "^3.0.0" escape-string-regexp "^4.0.0" eslint-scope "^7.2.0" eslint-visitor-keys "^3.4.1" espree "^9.5.2" esquery "^1.4.2" esutils "^2.0.2" fast-deep-equal "^3.1.3" file-entry-cache "^6.0.1" find-up "^5.0.0" glob-parent "^6.0.2" globals "^13.19.0" graphemer "^1.4.0" ignore "^5.2.0" import-fresh "^3.0.0" imurmurhash "^0.1.4" is-glob "^4.0.0" is-path-inside "^3.0.3" js-yaml "^4.1.0" json-stable-stringify-without-jsonify "^1.0.1" levn "^0.4.1" lodash.merge "^4.6.2" minimatch "^3.1.2" natural-compare "^1.4.0" optionator "^0.9.1" strip-ansi "^6.0.1" strip-json-comments "^3.1.0" text-table "^0.2.0" esm@^3.2.25: version "3.2.25" resolved "https://registry.yarnpkg.com/esm/-/esm-3.2.25.tgz#342c18c29d56157688ba5ce31f8431fbb795cc10" integrity sha512-U1suiZ2oDVWv4zPO56S0NcR5QriEahGtdN2OR6FiOG4WJvcjBVFB0qI4+eKoWFH483PKGuLuu6V8Z4T5g63UVA== espree@^9.5.2: version "9.5.2" resolved "https://registry.yarnpkg.com/espree/-/espree-9.5.2.tgz#e994e7dc33a082a7a82dceaf12883a829353215b" integrity sha512-7OASN1Wma5fum5SrNhFMAMJxOUAbhyfQ8dQ//PJaJbNw0URTPWqIghHWt1MmAANKhHZIYOHruW4Kw4ruUWOdGw== dependencies: acorn "^8.8.0" acorn-jsx "^5.3.2" eslint-visitor-keys "^3.4.1" esquery@^1.4.2: version "1.5.0" resolved "https://registry.yarnpkg.com/esquery/-/esquery-1.5.0.tgz#6ce17738de8577694edd7361c57182ac8cb0db0b" integrity sha512-YQLXUplAwJgCydQ78IMJywZCceoqk1oH01OERdSAJc/7U2AylwjhSCLDEtqwg811idIS/9fIU5GjG73IgjKMVg== dependencies: estraverse "^5.1.0" esrecurse@^4.3.0: version "4.3.0" resolved "https://registry.yarnpkg.com/esrecurse/-/esrecurse-4.3.0.tgz#7ad7964d679abb28bee72cec63758b1c5d2c9921" integrity sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag== dependencies: estraverse "^5.2.0" estraverse@^5.1.0, estraverse@^5.2.0: version "5.3.0" resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-5.3.0.tgz#2eea5290702f26ab8fe5370370ff86c965d21123" integrity sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA== esutils@^2.0.2: version "2.0.3" resolved "https://registry.yarnpkg.com/esutils/-/esutils-2.0.3.tgz#74d2eb4de0b8da1293711910d50775b9b710ef64" integrity sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g== execa@^5.1.1: version "5.1.1" resolved "https://registry.yarnpkg.com/execa/-/execa-5.1.1.tgz#f80ad9cbf4298f7bd1d4c9555c21e93741c411dd" integrity sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg== dependencies: cross-spawn "^7.0.3" get-stream "^6.0.0" human-signals "^2.1.0" is-stream "^2.0.0" merge-stream "^2.0.0" npm-run-path "^4.0.1" onetime "^5.1.2" signal-exit "^3.0.3" strip-final-newline "^2.0.0" fast-deep-equal@^3.1.1, fast-deep-equal@^3.1.3: version "3.1.3" resolved "https://registry.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz#3a7d56b559d6cbc3eb512325244e619a65c6c525" integrity sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q== fast-json-stable-stringify@^2.0.0: version "2.1.0" resolved "https://registry.yarnpkg.com/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz#874bf69c6f404c2b5d99c481341399fd55892633" integrity sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw== fast-levenshtein@^2.0.6: version "2.0.6" resolved "https://registry.yarnpkg.com/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz#3d8a5c66883a16a30ca8643e851f19baa7797917" integrity sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw== fast-url-parser@1.1.3: version "1.1.3" resolved "https://registry.yarnpkg.com/fast-url-parser/-/fast-url-parser-1.1.3.tgz#f4af3ea9f34d8a271cf58ad2b3759f431f0b318d" integrity sha512-5jOCVXADYNuRkKFzNJ0dCCewsZiYo0dz8QNYljkOpFC6r2U4OBmKtvm/Tsuh4w1YYdDqDb31a8TVhBJ2OJKdqQ== dependencies: punycode "^1.3.2" fastq@^1.6.0: version "1.15.0" resolved "https://registry.yarnpkg.com/fastq/-/fastq-1.15.0.tgz#d04d07c6a2a68fe4599fea8d2e103a937fae6b3a" integrity sha512-wBrocU2LCXXa+lWBt8RoIRD89Fi8OdABODa/kEnyeyjS5aZO5/GNvI5sEINADqP/h8M29UHTHUb53sUu5Ihqdw== dependencies: reusify "^1.0.4" file-entry-cache@^6.0.1: version "6.0.1" resolved "https://registry.yarnpkg.com/file-entry-cache/-/file-entry-cache-6.0.1.tgz#211b2dd9659cb0394b073e7323ac3c933d522027" integrity sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg== dependencies: flat-cache "^3.0.4" fill-range@^7.1.1: version "7.1.1" resolved "https://registry.yarnpkg.com/fill-range/-/fill-range-7.1.1.tgz#44265d3cac07e3ea7dc247516380643754a05292" integrity sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg== dependencies: to-regex-range "^5.0.1" find-up@5.0.0, find-up@^5.0.0: version "5.0.0" resolved "https://registry.yarnpkg.com/find-up/-/find-up-5.0.0.tgz#4c92819ecb7083561e4f4a240a86be5198f536fc" integrity sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng== dependencies: locate-path "^6.0.0" path-exists "^4.0.0" flat-cache@^3.0.4: version "3.0.4" resolved "https://registry.yarnpkg.com/flat-cache/-/flat-cache-3.0.4.tgz#61b0338302b2fe9f957dcc32fc2a87f1c3048b11" integrity sha512-dm9s5Pw7Jc0GvMYbshN6zchCA9RgQlzzEZX3vylR9IqFfS8XciblUXOKfW6SiuJ0e13eDYZoZV5wdrev7P3Nwg== dependencies: flatted "^3.1.0" rimraf "^3.0.2" flat@^5.0.2: version "5.0.2" resolved "https://registry.yarnpkg.com/flat/-/flat-5.0.2.tgz#8ca6fe332069ffa9d324c327198c598259ceb241" integrity sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ== flatted@^3.1.0: version "3.2.7" resolved "https://registry.yarnpkg.com/flatted/-/flatted-3.2.7.tgz#609f39207cb614b89d0765b477cb2d437fbf9787" integrity sha512-5nqDSxl8nn5BSNxyR3n4I6eDmbolI6WT+QqR547RwxQapgjQBmtktdP+HTBb/a/zLsbzERTONyUB5pefh5TtjQ== fs.realpath@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f" integrity sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw== fsevents@~2.3.2: version "2.3.2" resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-2.3.2.tgz#8a526f78b8fdf4623b709e0b975c52c24c02fd1a" integrity sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA== get-caller-file@^2.0.5: version "2.0.5" resolved "https://registry.yarnpkg.com/get-caller-file/-/get-caller-file-2.0.5.tgz#4f94412a82db32f36e3b0b9741f8a97feb031f7e" integrity sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg== get-func-name@^2.0.0: version "2.0.2" resolved "https://registry.yarnpkg.com/get-func-name/-/get-func-name-2.0.2.tgz#0d7cf20cd13fda808669ffa88f4ffc7a3943fc41" integrity sha512-8vXOvuE167CtIc3OyItco7N/dpRtBbYOsPsXCz7X/PMnlGjYjSGuZJgM1Y7mmew7BKf9BqvLX2tnOVy1BBUsxQ== get-stream@^6.0.0: version "6.0.1" resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-6.0.1.tgz#a262d8eef67aced57c2852ad6167526a43cbf7b7" integrity sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg== glob-parent@^6.0.2: version "6.0.2" resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-6.0.2.tgz#6d237d99083950c79290f24c7642a3de9a28f9e3" integrity sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A== dependencies: is-glob "^4.0.3" glob-parent@~5.1.2: version "5.1.2" resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-5.1.2.tgz#869832c58034fe68a4093c17dc15e8340d8401c4" integrity sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow== dependencies: is-glob "^4.0.1" glob@7.2.0: version "7.2.0" resolved "https://registry.yarnpkg.com/glob/-/glob-7.2.0.tgz#d15535af7732e02e948f4c41628bd910293f6023" integrity sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q== dependencies: fs.realpath "^1.0.0" inflight "^1.0.4" inherits "2" minimatch "^3.0.4" once "^1.3.0" path-is-absolute "^1.0.0" glob@^7.1.3: version "7.2.3" resolved "https://registry.yarnpkg.com/glob/-/glob-7.2.3.tgz#b8df0fb802bbfa8e89bd1d938b4e16578ed44f2b" integrity sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q== dependencies: fs.realpath "^1.0.0" inflight "^1.0.4" inherits "2" minimatch "^3.1.1" once "^1.3.0" path-is-absolute "^1.0.0" globals@^13.19.0: version "13.20.0" resolved "https://registry.yarnpkg.com/globals/-/globals-13.20.0.tgz#ea276a1e508ffd4f1612888f9d1bad1e2717bf82" integrity sha512-Qg5QtVkCy/kv3FUSlu4ukeZDVf9ee0iXLAUYX13gbR17bnejFTzr4iS9bY7kwCf1NztRNm1t91fjOiyx4CSwPQ== dependencies: type-fest "^0.20.2" graphemer@^1.4.0: version "1.4.0" resolved "https://registry.yarnpkg.com/graphemer/-/graphemer-1.4.0.tgz#fb2f1d55e0e3a1849aeffc90c4fa0dd53a0e66c6" integrity sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag== has-flag@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-4.0.0.tgz#944771fd9c81c81265c4d6941860da06bb59479b" integrity sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ== he@1.2.0: version "1.2.0" resolved "https://registry.yarnpkg.com/he/-/he-1.2.0.tgz#84ae65fa7eafb165fddb61566ae14baf05664f0f" integrity sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw== human-signals@^2.1.0: version "2.1.0" resolved "https://registry.yarnpkg.com/human-signals/-/human-signals-2.1.0.tgz#dc91fcba42e4d06e4abaed33b3e7a3c02f514ea0" integrity sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw== ignore@^5.2.0: version "5.2.4" resolved "https://registry.yarnpkg.com/ignore/-/ignore-5.2.4.tgz#a291c0c6178ff1b960befe47fcdec301674a6324" integrity sha512-MAb38BcSbH0eHNBxn7ql2NH/kX33OkB3lZ1BNdh7ENeRChHTYsTvWrMubiIAMNS2llXEEgZ1MUOBtXChP3kaFQ== import-fresh@^3.0.0, import-fresh@^3.2.1: version "3.3.0" resolved "https://registry.yarnpkg.com/import-fresh/-/import-fresh-3.3.0.tgz#37162c25fcb9ebaa2e6e53d5b4d88ce17d9e0c2b" integrity sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw== dependencies: parent-module "^1.0.0" resolve-from "^4.0.0" imurmurhash@^0.1.4: version "0.1.4" resolved "https://registry.yarnpkg.com/imurmurhash/-/imurmurhash-0.1.4.tgz#9218b9b2b928a238b13dc4fb6b6d576f231453ea" integrity sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA== inflight@^1.0.4: version "1.0.6" resolved "https://registry.yarnpkg.com/inflight/-/inflight-1.0.6.tgz#49bd6331d7d02d0c09bc910a1075ba8165b56df9" integrity sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA== dependencies: once "^1.3.0" wrappy "1" inherits@2: version "2.0.4" resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c" integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ== ini@~1.3.0: version "1.3.8" resolved "https://registry.yarnpkg.com/ini/-/ini-1.3.8.tgz#a29da425b48806f34767a4efce397269af28432c" integrity sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew== is-binary-path@~2.1.0: version "2.1.0" resolved "https://registry.yarnpkg.com/is-binary-path/-/is-binary-path-2.1.0.tgz#ea1f7f3b80f064236e83470f86c09c254fb45b09" integrity sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw== dependencies: binary-extensions "^2.0.0" is-docker@^2.0.0: version "2.2.1" resolved "https://registry.yarnpkg.com/is-docker/-/is-docker-2.2.1.tgz#33eeabe23cfe86f14bde4408a02c0cfb853acdaa" integrity sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ== is-extglob@^2.1.1: version "2.1.1" resolved "https://registry.yarnpkg.com/is-extglob/-/is-extglob-2.1.1.tgz#a88c02535791f02ed37c76a1b9ea9773c833f8c2" integrity sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ== is-fullwidth-code-point@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz#f116f8064fe90b3f7844a38997c0b75051269f1d" integrity sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg== is-glob@^4.0.0, is-glob@^4.0.1, is-glob@^4.0.3, is-glob@~4.0.1: version "4.0.3" resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-4.0.3.tgz#64f61e42cbbb2eec2071a9dac0b28ba1e65d5084" integrity sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg== dependencies: is-extglob "^2.1.1" is-number@^7.0.0: version "7.0.0" resolved "https://registry.yarnpkg.com/is-number/-/is-number-7.0.0.tgz#7535345b896734d5f80c4d06c50955527a14f12b" integrity sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng== is-path-inside@^3.0.3: version "3.0.3" resolved "https://registry.yarnpkg.com/is-path-inside/-/is-path-inside-3.0.3.tgz#d231362e53a07ff2b0e0ea7fed049161ffd16283" integrity sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ== is-plain-obj@^2.1.0: version "2.1.0" resolved "https://registry.yarnpkg.com/is-plain-obj/-/is-plain-obj-2.1.0.tgz#45e42e37fccf1f40da8e5f76ee21515840c09287" integrity sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA== is-port-reachable@4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/is-port-reachable/-/is-port-reachable-4.0.0.tgz#dac044091ef15319c8ab2f34604d8794181f8c2d" integrity sha512-9UoipoxYmSk6Xy7QFgRv2HDyaysmgSG75TFQs6S+3pDM7ZhKTF/bskZV+0UlABHzKjNVhPjYCLfeZUEg1wXxig== is-stream@^2.0.0: version "2.0.1" resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-2.0.1.tgz#fac1e3d53b97ad5a9d0ae9cef2389f5810a5c077" integrity sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg== is-unicode-supported@^0.1.0: version "0.1.0" resolved "https://registry.yarnpkg.com/is-unicode-supported/-/is-unicode-supported-0.1.0.tgz#3f26c76a809593b52bfa2ecb5710ed2779b522a7" integrity sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw== is-wsl@^2.2.0: version "2.2.0" resolved "https://registry.yarnpkg.com/is-wsl/-/is-wsl-2.2.0.tgz#74a4c76e77ca9fd3f932f290c17ea326cd157271" integrity sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww== dependencies: is-docker "^2.0.0" isexe@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/isexe/-/isexe-2.0.0.tgz#e8fbf374dc556ff8947a10dcb0572d633f2cfa10" integrity sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw== js-yaml@4.1.0, js-yaml@^4.1.0: version "4.1.0" resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-4.1.0.tgz#c1fb65f8f5017901cdd2c951864ba18458a10602" integrity sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA== dependencies: argparse "^2.0.1" json-schema-traverse@^0.4.1: version "0.4.1" resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz#69f6a87d9513ab8bb8fe63bdb0979c448e684660" integrity sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg== json-schema-traverse@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz#ae7bcb3656ab77a73ba5c49bf654f38e6b6860e2" integrity sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug== json-stable-stringify-without-jsonify@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz#9db7b59496ad3f3cfef30a75142d2d930ad72651" integrity sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw== levn@^0.4.1: version "0.4.1" resolved "https://registry.yarnpkg.com/levn/-/levn-0.4.1.tgz#ae4562c007473b932a6200d403268dd2fffc6ade" integrity sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ== dependencies: prelude-ls "^1.2.1" type-check "~0.4.0" locate-path@^6.0.0: version "6.0.0" resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-6.0.0.tgz#55321eb309febbc59c4801d931a72452a681d286" integrity sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw== dependencies: p-locate "^5.0.0" lodash.merge@^4.6.2: version "4.6.2" resolved "https://registry.yarnpkg.com/lodash.merge/-/lodash.merge-4.6.2.tgz#558aa53b43b661e1925a0afdfa36a9a1085fe57a" integrity sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ== log-symbols@4.1.0: version "4.1.0" resolved "https://registry.yarnpkg.com/log-symbols/-/log-symbols-4.1.0.tgz#3fbdbb95b4683ac9fc785111e792e558d4abd503" integrity sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg== dependencies: chalk "^4.1.0" is-unicode-supported "^0.1.0" loupe@^2.3.1: version "2.3.6" resolved "https://registry.yarnpkg.com/loupe/-/loupe-2.3.6.tgz#76e4af498103c532d1ecc9be102036a21f787b53" integrity sha512-RaPMZKiMy8/JruncMU5Bt6na1eftNoo++R4Y+N2FrxkDVTrGvcyzFTsaGif4QTeKESheMGegbhw6iUAq+5A8zA== dependencies: get-func-name "^2.0.0" merge-stream@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/merge-stream/-/merge-stream-2.0.0.tgz#52823629a14dd00c9770fb6ad47dc6310f2c1f60" integrity sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w== mime-db@1.52.0, "mime-db@>= 1.43.0 < 2": version "1.52.0" resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.52.0.tgz#bbabcdc02859f4987301c856e3387ce5ec43bf70" integrity sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg== mime-db@~1.33.0: version "1.33.0" resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.33.0.tgz#a3492050a5cb9b63450541e39d9788d2272783db" integrity sha512-BHJ/EKruNIqJf/QahvxwQZXKygOQ256myeN/Ew+THcAa5q+PjyTTMMeNQC4DZw5AwfvelsUrA6B67NKMqXDbzQ== mime-types@2.1.18: version "2.1.18" resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.18.tgz#6f323f60a83d11146f831ff11fd66e2fe5503bb8" integrity sha512-lc/aahn+t4/SWV/qcmumYjymLsWfN3ELhpmVuUFjgsORruuZPVSwAQryq+HHGvO/SI2KVX26bx+En+zhM8g8hQ== dependencies: mime-db "~1.33.0" mime-types@~2.1.34: version "2.1.35" resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.35.tgz#381a871b62a734450660ae3deee44813f70d959a" integrity sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw== dependencies: mime-db "1.52.0" mimic-fn@^2.1.0: version "2.1.0" resolved "https://registry.yarnpkg.com/mimic-fn/-/mimic-fn-2.1.0.tgz#7ed2c2ccccaf84d3ffcb7a69b57711fc2083401b" integrity sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg== minimatch@3.1.2, minimatch@^3.0.4, minimatch@^3.0.5, minimatch@^3.1.1, minimatch@^3.1.2: version "3.1.2" resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.1.2.tgz#19cd194bfd3e428f049a70817c038d89ab4be35b" integrity sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw== dependencies: brace-expansion "^1.1.7" minimatch@5.0.1: version "5.0.1" resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-5.0.1.tgz#fb9022f7528125187c92bd9e9b6366be1cf3415b" integrity sha512-nLDxIFRyhDblz3qMuq+SoRZED4+miJ/G+tdDrjkkkRnjAsBexeGpgjLEQ0blJy7rHhR2b93rhQY4SvyWu9v03g== dependencies: brace-expansion "^2.0.1" minimist@^1.2.0: version "1.2.8" resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.8.tgz#c1a464e7693302e082a075cee0c057741ac4772c" integrity sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA== mocha@^10.2.0: version "10.2.0" resolved "https://registry.yarnpkg.com/mocha/-/mocha-10.2.0.tgz#1fd4a7c32ba5ac372e03a17eef435bd00e5c68b8" integrity sha512-IDY7fl/BecMwFHzoqF2sg/SHHANeBoMMXFlS9r0OXKDssYE1M5O43wUY/9BVPeIvfH2zmEbBfseqN9gBQZzXkg== dependencies: ansi-colors "4.1.1" browser-stdout "1.3.1" chokidar "3.5.3" debug "4.3.4" diff "5.0.0" escape-string-regexp "4.0.0" find-up "5.0.0" glob "7.2.0" he "1.2.0" js-yaml "4.1.0" log-symbols "4.1.0" minimatch "5.0.1" ms "2.1.3" nanoid "3.3.3" serialize-javascript "6.0.0" strip-json-comments "3.1.1" supports-color "8.1.1" workerpool "6.2.1" yargs "16.2.0" yargs-parser "20.2.4" yargs-unparser "2.0.0" ms@2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/ms/-/ms-2.0.0.tgz#5608aeadfc00be6c2901df5f9861788de0d597c8" integrity sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A== ms@2.1.2: version "2.1.2" resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.2.tgz#d09d1f357b443f493382a8eb3ccd183872ae6009" integrity sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w== ms@2.1.3: version "2.1.3" resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.3.tgz#574c8138ce1d2b5861f0b44579dbadd60c6615b2" integrity sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA== nanoid@3.3.3: version "3.3.3" resolved "https://registry.yarnpkg.com/nanoid/-/nanoid-3.3.3.tgz#fd8e8b7aa761fe807dba2d1b98fb7241bb724a25" integrity sha512-p1sjXuopFs0xg+fPASzQ28agW1oHD7xDsd9Xkf3T15H3c/cifrFHVwrh74PdoklAPi+i7MdRsE47vm2r6JoB+w== natural-compare@^1.4.0: version "1.4.0" resolved "https://registry.yarnpkg.com/natural-compare/-/natural-compare-1.4.0.tgz#4abebfeed7541f2c27acfb29bdbbd15c8d5ba4f7" integrity sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw== negotiator@0.6.3: version "0.6.3" resolved "https://registry.yarnpkg.com/negotiator/-/negotiator-0.6.3.tgz#58e323a72fedc0d6f9cd4d31fe49f51479590ccd" integrity sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg== normalize-path@^3.0.0, normalize-path@~3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-3.0.0.tgz#0dcd69ff23a1c9b11fd0978316644a0388216a65" integrity sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA== npm-run-path@^4.0.1: version "4.0.1" resolved "https://registry.yarnpkg.com/npm-run-path/-/npm-run-path-4.0.1.tgz#b7ecd1e5ed53da8e37a55e1c2269e0b97ed748ea" integrity sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw== dependencies: path-key "^3.0.0" on-headers@~1.0.2: version "1.0.2" resolved "https://registry.yarnpkg.com/on-headers/-/on-headers-1.0.2.tgz#772b0ae6aaa525c399e489adfad90c403eb3c28f" integrity sha512-pZAE+FJLoyITytdqK0U5s+FIpjN0JP3OzFi/u8Rx+EV5/W+JTWGXG8xFzevE7AjBfDqHv/8vL8qQsIhHnqRkrA== once@^1.3.0: version "1.4.0" resolved "https://registry.yarnpkg.com/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1" integrity sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w== dependencies: wrappy "1" onetime@^5.1.2: version "5.1.2" resolved "https://registry.yarnpkg.com/onetime/-/onetime-5.1.2.tgz#d0e96ebb56b07476df1dd9c4806e5237985ca45e" integrity sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg== dependencies: mimic-fn "^2.1.0" optionator@^0.9.1: version "0.9.1" resolved "https://registry.yarnpkg.com/optionator/-/optionator-0.9.1.tgz#4f236a6373dae0566a6d43e1326674f50c291499" integrity sha512-74RlY5FCnhq4jRxVUPKDaRwrVNXMqsGsiW6AJw4XK8hmtm10wC0ypZBLw5IIp85NZMr91+qd1RvvENwg7jjRFw== dependencies: deep-is "^0.1.3" fast-levenshtein "^2.0.6" levn "^0.4.1" prelude-ls "^1.2.1" type-check "^0.4.0" word-wrap "^1.2.3" p-limit@^3.0.2: version "3.1.0" resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-3.1.0.tgz#e1daccbe78d0d1388ca18c64fea38e3e57e3706b" integrity sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ== dependencies: yocto-queue "^0.1.0" p-locate@^5.0.0: version "5.0.0" resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-5.0.0.tgz#83c8315c6785005e3bd021839411c9e110e6d834" integrity sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw== dependencies: p-limit "^3.0.2" parent-module@^1.0.0: version "1.0.1" resolved "https://registry.yarnpkg.com/parent-module/-/parent-module-1.0.1.tgz#691d2709e78c79fae3a156622452d00762caaaa2" integrity sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g== dependencies: callsites "^3.0.0" path-exists@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-4.0.0.tgz#513bdbe2d3b95d7762e8c1137efa195c6c61b5b3" integrity sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w== path-is-absolute@^1.0.0: version "1.0.1" resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f" integrity sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg== path-is-inside@1.0.2: version "1.0.2" resolved "https://registry.yarnpkg.com/path-is-inside/-/path-is-inside-1.0.2.tgz#365417dede44430d1c11af61027facf074bdfc53" integrity sha512-DUWJr3+ULp4zXmol/SZkFf3JGsS9/SIv+Y3Rt93/UjPpDpklB5f1er4O3POIbUuUJ3FXgqte2Q7SrU6zAqwk8w== path-key@^3.0.0, path-key@^3.1.0: version "3.1.1" resolved "https://registry.yarnpkg.com/path-key/-/path-key-3.1.1.tgz#581f6ade658cbba65a0d3380de7753295054f375" integrity sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q== path-to-regexp@3.3.0: version "3.3.0" resolved "https://registry.yarnpkg.com/path-to-regexp/-/path-to-regexp-3.3.0.tgz#f7f31d32e8518c2660862b644414b6d5c63a611b" integrity sha512-qyCH421YQPS2WFDxDjftfc1ZR5WKQzVzqsp4n9M2kQhVOo/ByahFoUNJfl58kOcEGfQ//7weFTDhm+ss8Ecxgw== pathval@^1.1.1: version "1.1.1" resolved "https://registry.yarnpkg.com/pathval/-/pathval-1.1.1.tgz#8534e77a77ce7ac5a2512ea21e0fdb8fcf6c3d8d" integrity sha512-Dp6zGqpTdETdR63lehJYPeIOqpiNBNtc7BpWSLrOje7UaIsE5aY92r/AunQA7rsXvet3lrJ3JnZX29UPTKXyKQ== picomatch@^2.0.4, picomatch@^2.2.1: version "2.3.1" resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-2.3.1.tgz#3ba3833733646d9d3e4995946c1365a67fb07a42" integrity sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA== prelude-ls@^1.2.1: version "1.2.1" resolved "https://registry.yarnpkg.com/prelude-ls/-/prelude-ls-1.2.1.tgz#debc6489d7a6e6b0e7611888cec880337d316396" integrity sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g== punycode@^1.3.2: version "1.4.1" resolved "https://registry.yarnpkg.com/punycode/-/punycode-1.4.1.tgz#c0d5a63b2718800ad8e1eb0fa5269c84dd41845e" integrity sha512-jmYNElW7yvO7TV33CjSmvSiE2yco3bV2czu/OzDKdMNVZQWfxCblURLhf+47syQRBntjfLdd/H0egrzIG+oaFQ== punycode@^2.1.0: version "2.3.0" resolved "https://registry.yarnpkg.com/punycode/-/punycode-2.3.0.tgz#f67fa67c94da8f4d0cfff981aee4118064199b8f" integrity sha512-rRV+zQD8tVFys26lAGR9WUuS4iUAngJScM+ZRSKtvl5tKeZ2t5bvdNFdNHBW9FWR4guGHlgmsZ1G7BSm2wTbuA== queue-microtask@^1.2.2: version "1.2.3" resolved "https://registry.yarnpkg.com/queue-microtask/-/queue-microtask-1.2.3.tgz#4929228bbc724dfac43e0efb058caf7b6cfb6243" integrity sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A== randombytes@^2.1.0: version "2.1.0" resolved "https://registry.yarnpkg.com/randombytes/-/randombytes-2.1.0.tgz#df6f84372f0270dc65cdf6291349ab7a473d4f2a" integrity sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ== dependencies: safe-buffer "^5.1.0" range-parser@1.2.0: version "1.2.0" resolved "https://registry.yarnpkg.com/range-parser/-/range-parser-1.2.0.tgz#f49be6b487894ddc40dcc94a322f611092e00d5e" integrity sha512-kA5WQoNVo4t9lNx2kQNFCxKeBl5IbbSNBl1M/tLkw9WCn+hxNBAW5Qh8gdhs63CJnhjJ2zQWFoqPJP2sK1AV5A== rc@^1.0.1, rc@^1.1.6: version "1.2.8" resolved "https://registry.yarnpkg.com/rc/-/rc-1.2.8.tgz#cd924bf5200a075b83c188cd6b9e211b7fc0d3ed" integrity sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw== dependencies: deep-extend "^0.6.0" ini "~1.3.0" minimist "^1.2.0" strip-json-comments "~2.0.1" readdirp@~3.6.0: version "3.6.0" resolved "https://registry.yarnpkg.com/readdirp/-/readdirp-3.6.0.tgz#74a370bd857116e245b29cc97340cd431a02a6c7" integrity sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA== dependencies: picomatch "^2.2.1" registry-auth-token@3.3.2: version "3.3.2" resolved "https://registry.yarnpkg.com/registry-auth-token/-/registry-auth-token-3.3.2.tgz#851fd49038eecb586911115af845260eec983f20" integrity sha512-JL39c60XlzCVgNrO+qq68FoNb56w/m7JYvGR2jT5iR1xBrUA3Mfx5Twk5rqTThPmQKMWydGmq8oFtDlxfrmxnQ== dependencies: rc "^1.1.6" safe-buffer "^5.0.1" registry-url@3.1.0: version "3.1.0" resolved "https://registry.yarnpkg.com/registry-url/-/registry-url-3.1.0.tgz#3d4ef870f73dde1d77f0cf9a381432444e174942" integrity sha512-ZbgR5aZEdf4UKZVBPYIgaglBmSF2Hi94s2PcIHhRGFjKYu+chjJdYfHn4rt3hB6eCKLJ8giVIIfgMa1ehDfZKA== dependencies: rc "^1.0.1" require-directory@^2.1.1: version "2.1.1" resolved "https://registry.yarnpkg.com/require-directory/-/require-directory-2.1.1.tgz#8c64ad5fd30dab1c976e2344ffe7f792a6a6df42" integrity sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q== require-from-string@^2.0.2: version "2.0.2" resolved "https://registry.yarnpkg.com/require-from-string/-/require-from-string-2.0.2.tgz#89a7fdd938261267318eafe14f9c32e598c36909" integrity sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw== resolve-from@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-4.0.0.tgz#4abcd852ad32dd7baabfe9b40e00a36db5f392e6" integrity sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g== reusify@^1.0.4: version "1.0.4" resolved "https://registry.yarnpkg.com/reusify/-/reusify-1.0.4.tgz#90da382b1e126efc02146e90845a88db12925d76" integrity sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw== rimraf@^3.0.2: version "3.0.2" resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-3.0.2.tgz#f1a5402ba6220ad52cc1282bac1ae3aa49fd061a" integrity sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA== dependencies: glob "^7.1.3" rollup@^3.29.5: version "3.29.5" resolved "https://registry.yarnpkg.com/rollup/-/rollup-3.29.5.tgz#8a2e477a758b520fb78daf04bca4c522c1da8a54" integrity sha512-GVsDdsbJzzy4S/v3dqWPJ7EfvZJfCHiDqe80IyrF59LYuP+e6U1LJoUqeuqRbwAWoMNoXivMNeNAOf5E22VA1w== optionalDependencies: fsevents "~2.3.2" run-parallel@^1.1.9: version "1.2.0" resolved "https://registry.yarnpkg.com/run-parallel/-/run-parallel-1.2.0.tgz#66d1368da7bdf921eb9d95bd1a9229e7f21a43ee" integrity sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA== dependencies: queue-microtask "^1.2.2" safe-buffer@5.1.2: version "5.1.2" resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.1.2.tgz#991ec69d296e0313747d59bdfd2b745c35f8828d" integrity sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g== safe-buffer@^5.0.1, safe-buffer@^5.1.0: version "5.2.1" resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.2.1.tgz#1eaf9fa9bdb1fdd4ec75f58f9cdb4e6b7827eec6" integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ== serialize-javascript@6.0.0: version "6.0.0" resolved "https://registry.yarnpkg.com/serialize-javascript/-/serialize-javascript-6.0.0.tgz#efae5d88f45d7924141da8b5c3a7a7e663fefeb8" integrity sha512-Qr3TosvguFt8ePWqsvRfrKyQXIiW+nGbYpy8XK24NQHE83caxWt+mIymTT19DGFbNWNLfEwsrkSmN64lVWB9ag== dependencies: randombytes "^2.1.0" serve-handler@6.1.5: version "6.1.5" resolved "https://registry.yarnpkg.com/serve-handler/-/serve-handler-6.1.5.tgz#a4a0964f5c55c7e37a02a633232b6f0d6f068375" integrity sha512-ijPFle6Hwe8zfmBxJdE+5fta53fdIY0lHISJvuikXB3VYFafRjMRpOffSPvCYsbKyBA7pvy9oYr/BT1O3EArlg== dependencies: bytes "3.0.0" content-disposition "0.5.2" fast-url-parser "1.1.3" mime-types "2.1.18" minimatch "3.1.2" path-is-inside "1.0.2" path-to-regexp "3.3.0" range-parser "1.2.0" serve@^14.2.0: version "14.2.0" resolved "https://registry.yarnpkg.com/serve/-/serve-14.2.0.tgz#3d768e88fa13ad8644f2393599189707176e66b8" integrity sha512-+HOw/XK1bW8tw5iBilBz/mJLWRzM8XM6MPxL4J/dKzdxq1vfdEWSwhaR7/yS8EJp5wzvP92p1qirysJvnEtjXg== dependencies: "@zeit/schemas" "2.29.0" ajv "8.11.0" arg "5.0.2" boxen "7.0.0" chalk "5.0.1" chalk-template "0.4.0" clipboardy "3.0.0" compression "1.7.4" is-port-reachable "4.0.0" serve-handler "6.1.5" update-check "1.5.4" shebang-command@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/shebang-command/-/shebang-command-2.0.0.tgz#ccd0af4f8835fbdc265b82461aaf0c36663f34ea" integrity sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA== dependencies: shebang-regex "^3.0.0" shebang-regex@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/shebang-regex/-/shebang-regex-3.0.0.tgz#ae16f1644d873ecad843b0307b143362d4c42172" integrity sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A== signal-exit@^3.0.3: version "3.0.7" resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-3.0.7.tgz#a9a1767f8af84155114eaabd73f99273c8f59ad9" integrity sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ== string-width@^4.1.0, string-width@^4.2.0: version "4.2.3" resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.2.3.tgz#269c7117d27b05ad2e536830a8ec895ef9c6d010" integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g== dependencies: emoji-regex "^8.0.0" is-fullwidth-code-point "^3.0.0" strip-ansi "^6.0.1" string-width@^5.0.1, string-width@^5.1.2: version "5.1.2" resolved "https://registry.yarnpkg.com/string-width/-/string-width-5.1.2.tgz#14f8daec6d81e7221d2a357e668cab73bdbca794" integrity sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA== dependencies: eastasianwidth "^0.2.0" emoji-regex "^9.2.2" strip-ansi "^7.0.1" strip-ansi@^6.0.0, strip-ansi@^6.0.1: version "6.0.1" resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.1.tgz#9e26c63d30f53443e9489495b2105d37b67a85d9" integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A== dependencies: ansi-regex "^5.0.1" strip-ansi@^7.0.1: version "7.1.0" resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-7.1.0.tgz#d5b6568ca689d8561370b0707685d22434faff45" integrity sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ== dependencies: ansi-regex "^6.0.1" strip-final-newline@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/strip-final-newline/-/strip-final-newline-2.0.0.tgz#89b852fb2fcbe936f6f4b3187afb0a12c1ab58ad" integrity sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA== strip-json-comments@3.1.1, strip-json-comments@^3.1.0, strip-json-comments@^3.1.1: version "3.1.1" resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-3.1.1.tgz#31f1281b3832630434831c310c01cccda8cbe006" integrity sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig== strip-json-comments@~2.0.1: version "2.0.1" resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-2.0.1.tgz#3c531942e908c2697c0ec344858c286c7ca0a60a" integrity sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ== supports-color@8.1.1: version "8.1.1" resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-8.1.1.tgz#cd6fc17e28500cff56c1b86c0a7fd4a54a73005c" integrity sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q== dependencies: has-flag "^4.0.0" supports-color@^7.1.0: version "7.2.0" resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-7.2.0.tgz#1b7dcdcb32b8138801b3e478ba6a51caa89648da" integrity sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw== dependencies: has-flag "^4.0.0" text-table@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/text-table/-/text-table-0.2.0.tgz#7f5ee823ae805207c00af2df4a84ec3fcfa570b4" integrity sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw== to-regex-range@^5.0.1: version "5.0.1" resolved "https://registry.yarnpkg.com/to-regex-range/-/to-regex-range-5.0.1.tgz#1648c44aae7c8d988a326018ed72f5b4dd0392e4" integrity sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ== dependencies: is-number "^7.0.0" type-check@^0.4.0, type-check@~0.4.0: version "0.4.0" resolved "https://registry.yarnpkg.com/type-check/-/type-check-0.4.0.tgz#07b8203bfa7056c0657050e3ccd2c37730bab8f1" integrity sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew== dependencies: prelude-ls "^1.2.1" type-detect@^4.0.0, type-detect@^4.0.5: version "4.0.8" resolved "https://registry.yarnpkg.com/type-detect/-/type-detect-4.0.8.tgz#7646fb5f18871cfbb7749e69bd39a6388eb7450c" integrity sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g== type-fest@^0.20.2: version "0.20.2" resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.20.2.tgz#1bf207f4b28f91583666cb5fbd327887301cd5f4" integrity sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ== type-fest@^2.13.0: version "2.19.0" resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-2.19.0.tgz#88068015bb33036a598b952e55e9311a60fd3a9b" integrity sha512-RAH822pAdBgcNMAfWnCBU3CFZcfZ/i1eZjwFU/dsLKumyuuP3niueg2UAukXYF0E2AAoc82ZSSf9J0WQBinzHA== update-check@1.5.4: version "1.5.4" resolved "https://registry.yarnpkg.com/update-check/-/update-check-1.5.4.tgz#5b508e259558f1ad7dbc8b4b0457d4c9d28c8743" integrity sha512-5YHsflzHP4t1G+8WGPlvKbJEbAJGCgw+Em+dGR1KmBUbr1J36SJBqlHLjR7oob7sco5hWHGQVcr9B2poIVDDTQ== dependencies: registry-auth-token "3.3.2" registry-url "3.1.0" uri-js@^4.2.2: version "4.4.1" resolved "https://registry.yarnpkg.com/uri-js/-/uri-js-4.4.1.tgz#9b1a52595225859e55f669d928f88c6c57f2a77e" integrity sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg== dependencies: punycode "^2.1.0" vary@~1.1.2: version "1.1.2" resolved "https://registry.yarnpkg.com/vary/-/vary-1.1.2.tgz#2299f02c6ded30d4a5961b0b9f74524a18f634fc" integrity sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg== which@^2.0.1: version "2.0.2" resolved "https://registry.yarnpkg.com/which/-/which-2.0.2.tgz#7c6a8dd0a636a0327e10b59c9286eee93f3f51b1" integrity sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA== dependencies: isexe "^2.0.0" widest-line@^4.0.1: version "4.0.1" resolved "https://registry.yarnpkg.com/widest-line/-/widest-line-4.0.1.tgz#a0fc673aaba1ea6f0a0d35b3c2795c9a9cc2ebf2" integrity sha512-o0cyEG0e8GPzT4iGHphIOh0cJOV8fivsXxddQasHPHfoZf1ZexrfeA21w2NaEN1RHE+fXlfISmOE8R9N3u3Qig== dependencies: string-width "^5.0.1" word-wrap@^1.2.3: version "1.2.4" resolved "https://registry.yarnpkg.com/word-wrap/-/word-wrap-1.2.4.tgz#cb4b50ec9aca570abd1f52f33cd45b6c61739a9f" integrity sha512-2V81OA4ugVo5pRo46hAoD2ivUJx8jXmWXfUkY4KFNw0hEptvN0QfH3K4nHiwzGeKl5rFKedV48QVoqYavy4YpA== workerpool@6.2.1: version "6.2.1" resolved "https://registry.yarnpkg.com/workerpool/-/workerpool-6.2.1.tgz#46fc150c17d826b86a008e5a4508656777e9c343" integrity sha512-ILEIE97kDZvF9Wb9f6h5aXK4swSlKGUcOEGiIYb2OOu/IrDU9iwj0fD//SsA6E5ibwJxpEvhullJY4Sl4GcpAw== wrap-ansi@^7.0.0: version "7.0.0" resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz#67e145cff510a6a6984bdf1152911d69d2eb9e43" integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q== dependencies: ansi-styles "^4.0.0" string-width "^4.1.0" strip-ansi "^6.0.0" wrap-ansi@^8.0.1: version "8.1.0" resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-8.1.0.tgz#56dc22368ee570face1b49819975d9b9a5ead214" integrity sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ== dependencies: ansi-styles "^6.1.0" string-width "^5.0.1" strip-ansi "^7.0.1" wrappy@1: version "1.0.2" resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f" integrity sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ== y18n@^5.0.5: version "5.0.8" resolved "https://registry.yarnpkg.com/y18n/-/y18n-5.0.8.tgz#7f4934d0f7ca8c56f95314939ddcd2dd91ce1d55" integrity sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA== yargs-parser@20.2.4: version "20.2.4" resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-20.2.4.tgz#b42890f14566796f85ae8e3a25290d205f154a54" integrity sha512-WOkpgNhPTlE73h4VFAFsOnomJVaovO8VqLDzy5saChRBFQFBoMYirowyW+Q9HB4HFF4Z7VZTiG3iSzJJA29yRA== yargs-parser@^20.2.2: version "20.2.9" resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-20.2.9.tgz#2eb7dc3b0289718fc295f362753845c41a0c94ee" integrity sha512-y11nGElTIV+CT3Zv9t7VKl+Q3hTQoT9a1Qzezhhl6Rp21gJ/IVTW7Z3y9EWXhuUBC2Shnf+DX0antecpAwSP8w== yargs-unparser@2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/yargs-unparser/-/yargs-unparser-2.0.0.tgz#f131f9226911ae5d9ad38c432fe809366c2325eb" integrity sha512-7pRTIA9Qc1caZ0bZ6RYRGbHJthJWuakf+WmHK0rVeLkNrrGhfoabBNdue6kdINI6r4if7ocq9aD/n7xwKOdzOA== dependencies: camelcase "^6.0.0" decamelize "^4.0.0" flat "^5.0.2" is-plain-obj "^2.1.0" yargs@16.2.0: version "16.2.0" resolved "https://registry.yarnpkg.com/yargs/-/yargs-16.2.0.tgz#1c82bf0f6b6a66eafce7ef30e376f49a12477f66" integrity sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw== dependencies: cliui "^7.0.2" escalade "^3.1.1" get-caller-file "^2.0.5" require-directory "^2.1.1" string-width "^4.2.0" y18n "^5.0.5" yargs-parser "^20.2.2" yocto-queue@^0.1.0: version "0.1.0" resolved "https://registry.yarnpkg.com/yocto-queue/-/yocto-queue-0.1.0.tgz#0294eb3dee05028d31ee1a5fa2c556a6aaf10a1b" integrity sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q== KhronosGroup-SPIRV-Tools-f289d04/tools/util/000077500000000000000000000000001475742701700206465ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/tools/util/cli_consumer.cpp000066400000000000000000000025761475742701700240460ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "tools/util/cli_consumer.h" #include namespace spvtools { namespace utils { void CLIMessageConsumer(spv_message_level_t level, const char*, const spv_position_t& position, const char* message) { switch (level) { case SPV_MSG_FATAL: case SPV_MSG_INTERNAL_ERROR: case SPV_MSG_ERROR: std::cerr << "error: line " << position.index << ": " << message << std::endl; break; case SPV_MSG_WARNING: std::cout << "warning: line " << position.index << ": " << message << std::endl; break; case SPV_MSG_INFO: std::cout << "info: line " << position.index << ": " << message << std::endl; break; default: break; } } } // namespace utils } // namespace spvtools KhronosGroup-SPIRV-Tools-f289d04/tools/util/cli_consumer.h000066400000000000000000000021071475742701700235010ustar00rootroot00000000000000// Copyright (c) 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SOURCE_UTIL_CLI_CONSUMMER_H_ #define SOURCE_UTIL_CLI_CONSUMMER_H_ #include "include/spirv-tools/libspirv.h" namespace spvtools { namespace utils { // A message consumer that can be used by command line tools like spirv-opt and // spirv-val to display messages. void CLIMessageConsumer(spv_message_level_t level, const char*, const spv_position_t& position, const char* message); } // namespace utils } // namespace spvtools #endif // SOURCE_UTIL_CLI_CONSUMMER_H_ KhronosGroup-SPIRV-Tools-f289d04/tools/util/flags.cpp000066400000000000000000000156051475742701700224550ustar00rootroot00000000000000// Copyright (c) 2023 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "flags.h" #include #include #include #include #include #include #include #include #include #include namespace flags { std::vector positional_arguments; namespace { using token_t = const char*; using token_iterator_t = token_t*; // Extracts the flag name from a potential token. // This function only looks for a '=', to split the flag name from the value for // long-form flags. Returns the name of the flag, prefixed with the hyphen(s). inline std::string get_flag_name(const std::string& flag, bool is_short_flag) { if (is_short_flag) { return flag; } size_t equal_index = flag.find('='); if (equal_index == std::string::npos) { return flag; } return flag.substr(0, equal_index); } // Parse a boolean flag. Returns `true` if the parsing succeeded, `false` // otherwise. bool parse_bool_flag(Flag& flag, bool is_short_flag, const std::string& token) { if (is_short_flag) { flag.value() = true; return true; } const std::string raw_flag(token); size_t equal_index = raw_flag.find('='); if (equal_index == std::string::npos) { flag.value() = true; return true; } const std::string value = raw_flag.substr(equal_index + 1); if (value == "true") { flag.value() = true; return true; } if (value == "false") { flag.value() = false; return true; } return false; } // Parse a uint32_t flag value. bool parse_flag_value(Flag& flag, const std::string& value) { std::regex unsigned_pattern("^ *[0-9]+ *$"); if (!std::regex_match(value, unsigned_pattern)) { std::cerr << "'" << value << "' is not a unsigned number." << std::endl; return false; } errno = 0; char* end_ptr = nullptr; const uint64_t number = strtoull(value.c_str(), &end_ptr, 10); if (end_ptr == nullptr || end_ptr != value.c_str() + value.size() || errno == EINVAL) { std::cerr << "'" << value << "' is not a unsigned number." << std::endl; return false; } if (errno == ERANGE || number > static_cast(UINT32_MAX)) { std::cerr << "'" << value << "' cannot be represented as a 32bit unsigned." << std::endl; return false; } flag.value() = static_cast(number); return true; } // "Parse" a string flag value (assigns it, cannot fail). bool parse_flag_value(Flag& flag, const std::string& value) { flag.value() = value; return true; } // Parse a potential multi-token flag. Moves the iterator to the last flag's // token if it's a multi-token flag. Returns `true` if the parsing succeeded. // The iterator is moved to the last parsed token. template bool parse_flag(Flag& flag, bool is_short_flag, const char*** iterator) { const std::string raw_flag(**iterator); std::string raw_value; const size_t equal_index = raw_flag.find('='); if (is_short_flag || equal_index == std::string::npos) { if ((*iterator)[1] == nullptr) { return false; } // This is a bi-token flag. Moving iterator to the last parsed token. raw_value = (*iterator)[1]; *iterator += 1; } else { // This is a mono-token flag, no need to move the iterator. raw_value = raw_flag.substr(equal_index + 1); } return parse_flag_value(flag, raw_value); } } // namespace // This is the function to expand if you want to support a new type. bool FlagList::parse_flag_info(FlagInfo& info, token_iterator_t* iterator) { bool success = false; std::visit( [&](auto&& item) { using T = std::decay_t; if constexpr (std::is_same_v>) { success = parse_bool_flag(item.get(), info.is_short, **iterator); } else if constexpr (std::is_same_v>) { success = parse_flag(item.get(), info.is_short, iterator); } else if constexpr (std::is_same_v>) { success = parse_flag(item.get(), info.is_short, iterator); } else { static_assert(always_false_v, "Unsupported flag type."); } }, info.flag); return success; } bool FlagList::parse(token_t* argv) { flags::positional_arguments.clear(); std::unordered_set parsed_flags; bool ignore_flags = false; for (const char** it = argv + 1; *it != nullptr; it++) { if (ignore_flags) { flags::positional_arguments.emplace_back(*it); continue; } // '--' alone is used to mark the end of the flags. if (std::strcmp(*it, "--") == 0) { ignore_flags = true; continue; } // '-' alone is not a flag, but often used to say 'stdin'. if (std::strcmp(*it, "-") == 0) { flags::positional_arguments.emplace_back(*it); continue; } const std::string raw_flag(*it); if (raw_flag.size() == 0) { continue; } if (raw_flag[0] != '-') { flags::positional_arguments.emplace_back(*it); continue; } // Only case left: flags (long and shorts). if (raw_flag.size() < 2) { std::cerr << "Unknown flag " << raw_flag << std::endl; return false; } const bool is_short_flag = std::strncmp(*it, "--", 2) != 0; const std::string flag_name = get_flag_name(raw_flag, is_short_flag); auto needle = std::find_if( get_flags().begin(), get_flags().end(), [&flag_name](const auto& item) { return item.name == flag_name; }); if (needle == get_flags().end()) { std::cerr << "Unknown flag " << flag_name << std::endl; return false; } if (parsed_flags.count(&*needle) != 0) { std::cerr << "The flag " << flag_name << " was specified multiple times." << std::endl; return false; } parsed_flags.insert(&*needle); if (!parse_flag_info(*needle, &it)) { std::cerr << "Invalid usage for flag " << flag_name << std::endl; return false; } } // Check that we parsed all required flags. for (const auto& flag : get_flags()) { if (!flag.required) { continue; } if (parsed_flags.count(&flag) == 0) { std::cerr << "Missing required flag " << flag.name << std::endl; return false; } } return true; } // Just the public wrapper around the parse function. bool Parse(const char** argv) { return FlagList::parse(argv); } } // namespace flags KhronosGroup-SPIRV-Tools-f289d04/tools/util/flags.h000066400000000000000000000223501475742701700221150ustar00rootroot00000000000000// Copyright (c) 2023 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef INCLUDE_SPIRV_TOOLS_UTIL_FLAGS_HPP_ #define INCLUDE_SPIRV_TOOLS_UTIL_FLAGS_HPP_ #include #include #include #include #include // This file provides some utils to define a command-line interface with // required and optional flags. // - Flag order is not checked. // - Currently supported flag types: BOOLEAN, STRING // - As with most nix tools, using '--' in the command-line means all following // tokens will be considered positional // arguments. // Example: binary -g -- -g --some-other-flag // - the first `-g` is a flag. // - the second `-g` is not a flag. // - `--some-other-flag` is not a flag. // - Both long-form and short-form flags are supported, but boolean flags don't // support split boolean literals (short and long form). // Example: // -g : allowed, sets g to true. // --my-flag : allowed, sets --my-flag to true. // --my-flag=true : allowed, sets --my-flag to true. // --my-flag true : NOT allowed. // -g true : NOT allowed. // --my-flag=TRUE : NOT allowed. // // - This implementation also supports string flags: // -o myfile.spv : allowed, sets -o to `myfile.spv`. // --output=myfile.spv : allowed, sets --output to `myfile.spv`. // --output myfile.spv : allowd, sets --output to `myfile.spv`. // // Note: then second token is NOT checked for hyphens. // --output -file.spv // flag name: `output` // flag value: `-file.spv` // // - This implementation generates flag at compile time. Meaning flag names // must be valid C++ identifiers. // However, flags are usually using hyphens for word separation. Hence // renaming is done behind the scenes. Example: // // Declaring a long-form flag. // FLAG_LONG_bool(my_flag, [...]) // // -> in the code: flags::my_flag.value() // -> command-line: --my-flag // // - The only additional lexing done is around '='. Otherwise token list is // processed as received in the Parse() // function. // Lexing the '=' sign: // - This is only done when parsing a long-form flag name. // - the first '=' found is considered a marker for long-form, splitting // the token into 2. // Example: --option=value=abc -> [--option, value=abc] // // In most cases, you want to define some flags, parse them, and query them. // Here is a small code sample: // // ```c // // Defines a '-h' boolean flag for help printing, optional. // FLAG_SHORT_bool(h, /*default=*/ false, "Print the help.", false); // // Defines a '--my-flag' string flag, required. // FLAG_LONG_string(my_flag, /*default=*/ "", "A magic flag!", true); // // int main(int argc, const char** argv) { // if (!flags::Parse(argv)) { // return -1; // } // // if (flags::h.value()) { // printf("usage: my-bin --my-flag=\n"); // return 0; // } // // printf("flag value: %s\n", flags::my_flag.value().c_str()); // for (const std::string& arg : flags::positional_arguments) { // printf("arg: %s\n", arg.c_str()); // } // return 0; // } // ```c // Those macros can be used to define flags. // - They should be used in the global scope. // - Underscores in the flag variable name are replaced with hyphens ('-'). // // Example: // FLAG_SHORT_bool(my_flag, false, "some help", false); // - in the code: flags::my_flag // - command line: --my-flag=true // #define FLAG_LONG_string(Name, Default, Required) \ UTIL_FLAGS_FLAG_LONG(std::string, Name, Default, Required) #define FLAG_LONG_bool(Name, Default, Required) \ UTIL_FLAGS_FLAG_LONG(bool, Name, Default, Required) #define FLAG_LONG_uint(Name, Default, Required) \ UTIL_FLAGS_FLAG_LONG(uint32_t, Name, Default, Required) #define FLAG_SHORT_string(Name, Default, Required) \ UTIL_FLAGS_FLAG_SHORT(std::string, Name, Default, Required) #define FLAG_SHORT_bool(Name, Default, Required) \ UTIL_FLAGS_FLAG_SHORT(bool, Name, Default, Required) #define FLAG_SHORT_uint(Name, Default, Required) \ UTIL_FLAGS_FLAG_SHORT(uint32_t, Name, Default, Required) namespace flags { // Parse the command-line arguments, checking flags, and separating positional // arguments from flags. // // * argv: the argv array received in the main function. This utility expects // the last pointer to // be NULL, as it should if coming from the main() function. // // Returns `true` if the parsing succeeds, `false` otherwise. bool Parse(const char** argv); } // namespace flags // ===================== BEGIN NON-PUBLIC SECTION ============================= // All the code below belongs to the implementation, and there is no guaranteed // around the API stability. Please do not use it directly. // Defines the static variable holding the flag, allowing access like // flags::my_flag. // By creating the FlagRegistration object, the flag can be added to // the global list. // The final `extern` definition is ONLY useful for clang-format: // - if the macro doesn't ends with a semicolon, clang-format goes wild. // - cannot disable clang-format for those macros on clang < 16. // (https://github.com/llvm/llvm-project/issues/54522) // - cannot allow trailing semi (-Wextra-semi). #define UTIL_FLAGS_FLAG(Type, Prefix, Name, Default, Required, IsShort) \ namespace flags { \ Flag Name(Default); \ namespace { \ static FlagRegistration Name##_registration(Name, Prefix #Name, Required, \ IsShort); \ } \ } \ extern flags::Flag flags::Name #define UTIL_FLAGS_FLAG_LONG(Type, Name, Default, Required) \ UTIL_FLAGS_FLAG(Type, "--", Name, Default, Required, false) #define UTIL_FLAGS_FLAG_SHORT(Type, Name, Default, Required) \ UTIL_FLAGS_FLAG(Type, "-", Name, Default, Required, true) namespace flags { // Just a wrapper around the flag value. template struct Flag { public: Flag(T&& default_value) : value_(default_value) {} Flag(Flag&& other) = delete; Flag(const Flag& other) = delete; const T& value() const { return value_; } T& value() { return value_; } private: T value_; }; // To add support for new flag-types, this needs to be extended, and the visitor // below. using FlagType = std::variant>, std::reference_wrapper>, std::reference_wrapper>>; template inline constexpr bool always_false_v = false; extern std::vector positional_arguments; // Static class keeping track of the flags/arguments values. class FlagList { struct FlagInfo { FlagInfo(FlagType&& flag_, std::string&& name_, bool required_, bool is_short_) : flag(std::move(flag_)), name(std::move(name_)), required(required_), is_short(is_short_) {} FlagType flag; std::string name; bool required; bool is_short; }; public: template static void register_flag(Flag& flag, std::string&& name, bool required, bool is_short) { get_flags().emplace_back(flag, std::move(name), required, is_short); } static bool parse(const char** argv); #ifdef TESTING // Flags are supposed to be constant for the whole app execution, hence the // static storage. Gtest doesn't fork before running a test, meaning we have // to manually clear the context at teardown. static void reset() { get_flags().clear(); positional_arguments.clear(); } #endif private: static std::vector& get_flags() { static std::vector flags; return flags; } static bool parse_flag_info(FlagInfo& info, const char*** iterator); static void print_usage(const char* binary_name, const std::string& usage_format); }; template struct FlagRegistration { FlagRegistration(Flag& flag, std::string&& name, bool required, bool is_short) { std::string fixed_name = name; for (auto& c : fixed_name) { if (c == '_') { c = '-'; } } FlagList::register_flag(flag, std::move(fixed_name), required, is_short); } }; // Explicit deduction guide to avoid `-Wctad-maybe-unsupported`. template FlagRegistration(Flag&, std::string&&, bool, bool) -> FlagRegistration; } // namespace flags #endif // INCLUDE_SPIRV_TOOLS_UTIL_FLAGS_HPP_ KhronosGroup-SPIRV-Tools-f289d04/tools/val/000077500000000000000000000000001475742701700204535ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/tools/val/val.cpp000066400000000000000000000232341475742701700217450ustar00rootroot00000000000000// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include #include #include "source/spirv_target_env.h" #include "source/spirv_validator_options.h" #include "spirv-tools/libspirv.hpp" #include "tools/io.h" #include "tools/util/cli_consumer.h" void print_usage(char* argv0) { std::string target_env_list = spvTargetEnvList(36, 105); printf( R"(%s - Validate a SPIR-V binary file. USAGE: %s [options] [] The SPIR-V binary is read from . If no file is specified, or if the filename is "-", then the binary is read from standard input. NOTE: The validator is a work in progress. Options: -h, --help Print this help. --max-struct-members --max-struct-depth --max-local-variables --max-global-variables --max-switch-branches --max-function-args --max-control-flow-nesting-depth --max-access-chain-indexes --max-id-bound --relax-logical-pointer Allow allocating an object of a pointer type and returning a pointer value from a function in logical addressing mode --relax-block-layout Enable VK_KHR_relaxed_block_layout when checking standard uniform, storage buffer, and push constant layouts. This is the default when targeting Vulkan 1.1 or later. --uniform-buffer-standard-layout Enable VK_KHR_uniform_buffer_standard_layout when checking standard uniform buffer layouts. --scalar-block-layout Enable VK_EXT_scalar_block_layout when checking standard uniform, storage buffer, and push constant layouts. Scalar layout rules are more permissive than relaxed block layout so in effect this will override the --relax-block-layout option. --workgroup-scalar-block-layout Enable scalar block layout when checking Workgroup block layouts. --skip-block-layout Skip checking standard uniform/storage buffer layout. Overrides any --relax-block-layout or --scalar-block-layout option. --relax-struct-store Allow store from one struct type to a different type with compatible layout and members. --allow-localsizeid Allow use of the LocalSizeId decoration where it would otherwise not be allowed by the target environment. --allow-offset-texture-operand Allow use of the Offset texture operands where it would otherwise not be allowed by the target environment. --allow-vulkan-32-bit-bitwise Allow use of non-32 bit for the Base operand where it would otherwise not be allowed by the target environment. --before-hlsl-legalization Allows code patterns that are intended to be fixed by spirv-opt's legalization passes. --version Display validator version information. --target-env {%s} Use validation rules from the specified environment. )", argv0, argv0, target_env_list.c_str()); } int main(int argc, char** argv) { const char* inFile = nullptr; spv_target_env target_env = SPV_ENV_UNIVERSAL_1_6; spvtools::ValidatorOptions options; bool continue_processing = true; int return_code = 0; for (int argi = 1; continue_processing && argi < argc; ++argi) { const char* cur_arg = argv[argi]; if ('-' == cur_arg[0]) { if (0 == strncmp(cur_arg, "--max-", 6)) { if (argi + 1 < argc) { spv_validator_limit limit_type; if (spvParseUniversalLimitsOptions(cur_arg, &limit_type)) { uint32_t limit = 0; if (sscanf(argv[++argi], "%u", &limit)) { options.SetUniversalLimit(limit_type, limit); } else { fprintf(stderr, "error: missing argument to %s\n", cur_arg); continue_processing = false; return_code = 1; } } else { fprintf(stderr, "error: unrecognized option: %s\n", cur_arg); continue_processing = false; return_code = 1; } } else { fprintf(stderr, "error: Missing argument to %s\n", cur_arg); continue_processing = false; return_code = 1; } } else if (0 == strcmp(cur_arg, "--version")) { printf("%s\n", spvSoftwareVersionDetailsString()); printf( "Targets:\n %s\n %s\n %s\n %s\n %s\n %s\n %s\n %s\n %s\n " "%s\n %s\n %s\n %s %s\n", spvTargetEnvDescription(SPV_ENV_UNIVERSAL_1_0), spvTargetEnvDescription(SPV_ENV_UNIVERSAL_1_1), spvTargetEnvDescription(SPV_ENV_UNIVERSAL_1_2), spvTargetEnvDescription(SPV_ENV_UNIVERSAL_1_3), spvTargetEnvDescription(SPV_ENV_UNIVERSAL_1_4), spvTargetEnvDescription(SPV_ENV_UNIVERSAL_1_5), spvTargetEnvDescription(SPV_ENV_UNIVERSAL_1_6), spvTargetEnvDescription(SPV_ENV_OPENCL_2_2), spvTargetEnvDescription(SPV_ENV_VULKAN_1_0), spvTargetEnvDescription(SPV_ENV_VULKAN_1_1), spvTargetEnvDescription(SPV_ENV_VULKAN_1_1_SPIRV_1_4), spvTargetEnvDescription(SPV_ENV_VULKAN_1_2), spvTargetEnvDescription(SPV_ENV_VULKAN_1_3), spvTargetEnvDescription(SPV_ENV_VULKAN_1_4)); continue_processing = false; return_code = 0; } else if (0 == strcmp(cur_arg, "--help") || 0 == strcmp(cur_arg, "-h")) { print_usage(argv[0]); continue_processing = false; return_code = 0; } else if (0 == strcmp(cur_arg, "--target-env")) { if (argi + 1 < argc) { const auto env_str = argv[++argi]; if (!spvParseTargetEnv(env_str, &target_env)) { fprintf(stderr, "error: Unrecognized target env: %s\n", env_str); continue_processing = false; return_code = 1; } } else { fprintf(stderr, "error: Missing argument to --target-env\n"); continue_processing = false; return_code = 1; } } else if (0 == strcmp(cur_arg, "--before-hlsl-legalization")) { options.SetBeforeHlslLegalization(true); } else if (0 == strcmp(cur_arg, "--relax-logical-pointer")) { options.SetRelaxLogicalPointer(true); } else if (0 == strcmp(cur_arg, "--relax-block-layout")) { options.SetRelaxBlockLayout(true); } else if (0 == strcmp(cur_arg, "--uniform-buffer-standard-layout")) { options.SetUniformBufferStandardLayout(true); } else if (0 == strcmp(cur_arg, "--scalar-block-layout")) { options.SetScalarBlockLayout(true); } else if (0 == strcmp(cur_arg, "--workgroup-scalar-block-layout")) { options.SetWorkgroupScalarBlockLayout(true); } else if (0 == strcmp(cur_arg, "--skip-block-layout")) { options.SetSkipBlockLayout(true); } else if (0 == strcmp(cur_arg, "--allow-localsizeid")) { options.SetAllowLocalSizeId(true); } else if (0 == strcmp(cur_arg, "--allow-offset-texture-operand")) { options.SetAllowOffsetTextureOperand(true); } else if (0 == strcmp(cur_arg, "--allow-vulkan-32-bit-bitwise")) { options.SetAllowVulkan32BitBitwise(true); } else if (0 == strcmp(cur_arg, "--relax-struct-store")) { options.SetRelaxStructStore(true); } else if (0 == cur_arg[1]) { // Setting a filename of "-" to indicate stdin. if (!inFile) { inFile = cur_arg; } else { fprintf(stderr, "error: More than one input file specified\n"); continue_processing = false; return_code = 1; } } else { print_usage(argv[0]); continue_processing = false; return_code = 1; } } else { if (!inFile) { inFile = cur_arg; } else { fprintf(stderr, "error: More than one input file specified\n"); continue_processing = false; return_code = 1; } } } // Exit if command line parsing was not successful. if (!continue_processing) { return return_code; } std::vector contents; if (!ReadBinaryFile(inFile, &contents)) return 1; spvtools::SpirvTools tools(target_env); tools.SetMessageConsumer(spvtools::utils::CLIMessageConsumer); bool succeed = tools.Validate(contents.data(), contents.size(), options); return !succeed; } KhronosGroup-SPIRV-Tools-f289d04/utils/000077500000000000000000000000001475742701700176715ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/utils/check_code_format.sh000077500000000000000000000040241475742701700236470ustar00rootroot00000000000000#!/bin/bash # Copyright (c) 2017 Google Inc. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # This script determines if the source code in a Pull Request is properly formatted. # Exits with non 0 exit code if formatting is needed. # Assumptions: # - git and python3 are on the path # - Runs from the project root diretory. # - 'clang-format' is on the path, or env var CLANG_FORMAT points to it. # - 'clang-format-diff.py' is in the utils directory, or env var # points to it.CLANG_FORMAT_DIFF BASE_BRANCH=${1:-main} CLANG_FORMAT=${CLANG_FORMAT:-clang-format} if [ ! -f "$CLANG_FORMAT" ]; then echo missing clang-format: set CLANG_FORMAT or put clang-format in the PATH exit 1 fi # Find clang-format-diff.py from an environment variable, or use a default CLANG_FORMAT_DIFF=${CLANG_FORMAT_DIFF:-./utils/clang-format-diff.py} if [ ! -f "$CLANG_FORMAT_DIFF" ]; then echo missing clang-format-diffy.py: set CLANG_FORMAT_DIFF or put it in ./utils/clang-format-diff.py exit 1 fi echo "Comparing "$(git rev-parse HEAD)" against $BASE_BRANCH" FILES_TO_CHECK=$(git diff --name-only ${BASE_BRANCH} | grep -E ".*\.(cpp|cc|c\+\+|cxx|c|h|hpp)$") if [ -z "${FILES_TO_CHECK}" ]; then echo "No source code to check for formatting." exit 0 fi FORMAT_DIFF=$(git diff -U0 ${BASE_BRANCH} -- ${FILES_TO_CHECK} | python3 "${CLANG_FORMAT_DIFF}" -p1 -style=file -binary "$CLANG_FORMAT") if [ -z "${FORMAT_DIFF}" ]; then echo "All source code in PR properly formatted." exit 0 else echo "Found formatting errors!" echo "${FORMAT_DIFF}" exit 1 fi KhronosGroup-SPIRV-Tools-f289d04/utils/check_copyright.py000077500000000000000000000226511475742701700234210ustar00rootroot00000000000000#!/usr/bin/env python3 # coding=utf-8 # Copyright (c) 2016 Google Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Checks for copyright notices in all the files that need them under the current directory. Optionally insert them. When inserting, replaces an MIT or Khronos free use license with Apache 2. """ import argparse import fileinput import fnmatch import inspect import os import re import sys # List of designated copyright owners. AUTHORS = ['The Khronos Group Inc.', 'LunarG Inc.', 'Google Inc.', 'Google LLC', 'Pierre Moreau', 'Samsung Inc', 'André Perez Maselco', 'Vasyl Teliman', 'Advanced Micro Devices, Inc.', 'Stefano Milizia', 'Alastair F. Donaldson', 'Mostafa Ashraf', 'Shiyu Liu', 'ZHOU He', 'Nintendo', 'Epic Games, Inc.', 'NVIDIA Corporation'] CURRENT_YEAR = 2023 FIRST_YEAR = 2014 FINAL_YEAR = CURRENT_YEAR + 5 # A regular expression to match the valid years in the copyright information. YEAR_REGEX = '(' + '|'.join( str(year) for year in range(FIRST_YEAR, FINAL_YEAR + 1)) + ')' # A regular expression to make a range of years in the form -. YEAR_RANGE_REGEX = '(' for year1 in range(FIRST_YEAR, FINAL_YEAR + 1): for year2 in range(year1 + 1, FINAL_YEAR + 1): YEAR_RANGE_REGEX += str(year1) + '-' + str(year2) + '|' YEAR_RANGE_REGEX = YEAR_RANGE_REGEX[:-1] + ')' # In the copyright info, the year can be a single year or a range. This is a # regex to make sure it matches one of them. YEAR_OR_RANGE_REGEX = '(' + YEAR_REGEX + '|' + YEAR_RANGE_REGEX + ')' # The final regular expression to match a valid copyright line. COPYRIGHT_RE = re.compile('Copyright \(c\) {} ({})'.format( YEAR_OR_RANGE_REGEX, '|'.join(AUTHORS))) MIT_BEGIN_RE = re.compile('Permission is hereby granted, ' 'free of charge, to any person obtaining a') MIT_END_RE = re.compile('MATERIALS OR THE USE OR OTHER DEALINGS IN ' 'THE MATERIALS.') APACHE2_BEGIN_RE = re.compile('Licensed under the Apache License, ' 'Version 2.0 \(the "License"\);') APACHE2_END_RE = re.compile('limitations under the License.') LICENSED = """Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.""" LICENSED_LEN = 10 # Number of lines in LICENSED def find(top, filename_glob, skip_glob_dir_list, skip_glob_files_list): """Returns files in the tree rooted at top matching filename_glob but not in directories matching skip_glob_dir_list nor files matching skip_glob_dir_list.""" file_list = [] for path, dirs, files in os.walk(top): for glob in skip_glob_dir_list: for match in fnmatch.filter(dirs, glob): dirs.remove(match) for filename in fnmatch.filter(files, filename_glob): full_file = os.path.join(path, filename) if full_file not in skip_glob_files_list: file_list.append(full_file) return file_list def filtered_descendants(glob): """Returns glob-matching filenames under the current directory, but skips some irrelevant paths.""" return find('.', glob, ['third_party', 'external', 'CompilerIdCXX', 'build*', 'out*'], ['./utils/clang-format-diff.py']) def skip(line): """Returns true if line is all whitespace or shebang.""" stripped = line.lstrip() return stripped == '' or stripped.startswith('#!') def comment(text, prefix): """Returns commented-out text. Each line of text will be prefixed by prefix and a space character. Any trailing whitespace will be trimmed. """ accum = ['{} {}'.format(prefix, line).rstrip() for line in text.split('\n')] return '\n'.join(accum) def insert_copyright(author, glob, comment_prefix): """Finds all glob-matching files under the current directory and inserts the copyright message, and license notice. An MIT license or Khronos free use license (modified MIT) is replaced with an Apache 2 license. The copyright message goes into the first non-whitespace, non-shebang line in a file. The license notice follows it. Both are prefixed on each line by comment_prefix and a space. """ copyright = comment('Copyright (c) {} {}'.format(CURRENT_YEAR, author), comment_prefix) + '\n\n' licensed = comment(LICENSED, comment_prefix) + '\n\n' for file in filtered_descendants(glob): # Parsing states are: # 0 Initial: Have not seen a copyright declaration. # 1 Seen a copyright line and no other interesting lines # 2 In the middle of an MIT or Khronos free use license # 9 Exited any of the above state = 0 update_file = False for line in fileinput.input(file, inplace=1): emit = True if state == 0: if COPYRIGHT_RE.search(line): state = 1 elif skip(line): pass else: # Didn't see a copyright. Inject copyright and license. sys.stdout.write(copyright) sys.stdout.write(licensed) # Assume there isn't a previous license notice. state = 1 elif state == 1: if MIT_BEGIN_RE.search(line): state = 2 emit = False elif APACHE2_BEGIN_RE.search(line): # Assume an Apache license is preceded by a copyright # notice. So just emit it like the rest of the file. state = 9 elif state == 2: # Replace the MIT license with Apache 2 emit = False if MIT_END_RE.search(line): state = 9 sys.stdout.write(licensed) if emit: sys.stdout.write(line) def alert_if_no_copyright(glob, comment_prefix): """Prints names of all files missing either a copyright or Apache 2 license. Finds all glob-matching files under the current directory and checks if they contain the copyright message and license notice. Prints the names of all the files that don't meet both criteria. Returns the total number of file names printed. """ printed_count = 0 for file in filtered_descendants(glob): has_copyright = False has_apache2 = False line_num = 0 apache_expected_end = 0 with open(file, encoding='utf-8') as contents: for line in contents: line_num += 1 if COPYRIGHT_RE.search(line): has_copyright = True if APACHE2_BEGIN_RE.search(line): apache_expected_end = line_num + LICENSED_LEN if (line_num is apache_expected_end) and APACHE2_END_RE.search(line): has_apache2 = True if not (has_copyright and has_apache2): message = file if not has_copyright: message += ' has no copyright' if not has_apache2: message += ' has no Apache 2 license notice' print(message) printed_count += 1 return printed_count class ArgParser(argparse.ArgumentParser): def __init__(self): super(ArgParser, self).__init__( description=inspect.getdoc(sys.modules[__name__])) self.add_argument('--update', dest='author', action='store', help='For files missing a copyright notice, insert ' 'one for the given author, and add a license ' 'notice. The author must be in the AUTHORS ' 'list in the script.') def main(): glob_comment_pairs = [('*.h', '//'), ('*.hpp', '//'), ('*.sh', '#'), ('*.py', '#'), ('*.cpp', '//'), ('CMakeLists.txt', '#')] argparser = ArgParser() args = argparser.parse_args() if args.author: if args.author not in AUTHORS: print('error: --update argument must be in the AUTHORS list in ' 'check_copyright.py: {}'.format(AUTHORS)) sys.exit(1) for pair in glob_comment_pairs: insert_copyright(args.author, *pair) sys.exit(0) else: count = sum([alert_if_no_copyright(*p) for p in glob_comment_pairs]) sys.exit(count > 0) if __name__ == '__main__': main() KhronosGroup-SPIRV-Tools-f289d04/utils/check_symbol_exports.py000077500000000000000000000106051475742701700244760ustar00rootroot00000000000000#!/usr/bin/env python3 # Copyright (c) 2017 Google Inc. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Ensures that all externally visible functions in the library have an appropriate name Appropriate function names are: - names starting with spv, - anything in a namespace, - functions added by the protobuf compiler, - and weak definitions of new and delete.""" import os.path import re import subprocess import sys PROG = 'check_symbol_exports' def command_output(cmd, directory): """Runs a command in a directory and returns its standard output stream. Captures the standard error stream. Raises a RuntimeError if the command fails to launch or otherwise fails. """ p = subprocess.Popen(cmd, cwd=directory, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True) (stdout, _) = p.communicate() if p.returncode != 0: raise RuntimeError('Failed to run %s in %s' % (cmd, directory)) return stdout def check_library(library): """Scans the given library file for global exports. If all such exports are namespaced or begin with spv (in either C or C++ styles) then return 0. Otherwise emit a message and return 1.""" # The pattern for an externally visible symbol record symbol_pattern = re.compile(r'^[0-aA-Fa-f]+ +([wg]) *F \.text.*[0-9A-Fa-f]+ +(.*)') # Ok patterns are as follows, assuming Itanium name mangling: # spv[A-Z] : extern "C" symbol starting with spv # _ZN : something in a namespace # _ZSt : something in the standard namespace # _ZZN : something in a local scope and namespace # _Z[0-9]+spv[A-Z_] : C++ symbol starting with spv[A-Z_] symbol_ok_pattern = re.compile(r'^(spv[A-Z]|_ZN|_ZSt|_ZZN|_Z[0-9]+spv[A-Z_])') # In addition, the following pattern allowlists global functions that are added # by the protobuf compiler: # - AddDescriptors_spvtoolsfuzz_2eproto() # - InitDefaults_spvtoolsfuzz_2eproto() symbol_allowlist_pattern = re.compile(r'_Z[0-9]+.*spvtoolsfuzz_2eproto.*') symbol_is_new_or_delete = re.compile(r'^(_Zna|_Znw|_Zdl|_Zda)') # Compilaion for Arm has various thunks for constructors, destructors, vtables. # They are weak. symbol_is_thunk = re.compile(r'^_ZT') # This occurs in NDK builds. symbol_is_hidden = re.compile(r'^\.hidden ') seen = set() result = 0 for line in command_output(['objdump', '-t', library], '.').split('\n'): match = symbol_pattern.search(line) if match: linkage = match.group(1) symbol = match.group(2) if symbol not in seen: seen.add(symbol) #print("look at '{}'".format(symbol)) if not (symbol_is_new_or_delete.match(symbol) and linkage == 'w'): if not (symbol_is_thunk.match(symbol) and linkage == 'w'): if not (symbol_allowlist_pattern.match(symbol) or symbol_ok_pattern.match(symbol) or symbol_is_hidden.match(symbol)): print('{}: error: Unescaped exported symbol: {}'.format(PROG, symbol)) result = 1 return result def main(): import argparse parser = argparse.ArgumentParser(description='Check global names exported from a library') parser.add_argument('library', help='The static library to examine') args = parser.parse_args() if not os.path.isfile(args.library): print('{}: error: {} does not exist'.format(PROG, args.library)) sys.exit(1) if os.name == 'posix': status = check_library(args.library) sys.exit(status) else: print('Passing test since not on Posix') sys.exit(0) if __name__ == '__main__': main() KhronosGroup-SPIRV-Tools-f289d04/utils/fixup_fuzz_result.py000077500000000000000000000015201475742701700240530ustar00rootroot00000000000000#!/usr/bin/env python3 # Copyright (c) 2018 Google Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import sys if len(sys.argv) < 1: print("Need file to chop"); with open(sys.argv[1], mode='rb') as file: file_content = file.read() content = file_content[:len(file_content) - (len(file_content) % 4)] sys.stdout.write(content) KhronosGroup-SPIRV-Tools-f289d04/utils/generate_changelog.py000066400000000000000000000055051475742701700240510ustar00rootroot00000000000000#!/usr/bin/env python3 # Copyright (c) 2023 Google Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Args: # Updates an output file with changelog from the given CHANGES file and tag. # - search for first line matching in file # - search for the next line with a tag # - writes all the lines in between those 2 tags into import errno import os import os.path import re import subprocess import logging import sys # Regex to match the SPIR-V version tag. # Example of matching tags: # - v2020.1 # - v2020.1-dev # - v2020.1.rc1 VERSION_REGEX = re.compile(r'^(v\d+\.\d+) +[0-9]+-[0-9]+-[0-9]+$') def mkdir_p(directory): """Make the directory, and all its ancestors as required. Any of the directories are allowed to already exist.""" if directory == "": # We're being asked to make the current directory. return try: os.makedirs(directory) except OSError as e: if e.errno == errno.EEXIST and os.path.isdir(directory): pass else: raise def main(): FORMAT = '%(asctime)s %(message)s' logging.basicConfig(format="[%(asctime)s][%(levelname)-8s] %(message)s", datefmt="%H:%M:%S") if len(sys.argv) != 4: logging.error("usage: {} ".format(sys.argv[0])) sys.exit(1) changes_path = sys.argv[1] start_tag = sys.argv[2] output_file_path = sys.argv[3] changelog = [] has_found_start = False with open(changes_path, "r") as file: for line in file.readlines(): m = VERSION_REGEX.match(line) if m: print(m.groups()[0]) print(start_tag) if has_found_start: break; if start_tag == m.groups()[0]: has_found_start = True continue if has_found_start: changelog.append(line) if not has_found_start: logging.error("No tag matching {} found.".format(start_tag)) sys.exit(1) content = "".join(changelog) if os.path.isfile(output_file_path): with open(output_file_path, 'r') as f: if content == f.read(): sys.exit(0) mkdir_p(os.path.dirname(output_file_path)) with open(output_file_path, 'w') as f: f.write(content) sys.exit(0) if __name__ == '__main__': main() KhronosGroup-SPIRV-Tools-f289d04/utils/generate_grammar_tables.py000077500000000000000000001127471475742701700251140ustar00rootroot00000000000000#!/usr/bin/env python3 # Copyright (c) 2016 Google Inc. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Generates various info tables from SPIR-V JSON grammar.""" import errno import json import os.path import re # Prefix for all C variables generated by this script. PYGEN_VARIABLE_PREFIX = 'pygen_variable' # Extensions to recognize, but which don't necessarily come from the SPIR-V # core or KHR grammar files. Get this list from the SPIR-V registry web page. # NOTE: Only put things on this list if it is not in those grammar files. EXTENSIONS_FROM_SPIRV_REGISTRY_AND_NOT_FROM_GRAMMARS = """ SPV_AMD_gcn_shader SPV_AMD_gpu_shader_half_float SPV_AMD_gpu_shader_int16 SPV_AMD_shader_trinary_minmax SPV_KHR_non_semantic_info SPV_EXT_relaxed_printf_string_address_space """ OUTPUT_LANGUAGE = 'c' def make_path_to_file(f): """Makes all ancestor directories to the given file, if they don't yet exist. Arguments: f: The file whose ancestor directories are to be created. """ dir = os.path.dirname(os.path.abspath(f)) try: os.makedirs(dir) except OSError as e: if e.errno == errno.EEXIST and os.path.isdir(dir): pass else: raise def convert_min_required_version(version): """Converts the minimal required SPIR-V version encoded in the grammar to the symbol in SPIRV-Tools.""" if version is None: return 'SPV_SPIRV_VERSION_WORD(1, 0)' if version == 'None': return '0xffffffffu' return 'SPV_SPIRV_VERSION_WORD({})'.format(version.replace('.', ',')) def convert_max_required_version(version): """Converts the maximum required SPIR-V version encoded in the grammar to the symbol in SPIRV-Tools.""" if version is None: return '0xffffffffu' return 'SPV_SPIRV_VERSION_WORD({})'.format(version.replace('.', ',')) def get_alias_array_name(aliases): """Returns the name of the array containing all the given aliases. Arguments: - aliases: a sequence of alias names """ if not aliases: return 'nullptr'; return '{}_aliases_{}'.format(PYGEN_VARIABLE_PREFIX, ''.join(aliases)) def compose_alias_list(aliases): """Returns a string containing a braced list of aliases. Arguments: - aliases: a sequence of alias names Returns: a string containing the braced list of char* named by aliases. """ return '{' + ', '.join([('"{}"').format(a) for a in aliases]) + '}' def generate_aliases_arrays(aliases): """Returns the arrays of aliases Arguments: - aliases: a sequence of sequence of alias names """ aliases = sorted(set([tuple(a) for a in aliases if a])) arrays = [ 'static const char* {}[] = {};'.format( get_alias_array_name(a), compose_alias_list(a)) for a in aliases] return '\n'.join(arrays) def compose_capability_list(caps): """Returns a string containing a braced list of capabilities as enums. Arguments: - caps: a sequence of capability names Returns: a string containing the braced list of SpvCapability* or spv::Capability:: enums named by caps. """ base_string = 'SpvCapability' global OUTPUT_LANGUAGE if OUTPUT_LANGUAGE == 'c++': base_string = 'spv::Capability::' return '{' + ', '.join([(base_string + '{}').format(c) for c in caps]) + '}' def get_capability_array_name(caps): """Returns the name of the array containing all the given capabilities. Args: - caps: a sequence of capability names """ if not caps: return 'nullptr' return '{}_caps_{}'.format(PYGEN_VARIABLE_PREFIX, ''.join(caps)) def generate_capability_arrays(caps): """Returns the arrays of capabilities. Arguments: - caps: a sequence of sequence of capability names """ caps = sorted(set([tuple(c) for c in caps if c])) cap_str = 'SpvCapability' global OUTPUT_LANGUAGE if OUTPUT_LANGUAGE == 'c++': cap_str = 'spv::Capability' arrays = [ 'static const ' + cap_str + ' {}[] = {};'.format( get_capability_array_name(c), compose_capability_list(c)) for c in caps] return '\n'.join(arrays) def compose_extension_list(exts): """Returns a string containing a braced list of extensions as enums. Arguments: - exts: a sequence of extension names Returns: a string containing the braced list of extensions named by exts. """ return '{' + ', '.join( ['spvtools::Extension::k{}'.format(e) for e in exts]) + '}' def get_extension_array_name(extensions): """Returns the name of the array containing all the given extensions. Args: - extensions: a sequence of extension names """ if not extensions: return 'nullptr' else: return '{}_exts_{}'.format( PYGEN_VARIABLE_PREFIX, ''.join(extensions)) def generate_extension_arrays(extensions): """Returns the arrays of extensions. Arguments: - caps: a sequence of sequence of extension names """ extensions = sorted(set([tuple(e) for e in extensions if e])) arrays = [ 'static const spvtools::Extension {}[] = {};'.format( get_extension_array_name(e), compose_extension_list(e)) for e in extensions] return '\n'.join(arrays) def convert_operand_kind(operand_tuple): """Returns the corresponding operand type used in spirv-tools for the given operand kind and quantifier used in the JSON grammar. Arguments: - operand_tuple: a tuple of two elements: - operand kind: used in the JSON grammar - quantifier: '', '?', or '*' Returns: a string of the enumerant name in spv_operand_type_t """ kind, quantifier = operand_tuple # The following cases are where we differ between the JSON grammar and # spirv-tools. if kind == 'IdResultType': kind = 'TypeId' elif kind == 'IdResult': kind = 'ResultId' elif kind == 'IdMemorySemantics' or kind == 'MemorySemantics': kind = 'MemorySemanticsId' elif kind == 'IdScope' or kind == 'Scope': kind = 'ScopeId' elif kind == 'IdRef': kind = 'Id' elif kind == 'ImageOperands': kind = 'Image' elif kind == 'Dim': kind = 'Dimensionality' elif kind == 'ImageFormat': kind = 'SamplerImageFormat' elif kind == 'KernelEnqueueFlags': kind = 'KernelEnqFlags' elif kind == 'LiteralExtInstInteger': kind = 'ExtensionInstructionNumber' elif kind == 'LiteralSpecConstantOpInteger': kind = 'SpecConstantOpNumber' elif kind == 'LiteralContextDependentNumber': kind = 'TypedLiteralNumber' elif kind == 'PairLiteralIntegerIdRef': kind = 'LiteralIntegerId' elif kind == 'PairIdRefLiteralInteger': kind = 'IdLiteralInteger' elif kind == 'PairIdRefIdRef': # Used by OpPhi in the grammar kind = 'Id' if kind == 'FPRoundingMode': kind = 'FpRoundingMode' elif kind == 'FPFastMathMode': kind = 'FpFastMathMode' if quantifier == '?': kind = 'Optional{}'.format(kind) elif quantifier == '*': kind = 'Variable{}'.format(kind) return 'SPV_OPERAND_TYPE_{}'.format( re.sub(r'([a-z])([A-Z])', r'\1_\2', kind).upper()) class InstInitializer(object): """Instances holds a SPIR-V instruction suitable for printing as the initializer for spv_opcode_desc_t.""" def __init__(self, opname, aliases, caps, exts, operands, version, lastVersion): """Initialization. Arguments: - opname: opcode name (with the 'Op' prefix) - aliases: a sequence of aliases for the name of this opcode - caps: a sequence of capability names required by this opcode - exts: a sequence of names of extensions enabling this enumerant - operands: a sequence of (operand-kind, operand-quantifier) tuples - version: minimal SPIR-V version required for this opcode - lastVersion: last version of SPIR-V that includes this opcode """ assert opname.startswith('Op') self.opname = opname[2:] # Remove the "Op" prefix. self.num_aliases = len(aliases); self.aliases_mask = get_alias_array_name(aliases) self.num_caps = len(caps) self.caps_mask = get_capability_array_name(caps) self.num_exts = len(exts) self.exts = get_extension_array_name(exts) self.operands = [convert_operand_kind(o) for o in operands] self.fix_syntax() operands = [o[0] for o in operands] self.ref_type_id = 'IdResultType' in operands self.def_result_id = 'IdResult' in operands self.version = convert_min_required_version(version) self.lastVersion = convert_max_required_version(lastVersion) def fix_syntax(self): """Fix an instruction's syntax, adjusting for differences between the officially released grammar and how SPIRV-Tools uses the grammar. Fixes: - ExtInst should not end with SPV_OPERAND_VARIABLE_ID. https://github.com/KhronosGroup/SPIRV-Tools/issues/233 """ if (self.opname == 'ExtInst' and self.operands[-1] == 'SPV_OPERAND_TYPE_VARIABLE_ID'): self.operands.pop() def __str__(self): global OUTPUT_LANGUAGE base_str = 'SpvOp' if OUTPUT_LANGUAGE == 'c++': base_str = 'spv::Op::Op' template = ['{{"{opname}"', base_str + '{opname}', '{num_aliases}', '{aliases_mask}', '{num_caps}', '{caps_mask}', '{num_operands}', '{{{operands}}}', '{def_result_id}', '{ref_type_id}', '{num_exts}', '{exts}', '{min_version}', '{max_version}}}'] return ', '.join(template).format( opname=self.opname, num_aliases=self.num_aliases, aliases_mask=self.aliases_mask, num_caps=self.num_caps, caps_mask=self.caps_mask, num_operands=len(self.operands), operands=', '.join(self.operands), def_result_id=(1 if self.def_result_id else 0), ref_type_id=(1 if self.ref_type_id else 0), num_exts=self.num_exts, exts=self.exts, min_version=self.version, max_version=self.lastVersion) class ExtInstInitializer(object): """Instances holds a SPIR-V extended instruction suitable for printing as the initializer for spv_ext_inst_desc_t.""" def __init__(self, opname, opcode, caps, operands): """Initialization. Arguments: - opname: opcode name - opcode: enumerant value for this opcode - caps: a sequence of capability names required by this opcode - operands: a sequence of (operand-kind, operand-quantifier) tuples """ self.opname = opname self.opcode = opcode self.num_caps = len(caps) self.caps_mask = get_capability_array_name(caps) self.operands = [convert_operand_kind(o) for o in operands] self.operands.append('SPV_OPERAND_TYPE_NONE') def __str__(self): template = ['{{"{opname}"', '{opcode}', '{num_caps}', '{caps_mask}', '{{{operands}}}}}'] return ', '.join(template).format( opname=self.opname, opcode=self.opcode, num_caps=self.num_caps, caps_mask=self.caps_mask, operands=', '.join(self.operands)) def generate_instruction(inst, is_ext_inst): """Returns the C initializer for the given SPIR-V instruction. Arguments: - inst: a dict containing information about a SPIR-V instruction - is_ext_inst: a bool indicating whether |inst| is an extended instruction. Returns: a string containing the C initializer for spv_opcode_desc_t or spv_ext_inst_desc_t """ opname = inst.get('opname') opcode = inst.get('opcode') aliases = inst.get('aliases', []) caps = inst.get('capabilities', []) exts = inst.get('extensions', []) operands = inst.get('operands', {}) operands = [(o['kind'], o.get('quantifier', '')) for o in operands] min_version = inst.get('version', None) max_version = inst.get('lastVersion', None) assert opname is not None if is_ext_inst: return str(ExtInstInitializer(opname, opcode, caps, operands)) else: return str(InstInitializer(opname, aliases, caps, exts, operands, min_version, max_version)) def generate_instruction_table(inst_table): """Returns the info table containing all SPIR-V instructions, sorted by opcode, and prefixed by capability arrays. Note: - the built-in sorted() function is guaranteed to be stable. https://docs.python.org/3/library/functions.html#sorted Arguments: - inst_table: a list containing all SPIR-V instructions. """ inst_table = sorted(inst_table, key=lambda k: (k['opcode'], k['opname'])) aliases_arrays = generate_aliases_arrays( [inst.get('aliases', []) for inst in inst_table]) caps_arrays = generate_capability_arrays( [inst.get('capabilities', []) for inst in inst_table]) exts_arrays = generate_extension_arrays( [inst.get('extensions', []) for inst in inst_table]) insts = [generate_instruction(inst, False) for inst in inst_table] insts = ['static const spv_opcode_desc_t kOpcodeTableEntries[] = {{\n' ' {}\n}};'.format(',\n '.join(insts))] return '{}\n\n{}\n\n{}\n\n{}'.format(aliases_arrays, caps_arrays, exts_arrays, '\n'.join(insts)) def generate_extended_instruction_table(json_grammar, set_name, operand_kind_prefix=""): """Returns the info table containing all SPIR-V extended instructions, sorted by opcode, and prefixed by capability arrays. Arguments: - inst_table: a list containing all SPIR-V instructions. - set_name: the name of the extended instruction set. - operand_kind_prefix: the prefix, if any, to add to the front of operand kind names. """ if operand_kind_prefix: prefix_operand_kind_names(operand_kind_prefix, json_grammar) inst_table = json_grammar["instructions"] set_name = set_name.replace(".", "_") inst_table = sorted(inst_table, key=lambda k: k['opcode']) caps = [inst.get('capabilities', []) for inst in inst_table] caps_arrays = generate_capability_arrays(caps) insts = [generate_instruction(inst, True) for inst in inst_table] insts = ['static const spv_ext_inst_desc_t {}_entries[] = {{\n' ' {}\n}};'.format(set_name, ',\n '.join(insts))] return '{}\n\n{}'.format(caps_arrays, '\n'.join(insts)) class EnumerantInitializer(object): """Prints an enumerant as the initializer for spv_operand_desc_t.""" def __init__(self, enumerant, value, aliases, caps, exts, parameters, version, lastVersion): """Initialization. Arguments: - enumerant: enumerant name - value: enumerant value - aliases: a sequence of aliased capability names - caps: a sequence of capability names required by this enumerant - exts: a sequence of names of extensions enabling this enumerant - parameters: a sequence of (operand-kind, operand-quantifier) tuples - version: minimal SPIR-V version required for this opcode - lastVersion: last SPIR-V version this opode appears """ self.enumerant = enumerant self.value = value self.num_aliases = len(aliases) self.aliases = get_alias_array_name(aliases) self.num_caps = len(caps) self.caps = get_capability_array_name(caps) self.num_exts = len(exts) self.exts = get_extension_array_name(exts) self.parameters = [convert_operand_kind(p) for p in parameters] self.version = convert_min_required_version(version) self.lastVersion = convert_max_required_version(lastVersion) def __str__(self): template = ['{{"{enumerant}"', '{value}', '{num_aliases}', '{aliases}', '{num_caps}', '{caps}', '{num_exts}', '{exts}', '{{{parameters}}}', '{min_version}', '{max_version}}}'] return ', '.join(template).format( enumerant=self.enumerant, value=self.value, num_aliases=self.num_aliases, aliases=self.aliases, num_caps=self.num_caps, caps=self.caps, num_exts=self.num_exts, exts=self.exts, parameters=', '.join(self.parameters), min_version=self.version, max_version=self.lastVersion) def generate_enum_operand_kind_entry(entry, extension_map): """Returns the C initializer for the given operand enum entry. Arguments: - entry: a dict containing information about an enum entry - extension_map: a dict mapping enum value to list of extensions Returns: a string containing the C initializer for spv_operand_desc_t """ enumerant = entry.get('enumerant') value = entry.get('value') aliases = entry.get('aliases', []) caps = entry.get('capabilities', []) if value in extension_map: exts = extension_map[value] else: exts = [] params = entry.get('parameters', []) params = [p.get('kind') for p in params] params = zip(params, [''] * len(params)) version = entry.get('version', None) max_version = entry.get('lastVersion', None) assert enumerant is not None assert value is not None return str(EnumerantInitializer( enumerant, value, aliases, caps, exts, params, version, max_version)) def generate_enum_operand_kind(enum, synthetic_exts_list): """Returns the C definition for the given operand kind. It's a static const named array of spv_operand_desc_t. Also appends to |synthetic_exts_list| a list of extension lists used. """ kind = enum.get('kind') assert kind is not None # Sort all enumerants according to their values, but otherwise # preserve their order so the first name listed in the grammar # as the preferred name for disassembly. if enum.get('category') == 'ValueEnum': def functor(k): return (k['value']) else: def functor(k): return (int(k['value'], 16)) entries = sorted(enum.get('enumerants', []), key=functor) # SubgroupEqMask and SubgroupEqMaskKHR are the same number with # same semantics, but one has no extension list while the other # does. Both should have the extension list. # So create a mapping from enum value to the union of the extensions # across all those grammar entries. Preserve order. extension_map = {} for e in entries: value = e.get('value') extension_map[value] = [] for e in entries: value = e.get('value') exts = e.get('extensions', []) for ext in exts: if ext not in extension_map[value]: extension_map[value].append(ext) synthetic_exts_list.extend(extension_map.values()) name = '{}_{}Entries'.format(PYGEN_VARIABLE_PREFIX, kind) entries = [' {}'.format(generate_enum_operand_kind_entry(e, extension_map)) for e in entries] if len(entries) == 0: # Insert a dummy entry. Otherwise the array is empty and compilation # will fail in MSVC. entries = [' {"place holder", 0, 0, nullptr, 0, nullptr, 0, nullptr, {}, SPV_SPIRV_VERSION_WORD(999,0), 0}'] template = ['static const spv_operand_desc_t {name}[] = {{', '{entries}', '}};'] entries = '\n'.join(template).format( name=name, entries=',\n'.join(entries)) return kind, name, entries def generate_operand_kind_table(enums): """Returns the info table containing all SPIR-V operand kinds.""" # We only need to output info tables for those operand kinds that are enums. enums = [e for e in enums if e.get('category') in ['ValueEnum', 'BitEnum']] aliases = [entry.get('aliases', []) for enum in enums for entry in enum.get('enumerants', [])] aliases_arrays = generate_aliases_arrays(aliases) caps = [entry.get('capabilities', []) for enum in enums for entry in enum.get('enumerants', [])] caps_arrays = generate_capability_arrays(caps) exts = [entry.get('extensions', []) for enum in enums for entry in enum.get('enumerants', [])] enums = [generate_enum_operand_kind(e, exts) for e in enums] exts_arrays = generate_extension_arrays(exts) # We have a few operand kinds that require their optional counterpart to # exist in the operand info table. optional_enums = ['ImageOperands', 'AccessQualifier', 'MemoryAccess', 'PackedVectorFormat', 'CooperativeMatrixOperands', 'MatrixMultiplyAccumulateOperands', 'RawAccessChainOperands', 'FPEncoding'] optional_enums = [e for e in enums if e[0] in optional_enums] enums.extend(optional_enums) enum_kinds, enum_names, enum_entries = zip(*enums) # Mark the last few as optional ones. enum_quantifiers = [''] * (len(enums) - len(optional_enums)) + ['?'] * len(optional_enums) # And we don't want redefinition of them. enum_entries = enum_entries[:-len(optional_enums)] enum_kinds = [convert_operand_kind(e) for e in zip(enum_kinds, enum_quantifiers)] table_entries = zip(enum_kinds, enum_names, enum_names) table_entries = [' {{{}, ARRAY_SIZE({}), {}}}'.format(*e) for e in table_entries] template = [ 'static const spv_operand_desc_group_t {p}_OperandInfoTable[] = {{', '{enums}', '}};'] table = '\n'.join(template).format( p=PYGEN_VARIABLE_PREFIX, enums=',\n'.join(table_entries)) return '\n\n'.join((aliases_arrays,) + (caps_arrays,) + (exts_arrays,) + enum_entries + (table,)) def get_extension_list(instructions, operand_kinds): """Returns extensions as an alphabetically sorted list of strings.""" things_with_an_extensions_field = [item for item in instructions] enumerants = sum([item.get('enumerants', []) for item in operand_kinds], []) things_with_an_extensions_field.extend(enumerants) extensions = sum([item.get('extensions', []) for item in things_with_an_extensions_field if item.get('extensions')], []) for item in EXTENSIONS_FROM_SPIRV_REGISTRY_AND_NOT_FROM_GRAMMARS.split(): # If it's already listed in a grammar, then don't put it in the # special exceptions list. assert item not in extensions, 'Extension %s is already in a grammar file' % item extensions.extend( EXTENSIONS_FROM_SPIRV_REGISTRY_AND_NOT_FROM_GRAMMARS.split()) # Validator would ignore type declaration unique check. Should only be used # for legacy autogenerated test files containing multiple instances of the # same type declaration, if fixing the test by other methods is too # difficult. Shouldn't be used for any other reasons. extensions.append('SPV_VALIDATOR_ignore_type_decl_unique') return sorted(set(extensions)) def get_capabilities(operand_kinds): """Returns capabilities as a list of JSON objects, in order of appearance.""" enumerants = sum([item.get('enumerants', []) for item in operand_kinds if item.get('kind') in ['Capability']], []) return enumerants def generate_extension_enum(extensions): """Returns enumeration containing extensions declared in the grammar.""" return ',\n'.join(['k' + extension for extension in extensions]) def generate_extension_to_string_mapping(extensions): """Returns mapping function from extensions to corresponding strings.""" function = 'const char* ExtensionToString(Extension extension) {\n' function += ' switch (extension) {\n' template = ' case Extension::k{extension}:\n' \ ' return "{extension}";\n' function += ''.join([template.format(extension=extension) for extension in extensions]) function += ' }\n\n return "";\n}' return function def generate_string_to_extension_mapping(extensions): """Returns mapping function from strings to corresponding extensions.""" function = ''' bool GetExtensionFromString(const char* str, Extension* extension) {{ static const char* known_ext_strs[] = {{ {strs} }}; static const Extension known_ext_ids[] = {{ {ids} }}; const auto b = std::begin(known_ext_strs); const auto e = std::end(known_ext_strs); const auto found = std::equal_range( b, e, str, [](const char* str1, const char* str2) {{ return std::strcmp(str1, str2) < 0; }}); if (found.first == e || found.first == found.second) return false; *extension = known_ext_ids[found.first - b]; return true; }} '''.format(strs=', '.join(['"{}"'.format(e) for e in extensions]), ids=', '.join(['Extension::k{}'.format(e) for e in extensions])) return function def generate_capability_to_string_mapping(operand_kinds): """Returns mapping function from capabilities to corresponding strings. We take care to avoid emitting duplicate values. """ cap_str = 'SpvCapability' cap_join = '' global OUTPUT_LANGUAGE if OUTPUT_LANGUAGE == 'c++': cap_str = 'spv::Capability' cap_join = '::' function = 'const char* CapabilityToString(' + cap_str + ' capability) {\n' function += ' switch (capability) {\n' template = ' case ' + cap_str + cap_join + '{capability}:\n' \ ' return "{capability}";\n' emitted = set() # The values of capabilities we already have emitted for capability in get_capabilities(operand_kinds): value = capability.get('value') if value not in emitted: emitted.add(value) function += template.format(capability=capability.get('enumerant')) function += ' case ' + cap_str + cap_join + 'Max:\n' \ ' assert(0 && "Attempting to convert ' + cap_str + cap_join + 'Max to string");\n' \ ' return "";\n' function += ' }\n\n return "";\n}' return function def generate_all_string_enum_mappings(extensions, operand_kinds): """Returns all string-to-enum / enum-to-string mapping tables.""" tables = [] tables.append(generate_extension_to_string_mapping(extensions)) tables.append(generate_string_to_extension_mapping(extensions)) tables.append(generate_capability_to_string_mapping(operand_kinds)) return '\n\n'.join(tables) def precondition_operand_kinds(operand_kinds): """For operand kinds that have the same number, make sure they all have the same extension list.""" # Map operand kind and value to list of the union of extensions # for same-valued enumerants. exts = {} for kind_entry in operand_kinds: kind = kind_entry.get('kind') for enum_entry in kind_entry.get('enumerants', []): value = enum_entry.get('value') key = kind + '.' + str(value) if key in exts: exts[key].extend(enum_entry.get('extensions', [])) else: exts[key] = enum_entry.get('extensions', []) exts[key] = sorted(set(exts[key])) # Now make each entry the same list. for kind_entry in operand_kinds: kind = kind_entry.get('kind') for enum_entry in kind_entry.get('enumerants', []): value = enum_entry.get('value') key = kind + '.' + str(value) if len(exts[key]) > 0: enum_entry['extensions'] = exts[key] return operand_kinds def prefix_operand_kind_names(prefix, json_dict): """Modifies json_dict, by prefixing all the operand kind names with the given prefix. Also modifies their uses in the instructions to match. """ old_to_new = {} for operand_kind in json_dict["operand_kinds"]: old_name = operand_kind["kind"] new_name = prefix + old_name operand_kind["kind"] = new_name old_to_new[old_name] = new_name for instruction in json_dict["instructions"]: for operand in instruction.get("operands", []): replacement = old_to_new.get(operand["kind"]) if replacement is not None: operand["kind"] = replacement def main(): import argparse parser = argparse.ArgumentParser(description='Generate SPIR-V info tables') parser.add_argument('--spirv-core-grammar', metavar='', type=str, required=False, help='input JSON grammar file for core SPIR-V ' 'instructions') parser.add_argument('--extinst-debuginfo-grammar', metavar='', type=str, required=False, default=None, help='input JSON grammar file for DebugInfo extended ' 'instruction set') parser.add_argument('--extinst-cldebuginfo100-grammar', metavar='', type=str, required=False, default=None, help='input JSON grammar file for OpenCL.DebugInfo.100 ' 'extended instruction set') parser.add_argument('--extinst-glsl-grammar', metavar='', type=str, required=False, default=None, help='input JSON grammar file for GLSL extended ' 'instruction set') parser.add_argument('--extinst-opencl-grammar', metavar='', type=str, required=False, default=None, help='input JSON grammar file for OpenCL extended ' 'instruction set') parser.add_argument('--output-language', type=str, required=False, default='c', choices=['c','c++'], help='specify output language type') parser.add_argument('--core-insts-output', metavar='', type=str, required=False, default=None, help='output file for core SPIR-V instructions') parser.add_argument('--glsl-insts-output', metavar='', type=str, required=False, default=None, help='output file for GLSL extended instruction set') parser.add_argument('--opencl-insts-output', metavar='', type=str, required=False, default=None, help='output file for OpenCL extended instruction set') parser.add_argument('--operand-kinds-output', metavar='', type=str, required=False, default=None, help='output file for operand kinds') parser.add_argument('--extension-enum-output', metavar='', type=str, required=False, default=None, help='output file for extension enumeration') parser.add_argument('--enum-string-mapping-output', metavar='', type=str, required=False, default=None, help='output file for enum-string mappings') parser.add_argument('--extinst-vendor-grammar', metavar='', type=str, required=False, default=None, help='input JSON grammar file for vendor extended ' 'instruction set'), parser.add_argument('--vendor-insts-output', metavar='', type=str, required=False, default=None, help='output file for vendor extended instruction set') parser.add_argument('--vendor-operand-kind-prefix', metavar='', type=str, required=False, default=None, help='prefix for operand kinds (to disambiguate operand type enums)') args = parser.parse_args() global OUTPUT_LANGUAGE OUTPUT_LANGUAGE = args.output_language # The GN build system needs this because it doesn't handle quoting # empty string arguments well. if args.vendor_operand_kind_prefix == "...nil...": args.vendor_operand_kind_prefix = "" if (args.core_insts_output is None) != \ (args.operand_kinds_output is None): print('error: --core-insts-output and --operand-kinds-output ' 'should be specified together.') exit(1) if args.operand_kinds_output and not (args.spirv_core_grammar and args.extinst_debuginfo_grammar and args.extinst_cldebuginfo100_grammar): print('error: --operand-kinds-output requires --spirv-core-grammar ' 'and --extinst-debuginfo-grammar ' 'and --extinst-cldebuginfo100-grammar') exit(1) if (args.glsl_insts_output is None) != \ (args.extinst_glsl_grammar is None): print('error: --glsl-insts-output and --extinst-glsl-grammar ' 'should be specified together.') exit(1) if (args.opencl_insts_output is None) != \ (args.extinst_opencl_grammar is None): print('error: --opencl-insts-output and --extinst-opencl-grammar ' 'should be specified together.') exit(1) if (args.vendor_insts_output is None) != \ (args.extinst_vendor_grammar is None): print('error: --vendor-insts-output and ' '--extinst-vendor-grammar should be specified together.') exit(1) if all([args.core_insts_output is None, args.glsl_insts_output is None, args.opencl_insts_output is None, args.vendor_insts_output is None, args.extension_enum_output is None, args.enum_string_mapping_output is None]): print('error: at least one output should be specified.') exit(1) if args.spirv_core_grammar is not None: with open(args.spirv_core_grammar) as json_file: core_grammar = json.loads(json_file.read()) with open(args.extinst_debuginfo_grammar) as debuginfo_json_file: debuginfo_grammar = json.loads(debuginfo_json_file.read()) with open(args.extinst_cldebuginfo100_grammar) as cldebuginfo100_json_file: cldebuginfo100_grammar = json.loads(cldebuginfo100_json_file.read()) prefix_operand_kind_names("CLDEBUG100_", cldebuginfo100_grammar) instructions = [] instructions.extend(core_grammar['instructions']) instructions.extend(debuginfo_grammar['instructions']) instructions.extend(cldebuginfo100_grammar['instructions']) operand_kinds = [] operand_kinds.extend(core_grammar['operand_kinds']) operand_kinds.extend(debuginfo_grammar['operand_kinds']) operand_kinds.extend(cldebuginfo100_grammar['operand_kinds']) extensions = get_extension_list(instructions, operand_kinds) operand_kinds = precondition_operand_kinds(operand_kinds) if args.core_insts_output is not None: make_path_to_file(args.core_insts_output) make_path_to_file(args.operand_kinds_output) with open(args.core_insts_output, 'w') as f: f.write(generate_instruction_table( core_grammar['instructions'])) with open(args.operand_kinds_output, 'w') as f: f.write(generate_operand_kind_table(operand_kinds)) if args.extension_enum_output is not None: make_path_to_file(args.extension_enum_output) with open(args.extension_enum_output, 'w') as f: f.write(generate_extension_enum(extensions)) if args.enum_string_mapping_output is not None: make_path_to_file(args.enum_string_mapping_output) with open(args.enum_string_mapping_output, 'w') as f: f.write(generate_all_string_enum_mappings( extensions, operand_kinds)) if args.extinst_glsl_grammar is not None: with open(args.extinst_glsl_grammar) as json_file: grammar = json.loads(json_file.read()) make_path_to_file(args.glsl_insts_output) with open(args.glsl_insts_output, 'w') as f: f.write(generate_extended_instruction_table( grammar, 'glsl')) if args.extinst_opencl_grammar is not None: with open(args.extinst_opencl_grammar) as json_file: grammar = json.loads(json_file.read()) make_path_to_file(args.opencl_insts_output) with open(args.opencl_insts_output, 'w') as f: f.write(generate_extended_instruction_table( grammar, 'opencl')) if args.extinst_vendor_grammar is not None: with open(args.extinst_vendor_grammar) as json_file: grammar = json.loads(json_file.read()) make_path_to_file(args.vendor_insts_output) name = args.extinst_vendor_grammar start = name.find('extinst.') + len('extinst.') name = name[start:-len('.grammar.json')].replace('-', '_') with open(args.vendor_insts_output, 'w') as f: f.write(generate_extended_instruction_table( grammar, name, args.vendor_operand_kind_prefix)) if __name__ == '__main__': main() KhronosGroup-SPIRV-Tools-f289d04/utils/generate_language_headers.py000077500000000000000000000140061475742701700253770ustar00rootroot00000000000000#!/usr/bin/env python3 # Copyright (c) 2017 Google Inc. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Generates language headers from a JSON grammar file""" import errno import json import os.path import re def make_path_to_file(f): """Makes all ancestor directories to the given file, if they don't yet exist. Arguments: f: The file whose ancestor directories are to be created. """ dir = os.path.dirname(os.path.abspath(f)) try: os.makedirs(dir) except OSError as e: if e.errno == errno.EEXIST and os.path.isdir(dir): pass else: raise class ExtInstGrammar: """The grammar for an extended instruction set""" def __init__(self, name, copyright, instructions, operand_kinds, version = None, revision = None): self.name = name self.copyright = copyright self.instructions = instructions self.operand_kinds = operand_kinds self.version = version self.revision = revision class LangGenerator: """A language-specific generator""" def __init__(self): self.upper_case_initial = re.compile('^[A-Z]') pass def comment_prefix(self): return "" def namespace_prefix(self): return "" def uses_guards(self): return False def cpp_guard_preamble(self): return "" def cpp_guard_postamble(self): return "" def enum_value(self, prefix, name, value): if self.upper_case_initial.match(name): use_name = name else: use_name = '_' + name return " {}{} = {},".format(prefix, use_name, value) def generate(self, grammar): """Returns a string that is the language-specific header for the given grammar""" parts = [] if grammar.copyright: parts.extend(["{}{}".format(self.comment_prefix(), f) for f in grammar.copyright]) parts.append('') guard = 'SPIRV_EXTINST_{}_H_'.format(grammar.name) if self.uses_guards: parts.append('#ifndef {}'.format(guard)) parts.append('#define {}'.format(guard)) parts.append('') parts.append(self.cpp_guard_preamble()) if grammar.version: parts.append(self.const_definition(grammar.name, 'Version', grammar.version)) if grammar.revision is not None: parts.append(self.const_definition(grammar.name, 'Revision', grammar.revision)) parts.append('') if grammar.instructions: parts.append(self.enum_prefix(grammar.name, 'Instructions')) for inst in grammar.instructions: parts.append(self.enum_value(grammar.name, inst['opname'], inst['opcode'])) parts.append(self.enum_end(grammar.name, 'Instructions')) parts.append('') if grammar.operand_kinds: for kind in grammar.operand_kinds: parts.append(self.enum_prefix(grammar.name, kind['kind'])) for e in kind['enumerants']: parts.append(self.enum_value(grammar.name, e['enumerant'], e['value'])) parts.append(self.enum_end(grammar.name, kind['kind'])) parts.append('') parts.append(self.cpp_guard_postamble()) if self.uses_guards: parts.append('#endif // {}'.format(guard)) return '\n'.join(parts) class CLikeGenerator(LangGenerator): def uses_guards(self): return True def comment_prefix(self): return "// " def const_definition(self, prefix, var, value): # Use an anonymous enum. Don't use a static const int variable because # that can bloat binary size. return 'enum {0} {1}{2} = {3}, {1}{2}_BitWidthPadding = 0x7fffffff {4};'.format( '{', prefix, var, value, '}') def enum_prefix(self, prefix, name): return 'enum {}{} {}'.format(prefix, name, '{') def enum_end(self, prefix, enum): return ' {}{}Max = 0x7ffffff\n{};\n'.format(prefix, enum, '}') def cpp_guard_preamble(self): return '#ifdef __cplusplus\nextern "C" {\n#endif\n' def cpp_guard_postamble(self): return '#ifdef __cplusplus\n}\n#endif\n' class CGenerator(CLikeGenerator): pass def main(): import argparse parser = argparse.ArgumentParser(description='Generate language headers from a JSON grammar') parser.add_argument('--extinst-grammar', metavar='', type=str, required=True, help='input JSON grammar file for extended instruction set') parser.add_argument('--extinst-output-path', metavar='', type=str, required=True, help='Path of the language-specific output file.') args = parser.parse_args() with open(args.extinst_grammar) as json_file: grammar_json = json.loads(json_file.read()) grammar_name = os.path.splitext(os.path.basename(args.extinst_output_path))[0] grammar = ExtInstGrammar(name = grammar_name, copyright = grammar_json['copyright'], instructions = grammar_json['instructions'], operand_kinds = grammar_json['operand_kinds'], version = grammar_json['version'], revision = grammar_json['revision']) make_path_to_file(args.extinst_output_path) with open(args.extinst_output_path, 'w') as f: f.write(CGenerator().generate(grammar)) if __name__ == '__main__': main() KhronosGroup-SPIRV-Tools-f289d04/utils/generate_registry_tables.py000077500000000000000000000067341475742701700253340ustar00rootroot00000000000000#!/usr/bin/env python3 # Copyright (c) 2016 Google Inc. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Generates the vendor tool table from the SPIR-V XML registry.""" import errno import io import os.path import platform from xml.etree.ElementTree import XML, XMLParser, TreeBuilder def mkdir_p(directory): """Make the directory, and all its ancestors as required. Any of the directories are allowed to already exist. This is compatible with Python down to 3.0. """ if directory == "": # We're being asked to make the current directory. return try: os.makedirs(directory) except OSError as e: if e.errno == errno.EEXIST and os.path.isdir(directory): pass else: raise def generate_vendor_table(registry): """Returns a list of C style initializers for the registered vendors and their tools. Args: registry: The SPIR-V XMLregistry as an xml.ElementTree """ lines = [] for ids in registry.iter('ids'): if 'vendor' == ids.attrib['type']: for an_id in ids.iter('id'): value = an_id.attrib['value'] vendor = an_id.attrib['vendor'] if 'tool' in an_id.attrib: tool = an_id.attrib['tool'] vendor_tool = vendor + ' ' + tool else: tool = '' vendor_tool = vendor line = '{' + '{}, "{}", "{}", "{}"'.format(value, vendor, tool, vendor_tool) + '},' lines.append(line) return '\n'.join(lines) def main(): import argparse parser = argparse.ArgumentParser(description= 'Generate tables from SPIR-V XML registry') parser.add_argument('--xml', metavar='', type=str, required=True, help='SPIR-V XML Registry file') parser.add_argument('--generator-output', metavar='', type=str, required=True, help='output file for SPIR-V generators table') args = parser.parse_args() with io.open(args.xml, encoding='utf-8') as xml_in: # Python3 default str to UTF-8. But Python2.7 (in case of NDK build, # don't be fooled by the shebang) is returning a unicode string. # So depending of the version, we need to make sure the correct # encoding is used. content = xml_in.read() if platform.python_version_tuple()[0] == '2': content = content.encode('utf-8') parser = XMLParser(target=TreeBuilder(), encoding='utf-8') registry = XML(content, parser=parser) mkdir_p(os.path.dirname(args.generator_output)) with open(args.generator_output, 'w') as f: f.write(generate_vendor_table(registry)) if __name__ == '__main__': main() KhronosGroup-SPIRV-Tools-f289d04/utils/git-sync-deps000077500000000000000000000273541475742701700223200ustar00rootroot00000000000000#!/usr/bin/env python3 # Copyright 2014 Google Inc. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are # met: # # * Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # * Redistributions in binary form must reproduce the above # copyright notice, this list of conditions and the following disclaimer # in the documentation and/or other materials provided with the # distribution. # * Neither the name of Google Inc. nor the names of its # contributors may be used to endorse or promote products derived from # this software without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """Parse a DEPS file and git checkout all of the dependencies. """ EXTRA_HELP = """ Environment Variables: GIT_EXECUTABLE: path to "git" binary; if unset, will look for one of ['git', 'git.exe', 'git.bat'] in your default path. GIT_SYNC_DEPS_PATH: file to get the dependency list from; if unset, will use the file ../DEPS relative to this script's directory. GIT_SYNC_DEPS_QUIET: if set to non-empty string, suppress messages. Git Config: To disable syncing of a single repository: cd path/to/repository git config sync-deps.disable true To re-enable sync: cd path/to/repository git config --unset sync-deps.disable """ import argparse import os import re import subprocess import sys import threading from builtins import bytes def git_executable(): """Find the git executable. Returns: A triple: A string suitable for passing to subprocess functions, or None. The major version number The minor version number """ envgit = os.environ.get('GIT_EXECUTABLE') searchlist = ['git', 'git.exe', 'git.bat'] if envgit: searchlist.insert(0, envgit) with open(os.devnull, 'w') as devnull: for git in searchlist: major=None minor=None try: version_info = subprocess.check_output([git, '--version']).decode('utf-8') match = re.search(r"^git version (\d+)\.(\d+)",version_info) print("Using {}".format(version_info)) if match: major = int(match.group(1)) minor = int(match.group(2)) else: continue except (OSError,): continue return (git,major,minor) return (None,0,0) DEFAULT_DEPS_PATH = os.path.normpath( os.path.join(os.path.dirname(__file__), os.pardir, 'DEPS')) def get_deps_os_str(deps_file): parsed_deps = parse_file_to_dict(deps_file) parts = [] if 'deps_os' in parsed_deps: for deps_os in parsed_deps['deps_os']: parts.append(' [{}]]'.format(deps_os)) return "\n".join(parts) def looks_like_raw_commit(commit): return re.match('^[a-f0-9]{40}$', commit) is not None def git_repository_sync_is_disabled(git, directory): try: disable = subprocess.check_output( [git, 'config', 'sync-deps.disable'], cwd=directory) return disable.lower().strip() in ['true', '1', 'yes', 'on'] except subprocess.CalledProcessError: return False def is_git_toplevel(git, directory): """Return true iff the directory is the top level of a Git repository. Args: git (string) the git executable directory (string) the path into which the repository is expected to be checked out. """ try: toplevel = subprocess.check_output( [git, 'rev-parse', '--show-toplevel'], cwd=directory).strip() return os.path.realpath(bytes(directory, 'utf8')) == os.path.realpath(toplevel) except subprocess.CalledProcessError: return False def status(directory, checkoutable): def truncate(s, length): return s if len(s) <= length else '...' + s[-(length - 3):] dlen = 36 directory = truncate(directory, dlen) checkoutable = truncate(checkoutable, 40) sys.stdout.write('%-*s @ %s\n' % (dlen, directory, checkoutable)) def git_checkout_to_directory(git, repo, checkoutable, directory, verbose, treeless): """Checkout (and clone if needed) a Git repository. Args: git (string) the git executable repo (string) the location of the repository, suitable for passing to `git clone`. checkoutable (string) a tag, branch, or commit, suitable for passing to `git checkout` directory (string) the path into which the repository should be checked out. verbose (boolean): emit status info to stdout treeless (boolean): when true, clone without any trees. Raises an exception if any calls to git fail. """ if not os.path.isdir(directory): # Use blobless or treeless checkouts for faster downloads. # This defers some work to checkout time. # https://github.blog/2020-12-21-get-up-to-speed-with-partial-clone-and-shallow-clone/ filter = ['--filter=tree:0'] if treeless else ['--filter=blob:none'] # If the thing to check out looks like a tag (and not like a commit), # then limit the checkout to that branch. branch = [] if looks_like_raw_commit(checkoutable) else ['--branch={}'.format(checkoutable)] subprocess.check_call( [git, 'clone', '--quiet', '--single-branch'] + filter + branch + [repo, directory]) if not is_git_toplevel(git, directory): # if the directory exists, but isn't a git repo, you will modify # the parent repostory, which isn't what you want. sys.stdout.write('%s\n IS NOT TOP-LEVEL GIT DIRECTORY.\n' % directory) return # Check to see if this repo is disabled. Quick return. if git_repository_sync_is_disabled(git, directory): sys.stdout.write('%s\n SYNC IS DISABLED.\n' % directory) return with open(os.devnull, 'w') as devnull: # If this fails, we will fetch before trying again. Don't spam user # with error information. if 0 == subprocess.call([git, 'checkout', '--quiet', checkoutable], cwd=directory, stderr=devnull): # if this succeeds, skip slow `git fetch`. if verbose: status(directory, checkoutable) # Success. return # If the repo has changed, always force use of the correct repo. # If origin already points to repo, this is a quick no-op. subprocess.check_call( [git, 'remote', 'set-url', 'origin', repo], cwd=directory) subprocess.check_call([git, 'fetch', '--quiet'], cwd=directory) subprocess.check_call([git, 'checkout', '--quiet', checkoutable], cwd=directory) if verbose: status(directory, checkoutable) # Success. def parse_file_to_dict(path): dictionary = {} contents = open(path).read() # Need to convert Var() to vars[], so that the DEPS is actually Python. Var() # comes from Autoroller using gclient which has a slightly different DEPS # format. contents = re.sub(r"Var\((.*?)\)", r"vars[\1]", contents) exec(contents, dictionary) return dictionary def git_sync_deps(deps_file_path, command_line_os_requests, verbose, treeless): """Grab dependencies, with optional platform support. Args: deps_file_path (string) Path to the DEPS file. command_line_os_requests (list of strings) Can be empty list. List of strings that should each be a key in the deps_os dictionary in the DEPS file. verbose (boolean): emit status info to stdout treeless (boolean): when true, clone as treeless instead of blobless Raises git Exceptions. """ (git,git_major,git_minor) = git_executable() assert git # --filter=tree:0 is available in git 2.20 and later if (git_major,git_minor) < (2,20): print("disabling --treeless: git is older than v2.20") treeless = False deps_file_directory = os.path.dirname(deps_file_path) deps_file = parse_file_to_dict(deps_file_path) dependencies = deps_file['deps'].copy() os_specific_dependencies = deps_file.get('deps_os', dict()) if 'all' in command_line_os_requests: for value in list(os_specific_dependencies.values()): dependencies.update(value) else: for os_name in command_line_os_requests: # Add OS-specific dependencies if os_name in os_specific_dependencies: dependencies.update(os_specific_dependencies[os_name]) for directory in dependencies: for other_dir in dependencies: if directory.startswith(other_dir + '/'): raise Exception('%r is parent of %r' % (other_dir, directory)) list_of_arg_lists = [] for directory in sorted(dependencies): if '@' in dependencies[directory]: repo, checkoutable = dependencies[directory].split('@', 1) else: raise Exception("please specify commit or tag") relative_directory = os.path.join(deps_file_directory, directory) list_of_arg_lists.append( (git, repo, checkoutable, relative_directory, verbose, treeless)) multithread(git_checkout_to_directory, list_of_arg_lists) for directory in deps_file.get('recursedeps', []): recursive_path = os.path.join(deps_file_directory, directory, 'DEPS') git_sync_deps(recursive_path, command_line_os_requests, verbose) def multithread(function, list_of_arg_lists): # for args in list_of_arg_lists: # function(*args) # return threads = [] for args in list_of_arg_lists: thread = threading.Thread(None, function, None, args) thread.start() threads.append(thread) for thread in threads: thread.join() def main(argv): argparser = argparse.ArgumentParser( prog = "git-sync-deps", description = "Checkout git-based dependencies as specified by the DEPS file", add_help=False # Because we want to print deps_os with -h option ) argparser.add_argument("--help", "-h", action='store_true', help="show this help message and exit") argparser.add_argument("--deps", default = os.environ.get('GIT_SYNC_DEPS_PATH', DEFAULT_DEPS_PATH), help="location of the the DEPS file") argparser.add_argument("--verbose", default=not bool(os.environ.get('GIT_SYNC_DEPS_QUIET', False)), action='store_true', help="be verbose: print status messages") argparser.add_argument("--treeless", default=False, action='store_true', help=""" Clone repos without trees (--filter=tree:0). This is the fastest option for a build machine, when you only need a single commit. Defers getting objects until checking out a commit. The default is to clone with trees but without blobs. Only takes effect if using git 2.20 or later. See https://github.blog/2020-12-21-get-up-to-speed-with-partial-clone-and-shallow-clone/ """) argparser.add_argument("os_requests",nargs="*", help="OS requests, as keys in the deps_os dictionariy in the DEPS file") args = argparser.parse_args() if args.help: print(argparser.format_help()) print(EXTRA_HELP) print(get_deps_os_str(args.deps)) return 0 git_sync_deps(args.deps, args.os_requests, args.verbose, args.treeless) return 0 if __name__ == '__main__': exit(main(sys.argv[1:])) KhronosGroup-SPIRV-Tools-f289d04/utils/roll_deps.sh000077500000000000000000000035311475742701700222150ustar00rootroot00000000000000#!/usr/bin/env bash # Copyright (c) 2021 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Attempts to roll all entries in DEPS to tip-of-tree and create a commit. # # Depends on roll-dep from depot_tools # (https://chromium.googlesource.com/chromium/tools/depot_tools) being in PATH. set -eo pipefail function ExitIfIsInterestingError() { local return_code=$1 if [[ ${return_code} -ne 0 && ${return_code} -ne 2 ]]; then exit ${return_code} fi return 0 } declare -A dependency_to_branch_map dependency_to_branch_map["external/abseil_cpp"]="origin/master" dependency_to_branch_map["external/effcee/"]="origin/main" dependency_to_branch_map["external/googletest/"]="origin/main" dependency_to_branch_map["external/re2/"]="origin/main" dependency_to_branch_map["external/spirv-headers/"]="origin/main" # This script assumes it's parent directory is the repo root. repo_path=$(dirname "$0")/.. cd "$repo_path" if [[ $(git diff --stat) != '' ]]; then echo "Working tree is dirty, commit changes before attempting to roll DEPS" exit 1 fi echo "*** Ignore messages about running 'git cl upload' ***" old_head=$(git rev-parse HEAD) set +e for dep in ${!dependency_to_branch_map[@]}; do branch=${dependency_to_branch_map[$dep]} echo "Rolling $dep" roll-dep --ignore-dirty-tree --roll-to="${branch}" "${dep}" ExitIfIsInterestingError $? done KhronosGroup-SPIRV-Tools-f289d04/utils/update_build_version.py000077500000000000000000000146771475742701700244730ustar00rootroot00000000000000#!/usr/bin/env python3 # Copyright (c) 2016 Google Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Updates an output file with version info unless the new content is the same # as the existing content. # # Args: # # The output file will contain a line of text consisting of two C source syntax # string literals separated by a comma: # - The software version deduced from the given CHANGES file. # - A longer string with the project name, the software version number, and # git commit information for the CHANGES file's directory. The commit # information is the content of the FORCED_BUILD_VERSION_DESCRIPTION # environement variable is it exists, else the output of "git describe" if # that succeeds, or "git rev-parse HEAD" if that succeeds, or otherwise a # message containing the phrase "unknown hash". # The string contents are escaped as necessary. import datetime import errno import os import os.path import re import subprocess import logging import sys import time # Format of the output generated by this script. Example: # "v2023.1", "SPIRV-Tools v2023.1 0fc5526f2b01a0cc89192c10cf8bef77f1007a62, 2023-01-18T14:51:49" OUTPUT_FORMAT = '"{version_tag}", "SPIRV-Tools {version_tag} {description}"\n' def mkdir_p(directory): """Make the directory, and all its ancestors as required. Any of the directories are allowed to already exist.""" if directory == "": # We're being asked to make the current directory. return try: os.makedirs(directory) except OSError as e: if e.errno == errno.EEXIST and os.path.isdir(directory): pass else: raise def command_output(cmd, directory): """Runs a command in a directory and returns its standard output stream. Returns (False, None) if the command fails to launch or otherwise fails. """ try: # Set shell=True on Windows so that Chromium's git.bat can be found when # 'git' is invoked. p = subprocess.Popen(cmd, cwd=directory, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=os.name == 'nt') (stdout, _) = p.communicate() if p.returncode != 0: return False, None except Exception as e: return False, None return p.returncode == 0, stdout def deduce_software_version(changes_file): """Returns a tuple (success, software version number) parsed from the given CHANGES file. Success is set to True if the software version could be deduced. Software version is undefined if success if False. Function expects the CHANGES file to describes most recent versions first. """ # Match the first well-formed version-and-date line # Allow trailing whitespace in the checked-out source code has # unexpected carriage returns on a linefeed-only system such as # Linux. pattern = re.compile(r'^(v\d+\.\d+(-dev)?) \d\d\d\d-\d\d-\d\d\s*$') with open(changes_file, mode='r') as f: for line in f.readlines(): match = pattern.match(line) if match: return True, match.group(1) return False, None def describe(repo_path): """Returns a string describing the current Git HEAD version as descriptively as possible. Runs 'git describe', or alternately 'git rev-parse HEAD', in directory. If successful, returns the output; otherwise returns 'unknown hash, '.""" # if we're in a git repository, attempt to extract version info success, output = command_output(["git", "rev-parse", "--show-toplevel"], repo_path) if success: success, output = command_output(["git", "describe", "--tags", "--match=v*", "--long"], repo_path) if not success: success, output = command_output(["git", "rev-parse", "HEAD"], repo_path) if success: # decode() is needed here for Python3 compatibility. In Python2, # str and bytes are the same type, but not in Python3. # Popen.communicate() returns a bytes instance, which needs to be # decoded into text data first in Python3. And this decode() won't # hurt Python2. return output.rstrip().decode() # This is the fallback case where git gives us no information, # e.g. because the source tree might not be in a git tree or # git is not available on the system. # In this case, usually use a timestamp. However, to ensure # reproducible builds, allow the builder to override the wall # clock time with environment variable SOURCE_DATE_EPOCH # containing a (presumably) fixed timestamp. timestamp = int(os.environ.get('SOURCE_DATE_EPOCH', time.time())) iso_date = datetime.datetime.fromtimestamp(timestamp, datetime.timezone.utc).isoformat() return "unknown hash, {}".format(iso_date) def main(): FORMAT = '%(asctime)s %(message)s' logging.basicConfig(format="[%(asctime)s][%(levelname)-8s] %(message)s", datefmt="%H:%M:%S") if len(sys.argv) != 3: logging.error("usage: {} ".format(sys.argv[0])) sys.exit(1) changes_file_path = os.path.realpath(sys.argv[1]) output_file_path = sys.argv[2] success, version = deduce_software_version(changes_file_path) if not success: logging.error("Could not deduce latest release version from {}.".format(changes_file_path)) sys.exit(1) repo_path = os.path.dirname(changes_file_path) description = os.getenv("FORCED_BUILD_VERSION_DESCRIPTION", describe(repo_path)) content = OUTPUT_FORMAT.format(version_tag=version, description=description) # Escape file content. content.replace('"', '\\"') if os.path.isfile(output_file_path): with open(output_file_path, 'r') as f: if content == f.read(): return mkdir_p(os.path.dirname(output_file_path)) with open(output_file_path, 'w') as f: f.write(content) if __name__ == '__main__': main() KhronosGroup-SPIRV-Tools-f289d04/utils/vim/000077500000000000000000000000001475742701700204645ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/utils/vim/README.md000066400000000000000000000043771475742701700217560ustar00rootroot00000000000000# Neovim configuration guide for SPIR-V disassembly files This directory holds instructions to configure Neovim for SPIR-V assembly files (`.spvasm`) At the end, Neovim should support: * Syntax highlighting * Jump to definition * Find all references * Symbol renaming * Operand hover information * Formatting * Completion suggestions for all Opcodes and Ids While the instructions here are specifically for Neovim, they should translate easily to vim. ## Dependencies In order to build and install the Visual Studio Code language server extension, you will need to install and have on your `PATH` the following dependencies: * [`golang 1.16+`](https://golang.org/) ## File type detection Neovim's default config location is typically `~/.config/nvim` so the rest of the instructions assume that but it will need to be changed if your system is different. Tell neovim that `*.spvasm` files should be treated as `spvasm` filetype ```bash echo "au BufRead,BufNewFile *.spvasm set filetype=spvasm" > ~/.config/nvim/ftdetect/spvasm.vim ``` ## Syntax Highlighting ### Generate the syntax highlighting file ```bash cd mkdir -p build && cd build # Any platform is fine, ninja is used an as example cmake -G Ninja .. ninja spirv-tools-vimsyntax ``` ### Copy the syntax file ```bash cp spvasm.vim ~/.config/nvim/syntax/spvasm.vim ``` ## Language Server ### Building the LSP (masOS / Linux) Run `build_lsp.sh` Copy `spirvls` and `spirv.json` to a location in `$PATH` ```bash cd /utils/vscode ./build_lsp.sh sudo cp spirvls/* /usr/local/bin/ ``` ### Building the LSP (Windows) TODO ### Configuring Neovim Configuration will depend a lot on your installed plugins but assuming you are using [nvim-lspconfig](https://github.com/neovim/nvim-lspconfig) the following should be sufficient. ```lua local lspconfig = require 'lspconfig' local configs = require 'lspconfig.configs' if not configs.spvasm then configs.spvasm = { default_config = { cmd = { 'spirvls' }, filetypes = { 'spvasm' }, root_dir = function(fname) return '.' end, settings = {}, }, } end lspconfig.spvasm.setup { capabilities = require('cmp_nvim_lsp').default_capabilities(vim.lsp.protocol.make_client_capabilities()), } ``` KhronosGroup-SPIRV-Tools-f289d04/utils/vim/generate_syntax.py000077500000000000000000000164751475742701700242560ustar00rootroot00000000000000#!/usr/bin/env python3 # Copyright (c) 2016 Google Inc. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Generates Vim syntax rules for SPIR-V assembly (.spvasm) files""" import json PREAMBLE="""" Vim syntax file " Language: spvasm " Generated by SPIRV-Tools if version < 600 syntax clear elseif exists("b:current_syntax") finish endif syn case match """ POSTAMBLE=""" syntax keyword spvasmTodo TODO FIXME contained syn match spvasmIdNumber /%\d\+\>/ " The assembler treats the leading minus sign as part of the number token. " This applies to integers, and to floats below. syn match spvasmNumber /-\?\<\d\+\>/ " Floating point literals. " In general, C++ requires at least digit in the mantissa, and the " floating point is optional. This applies to both the regular decimal float " case and the hex float case. " First case: digits before the optional decimal, no trailing digits. syn match spvasmFloat /-\?\d\+\.\?\(e[+-]\d\+\)\?/ " Second case: optional digits before decimal, trailing digits syn match spvasmFloat /-\?\d*\.\d\+\(e[+-]\d\+\)\?/ " First case: hex digits before the optional decimal, no trailing hex digits. syn match spvasmFloat /-\?0[xX]\\x\+\.\?p[-+]\d\+/ " Second case: optional hex digits before decimal, trailing hex digits syn match spvasmFloat /-\?0[xX]\\x*\.\\x\+p[-+]\d\+/ syn match spvasmComment /;.*$/ contains=spvasmTodo syn region spvasmString start=/"/ skip=/\\\\"/ end=/"/ syn match spvasmId /%[a-zA-Z_][a-zA-Z_0-9]*/ " Highlight unknown constants and statements as errors syn match spvasmError /[a-zA-Z][a-zA-Z_0-9]*/ if version >= 508 || !exists("did_c_syn_inits") if version < 508 let did_c_syn_inits = 1 command -nargs=+ HiLink hi link else command -nargs=+ HiLink hi def link endif HiLink spvasmStatement Statement HiLink spvasmNumber Number HiLink spvasmComment Comment HiLink spvasmString String HiLink spvasmFloat Float HiLink spvasmConstant Constant HiLink spvasmIdNumber Identifier HiLink spvasmId Identifier HiLink spvasmTodo Todo delcommand HiLink endif let b:current_syntax = "spvasm" """ # This list is taken from the description of OpSpecConstantOp in SPIR-V 1.1. # TODO(dneto): Propose that this information be embedded in the grammar file. SPEC_CONSTANT_OP_OPCODES = """ OpSConvert, OpFConvert OpSNegate, OpNot OpIAdd, OpISub OpIMul, OpUDiv, OpSDiv, OpUMod, OpSRem, OpSMod OpShiftRightLogical, OpShiftRightArithmetic, OpShiftLeftLogical OpBitwiseOr, OpBitwiseXor, OpBitwiseAnd OpVectorShuffle, OpCompositeExtract, OpCompositeInsert OpLogicalOr, OpLogicalAnd, OpLogicalNot, OpLogicalEqual, OpLogicalNotEqual OpSelect OpIEqual, OpINotEqual OpULessThan, OpSLessThan OpUGreaterThan, OpSGreaterThan OpULessThanEqual, OpSLessThanEqual OpUGreaterThanEqual, OpSGreaterThanEqual OpQuantizeToF16 OpConvertFToS, OpConvertSToF OpConvertFToU, OpConvertUToF OpUConvert OpConvertPtrToU, OpConvertUToPtr OpGenericCastToPtr, OpPtrCastToGeneric OpBitcast OpFNegate OpFAdd, OpFSub OpFMul, OpFDiv OpFRem, OpFMod OpAccessChain, OpInBoundsAccessChain OpPtrAccessChain, OpInBoundsPtrAccessChain""" def EmitAsStatement(name): """Emits the given name as a statement token""" print('syn keyword spvasmStatement', name) def EmitAsEnumerant(name): """Emits the given name as an named operand token""" print('syn keyword spvasmConstant', name) def main(): """Parses arguments, then generates the Vim syntax rules for SPIR-V assembly on stdout.""" import argparse parser = argparse.ArgumentParser(description='Generate SPIR-V info tables') parser.add_argument('--spirv-core-grammar', metavar='', type=str, required=True, help='input JSON grammar file for core SPIR-V ' 'instructions') parser.add_argument('--extinst-glsl-grammar', metavar='', type=str, required=False, default=None, help='input JSON grammar file for GLSL extended ' 'instruction set') parser.add_argument('--extinst-opencl-grammar', metavar='', type=str, required=False, default=None, help='input JSON grammar file for OpenGL extended ' 'instruction set') parser.add_argument('--extinst-debuginfo-grammar', metavar='', type=str, required=False, default=None, help='input JSON grammar file for DebugInfo extended ' 'instruction set') args = parser.parse_args() # Generate the syntax rules. print(PREAMBLE) core = json.loads(open(args.spirv_core_grammar).read()) print('\n" Core instructions') for inst in core["instructions"]: EmitAsStatement(inst['opname']) aliases = inst.get('aliases', []) for alias in aliases: EmitAsStatement(alias) print('\n" Core operand enums') for operand_kind in core["operand_kinds"]: if 'enumerants' in operand_kind: for e in operand_kind['enumerants']: EmitAsEnumerant(e['enumerant']) aliases = e.get('aliases', []) for a in aliases: EmitAsEnumerant(a) if args.extinst_glsl_grammar is not None: print('\n" GLSL.std.450 extended instructions') glsl = json.loads(open(args.extinst_glsl_grammar).read()) # These opcodes are really enumerant operands for the OpExtInst # instruction. for inst in glsl["instructions"]: EmitAsEnumerant(inst['opname']) if args.extinst_opencl_grammar is not None: print('\n" OpenCL.std extended instructions') opencl = json.loads(open(args.extinst_opencl_grammar).read()) for inst in opencl["instructions"]: EmitAsEnumerant(inst['opname']) if args.extinst_debuginfo_grammar is not None: print('\n" DebugInfo extended instructions') debuginfo = json.loads(open(args.extinst_debuginfo_grammar).read()) for inst in debuginfo["instructions"]: EmitAsEnumerant(inst['opname']) print('\n" DebugInfo operand enums') for operand_kind in debuginfo["operand_kinds"]: if 'enumerants' in operand_kind: for e in operand_kind['enumerants']: EmitAsEnumerant(e['enumerant']) print('\n" OpSpecConstantOp opcodes') for word in SPEC_CONSTANT_OP_OPCODES.split(' '): stripped = word.strip('\n,') if stripped != "": # Treat as an enumerant, but without the leading "Op" EmitAsEnumerant(stripped[2:]) print(POSTAMBLE) if __name__ == '__main__': main() KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/000077500000000000000000000000001475742701700211545ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/.gitignore000066400000000000000000000000071475742701700231410ustar00rootroot00000000000000cache/ KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/README.md000066400000000000000000000013211475742701700224300ustar00rootroot00000000000000# Visual Studio Code extension for SPIR-V disassembly files This directory holds a Visual Studio Code language server extension for SPIR-V assembly files (`.spvasm`) The extension supports: * Syntax highlighting * Jump to definition * Find all references * Symbol renaming * Operand hover information * Formatting * Completion suggestions for all Opcodes and Ids ## Dependencies In order to build and install the Visual Studio Code language server extension, you will need to install and have on your `PATH` the following dependencies: * [`npm`](https://www.npmjs.com/) * [`golang 1.16+`](https://golang.org/) ## Installing (macOS / Linux) Run `install_vscode.sh` ## Installing (Windows) Run `install_vscode.bat` KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/build_lsp.sh000077500000000000000000000020461475742701700234720ustar00rootroot00000000000000#!/usr/bin/env bash # Copyright (c) 2019 Google Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. set -e # Fail on any error. ROOT_PATH="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )" pushd ${ROOT_PATH} go run ./src/tools/gen-grammar.go --cache ./cache --template ./spirv.json.tmpl --out ./spirv.json go run ./src/tools/gen-grammar.go --cache ./cache --template ./src/schema/schema.go.tmpl --out ./src/schema/schema.go mkdir -p ./spirvls cp ./spirv.json ./spirvls go build -o ./spirvls/spirvls ./src/langsvr.go popd KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/extension.js000066400000000000000000000046731475742701700235400ustar00rootroot00000000000000/* * Copyright (C) 2019 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ var path = require('path'); var vscode = require('vscode'); var langClient = require('vscode-languageclient'); var LanguageClient = langClient.LanguageClient; // this method is called when your extension is activated // your extension is activated the very first time the command is executed function activate(context) { let serverModule = path.join(context.extensionPath, 'langsvr'); let debugOptions = {}; // If the extension is launched in debug mode then the debug server options are used // Otherwise the run options are used let serverOptions = { run: { command: serverModule, transport: langClient.stdio }, debug: { command: serverModule, transport: langClient.stdio, options: debugOptions } } // Options to control the language client let clientOptions = { documentSelector: ['spirv'], synchronize: { // Synchronize the setting section 'spirv' to the server configurationSection: 'spirv', // Notify the server about file changes to .spvasm files contained in the workspace fileEvents: vscode.workspace.createFileSystemWatcher('**/*.spvasm') } } // Create the language client and start the client. let disposable = new LanguageClient('spirv', serverOptions, clientOptions).start(); // Push the disposable to the context's subscriptions so that the // client can be deactivated on extension deactivation context.subscriptions.push(disposable); // Set the language configuration here instead of a language configuration // file to work around https://github.com/microsoft/vscode/issues/42649. vscode.languages.setLanguageConfiguration("spirv", { comments: { "lineComment": ";" }, wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g, }); } exports.activate = activate; // this method is called when your extension is deactivated function deactivate() { } exports.deactivate = deactivate; KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/go.mod000066400000000000000000000002451475742701700222630ustar00rootroot00000000000000module github.com/KhronosGroup/SPIRV-Tools/utils/vscode go 1.16 require ( github.com/pkg/errors v0.9.1 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 ) KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/go.sum000066400000000000000000000005701475742701700223110ustar00rootroot00000000000000github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/install_vscode.bat000066400000000000000000000023741475742701700246630ustar00rootroot00000000000000@REM Copyright (c) 2019 Google Inc. @REM @REM Licensed under the Apache License, Version 2.0 (the "License"); @REM you may not use this file except in compliance with the License. @REM You may obtain a copy of the License at @REM @REM http://www.apache.org/licenses/LICENSE-2.0 @REM @REM Unless required by applicable law or agreed to in writing, software @REM distributed under the License is distributed on an "AS IS" BASIS, @REM WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. @REM See the License for the specific language governing permissions and @REM limitations under the License. @set EXT_PATH=%userprofile%\.vscode\extensions\google.spirvls-0.0.1 @set ROOT_PATH=%~dp0 go run %ROOT_PATH%\src\tools\gen-grammar.go --cache %ROOT_PATH%\cache --template %ROOT_PATH%\spirv.json.tmpl --out %ROOT_PATH%\spirv.json go run %ROOT_PATH%\src\tools\gen-grammar.go --cache %ROOT_PATH%\cache --template %ROOT_PATH%\src\schema\schema.go.tmpl --out %ROOT_PATH%\src\schema\schema.go if not exist %EXT_PATH% mkdir -p %EXT_PATH% copy %ROOT_PATH%\extension.js %EXT_PATH% copy %ROOT_PATH%\package.json %EXT_PATH% copy %ROOT_PATH%\spirv.json %EXT_PATH% go build -o %EXT_PATH%\langsvr.exe %ROOT_PATH%\src\langsvr.go @pushd %EXT_PATH% call npm install @popd KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/install_vscode.sh000077500000000000000000000022771475742701700245340ustar00rootroot00000000000000#!/usr/bin/env bash # Copyright (c) 2019 Google Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. set -e # Fail on any error. EXT_PATH=~/.vscode/extensions/google.spirvls-0.0.1 ROOT_PATH="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )" pushd ${ROOT_PATH} go run ./src/tools/gen-grammar.go --cache ./cache --template ./spirv.json.tmpl --out ./spirv.json go run ./src/tools/gen-grammar.go --cache ./cache --template ./src/schema/schema.go.tmpl --out ./src/schema/schema.go mkdir -p ${EXT_PATH} cp ./extension.js ${EXT_PATH} cp ./package.json ${EXT_PATH} cp ./spirv.json ${EXT_PATH} go build -o ${EXT_PATH}/langsvr ./src/langsvr.go popd cd ${EXT_PATH} npm install KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/package.json000066400000000000000000000015771475742701700234540ustar00rootroot00000000000000{ "name": "spirvls", "description": "Language support for SPIR-V disassembly files", "author": "Google", "license": "Apache-2.0", "version": "0.0.1", "private": true, "publisher": "Google", "engines": { "vscode": "^0.10.10" }, "categories": [ "Programming Languages" ], "contributes": { "languages": [ { "id": "spirv", "extensions": [ "spvasm" ] } ], "grammars": [ { "language": "spirv", "scopeName": "source.spirv", "path": "spirv.json" } ] }, "dependencies": { "vscode-languageclient": "~4.3.0" }, "activationEvents": [ "*" ], "main": "./extension.js" } KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/spirv.json000066400000000000000000000677231475742701700232310ustar00rootroot00000000000000{ "scopeName": "source.spirv", "name": "SPIR-V", "comment": "Generated by gen-grammar.go --template=./spirv.json.tmpl --out=./spirv.json. Do not modify this file directly.", "patterns": [ { "include": "#BitEnum_ImageOperands" }, { "include": "#BitEnum_FPFastMathMode" }, { "include": "#BitEnum_SelectionControl" }, { "include": "#BitEnum_LoopControl" }, { "include": "#BitEnum_FunctionControl" }, { "include": "#BitEnum_MemorySemantics" }, { "include": "#BitEnum_MemoryAccess" }, { "include": "#BitEnum_KernelProfilingInfo" }, { "include": "#BitEnum_RayFlags" }, { "include": "#BitEnum_FragmentShadingRate" }, { "include": "#BitEnum_RawAccessChainOperands" }, { "include": "#ValueEnum_SourceLanguage" }, { "include": "#ValueEnum_ExecutionModel" }, { "include": "#ValueEnum_AddressingModel" }, { "include": "#ValueEnum_MemoryModel" }, { "include": "#ValueEnum_ExecutionMode" }, { "include": "#ValueEnum_StorageClass" }, { "include": "#ValueEnum_Dim" }, { "include": "#ValueEnum_SamplerAddressingMode" }, { "include": "#ValueEnum_SamplerFilterMode" }, { "include": "#ValueEnum_ImageFormat" }, { "include": "#ValueEnum_ImageChannelOrder" }, { "include": "#ValueEnum_ImageChannelDataType" }, { "include": "#ValueEnum_FPRoundingMode" }, { "include": "#ValueEnum_FPDenormMode" }, { "include": "#ValueEnum_QuantizationModes" }, { "include": "#ValueEnum_FPOperationMode" }, { "include": "#ValueEnum_OverflowModes" }, { "include": "#ValueEnum_LinkageType" }, { "include": "#ValueEnum_AccessQualifier" }, { "include": "#ValueEnum_HostAccessQualifier" }, { "include": "#ValueEnum_FunctionParameterAttribute" }, { "include": "#ValueEnum_Decoration" }, { "include": "#ValueEnum_BuiltIn" }, { "include": "#ValueEnum_Scope" }, { "include": "#ValueEnum_GroupOperation" }, { "include": "#ValueEnum_KernelEnqueueFlags" }, { "include": "#ValueEnum_Capability" }, { "include": "#ValueEnum_RayQueryIntersection" }, { "include": "#ValueEnum_RayQueryCommittedIntersectionType" }, { "include": "#ValueEnum_RayQueryCandidateIntersectionType" }, { "include": "#ValueEnum_PackedVectorFormat" }, { "include": "#BitEnum_CooperativeMatrixOperands" }, { "include": "#ValueEnum_CooperativeMatrixLayout" }, { "include": "#ValueEnum_CooperativeMatrixUse" }, { "include": "#BitEnum_CooperativeMatrixReduce" }, { "include": "#ValueEnum_TensorClampMode" }, { "include": "#BitEnum_TensorAddressingOperands" }, { "include": "#ValueEnum_InitializationModeQualifier" }, { "include": "#ValueEnum_LoadCacheControl" }, { "include": "#ValueEnum_StoreCacheControl" }, { "include": "#ValueEnum_NamedMaximumNumberOfRegisters" }, { "include": "#BitEnum_DebugInfoFlags" }, { "include": "#ValueEnum_DebugBaseTypeAttributeEncoding" }, { "include": "#ValueEnum_DebugCompositeType" }, { "include": "#ValueEnum_DebugTypeQualifier" }, { "include": "#ValueEnum_DebugOperation" }, { "include": "#ValueEnum_DebugImportedEntity" }, { "include": "#opcode" }, { "include": "#extopcode" }, { "include": "#identifier" }, { "include": "#number" }, { "include": "#string" }, { "include": "#comment" }, { "include": "#operator" } ], "repository": { "BitEnum_ImageOperands": { "match": "\\b(None|Bias|Lod|Grad|ConstOffset|Offset|ConstOffsets|Sample|MinLod|MakeTexelAvailable|MakeTexelVisible|NonPrivateTexel|VolatileTexel|SignExtend|ZeroExtend|Nontemporal|Offsets)\\b", "name": "keyword.spirv" }, "BitEnum_FPFastMathMode": { "match": "\\b(None|NotNaN|NotInf|NSZ|AllowRecip|Fast|AllowContract|AllowReassoc|AllowTransform)\\b", "name": "keyword.spirv" }, "BitEnum_SelectionControl": { "match": "\\b(None|Flatten|DontFlatten)\\b", "name": "keyword.spirv" }, "BitEnum_LoopControl": { "match": "\\b(None|Unroll|DontUnroll|DependencyInfinite|DependencyLength|MinIterations|MaxIterations|IterationMultiple|PeelCount|PartialCount|InitiationIntervalINTEL|MaxConcurrencyINTEL|DependencyArrayINTEL|PipelineEnableINTEL|LoopCoalesceINTEL|MaxInterleavingINTEL|SpeculatedIterationsINTEL|NoFusionINTEL|LoopCountINTEL|MaxReinvocationDelayINTEL)\\b", "name": "keyword.spirv" }, "BitEnum_FunctionControl": { "match": "\\b(None|Inline|DontInline|Pure|Const|OptNoneEXT)\\b", "name": "keyword.spirv" }, "BitEnum_MemorySemantics": { "match": "\\b(Relaxed|Acquire|Release|AcquireRelease|SequentiallyConsistent|UniformMemory|SubgroupMemory|WorkgroupMemory|CrossWorkgroupMemory|AtomicCounterMemory|ImageMemory|OutputMemory|MakeAvailable|MakeVisible|Volatile)\\b", "name": "keyword.spirv" }, "BitEnum_MemoryAccess": { "match": "\\b(None|Volatile|Aligned|Nontemporal|MakePointerAvailable|MakePointerVisible|NonPrivatePointer|AliasScopeINTELMask|NoAliasINTELMask)\\b", "name": "keyword.spirv" }, "BitEnum_KernelProfilingInfo": { "match": "\\b(None|CmdExecTime)\\b", "name": "keyword.spirv" }, "BitEnum_RayFlags": { "match": "\\b(NoneKHR|OpaqueKHR|NoOpaqueKHR|TerminateOnFirstHitKHR|SkipClosestHitShaderKHR|CullBackFacingTrianglesKHR|CullFrontFacingTrianglesKHR|CullOpaqueKHR|CullNoOpaqueKHR|SkipTrianglesKHR|SkipAABBsKHR|ForceOpacityMicromap2StateEXT)\\b", "name": "keyword.spirv" }, "BitEnum_FragmentShadingRate": { "match": "\\b(Vertical2Pixels|Vertical4Pixels|Horizontal2Pixels|Horizontal4Pixels)\\b", "name": "keyword.spirv" }, "BitEnum_RawAccessChainOperands": { "match": "\\b(None|RobustnessPerComponentNV|RobustnessPerElementNV)\\b", "name": "keyword.spirv" }, "ValueEnum_SourceLanguage": { "match": "\\b(Unknown|ESSL|GLSL|OpenCL_C|OpenCL_CPP|HLSL|CPP_for_OpenCL|SYCL|HERO_C|NZSL|WGSL|Slang|Zig)\\b", "name": "keyword.spirv" }, "ValueEnum_ExecutionModel": { "match": "\\b(Vertex|TessellationControl|TessellationEvaluation|Geometry|Fragment|GLCompute|Kernel|TaskNV|MeshNV|RayGenerationKHR|IntersectionKHR|AnyHitKHR|ClosestHitKHR|MissKHR|CallableKHR|TaskEXT|MeshEXT)\\b", "name": "keyword.spirv" }, "ValueEnum_AddressingModel": { "match": "\\b(Logical|Physical32|Physical64|PhysicalStorageBuffer64)\\b", "name": "keyword.spirv" }, "ValueEnum_MemoryModel": { "match": "\\b(Simple|GLSL450|OpenCL|Vulkan)\\b", "name": "keyword.spirv" }, "ValueEnum_ExecutionMode": { "match": "\\b(Invocations|SpacingEqual|SpacingFractionalEven|SpacingFractionalOdd|VertexOrderCw|VertexOrderCcw|PixelCenterInteger|OriginUpperLeft|OriginLowerLeft|EarlyFragmentTests|PointMode|Xfb|DepthReplacing|DepthGreater|DepthLess|DepthUnchanged|LocalSize|LocalSizeHint|InputPoints|InputLines|InputLinesAdjacency|Triangles|InputTrianglesAdjacency|Quads|Isolines|OutputVertices|OutputPoints|OutputLineStrip|OutputTriangleStrip|VecTypeHint|ContractionOff|Initializer|Finalizer|SubgroupSize|SubgroupsPerWorkgroup|SubgroupsPerWorkgroupId|LocalSizeId|LocalSizeHintId|NonCoherentColorAttachmentReadEXT|NonCoherentDepthAttachmentReadEXT|NonCoherentStencilAttachmentReadEXT|SubgroupUniformControlFlowKHR|PostDepthCoverage|DenormPreserve|DenormFlushToZero|SignedZeroInfNanPreserve|RoundingModeRTE|RoundingModeRTZ|EarlyAndLateFragmentTestsAMD|StencilRefReplacingEXT|CoalescingAMDX|IsApiEntryAMDX|MaxNodeRecursionAMDX|StaticNumWorkgroupsAMDX|ShaderIndexAMDX|MaxNumWorkgroupsAMDX|StencilRefUnchangedFrontAMD|StencilRefGreaterFrontAMD|StencilRefLessFrontAMD|StencilRefUnchangedBackAMD|StencilRefGreaterBackAMD|StencilRefLessBackAMD|QuadDerivativesKHR|RequireFullQuadsKHR|SharesInputWithAMDX|OutputLinesEXT|OutputPrimitivesEXT|DerivativeGroupQuadsKHR|DerivativeGroupLinearKHR|OutputTrianglesEXT|PixelInterlockOrderedEXT|PixelInterlockUnorderedEXT|SampleInterlockOrderedEXT|SampleInterlockUnorderedEXT|ShadingRateInterlockOrderedEXT|ShadingRateInterlockUnorderedEXT|SharedLocalMemorySizeINTEL|RoundingModeRTPINTEL|RoundingModeRTNINTEL|FloatingPointModeALTINTEL|FloatingPointModeIEEEINTEL|MaxWorkgroupSizeINTEL|MaxWorkDimINTEL|NoGlobalOffsetINTEL|NumSIMDWorkitemsINTEL|SchedulerTargetFmaxMhzINTEL|MaximallyReconvergesKHR|FPFastMathDefault|StreamingInterfaceINTEL|RegisterMapInterfaceINTEL|NamedBarrierCountINTEL|MaximumRegistersINTEL|MaximumRegistersIdINTEL|NamedMaximumRegistersINTEL)\\b", "name": "keyword.spirv" }, "ValueEnum_StorageClass": { "match": "\\b(UniformConstant|Input|Uniform|Output|Workgroup|CrossWorkgroup|Private|Function|Generic|PushConstant|AtomicCounter|Image|StorageBuffer|TileImageEXT|NodePayloadAMDX|CallableDataKHR|IncomingCallableDataKHR|RayPayloadKHR|HitAttributeKHR|IncomingRayPayloadKHR|ShaderRecordBufferKHR|PhysicalStorageBuffer|HitObjectAttributeNV|TaskPayloadWorkgroupEXT|CodeSectionINTEL|DeviceOnlyINTEL|HostOnlyINTEL)\\b", "name": "keyword.spirv" }, "ValueEnum_Dim": { "match": "\\b(1D|2D|3D|Cube|Rect|Buffer|SubpassData|TileImageDataEXT)\\b", "name": "keyword.spirv" }, "ValueEnum_SamplerAddressingMode": { "match": "\\b(None|ClampToEdge|Clamp|Repeat|RepeatMirrored)\\b", "name": "keyword.spirv" }, "ValueEnum_SamplerFilterMode": { "match": "\\b(Nearest|Linear)\\b", "name": "keyword.spirv" }, "ValueEnum_ImageFormat": { "match": "\\b(Unknown|Rgba32f|Rgba16f|R32f|Rgba8|Rgba8Snorm|Rg32f|Rg16f|R11fG11fB10f|R16f|Rgba16|Rgb10A2|Rg16|Rg8|R16|R8|Rgba16Snorm|Rg16Snorm|Rg8Snorm|R16Snorm|R8Snorm|Rgba32i|Rgba16i|Rgba8i|R32i|Rg32i|Rg16i|Rg8i|R16i|R8i|Rgba32ui|Rgba16ui|Rgba8ui|R32ui|Rgb10a2ui|Rg32ui|Rg16ui|Rg8ui|R16ui|R8ui|R64ui|R64i)\\b", "name": "keyword.spirv" }, "ValueEnum_ImageChannelOrder": { "match": "\\b(R|A|RG|RA|RGB|RGBA|BGRA|ARGB|Intensity|Luminance|Rx|RGx|RGBx|Depth|DepthStencil|sRGB|sRGBx|sRGBA|sBGRA|ABGR)\\b", "name": "keyword.spirv" }, "ValueEnum_ImageChannelDataType": { "match": "\\b(SnormInt8|SnormInt16|UnormInt8|UnormInt16|UnormShort565|UnormShort555|UnormInt101010|SignedInt8|SignedInt16|SignedInt32|UnsignedInt8|UnsignedInt16|UnsignedInt32|HalfFloat|Float|UnormInt24|UnormInt101010_2|UnsignedIntRaw10EXT|UnsignedIntRaw12EXT|UnormInt2_101010EXT)\\b", "name": "keyword.spirv" }, "ValueEnum_FPRoundingMode": { "match": "\\b(RTE|RTZ|RTP|RTN)\\b", "name": "keyword.spirv" }, "ValueEnum_FPDenormMode": { "match": "\\b(Preserve|FlushToZero)\\b", "name": "keyword.spirv" }, "ValueEnum_QuantizationModes": { "match": "\\b(TRN|TRN_ZERO|RND|RND_ZERO|RND_INF|RND_MIN_INF|RND_CONV|RND_CONV_ODD)\\b", "name": "keyword.spirv" }, "ValueEnum_FPOperationMode": { "match": "\\b(IEEE|ALT)\\b", "name": "keyword.spirv" }, "ValueEnum_OverflowModes": { "match": "\\b(WRAP|SAT|SAT_ZERO|SAT_SYM)\\b", "name": "keyword.spirv" }, "ValueEnum_LinkageType": { "match": "\\b(Export|Import|LinkOnceODR)\\b", "name": "keyword.spirv" }, "ValueEnum_AccessQualifier": { "match": "\\b(ReadOnly|WriteOnly|ReadWrite)\\b", "name": "keyword.spirv" }, "ValueEnum_HostAccessQualifier": { "match": "\\b(NoneINTEL|ReadINTEL|WriteINTEL|ReadWriteINTEL)\\b", "name": "keyword.spirv" }, "ValueEnum_FunctionParameterAttribute": { "match": "\\b(Zext|Sext|ByVal|Sret|NoAlias|NoCapture|NoWrite|NoReadWrite|RuntimeAlignedINTEL)\\b", "name": "keyword.spirv" }, "ValueEnum_Decoration": { "match": "\\b(RelaxedPrecision|SpecId|Block|BufferBlock|RowMajor|ColMajor|ArrayStride|MatrixStride|GLSLShared|GLSLPacked|CPacked|BuiltIn|NoPerspective|Flat|Patch|Centroid|Sample|Invariant|Restrict|Aliased|Volatile|Constant|Coherent|NonWritable|NonReadable|Uniform|UniformId|SaturatedConversion|Stream|Location|Component|Index|Binding|DescriptorSet|Offset|XfbBuffer|XfbStride|FuncParamAttr|FPRoundingMode|FPFastMathMode|LinkageAttributes|NoContraction|InputAttachmentIndex|Alignment|MaxByteOffset|AlignmentId|MaxByteOffsetId|NoSignedWrap|NoUnsignedWrap|WeightTextureQCOM|BlockMatchTextureQCOM|BlockMatchSamplerQCOM|ExplicitInterpAMD|NodeSharesPayloadLimitsWithAMDX|NodeMaxPayloadsAMDX|TrackFinishWritingAMDX|PayloadNodeNameAMDX|PayloadNodeBaseIndexAMDX|PayloadNodeSparseArrayAMDX|PayloadNodeArraySizeAMDX|PayloadDispatchIndirectAMDX|OverrideCoverageNV|PassthroughNV|ViewportRelativeNV|SecondaryViewportRelativeNV|PerPrimitiveEXT|PerViewNV|PerTaskNV|PerVertexKHR|NonUniform|RestrictPointer|AliasedPointer|HitObjectShaderRecordBufferNV|BindlessSamplerNV|BindlessImageNV|BoundSamplerNV|BoundImageNV|SIMTCallINTEL|ReferencedIndirectlyINTEL|ClobberINTEL|SideEffectsINTEL|VectorComputeVariableINTEL|FuncParamIOKindINTEL|VectorComputeFunctionINTEL|StackCallINTEL|GlobalVariableOffsetINTEL|CounterBuffer|UserSemantic|UserTypeGOOGLE|FunctionRoundingModeINTEL|FunctionDenormModeINTEL|RegisterINTEL|MemoryINTEL|NumbanksINTEL|BankwidthINTEL|MaxPrivateCopiesINTEL|SinglepumpINTEL|DoublepumpINTEL|MaxReplicatesINTEL|SimpleDualPortINTEL|MergeINTEL|BankBitsINTEL|ForcePow2DepthINTEL|StridesizeINTEL|WordsizeINTEL|TrueDualPortINTEL|BurstCoalesceINTEL|CacheSizeINTEL|DontStaticallyCoalesceINTEL|PrefetchINTEL|StallEnableINTEL|FuseLoopsInFunctionINTEL|MathOpDSPModeINTEL|AliasScopeINTEL|NoAliasINTEL|InitiationIntervalINTEL|MaxConcurrencyINTEL|PipelineEnableINTEL|BufferLocationINTEL|IOPipeStorageINTEL|FunctionFloatingPointModeINTEL|SingleElementVectorINTEL|VectorComputeCallableFunctionINTEL|MediaBlockIOINTEL|StallFreeINTEL|FPMaxErrorDecorationINTEL|LatencyControlLabelINTEL|LatencyControlConstraintINTEL|ConduitKernelArgumentINTEL|RegisterMapKernelArgumentINTEL|MMHostInterfaceAddressWidthINTEL|MMHostInterfaceDataWidthINTEL|MMHostInterfaceLatencyINTEL|MMHostInterfaceReadWriteModeINTEL|MMHostInterfaceMaxBurstINTEL|MMHostInterfaceWaitRequestINTEL|StableKernelArgumentINTEL|HostAccessINTEL|InitModeINTEL|ImplementInRegisterMapINTEL|CacheControlLoadINTEL|CacheControlStoreINTEL)\\b", "name": "keyword.spirv" }, "ValueEnum_BuiltIn": { "match": "\\b(Position|PointSize|ClipDistance|CullDistance|VertexId|InstanceId|PrimitiveId|InvocationId|Layer|ViewportIndex|TessLevelOuter|TessLevelInner|TessCoord|PatchVertices|FragCoord|PointCoord|FrontFacing|SampleId|SamplePosition|SampleMask|FragDepth|HelperInvocation|NumWorkgroups|WorkgroupSize|WorkgroupId|LocalInvocationId|GlobalInvocationId|LocalInvocationIndex|WorkDim|GlobalSize|EnqueuedWorkgroupSize|GlobalOffset|GlobalLinearId|SubgroupSize|SubgroupMaxSize|NumSubgroups|NumEnqueuedSubgroups|SubgroupId|SubgroupLocalInvocationId|VertexIndex|InstanceIndex|CoreIDARM|CoreCountARM|CoreMaxIDARM|WarpIDARM|WarpMaxIDARM|SubgroupEqMask|SubgroupGeMask|SubgroupGtMask|SubgroupLeMask|SubgroupLtMask|BaseVertex|BaseInstance|DrawIndex|PrimitiveShadingRateKHR|DeviceIndex|ViewIndex|ShadingRateKHR|BaryCoordNoPerspAMD|BaryCoordNoPerspCentroidAMD|BaryCoordNoPerspSampleAMD|BaryCoordSmoothAMD|BaryCoordSmoothCentroidAMD|BaryCoordSmoothSampleAMD|BaryCoordPullModelAMD|FragStencilRefEXT|RemainingRecursionLevelsAMDX|ShaderIndexAMDX|ViewportMaskNV|SecondaryPositionNV|SecondaryViewportMaskNV|PositionPerViewNV|ViewportMaskPerViewNV|FullyCoveredEXT|TaskCountNV|PrimitiveCountNV|PrimitiveIndicesNV|ClipDistancePerViewNV|CullDistancePerViewNV|LayerPerViewNV|MeshViewCountNV|MeshViewIndicesNV|BaryCoordKHR|BaryCoordNoPerspKHR|FragSizeEXT|FragInvocationCountEXT|PrimitivePointIndicesEXT|PrimitiveLineIndicesEXT|PrimitiveTriangleIndicesEXT|CullPrimitiveEXT|LaunchIdKHR|LaunchSizeKHR|WorldRayOriginKHR|WorldRayDirectionKHR|ObjectRayOriginKHR|ObjectRayDirectionKHR|RayTminKHR|RayTmaxKHR|InstanceCustomIndexKHR|ObjectToWorldKHR|WorldToObjectKHR|HitTNV|HitKindKHR|CurrentRayTimeNV|HitTriangleVertexPositionsKHR|HitMicroTriangleVertexPositionsNV|HitMicroTriangleVertexBarycentricsNV|IncomingRayFlagsKHR|RayGeometryIndexKHR|WarpsPerSMNV|SMCountNV|WarpIDNV|SMIDNV|HitKindFrontFacingMicroTriangleNV|HitKindBackFacingMicroTriangleNV|CullMaskKHR)\\b", "name": "keyword.spirv" }, "ValueEnum_Scope": { "match": "\\b(CrossDevice|Device|Workgroup|Subgroup|Invocation|QueueFamily|ShaderCallKHR)\\b", "name": "keyword.spirv" }, "ValueEnum_GroupOperation": { "match": "\\b(Reduce|InclusiveScan|ExclusiveScan|ClusteredReduce|PartitionedReduceNV|PartitionedInclusiveScanNV|PartitionedExclusiveScanNV)\\b", "name": "keyword.spirv" }, "ValueEnum_KernelEnqueueFlags": { "match": "\\b(NoWait|WaitKernel|WaitWorkGroup)\\b", "name": "keyword.spirv" }, "ValueEnum_Capability": { "match": "\\b(Matrix|Shader|Geometry|Tessellation|Addresses|Linkage|Kernel|Vector16|Float16Buffer|Float16|Float64|Int64|Int64Atomics|ImageBasic|ImageReadWrite|ImageMipmap|Pipes|Groups|DeviceEnqueue|LiteralSampler|AtomicStorage|Int16|TessellationPointSize|GeometryPointSize|ImageGatherExtended|StorageImageMultisample|UniformBufferArrayDynamicIndexing|SampledImageArrayDynamicIndexing|StorageBufferArrayDynamicIndexing|StorageImageArrayDynamicIndexing|ClipDistance|CullDistance|ImageCubeArray|SampleRateShading|ImageRect|SampledRect|GenericPointer|Int8|InputAttachment|SparseResidency|MinLod|Sampled1D|Image1D|SampledCubeArray|SampledBuffer|ImageBuffer|ImageMSArray|StorageImageExtendedFormats|ImageQuery|DerivativeControl|InterpolationFunction|TransformFeedback|GeometryStreams|StorageImageReadWithoutFormat|StorageImageWriteWithoutFormat|MultiViewport|SubgroupDispatch|NamedBarrier|PipeStorage|GroupNonUniform|GroupNonUniformVote|GroupNonUniformArithmetic|GroupNonUniformBallot|GroupNonUniformShuffle|GroupNonUniformShuffleRelative|GroupNonUniformClustered|GroupNonUniformQuad|ShaderLayer|ShaderViewportIndex|UniformDecoration|CoreBuiltinsARM|TileImageColorReadAccessEXT|TileImageDepthReadAccessEXT|TileImageStencilReadAccessEXT|CooperativeMatrixLayoutsARM|FragmentShadingRateKHR|SubgroupBallotKHR|DrawParameters|WorkgroupMemoryExplicitLayoutKHR|WorkgroupMemoryExplicitLayout8BitAccessKHR|WorkgroupMemoryExplicitLayout16BitAccessKHR|SubgroupVoteKHR|StorageBuffer16BitAccess|UniformAndStorageBuffer16BitAccess|StoragePushConstant16|StorageInputOutput16|DeviceGroup|MultiView|VariablePointersStorageBuffer|VariablePointers|AtomicStorageOps|SampleMaskPostDepthCoverage|StorageBuffer8BitAccess|UniformAndStorageBuffer8BitAccess|StoragePushConstant8|DenormPreserve|DenormFlushToZero|SignedZeroInfNanPreserve|RoundingModeRTE|RoundingModeRTZ|RayQueryProvisionalKHR|RayQueryKHR|UntypedPointersKHR|RayTraversalPrimitiveCullingKHR|RayTracingKHR|TextureSampleWeightedQCOM|TextureBoxFilterQCOM|TextureBlockMatchQCOM|TextureBlockMatch2QCOM|Float16ImageAMD|ImageGatherBiasLodAMD|FragmentMaskAMD|StencilExportEXT|ImageReadWriteLodAMD|Int64ImageEXT|ShaderClockKHR|ShaderEnqueueAMDX|QuadControlKHR|SampleMaskOverrideCoverageNV|GeometryShaderPassthroughNV|ShaderViewportIndexLayerEXT|ShaderViewportMaskNV|ShaderStereoViewNV|PerViewAttributesNV|FragmentFullyCoveredEXT|MeshShadingNV|ImageFootprintNV|MeshShadingEXT|FragmentBarycentricKHR|ComputeDerivativeGroupQuadsKHR|FragmentDensityEXT|GroupNonUniformPartitionedNV|ShaderNonUniform|RuntimeDescriptorArray|InputAttachmentArrayDynamicIndexing|UniformTexelBufferArrayDynamicIndexing|StorageTexelBufferArrayDynamicIndexing|UniformBufferArrayNonUniformIndexing|SampledImageArrayNonUniformIndexing|StorageBufferArrayNonUniformIndexing|StorageImageArrayNonUniformIndexing|InputAttachmentArrayNonUniformIndexing|UniformTexelBufferArrayNonUniformIndexing|StorageTexelBufferArrayNonUniformIndexing|RayTracingPositionFetchKHR|RayTracingNV|RayTracingMotionBlurNV|VulkanMemoryModel|VulkanMemoryModelDeviceScope|PhysicalStorageBufferAddresses|ComputeDerivativeGroupLinearKHR|RayTracingProvisionalKHR|CooperativeMatrixNV|FragmentShaderSampleInterlockEXT|FragmentShaderShadingRateInterlockEXT|ShaderSMBuiltinsNV|FragmentShaderPixelInterlockEXT|DemoteToHelperInvocation|DisplacementMicromapNV|RayTracingOpacityMicromapEXT|ShaderInvocationReorderNV|BindlessTextureNV|RayQueryPositionFetchKHR|AtomicFloat16VectorNV|RayTracingDisplacementMicromapNV|RawAccessChainsNV|CooperativeMatrixReductionsNV|CooperativeMatrixConversionsNV|CooperativeMatrixPerElementOperationsNV|CooperativeMatrixTensorAddressingNV|CooperativeMatrixBlockLoadsNV|TensorAddressingNV|SubgroupShuffleINTEL|SubgroupBufferBlockIOINTEL|SubgroupImageBlockIOINTEL|SubgroupImageMediaBlockIOINTEL|RoundToInfinityINTEL|FloatingPointModeINTEL|IntegerFunctions2INTEL|FunctionPointersINTEL|IndirectReferencesINTEL|AsmINTEL|AtomicFloat32MinMaxEXT|AtomicFloat64MinMaxEXT|AtomicFloat16MinMaxEXT|VectorComputeINTEL|VectorAnyINTEL|ExpectAssumeKHR|SubgroupAvcMotionEstimationINTEL|SubgroupAvcMotionEstimationIntraINTEL|SubgroupAvcMotionEstimationChromaINTEL|VariableLengthArrayINTEL|FunctionFloatControlINTEL|FPGAMemoryAttributesINTEL|FPFastMathModeINTEL|ArbitraryPrecisionIntegersINTEL|ArbitraryPrecisionFloatingPointINTEL|UnstructuredLoopControlsINTEL|FPGALoopControlsINTEL|KernelAttributesINTEL|FPGAKernelAttributesINTEL|FPGAMemoryAccessesINTEL|FPGAClusterAttributesINTEL|LoopFuseINTEL|FPGADSPControlINTEL|MemoryAccessAliasingINTEL|FPGAInvocationPipeliningAttributesINTEL|FPGABufferLocationINTEL|ArbitraryPrecisionFixedPointINTEL|USMStorageClassesINTEL|RuntimeAlignedAttributeINTEL|IOPipesINTEL|BlockingPipesINTEL|FPGARegINTEL|DotProductInputAll|DotProductInput4x8Bit|DotProductInput4x8BitPacked|DotProduct|RayCullMaskKHR|CooperativeMatrixKHR|ReplicatedCompositesEXT|BitInstructions|GroupNonUniformRotateKHR|FloatControls2|AtomicFloat32AddEXT|AtomicFloat64AddEXT|LongCompositesINTEL|OptNoneEXT|AtomicFloat16AddEXT|DebugInfoModuleINTEL|BFloat16ConversionINTEL|SplitBarrierINTEL|ArithmeticFenceEXT|FPGAClusterAttributesV2INTEL|FPGAKernelAttributesv2INTEL|FPMaxErrorINTEL|FPGALatencyControlINTEL|FPGAArgumentInterfacesINTEL|GlobalVariableHostAccessINTEL|GlobalVariableFPGADecorationsINTEL|SubgroupBufferPrefetchINTEL|GroupUniformArithmeticKHR|MaskedGatherScatterINTEL|CacheControlsINTEL|RegisterLimitsINTEL)\\b", "name": "keyword.spirv" }, "ValueEnum_RayQueryIntersection": { "match": "\\b(RayQueryCandidateIntersectionKHR|RayQueryCommittedIntersectionKHR)\\b", "name": "keyword.spirv" }, "ValueEnum_RayQueryCommittedIntersectionType": { "match": "\\b(RayQueryCommittedIntersectionNoneKHR|RayQueryCommittedIntersectionTriangleKHR|RayQueryCommittedIntersectionGeneratedKHR)\\b", "name": "keyword.spirv" }, "ValueEnum_RayQueryCandidateIntersectionType": { "match": "\\b(RayQueryCandidateIntersectionTriangleKHR|RayQueryCandidateIntersectionAABBKHR)\\b", "name": "keyword.spirv" }, "ValueEnum_PackedVectorFormat": { "match": "\\b(PackedVectorFormat4x8Bit)\\b", "name": "keyword.spirv" }, "BitEnum_CooperativeMatrixOperands": { "match": "\\b(NoneKHR|MatrixASignedComponentsKHR|MatrixBSignedComponentsKHR|MatrixCSignedComponentsKHR|MatrixResultSignedComponentsKHR|SaturatingAccumulationKHR)\\b", "name": "keyword.spirv" }, "ValueEnum_CooperativeMatrixLayout": { "match": "\\b(RowMajorKHR|ColumnMajorKHR|RowBlockedInterleavedARM|ColumnBlockedInterleavedARM)\\b", "name": "keyword.spirv" }, "ValueEnum_CooperativeMatrixUse": { "match": "\\b(MatrixAKHR|MatrixBKHR|MatrixAccumulatorKHR)\\b", "name": "keyword.spirv" }, "BitEnum_CooperativeMatrixReduce": { "match": "\\b(Row|Column|2x2)\\b", "name": "keyword.spirv" }, "ValueEnum_TensorClampMode": { "match": "\\b(Undefined|Constant|ClampToEdge|Repeat|RepeatMirrored)\\b", "name": "keyword.spirv" }, "BitEnum_TensorAddressingOperands": { "match": "\\b(None|TensorView|DecodeFunc)\\b", "name": "keyword.spirv" }, "ValueEnum_InitializationModeQualifier": { "match": "\\b(InitOnDeviceReprogramINTEL|InitOnDeviceResetINTEL)\\b", "name": "keyword.spirv" }, "ValueEnum_LoadCacheControl": { "match": "\\b(UncachedINTEL|CachedINTEL|StreamingINTEL|InvalidateAfterReadINTEL|ConstCachedINTEL)\\b", "name": "keyword.spirv" }, "ValueEnum_StoreCacheControl": { "match": "\\b(UncachedINTEL|WriteThroughINTEL|WriteBackINTEL|StreamingINTEL)\\b", "name": "keyword.spirv" }, "ValueEnum_NamedMaximumNumberOfRegisters": { "match": "\\b(AutoINTEL)\\b", "name": "keyword.spirv" }, "BitEnum_DebugInfoFlags": { "match": "\\b(None|FlagIsProtected|FlagIsPrivate|FlagIsPublic|FlagIsLocal|FlagIsDefinition|FlagFwdDecl|FlagArtificial|FlagExplicit|FlagPrototyped|FlagObjectPointer|FlagStaticMember|FlagIndirectVariable|FlagLValueReference|FlagRValueReference|FlagIsOptimized|FlagIsEnumClass|FlagTypePassByValue|FlagTypePassByReference)\\b", "name": "keyword.spirv" }, "ValueEnum_DebugBaseTypeAttributeEncoding": { "match": "\\b(Unspecified|Address|Boolean|Float|Signed|SignedChar|Unsigned|UnsignedChar)\\b", "name": "keyword.spirv" }, "ValueEnum_DebugCompositeType": { "match": "\\b(Class|Structure|Union)\\b", "name": "keyword.spirv" }, "ValueEnum_DebugTypeQualifier": { "match": "\\b(ConstType|VolatileType|RestrictType|AtomicType)\\b", "name": "keyword.spirv" }, "ValueEnum_DebugOperation": { "match": "\\b(Deref|Plus|Minus|PlusUconst|BitPiece|Swap|Xderef|StackValue|Constu|Fragment)\\b", "name": "keyword.spirv" }, "ValueEnum_DebugImportedEntity": { "match": "\\b(ImportedModule|ImportedDeclaration)\\b", "name": "keyword.spirv" }, "opcode": { "match": "(Op[a-zA-Z]+)", "name": "entity.name.function.spirv" }, "extopcode": { "match": "(Round|RoundEven|Trunc|FAbs|SAbs|FSign|SSign|Floor|Ceil|Fract|Radians|Degrees|Sin|Cos|Tan|Asin|Acos|Atan|Sinh|Cosh|Tanh|Asinh|Acosh|Atanh|Atan2|Pow|Exp|Log|Exp2|Log2|Sqrt|InverseSqrt|Determinant|MatrixInverse|Modf|ModfStruct|FMin|UMin|SMin|FMax|UMax|SMax|FClamp|UClamp|SClamp|FMix|IMix|Step|SmoothStep|Fma|Frexp|FrexpStruct|Ldexp|PackSnorm4x8|PackUnorm4x8|PackSnorm2x16|PackUnorm2x16|PackHalf2x16|PackDouble2x32|UnpackSnorm2x16|UnpackUnorm2x16|UnpackHalf2x16|UnpackSnorm4x8|UnpackUnorm4x8|UnpackDouble2x32|Length|Distance|Cross|Normalize|FaceForward|Reflect|Refract|FindILsb|FindSMsb|FindUMsb|InterpolateAtCentroid|InterpolateAtSample|InterpolateAtOffset|NMin|NMax|NClamp|acos|acosh|acospi|asin|asinh|asinpi|atan|atan2|atanh|atanpi|atan2pi|cbrt|ceil|copysign|cos|cosh|cospi|erfc|erf|exp|exp2|exp10|expm1|fabs|fdim|floor|fma|fmax|fmin|fmod|fract|frexp|hypot|ilogb|ldexp|lgamma|lgamma_r|log|log2|log10|log1p|logb|mad|maxmag|minmag|modf|nan|nextafter|pow|pown|powr|remainder|remquo|rint|rootn|round|rsqrt|sin|sincos|sinh|sinpi|sqrt|tan|tanh|tanpi|tgamma|trunc|half_cos|half_divide|half_exp|half_exp2|half_exp10|half_log|half_log2|half_log10|half_powr|half_recip|half_rsqrt|half_sin|half_sqrt|half_tan|native_cos|native_divide|native_exp|native_exp2|native_exp10|native_log|native_log2|native_log10|native_powr|native_recip|native_rsqrt|native_sin|native_sqrt|native_tan|s_abs|s_abs_diff|s_add_sat|u_add_sat|s_hadd|u_hadd|s_rhadd|u_rhadd|s_clamp|u_clamp|clz|ctz|s_mad_hi|u_mad_sat|s_mad_sat|s_max|u_max|s_min|u_min|s_mul_hi|rotate|s_sub_sat|u_sub_sat|u_upsample|s_upsample|popcount|s_mad24|u_mad24|s_mul24|u_mul24|u_abs|u_abs_diff|u_mul_hi|u_mad_hi|fclamp|degrees|fmax_common|fmin_common|mix|radians|step|smoothstep|sign|cross|distance|length|normalize|fast_distance|fast_length|fast_normalize|bitselect|select|vloadn|vstoren|vload_half|vload_halfn|vstore_half|vstore_half_r|vstore_halfn|vstore_halfn_r|vloada_halfn|vstorea_halfn|vstorea_halfn_r|shuffle|shuffle2|printf|prefetch|DebugInfoNone|DebugCompilationUnit|DebugTypeBasic|DebugTypePointer|DebugTypeQualifier|DebugTypeArray|DebugTypeVector|DebugTypedef|DebugTypeFunction|DebugTypeEnum|DebugTypeComposite|DebugTypeMember|DebugTypeInheritance|DebugTypePtrToMember|DebugTypeTemplate|DebugTypeTemplateParameter|DebugTypeTemplateTemplateParameter|DebugTypeTemplateParameterPack|DebugGlobalVariable|DebugFunctionDeclaration|DebugFunction|DebugLexicalBlock|DebugLexicalBlockDiscriminator|DebugScope|DebugNoScope|DebugInlinedAt|DebugLocalVariable|DebugInlinedVariable|DebugDeclare|DebugValue|DebugOperation|DebugExpression|DebugMacroDef|DebugMacroUndef|DebugImportedEntity|DebugSource|DebugModuleINTEL)", "name": "entity.name.function.ext" }, "identifier": { "match": "%[a-zA-Z0-9_]+", "name": "variable.spirv" }, "number": { "match": "\\b[0-9]+.?[0-9]*\\b", "name": "constant.numeric.spirv" }, "comment": { "match": ";[^\n]*", "name": "comment.line.spirv" }, "operator": { "match": "=", "name": "keyword.operator.spirv" }, "string": { "begin": "\"", "beginCaptures": { "0": { "name": "punctuation.definition.string.begin.spirv" } }, "end": "\"", "endCaptures": { "0": { "name": "punctuation.definition.string.end.spirv" } }, "name": "string.quoted.double.spirv", "patterns": [ { "include": "#string_escaped_char" } ] }, "string_escaped_char": { "patterns": [ { "match": "\\\\([0-7]{3}|[abfnrtv\\\\'\"]|x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8})", "name": "constant.character.escape.spirv" }, { "match": "\\\\[^0-7xuUabfnrtv\\'\"]", "name": "invalid.illegal.unknown-escape.spirv" } ] } } } KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/spirv.json.tmpl000066400000000000000000000035011475742701700241640ustar00rootroot00000000000000{ "scopeName": "source.spirv", "name": "SPIR-V", "comment": "Generated by {{GenerateArguments}}. Do not modify this file directly.", "patterns": [ {{range $o := .All.OperandKinds}}{{if len $o.Enumerants}} { "include": "#{{$o.Category}}_{{$o.Kind}}" }, {{end}}{{end}} { "include": "#opcode" }, { "include": "#extopcode" }, { "include": "#identifier" }, { "include": "#number" }, { "include": "#string" }, { "include": "#comment" }, { "include": "#operator" } ], "repository": { {{range $o := .All.OperandKinds}}{{if len $o.Enumerants}} "{{$o.Category}}_{{$o.Kind}}": { "match": "\\b({{OperandKindsMatch $o}})\\b", "name": "keyword.spirv" },{{end}}{{end}} "opcode": { "match": "(Op[a-zA-Z]+)", "name": "entity.name.function.spirv" }, "extopcode": { "match": "({{AllExtOpcodes}})", "name": "entity.name.function.ext" }, "identifier": { "match": "%[a-zA-Z0-9_]+", "name": "variable.spirv" }, "number": { "match": "\\b[0-9]+.?[0-9]*\\b", "name": "constant.numeric.spirv" }, "comment": { "match": ";[^\n]*", "name": "comment.line.spirv" }, "operator": { "match": "=", "name": "keyword.operator.spirv" }, "string": { "begin": "\"", "beginCaptures": { "0": { "name": "punctuation.definition.string.begin.spirv" } }, "end": "\"", "endCaptures": { "0": { "name": "punctuation.definition.string.end.spirv" } }, "name": "string.quoted.double.spirv", "patterns": [ { "include": "#string_escaped_char" } ] }, "string_escaped_char": { "patterns": [ { "match": "\\\\([0-7]{3}|[abfnrtv\\\\'\"]|x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8})", "name": "constant.character.escape.spirv" }, { "match": "\\\\[^0-7xuUabfnrtv\\'\"]", "name": "invalid.illegal.unknown-escape.spirv" } ] } } } KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/src/000077500000000000000000000000001475742701700217435ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/src/grammar/000077500000000000000000000000001475742701700233715ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/src/grammar/grammar.go000066400000000000000000000053761475742701700253610ustar00rootroot00000000000000// Copyright (C) 2019 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Package grammar holds the JSON type definitions for the SPIR-V grammar schema. // // See https://www.khronos.org/registry/spir-v/specs/unified1/MachineReadableGrammar.html // for more information. package grammar // Root is the top-level structure of the JSON grammar. type Root struct { MagicNumber string `json:"magic_number"` MajorVersion int `json:"major_version"` MinorVersion int `json:"minor_version"` Revision int `json:"revision"` Instructions []Instruction `json:"instructions"` OperandKinds []OperandKind `json:"operand_kinds"` } // Instruction holds information about a specific SPIR-V instruction. type Instruction struct { Opname string `json:"opname"` Class string `json:"class"` Opcode int `json:"opcode"` Operands []Operand `json:"operands"` } // Operand contains information about a logical operand for an instruction. type Operand struct { Kind string `json:"kind"` Name string `json:"name"` Quantifier Quantifier `json:"quantifier"` } // OperandKind contains information about a specific operand kind. type OperandKind struct { Category string `json:"category"` Kind string `json:"kind"` Enumerants []Enumerant `json:"enumerants"` Bases []string `json:"bases"` } // Enumerant contains information about an enumerant in an enum. type Enumerant struct { Enumerant string `json:"enumerant"` Value interface{} `json:"value"` Capabilities []string `json:"capabilities"` Parameters []Parameter `json:"parameters"` Version string `json:"version"` } // Parameter contains information about a logical parameter for an enumerant. type Parameter struct { Kind string `json:"kind"` Name string `json:"name"` } // Quantifier indicates the number of times the quantified term may appear. type Quantifier string const ( // Once indicates the quantified term may appear exactly once. Once Quantifier = "" // ZeroOrOnce indicates the quantified term may appear zero or one // time; an optional term. ZeroOrOnce Quantifier = "?" // ZeroOrMany indicates the quantified term may appear any number of // times. ZeroOrMany Quantifier = "*" ) KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/src/langsvr.go000066400000000000000000000421411475742701700237500ustar00rootroot00000000000000// Copyright (C) 2019 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // langsvr implements a Language Server for the SPIRV assembly language. package main import ( "context" "fmt" "io" "log" "os" "path" "sort" "strings" "sync" "unicode/utf8" "github.com/KhronosGroup/SPIRV-Tools/utils/vscode/src/parser" "github.com/KhronosGroup/SPIRV-Tools/utils/vscode/src/schema" "github.com/KhronosGroup/SPIRV-Tools/utils/vscode/src/lsp/jsonrpc2" lsp "github.com/KhronosGroup/SPIRV-Tools/utils/vscode/src/lsp/protocol" ) const ( enableDebugLogging = false ) // rSpy is a reader 'spy' that wraps an io.Reader, and logs all data that passes // through it. type rSpy struct { prefix string r io.Reader } func (s rSpy) Read(p []byte) (n int, err error) { n, err = s.r.Read(p) log.Printf("%v %v", s.prefix, string(p[:n])) return n, err } // wSpy is a reader 'spy' that wraps an io.Writer, and logs all data that passes // through it. type wSpy struct { prefix string w io.Writer } func (s wSpy) Write(p []byte) (n int, err error) { n, err = s.w.Write(p) log.Printf("%v %v", s.prefix, string(p)) return n, err } // main entry point. func main() { log.SetOutput(io.Discard) if enableDebugLogging { // create a log file in the executable's directory. if logfile, err := os.Create(path.Join(path.Dir(os.Args[0]), "log.txt")); err == nil { defer logfile.Close() log.SetOutput(logfile) } } log.Println("language server started") stream := jsonrpc2.NewHeaderStream(rSpy{"IDE", os.Stdin}, wSpy{"LS", os.Stdout}) s := server{ files: map[string]*file{}, } s.ctx, s.conn, s.client = lsp.NewServer(context.Background(), stream, &s) if err := s.conn.Run(s.ctx); err != nil { log.Panicln(err) os.Exit(1) } log.Println("language server stopped") } type server struct { ctx context.Context conn *jsonrpc2.Conn client lsp.Client files map[string]*file filesMutex sync.Mutex } // file represents a source file type file struct { fullRange parser.Range res parser.Results } // tokAt returns the parser token at the given position lp func (f *file) tokAt(lp lsp.Position) *parser.Token { toks := f.res.Tokens p := parser.Position{Line: int(lp.Line) + 1, Column: int(lp.Character) + 1} i := sort.Search(len(toks), func(i int) bool { return p.LessThan(toks[i].Range.End) }) if i == len(toks) { return nil } if toks[i].Range.Contains(p) { return toks[i] } return nil } func (s *server) DidChangeWorkspaceFolders(ctx context.Context, p *lsp.DidChangeWorkspaceFoldersParams) error { log.Println("server.DidChangeWorkspaceFolders()") return nil } func (s *server) Initialized(ctx context.Context, p *lsp.InitializedParams) error { log.Println("server.Initialized()") return nil } func (s *server) Exit(ctx context.Context) error { log.Println("server.Exit()") return nil } func (s *server) DidChangeConfiguration(ctx context.Context, p *lsp.DidChangeConfigurationParams) error { log.Println("server.DidChangeConfiguration()") return nil } func (s *server) DidOpen(ctx context.Context, p *lsp.DidOpenTextDocumentParams) error { log.Println("server.DidOpen()") return s.processFile(ctx, p.TextDocument.URI, p.TextDocument.Text) } func (s *server) DidChange(ctx context.Context, p *lsp.DidChangeTextDocumentParams) error { log.Println("server.DidChange()") return s.processFile(ctx, p.TextDocument.URI, p.ContentChanges[0].Text) } func (s *server) DidClose(ctx context.Context, p *lsp.DidCloseTextDocumentParams) error { log.Println("server.DidClose()") return nil } func (s *server) DidSave(ctx context.Context, p *lsp.DidSaveTextDocumentParams) error { log.Println("server.DidSave()") return nil } func (s *server) WillSave(ctx context.Context, p *lsp.WillSaveTextDocumentParams) error { log.Println("server.WillSave()") return nil } func (s *server) DidChangeWatchedFiles(ctx context.Context, p *lsp.DidChangeWatchedFilesParams) error { log.Println("server.DidChangeWatchedFiles()") return nil } func (s *server) Progress(ctx context.Context, p *lsp.ProgressParams) error { log.Println("server.Progress()") return nil } func (s *server) SetTraceNotification(ctx context.Context, p *lsp.SetTraceParams) error { log.Println("server.SetTraceNotification()") return nil } func (s *server) LogTraceNotification(ctx context.Context, p *lsp.LogTraceParams) error { log.Println("server.LogTraceNotification()") return nil } func (s *server) Implementation(ctx context.Context, p *lsp.ImplementationParams) ([]lsp.Location, error) { log.Println("server.Implementation()") return nil, nil } func (s *server) TypeDefinition(ctx context.Context, p *lsp.TypeDefinitionParams) ([]lsp.Location, error) { log.Println("server.TypeDefinition()") return nil, nil } func (s *server) DocumentColor(ctx context.Context, p *lsp.DocumentColorParams) ([]lsp.ColorInformation, error) { log.Println("server.DocumentColor()") return nil, nil } func (s *server) ColorPresentation(ctx context.Context, p *lsp.ColorPresentationParams) ([]lsp.ColorPresentation, error) { log.Println("server.ColorPresentation()") return nil, nil } func (s *server) FoldingRange(ctx context.Context, p *lsp.FoldingRangeParams) ([]lsp.FoldingRange, error) { log.Println("server.FoldingRange()") return nil, nil } func (s *server) Declaration(ctx context.Context, p *lsp.DeclarationParams) ([]lsp.DeclarationLink, error) { log.Println("server.Declaration()") return nil, nil } func (s *server) SelectionRange(ctx context.Context, p *lsp.SelectionRangeParams) ([]lsp.SelectionRange, error) { log.Println("server.SelectionRange()") return nil, nil } func (s *server) Initialize(ctx context.Context, p *lsp.ParamInitia) (*lsp.InitializeResult, error) { log.Println("server.Initialize()") res := lsp.InitializeResult{ Capabilities: lsp.ServerCapabilities{ TextDocumentSync: lsp.TextDocumentSyncOptions{ OpenClose: true, Change: lsp.Full, // TODO: Implement incremental }, HoverProvider: true, DefinitionProvider: true, ReferencesProvider: true, RenameProvider: true, DocumentFormattingProvider: true, CompletionProvider: &lsp.CompletionOptions{ TriggerCharacters: []string{"%"}, ResolveProvider: false, }, }, } return &res, nil } func (s *server) Shutdown(ctx context.Context) error { log.Println("server.Shutdown()") return nil } func (s *server) WillSaveWaitUntil(ctx context.Context, p *lsp.WillSaveTextDocumentParams) ([]lsp.TextEdit, error) { log.Println("server.WillSaveWaitUntil()") return nil, nil } func markdownOpcode(op *schema.Opcode) string { sb := strings.Builder{} sb.WriteString(fmt.Sprintf("**%s** (%s)\n\n", op.Opname, op.Class)) for idx, operand := range op.Operands { sb.WriteString(fmt.Sprintf("Operand %d%s: ", idx, operand.Quantifier)) sb.WriteString(fmt.Sprintf("%s (%s)\n", operand.Name, operand.Kind.Kind)) } return sb.String() } func (s *server) Completion(ctx context.Context, p *lsp.CompletionParams) (*lsp.CompletionList, error) { log.Println("server.Completion()") f := s.getFile(p.TextDocument.URI) if f == nil { return nil, fmt.Errorf("Unknown file") } if p.Context.TriggerCharacter == "%" { idents := []lsp.CompletionItem{} for name, ident := range f.res.Identifiers { idents = append(idents, lsp.CompletionItem{ Label: name, Kind: 6, Documentation: ident.Definition.Range.Text(f.res.Lines), }) } res := &lsp.CompletionList{ IsIncomplete: false, Items: idents, } return res, nil } opcodes := []lsp.CompletionItem{} for name, opcode := range schema.Opcodes { opcodes = append(opcodes, lsp.CompletionItem{ Label: name, Kind: 3, Documentation: markdownOpcode(opcode), }) } res := &lsp.CompletionList{ IsIncomplete: false, Items: opcodes, } return res, nil } func (s *server) Resolve(ctx context.Context, p *lsp.CompletionItem) (*lsp.CompletionItem, error) { log.Println("server.Resolve()") return nil, nil } func (s *server) Hover(ctx context.Context, p *lsp.HoverParams) (*lsp.Hover, error) { log.Println("server.Hover()") f := s.getFile(p.TextDocument.URI) if f == nil { return nil, fmt.Errorf("Unknown file") } if tok := f.tokAt(p.Position); tok != nil { sb := strings.Builder{} switch v := f.res.Mappings[tok].(type) { default: sb.WriteString(fmt.Sprintf("", v)) case *parser.Instruction: sb.WriteString(markdownOpcode(v.Opcode)) case *parser.Identifier: sb.WriteString(fmt.Sprintf("```\n%v\n```", v.Definition.Range.Text(f.res.Lines))) case *parser.Operand: if v.Name != "" { sb.WriteString(strings.Trim(v.Name, `'`)) sb.WriteString("\n\n") } switch v.Kind.Category { case schema.OperandCategoryBitEnum: case schema.OperandCategoryValueEnum: sb.WriteString("```\n") sb.WriteString(strings.Trim(v.Kind.Kind, `'`)) sb.WriteString("\n```") case schema.OperandCategoryID: if s := tok.Text(f.res.Lines); s != "" { if id, ok := f.res.Identifiers[s]; ok && id.Definition != nil { sb.WriteString("```\n") sb.WriteString(id.Definition.Range.Text(f.res.Lines)) sb.WriteString("\n```") } } case schema.OperandCategoryLiteral: case schema.OperandCategoryComposite: } case nil: } if sb.Len() > 0 { res := lsp.Hover{ Contents: lsp.MarkupContent{ Kind: "markdown", Value: sb.String(), }, } return &res, nil } } return nil, nil } func (s *server) SignatureHelp(ctx context.Context, p *lsp.SignatureHelpParams) (*lsp.SignatureHelp, error) { log.Println("server.SignatureHelp()") return nil, nil } func (s *server) Definition(ctx context.Context, p *lsp.DefinitionParams) ([]lsp.Location, error) { log.Println("server.Definition()") if f := s.getFile(p.TextDocument.URI); f != nil { if tok := f.tokAt(p.Position); tok != nil { if s := tok.Text(f.res.Lines); s != "" { if id, ok := f.res.Identifiers[s]; ok { loc := lsp.Location{ URI: p.TextDocument.URI, Range: rangeToLSP(id.Definition.Range), } return []lsp.Location{loc}, nil } } } } return nil, nil } func (s *server) References(ctx context.Context, p *lsp.ReferenceParams) ([]lsp.Location, error) { log.Println("server.References()") if f := s.getFile(p.TextDocument.URI); f != nil { if tok := f.tokAt(p.Position); tok != nil { if s := tok.Text(f.res.Lines); s != "" { if id, ok := f.res.Identifiers[s]; ok { locs := make([]lsp.Location, len(id.References)) for i, r := range id.References { locs[i] = lsp.Location{ URI: p.TextDocument.URI, Range: rangeToLSP(r.Range), } } return locs, nil } } } } return nil, nil } func (s *server) DocumentHighlight(ctx context.Context, p *lsp.DocumentHighlightParams) ([]lsp.DocumentHighlight, error) { log.Println("server.DocumentHighlight()") return nil, nil } func (s *server) DocumentSymbol(ctx context.Context, p *lsp.DocumentSymbolParams) ([]lsp.DocumentSymbol, error) { log.Println("server.DocumentSymbol()") return nil, nil } func (s *server) CodeAction(ctx context.Context, p *lsp.CodeActionParams) ([]lsp.CodeAction, error) { log.Println("server.CodeAction()") return nil, nil } func (s *server) Symbol(ctx context.Context, p *lsp.WorkspaceSymbolParams) ([]lsp.SymbolInformation, error) { log.Println("server.Symbol()") return nil, nil } func (s *server) CodeLens(ctx context.Context, p *lsp.CodeLensParams) ([]lsp.CodeLens, error) { log.Println("server.CodeLens()") return nil, nil } func (s *server) ResolveCodeLens(ctx context.Context, p *lsp.CodeLens) (*lsp.CodeLens, error) { log.Println("server.ResolveCodeLens()") return nil, nil } func (s *server) DocumentLink(ctx context.Context, p *lsp.DocumentLinkParams) ([]lsp.DocumentLink, error) { log.Println("server.DocumentLink()") return nil, nil } func (s *server) ResolveDocumentLink(ctx context.Context, p *lsp.DocumentLink) (*lsp.DocumentLink, error) { log.Println("server.ResolveDocumentLink()") return nil, nil } func (s *server) Formatting(ctx context.Context, p *lsp.DocumentFormattingParams) ([]lsp.TextEdit, error) { log.Println("server.Formatting()") if f := s.getFile(p.TextDocument.URI); f != nil { // Start by measuring the distance from the start of each line to the // first opcode on that line. lineInstOffsets, maxInstOffset, instOffset, curOffset := []int{}, 0, 0, -1 for _, t := range f.res.Tokens { curOffset++ // whitespace between tokens switch t.Type { case parser.Ident: if _, isInst := schema.Opcodes[t.Text(f.res.Lines)]; isInst && instOffset == 0 { instOffset = curOffset continue } case parser.Newline: lineInstOffsets = append(lineInstOffsets, instOffset) if instOffset > maxInstOffset { maxInstOffset = instOffset } curOffset, instOffset = -1, 0 default: curOffset += utf8.RuneCountInString(t.Text(f.res.Lines)) } } lineInstOffsets = append(lineInstOffsets, instOffset) // Now rewrite each of the lines, adding padding at the start of the // line for alignment. sb, newline := strings.Builder{}, true for _, t := range f.res.Tokens { if newline { newline = false indent := maxInstOffset - lineInstOffsets[0] lineInstOffsets = lineInstOffsets[1:] switch t.Type { case parser.Newline, parser.Comment: default: for s := 0; s < indent; s++ { sb.WriteRune(' ') } } } else if t.Type != parser.Newline { sb.WriteString(" ") } sb.WriteString(t.Text(f.res.Lines)) if t.Type == parser.Newline { newline = true } } formatted := sb.String() // Every good file ends with a single new line. formatted = strings.TrimRight(formatted, "\n") + "\n" return []lsp.TextEdit{ { Range: rangeToLSP(f.fullRange), NewText: formatted, }, }, nil } return nil, nil } func (s *server) RangeFormatting(ctx context.Context, p *lsp.DocumentRangeFormattingParams) ([]lsp.TextEdit, error) { log.Println("server.RangeFormatting()") return nil, nil } func (s *server) OnTypeFormatting(ctx context.Context, p *lsp.DocumentOnTypeFormattingParams) ([]lsp.TextEdit, error) { log.Println("server.OnTypeFormatting()") return nil, nil } func (s *server) Rename(ctx context.Context, p *lsp.RenameParams) (*lsp.WorkspaceEdit, error) { log.Println("server.Rename()") if f := s.getFile(p.TextDocument.URI); f != nil { if tok := f.tokAt(p.Position); tok != nil { if s := tok.Text(f.res.Lines); s != "" { if id, ok := f.res.Identifiers[s]; ok { changes := make([]lsp.TextEdit, len(id.References)) for i, r := range id.References { changes[i].Range = rangeToLSP(r.Range) changes[i].NewText = p.NewName } m := map[string][]lsp.TextEdit{} m[p.TextDocument.URI] = changes return &lsp.WorkspaceEdit{Changes: &m}, nil } } } } return nil, nil } func (s *server) PrepareRename(ctx context.Context, p *lsp.PrepareRenameParams) (*lsp.Range, error) { log.Println("server.PrepareRename()") return nil, nil } func (s *server) ExecuteCommand(ctx context.Context, p *lsp.ExecuteCommandParams) (interface{}, error) { log.Println("server.ExecuteCommand()") return nil, nil } func (s *server) processFile(ctx context.Context, uri, source string) error { log.Println("server.DidOpen()") res, err := parser.Parse(source) if err != nil { return err } fullRange := parser.Range{ Start: parser.Position{Line: 1, Column: 1}, End: parser.Position{Line: len(res.Lines), Column: utf8.RuneCountInString(res.Lines[len(res.Lines)-1]) + 1}, } s.filesMutex.Lock() s.files[uri] = &file{ fullRange: fullRange, res: res, } s.filesMutex.Unlock() dp := lsp.PublishDiagnosticsParams{URI: uri, Diagnostics: make([]lsp.Diagnostic, len(res.Diagnostics))} for i, d := range res.Diagnostics { dp.Diagnostics[i] = diagnosticToLSP(d) } s.client.PublishDiagnostics(ctx, &dp) return nil } func (s *server) getFile(uri string) *file { s.filesMutex.Lock() defer s.filesMutex.Unlock() return s.files[uri] } func diagnosticToLSP(d parser.Diagnostic) lsp.Diagnostic { return lsp.Diagnostic{ Range: rangeToLSP(d.Range), Severity: severityToLSP(d.Severity), Message: d.Message, } } func severityToLSP(s parser.Severity) lsp.DiagnosticSeverity { switch s { case parser.SeverityError: return lsp.SeverityError case parser.SeverityWarning: return lsp.SeverityWarning case parser.SeverityInformation: return lsp.SeverityInformation case parser.SeverityHint: return lsp.SeverityHint default: log.Panicf("Invalid severity '%d'", int(s)) return lsp.SeverityError } } func rangeToLSP(r parser.Range) lsp.Range { return lsp.Range{ Start: positionToLSP(r.Start), End: positionToLSP(r.End), } } func positionToLSP(r parser.Position) lsp.Position { return lsp.Position{ Line: float64(r.Line - 1), Character: float64(r.Column - 1), } } KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/src/lsp/000077500000000000000000000000001475742701700225415ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/src/lsp/LICENSE000066400000000000000000000261361475742701700235560ustar00rootroot00000000000000 Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright [yyyy] [name of copyright owner] Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/src/lsp/README.md000066400000000000000000000003441475742701700240210ustar00rootroot00000000000000This directory contains code forked from https://github.com/golang/tools/tree/master/internal/lsp. This code has been modified to remove unneeded features and dependencies. Submitted on behalf of a third-party: The Go Authors KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/src/lsp/jsonrpc2/000077500000000000000000000000001475742701700243015ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/src/lsp/jsonrpc2/handler.go000066400000000000000000000114631475742701700262520ustar00rootroot00000000000000// Copyright 2019 The Go Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package jsonrpc2 import ( "context" ) // Handler is the interface used to hook into the message handling of an rpc // connection. type Handler interface { // Deliver is invoked to handle incoming requests. // If the request returns false from IsNotify then the Handler must eventually // call Reply on the Conn with the supplied request. // Handlers are called synchronously, they should pass the work off to a go // routine if they are going to take a long time. // If Deliver returns true all subsequent handlers will be invoked with // delivered set to true, and should not attempt to deliver the message. Deliver(ctx context.Context, r *Request, delivered bool) bool // Cancel is invoked for cancelled outgoing requests. // It is okay to use the connection to send notifications, but the context will // be in the cancelled state, so you must do it with the background context // instead. // If Cancel returns true all subsequent handlers will be invoked with // cancelled set to true, and should not attempt to cancel the message. Cancel(ctx context.Context, conn *Conn, id ID, cancelled bool) bool // Log is invoked for all messages flowing through a Conn. // direction indicates if the message being received or sent // id is the message id, if not set it was a notification // elapsed is the time between a call being seen and the response, and is // negative for anything that is not a response. // method is the method name specified in the message // payload is the parameters for a call or notification, and the result for a // response // Request is called near the start of processing any request. Request(ctx context.Context, conn *Conn, direction Direction, r *WireRequest) context.Context // Response is called near the start of processing any response. Response(ctx context.Context, conn *Conn, direction Direction, r *WireResponse) context.Context // Done is called when any request is fully processed. // For calls, this means the response has also been processed, for notifies // this is as soon as the message has been written to the stream. // If err is set, it implies the request failed. Done(ctx context.Context, err error) // Read is called with a count each time some data is read from the stream. // The read calls are delayed until after the data has been interpreted so // that it can be attributed to a request/response. Read(ctx context.Context, bytes int64) context.Context // Wrote is called each time some data is written to the stream. Wrote(ctx context.Context, bytes int64) context.Context // Error is called with errors that cannot be delivered through the normal // mechanisms, for instance a failure to process a notify cannot be delivered // back to the other party. Error(ctx context.Context, err error) } // Direction is used to indicate to a logger whether the logged message was being // sent or received. type Direction bool const ( // Send indicates the message is outgoing. Send = Direction(true) // Receive indicates the message is incoming. Receive = Direction(false) ) func (d Direction) String() string { switch d { case Send: return "send" case Receive: return "receive" default: panic("unreachable") } } type EmptyHandler struct{} func (EmptyHandler) Deliver(ctx context.Context, r *Request, delivered bool) bool { return false } func (EmptyHandler) Cancel(ctx context.Context, conn *Conn, id ID, cancelled bool) bool { return false } func (EmptyHandler) Request(ctx context.Context, conn *Conn, direction Direction, r *WireRequest) context.Context { return ctx } func (EmptyHandler) Response(ctx context.Context, conn *Conn, direction Direction, r *WireResponse) context.Context { return ctx } func (EmptyHandler) Done(ctx context.Context, err error) { } func (EmptyHandler) Read(ctx context.Context, bytes int64) context.Context { return ctx } func (EmptyHandler) Wrote(ctx context.Context, bytes int64) context.Context { return ctx } func (EmptyHandler) Error(ctx context.Context, err error) {} type defaultHandler struct{ EmptyHandler } func (defaultHandler) Deliver(ctx context.Context, r *Request, delivered bool) bool { if delivered { return false } if !r.IsNotify() { r.Reply(ctx, nil, NewErrorf(CodeMethodNotFound, "method %q not found", r.Method)) } return true } KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/src/lsp/jsonrpc2/jsonrpc2.go000066400000000000000000000272731475742701700264030ustar00rootroot00000000000000// Copyright 2018 The Go Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Package jsonrpc2 is a minimal implementation of the JSON RPC 2 spec. // https://www.jsonrpc.org/specification // It is intended to be compatible with other implementations at the wire level. package jsonrpc2 import ( "context" "encoding/json" "fmt" "sync" "sync/atomic" ) // Conn is a JSON RPC 2 client server connection. // Conn is bidirectional; it does not have a designated server or client end. type Conn struct { seq int64 // must only be accessed using atomic operations handlers []Handler stream Stream err error pendingMu sync.Mutex // protects the pending map pending map[ID]chan *WireResponse handlingMu sync.Mutex // protects the handling map handling map[ID]*Request } type requestState int const ( requestWaiting = requestState(iota) requestSerial requestParallel requestReplied requestDone ) // Request is sent to a server to represent a Call or Notify operation. type Request struct { conn *Conn cancel context.CancelFunc state requestState nextRequest chan struct{} // The Wire values of the request. WireRequest } // NewErrorf builds a Error struct for the supplied message and code. // If args is not empty, message and args will be passed to Sprintf. func NewErrorf(code int64, format string, args ...interface{}) *Error { return &Error{ Code: code, Message: fmt.Sprintf(format, args...), } } // NewConn creates a new connection object around the supplied stream. // You must call Run for the connection to be active. func NewConn(s Stream) *Conn { conn := &Conn{ handlers: []Handler{defaultHandler{}}, stream: s, pending: make(map[ID]chan *WireResponse), handling: make(map[ID]*Request), } return conn } // AddHandler adds a new handler to the set the connection will invoke. // Handlers are invoked in the reverse order of how they were added, this // allows the most recent addition to be the first one to attempt to handle a // message. func (c *Conn) AddHandler(handler Handler) { // prepend the new handlers so we use them first c.handlers = append([]Handler{handler}, c.handlers...) } // Cancel cancels a pending Call on the server side. // The call is identified by its id. // JSON RPC 2 does not specify a cancel message, so cancellation support is not // directly wired in. This method allows a higher level protocol to choose how // to propagate the cancel. func (c *Conn) Cancel(id ID) { c.handlingMu.Lock() handling, found := c.handling[id] c.handlingMu.Unlock() if found { handling.cancel() } } // Notify is called to send a notification request over the connection. // It will return as soon as the notification has been sent, as no response is // possible. func (c *Conn) Notify(ctx context.Context, method string, params interface{}) (err error) { jsonParams, err := marshalToRaw(params) if err != nil { return fmt.Errorf("marshalling notify parameters: %v", err) } request := &WireRequest{ Method: method, Params: jsonParams, } data, err := json.Marshal(request) if err != nil { return fmt.Errorf("marshalling notify request: %v", err) } for _, h := range c.handlers { ctx = h.Request(ctx, c, Send, request) } defer func() { for _, h := range c.handlers { h.Done(ctx, err) } }() n, err := c.stream.Write(ctx, data) for _, h := range c.handlers { ctx = h.Wrote(ctx, n) } return err } // Call sends a request over the connection and then waits for a response. // If the response is not an error, it will be decoded into result. // result must be of a type you an pass to json.Unmarshal. func (c *Conn) Call(ctx context.Context, method string, params, result interface{}) (err error) { // generate a new request identifier id := ID{Number: atomic.AddInt64(&c.seq, 1)} jsonParams, err := marshalToRaw(params) if err != nil { return fmt.Errorf("marshalling call parameters: %v", err) } request := &WireRequest{ ID: &id, Method: method, Params: jsonParams, } // marshal the request now it is complete data, err := json.Marshal(request) if err != nil { return fmt.Errorf("marshalling call request: %v", err) } for _, h := range c.handlers { ctx = h.Request(ctx, c, Send, request) } // we have to add ourselves to the pending map before we send, otherwise we // are racing the response rchan := make(chan *WireResponse) c.pendingMu.Lock() c.pending[id] = rchan c.pendingMu.Unlock() defer func() { // clean up the pending response handler on the way out c.pendingMu.Lock() delete(c.pending, id) c.pendingMu.Unlock() for _, h := range c.handlers { h.Done(ctx, err) } }() // now we are ready to send n, err := c.stream.Write(ctx, data) for _, h := range c.handlers { ctx = h.Wrote(ctx, n) } if err != nil { // sending failed, we will never get a response, so don't leave it pending return err } // now wait for the response select { case response := <-rchan: for _, h := range c.handlers { ctx = h.Response(ctx, c, Receive, response) } // is it an error response? if response.Error != nil { return response.Error } if result == nil || response.Result == nil { return nil } if err := json.Unmarshal(*response.Result, result); err != nil { return fmt.Errorf("unmarshalling result: %v", err) } return nil case <-ctx.Done(): // allow the handler to propagate the cancel cancelled := false for _, h := range c.handlers { if h.Cancel(ctx, c, id, cancelled) { cancelled = true } } return ctx.Err() } } // Conn returns the connection that created this request. func (r *Request) Conn() *Conn { return r.conn } // IsNotify returns true if this request is a notification. func (r *Request) IsNotify() bool { return r.ID == nil } // Parallel indicates that the system is now allowed to process other requests // in parallel with this one. // It is safe to call any number of times, but must only be called from the // request handling go routine. // It is implied by both reply and by the handler returning. func (r *Request) Parallel() { if r.state >= requestParallel { return } r.state = requestParallel close(r.nextRequest) } // Reply sends a reply to the given request. // It is an error to call this if request was not a call. // You must call this exactly once for any given request. // It should only be called from the handler go routine. // If err is set then result will be ignored. // If the request has not yet dropped into parallel mode // it will be before this function returns. func (r *Request) Reply(ctx context.Context, result interface{}, err error) error { if r.state >= requestReplied { return fmt.Errorf("reply invoked more than once") } if r.IsNotify() { return fmt.Errorf("reply not invoked with a valid call") } // reply ends the handling phase of a call, so if we are not yet // parallel we should be now. The go routine is allowed to continue // to do work after replying, which is why it is important to unlock // the rpc system at this point. r.Parallel() r.state = requestReplied var raw *json.RawMessage if err == nil { raw, err = marshalToRaw(result) } response := &WireResponse{ Result: raw, ID: r.ID, } if err != nil { if callErr, ok := err.(*Error); ok { response.Error = callErr } else { response.Error = NewErrorf(0, "%s", err) } } data, err := json.Marshal(response) if err != nil { return err } for _, h := range r.conn.handlers { ctx = h.Response(ctx, r.conn, Send, response) } n, err := r.conn.stream.Write(ctx, data) for _, h := range r.conn.handlers { ctx = h.Wrote(ctx, n) } if err != nil { // TODO(iancottrell): if a stream write fails, we really need to shut down // the whole stream return err } return nil } func (c *Conn) setHandling(r *Request, active bool) { if r.ID == nil { return } r.conn.handlingMu.Lock() defer r.conn.handlingMu.Unlock() if active { r.conn.handling[*r.ID] = r } else { delete(r.conn.handling, *r.ID) } } // combined has all the fields of both Request and Response. // We can decode this and then work out which it is. type combined struct { VersionTag VersionTag `json:"jsonrpc"` ID *ID `json:"id,omitempty"` Method string `json:"method"` Params *json.RawMessage `json:"params,omitempty"` Result *json.RawMessage `json:"result,omitempty"` Error *Error `json:"error,omitempty"` } // Run blocks until the connection is terminated, and returns any error that // caused the termination. // It must be called exactly once for each Conn. // It returns only when the reader is closed or there is an error in the stream. func (c *Conn) Run(runCtx context.Context) error { // we need to make the next request "lock" in an unlocked state to allow // the first incoming request to proceed. All later requests are unlocked // by the preceding request going to parallel mode. nextRequest := make(chan struct{}) close(nextRequest) for { // get the data for a message data, n, err := c.stream.Read(runCtx) if err != nil { // the stream failed, we cannot continue return err } // read a combined message msg := &combined{} if err := json.Unmarshal(data, msg); err != nil { // a badly formed message arrived, log it and continue // we trust the stream to have isolated the error to just this message for _, h := range c.handlers { h.Error(runCtx, fmt.Errorf("unmarshal failed: %v", err)) } continue } // work out which kind of message we have switch { case msg.Method != "": // if method is set it must be a request reqCtx, cancelReq := context.WithCancel(runCtx) thisRequest := nextRequest nextRequest = make(chan struct{}) req := &Request{ conn: c, cancel: cancelReq, nextRequest: nextRequest, WireRequest: WireRequest{ VersionTag: msg.VersionTag, Method: msg.Method, Params: msg.Params, ID: msg.ID, }, } for _, h := range c.handlers { reqCtx = h.Request(reqCtx, c, Receive, &req.WireRequest) reqCtx = h.Read(reqCtx, n) } c.setHandling(req, true) go func() { <-thisRequest req.state = requestSerial defer func() { c.setHandling(req, false) if !req.IsNotify() && req.state < requestReplied { req.Reply(reqCtx, nil, NewErrorf(CodeInternalError, "method %q did not reply", req.Method)) } req.Parallel() for _, h := range c.handlers { h.Done(reqCtx, err) } cancelReq() }() delivered := false for _, h := range c.handlers { if h.Deliver(reqCtx, req, delivered) { delivered = true } } }() case msg.ID != nil: // we have a response, get the pending entry from the map c.pendingMu.Lock() rchan := c.pending[*msg.ID] if rchan != nil { delete(c.pending, *msg.ID) } c.pendingMu.Unlock() // and send the reply to the channel response := &WireResponse{ Result: msg.Result, Error: msg.Error, ID: msg.ID, } rchan <- response close(rchan) default: for _, h := range c.handlers { h.Error(runCtx, fmt.Errorf("message not a call, notify or response, ignoring")) } } } } func marshalToRaw(obj interface{}) (*json.RawMessage, error) { data, err := json.Marshal(obj) if err != nil { return nil, err } raw := json.RawMessage(data) return &raw, nil } KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/src/lsp/jsonrpc2/stream.go000066400000000000000000000101201475742701700261150ustar00rootroot00000000000000// Copyright 2018 The Go Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package jsonrpc2 import ( "bufio" "context" "encoding/json" "fmt" "io" "strconv" "strings" "sync" ) // Stream abstracts the transport mechanics from the JSON RPC protocol. // A Conn reads and writes messages using the stream it was provided on // construction, and assumes that each call to Read or Write fully transfers // a single message, or returns an error. type Stream interface { // Read gets the next message from the stream. // It is never called concurrently. Read(context.Context) ([]byte, int64, error) // Write sends a message to the stream. // It must be safe for concurrent use. Write(context.Context, []byte) (int64, error) } // NewStream returns a Stream built on top of an io.Reader and io.Writer // The messages are sent with no wrapping, and rely on json decode consistency // to determine message boundaries. func NewStream(in io.Reader, out io.Writer) Stream { return &plainStream{ in: json.NewDecoder(in), out: out, } } type plainStream struct { in *json.Decoder outMu sync.Mutex out io.Writer } func (s *plainStream) Read(ctx context.Context) ([]byte, int64, error) { select { case <-ctx.Done(): return nil, 0, ctx.Err() default: } var raw json.RawMessage if err := s.in.Decode(&raw); err != nil { return nil, 0, err } return raw, int64(len(raw)), nil } func (s *plainStream) Write(ctx context.Context, data []byte) (int64, error) { select { case <-ctx.Done(): return 0, ctx.Err() default: } s.outMu.Lock() n, err := s.out.Write(data) s.outMu.Unlock() return int64(n), err } // NewHeaderStream returns a Stream built on top of an io.Reader and io.Writer // The messages are sent with HTTP content length and MIME type headers. // This is the format used by LSP and others. func NewHeaderStream(in io.Reader, out io.Writer) Stream { return &headerStream{ in: bufio.NewReader(in), out: out, } } type headerStream struct { in *bufio.Reader outMu sync.Mutex out io.Writer } func (s *headerStream) Read(ctx context.Context) ([]byte, int64, error) { select { case <-ctx.Done(): return nil, 0, ctx.Err() default: } var total, length int64 // read the header, stop on the first empty line for { line, err := s.in.ReadString('\n') total += int64(len(line)) if err != nil { return nil, total, fmt.Errorf("failed reading header line %q", err) } line = strings.TrimSpace(line) // check we have a header line if line == "" { break } colon := strings.IndexRune(line, ':') if colon < 0 { return nil, total, fmt.Errorf("invalid header line %q", line) } name, value := line[:colon], strings.TrimSpace(line[colon+1:]) switch name { case "Content-Length": if length, err = strconv.ParseInt(value, 10, 32); err != nil { return nil, total, fmt.Errorf("failed parsing Content-Length: %v", value) } if length <= 0 { return nil, total, fmt.Errorf("invalid Content-Length: %v", length) } default: // ignoring unknown headers } } if length == 0 { return nil, total, fmt.Errorf("missing Content-Length header") } data := make([]byte, length) if _, err := io.ReadFull(s.in, data); err != nil { return nil, total, err } total += length return data, total, nil } func (s *headerStream) Write(ctx context.Context, data []byte) (int64, error) { select { case <-ctx.Done(): return 0, ctx.Err() default: } s.outMu.Lock() defer s.outMu.Unlock() n, err := fmt.Fprintf(s.out, "Content-Length: %v\r\n\r\n", len(data)) total := int64(n) if err == nil { n, err = s.out.Write(data) total += int64(n) } return total, err } KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/src/lsp/jsonrpc2/wire.go000066400000000000000000000111741475742701700256020ustar00rootroot00000000000000// Copyright 2018 The Go Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package jsonrpc2 import ( "encoding/json" "fmt" "strconv" ) // this file contains the go forms of the wire specification // see http://www.jsonrpc.org/specification for details const ( // CodeUnknownError should be used for all non coded errors. CodeUnknownError = -32001 // CodeParseError is used when invalid JSON was received by the server. CodeParseError = -32700 //CodeInvalidRequest is used when the JSON sent is not a valid Request object. CodeInvalidRequest = -32600 // CodeMethodNotFound should be returned by the handler when the method does // not exist / is not available. CodeMethodNotFound = -32601 // CodeInvalidParams should be returned by the handler when method // parameter(s) were invalid. CodeInvalidParams = -32602 // CodeInternalError is not currently returned but defined for completeness. CodeInternalError = -32603 //CodeServerOverloaded is returned when a message was refused due to a //server being temporarily unable to accept any new messages. CodeServerOverloaded = -32000 ) // WireRequest is sent to a server to represent a Call or Notify operation. type WireRequest struct { // VersionTag is always encoded as the string "2.0" VersionTag VersionTag `json:"jsonrpc"` // Method is a string containing the method name to invoke. Method string `json:"method"` // Params is either a struct or an array with the parameters of the method. Params *json.RawMessage `json:"params,omitempty"` // The id of this request, used to tie the Response back to the request. // Will be either a string or a number. If not set, the Request is a notify, // and no response is possible. ID *ID `json:"id,omitempty"` } // WireResponse is a reply to a Request. // It will always have the ID field set to tie it back to a request, and will // have either the Result or Error fields set depending on whether it is a // success or failure response. type WireResponse struct { // VersionTag is always encoded as the string "2.0" VersionTag VersionTag `json:"jsonrpc"` // Result is the response value, and is required on success. Result *json.RawMessage `json:"result,omitempty"` // Error is a structured error response if the call fails. Error *Error `json:"error,omitempty"` // ID must be set and is the identifier of the Request this is a response to. ID *ID `json:"id,omitempty"` } // Error represents a structured error in a Response. type Error struct { // Code is an error code indicating the type of failure. Code int64 `json:"code"` // Message is a short description of the error. Message string `json:"message"` // Data is optional structured data containing additional information about the error. Data *json.RawMessage `json:"data"` } // VersionTag is a special 0 sized struct that encodes as the jsonrpc version // tag. // It will fail during decode if it is not the correct version tag in the // stream. type VersionTag struct{} // ID is a Request identifier. // Only one of either the Name or Number members will be set, using the // number form if the Name is the empty string. type ID struct { Name string Number int64 } func (err *Error) Error() string { if err == nil { return "" } return err.Message } func (VersionTag) MarshalJSON() ([]byte, error) { return json.Marshal("2.0") } func (VersionTag) UnmarshalJSON(data []byte) error { version := "" if err := json.Unmarshal(data, &version); err != nil { return err } if version != "2.0" { return fmt.Errorf("Invalid RPC version %v", version) } return nil } // String returns a string representation of the ID. // The representation is non ambiguous, string forms are quoted, number forms // are preceded by a # func (id *ID) String() string { if id == nil { return "" } if id.Name != "" { return strconv.Quote(id.Name) } return "#" + strconv.FormatInt(id.Number, 10) } func (id *ID) MarshalJSON() ([]byte, error) { if id.Name != "" { return json.Marshal(id.Name) } return json.Marshal(id.Number) } func (id *ID) UnmarshalJSON(data []byte) error { *id = ID{} if err := json.Unmarshal(data, &id.Number); err == nil { return nil } return json.Unmarshal(data, &id.Name) } KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/src/lsp/protocol/000077500000000000000000000000001475742701700244025ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/src/lsp/protocol/context.go000066400000000000000000000014621475742701700264200ustar00rootroot00000000000000// Copyright 2018 The Go Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package protocol import ( "context" ) type contextKey int const ( clientKey = contextKey(iota) ) func WithClient(ctx context.Context, client Client) context.Context { return context.WithValue(ctx, clientKey, client) } KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/src/lsp/protocol/doc.go000066400000000000000000000021741475742701700255020ustar00rootroot00000000000000// Copyright 2018 The Go Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Package protocol contains the structs that map directly to the wire format // of the "Language Server Protocol". // // It is a literal transcription, with unmodified comments, and only the changes // required to make it go code. // Names are uppercased to export them. // All fields have JSON tags added to correct the names. // Fields marked with a ? are also marked as "omitempty" // Fields that are "|| null" are made pointers // Fields that are string or number are left as string // Fields that are type "number" are made float64 package protocol KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/src/lsp/protocol/enums.go000066400000000000000000000222231475742701700260610ustar00rootroot00000000000000// Copyright 2018 The Go Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package protocol import ( "fmt" ) var ( namesTextDocumentSyncKind [int(Incremental) + 1]string namesInitializeError [int(UnknownProtocolVersion) + 1]string namesMessageType [int(Log) + 1]string namesFileChangeType [int(Deleted) + 1]string namesWatchKind [int(WatchDelete) + 1]string namesCompletionTriggerKind [int(TriggerForIncompleteCompletions) + 1]string namesDiagnosticSeverity [int(SeverityHint) + 1]string namesDiagnosticTag [int(Unnecessary) + 1]string namesCompletionItemKind [int(TypeParameterCompletion) + 1]string namesInsertTextFormat [int(SnippetTextFormat) + 1]string namesDocumentHighlightKind [int(Write) + 1]string namesSymbolKind [int(TypeParameter) + 1]string namesTextDocumentSaveReason [int(FocusOut) + 1]string ) func init() { namesTextDocumentSyncKind[int(None)] = "None" namesTextDocumentSyncKind[int(Full)] = "Full" namesTextDocumentSyncKind[int(Incremental)] = "Incremental" namesInitializeError[int(UnknownProtocolVersion)] = "UnknownProtocolVersion" namesMessageType[int(Error)] = "Error" namesMessageType[int(Warning)] = "Warning" namesMessageType[int(Info)] = "Info" namesMessageType[int(Log)] = "Log" namesFileChangeType[int(Created)] = "Created" namesFileChangeType[int(Changed)] = "Changed" namesFileChangeType[int(Deleted)] = "Deleted" namesWatchKind[int(WatchCreate)] = "WatchCreate" namesWatchKind[int(WatchChange)] = "WatchChange" namesWatchKind[int(WatchDelete)] = "WatchDelete" namesCompletionTriggerKind[int(Invoked)] = "Invoked" namesCompletionTriggerKind[int(TriggerCharacter)] = "TriggerCharacter" namesCompletionTriggerKind[int(TriggerForIncompleteCompletions)] = "TriggerForIncompleteCompletions" namesDiagnosticSeverity[int(SeverityError)] = "Error" namesDiagnosticSeverity[int(SeverityWarning)] = "Warning" namesDiagnosticSeverity[int(SeverityInformation)] = "Information" namesDiagnosticSeverity[int(SeverityHint)] = "Hint" namesDiagnosticTag[int(Unnecessary)] = "Unnecessary" namesCompletionItemKind[int(TextCompletion)] = "text" namesCompletionItemKind[int(MethodCompletion)] = "method" namesCompletionItemKind[int(FunctionCompletion)] = "func" namesCompletionItemKind[int(ConstructorCompletion)] = "constructor" namesCompletionItemKind[int(FieldCompletion)] = "field" namesCompletionItemKind[int(VariableCompletion)] = "var" namesCompletionItemKind[int(ClassCompletion)] = "type" namesCompletionItemKind[int(InterfaceCompletion)] = "interface" namesCompletionItemKind[int(ModuleCompletion)] = "package" namesCompletionItemKind[int(PropertyCompletion)] = "property" namesCompletionItemKind[int(UnitCompletion)] = "unit" namesCompletionItemKind[int(ValueCompletion)] = "value" namesCompletionItemKind[int(EnumCompletion)] = "enum" namesCompletionItemKind[int(KeywordCompletion)] = "keyword" namesCompletionItemKind[int(SnippetCompletion)] = "snippet" namesCompletionItemKind[int(ColorCompletion)] = "color" namesCompletionItemKind[int(FileCompletion)] = "file" namesCompletionItemKind[int(ReferenceCompletion)] = "reference" namesCompletionItemKind[int(FolderCompletion)] = "folder" namesCompletionItemKind[int(EnumMemberCompletion)] = "enumMember" namesCompletionItemKind[int(ConstantCompletion)] = "const" namesCompletionItemKind[int(StructCompletion)] = "struct" namesCompletionItemKind[int(EventCompletion)] = "event" namesCompletionItemKind[int(OperatorCompletion)] = "operator" namesCompletionItemKind[int(TypeParameterCompletion)] = "typeParam" namesInsertTextFormat[int(PlainTextTextFormat)] = "PlainText" namesInsertTextFormat[int(SnippetTextFormat)] = "Snippet" namesDocumentHighlightKind[int(Text)] = "Text" namesDocumentHighlightKind[int(Read)] = "Read" namesDocumentHighlightKind[int(Write)] = "Write" namesSymbolKind[int(File)] = "File" namesSymbolKind[int(Module)] = "Module" namesSymbolKind[int(Namespace)] = "Namespace" namesSymbolKind[int(Package)] = "Package" namesSymbolKind[int(Class)] = "Class" namesSymbolKind[int(Method)] = "Method" namesSymbolKind[int(Property)] = "Property" namesSymbolKind[int(Field)] = "Field" namesSymbolKind[int(Constructor)] = "Constructor" namesSymbolKind[int(Enum)] = "Enum" namesSymbolKind[int(Interface)] = "Interface" namesSymbolKind[int(Function)] = "Function" namesSymbolKind[int(Variable)] = "Variable" namesSymbolKind[int(Constant)] = "Constant" namesSymbolKind[int(String)] = "String" namesSymbolKind[int(Number)] = "Number" namesSymbolKind[int(Boolean)] = "Boolean" namesSymbolKind[int(Array)] = "Array" namesSymbolKind[int(Object)] = "Object" namesSymbolKind[int(Key)] = "Key" namesSymbolKind[int(Null)] = "Null" namesSymbolKind[int(EnumMember)] = "EnumMember" namesSymbolKind[int(Struct)] = "Struct" namesSymbolKind[int(Event)] = "Event" namesSymbolKind[int(Operator)] = "Operator" namesSymbolKind[int(TypeParameter)] = "TypeParameter" namesTextDocumentSaveReason[int(Manual)] = "Manual" namesTextDocumentSaveReason[int(AfterDelay)] = "AfterDelay" namesTextDocumentSaveReason[int(FocusOut)] = "FocusOut" } func formatEnum(f fmt.State, c rune, i int, names []string, unknown string) { s := "" if i >= 0 && i < len(names) { s = names[i] } if s != "" { fmt.Fprint(f, s) } else { fmt.Fprintf(f, "%s(%d)", unknown, i) } } func parseEnum(s string, names []string) int { for i, name := range names { if s == name { return i } } return 0 } func (e TextDocumentSyncKind) Format(f fmt.State, c rune) { formatEnum(f, c, int(e), namesTextDocumentSyncKind[:], "TextDocumentSyncKind") } func ParseTextDocumentSyncKind(s string) TextDocumentSyncKind { return TextDocumentSyncKind(parseEnum(s, namesTextDocumentSyncKind[:])) } func (e InitializeError) Format(f fmt.State, c rune) { formatEnum(f, c, int(e), namesInitializeError[:], "InitializeError") } func ParseInitializeError(s string) InitializeError { return InitializeError(parseEnum(s, namesInitializeError[:])) } func (e MessageType) Format(f fmt.State, c rune) { formatEnum(f, c, int(e), namesMessageType[:], "MessageType") } func ParseMessageType(s string) MessageType { return MessageType(parseEnum(s, namesMessageType[:])) } func (e FileChangeType) Format(f fmt.State, c rune) { formatEnum(f, c, int(e), namesFileChangeType[:], "FileChangeType") } func ParseFileChangeType(s string) FileChangeType { return FileChangeType(parseEnum(s, namesFileChangeType[:])) } func (e WatchKind) Format(f fmt.State, c rune) { formatEnum(f, c, int(e), namesWatchKind[:], "WatchKind") } func ParseWatchKind(s string) WatchKind { return WatchKind(parseEnum(s, namesWatchKind[:])) } func (e CompletionTriggerKind) Format(f fmt.State, c rune) { formatEnum(f, c, int(e), namesCompletionTriggerKind[:], "CompletionTriggerKind") } func ParseCompletionTriggerKind(s string) CompletionTriggerKind { return CompletionTriggerKind(parseEnum(s, namesCompletionTriggerKind[:])) } func (e DiagnosticSeverity) Format(f fmt.State, c rune) { formatEnum(f, c, int(e), namesDiagnosticSeverity[:], "DiagnosticSeverity") } func ParseDiagnosticSeverity(s string) DiagnosticSeverity { return DiagnosticSeverity(parseEnum(s, namesDiagnosticSeverity[:])) } func (e DiagnosticTag) Format(f fmt.State, c rune) { formatEnum(f, c, int(e), namesDiagnosticTag[:], "DiagnosticTag") } func ParseDiagnosticTag(s string) DiagnosticTag { return DiagnosticTag(parseEnum(s, namesDiagnosticTag[:])) } func (e CompletionItemKind) Format(f fmt.State, c rune) { formatEnum(f, c, int(e), namesCompletionItemKind[:], "CompletionItemKind") } func ParseCompletionItemKind(s string) CompletionItemKind { return CompletionItemKind(parseEnum(s, namesCompletionItemKind[:])) } func (e InsertTextFormat) Format(f fmt.State, c rune) { formatEnum(f, c, int(e), namesInsertTextFormat[:], "InsertTextFormat") } func ParseInsertTextFormat(s string) InsertTextFormat { return InsertTextFormat(parseEnum(s, namesInsertTextFormat[:])) } func (e DocumentHighlightKind) Format(f fmt.State, c rune) { formatEnum(f, c, int(e), namesDocumentHighlightKind[:], "DocumentHighlightKind") } func ParseDocumentHighlightKind(s string) DocumentHighlightKind { return DocumentHighlightKind(parseEnum(s, namesDocumentHighlightKind[:])) } func (e SymbolKind) Format(f fmt.State, c rune) { formatEnum(f, c, int(e), namesSymbolKind[:], "SymbolKind") } func ParseSymbolKind(s string) SymbolKind { return SymbolKind(parseEnum(s, namesSymbolKind[:])) } func (e TextDocumentSaveReason) Format(f fmt.State, c rune) { formatEnum(f, c, int(e), namesTextDocumentSaveReason[:], "TextDocumentSaveReason") } func ParseTextDocumentSaveReason(s string) TextDocumentSaveReason { return TextDocumentSaveReason(parseEnum(s, namesTextDocumentSaveReason[:])) } KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/src/lsp/protocol/log.go000066400000000000000000000161231475742701700255150ustar00rootroot00000000000000// Copyright 2018 The Go Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package protocol import ( "context" "encoding/json" "fmt" "io" "strings" "sync" "time" "github.com/KhronosGroup/SPIRV-Tools/utils/vscode/src/lsp/jsonrpc2" ) type loggingStream struct { stream jsonrpc2.Stream log io.Writer } // LoggingStream returns a stream that does LSP protocol logging too func LoggingStream(str jsonrpc2.Stream, w io.Writer) jsonrpc2.Stream { return &loggingStream{str, w} } func (s *loggingStream) Read(ctx context.Context) ([]byte, int64, error) { data, count, err := s.stream.Read(ctx) if err == nil { logIn(s.log, data) } return data, count, err } func (s *loggingStream) Write(ctx context.Context, data []byte) (int64, error) { logOut(s.log, data) count, err := s.stream.Write(ctx, data) return count, err } // Combined has all the fields of both Request and Response. // We can decode this and then work out which it is. type Combined struct { VersionTag jsonrpc2.VersionTag `json:"jsonrpc"` ID *jsonrpc2.ID `json:"id,omitempty"` Method string `json:"method"` Params *json.RawMessage `json:"params,omitempty"` Result *json.RawMessage `json:"result,omitempty"` Error *jsonrpc2.Error `json:"error,omitempty"` } type req struct { method string start time.Time } type mapped struct { mu sync.Mutex clientCalls map[string]req serverCalls map[string]req } var maps = &mapped{ sync.Mutex{}, make(map[string]req), make(map[string]req), } // these 4 methods are each used exactly once, but it seemed // better to have the encapsulation rather than ad hoc mutex // code in 4 places func (m *mapped) client(id string, del bool) req { m.mu.Lock() defer m.mu.Unlock() v := m.clientCalls[id] if del { delete(m.clientCalls, id) } return v } func (m *mapped) server(id string, del bool) req { m.mu.Lock() defer m.mu.Unlock() v := m.serverCalls[id] if del { delete(m.serverCalls, id) } return v } func (m *mapped) setClient(id string, r req) { m.mu.Lock() defer m.mu.Unlock() m.clientCalls[id] = r } func (m *mapped) setServer(id string, r req) { m.mu.Lock() defer m.mu.Unlock() m.serverCalls[id] = r } const eor = "\r\n\r\n\r\n" func strID(x *jsonrpc2.ID) string { if x == nil { // should never happen, but we need a number return "999999999" } if x.Name != "" { return x.Name } return fmt.Sprintf("%d", x.Number) } func logCommon(outfd io.Writer, data []byte) (*Combined, time.Time, string) { if outfd == nil { return nil, time.Time{}, "" } var v Combined err := json.Unmarshal(data, &v) if err != nil { fmt.Fprintf(outfd, "Unmarshal %v\n", err) panic(err) // do better } tm := time.Now() tmfmt := tm.Format("15:04:05.000 PM") return &v, tm, tmfmt } // logOut and logIn could be combined. "received"<->"Sending", serverCalls<->clientCalls // but it wouldn't be a lot shorter or clearer and "shutdown" is a special case // Writing a message to the client, log it func logOut(outfd io.Writer, data []byte) { v, tm, tmfmt := logCommon(outfd, data) if v == nil { return } if v.Error != nil { id := strID(v.ID) fmt.Fprintf(outfd, "[Error - %s] Received #%s %s%s", tmfmt, id, v.Error, eor) return } buf := strings.Builder{} id := strID(v.ID) fmt.Fprintf(&buf, "[Trace - %s] ", tmfmt) // common beginning if v.ID != nil && v.Method != "" && v.Params != nil { fmt.Fprintf(&buf, "Received request '%s - (%s)'.\n", v.Method, id) fmt.Fprintf(&buf, "Params: %s%s", *v.Params, eor) maps.setServer(id, req{method: v.Method, start: tm}) } else if v.ID != nil && v.Method == "" && v.Params == nil { cc := maps.client(id, true) elapsed := tm.Sub(cc.start) fmt.Fprintf(&buf, "Received response '%s - (%s)' in %dms.\n", cc.method, id, elapsed/time.Millisecond) if v.Result == nil { fmt.Fprintf(&buf, "Result: {}%s", eor) } else { fmt.Fprintf(&buf, "Result: %s%s", string(*v.Result), eor) } } else if v.ID == nil && v.Method != "" && v.Params != nil { p := "null" if v.Params != nil { p = string(*v.Params) } fmt.Fprintf(&buf, "Received notification '%s'.\n", v.Method) fmt.Fprintf(&buf, "Params: %s%s", p, eor) } else { // for completeness, as it should never happen buf = strings.Builder{} // undo common Trace fmt.Fprintf(&buf, "[Error - %s] on write ID?%v method:%q Params:%v Result:%v Error:%v%s", tmfmt, v.ID != nil, v.Method, v.Params != nil, v.Result != nil, v.Error != nil, eor) p := "null" if v.Params != nil { p = string(*v.Params) } r := "null" if v.Result != nil { r = string(*v.Result) } fmt.Fprintf(&buf, "%s\n%s\n%s%s", p, r, v.Error, eor) } outfd.Write([]byte(buf.String())) } // Got a message from the client, log it func logIn(outfd io.Writer, data []byte) { v, tm, tmfmt := logCommon(outfd, data) if v == nil { return } // ID Method Params => Sending request // ID !Method Result(might be null, but !Params) => Sending response (could we get an Error?) // !ID Method Params => Sending notification if v.Error != nil { // does this ever happen? id := strID(v.ID) fmt.Fprintf(outfd, "[Error - %s] Sent #%s %s%s", tmfmt, id, v.Error, eor) return } buf := strings.Builder{} id := strID(v.ID) fmt.Fprintf(&buf, "[Trace - %s] ", tmfmt) // common beginning if v.ID != nil && v.Method != "" && (v.Params != nil || v.Method == "shutdown") { fmt.Fprintf(&buf, "Sending request '%s - (%s)'.\n", v.Method, id) x := "{}" if v.Params != nil { x = string(*v.Params) } fmt.Fprintf(&buf, "Params: %s%s", x, eor) maps.setClient(id, req{method: v.Method, start: tm}) } else if v.ID != nil && v.Method == "" && v.Params == nil { sc := maps.server(id, true) elapsed := tm.Sub(sc.start) fmt.Fprintf(&buf, "Sending response '%s - (%s)' took %dms.\n", sc.method, id, elapsed/time.Millisecond) if v.Result == nil { fmt.Fprintf(&buf, "Result: {}%s", eor) } else { fmt.Fprintf(&buf, "Result: %s%s", string(*v.Result), eor) } } else if v.ID == nil && v.Method != "" { p := "null" if v.Params != nil { p = string(*v.Params) } fmt.Fprintf(&buf, "Sending notification '%s'.\n", v.Method) fmt.Fprintf(&buf, "Params: %s%s", p, eor) } else { // for completeness, as it should never happen buf = strings.Builder{} // undo common Trace fmt.Fprintf(&buf, "[Error - %s] on read ID?%v method:%q Params:%v Result:%v Error:%v%s", tmfmt, v.ID != nil, v.Method, v.Params != nil, v.Result != nil, v.Error != nil, eor) p := "null" if v.Params != nil { p = string(*v.Params) } r := "null" if v.Result != nil { r = string(*v.Result) } fmt.Fprintf(&buf, "%s\n%s\n%s%s", p, r, v.Error, eor) } outfd.Write([]byte(buf.String())) } KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/src/lsp/protocol/protocol.go000066400000000000000000000046631475742701700266030ustar00rootroot00000000000000// Copyright 2018 The Go Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package protocol import ( "context" "encoding/json" "log" "github.com/KhronosGroup/SPIRV-Tools/utils/vscode/src/lsp/jsonrpc2" ) const ( // RequestCancelledError should be used when a request is cancelled early. RequestCancelledError = -32800 ) type DocumentUri = string type canceller struct{ jsonrpc2.EmptyHandler } type clientHandler struct { canceller client Client } type serverHandler struct { canceller server Server } func (canceller) Request(ctx context.Context, conn *jsonrpc2.Conn, direction jsonrpc2.Direction, r *jsonrpc2.WireRequest) context.Context { if direction == jsonrpc2.Receive && r.Method == "$/cancelRequest" { var params CancelParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { log.Printf("%v", err) } else { conn.Cancel(params.ID) } } return ctx } func (canceller) Cancel(ctx context.Context, conn *jsonrpc2.Conn, id jsonrpc2.ID, cancelled bool) bool { if cancelled { return false } conn.Notify(ctx, "$/cancelRequest", &CancelParams{ID: id}) return true } func NewClient(ctx context.Context, stream jsonrpc2.Stream, client Client) (context.Context, *jsonrpc2.Conn, Server) { ctx = WithClient(ctx, client) conn := jsonrpc2.NewConn(stream) conn.AddHandler(&clientHandler{client: client}) return ctx, conn, &serverDispatcher{Conn: conn} } func NewServer(ctx context.Context, stream jsonrpc2.Stream, server Server) (context.Context, *jsonrpc2.Conn, Client) { conn := jsonrpc2.NewConn(stream) client := &clientDispatcher{Conn: conn} ctx = WithClient(ctx, client) conn.AddHandler(&serverHandler{server: server}) return ctx, conn, client } func sendParseError(ctx context.Context, req *jsonrpc2.Request, err error) { if _, ok := err.(*jsonrpc2.Error); !ok { err = jsonrpc2.NewErrorf(jsonrpc2.CodeParseError, "%v", err) } if err := req.Reply(ctx, nil, err); err != nil { log.Printf("%v", err) } } KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/src/lsp/protocol/span.go000066400000000000000000000064111475742701700256740ustar00rootroot00000000000000// Copyright 2018 The Go Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // this file contains protocol<->span converters package protocol import ( "fmt" "github.com/KhronosGroup/SPIRV-Tools/utils/vscode/src/lsp/span" errors "golang.org/x/xerrors" ) type ColumnMapper struct { URI span.URI Converter *span.TokenConverter Content []byte } func NewURI(uri span.URI) string { return string(uri) } func (m *ColumnMapper) Location(s span.Span) (Location, error) { rng, err := m.Range(s) if err != nil { return Location{}, err } return Location{URI: NewURI(s.URI()), Range: rng}, nil } func (m *ColumnMapper) Range(s span.Span) (Range, error) { if span.CompareURI(m.URI, s.URI()) != 0 { return Range{}, errors.Errorf("column mapper is for file %q instead of %q", m.URI, s.URI()) } s, err := s.WithAll(m.Converter) if err != nil { return Range{}, err } start, err := m.Position(s.Start()) if err != nil { return Range{}, err } end, err := m.Position(s.End()) if err != nil { return Range{}, err } return Range{Start: start, End: end}, nil } func (m *ColumnMapper) Position(p span.Point) (Position, error) { chr, err := span.ToUTF16Column(p, m.Content) if err != nil { return Position{}, err } return Position{ Line: float64(p.Line() - 1), Character: float64(chr - 1), }, nil } func (m *ColumnMapper) Span(l Location) (span.Span, error) { return m.RangeSpan(l.Range) } func (m *ColumnMapper) RangeSpan(r Range) (span.Span, error) { start, err := m.Point(r.Start) if err != nil { return span.Span{}, err } end, err := m.Point(r.End) if err != nil { return span.Span{}, err } return span.New(m.URI, start, end).WithAll(m.Converter) } func (m *ColumnMapper) PointSpan(p Position) (span.Span, error) { start, err := m.Point(p) if err != nil { return span.Span{}, err } return span.New(m.URI, start, start).WithAll(m.Converter) } func (m *ColumnMapper) Point(p Position) (span.Point, error) { line := int(p.Line) + 1 offset, err := m.Converter.ToOffset(line, 1) if err != nil { return span.Point{}, err } lineStart := span.NewPoint(line, 1, offset) return span.FromUTF16Column(lineStart, int(p.Character)+1, m.Content) } func IsPoint(r Range) bool { return r.Start.Line == r.End.Line && r.Start.Character == r.End.Character } func CompareRange(a, b Range) int { if r := ComparePosition(a.Start, b.Start); r != 0 { return r } return ComparePosition(a.End, b.End) } func ComparePosition(a, b Position) int { if a.Line < b.Line { return -1 } if a.Line > b.Line { return 1 } if a.Character < b.Character { return -1 } if a.Character > b.Character { return 1 } return 0 } func (r Range) Format(f fmt.State, _ rune) { fmt.Fprintf(f, "%v:%v-%v:%v", r.Start.Line, r.Start.Character, r.End.Line, r.End.Character) } KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/src/lsp/protocol/tsclient.go000066400000000000000000000157341475742701700265700ustar00rootroot00000000000000// Copyright 2019 The Go Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package protocol import ( "context" "encoding/json" "log" "github.com/KhronosGroup/SPIRV-Tools/utils/vscode/src/lsp/jsonrpc2" ) type Client interface { ShowMessage(context.Context, *ShowMessageParams) error LogMessage(context.Context, *LogMessageParams) error Event(context.Context, *interface{}) error PublishDiagnostics(context.Context, *PublishDiagnosticsParams) error WorkspaceFolders(context.Context) ([]WorkspaceFolder, error) Configuration(context.Context, *ParamConfig) ([]interface{}, error) RegisterCapability(context.Context, *RegistrationParams) error UnregisterCapability(context.Context, *UnregistrationParams) error ShowMessageRequest(context.Context, *ShowMessageRequestParams) (*MessageActionItem, error) ApplyEdit(context.Context, *ApplyWorkspaceEditParams) (*ApplyWorkspaceEditResponse, error) } func (h clientHandler) Deliver(ctx context.Context, r *jsonrpc2.Request, delivered bool) bool { if delivered { return false } if ctx.Err() != nil { r.Reply(ctx, nil, jsonrpc2.NewErrorf(RequestCancelledError, "")) return true } switch r.Method { case "window/showMessage": // notif var params ShowMessageParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } if err := h.client.ShowMessage(ctx, ¶ms); err != nil { log.Printf("%v", err) } return true case "window/logMessage": // notif var params LogMessageParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } if err := h.client.LogMessage(ctx, ¶ms); err != nil { log.Printf("%v", err) } return true case "telemetry/event": // notif var params interface{} if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } if err := h.client.Event(ctx, ¶ms); err != nil { log.Printf("%v", err) } return true case "textDocument/publishDiagnostics": // notif var params PublishDiagnosticsParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } if err := h.client.PublishDiagnostics(ctx, ¶ms); err != nil { log.Printf("%v", err) } return true case "workspace/workspaceFolders": // req if r.Params != nil { r.Reply(ctx, nil, jsonrpc2.NewErrorf(jsonrpc2.CodeInvalidParams, "Expected no params")) return true } resp, err := h.client.WorkspaceFolders(ctx) if err := r.Reply(ctx, resp, err); err != nil { log.Printf("%v", err) } return true case "workspace/configuration": // req var params ParamConfig if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } resp, err := h.client.Configuration(ctx, ¶ms) if err := r.Reply(ctx, resp, err); err != nil { log.Printf("%v", err) } return true case "client/registerCapability": // req var params RegistrationParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } err := h.client.RegisterCapability(ctx, ¶ms) if err := r.Reply(ctx, nil, err); err != nil { log.Printf("%v", err) } return true case "client/unregisterCapability": // req var params UnregistrationParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } err := h.client.UnregisterCapability(ctx, ¶ms) if err := r.Reply(ctx, nil, err); err != nil { log.Printf("%v", err) } return true case "window/showMessageRequest": // req var params ShowMessageRequestParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } resp, err := h.client.ShowMessageRequest(ctx, ¶ms) if err := r.Reply(ctx, resp, err); err != nil { log.Printf("%v", err) } return true case "workspace/applyEdit": // req var params ApplyWorkspaceEditParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } resp, err := h.client.ApplyEdit(ctx, ¶ms) if err := r.Reply(ctx, resp, err); err != nil { log.Printf("%v", err) } return true default: return false } } type clientDispatcher struct { *jsonrpc2.Conn } func (s *clientDispatcher) ShowMessage(ctx context.Context, params *ShowMessageParams) error { return s.Conn.Notify(ctx, "window/showMessage", params) } func (s *clientDispatcher) LogMessage(ctx context.Context, params *LogMessageParams) error { return s.Conn.Notify(ctx, "window/logMessage", params) } func (s *clientDispatcher) Event(ctx context.Context, params *interface{}) error { return s.Conn.Notify(ctx, "telemetry/event", params) } func (s *clientDispatcher) PublishDiagnostics(ctx context.Context, params *PublishDiagnosticsParams) error { return s.Conn.Notify(ctx, "textDocument/publishDiagnostics", params) } func (s *clientDispatcher) WorkspaceFolders(ctx context.Context) ([]WorkspaceFolder, error) { var result []WorkspaceFolder if err := s.Conn.Call(ctx, "workspace/workspaceFolders", nil, &result); err != nil { return nil, err } return result, nil } func (s *clientDispatcher) Configuration(ctx context.Context, params *ParamConfig) ([]interface{}, error) { var result []interface{} if err := s.Conn.Call(ctx, "workspace/configuration", params, &result); err != nil { return nil, err } return result, nil } func (s *clientDispatcher) RegisterCapability(ctx context.Context, params *RegistrationParams) error { return s.Conn.Call(ctx, "client/registerCapability", params, nil) // Call, not Notify } func (s *clientDispatcher) UnregisterCapability(ctx context.Context, params *UnregistrationParams) error { return s.Conn.Call(ctx, "client/unregisterCapability", params, nil) // Call, not Notify } func (s *clientDispatcher) ShowMessageRequest(ctx context.Context, params *ShowMessageRequestParams) (*MessageActionItem, error) { var result MessageActionItem if err := s.Conn.Call(ctx, "window/showMessageRequest", params, &result); err != nil { return nil, err } return &result, nil } func (s *clientDispatcher) ApplyEdit(ctx context.Context, params *ApplyWorkspaceEditParams) (*ApplyWorkspaceEditResponse, error) { var result ApplyWorkspaceEditResponse if err := s.Conn.Call(ctx, "workspace/applyEdit", params, &result); err != nil { return nil, err } return &result, nil } // Types constructed to avoid structs as formal argument types type ParamConfig struct { ConfigurationParams PartialResultParams } KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/src/lsp/protocol/tsprotocol.go000066400000000000000000003766341475742701700271640ustar00rootroot00000000000000// Copyright 2019 The Go Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Package protocol contains data types and code for LSP jsonrpcs // generated automatically from vscode-languageserver-node // commit: 36ac51f057215e6e2e0408384e07ecf564a938da // last fetched Tue Sep 24 2019 17:44:28 GMT-0400 (Eastern Daylight Time) package protocol // Code generated (see typescript/README.md) DO NOT EDIT. /*ImplementationClientCapabilities defined: * Since 3.6.0 */ type ImplementationClientCapabilities struct { /*DynamicRegistration defined: * Whether implementation supports dynamic registration. If this is set to `true` * the client supports the new `ImplementationRegistrationOptions` return value * for the corresponding server capability as well. */ DynamicRegistration bool `json:"dynamicRegistration,omitempty"` /*LinkSupport defined: * The client supports additional metadata in the form of definition links. * * Since 3.14.0 */ LinkSupport bool `json:"linkSupport,omitempty"` } // ImplementationOptions is type ImplementationOptions struct { WorkDoneProgressOptions } // ImplementationRegistrationOptions is type ImplementationRegistrationOptions struct { TextDocumentRegistrationOptions ImplementationOptions StaticRegistrationOptions } // ImplementationParams is type ImplementationParams struct { TextDocumentPositionParams WorkDoneProgressParams PartialResultParams } /*TypeDefinitionClientCapabilities defined: * Since 3.6.0 */ type TypeDefinitionClientCapabilities struct { /*DynamicRegistration defined: * Whether implementation supports dynamic registration. If this is set to `true` * the client supports the new `TypeDefinitionRegistrationOptions` return value * for the corresponding server capability as well. */ DynamicRegistration bool `json:"dynamicRegistration,omitempty"` /*LinkSupport defined: * The client supports additional metadata in the form of definition links. * * Since 3.14.0 */ LinkSupport bool `json:"linkSupport,omitempty"` } // TypeDefinitionOptions is type TypeDefinitionOptions struct { WorkDoneProgressOptions } // TypeDefinitionRegistrationOptions is type TypeDefinitionRegistrationOptions struct { TextDocumentRegistrationOptions TypeDefinitionOptions StaticRegistrationOptions } // TypeDefinitionParams is type TypeDefinitionParams struct { TextDocumentPositionParams WorkDoneProgressParams PartialResultParams } // WorkspaceFoldersInitializeParams is type WorkspaceFoldersInitializeParams struct { /*WorkspaceFolders defined: * The actual configured workspace folders. */ WorkspaceFolders []WorkspaceFolder `json:"workspaceFolders"` } // WorkspaceFoldersClientCapabilities is type WorkspaceFoldersClientCapabilities struct { /*Workspace defined: * The workspace client capabilities */ Workspace *struct { /*WorkspaceFolders defined: * The client has support for workspace folders */ WorkspaceFolders bool `json:"workspaceFolders,omitempty"` } `json:"workspace,omitempty"` } // WorkspaceFoldersServerCapabilities is type WorkspaceFoldersServerCapabilities struct { /*Workspace defined: * The workspace server capabilities */ Workspace *struct { // WorkspaceFolders is WorkspaceFolders *struct { /*Supported defined: * The Server has support for workspace folders */ Supported bool `json:"supported,omitempty"` /*ChangeNotifications defined: * Whether the server wants to receive workspace folder * change notifications. * * If a strings is provided the string is treated as a ID * under which the notification is registered on the client * side. The ID can be used to unregister for these events * using the `client/unregisterCapability` request. */ ChangeNotifications string `json:"changeNotifications,omitempty"` // string | boolean } `json:"workspaceFolders,omitempty"` } `json:"workspace,omitempty"` } // WorkspaceFolder is type WorkspaceFolder struct { /*URI defined: * The associated URI for this workspace folder. */ URI string `json:"uri"` /*Name defined: * The name of the workspace folder. Used to refer to this * workspace folder in the user interface. */ Name string `json:"name"` } /*DidChangeWorkspaceFoldersParams defined: * The parameters of a `workspace/didChangeWorkspaceFolders` notification. */ type DidChangeWorkspaceFoldersParams struct { /*Event defined: * The actual workspace folder change event. */ Event WorkspaceFoldersChangeEvent `json:"event"` } /*WorkspaceFoldersChangeEvent defined: * The workspace folder change event. */ type WorkspaceFoldersChangeEvent struct { /*Added defined: * The array of added workspace folders */ Added []WorkspaceFolder `json:"added"` /*Removed defined: * The array of the removed workspace folders */ Removed []WorkspaceFolder `json:"removed"` } // ConfigurationClientCapabilities is type ConfigurationClientCapabilities struct { /*Workspace defined: * The workspace client capabilities */ Workspace *struct { /*Configuration defined: * The client supports `workspace/configuration` requests. */ Configuration bool `json:"configuration,omitempty"` } `json:"workspace,omitempty"` } // ConfigurationItem is type ConfigurationItem struct { /*ScopeURI defined: * The scope to get the configuration section for. */ ScopeURI string `json:"scopeUri,omitempty"` /*Section defined: * The configuration section asked for. */ Section string `json:"section,omitempty"` } /*ConfigurationParams defined: * The parameters of a configuration request. */ type ConfigurationParams struct { // Items is Items []ConfigurationItem `json:"items"` } // DocumentColorClientCapabilities is type DocumentColorClientCapabilities struct { /*DynamicRegistration defined: * Whether implementation supports dynamic registration. If this is set to `true` * the client supports the new `DocumentColorRegistrationOptions` return value * for the corresponding server capability as well. */ DynamicRegistration bool `json:"dynamicRegistration,omitempty"` } // DocumentColorOptions is type DocumentColorOptions struct { /*ResolveProvider defined: * Code lens has a resolve provider as well. */ ResolveProvider bool `json:"resolveProvider,omitempty"` WorkDoneProgressOptions } // DocumentColorRegistrationOptions is type DocumentColorRegistrationOptions struct { TextDocumentRegistrationOptions StaticRegistrationOptions DocumentColorOptions } /*DocumentColorParams defined: * Parameters for a [DocumentColorRequest](#DocumentColorRequest). */ type DocumentColorParams struct { /*TextDocument defined: * The text document. */ TextDocument TextDocumentIdentifier `json:"textDocument"` WorkDoneProgressParams PartialResultParams } /*ColorPresentationParams defined: * Parameters for a [ColorPresentationRequest](#ColorPresentationRequest). */ type ColorPresentationParams struct { /*TextDocument defined: * The text document. */ TextDocument TextDocumentIdentifier `json:"textDocument"` /*Color defined: * The color to request presentations for. */ Color Color `json:"color"` /*Range defined: * The range where the color would be inserted. Serves as a context. */ Range Range `json:"range"` WorkDoneProgressParams PartialResultParams } // FoldingRangeClientCapabilities is type FoldingRangeClientCapabilities struct { /*DynamicRegistration defined: * Whether implementation supports dynamic registration for folding range providers. If this is set to `true` * the client supports the new `FoldingRangeRegistrationOptions` return value for the corresponding server * capability as well. */ DynamicRegistration bool `json:"dynamicRegistration,omitempty"` /*RangeLimit defined: * The maximum number of folding ranges that the client prefers to receive per document. The value serves as a * hint, servers are free to follow the limit. */ RangeLimit float64 `json:"rangeLimit,omitempty"` /*LineFoldingOnly defined: * If set, the client signals that it only supports folding complete lines. If set, client will * ignore specified `startCharacter` and `endCharacter` properties in a FoldingRange. */ LineFoldingOnly bool `json:"lineFoldingOnly,omitempty"` } // FoldingRangeOptions is type FoldingRangeOptions struct { WorkDoneProgressOptions } // FoldingRangeRegistrationOptions is type FoldingRangeRegistrationOptions struct { TextDocumentRegistrationOptions FoldingRangeOptions StaticRegistrationOptions } /*FoldingRange defined: * Represents a folding range. */ type FoldingRange struct { /*StartLine defined: * The zero-based line number from where the folded range starts. */ StartLine float64 `json:"startLine"` /*StartCharacter defined: * The zero-based character offset from where the folded range starts. If not defined, defaults to the length of the start line. */ StartCharacter float64 `json:"startCharacter,omitempty"` /*EndLine defined: * The zero-based line number where the folded range ends. */ EndLine float64 `json:"endLine"` /*EndCharacter defined: * The zero-based character offset before the folded range ends. If not defined, defaults to the length of the end line. */ EndCharacter float64 `json:"endCharacter,omitempty"` /*Kind defined: * Describes the kind of the folding range such as `comment' or 'region'. The kind * is used to categorize folding ranges and used by commands like 'Fold all comments'. See * [FoldingRangeKind](#FoldingRangeKind) for an enumeration of standardized kinds. */ Kind string `json:"kind,omitempty"` } /*FoldingRangeParams defined: * Parameters for a [FoldingRangeRequest](#FoldingRangeRequest). */ type FoldingRangeParams struct { /*TextDocument defined: * The text document. */ TextDocument TextDocumentIdentifier `json:"textDocument"` WorkDoneProgressParams PartialResultParams } /*DeclarationClientCapabilities defined: * Since 3.14.0 */ type DeclarationClientCapabilities struct { /*DynamicRegistration defined: * Whether declaration supports dynamic registration. If this is set to `true` * the client supports the new `DeclarationRegistrationOptions` return value * for the corresponding server capability as well. */ DynamicRegistration bool `json:"dynamicRegistration,omitempty"` /*LinkSupport defined: * The client supports additional metadata in the form of declaration links. */ LinkSupport bool `json:"linkSupport,omitempty"` } // DeclarationOptions is type DeclarationOptions struct { WorkDoneProgressOptions } // DeclarationRegistrationOptions is type DeclarationRegistrationOptions struct { DeclarationOptions TextDocumentRegistrationOptions StaticRegistrationOptions } // DeclarationParams is type DeclarationParams struct { TextDocumentPositionParams WorkDoneProgressParams PartialResultParams } // SelectionRangeClientCapabilities is type SelectionRangeClientCapabilities struct { /*DynamicRegistration defined: * Whether implementation supports dynamic registration for selection range providers. If this is set to `true` * the client supports the new `SelectionRangeRegistrationOptions` return value for the corresponding server * capability as well. */ DynamicRegistration bool `json:"dynamicRegistration,omitempty"` } // SelectionRangeOptions is type SelectionRangeOptions struct { WorkDoneProgressOptions } // SelectionRangeRegistrationOptions is type SelectionRangeRegistrationOptions struct { SelectionRangeOptions TextDocumentRegistrationOptions StaticRegistrationOptions } /*SelectionRangeParams defined: * A parameter literal used in selection range requests. */ type SelectionRangeParams struct { /*TextDocument defined: * The text document. */ TextDocument TextDocumentIdentifier `json:"textDocument"` /*Positions defined: * The positions inside the text document. */ Positions []Position `json:"positions"` WorkDoneProgressParams PartialResultParams } /*Registration defined: * General parameters to to register for an notification or to register a provider. */ type Registration struct { /*ID defined: * The id used to register the request. The id can be used to deregister * the request again. */ ID string `json:"id"` /*Method defined: * The method to register for. */ Method string `json:"method"` /*RegisterOptions defined: * Options necessary for the registration. */ RegisterOptions interface{} `json:"registerOptions,omitempty"` } // RegistrationParams is type RegistrationParams struct { // Registrations is Registrations []Registration `json:"registrations"` } /*Unregistration defined: * General parameters to unregister a request or notification. */ type Unregistration struct { /*ID defined: * The id used to unregister the request or notification. Usually an id * provided during the register request. */ ID string `json:"id"` /*Method defined: * The method to unregister for. */ Method string `json:"method"` } // UnregistrationParams is type UnregistrationParams struct { // Unregisterations is Unregisterations []Unregistration `json:"unregisterations"` } // WorkDoneProgressParams is type WorkDoneProgressParams struct { /*WorkDoneToken defined: * An optional token that a server can use to report work done progress. */ WorkDoneToken *ProgressToken `json:"workDoneToken,omitempty"` } // PartialResultParams is type PartialResultParams struct { /*PartialResultToken defined: * An optional token that a server can use to report partial results (e.g. streaming) to * the client. */ PartialResultToken *ProgressToken `json:"partialResultToken,omitempty"` } /*TextDocumentPositionParams defined: * A parameter literal used in requests to pass a text document and a position inside that * document. */ type TextDocumentPositionParams struct { /*TextDocument defined: * The text document. */ TextDocument TextDocumentIdentifier `json:"textDocument"` /*Position defined: * The position inside the text document. */ Position Position `json:"position"` } /*WorkspaceClientCapabilities defined: * Workspace specific client capabilities. */ type WorkspaceClientCapabilities struct { /*ApplyEdit defined: * The client supports applying batch edits * to the workspace by supporting the request * 'workspace/applyEdit' */ ApplyEdit bool `json:"applyEdit,omitempty"` /*WorkspaceEdit defined: * Capabilities specific to `WorkspaceEdit`s */ WorkspaceEdit *WorkspaceEditClientCapabilities `json:"workspaceEdit,omitempty"` /*DidChangeConfiguration defined: * Capabilities specific to the `workspace/didChangeConfiguration` notification. */ DidChangeConfiguration *DidChangeConfigurationClientCapabilities `json:"didChangeConfiguration,omitempty"` /*DidChangeWatchedFiles defined: * Capabilities specific to the `workspace/didChangeWatchedFiles` notification. */ DidChangeWatchedFiles *DidChangeWatchedFilesClientCapabilities `json:"didChangeWatchedFiles,omitempty"` /*Symbol defined: * Capabilities specific to the `workspace/symbol` request. */ Symbol *WorkspaceSymbolClientCapabilities `json:"symbol,omitempty"` /*ExecuteCommand defined: * Capabilities specific to the `workspace/executeCommand` request. */ ExecuteCommand *ExecuteCommandClientCapabilities `json:"executeCommand,omitempty"` } /*TextDocumentClientCapabilities defined: * Text document specific client capabilities. */ type TextDocumentClientCapabilities struct { /*Synchronization defined: * Defines which synchronization capabilities the client supports. */ Synchronization *TextDocumentSyncClientCapabilities `json:"synchronization,omitempty"` /*Completion defined: * Capabilities specific to the `textDocument/completion` */ Completion *CompletionClientCapabilities `json:"completion,omitempty"` /*Hover defined: * Capabilities specific to the `textDocument/hover` */ Hover *HoverClientCapabilities `json:"hover,omitempty"` /*SignatureHelp defined: * Capabilities specific to the `textDocument/signatureHelp` */ SignatureHelp *SignatureHelpClientCapabilities `json:"signatureHelp,omitempty"` /*Declaration defined: * Capabilities specific to the `textDocument/declaration` * * @since 3.14.0 */ Declaration *DeclarationClientCapabilities `json:"declaration,omitempty"` /*Definition defined: * Capabilities specific to the `textDocument/definition` */ Definition *DefinitionClientCapabilities `json:"definition,omitempty"` /*TypeDefinition defined: * Capabilities specific to the `textDocument/typeDefinition` * * @since 3.6.0 */ TypeDefinition *TypeDefinitionClientCapabilities `json:"typeDefinition,omitempty"` /*Implementation defined: * Capabilities specific to the `textDocument/implementation` * * @since 3.6.0 */ Implementation *ImplementationClientCapabilities `json:"implementation,omitempty"` /*References defined: * Capabilities specific to the `textDocument/references` */ References *ReferenceClientCapabilities `json:"references,omitempty"` /*DocumentHighlight defined: * Capabilities specific to the `textDocument/documentHighlight` */ DocumentHighlight *DocumentHighlightClientCapabilities `json:"documentHighlight,omitempty"` /*DocumentSymbol defined: * Capabilities specific to the `textDocument/documentSymbol` */ DocumentSymbol *DocumentSymbolClientCapabilities `json:"documentSymbol,omitempty"` /*CodeAction defined: * Capabilities specific to the `textDocument/codeAction` */ CodeAction *CodeActionClientCapabilities `json:"codeAction,omitempty"` /*CodeLens defined: * Capabilities specific to the `textDocument/codeLens` */ CodeLens *CodeLensClientCapabilities `json:"codeLens,omitempty"` /*DocumentLink defined: * Capabilities specific to the `textDocument/documentLink` */ DocumentLink *DocumentLinkClientCapabilities `json:"documentLink,omitempty"` /*ColorProvider defined: * Capabilities specific to the `textDocument/documentColor` */ ColorProvider *DocumentColorClientCapabilities `json:"colorProvider,omitempty"` /*Formatting defined: * Capabilities specific to the `textDocument/formatting` */ Formatting *DocumentFormattingClientCapabilities `json:"formatting,omitempty"` /*RangeFormatting defined: * Capabilities specific to the `textDocument/rangeFormatting` */ RangeFormatting *DocumentRangeFormattingClientCapabilities `json:"rangeFormatting,omitempty"` /*OnTypeFormatting defined: * Capabilities specific to the `textDocument/onTypeFormatting` */ OnTypeFormatting *DocumentOnTypeFormattingClientCapabilities `json:"onTypeFormatting,omitempty"` /*Rename defined: * Capabilities specific to the `textDocument/rename` */ Rename *RenameClientCapabilities `json:"rename,omitempty"` /*FoldingRange defined: * Capabilities specific to `textDocument/foldingRange` requests. * * @since 3.10.0 */ FoldingRange *FoldingRangeClientCapabilities `json:"foldingRange,omitempty"` /*SelectionRange defined: * Capabilities specific to `textDocument/selectionRange` requests * * @since 3.15.0 */ SelectionRange *SelectionRangeClientCapabilities `json:"selectionRange,omitempty"` /*PublishDiagnostics defined: * Capabilities specific to `textDocument/publishDiagnostics`. */ PublishDiagnostics *PublishDiagnosticsClientCapabilities `json:"publishDiagnostics,omitempty"` } /*InnerClientCapabilities defined: * Defines the capabilities provided by the client. */ type InnerClientCapabilities struct { /*Workspace defined: * Workspace specific client capabilities. */ Workspace *WorkspaceClientCapabilities `json:"workspace,omitempty"` /*TextDocument defined: * Text document specific client capabilities. */ TextDocument *TextDocumentClientCapabilities `json:"textDocument,omitempty"` /*Window defined: * Window specific client capabilities. */ Window interface{} `json:"window,omitempty"` /*Experimental defined: * Experimental client capabilities. */ Experimental interface{} `json:"experimental,omitempty"` } // ClientCapabilities is type ClientCapabilities struct { /*Workspace defined: * Workspace specific client capabilities. */ Workspace struct { /*ApplyEdit defined: * The client supports applying batch edits * to the workspace by supporting the request * 'workspace/applyEdit' */ ApplyEdit bool `json:"applyEdit,omitempty"` /*WorkspaceEdit defined: * Capabilities specific to `WorkspaceEdit`s */ WorkspaceEdit WorkspaceEditClientCapabilities `json:"workspaceEdit,omitempty"` /*DidChangeConfiguration defined: * Capabilities specific to the `workspace/didChangeConfiguration` notification. */ DidChangeConfiguration DidChangeConfigurationClientCapabilities `json:"didChangeConfiguration,omitempty"` /*DidChangeWatchedFiles defined: * Capabilities specific to the `workspace/didChangeWatchedFiles` notification. */ DidChangeWatchedFiles DidChangeWatchedFilesClientCapabilities `json:"didChangeWatchedFiles,omitempty"` /*Symbol defined: * Capabilities specific to the `workspace/symbol` request. */ Symbol WorkspaceSymbolClientCapabilities `json:"symbol,omitempty"` /*ExecuteCommand defined: * Capabilities specific to the `workspace/executeCommand` request. */ ExecuteCommand ExecuteCommandClientCapabilities `json:"executeCommand,omitempty"` /*WorkspaceFolders defined: * The client has support for workspace folders */ WorkspaceFolders bool `json:"workspaceFolders,omitempty"` /*Configuration defined: * The client supports `workspace/configuration` requests. */ Configuration bool `json:"configuration,omitempty"` } `json:"workspace,omitempty"` /*TextDocument defined: * Text document specific client capabilities. */ TextDocument TextDocumentClientCapabilities `json:"textDocument,omitempty"` /*Window defined: * Window specific client capabilities. */ Window interface{} `json:"window,omitempty"` /*Experimental defined: * Experimental client capabilities. */ Experimental interface{} `json:"experimental,omitempty"` /*DynamicRegistration defined: * Whether implementation supports dynamic registration for selection range providers. If this is set to `true` * the client supports the new `SelectionRangeRegistrationOptions` return value for the corresponding server * capability as well. */ DynamicRegistration bool `json:"dynamicRegistration,omitempty"` } /*StaticRegistrationOptions defined: * Static registration options to be returned in the initialize * request. */ type StaticRegistrationOptions struct { /*ID defined: * The id used to register the request. The id can be used to deregister * the request again. See also Registration#id. */ ID string `json:"id,omitempty"` } /*TextDocumentRegistrationOptions defined: * General text document registration options. */ type TextDocumentRegistrationOptions struct { /*DocumentSelector defined: * A document selector to identify the scope of the registration. If set to null * the document selector provided on the client side will be used. */ DocumentSelector DocumentSelector `json:"documentSelector"` } /*SaveOptions defined: * Save options. */ type SaveOptions struct { /*IncludeText defined: * The client is supposed to include the content on save. */ IncludeText bool `json:"includeText,omitempty"` } // WorkDoneProgressOptions is type WorkDoneProgressOptions struct { // WorkDoneProgress is WorkDoneProgress bool `json:"workDoneProgress,omitempty"` } /*InnerServerCapabilities defined: * Defines the capabilities provided by a language * server. */ type InnerServerCapabilities struct { /*TextDocumentSync defined: * Defines how text documents are synced. Is either a detailed structure defining each notification or * for backwards compatibility the TextDocumentSyncKind number. */ TextDocumentSync interface{} `json:"textDocumentSync,omitempty"` // TextDocumentSyncOptions | TextDocumentSyncKind /*CompletionProvider defined: * The server provides completion support. */ CompletionProvider *CompletionOptions `json:"completionProvider,omitempty"` /*HoverProvider defined: * The server provides hover support. */ HoverProvider bool `json:"hoverProvider,omitempty"` // boolean | HoverOptions /*SignatureHelpProvider defined: * The server provides signature help support. */ SignatureHelpProvider *SignatureHelpOptions `json:"signatureHelpProvider,omitempty"` /*DeclarationProvider defined: * The server provides Goto Declaration support. */ DeclarationProvider bool `json:"declarationProvider,omitempty"` // boolean | DeclarationOptions | DeclarationRegistrationOptions /*DefinitionProvider defined: * The server provides goto definition support. */ DefinitionProvider bool `json:"definitionProvider,omitempty"` // boolean | DefinitionOptions /*TypeDefinitionProvider defined: * The server provides Goto Type Definition support. */ TypeDefinitionProvider bool `json:"typeDefinitionProvider,omitempty"` // boolean | TypeDefinitionOptions | TypeDefinitionRegistrationOptions /*ImplementationProvider defined: * The server provides Goto Implementation support. */ ImplementationProvider bool `json:"implementationProvider,omitempty"` // boolean | ImplementationOptions | ImplementationRegistrationOptions /*ReferencesProvider defined: * The server provides find references support. */ ReferencesProvider bool `json:"referencesProvider,omitempty"` // boolean | ReferenceOptions /*DocumentHighlightProvider defined: * The server provides document highlight support. */ DocumentHighlightProvider bool `json:"documentHighlightProvider,omitempty"` // boolean | DocumentHighlightOptions /*DocumentSymbolProvider defined: * The server provides document symbol support. */ DocumentSymbolProvider bool `json:"documentSymbolProvider,omitempty"` // boolean | DocumentSymbolOptions /*CodeActionProvider defined: * The server provides code actions. CodeActionOptions may only be * specified if the client states that it supports * `codeActionLiteralSupport` in its initial `initialize` request. */ CodeActionProvider interface{} `json:"codeActionProvider,omitempty"` // boolean | CodeActionOptions /*CodeLensProvider defined: * The server provides code lens. */ CodeLensProvider *CodeLensOptions `json:"codeLensProvider,omitempty"` /*DocumentLinkProvider defined: * The server provides document link support. */ DocumentLinkProvider *DocumentLinkOptions `json:"documentLinkProvider,omitempty"` /*ColorProvider defined: * The server provides color provider support. */ ColorProvider bool `json:"colorProvider,omitempty"` // boolean | DocumentColorOptions | DocumentColorRegistrationOptions /*WorkspaceSymbolProvider defined: * The server provides workspace symbol support. */ WorkspaceSymbolProvider bool `json:"workspaceSymbolProvider,omitempty"` // boolean | WorkspaceSymbolOptions /*DocumentFormattingProvider defined: * The server provides document formatting. */ DocumentFormattingProvider bool `json:"documentFormattingProvider,omitempty"` // boolean | DocumentFormattingOptions /*DocumentRangeFormattingProvider defined: * The server provides document range formatting. */ DocumentRangeFormattingProvider bool `json:"documentRangeFormattingProvider,omitempty"` // boolean | DocumentRangeFormattingOptions /*DocumentOnTypeFormattingProvider defined: * The server provides document formatting on typing. */ DocumentOnTypeFormattingProvider *DocumentOnTypeFormattingOptions `json:"documentOnTypeFormattingProvider,omitempty"` /*RenameProvider defined: * The server provides rename support. RenameOptions may only be * specified if the client states that it supports * `prepareSupport` in its initial `initialize` request. */ RenameProvider interface{} `json:"renameProvider,omitempty"` // boolean | RenameOptions /*FoldingRangeProvider defined: * The server provides folding provider support. */ FoldingRangeProvider bool `json:"foldingRangeProvider,omitempty"` // boolean | FoldingRangeOptions | FoldingRangeRegistrationOptions /*SelectionRangeProvider defined: * The server provides selection range support. */ SelectionRangeProvider bool `json:"selectionRangeProvider,omitempty"` // boolean | SelectionRangeOptions | SelectionRangeRegistrationOptions /*ExecuteCommandProvider defined: * The server provides execute command support. */ ExecuteCommandProvider *ExecuteCommandOptions `json:"executeCommandProvider,omitempty"` /*Experimental defined: * Experimental server capabilities. */ Experimental interface{} `json:"experimental,omitempty"` } // ServerCapabilities is type ServerCapabilities struct { /*TextDocumentSync defined: * Defines how text documents are synced. Is either a detailed structure defining each notification or * for backwards compatibility the TextDocumentSyncKind number. */ TextDocumentSync interface{} `json:"textDocumentSync,omitempty"` // TextDocumentSyncOptions | TextDocumentSyncKind /*CompletionProvider defined: * The server provides completion support. */ CompletionProvider *CompletionOptions `json:"completionProvider,omitempty"` /*HoverProvider defined: * The server provides hover support. */ HoverProvider bool `json:"hoverProvider,omitempty"` // boolean | HoverOptions /*SignatureHelpProvider defined: * The server provides signature help support. */ SignatureHelpProvider *SignatureHelpOptions `json:"signatureHelpProvider,omitempty"` /*DeclarationProvider defined: * The server provides Goto Declaration support. */ DeclarationProvider bool `json:"declarationProvider,omitempty"` // boolean | DeclarationOptions | DeclarationRegistrationOptions /*DefinitionProvider defined: * The server provides goto definition support. */ DefinitionProvider bool `json:"definitionProvider,omitempty"` // boolean | DefinitionOptions /*TypeDefinitionProvider defined: * The server provides Goto Type Definition support. */ TypeDefinitionProvider bool `json:"typeDefinitionProvider,omitempty"` // boolean | TypeDefinitionOptions | TypeDefinitionRegistrationOptions /*ImplementationProvider defined: * The server provides Goto Implementation support. */ ImplementationProvider bool `json:"implementationProvider,omitempty"` // boolean | ImplementationOptions | ImplementationRegistrationOptions /*ReferencesProvider defined: * The server provides find references support. */ ReferencesProvider bool `json:"referencesProvider,omitempty"` // boolean | ReferenceOptions /*DocumentHighlightProvider defined: * The server provides document highlight support. */ DocumentHighlightProvider bool `json:"documentHighlightProvider,omitempty"` // boolean | DocumentHighlightOptions /*DocumentSymbolProvider defined: * The server provides document symbol support. */ DocumentSymbolProvider bool `json:"documentSymbolProvider,omitempty"` // boolean | DocumentSymbolOptions /*CodeActionProvider defined: * The server provides code actions. CodeActionOptions may only be * specified if the client states that it supports * `codeActionLiteralSupport` in its initial `initialize` request. */ CodeActionProvider interface{} `json:"codeActionProvider,omitempty"` // boolean | CodeActionOptions /*CodeLensProvider defined: * The server provides code lens. */ CodeLensProvider *CodeLensOptions `json:"codeLensProvider,omitempty"` /*DocumentLinkProvider defined: * The server provides document link support. */ DocumentLinkProvider *DocumentLinkOptions `json:"documentLinkProvider,omitempty"` /*ColorProvider defined: * The server provides color provider support. */ ColorProvider bool `json:"colorProvider,omitempty"` // boolean | DocumentColorOptions | DocumentColorRegistrationOptions /*WorkspaceSymbolProvider defined: * The server provides workspace symbol support. */ WorkspaceSymbolProvider bool `json:"workspaceSymbolProvider,omitempty"` // boolean | WorkspaceSymbolOptions /*DocumentFormattingProvider defined: * The server provides document formatting. */ DocumentFormattingProvider bool `json:"documentFormattingProvider,omitempty"` // boolean | DocumentFormattingOptions /*DocumentRangeFormattingProvider defined: * The server provides document range formatting. */ DocumentRangeFormattingProvider bool `json:"documentRangeFormattingProvider,omitempty"` // boolean | DocumentRangeFormattingOptions /*DocumentOnTypeFormattingProvider defined: * The server provides document formatting on typing. */ DocumentOnTypeFormattingProvider *DocumentOnTypeFormattingOptions `json:"documentOnTypeFormattingProvider,omitempty"` /*RenameProvider defined: * The server provides rename support. RenameOptions may only be * specified if the client states that it supports * `prepareSupport` in its initial `initialize` request. */ RenameProvider interface{} `json:"renameProvider,omitempty"` // boolean | RenameOptions /*FoldingRangeProvider defined: * The server provides folding provider support. */ FoldingRangeProvider bool `json:"foldingRangeProvider,omitempty"` // boolean | FoldingRangeOptions | FoldingRangeRegistrationOptions /*SelectionRangeProvider defined: * The server provides selection range support. */ SelectionRangeProvider bool `json:"selectionRangeProvider,omitempty"` // boolean | SelectionRangeOptions | SelectionRangeRegistrationOptions /*ExecuteCommandProvider defined: * The server provides execute command support. */ ExecuteCommandProvider *ExecuteCommandOptions `json:"executeCommandProvider,omitempty"` /*Experimental defined: * Experimental server capabilities. */ Experimental interface{} `json:"experimental,omitempty"` /*Workspace defined: * The workspace server capabilities */ Workspace *struct { // WorkspaceFolders is WorkspaceFolders *struct { /*Supported defined: * The Server has support for workspace folders */ Supported bool `json:"supported,omitempty"` /*ChangeNotifications defined: * Whether the server wants to receive workspace folder * change notifications. * * If a strings is provided the string is treated as a ID * under which the notification is registered on the client * side. The ID can be used to unregister for these events * using the `client/unregisterCapability` request. */ ChangeNotifications string `json:"changeNotifications,omitempty"` // string | boolean } `json:"workspaceFolders,omitempty"` } `json:"workspace,omitempty"` } /*InnerInitializeParams defined: * The initialize parameters */ type InnerInitializeParams struct { /*ProcessID defined: * The process Id of the parent process that started * the server. */ ProcessID float64 `json:"processId"` /*ClientInfo defined: * Information about the client * * @since 3.15.0 */ ClientInfo *struct { /*Name defined: * The name of the client as defined by the client. */ Name string `json:"name"` /*Version defined: * The client's version as defined by the client. */ Version string `json:"version,omitempty"` } `json:"clientInfo,omitempty"` /*RootPath defined: * The rootPath of the workspace. Is null * if no folder is open. * * @deprecated in favour of rootUri. */ RootPath string `json:"rootPath,omitempty"` /*RootURI defined: * The rootUri of the workspace. Is null if no * folder is open. If both `rootPath` and `rootUri` are set * `rootUri` wins. * * @deprecated in favour of workspaceFolders. */ RootURI DocumentURI `json:"rootUri"` /*Capabilities defined: * The capabilities provided by the client (editor or tool) */ Capabilities ClientCapabilities `json:"capabilities"` /*InitializationOptions defined: * User provided initialization options. */ InitializationOptions interface{} `json:"initializationOptions,omitempty"` /*Trace defined: * The initial trace setting. If omitted trace is disabled ('off'). */ Trace string `json:"trace,omitempty"` // 'off' | 'messages' | 'verbose' WorkDoneProgressParams } // InitializeParams is type InitializeParams struct { /*ProcessID defined: * The process Id of the parent process that started * the server. */ ProcessID float64 `json:"processId"` /*ClientInfo defined: * Information about the client * * @since 3.15.0 */ ClientInfo *struct { /*Name defined: * The name of the client as defined by the client. */ Name string `json:"name"` /*Version defined: * The client's version as defined by the client. */ Version string `json:"version,omitempty"` } `json:"clientInfo,omitempty"` /*RootPath defined: * The rootPath of the workspace. Is null * if no folder is open. * * @deprecated in favour of rootUri. */ RootPath string `json:"rootPath,omitempty"` /*RootURI defined: * The rootUri of the workspace. Is null if no * folder is open. If both `rootPath` and `rootUri` are set * `rootUri` wins. * * @deprecated in favour of workspaceFolders. */ RootURI DocumentURI `json:"rootUri"` /*Capabilities defined: * The capabilities provided by the client (editor or tool) */ Capabilities ClientCapabilities `json:"capabilities"` /*InitializationOptions defined: * User provided initialization options. */ InitializationOptions interface{} `json:"initializationOptions,omitempty"` /*Trace defined: * The initial trace setting. If omitted trace is disabled ('off'). */ Trace string `json:"trace,omitempty"` // 'off' | 'messages' | 'verbose' /*WorkspaceFolders defined: * The actual configured workspace folders. */ WorkspaceFolders []WorkspaceFolder `json:"workspaceFolders"` } /*InitializeResult defined: * The result returned from an initialize request. */ type InitializeResult struct { /*Capabilities defined: * The capabilities the language server provides. */ Capabilities ServerCapabilities `json:"capabilities"` /*ServerInfo defined: * Information about the server. * * @since 3.15.0 */ ServerInfo *struct { /*Name defined: * The name of the server as defined by the server. */ Name string `json:"name"` /*Version defined: * The servers's version as defined by the server. */ Version string `json:"version,omitempty"` } `json:"serverInfo,omitempty"` /*Custom defined: * Custom initialization results. */ Custom map[string]interface{} `json:"custom"` // [custom: string]: any; } // InitializedParams is type InitializedParams struct { } // DidChangeConfigurationClientCapabilities is type DidChangeConfigurationClientCapabilities struct { /*DynamicRegistration defined: * Did change configuration notification supports dynamic registration. */ DynamicRegistration bool `json:"dynamicRegistration,omitempty"` } // DidChangeConfigurationRegistrationOptions is type DidChangeConfigurationRegistrationOptions struct { // Section is Section string `json:"section,omitempty"` // string | string[] } /*DidChangeConfigurationParams defined: * The parameters of a change configuration notification. */ type DidChangeConfigurationParams struct { /*Settings defined: * The actual changed settings */ Settings interface{} `json:"settings"` } /*ShowMessageParams defined: * The parameters of a notification message. */ type ShowMessageParams struct { /*Type defined: * The message type. See {@link MessageType} */ Type MessageType `json:"type"` /*Message defined: * The actual message */ Message string `json:"message"` } // MessageActionItem is type MessageActionItem struct { /*Title defined: * A short title like 'Retry', 'Open Log' etc. */ Title string `json:"title"` } // ShowMessageRequestParams is type ShowMessageRequestParams struct { /*Type defined: * The message type. See {@link MessageType} */ Type MessageType `json:"type"` /*Message defined: * The actual message */ Message string `json:"message"` /*Actions defined: * The message action items to present. */ Actions []MessageActionItem `json:"actions,omitempty"` } /*LogMessageParams defined: * The log message parameters. */ type LogMessageParams struct { /*Type defined: * The message type. See {@link MessageType} */ Type MessageType `json:"type"` /*Message defined: * The actual message */ Message string `json:"message"` } // TextDocumentSyncClientCapabilities is type TextDocumentSyncClientCapabilities struct { /*DynamicRegistration defined: * Whether text document synchronization supports dynamic registration. */ DynamicRegistration bool `json:"dynamicRegistration,omitempty"` /*WillSave defined: * The client supports sending will save notifications. */ WillSave bool `json:"willSave,omitempty"` /*WillSaveWaitUntil defined: * The client supports sending a will save request and * waits for a response providing text edits which will * be applied to the document before it is saved. */ WillSaveWaitUntil bool `json:"willSaveWaitUntil,omitempty"` /*DidSave defined: * The client supports did save notifications. */ DidSave bool `json:"didSave,omitempty"` } // TextDocumentSyncOptions is type TextDocumentSyncOptions struct { /*OpenClose defined: * Open and close notifications are sent to the server. If omitted open close notification should not * be sent. */ OpenClose bool `json:"openClose,omitempty"` /*Change defined: * Change notifications are sent to the server. See TextDocumentSyncKind.None, TextDocumentSyncKind.Full * and TextDocumentSyncKind.Incremental. If omitted it defaults to TextDocumentSyncKind.None. */ Change TextDocumentSyncKind `json:"change,omitempty"` /*WillSave defined: * If present will save notifications are sent to the server. If omitted the notification should not be * sent. */ WillSave bool `json:"willSave,omitempty"` /*WillSaveWaitUntil defined: * If present will save wait until requests are sent to the server. If omitted the request should not be * sent. */ WillSaveWaitUntil bool `json:"willSaveWaitUntil,omitempty"` /*Save defined: * If present save notifications are sent to the server. If omitted the notification should not be * sent. */ Save *SaveOptions `json:"save,omitempty"` } /*DidOpenTextDocumentParams defined: * The parameters send in a open text document notification */ type DidOpenTextDocumentParams struct { /*TextDocument defined: * The document that was opened. */ TextDocument TextDocumentItem `json:"textDocument"` } /*DidChangeTextDocumentParams defined: * The change text document notification's parameters. */ type DidChangeTextDocumentParams struct { /*TextDocument defined: * The document that did change. The version number points * to the version after all provided content changes have * been applied. */ TextDocument VersionedTextDocumentIdentifier `json:"textDocument"` /*ContentChanges defined: * The actual content changes. The content changes describe single state changes * to the document. So if there are two content changes c1 and c2 for a document * in state S then c1 move the document to S' and c2 to S''. */ ContentChanges []TextDocumentContentChangeEvent `json:"contentChanges"` } /*TextDocumentChangeRegistrationOptions defined: * Describe options to be used when registered for text document change events. */ type TextDocumentChangeRegistrationOptions struct { /*SyncKind defined: * How documents are synced to the server. */ SyncKind TextDocumentSyncKind `json:"syncKind"` TextDocumentRegistrationOptions } /*DidCloseTextDocumentParams defined: * The parameters send in a close text document notification */ type DidCloseTextDocumentParams struct { /*TextDocument defined: * The document that was closed. */ TextDocument TextDocumentIdentifier `json:"textDocument"` } /*DidSaveTextDocumentParams defined: * The parameters send in a save text document notification */ type DidSaveTextDocumentParams struct { /*TextDocument defined: * The document that was closed. */ TextDocument VersionedTextDocumentIdentifier `json:"textDocument"` /*Text defined: * Optional the content when saved. Depends on the includeText value * when the save notification was requested. */ Text string `json:"text,omitempty"` } /*TextDocumentSaveRegistrationOptions defined: * Save registration options. */ type TextDocumentSaveRegistrationOptions struct { TextDocumentRegistrationOptions SaveOptions } /*WillSaveTextDocumentParams defined: * The parameters send in a will save text document notification. */ type WillSaveTextDocumentParams struct { /*TextDocument defined: * The document that will be saved. */ TextDocument TextDocumentIdentifier `json:"textDocument"` /*Reason defined: * The 'TextDocumentSaveReason'. */ Reason TextDocumentSaveReason `json:"reason"` } // DidChangeWatchedFilesClientCapabilities is type DidChangeWatchedFilesClientCapabilities struct { /*DynamicRegistration defined: * Did change watched files notification supports dynamic registration. Please note * that the current protocol doesn't support static configuration for file changes * from the server side. */ DynamicRegistration bool `json:"dynamicRegistration,omitempty"` } /*DidChangeWatchedFilesParams defined: * The watched files change notification's parameters. */ type DidChangeWatchedFilesParams struct { /*Changes defined: * The actual file events. */ Changes []FileEvent `json:"changes"` } /*FileEvent defined: * An event describing a file change. */ type FileEvent struct { /*URI defined: * The file's uri. */ URI DocumentURI `json:"uri"` /*Type defined: * The change type. */ Type FileChangeType `json:"type"` } /*DidChangeWatchedFilesRegistrationOptions defined: * Describe options to be used when registered for text document change events. */ type DidChangeWatchedFilesRegistrationOptions struct { /*Watchers defined: * The watchers to register. */ Watchers []FileSystemWatcher `json:"watchers"` } // FileSystemWatcher is type FileSystemWatcher struct { /*GlobPattern defined: * The glob pattern to watch. Glob patterns can have the following syntax: * - `*` to match one or more characters in a path segment * - `?` to match on one character in a path segment * - `**` to match any number of path segments, including none * - `{}` to group conditions (e.g. `**​/*.{ts,js}` matches all TypeScript and JavaScript files) * - `[]` to declare a range of characters to match in a path segment (e.g., `example.[0-9]` to match on `example.0`, `example.1`, …) * - `[!...]` to negate a range of characters to match in a path segment (e.g., `example.[!0-9]` to match on `example.a`, `example.b`, but not `example.0`) */ GlobPattern string `json:"globPattern"` /*Kind defined: * The kind of events of interest. If omitted it defaults * to WatchKind.Create | WatchKind.Change | WatchKind.Delete * which is 7. */ Kind float64 `json:"kind,omitempty"` } /*PublishDiagnosticsClientCapabilities defined: * The publish diagnostic client capabilities. */ type PublishDiagnosticsClientCapabilities struct { /*RelatedInformation defined: * Whether the clients accepts diagnostics with related information. */ RelatedInformation bool `json:"relatedInformation,omitempty"` /*TagSupport defined: * Client supports the tag property to provide meta data about a diagnostic. * Clients supporting tags have to handle unknown tags gracefully. * * @since 3.15.0 */ TagSupport *struct { /*ValueSet defined: * The tags supported by the client. */ ValueSet []DiagnosticTag `json:"valueSet"` } `json:"tagSupport,omitempty"` } /*PublishDiagnosticsParams defined: * The publish diagnostic notification's parameters. */ type PublishDiagnosticsParams struct { /*URI defined: * The URI for which diagnostic information is reported. */ URI DocumentURI `json:"uri"` /*Version defined: * Optional the version number of the document the diagnostics are published for. * * @since 3.15.0 */ Version float64 `json:"version,omitempty"` /*Diagnostics defined: * An array of diagnostic information items. */ Diagnostics []Diagnostic `json:"diagnostics"` } /*CompletionClientCapabilities defined: * Completion client capabilities */ type CompletionClientCapabilities struct { /*DynamicRegistration defined: * Whether completion supports dynamic registration. */ DynamicRegistration bool `json:"dynamicRegistration,omitempty"` /*CompletionItem defined: * The client supports the following `CompletionItem` specific * capabilities. */ CompletionItem *struct { /*SnippetSupport defined: * Client supports snippets as insert text. * * A snippet can define tab stops and placeholders with `$1`, `$2` * and `${3:foo}`. `$0` defines the final tab stop, it defaults to * the end of the snippet. Placeholders with equal identifiers are linked, * that is typing in one will update others too. */ SnippetSupport bool `json:"snippetSupport,omitempty"` /*CommitCharactersSupport defined: * Client supports commit characters on a completion item. */ CommitCharactersSupport bool `json:"commitCharactersSupport,omitempty"` /*DocumentationFormat defined: * Client supports the follow content formats for the documentation * property. The order describes the preferred format of the client. */ DocumentationFormat []MarkupKind `json:"documentationFormat,omitempty"` /*DeprecatedSupport defined: * Client supports the deprecated property on a completion item. */ DeprecatedSupport bool `json:"deprecatedSupport,omitempty"` /*PreselectSupport defined: * Client supports the preselect property on a completion item. */ PreselectSupport bool `json:"preselectSupport,omitempty"` /*TagSupport defined: * Client supports the tag property on a completion item. Clients supporting * tags have to handle unknown tags gracefully. Clients especially need to * preserve unknown tags when sending a completion item back to the server in * a resolve call. * * @since 3.15.0 */ TagSupport *struct { /*ValueSet defined: * The tags supported by the client. */ ValueSet []CompletionItemTag `json:"valueSet"` } `json:"tagSupport,omitempty"` } `json:"completionItem,omitempty"` // CompletionItemKind is CompletionItemKind *struct { /*ValueSet defined: * The completion item kind values the client supports. When this * property exists the client also guarantees that it will * handle values outside its set gracefully and falls back * to a default value when unknown. * * If this property is not present the client only supports * the completion items kinds from `Text` to `Reference` as defined in * the initial version of the protocol. */ ValueSet []CompletionItemKind `json:"valueSet,omitempty"` } `json:"completionItemKind,omitempty"` /*ContextSupport defined: * The client supports to send additional context information for a * `textDocument/completion` requestion. */ ContextSupport bool `json:"contextSupport,omitempty"` } /*CompletionContext defined: * Contains additional information about the context in which a completion request is triggered. */ type CompletionContext struct { /*TriggerKind defined: * How the completion was triggered. */ TriggerKind CompletionTriggerKind `json:"triggerKind"` /*TriggerCharacter defined: * The trigger character (a single character) that has trigger code complete. * Is undefined if `triggerKind !== CompletionTriggerKind.TriggerCharacter` */ TriggerCharacter string `json:"triggerCharacter,omitempty"` } /*CompletionParams defined: * Completion parameters */ type CompletionParams struct { /*Context defined: * The completion context. This is only available it the client specifies * to send this using the client capability `textDocument.completion.contextSupport === true` */ Context *CompletionContext `json:"context,omitempty"` TextDocumentPositionParams WorkDoneProgressParams PartialResultParams } /*CompletionOptions defined: * Completion options. */ type CompletionOptions struct { /*TriggerCharacters defined: * Most tools trigger completion request automatically without explicitly requesting * it using a keyboard shortcut (e.g. Ctrl+Space). Typically they do so when the user * starts to type an identifier. For example if the user types `c` in a JavaScript file * code complete will automatically pop up present `console` besides others as a * completion item. Characters that make up identifiers don't need to be listed here. * * If code complete should automatically be trigger on characters not being valid inside * an identifier (for example `.` in JavaScript) list them in `triggerCharacters`. */ TriggerCharacters []string `json:"triggerCharacters,omitempty"` /*AllCommitCharacters defined: * The list of all possible characters that commit a completion. This field can be used * if clients don't support individual commit characters per completion item. See * `ClientCapabilities.textDocument.completion.completionItem.commitCharactersSupport` * * @since 3.2.0 */ AllCommitCharacters []string `json:"allCommitCharacters,omitempty"` /*ResolveProvider defined: * The server provides support to resolve additional * information for a completion item. */ ResolveProvider bool `json:"resolveProvider,omitempty"` WorkDoneProgressOptions } /*CompletionRegistrationOptions defined: * Registration options for a [CompletionRequest](#CompletionRequest). */ type CompletionRegistrationOptions struct { TextDocumentRegistrationOptions CompletionOptions } // HoverClientCapabilities is type HoverClientCapabilities struct { /*DynamicRegistration defined: * Whether hover supports dynamic registration. */ DynamicRegistration bool `json:"dynamicRegistration,omitempty"` /*ContentFormat defined: * Client supports the follow content formats for the content * property. The order describes the preferred format of the client. */ ContentFormat []MarkupKind `json:"contentFormat,omitempty"` } /*HoverOptions defined: * Hover options. */ type HoverOptions struct { WorkDoneProgressOptions } /*HoverParams defined: * Parameters for a [HoverRequest](#HoverRequest). */ type HoverParams struct { TextDocumentPositionParams WorkDoneProgressParams } /*HoverRegistrationOptions defined: * Registration options for a [HoverRequest](#HoverRequest). */ type HoverRegistrationOptions struct { TextDocumentRegistrationOptions HoverOptions } /*SignatureHelpClientCapabilities defined: * Client Capabilities for a [SignatureHelpRequest](#SignatureHelpRequest). */ type SignatureHelpClientCapabilities struct { /*DynamicRegistration defined: * Whether signature help supports dynamic registration. */ DynamicRegistration bool `json:"dynamicRegistration,omitempty"` /*SignatureInformation defined: * The client supports the following `SignatureInformation` * specific properties. */ SignatureInformation *struct { /*DocumentationFormat defined: * Client supports the follow content formats for the documentation * property. The order describes the preferred format of the client. */ DocumentationFormat []MarkupKind `json:"documentationFormat,omitempty"` /*ParameterInformation defined: * Client capabilities specific to parameter information. */ ParameterInformation *struct { /*LabelOffsetSupport defined: * The client supports processing label offsets instead of a * simple label string. * * @since 3.14.0 */ LabelOffsetSupport bool `json:"labelOffsetSupport,omitempty"` } `json:"parameterInformation,omitempty"` } `json:"signatureInformation,omitempty"` /*ContextSupport defined: * The client supports to send additional context information for a * `textDocument/signatureHelp` request. A client that opts into * contextSupport will also support the `retriggerCharacters` on * `SignatureHelpOptions`. * * @since 3.15.0 */ ContextSupport bool `json:"contextSupport,omitempty"` } /*SignatureHelpOptions defined: * Server Capabilities for a [SignatureHelpRequest](#SignatureHelpRequest). */ type SignatureHelpOptions struct { /*TriggerCharacters defined: * List of characters that trigger signature help. */ TriggerCharacters []string `json:"triggerCharacters,omitempty"` /*RetriggerCharacters defined: * List of characters that re-trigger signature help. * * These trigger characters are only active when signature help is already showing. All trigger characters * are also counted as re-trigger characters. * * @since 3.15.0 */ RetriggerCharacters []string `json:"retriggerCharacters,omitempty"` WorkDoneProgressOptions } /*SignatureHelpContext defined: * Additional information about the context in which a signature help request was triggered. * * @since 3.15.0 */ type SignatureHelpContext struct { /*TriggerKind defined: * Action that caused signature help to be triggered. */ TriggerKind SignatureHelpTriggerKind `json:"triggerKind"` /*TriggerCharacter defined: * Character that caused signature help to be triggered. * * This is undefined when `triggerKind !== SignatureHelpTriggerKind.TriggerCharacter` */ TriggerCharacter string `json:"triggerCharacter,omitempty"` /*IsRetrigger defined: * `true` if signature help was already showing when it was triggered. * * Retriggers occur when the signature help is already active and can be caused by actions such as * typing a trigger character, a cursor move, or document content changes. */ IsRetrigger bool `json:"isRetrigger"` /*ActiveSignatureHelp defined: * The currently active `SignatureHelp`. * * The `activeSignatureHelp` has its `SignatureHelp.activeSignature` field updated based on * the user navigating through available signatures. */ ActiveSignatureHelp *SignatureHelp `json:"activeSignatureHelp,omitempty"` } /*SignatureHelpParams defined: * Parameters for a [SignatureHelpRequest](#SignatureHelpRequest). */ type SignatureHelpParams struct { /*Context defined: * The signature help context. This is only available if the client specifies * to send this using the client capability `textDocument.signatureHelp.contextSupport === true` * * @since 3.15.0 */ Context *SignatureHelpContext `json:"context,omitempty"` TextDocumentPositionParams WorkDoneProgressParams } /*SignatureHelpRegistrationOptions defined: * Registration options for a [SignatureHelpRequest](#SignatureHelpRequest). */ type SignatureHelpRegistrationOptions struct { TextDocumentRegistrationOptions SignatureHelpOptions } /*DefinitionClientCapabilities defined: * Client Capabilities for a [DefinitionRequest](#DefinitionRequest). */ type DefinitionClientCapabilities struct { /*DynamicRegistration defined: * Whether definition supports dynamic registration. */ DynamicRegistration bool `json:"dynamicRegistration,omitempty"` /*LinkSupport defined: * The client supports additional metadata in the form of definition links. * * @since 3.14.0 */ LinkSupport bool `json:"linkSupport,omitempty"` } /*DefinitionOptions defined: * Server Capabilities for a [DefinitionRequest](#DefinitionRequest). */ type DefinitionOptions struct { WorkDoneProgressOptions } /*DefinitionParams defined: * Parameters for a [DefinitionRequest](#DefinitionRequest). */ type DefinitionParams struct { TextDocumentPositionParams WorkDoneProgressParams PartialResultParams } /*DefinitionRegistrationOptions defined: * Registration options for a [DefinitionRequest](#DefinitionRequest). */ type DefinitionRegistrationOptions struct { TextDocumentRegistrationOptions DefinitionOptions } /*ReferenceClientCapabilities defined: * Client Capabilities for a [ReferencesRequest](#ReferencesRequest). */ type ReferenceClientCapabilities struct { /*DynamicRegistration defined: * Whether references supports dynamic registration. */ DynamicRegistration bool `json:"dynamicRegistration,omitempty"` } /*ReferenceParams defined: * Parameters for a [ReferencesRequest](#ReferencesRequest). */ type ReferenceParams struct { // Context is Context ReferenceContext `json:"context"` TextDocumentPositionParams WorkDoneProgressParams PartialResultParams } /*ReferenceOptions defined: * Reference options. */ type ReferenceOptions struct { WorkDoneProgressOptions } /*ReferenceRegistrationOptions defined: * Registration options for a [ReferencesRequest](#ReferencesRequest). */ type ReferenceRegistrationOptions struct { TextDocumentRegistrationOptions ReferenceOptions } /*DocumentHighlightClientCapabilities defined: * Client Capabilities for a [DocumentHighlightRequest](#DocumentHighlightRequest). */ type DocumentHighlightClientCapabilities struct { /*DynamicRegistration defined: * Whether document highlight supports dynamic registration. */ DynamicRegistration bool `json:"dynamicRegistration,omitempty"` } /*DocumentHighlightParams defined: * Parameters for a [DocumentHighlightRequest](#DocumentHighlightRequest). */ type DocumentHighlightParams struct { TextDocumentPositionParams WorkDoneProgressParams PartialResultParams } /*DocumentHighlightOptions defined: * Provider options for a [DocumentHighlightRequest](#DocumentHighlightRequest). */ type DocumentHighlightOptions struct { WorkDoneProgressOptions } /*DocumentHighlightRegistrationOptions defined: * Registration options for a [DocumentHighlightRequest](#DocumentHighlightRequest). */ type DocumentHighlightRegistrationOptions struct { TextDocumentRegistrationOptions DocumentHighlightOptions } /*DocumentSymbolClientCapabilities defined: * Client Capabilities for a [DocumentSymbolRequest](#DocumentSymbolRequest). */ type DocumentSymbolClientCapabilities struct { /*DynamicRegistration defined: * Whether document symbol supports dynamic registration. */ DynamicRegistration bool `json:"dynamicRegistration,omitempty"` /*SymbolKind defined: * Specific capabilities for the `SymbolKind`. */ SymbolKind *struct { /*ValueSet defined: * The symbol kind values the client supports. When this * property exists the client also guarantees that it will * handle values outside its set gracefully and falls back * to a default value when unknown. * * If this property is not present the client only supports * the symbol kinds from `File` to `Array` as defined in * the initial version of the protocol. */ ValueSet []SymbolKind `json:"valueSet,omitempty"` } `json:"symbolKind,omitempty"` /*HierarchicalDocumentSymbolSupport defined: * The client support hierarchical document symbols. */ HierarchicalDocumentSymbolSupport bool `json:"hierarchicalDocumentSymbolSupport,omitempty"` } /*DocumentSymbolParams defined: * Parameters for a [DocumentSymbolRequest](#DocumentSymbolRequest). */ type DocumentSymbolParams struct { /*TextDocument defined: * The text document. */ TextDocument TextDocumentIdentifier `json:"textDocument"` WorkDoneProgressParams PartialResultParams } /*DocumentSymbolOptions defined: * Provider options for a [DocumentSymbolRequest](#DocumentSymbolRequest). */ type DocumentSymbolOptions struct { WorkDoneProgressOptions } /*DocumentSymbolRegistrationOptions defined: * Registration options for a [DocumentSymbolRequest](#DocumentSymbolRequest). */ type DocumentSymbolRegistrationOptions struct { TextDocumentRegistrationOptions DocumentSymbolOptions } /*CodeActionClientCapabilities defined: * The Client Capabilities of a [CodeActionRequest](#CodeActionRequest). */ type CodeActionClientCapabilities struct { /*DynamicRegistration defined: * Whether code action supports dynamic registration. */ DynamicRegistration bool `json:"dynamicRegistration,omitempty"` /*CodeActionLiteralSupport defined: * The client support code action literals as a valid * response of the `textDocument/codeAction` request. * * @since 3.8.0 */ CodeActionLiteralSupport *struct { /*CodeActionKind defined: * The code action kind is support with the following value * set. */ CodeActionKind struct { /*ValueSet defined: * The code action kind values the client supports. When this * property exists the client also guarantees that it will * handle values outside its set gracefully and falls back * to a default value when unknown. */ ValueSet []CodeActionKind `json:"valueSet"` } `json:"codeActionKind"` } `json:"codeActionLiteralSupport,omitempty"` /*IsPreferredSupport defined: * Whether code action supports the `isPreferred` property. * @since 3.15.0 */ IsPreferredSupport bool `json:"isPreferredSupport,omitempty"` } /*CodeActionParams defined: * The parameters of a [CodeActionRequest](#CodeActionRequest). */ type CodeActionParams struct { /*TextDocument defined: * The document in which the command was invoked. */ TextDocument TextDocumentIdentifier `json:"textDocument"` /*Range defined: * The range for which the command was invoked. */ Range Range `json:"range"` /*Context defined: * Context carrying additional information. */ Context CodeActionContext `json:"context"` WorkDoneProgressParams PartialResultParams } /*CodeActionOptions defined: * Provider options for a [CodeActionRequest](#CodeActionRequest). */ type CodeActionOptions struct { /*CodeActionKinds defined: * CodeActionKinds that this server may return. * * The list of kinds may be generic, such as `CodeActionKind.Refactor`, or the server * may list out every specific kind they provide. */ CodeActionKinds []CodeActionKind `json:"codeActionKinds,omitempty"` WorkDoneProgressOptions } /*CodeActionRegistrationOptions defined: * Registration options for a [CodeActionRequest](#CodeActionRequest). */ type CodeActionRegistrationOptions struct { TextDocumentRegistrationOptions CodeActionOptions } /*WorkspaceSymbolClientCapabilities defined: * Client capabilities for a [WorkspaceSymbolRequest](#WorkspaceSymbolRequest). */ type WorkspaceSymbolClientCapabilities struct { /*DynamicRegistration defined: * Symbol request supports dynamic registration. */ DynamicRegistration bool `json:"dynamicRegistration,omitempty"` /*SymbolKind defined: * Specific capabilities for the `SymbolKind` in the `workspace/symbol` request. */ SymbolKind *struct { /*ValueSet defined: * The symbol kind values the client supports. When this * property exists the client also guarantees that it will * handle values outside its set gracefully and falls back * to a default value when unknown. * * If this property is not present the client only supports * the symbol kinds from `File` to `Array` as defined in * the initial version of the protocol. */ ValueSet []SymbolKind `json:"valueSet,omitempty"` } `json:"symbolKind,omitempty"` } /*WorkspaceSymbolParams defined: * The parameters of a [WorkspaceSymbolRequest](#WorkspaceSymbolRequest). */ type WorkspaceSymbolParams struct { /*Query defined: * A query string to filter symbols by. Clients may send an empty * string here to request all symbols. */ Query string `json:"query"` WorkDoneProgressParams PartialResultParams } /*WorkspaceSymbolOptions defined: * Server capabilities for a [WorkspaceSymbolRequest](#WorkspaceSymbolRequest). */ type WorkspaceSymbolOptions struct { WorkDoneProgressOptions } /*WorkspaceSymbolRegistrationOptions defined: * Registration options for a [WorkspaceSymbolRequest](#WorkspaceSymbolRequest). */ type WorkspaceSymbolRegistrationOptions struct { WorkspaceSymbolOptions } /*CodeLensClientCapabilities defined: * The client capabilities of a [CodeLensRequest](#CodeLensRequest). */ type CodeLensClientCapabilities struct { /*DynamicRegistration defined: * Whether code lens supports dynamic registration. */ DynamicRegistration bool `json:"dynamicRegistration,omitempty"` } /*CodeLensParams defined: * The parameters of a [CodeLensRequest](#CodeLensRequest). */ type CodeLensParams struct { /*TextDocument defined: * The document to request code lens for. */ TextDocument TextDocumentIdentifier `json:"textDocument"` WorkDoneProgressParams PartialResultParams } /*CodeLensOptions defined: * Code Lens provider options of a [CodeLensRequest](#CodeLensRequest). */ type CodeLensOptions struct { /*ResolveProvider defined: * Code lens has a resolve provider as well. */ ResolveProvider bool `json:"resolveProvider,omitempty"` WorkDoneProgressOptions } /*CodeLensRegistrationOptions defined: * Registration options for a [CodeLensRequest](#CodeLensRequest). */ type CodeLensRegistrationOptions struct { TextDocumentRegistrationOptions CodeLensOptions } /*DocumentLinkClientCapabilities defined: * The client capabilities of a [DocumentLinkRequest](#DocumentLinkRequest). */ type DocumentLinkClientCapabilities struct { /*DynamicRegistration defined: * Whether document link supports dynamic registration. */ DynamicRegistration bool `json:"dynamicRegistration,omitempty"` /*TooltipSupport defined: * Whether the client support the `tooltip` property on `DocumentLink`. * * @since 3.15.0 */ TooltipSupport bool `json:"tooltipSupport,omitempty"` } /*DocumentLinkParams defined: * The parameters of a [DocumentLinkRequest](#DocumentLinkRequest). */ type DocumentLinkParams struct { /*TextDocument defined: * The document to provide document links for. */ TextDocument TextDocumentIdentifier `json:"textDocument"` WorkDoneProgressParams PartialResultParams } /*DocumentLinkOptions defined: * Provider options for a [DocumentLinkRequest](#DocumentLinkRequest). */ type DocumentLinkOptions struct { /*ResolveProvider defined: * Document links have a resolve provider as well. */ ResolveProvider bool `json:"resolveProvider,omitempty"` WorkDoneProgressOptions } /*DocumentLinkRegistrationOptions defined: * Registration options for a [DocumentLinkRequest](#DocumentLinkRequest). */ type DocumentLinkRegistrationOptions struct { TextDocumentRegistrationOptions DocumentLinkOptions } /*DocumentFormattingClientCapabilities defined: * Client capabilities of a [DocumentFormattingRequest](#DocumentFormattingRequest). */ type DocumentFormattingClientCapabilities struct { /*DynamicRegistration defined: * Whether formatting supports dynamic registration. */ DynamicRegistration bool `json:"dynamicRegistration,omitempty"` } /*DocumentFormattingParams defined: * The parameters of a [DocumentFormattingRequest](#DocumentFormattingRequest). */ type DocumentFormattingParams struct { /*TextDocument defined: * The document to format. */ TextDocument TextDocumentIdentifier `json:"textDocument"` /*Options defined: * The format options */ Options FormattingOptions `json:"options"` WorkDoneProgressParams } /*DocumentFormattingOptions defined: * Provider options for a [DocumentFormattingRequest](#DocumentFormattingRequest). */ type DocumentFormattingOptions struct { WorkDoneProgressOptions } /*DocumentFormattingRegistrationOptions defined: * Registration options for a [DocumentFormattingRequest](#DocumentFormattingRequest). */ type DocumentFormattingRegistrationOptions struct { TextDocumentRegistrationOptions DocumentFormattingOptions } /*DocumentRangeFormattingClientCapabilities defined: * Client capabilities of a [DocumentRangeFormattingRequest](#DocumentRangeFormattingRequest). */ type DocumentRangeFormattingClientCapabilities struct { /*DynamicRegistration defined: * Whether range formatting supports dynamic registration. */ DynamicRegistration bool `json:"dynamicRegistration,omitempty"` } /*DocumentRangeFormattingParams defined: * The parameters of a [DocumentRangeFormattingRequest](#DocumentRangeFormattingRequest). */ type DocumentRangeFormattingParams struct { /*TextDocument defined: * The document to format. */ TextDocument TextDocumentIdentifier `json:"textDocument"` /*Range defined: * The range to format */ Range Range `json:"range"` /*Options defined: * The format options */ Options FormattingOptions `json:"options"` WorkDoneProgressParams } /*DocumentRangeFormattingOptions defined: * Provider options for a [DocumentRangeFormattingRequest](#DocumentRangeFormattingRequest). */ type DocumentRangeFormattingOptions struct { WorkDoneProgressOptions } /*DocumentRangeFormattingRegistrationOptions defined: * Registration options for a [DocumentRangeFormattingRequest](#DocumentRangeFormattingRequest). */ type DocumentRangeFormattingRegistrationOptions struct { TextDocumentRegistrationOptions DocumentRangeFormattingOptions } /*DocumentOnTypeFormattingClientCapabilities defined: * Client capabilities of a [DocumentOnTypeFormattingRequest](#DocumentOnTypeFormattingRequest). */ type DocumentOnTypeFormattingClientCapabilities struct { /*DynamicRegistration defined: * Whether on type formatting supports dynamic registration. */ DynamicRegistration bool `json:"dynamicRegistration,omitempty"` } /*DocumentOnTypeFormattingParams defined: * The parameters of a [DocumentOnTypeFormattingRequest](#DocumentOnTypeFormattingRequest). */ type DocumentOnTypeFormattingParams struct { /*TextDocument defined: * The document to format. */ TextDocument TextDocumentIdentifier `json:"textDocument"` /*Position defined: * The position at which this request was send. */ Position Position `json:"position"` /*Ch defined: * The character that has been typed. */ Ch string `json:"ch"` /*Options defined: * The format options. */ Options FormattingOptions `json:"options"` } /*DocumentOnTypeFormattingOptions defined: * Provider options for a [DocumentOnTypeFormattingRequest](#DocumentOnTypeFormattingRequest). */ type DocumentOnTypeFormattingOptions struct { /*FirstTriggerCharacter defined: * A character on which formatting should be triggered, like `}`. */ FirstTriggerCharacter string `json:"firstTriggerCharacter"` /*MoreTriggerCharacter defined: * More trigger characters. */ MoreTriggerCharacter []string `json:"moreTriggerCharacter,omitempty"` } /*DocumentOnTypeFormattingRegistrationOptions defined: * Registration options for a [DocumentOnTypeFormattingRequest](#DocumentOnTypeFormattingRequest). */ type DocumentOnTypeFormattingRegistrationOptions struct { TextDocumentRegistrationOptions DocumentOnTypeFormattingOptions } // RenameClientCapabilities is type RenameClientCapabilities struct { /*DynamicRegistration defined: * Whether rename supports dynamic registration. */ DynamicRegistration bool `json:"dynamicRegistration,omitempty"` /*PrepareSupport defined: * Client supports testing for validity of rename operations * before execution. * * @since version 3.12.0 */ PrepareSupport bool `json:"prepareSupport,omitempty"` } /*RenameParams defined: * The parameters of a [RenameRequest](#RenameRequest). */ type RenameParams struct { /*TextDocument defined: * The document to rename. */ TextDocument TextDocumentIdentifier `json:"textDocument"` /*Position defined: * The position at which this request was sent. */ Position Position `json:"position"` /*NewName defined: * The new name of the symbol. If the given name is not valid the * request must return a [ResponseError](#ResponseError) with an * appropriate message set. */ NewName string `json:"newName"` WorkDoneProgressParams } /*RenameOptions defined: * Provider options for a [RenameRequest](#RenameRequest). */ type RenameOptions struct { /*PrepareProvider defined: * Renames should be checked and tested before being executed. * * @since version 3.12.0 */ PrepareProvider bool `json:"prepareProvider,omitempty"` WorkDoneProgressOptions } /*RenameRegistrationOptions defined: * Registration options for a [RenameRequest](#RenameRequest). */ type RenameRegistrationOptions struct { TextDocumentRegistrationOptions RenameOptions } // PrepareRenameParams is type PrepareRenameParams struct { TextDocumentPositionParams WorkDoneProgressParams } /*ExecuteCommandClientCapabilities defined: * The client capabilities of a [ExecuteCommandRequest](#ExecuteCommandRequest). */ type ExecuteCommandClientCapabilities struct { /*DynamicRegistration defined: * Execute command supports dynamic registration. */ DynamicRegistration bool `json:"dynamicRegistration,omitempty"` } /*ExecuteCommandParams defined: * The parameters of a [ExecuteCommandRequest](#ExecuteCommandRequest). */ type ExecuteCommandParams struct { /*Command defined: * The identifier of the actual command handler. */ Command string `json:"command"` /*Arguments defined: * Arguments that the command should be invoked with. */ Arguments []interface{} `json:"arguments,omitempty"` WorkDoneProgressParams } /*ExecuteCommandOptions defined: * The server capabilities of a [ExecuteCommandRequest](#ExecuteCommandRequest). */ type ExecuteCommandOptions struct { /*Commands defined: * The commands to be executed on the server */ Commands []string `json:"commands"` WorkDoneProgressOptions } /*ExecuteCommandRegistrationOptions defined: * Registration options for a [ExecuteCommandRequest](#ExecuteCommandRequest). */ type ExecuteCommandRegistrationOptions struct { ExecuteCommandOptions } // WorkspaceEditClientCapabilities is type WorkspaceEditClientCapabilities struct { /*DocumentChanges defined: * The client supports versioned document changes in `WorkspaceEdit`s */ DocumentChanges bool `json:"documentChanges,omitempty"` /*ResourceOperations defined: * The resource operations the client supports. Clients should at least * support 'create', 'rename' and 'delete' files and folders. * * @since 3.13.0 */ ResourceOperations []ResourceOperationKind `json:"resourceOperations,omitempty"` /*FailureHandling defined: * The failure handling strategy of a client if applying the workspace edit * fails. * * @since 3.13.0 */ FailureHandling FailureHandlingKind `json:"failureHandling,omitempty"` } /*ApplyWorkspaceEditParams defined: * The parameters passed via a apply workspace edit request. */ type ApplyWorkspaceEditParams struct { /*Label defined: * An optional label of the workspace edit. This label is * presented in the user interface for example on an undo * stack to undo the workspace edit. */ Label string `json:"label,omitempty"` /*Edit defined: * The edits to apply. */ Edit WorkspaceEdit `json:"edit"` } /*ApplyWorkspaceEditResponse defined: * A response returned from the apply workspace edit request. */ type ApplyWorkspaceEditResponse struct { /*Applied defined: * Indicates whether the edit was applied or not. */ Applied bool `json:"applied"` /*FailureReason defined: * An optional textual description for why the edit was not applied. * This may be used by the server for diagnostic logging or to provide * a suitable error for a request that triggered the edit. */ FailureReason string `json:"failureReason,omitempty"` /*FailedChange defined: * Depending on the client's failure handling strategy `failedChange` might * contain the index of the change that failed. This property is only available * if the client signals a `failureHandlingStrategy` in its client capabilities. */ FailedChange float64 `json:"failedChange,omitempty"` } /*Position defined: * Position in a text document expressed as zero-based line and character offset. * The offsets are based on a UTF-16 string representation. So a string of the form * `a𐐀b` the character offset of the character `a` is 0, the character offset of `𐐀` * is 1 and the character offset of b is 3 since `𐐀` is represented using two code * units in UTF-16. * * Positions are line end character agnostic. So you can not specify a position that * denotes `\r|\n` or `\n|` where `|` represents the character offset. */ type Position struct { /*Line defined: * Line position in a document (zero-based). * If a line number is greater than the number of lines in a document, it defaults back to the number of lines in the document. * If a line number is negative, it defaults to 0. */ Line float64 `json:"line"` /*Character defined: * Character offset on a line in a document (zero-based). Assuming that the line is * represented as a string, the `character` value represents the gap between the * `character` and `character + 1`. * * If the character value is greater than the line length it defaults back to the * line length. * If a line number is negative, it defaults to 0. */ Character float64 `json:"character"` } /*Range defined: * A range in a text document expressed as (zero-based) start and end positions. * * If you want to specify a range that contains a line including the line ending * character(s) then use an end position denoting the start of the next line. * For example: * ```ts * { * start: { line: 5, character: 23 } * end : { line 6, character : 0 } * } * ``` */ type Range struct { /*Start defined: * The range's start position */ Start Position `json:"start"` /*End defined: * The range's end position. */ End Position `json:"end"` } /*Location defined: * Represents a location inside a resource, such as a line * inside a text file. */ type Location struct { // URI is URI DocumentURI `json:"uri"` // Range is Range Range `json:"range"` } /*LocationLink defined: * Represents the connection of two locations. Provides additional metadata over normal [locations](#Location), * including an origin range. */ type LocationLink struct { /*OriginSelectionRange defined: * Span of the origin of this link. * * Used as the underlined span for mouse definition hover. Defaults to the word range at * the definition position. */ OriginSelectionRange *Range `json:"originSelectionRange,omitempty"` /*TargetURI defined: * The target resource identifier of this link. */ TargetURI DocumentURI `json:"targetUri"` /*TargetRange defined: * The full target range of this link. If the target for example is a symbol then target range is the * range enclosing this symbol not including leading/trailing whitespace but everything else * like comments. This information is typically used to highlight the range in the editor. */ TargetRange Range `json:"targetRange"` /*TargetSelectionRange defined: * The range that should be selected and revealed when this link is being followed, e.g the name of a function. * Must be contained by the `targetRange`. See also `DocumentSymbol#range` */ TargetSelectionRange Range `json:"targetSelectionRange"` } /*Color defined: * Represents a color in RGBA space. */ type Color struct { /*Red defined: * The red component of this color in the range [0-1]. */ Red float64 `json:"red"` /*Green defined: * The green component of this color in the range [0-1]. */ Green float64 `json:"green"` /*Blue defined: * The blue component of this color in the range [0-1]. */ Blue float64 `json:"blue"` /*Alpha defined: * The alpha component of this color in the range [0-1]. */ Alpha float64 `json:"alpha"` } /*ColorInformation defined: * Represents a color range from a document. */ type ColorInformation struct { /*Range defined: * The range in the document where this color appears. */ Range Range `json:"range"` /*Color defined: * The actual color value for this color range. */ Color Color `json:"color"` } // ColorPresentation is type ColorPresentation struct { /*Label defined: * The label of this color presentation. It will be shown on the color * picker header. By default this is also the text that is inserted when selecting * this color presentation. */ Label string `json:"label"` /*TextEdit defined: * An [edit](#TextEdit) which is applied to a document when selecting * this presentation for the color. When `falsy` the [label](#ColorPresentation.label) * is used. */ TextEdit *TextEdit `json:"textEdit,omitempty"` /*AdditionalTextEdits defined: * An optional array of additional [text edits](#TextEdit) that are applied when * selecting this color presentation. Edits must not overlap with the main [edit](#ColorPresentation.textEdit) nor with themselves. */ AdditionalTextEdits []TextEdit `json:"additionalTextEdits,omitempty"` } /*DiagnosticRelatedInformation defined: * Represents a related message and source code location for a diagnostic. This should be * used to point to code locations that cause or related to a diagnostics, e.g when duplicating * a symbol in a scope. */ type DiagnosticRelatedInformation struct { /*Location defined: * The location of this related diagnostic information. */ Location Location `json:"location"` /*Message defined: * The message of this related diagnostic information. */ Message string `json:"message"` } /*Diagnostic defined: * Represents a diagnostic, such as a compiler error or warning. Diagnostic objects * are only valid in the scope of a resource. */ type Diagnostic struct { /*Range defined: * The range at which the message applies */ Range Range `json:"range"` /*Severity defined: * The diagnostic's severity. Can be omitted. If omitted it is up to the * client to interpret diagnostics as error, warning, info or hint. */ Severity DiagnosticSeverity `json:"severity,omitempty"` /*Code defined: * The diagnostic's code, which usually appear in the user interface. */ Code interface{} `json:"code,omitempty"` // number | string /*Source defined: * A human-readable string describing the source of this * diagnostic, e.g. 'typescript' or 'super lint'. It usually * appears in the user interface. */ Source string `json:"source,omitempty"` /*Message defined: * The diagnostic's message. It usually appears in the user interface */ Message string `json:"message"` /*Tags defined: * Additional metadata about the diagnostic. */ Tags []DiagnosticTag `json:"tags,omitempty"` /*RelatedInformation defined: * An array of related diagnostic information, e.g. when symbol-names within * a scope collide all definitions can be marked via this property. */ RelatedInformation []DiagnosticRelatedInformation `json:"relatedInformation,omitempty"` } /*Command defined: * Represents a reference to a command. Provides a title which * will be used to represent a command in the UI and, optionally, * an array of arguments which will be passed to the command handler * function when invoked. */ type Command struct { /*Title defined: * Title of the command, like `save`. */ Title string `json:"title"` /*Command defined: * The identifier of the actual command handler. */ Command string `json:"command"` /*Arguments defined: * Arguments that the command handler should be * invoked with. */ Arguments []interface{} `json:"arguments,omitempty"` } /*TextEdit defined: * A text edit applicable to a text document. */ type TextEdit struct { /*Range defined: * The range of the text document to be manipulated. To insert * text into a document create a range where start === end. */ Range Range `json:"range"` /*NewText defined: * The string to be inserted. For delete operations use an * empty string. */ NewText string `json:"newText"` } /*TextDocumentEdit defined: * Describes textual changes on a text document. */ type TextDocumentEdit struct { /*TextDocument defined: * The text document to change. */ TextDocument VersionedTextDocumentIdentifier `json:"textDocument"` /*Edits defined: * The edits to be applied. */ Edits []TextEdit `json:"edits"` } // ResourceOperation is type ResourceOperation struct { // Kind is Kind string `json:"kind"` } /*CreateFileOptions defined: * Options to create a file. */ type CreateFileOptions struct { /*Overwrite defined: * Overwrite existing file. Overwrite wins over `ignoreIfExists` */ Overwrite bool `json:"overwrite,omitempty"` /*IgnoreIfExists defined: * Ignore if exists. */ IgnoreIfExists bool `json:"ignoreIfExists,omitempty"` } /*CreateFile defined: * Create file operation. */ type CreateFile struct { /*Kind defined: * A create */ Kind string `json:"kind"` // 'create' /*URI defined: * The resource to create. */ URI DocumentURI `json:"uri"` /*Options defined: * Additional options */ Options *CreateFileOptions `json:"options,omitempty"` } /*RenameFileOptions defined: * Rename file options */ type RenameFileOptions struct { /*Overwrite defined: * Overwrite target if existing. Overwrite wins over `ignoreIfExists` */ Overwrite bool `json:"overwrite,omitempty"` /*IgnoreIfExists defined: * Ignores if target exists. */ IgnoreIfExists bool `json:"ignoreIfExists,omitempty"` } /*RenameFile defined: * Rename file operation */ type RenameFile struct { /*Kind defined: * A rename */ Kind string `json:"kind"` // 'rename' /*OldURI defined: * The old (existing) location. */ OldURI DocumentURI `json:"oldUri"` /*NewURI defined: * The new location. */ NewURI DocumentURI `json:"newUri"` /*Options defined: * Rename options. */ Options *RenameFileOptions `json:"options,omitempty"` } /*DeleteFileOptions defined: * Delete file options */ type DeleteFileOptions struct { /*Recursive defined: * Delete the content recursively if a folder is denoted. */ Recursive bool `json:"recursive,omitempty"` /*IgnoreIfNotExists defined: * Ignore the operation if the file doesn't exist. */ IgnoreIfNotExists bool `json:"ignoreIfNotExists,omitempty"` } /*DeleteFile defined: * Delete file operation */ type DeleteFile struct { /*Kind defined: * A delete */ Kind string `json:"kind"` // 'delete' /*URI defined: * The file to delete. */ URI DocumentURI `json:"uri"` /*Options defined: * Delete options. */ Options *DeleteFileOptions `json:"options,omitempty"` } /*WorkspaceEdit defined: * A workspace edit represents changes to many resources managed in the workspace. The edit * should either provide `changes` or `documentChanges`. If documentChanges are present * they are preferred over `changes` if the client can handle versioned document edits. */ type WorkspaceEdit struct { /*Changes defined: * Holds changes to existing resources. */ Changes *map[string][]TextEdit `json:"changes,omitempty"` // [uri: string]: TextEdit[]; /*DocumentChanges defined: * Depending on the client capability `workspace.workspaceEdit.resourceOperations` document changes * are either an array of `TextDocumentEdit`s to express changes to n different text documents * where each text document edit addresses a specific version of a text document. Or it can contain * above `TextDocumentEdit`s mixed with create, rename and delete file / folder operations. * * Whether a client supports versioned document edits is expressed via * `workspace.workspaceEdit.documentChanges` client capability. * * If a client neither supports `documentChanges` nor `workspace.workspaceEdit.resourceOperations` then * only plain `TextEdit`s using the `changes` property are supported. */ DocumentChanges []TextDocumentEdit `json:"documentChanges,omitempty"` // (TextDocumentEdit | CreateFile | RenameFile | DeleteFile) } /*TextEditChange defined: * A change to capture text edits for existing resources. */ type TextEditChange struct { } /*TextDocumentIdentifier defined: * A literal to identify a text document in the client. */ type TextDocumentIdentifier struct { /*URI defined: * The text document's uri. */ URI DocumentURI `json:"uri"` } /*VersionedTextDocumentIdentifier defined: * An identifier to denote a specific version of a text document. */ type VersionedTextDocumentIdentifier struct { /*Version defined: * The version number of this document. If a versioned text document identifier * is sent from the server to the client and the file is not open in the editor * (the server has not received an open notification before) the server can send * `null` to indicate that the version is unknown and the content on disk is the * truth (as speced with document content ownership). */ Version float64 `json:"version"` TextDocumentIdentifier } /*TextDocumentItem defined: * An item to transfer a text document from the client to the * server. */ type TextDocumentItem struct { /*URI defined: * The text document's uri. */ URI DocumentURI `json:"uri"` /*LanguageID defined: * The text document's language identifier */ LanguageID string `json:"languageId"` /*Version defined: * The version number of this document (it will increase after each * change, including undo/redo). */ Version float64 `json:"version"` /*Text defined: * The content of the opened text document. */ Text string `json:"text"` } /*MarkupContent defined: * A `MarkupContent` literal represents a string value which content is interpreted base on its * kind flag. Currently the protocol supports `plaintext` and `markdown` as markup kinds. * * If the kind is `markdown` then the value can contain fenced code blocks like in GitHub issues. * See https://help.github.com/articles/creating-and-highlighting-code-blocks/#syntax-highlighting * * Here is an example how such a string can be constructed using JavaScript / TypeScript: * ```ts * let markdown: MarkdownContent = { * kind: MarkupKind.Markdown, * value: [ * '# Header', * 'Some text', * '```typescript', * 'someCode();', * '```' * ].join('\n') * }; * ``` * * *Please Note* that clients might sanitize the return markdown. A client could decide to * remove HTML from the markdown to avoid script execution. */ type MarkupContent struct { /*Kind defined: * The type of the Markup */ Kind MarkupKind `json:"kind"` /*Value defined: * The content itself */ Value string `json:"value"` } /*CompletionItem defined: * A completion item represents a text snippet that is * proposed to complete text that is being typed. */ type CompletionItem struct { /*Label defined: * The label of this completion item. By default * also the text that is inserted when selecting * this completion. */ Label string `json:"label"` /*Kind defined: * The kind of this completion item. Based of the kind * an icon is chosen by the editor. */ Kind CompletionItemKind `json:"kind,omitempty"` /*Tags defined: * Tags for this completion item. * * @since 3.15.0 */ Tags []CompletionItemTag `json:"tags,omitempty"` /*Detail defined: * A human-readable string with additional information * about this item, like type or symbol information. */ Detail string `json:"detail,omitempty"` /*Documentation defined: * A human-readable string that represents a doc-comment. */ Documentation string `json:"documentation,omitempty"` // string | MarkupContent /*Deprecated defined: * Indicates if this item is deprecated. * @deprecated Use `tags` instead. */ Deprecated bool `json:"deprecated,omitempty"` /*Preselect defined: * Select this item when showing. * * *Note* that only one completion item can be selected and that the * tool / client decides which item that is. The rule is that the *first* * item of those that match best is selected. */ Preselect bool `json:"preselect,omitempty"` /*SortText defined: * A string that should be used when comparing this item * with other items. When `falsy` the [label](#CompletionItem.label) * is used. */ SortText string `json:"sortText,omitempty"` /*FilterText defined: * A string that should be used when filtering a set of * completion items. When `falsy` the [label](#CompletionItem.label) * is used. */ FilterText string `json:"filterText,omitempty"` /*InsertText defined: * A string that should be inserted into a document when selecting * this completion. When `falsy` the [label](#CompletionItem.label) * is used. * * The `insertText` is subject to interpretation by the client side. * Some tools might not take the string literally. For example * VS Code when code complete is requested in this example `con` * and a completion item with an `insertText` of `console` is provided it * will only insert `sole`. Therefore it is recommended to use `textEdit` instead * since it avoids additional client side interpretation. */ InsertText string `json:"insertText,omitempty"` /*InsertTextFormat defined: * The format of the insert text. The format applies to both the `insertText` property * and the `newText` property of a provided `textEdit`. */ InsertTextFormat InsertTextFormat `json:"insertTextFormat,omitempty"` /*TextEdit defined: * An [edit](#TextEdit) which is applied to a document when selecting * this completion. When an edit is provided the value of * [insertText](#CompletionItem.insertText) is ignored. * * *Note:* The text edit's range must be a [single line] and it must contain the position * at which completion has been requested. */ TextEdit *TextEdit `json:"textEdit,omitempty"` /*AdditionalTextEdits defined: * An optional array of additional [text edits](#TextEdit) that are applied when * selecting this completion. Edits must not overlap (including the same insert position) * with the main [edit](#CompletionItem.textEdit) nor with themselves. * * Additional text edits should be used to change text unrelated to the current cursor position * (for example adding an import statement at the top of the file if the completion item will * insert an unqualified type). */ AdditionalTextEdits []TextEdit `json:"additionalTextEdits,omitempty"` /*CommitCharacters defined: * An optional set of characters that when pressed while this completion is active will accept it first and * then type that character. *Note* that all commit characters should have `length=1` and that superfluous * characters will be ignored. */ CommitCharacters []string `json:"commitCharacters,omitempty"` /*Command defined: * An optional [command](#Command) that is executed *after* inserting this completion. *Note* that * additional modifications to the current document should be described with the * [additionalTextEdits](#CompletionItem.additionalTextEdits)-property. */ Command *Command `json:"command,omitempty"` /*Data defined: * An data entry field that is preserved on a completion item between * a [CompletionRequest](#CompletionRequest) and a [CompletionResolveRequest] * (#CompletionResolveRequest) */ Data interface{} `json:"data,omitempty"` } /*CompletionList defined: * Represents a collection of [completion items](#CompletionItem) to be presented * in the editor. */ type CompletionList struct { /*IsIncomplete defined: * This list it not complete. Further typing results in recomputing this list. */ IsIncomplete bool `json:"isIncomplete"` /*Items defined: * The completion items. */ Items []CompletionItem `json:"items"` } /*Hover defined: * The result of a hover request. */ type Hover struct { /*Contents defined: * The hover's content */ Contents MarkupContent `json:"contents"` // MarkupContent | MarkedString | MarkedString[] /*Range defined: * An optional range */ Range *Range `json:"range,omitempty"` } /*ParameterInformation defined: * Represents a parameter of a callable-signature. A parameter can * have a label and a doc-comment. */ type ParameterInformation struct { /*Label defined: * The label of this parameter information. * * Either a string or an inclusive start and exclusive end offsets within its containing * signature label. (see SignatureInformation.label). The offsets are based on a UTF-16 * string representation as `Position` and `Range` does. * * *Note*: a label of type string should be a substring of its containing signature label. * Its intended use case is to highlight the parameter label part in the `SignatureInformation.label`. */ Label string `json:"label"` // string | [number, number] /*Documentation defined: * The human-readable doc-comment of this signature. Will be shown * in the UI but can be omitted. */ Documentation string `json:"documentation,omitempty"` // string | MarkupContent } /*SignatureInformation defined: * Represents the signature of something callable. A signature * can have a label, like a function-name, a doc-comment, and * a set of parameters. */ type SignatureInformation struct { /*Label defined: * The label of this signature. Will be shown in * the UI. */ Label string `json:"label"` /*Documentation defined: * The human-readable doc-comment of this signature. Will be shown * in the UI but can be omitted. */ Documentation string `json:"documentation,omitempty"` // string | MarkupContent /*Parameters defined: * The parameters of this signature. */ Parameters []ParameterInformation `json:"parameters,omitempty"` } /*SignatureHelp defined: * Signature help represents the signature of something * callable. There can be multiple signature but only one * active and only one active parameter. */ type SignatureHelp struct { /*Signatures defined: * One or more signatures. */ Signatures []SignatureInformation `json:"signatures"` /*ActiveSignature defined: * The active signature. Set to `null` if no * signatures exist. */ ActiveSignature float64 `json:"activeSignature"` /*ActiveParameter defined: * The active parameter of the active signature. Set to `null` * if the active signature has no parameters. */ ActiveParameter float64 `json:"activeParameter"` } /*ReferenceContext defined: * Value-object that contains additional information when * requesting references. */ type ReferenceContext struct { /*IncludeDeclaration defined: * Include the declaration of the current symbol. */ IncludeDeclaration bool `json:"includeDeclaration"` } /*DocumentHighlight defined: * A document highlight is a range inside a text document which deserves * special attention. Usually a document highlight is visualized by changing * the background color of its range. */ type DocumentHighlight struct { /*Range defined: * The range this highlight applies to. */ Range Range `json:"range"` /*Kind defined: * The highlight kind, default is [text](#DocumentHighlightKind.Text). */ Kind *DocumentHighlightKind `json:"kind,omitempty"` } /*SymbolInformation defined: * Represents information about programming constructs like variables, classes, * interfaces etc. */ type SymbolInformation struct { /*Name defined: * The name of this symbol. */ Name string `json:"name"` /*Kind defined: * The kind of this symbol. */ Kind SymbolKind `json:"kind"` /*Deprecated defined: * Indicates if this symbol is deprecated. */ Deprecated bool `json:"deprecated,omitempty"` /*Location defined: * The location of this symbol. The location's range is used by a tool * to reveal the location in the editor. If the symbol is selected in the * tool the range's start information is used to position the cursor. So * the range usually spans more than the actual symbol's name and does * normally include thinks like visibility modifiers. * * The range doesn't have to denote a node range in the sense of a abstract * syntax tree. It can therefore not be used to re-construct a hierarchy of * the symbols. */ Location Location `json:"location"` /*ContainerName defined: * The name of the symbol containing this symbol. This information is for * user interface purposes (e.g. to render a qualifier in the user interface * if necessary). It can't be used to re-infer a hierarchy for the document * symbols. */ ContainerName string `json:"containerName,omitempty"` } /*DocumentSymbol defined: * Represents programming constructs like variables, classes, interfaces etc. * that appear in a document. Document symbols can be hierarchical and they * have two ranges: one that encloses its definition and one that points to * its most interesting range, e.g. the range of an identifier. */ type DocumentSymbol struct { /*Name defined: * The name of this symbol. Will be displayed in the user interface and therefore must not be * an empty string or a string only consisting of white spaces. */ Name string `json:"name"` /*Detail defined: * More detail for this symbol, e.g the signature of a function. */ Detail string `json:"detail,omitempty"` /*Kind defined: * The kind of this symbol. */ Kind SymbolKind `json:"kind"` /*Deprecated defined: * Indicates if this symbol is deprecated. */ Deprecated bool `json:"deprecated,omitempty"` /*Range defined: * The range enclosing this symbol not including leading/trailing whitespace but everything else * like comments. This information is typically used to determine if the clients cursor is * inside the symbol to reveal in the symbol in the UI. */ Range Range `json:"range"` /*SelectionRange defined: * The range that should be selected and revealed when this symbol is being picked, e.g the name of a function. * Must be contained by the `range`. */ SelectionRange Range `json:"selectionRange"` /*Children defined: * Children of this symbol, e.g. properties of a class. */ Children []DocumentSymbol `json:"children,omitempty"` } /*CodeActionContext defined: * Contains additional diagnostic information about the context in which * a [code action](#CodeActionProvider.provideCodeActions) is run. */ type CodeActionContext struct { /*Diagnostics defined: * An array of diagnostics known on the client side overlapping the range provided to the * `textDocument/codeAction` request. They are provided so that the server knows which * errors are currently presented to the user for the given range. There is no guarantee * that these accurately reflect the error state of the resource. The primary parameter * to compute code actions is the provided range. */ Diagnostics []Diagnostic `json:"diagnostics"` /*Only defined: * Requested kind of actions to return. * * Actions not of this kind are filtered out by the client before being shown. So servers * can omit computing them. */ Only []CodeActionKind `json:"only,omitempty"` } /*CodeAction defined: * A code action represents a change that can be performed in code, e.g. to fix a problem or * to refactor code. * * A CodeAction must set either `edit` and/or a `command`. If both are supplied, the `edit` is applied first, then the `command` is executed. */ type CodeAction struct { /*Title defined: * A short, human-readable, title for this code action. */ Title string `json:"title"` /*Kind defined: * The kind of the code action. * * Used to filter code actions. */ Kind CodeActionKind `json:"kind,omitempty"` /*Diagnostics defined: * The diagnostics that this code action resolves. */ Diagnostics []Diagnostic `json:"diagnostics,omitempty"` /*IsPreferred defined: * Marks this as a preferred action. Preferred actions are used by the `auto fix` command and can be targeted * by keybindings. * * A quick fix should be marked preferred if it properly addresses the underlying error. * A refactoring should be marked preferred if it is the most reasonable choice of actions to take. * * @since 3.15.0 */ IsPreferred bool `json:"isPreferred,omitempty"` /*Edit defined: * The workspace edit this code action performs. */ Edit *WorkspaceEdit `json:"edit,omitempty"` /*Command defined: * A command this code action executes. If a code action * provides a edit and a command, first the edit is * executed and then the command. */ Command *Command `json:"command,omitempty"` } /*CodeLens defined: * A code lens represents a [command](#Command) that should be shown along with * source text, like the number of references, a way to run tests, etc. * * A code lens is _unresolved_ when no command is associated to it. For performance * reasons the creation of a code lens and resolving should be done to two stages. */ type CodeLens struct { /*Range defined: * The range in which this code lens is valid. Should only span a single line. */ Range Range `json:"range"` /*Command defined: * The command this code lens represents. */ Command *Command `json:"command,omitempty"` /*Data defined: * An data entry field that is preserved on a code lens item between * a [CodeLensRequest](#CodeLensRequest) and a [CodeLensResolveRequest] * (#CodeLensResolveRequest) */ Data interface{} `json:"data,omitempty"` } /*FormattingOptions defined: * Value-object describing what options formatting should use. */ type FormattingOptions struct { /*TabSize defined: * Size of a tab in spaces. */ TabSize float64 `json:"tabSize"` /*InsertSpaces defined: * Prefer spaces over tabs. */ InsertSpaces bool `json:"insertSpaces"` /*TrimTrailingWhitespace defined: * Trim trailing whitespaces on a line. * * @since 3.15.0 */ TrimTrailingWhitespace bool `json:"trimTrailingWhitespace,omitempty"` /*InsertFinalNewline defined: * Insert a newline character at the end of the file if one does not exist. * * @since 3.15.0 */ InsertFinalNewline bool `json:"insertFinalNewline,omitempty"` /*TrimFinalNewlines defined: * Trim all newlines after the final newline at the end of the file. * * @since 3.15.0 */ TrimFinalNewlines bool `json:"trimFinalNewlines,omitempty"` /*Key defined: * Signature for further properties. */ Key map[string]bool `json:"key"` // [key: string]: boolean | number | string | undefined; } /*DocumentLink defined: * A document link is a range in a text document that links to an internal or external resource, like another * text document or a web site. */ type DocumentLink struct { /*Range defined: * The range this link applies to. */ Range Range `json:"range"` /*Target defined: * The uri this link points to. */ Target string `json:"target,omitempty"` /*Tooltip defined: * The tooltip text when you hover over this link. * * If a tooltip is provided, is will be displayed in a string that includes instructions on how to * trigger the link, such as `{0} (ctrl + click)`. The specific instructions vary depending on OS, * user settings, and localization. * * @since 3.15.0 */ Tooltip string `json:"tooltip,omitempty"` /*Data defined: * A data entry field that is preserved on a document link between a * DocumentLinkRequest and a DocumentLinkResolveRequest. */ Data interface{} `json:"data,omitempty"` } /*SelectionRange defined: * A selection range represents a part of a selection hierarchy. A selection range * may have a parent selection range that contains it. */ type SelectionRange struct { /*Range defined: * The [range](#Range) of this selection range. */ Range Range `json:"range"` /*Parent defined: * The parent selection range containing this range. Therefore `parent.range` must contain `this.range`. */ Parent *SelectionRange `json:"parent,omitempty"` } /*TextDocument defined: * A simple text document. Not to be implemented. */ type TextDocument struct { /*URI defined: * The associated URI for this document. Most documents have the __file__-scheme, indicating that they * represent files on disk. However, some documents may have other schemes indicating that they are not * available on disk. * * @readonly */ URI DocumentURI `json:"uri"` /*LanguageID defined: * The identifier of the language associated with this document. * * @readonly */ LanguageID string `json:"languageId"` /*Version defined: * The version number of this document (it will increase after each * change, including undo/redo). * * @readonly */ Version float64 `json:"version"` /*LineCount defined: * The number of lines in this document. * * @readonly */ LineCount float64 `json:"lineCount"` } /*TextDocumentChangeEvent defined: * Event to signal changes to a simple text document. */ type TextDocumentChangeEvent struct { /*Document defined: * The document that has changed. */ Document TextDocument `json:"document"` } // TextDocumentWillSaveEvent is type TextDocumentWillSaveEvent struct { /*Document defined: * The document that will be saved */ Document TextDocument `json:"document"` /*Reason defined: * The reason why save was triggered. */ Reason TextDocumentSaveReason `json:"reason"` } /*TextDocumentContentChangeEvent defined: * An event describing a change to a text document. If range and rangeLength are omitted * the new text is considered to be the full content of the document. */ type TextDocumentContentChangeEvent struct { /*Range defined: * The range of the document that changed. */ Range *Range `json:"range,omitempty"` /*RangeLength defined: * The length of the range that got replaced. */ RangeLength float64 `json:"rangeLength,omitempty"` /*Text defined: * The new text of the document. */ Text string `json:"text"` } // ProgressParams is type ProgressParams struct { /*Token defined: * The progress token provided by the client or server. */ Token ProgressToken `json:"token"` /*Value defined: * The progress data. */ Value interface{} `json:"value"` } // SetTraceParams is type SetTraceParams struct { // Value is Value TraceValues `json:"value"` } // LogTraceParams is type LogTraceParams struct { // Message is Message string `json:"message"` // Verbose is Verbose string `json:"verbose,omitempty"` } // Tracer is type Tracer struct { } // FoldingRangeKind defines constants type FoldingRangeKind string // ResourceOperationKind defines constants type ResourceOperationKind string // FailureHandlingKind defines constants type FailureHandlingKind string // InitializeError defines constants type InitializeError float64 // MessageType defines constants type MessageType float64 // TextDocumentSyncKind defines constants type TextDocumentSyncKind float64 // FileChangeType defines constants type FileChangeType float64 // WatchKind defines constants type WatchKind float64 // CompletionTriggerKind defines constants type CompletionTriggerKind float64 // SignatureHelpTriggerKind defines constants type SignatureHelpTriggerKind float64 // DiagnosticSeverity defines constants type DiagnosticSeverity float64 // DiagnosticTag defines constants type DiagnosticTag float64 // MarkupKind defines constants type MarkupKind string // CompletionItemKind defines constants type CompletionItemKind float64 // InsertTextFormat defines constants type InsertTextFormat float64 // CompletionItemTag defines constants type CompletionItemTag float64 // DocumentHighlightKind defines constants type DocumentHighlightKind float64 // SymbolKind defines constants type SymbolKind float64 // CodeActionKind defines constants type CodeActionKind string // TextDocumentSaveReason defines constants type TextDocumentSaveReason float64 // ErrorCodes defines constants type ErrorCodes float64 // Touch defines constants type Touch float64 // Trace defines constants type Trace string // TraceFormat defines constants type TraceFormat string // ConnectionErrors defines constants type ConnectionErrors float64 // ConnectionState defines constants type ConnectionState float64 const ( /*Comment defined: * Folding range for a comment */ Comment FoldingRangeKind = "comment" /*Imports defined: * Folding range for a imports or includes */ Imports FoldingRangeKind = "imports" /*Region defined: * Folding range for a region (e.g. `#region`) */ Region FoldingRangeKind = "region" /*Create defined: * Supports creating new files and folders. */ Create ResourceOperationKind = "create" /*Rename defined: * Supports renaming existing files and folders. */ Rename ResourceOperationKind = "rename" /*Delete defined: * Supports deleting existing files and folders. */ Delete ResourceOperationKind = "delete" /*Abort defined: * Applying the workspace change is simply aborted if one of the changes provided * fails. All operations executed before the failing operation stay executed. */ Abort FailureHandlingKind = "abort" /*Transactional defined: * All operations are executed transactional. That means they either all * succeed or no changes at all are applied to the workspace. */ Transactional FailureHandlingKind = "transactional" /*TextOnlyTransactional defined: * If the workspace edit contains only textual file changes they are executed transactional. * If resource changes (create, rename or delete file) are part of the change the failure * handling strategy is abort. */ TextOnlyTransactional FailureHandlingKind = "textOnlyTransactional" /*Undo defined: * The client tries to undo the operations already executed. But there is no * guarantee that this is succeeding. */ Undo FailureHandlingKind = "undo" /*UnknownProtocolVersion defined: * If the protocol version provided by the client can't be handled by the server. * @deprecated This initialize error got replaced by client capabilities. There is * no version handshake in version 3.0x */ UnknownProtocolVersion InitializeError = 1 /*Error defined: * An error message. */ Error MessageType = 1 /*Warning defined: * A warning message. */ Warning MessageType = 2 /*Info defined: * An information message. */ Info MessageType = 3 /*Log defined: * A log message. */ Log MessageType = 4 /*None defined: * Documents should not be synced at all. */ None TextDocumentSyncKind = 0 /*Full defined: * Documents are synced by always sending the full content * of the document. */ Full TextDocumentSyncKind = 1 /*Incremental defined: * Documents are synced by sending the full content on open. * After that only incremental updates to the document are * send. */ Incremental TextDocumentSyncKind = 2 /*Created defined: * The file got created. */ Created FileChangeType = 1 /*Changed defined: * The file got changed. */ Changed FileChangeType = 2 /*Deleted defined: * The file got deleted. */ Deleted FileChangeType = 3 /*WatchCreate defined: * Interested in create events. */ WatchCreate WatchKind = 1 /*WatchChange defined: * Interested in change events */ WatchChange WatchKind = 2 /*WatchDelete defined: * Interested in delete events */ WatchDelete WatchKind = 4 /*Invoked defined: * Completion was triggered by typing an identifier (24x7 code * complete), manual invocation (e.g Ctrl+Space) or via API. */ Invoked CompletionTriggerKind = 1 /*TriggerCharacter defined: * Completion was triggered by a trigger character specified by * the `triggerCharacters` properties of the `CompletionRegistrationOptions`. */ TriggerCharacter CompletionTriggerKind = 2 /*TriggerForIncompleteCompletions defined: * Completion was re-triggered as current completion list is incomplete */ TriggerForIncompleteCompletions CompletionTriggerKind = 3 /*ContentChange defined: * Signature help was triggered by the cursor moving or by the document content changing. */ ContentChange SignatureHelpTriggerKind = 3 /*SeverityError defined: * Reports an error. */ SeverityError DiagnosticSeverity = 1 /*SeverityWarning defined: * Reports a warning. */ SeverityWarning DiagnosticSeverity = 2 /*SeverityInformation defined: * Reports an information. */ SeverityInformation DiagnosticSeverity = 3 /*SeverityHint defined: * Reports a hint. */ SeverityHint DiagnosticSeverity = 4 /*Unnecessary defined: * Unused or unnecessary code. * * Clients are allowed to render diagnostics with this tag faded out instead of having * an error squiggle. */ Unnecessary DiagnosticTag = 1 /*Deprecated defined: * Deprecated or obsolete code. * * Clients are allowed to rendered diagnostics with this tag strike through. */ Deprecated DiagnosticTag = 2 /*PlainText defined: * Plain text is supported as a content format */ PlainText MarkupKind = "plaintext" /*Markdown defined: * Markdown is supported as a content format */ Markdown MarkupKind = "markdown" // TextCompletion is TextCompletion CompletionItemKind = 1 // MethodCompletion is MethodCompletion CompletionItemKind = 2 // FunctionCompletion is FunctionCompletion CompletionItemKind = 3 // ConstructorCompletion is ConstructorCompletion CompletionItemKind = 4 // FieldCompletion is FieldCompletion CompletionItemKind = 5 // VariableCompletion is VariableCompletion CompletionItemKind = 6 // ClassCompletion is ClassCompletion CompletionItemKind = 7 // InterfaceCompletion is InterfaceCompletion CompletionItemKind = 8 // ModuleCompletion is ModuleCompletion CompletionItemKind = 9 // PropertyCompletion is PropertyCompletion CompletionItemKind = 10 // UnitCompletion is UnitCompletion CompletionItemKind = 11 // ValueCompletion is ValueCompletion CompletionItemKind = 12 // EnumCompletion is EnumCompletion CompletionItemKind = 13 // KeywordCompletion is KeywordCompletion CompletionItemKind = 14 // SnippetCompletion is SnippetCompletion CompletionItemKind = 15 // ColorCompletion is ColorCompletion CompletionItemKind = 16 // FileCompletion is FileCompletion CompletionItemKind = 17 // ReferenceCompletion is ReferenceCompletion CompletionItemKind = 18 // FolderCompletion is FolderCompletion CompletionItemKind = 19 // EnumMemberCompletion is EnumMemberCompletion CompletionItemKind = 20 // ConstantCompletion is ConstantCompletion CompletionItemKind = 21 // StructCompletion is StructCompletion CompletionItemKind = 22 // EventCompletion is EventCompletion CompletionItemKind = 23 // OperatorCompletion is OperatorCompletion CompletionItemKind = 24 // TypeParameterCompletion is TypeParameterCompletion CompletionItemKind = 25 /*PlainTextTextFormat defined: * The primary text to be inserted is treated as a plain string. */ PlainTextTextFormat InsertTextFormat = 1 /*SnippetTextFormat defined: * The primary text to be inserted is treated as a snippet. * * A snippet can define tab stops and placeholders with `$1`, `$2` * and `${3:foo}`. `$0` defines the final tab stop, it defaults to * the end of the snippet. Placeholders with equal identifiers are linked, * that is typing in one will update others too. * * See also: https://github.com/Microsoft/vscode/blob/master/src/vs/editor/contrib/snippet/common/snippet.md */ SnippetTextFormat InsertTextFormat = 2 /*Text defined: * A textual occurrence. */ Text DocumentHighlightKind = 1 /*Read defined: * Read-access of a symbol, like reading a variable. */ Read DocumentHighlightKind = 2 /*Write defined: * Write-access of a symbol, like writing to a variable. */ Write DocumentHighlightKind = 3 // File is File SymbolKind = 1 // Module is Module SymbolKind = 2 // Namespace is Namespace SymbolKind = 3 // Package is Package SymbolKind = 4 // Class is Class SymbolKind = 5 // Method is Method SymbolKind = 6 // Property is Property SymbolKind = 7 // Field is Field SymbolKind = 8 // Constructor is Constructor SymbolKind = 9 // Enum is Enum SymbolKind = 10 // Interface is Interface SymbolKind = 11 // Function is Function SymbolKind = 12 // Variable is Variable SymbolKind = 13 // Constant is Constant SymbolKind = 14 // String is String SymbolKind = 15 // Number is Number SymbolKind = 16 // Boolean is Boolean SymbolKind = 17 // Array is Array SymbolKind = 18 // Object is Object SymbolKind = 19 // Key is Key SymbolKind = 20 // Null is Null SymbolKind = 21 // EnumMember is EnumMember SymbolKind = 22 // Struct is Struct SymbolKind = 23 // Event is Event SymbolKind = 24 // Operator is Operator SymbolKind = 25 // TypeParameter is TypeParameter SymbolKind = 26 /*Empty defined: * Empty kind. */ Empty CodeActionKind = "" /*QuickFix defined: * Base kind for quickfix actions: 'quickfix' */ QuickFix CodeActionKind = "quickfix" /*Refactor defined: * Base kind for refactoring actions: 'refactor' */ Refactor CodeActionKind = "refactor" /*RefactorExtract defined: * Base kind for refactoring extraction actions: 'refactor.extract' * * Example extract actions: * * - Extract method * - Extract function * - Extract variable * - Extract interface from class * - ... */ RefactorExtract CodeActionKind = "refactor.extract" /*RefactorInline defined: * Base kind for refactoring inline actions: 'refactor.inline' * * Example inline actions: * * - Inline function * - Inline variable * - Inline constant * - ... */ RefactorInline CodeActionKind = "refactor.inline" /*RefactorRewrite defined: * Base kind for refactoring rewrite actions: 'refactor.rewrite' * * Example rewrite actions: * * - Convert JavaScript function to class * - Add or remove parameter * - Encapsulate field * - Make method static * - Move method to base class * - ... */ RefactorRewrite CodeActionKind = "refactor.rewrite" /*Source defined: * Base kind for source actions: `source` * * Source code actions apply to the entire file. */ Source CodeActionKind = "source" /*SourceOrganizeImports defined: * Base kind for an organize imports source action: `source.organizeImports` */ SourceOrganizeImports CodeActionKind = "source.organizeImports" /*Manual defined: * Manually triggered, e.g. by the user pressing save, by starting debugging, * or by an API call. */ Manual TextDocumentSaveReason = 1 /*AfterDelay defined: * Automatic after a delay. */ AfterDelay TextDocumentSaveReason = 2 /*FocusOut defined: * When the editor lost focus. */ FocusOut TextDocumentSaveReason = 3 // MessageWriteError is MessageWriteError ErrorCodes = 1 // MessageReadError is MessageReadError ErrorCodes = 2 // First is First Touch = 1 // Last is Last Touch = 2 // JSON is JSON TraceFormat = "json" /*Closed defined: * The connection is closed. */ Closed ConnectionErrors = 1 /*Disposed defined: * The connection got disposed. */ Disposed ConnectionErrors = 2 /*AlreadyListening defined: * The connection is already in listening mode. */ AlreadyListening ConnectionErrors = 3 // New is New ConnectionState = 1 // Listening is Listening ConnectionState = 2 ) // DocumentFilter is a type /** * A document filter denotes a document by different properties like * the [language](#TextDocument.languageId), the [scheme](#Uri.scheme) of * its resource, or a glob-pattern that is applied to the [path](#TextDocument.fileName). * * Glob patterns can have the following syntax: * - `*` to match one or more characters in a path segment * - `?` to match on one character in a path segment * - `**` to match any number of path segments, including none * - `{}` to group conditions (e.g. `**​/*.{ts,js}` matches all TypeScript and JavaScript files) * - `[]` to declare a range of characters to match in a path segment (e.g., `example.[0-9]` to match on `example.0`, `example.1`, …) * - `[!...]` to negate a range of characters to match in a path segment (e.g., `example.[!0-9]` to match on `example.a`, `example.b`, but not `example.0`) * * @sample A language filter that applies to typescript files on disk: `{ language: 'typescript', scheme: 'file' }` * @sample A language filter that applies to all package.json paths: `{ language: 'json', pattern: '**package.json' }` */ type DocumentFilter = struct { /*Language defined: A language id, like `typescript`. */ Language string `json:"language,omitempty"` /*Scheme defined: A Uri [scheme](#Uri.scheme), like `file` or `untitled`. */ Scheme string `json:"scheme,omitempty"` /*Pattern defined: A glob pattern, like `*.{ts,js}`. */ Pattern string `json:"pattern,omitempty"` } // DocumentSelector is a type /** * A document selector is the combination of one or many document filters. * * @sample `let sel:DocumentSelector = [{ language: 'typescript' }, { language: 'json', pattern: '**∕tsconfig.json' }]`; */ type DocumentSelector = []DocumentFilter // DocumentURI is a type /** * A tagging type for string properties that are actually URIs. */ type DocumentURI = string // MarkedString is a type /** * MarkedString can be used to render human readable text. It is either a markdown string * or a code-block that provides a language and a code snippet. The language identifier * is semantically equal to the optional language identifier in fenced code blocks in GitHub * issues. See https://help.github.com/articles/creating-and-highlighting-code-blocks/#syntax-highlighting * * The pair of a language and a value is an equivalent to markdown: * ```${language} * ${value} * ``` * * Note that markdown strings will be sanitized - that means html will be escaped. * @deprecated use MarkupContent instead. */ type MarkedString = string // DefinitionLink is a type /** * Information about where a symbol is defined. * * Provides additional metadata over normal [location](#Location) definitions, including the range of * the defining symbol */ type DefinitionLink = LocationLink // DeclarationLink is a type /** * Information about where a symbol is declared. * * Provides additional metadata over normal [location](#Location) declarations, including the range of * the declaring symbol. * * Servers should prefer returning `DeclarationLink` over `Declaration` if supported * by the client. */ type DeclarationLink = LocationLink // LSPMessageType is a type /** * A LSP Log Entry. */ type LSPMessageType = string // ProgressToken is a type type ProgressToken = interface{} // number | string // TraceValues is a type type TraceValues = string KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/src/lsp/protocol/tsserver.go000066400000000000000000000663731475742701700266250ustar00rootroot00000000000000// Copyright 2019 The Go Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package protocol import ( "context" "encoding/json" "log" "github.com/KhronosGroup/SPIRV-Tools/utils/vscode/src/lsp/jsonrpc2" ) type Server interface { DidChangeWorkspaceFolders(context.Context, *DidChangeWorkspaceFoldersParams) error Initialized(context.Context, *InitializedParams) error Exit(context.Context) error DidChangeConfiguration(context.Context, *DidChangeConfigurationParams) error DidOpen(context.Context, *DidOpenTextDocumentParams) error DidChange(context.Context, *DidChangeTextDocumentParams) error DidClose(context.Context, *DidCloseTextDocumentParams) error DidSave(context.Context, *DidSaveTextDocumentParams) error WillSave(context.Context, *WillSaveTextDocumentParams) error DidChangeWatchedFiles(context.Context, *DidChangeWatchedFilesParams) error Progress(context.Context, *ProgressParams) error SetTraceNotification(context.Context, *SetTraceParams) error LogTraceNotification(context.Context, *LogTraceParams) error Implementation(context.Context, *ImplementationParams) ([]Location, error) TypeDefinition(context.Context, *TypeDefinitionParams) ([]Location, error) DocumentColor(context.Context, *DocumentColorParams) ([]ColorInformation, error) ColorPresentation(context.Context, *ColorPresentationParams) ([]ColorPresentation, error) FoldingRange(context.Context, *FoldingRangeParams) ([]FoldingRange, error) Declaration(context.Context, *DeclarationParams) ([]DeclarationLink, error) SelectionRange(context.Context, *SelectionRangeParams) ([]SelectionRange, error) Initialize(context.Context, *ParamInitia) (*InitializeResult, error) Shutdown(context.Context) error WillSaveWaitUntil(context.Context, *WillSaveTextDocumentParams) ([]TextEdit, error) Completion(context.Context, *CompletionParams) (*CompletionList, error) Resolve(context.Context, *CompletionItem) (*CompletionItem, error) Hover(context.Context, *HoverParams) (*Hover, error) SignatureHelp(context.Context, *SignatureHelpParams) (*SignatureHelp, error) Definition(context.Context, *DefinitionParams) ([]Location, error) References(context.Context, *ReferenceParams) ([]Location, error) DocumentHighlight(context.Context, *DocumentHighlightParams) ([]DocumentHighlight, error) DocumentSymbol(context.Context, *DocumentSymbolParams) ([]DocumentSymbol, error) CodeAction(context.Context, *CodeActionParams) ([]CodeAction, error) Symbol(context.Context, *WorkspaceSymbolParams) ([]SymbolInformation, error) CodeLens(context.Context, *CodeLensParams) ([]CodeLens, error) ResolveCodeLens(context.Context, *CodeLens) (*CodeLens, error) DocumentLink(context.Context, *DocumentLinkParams) ([]DocumentLink, error) ResolveDocumentLink(context.Context, *DocumentLink) (*DocumentLink, error) Formatting(context.Context, *DocumentFormattingParams) ([]TextEdit, error) RangeFormatting(context.Context, *DocumentRangeFormattingParams) ([]TextEdit, error) OnTypeFormatting(context.Context, *DocumentOnTypeFormattingParams) ([]TextEdit, error) Rename(context.Context, *RenameParams) (*WorkspaceEdit, error) PrepareRename(context.Context, *PrepareRenameParams) (*Range, error) ExecuteCommand(context.Context, *ExecuteCommandParams) (interface{}, error) } func (h serverHandler) Deliver(ctx context.Context, r *jsonrpc2.Request, delivered bool) bool { if delivered { return false } if ctx.Err() != nil { r.Reply(ctx, nil, jsonrpc2.NewErrorf(RequestCancelledError, "")) return true } switch r.Method { case "workspace/didChangeWorkspaceFolders": // notif var params DidChangeWorkspaceFoldersParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } if err := h.server.DidChangeWorkspaceFolders(ctx, ¶ms); err != nil { log.Printf("%v", err) } return true case "initialized": // notif var params InitializedParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } if err := h.server.Initialized(ctx, ¶ms); err != nil { log.Printf("%v", err) } return true case "exit": // notif if err := h.server.Exit(ctx); err != nil { log.Printf("%v", err) } return true case "workspace/didChangeConfiguration": // notif var params DidChangeConfigurationParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } if err := h.server.DidChangeConfiguration(ctx, ¶ms); err != nil { log.Printf("%v", err) } return true case "textDocument/didOpen": // notif var params DidOpenTextDocumentParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } if err := h.server.DidOpen(ctx, ¶ms); err != nil { log.Printf("%v", err) } return true case "textDocument/didChange": // notif var params DidChangeTextDocumentParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } if err := h.server.DidChange(ctx, ¶ms); err != nil { log.Printf("%v", err) } return true case "textDocument/didClose": // notif var params DidCloseTextDocumentParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } if err := h.server.DidClose(ctx, ¶ms); err != nil { log.Printf("%v", err) } return true case "textDocument/didSave": // notif var params DidSaveTextDocumentParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } if err := h.server.DidSave(ctx, ¶ms); err != nil { log.Printf("%v", err) } return true case "textDocument/willSave": // notif var params WillSaveTextDocumentParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } if err := h.server.WillSave(ctx, ¶ms); err != nil { log.Printf("%v", err) } return true case "workspace/didChangeWatchedFiles": // notif var params DidChangeWatchedFilesParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } if err := h.server.DidChangeWatchedFiles(ctx, ¶ms); err != nil { log.Printf("%v", err) } return true case "$/progress": // notif var params ProgressParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } if err := h.server.Progress(ctx, ¶ms); err != nil { log.Printf("%v", err) } return true case "$/setTraceNotification": // notif var params SetTraceParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } if err := h.server.SetTraceNotification(ctx, ¶ms); err != nil { log.Printf("%v", err) } return true case "$/logTraceNotification": // notif var params LogTraceParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } if err := h.server.LogTraceNotification(ctx, ¶ms); err != nil { log.Printf("%v", err) } return true case "textDocument/implementation": // req var params ImplementationParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } resp, err := h.server.Implementation(ctx, ¶ms) if err := r.Reply(ctx, resp, err); err != nil { log.Printf("%v", err) } return true case "textDocument/typeDefinition": // req var params TypeDefinitionParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } resp, err := h.server.TypeDefinition(ctx, ¶ms) if err := r.Reply(ctx, resp, err); err != nil { log.Printf("%v", err) } return true case "textDocument/documentColor": // req var params DocumentColorParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } resp, err := h.server.DocumentColor(ctx, ¶ms) if err := r.Reply(ctx, resp, err); err != nil { log.Printf("%v", err) } return true case "textDocument/colorPresentation": // req var params ColorPresentationParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } resp, err := h.server.ColorPresentation(ctx, ¶ms) if err := r.Reply(ctx, resp, err); err != nil { log.Printf("%v", err) } return true case "textDocument/foldingRange": // req var params FoldingRangeParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } resp, err := h.server.FoldingRange(ctx, ¶ms) if err := r.Reply(ctx, resp, err); err != nil { log.Printf("%v", err) } return true case "textDocument/declaration": // req var params DeclarationParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } resp, err := h.server.Declaration(ctx, ¶ms) if err := r.Reply(ctx, resp, err); err != nil { log.Printf("%v", err) } return true case "textDocument/selectionRange": // req var params SelectionRangeParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } resp, err := h.server.SelectionRange(ctx, ¶ms) if err := r.Reply(ctx, resp, err); err != nil { log.Printf("%v", err) } return true case "initialize": // req var params ParamInitia if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } resp, err := h.server.Initialize(ctx, ¶ms) if err := r.Reply(ctx, resp, err); err != nil { log.Printf("%v", err) } return true case "shutdown": // req if r.Params != nil { r.Reply(ctx, nil, jsonrpc2.NewErrorf(jsonrpc2.CodeInvalidParams, "Expected no params")) return true } err := h.server.Shutdown(ctx) if err := r.Reply(ctx, nil, err); err != nil { log.Printf("%v", err) } return true case "textDocument/willSaveWaitUntil": // req var params WillSaveTextDocumentParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } resp, err := h.server.WillSaveWaitUntil(ctx, ¶ms) if err := r.Reply(ctx, resp, err); err != nil { log.Printf("%v", err) } return true case "textDocument/completion": // req var params CompletionParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } resp, err := h.server.Completion(ctx, ¶ms) if err := r.Reply(ctx, resp, err); err != nil { log.Printf("%v", err) } return true case "completionItem/resolve": // req var params CompletionItem if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } resp, err := h.server.Resolve(ctx, ¶ms) if err := r.Reply(ctx, resp, err); err != nil { log.Printf("%v", err) } return true case "textDocument/hover": // req var params HoverParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } resp, err := h.server.Hover(ctx, ¶ms) if err := r.Reply(ctx, resp, err); err != nil { log.Printf("%v", err) } return true case "textDocument/signatureHelp": // req var params SignatureHelpParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } resp, err := h.server.SignatureHelp(ctx, ¶ms) if err := r.Reply(ctx, resp, err); err != nil { log.Printf("%v", err) } return true case "textDocument/definition": // req var params DefinitionParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } resp, err := h.server.Definition(ctx, ¶ms) if err := r.Reply(ctx, resp, err); err != nil { log.Printf("%v", err) } return true case "textDocument/references": // req var params ReferenceParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } resp, err := h.server.References(ctx, ¶ms) if err := r.Reply(ctx, resp, err); err != nil { log.Printf("%v", err) } return true case "textDocument/documentHighlight": // req var params DocumentHighlightParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } resp, err := h.server.DocumentHighlight(ctx, ¶ms) if err := r.Reply(ctx, resp, err); err != nil { log.Printf("%v", err) } return true case "textDocument/documentSymbol": // req var params DocumentSymbolParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } resp, err := h.server.DocumentSymbol(ctx, ¶ms) if err := r.Reply(ctx, resp, err); err != nil { log.Printf("%v", err) } return true case "textDocument/codeAction": // req var params CodeActionParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } resp, err := h.server.CodeAction(ctx, ¶ms) if err := r.Reply(ctx, resp, err); err != nil { log.Printf("%v", err) } return true case "workspace/symbol": // req var params WorkspaceSymbolParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } resp, err := h.server.Symbol(ctx, ¶ms) if err := r.Reply(ctx, resp, err); err != nil { log.Printf("%v", err) } return true case "textDocument/codeLens": // req var params CodeLensParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } resp, err := h.server.CodeLens(ctx, ¶ms) if err := r.Reply(ctx, resp, err); err != nil { log.Printf("%v", err) } return true case "codeLens/resolve": // req var params CodeLens if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } resp, err := h.server.ResolveCodeLens(ctx, ¶ms) if err := r.Reply(ctx, resp, err); err != nil { log.Printf("%v", err) } return true case "textDocument/documentLink": // req var params DocumentLinkParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } resp, err := h.server.DocumentLink(ctx, ¶ms) if err := r.Reply(ctx, resp, err); err != nil { log.Printf("%v", err) } return true case "documentLink/resolve": // req var params DocumentLink if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } resp, err := h.server.ResolveDocumentLink(ctx, ¶ms) if err := r.Reply(ctx, resp, err); err != nil { log.Printf("%v", err) } return true case "textDocument/formatting": // req var params DocumentFormattingParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } resp, err := h.server.Formatting(ctx, ¶ms) if err := r.Reply(ctx, resp, err); err != nil { log.Printf("%v", err) } return true case "textDocument/rangeFormatting": // req var params DocumentRangeFormattingParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } resp, err := h.server.RangeFormatting(ctx, ¶ms) if err := r.Reply(ctx, resp, err); err != nil { log.Printf("%v", err) } return true case "textDocument/onTypeFormatting": // req var params DocumentOnTypeFormattingParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } resp, err := h.server.OnTypeFormatting(ctx, ¶ms) if err := r.Reply(ctx, resp, err); err != nil { log.Printf("%v", err) } return true case "textDocument/rename": // req var params RenameParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } resp, err := h.server.Rename(ctx, ¶ms) if err := r.Reply(ctx, resp, err); err != nil { log.Printf("%v", err) } return true case "textDocument/prepareRename": // req var params PrepareRenameParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } resp, err := h.server.PrepareRename(ctx, ¶ms) if err := r.Reply(ctx, resp, err); err != nil { log.Printf("%v", err) } return true case "workspace/executeCommand": // req var params ExecuteCommandParams if err := json.Unmarshal(*r.Params, ¶ms); err != nil { sendParseError(ctx, r, err) return true } resp, err := h.server.ExecuteCommand(ctx, ¶ms) if err := r.Reply(ctx, resp, err); err != nil { log.Printf("%v", err) } return true default: return false } } type serverDispatcher struct { *jsonrpc2.Conn } func (s *serverDispatcher) DidChangeWorkspaceFolders(ctx context.Context, params *DidChangeWorkspaceFoldersParams) error { return s.Conn.Notify(ctx, "workspace/didChangeWorkspaceFolders", params) } func (s *serverDispatcher) Initialized(ctx context.Context, params *InitializedParams) error { return s.Conn.Notify(ctx, "initialized", params) } func (s *serverDispatcher) Exit(ctx context.Context) error { return s.Conn.Notify(ctx, "exit", nil) } func (s *serverDispatcher) DidChangeConfiguration(ctx context.Context, params *DidChangeConfigurationParams) error { return s.Conn.Notify(ctx, "workspace/didChangeConfiguration", params) } func (s *serverDispatcher) DidOpen(ctx context.Context, params *DidOpenTextDocumentParams) error { return s.Conn.Notify(ctx, "textDocument/didOpen", params) } func (s *serverDispatcher) DidChange(ctx context.Context, params *DidChangeTextDocumentParams) error { return s.Conn.Notify(ctx, "textDocument/didChange", params) } func (s *serverDispatcher) DidClose(ctx context.Context, params *DidCloseTextDocumentParams) error { return s.Conn.Notify(ctx, "textDocument/didClose", params) } func (s *serverDispatcher) DidSave(ctx context.Context, params *DidSaveTextDocumentParams) error { return s.Conn.Notify(ctx, "textDocument/didSave", params) } func (s *serverDispatcher) WillSave(ctx context.Context, params *WillSaveTextDocumentParams) error { return s.Conn.Notify(ctx, "textDocument/willSave", params) } func (s *serverDispatcher) DidChangeWatchedFiles(ctx context.Context, params *DidChangeWatchedFilesParams) error { return s.Conn.Notify(ctx, "workspace/didChangeWatchedFiles", params) } func (s *serverDispatcher) Progress(ctx context.Context, params *ProgressParams) error { return s.Conn.Notify(ctx, "$/progress", params) } func (s *serverDispatcher) SetTraceNotification(ctx context.Context, params *SetTraceParams) error { return s.Conn.Notify(ctx, "$/setTraceNotification", params) } func (s *serverDispatcher) LogTraceNotification(ctx context.Context, params *LogTraceParams) error { return s.Conn.Notify(ctx, "$/logTraceNotification", params) } func (s *serverDispatcher) Implementation(ctx context.Context, params *ImplementationParams) ([]Location, error) { var result []Location if err := s.Conn.Call(ctx, "textDocument/implementation", params, &result); err != nil { return nil, err } return result, nil } func (s *serverDispatcher) TypeDefinition(ctx context.Context, params *TypeDefinitionParams) ([]Location, error) { var result []Location if err := s.Conn.Call(ctx, "textDocument/typeDefinition", params, &result); err != nil { return nil, err } return result, nil } func (s *serverDispatcher) DocumentColor(ctx context.Context, params *DocumentColorParams) ([]ColorInformation, error) { var result []ColorInformation if err := s.Conn.Call(ctx, "textDocument/documentColor", params, &result); err != nil { return nil, err } return result, nil } func (s *serverDispatcher) ColorPresentation(ctx context.Context, params *ColorPresentationParams) ([]ColorPresentation, error) { var result []ColorPresentation if err := s.Conn.Call(ctx, "textDocument/colorPresentation", params, &result); err != nil { return nil, err } return result, nil } func (s *serverDispatcher) FoldingRange(ctx context.Context, params *FoldingRangeParams) ([]FoldingRange, error) { var result []FoldingRange if err := s.Conn.Call(ctx, "textDocument/foldingRange", params, &result); err != nil { return nil, err } return result, nil } func (s *serverDispatcher) Declaration(ctx context.Context, params *DeclarationParams) ([]DeclarationLink, error) { var result []DeclarationLink if err := s.Conn.Call(ctx, "textDocument/declaration", params, &result); err != nil { return nil, err } return result, nil } func (s *serverDispatcher) SelectionRange(ctx context.Context, params *SelectionRangeParams) ([]SelectionRange, error) { var result []SelectionRange if err := s.Conn.Call(ctx, "textDocument/selectionRange", params, &result); err != nil { return nil, err } return result, nil } func (s *serverDispatcher) Initialize(ctx context.Context, params *ParamInitia) (*InitializeResult, error) { var result InitializeResult if err := s.Conn.Call(ctx, "initialize", params, &result); err != nil { return nil, err } return &result, nil } func (s *serverDispatcher) Shutdown(ctx context.Context) error { return s.Conn.Call(ctx, "shutdown", nil, nil) } func (s *serverDispatcher) WillSaveWaitUntil(ctx context.Context, params *WillSaveTextDocumentParams) ([]TextEdit, error) { var result []TextEdit if err := s.Conn.Call(ctx, "textDocument/willSaveWaitUntil", params, &result); err != nil { return nil, err } return result, nil } func (s *serverDispatcher) Completion(ctx context.Context, params *CompletionParams) (*CompletionList, error) { var result CompletionList if err := s.Conn.Call(ctx, "textDocument/completion", params, &result); err != nil { return nil, err } return &result, nil } func (s *serverDispatcher) Resolve(ctx context.Context, params *CompletionItem) (*CompletionItem, error) { var result CompletionItem if err := s.Conn.Call(ctx, "completionItem/resolve", params, &result); err != nil { return nil, err } return &result, nil } func (s *serverDispatcher) Hover(ctx context.Context, params *HoverParams) (*Hover, error) { var result Hover if err := s.Conn.Call(ctx, "textDocument/hover", params, &result); err != nil { return nil, err } return &result, nil } func (s *serverDispatcher) SignatureHelp(ctx context.Context, params *SignatureHelpParams) (*SignatureHelp, error) { var result SignatureHelp if err := s.Conn.Call(ctx, "textDocument/signatureHelp", params, &result); err != nil { return nil, err } return &result, nil } func (s *serverDispatcher) Definition(ctx context.Context, params *DefinitionParams) ([]Location, error) { var result []Location if err := s.Conn.Call(ctx, "textDocument/definition", params, &result); err != nil { return nil, err } return result, nil } func (s *serverDispatcher) References(ctx context.Context, params *ReferenceParams) ([]Location, error) { var result []Location if err := s.Conn.Call(ctx, "textDocument/references", params, &result); err != nil { return nil, err } return result, nil } func (s *serverDispatcher) DocumentHighlight(ctx context.Context, params *DocumentHighlightParams) ([]DocumentHighlight, error) { var result []DocumentHighlight if err := s.Conn.Call(ctx, "textDocument/documentHighlight", params, &result); err != nil { return nil, err } return result, nil } func (s *serverDispatcher) DocumentSymbol(ctx context.Context, params *DocumentSymbolParams) ([]DocumentSymbol, error) { var result []DocumentSymbol if err := s.Conn.Call(ctx, "textDocument/documentSymbol", params, &result); err != nil { return nil, err } return result, nil } func (s *serverDispatcher) CodeAction(ctx context.Context, params *CodeActionParams) ([]CodeAction, error) { var result []CodeAction if err := s.Conn.Call(ctx, "textDocument/codeAction", params, &result); err != nil { return nil, err } return result, nil } func (s *serverDispatcher) Symbol(ctx context.Context, params *WorkspaceSymbolParams) ([]SymbolInformation, error) { var result []SymbolInformation if err := s.Conn.Call(ctx, "workspace/symbol", params, &result); err != nil { return nil, err } return result, nil } func (s *serverDispatcher) CodeLens(ctx context.Context, params *CodeLensParams) ([]CodeLens, error) { var result []CodeLens if err := s.Conn.Call(ctx, "textDocument/codeLens", params, &result); err != nil { return nil, err } return result, nil } func (s *serverDispatcher) ResolveCodeLens(ctx context.Context, params *CodeLens) (*CodeLens, error) { var result CodeLens if err := s.Conn.Call(ctx, "codeLens/resolve", params, &result); err != nil { return nil, err } return &result, nil } func (s *serverDispatcher) DocumentLink(ctx context.Context, params *DocumentLinkParams) ([]DocumentLink, error) { var result []DocumentLink if err := s.Conn.Call(ctx, "textDocument/documentLink", params, &result); err != nil { return nil, err } return result, nil } func (s *serverDispatcher) ResolveDocumentLink(ctx context.Context, params *DocumentLink) (*DocumentLink, error) { var result DocumentLink if err := s.Conn.Call(ctx, "documentLink/resolve", params, &result); err != nil { return nil, err } return &result, nil } func (s *serverDispatcher) Formatting(ctx context.Context, params *DocumentFormattingParams) ([]TextEdit, error) { var result []TextEdit if err := s.Conn.Call(ctx, "textDocument/formatting", params, &result); err != nil { return nil, err } return result, nil } func (s *serverDispatcher) RangeFormatting(ctx context.Context, params *DocumentRangeFormattingParams) ([]TextEdit, error) { var result []TextEdit if err := s.Conn.Call(ctx, "textDocument/rangeFormatting", params, &result); err != nil { return nil, err } return result, nil } func (s *serverDispatcher) OnTypeFormatting(ctx context.Context, params *DocumentOnTypeFormattingParams) ([]TextEdit, error) { var result []TextEdit if err := s.Conn.Call(ctx, "textDocument/onTypeFormatting", params, &result); err != nil { return nil, err } return result, nil } func (s *serverDispatcher) Rename(ctx context.Context, params *RenameParams) (*WorkspaceEdit, error) { var result WorkspaceEdit if err := s.Conn.Call(ctx, "textDocument/rename", params, &result); err != nil { return nil, err } return &result, nil } func (s *serverDispatcher) PrepareRename(ctx context.Context, params *PrepareRenameParams) (*Range, error) { var result Range if err := s.Conn.Call(ctx, "textDocument/prepareRename", params, &result); err != nil { return nil, err } return &result, nil } func (s *serverDispatcher) ExecuteCommand(ctx context.Context, params *ExecuteCommandParams) (interface{}, error) { var result interface{} if err := s.Conn.Call(ctx, "workspace/executeCommand", params, &result); err != nil { return nil, err } return result, nil } type CancelParams struct { /** * The request id to cancel. */ ID jsonrpc2.ID `json:"id"` } // Types constructed to avoid structs as formal argument types type ParamInitia struct { InitializeParams WorkDoneProgressParams } KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/src/lsp/span/000077500000000000000000000000001475742701700235025ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/src/lsp/span/parse.go000066400000000000000000000062541475742701700251520ustar00rootroot00000000000000// Copyright 2019 The Go Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package span import ( "strconv" "strings" "unicode/utf8" ) // Parse returns the location represented by the input. // All inputs are valid locations, as they can always be a pure filename. // The returned span will be normalized, and thus if printed may produce a // different string. func Parse(input string) Span { // :0:0#0-0:0#0 valid := input var hold, offset int hadCol := false suf := rstripSuffix(input) if suf.sep == "#" { offset = suf.num suf = rstripSuffix(suf.remains) } if suf.sep == ":" { valid = suf.remains hold = suf.num hadCol = true suf = rstripSuffix(suf.remains) } switch { case suf.sep == ":": return New(NewURI(suf.remains), NewPoint(suf.num, hold, offset), Point{}) case suf.sep == "-": // we have a span, fall out of the case to continue default: // separator not valid, rewind to either the : or the start return New(NewURI(valid), NewPoint(hold, 0, offset), Point{}) } // only the span form can get here // at this point we still don't know what the numbers we have mean // if have not yet seen a : then we might have either a line or a column depending // on whether start has a column or not // we build an end point and will fix it later if needed end := NewPoint(suf.num, hold, offset) hold, offset = 0, 0 suf = rstripSuffix(suf.remains) if suf.sep == "#" { offset = suf.num suf = rstripSuffix(suf.remains) } if suf.sep != ":" { // turns out we don't have a span after all, rewind return New(NewURI(valid), end, Point{}) } valid = suf.remains hold = suf.num suf = rstripSuffix(suf.remains) if suf.sep != ":" { // line#offset only return New(NewURI(valid), NewPoint(hold, 0, offset), end) } // we have a column, so if end only had one number, it is also the column if !hadCol { end = NewPoint(suf.num, end.v.Line, end.v.Offset) } return New(NewURI(suf.remains), NewPoint(suf.num, hold, offset), end) } type suffix struct { remains string sep string num int } func rstripSuffix(input string) suffix { if len(input) == 0 { return suffix{"", "", -1} } remains := input num := -1 // first see if we have a number at the end last := strings.LastIndexFunc(remains, func(r rune) bool { return r < '0' || r > '9' }) if last >= 0 && last < len(remains)-1 { number, err := strconv.ParseInt(remains[last+1:], 10, 64) if err == nil { num = int(number) remains = remains[:last+1] } } // now see if we have a trailing separator r, w := utf8.DecodeLastRuneInString(remains) if r != ':' && r != '#' && r == '#' { return suffix{input, "", -1} } remains = remains[:len(remains)-w] return suffix{remains, string(r), num} } KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/src/lsp/span/span.go000066400000000000000000000171311475742701700247750ustar00rootroot00000000000000// Copyright 2019 The Go Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Package span contains support for representing with positions and ranges in // text files. package span import ( "encoding/json" "fmt" "path" ) // Span represents a source code range in standardized form. type Span struct { v span } // Point represents a single point within a file. // In general this should only be used as part of a Span, as on its own it // does not carry enough information. type Point struct { v point } type span struct { URI URI `json:"uri"` Start point `json:"start"` End point `json:"end"` } type point struct { Line int `json:"line"` Column int `json:"column"` Offset int `json:"offset"` } // Invalid is a span that reports false from IsValid var Invalid = Span{v: span{Start: invalidPoint.v, End: invalidPoint.v}} var invalidPoint = Point{v: point{Line: 0, Column: 0, Offset: -1}} // Converter is the interface to an object that can convert between line:column // and offset forms for a single file. type Converter interface { //ToPosition converts from an offset to a line:column pair. ToPosition(offset int) (int, int, error) //ToOffset converts from a line:column pair to an offset. ToOffset(line, col int) (int, error) } func New(uri URI, start Point, end Point) Span { s := Span{v: span{URI: uri, Start: start.v, End: end.v}} s.v.clean() return s } func NewPoint(line, col, offset int) Point { p := Point{v: point{Line: line, Column: col, Offset: offset}} p.v.clean() return p } func Compare(a, b Span) int { if r := CompareURI(a.URI(), b.URI()); r != 0 { return r } if r := comparePoint(a.v.Start, b.v.Start); r != 0 { return r } return comparePoint(a.v.End, b.v.End) } func ComparePoint(a, b Point) int { return comparePoint(a.v, b.v) } func comparePoint(a, b point) int { if !a.hasPosition() { if a.Offset < b.Offset { return -1 } if a.Offset > b.Offset { return 1 } return 0 } if a.Line < b.Line { return -1 } if a.Line > b.Line { return 1 } if a.Column < b.Column { return -1 } if a.Column > b.Column { return 1 } return 0 } func (s Span) HasPosition() bool { return s.v.Start.hasPosition() } func (s Span) HasOffset() bool { return s.v.Start.hasOffset() } func (s Span) IsValid() bool { return s.v.Start.isValid() } func (s Span) IsPoint() bool { return s.v.Start == s.v.End } func (s Span) URI() URI { return s.v.URI } func (s Span) Start() Point { return Point{s.v.Start} } func (s Span) End() Point { return Point{s.v.End} } func (s *Span) MarshalJSON() ([]byte, error) { return json.Marshal(&s.v) } func (s *Span) UnmarshalJSON(b []byte) error { return json.Unmarshal(b, &s.v) } func (p Point) HasPosition() bool { return p.v.hasPosition() } func (p Point) HasOffset() bool { return p.v.hasOffset() } func (p Point) IsValid() bool { return p.v.isValid() } func (p *Point) MarshalJSON() ([]byte, error) { return json.Marshal(&p.v) } func (p *Point) UnmarshalJSON(b []byte) error { return json.Unmarshal(b, &p.v) } func (p Point) Line() int { if !p.v.hasPosition() { panic(fmt.Errorf("position not set in %v", p.v)) } return p.v.Line } func (p Point) Column() int { if !p.v.hasPosition() { panic(fmt.Errorf("position not set in %v", p.v)) } return p.v.Column } func (p Point) Offset() int { if !p.v.hasOffset() { panic(fmt.Errorf("offset not set in %v", p.v)) } return p.v.Offset } func (p point) hasPosition() bool { return p.Line > 0 } func (p point) hasOffset() bool { return p.Offset >= 0 } func (p point) isValid() bool { return p.hasPosition() || p.hasOffset() } func (p point) isZero() bool { return (p.Line == 1 && p.Column == 1) || (!p.hasPosition() && p.Offset == 0) } func (s *span) clean() { //this presumes the points are already clean if !s.End.isValid() || (s.End == point{}) { s.End = s.Start } } func (p *point) clean() { if p.Line < 0 { p.Line = 0 } if p.Column <= 0 { if p.Line > 0 { p.Column = 1 } else { p.Column = 0 } } if p.Offset == 0 && (p.Line > 1 || p.Column > 1) { p.Offset = -1 } } // Format implements fmt.Formatter to print the Location in a standard form. // The format produced is one that can be read back in using Parse. func (s Span) Format(f fmt.State, c rune) { fullForm := f.Flag('+') preferOffset := f.Flag('#') // we should always have a uri, simplify if it is file format //TODO: make sure the end of the uri is unambiguous uri := string(s.v.URI) if c == 'f' { uri = path.Base(uri) } else if !fullForm { uri = s.v.URI.Filename() } fmt.Fprint(f, uri) if !s.IsValid() || (!fullForm && s.v.Start.isZero() && s.v.End.isZero()) { return } // see which bits of start to write printOffset := s.HasOffset() && (fullForm || preferOffset || !s.HasPosition()) printLine := s.HasPosition() && (fullForm || !printOffset) printColumn := printLine && (fullForm || (s.v.Start.Column > 1 || s.v.End.Column > 1)) fmt.Fprint(f, ":") if printLine { fmt.Fprintf(f, "%d", s.v.Start.Line) } if printColumn { fmt.Fprintf(f, ":%d", s.v.Start.Column) } if printOffset { fmt.Fprintf(f, "#%d", s.v.Start.Offset) } // start is written, do we need end? if s.IsPoint() { return } // we don't print the line if it did not change printLine = fullForm || (printLine && s.v.End.Line > s.v.Start.Line) fmt.Fprint(f, "-") if printLine { fmt.Fprintf(f, "%d", s.v.End.Line) } if printColumn { if printLine { fmt.Fprint(f, ":") } fmt.Fprintf(f, "%d", s.v.End.Column) } if printOffset { fmt.Fprintf(f, "#%d", s.v.End.Offset) } } func (s Span) WithPosition(c Converter) (Span, error) { if err := s.update(c, true, false); err != nil { return Span{}, err } return s, nil } func (s Span) WithOffset(c Converter) (Span, error) { if err := s.update(c, false, true); err != nil { return Span{}, err } return s, nil } func (s Span) WithAll(c Converter) (Span, error) { if err := s.update(c, true, true); err != nil { return Span{}, err } return s, nil } func (s *Span) update(c Converter, withPos, withOffset bool) error { if !s.IsValid() { return fmt.Errorf("cannot add information to an invalid span") } if withPos && !s.HasPosition() { if err := s.v.Start.updatePosition(c); err != nil { return err } if s.v.End.Offset == s.v.Start.Offset { s.v.End = s.v.Start } else if err := s.v.End.updatePosition(c); err != nil { return err } } if withOffset && (!s.HasOffset() || (s.v.End.hasPosition() && !s.v.End.hasOffset())) { if err := s.v.Start.updateOffset(c); err != nil { return err } if s.v.End.Line == s.v.Start.Line && s.v.End.Column == s.v.Start.Column { s.v.End.Offset = s.v.Start.Offset } else if err := s.v.End.updateOffset(c); err != nil { return err } } return nil } func (p *point) updatePosition(c Converter) error { line, col, err := c.ToPosition(p.Offset) if err != nil { return err } p.Line = line p.Column = col return nil } func (p *point) updateOffset(c Converter) error { offset, err := c.ToOffset(p.Line, p.Column) if err != nil { return err } p.Offset = offset return nil } KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/src/lsp/span/token.go000066400000000000000000000114571475742701700251610ustar00rootroot00000000000000// Copyright 2019 The Go Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package span import ( "fmt" "go/token" ) // Range represents a source code range in token.Pos form. // It also carries the FileSet that produced the positions, so that it is // self contained. type Range struct { FileSet *token.FileSet Start token.Pos End token.Pos } // TokenConverter is a Converter backed by a token file set and file. // It uses the file set methods to work out the conversions, which // makes it fast and does not require the file contents. type TokenConverter struct { fset *token.FileSet file *token.File } // NewRange creates a new Range from a FileSet and two positions. // To represent a point pass a 0 as the end pos. func NewRange(fset *token.FileSet, start, end token.Pos) Range { return Range{ FileSet: fset, Start: start, End: end, } } // NewTokenConverter returns an implementation of Converter backed by a // token.File. func NewTokenConverter(fset *token.FileSet, f *token.File) *TokenConverter { return &TokenConverter{fset: fset, file: f} } // NewContentConverter returns an implementation of Converter for the // given file content. func NewContentConverter(filename string, content []byte) *TokenConverter { fset := token.NewFileSet() f := fset.AddFile(filename, -1, len(content)) f.SetLinesForContent(content) return &TokenConverter{fset: fset, file: f} } // IsPoint returns true if the range represents a single point. func (r Range) IsPoint() bool { return r.Start == r.End } // Span converts a Range to a Span that represents the Range. // It will fill in all the members of the Span, calculating the line and column // information. func (r Range) Span() (Span, error) { f := r.FileSet.File(r.Start) if f == nil { return Span{}, fmt.Errorf("file not found in FileSet") } s := Span{v: span{URI: FileURI(f.Name())}} var err error s.v.Start.Offset, err = offset(f, r.Start) if err != nil { return Span{}, err } if r.End.IsValid() { s.v.End.Offset, err = offset(f, r.End) if err != nil { return Span{}, err } } s.v.Start.clean() s.v.End.clean() s.v.clean() converter := NewTokenConverter(r.FileSet, f) return s.WithPosition(converter) } // offset is a copy of the Offset function in go/token, but with the adjustment // that it does not panic on invalid positions. func offset(f *token.File, pos token.Pos) (int, error) { if int(pos) < f.Base() || int(pos) > f.Base()+f.Size() { return 0, fmt.Errorf("invalid pos") } return int(pos) - f.Base(), nil } // Range converts a Span to a Range that represents the Span for the supplied // File. func (s Span) Range(converter *TokenConverter) (Range, error) { s, err := s.WithOffset(converter) if err != nil { return Range{}, err } // go/token will panic if the offset is larger than the file's size, // so check here to avoid panicking. if s.Start().Offset() > converter.file.Size() { return Range{}, fmt.Errorf("start offset %v is past the end of the file %v", s.Start(), converter.file.Size()) } if s.End().Offset() > converter.file.Size() { return Range{}, fmt.Errorf("end offset %v is past the end of the file %v", s.End(), converter.file.Size()) } return Range{ FileSet: converter.fset, Start: converter.file.Pos(s.Start().Offset()), End: converter.file.Pos(s.End().Offset()), }, nil } func (l *TokenConverter) ToPosition(offset int) (int, int, error) { if offset > l.file.Size() { return 0, 0, fmt.Errorf("offset %v is past the end of the file %v", offset, l.file.Size()) } pos := l.file.Pos(offset) p := l.fset.Position(pos) if offset == l.file.Size() { return p.Line + 1, 1, nil } return p.Line, p.Column, nil } func (l *TokenConverter) ToOffset(line, col int) (int, error) { if line < 0 { return -1, fmt.Errorf("line is not valid") } lineMax := l.file.LineCount() + 1 if line > lineMax { return -1, fmt.Errorf("line is beyond end of file %v", lineMax) } else if line == lineMax { if col > 1 { return -1, fmt.Errorf("column is beyond end of file") } // at the end of the file, allowing for a trailing eol return l.file.Size(), nil } pos := lineStart(l.file, line) if !pos.IsValid() { return -1, fmt.Errorf("line is not in file") } // we assume that column is in bytes here, and that the first byte of a // line is at column 1 pos += token.Pos(col - 1) return offset(l.file, pos) } KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/src/lsp/span/token111.go000066400000000000000000000024511475742701700253760ustar00rootroot00000000000000// Copyright 2019 The Go Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // +build !go1.12 package span import ( "go/token" ) // lineStart is the pre-Go 1.12 version of (*token.File).LineStart. For Go // versions <= 1.11, we borrow logic from the analysisutil package. // TODO(rstambler): Delete this file when we no longer support Go 1.11. func lineStart(f *token.File, line int) token.Pos { // Use binary search to find the start offset of this line. min := 0 // inclusive max := f.Size() // exclusive for { offset := (min + max) / 2 pos := f.Pos(offset) posn := f.Position(pos) if posn.Line == line { return pos - (token.Pos(posn.Column) - 1) } if min+1 >= max { return token.NoPos } if posn.Line < line { min = offset } else { max = offset } } } KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/src/lsp/span/token112.go000066400000000000000000000014411475742701700253750ustar00rootroot00000000000000// Copyright 2019 The Go Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // +build go1.12 package span import ( "go/token" ) // TODO(rstambler): Delete this file when we no longer support Go 1.11. func lineStart(f *token.File, line int) token.Pos { return f.LineStart(line) } KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/src/lsp/span/uri.go000066400000000000000000000077151475742701700246420ustar00rootroot00000000000000// Copyright 2019 The Go Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package span import ( "fmt" "net/url" "os" "path" "path/filepath" "runtime" "strings" "unicode" ) const fileScheme = "file" // URI represents the full URI for a file. type URI string // Filename returns the file path for the given URI. // It is an error to call this on a URI that is not a valid filename. func (uri URI) Filename() string { filename, err := filename(uri) if err != nil { panic(err) } return filepath.FromSlash(filename) } func filename(uri URI) (string, error) { if uri == "" { return "", nil } u, err := url.ParseRequestURI(string(uri)) if err != nil { return "", err } if u.Scheme != fileScheme { return "", fmt.Errorf("only file URIs are supported, got %q from %q", u.Scheme, uri) } if isWindowsDriveURI(u.Path) { u.Path = u.Path[1:] } return u.Path, nil } // NewURI returns a span URI for the string. // It will attempt to detect if the string is a file path or uri. func NewURI(s string) URI { if u, err := url.PathUnescape(s); err == nil { s = u } if strings.HasPrefix(s, fileScheme+"://") { return URI(s) } return FileURI(s) } func CompareURI(a, b URI) int { if equalURI(a, b) { return 0 } if a < b { return -1 } return 1 } func equalURI(a, b URI) bool { if a == b { return true } // If we have the same URI basename, we may still have the same file URIs. if !strings.EqualFold(path.Base(string(a)), path.Base(string(b))) { return false } fa, err := filename(a) if err != nil { return false } fb, err := filename(b) if err != nil { return false } // Stat the files to check if they are equal. infoa, err := os.Stat(filepath.FromSlash(fa)) if err != nil { return false } infob, err := os.Stat(filepath.FromSlash(fb)) if err != nil { return false } return os.SameFile(infoa, infob) } // FileURI returns a span URI for the supplied file path. // It will always have the file scheme. func FileURI(path string) URI { if path == "" { return "" } // Handle standard library paths that contain the literal "$GOROOT". // TODO(rstambler): The go/packages API should allow one to determine a user's $GOROOT. const prefix = "$GOROOT" if len(path) >= len(prefix) && strings.EqualFold(prefix, path[:len(prefix)]) { suffix := path[len(prefix):] path = runtime.GOROOT() + suffix } if !isWindowsDrivePath(path) { if abs, err := filepath.Abs(path); err == nil { path = abs } } // Check the file path again, in case it became absolute. if isWindowsDrivePath(path) { path = "/" + path } path = filepath.ToSlash(path) u := url.URL{ Scheme: fileScheme, Path: path, } uri := u.String() if unescaped, err := url.PathUnescape(uri); err == nil { uri = unescaped } return URI(uri) } // isWindowsDrivePath returns true if the file path is of the form used by // Windows. We check if the path begins with a drive letter, followed by a ":". func isWindowsDrivePath(path string) bool { if len(path) < 4 { return false } return unicode.IsLetter(rune(path[0])) && path[1] == ':' } // isWindowsDriveURI returns true if the file URI is of the format used by // Windows URIs. The url.Parse package does not specially handle Windows paths // (see https://golang.org/issue/6027). We check if the URI path has // a drive prefix (e.g. "/C:"). If so, we trim the leading "/". func isWindowsDriveURI(uri string) bool { if len(uri) < 4 { return false } return uri[0] == '/' && unicode.IsLetter(rune(uri[1])) && uri[2] == ':' } KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/src/lsp/span/utf16.go000066400000000000000000000065551475742701700250110ustar00rootroot00000000000000// Copyright 2019 The Go Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package span import ( "fmt" "unicode/utf16" "unicode/utf8" ) // ToUTF16Column calculates the utf16 column expressed by the point given the // supplied file contents. // This is used to convert from the native (always in bytes) column // representation and the utf16 counts used by some editors. func ToUTF16Column(p Point, content []byte) (int, error) { if content == nil { return -1, fmt.Errorf("ToUTF16Column: missing content") } if !p.HasPosition() { return -1, fmt.Errorf("ToUTF16Column: point is missing position") } if !p.HasOffset() { return -1, fmt.Errorf("ToUTF16Column: point is missing offset") } offset := p.Offset() // 0-based colZero := p.Column() - 1 // 0-based if colZero == 0 { // 0-based column 0, so it must be chr 1 return 1, nil } else if colZero < 0 { return -1, fmt.Errorf("ToUTF16Column: column is invalid (%v)", colZero) } // work out the offset at the start of the line using the column lineOffset := offset - colZero if lineOffset < 0 || offset > len(content) { return -1, fmt.Errorf("ToUTF16Column: offsets %v-%v outside file contents (%v)", lineOffset, offset, len(content)) } // Use the offset to pick out the line start. // This cannot panic: offset > len(content) and lineOffset < offset. start := content[lineOffset:] // Now, truncate down to the supplied column. start = start[:colZero] // and count the number of utf16 characters // in theory we could do this by hand more efficiently... return len(utf16.Encode([]rune(string(start)))) + 1, nil } // FromUTF16Column advances the point by the utf16 character offset given the // supplied line contents. // This is used to convert from the utf16 counts used by some editors to the // native (always in bytes) column representation. func FromUTF16Column(p Point, chr int, content []byte) (Point, error) { if !p.HasOffset() { return Point{}, fmt.Errorf("FromUTF16Column: point is missing offset") } // if chr is 1 then no adjustment needed if chr <= 1 { return p, nil } if p.Offset() >= len(content) { return p, fmt.Errorf("FromUTF16Column: offset (%v) greater than length of content (%v)", p.Offset(), len(content)) } remains := content[p.Offset():] // scan forward the specified number of characters for count := 1; count < chr; count++ { if len(remains) <= 0 { return Point{}, fmt.Errorf("FromUTF16Column: chr goes beyond the content") } r, w := utf8.DecodeRune(remains) if r == '\n' { // Per the LSP spec: // // > If the character value is greater than the line length it // > defaults back to the line length. break } remains = remains[w:] if r >= 0x10000 { // a two point rune count++ // if we finished in a two point rune, do not advance past the first if count >= chr { break } } p.v.Column += w p.v.Offset += w } return p, nil } KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/src/parser/000077500000000000000000000000001475742701700232375ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/src/parser/parser.go000066400000000000000000000470551475742701700250750ustar00rootroot00000000000000// Copyright (C) 2019 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Package parser implements a SPIR-V assembly parser. package parser import ( "fmt" "io" "log" "strings" "unicode" "unicode/utf8" "github.com/KhronosGroup/SPIRV-Tools/utils/vscode/src/schema" ) // Type is an enumerator of token types. type Type int // Type enumerators const ( Ident Type = iota // Foo PIdent // %32, %foo Integer Float String Operator Comment Newline ) func (t Type) String() string { switch t { case Ident: return "Ident" case PIdent: return "PIdent" case Integer: return "Integer" case Float: return "Float" case String: return "String" case Operator: return "Operator" case Comment: return "Comment" default: return "" } } // Token represents a single lexed token. type Token struct { Type Type Range Range } func (t Token) String() string { return fmt.Sprintf("{%v %v}", t.Type, t.Range) } // Text returns the tokens text from the source. func (t Token) Text(lines []string) string { return t.Range.Text(lines) } // Range represents an interval in a text file. type Range struct { Start Position End Position } func (r Range) String() string { return fmt.Sprintf("[%v %v]", r.Start, r.End) } // Text returns the text for the given Range in the provided lines. func (r Range) Text(lines []string) string { sl, sc := r.Start.Line-1, r.Start.Column-1 if sl < 0 || sc < 0 || sl > len(lines) || sc > len(lines[sl]) { return fmt.Sprintf("", r.Start) } el, ec := r.End.Line-1, r.End.Column-1 if el < 0 || ec < 0 || el > len(lines) || ec > len(lines[sl]) { return fmt.Sprintf("", r.End) } sb := strings.Builder{} if sl != el { sb.WriteString(lines[sl][sc:]) for l := sl + 1; l < el; l++ { sb.WriteString(lines[l]) } sb.WriteString(lines[el][:ec]) } else { sb.WriteString(lines[sl][sc:ec]) } return sb.String() } // Contains returns true if p is in r. func (r Range) Contains(p Position) bool { return !(p.LessThan(r.Start) || p.GreaterThan(r.End)) } func (r *Range) grow(o Range) { if !r.Start.IsValid() || o.Start.LessThan(r.Start) { r.Start = o.Start } if !r.End.IsValid() || o.End.GreaterThan(r.End) { r.End = o.End } } // Position holds a line and column position in a text file. type Position struct { Line, Column int } func (p Position) String() string { return fmt.Sprintf("%v:%v", p.Line, p.Column) } // IsValid returns true if the position has a line and column greater than 1. func (p Position) IsValid() bool { return p.Line > 0 && p.Column > 0 } // LessThan returns true iff o is before p. func (p Position) LessThan(o Position) bool { switch { case !p.IsValid() || !o.IsValid(): return false case p.Line < o.Line: return true case p.Line > o.Line: return false case p.Column < o.Column: return true default: return false } } // GreaterThan returns true iff o is greater than p. func (p Position) GreaterThan(o Position) bool { switch { case !p.IsValid() || !o.IsValid(): return false case p.Line > o.Line: return true case p.Line < o.Line: return false case p.Column > o.Column: return true default: return false } } type lexer struct { source string lexerState diags []Diagnostic e error } type lexerState struct { offset int // byte offset in source toks []*Token // all the lexed tokens pos Position // current position } // err appends an fmt.Printf style error into l.diags for the given token. func (l *lexer) err(tok *Token, msg string, args ...interface{}) { rng := Range{} if tok != nil { rng = tok.Range } l.diags = append(l.diags, Diagnostic{ Range: rng, Severity: SeverityError, Message: fmt.Sprintf(msg, args...), }) } // next returns the next rune, or io.EOF if the last rune has already been // consumed. func (l *lexer) next() rune { if l.offset >= len(l.source) { l.e = io.EOF return 0 } r, n := utf8.DecodeRuneInString(l.source[l.offset:]) l.offset += n if n == 0 { l.e = io.EOF return 0 } if r == '\n' { l.pos.Line++ l.pos.Column = 1 } else { l.pos.Column++ } return r } // save returns the current lexerState. func (l *lexer) save() lexerState { return l.lexerState } // restore restores the current lexer state with s. func (l *lexer) restore(s lexerState) { l.lexerState = s } // pident processes the PIdent token at the current position. // The lexer *must* know the next token is a PIdent before calling. func (l *lexer) pident() { tok := &Token{Type: PIdent, Range: Range{Start: l.pos, End: l.pos}} if r := l.next(); r != '%' { log.Fatalf("lexer expected '%%', got '%v'", r) return } for l.e == nil { s := l.save() r := l.next() if !isAlphaNumeric(r) && r != '_' { l.restore(s) break } } tok.Range.End = l.pos l.toks = append(l.toks, tok) } // numberOrIdent processes the Ident, Float or Integer token at the current // position. func (l *lexer) numberOrIdent() { const Unknown Type = -1 tok := &Token{Type: Unknown, Range: Range{Start: l.pos, End: l.pos}} loop: for l.e == nil { s := l.save() r := l.next() switch { case r == '-', r == '+', isNumeric(r): continue case isAlpha(r), r == '_': switch tok.Type { case Unknown: tok.Type = Ident case Float, Integer: l.err(tok, "invalid number") return } case r == '.': switch tok.Type { case Unknown: tok.Type = Float default: l.restore(s) break loop } default: if tok.Type == Unknown { tok.Type = Integer } l.restore(s) break loop } } tok.Range.End = l.pos l.toks = append(l.toks, tok) } // string processes the String token at the current position. // The lexer *must* know the next token is a String before calling. func (l *lexer) string() { tok := &Token{Type: String, Range: Range{Start: l.pos, End: l.pos}} if r := l.next(); r != '"' { log.Fatalf("lexer expected '\"', got '%v'", r) return } escape := false for l.e == nil { switch l.next() { case '"': if !escape { tok.Range.End = l.pos l.toks = append(l.toks, tok) return } case '\\': escape = !escape default: escape = false } } } // operator processes the Operator token at the current position. // The lexer *must* know the next token is a Operator before calling. func (l *lexer) operator() { tok := &Token{Type: Operator, Range: Range{Start: l.pos, End: l.pos}} for l.e == nil { switch l.next() { case '=', '|': tok.Range.End = l.pos l.toks = append(l.toks, tok) return } } } // lineComment processes the Comment token at the current position. // The lexer *must* know the next token is a Comment before calling. func (l *lexer) lineComment() { tok := &Token{Type: Comment, Range: Range{Start: l.pos, End: l.pos}} if r := l.next(); r != ';' { log.Fatalf("lexer expected ';', got '%v'", r) return } for l.e == nil { s := l.save() switch l.next() { case '\n': l.restore(s) tok.Range.End = l.pos l.toks = append(l.toks, tok) return } } } // newline processes the Newline token at the current position. // The lexer *must* know the next token is a Newline before calling. func (l *lexer) newline() { tok := &Token{Type: Newline, Range: Range{Start: l.pos, End: l.pos}} if r := l.next(); r != '\n' { log.Fatalf("lexer expected '\n', got '%v'", r) return } tok.Range.End = l.pos l.toks = append(l.toks, tok) } // lex returns all the tokens and diagnostics after lexing source. func lex(source string) ([]*Token, []Diagnostic, error) { l := lexer{source: source, lexerState: lexerState{pos: Position{1, 1}}} lastPos := Position{} for l.e == nil { // Integrity check that the parser is making progress if l.pos == lastPos { log.Panicf("Parsing stuck at %v", l.pos) } lastPos = l.pos s := l.save() r := l.next() switch { case r == '%': l.restore(s) l.pident() case r == '+' || r == '-' || r == '_' || isAlphaNumeric(r): l.restore(s) l.numberOrIdent() case r == '"': l.restore(s) l.string() case r == '=', r == '|': l.restore(s) l.operator() case r == ';': l.restore(s) l.lineComment() case r == '\n': l.restore(s) l.newline() } } if l.e != nil && l.e != io.EOF { return nil, nil, l.e } return l.toks, l.diags, nil } func isNumeric(r rune) bool { return unicode.IsDigit(r) } func isAlpha(r rune) bool { return unicode.IsLetter(r) } func isAlphaNumeric(r rune) bool { return isAlpha(r) || isNumeric(r) } type parser struct { lines []string // all source lines toks []*Token // all tokens diags []Diagnostic // parser emitted diagnostics idents map[string]*Identifier // identifiers by name mappings map[*Token]interface{} // tokens to semantic map extInstImports map[string]schema.OpcodeMap // extension imports by identifier insts []*Instruction // all instructions } func (p *parser) parse() error { for i := 0; i < len(p.toks); { if p.newline(i) || p.comment(i) { i++ continue } if n := p.instruction(i); n > 0 { i += n } else { p.unexpected(i) i++ } } return nil } // instruction parses the instruction starting at the i'th token. func (p *parser) instruction(i int) (n int) { inst := &Instruction{} switch { case p.opcode(i) != nil: inst.Opcode = p.opcode(i) inst.Tokens = []*Token{p.tok(i)} p.mappings[p.tok(i)] = inst n++ case p.opcode(i+2) != nil: // try '%id' '=' inst.Result, inst.Opcode = p.pident(i), p.opcode(i+2) if inst.Result == nil || p.operator(i+1) != "=" { return 0 } n += 3 inst.Tokens = []*Token{p.tok(i), p.tok(i + 1), p.tok(i + 2)} p.mappings[p.tok(i+2)] = inst default: return } expectsResult := len(inst.Opcode.Operands) > 0 && IsResult(inst.Opcode.Operands[0].Kind) operands := inst.Opcode.Operands switch { case inst.Result != nil && !expectsResult: p.err(inst.Result, "'%s' does not have a result", inst.Opcode.Opname) return case inst.Result == nil && expectsResult: p.err(p.tok(i), "'%s' expects a result", inst.Opcode.Opname) return case inst.Result != nil && expectsResult: // Check the result is of the correct type o := inst.Opcode.Operands[0] p.operand(o.Name, o.Kind, i, false) operands = operands[1:] p.addIdentDef(inst.Result.Text(p.lines), inst, p.tok(i)) } processOperand := func(o schema.Operand) bool { if p.newline(i + n) { return false } switch o.Quantifier { case schema.Once: if op, c := p.operand(o.Name, o.Kind, i+n, false); op != nil { inst.Tokens = append(inst.Tokens, op.Tokens...) n += c } case schema.ZeroOrOnce: if op, c := p.operand(o.Name, o.Kind, i+n, true); op != nil { inst.Tokens = append(inst.Tokens, op.Tokens...) n += c } case schema.ZeroOrMany: for !p.newline(i + n) { if op, c := p.operand(o.Name, o.Kind, i+n, true); op != nil { inst.Tokens = append(inst.Tokens, op.Tokens...) n += c } else { return false } } } return true } for _, o := range operands { if !processOperand(o) { break } if inst.Opcode == schema.OpExtInst && n == 4 { extImportTok, extNameTok := p.tok(i+n), p.tok(i+n+1) extImport := extImportTok.Text(p.lines) if extOpcodes, ok := p.extInstImports[extImport]; ok { extName := extNameTok.Text(p.lines) if extOpcode, ok := extOpcodes[extName]; ok { n += 2 // skip ext import, ext name for _, o := range extOpcode.Operands { if !processOperand(o) { break } } } else { p.err(extNameTok, "Unknown extension opcode '%s'", extName) } } else { p.err(extImportTok, "Expected identifier to OpExtInstImport") } } } for _, t := range inst.Tokens { inst.Range.grow(t.Range) } p.insts = append(p.insts, inst) if inst.Opcode == schema.OpExtInstImport && len(inst.Tokens) >= 4 { // Instruction is a OpExtInstImport. Keep track of this. extTok := inst.Tokens[3] extName := strings.Trim(extTok.Text(p.lines), `"`) extOpcodes, ok := schema.ExtOpcodes[extName] if !ok { p.err(extTok, "Unknown extension '%s'", extName) } extImport := inst.Result.Text(p.lines) p.extInstImports[extImport] = extOpcodes } return } // operand parses the operand with the name n, kind k, starting at the i'th // token. func (p *parser) operand(n string, k *schema.OperandKind, i int, optional bool) (*Operand, int) { tok := p.tok(i) if tok == nil { return nil, 0 } op := &Operand{ Name: n, Kind: k, Tokens: []*Token{tok}, } p.mappings[tok] = op switch k.Category { case schema.OperandCategoryBitEnum, schema.OperandCategoryValueEnum: s := tok.Text(p.lines) for _, e := range k.Enumerants { if e.Enumerant == s { count := 1 for _, param := range e.Parameters { p, c := p.operand(param.Name, param.Kind, i+count, false) if p != nil { op.Tokens = append(op.Tokens, p.Tokens...) op.Parameters = append(op.Parameters, p) } count += c } // Handle bitfield '|' chains if p.tok(i+count).Text(p.lines) == "|" { count++ // '|' p, c := p.operand(n, k, i+count, false) if p != nil { op.Tokens = append(op.Tokens, p.Tokens...) op.Parameters = append(op.Parameters, p) } count += c } return op, count } } if !optional { p.err(p.tok(i), "invalid operand value '%s'", s) } return nil, 0 case schema.OperandCategoryID: id := p.pident(i) if id != nil { p.addIdentRef(p.tok(i)) return op, 1 } if !optional { p.err(p.tok(i), "operand requires id, got '%s'", tok.Text(p.lines)) } return nil, 0 case schema.OperandCategoryLiteral: switch tok.Type { case String, Integer, Float, Ident: return op, 1 } if !optional { p.err(p.tok(i), "operand requires literal, got '%s'", tok.Text(p.lines)) } return nil, 0 case schema.OperandCategoryComposite: n := 1 for _, b := range k.Bases { o, c := p.operand(b.Kind, b, i+n, optional) if o != nil { op.Tokens = append(op.Tokens, o.Tokens...) } n += c } return op, n default: p.err(p.tok(i), "OperandKind '%s' has unexpected category '%s'", k.Kind, k.Category) return nil, 0 } } // tok returns the i'th token, or nil if i is out of bounds. func (p *parser) tok(i int) *Token { if i < 0 || i >= len(p.toks) { return nil } return p.toks[i] } // opcode returns the schema.Opcode for the i'th token, or nil if the i'th token // does not represent an opcode. func (p *parser) opcode(i int) *schema.Opcode { if tok := p.ident(i); tok != nil { name := tok.Text(p.lines) if inst, found := schema.Opcodes[name]; found { return inst } } return nil } // operator returns the operator for the i'th token, or and empty string if the // i'th token is not an operator. func (p *parser) operator(i int) string { if tok := p.tok(i); tok != nil && tok.Type == Operator { return tok.Text(p.lines) } return "" } // ident returns the i'th token if it is an Ident, otherwise nil. func (p *parser) ident(i int) *Token { if tok := p.tok(i); tok != nil && tok.Type == Ident { return tok } return nil } // pident returns the i'th token if it is an PIdent, otherwise nil. func (p *parser) pident(i int) *Token { if tok := p.tok(i); tok != nil && tok.Type == PIdent { return tok } return nil } // comment returns true if the i'th token is a Comment, otherwise false. func (p *parser) comment(i int) bool { if tok := p.tok(i); tok != nil && tok.Type == Comment { return true } return false } // newline returns true if the i'th token is a Newline, otherwise false. func (p *parser) newline(i int) bool { if tok := p.tok(i); tok != nil && tok.Type == Newline { return true } return false } // unexpected emits an 'unexpected token error' for the i'th token. func (p *parser) unexpected(i int) { p.err(p.toks[i], "syntax error: unexpected '%s'", p.toks[i].Text(p.lines)) } // addIdentDef records the token definition for the instruction inst with the // given id. func (p *parser) addIdentDef(id string, inst *Instruction, def *Token) { i, existing := p.idents[id] if !existing { i = &Identifier{} p.idents[id] = i } if i.Definition == nil { i.Definition = inst } else { p.err(def, "id '%v' redeclared", id) } } // addIdentRef adds a identifier reference for the token ref. func (p *parser) addIdentRef(ref *Token) { id := ref.Text(p.lines) i, existing := p.idents[id] if !existing { i = &Identifier{} p.idents[id] = i } i.References = append(i.References, ref) } // err appends an fmt.Printf style error into l.diags for the given token. func (p *parser) err(tok *Token, msg string, args ...interface{}) { rng := Range{} if tok != nil { rng = tok.Range } p.diags = append(p.diags, Diagnostic{ Range: rng, Severity: SeverityError, Message: fmt.Sprintf(msg, args...), }) } // Parse parses the SPIR-V assembly string source, returning the parse results. func Parse(source string) (Results, error) { toks, diags, err := lex(source) if err != nil { return Results{}, err } lines := strings.SplitAfter(source, "\n") p := parser{ lines: lines, toks: toks, idents: map[string]*Identifier{}, mappings: map[*Token]interface{}{}, extInstImports: map[string]schema.OpcodeMap{}, } if err := p.parse(); err != nil { return Results{}, err } diags = append(diags, p.diags...) return Results{ Lines: lines, Tokens: toks, Diagnostics: p.diags, Identifiers: p.idents, Mappings: p.mappings, }, nil } // IsResult returns true if k is used to store the result of an instruction. func IsResult(k *schema.OperandKind) bool { switch k { case schema.OperandKindIdResult, schema.OperandKindIdResultType: return true default: return false } } // Results holds the output of Parse(). type Results struct { Lines []string Tokens []*Token Diagnostics []Diagnostic Identifiers map[string]*Identifier // identifiers by name Mappings map[*Token]interface{} // tokens to semantic map } // Instruction describes a single instruction instance type Instruction struct { Tokens []*Token // all the tokens that make up the instruction Result *Token // the token that represents the result of the instruction, or nil Operands []*Operand // the operands of the instruction Range Range // the textual range of the instruction Opcode *schema.Opcode // the opcode for the instruction } // Operand describes a single operand instance type Operand struct { Name string // name of the operand Kind *schema.OperandKind // kind of the operand Tokens []*Token // all the tokens that make up the operand Parameters []*Operand // all the parameters for the operand } // Identifier describes a single, unique SPIR-V identifier (i.e. %32) type Identifier struct { Definition *Instruction // where the identifier was defined References []*Token // all the places the identifier was referenced } // Severity is an enumerator of diagnostic severities type Severity int // Severity levels const ( SeverityError Severity = iota SeverityWarning SeverityInformation SeverityHint ) // Diagnostic holds a single diagnostic message that was generated while // parsing. type Diagnostic struct { Range Range Severity Severity Message string } KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/src/schema/000077500000000000000000000000001475742701700232035ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/src/schema/schema.go000077500000000000000000030073171475742701700250100ustar00rootroot00000000000000// Copyright (C) 2019 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Generated by gen-grammar.go --template=./src/schema/schema.go.tmpl --out=./src/schema/schema.go // Do not modify this file directly. package schema // Opcode holds information about a specific SPIR-V opcode. type Opcode struct { Opname string Class string Opcode int Operands []Operand } // Operand contains information about a logical operand for an instruction. type Operand struct { Kind *OperandKind Name string Quantifier Quantifier } // OperandKind contains information about a specific operand kind. type OperandKind struct { Category OperandCategory Kind string Enumerants []Enumerant Bases []*OperandKind } // Enumerant contains information about an enumerant in an enum. type Enumerant struct { Enumerant string Value interface{} Capabilities []string Parameters []Parameter Version string } // Parameter contains information about a logical parameter for an enumerant. type Parameter struct { Kind *OperandKind Name string } // Quantifier indicates the number of times the quantified term may appear. type Quantifier string const ( // Once indicates the quantified term may appear exactly once. Once Quantifier = "" // ZeroOrOnce indicates the quantified term may appear zero or one // time; an optional term. ZeroOrOnce Quantifier = "?" // ZeroOrMany indicates the quantified term may appear any number of // times. ZeroOrMany Quantifier = "*" ) // OperandCategory is an enumerator that groups operand kinds. type OperandCategory string const ( // OperandCategoryBitEnum describes an operand kind where its value is a // mask, which is formed by combining the bits specified as enumerants in an // enum. OperandCategoryBitEnum = "BitEnum" // OperandCategoryValueEnum describes an operand kind where its value is an // enumerant from an enum. OperandCategoryValueEnum = "ValueEnum" // OperandCategoryID describes and operand kind where its value is an // definition or reference. OperandCategoryID = "Id" // OperandCategoryLiteral describes and operand kind where its value is an // literal number or string. OperandCategoryLiteral = "Literal" // OperandCategoryComposite describes and operand kind where its value is // composed from operand values from the above categories. OperandCategoryComposite = "Composite" ) // OpcodeMap is a map of opcode name to Opcode type. type OpcodeMap map[string]*Opcode var ( // Opcodes is a map of opcode name to Opcode description. Opcodes = OpcodeMap { "OpNop": OpNop, "OpUndef": OpUndef, "OpSourceContinued": OpSourceContinued, "OpSource": OpSource, "OpSourceExtension": OpSourceExtension, "OpName": OpName, "OpMemberName": OpMemberName, "OpString": OpString, "OpLine": OpLine, "OpExtension": OpExtension, "OpExtInstImport": OpExtInstImport, "OpExtInst": OpExtInst, "OpMemoryModel": OpMemoryModel, "OpEntryPoint": OpEntryPoint, "OpExecutionMode": OpExecutionMode, "OpCapability": OpCapability, "OpTypeVoid": OpTypeVoid, "OpTypeBool": OpTypeBool, "OpTypeInt": OpTypeInt, "OpTypeFloat": OpTypeFloat, "OpTypeVector": OpTypeVector, "OpTypeMatrix": OpTypeMatrix, "OpTypeImage": OpTypeImage, "OpTypeSampler": OpTypeSampler, "OpTypeSampledImage": OpTypeSampledImage, "OpTypeArray": OpTypeArray, "OpTypeRuntimeArray": OpTypeRuntimeArray, "OpTypeStruct": OpTypeStruct, "OpTypeOpaque": OpTypeOpaque, "OpTypePointer": OpTypePointer, "OpTypeFunction": OpTypeFunction, "OpTypeEvent": OpTypeEvent, "OpTypeDeviceEvent": OpTypeDeviceEvent, "OpTypeReserveId": OpTypeReserveId, "OpTypeQueue": OpTypeQueue, "OpTypePipe": OpTypePipe, "OpTypeForwardPointer": OpTypeForwardPointer, "OpConstantTrue": OpConstantTrue, "OpConstantFalse": OpConstantFalse, "OpConstant": OpConstant, "OpConstantComposite": OpConstantComposite, "OpConstantSampler": OpConstantSampler, "OpConstantNull": OpConstantNull, "OpSpecConstantTrue": OpSpecConstantTrue, "OpSpecConstantFalse": OpSpecConstantFalse, "OpSpecConstant": OpSpecConstant, "OpSpecConstantComposite": OpSpecConstantComposite, "OpSpecConstantOp": OpSpecConstantOp, "OpFunction": OpFunction, "OpFunctionParameter": OpFunctionParameter, "OpFunctionEnd": OpFunctionEnd, "OpFunctionCall": OpFunctionCall, "OpVariable": OpVariable, "OpImageTexelPointer": OpImageTexelPointer, "OpLoad": OpLoad, "OpStore": OpStore, "OpCopyMemory": OpCopyMemory, "OpCopyMemorySized": OpCopyMemorySized, "OpAccessChain": OpAccessChain, "OpInBoundsAccessChain": OpInBoundsAccessChain, "OpPtrAccessChain": OpPtrAccessChain, "OpArrayLength": OpArrayLength, "OpGenericPtrMemSemantics": OpGenericPtrMemSemantics, "OpInBoundsPtrAccessChain": OpInBoundsPtrAccessChain, "OpDecorate": OpDecorate, "OpMemberDecorate": OpMemberDecorate, "OpDecorationGroup": OpDecorationGroup, "OpGroupDecorate": OpGroupDecorate, "OpGroupMemberDecorate": OpGroupMemberDecorate, "OpVectorExtractDynamic": OpVectorExtractDynamic, "OpVectorInsertDynamic": OpVectorInsertDynamic, "OpVectorShuffle": OpVectorShuffle, "OpCompositeConstruct": OpCompositeConstruct, "OpCompositeExtract": OpCompositeExtract, "OpCompositeInsert": OpCompositeInsert, "OpCopyObject": OpCopyObject, "OpTranspose": OpTranspose, "OpSampledImage": OpSampledImage, "OpImageSampleImplicitLod": OpImageSampleImplicitLod, "OpImageSampleExplicitLod": OpImageSampleExplicitLod, "OpImageSampleDrefImplicitLod": OpImageSampleDrefImplicitLod, "OpImageSampleDrefExplicitLod": OpImageSampleDrefExplicitLod, "OpImageSampleProjImplicitLod": OpImageSampleProjImplicitLod, "OpImageSampleProjExplicitLod": OpImageSampleProjExplicitLod, "OpImageSampleProjDrefImplicitLod": OpImageSampleProjDrefImplicitLod, "OpImageSampleProjDrefExplicitLod": OpImageSampleProjDrefExplicitLod, "OpImageFetch": OpImageFetch, "OpImageGather": OpImageGather, "OpImageDrefGather": OpImageDrefGather, "OpImageRead": OpImageRead, "OpImageWrite": OpImageWrite, "OpImage": OpImage, "OpImageQueryFormat": OpImageQueryFormat, "OpImageQueryOrder": OpImageQueryOrder, "OpImageQuerySizeLod": OpImageQuerySizeLod, "OpImageQuerySize": OpImageQuerySize, "OpImageQueryLod": OpImageQueryLod, "OpImageQueryLevels": OpImageQueryLevels, "OpImageQuerySamples": OpImageQuerySamples, "OpConvertFToU": OpConvertFToU, "OpConvertFToS": OpConvertFToS, "OpConvertSToF": OpConvertSToF, "OpConvertUToF": OpConvertUToF, "OpUConvert": OpUConvert, "OpSConvert": OpSConvert, "OpFConvert": OpFConvert, "OpQuantizeToF16": OpQuantizeToF16, "OpConvertPtrToU": OpConvertPtrToU, "OpSatConvertSToU": OpSatConvertSToU, "OpSatConvertUToS": OpSatConvertUToS, "OpConvertUToPtr": OpConvertUToPtr, "OpPtrCastToGeneric": OpPtrCastToGeneric, "OpGenericCastToPtr": OpGenericCastToPtr, "OpGenericCastToPtrExplicit": OpGenericCastToPtrExplicit, "OpBitcast": OpBitcast, "OpSNegate": OpSNegate, "OpFNegate": OpFNegate, "OpIAdd": OpIAdd, "OpFAdd": OpFAdd, "OpISub": OpISub, "OpFSub": OpFSub, "OpIMul": OpIMul, "OpFMul": OpFMul, "OpUDiv": OpUDiv, "OpSDiv": OpSDiv, "OpFDiv": OpFDiv, "OpUMod": OpUMod, "OpSRem": OpSRem, "OpSMod": OpSMod, "OpFRem": OpFRem, "OpFMod": OpFMod, "OpVectorTimesScalar": OpVectorTimesScalar, "OpMatrixTimesScalar": OpMatrixTimesScalar, "OpVectorTimesMatrix": OpVectorTimesMatrix, "OpMatrixTimesVector": OpMatrixTimesVector, "OpMatrixTimesMatrix": OpMatrixTimesMatrix, "OpOuterProduct": OpOuterProduct, "OpDot": OpDot, "OpIAddCarry": OpIAddCarry, "OpISubBorrow": OpISubBorrow, "OpUMulExtended": OpUMulExtended, "OpSMulExtended": OpSMulExtended, "OpAny": OpAny, "OpAll": OpAll, "OpIsNan": OpIsNan, "OpIsInf": OpIsInf, "OpIsFinite": OpIsFinite, "OpIsNormal": OpIsNormal, "OpSignBitSet": OpSignBitSet, "OpLessOrGreater": OpLessOrGreater, "OpOrdered": OpOrdered, "OpUnordered": OpUnordered, "OpLogicalEqual": OpLogicalEqual, "OpLogicalNotEqual": OpLogicalNotEqual, "OpLogicalOr": OpLogicalOr, "OpLogicalAnd": OpLogicalAnd, "OpLogicalNot": OpLogicalNot, "OpSelect": OpSelect, "OpIEqual": OpIEqual, "OpINotEqual": OpINotEqual, "OpUGreaterThan": OpUGreaterThan, "OpSGreaterThan": OpSGreaterThan, "OpUGreaterThanEqual": OpUGreaterThanEqual, "OpSGreaterThanEqual": OpSGreaterThanEqual, "OpULessThan": OpULessThan, "OpSLessThan": OpSLessThan, "OpULessThanEqual": OpULessThanEqual, "OpSLessThanEqual": OpSLessThanEqual, "OpFOrdEqual": OpFOrdEqual, "OpFUnordEqual": OpFUnordEqual, "OpFOrdNotEqual": OpFOrdNotEqual, "OpFUnordNotEqual": OpFUnordNotEqual, "OpFOrdLessThan": OpFOrdLessThan, "OpFUnordLessThan": OpFUnordLessThan, "OpFOrdGreaterThan": OpFOrdGreaterThan, "OpFUnordGreaterThan": OpFUnordGreaterThan, "OpFOrdLessThanEqual": OpFOrdLessThanEqual, "OpFUnordLessThanEqual": OpFUnordLessThanEqual, "OpFOrdGreaterThanEqual": OpFOrdGreaterThanEqual, "OpFUnordGreaterThanEqual": OpFUnordGreaterThanEqual, "OpShiftRightLogical": OpShiftRightLogical, "OpShiftRightArithmetic": OpShiftRightArithmetic, "OpShiftLeftLogical": OpShiftLeftLogical, "OpBitwiseOr": OpBitwiseOr, "OpBitwiseXor": OpBitwiseXor, "OpBitwiseAnd": OpBitwiseAnd, "OpNot": OpNot, "OpBitFieldInsert": OpBitFieldInsert, "OpBitFieldSExtract": OpBitFieldSExtract, "OpBitFieldUExtract": OpBitFieldUExtract, "OpBitReverse": OpBitReverse, "OpBitCount": OpBitCount, "OpDPdx": OpDPdx, "OpDPdy": OpDPdy, "OpFwidth": OpFwidth, "OpDPdxFine": OpDPdxFine, "OpDPdyFine": OpDPdyFine, "OpFwidthFine": OpFwidthFine, "OpDPdxCoarse": OpDPdxCoarse, "OpDPdyCoarse": OpDPdyCoarse, "OpFwidthCoarse": OpFwidthCoarse, "OpEmitVertex": OpEmitVertex, "OpEndPrimitive": OpEndPrimitive, "OpEmitStreamVertex": OpEmitStreamVertex, "OpEndStreamPrimitive": OpEndStreamPrimitive, "OpControlBarrier": OpControlBarrier, "OpMemoryBarrier": OpMemoryBarrier, "OpAtomicLoad": OpAtomicLoad, "OpAtomicStore": OpAtomicStore, "OpAtomicExchange": OpAtomicExchange, "OpAtomicCompareExchange": OpAtomicCompareExchange, "OpAtomicCompareExchangeWeak": OpAtomicCompareExchangeWeak, "OpAtomicIIncrement": OpAtomicIIncrement, "OpAtomicIDecrement": OpAtomicIDecrement, "OpAtomicIAdd": OpAtomicIAdd, "OpAtomicISub": OpAtomicISub, "OpAtomicSMin": OpAtomicSMin, "OpAtomicUMin": OpAtomicUMin, "OpAtomicSMax": OpAtomicSMax, "OpAtomicUMax": OpAtomicUMax, "OpAtomicAnd": OpAtomicAnd, "OpAtomicOr": OpAtomicOr, "OpAtomicXor": OpAtomicXor, "OpPhi": OpPhi, "OpLoopMerge": OpLoopMerge, "OpSelectionMerge": OpSelectionMerge, "OpLabel": OpLabel, "OpBranch": OpBranch, "OpBranchConditional": OpBranchConditional, "OpSwitch": OpSwitch, "OpKill": OpKill, "OpReturn": OpReturn, "OpReturnValue": OpReturnValue, "OpUnreachable": OpUnreachable, "OpLifetimeStart": OpLifetimeStart, "OpLifetimeStop": OpLifetimeStop, "OpGroupAsyncCopy": OpGroupAsyncCopy, "OpGroupWaitEvents": OpGroupWaitEvents, "OpGroupAll": OpGroupAll, "OpGroupAny": OpGroupAny, "OpGroupBroadcast": OpGroupBroadcast, "OpGroupIAdd": OpGroupIAdd, "OpGroupFAdd": OpGroupFAdd, "OpGroupFMin": OpGroupFMin, "OpGroupUMin": OpGroupUMin, "OpGroupSMin": OpGroupSMin, "OpGroupFMax": OpGroupFMax, "OpGroupUMax": OpGroupUMax, "OpGroupSMax": OpGroupSMax, "OpReadPipe": OpReadPipe, "OpWritePipe": OpWritePipe, "OpReservedReadPipe": OpReservedReadPipe, "OpReservedWritePipe": OpReservedWritePipe, "OpReserveReadPipePackets": OpReserveReadPipePackets, "OpReserveWritePipePackets": OpReserveWritePipePackets, "OpCommitReadPipe": OpCommitReadPipe, "OpCommitWritePipe": OpCommitWritePipe, "OpIsValidReserveId": OpIsValidReserveId, "OpGetNumPipePackets": OpGetNumPipePackets, "OpGetMaxPipePackets": OpGetMaxPipePackets, "OpGroupReserveReadPipePackets": OpGroupReserveReadPipePackets, "OpGroupReserveWritePipePackets": OpGroupReserveWritePipePackets, "OpGroupCommitReadPipe": OpGroupCommitReadPipe, "OpGroupCommitWritePipe": OpGroupCommitWritePipe, "OpEnqueueMarker": OpEnqueueMarker, "OpEnqueueKernel": OpEnqueueKernel, "OpGetKernelNDrangeSubGroupCount": OpGetKernelNDrangeSubGroupCount, "OpGetKernelNDrangeMaxSubGroupSize": OpGetKernelNDrangeMaxSubGroupSize, "OpGetKernelWorkGroupSize": OpGetKernelWorkGroupSize, "OpGetKernelPreferredWorkGroupSizeMultiple": OpGetKernelPreferredWorkGroupSizeMultiple, "OpRetainEvent": OpRetainEvent, "OpReleaseEvent": OpReleaseEvent, "OpCreateUserEvent": OpCreateUserEvent, "OpIsValidEvent": OpIsValidEvent, "OpSetUserEventStatus": OpSetUserEventStatus, "OpCaptureEventProfilingInfo": OpCaptureEventProfilingInfo, "OpGetDefaultQueue": OpGetDefaultQueue, "OpBuildNDRange": OpBuildNDRange, "OpImageSparseSampleImplicitLod": OpImageSparseSampleImplicitLod, "OpImageSparseSampleExplicitLod": OpImageSparseSampleExplicitLod, "OpImageSparseSampleDrefImplicitLod": OpImageSparseSampleDrefImplicitLod, "OpImageSparseSampleDrefExplicitLod": OpImageSparseSampleDrefExplicitLod, "OpImageSparseSampleProjImplicitLod": OpImageSparseSampleProjImplicitLod, "OpImageSparseSampleProjExplicitLod": OpImageSparseSampleProjExplicitLod, "OpImageSparseSampleProjDrefImplicitLod": OpImageSparseSampleProjDrefImplicitLod, "OpImageSparseSampleProjDrefExplicitLod": OpImageSparseSampleProjDrefExplicitLod, "OpImageSparseFetch": OpImageSparseFetch, "OpImageSparseGather": OpImageSparseGather, "OpImageSparseDrefGather": OpImageSparseDrefGather, "OpImageSparseTexelsResident": OpImageSparseTexelsResident, "OpNoLine": OpNoLine, "OpAtomicFlagTestAndSet": OpAtomicFlagTestAndSet, "OpAtomicFlagClear": OpAtomicFlagClear, "OpImageSparseRead": OpImageSparseRead, "OpSizeOf": OpSizeOf, "OpTypePipeStorage": OpTypePipeStorage, "OpConstantPipeStorage": OpConstantPipeStorage, "OpCreatePipeFromPipeStorage": OpCreatePipeFromPipeStorage, "OpGetKernelLocalSizeForSubgroupCount": OpGetKernelLocalSizeForSubgroupCount, "OpGetKernelMaxNumSubgroups": OpGetKernelMaxNumSubgroups, "OpTypeNamedBarrier": OpTypeNamedBarrier, "OpNamedBarrierInitialize": OpNamedBarrierInitialize, "OpMemoryNamedBarrier": OpMemoryNamedBarrier, "OpModuleProcessed": OpModuleProcessed, "OpExecutionModeId": OpExecutionModeId, "OpDecorateId": OpDecorateId, "OpGroupNonUniformElect": OpGroupNonUniformElect, "OpGroupNonUniformAll": OpGroupNonUniformAll, "OpGroupNonUniformAny": OpGroupNonUniformAny, "OpGroupNonUniformAllEqual": OpGroupNonUniformAllEqual, "OpGroupNonUniformBroadcast": OpGroupNonUniformBroadcast, "OpGroupNonUniformBroadcastFirst": OpGroupNonUniformBroadcastFirst, "OpGroupNonUniformBallot": OpGroupNonUniformBallot, "OpGroupNonUniformInverseBallot": OpGroupNonUniformInverseBallot, "OpGroupNonUniformBallotBitExtract": OpGroupNonUniformBallotBitExtract, "OpGroupNonUniformBallotBitCount": OpGroupNonUniformBallotBitCount, "OpGroupNonUniformBallotFindLSB": OpGroupNonUniformBallotFindLSB, "OpGroupNonUniformBallotFindMSB": OpGroupNonUniformBallotFindMSB, "OpGroupNonUniformShuffle": OpGroupNonUniformShuffle, "OpGroupNonUniformShuffleXor": OpGroupNonUniformShuffleXor, "OpGroupNonUniformShuffleUp": OpGroupNonUniformShuffleUp, "OpGroupNonUniformShuffleDown": OpGroupNonUniformShuffleDown, "OpGroupNonUniformIAdd": OpGroupNonUniformIAdd, "OpGroupNonUniformFAdd": OpGroupNonUniformFAdd, "OpGroupNonUniformIMul": OpGroupNonUniformIMul, "OpGroupNonUniformFMul": OpGroupNonUniformFMul, "OpGroupNonUniformSMin": OpGroupNonUniformSMin, "OpGroupNonUniformUMin": OpGroupNonUniformUMin, "OpGroupNonUniformFMin": OpGroupNonUniformFMin, "OpGroupNonUniformSMax": OpGroupNonUniformSMax, "OpGroupNonUniformUMax": OpGroupNonUniformUMax, "OpGroupNonUniformFMax": OpGroupNonUniformFMax, "OpGroupNonUniformBitwiseAnd": OpGroupNonUniformBitwiseAnd, "OpGroupNonUniformBitwiseOr": OpGroupNonUniformBitwiseOr, "OpGroupNonUniformBitwiseXor": OpGroupNonUniformBitwiseXor, "OpGroupNonUniformLogicalAnd": OpGroupNonUniformLogicalAnd, "OpGroupNonUniformLogicalOr": OpGroupNonUniformLogicalOr, "OpGroupNonUniformLogicalXor": OpGroupNonUniformLogicalXor, "OpGroupNonUniformQuadBroadcast": OpGroupNonUniformQuadBroadcast, "OpGroupNonUniformQuadSwap": OpGroupNonUniformQuadSwap, "OpCopyLogical": OpCopyLogical, "OpPtrEqual": OpPtrEqual, "OpPtrNotEqual": OpPtrNotEqual, "OpPtrDiff": OpPtrDiff, "OpColorAttachmentReadEXT": OpColorAttachmentReadEXT, "OpDepthAttachmentReadEXT": OpDepthAttachmentReadEXT, "OpStencilAttachmentReadEXT": OpStencilAttachmentReadEXT, "OpTerminateInvocation": OpTerminateInvocation, "OpTypeUntypedPointerKHR": OpTypeUntypedPointerKHR, "OpUntypedVariableKHR": OpUntypedVariableKHR, "OpUntypedAccessChainKHR": OpUntypedAccessChainKHR, "OpUntypedInBoundsAccessChainKHR": OpUntypedInBoundsAccessChainKHR, "OpSubgroupBallotKHR": OpSubgroupBallotKHR, "OpSubgroupFirstInvocationKHR": OpSubgroupFirstInvocationKHR, "OpUntypedPtrAccessChainKHR": OpUntypedPtrAccessChainKHR, "OpUntypedInBoundsPtrAccessChainKHR": OpUntypedInBoundsPtrAccessChainKHR, "OpUntypedArrayLengthKHR": OpUntypedArrayLengthKHR, "OpUntypedPrefetchKHR": OpUntypedPrefetchKHR, "OpSubgroupAllKHR": OpSubgroupAllKHR, "OpSubgroupAnyKHR": OpSubgroupAnyKHR, "OpSubgroupAllEqualKHR": OpSubgroupAllEqualKHR, "OpGroupNonUniformRotateKHR": OpGroupNonUniformRotateKHR, "OpSubgroupReadInvocationKHR": OpSubgroupReadInvocationKHR, "OpExtInstWithForwardRefsKHR": OpExtInstWithForwardRefsKHR, "OpTraceRayKHR": OpTraceRayKHR, "OpExecuteCallableKHR": OpExecuteCallableKHR, "OpConvertUToAccelerationStructureKHR": OpConvertUToAccelerationStructureKHR, "OpIgnoreIntersectionKHR": OpIgnoreIntersectionKHR, "OpTerminateRayKHR": OpTerminateRayKHR, "OpSDot": OpSDot, "OpUDot": OpUDot, "OpSUDot": OpSUDot, "OpSDotAccSat": OpSDotAccSat, "OpUDotAccSat": OpUDotAccSat, "OpSUDotAccSat": OpSUDotAccSat, "OpTypeCooperativeMatrixKHR": OpTypeCooperativeMatrixKHR, "OpCooperativeMatrixLoadKHR": OpCooperativeMatrixLoadKHR, "OpCooperativeMatrixStoreKHR": OpCooperativeMatrixStoreKHR, "OpCooperativeMatrixMulAddKHR": OpCooperativeMatrixMulAddKHR, "OpCooperativeMatrixLengthKHR": OpCooperativeMatrixLengthKHR, "OpConstantCompositeReplicateEXT": OpConstantCompositeReplicateEXT, "OpSpecConstantCompositeReplicateEXT": OpSpecConstantCompositeReplicateEXT, "OpCompositeConstructReplicateEXT": OpCompositeConstructReplicateEXT, "OpTypeRayQueryKHR": OpTypeRayQueryKHR, "OpRayQueryInitializeKHR": OpRayQueryInitializeKHR, "OpRayQueryTerminateKHR": OpRayQueryTerminateKHR, "OpRayQueryGenerateIntersectionKHR": OpRayQueryGenerateIntersectionKHR, "OpRayQueryConfirmIntersectionKHR": OpRayQueryConfirmIntersectionKHR, "OpRayQueryProceedKHR": OpRayQueryProceedKHR, "OpRayQueryGetIntersectionTypeKHR": OpRayQueryGetIntersectionTypeKHR, "OpImageSampleWeightedQCOM": OpImageSampleWeightedQCOM, "OpImageBoxFilterQCOM": OpImageBoxFilterQCOM, "OpImageBlockMatchSSDQCOM": OpImageBlockMatchSSDQCOM, "OpImageBlockMatchSADQCOM": OpImageBlockMatchSADQCOM, "OpImageBlockMatchWindowSSDQCOM": OpImageBlockMatchWindowSSDQCOM, "OpImageBlockMatchWindowSADQCOM": OpImageBlockMatchWindowSADQCOM, "OpImageBlockMatchGatherSSDQCOM": OpImageBlockMatchGatherSSDQCOM, "OpImageBlockMatchGatherSADQCOM": OpImageBlockMatchGatherSADQCOM, "OpGroupIAddNonUniformAMD": OpGroupIAddNonUniformAMD, "OpGroupFAddNonUniformAMD": OpGroupFAddNonUniformAMD, "OpGroupFMinNonUniformAMD": OpGroupFMinNonUniformAMD, "OpGroupUMinNonUniformAMD": OpGroupUMinNonUniformAMD, "OpGroupSMinNonUniformAMD": OpGroupSMinNonUniformAMD, "OpGroupFMaxNonUniformAMD": OpGroupFMaxNonUniformAMD, "OpGroupUMaxNonUniformAMD": OpGroupUMaxNonUniformAMD, "OpGroupSMaxNonUniformAMD": OpGroupSMaxNonUniformAMD, "OpFragmentMaskFetchAMD": OpFragmentMaskFetchAMD, "OpFragmentFetchAMD": OpFragmentFetchAMD, "OpReadClockKHR": OpReadClockKHR, "OpAllocateNodePayloadsAMDX": OpAllocateNodePayloadsAMDX, "OpEnqueueNodePayloadsAMDX": OpEnqueueNodePayloadsAMDX, "OpTypeNodePayloadArrayAMDX": OpTypeNodePayloadArrayAMDX, "OpFinishWritingNodePayloadAMDX": OpFinishWritingNodePayloadAMDX, "OpNodePayloadArrayLengthAMDX": OpNodePayloadArrayLengthAMDX, "OpIsNodePayloadValidAMDX": OpIsNodePayloadValidAMDX, "OpConstantStringAMDX": OpConstantStringAMDX, "OpSpecConstantStringAMDX": OpSpecConstantStringAMDX, "OpGroupNonUniformQuadAllKHR": OpGroupNonUniformQuadAllKHR, "OpGroupNonUniformQuadAnyKHR": OpGroupNonUniformQuadAnyKHR, "OpHitObjectRecordHitMotionNV": OpHitObjectRecordHitMotionNV, "OpHitObjectRecordHitWithIndexMotionNV": OpHitObjectRecordHitWithIndexMotionNV, "OpHitObjectRecordMissMotionNV": OpHitObjectRecordMissMotionNV, "OpHitObjectGetWorldToObjectNV": OpHitObjectGetWorldToObjectNV, "OpHitObjectGetObjectToWorldNV": OpHitObjectGetObjectToWorldNV, "OpHitObjectGetObjectRayDirectionNV": OpHitObjectGetObjectRayDirectionNV, "OpHitObjectGetObjectRayOriginNV": OpHitObjectGetObjectRayOriginNV, "OpHitObjectTraceRayMotionNV": OpHitObjectTraceRayMotionNV, "OpHitObjectGetShaderRecordBufferHandleNV": OpHitObjectGetShaderRecordBufferHandleNV, "OpHitObjectGetShaderBindingTableRecordIndexNV": OpHitObjectGetShaderBindingTableRecordIndexNV, "OpHitObjectRecordEmptyNV": OpHitObjectRecordEmptyNV, "OpHitObjectTraceRayNV": OpHitObjectTraceRayNV, "OpHitObjectRecordHitNV": OpHitObjectRecordHitNV, "OpHitObjectRecordHitWithIndexNV": OpHitObjectRecordHitWithIndexNV, "OpHitObjectRecordMissNV": OpHitObjectRecordMissNV, "OpHitObjectExecuteShaderNV": OpHitObjectExecuteShaderNV, "OpHitObjectGetCurrentTimeNV": OpHitObjectGetCurrentTimeNV, "OpHitObjectGetAttributesNV": OpHitObjectGetAttributesNV, "OpHitObjectGetHitKindNV": OpHitObjectGetHitKindNV, "OpHitObjectGetPrimitiveIndexNV": OpHitObjectGetPrimitiveIndexNV, "OpHitObjectGetGeometryIndexNV": OpHitObjectGetGeometryIndexNV, "OpHitObjectGetInstanceIdNV": OpHitObjectGetInstanceIdNV, "OpHitObjectGetInstanceCustomIndexNV": OpHitObjectGetInstanceCustomIndexNV, "OpHitObjectGetWorldRayDirectionNV": OpHitObjectGetWorldRayDirectionNV, "OpHitObjectGetWorldRayOriginNV": OpHitObjectGetWorldRayOriginNV, "OpHitObjectGetRayTMaxNV": OpHitObjectGetRayTMaxNV, "OpHitObjectGetRayTMinNV": OpHitObjectGetRayTMinNV, "OpHitObjectIsEmptyNV": OpHitObjectIsEmptyNV, "OpHitObjectIsHitNV": OpHitObjectIsHitNV, "OpHitObjectIsMissNV": OpHitObjectIsMissNV, "OpReorderThreadWithHitObjectNV": OpReorderThreadWithHitObjectNV, "OpReorderThreadWithHintNV": OpReorderThreadWithHintNV, "OpTypeHitObjectNV": OpTypeHitObjectNV, "OpImageSampleFootprintNV": OpImageSampleFootprintNV, "OpCooperativeMatrixConvertNV": OpCooperativeMatrixConvertNV, "OpEmitMeshTasksEXT": OpEmitMeshTasksEXT, "OpSetMeshOutputsEXT": OpSetMeshOutputsEXT, "OpGroupNonUniformPartitionNV": OpGroupNonUniformPartitionNV, "OpWritePackedPrimitiveIndices4x8NV": OpWritePackedPrimitiveIndices4x8NV, "OpFetchMicroTriangleVertexPositionNV": OpFetchMicroTriangleVertexPositionNV, "OpFetchMicroTriangleVertexBarycentricNV": OpFetchMicroTriangleVertexBarycentricNV, "OpReportIntersectionKHR": OpReportIntersectionKHR, "OpIgnoreIntersectionNV": OpIgnoreIntersectionNV, "OpTerminateRayNV": OpTerminateRayNV, "OpTraceNV": OpTraceNV, "OpTraceMotionNV": OpTraceMotionNV, "OpTraceRayMotionNV": OpTraceRayMotionNV, "OpRayQueryGetIntersectionTriangleVertexPositionsKHR": OpRayQueryGetIntersectionTriangleVertexPositionsKHR, "OpTypeAccelerationStructureKHR": OpTypeAccelerationStructureKHR, "OpExecuteCallableNV": OpExecuteCallableNV, "OpTypeCooperativeMatrixNV": OpTypeCooperativeMatrixNV, "OpCooperativeMatrixLoadNV": OpCooperativeMatrixLoadNV, "OpCooperativeMatrixStoreNV": OpCooperativeMatrixStoreNV, "OpCooperativeMatrixMulAddNV": OpCooperativeMatrixMulAddNV, "OpCooperativeMatrixLengthNV": OpCooperativeMatrixLengthNV, "OpBeginInvocationInterlockEXT": OpBeginInvocationInterlockEXT, "OpEndInvocationInterlockEXT": OpEndInvocationInterlockEXT, "OpCooperativeMatrixReduceNV": OpCooperativeMatrixReduceNV, "OpCooperativeMatrixLoadTensorNV": OpCooperativeMatrixLoadTensorNV, "OpCooperativeMatrixStoreTensorNV": OpCooperativeMatrixStoreTensorNV, "OpCooperativeMatrixPerElementOpNV": OpCooperativeMatrixPerElementOpNV, "OpTypeTensorLayoutNV": OpTypeTensorLayoutNV, "OpTypeTensorViewNV": OpTypeTensorViewNV, "OpCreateTensorLayoutNV": OpCreateTensorLayoutNV, "OpTensorLayoutSetDimensionNV": OpTensorLayoutSetDimensionNV, "OpTensorLayoutSetStrideNV": OpTensorLayoutSetStrideNV, "OpTensorLayoutSliceNV": OpTensorLayoutSliceNV, "OpTensorLayoutSetClampValueNV": OpTensorLayoutSetClampValueNV, "OpCreateTensorViewNV": OpCreateTensorViewNV, "OpTensorViewSetDimensionNV": OpTensorViewSetDimensionNV, "OpTensorViewSetStrideNV": OpTensorViewSetStrideNV, "OpDemoteToHelperInvocation": OpDemoteToHelperInvocation, "OpIsHelperInvocationEXT": OpIsHelperInvocationEXT, "OpTensorViewSetClipNV": OpTensorViewSetClipNV, "OpTensorLayoutSetBlockSizeNV": OpTensorLayoutSetBlockSizeNV, "OpCooperativeMatrixTransposeNV": OpCooperativeMatrixTransposeNV, "OpConvertUToImageNV": OpConvertUToImageNV, "OpConvertUToSamplerNV": OpConvertUToSamplerNV, "OpConvertImageToUNV": OpConvertImageToUNV, "OpConvertSamplerToUNV": OpConvertSamplerToUNV, "OpConvertUToSampledImageNV": OpConvertUToSampledImageNV, "OpConvertSampledImageToUNV": OpConvertSampledImageToUNV, "OpSamplerImageAddressingModeNV": OpSamplerImageAddressingModeNV, "OpRawAccessChainNV": OpRawAccessChainNV, "OpSubgroupShuffleINTEL": OpSubgroupShuffleINTEL, "OpSubgroupShuffleDownINTEL": OpSubgroupShuffleDownINTEL, "OpSubgroupShuffleUpINTEL": OpSubgroupShuffleUpINTEL, "OpSubgroupShuffleXorINTEL": OpSubgroupShuffleXorINTEL, "OpSubgroupBlockReadINTEL": OpSubgroupBlockReadINTEL, "OpSubgroupBlockWriteINTEL": OpSubgroupBlockWriteINTEL, "OpSubgroupImageBlockReadINTEL": OpSubgroupImageBlockReadINTEL, "OpSubgroupImageBlockWriteINTEL": OpSubgroupImageBlockWriteINTEL, "OpSubgroupImageMediaBlockReadINTEL": OpSubgroupImageMediaBlockReadINTEL, "OpSubgroupImageMediaBlockWriteINTEL": OpSubgroupImageMediaBlockWriteINTEL, "OpUCountLeadingZerosINTEL": OpUCountLeadingZerosINTEL, "OpUCountTrailingZerosINTEL": OpUCountTrailingZerosINTEL, "OpAbsISubINTEL": OpAbsISubINTEL, "OpAbsUSubINTEL": OpAbsUSubINTEL, "OpIAddSatINTEL": OpIAddSatINTEL, "OpUAddSatINTEL": OpUAddSatINTEL, "OpIAverageINTEL": OpIAverageINTEL, "OpUAverageINTEL": OpUAverageINTEL, "OpIAverageRoundedINTEL": OpIAverageRoundedINTEL, "OpUAverageRoundedINTEL": OpUAverageRoundedINTEL, "OpISubSatINTEL": OpISubSatINTEL, "OpUSubSatINTEL": OpUSubSatINTEL, "OpIMul32x16INTEL": OpIMul32x16INTEL, "OpUMul32x16INTEL": OpUMul32x16INTEL, "OpConstantFunctionPointerINTEL": OpConstantFunctionPointerINTEL, "OpFunctionPointerCallINTEL": OpFunctionPointerCallINTEL, "OpAsmTargetINTEL": OpAsmTargetINTEL, "OpAsmINTEL": OpAsmINTEL, "OpAsmCallINTEL": OpAsmCallINTEL, "OpAtomicFMinEXT": OpAtomicFMinEXT, "OpAtomicFMaxEXT": OpAtomicFMaxEXT, "OpAssumeTrueKHR": OpAssumeTrueKHR, "OpExpectKHR": OpExpectKHR, "OpDecorateString": OpDecorateString, "OpMemberDecorateString": OpMemberDecorateString, "OpVmeImageINTEL": OpVmeImageINTEL, "OpTypeVmeImageINTEL": OpTypeVmeImageINTEL, "OpTypeAvcImePayloadINTEL": OpTypeAvcImePayloadINTEL, "OpTypeAvcRefPayloadINTEL": OpTypeAvcRefPayloadINTEL, "OpTypeAvcSicPayloadINTEL": OpTypeAvcSicPayloadINTEL, "OpTypeAvcMcePayloadINTEL": OpTypeAvcMcePayloadINTEL, "OpTypeAvcMceResultINTEL": OpTypeAvcMceResultINTEL, "OpTypeAvcImeResultINTEL": OpTypeAvcImeResultINTEL, "OpTypeAvcImeResultSingleReferenceStreamoutINTEL": OpTypeAvcImeResultSingleReferenceStreamoutINTEL, "OpTypeAvcImeResultDualReferenceStreamoutINTEL": OpTypeAvcImeResultDualReferenceStreamoutINTEL, "OpTypeAvcImeSingleReferenceStreaminINTEL": OpTypeAvcImeSingleReferenceStreaminINTEL, "OpTypeAvcImeDualReferenceStreaminINTEL": OpTypeAvcImeDualReferenceStreaminINTEL, "OpTypeAvcRefResultINTEL": OpTypeAvcRefResultINTEL, "OpTypeAvcSicResultINTEL": OpTypeAvcSicResultINTEL, "OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL": OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL, "OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL": OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL, "OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL": OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL, "OpSubgroupAvcMceSetInterShapePenaltyINTEL": OpSubgroupAvcMceSetInterShapePenaltyINTEL, "OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL": OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL, "OpSubgroupAvcMceSetInterDirectionPenaltyINTEL": OpSubgroupAvcMceSetInterDirectionPenaltyINTEL, "OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL": OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL, "OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL": OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL, "OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL": OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL, "OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL": OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL, "OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL": OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL, "OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL": OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL, "OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL": OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL, "OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL": OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL, "OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL": OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL, "OpSubgroupAvcMceSetAcOnlyHaarINTEL": OpSubgroupAvcMceSetAcOnlyHaarINTEL, "OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL": OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL, "OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL": OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL, "OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL": OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL, "OpSubgroupAvcMceConvertToImePayloadINTEL": OpSubgroupAvcMceConvertToImePayloadINTEL, "OpSubgroupAvcMceConvertToImeResultINTEL": OpSubgroupAvcMceConvertToImeResultINTEL, "OpSubgroupAvcMceConvertToRefPayloadINTEL": OpSubgroupAvcMceConvertToRefPayloadINTEL, "OpSubgroupAvcMceConvertToRefResultINTEL": OpSubgroupAvcMceConvertToRefResultINTEL, "OpSubgroupAvcMceConvertToSicPayloadINTEL": OpSubgroupAvcMceConvertToSicPayloadINTEL, "OpSubgroupAvcMceConvertToSicResultINTEL": OpSubgroupAvcMceConvertToSicResultINTEL, "OpSubgroupAvcMceGetMotionVectorsINTEL": OpSubgroupAvcMceGetMotionVectorsINTEL, "OpSubgroupAvcMceGetInterDistortionsINTEL": OpSubgroupAvcMceGetInterDistortionsINTEL, "OpSubgroupAvcMceGetBestInterDistortionsINTEL": OpSubgroupAvcMceGetBestInterDistortionsINTEL, "OpSubgroupAvcMceGetInterMajorShapeINTEL": OpSubgroupAvcMceGetInterMajorShapeINTEL, "OpSubgroupAvcMceGetInterMinorShapeINTEL": OpSubgroupAvcMceGetInterMinorShapeINTEL, "OpSubgroupAvcMceGetInterDirectionsINTEL": OpSubgroupAvcMceGetInterDirectionsINTEL, "OpSubgroupAvcMceGetInterMotionVectorCountINTEL": OpSubgroupAvcMceGetInterMotionVectorCountINTEL, "OpSubgroupAvcMceGetInterReferenceIdsINTEL": OpSubgroupAvcMceGetInterReferenceIdsINTEL, "OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL": OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL, "OpSubgroupAvcImeInitializeINTEL": OpSubgroupAvcImeInitializeINTEL, "OpSubgroupAvcImeSetSingleReferenceINTEL": OpSubgroupAvcImeSetSingleReferenceINTEL, "OpSubgroupAvcImeSetDualReferenceINTEL": OpSubgroupAvcImeSetDualReferenceINTEL, "OpSubgroupAvcImeRefWindowSizeINTEL": OpSubgroupAvcImeRefWindowSizeINTEL, "OpSubgroupAvcImeAdjustRefOffsetINTEL": OpSubgroupAvcImeAdjustRefOffsetINTEL, "OpSubgroupAvcImeConvertToMcePayloadINTEL": OpSubgroupAvcImeConvertToMcePayloadINTEL, "OpSubgroupAvcImeSetMaxMotionVectorCountINTEL": OpSubgroupAvcImeSetMaxMotionVectorCountINTEL, "OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL": OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL, "OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL": OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL, "OpSubgroupAvcImeSetWeightedSadINTEL": OpSubgroupAvcImeSetWeightedSadINTEL, "OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL": OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL, "OpSubgroupAvcImeEvaluateWithDualReferenceINTEL": OpSubgroupAvcImeEvaluateWithDualReferenceINTEL, "OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL": OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL, "OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL": OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL, "OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL": OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL, "OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL": OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL, "OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL": OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL, "OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL": OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL, "OpSubgroupAvcImeConvertToMceResultINTEL": OpSubgroupAvcImeConvertToMceResultINTEL, "OpSubgroupAvcImeGetSingleReferenceStreaminINTEL": OpSubgroupAvcImeGetSingleReferenceStreaminINTEL, "OpSubgroupAvcImeGetDualReferenceStreaminINTEL": OpSubgroupAvcImeGetDualReferenceStreaminINTEL, "OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL": OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL, "OpSubgroupAvcImeStripDualReferenceStreamoutINTEL": OpSubgroupAvcImeStripDualReferenceStreamoutINTEL, "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL": OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL, "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL": OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL, "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL": OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL, "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL": OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL, "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL": OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL, "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL": OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL, "OpSubgroupAvcImeGetBorderReachedINTEL": OpSubgroupAvcImeGetBorderReachedINTEL, "OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL": OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL, "OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL": OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL, "OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL": OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL, "OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL": OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL, "OpSubgroupAvcFmeInitializeINTEL": OpSubgroupAvcFmeInitializeINTEL, "OpSubgroupAvcBmeInitializeINTEL": OpSubgroupAvcBmeInitializeINTEL, "OpSubgroupAvcRefConvertToMcePayloadINTEL": OpSubgroupAvcRefConvertToMcePayloadINTEL, "OpSubgroupAvcRefSetBidirectionalMixDisableINTEL": OpSubgroupAvcRefSetBidirectionalMixDisableINTEL, "OpSubgroupAvcRefSetBilinearFilterEnableINTEL": OpSubgroupAvcRefSetBilinearFilterEnableINTEL, "OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL": OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL, "OpSubgroupAvcRefEvaluateWithDualReferenceINTEL": OpSubgroupAvcRefEvaluateWithDualReferenceINTEL, "OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL": OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL, "OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL": OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL, "OpSubgroupAvcRefConvertToMceResultINTEL": OpSubgroupAvcRefConvertToMceResultINTEL, "OpSubgroupAvcSicInitializeINTEL": OpSubgroupAvcSicInitializeINTEL, "OpSubgroupAvcSicConfigureSkcINTEL": OpSubgroupAvcSicConfigureSkcINTEL, "OpSubgroupAvcSicConfigureIpeLumaINTEL": OpSubgroupAvcSicConfigureIpeLumaINTEL, "OpSubgroupAvcSicConfigureIpeLumaChromaINTEL": OpSubgroupAvcSicConfigureIpeLumaChromaINTEL, "OpSubgroupAvcSicGetMotionVectorMaskINTEL": OpSubgroupAvcSicGetMotionVectorMaskINTEL, "OpSubgroupAvcSicConvertToMcePayloadINTEL": OpSubgroupAvcSicConvertToMcePayloadINTEL, "OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL": OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL, "OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL": OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL, "OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL": OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL, "OpSubgroupAvcSicSetBilinearFilterEnableINTEL": OpSubgroupAvcSicSetBilinearFilterEnableINTEL, "OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL": OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL, "OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL": OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL, "OpSubgroupAvcSicEvaluateIpeINTEL": OpSubgroupAvcSicEvaluateIpeINTEL, "OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL": OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL, "OpSubgroupAvcSicEvaluateWithDualReferenceINTEL": OpSubgroupAvcSicEvaluateWithDualReferenceINTEL, "OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL": OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL, "OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL": OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL, "OpSubgroupAvcSicConvertToMceResultINTEL": OpSubgroupAvcSicConvertToMceResultINTEL, "OpSubgroupAvcSicGetIpeLumaShapeINTEL": OpSubgroupAvcSicGetIpeLumaShapeINTEL, "OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL": OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL, "OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL": OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL, "OpSubgroupAvcSicGetPackedIpeLumaModesINTEL": OpSubgroupAvcSicGetPackedIpeLumaModesINTEL, "OpSubgroupAvcSicGetIpeChromaModeINTEL": OpSubgroupAvcSicGetIpeChromaModeINTEL, "OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL": OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL, "OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL": OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL, "OpSubgroupAvcSicGetInterRawSadsINTEL": OpSubgroupAvcSicGetInterRawSadsINTEL, "OpVariableLengthArrayINTEL": OpVariableLengthArrayINTEL, "OpSaveMemoryINTEL": OpSaveMemoryINTEL, "OpRestoreMemoryINTEL": OpRestoreMemoryINTEL, "OpArbitraryFloatSinCosPiINTEL": OpArbitraryFloatSinCosPiINTEL, "OpArbitraryFloatCastINTEL": OpArbitraryFloatCastINTEL, "OpArbitraryFloatCastFromIntINTEL": OpArbitraryFloatCastFromIntINTEL, "OpArbitraryFloatCastToIntINTEL": OpArbitraryFloatCastToIntINTEL, "OpArbitraryFloatAddINTEL": OpArbitraryFloatAddINTEL, "OpArbitraryFloatSubINTEL": OpArbitraryFloatSubINTEL, "OpArbitraryFloatMulINTEL": OpArbitraryFloatMulINTEL, "OpArbitraryFloatDivINTEL": OpArbitraryFloatDivINTEL, "OpArbitraryFloatGTINTEL": OpArbitraryFloatGTINTEL, "OpArbitraryFloatGEINTEL": OpArbitraryFloatGEINTEL, "OpArbitraryFloatLTINTEL": OpArbitraryFloatLTINTEL, "OpArbitraryFloatLEINTEL": OpArbitraryFloatLEINTEL, "OpArbitraryFloatEQINTEL": OpArbitraryFloatEQINTEL, "OpArbitraryFloatRecipINTEL": OpArbitraryFloatRecipINTEL, "OpArbitraryFloatRSqrtINTEL": OpArbitraryFloatRSqrtINTEL, "OpArbitraryFloatCbrtINTEL": OpArbitraryFloatCbrtINTEL, "OpArbitraryFloatHypotINTEL": OpArbitraryFloatHypotINTEL, "OpArbitraryFloatSqrtINTEL": OpArbitraryFloatSqrtINTEL, "OpArbitraryFloatLogINTEL": OpArbitraryFloatLogINTEL, "OpArbitraryFloatLog2INTEL": OpArbitraryFloatLog2INTEL, "OpArbitraryFloatLog10INTEL": OpArbitraryFloatLog10INTEL, "OpArbitraryFloatLog1pINTEL": OpArbitraryFloatLog1pINTEL, "OpArbitraryFloatExpINTEL": OpArbitraryFloatExpINTEL, "OpArbitraryFloatExp2INTEL": OpArbitraryFloatExp2INTEL, "OpArbitraryFloatExp10INTEL": OpArbitraryFloatExp10INTEL, "OpArbitraryFloatExpm1INTEL": OpArbitraryFloatExpm1INTEL, "OpArbitraryFloatSinINTEL": OpArbitraryFloatSinINTEL, "OpArbitraryFloatCosINTEL": OpArbitraryFloatCosINTEL, "OpArbitraryFloatSinCosINTEL": OpArbitraryFloatSinCosINTEL, "OpArbitraryFloatSinPiINTEL": OpArbitraryFloatSinPiINTEL, "OpArbitraryFloatCosPiINTEL": OpArbitraryFloatCosPiINTEL, "OpArbitraryFloatASinINTEL": OpArbitraryFloatASinINTEL, "OpArbitraryFloatASinPiINTEL": OpArbitraryFloatASinPiINTEL, "OpArbitraryFloatACosINTEL": OpArbitraryFloatACosINTEL, "OpArbitraryFloatACosPiINTEL": OpArbitraryFloatACosPiINTEL, "OpArbitraryFloatATanINTEL": OpArbitraryFloatATanINTEL, "OpArbitraryFloatATanPiINTEL": OpArbitraryFloatATanPiINTEL, "OpArbitraryFloatATan2INTEL": OpArbitraryFloatATan2INTEL, "OpArbitraryFloatPowINTEL": OpArbitraryFloatPowINTEL, "OpArbitraryFloatPowRINTEL": OpArbitraryFloatPowRINTEL, "OpArbitraryFloatPowNINTEL": OpArbitraryFloatPowNINTEL, "OpLoopControlINTEL": OpLoopControlINTEL, "OpAliasDomainDeclINTEL": OpAliasDomainDeclINTEL, "OpAliasScopeDeclINTEL": OpAliasScopeDeclINTEL, "OpAliasScopeListDeclINTEL": OpAliasScopeListDeclINTEL, "OpFixedSqrtINTEL": OpFixedSqrtINTEL, "OpFixedRecipINTEL": OpFixedRecipINTEL, "OpFixedRsqrtINTEL": OpFixedRsqrtINTEL, "OpFixedSinINTEL": OpFixedSinINTEL, "OpFixedCosINTEL": OpFixedCosINTEL, "OpFixedSinCosINTEL": OpFixedSinCosINTEL, "OpFixedSinPiINTEL": OpFixedSinPiINTEL, "OpFixedCosPiINTEL": OpFixedCosPiINTEL, "OpFixedSinCosPiINTEL": OpFixedSinCosPiINTEL, "OpFixedLogINTEL": OpFixedLogINTEL, "OpFixedExpINTEL": OpFixedExpINTEL, "OpPtrCastToCrossWorkgroupINTEL": OpPtrCastToCrossWorkgroupINTEL, "OpCrossWorkgroupCastToPtrINTEL": OpCrossWorkgroupCastToPtrINTEL, "OpReadPipeBlockingINTEL": OpReadPipeBlockingINTEL, "OpWritePipeBlockingINTEL": OpWritePipeBlockingINTEL, "OpFPGARegINTEL": OpFPGARegINTEL, "OpRayQueryGetRayTMinKHR": OpRayQueryGetRayTMinKHR, "OpRayQueryGetRayFlagsKHR": OpRayQueryGetRayFlagsKHR, "OpRayQueryGetIntersectionTKHR": OpRayQueryGetIntersectionTKHR, "OpRayQueryGetIntersectionInstanceCustomIndexKHR": OpRayQueryGetIntersectionInstanceCustomIndexKHR, "OpRayQueryGetIntersectionInstanceIdKHR": OpRayQueryGetIntersectionInstanceIdKHR, "OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR": OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR, "OpRayQueryGetIntersectionGeometryIndexKHR": OpRayQueryGetIntersectionGeometryIndexKHR, "OpRayQueryGetIntersectionPrimitiveIndexKHR": OpRayQueryGetIntersectionPrimitiveIndexKHR, "OpRayQueryGetIntersectionBarycentricsKHR": OpRayQueryGetIntersectionBarycentricsKHR, "OpRayQueryGetIntersectionFrontFaceKHR": OpRayQueryGetIntersectionFrontFaceKHR, "OpRayQueryGetIntersectionCandidateAABBOpaqueKHR": OpRayQueryGetIntersectionCandidateAABBOpaqueKHR, "OpRayQueryGetIntersectionObjectRayDirectionKHR": OpRayQueryGetIntersectionObjectRayDirectionKHR, "OpRayQueryGetIntersectionObjectRayOriginKHR": OpRayQueryGetIntersectionObjectRayOriginKHR, "OpRayQueryGetWorldRayDirectionKHR": OpRayQueryGetWorldRayDirectionKHR, "OpRayQueryGetWorldRayOriginKHR": OpRayQueryGetWorldRayOriginKHR, "OpRayQueryGetIntersectionObjectToWorldKHR": OpRayQueryGetIntersectionObjectToWorldKHR, "OpRayQueryGetIntersectionWorldToObjectKHR": OpRayQueryGetIntersectionWorldToObjectKHR, "OpAtomicFAddEXT": OpAtomicFAddEXT, "OpTypeBufferSurfaceINTEL": OpTypeBufferSurfaceINTEL, "OpTypeStructContinuedINTEL": OpTypeStructContinuedINTEL, "OpConstantCompositeContinuedINTEL": OpConstantCompositeContinuedINTEL, "OpSpecConstantCompositeContinuedINTEL": OpSpecConstantCompositeContinuedINTEL, "OpCompositeConstructContinuedINTEL": OpCompositeConstructContinuedINTEL, "OpConvertFToBF16INTEL": OpConvertFToBF16INTEL, "OpConvertBF16ToFINTEL": OpConvertBF16ToFINTEL, "OpControlBarrierArriveINTEL": OpControlBarrierArriveINTEL, "OpControlBarrierWaitINTEL": OpControlBarrierWaitINTEL, "OpArithmeticFenceEXT": OpArithmeticFenceEXT, "OpSubgroupBlockPrefetchINTEL": OpSubgroupBlockPrefetchINTEL, "OpGroupIMulKHR": OpGroupIMulKHR, "OpGroupFMulKHR": OpGroupFMulKHR, "OpGroupBitwiseAndKHR": OpGroupBitwiseAndKHR, "OpGroupBitwiseOrKHR": OpGroupBitwiseOrKHR, "OpGroupBitwiseXorKHR": OpGroupBitwiseXorKHR, "OpGroupLogicalAndKHR": OpGroupLogicalAndKHR, "OpGroupLogicalOrKHR": OpGroupLogicalOrKHR, "OpGroupLogicalXorKHR": OpGroupLogicalXorKHR, "OpMaskedGatherINTEL": OpMaskedGatherINTEL, "OpMaskedScatterINTEL": OpMaskedScatterINTEL, } // ExtOpcodes is a map of extension name to Opcode description list. ExtOpcodes = map[string]OpcodeMap { "GLSL.std.450": { "Round": GLSLStd450_Round, "RoundEven": GLSLStd450_RoundEven, "Trunc": GLSLStd450_Trunc, "FAbs": GLSLStd450_FAbs, "SAbs": GLSLStd450_SAbs, "FSign": GLSLStd450_FSign, "SSign": GLSLStd450_SSign, "Floor": GLSLStd450_Floor, "Ceil": GLSLStd450_Ceil, "Fract": GLSLStd450_Fract, "Radians": GLSLStd450_Radians, "Degrees": GLSLStd450_Degrees, "Sin": GLSLStd450_Sin, "Cos": GLSLStd450_Cos, "Tan": GLSLStd450_Tan, "Asin": GLSLStd450_Asin, "Acos": GLSLStd450_Acos, "Atan": GLSLStd450_Atan, "Sinh": GLSLStd450_Sinh, "Cosh": GLSLStd450_Cosh, "Tanh": GLSLStd450_Tanh, "Asinh": GLSLStd450_Asinh, "Acosh": GLSLStd450_Acosh, "Atanh": GLSLStd450_Atanh, "Atan2": GLSLStd450_Atan2, "Pow": GLSLStd450_Pow, "Exp": GLSLStd450_Exp, "Log": GLSLStd450_Log, "Exp2": GLSLStd450_Exp2, "Log2": GLSLStd450_Log2, "Sqrt": GLSLStd450_Sqrt, "InverseSqrt": GLSLStd450_InverseSqrt, "Determinant": GLSLStd450_Determinant, "MatrixInverse": GLSLStd450_MatrixInverse, "Modf": GLSLStd450_Modf, "ModfStruct": GLSLStd450_ModfStruct, "FMin": GLSLStd450_FMin, "UMin": GLSLStd450_UMin, "SMin": GLSLStd450_SMin, "FMax": GLSLStd450_FMax, "UMax": GLSLStd450_UMax, "SMax": GLSLStd450_SMax, "FClamp": GLSLStd450_FClamp, "UClamp": GLSLStd450_UClamp, "SClamp": GLSLStd450_SClamp, "FMix": GLSLStd450_FMix, "IMix": GLSLStd450_IMix, "Step": GLSLStd450_Step, "SmoothStep": GLSLStd450_SmoothStep, "Fma": GLSLStd450_Fma, "Frexp": GLSLStd450_Frexp, "FrexpStruct": GLSLStd450_FrexpStruct, "Ldexp": GLSLStd450_Ldexp, "PackSnorm4x8": GLSLStd450_PackSnorm4x8, "PackUnorm4x8": GLSLStd450_PackUnorm4x8, "PackSnorm2x16": GLSLStd450_PackSnorm2x16, "PackUnorm2x16": GLSLStd450_PackUnorm2x16, "PackHalf2x16": GLSLStd450_PackHalf2x16, "PackDouble2x32": GLSLStd450_PackDouble2x32, "UnpackSnorm2x16": GLSLStd450_UnpackSnorm2x16, "UnpackUnorm2x16": GLSLStd450_UnpackUnorm2x16, "UnpackHalf2x16": GLSLStd450_UnpackHalf2x16, "UnpackSnorm4x8": GLSLStd450_UnpackSnorm4x8, "UnpackUnorm4x8": GLSLStd450_UnpackUnorm4x8, "UnpackDouble2x32": GLSLStd450_UnpackDouble2x32, "Length": GLSLStd450_Length, "Distance": GLSLStd450_Distance, "Cross": GLSLStd450_Cross, "Normalize": GLSLStd450_Normalize, "FaceForward": GLSLStd450_FaceForward, "Reflect": GLSLStd450_Reflect, "Refract": GLSLStd450_Refract, "FindILsb": GLSLStd450_FindILsb, "FindSMsb": GLSLStd450_FindSMsb, "FindUMsb": GLSLStd450_FindUMsb, "InterpolateAtCentroid": GLSLStd450_InterpolateAtCentroid, "InterpolateAtSample": GLSLStd450_InterpolateAtSample, "InterpolateAtOffset": GLSLStd450_InterpolateAtOffset, "NMin": GLSLStd450_NMin, "NMax": GLSLStd450_NMax, "NClamp": GLSLStd450_NClamp, }, "OpenCL.std": { "acos": OpenCLStd_acos, "acosh": OpenCLStd_acosh, "acospi": OpenCLStd_acospi, "asin": OpenCLStd_asin, "asinh": OpenCLStd_asinh, "asinpi": OpenCLStd_asinpi, "atan": OpenCLStd_atan, "atan2": OpenCLStd_atan2, "atanh": OpenCLStd_atanh, "atanpi": OpenCLStd_atanpi, "atan2pi": OpenCLStd_atan2pi, "cbrt": OpenCLStd_cbrt, "ceil": OpenCLStd_ceil, "copysign": OpenCLStd_copysign, "cos": OpenCLStd_cos, "cosh": OpenCLStd_cosh, "cospi": OpenCLStd_cospi, "erfc": OpenCLStd_erfc, "erf": OpenCLStd_erf, "exp": OpenCLStd_exp, "exp2": OpenCLStd_exp2, "exp10": OpenCLStd_exp10, "expm1": OpenCLStd_expm1, "fabs": OpenCLStd_fabs, "fdim": OpenCLStd_fdim, "floor": OpenCLStd_floor, "fma": OpenCLStd_fma, "fmax": OpenCLStd_fmax, "fmin": OpenCLStd_fmin, "fmod": OpenCLStd_fmod, "fract": OpenCLStd_fract, "frexp": OpenCLStd_frexp, "hypot": OpenCLStd_hypot, "ilogb": OpenCLStd_ilogb, "ldexp": OpenCLStd_ldexp, "lgamma": OpenCLStd_lgamma, "lgamma_r": OpenCLStd_lgamma_r, "log": OpenCLStd_log, "log2": OpenCLStd_log2, "log10": OpenCLStd_log10, "log1p": OpenCLStd_log1p, "logb": OpenCLStd_logb, "mad": OpenCLStd_mad, "maxmag": OpenCLStd_maxmag, "minmag": OpenCLStd_minmag, "modf": OpenCLStd_modf, "nan": OpenCLStd_nan, "nextafter": OpenCLStd_nextafter, "pow": OpenCLStd_pow, "pown": OpenCLStd_pown, "powr": OpenCLStd_powr, "remainder": OpenCLStd_remainder, "remquo": OpenCLStd_remquo, "rint": OpenCLStd_rint, "rootn": OpenCLStd_rootn, "round": OpenCLStd_round, "rsqrt": OpenCLStd_rsqrt, "sin": OpenCLStd_sin, "sincos": OpenCLStd_sincos, "sinh": OpenCLStd_sinh, "sinpi": OpenCLStd_sinpi, "sqrt": OpenCLStd_sqrt, "tan": OpenCLStd_tan, "tanh": OpenCLStd_tanh, "tanpi": OpenCLStd_tanpi, "tgamma": OpenCLStd_tgamma, "trunc": OpenCLStd_trunc, "half_cos": OpenCLStd_half_cos, "half_divide": OpenCLStd_half_divide, "half_exp": OpenCLStd_half_exp, "half_exp2": OpenCLStd_half_exp2, "half_exp10": OpenCLStd_half_exp10, "half_log": OpenCLStd_half_log, "half_log2": OpenCLStd_half_log2, "half_log10": OpenCLStd_half_log10, "half_powr": OpenCLStd_half_powr, "half_recip": OpenCLStd_half_recip, "half_rsqrt": OpenCLStd_half_rsqrt, "half_sin": OpenCLStd_half_sin, "half_sqrt": OpenCLStd_half_sqrt, "half_tan": OpenCLStd_half_tan, "native_cos": OpenCLStd_native_cos, "native_divide": OpenCLStd_native_divide, "native_exp": OpenCLStd_native_exp, "native_exp2": OpenCLStd_native_exp2, "native_exp10": OpenCLStd_native_exp10, "native_log": OpenCLStd_native_log, "native_log2": OpenCLStd_native_log2, "native_log10": OpenCLStd_native_log10, "native_powr": OpenCLStd_native_powr, "native_recip": OpenCLStd_native_recip, "native_rsqrt": OpenCLStd_native_rsqrt, "native_sin": OpenCLStd_native_sin, "native_sqrt": OpenCLStd_native_sqrt, "native_tan": OpenCLStd_native_tan, "s_abs": OpenCLStd_s_abs, "s_abs_diff": OpenCLStd_s_abs_diff, "s_add_sat": OpenCLStd_s_add_sat, "u_add_sat": OpenCLStd_u_add_sat, "s_hadd": OpenCLStd_s_hadd, "u_hadd": OpenCLStd_u_hadd, "s_rhadd": OpenCLStd_s_rhadd, "u_rhadd": OpenCLStd_u_rhadd, "s_clamp": OpenCLStd_s_clamp, "u_clamp": OpenCLStd_u_clamp, "clz": OpenCLStd_clz, "ctz": OpenCLStd_ctz, "s_mad_hi": OpenCLStd_s_mad_hi, "u_mad_sat": OpenCLStd_u_mad_sat, "s_mad_sat": OpenCLStd_s_mad_sat, "s_max": OpenCLStd_s_max, "u_max": OpenCLStd_u_max, "s_min": OpenCLStd_s_min, "u_min": OpenCLStd_u_min, "s_mul_hi": OpenCLStd_s_mul_hi, "rotate": OpenCLStd_rotate, "s_sub_sat": OpenCLStd_s_sub_sat, "u_sub_sat": OpenCLStd_u_sub_sat, "u_upsample": OpenCLStd_u_upsample, "s_upsample": OpenCLStd_s_upsample, "popcount": OpenCLStd_popcount, "s_mad24": OpenCLStd_s_mad24, "u_mad24": OpenCLStd_u_mad24, "s_mul24": OpenCLStd_s_mul24, "u_mul24": OpenCLStd_u_mul24, "u_abs": OpenCLStd_u_abs, "u_abs_diff": OpenCLStd_u_abs_diff, "u_mul_hi": OpenCLStd_u_mul_hi, "u_mad_hi": OpenCLStd_u_mad_hi, "fclamp": OpenCLStd_fclamp, "degrees": OpenCLStd_degrees, "fmax_common": OpenCLStd_fmax_common, "fmin_common": OpenCLStd_fmin_common, "mix": OpenCLStd_mix, "radians": OpenCLStd_radians, "step": OpenCLStd_step, "smoothstep": OpenCLStd_smoothstep, "sign": OpenCLStd_sign, "cross": OpenCLStd_cross, "distance": OpenCLStd_distance, "length": OpenCLStd_length, "normalize": OpenCLStd_normalize, "fast_distance": OpenCLStd_fast_distance, "fast_length": OpenCLStd_fast_length, "fast_normalize": OpenCLStd_fast_normalize, "bitselect": OpenCLStd_bitselect, "select": OpenCLStd_select, "vloadn": OpenCLStd_vloadn, "vstoren": OpenCLStd_vstoren, "vload_half": OpenCLStd_vload_half, "vload_halfn": OpenCLStd_vload_halfn, "vstore_half": OpenCLStd_vstore_half, "vstore_half_r": OpenCLStd_vstore_half_r, "vstore_halfn": OpenCLStd_vstore_halfn, "vstore_halfn_r": OpenCLStd_vstore_halfn_r, "vloada_halfn": OpenCLStd_vloada_halfn, "vstorea_halfn": OpenCLStd_vstorea_halfn, "vstorea_halfn_r": OpenCLStd_vstorea_halfn_r, "shuffle": OpenCLStd_shuffle, "shuffle2": OpenCLStd_shuffle2, "printf": OpenCLStd_printf, "prefetch": OpenCLStd_prefetch, }, "OpenCL.DebugInfo.100": { "DebugInfoNone": OpenCLDebugInfo100_DebugInfoNone, "DebugCompilationUnit": OpenCLDebugInfo100_DebugCompilationUnit, "DebugTypeBasic": OpenCLDebugInfo100_DebugTypeBasic, "DebugTypePointer": OpenCLDebugInfo100_DebugTypePointer, "DebugTypeQualifier": OpenCLDebugInfo100_DebugTypeQualifier, "DebugTypeArray": OpenCLDebugInfo100_DebugTypeArray, "DebugTypeVector": OpenCLDebugInfo100_DebugTypeVector, "DebugTypedef": OpenCLDebugInfo100_DebugTypedef, "DebugTypeFunction": OpenCLDebugInfo100_DebugTypeFunction, "DebugTypeEnum": OpenCLDebugInfo100_DebugTypeEnum, "DebugTypeComposite": OpenCLDebugInfo100_DebugTypeComposite, "DebugTypeMember": OpenCLDebugInfo100_DebugTypeMember, "DebugTypeInheritance": OpenCLDebugInfo100_DebugTypeInheritance, "DebugTypePtrToMember": OpenCLDebugInfo100_DebugTypePtrToMember, "DebugTypeTemplate": OpenCLDebugInfo100_DebugTypeTemplate, "DebugTypeTemplateParameter": OpenCLDebugInfo100_DebugTypeTemplateParameter, "DebugTypeTemplateTemplateParameter": OpenCLDebugInfo100_DebugTypeTemplateTemplateParameter, "DebugTypeTemplateParameterPack": OpenCLDebugInfo100_DebugTypeTemplateParameterPack, "DebugGlobalVariable": OpenCLDebugInfo100_DebugGlobalVariable, "DebugFunctionDeclaration": OpenCLDebugInfo100_DebugFunctionDeclaration, "DebugFunction": OpenCLDebugInfo100_DebugFunction, "DebugLexicalBlock": OpenCLDebugInfo100_DebugLexicalBlock, "DebugLexicalBlockDiscriminator": OpenCLDebugInfo100_DebugLexicalBlockDiscriminator, "DebugScope": OpenCLDebugInfo100_DebugScope, "DebugNoScope": OpenCLDebugInfo100_DebugNoScope, "DebugInlinedAt": OpenCLDebugInfo100_DebugInlinedAt, "DebugLocalVariable": OpenCLDebugInfo100_DebugLocalVariable, "DebugInlinedVariable": OpenCLDebugInfo100_DebugInlinedVariable, "DebugDeclare": OpenCLDebugInfo100_DebugDeclare, "DebugValue": OpenCLDebugInfo100_DebugValue, "DebugOperation": OpenCLDebugInfo100_DebugOperation, "DebugExpression": OpenCLDebugInfo100_DebugExpression, "DebugMacroDef": OpenCLDebugInfo100_DebugMacroDef, "DebugMacroUndef": OpenCLDebugInfo100_DebugMacroUndef, "DebugImportedEntity": OpenCLDebugInfo100_DebugImportedEntity, "DebugSource": OpenCLDebugInfo100_DebugSource, "DebugModuleINTEL": OpenCLDebugInfo100_DebugModuleINTEL, }, } OpNop = &Opcode { Opname: "OpNop", Class: "Miscellaneous", Opcode: 0, Operands: []Operand { }, } OpUndef = &Opcode { Opname: "OpUndef", Class: "Miscellaneous", Opcode: 1, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpSourceContinued = &Opcode { Opname: "OpSourceContinued", Class: "Debug", Opcode: 2, Operands: []Operand { Operand { Kind: OperandKindLiteralString, Name: "'Continued Source'", Quantifier: "", }, }, } OpSource = &Opcode { Opname: "OpSource", Class: "Debug", Opcode: 3, Operands: []Operand { Operand { Kind: OperandKindSourceLanguage, Name: "", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Version'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'File'", Quantifier: "?", }, Operand { Kind: OperandKindLiteralString, Name: "'Source'", Quantifier: "?", }, }, } OpSourceExtension = &Opcode { Opname: "OpSourceExtension", Class: "Debug", Opcode: 4, Operands: []Operand { Operand { Kind: OperandKindLiteralString, Name: "'Extension'", Quantifier: "", }, }, } OpName = &Opcode { Opname: "OpName", Class: "Debug", Opcode: 5, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Target'", Quantifier: "", }, Operand { Kind: OperandKindLiteralString, Name: "'Name'", Quantifier: "", }, }, } OpMemberName = &Opcode { Opname: "OpMemberName", Class: "Debug", Opcode: 6, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Type'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Member'", Quantifier: "", }, Operand { Kind: OperandKindLiteralString, Name: "'Name'", Quantifier: "", }, }, } OpString = &Opcode { Opname: "OpString", Class: "Debug", Opcode: 7, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindLiteralString, Name: "'String'", Quantifier: "", }, }, } OpLine = &Opcode { Opname: "OpLine", Class: "Debug", Opcode: 8, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'File'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Line'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Column'", Quantifier: "", }, }, } OpExtension = &Opcode { Opname: "OpExtension", Class: "Extension", Opcode: 10, Operands: []Operand { Operand { Kind: OperandKindLiteralString, Name: "'Name'", Quantifier: "", }, }, } OpExtInstImport = &Opcode { Opname: "OpExtInstImport", Class: "Extension", Opcode: 11, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindLiteralString, Name: "'Name'", Quantifier: "", }, }, } OpExtInst = &Opcode { Opname: "OpExtInst", Class: "Extension", Opcode: 12, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Set'", Quantifier: "", }, Operand { Kind: OperandKindLiteralExtInstInteger, Name: "'Instruction'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1', + 'Operand 2', + ...", Quantifier: "*", }, }, } OpMemoryModel = &Opcode { Opname: "OpMemoryModel", Class: "Mode-Setting", Opcode: 14, Operands: []Operand { Operand { Kind: OperandKindAddressingModel, Name: "", Quantifier: "", }, Operand { Kind: OperandKindMemoryModel, Name: "", Quantifier: "", }, }, } OpEntryPoint = &Opcode { Opname: "OpEntryPoint", Class: "Mode-Setting", Opcode: 15, Operands: []Operand { Operand { Kind: OperandKindExecutionModel, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Entry Point'", Quantifier: "", }, Operand { Kind: OperandKindLiteralString, Name: "'Name'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Interface'", Quantifier: "*", }, }, } OpExecutionMode = &Opcode { Opname: "OpExecutionMode", Class: "Mode-Setting", Opcode: 16, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Entry Point'", Quantifier: "", }, Operand { Kind: OperandKindExecutionMode, Name: "'Mode'", Quantifier: "", }, }, } OpCapability = &Opcode { Opname: "OpCapability", Class: "Mode-Setting", Opcode: 17, Operands: []Operand { Operand { Kind: OperandKindCapability, Name: "'Capability'", Quantifier: "", }, }, } OpTypeVoid = &Opcode { Opname: "OpTypeVoid", Class: "Type-Declaration", Opcode: 19, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpTypeBool = &Opcode { Opname: "OpTypeBool", Class: "Type-Declaration", Opcode: 20, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpTypeInt = &Opcode { Opname: "OpTypeInt", Class: "Type-Declaration", Opcode: 21, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Width'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Signedness'", Quantifier: "", }, }, } OpTypeFloat = &Opcode { Opname: "OpTypeFloat", Class: "Type-Declaration", Opcode: 22, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Width'", Quantifier: "", }, Operand { Kind: OperandKindFPEncoding, Name: "'Floating Point Encoding'", Quantifier: "?", }, }, } OpTypeVector = &Opcode { Opname: "OpTypeVector", Class: "Type-Declaration", Opcode: 23, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Component Type'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Component Count'", Quantifier: "", }, }, } OpTypeMatrix = &Opcode { Opname: "OpTypeMatrix", Class: "Type-Declaration", Opcode: 24, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Column Type'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Column Count'", Quantifier: "", }, }, } OpTypeImage = &Opcode { Opname: "OpTypeImage", Class: "Type-Declaration", Opcode: 25, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Sampled Type'", Quantifier: "", }, Operand { Kind: OperandKindDim, Name: "", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Depth'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Arrayed'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'MS'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Sampled'", Quantifier: "", }, Operand { Kind: OperandKindImageFormat, Name: "", Quantifier: "", }, Operand { Kind: OperandKindAccessQualifier, Name: "", Quantifier: "?", }, }, } OpTypeSampler = &Opcode { Opname: "OpTypeSampler", Class: "Type-Declaration", Opcode: 26, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpTypeSampledImage = &Opcode { Opname: "OpTypeSampledImage", Class: "Type-Declaration", Opcode: 27, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Image Type'", Quantifier: "", }, }, } OpTypeArray = &Opcode { Opname: "OpTypeArray", Class: "Type-Declaration", Opcode: 28, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Element Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Length'", Quantifier: "", }, }, } OpTypeRuntimeArray = &Opcode { Opname: "OpTypeRuntimeArray", Class: "Type-Declaration", Opcode: 29, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Element Type'", Quantifier: "", }, }, } OpTypeStruct = &Opcode { Opname: "OpTypeStruct", Class: "Type-Declaration", Opcode: 30, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Member 0 type', + 'member 1 type', + ...", Quantifier: "*", }, }, } OpTypeOpaque = &Opcode { Opname: "OpTypeOpaque", Class: "Type-Declaration", Opcode: 31, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindLiteralString, Name: "The name of the opaque type.", Quantifier: "", }, }, } OpTypePointer = &Opcode { Opname: "OpTypePointer", Class: "Type-Declaration", Opcode: 32, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindStorageClass, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Type'", Quantifier: "", }, }, } OpTypeFunction = &Opcode { Opname: "OpTypeFunction", Class: "Type-Declaration", Opcode: 33, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Return Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Parameter 0 Type', + 'Parameter 1 Type', + ...", Quantifier: "*", }, }, } OpTypeEvent = &Opcode { Opname: "OpTypeEvent", Class: "Type-Declaration", Opcode: 34, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpTypeDeviceEvent = &Opcode { Opname: "OpTypeDeviceEvent", Class: "Type-Declaration", Opcode: 35, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpTypeReserveId = &Opcode { Opname: "OpTypeReserveId", Class: "Type-Declaration", Opcode: 36, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpTypeQueue = &Opcode { Opname: "OpTypeQueue", Class: "Type-Declaration", Opcode: 37, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpTypePipe = &Opcode { Opname: "OpTypePipe", Class: "Type-Declaration", Opcode: 38, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindAccessQualifier, Name: "'Qualifier'", Quantifier: "", }, }, } OpTypeForwardPointer = &Opcode { Opname: "OpTypeForwardPointer", Class: "Type-Declaration", Opcode: 39, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Pointer Type'", Quantifier: "", }, Operand { Kind: OperandKindStorageClass, Name: "", Quantifier: "", }, }, } OpConstantTrue = &Opcode { Opname: "OpConstantTrue", Class: "Constant-Creation", Opcode: 41, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpConstantFalse = &Opcode { Opname: "OpConstantFalse", Class: "Constant-Creation", Opcode: 42, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpConstant = &Opcode { Opname: "OpConstant", Class: "Constant-Creation", Opcode: 43, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindLiteralContextDependentNumber, Name: "'Value'", Quantifier: "", }, }, } OpConstantComposite = &Opcode { Opname: "OpConstantComposite", Class: "Constant-Creation", Opcode: 44, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Constituents'", Quantifier: "*", }, }, } OpConstantSampler = &Opcode { Opname: "OpConstantSampler", Class: "Constant-Creation", Opcode: 45, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindSamplerAddressingMode, Name: "", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Param'", Quantifier: "", }, Operand { Kind: OperandKindSamplerFilterMode, Name: "", Quantifier: "", }, }, } OpConstantNull = &Opcode { Opname: "OpConstantNull", Class: "Constant-Creation", Opcode: 46, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpSpecConstantTrue = &Opcode { Opname: "OpSpecConstantTrue", Class: "Constant-Creation", Opcode: 48, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpSpecConstantFalse = &Opcode { Opname: "OpSpecConstantFalse", Class: "Constant-Creation", Opcode: 49, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpSpecConstant = &Opcode { Opname: "OpSpecConstant", Class: "Constant-Creation", Opcode: 50, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindLiteralContextDependentNumber, Name: "'Value'", Quantifier: "", }, }, } OpSpecConstantComposite = &Opcode { Opname: "OpSpecConstantComposite", Class: "Constant-Creation", Opcode: 51, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Constituents'", Quantifier: "*", }, }, } OpSpecConstantOp = &Opcode { Opname: "OpSpecConstantOp", Class: "Constant-Creation", Opcode: 52, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindLiteralSpecConstantOpInteger, Name: "'Opcode'", Quantifier: "", }, }, } OpFunction = &Opcode { Opname: "OpFunction", Class: "Function", Opcode: 54, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindFunctionControl, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Function Type'", Quantifier: "", }, }, } OpFunctionParameter = &Opcode { Opname: "OpFunctionParameter", Class: "Function", Opcode: 55, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpFunctionEnd = &Opcode { Opname: "OpFunctionEnd", Class: "Function", Opcode: 56, Operands: []Operand { }, } OpFunctionCall = &Opcode { Opname: "OpFunctionCall", Class: "Function", Opcode: 57, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Function'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Argument 0', + 'Argument 1', + ...", Quantifier: "*", }, }, } OpVariable = &Opcode { Opname: "OpVariable", Class: "Memory", Opcode: 59, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindStorageClass, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Initializer'", Quantifier: "?", }, }, } OpImageTexelPointer = &Opcode { Opname: "OpImageTexelPointer", Class: "Memory", Opcode: 60, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Coordinate'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Sample'", Quantifier: "", }, }, } OpLoad = &Opcode { Opname: "OpLoad", Class: "Memory", Opcode: 61, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, Operand { Kind: OperandKindMemoryAccess, Name: "", Quantifier: "?", }, }, } OpStore = &Opcode { Opname: "OpStore", Class: "Memory", Opcode: 62, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Object'", Quantifier: "", }, Operand { Kind: OperandKindMemoryAccess, Name: "", Quantifier: "?", }, }, } OpCopyMemory = &Opcode { Opname: "OpCopyMemory", Class: "Memory", Opcode: 63, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Target'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Source'", Quantifier: "", }, Operand { Kind: OperandKindMemoryAccess, Name: "", Quantifier: "?", }, Operand { Kind: OperandKindMemoryAccess, Name: "", Quantifier: "?", }, }, } OpCopyMemorySized = &Opcode { Opname: "OpCopyMemorySized", Class: "Memory", Opcode: 64, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Target'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Source'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Size'", Quantifier: "", }, Operand { Kind: OperandKindMemoryAccess, Name: "", Quantifier: "?", }, Operand { Kind: OperandKindMemoryAccess, Name: "", Quantifier: "?", }, }, } OpAccessChain = &Opcode { Opname: "OpAccessChain", Class: "Memory", Opcode: 65, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Base'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Indexes'", Quantifier: "*", }, }, } OpInBoundsAccessChain = &Opcode { Opname: "OpInBoundsAccessChain", Class: "Memory", Opcode: 66, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Base'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Indexes'", Quantifier: "*", }, }, } OpPtrAccessChain = &Opcode { Opname: "OpPtrAccessChain", Class: "Memory", Opcode: 67, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Base'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Element'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Indexes'", Quantifier: "*", }, }, } OpArrayLength = &Opcode { Opname: "OpArrayLength", Class: "Memory", Opcode: 68, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Structure'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Array member'", Quantifier: "", }, }, } OpGenericPtrMemSemantics = &Opcode { Opname: "OpGenericPtrMemSemantics", Class: "Memory", Opcode: 69, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, }, } OpInBoundsPtrAccessChain = &Opcode { Opname: "OpInBoundsPtrAccessChain", Class: "Memory", Opcode: 70, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Base'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Element'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Indexes'", Quantifier: "*", }, }, } OpDecorate = &Opcode { Opname: "OpDecorate", Class: "Annotation", Opcode: 71, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Target'", Quantifier: "", }, Operand { Kind: OperandKindDecoration, Name: "", Quantifier: "", }, }, } OpMemberDecorate = &Opcode { Opname: "OpMemberDecorate", Class: "Annotation", Opcode: 72, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Structure Type'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Member'", Quantifier: "", }, Operand { Kind: OperandKindDecoration, Name: "", Quantifier: "", }, }, } OpDecorationGroup = &Opcode { Opname: "OpDecorationGroup", Class: "Annotation", Opcode: 73, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpGroupDecorate = &Opcode { Opname: "OpGroupDecorate", Class: "Annotation", Opcode: 74, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Decoration Group'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Targets'", Quantifier: "*", }, }, } OpGroupMemberDecorate = &Opcode { Opname: "OpGroupMemberDecorate", Class: "Annotation", Opcode: 75, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Decoration Group'", Quantifier: "", }, Operand { Kind: OperandKindPairIdRefLiteralInteger, Name: "'Targets'", Quantifier: "*", }, }, } OpVectorExtractDynamic = &Opcode { Opname: "OpVectorExtractDynamic", Class: "Composite", Opcode: 77, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Vector'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Index'", Quantifier: "", }, }, } OpVectorInsertDynamic = &Opcode { Opname: "OpVectorInsertDynamic", Class: "Composite", Opcode: 78, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Vector'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Component'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Index'", Quantifier: "", }, }, } OpVectorShuffle = &Opcode { Opname: "OpVectorShuffle", Class: "Composite", Opcode: 79, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Vector 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Vector 2'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Components'", Quantifier: "*", }, }, } OpCompositeConstruct = &Opcode { Opname: "OpCompositeConstruct", Class: "Composite", Opcode: 80, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Constituents'", Quantifier: "*", }, }, } OpCompositeExtract = &Opcode { Opname: "OpCompositeExtract", Class: "Composite", Opcode: 81, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Composite'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Indexes'", Quantifier: "*", }, }, } OpCompositeInsert = &Opcode { Opname: "OpCompositeInsert", Class: "Composite", Opcode: 82, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Object'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Composite'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Indexes'", Quantifier: "*", }, }, } OpCopyObject = &Opcode { Opname: "OpCopyObject", Class: "Composite", Opcode: 83, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand'", Quantifier: "", }, }, } OpTranspose = &Opcode { Opname: "OpTranspose", Class: "Composite", Opcode: 84, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Matrix'", Quantifier: "", }, }, } OpSampledImage = &Opcode { Opname: "OpSampledImage", Class: "Image", Opcode: 86, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Sampler'", Quantifier: "", }, }, } OpImageSampleImplicitLod = &Opcode { Opname: "OpImageSampleImplicitLod", Class: "Image", Opcode: 87, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Sampled Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Coordinate'", Quantifier: "", }, Operand { Kind: OperandKindImageOperands, Name: "", Quantifier: "?", }, }, } OpImageSampleExplicitLod = &Opcode { Opname: "OpImageSampleExplicitLod", Class: "Image", Opcode: 88, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Sampled Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Coordinate'", Quantifier: "", }, Operand { Kind: OperandKindImageOperands, Name: "", Quantifier: "", }, }, } OpImageSampleDrefImplicitLod = &Opcode { Opname: "OpImageSampleDrefImplicitLod", Class: "Image", Opcode: 89, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Sampled Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Coordinate'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'D~ref~'", Quantifier: "", }, Operand { Kind: OperandKindImageOperands, Name: "", Quantifier: "?", }, }, } OpImageSampleDrefExplicitLod = &Opcode { Opname: "OpImageSampleDrefExplicitLod", Class: "Image", Opcode: 90, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Sampled Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Coordinate'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'D~ref~'", Quantifier: "", }, Operand { Kind: OperandKindImageOperands, Name: "", Quantifier: "", }, }, } OpImageSampleProjImplicitLod = &Opcode { Opname: "OpImageSampleProjImplicitLod", Class: "Image", Opcode: 91, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Sampled Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Coordinate'", Quantifier: "", }, Operand { Kind: OperandKindImageOperands, Name: "", Quantifier: "?", }, }, } OpImageSampleProjExplicitLod = &Opcode { Opname: "OpImageSampleProjExplicitLod", Class: "Image", Opcode: 92, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Sampled Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Coordinate'", Quantifier: "", }, Operand { Kind: OperandKindImageOperands, Name: "", Quantifier: "", }, }, } OpImageSampleProjDrefImplicitLod = &Opcode { Opname: "OpImageSampleProjDrefImplicitLod", Class: "Image", Opcode: 93, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Sampled Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Coordinate'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'D~ref~'", Quantifier: "", }, Operand { Kind: OperandKindImageOperands, Name: "", Quantifier: "?", }, }, } OpImageSampleProjDrefExplicitLod = &Opcode { Opname: "OpImageSampleProjDrefExplicitLod", Class: "Image", Opcode: 94, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Sampled Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Coordinate'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'D~ref~'", Quantifier: "", }, Operand { Kind: OperandKindImageOperands, Name: "", Quantifier: "", }, }, } OpImageFetch = &Opcode { Opname: "OpImageFetch", Class: "Image", Opcode: 95, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Coordinate'", Quantifier: "", }, Operand { Kind: OperandKindImageOperands, Name: "", Quantifier: "?", }, }, } OpImageGather = &Opcode { Opname: "OpImageGather", Class: "Image", Opcode: 96, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Sampled Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Coordinate'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Component'", Quantifier: "", }, Operand { Kind: OperandKindImageOperands, Name: "", Quantifier: "?", }, }, } OpImageDrefGather = &Opcode { Opname: "OpImageDrefGather", Class: "Image", Opcode: 97, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Sampled Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Coordinate'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'D~ref~'", Quantifier: "", }, Operand { Kind: OperandKindImageOperands, Name: "", Quantifier: "?", }, }, } OpImageRead = &Opcode { Opname: "OpImageRead", Class: "Image", Opcode: 98, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Coordinate'", Quantifier: "", }, Operand { Kind: OperandKindImageOperands, Name: "", Quantifier: "?", }, }, } OpImageWrite = &Opcode { Opname: "OpImageWrite", Class: "Image", Opcode: 99, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Coordinate'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Texel'", Quantifier: "", }, Operand { Kind: OperandKindImageOperands, Name: "", Quantifier: "?", }, }, } OpImage = &Opcode { Opname: "OpImage", Class: "Image", Opcode: 100, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Sampled Image'", Quantifier: "", }, }, } OpImageQueryFormat = &Opcode { Opname: "OpImageQueryFormat", Class: "Image", Opcode: 101, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Image'", Quantifier: "", }, }, } OpImageQueryOrder = &Opcode { Opname: "OpImageQueryOrder", Class: "Image", Opcode: 102, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Image'", Quantifier: "", }, }, } OpImageQuerySizeLod = &Opcode { Opname: "OpImageQuerySizeLod", Class: "Image", Opcode: 103, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Level of Detail'", Quantifier: "", }, }, } OpImageQuerySize = &Opcode { Opname: "OpImageQuerySize", Class: "Image", Opcode: 104, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Image'", Quantifier: "", }, }, } OpImageQueryLod = &Opcode { Opname: "OpImageQueryLod", Class: "Image", Opcode: 105, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Sampled Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Coordinate'", Quantifier: "", }, }, } OpImageQueryLevels = &Opcode { Opname: "OpImageQueryLevels", Class: "Image", Opcode: 106, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Image'", Quantifier: "", }, }, } OpImageQuerySamples = &Opcode { Opname: "OpImageQuerySamples", Class: "Image", Opcode: 107, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Image'", Quantifier: "", }, }, } OpConvertFToU = &Opcode { Opname: "OpConvertFToU", Class: "Conversion", Opcode: 109, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Float Value'", Quantifier: "", }, }, } OpConvertFToS = &Opcode { Opname: "OpConvertFToS", Class: "Conversion", Opcode: 110, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Float Value'", Quantifier: "", }, }, } OpConvertSToF = &Opcode { Opname: "OpConvertSToF", Class: "Conversion", Opcode: 111, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Signed Value'", Quantifier: "", }, }, } OpConvertUToF = &Opcode { Opname: "OpConvertUToF", Class: "Conversion", Opcode: 112, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Unsigned Value'", Quantifier: "", }, }, } OpUConvert = &Opcode { Opname: "OpUConvert", Class: "Conversion", Opcode: 113, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Unsigned Value'", Quantifier: "", }, }, } OpSConvert = &Opcode { Opname: "OpSConvert", Class: "Conversion", Opcode: 114, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Signed Value'", Quantifier: "", }, }, } OpFConvert = &Opcode { Opname: "OpFConvert", Class: "Conversion", Opcode: 115, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Float Value'", Quantifier: "", }, }, } OpQuantizeToF16 = &Opcode { Opname: "OpQuantizeToF16", Class: "Conversion", Opcode: 116, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, }, } OpConvertPtrToU = &Opcode { Opname: "OpConvertPtrToU", Class: "Conversion", Opcode: 117, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, }, } OpSatConvertSToU = &Opcode { Opname: "OpSatConvertSToU", Class: "Conversion", Opcode: 118, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Signed Value'", Quantifier: "", }, }, } OpSatConvertUToS = &Opcode { Opname: "OpSatConvertUToS", Class: "Conversion", Opcode: 119, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Unsigned Value'", Quantifier: "", }, }, } OpConvertUToPtr = &Opcode { Opname: "OpConvertUToPtr", Class: "Conversion", Opcode: 120, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Integer Value'", Quantifier: "", }, }, } OpPtrCastToGeneric = &Opcode { Opname: "OpPtrCastToGeneric", Class: "Conversion", Opcode: 121, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, }, } OpGenericCastToPtr = &Opcode { Opname: "OpGenericCastToPtr", Class: "Conversion", Opcode: 122, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, }, } OpGenericCastToPtrExplicit = &Opcode { Opname: "OpGenericCastToPtrExplicit", Class: "Conversion", Opcode: 123, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, Operand { Kind: OperandKindStorageClass, Name: "'Storage'", Quantifier: "", }, }, } OpBitcast = &Opcode { Opname: "OpBitcast", Class: "Conversion", Opcode: 124, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand'", Quantifier: "", }, }, } OpSNegate = &Opcode { Opname: "OpSNegate", Class: "Arithmetic", Opcode: 126, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand'", Quantifier: "", }, }, } OpFNegate = &Opcode { Opname: "OpFNegate", Class: "Arithmetic", Opcode: 127, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand'", Quantifier: "", }, }, } OpIAdd = &Opcode { Opname: "OpIAdd", Class: "Arithmetic", Opcode: 128, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpFAdd = &Opcode { Opname: "OpFAdd", Class: "Arithmetic", Opcode: 129, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpISub = &Opcode { Opname: "OpISub", Class: "Arithmetic", Opcode: 130, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpFSub = &Opcode { Opname: "OpFSub", Class: "Arithmetic", Opcode: 131, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpIMul = &Opcode { Opname: "OpIMul", Class: "Arithmetic", Opcode: 132, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpFMul = &Opcode { Opname: "OpFMul", Class: "Arithmetic", Opcode: 133, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpUDiv = &Opcode { Opname: "OpUDiv", Class: "Arithmetic", Opcode: 134, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpSDiv = &Opcode { Opname: "OpSDiv", Class: "Arithmetic", Opcode: 135, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpFDiv = &Opcode { Opname: "OpFDiv", Class: "Arithmetic", Opcode: 136, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpUMod = &Opcode { Opname: "OpUMod", Class: "Arithmetic", Opcode: 137, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpSRem = &Opcode { Opname: "OpSRem", Class: "Arithmetic", Opcode: 138, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpSMod = &Opcode { Opname: "OpSMod", Class: "Arithmetic", Opcode: 139, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpFRem = &Opcode { Opname: "OpFRem", Class: "Arithmetic", Opcode: 140, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpFMod = &Opcode { Opname: "OpFMod", Class: "Arithmetic", Opcode: 141, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpVectorTimesScalar = &Opcode { Opname: "OpVectorTimesScalar", Class: "Arithmetic", Opcode: 142, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Vector'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Scalar'", Quantifier: "", }, }, } OpMatrixTimesScalar = &Opcode { Opname: "OpMatrixTimesScalar", Class: "Arithmetic", Opcode: 143, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Matrix'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Scalar'", Quantifier: "", }, }, } OpVectorTimesMatrix = &Opcode { Opname: "OpVectorTimesMatrix", Class: "Arithmetic", Opcode: 144, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Vector'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Matrix'", Quantifier: "", }, }, } OpMatrixTimesVector = &Opcode { Opname: "OpMatrixTimesVector", Class: "Arithmetic", Opcode: 145, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Matrix'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Vector'", Quantifier: "", }, }, } OpMatrixTimesMatrix = &Opcode { Opname: "OpMatrixTimesMatrix", Class: "Arithmetic", Opcode: 146, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'LeftMatrix'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'RightMatrix'", Quantifier: "", }, }, } OpOuterProduct = &Opcode { Opname: "OpOuterProduct", Class: "Arithmetic", Opcode: 147, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Vector 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Vector 2'", Quantifier: "", }, }, } OpDot = &Opcode { Opname: "OpDot", Class: "Arithmetic", Opcode: 148, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Vector 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Vector 2'", Quantifier: "", }, }, } OpIAddCarry = &Opcode { Opname: "OpIAddCarry", Class: "Arithmetic", Opcode: 149, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpISubBorrow = &Opcode { Opname: "OpISubBorrow", Class: "Arithmetic", Opcode: 150, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpUMulExtended = &Opcode { Opname: "OpUMulExtended", Class: "Arithmetic", Opcode: 151, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpSMulExtended = &Opcode { Opname: "OpSMulExtended", Class: "Arithmetic", Opcode: 152, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpAny = &Opcode { Opname: "OpAny", Class: "Relational_and_Logical", Opcode: 154, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Vector'", Quantifier: "", }, }, } OpAll = &Opcode { Opname: "OpAll", Class: "Relational_and_Logical", Opcode: 155, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Vector'", Quantifier: "", }, }, } OpIsNan = &Opcode { Opname: "OpIsNan", Class: "Relational_and_Logical", Opcode: 156, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpIsInf = &Opcode { Opname: "OpIsInf", Class: "Relational_and_Logical", Opcode: 157, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpIsFinite = &Opcode { Opname: "OpIsFinite", Class: "Relational_and_Logical", Opcode: 158, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpIsNormal = &Opcode { Opname: "OpIsNormal", Class: "Relational_and_Logical", Opcode: 159, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpSignBitSet = &Opcode { Opname: "OpSignBitSet", Class: "Relational_and_Logical", Opcode: 160, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpLessOrGreater = &Opcode { Opname: "OpLessOrGreater", Class: "Relational_and_Logical", Opcode: 161, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpOrdered = &Opcode { Opname: "OpOrdered", Class: "Relational_and_Logical", Opcode: 162, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpUnordered = &Opcode { Opname: "OpUnordered", Class: "Relational_and_Logical", Opcode: 163, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpLogicalEqual = &Opcode { Opname: "OpLogicalEqual", Class: "Relational_and_Logical", Opcode: 164, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpLogicalNotEqual = &Opcode { Opname: "OpLogicalNotEqual", Class: "Relational_and_Logical", Opcode: 165, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpLogicalOr = &Opcode { Opname: "OpLogicalOr", Class: "Relational_and_Logical", Opcode: 166, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpLogicalAnd = &Opcode { Opname: "OpLogicalAnd", Class: "Relational_and_Logical", Opcode: 167, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpLogicalNot = &Opcode { Opname: "OpLogicalNot", Class: "Relational_and_Logical", Opcode: 168, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand'", Quantifier: "", }, }, } OpSelect = &Opcode { Opname: "OpSelect", Class: "Relational_and_Logical", Opcode: 169, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Condition'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Object 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Object 2'", Quantifier: "", }, }, } OpIEqual = &Opcode { Opname: "OpIEqual", Class: "Relational_and_Logical", Opcode: 170, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpINotEqual = &Opcode { Opname: "OpINotEqual", Class: "Relational_and_Logical", Opcode: 171, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpUGreaterThan = &Opcode { Opname: "OpUGreaterThan", Class: "Relational_and_Logical", Opcode: 172, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpSGreaterThan = &Opcode { Opname: "OpSGreaterThan", Class: "Relational_and_Logical", Opcode: 173, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpUGreaterThanEqual = &Opcode { Opname: "OpUGreaterThanEqual", Class: "Relational_and_Logical", Opcode: 174, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpSGreaterThanEqual = &Opcode { Opname: "OpSGreaterThanEqual", Class: "Relational_and_Logical", Opcode: 175, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpULessThan = &Opcode { Opname: "OpULessThan", Class: "Relational_and_Logical", Opcode: 176, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpSLessThan = &Opcode { Opname: "OpSLessThan", Class: "Relational_and_Logical", Opcode: 177, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpULessThanEqual = &Opcode { Opname: "OpULessThanEqual", Class: "Relational_and_Logical", Opcode: 178, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpSLessThanEqual = &Opcode { Opname: "OpSLessThanEqual", Class: "Relational_and_Logical", Opcode: 179, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpFOrdEqual = &Opcode { Opname: "OpFOrdEqual", Class: "Relational_and_Logical", Opcode: 180, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpFUnordEqual = &Opcode { Opname: "OpFUnordEqual", Class: "Relational_and_Logical", Opcode: 181, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpFOrdNotEqual = &Opcode { Opname: "OpFOrdNotEqual", Class: "Relational_and_Logical", Opcode: 182, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpFUnordNotEqual = &Opcode { Opname: "OpFUnordNotEqual", Class: "Relational_and_Logical", Opcode: 183, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpFOrdLessThan = &Opcode { Opname: "OpFOrdLessThan", Class: "Relational_and_Logical", Opcode: 184, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpFUnordLessThan = &Opcode { Opname: "OpFUnordLessThan", Class: "Relational_and_Logical", Opcode: 185, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpFOrdGreaterThan = &Opcode { Opname: "OpFOrdGreaterThan", Class: "Relational_and_Logical", Opcode: 186, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpFUnordGreaterThan = &Opcode { Opname: "OpFUnordGreaterThan", Class: "Relational_and_Logical", Opcode: 187, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpFOrdLessThanEqual = &Opcode { Opname: "OpFOrdLessThanEqual", Class: "Relational_and_Logical", Opcode: 188, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpFUnordLessThanEqual = &Opcode { Opname: "OpFUnordLessThanEqual", Class: "Relational_and_Logical", Opcode: 189, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpFOrdGreaterThanEqual = &Opcode { Opname: "OpFOrdGreaterThanEqual", Class: "Relational_and_Logical", Opcode: 190, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpFUnordGreaterThanEqual = &Opcode { Opname: "OpFUnordGreaterThanEqual", Class: "Relational_and_Logical", Opcode: 191, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpShiftRightLogical = &Opcode { Opname: "OpShiftRightLogical", Class: "Bit", Opcode: 194, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Base'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Shift'", Quantifier: "", }, }, } OpShiftRightArithmetic = &Opcode { Opname: "OpShiftRightArithmetic", Class: "Bit", Opcode: 195, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Base'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Shift'", Quantifier: "", }, }, } OpShiftLeftLogical = &Opcode { Opname: "OpShiftLeftLogical", Class: "Bit", Opcode: 196, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Base'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Shift'", Quantifier: "", }, }, } OpBitwiseOr = &Opcode { Opname: "OpBitwiseOr", Class: "Bit", Opcode: 197, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpBitwiseXor = &Opcode { Opname: "OpBitwiseXor", Class: "Bit", Opcode: 198, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpBitwiseAnd = &Opcode { Opname: "OpBitwiseAnd", Class: "Bit", Opcode: 199, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpNot = &Opcode { Opname: "OpNot", Class: "Bit", Opcode: 200, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand'", Quantifier: "", }, }, } OpBitFieldInsert = &Opcode { Opname: "OpBitFieldInsert", Class: "Bit", Opcode: 201, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Base'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Insert'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Offset'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Count'", Quantifier: "", }, }, } OpBitFieldSExtract = &Opcode { Opname: "OpBitFieldSExtract", Class: "Bit", Opcode: 202, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Base'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Offset'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Count'", Quantifier: "", }, }, } OpBitFieldUExtract = &Opcode { Opname: "OpBitFieldUExtract", Class: "Bit", Opcode: 203, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Base'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Offset'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Count'", Quantifier: "", }, }, } OpBitReverse = &Opcode { Opname: "OpBitReverse", Class: "Bit", Opcode: 204, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Base'", Quantifier: "", }, }, } OpBitCount = &Opcode { Opname: "OpBitCount", Class: "Bit", Opcode: 205, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Base'", Quantifier: "", }, }, } OpDPdx = &Opcode { Opname: "OpDPdx", Class: "Derivative", Opcode: 207, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'P'", Quantifier: "", }, }, } OpDPdy = &Opcode { Opname: "OpDPdy", Class: "Derivative", Opcode: 208, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'P'", Quantifier: "", }, }, } OpFwidth = &Opcode { Opname: "OpFwidth", Class: "Derivative", Opcode: 209, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'P'", Quantifier: "", }, }, } OpDPdxFine = &Opcode { Opname: "OpDPdxFine", Class: "Derivative", Opcode: 210, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'P'", Quantifier: "", }, }, } OpDPdyFine = &Opcode { Opname: "OpDPdyFine", Class: "Derivative", Opcode: 211, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'P'", Quantifier: "", }, }, } OpFwidthFine = &Opcode { Opname: "OpFwidthFine", Class: "Derivative", Opcode: 212, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'P'", Quantifier: "", }, }, } OpDPdxCoarse = &Opcode { Opname: "OpDPdxCoarse", Class: "Derivative", Opcode: 213, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'P'", Quantifier: "", }, }, } OpDPdyCoarse = &Opcode { Opname: "OpDPdyCoarse", Class: "Derivative", Opcode: 214, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'P'", Quantifier: "", }, }, } OpFwidthCoarse = &Opcode { Opname: "OpFwidthCoarse", Class: "Derivative", Opcode: 215, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'P'", Quantifier: "", }, }, } OpEmitVertex = &Opcode { Opname: "OpEmitVertex", Class: "Primitive", Opcode: 218, Operands: []Operand { }, } OpEndPrimitive = &Opcode { Opname: "OpEndPrimitive", Class: "Primitive", Opcode: 219, Operands: []Operand { }, } OpEmitStreamVertex = &Opcode { Opname: "OpEmitStreamVertex", Class: "Primitive", Opcode: 220, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Stream'", Quantifier: "", }, }, } OpEndStreamPrimitive = &Opcode { Opname: "OpEndStreamPrimitive", Class: "Primitive", Opcode: 221, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Stream'", Quantifier: "", }, }, } OpControlBarrier = &Opcode { Opname: "OpControlBarrier", Class: "Barrier", Opcode: 224, Operands: []Operand { Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Memory'", Quantifier: "", }, Operand { Kind: OperandKindIdMemorySemantics, Name: "'Semantics'", Quantifier: "", }, }, } OpMemoryBarrier = &Opcode { Opname: "OpMemoryBarrier", Class: "Barrier", Opcode: 225, Operands: []Operand { Operand { Kind: OperandKindIdScope, Name: "'Memory'", Quantifier: "", }, Operand { Kind: OperandKindIdMemorySemantics, Name: "'Semantics'", Quantifier: "", }, }, } OpAtomicLoad = &Opcode { Opname: "OpAtomicLoad", Class: "Atomic", Opcode: 227, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Memory'", Quantifier: "", }, Operand { Kind: OperandKindIdMemorySemantics, Name: "'Semantics'", Quantifier: "", }, }, } OpAtomicStore = &Opcode { Opname: "OpAtomicStore", Class: "Atomic", Opcode: 228, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Memory'", Quantifier: "", }, Operand { Kind: OperandKindIdMemorySemantics, Name: "'Semantics'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, }, } OpAtomicExchange = &Opcode { Opname: "OpAtomicExchange", Class: "Atomic", Opcode: 229, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Memory'", Quantifier: "", }, Operand { Kind: OperandKindIdMemorySemantics, Name: "'Semantics'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, }, } OpAtomicCompareExchange = &Opcode { Opname: "OpAtomicCompareExchange", Class: "Atomic", Opcode: 230, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Memory'", Quantifier: "", }, Operand { Kind: OperandKindIdMemorySemantics, Name: "'Equal'", Quantifier: "", }, Operand { Kind: OperandKindIdMemorySemantics, Name: "'Unequal'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Comparator'", Quantifier: "", }, }, } OpAtomicCompareExchangeWeak = &Opcode { Opname: "OpAtomicCompareExchangeWeak", Class: "Atomic", Opcode: 231, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Memory'", Quantifier: "", }, Operand { Kind: OperandKindIdMemorySemantics, Name: "'Equal'", Quantifier: "", }, Operand { Kind: OperandKindIdMemorySemantics, Name: "'Unequal'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Comparator'", Quantifier: "", }, }, } OpAtomicIIncrement = &Opcode { Opname: "OpAtomicIIncrement", Class: "Atomic", Opcode: 232, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Memory'", Quantifier: "", }, Operand { Kind: OperandKindIdMemorySemantics, Name: "'Semantics'", Quantifier: "", }, }, } OpAtomicIDecrement = &Opcode { Opname: "OpAtomicIDecrement", Class: "Atomic", Opcode: 233, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Memory'", Quantifier: "", }, Operand { Kind: OperandKindIdMemorySemantics, Name: "'Semantics'", Quantifier: "", }, }, } OpAtomicIAdd = &Opcode { Opname: "OpAtomicIAdd", Class: "Atomic", Opcode: 234, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Memory'", Quantifier: "", }, Operand { Kind: OperandKindIdMemorySemantics, Name: "'Semantics'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, }, } OpAtomicISub = &Opcode { Opname: "OpAtomicISub", Class: "Atomic", Opcode: 235, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Memory'", Quantifier: "", }, Operand { Kind: OperandKindIdMemorySemantics, Name: "'Semantics'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, }, } OpAtomicSMin = &Opcode { Opname: "OpAtomicSMin", Class: "Atomic", Opcode: 236, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Memory'", Quantifier: "", }, Operand { Kind: OperandKindIdMemorySemantics, Name: "'Semantics'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, }, } OpAtomicUMin = &Opcode { Opname: "OpAtomicUMin", Class: "Atomic", Opcode: 237, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Memory'", Quantifier: "", }, Operand { Kind: OperandKindIdMemorySemantics, Name: "'Semantics'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, }, } OpAtomicSMax = &Opcode { Opname: "OpAtomicSMax", Class: "Atomic", Opcode: 238, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Memory'", Quantifier: "", }, Operand { Kind: OperandKindIdMemorySemantics, Name: "'Semantics'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, }, } OpAtomicUMax = &Opcode { Opname: "OpAtomicUMax", Class: "Atomic", Opcode: 239, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Memory'", Quantifier: "", }, Operand { Kind: OperandKindIdMemorySemantics, Name: "'Semantics'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, }, } OpAtomicAnd = &Opcode { Opname: "OpAtomicAnd", Class: "Atomic", Opcode: 240, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Memory'", Quantifier: "", }, Operand { Kind: OperandKindIdMemorySemantics, Name: "'Semantics'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, }, } OpAtomicOr = &Opcode { Opname: "OpAtomicOr", Class: "Atomic", Opcode: 241, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Memory'", Quantifier: "", }, Operand { Kind: OperandKindIdMemorySemantics, Name: "'Semantics'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, }, } OpAtomicXor = &Opcode { Opname: "OpAtomicXor", Class: "Atomic", Opcode: 242, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Memory'", Quantifier: "", }, Operand { Kind: OperandKindIdMemorySemantics, Name: "'Semantics'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, }, } OpPhi = &Opcode { Opname: "OpPhi", Class: "Control-Flow", Opcode: 245, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindPairIdRefIdRef, Name: "'Variable, Parent, ...'", Quantifier: "*", }, }, } OpLoopMerge = &Opcode { Opname: "OpLoopMerge", Class: "Control-Flow", Opcode: 246, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Merge Block'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Continue Target'", Quantifier: "", }, Operand { Kind: OperandKindLoopControl, Name: "", Quantifier: "", }, }, } OpSelectionMerge = &Opcode { Opname: "OpSelectionMerge", Class: "Control-Flow", Opcode: 247, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Merge Block'", Quantifier: "", }, Operand { Kind: OperandKindSelectionControl, Name: "", Quantifier: "", }, }, } OpLabel = &Opcode { Opname: "OpLabel", Class: "Control-Flow", Opcode: 248, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpBranch = &Opcode { Opname: "OpBranch", Class: "Control-Flow", Opcode: 249, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Target Label'", Quantifier: "", }, }, } OpBranchConditional = &Opcode { Opname: "OpBranchConditional", Class: "Control-Flow", Opcode: 250, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Condition'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'True Label'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'False Label'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Branch weights'", Quantifier: "*", }, }, } OpSwitch = &Opcode { Opname: "OpSwitch", Class: "Control-Flow", Opcode: 251, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Selector'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Default'", Quantifier: "", }, Operand { Kind: OperandKindPairLiteralIntegerIdRef, Name: "'Target'", Quantifier: "*", }, }, } OpKill = &Opcode { Opname: "OpKill", Class: "Control-Flow", Opcode: 252, Operands: []Operand { }, } OpReturn = &Opcode { Opname: "OpReturn", Class: "Control-Flow", Opcode: 253, Operands: []Operand { }, } OpReturnValue = &Opcode { Opname: "OpReturnValue", Class: "Control-Flow", Opcode: 254, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, }, } OpUnreachable = &Opcode { Opname: "OpUnreachable", Class: "Control-Flow", Opcode: 255, Operands: []Operand { }, } OpLifetimeStart = &Opcode { Opname: "OpLifetimeStart", Class: "Control-Flow", Opcode: 256, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Size'", Quantifier: "", }, }, } OpLifetimeStop = &Opcode { Opname: "OpLifetimeStop", Class: "Control-Flow", Opcode: 257, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Size'", Quantifier: "", }, }, } OpGroupAsyncCopy = &Opcode { Opname: "OpGroupAsyncCopy", Class: "Group", Opcode: 259, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Destination'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Source'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Num Elements'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Stride'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Event'", Quantifier: "", }, }, } OpGroupWaitEvents = &Opcode { Opname: "OpGroupWaitEvents", Class: "Group", Opcode: 260, Operands: []Operand { Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Num Events'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Events List'", Quantifier: "", }, }, } OpGroupAll = &Opcode { Opname: "OpGroupAll", Class: "Group", Opcode: 261, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Predicate'", Quantifier: "", }, }, } OpGroupAny = &Opcode { Opname: "OpGroupAny", Class: "Group", Opcode: 262, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Predicate'", Quantifier: "", }, }, } OpGroupBroadcast = &Opcode { Opname: "OpGroupBroadcast", Class: "Group", Opcode: 263, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'LocalId'", Quantifier: "", }, }, } OpGroupIAdd = &Opcode { Opname: "OpGroupIAdd", Class: "Group", Opcode: 264, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'X'", Quantifier: "", }, }, } OpGroupFAdd = &Opcode { Opname: "OpGroupFAdd", Class: "Group", Opcode: 265, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'X'", Quantifier: "", }, }, } OpGroupFMin = &Opcode { Opname: "OpGroupFMin", Class: "Group", Opcode: 266, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'X'", Quantifier: "", }, }, } OpGroupUMin = &Opcode { Opname: "OpGroupUMin", Class: "Group", Opcode: 267, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'X'", Quantifier: "", }, }, } OpGroupSMin = &Opcode { Opname: "OpGroupSMin", Class: "Group", Opcode: 268, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'X'", Quantifier: "", }, }, } OpGroupFMax = &Opcode { Opname: "OpGroupFMax", Class: "Group", Opcode: 269, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'X'", Quantifier: "", }, }, } OpGroupUMax = &Opcode { Opname: "OpGroupUMax", Class: "Group", Opcode: 270, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'X'", Quantifier: "", }, }, } OpGroupSMax = &Opcode { Opname: "OpGroupSMax", Class: "Group", Opcode: 271, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'X'", Quantifier: "", }, }, } OpReadPipe = &Opcode { Opname: "OpReadPipe", Class: "Pipe", Opcode: 274, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pipe'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packet Size'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packet Alignment'", Quantifier: "", }, }, } OpWritePipe = &Opcode { Opname: "OpWritePipe", Class: "Pipe", Opcode: 275, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pipe'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packet Size'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packet Alignment'", Quantifier: "", }, }, } OpReservedReadPipe = &Opcode { Opname: "OpReservedReadPipe", Class: "Pipe", Opcode: 276, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pipe'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Reserve Id'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Index'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packet Size'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packet Alignment'", Quantifier: "", }, }, } OpReservedWritePipe = &Opcode { Opname: "OpReservedWritePipe", Class: "Pipe", Opcode: 277, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pipe'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Reserve Id'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Index'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packet Size'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packet Alignment'", Quantifier: "", }, }, } OpReserveReadPipePackets = &Opcode { Opname: "OpReserveReadPipePackets", Class: "Pipe", Opcode: 278, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pipe'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Num Packets'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packet Size'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packet Alignment'", Quantifier: "", }, }, } OpReserveWritePipePackets = &Opcode { Opname: "OpReserveWritePipePackets", Class: "Pipe", Opcode: 279, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pipe'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Num Packets'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packet Size'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packet Alignment'", Quantifier: "", }, }, } OpCommitReadPipe = &Opcode { Opname: "OpCommitReadPipe", Class: "Pipe", Opcode: 280, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Pipe'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Reserve Id'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packet Size'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packet Alignment'", Quantifier: "", }, }, } OpCommitWritePipe = &Opcode { Opname: "OpCommitWritePipe", Class: "Pipe", Opcode: 281, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Pipe'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Reserve Id'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packet Size'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packet Alignment'", Quantifier: "", }, }, } OpIsValidReserveId = &Opcode { Opname: "OpIsValidReserveId", Class: "Pipe", Opcode: 282, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Reserve Id'", Quantifier: "", }, }, } OpGetNumPipePackets = &Opcode { Opname: "OpGetNumPipePackets", Class: "Pipe", Opcode: 283, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pipe'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packet Size'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packet Alignment'", Quantifier: "", }, }, } OpGetMaxPipePackets = &Opcode { Opname: "OpGetMaxPipePackets", Class: "Pipe", Opcode: 284, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pipe'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packet Size'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packet Alignment'", Quantifier: "", }, }, } OpGroupReserveReadPipePackets = &Opcode { Opname: "OpGroupReserveReadPipePackets", Class: "Pipe", Opcode: 285, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pipe'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Num Packets'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packet Size'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packet Alignment'", Quantifier: "", }, }, } OpGroupReserveWritePipePackets = &Opcode { Opname: "OpGroupReserveWritePipePackets", Class: "Pipe", Opcode: 286, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pipe'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Num Packets'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packet Size'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packet Alignment'", Quantifier: "", }, }, } OpGroupCommitReadPipe = &Opcode { Opname: "OpGroupCommitReadPipe", Class: "Pipe", Opcode: 287, Operands: []Operand { Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pipe'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Reserve Id'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packet Size'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packet Alignment'", Quantifier: "", }, }, } OpGroupCommitWritePipe = &Opcode { Opname: "OpGroupCommitWritePipe", Class: "Pipe", Opcode: 288, Operands: []Operand { Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pipe'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Reserve Id'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packet Size'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packet Alignment'", Quantifier: "", }, }, } OpEnqueueMarker = &Opcode { Opname: "OpEnqueueMarker", Class: "Device-Side_Enqueue", Opcode: 291, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Queue'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Num Events'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Wait Events'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Ret Event'", Quantifier: "", }, }, } OpEnqueueKernel = &Opcode { Opname: "OpEnqueueKernel", Class: "Device-Side_Enqueue", Opcode: 292, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Queue'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Flags'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'ND Range'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Num Events'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Wait Events'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Ret Event'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Invoke'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Param'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Param Size'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Param Align'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Local Size'", Quantifier: "*", }, }, } OpGetKernelNDrangeSubGroupCount = &Opcode { Opname: "OpGetKernelNDrangeSubGroupCount", Class: "Device-Side_Enqueue", Opcode: 293, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'ND Range'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Invoke'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Param'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Param Size'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Param Align'", Quantifier: "", }, }, } OpGetKernelNDrangeMaxSubGroupSize = &Opcode { Opname: "OpGetKernelNDrangeMaxSubGroupSize", Class: "Device-Side_Enqueue", Opcode: 294, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'ND Range'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Invoke'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Param'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Param Size'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Param Align'", Quantifier: "", }, }, } OpGetKernelWorkGroupSize = &Opcode { Opname: "OpGetKernelWorkGroupSize", Class: "Device-Side_Enqueue", Opcode: 295, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Invoke'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Param'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Param Size'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Param Align'", Quantifier: "", }, }, } OpGetKernelPreferredWorkGroupSizeMultiple = &Opcode { Opname: "OpGetKernelPreferredWorkGroupSizeMultiple", Class: "Device-Side_Enqueue", Opcode: 296, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Invoke'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Param'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Param Size'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Param Align'", Quantifier: "", }, }, } OpRetainEvent = &Opcode { Opname: "OpRetainEvent", Class: "Device-Side_Enqueue", Opcode: 297, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Event'", Quantifier: "", }, }, } OpReleaseEvent = &Opcode { Opname: "OpReleaseEvent", Class: "Device-Side_Enqueue", Opcode: 298, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Event'", Quantifier: "", }, }, } OpCreateUserEvent = &Opcode { Opname: "OpCreateUserEvent", Class: "Device-Side_Enqueue", Opcode: 299, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpIsValidEvent = &Opcode { Opname: "OpIsValidEvent", Class: "Device-Side_Enqueue", Opcode: 300, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Event'", Quantifier: "", }, }, } OpSetUserEventStatus = &Opcode { Opname: "OpSetUserEventStatus", Class: "Device-Side_Enqueue", Opcode: 301, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Event'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Status'", Quantifier: "", }, }, } OpCaptureEventProfilingInfo = &Opcode { Opname: "OpCaptureEventProfilingInfo", Class: "Device-Side_Enqueue", Opcode: 302, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Event'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Profiling Info'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, }, } OpGetDefaultQueue = &Opcode { Opname: "OpGetDefaultQueue", Class: "Device-Side_Enqueue", Opcode: 303, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpBuildNDRange = &Opcode { Opname: "OpBuildNDRange", Class: "Device-Side_Enqueue", Opcode: 304, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'GlobalWorkSize'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'LocalWorkSize'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'GlobalWorkOffset'", Quantifier: "", }, }, } OpImageSparseSampleImplicitLod = &Opcode { Opname: "OpImageSparseSampleImplicitLod", Class: "Image", Opcode: 305, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Sampled Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Coordinate'", Quantifier: "", }, Operand { Kind: OperandKindImageOperands, Name: "", Quantifier: "?", }, }, } OpImageSparseSampleExplicitLod = &Opcode { Opname: "OpImageSparseSampleExplicitLod", Class: "Image", Opcode: 306, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Sampled Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Coordinate'", Quantifier: "", }, Operand { Kind: OperandKindImageOperands, Name: "", Quantifier: "", }, }, } OpImageSparseSampleDrefImplicitLod = &Opcode { Opname: "OpImageSparseSampleDrefImplicitLod", Class: "Image", Opcode: 307, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Sampled Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Coordinate'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'D~ref~'", Quantifier: "", }, Operand { Kind: OperandKindImageOperands, Name: "", Quantifier: "?", }, }, } OpImageSparseSampleDrefExplicitLod = &Opcode { Opname: "OpImageSparseSampleDrefExplicitLod", Class: "Image", Opcode: 308, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Sampled Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Coordinate'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'D~ref~'", Quantifier: "", }, Operand { Kind: OperandKindImageOperands, Name: "", Quantifier: "", }, }, } OpImageSparseSampleProjImplicitLod = &Opcode { Opname: "OpImageSparseSampleProjImplicitLod", Class: "Image", Opcode: 309, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Sampled Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Coordinate'", Quantifier: "", }, Operand { Kind: OperandKindImageOperands, Name: "", Quantifier: "?", }, }, } OpImageSparseSampleProjExplicitLod = &Opcode { Opname: "OpImageSparseSampleProjExplicitLod", Class: "Image", Opcode: 310, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Sampled Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Coordinate'", Quantifier: "", }, Operand { Kind: OperandKindImageOperands, Name: "", Quantifier: "", }, }, } OpImageSparseSampleProjDrefImplicitLod = &Opcode { Opname: "OpImageSparseSampleProjDrefImplicitLod", Class: "Image", Opcode: 311, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Sampled Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Coordinate'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'D~ref~'", Quantifier: "", }, Operand { Kind: OperandKindImageOperands, Name: "", Quantifier: "?", }, }, } OpImageSparseSampleProjDrefExplicitLod = &Opcode { Opname: "OpImageSparseSampleProjDrefExplicitLod", Class: "Image", Opcode: 312, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Sampled Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Coordinate'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'D~ref~'", Quantifier: "", }, Operand { Kind: OperandKindImageOperands, Name: "", Quantifier: "", }, }, } OpImageSparseFetch = &Opcode { Opname: "OpImageSparseFetch", Class: "Image", Opcode: 313, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Coordinate'", Quantifier: "", }, Operand { Kind: OperandKindImageOperands, Name: "", Quantifier: "?", }, }, } OpImageSparseGather = &Opcode { Opname: "OpImageSparseGather", Class: "Image", Opcode: 314, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Sampled Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Coordinate'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Component'", Quantifier: "", }, Operand { Kind: OperandKindImageOperands, Name: "", Quantifier: "?", }, }, } OpImageSparseDrefGather = &Opcode { Opname: "OpImageSparseDrefGather", Class: "Image", Opcode: 315, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Sampled Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Coordinate'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'D~ref~'", Quantifier: "", }, Operand { Kind: OperandKindImageOperands, Name: "", Quantifier: "?", }, }, } OpImageSparseTexelsResident = &Opcode { Opname: "OpImageSparseTexelsResident", Class: "Image", Opcode: 316, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Resident Code'", Quantifier: "", }, }, } OpNoLine = &Opcode { Opname: "OpNoLine", Class: "Debug", Opcode: 317, Operands: []Operand { }, } OpAtomicFlagTestAndSet = &Opcode { Opname: "OpAtomicFlagTestAndSet", Class: "Atomic", Opcode: 318, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Memory'", Quantifier: "", }, Operand { Kind: OperandKindIdMemorySemantics, Name: "'Semantics'", Quantifier: "", }, }, } OpAtomicFlagClear = &Opcode { Opname: "OpAtomicFlagClear", Class: "Atomic", Opcode: 319, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Memory'", Quantifier: "", }, Operand { Kind: OperandKindIdMemorySemantics, Name: "'Semantics'", Quantifier: "", }, }, } OpImageSparseRead = &Opcode { Opname: "OpImageSparseRead", Class: "Image", Opcode: 320, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Coordinate'", Quantifier: "", }, Operand { Kind: OperandKindImageOperands, Name: "", Quantifier: "?", }, }, } OpSizeOf = &Opcode { Opname: "OpSizeOf", Class: "Miscellaneous", Opcode: 321, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, }, } OpTypePipeStorage = &Opcode { Opname: "OpTypePipeStorage", Class: "Type-Declaration", Opcode: 322, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpConstantPipeStorage = &Opcode { Opname: "OpConstantPipeStorage", Class: "Pipe", Opcode: 323, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Packet Size'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Packet Alignment'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Capacity'", Quantifier: "", }, }, } OpCreatePipeFromPipeStorage = &Opcode { Opname: "OpCreatePipeFromPipeStorage", Class: "Pipe", Opcode: 324, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pipe Storage'", Quantifier: "", }, }, } OpGetKernelLocalSizeForSubgroupCount = &Opcode { Opname: "OpGetKernelLocalSizeForSubgroupCount", Class: "Device-Side_Enqueue", Opcode: 325, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Subgroup Count'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Invoke'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Param'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Param Size'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Param Align'", Quantifier: "", }, }, } OpGetKernelMaxNumSubgroups = &Opcode { Opname: "OpGetKernelMaxNumSubgroups", Class: "Device-Side_Enqueue", Opcode: 326, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Invoke'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Param'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Param Size'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Param Align'", Quantifier: "", }, }, } OpTypeNamedBarrier = &Opcode { Opname: "OpTypeNamedBarrier", Class: "Type-Declaration", Opcode: 327, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpNamedBarrierInitialize = &Opcode { Opname: "OpNamedBarrierInitialize", Class: "Barrier", Opcode: 328, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Subgroup Count'", Quantifier: "", }, }, } OpMemoryNamedBarrier = &Opcode { Opname: "OpMemoryNamedBarrier", Class: "Barrier", Opcode: 329, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Named Barrier'", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Memory'", Quantifier: "", }, Operand { Kind: OperandKindIdMemorySemantics, Name: "'Semantics'", Quantifier: "", }, }, } OpModuleProcessed = &Opcode { Opname: "OpModuleProcessed", Class: "Debug", Opcode: 330, Operands: []Operand { Operand { Kind: OperandKindLiteralString, Name: "'Process'", Quantifier: "", }, }, } OpExecutionModeId = &Opcode { Opname: "OpExecutionModeId", Class: "Mode-Setting", Opcode: 331, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Entry Point'", Quantifier: "", }, Operand { Kind: OperandKindExecutionMode, Name: "'Mode'", Quantifier: "", }, }, } OpDecorateId = &Opcode { Opname: "OpDecorateId", Class: "Annotation", Opcode: 332, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Target'", Quantifier: "", }, Operand { Kind: OperandKindDecoration, Name: "", Quantifier: "", }, }, } OpGroupNonUniformElect = &Opcode { Opname: "OpGroupNonUniformElect", Class: "Non-Uniform", Opcode: 333, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, }, } OpGroupNonUniformAll = &Opcode { Opname: "OpGroupNonUniformAll", Class: "Non-Uniform", Opcode: 334, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Predicate'", Quantifier: "", }, }, } OpGroupNonUniformAny = &Opcode { Opname: "OpGroupNonUniformAny", Class: "Non-Uniform", Opcode: 335, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Predicate'", Quantifier: "", }, }, } OpGroupNonUniformAllEqual = &Opcode { Opname: "OpGroupNonUniformAllEqual", Class: "Non-Uniform", Opcode: 336, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, }, } OpGroupNonUniformBroadcast = &Opcode { Opname: "OpGroupNonUniformBroadcast", Class: "Non-Uniform", Opcode: 337, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Id'", Quantifier: "", }, }, } OpGroupNonUniformBroadcastFirst = &Opcode { Opname: "OpGroupNonUniformBroadcastFirst", Class: "Non-Uniform", Opcode: 338, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, }, } OpGroupNonUniformBallot = &Opcode { Opname: "OpGroupNonUniformBallot", Class: "Non-Uniform", Opcode: 339, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Predicate'", Quantifier: "", }, }, } OpGroupNonUniformInverseBallot = &Opcode { Opname: "OpGroupNonUniformInverseBallot", Class: "Non-Uniform", Opcode: 340, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, }, } OpGroupNonUniformBallotBitExtract = &Opcode { Opname: "OpGroupNonUniformBallotBitExtract", Class: "Non-Uniform", Opcode: 341, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Index'", Quantifier: "", }, }, } OpGroupNonUniformBallotBitCount = &Opcode { Opname: "OpGroupNonUniformBallotBitCount", Class: "Non-Uniform", Opcode: 342, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, }, } OpGroupNonUniformBallotFindLSB = &Opcode { Opname: "OpGroupNonUniformBallotFindLSB", Class: "Non-Uniform", Opcode: 343, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, }, } OpGroupNonUniformBallotFindMSB = &Opcode { Opname: "OpGroupNonUniformBallotFindMSB", Class: "Non-Uniform", Opcode: 344, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, }, } OpGroupNonUniformShuffle = &Opcode { Opname: "OpGroupNonUniformShuffle", Class: "Non-Uniform", Opcode: 345, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Id'", Quantifier: "", }, }, } OpGroupNonUniformShuffleXor = &Opcode { Opname: "OpGroupNonUniformShuffleXor", Class: "Non-Uniform", Opcode: 346, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Mask'", Quantifier: "", }, }, } OpGroupNonUniformShuffleUp = &Opcode { Opname: "OpGroupNonUniformShuffleUp", Class: "Non-Uniform", Opcode: 347, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Delta'", Quantifier: "", }, }, } OpGroupNonUniformShuffleDown = &Opcode { Opname: "OpGroupNonUniformShuffleDown", Class: "Non-Uniform", Opcode: 348, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Delta'", Quantifier: "", }, }, } OpGroupNonUniformIAdd = &Opcode { Opname: "OpGroupNonUniformIAdd", Class: "Non-Uniform", Opcode: 349, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'ClusterSize'", Quantifier: "?", }, }, } OpGroupNonUniformFAdd = &Opcode { Opname: "OpGroupNonUniformFAdd", Class: "Non-Uniform", Opcode: 350, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'ClusterSize'", Quantifier: "?", }, }, } OpGroupNonUniformIMul = &Opcode { Opname: "OpGroupNonUniformIMul", Class: "Non-Uniform", Opcode: 351, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'ClusterSize'", Quantifier: "?", }, }, } OpGroupNonUniformFMul = &Opcode { Opname: "OpGroupNonUniformFMul", Class: "Non-Uniform", Opcode: 352, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'ClusterSize'", Quantifier: "?", }, }, } OpGroupNonUniformSMin = &Opcode { Opname: "OpGroupNonUniformSMin", Class: "Non-Uniform", Opcode: 353, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'ClusterSize'", Quantifier: "?", }, }, } OpGroupNonUniformUMin = &Opcode { Opname: "OpGroupNonUniformUMin", Class: "Non-Uniform", Opcode: 354, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'ClusterSize'", Quantifier: "?", }, }, } OpGroupNonUniformFMin = &Opcode { Opname: "OpGroupNonUniformFMin", Class: "Non-Uniform", Opcode: 355, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'ClusterSize'", Quantifier: "?", }, }, } OpGroupNonUniformSMax = &Opcode { Opname: "OpGroupNonUniformSMax", Class: "Non-Uniform", Opcode: 356, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'ClusterSize'", Quantifier: "?", }, }, } OpGroupNonUniformUMax = &Opcode { Opname: "OpGroupNonUniformUMax", Class: "Non-Uniform", Opcode: 357, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'ClusterSize'", Quantifier: "?", }, }, } OpGroupNonUniformFMax = &Opcode { Opname: "OpGroupNonUniformFMax", Class: "Non-Uniform", Opcode: 358, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'ClusterSize'", Quantifier: "?", }, }, } OpGroupNonUniformBitwiseAnd = &Opcode { Opname: "OpGroupNonUniformBitwiseAnd", Class: "Non-Uniform", Opcode: 359, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'ClusterSize'", Quantifier: "?", }, }, } OpGroupNonUniformBitwiseOr = &Opcode { Opname: "OpGroupNonUniformBitwiseOr", Class: "Non-Uniform", Opcode: 360, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'ClusterSize'", Quantifier: "?", }, }, } OpGroupNonUniformBitwiseXor = &Opcode { Opname: "OpGroupNonUniformBitwiseXor", Class: "Non-Uniform", Opcode: 361, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'ClusterSize'", Quantifier: "?", }, }, } OpGroupNonUniformLogicalAnd = &Opcode { Opname: "OpGroupNonUniformLogicalAnd", Class: "Non-Uniform", Opcode: 362, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'ClusterSize'", Quantifier: "?", }, }, } OpGroupNonUniformLogicalOr = &Opcode { Opname: "OpGroupNonUniformLogicalOr", Class: "Non-Uniform", Opcode: 363, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'ClusterSize'", Quantifier: "?", }, }, } OpGroupNonUniformLogicalXor = &Opcode { Opname: "OpGroupNonUniformLogicalXor", Class: "Non-Uniform", Opcode: 364, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'ClusterSize'", Quantifier: "?", }, }, } OpGroupNonUniformQuadBroadcast = &Opcode { Opname: "OpGroupNonUniformQuadBroadcast", Class: "Non-Uniform", Opcode: 365, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Index'", Quantifier: "", }, }, } OpGroupNonUniformQuadSwap = &Opcode { Opname: "OpGroupNonUniformQuadSwap", Class: "Non-Uniform", Opcode: 366, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Direction'", Quantifier: "", }, }, } OpCopyLogical = &Opcode { Opname: "OpCopyLogical", Class: "Composite", Opcode: 400, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand'", Quantifier: "", }, }, } OpPtrEqual = &Opcode { Opname: "OpPtrEqual", Class: "Memory", Opcode: 401, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpPtrNotEqual = &Opcode { Opname: "OpPtrNotEqual", Class: "Memory", Opcode: 402, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpPtrDiff = &Opcode { Opname: "OpPtrDiff", Class: "Memory", Opcode: 403, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpColorAttachmentReadEXT = &Opcode { Opname: "OpColorAttachmentReadEXT", Class: "Image", Opcode: 4160, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Attachment'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Sample'", Quantifier: "?", }, }, } OpDepthAttachmentReadEXT = &Opcode { Opname: "OpDepthAttachmentReadEXT", Class: "Image", Opcode: 4161, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Sample'", Quantifier: "?", }, }, } OpStencilAttachmentReadEXT = &Opcode { Opname: "OpStencilAttachmentReadEXT", Class: "Image", Opcode: 4162, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Sample'", Quantifier: "?", }, }, } OpTerminateInvocation = &Opcode { Opname: "OpTerminateInvocation", Class: "Control-Flow", Opcode: 4416, Operands: []Operand { }, } OpTypeUntypedPointerKHR = &Opcode { Opname: "OpTypeUntypedPointerKHR", Class: "Type-Declaration", Opcode: 4417, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindStorageClass, Name: "", Quantifier: "", }, }, } OpUntypedVariableKHR = &Opcode { Opname: "OpUntypedVariableKHR", Class: "Memory", Opcode: 4418, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindStorageClass, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Data Type'", Quantifier: "?", }, Operand { Kind: OperandKindIdRef, Name: "'Initializer'", Quantifier: "?", }, }, } OpUntypedAccessChainKHR = &Opcode { Opname: "OpUntypedAccessChainKHR", Class: "Memory", Opcode: 4419, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Base Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Base'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Indexes'", Quantifier: "*", }, }, } OpUntypedInBoundsAccessChainKHR = &Opcode { Opname: "OpUntypedInBoundsAccessChainKHR", Class: "Memory", Opcode: 4420, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Base Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Base'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Indexes'", Quantifier: "*", }, }, } OpSubgroupBallotKHR = &Opcode { Opname: "OpSubgroupBallotKHR", Class: "Group", Opcode: 4421, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Predicate'", Quantifier: "", }, }, } OpSubgroupFirstInvocationKHR = &Opcode { Opname: "OpSubgroupFirstInvocationKHR", Class: "Group", Opcode: 4422, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, }, } OpUntypedPtrAccessChainKHR = &Opcode { Opname: "OpUntypedPtrAccessChainKHR", Class: "Memory", Opcode: 4423, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Base Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Base'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Element'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Indexes'", Quantifier: "*", }, }, } OpUntypedInBoundsPtrAccessChainKHR = &Opcode { Opname: "OpUntypedInBoundsPtrAccessChainKHR", Class: "Memory", Opcode: 4424, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Base Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Base'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Element'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Indexes'", Quantifier: "*", }, }, } OpUntypedArrayLengthKHR = &Opcode { Opname: "OpUntypedArrayLengthKHR", Class: "Memory", Opcode: 4425, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Structure'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Array member'", Quantifier: "", }, }, } OpUntypedPrefetchKHR = &Opcode { Opname: "OpUntypedPrefetchKHR", Class: "Memory", Opcode: 4426, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Pointer Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Num Bytes'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'RW'", Quantifier: "?", }, Operand { Kind: OperandKindIdRef, Name: "'Locality'", Quantifier: "?", }, Operand { Kind: OperandKindIdRef, Name: "'Cache Type'", Quantifier: "?", }, }, } OpSubgroupAllKHR = &Opcode { Opname: "OpSubgroupAllKHR", Class: "Group", Opcode: 4428, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Predicate'", Quantifier: "", }, }, } OpSubgroupAnyKHR = &Opcode { Opname: "OpSubgroupAnyKHR", Class: "Group", Opcode: 4429, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Predicate'", Quantifier: "", }, }, } OpSubgroupAllEqualKHR = &Opcode { Opname: "OpSubgroupAllEqualKHR", Class: "Group", Opcode: 4430, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Predicate'", Quantifier: "", }, }, } OpGroupNonUniformRotateKHR = &Opcode { Opname: "OpGroupNonUniformRotateKHR", Class: "Group", Opcode: 4431, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Delta'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'ClusterSize'", Quantifier: "?", }, }, } OpSubgroupReadInvocationKHR = &Opcode { Opname: "OpSubgroupReadInvocationKHR", Class: "Group", Opcode: 4432, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Index'", Quantifier: "", }, }, } OpExtInstWithForwardRefsKHR = &Opcode { Opname: "OpExtInstWithForwardRefsKHR", Class: "Extension", Opcode: 4433, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Set'", Quantifier: "", }, Operand { Kind: OperandKindLiteralExtInstInteger, Name: "'Instruction'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1', + 'Operand 2', + ...", Quantifier: "*", }, }, } OpTraceRayKHR = &Opcode { Opname: "OpTraceRayKHR", Class: "Reserved", Opcode: 4445, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Accel'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Ray Flags'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Cull Mask'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'SBT Offset'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'SBT Stride'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Miss Index'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Ray Origin'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Ray Tmin'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Ray Direction'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Ray Tmax'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpExecuteCallableKHR = &Opcode { Opname: "OpExecuteCallableKHR", Class: "Reserved", Opcode: 4446, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'SBT Index'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Callable Data'", Quantifier: "", }, }, } OpConvertUToAccelerationStructureKHR = &Opcode { Opname: "OpConvertUToAccelerationStructureKHR", Class: "Reserved", Opcode: 4447, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Accel'", Quantifier: "", }, }, } OpIgnoreIntersectionKHR = &Opcode { Opname: "OpIgnoreIntersectionKHR", Class: "Reserved", Opcode: 4448, Operands: []Operand { }, } OpTerminateRayKHR = &Opcode { Opname: "OpTerminateRayKHR", Class: "Reserved", Opcode: 4449, Operands: []Operand { }, } OpSDot = &Opcode { Opname: "OpSDot", Class: "Arithmetic", Opcode: 4450, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Vector 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Vector 2'", Quantifier: "", }, Operand { Kind: OperandKindPackedVectorFormat, Name: "'Packed Vector Format'", Quantifier: "?", }, }, } OpUDot = &Opcode { Opname: "OpUDot", Class: "Arithmetic", Opcode: 4451, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Vector 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Vector 2'", Quantifier: "", }, Operand { Kind: OperandKindPackedVectorFormat, Name: "'Packed Vector Format'", Quantifier: "?", }, }, } OpSUDot = &Opcode { Opname: "OpSUDot", Class: "Arithmetic", Opcode: 4452, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Vector 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Vector 2'", Quantifier: "", }, Operand { Kind: OperandKindPackedVectorFormat, Name: "'Packed Vector Format'", Quantifier: "?", }, }, } OpSDotAccSat = &Opcode { Opname: "OpSDotAccSat", Class: "Arithmetic", Opcode: 4453, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Vector 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Vector 2'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Accumulator'", Quantifier: "", }, Operand { Kind: OperandKindPackedVectorFormat, Name: "'Packed Vector Format'", Quantifier: "?", }, }, } OpUDotAccSat = &Opcode { Opname: "OpUDotAccSat", Class: "Arithmetic", Opcode: 4454, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Vector 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Vector 2'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Accumulator'", Quantifier: "", }, Operand { Kind: OperandKindPackedVectorFormat, Name: "'Packed Vector Format'", Quantifier: "?", }, }, } OpSUDotAccSat = &Opcode { Opname: "OpSUDotAccSat", Class: "Arithmetic", Opcode: 4455, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Vector 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Vector 2'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Accumulator'", Quantifier: "", }, Operand { Kind: OperandKindPackedVectorFormat, Name: "'Packed Vector Format'", Quantifier: "?", }, }, } OpTypeCooperativeMatrixKHR = &Opcode { Opname: "OpTypeCooperativeMatrixKHR", Class: "Type-Declaration", Opcode: 4456, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Component Type'", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Scope'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Rows'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Columns'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Use'", Quantifier: "", }, }, } OpCooperativeMatrixLoadKHR = &Opcode { Opname: "OpCooperativeMatrixLoadKHR", Class: "Memory", Opcode: 4457, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'MemoryLayout'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Stride'", Quantifier: "?", }, Operand { Kind: OperandKindMemoryAccess, Name: "'Memory Operand'", Quantifier: "?", }, }, } OpCooperativeMatrixStoreKHR = &Opcode { Opname: "OpCooperativeMatrixStoreKHR", Class: "Memory", Opcode: 4458, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Object'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'MemoryLayout'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Stride'", Quantifier: "?", }, Operand { Kind: OperandKindMemoryAccess, Name: "'Memory Operand'", Quantifier: "?", }, }, } OpCooperativeMatrixMulAddKHR = &Opcode { Opname: "OpCooperativeMatrixMulAddKHR", Class: "Arithmetic", Opcode: 4459, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'B'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'C'", Quantifier: "", }, Operand { Kind: OperandKindCooperativeMatrixOperands, Name: "'Cooperative Matrix Operands'", Quantifier: "?", }, }, } OpCooperativeMatrixLengthKHR = &Opcode { Opname: "OpCooperativeMatrixLengthKHR", Class: "Miscellaneous", Opcode: 4460, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Type'", Quantifier: "", }, }, } OpConstantCompositeReplicateEXT = &Opcode { Opname: "OpConstantCompositeReplicateEXT", Class: "Constant-Creation", Opcode: 4461, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, }, } OpSpecConstantCompositeReplicateEXT = &Opcode { Opname: "OpSpecConstantCompositeReplicateEXT", Class: "Constant-Creation", Opcode: 4462, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, }, } OpCompositeConstructReplicateEXT = &Opcode { Opname: "OpCompositeConstructReplicateEXT", Class: "Composite", Opcode: 4463, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, }, } OpTypeRayQueryKHR = &Opcode { Opname: "OpTypeRayQueryKHR", Class: "Type-Declaration", Opcode: 4472, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpRayQueryInitializeKHR = &Opcode { Opname: "OpRayQueryInitializeKHR", Class: "Reserved", Opcode: 4473, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'RayQuery'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Accel'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'RayFlags'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'CullMask'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'RayOrigin'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'RayTMin'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'RayDirection'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'RayTMax'", Quantifier: "", }, }, } OpRayQueryTerminateKHR = &Opcode { Opname: "OpRayQueryTerminateKHR", Class: "Reserved", Opcode: 4474, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'RayQuery'", Quantifier: "", }, }, } OpRayQueryGenerateIntersectionKHR = &Opcode { Opname: "OpRayQueryGenerateIntersectionKHR", Class: "Reserved", Opcode: 4475, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'RayQuery'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'HitT'", Quantifier: "", }, }, } OpRayQueryConfirmIntersectionKHR = &Opcode { Opname: "OpRayQueryConfirmIntersectionKHR", Class: "Reserved", Opcode: 4476, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'RayQuery'", Quantifier: "", }, }, } OpRayQueryProceedKHR = &Opcode { Opname: "OpRayQueryProceedKHR", Class: "Reserved", Opcode: 4477, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'RayQuery'", Quantifier: "", }, }, } OpRayQueryGetIntersectionTypeKHR = &Opcode { Opname: "OpRayQueryGetIntersectionTypeKHR", Class: "Reserved", Opcode: 4479, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'RayQuery'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Intersection'", Quantifier: "", }, }, } OpImageSampleWeightedQCOM = &Opcode { Opname: "OpImageSampleWeightedQCOM", Class: "Image", Opcode: 4480, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Texture'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Coordinates'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Weights'", Quantifier: "", }, }, } OpImageBoxFilterQCOM = &Opcode { Opname: "OpImageBoxFilterQCOM", Class: "Image", Opcode: 4481, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Texture'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Coordinates'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Box Size'", Quantifier: "", }, }, } OpImageBlockMatchSSDQCOM = &Opcode { Opname: "OpImageBlockMatchSSDQCOM", Class: "Image", Opcode: 4482, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Target'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Target Coordinates'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Reference'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Reference Coordinates'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Block Size'", Quantifier: "", }, }, } OpImageBlockMatchSADQCOM = &Opcode { Opname: "OpImageBlockMatchSADQCOM", Class: "Image", Opcode: 4483, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Target'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Target Coordinates'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Reference'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Reference Coordinates'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Block Size'", Quantifier: "", }, }, } OpImageBlockMatchWindowSSDQCOM = &Opcode { Opname: "OpImageBlockMatchWindowSSDQCOM", Class: "Image", Opcode: 4500, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Target Sampled Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Target Coordinates'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Reference Sampled Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Reference Coordinates'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Block Size'", Quantifier: "", }, }, } OpImageBlockMatchWindowSADQCOM = &Opcode { Opname: "OpImageBlockMatchWindowSADQCOM", Class: "Image", Opcode: 4501, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Target Sampled Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Target Coordinates'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Reference Sampled Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Reference Coordinates'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Block Size'", Quantifier: "", }, }, } OpImageBlockMatchGatherSSDQCOM = &Opcode { Opname: "OpImageBlockMatchGatherSSDQCOM", Class: "Image", Opcode: 4502, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Target Sampled Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Target Coordinates'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Reference Sampled Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Reference Coordinates'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Block Size'", Quantifier: "", }, }, } OpImageBlockMatchGatherSADQCOM = &Opcode { Opname: "OpImageBlockMatchGatherSADQCOM", Class: "Image", Opcode: 4503, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Target Sampled Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Target Coordinates'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Reference Sampled Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Reference Coordinates'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Block Size'", Quantifier: "", }, }, } OpGroupIAddNonUniformAMD = &Opcode { Opname: "OpGroupIAddNonUniformAMD", Class: "Group", Opcode: 5000, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'X'", Quantifier: "", }, }, } OpGroupFAddNonUniformAMD = &Opcode { Opname: "OpGroupFAddNonUniformAMD", Class: "Group", Opcode: 5001, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'X'", Quantifier: "", }, }, } OpGroupFMinNonUniformAMD = &Opcode { Opname: "OpGroupFMinNonUniformAMD", Class: "Group", Opcode: 5002, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'X'", Quantifier: "", }, }, } OpGroupUMinNonUniformAMD = &Opcode { Opname: "OpGroupUMinNonUniformAMD", Class: "Group", Opcode: 5003, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'X'", Quantifier: "", }, }, } OpGroupSMinNonUniformAMD = &Opcode { Opname: "OpGroupSMinNonUniformAMD", Class: "Group", Opcode: 5004, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'X'", Quantifier: "", }, }, } OpGroupFMaxNonUniformAMD = &Opcode { Opname: "OpGroupFMaxNonUniformAMD", Class: "Group", Opcode: 5005, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'X'", Quantifier: "", }, }, } OpGroupUMaxNonUniformAMD = &Opcode { Opname: "OpGroupUMaxNonUniformAMD", Class: "Group", Opcode: 5006, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'X'", Quantifier: "", }, }, } OpGroupSMaxNonUniformAMD = &Opcode { Opname: "OpGroupSMaxNonUniformAMD", Class: "Group", Opcode: 5007, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'X'", Quantifier: "", }, }, } OpFragmentMaskFetchAMD = &Opcode { Opname: "OpFragmentMaskFetchAMD", Class: "Reserved", Opcode: 5011, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Coordinate'", Quantifier: "", }, }, } OpFragmentFetchAMD = &Opcode { Opname: "OpFragmentFetchAMD", Class: "Reserved", Opcode: 5012, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Coordinate'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Fragment Index'", Quantifier: "", }, }, } OpReadClockKHR = &Opcode { Opname: "OpReadClockKHR", Class: "Reserved", Opcode: 5056, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Scope'", Quantifier: "", }, }, } OpAllocateNodePayloadsAMDX = &Opcode { Opname: "OpAllocateNodePayloadsAMDX", Class: "Reserved", Opcode: 5074, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Visibility'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload Count'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Node Index'", Quantifier: "", }, }, } OpEnqueueNodePayloadsAMDX = &Opcode { Opname: "OpEnqueueNodePayloadsAMDX", Class: "Reserved", Opcode: 5075, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Payload Array'", Quantifier: "", }, }, } OpTypeNodePayloadArrayAMDX = &Opcode { Opname: "OpTypeNodePayloadArrayAMDX", Class: "Reserved", Opcode: 5076, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload Type'", Quantifier: "", }, }, } OpFinishWritingNodePayloadAMDX = &Opcode { Opname: "OpFinishWritingNodePayloadAMDX", Class: "Reserved", Opcode: 5078, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpNodePayloadArrayLengthAMDX = &Opcode { Opname: "OpNodePayloadArrayLengthAMDX", Class: "Reserved", Opcode: 5090, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload Array'", Quantifier: "", }, }, } OpIsNodePayloadValidAMDX = &Opcode { Opname: "OpIsNodePayloadValidAMDX", Class: "Reserved", Opcode: 5101, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Node Index'", Quantifier: "", }, }, } OpConstantStringAMDX = &Opcode { Opname: "OpConstantStringAMDX", Class: "Reserved", Opcode: 5103, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindLiteralString, Name: "'Literal String'", Quantifier: "", }, }, } OpSpecConstantStringAMDX = &Opcode { Opname: "OpSpecConstantStringAMDX", Class: "Reserved", Opcode: 5104, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindLiteralString, Name: "'Literal String'", Quantifier: "", }, }, } OpGroupNonUniformQuadAllKHR = &Opcode { Opname: "OpGroupNonUniformQuadAllKHR", Class: "Non-Uniform", Opcode: 5110, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Predicate'", Quantifier: "", }, }, } OpGroupNonUniformQuadAnyKHR = &Opcode { Opname: "OpGroupNonUniformQuadAnyKHR", Class: "Non-Uniform", Opcode: 5111, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Predicate'", Quantifier: "", }, }, } OpHitObjectRecordHitMotionNV = &Opcode { Opname: "OpHitObjectRecordHitMotionNV", Class: "Reserved", Opcode: 5249, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Hit Object'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Acceleration Structure'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'InstanceId'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'PrimitiveId'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'GeometryIndex'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Hit Kind'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'SBT Record Offset'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'SBT Record Stride'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Origin'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'TMin'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Direction'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'TMax'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Current Time'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'HitObject Attributes'", Quantifier: "", }, }, } OpHitObjectRecordHitWithIndexMotionNV = &Opcode { Opname: "OpHitObjectRecordHitWithIndexMotionNV", Class: "Reserved", Opcode: 5250, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Hit Object'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Acceleration Structure'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'InstanceId'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'PrimitiveId'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'GeometryIndex'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Hit Kind'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'SBT Record Index'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Origin'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'TMin'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Direction'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'TMax'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Current Time'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'HitObject Attributes'", Quantifier: "", }, }, } OpHitObjectRecordMissMotionNV = &Opcode { Opname: "OpHitObjectRecordMissMotionNV", Class: "Reserved", Opcode: 5251, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Hit Object'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'SBT Index'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Origin'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'TMin'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Direction'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'TMax'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Current Time'", Quantifier: "", }, }, } OpHitObjectGetWorldToObjectNV = &Opcode { Opname: "OpHitObjectGetWorldToObjectNV", Class: "Reserved", Opcode: 5252, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Hit Object'", Quantifier: "", }, }, } OpHitObjectGetObjectToWorldNV = &Opcode { Opname: "OpHitObjectGetObjectToWorldNV", Class: "Reserved", Opcode: 5253, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Hit Object'", Quantifier: "", }, }, } OpHitObjectGetObjectRayDirectionNV = &Opcode { Opname: "OpHitObjectGetObjectRayDirectionNV", Class: "Reserved", Opcode: 5254, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Hit Object'", Quantifier: "", }, }, } OpHitObjectGetObjectRayOriginNV = &Opcode { Opname: "OpHitObjectGetObjectRayOriginNV", Class: "Reserved", Opcode: 5255, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Hit Object'", Quantifier: "", }, }, } OpHitObjectTraceRayMotionNV = &Opcode { Opname: "OpHitObjectTraceRayMotionNV", Class: "Reserved", Opcode: 5256, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Hit Object'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Acceleration Structure'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'RayFlags'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Cullmask'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'SBT Record Offset'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'SBT Record Stride'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Miss Index'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Origin'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'TMin'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Direction'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'TMax'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Time'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpHitObjectGetShaderRecordBufferHandleNV = &Opcode { Opname: "OpHitObjectGetShaderRecordBufferHandleNV", Class: "Reserved", Opcode: 5257, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Hit Object'", Quantifier: "", }, }, } OpHitObjectGetShaderBindingTableRecordIndexNV = &Opcode { Opname: "OpHitObjectGetShaderBindingTableRecordIndexNV", Class: "Reserved", Opcode: 5258, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Hit Object'", Quantifier: "", }, }, } OpHitObjectRecordEmptyNV = &Opcode { Opname: "OpHitObjectRecordEmptyNV", Class: "Reserved", Opcode: 5259, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Hit Object'", Quantifier: "", }, }, } OpHitObjectTraceRayNV = &Opcode { Opname: "OpHitObjectTraceRayNV", Class: "Reserved", Opcode: 5260, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Hit Object'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Acceleration Structure'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'RayFlags'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Cullmask'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'SBT Record Offset'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'SBT Record Stride'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Miss Index'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Origin'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'TMin'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Direction'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'TMax'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpHitObjectRecordHitNV = &Opcode { Opname: "OpHitObjectRecordHitNV", Class: "Reserved", Opcode: 5261, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Hit Object'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Acceleration Structure'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'InstanceId'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'PrimitiveId'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'GeometryIndex'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Hit Kind'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'SBT Record Offset'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'SBT Record Stride'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Origin'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'TMin'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Direction'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'TMax'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'HitObject Attributes'", Quantifier: "", }, }, } OpHitObjectRecordHitWithIndexNV = &Opcode { Opname: "OpHitObjectRecordHitWithIndexNV", Class: "Reserved", Opcode: 5262, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Hit Object'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Acceleration Structure'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'InstanceId'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'PrimitiveId'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'GeometryIndex'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Hit Kind'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'SBT Record Index'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Origin'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'TMin'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Direction'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'TMax'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'HitObject Attributes'", Quantifier: "", }, }, } OpHitObjectRecordMissNV = &Opcode { Opname: "OpHitObjectRecordMissNV", Class: "Reserved", Opcode: 5263, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Hit Object'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'SBT Index'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Origin'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'TMin'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Direction'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'TMax'", Quantifier: "", }, }, } OpHitObjectExecuteShaderNV = &Opcode { Opname: "OpHitObjectExecuteShaderNV", Class: "Reserved", Opcode: 5264, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Hit Object'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpHitObjectGetCurrentTimeNV = &Opcode { Opname: "OpHitObjectGetCurrentTimeNV", Class: "Reserved", Opcode: 5265, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Hit Object'", Quantifier: "", }, }, } OpHitObjectGetAttributesNV = &Opcode { Opname: "OpHitObjectGetAttributesNV", Class: "Reserved", Opcode: 5266, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Hit Object'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Hit Object Attribute'", Quantifier: "", }, }, } OpHitObjectGetHitKindNV = &Opcode { Opname: "OpHitObjectGetHitKindNV", Class: "Reserved", Opcode: 5267, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Hit Object'", Quantifier: "", }, }, } OpHitObjectGetPrimitiveIndexNV = &Opcode { Opname: "OpHitObjectGetPrimitiveIndexNV", Class: "Reserved", Opcode: 5268, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Hit Object'", Quantifier: "", }, }, } OpHitObjectGetGeometryIndexNV = &Opcode { Opname: "OpHitObjectGetGeometryIndexNV", Class: "Reserved", Opcode: 5269, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Hit Object'", Quantifier: "", }, }, } OpHitObjectGetInstanceIdNV = &Opcode { Opname: "OpHitObjectGetInstanceIdNV", Class: "Reserved", Opcode: 5270, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Hit Object'", Quantifier: "", }, }, } OpHitObjectGetInstanceCustomIndexNV = &Opcode { Opname: "OpHitObjectGetInstanceCustomIndexNV", Class: "Reserved", Opcode: 5271, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Hit Object'", Quantifier: "", }, }, } OpHitObjectGetWorldRayDirectionNV = &Opcode { Opname: "OpHitObjectGetWorldRayDirectionNV", Class: "Reserved", Opcode: 5272, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Hit Object'", Quantifier: "", }, }, } OpHitObjectGetWorldRayOriginNV = &Opcode { Opname: "OpHitObjectGetWorldRayOriginNV", Class: "Reserved", Opcode: 5273, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Hit Object'", Quantifier: "", }, }, } OpHitObjectGetRayTMaxNV = &Opcode { Opname: "OpHitObjectGetRayTMaxNV", Class: "Reserved", Opcode: 5274, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Hit Object'", Quantifier: "", }, }, } OpHitObjectGetRayTMinNV = &Opcode { Opname: "OpHitObjectGetRayTMinNV", Class: "Reserved", Opcode: 5275, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Hit Object'", Quantifier: "", }, }, } OpHitObjectIsEmptyNV = &Opcode { Opname: "OpHitObjectIsEmptyNV", Class: "Reserved", Opcode: 5276, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Hit Object'", Quantifier: "", }, }, } OpHitObjectIsHitNV = &Opcode { Opname: "OpHitObjectIsHitNV", Class: "Reserved", Opcode: 5277, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Hit Object'", Quantifier: "", }, }, } OpHitObjectIsMissNV = &Opcode { Opname: "OpHitObjectIsMissNV", Class: "Reserved", Opcode: 5278, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Hit Object'", Quantifier: "", }, }, } OpReorderThreadWithHitObjectNV = &Opcode { Opname: "OpReorderThreadWithHitObjectNV", Class: "Reserved", Opcode: 5279, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Hit Object'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Hint'", Quantifier: "?", }, Operand { Kind: OperandKindIdRef, Name: "'Bits'", Quantifier: "?", }, }, } OpReorderThreadWithHintNV = &Opcode { Opname: "OpReorderThreadWithHintNV", Class: "Reserved", Opcode: 5280, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Hint'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Bits'", Quantifier: "", }, }, } OpTypeHitObjectNV = &Opcode { Opname: "OpTypeHitObjectNV", Class: "Type-Declaration", Opcode: 5281, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpImageSampleFootprintNV = &Opcode { Opname: "OpImageSampleFootprintNV", Class: "Image", Opcode: 5283, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Sampled Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Coordinate'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Granularity'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Coarse'", Quantifier: "", }, Operand { Kind: OperandKindImageOperands, Name: "", Quantifier: "?", }, }, } OpCooperativeMatrixConvertNV = &Opcode { Opname: "OpCooperativeMatrixConvertNV", Class: "Conversion", Opcode: 5293, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Matrix'", Quantifier: "", }, }, } OpEmitMeshTasksEXT = &Opcode { Opname: "OpEmitMeshTasksEXT", Class: "Reserved", Opcode: 5294, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Group Count X'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Group Count Y'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Group Count Z'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "?", }, }, } OpSetMeshOutputsEXT = &Opcode { Opname: "OpSetMeshOutputsEXT", Class: "Reserved", Opcode: 5295, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Vertex Count'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Primitive Count'", Quantifier: "", }, }, } OpGroupNonUniformPartitionNV = &Opcode { Opname: "OpGroupNonUniformPartitionNV", Class: "Non-Uniform", Opcode: 5296, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, }, } OpWritePackedPrimitiveIndices4x8NV = &Opcode { Opname: "OpWritePackedPrimitiveIndices4x8NV", Class: "Reserved", Opcode: 5299, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Index Offset'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packed Indices'", Quantifier: "", }, }, } OpFetchMicroTriangleVertexPositionNV = &Opcode { Opname: "OpFetchMicroTriangleVertexPositionNV", Class: "Reserved", Opcode: 5300, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Accel'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Instance Id'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Geometry Index'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Primitive Index'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Barycentric'", Quantifier: "", }, }, } OpFetchMicroTriangleVertexBarycentricNV = &Opcode { Opname: "OpFetchMicroTriangleVertexBarycentricNV", Class: "Reserved", Opcode: 5301, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Accel'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Instance Id'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Geometry Index'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Primitive Index'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Barycentric'", Quantifier: "", }, }, } OpReportIntersectionKHR = &Opcode { Opname: "OpReportIntersectionKHR", Class: "Reserved", Opcode: 5334, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Hit'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'HitKind'", Quantifier: "", }, }, } OpIgnoreIntersectionNV = &Opcode { Opname: "OpIgnoreIntersectionNV", Class: "Reserved", Opcode: 5335, Operands: []Operand { }, } OpTerminateRayNV = &Opcode { Opname: "OpTerminateRayNV", Class: "Reserved", Opcode: 5336, Operands: []Operand { }, } OpTraceNV = &Opcode { Opname: "OpTraceNV", Class: "Reserved", Opcode: 5337, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Accel'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Ray Flags'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Cull Mask'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'SBT Offset'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'SBT Stride'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Miss Index'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Ray Origin'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Ray Tmin'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Ray Direction'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Ray Tmax'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'PayloadId'", Quantifier: "", }, }, } OpTraceMotionNV = &Opcode { Opname: "OpTraceMotionNV", Class: "Reserved", Opcode: 5338, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Accel'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Ray Flags'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Cull Mask'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'SBT Offset'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'SBT Stride'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Miss Index'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Ray Origin'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Ray Tmin'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Ray Direction'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Ray Tmax'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Time'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'PayloadId'", Quantifier: "", }, }, } OpTraceRayMotionNV = &Opcode { Opname: "OpTraceRayMotionNV", Class: "Reserved", Opcode: 5339, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Accel'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Ray Flags'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Cull Mask'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'SBT Offset'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'SBT Stride'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Miss Index'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Ray Origin'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Ray Tmin'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Ray Direction'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Ray Tmax'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Time'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpRayQueryGetIntersectionTriangleVertexPositionsKHR = &Opcode { Opname: "OpRayQueryGetIntersectionTriangleVertexPositionsKHR", Class: "Reserved", Opcode: 5340, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'RayQuery'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Intersection'", Quantifier: "", }, }, } OpTypeAccelerationStructureKHR = &Opcode { Opname: "OpTypeAccelerationStructureKHR", Class: "Type-Declaration", Opcode: 5341, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpExecuteCallableNV = &Opcode { Opname: "OpExecuteCallableNV", Class: "Reserved", Opcode: 5344, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'SBT Index'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Callable DataId'", Quantifier: "", }, }, } OpTypeCooperativeMatrixNV = &Opcode { Opname: "OpTypeCooperativeMatrixNV", Class: "Type-Declaration", Opcode: 5358, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Component Type'", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Rows'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Columns'", Quantifier: "", }, }, } OpCooperativeMatrixLoadNV = &Opcode { Opname: "OpCooperativeMatrixLoadNV", Class: "Reserved", Opcode: 5359, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Stride'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Column Major'", Quantifier: "", }, Operand { Kind: OperandKindMemoryAccess, Name: "", Quantifier: "?", }, }, } OpCooperativeMatrixStoreNV = &Opcode { Opname: "OpCooperativeMatrixStoreNV", Class: "Reserved", Opcode: 5360, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Object'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Stride'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Column Major'", Quantifier: "", }, Operand { Kind: OperandKindMemoryAccess, Name: "", Quantifier: "?", }, }, } OpCooperativeMatrixMulAddNV = &Opcode { Opname: "OpCooperativeMatrixMulAddNV", Class: "Reserved", Opcode: 5361, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'B'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'C'", Quantifier: "", }, }, } OpCooperativeMatrixLengthNV = &Opcode { Opname: "OpCooperativeMatrixLengthNV", Class: "Reserved", Opcode: 5362, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Type'", Quantifier: "", }, }, } OpBeginInvocationInterlockEXT = &Opcode { Opname: "OpBeginInvocationInterlockEXT", Class: "Reserved", Opcode: 5364, Operands: []Operand { }, } OpEndInvocationInterlockEXT = &Opcode { Opname: "OpEndInvocationInterlockEXT", Class: "Reserved", Opcode: 5365, Operands: []Operand { }, } OpCooperativeMatrixReduceNV = &Opcode { Opname: "OpCooperativeMatrixReduceNV", Class: "Arithmetic", Opcode: 5366, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Matrix'", Quantifier: "", }, Operand { Kind: OperandKindCooperativeMatrixReduce, Name: "'Reduce'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'CombineFunc'", Quantifier: "", }, }, } OpCooperativeMatrixLoadTensorNV = &Opcode { Opname: "OpCooperativeMatrixLoadTensorNV", Class: "Memory", Opcode: 5367, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Object'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'TensorLayout'", Quantifier: "", }, Operand { Kind: OperandKindMemoryAccess, Name: "'Memory Operand'", Quantifier: "", }, Operand { Kind: OperandKindTensorAddressingOperands, Name: "'Tensor Addressing Operands'", Quantifier: "", }, }, } OpCooperativeMatrixStoreTensorNV = &Opcode { Opname: "OpCooperativeMatrixStoreTensorNV", Class: "Memory", Opcode: 5368, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Object'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'TensorLayout'", Quantifier: "", }, Operand { Kind: OperandKindMemoryAccess, Name: "'Memory Operand'", Quantifier: "", }, Operand { Kind: OperandKindTensorAddressingOperands, Name: "'Tensor Addressing Operands'", Quantifier: "", }, }, } OpCooperativeMatrixPerElementOpNV = &Opcode { Opname: "OpCooperativeMatrixPerElementOpNV", Class: "Function", Opcode: 5369, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Matrix'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Func'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operands'", Quantifier: "*", }, }, } OpTypeTensorLayoutNV = &Opcode { Opname: "OpTypeTensorLayoutNV", Class: "Type-Declaration", Opcode: 5370, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Dim'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'ClampMode'", Quantifier: "", }, }, } OpTypeTensorViewNV = &Opcode { Opname: "OpTypeTensorViewNV", Class: "Type-Declaration", Opcode: 5371, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Dim'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'HasDimensions'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'p'", Quantifier: "*", }, }, } OpCreateTensorLayoutNV = &Opcode { Opname: "OpCreateTensorLayoutNV", Class: "Reserved", Opcode: 5372, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpTensorLayoutSetDimensionNV = &Opcode { Opname: "OpTensorLayoutSetDimensionNV", Class: "Reserved", Opcode: 5373, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'TensorLayout'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Dim'", Quantifier: "*", }, }, } OpTensorLayoutSetStrideNV = &Opcode { Opname: "OpTensorLayoutSetStrideNV", Class: "Reserved", Opcode: 5374, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'TensorLayout'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Stride'", Quantifier: "*", }, }, } OpTensorLayoutSliceNV = &Opcode { Opname: "OpTensorLayoutSliceNV", Class: "Reserved", Opcode: 5375, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'TensorLayout'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operands'", Quantifier: "*", }, }, } OpTensorLayoutSetClampValueNV = &Opcode { Opname: "OpTensorLayoutSetClampValueNV", Class: "Reserved", Opcode: 5376, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'TensorLayout'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, }, } OpCreateTensorViewNV = &Opcode { Opname: "OpCreateTensorViewNV", Class: "Reserved", Opcode: 5377, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpTensorViewSetDimensionNV = &Opcode { Opname: "OpTensorViewSetDimensionNV", Class: "Reserved", Opcode: 5378, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'TensorView'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Dim'", Quantifier: "*", }, }, } OpTensorViewSetStrideNV = &Opcode { Opname: "OpTensorViewSetStrideNV", Class: "Reserved", Opcode: 5379, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'TensorView'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Stride'", Quantifier: "*", }, }, } OpDemoteToHelperInvocation = &Opcode { Opname: "OpDemoteToHelperInvocation", Class: "Control-Flow", Opcode: 5380, Operands: []Operand { }, } OpIsHelperInvocationEXT = &Opcode { Opname: "OpIsHelperInvocationEXT", Class: "Reserved", Opcode: 5381, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpTensorViewSetClipNV = &Opcode { Opname: "OpTensorViewSetClipNV", Class: "Reserved", Opcode: 5382, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'TensorView'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'ClipRowOffset'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'ClipRowSpan'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'ClipColOffset'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'ClipColSpan'", Quantifier: "", }, }, } OpTensorLayoutSetBlockSizeNV = &Opcode { Opname: "OpTensorLayoutSetBlockSizeNV", Class: "Reserved", Opcode: 5384, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'TensorLayout'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'BlockSize'", Quantifier: "*", }, }, } OpCooperativeMatrixTransposeNV = &Opcode { Opname: "OpCooperativeMatrixTransposeNV", Class: "Conversion", Opcode: 5390, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Matrix'", Quantifier: "", }, }, } OpConvertUToImageNV = &Opcode { Opname: "OpConvertUToImageNV", Class: "Reserved", Opcode: 5391, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand'", Quantifier: "", }, }, } OpConvertUToSamplerNV = &Opcode { Opname: "OpConvertUToSamplerNV", Class: "Reserved", Opcode: 5392, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand'", Quantifier: "", }, }, } OpConvertImageToUNV = &Opcode { Opname: "OpConvertImageToUNV", Class: "Reserved", Opcode: 5393, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand'", Quantifier: "", }, }, } OpConvertSamplerToUNV = &Opcode { Opname: "OpConvertSamplerToUNV", Class: "Reserved", Opcode: 5394, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand'", Quantifier: "", }, }, } OpConvertUToSampledImageNV = &Opcode { Opname: "OpConvertUToSampledImageNV", Class: "Reserved", Opcode: 5395, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand'", Quantifier: "", }, }, } OpConvertSampledImageToUNV = &Opcode { Opname: "OpConvertSampledImageToUNV", Class: "Reserved", Opcode: 5396, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand'", Quantifier: "", }, }, } OpSamplerImageAddressingModeNV = &Opcode { Opname: "OpSamplerImageAddressingModeNV", Class: "Reserved", Opcode: 5397, Operands: []Operand { Operand { Kind: OperandKindLiteralInteger, Name: "'Bit Width'", Quantifier: "", }, }, } OpRawAccessChainNV = &Opcode { Opname: "OpRawAccessChainNV", Class: "Memory", Opcode: 5398, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Base'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Byte stride'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Element index'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Byte offset'", Quantifier: "", }, Operand { Kind: OperandKindRawAccessChainOperands, Name: "", Quantifier: "?", }, }, } OpSubgroupShuffleINTEL = &Opcode { Opname: "OpSubgroupShuffleINTEL", Class: "Group", Opcode: 5571, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Data'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'InvocationId'", Quantifier: "", }, }, } OpSubgroupShuffleDownINTEL = &Opcode { Opname: "OpSubgroupShuffleDownINTEL", Class: "Group", Opcode: 5572, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Current'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Next'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Delta'", Quantifier: "", }, }, } OpSubgroupShuffleUpINTEL = &Opcode { Opname: "OpSubgroupShuffleUpINTEL", Class: "Group", Opcode: 5573, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Previous'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Current'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Delta'", Quantifier: "", }, }, } OpSubgroupShuffleXorINTEL = &Opcode { Opname: "OpSubgroupShuffleXorINTEL", Class: "Group", Opcode: 5574, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Data'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, }, } OpSubgroupBlockReadINTEL = &Opcode { Opname: "OpSubgroupBlockReadINTEL", Class: "Group", Opcode: 5575, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Ptr'", Quantifier: "", }, }, } OpSubgroupBlockWriteINTEL = &Opcode { Opname: "OpSubgroupBlockWriteINTEL", Class: "Group", Opcode: 5576, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Ptr'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Data'", Quantifier: "", }, }, } OpSubgroupImageBlockReadINTEL = &Opcode { Opname: "OpSubgroupImageBlockReadINTEL", Class: "Group", Opcode: 5577, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Coordinate'", Quantifier: "", }, }, } OpSubgroupImageBlockWriteINTEL = &Opcode { Opname: "OpSubgroupImageBlockWriteINTEL", Class: "Group", Opcode: 5578, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Coordinate'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Data'", Quantifier: "", }, }, } OpSubgroupImageMediaBlockReadINTEL = &Opcode { Opname: "OpSubgroupImageMediaBlockReadINTEL", Class: "Group", Opcode: 5580, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Coordinate'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Width'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Height'", Quantifier: "", }, }, } OpSubgroupImageMediaBlockWriteINTEL = &Opcode { Opname: "OpSubgroupImageMediaBlockWriteINTEL", Class: "Group", Opcode: 5581, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Coordinate'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Width'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Height'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Data'", Quantifier: "", }, }, } OpUCountLeadingZerosINTEL = &Opcode { Opname: "OpUCountLeadingZerosINTEL", Class: "Reserved", Opcode: 5585, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand'", Quantifier: "", }, }, } OpUCountTrailingZerosINTEL = &Opcode { Opname: "OpUCountTrailingZerosINTEL", Class: "Reserved", Opcode: 5586, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand'", Quantifier: "", }, }, } OpAbsISubINTEL = &Opcode { Opname: "OpAbsISubINTEL", Class: "Reserved", Opcode: 5587, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpAbsUSubINTEL = &Opcode { Opname: "OpAbsUSubINTEL", Class: "Reserved", Opcode: 5588, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpIAddSatINTEL = &Opcode { Opname: "OpIAddSatINTEL", Class: "Reserved", Opcode: 5589, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpUAddSatINTEL = &Opcode { Opname: "OpUAddSatINTEL", Class: "Reserved", Opcode: 5590, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpIAverageINTEL = &Opcode { Opname: "OpIAverageINTEL", Class: "Reserved", Opcode: 5591, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpUAverageINTEL = &Opcode { Opname: "OpUAverageINTEL", Class: "Reserved", Opcode: 5592, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpIAverageRoundedINTEL = &Opcode { Opname: "OpIAverageRoundedINTEL", Class: "Reserved", Opcode: 5593, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpUAverageRoundedINTEL = &Opcode { Opname: "OpUAverageRoundedINTEL", Class: "Reserved", Opcode: 5594, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpISubSatINTEL = &Opcode { Opname: "OpISubSatINTEL", Class: "Reserved", Opcode: 5595, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpUSubSatINTEL = &Opcode { Opname: "OpUSubSatINTEL", Class: "Reserved", Opcode: 5596, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpIMul32x16INTEL = &Opcode { Opname: "OpIMul32x16INTEL", Class: "Reserved", Opcode: 5597, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpUMul32x16INTEL = &Opcode { Opname: "OpUMul32x16INTEL", Class: "Reserved", Opcode: 5598, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 2'", Quantifier: "", }, }, } OpConstantFunctionPointerINTEL = &Opcode { Opname: "OpConstantFunctionPointerINTEL", Class: "@exclude", Opcode: 5600, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Function'", Quantifier: "", }, }, } OpFunctionPointerCallINTEL = &Opcode { Opname: "OpFunctionPointerCallINTEL", Class: "@exclude", Opcode: 5601, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Operand 1'", Quantifier: "*", }, }, } OpAsmTargetINTEL = &Opcode { Opname: "OpAsmTargetINTEL", Class: "@exclude", Opcode: 5609, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindLiteralString, Name: "'Asm target'", Quantifier: "", }, }, } OpAsmINTEL = &Opcode { Opname: "OpAsmINTEL", Class: "@exclude", Opcode: 5610, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Asm type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Target'", Quantifier: "", }, Operand { Kind: OperandKindLiteralString, Name: "'Asm instructions'", Quantifier: "", }, Operand { Kind: OperandKindLiteralString, Name: "'Constraints'", Quantifier: "", }, }, } OpAsmCallINTEL = &Opcode { Opname: "OpAsmCallINTEL", Class: "@exclude", Opcode: 5611, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Asm'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Argument 0'", Quantifier: "*", }, }, } OpAtomicFMinEXT = &Opcode { Opname: "OpAtomicFMinEXT", Class: "Atomic", Opcode: 5614, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Memory'", Quantifier: "", }, Operand { Kind: OperandKindIdMemorySemantics, Name: "'Semantics'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, }, } OpAtomicFMaxEXT = &Opcode { Opname: "OpAtomicFMaxEXT", Class: "Atomic", Opcode: 5615, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Memory'", Quantifier: "", }, Operand { Kind: OperandKindIdMemorySemantics, Name: "'Semantics'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, }, } OpAssumeTrueKHR = &Opcode { Opname: "OpAssumeTrueKHR", Class: "Miscellaneous", Opcode: 5630, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Condition'", Quantifier: "", }, }, } OpExpectKHR = &Opcode { Opname: "OpExpectKHR", Class: "Miscellaneous", Opcode: 5631, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'ExpectedValue'", Quantifier: "", }, }, } OpDecorateString = &Opcode { Opname: "OpDecorateString", Class: "Annotation", Opcode: 5632, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Target'", Quantifier: "", }, Operand { Kind: OperandKindDecoration, Name: "", Quantifier: "", }, }, } OpMemberDecorateString = &Opcode { Opname: "OpMemberDecorateString", Class: "Annotation", Opcode: 5633, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Struct Type'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Member'", Quantifier: "", }, Operand { Kind: OperandKindDecoration, Name: "", Quantifier: "", }, }, } OpVmeImageINTEL = &Opcode { Opname: "OpVmeImageINTEL", Class: "@exclude", Opcode: 5699, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Image Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Sampler'", Quantifier: "", }, }, } OpTypeVmeImageINTEL = &Opcode { Opname: "OpTypeVmeImageINTEL", Class: "@exclude", Opcode: 5700, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Image Type'", Quantifier: "", }, }, } OpTypeAvcImePayloadINTEL = &Opcode { Opname: "OpTypeAvcImePayloadINTEL", Class: "@exclude", Opcode: 5701, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpTypeAvcRefPayloadINTEL = &Opcode { Opname: "OpTypeAvcRefPayloadINTEL", Class: "@exclude", Opcode: 5702, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpTypeAvcSicPayloadINTEL = &Opcode { Opname: "OpTypeAvcSicPayloadINTEL", Class: "@exclude", Opcode: 5703, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpTypeAvcMcePayloadINTEL = &Opcode { Opname: "OpTypeAvcMcePayloadINTEL", Class: "@exclude", Opcode: 5704, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpTypeAvcMceResultINTEL = &Opcode { Opname: "OpTypeAvcMceResultINTEL", Class: "@exclude", Opcode: 5705, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpTypeAvcImeResultINTEL = &Opcode { Opname: "OpTypeAvcImeResultINTEL", Class: "@exclude", Opcode: 5706, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpTypeAvcImeResultSingleReferenceStreamoutINTEL = &Opcode { Opname: "OpTypeAvcImeResultSingleReferenceStreamoutINTEL", Class: "@exclude", Opcode: 5707, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpTypeAvcImeResultDualReferenceStreamoutINTEL = &Opcode { Opname: "OpTypeAvcImeResultDualReferenceStreamoutINTEL", Class: "@exclude", Opcode: 5708, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpTypeAvcImeSingleReferenceStreaminINTEL = &Opcode { Opname: "OpTypeAvcImeSingleReferenceStreaminINTEL", Class: "@exclude", Opcode: 5709, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpTypeAvcImeDualReferenceStreaminINTEL = &Opcode { Opname: "OpTypeAvcImeDualReferenceStreaminINTEL", Class: "@exclude", Opcode: 5710, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpTypeAvcRefResultINTEL = &Opcode { Opname: "OpTypeAvcRefResultINTEL", Class: "@exclude", Opcode: 5711, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpTypeAvcSicResultINTEL = &Opcode { Opname: "OpTypeAvcSicResultINTEL", Class: "@exclude", Opcode: 5712, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL = &Opcode { Opname: "OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL", Class: "@exclude", Opcode: 5713, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Slice Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Qp'", Quantifier: "", }, }, } OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL = &Opcode { Opname: "OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL", Class: "@exclude", Opcode: 5714, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Reference Base Penalty'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL = &Opcode { Opname: "OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL", Class: "@exclude", Opcode: 5715, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Slice Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Qp'", Quantifier: "", }, }, } OpSubgroupAvcMceSetInterShapePenaltyINTEL = &Opcode { Opname: "OpSubgroupAvcMceSetInterShapePenaltyINTEL", Class: "@exclude", Opcode: 5716, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packed Shape Penalty'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL = &Opcode { Opname: "OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL", Class: "@exclude", Opcode: 5717, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Slice Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Qp'", Quantifier: "", }, }, } OpSubgroupAvcMceSetInterDirectionPenaltyINTEL = &Opcode { Opname: "OpSubgroupAvcMceSetInterDirectionPenaltyINTEL", Class: "@exclude", Opcode: 5718, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Direction Cost'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL = &Opcode { Opname: "OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL", Class: "@exclude", Opcode: 5719, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Slice Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Qp'", Quantifier: "", }, }, } OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL = &Opcode { Opname: "OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL", Class: "@exclude", Opcode: 5720, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Slice Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Qp'", Quantifier: "", }, }, } OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL = &Opcode { Opname: "OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL", Class: "@exclude", Opcode: 5721, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL = &Opcode { Opname: "OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL", Class: "@exclude", Opcode: 5722, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL = &Opcode { Opname: "OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL", Class: "@exclude", Opcode: 5723, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL = &Opcode { Opname: "OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL", Class: "@exclude", Opcode: 5724, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packed Cost Center Delta'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packed Cost Table'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Cost Precision'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL = &Opcode { Opname: "OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL", Class: "@exclude", Opcode: 5725, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Slice Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Qp'", Quantifier: "", }, }, } OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL = &Opcode { Opname: "OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL", Class: "@exclude", Opcode: 5726, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL = &Opcode { Opname: "OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL", Class: "@exclude", Opcode: 5727, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpSubgroupAvcMceSetAcOnlyHaarINTEL = &Opcode { Opname: "OpSubgroupAvcMceSetAcOnlyHaarINTEL", Class: "@exclude", Opcode: 5728, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL = &Opcode { Opname: "OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL", Class: "@exclude", Opcode: 5729, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Source Field Polarity'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL = &Opcode { Opname: "OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL", Class: "@exclude", Opcode: 5730, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Reference Field Polarity'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL = &Opcode { Opname: "OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL", Class: "@exclude", Opcode: 5731, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Forward Reference Field Polarity'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Backward Reference Field Polarity'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcMceConvertToImePayloadINTEL = &Opcode { Opname: "OpSubgroupAvcMceConvertToImePayloadINTEL", Class: "@exclude", Opcode: 5732, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcMceConvertToImeResultINTEL = &Opcode { Opname: "OpSubgroupAvcMceConvertToImeResultINTEL", Class: "@exclude", Opcode: 5733, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcMceConvertToRefPayloadINTEL = &Opcode { Opname: "OpSubgroupAvcMceConvertToRefPayloadINTEL", Class: "@exclude", Opcode: 5734, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcMceConvertToRefResultINTEL = &Opcode { Opname: "OpSubgroupAvcMceConvertToRefResultINTEL", Class: "@exclude", Opcode: 5735, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcMceConvertToSicPayloadINTEL = &Opcode { Opname: "OpSubgroupAvcMceConvertToSicPayloadINTEL", Class: "@exclude", Opcode: 5736, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcMceConvertToSicResultINTEL = &Opcode { Opname: "OpSubgroupAvcMceConvertToSicResultINTEL", Class: "@exclude", Opcode: 5737, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcMceGetMotionVectorsINTEL = &Opcode { Opname: "OpSubgroupAvcMceGetMotionVectorsINTEL", Class: "@exclude", Opcode: 5738, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcMceGetInterDistortionsINTEL = &Opcode { Opname: "OpSubgroupAvcMceGetInterDistortionsINTEL", Class: "@exclude", Opcode: 5739, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcMceGetBestInterDistortionsINTEL = &Opcode { Opname: "OpSubgroupAvcMceGetBestInterDistortionsINTEL", Class: "@exclude", Opcode: 5740, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcMceGetInterMajorShapeINTEL = &Opcode { Opname: "OpSubgroupAvcMceGetInterMajorShapeINTEL", Class: "@exclude", Opcode: 5741, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcMceGetInterMinorShapeINTEL = &Opcode { Opname: "OpSubgroupAvcMceGetInterMinorShapeINTEL", Class: "@exclude", Opcode: 5742, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcMceGetInterDirectionsINTEL = &Opcode { Opname: "OpSubgroupAvcMceGetInterDirectionsINTEL", Class: "@exclude", Opcode: 5743, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcMceGetInterMotionVectorCountINTEL = &Opcode { Opname: "OpSubgroupAvcMceGetInterMotionVectorCountINTEL", Class: "@exclude", Opcode: 5744, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcMceGetInterReferenceIdsINTEL = &Opcode { Opname: "OpSubgroupAvcMceGetInterReferenceIdsINTEL", Class: "@exclude", Opcode: 5745, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL = &Opcode { Opname: "OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL", Class: "@exclude", Opcode: 5746, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packed Reference Ids'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packed Reference Parameter Field Polarities'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcImeInitializeINTEL = &Opcode { Opname: "OpSubgroupAvcImeInitializeINTEL", Class: "@exclude", Opcode: 5747, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Src Coord'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Partition Mask'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'SAD Adjustment'", Quantifier: "", }, }, } OpSubgroupAvcImeSetSingleReferenceINTEL = &Opcode { Opname: "OpSubgroupAvcImeSetSingleReferenceINTEL", Class: "@exclude", Opcode: 5748, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Ref Offset'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Search Window Config'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcImeSetDualReferenceINTEL = &Opcode { Opname: "OpSubgroupAvcImeSetDualReferenceINTEL", Class: "@exclude", Opcode: 5749, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Fwd Ref Offset'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Bwd Ref Offset'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'id> Search Window Config'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcImeRefWindowSizeINTEL = &Opcode { Opname: "OpSubgroupAvcImeRefWindowSizeINTEL", Class: "@exclude", Opcode: 5750, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Search Window Config'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Dual Ref'", Quantifier: "", }, }, } OpSubgroupAvcImeAdjustRefOffsetINTEL = &Opcode { Opname: "OpSubgroupAvcImeAdjustRefOffsetINTEL", Class: "@exclude", Opcode: 5751, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Ref Offset'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Src Coord'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Ref Window Size'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Image Size'", Quantifier: "", }, }, } OpSubgroupAvcImeConvertToMcePayloadINTEL = &Opcode { Opname: "OpSubgroupAvcImeConvertToMcePayloadINTEL", Class: "@exclude", Opcode: 5752, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcImeSetMaxMotionVectorCountINTEL = &Opcode { Opname: "OpSubgroupAvcImeSetMaxMotionVectorCountINTEL", Class: "@exclude", Opcode: 5753, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Max Motion Vector Count'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL = &Opcode { Opname: "OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL", Class: "@exclude", Opcode: 5754, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL = &Opcode { Opname: "OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL", Class: "@exclude", Opcode: 5755, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Threshold'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcImeSetWeightedSadINTEL = &Opcode { Opname: "OpSubgroupAvcImeSetWeightedSadINTEL", Class: "@exclude", Opcode: 5756, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packed Sad Weights'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL = &Opcode { Opname: "OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL", Class: "@exclude", Opcode: 5757, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Src Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Ref Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcImeEvaluateWithDualReferenceINTEL = &Opcode { Opname: "OpSubgroupAvcImeEvaluateWithDualReferenceINTEL", Class: "@exclude", Opcode: 5758, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Src Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Fwd Ref Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Bwd Ref Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL = &Opcode { Opname: "OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL", Class: "@exclude", Opcode: 5759, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Src Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Ref Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Streamin Components'", Quantifier: "", }, }, } OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL = &Opcode { Opname: "OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL", Class: "@exclude", Opcode: 5760, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Src Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Fwd Ref Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Bwd Ref Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Streamin Components'", Quantifier: "", }, }, } OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL = &Opcode { Opname: "OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL", Class: "@exclude", Opcode: 5761, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Src Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Ref Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL = &Opcode { Opname: "OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL", Class: "@exclude", Opcode: 5762, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Src Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Fwd Ref Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Bwd Ref Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL = &Opcode { Opname: "OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL", Class: "@exclude", Opcode: 5763, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Src Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Ref Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Streamin Components'", Quantifier: "", }, }, } OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL = &Opcode { Opname: "OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL", Class: "@exclude", Opcode: 5764, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Src Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Fwd Ref Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Bwd Ref Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Streamin Components'", Quantifier: "", }, }, } OpSubgroupAvcImeConvertToMceResultINTEL = &Opcode { Opname: "OpSubgroupAvcImeConvertToMceResultINTEL", Class: "@exclude", Opcode: 5765, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcImeGetSingleReferenceStreaminINTEL = &Opcode { Opname: "OpSubgroupAvcImeGetSingleReferenceStreaminINTEL", Class: "@exclude", Opcode: 5766, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcImeGetDualReferenceStreaminINTEL = &Opcode { Opname: "OpSubgroupAvcImeGetDualReferenceStreaminINTEL", Class: "@exclude", Opcode: 5767, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL = &Opcode { Opname: "OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL", Class: "@exclude", Opcode: 5768, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcImeStripDualReferenceStreamoutINTEL = &Opcode { Opname: "OpSubgroupAvcImeStripDualReferenceStreamoutINTEL", Class: "@exclude", Opcode: 5769, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL = &Opcode { Opname: "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL", Class: "@exclude", Opcode: 5770, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Major Shape'", Quantifier: "", }, }, } OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL = &Opcode { Opname: "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL", Class: "@exclude", Opcode: 5771, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Major Shape'", Quantifier: "", }, }, } OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL = &Opcode { Opname: "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL", Class: "@exclude", Opcode: 5772, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Major Shape'", Quantifier: "", }, }, } OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL = &Opcode { Opname: "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL", Class: "@exclude", Opcode: 5773, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Major Shape'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Direction'", Quantifier: "", }, }, } OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL = &Opcode { Opname: "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL", Class: "@exclude", Opcode: 5774, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Major Shape'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Direction'", Quantifier: "", }, }, } OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL = &Opcode { Opname: "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL", Class: "@exclude", Opcode: 5775, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Major Shape'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Direction'", Quantifier: "", }, }, } OpSubgroupAvcImeGetBorderReachedINTEL = &Opcode { Opname: "OpSubgroupAvcImeGetBorderReachedINTEL", Class: "@exclude", Opcode: 5776, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Image Select'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL = &Opcode { Opname: "OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL", Class: "@exclude", Opcode: 5777, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL = &Opcode { Opname: "OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL", Class: "@exclude", Opcode: 5778, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL = &Opcode { Opname: "OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL", Class: "@exclude", Opcode: 5779, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL = &Opcode { Opname: "OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL", Class: "@exclude", Opcode: 5780, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcFmeInitializeINTEL = &Opcode { Opname: "OpSubgroupAvcFmeInitializeINTEL", Class: "@exclude", Opcode: 5781, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Src Coord'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Motion Vectors'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Major Shapes'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Minor Shapes'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Direction'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pixel Resolution'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Sad Adjustment'", Quantifier: "", }, }, } OpSubgroupAvcBmeInitializeINTEL = &Opcode { Opname: "OpSubgroupAvcBmeInitializeINTEL", Class: "@exclude", Opcode: 5782, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Src Coord'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Motion Vectors'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Major Shapes'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Minor Shapes'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Direction'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pixel Resolution'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Bidirectional Weight'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Sad Adjustment'", Quantifier: "", }, }, } OpSubgroupAvcRefConvertToMcePayloadINTEL = &Opcode { Opname: "OpSubgroupAvcRefConvertToMcePayloadINTEL", Class: "@exclude", Opcode: 5783, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcRefSetBidirectionalMixDisableINTEL = &Opcode { Opname: "OpSubgroupAvcRefSetBidirectionalMixDisableINTEL", Class: "@exclude", Opcode: 5784, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcRefSetBilinearFilterEnableINTEL = &Opcode { Opname: "OpSubgroupAvcRefSetBilinearFilterEnableINTEL", Class: "@exclude", Opcode: 5785, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL = &Opcode { Opname: "OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL", Class: "@exclude", Opcode: 5786, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Src Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Ref Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcRefEvaluateWithDualReferenceINTEL = &Opcode { Opname: "OpSubgroupAvcRefEvaluateWithDualReferenceINTEL", Class: "@exclude", Opcode: 5787, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Src Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Fwd Ref Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Bwd Ref Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL = &Opcode { Opname: "OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL", Class: "@exclude", Opcode: 5788, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Src Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packed Reference Ids'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL = &Opcode { Opname: "OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL", Class: "@exclude", Opcode: 5789, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Src Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packed Reference Ids'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packed Reference Field Polarities'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcRefConvertToMceResultINTEL = &Opcode { Opname: "OpSubgroupAvcRefConvertToMceResultINTEL", Class: "@exclude", Opcode: 5790, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcSicInitializeINTEL = &Opcode { Opname: "OpSubgroupAvcSicInitializeINTEL", Class: "@exclude", Opcode: 5791, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Src Coord'", Quantifier: "", }, }, } OpSubgroupAvcSicConfigureSkcINTEL = &Opcode { Opname: "OpSubgroupAvcSicConfigureSkcINTEL", Class: "@exclude", Opcode: 5792, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Skip Block Partition Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Skip Motion Vector Mask'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Motion Vectors'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Bidirectional Weight'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Sad Adjustment'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcSicConfigureIpeLumaINTEL = &Opcode { Opname: "OpSubgroupAvcSicConfigureIpeLumaINTEL", Class: "@exclude", Opcode: 5793, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Luma Intra Partition Mask'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Intra Neighbour Availabilty'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Left Edge Luma Pixels'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Upper Left Corner Luma Pixel'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Upper Edge Luma Pixels'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Upper Right Edge Luma Pixels'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Sad Adjustment'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcSicConfigureIpeLumaChromaINTEL = &Opcode { Opname: "OpSubgroupAvcSicConfigureIpeLumaChromaINTEL", Class: "@exclude", Opcode: 5794, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Luma Intra Partition Mask'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Intra Neighbour Availabilty'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Left Edge Luma Pixels'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Upper Left Corner Luma Pixel'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Upper Edge Luma Pixels'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Upper Right Edge Luma Pixels'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Left Edge Chroma Pixels'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Upper Left Corner Chroma Pixel'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Upper Edge Chroma Pixels'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Sad Adjustment'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcSicGetMotionVectorMaskINTEL = &Opcode { Opname: "OpSubgroupAvcSicGetMotionVectorMaskINTEL", Class: "@exclude", Opcode: 5795, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Skip Block Partition Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Direction'", Quantifier: "", }, }, } OpSubgroupAvcSicConvertToMcePayloadINTEL = &Opcode { Opname: "OpSubgroupAvcSicConvertToMcePayloadINTEL", Class: "@exclude", Opcode: 5796, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL = &Opcode { Opname: "OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL", Class: "@exclude", Opcode: 5797, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packed Shape Penalty'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL = &Opcode { Opname: "OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL", Class: "@exclude", Opcode: 5798, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Luma Mode Penalty'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Luma Packed Neighbor Modes'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Luma Packed Non Dc Penalty'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL = &Opcode { Opname: "OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL", Class: "@exclude", Opcode: 5799, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Chroma Mode Base Penalty'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcSicSetBilinearFilterEnableINTEL = &Opcode { Opname: "OpSubgroupAvcSicSetBilinearFilterEnableINTEL", Class: "@exclude", Opcode: 5800, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL = &Opcode { Opname: "OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL", Class: "@exclude", Opcode: 5801, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packed Sad Coefficients'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL = &Opcode { Opname: "OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL", Class: "@exclude", Opcode: 5802, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Block Based Skip Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcSicEvaluateIpeINTEL = &Opcode { Opname: "OpSubgroupAvcSicEvaluateIpeINTEL", Class: "@exclude", Opcode: 5803, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Src Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL = &Opcode { Opname: "OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL", Class: "@exclude", Opcode: 5804, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Src Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Ref Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcSicEvaluateWithDualReferenceINTEL = &Opcode { Opname: "OpSubgroupAvcSicEvaluateWithDualReferenceINTEL", Class: "@exclude", Opcode: 5805, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Src Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Fwd Ref Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Bwd Ref Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL = &Opcode { Opname: "OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL", Class: "@exclude", Opcode: 5806, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Src Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packed Reference Ids'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL = &Opcode { Opname: "OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL", Class: "@exclude", Opcode: 5807, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Src Image'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packed Reference Ids'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packed Reference Field Polarities'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcSicConvertToMceResultINTEL = &Opcode { Opname: "OpSubgroupAvcSicConvertToMceResultINTEL", Class: "@exclude", Opcode: 5808, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcSicGetIpeLumaShapeINTEL = &Opcode { Opname: "OpSubgroupAvcSicGetIpeLumaShapeINTEL", Class: "@exclude", Opcode: 5809, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL = &Opcode { Opname: "OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL", Class: "@exclude", Opcode: 5810, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL = &Opcode { Opname: "OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL", Class: "@exclude", Opcode: 5811, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcSicGetPackedIpeLumaModesINTEL = &Opcode { Opname: "OpSubgroupAvcSicGetPackedIpeLumaModesINTEL", Class: "@exclude", Opcode: 5812, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcSicGetIpeChromaModeINTEL = &Opcode { Opname: "OpSubgroupAvcSicGetIpeChromaModeINTEL", Class: "@exclude", Opcode: 5813, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL = &Opcode { Opname: "OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL", Class: "@exclude", Opcode: 5814, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL = &Opcode { Opname: "OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL", Class: "@exclude", Opcode: 5815, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpSubgroupAvcSicGetInterRawSadsINTEL = &Opcode { Opname: "OpSubgroupAvcSicGetInterRawSadsINTEL", Class: "@exclude", Opcode: 5816, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Payload'", Quantifier: "", }, }, } OpVariableLengthArrayINTEL = &Opcode { Opname: "OpVariableLengthArrayINTEL", Class: "@exclude", Opcode: 5818, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Lenght'", Quantifier: "", }, }, } OpSaveMemoryINTEL = &Opcode { Opname: "OpSaveMemoryINTEL", Class: "@exclude", Opcode: 5819, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, }, } OpRestoreMemoryINTEL = &Opcode { Opname: "OpRestoreMemoryINTEL", Class: "@exclude", Opcode: 5820, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Ptr'", Quantifier: "", }, }, } OpArbitraryFloatSinCosPiINTEL = &Opcode { Opname: "OpArbitraryFloatSinCosPiINTEL", Class: "@exclude", Opcode: 5840, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Mout'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'FromSign'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'EnableSubnormals'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingMode'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingAccuracy'", Quantifier: "", }, }, } OpArbitraryFloatCastINTEL = &Opcode { Opname: "OpArbitraryFloatCastINTEL", Class: "@exclude", Opcode: 5841, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Mout'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'EnableSubnormals'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingMode'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingAccuracy'", Quantifier: "", }, }, } OpArbitraryFloatCastFromIntINTEL = &Opcode { Opname: "OpArbitraryFloatCastFromIntINTEL", Class: "@exclude", Opcode: 5842, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Mout'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'FromSign'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'EnableSubnormals'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingMode'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingAccuracy'", Quantifier: "", }, }, } OpArbitraryFloatCastToIntINTEL = &Opcode { Opname: "OpArbitraryFloatCastToIntINTEL", Class: "@exclude", Opcode: 5843, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'EnableSubnormals'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingMode'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingAccuracy'", Quantifier: "", }, }, } OpArbitraryFloatAddINTEL = &Opcode { Opname: "OpArbitraryFloatAddINTEL", Class: "@exclude", Opcode: 5846, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'B'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M2'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Mout'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'EnableSubnormals'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingMode'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingAccuracy'", Quantifier: "", }, }, } OpArbitraryFloatSubINTEL = &Opcode { Opname: "OpArbitraryFloatSubINTEL", Class: "@exclude", Opcode: 5847, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'B'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M2'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Mout'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'EnableSubnormals'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingMode'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingAccuracy'", Quantifier: "", }, }, } OpArbitraryFloatMulINTEL = &Opcode { Opname: "OpArbitraryFloatMulINTEL", Class: "@exclude", Opcode: 5848, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'B'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M2'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Mout'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'EnableSubnormals'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingMode'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingAccuracy'", Quantifier: "", }, }, } OpArbitraryFloatDivINTEL = &Opcode { Opname: "OpArbitraryFloatDivINTEL", Class: "@exclude", Opcode: 5849, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'B'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M2'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Mout'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'EnableSubnormals'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingMode'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingAccuracy'", Quantifier: "", }, }, } OpArbitraryFloatGTINTEL = &Opcode { Opname: "OpArbitraryFloatGTINTEL", Class: "@exclude", Opcode: 5850, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'B'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M2'", Quantifier: "", }, }, } OpArbitraryFloatGEINTEL = &Opcode { Opname: "OpArbitraryFloatGEINTEL", Class: "@exclude", Opcode: 5851, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'B'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M2'", Quantifier: "", }, }, } OpArbitraryFloatLTINTEL = &Opcode { Opname: "OpArbitraryFloatLTINTEL", Class: "@exclude", Opcode: 5852, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'B'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M2'", Quantifier: "", }, }, } OpArbitraryFloatLEINTEL = &Opcode { Opname: "OpArbitraryFloatLEINTEL", Class: "@exclude", Opcode: 5853, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'B'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M2'", Quantifier: "", }, }, } OpArbitraryFloatEQINTEL = &Opcode { Opname: "OpArbitraryFloatEQINTEL", Class: "@exclude", Opcode: 5854, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'B'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M2'", Quantifier: "", }, }, } OpArbitraryFloatRecipINTEL = &Opcode { Opname: "OpArbitraryFloatRecipINTEL", Class: "@exclude", Opcode: 5855, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Mout'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'EnableSubnormals'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingMode'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingAccuracy'", Quantifier: "", }, }, } OpArbitraryFloatRSqrtINTEL = &Opcode { Opname: "OpArbitraryFloatRSqrtINTEL", Class: "@exclude", Opcode: 5856, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Mout'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'EnableSubnormals'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingMode'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingAccuracy'", Quantifier: "", }, }, } OpArbitraryFloatCbrtINTEL = &Opcode { Opname: "OpArbitraryFloatCbrtINTEL", Class: "@exclude", Opcode: 5857, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Mout'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'EnableSubnormals'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingMode'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingAccuracy'", Quantifier: "", }, }, } OpArbitraryFloatHypotINTEL = &Opcode { Opname: "OpArbitraryFloatHypotINTEL", Class: "@exclude", Opcode: 5858, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'B'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M2'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Mout'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'EnableSubnormals'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingMode'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingAccuracy'", Quantifier: "", }, }, } OpArbitraryFloatSqrtINTEL = &Opcode { Opname: "OpArbitraryFloatSqrtINTEL", Class: "@exclude", Opcode: 5859, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Mout'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'EnableSubnormals'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingMode'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingAccuracy'", Quantifier: "", }, }, } OpArbitraryFloatLogINTEL = &Opcode { Opname: "OpArbitraryFloatLogINTEL", Class: "@exclude", Opcode: 5860, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Mout'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'EnableSubnormals'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingMode'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingAccuracy'", Quantifier: "", }, }, } OpArbitraryFloatLog2INTEL = &Opcode { Opname: "OpArbitraryFloatLog2INTEL", Class: "@exclude", Opcode: 5861, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Mout'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'EnableSubnormals'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingMode'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingAccuracy'", Quantifier: "", }, }, } OpArbitraryFloatLog10INTEL = &Opcode { Opname: "OpArbitraryFloatLog10INTEL", Class: "@exclude", Opcode: 5862, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Mout'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'EnableSubnormals'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingMode'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingAccuracy'", Quantifier: "", }, }, } OpArbitraryFloatLog1pINTEL = &Opcode { Opname: "OpArbitraryFloatLog1pINTEL", Class: "@exclude", Opcode: 5863, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Mout'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'EnableSubnormals'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingMode'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingAccuracy'", Quantifier: "", }, }, } OpArbitraryFloatExpINTEL = &Opcode { Opname: "OpArbitraryFloatExpINTEL", Class: "@exclude", Opcode: 5864, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Mout'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'EnableSubnormals'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingMode'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingAccuracy'", Quantifier: "", }, }, } OpArbitraryFloatExp2INTEL = &Opcode { Opname: "OpArbitraryFloatExp2INTEL", Class: "@exclude", Opcode: 5865, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Mout'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'EnableSubnormals'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingMode'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingAccuracy'", Quantifier: "", }, }, } OpArbitraryFloatExp10INTEL = &Opcode { Opname: "OpArbitraryFloatExp10INTEL", Class: "@exclude", Opcode: 5866, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Mout'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'EnableSubnormals'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingMode'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingAccuracy'", Quantifier: "", }, }, } OpArbitraryFloatExpm1INTEL = &Opcode { Opname: "OpArbitraryFloatExpm1INTEL", Class: "@exclude", Opcode: 5867, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Mout'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'EnableSubnormals'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingMode'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingAccuracy'", Quantifier: "", }, }, } OpArbitraryFloatSinINTEL = &Opcode { Opname: "OpArbitraryFloatSinINTEL", Class: "@exclude", Opcode: 5868, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Mout'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'EnableSubnormals'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingMode'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingAccuracy'", Quantifier: "", }, }, } OpArbitraryFloatCosINTEL = &Opcode { Opname: "OpArbitraryFloatCosINTEL", Class: "@exclude", Opcode: 5869, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Mout'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'EnableSubnormals'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingMode'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingAccuracy'", Quantifier: "", }, }, } OpArbitraryFloatSinCosINTEL = &Opcode { Opname: "OpArbitraryFloatSinCosINTEL", Class: "@exclude", Opcode: 5870, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Mout'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'EnableSubnormals'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingMode'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingAccuracy'", Quantifier: "", }, }, } OpArbitraryFloatSinPiINTEL = &Opcode { Opname: "OpArbitraryFloatSinPiINTEL", Class: "@exclude", Opcode: 5871, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Mout'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'EnableSubnormals'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingMode'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingAccuracy'", Quantifier: "", }, }, } OpArbitraryFloatCosPiINTEL = &Opcode { Opname: "OpArbitraryFloatCosPiINTEL", Class: "@exclude", Opcode: 5872, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Mout'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'EnableSubnormals'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingMode'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingAccuracy'", Quantifier: "", }, }, } OpArbitraryFloatASinINTEL = &Opcode { Opname: "OpArbitraryFloatASinINTEL", Class: "@exclude", Opcode: 5873, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Mout'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'EnableSubnormals'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingMode'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingAccuracy'", Quantifier: "", }, }, } OpArbitraryFloatASinPiINTEL = &Opcode { Opname: "OpArbitraryFloatASinPiINTEL", Class: "@exclude", Opcode: 5874, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Mout'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'EnableSubnormals'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingMode'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingAccuracy'", Quantifier: "", }, }, } OpArbitraryFloatACosINTEL = &Opcode { Opname: "OpArbitraryFloatACosINTEL", Class: "@exclude", Opcode: 5875, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Mout'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'EnableSubnormals'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingMode'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingAccuracy'", Quantifier: "", }, }, } OpArbitraryFloatACosPiINTEL = &Opcode { Opname: "OpArbitraryFloatACosPiINTEL", Class: "@exclude", Opcode: 5876, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Mout'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'EnableSubnormals'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingMode'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingAccuracy'", Quantifier: "", }, }, } OpArbitraryFloatATanINTEL = &Opcode { Opname: "OpArbitraryFloatATanINTEL", Class: "@exclude", Opcode: 5877, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Mout'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'EnableSubnormals'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingMode'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingAccuracy'", Quantifier: "", }, }, } OpArbitraryFloatATanPiINTEL = &Opcode { Opname: "OpArbitraryFloatATanPiINTEL", Class: "@exclude", Opcode: 5878, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Mout'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'EnableSubnormals'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingMode'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingAccuracy'", Quantifier: "", }, }, } OpArbitraryFloatATan2INTEL = &Opcode { Opname: "OpArbitraryFloatATan2INTEL", Class: "@exclude", Opcode: 5879, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'B'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M2'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Mout'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'EnableSubnormals'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingMode'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingAccuracy'", Quantifier: "", }, }, } OpArbitraryFloatPowINTEL = &Opcode { Opname: "OpArbitraryFloatPowINTEL", Class: "@exclude", Opcode: 5880, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'B'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M2'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Mout'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'EnableSubnormals'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingMode'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingAccuracy'", Quantifier: "", }, }, } OpArbitraryFloatPowRINTEL = &Opcode { Opname: "OpArbitraryFloatPowRINTEL", Class: "@exclude", Opcode: 5881, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'B'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M2'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Mout'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'EnableSubnormals'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingMode'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingAccuracy'", Quantifier: "", }, }, } OpArbitraryFloatPowNINTEL = &Opcode { Opname: "OpArbitraryFloatPowNINTEL", Class: "@exclude", Opcode: 5882, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'A'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'M1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'B'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Mout'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'EnableSubnormals'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingMode'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'RoundingAccuracy'", Quantifier: "", }, }, } OpLoopControlINTEL = &Opcode { Opname: "OpLoopControlINTEL", Class: "Reserved", Opcode: 5887, Operands: []Operand { Operand { Kind: OperandKindLiteralInteger, Name: "'Loop Control Parameters'", Quantifier: "*", }, }, } OpAliasDomainDeclINTEL = &Opcode { Opname: "OpAliasDomainDeclINTEL", Class: "@exclude", Opcode: 5911, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Name'", Quantifier: "?", }, }, } OpAliasScopeDeclINTEL = &Opcode { Opname: "OpAliasScopeDeclINTEL", Class: "@exclude", Opcode: 5912, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Alias Domain'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Name'", Quantifier: "?", }, }, } OpAliasScopeListDeclINTEL = &Opcode { Opname: "OpAliasScopeListDeclINTEL", Class: "@exclude", Opcode: 5913, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'AliasScope1, AliasScope2, ...'", Quantifier: "*", }, }, } OpFixedSqrtINTEL = &Opcode { Opname: "OpFixedSqrtINTEL", Class: "@exclude", Opcode: 5923, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Input Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Input'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'S'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'I'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'rI'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Q'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'O'", Quantifier: "", }, }, } OpFixedRecipINTEL = &Opcode { Opname: "OpFixedRecipINTEL", Class: "@exclude", Opcode: 5924, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Input Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Input'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'S'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'I'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'rI'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Q'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'O'", Quantifier: "", }, }, } OpFixedRsqrtINTEL = &Opcode { Opname: "OpFixedRsqrtINTEL", Class: "@exclude", Opcode: 5925, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Input Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Input'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'S'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'I'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'rI'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Q'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'O'", Quantifier: "", }, }, } OpFixedSinINTEL = &Opcode { Opname: "OpFixedSinINTEL", Class: "@exclude", Opcode: 5926, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Input Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Input'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'S'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'I'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'rI'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Q'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'O'", Quantifier: "", }, }, } OpFixedCosINTEL = &Opcode { Opname: "OpFixedCosINTEL", Class: "@exclude", Opcode: 5927, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Input Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Input'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'S'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'I'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'rI'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Q'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'O'", Quantifier: "", }, }, } OpFixedSinCosINTEL = &Opcode { Opname: "OpFixedSinCosINTEL", Class: "@exclude", Opcode: 5928, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Input Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Input'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'S'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'I'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'rI'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Q'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'O'", Quantifier: "", }, }, } OpFixedSinPiINTEL = &Opcode { Opname: "OpFixedSinPiINTEL", Class: "@exclude", Opcode: 5929, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Input Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Input'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'S'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'I'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'rI'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Q'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'O'", Quantifier: "", }, }, } OpFixedCosPiINTEL = &Opcode { Opname: "OpFixedCosPiINTEL", Class: "@exclude", Opcode: 5930, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Input Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Input'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'S'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'I'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'rI'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Q'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'O'", Quantifier: "", }, }, } OpFixedSinCosPiINTEL = &Opcode { Opname: "OpFixedSinCosPiINTEL", Class: "@exclude", Opcode: 5931, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Input Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Input'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'S'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'I'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'rI'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Q'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'O'", Quantifier: "", }, }, } OpFixedLogINTEL = &Opcode { Opname: "OpFixedLogINTEL", Class: "@exclude", Opcode: 5932, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Input Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Input'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'S'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'I'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'rI'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Q'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'O'", Quantifier: "", }, }, } OpFixedExpINTEL = &Opcode { Opname: "OpFixedExpINTEL", Class: "@exclude", Opcode: 5933, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Input Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Input'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'S'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'I'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'rI'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Q'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'O'", Quantifier: "", }, }, } OpPtrCastToCrossWorkgroupINTEL = &Opcode { Opname: "OpPtrCastToCrossWorkgroupINTEL", Class: "@exclude", Opcode: 5934, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, }, } OpCrossWorkgroupCastToPtrINTEL = &Opcode { Opname: "OpCrossWorkgroupCastToPtrINTEL", Class: "@exclude", Opcode: 5938, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, }, } OpReadPipeBlockingINTEL = &Opcode { Opname: "OpReadPipeBlockingINTEL", Class: "Pipe", Opcode: 5946, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packet Size'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packet Alignment'", Quantifier: "", }, }, } OpWritePipeBlockingINTEL = &Opcode { Opname: "OpWritePipeBlockingINTEL", Class: "Pipe", Opcode: 5947, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packet Size'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Packet Alignment'", Quantifier: "", }, }, } OpFPGARegINTEL = &Opcode { Opname: "OpFPGARegINTEL", Class: "Reserved", Opcode: 5949, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Result'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Input'", Quantifier: "", }, }, } OpRayQueryGetRayTMinKHR = &Opcode { Opname: "OpRayQueryGetRayTMinKHR", Class: "Reserved", Opcode: 6016, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'RayQuery'", Quantifier: "", }, }, } OpRayQueryGetRayFlagsKHR = &Opcode { Opname: "OpRayQueryGetRayFlagsKHR", Class: "Reserved", Opcode: 6017, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'RayQuery'", Quantifier: "", }, }, } OpRayQueryGetIntersectionTKHR = &Opcode { Opname: "OpRayQueryGetIntersectionTKHR", Class: "Reserved", Opcode: 6018, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'RayQuery'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Intersection'", Quantifier: "", }, }, } OpRayQueryGetIntersectionInstanceCustomIndexKHR = &Opcode { Opname: "OpRayQueryGetIntersectionInstanceCustomIndexKHR", Class: "Reserved", Opcode: 6019, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'RayQuery'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Intersection'", Quantifier: "", }, }, } OpRayQueryGetIntersectionInstanceIdKHR = &Opcode { Opname: "OpRayQueryGetIntersectionInstanceIdKHR", Class: "Reserved", Opcode: 6020, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'RayQuery'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Intersection'", Quantifier: "", }, }, } OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR = &Opcode { Opname: "OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR", Class: "Reserved", Opcode: 6021, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'RayQuery'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Intersection'", Quantifier: "", }, }, } OpRayQueryGetIntersectionGeometryIndexKHR = &Opcode { Opname: "OpRayQueryGetIntersectionGeometryIndexKHR", Class: "Reserved", Opcode: 6022, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'RayQuery'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Intersection'", Quantifier: "", }, }, } OpRayQueryGetIntersectionPrimitiveIndexKHR = &Opcode { Opname: "OpRayQueryGetIntersectionPrimitiveIndexKHR", Class: "Reserved", Opcode: 6023, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'RayQuery'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Intersection'", Quantifier: "", }, }, } OpRayQueryGetIntersectionBarycentricsKHR = &Opcode { Opname: "OpRayQueryGetIntersectionBarycentricsKHR", Class: "Reserved", Opcode: 6024, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'RayQuery'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Intersection'", Quantifier: "", }, }, } OpRayQueryGetIntersectionFrontFaceKHR = &Opcode { Opname: "OpRayQueryGetIntersectionFrontFaceKHR", Class: "Reserved", Opcode: 6025, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'RayQuery'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Intersection'", Quantifier: "", }, }, } OpRayQueryGetIntersectionCandidateAABBOpaqueKHR = &Opcode { Opname: "OpRayQueryGetIntersectionCandidateAABBOpaqueKHR", Class: "Reserved", Opcode: 6026, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'RayQuery'", Quantifier: "", }, }, } OpRayQueryGetIntersectionObjectRayDirectionKHR = &Opcode { Opname: "OpRayQueryGetIntersectionObjectRayDirectionKHR", Class: "Reserved", Opcode: 6027, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'RayQuery'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Intersection'", Quantifier: "", }, }, } OpRayQueryGetIntersectionObjectRayOriginKHR = &Opcode { Opname: "OpRayQueryGetIntersectionObjectRayOriginKHR", Class: "Reserved", Opcode: 6028, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'RayQuery'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Intersection'", Quantifier: "", }, }, } OpRayQueryGetWorldRayDirectionKHR = &Opcode { Opname: "OpRayQueryGetWorldRayDirectionKHR", Class: "Reserved", Opcode: 6029, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'RayQuery'", Quantifier: "", }, }, } OpRayQueryGetWorldRayOriginKHR = &Opcode { Opname: "OpRayQueryGetWorldRayOriginKHR", Class: "Reserved", Opcode: 6030, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'RayQuery'", Quantifier: "", }, }, } OpRayQueryGetIntersectionObjectToWorldKHR = &Opcode { Opname: "OpRayQueryGetIntersectionObjectToWorldKHR", Class: "Reserved", Opcode: 6031, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'RayQuery'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Intersection'", Quantifier: "", }, }, } OpRayQueryGetIntersectionWorldToObjectKHR = &Opcode { Opname: "OpRayQueryGetIntersectionWorldToObjectKHR", Class: "Reserved", Opcode: 6032, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'RayQuery'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Intersection'", Quantifier: "", }, }, } OpAtomicFAddEXT = &Opcode { Opname: "OpAtomicFAddEXT", Class: "Atomic", Opcode: 6035, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Pointer'", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Memory'", Quantifier: "", }, Operand { Kind: OperandKindIdMemorySemantics, Name: "'Semantics'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, }, } OpTypeBufferSurfaceINTEL = &Opcode { Opname: "OpTypeBufferSurfaceINTEL", Class: "Type-Declaration", Opcode: 6086, Operands: []Operand { Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindAccessQualifier, Name: "'AccessQualifier'", Quantifier: "", }, }, } OpTypeStructContinuedINTEL = &Opcode { Opname: "OpTypeStructContinuedINTEL", Class: "Type-Declaration", Opcode: 6090, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Member 0 type', + 'member 1 type', + ...", Quantifier: "*", }, }, } OpConstantCompositeContinuedINTEL = &Opcode { Opname: "OpConstantCompositeContinuedINTEL", Class: "Constant-Creation", Opcode: 6091, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Constituents'", Quantifier: "*", }, }, } OpSpecConstantCompositeContinuedINTEL = &Opcode { Opname: "OpSpecConstantCompositeContinuedINTEL", Class: "Constant-Creation", Opcode: 6092, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Constituents'", Quantifier: "*", }, }, } OpCompositeConstructContinuedINTEL = &Opcode { Opname: "OpCompositeConstructContinuedINTEL", Class: "Composite", Opcode: 6096, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Constituents'", Quantifier: "*", }, }, } OpConvertFToBF16INTEL = &Opcode { Opname: "OpConvertFToBF16INTEL", Class: "Conversion", Opcode: 6116, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Float Value'", Quantifier: "", }, }, } OpConvertBF16ToFINTEL = &Opcode { Opname: "OpConvertBF16ToFINTEL", Class: "Conversion", Opcode: 6117, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'BFloat16 Value'", Quantifier: "", }, }, } OpControlBarrierArriveINTEL = &Opcode { Opname: "OpControlBarrierArriveINTEL", Class: "Barrier", Opcode: 6142, Operands: []Operand { Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Memory'", Quantifier: "", }, Operand { Kind: OperandKindIdMemorySemantics, Name: "'Semantics'", Quantifier: "", }, }, } OpControlBarrierWaitINTEL = &Opcode { Opname: "OpControlBarrierWaitINTEL", Class: "Barrier", Opcode: 6143, Operands: []Operand { Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Memory'", Quantifier: "", }, Operand { Kind: OperandKindIdMemorySemantics, Name: "'Semantics'", Quantifier: "", }, }, } OpArithmeticFenceEXT = &Opcode { Opname: "OpArithmeticFenceEXT", Class: "Miscellaneous", Opcode: 6145, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Target '", Quantifier: "", }, }, } OpSubgroupBlockPrefetchINTEL = &Opcode { Opname: "OpSubgroupBlockPrefetchINTEL", Class: "Group", Opcode: 6221, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Ptr'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'NumBytes'", Quantifier: "", }, Operand { Kind: OperandKindMemoryAccess, Name: "", Quantifier: "?", }, }, } OpGroupIMulKHR = &Opcode { Opname: "OpGroupIMulKHR", Class: "Group", Opcode: 6401, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'X'", Quantifier: "", }, }, } OpGroupFMulKHR = &Opcode { Opname: "OpGroupFMulKHR", Class: "Group", Opcode: 6402, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'X'", Quantifier: "", }, }, } OpGroupBitwiseAndKHR = &Opcode { Opname: "OpGroupBitwiseAndKHR", Class: "Group", Opcode: 6403, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'X'", Quantifier: "", }, }, } OpGroupBitwiseOrKHR = &Opcode { Opname: "OpGroupBitwiseOrKHR", Class: "Group", Opcode: 6404, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'X'", Quantifier: "", }, }, } OpGroupBitwiseXorKHR = &Opcode { Opname: "OpGroupBitwiseXorKHR", Class: "Group", Opcode: 6405, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'X'", Quantifier: "", }, }, } OpGroupLogicalAndKHR = &Opcode { Opname: "OpGroupLogicalAndKHR", Class: "Group", Opcode: 6406, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'X'", Quantifier: "", }, }, } OpGroupLogicalOrKHR = &Opcode { Opname: "OpGroupLogicalOrKHR", Class: "Group", Opcode: 6407, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'X'", Quantifier: "", }, }, } OpGroupLogicalXorKHR = &Opcode { Opname: "OpGroupLogicalXorKHR", Class: "Group", Opcode: 6408, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdScope, Name: "'Execution'", Quantifier: "", }, Operand { Kind: OperandKindGroupOperation, Name: "'Operation'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'X'", Quantifier: "", }, }, } OpMaskedGatherINTEL = &Opcode { Opname: "OpMaskedGatherINTEL", Class: "Memory", Opcode: 6428, Operands: []Operand { Operand { Kind: OperandKindIdResultType, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdResult, Name: "", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'PtrVector'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Alignment'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Mask'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'FillEmpty'", Quantifier: "", }, }, } OpMaskedScatterINTEL = &Opcode { Opname: "OpMaskedScatterINTEL", Class: "Memory", Opcode: 6429, Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'InputVector'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'PtrVector'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Alignment'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Mask'", Quantifier: "", }, }, } GLSLStd450_Round = &Opcode { Opname: "Round", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } GLSLStd450_RoundEven = &Opcode { Opname: "RoundEven", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } GLSLStd450_Trunc = &Opcode { Opname: "Trunc", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } GLSLStd450_FAbs = &Opcode { Opname: "FAbs", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } GLSLStd450_SAbs = &Opcode { Opname: "SAbs", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } GLSLStd450_FSign = &Opcode { Opname: "FSign", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } GLSLStd450_SSign = &Opcode { Opname: "SSign", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } GLSLStd450_Floor = &Opcode { Opname: "Floor", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } GLSLStd450_Ceil = &Opcode { Opname: "Ceil", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } GLSLStd450_Fract = &Opcode { Opname: "Fract", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } GLSLStd450_Radians = &Opcode { Opname: "Radians", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'degrees'", Quantifier: "", }, }, } GLSLStd450_Degrees = &Opcode { Opname: "Degrees", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'radians'", Quantifier: "", }, }, } GLSLStd450_Sin = &Opcode { Opname: "Sin", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } GLSLStd450_Cos = &Opcode { Opname: "Cos", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } GLSLStd450_Tan = &Opcode { Opname: "Tan", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } GLSLStd450_Asin = &Opcode { Opname: "Asin", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } GLSLStd450_Acos = &Opcode { Opname: "Acos", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } GLSLStd450_Atan = &Opcode { Opname: "Atan", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'y_over_x'", Quantifier: "", }, }, } GLSLStd450_Sinh = &Opcode { Opname: "Sinh", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } GLSLStd450_Cosh = &Opcode { Opname: "Cosh", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } GLSLStd450_Tanh = &Opcode { Opname: "Tanh", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } GLSLStd450_Asinh = &Opcode { Opname: "Asinh", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } GLSLStd450_Acosh = &Opcode { Opname: "Acosh", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } GLSLStd450_Atanh = &Opcode { Opname: "Atanh", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } GLSLStd450_Atan2 = &Opcode { Opname: "Atan2", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } GLSLStd450_Pow = &Opcode { Opname: "Pow", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } GLSLStd450_Exp = &Opcode { Opname: "Exp", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } GLSLStd450_Log = &Opcode { Opname: "Log", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } GLSLStd450_Exp2 = &Opcode { Opname: "Exp2", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } GLSLStd450_Log2 = &Opcode { Opname: "Log2", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } GLSLStd450_Sqrt = &Opcode { Opname: "Sqrt", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } GLSLStd450_InverseSqrt = &Opcode { Opname: "InverseSqrt", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } GLSLStd450_Determinant = &Opcode { Opname: "Determinant", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } GLSLStd450_MatrixInverse = &Opcode { Opname: "MatrixInverse", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } GLSLStd450_Modf = &Opcode { Opname: "Modf", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'i'", Quantifier: "", }, }, } GLSLStd450_ModfStruct = &Opcode { Opname: "ModfStruct", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } GLSLStd450_FMin = &Opcode { Opname: "FMin", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } GLSLStd450_UMin = &Opcode { Opname: "UMin", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } GLSLStd450_SMin = &Opcode { Opname: "SMin", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } GLSLStd450_FMax = &Opcode { Opname: "FMax", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } GLSLStd450_UMax = &Opcode { Opname: "UMax", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } GLSLStd450_SMax = &Opcode { Opname: "SMax", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } GLSLStd450_FClamp = &Opcode { Opname: "FClamp", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'minVal'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'maxVal'", Quantifier: "", }, }, } GLSLStd450_UClamp = &Opcode { Opname: "UClamp", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'minVal'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'maxVal'", Quantifier: "", }, }, } GLSLStd450_SClamp = &Opcode { Opname: "SClamp", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'minVal'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'maxVal'", Quantifier: "", }, }, } GLSLStd450_FMix = &Opcode { Opname: "FMix", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'a'", Quantifier: "", }, }, } GLSLStd450_IMix = &Opcode { Opname: "IMix", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'a'", Quantifier: "", }, }, } GLSLStd450_Step = &Opcode { Opname: "Step", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'edge'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } GLSLStd450_SmoothStep = &Opcode { Opname: "SmoothStep", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'edge0'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'edge1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } GLSLStd450_Fma = &Opcode { Opname: "Fma", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'a'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'b'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'c'", Quantifier: "", }, }, } GLSLStd450_Frexp = &Opcode { Opname: "Frexp", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'exp'", Quantifier: "", }, }, } GLSLStd450_FrexpStruct = &Opcode { Opname: "FrexpStruct", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } GLSLStd450_Ldexp = &Opcode { Opname: "Ldexp", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'exp'", Quantifier: "", }, }, } GLSLStd450_PackSnorm4x8 = &Opcode { Opname: "PackSnorm4x8", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'v'", Quantifier: "", }, }, } GLSLStd450_PackUnorm4x8 = &Opcode { Opname: "PackUnorm4x8", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'v'", Quantifier: "", }, }, } GLSLStd450_PackSnorm2x16 = &Opcode { Opname: "PackSnorm2x16", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'v'", Quantifier: "", }, }, } GLSLStd450_PackUnorm2x16 = &Opcode { Opname: "PackUnorm2x16", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'v'", Quantifier: "", }, }, } GLSLStd450_PackHalf2x16 = &Opcode { Opname: "PackHalf2x16", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'v'", Quantifier: "", }, }, } GLSLStd450_PackDouble2x32 = &Opcode { Opname: "PackDouble2x32", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'v'", Quantifier: "", }, }, } GLSLStd450_UnpackSnorm2x16 = &Opcode { Opname: "UnpackSnorm2x16", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'p'", Quantifier: "", }, }, } GLSLStd450_UnpackUnorm2x16 = &Opcode { Opname: "UnpackUnorm2x16", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'p'", Quantifier: "", }, }, } GLSLStd450_UnpackHalf2x16 = &Opcode { Opname: "UnpackHalf2x16", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'v'", Quantifier: "", }, }, } GLSLStd450_UnpackSnorm4x8 = &Opcode { Opname: "UnpackSnorm4x8", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'p'", Quantifier: "", }, }, } GLSLStd450_UnpackUnorm4x8 = &Opcode { Opname: "UnpackUnorm4x8", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'p'", Quantifier: "", }, }, } GLSLStd450_UnpackDouble2x32 = &Opcode { Opname: "UnpackDouble2x32", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'v'", Quantifier: "", }, }, } GLSLStd450_Length = &Opcode { Opname: "Length", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } GLSLStd450_Distance = &Opcode { Opname: "Distance", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'p0'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'p1'", Quantifier: "", }, }, } GLSLStd450_Cross = &Opcode { Opname: "Cross", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } GLSLStd450_Normalize = &Opcode { Opname: "Normalize", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } GLSLStd450_FaceForward = &Opcode { Opname: "FaceForward", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'N'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'I'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Nref'", Quantifier: "", }, }, } GLSLStd450_Reflect = &Opcode { Opname: "Reflect", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'I'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'N'", Quantifier: "", }, }, } GLSLStd450_Refract = &Opcode { Opname: "Refract", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'I'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'N'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'eta'", Quantifier: "", }, }, } GLSLStd450_FindILsb = &Opcode { Opname: "FindILsb", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, }, } GLSLStd450_FindSMsb = &Opcode { Opname: "FindSMsb", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, }, } GLSLStd450_FindUMsb = &Opcode { Opname: "FindUMsb", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, }, } GLSLStd450_InterpolateAtCentroid = &Opcode { Opname: "InterpolateAtCentroid", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'interpolant'", Quantifier: "", }, }, } GLSLStd450_InterpolateAtSample = &Opcode { Opname: "InterpolateAtSample", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'interpolant'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'sample'", Quantifier: "", }, }, } GLSLStd450_InterpolateAtOffset = &Opcode { Opname: "InterpolateAtOffset", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'interpolant'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'offset'", Quantifier: "", }, }, } GLSLStd450_NMin = &Opcode { Opname: "NMin", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } GLSLStd450_NMax = &Opcode { Opname: "NMax", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } GLSLStd450_NClamp = &Opcode { Opname: "NClamp", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'minVal'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'maxVal'", Quantifier: "", }, }, } OpenCLStd_acos = &Opcode { Opname: "acos", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_acosh = &Opcode { Opname: "acosh", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_acospi = &Opcode { Opname: "acospi", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_asin = &Opcode { Opname: "asin", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_asinh = &Opcode { Opname: "asinh", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_asinpi = &Opcode { Opname: "asinpi", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_atan = &Opcode { Opname: "atan", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_atan2 = &Opcode { Opname: "atan2", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_atanh = &Opcode { Opname: "atanh", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_atanpi = &Opcode { Opname: "atanpi", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_atan2pi = &Opcode { Opname: "atan2pi", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_cbrt = &Opcode { Opname: "cbrt", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_ceil = &Opcode { Opname: "ceil", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_copysign = &Opcode { Opname: "copysign", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpenCLStd_cos = &Opcode { Opname: "cos", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_cosh = &Opcode { Opname: "cosh", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_cospi = &Opcode { Opname: "cospi", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_erfc = &Opcode { Opname: "erfc", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_erf = &Opcode { Opname: "erf", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_exp = &Opcode { Opname: "exp", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_exp2 = &Opcode { Opname: "exp2", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_exp10 = &Opcode { Opname: "exp10", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_expm1 = &Opcode { Opname: "expm1", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_fabs = &Opcode { Opname: "fabs", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_fdim = &Opcode { Opname: "fdim", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpenCLStd_floor = &Opcode { Opname: "floor", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_fma = &Opcode { Opname: "fma", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'a'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'b'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'c'", Quantifier: "", }, }, } OpenCLStd_fmax = &Opcode { Opname: "fmax", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpenCLStd_fmin = &Opcode { Opname: "fmin", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpenCLStd_fmod = &Opcode { Opname: "fmod", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpenCLStd_fract = &Opcode { Opname: "fract", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'ptr'", Quantifier: "", }, }, } OpenCLStd_frexp = &Opcode { Opname: "frexp", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'exp'", Quantifier: "", }, }, } OpenCLStd_hypot = &Opcode { Opname: "hypot", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpenCLStd_ilogb = &Opcode { Opname: "ilogb", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_ldexp = &Opcode { Opname: "ldexp", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'k'", Quantifier: "", }, }, } OpenCLStd_lgamma = &Opcode { Opname: "lgamma", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_lgamma_r = &Opcode { Opname: "lgamma_r", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'signp'", Quantifier: "", }, }, } OpenCLStd_log = &Opcode { Opname: "log", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_log2 = &Opcode { Opname: "log2", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_log10 = &Opcode { Opname: "log10", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_log1p = &Opcode { Opname: "log1p", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_logb = &Opcode { Opname: "logb", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_mad = &Opcode { Opname: "mad", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'a'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'b'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'c'", Quantifier: "", }, }, } OpenCLStd_maxmag = &Opcode { Opname: "maxmag", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpenCLStd_minmag = &Opcode { Opname: "minmag", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpenCLStd_modf = &Opcode { Opname: "modf", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'iptr'", Quantifier: "", }, }, } OpenCLStd_nan = &Opcode { Opname: "nan", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'nancode'", Quantifier: "", }, }, } OpenCLStd_nextafter = &Opcode { Opname: "nextafter", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpenCLStd_pow = &Opcode { Opname: "pow", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y", Quantifier: "", }, }, } OpenCLStd_pown = &Opcode { Opname: "pown", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpenCLStd_powr = &Opcode { Opname: "powr", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpenCLStd_remainder = &Opcode { Opname: "remainder", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpenCLStd_remquo = &Opcode { Opname: "remquo", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'quo'", Quantifier: "", }, }, } OpenCLStd_rint = &Opcode { Opname: "rint", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_rootn = &Opcode { Opname: "rootn", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpenCLStd_round = &Opcode { Opname: "round", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_rsqrt = &Opcode { Opname: "rsqrt", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_sin = &Opcode { Opname: "sin", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_sincos = &Opcode { Opname: "sincos", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'cosval'", Quantifier: "", }, }, } OpenCLStd_sinh = &Opcode { Opname: "sinh", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_sinpi = &Opcode { Opname: "sinpi", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_sqrt = &Opcode { Opname: "sqrt", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_tan = &Opcode { Opname: "tan", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_tanh = &Opcode { Opname: "tanh", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_tanpi = &Opcode { Opname: "tanpi", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_tgamma = &Opcode { Opname: "tgamma", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_trunc = &Opcode { Opname: "trunc", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_half_cos = &Opcode { Opname: "half_cos", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_half_divide = &Opcode { Opname: "half_divide", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpenCLStd_half_exp = &Opcode { Opname: "half_exp", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_half_exp2 = &Opcode { Opname: "half_exp2", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_half_exp10 = &Opcode { Opname: "half_exp10", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_half_log = &Opcode { Opname: "half_log", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_half_log2 = &Opcode { Opname: "half_log2", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_half_log10 = &Opcode { Opname: "half_log10", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_half_powr = &Opcode { Opname: "half_powr", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpenCLStd_half_recip = &Opcode { Opname: "half_recip", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_half_rsqrt = &Opcode { Opname: "half_rsqrt", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_half_sin = &Opcode { Opname: "half_sin", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_half_sqrt = &Opcode { Opname: "half_sqrt", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_half_tan = &Opcode { Opname: "half_tan", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_native_cos = &Opcode { Opname: "native_cos", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_native_divide = &Opcode { Opname: "native_divide", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpenCLStd_native_exp = &Opcode { Opname: "native_exp", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_native_exp2 = &Opcode { Opname: "native_exp2", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_native_exp10 = &Opcode { Opname: "native_exp10", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_native_log = &Opcode { Opname: "native_log", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_native_log2 = &Opcode { Opname: "native_log2", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_native_log10 = &Opcode { Opname: "native_log10", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_native_powr = &Opcode { Opname: "native_powr", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpenCLStd_native_recip = &Opcode { Opname: "native_recip", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_native_rsqrt = &Opcode { Opname: "native_rsqrt", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_native_sin = &Opcode { Opname: "native_sin", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_native_sqrt = &Opcode { Opname: "native_sqrt", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_native_tan = &Opcode { Opname: "native_tan", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_s_abs = &Opcode { Opname: "s_abs", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_s_abs_diff = &Opcode { Opname: "s_abs_diff", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpenCLStd_s_add_sat = &Opcode { Opname: "s_add_sat", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpenCLStd_u_add_sat = &Opcode { Opname: "u_add_sat", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpenCLStd_s_hadd = &Opcode { Opname: "s_hadd", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpenCLStd_u_hadd = &Opcode { Opname: "u_hadd", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpenCLStd_s_rhadd = &Opcode { Opname: "s_rhadd", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpenCLStd_u_rhadd = &Opcode { Opname: "u_rhadd", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpenCLStd_s_clamp = &Opcode { Opname: "s_clamp", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'minval'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'maxval'", Quantifier: "", }, }, } OpenCLStd_u_clamp = &Opcode { Opname: "u_clamp", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'minval'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'maxval'", Quantifier: "", }, }, } OpenCLStd_clz = &Opcode { Opname: "clz", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_ctz = &Opcode { Opname: "ctz", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_s_mad_hi = &Opcode { Opname: "s_mad_hi", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'a'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'b'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'c'", Quantifier: "", }, }, } OpenCLStd_u_mad_sat = &Opcode { Opname: "u_mad_sat", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'z'", Quantifier: "", }, }, } OpenCLStd_s_mad_sat = &Opcode { Opname: "s_mad_sat", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'z'", Quantifier: "", }, }, } OpenCLStd_s_max = &Opcode { Opname: "s_max", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpenCLStd_u_max = &Opcode { Opname: "u_max", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpenCLStd_s_min = &Opcode { Opname: "s_min", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpenCLStd_u_min = &Opcode { Opname: "u_min", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpenCLStd_s_mul_hi = &Opcode { Opname: "s_mul_hi", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpenCLStd_rotate = &Opcode { Opname: "rotate", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'v'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'i'", Quantifier: "", }, }, } OpenCLStd_s_sub_sat = &Opcode { Opname: "s_sub_sat", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpenCLStd_u_sub_sat = &Opcode { Opname: "u_sub_sat", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpenCLStd_u_upsample = &Opcode { Opname: "u_upsample", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'hi'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'lo'", Quantifier: "", }, }, } OpenCLStd_s_upsample = &Opcode { Opname: "s_upsample", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'hi'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'lo'", Quantifier: "", }, }, } OpenCLStd_popcount = &Opcode { Opname: "popcount", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_s_mad24 = &Opcode { Opname: "s_mad24", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'z'", Quantifier: "", }, }, } OpenCLStd_u_mad24 = &Opcode { Opname: "u_mad24", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'z'", Quantifier: "", }, }, } OpenCLStd_s_mul24 = &Opcode { Opname: "s_mul24", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpenCLStd_u_mul24 = &Opcode { Opname: "u_mul24", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpenCLStd_u_abs = &Opcode { Opname: "u_abs", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_u_abs_diff = &Opcode { Opname: "u_abs_diff", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpenCLStd_u_mul_hi = &Opcode { Opname: "u_mul_hi", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpenCLStd_u_mad_hi = &Opcode { Opname: "u_mad_hi", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'a'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'b'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'c'", Quantifier: "", }, }, } OpenCLStd_fclamp = &Opcode { Opname: "fclamp", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'minval'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'maxval'", Quantifier: "", }, }, } OpenCLStd_degrees = &Opcode { Opname: "degrees", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'radians'", Quantifier: "", }, }, } OpenCLStd_fmax_common = &Opcode { Opname: "fmax_common", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpenCLStd_fmin_common = &Opcode { Opname: "fmin_common", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, }, } OpenCLStd_mix = &Opcode { Opname: "mix", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'a'", Quantifier: "", }, }, } OpenCLStd_radians = &Opcode { Opname: "radians", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'degrees'", Quantifier: "", }, }, } OpenCLStd_step = &Opcode { Opname: "step", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'edge'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_smoothstep = &Opcode { Opname: "smoothstep", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'edge0'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'edge1'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_sign = &Opcode { Opname: "sign", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, }, } OpenCLStd_cross = &Opcode { Opname: "cross", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'p0'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'p1'", Quantifier: "", }, }, } OpenCLStd_distance = &Opcode { Opname: "distance", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'p0'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'p1'", Quantifier: "", }, }, } OpenCLStd_length = &Opcode { Opname: "length", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'p'", Quantifier: "", }, }, } OpenCLStd_normalize = &Opcode { Opname: "normalize", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'p'", Quantifier: "", }, }, } OpenCLStd_fast_distance = &Opcode { Opname: "fast_distance", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'p0'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'p1'", Quantifier: "", }, }, } OpenCLStd_fast_length = &Opcode { Opname: "fast_length", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'p'", Quantifier: "", }, }, } OpenCLStd_fast_normalize = &Opcode { Opname: "fast_normalize", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'p'", Quantifier: "", }, }, } OpenCLStd_bitselect = &Opcode { Opname: "bitselect", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'a'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'b'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'c'", Quantifier: "", }, }, } OpenCLStd_select = &Opcode { Opname: "select", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'a'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'b'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'c'", Quantifier: "", }, }, } OpenCLStd_vloadn = &Opcode { Opname: "vloadn", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'offset'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'p'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'n'", Quantifier: "", }, }, } OpenCLStd_vstoren = &Opcode { Opname: "vstoren", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'data'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'offset'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'p'", Quantifier: "", }, }, } OpenCLStd_vload_half = &Opcode { Opname: "vload_half", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'offset'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'p'", Quantifier: "", }, }, } OpenCLStd_vload_halfn = &Opcode { Opname: "vload_halfn", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'offset'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'p'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'n'", Quantifier: "", }, }, } OpenCLStd_vstore_half = &Opcode { Opname: "vstore_half", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'data'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'offset'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'p'", Quantifier: "", }, }, } OpenCLStd_vstore_half_r = &Opcode { Opname: "vstore_half_r", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'data'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'offset'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'p'", Quantifier: "", }, Operand { Kind: OperandKindFPRoundingMode, Name: "'mode'", Quantifier: "", }, }, } OpenCLStd_vstore_halfn = &Opcode { Opname: "vstore_halfn", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'data'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'offset'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'p'", Quantifier: "", }, }, } OpenCLStd_vstore_halfn_r = &Opcode { Opname: "vstore_halfn_r", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'data'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'offset'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'p'", Quantifier: "", }, Operand { Kind: OperandKindFPRoundingMode, Name: "'mode'", Quantifier: "", }, }, } OpenCLStd_vloada_halfn = &Opcode { Opname: "vloada_halfn", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'offset'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'p'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'n'", Quantifier: "", }, }, } OpenCLStd_vstorea_halfn = &Opcode { Opname: "vstorea_halfn", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'data'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'offset'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'p'", Quantifier: "", }, }, } OpenCLStd_vstorea_halfn_r = &Opcode { Opname: "vstorea_halfn_r", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'data'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'offset'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'p'", Quantifier: "", }, Operand { Kind: OperandKindFPRoundingMode, Name: "'mode'", Quantifier: "", }, }, } OpenCLStd_shuffle = &Opcode { Opname: "shuffle", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'shuffle mask'", Quantifier: "", }, }, } OpenCLStd_shuffle2 = &Opcode { Opname: "shuffle2", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'x'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'y'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'shuffle mask'", Quantifier: "", }, }, } OpenCLStd_printf = &Opcode { Opname: "printf", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'format'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'additional arguments'", Quantifier: "*", }, }, } OpenCLStd_prefetch = &Opcode { Opname: "prefetch", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'ptr'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'num elements'", Quantifier: "", }, }, } OpenCLDebugInfo100_DebugInfoNone = &Opcode { Opname: "DebugInfoNone", Operands: []Operand { }, } OpenCLDebugInfo100_DebugCompilationUnit = &Opcode { Opname: "DebugCompilationUnit", Operands: []Operand { Operand { Kind: OperandKindLiteralInteger, Name: "'Version'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'DWARF Version'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Source'", Quantifier: "", }, Operand { Kind: OperandKindSourceLanguage, Name: "'Language'", Quantifier: "", }, }, } OpenCLDebugInfo100_DebugTypeBasic = &Opcode { Opname: "DebugTypeBasic", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Name'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Size'", Quantifier: "", }, Operand { Kind: OperandKindDebugBaseTypeAttributeEncoding, Name: "'Encoding'", Quantifier: "", }, }, } OpenCLDebugInfo100_DebugTypePointer = &Opcode { Opname: "DebugTypePointer", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Base Type'", Quantifier: "", }, Operand { Kind: OperandKindStorageClass, Name: "'Storage Class'", Quantifier: "", }, Operand { Kind: OperandKindDebugInfoFlags, Name: "'Flags'", Quantifier: "", }, }, } OpenCLDebugInfo100_DebugTypeQualifier = &Opcode { Opname: "DebugTypeQualifier", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Base Type'", Quantifier: "", }, Operand { Kind: OperandKindDebugTypeQualifier, Name: "'Type Qualifier'", Quantifier: "", }, }, } OpenCLDebugInfo100_DebugTypeArray = &Opcode { Opname: "DebugTypeArray", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Base Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Component Counts'", Quantifier: "*", }, }, } OpenCLDebugInfo100_DebugTypeVector = &Opcode { Opname: "DebugTypeVector", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Base Type'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Component Count'", Quantifier: "", }, }, } OpenCLDebugInfo100_DebugTypedef = &Opcode { Opname: "DebugTypedef", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Name'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Base Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Source'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Line'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Column'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Parent'", Quantifier: "", }, }, } OpenCLDebugInfo100_DebugTypeFunction = &Opcode { Opname: "DebugTypeFunction", Operands: []Operand { Operand { Kind: OperandKindDebugInfoFlags, Name: "'Flags'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Return Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Parameter Types'", Quantifier: "*", }, }, } OpenCLDebugInfo100_DebugTypeEnum = &Opcode { Opname: "DebugTypeEnum", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Name'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Underlying Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Source'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Line'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Column'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Parent'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Size'", Quantifier: "", }, Operand { Kind: OperandKindDebugInfoFlags, Name: "'Flags'", Quantifier: "", }, Operand { Kind: OperandKindPairIdRefIdRef, Name: "'Value, Name, Value, Name, ...'", Quantifier: "*", }, }, } OpenCLDebugInfo100_DebugTypeComposite = &Opcode { Opname: "DebugTypeComposite", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Name'", Quantifier: "", }, Operand { Kind: OperandKindDebugCompositeType, Name: "'Tag'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Source'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Line'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Column'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Parent'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Linkage Name'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Size'", Quantifier: "", }, Operand { Kind: OperandKindDebugInfoFlags, Name: "'Flags'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Members'", Quantifier: "*", }, }, } OpenCLDebugInfo100_DebugTypeMember = &Opcode { Opname: "DebugTypeMember", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Name'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Source'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Line'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Column'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Parent'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Offset'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Size'", Quantifier: "", }, Operand { Kind: OperandKindDebugInfoFlags, Name: "'Flags'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "?", }, }, } OpenCLDebugInfo100_DebugTypeInheritance = &Opcode { Opname: "DebugTypeInheritance", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Child'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Parent'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Offset'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Size'", Quantifier: "", }, Operand { Kind: OperandKindDebugInfoFlags, Name: "'Flags'", Quantifier: "", }, }, } OpenCLDebugInfo100_DebugTypePtrToMember = &Opcode { Opname: "DebugTypePtrToMember", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Member Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Parent'", Quantifier: "", }, }, } OpenCLDebugInfo100_DebugTypeTemplate = &Opcode { Opname: "DebugTypeTemplate", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Target'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Parameters'", Quantifier: "*", }, }, } OpenCLDebugInfo100_DebugTypeTemplateParameter = &Opcode { Opname: "DebugTypeTemplateParameter", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Name'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Actual Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Source'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Line'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Column'", Quantifier: "", }, }, } OpenCLDebugInfo100_DebugTypeTemplateTemplateParameter = &Opcode { Opname: "DebugTypeTemplateTemplateParameter", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Name'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Template Name'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Source'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Line'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Column'", Quantifier: "", }, }, } OpenCLDebugInfo100_DebugTypeTemplateParameterPack = &Opcode { Opname: "DebugTypeTemplateParameterPack", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Name'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Source'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Line'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Column'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Template Parameters'", Quantifier: "*", }, }, } OpenCLDebugInfo100_DebugGlobalVariable = &Opcode { Opname: "DebugGlobalVariable", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Name'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Source'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Line'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Column'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Parent'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Linkage Name'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Variable'", Quantifier: "", }, Operand { Kind: OperandKindDebugInfoFlags, Name: "'Flags'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Static Member Declaration'", Quantifier: "?", }, }, } OpenCLDebugInfo100_DebugFunctionDeclaration = &Opcode { Opname: "DebugFunctionDeclaration", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Name'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Source'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Line'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Column'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Parent'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Linkage Name'", Quantifier: "", }, Operand { Kind: OperandKindDebugInfoFlags, Name: "'Flags'", Quantifier: "", }, }, } OpenCLDebugInfo100_DebugFunction = &Opcode { Opname: "DebugFunction", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Name'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Source'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Line'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Column'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Parent'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Linkage Name'", Quantifier: "", }, Operand { Kind: OperandKindDebugInfoFlags, Name: "'Flags'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Scope Line'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Function'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Declaration'", Quantifier: "?", }, }, } OpenCLDebugInfo100_DebugLexicalBlock = &Opcode { Opname: "DebugLexicalBlock", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Source'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Line'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Column'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Parent'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Name'", Quantifier: "?", }, }, } OpenCLDebugInfo100_DebugLexicalBlockDiscriminator = &Opcode { Opname: "DebugLexicalBlockDiscriminator", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Source'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Discriminator'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Parent'", Quantifier: "", }, }, } OpenCLDebugInfo100_DebugScope = &Opcode { Opname: "DebugScope", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Scope'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Inlined At'", Quantifier: "?", }, }, } OpenCLDebugInfo100_DebugNoScope = &Opcode { Opname: "DebugNoScope", Operands: []Operand { }, } OpenCLDebugInfo100_DebugInlinedAt = &Opcode { Opname: "DebugInlinedAt", Operands: []Operand { Operand { Kind: OperandKindLiteralInteger, Name: "'Line'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Scope'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Inlined'", Quantifier: "?", }, }, } OpenCLDebugInfo100_DebugLocalVariable = &Opcode { Opname: "DebugLocalVariable", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Name'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Type'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Source'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Line'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Column'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Parent'", Quantifier: "", }, Operand { Kind: OperandKindDebugInfoFlags, Name: "'Flags'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Arg Number'", Quantifier: "?", }, }, } OpenCLDebugInfo100_DebugInlinedVariable = &Opcode { Opname: "DebugInlinedVariable", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Variable'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Inlined'", Quantifier: "", }, }, } OpenCLDebugInfo100_DebugDeclare = &Opcode { Opname: "DebugDeclare", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Local Variable'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Variable'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Expression'", Quantifier: "", }, }, } OpenCLDebugInfo100_DebugValue = &Opcode { Opname: "DebugValue", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Local Variable'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Expression'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Indexes'", Quantifier: "*", }, }, } OpenCLDebugInfo100_DebugOperation = &Opcode { Opname: "DebugOperation", Operands: []Operand { Operand { Kind: OperandKindDebugOperation, Name: "'OpCode'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Operands ...'", Quantifier: "*", }, }, } OpenCLDebugInfo100_DebugExpression = &Opcode { Opname: "DebugExpression", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Operands ...'", Quantifier: "*", }, }, } OpenCLDebugInfo100_DebugMacroDef = &Opcode { Opname: "DebugMacroDef", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Source'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Line'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Name'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Value'", Quantifier: "?", }, }, } OpenCLDebugInfo100_DebugMacroUndef = &Opcode { Opname: "DebugMacroUndef", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Source'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Line'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Macro'", Quantifier: "", }, }, } OpenCLDebugInfo100_DebugImportedEntity = &Opcode { Opname: "DebugImportedEntity", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Name'", Quantifier: "", }, Operand { Kind: OperandKindDebugImportedEntity, Name: "'Tag'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Source'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Entity'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Line'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Column'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Parent'", Quantifier: "", }, }, } OpenCLDebugInfo100_DebugSource = &Opcode { Opname: "DebugSource", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'File'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Text'", Quantifier: "?", }, }, } OpenCLDebugInfo100_DebugModuleINTEL = &Opcode { Opname: "DebugModuleINTEL", Operands: []Operand { Operand { Kind: OperandKindIdRef, Name: "'Name'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Source'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'Parent'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'Line'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'ConfigurationMacros'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'IncludePath'", Quantifier: "", }, Operand { Kind: OperandKindIdRef, Name: "'APINotesFile'", Quantifier: "", }, Operand { Kind: OperandKindLiteralInteger, Name: "'IsDeclaration'", Quantifier: "", }, }, } OperandKindImageOperands = &OperandKind { Kind: "ImageOperands", Category: "BitEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "None", Value: 0x0000, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "Bias", Value: 0x0001, Capabilities: []string{"Shader",}, Parameters: []Parameter{{OperandKindIdRef, ""},}, Version: "1.0", }, Enumerant{ Enumerant: "Lod", Value: 0x0002, Capabilities: []string{}, Parameters: []Parameter{{OperandKindIdRef, ""},}, Version: "1.0", }, Enumerant{ Enumerant: "Grad", Value: 0x0004, Capabilities: []string{}, Parameters: []Parameter{{OperandKindIdRef, ""},{OperandKindIdRef, ""},}, Version: "1.0", }, Enumerant{ Enumerant: "ConstOffset", Value: 0x0008, Capabilities: []string{}, Parameters: []Parameter{{OperandKindIdRef, ""},}, Version: "1.0", }, Enumerant{ Enumerant: "Offset", Value: 0x0010, Capabilities: []string{"ImageGatherExtended",}, Parameters: []Parameter{{OperandKindIdRef, ""},}, Version: "1.0", }, Enumerant{ Enumerant: "ConstOffsets", Value: 0x0020, Capabilities: []string{"ImageGatherExtended",}, Parameters: []Parameter{{OperandKindIdRef, ""},}, Version: "1.0", }, Enumerant{ Enumerant: "Sample", Value: 0x0040, Capabilities: []string{}, Parameters: []Parameter{{OperandKindIdRef, ""},}, Version: "1.0", }, Enumerant{ Enumerant: "MinLod", Value: 0x0080, Capabilities: []string{"MinLod",}, Parameters: []Parameter{{OperandKindIdRef, ""},}, Version: "1.0", }, Enumerant{ Enumerant: "MakeTexelAvailable", Value: 0x0100, Capabilities: []string{"VulkanMemoryModel",}, Parameters: []Parameter{{OperandKindIdScope, ""},}, Version: "1.5", }, Enumerant{ Enumerant: "MakeTexelVisible", Value: 0x0200, Capabilities: []string{"VulkanMemoryModel",}, Parameters: []Parameter{{OperandKindIdScope, ""},}, Version: "1.5", }, Enumerant{ Enumerant: "NonPrivateTexel", Value: 0x0400, Capabilities: []string{"VulkanMemoryModel",}, Parameters: []Parameter{}, Version: "1.5", }, Enumerant{ Enumerant: "VolatileTexel", Value: 0x0800, Capabilities: []string{"VulkanMemoryModel",}, Parameters: []Parameter{}, Version: "1.5", }, Enumerant{ Enumerant: "SignExtend", Value: 0x1000, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.4", }, Enumerant{ Enumerant: "ZeroExtend", Value: 0x2000, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.4", }, Enumerant{ Enumerant: "Nontemporal", Value: 0x4000, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.6", }, Enumerant{ Enumerant: "Offsets", Value: 0x10000, Capabilities: []string{}, Parameters: []Parameter{{OperandKindIdRef, ""},}, Version: "1.0", }, }, Bases: []*OperandKind {}, } OperandKindFPFastMathMode = &OperandKind { Kind: "FPFastMathMode", Category: "BitEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "None", Value: 0x0000, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "NotNaN", Value: 0x0001, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "NotInf", Value: 0x0002, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "NSZ", Value: 0x0004, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "AllowRecip", Value: 0x0008, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Fast", Value: 0x0010, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "AllowContract", Value: 0x10000, Capabilities: []string{"FloatControls2","FPFastMathModeINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "AllowReassoc", Value: 0x20000, Capabilities: []string{"FloatControls2","FPFastMathModeINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "AllowTransform", Value: 0x40000, Capabilities: []string{"FloatControls2",}, Parameters: []Parameter{}, Version: "None", }, }, Bases: []*OperandKind {}, } OperandKindSelectionControl = &OperandKind { Kind: "SelectionControl", Category: "BitEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "None", Value: 0x0000, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Flatten", Value: 0x0001, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "DontFlatten", Value: 0x0002, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, }, Bases: []*OperandKind {}, } OperandKindLoopControl = &OperandKind { Kind: "LoopControl", Category: "BitEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "None", Value: 0x0000, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Unroll", Value: 0x0001, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "DontUnroll", Value: 0x0002, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "DependencyInfinite", Value: 0x0004, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.1", }, Enumerant{ Enumerant: "DependencyLength", Value: 0x0008, Capabilities: []string{}, Parameters: []Parameter{{OperandKindLiteralInteger, ""},}, Version: "1.1", }, Enumerant{ Enumerant: "MinIterations", Value: 0x0010, Capabilities: []string{}, Parameters: []Parameter{{OperandKindLiteralInteger, ""},}, Version: "1.4", }, Enumerant{ Enumerant: "MaxIterations", Value: 0x0020, Capabilities: []string{}, Parameters: []Parameter{{OperandKindLiteralInteger, ""},}, Version: "1.4", }, Enumerant{ Enumerant: "IterationMultiple", Value: 0x0040, Capabilities: []string{}, Parameters: []Parameter{{OperandKindLiteralInteger, ""},}, Version: "1.4", }, Enumerant{ Enumerant: "PeelCount", Value: 0x0080, Capabilities: []string{}, Parameters: []Parameter{{OperandKindLiteralInteger, ""},}, Version: "1.4", }, Enumerant{ Enumerant: "PartialCount", Value: 0x0100, Capabilities: []string{}, Parameters: []Parameter{{OperandKindLiteralInteger, ""},}, Version: "1.4", }, Enumerant{ Enumerant: "InitiationIntervalINTEL", Value: 0x10000, Capabilities: []string{"FPGALoopControlsINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, ""},}, Version: "None", }, Enumerant{ Enumerant: "MaxConcurrencyINTEL", Value: 0x20000, Capabilities: []string{"FPGALoopControlsINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, ""},}, Version: "None", }, Enumerant{ Enumerant: "DependencyArrayINTEL", Value: 0x40000, Capabilities: []string{"FPGALoopControlsINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, ""},}, Version: "None", }, Enumerant{ Enumerant: "PipelineEnableINTEL", Value: 0x80000, Capabilities: []string{"FPGALoopControlsINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, ""},}, Version: "None", }, Enumerant{ Enumerant: "LoopCoalesceINTEL", Value: 0x100000, Capabilities: []string{"FPGALoopControlsINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, ""},}, Version: "None", }, Enumerant{ Enumerant: "MaxInterleavingINTEL", Value: 0x200000, Capabilities: []string{"FPGALoopControlsINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, ""},}, Version: "None", }, Enumerant{ Enumerant: "SpeculatedIterationsINTEL", Value: 0x400000, Capabilities: []string{"FPGALoopControlsINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, ""},}, Version: "None", }, Enumerant{ Enumerant: "NoFusionINTEL", Value: 0x800000, Capabilities: []string{"FPGALoopControlsINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "LoopCountINTEL", Value: 0x1000000, Capabilities: []string{"FPGALoopControlsINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, ""},}, Version: "None", }, Enumerant{ Enumerant: "MaxReinvocationDelayINTEL", Value: 0x2000000, Capabilities: []string{"FPGALoopControlsINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, ""},}, Version: "None", }, }, Bases: []*OperandKind {}, } OperandKindFunctionControl = &OperandKind { Kind: "FunctionControl", Category: "BitEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "None", Value: 0x0000, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Inline", Value: 0x0001, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "DontInline", Value: 0x0002, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Pure", Value: 0x0004, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Const", Value: 0x0008, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "OptNoneEXT", Value: 0x10000, Capabilities: []string{"OptNoneEXT",}, Parameters: []Parameter{}, Version: "None", }, }, Bases: []*OperandKind {}, } OperandKindMemorySemantics = &OperandKind { Kind: "MemorySemantics", Category: "BitEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "Relaxed", Value: 0x0000, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Acquire", Value: 0x0002, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Release", Value: 0x0004, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "AcquireRelease", Value: 0x0008, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "SequentiallyConsistent", Value: 0x0010, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "UniformMemory", Value: 0x0040, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "SubgroupMemory", Value: 0x0080, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "WorkgroupMemory", Value: 0x0100, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "CrossWorkgroupMemory", Value: 0x0200, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "AtomicCounterMemory", Value: 0x0400, Capabilities: []string{"AtomicStorage",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "ImageMemory", Value: 0x0800, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "OutputMemory", Value: 0x1000, Capabilities: []string{"VulkanMemoryModel",}, Parameters: []Parameter{}, Version: "1.5", }, Enumerant{ Enumerant: "MakeAvailable", Value: 0x2000, Capabilities: []string{"VulkanMemoryModel",}, Parameters: []Parameter{}, Version: "1.5", }, Enumerant{ Enumerant: "MakeVisible", Value: 0x4000, Capabilities: []string{"VulkanMemoryModel",}, Parameters: []Parameter{}, Version: "1.5", }, Enumerant{ Enumerant: "Volatile", Value: 0x8000, Capabilities: []string{"VulkanMemoryModel",}, Parameters: []Parameter{}, Version: "1.5", }, }, Bases: []*OperandKind {}, } OperandKindMemoryAccess = &OperandKind { Kind: "MemoryAccess", Category: "BitEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "None", Value: 0x0000, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Volatile", Value: 0x0001, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Aligned", Value: 0x0002, Capabilities: []string{}, Parameters: []Parameter{{OperandKindLiteralInteger, ""},}, Version: "1.0", }, Enumerant{ Enumerant: "Nontemporal", Value: 0x0004, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "MakePointerAvailable", Value: 0x0008, Capabilities: []string{"VulkanMemoryModel",}, Parameters: []Parameter{{OperandKindIdScope, ""},}, Version: "1.5", }, Enumerant{ Enumerant: "MakePointerVisible", Value: 0x0010, Capabilities: []string{"VulkanMemoryModel",}, Parameters: []Parameter{{OperandKindIdScope, ""},}, Version: "1.5", }, Enumerant{ Enumerant: "NonPrivatePointer", Value: 0x0020, Capabilities: []string{"VulkanMemoryModel",}, Parameters: []Parameter{}, Version: "1.5", }, Enumerant{ Enumerant: "AliasScopeINTELMask", Value: 0x10000, Capabilities: []string{"MemoryAccessAliasingINTEL",}, Parameters: []Parameter{{OperandKindIdRef, ""},}, Version: "None", }, Enumerant{ Enumerant: "NoAliasINTELMask", Value: 0x20000, Capabilities: []string{"MemoryAccessAliasingINTEL",}, Parameters: []Parameter{{OperandKindIdRef, ""},}, Version: "None", }, }, Bases: []*OperandKind {}, } OperandKindKernelProfilingInfo = &OperandKind { Kind: "KernelProfilingInfo", Category: "BitEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "None", Value: 0x0000, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "CmdExecTime", Value: 0x0001, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "1.0", }, }, Bases: []*OperandKind {}, } OperandKindRayFlags = &OperandKind { Kind: "RayFlags", Category: "BitEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "NoneKHR", Value: 0x0000, Capabilities: []string{"RayQueryKHR","RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "OpaqueKHR", Value: 0x0001, Capabilities: []string{"RayQueryKHR","RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "NoOpaqueKHR", Value: 0x0002, Capabilities: []string{"RayQueryKHR","RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "TerminateOnFirstHitKHR", Value: 0x0004, Capabilities: []string{"RayQueryKHR","RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "SkipClosestHitShaderKHR", Value: 0x0008, Capabilities: []string{"RayQueryKHR","RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "CullBackFacingTrianglesKHR", Value: 0x0010, Capabilities: []string{"RayQueryKHR","RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "CullFrontFacingTrianglesKHR", Value: 0x0020, Capabilities: []string{"RayQueryKHR","RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "CullOpaqueKHR", Value: 0x0040, Capabilities: []string{"RayQueryKHR","RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "CullNoOpaqueKHR", Value: 0x0080, Capabilities: []string{"RayQueryKHR","RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "SkipTrianglesKHR", Value: 0x0100, Capabilities: []string{"RayTraversalPrimitiveCullingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "SkipAABBsKHR", Value: 0x0200, Capabilities: []string{"RayTraversalPrimitiveCullingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ForceOpacityMicromap2StateEXT", Value: 0x0400, Capabilities: []string{"RayTracingOpacityMicromapEXT",}, Parameters: []Parameter{}, Version: "None", }, }, Bases: []*OperandKind {}, } OperandKindFragmentShadingRate = &OperandKind { Kind: "FragmentShadingRate", Category: "BitEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "Vertical2Pixels", Value: 0x0001, Capabilities: []string{"FragmentShadingRateKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "Vertical4Pixels", Value: 0x0002, Capabilities: []string{"FragmentShadingRateKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "Horizontal2Pixels", Value: 0x0004, Capabilities: []string{"FragmentShadingRateKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "Horizontal4Pixels", Value: 0x0008, Capabilities: []string{"FragmentShadingRateKHR",}, Parameters: []Parameter{}, Version: "None", }, }, Bases: []*OperandKind {}, } OperandKindRawAccessChainOperands = &OperandKind { Kind: "RawAccessChainOperands", Category: "BitEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "None", Value: 0x0000, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "RobustnessPerComponentNV", Value: 0x0001, Capabilities: []string{"RawAccessChainsNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "RobustnessPerElementNV", Value: 0x0002, Capabilities: []string{"RawAccessChainsNV",}, Parameters: []Parameter{}, Version: "None", }, }, Bases: []*OperandKind {}, } OperandKindSourceLanguage = &OperandKind { Kind: "SourceLanguage", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "Unknown", Value: 0, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "ESSL", Value: 1, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "GLSL", Value: 2, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "OpenCL_C", Value: 3, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "OpenCL_CPP", Value: 4, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "HLSL", Value: 5, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "CPP_for_OpenCL", Value: 6, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "SYCL", Value: 7, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "HERO_C", Value: 8, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "NZSL", Value: 9, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "WGSL", Value: 10, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Slang", Value: 11, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Zig", Value: 12, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, }, Bases: []*OperandKind {}, } OperandKindExecutionModel = &OperandKind { Kind: "ExecutionModel", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "Vertex", Value: 0, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "TessellationControl", Value: 1, Capabilities: []string{"Tessellation",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "TessellationEvaluation", Value: 2, Capabilities: []string{"Tessellation",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Geometry", Value: 3, Capabilities: []string{"Geometry",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Fragment", Value: 4, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "GLCompute", Value: 5, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Kernel", Value: 6, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "TaskNV", Value: 5267, Capabilities: []string{"MeshShadingNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "MeshNV", Value: 5268, Capabilities: []string{"MeshShadingNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "RayGenerationKHR", Value: 5313, Capabilities: []string{"RayTracingNV","RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "IntersectionKHR", Value: 5314, Capabilities: []string{"RayTracingNV","RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "AnyHitKHR", Value: 5315, Capabilities: []string{"RayTracingNV","RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ClosestHitKHR", Value: 5316, Capabilities: []string{"RayTracingNV","RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "MissKHR", Value: 5317, Capabilities: []string{"RayTracingNV","RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "CallableKHR", Value: 5318, Capabilities: []string{"RayTracingNV","RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "TaskEXT", Value: 5364, Capabilities: []string{"MeshShadingEXT",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "MeshEXT", Value: 5365, Capabilities: []string{"MeshShadingEXT",}, Parameters: []Parameter{}, Version: "None", }, }, Bases: []*OperandKind {}, } OperandKindAddressingModel = &OperandKind { Kind: "AddressingModel", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "Logical", Value: 0, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Physical32", Value: 1, Capabilities: []string{"Addresses",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Physical64", Value: 2, Capabilities: []string{"Addresses",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "PhysicalStorageBuffer64", Value: 5348, Capabilities: []string{"PhysicalStorageBufferAddresses",}, Parameters: []Parameter{}, Version: "1.5", }, }, Bases: []*OperandKind {}, } OperandKindMemoryModel = &OperandKind { Kind: "MemoryModel", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "Simple", Value: 0, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "GLSL450", Value: 1, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "OpenCL", Value: 2, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Vulkan", Value: 3, Capabilities: []string{"VulkanMemoryModel",}, Parameters: []Parameter{}, Version: "1.5", }, }, Bases: []*OperandKind {}, } OperandKindExecutionMode = &OperandKind { Kind: "ExecutionMode", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "Invocations", Value: 0, Capabilities: []string{"Geometry",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Number of <>'"},}, Version: "1.0", }, Enumerant{ Enumerant: "SpacingEqual", Value: 1, Capabilities: []string{"Tessellation",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "SpacingFractionalEven", Value: 2, Capabilities: []string{"Tessellation",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "SpacingFractionalOdd", Value: 3, Capabilities: []string{"Tessellation",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "VertexOrderCw", Value: 4, Capabilities: []string{"Tessellation",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "VertexOrderCcw", Value: 5, Capabilities: []string{"Tessellation",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "PixelCenterInteger", Value: 6, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "OriginUpperLeft", Value: 7, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "OriginLowerLeft", Value: 8, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "EarlyFragmentTests", Value: 9, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "PointMode", Value: 10, Capabilities: []string{"Tessellation",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Xfb", Value: 11, Capabilities: []string{"TransformFeedback",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "DepthReplacing", Value: 12, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "DepthGreater", Value: 14, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "DepthLess", Value: 15, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "DepthUnchanged", Value: 16, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "LocalSize", Value: 17, Capabilities: []string{}, Parameters: []Parameter{{OperandKindLiteralInteger, "'x size'"},{OperandKindLiteralInteger, "'y size'"},{OperandKindLiteralInteger, "'z size'"},}, Version: "1.0", }, Enumerant{ Enumerant: "LocalSizeHint", Value: 18, Capabilities: []string{"Kernel",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'x size'"},{OperandKindLiteralInteger, "'y size'"},{OperandKindLiteralInteger, "'z size'"},}, Version: "1.0", }, Enumerant{ Enumerant: "InputPoints", Value: 19, Capabilities: []string{"Geometry",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "InputLines", Value: 20, Capabilities: []string{"Geometry",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "InputLinesAdjacency", Value: 21, Capabilities: []string{"Geometry",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Triangles", Value: 22, Capabilities: []string{"Geometry","Tessellation",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "InputTrianglesAdjacency", Value: 23, Capabilities: []string{"Geometry",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Quads", Value: 24, Capabilities: []string{"Tessellation",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Isolines", Value: 25, Capabilities: []string{"Tessellation",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "OutputVertices", Value: 26, Capabilities: []string{"Geometry","Tessellation","MeshShadingNV","MeshShadingEXT",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Vertex count'"},}, Version: "1.0", }, Enumerant{ Enumerant: "OutputPoints", Value: 27, Capabilities: []string{"Geometry","MeshShadingNV","MeshShadingEXT",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "OutputLineStrip", Value: 28, Capabilities: []string{"Geometry",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "OutputTriangleStrip", Value: 29, Capabilities: []string{"Geometry",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "VecTypeHint", Value: 30, Capabilities: []string{"Kernel",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Vector type'"},}, Version: "1.0", }, Enumerant{ Enumerant: "ContractionOff", Value: 31, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Initializer", Value: 33, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "1.1", }, Enumerant{ Enumerant: "Finalizer", Value: 34, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "1.1", }, Enumerant{ Enumerant: "SubgroupSize", Value: 35, Capabilities: []string{"SubgroupDispatch",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Subgroup Size'"},}, Version: "1.1", }, Enumerant{ Enumerant: "SubgroupsPerWorkgroup", Value: 36, Capabilities: []string{"SubgroupDispatch",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Subgroups Per Workgroup'"},}, Version: "1.1", }, Enumerant{ Enumerant: "SubgroupsPerWorkgroupId", Value: 37, Capabilities: []string{"SubgroupDispatch",}, Parameters: []Parameter{{OperandKindIdRef, "'Subgroups Per Workgroup'"},}, Version: "1.2", }, Enumerant{ Enumerant: "LocalSizeId", Value: 38, Capabilities: []string{}, Parameters: []Parameter{{OperandKindIdRef, "'x size'"},{OperandKindIdRef, "'y size'"},{OperandKindIdRef, "'z size'"},}, Version: "1.2", }, Enumerant{ Enumerant: "LocalSizeHintId", Value: 39, Capabilities: []string{"Kernel",}, Parameters: []Parameter{{OperandKindIdRef, "'x size hint'"},{OperandKindIdRef, "'y size hint'"},{OperandKindIdRef, "'z size hint'"},}, Version: "1.2", }, Enumerant{ Enumerant: "NonCoherentColorAttachmentReadEXT", Value: 4169, Capabilities: []string{"TileImageColorReadAccessEXT",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "NonCoherentDepthAttachmentReadEXT", Value: 4170, Capabilities: []string{"TileImageDepthReadAccessEXT",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "NonCoherentStencilAttachmentReadEXT", Value: 4171, Capabilities: []string{"TileImageStencilReadAccessEXT",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "SubgroupUniformControlFlowKHR", Value: 4421, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "PostDepthCoverage", Value: 4446, Capabilities: []string{"SampleMaskPostDepthCoverage",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "DenormPreserve", Value: 4459, Capabilities: []string{"DenormPreserve",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Target Width'"},}, Version: "1.4", }, Enumerant{ Enumerant: "DenormFlushToZero", Value: 4460, Capabilities: []string{"DenormFlushToZero",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Target Width'"},}, Version: "1.4", }, Enumerant{ Enumerant: "SignedZeroInfNanPreserve", Value: 4461, Capabilities: []string{"SignedZeroInfNanPreserve",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Target Width'"},}, Version: "1.4", }, Enumerant{ Enumerant: "RoundingModeRTE", Value: 4462, Capabilities: []string{"RoundingModeRTE",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Target Width'"},}, Version: "1.4", }, Enumerant{ Enumerant: "RoundingModeRTZ", Value: 4463, Capabilities: []string{"RoundingModeRTZ",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Target Width'"},}, Version: "1.4", }, Enumerant{ Enumerant: "EarlyAndLateFragmentTestsAMD", Value: 5017, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "StencilRefReplacingEXT", Value: 5027, Capabilities: []string{"StencilExportEXT",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "CoalescingAMDX", Value: 5069, Capabilities: []string{"ShaderEnqueueAMDX",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "IsApiEntryAMDX", Value: 5070, Capabilities: []string{"ShaderEnqueueAMDX",}, Parameters: []Parameter{{OperandKindIdRef, "'Is Entry'"},}, Version: "None", }, Enumerant{ Enumerant: "MaxNodeRecursionAMDX", Value: 5071, Capabilities: []string{"ShaderEnqueueAMDX",}, Parameters: []Parameter{{OperandKindIdRef, "'Number of recursions'"},}, Version: "None", }, Enumerant{ Enumerant: "StaticNumWorkgroupsAMDX", Value: 5072, Capabilities: []string{"ShaderEnqueueAMDX",}, Parameters: []Parameter{{OperandKindIdRef, "'x size'"},{OperandKindIdRef, "'y size'"},{OperandKindIdRef, "'z size'"},}, Version: "None", }, Enumerant{ Enumerant: "ShaderIndexAMDX", Value: 5073, Capabilities: []string{"ShaderEnqueueAMDX",}, Parameters: []Parameter{{OperandKindIdRef, "'Shader Index'"},}, Version: "None", }, Enumerant{ Enumerant: "MaxNumWorkgroupsAMDX", Value: 5077, Capabilities: []string{"ShaderEnqueueAMDX",}, Parameters: []Parameter{{OperandKindIdRef, "'x size'"},{OperandKindIdRef, "'y size'"},{OperandKindIdRef, "'z size'"},}, Version: "None", }, Enumerant{ Enumerant: "StencilRefUnchangedFrontAMD", Value: 5079, Capabilities: []string{"StencilExportEXT",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "StencilRefGreaterFrontAMD", Value: 5080, Capabilities: []string{"StencilExportEXT",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "StencilRefLessFrontAMD", Value: 5081, Capabilities: []string{"StencilExportEXT",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "StencilRefUnchangedBackAMD", Value: 5082, Capabilities: []string{"StencilExportEXT",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "StencilRefGreaterBackAMD", Value: 5083, Capabilities: []string{"StencilExportEXT",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "StencilRefLessBackAMD", Value: 5084, Capabilities: []string{"StencilExportEXT",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "QuadDerivativesKHR", Value: 5088, Capabilities: []string{"QuadControlKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "RequireFullQuadsKHR", Value: 5089, Capabilities: []string{"QuadControlKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "SharesInputWithAMDX", Value: 5102, Capabilities: []string{"ShaderEnqueueAMDX",}, Parameters: []Parameter{{OperandKindIdRef, "'Node Name'"},{OperandKindIdRef, "'Shader Index'"},}, Version: "None", }, Enumerant{ Enumerant: "OutputLinesEXT", Value: 5269, Capabilities: []string{"MeshShadingNV","MeshShadingEXT",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "OutputPrimitivesEXT", Value: 5270, Capabilities: []string{"MeshShadingNV","MeshShadingEXT",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Primitive count'"},}, Version: "None", }, Enumerant{ Enumerant: "DerivativeGroupQuadsKHR", Value: 5289, Capabilities: []string{"ComputeDerivativeGroupQuadsNV","ComputeDerivativeGroupQuadsKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "DerivativeGroupLinearKHR", Value: 5290, Capabilities: []string{"ComputeDerivativeGroupLinearNV","ComputeDerivativeGroupLinearKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "OutputTrianglesEXT", Value: 5298, Capabilities: []string{"MeshShadingNV","MeshShadingEXT",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "PixelInterlockOrderedEXT", Value: 5366, Capabilities: []string{"FragmentShaderPixelInterlockEXT",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "PixelInterlockUnorderedEXT", Value: 5367, Capabilities: []string{"FragmentShaderPixelInterlockEXT",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "SampleInterlockOrderedEXT", Value: 5368, Capabilities: []string{"FragmentShaderSampleInterlockEXT",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "SampleInterlockUnorderedEXT", Value: 5369, Capabilities: []string{"FragmentShaderSampleInterlockEXT",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ShadingRateInterlockOrderedEXT", Value: 5370, Capabilities: []string{"FragmentShaderShadingRateInterlockEXT",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ShadingRateInterlockUnorderedEXT", Value: 5371, Capabilities: []string{"FragmentShaderShadingRateInterlockEXT",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "SharedLocalMemorySizeINTEL", Value: 5618, Capabilities: []string{"VectorComputeINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Size'"},}, Version: "None", }, Enumerant{ Enumerant: "RoundingModeRTPINTEL", Value: 5620, Capabilities: []string{"RoundToInfinityINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Target Width'"},}, Version: "None", }, Enumerant{ Enumerant: "RoundingModeRTNINTEL", Value: 5621, Capabilities: []string{"RoundToInfinityINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Target Width'"},}, Version: "None", }, Enumerant{ Enumerant: "FloatingPointModeALTINTEL", Value: 5622, Capabilities: []string{"RoundToInfinityINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Target Width'"},}, Version: "None", }, Enumerant{ Enumerant: "FloatingPointModeIEEEINTEL", Value: 5623, Capabilities: []string{"RoundToInfinityINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Target Width'"},}, Version: "None", }, Enumerant{ Enumerant: "MaxWorkgroupSizeINTEL", Value: 5893, Capabilities: []string{"KernelAttributesINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'max_x_size'"},{OperandKindLiteralInteger, "'max_y_size'"},{OperandKindLiteralInteger, "'max_z_size'"},}, Version: "None", }, Enumerant{ Enumerant: "MaxWorkDimINTEL", Value: 5894, Capabilities: []string{"KernelAttributesINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'max_dimensions'"},}, Version: "None", }, Enumerant{ Enumerant: "NoGlobalOffsetINTEL", Value: 5895, Capabilities: []string{"KernelAttributesINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "NumSIMDWorkitemsINTEL", Value: 5896, Capabilities: []string{"FPGAKernelAttributesINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'vector_width'"},}, Version: "None", }, Enumerant{ Enumerant: "SchedulerTargetFmaxMhzINTEL", Value: 5903, Capabilities: []string{"FPGAKernelAttributesINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'target_fmax'"},}, Version: "None", }, Enumerant{ Enumerant: "MaximallyReconvergesKHR", Value: 6023, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "FPFastMathDefault", Value: 6028, Capabilities: []string{"FloatControls2",}, Parameters: []Parameter{{OperandKindIdRef, "'Target Type'"},{OperandKindIdRef, "'Fast-Math Mode'"},}, Version: "None", }, Enumerant{ Enumerant: "StreamingInterfaceINTEL", Value: 6154, Capabilities: []string{"FPGAKernelAttributesINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'StallFreeReturn'"},}, Version: "None", }, Enumerant{ Enumerant: "RegisterMapInterfaceINTEL", Value: 6160, Capabilities: []string{"FPGAKernelAttributesv2INTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'WaitForDoneWrite'"},}, Version: "None", }, Enumerant{ Enumerant: "NamedBarrierCountINTEL", Value: 6417, Capabilities: []string{"VectorComputeINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Barrier Count'"},}, Version: "None", }, Enumerant{ Enumerant: "MaximumRegistersINTEL", Value: 6461, Capabilities: []string{"RegisterLimitsINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Number of Registers'"},}, Version: "None", }, Enumerant{ Enumerant: "MaximumRegistersIdINTEL", Value: 6462, Capabilities: []string{"RegisterLimitsINTEL",}, Parameters: []Parameter{{OperandKindIdRef, "'Number of Registers'"},}, Version: "None", }, Enumerant{ Enumerant: "NamedMaximumRegistersINTEL", Value: 6463, Capabilities: []string{"RegisterLimitsINTEL",}, Parameters: []Parameter{{OperandKindNamedMaximumNumberOfRegisters, "'Named Maximum Number of Registers'"},}, Version: "None", }, }, Bases: []*OperandKind {}, } OperandKindStorageClass = &OperandKind { Kind: "StorageClass", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "UniformConstant", Value: 0, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Input", Value: 1, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Uniform", Value: 2, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Output", Value: 3, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Workgroup", Value: 4, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "CrossWorkgroup", Value: 5, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Private", Value: 6, Capabilities: []string{"Shader","VectorComputeINTEL",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Function", Value: 7, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Generic", Value: 8, Capabilities: []string{"GenericPointer",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "PushConstant", Value: 9, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "AtomicCounter", Value: 10, Capabilities: []string{"AtomicStorage",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Image", Value: 11, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "StorageBuffer", Value: 12, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.3", }, Enumerant{ Enumerant: "TileImageEXT", Value: 4172, Capabilities: []string{"TileImageColorReadAccessEXT",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "NodePayloadAMDX", Value: 5068, Capabilities: []string{"ShaderEnqueueAMDX",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "CallableDataKHR", Value: 5328, Capabilities: []string{"RayTracingNV","RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "IncomingCallableDataKHR", Value: 5329, Capabilities: []string{"RayTracingNV","RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "RayPayloadKHR", Value: 5338, Capabilities: []string{"RayTracingNV","RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "HitAttributeKHR", Value: 5339, Capabilities: []string{"RayTracingNV","RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "IncomingRayPayloadKHR", Value: 5342, Capabilities: []string{"RayTracingNV","RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ShaderRecordBufferKHR", Value: 5343, Capabilities: []string{"RayTracingNV","RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "PhysicalStorageBuffer", Value: 5349, Capabilities: []string{"PhysicalStorageBufferAddresses",}, Parameters: []Parameter{}, Version: "1.5", }, Enumerant{ Enumerant: "HitObjectAttributeNV", Value: 5385, Capabilities: []string{"ShaderInvocationReorderNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "TaskPayloadWorkgroupEXT", Value: 5402, Capabilities: []string{"MeshShadingEXT",}, Parameters: []Parameter{}, Version: "1.4", }, Enumerant{ Enumerant: "CodeSectionINTEL", Value: 5605, Capabilities: []string{"FunctionPointersINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "DeviceOnlyINTEL", Value: 5936, Capabilities: []string{"USMStorageClassesINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "HostOnlyINTEL", Value: 5937, Capabilities: []string{"USMStorageClassesINTEL",}, Parameters: []Parameter{}, Version: "None", }, }, Bases: []*OperandKind {}, } OperandKindDim = &OperandKind { Kind: "Dim", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "1D", Value: 0, Capabilities: []string{"Sampled1D",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "2D", Value: 1, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "3D", Value: 2, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Cube", Value: 3, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Rect", Value: 4, Capabilities: []string{"SampledRect",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Buffer", Value: 5, Capabilities: []string{"SampledBuffer",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "SubpassData", Value: 6, Capabilities: []string{"InputAttachment",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "TileImageDataEXT", Value: 4173, Capabilities: []string{"TileImageColorReadAccessEXT",}, Parameters: []Parameter{}, Version: "None", }, }, Bases: []*OperandKind {}, } OperandKindSamplerAddressingMode = &OperandKind { Kind: "SamplerAddressingMode", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "None", Value: 0, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "ClampToEdge", Value: 1, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Clamp", Value: 2, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Repeat", Value: 3, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "RepeatMirrored", Value: 4, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, }, Bases: []*OperandKind {}, } OperandKindSamplerFilterMode = &OperandKind { Kind: "SamplerFilterMode", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "Nearest", Value: 0, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Linear", Value: 1, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, }, Bases: []*OperandKind {}, } OperandKindImageFormat = &OperandKind { Kind: "ImageFormat", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "Unknown", Value: 0, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Rgba32f", Value: 1, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Rgba16f", Value: 2, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "R32f", Value: 3, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Rgba8", Value: 4, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Rgba8Snorm", Value: 5, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Rg32f", Value: 6, Capabilities: []string{"StorageImageExtendedFormats",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Rg16f", Value: 7, Capabilities: []string{"StorageImageExtendedFormats",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "R11fG11fB10f", Value: 8, Capabilities: []string{"StorageImageExtendedFormats",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "R16f", Value: 9, Capabilities: []string{"StorageImageExtendedFormats",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Rgba16", Value: 10, Capabilities: []string{"StorageImageExtendedFormats",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Rgb10A2", Value: 11, Capabilities: []string{"StorageImageExtendedFormats",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Rg16", Value: 12, Capabilities: []string{"StorageImageExtendedFormats",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Rg8", Value: 13, Capabilities: []string{"StorageImageExtendedFormats",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "R16", Value: 14, Capabilities: []string{"StorageImageExtendedFormats",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "R8", Value: 15, Capabilities: []string{"StorageImageExtendedFormats",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Rgba16Snorm", Value: 16, Capabilities: []string{"StorageImageExtendedFormats",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Rg16Snorm", Value: 17, Capabilities: []string{"StorageImageExtendedFormats",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Rg8Snorm", Value: 18, Capabilities: []string{"StorageImageExtendedFormats",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "R16Snorm", Value: 19, Capabilities: []string{"StorageImageExtendedFormats",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "R8Snorm", Value: 20, Capabilities: []string{"StorageImageExtendedFormats",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Rgba32i", Value: 21, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Rgba16i", Value: 22, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Rgba8i", Value: 23, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "R32i", Value: 24, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Rg32i", Value: 25, Capabilities: []string{"StorageImageExtendedFormats",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Rg16i", Value: 26, Capabilities: []string{"StorageImageExtendedFormats",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Rg8i", Value: 27, Capabilities: []string{"StorageImageExtendedFormats",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "R16i", Value: 28, Capabilities: []string{"StorageImageExtendedFormats",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "R8i", Value: 29, Capabilities: []string{"StorageImageExtendedFormats",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Rgba32ui", Value: 30, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Rgba16ui", Value: 31, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Rgba8ui", Value: 32, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "R32ui", Value: 33, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Rgb10a2ui", Value: 34, Capabilities: []string{"StorageImageExtendedFormats",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Rg32ui", Value: 35, Capabilities: []string{"StorageImageExtendedFormats",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Rg16ui", Value: 36, Capabilities: []string{"StorageImageExtendedFormats",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Rg8ui", Value: 37, Capabilities: []string{"StorageImageExtendedFormats",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "R16ui", Value: 38, Capabilities: []string{"StorageImageExtendedFormats",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "R8ui", Value: 39, Capabilities: []string{"StorageImageExtendedFormats",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "R64ui", Value: 40, Capabilities: []string{"Int64ImageEXT",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "R64i", Value: 41, Capabilities: []string{"Int64ImageEXT",}, Parameters: []Parameter{}, Version: "1.0", }, }, Bases: []*OperandKind {}, } OperandKindImageChannelOrder = &OperandKind { Kind: "ImageChannelOrder", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "R", Value: 0, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "A", Value: 1, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "RG", Value: 2, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "RA", Value: 3, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "RGB", Value: 4, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "RGBA", Value: 5, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "BGRA", Value: 6, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "ARGB", Value: 7, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Intensity", Value: 8, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Luminance", Value: 9, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Rx", Value: 10, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "RGx", Value: 11, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "RGBx", Value: 12, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Depth", Value: 13, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "DepthStencil", Value: 14, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "sRGB", Value: 15, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "sRGBx", Value: 16, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "sRGBA", Value: 17, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "sBGRA", Value: 18, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "ABGR", Value: 19, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, }, Bases: []*OperandKind {}, } OperandKindImageChannelDataType = &OperandKind { Kind: "ImageChannelDataType", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "SnormInt8", Value: 0, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "SnormInt16", Value: 1, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "UnormInt8", Value: 2, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "UnormInt16", Value: 3, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "UnormShort565", Value: 4, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "UnormShort555", Value: 5, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "UnormInt101010", Value: 6, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "SignedInt8", Value: 7, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "SignedInt16", Value: 8, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "SignedInt32", Value: 9, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "UnsignedInt8", Value: 10, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "UnsignedInt16", Value: 11, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "UnsignedInt32", Value: 12, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "HalfFloat", Value: 13, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Float", Value: 14, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "UnormInt24", Value: 15, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "UnormInt101010_2", Value: 16, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "UnsignedIntRaw10EXT", Value: 19, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "UnsignedIntRaw12EXT", Value: 20, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "UnormInt2_101010EXT", Value: 21, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, }, Bases: []*OperandKind {}, } OperandKindFPRoundingMode = &OperandKind { Kind: "FPRoundingMode", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "RTE", Value: 0, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "RTZ", Value: 1, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "RTP", Value: 2, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "RTN", Value: 3, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, }, Bases: []*OperandKind {}, } OperandKindFPDenormMode = &OperandKind { Kind: "FPDenormMode", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "Preserve", Value: 0, Capabilities: []string{"FunctionFloatControlINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "FlushToZero", Value: 1, Capabilities: []string{"FunctionFloatControlINTEL",}, Parameters: []Parameter{}, Version: "None", }, }, Bases: []*OperandKind {}, } OperandKindQuantizationModes = &OperandKind { Kind: "QuantizationModes", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "TRN", Value: 0, Capabilities: []string{"ArbitraryPrecisionFixedPointINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "TRN_ZERO", Value: 1, Capabilities: []string{"ArbitraryPrecisionFixedPointINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "RND", Value: 2, Capabilities: []string{"ArbitraryPrecisionFixedPointINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "RND_ZERO", Value: 3, Capabilities: []string{"ArbitraryPrecisionFixedPointINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "RND_INF", Value: 4, Capabilities: []string{"ArbitraryPrecisionFixedPointINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "RND_MIN_INF", Value: 5, Capabilities: []string{"ArbitraryPrecisionFixedPointINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "RND_CONV", Value: 6, Capabilities: []string{"ArbitraryPrecisionFixedPointINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "RND_CONV_ODD", Value: 7, Capabilities: []string{"ArbitraryPrecisionFixedPointINTEL",}, Parameters: []Parameter{}, Version: "None", }, }, Bases: []*OperandKind {}, } OperandKindFPOperationMode = &OperandKind { Kind: "FPOperationMode", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "IEEE", Value: 0, Capabilities: []string{"FunctionFloatControlINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ALT", Value: 1, Capabilities: []string{"FunctionFloatControlINTEL",}, Parameters: []Parameter{}, Version: "None", }, }, Bases: []*OperandKind {}, } OperandKindOverflowModes = &OperandKind { Kind: "OverflowModes", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "WRAP", Value: 0, Capabilities: []string{"ArbitraryPrecisionFixedPointINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "SAT", Value: 1, Capabilities: []string{"ArbitraryPrecisionFixedPointINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "SAT_ZERO", Value: 2, Capabilities: []string{"ArbitraryPrecisionFixedPointINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "SAT_SYM", Value: 3, Capabilities: []string{"ArbitraryPrecisionFixedPointINTEL",}, Parameters: []Parameter{}, Version: "None", }, }, Bases: []*OperandKind {}, } OperandKindLinkageType = &OperandKind { Kind: "LinkageType", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "Export", Value: 0, Capabilities: []string{"Linkage",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Import", Value: 1, Capabilities: []string{"Linkage",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "LinkOnceODR", Value: 2, Capabilities: []string{"Linkage",}, Parameters: []Parameter{}, Version: "None", }, }, Bases: []*OperandKind {}, } OperandKindAccessQualifier = &OperandKind { Kind: "AccessQualifier", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "ReadOnly", Value: 0, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "WriteOnly", Value: 1, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "ReadWrite", Value: 2, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "1.0", }, }, Bases: []*OperandKind {}, } OperandKindHostAccessQualifier = &OperandKind { Kind: "HostAccessQualifier", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "NoneINTEL", Value: 0, Capabilities: []string{"GlobalVariableHostAccessINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ReadINTEL", Value: 1, Capabilities: []string{"GlobalVariableHostAccessINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "WriteINTEL", Value: 2, Capabilities: []string{"GlobalVariableHostAccessINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ReadWriteINTEL", Value: 3, Capabilities: []string{"GlobalVariableHostAccessINTEL",}, Parameters: []Parameter{}, Version: "None", }, }, Bases: []*OperandKind {}, } OperandKindFunctionParameterAttribute = &OperandKind { Kind: "FunctionParameterAttribute", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "Zext", Value: 0, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Sext", Value: 1, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "ByVal", Value: 2, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Sret", Value: 3, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "NoAlias", Value: 4, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "NoCapture", Value: 5, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "NoWrite", Value: 6, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "NoReadWrite", Value: 7, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "RuntimeAlignedINTEL", Value: 5940, Capabilities: []string{"RuntimeAlignedAttributeINTEL",}, Parameters: []Parameter{}, Version: "1.0", }, }, Bases: []*OperandKind {}, } OperandKindDecoration = &OperandKind { Kind: "Decoration", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "RelaxedPrecision", Value: 0, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "SpecId", Value: 1, Capabilities: []string{"Shader","Kernel",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Specialization Constant ID'"},}, Version: "1.0", }, Enumerant{ Enumerant: "Block", Value: 2, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "BufferBlock", Value: 3, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "RowMajor", Value: 4, Capabilities: []string{"Matrix",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "ColMajor", Value: 5, Capabilities: []string{"Matrix",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "ArrayStride", Value: 6, Capabilities: []string{"Shader",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Array Stride'"},}, Version: "1.0", }, Enumerant{ Enumerant: "MatrixStride", Value: 7, Capabilities: []string{"Matrix",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Matrix Stride'"},}, Version: "1.0", }, Enumerant{ Enumerant: "GLSLShared", Value: 8, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "GLSLPacked", Value: 9, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "CPacked", Value: 10, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "BuiltIn", Value: 11, Capabilities: []string{}, Parameters: []Parameter{{OperandKindBuiltIn, ""},}, Version: "1.0", }, Enumerant{ Enumerant: "NoPerspective", Value: 13, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Flat", Value: 14, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Patch", Value: 15, Capabilities: []string{"Tessellation",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Centroid", Value: 16, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Sample", Value: 17, Capabilities: []string{"SampleRateShading",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Invariant", Value: 18, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Restrict", Value: 19, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Aliased", Value: 20, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Volatile", Value: 21, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Constant", Value: 22, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Coherent", Value: 23, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "NonWritable", Value: 24, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "NonReadable", Value: 25, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Uniform", Value: 26, Capabilities: []string{"Shader","UniformDecoration",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "UniformId", Value: 27, Capabilities: []string{"Shader","UniformDecoration",}, Parameters: []Parameter{{OperandKindIdScope, "'Execution'"},}, Version: "1.4", }, Enumerant{ Enumerant: "SaturatedConversion", Value: 28, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Stream", Value: 29, Capabilities: []string{"GeometryStreams",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Stream Number'"},}, Version: "1.0", }, Enumerant{ Enumerant: "Location", Value: 30, Capabilities: []string{"Shader",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Location'"},}, Version: "1.0", }, Enumerant{ Enumerant: "Component", Value: 31, Capabilities: []string{"Shader",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Component'"},}, Version: "1.0", }, Enumerant{ Enumerant: "Index", Value: 32, Capabilities: []string{"Shader",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Index'"},}, Version: "1.0", }, Enumerant{ Enumerant: "Binding", Value: 33, Capabilities: []string{"Shader",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Binding Point'"},}, Version: "1.0", }, Enumerant{ Enumerant: "DescriptorSet", Value: 34, Capabilities: []string{"Shader",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Descriptor Set'"},}, Version: "1.0", }, Enumerant{ Enumerant: "Offset", Value: 35, Capabilities: []string{"Shader",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Byte Offset'"},}, Version: "1.0", }, Enumerant{ Enumerant: "XfbBuffer", Value: 36, Capabilities: []string{"TransformFeedback",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'XFB Buffer Number'"},}, Version: "1.0", }, Enumerant{ Enumerant: "XfbStride", Value: 37, Capabilities: []string{"TransformFeedback",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'XFB Stride'"},}, Version: "1.0", }, Enumerant{ Enumerant: "FuncParamAttr", Value: 38, Capabilities: []string{"Kernel",}, Parameters: []Parameter{{OperandKindFunctionParameterAttribute, "'Function Parameter Attribute'"},}, Version: "1.0", }, Enumerant{ Enumerant: "FPRoundingMode", Value: 39, Capabilities: []string{}, Parameters: []Parameter{{OperandKindFPRoundingMode, "'Floating-Point Rounding Mode'"},}, Version: "1.0", }, Enumerant{ Enumerant: "FPFastMathMode", Value: 40, Capabilities: []string{"Kernel","FloatControls2",}, Parameters: []Parameter{{OperandKindFPFastMathMode, "'Fast-Math Mode'"},}, Version: "1.0", }, Enumerant{ Enumerant: "LinkageAttributes", Value: 41, Capabilities: []string{"Linkage",}, Parameters: []Parameter{{OperandKindLiteralString, "'Name'"},{OperandKindLinkageType, "'Linkage Type'"},}, Version: "1.0", }, Enumerant{ Enumerant: "NoContraction", Value: 42, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "InputAttachmentIndex", Value: 43, Capabilities: []string{"InputAttachment",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Attachment Index'"},}, Version: "1.0", }, Enumerant{ Enumerant: "Alignment", Value: 44, Capabilities: []string{"Kernel",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Alignment'"},}, Version: "1.0", }, Enumerant{ Enumerant: "MaxByteOffset", Value: 45, Capabilities: []string{"Addresses",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Max Byte Offset'"},}, Version: "1.1", }, Enumerant{ Enumerant: "AlignmentId", Value: 46, Capabilities: []string{"Kernel",}, Parameters: []Parameter{{OperandKindIdRef, "'Alignment'"},}, Version: "1.2", }, Enumerant{ Enumerant: "MaxByteOffsetId", Value: 47, Capabilities: []string{"Addresses",}, Parameters: []Parameter{{OperandKindIdRef, "'Max Byte Offset'"},}, Version: "1.2", }, Enumerant{ Enumerant: "NoSignedWrap", Value: 4469, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.4", }, Enumerant{ Enumerant: "NoUnsignedWrap", Value: 4470, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.4", }, Enumerant{ Enumerant: "WeightTextureQCOM", Value: 4487, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "BlockMatchTextureQCOM", Value: 4488, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "BlockMatchSamplerQCOM", Value: 4499, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ExplicitInterpAMD", Value: 4999, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "NodeSharesPayloadLimitsWithAMDX", Value: 5019, Capabilities: []string{"ShaderEnqueueAMDX",}, Parameters: []Parameter{{OperandKindIdRef, "'Payload Type'"},}, Version: "None", }, Enumerant{ Enumerant: "NodeMaxPayloadsAMDX", Value: 5020, Capabilities: []string{"ShaderEnqueueAMDX",}, Parameters: []Parameter{{OperandKindIdRef, "'Max number of payloads'"},}, Version: "None", }, Enumerant{ Enumerant: "TrackFinishWritingAMDX", Value: 5078, Capabilities: []string{"ShaderEnqueueAMDX",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "PayloadNodeNameAMDX", Value: 5091, Capabilities: []string{"ShaderEnqueueAMDX",}, Parameters: []Parameter{{OperandKindIdRef, "'Node Name'"},}, Version: "None", }, Enumerant{ Enumerant: "PayloadNodeBaseIndexAMDX", Value: 5098, Capabilities: []string{"ShaderEnqueueAMDX",}, Parameters: []Parameter{{OperandKindIdRef, "'Base Index'"},}, Version: "None", }, Enumerant{ Enumerant: "PayloadNodeSparseArrayAMDX", Value: 5099, Capabilities: []string{"ShaderEnqueueAMDX",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "PayloadNodeArraySizeAMDX", Value: 5100, Capabilities: []string{"ShaderEnqueueAMDX",}, Parameters: []Parameter{{OperandKindIdRef, "'Array Size'"},}, Version: "None", }, Enumerant{ Enumerant: "PayloadDispatchIndirectAMDX", Value: 5105, Capabilities: []string{"ShaderEnqueueAMDX",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "OverrideCoverageNV", Value: 5248, Capabilities: []string{"SampleMaskOverrideCoverageNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "PassthroughNV", Value: 5250, Capabilities: []string{"GeometryShaderPassthroughNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ViewportRelativeNV", Value: 5252, Capabilities: []string{"ShaderViewportMaskNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "SecondaryViewportRelativeNV", Value: 5256, Capabilities: []string{"ShaderStereoViewNV",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Offset'"},}, Version: "None", }, Enumerant{ Enumerant: "PerPrimitiveEXT", Value: 5271, Capabilities: []string{"MeshShadingNV","MeshShadingEXT",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "PerViewNV", Value: 5272, Capabilities: []string{"MeshShadingNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "PerTaskNV", Value: 5273, Capabilities: []string{"MeshShadingNV","MeshShadingEXT",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "PerVertexKHR", Value: 5285, Capabilities: []string{"FragmentBarycentricKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "NonUniform", Value: 5300, Capabilities: []string{"ShaderNonUniform",}, Parameters: []Parameter{}, Version: "1.5", }, Enumerant{ Enumerant: "RestrictPointer", Value: 5355, Capabilities: []string{"PhysicalStorageBufferAddresses",}, Parameters: []Parameter{}, Version: "1.5", }, Enumerant{ Enumerant: "AliasedPointer", Value: 5356, Capabilities: []string{"PhysicalStorageBufferAddresses",}, Parameters: []Parameter{}, Version: "1.5", }, Enumerant{ Enumerant: "HitObjectShaderRecordBufferNV", Value: 5386, Capabilities: []string{"ShaderInvocationReorderNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "BindlessSamplerNV", Value: 5398, Capabilities: []string{"BindlessTextureNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "BindlessImageNV", Value: 5399, Capabilities: []string{"BindlessTextureNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "BoundSamplerNV", Value: 5400, Capabilities: []string{"BindlessTextureNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "BoundImageNV", Value: 5401, Capabilities: []string{"BindlessTextureNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "SIMTCallINTEL", Value: 5599, Capabilities: []string{"VectorComputeINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'N'"},}, Version: "None", }, Enumerant{ Enumerant: "ReferencedIndirectlyINTEL", Value: 5602, Capabilities: []string{"IndirectReferencesINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ClobberINTEL", Value: 5607, Capabilities: []string{"AsmINTEL",}, Parameters: []Parameter{{OperandKindLiteralString, "'Register'"},}, Version: "None", }, Enumerant{ Enumerant: "SideEffectsINTEL", Value: 5608, Capabilities: []string{"AsmINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "VectorComputeVariableINTEL", Value: 5624, Capabilities: []string{"VectorComputeINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "FuncParamIOKindINTEL", Value: 5625, Capabilities: []string{"VectorComputeINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Kind'"},}, Version: "None", }, Enumerant{ Enumerant: "VectorComputeFunctionINTEL", Value: 5626, Capabilities: []string{"VectorComputeINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "StackCallINTEL", Value: 5627, Capabilities: []string{"VectorComputeINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "GlobalVariableOffsetINTEL", Value: 5628, Capabilities: []string{"VectorComputeINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Offset'"},}, Version: "None", }, Enumerant{ Enumerant: "CounterBuffer", Value: 5634, Capabilities: []string{}, Parameters: []Parameter{{OperandKindIdRef, "'Counter Buffer'"},}, Version: "1.4", }, Enumerant{ Enumerant: "UserSemantic", Value: 5635, Capabilities: []string{}, Parameters: []Parameter{{OperandKindLiteralString, "'Semantic'"},}, Version: "1.4", }, Enumerant{ Enumerant: "UserTypeGOOGLE", Value: 5636, Capabilities: []string{}, Parameters: []Parameter{{OperandKindLiteralString, "'User Type'"},}, Version: "None", }, Enumerant{ Enumerant: "FunctionRoundingModeINTEL", Value: 5822, Capabilities: []string{"FunctionFloatControlINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Target Width'"},{OperandKindFPRoundingMode, "'FP Rounding Mode'"},}, Version: "None", }, Enumerant{ Enumerant: "FunctionDenormModeINTEL", Value: 5823, Capabilities: []string{"FunctionFloatControlINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Target Width'"},{OperandKindFPDenormMode, "'FP Denorm Mode'"},}, Version: "None", }, Enumerant{ Enumerant: "RegisterINTEL", Value: 5825, Capabilities: []string{"FPGAMemoryAttributesINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "MemoryINTEL", Value: 5826, Capabilities: []string{"FPGAMemoryAttributesINTEL",}, Parameters: []Parameter{{OperandKindLiteralString, "'Memory Type'"},}, Version: "None", }, Enumerant{ Enumerant: "NumbanksINTEL", Value: 5827, Capabilities: []string{"FPGAMemoryAttributesINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Banks'"},}, Version: "None", }, Enumerant{ Enumerant: "BankwidthINTEL", Value: 5828, Capabilities: []string{"FPGAMemoryAttributesINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Bank Width'"},}, Version: "None", }, Enumerant{ Enumerant: "MaxPrivateCopiesINTEL", Value: 5829, Capabilities: []string{"FPGAMemoryAttributesINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Maximum Copies'"},}, Version: "None", }, Enumerant{ Enumerant: "SinglepumpINTEL", Value: 5830, Capabilities: []string{"FPGAMemoryAttributesINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "DoublepumpINTEL", Value: 5831, Capabilities: []string{"FPGAMemoryAttributesINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "MaxReplicatesINTEL", Value: 5832, Capabilities: []string{"FPGAMemoryAttributesINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Maximum Replicates'"},}, Version: "None", }, Enumerant{ Enumerant: "SimpleDualPortINTEL", Value: 5833, Capabilities: []string{"FPGAMemoryAttributesINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "MergeINTEL", Value: 5834, Capabilities: []string{"FPGAMemoryAttributesINTEL",}, Parameters: []Parameter{{OperandKindLiteralString, "'Merge Key'"},{OperandKindLiteralString, "'Merge Type'"},}, Version: "None", }, Enumerant{ Enumerant: "BankBitsINTEL", Value: 5835, Capabilities: []string{"FPGAMemoryAttributesINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Bank Bits'"},}, Version: "None", }, Enumerant{ Enumerant: "ForcePow2DepthINTEL", Value: 5836, Capabilities: []string{"FPGAMemoryAttributesINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Force Key'"},}, Version: "None", }, Enumerant{ Enumerant: "StridesizeINTEL", Value: 5883, Capabilities: []string{"FPGAMemoryAttributesINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Stride Size'"},}, Version: "None", }, Enumerant{ Enumerant: "WordsizeINTEL", Value: 5884, Capabilities: []string{"FPGAMemoryAttributesINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Word Size'"},}, Version: "None", }, Enumerant{ Enumerant: "TrueDualPortINTEL", Value: 5885, Capabilities: []string{"FPGAMemoryAttributesINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "BurstCoalesceINTEL", Value: 5899, Capabilities: []string{"FPGAMemoryAccessesINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "CacheSizeINTEL", Value: 5900, Capabilities: []string{"FPGAMemoryAccessesINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Cache Size in bytes'"},}, Version: "None", }, Enumerant{ Enumerant: "DontStaticallyCoalesceINTEL", Value: 5901, Capabilities: []string{"FPGAMemoryAccessesINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "PrefetchINTEL", Value: 5902, Capabilities: []string{"FPGAMemoryAccessesINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Prefetcher Size in bytes'"},}, Version: "None", }, Enumerant{ Enumerant: "StallEnableINTEL", Value: 5905, Capabilities: []string{"FPGAClusterAttributesINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "FuseLoopsInFunctionINTEL", Value: 5907, Capabilities: []string{"LoopFuseINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "MathOpDSPModeINTEL", Value: 5909, Capabilities: []string{"FPGADSPControlINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Mode'"},{OperandKindLiteralInteger, "'Propagate'"},}, Version: "None", }, Enumerant{ Enumerant: "AliasScopeINTEL", Value: 5914, Capabilities: []string{"MemoryAccessAliasingINTEL",}, Parameters: []Parameter{{OperandKindIdRef, "'Aliasing Scopes List'"},}, Version: "None", }, Enumerant{ Enumerant: "NoAliasINTEL", Value: 5915, Capabilities: []string{"MemoryAccessAliasingINTEL",}, Parameters: []Parameter{{OperandKindIdRef, "'Aliasing Scopes List'"},}, Version: "None", }, Enumerant{ Enumerant: "InitiationIntervalINTEL", Value: 5917, Capabilities: []string{"FPGAInvocationPipeliningAttributesINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Cycles'"},}, Version: "None", }, Enumerant{ Enumerant: "MaxConcurrencyINTEL", Value: 5918, Capabilities: []string{"FPGAInvocationPipeliningAttributesINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Invocations'"},}, Version: "None", }, Enumerant{ Enumerant: "PipelineEnableINTEL", Value: 5919, Capabilities: []string{"FPGAInvocationPipeliningAttributesINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Enable'"},}, Version: "None", }, Enumerant{ Enumerant: "BufferLocationINTEL", Value: 5921, Capabilities: []string{"FPGABufferLocationINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Buffer Location ID'"},}, Version: "None", }, Enumerant{ Enumerant: "IOPipeStorageINTEL", Value: 5944, Capabilities: []string{"IOPipesINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'IO Pipe ID'"},}, Version: "None", }, Enumerant{ Enumerant: "FunctionFloatingPointModeINTEL", Value: 6080, Capabilities: []string{"FunctionFloatControlINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Target Width'"},{OperandKindFPOperationMode, "'FP Operation Mode'"},}, Version: "None", }, Enumerant{ Enumerant: "SingleElementVectorINTEL", Value: 6085, Capabilities: []string{"VectorComputeINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "VectorComputeCallableFunctionINTEL", Value: 6087, Capabilities: []string{"VectorComputeINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "MediaBlockIOINTEL", Value: 6140, Capabilities: []string{"VectorComputeINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "StallFreeINTEL", Value: 6151, Capabilities: []string{"FPGAClusterAttributesV2INTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "FPMaxErrorDecorationINTEL", Value: 6170, Capabilities: []string{"FPMaxErrorINTEL",}, Parameters: []Parameter{{OperandKindLiteralFloat, "'Max Error'"},}, Version: "None", }, Enumerant{ Enumerant: "LatencyControlLabelINTEL", Value: 6172, Capabilities: []string{"FPGALatencyControlINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Latency Label'"},}, Version: "None", }, Enumerant{ Enumerant: "LatencyControlConstraintINTEL", Value: 6173, Capabilities: []string{"FPGALatencyControlINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Relative To'"},{OperandKindLiteralInteger, "'Control Type'"},{OperandKindLiteralInteger, "'Relative Cycle'"},}, Version: "None", }, Enumerant{ Enumerant: "ConduitKernelArgumentINTEL", Value: 6175, Capabilities: []string{"FPGAArgumentInterfacesINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "RegisterMapKernelArgumentINTEL", Value: 6176, Capabilities: []string{"FPGAArgumentInterfacesINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "MMHostInterfaceAddressWidthINTEL", Value: 6177, Capabilities: []string{"FPGAArgumentInterfacesINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'AddressWidth'"},}, Version: "None", }, Enumerant{ Enumerant: "MMHostInterfaceDataWidthINTEL", Value: 6178, Capabilities: []string{"FPGAArgumentInterfacesINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'DataWidth'"},}, Version: "None", }, Enumerant{ Enumerant: "MMHostInterfaceLatencyINTEL", Value: 6179, Capabilities: []string{"FPGAArgumentInterfacesINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Latency'"},}, Version: "None", }, Enumerant{ Enumerant: "MMHostInterfaceReadWriteModeINTEL", Value: 6180, Capabilities: []string{"FPGAArgumentInterfacesINTEL",}, Parameters: []Parameter{{OperandKindAccessQualifier, "'ReadWriteMode'"},}, Version: "None", }, Enumerant{ Enumerant: "MMHostInterfaceMaxBurstINTEL", Value: 6181, Capabilities: []string{"FPGAArgumentInterfacesINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'MaxBurstCount'"},}, Version: "None", }, Enumerant{ Enumerant: "MMHostInterfaceWaitRequestINTEL", Value: 6182, Capabilities: []string{"FPGAArgumentInterfacesINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Waitrequest'"},}, Version: "None", }, Enumerant{ Enumerant: "StableKernelArgumentINTEL", Value: 6183, Capabilities: []string{"FPGAArgumentInterfacesINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "HostAccessINTEL", Value: 6188, Capabilities: []string{"GlobalVariableHostAccessINTEL",}, Parameters: []Parameter{{OperandKindHostAccessQualifier, "'Access'"},{OperandKindLiteralString, "'Name'"},}, Version: "None", }, Enumerant{ Enumerant: "InitModeINTEL", Value: 6190, Capabilities: []string{"GlobalVariableFPGADecorationsINTEL",}, Parameters: []Parameter{{OperandKindInitializationModeQualifier, "'Trigger'"},}, Version: "None", }, Enumerant{ Enumerant: "ImplementInRegisterMapINTEL", Value: 6191, Capabilities: []string{"GlobalVariableFPGADecorationsINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "Value"},}, Version: "None", }, Enumerant{ Enumerant: "CacheControlLoadINTEL", Value: 6442, Capabilities: []string{"CacheControlsINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Cache Level'"},{OperandKindLoadCacheControl, "'Cache Control'"},}, Version: "None", }, Enumerant{ Enumerant: "CacheControlStoreINTEL", Value: 6443, Capabilities: []string{"CacheControlsINTEL",}, Parameters: []Parameter{{OperandKindLiteralInteger, "'Cache Level'"},{OperandKindStoreCacheControl, "'Cache Control'"},}, Version: "None", }, }, Bases: []*OperandKind {}, } OperandKindBuiltIn = &OperandKind { Kind: "BuiltIn", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "Position", Value: 0, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "PointSize", Value: 1, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "ClipDistance", Value: 3, Capabilities: []string{"ClipDistance",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "CullDistance", Value: 4, Capabilities: []string{"CullDistance",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "VertexId", Value: 5, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "InstanceId", Value: 6, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "PrimitiveId", Value: 7, Capabilities: []string{"Geometry","Tessellation","RayTracingNV","RayTracingKHR","MeshShadingNV","MeshShadingEXT",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "InvocationId", Value: 8, Capabilities: []string{"Geometry","Tessellation",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Layer", Value: 9, Capabilities: []string{"Geometry","ShaderLayer","ShaderViewportIndexLayerEXT","MeshShadingNV","MeshShadingEXT",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "ViewportIndex", Value: 10, Capabilities: []string{"MultiViewport","ShaderViewportIndex","ShaderViewportIndexLayerEXT","MeshShadingNV","MeshShadingEXT",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "TessLevelOuter", Value: 11, Capabilities: []string{"Tessellation",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "TessLevelInner", Value: 12, Capabilities: []string{"Tessellation",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "TessCoord", Value: 13, Capabilities: []string{"Tessellation",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "PatchVertices", Value: 14, Capabilities: []string{"Tessellation",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "FragCoord", Value: 15, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "PointCoord", Value: 16, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "FrontFacing", Value: 17, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "SampleId", Value: 18, Capabilities: []string{"SampleRateShading",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "SamplePosition", Value: 19, Capabilities: []string{"SampleRateShading",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "SampleMask", Value: 20, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "FragDepth", Value: 22, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "HelperInvocation", Value: 23, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "NumWorkgroups", Value: 24, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "WorkgroupSize", Value: 25, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "WorkgroupId", Value: 26, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "LocalInvocationId", Value: 27, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "GlobalInvocationId", Value: 28, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "LocalInvocationIndex", Value: 29, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "WorkDim", Value: 30, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "GlobalSize", Value: 31, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "EnqueuedWorkgroupSize", Value: 32, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "GlobalOffset", Value: 33, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "GlobalLinearId", Value: 34, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "SubgroupSize", Value: 36, Capabilities: []string{"Kernel","GroupNonUniform","SubgroupBallotKHR",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "SubgroupMaxSize", Value: 37, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "NumSubgroups", Value: 38, Capabilities: []string{"Kernel","GroupNonUniform",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "NumEnqueuedSubgroups", Value: 39, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "SubgroupId", Value: 40, Capabilities: []string{"Kernel","GroupNonUniform",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "SubgroupLocalInvocationId", Value: 41, Capabilities: []string{"Kernel","GroupNonUniform","SubgroupBallotKHR",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "VertexIndex", Value: 42, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "InstanceIndex", Value: 43, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "CoreIDARM", Value: 4160, Capabilities: []string{"CoreBuiltinsARM",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "CoreCountARM", Value: 4161, Capabilities: []string{"CoreBuiltinsARM",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "CoreMaxIDARM", Value: 4162, Capabilities: []string{"CoreBuiltinsARM",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "WarpIDARM", Value: 4163, Capabilities: []string{"CoreBuiltinsARM",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "WarpMaxIDARM", Value: 4164, Capabilities: []string{"CoreBuiltinsARM",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "SubgroupEqMask", Value: 4416, Capabilities: []string{"SubgroupBallotKHR","GroupNonUniformBallot",}, Parameters: []Parameter{}, Version: "1.3", }, Enumerant{ Enumerant: "SubgroupGeMask", Value: 4417, Capabilities: []string{"SubgroupBallotKHR","GroupNonUniformBallot",}, Parameters: []Parameter{}, Version: "1.3", }, Enumerant{ Enumerant: "SubgroupGtMask", Value: 4418, Capabilities: []string{"SubgroupBallotKHR","GroupNonUniformBallot",}, Parameters: []Parameter{}, Version: "1.3", }, Enumerant{ Enumerant: "SubgroupLeMask", Value: 4419, Capabilities: []string{"SubgroupBallotKHR","GroupNonUniformBallot",}, Parameters: []Parameter{}, Version: "1.3", }, Enumerant{ Enumerant: "SubgroupLtMask", Value: 4420, Capabilities: []string{"SubgroupBallotKHR","GroupNonUniformBallot",}, Parameters: []Parameter{}, Version: "1.3", }, Enumerant{ Enumerant: "BaseVertex", Value: 4424, Capabilities: []string{"DrawParameters",}, Parameters: []Parameter{}, Version: "1.3", }, Enumerant{ Enumerant: "BaseInstance", Value: 4425, Capabilities: []string{"DrawParameters",}, Parameters: []Parameter{}, Version: "1.3", }, Enumerant{ Enumerant: "DrawIndex", Value: 4426, Capabilities: []string{"DrawParameters","MeshShadingNV","MeshShadingEXT",}, Parameters: []Parameter{}, Version: "1.3", }, Enumerant{ Enumerant: "PrimitiveShadingRateKHR", Value: 4432, Capabilities: []string{"FragmentShadingRateKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "DeviceIndex", Value: 4438, Capabilities: []string{"DeviceGroup",}, Parameters: []Parameter{}, Version: "1.3", }, Enumerant{ Enumerant: "ViewIndex", Value: 4440, Capabilities: []string{"MultiView",}, Parameters: []Parameter{}, Version: "1.3", }, Enumerant{ Enumerant: "ShadingRateKHR", Value: 4444, Capabilities: []string{"FragmentShadingRateKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "BaryCoordNoPerspAMD", Value: 4992, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "BaryCoordNoPerspCentroidAMD", Value: 4993, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "BaryCoordNoPerspSampleAMD", Value: 4994, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "BaryCoordSmoothAMD", Value: 4995, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "BaryCoordSmoothCentroidAMD", Value: 4996, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "BaryCoordSmoothSampleAMD", Value: 4997, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "BaryCoordPullModelAMD", Value: 4998, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "FragStencilRefEXT", Value: 5014, Capabilities: []string{"StencilExportEXT",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "RemainingRecursionLevelsAMDX", Value: 5021, Capabilities: []string{"ShaderEnqueueAMDX",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ShaderIndexAMDX", Value: 5073, Capabilities: []string{"ShaderEnqueueAMDX",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ViewportMaskNV", Value: 5253, Capabilities: []string{"ShaderViewportMaskNV","MeshShadingNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "SecondaryPositionNV", Value: 5257, Capabilities: []string{"ShaderStereoViewNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "SecondaryViewportMaskNV", Value: 5258, Capabilities: []string{"ShaderStereoViewNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "PositionPerViewNV", Value: 5261, Capabilities: []string{"PerViewAttributesNV","MeshShadingNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ViewportMaskPerViewNV", Value: 5262, Capabilities: []string{"PerViewAttributesNV","MeshShadingNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "FullyCoveredEXT", Value: 5264, Capabilities: []string{"FragmentFullyCoveredEXT",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "TaskCountNV", Value: 5274, Capabilities: []string{"MeshShadingNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "PrimitiveCountNV", Value: 5275, Capabilities: []string{"MeshShadingNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "PrimitiveIndicesNV", Value: 5276, Capabilities: []string{"MeshShadingNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ClipDistancePerViewNV", Value: 5277, Capabilities: []string{"MeshShadingNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "CullDistancePerViewNV", Value: 5278, Capabilities: []string{"MeshShadingNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "LayerPerViewNV", Value: 5279, Capabilities: []string{"MeshShadingNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "MeshViewCountNV", Value: 5280, Capabilities: []string{"MeshShadingNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "MeshViewIndicesNV", Value: 5281, Capabilities: []string{"MeshShadingNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "BaryCoordKHR", Value: 5286, Capabilities: []string{"FragmentBarycentricKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "BaryCoordNoPerspKHR", Value: 5287, Capabilities: []string{"FragmentBarycentricKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "FragSizeEXT", Value: 5292, Capabilities: []string{"FragmentDensityEXT",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "FragInvocationCountEXT", Value: 5293, Capabilities: []string{"FragmentDensityEXT",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "PrimitivePointIndicesEXT", Value: 5294, Capabilities: []string{"MeshShadingEXT",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "PrimitiveLineIndicesEXT", Value: 5295, Capabilities: []string{"MeshShadingEXT",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "PrimitiveTriangleIndicesEXT", Value: 5296, Capabilities: []string{"MeshShadingEXT",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "CullPrimitiveEXT", Value: 5299, Capabilities: []string{"MeshShadingEXT",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "LaunchIdKHR", Value: 5319, Capabilities: []string{"RayTracingNV","RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "LaunchSizeKHR", Value: 5320, Capabilities: []string{"RayTracingNV","RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "WorldRayOriginKHR", Value: 5321, Capabilities: []string{"RayTracingNV","RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "WorldRayDirectionKHR", Value: 5322, Capabilities: []string{"RayTracingNV","RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ObjectRayOriginKHR", Value: 5323, Capabilities: []string{"RayTracingNV","RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ObjectRayDirectionKHR", Value: 5324, Capabilities: []string{"RayTracingNV","RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "RayTminKHR", Value: 5325, Capabilities: []string{"RayTracingNV","RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "RayTmaxKHR", Value: 5326, Capabilities: []string{"RayTracingNV","RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "InstanceCustomIndexKHR", Value: 5327, Capabilities: []string{"RayTracingNV","RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ObjectToWorldKHR", Value: 5330, Capabilities: []string{"RayTracingNV","RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "WorldToObjectKHR", Value: 5331, Capabilities: []string{"RayTracingNV","RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "HitTNV", Value: 5332, Capabilities: []string{"RayTracingNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "HitKindKHR", Value: 5333, Capabilities: []string{"RayTracingNV","RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "CurrentRayTimeNV", Value: 5334, Capabilities: []string{"RayTracingMotionBlurNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "HitTriangleVertexPositionsKHR", Value: 5335, Capabilities: []string{"RayTracingPositionFetchKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "HitMicroTriangleVertexPositionsNV", Value: 5337, Capabilities: []string{"RayTracingDisplacementMicromapNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "HitMicroTriangleVertexBarycentricsNV", Value: 5344, Capabilities: []string{"RayTracingDisplacementMicromapNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "IncomingRayFlagsKHR", Value: 5351, Capabilities: []string{"RayTracingNV","RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "RayGeometryIndexKHR", Value: 5352, Capabilities: []string{"RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "WarpsPerSMNV", Value: 5374, Capabilities: []string{"ShaderSMBuiltinsNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "SMCountNV", Value: 5375, Capabilities: []string{"ShaderSMBuiltinsNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "WarpIDNV", Value: 5376, Capabilities: []string{"ShaderSMBuiltinsNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "SMIDNV", Value: 5377, Capabilities: []string{"ShaderSMBuiltinsNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "HitKindFrontFacingMicroTriangleNV", Value: 5405, Capabilities: []string{"RayTracingDisplacementMicromapNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "HitKindBackFacingMicroTriangleNV", Value: 5406, Capabilities: []string{"RayTracingDisplacementMicromapNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "CullMaskKHR", Value: 6021, Capabilities: []string{"RayCullMaskKHR",}, Parameters: []Parameter{}, Version: "None", }, }, Bases: []*OperandKind {}, } OperandKindScope = &OperandKind { Kind: "Scope", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "CrossDevice", Value: 0, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Device", Value: 1, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Workgroup", Value: 2, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Subgroup", Value: 3, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Invocation", Value: 4, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "QueueFamily", Value: 5, Capabilities: []string{"VulkanMemoryModel",}, Parameters: []Parameter{}, Version: "1.5", }, Enumerant{ Enumerant: "ShaderCallKHR", Value: 6, Capabilities: []string{"RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, }, Bases: []*OperandKind {}, } OperandKindGroupOperation = &OperandKind { Kind: "GroupOperation", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "Reduce", Value: 0, Capabilities: []string{"Kernel","GroupNonUniformArithmetic","GroupNonUniformBallot",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "InclusiveScan", Value: 1, Capabilities: []string{"Kernel","GroupNonUniformArithmetic","GroupNonUniformBallot",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "ExclusiveScan", Value: 2, Capabilities: []string{"Kernel","GroupNonUniformArithmetic","GroupNonUniformBallot",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "ClusteredReduce", Value: 3, Capabilities: []string{"GroupNonUniformClustered",}, Parameters: []Parameter{}, Version: "1.3", }, Enumerant{ Enumerant: "PartitionedReduceNV", Value: 6, Capabilities: []string{"GroupNonUniformPartitionedNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "PartitionedInclusiveScanNV", Value: 7, Capabilities: []string{"GroupNonUniformPartitionedNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "PartitionedExclusiveScanNV", Value: 8, Capabilities: []string{"GroupNonUniformPartitionedNV",}, Parameters: []Parameter{}, Version: "None", }, }, Bases: []*OperandKind {}, } OperandKindKernelEnqueueFlags = &OperandKind { Kind: "KernelEnqueueFlags", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "NoWait", Value: 0, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "WaitKernel", Value: 1, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "WaitWorkGroup", Value: 2, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "1.0", }, }, Bases: []*OperandKind {}, } OperandKindCapability = &OperandKind { Kind: "Capability", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "Matrix", Value: 0, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Shader", Value: 1, Capabilities: []string{"Matrix",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Geometry", Value: 2, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Tessellation", Value: 3, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Addresses", Value: 4, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Linkage", Value: 5, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Kernel", Value: 6, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Vector16", Value: 7, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Float16Buffer", Value: 8, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Float16", Value: 9, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Float64", Value: 10, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Int64", Value: 11, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Int64Atomics", Value: 12, Capabilities: []string{"Int64",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "ImageBasic", Value: 13, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "ImageReadWrite", Value: 14, Capabilities: []string{"ImageBasic",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "ImageMipmap", Value: 15, Capabilities: []string{"ImageBasic",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Pipes", Value: 17, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Groups", Value: 18, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "DeviceEnqueue", Value: 19, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "LiteralSampler", Value: 20, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "AtomicStorage", Value: 21, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Int16", Value: 22, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "TessellationPointSize", Value: 23, Capabilities: []string{"Tessellation",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "GeometryPointSize", Value: 24, Capabilities: []string{"Geometry",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "ImageGatherExtended", Value: 25, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "StorageImageMultisample", Value: 27, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "UniformBufferArrayDynamicIndexing", Value: 28, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "SampledImageArrayDynamicIndexing", Value: 29, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "StorageBufferArrayDynamicIndexing", Value: 30, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "StorageImageArrayDynamicIndexing", Value: 31, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "ClipDistance", Value: 32, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "CullDistance", Value: 33, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "ImageCubeArray", Value: 34, Capabilities: []string{"SampledCubeArray",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "SampleRateShading", Value: 35, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "ImageRect", Value: 36, Capabilities: []string{"SampledRect",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "SampledRect", Value: 37, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "GenericPointer", Value: 38, Capabilities: []string{"Addresses",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Int8", Value: 39, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "InputAttachment", Value: 40, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "SparseResidency", Value: 41, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "MinLod", Value: 42, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Sampled1D", Value: 43, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "Image1D", Value: 44, Capabilities: []string{"Sampled1D",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "SampledCubeArray", Value: 45, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "SampledBuffer", Value: 46, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "ImageBuffer", Value: 47, Capabilities: []string{"SampledBuffer",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "ImageMSArray", Value: 48, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "StorageImageExtendedFormats", Value: 49, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "ImageQuery", Value: 50, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "DerivativeControl", Value: 51, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "InterpolationFunction", Value: 52, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "TransformFeedback", Value: 53, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "GeometryStreams", Value: 54, Capabilities: []string{"Geometry",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "StorageImageReadWithoutFormat", Value: 55, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "StorageImageWriteWithoutFormat", Value: 56, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "MultiViewport", Value: 57, Capabilities: []string{"Geometry",}, Parameters: []Parameter{}, Version: "1.0", }, Enumerant{ Enumerant: "SubgroupDispatch", Value: 58, Capabilities: []string{"DeviceEnqueue",}, Parameters: []Parameter{}, Version: "1.1", }, Enumerant{ Enumerant: "NamedBarrier", Value: 59, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "1.1", }, Enumerant{ Enumerant: "PipeStorage", Value: 60, Capabilities: []string{"Pipes",}, Parameters: []Parameter{}, Version: "1.1", }, Enumerant{ Enumerant: "GroupNonUniform", Value: 61, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.3", }, Enumerant{ Enumerant: "GroupNonUniformVote", Value: 62, Capabilities: []string{"GroupNonUniform",}, Parameters: []Parameter{}, Version: "1.3", }, Enumerant{ Enumerant: "GroupNonUniformArithmetic", Value: 63, Capabilities: []string{"GroupNonUniform",}, Parameters: []Parameter{}, Version: "1.3", }, Enumerant{ Enumerant: "GroupNonUniformBallot", Value: 64, Capabilities: []string{"GroupNonUniform",}, Parameters: []Parameter{}, Version: "1.3", }, Enumerant{ Enumerant: "GroupNonUniformShuffle", Value: 65, Capabilities: []string{"GroupNonUniform",}, Parameters: []Parameter{}, Version: "1.3", }, Enumerant{ Enumerant: "GroupNonUniformShuffleRelative", Value: 66, Capabilities: []string{"GroupNonUniform",}, Parameters: []Parameter{}, Version: "1.3", }, Enumerant{ Enumerant: "GroupNonUniformClustered", Value: 67, Capabilities: []string{"GroupNonUniform",}, Parameters: []Parameter{}, Version: "1.3", }, Enumerant{ Enumerant: "GroupNonUniformQuad", Value: 68, Capabilities: []string{"GroupNonUniform",}, Parameters: []Parameter{}, Version: "1.3", }, Enumerant{ Enumerant: "ShaderLayer", Value: 69, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.5", }, Enumerant{ Enumerant: "ShaderViewportIndex", Value: 70, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.5", }, Enumerant{ Enumerant: "UniformDecoration", Value: 71, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.6", }, Enumerant{ Enumerant: "CoreBuiltinsARM", Value: 4165, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "TileImageColorReadAccessEXT", Value: 4166, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "TileImageDepthReadAccessEXT", Value: 4167, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "TileImageStencilReadAccessEXT", Value: 4168, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "CooperativeMatrixLayoutsARM", Value: 4201, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "FragmentShadingRateKHR", Value: 4422, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "SubgroupBallotKHR", Value: 4423, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "DrawParameters", Value: 4427, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.3", }, Enumerant{ Enumerant: "WorkgroupMemoryExplicitLayoutKHR", Value: 4428, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "WorkgroupMemoryExplicitLayout8BitAccessKHR", Value: 4429, Capabilities: []string{"WorkgroupMemoryExplicitLayoutKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "WorkgroupMemoryExplicitLayout16BitAccessKHR", Value: 4430, Capabilities: []string{"WorkgroupMemoryExplicitLayoutKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "SubgroupVoteKHR", Value: 4431, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "StorageBuffer16BitAccess", Value: 4433, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.3", }, Enumerant{ Enumerant: "UniformAndStorageBuffer16BitAccess", Value: 4434, Capabilities: []string{"StorageBuffer16BitAccess",}, Parameters: []Parameter{}, Version: "1.3", }, Enumerant{ Enumerant: "StoragePushConstant16", Value: 4435, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.3", }, Enumerant{ Enumerant: "StorageInputOutput16", Value: 4436, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.3", }, Enumerant{ Enumerant: "DeviceGroup", Value: 4437, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.3", }, Enumerant{ Enumerant: "MultiView", Value: 4439, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.3", }, Enumerant{ Enumerant: "VariablePointersStorageBuffer", Value: 4441, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.3", }, Enumerant{ Enumerant: "VariablePointers", Value: 4442, Capabilities: []string{"VariablePointersStorageBuffer",}, Parameters: []Parameter{}, Version: "1.3", }, Enumerant{ Enumerant: "AtomicStorageOps", Value: 4445, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "SampleMaskPostDepthCoverage", Value: 4447, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "StorageBuffer8BitAccess", Value: 4448, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.5", }, Enumerant{ Enumerant: "UniformAndStorageBuffer8BitAccess", Value: 4449, Capabilities: []string{"StorageBuffer8BitAccess",}, Parameters: []Parameter{}, Version: "1.5", }, Enumerant{ Enumerant: "StoragePushConstant8", Value: 4450, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.5", }, Enumerant{ Enumerant: "DenormPreserve", Value: 4464, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.4", }, Enumerant{ Enumerant: "DenormFlushToZero", Value: 4465, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.4", }, Enumerant{ Enumerant: "SignedZeroInfNanPreserve", Value: 4466, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.4", }, Enumerant{ Enumerant: "RoundingModeRTE", Value: 4467, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.4", }, Enumerant{ Enumerant: "RoundingModeRTZ", Value: 4468, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.4", }, Enumerant{ Enumerant: "RayQueryProvisionalKHR", Value: 4471, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "RayQueryKHR", Value: 4472, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "UntypedPointersKHR", Value: 4473, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "RayTraversalPrimitiveCullingKHR", Value: 4478, Capabilities: []string{"RayQueryKHR","RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "RayTracingKHR", Value: 4479, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "TextureSampleWeightedQCOM", Value: 4484, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "TextureBoxFilterQCOM", Value: 4485, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "TextureBlockMatchQCOM", Value: 4486, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "TextureBlockMatch2QCOM", Value: 4498, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "Float16ImageAMD", Value: 5008, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ImageGatherBiasLodAMD", Value: 5009, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "FragmentMaskAMD", Value: 5010, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "StencilExportEXT", Value: 5013, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ImageReadWriteLodAMD", Value: 5015, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "Int64ImageEXT", Value: 5016, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ShaderClockKHR", Value: 5055, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ShaderEnqueueAMDX", Value: 5067, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "QuadControlKHR", Value: 5087, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "SampleMaskOverrideCoverageNV", Value: 5249, Capabilities: []string{"SampleRateShading",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "GeometryShaderPassthroughNV", Value: 5251, Capabilities: []string{"Geometry",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ShaderViewportIndexLayerEXT", Value: 5254, Capabilities: []string{"MultiViewport",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ShaderViewportMaskNV", Value: 5255, Capabilities: []string{"ShaderViewportIndexLayerEXT",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ShaderStereoViewNV", Value: 5259, Capabilities: []string{"ShaderViewportMaskNV",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "PerViewAttributesNV", Value: 5260, Capabilities: []string{"MultiView",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "FragmentFullyCoveredEXT", Value: 5265, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "MeshShadingNV", Value: 5266, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ImageFootprintNV", Value: 5282, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "MeshShadingEXT", Value: 5283, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "FragmentBarycentricKHR", Value: 5284, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ComputeDerivativeGroupQuadsKHR", Value: 5288, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "FragmentDensityEXT", Value: 5291, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "GroupNonUniformPartitionedNV", Value: 5297, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ShaderNonUniform", Value: 5301, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.5", }, Enumerant{ Enumerant: "RuntimeDescriptorArray", Value: 5302, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.5", }, Enumerant{ Enumerant: "InputAttachmentArrayDynamicIndexing", Value: 5303, Capabilities: []string{"InputAttachment",}, Parameters: []Parameter{}, Version: "1.5", }, Enumerant{ Enumerant: "UniformTexelBufferArrayDynamicIndexing", Value: 5304, Capabilities: []string{"SampledBuffer",}, Parameters: []Parameter{}, Version: "1.5", }, Enumerant{ Enumerant: "StorageTexelBufferArrayDynamicIndexing", Value: 5305, Capabilities: []string{"ImageBuffer",}, Parameters: []Parameter{}, Version: "1.5", }, Enumerant{ Enumerant: "UniformBufferArrayNonUniformIndexing", Value: 5306, Capabilities: []string{"ShaderNonUniform",}, Parameters: []Parameter{}, Version: "1.5", }, Enumerant{ Enumerant: "SampledImageArrayNonUniformIndexing", Value: 5307, Capabilities: []string{"ShaderNonUniform",}, Parameters: []Parameter{}, Version: "1.5", }, Enumerant{ Enumerant: "StorageBufferArrayNonUniformIndexing", Value: 5308, Capabilities: []string{"ShaderNonUniform",}, Parameters: []Parameter{}, Version: "1.5", }, Enumerant{ Enumerant: "StorageImageArrayNonUniformIndexing", Value: 5309, Capabilities: []string{"ShaderNonUniform",}, Parameters: []Parameter{}, Version: "1.5", }, Enumerant{ Enumerant: "InputAttachmentArrayNonUniformIndexing", Value: 5310, Capabilities: []string{"InputAttachment","ShaderNonUniform",}, Parameters: []Parameter{}, Version: "1.5", }, Enumerant{ Enumerant: "UniformTexelBufferArrayNonUniformIndexing", Value: 5311, Capabilities: []string{"SampledBuffer","ShaderNonUniform",}, Parameters: []Parameter{}, Version: "1.5", }, Enumerant{ Enumerant: "StorageTexelBufferArrayNonUniformIndexing", Value: 5312, Capabilities: []string{"ImageBuffer","ShaderNonUniform",}, Parameters: []Parameter{}, Version: "1.5", }, Enumerant{ Enumerant: "RayTracingPositionFetchKHR", Value: 5336, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "RayTracingNV", Value: 5340, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "RayTracingMotionBlurNV", Value: 5341, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "VulkanMemoryModel", Value: 5345, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.5", }, Enumerant{ Enumerant: "VulkanMemoryModelDeviceScope", Value: 5346, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.5", }, Enumerant{ Enumerant: "PhysicalStorageBufferAddresses", Value: 5347, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.5", }, Enumerant{ Enumerant: "ComputeDerivativeGroupLinearKHR", Value: 5350, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "RayTracingProvisionalKHR", Value: 5353, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "CooperativeMatrixNV", Value: 5357, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "FragmentShaderSampleInterlockEXT", Value: 5363, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "FragmentShaderShadingRateInterlockEXT", Value: 5372, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ShaderSMBuiltinsNV", Value: 5373, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "FragmentShaderPixelInterlockEXT", Value: 5378, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "DemoteToHelperInvocation", Value: 5379, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "1.6", }, Enumerant{ Enumerant: "DisplacementMicromapNV", Value: 5380, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "RayTracingOpacityMicromapEXT", Value: 5381, Capabilities: []string{"RayQueryKHR","RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ShaderInvocationReorderNV", Value: 5383, Capabilities: []string{"RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "BindlessTextureNV", Value: 5390, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "RayQueryPositionFetchKHR", Value: 5391, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "AtomicFloat16VectorNV", Value: 5404, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "RayTracingDisplacementMicromapNV", Value: 5409, Capabilities: []string{"RayTracingKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "RawAccessChainsNV", Value: 5414, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "CooperativeMatrixReductionsNV", Value: 5430, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "CooperativeMatrixConversionsNV", Value: 5431, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "CooperativeMatrixPerElementOperationsNV", Value: 5432, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "CooperativeMatrixTensorAddressingNV", Value: 5433, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "CooperativeMatrixBlockLoadsNV", Value: 5434, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "TensorAddressingNV", Value: 5439, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "SubgroupShuffleINTEL", Value: 5568, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "SubgroupBufferBlockIOINTEL", Value: 5569, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "SubgroupImageBlockIOINTEL", Value: 5570, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "SubgroupImageMediaBlockIOINTEL", Value: 5579, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "RoundToInfinityINTEL", Value: 5582, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "FloatingPointModeINTEL", Value: 5583, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "IntegerFunctions2INTEL", Value: 5584, Capabilities: []string{"Shader",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "FunctionPointersINTEL", Value: 5603, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "IndirectReferencesINTEL", Value: 5604, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "AsmINTEL", Value: 5606, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "AtomicFloat32MinMaxEXT", Value: 5612, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "AtomicFloat64MinMaxEXT", Value: 5613, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "AtomicFloat16MinMaxEXT", Value: 5616, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "VectorComputeINTEL", Value: 5617, Capabilities: []string{"VectorAnyINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "VectorAnyINTEL", Value: 5619, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ExpectAssumeKHR", Value: 5629, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "SubgroupAvcMotionEstimationINTEL", Value: 5696, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "SubgroupAvcMotionEstimationIntraINTEL", Value: 5697, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "SubgroupAvcMotionEstimationChromaINTEL", Value: 5698, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "VariableLengthArrayINTEL", Value: 5817, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "FunctionFloatControlINTEL", Value: 5821, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "FPGAMemoryAttributesINTEL", Value: 5824, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "FPFastMathModeINTEL", Value: 5837, Capabilities: []string{"Kernel",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ArbitraryPrecisionIntegersINTEL", Value: 5844, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ArbitraryPrecisionFloatingPointINTEL", Value: 5845, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "UnstructuredLoopControlsINTEL", Value: 5886, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "FPGALoopControlsINTEL", Value: 5888, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "KernelAttributesINTEL", Value: 5892, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "FPGAKernelAttributesINTEL", Value: 5897, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "FPGAMemoryAccessesINTEL", Value: 5898, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "FPGAClusterAttributesINTEL", Value: 5904, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "LoopFuseINTEL", Value: 5906, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "FPGADSPControlINTEL", Value: 5908, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "MemoryAccessAliasingINTEL", Value: 5910, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "FPGAInvocationPipeliningAttributesINTEL", Value: 5916, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "FPGABufferLocationINTEL", Value: 5920, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ArbitraryPrecisionFixedPointINTEL", Value: 5922, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "USMStorageClassesINTEL", Value: 5935, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "RuntimeAlignedAttributeINTEL", Value: 5939, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "IOPipesINTEL", Value: 5943, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "BlockingPipesINTEL", Value: 5945, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "FPGARegINTEL", Value: 5948, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "DotProductInputAll", Value: 6016, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.6", }, Enumerant{ Enumerant: "DotProductInput4x8Bit", Value: 6017, Capabilities: []string{"Int8",}, Parameters: []Parameter{}, Version: "1.6", }, Enumerant{ Enumerant: "DotProductInput4x8BitPacked", Value: 6018, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.6", }, Enumerant{ Enumerant: "DotProduct", Value: 6019, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.6", }, Enumerant{ Enumerant: "RayCullMaskKHR", Value: 6020, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "CooperativeMatrixKHR", Value: 6022, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ReplicatedCompositesEXT", Value: 6024, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "BitInstructions", Value: 6025, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "GroupNonUniformRotateKHR", Value: 6026, Capabilities: []string{"GroupNonUniform",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "FloatControls2", Value: 6029, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "AtomicFloat32AddEXT", Value: 6033, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "AtomicFloat64AddEXT", Value: 6034, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "LongCompositesINTEL", Value: 6089, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "OptNoneEXT", Value: 6094, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "AtomicFloat16AddEXT", Value: 6095, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "DebugInfoModuleINTEL", Value: 6114, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "BFloat16ConversionINTEL", Value: 6115, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "SplitBarrierINTEL", Value: 6141, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ArithmeticFenceEXT", Value: 6144, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "FPGAClusterAttributesV2INTEL", Value: 6150, Capabilities: []string{"FPGAClusterAttributesINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "FPGAKernelAttributesv2INTEL", Value: 6161, Capabilities: []string{"FPGAKernelAttributesINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "FPMaxErrorINTEL", Value: 6169, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "FPGALatencyControlINTEL", Value: 6171, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "FPGAArgumentInterfacesINTEL", Value: 6174, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "GlobalVariableHostAccessINTEL", Value: 6187, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "GlobalVariableFPGADecorationsINTEL", Value: 6189, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "SubgroupBufferPrefetchINTEL", Value: 6220, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "GroupUniformArithmeticKHR", Value: 6400, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "MaskedGatherScatterINTEL", Value: 6427, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "CacheControlsINTEL", Value: 6441, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "RegisterLimitsINTEL", Value: 6460, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, }, Bases: []*OperandKind {}, } OperandKindRayQueryIntersection = &OperandKind { Kind: "RayQueryIntersection", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "RayQueryCandidateIntersectionKHR", Value: 0, Capabilities: []string{"RayQueryKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "RayQueryCommittedIntersectionKHR", Value: 1, Capabilities: []string{"RayQueryKHR",}, Parameters: []Parameter{}, Version: "None", }, }, Bases: []*OperandKind {}, } OperandKindRayQueryCommittedIntersectionType = &OperandKind { Kind: "RayQueryCommittedIntersectionType", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "RayQueryCommittedIntersectionNoneKHR", Value: 0, Capabilities: []string{"RayQueryKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "RayQueryCommittedIntersectionTriangleKHR", Value: 1, Capabilities: []string{"RayQueryKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "RayQueryCommittedIntersectionGeneratedKHR", Value: 2, Capabilities: []string{"RayQueryKHR",}, Parameters: []Parameter{}, Version: "None", }, }, Bases: []*OperandKind {}, } OperandKindRayQueryCandidateIntersectionType = &OperandKind { Kind: "RayQueryCandidateIntersectionType", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "RayQueryCandidateIntersectionTriangleKHR", Value: 0, Capabilities: []string{"RayQueryKHR",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "RayQueryCandidateIntersectionAABBKHR", Value: 1, Capabilities: []string{"RayQueryKHR",}, Parameters: []Parameter{}, Version: "None", }, }, Bases: []*OperandKind {}, } OperandKindPackedVectorFormat = &OperandKind { Kind: "PackedVectorFormat", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "PackedVectorFormat4x8Bit", Value: 0, Capabilities: []string{}, Parameters: []Parameter{}, Version: "1.6", }, }, Bases: []*OperandKind {}, } OperandKindCooperativeMatrixOperands = &OperandKind { Kind: "CooperativeMatrixOperands", Category: "BitEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "NoneKHR", Value: 0x0000, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "MatrixASignedComponentsKHR", Value: 0x0001, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "MatrixBSignedComponentsKHR", Value: 0x0002, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "MatrixCSignedComponentsKHR", Value: 0x0004, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "MatrixResultSignedComponentsKHR", Value: 0x0008, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "SaturatingAccumulationKHR", Value: 0x0010, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, }, Bases: []*OperandKind {}, } OperandKindCooperativeMatrixLayout = &OperandKind { Kind: "CooperativeMatrixLayout", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "RowMajorKHR", Value: 0, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ColumnMajorKHR", Value: 1, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "RowBlockedInterleavedARM", Value: 4202, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ColumnBlockedInterleavedARM", Value: 4203, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, }, Bases: []*OperandKind {}, } OperandKindCooperativeMatrixUse = &OperandKind { Kind: "CooperativeMatrixUse", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "MatrixAKHR", Value: 0, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "MatrixBKHR", Value: 1, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "MatrixAccumulatorKHR", Value: 2, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, }, Bases: []*OperandKind {}, } OperandKindCooperativeMatrixReduce = &OperandKind { Kind: "CooperativeMatrixReduce", Category: "BitEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "Row", Value: 0x0001, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "Column", Value: 0x0002, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "2x2", Value: 0x0004, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, }, Bases: []*OperandKind {}, } OperandKindTensorClampMode = &OperandKind { Kind: "TensorClampMode", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "Undefined", Value: 0, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "Constant", Value: 1, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ClampToEdge", Value: 2, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "Repeat", Value: 3, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "RepeatMirrored", Value: 4, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, }, Bases: []*OperandKind {}, } OperandKindTensorAddressingOperands = &OperandKind { Kind: "TensorAddressingOperands", Category: "BitEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "None", Value: 0x0000, Capabilities: []string{}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "TensorView", Value: 0x0001, Capabilities: []string{"CooperativeMatrixTensorAddressingNV",}, Parameters: []Parameter{{OperandKindIdRef, ""},}, Version: "None", }, Enumerant{ Enumerant: "DecodeFunc", Value: 0x0002, Capabilities: []string{"CooperativeMatrixBlockLoadsNV",}, Parameters: []Parameter{{OperandKindIdRef, ""},}, Version: "None", }, }, Bases: []*OperandKind {}, } OperandKindInitializationModeQualifier = &OperandKind { Kind: "InitializationModeQualifier", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "InitOnDeviceReprogramINTEL", Value: 0, Capabilities: []string{"GlobalVariableFPGADecorationsINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "InitOnDeviceResetINTEL", Value: 1, Capabilities: []string{"GlobalVariableFPGADecorationsINTEL",}, Parameters: []Parameter{}, Version: "None", }, }, Bases: []*OperandKind {}, } OperandKindLoadCacheControl = &OperandKind { Kind: "LoadCacheControl", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "UncachedINTEL", Value: 0, Capabilities: []string{"CacheControlsINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "CachedINTEL", Value: 1, Capabilities: []string{"CacheControlsINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "StreamingINTEL", Value: 2, Capabilities: []string{"CacheControlsINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "InvalidateAfterReadINTEL", Value: 3, Capabilities: []string{"CacheControlsINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "ConstCachedINTEL", Value: 4, Capabilities: []string{"CacheControlsINTEL",}, Parameters: []Parameter{}, Version: "None", }, }, Bases: []*OperandKind {}, } OperandKindStoreCacheControl = &OperandKind { Kind: "StoreCacheControl", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "UncachedINTEL", Value: 0, Capabilities: []string{"CacheControlsINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "WriteThroughINTEL", Value: 1, Capabilities: []string{"CacheControlsINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "WriteBackINTEL", Value: 2, Capabilities: []string{"CacheControlsINTEL",}, Parameters: []Parameter{}, Version: "None", }, Enumerant{ Enumerant: "StreamingINTEL", Value: 3, Capabilities: []string{"CacheControlsINTEL",}, Parameters: []Parameter{}, Version: "None", }, }, Bases: []*OperandKind {}, } OperandKindNamedMaximumNumberOfRegisters = &OperandKind { Kind: "NamedMaximumNumberOfRegisters", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "AutoINTEL", Value: 0, Capabilities: []string{"RegisterLimitsINTEL",}, Parameters: []Parameter{}, Version: "None", }, }, Bases: []*OperandKind {}, } OperandKindFPEncoding = &OperandKind { Kind: "FPEncoding", Category: "ValueEnum", Enumerants: []Enumerant { }, Bases: []*OperandKind {}, } OperandKindIdResultType = &OperandKind { Kind: "IdResultType", Category: "Id", Enumerants: []Enumerant { }, Bases: []*OperandKind {}, } OperandKindIdResult = &OperandKind { Kind: "IdResult", Category: "Id", Enumerants: []Enumerant { }, Bases: []*OperandKind {}, } OperandKindIdMemorySemantics = &OperandKind { Kind: "IdMemorySemantics", Category: "Id", Enumerants: []Enumerant { }, Bases: []*OperandKind {}, } OperandKindIdScope = &OperandKind { Kind: "IdScope", Category: "Id", Enumerants: []Enumerant { }, Bases: []*OperandKind {}, } OperandKindIdRef = &OperandKind { Kind: "IdRef", Category: "Id", Enumerants: []Enumerant { }, Bases: []*OperandKind {}, } OperandKindLiteralInteger = &OperandKind { Kind: "LiteralInteger", Category: "Literal", Enumerants: []Enumerant { }, Bases: []*OperandKind {}, } OperandKindLiteralString = &OperandKind { Kind: "LiteralString", Category: "Literal", Enumerants: []Enumerant { }, Bases: []*OperandKind {}, } OperandKindLiteralFloat = &OperandKind { Kind: "LiteralFloat", Category: "Literal", Enumerants: []Enumerant { }, Bases: []*OperandKind {}, } OperandKindLiteralContextDependentNumber = &OperandKind { Kind: "LiteralContextDependentNumber", Category: "Literal", Enumerants: []Enumerant { }, Bases: []*OperandKind {}, } OperandKindLiteralExtInstInteger = &OperandKind { Kind: "LiteralExtInstInteger", Category: "Literal", Enumerants: []Enumerant { }, Bases: []*OperandKind {}, } OperandKindLiteralSpecConstantOpInteger = &OperandKind { Kind: "LiteralSpecConstantOpInteger", Category: "Literal", Enumerants: []Enumerant { }, Bases: []*OperandKind {}, } OperandKindPairLiteralIntegerIdRef = &OperandKind { Kind: "PairLiteralIntegerIdRef", Category: "Composite", Enumerants: []Enumerant { }, Bases: []*OperandKind {OperandKindLiteralInteger,OperandKindIdRef,}, } OperandKindPairIdRefLiteralInteger = &OperandKind { Kind: "PairIdRefLiteralInteger", Category: "Composite", Enumerants: []Enumerant { }, Bases: []*OperandKind {OperandKindIdRef,OperandKindLiteralInteger,}, } OperandKindPairIdRefIdRef = &OperandKind { Kind: "PairIdRefIdRef", Category: "Composite", Enumerants: []Enumerant { }, Bases: []*OperandKind {OperandKindIdRef,OperandKindIdRef,}, } OperandKindDebugInfoFlags = &OperandKind { Kind: "DebugInfoFlags", Category: "BitEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "None", Value: 0x0000, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "FlagIsProtected", Value: 0x01, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "FlagIsPrivate", Value: 0x02, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "FlagIsPublic", Value: 0x03, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "FlagIsLocal", Value: 0x04, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "FlagIsDefinition", Value: 0x08, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "FlagFwdDecl", Value: 0x10, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "FlagArtificial", Value: 0x20, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "FlagExplicit", Value: 0x40, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "FlagPrototyped", Value: 0x80, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "FlagObjectPointer", Value: 0x100, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "FlagStaticMember", Value: 0x200, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "FlagIndirectVariable", Value: 0x400, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "FlagLValueReference", Value: 0x800, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "FlagRValueReference", Value: 0x1000, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "FlagIsOptimized", Value: 0x2000, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "FlagIsEnumClass", Value: 0x4000, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "FlagTypePassByValue", Value: 0x8000, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "FlagTypePassByReference", Value: 0x10000, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, }, Bases: []*OperandKind {}, } OperandKindDebugBaseTypeAttributeEncoding = &OperandKind { Kind: "DebugBaseTypeAttributeEncoding", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "Unspecified", Value: 0, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "Address", Value: 1, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "Boolean", Value: 2, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "Float", Value: 3, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "Signed", Value: 4, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "SignedChar", Value: 5, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "Unsigned", Value: 6, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "UnsignedChar", Value: 7, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, }, Bases: []*OperandKind {}, } OperandKindDebugCompositeType = &OperandKind { Kind: "DebugCompositeType", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "Class", Value: 0, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "Structure", Value: 1, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "Union", Value: 2, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, }, Bases: []*OperandKind {}, } OperandKindDebugTypeQualifier = &OperandKind { Kind: "DebugTypeQualifier", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "ConstType", Value: 0, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "VolatileType", Value: 1, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "RestrictType", Value: 2, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "AtomicType", Value: 3, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, }, Bases: []*OperandKind {}, } OperandKindDebugOperation = &OperandKind { Kind: "DebugOperation", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "Deref", Value: 0, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "Plus", Value: 1, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "Minus", Value: 2, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "PlusUconst", Value: 3, Capabilities: []string{}, Parameters: []Parameter{{OperandKindLiteralInteger, ""},}, Version: "", }, Enumerant{ Enumerant: "BitPiece", Value: 4, Capabilities: []string{}, Parameters: []Parameter{{OperandKindLiteralInteger, ""},{OperandKindLiteralInteger, ""},}, Version: "", }, Enumerant{ Enumerant: "Swap", Value: 5, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "Xderef", Value: 6, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "StackValue", Value: 7, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "Constu", Value: 8, Capabilities: []string{}, Parameters: []Parameter{{OperandKindLiteralInteger, ""},}, Version: "", }, Enumerant{ Enumerant: "Fragment", Value: 9, Capabilities: []string{}, Parameters: []Parameter{{OperandKindLiteralInteger, ""},{OperandKindLiteralInteger, ""},}, Version: "", }, }, Bases: []*OperandKind {}, } OperandKindDebugImportedEntity = &OperandKind { Kind: "DebugImportedEntity", Category: "ValueEnum", Enumerants: []Enumerant { Enumerant{ Enumerant: "ImportedModule", Value: 0, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, Enumerant{ Enumerant: "ImportedDeclaration", Value: 1, Capabilities: []string{}, Parameters: []Parameter{}, Version: "", }, }, Bases: []*OperandKind {}, } ) KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/src/schema/schema.go.tmpl000066400000000000000000000113001475742701700257400ustar00rootroot00000000000000// Copyright (C) 2019 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Generated by {{GenerateArguments}} // Do not modify this file directly. package schema // Opcode holds information about a specific SPIR-V opcode. type Opcode struct { Opname string Class string Opcode int Operands []Operand } // Operand contains information about a logical operand for an instruction. type Operand struct { Kind *OperandKind Name string Quantifier Quantifier } // OperandKind contains information about a specific operand kind. type OperandKind struct { Category OperandCategory Kind string Enumerants []Enumerant Bases []*OperandKind } // Enumerant contains information about an enumerant in an enum. type Enumerant struct { Enumerant string Value interface{} Capabilities []string Parameters []Parameter Version string } // Parameter contains information about a logical parameter for an enumerant. type Parameter struct { Kind *OperandKind Name string } // Quantifier indicates the number of times the quantified term may appear. type Quantifier string const ( // Once indicates the quantified term may appear exactly once. Once Quantifier = "" // ZeroOrOnce indicates the quantified term may appear zero or one // time; an optional term. ZeroOrOnce Quantifier = "?" // ZeroOrMany indicates the quantified term may appear any number of // times. ZeroOrMany Quantifier = "*" ) // OperandCategory is an enumerator that groups operand kinds. type OperandCategory string const ( // OperandCategoryBitEnum describes an operand kind where its value is a // mask, which is formed by combining the bits specified as enumerants in an // enum. OperandCategoryBitEnum = "BitEnum" // OperandCategoryValueEnum describes an operand kind where its value is an // enumerant from an enum. OperandCategoryValueEnum = "ValueEnum" // OperandCategoryID describes and operand kind where its value is an // definition or reference. OperandCategoryID = "Id" // OperandCategoryLiteral describes and operand kind where its value is an // literal number or string. OperandCategoryLiteral = "Literal" // OperandCategoryComposite describes and operand kind where its value is // composed from operand values from the above categories. OperandCategoryComposite = "Composite" ) // OpcodeMap is a map of opcode name to Opcode type. type OpcodeMap map[string]*Opcode var ( // Opcodes is a map of opcode name to Opcode description. Opcodes = OpcodeMap {•{{range $i := .SPIRV.Instructions}} "{{$i.Opname}}": {{Title $i.Opname}},{{end}} } // ExtOpcodes is a map of extension name to Opcode description list. ExtOpcodes = map[string]OpcodeMap {•{{range $ext := .Extensions}} "{{$ext.Name}}": {•{{range $i := $ext.Instructions}} "{{$i.Opname}}": {{Global $ext.Name}}_{{$i.Opname}},{{end}} },{{end}} } {{range $i := .SPIRV.Instructions}} {{Title $i.Opname}} = &Opcode { Opname: "{{$i.Opname}}", Class: "{{$i.Class}}", Opcode: {{$i.Opcode}}, Operands: []Operand {•{{range $i := $i.Operands}} Operand { Kind: OperandKind{{$i.Kind}}, Name: "{{Replace $i.Name "\n" " "}}", Quantifier: "{{$i.Quantifier}}", }, {{end}} }, } {{end}} {{range $ext := .Extensions}}{{range $i := $ext.Instructions}} {{Global $ext.Name}}_{{$i.Opname}} = &Opcode { Opname: "{{$i.Opname}}", Operands: []Operand {•{{range $i := $i.Operands}} Operand { Kind: OperandKind{{$i.Kind}}, Name: "{{Replace $i.Name "\n" " "}}", Quantifier: "{{$i.Quantifier}}", }, {{end}} }, } {{end}}{{end}} {{range $o := .All.OperandKinds}} OperandKind{{$o.Kind}} = &OperandKind { Kind: "{{$o.Kind}}", Category: "{{$o.Category}}", Enumerants: []Enumerant {•{{range $e := $o.Enumerants}} Enumerant{ Enumerant: "{{$e.Enumerant}}", Value: {{$e.Value}}, Capabilities: []string{•{{range $c := $e.Capabilities}}"{{$c}}",{{end}}•}, Parameters: []Parameter{•{{range $p := $e.Parameters}}{•OperandKind{{$p.Kind}}, "{{$p.Name}}"•},{{end}}•}, Version: "{{$e.Version}}", },{{end}} }, Bases: []*OperandKind {•{{range $b := $o.Bases}}OperandKind{{$b}},{{end}}•}, } {{end}} ) KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/src/tools/000077500000000000000000000000001475742701700231035ustar00rootroot00000000000000KhronosGroup-SPIRV-Tools-f289d04/utils/vscode/src/tools/gen-grammar.go000066400000000000000000000144701475742701700256350ustar00rootroot00000000000000// Copyright (C) 2019 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // gen-grammar generates the spirv.json grammar file from the official SPIR-V // grammar JSON file. package main import ( "bytes" "encoding/json" "flag" "fmt" "io/ioutil" "net/http" "os" "path/filepath" "runtime" "strings" "text/template" "github.com/pkg/errors" "github.com/KhronosGroup/SPIRV-Tools/utils/vscode/src/grammar" ) type grammarDefinition struct { name string url string } var ( spirvGrammar = grammarDefinition{ name: "SPIR-V", url: "https://raw.githubusercontent.com/KhronosGroup/SPIRV-Headers/master/include/spirv/unified1/spirv.core.grammar.json", } extensionGrammars = []grammarDefinition{ { name: "GLSL.std.450", url: "https://raw.githubusercontent.com/KhronosGroup/SPIRV-Headers/master/include/spirv/unified1/extinst.glsl.std.450.grammar.json", }, { name: "OpenCL.std", url: "https://raw.githubusercontent.com/KhronosGroup/SPIRV-Headers/master/include/spirv/unified1/extinst.opencl.std.100.grammar.json", }, { name: "OpenCL.DebugInfo.100", url: "https://raw.githubusercontent.com/KhronosGroup/SPIRV-Headers/master/include/spirv/unified1/extinst.opencl.debuginfo.100.grammar.json", }, } templatePath = flag.String("template", "", "Path to input template file (required)") outputPath = flag.String("out", "", "Path to output generated file (required)") cachePath = flag.String("cache", "", "Cache directory for downloaded files (optional)") thisDir = func() string { _, file, _, _ := runtime.Caller(1) return filepath.Dir(file) }() ) func main() { flag.Parse() if *templatePath == "" || *outputPath == "" { flag.Usage() os.Exit(1) } if err := run(); err != nil { fmt.Fprintln(os.Stderr, err) os.Exit(1) } } func run() error { tf, err := ioutil.ReadFile(*templatePath) if err != nil { return errors.Wrap(err, "Could not open template file") } type extension struct { grammar.Root Name string } args := struct { SPIRV grammar.Root Extensions []extension All grammar.Root // Combination of SPIRV + Extensions }{} if args.SPIRV, err = parseGrammar(spirvGrammar); err != nil { return errors.Wrap(err, "Failed to parse SPIR-V grammar file") } args.All.Instructions = append(args.All.Instructions, args.SPIRV.Instructions...) args.All.OperandKinds = append(args.All.OperandKinds, args.SPIRV.OperandKinds...) for _, ext := range extensionGrammars { root, err := parseGrammar(ext) if err != nil { return errors.Wrap(err, "Failed to parse extension grammar file: "+ext.name) } args.Extensions = append(args.Extensions, extension{Root: root, Name: ext.name}) args.All.Instructions = append(args.All.Instructions, root.Instructions...) args.All.OperandKinds = append(args.All.OperandKinds, root.OperandKinds...) } t, err := template.New("tmpl"). Funcs(template.FuncMap{ "GenerateArguments": func() string { relPath := func(path string) string { rel, err := filepath.Rel(thisDir, path) if err != nil { return path } return rel } escape := func(str string) string { return strings.ReplaceAll(str, `\`, `/`) } args := []string{ "--template=" + escape(relPath(*templatePath)), "--out=" + escape(relPath(*outputPath)), } return "gen-grammar.go " + strings.Join(args, " ") }, "OperandKindsMatch": func(k grammar.OperandKind) string { sb := strings.Builder{} for i, e := range k.Enumerants { if i > 0 { sb.WriteString("|") } sb.WriteString(e.Enumerant) } return sb.String() }, "AllExtOpcodes": func() string { sb := strings.Builder{} for _, ext := range args.Extensions { for _, inst := range ext.Root.Instructions { if sb.Len() > 0 { sb.WriteString("|") } sb.WriteString(inst.Opname) } } return sb.String() }, "Title": strings.Title, "Replace": strings.ReplaceAll, "Global": func(s string) string { return strings.ReplaceAll(strings.Title(s), ".", "") }, }).Parse(string(tf)) if err != nil { return errors.Wrap(err, "Failed to parse template") } buf := bytes.Buffer{} if err := t.Execute(&buf, args); err != nil { return errors.Wrap(err, "Failed to execute template") } out := buf.String() out = strings.ReplaceAll(out, "•", "") if err := ioutil.WriteFile(*outputPath, []byte(out), 0777); err != nil { return errors.Wrap(err, "Failed to write output file") } return nil } // parseGrammar downloads (or loads from the cache) the grammar file and returns // the parsed grammar.Root. func parseGrammar(def grammarDefinition) (grammar.Root, error) { file, err := getOrDownload(def.name, def.url) if err != nil { return grammar.Root{}, errors.Wrap(err, "Failed to load grammar file") } g := grammar.Root{} if err := json.NewDecoder(bytes.NewReader(file)).Decode(&g); err != nil { return grammar.Root{}, errors.Wrap(err, "Failed to parse grammar file") } return g, nil } // getOrDownload loads the specific file from the cache, or downloads the file // from the given url. func getOrDownload(name, url string) ([]byte, error) { if *cachePath != "" { if err := os.MkdirAll(*cachePath, 0777); err == nil { path := filepath.Join(*cachePath, name) if isFile(path) { return ioutil.ReadFile(path) } } } resp, err := http.Get(url) if err != nil { return nil, err } data, err := ioutil.ReadAll(resp.Body) if err != nil { return nil, err } if *cachePath != "" { ioutil.WriteFile(filepath.Join(*cachePath, name), data, 0777) } return data, nil } // isFile returns true if path is a file. func isFile(path string) bool { s, err := os.Stat(path) if err != nil { return false } return !s.IsDir() } // isDir returns true if path is a directory. func isDir(path string) bool { s, err := os.Stat(path) if err != nil { return false } return s.IsDir() }